diff --git a/.gitattributes b/.gitattributes
index 8989baade9679009d4f742e9f0ba83b3717885aa..ce8284918793368421bb9fbdc858fd1366bc66e2 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -120,3 +120,40 @@ ml-stable-diffusion/assets/mbp/a_high_quality_photo_of_a_surfing_dog.7667.final_
 ml-stable-diffusion/assets/mbp/a_high_quality_photo_of_a_surfing_dog.7667.final_float16_original.png filter=lfs diff=lfs merge=lfs -text
 ml-stable-diffusion/assets/palette6_cpuandne_readmereel.png filter=lfs diff=lfs merge=lfs -text
 ml-stable-diffusion/assets/readme_reel.png filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/compile.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/einsum.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/export.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/fast.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/load.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/linalg.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/primitives.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/random.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/transforms.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/libnanobind-static.a filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/docs/src/_static/metal_debugger/capture.png filter=lfs diff=lfs merge=lfs -text
+ml-stable-diffusion/mlx/docs/src/_static/metal_debugger/schema.png filter=lfs diff=lfs merge=lfs -text
diff --git a/ml-stable-diffusion/mlx/.circleci/config.yml b/ml-stable-diffusion/mlx/.circleci/config.yml
new file mode 100644
index 0000000000000000000000000000000000000000..a953db52a7b9c927b1f5a1fb97d061db616a3c8b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/.circleci/config.yml
@@ -0,0 +1,579 @@
+version: 2.1
+
+orbs:
+  apple: ml-explore/pr-approval@0.1.0
+
+parameters:
+  nightly_build:
+    type: boolean
+    default: false
+  test_release:
+    type: boolean
+    default: false
+
+jobs:
+  build_documentation:
+    parameters:
+      upload-docs:
+        type: boolean
+        default: false
+    macos:
+      xcode: "26.0.0"
+    resource_class: m4pro.medium
+    steps:
+      - checkout
+      - run:
+          name: Install
+          command: |
+            xcodebuild -downloadComponent MetalToolchain
+            brew install python@3.9
+            brew install doxygen
+            python3.9 -m venv env
+            source env/bin/activate
+            pip install --upgrade pip
+            pip install --upgrade cmake
+            pip install -r docs/requirements.txt
+            pip install . -v
+      - when:
+          condition:
+            not: << parameters.upload-docs >>
+          steps:
+            - run:
+               name: Build documentation
+               command: |
+                 source env/bin/activate
+                 cd docs && doxygen && make html O=-W
+      - when:
+          condition: << parameters.upload-docs >>
+          steps:
+            - add_ssh_keys:
+                fingerprints:
+                  - "SHA256:OhcVVMovbT0pkgMeiVRyxMnjV9R2t+hKBsNcuxq9h+0"
+            - run:
+               name: Upload documentation
+               command: |
+                 source env/bin/activate
+                 git config user.email "mlx@group.apple.com"
+                 git config user.name "CircleCI Docs"
+                 git checkout gh-pages
+                 git rebase main
+                 cd docs
+                 git rm -rf build/html
+                 doxygen && make html O=-W
+                 git add -f build/html
+                 git commit -m "rebase"
+                 git push -f origin gh-pages
+
+  linux_build_and_test:
+    machine:
+      image: ubuntu-2204:current
+      resource_class: large
+    steps:
+      - checkout
+      - run:
+          name: Run style checks
+          command: |
+            pip install pre-commit
+            pre-commit run --all
+            if ! git diff --quiet; then echo 'Style checks failed, please install pre-commit and run pre-commit run --all and push the change'; exit 1; fi
+      - run:
+          name: Install dependencies
+          command: |
+            export DEBIAN_FRONTEND=noninteractive
+            export NEEDRESTART_MODE=a
+            sudo apt-get update
+            sudo apt-get install -y libblas-dev liblapack-dev liblapacke-dev
+            sudo apt-get install openmpi-bin openmpi-common libopenmpi-dev
+            curl -LsSf https://astral.sh/uv/install.sh | sh
+      - run:
+          name: Install Python package
+          command: |
+            uv venv
+            uv pip install cmake
+            DEBUG=1 CMAKE_ARGS="-DCMAKE_COMPILE_WARNING_AS_ERROR=ON" \
+              uv pip install -e ".[dev]" -v
+      - run:
+          name: Generate package stubs
+          command: |
+            uv pip install typing_extensions
+            uv run --no-project setup.py generate_stubs
+      - run:
+          name: Run Python tests
+          command: |
+            source .venv/bin/activate
+            python -m unittest discover python/tests -v
+            mpirun --bind-to none -host localhost:8 -np 8 python python/tests/mpi_test_distributed.py
+            mlx.launch --verbose -n 8 python/tests/ring_test_distributed.py -v 2> >(tee -a stderr.log >&2)
+            if $(grep "\[WARN\]" stderr.log); then echo "Distributed ring test failed"; exit 1; fi
+      - run:
+          name: Build CPP only
+          command: |
+            source .venv/bin/activate
+            mkdir -p build && cd build
+            cmake .. -DMLX_BUILD_METAL=OFF -DCMAKE_BUILD_TYPE=DEBUG
+            make -j `nproc`
+      - run:
+          name: Run CPP tests
+          command: ./build/tests/tests
+
+  mac_build_and_test:
+    parameters:
+      xcode_version:
+        type: string
+        default: "26.0.0"
+      macosx_deployment_target:
+        type: string
+        default: ""
+    macos:
+      xcode: << parameters.xcode_version >>
+    environment:
+      MACOSX_DEPLOYMENT_TARGET: << parameters.macosx_deployment_target >>
+    resource_class: m4pro.medium
+    steps:
+      - checkout
+      - run:
+          name: Install dependencies
+          command: |
+            xcodebuild -downloadComponent MetalToolchain
+            HOMEBREW_NO_AUTO_UPDATE=1 HOMEBREW_NO_INSTALL_CLEANUP=1 \
+              brew install openmpi uv
+      - run:
+          name: Install Python package
+          command: |
+            uv venv --python 3.9
+            uv pip install \
+              nanobind==2.4.0 \
+              cmake \
+              numpy \
+              torch \
+              tensorflow \
+              unittest-xml-reporting
+            DEBUG=1 CMAKE_ARGS="-DCMAKE_COMPILE_WARNING_AS_ERROR=ON" \
+              uv pip install -e . -v
+      - run:
+          name: Generate package stubs
+          command: |
+            uv pip install typing_extensions
+            uv run --no-project setup.py generate_stubs
+      - run:
+          name: Run Python tests
+          command: |
+            source .venv/bin/activate
+            LOW_MEMORY=1 DEVICE=cpu python -m xmlrunner discover -v python/tests -o test-results/cpu
+            LOW_MEMORY=1 DEVICE=gpu METAL_DEVICE_WRAPPER_TYPE=1 METAL_DEBUG_ERROR_MODE=0 python -m xmlrunner discover -v python/tests -o test-results/gpu
+            mpirun --bind-to none -host localhost:8 -np 8 -x DYLD_LIBRARY_PATH=/opt/homebrew/lib/ python python/tests/mpi_test_distributed.py
+            mlx.launch --verbose -n 8 python/tests/ring_test_distributed.py -v 2> >(tee -a stderr.log >&2)
+            if $(grep "\[WARN\]" stderr.log); then echo "Distributed ring test failed"; exit 1; fi
+      - run:
+          name: Build example extension
+          command: |
+            source .venv/bin/activate
+            cd examples/extensions
+            uv pip install -r requirements.txt
+            uv run --no-project setup.py build_ext --inplace
+            uv run --no-project python test.py
+      - store_test_results:
+          path: test-results
+      - run:
+          name: Build CPP only
+          command: |
+            source .venv/bin/activate
+            mkdir -p build && cd build && cmake .. && make -j `sysctl -n hw.ncpu`
+      - run:
+          name: Run CPP tests
+          command: |
+            DEVICE=gpu METAL_DEVICE_WRAPPER_TYPE=1 METAL_DEBUG_ERROR_MODE=0 ./build/tests/tests
+      - run:
+          name: Build small binary
+          command: |
+            source .venv/bin/activate
+            cd build/
+            cmake .. -DCMAKE_BUILD_TYPE=MinSizeRel \
+              -DBUILD_SHARED_LIBS=ON \
+              -DMLX_BUILD_CPU=OFF \
+              -DMLX_BUILD_SAFETENSORS=OFF \
+              -DMLX_BUILD_GGUF=OFF \
+              -DMLX_METAL_JIT=ON
+            make -j `sysctl -n hw.ncpu`
+      - run:
+          name: Run Python tests with JIT
+          command: |
+            CMAKE_ARGS="-DMLX_METAL_JIT=ON" \
+              uv pip install -e . -v
+            LOW_MEMORY=1 DEVICE=gpu METAL_DEVICE_WRAPPER_TYPE=1 \
+              METAL_DEBUG_ERROR_MODE=0 \
+              uv run --no-project python -m xmlrunner discover \
+                -v python/tests \
+                -o test-results/gpu_jit
+
+  cuda_build_and_test:
+    parameters:
+      image_date:
+        type: string
+        default: "2023.11.1"
+    machine:
+      image: "linux-cuda-12:<< parameters.image_date >>"
+      resource_class: gpu.nvidia.small.gen2
+    steps:
+      - checkout
+      - restore_cache:
+          keys:
+            - cuda-<< parameters.image_date >>-{{ arch }}-
+      - run:
+          name: Install dependencies
+          command: |
+            sudo apt-get update
+            sudo apt-get install libcudnn9-dev-cuda-12
+            sudo apt-get install libblas-dev liblapack-dev liblapacke-dev
+            sudo apt-get install libnccl2 libnccl-dev
+            curl -sL https://github.com/ccache/ccache/releases/download/v4.11.3/ccache-4.11.3-linux-x86_64.tar.xz | tar xJf -
+            sudo mv ccache-4.11.3-linux-x86_64/ccache /usr/bin/ccache
+            rm -rf ccache-4.11.3-linux-x86_64
+            curl -LsSf https://astral.sh/uv/install.sh | sh
+      - run:
+          name: Set CCache size
+          command: ccache --max-size 1G
+      - run:
+          name: Install Python package
+          command: |
+            uv venv
+            uv pip install cmake
+            DEBUG=1 CMAKE_ARGS="-DMLX_BUILD_CUDA=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DCMAKE_CUDA_COMPILER=`which nvcc`" \
+              uv pip install -e ".[dev]" -v
+      - run:
+          name: Run Python tests
+          command: |
+            source .venv/bin/activate
+            LOW_MEMORY=1 DEVICE=cpu python -m unittest discover python/tests -v
+            LOW_MEMORY=1 DEVICE=gpu python -m tests discover python/tests -v
+      - run:
+          name: Build CPP only
+          command: |
+            source .venv/bin/activate
+            cmake . -B build \
+              -DMLX_BUILD_CUDA=ON \
+              -DCMAKE_CUDA_COMPILER=`which nvcc` \
+              -DCMAKE_BUILD_TYPE=DEBUG
+            cmake --build build -j `nproc`
+      - run:
+          name: Run CPP tests
+          command: ./build/tests/tests -sfe="*fft_tests.cpp,*linalg_tests.cpp"
+      - run:
+          name: CCache report
+          command: |
+            ccache --show-stats
+            ccache --zero-stats
+            ccache --cleanup
+      - save_cache:
+          key: cuda-<< parameters.image_date >>-{{ arch }}-{{ epoch }}
+          paths:
+            - /home/circleci/.cache/ccache
+
+  build_release:
+    parameters:
+      python_version:
+        type: string
+        default: "3.9"
+      xcode_version:
+        type: string
+        default: "26.0.0"
+      build_env:
+        type: string
+        default: ""
+      macosx_deployment_target:
+        type: string
+        default: ""
+    macos:
+      xcode: << parameters.xcode_version >>
+    resource_class: m4pro.medium
+    environment:
+      MACOSX_DEPLOYMENT_TARGET: << parameters.macosx_deployment_target >>
+    steps:
+      - checkout
+      - run:
+          name: Install dependencies
+          command: |
+            xcodebuild -downloadComponent MetalToolchain
+            mkdir -p ~/miniconda3
+            curl https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh -o ~/miniconda3/miniconda.sh
+            bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
+            rm ~/miniconda3/miniconda.sh
+            source ~/miniconda3/bin/activate
+            conda init --all
+            conda create -n env python=<< parameters.python_version >> -y
+            conda activate env
+            pip install --upgrade cmake
+            pip install nanobind==2.4.0
+            pip install --upgrade setuptools
+            pip install numpy
+            pip install twine
+            pip install build
+      - run:
+          name: Install Python package
+          command: |
+            conda activate env
+            env -u MACOSX_DEPLOYMENT_TARGET DEV_RELEASE=1 \
+              pip install . -v
+      - run:
+          name: Generate package stubs
+          command: |
+            conda activate env
+            pip install typing_extensions
+            python setup.py generate_stubs
+      - run:
+          name: Build Python package
+          command: |
+            conda activate env
+            python setup.py clean --all
+            << parameters.build_env >> MLX_BUILD_STAGE=1 python -m build -w
+      - when:
+          condition:
+            equal: ["3.9", << parameters.python_version >>]
+          steps:
+            - run:
+                name: Build common package
+                command: |
+                  conda activate env
+                  python setup.py clean --all
+                  << parameters.build_env >> MLX_BUILD_STAGE=2 python -m build -w
+      - when:
+          condition: << parameters.build_env >>
+          steps:
+            - run:
+                name: Upload package
+                command: |
+                  conda activate env
+                  twine upload dist/*
+      - store_artifacts:
+          path: dist/
+
+  build_linux_release:
+    parameters:
+      python_version:
+        type: string
+        default: "3.9"
+      build_env:
+        type: string
+        default: ""
+    machine:
+      image: ubuntu-2204:current
+      resource_class: large
+    steps:
+      - checkout
+      - run:
+          name: Build wheel
+          command: |
+            PYTHON=python<< parameters.python_version >>
+            export DEBIAN_FRONTEND=noninteractive
+            export NEEDRESTART_MODE=a
+            sudo apt-get update
+            TZ=Etc/UTC sudo apt-get -y install tzdata
+            sudo add-apt-repository -y ppa:deadsnakes/ppa
+            sudo apt-get install -y $PYTHON $PYTHON-dev $PYTHON-full
+            sudo apt-get install -y libblas-dev liblapack-dev liblapacke-dev
+            $PYTHON -m venv env
+            source env/bin/activate
+            pip install --upgrade pip
+            pip install --upgrade cmake
+            pip install auditwheel
+            pip install patchelf
+            pip install build
+            pip install twine
+            << parameters.build_env >> pip install ".[dev]" -v
+            pip install typing_extensions
+            python setup.py generate_stubs
+            python setup.py clean --all
+            MLX_BUILD_STAGE=1 << parameters.build_env >> python -m build -w
+            bash python/scripts/repair_linux.sh
+      - when:
+          condition:
+            equal: ["3.9", << parameters.python_version >>]
+          steps:
+            - run:
+                name: Build common package
+                command: |
+                  source env/bin/activate
+                  python setup.py clean --all
+                  << parameters.build_env >> MLX_BUILD_STAGE=2 \
+                    python -m build -w
+                  auditwheel repair dist/mlx_cpu*.whl --plat manylinux_2_35_x86_64
+      - when:
+          condition: << parameters.build_env >>
+          steps:
+            - run:
+                name: Upload packages
+                command: |
+                  source env/bin/activate
+                  twine upload wheelhouse/*.whl
+      - store_artifacts:
+          path: wheelhouse/
+
+  build_cuda_release:
+    parameters:
+      build_env:
+        type: string
+        default: ""
+    machine:
+      image: ubuntu-2204:current
+      resource_class: xlarge
+    steps:
+      - checkout
+      - run:
+          name: Build wheel
+          command: |
+            export DEBIAN_FRONTEND=noninteractive
+            export NEEDRESTART_MODE=a
+            wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
+            sudo dpkg -i cuda-keyring_1.1-1_all.deb
+            sudo apt-get update
+            sudo apt-get install cuda-toolkit-12-9 libcudnn9-dev-cuda-12
+            sudo apt-get install libblas-dev liblapack-dev liblapacke-dev
+            sudo apt-get install zip
+            pip install auditwheel
+            pip install patchelf
+            pip install build
+            pip install twine
+            export PATH=/usr/local/cuda/bin${PATH:+:${PATH}}
+            export LD_LIBRARY_PATH=/usr/local/cuda/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}
+            << parameters.build_env >> MLX_BUILD_STAGE=2 \
+              CMAKE_ARGS="-DMLX_BUILD_CUDA=ON -DCMAKE_CUDA_COMPILER=`which nvcc`" \
+              python -m build -w
+            bash python/scripts/repair_cuda.sh
+      - when:
+          condition: << parameters.build_env >>
+          steps:
+            - run:
+                name: Upload package
+                command: |
+                  twine upload wheelhouse/*.whl
+      - store_artifacts:
+          path: wheelhouse/
+
+workflows:
+  build_and_test:
+    when:
+      and:
+        - matches:
+            pattern: "^(?!pull/)[-\\w]+$"
+            value: << pipeline.git.branch >>
+        - not: << pipeline.parameters.nightly_build >>
+        - not: << pipeline.parameters.test_release >>
+    jobs:
+      - mac_build_and_test:
+          matrix:
+            parameters:
+              macosx_deployment_target: ["13.5", "15.0"]
+      - linux_build_and_test
+      - cuda_build_and_test:
+          matrix:
+            parameters:
+              image_date: ["2023.11.1", "2025.05.1"]
+      - build_documentation 
+
+  build_pypi_release:
+    when:
+      and:
+        - not: << pipeline.parameters.nightly_build >>
+        - not: << pipeline.parameters.test_release >>
+    jobs:
+      - build_release:
+          filters:
+            tags:
+              only: /^v.*/
+            branches:
+              ignore: /.*/
+          matrix:
+            parameters:
+              python_version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+              macosx_deployment_target: ["13.5", "14.0", "15.0"]
+              build_env: ["PYPI_RELEASE=1"]
+              xcode_version: ["26.0.0"]
+      - build_documentation:
+          filters:
+            tags:
+              only: /^v.*/
+            branches:
+              ignore: /.*/
+          upload-docs: true
+      - build_linux_release:
+          filters:
+            tags:
+              only: /^v.*/
+            branches:
+              ignore: /.*/
+          matrix:
+            parameters:
+              python_version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+              build_env: ["PYPI_RELEASE=1"]
+      - build_cuda_release:
+          filters:
+            tags:
+              only: /^v.*/
+            branches:
+              ignore: /.*/
+          matrix:
+            parameters:
+              build_env: ["PYPI_RELEASE=1"]
+
+  prb:
+    when:
+      matches:
+        pattern: "^pull/\\d+(/head)?$"
+        value: << pipeline.git.branch >>
+    jobs:
+      - hold:
+          type: approval
+      - apple/authenticate:
+          context: pr-approval
+      - mac_build_and_test:
+          requires: [ hold ]
+          matrix:
+            parameters:
+              macosx_deployment_target: ["13.5", "15.0"]
+      - linux_build_and_test:
+          requires: [ hold ]
+      - cuda_build_and_test:
+          requires: [ hold ]
+          matrix:
+            parameters:
+              image_date: ["2023.11.1", "2025.05.1"]
+  nightly_build:
+    when:
+      and:
+        - equal: [ main, << pipeline.git.branch >> ]
+        - << pipeline.parameters.nightly_build >>
+    jobs:
+      - build_release:
+          matrix:
+            parameters:
+              python_version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+              macosx_deployment_target: ["13.5", "14.0", "15.0"]
+              xcode_version: ["26.0.0"]
+      - build_linux_release:
+          matrix:
+            parameters:
+              python_version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+      - build_cuda_release
+
+  build_dev_release:
+    when:
+      and:
+        - equal: [ main, << pipeline.git.branch >> ]
+        - << pipeline.parameters.test_release >>
+    jobs:
+      - build_release:
+          matrix:
+            parameters:
+              python_version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+              macosx_deployment_target: ["13.5", "14.0", "15.0"]
+              build_env: ["DEV_RELEASE=1"]
+              xcode_version: ["26.0.0"]
+      - build_linux_release:
+          matrix:
+            parameters:
+              python_version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+              build_env: ["DEV_RELEASE=1"]
+      - build_cuda_release:
+          matrix:
+            parameters:
+              build_env: ["DEV_RELEASE=1"]
diff --git a/ml-stable-diffusion/mlx/.clang-format b/ml-stable-diffusion/mlx/.clang-format
new file mode 100644
index 0000000000000000000000000000000000000000..eab4576fe09a53b1c71603d923bc3431367f3b9a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/.clang-format
@@ -0,0 +1,87 @@
+---
+AccessModifierOffset: -1
+AlignAfterOpenBracket: AlwaysBreak
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlinesLeft: true
+AlignOperands:   false
+AlignTrailingComments: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: false
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ForEachMacros:   [ FOR_EACH, FOR_EACH_R, FOR_EACH_RANGE, ]
+IncludeCategories:
+  - Regex:           '^<.*\.h(pp)?>'
+    Priority:        1
+  - Regex:           '^<.*'
+    Priority:        2
+  - Regex:           '.*'
+    Priority:        3
+IndentCaseLabels: true
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+ReflowComments:  true
+SortIncludes:    true
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        8
+UseTab:          Never
+...
diff --git a/ml-stable-diffusion/mlx/.github/ISSUE_TEMPLATE/bug_report.md b/ml-stable-diffusion/mlx/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000000000000000000000000000000000000..22a0857923f2f256b5ce317c0b211211a818d6ed
--- /dev/null
+++ b/ml-stable-diffusion/mlx/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,28 @@
+---
+name: Bug report
+about: Create a report about an issue you've encountered
+title: "[BUG] "
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+
+Include code snippet
+```python
+
+```
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Desktop (please complete the following information):**
+ - OS Version: [e.g. MacOS 14.1.2]
+ - Version [e.g. 0.7.0]
+
+**Additional context**
+Add any other context about the problem here.
diff --git a/ml-stable-diffusion/mlx/.github/pull_request_template.md b/ml-stable-diffusion/mlx/.github/pull_request_template.md
new file mode 100644
index 0000000000000000000000000000000000000000..02bb9b79a944b161056ac823fdaa92a5a28ef817
--- /dev/null
+++ b/ml-stable-diffusion/mlx/.github/pull_request_template.md
@@ -0,0 +1,12 @@
+## Proposed changes
+
+Please include a description of the problem or feature this PR is addressing. If there is a corresponding issue, include the issue #.
+
+## Checklist
+
+Put an `x` in the boxes that apply.
+
+- [ ] I have read the [CONTRIBUTING](https://github.com/ml-explore/mlx/blob/main/CONTRIBUTING.md) document
+- [ ] I have run `pre-commit run --all-files` to format my code / installed pre-commit prior to committing changes
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] I have updated the necessary documentation (if needed)
diff --git a/ml-stable-diffusion/mlx/.github/workflows/pull_request.yml b/ml-stable-diffusion/mlx/.github/workflows/pull_request.yml
new file mode 100644
index 0000000000000000000000000000000000000000..7a03796e1b845c051f3ff61404bfc384fb12ce37
--- /dev/null
+++ b/ml-stable-diffusion/mlx/.github/workflows/pull_request.yml
@@ -0,0 +1,20 @@
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  check_lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: 3.8
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pre-commit black isort clang-format
+      - name: Run lint
+        run: |
+          pre-commit run --all-files
diff --git a/ml-stable-diffusion/mlx/.gitignore b/ml-stable-diffusion/mlx/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..43629548dbdb1ce9e34bd07ee9a4089f0bcc6e53
--- /dev/null
+++ b/ml-stable-diffusion/mlx/.gitignore
@@ -0,0 +1,88 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# tensor files
+*.safe
+*.safetensors
+
+# Metal libraries
+*.metallib
+venv/
+
+# Distribution / packaging
+python/mlx/core
+python/mlx/share
+python/mlx/include
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+uv.lock
+
+# vim
+*.swp
+
+# Ignore build dir
+build/
+
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# Debug symbols
+*.pdb
+
+# VSCode 
+.vscode/
+.DS_Store
+
+# Jetbrains
+.cache
diff --git a/ml-stable-diffusion/mlx/.pre-commit-config.yaml b/ml-stable-diffusion/mlx/.pre-commit-config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..255ea894e9190e4b575a2dd9f5fb6204c5156fff
--- /dev/null
+++ b/ml-stable-diffusion/mlx/.pre-commit-config.yaml
@@ -0,0 +1,21 @@
+repos:
+-   repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: v19.1.7
+    hooks:
+    -   id: clang-format
+# Using this mirror lets us use mypyc-compiled black, which is about 2x faster
+-   repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 25.1.0
+    hooks:
+    -   id: black
+    
+-   repo: https://github.com/pycqa/isort
+    rev: 6.0.0
+    hooks:
+    -   id: isort
+        args:
+            - --profile=black
+- repo: https://github.com/cheshirekow/cmake-format-precommit
+  rev: v0.6.13
+  hooks:
+    - id: cmake-format
diff --git a/ml-stable-diffusion/mlx/ACKNOWLEDGMENTS.md b/ml-stable-diffusion/mlx/ACKNOWLEDGMENTS.md
new file mode 100644
index 0000000000000000000000000000000000000000..186908f09c1b8829366130ad316b895063fb4f6a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/ACKNOWLEDGMENTS.md
@@ -0,0 +1,268 @@
+# Individual Contributors
+
+If you wish to be acknowledged for your contributions, please list your name
+with a short description of your contribution(s) below. For example:
+
+- Jane Smith: Added the `foo` and `bar` ops.
+
+MLX was developed with contributions from the following individuals:
+
+- Nripesh Niketan: Added `softsign`, `softmax`, `hardswish`, `logsoftmax` activation functions. Added `dropout3d` ops. Added `LogicalAnd` and `LogicalOR` ops. Added `clip_grad_norm` along with `tree_reduce`. Added `cross`. Added `orthogonal` initializer.
+- Juarez Bochi: Fixed bug in cross attention.
+- Justin Deschenaux: Sine, Cosine, arange, randint, truncated normal, bernoulli, lion optimizer, Dropout2d, linear and logistic regression python example.
+- Diogo Da Cruz: Added `tri`, `tril`, `triu`, `tensordot`, `inner`, `outer`, `tile`, `StreamContext`, `stream`, safetensors support, `einsum`, and `einsum_path`.
+- Gabrijel Boduljak: Added `mlx.core.linalg`, implemented `norm` method and `InstanceNorm` layer. Implemented pooling layers and ``Upsample``.
+- Hinrik Snær Guðmundsson: Added `atleast_1d`, `atleast_2d`, `atleast_3d` ops.
+- Luca Arnaboldi: Added `Ceil` and `Floor` ops; implemented pickling, copy and deepcopy for mlx arrays.
+- Brian Keene & Atila Orhon, with Argmax Inc.: Added `fast.scaled_dot_product_attention`
+- AmirHossein Razlighi: Added chaining support for some of the ops in `nn.Module`. Comparison works for non array objects in `mlx.core.array`. Exception handling for invalid operations in `mlx.core.array`.
+- Gleb Pobudzey: Added the `where` primitive, and groups in 1D and 2D convolutions.
+- Paul Paczuski: Improved stability of BCE loss calculation
+- Max-Heinrich Laves: Added `conv_transpose1d`, `conv_transpose2d`, and `conv_transpose3d` ops.
+- Gökdeniz Gülmez: Added the `Muon (MomentUm Orthogonalized by Newton-schulz)` optimizer, and the `ReLU²` activation function.
+
+<a href="https://github.com/ml-explore/mlx/graphs/contributors">
+  <img class="dark-light" src="https://contrib.rocks/image?repo=ml-explore/mlx&anon=0&columns=20&max=100&r=true" />
+</a>
+
+# Organizations
+
+MLX has received contributions from the following companies:
+- NVIDIA Corporation & Affiliates
+
+# Third-Party Software
+
+MLX leverages several third-party software, listed here together with
+their license copied verbatim.
+
+## PocketFFT
+
+Copyright (C) 2010-2018 Max-Planck-Society
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+* Neither the name of the copyright holder nor the names of its contributors may
+  be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+## metal-cpp
+
+                              Apache License
+                        Version 2.0, January 2004
+                    http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+  "License" shall mean the terms and conditions for use, reproduction,
+  and distribution as defined by Sections 1 through 9 of this document.
+
+  "Licensor" shall mean the copyright owner or entity authorized by
+  the copyright owner that is granting the License.
+
+  "Legal Entity" shall mean the union of the acting entity and all
+  other entities that control, are controlled by, or are under common
+  control with that entity. For the purposes of this definition,
+  "control" means (i) the power, direct or indirect, to cause the
+  direction or management of such entity, whether by contract or
+  otherwise, or (ii) ownership of fifty percent (50%) or more of the
+  outstanding shares, or (iii) beneficial ownership of such entity.
+
+  "You" (or "Your") shall mean an individual or Legal Entity
+  exercising permissions granted by this License.
+
+  "Source" form shall mean the preferred form for making modifications,
+  including but not limited to software source code, documentation
+  source, and configuration files.
+
+  "Object" form shall mean any form resulting from mechanical
+  transformation or translation of a Source form, including but
+  not limited to compiled object code, generated documentation,
+  and conversions to other media types.
+
+  "Work" shall mean the work of authorship, whether in Source or
+  Object form, made available under the License, as indicated by a
+  copyright notice that is included in or attached to the work
+  (an example is provided in the Appendix below).
+
+  "Derivative Works" shall mean any work, whether in Source or Object
+  form, that is based on (or derived from) the Work and for which the
+  editorial revisions, annotations, elaborations, or other modifications
+  represent, as a whole, an original work of authorship. For the purposes
+  of this License, Derivative Works shall not include works that remain
+  separable from, or merely link (or bind by name) to the interfaces of,
+  the Work and Derivative Works thereof.
+
+  "Contribution" shall mean any work of authorship, including
+  the original version of the Work and any modifications or additions
+  to that Work or Derivative Works thereof, that is intentionally
+  submitted to Licensor for inclusion in the Work by the copyright owner
+  or by an individual or Legal Entity authorized to submit on behalf of
+  the copyright owner. For the purposes of this definition, "submitted"
+  means any form of electronic, verbal, or written communication sent
+  to the Licensor or its representatives, including but not limited to
+  communication on electronic mailing lists, source code control systems,
+  and issue tracking systems that are managed by, or on behalf of, the
+  Licensor for the purpose of discussing and improving the Work, but
+  excluding communication that is conspicuously marked or otherwise
+  designated in writing by the copyright owner as "Not a Contribution."
+
+  "Contributor" shall mean Licensor and any individual or Legal Entity
+  on behalf of whom a Contribution has been received by Licensor and
+  subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  copyright license to reproduce, prepare Derivative Works of,
+  publicly display, publicly perform, sublicense, and distribute the
+  Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  (except as stated in this section) patent license to make, have made,
+  use, offer to sell, sell, import, and otherwise transfer the Work,
+  where such license applies only to those patent claims licensable
+  by such Contributor that are necessarily infringed by their
+  Contribution(s) alone or by combination of their Contribution(s)
+  with the Work to which such Contribution(s) was submitted. If You
+  institute patent litigation against any entity (including a
+  cross-claim or counterclaim in a lawsuit) alleging that the Work
+  or a Contribution incorporated within the Work constitutes direct
+  or contributory patent infringement, then any patent licenses
+  granted to You under this License for that Work shall terminate
+  as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+  Work or Derivative Works thereof in any medium, with or without
+  modifications, and in Source or Object form, provided that You
+  meet the following conditions:
+
+  (a) You must give any other recipients of the Work or
+      Derivative Works a copy of this License; and
+
+  (b) You must cause any modified files to carry prominent notices
+      stating that You changed the files; and
+
+  (c) You must retain, in the Source form of any Derivative Works
+      that You distribute, all copyright, patent, trademark, and
+      attribution notices from the Source form of the Work,
+      excluding those notices that do not pertain to any part of
+      the Derivative Works; and
+
+  (d) If the Work includes a "NOTICE" text file as part of its
+      distribution, then any Derivative Works that You distribute must
+      include a readable copy of the attribution notices contained
+      within such NOTICE file, excluding those notices that do not
+      pertain to any part of the Derivative Works, in at least one
+      of the following places: within a NOTICE text file distributed
+      as part of the Derivative Works; within the Source form or
+      documentation, if provided along with the Derivative Works; or,
+      within a display generated by the Derivative Works, if and
+      wherever such third-party notices normally appear. The contents
+      of the NOTICE file are for informational purposes only and
+      do not modify the License. You may add Your own attribution
+      notices within Derivative Works that You distribute, alongside
+      or as an addendum to the NOTICE text from the Work, provided
+      that such additional attribution notices cannot be construed
+      as modifying the License.
+
+  You may add Your own copyright statement to Your modifications and
+  may provide additional or different license terms and conditions
+  for use, reproduction, or distribution of Your modifications, or
+  for any such Derivative Works as a whole, provided Your use,
+  reproduction, and distribution of the Work otherwise complies with
+  the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+  any Contribution intentionally submitted for inclusion in the Work
+  by You to the Licensor shall be under the terms and conditions of
+  this License, without any additional terms or conditions.
+  Notwithstanding the above, nothing herein shall supersede or modify
+  the terms of any separate license agreement you may have executed
+  with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+  names, trademarks, service marks, or product names of the Licensor,
+  except as required for reasonable and customary use in describing the
+  origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+  agreed to in writing, Licensor provides the Work (and each
+  Contributor provides its Contributions) on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied, including, without limitation, any warranties or conditions
+  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+  PARTICULAR PURPOSE. You are solely responsible for determining the
+  appropriateness of using or redistributing the Work and assume any
+  risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+  whether in tort (including negligence), contract, or otherwise,
+  unless required by applicable law (such as deliberate and grossly
+  negligent acts) or agreed to in writing, shall any Contributor be
+  liable to You for damages, including any direct, indirect, special,
+  incidental, or consequential damages of any character arising as a
+  result of this License or out of the use or inability to use the
+  Work (including but not limited to damages for loss of goodwill,
+  work stoppage, computer failure or malfunction, or any and all
+  other commercial damages or losses), even if such Contributor
+  has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+  the Work or Derivative Works thereof, You may choose to offer,
+  and charge a fee for, acceptance of support, warranty, indemnity,
+  or other liability obligations and/or rights consistent with this
+  License. However, in accepting such obligations, You may act only
+  on Your own behalf and on Your sole responsibility, not on behalf
+  of any other Contributor, and only if You agree to indemnify,
+  defend, and hold each Contributor harmless for any liability
+  incurred by, or claims asserted against, such Contributor by reason
+  of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+  To apply the Apache License to your work, attach the following
+  boilerplate notice, with the fields enclosed by brackets "[]"
+  replaced with your own identifying information. (Don't include
+  the brackets!)  The text should be enclosed in the appropriate
+  comment syntax for the file format. We also recommend that a
+  file or class name and description of purpose be included on the
+  same "printed page" as the copyright notice for easier
+  identification within third-party archives.
+
+Copyright © 2023 Apple Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/ml-stable-diffusion/mlx/CITATION.cff b/ml-stable-diffusion/mlx/CITATION.cff
new file mode 100644
index 0000000000000000000000000000000000000000..ef4168f43ace5ae63a5fd18f8218de895525a3d6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/CITATION.cff
@@ -0,0 +1,24 @@
+cff-version: 1.2.0
+title: mlx
+message: >-
+  If you use this software, please cite it using the
+  metadata from this file.
+type: software
+authors:
+  - given-names: Awni
+    family-names: Hannun
+    affiliation: Apple
+  - given-names: Jagrit
+    family-names: Digani
+    affiliation: Apple
+  - given-names: Angelos
+    family-names: Katharopoulos
+    affiliation: Apple
+  - given-names: Ronan
+    family-names: Collobert
+    affiliation: Apple
+repository-code: 'https://github.com/ml-explore'
+abstract: >-
+  MLX: efficient and flexible machine learning on Apple
+  silicon
+license: MIT
diff --git a/ml-stable-diffusion/mlx/CMakeLists.txt b/ml-stable-diffusion/mlx/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..84d4198baff806d24935023a3a4f8dd253d2ffe1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/CMakeLists.txt
@@ -0,0 +1,353 @@
+cmake_minimum_required(VERSION 3.25)
+
+if(NOT MLX_VERSION)
+  file(STRINGS "mlx/version.h" _mlx_h_version REGEX "^#define MLX_VERSION_.*$")
+  string(REGEX MATCH "#define MLX_VERSION_MAJOR ([0-9]+)" _ "${_mlx_h_version}")
+  set(_major ${CMAKE_MATCH_1})
+  string(REGEX MATCH "#define MLX_VERSION_MINOR ([0-9]+)" _ "${_mlx_h_version}")
+  set(_minor ${CMAKE_MATCH_1})
+  string(REGEX MATCH "#define MLX_VERSION_PATCH ([0-9]+)" _ "${_mlx_h_version}")
+  set(_patch ${CMAKE_MATCH_1})
+  set(MLX_PROJECT_VERSION "${_major}.${_minor}.${_patch}")
+  set(MLX_VERSION ${MLX_PROJECT_VERSION})
+else()
+  string(REGEX REPLACE "^([0-9]+\.[0-9]+\.[0-9]+).*" "\\1" MLX_PROJECT_VERSION
+                       ${MLX_VERSION})
+endif()
+
+project(
+  mlx
+  LANGUAGES C CXX
+  VERSION ${MLX_PROJECT_VERSION})
+
+# ----------------------------- Setup -----------------------------
+set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(CMAKE_INSTALL_MESSAGE NEVER)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# ----------------------------- Configuration -----------------------------
+option(MLX_BUILD_TESTS "Build tests for mlx" ON)
+option(MLX_BUILD_EXAMPLES "Build examples for mlx" ON)
+option(MLX_BUILD_BENCHMARKS "Build benchmarks for mlx" OFF)
+option(MLX_BUILD_PYTHON_BINDINGS "Build python bindings for mlx" OFF)
+option(MLX_BUILD_METAL "Build metal backend" ON)
+option(MLX_BUILD_CPU "Build cpu backend" ON)
+option(MLX_BUILD_CUDA "Build cuda backend" OFF)
+option(MLX_METAL_DEBUG "Enhance metal debug workflow" OFF)
+option(MLX_ENABLE_X64_MAC "Enable building for x64 macOS" OFF)
+option(MLX_BUILD_GGUF "Include support for GGUF format" ON)
+option(MLX_BUILD_SAFETENSORS "Include support for safetensors format" ON)
+option(MLX_BUILD_BLAS_FROM_SOURCE "Build OpenBLAS from source code" OFF)
+option(MLX_METAL_JIT "Use JIT compilation for Metal kernels" OFF)
+option(MLX_USE_CCACHE "Use CCache for compilation cache when available" ON)
+option(BUILD_SHARED_LIBS "Build mlx as a shared library" OFF)
+option(USE_SYSTEM_FMT "Use system's provided fmt library" OFF)
+
+# --------------------- Processor tests -------------------------
+message(
+  STATUS
+    "Building MLX for ${CMAKE_SYSTEM_PROCESSOR} processor on ${CMAKE_SYSTEM_NAME}"
+)
+
+if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+  if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "x86_64")
+    if(NOT MLX_ENABLE_X64_MAC)
+      message(
+        FATAL_ERROR
+          "Building for x86_64 on macOS is not supported."
+          " If you are on an Apple silicon system, check the build"
+          " documentation for possible fixes: "
+          "https://ml-explore.github.io/mlx/build/html/install.html#build-from-source"
+      )
+    else()
+      set(MLX_BUILD_METAL OFF)
+      message(WARNING "Building for x86_64 arch is not officially supported.")
+    endif()
+  endif()
+else()
+  set(MLX_BUILD_METAL OFF)
+endif()
+
+if(MLX_USE_CCACHE)
+  find_program(CCACHE_PROGRAM ccache)
+  if(CCACHE_PROGRAM)
+    set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+    set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+    set(CMAKE_CUDA_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+  endif()
+endif()
+
+# ----------------------------- Lib -----------------------------
+
+include(FetchContent)
+# Avoid warning about DOWNLOAD_EXTRACT_TIMESTAMP in CMake 3.24:
+cmake_policy(SET CMP0135 NEW)
+
+add_library(mlx)
+
+if(MLX_BUILD_CUDA)
+  enable_language(CUDA)
+endif()
+
+if(MLX_BUILD_METAL)
+  find_library(METAL_LIB Metal)
+  find_library(FOUNDATION_LIB Foundation)
+  find_library(QUARTZ_LIB QuartzCore)
+  if(METAL_LIB)
+    message(STATUS "Metal found ${METAL_LIB}")
+  else()
+    message(
+      FATAL_ERROR
+        "Metal not found. Set MLX_BUILD_METAL=OFF to build without GPU")
+  endif()
+
+  if(MLX_METAL_DEBUG)
+    add_compile_definitions(MLX_METAL_DEBUG)
+  endif()
+
+  # Throw an error if xcrun not found
+  execute_process(
+    COMMAND zsh "-c" "/usr/bin/xcrun -sdk macosx --show-sdk-version"
+    OUTPUT_VARIABLE MACOS_SDK_VERSION
+    OUTPUT_STRIP_TRAILING_WHITESPACE COMMAND_ERROR_IS_FATAL ANY)
+
+  if(${MACOS_SDK_VERSION} LESS 14.0)
+    message(
+      FATAL_ERROR
+        "MLX requires macOS SDK >= 14.0 to be built with MLX_BUILD_METAL=ON")
+  endif()
+  message(STATUS "Building with macOS SDK version ${MACOS_SDK_VERSION}")
+
+  set(METAL_CPP_URL
+      https://developer.apple.com/metal/cpp/files/metal-cpp_macOS15_iOS18.zip)
+
+  if(NOT CMAKE_OSX_DEPLOYMENT_TARGET STREQUAL "")
+    set(XCRUN_FLAGS "-mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
+  endif()
+  execute_process(
+    COMMAND
+      zsh "-c"
+      "echo \"__METAL_VERSION__\" | xcrun -sdk macosx metal ${XCRUN_FLAGS} -E -x metal -P - | tail -1 | tr -d '\n'"
+    OUTPUT_VARIABLE MLX_METAL_VERSION COMMAND_ERROR_IS_FATAL ANY)
+  FetchContent_Declare(metal_cpp URL ${METAL_CPP_URL})
+
+  FetchContent_MakeAvailable(metal_cpp)
+  target_include_directories(
+    mlx PUBLIC $<BUILD_INTERFACE:${metal_cpp_SOURCE_DIR}>
+               $<INSTALL_INTERFACE:include/metal_cpp>)
+  target_link_libraries(mlx PUBLIC ${METAL_LIB} ${FOUNDATION_LIB} ${QUARTZ_LIB})
+endif()
+
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+  # With newer clang/gcc versions following libs are implicitly linked, but when
+  # building on old distributions they need to be explicitly listed.
+  target_link_libraries(mlx PRIVATE dl pthread)
+endif()
+
+if(WIN32)
+  if(MSVC)
+    # GGUF does not build with MSVC.
+    set(MLX_BUILD_GGUF OFF)
+    # There is no prebuilt OpenBLAS distribution for MSVC.
+    set(MLX_BUILD_BLAS_FROM_SOURCE ON)
+  endif()
+  # Windows implementation of dlfcn.h APIs.
+  FetchContent_Declare(
+    dlfcn-win32
+    GIT_REPOSITORY https://github.com/dlfcn-win32/dlfcn-win32.git
+    GIT_TAG v1.4.1
+    EXCLUDE_FROM_ALL)
+  block()
+  set(BUILD_SHARED_LIBS OFF)
+  FetchContent_MakeAvailable(dlfcn-win32)
+  endblock()
+  target_include_directories(mlx PRIVATE "${dlfcn-win32_SOURCE_DIR}/src")
+  target_link_libraries(mlx PRIVATE dl)
+endif()
+
+if(MLX_BUILD_CPU)
+  find_library(ACCELERATE_LIBRARY Accelerate)
+  if(ACCELERATE_LIBRARY)
+    message(STATUS "Accelerate found ${ACCELERATE_LIBRARY}")
+    set(MLX_BUILD_ACCELERATE ON)
+  else()
+    message(STATUS "Accelerate not found, using default backend.")
+    set(MLX_BUILD_ACCELERATE OFF)
+  endif()
+
+  if(MLX_BUILD_ACCELERATE)
+    target_link_libraries(mlx PUBLIC ${ACCELERATE_LIBRARY})
+    add_compile_definitions(MLX_USE_ACCELERATE)
+    add_compile_definitions(ACCELERATE_NEW_LAPACK)
+  elseif(MLX_BUILD_BLAS_FROM_SOURCE)
+    # Download and build OpenBLAS from source code.
+    FetchContent_Declare(
+      openblas
+      GIT_REPOSITORY https://github.com/OpenMathLib/OpenBLAS.git
+      GIT_TAG v0.3.28
+      EXCLUDE_FROM_ALL)
+    set(BUILD_STATIC_LIBS ON) # link statically
+    set(NOFORTRAN ON) # msvc has no fortran compiler
+    FetchContent_MakeAvailable(openblas)
+    target_link_libraries(mlx PRIVATE openblas)
+    target_include_directories(
+      mlx PRIVATE "${openblas_SOURCE_DIR}/lapack-netlib/LAPACKE/include"
+                  "${CMAKE_BINARY_DIR}/generated" "${CMAKE_BINARY_DIR}")
+  else()
+    if(${CMAKE_HOST_APPLE})
+      # The blas shipped in macOS SDK is not supported, search homebrew for
+      # openblas instead.
+      set(BLA_VENDOR OpenBLAS)
+      set(LAPACK_ROOT
+          "${LAPACK_ROOT};$ENV{LAPACK_ROOT};/usr/local/opt/openblas")
+    endif()
+    # Search and link with lapack.
+    find_package(LAPACK REQUIRED)
+    if(NOT LAPACK_FOUND)
+      message(FATAL_ERROR "Must have LAPACK installed")
+    endif()
+    find_path(LAPACK_INCLUDE_DIRS lapacke.h /usr/include /usr/local/include
+              /usr/local/opt/openblas/include)
+    message(STATUS "Lapack lib " ${LAPACK_LIBRARIES})
+    message(STATUS "Lapack include " ${LAPACK_INCLUDE_DIRS})
+    target_include_directories(mlx PRIVATE ${LAPACK_INCLUDE_DIRS})
+    target_link_libraries(mlx PRIVATE ${LAPACK_LIBRARIES})
+    # List blas after lapack otherwise we may accidentally incldue an old
+    # version of lapack.h from the include dirs of blas.
+    find_package(BLAS REQUIRED)
+    if(NOT BLAS_FOUND)
+      message(FATAL_ERROR "Must have BLAS installed")
+    endif()
+    # TODO find a cleaner way to do this
+    find_path(BLAS_INCLUDE_DIRS cblas.h /usr/include /usr/local/include
+              $ENV{BLAS_HOME}/include)
+    message(STATUS "Blas lib " ${BLAS_LIBRARIES})
+    message(STATUS "Blas include " ${BLAS_INCLUDE_DIRS})
+    target_include_directories(mlx PRIVATE ${BLAS_INCLUDE_DIRS})
+    target_link_libraries(mlx PRIVATE ${BLAS_LIBRARIES})
+  endif()
+else()
+  set(MLX_BUILD_ACCELERATE OFF)
+endif()
+
+message(STATUS "Downloading json")
+FetchContent_Declare(
+  json
+  URL https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz)
+FetchContent_MakeAvailable(json)
+target_include_directories(
+  mlx PRIVATE $<BUILD_INTERFACE:${json_SOURCE_DIR}/single_include/nlohmann>)
+
+add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/mlx)
+
+target_include_directories(
+  mlx PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}>
+             $<INSTALL_INTERFACE:include>)
+
+# Do not add mlx_EXPORTS define for shared library.
+set_target_properties(mlx PROPERTIES DEFINE_SYMBOL "")
+
+if(USE_SYSTEM_FMT)
+  find_package(fmt REQUIRED)
+else()
+  FetchContent_Declare(
+    fmt
+    GIT_REPOSITORY https://github.com/fmtlib/fmt.git
+    GIT_TAG 10.2.1
+    EXCLUDE_FROM_ALL)
+  FetchContent_MakeAvailable(fmt)
+endif()
+target_link_libraries(mlx PRIVATE $<BUILD_INTERFACE:fmt::fmt-header-only>)
+
+if(MLX_BUILD_PYTHON_BINDINGS)
+  message(STATUS "Building Python bindings.")
+  find_package(
+    Python 3.8
+    COMPONENTS Interpreter Development.Module
+    REQUIRED)
+  execute_process(
+    COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    OUTPUT_VARIABLE nanobind_ROOT)
+  find_package(nanobind CONFIG REQUIRED)
+  add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/python/src)
+endif()
+
+if(MLX_BUILD_TESTS)
+  include(CTest)
+  add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/tests)
+endif()
+
+if(MLX_BUILD_EXAMPLES)
+  add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/examples/cpp)
+endif()
+
+if(MLX_BUILD_BENCHMARKS)
+  add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/benchmarks/cpp)
+endif()
+
+# ----------------------------- Installation -----------------------------
+include(GNUInstallDirs)
+
+# Install library
+install(
+  TARGETS mlx
+  EXPORT MLXTargets
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  INCLUDES
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+# Install headers
+install(
+  DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/mlx
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+  COMPONENT headers
+  FILES_MATCHING
+  PATTERN "*.h"
+  PATTERN "backend/metal/kernels.h" EXCLUDE)
+
+# Install metal dependencies
+if(MLX_BUILD_METAL)
+
+  # Install metal cpp
+  install(
+    DIRECTORY ${metal_cpp_SOURCE_DIR}/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/metal_cpp
+    COMPONENT metal_cpp_source)
+
+endif()
+
+# Install cmake config
+set(MLX_CMAKE_BUILD_CONFIG ${CMAKE_BINARY_DIR}/MLXConfig.cmake)
+set(MLX_CMAKE_BUILD_VERSION_CONFIG ${CMAKE_BINARY_DIR}/MLXConfigVersion.cmake)
+set(MLX_CMAKE_INSTALL_MODULE_DIR share/cmake/MLX)
+
+install(
+  EXPORT MLXTargets
+  FILE MLXTargets.cmake
+  DESTINATION ${MLX_CMAKE_INSTALL_MODULE_DIR})
+
+include(CMakePackageConfigHelpers)
+
+write_basic_package_version_file(
+  ${MLX_CMAKE_BUILD_VERSION_CONFIG}
+  COMPATIBILITY SameMajorVersion
+  VERSION ${MLX_VERSION})
+
+configure_package_config_file(
+  ${CMAKE_CURRENT_LIST_DIR}/mlx.pc.in ${MLX_CMAKE_BUILD_CONFIG}
+  INSTALL_DESTINATION ${MLX_CMAKE_INSTALL_MODULE_DIR}
+  NO_CHECK_REQUIRED_COMPONENTS_MACRO
+  PATH_VARS CMAKE_INSTALL_LIBDIR CMAKE_INSTALL_INCLUDEDIR
+            MLX_CMAKE_INSTALL_MODULE_DIR)
+
+install(FILES ${MLX_CMAKE_BUILD_CONFIG} ${MLX_CMAKE_BUILD_VERSION_CONFIG}
+        DESTINATION ${MLX_CMAKE_INSTALL_MODULE_DIR})
+
+install(DIRECTORY ${CMAKE_MODULE_PATH}/
+        DESTINATION ${MLX_CMAKE_INSTALL_MODULE_DIR})
diff --git a/ml-stable-diffusion/mlx/CODE_OF_CONDUCT.md b/ml-stable-diffusion/mlx/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000000000000000000000000000000000000..e8d213c7b24581d85b981d812af53e0fa3413186
--- /dev/null
+++ b/ml-stable-diffusion/mlx/CODE_OF_CONDUCT.md
@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[opensource-conduct@group.apple.com](mailto:opensource-conduct@group.apple.com).
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations
diff --git a/ml-stable-diffusion/mlx/CONTRIBUTING.md b/ml-stable-diffusion/mlx/CONTRIBUTING.md
new file mode 100644
index 0000000000000000000000000000000000000000..fddb2a9743cf1b6bdd1934d01fbfba2362e95609
--- /dev/null
+++ b/ml-stable-diffusion/mlx/CONTRIBUTING.md
@@ -0,0 +1,38 @@
+# Contributing to MLX
+
+We want to make contributing to this project as easy and transparent as
+possible.
+
+## Pull Requests
+
+1. Fork and submit pull requests to the repo.
+2. If you've added code that should be tested, add tests.
+3. If a change is likely to impact efficiency, run some of the benchmarks before
+   and after the change. Examples of benchmarks can be found in `benchmarks/python/`.
+4. If you've changed APIs, update the documentation.
+5. Every PR should have passing tests and at least one review.
+6. For code formatting install `pre-commit` using something like `pip install pre-commit` and run `pre-commit install`.
+   This should install hooks for running `black` and `clang-format` to ensure
+   consistent style for C++ and python code.
+
+   You can also run the formatters manually as follows:
+
+   ```shell
+   clang-format -i file.cpp
+   ```
+
+   ```shell
+   black file.py
+   ```
+
+   or run `pre-commit run --all-files` to check all files in the repo.
+
+## Issues
+
+We use GitHub issues to track public bugs. Please ensure your description is
+clear and has sufficient instructions to be able to reproduce the issue.
+
+## License
+
+By contributing to MLX, you agree that your contributions will be licensed
+under the LICENSE file in the root directory of this source tree.
diff --git a/ml-stable-diffusion/mlx/LICENSE b/ml-stable-diffusion/mlx/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..98ff47b9ef9d4ac9f1a4bde3db13dd27456c5ea1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright © 2023 Apple Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/ml-stable-diffusion/mlx/MANIFEST.in b/ml-stable-diffusion/mlx/MANIFEST.in
new file mode 100644
index 0000000000000000000000000000000000000000..d0daeb7ae6936ee4a7524fb35542fff1bbde99b9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/MANIFEST.in
@@ -0,0 +1,6 @@
+include CMakeLists.txt
+include mlx.pc.in
+recursive-include mlx/ *
+include cmake/*
+include python/src/*
+include python/mlx/py.typed # support type hinting as in PEP-561
diff --git a/ml-stable-diffusion/mlx/README.md b/ml-stable-diffusion/mlx/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8ca186dcfc47ed19208b9c2dc340d2cf6dc64149
--- /dev/null
+++ b/ml-stable-diffusion/mlx/README.md
@@ -0,0 +1,121 @@
+# MLX
+
+[**Quickstart**](#quickstart) | [**Installation**](#installation) |
+[**Documentation**](https://ml-explore.github.io/mlx/build/html/index.html) |
+[**Examples**](#examples) 
+
+[![CircleCI](https://circleci.com/gh/ml-explore/mlx.svg?style=svg)](https://circleci.com/gh/ml-explore/mlx)
+
+MLX is an array framework for machine learning on Apple silicon,
+brought to you by Apple machine learning research.
+
+Some key features of MLX include:
+
+ - **Familiar APIs**: MLX has a Python API that closely follows NumPy. MLX
+   also has fully featured C++, [C](https://github.com/ml-explore/mlx-c), and
+   [Swift](https://github.com/ml-explore/mlx-swift/) APIs, which closely mirror
+   the Python API. MLX has higher-level packages like `mlx.nn` and
+   `mlx.optimizers` with APIs that closely follow PyTorch to simplify building
+   more complex models.
+
+ - **Composable function transformations**: MLX supports composable function
+   transformations for automatic differentiation, automatic vectorization,
+   and computation graph optimization.
+
+ - **Lazy computation**: Computations in MLX are lazy. Arrays are only
+   materialized when needed.
+
+ - **Dynamic graph construction**: Computation graphs in MLX are constructed
+   dynamically. Changing the shapes of function arguments does not trigger
+   slow compilations, and debugging is simple and intuitive.
+
+ - **Multi-device**: Operations can run on any of the supported devices
+   (currently the CPU and the GPU).
+
+ - **Unified memory**: A notable difference from MLX and other frameworks
+   is the *unified memory model*. Arrays in MLX live in shared memory.
+   Operations on MLX arrays can be performed on any of the supported
+   device types without transferring data.
+
+MLX is designed by machine learning researchers for machine learning
+researchers. The framework is intended to be user-friendly, but still efficient
+to train and deploy models. The design of the framework itself is also
+conceptually simple. We intend to make it easy for researchers to extend and
+improve MLX with the goal of quickly exploring new ideas. 
+
+The design of MLX is inspired by frameworks like
+[NumPy](https://numpy.org/doc/stable/index.html),
+[PyTorch](https://pytorch.org/), [Jax](https://github.com/google/jax), and
+[ArrayFire](https://arrayfire.org/).
+
+## Examples
+
+The [MLX examples repo](https://github.com/ml-explore/mlx-examples) has a
+variety of examples, including:
+
+- [Transformer language model](https://github.com/ml-explore/mlx-examples/tree/main/transformer_lm) training.
+- Large-scale text generation with
+  [LLaMA](https://github.com/ml-explore/mlx-examples/tree/main/llms/llama) and
+  finetuning with [LoRA](https://github.com/ml-explore/mlx-examples/tree/main/lora).
+- Generating images with [Stable Diffusion](https://github.com/ml-explore/mlx-examples/tree/main/stable_diffusion).
+- Speech recognition with [OpenAI's Whisper](https://github.com/ml-explore/mlx-examples/tree/main/whisper).
+
+## Quickstart
+
+See the [quick start
+guide](https://ml-explore.github.io/mlx/build/html/usage/quick_start.html)
+in the documentation.
+
+## Installation
+
+MLX is available on [PyPI](https://pypi.org/project/mlx/). To install MLX on
+macOS, run:
+
+```bash
+pip install mlx
+```
+
+To install the CUDA backend on Linux, run:
+
+```bash
+pip install mlx[cuda]
+```
+
+To install a CPU-only Linux package, run:
+
+```bash
+pip install mlx[cpu]
+```
+
+Checkout the
+[documentation](https://ml-explore.github.io/mlx/build/html/install.html#)
+for more information on building the C++ and Python APIs from source.
+
+## Contributing 
+
+Check out the [contribution guidelines](https://github.com/ml-explore/mlx/tree/main/CONTRIBUTING.md) for more information
+on contributing to MLX. See the
+[docs](https://ml-explore.github.io/mlx/build/html/install.html) for more
+information on building from source, and running tests.
+
+We are grateful for all of [our
+contributors](https://github.com/ml-explore/mlx/tree/main/ACKNOWLEDGMENTS.md#Individual-Contributors). If you contribute
+to MLX and wish to be acknowledged, please add your name to the list in your
+pull request.
+
+## Citing MLX
+
+The MLX software suite was initially developed with equal contribution by Awni
+Hannun, Jagrit Digani, Angelos Katharopoulos, and Ronan Collobert. If you find
+MLX useful in your research and wish to cite it, please use the following
+BibTex entry:
+
+```
+@software{mlx2023,
+  author = {Awni Hannun and Jagrit Digani and Angelos Katharopoulos and Ronan Collobert},
+  title = {{MLX}: Efficient and flexible machine learning on Apple silicon},
+  url = {https://github.com/ml-explore},
+  version = {0.0},
+  year = {2023},
+}
+```
diff --git a/ml-stable-diffusion/mlx/benchmarks/cpp/CMakeLists.txt b/ml-stable-diffusion/mlx/benchmarks/cpp/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..82d5ffce9dffa8515db80185f516f787f41e1e26
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/cpp/CMakeLists.txt
@@ -0,0 +1,11 @@
+function(build_benchmark SRCFILE)
+  get_filename_component(src_name ${SRCFILE} NAME_WE)
+  set(target "${src_name}")
+  add_executable(${target} ${SRCFILE})
+  target_link_libraries(${target} PRIVATE mlx)
+endfunction(build_benchmark)
+
+build_benchmark(single_ops.cpp)
+build_benchmark(irregular_strides.cpp)
+build_benchmark(compare_devices.cpp)
+build_benchmark(autograd.cpp)
diff --git a/ml-stable-diffusion/mlx/benchmarks/cpp/autograd.cpp b/ml-stable-diffusion/mlx/benchmarks/cpp/autograd.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4303a840aafd43e7e009da5d03cf5b6dc1f3ff5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/cpp/autograd.cpp
@@ -0,0 +1,39 @@
+// Copyright © 2023 Apple Inc.
+
+#include <iostream>
+
+#include "mlx/mlx.h"
+#include "time_utils.h"
+
+namespace mx = mlx::core;
+
+void time_value_and_grad() {
+  auto x = mx::ones({200, 1000});
+  mx::eval(x);
+  auto fn = [](mx::array x) {
+    for (int i = 0; i < 20; ++i) {
+      x = mx::log(mx::exp(x));
+    }
+    return mx::sum(x);
+  };
+
+  auto grad_fn = mx::grad(fn);
+  auto independent_value_and_grad = [&]() {
+    auto value = fn(x);
+    auto dfdx = grad_fn(x);
+    return std::vector<mx::array>{value, dfdx};
+  };
+  TIME(independent_value_and_grad);
+
+  auto value_and_grad_fn = mx::value_and_grad(fn);
+  auto combined_value_and_grad = [&]() {
+    auto [value, dfdx] = value_and_grad_fn(x);
+    return std::vector<mx::array>{value, dfdx};
+  };
+  TIME(combined_value_and_grad);
+}
+
+int main() {
+  std::cout << "Benchmarks for " << mx::default_device() << std::endl;
+  time_value_and_grad();
+}
diff --git a/ml-stable-diffusion/mlx/benchmarks/cpp/compare_devices.cpp b/ml-stable-diffusion/mlx/benchmarks/cpp/compare_devices.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9af6c710375542a1f8872f6681e9d8fd6580bbb4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/cpp/compare_devices.cpp
@@ -0,0 +1,27 @@
+// Copyright © 2023 Apple Inc.
+
+#include <iostream>
+#include "mlx/mlx.h"
+#include "time_utils.h"
+
+namespace mx = mlx::core;
+
+void time_add_op() {
+  std::vector<int> sizes(1, 1);
+  for (int i = 0; i < 9; ++i) {
+    sizes.push_back(10 * sizes.back());
+  }
+  set_default_device(mx::Device::cpu);
+  for (auto size : sizes) {
+    auto a = mx::random::uniform({size});
+    auto b = mx::random::uniform({size});
+    mx::eval(a, b);
+    std::cout << "Size " << size << std::endl;
+    TIMEM("cpu", mx::add, a, b, mx::Device::cpu);
+    TIMEM("gpu", mx::add, a, b, mx::Device::gpu);
+  }
+}
+
+int main() {
+  time_add_op();
+}
diff --git a/ml-stable-diffusion/mlx/benchmarks/cpp/irregular_strides.cpp b/ml-stable-diffusion/mlx/benchmarks/cpp/irregular_strides.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5524613357ede41d71f752062694ad4bdf9ebe28
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/cpp/irregular_strides.cpp
@@ -0,0 +1,201 @@
+// Copyright © 2023 Apple Inc.
+
+#include <cstring>
+#include <iostream>
+#include <sstream>
+
+#include "mlx/mlx.h"
+#include "time_utils.h"
+
+namespace mx = mlx::core;
+
+void time_irregular_binary_ops_1D() {
+  auto device = mx::default_device();
+  int size = 1000000;
+  int step = 2;
+  auto a = mx::random::uniform({size});
+  auto b = mx::random::uniform({size});
+  mx::eval(a, b);
+  a = slice(a, {0}, {size}, {step});
+  b = slice(b, {0}, {size}, {step});
+  TIMEM("1D strided", mx::add, a, b, device);
+}
+
+void time_irregular_binary_ops_2D() {
+  auto device = mx::default_device();
+  int size = 2048;
+  auto a = mx::random::uniform({size, size});
+  auto b = mx::random::uniform({size, size});
+  mx::eval(a, b);
+  TIMEM("2D regular", mx::add, a, b, device);
+
+  b = mx::transpose(b);
+  mx::eval(b);
+  TIMEM("2D mx::transpose", mx::add, a, b, device);
+
+  b = mx::random::uniform({size});
+  mx::eval(b);
+  TIMEM("2D broadcast dim 0", mx::add, a, b, device);
+
+  b = mx::reshape(b, {size, 1});
+  mx::eval(b);
+  TIMEM("2D broadcast dim 1", mx::add, a, b, device);
+}
+
+void time_irregular_binary_ops_3D() {
+  auto device = mx::default_device();
+  int d0 = 32;
+  int d1 = 512;
+  int d2 = 512;
+  auto a = mx::random::uniform({d0, d1, d2});
+  auto b = mx::random::uniform({d0, d1, d2});
+  TIMEM("3D regular", mx::add, a, b, device);
+
+  b = mx::transpose(b, {0, 2, 1});
+  TIMEM("3D mx::transpose", mx::add, a, b, device);
+
+  b = mx::random::uniform({d1, d2});
+  TIMEM("3D broadcast dim 0", mx::add, a, b, device);
+
+  b = mx::random::uniform({d0, 1, d2});
+  TIMEM("3D broadcast dim 1", mx::add, a, b, device);
+
+  b = mx::random::uniform({d0, d1, 1});
+  TIMEM("3D broadcast dim 2", mx::add, a, b, device);
+
+  b = mx::random::uniform({d2});
+  TIMEM("3D broadcast dims 0, 1", mx::add, a, b, device);
+
+  b = mx::random::uniform({d1, 1});
+  TIMEM("3D broadcast dims 0, 2", mx::add, a, b, device);
+
+  b = mx::random::uniform({d0, 1, 1});
+  TIMEM("3D broadcast dims 1, 2", mx::add, a, b, device);
+}
+
+void time_irregular_binary_ops_4D() {
+  auto device = mx::default_device();
+  std::vector<int> shape = {8, 8, 512, 512};
+  auto a = mx::random::uniform(shape);
+  auto b = mx::random::uniform(shape);
+
+  TIMEM("4D regular", mx::add, a, b, device);
+
+  b = mx::transpose(b, {0, 1, 3, 2});
+  TIMEM("4D mx::transpose", mx::add, a, b, device);
+
+  std::string om = "4D broadcast dims ";
+  for (int i = 0; i < shape.size(); ++i) {
+    shape[i] = 1;
+    b = mx::random::uniform(shape);
+    std::ostringstream msg;
+    msg << om << i;
+    TIMEM(msg.str(), mx::add, a, b, device);
+
+    for (int j = i + 1; j < shape.size(); ++j) {
+      shape[j] = 1;
+      std::ostringstream msg;
+      msg << om << i << ", " << j;
+      b = mx::random::uniform(shape);
+      TIMEM(msg.str(), mx::add, a, b, device);
+      shape[j] = a.shape(j);
+
+      for (int k = j + 1; k < shape.size(); ++k) {
+        shape[k] = 1;
+        std::ostringstream msg;
+        msg << om << i << ", " << j << ", " << k;
+        b = mx::random::uniform(shape);
+        TIMEM(msg.str(), mx::add, a, b, device);
+        shape[k] = a.shape(k);
+      }
+    }
+    shape[i] = a.shape(i);
+  }
+}
+
+void time_irregular_reshape() {
+  auto device = mx::default_device();
+  std::vector<int> shape;
+  auto reshape_fn = [&shape, device](const mx::array& a) {
+    return mx::reshape(a, shape, device);
+  };
+
+  int size = 64;
+  int d = 2 * size;
+
+  auto a = mx::random::uniform({d, d, d});
+
+  shape = {8 * size, size, size};
+  TIMEM("3D contiguous", reshape_fn, a);
+
+  a = mx::transpose(a);
+  shape = {8 * size, size, size};
+  TIMEM("3D mx::transpose", reshape_fn, a);
+
+  a = mx::transpose(a, {1, 2, 0});
+  shape = {8 * size, size, size};
+  TIMEM("3D mx::transpose dims 1 2", reshape_fn, a);
+
+  a = mx::broadcast_to(mx::random::uniform({d, d}), {d, d, d});
+  TIMEM("3D broadcast dim 0", reshape_fn, a);
+
+  a = mx::broadcast_to(mx::random::uniform({d, 1, d}), {d, d, d});
+  TIMEM("3D broadcast dim 1", reshape_fn, a);
+
+  a = mx::broadcast_to(mx::random::uniform({d, d, 1}), {d, d, d});
+  TIMEM("3D broadcast dim 2", reshape_fn, a);
+
+  a = mx::broadcast_to(mx::random::uniform({d}), {d, d, d});
+  TIMEM("3D broadcast dims 0, 1", reshape_fn, a);
+
+  a = mx::broadcast_to(mx::random::uniform({d, 1}), {d, d, d});
+  TIMEM("3D broadcast dims 0, 2", reshape_fn, a);
+
+  a = mx::broadcast_to(mx::random::uniform({d, 1, 1}), {d, d, d});
+  TIMEM("3D broadcast dims 1, 2", reshape_fn, a);
+
+  a = mx::broadcast_to(mx::random::uniform({1, 1, 1}), {d, d, d});
+  TIMEM("3D broadcast dims 1, 2, 3", reshape_fn, a);
+}
+
+void time_irregular_astype_1D() {
+  auto device = mx::default_device();
+  int size = 1000000;
+  int step = 2;
+  auto a = mx::random::uniform({size});
+  a = slice(a, {0}, {size}, {step});
+  TIMEM("1D strided", mx::astype, a, mx::int32, device);
+}
+
+void time_irregular_astype_2D() {
+  auto device = mx::default_device();
+  int size = 2048;
+  std::vector<int> shape = {size, size};
+
+  auto a = mx::random::uniform(shape);
+  TIMEM("2D regular", mx::astype, a, mx::int32, device);
+
+  a = mx::transpose(a);
+  TIMEM("2D mx::transpose", mx::astype, a, mx::int32, device);
+
+  a = mx::broadcast_to(mx::random::uniform({size}), shape);
+  TIMEM("2D broadcast dim 0", mx::astype, a, mx::int32, device);
+
+  a = mx::broadcast_to(mx::random::uniform({size, 1}), shape);
+  TIMEM("2D broadcast dim 1", mx::astype, a, mx::int32, device);
+}
+
+int main(int argc, char** argv) {
+  if (argc > 1) {
+    bool use_gpu = !strcmp(argv[1], "gpu");
+    set_default_device(use_gpu ? mx::Device::gpu : mx::Device::cpu);
+  }
+  std::cout << "Benchmarks for " << mx::default_device() << std::endl;
+  time_irregular_binary_ops_1D();
+  time_irregular_binary_ops_2D();
+  time_irregular_binary_ops_3D();
+  time_irregular_binary_ops_4D();
+  time_irregular_reshape();
+  time_irregular_astype_1D();
+  time_irregular_astype_2D();
+}
diff --git a/ml-stable-diffusion/mlx/benchmarks/cpp/single_ops.cpp b/ml-stable-diffusion/mlx/benchmarks/cpp/single_ops.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1f93a78d71936735c8f29e94fb198cb03bebf089
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/cpp/single_ops.cpp
@@ -0,0 +1,288 @@
+// Copyright © 2023 Apple Inc.
+
+#include "mlx/mlx.h"
+#include "time_utils.h"
+
+namespace mx = mlx::core;
+
+void time_creation_ops() {
+  int M = 2000;
+  int N = 500;
+  auto shape = {M, N};
+  auto full_fp32 = [&]() { return mx::full(shape, 3.3f); };
+  TIME(full_fp32);
+  auto zeros_fp32 = [&]() { return mx::zeros(shape, mx::float32); };
+  TIME(zeros_fp32);
+  auto ones_fp32 = [&]() { return mx::ones(shape, mx::float32); };
+  TIME(ones_fp32);
+
+  auto arange_fp32 = [&]() { return mx::arange(0.0, 10.0, 1e-4); };
+  TIME(arange_fp32);
+}
+
+void time_type_conversions() {
+  int M = 2000;
+  int N = 500;
+  auto shape = {M, N};
+  auto device = mx::default_device();
+
+  auto a = mx::zeros(shape, mx::float32);
+  mx::eval(a);
+  TIMEM("mx::float32 to mx::int32", mx::astype, a, mx::int32, device);
+  TIMEM("mx::float32 to mx::uint32", mx::astype, a, mx::uint32, device);
+
+  a = mx::zeros(shape, mx::int32);
+  mx::eval(a);
+  TIMEM("mx::int32 to mx::float32", mx::astype, a, mx::float32, device);
+
+  a = mx::zeros(shape, mx::bool_);
+  mx::eval(a);
+  TIMEM("bool to mx::float32", mx::astype, a, mx::float32, device);
+  TIMEM("bool to mx::int32", mx::astype, a, mx::int32, device);
+  TIMEM("bool to mx::uint32", mx::astype, a, mx::uint32, device);
+}
+
+void time_random_generation() {
+  int M = 2000;
+  int N = 500;
+
+  auto uniform = [&]() { return mx::random::uniform({M, N}, mx::float32); };
+  TIME(uniform);
+  auto normal = [&]() { return mx::random::normal({M, N}, mx::float32); };
+  TIME(normal);
+}
+
+void time_unary_ops() {
+  int M = 2000;
+  int N = 500;
+  auto device = mx::default_device();
+
+  auto a = mx::random::normal({M, N});
+  mx::eval(a);
+  TIME(mlx::core::abs, a, device);
+  TIME(mx::negative, a, device);
+  TIME(mx::sign, a, device);
+  TIME(mx::square, a, device);
+  TIME(mlx::core::sqrt, a, device);
+  TIME(mx::rsqrt, a, device);
+  TIME(mlx::core::exp, a, device);
+
+  a = mx::random::uniform({M, N});
+  TIME(mlx::core::log, a, device);
+}
+
+void time_binary_ops() {
+  int M = 1000, N = 100, K = 10;
+  auto condition = mx::random::randint(0, 2, {M, N, K});
+  auto a = mx::random::uniform({M, N, K});
+  auto b = mx::random::uniform({M, N, K});
+  auto device = mx::default_device();
+  mx::eval(a, b);
+
+  TIME(mx::add, a, b, device);
+  TIME(mx::subtract, a, b, device);
+  TIME(mx::multiply, a, b, device);
+  TIME(mx::divide, a, b, device);
+  TIME(mx::maximum, a, b, device);
+  TIME(mx::minimum, a, b, device);
+  TIME(mx::where, condition, a, b, device);
+
+  condition = mx::array({true});
+  b = mx::random::uniform({1});
+  mx::eval(b);
+  TIMEM("scalar", mx::add, a, b, device);
+  TIMEM("vector-scalar", mx::subtract, a, b, device);
+  TIMEM("scalar-vector", mx::subtract, b, a, device);
+  TIMEM("scalar", mx::multiply, a, b, device);
+  TIMEM("vector-scalar", mx::divide, a, b, device);
+  TIMEM("scalar-vector", mx::divide, b, a, device);
+  TIMEM("scalar-vector", mx::where, condition, a, b, device);
+
+  condition = mx::broadcast_to(mx::array({true}), {1000, 100});
+  a = mx::broadcast_to(mx::random::uniform({1}), {1000, 100});
+  b = mx::broadcast_to(mx::random::uniform({1}), {1000, 100});
+  mx::eval(a, b);
+  TIMEM("scalar-scalar broadcast", mx::add, a, b, device);
+  TIMEM("scalar-scalar broadcast", mx::subtract, a, b, device);
+  TIMEM("scalar-scalar broadcast", mx::multiply, a, b, device);
+  TIMEM("scalar-scalar broadcast", mx::divide, a, b, device);
+  TIMEM("scalar-scalar broadcast", mx::where, condition, a, b, device);
+}
+
+void time_strided_ops() {
+  int M = 50, N = 50, O = 50, P = 50;
+  auto a = mx::random::uniform({M, N, O, P});
+  auto b = mx::random::uniform({M, N, O, P});
+  auto device = mx::default_device();
+  mx::eval(a, b);
+  TIMEM("non-strided", mx::add, a, b, device);
+  a = mx::transpose(a, {1, 0, 2, 3});
+  b = mx::transpose(b, {3, 2, 0, 1});
+  mx::eval(a, b);
+  TIMEM("strided", mx::add, a, b, device);
+}
+
+void time_comparisons() {
+  int M = 1000, N = 100, K = 10;
+  auto a = mx::random::uniform({M, N, K});
+  auto b = mx::random::uniform({M, N, K});
+  auto device = mx::default_device();
+  mx::eval(a, b);
+  TIME(mx::equal, a, b, device);
+  TIME(mx::greater, a, b, device);
+  TIME(mx::greater_equal, a, b, device);
+  TIME(mx::less, a, b, device);
+  TIME(mx::less_equal, a, b, device);
+}
+
+void time_matvec() {
+  int M = 2000, N = 200;
+  auto a = mx::random::uniform({M, N});
+  auto b = mx::random::uniform({N});
+  auto c = mx::random::uniform({M});
+  mx::eval(a, b, c);
+  auto matvec = [&]() { return mx::matmul(a, b); };
+  TIME(matvec);
+
+  auto matvec_transpose = [&]() { return mx::matmul(mx::transpose(a), c); };
+  TIME(matvec_transpose);
+}
+
+void time_matmul() {
+  int M = 1000, N = 1000, K = 1000;
+  auto a = mx::random::uniform({M, K});
+  auto b = mx::random::uniform({K, N});
+  auto device = mx::default_device();
+  mx::eval(a, b);
+  TIME(mx::matmul, a, b, device);
+
+  auto transpose_matmul = [&]() { return mx::matmul(mx::transpose(a), b); };
+  TIME(transpose_matmul);
+}
+
+void time_reductions() {
+  auto a = mx::random::normal({10000, 1000});
+  mx::eval(a);
+  auto sum_all = [&a]() { return mx::sum(a, false); };
+  TIME(sum_all);
+
+  auto sum_along_0 = [&a]() { return mx::sum(a, 0, false); };
+  TIME(sum_along_0);
+
+  auto sum_along_1 = [&a]() { return mx::sum(a, 1, false); };
+  TIME(sum_along_1);
+
+  auto prod_all = [&a]() { return mx::prod(a, false); };
+  TIME(prod_all);
+
+  auto all_true = [&a]() { return mx::all(a, false); };
+  TIME(all_true);
+
+  auto all_along_0 = [&a]() { return mx::all(a, 0, false); };
+  TIME(all_along_0);
+
+  auto all_along_1 = [&a]() { return mx::all(a, 1, false); };
+  TIME(all_along_1);
+
+  auto any_true = [&a]() { return mx::any(a, false); };
+  TIME(any_true);
+
+  auto argmin_along_0 = [&a]() { return mx::argmin(a, 0, false); };
+  TIME(argmin_along_0);
+
+  auto argmin_along_1 = [&a]() { return mx::argmin(a, 1, false); };
+  TIME(argmin_along_1);
+
+  auto indices = mx::array({1});
+  auto updates = mx::reshape(mx::array({NAN}), {1, 1, 1});
+  std::vector<int> axes{0};
+  auto b = scatter(a, {indices}, updates, axes);
+  mx::eval(b);
+
+  auto max_along_0 = [&b]() { return mx::max(b, 0, false); };
+  TIME(max_along_0);
+  auto max_along_1 = [&b]() { return mx::max(b, 1, false); };
+  TIME(max_along_1);
+
+  auto min_along_0 = [&b]() { return mx::min(b, 0, false); };
+  TIME(min_along_0);
+  auto min_along_1 = [&b]() { return mx::min(b, 1, false); };
+  TIME(min_along_1);
+}
+
+void time_gather_scatter() {
+  auto a = mx::random::normal({1000, 768});
+  mx::eval(a);
+  auto indices = mx::random::randint(0, 1000, {256});
+  mx::eval(indices);
+
+  auto embedding_lookup = [&a, &indices]() { return mx::take(a, indices, 0); };
+  TIME(embedding_lookup);
+
+  indices = mx::random::randint(0, 768 * 1000, {256 * 768});
+  mx::eval(indices);
+
+  auto single_element_lookup = [&a, &indices]() {
+    return mx::take(a, indices);
+  };
+  TIME(single_element_lookup);
+
+  indices = mx::random::randint(0, 1000, {256});
+  auto updates = mx::random::normal({256, 1, 768});
+  mx::eval(indices, updates);
+
+  auto embedding_update = [&a, &indices, &updates]() {
+    return scatter(a, indices, updates, 0);
+  };
+  TIME(embedding_update);
+
+  auto embedding_add = [&a, &indices, &updates]() {
+    return scatter_add(a, indices, updates, 0);
+  };
+  TIME(embedding_add);
+
+  a = mx::reshape(a, {-1});
+  indices = mx::random::randint(0, 768 * 1000, {768 * 256});
+  updates = mx::random::normal({256 * 768, 1});
+  mx::eval(a, indices, updates);
+
+  auto single_element_update = [&a, &indices, &updates]() {
+    return scatter(a, indices, updates, 0);
+  };
+  TIME(single_element_update);
+
+  auto single_element_add = [&a, &indices, &updates]() {
+    return scatter_add(a, indices, updates, 0);
+  };
+  TIME(single_element_add);
+}
+
+void time_divmod() {
+  auto a = mx::random::normal({1000});
+  auto b = mx::random::normal({1000});
+  mx::eval({a, b});
+
+  auto divmod_fused = [&a, &b]() { return mx::divmod(a, b); };
+  TIME(divmod_fused);
+
+  auto divmod_separate = [&a, &b]() {
+    return std::vector<mx::array>{mx::floor_divide(a, b), mx::remainder(a, b)};
+  };
+  TIME(divmod_separate);
+}
+
+int main() {
+  std::cout << "Benchmarks for " << mx::default_device() << std::endl;
+  time_creation_ops();
+  time_type_conversions();
+  time_unary_ops();
+  time_binary_ops();
+  time_strided_ops();
+  time_random_generation();
+  time_comparisons();
+  time_matvec();
+  time_matmul();
+  time_reductions();
+  time_gather_scatter();
+  time_divmod();
+}
diff --git a/ml-stable-diffusion/mlx/benchmarks/cpp/time_utils.h b/ml-stable-diffusion/mlx/benchmarks/cpp/time_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf9d21a16d6fcc8fbc66e7e00f57494e998a090a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/cpp/time_utils.h
@@ -0,0 +1,39 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+
+#include "mlx/mlx.h"
+
+#define milliseconds(x) \
+  (std::chrono::duration_cast<std::chrono::nanoseconds>(x).count() / 1e6)
+#define time_now() std::chrono::high_resolution_clock::now()
+
+#define TIME(FUNC, ...)                                                        \
+  std::cout << "Timing " << #FUNC << " ... " << std::flush                     \
+            << std::setprecision(5) << time_fn(FUNC, ##__VA_ARGS__) << " msec" \
+            << std::endl;
+
+#define TIMEM(MSG, FUNC, ...)                                      \
+  std::cout << "Timing " << "(" << MSG << ") " << #FUNC << " ... " \
+            << std::flush << std::setprecision(5)                  \
+            << time_fn(FUNC, ##__VA_ARGS__) << " msec" << std::endl;
+
+template <typename F, typename... Args>
+double time_fn(F fn, Args&&... args) {
+  // warmup
+  for (int i = 0; i < 5; ++i) {
+    eval(fn(std::forward<Args>(args)...));
+  }
+
+  int num_iters = 100;
+  auto start = time_now();
+  for (int i = 0; i < num_iters; i++) {
+    eval(fn(std::forward<Args>(args)...));
+  }
+  auto end = time_now();
+  return milliseconds(end - start) / static_cast<double>(num_iters);
+}
diff --git a/ml-stable-diffusion/mlx/benchmarks/numpy/single_ops.py b/ml-stable-diffusion/mlx/benchmarks/numpy/single_ops.py
new file mode 100644
index 0000000000000000000000000000000000000000..390748130ddaa057e70874bebdbb850ad8250428
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/numpy/single_ops.py
@@ -0,0 +1,39 @@
+# Copyright © 2023 Apple Inc.
+
+import numpy as np
+from time_utils import time_fn
+
+
+def time_add():
+    a = np.ones((100, 100, 10), dtype=np.float32)
+    b = np.ones((100, 100, 10), dtype=np.float32)
+    time_fn(np.add, a, b)
+
+
+def time_matmul():
+    a = np.random.rand(1000, 500).astype(np.float32)
+    b = np.random.rand(500, 1000).astype(np.float32)
+    time_fn(np.matmul, a, b)
+
+
+def time_exp():
+    a = np.random.randn(1000, 100).astype(np.float32)
+    time_fn(np.exp, a)
+
+
+def time_take():
+    a = np.random.rand(10000, 500)
+    ids = np.random.randint(0, 10000, (20, 10))
+    ids = [idx.reshape(-1) for idx in np.split(ids, 20)]
+
+    def random_take():
+        return [np.take(a, idx, 0) for idx in ids]
+
+    time_fn(random_take)
+
+
+if __name__ == "__main__":
+    time_add()
+    time_matmul()
+    time_exp()
+    time_take()
diff --git a/ml-stable-diffusion/mlx/benchmarks/numpy/time_utils.py b/ml-stable-diffusion/mlx/benchmarks/numpy/time_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..163f007dcee33220fa72a1adc3d4d7d78887d1ae
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/numpy/time_utils.py
@@ -0,0 +1,20 @@
+# Copyright © 2023 Apple Inc.
+
+import time
+
+
+def time_fn(fn, *args):
+    print(f"Timing {fn.__name__} ...", end=" ")
+
+    # warmup
+    for _ in range(5):
+        fn(*args)
+
+    num_iters = 100
+    tic = time.perf_counter()
+    for _ in range(num_iters):
+        x = fn(*args)
+    toc = time.perf_counter()
+
+    msec = 1e3 * (toc - tic) / num_iters
+    print(f"{msec:.5f} msec")
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/batch_matmul_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/batch_matmul_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d822493b84cf69f4dbeb74c4611185ab5956aec
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/batch_matmul_bench.py
@@ -0,0 +1,62 @@
+# Copyright © 2023 Apple Inc.
+
+import argparse
+
+import mlx.core as mx
+from time_utils import time_fn
+
+B = 8
+T = 1024
+D = 512
+
+
+def time_batch_matmul():
+    mx.random.seed(3)
+    a = mx.random.uniform(shape=(B, T, D))
+    b = mx.random.uniform(shape=(D, D))
+    c = mx.random.uniform(shape=(B, T, D))
+    mx.eval(a, b, c)
+
+    time_fn(mx.matmul, a, b)
+
+    def batch_vjp_first():
+        return mx.vjp(mx.matmul, [a, b], [c])[1][0]
+
+    time_fn(batch_vjp_first)
+
+    def batch_vjp_second():
+        return mx.vjp(mx.matmul, [a, b], [c])[1][1]
+
+    time_fn(batch_vjp_second)
+
+
+def time_unbatch_matmul():
+    mx.random.seed(3)
+    a = mx.random.uniform(shape=(B * T, D))
+    b = mx.random.uniform(shape=(D, D))
+    c = mx.random.uniform(shape=(B * T, D))
+    mx.eval(a, b, c)
+    time_fn(mx.matmul, a, b)
+
+    def unbatch_vjp_first():
+        return mx.matmul(c, mx.transpose(b))
+
+    time_fn(unbatch_vjp_first)
+
+    def unbatch_vjp_second():
+        return mx.matmul(mx.transpose(a), c)
+
+    time_fn(unbatch_vjp_second)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser("MLX benchmarks.")
+    parser.add_argument("--gpu", action="store_true", help="Use the Metal back-end.")
+    args = parser.parse_args()
+    if args.gpu:
+        mx.set_default_device(mx.gpu)
+    else:
+        mx.set_default_device(mx.cpu)
+
+    time_batch_matmul()
+    time_unbatch_matmul()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/blas/bench_gemm.py b/ml-stable-diffusion/mlx/benchmarks/python/blas/bench_gemm.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee358a95d8fe23e85d9f3c2c842abb5ec3d13111
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/blas/bench_gemm.py
@@ -0,0 +1,191 @@
+# Copyright © 2023 Apple Inc.
+
+import argparse
+import math
+import os
+import subprocess
+import time
+
+import mlx.core as mx
+import numpy as np
+import torch
+
+device_name = subprocess.check_output(["sysctl", "-n", "machdep.cpu.brand_string"])
+device_name = device_name.decode("utf-8").strip("\n")
+
+N_warmup = 8
+N_iter_bench = 80
+N_iter_func = 5
+
+
+def bench(f, a, b):
+    for i in range(N_warmup):
+        f(a, b)
+    torch.mps.synchronize()
+
+    s = time.perf_counter_ns()
+    for i in range(N_iter_bench):
+        f(a, b)
+    e = time.perf_counter_ns()
+    return (e - s) * 1e-9
+
+
+def gemm_nn_mlx(a, b):
+    ys = []
+    for i in range(N_iter_func):
+        y = a @ b
+        ys.append(y)
+    mx.eval(ys)
+    return ys
+
+
+def gemm_nt_mlx(a, b):
+    ys = []
+    for i in range(N_iter_func):
+        y = a @ b.transpose((0, 2, 1))
+        ys.append(y)
+    mx.eval(ys)
+    return ys
+
+
+def gemm_tn_mlx(a, b):
+    ys = []
+    for i in range(N_iter_func):
+        y = a.transpose((0, 2, 1)) @ b
+        ys.append(y)
+    mx.eval(ys)
+    return ys
+
+
+def gemm_tt_mlx(a, b):
+    ys = []
+    for i in range(N_iter_func):
+        y = a.transpose((0, 2, 1)) @ b.transpose((0, 2, 1))
+        ys.append(y)
+    mx.eval(ys)
+    return ys
+
+
+@torch.no_grad()
+def gemm_nn_torch(a, b):
+    ys = []
+    for i in range(N_iter_func):
+        y = a @ b
+        ys.append(y)
+    torch.mps.synchronize()
+    return ys
+
+
+@torch.no_grad()
+def gemm_nt_torch(a, b):
+    ys = []
+    for i in range(N_iter_func):
+        y = a @ b.transpose(-1, -2)
+        ys.append(y)
+    torch.mps.synchronize()
+    return ys
+
+
+@torch.no_grad()
+def gemm_tn_torch(a, b):
+    ys = []
+    for i in range(N_iter_func):
+        y = a.transpose(-1, -2) @ b
+        ys.append(y)
+    torch.mps.synchronize()
+    return ys
+
+
+@torch.no_grad()
+def gemm_tt_torch(a, b):
+    ys = []
+    for i in range(N_iter_func):
+        y = a.transpose(-1, -2) @ b.transpose(-1, -2)
+        ys.append(y)
+    torch.mps.synchronize()
+    return ys
+
+
+def bench_shape(B, M, N, K, np_dtype, transpose="nn"):
+    shape_a = (B, M, K) if transpose[0] == "n" else (B, K, M)
+    shape_b = (B, K, N) if transpose[1] == "n" else (B, N, K)
+
+    a_np = np.random.normal(0.0, 1.0 / math.sqrt(M + K), shape_a).astype(np_dtype)
+    b_np = np.random.normal(0.0, 1.0 / math.sqrt(N + K), shape_b).astype(np_dtype)
+
+    a_mx = mx.array(a_np)
+    b_mx = mx.array(b_np)
+
+    a_pt = torch.from_numpy(a_np).to("mps")
+    b_pt = torch.from_numpy(b_np).to("mps")
+
+    torch.mps.synchronize()
+
+    f_mx = {
+        "nn": gemm_nn_mlx,
+        "nt": gemm_nt_mlx,
+        "tn": gemm_tn_mlx,
+        "tt": gemm_tt_mlx,
+    }[transpose]
+
+    f_pt = {
+        "nn": gemm_nn_torch,
+        "nt": gemm_nt_torch,
+        "tn": gemm_tn_torch,
+        "tt": gemm_tt_torch,
+    }[transpose]
+
+    time_torch = bench(f_pt, a_pt, b_pt)
+    time_mlx = bench(f_mx, a_mx, b_mx)
+
+    t_a = (0, 1, 2) if transpose[0] == "n" else (0, 2, 1)
+    t_b = (0, 1, 2) if transpose[1] == "n" else (0, 2, 1)
+
+    c_mlx = a_mx.transpose(t_a) @ b_mx.transpose(t_b)
+    c_npy = a_np.transpose(t_a).astype(np_dtype) @ b_np.transpose(t_b).astype(np_dtype)
+
+    atol = 1e-5 if np_dtype == np.float32 else 1e-4
+
+    if not np.allclose(c_mlx, c_npy.astype(np_dtype), atol=atol):
+        print(
+            f"Failed at {(B, M, N, K)} [transpose = {transpose}] with max(|a - b|) = {np.max(np.abs(c_npy - c_mlx))}"
+        )
+
+    return time_mlx, time_torch
+
+
+def get_gflop_count(B, M, N, K):
+    return float(2.0 * N_iter_bench * N_iter_func * B * M * N * K) / float(1024.0**3)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run gemm benchmarks")
+
+    dtypes = ("float32", "float16", "complex64")
+    transposes = ("nn", "nt", "tn")
+    shapes = (
+        (16, 234, 768, 3072),
+        (1, 64, 64, 25344),
+        (16, 1024, 1024, 1024),
+        (1, 1024, 1024, 2048),
+        (4, 1024, 1024, 4096),
+        (4, 1024, 4096, 1024),
+        (1, 4096, 4096, 4096),
+    )
+
+    for dtype in dtypes:
+        for transpose in transposes:
+            for B, M, N, K in shapes:
+                np_dtype = getattr(np, dtype)
+                time_mlx, time_torch = bench_shape(B, M, N, K, np_dtype, transpose)
+
+                gflop_count = get_gflop_count(B, M, N, K)
+                gflops_mx = gflop_count / (time_mlx)
+                gflops_pt = gflop_count / (time_torch)
+                diff = gflops_mx / gflops_pt - 1.0
+
+                print(
+                    f"{B:3d}, {M:4d}, {N:4d}, {K:4d}, {dtype}, {transpose}, {gflops_pt:05.3f}, {gflops_mx:05.3f}, {100.0 * diff:+5.2f}%"
+                )
+                if gflops_pt >= 2.0 * gflops_mx:
+                    print("ATTENTION ^^^^^^^")
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/blas/bench_gemv.py b/ml-stable-diffusion/mlx/benchmarks/python/blas/bench_gemv.py
new file mode 100644
index 0000000000000000000000000000000000000000..01a4339c739e01a20ffae7dcd876a6f1e4906923
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/blas/bench_gemv.py
@@ -0,0 +1,221 @@
+# Copyright © 2023 Apple Inc.
+
+import argparse
+import os
+import subprocess
+import time
+
+import matplotlib.pyplot as plt
+import mlx.core as mx
+import numpy as np
+import torch
+
+results_dir = "./results"
+
+if not os.path.isdir(results_dir):
+    os.mkdir(results_dir)
+
+device_name = subprocess.check_output(["sysctl", "-n", "machdep.cpu.brand_string"])
+device_name = device_name.decode("utf-8").strip("\n")
+
+N_warmup = 5
+N_iter_bench = 50
+N_iter_func = 20
+
+out_vec_sizes = [128, 512, 2048, 4096]
+in_vec_sizes = [128, 512, 2048, 4096]
+
+benchmark_vector_lens = []
+benchmark_vector_lens += [(i + 1) * 4096 for i in range(8)][::2]
+benchmark_vector_lens += [(i + 1) * 4095 for i in range(8)][::2]
+benchmark_vector_lens += [(i + 1) * 4097 for i in range(8)][::2]
+benchmark_vector_lens += [64, 128, 512, 1024, 2048, 11008, 32000]
+
+benchmark_vector_lens.sort()
+
+
+def bench(f, m, v):
+    for i in range(N_warmup):
+        f(m, v)
+    torch.mps.synchronize()
+
+    s = time.perf_counter_ns()
+    for i in range(N_iter_bench):
+        f(m, v)
+    e = time.perf_counter_ns()
+    return (e - s) * 1e-9
+
+
+def gemv_mlx(m, v):
+    ys = []
+    for i in range(N_iter_func):
+        y = m @ v
+        ys.append(y)
+    mx.eval(ys)
+    return ys
+
+
+def gemv_t_mlx(m, v):
+    ys = []
+    for i in range(N_iter_func):
+        y = v @ m
+        ys.append(y)
+    mx.eval(ys)
+    return ys
+
+
+@torch.no_grad()
+def gemv_torch(m, v):
+    ys = []
+    for i in range(N_iter_func):
+        y = m @ v
+        ys.append(y)
+    torch.mps.synchronize()
+    return ys
+
+
+@torch.no_grad()
+def gemv_t_torch(m, v):
+    ys = []
+    for i in range(N_iter_func):
+        y = v @ m
+        ys.append(y)
+    torch.mps.synchronize()
+    return ys
+
+
+def bench_lens(in_vec_len, out_vec_len, np_dtype, transpose=False):
+    shape_mat = (in_vec_len, out_vec_len) if transpose else (out_vec_len, in_vec_len)
+    shape_vec = (1, in_vec_len) if transpose else (in_vec_len, 1)
+
+    mat_npy = np.random.normal(0.0, 2.0 / in_vec_len, shape_mat).astype(np_dtype)
+    vec_npy = np.random.normal(0.0, 2.0 / in_vec_len, shape_vec).astype(np_dtype)
+    mat_mlx = mx.array(mat_npy)
+    vec_mlx = mx.array(vec_npy)
+    mat_trc = torch.from_numpy(mat_npy).to("mps")
+    vec_trc = torch.from_numpy(vec_npy).to("mps")
+
+    torch.mps.synchronize()
+
+    time_torch = (
+        bench(gemv_t_torch, mat_trc, vec_trc)
+        if transpose
+        else bench(gemv_torch, mat_trc, vec_trc)
+    )
+    time_mlx = (
+        bench(gemv_t_mlx, mat_mlx, vec_mlx)
+        if transpose
+        else bench(gemv_mlx, mat_mlx, vec_mlx)
+    )
+
+    c_mlx = (
+        np.asarray(vec_mlx @ mat_mlx) if transpose else np.asarray(mat_mlx @ vec_mlx)
+    )
+    c_npy = (vec_npy @ mat_npy) if transpose else (mat_npy @ vec_npy)
+
+    if not np.allclose(c_mlx, c_npy, atol=2e-5):
+        print(
+            f"Failed at {shape_mat} [transpose = {transpose}] with max(|a - b|) = {np.max(np.abs(c_npy - c_mlx))}"
+        )
+
+    return time_mlx, time_torch
+
+
+def get_gflop_count(in_vec_len, out_vec_len):
+    return float(2.0 * N_iter_bench * N_iter_func * in_vec_len * out_vec_len) / float(
+        1024**3
+    )
+
+
+def get_gbyte_size(in_vec_len, out_vec_len, np_dtype):
+    n_elem = in_vec_len * out_vec_len + in_vec_len + out_vec_len
+    item_size = 4 if np_dtype == np.float32 else 2
+    return float(N_iter_bench * N_iter_func * n_elem * item_size) / float(1024**3)
+
+
+def bench_with_in_len(ax, in_vec_len, out_vector_lens, dtype, transpose):
+    np_dtype = getattr(np, dtype)
+    mlx_gb_s = []
+    mlx_gflops = []
+    pyt_gb_s = []
+    pyt_gflops = []
+
+    for out_vec_len in out_vector_lens:
+        gflop_count = get_gflop_count(in_vec_len, out_vec_len)
+        gbyte_size = get_gbyte_size(in_vec_len, out_vec_len, np_dtype)
+
+        time_mlx, time_torch = bench_lens(in_vec_len, out_vec_len, np_dtype, transpose)
+
+        mlx_gb_s.append(gbyte_size / time_mlx)
+        pyt_gb_s.append(gbyte_size / time_torch)
+
+        mlx_gflops.append(gflop_count / time_mlx)
+        pyt_gflops.append(gflop_count / time_torch)
+
+    if transpose:
+        title = f"gemv_t ([1, {in_vec_len}] [{in_vec_len}, out_vec_len]) | {dtype}"
+    else:
+        title = f"gemv ([out_vec_len, {in_vec_len}] X [{in_vec_len}, 1] ) | {dtype}"
+
+    ax.plot(out_vector_lens, mlx_gb_s, "tab:blue", label="MLX")
+    ax.plot(out_vector_lens, pyt_gb_s, "tab:red", label="Torch")
+    ax.set_title(title)
+    ax.set(xlabel="out_vector_len", ylabel="Performance (GB/s)")
+    ax.legend()
+
+
+def bench_with_out_len(ax, out_vec_len, in_vector_lens, dtype, transpose):
+    np_dtype = getattr(np, dtype)
+    mlx_gb_s = []
+    mlx_gflops = []
+    pyt_gb_s = []
+    pyt_gflops = []
+
+    for in_vec_len in in_vector_lens:
+        gflop_count = get_gflop_count(in_vec_len, out_vec_len)
+        gbyte_size = get_gbyte_size(in_vec_len, out_vec_len, np_dtype)
+
+        time_mlx, time_torch = bench_lens(in_vec_len, out_vec_len, np_dtype, transpose)
+
+        mlx_gb_s.append(gbyte_size / time_mlx)
+        pyt_gb_s.append(gbyte_size / time_torch)
+
+        mlx_gflops.append(gflop_count / time_mlx)
+        pyt_gflops.append(gflop_count / time_torch)
+
+    if transpose:
+        title = f"([1, in_vec_len] [in_vec_len, {out_vec_len}])"
+    else:
+        title = f"([{out_vec_len}, in_vec_len] X [in_vec_len, 1] )"
+
+    ax.plot(in_vector_lens, mlx_gb_s, "tab:blue", label="MLX")
+    ax.plot(in_vector_lens, pyt_gb_s, "tab:red", label="Torch")
+    ax.set_title(title)
+    ax.set(xlabel="in_vector_len", ylabel="Performance (GB/s)")
+    ax.legend()
+
+
+for transpose in (False, True):
+    for dtype in ("float32", "float16", "complex64"):
+        fig, axs = plt.subplots(
+            len(in_vec_sizes), 2, figsize=(8.5, 11), layout="constrained"
+        )
+
+        for i, in_vec_len in enumerate(in_vec_sizes):
+            bench_with_in_len(
+                axs[i][0], in_vec_len, benchmark_vector_lens, dtype, transpose
+            )
+
+        for i, out_vec_len in enumerate(out_vec_sizes):
+            bench_with_out_len(
+                axs[i][1], out_vec_len, benchmark_vector_lens, dtype, transpose
+            )
+
+        op_name = "gemv_t" if transpose else "gemv"
+        fig.suptitle(f"{device_name}: {dtype} {op_name}")
+        fig.savefig(
+            os.path.join(
+                results_dir, f"{device_name.replace(' ', '_')}_{dtype}_{op_name}.pdf"
+            )
+        )
+        plt.close(fig)
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/comparative/README.md b/ml-stable-diffusion/mlx/benchmarks/python/comparative/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..dc0e8306a7d801e17265936f09c2427516868e03
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/comparative/README.md
@@ -0,0 +1,15 @@
+Microbenchmarks comparing MLX to PyTorch
+========================================
+
+Implement the same microbenchmarks in MLX and PyTorch to compare and make a
+list of the biggest possible performance improvements and/or regressions.
+
+Run with `python bench_mlx.py sum_axis --size 8x1024x128 --axis 2 --cpu` for
+instance to measure the times it takes to sum across the 3rd axis of the above
+tensor on the cpu.
+
+`compare.py` runs several benchmarks and compares the speed-up or lack thereof
+in comparison to PyTorch.
+
+Each bench script can be run with `--print-pid` to print the PID and wait for a
+key in order to ease attaching a debugger.
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/comparative/bench_mlx.py b/ml-stable-diffusion/mlx/benchmarks/python/comparative/bench_mlx.py
new file mode 100644
index 0000000000000000000000000000000000000000..0821ccae68d6138a88e18669243c521e83d2f863
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/comparative/bench_mlx.py
@@ -0,0 +1,519 @@
+# Copyright © 2023 Apple Inc.
+
+import argparse
+import math
+import os
+import time
+from functools import partial
+
+import mlx.core as mx
+import mlx.nn as nn
+
+
+def int_or_list(x):
+    try:
+        return int(x)
+    except ValueError:
+        return [int(xi) for xi in x.split(",")]
+
+
+def none_or_list(x):
+    if x == "":
+        return None
+    else:
+        return [int(xi) for xi in x.split(",")]
+
+
+def dtype_from_str(x):
+    if x == "":
+        return mx.float32
+    else:
+        dt = getattr(mx, x)
+        if not isinstance(dt, mx.Dtype):
+            raise ValueError(f"{x} is not an mlx dtype")
+        return dt
+
+
+def bench(f, *args):
+    for i in range(10):
+        f(*args)
+
+    s = time.time()
+    for i in range(100):
+        f(*args)
+    e = time.time()
+    return e - s
+
+
+def matmul_square(x):
+    y = x
+    for i in range(10):
+        y = y @ x
+    mx.eval(y)
+    return y
+
+
+def matmul(x, y):
+    ys = []
+    for i in range(10):
+        ys.append(x @ y)
+    mx.eval(ys)
+
+
+def _quant_matmul(x, w, s, b, transpose, group_size, bits):
+    ys = []
+    for i in range(10):
+        ys.append(
+            mx.quantized_matmul(
+                x, w, s, b, transpose=transpose, group_size=group_size, bits=bits
+            )
+        )
+    mx.eval(ys)
+
+
+quant_matmul = {
+    "quant_matmul_32_2": partial(_quant_matmul, transpose=False, group_size=32, bits=2),
+    "quant_matmul_32_4": partial(_quant_matmul, transpose=False, group_size=32, bits=4),
+    "quant_matmul_32_8": partial(_quant_matmul, transpose=False, group_size=32, bits=8),
+    "quant_matmul_64_2": partial(_quant_matmul, transpose=False, group_size=64, bits=2),
+    "quant_matmul_64_4": partial(_quant_matmul, transpose=False, group_size=64, bits=4),
+    "quant_matmul_64_8": partial(_quant_matmul, transpose=False, group_size=64, bits=8),
+    "quant_matmul_128_2": partial(
+        _quant_matmul, transpose=False, group_size=128, bits=2
+    ),
+    "quant_matmul_128_4": partial(
+        _quant_matmul, transpose=False, group_size=128, bits=4
+    ),
+    "quant_matmul_128_8": partial(
+        _quant_matmul, transpose=False, group_size=128, bits=8
+    ),
+    "quant_matmul_t_32_2": partial(
+        _quant_matmul, transpose=True, group_size=32, bits=2
+    ),
+    "quant_matmul_t_32_4": partial(
+        _quant_matmul, transpose=True, group_size=32, bits=4
+    ),
+    "quant_matmul_t_32_8": partial(
+        _quant_matmul, transpose=True, group_size=32, bits=8
+    ),
+    "quant_matmul_t_64_2": partial(
+        _quant_matmul, transpose=True, group_size=64, bits=2
+    ),
+    "quant_matmul_t_64_4": partial(
+        _quant_matmul, transpose=True, group_size=64, bits=4
+    ),
+    "quant_matmul_t_64_8": partial(
+        _quant_matmul, transpose=True, group_size=64, bits=8
+    ),
+    "quant_matmul_t_128_2": partial(
+        _quant_matmul, transpose=True, group_size=128, bits=2
+    ),
+    "quant_matmul_t_128_4": partial(
+        _quant_matmul, transpose=True, group_size=128, bits=4
+    ),
+    "quant_matmul_t_128_8": partial(
+        _quant_matmul, transpose=True, group_size=128, bits=8
+    ),
+}
+
+
+def conv1d(x, y):
+    ys = []
+    for i in range(10):
+        ys.append(mx.conv1d(x, y))
+    mx.eval(ys)
+
+
+def conv2d(x, y):
+    ys = []
+    for i in range(10):
+        ys.append(mx.conv2d(x, y))
+    mx.eval(ys)
+
+
+def binary(op, x, y):
+    for i in range(100):
+        y = getattr(mx, op)(x, y)
+    mx.eval(y)
+
+
+def reduction(op, axis, x):
+    ys = []
+    for i in range(100):
+        ys.append(getattr(mx, op)(x, axis=axis))
+    mx.eval(ys)
+
+
+def sum_and_add(axis, x, y):
+    z = x.sum(axis=axis, keepdims=True)
+    for i in range(50):
+        z = (z + y).sum(axis=axis, keepdims=True)
+    mx.eval(z)
+
+
+def softmax(axis, x):
+    ys = []
+    for i in range(100):
+        ex = mx.exp(x - mx.max(x, axis=axis, keepdims=True))
+        y = ex / mx.sum(ex, axis=axis, keepdims=True)
+        ys.append(y)
+    mx.eval(ys)
+
+
+def softmax_fused(axis, x):
+    ys = []
+    for i in range(100):
+        y = mx.softmax(x, axis=axis)
+        ys.append(y)
+    mx.eval(ys)
+
+
+def relu(x):
+    y = x
+    for i in range(100):
+        y = nn.relu(y)
+    mx.eval(y)
+
+
+def leaky_relu(x: mx.array):
+    y = x
+    for i in range(100):
+        y = nn.leaky_relu(y)
+    mx.eval(y)
+
+
+def prelu(x: mx.array):
+    y = x
+    for i in range(100):
+        y = nn.prelu(y, mx.ones(1))
+    mx.eval(y)
+
+
+def softplus(x: mx.array):
+    y = x
+    for i in range(100):
+        y = nn.softplus(y)
+    mx.eval(y)
+
+
+def mish(x: mx.array):
+    y = x
+    for i in range(100):
+        y = nn.mish(y)
+    mx.eval(y)
+
+
+def leaky_relu(x):
+    y = x
+    for i in range(100):
+        y = nn.leaky_relu(y)
+    mx.eval(y)
+
+
+def elu(x):
+    y = x
+    for i in range(100):
+        y = nn.elu(y)
+    mx.eval(y)
+
+
+def relu6(x):
+    y = x
+    for i in range(100):
+        y = nn.relu6(y)
+    mx.eval(y)
+
+
+def softplus(x):
+    y = x
+    for i in range(100):
+        y = nn.softplus(y)
+    mx.eval(y)
+
+
+def celu(x):
+    y = x
+    for i in range(100):
+        y = nn.celu(y)
+    mx.eval(y)
+
+
+def log_sigmoid(x):
+    y = x
+    for i in range(100):
+        y = nn.log_sigmoid(y)
+    mx.eval(y)
+
+
+def scalar_mult(x):
+    y = x
+    for i in range(100):
+        y = y * (1.0 / (1 + i))
+    mx.eval(y)
+
+
+def cross_entropy(targets, x):
+    ys = []
+    for i in range(100):
+        y = mx.logsumexp(x, axis=-1, keepdims=True) - mx.take_along_axis(
+            x, mx.reshape(targets, (-1, 1)), axis=-1
+        )
+        ys.append(mx.mean(y))
+    mx.eval(ys)
+
+
+def logsumexp(axis, x):
+    ys = []
+    for i in range(100):
+        ys.append(mx.logsumexp(x, axis=axis))
+    mx.eval(ys)
+
+
+def linear(w, b, x):
+    ys = []
+    for i in range(10):
+        ys.append(x @ mx.transpose(w, (1, 0)) + b)
+    mx.eval(ys)
+
+
+def linear_fused(w, b, x):
+    ys = []
+    for i in range(10):
+        ys.append(mx.addmm(b, x, mx.transpose(w, (1, 0))))
+    mx.eval(ys)
+
+
+def rope(x):
+    *_, N, D = x.shape
+    ys = []
+    for i in range(10):
+        shape = x.shape
+        x = mx.reshape(x, (-1, N, D))
+        positions = mx.arange(N)
+        freqs = mx.exp(mx.arange(0.0, D // 2) / math.log(10000 / (D // 2 - 1)))
+        theta = mx.reshape(positions, (-1, 1)) * mx.reshape(freqs, (1, -1))
+        costheta = mx.cos(theta)
+        sintheta = mx.sin(theta)
+        x1 = x[..., ::2]
+        x2 = x[..., 1::2]
+        rx1 = x1 * costheta - x2 * sintheta
+        rx2 = x1 * sintheta + x2 * costheta
+        y = mx.concatenate([rx1[..., None], rx2[..., None]], axis=-1)
+        y = mx.reshape(y, (-1, N, D))
+        ys.append(y)
+    mx.eval(ys)
+
+
+def concatenate(axis, x, y):
+    ys = []
+    for i in range(10):
+        ys.append(mx.concatenate([x, y], axis=axis))
+    mx.eval(ys)
+
+
+def cumsum(axis, x):
+    ys = []
+    for i in range(10):
+        ys.append(mx.cumsum(x, axis))
+    mx.eval(ys)
+
+
+def sort(axis, x):
+    ys = []
+    for i in range(10):
+        ys.append(mx.sort(x, axis))
+    mx.eval(ys)
+
+
+def topk(axis, x):
+    k = x.shape[axis] // 3
+    ys = []
+    for i in range(10):
+        ys.append(mx.topk(x, k, axis))
+    mx.eval(ys)
+
+
+def step_function(x):
+    y = x
+    for i in range(100):
+        y = nn.step(x)
+    mx.eval(y)
+
+
+def selu(x):
+    y = x
+    for i in range(100):
+        y = nn.selu(x)
+    mx.eval(y)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("benchmark", help="Choose the benchmark to run")
+    parser.add_argument(
+        "--size",
+        default=[(1024, 1024)],
+        type=lambda x: list(map(int, x.split("x"))),
+        help="Set the matrix size",
+        action="append",
+    )
+    parser.add_argument(
+        "--axis",
+        default=[1],
+        type=int_or_list,
+        help="Set a reduction axis",
+        action="append",
+    )
+    parser.add_argument(
+        "--transpose",
+        type=none_or_list,
+        default=[],
+        help="Permute the matrix",
+        action="append",
+    )
+    parser.add_argument(
+        "--print-pid", action="store_true", help="Print the PID and pause"
+    )
+    parser.add_argument("--cpu", action="store_true", help="Use the CPU")
+    parser.add_argument(
+        "--fused", action="store_true", help="Use fused functions where possible"
+    )
+    parser.add_argument("--dtype", type=dtype_from_str, default=[], action="append")
+
+    args = parser.parse_args()
+
+    if len(args.size) > 1:
+        args.size.pop(0)
+    if len(args.axis) > 1:
+        args.axis.pop(0)
+
+    if args.cpu:
+        mx.set_default_device(mx.cpu)
+    else:
+        mx.set_default_device(mx.gpu)
+
+    types = args.dtype
+    if not types:
+        types = [mx.float32]
+    if len(types) < len(args.size):
+        types = types + [types[0]] * (len(args.size) - len(types))
+
+    xs = []
+    for size, dtype in zip(args.size, types):
+        xs.append(mx.random.normal(size).astype(dtype))
+    for i, t in enumerate(args.transpose):
+        if t is None:
+            continue
+        xs[i] = mx.transpose(xs[i], t)
+    mx.eval(xs)
+    x = xs[0]
+    axis = args.axis[0]
+
+    if args.print_pid:
+        print(os.getpid())
+        input("Press enter to run")
+
+    if args.benchmark == "matmul_square":
+        print(bench(matmul_square, x))
+
+    elif args.benchmark == "matmul":
+        print(bench(matmul, *xs))
+
+    elif args.benchmark.startswith("quant_matmul"):
+        print(bench(quant_matmul[args.benchmark], *xs))
+
+    elif args.benchmark == "linear":
+        if args.fused:
+            print(bench(linear_fused, *xs))
+        else:
+            print(bench(linear, *xs))
+
+    elif args.benchmark == "sum_axis":
+        print(bench(reduction, "sum", axis, x))
+
+    elif args.benchmark == "sum_all":
+        print(bench(reduction, "sum", None, x))
+
+    elif args.benchmark == "argmax":
+        print(bench(reduction, "argmax", axis, x))
+
+    elif args.benchmark == "add":
+        print(bench(binary, "add", *xs))
+
+    elif args.benchmark == "mul":
+        print(bench(binary, "multiply", *xs))
+
+    elif args.benchmark == "softmax":
+        if args.fused:
+            print(bench(softmax_fused, axis, x))
+        else:
+            print(bench(softmax, axis, x))
+
+    elif args.benchmark == "relu":
+        print(bench(relu, x))
+
+    elif args.benchmark == "elu":
+        print(bench(elu, x))
+
+    elif args.benchmark == "relu6":
+        print(bench(relu6, x))
+
+    elif args.benchmark == "celu":
+        print(bench(celu, x))
+
+    elif args.benchmark == "log_sigmoid":
+        print(bench(log_sigmoid, x))
+
+    elif args.benchmark == "leaky_relu":
+        print(bench(leaky_relu, x))
+    elif args.benchmark == "prelu":
+        print(bench(prelu, x))
+    elif args.benchmark == "softplus":
+        print(bench(softplus, x))
+    elif args.benchmark == "mish":
+        print(bench(mish, x))
+    elif args.benchmark == "scalar_mul":
+        print(bench(scalar_mult, x))
+
+    elif args.benchmark == "cross_entropy":
+        if len(size) != 2:
+            raise ValueError("Error: [cross_entropy] benchmark requires a 2 dim size")
+
+        targets = mx.zeros((len(x),), dtype=mx.uint32)
+        print(bench(cross_entropy, targets, x))
+
+    elif args.benchmark == "logsumexp":
+        print(bench(logsumexp, axis, x))
+
+    elif args.benchmark == "rope":
+        print(bench(rope, x))
+
+    elif args.benchmark == "concatenate":
+        print(bench(concatenate, axis, *xs))
+
+    elif args.benchmark == "cumsum":
+        print(bench(cumsum, axis, *xs))
+
+    elif args.benchmark == "conv1d":
+        print(bench(conv1d, *xs))
+
+    elif args.benchmark == "conv2d":
+        print(bench(conv2d, *xs))
+
+    elif args.benchmark == "sort":
+        print(bench(sort, axis, x))
+
+    elif args.benchmark == "topk":
+        print(bench(topk, axis, x))
+
+    elif args.benchmark == "step":
+        print(bench(step_function, x))
+
+    elif args.benchmark == "selu":
+        print(bench(selu, x))
+
+    elif args.benchmark == "sum_and_add":
+        print(bench(sum_and_add, axis, *xs))
+
+    else:
+        raise ValueError("Unknown benchmark")
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/comparative/bench_torch.py b/ml-stable-diffusion/mlx/benchmarks/python/comparative/bench_torch.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd3436d9ab73d419caf353920f7b7291d486f806
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/comparative/bench_torch.py
@@ -0,0 +1,482 @@
+# Copyright © 2023 Apple Inc.
+
+import argparse
+import os
+import time
+
+import torch
+import torch.cuda
+import torch.mps
+
+
+def int_or_list(x):
+    try:
+        return int(x)
+    except ValueError:
+        return [int(xi) for xi in x.split(",")]
+
+
+def none_or_list(x):
+    if x == "":
+        return None
+    else:
+        return [int(xi) for xi in x.split(",")]
+
+
+def dtype_from_str(x):
+    if x == "":
+        return torch.float32
+    else:
+        dt = getattr(torch, x)
+        if not isinstance(dt, torch.dtype):
+            raise ValueError(f"{x} is not a torch dtype")
+        return dt
+
+
+def bench(f, *args):
+    for i in range(10):
+        f(*args)
+
+    s = time.time()
+    for i in range(100):
+        f(*args)
+    e = time.time()
+    return e - s
+
+
+def sync_if_needed(x):
+    if x.device == torch.device("mps"):
+        torch.mps.synchronize()
+    elif x.device == torch.device("cuda"):
+        torch.cuda.synchronize()
+
+
+@torch.no_grad()
+def matmul_square(x):
+    y = x
+    for i in range(10):
+        y = y @ x
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def matmul(x, y):
+    ys = []
+    for i in range(10):
+        ys.append(x @ y)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def conv1d(x, y):
+    x = torch.transpose(x, -1, -2)
+    y = torch.transpose(y, -1, -2)
+    ys = []
+    for i in range(10):
+        ys.append(torch.nn.functional.conv1d(x, y))
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def conv2d(x, y):
+    x = torch.permute(x, (0, 3, 1, 2))
+    y = torch.permute(y, (0, 3, 1, 2))
+    ys = []
+    for i in range(10):
+        ys.append(torch.nn.functional.conv2d(x, y))
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def binary(op, x, y):
+    for i in range(100):
+        y = getattr(torch, op)(x, y)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def reduction(op, axis, x):
+    ys = []
+    for i in range(100):
+        ys.append(getattr(x, op)(axis))
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def sum_and_add(axis, x, y):
+    z = x.sum(axis=axis, keepdims=True)
+    for i in range(50):
+        z = (z + y).sum(axis=axis, keepdims=True)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def softmax(axis, x):
+    ys = []
+    for i in range(100):
+        ex = torch.exp(x - torch.max(x, dim=axis, keepdims=True).values)
+        y = ex / torch.sum(ex, dim=axis, keepdims=True)
+        ys.append(y)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def softmax_fused(axis, x):
+    ys = []
+    for i in range(100):
+        ys.append(torch.nn.functional.softmax(x, dim=axis))
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def relu(x):
+    y = x
+    for i in range(100):
+        y = torch.nn.functional.relu(y)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def leaky_relu(x):
+    y = x
+    for i in range(100):
+        y = torch.nn.functional.leaky_relu(y)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def elu(x):
+    y = x
+    for i in range(100):
+        y = torch.nn.functional.elu(y)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def celu(x):
+    y = x
+    for i in range(100):
+        y = torch.nn.functional.celu(y)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def relu6(x):
+    y = x
+    for i in range(100):
+        y = torch.nn.functional.relu6(y)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def softplus(x):
+    y = x
+    for i in range(100):
+        y = torch.nn.functional.softplus(y)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def log_sigmoid(x):
+    y = x
+    for i in range(100):
+        y = torch.nn.functional.logsigmoid(y)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def prelu(x: torch.Tensor) -> torch.Tensor:
+    y = x
+    for _ in range(100):
+        y = torch.nn.functional.prelu(y, torch.ones(1).to(y.device))
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def mish(x: torch.Tensor) -> torch.Tensor:
+    y = x
+    for _ in range(100):
+        y = torch.nn.functional.mish(y)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def scalar_mult(x):
+    y = x
+    for i in range(100):
+        y = y * (1.0 / (1 + i))
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def cross_entropy(targets, x):
+    ys = []
+    for i in range(100):
+        ys.append(torch.nn.functional.cross_entropy(x, targets))
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def logsumexp(axis, x):
+    ys = []
+    for i in range(100):
+        ys.append(torch.logsumexp(x, dim=axis))
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def linear_fused(w, b, x):
+    ys = []
+    for i in range(10):
+        ys.append(torch.nn.functional.linear(x, w, b))
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def linear(w, b, x):
+    ys = []
+    for i in range(10):
+        ys.append((x @ torch.transpose(w, -2, -1)) + b)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def rope(x):
+    *_, N, D = x.shape
+    ys = []
+    for i in range(10):
+        x = x.view(-1, N, D)
+        positions = torch.arange(N, device=x.device)
+        freqs = 10000 ** torch.linspace(0, 1, D // 2, device=x.device)
+        theta = positions[:, None] * freqs[None]
+        costheta = torch.cos(theta)
+        sintheta = torch.sin(theta)
+        x1 = x[..., ::2]
+        x2 = x[..., 1::2]
+        rx1 = x1 * costheta - x2 * sintheta
+        rx2 = x1 * sintheta + x2 * costheta
+        y = torch.cat([rx1[..., None], rx2[..., None]], dim=-1)
+        y = y.reshape(-1, N, D)
+        ys.append(y)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def concatenate(axis, x, y):
+    ys = []
+    for i in range(10):
+        ys.append(torch.cat([x, y], dim=axis))
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def cumsum(axis, x):
+    ys = []
+    for i in range(10):
+        ys.append(x.cumsum(axis))
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def sort(axis, x):
+    ys = []
+    for i in range(10):
+        ys.append(torch.sort(x, dim=axis)[0])
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def topk(axis, x):
+    k = x.shape[axis] // 3
+    ys = []
+    for i in range(10):
+        ys.append(torch.topk(x, k, dim=axis)[0])
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def step_function(x):
+    y = x
+    for i in range(100):
+        y = torch.where(y < 0, 0, 1)
+    sync_if_needed(x)
+
+
+@torch.no_grad()
+def selu(x):
+    y = x
+    for i in range(100):
+        y = torch.nn.functional.selu(y)
+    sync_if_needed(x)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("benchmark", help="Choose the benchmark to run")
+    parser.add_argument(
+        "--size",
+        default=[(1024, 1024)],
+        type=lambda x: list(map(int, x.split("x"))),
+        help="Set the matrix size",
+        action="append",
+    )
+    parser.add_argument(
+        "--axis",
+        default=[1],
+        type=int_or_list,
+        help="Set a reduction axis",
+        action="append",
+    )
+    parser.add_argument(
+        "--transpose",
+        type=none_or_list,
+        default=[],
+        help="Permute the matrix",
+        action="append",
+    )
+    parser.add_argument(
+        "--print-pid", action="store_true", help="Print the PID and pause"
+    )
+    parser.add_argument("--cpu", action="store_true", help="Use the CPU")
+    parser.add_argument(
+        "--fused", action="store_true", help="Use fused functions where possible"
+    )
+    parser.add_argument("--dtype", type=dtype_from_str, default=[], action="append")
+
+    args = parser.parse_args()
+
+    if len(args.size) > 1:
+        args.size.pop(0)
+    if len(args.axis) > 1:
+        args.axis.pop(0)
+
+    torch.set_num_threads(1)
+    device = "mps"
+    if torch.cuda.is_available():
+        device = "cuda"
+    if args.cpu:
+        device = "cpu"
+
+    types = args.dtype
+    if not types:
+        types = [torch.float32]
+    if len(types) < len(args.size):
+        types = types + [types[0]] * (len(args.size) - len(types))
+
+    xs = []
+    for size, dtype in zip(args.size, types):
+        xs.append(torch.randn(*size).to(device).to(dtype))
+    for i, t in enumerate(args.transpose):
+        if t is None:
+            continue
+        xs[i] = xs[i].permute(*t)
+    x = xs[0]
+    axis = args.axis[0]
+
+    if args.print_pid:
+        print(os.getpid())
+        input("Press enter to run")
+
+    if args.benchmark == "matmul_square":
+        print(bench(matmul_square, x))
+
+    elif args.benchmark == "matmul":
+        print(bench(matmul, *xs))
+
+    elif args.benchmark == "linear":
+        if args.fused:
+            print(bench(linear_fused, *xs))
+        else:
+            print(bench(linear, *xs))
+
+    elif args.benchmark == "sum_axis":
+        print(bench(reduction, "sum", axis, x))
+
+    elif args.benchmark == "sum_all":
+        print(bench(reduction, "sum", None, x))
+
+    elif args.benchmark == "argmax":
+        print(bench(reduction, "argmax", axis, x))
+
+    elif args.benchmark == "add":
+        print(bench(binary, "add", *xs))
+
+    elif args.benchmark == "mul":
+        print(bench(binary, "mul", *xs))
+
+    elif args.benchmark == "softmax":
+        if args.fused:
+            print(bench(softmax_fused, axis, x))
+        else:
+            print(bench(softmax, axis, x))
+
+    elif args.benchmark == "relu":
+        print(bench(relu, x))
+
+    elif args.benchmark == "leaky_relu":
+        print(bench(leaky_relu, x))
+
+    elif args.benchmark == "elu":
+        print(bench(elu, x))
+
+    elif args.benchmark == "relu6":
+        print(bench(relu6, x))
+
+    elif args.benchmark == "softplus":
+        print(bench(softplus, x))
+
+    elif args.benchmark == "celu":
+        print(bench(celu, x))
+
+    elif args.benchmark == "log_sigmoid":
+        print(bench(log_sigmoid, x))
+
+    elif args.benchmark == "prelu":
+        print(bench(prelu, x))
+    elif args.benchmark == "mish":
+        print(bench(mish, x))
+    elif args.benchmark == "scalar_mul":
+        print(bench(scalar_mult, x))
+
+    elif args.benchmark == "cross_entropy":
+        if len(size) != 2:
+            raise ValueError("Error: [cross_entropy] benchmark requires a 2 dim size")
+
+        targets = torch.zeros(len(x), dtype=torch.long).to(x.device)
+        print(bench(cross_entropy, targets, x))
+
+    elif args.benchmark == "logsumexp":
+        print(bench(logsumexp, axis, x))
+
+    elif args.benchmark == "rope":
+        print(bench(rope, x))
+
+    elif args.benchmark == "concatenate":
+        print(bench(concatenate, axis, *xs))
+
+    elif args.benchmark == "cumsum":
+        print(bench(cumsum, axis, *xs))
+
+    elif args.benchmark == "conv1d":
+        print(bench(conv1d, *xs))
+
+    elif args.benchmark == "conv2d":
+        print(bench(conv2d, *xs))
+
+    elif args.benchmark == "sort":
+        print(bench(sort, axis, x))
+
+    elif args.benchmark == "topk":
+        print(bench(topk, axis, x))
+
+    elif args.benchmark == "step":
+        print(bench(step_function, x))
+
+    elif args.benchmark == "selu":
+        print(bench(selu, x))
+
+    elif args.benchmark == "sum_and_add":
+        print(bench(sum_and_add, axis, *xs))
+
+    else:
+        raise ValueError(f"Unknown benchmark `{args.benchmark}`.")
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/comparative/compare.py b/ml-stable-diffusion/mlx/benchmarks/python/comparative/compare.py
new file mode 100644
index 0000000000000000000000000000000000000000..68b4a5bd32328405d2178b2523a1732d6eea12be
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/comparative/compare.py
@@ -0,0 +1,284 @@
+# Copyright © 2023 Apple Inc.
+
+#!/usr/bin/env python
+
+import argparse
+import re
+from pathlib import Path
+from subprocess import run
+
+BENCH_MLX = Path(__file__).parent / "bench_mlx.py"
+BENCH_TORCH = Path(__file__).parent / "bench_torch.py"
+
+
+def run_or_raise(*args, **kwargs):
+    try:
+        result = run(*args, capture_output=True, **kwargs)
+        return float(result.stdout)
+    except ValueError:
+        raise ValueError(
+            f"stdout: {result.stdout.decode()}\nstderr: {result.stderr.decode()}"
+        )
+
+
+def compare(args):
+    t_mlx = run_or_raise(["python", BENCH_MLX] + args)
+    t_torch = run_or_raise(["python", BENCH_TORCH] + args)
+
+    print((t_torch - t_mlx) / t_torch, " ".join(args), sep="\t")
+
+
+def compare_mlx_dtypes(args, dt1, dt2):
+    t_mlx_dt1 = run_or_raise(["python", BENCH_MLX] + args + ["--dtype", dt1])
+    t_mlx_dt2 = run_or_raise(["python", BENCH_MLX] + args + ["--dtype", dt2])
+
+    print((t_mlx_dt2 - t_mlx_dt1) / t_mlx_dt2, " ".join(args), sep="\t")
+
+
+def make_regex_search(regexes):
+    compiled_regexes = list(map(re.compile, regexes))
+
+    def search(x):
+        return (c.search(x) is not None for c in compiled_regexes)
+
+    return search
+
+
+def make_predicate(positive_filter, negative_filter):
+    if positive_filter is not None:
+        positive_filter_search = make_regex_search(positive_filter)
+        positive_filter = lambda x: all(positive_filter_search(x))
+    else:
+        positive_filter = lambda x: True
+
+    if negative_filter is not None:
+        negative_filter_search = make_regex_search(negative_filter)
+        negative_filter = lambda x: not any(negative_filter_search(x))
+    else:
+        negative_filter = lambda x: True
+
+    def predicate(x):
+        return positive_filter(x) and negative_filter(x)
+
+    return predicate
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run comparisons against PyTorch")
+    parser.add_argument(
+        "--filter", "-f", help="Regex filter to select benchmarks", nargs="+"
+    )
+    parser.add_argument(
+        "--negative_filter", "-n", help="Regex filter to remove benchmarks", nargs="+"
+    )
+    parser.add_argument(
+        "--mlx_dtypes",
+        "-d",
+        help="Compare mlx benchmarks between the 2 provided data types",
+        nargs=2,
+    )
+    args, rest = parser.parse_known_args()
+
+    _filter = make_predicate(args.filter, args.negative_filter)
+
+    if args.mlx_dtypes:
+        compare_filtered = lambda x: (
+            compare_mlx_dtypes(x.split() + rest, args.mlx_dtypes[0], args.mlx_dtypes[1])
+            if _filter(x)
+            else None
+        )
+    else:
+        compare_filtered = lambda x: compare(x.split() + rest) if _filter(x) else None
+
+    # Binary ops
+    compare_filtered("add --size 10x1024x128 --size 1x1024x128 --cpu")
+    compare_filtered("add --size 10x1024x128 --size 1x1024x128")
+    compare_filtered("add --size 1024x128 --size 1x128 --cpu")
+    compare_filtered("add --size 1024x128 --size 1x128")
+    compare_filtered("add --size 1024x4096 --size 1x4096 --cpu")
+    compare_filtered("add --size 1024x4096 --size 1x4096")
+    compare_filtered("add --size 1024x4096 --size 1x1024 --transpose 1,0 --cpu")
+    compare_filtered("add --size 1024x4096 --size 1x1024 --transpose 1,0")
+    compare_filtered("add --size 1024x1024 --size 1024x1024 --cpu")
+    compare_filtered("add --size 1024x1024 --size 1024x1024")
+    compare_filtered("add --size 1024x1024 --size 1024x1024 --transpose 1,0 --cpu")
+    compare_filtered("add --size 1024x1024 --size 1024x1024 --transpose 1,0")
+    compare_filtered(
+        "add --size 1024x1024 --size 1024x1024 --transpose 1,0 --transpose 1,0 --cpu"
+    )
+    compare_filtered(
+        "add --size 1024x1024 --size 1024x1024 --transpose 1,0 --transpose 1,0"
+    )
+
+    # Reduction ops
+    compare_filtered("sum_all --size 10x1024x128 --cpu")
+    compare_filtered("sum_all --size 10x1024x128")
+    compare_filtered("sum_axis --size 16x1024x128 --axis 2 --cpu")
+    compare_filtered("sum_axis --size 16x1024x128 --axis 2")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 2 --cpu")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 2")
+    compare_filtered("sum_axis --size 1024x1024 --axis 1 --cpu")
+    compare_filtered("sum_axis --size 1024x1024 --axis 1")
+    compare_filtered("sum_axis --size 1024x1024 --axis 0 --cpu")
+    compare_filtered("sum_axis --size 1024x1024 --axis 0")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 1 --cpu")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 1")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 0 --cpu")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 0")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 0,1 --cpu")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 0,1")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 0,2 --cpu")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 0,2")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 0,1 --transpose 0,2,1 --cpu")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 0,1 --transpose 0,2,1")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 0,2 --transpose 0,2,1 --cpu")
+    compare_filtered("sum_axis --size 16x128x1024 --axis 0,2 --transpose 0,2,1")
+    compare_filtered("argmax --size 10x1024x128 --axis 1 --cpu")
+    compare_filtered("argmax --size 10x1024x128 --axis 1")
+    compare_filtered("argmax --size 10x1024x128 --axis 2 --cpu")
+    compare_filtered("argmax --size 10x1024x128 --axis 2")
+    compare_filtered("argmax --size 1024x1024 --axis 1 --cpu")
+    compare_filtered("argmax --size 1024x1024 --axis 1")
+
+    # Matmul ops
+    compare_filtered("matmul_square --size 1024x1024")
+    compare_filtered("matmul_square --size 1024x1024 --cpu")
+    compare_filtered("matmul_square --size 16x1024x1024")
+    compare_filtered("matmul_square --size 16x1024x1024 --cpu")
+    compare_filtered(
+        "matmul --size 16x768x768 --size 16x768x768 --transpose= --transpose 0,2,1"
+    )
+    compare_filtered(
+        "matmul --size 16x768x768 --size 16x768x768 --transpose= --transpose 0,2,1 --cpu"
+    )
+    compare_filtered(
+        "matmul --size 16x768x128 --size 16x768x128 --transpose= --transpose 0,2,1"
+    )
+    compare_filtered(
+        "matmul --size 16x768x128 --size 16x768x128 --transpose= --transpose 0,2,1 --cpu"
+    )
+    compare_filtered("matmul --size 512x8192 --size 8192x512")
+    compare_filtered("matmul --size 512x8192 --size 8192x512 --cpu")
+    # compare_filtered("matmul --size 512x131072 --size 131072x512")
+    # compare_filtered("matmul --size 512x131072 --size 131072x512 --cpu")
+    compare_filtered("matmul --size 8192x512 --size 512x8192")
+    compare_filtered("matmul --size 8192x512 --size 512x8192 --cpu")
+    # compare_filtered("matmul --size 131072x512 --size 512x512")
+    # compare_filtered("matmul --size 131072x512 --size 512x512 --cpu")
+    compare_filtered("linear --size 1024x1024 --size 1024 --size 128x1024")
+    compare_filtered("linear --size 1024x1024 --size 1024 --size 128x1024 --cpu")
+    compare_filtered("linear --size 1024x1024 --size 1024 --size 128x1024 --fused")
+    compare_filtered(
+        "linear --size 1024x1024 --size 1024 --size 128x1024 --fused --cpu"
+    )
+
+    # Matvec ops
+    compare_filtered("matmul --size 1x1x4096 --size 4096x4096 --cpu")
+    compare_filtered("matmul --size 1x1x4096 --size 4096x4096")
+    compare_filtered(
+        "matmul --size 1x1x4096 --size 4096x4096 --transpose= --transpose 1,0 --cpu"
+    )
+    compare_filtered(
+        "matmul --size 1x1x4096 --size 4096x4096 --transpose= --transpose 1,0"
+    )
+    compare_filtered("matmul --size 32x1x1000 --size 32x1000x128 --cpu")
+    compare_filtered("matmul --size 32x1x1000 --size 32x1000x128")
+    compare_filtered(
+        "matmul --size 32x1x1000 --size 32x128x1000 --transpose= --transpose 0,2,1 --cpu"
+    )
+    compare_filtered(
+        "matmul --size 32x1x1000 --size 32x128x1000 --transpose= --transpose 0,2,1"
+    )
+
+    # Various ops
+    compare_filtered("softmax --size 32x16x1024 --axis 2")
+    compare_filtered("softmax --size 32x16x1024 --axis 2 --cpu")
+    compare_filtered("softmax --size 32x16x1024 --axis 2 --fused")
+    compare_filtered("softmax --size 32x16x1024 --axis 2 --fused --cpu")
+    compare_filtered("softmax --size 2x1024x1024 --axis 1")
+    compare_filtered("softmax --size 2x1024x1024 --axis 1 --cpu")
+    compare_filtered("softmax --size 2x1024x1024 --axis 1 --fused")
+    compare_filtered("softmax --size 2x1024x1024 --axis 1 --fused --cpu")
+    compare_filtered("relu --size 32x16x1024")
+    compare_filtered("relu --size 32x16x1024 --cpu")
+    compare_filtered("leaky_relu --size 32x16x1024")
+    compare_filtered("leaky_relu --size 32x16x1024 --cpu")
+    compare_filtered("elu --size 32x16x1024")
+    compare_filtered("elu --size 32x16x1024 --cpu")
+    compare_filtered("relu6 --size 32x16x1024")
+    compare_filtered("relu6 --size 32x16x1024 --cpu")
+    compare_filtered("softplus --size 32x16x1024")
+    compare_filtered("softplus --size 32x16x1024 --cpu")
+    compare_filtered("celu --size 32x16x1024")
+    compare_filtered("celu --size 32x16x1024 --cpu")
+    compare_filtered("log_sigmoid --size 32x16x1024")
+    compare_filtered("log_sigmoid --size 32x16x1024 --cpu")
+    compare_filtered("step --size 32x16x1024")
+    compare_filtered("step --size 32x16x1024 --cpu")
+    compare_filtered("selu --size 32x16x1024")
+    compare_filtered("selu --size 32x16x1024 --cpu")
+    # compare_filtered("mish --size 32x16x1024") NOTE: Torch does not implement Mish in MPS atm
+    compare_filtered("mish --size 32x16x1024 --cpu")
+    compare_filtered("prelu --size 32x16x1024")
+    compare_filtered("prelu --size 32x16x1024 --cpu")
+
+    compare_filtered("scalar_mul --size 32x16x1024")
+    compare_filtered("scalar_mul --size 32x16x1024 --cpu")
+    compare_filtered("cross_entropy --size 256x1024")
+    compare_filtered("cross_entropy --size 256x1024 --cpu")
+    compare_filtered("logsumexp --size 1024x1024 --axis 1")
+    compare_filtered("logsumexp --size 1024x1024 --axis 1 --cpu")
+    compare_filtered("logsumexp --size 1024x1024 --axis 0")
+    compare_filtered("logsumexp --size 1024x1024 --axis 0 --cpu")
+    compare_filtered("concatenate --size 32x1024x128 --size 32x1024x128 --axis 2")
+    compare_filtered("concatenate --size 32x1024x128 --size 32x1024x128 --axis 2 --cpu")
+    compare_filtered("concatenate --size 32x1024x128 --size 32x1024x128 --axis 1")
+    compare_filtered("concatenate --size 32x1024x128 --size 32x1024x128 --axis 1 --cpu")
+    compare_filtered("concatenate --size 32x1024x128 --size 32x1024x128 --axis 0")
+    compare_filtered("concatenate --size 32x1024x128 --size 32x1024x128 --axis 0 --cpu")
+    compare_filtered("concatenate --size 32x1024x128 --size 32x16x128 --axis 1")
+    compare_filtered("concatenate --size 32x1024x128 --size 32x16x128 --axis 1 --cpu")
+    compare_filtered("concatenate --size 32x1024x128 --size 32x1x128 --axis 1")
+    compare_filtered("concatenate --size 32x1024x128 --size 32x1x128 --axis 1 --cpu")
+    compare_filtered("concatenate --size 1x32x1024x128 --size 1x32x1x128 --axis 2")
+    compare_filtered(
+        "concatenate --size 1x32x1024x128 --size 1x32x1x128 --axis 2 --cpu"
+    )
+    compare_filtered("conv1d --size 1x1000x80 --size 128x11x80")
+    compare_filtered("conv1d --size 1x1000x80 --size 128x11x80 --cpu")
+    compare_filtered("conv1d --size 16x1000x80 --size 128x11x80")
+    compare_filtered("conv1d --size 4x1000x80 --size 128x11x80 --cpu")
+    compare_filtered("conv2d --size 1x256x256x3 --size 8x3x3x3")
+    compare_filtered("conv2d --size 1x256x256x3 --size 8x3x3x3 --cpu")
+    compare_filtered("conv2d --size 16x256x256x3 --size 8x3x3x3")
+    compare_filtered("conv2d --size 4x256x256x3 --size 8x3x3x3 --cpu")
+    compare_filtered("cumsum --size 1024x1024 --axis 1 --cpu")
+    compare_filtered("cumsum --size 1024x1024 --axis 0 --cpu")
+    compare_filtered("cumsum --size 1024x1024 --axis 1")
+    compare_filtered("cumsum --size 1024x1024 --axis 0")
+    compare_filtered("cumsum --size 128x1024 --axis 1")
+    compare_filtered("cumsum --size 128x1024 --axis 0")
+    compare_filtered("cumsum --size 1024x4096 --axis 1")
+    compare_filtered("cumsum --size 1024x4096 --axis 0")
+    compare_filtered("cumsum --size 128x4096 --axis 1")
+    compare_filtered("cumsum --size 128x4096 --axis 0")
+    compare_filtered("cumsum --size 1024x7777 --axis 1")
+    compare_filtered("cumsum --size 1024x7777 --axis 0")
+    compare_filtered("cumsum --size 128x7777 --axis 1")
+    compare_filtered("cumsum --size 128x7777 --axis 0")
+    compare_filtered("cumsum --size 32768x128 --axis 1")
+    compare_filtered("cumsum --size 32768x128 --axis 0")
+
+    compare_filtered("sort --size 1024x1024 --axis 0")
+    compare_filtered("sort --size 1024x1024 --axis 1")
+    compare_filtered("sort --size 32768x128 --axis 0")
+    compare_filtered("sort --size 32768x128 --axis 1")
+    compare_filtered("sort --size 128x128 --axis 0 --cpu")
+    compare_filtered("sort --size 128x128 --axis 1 --cpu")
+
+    compare_filtered("topk --size 1024x1024 --axis 0")
+    compare_filtered("topk --size 1024x1024 --axis 1")
+    compare_filtered("topk --size 32768x128 --axis 0")
+    compare_filtered("topk --size 32768x128 --axis 1")
+    compare_filtered("topk --size 128x128 --axis 0 --cpu")
+    compare_filtered("topk --size 128x128 --axis 1 --cpu")
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/compile_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/compile_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..a204ee4390bc11c516c26c9a8332503324796110
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/compile_bench.py
@@ -0,0 +1,107 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import argparse
+import math
+import random
+
+import mlx.core as mx
+from time_utils import time_fn
+
+
+def bench_gelu():
+    def gelu(x):
+        return x * (1 + mx.erf(x / math.sqrt(2))) / 2
+
+    x = mx.random.uniform(shape=(1000, 1024))
+
+    def gen_fun(fun):
+        def bench_fun(x):
+            for _ in range(10):
+                x = fun(x)
+            return x
+
+        return bench_fun
+
+    time_fn(gen_fun(gelu), x, msg="fixed gelu")
+    time_fn(gen_fun(mx.compile(gelu)), x, msg="compiled fixed gelu")
+
+    def randint():
+        return random.randint(1, x.shape[0])
+
+    def gen_fun(fun):
+        def bench_fun(x, y):
+            x = x[: randint()]
+            for _ in range(10):
+                x = fun(x)
+                y = fun(y)
+            return x, y
+
+        return bench_fun
+
+    y = mx.random.uniform(shape=(1000, 1024))
+    time_fn(gen_fun(gelu), x, y, msg="variable gelu")
+    time_fn(gen_fun(mx.compile(gelu)), x, y, msg="compiled variable gelu")
+    time_fn(
+        gen_fun(mx.compile(gelu, shapeless=True)),
+        x,
+        y,
+        msg="shapeless variable gelu",
+    )
+
+
+def bench_layernorm():
+    weight = mx.random.uniform(shape=(4096,)).astype(mx.float16)
+    bias = mx.random.uniform(shape=(4096,)).astype(mx.float16)
+    mx.eval(weight, bias)
+
+    def layernorm(x):
+        x = x.astype(mx.float32)
+        means = mx.mean(x, axis=-1, keepdims=True)
+        var = mx.var(x, axis=-1, keepdims=True)
+        x = (x - means) * mx.rsqrt(var + 1e-4)
+        x = x.astype(mx.float16)
+        return weight * x + bias
+
+    x = mx.random.uniform(shape=(1000, 4096)).astype(mx.float16)
+
+    def gen_fun(fun):
+        def bench_fun(x):
+            for _ in range(10):
+                x = fun(x)
+            return x
+
+        return bench_fun
+
+    time_fn(gen_fun(layernorm), x, msg="fixed layernorm")
+    time_fn(gen_fun(mx.compile(layernorm)), x, msg="compiled fixed layernorm")
+
+    def randint():
+        return random.randint(1, x.shape[0])
+
+    def gen_fun(fun):
+        def bench_fun(x):
+            x = x[: randint()]
+            for _ in range(10):
+                x = fun(x)
+            return x
+
+        return bench_fun
+
+    random.seed(0)
+    time_fn(gen_fun(layernorm), x, msg="variable layernorm")
+    random.seed(0)
+    time_fn(gen_fun(mx.compile(layernorm)), x, msg="compiled variable layernorm")
+    random.seed(0)
+    time_fn(
+        gen_fun(mx.compile(layernorm, shapeless=True)),
+        x,
+        msg="shapeless variable layernorm",
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser("Compile benchmarks.")
+    args = parser.parse_args()
+
+    bench_gelu()
+    bench_layernorm()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/conv1d_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/conv1d_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..0306a3e086e9df17ba76456c425bb4aa3fb46887
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/conv1d_bench.py
@@ -0,0 +1,123 @@
+import argparse
+import math
+import os
+import subprocess
+import time
+
+import mlx.core as mx
+import numpy as np
+import torch
+
+device_name = subprocess.check_output(["sysctl", "-n", "machdep.cpu.brand_string"])
+device_name = device_name.decode("utf-8").strip("\n")
+
+N_warmup = 10
+N_iter_bench = 100
+N_iter_func = 5
+
+
+def bench(f, a, b):
+    for i in range(N_warmup):
+        f(a, b)
+    torch.mps.synchronize()
+
+    s = time.perf_counter_ns()
+    for i in range(N_iter_bench):
+        f(a, b)
+    e = time.perf_counter_ns()
+    return (e - s) * 1e-9
+
+
+def make_mx_conv_1D(strides=1, padding=0, groups=1):
+    def mx_conv_1D(a, b):
+        ys = []
+        for _ in range(N_iter_func):
+            y = mx.conv1d(a, b, stride=strides, padding=padding, groups=groups)
+            ys.append(y)
+        mx.eval(ys)
+        return ys
+
+    return mx_conv_1D
+
+
+def make_pt_conv_1D(strides=1, padding=0, groups=1):
+    @torch.no_grad()
+    def pt_conv_1D(a, b):
+        ys = []
+        for _ in range(N_iter_func):
+            y = torch.conv1d(a, b, stride=strides, padding=padding, groups=groups)
+            ys.append(y)
+        torch.mps.synchronize()
+        return ys
+
+    return pt_conv_1D
+
+
+def bench_shape(N, iH, C, wH, O, strides, padding, np_dtype, groups):
+    scale = 1.0 / math.sqrt(wH * C)
+    a_np = np.random.uniform(0, 0.5, (N, iH, C)).astype(np_dtype)
+    b_np = np.random.uniform(-scale, scale, (O, wH, int(C / groups))).astype(np_dtype)
+
+    a_mx = mx.array(a_np)
+    b_mx = mx.array(b_np)
+
+    a_pt = torch.from_numpy(a_np.transpose((0, 2, 1))).to("mps")
+    b_pt = torch.from_numpy(b_np.transpose((0, 2, 1))).to("mps")
+
+    torch.mps.synchronize()
+
+    f_mx = make_mx_conv_1D(strides, padding, groups)
+    f_pt = make_pt_conv_1D(strides, padding, groups)
+
+    time_torch = bench(f_pt, a_pt, b_pt)
+    time_mlx = bench(f_mx, a_mx, b_mx)
+
+    out_mx = mx.conv1d(a_mx, b_mx, stride=strides, padding=padding, groups=groups)
+    out_pt = torch.conv1d(
+        a_pt.to("cpu"), b_pt.to("cpu"), stride=strides, padding=padding, groups=groups
+    )
+    out_pt = torch.permute(out_pt, (0, 2, 1))
+    out_pt = out_pt.numpy(force=True)
+
+    atol = 2e-5 if np_dtype == np.float32 else 1e-4
+
+    if not np.allclose(out_pt, out_mx, atol=atol):
+        print(
+            f"Failed at {(N, iH, C)}, {(O, wH, C)} [strides = {strides}, padding = {padding}, groups = {groups}] with max(|a - b|) = {np.max(np.abs(out_pt - out_mx))}"
+        )
+
+    return time_mlx, time_torch
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run conv benchmarks")
+
+    dtypes = ("float32",)
+    shapes = (
+        (4, 32, 32, 5, 32, 1, 2, 1),
+        (4, 32, 32, 5, 32, 1, 2, 2),
+        (4, 32, 32, 5, 32, 1, 2, 4),
+        (4, 32, 32, 5, 32, 1, 2, 8),
+        (4, 32, 32, 5, 32, 1, 2, 8),
+        (4, 32, 32, 5, 32, 1, 2, 16),
+        (4, 32, 32, 5, 32, 1, 2, 32),
+        (4, 32, 256, 5, 512, 1, 2, 2),
+        (4, 32, 256, 5, 512, 1, 2, 128),
+        (4, 32, 256, 5, 512, 1, 2, 256),
+    )
+
+    for dtype in dtypes:
+        print("(N,  iH,  C),  (O,  wH,  C),   dtype,  stride, pads, groups, diff%")
+        for N, iH, C, wH, O, strides, padding, groups in shapes:
+            np_dtype = getattr(np, dtype)
+            time_mlx, time_torch = bench_shape(
+                N, iH, C, wH, O, strides, padding, np_dtype, groups
+            )
+            diff = time_torch / time_mlx - 1.0
+
+            print(
+                f"({N}, {iH:3d}, {C:3d}), ({O:3d}, {wH:2d}, {C:3d}), {dtype}, {strides:5d}, {padding:4d}, {groups:6d}, {100. * diff:+5.2f}%"
+            )
+
+            if time_mlx >= 2.0 * time_torch:
+                print("ATTENTION ^^^^^^^")
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/conv2d_bench_cpu.py b/ml-stable-diffusion/mlx/benchmarks/python/conv2d_bench_cpu.py
new file mode 100644
index 0000000000000000000000000000000000000000..d560ae1b3ae895717e73e10e4dd9966e1296799d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/conv2d_bench_cpu.py
@@ -0,0 +1,127 @@
+import argparse
+import math
+import time
+
+import mlx.core as mx
+import numpy as np
+import torch
+
+N_warmup = 1
+N_iter_bench = 10
+N_iter_func = 5
+mx.set_default_device(mx.cpu)
+
+
+def bench(f, a, b):
+    for i in range(N_warmup):
+        f(a, b)
+
+    s = time.perf_counter_ns()
+    for i in range(N_iter_bench):
+        f(a, b)
+    e = time.perf_counter_ns()
+    return (e - s) * 1e-9
+
+
+def make_mx_conv_2D(strides=(1, 1), padding=(0, 0), groups=1):
+    def mx_conv_2D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = mx.conv2d(a, b, stride=strides, padding=padding, groups=groups)
+            ys.append(y)
+        mx.eval(ys)
+        return ys
+
+    return mx_conv_2D
+
+
+def make_pt_conv_2D(strides=(1, 1), padding=(0, 0), groups=1):
+    @torch.no_grad()
+    def pt_conv_2D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = torch.conv2d(a, b, stride=strides, padding=padding, groups=groups)
+            ys.append(y)
+        return ys
+
+    return pt_conv_2D
+
+
+def bench_shape(N, H, W, C, kH, kW, O, strides, padding, groups, np_dtype):
+    scale = 1.0 / math.sqrt(kH * kH * C)
+    a_np = np.random.uniform(0, 0.5, (N, H, W, C)).astype(np_dtype)
+    b_np = np.random.uniform(-scale, scale, (O, kH, kW, int(C / groups))).astype(
+        np_dtype
+    )
+
+    a_mx = mx.array(a_np)
+    b_mx = mx.array(b_np)
+
+    a_pt = torch.from_numpy(a_np.transpose((0, 3, 1, 2))).to("cpu")
+    b_pt = torch.from_numpy(b_np.transpose((0, 3, 1, 2))).to("cpu")
+
+    f_mx = make_mx_conv_2D(strides, padding, groups)
+    f_pt = make_pt_conv_2D(strides, padding, groups)
+
+    time_torch = bench(f_pt, a_pt, b_pt)
+    time_mlx = bench(f_mx, a_mx, b_mx)
+
+    out_mx = mx.conv2d(a_mx, b_mx, stride=strides, padding=padding, groups=groups)
+    out_pt = torch.conv2d(
+        a_pt.to("cpu"), b_pt.to("cpu"), stride=strides, padding=padding, groups=groups
+    )
+    out_pt = torch.permute(out_pt, (0, 2, 3, 1))
+    out_pt = out_pt.numpy(force=True)
+
+    atol = 2e-5 if np_dtype == np.float32 else 1e-4
+
+    if not np.allclose(out_pt, out_mx, atol=atol):
+        print(
+            f"Failed at {(N, H, W, C)}, {(O, kH, kW, C)} [strides = {strides}, padding = {padding}, groups = {groups}] with max(|a - b|) = {np.max(np.abs(out_pt - out_mx))}"
+        )
+
+    return time_mlx, time_torch
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run conv benchmarks")
+
+    dtypes = ("float32",)
+    shapes = (
+        (4, 32, 32, 32, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 32, 32, 64, 5, 5, 64, (1, 1), (2, 2), 1),
+        (4, 32, 32, 128, 5, 5, 128, (1, 1), (2, 2), 1),
+        (4, 32, 32, 256, 5, 5, 256, (1, 1), (2, 2), 1),
+        (4, 32, 32, 512, 5, 5, 512, (1, 1), (2, 2), 1),
+        (4, 64, 64, 32, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 64, 64, 64, 5, 5, 64, (1, 1), (2, 2), 1),
+        (4, 64, 64, 128, 5, 5, 128, (1, 1), (2, 2), 1),
+        (4, 64, 64, 256, 5, 5, 256, (1, 1), (2, 2), 1),
+        # (4, 64, 64, 256, 5, 5, 256, (1, 1), (2, 2), 2),
+        # (4, 64, 64, 256, 5, 5, 256, (1, 1), (2, 2), 16),
+        # (4, 64, 64, 256, 5, 5, 256, (1, 1), (2, 2), 64),
+        (4, 128, 128, 32, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 128, 128, 64, 5, 5, 64, (1, 1), (2, 2), 1),
+        (4, 128, 128, 128, 5, 5, 128, (1, 1), (2, 2), 1),
+        (4, 256, 256, 32, 5, 5, 3, (1, 1), (2, 2), 1),
+        (4, 256, 256, 3, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 128, 128, 64, 5, 5, 3, (1, 1), (2, 2), 1),
+        (4, 128, 128, 3, 5, 5, 64, (1, 1), (2, 2), 1),
+    )
+
+    for dtype in dtypes:
+        print(
+            "(N,   H,   W,   C), (  O, kH, kW,   C),   dtype, stride,   pads,  groups, diff%"
+        )
+        for N, H, W, C, kH, kW, O, strides, padding, groups in shapes:
+            np_dtype = getattr(np, dtype)
+            time_mlx, time_torch = bench_shape(
+                N, H, W, C, kH, kW, O, strides, padding, groups, np_dtype
+            )
+            diff = time_torch / time_mlx - 1.0
+
+            print(
+                f"({N}, {H:3d}, {W:3d}, {C:3d}), ({O:3d}, {kH:2d}, {kW:2d}, {C:3d}), {dtype}, {strides}, {padding}, {groups:7d}, {100. * diff:+5.2f}%"
+            )
+            if time_mlx >= 2.0 * time_torch:
+                print("ATTENTION ^^^^^^^")
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/conv2d_train_bench_cpu.py b/ml-stable-diffusion/mlx/benchmarks/python/conv2d_train_bench_cpu.py
new file mode 100644
index 0000000000000000000000000000000000000000..d85587909db59fb3243ee3dee56cabbdeb475e68
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/conv2d_train_bench_cpu.py
@@ -0,0 +1,143 @@
+import time
+
+import mlx.core as mx
+import mlx.nn
+import mlx.optimizers as opt
+import torch
+
+
+def bench_mlx(steps: int = 20) -> float:
+    mx.set_default_device(mx.cpu)
+
+    class BenchNetMLX(mlx.nn.Module):
+        # simple encoder-decoder net
+
+        def __init__(self, in_channels, hidden_channels=32):
+            super().__init__()
+
+            self.net = mlx.nn.Sequential(
+                mlx.nn.Conv2d(in_channels, hidden_channels, kernel_size=3, padding=1),
+                mlx.nn.ReLU(),
+                mlx.nn.Conv2d(
+                    hidden_channels, 2 * hidden_channels, kernel_size=3, padding=1
+                ),
+                mlx.nn.ReLU(),
+                mlx.nn.ConvTranspose2d(
+                    2 * hidden_channels, hidden_channels, kernel_size=3, padding=1
+                ),
+                mlx.nn.ReLU(),
+                mlx.nn.ConvTranspose2d(
+                    hidden_channels, in_channels, kernel_size=3, padding=1
+                ),
+            )
+
+        def __call__(self, input):
+            return self.net(input)
+
+    benchNet = BenchNetMLX(3)
+    mx.eval(benchNet.parameters())
+    optim = opt.Adam(learning_rate=1e-3)
+
+    inputs = mx.random.normal([10, 256, 256, 3])
+
+    params = benchNet.parameters()
+    optim.init(params)
+
+    state = [benchNet.state, optim.state]
+
+    def loss_fn(params, image):
+        benchNet.update(params)
+        pred_image = benchNet(image)
+        return (pred_image - image).abs().mean()
+
+    def step(params, image):
+        loss, grads = mx.value_and_grad(loss_fn)(params, image)
+        optim.update(benchNet, grads)
+        return loss
+
+    total_time = 0.0
+    print("MLX:")
+    for i in range(steps):
+        start_time = time.perf_counter()
+
+        step(benchNet.parameters(), inputs)
+        mx.eval(state)
+        end_time = time.perf_counter()
+
+        print(f"{i:3d}, time={(end_time-start_time) * 1000:7.2f} ms")
+        total_time += (end_time - start_time) * 1000
+
+    return total_time
+
+
+def bench_torch(steps: int = 20) -> float:
+    device = torch.device("cpu")
+
+    class BenchNetTorch(torch.nn.Module):
+        # simple encoder-decoder net
+
+        def __init__(self, in_channels, hidden_channels=32):
+            super().__init__()
+
+            self.net = torch.nn.Sequential(
+                torch.nn.Conv2d(in_channels, hidden_channels, kernel_size=3, padding=1),
+                torch.nn.ReLU(),
+                torch.nn.Conv2d(
+                    hidden_channels, 2 * hidden_channels, kernel_size=3, padding=1
+                ),
+                torch.nn.ReLU(),
+                torch.nn.ConvTranspose2d(
+                    2 * hidden_channels, hidden_channels, kernel_size=3, padding=1
+                ),
+                torch.nn.ReLU(),
+                torch.nn.ConvTranspose2d(
+                    hidden_channels, in_channels, kernel_size=3, padding=1
+                ),
+            )
+
+        def forward(self, input):
+            return self.net(input)
+
+    benchNet = BenchNetTorch(3).to(device)
+    optim = torch.optim.Adam(benchNet.parameters(), lr=1e-3)
+
+    inputs = torch.randn(10, 3, 256, 256, device=device)
+
+    def loss_fn(pred_image, image):
+        return (pred_image - image).abs().mean()
+
+    total_time = 0.0
+    print("PyTorch:")
+    for i in range(steps):
+        start_time = time.perf_counter()
+
+        optim.zero_grad()
+        pred_image = benchNet(inputs)
+        loss = loss_fn(pred_image, inputs)
+        loss.backward()
+        optim.step()
+
+        end_time = time.perf_counter()
+
+        print(f"{i:3d}, time={(end_time-start_time) * 1000:7.2f} ms")
+        total_time += (end_time - start_time) * 1000
+
+    return total_time
+
+
+def main():
+    steps = 20
+    time_mlx = bench_mlx(steps)
+    time_torch = bench_torch(steps)
+
+    print(f"average time of MLX:     {time_mlx/steps:9.2f} ms")
+    print(f"total time of MLX:       {time_mlx:9.2f} ms")
+    print(f"average time of PyTorch: {time_torch/steps:9.2f} ms")
+    print(f"total time of PyTorch:   {time_torch:9.2f} ms")
+
+    diff = time_torch / time_mlx - 1.0
+    print(f"torch/mlx diff: {100. * diff:+5.2f}%")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/conv2d_transpose_bench_cpu.py b/ml-stable-diffusion/mlx/benchmarks/python/conv2d_transpose_bench_cpu.py
new file mode 100644
index 0000000000000000000000000000000000000000..28f31f66a86c86b5b7982a61124597f0e34f8fa5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/conv2d_transpose_bench_cpu.py
@@ -0,0 +1,129 @@
+import argparse
+import math
+import time
+
+import mlx.core as mx
+import numpy as np
+import torch
+
+N_warmup = 1
+N_iter_bench = 10
+N_iter_func = 5
+
+
+def bench(f, a, b):
+    for i in range(N_warmup):
+        f(a, b)
+
+    s = time.perf_counter_ns()
+    for i in range(N_iter_bench):
+        f(a, b)
+    e = time.perf_counter_ns()
+    return (e - s) * 1e-9
+
+
+def make_mx_conv_transpose_2D(strides=(1, 1), padding=(0, 0), groups=1):
+    def mx_conv_transpose_2D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = mx.conv_transpose2d(
+                a, b, stride=strides, padding=padding, groups=groups, stream=mx.cpu
+            )
+            ys.append(y)
+        mx.eval(ys)
+        return ys
+
+    return mx_conv_transpose_2D
+
+
+def make_pt_conv_transpose_2D(strides=(1, 1), padding=(0, 0), groups=1):
+    @torch.no_grad()
+    def pt_conv_transpose_2D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = torch.conv_transpose2d(
+                a, b, stride=strides, padding=padding, groups=groups
+            )
+            ys.append(y)
+        return ys
+
+    return pt_conv_transpose_2D
+
+
+def bench_shape(N, H, W, C, kH, kW, O, strides, padding, groups, np_dtype):
+    scale = 1.0 / math.sqrt(kH * kH * C)
+    a_np = np.random.uniform(0, 0.5, (N, H, W, C)).astype(np_dtype)
+    b_np = np.random.uniform(-scale, scale, (int(O / groups), kH, kW, C)).astype(
+        np_dtype
+    )
+
+    a_mx = mx.array(a_np)
+    b_mx = mx.array(b_np)
+
+    a_pt = torch.from_numpy(a_np.transpose((0, 3, 1, 2))).to("cpu")
+    b_pt = torch.from_numpy(b_np.transpose((3, 0, 1, 2))).to("cpu")
+
+    f_mx = make_mx_conv_transpose_2D(strides, padding, groups)
+    f_pt = make_pt_conv_transpose_2D(strides, padding, groups)
+
+    time_torch = bench(f_pt, a_pt, b_pt)
+    time_mlx = bench(f_mx, a_mx, b_mx)
+
+    out_mx = mx.conv_transpose2d(
+        a_mx, b_mx, stride=strides, padding=padding, groups=groups, stream=mx.cpu
+    )
+    out_pt = torch.conv_transpose2d(
+        a_pt.to("cpu"), b_pt.to("cpu"), stride=strides, padding=padding, groups=groups
+    )
+    out_pt = torch.permute(out_pt, (0, 2, 3, 1))
+    out_pt = out_pt.numpy(force=True)
+
+    atol = 2e-5 if np_dtype == np.float32 else 1e-4
+
+    if not np.allclose(out_pt, out_mx, atol=atol):
+        print(
+            f"Failed at {(N, H, W, C)}, {(O, kH, kW, C)} [strides = {strides}, padding = {padding}, groups = {groups}] with max(|a - b|) = {np.max(np.abs(out_pt - out_mx))}"
+        )
+
+    return time_mlx, time_torch
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run conv benchmarks")
+
+    dtypes = ("float32",)
+    shapes = (
+        (4, 32, 32, 32, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 32, 32, 64, 5, 5, 64, (1, 1), (2, 2), 1),
+        (4, 32, 32, 128, 5, 5, 128, (1, 1), (2, 2), 1),
+        (4, 32, 32, 256, 5, 5, 256, (1, 1), (2, 2), 1),
+        (4, 32, 32, 512, 5, 5, 512, (1, 1), (2, 2), 1),
+        (4, 64, 64, 32, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 64, 64, 64, 5, 5, 64, (1, 1), (2, 2), 1),
+        (4, 64, 64, 128, 5, 5, 128, (1, 1), (2, 2), 1),
+        (4, 64, 64, 256, 5, 5, 256, (1, 1), (2, 2), 1),
+        (4, 128, 128, 32, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 128, 128, 64, 5, 5, 64, (1, 1), (2, 2), 1),
+        (4, 128, 128, 128, 5, 5, 128, (1, 1), (2, 2), 1),
+        (4, 256, 256, 32, 5, 5, 3, (1, 1), (2, 2), 1),
+        (4, 256, 256, 3, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 128, 128, 64, 5, 5, 3, (1, 1), (2, 2), 1),
+        (4, 128, 128, 3, 5, 5, 64, (1, 1), (2, 2), 1),
+    )
+
+    for dtype in dtypes:
+        print(
+            "(N,   H,   W,   C), (  O, kH, kW,   C),   dtype, stride,   pads,  groups, diff%"
+        )
+        for N, H, W, C, kH, kW, O, strides, padding, groups in shapes:
+            np_dtype = getattr(np, dtype)
+            time_mlx, time_torch = bench_shape(
+                N, H, W, C, kH, kW, O, strides, padding, groups, np_dtype
+            )
+            diff = time_torch / time_mlx - 1.0
+
+            print(
+                f"({N}, {H:3d}, {W:3d}, {C:3d}), ({O:3d}, {kH:2d}, {kW:2d}, {C:3d}), {dtype}, {strides}, {padding}, {groups:7d}, {100. * diff:+5.2f}%"
+            )
+            if time_mlx >= 2.0 * time_torch:
+                print("ATTENTION ^^^^^^^")
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/conv3d_bench_cpu.py b/ml-stable-diffusion/mlx/benchmarks/python/conv3d_bench_cpu.py
new file mode 100644
index 0000000000000000000000000000000000000000..d3b263da85deccf019922f6e0f3ac04189d22f82
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/conv3d_bench_cpu.py
@@ -0,0 +1,110 @@
+import argparse
+import math
+import time
+
+import mlx.core as mx
+import numpy as np
+import torch
+
+N_warmup = 1
+N_iter_bench = 10
+N_iter_func = 5
+mx.set_default_device(mx.cpu)
+
+
+def bench(f, a, b):
+    for i in range(N_warmup):
+        f(a, b)
+
+    s = time.perf_counter_ns()
+    for i in range(N_iter_bench):
+        f(a, b)
+    e = time.perf_counter_ns()
+    return (e - s) * 1e-9
+
+
+def make_mx_conv_3D(strides=(1, 1), padding=(0, 0), groups=1):
+    def mx_conv_3D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = mx.conv3d(a, b, stride=strides, padding=padding, groups=groups)
+            ys.append(y)
+        mx.eval(ys)
+        return ys
+
+    return mx_conv_3D
+
+
+def make_pt_conv_3D(strides=(1, 1), padding=(0, 0), groups=1):
+    @torch.no_grad()
+    def pt_conv_3D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = torch.conv3d(a, b, stride=strides, padding=padding, groups=groups)
+            ys.append(y)
+        return ys
+
+    return pt_conv_3D
+
+
+def bench_shape(N, D, H, W, C, kD, kH, kW, O, strides, padding, groups, np_dtype):
+    scale = 1.0 / math.sqrt(kD * kH * kW * C)
+    a_np = np.random.uniform(0, 0.5, (N, D, H, W, C)).astype(np_dtype)
+    b_np = np.random.uniform(-scale, scale, (O, kD, kH, kW, int(C / groups))).astype(
+        np_dtype
+    )
+
+    a_mx = mx.array(a_np)
+    b_mx = mx.array(b_np)
+
+    a_pt = torch.from_numpy(a_np.transpose((0, 4, 1, 2, 3))).to("cpu")
+    b_pt = torch.from_numpy(b_np.transpose((0, 4, 1, 2, 3))).to("cpu")
+
+    f_mx = make_mx_conv_3D(strides, padding, groups)
+    f_pt = make_pt_conv_3D(strides, padding, groups)
+
+    time_torch = bench(f_pt, a_pt, b_pt)
+    time_mlx = bench(f_mx, a_mx, b_mx)
+
+    out_mx = mx.conv3d(a_mx, b_mx, stride=strides, padding=padding, groups=groups)
+    out_pt = torch.conv3d(
+        a_pt.to("cpu"), b_pt.to("cpu"), stride=strides, padding=padding, groups=groups
+    )
+    out_pt = torch.permute(out_pt, (0, 2, 3, 4, 1))
+    out_pt = out_pt.numpy(force=True)
+
+    atol = 2e-5 if np_dtype == np.float32 else 1e-4
+
+    if not np.allclose(out_pt, out_mx, atol=atol):
+        print(
+            f"Failed at {(N, D, H, W, C)}, {(O, kD, kH, kW, C)} [strides = {strides}, padding = {padding}, groups = {groups}] with max(|a - b|) = {np.max(np.abs(out_pt - out_mx))}"
+        )
+
+    return time_mlx, time_torch
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run conv benchmarks")
+
+    dtypes = ("float32",)
+    shapes = (
+        (4, 16, 16, 16, 16, 5, 5, 5, 16, (1, 1, 1), (2, 2, 2), 1),
+        (4, 16, 16, 16, 32, 5, 5, 5, 32, (1, 1, 1), (2, 2, 2), 1),
+    )
+
+    for dtype in dtypes:
+        print(
+            "(N,   D,   H,   W,   C), (  O, kD, kH, kW,   C),   dtype,    stride,      pads,  groups, diff%"
+        )
+        for N, D, H, W, C, kD, kH, kW, O, strides, padding, groups in shapes:
+            np_dtype = getattr(np, dtype)
+            time_mlx, time_torch = bench_shape(
+                N, D, H, W, C, kD, kH, kW, O, strides, padding, groups, np_dtype
+            )
+            diff = time_torch / time_mlx - 1.0
+
+            print(
+                f"({N}, {D:3d}, {H:3d}, {W:3d}, {C:3d}), ({O:3d}, {kD:2d}, {kH:2d}, {kW:2d}, {C:3d}), {dtype}, {strides}, {padding}, {groups:7d}, {100. * diff:+5.2f}%"
+            )
+            if time_mlx >= 2.0 * time_torch:
+                print("ATTENTION ^^^^^^^")
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/conv3d_train_bench_cpu.py b/ml-stable-diffusion/mlx/benchmarks/python/conv3d_train_bench_cpu.py
new file mode 100644
index 0000000000000000000000000000000000000000..fee99ee76e060957e0b2bb5499fa554270a07d24
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/conv3d_train_bench_cpu.py
@@ -0,0 +1,143 @@
+import time
+
+import mlx.core as mx
+import mlx.nn
+import mlx.optimizers as opt
+import torch
+
+
+def bench_mlx(steps: int = 20, shape=(10, 32, 32, 32, 3)) -> float:
+    mx.set_default_device(mx.cpu)
+
+    class BenchNetMLX(mlx.nn.Module):
+        # simple encoder-decoder net
+
+        def __init__(self, in_channels, hidden_channels=16):
+            super().__init__()
+
+            self.net = mlx.nn.Sequential(
+                mlx.nn.Conv3d(in_channels, hidden_channels, kernel_size=3, padding=1),
+                mlx.nn.ReLU(),
+                mlx.nn.Conv3d(
+                    hidden_channels, 2 * hidden_channels, kernel_size=3, padding=1
+                ),
+                mlx.nn.ReLU(),
+                mlx.nn.ConvTranspose3d(
+                    2 * hidden_channels, hidden_channels, kernel_size=3, padding=1
+                ),
+                mlx.nn.ReLU(),
+                mlx.nn.ConvTranspose3d(
+                    hidden_channels, in_channels, kernel_size=3, padding=1
+                ),
+            )
+
+        def __call__(self, input):
+            return self.net(input)
+
+    benchNet = BenchNetMLX(3)
+    mx.eval(benchNet.parameters())
+    optim = opt.Adam(learning_rate=1e-3)
+
+    inputs = mx.random.normal(shape)
+
+    params = benchNet.parameters()
+    optim.init(params)
+
+    state = [benchNet.state, optim.state]
+
+    def loss_fn(params, image):
+        benchNet.update(params)
+        pred_image = benchNet(image)
+        return (pred_image - image).abs().mean()
+
+    def step(params, image):
+        loss, grads = mx.value_and_grad(loss_fn)(params, image)
+        optim.update(benchNet, grads)
+        return loss
+
+    total_time = 0.0
+    print("MLX:")
+    for i in range(steps):
+        start_time = time.perf_counter()
+
+        step(benchNet.parameters(), inputs)
+        mx.eval(state)
+        end_time = time.perf_counter()
+
+        print(f"{i:3d}, time={(end_time-start_time) * 1000:7.2f} ms")
+        total_time += (end_time - start_time) * 1000
+
+    return total_time
+
+
+def bench_torch(steps: int = 20, shape=(10, 3, 32, 32, 32)) -> float:
+    device = torch.device("cpu")
+
+    class BenchNetTorch(torch.nn.Module):
+        # simple encoder-decoder net
+
+        def __init__(self, in_channels, hidden_channels=16):
+            super().__init__()
+
+            self.net = torch.nn.Sequential(
+                torch.nn.Conv3d(in_channels, hidden_channels, kernel_size=3, padding=1),
+                torch.nn.ReLU(),
+                torch.nn.Conv3d(
+                    hidden_channels, 2 * hidden_channels, kernel_size=3, padding=1
+                ),
+                torch.nn.ReLU(),
+                torch.nn.ConvTranspose3d(
+                    2 * hidden_channels, hidden_channels, kernel_size=3, padding=1
+                ),
+                torch.nn.ReLU(),
+                torch.nn.ConvTranspose3d(
+                    hidden_channels, in_channels, kernel_size=3, padding=1
+                ),
+            )
+
+        def forward(self, input):
+            return self.net(input)
+
+    benchNet = BenchNetTorch(3).to(device)
+    optim = torch.optim.Adam(benchNet.parameters(), lr=1e-3)
+
+    inputs = torch.randn(*shape, device=device)
+
+    def loss_fn(pred_image, image):
+        return (pred_image - image).abs().mean()
+
+    total_time = 0.0
+    print("PyTorch:")
+    for i in range(steps):
+        start_time = time.perf_counter()
+
+        optim.zero_grad()
+        pred_image = benchNet(inputs)
+        loss = loss_fn(pred_image, inputs)
+        loss.backward()
+        optim.step()
+
+        end_time = time.perf_counter()
+
+        print(f"{i:3d}, time={(end_time-start_time) * 1000:7.2f} ms")
+        total_time += (end_time - start_time) * 1000
+
+    return total_time
+
+
+def main():
+    steps = 10
+    time_mlx = bench_mlx(steps)
+    time_torch = bench_torch(steps)
+
+    print(f"average time of MLX:     {time_mlx/steps:9.2f} ms")
+    print(f"total time of MLX:       {time_mlx:9.2f} ms")
+    print(f"average time of PyTorch: {time_torch/steps:9.2f} ms")
+    print(f"total time of PyTorch:   {time_torch:9.2f} ms")
+
+    diff = time_torch / time_mlx - 1.0
+    print(f"torch/mlx diff: {100. * diff:+5.2f}%")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/conv3d_transpose_bench_cpu.py b/ml-stable-diffusion/mlx/benchmarks/python/conv3d_transpose_bench_cpu.py
new file mode 100644
index 0000000000000000000000000000000000000000..742d9d46b15a7d4b792dd4887c5445455a9eb8f7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/conv3d_transpose_bench_cpu.py
@@ -0,0 +1,116 @@
+import argparse
+import math
+import time
+
+import mlx.core as mx
+import numpy as np
+import torch
+
+N_warmup = 1
+N_iter_bench = 10
+N_iter_func = 5
+mx.set_default_device(mx.cpu)
+
+
+def bench(f, a, b):
+    for i in range(N_warmup):
+        f(a, b)
+
+    s = time.perf_counter_ns()
+    for i in range(N_iter_bench):
+        f(a, b)
+    e = time.perf_counter_ns()
+    return (e - s) * 1e-9
+
+
+def make_mx_conv_3D(strides=(1, 1, 1), padding=(0, 0, 0), groups=1):
+    def mx_conv_3D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = mx.conv_transpose3d(
+                a, b, stride=strides, padding=padding, groups=groups
+            )
+            ys.append(y)
+        mx.eval(ys)
+        return ys
+
+    return mx_conv_3D
+
+
+def make_pt_conv_3D(strides=(1, 1, 1), padding=(0, 0, 0), groups=1):
+    @torch.no_grad()
+    def pt_conv_3D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = torch.conv_transpose3d(
+                a, b, stride=strides, padding=padding, groups=groups
+            )
+            ys.append(y)
+        return ys
+
+    return pt_conv_3D
+
+
+def bench_shape(N, D, H, W, C, kD, kH, kW, O, strides, padding, groups, np_dtype):
+    scale = 1.0 / math.sqrt(kD * kH * kW * C)
+    a_np = np.random.uniform(0, 0.5, (N, D, H, W, C)).astype(np_dtype)
+    b_np = np.random.uniform(-scale, scale, (O, kD, kH, kW, int(C / groups))).astype(
+        np_dtype
+    )
+
+    a_mx = mx.array(a_np)
+    b_mx = mx.array(b_np)
+
+    a_pt = torch.from_numpy(a_np.transpose((0, 4, 1, 2, 3))).to("cpu")
+    b_pt = torch.from_numpy(b_np.transpose((4, 0, 1, 2, 3))).to("cpu")
+
+    f_mx = make_mx_conv_3D(strides, padding, groups)
+    f_pt = make_pt_conv_3D(strides, padding, groups)
+
+    time_torch = bench(f_pt, a_pt, b_pt)
+    time_mlx = bench(f_mx, a_mx, b_mx)
+
+    out_mx = mx.conv_transpose3d(
+        a_mx, b_mx, stride=strides, padding=padding, groups=groups
+    )
+    out_pt = torch.conv_transpose3d(
+        a_pt.to("cpu"), b_pt.to("cpu"), stride=strides, padding=padding, groups=groups
+    )
+    out_pt = torch.permute(out_pt, (0, 2, 3, 4, 1))
+    out_pt = out_pt.numpy(force=True)
+
+    atol = 2e-5 if np_dtype == np.float32 else 1e-4
+
+    if not np.allclose(out_pt, out_mx, atol=atol):
+        print(
+            f"Failed at {(N, D, H, W, C)}, {(O, kD, kH, kW, C)} [strides = {strides}, padding = {padding}, groups = {groups}] with max(|a - b|) = {np.max(np.abs(out_pt - out_mx))}"
+        )
+
+    return time_mlx, time_torch
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run conv benchmarks")
+
+    dtypes = ("float32",)
+    shapes = (
+        (4, 16, 16, 16, 16, 5, 5, 5, 16, (1, 1, 1), (2, 2, 2), 1),
+        (4, 16, 16, 16, 32, 5, 5, 5, 32, (1, 1, 1), (2, 2, 2), 1),
+    )
+
+    for dtype in dtypes:
+        print(
+            "(N,   D,   H,   W,   C), (  O, kD, kH, kW,   C),   dtype,    stride,      pads,  groups, diff%"
+        )
+        for N, D, H, W, C, kD, kH, kW, O, strides, padding, groups in shapes:
+            np_dtype = getattr(np, dtype)
+            time_mlx, time_torch = bench_shape(
+                N, D, H, W, C, kD, kH, kW, O, strides, padding, groups, np_dtype
+            )
+            diff = time_torch / time_mlx - 1.0
+
+            print(
+                f"({N}, {D:3d}, {H:3d}, {W:3d}, {C:3d}), ({O:3d}, {kD:2d}, {kH:2d}, {kW:2d}, {C:3d}), {dtype}, {strides}, {padding}, {groups:7d}, {100. * diff:+5.2f}%"
+            )
+            if time_mlx >= 2.0 * time_torch:
+                print("ATTENTION ^^^^^^^")
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/conv_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/conv_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..f421963adde427ab21dc0ec5e6a4bfca4e4fe71c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/conv_bench.py
@@ -0,0 +1,135 @@
+import argparse
+import math
+import os
+import subprocess
+import time
+
+import mlx.core as mx
+import numpy as np
+import torch
+
+device_name = subprocess.check_output(["sysctl", "-n", "machdep.cpu.brand_string"])
+device_name = device_name.decode("utf-8").strip("\n")
+
+N_warmup = 10
+N_iter_bench = 100
+N_iter_func = 5
+
+
+def bench(f, a, b):
+    for i in range(N_warmup):
+        f(a, b)
+    torch.mps.synchronize()
+
+    s = time.perf_counter_ns()
+    for i in range(N_iter_bench):
+        f(a, b)
+    e = time.perf_counter_ns()
+    return (e - s) * 1e-9
+
+
+def make_mx_conv_2D(strides=(1, 1), padding=(0, 0), groups=1):
+    def mx_conv_2D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = mx.conv2d(a, b, stride=strides, padding=padding, groups=groups)
+            ys.append(y)
+        mx.eval(ys)
+        return ys
+
+    return mx_conv_2D
+
+
+def make_pt_conv_2D(strides=(1, 1), padding=(0, 0), groups=1):
+    @torch.no_grad()
+    def pt_conv_2D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = torch.conv2d(a, b, stride=strides, padding=padding, groups=groups)
+            ys.append(y)
+        torch.mps.synchronize()
+        return ys
+
+    return pt_conv_2D
+
+
+def bench_shape(N, H, W, C, kH, kW, O, strides, padding, groups, np_dtype):
+    scale = 1.0 / math.sqrt(kH * kH * C)
+    a_np = np.random.uniform(0, 0.5, (N, H, W, C)).astype(np_dtype)
+    b_np = np.random.uniform(-scale, scale, (O, kH, kW, int(C / groups))).astype(
+        np_dtype
+    )
+
+    a_mx = mx.array(a_np)
+    b_mx = mx.array(b_np)
+
+    a_pt = torch.from_numpy(a_np.transpose((0, 3, 1, 2))).to("mps")
+    b_pt = torch.from_numpy(b_np.transpose((0, 3, 1, 2))).to("mps")
+
+    torch.mps.synchronize()
+
+    f_mx = make_mx_conv_2D(strides, padding, groups)
+    f_pt = make_pt_conv_2D(strides, padding, groups)
+
+    time_torch = bench(f_pt, a_pt, b_pt)
+    time_mlx = bench(f_mx, a_mx, b_mx)
+
+    out_mx = mx.conv2d(a_mx, b_mx, stride=strides, padding=padding, groups=groups)
+    out_pt = torch.conv2d(
+        a_pt.to("cpu"), b_pt.to("cpu"), stride=strides, padding=padding, groups=groups
+    )
+    out_pt = torch.permute(out_pt, (0, 2, 3, 1))
+    out_pt = out_pt.numpy(force=True)
+
+    atol = 2e-5 if np_dtype == np.float32 else 1e-4
+
+    if not np.allclose(out_pt, out_mx, atol=atol):
+        print(
+            f"Failed at {(N, H, W, C)}, {(O, kH, kW, C)} [strides = {strides}, padding = {padding}, groups = {groups}] with max(|a - b|) = {np.max(np.abs(out_pt - out_mx))}"
+        )
+
+    return time_mlx, time_torch
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run conv benchmarks")
+
+    dtypes = ("float32",)
+    shapes = (
+        (4, 32, 32, 32, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 32, 32, 64, 5, 5, 64, (1, 1), (2, 2), 1),
+        (4, 32, 32, 128, 5, 5, 128, (1, 1), (2, 2), 1),
+        (4, 32, 32, 256, 5, 5, 256, (1, 1), (2, 2), 1),
+        (4, 32, 32, 512, 5, 5, 512, (1, 1), (2, 2), 1),
+        (4, 64, 64, 32, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 64, 64, 64, 5, 5, 64, (1, 1), (2, 2), 1),
+        (4, 64, 64, 128, 5, 5, 128, (1, 1), (2, 2), 1),
+        (4, 64, 64, 256, 5, 5, 256, (1, 1), (2, 2), 1),
+        (4, 64, 64, 256, 5, 5, 256, (1, 1), (2, 2), 2),
+        (4, 64, 64, 256, 5, 5, 256, (1, 1), (2, 2), 16),
+        (4, 64, 64, 256, 5, 5, 256, (1, 1), (2, 2), 64),
+        (4, 128, 128, 32, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 128, 128, 64, 5, 5, 64, (1, 1), (2, 2), 1),
+        (4, 128, 128, 128, 5, 5, 128, (1, 1), (2, 2), 1),
+        (4, 256, 256, 32, 5, 5, 3, (1, 1), (2, 2), 1),
+        (4, 256, 256, 3, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 128, 128, 64, 5, 5, 3, (1, 1), (2, 2), 1),
+        (4, 128, 128, 3, 5, 5, 64, (1, 1), (2, 2), 1),
+    )
+
+    for dtype in dtypes:
+        print(
+            "(N,   H,   W,   C), (  O, kH, kW,   C),   dtype, stride,   pads,  groups, diff%"
+        )
+        for N, H, W, C, kH, kW, O, strides, padding, groups in shapes:
+            np_dtype = getattr(np, dtype)
+            time_mlx, time_torch = bench_shape(
+                N, H, W, C, kH, kW, O, strides, padding, groups, np_dtype
+            )
+            diff = time_torch / time_mlx - 1.0
+
+            print(
+                f"({N}, {H:3d}, {W:3d}, {C:3d}), ({O:3d}, {kH:2d}, {kW:2d}, {C:3d}), {dtype}, {strides}, {padding}, {groups:7d}, {100. * diff:+5.2f}%"
+            )
+            if time_mlx >= 2.0 * time_torch:
+                print("ATTENTION ^^^^^^^")
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/conv_transpose_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/conv_transpose_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..22522d8edf0a1a61bcfab4ff69971a2e5def6211
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/conv_transpose_bench.py
@@ -0,0 +1,135 @@
+import argparse
+import math
+import os
+import subprocess
+import time
+
+import mlx.core as mx
+import numpy as np
+import torch
+
+N_warmup = 10
+N_iter_bench = 100
+N_iter_func = 5
+
+
+def bench(f, a, b):
+    for i in range(N_warmup):
+        f(a, b)
+    torch.mps.synchronize()
+
+    s = time.perf_counter_ns()
+    for i in range(N_iter_bench):
+        f(a, b)
+    e = time.perf_counter_ns()
+    return (e - s) * 1e-9
+
+
+def make_mx_conv_transpose_2D(strides=(1, 1), padding=(0, 0), groups=1):
+    def mx_conv_transpose_2D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = mx.conv_transpose2d(
+                a, b, stride=strides, padding=padding, groups=groups
+            )
+            ys.append(y)
+        mx.eval(ys)
+        return ys
+
+    return mx_conv_transpose_2D
+
+
+def make_pt_conv_transpose_2D(strides=(1, 1), padding=(0, 0), groups=1):
+    @torch.no_grad()
+    def pt_conv_transpose_2D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = torch.conv_transpose2d(
+                a, b, stride=strides, padding=padding, groups=groups
+            )
+            ys.append(y)
+        torch.mps.synchronize()
+        return ys
+
+    return pt_conv_transpose_2D
+
+
+def bench_shape(N, H, W, C, kH, kW, O, strides, padding, groups, np_dtype):
+    scale = 1.0 / math.sqrt(kH * kH * C)
+    a_np = np.random.uniform(0, 0.5, (N, H, W, C)).astype(np_dtype)
+    b_np = np.random.uniform(-scale, scale, (O, kH, kW, int(C / groups))).astype(
+        np_dtype
+    )
+
+    a_mx = mx.array(a_np)
+    b_mx = mx.array(b_np)
+
+    a_pt = torch.from_numpy(a_np.transpose((0, 3, 1, 2))).to("mps")
+    b_pt = torch.from_numpy(b_np.transpose((3, 0, 1, 2))).to("mps")
+
+    torch.mps.synchronize()
+
+    f_mx = make_mx_conv_transpose_2D(strides, padding, groups)
+    f_pt = make_pt_conv_transpose_2D(strides, padding, groups)
+
+    time_torch = bench(f_pt, a_pt, b_pt)
+    time_mlx = bench(f_mx, a_mx, b_mx)
+
+    out_mx = mx.conv_transpose2d(
+        a_mx, b_mx, stride=strides, padding=padding, groups=groups
+    )
+    out_pt = torch.conv_transpose2d(
+        a_pt.to("cpu"), b_pt.to("cpu"), stride=strides, padding=padding, groups=groups
+    )
+    out_pt = torch.permute(out_pt, (0, 2, 3, 1))
+    out_pt = out_pt.numpy(force=True)
+
+    atol = 2e-5 if np_dtype == np.float32 else 1e-4
+
+    if not np.allclose(out_pt, out_mx, atol=atol):
+        print(
+            f"Failed at {(N, H, W, C)}, {(O, kH, kW, C)} [strides = {strides}, padding = {padding}, groups = {groups}] with max(|a - b|) = {np.max(np.abs(out_pt - out_mx))}"
+        )
+
+    return time_mlx, time_torch
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run conv benchmarks")
+
+    dtypes = ("float32",)
+    shapes = (
+        (4, 32, 32, 32, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 32, 32, 64, 5, 5, 64, (1, 1), (2, 2), 1),
+        (4, 32, 32, 128, 5, 5, 128, (1, 1), (2, 2), 1),
+        (4, 32, 32, 256, 5, 5, 256, (1, 1), (2, 2), 1),
+        (4, 32, 32, 512, 5, 5, 512, (1, 1), (2, 2), 1),
+        (4, 64, 64, 32, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 64, 64, 64, 5, 5, 64, (1, 1), (2, 2), 1),
+        (4, 64, 64, 128, 5, 5, 128, (1, 1), (2, 2), 1),
+        (4, 64, 64, 256, 5, 5, 256, (1, 1), (2, 2), 1),
+        (4, 128, 128, 32, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 128, 128, 64, 5, 5, 64, (1, 1), (2, 2), 1),
+        (4, 128, 128, 128, 5, 5, 128, (1, 1), (2, 2), 1),
+        (4, 256, 256, 32, 5, 5, 3, (1, 1), (2, 2), 1),
+        (4, 256, 256, 3, 5, 5, 32, (1, 1), (2, 2), 1),
+        (4, 128, 128, 64, 5, 5, 3, (1, 1), (2, 2), 1),
+        (4, 128, 128, 3, 5, 5, 64, (1, 1), (2, 2), 1),
+    )
+
+    for dtype in dtypes:
+        print(
+            "(N,   H,   W,   C), (  O, kH, kW,   C),   dtype, stride,   pads,  groups, diff%"
+        )
+        for N, H, W, C, kH, kW, O, strides, padding, groups in shapes:
+            np_dtype = getattr(np, dtype)
+            time_mlx, time_torch = bench_shape(
+                N, H, W, C, kH, kW, O, strides, padding, groups, np_dtype
+            )
+            diff = time_torch / time_mlx - 1.0
+
+            print(
+                f"({N}, {H:3d}, {W:3d}, {C:3d}), ({O:3d}, {kH:2d}, {kW:2d}, {C:3d}), {dtype}, {strides}, {padding}, {groups:7d}, {100. * diff:+5.2f}%"
+            )
+            if time_mlx >= 2.0 * time_torch:
+                print("ATTENTION ^^^^^^^")
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/conv_unaligned_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/conv_unaligned_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..981d7b48bf6b0020dd9d39d47f8bacdca92296d7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/conv_unaligned_bench.py
@@ -0,0 +1,107 @@
+import math
+import time
+
+import mlx.core as mx
+import numpy as np
+import torch
+
+N_warmup = 10
+N_iter_bench = 100
+N_iter_func = 5
+
+
+def bench(f, a, b):
+    for i in range(N_warmup):
+        f(a, b)
+    torch.mps.synchronize()
+
+    s = time.perf_counter_ns()
+    for i in range(N_iter_bench):
+        f(a, b)
+    e = time.perf_counter_ns()
+    return (e - s) * 1e-9
+
+
+def make_mx_conv_2D(strides=(1, 1), padding=(0, 0), groups=1):
+    def mx_conv_2D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = mx.conv2d(a, b, stride=strides, padding=padding, groups=groups)
+            ys.append(y)
+        mx.eval(ys)
+        return ys
+
+    return mx_conv_2D
+
+
+def make_pt_conv_2D(strides=(1, 1), padding=(0, 0), groups=1):
+    @torch.no_grad()
+    def pt_conv_2D(a, b):
+        ys = []
+        for i in range(N_iter_func):
+            y = torch.conv2d(a, b, stride=strides, padding=padding, groups=groups)
+            ys.append(y)
+        torch.mps.synchronize()
+        return ys
+
+    return pt_conv_2D
+
+
+def bench_shape(N, H, W, C, kH, kW, O, strides, padding, groups, np_dtype):
+    scale = 1.0 / math.sqrt(kH * kH * C)
+    a_np = np.random.uniform(0, 0.5, (N, H, W, C)).astype(np_dtype)
+    b_np = np.random.uniform(-scale, scale, (O, kH, kW, int(C / groups))).astype(
+        np_dtype
+    )
+
+    a_mx = mx.array(a_np)
+    b_mx = mx.array(b_np)
+
+    a_pt = torch.from_numpy(a_np.transpose((0, 3, 1, 2))).to("mps")
+    b_pt = torch.from_numpy(b_np.transpose((0, 3, 1, 2))).to("mps")
+
+    torch.mps.synchronize()
+
+    f_mx = make_mx_conv_2D(strides, padding, groups)
+    f_pt = make_pt_conv_2D(strides, padding, groups)
+
+    time_torch = bench(f_pt, a_pt, b_pt)
+    time_mlx = bench(f_mx, a_mx, b_mx)
+
+    out_mx = mx.conv2d(a_mx, b_mx, stride=strides, padding=padding, groups=groups)
+    out_pt = torch.conv2d(
+        a_pt.to("cpu"), b_pt.to("cpu"), stride=strides, padding=padding, groups=groups
+    )
+    out_pt = torch.permute(out_pt, (0, 2, 3, 1))
+    out_pt = out_pt.numpy(force=True)
+
+    atol = 2e-5 if np_dtype == np.float32 else 1e-4
+
+    if not np.allclose(out_pt, out_mx, atol=atol):
+        print(
+            f"Failed at {(N, H, W, C)}, {(O, kH, kW, C)} [strides = {strides}, padding = {padding}, groups = {groups}] with max(|a - b|) = {np.max(np.abs(out_pt - out_mx))}"
+        )
+
+    return time_mlx, time_torch
+
+
+if __name__ == "__main__":
+    dtype = "float32"
+    shapes = (
+        (4, 32, 32, 21, 3, 3, 128),
+        (4, 32, 32, 21, 3, 3, 37),
+        (4, 32, 32, 370, 3, 3, 370),
+        (4, 32, 32, 370, 7, 7, 128),
+        (2, 320, 640, 21, 7, 7, 21),
+    )
+    for N, H, W, C, kh, kw, O in shapes:
+        time_mlx, time_torch = bench_shape(
+            N, H, W, C, kh, kw, O, (1, 1), (0, 0), 1, dtype
+        )
+        diff = time_torch / time_mlx - 1.0
+
+        print(
+            f"({N}, {H:3d}, {W:3d}, {C:3d}), ({O:3d}, {kh:2d}, {kw:2d}, {C:3d}), {dtype}, {100. * diff:+5.2f}%"
+        )
+        if time_mlx >= 2.0 * time_torch:
+            print("ATTENTION ^^^^^^^")
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/distributed_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/distributed_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6fcef19eaa45eae6f098df66939e4bb3f98b536
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/distributed_bench.py
@@ -0,0 +1,66 @@
+# Copyright © 2024 Apple Inc.
+
+"""
+Run with:
+    mpirun -n 2 python /path/to/distributed_bench.py
+"""
+
+import time
+
+import mlx.core as mx
+
+
+def time_fn(fn, *args, **kwargs):
+    msg = kwargs.pop("msg", None)
+    world = mx.distributed.init()
+    if world.rank() == 0:
+        if msg:
+            print(f"Timing {msg} ...", end=" ")
+        else:
+            print(f"Timing {fn.__name__} ...", end=" ")
+
+    # warmup
+    for _ in range(5):
+        mx.eval(fn(*args, **kwargs))
+
+    num_iters = 100
+    tic = time.perf_counter()
+    for _ in range(num_iters):
+        x = mx.eval(fn(*args, **kwargs))
+    toc = time.perf_counter()
+
+    msec = 1e3 * (toc - tic) / num_iters
+    if world.rank() == 0:
+        print(f"{msec:.5f} msec")
+
+
+def time_all_sum():
+    shape = (4096,)
+    x = mx.random.uniform(shape=shape)
+    mx.eval(x)
+
+    def sine(x):
+        for _ in range(20):
+            x = mx.sin(x)
+        return x
+
+    time_fn(sine, x)
+
+    def all_sum_plain(x):
+        for _ in range(20):
+            x = mx.distributed.all_sum(x)
+        return x
+
+    time_fn(all_sum_plain, x)
+
+    def all_sum_with_sine(x):
+        for _ in range(20):
+            x = mx.sin(x)
+            x = mx.distributed.all_sum(x)
+        return x
+
+    time_fn(all_sum_with_sine, x)
+
+
+if __name__ == "__main__":
+    time_all_sum()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/einsum_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/einsum_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..a70311aec09fdb1fe3c4248872b86f9425db9946
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/einsum_bench.py
@@ -0,0 +1,84 @@
+# Copyright © 2024 Apple Inc.
+
+import time
+
+import mlx.core as mx
+import numpy as np
+
+
+def timeit(fn, its=100, args=[]):
+    for _ in range(5):
+        fn(*args)
+    tic = time.perf_counter()
+    for _ in range(its):
+        fn(*args)
+    toc = time.perf_counter()
+    return 1e3 * (toc - tic) / its
+
+
+def time_little_einsum_path():
+    subscripts = "ik,kj->ij"
+    x = mx.ones((32, 32))
+    y = mx.ones((32, 32))
+    mx_time = timeit(mx.einsum_path, args=(subscripts, x, y))
+
+    x = np.array(x)
+    y = np.array(y)
+    np_time = timeit(np.einsum_path, args=(subscripts, x, y))
+    print("Timing little einsum path...")
+    print(f"MLX ... {mx_time:.3f} ms")
+    print(f"NumPy... {np_time:.3f} ms")
+
+
+def time_big_einsum_path():
+    chars = list("abcdefgh")
+    char_to_dim = {c: v for v, c in enumerate(chars)}
+
+    num_inputs = 10
+    inputs = []
+    subscripts = []
+    for _ in range(num_inputs):
+        subscript = np.random.choice(chars, size=5, replace=False).tolist()
+        subscripts.append("".join(subscript))
+        inputs.append(np.ones(list(char_to_dim[c] for c in subscript)))
+    subscripts = ",".join(subscripts)
+
+    np_time = timeit(np.einsum_path, args=(subscripts, *inputs))
+
+    inputs = [mx.array(x) for x in inputs]
+    mx_time = timeit(mx.einsum_path, args=(subscripts, *inputs))
+    print("Timing big einsum path...")
+    print(f"MLX ... {mx_time:.3f} ms")
+    print(f"NumPy... {np_time:.3f} ms")
+
+
+def time_attention():
+    def regular_attention(x):
+        # shape [batch, sequence, num_heads, head_dim]
+        queries, keys, values = x, x, x
+        scores = queries.transpose(0, 2, 1, 3) @ keys.transpose(0, 2, 3, 1)
+        scores = mx.softmax(scores, axis=-1)
+        output = (scores @ values.transpose(0, 2, 1, 3)).swapaxes(1, 2)
+        mx.eval(output)
+
+    def einsum_attention(x):
+        # shape [batch, sequence, num_heads, head_dim]
+        queries, keys, values = x, x, x
+        scores = mx.einsum("itjk,iujk->ijtu", queries, keys)
+        scores = mx.softmax(scores, axis=-1)
+        output = mx.einsum("ijtu,iujk->itjk", scores, values)
+        mx.eval(output)
+
+    x = mx.random.uniform(shape=(8, 512, 32, 128))
+
+    regular_time = timeit(regular_attention, args=(x,))
+    ein_time = timeit(einsum_attention, args=(x,))
+    print("Timing einsum attention...")
+    print(f"Regular ... {regular_time:.3f} ms")
+    print(f"Einsum ... {ein_time:.3f} ms")
+
+
+if __name__ == "__main__":
+    time_little_einsum_path()
+    time_big_einsum_path()
+    time_attention()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/fft_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/fft_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f3603f47d4490e2044794a5ff764ea81046ea32
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/fft_bench.py
@@ -0,0 +1,118 @@
+# Copyright © 2024 Apple Inc.
+
+import matplotlib
+import mlx.core as mx
+import numpy as np
+import sympy
+import torch
+from time_utils import measure_runtime
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+
+def bandwidth_gb(runtime_ms, system_size):
+    bytes_per_fft = np.dtype(np.complex64).itemsize * 2
+    bytes_per_gb = 1e9
+    ms_per_s = 1e3
+    return system_size * bytes_per_fft / runtime_ms * ms_per_s / bytes_per_gb
+
+
+def run_bench(system_size, fft_sizes, backend="mlx", dim=1):
+    def fft_mlx(x):
+        if dim == 1:
+            out = mx.fft.fft(x)
+        elif dim == 2:
+            out = mx.fft.fft2(x)
+        mx.eval(out)
+        return out
+
+    def fft_mps(x):
+        if dim == 1:
+            out = torch.fft.fft(x)
+        elif dim == 2:
+            out = torch.fft.fft2(x)
+        torch.mps.synchronize()
+        return out
+
+    bandwidths = []
+    for n in fft_sizes:
+        batch_size = system_size // n**dim
+        shape = [batch_size] + [n for _ in range(dim)]
+        if backend == "mlx":
+            x_np = np.random.uniform(size=(system_size // n, n)).astype(np.complex64)
+            x = mx.array(x_np)
+            mx.eval(x)
+            fft = fft_mlx
+        elif backend == "mps":
+            x_np = np.random.uniform(size=(system_size // n, n)).astype(np.complex64)
+            x = torch.tensor(x_np, device="mps")
+            torch.mps.synchronize()
+            fft = fft_mps
+        else:
+            raise NotImplementedError()
+        runtime_ms = measure_runtime(fft, x=x)
+        bandwidth = bandwidth_gb(runtime_ms, np.prod(shape))
+        print(n, bandwidth)
+        bandwidths.append(bandwidth)
+
+    return np.array(bandwidths)
+
+
+def time_fft():
+    x = np.array(range(2, 512))
+    system_size = int(2**26)
+
+    print("MLX GPU")
+    with mx.stream(mx.gpu):
+        gpu_bandwidths = run_bench(system_size=system_size, fft_sizes=x)
+
+    print("MPS GPU")
+    mps_bandwidths = run_bench(system_size=system_size, fft_sizes=x, backend="mps")
+
+    print("CPU")
+    system_size = int(2**20)
+    with mx.stream(mx.cpu):
+        cpu_bandwidths = run_bench(system_size=system_size, fft_sizes=x)
+
+    x = np.array(x)
+
+    all_indices = x - x[0]
+    radix_2to13 = (
+        np.array([i for i in x if all(p <= 13 for p in sympy.primefactors(i))]) - x[0]
+    )
+    bluesteins = (
+        np.array([i for i in x if any(p > 13 for p in sympy.primefactors(i))]) - x[0]
+    )
+
+    for indices, name in [
+        (all_indices, "All"),
+        (radix_2to13, "Radix 2-13"),
+        (bluesteins, "Bluestein's"),
+    ]:
+        # plot bandwidths
+        print(name)
+        plt.scatter(x[indices], gpu_bandwidths[indices], color="green", label="GPU")
+        plt.scatter(x[indices], mps_bandwidths[indices], color="blue", label="MPS")
+        plt.scatter(x[indices], cpu_bandwidths[indices], color="red", label="CPU")
+        plt.title(f"MLX FFT Benchmark -- {name}")
+        plt.xlabel("N")
+        plt.ylabel("Bandwidth (GB/s)")
+        plt.legend()
+        plt.savefig(f"{name}.png")
+        plt.clf()
+
+    av_gpu_bandwidth = np.mean(gpu_bandwidths)
+    av_mps_bandwidth = np.mean(mps_bandwidths)
+    av_cpu_bandwidth = np.mean(cpu_bandwidths)
+    print("Average bandwidths:")
+    print("GPU:", av_gpu_bandwidth)
+    print("MPS:", av_mps_bandwidth)
+    print("CPU:", av_cpu_bandwidth)
+
+    portion_faster = len(np.where(gpu_bandwidths > mps_bandwidths)[0]) / len(x)
+    print("Percent MLX faster than MPS: ", portion_faster * 100)
+
+
+if __name__ == "__main__":
+    time_fft()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/gather_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/gather_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae6fb8f5f9d0c64c9e4e692c9de9aba8fe898097
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/gather_bench.py
@@ -0,0 +1,52 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import argparse
+
+import mlx.core as mx
+import torch
+from time_utils import measure_runtime
+
+
+def benchmark_gather_mlx(x_shape, idx_shape):
+    def gather(x, idx):
+        mx.eval(x[idx])
+
+    idx = mx.random.randint(0, x_shape[0] - 1, idx_shape)
+    x = mx.random.normal(x_shape).astype(mx.float32)
+
+    runtime = measure_runtime(gather, x=x, idx=idx)
+    print(f"MLX: {runtime:.3f}ms")
+
+
+def benchmark_gather_torch(x_shape, idx_shape, device):
+    def gather(x, idx, device):
+        _ = x[idx]
+        if device == torch.device("mps"):
+            torch.mps.synchronize()
+
+    idx = torch.randint(0, x_shape[0] - 1, idx_shape).to(device)
+    x = torch.randn(x_shape, dtype=torch.float32).to(device)
+
+    runtime = measure_runtime(gather, x=x, idx=idx, device=device)
+    print(f"PyTorch: {runtime:.3f}ms")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser("Gather benchmarks.")
+    parser.add_argument("--cpu", action="store_true", help="Use the CPU.")
+    args = parser.parse_args()
+
+    if args.cpu:
+        mx.set_default_device(mx.cpu)
+        device = torch.device("cpu")
+    else:
+        device = torch.device("mps")
+
+    idx_shapes = [(1_000_000,), (100_000,), ()]
+    x_shapes = [(100, 64), (100, 1024), (4, 1_000_000)]
+
+    for x_shape, idx_shape in zip(x_shapes, idx_shapes):
+        print("=" * 20)
+        print(f"X {x_shape}, Indices {idx_shape}")
+        benchmark_gather_mlx(x_shape, idx_shape)
+        benchmark_gather_torch(x_shape, idx_shape, device=device)
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/gather_mm_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/gather_mm_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..ffeb734879d9bd965c8af58a510aac1a3a26a8f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/gather_mm_bench.py
@@ -0,0 +1,74 @@
+# Copyright © 2025 Apple Inc.
+
+import mlx.core as mx
+from time_utils import time_fn
+
+N = 1024
+D = 1024
+M = 1024
+E = 32
+I = 4
+
+
+def gather_sort(x, indices):
+    N, M = indices.shape
+    indices = indices.flatten()
+    order = mx.argsort(indices)
+    inv_order = mx.argsort(order)
+    return x.flatten(0, -3)[order // M], indices[order], inv_order
+
+
+def scatter_unsort(x, inv_order, shape=None):
+    x = x[inv_order]
+    if shape is not None:
+        x = mx.unflatten(x, 0, shape)
+    return x
+
+
+def gather_mm_simulate(x, w, indices):
+    x, idx, inv_order = gather_sort(x, indices)
+    for i in range(2):
+        y = mx.concatenate([x[i] @ w[j].T for i, j in enumerate(idx.tolist())], axis=0)
+        x = y[:, None]
+    x = scatter_unsort(x, inv_order, indices.shape)
+    return x
+
+
+def time_gather_mm():
+    x = mx.random.normal((N, 1, 1, D)) / 1024**0.5
+    w1 = mx.random.normal((E, M, D)) / 1024**0.5
+    w2 = mx.random.normal((E, D, M)) / 1024**0.5
+    indices = (mx.random.uniform(shape=(N, I)) * E).astype(mx.uint32)
+    sorted_indices = mx.sort(indices.flatten()).reshape(N, I)
+    mx.eval(x, w1, w2, indices, sorted_indices)
+
+    def gather_mm(x, w1, w2, indices, sort):
+        idx = indices
+        inv_order = None
+        if sort:
+            x, idx, inv_order = gather_sort(x, indices)
+        x = mx.gather_mm(x, w1.swapaxes(-1, -2), rhs_indices=idx, sorted_indices=sort)
+        x = mx.gather_mm(x, w2.swapaxes(-1, -2), rhs_indices=idx, sorted_indices=sort)
+        if sort:
+            x = scatter_unsort(x, inv_order, indices.shape)
+        return x
+
+    time_fn(gather_mm, x, w1, w2, indices, False)
+    time_fn(gather_mm, x, w1, w2, sorted_indices, False)
+    time_fn(gather_mm, x, w1, w2, indices, True)
+
+    x = mx.random.normal((N * I, D)) / 1024**0.5
+    w1 = mx.random.normal((M, D)) / 1024**0.5
+    w2 = mx.random.normal((D, M)) / 1024**0.5
+    mx.eval(x, w1, w2)
+
+    def equivalent_matmul(x, w1, w2):
+        x = x @ w1.T
+        x = x @ w2.T
+        return x
+
+    time_fn(equivalent_matmul, x, w1, w2)
+
+
+if __name__ == "__main__":
+    time_gather_mm()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/gather_qmm_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/gather_qmm_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..17c06d57d24baee05cbed8e93f6533c6bb721124
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/gather_qmm_bench.py
@@ -0,0 +1,84 @@
+# Copyright © 2025 Apple Inc.
+
+import mlx.core as mx
+from time_utils import time_fn
+
+N = 1024
+D = 1024
+M = 1024
+E = 32
+I = 4
+
+
+def gather_sort(x, indices):
+    N, M = indices.shape
+    indices = indices.flatten()
+    order = mx.argsort(indices)
+    inv_order = mx.argsort(order)
+    return x.flatten(0, -3)[order // M], indices[order], inv_order
+
+
+def scatter_unsort(x, inv_order, shape=None):
+    x = x[inv_order]
+    if shape is not None:
+        x = mx.unflatten(x, 0, shape)
+    return x
+
+
+def gather_mm_simulate(x, w, indices):
+    x, idx, inv_order = gather_sort(x, indices)
+    for i in range(2):
+        y = mx.concatenate(
+            [
+                mx.quantized_matmul(x[i], w[0][j], w[1][j], w[2][j], transpose=True)
+                for i, j in enumerate(idx.tolist())
+            ],
+            axis=0,
+        )
+        x = y[:, None]
+    x = scatter_unsort(x, inv_order, indices.shape)
+    return x
+
+
+def time_gather_qmm():
+    x = mx.random.normal((N, 1, 1, D)) / 1024**0.5
+    w1 = mx.random.normal((E, M, D)) / 1024**0.5
+    w2 = mx.random.normal((E, D, M)) / 1024**0.5
+    w1 = mx.quantize(w1)
+    w2 = mx.quantize(w2)
+    indices = (mx.random.uniform(shape=(N, I)) * E).astype(mx.uint32)
+    sorted_indices = mx.sort(indices.flatten()).reshape(N, I)
+    mx.eval(x, w1, w2, indices, sorted_indices)
+
+    def gather_mm(x, w1, w2, indices, sort):
+        idx = indices
+        inv_order = None
+        if sort:
+            x, idx, inv_order = gather_sort(x, indices)
+        x = mx.gather_qmm(x, *w1, transpose=True, rhs_indices=idx, sorted_indices=sort)
+        x = mx.gather_qmm(x, *w2, transpose=True, rhs_indices=idx, sorted_indices=sort)
+        if sort:
+            x = scatter_unsort(x, inv_order, indices.shape)
+        return x
+
+    time_fn(gather_mm, x, w1, w2, indices, False)
+    time_fn(gather_mm, x, w1, w2, sorted_indices, False)
+    time_fn(gather_mm, x, w1, w2, indices, True)
+
+    x = mx.random.normal((N * I, D)) / 1024**0.5
+    w1 = mx.random.normal((M, D)) / 1024**0.5
+    w2 = mx.random.normal((D, M)) / 1024**0.5
+    w1 = mx.quantize(w1)
+    w2 = mx.quantize(w2)
+    mx.eval(x, w1, w2)
+
+    def equivalent_matmul(x, w1, w2):
+        x = mx.quantized_matmul(x, *w1, transpose=True)
+        x = mx.quantized_matmul(x, *w2, transpose=True)
+        return x
+
+    time_fn(equivalent_matmul, x, w1, w2)
+
+
+if __name__ == "__main__":
+    time_gather_qmm()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/hadamard_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/hadamard_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..2fe45473ce86c0734a7dcb99fc704d442d3d08c1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/hadamard_bench.py
@@ -0,0 +1,70 @@
+import argparse
+
+import matplotlib
+import mlx.core as mx
+import numpy as np
+from time_utils import measure_runtime
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+
+
+def had(x):
+    y = mx.hadamard_transform(x)
+    mx.eval(y)
+
+
+def copy(x):
+    y = x + 1.0
+    mx.eval(y)
+
+
+def run(dtype):
+    system_size = 2**26
+    outputs = {}
+    for test_fn in (had, copy):
+        for m in [1, 12, 20, 28]:
+            if test_fn == copy:
+                key = "copy"
+            elif m == 1:
+                key = "had_2^k"
+            else:
+                key = "had_m*2^k"
+            outputs.setdefault(key, {})
+            for k in range(7, 14):
+                n = m * 2**k
+                if n > 2**15:
+                    continue
+                x_np = np.random.normal(size=(system_size // n, n)).astype(dtype)
+                x = mx.array(x_np)
+                runtime_ms = measure_runtime(test_fn, x=x)
+                bytes_per_gb = 1e9
+                ms_per_s = 1e3
+                bytes_per_had = np.dtype(x_np.dtype).itemsize * 2
+                bandwidth_gb = (
+                    system_size * bytes_per_had / runtime_ms * ms_per_s / bytes_per_gb
+                )
+                print(n, bandwidth_gb)
+                outputs[key][n] = bandwidth_gb
+
+    colors = {
+        "copy": "black",
+        "had_2^k": "steelblue",
+        "had_m*2^k": "skyblue",
+    }
+    for key, output in outputs.items():
+        plt.scatter(output.keys(), output.values(), color=colors[key], label=key)
+    plt.title(f"MLX Hadamard Benchmark -- {dtype.__name__}")
+    plt.xlabel("N")
+    plt.ylabel("Bandwidth (GB/s)")
+    plt.legend()
+    plt.savefig(f"bench_{dtype.__name__}.png")
+    plt.clf()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--fp16", action="store_true")
+    args = parser.parse_args()
+    dtype = np.float16 if args.fp16 else np.float32
+    run(dtype)
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/layer_norm_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/layer_norm_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..29925de0b532f7dba36b01a888bb88a806bca2b6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/layer_norm_bench.py
@@ -0,0 +1,82 @@
+# Copyright © 2023-2024 Apple Inc.
+
+from functools import partial
+
+import mlx.core as mx
+import mlx.nn as nn
+from time_utils import time_fn
+
+
+def layer_norm(x, w, b, eps):
+    ot = x.dtype
+    x = x.astype(mx.float32)
+    mu = mx.mean(x, -1, keepdims=True)
+    v = mx.var(x, -1, keepdims=True)
+    y = (x - mu) * mx.rsqrt(v + eps)
+    if w is not None:
+        y = y * w
+    if b is not None:
+        y = y + b
+    return y
+
+
+def time_layer_norm(N, dt):
+    L = 1024
+    f1 = lambda x, w, b, y: (layer_norm(x, w, b, 1e-5) * y).sum()
+    f2 = lambda x, w, b, y: (mx.fast.layer_norm(x, w, b, 1e-5) * y).sum()
+    g1 = mx.grad(f1, argnums=(0, 1, 2))
+    g2 = mx.grad(f2, argnums=(0, 1, 2))
+
+    x = mx.random.uniform(shape=(8, L, N)).astype(dt)
+    w = mx.random.uniform(shape=(N,)).astype(dt)
+    b = mx.random.uniform(shape=(N,)).astype(dt)
+    y = mx.random.uniform(shape=(8, L, N)).astype(dt)
+    mx.eval(x, w, b, y)
+
+    def layer_norm_loop(f, x, w, b):
+        for _ in range(32):
+            x = f(x, w, b)
+        return x
+
+    time_fn(layer_norm_loop, partial(layer_norm, eps=1e-5), x, w, b)
+    time_fn(layer_norm_loop, partial(mx.fast.layer_norm, eps=1e-5), x, w, b)
+
+    def layer_norm_grad_loop(g, x, w, b):
+        gx, gw, gb = x, w, b
+        for _ in range(32):
+            gx, gw, gb = g(gx, gw, gb, y)
+        return gx, gw, gb
+
+    time_fn(layer_norm_grad_loop, g1, x, w, b)
+    time_fn(layer_norm_grad_loop, g2, x, w, b)
+    time_fn(layer_norm_grad_loop, mx.compile(g1), x, w, b)
+    time_fn(layer_norm_grad_loop, mx.compile(g2), x, w, b)
+
+    f1 = lambda x, y: (layer_norm(x, None, None, 1e-5) * y).sum()
+    f2 = lambda x, y: (mx.fast.layer_norm(x, None, None, 1e-5) * y).sum()
+    g1 = mx.grad(f1, argnums=(0,))
+    g2 = mx.grad(f2, argnums=(0,))
+
+    x = mx.random.uniform(shape=(8, L, N)).astype(dt)
+    w = mx.random.uniform(shape=(N,)).astype(dt)
+    b = mx.random.uniform(shape=(N,)).astype(dt)
+    y = mx.random.uniform(shape=(8, L, N)).astype(dt)
+    mx.eval(x, w, b, y)
+
+    def layer_norm_grad_x_loop(g, x):
+        gx = x
+        for _ in range(32):
+            gx = g(gx, y)
+        return gx
+
+    time_fn(layer_norm_grad_x_loop, g1, x)
+    time_fn(layer_norm_grad_x_loop, g2, x)
+    time_fn(layer_norm_grad_x_loop, mx.compile(g1), x)
+    time_fn(layer_norm_grad_x_loop, mx.compile(g2), x)
+
+
+if __name__ == "__main__":
+    for dt in [mx.float32, mx.float16, mx.bfloat16]:
+        for n in [1024, 2048, 4096, 8192, 8192 + 1024]:
+            print(dt, n)
+            time_layer_norm(n, dt)
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/rms_norm_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/rms_norm_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..50f3a40b089f790a26a7e47ab5d690a74f7e6ec4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/rms_norm_bench.py
@@ -0,0 +1,63 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import mlx.core as mx
+import mlx.nn as nn
+from time_utils import time_fn
+
+
+def rms_norm(x, w, eps):
+    ot = x.dtype
+    x = x.astype(mx.float32)
+    n = mx.rsqrt(x.square().mean(-1, keepdims=True) + eps)
+    y = (x * n).astype(ot)
+    if w is not None:
+        y = y * w
+    return y
+
+
+def time_rms_norm():
+    f1 = lambda x, w, y: (rms_norm(x, w, 1e-5) * y).sum()
+    f2 = lambda x, w, y: (mx.fast.rms_norm(x, w, 1e-5) * y).sum()
+    g1 = mx.grad(f1, argnums=(0, 1))
+    g2 = mx.grad(f2, argnums=(0, 1))
+
+    x = mx.random.uniform(shape=(8, 1024, 4096)).astype(mx.float16)
+    w = mx.random.uniform(shape=(4096,)).astype(mx.float16)
+    y = mx.random.uniform(shape=(8, 1024, 4096)).astype(mx.float16)
+    mx.eval(x, w, y)
+
+    def rms_norm_loop(g, x, w):
+        gx, gw = x, w
+        for _ in range(32):
+            gx, gw = g(gx, gw, y)
+        return gx, gw
+
+    time_fn(rms_norm_loop, g1, x, w)
+    time_fn(rms_norm_loop, g2, x, w)
+    time_fn(rms_norm_loop, mx.compile(g1), x, w)
+    time_fn(rms_norm_loop, mx.compile(g2), x, w)
+
+    f1 = lambda x, y: (rms_norm(x, None, 1e-5) * y).sum()
+    f2 = lambda x, y: (mx.fast.rms_norm(x, None, 1e-5) * y).sum()
+    g1 = mx.grad(f1, argnums=(0,))
+    g2 = mx.grad(f2, argnums=(0,))
+
+    x = mx.random.uniform(shape=(8, 1024, 4096)).astype(mx.float16)
+    w = mx.random.uniform(shape=(4096,)).astype(mx.float16)
+    y = mx.random.uniform(shape=(8, 1024, 4096)).astype(mx.float16)
+    mx.eval(x, w, y)
+
+    def rms_norm_loop(g, x):
+        gx = x
+        for _ in range(32):
+            gx = g(gx, y)
+        return gx
+
+    time_fn(rms_norm_loop, g1, x)
+    time_fn(rms_norm_loop, g2, x)
+    time_fn(rms_norm_loop, mx.compile(g1), x)
+    time_fn(rms_norm_loop, mx.compile(g2), x)
+
+
+if __name__ == "__main__":
+    time_rms_norm()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/rope_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/rope_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..35479c0b1aa38fe5b49e67124528fb6218799c10
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/rope_bench.py
@@ -0,0 +1,35 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import mlx.core as mx
+import mlx.nn as nn
+from time_utils import time_fn
+
+
+def time_rope():
+    rope = nn.RoPE(64)
+
+    # vec
+    x = mx.random.uniform(shape=(1, 32, 1, 128)).astype(mx.float16)
+    mx.eval(x)
+
+    def rope_vec(x):
+        for _ in range(32):
+            x = rope(x, offset=100)
+        return x
+
+    time_fn(rope_vec, x)
+
+    # matrix
+    x = mx.random.uniform(shape=(1, 32, 1024, 128)).astype(mx.float16)
+    mx.eval(x)
+
+    def rope_mat(x):
+        for _ in range(32):
+            x = rope(x)
+        return x
+
+    time_fn(rope_mat, x)
+
+
+if __name__ == "__main__":
+    time_rope()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/scatter_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/scatter_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..655cf0b033ae343e9d6af467ade9fd5d9a8b36f1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/scatter_bench.py
@@ -0,0 +1,96 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import argparse
+
+import mlx.core as mx
+import torch
+from time_utils import measure_runtime
+
+
+def benchmark_scatter_mlx(dst_shape, x_shape, idx_shapes):
+    def scatter(dst, x, idx):
+        dst[tuple(idx)] = x
+        mx.eval(dst)
+
+    idx = []
+    for idx_shape in idx_shapes:
+        idx.append(mx.random.randint(0, dst_shape[0] - 1, idx_shape))
+    x = mx.random.normal(x_shape).astype(mx.float32)
+    dst = mx.random.normal(dst_shape).astype(mx.float32)
+
+    runtime = measure_runtime(scatter, dst=dst, x=x, idx=idx)
+    print(f"MLX: {runtime:.3f}ms")
+
+
+def benchmark_scatter_torch(dst_shape, x_shape, idx_shapes, device):
+    def scatter(dst, x, idx, device):
+        dst[tuple(idx)] = x
+        if device == torch.device("mps"):
+            torch.mps.synchronize()
+
+    idx = []
+    for idx_shape in idx_shapes:
+        idx.append(torch.randint(0, dst_shape[0] - 1, idx_shape).to(device))
+    x = torch.randn(x_shape, dtype=torch.float32).to(device)
+    dst = torch.randn(dst_shape, dtype=torch.float32).to(device)
+
+    runtime = measure_runtime(scatter, dst=dst, x=x, idx=idx, device=device)
+    print(f"PyTorch: {runtime:.3f}ms")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser("Gather benchmarks.")
+    parser.add_argument("--cpu", action="store_true", help="Use the CPU.")
+    args = parser.parse_args()
+
+    if args.cpu:
+        mx.set_default_device(mx.cpu)
+        device = torch.device("cpu")
+    else:
+        device = torch.device("mps")
+
+    dst_shapes = [
+        (10, 64),
+        (100_000, 64),
+        (1_000_000, 64),
+        (100_000,),
+        (200_000,),
+        (20_000_000,),
+        (10000, 64),
+        (100, 64),
+        (100, 10_000, 64),
+        (10, 100, 100, 21),
+        (1_000, 1_000, 10),
+    ]
+    idx_shapes = [
+        [(1_000_000,)],
+        [(1_000_000,)],
+        [(100_000,)],
+        [(1_000_000,)],
+        [(20_000_000,)],
+        [(20_000_000,)],
+        [(1000000,)],
+        [(10000000,)],
+        [(1_000,)],
+        [(10_000,)],
+        [(1_000,), (1_000,)],
+    ]
+    x_shapes = [
+        (1_000_000, 64),
+        (1_000_000, 64),
+        (100_000, 64),
+        (1_000_000,),
+        (20_000_000,),
+        (20_000_000,),
+        (1000000, 64),
+        (10000000, 64),
+        (1_000, 10_000, 64),
+        (10_000, 100, 100, 21),
+        (1_000, 10),
+    ]
+
+    for dst_shape, x_shape, idx_shape in zip(dst_shapes, x_shapes, idx_shapes):
+        print("=" * 20)
+        print(f"Dst: {dst_shape}, X {x_shape}, Indices {idx_shape}")
+        benchmark_scatter_mlx(dst_shape, x_shape, idx_shape)
+        benchmark_scatter_torch(dst_shape, x_shape, idx_shape, device=device)
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/sdpa_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/sdpa_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..5eb789de05433d71f8160e7110e24b6670dd908b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/sdpa_bench.py
@@ -0,0 +1,223 @@
+# Copyright © 2024 Apple Inc.
+
+import argparse
+import math
+import os
+import subprocess
+import time
+
+import mlx.core as mx
+import numpy as np
+
+device_name = subprocess.check_output(["sysctl", "-n", "machdep.cpu.brand_string"])
+device_name = device_name.decode("utf-8").strip("\n")
+
+N_warmup = 5
+N_iter_bench = 40
+N_iter_func = 8
+
+
+def bench(f, *args):
+    for i in range(N_warmup):
+        f(*args)
+
+    s = time.perf_counter_ns()
+    for i in range(N_iter_bench):
+        f(*args)
+    e = time.perf_counter_ns()
+    return (e - s) * 1e-9
+
+
+def prepare_inputs(B, qL, kL, D, qH, kH, mask, transpose, dtype):
+    np_dtype = getattr(np, dtype)
+
+    shape_q = (B, qL, qH, D) if transpose else (B, qH, qL, D)
+    shape_kv = (B, kL, kH, D) if transpose else (B, kH, kL, D)
+
+    scale = 1.0 / math.sqrt(D)
+
+    q_np = np.random.normal(0.0, 1.0, shape_q).astype(np_dtype)
+    k_np = np.random.normal(0.0, scale, shape_kv).astype(np_dtype)
+    v_np = np.random.normal(0.0, scale, shape_kv).astype(np_dtype)
+
+    q_mx = mx.array(q_np)
+    k_mx = mx.array(k_np)
+    v_mx = mx.array(v_np)
+
+    if mask is not None:
+        if mask == "additive":
+            mask_np = np.random.normal(0.0, 1.0, (B, qH, qL, kL)).astype(np_dtype)
+            mask = mx.array(mask_np)
+        elif mask == "bool":
+            mask_np = np.random.uniform(0.0, 1.0, (B, qH, qL, kL)) < 0.5
+            mask = mx.array(mask_np)
+
+    return q_mx, k_mx, v_mx, scale, mask
+
+
+def mlx_ref_attn(q, k, v, scale=1.0, mask=None):
+    q_dtype = q.dtype
+    q = q * mx.array(scale, q_dtype)
+    n_q_heads = q.shape[-3]
+    n_kv_heads = k.shape[-3]
+    n_repeats = n_q_heads // n_kv_heads
+
+    B = q.shape[0]
+    L = q.shape[2]
+    kL = k.shape[2]
+
+    if n_repeats > 1:
+        q = mx.reshape(q, [B, n_kv_heads, n_repeats, L, -1])
+        k = mx.expand_dims(k, 2)
+        v = mx.expand_dims(v, 2)
+
+    scores = q @ mx.swapaxes(k, -1, -2)
+
+    if mask is not None:
+
+        if mask == "causal":
+            q_offset = max(0, kL - L)
+            q_indices = mx.arange(q_offset, q_offset + L)
+            k_indices = mx.arange(kL)
+            mask = q_indices[:, None] >= k_indices[None]
+
+        if n_repeats > 1 and mask.ndim >= 3:
+            if mask.shape[-3] == 1:
+                mask = mx.expand_dims(mask, -3)
+            else:
+                mask = mx.unflatten(mask, -3, (n_kv_heads, n_repeats))
+
+        if mask.dtype == mx.bool_:
+            scores = mx.where(mask, scores, -np.float32(np.inf))
+        else:
+            scores += mask
+
+    scores = mx.softmax(scores, axis=-1, precise=True)
+
+    out = scores @ v
+    if n_repeats > 1:
+        out = mx.reshape(out, [B, n_q_heads, L, -1])
+
+    return out
+
+
+def mlx_fused_attn(q, k, v, scale, mask):
+    return mx.fast.scaled_dot_product_attention(q, k, v, scale=scale, mask=mask)
+
+
+def do_attention(f, q, k, v, scale, mask=None, transpose=False):
+    if transpose:
+        q_t = mx.transpose(q, (0, 2, 1, 3))
+        k_t = mx.transpose(k, (0, 2, 1, 3))
+        v_t = mx.transpose(v, (0, 2, 1, 3))
+        o_t = f(q_t, k_t, v_t, scale=scale, mask=mask)
+        return mx.transpose(o_t, (0, 2, 1, 3))
+    else:
+        return f(q, k, v, scale=scale, mask=mask)
+
+
+def do_attention_bench(f, q, k, v, scale, mask=None, transpose=False):
+    q_out = q
+
+    for i in range(N_iter_func):
+        q_out = do_attention(f, q_out, k, v, scale, mask=mask, transpose=transpose)
+
+    mx.eval(q_out)
+    return q_out
+
+
+def bench_shape(
+    B, qsl, ksl, head_dim, n_q_heads, n_kv_heads, dtype, transpose=True, mask_in=None
+):
+    q_mx, k_mx, v_mx, scale, mask = prepare_inputs(
+        B, qsl, ksl, head_dim, n_q_heads, n_kv_heads, mask_in, transpose, dtype
+    )
+
+    time_mlx_unfused = bench(
+        do_attention_bench, mlx_ref_attn, q_mx, k_mx, v_mx, scale, mask, transpose
+    )
+    time_mlx_fused = bench(
+        do_attention_bench, mlx_fused_attn, q_mx, k_mx, v_mx, scale, mask, transpose
+    )
+
+    o_mlx_fused = do_attention(mlx_ref_attn, q_mx, k_mx, v_mx, scale, mask, transpose)
+    o_mlx_unfused = do_attention(
+        mlx_fused_attn, q_mx, k_mx, v_mx, scale, mask, transpose
+    )
+
+    atol = 1e-5 if dtype == "float32" else 2e-4
+
+    if not mx.allclose(o_mlx_fused, o_mlx_unfused, atol=atol, rtol=atol):
+        print(
+            f"Failed at (B: {B}, qsl: {qsl}, ksl: {ksl}, head_dim: {head_dim}, n_qh: {n_q_heads}, n_kvh: {n_kv_heads}, mask: {mask_in}) [tpose = {transpose}] with max(|a - b|) = {mx.max(mx.abs(o_mlx_unfused - o_mlx_fused)):3.2e}"
+        )
+
+    return time_mlx_fused, time_mlx_unfused
+
+
+def get_gflop_count(B, M, N, K):
+    return float(2.0 * N_iter_bench * N_iter_func * B * M * N * K) / float(1024.0**3)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run gemm benchmarks")
+
+    dtypes = ("float16", "float32")[:1]
+    transposes = (False,)
+
+    # fmt: off
+    shapes_64 = (
+        # (  B,   qsl,   ksl, head_dim, n_qh, n_kvh)
+          (  1,    32,    32,       64,   32,    32),
+          (  1,    64,    64,       64,   32,    32),
+          (  1,   128,   128,       64,   32,    32),
+          (  1,   256,   256,       64,   32,    32),
+          (  1,   512,   512,       64,   32,    32),
+          (  1,  1024,  1024,       64,   32,     8),
+          (  1,  2048,  2048,       64,   32,     8),
+          (  1,  4096,  4096,       64,   32,     8),
+    )
+
+    shapes_80 = (
+        # (  B,   qsl,   ksl, head_dim, n_qh, n_kvh)
+          (  1,  1024,  1024,       80,   32,     8),
+          (  1,  2048,  2048,       80,   32,     8),
+          (  1,  4096,  4096,       80,   32,     8),
+    )
+
+    shapes_128 = (
+        # (  B,   qsl,   ksl, head_dim, n_qh, n_kvh)
+          (  1,  1024,  1024,      128,   32,     8),
+          (  1,  2048,  2048,      128,   32,     8),
+          (  1,  4096,  4096,      128,   32,     8),
+    )
+    # fmt: on
+
+    shapes = shapes_64 + shapes_80 + shapes_128
+
+    masks = [None, "bool", "causal"]
+
+    print(
+        "  B,   qsl,   ksl, hdim, n_qh, n_kvh, t,   dtype,     mask, t_unfs, t_fuse, diff%"
+    )
+
+    for dtype in dtypes:
+        for transpose in transposes:
+            for B, qsl, ksl, head_dim, n_q_heads, n_kv_heads in shapes:
+                for mask_in in masks:
+                    time_mlx_fused, time_mlx_unfused = bench_shape(
+                        B,
+                        qsl,
+                        ksl,
+                        head_dim,
+                        n_q_heads,
+                        n_kv_heads,
+                        dtype,
+                        transpose,
+                        mask_in,
+                    )
+                    diff = time_mlx_unfused / time_mlx_fused - 1.0
+                    t_str = 1 if transpose else 0
+                    print(
+                        f"{B:3d}, {qsl:5d}, {ksl:5d}, {head_dim:4d}, {n_q_heads:4d}, {n_kv_heads:5d}, {t_str:1d}, {dtype}, {str(mask_in):>8}, {time_mlx_unfused: 2.3f}, {time_mlx_fused: 2.3f}, {100. * diff:+5.2f}%"
+                    )
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/sdpa_vector_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/sdpa_vector_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..546bff84c22efb8ce67e10c18a3941beda3cb952
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/sdpa_vector_bench.py
@@ -0,0 +1,95 @@
+import argparse
+import math
+
+import mlx.core as mx
+from time_utils import time_fn
+
+L = 16384
+H = 32
+H_k = H // 4
+D = 128
+V = 128
+dtype = mx.float16
+loops = 10
+
+
+def upproject(x, w):
+    if w is None:
+        return x
+    else:
+        return x @ w.T
+
+
+def attention(q, k, v, mask=None, w=None):
+    def _sdpa(q, k, v):
+        B, Hq, L, D = q.shape
+        _, Hk, S, _ = k.shape
+        _, _, _, V = v.shape
+        q = q.reshape(B, Hk, Hq // Hk, L, D)
+        k = k[:, :, None, :, :]
+        v = v[:, :, None, :, :]
+        s = q @ k.transpose(0, 1, 2, 4, 3)
+        if mask is not None:
+            m = mx.broadcast_to(mask, (B, Hq, L, S)).reshape(B, Hk, Hq // Hk, L, S)
+            s = mx.where(m, s, mx.finfo(s.dtype).min)
+        p = mx.softmax(s.astype(mx.float32), axis=-1).astype(s.dtype)
+        o = p @ v
+        return o.reshape(B, Hq, L, V)
+
+    for i in range(loops):
+        q = _sdpa(q, k, v)
+        q = upproject(q, w)
+    return q
+
+
+def sdpa(q, k, v, mask=None, w=None):
+    for i in range(loops):
+        q = mx.fast.scaled_dot_product_attention(q, k, v, scale=1.0, mask=mask)
+        q = upproject(q, w)
+    return q
+
+
+def time_self_attention_primitives():
+    mx.random.seed(3)
+    q = mx.random.uniform(shape=(1, H, 1, D)).astype(dtype)
+    k = mx.random.uniform(shape=(1, H_k, L, D)).astype(dtype)
+    v = mx.random.uniform(shape=(1, H_k, L, V)).astype(dtype)
+    w = mx.random.uniform(shape=(D, V)).astype(dtype) if V != D else None
+    mx.eval(q, k, v, w)
+    time_fn(attention, q, k, v, w=w)
+
+
+def time_self_attention_sdpa():
+    mx.random.seed(3)
+    q = mx.random.uniform(shape=(1, H, 1, D)).astype(dtype)
+    k = mx.random.uniform(shape=(1, H_k, L, D)).astype(dtype)
+    v = mx.random.uniform(shape=(1, H_k, L, V)).astype(dtype)
+    w = mx.random.uniform(shape=(D, V)).astype(dtype) if V != D else None
+    mx.eval(q, k, v, w)
+    time_fn(sdpa, q, k, v, w=w)
+
+
+def time_self_attention_sdpa_with_mask():
+    mx.random.seed(3)
+    q = mx.random.uniform(shape=(1, H, 1, D)).astype(dtype)
+    k = mx.random.uniform(shape=(1, H_k, L, D)).astype(dtype)
+    v = mx.random.uniform(shape=(1, H_k, L, V)).astype(dtype)
+    w = mx.random.uniform(shape=(D, V)).astype(dtype) if V != D else None
+    mask = mx.full((L,), True)
+    mask[L // 2 :] = False
+    mx.eval(q, k, v, mask, w)
+
+    def sdpa_mask(*args):
+        return sdpa(*args, mask=mask, w=w)
+
+    def attention_mask(*args):
+        return attention(*args, mask=mask, w=w)
+
+    time_fn(attention_mask, q, k, v)
+    time_fn(sdpa_mask, q, k, v)
+
+
+if __name__ == "__main__":
+    time_self_attention_sdpa()
+    time_self_attention_primitives()
+    time_self_attention_sdpa_with_mask()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/single_ops.py b/ml-stable-diffusion/mlx/benchmarks/python/single_ops.py
new file mode 100644
index 0000000000000000000000000000000000000000..939faf305e6e2170782df8628b970f32b9d20320
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/single_ops.py
@@ -0,0 +1,132 @@
+# Copyright © 2023 Apple Inc.
+
+import argparse
+
+import mlx.core as mx
+from time_utils import time_fn
+
+
+def time_add():
+    a = mx.random.uniform(shape=(32, 1024, 1024))
+    b = mx.random.uniform(shape=(32, 1024, 1024))
+    mx.eval(a, b)
+    time_fn(mx.add, a, b)
+
+    aT = mx.transpose(a, [0, 2, 1])
+    mx.eval(aT)
+
+    def transpose_add(a, b):
+        return mx.add(a, b)
+
+    time_fn(transpose_add, aT, b)
+
+    b = mx.random.uniform(shape=(1024,))
+    mx.eval(b)
+
+    def slice_add(a, b):
+        return mx.add(a, b)
+
+    time_fn(slice_add, a, b)
+
+    b = mx.reshape(b, (1, 1024, 1))
+    mx.eval(b)
+
+    def mid_slice_add(a, b):
+        return mx.add(a, b)
+
+    time_fn(mid_slice_add, a, b)
+
+
+def time_matmul():
+    a = mx.random.uniform(shape=(1024, 1024))
+    b = mx.random.uniform(shape=(1024, 1024))
+    mx.eval(a, b)
+    time_fn(mx.matmul, a, b)
+
+
+def time_maximum():
+    a = mx.random.uniform(shape=(32, 1024, 1024))
+    b = mx.random.uniform(shape=(32, 1024, 1024))
+    mx.eval(a, b)
+    time_fn(mx.maximum, a, b)
+
+
+def time_max():
+    a = mx.random.uniform(shape=(32, 1024, 1024))
+    a[1, 1] = mx.nan
+    mx.eval(a)
+    time_fn(mx.max, a, 0)
+
+
+def time_min():
+    a = mx.random.uniform(shape=(32, 1024, 1024))
+    a[1, 1] = mx.nan
+    mx.eval(a)
+    time_fn(mx.min, a, 0)
+
+
+def time_negative():
+    a = mx.random.uniform(shape=(10000, 1000))
+    mx.eval(a)
+
+    def negative(a):
+        return -a
+
+    mx.eval(a)
+
+    time_fn(negative, a)
+
+
+def time_exp():
+    a = mx.random.uniform(shape=(1000, 100))
+    mx.eval(a)
+    time_fn(mx.exp, a)
+
+
+def time_logsumexp():
+    a = mx.random.uniform(shape=(64, 10, 10000))
+    mx.eval(a)
+    time_fn(mx.logsumexp, a, axis=-1)
+
+
+def time_take():
+    a = mx.random.uniform(shape=(10000, 500))
+    ids = mx.random.randint(low=0, high=10000, shape=(20, 10))
+    ids = [mx.reshape(idx, (-1,)) for idx in ids]
+    mx.eval(ids)
+
+    def random_take():
+        return [mx.take(a, idx, 0) for idx in ids]
+
+    time_fn(random_take)
+
+
+def time_reshape_transposed():
+    x = mx.random.uniform(shape=(256, 256, 128))
+    mx.eval(x)
+
+    def reshape_transposed():
+        return mx.reshape(mx.transpose(x, (1, 0, 2)), (-1,))
+
+    time_fn(reshape_transposed)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser("MLX benchmarks.")
+    parser.add_argument("--gpu", action="store_true", help="Use the Metal back-end.")
+    args = parser.parse_args()
+    if args.gpu:
+        mx.set_default_device(mx.gpu)
+    else:
+        mx.set_default_device(mx.cpu)
+
+    time_add()
+    time_matmul()
+    time_min()
+    time_max()
+    time_maximum()
+    time_exp()
+    time_negative()
+    time_logsumexp()
+    time_take()
+    time_reshape_transposed()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/synchronize_bench.py b/ml-stable-diffusion/mlx/benchmarks/python/synchronize_bench.py
new file mode 100644
index 0000000000000000000000000000000000000000..db006d70bf289fe666cb9df9f47b600469eb6a42
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/synchronize_bench.py
@@ -0,0 +1,55 @@
+import time
+
+import mlx.core as mx
+
+rank = mx.distributed.init().rank()
+
+
+def timeit(fn, a):
+
+    # warmup
+    for _ in range(5):
+        mx.eval(fn(a))
+
+    its = 10
+    tic = time.perf_counter()
+    for _ in range(its):
+        mx.eval(fn(a))
+    toc = time.perf_counter()
+    ms = 1000 * (toc - tic) / its
+    return ms
+
+
+def all_reduce_benchmark():
+    a = mx.ones((5, 5), mx.int32)
+
+    its_per_eval = 100
+
+    def fn(x):
+        for _ in range(its_per_eval):
+            x = mx.distributed.all_sum(x)
+            x = x - 1
+        return x
+
+    ms = timeit(fn, a) / its_per_eval
+    if rank == 0:
+        print(f"All Reduce: time per iteration {ms:.6f} (ms)")
+
+
+def all_gather_benchmark():
+    a = mx.ones((5, 5), mx.int32)
+    its_per_eval = 100
+
+    def fn(x):
+        for _ in range(its_per_eval):
+            x = mx.distributed.all_gather(x)[0]
+        return x
+
+    ms = timeit(fn, a) / its_per_eval
+    if rank == 0:
+        print(f"All gather: time per iteration {ms:.6f} (ms)")
+
+
+if __name__ == "__main__":
+    all_reduce_benchmark()
+    all_gather_benchmark()
diff --git a/ml-stable-diffusion/mlx/benchmarks/python/time_utils.py b/ml-stable-diffusion/mlx/benchmarks/python/time_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..2903c32936f76ade14c74bb97b90a7f1863f8dbf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/benchmarks/python/time_utils.py
@@ -0,0 +1,38 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import time
+
+import mlx.core as mx
+
+
+def time_fn(fn, *args, **kwargs):
+    msg = kwargs.pop("msg", None)
+    if msg:
+        print(f"Timing {msg} ...", end=" ")
+    else:
+        print(f"Timing {fn.__name__} ...", end=" ")
+
+    # warmup
+    for _ in range(5):
+        mx.eval(fn(*args, **kwargs))
+
+    num_iters = 100
+    tic = time.perf_counter()
+    for _ in range(num_iters):
+        x = mx.eval(fn(*args, **kwargs))
+    toc = time.perf_counter()
+
+    msec = 1e3 * (toc - tic) / num_iters
+    print(f"{msec:.5f} msec")
+
+
+def measure_runtime(fn, **kwargs):
+    # Warmup
+    for _ in range(5):
+        fn(**kwargs)
+
+    tic = time.time()
+    iters = 100
+    for _ in range(iters):
+        fn(**kwargs)
+    return (time.time() - tic) * 1000 / iters
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/__main__.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c21ef112a98442d67864d338d5e66d5a5f2e915
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/__main__.py
@@ -0,0 +1,27 @@
+import argparse
+
+
+def main() -> None:
+    from mlx.core import __version__
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=__version__,
+        help="Print the version number.",
+    )
+    parser.add_argument(
+        "--cmake-dir",
+        action="store_true",
+        help="Print the path to the MLX CMake module directory.",
+    )
+    args = parser.parse_args()
+    if args.cmake_dir:
+        from pathlib import Path
+
+        print(Path(__file__).parent)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/_os_warning.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/_os_warning.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d40b9f4e46cad4e207f248a7222596bdaf60d33
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/_os_warning.py
@@ -0,0 +1,9 @@
+import platform
+
+if platform.system() == "Darwin":
+    version = tuple(map(int, platform.mac_ver()[0].split(".")))
+    major, minor = version[0], version[1]
+    if (major, minor) < (13, 5):
+        raise ImportError(
+            f"Only macOS 13.5 and newer are supported, not {major}.{minor}"
+        )
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/_reprlib_fix.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/_reprlib_fix.py
new file mode 100644
index 0000000000000000000000000000000000000000..29485f3698380f07693f79640d322dcab060e47a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/_reprlib_fix.py
@@ -0,0 +1,16 @@
+# Copyright © 2023 Apple Inc.
+
+import array
+import reprlib
+
+_old_repr_array = reprlib.Repr.repr_array
+
+
+def repr_array(self, x, maxlevel):
+    if isinstance(x, array.array):
+        return _old_repr_array(self, x, maxlevel)
+    else:
+        return self.repr_instance(x, maxlevel)
+
+
+reprlib.Repr.repr_array = repr_array
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/distributed_run.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/distributed_run.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb0e3c6334071b2023e9e364e337c48a98eabe2f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/distributed_run.py
@@ -0,0 +1,872 @@
+# Copyright © 2025 Apple Inc.
+
+import argparse
+import base64
+import ipaddress
+import json
+import os
+import shlex
+import shutil
+import sys
+import tempfile
+import threading
+import time
+from collections import Counter
+from dataclasses import dataclass
+from pathlib import Path
+from queue import Empty as QueueEmpty
+from queue import Queue
+from select import select
+from subprocess import PIPE, Popen, run
+from typing import Optional
+
+import mlx.core as mx
+
+
+@dataclass
+class Host:
+    rank: int
+    ssh_hostname: str
+    ips: list[str]
+
+
+@dataclass
+class ThunderboltPort:
+    iface: str
+    uuid: str
+    connected_to: Optional[str]
+
+
+@dataclass
+class ThunderboltHost:
+    name: str
+    ports: list[ThunderboltPort]
+
+
+def parse_hardware_ports(ports_string):
+    ports = {}
+    port_name = None
+    for l in ports_string.decode("utf-8").split("\n"):
+        if l.startswith("Hardware Port:"):
+            port_name = l.strip()[15:]
+        elif l.startswith("Device:"):
+            ports[port_name] = l.strip()[8:]
+            port_name = None
+    return ports
+
+
+def get_num_nvidia_gpus():
+    result = run(["nvidia-smi", "-L"], capture_output=True, text=True, check=True)
+    return len(result.stdout.strip().split("\n"))
+
+
+def extract_rings(hosts, index):
+    def usable_port(i, j, used_ports):
+        return (i, j) not in used_ports and hosts[i].ports[j].connected_to is not None
+
+    def dfs(start_node, node, path, visited, used_ports):
+        path.append(node)
+        visited.add(node)
+        for j, p in enumerate(hosts[node].ports):
+            if not usable_port(node, j, used_ports):
+                continue
+            next_node, _ = index[p.connected_to]
+            if next_node == start_node:
+                yield path[:]
+            if next_node not in visited:
+                yield from dfs(start_node, next_node, path, visited, used_ports)
+        path.pop()
+        visited.remove(node)
+
+    # Concretize maps the found cycle to real thunderbolt ports. It also adds
+    # those ports to the used set so next cycles can't use them again.
+    def concretize(cycle, used_ports):
+        concrete_path = []
+        for n1, n2 in zip(cycle, cycle[1:] + cycle[:1]):
+            for j, p in enumerate(hosts[n1].ports):
+                if not usable_port(n1, j, used_ports):
+                    continue
+                n2_hat, nj = index[p.connected_to]
+                if n2 == n2_hat:
+                    concrete_path.append(((n1, j), (n2, nj)))
+                    used_ports.add((n1, j))
+                    used_ports.add((n2, nj))
+                    break
+            if concrete_path[-1][0][0] != n1:
+                raise RuntimeError("Couldn't concretize the cycle")
+        return concrete_path
+
+    # Normalize tries to ensure that the cycles have the same direction so we can
+    # use them together. We achieve this by selecting the direction such that
+    # the smallest rank hosts connect to larger rank hosts.
+    def normalize(path):
+        small_to_large = sum(1 for p in path if p[0][0] < p[1][0])
+        if small_to_large > len(path) - small_to_large:
+            return path
+        else:
+            return [(p[1], p[0]) for p in path]
+
+    rings = []
+    used_ports = set()
+    for start_node in range(len(hosts)):
+        while True:
+            ring = []
+            for r in dfs(start_node, start_node, [], set(), used_ports):
+                if len(r) > len(ring):
+                    ring = r
+                # Break early since we won't find a bigger ring no matter what
+                if len(ring) == len(hosts):
+                    break
+            if not ring:
+                break
+            try:
+                rings.append(normalize(concretize(ring, used_ports)))
+            except RuntimeError:
+                if len(rings) > 0:
+                    return rings
+                raise
+
+    return rings
+
+
+def positive_number(x):
+    x = int(x)
+    if x <= 0:
+        raise ValueError("Number should be positive")
+    return x
+
+
+def log(verbose, *args, **kwargs):
+    if not verbose:
+        return
+    print("\033[32m[INFO]", *args, "\033[0m", **kwargs)
+
+
+def log_warning(*args, **kwargs):
+    kwargs["file"] = sys.stderr
+    print("\033[33m[WARN]", *args, "\033[0m", **kwargs)
+
+
+def log_error(*args, **kwargs):
+    kwargs["file"] = sys.stderr
+    print("\033[31m[ERROR]", *args, "\033[0m", **kwargs)
+
+
+def parse_hostfile(parser, hostfile):
+    """Parse the json hostfile that contains both the hostnames to ssh into and
+    the ips to communicate over when using the ring backend.
+
+    Example:
+
+        [
+            {"ssh": "hostname1", "ips": ["123.123.123.1"]},
+            {"ssh": "hostname2", "ips": ["123.123.123.2"]},
+            ...
+            {"ssh": "hostnameN", "ips": ["123.123.123.N"]},
+        ]
+
+    Args:
+        hostfile (str): The path to the json file containing the host
+            information
+    """
+    hostfile = Path(hostfile)
+    if not hostfile.exists():
+        parser.error(f"Hostfile {str(hostfile)} doesn't exist")
+
+    try:
+        hosts = []
+        with open(hostfile) as f:
+            for i, h in enumerate(json.load(f)):
+                hosts.append(Host(i, h["ssh"], h.get("ips", [])))
+        return hosts
+    except Exception as e:
+        parser.error(f"Failed to parse hostfile {str(hostfile)} ({str(e)})")
+
+
+def parse_hostlist(parser, hostlist, repeats):
+    hosts = []
+    for i, h in enumerate(hostlist.split(",")):
+        if h == "":
+            raise ValueError("Hostname cannot be empty")
+        try:
+            ipaddress.ip_address(h)
+            ips = [h]
+        except ValueError:
+            ips = []
+        for i in range(repeats):
+            hosts.append(Host(i, h, ips))
+    return hosts
+
+
+def make_monitor_script(rank, hostfile, cwd, env, command, verbose):
+    # Imports that are used throughout
+    script = ""
+    script += "import os\n"
+    script += "import sys\n"
+    script += "import tempfile\n"
+    script += "from pathlib import Path\n"
+
+    # Write the PID to a file so we can kill the process if needed
+    script += "_, pidfile = tempfile.mkstemp() \n"
+    script += "open(pidfile, 'w').write(str(os.getpid()))\n"
+    script += "print(pidfile, flush=True)\n"
+
+    # Change the working directory if one was requested. Otherwise attempt to
+    # change to the current one but don't fail if it wasn't possible.
+    d = cwd or os.getcwd()
+    script += f"if Path({repr(d)}).exists():\n"
+    script += f"    os.chdir({repr(d)})\n"
+    if cwd is not None:
+        script += "else:\n"
+        script += (
+            f"    print('Failed to change directory to', {repr(d)}, file=sys.stderr)\n"
+        )
+        script += f"    sys.exit(1)\n"
+
+    # Add the environment variables that were given to us
+    script += "env = dict(os.environ)\n"
+    for e in env:
+        key, *value = e.split("=", maxsplit=1)
+        value = shlex.quote(value[0]) if len(value) > 0 else ""
+        if not all(c.isalnum() or c == "_" for c in key):
+            log_warning(f"'{e}' is an invalid environment variable so it is ignored")
+            continue
+        script += f"env[{repr(key)}] = {repr(value)}\n"
+
+    # Add the environment variables to enable the ring distributed backend
+    if hostfile != "":
+        script += "_, hostfile = tempfile.mkstemp()\n"
+        script += "with open(hostfile, 'w') as f:\n"
+        script += f"    f.write({repr(hostfile)})\n"
+        if verbose:
+            script += "env['MLX_RING_VERBOSE'] = '1'\n"
+        script += "env['MLX_HOSTFILE'] = hostfile\n"
+        script += f"env['MLX_RANK'] = '{rank}'\n"
+        script += "\n"
+
+    # Replace the process with the script
+    script += f"command = [{','.join(map(repr, command))}]\n"
+    script += "os.execve(command[0], command, env)\n"
+
+    return script
+
+
+def launch_ring(parser, hosts, args, command):
+    stop = False
+    exit_codes = [None] * len(hosts)
+
+    def node_thread(rank, host, hostfile, input_queue):
+        is_local = host == "127.0.0.1"
+        script = make_monitor_script(
+            rank, hostfile, args.cwd, args.env, command, args.verbose
+        )
+        script_b64 = base64.b64encode(script.encode()).decode()
+        cmd = f'{sys.executable} -c "import base64; exec(base64.b64decode(\\"{script_b64}\\"));"'
+        if not is_local:
+            cmd = f"ssh {host} '{cmd}'"
+        p = Popen(
+            cmd,
+            shell=True,
+            stdin=PIPE,
+            stdout=PIPE,
+            stderr=PIPE,
+        )
+        os.set_blocking(p.stdout.fileno(), False)
+        os.set_blocking(p.stderr.fileno(), False)
+        os.set_blocking(p.stdin.fileno(), False)
+
+        # Repeat the stdout and stderr to the local machine
+        to_read = [p.stdout.fileno(), p.stderr.fileno()]
+        to_write = [p.stdin.fileno(), sys.stdout.fileno(), sys.stderr.fileno()]
+        pidfile = ""
+        stdin_buffer = b""
+        stdout_buffer = b""
+        stderr_buffer = b""
+        while p.poll() is None:
+            try:
+                stdin_buffer += input_queue.get_nowait()
+            except QueueEmpty:
+                pass
+            rlist, wlist, _ = select(to_read, to_write, [], 1.0)
+            for fd in rlist:
+                msg = os.read(fd, 8192).decode(errors="ignore")
+
+                # Fetch the PID file first if we haven't already
+                if pidfile == "":
+                    pidfile, *msg = msg.split("\n", maxsplit=1)
+                    msg = msg[0] if msg else ""
+
+                is_stdout = fd == p.stdout.fileno()
+                if is_stdout:
+                    stdout_buffer += msg.encode()
+                else:
+                    stderr_buffer += msg.encode()
+            for fd in wlist:
+                if fd == p.stdin.fileno() and len(stdin_buffer) > 0:
+                    n = os.write(fd, stdin_buffer)
+                    stdin_buffer = stdin_buffer[n:]
+                elif fd == sys.stdout.fileno() and len(stdout_buffer) > 0:
+                    n = os.write(fd, stdout_buffer)
+                    stdout_buffer = stdout_buffer[n:]
+                elif fd == sys.stderr.fileno() and len(stderr_buffer) > 0:
+                    n = os.write(fd, stderr_buffer)
+                    stderr_buffer = stderr_buffer[n:]
+            if stop:
+                p.terminate()
+                break
+        p.wait()
+        exit_codes[rank] = p.returncode
+
+        # Kill the remote program if possible
+        cmd = ""
+        cmd += f"pid=$(cat {pidfile}); "
+        cmd += "if ps -p $pid >/dev/null; then "
+        cmd += "    kill $pid; "
+        cmd += "    echo 1; "
+        cmd += "else "
+        cmd += "    echo 0; "
+        cmd += "fi; "
+        cmd += f"rm {pidfile}"
+        if not is_local:
+            cmd = f"ssh {host} '{cmd}'"
+        c = run(cmd, check=True, shell=True, capture_output=True, text=True)
+        if c.stdout.strip() == "1":
+            log_warning(f"Node with rank {rank} was killed")
+        elif p.returncode != 0:
+            log_warning(f"Node with rank {rank} exited with code {p.returncode}")
+        else:
+            log(args.verbose, f"Node with rank {rank} completed")
+
+    if all(len(h.ips) == 0 for h in hosts):
+        parser.error(
+            "The ring backend requires IPs to be provided instead of hostnames"
+        )
+
+    port = args.starting_port
+    ring_hosts = []
+    for h in hosts:
+        node = []
+        for ip in h.ips:
+            for i in range(args.connections_per_ip):
+                node.append(f"{ip}:{port}")
+                port += 1
+        ring_hosts.append(node)
+    hostfile = json.dumps(ring_hosts) if len(ring_hosts) > 1 else ""
+
+    log(args.verbose, "Running", shlex.join(command))
+
+    input_queues = []
+    threads = []
+    for i, h in enumerate(hosts):
+        if i + 1 == len(hosts):
+            time.sleep(1.0)
+        input_queues.append(Queue())
+        t = threading.Thread(
+            target=node_thread, args=(i, h.ssh_hostname, hostfile, input_queues[-1])
+        )
+        t.start()
+        threads.append(t)
+
+    os.set_blocking(sys.stdin.fileno(), False)
+    while not stop:
+        rlist, _, _ = select([sys.stdin.fileno()], [], [], 1.0)
+        for fd in rlist:
+            stdin_buffer = os.read(fd, 8192)
+            for q in input_queues:
+                q.put(stdin_buffer)
+        if any(t.is_alive() for t in threads):
+            for i, t in enumerate(threads):
+                if not t.is_alive():
+                    if exit_codes[i] != 0:
+                        stop = True
+                        break
+        else:
+            break
+    for t in threads:
+        t.join()
+
+
+def launch_mpi(parser, hosts, args, command):
+    mpirun = run(["which", "mpirun"], check=True, capture_output=True)
+    mpirun = mpirun.stdout.strip().decode()
+
+    # Homebrew libmpi doesn't work with anaconda python out of the box.
+    # TODO: Check if we should do this with every mpirun
+    if "homebrew" in mpirun:
+        dyld = Path(mpirun).parent.parent / "lib"
+        args.env = [f"DYLD_LIBRARY_PATH={str(dyld)}"] + args.env
+
+    log(args.verbose, f"Using '{mpirun}'")
+    with tempfile.NamedTemporaryFile(mode="w") as f:
+        hosts = Counter((h.ssh_hostname for h in hosts))
+        for h, n in hosts.items():
+            print(f"{h} slots={n}", file=f)
+        f.flush()
+
+        cmd = [
+            mpirun,
+            "--output",
+            ":raw",  # do not line buffer output
+            "--hostfile",
+            f.name,
+            *(["-cwd", args.cwd] if args.cwd else []),
+            *sum((["-x", e] for e in args.env), []),
+            *sum([shlex.split(arg) for arg in args.mpi_arg], []),
+            "--",
+            *command,
+        ]
+        log(args.verbose, "Running", " ".join(cmd))
+        try:
+            run(cmd)
+        except KeyboardInterrupt:
+            pass
+
+
+def launch_nccl(parser, hosts, args, command):
+    master_host = hosts[0].ips[0]
+
+    if master_host != "127.0.0.1":
+        raise ValueError("The NCCL backend only supports localhost for now.")
+    master_port = args.nccl_port
+    world_size = len(hosts)
+
+    base_env = os.environ.copy()
+    base_env.update(
+        {
+            "NCCL_DEBUG": base_env.get(
+                "NCCL_DEBUG", "INFO" if args.verbose else "DEBUG"
+            ),
+            "NCCL_SOCKET_IFNAME": "lo",  # Use loopback for local communication
+            "NCCL_HOST_IP": master_host,
+            "NCCL_PORT": str(master_port),
+            "MLX_WORLD_SIZE": str(world_size),
+        }
+    )
+    procs = []
+    num_gpus = get_num_nvidia_gpus()
+    if num_gpus == 0:
+        raise RuntimeError("Cannot run NCCL backend with no GPUs.")
+    if args.repeat_hosts > num_gpus:
+        raise RuntimeError("NCCL requires a separate GPU per process.")
+
+    try:
+        for rank in range(world_size):
+            env = base_env.copy()
+            mlx_rank = str(rank % args.repeat_hosts)
+            env["MLX_RANK"] = mlx_rank
+            env["CUDA_VISIBLE_DEVICES"] = mlx_rank
+            p = Popen(command, env=env)
+            procs.append(p)
+
+        for p in procs:
+            ret = p.wait()
+            if ret != 0:
+                raise RuntimeError(f"Rank process exited with {ret}")
+
+    except (RuntimeError, KeyboardInterrupt) as err:
+        for p in procs:
+            if p.poll() is None:
+                try:
+                    p.kill()
+                except Exception:
+                    pass
+        raise
+
+
+def check_ssh_connections(hosts):
+    results = [False] * len(hosts)
+
+    def _check(hostname, i):
+        result = run(
+            [
+                "ssh",
+                "-o",
+                "BatchMode=yes",
+                "-o",
+                "ConnectTimeout=5",
+                hostname,
+                "echo",
+                "success",
+            ],
+            stdout=PIPE,
+            stderr=PIPE,
+        )
+        results[i] = result.returncode == 0
+
+    threads = [
+        threading.Thread(target=_check, args=(h.ssh_hostname, i))
+        for i, h in enumerate(hosts)
+    ]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join()
+
+    if not all(results):
+        log_error("Could not ssh to the following hosts:")
+        for i, h in enumerate(hosts):
+            if not results[i]:
+                log_error("  - ", h.ssh_hostname)
+        log_error()
+        log_error("Maybe they are not set-up for password-less ssh?")
+        sys.exit(1)
+
+
+def prepare_tb_ring(args, hosts):
+    log(
+        args.verbose,
+        f"Preparing a thunderbolt ring for {', '.join(h.ssh_hostname for h in hosts)}",
+    )
+
+    # Check that we can ssh
+    check_ssh_connections(hosts)
+    if args.auto_setup and args.verbose:
+        log_warning(
+            "--auto-setup is requested which requires password-less sudo",
+            "on the remote hosts",
+        )
+
+    # Extract the current connectivity from the remote hosts
+    thunderbolt_connections = []
+    for h in hosts:
+        log(args.verbose, "Getting connectivity from", h.ssh_hostname)
+        thunderbolt_connections.append(
+            json.loads(
+                run(
+                    [
+                        "ssh",
+                        h.ssh_hostname,
+                        "system_profiler",
+                        "SPThunderboltDataType",
+                        "-json",
+                    ],
+                    capture_output=True,
+                ).stdout
+            )
+        )
+    interface_maps = []
+    for h in hosts:
+        log(args.verbose, "Getting interface names from", h.ssh_hostname)
+        interface_maps.append(
+            parse_hardware_ports(
+                run(
+                    [
+                        "ssh",
+                        h.ssh_hostname,
+                        "networksetup",
+                        "-listallhardwareports",
+                    ],
+                    capture_output=True,
+                ).stdout
+            )
+        )
+
+    # Parse the connectivity into some simple dataclasses
+    tb_hosts = []
+    for c, iface_map in zip(thunderbolt_connections, interface_maps):
+        name = ""
+        ports = []
+        for t in c["SPThunderboltDataType"]:
+            name = t["device_name_key"]
+            uuid = t["domain_uuid_key"]
+            tag = t["receptacle_1_tag"]["receptacle_id_key"]
+            if items := t.get("_items", []):
+                connected_to = items[0]["domain_uuid_key"]
+            else:
+                connected_to = None
+            iface = iface_map[f"Thunderbolt {tag}"]
+            ports.append(ThunderboltPort(iface, uuid, connected_to))
+        tb_hosts.append(ThunderboltHost(name, sorted(ports, key=lambda x: x.iface)))
+
+    # Create a reverse index to be able to map uuids to (host, port) quickly
+    uuid_reverse_index = {}
+    for i, h in enumerate(tb_hosts):
+        for j, p in enumerate(h.ports):
+            uuid_reverse_index[p.uuid] = (i, j)
+
+    # Find the rings by simply walking and marking visited (host, port) tuples
+    # and keeping the largest rings greedily.
+    log(args.verbose, "Extracting rings from the parsed connectivity")
+    rings = extract_rings(tb_hosts, uuid_reverse_index)
+
+    # Just output a DOT graphical representation of the found rings
+    if args.dot:
+        names = []
+        for i in range(len(tb_hosts)):
+            n = ""
+            j = i
+            while True:
+                n += chr(97 + j % 26)
+                j //= 26
+                if j == 0:
+                    break
+            names.append(n)
+
+        print("graph G {")
+        print("  node [shape=rectangle];")
+        for i, h in enumerate(hosts):
+            print(f'  {names[i]} [label="{h.ssh_hostname}"];')
+        for r in rings:
+            for (i, _), (j, _) in r:
+                print(f"  {names[i]} -- {names[j]};")
+        print("}")
+        return
+
+    # Assign IPs to each interface such that the interfaces can communicate
+    ips = {}
+    pairs = {}
+    expecting = set()
+    ip0 = 0
+    ip1 = 0
+    netmask = "255.255.255.252"
+    for r in rings:
+        for a, b in r:
+            ips[a] = f"192.168.{ip0}.{ip1 + 1}"
+            ips[b] = f"192.168.{ip0}.{ip1 + 2}"
+            pairs[a] = b
+            pairs[b] = a
+            expecting.add(b)
+            ip1 += 4
+            if ip1 > 255:
+                ip0 += 1
+                ip1 = 0
+            if ip0 > 255:
+                raise ValueError("Ran out of available local IPs for the ring")
+
+    # Create the hostfile
+    hostfile = []
+    for i, h in enumerate(hosts):
+        host = {
+            "ssh": h.ssh_hostname,
+            "ips": [
+                ips[i, j]
+                for j, p in enumerate(tb_hosts[i].ports)
+                if (i, j) in expecting
+            ],
+        }
+        hostfile.append(host)
+
+    if not args.hostfile_only:
+        for i, h in enumerate(hosts):
+            command = ""
+            command += "sudo ifconfig bridge0 down\n"
+            for j, p in enumerate(tb_hosts[i].ports):
+                if (i, j) not in ips:
+                    continue
+                iface = p.iface
+                ip = ips[i, j]
+                peer = ips[pairs[i, j]]
+                command += f"sudo ifconfig {iface} inet {ip} netmask {netmask}\n"
+                command += f"sudo route change {peer} -interface {iface}\n"
+            if args.auto_setup:
+                print(f"Running auto setup for {h.ssh_hostname}")
+                command = command.strip().replace("\n", " && ")
+                command = ["ssh", h.ssh_hostname, command]
+                log(args.verbose, shlex.join(command))
+                run(command)
+            else:
+                msg = f"Setup for {h.ssh_hostname}"
+                print(msg)
+                print("=" * len(msg))
+                print(command)
+                input("Enter to continue")
+            print()
+
+    if args.output_hostfile:
+        with open(args.output_hostfile, "w") as f:
+            json.dump(hostfile, f, indent=4)
+    else:
+        print("Hostfile")
+        print("========")
+        print(json.dumps(hostfile, indent=4))
+
+
+def prepare_hostfile(args, hosts):
+    log(
+        args.verbose,
+        f"Preparing an ethernet hostfile for {', '.join(h.ssh_hostname for h in hosts)}",
+    )
+
+    # Check that we can ssh
+    check_ssh_connections(hosts)
+
+    # Get the ips for each host
+    for h in hosts:
+        log(args.verbose, "Getting the ip from", h.ssh_hostname)
+        h.ips.append(
+            run(
+                ["ssh", h.ssh_hostname, "ipconfig", "getifaddr", "en0"],
+                capture_output=True,
+                text=True,
+            ).stdout.strip()
+        )
+
+    hostfile = []
+    for h in hosts:
+        hostfile.append(dict(ssh=h.ssh_hostname, ips=h.ips))
+
+    if args.output_hostfile:
+        with open(args.output_hostfile, "w") as f:
+            json.dump(hostfile, f, indent=4)
+    else:
+        print("Hostfile")
+        print("========")
+        print(json.dumps(hostfile, indent=4))
+
+
+def distributed_config():
+    parser = argparse.ArgumentParser(
+        description="Configure remote machines for use with MLX distributed"
+    )
+    parser.add_argument(
+        "--verbose", action="store_true", help="Print debug messages in stdout"
+    )
+    parser.add_argument(
+        "--backend",
+        choices=["ring", "mpi", "nccl"],
+        default="nccl" if mx.cuda.is_available() else "ring",
+        help="Which distributed backend to configure",
+    )
+    parser.add_argument(
+        "--over",
+        choices=["thunderbolt", "ethernet"],
+        default="thunderbolt",
+        help="What type of connectivity to configure",
+    )
+    parser.add_argument(
+        "--hosts", default="127.0.0.1", help="A comma separated list of hosts"
+    )
+    parser.add_argument("--hostfile", help="The file containing the hosts")
+    parser.add_argument(
+        "--dot", action="store_true", help="Output the topology in DOT format and exit"
+    )
+    parser.add_argument(
+        "--hostfile-only", action="store_true", help="If set only compute the hostfile"
+    )
+    parser.add_argument(
+        "--output-hostfile", help="If provided, save the hostfile to this path"
+    )
+    parser.add_argument(
+        "--auto-setup",
+        action="store_true",
+        help="If set we will attempt to automatically configure the machines via ssh",
+    )
+    args = parser.parse_args()
+
+    if args.backend == "mpi" and args.over == "thunderbolt":
+        raise ValueError(
+            (
+                "The configuration of MPI over thunderbolt is "
+                "not supported yet by mlx.distributed_config"
+            )
+        )
+
+    if args.hostfile is not None:
+        hosts = parse_hostfile(parser, args.hostfile)
+    else:
+        hosts = parse_hostlist(parser, args.hosts, 1)
+
+    if args.over == "thunderbolt":
+        prepare_tb_ring(args, hosts)
+    else:
+        prepare_hostfile(args, hosts)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Launch an MLX distributed program")
+    parser.add_argument(
+        "--print-python",
+        action="store_true",
+        help="Print the path to the current python executable and exit",
+    )
+    parser.add_argument(
+        "--verbose", action="store_true", help="Print debug messages in stdout"
+    )
+    parser.add_argument(
+        "--hosts", default="127.0.0.1", help="A comma separated list of hosts"
+    )
+    parser.add_argument(
+        "--repeat-hosts",
+        "-n",
+        type=positive_number,
+        default=1,
+        help="Repeat each host a given number of times",
+    )
+    parser.add_argument("--hostfile", help="The file containing the hosts")
+    parser.add_argument(
+        "--backend",
+        choices=["ring", "mpi", "nccl"],
+        default="nccl" if mx.cuda.is_available() else "ring",
+        help="Which distributed backend to launch",
+    )
+    parser.add_argument(
+        "--env",
+        action="append",
+        default=[],
+        help="Set environment variables for the jobs",
+    )
+    parser.add_argument(
+        "--mpi-arg",
+        action="append",
+        default=[],
+        help="Arguments to pass directly to mpirun",
+    )
+    parser.add_argument(
+        "--connections-per-ip",
+        default=1,
+        type=int,
+        help="How many connections per ip to use for the ring backend",
+    )
+    parser.add_argument(
+        "--starting-port",
+        "-p",
+        type=int,
+        default=5000,
+        help="For the ring backend listen on this port increasing by 1 per rank and IP",
+    )
+    parser.add_argument(
+        "--cwd", help="Set the working directory on each node to the provided one"
+    )
+    parser.add_argument(
+        "--nccl-port",
+        type=int,
+        default=12345,
+        help="The port to use for the NCCL communication (only for nccl backend)",
+    )
+
+    args, rest = parser.parse_known_args()
+
+    if args.print_python:
+        print(sys.executable)
+        return
+
+    if len(rest) == 0:
+        parser.error("No script is provided")
+    if rest[0] == "--":
+        rest.pop(0)
+
+    # Try to extract a list of hosts and corresponding ips
+    if args.hostfile is not None:
+        hosts = parse_hostfile(parser, args.hostfile)
+    else:
+        hosts = parse_hostlist(parser, args.hosts, args.repeat_hosts)
+
+    # Check if the script is a file and convert it to a full path
+    if (script := Path(rest[0])).exists():
+        rest[0:1] = [sys.executable, str(script.resolve())]
+    elif (command := shutil.which(rest[0])) is not None:
+        rest[0] = command
+    else:
+        raise ValueError(f"Invalid script or command {rest[0]}")
+
+    # Launch
+    if args.backend == "ring":
+        launch_ring(parser, hosts, args, rest)
+    if args.backend == "mpi":
+        launch_mpi(parser, hosts, args, rest)
+    if args.backend == "nccl":
+        launch_nccl(parser, hosts, args, rest)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/extension.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/extension.py
new file mode 100644
index 0000000000000000000000000000000000000000..c426d59531c6c19262af6b7e049b1b180b3edc95
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/extension.py
@@ -0,0 +1,88 @@
+# Copyright © 2023 Apple Inc.
+
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+from setuptools import Extension
+from setuptools.command.build_ext import build_ext
+
+import mlx
+
+_MLX_PATH = str(mlx.__path__[0])
+
+
+# A CMakeExtension needs a sourcedir instead of a file list.
+class CMakeExtension(Extension):
+    def __init__(self, name: str, sourcedir: str = "") -> None:
+        super().__init__(name, sources=[])
+        self.sourcedir = os.fspath(Path(sourcedir).resolve())
+
+
+class CMakeBuild(build_ext):
+    def build_extension(self, ext: CMakeExtension) -> None:
+        # Must be in this form due to bug in .resolve() only fixed in Python 3.10+
+        ext_fullpath = Path.cwd() / self.get_ext_fullpath(ext.name)  # type: ignore[no-untyped-call]
+        extdir = ext_fullpath.parent.resolve()
+
+        debug = int(os.environ.get("DEBUG", 0)) if self.debug is None else self.debug
+        cfg = "Debug" if debug else "Release"
+
+        # Set Python_EXECUTABLE instead if you use PYBIND11_FINDPYTHON
+        # EXAMPLE_VERSION_INFO shows you how to pass a value into the C++ code
+        # from Python.
+        cmake_args = [
+            f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}{os.sep}",
+            f"-DCMAKE_BUILD_TYPE={cfg}",
+            "-DBUILD_SHARED_LIBS=ON",
+        ]
+        build_args = []
+        # Adding CMake arguments set as environment variable
+        # (needed e.g. to build for ARM OSx on conda-forge)
+        if "CMAKE_ARGS" in os.environ:
+            cmake_args += [item for item in os.environ["CMAKE_ARGS"].split(" ") if item]
+
+        if sys.platform.startswith("darwin"):
+            # Cross-compile support for macOS - respect ARCHFLAGS if set
+            archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", ""))
+            if archs:
+                cmake_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs))]
+
+        # Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level
+        # across all generators.
+        if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ:
+            build_args += [f"-j{os.cpu_count()}"]
+
+        build_temp = Path(self.build_temp) / ext.name
+        if not build_temp.exists():
+            build_temp.mkdir(parents=True)
+
+        # Make sure cmake can find MLX
+        os.environ["MLX_DIR"] = _MLX_PATH
+
+        subprocess.run(
+            ["cmake", ext.sourcedir, *cmake_args], cwd=build_temp, check=True
+        )
+        subprocess.run(
+            ["cmake", "--build", ".", *build_args], cwd=build_temp, check=True
+        )
+
+    def run(self) -> None:
+        super().run()
+
+        # Based on https://github.com/pypa/setuptools/blob/main/setuptools/command/build_ext.py#L102
+        if self.inplace:
+            for ext in self.extensions:
+                if isinstance(ext, CMakeExtension):
+                    # Resolve inplace package dir
+                    build_py = self.get_finalized_command("build_py")
+                    inplace_file, regular_file = self._get_inplace_equivalent(
+                        build_py, ext
+                    )
+
+                    inplace_dir = str(Path(inplace_file).parent.resolve())
+                    regular_dir = str(Path(regular_file).parent.resolve())
+
+                    self.copy_tree(regular_dir, inplace_dir)
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/__init__.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..df72e2a94fe0f203e152d591ec7e4703624610e0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/__init__.py
@@ -0,0 +1,5 @@
+# Copyright © 2023 Apple Inc.
+
+from mlx.nn import init, losses
+from mlx.nn.layers import *
+from mlx.nn.utils import average_gradients, value_and_grad
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/init.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/init.py
new file mode 100644
index 0000000000000000000000000000000000000000..68a9221c45f671d3d34cb3bda1deb27c82cb59bb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/init.py
@@ -0,0 +1,441 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+from typing import Callable, Literal
+
+import mlx.core as mx
+
+
+def constant(
+    value: float, dtype: mx.Dtype = mx.float32
+) -> Callable[[mx.array], mx.array]:
+    r"""An initializer that returns an array filled with ``value``.
+
+    Args:
+        value (float): The value to fill the array with.
+        dtype (Dtype, optional): The data type of the array. Default:
+          ``float32``.
+
+    Returns:
+        Callable[[array], array]: An initializer that returns an array with the
+        same shape as the input, filled with ``value``.
+
+    Example:
+
+        >>> init_fn = nn.init.constant(0.5)
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[0.5, 0.5],
+               [0.5, 0.5]], dtype=float32)
+    """
+
+    def initializer(a: mx.array) -> mx.array:
+        return mx.full(a.shape, value, dtype=dtype)
+
+    return initializer
+
+
+def normal(
+    mean: float = 0.0, std: float = 1.0, dtype: mx.Dtype = mx.float32
+) -> Callable[[mx.array], mx.array]:
+    r"""An initializer that returns samples from a normal distribution.
+
+    Args:
+        mean (float, optional): Mean of the normal distribution. Default:
+          ``0.0``.
+        std (float, optional): Standard deviation of the normal distribution.
+          Default: ``1.0``.
+        dtype (Dtype, optional): The data type of the array. Default:
+          ``float32``.
+
+    Returns:
+        Callable[[array], array]: An initializer that returns an array with the
+        same shape as the input, filled with samples from a normal distribution.
+
+    Example:
+
+        >>> init_fn = nn.init.normal()
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[-0.982273, -0.534422],
+               [0.380709, 0.0645099]], dtype=float32)
+    """
+
+    def initializer(a: mx.array) -> mx.array:
+        return mx.random.normal(shape=a.shape, scale=std, loc=mean, dtype=dtype)
+
+    return initializer
+
+
+def uniform(
+    low: float = 0.0, high: float = 1.0, dtype: mx.Dtype = mx.float32
+) -> Callable[[mx.array], mx.array]:
+    r"""An initializer that returns samples from a uniform distribution.
+
+    Args:
+        low (float, optional): The lower bound of the uniform distribution.
+          Default: ``0.0``.
+        high (float, optional): The upper bound of the uniform distribution.
+          Default: ``1.0``
+        dtype (Dtype, optional): The data type of the array. Default: ``float32``.
+
+    Returns:
+        Callable[[array], array]: An initializer that returns an array
+        with the same shape as the input, filled with samples from a uniform
+        distribution
+
+    Example:
+
+        >>> init_fn = nn.init.uniform(low=0, high=1)
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[0.883935, 0.863726],
+               [0.617261, 0.417497]], dtype=float32)
+    """
+
+    def initializer(a: mx.array) -> mx.array:
+        return mx.random.uniform(low, high, a.shape, dtype=dtype)
+
+    return initializer
+
+
+def identity(dtype: mx.Dtype = mx.float32) -> Callable[[mx.array], mx.array]:
+    r"""An initializer that returns an identity matrix.
+
+    Args:
+        dtype (Dtype, optional): The data type of the array. Defaults:
+          ``float32``.
+
+    Returns:
+        Callable[[array], array]: An initializer that returns an identity
+        matrix with the same shape as the input.
+
+    Example:
+
+        >>> init_fn = nn.init.identity()
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[1, 0],
+               [0, 1]], dtype=float32)
+    """
+
+    def initializer(arr: mx.array) -> mx.array:
+        if arr.ndim != 2 or arr.shape[0] != arr.shape[1]:
+            raise ValueError(
+                f"The input array must be a square matrix but got shape {arr.shape}."
+            )
+        return mx.eye(n=arr.shape[0], dtype=dtype)
+
+    return initializer
+
+
+def _calculate_fan_in_fan_out(x):
+    if x.ndim < 2:
+        raise ValueError(
+            "Glorot / He initialization requires at least 2 dimensional input"
+            f" but input with {x.ndim} dimensions."
+        )
+
+    fan_in = x.shape[-1]
+    fan_out = x.shape[0]
+
+    if x.ndim > 2:
+        receptive_field = 1
+        for d in x.shape[1:-1]:
+            receptive_field *= d
+
+        fan_in = fan_in * receptive_field
+        fan_out = fan_out * receptive_field
+
+    return fan_in, fan_out
+
+
+def glorot_normal(
+    dtype: mx.Dtype = mx.float32,
+) -> Callable[[mx.array, float], mx.array]:
+    r"""A Glorot normal initializer.
+
+    This initializer samples from a normal distribution with a standard
+    deviation computed from the number of input (``fan_in``) and output
+    (``fan_out``) units according to:
+
+    .. math::
+        \sigma = \gamma \sqrt{\frac{2.0}{\text{fan\_in} + \text{fan\_out}}}
+
+    For more details see the original reference: `Understanding the difficulty
+    of training deep feedforward neural networks
+    <https://proceedings.mlr.press/v9/glorot10a.html>`_
+
+    Args:
+        dtype (Dtype, optional): The data type of the array. Default: ``float32``.
+
+    Returns:
+        Callable[[array, float], array]: An initializer that returns an array
+        with the same shape as the input, filled with samples from the Glorot
+        normal distribution.
+
+    Example:
+
+        >>> init_fn = nn.init.glorot_normal()
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[0.191107, 1.61278],
+               [-0.150594, -0.363207]], dtype=float32)
+        >>> init_fn(mx.zeros((2, 2)), gain=4.0)
+        array([[1.89613, -4.53947],
+               [4.48095, 0.995016]], dtype=float32)
+    """
+
+    def initializer(a: mx.array, gain: float = 1.0) -> mx.array:
+        fan_in, fan_out = _calculate_fan_in_fan_out(a)
+        std = gain * math.sqrt(2.0 / (fan_in + fan_out))
+        return mx.random.normal(shape=a.shape, scale=std, dtype=dtype)
+
+    return initializer
+
+
+def glorot_uniform(
+    dtype: mx.Dtype = mx.float32,
+) -> Callable[[mx.array, float], mx.array]:
+    r"""A Glorot uniform initializer.
+
+    This initializer samples from a uniform distribution with a range
+    computed from the number of input (``fan_in``) and output (``fan_out``)
+    units according to:
+
+    .. math::
+        \sigma = \gamma \sqrt{\frac{6.0}{\text{fan\_in} + \text{fan\_out}}}
+
+    For more details see the original reference: `Understanding the difficulty
+    of training deep feedforward neural networks
+    <https://proceedings.mlr.press/v9/glorot10a.html>`_
+
+    Args:
+        dtype (Dtype, optional): The data type of the array. Default: ``float32``.
+
+    Returns:
+        Callable[[array, float], array]: An initializer that returns an array
+        with the same shape as the input, filled with samples from the Glorot
+        uniform distribution.
+
+    Example:
+
+        >>> init_fn = nn.init.glorot_uniform()
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[0.223404, -0.890597],
+               [-0.379159, -0.776856]], dtype=float32)
+        >>> init_fn(mx.zeros((2, 2)), gain=4.0)
+        array([[-1.90041, 3.02264],
+               [-0.912766, 4.12451]], dtype=float32)
+    """
+
+    def initializer(a: mx.array, gain: float = 1.0) -> mx.array:
+        fan_in, fan_out = _calculate_fan_in_fan_out(a)
+        limit = gain * math.sqrt(6.0 / (fan_in + fan_out))
+        return mx.random.uniform(-limit, limit, a.shape, dtype=dtype)
+
+    return initializer
+
+
+def he_normal(
+    dtype: mx.Dtype = mx.float32,
+) -> Callable[[mx.array, Literal["fan_in", "fan_out"], float], mx.array]:
+    r"""Build a He normal initializer.
+
+    This initializer samples from a normal distribution with a standard
+    deviation computed from the number of input (``fan_in``) or output
+    (``fan_out``) units according to:
+
+    .. math::
+        \sigma = \gamma \frac{1}{\sqrt{\text{fan}}}
+
+    where :math:`\text{fan}` is either the number of input units when the
+    ``mode`` is ``"fan_in"`` or output units when the ``mode`` is
+    ``"fan_out"``.
+
+    For more details see the original reference: `Delving Deep into Rectifiers:
+    Surpassing Human-Level Performance on ImageNet Classification
+    <https://arxiv.org/abs/1502.01852>`_
+
+    Args:
+        dtype (Dtype, optional): The data type of the array. Defaults to mx.float32.
+
+    Returns:
+        Callable[[array, str, float], array]: An initializer that returns an
+        array with the same shape as the input, filled with samples from the He
+        normal distribution.
+
+    Example:
+
+        >>> init_fn = nn.init.he_normal()
+        >>> init_fn(mx.zeros((2, 2)))  # uses fan_in
+        array([[-1.25211, 0.458835],
+               [-0.177208, -0.0137595]], dtype=float32)
+        >>> init_fn(mx.zeros((2, 2)), mode="fan_out", gain=5)
+        array([[5.6967, 4.02765],
+               [-4.15268, -2.75787]], dtype=float32)
+    """
+
+    def initializer(
+        a: mx.array,
+        mode: Literal["fan_in", "fan_out"] = "fan_in",
+        gain: float = 1.0,
+    ) -> mx.array:
+        fan_in, fan_out = _calculate_fan_in_fan_out(a)
+        if mode == "fan_in":
+            fan = fan_in
+        elif mode == "fan_out":
+            fan = fan_out
+        else:
+            raise ValueError(f"Invalid mode: {mode}. Valid modes are: fan_in, fan_out")
+
+        std = gain / math.sqrt(fan)
+        return mx.random.normal(shape=a.shape, scale=std, dtype=dtype)
+
+    return initializer
+
+
+def he_uniform(
+    dtype: mx.Dtype = mx.float32,
+) -> Callable[[mx.array, Literal["fan_in", "fan_out"], float], mx.array]:
+    r"""A He uniform (Kaiming uniform) initializer.
+
+    This initializer samples from a uniform distribution with a range
+    computed from the number of input (``fan_in``) or output (``fan_out``)
+    units according to:
+
+    .. math::
+
+        \sigma = \gamma \sqrt{\frac{3.0}{\text{fan}}}
+
+    where :math:`\text{fan}` is either the number of input units when the
+    ``mode`` is ``"fan_in"`` or output units when the ``mode`` is
+    ``"fan_out"``.
+
+    For more details see the original reference: `Delving Deep into Rectifiers:
+    Surpassing Human-Level Performance on ImageNet Classification
+    <https://arxiv.org/abs/1502.01852>`_
+
+
+    Args:
+        dtype (Dtype, optional): The data type of the array. Default: ``float32``.
+
+    Returns:
+        Callable[[array, str, float], array]: An initializer that returns an
+        array with the same shape as the input, filled with samples from  the
+        He uniform distribution.
+
+    Example:
+
+        >>> init_fn = nn.init.he_uniform()
+        >>> init_fn(mx.zeros((2, 2)))  # uses fan_in
+        array([[0.0300242, -0.0184009],
+               [0.793615, 0.666329]], dtype=float32)
+        >>> init_fn(mx.zeros((2, 2)), mode="fan_out", gain=5)
+        array([[-1.64331, -2.16506],
+               [1.08619, 5.79854]], dtype=float32)
+    """
+
+    def initializer(
+        a: mx.array,
+        mode: Literal["fan_in", "fan_out"] = "fan_in",
+        gain: float = 1.0,
+    ) -> mx.array:
+        fan_in, fan_out = _calculate_fan_in_fan_out(a)
+        if mode == "fan_in":
+            fan = fan_in
+        elif mode == "fan_out":
+            fan = fan_out
+        else:
+            raise ValueError(f"Invalid mode: {mode}. Valid modes are: fan_in, fan_out")
+
+        limit = gain * math.sqrt(3.0 / fan)
+        return mx.random.uniform(-limit, limit, a.shape, dtype=dtype)
+
+    return initializer
+
+
+def sparse(
+    sparsity: float,
+    mean: float = 0.0,
+    std: float = 1.0,
+    dtype: mx.Dtype = mx.float32,
+) -> Callable[[mx.array], mx.array]:
+    r"""An initializer that returns a sparse matrix.
+
+    Args:
+        sparsity (float): The fraction of elements in each column to be set to
+        zero.
+        mean (float, optional): Mean of the normal distribution. Default:
+          ``0.0``.
+        std (float, optional): Standard deviation of the normal distribution.
+          Default: ``1.0``.
+        dtype (Dtype, optional): The data type of the array. Default:
+          ``float32``.
+
+    Returns:
+        Callable[[array], array]: An initializer that returns an array with the
+        same shape as the input, filled with samples from a normal distribution.
+
+    Example:
+
+        >>> init_fn = nn.init.sparse(sparsity=0.5)
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[-1.91187, -0.117483],
+       [0, 0]], dtype=float32)
+    """
+
+    def initializer(a: mx.array) -> mx.array:
+        if a.ndim != 2:
+            raise ValueError("Only tensors with 2 dimensions are supported")
+
+        rows, cols = a.shape
+        num_zeros = int(math.ceil(sparsity * cols))
+
+        order = mx.argsort(mx.random.uniform(shape=a.shape), axis=1)
+        a = mx.random.normal(shape=a.shape, scale=std, loc=mean, dtype=dtype)
+
+        a[mx.arange(rows).reshape(rows, 1), order[:, :num_zeros]] = 0
+
+        return a
+
+    return initializer
+
+
+def orthogonal(
+    gain: float = 1.0, dtype: mx.Dtype = mx.float32
+) -> Callable[[mx.array], mx.array]:
+    r"""An initializer that returns an orthogonal matrix.
+
+    Args:
+        gain (float, optional): Scaling factor for the orthogonal matrix.
+            Default: ``1.0``.
+        dtype (Dtype, optional): Data type of the array. Default: ``float32``.
+
+    Returns:
+        Callable[[array], array]: An initializer that returns
+        an orthogonal matrix with the same shape as the input.
+    """
+
+    def initializer(a: mx.array) -> mx.array:
+        if a.ndim != 2:
+            raise ValueError(
+                f"Orthogonal initialization requires a 2D array but got"
+                " a {a.ndim}D array."
+            )
+
+        rows, cols = a.shape
+        n = max(rows, cols)
+
+        rmat = mx.random.normal(shape=(n, n))
+
+        # Perform QR decomposition on CPU
+        q, r = mx.linalg.qr(rmat, stream=mx.cpu)
+
+        # Adjust the sign of Q using the diagonal of R
+        d = mx.diag(r)
+        q = q * mx.sign(d)
+
+        # Slice Q to the desired shape
+        q = q[:rows, :cols]
+
+        # Scale Q by gain
+        q = q * gain
+        return q.astype(dtype)
+
+    return initializer
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/__init__.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea2d3029d8855ca3711c11580025ba891182676a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/__init__.py
@@ -0,0 +1,100 @@
+# Copyright © 2023 Apple Inc.
+
+from mlx.nn.layers.activations import (
+    CELU,
+    ELU,
+    GELU,
+    GLU,
+    SELU,
+    HardShrink,
+    Hardswish,
+    HardTanh,
+    LeakyReLU,
+    LogSigmoid,
+    LogSoftmax,
+    Mish,
+    PReLU,
+    ReLU,
+    ReLU2,
+    ReLU6,
+    Sigmoid,
+    SiLU,
+    Softmax,
+    Softmin,
+    Softplus,
+    Softshrink,
+    Softsign,
+    Step,
+    Tanh,
+    celu,
+    elu,
+    gelu,
+    gelu_approx,
+    gelu_fast_approx,
+    glu,
+    hard_shrink,
+    hard_tanh,
+    hardswish,
+    leaky_relu,
+    log_sigmoid,
+    log_softmax,
+    mish,
+    prelu,
+    relu,
+    relu2,
+    relu6,
+    selu,
+    sigmoid,
+    silu,
+    softmax,
+    softmin,
+    softplus,
+    softshrink,
+    softsign,
+    step,
+    tanh,
+)
+from mlx.nn.layers.base import Module
+from mlx.nn.layers.containers import Sequential
+from mlx.nn.layers.convolution import Conv1d, Conv2d, Conv3d
+from mlx.nn.layers.convolution_transpose import (
+    ConvTranspose1d,
+    ConvTranspose2d,
+    ConvTranspose3d,
+)
+from mlx.nn.layers.distributed import (
+    AllToShardedLinear,
+    QuantizedAllToShardedLinear,
+    QuantizedShardedToAllLinear,
+    ShardedToAllLinear,
+)
+from mlx.nn.layers.dropout import Dropout, Dropout2d, Dropout3d
+from mlx.nn.layers.embedding import Embedding
+from mlx.nn.layers.linear import Bilinear, Identity, Linear
+from mlx.nn.layers.normalization import (
+    BatchNorm,
+    GroupNorm,
+    InstanceNorm,
+    LayerNorm,
+    RMSNorm,
+)
+from mlx.nn.layers.pooling import (
+    AvgPool1d,
+    AvgPool2d,
+    AvgPool3d,
+    MaxPool1d,
+    MaxPool2d,
+    MaxPool3d,
+)
+from mlx.nn.layers.positional_encoding import ALiBi, RoPE, SinusoidalPositionalEncoding
+from mlx.nn.layers.quantized import QuantizedEmbedding, QuantizedLinear, quantize
+from mlx.nn.layers.recurrent import GRU, LSTM, RNN
+from mlx.nn.layers.transformer import (
+    MultiHeadAttention,
+    Transformer,
+    TransformerDecoder,
+    TransformerDecoderLayer,
+    TransformerEncoder,
+    TransformerEncoderLayer,
+)
+from mlx.nn.layers.upsample import Upsample
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/activations.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/activations.py
new file mode 100644
index 0000000000000000000000000000000000000000..360bb113d5a1cdecaba16f35068045329d77046f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/activations.py
@@ -0,0 +1,661 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from functools import partial
+from typing import Any
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+def _make_activation_module(f):
+    def decorator(klass):
+        klass.__call__ = lambda _, x: f(x)
+        return klass
+
+    return decorator
+
+
+@partial(mx.compile, shapeless=True)
+def sigmoid(x):
+    r"""Applies the sigmoid function.
+
+    .. math::
+        \text{Sigmoid}(x) = \sigma(x) = \frac{1}{1 + \exp(-x)}
+    """
+    return mx.sigmoid(x)
+
+
+@partial(mx.compile, shapeless=True)
+def relu(x):
+    r"""Applies the Rectified Linear Unit.
+
+    Simply ``mx.maximum(x, 0)``.
+    """
+    return mx.maximum(x, 0)
+
+
+@partial(mx.compile, shapeless=True)
+def relu2(x):
+    r"""Applies the ReLU² activation function.
+
+    Applies :math:`\max(0, x)^2` element wise.
+    """
+    return mx.square(mx.maximum(x, 0))
+
+
+@partial(mx.compile, shapeless=True)
+def relu6(x):
+    r"""Applies the Rectified Linear Unit 6.
+
+    Applies :math:`\min(\max(x, 0), 6)` element wise.
+    """
+    return mx.minimum(mx.maximum(x, 0), 6.0)
+
+
+@partial(mx.compile, shapeless=True)
+def leaky_relu(x, negative_slope=0.01):
+    r"""Applies the Leaky Rectified Linear Unit.
+
+    Simply ``mx.maximum(negative_slope * x, x)``.
+    """
+    return mx.maximum(negative_slope * x, x)
+
+
+@partial(mx.compile, shapeless=True)
+def log_softmax(x, axis=-1):
+    r"""Applies the Log Softmax function.
+
+    Applies :math:`x + \log \sum_i e^{x_i}` element wise.
+    """
+    return x - mx.logsumexp(x, axis=axis, keepdims=True)
+
+
+@partial(mx.compile, shapeless=True)
+def elu(x, alpha=1.0):
+    r"""Applies the Exponential Linear Unit.
+
+    Simply ``mx.where(x > 0, x, alpha * (mx.exp(x) - 1))``.
+    """
+    return mx.where(x > 0, x, alpha * (mx.exp(x) - 1))
+
+
+@partial(mx.compile, shapeless=True)
+def softmax(x, axis=-1):
+    r"""Applies the Softmax function.
+
+    Applies :math:`\frac{e^{x_i}}{\sum_j e^{x_j}}` element wise.
+    """
+    return mx.softmax(x, axis=axis)
+
+
+@partial(mx.compile, shapeless=True)
+def softplus(x):
+    r"""Applies the Softplus function.
+
+    Applies :math:`\log(1 + \exp(x))` element wise.
+    """
+    return mx.logaddexp(x, 0)
+
+
+@partial(mx.compile, shapeless=True)
+def softsign(x):
+    r"""Applies the Softsign function.
+
+    Applies :math:`\frac{x}{1 + |x|}` element wise.
+    """
+    return mx.divide(x, 1 + mx.abs(x))
+
+
+@partial(mx.compile, shapeless=True)
+def softshrink(x, lambd: float = 0.5):
+    r"""Applies the Softshrink activation function.
+
+    .. math::
+        \text{softshrink}(x) = \begin{cases}
+        x - \lambda & \text{if } x > \lambda \\
+        x + \lambda & \text{if } x < -\lambda \\
+        0 & \text{otherwise}
+        \end{cases}
+    """
+    return mx.where(mx.abs(x) > lambd, x - mx.sign(x) * lambd, 0)
+
+
+@partial(mx.compile, shapeless=True)
+def celu(x, alpha=1.0):
+    r"""Applies the Continuously Differentiable Exponential Linear Unit.
+
+    Applies :math:`\max(0, x) + \min(0, \alpha * (\exp(x / \alpha) - 1))`
+    element wise.
+    """
+    return mx.maximum(x, 0.0) + alpha * (mx.exp(mx.minimum(x, 0.0) / alpha) - 1)
+
+
+@partial(mx.compile, shapeless=True)
+def silu(x):
+    r"""Applies the Sigmoid Linear Unit. Also known as Swish.
+
+    Applies :math:`x \sigma(x)` element wise, where :math:`\sigma(\cdot)` is
+    the logistic sigmoid.
+    """
+    return x * mx.sigmoid(x)
+
+
+@partial(mx.compile, shapeless=True)
+def log_sigmoid(x):
+    r"""Applies the Log Sigmoid function.
+
+    Applies :math:`\log(\sigma(x)) = -\log(1 + e^{-x})` element wise.
+    """
+    return -softplus(-x)
+
+
+@partial(mx.compile, shapeless=True)
+def gelu(x) -> mx.array:
+    r"""Applies the Gaussian Error Linear Units function.
+
+    .. math::
+        \textrm{GELU}(x) = x * \Phi(x)
+
+    where :math:`\Phi(x)` is the Gaussian CDF.
+
+    See also :func:`gelu_approx` and :func:`gelu_fast_approx` for faster
+    approximations.
+    """
+    return x * (1 + mx.erf(x / math.sqrt(2))) / 2
+
+
+@partial(mx.compile, shapeless=True)
+def gelu_approx(x):
+    r"""An approximation to Gaussian Error Linear Unit.
+
+    See :func:`gelu` for the exact computation.
+
+    This function approximates ``gelu`` with a maximum absolute error :math:`<
+    0.0005` in the range :math:`[-6, 6]` using the following
+
+    .. math::
+
+        x = 0.5 * x * \left(1 + \text{Tanh}\left((\sqrt{2 / \pi} * \left(x + 0.044715 * x^3\right)\right)\right)
+
+    """
+    return 0.5 * x * (1 + mx.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * x**3)))
+
+
+@partial(mx.compile, shapeless=True)
+def gelu_fast_approx(x):
+    r"""A fast approximation to Gaussian Error Linear Unit.
+
+    See :func:`gelu` for the exact computation.
+
+    This function approximates ``gelu`` with a maximum absolute error :math:`<
+    0.015` in the range :math:`[-6, 6]` using the following
+
+    .. math::
+
+        x = x \sigma\left(1.702 x\right)
+
+    where :math:`\sigma(\cdot)` is the logistic sigmoid.
+
+    References:
+    - https://github.com/hendrycks/GELUs
+    - https://arxiv.org/abs/1606.08415
+    """
+    return x * mx.sigmoid(1.702 * x)
+
+
+def glu(x: mx.array, axis: int = -1) -> mx.array:
+    r"""Applies the gated linear unit function.
+
+    This function splits the ``axis`` dimension of the input into two halves
+    (:math:`a` and :math:`b`) and applies :math:`a * \sigma(b)`.
+
+    .. math::
+        \textrm{GLU}(x) = a * \sigma(b)
+
+    Args:
+        axis (int): The dimension to split along. Default: ``-1``
+    """
+    a, b = mx.split(x, indices_or_sections=2, axis=axis)
+    return a * mx.sigmoid(b)
+
+
+@partial(mx.compile, shapeless=True)
+def step(x: mx.array, threshold: float = 0.0):
+    r"""Applies the Step Activation Function.
+
+    This function implements a binary step activation, where the output is set
+    to 1 if the input is greater than a specified threshold, and 0 otherwise.
+
+    .. math::
+        \text{step}(x) = \begin{cases}
+        0 & \text{if } x < \text{threshold} \\
+        1 & \text{if } x \geq \text{threshold}
+        \end{cases}
+
+    Args:
+        threshold: The value to threshold at.
+    """
+
+    return mx.where(x > threshold, 1, 0)
+
+
+@partial(mx.compile, shapeless=True)
+def selu(x):
+    r"""Applies the Scaled Exponential Linear Unit.
+
+    .. math::
+        \text{selu}(x) = \begin{cases}
+        \lambda x & \text{if } x > 0 \\
+        \lambda \alpha (\exp(x) - 1) & \text{if } x \leq 0
+        \end{cases}
+
+    where :math:`\lambda = 1.0507` and :math:`\alpha = 1.67326`.
+
+    See also :func:`elu`.
+    """
+    return elu(x, 1.67326) * 1.0507
+
+
+@partial(mx.compile, shapeless=True)
+def prelu(x: mx.array, alpha: mx.array) -> mx.array:
+    r"""Applies the element-wise parametric ReLU.
+
+    .. math::
+        \text{PReLU}(x) = \max(0,x) + a * \min(0,x)
+
+    where :math:`a` is an array.
+    """
+    return mx.maximum(0, x) + alpha * mx.minimum(0, x)
+
+
+@partial(mx.compile, shapeless=True)
+def mish(x: mx.array) -> mx.array:
+    r"""Applies the Mish function, element-wise.
+
+    Mish: A Self Regularized Non-Monotonic Neural Activation Function.
+
+    Reference: https://arxiv.org/abs/1908.08681
+
+    .. math::
+        \text{Mish}(x) = x * \text{Tanh}(\text{Softplus}(x))
+
+    """
+    return x * mx.tanh(softplus(x))
+
+
+@partial(mx.compile, shapeless=True)
+def hardswish(x):
+    r"""Applies the hardswish function, element-wise.
+
+    .. math::
+        \text{Hardswish}(x) = x * \min(\max(x + 3, 0), 6) / 6
+    """
+    max_x_3 = mx.maximum(x + 3, 0)
+    return x * mx.minimum(max_x_3, 6) / 6
+
+
+@partial(mx.compile, shapeless=True)
+def hard_tanh(x, min_val=-1.0, max_val=1.0):
+    r"""Applies the HardTanh function.
+
+    Applies :math:`\max(\min(x, \text{max\_val}), \text{min\_val})` element-wise.
+    """
+    return mx.minimum(mx.maximum(x, min_val), max_val)
+
+
+@partial(mx.compile, shapeless=True)
+def hard_shrink(x, lambd=0.5):
+    r"""Applies the HardShrink activation function.
+
+    .. math::
+        \text{hardshrink}(x) = \begin{cases}
+        x & \text{if } x > \lambda \\
+        x & \text{if } x < -\lambda \\
+        0 & \text{otherwise}
+        \end{cases}
+    """
+    return mx.where(mx.abs(x) > lambd, x, 0)
+
+
+@partial(mx.compile, shapeless=True)
+def softmin(x, axis=-1):
+    r"""Applies the Softmin function.
+
+    Applies :math:`\frac{e^{-x_i}}{\sum_j e^{-x_j}}` element-wise.
+    """
+    return mx.softmax(-x, axis=axis)
+
+
+def tanh(x):
+    """Applies the hyperbolic tangent function.
+
+    Simply ``mx.tanh(x)``.
+    """
+    return mx.tanh(x)
+
+
+class GLU(Module):
+    r"""Applies the gated linear unit function.
+
+    This function splits the ``axis`` dimension of the input into two halves
+    (:math:`a` and :math:`b`) and applies :math:`a * \sigma(b)`.
+
+    .. math::
+        \textrm{GLU}(x) = a * \sigma(b)
+
+    Args:
+        axis (int): The dimension to split along. Default: ``-1``
+    """
+
+    def __init__(self, axis: int = -1):
+        super().__init__()
+        self.axis = axis
+
+    def __call__(self, x) -> Any:
+        return glu(x=x, axis=self.axis)
+
+
+@_make_activation_module(sigmoid)
+class Sigmoid(Module):
+    r"""Applies the sigmoid function, element-wise.
+
+    .. math::
+        \text{Sigmoid}(x) = \sigma(x) = \frac{1}{1 + \exp(-x)}
+    """
+
+
+@_make_activation_module(mish)
+class Mish(Module):
+    r"""Applies the Mish function, element-wise.
+
+    Reference: https://arxiv.org/abs/1908.08681
+
+    .. math::
+        \text{Mish}(x) = x * \text{Tanh}(\text{Softplus}(x))
+
+    """
+
+
+@_make_activation_module(relu)
+class ReLU(Module):
+    r"""Applies the Rectified Linear Unit.
+        Simply ``mx.maximum(x, 0)``.
+
+    See :func:`relu` for the functional equivalent.
+    """
+
+
+@_make_activation_module(relu2)
+class ReLU2(Module):
+    r"""Applies the ReLU² activation function.
+
+    See :func:`relu2` for the functional equivalent.
+    """
+
+
+@_make_activation_module(relu6)
+class ReLU6(Module):
+    r"""Applies the Rectified Linear Unit 6.
+
+    See :func:`relu6` for the functional equivalent.
+    """
+
+
+class LeakyReLU(Module):
+    r"""Applies the Leaky Rectified Linear Unit.
+
+    Simply ``mx.maximum(negative_slope * x, x)``.
+
+    Args:
+        negative_slope: Controls the angle of the negative slope. Default: ``1e-2``
+    """
+
+    def __init__(self, negative_slope=1e-2):
+        super().__init__()
+        self._negative_slope = negative_slope
+
+    def __call__(self, x):
+        return leaky_relu(x, self._negative_slope)
+
+
+class ELU(Module):
+    r"""Applies the Exponential Linear Unit.
+        Simply ``mx.where(x > 0, x, alpha * (mx.exp(x) - 1))``.
+
+    See :func:`elu` for the functional equivalent.
+
+    Args:
+        alpha: the :math:`\alpha` value for the ELU formulation. Default: ``1.0``
+    """
+
+    def __init__(self, alpha=1.0):
+        super().__init__()
+        self._alpha = alpha
+
+    def __call__(self, x):
+        return elu(x, self._alpha)
+
+
+@_make_activation_module(softmax)
+class Softmax(Module):
+    r"""Applies the Softmax function.
+
+    See :func:`softmax` for the functional equivalent.
+    """
+
+
+@_make_activation_module(softplus)
+class Softplus(Module):
+    r"""Applies the Softplus function.
+
+    See :func:`softplus` for the functional equivalent.
+    """
+
+
+@_make_activation_module(softsign)
+class Softsign(Module):
+    r"""Applies the Softsign function.
+
+    See :func:`softsign` for the functional equivalent.
+    """
+
+
+class Softshrink(Module):
+    r"""Applies the Softshrink function.
+
+    See :func:`softshrink` for the functional equivalent.
+
+    Args:
+        lambd: the :math:`\lambda` value for Softshrink. Default: ``0.5``
+    """
+
+    def __init__(self, lambd=0.5):
+        super().__init__()
+        self.lambd = lambd
+
+    def __call__(self, x):
+        return softshrink(x, self.lambd)
+
+
+class CELU(Module):
+    r"""Applies the Continuously Differentiable Exponential Linear Unit.
+        Applies :math:`\max(0, x) + \min(0, \alpha * (\exp(x / \alpha) - 1))`
+        element wise.
+
+    See :func:`celu` for the functional equivalent.
+
+    Args:
+        alpha: the :math:`\alpha` value for the CELU formulation. Default: ``1.0``
+    """
+
+    def __init__(self, alpha=1.0):
+        super().__init__()
+        self._alpha = alpha
+
+    def __call__(self, x):
+        return celu(x, self._alpha)
+
+
+@_make_activation_module(silu)
+class SiLU(Module):
+    r"""Applies the Sigmoid Linear Unit. Also known as Swish.
+
+    See :func:`silu` for the functional equivalent.
+    """
+
+
+@_make_activation_module(log_softmax)
+class LogSoftmax(Module):
+    r"""Applies the Log Softmax function.
+
+    See :func:`log_softmax` for the functional equivalent.
+    """
+
+
+@_make_activation_module(log_sigmoid)
+class LogSigmoid(Module):
+    r"""Applies the Log Sigmoid function.
+
+    See :func:`log_sigmoid` for the functional equivalent.
+    """
+
+
+class PReLU(Module):
+    r"""Applies the element-wise parametric ReLU.
+        Applies :math:`\max(0, x) + a * \min(0, x)` element wise, where :math:`a`
+        is an array.
+
+    See :func:`prelu` for the functional equivalent.
+
+    Args:
+        num_parameters: number of :math:`a` to learn. Default: ``1``
+        init: the initial value of :math:`a`. Default: ``0.25``
+    """
+
+    def __init__(self, num_parameters=1, init=0.25):
+        super().__init__()
+        self.weight = mx.full([num_parameters], init)
+
+    def __call__(self, x: mx.array):
+        return prelu(x, self.weight)
+
+
+class GELU(Module):
+    r"""Applies the Gaussian Error Linear Units.
+
+    .. math::
+        \textrm{GELU}(x) = x * \Phi(x)
+
+    where :math:`\Phi(x)` is the Gaussian CDF.
+
+    However, if ``approx`` is set to 'precise' or 'fast' it applies
+
+    .. math::
+        \textrm{GELUApprox}(x) &= 0.5 * x * \left(1 + \text{Tanh}\left((\sqrt{2 / \pi} * \left(x + 0.044715 * x^3\right)\right)\right) \\
+        \textrm{GELUFast}(x) &= x * \sigma\left(1.702 * x\right)
+
+    respectively.
+
+    .. note::
+       For compatibility with the PyTorch API, 'tanh' can be used as an alias
+       for 'precise'.
+
+    See :func:`gelu`, :func:`gelu_approx` and :func:`gelu_fast_approx` for the
+    functional equivalents and information regarding error bounds.
+
+
+    Args:
+        approx ('none' | 'precise' | 'fast'): Which approximation to gelu to use if any.
+    """
+
+    def __init__(self, approx="none"):
+        super().__init__()
+        self._approx = approx
+        allowed = ["none", "precise", "tanh", "fast"]
+        if approx not in allowed:
+            raise ValueError(
+                f"The approximation should be in {allowed} but '{approx}' was given"
+            )
+
+    def __call__(self, x):
+        if self._approx == "none":
+            return gelu(x)
+        elif self._approx in ["precise", "tanh"]:
+            return gelu_approx(x)
+        return gelu_fast_approx(x)
+
+
+@_make_activation_module(tanh)
+class Tanh(Module):
+    r"""Applies the hyperbolic tangent function.
+
+    See :func:`tanh` for the functional equivalent.
+    """
+
+
+@_make_activation_module(hardswish)
+class Hardswish(Module):
+    r"""Applies the hardswish function, element-wise.
+
+    See :func:`hardswish` for the functional equivalent.
+    """
+
+
+class Step(Module):
+    r"""Applies the Step Activation Function.
+
+    This function implements a binary step activation, where the output is set
+    to 1 if the input is greater than a specified threshold, and 0 otherwise.
+
+    .. math::
+        \text{step}(x) = \begin{cases}
+        0 & \text{if } x < \text{threshold} \\
+        1 & \text{if } x \geq \text{threshold}
+        \end{cases}
+
+    Args:
+        threshold: The value to threshold at.
+    """
+
+    def __init__(self, threshold: float = 0.0):
+        super().__init__()
+        self.threshold = threshold
+
+    def __call__(self, x: mx.array):
+        return step(x, self.threshold)
+
+
+@_make_activation_module(selu)
+class SELU(Module):
+    r"""Applies the Scaled Exponential Linear Unit.
+
+    See :func:`selu` for the functional equivalent.
+    """
+
+
+@_make_activation_module(hard_tanh)
+class HardTanh(Module):
+    r"""Applies the HardTanh function.
+
+    See :func:`hard_tanh` for the functional equivalent.
+    """
+
+
+@_make_activation_module(hard_shrink)
+class HardShrink(Module):
+    r"""Applies the HardShrink function.
+
+    See :func:`hard_shrink` for the functional equivalent.
+
+    Args:
+        lambd: the :math:`\lambda` value for Hardshrink. Default: ``0.5``
+    """
+
+
+@_make_activation_module(softmin)
+class Softmin(Module):
+    r"""Applies the Softmin function.
+
+    See :func:`softmin` for the functional equivalent.
+    """
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/base.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ae92727999dec83b3b4cb9f60598b4109eb228f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/base.py
@@ -0,0 +1,671 @@
+# Copyright © 2023 Apple Inc.
+
+from __future__ import annotations
+
+import textwrap
+from typing import Any, Callable, List, Optional, Tuple, Union
+
+import mlx.core as mx
+from mlx.utils import tree_flatten, tree_unflatten
+
+
+class Module(dict):
+    """Base class for building neural networks with MLX.
+
+    All the layers provided in :mod:`mlx.nn.layers` subclass this class and
+    your models should do the same.
+
+    A ``Module`` can contain other ``Module`` instances or :class:`mlx.core.array`
+    instances in arbitrary nesting of python lists or dicts. The ``Module``
+    then allows recursively extracting all the :class:`mlx.core.array` instances
+    using :meth:`mlx.nn.Module.parameters`.
+
+    In addition, the ``Module`` has the concept of trainable and non trainable
+    parameters (called "frozen"). When using :func:`mlx.nn.value_and_grad`
+    the gradients are returned only with respect to the trainable parameters.
+    All arrays in a module are trainable unless they are added in the "frozen"
+    set by calling :meth:`freeze`.
+
+    .. code-block:: python
+
+        import mlx.core as mx
+        import mlx.nn as nn
+
+        class MyMLP(nn.Module):
+            def __init__(self, in_dims: int, out_dims: int, hidden_dims: int = 16):
+                super().__init__()
+
+                self.in_proj = nn.Linear(in_dims, hidden_dims)
+                self.out_proj = nn.Linear(hidden_dims, out_dims)
+
+            def __call__(self, x):
+                x = self.in_proj(x)
+                x = mx.maximum(x, 0)
+                return self.out_proj(x)
+
+        model = MyMLP(2, 1)
+
+        # All the model parameters are created but since MLX is lazy by
+        # default, they are not evaluated yet. Calling `mx.eval` actually
+        # allocates memory and initializes the parameters.
+        mx.eval(model.parameters())
+
+        # Setting a parameter to a new value is as simply as accessing that
+        # parameter and assigning a new array to it.
+        model.in_proj.weight = model.in_proj.weight * 2
+        mx.eval(model.parameters())
+    """
+
+    __call__: Callable
+
+    def __init__(self):
+        """Should be called by the subclasses of ``Module``."""
+        self._no_grad = set()
+        self._training = True
+
+    @property
+    def training(self):
+        """Boolean indicating if the model is in training mode."""
+        return self._training
+
+    @property
+    def state(self):
+        """The module's state dictionary
+
+        The module's state dictionary contains any attribute set on the
+        module including parameters in :meth:`Module.parameters`
+
+        Unlike :meth:`Module.parameters`, the :attr:`Module.state` property is
+        a reference to the module's state. Updates to it will be reflected in
+        the original module.
+        """
+        return self
+
+    def _extra_repr(self) -> str:
+        return ""
+
+    def __repr__(self):
+        children = tree_flatten(self.children(), is_leaf=self.is_module)
+        value = f"{type(self).__name__}({self._extra_repr()}"
+        for k, v in children:
+            value += "\n"
+            value += textwrap.indent(f"({k}): {repr(v)}", prefix="  ")
+        if children:
+            value += "\n"
+        value += ")"
+
+        return value
+
+    def __getattr__(self, key: str):
+        if (value := self.get(key, None)) is not None:
+            return value
+        else:
+            super(Module, self).__getattribute__(key)
+
+    def __setattr__(self, key: str, val: Any):
+        if isinstance(val, (mx.array, dict, list, tuple)):
+            # If attribute was previously set but not in the
+            # dictionary, delete it so we pick it up in future
+            # calls to __getattr__
+            if hasattr(self, key) and key not in self:
+                delattr(self, key)
+            self[key] = val
+        else:
+            super(Module, self).__setattr__(key, val)
+            self.pop(key, None)
+
+    def __delattr__(self, name):
+        if (val := self.get(name, None)) is not None:
+            del self[name]
+        else:
+            super().__delattr__(name)
+
+    def load_weights(
+        self,
+        file_or_weights: Union[str, List[Tuple[str, mx.array]]],
+        strict: bool = True,
+    ) -> Module:
+        """
+        Update the model's weights from a ``.npz``, a ``.safetensors`` file, or a list.
+
+        Args:
+            file_or_weights (str or list(tuple(str, mx.array))): The path to
+                the weights ``.npz`` file (``.npz`` or ``.safetensors``) or a list
+                of pairs of parameter names and arrays.
+            strict (bool, optional): If ``True`` then checks that the provided
+              weights exactly match the parameters of the model. Otherwise,
+              only the weights actually contained in the model are loaded and
+              shapes are not checked. Default: ``True``.
+
+        Returns:
+            The module instance after updating the weights.
+
+        Example:
+
+            .. code-block:: python
+
+                import mlx.core as mx
+                import mlx.nn as nn
+                model = nn.Linear(10, 10)
+
+                # Load from file
+                model.load_weights("weights.npz")
+
+                # Load from .safetensors file
+                model.load_weights("weights.safetensors")
+
+                # Load from list
+                weights = [
+                    ("weight", mx.random.uniform(shape=(10, 10))),
+                    ("bias",  mx.zeros((10,))),
+                ]
+                model.load_weights(weights)
+
+                # Missing weight
+                weights = [
+                    ("weight", mx.random.uniform(shape=(10, 10))),
+                ]
+
+                # Raises a ValueError exception
+                model.load_weights(weights)
+
+                # Ok, only updates the weight but not the bias
+                model.load_weights(weights, strict=False)
+        """
+        weights = file_or_weights
+        if isinstance(weights, str):
+            weights = list(mx.load(weights).items())
+
+        if strict:
+            new_weights = dict(weights)
+            curr_weights = tree_flatten(self.parameters(), destination={})
+            if extras := (new_weights.keys() - curr_weights.keys()):
+                num_extra = len(extras)
+                extras = ",\n".join(sorted(extras))
+                raise ValueError(
+                    f"Received {num_extra} parameters not in model: \n{extras}."
+                )
+            if missing := (curr_weights.keys() - new_weights.keys()):
+                num_missing = len(missing)
+                missing = ",\n".join(sorted(missing))
+                raise ValueError(f"Missing {num_missing} parameters: \n{missing}.")
+            for k, v in curr_weights.items():
+                v_new = new_weights[k]
+                if not isinstance(v_new, mx.array):
+                    raise ValueError(
+                        "Expected mx.array but received "
+                        f"{type(v_new)} for parameter {k}"
+                    )
+                if v_new.shape != v.shape:
+                    raise ValueError(
+                        f"Expected shape {v.shape} but received "
+                        f"shape {v_new.shape} for parameter {k}"
+                    )
+
+        if len(weights) != 0:
+            self.update(tree_unflatten(weights), strict=False)
+        return self
+
+    def save_weights(self, file: str):
+        """
+        Save the model's weights to a file. The saving method is determined by the file extension:
+        - ``.npz`` will use :func:`mx.savez`
+        - ``.safetensors`` will use :func:`mx.save_safetensors`
+        """
+        params_dict = tree_flatten(self.parameters(), destination={})
+
+        if file.endswith(".npz"):
+            mx.savez(file, **params_dict)
+        elif file.endswith(".safetensors"):
+            mx.save_safetensors(file, params_dict)
+        else:
+            raise ValueError(
+                f"Unsupported file extension for {file}. Use '.npz' or '.safetensors'."
+            )
+
+    @staticmethod
+    def is_module(value):
+        return isinstance(value, Module)
+
+    @staticmethod
+    def valid_child_filter(module, key, value):
+        return isinstance(value, (dict, list))
+
+    @staticmethod
+    def valid_parameter_filter(module, key, value):
+        return isinstance(value, (dict, list, mx.array)) and not key.startswith("_")
+
+    @staticmethod
+    def trainable_parameter_filter(module, key, value):
+        return (
+            Module.valid_parameter_filter(module, key, value)
+            and key not in module._no_grad
+        )
+
+    def filter_and_map(
+        self,
+        filter_fn: Callable[[Module, str, Any], bool],
+        map_fn: Optional[Callable] = None,
+        is_leaf_fn: Optional[Callable[[Module, str, Any], bool]] = None,
+    ):
+        """Recursively filter the contents of the module using ``filter_fn``,
+        namely only select keys and values where ``filter_fn`` returns true.
+
+        This is used to implement :meth:`parameters` and :meth:`trainable_parameters`
+        but it can also be used to extract any subset of the module's parameters.
+
+        Args:
+            filter_fn (Callable): Given a value, the key in which it is found
+                and the containing module, decide whether to keep the value or
+                drop it.
+            map_fn (Callable, optional): Optionally transform the value before
+                returning it.
+            is_leaf_fn (Callable, optional): Given a value, the key in which it
+                is found and the containing module decide if it is a leaf.
+
+        Returns:
+            A dictionary containing the contents of the module recursively filtered
+        """
+
+        map_fn = map_fn or (lambda x: x)
+        is_leaf_fn = is_leaf_fn or (
+            lambda m, k, v: not isinstance(v, (Module, dict, list))
+        )
+        return {
+            k: _unwrap(self, k, v, filter_fn, map_fn, is_leaf_fn)
+            for k, v in self.items()
+            if filter_fn(self, k, v)
+        }
+
+    def parameters(self):
+        """Recursively return all the :class:`mlx.core.array` members of this Module
+        as a dict of dicts and lists."""
+        return self.filter_and_map(self.valid_parameter_filter)
+
+    def trainable_parameters(self):
+        """Recursively return all the non frozen :class:`mlx.core.array` members of
+        this Module as a dict of dicts and lists."""
+        return self.filter_and_map(self.trainable_parameter_filter)
+
+    def children(self):
+        """Return the direct descendants of this Module instance."""
+        return self.filter_and_map(
+            self.valid_child_filter, is_leaf_fn=lambda m, k, v: isinstance(v, Module)
+        )
+
+    def leaf_modules(self):
+        """Return the submodules that do not contain other modules."""
+
+        def _is_leaf_module(m, k, v):
+            return isinstance(v, Module) and len(tree_flatten(v.children())) == 0
+
+        return self.filter_and_map(self.valid_child_filter, is_leaf_fn=_is_leaf_module)
+
+    def update(self, parameters: dict, strict: bool = True) -> Module:
+        """Replace the parameters of this Module with the provided ones in the
+        dict of dicts and lists.
+
+        Commonly used by the optimizer to change the model to the updated
+        (optimized) parameters. Also used by the :meth:`mlx.nn.value_and_grad` to set the
+        tracers in the model in order to compute gradients.
+
+        The passed in parameters dictionary need not be a full dictionary
+        similar to :meth:`parameters`. Only the provided locations will be
+        updated.
+
+        Args:
+            parameters (dict): A complete or partial dictionary of the modules
+                parameters.
+            strict (bool): If ``True`` checks that ``parameters`` is a
+                subset of the module's parameters. Default: ``True``.
+        Returns:
+            The module instance after updating the parameters.
+        """
+
+        def apply(dst, parameters):
+            if isinstance(parameters, dict):
+                for k in parameters:
+                    if k in dst:
+                        current_value = dst[k]
+                        new_value = parameters[k]
+                        if isinstance(current_value, mx.array):
+                            if strict and not isinstance(new_value, mx.array):
+                                raise ValueError(
+                                    f"Received invalid type: {type(new_value).__name__}."
+                                )
+                            dst[k] = new_value
+                        else:
+                            apply(current_value, new_value)
+                    elif strict:
+                        raise ValueError(f'Module does not have parameter named "{k}".')
+            elif isinstance(parameters, list):
+                for i in range(len(parameters)):
+                    current_value = dst[i]
+                    new_value = parameters[i]
+                    if isinstance(current_value, mx.array):
+                        if strict and not isinstance(new_value, mx.array):
+                            raise ValueError(
+                                f"Received invalid type: {type(new_value).__name__}."
+                            )
+                        dst[i] = new_value
+                    else:
+                        apply(current_value, new_value)
+            elif strict:
+                raise ValueError(f"Received invalid type: {type(parameters).__name__}.")
+
+        apply(self, parameters)
+        return self
+
+    def apply(
+        self,
+        map_fn: Callable[[mx.array], mx.array],
+        filter_fn: Optional[Callable[[Module, str, Any], bool]] = None,
+    ) -> Module:
+        """Map all the parameters using the provided ``map_fn`` and immediately
+        update the module with the mapped parameters.
+
+        For instance running ``model.apply(lambda x: x.astype(mx.float16))``
+        casts all parameters to 16 bit floats.
+
+        Args:
+            map_fn (Callable): Maps an array to another array
+            filter_fn (Callable, optional): Filter to select which arrays to
+                map (default: :meth:`Module.valid_parameter_filter`).
+
+        Returns:
+            The module instance after updating the parameters.
+        """
+        filter_fn = filter_fn or Module.valid_parameter_filter
+        self.update(self.filter_and_map(filter_fn, map_fn))
+        return self
+
+    def update_modules(self, modules: dict, strict: bool = True) -> Module:
+        """Replace the child modules of this :class:`Module` instance with the
+        provided ones in the dict of dicts and lists.
+
+        It is the equivalent of :meth:`Module.update` but for modules instead
+        of parameters and allows us to flexibly edit complex architectures by
+        programmatically swapping layers.
+
+        The passed in parameters dictionary need not be a full dictionary
+        similar to :meth:`modules`. Only the provided locations will be
+        updated.
+
+        Args:
+            modules (dict): A complete or partial dictionary of the module's
+                submodules.
+            strict (bool): If ``True`` checks that ``modules`` is a
+                subset of the child modules of this instance. Default: ``True``.
+        Returns:
+            The module instance after updating the submodules.
+        """
+        _update_modules(self, modules, strict)
+        return self
+
+    def apply_to_modules(self, apply_fn: Callable[[str, Module], Any]) -> Module:
+        """Apply a function to all the modules in this instance (including this
+        instance).
+
+        Args:
+            apply_fn (Callable): The function to apply to the modules.
+
+        Returns:
+            The module instance after updating submodules.
+        """
+        module_stack = [("", self)]
+        while module_stack:
+            prefix, mod = module_stack.pop()
+            apply_fn(prefix, mod)
+            prefix = "." + prefix if prefix else ""
+            module_stack.extend(
+                tree_flatten(mod.children(), prefix=prefix, is_leaf=self.is_module)
+            )
+        return self
+
+    def modules(self):
+        """Return a list with all the modules in this instance.
+
+        Returns:
+            A list of :class:`mlx.nn.Module` instances.
+        """
+        modulelist = []
+        self.apply_to_modules(lambda k, m: modulelist.append(m))
+        return modulelist
+
+    def named_modules(self):
+        """Return a list with all the modules in this instance and their name
+        with dot notation.
+
+        Returns:
+            A list of tuples (str, :class:`mlx.nn.Module`).
+        """
+        modulelist = []
+        self.apply_to_modules(lambda k, m: modulelist.append((k, m)))
+        return modulelist
+
+    def _validate_keys(self, keys, strict):
+        keys = keys if isinstance(keys, list) else [keys]
+        if strict:
+            for k in keys:
+                if k not in self:
+                    raise KeyError(f"Module doesn't contain member {k}.")
+        return keys
+
+    def freeze(
+        self,
+        *,
+        recurse: bool = True,
+        keys: Optional[Union[str, List[str]]] = None,
+        strict: bool = False,
+    ) -> Module:
+        """Freeze the Module's parameters or some of them. Freezing a parameter means not
+        computing gradients for it.
+
+        This function is idempotent i.e. freezing a frozen model is a no-op.
+
+        Example:
+            For instance to only train the attention parameters from a Transformer:
+
+            .. code-block:: python
+
+                model = nn.Transformer()
+                model.freeze()
+                model.apply_to_modules(lambda k, v: v.unfreeze() if k.endswith("attention") else None)
+
+        Args:
+            recurse (bool, optional): If True then freeze the parameters of the
+                submodules as well. Default: ``True``.
+            keys (str or list[str], optional): If provided then only these
+                parameters will be frozen otherwise all the parameters of a
+                module. For instance freeze all biases by calling
+                ``module.freeze(keys="bias")``.
+            strict (bool, optional): If set to ``True`` validate that the passed keys exist.
+                Default: ``False``.
+
+        Returns:
+            The module instance after freezing the parameters.
+        """
+
+        def _freeze_impl(_, m):
+            local_keys = keys
+            if local_keys is None:
+                local_keys = tree_flatten(
+                    m.filter_and_map(
+                        lambda m, k, v: (not isinstance(v, Module))
+                        and m.valid_parameter_filter(m, k, v)
+                    )
+                )
+                local_keys = [k for (k, v) in local_keys]
+
+            local_keys = m._validate_keys(local_keys, strict)
+            m._no_grad.update(local_keys)
+
+        if recurse:
+            self.apply_to_modules(_freeze_impl)
+        else:
+            _freeze_impl("", self)
+        return self
+
+    def unfreeze(
+        self,
+        *,
+        recurse: bool = True,
+        keys: Optional[Union[str, List[str]]] = None,
+        strict: bool = False,
+    ) -> Module:
+        """Unfreeze the Module's parameters or some of them.
+
+        This function is idempotent ie unfreezing a model that is not frozen is
+        a noop.
+
+        Example:
+
+            For instance to only train the biases of a Transformer one can do:
+
+            .. code-block:: python
+
+                model = nn.Transformer()
+                model.freeze()
+                model.unfreeze(keys="bias")
+
+        Args:
+            recurse (bool, optional): If True then unfreeze the parameters of the
+                submodules as well. Default: ``True``.
+            keys (str or list[str], optional): If provided then only these
+                parameters will be unfrozen otherwise all the parameters of a
+                module. For instance unfreeze all biases by calling
+                ``module.unfreeze(keys="bias")``.
+            strict (bool, optional): If set to ``True`` validate that the passed keys exist.
+                Default: ``False``.
+
+        Returns:
+            The module instance after unfreezing the parameters.
+        """
+
+        def _unfreeze_impl(_, m):
+            if keys is None:
+                m._no_grad.clear()
+
+            else:
+                local_keys = m._validate_keys(keys, strict)
+                m._no_grad.difference_update(local_keys)
+
+        if recurse:
+            self.apply_to_modules(_unfreeze_impl)
+        else:
+            _unfreeze_impl("", self)
+        return self
+
+    def train(self, mode: bool = True) -> Module:
+        """Set the model in or out of training mode.
+
+        Training mode only applies to certain layers. For example
+        :obj:`Dropout` applies a random mask in training mode, but is the
+        identity in evaluation mode.
+
+        Args:
+            mode (bool): Indicate if the model should be in training or
+                evaluation mode. Default: ``True``.
+        Returns:
+            The module instance after updating the training mode.
+        """
+
+        def _set_train(_, m):
+            m._training = mode
+
+        self.apply_to_modules(_set_train)
+        return self
+
+    def eval(self) -> Module:
+        """Set the model to evaluation mode.
+
+        See :func:`train`.
+        """
+        return self.train(False)
+
+    def set_dtype(
+        self,
+        dtype: mx.Dtype,
+        predicate: Optional[Callable[[mx.Dtype], bool]] = lambda x: mx.issubdtype(
+            x, mx.floating
+        ),
+    ):
+        """Set the dtype of the module's parameters.
+
+        Args:
+            dtype (Dtype): The new dtype.
+            predicate (typing.Callable, optional): A predicate to select
+              parameters to cast. By default, only parameters of type
+              :attr:`floating` will be updated to avoid casting integer
+              parameters to the new dtype.
+        """
+        if predicate is None:
+            predicate = lambda _: True
+
+        self.apply(lambda x: x.astype(dtype) if predicate(x.dtype) else x)
+
+
+def _update_modules(dst, modules, strict):
+    if isinstance(modules, dict):
+        for k in modules:
+            if k in dst:
+                current_value = dst[k]
+                new_value = modules[k]
+                if Module.is_module(current_value) and Module.is_module(new_value):
+                    dst[k] = new_value
+                elif isinstance(current_value, (dict, list)):
+                    _update_modules(current_value, new_value, strict)
+                elif strict and new_value != {}:
+                    raise ValueError(
+                        f"Received invalid type: {type(new_value).__name__}."
+                    )
+            elif strict:
+                raise ValueError(f'Module does not have sub-module named "{k}".')
+    elif isinstance(modules, list):
+        for i in range(len(modules)):
+            current_value = dst[i]
+            new_value = modules[i]
+            if Module.is_module(current_value) and Module.is_module(new_value):
+                dst[i] = new_value
+            elif isinstance(current_value, (dict, list)):
+                _update_modules(current_value, new_value, strict)
+            elif strict and new_value != {}:
+                raise ValueError(f"Received invalid type: {type(new_value).__name__}.")
+    elif strict:
+        raise ValueError(f"Received invalid type: {type(modules).__name__}.")
+
+
+def _unwrap(model, value_key, value, filter_fn, map_fn, is_leaf_fn):
+    if is_leaf_fn(model, value_key, value):
+        return map_fn(value)
+
+    elif isinstance(value, Module):
+        return {
+            k: _unwrap(value, k, v, filter_fn, map_fn, is_leaf_fn)
+            for k, v in value.items()
+            if filter_fn(value, k, v)
+        }
+
+    elif isinstance(value, dict):
+        nd = {}
+        for k, v in value.items():
+            tk = f"{value_key}.{k}"
+            nd[k] = (
+                _unwrap(model, tk, v, filter_fn, map_fn, is_leaf_fn)
+                if filter_fn(model, tk, v)
+                else {}
+            )
+        return nd
+
+    elif isinstance(value, list):
+        nl = []
+        for i, vi in enumerate(value):
+            tk = f"{value_key}.{i}"
+            nl.append(
+                _unwrap(model, tk, vi, filter_fn, map_fn, is_leaf_fn)
+                if filter_fn(model, tk, vi)
+                else {}
+            )
+        return nl
+
+    raise RuntimeError("Unexpected leaf found while traversing the module")
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/containers.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/containers.py
new file mode 100644
index 0000000000000000000000000000000000000000..c57fbb9922b494e72f830419cd5e0277c311dd4b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/containers.py
@@ -0,0 +1,24 @@
+# Copyright © 2023 Apple Inc.
+
+from mlx.nn.layers.base import Module
+
+
+class Sequential(Module):
+    """A layer that calls the passed callables in order.
+
+    We can pass either modules or plain callables to the Sequential module. If
+    our functions have learnable parameters they should be implemented as
+    ``nn.Module`` instances.
+
+    Args:
+        modules (tuple of Callables): The modules to call in order
+    """
+
+    def __init__(self, *modules):
+        super().__init__()
+        self.layers = list(modules)
+
+    def __call__(self, x):
+        for m in self.layers:
+            x = m(x)
+        return x
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/convolution.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/convolution.py
new file mode 100644
index 0000000000000000000000000000000000000000..88b97add0d89a7378f969fc68fc92e6a5bd75eb3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/convolution.py
@@ -0,0 +1,232 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Union
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class Conv1d(Module):
+    """Applies a 1-dimensional convolution over the multi-channel input sequence.
+
+    The channels are expected to be last i.e. the input shape should be ``NLC`` where:
+
+    * ``N`` is the batch dimension
+    * ``L`` is the sequence length
+    * ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels
+        out_channels (int): The number of output channels
+        kernel_size (int): The size of the convolution filters
+        stride (int, optional): The stride when applying the filter.
+            Default: ``1``.
+        padding (int, optional): How many positions to 0-pad the input with.
+            Default: ``0``.
+        dilation (int, optional): The dilation of the convolution.
+        groups (int, optional): The number of groups for the convolution.
+            Default: ``1``.
+        bias (bool, optional): If ``True`` add a learnable bias to the output.
+            Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: int,
+        stride: int = 1,
+        padding: int = 0,
+        dilation: int = 1,
+        groups: int = 1,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        if in_channels % groups != 0:
+            raise ValueError(
+                f"The number of input channels ({in_channels}) must be "
+                f"divisible by the number of groups ({groups})"
+            )
+
+        scale = math.sqrt(1 / (in_channels * kernel_size))
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, kernel_size, in_channels // groups),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.dilation = dilation
+        self.stride = stride
+        self.groups = groups
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1]}, stride={self.stride}, "
+            f"padding={self.padding}, dilation={self.dilation}, "
+            f"groups={self.groups}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv1d(
+            x, self.weight, self.stride, self.padding, self.dilation, self.groups
+        )
+        if "bias" in self:
+            y = y + self.bias
+        return y
+
+
+class Conv2d(Module):
+    """Applies a 2-dimensional convolution over the multi-channel input image.
+
+    The channels are expected to be last i.e. the input shape should be ``NHWC`` where:
+
+    * ``N`` is the batch dimension
+    * ``H`` is the input image height
+    * ``W`` is the input image width
+    * ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        kernel_size (int or tuple): The size of the convolution filters.
+        stride (int or tuple, optional): The size of the stride when
+            applying the filter. Default: ``1``.
+        padding (int or tuple, optional): How many positions to 0-pad
+            the input with. Default: ``0``.
+        dilation (int or tuple, optional): The dilation of the convolution.
+        groups (int, optional): The number of groups for the convolution.
+            Default: ``1``.
+        bias (bool, optional): If ``True`` add a learnable bias to the
+            output. Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: Union[int, tuple],
+        stride: Union[int, tuple] = 1,
+        padding: Union[int, tuple] = 0,
+        dilation: Union[int, tuple] = 1,
+        groups: int = 1,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        if in_channels % groups != 0:
+            raise ValueError(
+                f"The number of input channels ({in_channels}) must be "
+                f"divisible by the number of groups ({groups})"
+            )
+
+        kernel_size, stride, padding = map(
+            lambda x: (x, x) if isinstance(x, int) else x,
+            (kernel_size, stride, padding),
+        )
+        scale = math.sqrt(1 / (in_channels * kernel_size[0] * kernel_size[1]))
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, *kernel_size, in_channels // groups),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.stride = stride
+        self.dilation = dilation
+        self.groups = groups
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1:3]}, stride={self.stride}, "
+            f"padding={self.padding}, dilation={self.dilation}, "
+            f"groups={self.groups}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv2d(
+            x, self.weight, self.stride, self.padding, self.dilation, self.groups
+        )
+        if "bias" in self:
+            y = y + self.bias
+        return y
+
+
+class Conv3d(Module):
+    """Applies a 3-dimensional convolution over the multi-channel input image.
+
+    The channels are expected to be last i.e. the input shape should be ``NDHWC`` where:
+
+    * ``N`` is the batch dimension
+    * ``D`` is the input image depth
+    * ``H`` is the input image height
+    * ``W`` is the input image width
+    * ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        kernel_size (int or tuple): The size of the convolution filters.
+        stride (int or tuple, optional): The size of the stride when
+            applying the filter. Default: ``1``.
+        dilation (int or tuple, optional): The dilation of the convolution.
+        padding (int or tuple, optional): How many positions to 0-pad
+            the input with. Default: ``0``.
+        bias (bool, optional): If ``True`` add a learnable bias to the
+            output. Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: Union[int, tuple],
+        stride: Union[int, tuple] = 1,
+        padding: Union[int, tuple] = 0,
+        dilation: Union[int, tuple] = 1,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        kernel_size, stride, padding = map(
+            lambda x: (x, x, x) if isinstance(x, int) else x,
+            (kernel_size, stride, padding),
+        )
+        scale = math.sqrt(
+            1 / (in_channels * kernel_size[0] * kernel_size[1] * kernel_size[2])
+        )
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, *kernel_size, in_channels),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.stride = stride
+        self.dilation = dilation
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1:4]}, stride={self.stride}, "
+            f"padding={self.padding}, dilation={self.dilation}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv3d(x, self.weight, self.stride, self.padding, self.dilation)
+        if "bias" in self:
+            y = y + self.bias
+        return y
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/convolution_transpose.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/convolution_transpose.py
new file mode 100644
index 0000000000000000000000000000000000000000..a11c4cb40379fc9b9398d15a1da411ce9d7ef4a3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/convolution_transpose.py
@@ -0,0 +1,242 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Union
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class ConvTranspose1d(Module):
+    """Applies a 1-dimensional transposed convolution over the multi-channel input sequence.
+
+    The channels are expected to be last i.e. the input shape should be ``NLC`` where:
+
+    * ``N`` is the batch dimension
+    * ``L`` is the sequence length
+    * ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels
+        out_channels (int): The number of output channels
+        kernel_size (int): The size of the convolution filters
+        stride (int, optional): The stride when applying the filter.
+            Default: ``1``.
+        padding (int, optional): How many positions to 0-pad the input with.
+            Default: ``0``.
+        dilation (int, optional): The dilation of the convolution.
+        output_padding(int, optional): Additional size added to one side of the
+            output shape. Default: ``0``.
+        bias (bool, optional): If ``True`` add a learnable bias to the output.
+            Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: int,
+        stride: int = 1,
+        padding: int = 0,
+        dilation: int = 1,
+        output_padding: int = 0,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        scale = math.sqrt(1 / (in_channels * kernel_size))
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, kernel_size, in_channels),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.dilation = dilation
+        self.stride = stride
+        self.output_padding = output_padding
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1]}, stride={self.stride}, "
+            f"padding={self.padding}, dilation={self.dilation}, "
+            f"output_padding={self.output_padding}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv_transpose1d(
+            x,
+            self.weight,
+            self.stride,
+            self.padding,
+            self.dilation,
+            self.output_padding,
+        )
+        if "bias" in self:
+            y = y + self.bias
+        return y
+
+
+class ConvTranspose2d(Module):
+    """Applies a 2-dimensional transposed convolution over the multi-channel input image.
+
+    The channels are expected to be last i.e. the input shape should be ``NHWC`` where:
+
+    * ``N`` is the batch dimension
+    * ``H`` is the input image height
+    * ``W`` is the input image width
+    * ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        kernel_size (int or tuple): The size of the convolution filters.
+        stride (int or tuple, optional): The size of the stride when
+            applying the filter. Default: ``1``.
+        padding (int or tuple, optional): How many positions to 0-pad
+            the input with. Default: ``0``.
+        dilation (int or tuple, optional): The dilation of the convolution.
+        output_padding(int or tuple, optional): Additional size added to one
+            side of the output shape. Default: ``0``.
+        bias (bool, optional): If ``True`` add a learnable bias to the
+            output. Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: Union[int, tuple],
+        stride: Union[int, tuple] = 1,
+        padding: Union[int, tuple] = 0,
+        dilation: Union[int, tuple] = 1,
+        output_padding: Union[int, tuple] = 0,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        kernel_size, stride, padding, output_padding = map(
+            lambda x: (x, x) if isinstance(x, int) else x,
+            (kernel_size, stride, padding, output_padding),
+        )
+        scale = math.sqrt(1 / (in_channels * kernel_size[0] * kernel_size[1]))
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, *kernel_size, in_channels),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.stride = stride
+        self.dilation = dilation
+        self.output_padding = output_padding
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1:2]}, stride={self.stride}, "
+            f"padding={self.padding}, dilation={self.dilation}, "
+            f"output_padding={self.output_padding}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv_transpose2d(
+            x,
+            self.weight,
+            self.stride,
+            self.padding,
+            self.dilation,
+            self.output_padding,
+        )
+        if "bias" in self:
+            y = y + self.bias
+        return y
+
+
+class ConvTranspose3d(Module):
+    """Applies a 3-dimensional transposed convolution over the multi-channel input image.
+
+    The channels are expected to be last i.e. the input shape should be ``NDHWC`` where:
+
+    * ``N`` is the batch dimension
+    * ``D`` is the input image depth
+    * ``H`` is the input image height
+    * ``W`` is the input image width
+    * ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        kernel_size (int or tuple): The size of the convolution filters.
+        stride (int or tuple, optional): The size of the stride when
+            applying the filter. Default: ``1``.
+        padding (int or tuple, optional): How many positions to 0-pad
+            the input with. Default: ``0``.
+        dilation (int or tuple, optional): The dilation of the convolution.
+        output_padding(int or tuple, optional): Additional size added to one
+            side of the output shape. Default: ``0``.
+        bias (bool, optional): If ``True`` add a learnable bias to the
+            output. Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: Union[int, tuple],
+        stride: Union[int, tuple] = 1,
+        padding: Union[int, tuple] = 0,
+        dilation: Union[int, tuple] = 1,
+        output_padding: Union[int, tuple] = 0,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        kernel_size, stride, padding, output_padding = map(
+            lambda x: (x, x, x) if isinstance(x, int) else x,
+            (kernel_size, stride, padding, output_padding),
+        )
+        scale = math.sqrt(
+            1 / (in_channels * kernel_size[0] * kernel_size[1] * kernel_size[2])
+        )
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, *kernel_size, in_channels),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.stride = stride
+        self.dilation = dilation
+        self.output_padding = output_padding
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1:3]}, stride={self.stride}, "
+            f"padding={self.padding}, dilation={self.dilation}, "
+            f"output_padding={self.output_padding}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv_transpose3d(
+            x,
+            self.weight,
+            self.stride,
+            self.padding,
+            self.dilation,
+            self.output_padding,
+        )
+        if "bias" in self:
+            y = y + self.bias
+        return y
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/distributed.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/distributed.py
new file mode 100644
index 0000000000000000000000000000000000000000..92acde8f60185b93068241c8745739d8977a14f1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/distributed.py
@@ -0,0 +1,599 @@
+# Copyright © 2024 Apple Inc.
+
+import math
+from functools import lru_cache
+from typing import Callable, Optional, Union
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+from mlx.nn.layers.linear import Linear
+from mlx.nn.layers.quantized import QuantizedLinear
+from mlx.utils import tree_map_with_path
+
+
+@lru_cache
+def sum_gradients(group):
+    if group.size() == 1:
+        return lambda x: x
+
+    @mx.custom_function
+    def f(x):
+        return x
+
+    @f.vjp
+    def f(x, dx, _):
+        return mx.distributed.all_sum(dx, group=group)
+
+    return f
+
+
+def _split(weight, segments, axis):
+    """Equivalent to mx.split but allows for fractional segments."""
+    if isinstance(segments, int) or isinstance(segments[0], int):
+        return mx.split(weight, segments, axis=axis)
+
+    N = weight.shape[axis]
+    indices = [int(s * N) for s in segments]
+    return mx.split(weight, indices, axis=axis)
+
+
+def _shard(
+    parameters: dict,
+    sharding_predicate: Callable,
+    group: Optional[mx.distributed.Group] = None,
+):
+    """Returns a new parameter tree with the weights sharded according to the
+    sharding_predicate.
+
+    The sharding predicate should return the sharding axis and optionally also
+    the segments that comprise the weight.
+    """
+    group = group or mx.distributed.init()
+    N = group.size()
+    r = group.rank()
+
+    def _shard_fn(path, weight):
+        if not isinstance(weight, mx.array):
+            return weight
+
+        s = sharding_predicate(path, weight)
+        if s is None:
+            return weight
+
+        axis = None
+        segments = 1
+        if isinstance(s, int):
+            axis = s
+        elif isinstance(s, tuple):
+            axis, segments = s
+        else:
+            raise ValueError(
+                "The sharding function should return int or tuple[int, list]"
+            )
+
+        return mx.contiguous(
+            mx.concatenate(
+                [_split(part, N, axis)[r] for part in _split(weight, segments, axis)],
+                axis=axis,
+            )
+        )
+
+    return tree_map_with_path(_shard_fn, parameters)
+
+
+def _all_to_sharded(segments):
+    """Simple predicate to shard fully connected layers such that a common
+    representation becomes a sharded representation."""
+
+    def _shard_fn(path, weight):
+        return max(weight.ndim - 2, 0), segments
+
+    return _shard_fn
+
+
+def _sharded_to_all(segments):
+    """Simple predicate to shard fully connected layers such that a sharded
+    representation becomes a common representation."""
+
+    def _shard_fn(path, weight):
+        if path.endswith("bias"):
+            return None
+        return -1, segments
+
+    return _shard_fn
+
+
+def _check_sharding(sharding):
+    if sharding not in ("all-to-sharded", "sharded-to-all"):
+        raise ValueError(
+            (
+                f"Sharding type {sharding=} not supported, "
+                "choose one of 'all-to-sharded' or 'sharded-to-all'"
+            )
+        )
+
+
+def shard_inplace(
+    module: Module,
+    sharding: Union[str, Callable],
+    *,
+    segments: Union[int, list] = 1,
+    group: Optional[mx.distributed.Group] = None,
+):
+    """Shard a module in-place by updating its parameter dictionary with the
+    sharded parameter dictionary.
+
+    The ``sharding`` argument can be any callable that given the path and the
+    weight returns the sharding axis and optionally also the segments that
+    comprise the unsharded weight. For instance if the weight is a fused QKV
+    matrix the segments should be 3.
+
+    .. note::
+        The module doesn't change so in order for distributed communication to
+        happen the module needs to natively support it and for it to be enabled.
+
+    Args:
+        module (mlx.nn.Module): The parameters of this module will be sharded
+            in-place.
+        sharding (str or callable): One of "all-to-sharded" and
+            "sharded-to-all" or a callable that returns the sharding axis and
+            segments.
+        segments (int or list): The segments to use if ``sharding`` is a
+            string. Default: ``1``.
+        group (mlx.core.distributed.Group): The distributed group to shard
+            across. If not set, the global group will be used. Default: ``None``.
+    """
+    if isinstance(sharding, str):
+        _check_sharding(sharding)
+        sharding = (
+            _all_to_sharded(segments)
+            if sharding == "all-to-sharded"
+            else _sharded_to_all(segments)
+        )
+    module.update(_shard(module.parameters(), sharding, group))
+
+
+def shard_linear(
+    module: Module,
+    sharding: str,
+    *,
+    segments: Union[int, list] = 1,
+    group: Optional[mx.distributed.Group] = None,
+):
+    """Create a new linear layer that has its parameters sharded and also
+    performs distributed communication either in the forward or backward
+    pass.
+
+    .. note::
+        Contrary to ``shard_inplace``, the original layer is not changed but a
+        new layer is returned.
+
+    Args:
+        module (mlx.nn.Module): The linear layer to be sharded.
+        sharding (str): One of "all-to-sharded" and
+            "sharded-to-all" that defines the type of sharding to perform.
+        segments (int or list): The segments to use. Default: ``1``.
+        group (mlx.core.distributed.Group): The distributed group to shard
+            across. If not set, the global group will be used. Default: ``None``.
+    """
+    _check_sharding(sharding)
+    fns = {
+        ("all-to-sharded", True): AllToShardedLinear.from_linear,
+        ("all-to-sharded", False): QuantizedAllToShardedLinear.from_quantized_linear,
+        ("sharded-to-all", True): ShardedToAllLinear.from_linear,
+        ("sharded-to-all", False): QuantizedShardedToAllLinear.from_quantized_linear,
+    }
+    return fns[sharding, isinstance(module, Linear)](
+        module, segments=segments, group=group
+    )
+
+
+class AllToShardedLinear(Module):
+    """Each member of the group applies part of the affine transformation such
+    that the result is sharded across the group.
+
+    The gradients are automatically aggregated from each member of the group.
+
+    Args:
+        input_dims (int): The dimensionality of the input features
+        output_dims (int): The dimensionality of the output features
+        bias (bool, optional): If set to ``False`` the the layer will not use a
+            bias. Default is ``True``.
+        group (mx.distributed.Group, optional): The sharding will happen across
+            this group. If not set then the global group is used. Default is
+            ``None``.
+    """
+
+    def __init__(
+        self,
+        input_dims: int,
+        output_dims: int,
+        bias: bool = True,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        super().__init__()
+
+        # Initialize the parameters
+        scale = math.sqrt(1.0 / input_dims)
+        self.group = group or mx.distributed.init()
+        N = self.group.size()
+
+        if (output_dims % N) != 0:
+            raise ValueError(
+                f"Cannot shard the output of size {output_dims} across {N} devices."
+            )
+
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims // N, input_dims),
+        )
+        if bias:
+            self.bias = mx.random.uniform(
+                low=-scale,
+                high=scale,
+                shape=(output_dims // N,),
+            )
+
+    def _extra_repr(self) -> str:
+        out_dims, in_dims = self.weight.shape
+        N = self.group.size()
+        out_dims *= N
+        return f"input_dims={in_dims}, output_dims={out_dims}, bias={'bias' in self}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        # Aggregate the gradients coming from each shard
+        x = sum_gradients(self.group)(x)
+
+        # Compute the affine projection
+        if "bias" in self:
+            x = mx.addmm(self["bias"], x, self["weight"].T)
+        else:
+            x = x @ self["weight"].T
+        return x
+
+    @classmethod
+    def from_linear(
+        cls,
+        linear_layer: Module,
+        *,
+        segments: Union[int, list] = 1,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        group = group or mx.distributed.init()
+        output_dims, input_dims = linear_layer.weight.shape
+
+        sl = cls(input_dims, output_dims, hasattr(linear_layer, "bias"), group)
+        sl.update(_shard(linear_layer.parameters(), _all_to_sharded(segments), group))
+
+        return sl
+
+
+class ShardedToAllLinear(Module):
+    """Each member of the group applies part of the affine transformation and
+    then aggregates the results.
+
+    All nodes will have the same exact result after this layer.
+
+    :class:`ShardedToAllLinear` provides a classmethod :meth:`from_linear` to
+    convert linear layers to sharded :obj:`ShardedToAllLinear` layers.
+
+    Args:
+        input_dims (int): The dimensionality of the input features
+        output_dims (int): The dimensionality of the output features
+        bias (bool, optional): If set to ``False`` the the layer will not use a
+            bias. Default is ``True``.
+        group (mx.distributed.Group, optional): The sharding will happen across
+            this group. If not set then the global group is used. Default is
+            ``None``.
+    """
+
+    def __init__(
+        self,
+        input_dims: int,
+        output_dims: int,
+        bias: bool = True,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        super().__init__()
+
+        # Initialize the parameters
+        scale = math.sqrt(1.0 / input_dims)
+        self.group = group or mx.distributed.init()
+        N = self.group.size()
+
+        if (input_dims % N) != 0:
+            raise ValueError(
+                f"The input of size {input_dims} cannot be sharded across {N} devices."
+            )
+
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims, input_dims // N),
+        )
+        if bias:
+            self.bias = mx.random.uniform(
+                low=-scale,
+                high=scale,
+                shape=(output_dims,),
+            )
+
+    def _extra_repr(self) -> str:
+        N = self.group.size()
+        out_dims, in_dims = self.weight.shape
+        in_dims *= N
+        return f"input_dims={in_dims}, output_dims={out_dims}, bias={'bias' in self}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        x = x @ self["weight"].T
+
+        x = mx.distributed.all_sum(x, group=self.group)
+
+        if "bias" in self:
+            x = x + self["bias"]
+
+        return x
+
+    @classmethod
+    def from_linear(
+        cls,
+        linear_layer: Module,
+        *,
+        segments: Union[int, list] = 1,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        group = group or mx.distributed.init()
+        output_dims, input_dims = linear_layer.weight.shape
+
+        sl = cls(input_dims, output_dims, hasattr(linear_layer, "bias"), group)
+        sl.update(_shard(linear_layer.parameters(), _sharded_to_all(segments), group))
+
+        return sl
+
+
+class QuantizedAllToShardedLinear(Module):
+    """Each member of the group applies part of the affine transformation with
+    a quantized matrix such that the result is sharded across the group.
+
+    It is the quantized equivalent of :class:`mlx.nn.AllToShardedLinear`.
+    Similar to :class:`mlx.nn.QuantizedLinear` its parameters are frozen and
+    will not be included in any gradient computation.
+
+    Args:
+        input_dims (int): The dimensionality of the input features.
+        output_dims (int): The dimensionality of the output features.
+        bias (bool, optional): If set to ``False`` then the layer will not use
+            a bias. Default: ``True``.
+        group_size (int, optional): The group size to use for the quantized
+            weight. See :func:`~mlx.core.quantize`. Default: ``64``.
+        bits (int, optional): The bit width to use for the quantized weight.
+            See :func:`~mlx.core.quantize`. Default: ``4``.
+        group (mx.distributed.Group, optional): The sharding will happen across
+            this group. If not set then the global group is used. Default is
+            ``None``.
+    """
+
+    def __init__(
+        self,
+        input_dims: int,
+        output_dims: int,
+        bias: bool = True,
+        group_size: int = 64,
+        bits: int = 4,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        super().__init__()
+
+        # Quantization config
+        self.group_size = group_size
+        self.bits = bits
+
+        # Initialize the quantized weight
+        scale = math.sqrt(1.0 / input_dims)
+        self.group = group or mx.distributed.init()
+        N = self.group.size()
+
+        if (output_dims % N) != 0:
+            raise ValueError(
+                f"Cannot shard the output of size {output_dims} across {N} devices."
+            )
+
+        weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims // N, input_dims),
+        )
+        self.weight, self.scales, self.biases = mx.quantize(weight, group_size, bits)
+
+        # And bias if needed
+        if bias:
+            self.bias = mx.zeros((output_dims // N,))
+
+        # Freeze this model's parameters
+        self.freeze()
+
+    def unfreeze(self, *args, **kwargs):
+        """Wrap unfreeze so that we unfreeze any layers we might contain but
+        our parameters will remain frozen."""
+        super().unfreeze(*args, **kwargs)
+        self.freeze(recurse=False)
+
+    def _extra_repr(self) -> str:
+        out_dims, in_dims = self.weight.shape
+        in_dims *= 32 // self.bits
+        out_dims *= self.group.size()
+        return (
+            f"input_dims={in_dims}, output_dims={out_dims}, bias={'bias' in self}, "
+            f"group_size={self.group_size}, bits={self.bits}"
+        )
+
+    def __call__(self, x: mx.array) -> mx.array:
+        # Aggregate the gradients coming from each shard
+        x = sum_gradients(self.group)(x)
+
+        x = mx.quantized_matmul(
+            x,
+            self["weight"],
+            scales=self["scales"],
+            biases=self["biases"],
+            transpose=True,
+            group_size=self.group_size,
+            bits=self.bits,
+        )
+        if "bias" in self:
+            x = x + self["bias"]
+        return x
+
+    @classmethod
+    def from_quantized_linear(
+        cls,
+        quantized_linear_layer: Module,
+        *,
+        segments: Union[int, list] = 1,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        group = group or mx.distributed.init()
+        output_dims, input_dims = quantized_linear_layer.weight.shape
+        input_dims *= 32 // quantized_linear_layer.bits
+
+        sl = cls(
+            input_dims,
+            output_dims,
+            hasattr(quantized_linear_layer, "bias"),
+            group_size=quantized_linear_layer.group_size,
+            bits=quantized_linear_layer.bits,
+            group=group,
+        )
+        sl.update(
+            _shard(
+                quantized_linear_layer.parameters(),
+                _all_to_sharded(segments),
+                group,
+            )
+        )
+
+        return sl
+
+
+class QuantizedShardedToAllLinear(Module):
+    """Each member of the group applies part of the affine transformation using
+    the quantized matrix and then aggregates the results.
+
+    All nodes will have the same exact result after this layer.
+
+    It is the quantized equivalent of :class:`mlx.nn.ShardedToAllLinear`.
+    Similar to :class:`mlx.nn.QuantizedLinear` its parameters are frozen and
+    will not be included in any gradient computation.
+
+    Args:
+        input_dims (int): The dimensionality of the input features.
+        output_dims (int): The dimensionality of the output features.
+        bias (bool, optional): If set to ``False`` then the layer will not use
+            a bias. Default: ``True``.
+        group_size (int, optional): The group size to use for the quantized
+            weight. See :func:`~mlx.core.quantize`. Default: ``64``.
+        bits (int, optional): The bit width to use for the quantized weight.
+            See :func:`~mlx.core.quantize`. Default: ``4``.
+        group (mx.distributed.Group, optional): The sharding will happen across
+            this group. If not set then the global group is used. Default is
+            ``None``.
+    """
+
+    def __init__(
+        self,
+        input_dims: int,
+        output_dims: int,
+        bias: bool = True,
+        group_size: int = 64,
+        bits: int = 4,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        super().__init__()
+
+        # Quantization config
+        self.group_size = group_size
+        self.bits = bits
+
+        # Initialize the quantized weight
+        scale = math.sqrt(1.0 / input_dims)
+        self.group = group or mx.distributed.init()
+        N = self.group.size()
+
+        if (input_dims % N) != 0:
+            raise ValueError(
+                f"The input of size {input_dims} cannot be sharded across {N} devices."
+            )
+
+        weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims, input_dims // N),
+        )
+        self.weight, self.scales, self.biases = mx.quantize(weight, group_size, bits)
+
+        # And bias if needed
+        if bias:
+            self.bias = mx.zeros((output_dims,))
+
+        # Freeze this model's parameters
+        self.freeze()
+
+    def unfreeze(self, *args, **kwargs):
+        """Wrap unfreeze so that we unfreeze any layers we might contain but
+        our parameters will remain frozen."""
+        super().unfreeze(*args, **kwargs)
+        self.freeze(recurse=False)
+
+    def _extra_repr(self) -> str:
+        out_dims, in_dims = self.weight.shape
+        in_dims *= (32 // self.bits) * self.group.size()
+        return (
+            f"input_dims={in_dims}, output_dims={out_dims}, bias={'bias' in self}, "
+            f"group_size={self.group_size}, bits={self.bits}"
+        )
+
+    def __call__(self, x: mx.array) -> mx.array:
+        x = mx.quantized_matmul(
+            x,
+            self["weight"],
+            scales=self["scales"],
+            biases=self["biases"],
+            transpose=True,
+            group_size=self.group_size,
+            bits=self.bits,
+        )
+        x = mx.distributed.all_sum(x, group=self.group)
+        if "bias" in self:
+            x = x + self["bias"]
+        return x
+
+    @classmethod
+    def from_quantized_linear(
+        cls,
+        quantized_linear_layer: Module,
+        *,
+        segments: Union[int, list] = 1,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        group = group or mx.distributed.init()
+        output_dims, input_dims = quantized_linear_layer.weight.shape
+        input_dims *= 32 // quantized_linear_layer.bits
+
+        sl = cls(
+            input_dims,
+            output_dims,
+            hasattr(quantized_linear_layer, "bias"),
+            group_size=quantized_linear_layer.group_size,
+            bits=quantized_linear_layer.bits,
+            group=group,
+        )
+        sl.update(
+            _shard(
+                quantized_linear_layer.parameters(),
+                _sharded_to_all(segments),
+                group,
+            )
+        )
+
+        return sl
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/dropout.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/dropout.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6a690996e718761aa3ed5942b99f97a0990fbff
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/dropout.py
@@ -0,0 +1,137 @@
+# Copyright © 2023 Apple Inc.
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class Dropout(Module):
+    r"""Randomly zero a portion of the elements during training.
+
+    The remaining elements are multiplied with :math:`\frac{1}{1-p}` where
+    :math:`p` is the probability of zeroing an element. This is done so the
+    expected value of a given element will remain the same.
+
+    Args:
+        p (float): The probability to zero an element
+    """
+
+    def __init__(self, p: float = 0.5):
+        super().__init__()
+
+        if p < 0 or p >= 1:
+            raise ValueError(f"The dropout probability {p} is not in [0, 1)")
+
+        self._p_1 = 1 - p
+
+    def _extra_repr(self) -> str:
+        return f"p={1-self._p_1}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        if self._p_1 == 1 or not self.training:
+            return x
+
+        mask = mx.random.bernoulli(self._p_1, x.shape)
+
+        return (mask * x) * (1 / self._p_1)
+
+
+class Dropout2d(Module):
+    r"""Apply 2D channel-wise dropout during training.
+
+    Randomly zero out entire channels independently with probability :math:`p`.
+    This layer expects the channels to be last, i.e. the input shape should be
+    ``NWHC`` or ``WHC`` where:``N`` is the batch dimension,``H`` is the input
+    image height,``W`` is the input image width, and``C`` is the number of
+    input channels
+
+    The remaining channels are scaled by :math:`\frac{1}{1-p}` to
+    maintain the expected value of each element. Unlike traditional dropout,
+    which zeros individual entries, this layer zeros entire channels. This is
+    beneficial for early convolution layers where adjacent pixels are
+    correlated. In such case, traditional dropout may not effectively
+    regularize activations. For more details, see [1].
+
+    [1]: Thompson, J., Goroshin, R., Jain, A., LeCun, Y. and Bregler C., 2015.
+    Efficient Object Localization Using Convolutional Networks. CVPR 2015.
+
+    Args:
+        p (float): Probability of zeroing a channel during training.
+    """
+
+    def __init__(self, p: float = 0.5):
+        super().__init__()
+
+        if p < 0 or p >= 1:
+            raise ValueError(f"The dropout probability {p} is not in [0, 1)")
+
+        self._p_1 = 1 - p
+
+    def _extra_repr(self) -> str:
+        return f"p={1-self._p_1}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        if x.ndim not in (3, 4):
+            raise ValueError(
+                f"Received input with {x.ndim} dimensions. Expected 3 or 4 dimensions."
+            )
+
+        if self._p_1 == 1 or not self.training:
+            return x
+
+        # Dropout is applied on the whole channel
+        # 3D input: (1, 1, C)
+        # 4D input: (B, 1, 1, C)
+        mask_shape = list(x.shape)
+        mask_shape[-2] = mask_shape[-3] = 1
+
+        mask = mx.random.bernoulli(p=self._p_1, shape=mask_shape)
+        return (mask * x) * (1 / self._p_1)
+
+
+class Dropout3d(Module):
+    r"""Apply 3D channel-wise dropout during training.
+
+    Randomly zero out entire channels independently with probability :math:`p`.
+    This layer expects the channels to be last, i.e., the input shape should be
+    `NDHWC` or `DHWC` where: `N` is the batch dimension, `D` is the depth,
+    `H` is the input image height, `W` is the input image width, and `C` is
+    the number of input channels.
+
+    The remaining channels are scaled by :math:`\frac{1}{1-p}` to
+    maintain the expected value of each element. Unlike traditional dropout,
+    which zeros individual entries, this layer zeros entire channels. This is
+    often beneficial for convolutional layers processing 3D data, like in
+    medical imaging or video processing.
+
+    Args:
+        p (float): Probability of zeroing a channel during training.
+    """
+
+    def __init__(self, p: float = 0.5):
+        super().__init__()
+
+        if p < 0 or p >= 1:
+            raise ValueError(f"The dropout probability {p} is not in [0, 1)")
+
+        self._p_1 = 1 - p
+
+    def _extra_repr(self) -> str:
+        return f"p={1-self._p_1}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        if x.ndim not in (4, 5):
+            raise ValueError(
+                f"Received input with {x.ndim} dimensions. Expected 4 or 5 dimensions."
+            )
+
+        if self._p_1 == 1 or not self.training:
+            return x
+
+        # Dropout is applied on the whole channel
+        # 4D input: (1, 1, 1, C)
+        # 5D input: (B, 1, 1, 1, C)
+        mask_shape = list(x.shape)
+        mask_shape[-2] = mask_shape[-3] = mask_shape[-4] = 1
+
+        mask = mx.random.bernoulli(p=self._p_1, shape=mask_shape)
+        return (mask * x) * (1 / self._p_1)
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/embedding.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/embedding.py
new file mode 100644
index 0000000000000000000000000000000000000000..1edf7e3a5d4365e546a0af9ac6974ec3b2520a78
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/embedding.py
@@ -0,0 +1,44 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+from mlx.nn.layers.quantized import QuantizedEmbedding
+
+
+class Embedding(Module):
+    """Implements a simple lookup table that maps each input integer to a
+    high-dimensional vector.
+
+    Typically used to embed discrete tokens for processing by neural networks.
+
+    Args:
+        num_embeddings (int): How many possible discrete tokens can we embed.
+           Usually called the vocabulary size.
+        dims (int): The dimensionality of the embeddings.
+    """
+
+    def __init__(self, num_embeddings: int, dims: int):
+        super().__init__()
+        scale = math.sqrt(1 / dims)
+        self.weight = mx.random.normal(shape=(num_embeddings, dims), scale=scale)
+
+    def _extra_repr(self):
+        return f"{self.weight.shape[0]}, {self.weight.shape[1]}"
+
+    def __call__(self, x):
+        return self.weight[x]
+
+    def as_linear(self, x):
+        """
+        Call the embedding layer as a linear layer.
+
+        Use this for example when input embedding and output projection
+        weights are tied.
+        """
+        return x @ self.weight.T
+
+    def to_quantized(self, group_size: int = 64, bits: int = 4, mode: str = "affine"):
+        """Return a :obj:`QuantizedEmbedding` layer that approximates this embedding layer."""
+        return QuantizedEmbedding.from_embedding(self, group_size, bits, mode)
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/linear.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/linear.py
new file mode 100644
index 0000000000000000000000000000000000000000..84a4d8327186fa0744f0d64b7fd978b590cfa404
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/linear.py
@@ -0,0 +1,147 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Any
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+from mlx.nn.layers.quantized import QuantizedLinear
+
+
+class Identity(Module):
+    r"""A placeholder identity operator that is argument-insensitive.
+
+    Args:
+        args: any argument (unused)
+        kwargs: any keyword argument (unused)
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__()
+
+    def __call__(self, x: mx.array) -> mx.array:
+        return x
+
+
+class Linear(Module):
+    r"""Applies an affine transformation to the input.
+
+    Concretely:
+
+    .. math::
+
+        y = x W^\top + b
+
+    where:
+    where :math:`W` has shape ``[output_dims, input_dims]`` and :math:`b` has shape ``[output_dims]``.
+
+    The values are initialized from the uniform distribution :math:`\mathcal{U}(-{k}, {k})`,
+    where :math:`k = \frac{1}{\sqrt{D_i}}` and :math:`D_i` is equal to ``input_dims``.
+
+    Args:
+        input_dims (int): The dimensionality of the input features
+        output_dims (int): The dimensionality of the output features
+        bias (bool, optional): If set to ``False`` then the layer will
+          not use a bias. Default is ``True``.
+    """
+
+    def __init__(self, input_dims: int, output_dims: int, bias: bool = True) -> None:
+        super().__init__()
+        scale = math.sqrt(1.0 / input_dims)
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims, input_dims),
+        )
+        if bias:
+            self.bias = mx.random.uniform(
+                low=-scale,
+                high=scale,
+                shape=(output_dims,),
+            )
+
+    def _extra_repr(self) -> str:
+        return f"input_dims={self.weight.shape[1]}, output_dims={self.weight.shape[0]}, bias={'bias' in self}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        if "bias" in self:
+            x = mx.addmm(self["bias"], x, self["weight"].T)
+        else:
+            x = x @ self["weight"].T
+        return x
+
+    def to_quantized(self, group_size: int = 64, bits: int = 4, mode: str = "affine"):
+        """Return a :obj:`QuantizedLinear` layer that approximates this layer."""
+        return QuantizedLinear.from_linear(self, group_size, bits, mode)
+
+
+class Bilinear(Module):
+    r"""Applies a bilinear transformation to the inputs.
+
+    Concretely:
+
+    .. math::
+
+        y_i = x_1^\top W_i x_2 + b_i
+
+    where:
+    :math:`W` has shape ``[output_dims, input1_dims, input2_dims]``, :math:`b` has shape ``[output_dims ]``,
+    and :math:`i` indexes the output dimension.
+
+    The values are initialized from the uniform distribution :math:`\mathcal{U}(-{k}, {k})`,
+    where :math:`k = \frac{1}{\sqrt{D_1}}` and :math:`D_1` is ``input1_dims``.
+
+    Args:
+        input1_dims (int): The dimensionality of the input1 features
+        input2_dims (int): The dimensionality of the input2 features
+        output_dims (int): The dimensionality of the output features
+        bias (bool, optional): If set to ``False`` then the layer will
+          not use a bias. Default is ``True``.
+    """
+
+    def __init__(
+        self, input1_dims: int, input2_dims: int, output_dims: int, bias: bool = True
+    ) -> None:
+        super().__init__()
+        scale = math.sqrt(1.0 / input1_dims)
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims, input2_dims, input1_dims),
+        )
+        if bias:
+            self.bias = mx.random.uniform(
+                low=-scale,
+                high=scale,
+                shape=(output_dims,),
+            )
+
+    def _extra_repr(self) -> str:
+        out, in2, in1 = self.weight.shape
+        return (
+            f"input1_dims={in1}, input2_dims={in2}, output_dims={out}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x1: mx.array, x2: mx.array) -> mx.array:
+        # Normalize shapes
+        out, in2, in1 = self.weight.shape
+        xshape = x1.shape[:-1]
+        x1 = x1.reshape(-1, in1)
+        x2 = x2.reshape(-1, 1, in2)
+
+        # Perform the bilinear transformation
+        w = self.weight.reshape(out * in2, in1)
+        y = x1 @ w.T
+        y = y.reshape(-1, out, in2).swapaxes(-2, -1)
+        y = x2 @ y
+        y = y.squeeze(1)
+
+        # Reset the shape
+        y = y.reshape(*xshape, out)
+
+        # Apply the bias
+        if "bias" in self:
+            y = y + self.bias
+
+        return y
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/normalization.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/normalization.py
new file mode 100644
index 0000000000000000000000000000000000000000..bdddb6ccfb0bbb7049c8b3364da03d9a86fbf58d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/normalization.py
@@ -0,0 +1,363 @@
+# Copyright © 2023 Apple Inc.
+
+from typing import Tuple
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class InstanceNorm(Module):
+    r"""Applies instance normalization [1] on the inputs.
+
+    Computes
+
+    .. math::
+
+        y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta,
+
+    where :math:`\gamma` and :math:`\beta` are learned per feature dimension
+    parameters initialized at 1 and 0 respectively. Both are of size :attr:`dims`,
+    if :attr:`affine` is ``True``.
+
+    Args:
+        dims (int): The number of features of the input.
+        eps (float): A value added to the denominator for numerical stability. Default: ``1e-5``.
+        affine (bool): Default: ``False``.
+
+    Shape:
+      - Input: :math:`(..., C)` where :math:`C` is equal to :attr:`dims`.
+      - Output: Same shape as the input.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+        >>> x = mx.random.normal((8, 4, 4, 16))
+        >>> inorm = nn.InstanceNorm(dims=16)
+        >>> output = inorm(x)
+
+    References:
+        [1]: https://arxiv.org/abs/1607.08022
+    """
+
+    def __init__(
+        self,
+        dims: int,
+        eps: float = 1e-5,
+        affine: bool = False,
+    ):
+        super().__init__()
+        if affine:
+            self.weight = mx.ones((dims,))
+            self.bias = mx.zeros((dims,))
+        self.dims = dims
+        self.eps = eps
+
+    def _extra_repr(self):
+        return f"{self.dims}, eps={self.eps}, affine={'weight' in self}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        reduction_axes = tuple(range(1, x.ndim - 1))
+        # Compute stats
+        mean = mx.mean(x, axis=reduction_axes, keepdims=True)
+        var = mx.var(x, axis=reduction_axes, keepdims=True)
+        # Normalize
+        x = (x - mean) * mx.rsqrt(var + self.eps)
+        # Scale and shift if necessary
+        return (self.weight * x + self.bias) if "weight" in self else x
+
+
+class LayerNorm(Module):
+    r"""Applies layer normalization [1] on the inputs.
+
+    Computes
+
+    .. math::
+
+        y = \frac{x - E[x]}{\sqrt{Var[x]} + \epsilon} \gamma + \beta,
+
+    where :math:`\gamma` and :math:`\beta` are learned per feature dimension
+    parameters initialized at 1 and 0 respectively.
+
+    [1]: https://arxiv.org/abs/1607.06450
+
+    Args:
+        dims (int): The feature dimension of the input to normalize over
+        eps (float): A small additive constant for numerical stability
+        affine (bool): If True learn an affine transform to apply after the
+            normalization
+        bias (bool): If True include a translation to the affine
+            transformation. If set to False the transformation is not really affine
+            just scaling.
+    """
+
+    def __init__(
+        self, dims: int, eps: float = 1e-5, affine: bool = True, bias: bool = True
+    ):
+        super().__init__()
+        if affine:
+            self.weight = mx.ones((dims,))
+            if bias:
+                self.bias = mx.zeros((dims,))
+        self.eps = eps
+        self.dims = dims
+
+    def _extra_repr(self):
+        return f"{self.dims}, eps={self.eps}, affine={'weight' in self}"
+
+    def __call__(self, x):
+        weight = self.weight if "weight" in self else None
+        bias = self.bias if "bias" in self else None
+        return mx.fast.layer_norm(x, weight, bias, self.eps)
+
+
+class RMSNorm(Module):
+    r"""Applies Root Mean Square normalization [1] to the inputs.
+
+    Computes
+
+    ..  math::
+
+        y = \frac{x}{\sqrt{E[x^2] + \epsilon}} \gamma
+
+    where :math:`\gamma` is a learned per feature dimension parameter initialized at
+    1.
+
+    Note the accumulation for the mean is done in 32-bit precision.
+
+    [1]: https://arxiv.org/abs/1910.07467
+
+    Args:
+        dims (int): The feature dimension of the input to normalize over
+        eps (float): A small additive constant for numerical stability
+    """
+
+    def __init__(self, dims: int, eps: float = 1e-5):
+        super().__init__()
+        self.weight = mx.ones((dims,))
+        self.eps = eps
+
+    def _extra_repr(self):
+        return f"{self.weight.shape[0]}, eps={self.eps}"
+
+    def __call__(self, x):
+        return mx.fast.rms_norm(x, self["weight"], self.eps)
+
+
+class GroupNorm(Module):
+    r"""Applies Group Normalization [1] to the inputs.
+
+    Computes the same normalization as layer norm, namely
+
+    .. math::
+
+        y = \frac{x - E[x]}{\sqrt{Var[x]} + \epsilon} \gamma + \beta,
+
+    where :math:`\gamma` and :math:`\beta` are learned per feature dimension
+    parameters initialized at 1 and 0 respectively. However, the mean and
+    variance are computed over the spatial dimensions and each group of
+    features. In particular, the input is split into num_groups across the
+    feature dimension.
+
+    The feature dimension is assumed to be the last dimension and the dimensions
+    that precede it (except the first) are considered the spatial dimensions.
+
+    [1]: https://arxiv.org/abs/1803.08494
+
+    Args:
+        num_groups (int): Number of groups to separate the features into
+        dims (int): The feature dimensions of the input to normalize over
+        eps (float): A small additive constant for numerical stability
+        affine (bool): If True learn an affine transform to apply after the
+            normalization.
+        pytorch_compatible (bool): If True perform the group normalization in
+            the same order/grouping as PyTorch.
+    """
+
+    def __init__(
+        self,
+        num_groups: int,
+        dims: int,
+        eps: float = 1e-5,
+        affine: bool = True,
+        pytorch_compatible: bool = False,
+    ):
+        super().__init__()
+        if affine:
+            self.bias = mx.zeros((dims,))
+            self.weight = mx.ones((dims,))
+        self.num_groups = num_groups
+        self.dims = dims
+        self.eps = eps
+        self.pytorch_compatible = pytorch_compatible
+
+    def _extra_repr(self):
+        return (
+            f"{self.num_groups}, {self.dims}, eps={self.eps}, "
+            f"affine={'weight' in self}, pytorch_compatible={self.pytorch_compatible}"
+        )
+
+    def _pytorch_compatible_group_norm(self, x):
+        num_groups = self.num_groups
+        batch, *rest, dims = x.shape
+        group_size = dims // num_groups
+
+        # Split into groups
+        x = x.reshape(batch, -1, num_groups, group_size)
+        x = x.transpose(0, 2, 1, 3).reshape(batch, num_groups, -1)
+
+        # Normalize
+        x = mx.fast.layer_norm(x, eps=self.eps, weight=None, bias=None)
+
+        x = x.reshape(batch, num_groups, -1, group_size)
+        x = x.transpose(0, 2, 1, 3).reshape(batch, *rest, dims)
+        return x
+
+    def _group_norm(self, x):
+        num_groups = self.num_groups
+        batch, *rest, dims = x.shape
+
+        # Split into groups
+        x = x.reshape(batch, -1, num_groups)
+
+        # Normalize
+        means = mx.mean(x, axis=1, keepdims=True)
+        var = mx.var(x, axis=1, keepdims=True)
+        x = (x - means) * mx.rsqrt(var + self.eps)
+        x = x.reshape(batch, *rest, dims)
+
+        return x
+
+    def __call__(self, x):
+        group_norm = (
+            self._pytorch_compatible_group_norm
+            if self.pytorch_compatible
+            else self._group_norm
+        )
+        x = group_norm(x)
+        return (self.weight * x + self.bias) if "weight" in self else x
+
+
+class BatchNorm(Module):
+    r"""Applies Batch Normalization over a 2D or 3D input.
+
+    Computes
+
+    .. math::
+
+        y = \frac{x - E[x]}{\sqrt{Var[x]} + \epsilon} \gamma + \beta,
+
+    where :math:`\gamma` and :math:`\beta` are learned per feature dimension
+    parameters initialized at 1 and 0 respectively.
+
+    The input shape is specified as ``NC`` or ``NLC``, where ``N`` is the
+    batch, ``C`` is the number of features or channels, and ``L`` is the
+    sequence length. The output has the same shape as the input. For
+    four-dimensional arrays, the shape is ``NHWC``, where ``H`` and ``W`` are
+    the height and width respectively.
+
+    For more information on Batch Normalization, see the original paper `Batch
+    Normalization: Accelerating Deep Network Training by Reducing Internal
+    Covariate Shift <https://arxiv.org/abs/1502.03167>`_.
+
+    Args:
+        num_features (int): The feature dimension to normalize over.
+        eps (float, optional): A small additive constant for numerical
+            stability. Default: ``1e-5``.
+        momentum (float, optional): The momentum for updating the running
+            mean and variance. Default: ``0.1``.
+        affine (bool, optional): If ``True``, apply a learned affine
+            transformation after the normalization. Default: ``True``.
+        track_running_stats (bool, optional): If ``True``, track the
+            running mean and variance. Default: ``True``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+        >>> x = mx.random.normal((5, 4))
+        >>> bn = nn.BatchNorm(num_features=4, affine=True)
+        >>> output = bn(x)
+    """
+
+    def __init__(
+        self,
+        num_features: int,
+        eps: float = 1e-5,
+        momentum: float = 0.1,
+        affine: bool = True,
+        track_running_stats: bool = True,
+    ):
+        super().__init__()
+
+        self.num_features = num_features
+        self.eps = eps
+        self.momentum = momentum
+        self.track_running_stats = track_running_stats
+
+        if affine:
+            self.weight = mx.ones((num_features,))
+            self.bias = mx.zeros((num_features,))
+
+        if self.track_running_stats:
+            self.running_mean = mx.zeros((num_features,))
+            self.running_var = mx.ones((num_features,))
+            self.freeze(keys=["running_mean", "running_var"], recurse=False)
+
+    def unfreeze(self, *args, **kwargs):
+        """Wrap unfreeze to make sure that running_mean and var are always
+        frozen parameters."""
+        super().unfreeze(*args, **kwargs)
+        self.freeze(keys=["running_mean", "running_var"], recurse=False)
+
+    def _extra_repr(self):
+        return (
+            f"{self.num_features}, eps={self.eps}, "
+            f"momentum={self.momentum}, affine={'weight' in self}, "
+            f"track_running_stats={self.track_running_stats}"
+        )
+
+    def _calc_stats(self, x: mx.array) -> Tuple[mx.array, mx.array]:
+        """
+        Calculate the mean and variance of the input tensor across the batch
+        and spatial dimensions.
+
+        Args:
+            x (array): Input tensor.
+
+        Returns:
+            tuple: Tuple containing mean and variance.
+        """
+        reduction_axes = tuple(range(0, x.ndim - 1))
+
+        mean = mx.mean(x, axis=reduction_axes)
+        var = mx.var(x, axis=reduction_axes)
+
+        return mean, var
+
+    def __call__(self, x: mx.array) -> mx.array:
+        """
+        Forward pass of BatchNorm.
+
+        Args:
+            x (array): Input tensor.
+
+        Returns:
+            array: Normalized output tensor.
+        """
+        if x.ndim < 2 or x.ndim > 4:
+            raise ValueError(
+                f"Expected input tensor to have 2, 3 or 4 dimensions, but got {x.ndim}"
+            )
+
+        # Calculate the mean and variance used to normalize the input x. If we
+        # are in training mode update the running stats if needed.
+        mean, var = self._calc_stats(x)
+        if self.training and self.track_running_stats:
+            mu = self.momentum
+            self.running_mean = (1 - mu) * self.running_mean + mu * mean
+            self.running_var = (1 - mu) * self.running_var + mu * var
+        elif self.track_running_stats:
+            mean = self.running_mean
+            var = self.running_var
+
+        x = (x - mean) * mx.rsqrt(var + self.eps)
+        return (self.weight * x + self.bias) if "weight" in self else x
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/pooling.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/pooling.py
new file mode 100644
index 0000000000000000000000000000000000000000..2031176346532fb878ce2602674dfa60473eeb6a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/pooling.py
@@ -0,0 +1,398 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import operator
+from itertools import accumulate
+from typing import Optional, Tuple, Union
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+def _value_or_list(x, n, msg):
+    if isinstance(x, (list, tuple)):
+        if len(x) != n:
+            raise ValueError(msg)
+        return list(x)
+
+    if not isinstance(x, int):
+        raise ValueError(msg)
+
+    return [x] * n
+
+
+def _non_overlapping_sliding_windows(x, shape, window_shape):
+    # Compute the intermediate shape
+    new_shape = [shape[0]]
+    for s, w in zip(shape[1:], window_shape):
+        new_shape.append(s // w)
+        new_shape.append(w)
+    new_shape.append(shape[-1])
+
+    last_axis = len(new_shape) - 1
+    axis_order = [0, *range(1, last_axis, 2), *range(2, last_axis, 2), last_axis]
+
+    x = x.reshape(new_shape)
+    x = x.transpose(axis_order)
+    return x
+
+
+def _sliding_windows(x, window_shape, window_strides):
+    if x.ndim < 3:
+        raise ValueError(
+            f"To extract sliding windows at least 1 spatial dimension "
+            f"(3 total) is needed but the input only has {x.ndim} dimensions."
+        )
+
+    spatial_dims = x.shape[1:-1]
+    if not (len(spatial_dims) == len(window_shape) == len(window_strides)):
+        raise ValueError(
+            f"To extract sliding windows the window shapes and strides must have "
+            f"the same number of spatial dimensions as the signal but the signal "
+            f"has {len(spatial_dims)} dims and the window shape has {len(window_shape)} "
+            f"and strides have {len(window_strides)}."
+        )
+
+    shape = x.shape
+    if all(
+        window == stride and size % window == 0
+        for size, window, stride in zip(spatial_dims, window_shape, window_strides)
+    ):
+        return _non_overlapping_sliding_windows(x, shape, window_shape)
+
+    strides = list(reversed(list(accumulate(reversed(shape + (1,)), operator.mul))))[1:]
+
+    # Compute the output shape
+    final_shape = [shape[0]]
+    final_shape += [
+        (size - window) // stride + 1
+        for size, window, stride in zip(spatial_dims, window_shape, window_strides)
+    ]
+    final_shape += window_shape
+    final_shape += [shape[-1]]
+
+    # Compute the output strides
+    final_strides = strides[:1]
+    final_strides += [
+        og_stride * stride for og_stride, stride in zip(strides[1:-1], window_strides)
+    ]
+    final_strides += strides[1:-1]
+    final_strides += strides[-1:]  # should always be [1]
+
+    return mx.as_strided(x, final_shape, final_strides)
+
+
+class _Pool(Module):
+    def __init__(self, pooling_function, kernel_size, stride, padding, padding_value):
+        super().__init__()
+
+        self._pooling_function = pooling_function
+        self._kernel_size = kernel_size
+        self._stride = stride
+        self._padding = padding
+        self._padding_value = padding_value
+        self._axes = tuple(range(-len(self._kernel_size) - 1, -1, 1))
+
+    def _extra_repr(self):
+        ks = tuple(self._kernel_size)
+        st = tuple(self._stride)
+        pd = tuple(p[0] for p in self._padding)
+
+        return f"kernel_size={ks}, stride={st}, padding={pd}"
+
+    def __call__(self, x):
+        if any(p[0] > 0 for p in self._padding):
+            x = mx.pad(
+                x,
+                [(0, 0)] + self._padding + [(0, 0)],
+                constant_values=self._padding_value,
+            )
+        x = _sliding_windows(x, self._kernel_size, self._stride)
+        return self._pooling_function(x, self._axes)
+
+
+class _Pool1d(_Pool):
+    def __init__(
+        self,
+        pooling_function,
+        padding_value,
+        kernel_size: Union[int, Tuple[int]],
+        stride: Optional[Union[int, Tuple[int]]] = None,
+        padding: Union[int, Tuple[int]] = 0,
+    ):
+        class_name = type(self).__name__
+        msg = "[{}] '{}' must be an integer or a tuple containing 1 integer"
+        kernel_size = _value_or_list(
+            kernel_size, 1, msg.format(class_name, "kernel_size")
+        )
+        if stride is not None:
+            stride = _value_or_list(stride, 1, msg.format(class_name, "stride"))
+        else:
+            stride = kernel_size
+        padding = _value_or_list(padding, 1, msg.format(class_name, "padding"))
+        padding = [(p, p) for p in padding]
+
+        super().__init__(pooling_function, kernel_size, stride, padding, padding_value)
+
+
+class _Pool2d(_Pool):
+    def __init__(
+        self,
+        pooling_function,
+        padding_value,
+        kernel_size: Union[int, Tuple[int, int]],
+        stride: Optional[Union[int, Tuple[int, int]]] = None,
+        padding: Optional[Union[int, Tuple[int, int]]] = 0,
+    ):
+        class_name = type(self).__name__
+        msg = "[{}] '{}' must be an integer or a tuple containing 2 integers"
+        kernel_size = _value_or_list(
+            kernel_size, 2, msg.format(class_name, "kernel_size")
+        )
+        if stride is not None:
+            stride = _value_or_list(stride, 2, msg.format(class_name, "stride"))
+        else:
+            stride = kernel_size
+        padding = _value_or_list(padding, 2, msg.format(class_name, "padding"))
+        padding = [(p, p) for p in padding]
+
+        super().__init__(pooling_function, kernel_size, stride, padding, padding_value)
+
+
+class _Pool3d(_Pool):
+    def __init__(
+        self,
+        pooling_function,
+        padding_value,
+        kernel_size: Union[int, Tuple[int, int, int]],
+        stride: Optional[Union[int, Tuple[int, int, int]]] = None,
+        padding: Optional[Union[int, Tuple[int, int, int]]] = 0,
+    ):
+        class_name = type(self).__name__
+        msg = "[{}] '{}' must be an integer or a tuple containing 3 integers"
+        kernel_size = _value_or_list(
+            kernel_size, 3, msg.format(class_name, "kernel_size")
+        )
+        if stride is not None:
+            stride = _value_or_list(stride, 3, msg.format(class_name, "stride"))
+        else:
+            stride = kernel_size
+        padding = _value_or_list(padding, 3, msg.format(class_name, "padding"))
+        padding = [(p, p) for p in padding]
+
+        super().__init__(pooling_function, kernel_size, stride, padding, padding_value)
+
+
+class MaxPool1d(_Pool1d):
+    r"""Applies 1-dimensional max pooling.
+
+    Spatially downsamples the input by taking the maximum of a sliding window
+    of size ``kernel_size`` and sliding stride ``stride``.
+
+    Args:
+        kernel_size (int or tuple(int)): The size of the pooling window kernel.
+        stride (int or tuple(int), optional): The stride of the pooling window.
+            Default: ``kernel_size``.
+        padding (int or tuple(int), optional): How much negative infinity
+            padding to apply to the input. The padding amount is applied to
+            both sides of the spatial axis. Default: ``0``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn.layers as nn
+        >>> x = mx.random.normal(shape=(4, 16, 5))
+        >>> pool = nn.MaxPool1d(kernel_size=2, stride=2)
+        >>> pool(x)
+    """
+
+    def __init__(
+        self,
+        kernel_size: Union[int, Tuple[int]],
+        stride: Optional[Union[int, Tuple[int]]] = None,
+        padding: Union[int, Tuple[int]] = 0,
+    ):
+        super().__init__(mx.max, -float("inf"), kernel_size, stride, padding)
+
+
+class AvgPool1d(_Pool1d):
+    r"""Applies 1-dimensional average pooling.
+
+    Spatially downsamples the input by taking the average of a sliding window
+    of size ``kernel_size`` and sliding stride ``stride``.
+
+    Args:
+        kernel_size (int or tuple(int)): The size of the pooling window kernel.
+        stride (int or tuple(int), optional): The stride of the pooling window.
+            Default: ``kernel_size``.
+        padding (int or tuple(int), optional): How much zero padding to apply to
+            the input. The padding amount is applied to both sides of the spatial
+            axis. Default: ``0``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn.layers as nn
+        >>> x = mx.random.normal(shape=(4, 16, 5))
+        >>> pool = nn.AvgPool1d(kernel_size=2, stride=2)
+        >>> pool(x)
+    """
+
+    def __init__(
+        self,
+        kernel_size: Union[int, Tuple[int]],
+        stride: Optional[Union[int, Tuple[int]]] = None,
+        padding: Union[int, Tuple[int]] = 0,
+    ):
+        super().__init__(mx.mean, 0, kernel_size, stride, padding)
+
+
+class MaxPool2d(_Pool2d):
+    r"""Applies 2-dimensional max pooling.
+
+    Spatially downsamples the input by taking the maximum of a sliding window
+    of size ``kernel_size`` and sliding stride ``stride``.
+
+    The parameters ``kernel_size``, ``stride``, and ``padding`` can either be:
+
+    * a single ``int`` -- in which case the same value is used for both the
+      height and width axis.
+    * a ``tuple`` of two ``int`` s -- in which case, the first ``int`` is
+      used for the height axis, the second ``int`` for the width axis.
+
+    Args:
+        kernel_size (int or tuple(int, int)): The size of the pooling window.
+        stride (int or tuple(int, int), optional): The stride of the pooling
+            window. Default: ``kernel_size``.
+        padding (int or tuple(int, int), optional): How much negative infinity
+            padding to apply to the input. The padding is applied on both sides
+            of the height and width axis. Default: ``0``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn.layers as nn
+        >>> x = mx.random.normal(shape=(8, 32, 32, 4))
+        >>> pool = nn.MaxPool2d(kernel_size=2, stride=2)
+        >>> pool(x)
+    """
+
+    def __init__(
+        self,
+        kernel_size: Union[int, Tuple[int, int]],
+        stride: Optional[Union[int, Tuple[int, int]]] = None,
+        padding: Optional[Union[int, Tuple[int, int]]] = 0,
+    ):
+        super().__init__(mx.max, -float("inf"), kernel_size, stride, padding)
+
+
+class AvgPool2d(_Pool2d):
+    r"""Applies 2-dimensional average pooling.
+
+    Spatially downsamples the input by taking the average of a sliding window
+    of size ``kernel_size`` and sliding stride ``stride``.
+
+    The parameters ``kernel_size``, ``stride``, and ``padding`` can either be:
+
+    * a single ``int`` -- in which case the same value is used for both the
+      height and width axis.
+    * a ``tuple`` of two ``int`` s -- in which case, the first ``int`` is
+      used for the height axis, the second ``int`` for the width axis.
+
+    Args:
+        kernel_size (int or tuple(int, int)): The size of the pooling window.
+        stride (int or tuple(int, int), optional): The stride of the pooling
+            window. Default: ``kernel_size``.
+        padding (int or tuple(int, int), optional): How much zero
+            padding to apply to the input. The padding is applied on both sides
+            of the height and width axis. Default: ``0``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn.layers as nn
+        >>> x = mx.random.normal(shape=(8, 32, 32, 4))
+        >>> pool = nn.AvgPool2d(kernel_size=2, stride=2)
+        >>> pool(x)
+    """
+
+    def __init__(
+        self,
+        kernel_size: Union[int, Tuple[int, int]],
+        stride: Optional[Union[int, Tuple[int, int]]] = None,
+        padding: Optional[Union[int, Tuple[int, int]]] = 0,
+    ):
+        super().__init__(mx.mean, 0, kernel_size, stride, padding)
+
+
+class MaxPool3d(_Pool3d):
+    r"""Applies 3-dimensional max pooling.
+
+    Spatially downsamples the input by taking the maximum of a sliding window
+    of size ``kernel_size`` and sliding stride ``stride``.
+
+    The parameters ``kernel_size``, ``stride``, and ``padding`` can either be:
+
+    * a single ``int`` -- in which case the same value is used for the depth,
+      height, and width axis.
+    * a ``tuple`` of three ``int`` s -- in which case, the first ``int`` is used
+      for the depth axis, the second ``int`` for the height axis, and the third
+      ``int`` for the width axis.
+
+    Args:
+        kernel_size (int or tuple(int, int, int)): The size of the pooling window.
+        stride (int or tuple(int, int, int), optional): The stride of the pooling
+            window. Default: ``kernel_size``.
+        padding (int or tuple(int, int, int), optional): How much negative infinity
+            padding to apply to the input. The padding is applied on both sides
+            of the depth, height and width axis. Default: ``0``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn.layers as nn
+        >>> x = mx.random.normal(shape=(8, 16, 32, 32, 4))
+        >>> pool = nn.MaxPool3d(kernel_size=2, stride=2)
+        >>> pool(x)
+    """
+
+    def __init__(
+        self,
+        kernel_size: Union[int, Tuple[int, int, int]],
+        stride: Optional[Union[int, Tuple[int, int, int]]] = None,
+        padding: Optional[Union[int, Tuple[int, int, int]]] = 0,
+    ):
+        super().__init__(mx.max, -float("inf"), kernel_size, stride, padding)
+
+
+class AvgPool3d(_Pool3d):
+    r"""Applies 3-dimensional average pooling.
+
+    Spatially downsamples the input by taking the average of a sliding window
+    of size ``kernel_size`` and sliding stride ``stride``.
+
+    The parameters ``kernel_size``, ``stride``, and ``padding`` can either be:
+
+    * a single ``int`` -- in which case the same value is used for the depth,
+      height, and width axis.
+    * a ``tuple`` of three ``int`` s -- in which case, the first ``int`` is used
+      for the depth axis, the second ``int`` for the height axis, and the third
+      ``int`` for the width axis.
+
+    Args:
+        kernel_size (int or tuple(int, int, int)): The size of the pooling window.
+        stride (int or tuple(int, int, int), optional): The stride of the pooling
+            window. Default: ``kernel_size``.
+        padding (int or tuple(int, int, int), optional): How much zero
+            padding to apply to the input. The padding is applied on both sides
+            of the depth, height and width axis. Default: ``0``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn.layers as nn
+        >>> x = mx.random.normal(shape=(8, 16, 32, 32, 4))
+        >>> pool = nn.AvgPool3d(kernel_size=2, stride=2)
+        >>> pool(x)
+    """
+
+    def __init__(
+        self,
+        kernel_size: Union[int, Tuple[int, int, int]],
+        stride: Optional[Union[int, Tuple[int, int, int]]] = None,
+        padding: Optional[Union[int, Tuple[int, int, int]]] = 0,
+    ):
+        super().__init__(mx.mean, 0, kernel_size, stride, padding)
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/positional_encoding.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/positional_encoding.py
new file mode 100644
index 0000000000000000000000000000000000000000..950a93cd5d8dfd4a9c5ee50a67a5754c6c4170dc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/positional_encoding.py
@@ -0,0 +1,171 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+from typing import Optional
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class RoPE(Module):
+    """Implements the rotary positional encoding.
+
+    The traditional implementation rotates consecutive pairs of elements in the
+    feature dimension while the default implementation rotates pairs with
+    stride half the feature dimensions for efficiency.
+
+    For more details see `RoFormer: Enhanced Transformer with Rotary Position
+    Embedding <https://arxiv.org/abs/2104.09864>`_.
+
+    Args:
+        dims (int): The feature dimensions to be rotated. If the input feature
+            is larger than dims then the rest is left unchanged.
+        traditional (bool, optional): If set to ``True`` choose the traditional
+            implementation which is slightly less efficient. Default: ``False``.
+        base (float, optional): The base used to compute angular frequency for
+            each dimension in the positional encodings. Default: ``10000``.
+        scale (float, optional): The scale used to scale the positions. Default: ``1.0``.
+    """
+
+    def __init__(
+        self,
+        dims: int,
+        traditional: bool = False,
+        base: float = 10000,
+        scale: float = 1.0,
+    ):
+        super().__init__()
+        self.dims = dims
+        self.traditional = traditional
+        self.base = base
+        self.scale = scale
+
+    def _extra_repr(self):
+        return f"{self.dims}, traditional={self.traditional}"
+
+    def __call__(self, x, offset: int = 0):
+        return mx.fast.rope(
+            x,
+            self.dims,
+            traditional=self.traditional,
+            base=self.base,
+            scale=self.scale,
+            offset=offset,
+        )
+
+
+class SinusoidalPositionalEncoding(Module):
+    r"""Implements sinusoidal positional encoding.
+
+    For more details see the paper `Attention Is All You Need
+    <https://arxiv.org/abs/1706.03762>`_.
+
+    Args:
+        dims (int): The dimensionality of the resulting positional embeddings.
+        min_freq (float, optional): The minimum frequency expected. Default:
+            ``0.0001``.
+        max_freq (float, optional): The maximum frequency expected. Default:
+            ``1``.
+        scale (float, optional): A multiplicative scale for the embeddings.
+            Default: ``sqrt(2/dims)``.
+        cos_first (bool, optional): If ``True`` embed using ``[cos(x); sin(x)]``
+            instead of the reverse. Default: ``False``.
+        full_turns (bool, optional): If ``True`` multiply the frequencies with
+            :math:`2\pi`. Default: ``False``.
+    """
+
+    def __init__(
+        self,
+        dims: int,
+        min_freq: float = 0.0001,
+        max_freq: float = 1,
+        scale: Optional[float] = None,
+        cos_first: bool = False,
+        full_turns: bool = False,
+    ):
+        super().__init__()
+
+        one_zero = 1 - mx.arange(0, dims // 2) / (dims // 2 - 1)
+        min_freq = math.log(min_freq)
+        max_freq = math.log(max_freq)
+
+        # Start with underscore so it is not included in the parameters
+        self._sigmas = mx.exp(one_zero * (max_freq - min_freq) + min_freq)
+        if full_turns:
+            self._sigmas = self._sigmas * (2 * math.pi)
+
+        # Save some constants that define the implementation
+        self.scale = scale or (2 / dims) ** 0.5
+        self.cos_first = cos_first
+
+    def __call__(self, x):
+        y = x[..., None] * self._sigmas
+        cosy = mx.cos(y)
+        siny = mx.sin(y)
+
+        if self.cos_first:
+            y = mx.concatenate([cosy, siny], axis=-1)
+        else:
+            y = mx.concatenate([siny, cosy], axis=-1)
+
+        if self.scale != 1:
+            y = y * self.scale
+
+        return y
+
+
+class ALiBi(Module):
+    _alibi_mask_key = None
+    _alibi_mask = None
+
+    @classmethod
+    def create_alibi_matrix(
+        cls,
+        q_sequence_length: int,
+        k_sequence_length: int,
+        num_heads: int,
+        offset: int,
+        dtype=mx.float32,
+    ):
+        if (
+            q_sequence_length,
+            k_sequence_length,
+            num_heads,
+            offset,
+            dtype,
+        ) != cls._alibi_mask_key:
+            x1 = mx.arange(offset, q_sequence_length)
+            x2 = mx.arange(0, k_sequence_length)
+            distance_matrix = -mx.abs(
+                mx.expand_dims(x1[:, None] - x2[None, :], axis=(0, 1))
+            )
+            alibi_slope = ALiBi.create_alibi_slope(num_heads=num_heads)
+            alibi_mask = (distance_matrix * alibi_slope).astype(dtype)
+            cls._alibi_mask_key = (
+                q_sequence_length,
+                k_sequence_length,
+                num_heads,
+                offset,
+                dtype,
+            )
+            cls._alibi_mask = alibi_mask
+
+        return cls._alibi_mask
+
+    @staticmethod
+    def create_alibi_slope(num_heads):
+        x = (2**8) ** (1 / num_heads)
+        out = mx.power(x, -mx.arange(1, num_heads + 1))
+        return mx.expand_dims(out, axis=(-1, -2))
+
+    def __call__(self, attention_scores, offset=0, mask=None):
+        alibi_mask = ALiBi.create_alibi_matrix(
+            q_sequence_length=attention_scores.shape[-2] + offset,
+            k_sequence_length=attention_scores.shape[-1],
+            num_heads=attention_scores.shape[1],
+            offset=offset,
+            dtype=attention_scores.dtype,
+        )
+        if mask is not None:
+            alibi_mask = alibi_mask + mask
+        return attention_scores + alibi_mask
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/quantized.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/quantized.py
new file mode 100644
index 0000000000000000000000000000000000000000..c308e884ba0c7ed415788b0d23921a8ac5a90212
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/quantized.py
@@ -0,0 +1,270 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+from typing import Callable, Optional, Union
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+from mlx.utils import tree_map_with_path
+
+
+def quantize(
+    model: Module,
+    group_size: int = 64,
+    bits: int = 4,
+    *,
+    mode: str = "affine",
+    class_predicate: Optional[Callable[[str, Module], Union[bool, dict]]] = None,
+):
+    """Quantize the sub-modules of a module according to a predicate.
+
+    By default all layers that define a ``to_quantized(group_size, bits)``
+    method will be quantized. Both :obj:`Linear` and :obj:`Embedding` layers
+    will be quantized. Note also, the module is updated in-place.
+
+    Args:
+        model (mlx.nn.Module): The model whose leaf modules may be quantized.
+        group_size (int): The quantization group size (see
+           :func:`mlx.core.quantize`). Default: ``64``.
+        bits (int): The number of bits per parameter (see
+           :func:`mlx.core.quantize`). Default: ``4``.
+        mode (str): The quantization method to use (see
+           :func:`mlx.core.quantize`). Default: ``"affine"``.
+        class_predicate (Optional[Callable]): A callable which receives the
+          :obj:`Module` path and :obj:`Module` itself and returns ``True`` or a
+          dict of params for `to_quantized` if it should be quantized and
+          ``False`` otherwise. If ``None``, then all layers that define a
+          ``to_quantized(group_size, bits)`` method are quantized.
+          Default: ``None``.
+    """
+    class_predicate = class_predicate or (lambda _, m: hasattr(m, "to_quantized"))
+
+    def _maybe_quantize(path, m):
+        if bool_or_params := class_predicate(path, m):
+            if hasattr(m, "to_quantized"):
+                if isinstance(bool_or_params, bool):
+                    return m.to_quantized(group_size=group_size, bits=bits, mode=mode)
+                elif isinstance(bool_or_params, dict):
+                    return m.to_quantized(**bool_or_params)
+                else:
+                    raise ValueError(
+                        "``class_predicate`` must return a bool"
+                        " or a dict of parameters to pass to ``to_quantized``"
+                    )
+            else:
+                raise ValueError(f"Unable to quantize model of type {type(m)}")
+        else:
+            return m
+
+    leaves = model.leaf_modules()
+    leaves = tree_map_with_path(_maybe_quantize, leaves, is_leaf=Module.is_module)
+    model.update_modules(leaves)
+
+
+class QuantizedEmbedding(Module):
+    """The same as :obj:`Embedding` but with a  quantized weight matrix.
+
+    :obj:`QuantizedEmbedding` also provides a :meth:`from_embedding`
+    classmethod to convert embedding layers to :obj:`QuantizedEmbedding`
+    layers.
+
+    Args:
+        num_embeddings (int): How many possible discrete tokens can we embed.
+           Usually called the vocabulary size.
+        dims (int): The dimensionality of the embeddings.
+        group_size (int, optional): The group size to use for the quantized
+            weight. See :func:`~mlx.core.quantize`. Default: ``64``.
+        bits (int, optional): The bit width to use for the quantized weight.
+            See :func:`~mlx.core.quantize`. Default: ``4``.
+        mode (str): The quantization method to use (see
+           :func:`mlx.core.quantize`). Default: ``"affine"``.
+    """
+
+    def __init__(
+        self,
+        num_embeddings: int,
+        dims: int,
+        group_size: int = 64,
+        bits: int = 4,
+        mode: str = "affine",
+    ):
+        super().__init__()
+
+        # Quantization config
+        self.group_size = group_size
+        self.bits = bits
+        self.mode = mode
+
+        # Initialize the quantized weight
+        scale = math.sqrt(1 / dims)
+        weight = mx.random.normal(shape=(num_embeddings, dims), scale=scale)
+        self.weight, self.scales, *biases = mx.quantize(
+            weight, group_size, bits, mode=mode
+        )
+        self.biases = biases[0] if biases else None
+        self.num_embeddings = num_embeddings
+        self.dims = dims
+
+        # Freeze this model's parameters
+        self.freeze()
+
+    def __call__(self, x):
+        biases = self.get("biases")
+        return mx.dequantize(
+            self["weight"][x],
+            scales=self["scales"][x],
+            biases=biases[x] if biases is not None else None,
+            group_size=self.group_size,
+            bits=self.bits,
+            mode=self.mode,
+        )
+
+    def as_linear(self, x):
+        """
+        Call the quantized embedding layer as a quantized linear layer.
+
+        Use this for example when input embedding and output projection
+        weights are tied.
+        """
+        return mx.quantized_matmul(
+            x,
+            self["weight"],
+            scales=self["scales"],
+            biases=self.get("biases"),
+            transpose=True,
+            group_size=self.group_size,
+            bits=self.bits,
+            mode=self.mode,
+        )
+
+    def _extra_repr(self):
+        return (
+            f"{self.num_embeddings}, {self.dims}, "
+            f"group_size={self.group_size}, bits={self.bits}, mode={self.mode}"
+        )
+
+    @classmethod
+    def from_embedding(
+        cls,
+        embedding_layer: Module,
+        group_size: int = 64,
+        bits: int = 4,
+        mode: str = "affine",
+    ):
+        """Create a :obj:`QuantizedEmbedding` layer from an :obj:`Embedding` layer."""
+        embedding_dims, dims = embedding_layer.weight.shape
+        ql = cls(embedding_dims, dims, group_size, bits, mode=mode)
+        ql.weight, ql.scales, *biases = mx.quantize(
+            embedding_layer.weight,
+            group_size,
+            bits,
+            mode=mode,
+        )
+        ql.biases = biases[0] if biases else None
+        return ql
+
+
+class QuantizedLinear(Module):
+    """Applies an affine transformation to the input using a quantized weight matrix.
+
+    It is the quantized equivalent of :class:`mlx.nn.Linear`. For now its
+    parameters are frozen and will not be included in any gradient computation
+    but this will probably change in the future.
+
+    :obj:`QuantizedLinear` also provides a classmethod :meth:`from_linear` to
+    convert linear layers to :obj:`QuantizedLinear` layers.
+
+    Args:
+        input_dims (int): The dimensionality of the input features.
+        output_dims (int): The dimensionality of the output features.
+        bias (bool, optional): If set to ``False`` then the layer will not use
+            a bias. Default: ``True``.
+        group_size (int, optional): The group size to use for the quantized
+            weight. See :func:`~mlx.core.quantize`. Default: ``64``.
+        bits (int, optional): The bit width to use for the quantized weight.
+            See :func:`~mlx.core.quantize`. Default: ``4``.
+        mode (str): The quantization method to use (see
+           :func:`mlx.core.quantize`). Default: ``"affine"``.
+    """
+
+    def __init__(
+        self,
+        input_dims: int,
+        output_dims: int,
+        bias: bool = True,
+        group_size: int = 64,
+        bits: int = 4,
+        mode: str = "affine",
+    ):
+        super().__init__()
+
+        # Quantization config
+        self.group_size = group_size
+        self.bits = bits
+        self.mode = mode
+
+        # Initialize the quantized weight
+        scale = math.sqrt(1 / input_dims)
+        weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims, input_dims),
+        )
+        self.weight, self.scales, *biases = mx.quantize(
+            weight, group_size, bits, mode=mode
+        )
+        self.biases = biases[0] if biases else None
+
+        # And bias if needed
+        if bias:
+            self.bias = mx.zeros((output_dims,))
+
+        # Freeze this model's parameters
+        self.freeze()
+
+    def _extra_repr(self):
+        out_dims, in_dims = self.weight.shape
+        in_dims *= 32 // self.bits
+        return (
+            f"input_dims={in_dims}, output_dims={out_dims}, bias={'bias' in self}, "
+            f"group_size={self.group_size}, bits={self.bits}, mode={self.mode}"
+        )
+
+    def __call__(self, x):
+        x = mx.quantized_matmul(
+            x,
+            self["weight"],
+            scales=self["scales"],
+            biases=self.get("biases"),
+            transpose=True,
+            group_size=self.group_size,
+            bits=self.bits,
+            mode=self.mode,
+        )
+        if "bias" in self:
+            x = x + self["bias"]
+        return x
+
+    @classmethod
+    def from_linear(
+        cls,
+        linear_layer: Module,
+        group_size: int = 64,
+        bits: int = 4,
+        mode: str = "affine",
+    ):
+        """Create a :obj:`QuantizedLinear` layer from a :obj:`Linear` layer."""
+        output_dims, input_dims = linear_layer.weight.shape
+        ql = cls(input_dims, output_dims, False, group_size, bits, mode=mode)
+        ql.weight, ql.scales, *biases = mx.quantize(
+            linear_layer.weight,
+            group_size,
+            bits,
+            mode=mode,
+        )
+        ql.biases = biases[0] if biases else None
+
+        if "bias" in linear_layer:
+            ql.bias = linear_layer.bias
+
+        return ql
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/recurrent.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/recurrent.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ffa7654c3e07afbe6c091339179c2464747de18
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/recurrent.py
@@ -0,0 +1,289 @@
+# Copyright © 2024 Apple Inc.
+
+import math
+from typing import Callable, Optional
+
+import mlx.core as mx
+from mlx.nn.layers.activations import tanh
+from mlx.nn.layers.base import Module
+
+
+class RNN(Module):
+    r"""An Elman recurrent layer.
+
+    The input is a sequence of shape ``NLD`` or ``LD`` where:
+
+    * ``N`` is the optional batch dimension
+    * ``L`` is the sequence length
+    * ``D`` is the input's feature dimension
+
+    Concretely, for each element along the sequence length axis, this
+    layer applies the function:
+
+    .. math::
+
+        h_{t + 1} = \text{tanh} (W_{ih}x_t + W_{hh}h_t + b)
+
+    The hidden state :math:`h` has shape ``NH`` or ``H``, depending on
+    whether the input is batched or not. Returns the hidden state at each
+    time step, of shape ``NLH`` or ``LH``.
+
+    Args:
+        input_size (int): Dimension of the input, ``D``.
+        hidden_size (int): Dimension of the hidden state, ``H``.
+        bias (bool, optional): Whether to use a bias. Default: ``True``.
+        nonlinearity (callable, optional): Non-linearity to use. If ``None``,
+            then func:`tanh` is used. Default: ``None``.
+    """
+
+    def __init__(
+        self,
+        input_size: int,
+        hidden_size: int,
+        bias: bool = True,
+        nonlinearity: Optional[Callable] = None,
+    ):
+        super().__init__()
+
+        self.nonlinearity = nonlinearity or tanh
+        if not callable(self.nonlinearity):
+            raise ValueError(
+                f"Nonlinearity must be callable. Current value: {nonlinearity}."
+            )
+
+        scale = 1.0 / math.sqrt(hidden_size)
+        self.hidden_size = hidden_size
+        self.Wxh = mx.random.uniform(
+            low=-scale, high=scale, shape=(hidden_size, input_size)
+        )
+        self.Whh = mx.random.uniform(
+            low=-scale, high=scale, shape=(hidden_size, hidden_size)
+        )
+        self.bias = (
+            mx.random.uniform(low=-scale, high=scale, shape=(hidden_size,))
+            if bias
+            else None
+        )
+
+    def _extra_repr(self):
+        return (
+            f"input_dims={self.Wxh.shape[1]}, "
+            f"hidden_size={self.hidden_size}, "
+            f"nonlinearity={self.nonlinearity}, bias={self.bias is not None}"
+        )
+
+    def __call__(self, x, hidden=None):
+        if self.bias is not None:
+            x = mx.addmm(self.bias, x, self.Wxh.T)
+        else:
+            x = x @ self.Wxh.T
+
+        all_hidden = []
+        for idx in range(x.shape[-2]):
+            if hidden is not None:
+                hidden = mx.addmm(x[..., idx, :], hidden, self.Whh.T)
+            else:
+                hidden = x[..., idx, :]
+            hidden = self.nonlinearity(hidden)
+            all_hidden.append(hidden)
+
+        return mx.stack(all_hidden, axis=-2)
+
+
+class GRU(Module):
+    r"""A gated recurrent unit (GRU) RNN layer.
+
+    The input has shape ``NLD`` or ``LD`` where:
+
+    * ``N`` is the optional batch dimension
+    * ``L`` is the sequence length
+    * ``D`` is the input's feature dimension
+
+    Concretely, for each element of the sequence, this layer computes:
+
+    .. math::
+
+        \begin{aligned}
+        r_t &= \sigma (W_{xr}x_t + W_{hr}h_t + b_{r}) \\
+        z_t &= \sigma (W_{xz}x_t + W_{hz}h_t + b_{z}) \\
+        n_t &= \text{tanh}(W_{xn}x_t + b_{n} + r_t \odot (W_{hn}h_t + b_{hn})) \\
+        h_{t + 1} &= (1 - z_t) \odot n_t + z_t \odot h_t
+        \end{aligned}
+
+    The hidden state :math:`h` has shape ``NH`` or ``H`` depending on
+    whether the input is batched or not. Returns the hidden state at each
+    time step of shape ``NLH`` or ``LH``.
+
+    Args:
+        input_size (int): Dimension of the input, ``D``.
+        hidden_size (int): Dimension of the hidden state, ``H``.
+        bias (bool): Whether to use biases or not. Default: ``True``.
+    """
+
+    def __init__(
+        self,
+        input_size: int,
+        hidden_size: int,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        self.hidden_size = hidden_size
+        scale = 1.0 / math.sqrt(hidden_size)
+        self.Wx = mx.random.uniform(
+            low=-scale, high=scale, shape=(3 * hidden_size, input_size)
+        )
+        self.Wh = mx.random.uniform(
+            low=-scale, high=scale, shape=(3 * hidden_size, hidden_size)
+        )
+        self.b = (
+            mx.random.uniform(low=-scale, high=scale, shape=(3 * hidden_size,))
+            if bias
+            else None
+        )
+        self.bhn = (
+            mx.random.uniform(low=-scale, high=scale, shape=(hidden_size,))
+            if bias
+            else None
+        )
+
+    def _extra_repr(self):
+        return (
+            f"input_dims={self.Wx.shape[1]}, "
+            f"hidden_size={self.hidden_size}, bias={self.b is not None}"
+        )
+
+    def __call__(self, x, hidden=None):
+        if self.b is not None:
+            x = mx.addmm(self.b, x, self.Wx.T)
+        else:
+            x = x @ self.Wx.T
+
+        x_rz = x[..., : -self.hidden_size]
+        x_n = x[..., -self.hidden_size :]
+
+        all_hidden = []
+
+        for idx in range(x.shape[-2]):
+            rz = x_rz[..., idx, :]
+            if hidden is not None:
+                h_proj = hidden @ self.Wh.T
+                h_proj_rz = h_proj[..., : -self.hidden_size]
+                h_proj_n = h_proj[..., -self.hidden_size :]
+
+                if self.bhn is not None:
+                    h_proj_n += self.bhn
+
+                rz = rz + h_proj_rz
+
+            rz = mx.sigmoid(rz)
+
+            r, z = mx.split(rz, 2, axis=-1)
+
+            n = x_n[..., idx, :]
+
+            if hidden is not None:
+                n = n + r * h_proj_n
+            n = mx.tanh(n)
+
+            if hidden is not None:
+                hidden = (1 - z) * n + z * hidden
+            else:
+                hidden = (1 - z) * n
+
+            all_hidden.append(hidden)
+
+        return mx.stack(all_hidden, axis=-2)
+
+
+class LSTM(Module):
+    r"""An LSTM recurrent layer.
+
+    The input has shape ``NLD`` or ``LD`` where:
+
+    * ``N`` is the optional batch dimension
+    * ``L`` is the sequence length
+    * ``D`` is the input's feature dimension
+
+    Concretely, for each element of the sequence, this layer computes:
+
+    .. math::
+        \begin{aligned}
+        i_t &= \sigma (W_{xi}x_t + W_{hi}h_t + b_{i}) \\
+        f_t &= \sigma (W_{xf}x_t + W_{hf}h_t + b_{f}) \\
+        g_t &= \text{tanh} (W_{xg}x_t + W_{hg}h_t + b_{g}) \\
+        o_t &= \sigma (W_{xo}x_t + W_{ho}h_t + b_{o}) \\
+        c_{t + 1} &= f_t \odot c_t + i_t \odot g_t \\
+        h_{t + 1} &= o_t \text{tanh}(c_{t + 1})
+        \end{aligned}
+
+    The hidden state :math:`h` and cell state :math:`c` have shape ``NH``
+    or ``H``, depending on whether the input is batched or not.
+
+    The layer returns two arrays, the hidden state and the cell state at
+    each time step, both of shape ``NLH`` or ``LH``.
+
+    Args:
+        input_size (int): Dimension of the input, ``D``.
+        hidden_size (int): Dimension of the hidden state, ``H``.
+        bias (bool): Whether to use biases or not. Default: ``True``.
+    """
+
+    def __init__(
+        self,
+        input_size: int,
+        hidden_size: int,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        self.hidden_size = hidden_size
+        scale = 1.0 / math.sqrt(hidden_size)
+        self.Wx = mx.random.uniform(
+            low=-scale, high=scale, shape=(4 * hidden_size, input_size)
+        )
+        self.Wh = mx.random.uniform(
+            low=-scale, high=scale, shape=(4 * hidden_size, hidden_size)
+        )
+        self.bias = (
+            mx.random.uniform(low=-scale, high=scale, shape=(4 * hidden_size,))
+            if bias
+            else None
+        )
+
+    def _extra_repr(self):
+        return (
+            f"input_dims={self.Wx.shape[1]}, "
+            f"hidden_size={self.hidden_size}, bias={self.bias is not None}"
+        )
+
+    def __call__(self, x, hidden=None, cell=None):
+        if self.bias is not None:
+            x = mx.addmm(self.bias, x, self.Wx.T)
+        else:
+            x = x @ self.Wx.T
+
+        all_hidden = []
+        all_cell = []
+
+        for idx in range(x.shape[-2]):
+            ifgo = x[..., idx, :]
+            if hidden is not None:
+                ifgo = mx.addmm(ifgo, hidden, self.Wh.T)
+            i, f, g, o = mx.split(ifgo, 4, axis=-1)
+
+            i = mx.sigmoid(i)
+            f = mx.sigmoid(f)
+            g = mx.tanh(g)
+            o = mx.sigmoid(o)
+
+            if cell is not None:
+                cell = f * cell + i * g
+            else:
+                cell = i * g
+            hidden = o * mx.tanh(cell)
+
+            all_cell.append(cell)
+            all_hidden.append(hidden)
+
+        return mx.stack(all_hidden, axis=-2), mx.stack(all_cell, axis=-2)
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/transformer.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/transformer.py
new file mode 100644
index 0000000000000000000000000000000000000000..d856f2554f79a3a746ae1f4ef7e384007ccf3e29
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/transformer.py
@@ -0,0 +1,354 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Any, Callable, Optional
+
+import mlx.core as mx
+from mlx.nn.layers.activations import relu
+from mlx.nn.layers.base import Module
+from mlx.nn.layers.dropout import Dropout
+from mlx.nn.layers.linear import Linear
+from mlx.nn.layers.normalization import LayerNorm
+from mlx.nn.utils import checkpoint
+
+
+class MultiHeadAttention(Module):
+    """Implements the scaled dot product attention with multiple heads.
+
+    Given inputs for queries, keys and values the ``MultiHeadAttention``
+    produces new values by aggregating information from the input values
+    according to the similarities of the input queries and keys.
+
+    All inputs as well as the output are linearly projected without biases by
+    default.
+
+    ``MultiHeadAttention`` also takes an optional additive attention mask that
+    should be broadcastable with ``(batch, num_heads, # queries, # keys)``. The
+    mask should have ``-inf`` or very large negative numbers at the positions
+    that should *not* be attended to.
+
+    Args:
+        dims (int): The model dimensions. This is also the default
+            value for the queries, keys, values, and the output.
+        num_heads (int): The number of attention heads to use.
+        query_input_dims (int, optional): The input dimensions of the queries.
+            Default: ``dims``.
+        key_input_dims (int, optional): The input dimensions of the keys.
+            Default: ``dims``.
+        value_input_dims (int, optional): The input dimensions of the values.
+            Default: ``key_input_dims``.
+        value_dims (int, optional): The dimensions of the values after the
+            projection. Default: ``dims``.
+        value_output_dims (int, optional): The dimensions the new values will
+            be projected to. Default: ``dims``.
+        bias (bool, optional): Whether or not to use a bias in the projections.
+            Default: ``False``.
+    """
+
+    def __init__(
+        self,
+        dims: int,
+        num_heads: int,
+        query_input_dims: Optional[int] = None,
+        key_input_dims: Optional[int] = None,
+        value_input_dims: Optional[int] = None,
+        value_dims: Optional[int] = None,
+        value_output_dims: Optional[int] = None,
+        bias: bool = False,
+    ):
+        super().__init__()
+
+        if (dims % num_heads) != 0:
+            raise ValueError(
+                "The input feature dimensions should be divisible by the "
+                f"number of heads ({dims} % {num_heads}) != 0"
+            )
+
+        query_input_dims = query_input_dims or dims
+        key_input_dims = key_input_dims or dims
+        value_input_dims = value_input_dims or key_input_dims
+        value_dims = value_dims or dims
+        value_output_dims = value_output_dims or dims
+
+        self.num_heads = num_heads
+        self.query_proj = Linear(query_input_dims, dims, bias=bias)
+        self.key_proj = Linear(key_input_dims, dims, bias=bias)
+        self.value_proj = Linear(value_input_dims, value_dims, bias=bias)
+        self.out_proj = Linear(value_dims, value_output_dims, bias=bias)
+
+    def __call__(self, queries, keys, values, mask=None):
+        queries = self.query_proj(queries)
+        keys = self.key_proj(keys)
+        values = self.value_proj(values)
+
+        num_heads = self.num_heads
+        queries = mx.unflatten(queries, -1, (num_heads, -1)).transpose(0, 2, 1, 3)
+        keys = mx.unflatten(keys, -1, (num_heads, -1)).transpose(0, 2, 1, 3)
+        values = mx.unflatten(values, -1, (num_heads, -1)).transpose(0, 2, 1, 3)
+        scale = math.sqrt(1 / queries.shape[-1])
+        output = mx.fast.scaled_dot_product_attention(
+            queries, keys, values, scale=scale, mask=mask
+        )
+        output = output.transpose(0, 2, 1, 3).flatten(-2, -1)
+        return self.out_proj(output)
+
+    @staticmethod
+    def create_additive_causal_mask(N: int, dtype: mx.Dtype = mx.float32):
+        indices = mx.arange(N)
+        mask = indices[:, None] < indices[None]
+        mask = mask.astype(dtype) * mx.finfo(dtype).min
+        return mask
+
+
+class TransformerEncoderLayer(Module):
+    def __init__(
+        self,
+        dims: int,
+        num_heads: int,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation: Callable[[Any], Any] = relu,
+        norm_first: bool = True,
+    ):
+        super().__init__()
+        mlp_dims = mlp_dims or dims * 4
+        self.attention = MultiHeadAttention(dims, num_heads)
+        self.ln1 = LayerNorm(dims)
+        self.ln2 = LayerNorm(dims)
+        self.linear1 = Linear(dims, mlp_dims)
+        self.linear2 = Linear(mlp_dims, dims)
+        self.dropout1 = Dropout(dropout)
+        self.dropout2 = Dropout(dropout)
+        self.activation = activation
+        self.norm_first = norm_first
+
+    def __call__(self, x, mask):
+        if self.norm_first:
+            y = self.ln1(x)
+            y = self.attention(y, y, y, mask)
+            y = self.dropout1(y)
+            x = x + y
+
+            y = self.ln2(x)
+            y = self.linear1(y)
+            y = self.activation(y)
+            y = self.dropout2(y)
+            y = self.linear2(y)
+            y = x + y
+
+        else:
+            y = self.attention(x, x, x, mask)
+            y = self.dropout1(y)
+            x = self.ln1(x + y)
+
+            y = self.linear1(x)
+            y = self.activation(y)
+            y = self.dropout2(y)
+            y = self.linear2(y)
+            y = self.ln2(x + y)
+
+        return y
+
+
+class TransformerEncoder(Module):
+    def __init__(
+        self,
+        num_layers: int,
+        dims: int,
+        num_heads: int,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation=relu,
+        norm_first: bool = True,
+        checkpoint: bool = False,
+    ):
+        super().__init__()
+        self.layers = [
+            TransformerEncoderLayer(
+                dims, num_heads, mlp_dims, dropout, activation, norm_first
+            )
+            for i in range(num_layers)
+        ]
+        self.ln = LayerNorm(dims)
+        self.checkpoint = checkpoint
+
+    def __call__(self, x, mask):
+        for l in self.layers:
+            l = checkpoint(l) if self.checkpoint else l
+            x = l(x, mask)
+        return self.ln(x)
+
+
+class TransformerDecoderLayer(Module):
+    def __init__(
+        self,
+        dims: int,
+        num_heads: int,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation: Callable[[Any], Any] = relu,
+        norm_first: bool = True,
+    ):
+        super().__init__()
+        mlp_dims = mlp_dims or dims * 4
+        self.self_attention = MultiHeadAttention(dims, num_heads)
+        self.cross_attention = MultiHeadAttention(dims, num_heads)
+        self.ln1 = LayerNorm(dims)
+        self.ln2 = LayerNorm(dims)
+        self.ln3 = LayerNorm(dims)
+        self.linear1 = Linear(dims, mlp_dims)
+        self.linear2 = Linear(mlp_dims, dims)
+        self.dropout1 = Dropout(dropout)
+        self.dropout2 = Dropout(dropout)
+        self.dropout3 = Dropout(dropout)
+        self.activation = activation
+        self.norm_first = norm_first
+
+    def __call__(self, x, memory, x_mask, memory_mask):
+        if self.norm_first:
+            y = self.ln1(x)
+            y = self.self_attention(y, y, y, x_mask)
+            y = self.dropout1(y)
+            x = x + y
+
+            y = self.ln2(x)
+            y = self.cross_attention(y, memory, memory, memory_mask)
+            y = self.dropout2(y)
+            x = x + y
+
+            y = self.ln3(x)
+            y = self.linear1(y)
+            y = self.activation(y)
+            y = self.dropout3(y)
+            y = self.linear2(y)
+            y = x + y
+
+        else:
+            y = self.self_attention(x, x, x, x_mask)
+            y = self.dropout1(y)
+            x = self.ln1(x + y)
+
+            y = self.cross_attention(y, memory, memory, memory_mask)
+            y = self.dropout2(y)
+            x = self.ln2(x + y)
+
+            y = self.linear1(x)
+            y = self.activation(y)
+            y = self.dropout3(y)
+            y = self.linear2(y)
+            y = self.ln3(x + y)
+
+        return y
+
+
+class TransformerDecoder(Module):
+    def __init__(
+        self,
+        num_layers: int,
+        dims: int,
+        num_heads: int,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation=relu,
+        norm_first: bool = True,
+        checkpoint: bool = False,
+    ):
+        super().__init__()
+        self.layers = [
+            TransformerDecoderLayer(
+                dims, num_heads, mlp_dims, dropout, activation, norm_first
+            )
+            for i in range(num_layers)
+        ]
+        self.ln = LayerNorm(dims)
+        self.checkpoint = checkpoint
+
+    def __call__(self, x, memory, x_mask, memory_mask):
+        for l in self.layers:
+            l = checkpoint(l) if self.checkpoint else l
+            x = l(x, memory, x_mask, memory_mask)
+        return self.ln(x)
+
+
+class Transformer(Module):
+    """
+    Implements a standard Transformer model.
+
+    The implementation is based on `Attention Is All You Need
+    <https://arxiv.org/abs/1706.03762>`_.
+
+    The Transformer model contains an encoder and a decoder. The encoder
+    processes the input sequence and the decoder generates the output sequence.
+    The interaction between encoder and decoder happens through the attention
+    mechanism.
+
+    Args:
+        dims (int, optional): The number of expected features in the
+            encoder/decoder inputs. Default: ``512``.
+        num_heads (int, optional): The number of attention heads. Default:
+            ``8``.
+        num_encoder_layers (int, optional): The number of encoder layers in the
+            Transformer encoder. Default: ``6``.
+        num_decoder_layers (int, optional): The number of decoder layers in the
+            Transformer decoder. Default: ``6``.
+        mlp_dims (int, optional): The hidden dimension of the MLP block in each
+            Transformer layer. Defaults to ``4*dims`` if not provided. Default:
+            ``None``.
+        dropout (float, optional): The dropout value for the Transformer
+            encoder and decoder. Dropout is used after each attention layer and
+            the activation in the MLP layer. Default: ``0.0``.
+        activation (function, optional): the activation function for the MLP
+            hidden layer. Default: :func:`mlx.nn.relu`.
+        custom_encoder (nn.Module, optional): A custom encoder to replace the
+            standard Transformer encoder. Default: ``None``.
+        custom_decoder (nn.Module, optional): A custom decoder to replace the
+            standard Transformer decoder. Default: ``None``.
+        norm_first (bool, optional): if ``True``, encoder and decoder layers
+            will perform layer normalization before attention and MLP
+            operations, otherwise after. Default: ``True``.
+        checkpoint (bool, optional): if ``True`` perform gradient checkpointing
+            to reduce the memory usage at the expense of more computation.
+            Default: ``False``.
+    """
+
+    def __init__(
+        self,
+        dims: int = 512,
+        num_heads: int = 8,
+        num_encoder_layers: int = 6,
+        num_decoder_layers: int = 6,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation: Callable[[Any], Any] = relu,
+        custom_encoder: Optional[Any] = None,
+        custom_decoder: Optional[Any] = None,
+        norm_first: bool = True,
+        checkpoint: bool = False,
+    ):
+        super().__init__()
+
+        self.encoder = custom_encoder or TransformerEncoder(
+            num_encoder_layers,
+            dims,
+            num_heads,
+            mlp_dims,
+            dropout,
+            activation,
+            norm_first,
+            checkpoint,
+        )
+
+        self.decoder = custom_decoder or TransformerDecoder(
+            num_decoder_layers,
+            dims,
+            num_heads,
+            mlp_dims,
+            dropout,
+            activation,
+            norm_first,
+            checkpoint,
+        )
+
+    def __call__(self, src, tgt, src_mask, tgt_mask, memory_mask):
+        memory = self.encoder(src, src_mask)
+        return self.decoder(tgt, memory, tgt_mask, memory_mask)
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/upsample.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/upsample.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6bd282af1a7f6538d3fb56ef83e48449c97954e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/layers/upsample.py
@@ -0,0 +1,277 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import operator
+from functools import partial, reduce
+from itertools import product
+from typing import Callable, Literal, Tuple, Union
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+def _scaled_indices(N, scale, align_corners, dim, ndims):
+    M = int(scale * N)
+    if align_corners:
+        indices = mx.arange(M, dtype=mx.float32) * ((N - 1) / (M - 1))
+    else:
+        step = 1 / scale
+        start = ((M - 1) * step - N + 1) / 2
+        indices = mx.arange(M, dtype=mx.float32) * step - start
+
+    shape = [1] * ndims
+    shape[dim] = -1
+
+    return indices.reshape(shape)
+
+
+def _nearest_indices(N, scale, dim, ndims):
+    M = int(scale * N)
+    indices = mx.arange(M, dtype=mx.float32)
+    if M > N:
+        indices = (indices + 0.5) * (N / M) - 0.5
+        indices = indices.round()
+    else:
+        indices = indices * (N / M)
+    shape = [1] * ndims
+    shape[dim] = -1
+    return indices.astype(mx.uint32).reshape(shape)
+
+
+def _linear_indices(N, scale, align_corners, dim, ndims):
+    indices = _scaled_indices(N, scale, align_corners, dim, ndims)
+    indices = mx.clip(indices, a_min=0, a_max=N - 1)
+    indices_l = mx.floor(indices)
+    indices_r = mx.ceil(indices)
+    weight = indices - indices_l
+    weight = mx.expand_dims(weight, -1)
+
+    return (
+        (indices_l.astype(mx.uint32), 1 - weight),
+        (indices_r.astype(mx.uint32), weight),
+    )
+
+
+def _cubic_indices(N, scale, align_corners, dim, ndims):
+    indices = _scaled_indices(N, scale, align_corners, dim, ndims)
+    indices_l1 = mx.floor(indices)
+    indices_r1 = mx.floor(indices + 1)
+    indices_l2 = indices_l1 - 1
+    indices_r2 = indices_r1 + 1
+
+    @partial(mx.compile, shapeless=True)
+    def _get_weight(ind, grid, dist):
+        # PyTorch uses -0.5 for antialiasing=true (compatibility with PIL)
+        # and uses -0.75 for antialiasing=false (compatibility with OpenCV)
+        a = -0.75
+        x = mx.abs(ind - grid)
+        if dist == 1:
+            weight = ((a + 2.0) * x - (a + 3.0)) * x * x + 1
+        else:
+            weight = (((x - 5) * x + 8) * x - 4) * a
+        return weight
+
+    weight_l1 = _get_weight(indices, indices_l1, dist=1)[..., None]
+    weight_r1 = _get_weight(indices, indices_r1, dist=1)[..., None]
+    weight_l2 = _get_weight(indices, indices_l2, dist=2)[..., None]
+    weight_r2 = _get_weight(indices, indices_r2, dist=2)[..., None]
+
+    # padding with border value
+    indices_l1 = mx.clip(indices_l1, a_min=0, a_max=N - 1)
+    indices_r1 = mx.clip(indices_r1, a_min=0, a_max=N - 1)
+    indices_l2 = mx.clip(indices_l2, a_min=0, a_max=N - 1)
+    indices_r2 = mx.clip(indices_r2, a_min=0, a_max=N - 1)
+
+    return (
+        (indices_l1.astype(mx.uint32), weight_l1),
+        (indices_r1.astype(mx.uint32), weight_r1),
+        (indices_l2.astype(mx.uint32), weight_l2),
+        (indices_r2.astype(mx.uint32), weight_r2),
+    )
+
+
+def upsample_nearest(x: mx.array, scale_factor: Tuple):
+    dims = x.ndim - 2
+    if dims != len(scale_factor):
+        raise ValueError("A scale needs to be provided for each spatial dimension")
+
+    # Integer scale_factors means we can simply expand-broadcast and reshape
+    if tuple(map(int, scale_factor)) == scale_factor:
+        shape = list(x.shape)
+        for d in range(dims):
+            shape.insert(2 + 2 * d, 1)
+        x = x.reshape(shape)
+        for d in range(dims):
+            shape[2 + 2 * d] = int(scale_factor[d])
+        x = mx.broadcast_to(x, shape)
+        for d in range(dims):
+            shape[d + 1] *= shape[d + 2]
+            shape.pop(d + 2)
+        x = x.reshape(shape)
+        return x
+
+    else:
+        B, *N, C = x.shape
+        indices = [slice(None)]
+        for i, (n, s) in enumerate(zip(N, scale_factor)):
+            indices.append(_nearest_indices(n, s, i, dims))
+        indices = tuple(indices)
+
+        return x[indices]
+
+
+def _interpolate(
+    x: mx.array, scale_factor: Tuple, indices_fn: Callable, align_corners: bool = False
+):
+    dims = x.ndim - 2
+    if dims != len(scale_factor):
+        raise ValueError("A scale needs to be provided for each spatial dimension")
+
+    B, *N, C = x.shape
+
+    # Compute the sampling grid
+    indices = []
+    for i, (n, s) in enumerate(zip(N, scale_factor)):
+        indices.append(indices_fn(n, s, align_corners, i, dims))
+
+    # Sample and compute the weights
+    samples = []
+    weights = []
+    for idx_weight in product(*indices):
+        idx, weight = zip(*idx_weight)
+        samples.append(x[(slice(None),) + idx])
+        weights.append(reduce(operator.mul, weight))
+
+    # Interpolate
+    return sum(wi * xi for wi, xi in zip(weights, samples))
+
+
+def upsample_linear(x: mx.array, scale_factor: Tuple, align_corners: bool = False):
+    return _interpolate(
+        x=x,
+        scale_factor=scale_factor,
+        indices_fn=_linear_indices,
+        align_corners=align_corners,
+    )
+
+
+def upsample_cubic(x: mx.array, scale_factor: Tuple, align_corners: bool = False):
+    return _interpolate(
+        x=x,
+        scale_factor=scale_factor,
+        indices_fn=_cubic_indices,
+        align_corners=align_corners,
+    )
+
+
+class Upsample(Module):
+    r"""Upsample the input signal spatially.
+
+    The spatial dimensions are by convention dimensions ``1`` to ``x.ndim -
+    2``. The first is the batch dimension and the last is the feature
+    dimension.
+
+    For example, an audio signal would be 3D with 1 spatial dimension, an image
+    4D with 2 and so on and so forth.
+
+    There are three upsampling algorithms implemented nearest neighbor upsampling,
+    linear interpolation, and cubic interpolation. All can be applied to any number
+    of spatial dimensions. The linear interpolation will be bilinear, trilinear etc
+    when applied to more than one spatial dimension. And cubic interpolation will be
+    bicubic when there are 2 spatial dimensions.
+
+    .. note::
+       When using one of the linear or cubic interpolation modes the ``align_corners``
+       argument changes how the corners are treated in the input image. If
+       ``align_corners=True`` then the top and left edge of the input and
+       output will be matching as will the bottom right edge.
+
+    Parameters:
+        scale_factor (float or tuple): The multiplier for the spatial size.
+            If a ``float`` is provided, it is the multiplier for all spatial dimensions.
+            Otherwise, the number of scale factors provided must match the
+            number of spatial dimensions.
+        mode (str, optional): The upsampling algorithm, either ``"nearest"``,
+            ``"linear"`` or ``"cubic"``. Default: ``"nearest"``.
+        align_corners (bool, optional): Changes the way the corners are treated
+            during ``"linear"`` and ``"cubic"`` upsampling.  See the note above and the
+            examples below for more details.  Default: ``False``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+        >>> x = mx.arange(1, 5).reshape((1, 2, 2, 1))
+        >>> x
+        array([[[[1],
+                 [2]],
+                [[3],
+                 [4]]]], dtype=int32)
+        >>> n = nn.Upsample(scale_factor=2, mode='nearest')
+        >>> n(x).squeeze()
+        array([[1, 1, 2, 2],
+               [1, 1, 2, 2],
+               [3, 3, 4, 4],
+               [3, 3, 4, 4]], dtype=int32)
+        >>> b = nn.Upsample(scale_factor=2, mode='linear')
+        >>> b(x).squeeze()
+        array([[1, 1.25, 1.75, 2],
+               [1.5, 1.75, 2.25, 2.5],
+               [2.5, 2.75, 3.25, 3.5],
+               [3, 3.25, 3.75, 4]], dtype=float32)
+        >>> b = nn.Upsample(scale_factor=2, mode='linear', align_corners=True)
+        >>> b(x).squeeze()
+        array([[1, 1.33333, 1.66667, 2],
+               [1.66667, 2, 2.33333, 2.66667],
+               [2.33333, 2.66667, 3, 3.33333],
+               [3, 3.33333, 3.66667, 4]], dtype=float32)
+    """
+
+    def __init__(
+        self,
+        scale_factor: Union[float, Tuple],
+        mode: Literal["nearest", "linear", "cubic"] = "nearest",
+        align_corners: bool = False,
+    ):
+        super().__init__()
+        if mode not in ["nearest", "linear", "cubic"]:
+            raise ValueError(f"[Upsample] Got unsupported upsampling algorithm: {mode}")
+        if isinstance(scale_factor, (list, tuple)):
+            self.scale_factor = tuple(map(float, scale_factor))
+        else:
+            self.scale_factor = float(scale_factor)
+        self.mode = mode
+        self.align_corners = align_corners
+
+    def _extra_repr(self) -> str:
+        return (
+            f"scale_factor={self.scale_factor}, mode={self.mode!r}, "
+            f"align_corners={self.align_corners}"
+        )
+
+    def __call__(self, x: mx.array) -> mx.array:
+        dims = x.ndim - 2
+        if dims <= 0:
+            raise ValueError(
+                f"[Upsample] The input should have at least 1 spatial "
+                f"dimension which means it should be at least 3D but "
+                f"{x.ndim}D was provided"
+            )
+
+        scale_factor = self.scale_factor
+        if isinstance(scale_factor, tuple):
+            if len(scale_factor) != dims:
+                raise ValueError(
+                    f"[Upsample] One scale per spatial dimension is required but "
+                    f"scale_factor={scale_factor} and the number of spatial "
+                    f"dimensions were {dims}"
+                )
+        else:
+            scale_factor = (scale_factor,) * dims
+
+        if self.mode == "nearest":
+            return upsample_nearest(x, scale_factor)
+        elif self.mode == "linear":
+            return upsample_linear(x, scale_factor, self.align_corners)
+        elif self.mode == "cubic":
+            return upsample_cubic(x, scale_factor, self.align_corners)
+        else:
+            raise Exception(f"Unknown interpolation mode: {self.mode}")
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/losses.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/losses.py
new file mode 100644
index 0000000000000000000000000000000000000000..b765d25dee091db2dc4663f104288a1c3c3712ec
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/losses.py
@@ -0,0 +1,610 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Literal, Optional, get_args
+
+import mlx.core as mx
+
+Reduction = Literal["none", "mean", "sum"]
+
+
+def _reduce(loss: mx.array, reduction: Reduction = "none"):
+    if reduction not in get_args(Reduction):
+        raise ValueError(f"Invalid reduction. Must be one of {get_args(Reduction)}.")
+
+    if reduction == "mean":
+        return mx.mean(loss)
+    elif reduction == "sum":
+        return mx.sum(loss)
+    elif reduction == "none":
+        return loss
+
+
+def cross_entropy(
+    logits: mx.array,
+    targets: mx.array,
+    weights: Optional[mx.array] = None,
+    axis: int = -1,
+    label_smoothing: float = 0.0,
+    reduction: Reduction = "none",
+) -> mx.array:
+    """
+    Computes the cross entropy loss.
+
+    Args:
+        logits (array): The unnormalized logits.
+        targets (array): The ground truth values. These can be class indices or
+            probabilities for each class. If the ``targets`` are class indices,
+            then ``targets`` shape should match the ``logits`` shape with
+            the ``axis`` dimension removed. If the ``targets`` are probabilities
+            (or one-hot encoded), then the ``targets`` shape should be the same as
+            the ``logits`` shape.
+        weights (array, optional): Optional weights for each target. Default: ``None``.
+        axis (int, optional): The axis over which to compute softmax. Default: ``-1``.
+        label_smoothing (float, optional): Label smoothing factor. Default: ``0``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+            ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed cross entropy loss.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+        >>>
+        >>> # Class indices as targets
+        >>> logits = mx.array([[2.0, -1.0], [-1.0, 2.0]])
+        >>> targets = mx.array([0, 1])
+        >>> nn.losses.cross_entropy(logits, targets)
+        array([0.0485873, 0.0485873], dtype=float32)
+        >>>
+        >>> # Probabilities (or one-hot vectors) as targets
+        >>> logits = mx.array([[2.0, -1.0], [-1.0, 2.0]])
+        >>> targets = mx.array([[0.9, 0.1], [0.1, 0.9]])
+        >>> nn.losses.cross_entropy(logits, targets)
+        array([0.348587, 0.348587], dtype=float32)
+    """
+    if label_smoothing < 0 or label_smoothing >= 1:
+        raise ValueError(f"Label smoothing must in [0, 1), got {label_smoothing}.")
+
+    # Whether targets are class indices or probabilities
+    targets_as_probs = targets.ndim == logits.ndim
+
+    def _drop_dim(shape, axis):
+        shape = list(shape)
+        shape.pop(axis)
+        return tuple(shape)
+
+    # Check shapes in two cases: targets as class indices and targets as probabilities
+    if (targets_as_probs and targets.shape != logits.shape) or (
+        not targets_as_probs and targets.shape != _drop_dim(logits.shape, axis)
+    ):
+        raise ValueError(
+            f"Targets shape {targets.shape} does not match logits shape {logits.shape}."
+        )
+
+    if targets_as_probs:
+        score = mx.sum(logits * targets, axis=axis)
+    else:
+        score = mx.take_along_axis(logits, mx.expand_dims(targets, axis), axis).squeeze(
+            axis
+        )
+
+    logsumexp_logits = mx.logsumexp(logits, axis=axis)
+    if label_smoothing > 0:
+        # Adjust the true class score with label smoothing
+        adjusted_score = (1 - label_smoothing) * score
+
+        # Calculate the mean logit across the classes for smoothed loss
+        mean_logits = logits.mean(axis=axis)
+        smoothed_loss = -mean_logits * label_smoothing
+
+        # Combine the adjusted score and smoothed loss with the logsumexp logits
+        loss = logsumexp_logits - adjusted_score + smoothed_loss
+    else:
+        loss = logsumexp_logits - score
+
+    # Apply weights if provided
+    if weights is not None:
+        if weights.shape != loss.shape:
+            raise ValueError(
+                f"Weights with shape {weights.shape} is not the same as "
+                f"output loss with shape {loss.shape}."
+            )
+        loss *= weights
+
+    # Apply reduction
+    return _reduce(loss, reduction)
+
+
+def binary_cross_entropy(
+    inputs: mx.array,
+    targets: mx.array,
+    weights: Optional[mx.array] = None,
+    with_logits: bool = True,
+    reduction: Reduction = "mean",
+) -> mx.array:
+    """
+    Computes the binary cross entropy loss.
+
+    By default, this function takes the pre-sigmoid logits, which results in a faster
+    and more precise loss. For improved numerical stability when ``with_logits=False``,
+    the loss calculation clips the input probabilities (in log-space) to a minimum value
+    of ``-100``.
+
+    Args:
+        inputs (array): The predicted values. If ``with_logits`` is ``True``, then
+            ``inputs`` are unnormalized logits. Otherwise, ``inputs`` are probabilities.
+        targets (array): The binary target values in {0, 1}.
+        with_logits (bool, optional): Whether ``inputs`` are logits. Default: ``True``.
+        weights (array, optional): Optional weights for each target. Default: ``None``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``.
+
+    Returns:
+        array: The computed binary cross entropy loss.
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+
+        >>> logits = mx.array([0.105361, 0.223144, 1.20397, 0.916291])
+        >>> targets = mx.array([0, 0, 1, 1])
+        >>> loss = nn.losses.binary_cross_entropy(logits, targets, reduction="mean")
+        >>> loss
+        array(0.539245, dtype=float32)
+
+        >>> probs = mx.array([0.1, 0.1, 0.4, 0.4])
+        >>> targets = mx.array([0, 0, 1, 1])
+        >>> loss = nn.losses.binary_cross_entropy(probs, targets, with_logits=False, reduction="mean")
+        >>> loss
+        array(0.510826, dtype=float32)
+    """
+    if inputs.shape != targets.shape:
+        raise ValueError(
+            f"Inputs shape {inputs.shape} does not match targets shape {targets.shape}."
+        )
+
+    if with_logits:
+        loss = mx.logaddexp(0.0, inputs) - inputs * targets
+    else:
+        log_inputs_clip = mx.clip(mx.log(inputs), a_min=-100, a_max=None)
+        log_inputs_inv_clip = mx.clip(mx.log(1 - inputs), a_min=-100, a_max=None)
+        loss = -(targets * log_inputs_clip + (1 - targets) * log_inputs_inv_clip)
+
+    # Apply weights if provided
+    if weights is not None:
+        if weights.shape != loss.shape:
+            raise ValueError(
+                f"Weights with shape {weights.shape} is not the same as "
+                f"output loss with shape {loss.shape}."
+            )
+        loss *= weights
+
+    return _reduce(loss, reduction)
+
+
+def l1_loss(
+    predictions: mx.array, targets: mx.array, reduction: Reduction = "mean"
+) -> mx.array:
+    """
+    Computes the L1 loss.
+
+    Args:
+        predictions (array): The predicted values.
+        targets (array): The target values.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``.
+
+    Returns:
+        array: The computed L1 loss.
+    """
+    if predictions.shape != targets.shape:
+        raise ValueError(
+            f"Predictions shape {predictions.shape} does not match "
+            f"targets shape {targets.shape}."
+        )
+    loss = mx.abs(predictions - targets)
+
+    return _reduce(loss, reduction)
+
+
+def mse_loss(
+    predictions: mx.array, targets: mx.array, reduction: Reduction = "mean"
+) -> mx.array:
+    """
+    Computes the mean squared error loss.
+
+    Args:
+        predictions (array): The predicted values.
+        targets (array): The target values.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``.
+
+    Returns:
+        array: The computed mean squared error loss.
+    """
+    if predictions.shape != targets.shape:
+        raise ValueError(
+            f"Predictions shape {predictions.shape} does not match "
+            f"targets shape {targets.shape}."
+        )
+
+    loss = mx.square(predictions - targets)
+    return _reduce(loss, reduction)
+
+
+def nll_loss(
+    inputs: mx.array, targets: mx.array, axis: int = -1, reduction: Reduction = "none"
+) -> mx.array:
+    """
+    Computes the negative log likelihood loss.
+
+    Args:
+        inputs (array): The predicted distribution in log space.
+        targets (array): The target values.
+        axis (int, optional): The distribution axis. Default: ``-1``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed NLL loss.
+    """
+    loss = -mx.take_along_axis(inputs, targets[..., None], axis).squeeze(-1)
+
+    return _reduce(loss, reduction)
+
+
+def gaussian_nll_loss(
+    inputs: mx.array,
+    targets: mx.array,
+    vars: mx.array,
+    full: bool = False,
+    eps: float = 1e-6,
+    reduction: Reduction = "mean",
+) -> mx.array:
+    r"""
+    Computes the negative log likelihood loss for a Gaussian distribution.
+
+    The loss is given by:
+
+    .. math::
+        \frac{1}{2}\left(\log\left(\max\left(\text{vars},
+        \ \epsilon\right)\right) + \frac{\left(\text{inputs} - \text{targets} \right)^2}
+        {\max\left(\text{vars}, \ \epsilon \right)}\right) + \text{const.}
+
+    where ``inputs`` are the predicted means and ``vars`` are the the
+    predicted variances.
+
+    Args:
+        inputs (array): The predicted expectation of the Gaussian distribution.
+        targets (array): The target values (samples from the Gaussian distribution).
+        vars (array): The predicted variance of the Gaussian distribution.
+        full (bool, optional): Whether to include the constant term in the loss calculation.
+            Default: ``False``.
+        eps (float, optional): Small positive constant for numerical stability.
+            Default: ``1e-6``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The Gaussian NLL loss.
+    """
+    if inputs.shape != targets.shape:
+        raise ValueError(
+            f"Inputs shape {inputs.shape} does not match targets shape {targets.shape}."
+        )
+
+    if inputs.shape != vars.shape:
+        raise ValueError(
+            f"Inputs shape {inputs.shape} does not match vars shape {vars.shape}."
+        )
+
+    # For stability
+    vars = mx.maximum(vars, eps)
+    loss = 0.5 * (mx.log(vars) + mx.square(targets - inputs) / vars)
+
+    if full:
+        loss += 0.5 * math.log(2 * math.pi)
+
+    return _reduce(loss, reduction)
+
+
+def kl_div_loss(
+    inputs: mx.array, targets: mx.array, axis: int = -1, reduction: Reduction = "none"
+) -> mx.array:
+    """
+    Computes the Kullback-Leibler divergence loss.
+
+    Computes the following when ``reduction == 'none'``:
+
+    .. code-block:: python
+
+        mx.exp(targets) * (targets - inputs).sum(axis)
+
+    Args:
+        inputs (array): Log probabilities for the predicted distribution.
+        targets (array): Log probabilities for the target distribution.
+        axis (int, optional): The distribution axis. Default: ``-1``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed Kullback-Leibler divergence loss.
+    """
+    loss = mx.sum(mx.exp(targets) * (targets - inputs), axis)
+
+    return _reduce(loss, reduction)
+
+
+def smooth_l1_loss(
+    predictions: mx.array,
+    targets: mx.array,
+    beta: float = 1.0,
+    reduction: Reduction = "mean",
+) -> mx.array:
+    r"""
+    Computes the smooth L1 loss.
+
+    The smooth L1 loss is a variant of the L1 loss which replaces the absolute
+    difference with a squared difference when the absolute difference is less
+    than ``beta``.
+
+    The formula for the smooth L1 Loss is:
+
+    .. math::
+
+      l = \begin{cases}
+            0.5 (x - y)^2 / \beta, & \text{if } |x - y| < \beta \\
+            |x - y| - 0.5 \beta, & \text{otherwise}
+          \end{cases}
+
+    Args:
+        predictions (array): Predicted values.
+        targets (array): Ground truth values.
+        beta (float, optional): The threshold after which the loss changes
+          from the squared to the absolute difference. Default: ``1.0``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``.
+
+    Returns:
+        array: The computed smooth L1 loss.
+    """
+    if predictions.shape != targets.shape:
+        raise ValueError(
+            f"Predictions shape {predictions.shape} does not match "
+            f"targets shape {targets.shape}."
+        )
+
+    diff = mx.abs(predictions - targets)
+    loss = mx.where(
+        diff < beta, 0.5 * mx.square(diff) / beta, mx.abs(diff) - 0.5 * beta
+    )
+
+    return _reduce(loss, reduction)
+
+
+def triplet_loss(
+    anchors: mx.array,
+    positives: mx.array,
+    negatives: mx.array,
+    axis: int = -1,
+    p: int = 2,
+    margin: float = 1.0,
+    eps: float = 1e-6,
+    reduction: Reduction = "none",
+) -> mx.array:
+    r"""
+    Computes the triplet loss for a set of anchor, positive, and negative samples.
+    Margin is represented with alpha in the math section.
+
+    .. math::
+
+       \max\left(\|A - P\|_p - \|A - N\|_p + \alpha, 0\right)
+
+    Args:
+        anchors (array): The anchor samples.
+        positives (array): The positive samples.
+        negatives (array): The negative samples.
+        axis (int, optional): The distribution axis. Default: ``-1``.
+        p (int, optional): The norm degree for pairwise distance. Default: ``2``.
+        margin (float, optional): Margin for the triplet loss. Defaults to ``1.0``.
+        eps (float, optional): Small positive constant to prevent numerical instability. Defaults to ``1e-6``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: Computed triplet loss. If reduction is "none", returns a tensor of the same shape as input;
+                  if reduction is "mean" or "sum", returns a scalar tensor.
+    """
+    loss = mx.maximum(
+        mx.sqrt(mx.power(anchors - positives, p).sum(axis) + eps)
+        - mx.sqrt(mx.power(anchors - negatives, p).sum(axis) + eps)
+        + margin,
+        0,
+    )
+    return _reduce(loss, reduction)
+
+
+def hinge_loss(
+    inputs: mx.array, targets: mx.array, reduction: Reduction = "none"
+) -> mx.array:
+    r"""
+    Computes the hinge loss between inputs and targets.
+
+    .. math::
+
+       \text{hinge}(y, y_{\text{pred}}) = \max(0, 1 - y \cdot y_{\text{pred}})
+
+
+    Args:
+        inputs (array): The predicted values.
+        targets (array): The target values. They should be -1 or 1.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed hinge loss.
+    """
+    loss = mx.maximum(1 - inputs * targets, 0)
+
+    return _reduce(loss, reduction)
+
+
+def huber_loss(
+    inputs: mx.array,
+    targets: mx.array,
+    delta: float = 1.0,
+    reduction: Reduction = "none",
+) -> mx.array:
+    r"""
+    Computes the Huber loss between inputs and targets.
+
+    .. math::
+
+        l_{\delta}(a) =
+        \left\{ \begin{array}{ll}
+            \frac{1}{2} a^2 & \text{for } |a| \leq \delta, \\
+            \delta \left( |a| - \frac{1}{2} \delta \right) & \text{otherwise.}
+        \end{array} \right.
+
+    Args:
+        inputs (array): The predicted values.
+        targets (array): The target values.
+        delta (float, optional): The threshold at which to change between L1 and L2 loss.
+          Default: ``1.0``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed Huber loss.
+    """
+    errors = inputs - targets
+    abs_errors = mx.abs(errors)
+    quadratic = mx.minimum(abs_errors, delta)
+    linear = abs_errors - quadratic
+    loss = 0.5 * quadratic**2 + delta * linear
+
+    return _reduce(loss, reduction)
+
+
+def log_cosh_loss(
+    inputs: mx.array, targets: mx.array, reduction: Reduction = "none"
+) -> mx.array:
+    r"""
+    Computes the log cosh loss between inputs and targets.
+
+    Logcosh acts like L2 loss for small errors, ensuring stable gradients,
+    and like the L1 loss for large errors, reducing sensitivity to outliers. This
+    dual behavior offers a balanced, robust approach for regression tasks.
+
+    .. math::
+
+       \text{logcosh}(y_{\text{true}}, y_{\text{pred}}) =
+            \frac{1}{n} \sum_{i=1}^{n}
+            \log(\cosh(y_{\text{pred}}^{(i)} - y_{\text{true}}^{(i)}))
+
+
+    Args:
+        inputs (array): The predicted values.
+        targets (array): The target values.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed log cosh loss.
+    """
+    errors = inputs - targets
+    loss = mx.logaddexp(errors, -errors) - math.log(2)
+
+    return _reduce(loss, reduction)
+
+
+def cosine_similarity_loss(
+    x1: mx.array,
+    x2: mx.array,
+    axis: int = 1,
+    eps: float = 1e-8,
+    reduction: Reduction = "none",
+) -> mx.array:
+    r"""
+    Computes the cosine similarity between the two inputs.
+
+    The cosine similarity loss is given by
+
+    .. math::
+
+        \frac{x_1 \cdot x_2}{\max(\|x_1\|  \cdot \|x_2\|, \epsilon)}
+
+    Args:
+        x1 (mx.array): The first set of inputs.
+        x2 (mx.array): The second set of inputs.
+        axis (int, optional): The embedding axis. Default: ``1``.
+        eps (float, optional): The minimum value of the denominator used for
+          numerical stability. Default: ``1e-8``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        mx.array: The computed cosine similarity loss.
+    """
+    x1_norm = mx.linalg.norm(x1, axis=axis)
+    x2_norm = mx.linalg.norm(x2, axis=axis)
+
+    loss = mx.sum(x1 * x2, axis=axis) / mx.maximum(x1_norm * x2_norm, eps)
+
+    return _reduce(loss, reduction)
+
+
+def margin_ranking_loss(
+    inputs1: mx.array,
+    inputs2: mx.array,
+    targets: mx.array,
+    margin: float = 0.0,
+    reduction: Reduction = "none",
+) -> mx.array:
+    r"""
+    Calculate the margin ranking loss that loss given inputs :math:`x_1`, :math:`x_2` and a label
+    :math:`y` (containing 1 or -1).
+
+    The loss is given by:
+
+    .. math::
+        \text{loss} = \max (0, -y * (x_1 - x_2) + \text{margin})
+
+    Where :math:`y` represents ``targets``, :math:`x_1` represents ``inputs1`` and :math:`x_2`
+    represents ``inputs2``.
+
+    Args:
+        inputs1 (array): Scores for the first input.
+        inputs2 (array): Scores for the second input.
+        targets (array): Labels indicating whether samples in ``inputs1`` should be ranked higher
+            than samples in ``inputs2``. Values should be 1 or -1.
+        margin (float, optional): The margin by which the scores should be separated.
+            Default: ``0.0``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+            ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed margin ranking loss.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+        >>> targets = mx.array([1, 1, -1])
+        >>> inputs1 = mx.array([-0.573409, -0.765166, -0.0638])
+        >>> inputs2 = mx.array([0.75596, 0.225763, 0.256995])
+        >>> loss = nn.losses.margin_ranking_loss(inputs1, inputs2, targets)
+        >>> loss
+        array(0.773433, dtype=float32)
+    """
+    if not (inputs1.shape == inputs2.shape == targets.shape):
+        raise ValueError(
+            f"The shapes of the arguments do not match. The provided shapes are "
+            f"inputs1.shape={inputs1.shape}, inputs2.shape={inputs2.shape}, and "
+            f"targets.shape={targets.shape}."
+        )
+
+    differences = inputs1 - inputs2
+    loss = mx.maximum(0, -targets * differences + margin)
+
+    return _reduce(loss, reduction)
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/utils.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..97354d112aae73ae9966eb31d6882b454e6803f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/nn/utils.py
@@ -0,0 +1,165 @@
+# Copyright © 2023-2024 Apple Inc.
+
+from functools import reduce, wraps
+from typing import Any, Callable, Optional
+
+import mlx.core as mx
+
+from ..utils import tree_flatten, tree_map, tree_unflatten
+from .layers.base import Module
+
+
+def value_and_grad(model: Module, fn: Callable):
+    """Transform the passed function ``fn`` to a function that computes the
+    gradients of ``fn`` wrt the model's trainable parameters and also its
+    value.
+
+    Args:
+        model (mlx.nn.Module): The model whose trainable parameters to compute
+                               gradients for
+        fn (Callable): The scalar function to compute gradients for
+
+    Returns:
+        A callable that returns the value of ``fn`` and the gradients wrt the
+        trainable parameters of ``model``
+    """
+
+    def inner_fn(params, *args, **kwargs):
+        model.update(params)
+        return fn(*args, **kwargs)
+
+    value_grad_fn = mx.value_and_grad(inner_fn)
+
+    @wraps(fn)
+    def wrapped_value_grad_fn(*args, **kwargs):
+        value, grad = value_grad_fn(model.trainable_parameters(), *args, **kwargs)
+        return value, grad
+
+    return wrapped_value_grad_fn
+
+
+def checkpoint(module: Module, fn: Optional[Callable] = None):
+    """Transform the passed callable to one that performs gradient
+    checkpointing with respect to the trainable parameters of the module (and
+    the callable's inputs).
+
+    Args:
+        module (mlx.nn.Module): The module for whose parameters we will be
+            performing gradient checkpointing.
+        fn (Callable, optional): The function to checkpoint. If not provided it
+            defaults to the provided module.
+
+    Returns:
+        A callable that saves the inputs and outputs during the forward pass
+        and recomputes all intermediate states during the backward pass.
+    """
+    if fn is None:
+        # Capturing module instead of module.__call__ allows someone to
+        # monkey-patch __call__ later on and the correct method will be used
+        fn = module
+
+    def inner_fn(params, *args, **kwargs):
+        module.update(params)
+        return fn(*args, **kwargs)
+
+    checkpointed_fn = mx.checkpoint(inner_fn)
+
+    @wraps(fn)
+    def wrapped_checkpointed_fn(*args, **kwargs):
+        return checkpointed_fn(module.trainable_parameters(), *args, **kwargs)
+
+    return wrapped_checkpointed_fn
+
+
+def average_gradients(
+    gradients: Any,
+    group: Optional[mx.distributed.Group] = None,
+    all_reduce_size: int = 32 * 1024**2,
+    communication_type: Optional[mx.Dtype] = None,
+    communication_stream: Optional[mx.Stream] = None,
+):
+    """Average the gradients across the distributed processes in the passed group.
+
+    This helper enables concatenating several gradients of small arrays to one
+    big all reduce call for better networking performance.
+
+    Args:
+        gradients (Any): The Python tree containing the gradients (it should
+            have the same structure across processes)
+        group (Optional[mlx.core.distributed.Group]): The group of processes to
+            average the gradients. If set to ``None`` the global group is used.
+            Default: ``None``.
+        all_reduce_size (int): Group arrays until their size in bytes exceeds
+            this number. Perform one communication step per group of arrays. If
+            less or equal to 0 array grouping is disabled. Default: ``32MiB``.
+        communication_type (Optional[mlx.core.Dtype]): If provided cast to this
+            type before performing the communication. Typically cast to a
+            smaller float to reduce the communication size. Default: ``None``.
+        communication_stream (Optional[mlx.core.Stream]): The stream to usse
+            for the communication. If unspecified the default communication
+            stream is used which can vary by back-end. Default: ``None``.
+    """
+    group = group or mx.distributed.init()
+    N = group.size()
+
+    if N == 1:
+        return gradients
+
+    def _average(x):
+        dt = x.dtype
+        x = x.astype(communication_type) if communication_type is not None else x
+        return mx.distributed.all_sum(x, stream=communication_stream).astype(dt) / N
+
+    if all_reduce_size <= 0:
+        return tree_map(_average, gradients)
+
+    else:
+        flat_grads = tree_flatten(gradients)
+        if len(flat_grads) == 0:
+            return gradients
+
+        # Extract some info for the gradient
+        keys = [k for k, _ in flat_grads]
+        shapes = [v.shape for _, v in flat_grads]
+        sizes = [v.size for _, v in flat_grads]
+        dtypes = [v.dtype for _, v in flat_grads]
+
+        # We can't group them if they have mixed types
+        if not all(dt == dtypes[0] for dt in dtypes):
+            return average_gradients(gradients, group, 0, communication_type)
+        itemsize = (
+            communication_type.size
+            if communication_type is not None
+            else dtypes[0].size
+        )
+
+        # Gather the gradients in groups that are just above or equal to all_reduce_size
+        grad_groups = []
+        grad_group = []
+        grad_group_size = 0
+        for i in range(len(keys)):
+            grad_group.append(i)
+            grad_group_size += sizes[i] * itemsize
+            if grad_group_size >= all_reduce_size:
+                grad_groups.append(grad_group)
+                grad_group = []
+                grad_group_size = 0
+        if grad_group:
+            grad_groups.append(grad_group)
+            grad_group = []
+
+        # Concatenate-reduce-split
+        new_flat_grads = []
+        for grad_group in grad_groups:
+            indices = reduce(lambda x, y: x + [x[-1] + sizes[y]], grad_group, [0])
+            big_grad = mx.concatenate(
+                [flat_grads[i][1].reshape(-1) for i in grad_group]
+            )
+            big_grad = _average(big_grad)
+            big_grad = mx.split(big_grad, indices[1:-1])
+            new_flat_grads.extend(
+                (keys[j], big_grad[i].reshape(shapes[j]))
+                for i, j in enumerate(grad_group)
+            )
+
+        return tree_unflatten(new_flat_grads)
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/optimizers/__init__.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/optimizers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e8e0ccd4539ea497c65303bed1a29730c54782f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/optimizers/__init__.py
@@ -0,0 +1,4 @@
+# Copyright © 2023-2024 Apple Inc.
+
+from mlx.optimizers.optimizers import *
+from mlx.optimizers.schedulers import *
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/optimizers/optimizers.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/optimizers/optimizers.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cc9e26b1700d89fc579115b458c2a992433ce03
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/optimizers/optimizers.py
@@ -0,0 +1,976 @@
+# Copyright © 2023-2024 Apple Inc.
+
+from typing import Callable, List, Optional, Tuple, Union
+
+import mlx.core as mx
+from mlx.nn import Module
+from mlx.utils import tree_flatten, tree_map, tree_merge, tree_reduce, tree_unflatten
+
+
+class Optimizer:
+    """The base class for all optimizers. It allows us to implement an
+    optimizer on a per-parameter basis and apply it to a parameter tree.
+    """
+
+    def __init__(self, schedulers=None):
+        self._initialized = False
+        self._state = {"step": mx.array(0, mx.uint64)}
+        self._schedulers = {k: v for k, v in (schedulers or {}).items()}
+
+    def update(self, model: Module, gradients: dict):
+        """Apply the gradients to the parameters of the model and update the
+        model with the new parameters.
+
+        Args:
+            model (mlx.nn.Module): An mlx module to be updated.
+            gradients (dict): A Python tree of gradients, most likely computed
+                              via :func:`mlx.nn.value_and_grad`.
+        """
+        model.update(self.apply_gradients(gradients, model))
+
+    def init(self, parameters: dict):
+        """Initialize the optimizer's state
+
+        This function can be used to initialize optimizers which have state
+        (like momentum in :class:`SGD`). Using this method is optional as the
+        optimizer will initialize itself if the state is not yet set. However,
+        there are some cases where explicit initialization is useful in order
+        to have access to the :attr:`Optimizer.state` before the first call to
+        :meth:`Optimizer.update`.
+
+        Args:
+            model (dict): A Python tree of parameters.
+
+        Example:
+            >>> optimizer = optim.SGD(learning_rate=1e-1, momentum=0.9)
+            >>> model = nn.Linear(2, 2)
+            >>> optimizer.init(model.trainable_parameters())
+            >>> optimizer.state.keys()
+            dict_keys(['step', 'learning_rate', 'weight', 'bias'])
+        """
+
+        # Initialize the optimizer state to match the parameter state
+        def update_state(params, state):
+            if isinstance(params, (list, tuple)):
+                state = list(state)
+                for i in range(len(state)):
+                    state[i] = update_state(params[i], state[i])
+                if len(state) != len(params):
+                    state.extend(tree_map(lambda _: {}, params[len(state) :]))
+                return type(params)(state)
+            elif isinstance(params, dict):
+                for k, v in params.items():
+                    if k not in state:
+                        state[k] = tree_map(lambda _: {}, v)
+                    else:
+                        state[k] = update_state(v, state[k])
+                return state
+            else:
+                return state
+
+        update_state(parameters, self._state)
+        tree_map(lambda p, s: s or self.init_single(p, s), parameters, self._state)
+        self._initialized = True
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """To be extended by the children classes to implement each optimizer's
+        state initialization.
+
+        Args:
+            parameter (mx.array): A single parameter that will be optimized.
+            state (dict): The optimizer's state.
+        """
+        raise NotImplementedError()
+
+    def apply_gradients(self, gradients: dict, parameters: dict):
+        """Apply the gradients to the parameters and return the updated parameters.
+
+        Can be used to update a model via
+        ``model.update(opt.apply_gradients(grads, model))`` which is precisely
+        how :meth:`Optimizer.update` is implemented.
+
+        Args:
+            gradients (dict): A Python tree of gradients.
+            parameters (dict): A Python tree of parameters. It can be a
+              superset of the gradients. In that case the returned python
+              tree will be of the same structure as the gradients.
+        """
+        if not self._initialized:
+            self.init(gradients)
+
+        # Update any scheduled variables
+        for param, scheduler in self._schedulers.items():
+            self.state[param] = scheduler(self.step)
+
+        # Increment the step
+        self.state["step"] = self.step + 1
+
+        # Apply the update
+        return tree_map(self.apply_single, gradients, parameters, self.state)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """To be extended by derived classes to implement the optimizer's update.
+
+        Args:
+            gradient (mx.array): The ``parameter`` gradient.
+            parameter (mx.array): The ``parameter`` to update.
+            state (dict): The optimizer's state.
+        """
+        raise NotImplementedError()
+
+    @property
+    def state(self):
+        """The optimizer's state dictionary."""
+        return self._state
+
+    @state.setter
+    def state(self, state: dict):
+        self._initialized = False
+        self._state = state
+
+    @property
+    def step(self):
+        return self.state["step"]
+
+    @property
+    def learning_rate(self):
+        return self.state["learning_rate"]
+
+    @learning_rate.setter
+    def learning_rate(self, learning_rate: Union[float, mx.array]):
+        self.state["learning_rate"] = mx.array(learning_rate)
+
+    def _maybe_schedule(
+        self, name: str, param: Union[float, Callable[[mx.array], mx.array]]
+    ):
+        """
+        To be used by derived classes to optionally put a parameter on a schedule.
+        """
+        if isinstance(param, Callable):
+            self._schedulers[name] = param
+            parameter = param(self.step)
+        else:
+            parameter = mx.array(param)
+        self.state[name] = parameter
+
+
+class MultiOptimizer(Optimizer):
+    """Wraps a list of optimizers with corresponding weight predicates/filters
+    to make it easy to use different optimizers for different weights.
+
+    The predicates take the full "path" of the weight and the weight itself and
+    return True if it should be considered for this optimizer. The last
+    optimizer in the list is a fallback optimizer and no predicate should be
+    given for it.
+
+    Args:
+        optimizers (list[Optimizer]): A list of optimizers to delegate to
+        filters (list[Callable[[str, array], bool]): A list of predicates that
+            should be one less than the provided optimizers.
+    """
+
+    def __init__(self, optimizers, filters: list = []):
+        super().__init__()
+        self._state = {}
+
+        if len(filters) != len(optimizers) - 1:
+            raise ValueError(
+                f"Given {len(filters)} filters but {len(optimizers)-1} needed."
+            )
+
+        self.optimizers = optimizers
+        self.filters = filters + [lambda *args, **kwargs: True]
+
+    def _split_dictionary(self, gradients: dict):
+        if len(self.optimizers) == 1:
+            return [gradients]
+
+        parts = [[] for _ in range(len(self.optimizers))]
+        flat_gradients = tree_flatten(gradients)
+        for k, g in flat_gradients:
+            for i, fn in enumerate(self.filters):
+                if fn(k, g):
+                    parts[i].append((k, g))
+                    break
+
+        return [tree_unflatten(p) for p in parts]
+
+    def init(self, parameters: dict):
+        for o, p in zip(self.optimizers, self._split_dictionary(parameters)):
+            o.init(p)
+
+    def apply_gradients(self, gradients: dict, parameters: dict):
+        tree = {}
+        for o, g in zip(self.optimizers, self._split_dictionary(gradients)):
+            tree = tree_merge(tree, o.apply_gradients(g, parameters))
+        return tree
+
+    @property
+    def state(self):
+        return {"states": [o.state for o in self.optimizers]}
+
+    @state.setter
+    def state(self, state: dict):
+        if "states" not in state or len(state["states"]) != len(self.optimizers):
+            raise ValueError("Invalid state provided")
+
+        for o, s in zip(self.optimizers, state["states"]):
+            o.state = s
+
+    @property
+    def learning_rate(self):
+        return self.optimizers[0].learning_rate
+
+    @learning_rate.setter
+    def learning_rate(self, learning_rate: Union[float, mx.array]):
+        for o in self.optimizers:
+            o.learning_rate = learning_rate
+
+
+class SGD(Optimizer):
+    r"""The stochastic gradient descent optimizer.
+
+    Updates a parameter :math:`w` with a gradient :math:`g` as follows
+
+    .. math::
+
+        v_{t+1} &= \mu v_t + (1 - \tau) g_t \\
+        w_{t+1} &= w_t - \lambda v_{t+1}
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\lambda`.
+        momentum (float, optional): The momentum strength :math:`\mu`. Default: ``0``
+        weight_decay (float, optional): The weight decay (L2 penalty). Default: ``0``
+        dampening (float, optional): Dampening for momentum :math:`\tau`. Default: ``0``
+        nesterov (bool, optional): Enables Nesterov momentum. Default: ``False``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        momentum: float = 0.0,
+        weight_decay: float = 0.0,
+        dampening: float = 0.0,
+        nesterov: bool = False,
+    ):
+        if nesterov and (momentum <= 0 or dampening != 0):
+            raise ValueError(
+                "Nesterov momentum requires a momentum and zero dampening."
+            )
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.momentum = momentum
+        self.weight_decay = weight_decay
+        self.dampening = dampening
+        self.nesterov = nesterov
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["v"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the SGD parameter update and stores :math:`v` in the
+        optimizer state."""
+
+        if self.weight_decay != 0:
+            gradient += self.weight_decay * parameter
+
+        if self.momentum <= 0:
+            return parameter - self.learning_rate.astype(gradient.dtype) * gradient
+
+        v = self.momentum * state.get("v")
+        if self.dampening > 0:
+            v += (1 - self.dampening) * gradient
+        else:
+            v += gradient
+
+        if self.nesterov:
+            update = gradient + self.momentum * v
+        else:
+            update = v
+
+        state["v"] = v
+        return parameter - self.learning_rate.astype(gradient.dtype) * update
+
+
+class RMSprop(Optimizer):
+    r"""The RMSprop optimizer [1].
+
+    [1]: Tieleman, T. and Hinton, G. 2012. Lecture 6.5-rmsprop, coursera: Neural networks for machine learning
+
+    .. math::
+
+        v_{t+1} &= \alpha v_t + (1 - \alpha) g_t^2 \\
+        w_{t+1} &= w_t - \lambda \frac{g_t}{\sqrt{v_{t+1}} + \epsilon}
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\lambda`.
+        alpha (float, optional): The smoothing constant :math:`\alpha`.
+          Default: ``0.99``
+        eps (float, optional): The term :math:`\epsilon` added to the denominator
+          to improve numerical stability. Default: ``1e-8``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        alpha: float = 0.99,
+        eps: float = 1e-8,
+    ):
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.alpha = alpha
+        self.eps = eps
+
+        if self.alpha < 0.0:
+            raise ValueError(
+                f"RMSprop alpha should be >=0, {self.alpha} was provided instead"
+            )
+        if self.eps < 0.0:
+            raise ValueError(
+                f"RMSprop epsilon should be >0, {self.eps} was provided instead"
+            )
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["v"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the RMSprop parameter update and stores :math:`v` in the optimizer state."""
+        lr = self.learning_rate.astype(gradient.dtype)
+        alpha = self.alpha
+        eps = self.eps
+
+        v = state["v"]
+        v = alpha * v + (1 - alpha) * mx.square(gradient)
+        state["v"] = v
+
+        return parameter - lr * gradient / (mx.sqrt(v) + eps)
+
+
+class Adagrad(Optimizer):
+    r"""The Adagrad optimizer [1].
+
+    Our Adagrad implementation follows the original paper. In detail,
+
+    [1]: Duchi, J., Hazan, E. and Singer, Y., 2011. Adaptive subgradient methods
+    for online learning and stochastic optimization. JMLR 2011.
+
+    .. math::
+
+        v_{t+1} &= v_t + g_t^2 \\
+        w_{t+1} &= w_t - \lambda \frac{g_t}{\sqrt{v_{t+1}} + \epsilon}
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\lambda`.
+        eps (float, optional): The term :math:`\epsilon` added to the
+          denominator to improve numerical stability. Default: ``1e-8``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        eps: float = 1e-8,
+    ):
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.eps = eps
+
+        if self.eps < 0.0:
+            raise ValueError(
+                f"Adagrad epsilon should be >0, {self.eps} was provided instead"
+            )
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["v"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the Adagrad parameter update and stores :math:`v` in the
+        optimizer state."""
+        lr = self.learning_rate.astype(gradient.dtype)
+        eps = self.eps
+
+        v = state["v"] + mx.square(gradient)
+        state["v"] = v
+
+        return parameter - lr * gradient / (mx.sqrt(v) + eps)
+
+
+class AdaDelta(Optimizer):
+    r"""The AdaDelta optimizer with a learning rate [1].
+
+    Our AdaDelta implementation follows the original paper. In detail,
+
+    [1]: Zeiler, M.D., 2012. ADADELTA: an adaptive learning rate method. arXiv preprint arXiv:1212.5701.
+
+    .. math::
+
+        v_{t+1} &= \rho v_t + (1 - \rho) g_t^2 \\
+        \Delta w_{t+1} &= \frac{\sqrt{u_t + \epsilon}}{\sqrt{v_{t+1} + \epsilon}} g_t \\
+        u_{t+1} &= \rho u_t + (1 - \rho) \Delta w_{t+1}^2 \\
+        w_{t+1} &= w_t - \lambda \Delta w_{t+1}
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\lambda`.
+        rho (float, optional): The coefficient :math:`\rho` used for computing a
+            running average of squared gradients. Default: ``0.9``
+        eps (float, optional): The term :math:`\epsilon` added to the denominator to improve
+          numerical stability. Default: `1e-8`
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        rho: float = 0.9,
+        eps: float = 1e-6,
+    ):
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.rho = rho
+        self.eps = eps
+        if self.rho < 0.0:
+            raise ValueError(
+                f"AdaDelta rho should be >=0, {self.rho} was provided instead"
+            )
+        if self.eps < 0.0:
+            raise ValueError(
+                f"AdaDelta epsilon should be >0, {self.eps} was provided instead"
+            )
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["v"] = mx.zeros_like(parameter)
+        state["u"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the AdaDelta parameter update and stores :math:`v` and
+        :math:`u` in the optimizer state."""
+        lr = self.learning_rate.astype(gradient.dtype)
+        rho = self.rho
+        eps = self.eps
+
+        v = state["v"]
+        u = state["u"]
+
+        v = rho * v + (1 - rho) * mx.square(gradient)
+        d = mx.sqrt(u + eps) / mx.sqrt(v + eps) * gradient
+        u = rho * u + (1 - rho) * mx.square(d)
+
+        state["v"] = v
+        state["u"] = u
+
+        return parameter - lr * d
+
+
+class Adam(Optimizer):
+    r"""The Adam optimizer [1]. In detail,
+
+    [1]: Kingma, D.P. and Ba, J., 2015. Adam: A method for stochastic
+    optimization. ICLR 2015.
+
+    .. math::
+
+        m_{t+1} &= \beta_1 m_t + (1 - \beta_1) g_t \\
+        v_{t+1} &= \beta_2 v_t + (1 - \beta_2) g_t^2 \\
+        w_{t+1} &= w_t - \lambda \frac{m_{t+1}}{\sqrt{v_{t+1}} + \epsilon}
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\lambda`.
+        betas (Tuple[float, float], optional): The coefficients
+          :math:`(\beta_1, \beta_2)` used for computing running averages of the
+          gradient and its square. Default: ``(0.9, 0.999)``
+        eps (float, optional): The term :math:`\epsilon` added to the
+          denominator to improve numerical stability. Default: ``1e-8``
+        bias_correction (bool, optional): If set to ``True``, bias correction
+          is applied. Default: ``False``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        betas: List[float] = [0.9, 0.999],
+        eps: float = 1e-8,
+        bias_correction: bool = False,
+    ):
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.betas = betas
+        self.eps = eps
+        self.bias_correction = bias_correction
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["m"] = mx.zeros_like(parameter)
+        state["v"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the Adam parameter update and stores :math:`v` and
+        :math:`m` in the optimizer state."""
+        lr = self.learning_rate.astype(gradient.dtype)
+        b1, b2 = self.betas
+        eps = self.eps
+        bias_correction = self.bias_correction
+        step = self.step
+
+        m = state["m"]
+        v = state["v"]
+        m = b1 * m + (1 - b1) * gradient
+        v = b2 * v + (1 - b2) * mx.square(gradient)
+        state["m"] = m
+        state["v"] = v
+
+        if bias_correction:
+            c1 = (lr / (1 - b1**step)).astype(gradient.dtype)
+            c2 = mx.rsqrt(1 - b2**step).astype(gradient.dtype)
+            numerator = c1 * m
+            denominator = mx.sqrt(v) * c2 + eps
+            return parameter - numerator / denominator
+        else:
+            return parameter - lr * m / (mx.sqrt(v) + eps)
+
+
+class AdamW(Adam):
+    r"""The AdamW optimizer [1]. We update the weights with a weight_decay
+    (:math:`\lambda`) value:
+
+    [1]: Loshchilov, I. and Hutter, F., 2019. Decoupled weight decay
+    regularization. ICLR 2019.
+
+    .. math::
+
+        m_{t+1} &= \beta_1 m_t + (1 - \beta_1) g_t \\
+        v_{t+1} &= \beta_2 v_t + (1 - \beta_2) g_t^2 \\
+        w_{t+1} &= w_t - \alpha (\frac{m_{t+1}}{\sqrt{v_{t+1}} + \epsilon} + \lambda w_t)
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\alpha`.
+        betas (Tuple[float, float], optional): The coefficients
+          :math:`(\beta_1, \beta_2)` used for computing running averages of the
+          gradient and its square. Default: ``(0.9, 0.999)``
+        eps (float, optional): The term :math:`\epsilon` added to the
+          denominator to improve numerical stability. Default: ``1e-8``
+        weight_decay (float, optional): The weight decay :math:`\lambda`.
+          Default: ``0.01``.
+        bias_correction (bool, optional): If set to ``True``, bias correction
+          is applied. Default: ``False``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        betas: List[float] = [0.9, 0.999],
+        eps: float = 1e-8,
+        weight_decay: float = 0.01,
+        bias_correction: bool = False,
+    ):
+        super().__init__(
+            learning_rate=learning_rate,
+            betas=betas,
+            eps=eps,
+            bias_correction=bias_correction,
+        )
+        self.weight_decay = weight_decay
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the AdamW parameter update by modifying the parameters
+        passed into Adam.
+        """
+
+        lr = self.learning_rate.astype(gradient.dtype)
+        return super().apply_single(
+            gradient, parameter * (1 - lr * self.weight_decay), state
+        )
+
+
+class Adamax(Adam):
+    r"""The Adamax optimizer, a variant of Adam based on the infinity norm [1].
+
+    Our Adam implementation follows the original paper and omits the bias
+    correction in the first and second moment estimates. In detail,
+
+    [1]: Kingma, D.P. and Ba, J., 2015. Adam: A method for stochastic
+    optimization. ICLR 2015.
+
+    .. math::
+
+        m_{t+1} &= \beta_1 m_t + (1 - \beta_1) g_t \\
+        v_{t+1} &= \max(\beta_2 v_t, |g_t|) \\
+        w_{t+1} &= w_t - \lambda \frac{m_{t+1}}{v_{t+1} + \epsilon}
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\lambda`.
+        betas (Tuple[float, float], optional): The coefficients
+          :math:`(\beta_1, \beta_2)` used for computing running averages of the
+          gradient and its square. Default: ``(0.9, 0.999)``
+        eps (float, optional): The term :math:`\epsilon` added to the
+          denominator to improve numerical stability. Default: ``1e-8``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        betas: List[float] = [0.9, 0.999],
+        eps: float = 1e-8,
+    ):
+        super().__init__(learning_rate, betas, eps)
+        if not 0.0 <= eps:
+            raise ValueError(
+                f"Epsilon value should be >=0, {self.eps} was provided instead"
+            )
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["m"] = mx.zeros_like(parameter)
+        state["v"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the Adamax parameter update and stores :math:`v` and
+        :math:`m` in the optimizer state."""
+        lr = self.learning_rate.astype(gradient.dtype)
+        b1, b2 = self.betas
+        eps = self.eps
+
+        m = state["m"]
+        v = state["v"]
+
+        m = b1 * m + (1 - b1) * gradient
+        v = mx.maximum(b2 * v, mx.abs(gradient))
+        state["m"] = m
+        state["v"] = v
+
+        return parameter - lr * m / (v + eps)
+
+
+class Lion(Optimizer):
+    r"""The Lion optimizer [1].
+
+    Since updates are computed through the sign operation, they tend to
+    have larger norm than for other optimizers such as SGD and Adam.
+    We recommend a learning rate that is 3-10x smaller than AdamW and a
+    weight decay 3-10x larger than AdamW to maintain the strength
+    (lr * wd). Our Lion implementation follows the original paper. In
+    detail,
+
+    [1]: Chen, X. Symbolic Discovery of Optimization Algorithms. arXiv
+    preprint arXiv:2302.06675.
+
+    .. math::
+
+        c_{t + 1} &= \beta_1 m_t + (1 - \beta_1) g_t \\
+        m_{t + 1} &= \beta_2 m_t + (1 - \beta_2) g_t \\
+        w_{t + 1} &= w_t - \eta (\text{sign}(c_t) + \lambda w_t)
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\eta`.
+        betas (Tuple[float, float], optional): The coefficients
+          :math:`(\beta_1, \beta_2)` used for computing the gradient
+          momentum and update direction. Default: ``(0.9, 0.99)``
+        weight_decay (float, optional): The weight decay :math:`\lambda`. Default: ``0.0``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        betas: List[float] = [0.9, 0.99],
+        weight_decay: float = 0.0,
+    ):
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.betas = betas
+        self.weight_decay = weight_decay
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["m"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the Lion parameter update and stores :math:`m`
+        in the optimizer state."""
+        lr = self.learning_rate.astype(gradient.dtype)
+        b1, b2 = self.betas
+        weight_decay = self.weight_decay
+
+        m = state["m"]
+        c = b1 * m + (1 - b1) * gradient
+        state["m"] = b2 * m + (1 - b2) * gradient
+        if weight_decay > 0:
+            parameter = (1 - lr * weight_decay) * parameter
+        return parameter - lr * mx.sign(c)
+
+
+class Adafactor(Optimizer):
+    r"""The Adafactor optimizer.
+
+    Our Adafactor implementation follows the original paper: `Adafactor:
+    Adaptive Learning Rates with Sublinear Memory Cost
+    <https://arxiv.org/abs/1804.04235>`_
+
+    Args:
+        learning_rate (float or callable, optional): The learning rate.
+            Default: ``None``.
+        eps (tuple(float, float), optional): The first term :math:`\epsilon_1`
+            added to the square of the gradients to improve numerical
+            stability and the second term :math:`\epsilon_2` is used for
+            parameter scaling if ``parameter_scale`` is set to ``True``.
+            Default: ``(1e-30, 1e-3)``.
+        clip_threshold (float, optional): Clips the unscaled update at
+            ``clip_threshold``. Default: ``1.0``.
+        decay_rate (float, optional): Coefficient for the running average
+            of the squared gradient. Default: ``-0.8``.
+        beta_1 (float, optional): If set to a value bigger than zero
+            then first moment will be used. Default: ``None``.
+        weight_decay (float, optional): The weight decay :math:`\lambda`.
+            Default: ``0.0``.
+        scale_parameter (bool, optional): If set to ``True`` the learning rate
+            will be scaled by :math:`\max(\epsilon_1, \text{RMS}(w_{t-1}))`.
+            Default: ``True``.
+        relative_step (bool, optional): If set to ``True`` the ``learning_rate``
+            will be ignored and relative step size will be computed.
+            Default: ``True``.
+        warmup_init (bool, optional): If set to ``True`` then the relative
+            step size will be calculated by the current step. Default:
+            ``False``.
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array], None] = None,
+        eps: Tuple[float, float] = (1e-30, 1e-3),
+        clip_threshold: float = 1.0,
+        decay_rate: float = -0.8,
+        beta_1: Optional[float] = None,
+        weight_decay: float = 0.0,
+        scale_parameter: bool = True,
+        relative_step: bool = True,
+        warmup_init: bool = False,
+    ):
+        super().__init__()
+        if learning_rate is not None:
+            self._maybe_schedule("learning_rate", learning_rate)
+        self.eps = eps
+        self.clip_threshold = clip_threshold
+        self.decay_rate = decay_rate
+        self.beta_1 = beta_1
+        self.weight_decay = weight_decay
+        self.scale_parameter = scale_parameter
+        self.relative_step = relative_step
+        self.warmup_init = warmup_init
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        if parameter.ndim >= 2:
+            shape = parameter.shape
+            dtype = parameter.dtype
+            state["exp_avg_sq_row"] = mx.zeros(shape[:-1], dtype=dtype)
+            state["exp_avg_sq_col"] = mx.zeros(shape[:-2] + shape[-1:], dtype=dtype)
+        else:
+            state["exp_avg_sq"] = mx.zeros_like(parameter)
+
+        if self.beta_1 is not None:
+            state["exp_avg"] = mx.zeros_like(parameter)
+
+    def _compute_rms(self, inputs):
+        return mx.sqrt(mx.mean(mx.square(inputs)))
+
+    def _compute_learning_rate(self, step, parameter_rms):
+        if self.relative_step:
+            min_step = 1e-6 * step if self.warmup_init else 1e-2
+            relative_step_size = mx.minimum(min_step, mx.rsqrt(step))
+        else:
+            relative_step_size = self.learning_rate
+
+        relative_step_size = relative_step_size.astype(parameter_rms.dtype)
+        parameter_scale = 1.0
+        if self.scale_parameter:
+            parameter_scale = mx.maximum(self.eps[1], parameter_rms)
+        return parameter_scale * relative_step_size
+
+    def _approximate_exp_moving_avg(self, exp_avg_sq_row, exp_avg_sq_col):
+        r_factor = mx.rsqrt(
+            exp_avg_sq_row / mx.mean(exp_avg_sq_row, axis=-1, keepdims=True)
+        )
+        c_factor = mx.rsqrt(exp_avg_sq_col)
+        return mx.matmul(
+            mx.expand_dims(r_factor, axis=-1), mx.expand_dims(c_factor, axis=0)
+        )
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the Adafactor parameter and state update."""
+        factored = gradient.ndim >= 2
+
+        step = self.step
+        use_first_moment = self.beta_1 is not None
+
+        parameter_rms = self._compute_rms(parameter)
+        learning_rate = self._compute_learning_rate(step, parameter_rms)
+        beta_2 = 1.0 - (step**self.decay_rate).astype(parameter_rms.dtype)
+        update = mx.square(gradient) + self.eps[0]
+
+        if factored:
+            exp_avg_sq_row = state["exp_avg_sq_row"]
+            exp_avg_sq_col = state["exp_avg_sq_col"]
+            exp_avg_sq_row = (beta_2 * exp_avg_sq_row) + (
+                (1 - beta_2) * mx.mean(update, axis=-1)
+            )
+            exp_avg_sq_col = (beta_2 * exp_avg_sq_col) + (
+                (1 - beta_2) * mx.mean(update, axis=-2)
+            )
+            state["exp_avg_sq_row"] = exp_avg_sq_row
+            state["exp_avg_sq_col"] = exp_avg_sq_col
+            update = self._approximate_exp_moving_avg(exp_avg_sq_row, exp_avg_sq_col)
+            update = update * gradient
+        else:
+            exp_avg_sq = state["exp_avg_sq"]
+            exp_avg_sq = (beta_2 * exp_avg_sq) + ((1 - beta_2) * update)
+            state["exp_avg_sq"] = exp_avg_sq
+            update = mx.rsqrt(exp_avg_sq) * gradient
+
+        update = update / mx.maximum(
+            1.0, self._compute_rms(update) / self.clip_threshold
+        )
+        update = learning_rate * update
+
+        if use_first_moment:
+            exp_avg = state["exp_avg"]
+            exp_avg = (self.beta_1 * exp_avg) + ((1 - self.beta_1) * update)
+            state["exp_avg"] = exp_avg
+            update = exp_avg
+
+        if self.weight_decay != 0:
+            parameter += parameter * (-self.weight_decay * learning_rate)
+        return parameter - update
+
+
+class Muon(Optimizer):
+    r"""The Muon optimizer.
+
+    Our Muon (MomentUm Orthogonalized by Newton-schulz) optimizer follows the
+    original implementation: `Muon: An optimizer for hidden layers in neural
+    networks <https://kellerjordan.github.io/posts/muon/>`_
+
+    Note:
+        - Muon may be sub-optimal for the embedding layer, the final fully
+          connected layer, or any 0D/1D parameters. Those should be optimized
+          by a different method (e.g., :class:`AdamW`).
+        - For 4D convolutional filters, it works by flattening their last
+          dimensions.
+
+    Args:
+        learning_rate (float or callable): The learning rate.
+        momentum (float, optional): The momentum strength. Default: ``0.95``
+        weight_decay (float, optional): The weight decay (L2 penalty).
+            Default: ``0.01``
+        nesterov (bool, optional): Enables Nesterov momentum. Recommended for
+            better performance.  Default: ``True``
+        ns_steps (int, optional): Number of Newton-Schulz iteration steps for
+            orthogonalization.  Default: ``5``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        momentum: float = 0.95,
+        weight_decay: float = 0.01,
+        nesterov: bool = True,
+        ns_steps: int = 5,
+    ):
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.momentum = momentum
+        self.weight_decay = weight_decay
+        self.nesterov = nesterov
+        self.ns_steps = ns_steps
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["v"] = mx.zeros_like(parameter)
+
+    def _zeropower_via_newtonschulz5(self, X, steps: int):
+        assert (
+            X.ndim == 2
+        ), f"Expected a 2D array for Newton-Schulz iteration, got shape {X.shape} instead."
+        a, b, c = (3.4445, -4.7750, 2.0315)
+        transpose_needed = X.shape[-2] > X.shape[-1]
+
+        if transpose_needed:
+            X = X.T
+
+        X = X / (mx.linalg.norm(X, keepdims=True) + 1e-7)
+
+        for _ in range(steps):
+            A = X @ X.T
+            B = mx.addmm(b * A, A, A, beta=1.0, alpha=c)
+            X = mx.addmm(a * X, B, X, beta=1.0, alpha=1.0)
+
+        if transpose_needed:
+            X = X.T
+        return X
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the Muon parameter update"""
+
+        if self.weight_decay != 0:
+            gradient = gradient + self.weight_decay * parameter
+
+        v = self.momentum * state["v"]
+        v = v + (1 - self.momentum) * gradient
+        state["v"] = v
+
+        if self.nesterov:
+            update = gradient * (1 - self.momentum) + v * self.momentum
+        else:
+            update = v
+
+        lr = self.learning_rate.astype(gradient.dtype)
+
+        if update.ndim >= 2:
+            original_shape = update.shape
+            reshape_needed = update.ndim > 2
+
+            if reshape_needed:
+                update = mx.reshape(update, (update.shape[0], -1))
+
+            update = self._zeropower_via_newtonschulz5(update, steps=self.ns_steps)
+
+            if reshape_needed:
+                update = mx.reshape(update, original_shape)
+
+            lr *= max(1, update.shape[-2] / update.shape[-1]) ** 0.5
+
+        return parameter - lr * update
+
+
+def clip_grad_norm(grads, max_norm):
+    """Clips the global norm of the gradients.
+
+    This function ensures that the global norm of the gradients does not exceed
+    ``max_norm``. It scales down the gradients proportionally if their norm is
+    greater than ``max_norm``.
+
+    Example:
+        >>> grads = {"w1": mx.array([2, 3]), "w2": mx.array([1])}
+        >>> clipped_grads, total_norm = clip_grad_norm(grads, max_norm=2.0)
+        >>> print(clipped_grads)
+        {"w1": mx.array([...]), "w2": mx.array([...])}
+
+    Args:
+        grads (dict): A dictionary containing the gradient arrays.
+        max_norm (float): The maximum allowed global norm of the gradients.
+
+    Returns:
+        (dict, float): The possibly rescaled gradients and the original
+        gradient norm.
+    """
+    norm_squared = tree_reduce(lambda acc, g: acc + g.square().sum(), grads, 0.0)
+    total_norm = mx.sqrt(norm_squared)
+    normalizer = mx.minimum(max_norm / (total_norm + 1e-6), 1.0)
+    clipped_grads = tree_map(lambda g: g * normalizer, grads)
+    return clipped_grads, total_norm
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/optimizers/schedulers.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/optimizers/schedulers.py
new file mode 100644
index 0000000000000000000000000000000000000000..67e4e29cd2560e42d2f6800cec319cd6f027933e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/optimizers/schedulers.py
@@ -0,0 +1,158 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+from typing import Callable, List
+
+import mlx.core as mx
+
+
+def exponential_decay(init: float, decay_rate: float) -> Callable:
+    r"""Make an exponential decay scheduler.
+
+    Args:
+        init (float): Initial value.
+        decay_rate (float): Multiplicative factor to decay by.
+
+    Example:
+        >>> lr_schedule = optim.exponential_decay(1e-1, 0.9)
+        >>> optimizer = optim.SGD(learning_rate=lr_schedule)
+        >>> optimizer.learning_rate
+        array(0.1, dtype=float32)
+        >>>
+        >>> for _ in range(5): optimizer.update({}, {})
+        ...
+        >>> optimizer.learning_rate
+        array(0.06561, dtype=float32)
+    """
+
+    def schedule(step):
+        return init * decay_rate**step
+
+    return schedule
+
+
+def step_decay(init: float, decay_rate: float, step_size: int) -> Callable:
+    r"""Make a step decay scheduler.
+
+    Args:
+        init (float): Initial value.
+        decay_rate (float): Multiplicative factor to decay by.
+        step_size (int): Decay every ``step_size`` steps.
+
+    Example:
+
+        >>> lr_schedule = optim.step_decay(1e-1, 0.9, 10)
+        >>> optimizer = optim.SGD(learning_rate=lr_schedule)
+        >>> optimizer.learning_rate
+        array(0.1, dtype=float32)
+        >>>
+        >>> for _ in range(21): optimizer.update({}, {})
+        ...
+        >>> optimizer.learning_rate
+        array(0.081, dtype=float32)
+    """
+
+    def schedule(step):
+        return init * (decay_rate ** (step // step_size))
+
+    return schedule
+
+
+def cosine_decay(init: float, decay_steps: int, end: float = 0.0) -> Callable:
+    r"""Make a cosine decay scheduler.
+
+    Args:
+        init (float): Initial value.
+        decay_steps (int): Number of steps to decay over. The decayed
+            value is constant for steps beyond ``decay_steps``.
+        end (float, optional): Final value to decay to. Default: ``0``.
+
+    Example:
+
+        >>> lr_schedule = optim.cosine_decay(1e-1, 1000)
+        >>> optimizer = optim.SGD(learning_rate=lr_schedule)
+        >>> optimizer.learning_rate
+        array(0.1, dtype=float32)
+        >>>
+        >>> for _ in range(5): optimizer.update({}, {})
+        ...
+        >>> optimizer.learning_rate
+        array(0.0999961, dtype=float32)
+    """
+
+    def schedule(step):
+        s = mx.minimum(step, decay_steps)
+        decay = 0.5 * (1.0 + mx.cos((math.pi / decay_steps) * s))
+        return end + decay * (init - end)
+
+    return schedule
+
+
+def join_schedules(schedules: List[Callable], boundaries: List[int]) -> Callable:
+    r"""Join multiple schedules to create a new schedule.
+
+    Args:
+        schedules (list(Callable)): A list of schedules. Schedule :math:`i+1`
+          receives a step count indicating the number of steps since
+          the :math:`i`-th boundary.
+        boundaries (list(int)): A list of integers of length ``len(schedules) - 1``
+          that indicates when to transition between schedules.
+
+    Example:
+        >>> linear = optim.linear_schedule(0, 1e-1, steps=10)
+        >>> cosine = optim.cosine_decay(1e-1, 200)
+        >>> lr_schedule = optim.join_schedules([linear, cosine], [10])
+        >>> optimizer = optim.Adam(learning_rate=lr_schedule)
+        >>> optimizer.learning_rate
+        array(0.0, dtype=float32)
+        >>> for _ in range(12): optimizer.update({}, {})
+        ...
+        >>> optimizer.learning_rate
+        array(0.0999938, dtype=float32)
+    """
+    if len(schedules) == 0:
+        raise ValueError("Must provide at least 1 schedule to join.")
+
+    if len(schedules) != len(boundaries) + 1:
+        raise ValueError(
+            f"Received {len(boundaries)} boundaries but "
+            f"expected {len(schedules) - 1}."
+        )
+
+    def schedule(step):
+        output = schedules[0](step)
+        for boundary, schedule in zip(boundaries, schedules[1:]):
+            output = mx.where(step < boundary, output, schedule(step - boundary))
+        return output
+
+    return schedule
+
+
+def linear_schedule(init: float, end: float, steps: int) -> Callable:
+    r"""Make a linear scheduler.
+
+    Args:
+        init (float): Initial value.
+        end (float): Final value.
+        steps (int): Number of steps to apply the schedule over. The value is
+          ``end`` for any steps beyond ``steps``.
+
+    Example:
+
+        >>> lr_schedule = optim.linear_schedule(0, 1e-1, 100)
+        >>> optimizer = optim.Adam(learning_rate=lr_schedule)
+        >>> optimizer.learning_rate
+        array(0.0, dtype=float32)
+        >>> for _ in range(101): optimizer.update({}, {})
+        ...
+        >>> optimizer.learning_rate
+        array(0.1, dtype=float32)
+    """
+    if steps < 1:
+        raise ValueError(f"steps must be greater than 0, but got {steps}.")
+
+    def schedule(step):
+        step = mx.minimum(step, steps)
+        return step * ((end - init) / steps) + init
+
+    return schedule
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/py.typed b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/py.typed
@@ -0,0 +1 @@
+
diff --git a/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/utils.py b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa9884c10f74449c36021e38086152479160a5bd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/utils.py
@@ -0,0 +1,324 @@
+# Copyright © 2023 Apple Inc.
+from collections import defaultdict
+from itertools import zip_longest
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+
+def tree_map(
+    fn: Callable, tree: Any, *rest: Any, is_leaf: Optional[Callable] = None
+) -> Any:
+    """Applies ``fn`` to the leaves of the Python tree ``tree`` and
+    returns a new collection with the results.
+
+    If ``rest`` is provided, every item is assumed to be a superset of ``tree``
+    and the corresponding leaves are provided as extra positional arguments to
+    ``fn``. In that respect, :meth:`tree_map` is closer to :func:`itertools.starmap`
+    than to :func:`map`.
+
+    The keyword argument ``is_leaf`` decides what constitutes a leaf from
+    ``tree`` similar to :func:`tree_flatten`.
+
+    .. code-block:: python
+
+        import mlx.nn as nn
+        from mlx.utils import tree_map
+
+        model = nn.Linear(10, 10)
+        print(model.parameters().keys())
+        # dict_keys(['weight', 'bias'])
+
+        # square the parameters
+        model.update(tree_map(lambda x: x*x, model.parameters()))
+
+    Args:
+        fn (callable): The function that processes the leaves of the tree.
+        tree (Any): The main Python tree that will be iterated upon.
+        rest (tuple[Any]): Extra trees to be iterated together with ``tree``.
+        is_leaf (callable, optional): An optional callable that returns ``True``
+           if the passed object is considered a leaf or ``False`` otherwise.
+
+    Returns:
+        A Python tree with the new values returned by ``fn``.
+    """
+    if is_leaf is not None and is_leaf(tree):
+        return fn(tree, *rest)
+    elif isinstance(tree, (list, tuple)):
+        TreeType = type(tree)
+        return TreeType(
+            tree_map(fn, child, *(r[i] for r in rest), is_leaf=is_leaf)
+            for i, child in enumerate(tree)
+        )
+    elif isinstance(tree, dict):
+        return {
+            k: tree_map(fn, child, *(r[k] for r in rest), is_leaf=is_leaf)
+            for k, child in tree.items()
+        }
+    else:
+        return fn(tree, *rest)
+
+
+def tree_map_with_path(
+    fn: Callable,
+    tree: Any,
+    *rest: Any,
+    is_leaf: Optional[Callable] = None,
+    path: Optional[Any] = None,
+) -> Any:
+    """Applies ``fn`` to the path and leaves of the Python tree ``tree`` and
+    returns a new collection with the results.
+
+    This function is the same :func:`tree_map` but the ``fn`` takes the path as
+    the first argument followed by the remaining tree nodes.
+
+    Args:
+        fn (callable): The function that processes the leaves of the tree.
+        tree (Any): The main Python tree that will be iterated upon.
+        rest (tuple[Any]): Extra trees to be iterated together with ``tree``.
+        is_leaf (Optional[Callable]): An optional callable that returns ``True``
+           if the passed object is considered a leaf or ``False`` otherwise.
+        path (Optional[Any]): Prefix will be added to the result.
+
+    Returns:
+        A Python tree with the new values returned by ``fn``.
+
+    Example:
+        >>> from mlx.utils import tree_map_with_path
+        >>> tree = {"model": [{"w": 0, "b": 1}, {"w": 0, "b": 1}]}
+        >>> new_tree = tree_map_with_path(lambda path, _: print(path), tree)
+        model.0.w
+        model.0.b
+        model.1.w
+        model.1.b
+    """
+    if is_leaf is not None and is_leaf(tree):
+        return fn(path, tree, *rest)
+    elif isinstance(tree, (list, tuple)):
+        prefix = f"{path}." if path else ""
+        TreeType = type(tree)
+        return TreeType(
+            tree_map_with_path(
+                fn, child, *(r[i] for r in rest), is_leaf=is_leaf, path=f"{prefix}{i}"
+            )
+            for i, child in enumerate(tree)
+        )
+    elif isinstance(tree, dict):
+        prefix = f"{path}." if path else ""
+        return {
+            k: tree_map_with_path(
+                fn, child, *(r[k] for r in rest), is_leaf=is_leaf, path=f"{prefix}{k}"
+            )
+            for k, child in tree.items()
+        }
+    else:
+        return fn(path, tree, *rest)
+
+
+def tree_flatten(
+    tree: Any,
+    prefix: str = "",
+    is_leaf: Optional[Callable] = None,
+    destination: Optional[Union[List[Tuple[str, Any]], Dict[str, Any]]] = None,
+) -> Union[List[Tuple[str, Any]], Dict[str, Any]]:
+    """Flattens a Python tree to a list of key, value tuples.
+
+    The keys are using the dot notation to define trees of arbitrary depth and
+    complexity.
+
+    .. code-block:: python
+
+        from mlx.utils import tree_flatten
+
+        print(tree_flatten([[[0]]]))
+        # [("0.0.0", 0)]
+
+        print(tree_flatten([[[0]]], prefix=".hello"))
+        # [("hello.0.0.0", 0)]
+
+        tree_flatten({"a": {"b": 1}}, destination={})
+        {"a.b": 1}
+
+    .. note::
+       Dictionaries should have keys that are valid Python identifiers.
+
+    Args:
+        tree (Any): The Python tree to be flattened.
+        prefix (str): A prefix to use for the keys. The first character is
+            always discarded.
+        is_leaf (callable): An optional callable that returns True if the
+            passed object is considered a leaf or False otherwise.
+        destination (list or dict, optional): A list or dictionary to store the
+            flattened tree. If None an empty list will be used. Default: ``None``.
+
+    Returns:
+        Union[List[Tuple[str, Any]], Dict[str, Any]]: The flat representation of
+            the Python tree.
+    """
+    if destination is None:
+        destination = []
+
+    # Create the function to update the destination. We are taking advantage of
+    # the fact that list.extend and dict.update have the same API to simplify
+    # the code a bit.
+    if isinstance(destination, list):
+        _add_to_destination = destination.extend
+    elif isinstance(destination, dict):
+        _add_to_destination = destination.update
+    else:
+        raise ValueError("Destination should be either a list or a dictionary or None")
+
+    # Leaf identified by is_leaf so add it and return
+    if is_leaf is not None and is_leaf(tree):
+        _add_to_destination([(prefix[1:], tree)])
+        return destination
+
+    # List or tuple so recursively add each subtree
+    if isinstance(tree, (list, tuple)):
+        for i, item in enumerate(tree):
+            tree_flatten(item, f"{prefix}.{i}", is_leaf, destination)
+        return destination
+
+    # Dictionary so recursively add each subtree
+    if isinstance(tree, dict):
+        for key, value in tree.items():
+            tree_flatten(value, f"{prefix}.{key}", is_leaf, destination)
+        return destination
+
+    # Leaf so add it and return
+    _add_to_destination([(prefix[1:], tree)])
+
+    return destination
+
+
+def tree_unflatten(tree: Union[List[Tuple[str, Any]], Dict[str, Any]]) -> Any:
+    """Recreate a Python tree from its flat representation.
+
+    .. code-block:: python
+
+        from mlx.utils import tree_unflatten
+
+        d = tree_unflatten([("hello.world", 42)])
+        print(d)
+        # {"hello": {"world": 42}}
+
+        d = tree_unflatten({"hello.world": 42})
+        print(d)
+        # {"hello": {"world": 42}}
+
+    Args:
+        tree (list[tuple[str, Any]] or dict[str, Any]): The flat representation of a Python tree.
+           For instance as returned by :meth:`tree_flatten`.
+
+    Returns:
+        A Python tree.
+    """
+    items = tree.items() if isinstance(tree, dict) else tree
+
+    # Special case when we have just one element in the tree ie not a tree
+    if len(items) == 1:
+        key, value = next(iter(items))
+        if key == "":
+            return value
+
+    # collect children
+    children = defaultdict(list)
+    for key, value in items:
+        current_idx, *next_idx = key.split(".", maxsplit=1)
+        next_idx = "" if not next_idx else next_idx[0]
+        children[current_idx].append((next_idx, value))
+
+    # Assume they are a list and fail to dict if the keys are not all integers
+    try:
+        keys = sorted((int(idx), idx) for idx in children.keys())
+        l = []
+        for i, k in keys:
+            # if i <= len(l), no {} will be appended.
+            l.extend([{} for _ in range(i - len(l))])
+            l.append(tree_unflatten(children[k]))
+        return l
+    except ValueError:
+        return {k: tree_unflatten(v) for k, v in children.items()}
+
+
+def tree_reduce(fn, tree, initializer=None, is_leaf=None):
+    """Applies a reduction to the leaves of a Python tree.
+
+    This function reduces Python trees into an accumulated result by applying
+    the provided function ``fn`` to the leaves of the tree.
+
+    Example:
+        >>> from mlx.utils import tree_reduce
+        >>> tree = {"a": [1, 2, 3], "b": [4, 5]}
+        >>> tree_reduce(lambda acc, x: acc + x, tree, 0)
+        15
+
+    Args:
+        fn (callable): The reducer function that takes two arguments (accumulator,
+            current value) and returns the updated accumulator.
+        tree (Any): The Python tree to reduce. It can be any nested combination of
+            lists, tuples, or dictionaries.
+        initializer (Any, optional): The initial value to start the reduction. If
+            not provided, the first leaf value is used.
+        is_leaf (callable, optional): A function to determine if an object is a
+            leaf, returning ``True`` for leaf nodes and ``False`` otherwise.
+
+    Returns:
+        Any: The accumulated value.
+    """
+    if is_leaf is not None and is_leaf(tree):
+        return tree if initializer is None else fn(initializer, tree)
+
+    accumulator = initializer
+
+    if isinstance(tree, (list, tuple)):
+        for item in tree:
+            accumulator = tree_reduce(fn, item, accumulator, is_leaf)
+    elif isinstance(tree, dict):
+        for item in tree.values():
+            accumulator = tree_reduce(fn, item, accumulator, is_leaf)
+    else:
+        return tree if accumulator is None else fn(accumulator, tree)
+
+    return accumulator
+
+
+def tree_merge(tree_a, tree_b, merge_fn=None):
+    """Merge two Python trees in one containing the values of both. It can be
+    thought of as a deep dict.update method.
+
+    Args:
+        tree_a (Any): The first Python tree.
+        tree_b (Any): The second Python tree.
+        merge_fn (callable, optional): A function to merge leaves.
+
+    Returns:
+        The Python tree containing the values of both ``tree_a`` and
+        ``tree_b``.
+    """
+    if isinstance(tree_a, (dict, list, tuple)) and len(tree_a) == 0:
+        tree_a = None
+    if isinstance(tree_b, (dict, list, tuple)) and len(tree_b) == 0:
+        tree_b = None
+    if tree_a is None and tree_b is not None:
+        return tree_b
+    if tree_a is not None and tree_b is None:
+        return tree_a
+
+    if isinstance(tree_a, (list, tuple)) and isinstance(tree_b, (list, tuple)):
+        TreeType = type(tree_a)
+        return TreeType(
+            tree_merge(a, b, merge_fn) for a, b in zip_longest(tree_a, tree_b)
+        )
+    elif isinstance(tree_a, dict) and isinstance(tree_b, dict):
+        return {
+            k: tree_merge(tree_a.get(k, None), tree_b.get(k, None), merge_fn)
+            for k in set(tree_a.keys()) | set(tree_b.keys())
+        }
+    else:
+        if merge_fn is None:
+            raise ValueError(
+                (
+                    "Trees contain elements at the same locations but no merge "
+                    "function was provided"
+                )
+            )
+        return merge_fn(tree_a, tree_b)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeCache.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeCache.txt
new file mode 100644
index 0000000000000000000000000000000000000000..31223cc2ac3ad07b5c97487b001594c0abece241
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeCache.txt
@@ -0,0 +1,773 @@
+# This is the CMakeCache file.
+# For build in directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+# It was generated by CMake: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+# You can edit this file to change values found and used by cmake.
+# If you do not want to change any of the values, simply exit the editor.
+# If you do want to change a value, simply edit, save, and exit the editor.
+# The syntax for the file is as follows:
+# KEY:TYPE=VALUE
+# KEY is the name of a variable in the cache.
+# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
+# VALUE is the current value for the KEY.
+
+########################
+# EXTERNAL cache entries
+########################
+
+//Path to a library.
+ACCELERATE_LIBRARY:FILEPATH=ACCELERATE_LIBRARY-NOTFOUND
+
+//Path to a file.
+BLAS_INCLUDE_DIRS:PATH=/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include
+
+//Path to a library.
+BLAS_flexiblas_LIBRARY:FILEPATH=BLAS_flexiblas_LIBRARY-NOTFOUND
+
+//Path to a library.
+BLAS_goto2_LIBRARY:FILEPATH=BLAS_goto2_LIBRARY-NOTFOUND
+
+//Path to a library.
+BLAS_mkl_LIBRARY:FILEPATH=BLAS_mkl_LIBRARY-NOTFOUND
+
+//Path to a library.
+BLAS_mkl_em64t_LIBRARY:FILEPATH=BLAS_mkl_em64t_LIBRARY-NOTFOUND
+
+//Path to a library.
+BLAS_mkl_ia32_LIBRARY:FILEPATH=BLAS_mkl_ia32_LIBRARY-NOTFOUND
+
+//Path to a library.
+BLAS_mkl_intel_LIBRARY:FILEPATH=BLAS_mkl_intel_LIBRARY-NOTFOUND
+
+//Path to a library.
+BLAS_mkl_intel_lp64_LIBRARY:FILEPATH=BLAS_mkl_intel_lp64_LIBRARY-NOTFOUND
+
+//Path to a library.
+BLAS_mkl_rt_LIBRARY:FILEPATH=BLAS_mkl_rt_LIBRARY-NOTFOUND
+
+//Path to a library.
+BLAS_openblas_LIBRARY:FILEPATH=/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/libopenblas.so
+
+//Build mlx as a shared library
+BUILD_SHARED_LIBS:BOOL=ON
+
+//Path to a program.
+CCACHE_PROGRAM:FILEPATH=CCACHE_PROGRAM-NOTFOUND
+
+//Path to a program.
+CMAKE_ADDR2LINE:FILEPATH=/usr/bin/addr2line
+
+//Path to a program.
+CMAKE_AR:FILEPATH=/usr/bin/ar
+
+//Choose the type of build, options are: None Debug Release RelWithDebInfo
+// MinSizeRel ...
+CMAKE_BUILD_TYPE:STRING=Release
+
+//Enable/Disable color output during build.
+CMAKE_COLOR_MAKEFILE:BOOL=ON
+
+//CXX compiler
+CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/c++
+
+//A wrapper around 'ar' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_CXX_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar
+
+//A wrapper around 'ranlib' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib
+
+//Flags used by the CXX compiler during all build types.
+CMAKE_CXX_FLAGS:STRING=
+
+//Flags used by the CXX compiler during DEBUG builds.
+CMAKE_CXX_FLAGS_DEBUG:STRING=-g
+
+//Flags used by the CXX compiler during MINSIZEREL builds.
+CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG
+
+//Flags used by the CXX compiler during RELEASE builds.
+CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
+
+//Flags used by the CXX compiler during RELWITHDEBINFO builds.
+CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG
+
+//C compiler
+CMAKE_C_COMPILER:FILEPATH=/usr/bin/cc
+
+//A wrapper around 'ar' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_C_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar
+
+//A wrapper around 'ranlib' adding the appropriate '--plugin' option
+// for the GCC compiler
+CMAKE_C_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib
+
+//Flags used by the C compiler during all build types.
+CMAKE_C_FLAGS:STRING=
+
+//Flags used by the C compiler during DEBUG builds.
+CMAKE_C_FLAGS_DEBUG:STRING=-g
+
+//Flags used by the C compiler during MINSIZEREL builds.
+CMAKE_C_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG
+
+//Flags used by the C compiler during RELEASE builds.
+CMAKE_C_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
+
+//Flags used by the C compiler during RELWITHDEBINFO builds.
+CMAKE_C_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG
+
+//Path to a program.
+CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND
+
+//Flags used by the linker during all build types.
+CMAKE_EXE_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during DEBUG builds.
+CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during MINSIZEREL builds.
+CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during RELEASE builds.
+CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during RELWITHDEBINFO builds.
+CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Enable/Disable output of compile commands during generation.
+CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=
+
+//Value Computed by CMake.
+CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/pkgRedirects
+
+//User executables (bin)
+CMAKE_INSTALL_BINDIR:PATH=bin
+
+//Read-only architecture-independent data (DATAROOTDIR)
+CMAKE_INSTALL_DATADIR:PATH=
+
+//Read-only architecture-independent data root (share)
+CMAKE_INSTALL_DATAROOTDIR:PATH=share
+
+//Documentation root (DATAROOTDIR/doc/PROJECT_NAME)
+CMAKE_INSTALL_DOCDIR:PATH=
+
+//C header files (include)
+CMAKE_INSTALL_INCLUDEDIR:PATH=include
+
+//Info documentation (DATAROOTDIR/info)
+CMAKE_INSTALL_INFODIR:PATH=
+
+//Object code libraries (lib64)
+CMAKE_INSTALL_LIBDIR:PATH=lib64
+
+//Program executables (libexec)
+CMAKE_INSTALL_LIBEXECDIR:PATH=libexec
+
+//Locale-dependent data (DATAROOTDIR/locale)
+CMAKE_INSTALL_LOCALEDIR:PATH=
+
+//Modifiable single-machine data (var)
+CMAKE_INSTALL_LOCALSTATEDIR:PATH=var
+
+//Man documentation (DATAROOTDIR/man)
+CMAKE_INSTALL_MANDIR:PATH=
+
+//C header files for non-gcc (/usr/include)
+CMAKE_INSTALL_OLDINCLUDEDIR:PATH=/usr/include
+
+//Install path prefix, prepended onto install directories.
+CMAKE_INSTALL_PREFIX:PATH=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx
+
+//Run-time variable data (LOCALSTATEDIR/run)
+CMAKE_INSTALL_RUNSTATEDIR:PATH=
+
+//System admin executables (sbin)
+CMAKE_INSTALL_SBINDIR:PATH=sbin
+
+//Modifiable architecture-independent data (com)
+CMAKE_INSTALL_SHAREDSTATEDIR:PATH=com
+
+//Read-only single-machine data (etc)
+CMAKE_INSTALL_SYSCONFDIR:PATH=etc
+
+//Path to a program.
+CMAKE_LINKER:FILEPATH=/usr/bin/ld
+
+//Path to a program.
+CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/gmake
+
+//Flags used by the linker during the creation of modules during
+// all build types.
+CMAKE_MODULE_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during the creation of modules during
+// DEBUG builds.
+CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during the creation of modules during
+// MINSIZEREL builds.
+CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during the creation of modules during
+// RELEASE builds.
+CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during the creation of modules during
+// RELWITHDEBINFO builds.
+CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Path to a program.
+CMAKE_NM:FILEPATH=/usr/bin/nm
+
+//Path to a program.
+CMAKE_OBJCOPY:FILEPATH=/usr/bin/objcopy
+
+//Path to a program.
+CMAKE_OBJDUMP:FILEPATH=/usr/bin/objdump
+
+//Value Computed by CMake
+CMAKE_PROJECT_DESCRIPTION:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_HOMEPAGE_URL:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_NAME:STATIC=mlx
+
+//Value Computed by CMake
+CMAKE_PROJECT_VERSION:STATIC=0.29.2
+
+//Value Computed by CMake
+CMAKE_PROJECT_VERSION_MAJOR:STATIC=0
+
+//Value Computed by CMake
+CMAKE_PROJECT_VERSION_MINOR:STATIC=29
+
+//Value Computed by CMake
+CMAKE_PROJECT_VERSION_PATCH:STATIC=2
+
+//Value Computed by CMake
+CMAKE_PROJECT_VERSION_TWEAK:STATIC=
+
+//Path to a program.
+CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib
+
+//Path to a program.
+CMAKE_READELF:FILEPATH=/usr/bin/readelf
+
+//Flags used by the linker during the creation of shared libraries
+// during all build types.
+CMAKE_SHARED_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during DEBUG builds.
+CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during MINSIZEREL builds.
+CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during RELEASE builds.
+CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during the creation of shared libraries
+// during RELWITHDEBINFO builds.
+CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//If set, runtime paths are not added when installing shared libraries,
+// but are added when building.
+CMAKE_SKIP_INSTALL_RPATH:BOOL=NO
+
+//If set, runtime paths are not added when using shared libraries.
+CMAKE_SKIP_RPATH:BOOL=NO
+
+//Flags used by the linker during the creation of static libraries
+// during all build types.
+CMAKE_STATIC_LINKER_FLAGS:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during DEBUG builds.
+CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during MINSIZEREL builds.
+CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during RELEASE builds.
+CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING=
+
+//Flags used by the linker during the creation of static libraries
+// during RELWITHDEBINFO builds.
+CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING=
+
+//Path to a program.
+CMAKE_STRIP:FILEPATH=/usr/bin/strip
+
+//Path to a program.
+CMAKE_TAPI:FILEPATH=CMAKE_TAPI-NOTFOUND
+
+//If this value is on, makefiles will be generated without the
+// .SILENT directive, and all commands will be echoed to the console
+// during the make.  This is useful for debugging only. With Visual
+// Studio IDE projects all commands are done without /nologo.
+CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE
+
+//Directory under which to collect all populated content
+FETCHCONTENT_BASE_DIR:PATH=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps
+
+//Disables all attempts to download or update content and assumes
+// source dirs already exist
+FETCHCONTENT_FULLY_DISCONNECTED:BOOL=OFF
+
+//Enables QUIET option for all content population
+FETCHCONTENT_QUIET:BOOL=ON
+
+//When not empty, overrides where to find pre-populated content
+// for fmt
+FETCHCONTENT_SOURCE_DIR_FMT:PATH=
+
+//When not empty, overrides where to find pre-populated content
+// for gguflib
+FETCHCONTENT_SOURCE_DIR_GGUFLIB:PATH=
+
+//When not empty, overrides where to find pre-populated content
+// for json
+FETCHCONTENT_SOURCE_DIR_JSON:PATH=
+
+//Enables UPDATE_DISCONNECTED behavior for all content population
+FETCHCONTENT_UPDATES_DISCONNECTED:BOOL=OFF
+
+//Enables UPDATE_DISCONNECTED behavior just for population of fmt
+FETCHCONTENT_UPDATES_DISCONNECTED_FMT:BOOL=OFF
+
+//Enables UPDATE_DISCONNECTED behavior just for population of gguflib
+FETCHCONTENT_UPDATES_DISCONNECTED_GGUFLIB:BOOL=OFF
+
+//Enables UPDATE_DISCONNECTED behavior just for population of json
+FETCHCONTENT_UPDATES_DISCONNECTED_JSON:BOOL=OFF
+
+//Value Computed by CMake
+FMT_BINARY_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build
+
+//Installation directory for cmake files, a relative path that
+// will be joined with /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx
+// or an absolute path.
+FMT_CMAKE_DIR:STRING=lib64/cmake/fmt
+
+//Generate the cuda-test target.
+FMT_CUDA_TEST:BOOL=OFF
+
+//Debug library postfix.
+FMT_DEBUG_POSTFIX:STRING=d
+
+//Generate the doc target.
+FMT_DOC:BOOL=OFF
+
+//Generate the fuzz target.
+FMT_FUZZ:BOOL=OFF
+
+//Installation directory for include files, a relative path that
+// will be joined with /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx
+// or an absolute path.
+FMT_INC_DIR:STRING=include
+
+//Generate the install target.
+FMT_INSTALL:BOOL=ON
+
+//Value Computed by CMake
+FMT_IS_TOP_LEVEL:STATIC=OFF
+
+//Installation directory for libraries, a relative path that will
+// be joined to /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx
+// or an absolute path.
+FMT_LIB_DIR:STRING=lib64
+
+//Build a module instead of a traditional library.
+FMT_MODULE:BOOL=OFF
+
+//Include core requiring OS (Windows/Posix) 
+FMT_OS:BOOL=ON
+
+//Enable extra warnings and expensive tests.
+FMT_PEDANTIC:BOOL=OFF
+
+//Installation directory for pkgconfig (.pc) files, a relative
+// path that will be joined with /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx
+// or an absolute path.
+FMT_PKGCONFIG_DIR:STRING=lib64/pkgconfig
+
+//Value Computed by CMake
+FMT_SOURCE_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src
+
+//Expose headers with marking them as system.
+FMT_SYSTEM_HEADERS:BOOL=OFF
+
+//Generate the test target.
+FMT_TEST:BOOL=OFF
+
+//Halt the compilation with an error on compiler warnings.
+FMT_WERROR:BOOL=OFF
+
+//Git command line client
+GIT_EXECUTABLE:FILEPATH=/usr/bin/git
+
+//Build the unit tests when BUILD_TESTING is enabled.
+JSON_BuildTests:BOOL=OFF
+
+//Enable CI build targets.
+JSON_CI:BOOL=OFF
+
+//Use extended diagnostic messages.
+JSON_Diagnostics:BOOL=OFF
+
+//Disable default integer enum serialization.
+JSON_DisableEnumSerialization:BOOL=OFF
+
+//Place use-defined string literals in the global namespace.
+JSON_GlobalUDLs:BOOL=ON
+
+//Enable implicit conversions.
+JSON_ImplicitConversions:BOOL=ON
+
+//Install CMake targets during install step.
+JSON_Install:BOOL=OFF
+
+//Enable legacy discarded value comparison.
+JSON_LegacyDiscardedValueComparison:BOOL=OFF
+
+//Use non-amalgamated version of the library.
+JSON_MultipleHeaders:BOOL=ON
+
+//Include as system headers (skip for clang-tidy).
+JSON_SystemInclude:BOOL=OFF
+
+//Path to a file.
+LAPACK_INCLUDE_DIRS:PATH=/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include
+
+//Build benchmarks for mlx
+MLX_BUILD_BENCHMARKS:BOOL=OFF
+
+//Build OpenBLAS from source code
+MLX_BUILD_BLAS_FROM_SOURCE:BOOL=OFF
+
+//Build cpu backend
+MLX_BUILD_CPU:BOOL=ON
+
+//Build cuda backend
+MLX_BUILD_CUDA:BOOL=OFF
+
+//Build examples for mlx
+MLX_BUILD_EXAMPLES:BOOL=OFF
+
+//Include support for GGUF format
+MLX_BUILD_GGUF:BOOL=ON
+
+//Build metal backend
+MLX_BUILD_METAL:BOOL=ON
+
+//Build python bindings for mlx
+MLX_BUILD_PYTHON_BINDINGS:BOOL=ON
+
+//Include support for safetensors format
+MLX_BUILD_SAFETENSORS:BOOL=ON
+
+//Build tests for mlx
+MLX_BUILD_TESTS:BOOL=OFF
+
+//Enable building for x64 macOS
+MLX_ENABLE_X64_MAC:BOOL=OFF
+
+//Enhance metal debug workflow
+MLX_METAL_DEBUG:BOOL=OFF
+
+//Use JIT compilation for Metal kernels
+MLX_METAL_JIT:BOOL=OFF
+
+//No help, variable specified on the command line.
+MLX_PYTHON_BINDINGS_OUTPUT_DIRECTORY:UNINITIALIZED=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/
+
+//Use CCache for compilation cache when available
+MLX_USE_CCACHE:BOOL=ON
+
+//No help, variable specified on the command line.
+MLX_VERSION:UNINITIALIZED=0.29.2.dev20251007+0073096d
+
+//Use system's provided fmt library
+USE_SYSTEM_FMT:BOOL=OFF
+
+//Value Computed by CMake
+mlx_BINARY_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+//Value Computed by CMake
+mlx_IS_TOP_LEVEL:STATIC=ON
+
+//Value Computed by CMake
+mlx_SOURCE_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+//The directory containing a CMake configuration file for nanobind.
+nanobind_DIR:PATH=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/cmake
+
+//Value Computed by CMake
+nlohmann_json_BINARY_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build
+
+//Value Computed by CMake
+nlohmann_json_IS_TOP_LEVEL:STATIC=OFF
+
+//Value Computed by CMake
+nlohmann_json_SOURCE_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src
+
+
+########################
+# INTERNAL cache entries
+########################
+
+//Have function sgemm_
+BLAS_WORKS:INTERNAL=
+//ADVANCED property for variable: BLAS_flexiblas_LIBRARY
+BLAS_flexiblas_LIBRARY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: BLAS_goto2_LIBRARY
+BLAS_goto2_LIBRARY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: BLAS_mkl_LIBRARY
+BLAS_mkl_LIBRARY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: BLAS_mkl_em64t_LIBRARY
+BLAS_mkl_em64t_LIBRARY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: BLAS_mkl_ia32_LIBRARY
+BLAS_mkl_ia32_LIBRARY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: BLAS_mkl_intel_LIBRARY
+BLAS_mkl_intel_LIBRARY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: BLAS_mkl_intel_lp64_LIBRARY
+BLAS_mkl_intel_lp64_LIBRARY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: BLAS_mkl_rt_LIBRARY
+BLAS_mkl_rt_LIBRARY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: BLAS_openblas_LIBRARY
+BLAS_openblas_LIBRARY-ADVANCED:INTERNAL=1
+//Have function sgemm_
+BLAS_openblas_WORKS:INTERNAL=1
+//ADVANCED property for variable: CMAKE_ADDR2LINE
+CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_AR
+CMAKE_AR-ADVANCED:INTERNAL=1
+//This is the directory where this CMakeCache.txt was created
+CMAKE_CACHEFILE_DIR:INTERNAL=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+//Major version of cmake used to create the current loaded cache
+CMAKE_CACHE_MAJOR_VERSION:INTERNAL=4
+//Minor version of cmake used to create the current loaded cache
+CMAKE_CACHE_MINOR_VERSION:INTERNAL=0
+//Patch version of cmake used to create the current loaded cache
+CMAKE_CACHE_PATCH_VERSION:INTERNAL=3
+//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
+CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
+//Path to CMake executable.
+CMAKE_COMMAND:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+//Path to cpack program executable.
+CMAKE_CPACK_COMMAND:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cpack
+//Path to ctest program executable.
+CMAKE_CTEST_COMMAND:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/ctest
+//ADVANCED property for variable: CMAKE_CXX_COMPILER
+CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR
+CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB
+CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS
+CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG
+CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL
+CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE
+CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO
+CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_COMPILER
+CMAKE_C_COMPILER-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_COMPILER_AR
+CMAKE_C_COMPILER_AR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_COMPILER_RANLIB
+CMAKE_C_COMPILER_RANLIB-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS
+CMAKE_C_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_DEBUG
+CMAKE_C_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_MINSIZEREL
+CMAKE_C_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_RELEASE
+CMAKE_C_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_C_FLAGS_RELWITHDEBINFO
+CMAKE_C_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_DLLTOOL
+CMAKE_DLLTOOL-ADVANCED:INTERNAL=1
+//Executable file format
+CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS
+CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG
+CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL
+CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE
+CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS
+CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1
+//Name of external makefile project generator.
+CMAKE_EXTRA_GENERATOR:INTERNAL=
+//Name of generator.
+CMAKE_GENERATOR:INTERNAL=Unix Makefiles
+//Generator instance identifier.
+CMAKE_GENERATOR_INSTANCE:INTERNAL=
+//Name of generator platform.
+CMAKE_GENERATOR_PLATFORM:INTERNAL=
+//Name of generator toolset.
+CMAKE_GENERATOR_TOOLSET:INTERNAL=
+//Test CMAKE_HAVE_LIBC_PTHREAD
+CMAKE_HAVE_LIBC_PTHREAD:INTERNAL=
+//Have library pthreads
+CMAKE_HAVE_PTHREADS_CREATE:INTERNAL=
+//Have library pthread
+CMAKE_HAVE_PTHREAD_CREATE:INTERNAL=1
+//Source directory with the top level CMakeLists.txt file for this
+// project
+CMAKE_HOME_DIRECTORY:INTERNAL=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+//ADVANCED property for variable: CMAKE_INSTALL_BINDIR
+CMAKE_INSTALL_BINDIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_DATADIR
+CMAKE_INSTALL_DATADIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_DATAROOTDIR
+CMAKE_INSTALL_DATAROOTDIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_DOCDIR
+CMAKE_INSTALL_DOCDIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_INCLUDEDIR
+CMAKE_INSTALL_INCLUDEDIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_INFODIR
+CMAKE_INSTALL_INFODIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_LIBDIR
+CMAKE_INSTALL_LIBDIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_LIBEXECDIR
+CMAKE_INSTALL_LIBEXECDIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_LOCALEDIR
+CMAKE_INSTALL_LOCALEDIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_LOCALSTATEDIR
+CMAKE_INSTALL_LOCALSTATEDIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_MANDIR
+CMAKE_INSTALL_MANDIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_OLDINCLUDEDIR
+CMAKE_INSTALL_OLDINCLUDEDIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_RUNSTATEDIR
+CMAKE_INSTALL_RUNSTATEDIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_SBINDIR
+CMAKE_INSTALL_SBINDIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_INSTALL_SHAREDSTATEDIR
+CMAKE_INSTALL_SHAREDSTATEDIR-ADVANCED:INTERNAL=1
+//Install .so files without execute permission.
+CMAKE_INSTALL_SO_NO_EXE:INTERNAL=0
+//ADVANCED property for variable: CMAKE_INSTALL_SYSCONFDIR
+CMAKE_INSTALL_SYSCONFDIR-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_LINKER
+CMAKE_LINKER-ADVANCED:INTERNAL=1
+//Name of CMakeLists files to read
+CMAKE_LIST_FILE_NAME:INTERNAL=CMakeLists.txt
+//ADVANCED property for variable: CMAKE_MAKE_PROGRAM
+CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS
+CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG
+CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL
+CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE
+CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_NM
+CMAKE_NM-ADVANCED:INTERNAL=1
+//number of local generators
+CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=13
+//ADVANCED property for variable: CMAKE_OBJCOPY
+CMAKE_OBJCOPY-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_OBJDUMP
+CMAKE_OBJDUMP-ADVANCED:INTERNAL=1
+//Platform information initialized
+CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_RANLIB
+CMAKE_RANLIB-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_READELF
+CMAKE_READELF-ADVANCED:INTERNAL=1
+//Path to CMake installation.
+CMAKE_ROOT:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS
+CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG
+CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL
+CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE
+CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH
+CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SKIP_RPATH
+CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS
+CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG
+CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL
+CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE
+CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO
+CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_STRIP
+CMAKE_STRIP-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_TAPI
+CMAKE_TAPI-ADVANCED:INTERNAL=1
+//uname command
+CMAKE_UNAME:INTERNAL=/usr/bin/uname
+//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE
+CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1
+//Details about finding BLAS
+FIND_PACKAGE_MESSAGE_DETAILS_BLAS:INTERNAL=[/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/libopenblas.so][v()]
+//Details about finding LAPACK
+FIND_PACKAGE_MESSAGE_DETAILS_LAPACK:INTERNAL=[/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/libopenblas.so;-lpthread;-lm;-ldl][v()]
+//Details about finding Python
+FIND_PACKAGE_MESSAGE_DETAILS_Python:INTERNAL=[/proj/cvl/users/x_fahkh2/envs/matagent/bin/python3.10][/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10][found components: Interpreter Development.Module ][v3.10.16(3.8)]
+//Details about finding Threads
+FIND_PACKAGE_MESSAGE_DETAILS_Threads:INTERNAL=[TRUE][v()]
+//ADVANCED property for variable: GIT_EXECUTABLE
+GIT_EXECUTABLE-ADVANCED:INTERNAL=1
+//Have function cheev_
+LAPACK_WORKS:INTERNAL=1
+NB_ABI:INTERNAL=310
+NB_DIR:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind
+NB_OPT:INTERNAL=$<OR:$<CONFIG:Release>,$<CONFIG:MinSizeRel>>
+NB_OPT_SIZE:INTERNAL=$<OR:$<CONFIG:Release>,$<CONFIG:MinSizeRel>,$<CONFIG:RelWithDebInfo>>
+NB_SUFFIX:INTERNAL=.cpython-310-x86_64-linux-gnu.so
+NB_SUFFIX_S:INTERNAL=.abi3.so
+NLOHMANN_JSON_CONFIG_INSTALL_DIR:INTERNAL=share/cmake/nlohmann_json
+//CMAKE_INSTALL_PREFIX during last run
+_GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX:INTERNAL=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx
+//Compiler reason failure
+_Python_Compiler_REASON_FAILURE:INTERNAL=
+_Python_DEVELOPMENT_MODULE_SIGNATURE:INTERNAL=cfa113e2483be64b45ef98c53556c452
+//Development reason failure
+_Python_Development_REASON_FAILURE:INTERNAL=
+//Path to a program.
+_Python_EXECUTABLE:INTERNAL=/proj/cvl/users/x_fahkh2/envs/matagent/bin/python3.10
+//Path to a file.
+_Python_INCLUDE_DIR:INTERNAL=/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10
+//Python Properties
+_Python_INTERPRETER_PROPERTIES:INTERNAL=Python;3;10;16;64;<none>;cpython-310-x86_64-linux-gnu;abi3;/proj/cvl/users/x_fahkh2/envs/matagent/lib/python3.10;/proj/cvl/users/x_fahkh2/envs/matagent/lib/python3.10;/proj/cvl/users/x_fahkh2/envs/matagent/lib/python3.10/site-packages;/proj/cvl/users/x_fahkh2/envs/matagent/lib/python3.10/site-packages
+_Python_INTERPRETER_SIGNATURE:INTERNAL=49adea9f1bb684c21f503b865c3939e5
+//Interpreter reason failure
+_Python_Interpreter_REASON_FAILURE:INTERNAL=
+//NumPy reason failure
+_Python_NumPy_REASON_FAILURE:INTERNAL=
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeCCompiler.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeCCompiler.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..2b0a0cdfa35dd3f649b4e2c105270ee6dc5b48ea
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeCCompiler.cmake
@@ -0,0 +1,84 @@
+set(CMAKE_C_COMPILER "/usr/bin/cc")
+set(CMAKE_C_COMPILER_ARG1 "")
+set(CMAKE_C_COMPILER_ID "GNU")
+set(CMAKE_C_COMPILER_VERSION "8.5.0")
+set(CMAKE_C_COMPILER_VERSION_INTERNAL "")
+set(CMAKE_C_COMPILER_WRAPPER "")
+set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "17")
+set(CMAKE_C_EXTENSIONS_COMPUTED_DEFAULT "ON")
+set(CMAKE_C_STANDARD_LATEST "17")
+set(CMAKE_C_COMPILE_FEATURES "c_std_90;c_function_prototypes;c_std_99;c_restrict;c_variadic_macros;c_std_11;c_static_assert;c_std_17")
+set(CMAKE_C90_COMPILE_FEATURES "c_std_90;c_function_prototypes")
+set(CMAKE_C99_COMPILE_FEATURES "c_std_99;c_restrict;c_variadic_macros")
+set(CMAKE_C11_COMPILE_FEATURES "c_std_11;c_static_assert")
+set(CMAKE_C17_COMPILE_FEATURES "c_std_17")
+set(CMAKE_C23_COMPILE_FEATURES "")
+
+set(CMAKE_C_PLATFORM_ID "Linux")
+set(CMAKE_C_SIMULATE_ID "")
+set(CMAKE_C_COMPILER_FRONTEND_VARIANT "GNU")
+set(CMAKE_C_COMPILER_APPLE_SYSROOT "")
+set(CMAKE_C_SIMULATE_VERSION "")
+
+
+
+
+set(CMAKE_AR "/usr/bin/ar")
+set(CMAKE_C_COMPILER_AR "/usr/bin/gcc-ar")
+set(CMAKE_RANLIB "/usr/bin/ranlib")
+set(CMAKE_C_COMPILER_RANLIB "/usr/bin/gcc-ranlib")
+set(CMAKE_LINKER "/usr/bin/ld")
+set(CMAKE_LINKER_LINK "")
+set(CMAKE_LINKER_LLD "")
+set(CMAKE_C_COMPILER_LINKER "/software/sse/manual/ld-wrapper/1.0/bin/ld")
+set(CMAKE_C_COMPILER_LINKER_ID "GNU")
+set(CMAKE_C_COMPILER_LINKER_VERSION 2.30)
+set(CMAKE_C_COMPILER_LINKER_FRONTEND_VARIANT GNU)
+set(CMAKE_MT "")
+set(CMAKE_TAPI "CMAKE_TAPI-NOTFOUND")
+set(CMAKE_COMPILER_IS_GNUCC 1)
+set(CMAKE_C_COMPILER_LOADED 1)
+set(CMAKE_C_COMPILER_WORKS TRUE)
+set(CMAKE_C_ABI_COMPILED TRUE)
+
+set(CMAKE_C_COMPILER_ENV_VAR "CC")
+
+set(CMAKE_C_COMPILER_ID_RUN 1)
+set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m)
+set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
+set(CMAKE_C_LINKER_PREFERENCE 10)
+set(CMAKE_C_LINKER_DEPFILE_SUPPORTED FALSE)
+set(CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED TRUE)
+set(CMAKE_C_LINKER_PUSHPOP_STATE_SUPPORTED TRUE)
+
+# Save compiler ABI information.
+set(CMAKE_C_SIZEOF_DATA_PTR "8")
+set(CMAKE_C_COMPILER_ABI "ELF")
+set(CMAKE_C_BYTE_ORDER "LITTLE_ENDIAN")
+set(CMAKE_C_LIBRARY_ARCHITECTURE "")
+
+if(CMAKE_C_SIZEOF_DATA_PTR)
+  set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}")
+endif()
+
+if(CMAKE_C_COMPILER_ABI)
+  set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}")
+endif()
+
+if(CMAKE_C_LIBRARY_ARCHITECTURE)
+  set(CMAKE_LIBRARY_ARCHITECTURE "")
+endif()
+
+set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "")
+if(CMAKE_C_CL_SHOWINCLUDES_PREFIX)
+  set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}")
+endif()
+
+
+
+
+
+set(CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES "/software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include;/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include;/software/sse/manual/CUDA/12.1.1_530.30.02/include;/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include;/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include;/software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include;/software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include;/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include;/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include;/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include;/software/sse/manual/GCC/12.3.0/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include;/usr/lib/gcc/x86_64-redhat-linux/8/include;/usr/local/include;/usr/include")
+set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "gcc;gcc_s;c;gcc;gcc_s")
+set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64;/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64;/software/sse/manual/GCC/12.3.0/lib64;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib64;/usr/lib/gcc/x86_64-redhat-linux/8;/usr/lib64;/lib64;/software/sse/manual/CUDA/12.1.1_530.30.02/lib64;/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib;/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib;/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib;/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib;/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib;/usr/lib")
+set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeCXXCompiler.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeCXXCompiler.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..0ecd1d71b8b5a39b5c4dadb883a21a526709664e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeCXXCompiler.cmake
@@ -0,0 +1,100 @@
+set(CMAKE_CXX_COMPILER "/usr/bin/c++")
+set(CMAKE_CXX_COMPILER_ARG1 "")
+set(CMAKE_CXX_COMPILER_ID "GNU")
+set(CMAKE_CXX_COMPILER_VERSION "8.5.0")
+set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "")
+set(CMAKE_CXX_COMPILER_WRAPPER "")
+set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "14")
+set(CMAKE_CXX_EXTENSIONS_COMPUTED_DEFAULT "ON")
+set(CMAKE_CXX_STANDARD_LATEST "20")
+set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20")
+set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters")
+set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates")
+set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates")
+set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17")
+set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20")
+set(CMAKE_CXX23_COMPILE_FEATURES "")
+set(CMAKE_CXX26_COMPILE_FEATURES "")
+
+set(CMAKE_CXX_PLATFORM_ID "Linux")
+set(CMAKE_CXX_SIMULATE_ID "")
+set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "GNU")
+set(CMAKE_CXX_COMPILER_APPLE_SYSROOT "")
+set(CMAKE_CXX_SIMULATE_VERSION "")
+
+
+
+
+set(CMAKE_AR "/usr/bin/ar")
+set(CMAKE_CXX_COMPILER_AR "/usr/bin/gcc-ar")
+set(CMAKE_RANLIB "/usr/bin/ranlib")
+set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/gcc-ranlib")
+set(CMAKE_LINKER "/usr/bin/ld")
+set(CMAKE_LINKER_LINK "")
+set(CMAKE_LINKER_LLD "")
+set(CMAKE_CXX_COMPILER_LINKER "/software/sse/manual/ld-wrapper/1.0/bin/ld")
+set(CMAKE_CXX_COMPILER_LINKER_ID "GNU")
+set(CMAKE_CXX_COMPILER_LINKER_VERSION 2.30)
+set(CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT GNU)
+set(CMAKE_MT "")
+set(CMAKE_TAPI "CMAKE_TAPI-NOTFOUND")
+set(CMAKE_COMPILER_IS_GNUCXX 1)
+set(CMAKE_CXX_COMPILER_LOADED 1)
+set(CMAKE_CXX_COMPILER_WORKS TRUE)
+set(CMAKE_CXX_ABI_COMPILED TRUE)
+
+set(CMAKE_CXX_COMPILER_ENV_VAR "CXX")
+
+set(CMAKE_CXX_COMPILER_ID_RUN 1)
+set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP;ixx;cppm;ccm;cxxm;c++m)
+set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC)
+
+foreach (lang IN ITEMS C OBJC OBJCXX)
+  if (CMAKE_${lang}_COMPILER_ID_RUN)
+    foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS)
+      list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension})
+    endforeach()
+  endif()
+endforeach()
+
+set(CMAKE_CXX_LINKER_PREFERENCE 30)
+set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1)
+set(CMAKE_CXX_LINKER_DEPFILE_SUPPORTED FALSE)
+set(CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED TRUE)
+set(CMAKE_CXX_LINKER_PUSHPOP_STATE_SUPPORTED TRUE)
+
+# Save compiler ABI information.
+set(CMAKE_CXX_SIZEOF_DATA_PTR "8")
+set(CMAKE_CXX_COMPILER_ABI "ELF")
+set(CMAKE_CXX_BYTE_ORDER "LITTLE_ENDIAN")
+set(CMAKE_CXX_LIBRARY_ARCHITECTURE "")
+
+if(CMAKE_CXX_SIZEOF_DATA_PTR)
+  set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}")
+endif()
+
+if(CMAKE_CXX_COMPILER_ABI)
+  set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}")
+endif()
+
+if(CMAKE_CXX_LIBRARY_ARCHITECTURE)
+  set(CMAKE_LIBRARY_ARCHITECTURE "")
+endif()
+
+set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "")
+if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX)
+  set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}")
+endif()
+
+
+
+
+
+set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "/software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include;/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include;/software/sse/manual/CUDA/12.1.1_530.30.02/include;/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include;/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include;/software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include;/software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include;/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include;/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include;/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include;/software/sse/manual/GCC/12.3.0/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include;/usr/include/c++/8;/usr/include/c++/8/x86_64-redhat-linux;/usr/include/c++/8/backward;/usr/lib/gcc/x86_64-redhat-linux/8/include;/usr/local/include;/usr/include")
+set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;gcc_s;gcc;c;gcc_s;gcc")
+set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64;/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64;/software/sse/manual/GCC/12.3.0/lib64;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib64;/usr/lib/gcc/x86_64-redhat-linux/8;/usr/lib64;/lib64;/software/sse/manual/CUDA/12.1.1_530.30.02/lib64;/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib;/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib;/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib;/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib;/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib;/usr/lib")
+set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")
+set(CMAKE_CXX_COMPILER_CLANG_RESOURCE_DIR "")
+
+set(CMAKE_CXX_COMPILER_IMPORT_STD "")
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeDetermineCompilerABI_C.bin b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeDetermineCompilerABI_C.bin
new file mode 100644
index 0000000000000000000000000000000000000000..6bec91a397c48a6a1115c49b082ead2eefeed589
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeDetermineCompilerABI_C.bin
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93064b030ba1ef23a5d16a9bc4c03d23cdc58c33feafe6d72ddef0aa03821211
+size 22192
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeDetermineCompilerABI_CXX.bin b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeDetermineCompilerABI_CXX.bin
new file mode 100644
index 0000000000000000000000000000000000000000..1b7bef74c2c75437ab34589df3433e73a205451d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeDetermineCompilerABI_CXX.bin
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:536b3135411120c8b723c32f12844d7a54d0b9000200418847adee96d6aa7d19
+size 22216
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeSystem.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeSystem.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..6ac4680931858770a602d316fb4a5f01540d588e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CMakeSystem.cmake
@@ -0,0 +1,15 @@
+set(CMAKE_HOST_SYSTEM "Linux-4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_HOST_SYSTEM_NAME "Linux")
+set(CMAKE_HOST_SYSTEM_VERSION "4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
+
+
+
+set(CMAKE_SYSTEM "Linux-4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_SYSTEM_VERSION "4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_SYSTEM_PROCESSOR "x86_64")
+
+set(CMAKE_CROSSCOMPILING "FALSE")
+
+set(CMAKE_SYSTEM_LOADED 1)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdC/CMakeCCompilerId.c b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdC/CMakeCCompilerId.c
new file mode 100644
index 0000000000000000000000000000000000000000..a842bb69258715b9ea00ac54551effc89434f8da
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdC/CMakeCCompilerId.c
@@ -0,0 +1,905 @@
+#ifdef __cplusplus
+# error "A C++ compiler has been selected for C."
+#endif
+
+#if defined(__18CXX)
+# define ID_VOID_MAIN
+#endif
+#if defined(__CLASSIC_C__)
+/* cv-qualifiers did not exist in K&R C */
+# define const
+# define volatile
+#endif
+
+#if !defined(__has_include)
+/* If the compiler does not have __has_include, pretend the answer is
+   always no.  */
+#  define __has_include(x) 0
+#endif
+
+
+/* Version number components: V=Version, R=Revision, P=Patch
+   Version date components:   YYYY=Year, MM=Month,   DD=Day  */
+
+#if defined(__INTEL_COMPILER) || defined(__ICC)
+# define COMPILER_ID "Intel"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_ID "GNU"
+# endif
+  /* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later,
+     except that a few beta releases use the old format with V=2021.  */
+# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111
+#  define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
+#  define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
+#  if defined(__INTEL_COMPILER_UPDATE)
+#   define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
+#  else
+#   define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER   % 10)
+#  endif
+# else
+#  define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER)
+#  define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE)
+   /* The third version component from --version is an update index,
+      but no macro is provided for it.  */
+#  define COMPILER_VERSION_PATCH DEC(0)
+# endif
+# if defined(__INTEL_COMPILER_BUILD_DATE)
+   /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
+#  define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
+# endif
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+# elif defined(__GNUG__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER)
+# define COMPILER_ID "IntelLLVM"
+#if defined(_MSC_VER)
+# define SIMULATE_ID "MSVC"
+#endif
+#if defined(__GNUC__)
+# define SIMULATE_ID "GNU"
+#endif
+/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and
+ * later.  Look for 6 digit vs. 8 digit version number to decide encoding.
+ * VVVV is no smaller than the current year when a version is released.
+ */
+#if __INTEL_LLVM_COMPILER < 1000000L
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER    % 10)
+#else
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100)
+# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER     % 100)
+#endif
+#if defined(_MSC_VER)
+  /* _MSC_VER = VVRR */
+# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+#endif
+#if defined(__GNUC__)
+# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+#elif defined(__GNUG__)
+# define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
+#endif
+#if defined(__GNUC_MINOR__)
+# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+#endif
+#if defined(__GNUC_PATCHLEVEL__)
+# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+#endif
+
+#elif defined(__PATHCC__)
+# define COMPILER_ID "PathScale"
+# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
+# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
+# if defined(__PATHCC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
+# endif
+
+#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
+# define COMPILER_ID "Embarcadero"
+# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
+# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
+# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__     & 0xFFFF)
+
+#elif defined(__BORLANDC__)
+# define COMPILER_ID "Borland"
+  /* __BORLANDC__ = 0xVRR */
+# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
+# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
+
+#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
+# define COMPILER_ID "Watcom"
+   /* __WATCOMC__ = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__WATCOMC__)
+# define COMPILER_ID "OpenWatcom"
+   /* __WATCOMC__ = VVRP + 1100 */
+# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__SUNPRO_C)
+# define COMPILER_ID "SunPro"
+# if __SUNPRO_C >= 0x5100
+   /* __SUNPRO_C = 0xVRRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>12)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xFF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_C    & 0xF)
+# else
+   /* __SUNPRO_CC = 0xVRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>8)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_C    & 0xF)
+# endif
+
+#elif defined(__HP_cc)
+# define COMPILER_ID "HP"
+  /* __HP_cc = VVRRPP */
+# define COMPILER_VERSION_MAJOR DEC(__HP_cc/10000)
+# define COMPILER_VERSION_MINOR DEC(__HP_cc/100 % 100)
+# define COMPILER_VERSION_PATCH DEC(__HP_cc     % 100)
+
+#elif defined(__DECC)
+# define COMPILER_ID "Compaq"
+  /* __DECC_VER = VVRRTPPPP */
+# define COMPILER_VERSION_MAJOR DEC(__DECC_VER/10000000)
+# define COMPILER_VERSION_MINOR DEC(__DECC_VER/100000  % 100)
+# define COMPILER_VERSION_PATCH DEC(__DECC_VER         % 10000)
+
+#elif defined(__IBMC__) && defined(__COMPILER_VER__)
+# define COMPILER_ID "zOS"
+  /* __IBMC__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+
+#elif defined(__open_xl__) && defined(__clang__)
+# define COMPILER_ID "IBMClang"
+# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__)
+# define COMPILER_VERSION_MINOR DEC(__open_xl_release__)
+# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__)
+# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__)
+# define COMPILER_VERSION_INTERNAL_STR  __clang_version__
+
+
+#elif defined(__ibmxl__) && defined(__clang__)
+# define COMPILER_ID "XLClang"
+# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
+# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
+# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
+# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
+
+
+#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ >= 800
+# define COMPILER_ID "XL"
+  /* __IBMC__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+
+#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ < 800
+# define COMPILER_ID "VisualAge"
+  /* __IBMC__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMC__    % 10)
+
+#elif defined(__NVCOMPILER)
+# define COMPILER_ID "NVHPC"
+# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__)
+# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__)
+# if defined(__NVCOMPILER_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__)
+# endif
+
+#elif defined(__PGI)
+# define COMPILER_ID "PGI"
+# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
+# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
+# if defined(__PGIC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
+# endif
+
+#elif defined(__clang__) && defined(__cray__)
+# define COMPILER_ID "CrayClang"
+# define COMPILER_VERSION_MAJOR DEC(__cray_major__)
+# define COMPILER_VERSION_MINOR DEC(__cray_minor__)
+# define COMPILER_VERSION_PATCH DEC(__cray_patchlevel__)
+# define COMPILER_VERSION_INTERNAL_STR __clang_version__
+
+
+#elif defined(_CRAYC)
+# define COMPILER_ID "Cray"
+# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
+# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
+
+#elif defined(__TI_COMPILER_VERSION__)
+# define COMPILER_ID "TI"
+  /* __TI_COMPILER_VERSION__ = VVVRRRPPP */
+# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
+# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000   % 1000)
+# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__        % 1000)
+
+#elif defined(__CLANG_FUJITSU)
+# define COMPILER_ID "FujitsuClang"
+# define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
+# define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
+# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
+# define COMPILER_VERSION_INTERNAL_STR __clang_version__
+
+
+#elif defined(__FUJITSU)
+# define COMPILER_ID "Fujitsu"
+# if defined(__FCC_version__)
+#   define COMPILER_VERSION __FCC_version__
+# elif defined(__FCC_major__)
+#   define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
+#   define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
+#   define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
+# endif
+# if defined(__fcc_version)
+#   define COMPILER_VERSION_INTERNAL DEC(__fcc_version)
+# elif defined(__FCC_VERSION)
+#   define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION)
+# endif
+
+
+#elif defined(__ghs__)
+# define COMPILER_ID "GHS"
+/* __GHS_VERSION_NUMBER = VVVVRP */
+# ifdef __GHS_VERSION_NUMBER
+# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
+# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER      % 10)
+# endif
+
+#elif defined(__TASKING__)
+# define COMPILER_ID "Tasking"
+  # define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000)
+  # define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100)
+# define COMPILER_VERSION_INTERNAL DEC(__VERSION__)
+
+#elif defined(__ORANGEC__)
+# define COMPILER_ID "OrangeC"
+# define COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__)
+# define COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__)
+# define COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__)
+
+#elif defined(__TINYC__)
+# define COMPILER_ID "TinyCC"
+
+#elif defined(__BCC__)
+# define COMPILER_ID "Bruce"
+
+#elif defined(__SCO_VERSION__)
+# define COMPILER_ID "SCO"
+
+#elif defined(__ARMCC_VERSION) && !defined(__clang__)
+# define COMPILER_ID "ARMCC"
+#if __ARMCC_VERSION >= 1000000
+  /* __ARMCC_VERSION = VRRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION     % 10000)
+#else
+  /* __ARMCC_VERSION = VRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION    % 10000)
+#endif
+
+
+#elif defined(__clang__) && defined(__apple_build_version__)
+# define COMPILER_ID "AppleClang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
+
+#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
+# define COMPILER_ID "ARMClang"
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100   % 100)
+# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
+
+#elif defined(__clang__) && defined(__ti__)
+# define COMPILER_ID "TIClang"
+  # define COMPILER_VERSION_MAJOR DEC(__ti_major__)
+  # define COMPILER_VERSION_MINOR DEC(__ti_minor__)
+  # define COMPILER_VERSION_PATCH DEC(__ti_patchlevel__)
+# define COMPILER_VERSION_INTERNAL DEC(__ti_version__)
+
+#elif defined(__clang__)
+# define COMPILER_ID "Clang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+
+#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__))
+# define COMPILER_ID "LCC"
+# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100)
+# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100)
+# if defined(__LCC_MINOR__)
+#  define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__)
+# endif
+# if defined(__GNUC__) && defined(__GNUC_MINOR__)
+#  define SIMULATE_ID "GNU"
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+#  define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+#  if defined(__GNUC_PATCHLEVEL__)
+#   define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+#  endif
+# endif
+
+#elif defined(__GNUC__)
+# define COMPILER_ID "GNU"
+# define COMPILER_VERSION_MAJOR DEC(__GNUC__)
+# if defined(__GNUC_MINOR__)
+#  define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(_MSC_VER)
+# define COMPILER_ID "MSVC"
+  /* _MSC_VER = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
+# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
+# if defined(_MSC_FULL_VER)
+#  if _MSC_VER >= 1400
+    /* _MSC_FULL_VER = VVRRPPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
+#  else
+    /* _MSC_FULL_VER = VVRRPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
+#  endif
+# endif
+# if defined(_MSC_BUILD)
+#  define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
+# endif
+
+#elif defined(_ADI_COMPILER)
+# define COMPILER_ID "ADSP"
+#if defined(__VERSIONNUM__)
+  /* __VERSIONNUM__ = 0xVVRRPPTT */
+#  define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF)
+#  define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF)
+#  define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF)
+#  define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF)
+#endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# define COMPILER_ID "IAR"
+# if defined(__VER__) && defined(__ICCARM__)
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
+#  define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
+#  define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__))
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
+#  define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
+#  define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# endif
+
+#elif defined(__SDCC_VERSION_MAJOR) || defined(SDCC)
+# define COMPILER_ID "SDCC"
+# if defined(__SDCC_VERSION_MAJOR)
+#  define COMPILER_VERSION_MAJOR DEC(__SDCC_VERSION_MAJOR)
+#  define COMPILER_VERSION_MINOR DEC(__SDCC_VERSION_MINOR)
+#  define COMPILER_VERSION_PATCH DEC(__SDCC_VERSION_PATCH)
+# else
+  /* SDCC = VRP */
+#  define COMPILER_VERSION_MAJOR DEC(SDCC/100)
+#  define COMPILER_VERSION_MINOR DEC(SDCC/10 % 10)
+#  define COMPILER_VERSION_PATCH DEC(SDCC    % 10)
+# endif
+
+
+/* These compilers are either not known or too old to define an
+  identification macro.  Try to identify the platform and guess that
+  it is the native compiler.  */
+#elif defined(__hpux) || defined(__hpua)
+# define COMPILER_ID "HP"
+
+#else /* unknown compiler */
+# define COMPILER_ID ""
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
+#ifdef SIMULATE_ID
+char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
+#endif
+
+#ifdef __QNXNTO__
+char const* qnxnto = "INFO" ":" "qnxnto[]";
+#endif
+
+#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
+char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
+#endif
+
+#define STRINGIFY_HELPER(X) #X
+#define STRINGIFY(X) STRINGIFY_HELPER(X)
+
+/* Identify known platforms by name.  */
+#if defined(__linux) || defined(__linux__) || defined(linux)
+# define PLATFORM_ID "Linux"
+
+#elif defined(__MSYS__)
+# define PLATFORM_ID "MSYS"
+
+#elif defined(__CYGWIN__)
+# define PLATFORM_ID "Cygwin"
+
+#elif defined(__MINGW32__)
+# define PLATFORM_ID "MinGW"
+
+#elif defined(__APPLE__)
+# define PLATFORM_ID "Darwin"
+
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+# define PLATFORM_ID "Windows"
+
+#elif defined(__FreeBSD__) || defined(__FreeBSD)
+# define PLATFORM_ID "FreeBSD"
+
+#elif defined(__NetBSD__) || defined(__NetBSD)
+# define PLATFORM_ID "NetBSD"
+
+#elif defined(__OpenBSD__) || defined(__OPENBSD)
+# define PLATFORM_ID "OpenBSD"
+
+#elif defined(__sun) || defined(sun)
+# define PLATFORM_ID "SunOS"
+
+#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
+# define PLATFORM_ID "AIX"
+
+#elif defined(__hpux) || defined(__hpux__)
+# define PLATFORM_ID "HP-UX"
+
+#elif defined(__HAIKU__)
+# define PLATFORM_ID "Haiku"
+
+#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
+# define PLATFORM_ID "BeOS"
+
+#elif defined(__QNX__) || defined(__QNXNTO__)
+# define PLATFORM_ID "QNX"
+
+#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
+# define PLATFORM_ID "Tru64"
+
+#elif defined(__riscos) || defined(__riscos__)
+# define PLATFORM_ID "RISCos"
+
+#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
+# define PLATFORM_ID "SINIX"
+
+#elif defined(__UNIX_SV__)
+# define PLATFORM_ID "UNIX_SV"
+
+#elif defined(__bsdos__)
+# define PLATFORM_ID "BSDOS"
+
+#elif defined(_MPRAS) || defined(MPRAS)
+# define PLATFORM_ID "MP-RAS"
+
+#elif defined(__osf) || defined(__osf__)
+# define PLATFORM_ID "OSF1"
+
+#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
+# define PLATFORM_ID "SCO_SV"
+
+#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
+# define PLATFORM_ID "ULTRIX"
+
+#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
+# define PLATFORM_ID "Xenix"
+
+#elif defined(__WATCOMC__)
+# if defined(__LINUX__)
+#  define PLATFORM_ID "Linux"
+
+# elif defined(__DOS__)
+#  define PLATFORM_ID "DOS"
+
+# elif defined(__OS2__)
+#  define PLATFORM_ID "OS2"
+
+# elif defined(__WINDOWS__)
+#  define PLATFORM_ID "Windows3x"
+
+# elif defined(__VXWORKS__)
+#  define PLATFORM_ID "VxWorks"
+
+# else /* unknown platform */
+#  define PLATFORM_ID
+# endif
+
+#elif defined(__INTEGRITY)
+# if defined(INT_178B)
+#  define PLATFORM_ID "Integrity178"
+
+# else /* regular Integrity */
+#  define PLATFORM_ID "Integrity"
+# endif
+
+# elif defined(_ADI_COMPILER)
+#  define PLATFORM_ID "ADSP"
+
+#else /* unknown platform */
+# define PLATFORM_ID
+
+#endif
+
+/* For windows compilers MSVC and Intel we can determine
+   the architecture of the compiler being used.  This is because
+   the compilers do not have flags that can change the architecture,
+   but rather depend on which compiler is being used
+*/
+#if defined(_WIN32) && defined(_MSC_VER)
+# if defined(_M_IA64)
+#  define ARCHITECTURE_ID "IA64"
+
+# elif defined(_M_ARM64EC)
+#  define ARCHITECTURE_ID "ARM64EC"
+
+# elif defined(_M_X64) || defined(_M_AMD64)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# elif defined(_M_ARM64)
+#  define ARCHITECTURE_ID "ARM64"
+
+# elif defined(_M_ARM)
+#  if _M_ARM == 4
+#   define ARCHITECTURE_ID "ARMV4I"
+#  elif _M_ARM == 5
+#   define ARCHITECTURE_ID "ARMV5I"
+#  else
+#   define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
+#  endif
+
+# elif defined(_M_MIPS)
+#  define ARCHITECTURE_ID "MIPS"
+
+# elif defined(_M_SH)
+#  define ARCHITECTURE_ID "SHx"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__WATCOMC__)
+# if defined(_M_I86)
+#  define ARCHITECTURE_ID "I86"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# if defined(__ICCARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__ICCRX__)
+#  define ARCHITECTURE_ID "RX"
+
+# elif defined(__ICCRH850__)
+#  define ARCHITECTURE_ID "RH850"
+
+# elif defined(__ICCRL78__)
+#  define ARCHITECTURE_ID "RL78"
+
+# elif defined(__ICCRISCV__)
+#  define ARCHITECTURE_ID "RISCV"
+
+# elif defined(__ICCAVR__)
+#  define ARCHITECTURE_ID "AVR"
+
+# elif defined(__ICC430__)
+#  define ARCHITECTURE_ID "MSP430"
+
+# elif defined(__ICCV850__)
+#  define ARCHITECTURE_ID "V850"
+
+# elif defined(__ICC8051__)
+#  define ARCHITECTURE_ID "8051"
+
+# elif defined(__ICCSTM8__)
+#  define ARCHITECTURE_ID "STM8"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__ghs__)
+# if defined(__PPC64__)
+#  define ARCHITECTURE_ID "PPC64"
+
+# elif defined(__ppc__)
+#  define ARCHITECTURE_ID "PPC"
+
+# elif defined(__ARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__x86_64__)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(__i386__)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__clang__) && defined(__ti__)
+# if defined(__ARM_ARCH)
+#  define ARCHITECTURE_ID "ARM"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__TI_COMPILER_VERSION__)
+# if defined(__TI_ARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__MSP430__)
+#  define ARCHITECTURE_ID "MSP430"
+
+# elif defined(__TMS320C28XX__)
+#  define ARCHITECTURE_ID "TMS320C28x"
+
+# elif defined(__TMS320C6X__) || defined(_TMS320C6X)
+#  define ARCHITECTURE_ID "TMS320C6x"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+# elif defined(__ADSPSHARC__)
+#  define ARCHITECTURE_ID "SHARC"
+
+# elif defined(__ADSPBLACKFIN__)
+#  define ARCHITECTURE_ID "Blackfin"
+
+#elif defined(__TASKING__)
+
+# if defined(__CTC__) || defined(__CPTC__)
+#  define ARCHITECTURE_ID "TriCore"
+
+# elif defined(__CMCS__)
+#  define ARCHITECTURE_ID "MCS"
+
+# elif defined(__CARM__) || defined(__CPARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__CARC__)
+#  define ARCHITECTURE_ID "ARC"
+
+# elif defined(__C51__)
+#  define ARCHITECTURE_ID "8051"
+
+# elif defined(__CPCP__)
+#  define ARCHITECTURE_ID "PCP"
+
+# else
+#  define ARCHITECTURE_ID ""
+# endif
+
+#else
+#  define ARCHITECTURE_ID
+#endif
+
+/* Convert integer to decimal digit literals.  */
+#define DEC(n)                   \
+  ('0' + (((n) / 10000000)%10)), \
+  ('0' + (((n) / 1000000)%10)),  \
+  ('0' + (((n) / 100000)%10)),   \
+  ('0' + (((n) / 10000)%10)),    \
+  ('0' + (((n) / 1000)%10)),     \
+  ('0' + (((n) / 100)%10)),      \
+  ('0' + (((n) / 10)%10)),       \
+  ('0' +  ((n) % 10))
+
+/* Convert integer to hex digit literals.  */
+#define HEX(n)             \
+  ('0' + ((n)>>28 & 0xF)), \
+  ('0' + ((n)>>24 & 0xF)), \
+  ('0' + ((n)>>20 & 0xF)), \
+  ('0' + ((n)>>16 & 0xF)), \
+  ('0' + ((n)>>12 & 0xF)), \
+  ('0' + ((n)>>8  & 0xF)), \
+  ('0' + ((n)>>4  & 0xF)), \
+  ('0' + ((n)     & 0xF))
+
+/* Construct a string literal encoding the version number. */
+#ifdef COMPILER_VERSION
+char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]";
+
+/* Construct a string literal encoding the version number components. */
+#elif defined(COMPILER_VERSION_MAJOR)
+char const info_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
+  COMPILER_VERSION_MAJOR,
+# ifdef COMPILER_VERSION_MINOR
+  '.', COMPILER_VERSION_MINOR,
+#  ifdef COMPILER_VERSION_PATCH
+   '.', COMPILER_VERSION_PATCH,
+#   ifdef COMPILER_VERSION_TWEAK
+    '.', COMPILER_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct a string literal encoding the internal version number. */
+#ifdef COMPILER_VERSION_INTERNAL
+char const info_version_internal[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
+  'i','n','t','e','r','n','a','l','[',
+  COMPILER_VERSION_INTERNAL,']','\0'};
+#elif defined(COMPILER_VERSION_INTERNAL_STR)
+char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]";
+#endif
+
+/* Construct a string literal encoding the version number components. */
+#ifdef SIMULATE_VERSION_MAJOR
+char const info_simulate_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
+  SIMULATE_VERSION_MAJOR,
+# ifdef SIMULATE_VERSION_MINOR
+  '.', SIMULATE_VERSION_MINOR,
+#  ifdef SIMULATE_VERSION_PATCH
+   '.', SIMULATE_VERSION_PATCH,
+#   ifdef SIMULATE_VERSION_TWEAK
+    '.', SIMULATE_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
+char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
+
+
+
+#define C_STD_99 199901L
+#define C_STD_11 201112L
+#define C_STD_17 201710L
+#define C_STD_23 202311L
+
+#ifdef __STDC_VERSION__
+#  define C_STD __STDC_VERSION__
+#endif
+
+#if !defined(__STDC__) && !defined(__clang__)
+# if defined(_MSC_VER) || defined(__ibmxl__) || defined(__IBMC__)
+#  define C_VERSION "90"
+# else
+#  define C_VERSION
+# endif
+#elif C_STD > C_STD_17
+# define C_VERSION "23"
+#elif C_STD > C_STD_11
+# define C_VERSION "17"
+#elif C_STD > C_STD_99
+# define C_VERSION "11"
+#elif C_STD >= C_STD_99
+# define C_VERSION "99"
+#else
+# define C_VERSION "90"
+#endif
+const char* info_language_standard_default =
+  "INFO" ":" "standard_default[" C_VERSION "]";
+
+const char* info_language_extensions_default = "INFO" ":" "extensions_default["
+#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) ||           \
+     defined(__TI_COMPILER_VERSION__)) &&                                     \
+  !defined(__STRICT_ANSI__)
+  "ON"
+#else
+  "OFF"
+#endif
+"]";
+
+/*--------------------------------------------------------------------------*/
+
+#ifdef ID_VOID_MAIN
+void main() {}
+#else
+# if defined(__CLASSIC_C__)
+int main(argc, argv) int argc; char *argv[];
+# else
+int main(int argc, char* argv[])
+# endif
+{
+  int require = 0;
+  require += info_compiler[argc];
+  require += info_platform[argc];
+  require += info_arch[argc];
+#ifdef COMPILER_VERSION_MAJOR
+  require += info_version[argc];
+#endif
+#if defined(COMPILER_VERSION_INTERNAL) || defined(COMPILER_VERSION_INTERNAL_STR)
+  require += info_version_internal[argc];
+#endif
+#ifdef SIMULATE_ID
+  require += info_simulate[argc];
+#endif
+#ifdef SIMULATE_VERSION_MAJOR
+  require += info_simulate_version[argc];
+#endif
+#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
+  require += info_cray[argc];
+#endif
+  require += info_language_standard_default[argc];
+  require += info_language_extensions_default[argc];
+  (void)argv;
+  return require;
+}
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdC/a.out b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdC/a.out
new file mode 100644
index 0000000000000000000000000000000000000000..725c50fcb22460ef9c1fd72afe3bf524ca4071f4
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdC/a.out differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdCXX/CMakeCXXCompilerId.cpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdCXX/CMakeCXXCompilerId.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..94d431033a15ab5de08da642933e1e59e0cae1a4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdCXX/CMakeCXXCompilerId.cpp
@@ -0,0 +1,920 @@
+/* This source file must have a .cpp extension so that all C++ compilers
+   recognize the extension without flags.  Borland does not know .cxx for
+   example.  */
+#ifndef __cplusplus
+# error "A C compiler has been selected for C++."
+#endif
+
+#if !defined(__has_include)
+/* If the compiler does not have __has_include, pretend the answer is
+   always no.  */
+#  define __has_include(x) 0
+#endif
+
+
+/* Version number components: V=Version, R=Revision, P=Patch
+   Version date components:   YYYY=Year, MM=Month,   DD=Day  */
+
+#if defined(__INTEL_COMPILER) || defined(__ICC)
+# define COMPILER_ID "Intel"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_ID "GNU"
+# endif
+  /* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later,
+     except that a few beta releases use the old format with V=2021.  */
+# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111
+#  define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
+#  define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
+#  if defined(__INTEL_COMPILER_UPDATE)
+#   define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
+#  else
+#   define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER   % 10)
+#  endif
+# else
+#  define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER)
+#  define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE)
+   /* The third version component from --version is an update index,
+      but no macro is provided for it.  */
+#  define COMPILER_VERSION_PATCH DEC(0)
+# endif
+# if defined(__INTEL_COMPILER_BUILD_DATE)
+   /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
+#  define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
+# endif
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# if defined(__GNUC__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+# elif defined(__GNUG__)
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER)
+# define COMPILER_ID "IntelLLVM"
+#if defined(_MSC_VER)
+# define SIMULATE_ID "MSVC"
+#endif
+#if defined(__GNUC__)
+# define SIMULATE_ID "GNU"
+#endif
+/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and
+ * later.  Look for 6 digit vs. 8 digit version number to decide encoding.
+ * VVVV is no smaller than the current year when a version is released.
+ */
+#if __INTEL_LLVM_COMPILER < 1000000L
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER    % 10)
+#else
+# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000)
+# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100)
+# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER     % 100)
+#endif
+#if defined(_MSC_VER)
+  /* _MSC_VER = VVRR */
+# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+#endif
+#if defined(__GNUC__)
+# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+#elif defined(__GNUG__)
+# define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
+#endif
+#if defined(__GNUC_MINOR__)
+# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+#endif
+#if defined(__GNUC_PATCHLEVEL__)
+# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+#endif
+
+#elif defined(__PATHCC__)
+# define COMPILER_ID "PathScale"
+# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
+# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
+# if defined(__PATHCC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
+# endif
+
+#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
+# define COMPILER_ID "Embarcadero"
+# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
+# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
+# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__     & 0xFFFF)
+
+#elif defined(__BORLANDC__)
+# define COMPILER_ID "Borland"
+  /* __BORLANDC__ = 0xVRR */
+# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
+# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
+
+#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
+# define COMPILER_ID "Watcom"
+   /* __WATCOMC__ = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__WATCOMC__)
+# define COMPILER_ID "OpenWatcom"
+   /* __WATCOMC__ = VVRP + 1100 */
+# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
+# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
+# if (__WATCOMC__ % 10) > 0
+#  define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
+# endif
+
+#elif defined(__SUNPRO_CC)
+# define COMPILER_ID "SunPro"
+# if __SUNPRO_CC >= 0x5100
+   /* __SUNPRO_CC = 0xVRRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC    & 0xF)
+# else
+   /* __SUNPRO_CC = 0xVRP */
+#  define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8)
+#  define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF)
+#  define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC    & 0xF)
+# endif
+
+#elif defined(__HP_aCC)
+# define COMPILER_ID "HP"
+  /* __HP_aCC = VVRRPP */
+# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000)
+# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100)
+# define COMPILER_VERSION_PATCH DEC(__HP_aCC     % 100)
+
+#elif defined(__DECCXX)
+# define COMPILER_ID "Compaq"
+  /* __DECCXX_VER = VVRRTPPPP */
+# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000)
+# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000  % 100)
+# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER         % 10000)
+
+#elif defined(__IBMCPP__) && defined(__COMPILER_VER__)
+# define COMPILER_ID "zOS"
+  /* __IBMCPP__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMCPP__    % 10)
+
+#elif defined(__open_xl__) && defined(__clang__)
+# define COMPILER_ID "IBMClang"
+# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__)
+# define COMPILER_VERSION_MINOR DEC(__open_xl_release__)
+# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__)
+# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__)
+# define COMPILER_VERSION_INTERNAL_STR  __clang_version__
+
+
+#elif defined(__ibmxl__) && defined(__clang__)
+# define COMPILER_ID "XLClang"
+# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
+# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
+# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
+# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
+
+
+#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800
+# define COMPILER_ID "XL"
+  /* __IBMCPP__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMCPP__    % 10)
+
+#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800
+# define COMPILER_ID "VisualAge"
+  /* __IBMCPP__ = VRP */
+# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
+# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__IBMCPP__    % 10)
+
+#elif defined(__NVCOMPILER)
+# define COMPILER_ID "NVHPC"
+# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__)
+# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__)
+# if defined(__NVCOMPILER_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__)
+# endif
+
+#elif defined(__PGI)
+# define COMPILER_ID "PGI"
+# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
+# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
+# if defined(__PGIC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
+# endif
+
+#elif defined(__clang__) && defined(__cray__)
+# define COMPILER_ID "CrayClang"
+# define COMPILER_VERSION_MAJOR DEC(__cray_major__)
+# define COMPILER_VERSION_MINOR DEC(__cray_minor__)
+# define COMPILER_VERSION_PATCH DEC(__cray_patchlevel__)
+# define COMPILER_VERSION_INTERNAL_STR __clang_version__
+
+
+#elif defined(_CRAYC)
+# define COMPILER_ID "Cray"
+# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
+# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
+
+#elif defined(__TI_COMPILER_VERSION__)
+# define COMPILER_ID "TI"
+  /* __TI_COMPILER_VERSION__ = VVVRRRPPP */
+# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
+# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000   % 1000)
+# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__        % 1000)
+
+#elif defined(__CLANG_FUJITSU)
+# define COMPILER_ID "FujitsuClang"
+# define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
+# define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
+# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
+# define COMPILER_VERSION_INTERNAL_STR __clang_version__
+
+
+#elif defined(__FUJITSU)
+# define COMPILER_ID "Fujitsu"
+# if defined(__FCC_version__)
+#   define COMPILER_VERSION __FCC_version__
+# elif defined(__FCC_major__)
+#   define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
+#   define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
+#   define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
+# endif
+# if defined(__fcc_version)
+#   define COMPILER_VERSION_INTERNAL DEC(__fcc_version)
+# elif defined(__FCC_VERSION)
+#   define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION)
+# endif
+
+
+#elif defined(__ghs__)
+# define COMPILER_ID "GHS"
+/* __GHS_VERSION_NUMBER = VVVVRP */
+# ifdef __GHS_VERSION_NUMBER
+# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
+# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
+# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER      % 10)
+# endif
+
+#elif defined(__TASKING__)
+# define COMPILER_ID "Tasking"
+  # define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000)
+  # define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100)
+# define COMPILER_VERSION_INTERNAL DEC(__VERSION__)
+
+#elif defined(__ORANGEC__)
+# define COMPILER_ID "OrangeC"
+# define COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__)
+# define COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__)
+# define COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__)
+
+#elif defined(__SCO_VERSION__)
+# define COMPILER_ID "SCO"
+
+#elif defined(__ARMCC_VERSION) && !defined(__clang__)
+# define COMPILER_ID "ARMCC"
+#if __ARMCC_VERSION >= 1000000
+  /* __ARMCC_VERSION = VRRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION     % 10000)
+#else
+  /* __ARMCC_VERSION = VRPPPP */
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION    % 10000)
+#endif
+
+
+#elif defined(__clang__) && defined(__apple_build_version__)
+# define COMPILER_ID "AppleClang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
+
+#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
+# define COMPILER_ID "ARMClang"
+  # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
+  # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
+  # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100   % 100)
+# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
+
+#elif defined(__clang__) && defined(__ti__)
+# define COMPILER_ID "TIClang"
+  # define COMPILER_VERSION_MAJOR DEC(__ti_major__)
+  # define COMPILER_VERSION_MINOR DEC(__ti_minor__)
+  # define COMPILER_VERSION_PATCH DEC(__ti_patchlevel__)
+# define COMPILER_VERSION_INTERNAL DEC(__ti_version__)
+
+#elif defined(__clang__)
+# define COMPILER_ID "Clang"
+# if defined(_MSC_VER)
+#  define SIMULATE_ID "MSVC"
+# endif
+# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
+# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
+# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
+# if defined(_MSC_VER)
+   /* _MSC_VER = VVRR */
+#  define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
+#  define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
+# endif
+
+#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__))
+# define COMPILER_ID "LCC"
+# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100)
+# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100)
+# if defined(__LCC_MINOR__)
+#  define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__)
+# endif
+# if defined(__GNUC__) && defined(__GNUC_MINOR__)
+#  define SIMULATE_ID "GNU"
+#  define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
+#  define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
+#  if defined(__GNUC_PATCHLEVEL__)
+#   define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+#  endif
+# endif
+
+#elif defined(__GNUC__) || defined(__GNUG__)
+# define COMPILER_ID "GNU"
+# if defined(__GNUC__)
+#  define COMPILER_VERSION_MAJOR DEC(__GNUC__)
+# else
+#  define COMPILER_VERSION_MAJOR DEC(__GNUG__)
+# endif
+# if defined(__GNUC_MINOR__)
+#  define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
+# endif
+# if defined(__GNUC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
+# endif
+
+#elif defined(_MSC_VER)
+# define COMPILER_ID "MSVC"
+  /* _MSC_VER = VVRR */
+# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
+# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
+# if defined(_MSC_FULL_VER)
+#  if _MSC_VER >= 1400
+    /* _MSC_FULL_VER = VVRRPPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
+#  else
+    /* _MSC_FULL_VER = VVRRPPPP */
+#   define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
+#  endif
+# endif
+# if defined(_MSC_BUILD)
+#  define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
+# endif
+
+#elif defined(_ADI_COMPILER)
+# define COMPILER_ID "ADSP"
+#if defined(__VERSIONNUM__)
+  /* __VERSIONNUM__ = 0xVVRRPPTT */
+#  define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF)
+#  define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF)
+#  define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF)
+#  define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF)
+#endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# define COMPILER_ID "IAR"
+# if defined(__VER__) && defined(__ICCARM__)
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
+#  define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
+#  define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__))
+#  define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
+#  define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
+#  define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
+#  define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
+# endif
+
+
+/* These compilers are either not known or too old to define an
+  identification macro.  Try to identify the platform and guess that
+  it is the native compiler.  */
+#elif defined(__hpux) || defined(__hpua)
+# define COMPILER_ID "HP"
+
+#else /* unknown compiler */
+# define COMPILER_ID ""
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
+#ifdef SIMULATE_ID
+char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
+#endif
+
+#ifdef __QNXNTO__
+char const* qnxnto = "INFO" ":" "qnxnto[]";
+#endif
+
+#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
+char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
+#endif
+
+#define STRINGIFY_HELPER(X) #X
+#define STRINGIFY(X) STRINGIFY_HELPER(X)
+
+/* Identify known platforms by name.  */
+#if defined(__linux) || defined(__linux__) || defined(linux)
+# define PLATFORM_ID "Linux"
+
+#elif defined(__MSYS__)
+# define PLATFORM_ID "MSYS"
+
+#elif defined(__CYGWIN__)
+# define PLATFORM_ID "Cygwin"
+
+#elif defined(__MINGW32__)
+# define PLATFORM_ID "MinGW"
+
+#elif defined(__APPLE__)
+# define PLATFORM_ID "Darwin"
+
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+# define PLATFORM_ID "Windows"
+
+#elif defined(__FreeBSD__) || defined(__FreeBSD)
+# define PLATFORM_ID "FreeBSD"
+
+#elif defined(__NetBSD__) || defined(__NetBSD)
+# define PLATFORM_ID "NetBSD"
+
+#elif defined(__OpenBSD__) || defined(__OPENBSD)
+# define PLATFORM_ID "OpenBSD"
+
+#elif defined(__sun) || defined(sun)
+# define PLATFORM_ID "SunOS"
+
+#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
+# define PLATFORM_ID "AIX"
+
+#elif defined(__hpux) || defined(__hpux__)
+# define PLATFORM_ID "HP-UX"
+
+#elif defined(__HAIKU__)
+# define PLATFORM_ID "Haiku"
+
+#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
+# define PLATFORM_ID "BeOS"
+
+#elif defined(__QNX__) || defined(__QNXNTO__)
+# define PLATFORM_ID "QNX"
+
+#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
+# define PLATFORM_ID "Tru64"
+
+#elif defined(__riscos) || defined(__riscos__)
+# define PLATFORM_ID "RISCos"
+
+#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
+# define PLATFORM_ID "SINIX"
+
+#elif defined(__UNIX_SV__)
+# define PLATFORM_ID "UNIX_SV"
+
+#elif defined(__bsdos__)
+# define PLATFORM_ID "BSDOS"
+
+#elif defined(_MPRAS) || defined(MPRAS)
+# define PLATFORM_ID "MP-RAS"
+
+#elif defined(__osf) || defined(__osf__)
+# define PLATFORM_ID "OSF1"
+
+#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
+# define PLATFORM_ID "SCO_SV"
+
+#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
+# define PLATFORM_ID "ULTRIX"
+
+#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
+# define PLATFORM_ID "Xenix"
+
+#elif defined(__WATCOMC__)
+# if defined(__LINUX__)
+#  define PLATFORM_ID "Linux"
+
+# elif defined(__DOS__)
+#  define PLATFORM_ID "DOS"
+
+# elif defined(__OS2__)
+#  define PLATFORM_ID "OS2"
+
+# elif defined(__WINDOWS__)
+#  define PLATFORM_ID "Windows3x"
+
+# elif defined(__VXWORKS__)
+#  define PLATFORM_ID "VxWorks"
+
+# else /* unknown platform */
+#  define PLATFORM_ID
+# endif
+
+#elif defined(__INTEGRITY)
+# if defined(INT_178B)
+#  define PLATFORM_ID "Integrity178"
+
+# else /* regular Integrity */
+#  define PLATFORM_ID "Integrity"
+# endif
+
+# elif defined(_ADI_COMPILER)
+#  define PLATFORM_ID "ADSP"
+
+#else /* unknown platform */
+# define PLATFORM_ID
+
+#endif
+
+/* For windows compilers MSVC and Intel we can determine
+   the architecture of the compiler being used.  This is because
+   the compilers do not have flags that can change the architecture,
+   but rather depend on which compiler is being used
+*/
+#if defined(_WIN32) && defined(_MSC_VER)
+# if defined(_M_IA64)
+#  define ARCHITECTURE_ID "IA64"
+
+# elif defined(_M_ARM64EC)
+#  define ARCHITECTURE_ID "ARM64EC"
+
+# elif defined(_M_X64) || defined(_M_AMD64)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# elif defined(_M_ARM64)
+#  define ARCHITECTURE_ID "ARM64"
+
+# elif defined(_M_ARM)
+#  if _M_ARM == 4
+#   define ARCHITECTURE_ID "ARMV4I"
+#  elif _M_ARM == 5
+#   define ARCHITECTURE_ID "ARMV5I"
+#  else
+#   define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
+#  endif
+
+# elif defined(_M_MIPS)
+#  define ARCHITECTURE_ID "MIPS"
+
+# elif defined(_M_SH)
+#  define ARCHITECTURE_ID "SHx"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__WATCOMC__)
+# if defined(_M_I86)
+#  define ARCHITECTURE_ID "I86"
+
+# elif defined(_M_IX86)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
+# if defined(__ICCARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__ICCRX__)
+#  define ARCHITECTURE_ID "RX"
+
+# elif defined(__ICCRH850__)
+#  define ARCHITECTURE_ID "RH850"
+
+# elif defined(__ICCRL78__)
+#  define ARCHITECTURE_ID "RL78"
+
+# elif defined(__ICCRISCV__)
+#  define ARCHITECTURE_ID "RISCV"
+
+# elif defined(__ICCAVR__)
+#  define ARCHITECTURE_ID "AVR"
+
+# elif defined(__ICC430__)
+#  define ARCHITECTURE_ID "MSP430"
+
+# elif defined(__ICCV850__)
+#  define ARCHITECTURE_ID "V850"
+
+# elif defined(__ICC8051__)
+#  define ARCHITECTURE_ID "8051"
+
+# elif defined(__ICCSTM8__)
+#  define ARCHITECTURE_ID "STM8"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__ghs__)
+# if defined(__PPC64__)
+#  define ARCHITECTURE_ID "PPC64"
+
+# elif defined(__ppc__)
+#  define ARCHITECTURE_ID "PPC"
+
+# elif defined(__ARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__x86_64__)
+#  define ARCHITECTURE_ID "x64"
+
+# elif defined(__i386__)
+#  define ARCHITECTURE_ID "X86"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__clang__) && defined(__ti__)
+# if defined(__ARM_ARCH)
+#  define ARCHITECTURE_ID "ARM"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+#elif defined(__TI_COMPILER_VERSION__)
+# if defined(__TI_ARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__MSP430__)
+#  define ARCHITECTURE_ID "MSP430"
+
+# elif defined(__TMS320C28XX__)
+#  define ARCHITECTURE_ID "TMS320C28x"
+
+# elif defined(__TMS320C6X__) || defined(_TMS320C6X)
+#  define ARCHITECTURE_ID "TMS320C6x"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
+# elif defined(__ADSPSHARC__)
+#  define ARCHITECTURE_ID "SHARC"
+
+# elif defined(__ADSPBLACKFIN__)
+#  define ARCHITECTURE_ID "Blackfin"
+
+#elif defined(__TASKING__)
+
+# if defined(__CTC__) || defined(__CPTC__)
+#  define ARCHITECTURE_ID "TriCore"
+
+# elif defined(__CMCS__)
+#  define ARCHITECTURE_ID "MCS"
+
+# elif defined(__CARM__) || defined(__CPARM__)
+#  define ARCHITECTURE_ID "ARM"
+
+# elif defined(__CARC__)
+#  define ARCHITECTURE_ID "ARC"
+
+# elif defined(__C51__)
+#  define ARCHITECTURE_ID "8051"
+
+# elif defined(__CPCP__)
+#  define ARCHITECTURE_ID "PCP"
+
+# else
+#  define ARCHITECTURE_ID ""
+# endif
+
+#else
+#  define ARCHITECTURE_ID
+#endif
+
+/* Convert integer to decimal digit literals.  */
+#define DEC(n)                   \
+  ('0' + (((n) / 10000000)%10)), \
+  ('0' + (((n) / 1000000)%10)),  \
+  ('0' + (((n) / 100000)%10)),   \
+  ('0' + (((n) / 10000)%10)),    \
+  ('0' + (((n) / 1000)%10)),     \
+  ('0' + (((n) / 100)%10)),      \
+  ('0' + (((n) / 10)%10)),       \
+  ('0' +  ((n) % 10))
+
+/* Convert integer to hex digit literals.  */
+#define HEX(n)             \
+  ('0' + ((n)>>28 & 0xF)), \
+  ('0' + ((n)>>24 & 0xF)), \
+  ('0' + ((n)>>20 & 0xF)), \
+  ('0' + ((n)>>16 & 0xF)), \
+  ('0' + ((n)>>12 & 0xF)), \
+  ('0' + ((n)>>8  & 0xF)), \
+  ('0' + ((n)>>4  & 0xF)), \
+  ('0' + ((n)     & 0xF))
+
+/* Construct a string literal encoding the version number. */
+#ifdef COMPILER_VERSION
+char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]";
+
+/* Construct a string literal encoding the version number components. */
+#elif defined(COMPILER_VERSION_MAJOR)
+char const info_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
+  COMPILER_VERSION_MAJOR,
+# ifdef COMPILER_VERSION_MINOR
+  '.', COMPILER_VERSION_MINOR,
+#  ifdef COMPILER_VERSION_PATCH
+   '.', COMPILER_VERSION_PATCH,
+#   ifdef COMPILER_VERSION_TWEAK
+    '.', COMPILER_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct a string literal encoding the internal version number. */
+#ifdef COMPILER_VERSION_INTERNAL
+char const info_version_internal[] = {
+  'I', 'N', 'F', 'O', ':',
+  'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
+  'i','n','t','e','r','n','a','l','[',
+  COMPILER_VERSION_INTERNAL,']','\0'};
+#elif defined(COMPILER_VERSION_INTERNAL_STR)
+char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]";
+#endif
+
+/* Construct a string literal encoding the version number components. */
+#ifdef SIMULATE_VERSION_MAJOR
+char const info_simulate_version[] = {
+  'I', 'N', 'F', 'O', ':',
+  's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
+  SIMULATE_VERSION_MAJOR,
+# ifdef SIMULATE_VERSION_MINOR
+  '.', SIMULATE_VERSION_MINOR,
+#  ifdef SIMULATE_VERSION_PATCH
+   '.', SIMULATE_VERSION_PATCH,
+#   ifdef SIMULATE_VERSION_TWEAK
+    '.', SIMULATE_VERSION_TWEAK,
+#   endif
+#  endif
+# endif
+  ']','\0'};
+#endif
+
+/* Construct the string literal in pieces to prevent the source from
+   getting matched.  Store it in a pointer rather than an array
+   because some compilers will just produce instructions to fill the
+   array rather than assigning a pointer to a static array.  */
+char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
+char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
+
+
+
+#define CXX_STD_98 199711L
+#define CXX_STD_11 201103L
+#define CXX_STD_14 201402L
+#define CXX_STD_17 201703L
+#define CXX_STD_20 202002L
+#define CXX_STD_23 202302L
+
+#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG)
+#  if _MSVC_LANG > CXX_STD_17
+#    define CXX_STD _MSVC_LANG
+#  elif _MSVC_LANG == CXX_STD_17 && defined(__cpp_aggregate_paren_init)
+#    define CXX_STD CXX_STD_20
+#  elif _MSVC_LANG > CXX_STD_14 && __cplusplus > CXX_STD_17
+#    define CXX_STD CXX_STD_20
+#  elif _MSVC_LANG > CXX_STD_14
+#    define CXX_STD CXX_STD_17
+#  elif defined(__INTEL_CXX11_MODE__) && defined(__cpp_aggregate_nsdmi)
+#    define CXX_STD CXX_STD_14
+#  elif defined(__INTEL_CXX11_MODE__)
+#    define CXX_STD CXX_STD_11
+#  else
+#    define CXX_STD CXX_STD_98
+#  endif
+#elif defined(_MSC_VER) && defined(_MSVC_LANG)
+#  if _MSVC_LANG > __cplusplus
+#    define CXX_STD _MSVC_LANG
+#  else
+#    define CXX_STD __cplusplus
+#  endif
+#elif defined(__NVCOMPILER)
+#  if __cplusplus == CXX_STD_17 && defined(__cpp_aggregate_paren_init)
+#    define CXX_STD CXX_STD_20
+#  else
+#    define CXX_STD __cplusplus
+#  endif
+#elif defined(__INTEL_COMPILER) || defined(__PGI)
+#  if __cplusplus == CXX_STD_11 && defined(__cpp_namespace_attributes)
+#    define CXX_STD CXX_STD_17
+#  elif __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi)
+#    define CXX_STD CXX_STD_14
+#  else
+#    define CXX_STD __cplusplus
+#  endif
+#elif (defined(__IBMCPP__) || defined(__ibmxl__)) && defined(__linux__)
+#  if __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi)
+#    define CXX_STD CXX_STD_14
+#  else
+#    define CXX_STD __cplusplus
+#  endif
+#elif __cplusplus == 1 && defined(__GXX_EXPERIMENTAL_CXX0X__)
+#  define CXX_STD CXX_STD_11
+#else
+#  define CXX_STD __cplusplus
+#endif
+
+const char* info_language_standard_default = "INFO" ":" "standard_default["
+#if CXX_STD > CXX_STD_23
+  "26"
+#elif CXX_STD > CXX_STD_20
+  "23"
+#elif CXX_STD > CXX_STD_17
+  "20"
+#elif CXX_STD > CXX_STD_14
+  "17"
+#elif CXX_STD > CXX_STD_11
+  "14"
+#elif CXX_STD >= CXX_STD_11
+  "11"
+#else
+  "98"
+#endif
+"]";
+
+const char* info_language_extensions_default = "INFO" ":" "extensions_default["
+#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) ||           \
+     defined(__TI_COMPILER_VERSION__)) &&                                     \
+  !defined(__STRICT_ANSI__)
+  "ON"
+#else
+  "OFF"
+#endif
+"]";
+
+/*--------------------------------------------------------------------------*/
+
+int main(int argc, char* argv[])
+{
+  int require = 0;
+  require += info_compiler[argc];
+  require += info_platform[argc];
+  require += info_arch[argc];
+#ifdef COMPILER_VERSION_MAJOR
+  require += info_version[argc];
+#endif
+#if defined(COMPILER_VERSION_INTERNAL) || defined(COMPILER_VERSION_INTERNAL_STR)
+  require += info_version_internal[argc];
+#endif
+#ifdef SIMULATE_ID
+  require += info_simulate[argc];
+#endif
+#ifdef SIMULATE_VERSION_MAJOR
+  require += info_simulate_version[argc];
+#endif
+#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
+  require += info_cray[argc];
+#endif
+  require += info_language_standard_default[argc];
+  require += info_language_extensions_default[argc];
+  (void)argv;
+  return require;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdCXX/a.out b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdCXX/a.out
new file mode 100644
index 0000000000000000000000000000000000000000..2a0693e94fd5cc9993754e6285ac301490666325
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdCXX/a.out differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeConfigureLog.yaml b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeConfigureLog.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..2e05945e42439958936fca615b58d5e716393a3c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeConfigureLog.yaml
@@ -0,0 +1,989 @@
+
+---
+events:
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineSystem.cmake:205 (message)"
+      - "CMakeLists.txt:18 (project)"
+    message: |
+      The system is: Linux - 4.18.0-553.75.1.el8_10.x86_64 - x86_64
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCompilerId.cmake:17 (message)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCCompiler.cmake:123 (CMAKE_DETERMINE_COMPILER_ID)"
+      - "CMakeLists.txt:18 (project)"
+    message: |
+      Compiling the C compiler identification source file "CMakeCCompilerId.c" succeeded.
+      Compiler: /usr/bin/cc 
+      Build flags: 
+      Id flags:  
+      
+      The output was:
+      0
+      
+      
+      Compilation of the C compiler identification source "CMakeCCompilerId.c" produced "a.out"
+      
+      The C compiler identification is GNU, found in:
+        /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdC/a.out
+      
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCompilerId.cmake:17 (message)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCXXCompiler.cmake:126 (CMAKE_DETERMINE_COMPILER_ID)"
+      - "CMakeLists.txt:18 (project)"
+    message: |
+      Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded.
+      Compiler: /usr/bin/c++ 
+      Build flags: 
+      Id flags:  
+      
+      The output was:
+      0
+      
+      
+      Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.out"
+      
+      The CXX compiler identification is GNU, found in:
+        /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/4.0.3/CompilerIdCXX/a.out
+      
+  -
+    kind: "try_compile-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCompilerABI.cmake:83 (try_compile)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeTestCCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:18 (project)"
+    checks:
+      - "Detecting C compiler ABI info"
+    directories:
+      source: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-HepA0w"
+      binary: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-HepA0w"
+    cmakeVariables:
+      CMAKE_C_FLAGS: ""
+      CMAKE_C_FLAGS_DEBUG: "-g"
+      CMAKE_EXE_LINKER_FLAGS: ""
+    buildResult:
+      variable: "CMAKE_C_ABI_COMPILED"
+      cached: true
+      stdout: |
+        Change Dir: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-HepA0w'
+        
+        Run Build Command(s): /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_a7661/fast
+        /usr/bin/gmake  -f CMakeFiles/cmTC_a7661.dir/build.make CMakeFiles/cmTC_a7661.dir/build
+        gmake[1]: Entering directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-HepA0w'
+        Building C object CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o
+        /usr/bin/cc   -v -o CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeCCompilerABI.c
+        Using built-in specs.
+        COLLECT_GCC=/usr/bin/cc
+        OFFLOAD_TARGET_NAMES=nvptx-none
+        OFFLOAD_TARGET_DEFAULT=1
+        Target: x86_64-redhat-linux
+        Configured with: ../configure --enable-bootstrap --enable-languages=c,c++,fortran,lto --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugs.almalinux.org/ --enable-shared --enable-threads=posix --enable-checking=release --enable-multilib --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-gcc-major-version-only --with-linker-hash-style=gnu --enable-plugin --enable-initfini-array --with-isl --disable-libmpx --enable-offload-targets=nvptx-none --without-cuda-driver --enable-gnu-indirect-function --enable-cet --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux
+        Thread model: posix
+        gcc version 8.5.0 20210514 (Red Hat 8.5.0-28) (GCC) 
+        COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64'
+         /usr/libexec/gcc/x86_64-redhat-linux/8/cc1 -quiet -v /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeCCompilerABI.c -quiet -dumpbase CMakeCCompilerABI.c -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o -version -o /proj/cvl/users/x_fahkh2/caches/ccueHEAc.s
+        GNU C17 (GCC) version 8.5.0 20210514 (Red Hat 8.5.0-28) (x86_64-redhat-linux)
+        	compiled by GNU C version 8.5.0 20210514 (Red Hat 8.5.0-28), GMP version 6.1.2, MPFR version 3.1.6-p2, MPC version 1.1.0, isl version isl-0.16.1-GMP
+        
+        GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+        ignoring nonexistent directory "/usr/lib/gcc/x86_64-redhat-linux/8/include-fixed"
+        ignoring nonexistent directory "/usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include"
+        ignoring nonexistent directory "/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/include"
+        ignoring nonexistent directory "/cm/shared/apps/slurm/current/include"
+        #include "..." search starts here:
+        #include <...> search starts here:
+         /software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include
+         /software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include
+         /software/sse/manual/CUDA/12.1.1_530.30.02/include
+         /software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include
+         /software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include
+         /software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include
+         /software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include
+         /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include
+         /software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include
+         /software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include
+         /software/sse/manual/GCC/12.3.0/include
+         /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include
+         /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include
+         /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include
+         /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include
+         /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include
+         /usr/lib/gcc/x86_64-redhat-linux/8/include
+         /usr/local/include
+         /usr/include
+        End of search list.
+        GNU C17 (GCC) version 8.5.0 20210514 (Red Hat 8.5.0-28) (x86_64-redhat-linux)
+        	compiled by GNU C version 8.5.0 20210514 (Red Hat 8.5.0-28), GMP version 6.1.2, MPFR version 3.1.6-p2, MPC version 1.1.0, isl version isl-0.16.1-GMP
+        
+        GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+        Compiler executable checksum: 9fb8df8ec8fe15dca3287c63d9ff7ff4
+        COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64'
+         as -v --64 -o CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o /proj/cvl/users/x_fahkh2/caches/ccueHEAc.s
+        GNU assembler version 2.30 (x86_64-redhat-linux) using BFD version version 2.30-125.el8_10
+        COMPILER_PATH=/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/
+        LIBRARY_PATH=/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64/:/software/sse/manual/GCC/12.3.0/lib64/../lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/:/lib/../lib64/:/usr/lib/../lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/:/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/:/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib/:/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/:/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib/:/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib/:/software/sse/manual/GCC/12.3.0/lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../:/lib/:/usr/lib/
+        COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64'
+        Linking C executable cmTC_a7661
+        /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_a7661.dir/link.txt --verbose=1
+        Using built-in specs.
+        COLLECT_GCC=/usr/bin/cc
+        COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper
+        OFFLOAD_TARGET_NAMES=nvptx-none
+        OFFLOAD_TARGET_DEFAULT=1
+        Target: x86_64-redhat-linux
+        Configured with: ../configure --enable-bootstrap --enable-languages=c,c++,fortran,lto --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugs.almalinux.org/ --enable-shared --enable-threads=posix --enable-checking=release --enable-multilib --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-gcc-major-version-only --with-linker-hash-style=gnu --enable-plugin --enable-initfini-array --with-isl --disable-libmpx --enable-offload-targets=nvptx-none --without-cuda-driver --enable-gnu-indirect-function --enable-cet --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux
+        Thread model: posix
+        gcc version 8.5.0 20210514 (Red Hat 8.5.0-28) (GCC) 
+        COMPILER_PATH=/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/
+        LIBRARY_PATH=/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64/:/software/sse/manual/GCC/12.3.0/lib64/../lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/:/lib/../lib64/:/usr/lib/../lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/:/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/:/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib/:/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/:/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib/:/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib/:/software/sse/manual/GCC/12.3.0/lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../:/lib/:/usr/lib/
+        COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_a7661' '-mtune=generic' '-march=x86-64'
+         /usr/libexec/gcc/x86_64-redhat-linux/8/collect2 -plugin /usr/libexec/gcc/x86_64-redhat-linux/8/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper -plugin-opt=-fresolution=/proj/cvl/users/x_fahkh2/caches/cc45f6fB.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o cmTC_a7661 /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o /usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64 -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64 -L/software/sse/manual/GCC/12.3.0/lib64/../lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64 -L/usr/lib/gcc/x86_64-redhat-linux/8 -L/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64 -L/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64 -L/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib -L/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib -L/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib -L/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib -L/software/sse/manual/GCC/12.3.0/lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib -L/usr/lib/gcc/x86_64-redhat-linux/8/../../.. -v CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o -lgcc --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s --no-as-needed /usr/lib/gcc/x86_64-redhat-linux/8/crtend.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o
+        collect2 version 8.5.0 20210514 (Red Hat 8.5.0-28)
+        /software/sse/manual/ld-wrapper/1.0/bin/ld -plugin /usr/libexec/gcc/x86_64-redhat-linux/8/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper -plugin-opt=-fresolution=/proj/cvl/users/x_fahkh2/caches/cc45f6fB.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o cmTC_a7661 /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o /usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64 -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64 -L/software/sse/manual/GCC/12.3.0/lib64/../lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64 -L/usr/lib/gcc/x86_64-redhat-linux/8 -L/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64 -L/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64 -L/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib -L/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib -L/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib -L/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib -L/software/sse/manual/GCC/12.3.0/lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib -L/usr/lib/gcc/x86_64-redhat-linux/8/../../.. -v CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o -lgcc --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s --no-as-needed /usr/lib/gcc/x86_64-redhat-linux/8/crtend.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o
+        GNU ld version 2.30-125.el8_10
+        COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_a7661' '-mtune=generic' '-march=x86-64'
+        /usr/bin/cc  -v -Wl,-v CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o -o cmTC_a7661
+        gmake[1]: Leaving directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-HepA0w'
+        
+      exitCode: 0
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCompilerABI.cmake:191 (message)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeTestCCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:18 (project)"
+    message: |
+      Parsed C implicit include dir info: rv=done
+        found start of include info
+        found start of implicit include info
+          add: [/software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include]
+          add: [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include]
+          add: [/software/sse/manual/CUDA/12.1.1_530.30.02/include]
+          add: [/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include]
+          add: [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include]
+          add: [/software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include]
+          add: [/software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include]
+          add: [/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include]
+          add: [/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include]
+          add: [/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include]
+          add: [/software/sse/manual/GCC/12.3.0/include]
+          add: [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include]
+          add: [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include]
+          add: [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include]
+          add: [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include]
+          add: [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include]
+          add: [/usr/lib/gcc/x86_64-redhat-linux/8/include]
+          add: [/usr/local/include]
+          add: [/usr/include]
+        end of search list found
+        collapse include dir [/software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include] ==> [/software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include]
+        collapse include dir [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include] ==> [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include]
+        collapse include dir [/software/sse/manual/CUDA/12.1.1_530.30.02/include] ==> [/software/sse/manual/CUDA/12.1.1_530.30.02/include]
+        collapse include dir [/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include] ==> [/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include]
+        collapse include dir [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include] ==> [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include]
+        collapse include dir [/software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include] ==> [/software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include]
+        collapse include dir [/software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include] ==> [/software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include]
+        collapse include dir [/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include] ==> [/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include]
+        collapse include dir [/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include] ==> [/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include]
+        collapse include dir [/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include] ==> [/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include]
+        collapse include dir [/software/sse/manual/GCC/12.3.0/include] ==> [/software/sse/manual/GCC/12.3.0/include]
+        collapse include dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include]
+        collapse include dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include]
+        collapse include dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include]
+        collapse include dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include]
+        collapse include dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include]
+        collapse include dir [/usr/lib/gcc/x86_64-redhat-linux/8/include] ==> [/usr/lib/gcc/x86_64-redhat-linux/8/include]
+        collapse include dir [/usr/local/include] ==> [/usr/local/include]
+        collapse include dir [/usr/include] ==> [/usr/include]
+        implicit include dirs: [/software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include;/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include;/software/sse/manual/CUDA/12.1.1_530.30.02/include;/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include;/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include;/software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include;/software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include;/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include;/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include;/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include;/software/sse/manual/GCC/12.3.0/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include;/usr/lib/gcc/x86_64-redhat-linux/8/include;/usr/local/include;/usr/include]
+      
+      
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCompilerABI.cmake:227 (message)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeTestCCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:18 (project)"
+    message: |
+      Parsed C implicit link information:
+        link line regex: [^( *|.*[/\\])(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)]
+        linker tool regex: [^[ 	]*(->|")?[ 	]*(([^"]*[/\\])?(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)))("|,| |$)]
+        ignore line: [Change Dir: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-HepA0w']
+        ignore line: []
+        ignore line: [Run Build Command(s): /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_a7661/fast]
+        ignore line: [/usr/bin/gmake  -f CMakeFiles/cmTC_a7661.dir/build.make CMakeFiles/cmTC_a7661.dir/build]
+        ignore line: [gmake[1]: Entering directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-HepA0w']
+        ignore line: [Building C object CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o]
+        ignore line: [/usr/bin/cc   -v -o CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeCCompilerABI.c]
+        ignore line: [Using built-in specs.]
+        ignore line: [COLLECT_GCC=/usr/bin/cc]
+        ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none]
+        ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+        ignore line: [Target: x86_64-redhat-linux]
+        ignore line: [Configured with: ../configure --enable-bootstrap --enable-languages=c c++ fortran lto --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugs.almalinux.org/ --enable-shared --enable-threads=posix --enable-checking=release --enable-multilib --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-gcc-major-version-only --with-linker-hash-style=gnu --enable-plugin --enable-initfini-array --with-isl --disable-libmpx --enable-offload-targets=nvptx-none --without-cuda-driver --enable-gnu-indirect-function --enable-cet --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux]
+        ignore line: [Thread model: posix]
+        ignore line: [gcc version 8.5.0 20210514 (Red Hat 8.5.0-28) (GCC) ]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64']
+        ignore line: [ /usr/libexec/gcc/x86_64-redhat-linux/8/cc1 -quiet -v /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeCCompilerABI.c -quiet -dumpbase CMakeCCompilerABI.c -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o -version -o /proj/cvl/users/x_fahkh2/caches/ccueHEAc.s]
+        ignore line: [GNU C17 (GCC) version 8.5.0 20210514 (Red Hat 8.5.0-28) (x86_64-redhat-linux)]
+        ignore line: [	compiled by GNU C version 8.5.0 20210514 (Red Hat 8.5.0-28)  GMP version 6.1.2  MPFR version 3.1.6-p2  MPC version 1.1.0  isl version isl-0.16.1-GMP]
+        ignore line: []
+        ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
+        ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-redhat-linux/8/include-fixed"]
+        ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include"]
+        ignore line: [ignoring nonexistent directory "/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/include"]
+        ignore line: [ignoring nonexistent directory "/cm/shared/apps/slurm/current/include"]
+        ignore line: [#include "..." search starts here:]
+        ignore line: [#include <...> search starts here:]
+        ignore line: [ /software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include]
+        ignore line: [ /software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include]
+        ignore line: [ /software/sse/manual/CUDA/12.1.1_530.30.02/include]
+        ignore line: [ /software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include]
+        ignore line: [ /software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include]
+        ignore line: [ /software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include]
+        ignore line: [ /software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include]
+        ignore line: [ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include]
+        ignore line: [ /software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include]
+        ignore line: [ /software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include]
+        ignore line: [ /software/sse/manual/GCC/12.3.0/include]
+        ignore line: [ /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include]
+        ignore line: [ /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include]
+        ignore line: [ /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include]
+        ignore line: [ /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include]
+        ignore line: [ /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include]
+        ignore line: [ /usr/lib/gcc/x86_64-redhat-linux/8/include]
+        ignore line: [ /usr/local/include]
+        ignore line: [ /usr/include]
+        ignore line: [End of search list.]
+        ignore line: [GNU C17 (GCC) version 8.5.0 20210514 (Red Hat 8.5.0-28) (x86_64-redhat-linux)]
+        ignore line: [	compiled by GNU C version 8.5.0 20210514 (Red Hat 8.5.0-28)  GMP version 6.1.2  MPFR version 3.1.6-p2  MPC version 1.1.0  isl version isl-0.16.1-GMP]
+        ignore line: []
+        ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
+        ignore line: [Compiler executable checksum: 9fb8df8ec8fe15dca3287c63d9ff7ff4]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64']
+        ignore line: [ as -v --64 -o CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o /proj/cvl/users/x_fahkh2/caches/ccueHEAc.s]
+        ignore line: [GNU assembler version 2.30 (x86_64-redhat-linux) using BFD version version 2.30-125.el8_10]
+        ignore line: [COMPILER_PATH=/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/]
+        ignore line: [LIBRARY_PATH=/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64/:/software/sse/manual/GCC/12.3.0/lib64/../lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/:/lib/../lib64/:/usr/lib/../lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/:/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/:/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib/:/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/:/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib/:/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib/:/software/sse/manual/GCC/12.3.0/lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../:/lib/:/usr/lib/]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o' '-c' '-mtune=generic' '-march=x86-64']
+        ignore line: [Linking C executable cmTC_a7661]
+        ignore line: [/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_a7661.dir/link.txt --verbose=1]
+        ignore line: [Using built-in specs.]
+        ignore line: [COLLECT_GCC=/usr/bin/cc]
+        ignore line: [COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper]
+        ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none]
+        ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+        ignore line: [Target: x86_64-redhat-linux]
+        ignore line: [Configured with: ../configure --enable-bootstrap --enable-languages=c c++ fortran lto --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugs.almalinux.org/ --enable-shared --enable-threads=posix --enable-checking=release --enable-multilib --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-gcc-major-version-only --with-linker-hash-style=gnu --enable-plugin --enable-initfini-array --with-isl --disable-libmpx --enable-offload-targets=nvptx-none --without-cuda-driver --enable-gnu-indirect-function --enable-cet --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux]
+        ignore line: [Thread model: posix]
+        ignore line: [gcc version 8.5.0 20210514 (Red Hat 8.5.0-28) (GCC) ]
+        ignore line: [COMPILER_PATH=/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/]
+        ignore line: [LIBRARY_PATH=/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64/:/software/sse/manual/GCC/12.3.0/lib64/../lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/:/lib/../lib64/:/usr/lib/../lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/:/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/:/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib/:/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/:/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib/:/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib/:/software/sse/manual/GCC/12.3.0/lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../:/lib/:/usr/lib/]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_a7661' '-mtune=generic' '-march=x86-64']
+        link line: [ /usr/libexec/gcc/x86_64-redhat-linux/8/collect2 -plugin /usr/libexec/gcc/x86_64-redhat-linux/8/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper -plugin-opt=-fresolution=/proj/cvl/users/x_fahkh2/caches/cc45f6fB.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o cmTC_a7661 /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o /usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64 -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64 -L/software/sse/manual/GCC/12.3.0/lib64/../lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64 -L/usr/lib/gcc/x86_64-redhat-linux/8 -L/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64 -L/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64 -L/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib -L/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib -L/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib -L/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib -L/software/sse/manual/GCC/12.3.0/lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib -L/usr/lib/gcc/x86_64-redhat-linux/8/../../.. -v CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o -lgcc --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s --no-as-needed /usr/lib/gcc/x86_64-redhat-linux/8/crtend.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o]
+          arg [/usr/libexec/gcc/x86_64-redhat-linux/8/collect2] ==> ignore
+          arg [-plugin] ==> ignore
+          arg [/usr/libexec/gcc/x86_64-redhat-linux/8/liblto_plugin.so] ==> ignore
+          arg [-plugin-opt=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper] ==> ignore
+          arg [-plugin-opt=-fresolution=/proj/cvl/users/x_fahkh2/caches/cc45f6fB.res] ==> ignore
+          arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
+          arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
+          arg [-plugin-opt=-pass-through=-lc] ==> ignore
+          arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
+          arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
+          arg [--build-id] ==> ignore
+          arg [--no-add-needed] ==> ignore
+          arg [--eh-frame-hdr] ==> ignore
+          arg [--hash-style=gnu] ==> ignore
+          arg [-m] ==> ignore
+          arg [elf_x86_64] ==> ignore
+          arg [-dynamic-linker] ==> ignore
+          arg [/lib64/ld-linux-x86-64.so.2] ==> ignore
+          arg [-o] ==> ignore
+          arg [cmTC_a7661] ==> ignore
+          arg [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o] ==> obj [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o]
+          arg [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o] ==> obj [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o]
+          arg [/usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o] ==> obj [/usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o]
+          arg [-L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64] ==> dir [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64]
+          arg [-L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64] ==> dir [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64]
+          arg [-L/software/sse/manual/GCC/12.3.0/lib64/../lib64] ==> dir [/software/sse/manual/GCC/12.3.0/lib64/../lib64]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64]
+          arg [-L/usr/lib/gcc/x86_64-redhat-linux/8] ==> dir [/usr/lib/gcc/x86_64-redhat-linux/8]
+          arg [-L/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64] ==> dir [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64]
+          arg [-L/lib/../lib64] ==> dir [/lib/../lib64]
+          arg [-L/usr/lib/../lib64] ==> dir [/usr/lib/../lib64]
+          arg [-L/software/sse/manual/CUDA/12.1.1_530.30.02/lib64] ==> dir [/software/sse/manual/CUDA/12.1.1_530.30.02/lib64]
+          arg [-L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64] ==> dir [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64]
+          arg [-L/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib] ==> dir [/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib]
+          arg [-L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64] ==> dir [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64]
+          arg [-L/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib] ==> dir [/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib]
+          arg [-L/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib] ==> dir [/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib]
+          arg [-L/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib] ==> dir [/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib]
+          arg [-L/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib] ==> dir [/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib]
+          arg [-L/software/sse/manual/GCC/12.3.0/lib64] ==> dir [/software/sse/manual/GCC/12.3.0/lib64]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib]
+          arg [-L/usr/lib/gcc/x86_64-redhat-linux/8/../../..] ==> dir [/usr/lib/gcc/x86_64-redhat-linux/8/../../..]
+          arg [-v] ==> ignore
+          arg [CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o] ==> ignore
+          arg [-lgcc] ==> lib [gcc]
+          arg [--as-needed] ==> ignore
+          arg [-lgcc_s] ==> lib [gcc_s]
+          arg [--no-as-needed] ==> ignore
+          arg [-lc] ==> lib [c]
+          arg [-lgcc] ==> lib [gcc]
+          arg [--as-needed] ==> ignore
+          arg [-lgcc_s] ==> lib [gcc_s]
+          arg [--no-as-needed] ==> ignore
+          arg [/usr/lib/gcc/x86_64-redhat-linux/8/crtend.o] ==> obj [/usr/lib/gcc/x86_64-redhat-linux/8/crtend.o]
+          arg [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o] ==> obj [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o]
+        ignore line: [collect2 version 8.5.0 20210514 (Red Hat 8.5.0-28)]
+        ignore line: [/software/sse/manual/ld-wrapper/1.0/bin/ld -plugin /usr/libexec/gcc/x86_64-redhat-linux/8/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper -plugin-opt=-fresolution=/proj/cvl/users/x_fahkh2/caches/cc45f6fB.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o cmTC_a7661 /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o /usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64 -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64 -L/software/sse/manual/GCC/12.3.0/lib64/../lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64 -L/usr/lib/gcc/x86_64-redhat-linux/8 -L/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64 -L/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64 -L/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib -L/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib -L/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib -L/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib -L/software/sse/manual/GCC/12.3.0/lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib -L/usr/lib/gcc/x86_64-redhat-linux/8/../../.. -v CMakeFiles/cmTC_a7661.dir/CMakeCCompilerABI.c.o -lgcc --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s --no-as-needed /usr/lib/gcc/x86_64-redhat-linux/8/crtend.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o]
+        linker tool for 'C': /software/sse/manual/ld-wrapper/1.0/bin/ld
+        collapse obj [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o] ==> [/usr/lib64/crt1.o]
+        collapse obj [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o] ==> [/usr/lib64/crti.o]
+        collapse obj [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o] ==> [/usr/lib64/crtn.o]
+        collapse library dir [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64] ==> [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64]
+        collapse library dir [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64] ==> [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64]
+        collapse library dir [/software/sse/manual/GCC/12.3.0/lib64/../lib64] ==> [/software/sse/manual/GCC/12.3.0/lib64]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib64]
+        collapse library dir [/usr/lib/gcc/x86_64-redhat-linux/8] ==> [/usr/lib/gcc/x86_64-redhat-linux/8]
+        collapse library dir [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64] ==> [/usr/lib64]
+        collapse library dir [/lib/../lib64] ==> [/lib64]
+        collapse library dir [/usr/lib/../lib64] ==> [/usr/lib64]
+        collapse library dir [/software/sse/manual/CUDA/12.1.1_530.30.02/lib64] ==> [/software/sse/manual/CUDA/12.1.1_530.30.02/lib64]
+        collapse library dir [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64] ==> [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64]
+        collapse library dir [/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib] ==> [/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib]
+        collapse library dir [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64] ==> [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64]
+        collapse library dir [/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib] ==> [/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib]
+        collapse library dir [/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib] ==> [/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib]
+        collapse library dir [/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib] ==> [/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib]
+        collapse library dir [/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib] ==> [/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib]
+        collapse library dir [/software/sse/manual/GCC/12.3.0/lib64] ==> [/software/sse/manual/GCC/12.3.0/lib64]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib]
+        collapse library dir [/usr/lib/gcc/x86_64-redhat-linux/8/../../..] ==> [/usr/lib]
+        implicit libs: [gcc;gcc_s;c;gcc;gcc_s]
+        implicit objs: [/usr/lib64/crt1.o;/usr/lib64/crti.o;/usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o;/usr/lib/gcc/x86_64-redhat-linux/8/crtend.o;/usr/lib64/crtn.o]
+        implicit dirs: [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64;/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64;/software/sse/manual/GCC/12.3.0/lib64;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib64;/usr/lib/gcc/x86_64-redhat-linux/8;/usr/lib64;/lib64;/software/sse/manual/CUDA/12.1.1_530.30.02/lib64;/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib;/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib;/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib;/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib;/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib;/usr/lib]
+        implicit fwks: []
+      
+      
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Internal/CMakeDetermineLinkerId.cmake:36 (message)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCompilerABI.cmake:270 (cmake_determine_linker_id)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeTestCCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:18 (project)"
+    message: |
+      Running the C compiler's linker: "/software/sse/manual/ld-wrapper/1.0/bin/ld" "-v"
+      GNU ld version 2.30-125.el8_10
+  -
+    kind: "try_compile-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCompilerABI.cmake:83 (try_compile)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:18 (project)"
+    checks:
+      - "Detecting CXX compiler ABI info"
+    directories:
+      source: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-KPzlRV"
+      binary: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-KPzlRV"
+    cmakeVariables:
+      CMAKE_CXX_FLAGS: ""
+      CMAKE_CXX_FLAGS_DEBUG: "-g"
+      CMAKE_CXX_SCAN_FOR_MODULES: "OFF"
+      CMAKE_EXE_LINKER_FLAGS: ""
+    buildResult:
+      variable: "CMAKE_CXX_ABI_COMPILED"
+      cached: true
+      stdout: |
+        Change Dir: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-KPzlRV'
+        
+        Run Build Command(s): /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_812a8/fast
+        /usr/bin/gmake  -f CMakeFiles/cmTC_812a8.dir/build.make CMakeFiles/cmTC_812a8.dir/build
+        gmake[1]: Entering directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-KPzlRV'
+        Building CXX object CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o
+        /usr/bin/c++   -v -o CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeCXXCompilerABI.cpp
+        Using built-in specs.
+        COLLECT_GCC=/usr/bin/c++
+        OFFLOAD_TARGET_NAMES=nvptx-none
+        OFFLOAD_TARGET_DEFAULT=1
+        Target: x86_64-redhat-linux
+        Configured with: ../configure --enable-bootstrap --enable-languages=c,c++,fortran,lto --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugs.almalinux.org/ --enable-shared --enable-threads=posix --enable-checking=release --enable-multilib --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-gcc-major-version-only --with-linker-hash-style=gnu --enable-plugin --enable-initfini-array --with-isl --disable-libmpx --enable-offload-targets=nvptx-none --without-cuda-driver --enable-gnu-indirect-function --enable-cet --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux
+        Thread model: posix
+        gcc version 8.5.0 20210514 (Red Hat 8.5.0-28) (GCC) 
+        COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+         /usr/libexec/gcc/x86_64-redhat-linux/8/cc1plus -quiet -v -D_GNU_SOURCE /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpbase CMakeCXXCompilerABI.cpp -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o -version -o /proj/cvl/users/x_fahkh2/caches/ccu7WUSt.s
+        GNU C++14 (GCC) version 8.5.0 20210514 (Red Hat 8.5.0-28) (x86_64-redhat-linux)
+        	compiled by GNU C version 8.5.0 20210514 (Red Hat 8.5.0-28), GMP version 6.1.2, MPFR version 3.1.6-p2, MPC version 1.1.0, isl version isl-0.16.1-GMP
+        
+        GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+        ignoring nonexistent directory "/usr/lib/gcc/x86_64-redhat-linux/8/include-fixed"
+        ignoring nonexistent directory "/usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include"
+        ignoring nonexistent directory "/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/include"
+        ignoring nonexistent directory "/cm/shared/apps/slurm/current/include"
+        #include "..." search starts here:
+        #include <...> search starts here:
+         /software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include
+         /software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include
+         /software/sse/manual/CUDA/12.1.1_530.30.02/include
+         /software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include
+         /software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include
+         /software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include
+         /software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include
+         /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include
+         /software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include
+         /software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include
+         /software/sse/manual/GCC/12.3.0/include
+         /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include
+         /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include
+         /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include
+         /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include
+         /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include
+         /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8
+         /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux
+         /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward
+         /usr/lib/gcc/x86_64-redhat-linux/8/include
+         /usr/local/include
+         /usr/include
+        End of search list.
+        GNU C++14 (GCC) version 8.5.0 20210514 (Red Hat 8.5.0-28) (x86_64-redhat-linux)
+        	compiled by GNU C version 8.5.0 20210514 (Red Hat 8.5.0-28), GMP version 6.1.2, MPFR version 3.1.6-p2, MPC version 1.1.0, isl version isl-0.16.1-GMP
+        
+        GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
+        Compiler executable checksum: c1725d49d5500384a54ea6d1e027ad4d
+        COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+         as -v --64 -o CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o /proj/cvl/users/x_fahkh2/caches/ccu7WUSt.s
+        GNU assembler version 2.30 (x86_64-redhat-linux) using BFD version version 2.30-125.el8_10
+        COMPILER_PATH=/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/
+        LIBRARY_PATH=/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64/:/software/sse/manual/GCC/12.3.0/lib64/../lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/:/lib/../lib64/:/usr/lib/../lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/:/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/:/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib/:/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/:/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib/:/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib/:/software/sse/manual/GCC/12.3.0/lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../:/lib/:/usr/lib/
+        COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+        Linking CXX executable cmTC_812a8
+        /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_812a8.dir/link.txt --verbose=1
+        Using built-in specs.
+        COLLECT_GCC=/usr/bin/c++
+        COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper
+        OFFLOAD_TARGET_NAMES=nvptx-none
+        OFFLOAD_TARGET_DEFAULT=1
+        Target: x86_64-redhat-linux
+        Configured with: ../configure --enable-bootstrap --enable-languages=c,c++,fortran,lto --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugs.almalinux.org/ --enable-shared --enable-threads=posix --enable-checking=release --enable-multilib --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-gcc-major-version-only --with-linker-hash-style=gnu --enable-plugin --enable-initfini-array --with-isl --disable-libmpx --enable-offload-targets=nvptx-none --without-cuda-driver --enable-gnu-indirect-function --enable-cet --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux
+        Thread model: posix
+        gcc version 8.5.0 20210514 (Red Hat 8.5.0-28) (GCC) 
+        COMPILER_PATH=/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/
+        LIBRARY_PATH=/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64/:/software/sse/manual/GCC/12.3.0/lib64/../lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/:/lib/../lib64/:/usr/lib/../lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/:/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/:/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib/:/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/:/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib/:/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib/:/software/sse/manual/GCC/12.3.0/lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../:/lib/:/usr/lib/
+        COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_812a8' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+         /usr/libexec/gcc/x86_64-redhat-linux/8/collect2 -plugin /usr/libexec/gcc/x86_64-redhat-linux/8/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper -plugin-opt=-fresolution=/proj/cvl/users/x_fahkh2/caches/ccauH5YK.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o cmTC_812a8 /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o /usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64 -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64 -L/software/sse/manual/GCC/12.3.0/lib64/../lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64 -L/usr/lib/gcc/x86_64-redhat-linux/8 -L/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64 -L/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64 -L/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib -L/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib -L/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib -L/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib -L/software/sse/manual/GCC/12.3.0/lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib -L/usr/lib/gcc/x86_64-redhat-linux/8/../../.. -v CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-redhat-linux/8/crtend.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o
+        collect2 version 8.5.0 20210514 (Red Hat 8.5.0-28)
+        /software/sse/manual/ld-wrapper/1.0/bin/ld -plugin /usr/libexec/gcc/x86_64-redhat-linux/8/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper -plugin-opt=-fresolution=/proj/cvl/users/x_fahkh2/caches/ccauH5YK.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o cmTC_812a8 /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o /usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64 -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64 -L/software/sse/manual/GCC/12.3.0/lib64/../lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64 -L/usr/lib/gcc/x86_64-redhat-linux/8 -L/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64 -L/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64 -L/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib -L/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib -L/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib -L/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib -L/software/sse/manual/GCC/12.3.0/lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib -L/usr/lib/gcc/x86_64-redhat-linux/8/../../.. -v CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-redhat-linux/8/crtend.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o
+        GNU ld version 2.30-125.el8_10
+        COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_812a8' '-shared-libgcc' '-mtune=generic' '-march=x86-64'
+        /usr/bin/c++  -v -Wl,-v CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_812a8
+        gmake[1]: Leaving directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-KPzlRV'
+        
+      exitCode: 0
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCompilerABI.cmake:191 (message)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:18 (project)"
+    message: |
+      Parsed CXX implicit include dir info: rv=done
+        found start of include info
+        found start of implicit include info
+          add: [/software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include]
+          add: [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include]
+          add: [/software/sse/manual/CUDA/12.1.1_530.30.02/include]
+          add: [/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include]
+          add: [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include]
+          add: [/software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include]
+          add: [/software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include]
+          add: [/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include]
+          add: [/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include]
+          add: [/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include]
+          add: [/software/sse/manual/GCC/12.3.0/include]
+          add: [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include]
+          add: [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include]
+          add: [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include]
+          add: [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include]
+          add: [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include]
+          add: [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8]
+          add: [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux]
+          add: [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward]
+          add: [/usr/lib/gcc/x86_64-redhat-linux/8/include]
+          add: [/usr/local/include]
+          add: [/usr/include]
+        end of search list found
+        collapse include dir [/software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include] ==> [/software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include]
+        collapse include dir [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include] ==> [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include]
+        collapse include dir [/software/sse/manual/CUDA/12.1.1_530.30.02/include] ==> [/software/sse/manual/CUDA/12.1.1_530.30.02/include]
+        collapse include dir [/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include] ==> [/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include]
+        collapse include dir [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include] ==> [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include]
+        collapse include dir [/software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include] ==> [/software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include]
+        collapse include dir [/software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include] ==> [/software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include]
+        collapse include dir [/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include] ==> [/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include]
+        collapse include dir [/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include] ==> [/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include]
+        collapse include dir [/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include] ==> [/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include]
+        collapse include dir [/software/sse/manual/GCC/12.3.0/include] ==> [/software/sse/manual/GCC/12.3.0/include]
+        collapse include dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include]
+        collapse include dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include]
+        collapse include dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include]
+        collapse include dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include]
+        collapse include dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include]
+        collapse include dir [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8] ==> [/usr/include/c++/8]
+        collapse include dir [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux] ==> [/usr/include/c++/8/x86_64-redhat-linux]
+        collapse include dir [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward] ==> [/usr/include/c++/8/backward]
+        collapse include dir [/usr/lib/gcc/x86_64-redhat-linux/8/include] ==> [/usr/lib/gcc/x86_64-redhat-linux/8/include]
+        collapse include dir [/usr/local/include] ==> [/usr/local/include]
+        collapse include dir [/usr/include] ==> [/usr/include]
+        implicit include dirs: [/software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include;/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include;/software/sse/manual/CUDA/12.1.1_530.30.02/include;/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include;/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include;/software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include;/software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include;/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include;/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include;/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include;/software/sse/manual/GCC/12.3.0/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include;/usr/include/c++/8;/usr/include/c++/8/x86_64-redhat-linux;/usr/include/c++/8/backward;/usr/lib/gcc/x86_64-redhat-linux/8/include;/usr/local/include;/usr/include]
+      
+      
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCompilerABI.cmake:227 (message)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:18 (project)"
+    message: |
+      Parsed CXX implicit link information:
+        link line regex: [^( *|.*[/\\])(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)]
+        linker tool regex: [^[ 	]*(->|")?[ 	]*(([^"]*[/\\])?(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)))("|,| |$)]
+        ignore line: [Change Dir: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-KPzlRV']
+        ignore line: []
+        ignore line: [Run Build Command(s): /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_812a8/fast]
+        ignore line: [/usr/bin/gmake  -f CMakeFiles/cmTC_812a8.dir/build.make CMakeFiles/cmTC_812a8.dir/build]
+        ignore line: [gmake[1]: Entering directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-KPzlRV']
+        ignore line: [Building CXX object CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o]
+        ignore line: [/usr/bin/c++   -v -o CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeCXXCompilerABI.cpp]
+        ignore line: [Using built-in specs.]
+        ignore line: [COLLECT_GCC=/usr/bin/c++]
+        ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none]
+        ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+        ignore line: [Target: x86_64-redhat-linux]
+        ignore line: [Configured with: ../configure --enable-bootstrap --enable-languages=c c++ fortran lto --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugs.almalinux.org/ --enable-shared --enable-threads=posix --enable-checking=release --enable-multilib --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-gcc-major-version-only --with-linker-hash-style=gnu --enable-plugin --enable-initfini-array --with-isl --disable-libmpx --enable-offload-targets=nvptx-none --without-cuda-driver --enable-gnu-indirect-function --enable-cet --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux]
+        ignore line: [Thread model: posix]
+        ignore line: [gcc version 8.5.0 20210514 (Red Hat 8.5.0-28) (GCC) ]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64']
+        ignore line: [ /usr/libexec/gcc/x86_64-redhat-linux/8/cc1plus -quiet -v -D_GNU_SOURCE /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpbase CMakeCXXCompilerABI.cpp -mtune=generic -march=x86-64 -auxbase-strip CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o -version -o /proj/cvl/users/x_fahkh2/caches/ccu7WUSt.s]
+        ignore line: [GNU C++14 (GCC) version 8.5.0 20210514 (Red Hat 8.5.0-28) (x86_64-redhat-linux)]
+        ignore line: [	compiled by GNU C version 8.5.0 20210514 (Red Hat 8.5.0-28)  GMP version 6.1.2  MPFR version 3.1.6-p2  MPC version 1.1.0  isl version isl-0.16.1-GMP]
+        ignore line: []
+        ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
+        ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-redhat-linux/8/include-fixed"]
+        ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include"]
+        ignore line: [ignoring nonexistent directory "/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/include"]
+        ignore line: [ignoring nonexistent directory "/cm/shared/apps/slurm/current/include"]
+        ignore line: [#include "..." search starts here:]
+        ignore line: [#include <...> search starts here:]
+        ignore line: [ /software/sse/manual/CUDA/12.1.1_530.30.02/nvvm/include]
+        ignore line: [ /software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/include]
+        ignore line: [ /software/sse/manual/CUDA/12.1.1_530.30.02/include]
+        ignore line: [ /software/sse/manual/LLVM/17.0.1/gcc-12.3.0/include]
+        ignore line: [ /software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/include]
+        ignore line: [ /software/sse/manual/MAGMA/2.7.1/gcc-12.3.0/cuda-12.1.1/include]
+        ignore line: [ /software/sse/manual/Eigen/3.4.0/gcc-12.3.0/include]
+        ignore line: [ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include]
+        ignore line: [ /software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/include]
+        ignore line: [ /software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/include]
+        ignore line: [ /software/sse/manual/GCC/12.3.0/include]
+        ignore line: [ /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/include]
+        ignore line: [ /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/include]
+        ignore line: [ /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/include]
+        ignore line: [ /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/include]
+        ignore line: [ /software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/include]
+        ignore line: [ /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8]
+        ignore line: [ /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux]
+        ignore line: [ /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward]
+        ignore line: [ /usr/lib/gcc/x86_64-redhat-linux/8/include]
+        ignore line: [ /usr/local/include]
+        ignore line: [ /usr/include]
+        ignore line: [End of search list.]
+        ignore line: [GNU C++14 (GCC) version 8.5.0 20210514 (Red Hat 8.5.0-28) (x86_64-redhat-linux)]
+        ignore line: [	compiled by GNU C version 8.5.0 20210514 (Red Hat 8.5.0-28)  GMP version 6.1.2  MPFR version 3.1.6-p2  MPC version 1.1.0  isl version isl-0.16.1-GMP]
+        ignore line: []
+        ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
+        ignore line: [Compiler executable checksum: c1725d49d5500384a54ea6d1e027ad4d]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64']
+        ignore line: [ as -v --64 -o CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o /proj/cvl/users/x_fahkh2/caches/ccu7WUSt.s]
+        ignore line: [GNU assembler version 2.30 (x86_64-redhat-linux) using BFD version version 2.30-125.el8_10]
+        ignore line: [COMPILER_PATH=/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/]
+        ignore line: [LIBRARY_PATH=/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64/:/software/sse/manual/GCC/12.3.0/lib64/../lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/:/lib/../lib64/:/usr/lib/../lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/:/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/:/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib/:/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/:/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib/:/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib/:/software/sse/manual/GCC/12.3.0/lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../:/lib/:/usr/lib/]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64']
+        ignore line: [Linking CXX executable cmTC_812a8]
+        ignore line: [/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_812a8.dir/link.txt --verbose=1]
+        ignore line: [Using built-in specs.]
+        ignore line: [COLLECT_GCC=/usr/bin/c++]
+        ignore line: [COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper]
+        ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none]
+        ignore line: [OFFLOAD_TARGET_DEFAULT=1]
+        ignore line: [Target: x86_64-redhat-linux]
+        ignore line: [Configured with: ../configure --enable-bootstrap --enable-languages=c c++ fortran lto --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugs.almalinux.org/ --enable-shared --enable-threads=posix --enable-checking=release --enable-multilib --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-linker-build-id --with-gcc-major-version-only --with-linker-hash-style=gnu --enable-plugin --enable-initfini-array --with-isl --disable-libmpx --enable-offload-targets=nvptx-none --without-cuda-driver --enable-gnu-indirect-function --enable-cet --with-tune=generic --with-arch_32=x86-64 --build=x86_64-redhat-linux]
+        ignore line: [Thread model: posix]
+        ignore line: [gcc version 8.5.0 20210514 (Red Hat 8.5.0-28) (GCC) ]
+        ignore line: [COMPILER_PATH=/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/8/:/usr/libexec/gcc/x86_64-redhat-linux/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/]
+        ignore line: [LIBRARY_PATH=/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64/:/software/sse/manual/GCC/12.3.0/lib64/../lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64/:/usr/lib/gcc/x86_64-redhat-linux/8/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/:/lib/../lib64/:/usr/lib/../lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/lib64/:/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/:/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib/:/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/:/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib/:/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/:/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib/:/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib/:/software/sse/manual/GCC/12.3.0/lib64/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib/:/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib/:/usr/lib/gcc/x86_64-redhat-linux/8/../../../:/lib/:/usr/lib/]
+        ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_812a8' '-shared-libgcc' '-mtune=generic' '-march=x86-64']
+        link line: [ /usr/libexec/gcc/x86_64-redhat-linux/8/collect2 -plugin /usr/libexec/gcc/x86_64-redhat-linux/8/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper -plugin-opt=-fresolution=/proj/cvl/users/x_fahkh2/caches/ccauH5YK.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o cmTC_812a8 /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o /usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64 -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64 -L/software/sse/manual/GCC/12.3.0/lib64/../lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64 -L/usr/lib/gcc/x86_64-redhat-linux/8 -L/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64 -L/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64 -L/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib -L/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib -L/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib -L/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib -L/software/sse/manual/GCC/12.3.0/lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib -L/usr/lib/gcc/x86_64-redhat-linux/8/../../.. -v CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-redhat-linux/8/crtend.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o]
+          arg [/usr/libexec/gcc/x86_64-redhat-linux/8/collect2] ==> ignore
+          arg [-plugin] ==> ignore
+          arg [/usr/libexec/gcc/x86_64-redhat-linux/8/liblto_plugin.so] ==> ignore
+          arg [-plugin-opt=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper] ==> ignore
+          arg [-plugin-opt=-fresolution=/proj/cvl/users/x_fahkh2/caches/ccauH5YK.res] ==> ignore
+          arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
+          arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
+          arg [-plugin-opt=-pass-through=-lc] ==> ignore
+          arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
+          arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
+          arg [--build-id] ==> ignore
+          arg [--no-add-needed] ==> ignore
+          arg [--eh-frame-hdr] ==> ignore
+          arg [--hash-style=gnu] ==> ignore
+          arg [-m] ==> ignore
+          arg [elf_x86_64] ==> ignore
+          arg [-dynamic-linker] ==> ignore
+          arg [/lib64/ld-linux-x86-64.so.2] ==> ignore
+          arg [-o] ==> ignore
+          arg [cmTC_812a8] ==> ignore
+          arg [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o] ==> obj [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o]
+          arg [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o] ==> obj [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o]
+          arg [/usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o] ==> obj [/usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o]
+          arg [-L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64] ==> dir [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64]
+          arg [-L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64] ==> dir [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64]
+          arg [-L/software/sse/manual/GCC/12.3.0/lib64/../lib64] ==> dir [/software/sse/manual/GCC/12.3.0/lib64/../lib64]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64]
+          arg [-L/usr/lib/gcc/x86_64-redhat-linux/8] ==> dir [/usr/lib/gcc/x86_64-redhat-linux/8]
+          arg [-L/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64] ==> dir [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64]
+          arg [-L/lib/../lib64] ==> dir [/lib/../lib64]
+          arg [-L/usr/lib/../lib64] ==> dir [/usr/lib/../lib64]
+          arg [-L/software/sse/manual/CUDA/12.1.1_530.30.02/lib64] ==> dir [/software/sse/manual/CUDA/12.1.1_530.30.02/lib64]
+          arg [-L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64] ==> dir [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64]
+          arg [-L/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib] ==> dir [/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib]
+          arg [-L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64] ==> dir [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64]
+          arg [-L/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib] ==> dir [/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib]
+          arg [-L/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib] ==> dir [/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib]
+          arg [-L/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib] ==> dir [/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib]
+          arg [-L/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib] ==> dir [/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib]
+          arg [-L/software/sse/manual/GCC/12.3.0/lib64] ==> dir [/software/sse/manual/GCC/12.3.0/lib64]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib]
+          arg [-L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib] ==> dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib]
+          arg [-L/usr/lib/gcc/x86_64-redhat-linux/8/../../..] ==> dir [/usr/lib/gcc/x86_64-redhat-linux/8/../../..]
+          arg [-v] ==> ignore
+          arg [CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o] ==> ignore
+          arg [-lstdc++] ==> lib [stdc++]
+          arg [-lm] ==> lib [m]
+          arg [-lgcc_s] ==> lib [gcc_s]
+          arg [-lgcc] ==> lib [gcc]
+          arg [-lc] ==> lib [c]
+          arg [-lgcc_s] ==> lib [gcc_s]
+          arg [-lgcc] ==> lib [gcc]
+          arg [/usr/lib/gcc/x86_64-redhat-linux/8/crtend.o] ==> obj [/usr/lib/gcc/x86_64-redhat-linux/8/crtend.o]
+          arg [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o] ==> obj [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o]
+        ignore line: [collect2 version 8.5.0 20210514 (Red Hat 8.5.0-28)]
+        ignore line: [/software/sse/manual/ld-wrapper/1.0/bin/ld -plugin /usr/libexec/gcc/x86_64-redhat-linux/8/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-redhat-linux/8/lto-wrapper -plugin-opt=-fresolution=/proj/cvl/users/x_fahkh2/caches/ccauH5YK.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --no-add-needed --eh-frame-hdr --hash-style=gnu -m elf_x86_64 -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o cmTC_812a8 /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o /usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64 -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64 -L/software/sse/manual/GCC/12.3.0/lib64/../lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64 -L/usr/lib/gcc/x86_64-redhat-linux/8 -L/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64 -L/lib/../lib64 -L/usr/lib/../lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/lib64 -L/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64 -L/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib -L/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64 -L/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib -L/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib -L/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib -L/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib -L/software/sse/manual/GCC/12.3.0/lib64 -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib -L/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib -L/usr/lib/gcc/x86_64-redhat-linux/8/../../.. -v CMakeFiles/cmTC_812a8.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-redhat-linux/8/crtend.o /usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o]
+        linker tool for 'CXX': /software/sse/manual/ld-wrapper/1.0/bin/ld
+        collapse obj [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crt1.o] ==> [/usr/lib64/crt1.o]
+        collapse obj [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crti.o] ==> [/usr/lib64/crti.o]
+        collapse obj [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64/crtn.o] ==> [/usr/lib64/crtn.o]
+        collapse library dir [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64/../lib64] ==> [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64]
+        collapse library dir [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64/../lib64] ==> [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64]
+        collapse library dir [/software/sse/manual/GCC/12.3.0/lib64/../lib64] ==> [/software/sse/manual/GCC/12.3.0/lib64]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib/../lib64] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib64]
+        collapse library dir [/usr/lib/gcc/x86_64-redhat-linux/8] ==> [/usr/lib/gcc/x86_64-redhat-linux/8]
+        collapse library dir [/usr/lib/gcc/x86_64-redhat-linux/8/../../../../lib64] ==> [/usr/lib64]
+        collapse library dir [/lib/../lib64] ==> [/lib64]
+        collapse library dir [/usr/lib/../lib64] ==> [/usr/lib64]
+        collapse library dir [/software/sse/manual/CUDA/12.1.1_530.30.02/lib64] ==> [/software/sse/manual/CUDA/12.1.1_530.30.02/lib64]
+        collapse library dir [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64] ==> [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64]
+        collapse library dir [/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib] ==> [/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib]
+        collapse library dir [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64] ==> [/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64]
+        collapse library dir [/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib] ==> [/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib]
+        collapse library dir [/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib] ==> [/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib]
+        collapse library dir [/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib] ==> [/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib]
+        collapse library dir [/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib] ==> [/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib]
+        collapse library dir [/software/sse/manual/GCC/12.3.0/lib64] ==> [/software/sse/manual/GCC/12.3.0/lib64]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib]
+        collapse library dir [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib] ==> [/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib]
+        collapse library dir [/usr/lib/gcc/x86_64-redhat-linux/8/../../..] ==> [/usr/lib]
+        implicit libs: [stdc++;m;gcc_s;gcc;c;gcc_s;gcc]
+        implicit objs: [/usr/lib64/crt1.o;/usr/lib64/crti.o;/usr/lib/gcc/x86_64-redhat-linux/8/crtbegin.o;/usr/lib/gcc/x86_64-redhat-linux/8/crtend.o;/usr/lib64/crtn.o]
+        implicit dirs: [/software/sse/manual/CUDA/12.1.1_530.30.02/extras/CUPTI/lib64;/software/sse/manual/OpenCV/4.8.0/gcc-12.3.0/lib64;/software/sse/manual/GCC/12.3.0/lib64;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib64;/usr/lib/gcc/x86_64-redhat-linux/8;/usr/lib64;/lib64;/software/sse/manual/CUDA/12.1.1_530.30.02/lib64;/software/sse/manual/LLVM/17.0.1/gcc-12.3.0/lib;/software/sse/manual/ScaLAPACK/2.2.0/gcc-12.3.0/openmpi-4.1.5/openblas-0.3.23/lib;/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib;/software/sse/manual/FFTW/3.3.10/gcc-12.3.0/openmpi-4.1.5/lib;/software/sse/manual/OpenMPI/4.1.5/gcc-12.3.0/cuda-12.1.1/hpc1/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ompi/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/nccl_rdma_sharp_plugin/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/sharp/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/hcoll/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucc/lib;/software/sse/manual/NVHPC/24.5/bdist/Linux_x86_64/24.5/comm_libs/12.4/hpcx/hpcx-2.19/ucx/lib;/usr/lib]
+        implicit fwks: []
+      
+      
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Internal/CMakeDetermineLinkerId.cmake:36 (message)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineCompilerABI.cmake:270 (cmake_determine_linker_id)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
+      - "CMakeLists.txt:18 (project)"
+    message: |
+      Running the CXX compiler's linker: "/software/sse/manual/ld-wrapper/1.0/bin/ld" "-v"
+      GNU ld version 2.30-125.el8_10
+  -
+    kind: "try_compile-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CheckFunctionExists.cmake:93 (try_compile)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindBLAS.cmake:379 (check_function_exists)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindBLAS.cmake:423 (check_blas_libraries)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindLAPACK.cmake:247 (find_package)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindLAPACK.cmake:283 (_lapack_find_dependency)"
+      - "CMakeLists.txt:208 (find_package)"
+    checks:
+      - "Looking for sgemm_"
+    directories:
+      source: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-8Q8xzR"
+      binary: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-8Q8xzR"
+    cmakeVariables:
+      CMAKE_C_FLAGS: ""
+      CMAKE_C_FLAGS_DEBUG: "-g"
+      CMAKE_EXE_LINKER_FLAGS: ""
+      CMAKE_MODULE_PATH: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/cmake"
+      CMAKE_POSITION_INDEPENDENT_CODE: "ON"
+    buildResult:
+      variable: "BLAS_WORKS"
+      cached: true
+      stdout: |
+        Change Dir: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-8Q8xzR'
+        
+        Run Build Command(s): /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_48cf2/fast
+        /usr/bin/gmake  -f CMakeFiles/cmTC_48cf2.dir/build.make CMakeFiles/cmTC_48cf2.dir/build
+        gmake[1]: Entering directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-8Q8xzR'
+        Building C object CMakeFiles/cmTC_48cf2.dir/CheckFunctionExists.c.o
+        /usr/bin/cc   -DCHECK_FUNCTION_EXISTS=sgemm_ -fPIE -o CMakeFiles/cmTC_48cf2.dir/CheckFunctionExists.c.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-8Q8xzR/CheckFunctionExists.c
+        Linking C executable cmTC_48cf2
+        /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_48cf2.dir/link.txt --verbose=1
+        CMakeFiles/cmTC_48cf2.dir/CheckFunctionExists.c.o: In function `main':
+        CheckFunctionExists.c:(.text+0x10): undefined reference to `sgemm_'
+        collect2: error: ld returned 1 exit status
+        /usr/bin/cc  -DCHECK_FUNCTION_EXISTS=sgemm_ CMakeFiles/cmTC_48cf2.dir/CheckFunctionExists.c.o -o cmTC_48cf2
+        gmake[1]: *** [CMakeFiles/cmTC_48cf2.dir/build.make:102: cmTC_48cf2] Error 1
+        gmake[1]: Leaving directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-8Q8xzR'
+        gmake: *** [Makefile:134: cmTC_48cf2/fast] Error 2
+        
+      exitCode: 2
+  -
+    kind: "try_compile-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Internal/CheckSourceCompiles.cmake:104 (try_compile)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CheckCSourceCompiles.cmake:58 (cmake_check_source_compiles)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindThreads.cmake:97 (check_c_source_compiles)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindThreads.cmake:163 (_threads_check_libc)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindBLAS.cmake:477 (find_package)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindLAPACK.cmake:247 (find_package)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindLAPACK.cmake:283 (_lapack_find_dependency)"
+      - "CMakeLists.txt:208 (find_package)"
+    checks:
+      - "Performing Test CMAKE_HAVE_LIBC_PTHREAD"
+    directories:
+      source: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-XvRDFf"
+      binary: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-XvRDFf"
+    cmakeVariables:
+      CMAKE_C_FLAGS: ""
+      CMAKE_C_FLAGS_DEBUG: "-g"
+      CMAKE_EXE_LINKER_FLAGS: ""
+      CMAKE_MODULE_PATH: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/cmake"
+      CMAKE_POSITION_INDEPENDENT_CODE: "ON"
+    buildResult:
+      variable: "CMAKE_HAVE_LIBC_PTHREAD"
+      cached: true
+      stdout: |
+        Change Dir: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-XvRDFf'
+        
+        Run Build Command(s): /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_847c3/fast
+        /usr/bin/gmake  -f CMakeFiles/cmTC_847c3.dir/build.make CMakeFiles/cmTC_847c3.dir/build
+        gmake[1]: Entering directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-XvRDFf'
+        Building C object CMakeFiles/cmTC_847c3.dir/src.c.o
+        /usr/bin/cc -DCMAKE_HAVE_LIBC_PTHREAD  -fPIE -o CMakeFiles/cmTC_847c3.dir/src.c.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-XvRDFf/src.c
+        Linking C executable cmTC_847c3
+        /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_847c3.dir/link.txt --verbose=1
+        CMakeFiles/cmTC_847c3.dir/src.c.o: In function `main':
+        src.c:(.text+0x2f): undefined reference to `pthread_create'
+        src.c:(.text+0x3b): undefined reference to `pthread_detach'
+        src.c:(.text+0x47): undefined reference to `pthread_cancel'
+        src.c:(.text+0x58): undefined reference to `pthread_join'
+        collect2: error: ld returned 1 exit status
+        /usr/bin/cc CMakeFiles/cmTC_847c3.dir/src.c.o -o cmTC_847c3
+        gmake[1]: *** [CMakeFiles/cmTC_847c3.dir/build.make:102: cmTC_847c3] Error 1
+        gmake[1]: Leaving directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-XvRDFf'
+        gmake: *** [Makefile:134: cmTC_847c3/fast] Error 2
+        
+      exitCode: 2
+  -
+    kind: "try_compile-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CheckLibraryExists.cmake:112 (try_compile)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindThreads.cmake:112 (check_library_exists)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindThreads.cmake:175 (_threads_check_lib)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindBLAS.cmake:477 (find_package)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindLAPACK.cmake:247 (find_package)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindLAPACK.cmake:283 (_lapack_find_dependency)"
+      - "CMakeLists.txt:208 (find_package)"
+    checks:
+      - "Looking for pthread_create in pthreads"
+    directories:
+      source: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-0oA726"
+      binary: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-0oA726"
+    cmakeVariables:
+      CMAKE_C_FLAGS: ""
+      CMAKE_C_FLAGS_DEBUG: "-g"
+      CMAKE_EXE_LINKER_FLAGS: ""
+      CMAKE_MODULE_PATH: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/cmake"
+      CMAKE_POSITION_INDEPENDENT_CODE: "ON"
+    buildResult:
+      variable: "CMAKE_HAVE_PTHREADS_CREATE"
+      cached: true
+      stdout: |
+        Change Dir: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-0oA726'
+        
+        Run Build Command(s): /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_a134b/fast
+        /usr/bin/gmake  -f CMakeFiles/cmTC_a134b.dir/build.make CMakeFiles/cmTC_a134b.dir/build
+        gmake[1]: Entering directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-0oA726'
+        Building C object CMakeFiles/cmTC_a134b.dir/CheckFunctionExists.c.o
+        /usr/bin/cc   -DCHECK_FUNCTION_EXISTS=pthread_create -fPIE -o CMakeFiles/cmTC_a134b.dir/CheckFunctionExists.c.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-0oA726/CheckFunctionExists.c
+        Linking C executable cmTC_a134b
+        /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_a134b.dir/link.txt --verbose=1
+        /usr/bin/ld: cannot find -lpthreads
+        collect2: error: ld returned 1 exit status
+        /usr/bin/cc  -DCHECK_FUNCTION_EXISTS=pthread_create CMakeFiles/cmTC_a134b.dir/CheckFunctionExists.c.o -o cmTC_a134b  -lpthreads
+        gmake[1]: *** [CMakeFiles/cmTC_a134b.dir/build.make:102: cmTC_a134b] Error 1
+        gmake[1]: Leaving directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-0oA726'
+        gmake: *** [Makefile:134: cmTC_a134b/fast] Error 2
+        
+      exitCode: 2
+  -
+    kind: "try_compile-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CheckLibraryExists.cmake:112 (try_compile)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindThreads.cmake:112 (check_library_exists)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindThreads.cmake:176 (_threads_check_lib)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindBLAS.cmake:477 (find_package)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindLAPACK.cmake:247 (find_package)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindLAPACK.cmake:283 (_lapack_find_dependency)"
+      - "CMakeLists.txt:208 (find_package)"
+    checks:
+      - "Looking for pthread_create in pthread"
+    directories:
+      source: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-FDq1nF"
+      binary: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-FDq1nF"
+    cmakeVariables:
+      CMAKE_C_FLAGS: ""
+      CMAKE_C_FLAGS_DEBUG: "-g"
+      CMAKE_EXE_LINKER_FLAGS: ""
+      CMAKE_MODULE_PATH: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/cmake"
+      CMAKE_POSITION_INDEPENDENT_CODE: "ON"
+    buildResult:
+      variable: "CMAKE_HAVE_PTHREAD_CREATE"
+      cached: true
+      stdout: |
+        Change Dir: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-FDq1nF'
+        
+        Run Build Command(s): /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_ae2c2/fast
+        /usr/bin/gmake  -f CMakeFiles/cmTC_ae2c2.dir/build.make CMakeFiles/cmTC_ae2c2.dir/build
+        gmake[1]: Entering directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-FDq1nF'
+        Building C object CMakeFiles/cmTC_ae2c2.dir/CheckFunctionExists.c.o
+        /usr/bin/cc   -DCHECK_FUNCTION_EXISTS=pthread_create -fPIE -o CMakeFiles/cmTC_ae2c2.dir/CheckFunctionExists.c.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-FDq1nF/CheckFunctionExists.c
+        Linking C executable cmTC_ae2c2
+        /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_ae2c2.dir/link.txt --verbose=1
+        /usr/bin/cc  -DCHECK_FUNCTION_EXISTS=pthread_create CMakeFiles/cmTC_ae2c2.dir/CheckFunctionExists.c.o -o cmTC_ae2c2  -lpthread
+        gmake[1]: Leaving directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-FDq1nF'
+        
+      exitCode: 0
+  -
+    kind: "try_compile-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CheckFunctionExists.cmake:93 (try_compile)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindBLAS.cmake:379 (check_function_exists)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindBLAS.cmake:764 (check_blas_libraries)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindLAPACK.cmake:247 (find_package)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindLAPACK.cmake:283 (_lapack_find_dependency)"
+      - "CMakeLists.txt:208 (find_package)"
+    checks:
+      - "Looking for sgemm_"
+    directories:
+      source: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-K6OIGe"
+      binary: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-K6OIGe"
+    cmakeVariables:
+      CMAKE_C_FLAGS: ""
+      CMAKE_C_FLAGS_DEBUG: "-g"
+      CMAKE_EXE_LINKER_FLAGS: ""
+      CMAKE_MODULE_PATH: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/cmake"
+      CMAKE_POSITION_INDEPENDENT_CODE: "ON"
+    buildResult:
+      variable: "BLAS_openblas_WORKS"
+      cached: true
+      stdout: |
+        Change Dir: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-K6OIGe'
+        
+        Run Build Command(s): /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_cd7b8/fast
+        /usr/bin/gmake  -f CMakeFiles/cmTC_cd7b8.dir/build.make CMakeFiles/cmTC_cd7b8.dir/build
+        gmake[1]: Entering directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-K6OIGe'
+        Building C object CMakeFiles/cmTC_cd7b8.dir/CheckFunctionExists.c.o
+        /usr/bin/cc   -DCHECK_FUNCTION_EXISTS=sgemm_ -fPIE -o CMakeFiles/cmTC_cd7b8.dir/CheckFunctionExists.c.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-K6OIGe/CheckFunctionExists.c
+        Linking C executable cmTC_cd7b8
+        /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_cd7b8.dir/link.txt --verbose=1
+        /usr/bin/cc  -DCHECK_FUNCTION_EXISTS=sgemm_ CMakeFiles/cmTC_cd7b8.dir/CheckFunctionExists.c.o -o cmTC_cd7b8  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/libopenblas.so
+        gmake[1]: Leaving directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-K6OIGe'
+        
+      exitCode: 0
+  -
+    kind: "try_compile-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CheckFunctionExists.cmake:93 (try_compile)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindLAPACK.cmake:220 (check_function_exists)"
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindLAPACK.cmake:399 (check_lapack_libraries)"
+      - "CMakeLists.txt:208 (find_package)"
+    checks:
+      - "Looking for cheev_"
+    directories:
+      source: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-yGpKmC"
+      binary: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-yGpKmC"
+    cmakeVariables:
+      CMAKE_C_FLAGS: ""
+      CMAKE_C_FLAGS_DEBUG: "-g"
+      CMAKE_EXE_LINKER_FLAGS: ""
+      CMAKE_MODULE_PATH: "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/cmake"
+      CMAKE_POSITION_INDEPENDENT_CODE: "ON"
+    buildResult:
+      variable: "LAPACK_WORKS"
+      cached: true
+      stdout: |
+        Change Dir: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-yGpKmC'
+        
+        Run Build Command(s): /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_f6fc9/fast
+        /usr/bin/gmake  -f CMakeFiles/cmTC_f6fc9.dir/build.make CMakeFiles/cmTC_f6fc9.dir/build
+        gmake[1]: Entering directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-yGpKmC'
+        Building C object CMakeFiles/cmTC_f6fc9.dir/CheckFunctionExists.c.o
+        /usr/bin/cc   -DCHECK_FUNCTION_EXISTS=cheev_ -fPIE -o CMakeFiles/cmTC_f6fc9.dir/CheckFunctionExists.c.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-yGpKmC/CheckFunctionExists.c
+        Linking C executable cmTC_f6fc9
+        /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E cmake_link_script CMakeFiles/cmTC_f6fc9.dir/link.txt --verbose=1
+        /usr/bin/cc  -DCHECK_FUNCTION_EXISTS=cheev_ CMakeFiles/cmTC_f6fc9.dir/CheckFunctionExists.c.o -o cmTC_f6fc9  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/libopenblas.so -lpthread -lm -ldl
+        gmake[1]: Leaving directory '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeScratch/TryCompile-yGpKmC'
+        
+      exitCode: 0
+...
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb9de92640e91b3d38364ee7a569cd8b862951
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeRuleHashes.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeRuleHashes.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0cad7767cb81c5055a1c5272e3e72f0fd7724511
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/CMakeRuleHashes.txt
@@ -0,0 +1,3 @@
+# Hashes of file build rules.
+fac202fc3d7f87e1b1dd777fa67932a9 mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble
+1f45cea39e3c9aaad29d207f7586515e mlx/backend/cpu/compiled_preamble.cpp
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Export/1e8da368a82b8fcebd3a63675e0335e4/MLXTargets-release.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Export/1e8da368a82b8fcebd3a63675e0335e4/MLXTargets-release.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..9efcb5dc1167dbda92c70f434b51a6992040513d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Export/1e8da368a82b8fcebd3a63675e0335e4/MLXTargets-release.cmake
@@ -0,0 +1,19 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "mlx" for configuration "Release"
+set_property(TARGET mlx APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(mlx PROPERTIES
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libmlx.so"
+  IMPORTED_SONAME_RELEASE "libmlx.so"
+  )
+
+list(APPEND _cmake_import_check_targets mlx )
+list(APPEND _cmake_import_check_files_for_mlx "${_IMPORT_PREFIX}/lib64/libmlx.so" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Export/1e8da368a82b8fcebd3a63675e0335e4/MLXTargets.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Export/1e8da368a82b8fcebd3a63675e0335e4/MLXTargets.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..da5189a2b47f51454f7b4ccb23e9dd3d43997f02
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Export/1e8da368a82b8fcebd3a63675e0335e4/MLXTargets.cmake
@@ -0,0 +1,106 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+   message(FATAL_ERROR "CMake >= 2.8.3 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "2.8.3")
+   message(FATAL_ERROR "CMake >= 2.8.3 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 2.8.3...3.30)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS mlx)
+  list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+  if(TARGET "${_cmake_expected_target}")
+    list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+  else()
+    list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+  endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+  unset(_cmake_targets_defined)
+  unset(_cmake_targets_not_defined)
+  unset(_cmake_expected_targets)
+  unset(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+  string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+  string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target mlx
+add_library(mlx SHARED IMPORTED)
+
+set_target_properties(mlx PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include;${_IMPORT_PREFIX}/include"
+)
+
+# Load information for each installed configuration.
+file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/MLXTargets-*.cmake")
+foreach(_cmake_config_file IN LISTS _cmake_config_files)
+  include("${_cmake_config_file}")
+endforeach()
+unset(_cmake_config_file)
+unset(_cmake_config_files)
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(_cmake_target IN LISTS _cmake_import_check_targets)
+  if(CMAKE_VERSION VERSION_LESS "3.28"
+      OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target}
+      OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}")
+    foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+      if(NOT EXISTS "${_cmake_file}")
+        message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+   \"${_cmake_file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+      endif()
+    endforeach()
+  endif()
+  unset(_cmake_file)
+  unset("_cmake_import_check_files_for_${_cmake_target}")
+endforeach()
+unset(_cmake_target)
+unset(_cmake_import_check_targets)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/InstallScripts.json b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/InstallScripts.json
new file mode 100644
index 0000000000000000000000000000000000000000..ef43874e8483de01881c00cfb42f683b67247e1d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/InstallScripts.json
@@ -0,0 +1,19 @@
+{
+	"InstallScripts" : 
+	[
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/cmake_install.cmake",
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/cmake_install.cmake",
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/cmake_install.cmake",
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/cmake_install.cmake",
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/cmake_install.cmake",
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/cmake_install.cmake",
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/cmake_install.cmake",
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/cmake_install.cmake",
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/cmake_install.cmake",
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/cmake_install.cmake",
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/cmake_install.cmake",
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/cmake_install.cmake",
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/cmake_install.cmake"
+	],
+	"Parallel" : false
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Makefile.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Makefile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..93e6ae9cee964cdf79994284c536c5c08bc794b8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Makefile.cmake
@@ -0,0 +1,136 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# The generator used is:
+set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles")
+
+# The top level Makefile was generated from the following files:
+set(CMAKE_MAKEFILE_DEPENDS
+  "CMakeCache.txt"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/BasicConfigVersion-AnyNewerVersion.cmake.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/BasicConfigVersion-SameMajorVersion.cmake.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeCInformation.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeCXXInformation.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeCommonLanguageInclude.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeGenericSystem.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeInitializeConfigs.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeLanguageInformation.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakePackageConfigHelpers.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeParseArguments.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeSystemSpecificInformation.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeSystemSpecificInitialize.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CheckCSourceCompiles.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CheckCXXCompilerFlag.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CheckCXXSourceCompiles.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CheckFunctionExists.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CheckIncludeFile.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CheckLibraryExists.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Compiler/CMakeCommonCompilerMacros.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Compiler/GNU-C.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Compiler/GNU-CXX.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Compiler/GNU.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/shared_internal_commands.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FetchContent.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FetchContent/CMakeLists.cmake.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindBLAS.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindGit.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindLAPACK.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindPackageHandleStandardArgs.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindPackageMessage.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindPython.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindPython/Support.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/FindThreads.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/GNUInstallDirs.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Internal/CMakeCLinkerInformation.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Internal/CMakeCXXLinkerInformation.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Internal/CMakeCommonLinkerInformation.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Internal/CheckCompilerFlag.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Internal/CheckFlagCommonConfig.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Internal/CheckSourceCompiles.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Linker/GNU-C.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Linker/GNU-CXX.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Linker/GNU.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linker/GNU.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linker/Linux-GNU-C.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linker/Linux-GNU-CXX.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linker/Linux-GNU.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linux-GNU-C.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linux-GNU-CXX.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linux-GNU.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linux-Initialize.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linux.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/UnixPaths.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/WriteBasicConfigVersionFile.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/cmake/nanobind-config-version.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/cmake/nanobind-config.cmake"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/CMakeLists.txt"
+  "CMakeFiles/4.0.3/CMakeCCompiler.cmake"
+  "CMakeFiles/4.0.3/CMakeCXXCompiler.cmake"
+  "CMakeFiles/4.0.3/CMakeSystem.cmake"
+  "_deps/fmt-src/CMakeLists.txt"
+  "_deps/fmt-src/support/cmake/JoinPaths.cmake"
+  "_deps/fmt-src/support/cmake/fmt-config.cmake.in"
+  "_deps/fmt-src/support/cmake/fmt.pc.in"
+  "_deps/json-src/CMakeLists.txt"
+  "_deps/json-src/cmake/config.cmake.in"
+  "_deps/json-src/cmake/nlohmann_jsonConfigVersion.cmake.in"
+  "_deps/json-src/cmake/pkg-config.pc.in"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx.pc.in"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/CMakeLists.txt"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/CMakeLists.txt"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/CMakeLists.txt"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/CMakeLists.txt"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/CMakeLists.txt"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/CMakeLists.txt"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/CMakeLists.txt"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/CMakeLists.txt"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/CMakeLists.txt"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/CMakeLists.txt"
+  )
+
+# The corresponding makefile is:
+set(CMAKE_MAKEFILE_OUTPUTS
+  "Makefile"
+  "CMakeFiles/cmake.check_cache"
+  )
+
+# Byproducts of CMake generate step:
+set(CMAKE_MAKEFILE_PRODUCTS
+  "_deps/json-subbuild/CMakeLists.txt"
+  "_deps/fmt-subbuild/CMakeLists.txt"
+  "MLXConfigVersion.cmake"
+  "MLXConfig.cmake"
+  "CMakeFiles/CMakeDirectoryInformation.cmake"
+  "_deps/json-build/nlohmann_json.pc"
+  "_deps/json-build/nlohmann_jsonConfigVersion.cmake"
+  "_deps/json-build/nlohmann_jsonConfig.cmake"
+  "_deps/json-build/CMakeFiles/CMakeDirectoryInformation.cmake"
+  "mlx/CMakeFiles/CMakeDirectoryInformation.cmake"
+  "mlx/backend/common/CMakeFiles/CMakeDirectoryInformation.cmake"
+  "mlx/backend/cpu/CMakeFiles/CMakeDirectoryInformation.cmake"
+  "mlx/distributed/CMakeFiles/CMakeDirectoryInformation.cmake"
+  "mlx/distributed/mpi/CMakeFiles/CMakeDirectoryInformation.cmake"
+  "mlx/distributed/ring/CMakeFiles/CMakeDirectoryInformation.cmake"
+  "mlx/distributed/nccl/CMakeFiles/CMakeDirectoryInformation.cmake"
+  "_deps/gguflib-subbuild/CMakeLists.txt"
+  "mlx/io/CMakeFiles/CMakeDirectoryInformation.cmake"
+  "mlx/backend/no_gpu/CMakeFiles/CMakeDirectoryInformation.cmake"
+  "_deps/fmt-build/fmt-config-version.cmake"
+  "_deps/fmt-build/fmt.pc"
+  "_deps/fmt-build/fmt-config.cmake"
+  "_deps/fmt-build/CMakeFiles/CMakeDirectoryInformation.cmake"
+  "python/src/CMakeFiles/CMakeDirectoryInformation.cmake"
+  )
+
+# Dependency information for all targets:
+set(CMAKE_DEPEND_INFO_FILES
+  "CMakeFiles/mlx.dir/DependInfo.cmake"
+  "mlx/CMakeFiles/mlx_version.dir/DependInfo.cmake"
+  "mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/DependInfo.cmake"
+  "mlx/io/CMakeFiles/gguflib.dir/DependInfo.cmake"
+  "_deps/fmt-build/CMakeFiles/fmt.dir/DependInfo.cmake"
+  "python/src/CMakeFiles/core.dir/DependInfo.cmake"
+  "python/src/CMakeFiles/nanobind-static.dir/DependInfo.cmake"
+  )
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Makefile2 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Makefile2
new file mode 100644
index 0000000000000000000000000000000000000000..2335202143cad4d93bb28d433348f8e321ab215a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Makefile2
@@ -0,0 +1,585 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Directory level rules for the build root directory
+
+# The main recursive "all" target.
+all: CMakeFiles/mlx.dir/all
+all: _deps/json-build/all
+all: mlx/all
+all: python/src/all
+.PHONY : all
+
+# The main recursive "codegen" target.
+codegen: CMakeFiles/mlx.dir/codegen
+codegen: _deps/json-build/codegen
+codegen: mlx/codegen
+codegen: python/src/codegen
+.PHONY : codegen
+
+# The main recursive "preinstall" target.
+preinstall: _deps/json-build/preinstall
+preinstall: mlx/preinstall
+preinstall: python/src/preinstall
+.PHONY : preinstall
+
+# The main recursive "clean" target.
+clean: CMakeFiles/mlx.dir/clean
+clean: _deps/json-build/clean
+clean: mlx/clean
+clean: _deps/fmt-build/clean
+clean: python/src/clean
+.PHONY : clean
+
+#=============================================================================
+# Directory level rules for directory _deps/fmt-build
+
+# Recursive "all" directory target.
+_deps/fmt-build/all: _deps/fmt-build/CMakeFiles/fmt.dir/all
+.PHONY : _deps/fmt-build/all
+
+# Recursive "codegen" directory target.
+_deps/fmt-build/codegen: _deps/fmt-build/CMakeFiles/fmt.dir/codegen
+.PHONY : _deps/fmt-build/codegen
+
+# Recursive "preinstall" directory target.
+_deps/fmt-build/preinstall:
+.PHONY : _deps/fmt-build/preinstall
+
+# Recursive "clean" directory target.
+_deps/fmt-build/clean: _deps/fmt-build/CMakeFiles/fmt.dir/clean
+.PHONY : _deps/fmt-build/clean
+
+#=============================================================================
+# Directory level rules for directory _deps/json-build
+
+# Recursive "all" directory target.
+_deps/json-build/all:
+.PHONY : _deps/json-build/all
+
+# Recursive "codegen" directory target.
+_deps/json-build/codegen:
+.PHONY : _deps/json-build/codegen
+
+# Recursive "preinstall" directory target.
+_deps/json-build/preinstall:
+.PHONY : _deps/json-build/preinstall
+
+# Recursive "clean" directory target.
+_deps/json-build/clean:
+.PHONY : _deps/json-build/clean
+
+#=============================================================================
+# Directory level rules for directory mlx
+
+# Recursive "all" directory target.
+mlx/all: mlx/CMakeFiles/mlx_version.dir/all
+mlx/all: mlx/backend/common/all
+mlx/all: mlx/backend/cpu/all
+mlx/all: mlx/distributed/all
+mlx/all: mlx/io/all
+mlx/all: mlx/backend/no_gpu/all
+.PHONY : mlx/all
+
+# Recursive "codegen" directory target.
+mlx/codegen: mlx/CMakeFiles/mlx_version.dir/codegen
+mlx/codegen: mlx/backend/common/codegen
+mlx/codegen: mlx/backend/cpu/codegen
+mlx/codegen: mlx/distributed/codegen
+mlx/codegen: mlx/io/codegen
+mlx/codegen: mlx/backend/no_gpu/codegen
+.PHONY : mlx/codegen
+
+# Recursive "preinstall" directory target.
+mlx/preinstall: mlx/backend/common/preinstall
+mlx/preinstall: mlx/backend/cpu/preinstall
+mlx/preinstall: mlx/distributed/preinstall
+mlx/preinstall: mlx/io/preinstall
+mlx/preinstall: mlx/backend/no_gpu/preinstall
+.PHONY : mlx/preinstall
+
+# Recursive "clean" directory target.
+mlx/clean: mlx/CMakeFiles/mlx_version.dir/clean
+mlx/clean: mlx/backend/common/clean
+mlx/clean: mlx/backend/cpu/clean
+mlx/clean: mlx/distributed/clean
+mlx/clean: mlx/io/clean
+mlx/clean: mlx/backend/no_gpu/clean
+.PHONY : mlx/clean
+
+#=============================================================================
+# Directory level rules for directory mlx/backend/common
+
+# Recursive "all" directory target.
+mlx/backend/common/all:
+.PHONY : mlx/backend/common/all
+
+# Recursive "codegen" directory target.
+mlx/backend/common/codegen:
+.PHONY : mlx/backend/common/codegen
+
+# Recursive "preinstall" directory target.
+mlx/backend/common/preinstall:
+.PHONY : mlx/backend/common/preinstall
+
+# Recursive "clean" directory target.
+mlx/backend/common/clean:
+.PHONY : mlx/backend/common/clean
+
+#=============================================================================
+# Directory level rules for directory mlx/backend/cpu
+
+# Recursive "all" directory target.
+mlx/backend/cpu/all:
+.PHONY : mlx/backend/cpu/all
+
+# Recursive "codegen" directory target.
+mlx/backend/cpu/codegen:
+.PHONY : mlx/backend/cpu/codegen
+
+# Recursive "preinstall" directory target.
+mlx/backend/cpu/preinstall:
+.PHONY : mlx/backend/cpu/preinstall
+
+# Recursive "clean" directory target.
+mlx/backend/cpu/clean: mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/clean
+.PHONY : mlx/backend/cpu/clean
+
+#=============================================================================
+# Directory level rules for directory mlx/backend/no_gpu
+
+# Recursive "all" directory target.
+mlx/backend/no_gpu/all:
+.PHONY : mlx/backend/no_gpu/all
+
+# Recursive "codegen" directory target.
+mlx/backend/no_gpu/codegen:
+.PHONY : mlx/backend/no_gpu/codegen
+
+# Recursive "preinstall" directory target.
+mlx/backend/no_gpu/preinstall:
+.PHONY : mlx/backend/no_gpu/preinstall
+
+# Recursive "clean" directory target.
+mlx/backend/no_gpu/clean:
+.PHONY : mlx/backend/no_gpu/clean
+
+#=============================================================================
+# Directory level rules for directory mlx/distributed
+
+# Recursive "all" directory target.
+mlx/distributed/all: mlx/distributed/mpi/all
+mlx/distributed/all: mlx/distributed/ring/all
+mlx/distributed/all: mlx/distributed/nccl/all
+.PHONY : mlx/distributed/all
+
+# Recursive "codegen" directory target.
+mlx/distributed/codegen: mlx/distributed/mpi/codegen
+mlx/distributed/codegen: mlx/distributed/ring/codegen
+mlx/distributed/codegen: mlx/distributed/nccl/codegen
+.PHONY : mlx/distributed/codegen
+
+# Recursive "preinstall" directory target.
+mlx/distributed/preinstall: mlx/distributed/mpi/preinstall
+mlx/distributed/preinstall: mlx/distributed/ring/preinstall
+mlx/distributed/preinstall: mlx/distributed/nccl/preinstall
+.PHONY : mlx/distributed/preinstall
+
+# Recursive "clean" directory target.
+mlx/distributed/clean: mlx/distributed/mpi/clean
+mlx/distributed/clean: mlx/distributed/ring/clean
+mlx/distributed/clean: mlx/distributed/nccl/clean
+.PHONY : mlx/distributed/clean
+
+#=============================================================================
+# Directory level rules for directory mlx/distributed/mpi
+
+# Recursive "all" directory target.
+mlx/distributed/mpi/all:
+.PHONY : mlx/distributed/mpi/all
+
+# Recursive "codegen" directory target.
+mlx/distributed/mpi/codegen:
+.PHONY : mlx/distributed/mpi/codegen
+
+# Recursive "preinstall" directory target.
+mlx/distributed/mpi/preinstall:
+.PHONY : mlx/distributed/mpi/preinstall
+
+# Recursive "clean" directory target.
+mlx/distributed/mpi/clean:
+.PHONY : mlx/distributed/mpi/clean
+
+#=============================================================================
+# Directory level rules for directory mlx/distributed/nccl
+
+# Recursive "all" directory target.
+mlx/distributed/nccl/all:
+.PHONY : mlx/distributed/nccl/all
+
+# Recursive "codegen" directory target.
+mlx/distributed/nccl/codegen:
+.PHONY : mlx/distributed/nccl/codegen
+
+# Recursive "preinstall" directory target.
+mlx/distributed/nccl/preinstall:
+.PHONY : mlx/distributed/nccl/preinstall
+
+# Recursive "clean" directory target.
+mlx/distributed/nccl/clean:
+.PHONY : mlx/distributed/nccl/clean
+
+#=============================================================================
+# Directory level rules for directory mlx/distributed/ring
+
+# Recursive "all" directory target.
+mlx/distributed/ring/all:
+.PHONY : mlx/distributed/ring/all
+
+# Recursive "codegen" directory target.
+mlx/distributed/ring/codegen:
+.PHONY : mlx/distributed/ring/codegen
+
+# Recursive "preinstall" directory target.
+mlx/distributed/ring/preinstall:
+.PHONY : mlx/distributed/ring/preinstall
+
+# Recursive "clean" directory target.
+mlx/distributed/ring/clean:
+.PHONY : mlx/distributed/ring/clean
+
+#=============================================================================
+# Directory level rules for directory mlx/io
+
+# Recursive "all" directory target.
+mlx/io/all: mlx/io/CMakeFiles/gguflib.dir/all
+.PHONY : mlx/io/all
+
+# Recursive "codegen" directory target.
+mlx/io/codegen: mlx/io/CMakeFiles/gguflib.dir/codegen
+.PHONY : mlx/io/codegen
+
+# Recursive "preinstall" directory target.
+mlx/io/preinstall:
+.PHONY : mlx/io/preinstall
+
+# Recursive "clean" directory target.
+mlx/io/clean: mlx/io/CMakeFiles/gguflib.dir/clean
+.PHONY : mlx/io/clean
+
+#=============================================================================
+# Directory level rules for directory python/src
+
+# Recursive "all" directory target.
+python/src/all: python/src/CMakeFiles/core.dir/all
+.PHONY : python/src/all
+
+# Recursive "codegen" directory target.
+python/src/codegen: python/src/CMakeFiles/core.dir/codegen
+.PHONY : python/src/codegen
+
+# Recursive "preinstall" directory target.
+python/src/preinstall:
+.PHONY : python/src/preinstall
+
+# Recursive "clean" directory target.
+python/src/clean: python/src/CMakeFiles/core.dir/clean
+python/src/clean: python/src/CMakeFiles/nanobind-static.dir/clean
+.PHONY : python/src/clean
+
+#=============================================================================
+# Target rules for target CMakeFiles/mlx.dir
+
+# All Build rule for target.
+CMakeFiles/mlx.dir/all: mlx/CMakeFiles/mlx_version.dir/all
+CMakeFiles/mlx.dir/all: mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/all
+CMakeFiles/mlx.dir/all: mlx/io/CMakeFiles/gguflib.dir/all
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/depend
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90 "Built target mlx"
+.PHONY : CMakeFiles/mlx.dir/all
+
+# Build rule for subdir invocation for target.
+CMakeFiles/mlx.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 68
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/mlx.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : CMakeFiles/mlx.dir/rule
+
+# Convenience name for target.
+mlx: CMakeFiles/mlx.dir/rule
+.PHONY : mlx
+
+# codegen rule for target.
+CMakeFiles/mlx.dir/codegen: mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/all
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/codegen
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90 "Finished codegen for target mlx"
+.PHONY : CMakeFiles/mlx.dir/codegen
+
+# clean rule for target.
+CMakeFiles/mlx.dir/clean:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/clean
+.PHONY : CMakeFiles/mlx.dir/clean
+
+#=============================================================================
+# Target rules for target mlx/CMakeFiles/mlx_version.dir
+
+# All Build rule for target.
+mlx/CMakeFiles/mlx_version.dir/all:
+	$(MAKE) $(MAKESILENT) -f mlx/CMakeFiles/mlx_version.dir/build.make mlx/CMakeFiles/mlx_version.dir/depend
+	$(MAKE) $(MAKESILENT) -f mlx/CMakeFiles/mlx_version.dir/build.make mlx/CMakeFiles/mlx_version.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num= "Built target mlx_version"
+.PHONY : mlx/CMakeFiles/mlx_version.dir/all
+
+# Build rule for subdir invocation for target.
+mlx/CMakeFiles/mlx_version.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/CMakeFiles/mlx_version.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : mlx/CMakeFiles/mlx_version.dir/rule
+
+# Convenience name for target.
+mlx_version: mlx/CMakeFiles/mlx_version.dir/rule
+.PHONY : mlx_version
+
+# codegen rule for target.
+mlx/CMakeFiles/mlx_version.dir/codegen:
+	$(MAKE) $(MAKESILENT) -f mlx/CMakeFiles/mlx_version.dir/build.make mlx/CMakeFiles/mlx_version.dir/codegen
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num= "Finished codegen for target mlx_version"
+.PHONY : mlx/CMakeFiles/mlx_version.dir/codegen
+
+# clean rule for target.
+mlx/CMakeFiles/mlx_version.dir/clean:
+	$(MAKE) $(MAKESILENT) -f mlx/CMakeFiles/mlx_version.dir/build.make mlx/CMakeFiles/mlx_version.dir/clean
+.PHONY : mlx/CMakeFiles/mlx_version.dir/clean
+
+#=============================================================================
+# Target rules for target mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir
+
+# All Build rule for target.
+mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/all:
+	$(MAKE) $(MAKESILENT) -f mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build.make mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/depend
+	$(MAKE) $(MAKESILENT) -f mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build.make mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num= "Built target cpu_compiled_preamble"
+.PHONY : mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/all
+
+# Build rule for subdir invocation for target.
+mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/rule
+
+# Convenience name for target.
+cpu_compiled_preamble: mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/rule
+.PHONY : cpu_compiled_preamble
+
+# codegen rule for target.
+mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/codegen:
+	$(MAKE) $(MAKESILENT) -f mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build.make mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/codegen
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num= "Finished codegen for target cpu_compiled_preamble"
+.PHONY : mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/codegen
+
+# clean rule for target.
+mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/clean:
+	$(MAKE) $(MAKESILENT) -f mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build.make mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/clean
+.PHONY : mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/clean
+
+#=============================================================================
+# Target rules for target mlx/io/CMakeFiles/gguflib.dir
+
+# All Build rule for target.
+mlx/io/CMakeFiles/gguflib.dir/all:
+	$(MAKE) $(MAKESILENT) -f mlx/io/CMakeFiles/gguflib.dir/build.make mlx/io/CMakeFiles/gguflib.dir/depend
+	$(MAKE) $(MAKESILENT) -f mlx/io/CMakeFiles/gguflib.dir/build.make mlx/io/CMakeFiles/gguflib.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=23,24 "Built target gguflib"
+.PHONY : mlx/io/CMakeFiles/gguflib.dir/all
+
+# Build rule for subdir invocation for target.
+mlx/io/CMakeFiles/gguflib.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 2
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/io/CMakeFiles/gguflib.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : mlx/io/CMakeFiles/gguflib.dir/rule
+
+# Convenience name for target.
+gguflib: mlx/io/CMakeFiles/gguflib.dir/rule
+.PHONY : gguflib
+
+# codegen rule for target.
+mlx/io/CMakeFiles/gguflib.dir/codegen:
+	$(MAKE) $(MAKESILENT) -f mlx/io/CMakeFiles/gguflib.dir/build.make mlx/io/CMakeFiles/gguflib.dir/codegen
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=23,24 "Finished codegen for target gguflib"
+.PHONY : mlx/io/CMakeFiles/gguflib.dir/codegen
+
+# clean rule for target.
+mlx/io/CMakeFiles/gguflib.dir/clean:
+	$(MAKE) $(MAKESILENT) -f mlx/io/CMakeFiles/gguflib.dir/build.make mlx/io/CMakeFiles/gguflib.dir/clean
+.PHONY : mlx/io/CMakeFiles/gguflib.dir/clean
+
+#=============================================================================
+# Target rules for target _deps/fmt-build/CMakeFiles/fmt.dir
+
+# All Build rule for target.
+_deps/fmt-build/CMakeFiles/fmt.dir/all:
+	$(MAKE) $(MAKESILENT) -f _deps/fmt-build/CMakeFiles/fmt.dir/build.make _deps/fmt-build/CMakeFiles/fmt.dir/depend
+	$(MAKE) $(MAKESILENT) -f _deps/fmt-build/CMakeFiles/fmt.dir/build.make _deps/fmt-build/CMakeFiles/fmt.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=20,21,22 "Built target fmt"
+.PHONY : _deps/fmt-build/CMakeFiles/fmt.dir/all
+
+# Build rule for subdir invocation for target.
+_deps/fmt-build/CMakeFiles/fmt.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 3
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 _deps/fmt-build/CMakeFiles/fmt.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : _deps/fmt-build/CMakeFiles/fmt.dir/rule
+
+# Convenience name for target.
+fmt: _deps/fmt-build/CMakeFiles/fmt.dir/rule
+.PHONY : fmt
+
+# codegen rule for target.
+_deps/fmt-build/CMakeFiles/fmt.dir/codegen:
+	$(MAKE) $(MAKESILENT) -f _deps/fmt-build/CMakeFiles/fmt.dir/build.make _deps/fmt-build/CMakeFiles/fmt.dir/codegen
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=20,21,22 "Finished codegen for target fmt"
+.PHONY : _deps/fmt-build/CMakeFiles/fmt.dir/codegen
+
+# clean rule for target.
+_deps/fmt-build/CMakeFiles/fmt.dir/clean:
+	$(MAKE) $(MAKESILENT) -f _deps/fmt-build/CMakeFiles/fmt.dir/build.make _deps/fmt-build/CMakeFiles/fmt.dir/clean
+.PHONY : _deps/fmt-build/CMakeFiles/fmt.dir/clean
+
+#=============================================================================
+# Target rules for target python/src/CMakeFiles/core.dir
+
+# All Build rule for target.
+python/src/CMakeFiles/core.dir/all: CMakeFiles/mlx.dir/all
+python/src/CMakeFiles/core.dir/all: python/src/CMakeFiles/nanobind-static.dir/all
+	$(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/depend
+	$(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 "Built target core"
+.PHONY : python/src/CMakeFiles/core.dir/all
+
+# Build rule for subdir invocation for target.
+python/src/CMakeFiles/core.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 97
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 python/src/CMakeFiles/core.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : python/src/CMakeFiles/core.dir/rule
+
+# Convenience name for target.
+core: python/src/CMakeFiles/core.dir/rule
+.PHONY : core
+
+# codegen rule for target.
+python/src/CMakeFiles/core.dir/codegen:
+	$(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/codegen
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 "Finished codegen for target core"
+.PHONY : python/src/CMakeFiles/core.dir/codegen
+
+# clean rule for target.
+python/src/CMakeFiles/core.dir/clean:
+	$(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/clean
+.PHONY : python/src/CMakeFiles/core.dir/clean
+
+#=============================================================================
+# Target rules for target python/src/CMakeFiles/nanobind-static.dir
+
+# All Build rule for target.
+python/src/CMakeFiles/nanobind-static.dir/all:
+	$(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/depend
+	$(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=91,92,93,94,95,96,97,98,99,100 "Built target nanobind-static"
+.PHONY : python/src/CMakeFiles/nanobind-static.dir/all
+
+# Build rule for subdir invocation for target.
+python/src/CMakeFiles/nanobind-static.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 10
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 python/src/CMakeFiles/nanobind-static.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : python/src/CMakeFiles/nanobind-static.dir/rule
+
+# Convenience name for target.
+nanobind-static: python/src/CMakeFiles/nanobind-static.dir/rule
+.PHONY : nanobind-static
+
+# codegen rule for target.
+python/src/CMakeFiles/nanobind-static.dir/codegen:
+	$(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/codegen
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=91,92,93,94,95,96,97,98,99,100 "Finished codegen for target nanobind-static"
+.PHONY : python/src/CMakeFiles/nanobind-static.dir/codegen
+
+# clean rule for target.
+python/src/CMakeFiles/nanobind-static.dir/clean:
+	$(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/clean
+.PHONY : python/src/CMakeFiles/nanobind-static.dir/clean
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/100 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/100
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/100
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/23 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/23
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/23
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/24 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/24
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/24
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/74 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/74
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/74
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/75 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/75
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/75
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/79 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/79
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/79
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/81 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/81
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/81
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/82 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/82
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/82
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/83 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/83
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/83
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/91 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/91
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/91
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/92 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/92
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/92
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/93 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/93
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/93
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/94 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/94
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/94
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/95 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/95
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/95
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/96 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/96
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/96
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/97 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/97
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/97
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/98 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/98
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/98
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/99 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/99
new file mode 100644
index 0000000000000000000000000000000000000000..7b4d68d70fcae134d5348f5e118f5e9c9d3f05f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/99
@@ -0,0 +1 @@
+empty
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/count.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/count.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c17e934b51c1f08a2b3056e4cd63fe62d111672d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Progress/count.txt
@@ -0,0 +1 @@
+97
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/TargetDirectories.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/TargetDirectories.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5a7761083515cd704447315d42fd6710efee3bab
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/TargetDirectories.txt
@@ -0,0 +1,85 @@
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/rebuild_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/list_install_components.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/install.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/install/local.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/install/strip.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/CMakeFiles/rebuild_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/CMakeFiles/list_install_components.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/CMakeFiles/install.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/CMakeFiles/install/local.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/CMakeFiles/install/strip.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/rebuild_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/list_install_components.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/install.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/install/local.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/install/strip.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/CMakeFiles/rebuild_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/CMakeFiles/list_install_components.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/CMakeFiles/install.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/CMakeFiles/install/local.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/CMakeFiles/install/strip.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/rebuild_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/list_install_components.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/install.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/install/local.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/install/strip.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/CMakeFiles/rebuild_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/CMakeFiles/list_install_components.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/CMakeFiles/install.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/CMakeFiles/install/local.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/CMakeFiles/install/strip.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/CMakeFiles/rebuild_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/CMakeFiles/list_install_components.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/CMakeFiles/install.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/CMakeFiles/install/local.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/CMakeFiles/install/strip.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/CMakeFiles/rebuild_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/CMakeFiles/list_install_components.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/CMakeFiles/install.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/CMakeFiles/install/local.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/CMakeFiles/install/strip.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/CMakeFiles/rebuild_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/CMakeFiles/list_install_components.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/CMakeFiles/install.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/CMakeFiles/install/local.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/CMakeFiles/install/strip.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/rebuild_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/list_install_components.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/install.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/install/local.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/install/strip.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/CMakeFiles/rebuild_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/CMakeFiles/list_install_components.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/CMakeFiles/install.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/CMakeFiles/install/local.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/CMakeFiles/install/strip.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/rebuild_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/list_install_components.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/install.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/install/local.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/install/strip.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/rebuild_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/list_install_components.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/install.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/install/local.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/install/strip.dir
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/cmake.check_cache b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/cmake.check_cache
new file mode 100644
index 0000000000000000000000000000000000000000..3dccd731726d7faa8b29d8d7dba3b981a53ca497
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/cmake.check_cache
@@ -0,0 +1 @@
+# This file is generated by cmake for dependency checking of the CMakeCache.txt file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/DependInfo.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/DependInfo.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e7f55528fb6f954610ee362a97b8e33581396fa2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/DependInfo.cmake
@@ -0,0 +1,100 @@
+
+# Consider dependencies only in project.
+set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
+
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  )
+
+# The set of dependency files which are needed:
+set(CMAKE_DEPENDS_DEPENDENCY_FILES
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.cpp" "CMakeFiles/mlx.dir/mlx/allocator.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/allocator.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.cpp" "CMakeFiles/mlx.dir/mlx/array.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/array.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp" "CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp" "CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp" "CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp" "CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp" "CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp" "CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp" "CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/compiled_preamble.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp" "CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp" "CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp" "CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp" "CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp" "CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp" "CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp" "CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp" "CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.cpp" "CMakeFiles/mlx.dir/mlx/compile.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/compile.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.cpp" "CMakeFiles/mlx.dir/mlx/device.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/device.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp" "CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp" "CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp" "CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp" "CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp" "CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp" "CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.cpp" "CMakeFiles/mlx.dir/mlx/dtype.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/dtype.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp" "CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.cpp" "CMakeFiles/mlx.dir/mlx/einsum.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/einsum.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.cpp" "CMakeFiles/mlx.dir/mlx/export.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/export.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.cpp" "CMakeFiles/mlx.dir/mlx/fast.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/fast.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.cpp" "CMakeFiles/mlx.dir/mlx/fft.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/fft.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.cpp" "CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.cpp" "CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp" "CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.cpp" "CMakeFiles/mlx.dir/mlx/io/load.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/io/load.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp" "CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.cpp" "CMakeFiles/mlx.dir/mlx/linalg.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/linalg.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.cpp" "CMakeFiles/mlx.dir/mlx/ops.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/ops.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.cpp" "CMakeFiles/mlx.dir/mlx/primitives.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/primitives.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.cpp" "CMakeFiles/mlx.dir/mlx/random.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/random.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.cpp" "CMakeFiles/mlx.dir/mlx/scheduler.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/scheduler.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.cpp" "CMakeFiles/mlx.dir/mlx/transforms.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/transforms.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.cpp" "CMakeFiles/mlx.dir/mlx/utils.cpp.o" "gcc" "CMakeFiles/mlx.dir/mlx/utils.cpp.o.d"
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/build.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/build.make
new file mode 100644
index 0000000000000000000000000000000000000000..a0807d0d6a016dc815e78224e889871eac83504d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/build.make
@@ -0,0 +1,1350 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+# Include any dependencies generated for this target.
+include CMakeFiles/mlx.dir/depend.make
+# Include any dependencies generated by the compiler for this target.
+include CMakeFiles/mlx.dir/compiler_depend.make
+
+# Include the progress variables for this target.
+include CMakeFiles/mlx.dir/progress.make
+
+# Include the compile flags for this target's objects.
+include CMakeFiles/mlx.dir/flags.make
+
+CMakeFiles/mlx.dir/codegen:
+.PHONY : CMakeFiles/mlx.dir/codegen
+
+CMakeFiles/mlx.dir/mlx/allocator.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/allocator.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.cpp
+CMakeFiles/mlx.dir/mlx/allocator.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object CMakeFiles/mlx.dir/mlx/allocator.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/allocator.cpp.o -MF CMakeFiles/mlx.dir/mlx/allocator.cpp.o.d -o CMakeFiles/mlx.dir/mlx/allocator.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.cpp
+
+CMakeFiles/mlx.dir/mlx/allocator.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/allocator.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.cpp > CMakeFiles/mlx.dir/mlx/allocator.cpp.i
+
+CMakeFiles/mlx.dir/mlx/allocator.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/allocator.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.cpp -o CMakeFiles/mlx.dir/mlx/allocator.cpp.s
+
+CMakeFiles/mlx.dir/mlx/array.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/array.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.cpp
+CMakeFiles/mlx.dir/mlx/array.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object CMakeFiles/mlx.dir/mlx/array.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/array.cpp.o -MF CMakeFiles/mlx.dir/mlx/array.cpp.o.d -o CMakeFiles/mlx.dir/mlx/array.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.cpp
+
+CMakeFiles/mlx.dir/mlx/array.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/array.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.cpp > CMakeFiles/mlx.dir/mlx/array.cpp.i
+
+CMakeFiles/mlx.dir/mlx/array.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/array.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.cpp -o CMakeFiles/mlx.dir/mlx/array.cpp.s
+
+CMakeFiles/mlx.dir/mlx/compile.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/compile.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.cpp
+CMakeFiles/mlx.dir/mlx/compile.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object CMakeFiles/mlx.dir/mlx/compile.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/compile.cpp.o -MF CMakeFiles/mlx.dir/mlx/compile.cpp.o.d -o CMakeFiles/mlx.dir/mlx/compile.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.cpp
+
+CMakeFiles/mlx.dir/mlx/compile.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/compile.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.cpp > CMakeFiles/mlx.dir/mlx/compile.cpp.i
+
+CMakeFiles/mlx.dir/mlx/compile.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/compile.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.cpp -o CMakeFiles/mlx.dir/mlx/compile.cpp.s
+
+CMakeFiles/mlx.dir/mlx/device.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/device.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.cpp
+CMakeFiles/mlx.dir/mlx/device.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Building CXX object CMakeFiles/mlx.dir/mlx/device.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/device.cpp.o -MF CMakeFiles/mlx.dir/mlx/device.cpp.o.d -o CMakeFiles/mlx.dir/mlx/device.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.cpp
+
+CMakeFiles/mlx.dir/mlx/device.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/device.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.cpp > CMakeFiles/mlx.dir/mlx/device.cpp.i
+
+CMakeFiles/mlx.dir/mlx/device.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/device.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.cpp -o CMakeFiles/mlx.dir/mlx/device.cpp.s
+
+CMakeFiles/mlx.dir/mlx/dtype.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/dtype.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.cpp
+CMakeFiles/mlx.dir/mlx/dtype.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "Building CXX object CMakeFiles/mlx.dir/mlx/dtype.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/dtype.cpp.o -MF CMakeFiles/mlx.dir/mlx/dtype.cpp.o.d -o CMakeFiles/mlx.dir/mlx/dtype.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.cpp
+
+CMakeFiles/mlx.dir/mlx/dtype.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/dtype.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.cpp > CMakeFiles/mlx.dir/mlx/dtype.cpp.i
+
+CMakeFiles/mlx.dir/mlx/dtype.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/dtype.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.cpp -o CMakeFiles/mlx.dir/mlx/dtype.cpp.s
+
+CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp
+CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_6) "Building CXX object CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o -MF CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o.d -o CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp
+
+CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp > CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.i
+
+CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp -o CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.s
+
+CMakeFiles/mlx.dir/mlx/export.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/export.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.cpp
+CMakeFiles/mlx.dir/mlx/export.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_7) "Building CXX object CMakeFiles/mlx.dir/mlx/export.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/export.cpp.o -MF CMakeFiles/mlx.dir/mlx/export.cpp.o.d -o CMakeFiles/mlx.dir/mlx/export.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.cpp
+
+CMakeFiles/mlx.dir/mlx/export.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/export.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.cpp > CMakeFiles/mlx.dir/mlx/export.cpp.i
+
+CMakeFiles/mlx.dir/mlx/export.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/export.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.cpp -o CMakeFiles/mlx.dir/mlx/export.cpp.s
+
+CMakeFiles/mlx.dir/mlx/einsum.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/einsum.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.cpp
+CMakeFiles/mlx.dir/mlx/einsum.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_8) "Building CXX object CMakeFiles/mlx.dir/mlx/einsum.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/einsum.cpp.o -MF CMakeFiles/mlx.dir/mlx/einsum.cpp.o.d -o CMakeFiles/mlx.dir/mlx/einsum.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.cpp
+
+CMakeFiles/mlx.dir/mlx/einsum.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/einsum.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.cpp > CMakeFiles/mlx.dir/mlx/einsum.cpp.i
+
+CMakeFiles/mlx.dir/mlx/einsum.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/einsum.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.cpp -o CMakeFiles/mlx.dir/mlx/einsum.cpp.s
+
+CMakeFiles/mlx.dir/mlx/fast.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/fast.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.cpp
+CMakeFiles/mlx.dir/mlx/fast.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_9) "Building CXX object CMakeFiles/mlx.dir/mlx/fast.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/fast.cpp.o -MF CMakeFiles/mlx.dir/mlx/fast.cpp.o.d -o CMakeFiles/mlx.dir/mlx/fast.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.cpp
+
+CMakeFiles/mlx.dir/mlx/fast.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/fast.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.cpp > CMakeFiles/mlx.dir/mlx/fast.cpp.i
+
+CMakeFiles/mlx.dir/mlx/fast.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/fast.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.cpp -o CMakeFiles/mlx.dir/mlx/fast.cpp.s
+
+CMakeFiles/mlx.dir/mlx/fft.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/fft.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.cpp
+CMakeFiles/mlx.dir/mlx/fft.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_10) "Building CXX object CMakeFiles/mlx.dir/mlx/fft.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/fft.cpp.o -MF CMakeFiles/mlx.dir/mlx/fft.cpp.o.d -o CMakeFiles/mlx.dir/mlx/fft.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.cpp
+
+CMakeFiles/mlx.dir/mlx/fft.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/fft.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.cpp > CMakeFiles/mlx.dir/mlx/fft.cpp.i
+
+CMakeFiles/mlx.dir/mlx/fft.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/fft.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.cpp -o CMakeFiles/mlx.dir/mlx/fft.cpp.s
+
+CMakeFiles/mlx.dir/mlx/ops.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/ops.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.cpp
+CMakeFiles/mlx.dir/mlx/ops.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_11) "Building CXX object CMakeFiles/mlx.dir/mlx/ops.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/ops.cpp.o -MF CMakeFiles/mlx.dir/mlx/ops.cpp.o.d -o CMakeFiles/mlx.dir/mlx/ops.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.cpp
+
+CMakeFiles/mlx.dir/mlx/ops.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/ops.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.cpp > CMakeFiles/mlx.dir/mlx/ops.cpp.i
+
+CMakeFiles/mlx.dir/mlx/ops.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/ops.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.cpp -o CMakeFiles/mlx.dir/mlx/ops.cpp.s
+
+CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.cpp
+CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_12) "Building CXX object CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o -MF CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o.d -o CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.cpp
+
+CMakeFiles/mlx.dir/mlx/graph_utils.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/graph_utils.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.cpp > CMakeFiles/mlx.dir/mlx/graph_utils.cpp.i
+
+CMakeFiles/mlx.dir/mlx/graph_utils.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/graph_utils.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.cpp -o CMakeFiles/mlx.dir/mlx/graph_utils.cpp.s
+
+CMakeFiles/mlx.dir/mlx/primitives.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/primitives.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.cpp
+CMakeFiles/mlx.dir/mlx/primitives.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_13) "Building CXX object CMakeFiles/mlx.dir/mlx/primitives.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/primitives.cpp.o -MF CMakeFiles/mlx.dir/mlx/primitives.cpp.o.d -o CMakeFiles/mlx.dir/mlx/primitives.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.cpp
+
+CMakeFiles/mlx.dir/mlx/primitives.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/primitives.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.cpp > CMakeFiles/mlx.dir/mlx/primitives.cpp.i
+
+CMakeFiles/mlx.dir/mlx/primitives.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/primitives.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.cpp -o CMakeFiles/mlx.dir/mlx/primitives.cpp.s
+
+CMakeFiles/mlx.dir/mlx/random.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/random.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.cpp
+CMakeFiles/mlx.dir/mlx/random.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_14) "Building CXX object CMakeFiles/mlx.dir/mlx/random.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/random.cpp.o -MF CMakeFiles/mlx.dir/mlx/random.cpp.o.d -o CMakeFiles/mlx.dir/mlx/random.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.cpp
+
+CMakeFiles/mlx.dir/mlx/random.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/random.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.cpp > CMakeFiles/mlx.dir/mlx/random.cpp.i
+
+CMakeFiles/mlx.dir/mlx/random.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/random.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.cpp -o CMakeFiles/mlx.dir/mlx/random.cpp.s
+
+CMakeFiles/mlx.dir/mlx/scheduler.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/scheduler.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.cpp
+CMakeFiles/mlx.dir/mlx/scheduler.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_15) "Building CXX object CMakeFiles/mlx.dir/mlx/scheduler.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/scheduler.cpp.o -MF CMakeFiles/mlx.dir/mlx/scheduler.cpp.o.d -o CMakeFiles/mlx.dir/mlx/scheduler.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.cpp
+
+CMakeFiles/mlx.dir/mlx/scheduler.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/scheduler.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.cpp > CMakeFiles/mlx.dir/mlx/scheduler.cpp.i
+
+CMakeFiles/mlx.dir/mlx/scheduler.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/scheduler.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.cpp -o CMakeFiles/mlx.dir/mlx/scheduler.cpp.s
+
+CMakeFiles/mlx.dir/mlx/transforms.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/transforms.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.cpp
+CMakeFiles/mlx.dir/mlx/transforms.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_16) "Building CXX object CMakeFiles/mlx.dir/mlx/transforms.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/transforms.cpp.o -MF CMakeFiles/mlx.dir/mlx/transforms.cpp.o.d -o CMakeFiles/mlx.dir/mlx/transforms.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.cpp
+
+CMakeFiles/mlx.dir/mlx/transforms.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/transforms.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.cpp > CMakeFiles/mlx.dir/mlx/transforms.cpp.i
+
+CMakeFiles/mlx.dir/mlx/transforms.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/transforms.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.cpp -o CMakeFiles/mlx.dir/mlx/transforms.cpp.s
+
+CMakeFiles/mlx.dir/mlx/utils.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/utils.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.cpp
+CMakeFiles/mlx.dir/mlx/utils.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_17) "Building CXX object CMakeFiles/mlx.dir/mlx/utils.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/utils.cpp.o -MF CMakeFiles/mlx.dir/mlx/utils.cpp.o.d -o CMakeFiles/mlx.dir/mlx/utils.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.cpp
+
+CMakeFiles/mlx.dir/mlx/utils.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/utils.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.cpp > CMakeFiles/mlx.dir/mlx/utils.cpp.i
+
+CMakeFiles/mlx.dir/mlx/utils.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/utils.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.cpp -o CMakeFiles/mlx.dir/mlx/utils.cpp.s
+
+CMakeFiles/mlx.dir/mlx/linalg.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/linalg.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.cpp
+CMakeFiles/mlx.dir/mlx/linalg.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_18) "Building CXX object CMakeFiles/mlx.dir/mlx/linalg.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/linalg.cpp.o -MF CMakeFiles/mlx.dir/mlx/linalg.cpp.o.d -o CMakeFiles/mlx.dir/mlx/linalg.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.cpp
+
+CMakeFiles/mlx.dir/mlx/linalg.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/linalg.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.cpp > CMakeFiles/mlx.dir/mlx/linalg.cpp.i
+
+CMakeFiles/mlx.dir/mlx/linalg.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/linalg.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.cpp -o CMakeFiles/mlx.dir/mlx/linalg.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp
+CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_19) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp > CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp -o CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp
+CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_20) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp > CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp -o CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp
+CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_21) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp > CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp -o CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp
+CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_22) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp > CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp -o CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp
+CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_23) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp > CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp -o CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp
+CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_24) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp > CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp -o CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp
+CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_25) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp > CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp -o CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_26) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_27) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_28) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_29) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_30) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_31) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_32) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_33) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_34) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_35) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_36) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_37) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_38) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_39) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_40) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_41) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_42) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_43) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_44) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_45) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_46) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_47) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_48) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_49) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_50) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_51) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_52) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_53) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_54) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_55) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_56) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o: mlx/backend/cpu/compiled_preamble.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_57) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/compiled_preamble.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/compiled_preamble.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/compiled_preamble.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_58) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_59) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_60) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp
+CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_61) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp > CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp -o CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.s
+
+CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp
+CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_62) "Building CXX object CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o -MF CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o.d -o CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp
+
+CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp > CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.i
+
+CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp -o CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.s
+
+CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp
+CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_63) "Building CXX object CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o -MF CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o.d -o CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp
+
+CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp > CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.i
+
+CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp -o CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.s
+
+CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp
+CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_64) "Building CXX object CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o -MF CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o.d -o CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp
+
+CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp > CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.i
+
+CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp -o CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.s
+
+CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp
+CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_65) "Building CXX object CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o -MF CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o.d -o CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp
+
+CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp > CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.i
+
+CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp -o CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.s
+
+CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp
+CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_66) "Building CXX object CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o -MF CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o.d -o CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp
+
+CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp > CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.i
+
+CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp -o CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.s
+
+CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp
+CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_67) "Building CXX object CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o -MF CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o.d -o CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp
+
+CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp > CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.i
+
+CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp -o CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.s
+
+CMakeFiles/mlx.dir/mlx/io/load.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/io/load.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.cpp
+CMakeFiles/mlx.dir/mlx/io/load.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_68) "Building CXX object CMakeFiles/mlx.dir/mlx/io/load.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/io/load.cpp.o -MF CMakeFiles/mlx.dir/mlx/io/load.cpp.o.d -o CMakeFiles/mlx.dir/mlx/io/load.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.cpp
+
+CMakeFiles/mlx.dir/mlx/io/load.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/io/load.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.cpp > CMakeFiles/mlx.dir/mlx/io/load.cpp.i
+
+CMakeFiles/mlx.dir/mlx/io/load.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/io/load.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.cpp -o CMakeFiles/mlx.dir/mlx/io/load.cpp.s
+
+CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp
+CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_69) "Building CXX object CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o -MF CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o.d -o CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp
+
+CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp > CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.i
+
+CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp -o CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.s
+
+CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.cpp
+CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_70) "Building CXX object CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o -MF CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o.d -o CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.cpp
+
+CMakeFiles/mlx.dir/mlx/io/gguf.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/io/gguf.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.cpp > CMakeFiles/mlx.dir/mlx/io/gguf.cpp.i
+
+CMakeFiles/mlx.dir/mlx/io/gguf.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/io/gguf.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.cpp -o CMakeFiles/mlx.dir/mlx/io/gguf.cpp.s
+
+CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp
+CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_71) "Building CXX object CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o -MF CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o.d -o CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp
+
+CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp > CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.i
+
+CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp -o CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp
+CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_72) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp > CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp -o CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp
+CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_73) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp > CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp -o CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_74) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp > CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_75) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp > CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_76) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp > CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_77) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp > CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.s
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o: CMakeFiles/mlx.dir/flags.make
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o: CMakeFiles/mlx.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_78) "Building CXX object CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o -MF CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o.d -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.i"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp > CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.i
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.s"
+	/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.s
+
+# Object files for target mlx
+mlx_OBJECTS = \
+"CMakeFiles/mlx.dir/mlx/allocator.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/array.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/compile.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/device.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/dtype.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/export.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/einsum.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/fast.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/fft.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/ops.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/primitives.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/random.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/scheduler.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/transforms.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/utils.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/linalg.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/io/load.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o" \
+"CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o"
+
+# External object files for target mlx
+mlx_EXTERNAL_OBJECTS = \
+"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/version.cpp.o"
+
+libmlx.so: CMakeFiles/mlx.dir/mlx/allocator.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/array.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/compile.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/device.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/dtype.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/export.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/einsum.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/fast.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/fft.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/ops.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/primitives.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/random.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/scheduler.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/transforms.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/utils.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/linalg.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/io/load.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o
+libmlx.so: mlx/CMakeFiles/mlx_version.dir/version.cpp.o
+libmlx.so: CMakeFiles/mlx.dir/build.make
+libmlx.so: /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/libopenblas.so
+libmlx.so: /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/libopenblas.so
+libmlx.so: mlx/io/libgguflib.a
+libmlx.so: CMakeFiles/mlx.dir/link.txt
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_79) "Linking CXX shared library libmlx.so"
+	$(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/mlx.dir/link.txt --verbose=$(VERBOSE)
+
+# Rule to build all files generated by this target.
+CMakeFiles/mlx.dir/build: libmlx.so
+.PHONY : CMakeFiles/mlx.dir/build
+
+CMakeFiles/mlx.dir/clean:
+	$(CMAKE_COMMAND) -P CMakeFiles/mlx.dir/cmake_clean.cmake
+.PHONY : CMakeFiles/mlx.dir/clean
+
+CMakeFiles/mlx.dir/depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/DependInfo.cmake "--color=$(COLOR)"
+.PHONY : CMakeFiles/mlx.dir/depend
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/cmake_clean.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/cmake_clean.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b7c141f5da47fca86436043e741375200df9ef17
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/cmake_clean.cmake
@@ -0,0 +1,165 @@
+file(REMOVE_RECURSE
+  "CMakeFiles/mlx.dir/mlx/allocator.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/allocator.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/array.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/array.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/compile.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/compile.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/device.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/device.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/dtype.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/dtype.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/einsum.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/einsum.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/export.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/export.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/fast.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/fast.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/fft.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/fft.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/io/load.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/io/load.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/linalg.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/linalg.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/ops.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/ops.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/primitives.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/primitives.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/random.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/random.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/scheduler.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/scheduler.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/transforms.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/transforms.cpp.o.d"
+  "CMakeFiles/mlx.dir/mlx/utils.cpp.o"
+  "CMakeFiles/mlx.dir/mlx/utils.cpp.o.d"
+  "libmlx.pdb"
+  "libmlx.so"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang CXX)
+  include(CMakeFiles/mlx.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/compiler_depend.internal b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/compiler_depend.internal
new file mode 100644
index 0000000000000000000000000000000000000000..fc0b10932c479cf28a45259505597913406fdb1c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/compiler_depend.internal
@@ -0,0 +1,22641 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+CMakeFiles/mlx.dir/mlx/allocator.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/new
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/array.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/iomanip
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/dlfcn.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/dlfcn.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.h
+ /usr/include/stdc-predef.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/binary.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_two.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/stdlib.h
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/inttypes.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/core.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format-inl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled_preamble.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary_ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/dlfcn.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/local_lim.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix1_lim.h
+ /usr/include/bits/posix2_lim.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/uio_lim.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/bits/xopen_lim.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/fstream.tcc
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/list.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_list.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/stream_iterator.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/climits
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstddef
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cstring
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/fstream
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/iomanip
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/iterator
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/list
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/shared_mutex
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/basic_file.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++io.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/dlfcn.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/limits.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/limits.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/string.h
+ /usr/include/strings.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/compiled_preamble.cpp
+ /usr/include/stdc-predef.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/stdlib.h
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/inttypes.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/stdlib.h
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/inttypes.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/stdlib.h
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/inttypes.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/3rdparty/pocketfft.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/stdlib.h
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/inttypes.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_gemm.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_gemm.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/hadamard.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_map.h
+ /usr/include/c++/8/bits/stl_multimap.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_tree.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/map
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/stdlib.h
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/inttypes.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/core.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format-inl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/local_lim.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix1_lim.h
+ /usr/include/bits/posix2_lim.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/uio_lim.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/bits/xopen_lim.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/stream_iterator.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/climits
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/cstddef
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cstring
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/iterator
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/limits.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/limits.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/string.h
+ /usr/include/strings.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/limits.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/stdlib.h
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/inttypes.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cstring
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/stdlib.h
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/inttypes.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/string.h
+ /usr/include/strings.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cstring
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/string.h
+ /usr/include/strings.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arange.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/stdlib.h
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/inttypes.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/ternary.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/ternary.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/limits.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/stdlib.h
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/inttypes.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/types.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/sys/cdefs.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/unary.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary_ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/metal.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/linux_memory.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/kernel.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/sysinfo.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/sysinfo.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/available.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fence.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/compile.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_map.h
+ /usr/include/c++/8/bits/stl_multimap.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_tree.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/iomanip
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/map
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/device.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/available.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/new
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi_declarations.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/dlfcn.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/iostream
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/dlfcn.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/metal.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann/json.hpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/arpa/inet.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/socket.h
+ /usr/include/asm-generic/sockios.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/socket.h
+ /usr/include/asm/sockios.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/in.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/netdb.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/sockaddr.h
+ /usr/include/bits/socket.h
+ /usr/include/bits/socket_type.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/__sigval_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigevent_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_osockaddr.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/any
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/forward_list.h
+ /usr/include/c++/8/bits/forward_list.tcc
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/fstream.tcc
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/gslice.h
+ /usr/include/c++/8/bits/gslice_array.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/indirect_array.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/list.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/mask_array.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/slice_array.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_list.h
+ /usr/include/c++/8/bits/stl_map.h
+ /usr/include/c++/8/bits/stl_multimap.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_tree.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/stream_iterator.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/valarray_after.h
+ /usr/include/c++/8/bits/valarray_array.h
+ /usr/include/c++/8/bits/valarray_array.tcc
+ /usr/include/c++/8/bits/valarray_before.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstddef
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cstring
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/forward_list
+ /usr/include/c++/8/fstream
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/iomanip
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/iostream
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/iterator
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/list
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/map
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/valarray
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/basic_file.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++io.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/netdb.h
+ /usr/include/netinet/in.h
+ /usr/include/netinet/tcp.h
+ /usr/include/pthread.h
+ /usr/include/rpc/netdb.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/string.h
+ /usr/include/strings.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/socket.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/dtype.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/new
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/einsum.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/export.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_map.h
+ /usr/include/c++/8/bits/stl_multimap.h
+ /usr/include/c++/8/bits/stl_multiset.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_set.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_tree.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/map
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/set
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/fast.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/fft.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_multiset.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_set.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_tree.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/set
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fstream.tcc
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cstring
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/fstream
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/basic_file.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++io.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/string.h
+ /usr/include/strings.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cstring
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/string.h
+ /usr/include/strings.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/io/load.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fstream.tcc
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cstring
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/fstream
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/basic_file.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++io.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/string.h
+ /usr/include/strings.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann/json.hpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/any
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/forward_list.h
+ /usr/include/c++/8/bits/forward_list.tcc
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/gslice.h
+ /usr/include/c++/8/bits/gslice_array.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/indirect_array.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/mask_array.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/slice_array.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_map.h
+ /usr/include/c++/8/bits/stl_multimap.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_stack.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_tree.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/stream_iterator.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/valarray_after.h
+ /usr/include/c++/8/bits/valarray_array.h
+ /usr/include/c++/8/bits/valarray_array.tcc
+ /usr/include/c++/8/bits/valarray_before.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstddef
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cstring
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/forward_list
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/iomanip
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/iterator
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/map
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stack
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/valarray
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/string.h
+ /usr/include/strings.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/linalg.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/ops.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/local_lim.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix1_lim.h
+ /usr/include/bits/posix2_lim.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/uio_lim.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/bits/xopen_lim.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_multiset.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_set.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_tree.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/climits
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/set
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/limits.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/limits.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h
+
+CMakeFiles/mlx.dir/mlx/primitives.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/codecvt.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/fs_dir.h
+ /usr/include/c++/8/bits/fs_fwd.h
+ /usr/include/c++/8/bits/fs_ops.h
+ /usr/include/c++/8/bits/fs_path.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_conv.h
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/locale_facets_nonio.h
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/quoted_string.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/codecvt
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/filesystem
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/locale
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/libintl.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/random.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/scheduler.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/available.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/transforms.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fence.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/memory.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms_impl.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/bitsperlong.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm-generic/int-ll64.h
+ /usr/include/asm-generic/posix_types.h
+ /usr/include/asm-generic/types.h
+ /usr/include/asm/bitsperlong.h
+ /usr/include/asm/errno.h
+ /usr/include/asm/posix_types.h
+ /usr/include/asm/posix_types_64.h
+ /usr/include/asm/types.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/statx-generic.h
+ /usr/include/bits/statx.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_iovec.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_statx.h
+ /usr/include/bits/types/struct_statx_timestamp.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/atomic
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_futex.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/deque.tcc
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/std_mutex.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_deque.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_multiset.h
+ /usr/include/c++/8/bits/stl_numeric.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_queue.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_set.h
+ /usr/include/c++/8/bits/stl_stack.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_tree.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/unordered_set.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/chrono
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/condition_variable
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/ctime
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/deque
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/future
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/mutex
+ /usr/include/c++/8/new
+ /usr/include/c++/8/numeric
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/queue
+ /usr/include/c++/8/ratio
+ /usr/include/c++/8/set
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stack
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/thread
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/unordered_set
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/linux/falloc.h
+ /usr/include/linux/posix_types.h
+ /usr/include/linux/stat.h
+ /usr/include/linux/stddef.h
+ /usr/include/linux/types.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/unistd.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/utils.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.cpp
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/limits.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/cpu-set.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/iscanonical.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/locale.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls-narrow.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/sched.h
+ /usr/include/bits/select.h
+ /usr/include/bits/setjmp.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/time.h
+ /usr/include/bits/timex.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/cookie_io_functions_t.h
+ /usr/include/bits/types/error_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/mbstate_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_itimerspec.h
+ /usr/include/bits/types/struct_sched_param.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/struct_tm.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/types/wint_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wctype-wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/c++/8/algorithm
+ /usr/include/c++/8/array
+ /usr/include/c++/8/backward/auto_ptr.h
+ /usr/include/c++/8/backward/binders.h
+ /usr/include/c++/8/bits/algorithmfwd.h
+ /usr/include/c++/8/bits/alloc_traits.h
+ /usr/include/c++/8/bits/allocated_ptr.h
+ /usr/include/c++/8/bits/allocator.h
+ /usr/include/c++/8/bits/atomic_base.h
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h
+ /usr/include/c++/8/bits/basic_ios.h
+ /usr/include/c++/8/bits/basic_ios.tcc
+ /usr/include/c++/8/bits/basic_string.h
+ /usr/include/c++/8/bits/basic_string.tcc
+ /usr/include/c++/8/bits/char_traits.h
+ /usr/include/c++/8/bits/concept_check.h
+ /usr/include/c++/8/bits/cpp_type_traits.h
+ /usr/include/c++/8/bits/cxxabi_forced.h
+ /usr/include/c++/8/bits/cxxabi_init_exception.h
+ /usr/include/c++/8/bits/enable_special_members.h
+ /usr/include/c++/8/bits/exception.h
+ /usr/include/c++/8/bits/exception_defines.h
+ /usr/include/c++/8/bits/exception_ptr.h
+ /usr/include/c++/8/bits/functexcept.h
+ /usr/include/c++/8/bits/functional_hash.h
+ /usr/include/c++/8/bits/hash_bytes.h
+ /usr/include/c++/8/bits/hashtable.h
+ /usr/include/c++/8/bits/hashtable_policy.h
+ /usr/include/c++/8/bits/invoke.h
+ /usr/include/c++/8/bits/ios_base.h
+ /usr/include/c++/8/bits/istream.tcc
+ /usr/include/c++/8/bits/locale_classes.h
+ /usr/include/c++/8/bits/locale_classes.tcc
+ /usr/include/c++/8/bits/locale_facets.h
+ /usr/include/c++/8/bits/locale_facets.tcc
+ /usr/include/c++/8/bits/localefwd.h
+ /usr/include/c++/8/bits/memoryfwd.h
+ /usr/include/c++/8/bits/move.h
+ /usr/include/c++/8/bits/nested_exception.h
+ /usr/include/c++/8/bits/node_handle.h
+ /usr/include/c++/8/bits/ostream.tcc
+ /usr/include/c++/8/bits/ostream_insert.h
+ /usr/include/c++/8/bits/parse_numbers.h
+ /usr/include/c++/8/bits/postypes.h
+ /usr/include/c++/8/bits/predefined_ops.h
+ /usr/include/c++/8/bits/ptr_traits.h
+ /usr/include/c++/8/bits/range_access.h
+ /usr/include/c++/8/bits/refwrap.h
+ /usr/include/c++/8/bits/shared_ptr.h
+ /usr/include/c++/8/bits/shared_ptr_atomic.h
+ /usr/include/c++/8/bits/shared_ptr_base.h
+ /usr/include/c++/8/bits/specfun.h
+ /usr/include/c++/8/bits/sstream.tcc
+ /usr/include/c++/8/bits/std_abs.h
+ /usr/include/c++/8/bits/std_function.h
+ /usr/include/c++/8/bits/stl_algo.h
+ /usr/include/c++/8/bits/stl_algobase.h
+ /usr/include/c++/8/bits/stl_bvector.h
+ /usr/include/c++/8/bits/stl_construct.h
+ /usr/include/c++/8/bits/stl_function.h
+ /usr/include/c++/8/bits/stl_heap.h
+ /usr/include/c++/8/bits/stl_iterator.h
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h
+ /usr/include/c++/8/bits/stl_iterator_base_types.h
+ /usr/include/c++/8/bits/stl_pair.h
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h
+ /usr/include/c++/8/bits/stl_relops.h
+ /usr/include/c++/8/bits/stl_tempbuf.h
+ /usr/include/c++/8/bits/stl_uninitialized.h
+ /usr/include/c++/8/bits/stl_vector.h
+ /usr/include/c++/8/bits/streambuf.tcc
+ /usr/include/c++/8/bits/streambuf_iterator.h
+ /usr/include/c++/8/bits/string_view.tcc
+ /usr/include/c++/8/bits/stringfwd.h
+ /usr/include/c++/8/bits/uniform_int_dist.h
+ /usr/include/c++/8/bits/unique_ptr.h
+ /usr/include/c++/8/bits/unordered_map.h
+ /usr/include/c++/8/bits/uses_allocator.h
+ /usr/include/c++/8/bits/vector.tcc
+ /usr/include/c++/8/cassert
+ /usr/include/c++/8/cctype
+ /usr/include/c++/8/cerrno
+ /usr/include/c++/8/clocale
+ /usr/include/c++/8/cmath
+ /usr/include/c++/8/complex
+ /usr/include/c++/8/cstdint
+ /usr/include/c++/8/cstdio
+ /usr/include/c++/8/cstdlib
+ /usr/include/c++/8/cwchar
+ /usr/include/c++/8/cwctype
+ /usr/include/c++/8/debug/assertions.h
+ /usr/include/c++/8/debug/debug.h
+ /usr/include/c++/8/exception
+ /usr/include/c++/8/ext/aligned_buffer.h
+ /usr/include/c++/8/ext/alloc_traits.h
+ /usr/include/c++/8/ext/atomicity.h
+ /usr/include/c++/8/ext/concurrence.h
+ /usr/include/c++/8/ext/new_allocator.h
+ /usr/include/c++/8/ext/numeric_traits.h
+ /usr/include/c++/8/ext/string_conversions.h
+ /usr/include/c++/8/ext/type_traits.h
+ /usr/include/c++/8/functional
+ /usr/include/c++/8/initializer_list
+ /usr/include/c++/8/ios
+ /usr/include/c++/8/iosfwd
+ /usr/include/c++/8/iostream
+ /usr/include/c++/8/istream
+ /usr/include/c++/8/limits
+ /usr/include/c++/8/memory
+ /usr/include/c++/8/new
+ /usr/include/c++/8/optional
+ /usr/include/c++/8/ostream
+ /usr/include/c++/8/sstream
+ /usr/include/c++/8/stdexcept
+ /usr/include/c++/8/streambuf
+ /usr/include/c++/8/string
+ /usr/include/c++/8/string_view
+ /usr/include/c++/8/system_error
+ /usr/include/c++/8/tr1/bessel_function.tcc
+ /usr/include/c++/8/tr1/beta_function.tcc
+ /usr/include/c++/8/tr1/ell_integral.tcc
+ /usr/include/c++/8/tr1/exp_integral.tcc
+ /usr/include/c++/8/tr1/gamma.tcc
+ /usr/include/c++/8/tr1/hypergeometric.tcc
+ /usr/include/c++/8/tr1/legendre_function.tcc
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc
+ /usr/include/c++/8/tr1/poly_hermite.tcc
+ /usr/include/c++/8/tr1/poly_laguerre.tcc
+ /usr/include/c++/8/tr1/riemann_zeta.tcc
+ /usr/include/c++/8/tr1/special_function_util.h
+ /usr/include/c++/8/tuple
+ /usr/include/c++/8/type_traits
+ /usr/include/c++/8/typeinfo
+ /usr/include/c++/8/unordered_map
+ /usr/include/c++/8/utility
+ /usr/include/c++/8/variant
+ /usr/include/c++/8/vector
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h
+ /usr/include/ctype.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/linux/errno.h
+ /usr/include/locale.h
+ /usr/include/math.h
+ /usr/include/pthread.h
+ /usr/include/sched.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/select.h
+ /usr/include/sys/types.h
+ /usr/include/time.h
+ /usr/include/wchar.h
+ /usr/include/wctype.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/compiler_depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/compiler_depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..51bf623461d6a1c8570952dc6954947deb7b4ef3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/compiler_depend.make
@@ -0,0 +1,23657 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+CMakeFiles/mlx.dir/mlx/allocator.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/array.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/iomanip \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/dlfcn.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/dlfcn.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.h \
+  /usr/include/stdc-predef.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/binary.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_two.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/stdlib.h \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/inttypes.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp \
+  _deps/fmt-src/include/fmt/core.h \
+  _deps/fmt-src/include/fmt/format-inl.h \
+  _deps/fmt-src/include/fmt/format.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled_preamble.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary_ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/dlfcn.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/local_lim.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix1_lim.h \
+  /usr/include/bits/posix2_lim.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/uio_lim.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/bits/xopen_lim.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/fstream.tcc \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/list.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_list.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/stream_iterator.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/climits \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstddef \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cstring \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/fstream \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/iomanip \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/iterator \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/list \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/shared_mutex \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/basic_file.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++io.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/dlfcn.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/limits.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/limits.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/string.h \
+  /usr/include/strings.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o: mlx/backend/cpu/compiled_preamble.cpp \
+  /usr/include/stdc-predef.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/stdlib.h \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/inttypes.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/stdlib.h \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/inttypes.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/stdlib.h \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/inttypes.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/3rdparty/pocketfft.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/stdlib.h \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/inttypes.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_gemm.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_gemm.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/hadamard.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_map.h \
+  /usr/include/c++/8/bits/stl_multimap.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_tree.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/map \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/stdlib.h \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/inttypes.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp \
+  _deps/fmt-src/include/fmt/core.h \
+  _deps/fmt-src/include/fmt/format-inl.h \
+  _deps/fmt-src/include/fmt/format.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/local_lim.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix1_lim.h \
+  /usr/include/bits/posix2_lim.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/uio_lim.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/bits/xopen_lim.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/stream_iterator.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/climits \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/cstddef \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cstring \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/iterator \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/limits.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/limits.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/string.h \
+  /usr/include/strings.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/limits.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/stdlib.h \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/inttypes.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cstring \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/stdlib.h \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/inttypes.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/string.h \
+  /usr/include/strings.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cstring \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/string.h \
+  /usr/include/strings.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arange.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/stdlib.h \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/inttypes.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/ternary.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/ternary.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/limits.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+  /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/stdlib.h \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/inttypes.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/sys/cdefs.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/unary.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary_ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/metal.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/linux_memory.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/kernel.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/sysinfo.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/sysinfo.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/available.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fence.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/compile.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_map.h \
+  /usr/include/c++/8/bits/stl_multimap.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_tree.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/iomanip \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/map \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/device.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/available.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi_declarations.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/dlfcn.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/iostream \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/dlfcn.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/metal.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp \
+  _deps/json-src/single_include/nlohmann/json.hpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/arpa/inet.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/socket.h \
+  /usr/include/asm-generic/sockios.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/socket.h \
+  /usr/include/asm/sockios.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/in.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/netdb.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/sockaddr.h \
+  /usr/include/bits/socket.h \
+  /usr/include/bits/socket_type.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/__sigval_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigevent_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_osockaddr.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/any \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/forward_list.h \
+  /usr/include/c++/8/bits/forward_list.tcc \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/fstream.tcc \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/gslice.h \
+  /usr/include/c++/8/bits/gslice_array.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/indirect_array.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/list.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/mask_array.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/slice_array.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_list.h \
+  /usr/include/c++/8/bits/stl_map.h \
+  /usr/include/c++/8/bits/stl_multimap.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_tree.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/stream_iterator.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/valarray_after.h \
+  /usr/include/c++/8/bits/valarray_array.h \
+  /usr/include/c++/8/bits/valarray_array.tcc \
+  /usr/include/c++/8/bits/valarray_before.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstddef \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cstring \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/forward_list \
+  /usr/include/c++/8/fstream \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/iomanip \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/iostream \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/iterator \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/list \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/map \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/valarray \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/basic_file.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++io.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/netdb.h \
+  /usr/include/netinet/in.h \
+  /usr/include/netinet/tcp.h \
+  /usr/include/pthread.h \
+  /usr/include/rpc/netdb.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/string.h \
+  /usr/include/strings.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/socket.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/dtype.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/einsum.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/export.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_map.h \
+  /usr/include/c++/8/bits/stl_multimap.h \
+  /usr/include/c++/8/bits/stl_multiset.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_set.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_tree.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/map \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/set \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/fast.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/fft.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_multiset.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_set.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_tree.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/set \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.cpp \
+  _deps/gguflib-src/gguflib.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fstream.tcc \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cstring \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/fstream \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/basic_file.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++io.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/string.h \
+  /usr/include/strings.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp \
+  _deps/gguflib-src/gguflib.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cstring \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/string.h \
+  /usr/include/strings.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/io/load.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fstream.tcc \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cstring \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/fstream \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/basic_file.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++io.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/string.h \
+  /usr/include/strings.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp \
+  _deps/json-src/single_include/nlohmann/json.hpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/any \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/forward_list.h \
+  /usr/include/c++/8/bits/forward_list.tcc \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/gslice.h \
+  /usr/include/c++/8/bits/gslice_array.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/indirect_array.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/mask_array.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/slice_array.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_map.h \
+  /usr/include/c++/8/bits/stl_multimap.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_stack.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_tree.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/stream_iterator.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/valarray_after.h \
+  /usr/include/c++/8/bits/valarray_array.h \
+  /usr/include/c++/8/bits/valarray_array.tcc \
+  /usr/include/c++/8/bits/valarray_before.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstddef \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cstring \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/forward_list \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/iomanip \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/iterator \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/map \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stack \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/valarray \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/string.h \
+  /usr/include/strings.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/linalg.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/ops.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/local_lim.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix1_lim.h \
+  /usr/include/bits/posix2_lim.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/uio_lim.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/bits/xopen_lim.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_multiset.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_set.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_tree.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/climits \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/set \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/limits.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/limits.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h
+
+CMakeFiles/mlx.dir/mlx/primitives.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/codecvt.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/fs_dir.h \
+  /usr/include/c++/8/bits/fs_fwd.h \
+  /usr/include/c++/8/bits/fs_ops.h \
+  /usr/include/c++/8/bits/fs_path.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_conv.h \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/locale_facets_nonio.h \
+  /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/quoted_string.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/codecvt \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/filesystem \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/locale \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/libintl.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/random.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/scheduler.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/available.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/transforms.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fence.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/memory.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms_impl.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/bitsperlong.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm-generic/int-ll64.h \
+  /usr/include/asm-generic/posix_types.h \
+  /usr/include/asm-generic/types.h \
+  /usr/include/asm/bitsperlong.h \
+  /usr/include/asm/errno.h \
+  /usr/include/asm/posix_types.h \
+  /usr/include/asm/posix_types_64.h \
+  /usr/include/asm/types.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/statx-generic.h \
+  /usr/include/bits/statx.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_iovec.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_statx.h \
+  /usr/include/bits/types/struct_statx_timestamp.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/atomic \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_futex.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/deque.tcc \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/std_mutex.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_deque.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_multiset.h \
+  /usr/include/c++/8/bits/stl_numeric.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_queue.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_set.h \
+  /usr/include/c++/8/bits/stl_stack.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_tree.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/unordered_set.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/chrono \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/condition_variable \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/ctime \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/deque \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/future \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/mutex \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/numeric \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/queue \
+  /usr/include/c++/8/ratio \
+  /usr/include/c++/8/set \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stack \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/thread \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/unordered_set \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/linux/falloc.h \
+  /usr/include/linux/posix_types.h \
+  /usr/include/linux/stat.h \
+  /usr/include/linux/stddef.h \
+  /usr/include/linux/types.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/unistd.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+CMakeFiles/mlx.dir/mlx/utils.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.cpp \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/limits.h \
+  /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/cpu-set.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/iscanonical.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/locale.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls-narrow.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/sched.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/setjmp.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/time.h \
+  /usr/include/bits/timex.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/cookie_io_functions_t.h \
+  /usr/include/bits/types/error_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/mbstate_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_itimerspec.h \
+  /usr/include/bits/types/struct_sched_param.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/struct_tm.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/types/wint_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wctype-wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/c++/8/algorithm \
+  /usr/include/c++/8/array \
+  /usr/include/c++/8/backward/auto_ptr.h \
+  /usr/include/c++/8/backward/binders.h \
+  /usr/include/c++/8/bits/algorithmfwd.h \
+  /usr/include/c++/8/bits/alloc_traits.h \
+  /usr/include/c++/8/bits/allocated_ptr.h \
+  /usr/include/c++/8/bits/allocator.h \
+  /usr/include/c++/8/bits/atomic_base.h \
+  /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+  /usr/include/c++/8/bits/basic_ios.h \
+  /usr/include/c++/8/bits/basic_ios.tcc \
+  /usr/include/c++/8/bits/basic_string.h \
+  /usr/include/c++/8/bits/basic_string.tcc \
+  /usr/include/c++/8/bits/char_traits.h \
+  /usr/include/c++/8/bits/concept_check.h \
+  /usr/include/c++/8/bits/cpp_type_traits.h \
+  /usr/include/c++/8/bits/cxxabi_forced.h \
+  /usr/include/c++/8/bits/cxxabi_init_exception.h \
+  /usr/include/c++/8/bits/enable_special_members.h \
+  /usr/include/c++/8/bits/exception.h \
+  /usr/include/c++/8/bits/exception_defines.h \
+  /usr/include/c++/8/bits/exception_ptr.h \
+  /usr/include/c++/8/bits/functexcept.h \
+  /usr/include/c++/8/bits/functional_hash.h \
+  /usr/include/c++/8/bits/hash_bytes.h \
+  /usr/include/c++/8/bits/hashtable.h \
+  /usr/include/c++/8/bits/hashtable_policy.h \
+  /usr/include/c++/8/bits/invoke.h \
+  /usr/include/c++/8/bits/ios_base.h \
+  /usr/include/c++/8/bits/istream.tcc \
+  /usr/include/c++/8/bits/locale_classes.h \
+  /usr/include/c++/8/bits/locale_classes.tcc \
+  /usr/include/c++/8/bits/locale_facets.h \
+  /usr/include/c++/8/bits/locale_facets.tcc \
+  /usr/include/c++/8/bits/localefwd.h \
+  /usr/include/c++/8/bits/memoryfwd.h \
+  /usr/include/c++/8/bits/move.h \
+  /usr/include/c++/8/bits/nested_exception.h \
+  /usr/include/c++/8/bits/node_handle.h \
+  /usr/include/c++/8/bits/ostream.tcc \
+  /usr/include/c++/8/bits/ostream_insert.h \
+  /usr/include/c++/8/bits/parse_numbers.h \
+  /usr/include/c++/8/bits/postypes.h \
+  /usr/include/c++/8/bits/predefined_ops.h \
+  /usr/include/c++/8/bits/ptr_traits.h \
+  /usr/include/c++/8/bits/range_access.h \
+  /usr/include/c++/8/bits/refwrap.h \
+  /usr/include/c++/8/bits/shared_ptr.h \
+  /usr/include/c++/8/bits/shared_ptr_atomic.h \
+  /usr/include/c++/8/bits/shared_ptr_base.h \
+  /usr/include/c++/8/bits/specfun.h \
+  /usr/include/c++/8/bits/sstream.tcc \
+  /usr/include/c++/8/bits/std_abs.h \
+  /usr/include/c++/8/bits/std_function.h \
+  /usr/include/c++/8/bits/stl_algo.h \
+  /usr/include/c++/8/bits/stl_algobase.h \
+  /usr/include/c++/8/bits/stl_bvector.h \
+  /usr/include/c++/8/bits/stl_construct.h \
+  /usr/include/c++/8/bits/stl_function.h \
+  /usr/include/c++/8/bits/stl_heap.h \
+  /usr/include/c++/8/bits/stl_iterator.h \
+  /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+  /usr/include/c++/8/bits/stl_iterator_base_types.h \
+  /usr/include/c++/8/bits/stl_pair.h \
+  /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+  /usr/include/c++/8/bits/stl_relops.h \
+  /usr/include/c++/8/bits/stl_tempbuf.h \
+  /usr/include/c++/8/bits/stl_uninitialized.h \
+  /usr/include/c++/8/bits/stl_vector.h \
+  /usr/include/c++/8/bits/streambuf.tcc \
+  /usr/include/c++/8/bits/streambuf_iterator.h \
+  /usr/include/c++/8/bits/string_view.tcc \
+  /usr/include/c++/8/bits/stringfwd.h \
+  /usr/include/c++/8/bits/uniform_int_dist.h \
+  /usr/include/c++/8/bits/unique_ptr.h \
+  /usr/include/c++/8/bits/unordered_map.h \
+  /usr/include/c++/8/bits/uses_allocator.h \
+  /usr/include/c++/8/bits/vector.tcc \
+  /usr/include/c++/8/cassert \
+  /usr/include/c++/8/cctype \
+  /usr/include/c++/8/cerrno \
+  /usr/include/c++/8/clocale \
+  /usr/include/c++/8/cmath \
+  /usr/include/c++/8/complex \
+  /usr/include/c++/8/cstdint \
+  /usr/include/c++/8/cstdio \
+  /usr/include/c++/8/cstdlib \
+  /usr/include/c++/8/cwchar \
+  /usr/include/c++/8/cwctype \
+  /usr/include/c++/8/debug/assertions.h \
+  /usr/include/c++/8/debug/debug.h \
+  /usr/include/c++/8/exception \
+  /usr/include/c++/8/ext/aligned_buffer.h \
+  /usr/include/c++/8/ext/alloc_traits.h \
+  /usr/include/c++/8/ext/atomicity.h \
+  /usr/include/c++/8/ext/concurrence.h \
+  /usr/include/c++/8/ext/new_allocator.h \
+  /usr/include/c++/8/ext/numeric_traits.h \
+  /usr/include/c++/8/ext/string_conversions.h \
+  /usr/include/c++/8/ext/type_traits.h \
+  /usr/include/c++/8/functional \
+  /usr/include/c++/8/initializer_list \
+  /usr/include/c++/8/ios \
+  /usr/include/c++/8/iosfwd \
+  /usr/include/c++/8/iostream \
+  /usr/include/c++/8/istream \
+  /usr/include/c++/8/limits \
+  /usr/include/c++/8/memory \
+  /usr/include/c++/8/new \
+  /usr/include/c++/8/optional \
+  /usr/include/c++/8/ostream \
+  /usr/include/c++/8/sstream \
+  /usr/include/c++/8/stdexcept \
+  /usr/include/c++/8/streambuf \
+  /usr/include/c++/8/string \
+  /usr/include/c++/8/string_view \
+  /usr/include/c++/8/system_error \
+  /usr/include/c++/8/tr1/bessel_function.tcc \
+  /usr/include/c++/8/tr1/beta_function.tcc \
+  /usr/include/c++/8/tr1/ell_integral.tcc \
+  /usr/include/c++/8/tr1/exp_integral.tcc \
+  /usr/include/c++/8/tr1/gamma.tcc \
+  /usr/include/c++/8/tr1/hypergeometric.tcc \
+  /usr/include/c++/8/tr1/legendre_function.tcc \
+  /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+  /usr/include/c++/8/tr1/poly_hermite.tcc \
+  /usr/include/c++/8/tr1/poly_laguerre.tcc \
+  /usr/include/c++/8/tr1/riemann_zeta.tcc \
+  /usr/include/c++/8/tr1/special_function_util.h \
+  /usr/include/c++/8/tuple \
+  /usr/include/c++/8/type_traits \
+  /usr/include/c++/8/typeinfo \
+  /usr/include/c++/8/unordered_map \
+  /usr/include/c++/8/utility \
+  /usr/include/c++/8/variant \
+  /usr/include/c++/8/vector \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+  /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+  /usr/include/ctype.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/linux/errno.h \
+  /usr/include/locale.h \
+  /usr/include/math.h \
+  /usr/include/pthread.h \
+  /usr/include/sched.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/types.h \
+  /usr/include/time.h \
+  /usr/include/wchar.h \
+  /usr/include/wctype.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/memory.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.cpp:
+
+/usr/include/c++/8/set:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export_impl.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.cpp:
+
+/usr/include/sys/socket.h:
+
+/usr/include/rpc/netdb.h:
+
+/usr/include/netinet/tcp.h:
+
+/usr/include/netdb.h:
+
+/usr/include/c++/8/forward_list:
+
+/usr/include/c++/8/bits/valarray_before.h:
+
+/usr/include/c++/8/bits/valarray_array.tcc:
+
+/usr/include/c++/8/bits/valarray_array.h:
+
+/usr/include/c++/8/bits/mask_array.h:
+
+/usr/include/c++/8/bits/indirect_array.h:
+
+/usr/include/c++/8/bits/gslice.h:
+
+/usr/include/c++/8/bits/forward_list.h:
+
+/usr/include/bits/types/sigevent_t.h:
+
+/usr/include/bits/types/__sigval_t.h:
+
+/usr/include/bits/sockaddr.h:
+
+/usr/include/bits/in.h:
+
+/usr/include/asm/socket.h:
+
+/usr/include/asm/sockios.h:
+
+/usr/include/asm-generic/socket.h:
+
+/usr/include/arpa/inet.h:
+
+_deps/json-src/single_include/nlohmann/json.hpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi_declarations.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.h:
+
+/usr/include/c++/8/bits/stl_set.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile_impl.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fence.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp:
+
+/usr/include/linux/kernel.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/metal.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/unary.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/ternary.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.h:
+
+/usr/include/netinet/in.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arange.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp:
+
+/usr/include/asm-generic/sockios.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp:
+
+/usr/include/c++/8/bits/stl_tree.h:
+
+/usr/include/c++/8/bits/stl_multimap.h:
+
+/usr/include/c++/8/bits/stl_map.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/3rdparty/pocketfft.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.h:
+
+/usr/include/c++/8/numeric:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp:
+
+/usr/include/c++/8/bits/stl_numeric.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp:
+
+mlx/backend/cpu/compiled_preamble.cpp:
+
+/usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h:
+
+/usr/include/string.h:
+
+/usr/include/linux/limits.h:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/c++io.h:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/basic_file.h:
+
+/usr/include/c++/8/shared_mutex:
+
+/usr/include/c++/8/bits/slice_array.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp:
+
+/usr/include/c++/8/list:
+
+/usr/include/c++/8/iterator:
+
+/usr/include/c++/8/fstream:
+
+/usr/include/c++/8/cstddef:
+
+/usr/include/c++/8/climits:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/ternary.h:
+
+/usr/include/c++/8/bits/stream_iterator.h:
+
+/usr/include/c++/8/bits/stl_list.h:
+
+/usr/include/bits/uio_lim.h:
+
+/usr/include/bits/posix2_lim.h:
+
+/usr/include/bits/local_lim.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary_ops.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled_preamble.h:
+
+_deps/fmt-src/include/fmt/format.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h:
+
+_deps/fmt-src/include/fmt/format-inl.h:
+
+_deps/fmt-src/include/fmt/core.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/hadamard.h:
+
+/usr/include/c++/8/stdlib.h:
+
+/usr/include/c++/8/bits/fstream.tcc:
+
+/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h:
+
+/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h:
+
+/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp:
+
+/usr/include/c++/8/bits/stl_stack.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_two.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/binary.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp:
+
+/usr/include/c++/8/valarray:
+
+/usr/include/dlfcn.h:
+
+/usr/include/endian.h:
+
+/usr/include/fcntl.h:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h:
+
+/usr/include/c++/8/cwctype:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h:
+
+/usr/include/sys/stat.h:
+
+/usr/include/c++/8/typeinfo:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.h:
+
+/usr/include/c++/8/type_traits:
+
+/usr/include/c++/8/bits/locale_classes.h:
+
+/usr/include/bits/types/__mbstate_t.h:
+
+/usr/include/c++/8/string:
+
+/usr/include/stdio.h:
+
+/usr/include/c++/8/bits/std_mutex.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h:
+
+/usr/include/c++/8/sstream:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp:
+
+/usr/include/c++/8/iosfwd:
+
+/usr/include/c++/8/new:
+
+/usr/include/c++/8/exception:
+
+/usr/include/c++/8/backward/binders.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h:
+
+/usr/include/linux/errno.h:
+
+/usr/include/c++/8/bits/move.h:
+
+/usr/include/bits/select.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp:
+
+/usr/include/c++/8/stack:
+
+/usr/include/ctype.h:
+
+/usr/include/c++/8/cstdlib:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp:
+
+/usr/include/bits/types/error_t.h:
+
+/usr/include/c++/8/locale:
+
+/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h:
+
+/usr/include/c++/8/cctype:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.cpp:
+
+/usr/include/locale.h:
+
+/usr/include/c++/8/bits/refwrap.h:
+
+/usr/include/c++/8/ios:
+
+/usr/include/bits/floatn.h:
+
+/usr/include/c++/8/bits/stringfwd.h:
+
+/usr/include/sched.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp:
+
+/usr/include/c++/8/bits/stl_iterator_base_types.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h:
+
+/usr/include/c++/8/bits/stl_iterator.h:
+
+/usr/include/c++/8/unordered_set:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp:
+
+/usr/include/c++/8/chrono:
+
+/usr/include/linux/posix_types.h:
+
+/usr/include/c++/8/bits/stl_algo.h:
+
+/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h:
+
+/usr/include/c++/8/bits/atomic_futex.h:
+
+/usr/include/c++/8/tr1/beta_function.tcc:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.cpp:
+
+/usr/include/c++/8/tr1/poly_hermite.tcc:
+
+/usr/include/c++/8/bits/range_access.h:
+
+/usr/include/c++/8/bits/alloc_traits.h:
+
+/usr/include/c++/8/bits/predefined_ops.h:
+
+/usr/include/c++/8/bits/ostream.tcc:
+
+/usr/include/c++/8/bits/localefwd.h:
+
+/usr/include/c++/8/bits/memoryfwd.h:
+
+/usr/include/c++/8/bits/stl_vector.h:
+
+/usr/include/inttypes.h:
+
+/usr/include/linux/stat.h:
+
+/usr/include/c++/8/bits/locale_classes.tcc:
+
+/usr/include/c++/8/bits/istream.tcc:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h:
+
+/usr/include/c++/8/bits/string_view.tcc:
+
+/usr/include/c++/8/bits/hash_bytes.h:
+
+/usr/include/c++/8/system_error:
+
+/usr/include/bits/timex.h:
+
+/usr/include/c++/8/tr1/exp_integral.tcc:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h:
+
+/usr/include/c++/8/tr1/legendre_function.tcc:
+
+/usr/include/c++/8/bits/ios_base.h:
+
+/usr/include/bits/stdio.h:
+
+/usr/include/c++/8/bits/gslice_array.h:
+
+/usr/include/bits/types/__fpos64_t.h:
+
+/usr/include/c++/8/queue:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp:
+
+/usr/include/c++/8/iomanip:
+
+/usr/include/bits/types.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp:
+
+/usr/include/c++/8/ext/numeric_traits.h:
+
+/usr/include/c++/8/bits/std_abs.h:
+
+/usr/include/c++/8/cassert:
+
+/usr/include/bits/stdint-intn.h:
+
+/usr/include/bits/cpu-set.h:
+
+/usr/include/c++/8/any:
+
+/usr/include/bits/types/__FILE.h:
+
+/usr/include/c++/8/ratio:
+
+/usr/include/c++/8/ctime:
+
+/usr/include/c++/8/bits/streambuf_iterator.h:
+
+/usr/include/bits/setjmp.h:
+
+/usr/include/asm/errno.h:
+
+/usr/include/strings.h:
+
+/usr/include/bits/types/cookie_io_functions_t.h:
+
+/usr/include/bits/time.h:
+
+/usr/include/bits/stdio_lim.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp:
+
+/usr/include/bits/sched.h:
+
+/usr/include/alloca.h:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h:
+
+/usr/include/c++/8/bits/stl_multiset.h:
+
+/usr/include/c++/8/bits/locale_facets.tcc:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp:
+
+/usr/include/asm-generic/errno-base.h:
+
+/usr/include/bits/types/mbstate_t.h:
+
+/usr/include/c++/8/cstdint:
+
+/usr/include/bits/posix_opt.h:
+
+/usr/include/c++/8/bits/node_handle.h:
+
+/usr/include/c++/8/bits/postypes.h:
+
+/usr/include/bits/thread-shared-types.h:
+
+/usr/include/bits/stdlib-bsearch.h:
+
+/usr/include/bits/long-double.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/limits.h:
+
+/usr/include/bits/stat.h:
+
+/usr/include/c++/8/unordered_map:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h:
+
+/usr/include/c++/8/cstring:
+
+/usr/include/c++/8/algorithm:
+
+/usr/include/c++/8/bits/specfun.h:
+
+/usr/include/bits/types/__locale_t.h:
+
+/usr/include/c++/8/bits/exception_ptr.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.h:
+
+/usr/include/bits/libc-header-start.h:
+
+/usr/include/bits/types/time_t.h:
+
+/usr/include/c++/8/stdexcept:
+
+/usr/include/bits/xopen_lim.h:
+
+/usr/include/gnu/stubs-64.h:
+
+/usr/include/c++/8/bits/basic_string.h:
+
+/usr/include/c++/8/bits/ostream_insert.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp:
+
+/usr/include/bits/uintn-identity.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.h:
+
+/usr/include/c++/8/bits/functional_hash.h:
+
+/usr/include/pthread.h:
+
+/usr/include/linux/stddef.h:
+
+/usr/include/stdint.h:
+
+/usr/include/errno.h:
+
+/usr/include/bits/pthreadtypes.h:
+
+/usr/include/bits/pthreadtypes-arch.h:
+
+/usr/include/c++/8/istream:
+
+/usr/include/bits/wctype-wchar.h:
+
+/usr/include/bits/byteswap.h:
+
+/usr/include/c++/8/bits/locale_conv.h:
+
+/usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h:
+
+/usr/include/c++/8/initializer_list:
+
+/usr/include/c++/8/streambuf:
+
+/usr/include/c++/8/bits/basic_ios.h:
+
+/usr/include/c++/8/cmath:
+
+/usr/include/bits/types/__fpos_t.h:
+
+/usr/include/bits/types/wint_t.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.cpp:
+
+/usr/include/bits/locale.h:
+
+/usr/include/c++/8/bits/codecvt.h:
+
+/usr/include/bits/types/__sigset_t.h:
+
+/usr/include/bits/types/clockid_t.h:
+
+/usr/include/limits.h:
+
+/usr/include/bits/waitstatus.h:
+
+/usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io.h:
+
+/usr/include/c++/8/ext/new_allocator.h:
+
+/usr/include/bits/types/locale_t.h:
+
+/usr/include/bits/typesizes.h:
+
+/usr/include/bits/types/sigset_t.h:
+
+/usr/include/bits/types/struct_FILE.h:
+
+/usr/include/sys/cdefs.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_gemm.h:
+
+/usr/include/c++/8/bits/stl_iterator_base_funcs.h:
+
+/usr/include/c++/8/bits/locale_facets.h:
+
+/usr/include/stdc-predef.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp:
+
+/usr/include/linux/falloc.h:
+
+/usr/include/c++/8/bits/functexcept.h:
+
+/usr/include/c++/8/limits:
+
+/usr/include/c++/8/bits/basic_string.tcc:
+
+/usr/include/bits/endian.h:
+
+/usr/include/c++/8/bits/stl_construct.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp:
+
+/usr/include/bits/types/struct_itimerspec.h:
+
+/usr/include/bits/types/struct_sched_param.h:
+
+/usr/include/c++/8/utility:
+
+/usr/include/bits/types/struct_timespec.h:
+
+/usr/include/c++/8/atomic:
+
+/usr/include/c++/8/tr1/modified_bessel_func.tcc:
+
+/usr/include/bits/types/struct_timeval.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp:
+
+/usr/include/bits/netdb.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp:
+
+/usr/include/c++/8/cerrno:
+
+/usr/include/bits/waitflags.h:
+
+/usr/include/sys/select.h:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h:
+
+/usr/include/c++/8/bits/invoke.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.cpp:
+
+/usr/include/c++/8/ostream:
+
+/usr/include/c++/8/bits/allocator.h:
+
+/usr/include/c++/8/bits/valarray_after.h:
+
+/usr/include/c++/8/variant:
+
+/usr/include/bits/types/timer_t.h:
+
+/usr/include/c++/8/bits/list.tcc:
+
+/usr/include/bits/wchar.h:
+
+/usr/include/asm-generic/int-ll64.h:
+
+/usr/include/c++/8/debug/debug.h:
+
+/usr/include/gnu/stubs.h:
+
+/usr/include/c++/8/bits/atomic_base.h:
+
+/usr/include/c++/8/bits/stl_pair.h:
+
+/usr/include/c++/8/bits/concept_check.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp:
+
+/usr/include/c++/8/bits/exception_defines.h:
+
+/usr/include/c++/8/bits/shared_ptr.h:
+
+/usr/include/asm-generic/bitsperlong.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/linux_memory.h:
+
+/usr/include/c++/8/map:
+
+/usr/include/asm/bitsperlong.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/available.h:
+
+/usr/include/features.h:
+
+/usr/include/c++/8/bits/char_traits.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp:
+
+/usr/include/c++/8/bits/ptr_traits.h:
+
+/usr/include/bits/stdlib-float.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp:
+
+/usr/include/c++/8/bits/stl_raw_storage_iter.h:
+
+/usr/include/c++/8/cstdio:
+
+/usr/include/c++/8/bits/fs_ops.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp:
+
+/usr/include/bits/types/FILE.h:
+
+/usr/include/c++/8/string_view:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h:
+
+/usr/include/c++/8/bits/cpp_type_traits.h:
+
+/usr/include/c++/8/bits/cxxabi_forced.h:
+
+/usr/include/c++/8/clocale:
+
+/usr/include/c++/8/ext/string_conversions.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h:
+
+/usr/include/c++/8/bits/cxxabi_init_exception.h:
+
+/usr/include/c++/8/bits/basic_ios.tcc:
+
+/usr/include/sys/types.h:
+
+/usr/include/time.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.cpp:
+
+/usr/include/bits/types/struct_osockaddr.h:
+
+/usr/include/wchar.h:
+
+/usr/include/c++/8/bits/stl_function.h:
+
+/usr/include/c++/8/bits/shared_ptr_atomic.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h:
+
+/usr/include/c++/8/bits/stl_algobase.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h:
+
+/usr/include/math.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h:
+
+/usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms_impl.h:
+
+/usr/include/c++/8/future:
+
+/usr/include/c++/8/cwchar:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp:
+
+/usr/include/c++/8/bits/stl_heap.h:
+
+/usr/include/c++/8/tr1/poly_laguerre.tcc:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h:
+
+/usr/include/bits/floatn-common.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h:
+
+/usr/include/bits/stdint-uintn.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h:
+
+/usr/include/asm-generic/posix_types.h:
+
+/usr/include/c++/8/mutex:
+
+/usr/include/asm/posix_types.h:
+
+/usr/include/bits/libm-simd-decl-stubs.h:
+
+/usr/include/c++/8/bits/std_function.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp:
+
+/usr/include/bits/fcntl.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp:
+
+/usr/include/c++/8/debug/assertions.h:
+
+/usr/include/bits/mathcalls-helper-functions.h:
+
+/usr/include/assert.h:
+
+/usr/include/c++/8/bits/nested_exception.h:
+
+/usr/include/c++/8/bits/stl_tempbuf.h:
+
+/usr/include/c++/8/bits/exception.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h:
+
+/usr/include/bits/confname.h:
+
+/usr/include/bits/errno.h:
+
+/usr/include/bits/fcntl-linux.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h:
+
+/usr/include/bits/flt-eval-method.h:
+
+/usr/include/bits/getopt_core.h:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h:
+
+/usr/include/c++/8/filesystem:
+
+/usr/include/wctype.h:
+
+/usr/include/bits/fp-logb.h:
+
+/usr/include/asm-generic/errno.h:
+
+/usr/include/bits/getopt_posix.h:
+
+/usr/include/c++/8/bits/stl_relops.h:
+
+/usr/include/bits/math-vector.h:
+
+/usr/include/bits/mathcalls-narrow.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp:
+
+/usr/include/bits/mathcalls.h:
+
+/usr/include/bits/mathinline.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp:
+
+/usr/include/bits/iscanonical.h:
+
+/usr/include/bits/statx-generic.h:
+
+/usr/include/bits/sys_errlist.h:
+
+/usr/include/c++/8/deque:
+
+/usr/include/asm/types.h:
+
+/usr/include/c++/8/tr1/ell_integral.tcc:
+
+/usr/include/c++/8/bits/sstream.tcc:
+
+/usr/include/bits/statx.h:
+
+/usr/include/c++/8/array:
+
+/usr/include/bits/socket.h:
+
+/usr/include/bits/types/struct_iovec.h:
+
+/usr/include/bits/types/struct_statx.h:
+
+/usr/include/c++/8/ext/type_traits.h:
+
+/usr/include/c++/8/condition_variable:
+
+/usr/include/c++/8/bits/stl_bvector.h:
+
+/usr/include/c++/8/tr1/hypergeometric.tcc:
+
+/usr/include/c++/8/backward/auto_ptr.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.cpp:
+
+/usr/include/bits/types/struct_statx_timestamp.h:
+
+/usr/include/c++/8/bits/algorithmfwd.h:
+
+/usr/include/bits/types/struct_tm.h:
+
+/usr/include/c++/8/bits/allocated_ptr.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h:
+
+/usr/include/c++/8/bits/atomic_lockfree_defines.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h:
+
+/usr/include/asm-generic/types.h:
+
+/usr/include/c++/8/bits/deque.tcc:
+
+/usr/include/c++/8/bits/stl_queue.h:
+
+/usr/include/c++/8/bits/vector.tcc:
+
+/usr/include/linux/types.h:
+
+/usr/include/bits/socket_type.h:
+
+/usr/include/unistd.h:
+
+/usr/include/sys/sysinfo.h:
+
+/usr/include/bits/wordsize.h:
+
+/usr/include/c++/8/bits/locale_facets_nonio.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.h:
+
+/usr/include/c++/8/bits/enable_special_members.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp:
+
+/usr/include/bits/posix1_lim.h:
+
+/usr/include/c++/8/ext/atomicity.h:
+
+/usr/include/bits/fp-fast.h:
+
+/usr/include/c++/8/bits/hashtable.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp:
+
+/usr/include/c++/8/bits/hashtable_policy.h:
+
+/usr/include/c++/8/bits/parse_numbers.h:
+
+/usr/include/c++/8/ext/alloc_traits.h:
+
+/usr/include/c++/8/bits/shared_ptr_base.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.h:
+
+/usr/include/bits/environments.h:
+
+/usr/include/c++/8/bits/stl_deque.h:
+
+/usr/include/c++/8/bits/stl_uninitialized.h:
+
+/usr/include/c++/8/bits/uniform_int_dist.h:
+
+/usr/include/c++/8/bits/fs_dir.h:
+
+/usr/include/c++/8/bits/unique_ptr.h:
+
+/usr/include/c++/8/bits/streambuf.tcc:
+
+/usr/include/c++/8/bits/unordered_map.h:
+
+/usr/include/asm/posix_types_64.h:
+
+/usr/include/c++/8/bits/unordered_set.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl.h:
+
+/usr/include/c++/8/bits/uses_allocator.h:
+
+/usr/include/c++/8/complex:
+
+_deps/gguflib-src/gguflib.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp:
+
+/usr/include/c++/8/ext/aligned_buffer.h:
+
+/usr/include/c++/8/ext/concurrence.h:
+
+/usr/include/c++/8/functional:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h:
+
+/usr/include/c++/8/memory:
+
+/usr/include/c++/8/optional:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp:
+
+/usr/include/c++/8/tr1/bessel_function.tcc:
+
+/usr/include/c++/8/tr1/gamma.tcc:
+
+/usr/include/c++/8/tr1/riemann_zeta.tcc:
+
+/usr/include/c++/8/tr1/special_function_util.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.h:
+
+/usr/include/c++/8/tuple:
+
+/usr/include/c++/8/vector:
+
+/usr/include/c++/8/thread:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h:
+
+/usr/include/c++/8/bits/fs_path.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.h:
+
+/usr/include/c++/8/bits/locale_facets_nonio.tcc:
+
+/usr/include/c++/8/iostream:
+
+/usr/include/c++/8/bits/quoted_string.h:
+
+/usr/include/c++/8/codecvt:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.cpp:
+
+/usr/include/bits/dlfcn.h:
+
+/usr/include/stdlib.h:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h:
+
+/usr/include/c++/8/bits/forward_list.tcc:
+
+/usr/include/linux/sysinfo.h:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h:
+
+/usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h:
+
+/usr/include/c++/8/bits/fs_fwd.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp:
+
+/usr/include/libintl.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h:
+
+/usr/include/bits/types/clock_t.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h:
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/compiler_depend.ts b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/compiler_depend.ts
new file mode 100644
index 0000000000000000000000000000000000000000..59f250d219ce9a49250d36c835f7f121396fa689
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/compiler_depend.ts
@@ -0,0 +1,2 @@
+# CMAKE generated file: DO NOT EDIT!
+# Timestamp file for compiler generated dependencies management for mlx.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..5158306651f2a8baba462557f8c6b59283f32db3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/depend.make
@@ -0,0 +1,2 @@
+# Empty dependencies file for mlx.
+# This may be replaced when dependencies are built.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/flags.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/flags.make
new file mode 100644
index 0000000000000000000000000000000000000000..621ab722174e60f9a5e03259730683732111b89a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/flags.make
@@ -0,0 +1,10 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# compile CXX with /usr/bin/c++
+CXX_DEFINES = -DFMT_HEADER_ONLY=1
+
+CXX_INCLUDES = -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include
+
+CXX_FLAGS = -O3 -DNDEBUG -std=gnu++17 -fPIC
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/link.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/link.txt
new file mode 100644
index 0000000000000000000000000000000000000000..25c80d2c977ed1957d2f5f00de78560a4ed2837a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/link.txt
@@ -0,0 +1 @@
+/usr/bin/c++ -fPIC -O3 -DNDEBUG -shared -Wl,-soname,libmlx.so -o libmlx.so CMakeFiles/mlx.dir/mlx/allocator.cpp.o CMakeFiles/mlx.dir/mlx/array.cpp.o CMakeFiles/mlx.dir/mlx/compile.cpp.o CMakeFiles/mlx.dir/mlx/device.cpp.o CMakeFiles/mlx.dir/mlx/dtype.cpp.o CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o CMakeFiles/mlx.dir/mlx/export.cpp.o CMakeFiles/mlx.dir/mlx/einsum.cpp.o CMakeFiles/mlx.dir/mlx/fast.cpp.o CMakeFiles/mlx.dir/mlx/fft.cpp.o CMakeFiles/mlx.dir/mlx/ops.cpp.o CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o CMakeFiles/mlx.dir/mlx/primitives.cpp.o CMakeFiles/mlx.dir/mlx/random.cpp.o CMakeFiles/mlx.dir/mlx/scheduler.cpp.o CMakeFiles/mlx.dir/mlx/transforms.cpp.o CMakeFiles/mlx.dir/mlx/utils.cpp.o CMakeFiles/mlx.dir/mlx/linalg.cpp.o CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o CMakeFiles/mlx.dir/mlx/io/load.cpp.o CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o mlx/CMakeFiles/mlx_version.dir/version.cpp.o  -ldl -lpthread /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/libopenblas.so -lpthread -lm -ldl /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/lib/libopenblas.so mlx/io/libgguflib.a -lpthread -lm -ldl
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/allocator.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/allocator.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..19d27d69c05e86269dcc76b8c958176b98c754c9
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/allocator.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/allocator.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/allocator.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..6fd9831b7028ae053fa9842faf0109b4dbe87182
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/allocator.cpp.o.d
@@ -0,0 +1,116 @@
+CMakeFiles/mlx.dir/mlx/allocator.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/iosfwd /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/array.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/array.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..b42e969526d079a5ffeed119931705302d315b84
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/array.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/array.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/array.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..1f8db4d8d02dfbc29324dc4eed01ed88d19211ba
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/array.cpp.o.d
@@ -0,0 +1,209 @@
+CMakeFiles/mlx.dir/mlx/array.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_function.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/backward/binders.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant /usr/include/c++/8/bits/parse_numbers.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms_impl.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..d0f8a71de3f7543fcbcf893acd65aaafeae4dcec
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..d785e5053e4db25f766a4c5799499ddb93279c87
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o.d
@@ -0,0 +1,187 @@
+CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..64effabdfe0e6d11855aa6484d8de6eb357ee639
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..908e17e175c3b7d5f103c4a970de64ca4672583c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o.d
@@ -0,0 +1,216 @@
+CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/wchar.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..051b184f328d5be6dfe313e608909f63d4d36e64
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..a803a66a8b3c8ae219708ab51d7f428c4e14aa95
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o.d
@@ -0,0 +1,220 @@
+CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.h \
+ /usr/include/c++/8/functional \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_function.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/backward/binders.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/iomanip \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_facets.h \
+ /usr/include/c++/8/cwctype /usr/include/wctype.h \
+ /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h /usr/include/c++/8/ctime \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/fs_dir.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..be1075d84dbd768636810b54715a6cc49338dd9f
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..5c2cf6dacc9d4c6e0b673ec4b8a3db4c5be11323
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o.d
@@ -0,0 +1,207 @@
+CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/algorithm \
+ /usr/include/c++/8/utility \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..eeb839e2ce4474014f68f04638b55c3506d3ec8d
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..f2516f3bdbc78a2b1d0ffe9d7ea076d871e12e60
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o.d
@@ -0,0 +1,188 @@
+CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..f641b38886b7cabb16e71483e913cbb0bad9e13e
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..72fe40f029d334d87b4ef2e734b955e0688922b5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o.d
@@ -0,0 +1,187 @@
+CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..b62382c948ef3f21d9606a9b0364c138cdfd78ee
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..018a8f72b532eccb3542577c33d38ca3e515b865
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o.d
@@ -0,0 +1,187 @@
+CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp \
+ /usr/include/stdc-predef.h /usr/include/dlfcn.h /usr/include/features.h \
+ /usr/include/sys/cdefs.h /usr/include/bits/wordsize.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/dlfcn.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..bbce6bc8ebddb5258d3c7effa0458baaa33a0e3a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:69c4820715aba7c5dea1ba9cf7b9515edeb38ab8508f9b8da547709b1a5d1126
+size 100640
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..d3236d1361aada51f4b49917210412447f33bef2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o.d
@@ -0,0 +1,216 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..b32af202d71f4f836bfe7883097dd4c815d13f46
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..3f54d898e65e137e8345f22a7c4fdf5b2e828104
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o.d
@@ -0,0 +1,4 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..797d61d5d7e4ccf11db55851bd2bd50e78075a5d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a7cda8679113cff6fbe1fa8a4374837d82572565ff8980228b26488fc6986a5
+size 6001112
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..9319fdf82711231a5756253d650bc4de6145fc82
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o.d
@@ -0,0 +1,227 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h /usr/include/c++/8/cmath \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h /usr/include/math.h \
+ /usr/include/bits/libc-header-start.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/math-vector.h \
+ /usr/include/bits/libm-simd-decl-stubs.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h /usr/include/bits/flt-eval-method.h \
+ /usr/include/bits/fp-logb.h /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/stdlib.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/iosfwd /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/binary.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_two.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..d80c23609cbb076eba3631d13996feb840388402
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..2489f8b2096b87a311c5ae008e6fdd1aeab8d04e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o.d
@@ -0,0 +1,232 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+ /usr/include/c++/8/stdlib.h /usr/include/inttypes.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..0e234413cc10f794d080bb369a5e87c070a6c38d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aabc25ed9305fa08951ba2a360f5aae8b1ad16cd3c79d818c34015c9f9380ed4
+size 300200
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..a269943a9cc721df1affdeb1a5557ab6ba33e5fd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o.d
@@ -0,0 +1,246 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp \
+ /usr/include/stdc-predef.h /usr/include/dlfcn.h /usr/include/features.h \
+ /usr/include/sys/cdefs.h /usr/include/bits/wordsize.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/dlfcn.h /usr/include/c++/8/filesystem \
+ /usr/include/c++/8/bits/fs_fwd.h /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /usr/include/c++/8/fstream \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/basic_file.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++io.h \
+ /usr/include/c++/8/bits/fstream.tcc /usr/include/c++/8/list \
+ /usr/include/c++/8/bits/stl_list.h /usr/include/c++/8/bits/list.tcc \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/shared_mutex /usr/include/c++/8/condition_variable \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/cstring \
+ /usr/include/string.h /usr/include/strings.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/core.h \
+ /usr/include/c++/8/cstddef /usr/include/c++/8/iterator \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format-inl.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/climits \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/iomanip \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/future /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled_preamble.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..d6424c92dda4ee787342657ac8f5d33353875dbf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:89a680b3c2d00f426561c604166b31249e2d28b0f2a4fe63e802fc3d92c4741c
+size 1620304
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..b7e412ba8af75d931abeb22b0cc811e6d6434219
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o.d
@@ -0,0 +1,3 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/compiled_preamble.cpp \
+ /usr/include/stdc-predef.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..ea3056d871482d7a1eebfc683257290b87d369a1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30b12d79d4cbfb0885795d39e54ecff702ed50bc91a7007ba50e0e1954237e06
+size 277904
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..1414a40e2b9b3c914f343b844e67b7fd9b13b8d3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o.d
@@ -0,0 +1,229 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h /usr/include/c++/8/numeric \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/stl_numeric.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/debug/assertions.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/initializer_list /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+ /usr/include/c++/8/stdlib.h /usr/include/inttypes.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..bc53969faeae6fcb0b5950b72f083bf959b9d96d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a09ef641365d5d6d62d526aa197acb5b82ae01c299b4ee2a211579800149cb92
+size 1260976
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..b4b142e657f3f2aa87d8d3f3a3775be79691cda8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o.d
@@ -0,0 +1,202 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/numeric \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/stl_numeric.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/debug/assertions.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /usr/include/c++/8/cstdlib /usr/include/stdlib.h \
+ /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..c0abe6f6447f3af9c3cec17106ceb6fcf50615a2
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..d65dfbd9133dd8ca62d890cef63daf838cbe3158
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o.d
@@ -0,0 +1,227 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /usr/include/c++/8/cstdlib /usr/include/stdlib.h \
+ /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..44aeb7800a4fdbec9fdfa0ca37ee9812d7223c0d
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..dfb6427f3b375df7fc5ac3ce5e17845dbeed901a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o.d
@@ -0,0 +1,231 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/wchar.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+ /usr/include/c++/8/stdlib.h /usr/include/inttypes.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..492fae3d262f943a50cab2a409682093fe01233e
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..dd63dec4e48adc363d0bc57abc7daef8e563cef2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o.d
@@ -0,0 +1,231 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/wchar.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+ /usr/include/c++/8/stdlib.h /usr/include/inttypes.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..aed9f8ffde8bca78a722c273b874ac0bfb6bb057
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..acd9341577493ff3f49fb019f45709a0878d48d6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o.d
@@ -0,0 +1,189 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/initializer_list /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/ptr_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/limits \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/vector /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/thread \
+ /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..d409b2de0c3d5a893c5f1ea25ab217a96e38a8af
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..7abac1d8567a0db15a690c2f933616ec92ad612e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o.d
@@ -0,0 +1,210 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/utility \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/wchar.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/thread \
+ /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..f064aed83d471ffcde467d9babc72df1c1ea342b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:329da3a2f19985bdee33ae4ad7043550dbb5152677fe472220274a12e252185c
+size 436720
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..9474b0f5b3b5019542a763574530528d6ec290e4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o.d
@@ -0,0 +1,211 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/numeric \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/stl_numeric.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/debug/assertions.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/3rdparty/pocketfft.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/libc-header-start.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/math-vector.h \
+ /usr/include/bits/libm-simd-decl-stubs.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h /usr/include/bits/flt-eval-method.h \
+ /usr/include/bits/fp-logb.h /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/stdlib.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/invoke.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/complex /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/algorithm \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/mutex \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/thread \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h /usr/include/c++/8/atomic \
+ /usr/include/c++/8/functional /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/future /usr/include/c++/8/bits/atomic_futex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..6d72506827add55262e91baf6330f6fe137c6a90
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..364f5fd417236b82afe501a85fd29a31eb2baf94
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o.d
@@ -0,0 +1,194 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+ /usr/include/c++/8/stdlib.h /usr/include/inttypes.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..c09d858b7088c392c3f74af59c02c278fe2be2fe
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..c772c9eeedbe7f2246e7bf17e2dabd210f3d0036
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o.d
@@ -0,0 +1,193 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_gemm.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..8797eb5232b05db982221d38107fe7cc80ba4ac7
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..68f561f9fcf74d235a084ec20193c65446338f9c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o.d
@@ -0,0 +1,193 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_gemm.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..801d43be0347b25beb6d2775ad8337c395b5dffe
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..fd640fa4de3d41a6ad868f56ad42743ae6d24839
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o.d
@@ -0,0 +1,224 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/hadamard.h \
+ /usr/include/c++/8/map /usr/include/c++/8/bits/stl_tree.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/initializer_list /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/include/bits/libc-header-start.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/limits \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/stl_map.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/stl_multimap.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/fs_path.h \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..038a9c91a3a38ee9b2af39d4b1d8d306a035963b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f2f56ddd2d5b6fcc8d6684a7aa21e5d6a13de23b8b2c653dd51be4b50473e14
+size 3176944
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..cf2e919e11f14acd7e2346350fed397b972fd2f2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o.d
@@ -0,0 +1,222 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/algorithm \
+ /usr/include/c++/8/utility \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..1ad7706441ee86d7653ebe9ed9f4bd5f531f2e76
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..bc942a27cdc049b422021c30a46d6fa428a78d3b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o.d
@@ -0,0 +1,228 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+ /usr/include/c++/8/stdlib.h /usr/include/inttypes.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..c5fb75a901e0919e09a773ef7521b8331168bb7a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a014e755871e28d31c3c115f647753a997135d0ffc567d1b894e24ecbe245fb
+size 236736
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..e760797fa7218a309cc4299090a36a35d696f510
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o.d
@@ -0,0 +1,183 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/cstring \
+ /usr/include/string.h /usr/include/strings.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/core.h \
+ /usr/include/c++/8/cstddef /usr/include/c++/8/iterator \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format-inl.h \
+ /usr/include/c++/8/climits \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..39bd424efbebdc4300fb06a477727f8af0bd02e2
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..7f028717278d1c2999a72057a72b6f48b651b9da
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o.d
@@ -0,0 +1,225 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h /usr/include/c++/8/cmath \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h /usr/include/math.h \
+ /usr/include/bits/libc-header-start.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/math-vector.h \
+ /usr/include/bits/libm-simd-decl-stubs.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h /usr/include/bits/flt-eval-method.h \
+ /usr/include/bits/fp-logb.h /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/stdlib.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/limits.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..858fd14883b519710822819d2f658038c93c7ef8
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..8d2f57b70ca118fe9e86d17a74543c0e806011c1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o.d
@@ -0,0 +1,228 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /usr/include/c++/8/cstdlib /usr/include/stdlib.h \
+ /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+ /usr/include/c++/8/stdlib.h /usr/include/inttypes.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..08697a097f7a772d1edeacb1c868fd2eab53c213
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27a85330efb59bad63ac90d2325eb1ab165a4f68fae230430cdd0c5632f67f94
+size 161176
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..53b585b140d5abcac0fa2e8868a625e605ba756d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o.d
@@ -0,0 +1,228 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cstring \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/string.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/strings.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h /usr/include/sys/types.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/clockid_t.h \
+ /usr/include/bits/types/time_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/stdint-intn.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h /usr/include/sys/select.h \
+ /usr/include/bits/select.h /usr/include/bits/types/sigset_t.h \
+ /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/wchar.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+ /usr/include/c++/8/stdlib.h /usr/include/inttypes.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..2a9e45d53982cc987722442471ba562305dd98fe
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2605a6ea6db9c1f791d6e36bfac643e082f081c88e38aa3894874552db98bb56
+size 211096
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..3124132416747d8a35c80745d5688c882993848b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o.d
@@ -0,0 +1,222 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cstring \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/string.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/strings.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h /usr/include/sys/types.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/clockid_t.h \
+ /usr/include/bits/types/time_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/stdint-intn.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h /usr/include/sys/select.h \
+ /usr/include/bits/select.h /usr/include/bits/types/sigset_t.h \
+ /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/wchar.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..23b14a3f788032bd33d6e19c3d50542ed9e42907
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:143dfbef37756450a49e3f998bb67d49a2ff7fbdee9bf8b0f5e48ba1e6e256e1
+size 317248
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..b1d35fdfc4a66bf9237080d2662ed60b7a06c4a4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o.d
@@ -0,0 +1,226 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/algorithm \
+ /usr/include/c++/8/utility \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/numeric \
+ /usr/include/c++/8/bits/stl_numeric.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/iosfwd /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arange.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..5790110d65acc6de3f355623960d915fd6f98eb9
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..a03d800b524aa6c1202d3371dc891503f9ef139b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o.d
@@ -0,0 +1,228 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+ /usr/include/c++/8/stdlib.h /usr/include/inttypes.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..44a7a68fab2823d5434d61b9b68ae33a7816a80f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:216a1beb13c136c27bcf392378e1421e00b58ea6b5ab8adbd843ba7071e07e60
+size 343752
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..7027ab4535cf4335ab02cf8089aa864bff53ca41
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o.d
@@ -0,0 +1,228 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..cf8709620b58ea8fdce74e8f1a5dd5f6165e0bf1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53b9216be8233d8aafd1e091c470d9c06bb59714be3f8883cf995ebf26ca8851
+size 952152
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..3a025f38002e13be565ba3dfffe3ab7161cce7e6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o.d
@@ -0,0 +1,222 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/stl_function.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/backward/binders.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..9f1666e392cf013e2ef275ce43f363e6677c81d0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92150eb8ba9b641ef0a30ce674ec069653a8d54eac8165ea17c1cb77a064300b
+size 360232
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..54249f563bc5bca106f20b115bce2e6af6b3207f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o.d
@@ -0,0 +1,223 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..0964e8e2483f0f4cf3a4eb3e6d52f48afae6916e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07023363287e4a2806f3f6066654173db092b091d3048dafce7018722d0d8d59
+size 133480
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..b3e5da936a18b4dcb4bc8d1c2327bf1e5f22ad75
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o.d
@@ -0,0 +1,225 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/algorithm \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h /usr/include/sys/select.h \
+ /usr/include/bits/select.h /usr/include/bits/types/sigset_t.h \
+ /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/complex \
+ /usr/include/c++/8/sstream /usr/include/c++/8/istream \
+ /usr/include/c++/8/ios /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/cstdint /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/ternary.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/ternary.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..3befc4f269594bb2bfa69f5720348902ecb67bea
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..63843e3d0b747b5da6c646ca4758526e85b165ce
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o.d
@@ -0,0 +1,225 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h /usr/include/c++/8/cmath \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h /usr/include/math.h \
+ /usr/include/bits/libc-header-start.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/math-vector.h \
+ /usr/include/bits/libm-simd-decl-stubs.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h /usr/include/bits/flt-eval-method.h \
+ /usr/include/bits/fp-logb.h /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/stdlib.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/limits.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..d2708147754c7ea72e750ecf66ff9a091ae92aca
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9faba34440821a77c88d04ec00a09e329928421646455e488a5328ce26b576a0
+size 562912
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..62ccab97b0e08e2675816578bb561f616f100817
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o.d
@@ -0,0 +1,223 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/algorithm \
+ /usr/include/c++/8/utility \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/numeric \
+ /usr/include/c++/8/bits/stl_numeric.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..818b9ab5842db75b83c5b08587c092ea81e1ff11
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..f9caf361bf371435bdbb0df8fa8a1a90bf465160
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o.d
@@ -0,0 +1,228 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/copy.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/cblas.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/openblas_config.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapack.h \
+ /software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include/lapacke_mangling.h \
+ /usr/include/c++/8/stdlib.h /usr/include/inttypes.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..8107d7c1a0dc1dd148ce1e810ae6fe54517ce670
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..88389d29d9062234815721d33f683a3393c80a04
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o.d
@@ -0,0 +1,20 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.h \
+ /usr/include/c++/8/cstdint \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..62e56eb2929fd7b3a5040eb4bbe18a52a2091342
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e78a34022149e8664e97e93ffb29982ce52b95189766e571985f8a25aaada463
+size 1214672
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..2c14d7b73bb2f7c20634344295d58ea850a97de7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o.d
@@ -0,0 +1,226 @@
+CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/unary.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /usr/include/c++/8/cstdlib /usr/include/stdlib.h \
+ /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..9fc50240a4fb37b85419732ac92b8913d5029399
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..23e0539301a96aee0a99128e797337689ced13a8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o.d
@@ -0,0 +1,181 @@
+CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/variant /usr/include/c++/8/bits/invoke.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..759735673e02836bd855bfd896a9fb8653f4fb6d
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..6f2c5efa137bf5b46da771416bc1363b6e292544
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o.d
@@ -0,0 +1,180 @@
+CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/metal.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/variant \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/vector /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..b9eb1d65bb08621643918399f8280c84bdb62bc9
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..df4dcc7090d1e01a3e8a77ecbfc0a2cf56483bad
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o.d
@@ -0,0 +1,120 @@
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/algorithm \
+ /usr/include/c++/8/utility \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/mutex /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/bits/std_mutex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/linux_memory.h \
+ /usr/include/sys/sysinfo.h /usr/include/linux/kernel.h \
+ /usr/include/linux/sysinfo.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..857eaa6f09de0b52fe10ebcdb3b454c4624e7836
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..463cca2ffec89154dae4c4cc1beb56334ee6a959
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o.d
@@ -0,0 +1,186 @@
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/available.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /usr/include/c++/8/future /usr/include/c++/8/mutex \
+ /usr/include/c++/8/tuple /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/thread \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/atomic \
+ /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/bits/std_function.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..e814e4b666ff2c0adec71ba08e733c720c64c21a
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..ee34c3d500a0a0f48d0b942ced46b3a2bcbe6097
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o.d
@@ -0,0 +1,184 @@
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/include/bits/libc-header-start.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sched.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/thread \
+ /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_queue.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..069c774c9e40935f4a80ac25db0c47380fc3c089
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..ad1423617e235840c0c00bfd653d9a49bb0f5e19
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o.d
@@ -0,0 +1,187 @@
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/ctime /usr/include/time.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/cerrno /usr/include/errno.h /usr/include/bits/errno.h \
+ /usr/include/linux/errno.h /usr/include/asm/errno.h \
+ /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \
+ /usr/include/bits/types/error_t.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/mutex \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fence.h \
+ /usr/include/c++/8/vector /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/thread /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..19c6b211e468edf46049e7c5358a17aab23b205c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62e0df4f6b6ba923dcf70d33a10a88b82dd8301c460443d2ceab9a4c5521289e
+size 129944
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..fc78f896464c6ede4112b9e3719362ed64ab08be
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o.d
@@ -0,0 +1,212 @@
+CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/initializer_list /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/ptr_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/limits \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/unordered_map.h \
+ /usr/include/c++/8/vector /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/compile.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/compile.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..1a621c1e3f239ca0cdb98003cc01f2f0e1671e6f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/compile.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d1bf264fb998710e19e74a5826f32ecf86fac18a3556e8b927bbdec2fd068a9
+size 180712
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/compile.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/compile.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..1fa61f4786d9284eb6ce88788e93213fd2cfbcb0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/compile.cpp.o.d
@@ -0,0 +1,225 @@
+CMakeFiles/mlx.dir/mlx/compile.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/map \
+ /usr/include/c++/8/bits/stl_tree.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/initializer_list /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/limits \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/stl_map.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/stl_multimap.h \
+ /usr/include/c++/8/sstream /usr/include/c++/8/istream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/unordered_set \
+ /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/iomanip \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/ctime \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/quoted_string.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile_impl.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms_impl.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/device.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/device.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..84e2e9b255eb8bb083075941ad53a3779907b27d
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/device.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/device.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/device.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..dfcbc11f8c3d7a0484ec2348f8724803adcf52d2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/device.cpp.o.d
@@ -0,0 +1,102 @@
+CMakeFiles/mlx.dir/mlx/device.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/available.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..268af7980938d56687b4a564e90002118b791e5b
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..b4c2decf8f7b1aaf8f3472bbf2591de46f4950ad
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o.d
@@ -0,0 +1,187 @@
+CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/initializer_list /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/ptr_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/limits \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant /usr/include/c++/8/bits/parse_numbers.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..ea8ea3cef308c825d08169aa31d17eeb39d9c7d5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa018a8728947482f37c46d232bb9a1c8ff54d352f5b90fdf73093980cf69184
+size 114128
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..9aee1d7618c9ecafadc5bbd3350e97960aff1233
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o.d
@@ -0,0 +1,193 @@
+CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp \
+ /usr/include/stdc-predef.h /usr/include/dlfcn.h /usr/include/features.h \
+ /usr/include/sys/cdefs.h /usr/include/bits/wordsize.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/dlfcn.h /usr/include/c++/8/iostream \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/ostream /usr/include/c++/8/ios \
+ /usr/include/c++/8/iosfwd /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/include/bits/libc-header-start.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/vector /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/thread \
+ /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi_declarations.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..a77c2b788907b5aedee877f1f7107a8cda6751cf
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..4f3ea3e3c88fe882b3763ecb684c251dbc549d30
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o.d
@@ -0,0 +1,178 @@
+CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/include/bits/libc-header-start.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sched.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant /usr/include/c++/8/bits/parse_numbers.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..5f8ae7c49db1d033a85e3cfc598d7b4bf30542d0
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..d52aca6de95364a81f592683102798d5129de3ee
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o.d
@@ -0,0 +1,212 @@
+CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/metal.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/variant \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..e2e315852dbdb1387b101fe760c890749d101b92
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..79a5d70ac930322bdd18de83753fa2ccdec81c1c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o.d
@@ -0,0 +1,214 @@
+CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /usr/include/c++/8/cstdlib /usr/include/stdlib.h \
+ /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/invoke.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant /usr/include/c++/8/bits/parse_numbers.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..4b1ccda6c3350dc594885b1cae34761f9d3647c4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00ac5e581143a94968033461c00ba3c18c193f0938df2c0253b50f62fd339c2b
+size 2089376
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..44473be8d318fcc39dcd6baf0a268090df698adf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o.d
@@ -0,0 +1,244 @@
+CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp \
+ /usr/include/stdc-predef.h /usr/include/arpa/inet.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/wordsize.h /usr/include/bits/long-double.h \
+ /usr/include/gnu/stubs.h /usr/include/gnu/stubs-64.h \
+ /usr/include/netinet/in.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/sys/socket.h /usr/include/bits/types/struct_iovec.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/socket.h /usr/include/sys/types.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/clockid_t.h \
+ /usr/include/bits/types/time_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/stdint-intn.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h /usr/include/sys/select.h \
+ /usr/include/bits/select.h /usr/include/bits/types/sigset_t.h \
+ /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/socket_type.h \
+ /usr/include/bits/sockaddr.h /usr/include/asm/socket.h \
+ /usr/include/asm-generic/socket.h /usr/include/asm/sockios.h \
+ /usr/include/asm-generic/sockios.h \
+ /usr/include/bits/types/struct_osockaddr.h /usr/include/bits/in.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/linux/falloc.h \
+ /usr/include/bits/stat.h /usr/include/netdb.h /usr/include/rpc/netdb.h \
+ /usr/include/bits/types/sigevent_t.h \
+ /usr/include/bits/types/__sigval_t.h /usr/include/bits/netdb.h \
+ /usr/include/netinet/tcp.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/wchar.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/cstdint /usr/include/c++/8/limits \
+ /usr/include/c++/8/ctime /usr/include/time.h /usr/include/bits/time.h \
+ /usr/include/bits/timex.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/c++/8/bits/parse_numbers.h /usr/include/c++/8/fstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/iosfwd /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/basic_file.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++io.h \
+ /usr/include/c++/8/bits/fstream.tcc /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/std_mutex.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/atomic \
+ /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/iostream \
+ /usr/include/c++/8/list /usr/include/c++/8/bits/stl_list.h \
+ /usr/include/c++/8/bits/list.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann/json.hpp \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/functional /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/iterator /usr/include/c++/8/bits/stream_iterator.h \
+ /usr/include/c++/8/forward_list /usr/include/c++/8/bits/forward_list.h \
+ /usr/include/c++/8/bits/forward_list.tcc /usr/include/c++/8/map \
+ /usr/include/c++/8/bits/stl_tree.h /usr/include/c++/8/bits/stl_map.h \
+ /usr/include/c++/8/bits/stl_multimap.h /usr/include/c++/8/valarray \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /usr/include/c++/8/bits/valarray_array.h \
+ /usr/include/c++/8/bits/valarray_array.tcc \
+ /usr/include/c++/8/bits/valarray_before.h \
+ /usr/include/c++/8/bits/slice_array.h \
+ /usr/include/c++/8/bits/valarray_after.h \
+ /usr/include/c++/8/bits/gslice.h /usr/include/c++/8/bits/gslice_array.h \
+ /usr/include/c++/8/bits/mask_array.h \
+ /usr/include/c++/8/bits/indirect_array.h /usr/include/c++/8/cassert \
+ /usr/include/assert.h /usr/include/c++/8/cstring /usr/include/string.h \
+ /usr/include/strings.h /usr/include/c++/8/filesystem \
+ /usr/include/c++/8/bits/fs_fwd.h /usr/include/c++/8/bits/fs_path.h \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h /usr/include/c++/8/numeric \
+ /usr/include/c++/8/bits/stl_numeric.h /usr/include/c++/8/iomanip \
+ /usr/include/c++/8/any \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/dtype.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/dtype.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..1db63b7b0a8f8da01d99828cd7a0dfe8d4bdd6d2
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/dtype.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/dtype.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/dtype.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..293a944232e8e1488a4aca4928dd1006b398177c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/dtype.cpp.o.d
@@ -0,0 +1,148 @@
+CMakeFiles/mlx.dir/mlx/dtype.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cstdint \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h /usr/include/c++/8/cmath \
+ /usr/include/math.h /usr/include/bits/math-vector.h \
+ /usr/include/bits/libm-simd-decl-stubs.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h /usr/include/bits/flt-eval-method.h \
+ /usr/include/bits/fp-logb.h /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/stdlib.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h /usr/include/sys/select.h \
+ /usr/include/bits/select.h /usr/include/bits/types/sigset_t.h \
+ /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/iosfwd /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..6e5212521fcec48e89c682eadb428d6b936d64e6
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..0c89efe3c241cce8781bdde921a34632cdd93d22
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o.d
@@ -0,0 +1,178 @@
+CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.h \
+ /usr/include/c++/8/sstream /usr/include/c++/8/istream \
+ /usr/include/c++/8/ios /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/einsum.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/einsum.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..764dd866fb67e2fe672f66131f1174071b048087
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/einsum.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be18c0c5ce8301c4dc419b8eb2724ad666c9e8f2fee97f068885a1ef65513286
+size 144704
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/einsum.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/einsum.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..a74df994023ed4a8b974b4dc4f117350c05db318
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/einsum.cpp.o.d
@@ -0,0 +1,179 @@
+CMakeFiles/mlx.dir/mlx/einsum.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/numeric \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/stl_numeric.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/debug/assertions.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/iosfwd /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/include/bits/libc-header-start.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/unordered_set \
+ /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.h \
+ /usr/include/c++/8/vector /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant /usr/include/c++/8/bits/parse_numbers.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/export.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/export.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..1c3939796db93a5f6c1f78bb0bcaf63417772009
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/export.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fbbe63b321efd881d62456f760b902a490e3541683d4554501b79c0c45a5fee3
+size 1442272
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/export.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/export.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..152cfbe0f4ccb485fd3fed3792c2d257e9122307
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/export.cpp.o.d
@@ -0,0 +1,214 @@
+CMakeFiles/mlx.dir/mlx/export.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.h \
+ /usr/include/c++/8/set /usr/include/c++/8/bits/stl_tree.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/initializer_list /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/include/bits/libc-header-start.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/limits \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/stl_set.h /usr/include/c++/8/bits/stl_multiset.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/unordered_map.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/vector /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export_impl.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h /usr/include/c++/8/map \
+ /usr/include/c++/8/bits/stl_map.h /usr/include/c++/8/bits/stl_multimap.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile_impl.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/fast.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/fast.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..a823781b73b409a6416be175931200ad31885a9c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/fast.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6ae15baaf991975a22e580fff1b2267b4c4c9eb4ed8aa17982e7f3e63c44396
+size 236504
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/fast.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/fast.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..7b24af98b0018b1ea188b64f07380008f0614e20
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/fast.cpp.o.d
@@ -0,0 +1,211 @@
+CMakeFiles/mlx.dir/mlx/fast.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cassert \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/assert.h /usr/include/c++/8/numeric \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/stl_numeric.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/debug/assertions.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/initializer_list /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/variant /usr/include/c++/8/bits/invoke.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/fft.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/fft.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..34f3679bc54c089932bd57ea60540c5ca3e274c9
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/fft.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/fft.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/fft.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..c6f3edd9cff6c4a016731cadb898e1fe84408ed4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/fft.cpp.o.d
@@ -0,0 +1,212 @@
+CMakeFiles/mlx.dir/mlx/fft.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/numeric \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/stl_numeric.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/debug/assertions.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h /usr/include/c++/8/set \
+ /usr/include/c++/8/bits/stl_tree.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/initializer_list /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/include/bits/libc-header-start.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/limits \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/stl_set.h /usr/include/c++/8/bits/stl_multiset.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.h \
+ /usr/include/c++/8/variant /usr/include/c++/8/bits/invoke.h \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..501d9b8e1890fd6cd732e00c1b7cf071430c94d6
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..6f24d5ebe55e0d705123f71f828a337778589e44
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o.d
@@ -0,0 +1,208 @@
+CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_function.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/backward/binders.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/unordered_set \
+ /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..868cab0694a228d8291d1be6168d9d165d1ea5e9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:822597fa4d49abbb63f4079dd68743fc1665589464af3f3435e11137c09eda6e
+size 184760
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..0d9d0fe376dad763e412f2d4f62281144f655a68
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o.d
@@ -0,0 +1,216 @@
+CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cstdint \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/cstring \
+ /usr/include/string.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/strings.h /usr/include/c++/8/fstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/iosfwd /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/basic_file.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++io.h \
+ /usr/include/c++/8/bits/fstream.tcc /usr/include/c++/8/numeric \
+ /usr/include/c++/8/bits/stl_numeric.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/variant \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/vector /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..47a07853690558ac4b2482e37170e6c0e01173d8
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..c3df3ddd0f873b8dc3b2eca133b3897023920844
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o.d
@@ -0,0 +1,214 @@
+CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cstdint \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/cstring \
+ /usr/include/string.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/strings.h /usr/include/c++/8/numeric \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/stl_numeric.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/debug/assertions.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/ptr_traits.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/limits \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/variant \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/vector /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/load.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/load.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..68fd8ac8c126445e05908d4e159b2be9318a644b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/load.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:779a20fbc0e07e35ccac8ccdb8fd6e369100889996d479d077c3a89e13b985d3
+size 145112
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/load.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/load.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..e9ff6e38c9925742eae0232433edc8d1c9337a38
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/load.cpp.o.d
@@ -0,0 +1,212 @@
+CMakeFiles/mlx.dir/mlx/io/load.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/algorithm \
+ /usr/include/c++/8/utility \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/cstring /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/fstream /usr/include/c++/8/istream \
+ /usr/include/c++/8/ios /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/basic_file.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++io.h \
+ /usr/include/c++/8/bits/fstream.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/invoke.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h /usr/include/fcntl.h \
+ /usr/include/bits/fcntl.h /usr/include/bits/fcntl-linux.h \
+ /usr/include/bits/types/struct_iovec.h /usr/include/linux/falloc.h \
+ /usr/include/bits/stat.h /usr/include/sys/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/future /usr/include/c++/8/mutex \
+ /usr/include/c++/8/thread /usr/include/c++/8/atomic \
+ /usr/include/c++/8/bits/atomic_futex.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..6b62548dcbcc2e3efc251080f0c62bac064c4485
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3e7d51f142cc08497dcc7d28206721b2e113d00ec9565e3c4db1e3fe7864030
+size 398664
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..d364b40beb8bd1c98ea91df34b138115a7f89f9b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o.d
@@ -0,0 +1,240 @@
+CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann/json.hpp \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/utility \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/cstddef /usr/include/c++/8/functional \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h /usr/include/c++/8/forward_list \
+ /usr/include/c++/8/bits/forward_list.h \
+ /usr/include/c++/8/bits/forward_list.tcc /usr/include/c++/8/map \
+ /usr/include/c++/8/bits/stl_tree.h /usr/include/c++/8/bits/stl_map.h \
+ /usr/include/c++/8/bits/stl_multimap.h /usr/include/c++/8/valarray \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /usr/include/c++/8/bits/valarray_array.h \
+ /usr/include/c++/8/bits/valarray_array.tcc \
+ /usr/include/c++/8/bits/valarray_before.h \
+ /usr/include/c++/8/bits/slice_array.h \
+ /usr/include/c++/8/bits/valarray_after.h \
+ /usr/include/c++/8/bits/gslice.h /usr/include/c++/8/bits/gslice_array.h \
+ /usr/include/c++/8/bits/mask_array.h \
+ /usr/include/c++/8/bits/indirect_array.h /usr/include/c++/8/cassert \
+ /usr/include/assert.h /usr/include/c++/8/cstring /usr/include/string.h \
+ /usr/include/strings.h /usr/include/c++/8/filesystem \
+ /usr/include/c++/8/bits/fs_fwd.h /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/locale \
+ /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/bits/fs_ops.h /usr/include/c++/8/numeric \
+ /usr/include/c++/8/bits/stl_numeric.h /usr/include/c++/8/iomanip \
+ /usr/include/c++/8/any /usr/include/c++/8/stack /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_stack.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/linalg.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/linalg.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..4db210a7cf6ca62dd16eb52717ed75934c7c5e76
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/linalg.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99838a1dfa36d09077edb7c565a7d38b6bfb040f03474ab17b036629b0e60275
+size 200136
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/linalg.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/linalg.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..0269ae15e9d8ad3b4c940f4595c588bf9322a1a2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/linalg.cpp.o.d
@@ -0,0 +1,208 @@
+CMakeFiles/mlx.dir/mlx/linalg.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/numeric \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/stl_numeric.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/debug/assertions.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/bits/stringfwd.h /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ios_base.h /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h \
+ /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant /usr/include/c++/8/bits/parse_numbers.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/ops.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/ops.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..14e0bfaf2efd227d791d43c562d15edb25cee2bc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/ops.cpp.o.d
@@ -0,0 +1,219 @@
+CMakeFiles/mlx.dir/mlx/ops.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/algorithm \
+ /usr/include/c++/8/utility \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/climits \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/numeric \
+ /usr/include/c++/8/bits/stl_numeric.h /usr/include/c++/8/set \
+ /usr/include/c++/8/bits/stl_tree.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/stl_set.h /usr/include/c++/8/bits/stl_multiset.h \
+ /usr/include/c++/8/sstream /usr/include/c++/8/istream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast_primitives.h \
+ /usr/include/c++/8/variant /usr/include/c++/8/bits/invoke.h \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms_impl.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/primitives.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/primitives.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..1067801fc3609207f83e538bbc178742c89fb77a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/primitives.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:139627643953c5e5a10001672da951988f99b9e9019ac426bd0850a9140690e7
+size 703176
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/primitives.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/primitives.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..d59d8e7e38030d67bfdb341bc5ecce4a917dc52a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/primitives.cpp.o.d
@@ -0,0 +1,221 @@
+CMakeFiles/mlx.dir/mlx/primitives.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/algorithm \
+ /usr/include/c++/8/utility \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/numeric \
+ /usr/include/c++/8/bits/stl_numeric.h /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/iosfwd /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.h \
+ /usr/include/c++/8/filesystem /usr/include/c++/8/bits/fs_fwd.h \
+ /usr/include/c++/8/chrono /usr/include/c++/8/ratio \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h \
+ /usr/include/c++/8/bits/fs_path.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/locale /usr/include/c++/8/bits/locale_facets_nonio.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/time_members.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/messages_members.h \
+ /usr/include/libintl.h /usr/include/c++/8/bits/codecvt.h \
+ /usr/include/c++/8/bits/locale_facets_nonio.tcc \
+ /usr/include/c++/8/bits/locale_conv.h \
+ /usr/include/c++/8/bits/unique_ptr.h /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/codecvt \
+ /usr/include/c++/8/bits/quoted_string.h /usr/include/c++/8/bits/fs_dir.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h /usr/include/c++/8/bits/fs_ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/random.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/random.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..6bef96ab02abe32bdd8e978634241f57d89fe6fe
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/random.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a4b7fc7cecf721f0a18b91195b8144fdc75623252b1486fbe9c32c326ae3e1d
+size 133304
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/random.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/random.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..dc8d2e8e64af1ae3932a555bfb658d39d5defa82
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/random.cpp.o.d
@@ -0,0 +1,209 @@
+CMakeFiles/mlx.dir/mlx/random.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cmath \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h /usr/include/math.h \
+ /usr/include/bits/libc-header-start.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/math-vector.h \
+ /usr/include/bits/libm-simd-decl-stubs.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h /usr/include/bits/flt-eval-method.h \
+ /usr/include/bits/fp-logb.h /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/stdlib.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/bits/move.h \
+ /usr/include/c++/8/bits/concept_check.h /usr/include/c++/8/type_traits \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/iosfwd /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.h \
+ /usr/include/c++/8/optional /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant /usr/include/c++/8/bits/parse_numbers.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /usr/include/c++/8/unordered_set /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/thread \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/deque \
+ /usr/include/c++/8/bits/stl_deque.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/scheduler.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/scheduler.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..e13b7b0bf31c73879c7cc52d717c72ac4ac645ee
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/scheduler.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/scheduler.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/scheduler.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..dc092013cb2cfce30805dc39a6c6f5067da1a475
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/scheduler.cpp.o.d
@@ -0,0 +1,189 @@
+CMakeFiles/mlx.dir/mlx/scheduler.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/future \
+ /usr/include/c++/8/mutex /usr/include/c++/8/tuple \
+ /usr/include/c++/8/utility /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/bits/stl_pair.h /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/array /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/cstdint \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/thread \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /usr/include/c++/8/condition_variable \
+ /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/queue \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/deque.tcc /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_queue.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/functional \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/istream /usr/include/c++/8/ios \
+ /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/available.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/transforms.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/transforms.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..9e2021976adb82997b220f0cde24210d81125aee
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/transforms.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cdb555482b904d8be3734a8427d3957bc8994f64b4cbad2f66d0b43c736cf1a
+size 249392
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/transforms.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/transforms.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..9e9fd3584aed24cab548826dea6eed50de7e5c85
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/transforms.cpp.o.d
@@ -0,0 +1,219 @@
+CMakeFiles/mlx.dir/mlx/transforms.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/algorithm \
+ /usr/include/c++/8/utility \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/c++/8/bits/stl_relops.h /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/stl_algo.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/stl_construct.h /usr/include/c++/8/new \
+ /usr/include/c++/8/exception /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/limits \
+ /usr/include/c++/8/deque /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_deque.h \
+ /usr/include/c++/8/bits/range_access.h /usr/include/c++/8/bits/deque.tcc \
+ /usr/include/c++/8/future /usr/include/c++/8/mutex \
+ /usr/include/c++/8/tuple /usr/include/c++/8/array \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/char_traits.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/string_view /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ratio /usr/include/c++/8/ctime \
+ /usr/include/c++/8/bits/parse_numbers.h /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/bits/std_mutex.h /usr/include/c++/8/thread \
+ /usr/include/c++/8/memory /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /usr/include/c++/8/condition_variable /usr/include/c++/8/atomic \
+ /usr/include/c++/8/bits/atomic_futex.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/numeric \
+ /usr/include/c++/8/bits/stl_numeric.h /usr/include/c++/8/set \
+ /usr/include/c++/8/bits/stl_tree.h /usr/include/c++/8/bits/node_handle.h \
+ /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/stl_set.h /usr/include/c++/8/bits/stl_multiset.h \
+ /usr/include/c++/8/sstream /usr/include/c++/8/istream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc /usr/include/c++/8/ostream \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/stack \
+ /usr/include/c++/8/bits/stl_stack.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/unordered_set \
+ /usr/include/c++/8/bits/unordered_set.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fence.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/memory.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.h \
+ /usr/include/fcntl.h /usr/include/bits/fcntl.h \
+ /usr/include/bits/fcntl-linux.h /usr/include/bits/types/struct_iovec.h \
+ /usr/include/linux/falloc.h /usr/include/bits/stat.h \
+ /usr/include/sys/stat.h /usr/include/bits/statx.h \
+ /usr/include/linux/stat.h /usr/include/linux/types.h \
+ /usr/include/asm/types.h /usr/include/asm-generic/types.h \
+ /usr/include/asm-generic/int-ll64.h /usr/include/asm/bitsperlong.h \
+ /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \
+ /usr/include/linux/stddef.h /usr/include/asm/posix_types.h \
+ /usr/include/asm/posix_types_64.h /usr/include/asm-generic/posix_types.h \
+ /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/threadpool.h \
+ /usr/include/c++/8/queue /usr/include/c++/8/bits/stl_queue.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms_impl.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/utils.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/utils.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..17ae16a90ab940b84f82d5487b27bbb41196251d
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/utils.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/utils.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/utils.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..e3b89d5c3127b811b34ccf94182b19019fbda973
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/mlx/utils.cpp.o.d
@@ -0,0 +1,181 @@
+CMakeFiles/mlx.dir/mlx/utils.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.cpp \
+ /usr/include/stdc-predef.h /usr/include/c++/8/cstdlib \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/include/stdlib.h /usr/include/bits/libc-header-start.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/sys/types.h /usr/include/bits/types.h \
+ /usr/include/bits/typesizes.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/include/c++/8/bits/std_abs.h /usr/include/c++/8/iostream \
+ /usr/include/c++/8/ostream /usr/include/c++/8/ios \
+ /usr/include/c++/8/iosfwd /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h /usr/include/c++/8/bits/postypes.h \
+ /usr/include/c++/8/cwchar /usr/include/wchar.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/wchar.h /usr/include/bits/types/wint_t.h \
+ /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/stdint-uintn.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/cctype \
+ /usr/include/ctype.h /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/struct_itimerspec.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/bits/locale_classes.h /usr/include/c++/8/string \
+ /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdio \
+ /usr/include/stdio.h /usr/include/bits/types/__fpos_t.h \
+ /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/stdexcept /usr/include/c++/8/streambuf \
+ /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc /usr/include/c++/8/sstream \
+ /usr/include/c++/8/bits/sstream.tcc /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.h \
+ /usr/include/c++/8/complex /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.h \
+ /usr/include/c++/8/variant \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/parse_numbers.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/refwrap.h /usr/include/c++/8/bits/std_function.h \
+ /usr/include/c++/8/unordered_map /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/event.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/stream.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/small_vector.h \
+ /usr/include/c++/8/cassert /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/limits.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/progress.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/progress.make
new file mode 100644
index 0000000000000000000000000000000000000000..1e326a30ca74a2b8f6c8461b677964db014034e8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/mlx.dir/progress.make
@@ -0,0 +1,80 @@
+CMAKE_PROGRESS_1 = 25
+CMAKE_PROGRESS_2 = 26
+CMAKE_PROGRESS_3 = 27
+CMAKE_PROGRESS_4 = 28
+CMAKE_PROGRESS_5 = 
+CMAKE_PROGRESS_6 = 29
+CMAKE_PROGRESS_7 = 30
+CMAKE_PROGRESS_8 = 31
+CMAKE_PROGRESS_9 = 32
+CMAKE_PROGRESS_10 = 33
+CMAKE_PROGRESS_11 = 
+CMAKE_PROGRESS_12 = 34
+CMAKE_PROGRESS_13 = 35
+CMAKE_PROGRESS_14 = 36
+CMAKE_PROGRESS_15 = 37
+CMAKE_PROGRESS_16 = 38
+CMAKE_PROGRESS_17 = 
+CMAKE_PROGRESS_18 = 39
+CMAKE_PROGRESS_19 = 40
+CMAKE_PROGRESS_20 = 41
+CMAKE_PROGRESS_21 = 42
+CMAKE_PROGRESS_22 = 
+CMAKE_PROGRESS_23 = 43
+CMAKE_PROGRESS_24 = 44
+CMAKE_PROGRESS_25 = 45
+CMAKE_PROGRESS_26 = 46
+CMAKE_PROGRESS_27 = 47
+CMAKE_PROGRESS_28 = 
+CMAKE_PROGRESS_29 = 48
+CMAKE_PROGRESS_30 = 49
+CMAKE_PROGRESS_31 = 50
+CMAKE_PROGRESS_32 = 51
+CMAKE_PROGRESS_33 = 52
+CMAKE_PROGRESS_34 = 
+CMAKE_PROGRESS_35 = 53
+CMAKE_PROGRESS_36 = 54
+CMAKE_PROGRESS_37 = 55
+CMAKE_PROGRESS_38 = 56
+CMAKE_PROGRESS_39 = 57
+CMAKE_PROGRESS_40 = 
+CMAKE_PROGRESS_41 = 58
+CMAKE_PROGRESS_42 = 59
+CMAKE_PROGRESS_43 = 60
+CMAKE_PROGRESS_44 = 61
+CMAKE_PROGRESS_45 = 
+CMAKE_PROGRESS_46 = 62
+CMAKE_PROGRESS_47 = 63
+CMAKE_PROGRESS_48 = 64
+CMAKE_PROGRESS_49 = 65
+CMAKE_PROGRESS_50 = 66
+CMAKE_PROGRESS_51 = 
+CMAKE_PROGRESS_52 = 67
+CMAKE_PROGRESS_53 = 68
+CMAKE_PROGRESS_54 = 69
+CMAKE_PROGRESS_55 = 70
+CMAKE_PROGRESS_56 = 71
+CMAKE_PROGRESS_57 = 
+CMAKE_PROGRESS_58 = 72
+CMAKE_PROGRESS_59 = 73
+CMAKE_PROGRESS_60 = 74
+CMAKE_PROGRESS_61 = 75
+CMAKE_PROGRESS_62 = 76
+CMAKE_PROGRESS_63 = 
+CMAKE_PROGRESS_64 = 77
+CMAKE_PROGRESS_65 = 78
+CMAKE_PROGRESS_66 = 79
+CMAKE_PROGRESS_67 = 80
+CMAKE_PROGRESS_68 = 
+CMAKE_PROGRESS_69 = 81
+CMAKE_PROGRESS_70 = 82
+CMAKE_PROGRESS_71 = 83
+CMAKE_PROGRESS_72 = 84
+CMAKE_PROGRESS_73 = 85
+CMAKE_PROGRESS_74 = 
+CMAKE_PROGRESS_75 = 86
+CMAKE_PROGRESS_76 = 87
+CMAKE_PROGRESS_77 = 88
+CMAKE_PROGRESS_78 = 89
+CMAKE_PROGRESS_79 = 90
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..c17e934b51c1f08a2b3056e4cd63fe62d111672d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+97
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/MLXConfig.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/MLXConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..748b1b604632e01083e92e5f73464e612bf23561
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/MLXConfig.cmake
@@ -0,0 +1,66 @@
+# Find MLX
+#
+# Defines the following variables:
+#
+#   MLX_FOUND            : True if MLX is found
+#   MLX_INCLUDE_DIRS     : Include directory
+#   MLX_LIBRARIES        : Libraries to link against
+#   MLX_CXX_FLAGS        : Additional compiler flags
+#   MLX_BUILD_ACCELERATE : True if MLX was built with accelerate 
+#   MLX_BUILD_METAL      : True if MLX was built with metal 
+
+
+####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() #######
+####### Any changes to this file will be overwritten by the next CMake run ####
+####### The input file was mlx.pc.in                            ########
+
+get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
+
+macro(set_and_check _var _file)
+  set(${_var} "${_file}")
+  if(NOT EXISTS "${_file}")
+    message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
+  endif()
+endmacro()
+
+####################################################################################
+
+include(${PACKAGE_PREFIX_DIR}/share/cmake/MLX/MLXTargets.cmake)
+include(${PACKAGE_PREFIX_DIR}/share/cmake/MLX/extension.cmake)
+
+set_and_check(MLX_LIBRARY_DIRS ${PACKAGE_PREFIX_DIR}/lib64)
+set_and_check(MLX_INCLUDE_DIRS ${PACKAGE_PREFIX_DIR}/include)
+set(MLX_LIBRARIES mlx)
+
+find_library(MLX_LIBRARY mlx PATHS ${MLX_LIBRARY_DIRS})
+
+if (OFF)
+    set(MLX_BUILD_ACCELERATE OFF)
+    set(MLX_CXX_FLAGS ${MLX_CXX_FLAGS} -DACCELERATE_NEW_LAPACK)
+endif()
+
+if (OFF)
+    set(MLX_BUILD_METAL OFF)
+    set(MLX_CXX_FLAGS ${MLX_CXX_FLAGS} -D_METAL_)
+    set(MLX_INCLUDE_DIRS 
+        "${MLX_INCLUDE_DIRS};"
+        ${PACKAGE_PREFIX_DIR}/include/metal_cpp
+    )
+    if( GREATER_EQUAL 310)
+      set(MLX_INCLUDE_DIRS
+        "${MLX_INCLUDE_DIRS};"
+        ${PACKAGE_PREFIX_DIR}/include/mlx/backend/metal/kernels/metal_3_1)
+    else()
+      set(MLX_INCLUDE_DIRS
+        "${MLX_INCLUDE_DIRS};"
+        ${PACKAGE_PREFIX_DIR}/include/mlx/backend/metal/kernels/metal_3_0)
+    endif()
+endif()
+
+set_target_properties(mlx PROPERTIES
+    CXX_STANDARD 17
+    INTERFACE_COMPILE_OPTIONS "${MLX_CXX_FLAGS}"
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(MLX DEFAULT_MSG MLX_LIBRARY MLX_INCLUDE_DIRS)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/MLXConfigVersion.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/MLXConfigVersion.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ca2d8c0879d7c2cc2464f104e63296399b19fc53
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/MLXConfigVersion.cmake
@@ -0,0 +1,65 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version,
+# but only if the requested major version is the same as the current one.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+
+set(PACKAGE_VERSION "0.29.2.dev20251007+0073096d")
+
+if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+
+  if("0.29.2.dev20251007+0073096d" MATCHES "^([0-9]+)\\.")
+    set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}")
+    if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0)
+      string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}")
+    endif()
+  else()
+    set(CVF_VERSION_MAJOR "0.29.2.dev20251007+0073096d")
+  endif()
+
+  if(PACKAGE_FIND_VERSION_RANGE)
+    # both endpoints of the range must have the expected major version
+    math (EXPR CVF_VERSION_MAJOR_NEXT "${CVF_VERSION_MAJOR} + 1")
+    if (NOT PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR
+        OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR)
+          OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL CVF_VERSION_MAJOR_NEXT)))
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR
+        AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX)
+        OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX)))
+      set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    else()
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    endif()
+  else()
+    if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR)
+      set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    else()
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    endif()
+
+    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+  endif()
+endif()
+
+
+# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "")
+  return()
+endif()
+
+# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
+if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8")
+  math(EXPR installedBits "8 * 8")
+  set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
+  set(PACKAGE_VERSION_UNSUITABLE TRUE)
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..60639dfbe6bafd6e77363768a53fb51087b8a0cf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/Makefile
@@ -0,0 +1,2393 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\" \"headers\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core//CMakeFiles/progress.marks
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+#=============================================================================
+# Target rules for targets named mlx
+
+# Build rule for target.
+mlx: cmake_check_build_system
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx
+.PHONY : mlx
+
+# fast build rule for target.
+mlx/fast:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/build
+.PHONY : mlx/fast
+
+#=============================================================================
+# Target rules for targets named mlx_version
+
+# Build rule for target.
+mlx_version: cmake_check_build_system
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx_version
+.PHONY : mlx_version
+
+# fast build rule for target.
+mlx_version/fast:
+	$(MAKE) $(MAKESILENT) -f mlx/CMakeFiles/mlx_version.dir/build.make mlx/CMakeFiles/mlx_version.dir/build
+.PHONY : mlx_version/fast
+
+#=============================================================================
+# Target rules for targets named cpu_compiled_preamble
+
+# Build rule for target.
+cpu_compiled_preamble: cmake_check_build_system
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 cpu_compiled_preamble
+.PHONY : cpu_compiled_preamble
+
+# fast build rule for target.
+cpu_compiled_preamble/fast:
+	$(MAKE) $(MAKESILENT) -f mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build.make mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build
+.PHONY : cpu_compiled_preamble/fast
+
+#=============================================================================
+# Target rules for targets named gguflib
+
+# Build rule for target.
+gguflib: cmake_check_build_system
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 gguflib
+.PHONY : gguflib
+
+# fast build rule for target.
+gguflib/fast:
+	$(MAKE) $(MAKESILENT) -f mlx/io/CMakeFiles/gguflib.dir/build.make mlx/io/CMakeFiles/gguflib.dir/build
+.PHONY : gguflib/fast
+
+#=============================================================================
+# Target rules for targets named fmt
+
+# Build rule for target.
+fmt: cmake_check_build_system
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 fmt
+.PHONY : fmt
+
+# fast build rule for target.
+fmt/fast:
+	$(MAKE) $(MAKESILENT) -f _deps/fmt-build/CMakeFiles/fmt.dir/build.make _deps/fmt-build/CMakeFiles/fmt.dir/build
+.PHONY : fmt/fast
+
+#=============================================================================
+# Target rules for targets named core
+
+# Build rule for target.
+core: cmake_check_build_system
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 core
+.PHONY : core
+
+# fast build rule for target.
+core/fast:
+	$(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/build
+.PHONY : core/fast
+
+#=============================================================================
+# Target rules for targets named nanobind-static
+
+# Build rule for target.
+nanobind-static: cmake_check_build_system
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 nanobind-static
+.PHONY : nanobind-static
+
+# fast build rule for target.
+nanobind-static/fast:
+	$(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/build
+.PHONY : nanobind-static/fast
+
+mlx/allocator.o: mlx/allocator.cpp.o
+.PHONY : mlx/allocator.o
+
+# target to build an object file
+mlx/allocator.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/allocator.cpp.o
+.PHONY : mlx/allocator.cpp.o
+
+mlx/allocator.i: mlx/allocator.cpp.i
+.PHONY : mlx/allocator.i
+
+# target to preprocess a source file
+mlx/allocator.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/allocator.cpp.i
+.PHONY : mlx/allocator.cpp.i
+
+mlx/allocator.s: mlx/allocator.cpp.s
+.PHONY : mlx/allocator.s
+
+# target to generate assembly for a file
+mlx/allocator.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/allocator.cpp.s
+.PHONY : mlx/allocator.cpp.s
+
+mlx/array.o: mlx/array.cpp.o
+.PHONY : mlx/array.o
+
+# target to build an object file
+mlx/array.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/array.cpp.o
+.PHONY : mlx/array.cpp.o
+
+mlx/array.i: mlx/array.cpp.i
+.PHONY : mlx/array.i
+
+# target to preprocess a source file
+mlx/array.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/array.cpp.i
+.PHONY : mlx/array.cpp.i
+
+mlx/array.s: mlx/array.cpp.s
+.PHONY : mlx/array.s
+
+# target to generate assembly for a file
+mlx/array.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/array.cpp.s
+.PHONY : mlx/array.cpp.s
+
+mlx/backend/common/broadcasting.o: mlx/backend/common/broadcasting.cpp.o
+.PHONY : mlx/backend/common/broadcasting.o
+
+# target to build an object file
+mlx/backend/common/broadcasting.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o
+.PHONY : mlx/backend/common/broadcasting.cpp.o
+
+mlx/backend/common/broadcasting.i: mlx/backend/common/broadcasting.cpp.i
+.PHONY : mlx/backend/common/broadcasting.i
+
+# target to preprocess a source file
+mlx/backend/common/broadcasting.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.i
+.PHONY : mlx/backend/common/broadcasting.cpp.i
+
+mlx/backend/common/broadcasting.s: mlx/backend/common/broadcasting.cpp.s
+.PHONY : mlx/backend/common/broadcasting.s
+
+# target to generate assembly for a file
+mlx/backend/common/broadcasting.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.s
+.PHONY : mlx/backend/common/broadcasting.cpp.s
+
+mlx/backend/common/common.o: mlx/backend/common/common.cpp.o
+.PHONY : mlx/backend/common/common.o
+
+# target to build an object file
+mlx/backend/common/common.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o
+.PHONY : mlx/backend/common/common.cpp.o
+
+mlx/backend/common/common.i: mlx/backend/common/common.cpp.i
+.PHONY : mlx/backend/common/common.i
+
+# target to preprocess a source file
+mlx/backend/common/common.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.i
+.PHONY : mlx/backend/common/common.cpp.i
+
+mlx/backend/common/common.s: mlx/backend/common/common.cpp.s
+.PHONY : mlx/backend/common/common.s
+
+# target to generate assembly for a file
+mlx/backend/common/common.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.s
+.PHONY : mlx/backend/common/common.cpp.s
+
+mlx/backend/common/compiled.o: mlx/backend/common/compiled.cpp.o
+.PHONY : mlx/backend/common/compiled.o
+
+# target to build an object file
+mlx/backend/common/compiled.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o
+.PHONY : mlx/backend/common/compiled.cpp.o
+
+mlx/backend/common/compiled.i: mlx/backend/common/compiled.cpp.i
+.PHONY : mlx/backend/common/compiled.i
+
+# target to preprocess a source file
+mlx/backend/common/compiled.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.i
+.PHONY : mlx/backend/common/compiled.cpp.i
+
+mlx/backend/common/compiled.s: mlx/backend/common/compiled.cpp.s
+.PHONY : mlx/backend/common/compiled.s
+
+# target to generate assembly for a file
+mlx/backend/common/compiled.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.s
+.PHONY : mlx/backend/common/compiled.cpp.s
+
+mlx/backend/common/load.o: mlx/backend/common/load.cpp.o
+.PHONY : mlx/backend/common/load.o
+
+# target to build an object file
+mlx/backend/common/load.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o
+.PHONY : mlx/backend/common/load.cpp.o
+
+mlx/backend/common/load.i: mlx/backend/common/load.cpp.i
+.PHONY : mlx/backend/common/load.i
+
+# target to preprocess a source file
+mlx/backend/common/load.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.i
+.PHONY : mlx/backend/common/load.cpp.i
+
+mlx/backend/common/load.s: mlx/backend/common/load.cpp.s
+.PHONY : mlx/backend/common/load.s
+
+# target to generate assembly for a file
+mlx/backend/common/load.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.s
+.PHONY : mlx/backend/common/load.cpp.s
+
+mlx/backend/common/reduce.o: mlx/backend/common/reduce.cpp.o
+.PHONY : mlx/backend/common/reduce.o
+
+# target to build an object file
+mlx/backend/common/reduce.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o
+.PHONY : mlx/backend/common/reduce.cpp.o
+
+mlx/backend/common/reduce.i: mlx/backend/common/reduce.cpp.i
+.PHONY : mlx/backend/common/reduce.i
+
+# target to preprocess a source file
+mlx/backend/common/reduce.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.i
+.PHONY : mlx/backend/common/reduce.cpp.i
+
+mlx/backend/common/reduce.s: mlx/backend/common/reduce.cpp.s
+.PHONY : mlx/backend/common/reduce.s
+
+# target to generate assembly for a file
+mlx/backend/common/reduce.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.s
+.PHONY : mlx/backend/common/reduce.cpp.s
+
+mlx/backend/common/slicing.o: mlx/backend/common/slicing.cpp.o
+.PHONY : mlx/backend/common/slicing.o
+
+# target to build an object file
+mlx/backend/common/slicing.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o
+.PHONY : mlx/backend/common/slicing.cpp.o
+
+mlx/backend/common/slicing.i: mlx/backend/common/slicing.cpp.i
+.PHONY : mlx/backend/common/slicing.i
+
+# target to preprocess a source file
+mlx/backend/common/slicing.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.i
+.PHONY : mlx/backend/common/slicing.cpp.i
+
+mlx/backend/common/slicing.s: mlx/backend/common/slicing.cpp.s
+.PHONY : mlx/backend/common/slicing.s
+
+# target to generate assembly for a file
+mlx/backend/common/slicing.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.s
+.PHONY : mlx/backend/common/slicing.cpp.s
+
+mlx/backend/common/utils.o: mlx/backend/common/utils.cpp.o
+.PHONY : mlx/backend/common/utils.o
+
+# target to build an object file
+mlx/backend/common/utils.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o
+.PHONY : mlx/backend/common/utils.cpp.o
+
+mlx/backend/common/utils.i: mlx/backend/common/utils.cpp.i
+.PHONY : mlx/backend/common/utils.i
+
+# target to preprocess a source file
+mlx/backend/common/utils.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.i
+.PHONY : mlx/backend/common/utils.cpp.i
+
+mlx/backend/common/utils.s: mlx/backend/common/utils.cpp.s
+.PHONY : mlx/backend/common/utils.s
+
+# target to generate assembly for a file
+mlx/backend/common/utils.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.s
+.PHONY : mlx/backend/common/utils.cpp.s
+
+mlx/backend/cpu/arg_reduce.o: mlx/backend/cpu/arg_reduce.cpp.o
+.PHONY : mlx/backend/cpu/arg_reduce.o
+
+# target to build an object file
+mlx/backend/cpu/arg_reduce.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o
+.PHONY : mlx/backend/cpu/arg_reduce.cpp.o
+
+mlx/backend/cpu/arg_reduce.i: mlx/backend/cpu/arg_reduce.cpp.i
+.PHONY : mlx/backend/cpu/arg_reduce.i
+
+# target to preprocess a source file
+mlx/backend/cpu/arg_reduce.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.i
+.PHONY : mlx/backend/cpu/arg_reduce.cpp.i
+
+mlx/backend/cpu/arg_reduce.s: mlx/backend/cpu/arg_reduce.cpp.s
+.PHONY : mlx/backend/cpu/arg_reduce.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/arg_reduce.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.s
+.PHONY : mlx/backend/cpu/arg_reduce.cpp.s
+
+mlx/backend/cpu/available.o: mlx/backend/cpu/available.cpp.o
+.PHONY : mlx/backend/cpu/available.o
+
+# target to build an object file
+mlx/backend/cpu/available.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o
+.PHONY : mlx/backend/cpu/available.cpp.o
+
+mlx/backend/cpu/available.i: mlx/backend/cpu/available.cpp.i
+.PHONY : mlx/backend/cpu/available.i
+
+# target to preprocess a source file
+mlx/backend/cpu/available.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.i
+.PHONY : mlx/backend/cpu/available.cpp.i
+
+mlx/backend/cpu/available.s: mlx/backend/cpu/available.cpp.s
+.PHONY : mlx/backend/cpu/available.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/available.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.s
+.PHONY : mlx/backend/cpu/available.cpp.s
+
+mlx/backend/cpu/binary.o: mlx/backend/cpu/binary.cpp.o
+.PHONY : mlx/backend/cpu/binary.o
+
+# target to build an object file
+mlx/backend/cpu/binary.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o
+.PHONY : mlx/backend/cpu/binary.cpp.o
+
+mlx/backend/cpu/binary.i: mlx/backend/cpu/binary.cpp.i
+.PHONY : mlx/backend/cpu/binary.i
+
+# target to preprocess a source file
+mlx/backend/cpu/binary.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.i
+.PHONY : mlx/backend/cpu/binary.cpp.i
+
+mlx/backend/cpu/binary.s: mlx/backend/cpu/binary.cpp.s
+.PHONY : mlx/backend/cpu/binary.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/binary.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.s
+.PHONY : mlx/backend/cpu/binary.cpp.s
+
+mlx/backend/cpu/cholesky.o: mlx/backend/cpu/cholesky.cpp.o
+.PHONY : mlx/backend/cpu/cholesky.o
+
+# target to build an object file
+mlx/backend/cpu/cholesky.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o
+.PHONY : mlx/backend/cpu/cholesky.cpp.o
+
+mlx/backend/cpu/cholesky.i: mlx/backend/cpu/cholesky.cpp.i
+.PHONY : mlx/backend/cpu/cholesky.i
+
+# target to preprocess a source file
+mlx/backend/cpu/cholesky.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.i
+.PHONY : mlx/backend/cpu/cholesky.cpp.i
+
+mlx/backend/cpu/cholesky.s: mlx/backend/cpu/cholesky.cpp.s
+.PHONY : mlx/backend/cpu/cholesky.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/cholesky.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.s
+.PHONY : mlx/backend/cpu/cholesky.cpp.s
+
+mlx/backend/cpu/compiled.o: mlx/backend/cpu/compiled.cpp.o
+.PHONY : mlx/backend/cpu/compiled.o
+
+# target to build an object file
+mlx/backend/cpu/compiled.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o
+.PHONY : mlx/backend/cpu/compiled.cpp.o
+
+mlx/backend/cpu/compiled.i: mlx/backend/cpu/compiled.cpp.i
+.PHONY : mlx/backend/cpu/compiled.i
+
+# target to preprocess a source file
+mlx/backend/cpu/compiled.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.i
+.PHONY : mlx/backend/cpu/compiled.cpp.i
+
+mlx/backend/cpu/compiled.s: mlx/backend/cpu/compiled.cpp.s
+.PHONY : mlx/backend/cpu/compiled.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/compiled.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.s
+.PHONY : mlx/backend/cpu/compiled.cpp.s
+
+mlx/backend/cpu/compiled_preamble.o: mlx/backend/cpu/compiled_preamble.cpp.o
+.PHONY : mlx/backend/cpu/compiled_preamble.o
+
+# target to build an object file
+mlx/backend/cpu/compiled_preamble.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o
+.PHONY : mlx/backend/cpu/compiled_preamble.cpp.o
+
+mlx/backend/cpu/compiled_preamble.i: mlx/backend/cpu/compiled_preamble.cpp.i
+.PHONY : mlx/backend/cpu/compiled_preamble.i
+
+# target to preprocess a source file
+mlx/backend/cpu/compiled_preamble.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.i
+.PHONY : mlx/backend/cpu/compiled_preamble.cpp.i
+
+mlx/backend/cpu/compiled_preamble.s: mlx/backend/cpu/compiled_preamble.cpp.s
+.PHONY : mlx/backend/cpu/compiled_preamble.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/compiled_preamble.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.s
+.PHONY : mlx/backend/cpu/compiled_preamble.cpp.s
+
+mlx/backend/cpu/conv.o: mlx/backend/cpu/conv.cpp.o
+.PHONY : mlx/backend/cpu/conv.o
+
+# target to build an object file
+mlx/backend/cpu/conv.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o
+.PHONY : mlx/backend/cpu/conv.cpp.o
+
+mlx/backend/cpu/conv.i: mlx/backend/cpu/conv.cpp.i
+.PHONY : mlx/backend/cpu/conv.i
+
+# target to preprocess a source file
+mlx/backend/cpu/conv.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.i
+.PHONY : mlx/backend/cpu/conv.cpp.i
+
+mlx/backend/cpu/conv.s: mlx/backend/cpu/conv.cpp.s
+.PHONY : mlx/backend/cpu/conv.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/conv.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.s
+.PHONY : mlx/backend/cpu/conv.cpp.s
+
+mlx/backend/cpu/copy.o: mlx/backend/cpu/copy.cpp.o
+.PHONY : mlx/backend/cpu/copy.o
+
+# target to build an object file
+mlx/backend/cpu/copy.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o
+.PHONY : mlx/backend/cpu/copy.cpp.o
+
+mlx/backend/cpu/copy.i: mlx/backend/cpu/copy.cpp.i
+.PHONY : mlx/backend/cpu/copy.i
+
+# target to preprocess a source file
+mlx/backend/cpu/copy.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.i
+.PHONY : mlx/backend/cpu/copy.cpp.i
+
+mlx/backend/cpu/copy.s: mlx/backend/cpu/copy.cpp.s
+.PHONY : mlx/backend/cpu/copy.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/copy.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.s
+.PHONY : mlx/backend/cpu/copy.cpp.s
+
+mlx/backend/cpu/distributed.o: mlx/backend/cpu/distributed.cpp.o
+.PHONY : mlx/backend/cpu/distributed.o
+
+# target to build an object file
+mlx/backend/cpu/distributed.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o
+.PHONY : mlx/backend/cpu/distributed.cpp.o
+
+mlx/backend/cpu/distributed.i: mlx/backend/cpu/distributed.cpp.i
+.PHONY : mlx/backend/cpu/distributed.i
+
+# target to preprocess a source file
+mlx/backend/cpu/distributed.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.i
+.PHONY : mlx/backend/cpu/distributed.cpp.i
+
+mlx/backend/cpu/distributed.s: mlx/backend/cpu/distributed.cpp.s
+.PHONY : mlx/backend/cpu/distributed.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/distributed.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.s
+.PHONY : mlx/backend/cpu/distributed.cpp.s
+
+mlx/backend/cpu/eig.o: mlx/backend/cpu/eig.cpp.o
+.PHONY : mlx/backend/cpu/eig.o
+
+# target to build an object file
+mlx/backend/cpu/eig.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o
+.PHONY : mlx/backend/cpu/eig.cpp.o
+
+mlx/backend/cpu/eig.i: mlx/backend/cpu/eig.cpp.i
+.PHONY : mlx/backend/cpu/eig.i
+
+# target to preprocess a source file
+mlx/backend/cpu/eig.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.i
+.PHONY : mlx/backend/cpu/eig.cpp.i
+
+mlx/backend/cpu/eig.s: mlx/backend/cpu/eig.cpp.s
+.PHONY : mlx/backend/cpu/eig.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/eig.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.s
+.PHONY : mlx/backend/cpu/eig.cpp.s
+
+mlx/backend/cpu/eigh.o: mlx/backend/cpu/eigh.cpp.o
+.PHONY : mlx/backend/cpu/eigh.o
+
+# target to build an object file
+mlx/backend/cpu/eigh.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o
+.PHONY : mlx/backend/cpu/eigh.cpp.o
+
+mlx/backend/cpu/eigh.i: mlx/backend/cpu/eigh.cpp.i
+.PHONY : mlx/backend/cpu/eigh.i
+
+# target to preprocess a source file
+mlx/backend/cpu/eigh.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.i
+.PHONY : mlx/backend/cpu/eigh.cpp.i
+
+mlx/backend/cpu/eigh.s: mlx/backend/cpu/eigh.cpp.s
+.PHONY : mlx/backend/cpu/eigh.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/eigh.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.s
+.PHONY : mlx/backend/cpu/eigh.cpp.s
+
+mlx/backend/cpu/encoder.o: mlx/backend/cpu/encoder.cpp.o
+.PHONY : mlx/backend/cpu/encoder.o
+
+# target to build an object file
+mlx/backend/cpu/encoder.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o
+.PHONY : mlx/backend/cpu/encoder.cpp.o
+
+mlx/backend/cpu/encoder.i: mlx/backend/cpu/encoder.cpp.i
+.PHONY : mlx/backend/cpu/encoder.i
+
+# target to preprocess a source file
+mlx/backend/cpu/encoder.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.i
+.PHONY : mlx/backend/cpu/encoder.cpp.i
+
+mlx/backend/cpu/encoder.s: mlx/backend/cpu/encoder.cpp.s
+.PHONY : mlx/backend/cpu/encoder.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/encoder.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.s
+.PHONY : mlx/backend/cpu/encoder.cpp.s
+
+mlx/backend/cpu/eval.o: mlx/backend/cpu/eval.cpp.o
+.PHONY : mlx/backend/cpu/eval.o
+
+# target to build an object file
+mlx/backend/cpu/eval.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o
+.PHONY : mlx/backend/cpu/eval.cpp.o
+
+mlx/backend/cpu/eval.i: mlx/backend/cpu/eval.cpp.i
+.PHONY : mlx/backend/cpu/eval.i
+
+# target to preprocess a source file
+mlx/backend/cpu/eval.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.i
+.PHONY : mlx/backend/cpu/eval.cpp.i
+
+mlx/backend/cpu/eval.s: mlx/backend/cpu/eval.cpp.s
+.PHONY : mlx/backend/cpu/eval.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/eval.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.s
+.PHONY : mlx/backend/cpu/eval.cpp.s
+
+mlx/backend/cpu/fft.o: mlx/backend/cpu/fft.cpp.o
+.PHONY : mlx/backend/cpu/fft.o
+
+# target to build an object file
+mlx/backend/cpu/fft.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o
+.PHONY : mlx/backend/cpu/fft.cpp.o
+
+mlx/backend/cpu/fft.i: mlx/backend/cpu/fft.cpp.i
+.PHONY : mlx/backend/cpu/fft.i
+
+# target to preprocess a source file
+mlx/backend/cpu/fft.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.i
+.PHONY : mlx/backend/cpu/fft.cpp.i
+
+mlx/backend/cpu/fft.s: mlx/backend/cpu/fft.cpp.s
+.PHONY : mlx/backend/cpu/fft.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/fft.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.s
+.PHONY : mlx/backend/cpu/fft.cpp.s
+
+mlx/backend/cpu/gemms/cblas.o: mlx/backend/cpu/gemms/cblas.cpp.o
+.PHONY : mlx/backend/cpu/gemms/cblas.o
+
+# target to build an object file
+mlx/backend/cpu/gemms/cblas.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o
+.PHONY : mlx/backend/cpu/gemms/cblas.cpp.o
+
+mlx/backend/cpu/gemms/cblas.i: mlx/backend/cpu/gemms/cblas.cpp.i
+.PHONY : mlx/backend/cpu/gemms/cblas.i
+
+# target to preprocess a source file
+mlx/backend/cpu/gemms/cblas.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.i
+.PHONY : mlx/backend/cpu/gemms/cblas.cpp.i
+
+mlx/backend/cpu/gemms/cblas.s: mlx/backend/cpu/gemms/cblas.cpp.s
+.PHONY : mlx/backend/cpu/gemms/cblas.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/gemms/cblas.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.s
+.PHONY : mlx/backend/cpu/gemms/cblas.cpp.s
+
+mlx/backend/cpu/gemms/simd_bf16.o: mlx/backend/cpu/gemms/simd_bf16.cpp.o
+.PHONY : mlx/backend/cpu/gemms/simd_bf16.o
+
+# target to build an object file
+mlx/backend/cpu/gemms/simd_bf16.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o
+.PHONY : mlx/backend/cpu/gemms/simd_bf16.cpp.o
+
+mlx/backend/cpu/gemms/simd_bf16.i: mlx/backend/cpu/gemms/simd_bf16.cpp.i
+.PHONY : mlx/backend/cpu/gemms/simd_bf16.i
+
+# target to preprocess a source file
+mlx/backend/cpu/gemms/simd_bf16.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.i
+.PHONY : mlx/backend/cpu/gemms/simd_bf16.cpp.i
+
+mlx/backend/cpu/gemms/simd_bf16.s: mlx/backend/cpu/gemms/simd_bf16.cpp.s
+.PHONY : mlx/backend/cpu/gemms/simd_bf16.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/gemms/simd_bf16.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.s
+.PHONY : mlx/backend/cpu/gemms/simd_bf16.cpp.s
+
+mlx/backend/cpu/gemms/simd_fp16.o: mlx/backend/cpu/gemms/simd_fp16.cpp.o
+.PHONY : mlx/backend/cpu/gemms/simd_fp16.o
+
+# target to build an object file
+mlx/backend/cpu/gemms/simd_fp16.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o
+.PHONY : mlx/backend/cpu/gemms/simd_fp16.cpp.o
+
+mlx/backend/cpu/gemms/simd_fp16.i: mlx/backend/cpu/gemms/simd_fp16.cpp.i
+.PHONY : mlx/backend/cpu/gemms/simd_fp16.i
+
+# target to preprocess a source file
+mlx/backend/cpu/gemms/simd_fp16.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.i
+.PHONY : mlx/backend/cpu/gemms/simd_fp16.cpp.i
+
+mlx/backend/cpu/gemms/simd_fp16.s: mlx/backend/cpu/gemms/simd_fp16.cpp.s
+.PHONY : mlx/backend/cpu/gemms/simd_fp16.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/gemms/simd_fp16.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.s
+.PHONY : mlx/backend/cpu/gemms/simd_fp16.cpp.s
+
+mlx/backend/cpu/hadamard.o: mlx/backend/cpu/hadamard.cpp.o
+.PHONY : mlx/backend/cpu/hadamard.o
+
+# target to build an object file
+mlx/backend/cpu/hadamard.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o
+.PHONY : mlx/backend/cpu/hadamard.cpp.o
+
+mlx/backend/cpu/hadamard.i: mlx/backend/cpu/hadamard.cpp.i
+.PHONY : mlx/backend/cpu/hadamard.i
+
+# target to preprocess a source file
+mlx/backend/cpu/hadamard.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.i
+.PHONY : mlx/backend/cpu/hadamard.cpp.i
+
+mlx/backend/cpu/hadamard.s: mlx/backend/cpu/hadamard.cpp.s
+.PHONY : mlx/backend/cpu/hadamard.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/hadamard.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.s
+.PHONY : mlx/backend/cpu/hadamard.cpp.s
+
+mlx/backend/cpu/indexing.o: mlx/backend/cpu/indexing.cpp.o
+.PHONY : mlx/backend/cpu/indexing.o
+
+# target to build an object file
+mlx/backend/cpu/indexing.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o
+.PHONY : mlx/backend/cpu/indexing.cpp.o
+
+mlx/backend/cpu/indexing.i: mlx/backend/cpu/indexing.cpp.i
+.PHONY : mlx/backend/cpu/indexing.i
+
+# target to preprocess a source file
+mlx/backend/cpu/indexing.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.i
+.PHONY : mlx/backend/cpu/indexing.cpp.i
+
+mlx/backend/cpu/indexing.s: mlx/backend/cpu/indexing.cpp.s
+.PHONY : mlx/backend/cpu/indexing.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/indexing.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.s
+.PHONY : mlx/backend/cpu/indexing.cpp.s
+
+mlx/backend/cpu/inverse.o: mlx/backend/cpu/inverse.cpp.o
+.PHONY : mlx/backend/cpu/inverse.o
+
+# target to build an object file
+mlx/backend/cpu/inverse.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o
+.PHONY : mlx/backend/cpu/inverse.cpp.o
+
+mlx/backend/cpu/inverse.i: mlx/backend/cpu/inverse.cpp.i
+.PHONY : mlx/backend/cpu/inverse.i
+
+# target to preprocess a source file
+mlx/backend/cpu/inverse.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.i
+.PHONY : mlx/backend/cpu/inverse.cpp.i
+
+mlx/backend/cpu/inverse.s: mlx/backend/cpu/inverse.cpp.s
+.PHONY : mlx/backend/cpu/inverse.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/inverse.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.s
+.PHONY : mlx/backend/cpu/inverse.cpp.s
+
+mlx/backend/cpu/jit_compiler.o: mlx/backend/cpu/jit_compiler.cpp.o
+.PHONY : mlx/backend/cpu/jit_compiler.o
+
+# target to build an object file
+mlx/backend/cpu/jit_compiler.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o
+.PHONY : mlx/backend/cpu/jit_compiler.cpp.o
+
+mlx/backend/cpu/jit_compiler.i: mlx/backend/cpu/jit_compiler.cpp.i
+.PHONY : mlx/backend/cpu/jit_compiler.i
+
+# target to preprocess a source file
+mlx/backend/cpu/jit_compiler.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.i
+.PHONY : mlx/backend/cpu/jit_compiler.cpp.i
+
+mlx/backend/cpu/jit_compiler.s: mlx/backend/cpu/jit_compiler.cpp.s
+.PHONY : mlx/backend/cpu/jit_compiler.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/jit_compiler.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.s
+.PHONY : mlx/backend/cpu/jit_compiler.cpp.s
+
+mlx/backend/cpu/logsumexp.o: mlx/backend/cpu/logsumexp.cpp.o
+.PHONY : mlx/backend/cpu/logsumexp.o
+
+# target to build an object file
+mlx/backend/cpu/logsumexp.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o
+.PHONY : mlx/backend/cpu/logsumexp.cpp.o
+
+mlx/backend/cpu/logsumexp.i: mlx/backend/cpu/logsumexp.cpp.i
+.PHONY : mlx/backend/cpu/logsumexp.i
+
+# target to preprocess a source file
+mlx/backend/cpu/logsumexp.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.i
+.PHONY : mlx/backend/cpu/logsumexp.cpp.i
+
+mlx/backend/cpu/logsumexp.s: mlx/backend/cpu/logsumexp.cpp.s
+.PHONY : mlx/backend/cpu/logsumexp.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/logsumexp.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.s
+.PHONY : mlx/backend/cpu/logsumexp.cpp.s
+
+mlx/backend/cpu/luf.o: mlx/backend/cpu/luf.cpp.o
+.PHONY : mlx/backend/cpu/luf.o
+
+# target to build an object file
+mlx/backend/cpu/luf.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o
+.PHONY : mlx/backend/cpu/luf.cpp.o
+
+mlx/backend/cpu/luf.i: mlx/backend/cpu/luf.cpp.i
+.PHONY : mlx/backend/cpu/luf.i
+
+# target to preprocess a source file
+mlx/backend/cpu/luf.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.i
+.PHONY : mlx/backend/cpu/luf.cpp.i
+
+mlx/backend/cpu/luf.s: mlx/backend/cpu/luf.cpp.s
+.PHONY : mlx/backend/cpu/luf.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/luf.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.s
+.PHONY : mlx/backend/cpu/luf.cpp.s
+
+mlx/backend/cpu/masked_mm.o: mlx/backend/cpu/masked_mm.cpp.o
+.PHONY : mlx/backend/cpu/masked_mm.o
+
+# target to build an object file
+mlx/backend/cpu/masked_mm.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o
+.PHONY : mlx/backend/cpu/masked_mm.cpp.o
+
+mlx/backend/cpu/masked_mm.i: mlx/backend/cpu/masked_mm.cpp.i
+.PHONY : mlx/backend/cpu/masked_mm.i
+
+# target to preprocess a source file
+mlx/backend/cpu/masked_mm.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.i
+.PHONY : mlx/backend/cpu/masked_mm.cpp.i
+
+mlx/backend/cpu/masked_mm.s: mlx/backend/cpu/masked_mm.cpp.s
+.PHONY : mlx/backend/cpu/masked_mm.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/masked_mm.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.s
+.PHONY : mlx/backend/cpu/masked_mm.cpp.s
+
+mlx/backend/cpu/matmul.o: mlx/backend/cpu/matmul.cpp.o
+.PHONY : mlx/backend/cpu/matmul.o
+
+# target to build an object file
+mlx/backend/cpu/matmul.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o
+.PHONY : mlx/backend/cpu/matmul.cpp.o
+
+mlx/backend/cpu/matmul.i: mlx/backend/cpu/matmul.cpp.i
+.PHONY : mlx/backend/cpu/matmul.i
+
+# target to preprocess a source file
+mlx/backend/cpu/matmul.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.i
+.PHONY : mlx/backend/cpu/matmul.cpp.i
+
+mlx/backend/cpu/matmul.s: mlx/backend/cpu/matmul.cpp.s
+.PHONY : mlx/backend/cpu/matmul.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/matmul.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.s
+.PHONY : mlx/backend/cpu/matmul.cpp.s
+
+mlx/backend/cpu/primitives.o: mlx/backend/cpu/primitives.cpp.o
+.PHONY : mlx/backend/cpu/primitives.o
+
+# target to build an object file
+mlx/backend/cpu/primitives.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o
+.PHONY : mlx/backend/cpu/primitives.cpp.o
+
+mlx/backend/cpu/primitives.i: mlx/backend/cpu/primitives.cpp.i
+.PHONY : mlx/backend/cpu/primitives.i
+
+# target to preprocess a source file
+mlx/backend/cpu/primitives.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.i
+.PHONY : mlx/backend/cpu/primitives.cpp.i
+
+mlx/backend/cpu/primitives.s: mlx/backend/cpu/primitives.cpp.s
+.PHONY : mlx/backend/cpu/primitives.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/primitives.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.s
+.PHONY : mlx/backend/cpu/primitives.cpp.s
+
+mlx/backend/cpu/qrf.o: mlx/backend/cpu/qrf.cpp.o
+.PHONY : mlx/backend/cpu/qrf.o
+
+# target to build an object file
+mlx/backend/cpu/qrf.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o
+.PHONY : mlx/backend/cpu/qrf.cpp.o
+
+mlx/backend/cpu/qrf.i: mlx/backend/cpu/qrf.cpp.i
+.PHONY : mlx/backend/cpu/qrf.i
+
+# target to preprocess a source file
+mlx/backend/cpu/qrf.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.i
+.PHONY : mlx/backend/cpu/qrf.cpp.i
+
+mlx/backend/cpu/qrf.s: mlx/backend/cpu/qrf.cpp.s
+.PHONY : mlx/backend/cpu/qrf.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/qrf.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.s
+.PHONY : mlx/backend/cpu/qrf.cpp.s
+
+mlx/backend/cpu/quantized.o: mlx/backend/cpu/quantized.cpp.o
+.PHONY : mlx/backend/cpu/quantized.o
+
+# target to build an object file
+mlx/backend/cpu/quantized.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o
+.PHONY : mlx/backend/cpu/quantized.cpp.o
+
+mlx/backend/cpu/quantized.i: mlx/backend/cpu/quantized.cpp.i
+.PHONY : mlx/backend/cpu/quantized.i
+
+# target to preprocess a source file
+mlx/backend/cpu/quantized.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.i
+.PHONY : mlx/backend/cpu/quantized.cpp.i
+
+mlx/backend/cpu/quantized.s: mlx/backend/cpu/quantized.cpp.s
+.PHONY : mlx/backend/cpu/quantized.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/quantized.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.s
+.PHONY : mlx/backend/cpu/quantized.cpp.s
+
+mlx/backend/cpu/reduce.o: mlx/backend/cpu/reduce.cpp.o
+.PHONY : mlx/backend/cpu/reduce.o
+
+# target to build an object file
+mlx/backend/cpu/reduce.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o
+.PHONY : mlx/backend/cpu/reduce.cpp.o
+
+mlx/backend/cpu/reduce.i: mlx/backend/cpu/reduce.cpp.i
+.PHONY : mlx/backend/cpu/reduce.i
+
+# target to preprocess a source file
+mlx/backend/cpu/reduce.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.i
+.PHONY : mlx/backend/cpu/reduce.cpp.i
+
+mlx/backend/cpu/reduce.s: mlx/backend/cpu/reduce.cpp.s
+.PHONY : mlx/backend/cpu/reduce.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/reduce.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.s
+.PHONY : mlx/backend/cpu/reduce.cpp.s
+
+mlx/backend/cpu/scan.o: mlx/backend/cpu/scan.cpp.o
+.PHONY : mlx/backend/cpu/scan.o
+
+# target to build an object file
+mlx/backend/cpu/scan.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o
+.PHONY : mlx/backend/cpu/scan.cpp.o
+
+mlx/backend/cpu/scan.i: mlx/backend/cpu/scan.cpp.i
+.PHONY : mlx/backend/cpu/scan.i
+
+# target to preprocess a source file
+mlx/backend/cpu/scan.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.i
+.PHONY : mlx/backend/cpu/scan.cpp.i
+
+mlx/backend/cpu/scan.s: mlx/backend/cpu/scan.cpp.s
+.PHONY : mlx/backend/cpu/scan.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/scan.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.s
+.PHONY : mlx/backend/cpu/scan.cpp.s
+
+mlx/backend/cpu/select.o: mlx/backend/cpu/select.cpp.o
+.PHONY : mlx/backend/cpu/select.o
+
+# target to build an object file
+mlx/backend/cpu/select.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o
+.PHONY : mlx/backend/cpu/select.cpp.o
+
+mlx/backend/cpu/select.i: mlx/backend/cpu/select.cpp.i
+.PHONY : mlx/backend/cpu/select.i
+
+# target to preprocess a source file
+mlx/backend/cpu/select.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.i
+.PHONY : mlx/backend/cpu/select.cpp.i
+
+mlx/backend/cpu/select.s: mlx/backend/cpu/select.cpp.s
+.PHONY : mlx/backend/cpu/select.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/select.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.s
+.PHONY : mlx/backend/cpu/select.cpp.s
+
+mlx/backend/cpu/softmax.o: mlx/backend/cpu/softmax.cpp.o
+.PHONY : mlx/backend/cpu/softmax.o
+
+# target to build an object file
+mlx/backend/cpu/softmax.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o
+.PHONY : mlx/backend/cpu/softmax.cpp.o
+
+mlx/backend/cpu/softmax.i: mlx/backend/cpu/softmax.cpp.i
+.PHONY : mlx/backend/cpu/softmax.i
+
+# target to preprocess a source file
+mlx/backend/cpu/softmax.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.i
+.PHONY : mlx/backend/cpu/softmax.cpp.i
+
+mlx/backend/cpu/softmax.s: mlx/backend/cpu/softmax.cpp.s
+.PHONY : mlx/backend/cpu/softmax.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/softmax.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.s
+.PHONY : mlx/backend/cpu/softmax.cpp.s
+
+mlx/backend/cpu/sort.o: mlx/backend/cpu/sort.cpp.o
+.PHONY : mlx/backend/cpu/sort.o
+
+# target to build an object file
+mlx/backend/cpu/sort.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o
+.PHONY : mlx/backend/cpu/sort.cpp.o
+
+mlx/backend/cpu/sort.i: mlx/backend/cpu/sort.cpp.i
+.PHONY : mlx/backend/cpu/sort.i
+
+# target to preprocess a source file
+mlx/backend/cpu/sort.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.i
+.PHONY : mlx/backend/cpu/sort.cpp.i
+
+mlx/backend/cpu/sort.s: mlx/backend/cpu/sort.cpp.s
+.PHONY : mlx/backend/cpu/sort.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/sort.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.s
+.PHONY : mlx/backend/cpu/sort.cpp.s
+
+mlx/backend/cpu/svd.o: mlx/backend/cpu/svd.cpp.o
+.PHONY : mlx/backend/cpu/svd.o
+
+# target to build an object file
+mlx/backend/cpu/svd.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o
+.PHONY : mlx/backend/cpu/svd.cpp.o
+
+mlx/backend/cpu/svd.i: mlx/backend/cpu/svd.cpp.i
+.PHONY : mlx/backend/cpu/svd.i
+
+# target to preprocess a source file
+mlx/backend/cpu/svd.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.i
+.PHONY : mlx/backend/cpu/svd.cpp.i
+
+mlx/backend/cpu/svd.s: mlx/backend/cpu/svd.cpp.s
+.PHONY : mlx/backend/cpu/svd.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/svd.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.s
+.PHONY : mlx/backend/cpu/svd.cpp.s
+
+mlx/backend/cpu/threefry.o: mlx/backend/cpu/threefry.cpp.o
+.PHONY : mlx/backend/cpu/threefry.o
+
+# target to build an object file
+mlx/backend/cpu/threefry.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o
+.PHONY : mlx/backend/cpu/threefry.cpp.o
+
+mlx/backend/cpu/threefry.i: mlx/backend/cpu/threefry.cpp.i
+.PHONY : mlx/backend/cpu/threefry.i
+
+# target to preprocess a source file
+mlx/backend/cpu/threefry.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.i
+.PHONY : mlx/backend/cpu/threefry.cpp.i
+
+mlx/backend/cpu/threefry.s: mlx/backend/cpu/threefry.cpp.s
+.PHONY : mlx/backend/cpu/threefry.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/threefry.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.s
+.PHONY : mlx/backend/cpu/threefry.cpp.s
+
+mlx/backend/cpu/unary.o: mlx/backend/cpu/unary.cpp.o
+.PHONY : mlx/backend/cpu/unary.o
+
+# target to build an object file
+mlx/backend/cpu/unary.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o
+.PHONY : mlx/backend/cpu/unary.cpp.o
+
+mlx/backend/cpu/unary.i: mlx/backend/cpu/unary.cpp.i
+.PHONY : mlx/backend/cpu/unary.i
+
+# target to preprocess a source file
+mlx/backend/cpu/unary.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.i
+.PHONY : mlx/backend/cpu/unary.cpp.i
+
+mlx/backend/cpu/unary.s: mlx/backend/cpu/unary.cpp.s
+.PHONY : mlx/backend/cpu/unary.s
+
+# target to generate assembly for a file
+mlx/backend/cpu/unary.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.s
+.PHONY : mlx/backend/cpu/unary.cpp.s
+
+mlx/backend/cuda/no_cuda.o: mlx/backend/cuda/no_cuda.cpp.o
+.PHONY : mlx/backend/cuda/no_cuda.o
+
+# target to build an object file
+mlx/backend/cuda/no_cuda.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o
+.PHONY : mlx/backend/cuda/no_cuda.cpp.o
+
+mlx/backend/cuda/no_cuda.i: mlx/backend/cuda/no_cuda.cpp.i
+.PHONY : mlx/backend/cuda/no_cuda.i
+
+# target to preprocess a source file
+mlx/backend/cuda/no_cuda.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.i
+.PHONY : mlx/backend/cuda/no_cuda.cpp.i
+
+mlx/backend/cuda/no_cuda.s: mlx/backend/cuda/no_cuda.cpp.s
+.PHONY : mlx/backend/cuda/no_cuda.s
+
+# target to generate assembly for a file
+mlx/backend/cuda/no_cuda.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.s
+.PHONY : mlx/backend/cuda/no_cuda.cpp.s
+
+mlx/backend/metal/no_metal.o: mlx/backend/metal/no_metal.cpp.o
+.PHONY : mlx/backend/metal/no_metal.o
+
+# target to build an object file
+mlx/backend/metal/no_metal.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o
+.PHONY : mlx/backend/metal/no_metal.cpp.o
+
+mlx/backend/metal/no_metal.i: mlx/backend/metal/no_metal.cpp.i
+.PHONY : mlx/backend/metal/no_metal.i
+
+# target to preprocess a source file
+mlx/backend/metal/no_metal.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.i
+.PHONY : mlx/backend/metal/no_metal.cpp.i
+
+mlx/backend/metal/no_metal.s: mlx/backend/metal/no_metal.cpp.s
+.PHONY : mlx/backend/metal/no_metal.s
+
+# target to generate assembly for a file
+mlx/backend/metal/no_metal.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.s
+.PHONY : mlx/backend/metal/no_metal.cpp.s
+
+mlx/backend/no_gpu/allocator.o: mlx/backend/no_gpu/allocator.cpp.o
+.PHONY : mlx/backend/no_gpu/allocator.o
+
+# target to build an object file
+mlx/backend/no_gpu/allocator.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o
+.PHONY : mlx/backend/no_gpu/allocator.cpp.o
+
+mlx/backend/no_gpu/allocator.i: mlx/backend/no_gpu/allocator.cpp.i
+.PHONY : mlx/backend/no_gpu/allocator.i
+
+# target to preprocess a source file
+mlx/backend/no_gpu/allocator.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.i
+.PHONY : mlx/backend/no_gpu/allocator.cpp.i
+
+mlx/backend/no_gpu/allocator.s: mlx/backend/no_gpu/allocator.cpp.s
+.PHONY : mlx/backend/no_gpu/allocator.s
+
+# target to generate assembly for a file
+mlx/backend/no_gpu/allocator.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.s
+.PHONY : mlx/backend/no_gpu/allocator.cpp.s
+
+mlx/backend/no_gpu/eval.o: mlx/backend/no_gpu/eval.cpp.o
+.PHONY : mlx/backend/no_gpu/eval.o
+
+# target to build an object file
+mlx/backend/no_gpu/eval.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o
+.PHONY : mlx/backend/no_gpu/eval.cpp.o
+
+mlx/backend/no_gpu/eval.i: mlx/backend/no_gpu/eval.cpp.i
+.PHONY : mlx/backend/no_gpu/eval.i
+
+# target to preprocess a source file
+mlx/backend/no_gpu/eval.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.i
+.PHONY : mlx/backend/no_gpu/eval.cpp.i
+
+mlx/backend/no_gpu/eval.s: mlx/backend/no_gpu/eval.cpp.s
+.PHONY : mlx/backend/no_gpu/eval.s
+
+# target to generate assembly for a file
+mlx/backend/no_gpu/eval.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.s
+.PHONY : mlx/backend/no_gpu/eval.cpp.s
+
+mlx/backend/no_gpu/event.o: mlx/backend/no_gpu/event.cpp.o
+.PHONY : mlx/backend/no_gpu/event.o
+
+# target to build an object file
+mlx/backend/no_gpu/event.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o
+.PHONY : mlx/backend/no_gpu/event.cpp.o
+
+mlx/backend/no_gpu/event.i: mlx/backend/no_gpu/event.cpp.i
+.PHONY : mlx/backend/no_gpu/event.i
+
+# target to preprocess a source file
+mlx/backend/no_gpu/event.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.i
+.PHONY : mlx/backend/no_gpu/event.cpp.i
+
+mlx/backend/no_gpu/event.s: mlx/backend/no_gpu/event.cpp.s
+.PHONY : mlx/backend/no_gpu/event.s
+
+# target to generate assembly for a file
+mlx/backend/no_gpu/event.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.s
+.PHONY : mlx/backend/no_gpu/event.cpp.s
+
+mlx/backend/no_gpu/fence.o: mlx/backend/no_gpu/fence.cpp.o
+.PHONY : mlx/backend/no_gpu/fence.o
+
+# target to build an object file
+mlx/backend/no_gpu/fence.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o
+.PHONY : mlx/backend/no_gpu/fence.cpp.o
+
+mlx/backend/no_gpu/fence.i: mlx/backend/no_gpu/fence.cpp.i
+.PHONY : mlx/backend/no_gpu/fence.i
+
+# target to preprocess a source file
+mlx/backend/no_gpu/fence.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.i
+.PHONY : mlx/backend/no_gpu/fence.cpp.i
+
+mlx/backend/no_gpu/fence.s: mlx/backend/no_gpu/fence.cpp.s
+.PHONY : mlx/backend/no_gpu/fence.s
+
+# target to generate assembly for a file
+mlx/backend/no_gpu/fence.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.s
+.PHONY : mlx/backend/no_gpu/fence.cpp.s
+
+mlx/backend/no_gpu/primitives.o: mlx/backend/no_gpu/primitives.cpp.o
+.PHONY : mlx/backend/no_gpu/primitives.o
+
+# target to build an object file
+mlx/backend/no_gpu/primitives.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o
+.PHONY : mlx/backend/no_gpu/primitives.cpp.o
+
+mlx/backend/no_gpu/primitives.i: mlx/backend/no_gpu/primitives.cpp.i
+.PHONY : mlx/backend/no_gpu/primitives.i
+
+# target to preprocess a source file
+mlx/backend/no_gpu/primitives.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.i
+.PHONY : mlx/backend/no_gpu/primitives.cpp.i
+
+mlx/backend/no_gpu/primitives.s: mlx/backend/no_gpu/primitives.cpp.s
+.PHONY : mlx/backend/no_gpu/primitives.s
+
+# target to generate assembly for a file
+mlx/backend/no_gpu/primitives.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.s
+.PHONY : mlx/backend/no_gpu/primitives.cpp.s
+
+mlx/compile.o: mlx/compile.cpp.o
+.PHONY : mlx/compile.o
+
+# target to build an object file
+mlx/compile.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/compile.cpp.o
+.PHONY : mlx/compile.cpp.o
+
+mlx/compile.i: mlx/compile.cpp.i
+.PHONY : mlx/compile.i
+
+# target to preprocess a source file
+mlx/compile.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/compile.cpp.i
+.PHONY : mlx/compile.cpp.i
+
+mlx/compile.s: mlx/compile.cpp.s
+.PHONY : mlx/compile.s
+
+# target to generate assembly for a file
+mlx/compile.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/compile.cpp.s
+.PHONY : mlx/compile.cpp.s
+
+mlx/device.o: mlx/device.cpp.o
+.PHONY : mlx/device.o
+
+# target to build an object file
+mlx/device.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/device.cpp.o
+.PHONY : mlx/device.cpp.o
+
+mlx/device.i: mlx/device.cpp.i
+.PHONY : mlx/device.i
+
+# target to preprocess a source file
+mlx/device.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/device.cpp.i
+.PHONY : mlx/device.cpp.i
+
+mlx/device.s: mlx/device.cpp.s
+.PHONY : mlx/device.s
+
+# target to generate assembly for a file
+mlx/device.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/device.cpp.s
+.PHONY : mlx/device.cpp.s
+
+mlx/distributed/distributed.o: mlx/distributed/distributed.cpp.o
+.PHONY : mlx/distributed/distributed.o
+
+# target to build an object file
+mlx/distributed/distributed.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o
+.PHONY : mlx/distributed/distributed.cpp.o
+
+mlx/distributed/distributed.i: mlx/distributed/distributed.cpp.i
+.PHONY : mlx/distributed/distributed.i
+
+# target to preprocess a source file
+mlx/distributed/distributed.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.i
+.PHONY : mlx/distributed/distributed.cpp.i
+
+mlx/distributed/distributed.s: mlx/distributed/distributed.cpp.s
+.PHONY : mlx/distributed/distributed.s
+
+# target to generate assembly for a file
+mlx/distributed/distributed.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.s
+.PHONY : mlx/distributed/distributed.cpp.s
+
+mlx/distributed/mpi/mpi.o: mlx/distributed/mpi/mpi.cpp.o
+.PHONY : mlx/distributed/mpi/mpi.o
+
+# target to build an object file
+mlx/distributed/mpi/mpi.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o
+.PHONY : mlx/distributed/mpi/mpi.cpp.o
+
+mlx/distributed/mpi/mpi.i: mlx/distributed/mpi/mpi.cpp.i
+.PHONY : mlx/distributed/mpi/mpi.i
+
+# target to preprocess a source file
+mlx/distributed/mpi/mpi.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.i
+.PHONY : mlx/distributed/mpi/mpi.cpp.i
+
+mlx/distributed/mpi/mpi.s: mlx/distributed/mpi/mpi.cpp.s
+.PHONY : mlx/distributed/mpi/mpi.s
+
+# target to generate assembly for a file
+mlx/distributed/mpi/mpi.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.s
+.PHONY : mlx/distributed/mpi/mpi.cpp.s
+
+mlx/distributed/nccl/no_nccl.o: mlx/distributed/nccl/no_nccl.cpp.o
+.PHONY : mlx/distributed/nccl/no_nccl.o
+
+# target to build an object file
+mlx/distributed/nccl/no_nccl.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o
+.PHONY : mlx/distributed/nccl/no_nccl.cpp.o
+
+mlx/distributed/nccl/no_nccl.i: mlx/distributed/nccl/no_nccl.cpp.i
+.PHONY : mlx/distributed/nccl/no_nccl.i
+
+# target to preprocess a source file
+mlx/distributed/nccl/no_nccl.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.i
+.PHONY : mlx/distributed/nccl/no_nccl.cpp.i
+
+mlx/distributed/nccl/no_nccl.s: mlx/distributed/nccl/no_nccl.cpp.s
+.PHONY : mlx/distributed/nccl/no_nccl.s
+
+# target to generate assembly for a file
+mlx/distributed/nccl/no_nccl.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.s
+.PHONY : mlx/distributed/nccl/no_nccl.cpp.s
+
+mlx/distributed/ops.o: mlx/distributed/ops.cpp.o
+.PHONY : mlx/distributed/ops.o
+
+# target to build an object file
+mlx/distributed/ops.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o
+.PHONY : mlx/distributed/ops.cpp.o
+
+mlx/distributed/ops.i: mlx/distributed/ops.cpp.i
+.PHONY : mlx/distributed/ops.i
+
+# target to preprocess a source file
+mlx/distributed/ops.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.i
+.PHONY : mlx/distributed/ops.cpp.i
+
+mlx/distributed/ops.s: mlx/distributed/ops.cpp.s
+.PHONY : mlx/distributed/ops.s
+
+# target to generate assembly for a file
+mlx/distributed/ops.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.s
+.PHONY : mlx/distributed/ops.cpp.s
+
+mlx/distributed/primitives.o: mlx/distributed/primitives.cpp.o
+.PHONY : mlx/distributed/primitives.o
+
+# target to build an object file
+mlx/distributed/primitives.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o
+.PHONY : mlx/distributed/primitives.cpp.o
+
+mlx/distributed/primitives.i: mlx/distributed/primitives.cpp.i
+.PHONY : mlx/distributed/primitives.i
+
+# target to preprocess a source file
+mlx/distributed/primitives.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.i
+.PHONY : mlx/distributed/primitives.cpp.i
+
+mlx/distributed/primitives.s: mlx/distributed/primitives.cpp.s
+.PHONY : mlx/distributed/primitives.s
+
+# target to generate assembly for a file
+mlx/distributed/primitives.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.s
+.PHONY : mlx/distributed/primitives.cpp.s
+
+mlx/distributed/ring/ring.o: mlx/distributed/ring/ring.cpp.o
+.PHONY : mlx/distributed/ring/ring.o
+
+# target to build an object file
+mlx/distributed/ring/ring.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o
+.PHONY : mlx/distributed/ring/ring.cpp.o
+
+mlx/distributed/ring/ring.i: mlx/distributed/ring/ring.cpp.i
+.PHONY : mlx/distributed/ring/ring.i
+
+# target to preprocess a source file
+mlx/distributed/ring/ring.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.i
+.PHONY : mlx/distributed/ring/ring.cpp.i
+
+mlx/distributed/ring/ring.s: mlx/distributed/ring/ring.cpp.s
+.PHONY : mlx/distributed/ring/ring.s
+
+# target to generate assembly for a file
+mlx/distributed/ring/ring.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.s
+.PHONY : mlx/distributed/ring/ring.cpp.s
+
+mlx/dtype.o: mlx/dtype.cpp.o
+.PHONY : mlx/dtype.o
+
+# target to build an object file
+mlx/dtype.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/dtype.cpp.o
+.PHONY : mlx/dtype.cpp.o
+
+mlx/dtype.i: mlx/dtype.cpp.i
+.PHONY : mlx/dtype.i
+
+# target to preprocess a source file
+mlx/dtype.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/dtype.cpp.i
+.PHONY : mlx/dtype.cpp.i
+
+mlx/dtype.s: mlx/dtype.cpp.s
+.PHONY : mlx/dtype.s
+
+# target to generate assembly for a file
+mlx/dtype.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/dtype.cpp.s
+.PHONY : mlx/dtype.cpp.s
+
+mlx/dtype_utils.o: mlx/dtype_utils.cpp.o
+.PHONY : mlx/dtype_utils.o
+
+# target to build an object file
+mlx/dtype_utils.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o
+.PHONY : mlx/dtype_utils.cpp.o
+
+mlx/dtype_utils.i: mlx/dtype_utils.cpp.i
+.PHONY : mlx/dtype_utils.i
+
+# target to preprocess a source file
+mlx/dtype_utils.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.i
+.PHONY : mlx/dtype_utils.cpp.i
+
+mlx/dtype_utils.s: mlx/dtype_utils.cpp.s
+.PHONY : mlx/dtype_utils.s
+
+# target to generate assembly for a file
+mlx/dtype_utils.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.s
+.PHONY : mlx/dtype_utils.cpp.s
+
+mlx/einsum.o: mlx/einsum.cpp.o
+.PHONY : mlx/einsum.o
+
+# target to build an object file
+mlx/einsum.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/einsum.cpp.o
+.PHONY : mlx/einsum.cpp.o
+
+mlx/einsum.i: mlx/einsum.cpp.i
+.PHONY : mlx/einsum.i
+
+# target to preprocess a source file
+mlx/einsum.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/einsum.cpp.i
+.PHONY : mlx/einsum.cpp.i
+
+mlx/einsum.s: mlx/einsum.cpp.s
+.PHONY : mlx/einsum.s
+
+# target to generate assembly for a file
+mlx/einsum.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/einsum.cpp.s
+.PHONY : mlx/einsum.cpp.s
+
+mlx/export.o: mlx/export.cpp.o
+.PHONY : mlx/export.o
+
+# target to build an object file
+mlx/export.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/export.cpp.o
+.PHONY : mlx/export.cpp.o
+
+mlx/export.i: mlx/export.cpp.i
+.PHONY : mlx/export.i
+
+# target to preprocess a source file
+mlx/export.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/export.cpp.i
+.PHONY : mlx/export.cpp.i
+
+mlx/export.s: mlx/export.cpp.s
+.PHONY : mlx/export.s
+
+# target to generate assembly for a file
+mlx/export.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/export.cpp.s
+.PHONY : mlx/export.cpp.s
+
+mlx/fast.o: mlx/fast.cpp.o
+.PHONY : mlx/fast.o
+
+# target to build an object file
+mlx/fast.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/fast.cpp.o
+.PHONY : mlx/fast.cpp.o
+
+mlx/fast.i: mlx/fast.cpp.i
+.PHONY : mlx/fast.i
+
+# target to preprocess a source file
+mlx/fast.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/fast.cpp.i
+.PHONY : mlx/fast.cpp.i
+
+mlx/fast.s: mlx/fast.cpp.s
+.PHONY : mlx/fast.s
+
+# target to generate assembly for a file
+mlx/fast.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/fast.cpp.s
+.PHONY : mlx/fast.cpp.s
+
+mlx/fft.o: mlx/fft.cpp.o
+.PHONY : mlx/fft.o
+
+# target to build an object file
+mlx/fft.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/fft.cpp.o
+.PHONY : mlx/fft.cpp.o
+
+mlx/fft.i: mlx/fft.cpp.i
+.PHONY : mlx/fft.i
+
+# target to preprocess a source file
+mlx/fft.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/fft.cpp.i
+.PHONY : mlx/fft.cpp.i
+
+mlx/fft.s: mlx/fft.cpp.s
+.PHONY : mlx/fft.s
+
+# target to generate assembly for a file
+mlx/fft.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/fft.cpp.s
+.PHONY : mlx/fft.cpp.s
+
+mlx/graph_utils.o: mlx/graph_utils.cpp.o
+.PHONY : mlx/graph_utils.o
+
+# target to build an object file
+mlx/graph_utils.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o
+.PHONY : mlx/graph_utils.cpp.o
+
+mlx/graph_utils.i: mlx/graph_utils.cpp.i
+.PHONY : mlx/graph_utils.i
+
+# target to preprocess a source file
+mlx/graph_utils.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/graph_utils.cpp.i
+.PHONY : mlx/graph_utils.cpp.i
+
+mlx/graph_utils.s: mlx/graph_utils.cpp.s
+.PHONY : mlx/graph_utils.s
+
+# target to generate assembly for a file
+mlx/graph_utils.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/graph_utils.cpp.s
+.PHONY : mlx/graph_utils.cpp.s
+
+mlx/io/gguf.o: mlx/io/gguf.cpp.o
+.PHONY : mlx/io/gguf.o
+
+# target to build an object file
+mlx/io/gguf.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o
+.PHONY : mlx/io/gguf.cpp.o
+
+mlx/io/gguf.i: mlx/io/gguf.cpp.i
+.PHONY : mlx/io/gguf.i
+
+# target to preprocess a source file
+mlx/io/gguf.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/io/gguf.cpp.i
+.PHONY : mlx/io/gguf.cpp.i
+
+mlx/io/gguf.s: mlx/io/gguf.cpp.s
+.PHONY : mlx/io/gguf.s
+
+# target to generate assembly for a file
+mlx/io/gguf.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/io/gguf.cpp.s
+.PHONY : mlx/io/gguf.cpp.s
+
+mlx/io/gguf_quants.o: mlx/io/gguf_quants.cpp.o
+.PHONY : mlx/io/gguf_quants.o
+
+# target to build an object file
+mlx/io/gguf_quants.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o
+.PHONY : mlx/io/gguf_quants.cpp.o
+
+mlx/io/gguf_quants.i: mlx/io/gguf_quants.cpp.i
+.PHONY : mlx/io/gguf_quants.i
+
+# target to preprocess a source file
+mlx/io/gguf_quants.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.i
+.PHONY : mlx/io/gguf_quants.cpp.i
+
+mlx/io/gguf_quants.s: mlx/io/gguf_quants.cpp.s
+.PHONY : mlx/io/gguf_quants.s
+
+# target to generate assembly for a file
+mlx/io/gguf_quants.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.s
+.PHONY : mlx/io/gguf_quants.cpp.s
+
+mlx/io/load.o: mlx/io/load.cpp.o
+.PHONY : mlx/io/load.o
+
+# target to build an object file
+mlx/io/load.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/io/load.cpp.o
+.PHONY : mlx/io/load.cpp.o
+
+mlx/io/load.i: mlx/io/load.cpp.i
+.PHONY : mlx/io/load.i
+
+# target to preprocess a source file
+mlx/io/load.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/io/load.cpp.i
+.PHONY : mlx/io/load.cpp.i
+
+mlx/io/load.s: mlx/io/load.cpp.s
+.PHONY : mlx/io/load.s
+
+# target to generate assembly for a file
+mlx/io/load.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/io/load.cpp.s
+.PHONY : mlx/io/load.cpp.s
+
+mlx/io/safetensors.o: mlx/io/safetensors.cpp.o
+.PHONY : mlx/io/safetensors.o
+
+# target to build an object file
+mlx/io/safetensors.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o
+.PHONY : mlx/io/safetensors.cpp.o
+
+mlx/io/safetensors.i: mlx/io/safetensors.cpp.i
+.PHONY : mlx/io/safetensors.i
+
+# target to preprocess a source file
+mlx/io/safetensors.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.i
+.PHONY : mlx/io/safetensors.cpp.i
+
+mlx/io/safetensors.s: mlx/io/safetensors.cpp.s
+.PHONY : mlx/io/safetensors.s
+
+# target to generate assembly for a file
+mlx/io/safetensors.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.s
+.PHONY : mlx/io/safetensors.cpp.s
+
+mlx/linalg.o: mlx/linalg.cpp.o
+.PHONY : mlx/linalg.o
+
+# target to build an object file
+mlx/linalg.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/linalg.cpp.o
+.PHONY : mlx/linalg.cpp.o
+
+mlx/linalg.i: mlx/linalg.cpp.i
+.PHONY : mlx/linalg.i
+
+# target to preprocess a source file
+mlx/linalg.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/linalg.cpp.i
+.PHONY : mlx/linalg.cpp.i
+
+mlx/linalg.s: mlx/linalg.cpp.s
+.PHONY : mlx/linalg.s
+
+# target to generate assembly for a file
+mlx/linalg.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/linalg.cpp.s
+.PHONY : mlx/linalg.cpp.s
+
+mlx/ops.o: mlx/ops.cpp.o
+.PHONY : mlx/ops.o
+
+# target to build an object file
+mlx/ops.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/ops.cpp.o
+.PHONY : mlx/ops.cpp.o
+
+mlx/ops.i: mlx/ops.cpp.i
+.PHONY : mlx/ops.i
+
+# target to preprocess a source file
+mlx/ops.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/ops.cpp.i
+.PHONY : mlx/ops.cpp.i
+
+mlx/ops.s: mlx/ops.cpp.s
+.PHONY : mlx/ops.s
+
+# target to generate assembly for a file
+mlx/ops.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/ops.cpp.s
+.PHONY : mlx/ops.cpp.s
+
+mlx/primitives.o: mlx/primitives.cpp.o
+.PHONY : mlx/primitives.o
+
+# target to build an object file
+mlx/primitives.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/primitives.cpp.o
+.PHONY : mlx/primitives.cpp.o
+
+mlx/primitives.i: mlx/primitives.cpp.i
+.PHONY : mlx/primitives.i
+
+# target to preprocess a source file
+mlx/primitives.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/primitives.cpp.i
+.PHONY : mlx/primitives.cpp.i
+
+mlx/primitives.s: mlx/primitives.cpp.s
+.PHONY : mlx/primitives.s
+
+# target to generate assembly for a file
+mlx/primitives.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/primitives.cpp.s
+.PHONY : mlx/primitives.cpp.s
+
+mlx/random.o: mlx/random.cpp.o
+.PHONY : mlx/random.o
+
+# target to build an object file
+mlx/random.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/random.cpp.o
+.PHONY : mlx/random.cpp.o
+
+mlx/random.i: mlx/random.cpp.i
+.PHONY : mlx/random.i
+
+# target to preprocess a source file
+mlx/random.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/random.cpp.i
+.PHONY : mlx/random.cpp.i
+
+mlx/random.s: mlx/random.cpp.s
+.PHONY : mlx/random.s
+
+# target to generate assembly for a file
+mlx/random.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/random.cpp.s
+.PHONY : mlx/random.cpp.s
+
+mlx/scheduler.o: mlx/scheduler.cpp.o
+.PHONY : mlx/scheduler.o
+
+# target to build an object file
+mlx/scheduler.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/scheduler.cpp.o
+.PHONY : mlx/scheduler.cpp.o
+
+mlx/scheduler.i: mlx/scheduler.cpp.i
+.PHONY : mlx/scheduler.i
+
+# target to preprocess a source file
+mlx/scheduler.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/scheduler.cpp.i
+.PHONY : mlx/scheduler.cpp.i
+
+mlx/scheduler.s: mlx/scheduler.cpp.s
+.PHONY : mlx/scheduler.s
+
+# target to generate assembly for a file
+mlx/scheduler.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/scheduler.cpp.s
+.PHONY : mlx/scheduler.cpp.s
+
+mlx/transforms.o: mlx/transforms.cpp.o
+.PHONY : mlx/transforms.o
+
+# target to build an object file
+mlx/transforms.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/transforms.cpp.o
+.PHONY : mlx/transforms.cpp.o
+
+mlx/transforms.i: mlx/transforms.cpp.i
+.PHONY : mlx/transforms.i
+
+# target to preprocess a source file
+mlx/transforms.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/transforms.cpp.i
+.PHONY : mlx/transforms.cpp.i
+
+mlx/transforms.s: mlx/transforms.cpp.s
+.PHONY : mlx/transforms.s
+
+# target to generate assembly for a file
+mlx/transforms.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/transforms.cpp.s
+.PHONY : mlx/transforms.cpp.s
+
+mlx/utils.o: mlx/utils.cpp.o
+.PHONY : mlx/utils.o
+
+# target to build an object file
+mlx/utils.cpp.o:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/utils.cpp.o
+.PHONY : mlx/utils.cpp.o
+
+mlx/utils.i: mlx/utils.cpp.i
+.PHONY : mlx/utils.i
+
+# target to preprocess a source file
+mlx/utils.cpp.i:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/utils.cpp.i
+.PHONY : mlx/utils.cpp.i
+
+mlx/utils.s: mlx/utils.cpp.s
+.PHONY : mlx/utils.s
+
+# target to generate assembly for a file
+mlx/utils.cpp.s:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/mlx.dir/build.make CMakeFiles/mlx.dir/mlx/utils.cpp.s
+.PHONY : mlx/utils.cpp.s
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+	@echo "... cpu_compiled_preamble"
+	@echo "... core"
+	@echo "... fmt"
+	@echo "... gguflib"
+	@echo "... mlx"
+	@echo "... mlx_version"
+	@echo "... nanobind-static"
+	@echo "... mlx/allocator.o"
+	@echo "... mlx/allocator.i"
+	@echo "... mlx/allocator.s"
+	@echo "... mlx/array.o"
+	@echo "... mlx/array.i"
+	@echo "... mlx/array.s"
+	@echo "... mlx/backend/common/broadcasting.o"
+	@echo "... mlx/backend/common/broadcasting.i"
+	@echo "... mlx/backend/common/broadcasting.s"
+	@echo "... mlx/backend/common/common.o"
+	@echo "... mlx/backend/common/common.i"
+	@echo "... mlx/backend/common/common.s"
+	@echo "... mlx/backend/common/compiled.o"
+	@echo "... mlx/backend/common/compiled.i"
+	@echo "... mlx/backend/common/compiled.s"
+	@echo "... mlx/backend/common/load.o"
+	@echo "... mlx/backend/common/load.i"
+	@echo "... mlx/backend/common/load.s"
+	@echo "... mlx/backend/common/reduce.o"
+	@echo "... mlx/backend/common/reduce.i"
+	@echo "... mlx/backend/common/reduce.s"
+	@echo "... mlx/backend/common/slicing.o"
+	@echo "... mlx/backend/common/slicing.i"
+	@echo "... mlx/backend/common/slicing.s"
+	@echo "... mlx/backend/common/utils.o"
+	@echo "... mlx/backend/common/utils.i"
+	@echo "... mlx/backend/common/utils.s"
+	@echo "... mlx/backend/cpu/arg_reduce.o"
+	@echo "... mlx/backend/cpu/arg_reduce.i"
+	@echo "... mlx/backend/cpu/arg_reduce.s"
+	@echo "... mlx/backend/cpu/available.o"
+	@echo "... mlx/backend/cpu/available.i"
+	@echo "... mlx/backend/cpu/available.s"
+	@echo "... mlx/backend/cpu/binary.o"
+	@echo "... mlx/backend/cpu/binary.i"
+	@echo "... mlx/backend/cpu/binary.s"
+	@echo "... mlx/backend/cpu/cholesky.o"
+	@echo "... mlx/backend/cpu/cholesky.i"
+	@echo "... mlx/backend/cpu/cholesky.s"
+	@echo "... mlx/backend/cpu/compiled.o"
+	@echo "... mlx/backend/cpu/compiled.i"
+	@echo "... mlx/backend/cpu/compiled.s"
+	@echo "... mlx/backend/cpu/compiled_preamble.o"
+	@echo "... mlx/backend/cpu/compiled_preamble.i"
+	@echo "... mlx/backend/cpu/compiled_preamble.s"
+	@echo "... mlx/backend/cpu/conv.o"
+	@echo "... mlx/backend/cpu/conv.i"
+	@echo "... mlx/backend/cpu/conv.s"
+	@echo "... mlx/backend/cpu/copy.o"
+	@echo "... mlx/backend/cpu/copy.i"
+	@echo "... mlx/backend/cpu/copy.s"
+	@echo "... mlx/backend/cpu/distributed.o"
+	@echo "... mlx/backend/cpu/distributed.i"
+	@echo "... mlx/backend/cpu/distributed.s"
+	@echo "... mlx/backend/cpu/eig.o"
+	@echo "... mlx/backend/cpu/eig.i"
+	@echo "... mlx/backend/cpu/eig.s"
+	@echo "... mlx/backend/cpu/eigh.o"
+	@echo "... mlx/backend/cpu/eigh.i"
+	@echo "... mlx/backend/cpu/eigh.s"
+	@echo "... mlx/backend/cpu/encoder.o"
+	@echo "... mlx/backend/cpu/encoder.i"
+	@echo "... mlx/backend/cpu/encoder.s"
+	@echo "... mlx/backend/cpu/eval.o"
+	@echo "... mlx/backend/cpu/eval.i"
+	@echo "... mlx/backend/cpu/eval.s"
+	@echo "... mlx/backend/cpu/fft.o"
+	@echo "... mlx/backend/cpu/fft.i"
+	@echo "... mlx/backend/cpu/fft.s"
+	@echo "... mlx/backend/cpu/gemms/cblas.o"
+	@echo "... mlx/backend/cpu/gemms/cblas.i"
+	@echo "... mlx/backend/cpu/gemms/cblas.s"
+	@echo "... mlx/backend/cpu/gemms/simd_bf16.o"
+	@echo "... mlx/backend/cpu/gemms/simd_bf16.i"
+	@echo "... mlx/backend/cpu/gemms/simd_bf16.s"
+	@echo "... mlx/backend/cpu/gemms/simd_fp16.o"
+	@echo "... mlx/backend/cpu/gemms/simd_fp16.i"
+	@echo "... mlx/backend/cpu/gemms/simd_fp16.s"
+	@echo "... mlx/backend/cpu/hadamard.o"
+	@echo "... mlx/backend/cpu/hadamard.i"
+	@echo "... mlx/backend/cpu/hadamard.s"
+	@echo "... mlx/backend/cpu/indexing.o"
+	@echo "... mlx/backend/cpu/indexing.i"
+	@echo "... mlx/backend/cpu/indexing.s"
+	@echo "... mlx/backend/cpu/inverse.o"
+	@echo "... mlx/backend/cpu/inverse.i"
+	@echo "... mlx/backend/cpu/inverse.s"
+	@echo "... mlx/backend/cpu/jit_compiler.o"
+	@echo "... mlx/backend/cpu/jit_compiler.i"
+	@echo "... mlx/backend/cpu/jit_compiler.s"
+	@echo "... mlx/backend/cpu/logsumexp.o"
+	@echo "... mlx/backend/cpu/logsumexp.i"
+	@echo "... mlx/backend/cpu/logsumexp.s"
+	@echo "... mlx/backend/cpu/luf.o"
+	@echo "... mlx/backend/cpu/luf.i"
+	@echo "... mlx/backend/cpu/luf.s"
+	@echo "... mlx/backend/cpu/masked_mm.o"
+	@echo "... mlx/backend/cpu/masked_mm.i"
+	@echo "... mlx/backend/cpu/masked_mm.s"
+	@echo "... mlx/backend/cpu/matmul.o"
+	@echo "... mlx/backend/cpu/matmul.i"
+	@echo "... mlx/backend/cpu/matmul.s"
+	@echo "... mlx/backend/cpu/primitives.o"
+	@echo "... mlx/backend/cpu/primitives.i"
+	@echo "... mlx/backend/cpu/primitives.s"
+	@echo "... mlx/backend/cpu/qrf.o"
+	@echo "... mlx/backend/cpu/qrf.i"
+	@echo "... mlx/backend/cpu/qrf.s"
+	@echo "... mlx/backend/cpu/quantized.o"
+	@echo "... mlx/backend/cpu/quantized.i"
+	@echo "... mlx/backend/cpu/quantized.s"
+	@echo "... mlx/backend/cpu/reduce.o"
+	@echo "... mlx/backend/cpu/reduce.i"
+	@echo "... mlx/backend/cpu/reduce.s"
+	@echo "... mlx/backend/cpu/scan.o"
+	@echo "... mlx/backend/cpu/scan.i"
+	@echo "... mlx/backend/cpu/scan.s"
+	@echo "... mlx/backend/cpu/select.o"
+	@echo "... mlx/backend/cpu/select.i"
+	@echo "... mlx/backend/cpu/select.s"
+	@echo "... mlx/backend/cpu/softmax.o"
+	@echo "... mlx/backend/cpu/softmax.i"
+	@echo "... mlx/backend/cpu/softmax.s"
+	@echo "... mlx/backend/cpu/sort.o"
+	@echo "... mlx/backend/cpu/sort.i"
+	@echo "... mlx/backend/cpu/sort.s"
+	@echo "... mlx/backend/cpu/svd.o"
+	@echo "... mlx/backend/cpu/svd.i"
+	@echo "... mlx/backend/cpu/svd.s"
+	@echo "... mlx/backend/cpu/threefry.o"
+	@echo "... mlx/backend/cpu/threefry.i"
+	@echo "... mlx/backend/cpu/threefry.s"
+	@echo "... mlx/backend/cpu/unary.o"
+	@echo "... mlx/backend/cpu/unary.i"
+	@echo "... mlx/backend/cpu/unary.s"
+	@echo "... mlx/backend/cuda/no_cuda.o"
+	@echo "... mlx/backend/cuda/no_cuda.i"
+	@echo "... mlx/backend/cuda/no_cuda.s"
+	@echo "... mlx/backend/metal/no_metal.o"
+	@echo "... mlx/backend/metal/no_metal.i"
+	@echo "... mlx/backend/metal/no_metal.s"
+	@echo "... mlx/backend/no_gpu/allocator.o"
+	@echo "... mlx/backend/no_gpu/allocator.i"
+	@echo "... mlx/backend/no_gpu/allocator.s"
+	@echo "... mlx/backend/no_gpu/eval.o"
+	@echo "... mlx/backend/no_gpu/eval.i"
+	@echo "... mlx/backend/no_gpu/eval.s"
+	@echo "... mlx/backend/no_gpu/event.o"
+	@echo "... mlx/backend/no_gpu/event.i"
+	@echo "... mlx/backend/no_gpu/event.s"
+	@echo "... mlx/backend/no_gpu/fence.o"
+	@echo "... mlx/backend/no_gpu/fence.i"
+	@echo "... mlx/backend/no_gpu/fence.s"
+	@echo "... mlx/backend/no_gpu/primitives.o"
+	@echo "... mlx/backend/no_gpu/primitives.i"
+	@echo "... mlx/backend/no_gpu/primitives.s"
+	@echo "... mlx/compile.o"
+	@echo "... mlx/compile.i"
+	@echo "... mlx/compile.s"
+	@echo "... mlx/device.o"
+	@echo "... mlx/device.i"
+	@echo "... mlx/device.s"
+	@echo "... mlx/distributed/distributed.o"
+	@echo "... mlx/distributed/distributed.i"
+	@echo "... mlx/distributed/distributed.s"
+	@echo "... mlx/distributed/mpi/mpi.o"
+	@echo "... mlx/distributed/mpi/mpi.i"
+	@echo "... mlx/distributed/mpi/mpi.s"
+	@echo "... mlx/distributed/nccl/no_nccl.o"
+	@echo "... mlx/distributed/nccl/no_nccl.i"
+	@echo "... mlx/distributed/nccl/no_nccl.s"
+	@echo "... mlx/distributed/ops.o"
+	@echo "... mlx/distributed/ops.i"
+	@echo "... mlx/distributed/ops.s"
+	@echo "... mlx/distributed/primitives.o"
+	@echo "... mlx/distributed/primitives.i"
+	@echo "... mlx/distributed/primitives.s"
+	@echo "... mlx/distributed/ring/ring.o"
+	@echo "... mlx/distributed/ring/ring.i"
+	@echo "... mlx/distributed/ring/ring.s"
+	@echo "... mlx/dtype.o"
+	@echo "... mlx/dtype.i"
+	@echo "... mlx/dtype.s"
+	@echo "... mlx/dtype_utils.o"
+	@echo "... mlx/dtype_utils.i"
+	@echo "... mlx/dtype_utils.s"
+	@echo "... mlx/einsum.o"
+	@echo "... mlx/einsum.i"
+	@echo "... mlx/einsum.s"
+	@echo "... mlx/export.o"
+	@echo "... mlx/export.i"
+	@echo "... mlx/export.s"
+	@echo "... mlx/fast.o"
+	@echo "... mlx/fast.i"
+	@echo "... mlx/fast.s"
+	@echo "... mlx/fft.o"
+	@echo "... mlx/fft.i"
+	@echo "... mlx/fft.s"
+	@echo "... mlx/graph_utils.o"
+	@echo "... mlx/graph_utils.i"
+	@echo "... mlx/graph_utils.s"
+	@echo "... mlx/io/gguf.o"
+	@echo "... mlx/io/gguf.i"
+	@echo "... mlx/io/gguf.s"
+	@echo "... mlx/io/gguf_quants.o"
+	@echo "... mlx/io/gguf_quants.i"
+	@echo "... mlx/io/gguf_quants.s"
+	@echo "... mlx/io/load.o"
+	@echo "... mlx/io/load.i"
+	@echo "... mlx/io/load.s"
+	@echo "... mlx/io/safetensors.o"
+	@echo "... mlx/io/safetensors.i"
+	@echo "... mlx/io/safetensors.s"
+	@echo "... mlx/linalg.o"
+	@echo "... mlx/linalg.i"
+	@echo "... mlx/linalg.s"
+	@echo "... mlx/ops.o"
+	@echo "... mlx/ops.i"
+	@echo "... mlx/ops.s"
+	@echo "... mlx/primitives.o"
+	@echo "... mlx/primitives.i"
+	@echo "... mlx/primitives.s"
+	@echo "... mlx/random.o"
+	@echo "... mlx/random.i"
+	@echo "... mlx/random.s"
+	@echo "... mlx/scheduler.o"
+	@echo "... mlx/scheduler.i"
+	@echo "... mlx/scheduler.s"
+	@echo "... mlx/transforms.o"
+	@echo "... mlx/transforms.i"
+	@echo "... mlx/transforms.s"
+	@echo "... mlx/utils.o"
+	@echo "... mlx/utils.i"
+	@echo "... mlx/utils.s"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb9de92640e91b3d38364ee7a569cd8b862951
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/Export/52567436e6aeb216c623c7cea7a08046/fmt-targets-release.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/Export/52567436e6aeb216c623c7cea7a08046/fmt-targets-release.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..348b53c40f3e6bcc6d80d6df076c9fd427167789
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/Export/52567436e6aeb216c623c7cea7a08046/fmt-targets-release.cmake
@@ -0,0 +1,19 @@
+#----------------------------------------------------------------
+# Generated CMake target import file for configuration "Release".
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Import target "fmt::fmt" for configuration "Release"
+set_property(TARGET fmt::fmt APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(fmt::fmt PROPERTIES
+  IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib64/libfmt.so.10.2.1"
+  IMPORTED_SONAME_RELEASE "libfmt.so.10"
+  )
+
+list(APPEND _cmake_import_check_targets fmt::fmt )
+list(APPEND _cmake_import_check_files_for_fmt::fmt "${_IMPORT_PREFIX}/lib64/libfmt.so.10.2.1" )
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/Export/52567436e6aeb216c623c7cea7a08046/fmt-targets.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/Export/52567436e6aeb216c623c7cea7a08046/fmt-targets.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..8c2477286f5c1620a56534e97943836764484810
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/Export/52567436e6aeb216c623c7cea7a08046/fmt-targets.cmake
@@ -0,0 +1,117 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+   message(FATAL_ERROR "CMake >= 3.0.0 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "3.0.0")
+   message(FATAL_ERROR "CMake >= 3.0.0 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.0.0...3.30)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS fmt::fmt fmt::fmt-header-only)
+  list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+  if(TARGET "${_cmake_expected_target}")
+    list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+  else()
+    list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+  endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+  unset(_cmake_targets_defined)
+  unset(_cmake_targets_not_defined)
+  unset(_cmake_expected_targets)
+  unset(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+  string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+  string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target fmt::fmt
+add_library(fmt::fmt SHARED IMPORTED)
+
+set_target_properties(fmt::fmt PROPERTIES
+  INTERFACE_COMPILE_DEFINITIONS "FMT_SHARED"
+  INTERFACE_COMPILE_FEATURES "cxx_std_11"
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
+)
+
+# Create imported target fmt::fmt-header-only
+add_library(fmt::fmt-header-only INTERFACE IMPORTED)
+
+set_target_properties(fmt::fmt-header-only PROPERTIES
+  INTERFACE_COMPILE_DEFINITIONS "FMT_HEADER_ONLY=1"
+  INTERFACE_COMPILE_FEATURES "cxx_std_11"
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
+)
+
+# Load information for each installed configuration.
+file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/fmt-targets-*.cmake")
+foreach(_cmake_config_file IN LISTS _cmake_config_files)
+  include("${_cmake_config_file}")
+endforeach()
+unset(_cmake_config_file)
+unset(_cmake_config_files)
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(_cmake_target IN LISTS _cmake_import_check_targets)
+  if(CMAKE_VERSION VERSION_LESS "3.28"
+      OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target}
+      OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}")
+    foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+      if(NOT EXISTS "${_cmake_file}")
+        message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+   \"${_cmake_file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+      endif()
+    endforeach()
+  endif()
+  unset(_cmake_file)
+  unset("_cmake_import_check_files_for_${_cmake_target}")
+endforeach()
+unset(_cmake_target)
+unset(_cmake_import_check_targets)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/DependInfo.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/DependInfo.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..935e28039ef357b4ec78b4ad77624b8a3a258db2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/DependInfo.cmake
@@ -0,0 +1,31 @@
+
+# Consider dependencies only in project.
+set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
+
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  )
+
+# The set of dependency files which are needed:
+set(CMAKE_DEPENDS_DEPENDENCY_FILES
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/format.cc" "_deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.o" "gcc" "_deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/os.cc" "_deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.o" "gcc" "_deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.o.d"
+  )
+
+# Pairs of files generated by the same build rule.
+set(CMAKE_MULTIPLE_OUTPUT_PAIRS
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/libfmt.so" "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/libfmt.so.10.2.1"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/libfmt.so.10" "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/libfmt.so.10.2.1"
+  )
+
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/build.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/build.make
new file mode 100644
index 0000000000000000000000000000000000000000..678392dc91e0fab82e5f61006f16b1b455c7a953
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/build.make
@@ -0,0 +1,136 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+# Include any dependencies generated for this target.
+include _deps/fmt-build/CMakeFiles/fmt.dir/depend.make
+# Include any dependencies generated by the compiler for this target.
+include _deps/fmt-build/CMakeFiles/fmt.dir/compiler_depend.make
+
+# Include the progress variables for this target.
+include _deps/fmt-build/CMakeFiles/fmt.dir/progress.make
+
+# Include the compile flags for this target's objects.
+include _deps/fmt-build/CMakeFiles/fmt.dir/flags.make
+
+_deps/fmt-build/CMakeFiles/fmt.dir/codegen:
+.PHONY : _deps/fmt-build/CMakeFiles/fmt.dir/codegen
+
+_deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.o: _deps/fmt-build/CMakeFiles/fmt.dir/flags.make
+_deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.o: _deps/fmt-src/src/format.cc
+_deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.o: _deps/fmt-build/CMakeFiles/fmt.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object _deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT _deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.o -MF CMakeFiles/fmt.dir/src/format.cc.o.d -o CMakeFiles/fmt.dir/src/format.cc.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/format.cc
+
+_deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/fmt.dir/src/format.cc.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/format.cc > CMakeFiles/fmt.dir/src/format.cc.i
+
+_deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/fmt.dir/src/format.cc.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/format.cc -o CMakeFiles/fmt.dir/src/format.cc.s
+
+_deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.o: _deps/fmt-build/CMakeFiles/fmt.dir/flags.make
+_deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.o: _deps/fmt-src/src/os.cc
+_deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.o: _deps/fmt-build/CMakeFiles/fmt.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object _deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT _deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.o -MF CMakeFiles/fmt.dir/src/os.cc.o.d -o CMakeFiles/fmt.dir/src/os.cc.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/os.cc
+
+_deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/fmt.dir/src/os.cc.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/os.cc > CMakeFiles/fmt.dir/src/os.cc.i
+
+_deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/fmt.dir/src/os.cc.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/os.cc -o CMakeFiles/fmt.dir/src/os.cc.s
+
+# Object files for target fmt
+fmt_OBJECTS = \
+"CMakeFiles/fmt.dir/src/format.cc.o" \
+"CMakeFiles/fmt.dir/src/os.cc.o"
+
+# External object files for target fmt
+fmt_EXTERNAL_OBJECTS =
+
+_deps/fmt-build/libfmt.so.10.2.1: _deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.o
+_deps/fmt-build/libfmt.so.10.2.1: _deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.o
+_deps/fmt-build/libfmt.so.10.2.1: _deps/fmt-build/CMakeFiles/fmt.dir/build.make
+_deps/fmt-build/libfmt.so.10.2.1: _deps/fmt-build/CMakeFiles/fmt.dir/link.txt
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Linking CXX shared library libfmt.so"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/fmt.dir/link.txt --verbose=$(VERBOSE)
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && $(CMAKE_COMMAND) -E cmake_symlink_library libfmt.so.10.2.1 libfmt.so.10 libfmt.so
+
+_deps/fmt-build/libfmt.so.10: _deps/fmt-build/libfmt.so.10.2.1
+	@$(CMAKE_COMMAND) -E touch_nocreate _deps/fmt-build/libfmt.so.10
+
+_deps/fmt-build/libfmt.so: _deps/fmt-build/libfmt.so.10.2.1
+	@$(CMAKE_COMMAND) -E touch_nocreate _deps/fmt-build/libfmt.so
+
+# Rule to build all files generated by this target.
+_deps/fmt-build/CMakeFiles/fmt.dir/build: _deps/fmt-build/libfmt.so
+.PHONY : _deps/fmt-build/CMakeFiles/fmt.dir/build
+
+_deps/fmt-build/CMakeFiles/fmt.dir/clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && $(CMAKE_COMMAND) -P CMakeFiles/fmt.dir/cmake_clean.cmake
+.PHONY : _deps/fmt-build/CMakeFiles/fmt.dir/clean
+
+_deps/fmt-build/CMakeFiles/fmt.dir/depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/DependInfo.cmake "--color=$(COLOR)"
+.PHONY : _deps/fmt-build/CMakeFiles/fmt.dir/depend
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/cmake_clean.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/cmake_clean.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..a8d44c30f564236be8faa53acb397ae43a1c48b2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/cmake_clean.cmake
@@ -0,0 +1,16 @@
+file(REMOVE_RECURSE
+  ".10"
+  "CMakeFiles/fmt.dir/src/format.cc.o"
+  "CMakeFiles/fmt.dir/src/format.cc.o.d"
+  "CMakeFiles/fmt.dir/src/os.cc.o"
+  "CMakeFiles/fmt.dir/src/os.cc.o.d"
+  "libfmt.pdb"
+  "libfmt.so"
+  "libfmt.so.10"
+  "libfmt.so.10.2.1"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang CXX)
+  include(CMakeFiles/fmt.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/compiler_depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/compiler_depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..7f064b376f163a35746dc489c9dbf912d8030740
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/compiler_depend.make
@@ -0,0 +1,2 @@
+# Empty compiler generated dependencies file for fmt.
+# This may be replaced when dependencies are built.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/compiler_depend.ts b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/compiler_depend.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4f7415154b13887ba5eecbe6b37135918cfbbb85
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/compiler_depend.ts
@@ -0,0 +1,2 @@
+# CMAKE generated file: DO NOT EDIT!
+# Timestamp file for compiler generated dependencies management for fmt.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..012503b83c5f6a3f5c80d6334d482f8245d4b859
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/depend.make
@@ -0,0 +1,2 @@
+# Empty dependencies file for fmt.
+# This may be replaced when dependencies are built.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/flags.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/flags.make
new file mode 100644
index 0000000000000000000000000000000000000000..24efdd48c02e4ba0433e92716912d1e282b71e5c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/flags.make
@@ -0,0 +1,10 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# compile CXX with /usr/bin/c++
+CXX_DEFINES = -DFMT_LIB_EXPORT -Dfmt_EXPORTS
+
+CXX_INCLUDES = -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include
+
+CXX_FLAGS = -O3 -DNDEBUG -std=gnu++17 -fPIC
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/link.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/link.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4c9f65ba4a50785d511309ecb049f4f89dae8da8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/link.txt
@@ -0,0 +1 @@
+/usr/bin/c++ -fPIC -O3 -DNDEBUG -shared -Wl,-soname,libfmt.so.10 -o libfmt.so.10.2.1 CMakeFiles/fmt.dir/src/format.cc.o CMakeFiles/fmt.dir/src/os.cc.o
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/progress.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/progress.make
new file mode 100644
index 0000000000000000000000000000000000000000..e6d9ab3addcf0216f45da310cfd056d5d91ba377
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/fmt.dir/progress.make
@@ -0,0 +1,4 @@
+CMAKE_PROGRESS_1 = 20
+CMAKE_PROGRESS_2 = 21
+CMAKE_PROGRESS_3 = 22
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..00750edc07d6415dcc07ae0351e9397b0222b7ba
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+3
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..5474d99e7604ed0284149e626e5a3080c1c79548
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/Makefile
@@ -0,0 +1,258 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\" \"headers\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build//CMakeFiles/progress.marks
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 _deps/fmt-build/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 _deps/fmt-build/clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 _deps/fmt-build/preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 _deps/fmt-build/preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+# Convenience name for target.
+_deps/fmt-build/CMakeFiles/fmt.dir/rule:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 _deps/fmt-build/CMakeFiles/fmt.dir/rule
+.PHONY : _deps/fmt-build/CMakeFiles/fmt.dir/rule
+
+# Convenience name for target.
+fmt: _deps/fmt-build/CMakeFiles/fmt.dir/rule
+.PHONY : fmt
+
+# fast build rule for target.
+fmt/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f _deps/fmt-build/CMakeFiles/fmt.dir/build.make _deps/fmt-build/CMakeFiles/fmt.dir/build
+.PHONY : fmt/fast
+
+src/format.o: src/format.cc.o
+.PHONY : src/format.o
+
+# target to build an object file
+src/format.cc.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f _deps/fmt-build/CMakeFiles/fmt.dir/build.make _deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.o
+.PHONY : src/format.cc.o
+
+src/format.i: src/format.cc.i
+.PHONY : src/format.i
+
+# target to preprocess a source file
+src/format.cc.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f _deps/fmt-build/CMakeFiles/fmt.dir/build.make _deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.i
+.PHONY : src/format.cc.i
+
+src/format.s: src/format.cc.s
+.PHONY : src/format.s
+
+# target to generate assembly for a file
+src/format.cc.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f _deps/fmt-build/CMakeFiles/fmt.dir/build.make _deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.s
+.PHONY : src/format.cc.s
+
+src/os.o: src/os.cc.o
+.PHONY : src/os.o
+
+# target to build an object file
+src/os.cc.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f _deps/fmt-build/CMakeFiles/fmt.dir/build.make _deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.o
+.PHONY : src/os.cc.o
+
+src/os.i: src/os.cc.i
+.PHONY : src/os.i
+
+# target to preprocess a source file
+src/os.cc.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f _deps/fmt-build/CMakeFiles/fmt.dir/build.make _deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.i
+.PHONY : src/os.cc.i
+
+src/os.s: src/os.cc.s
+.PHONY : src/os.s
+
+# target to generate assembly for a file
+src/os.cc.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f _deps/fmt-build/CMakeFiles/fmt.dir/build.make _deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.s
+.PHONY : src/os.cc.s
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+	@echo "... fmt"
+	@echo "... src/format.o"
+	@echo "... src/format.i"
+	@echo "... src/format.s"
+	@echo "... src/os.o"
+	@echo "... src/os.i"
+	@echo "... src/os.s"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..fec74eb2812ea9cd1ee9089a3ff1e21c501e8f5a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/cmake_install.cmake
@@ -0,0 +1,135 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  foreach(file
+      "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/libfmt.so.10.2.1"
+      "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/libfmt.so.10"
+      )
+    if(EXISTS "${file}" AND
+       NOT IS_SYMLINK "${file}")
+      file(RPATH_CHECK
+           FILE "${file}"
+           RPATH "")
+    endif()
+  endforeach()
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/lib64" TYPE SHARED_LIBRARY MESSAGE_NEVER FILES
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/libfmt.so.10.2.1"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/libfmt.so.10"
+    )
+  foreach(file
+      "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/libfmt.so.10.2.1"
+      "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/libfmt.so.10"
+      )
+    if(EXISTS "${file}" AND
+       NOT IS_SYMLINK "${file}")
+      if(CMAKE_INSTALL_DO_STRIP)
+        execute_process(COMMAND "/usr/bin/strip" "${file}")
+      endif()
+    endif()
+  endforeach()
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/lib64" TYPE SHARED_LIBRARY MESSAGE_NEVER FILES "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/libfmt.so")
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/include/fmt" TYPE FILE MESSAGE_NEVER FILES
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/args.h"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/chrono.h"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/color.h"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/compile.h"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/core.h"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format.h"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format-inl.h"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/os.h"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/ostream.h"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/printf.h"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/ranges.h"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/std.h"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/xchar.h"
+    )
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/lib64/cmake/fmt" TYPE FILE MESSAGE_NEVER FILES
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt-config.cmake"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt-config-version.cmake"
+    )
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  if(EXISTS "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/cmake/fmt/fmt-targets.cmake")
+    file(DIFFERENT _cmake_export_file_changed FILES
+         "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/cmake/fmt/fmt-targets.cmake"
+         "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/Export/52567436e6aeb216c623c7cea7a08046/fmt-targets.cmake")
+    if(_cmake_export_file_changed)
+      file(GLOB _cmake_old_config_files "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/cmake/fmt/fmt-targets-*.cmake")
+      if(_cmake_old_config_files)
+        string(REPLACE ";" ", " _cmake_old_config_files_text "${_cmake_old_config_files}")
+        message(STATUS "Old export file \"$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/cmake/fmt/fmt-targets.cmake\" will be replaced.  Removing files [${_cmake_old_config_files_text}].")
+        unset(_cmake_old_config_files_text)
+        file(REMOVE ${_cmake_old_config_files})
+      endif()
+      unset(_cmake_old_config_files)
+    endif()
+    unset(_cmake_export_file_changed)
+  endif()
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/lib64/cmake/fmt" TYPE FILE MESSAGE_NEVER FILES "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/Export/52567436e6aeb216c623c7cea7a08046/fmt-targets.cmake")
+  if(CMAKE_INSTALL_CONFIG_NAME MATCHES "^([Rr][Ee][Ll][Ee][Aa][Ss][Ee])$")
+    file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/lib64/cmake/fmt" TYPE FILE MESSAGE_NEVER FILES "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/CMakeFiles/Export/52567436e6aeb216c623c7cea7a08046/fmt-targets-release.cmake")
+  endif()
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/lib64/pkgconfig" TYPE FILE MESSAGE_NEVER FILES "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt.pc")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt-config-version.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt-config-version.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..af9a9eb47db1a5e54121d36aef7ad93d87c24249
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt-config-version.cmake
@@ -0,0 +1,43 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+set(PACKAGE_VERSION "10.2.1")
+
+if (PACKAGE_FIND_VERSION_RANGE)
+  # Package version must be in the requested version range
+  if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN)
+      OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX)
+        OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX)))
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  endif()
+else()
+  if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+  endif()
+endif()
+
+
+# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "")
+  return()
+endif()
+
+# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
+if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8")
+  math(EXPR installedBits "8 * 8")
+  set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
+  set(PACKAGE_VERSION_UNSUITABLE TRUE)
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt-config.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt-config.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..c1b9de53150a3432280f1a14603077d7993eef78
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt-config.cmake
@@ -0,0 +1,31 @@
+
+####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() #######
+####### Any changes to this file will be overwritten by the next CMake run ####
+####### The input file was fmt-config.cmake.in                            ########
+
+get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
+
+macro(set_and_check _var _file)
+  set(${_var} "${_file}")
+  if(NOT EXISTS "${_file}")
+    message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
+  endif()
+endmacro()
+
+macro(check_required_components _NAME)
+  foreach(comp ${${_NAME}_FIND_COMPONENTS})
+    if(NOT ${_NAME}_${comp}_FOUND)
+      if(${_NAME}_FIND_REQUIRED_${comp})
+        set(${_NAME}_FOUND FALSE)
+      endif()
+    endif()
+  endforeach()
+endmacro()
+
+####################################################################################
+
+if (NOT TARGET fmt::fmt)
+  include(${CMAKE_CURRENT_LIST_DIR}/fmt-targets.cmake)
+endif ()
+
+check_required_components(fmt)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt-targets.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt-targets.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..3e529fec289aed9aeaa69867d58143381b84dc47
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt-targets.cmake
@@ -0,0 +1,79 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+   message(FATAL_ERROR "CMake >= 3.0.0 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "3.0.0")
+   message(FATAL_ERROR "CMake >= 3.0.0 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.0.0...3.30)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS fmt::fmt fmt::fmt-header-only)
+  list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+  if(TARGET "${_cmake_expected_target}")
+    list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+  else()
+    list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+  endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+  unset(_cmake_targets_defined)
+  unset(_cmake_targets_not_defined)
+  unset(_cmake_expected_targets)
+  unset(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+  string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+  string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Create imported target fmt::fmt
+add_library(fmt::fmt SHARED IMPORTED)
+
+set_target_properties(fmt::fmt PROPERTIES
+  INTERFACE_COMPILE_DEFINITIONS "FMT_SHARED"
+  INTERFACE_COMPILE_FEATURES "cxx_std_11"
+  INTERFACE_INCLUDE_DIRECTORIES "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include"
+)
+
+# Create imported target fmt::fmt-header-only
+add_library(fmt::fmt-header-only INTERFACE IMPORTED)
+
+set_target_properties(fmt::fmt-header-only PROPERTIES
+  INTERFACE_COMPILE_DEFINITIONS "FMT_HEADER_ONLY=1"
+  INTERFACE_COMPILE_FEATURES "cxx_std_11"
+  INTERFACE_INCLUDE_DIRECTORIES "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include"
+)
+
+# Import target "fmt::fmt" for configuration "Release"
+set_property(TARGET fmt::fmt APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+set_target_properties(fmt::fmt PROPERTIES
+  IMPORTED_LOCATION_RELEASE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/libfmt.so.10.2.1"
+  IMPORTED_SONAME_RELEASE "libfmt.so.10"
+  )
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt.pc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt.pc
new file mode 100644
index 0000000000000000000000000000000000000000..227026ee5b57cece93f34d61ba6cfa3fd0b61d2c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build/fmt.pc
@@ -0,0 +1,11 @@
+prefix=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx
+exec_prefix=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx
+libdir=${exec_prefix}/lib64
+includedir=${prefix}/include
+
+Name: fmt
+Description: A modern formatting library
+Version: 10.2.1
+Libs: -L${libdir} -lfmt
+Cflags: -I${includedir}
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.clang-format b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.clang-format
new file mode 100644
index 0000000000000000000000000000000000000000..df55d340f018f5faae470f58fb06507148728e2c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.clang-format
@@ -0,0 +1,8 @@
+# Run manually to reformat a file:
+# clang-format -i --style=file <file>
+Language: Cpp
+BasedOnStyle: Google
+IndentPPDirectives: AfterHash
+IndentCaseLabels: false
+AlwaysBreakTemplateDeclarations: false
+DerivePointerAlignment: false
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/dependabot.yml b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/dependabot.yml
new file mode 100644
index 0000000000000000000000000000000000000000..55c156a6a7c1f982b7bbd2479ad6b79618aae26e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/dependabot.yml
@@ -0,0 +1,8 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions" # Necessary to update action hashs	
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    # Allow up to 3 opened pull requests for github-actions versions
+    open-pull-requests-limit: 3
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/issue_template.md b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/issue_template.md
new file mode 100644
index 0000000000000000000000000000000000000000..8e39c5ba749fbd194cb420cc3f783764660cb8d2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/issue_template.md
@@ -0,0 +1,6 @@
+<!--
+Please make sure that the problem reproduces on the current master before
+submitting an issue.
+If possible please provide a repro on Compiler Explorer:
+https://godbolt.org/z/fxccbh53W.
+-->
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/pull_request_template.md b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/pull_request_template.md
new file mode 100644
index 0000000000000000000000000000000000000000..e877413390f2d0e0ac0029801c7d59b7ea6c3ffa
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/pull_request_template.md
@@ -0,0 +1,7 @@
+<!--
+Please read the contribution guidelines before submitting a pull request:
+https://github.com/fmtlib/fmt/blob/master/CONTRIBUTING.md.
+By submitting this pull request, you agree to license your contribution(s)
+under the terms outlined in LICENSE.rst and represent that you have the right
+to do so.
+-->
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/cifuzz.yml b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/cifuzz.yml
new file mode 100644
index 0000000000000000000000000000000000000000..25250e8b83f3753fe711ef52eb2fcbb63af72702
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/cifuzz.yml
@@ -0,0 +1,30 @@
+name: CIFuzz
+on: [pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  Fuzzing:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Build Fuzzers
+      id: build
+      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@061583ebb5a96653e42feb3a97ee513eedc18078 # master
+      with:
+        oss-fuzz-project-name: 'fmt'
+        dry-run: false
+        language: c++
+    - name: Run Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@061583ebb5a96653e42feb3a97ee513eedc18078 # master
+      with:
+        oss-fuzz-project-name: 'fmt'
+        fuzz-seconds: 300
+        dry-run: false
+        language: c++
+    - name: Upload Crash
+      uses: actions/upload-artifact@c7d193f32edcb7bfad88892161225aeda64e9392 # v4.0.0
+      if: failure() && steps.build.outcome == 'success'
+      with:
+        name: artifacts
+        path: ./out/artifacts
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/doc.yml b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/doc.yml
new file mode 100644
index 0000000000000000000000000000000000000000..4055b9f38007ecd90581507a75438bd7a068b443
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/doc.yml
@@ -0,0 +1,35 @@
+name: doc
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    # Use Ubuntu 20.04 because doxygen 1.8.13 from Ubuntu 18.04 is broken.
+    runs-on: ubuntu-20.04
+
+    steps:
+    - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+
+    - name: Add ubuntu mirrors
+      run: |
+        # Github Actions caching proxy is at times unreliable
+        # see https://github.com/actions/runner-images/issues/7048
+        printf 'http://azure.archive.ubuntu.com/ubuntu\tpriority:1\n' | sudo tee /etc/apt/mirrors.txt
+        curl http://mirrors.ubuntu.com/mirrors.txt | sudo tee --append /etc/apt/mirrors.txt
+        sudo sed -i 's~http://azure.archive.ubuntu.com/ubuntu/~mirror+file:/etc/apt/mirrors.txt~' /etc/apt/sources.list
+
+    - name: Create Build Environment
+      run: |
+        sudo apt update
+        sudo apt install doxygen python3-virtualenv
+        sudo npm install -g less clean-css
+        cmake -E make_directory ${{runner.workspace}}/build
+
+    - name: Build
+      working-directory: ${{runner.workspace}}/build
+      env:
+        KEY: ${{secrets.KEY}}
+      run: $GITHUB_WORKSPACE/support/build-docs.py
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/lint.yml b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/lint.yml
new file mode 100644
index 0000000000000000000000000000000000000000..b906fac275a5ab7eb5050a90b832e9ba47088733
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/lint.yml
@@ -0,0 +1,26 @@
+name: lint
+
+on:
+  pull_request:
+    paths:
+      - '**.h'
+      - '**.cc'
+
+permissions:
+  contents: read
+
+jobs:
+  format_code:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install clang-format
+      uses: aminya/setup-cpp@v1
+      with:
+        clangformat: 17.0.5
+
+    - name: Run clang-format
+      run: |
+        find include src -name '*.h' -o -name '*.cc' |  xargs clang-format -i -style=file -fallback-style=none
+        git diff --exit-code
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/linux.yml b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/linux.yml
new file mode 100644
index 0000000000000000000000000000000000000000..0f30ba63c148e43e1a91776e370868df631e3c49
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/linux.yml
@@ -0,0 +1,111 @@
+name: linux
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-20.04
+    strategy:
+      matrix:
+        cxx: [g++-4.8, g++-10, clang++-9]
+        build_type: [Debug, Release]
+        std: [11]
+        include:
+          - cxx: g++-4.8
+            install: sudo apt install g++-4.8
+          - cxx: g++-8
+            build_type: Debug
+            std: 14
+            install: sudo apt install g++-8
+          - cxx: g++-8
+            build_type: Debug
+            std: 17
+            install: sudo apt install g++-8
+          - cxx: g++-9
+            build_type: Debug
+            std: 17
+          - cxx: g++-10
+            build_type: Debug
+            std: 17
+          - cxx: g++-11
+            build_type: Debug
+            std: 20
+            install: sudo apt install g++-11
+          - cxx: clang++-8
+            build_type: Debug
+            std: 17
+            cxxflags: -stdlib=libc++
+            install: sudo apt install clang-8 libc++-8-dev libc++abi-8-dev
+          - cxx: clang++-9
+            install: sudo apt install clang-9
+          - cxx: clang++-9
+            build_type: Debug
+            fuzz: -DFMT_FUZZ=ON -DFMT_FUZZ_LINKMAIN=ON
+            std: 17
+            install: sudo apt install clang-9
+          - cxx: clang++-11
+            build_type: Debug
+            std: 20
+          - cxx: clang++-11
+            build_type: Debug
+            std: 20
+            cxxflags: -stdlib=libc++
+            install: sudo apt install libc++-11-dev libc++abi-11-dev
+          - shared: -DBUILD_SHARED_LIBS=ON
+
+    steps:
+    - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+
+    - name: Set timezone
+      run: sudo timedatectl set-timezone 'Asia/Yekaterinburg'
+
+    - name: Add repositories for older GCC
+      run: |
+        # Below two repos provide GCC 4.8, 5.5 and 6.4
+        sudo apt-add-repository 'deb http://azure.archive.ubuntu.com/ubuntu/ bionic main'
+        sudo apt-add-repository 'deb http://azure.archive.ubuntu.com/ubuntu/ bionic universe'
+        # Below two repos additionally update GCC 6 to 6.5
+        # sudo apt-add-repository 'deb http://azure.archive.ubuntu.com/ubuntu/ bionic-updates main'
+        # sudo apt-add-repository 'deb http://azure.archive.ubuntu.com/ubuntu/ bionic-updates universe'
+      if: ${{ matrix.cxx == 'g++-4.8' }}
+
+    - name: Add ubuntu mirrors
+      run: |
+        # Github Actions caching proxy is at times unreliable
+        # see https://github.com/actions/runner-images/issues/7048
+        printf 'http://azure.archive.ubuntu.com/ubuntu\tpriority:1\n' | sudo tee /etc/apt/mirrors.txt
+        curl http://mirrors.ubuntu.com/mirrors.txt | sudo tee --append /etc/apt/mirrors.txt
+        sudo sed -i 's~http://azure.archive.ubuntu.com/ubuntu/~mirror+file:/etc/apt/mirrors.txt~' /etc/apt/sources.list
+
+    - name: Create Build Environment
+      run: |
+        sudo apt update
+        ${{matrix.install}}
+        sudo apt install locales-all
+        cmake -E make_directory ${{runner.workspace}}/build
+
+    - name: Configure
+      working-directory: ${{runner.workspace}}/build
+      env:
+        CXX: ${{matrix.cxx}}
+        CXXFLAGS: ${{matrix.cxxflags}}
+      run: |
+        cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} ${{matrix.fuzz}} ${{matrix.shared}} \
+              -DCMAKE_CXX_STANDARD=${{matrix.std}} -DFMT_DOC=OFF \
+              -DCMAKE_CXX_VISIBILITY_PRESET=hidden -DCMAKE_VISIBILITY_INLINES_HIDDEN=ON \
+              -DFMT_PEDANTIC=ON -DFMT_WERROR=ON $GITHUB_WORKSPACE
+
+    - name: Build
+      working-directory: ${{runner.workspace}}/build
+      run: |
+        threads=`nproc`
+        cmake --build . --config ${{matrix.build_type}} --parallel $threads
+
+    - name: Test
+      working-directory: ${{runner.workspace}}/build
+      run: ctest -C ${{matrix.build_type}}
+      env:
+        CTEST_OUTPUT_ON_FAILURE: True
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/macos.yml b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/macos.yml
new file mode 100644
index 0000000000000000000000000000000000000000..48d179f6cbcb5d2fa461a24cda958d9d5731a3c8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/macos.yml
@@ -0,0 +1,55 @@
+name: macos
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [macos-11, macos-13]
+        build_type: [Debug, Release]
+        std: [11, 17, 20]
+        exclude:
+          - { os: macos-11, std: 20 }
+          - { os: macos-13, std: 11 }
+          - { os: macos-13, std: 17 }
+        include:
+          - shared: -DBUILD_SHARED_LIBS=ON
+
+    runs-on: '${{ matrix.os }}'
+
+    steps:
+    - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+
+    - name: Set timezone
+      run: sudo systemsetup -settimezone 'Asia/Yekaterinburg'
+
+    - name: Select Xcode 14.3 (macOS 13)
+      run: sudo xcode-select -s "/Applications/Xcode_14.3.app"
+      if: ${{ matrix.os == 'macos-13' }}
+
+    - name: Create Build Environment
+      run: cmake -E make_directory ${{runner.workspace}}/build
+
+    - name: Configure
+      working-directory: ${{runner.workspace}}/build
+      run: |
+        cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} ${{matrix.shared}} \
+              -DCMAKE_CXX_STANDARD=${{matrix.std}} \
+              -DCMAKE_CXX_VISIBILITY_PRESET=hidden -DCMAKE_VISIBILITY_INLINES_HIDDEN=ON \
+              -DFMT_DOC=OFF -DFMT_PEDANTIC=ON -DFMT_WERROR=ON $GITHUB_WORKSPACE
+
+    - name: Build
+      working-directory: ${{runner.workspace}}/build
+      run: |
+        threads=`sysctl -n hw.logicalcpu`
+        cmake --build . --config ${{matrix.build_type}} --parallel $threads
+
+    - name: Test
+      working-directory: ${{runner.workspace}}/build
+      run: ctest -C ${{matrix.build_type}}
+      env:
+        CTEST_OUTPUT_ON_FAILURE: True
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/scorecard.yml b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/scorecard.yml
new file mode 100644
index 0000000000000000000000000000000000000000..c5f2ea9d5234f3870e20132bd9bf9e7df0a12691
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/scorecard.yml
@@ -0,0 +1,65 @@
+# This workflow uses actions that are not certified by GitHub. They are provided
+# by a third-party and are governed by separate terms of service, privacy
+# policy, and support documentation.
+
+name: Scorecard supply-chain security
+on:
+  # For Branch-Protection check. Only the default branch is supported. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
+  branch_protection_rule:
+  # To guarantee Maintained check is occasionally updated. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained
+  schedule:
+    - cron: '26 14 * * 5'
+  push:
+    branches: [ "master" ]
+
+# Declare default permissions as read only.
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecard analysis
+    runs-on: ubuntu-latest
+    permissions:
+      # Needed to upload the results to code-scanning dashboard.
+      security-events: write
+      # Needed to publish results and get a badge (see publish_results below).
+      id-token: write
+
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@0864cf19026789058feabb7e87baa5f140aac736 # v2.3.1
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          # (Optional) "write" PAT token. Uncomment the `repo_token` line below if:
+          # - you want to enable the Branch-Protection check on a *public* repository, or
+          # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action#authentication-with-pat.
+          # repo_token: ${{ secrets.SCORECARD_TOKEN }}
+
+          # Public repositories:
+          #   - Publish results to OpenSSF REST API for easy access by consumers
+          #   - Allows the repository to include the Scorecard badge.
+          #   - See https://github.com/ossf/scorecard-action#publishing-results.
+          publish_results: true
+
+      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
+      # format to the repository Actions tab.
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@c7d193f32edcb7bfad88892161225aeda64e9392 # v4.0.0
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      # Upload the results to GitHub's code scanning dashboard.
+      - name: "Upload to code-scanning"
+        uses: github/codeql-action/upload-sarif@74483a38d39275f33fcff5f35b679b5ca4a26a99 # v2.22.5
+        with:
+          sarif_file: results.sarif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/windows.yml b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/windows.yml
new file mode 100644
index 0000000000000000000000000000000000000000..d576abb1ae9775d96c5984f537e6d2aca96946e8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.github/workflows/windows.yml
@@ -0,0 +1,100 @@
+name: windows
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ${{matrix.os}}
+    strategy:
+      matrix:
+        # windows-2019 has MSVC 2019 installed;
+        # windows-2022 has MSVC 2022 installed:
+        # https://github.com/actions/virtual-environments.
+        os: [windows-2019]
+        platform: [Win32, x64]
+        toolset: [v140, v141, v142]
+        standard: [14, 17, 20]
+        shared: ["", -DBUILD_SHARED_LIBS=ON]
+        build_type: [Debug, Release]
+        exclude:
+          - { toolset: v140, standard: 17 }
+          - { toolset: v140, standard: 20 }
+          - { toolset: v141, standard: 14 }
+          - { toolset: v141, standard: 20 }
+          - { toolset: v142, standard: 14 }
+          - { platform: Win32, toolset: v140 }
+          - { platform: Win32, toolset: v141 }
+          - { platform: Win32, standard: 14 }
+          - { platform: Win32, standard: 20 }
+          - { platform: x64, toolset: v140, shared: -DBUILD_SHARED_LIBS=ON }
+          - { platform: x64, toolset: v141, shared: -DBUILD_SHARED_LIBS=ON }
+          - { platform: x64, standard: 14, shared: -DBUILD_SHARED_LIBS=ON }
+          - { platform: x64, standard: 20, shared: -DBUILD_SHARED_LIBS=ON }
+        include:
+          - os: windows-2022
+            platform: x64
+            toolset: v143
+            build_type: Debug
+            standard: 20
+
+    steps:
+    - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+
+    - name: Set timezone
+      run: tzutil /s "Ekaterinburg Standard Time"
+
+    - name: Create Build Environment
+      run: cmake -E make_directory ${{runner.workspace}}/build
+
+    - name: Configure
+      # Use a bash shell for $GITHUB_WORKSPACE.
+      shell: bash
+      working-directory: ${{runner.workspace}}/build
+      run: |
+        cmake -A ${{matrix.platform}} -T ${{matrix.toolset}} \
+              -DCMAKE_CXX_STANDARD=${{matrix.standard}} \
+              ${{matrix.shared}} -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
+              $GITHUB_WORKSPACE
+
+    - name: Build
+      working-directory: ${{runner.workspace}}/build
+      run: |
+        $threads = (Get-CimInstance Win32_ComputerSystem).NumberOfLogicalProcessors
+        cmake --build . --config ${{matrix.build_type}} --parallel $threads
+
+    - name: Test
+      working-directory: ${{runner.workspace}}/build
+      run: ctest -C ${{matrix.build_type}} -V
+      env:
+        CTEST_OUTPUT_ON_FAILURE: True
+
+  mingw:
+    runs-on: windows-latest
+    defaults:
+      run:
+        shell: msys2 {0}
+    strategy:
+      matrix:
+        sys: [ mingw64, ucrt64 ]
+    steps:
+    - name: Set timezone
+      run: tzutil /s "Ekaterinburg Standard Time"
+      shell: cmd
+    - uses: msys2/setup-msys2@7efe20baefed56359985e327d329042cde2434ff # v2
+      with:
+        release: false
+        msystem: ${{matrix.sys}}
+        pacboy: cc:p cmake:p ninja:p lld:p
+    - uses: actions/checkout@8ade135a41bc03ea155e62e844d188df1ea18608 # v4.1.0
+    - name: Configure
+      run: cmake -B ../build -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE=Debug
+      env: { LDFLAGS: -fuse-ld=lld }
+    - name: Build
+      run: cmake --build ../build
+    - name: Test
+      run: ctest -j `nproc` --test-dir ../build
+      env:
+        CTEST_OUTPUT_ON_FAILURE: True
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.gitignore b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..1406ac347ff67e6a9d43d5906a75ada27c81274a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/.gitignore
@@ -0,0 +1,24 @@
+*.a
+*.so*
+*.xcodeproj
+*~
+.vscode/
+/CMakeScripts
+/Testing
+/_CPack_Packages
+/doc/doxyxml
+/doc/html
+/doc/node_modules
+/install_manifest.txt
+CMakeCache.txt
+CMakeFiles
+CPack*.cmake
+CTestTestfile.cmake
+FMT.build
+Makefile
+bin/
+build/
+cmake_install.cmake
+fmt-*.cmake
+fmt.pc
+virtualenv
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4b928ae35c3e43bea2952a1379ab1c06d2b6ef48
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/CMakeLists.txt
@@ -0,0 +1,453 @@
+cmake_minimum_required(VERSION 3.8...3.26)
+
+# Fallback for using newer policies on CMake <3.12.
+if (${CMAKE_VERSION} VERSION_LESS 3.12)
+  cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
+endif ()
+
+# Determine if fmt is built as a subproject (using add_subdirectory)
+# or if it is the master project.
+if (NOT DEFINED FMT_MASTER_PROJECT)
+  set(FMT_MASTER_PROJECT OFF)
+  if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    set(FMT_MASTER_PROJECT ON)
+    message(STATUS "CMake version: ${CMAKE_VERSION}")
+  endif ()
+endif ()
+
+# Joins arguments and places the results in ${result_var}.
+function(join result_var)
+  set(result "")
+  foreach (arg ${ARGN})
+    set(result "${result}${arg}")
+  endforeach ()
+  set(${result_var} "${result}" PARENT_SCOPE)
+endfunction()
+
+# DEPRECATED! Should be merged into add_module_library.
+function(enable_module target)
+  if (MSVC)
+    set(BMI ${CMAKE_CURRENT_BINARY_DIR}/${target}.ifc)
+    target_compile_options(${target}
+      PRIVATE /interface /ifcOutput ${BMI}
+      INTERFACE /reference fmt=${BMI})
+    set_target_properties(${target} PROPERTIES ADDITIONAL_CLEAN_FILES ${BMI})
+    set_source_files_properties(${BMI} PROPERTIES GENERATED ON)
+  endif ()
+endfunction()
+
+# Adds a library compiled with C++20 module support.
+# `enabled` is a CMake variables that specifies if modules are enabled.
+# If modules are disabled `add_module_library` falls back to creating a
+# non-modular library.
+#
+# Usage:
+#   add_module_library(<name> [sources...] FALLBACK [sources...] [IF enabled])
+function(add_module_library name)
+  cmake_parse_arguments(AML "" "IF" "FALLBACK" ${ARGN})
+  set(sources ${AML_UNPARSED_ARGUMENTS})
+
+  add_library(${name})
+  set_target_properties(${name} PROPERTIES LINKER_LANGUAGE CXX)
+
+  if (NOT ${${AML_IF}})
+    # Create a non-modular library.
+    target_sources(${name} PRIVATE ${AML_FALLBACK})
+    return()
+  endif ()
+
+  # Modules require C++20.
+  target_compile_features(${name} PUBLIC cxx_std_20)
+  if (CMAKE_COMPILER_IS_GNUCXX)
+    target_compile_options(${name} PUBLIC -fmodules-ts)
+  endif ()
+
+  # `std` is affected by CMake options and may be higher than C++20.
+  get_target_property(std ${name} CXX_STANDARD)
+
+  if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    set(pcms)
+    foreach (src ${sources})
+      get_filename_component(pcm ${src} NAME_WE)
+      set(pcm ${pcm}.pcm)
+
+      # Propagate -fmodule-file=*.pcm to targets that link with this library.
+      target_compile_options(
+        ${name} PUBLIC -fmodule-file=${CMAKE_CURRENT_BINARY_DIR}/${pcm})
+
+      # Use an absolute path to prevent target_link_libraries prepending -l
+      # to it.
+      set(pcms ${pcms} ${CMAKE_CURRENT_BINARY_DIR}/${pcm})
+      add_custom_command(
+        OUTPUT ${pcm}
+        COMMAND ${CMAKE_CXX_COMPILER}
+                -std=c++${std} -x c++-module --precompile -c
+                -o ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
+                "-I$<JOIN:$<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>,;-I>"
+        # Required by the -I generator expression above.
+        COMMAND_EXPAND_LISTS
+        DEPENDS ${src})
+    endforeach ()
+
+    # Add .pcm files as sources to make sure they are built before the library.
+    set(sources)
+    foreach (pcm ${pcms})
+      get_filename_component(pcm_we ${pcm} NAME_WE)
+      set(obj ${pcm_we}.o)
+      # Use an absolute path to prevent target_link_libraries prepending -l.
+      set(sources ${sources} ${pcm} ${CMAKE_CURRENT_BINARY_DIR}/${obj})
+      add_custom_command(
+        OUTPUT ${obj}
+        COMMAND ${CMAKE_CXX_COMPILER} $<TARGET_PROPERTY:${name},COMPILE_OPTIONS>
+                -c -o ${obj} ${pcm}
+        DEPENDS ${pcm})
+    endforeach ()
+  endif ()
+  target_sources(${name} PRIVATE ${sources})
+endfunction()
+
+include(CMakeParseArguments)
+
+# Sets a cache variable with a docstring joined from multiple arguments:
+#   set(<variable> <value>... CACHE <type> <docstring>...)
+# This allows splitting a long docstring for readability.
+function(set_verbose)
+  # cmake_parse_arguments is broken in CMake 3.4 (cannot parse CACHE) so use
+  # list instead.
+  list(GET ARGN 0 var)
+  list(REMOVE_AT ARGN 0)
+  list(GET ARGN 0 val)
+  list(REMOVE_AT ARGN 0)
+  list(REMOVE_AT ARGN 0)
+  list(GET ARGN 0 type)
+  list(REMOVE_AT ARGN 0)
+  join(doc ${ARGN})
+  set(${var} ${val} CACHE ${type} ${doc})
+endfunction()
+
+# Set the default CMAKE_BUILD_TYPE to Release.
+# This should be done before the project command since the latter can set
+# CMAKE_BUILD_TYPE itself (it does so for nmake).
+if (FMT_MASTER_PROJECT AND NOT CMAKE_BUILD_TYPE)
+  set_verbose(CMAKE_BUILD_TYPE Release CACHE STRING
+              "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or "
+              "CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
+endif ()
+
+project(FMT CXX)
+include(GNUInstallDirs)
+set_verbose(FMT_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE STRING
+            "Installation directory for include files, a relative path that "
+            "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute path.")
+
+option(FMT_PEDANTIC "Enable extra warnings and expensive tests." OFF)
+option(FMT_WERROR "Halt the compilation with an error on compiler warnings."
+       OFF)
+
+# Options that control generation of various targets.
+option(FMT_DOC "Generate the doc target." ${FMT_MASTER_PROJECT})
+option(FMT_INSTALL "Generate the install target." ON)
+option(FMT_TEST "Generate the test target." ${FMT_MASTER_PROJECT})
+option(FMT_FUZZ "Generate the fuzz target." OFF)
+option(FMT_CUDA_TEST "Generate the cuda-test target." OFF)
+option(FMT_OS "Include core requiring OS (Windows/Posix) " ON)
+option(FMT_MODULE "Build a module instead of a traditional library." OFF)
+option(FMT_SYSTEM_HEADERS "Expose headers with marking them as system." OFF)
+
+if (FMT_TEST AND FMT_MODULE)
+  # The tests require {fmt} to be compiled as traditional library
+  message(STATUS "Testing is incompatible with build mode 'module'.")
+endif ()
+set(FMT_SYSTEM_HEADERS_ATTRIBUTE "")
+if (FMT_SYSTEM_HEADERS)
+  set(FMT_SYSTEM_HEADERS_ATTRIBUTE SYSTEM)
+endif ()
+if (CMAKE_SYSTEM_NAME STREQUAL "MSDOS")
+  set(FMT_TEST OFF)
+  message(STATUS "MSDOS is incompatible with gtest")
+endif ()
+
+# Get version from core.h
+file(READ include/fmt/core.h core_h)
+if (NOT core_h MATCHES "FMT_VERSION ([0-9]+)([0-9][0-9])([0-9][0-9])")
+  message(FATAL_ERROR "Cannot get FMT_VERSION from core.h.")
+endif ()
+# Use math to skip leading zeros if any.
+math(EXPR CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
+math(EXPR CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
+math(EXPR CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
+join(FMT_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.
+                 ${CPACK_PACKAGE_VERSION_PATCH})
+message(STATUS "Version: ${FMT_VERSION}")
+
+message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
+
+if (NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
+  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin)
+endif ()
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
+  "${CMAKE_CURRENT_SOURCE_DIR}/support/cmake")
+
+include(CheckCXXCompilerFlag)
+include(JoinPaths)
+
+if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
+  set_verbose(CMAKE_CXX_VISIBILITY_PRESET hidden CACHE STRING
+              "Preset for the export of private symbols")
+  set_property(CACHE CMAKE_CXX_VISIBILITY_PRESET PROPERTY STRINGS
+               hidden default)
+endif ()
+
+if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_VISIBILITY_INLINES_HIDDEN)
+  set_verbose(CMAKE_VISIBILITY_INLINES_HIDDEN ON CACHE BOOL
+              "Whether to add a compile flag to hide symbols of inline functions")
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+  set(PEDANTIC_COMPILE_FLAGS -pedantic-errors -Wall -Wextra -pedantic
+      -Wold-style-cast -Wundef
+      -Wredundant-decls -Wwrite-strings -Wpointer-arith
+      -Wcast-qual -Wformat=2 -Wmissing-include-dirs
+      -Wcast-align
+      -Wctor-dtor-privacy -Wdisabled-optimization
+      -Winvalid-pch -Woverloaded-virtual
+      -Wconversion -Wundef
+      -Wno-ctor-dtor-privacy -Wno-format-nonliteral)
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
+      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
+         -Wno-dangling-else -Wno-unused-local-typedefs)
+  endif ()
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
+      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wdouble-promotion
+          -Wtrampolines -Wzero-as-null-pointer-constant -Wuseless-cast
+          -Wvector-operation-performance -Wsized-deallocation -Wshadow)
+  endif ()
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.0)
+      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wshift-overflow=2
+          -Wnull-dereference -Wduplicated-cond)
+  endif ()
+  set(WERROR_FLAG -Werror)
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -pedantic -Wconversion -Wundef
+      -Wdeprecated -Wweak-vtables -Wshadow
+      -Wno-gnu-zero-variadic-macro-arguments)
+  check_cxx_compiler_flag(-Wzero-as-null-pointer-constant HAS_NULLPTR_WARNING)
+  if (HAS_NULLPTR_WARNING)
+    set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
+        -Wzero-as-null-pointer-constant)
+  endif ()
+  set(WERROR_FLAG -Werror)
+endif ()
+
+if (MSVC)
+  set(PEDANTIC_COMPILE_FLAGS /W3)
+  set(WERROR_FLAG /WX)
+endif ()
+
+if (FMT_MASTER_PROJECT AND CMAKE_GENERATOR MATCHES "Visual Studio")
+  # If Microsoft SDK is installed create script run-msbuild.bat that
+  # calls SetEnv.cmd to set up build environment and runs msbuild.
+  # It is useful when building Visual Studio projects with the SDK
+  # toolchain rather than Visual Studio.
+  include(FindSetEnv)
+  if (WINSDK_SETENV)
+    set(MSBUILD_SETUP "call \"${WINSDK_SETENV}\"")
+  endif ()
+  # Set FrameworkPathOverride to get rid of MSB3644 warnings.
+  join(netfxpath
+       "C:\\Program Files\\Reference Assemblies\\Microsoft\\Framework\\"
+       ".NETFramework\\v4.0")
+  file(WRITE run-msbuild.bat "
+    ${MSBUILD_SETUP}
+    ${CMAKE_MAKE_PROGRAM} -p:FrameworkPathOverride=\"${netfxpath}\" %*")
+endif ()
+
+function(add_headers VAR)
+  set(headers ${${VAR}})
+  foreach (header ${ARGN})
+    set(headers ${headers} include/fmt/${header})
+  endforeach()
+  set(${VAR} ${headers} PARENT_SCOPE)
+endfunction()
+
+# Define the fmt library, its includes and the needed defines.
+add_headers(FMT_HEADERS args.h chrono.h color.h compile.h core.h format.h
+                        format-inl.h os.h ostream.h printf.h ranges.h std.h
+                        xchar.h)
+set(FMT_SOURCES src/format.cc)
+if (FMT_OS)
+  set(FMT_SOURCES ${FMT_SOURCES} src/os.cc)
+endif ()
+
+add_module_library(fmt src/fmt.cc FALLBACK
+                   ${FMT_SOURCES} ${FMT_HEADERS} README.md ChangeLog.md
+                   IF FMT_MODULE)
+add_library(fmt::fmt ALIAS fmt)
+if (FMT_MODULE)
+  enable_module(fmt)
+endif ()
+
+if (FMT_WERROR)
+  target_compile_options(fmt PRIVATE ${WERROR_FLAG})
+endif ()
+if (FMT_PEDANTIC)
+  target_compile_options(fmt PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+endif ()
+
+if (cxx_std_11 IN_LIST CMAKE_CXX_COMPILE_FEATURES)
+  target_compile_features(fmt PUBLIC cxx_std_11)
+else ()
+  message(WARNING "Feature cxx_std_11 is unknown for the CXX compiler")
+endif ()
+
+target_include_directories(fmt ${FMT_SYSTEM_HEADERS_ATTRIBUTE} PUBLIC
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)
+
+set(FMT_DEBUG_POSTFIX d CACHE STRING "Debug library postfix.")
+
+set_target_properties(fmt PROPERTIES
+  VERSION ${FMT_VERSION} SOVERSION ${CPACK_PACKAGE_VERSION_MAJOR}
+  PUBLIC_HEADER "${FMT_HEADERS}"
+  DEBUG_POSTFIX "${FMT_DEBUG_POSTFIX}"
+
+  # Workaround for Visual Studio 2017:
+  # Ensure the .pdb is created with the same name and in the same directory
+  # as the .lib. Newer VS versions already do this by default, but there is no
+  # harm in setting it for those too. Ignored by other generators.
+  COMPILE_PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+  COMPILE_PDB_NAME "fmt"
+  COMPILE_PDB_NAME_DEBUG "fmt${FMT_DEBUG_POSTFIX}")
+
+# Set FMT_LIB_NAME for pkg-config fmt.pc. We cannot use the OUTPUT_NAME target
+# property because it's not set by default.
+set(FMT_LIB_NAME fmt)
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+  set(FMT_LIB_NAME ${FMT_LIB_NAME}${FMT_DEBUG_POSTFIX})
+endif ()
+
+if (BUILD_SHARED_LIBS)
+  target_compile_definitions(fmt PRIVATE FMT_LIB_EXPORT INTERFACE FMT_SHARED)
+endif ()
+if (FMT_SAFE_DURATION_CAST)
+  target_compile_definitions(fmt PUBLIC FMT_SAFE_DURATION_CAST)
+endif ()
+
+add_library(fmt-header-only INTERFACE)
+add_library(fmt::fmt-header-only ALIAS fmt-header-only)
+
+target_compile_definitions(fmt-header-only INTERFACE FMT_HEADER_ONLY=1)
+target_compile_features(fmt-header-only INTERFACE cxx_std_11)
+
+target_include_directories(fmt-header-only
+  ${FMT_SYSTEM_HEADERS_ATTRIBUTE} INTERFACE
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)
+
+# Install targets.
+if (FMT_INSTALL)
+  include(CMakePackageConfigHelpers)
+  set_verbose(FMT_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/fmt CACHE STRING
+              "Installation directory for cmake files, a relative path that "
+              "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute "
+              "path.")
+  set(version_config ${PROJECT_BINARY_DIR}/fmt-config-version.cmake)
+  set(project_config ${PROJECT_BINARY_DIR}/fmt-config.cmake)
+  set(pkgconfig ${PROJECT_BINARY_DIR}/fmt.pc)
+  set(targets_export_name fmt-targets)
+
+  set_verbose(FMT_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE STRING
+              "Installation directory for libraries, a relative path that "
+              "will be joined to ${CMAKE_INSTALL_PREFIX} or an absolute path.")
+
+  set_verbose(FMT_PKGCONFIG_DIR ${CMAKE_INSTALL_LIBDIR}/pkgconfig CACHE STRING
+              "Installation directory for pkgconfig (.pc) files, a relative "
+              "path that will be joined with ${CMAKE_INSTALL_PREFIX} or an "
+              "absolute path.")
+
+  # Generate the version, config and target files into the build directory.
+  write_basic_package_version_file(
+    ${version_config}
+    VERSION ${FMT_VERSION}
+    COMPATIBILITY AnyNewerVersion)
+
+  join_paths(libdir_for_pc_file "\${exec_prefix}" "${FMT_LIB_DIR}")
+  join_paths(includedir_for_pc_file "\${prefix}" "${FMT_INC_DIR}")
+
+  configure_file(
+    "${PROJECT_SOURCE_DIR}/support/cmake/fmt.pc.in"
+    "${pkgconfig}"
+    @ONLY)
+  configure_package_config_file(
+    ${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in
+    ${project_config}
+    INSTALL_DESTINATION ${FMT_CMAKE_DIR})
+
+  set(INSTALL_TARGETS fmt fmt-header-only)
+
+  # Install the library and headers.
+  install(TARGETS ${INSTALL_TARGETS} EXPORT ${targets_export_name}
+          LIBRARY DESTINATION ${FMT_LIB_DIR}
+          ARCHIVE DESTINATION ${FMT_LIB_DIR}
+          PUBLIC_HEADER DESTINATION "${FMT_INC_DIR}/fmt"
+          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+  # Use a namespace because CMake provides better diagnostics for namespaced
+  # imported targets.
+  export(TARGETS ${INSTALL_TARGETS} NAMESPACE fmt::
+         FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)
+
+  # Install version, config and target files.
+  install(
+    FILES ${project_config} ${version_config}
+    DESTINATION ${FMT_CMAKE_DIR})
+  install(EXPORT ${targets_export_name} DESTINATION ${FMT_CMAKE_DIR}
+          NAMESPACE fmt::)
+
+  install(FILES "${pkgconfig}" DESTINATION "${FMT_PKGCONFIG_DIR}")
+endif ()
+
+if (FMT_DOC)
+  add_subdirectory(doc)
+endif ()
+
+if (FMT_TEST)
+  enable_testing()
+  add_subdirectory(test)
+endif ()
+
+# Control fuzzing independent of the unit tests.
+if (FMT_FUZZ)
+  add_subdirectory(test/fuzzing)
+
+  # The FMT_FUZZ macro is used to prevent resource exhaustion in fuzzing
+  # mode and make fuzzing practically possible. It is similar to
+  # FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION but uses a different name to
+  # avoid interfering with fuzzing of projects that use {fmt}.
+  # See also https://llvm.org/docs/LibFuzzer.html#fuzzer-friendly-build-mode.
+  target_compile_definitions(fmt PUBLIC FMT_FUZZ)
+endif ()
+
+set(gitignore ${PROJECT_SOURCE_DIR}/.gitignore)
+if (FMT_MASTER_PROJECT AND EXISTS ${gitignore})
+  # Get the list of ignored files from .gitignore.
+  file (STRINGS ${gitignore} lines)
+  list(REMOVE_ITEM lines /doc/html)
+  foreach (line ${lines})
+    string(REPLACE "." "[.]" line "${line}")
+    string(REPLACE "*" ".*" line "${line}")
+    set(ignored_files ${ignored_files} "${line}$" "${line}/")
+  endforeach ()
+  set(ignored_files ${ignored_files}
+    /.git /breathe /format-benchmark sphinx/ .buildinfo .doctrees)
+
+  set(CPACK_SOURCE_GENERATOR ZIP)
+  set(CPACK_SOURCE_IGNORE_FILES ${ignored_files})
+  set(CPACK_SOURCE_PACKAGE_FILE_NAME fmt-${FMT_VERSION})
+  set(CPACK_PACKAGE_NAME fmt)
+  set(CPACK_RESOURCE_FILE_README ${PROJECT_SOURCE_DIR}/README.md)
+  include(CPack)
+endif ()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/CONTRIBUTING.md b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/CONTRIBUTING.md
new file mode 100644
index 0000000000000000000000000000000000000000..b82f145069a8c61601ce12604b00fd06a8050488
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/CONTRIBUTING.md
@@ -0,0 +1,20 @@
+Contributing to {fmt}
+=====================
+
+By submitting a pull request or a patch, you represent that you have the right
+to license your contribution to the {fmt} project owners and the community,
+agree that your contributions are licensed under the {fmt} license, and agree
+to future changes to the licensing.
+
+All C++ code must adhere to [Google C++ Style Guide](
+https://google.github.io/styleguide/cppguide.html) with the following
+exceptions:
+
+* Exceptions are permitted
+* snake_case should be used instead of UpperCamelCase for function and type
+  names
+
+All documentation must adhere to the [Google Developer Documentation Style
+Guide](https://developers.google.com/style).
+
+Thanks for contributing!
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/ChangeLog.md b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/ChangeLog.md
new file mode 100644
index 0000000000000000000000000000000000000000..515f9fdc1d90e941abc7c8cdb5b3bf187ce5694f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/ChangeLog.md
@@ -0,0 +1,5533 @@
+# 10.2.1 - 2024-01-03
+
+-   Fixed ABI compatibility with earlier 10.x versions
+    (https://github.com/fmtlib/fmt/pull/3786). Thanks @saraedum.
+
+# 10.2.0 - 2024-01-01
+
+-   Added support for the `%j` specifier (the number of days) for
+    `std::chrono::duration` (https://github.com/fmtlib/fmt/issues/3643,
+    https://github.com/fmtlib/fmt/pull/3732). Thanks @intelfx.
+
+-   Added support for the chrono suffix for days and changed
+    the suffix for minutes from "m" to the correct "min"
+    (https://github.com/fmtlib/fmt/issues/3662,
+    https://github.com/fmtlib/fmt/pull/3664).
+    For example ([godbolt](https://godbolt.org/z/9KhMnq9ba)):
+
+    ```c++
+    #include <fmt/chrono.h>
+
+    int main() {
+      fmt::print("{}\n", std::chrono::days(42)); // prints "42d"
+    }
+    ```
+
+    Thanks @Richardk2n.
+
+-   Fixed an overflow in `std::chrono::time_point` formatting with large dates
+    (https://github.com/fmtlib/fmt/issues/3725,
+    https://github.com/fmtlib/fmt/pull/3727). Thanks @cschreib.
+
+-   Added a formatter for `std::source_location`
+    (https://github.com/fmtlib/fmt/pull/3730).
+    For example ([godbolt](https://godbolt.org/z/YajfKjhhr)):
+
+    ```c++
+    #include <source_location>
+    #include <fmt/std.h>
+
+    int main() {
+      fmt::print("{}\n", std::source_location::current());
+    }
+    ```
+
+    prints
+
+    ```
+    /app/example.cpp:5:51: int main()
+    ```
+
+    Thanks @felix642.
+
+-   Added a formatter for `std::bitset`
+    (https://github.com/fmtlib/fmt/pull/3660).
+    For example ([godbolt](https://godbolt.org/z/bdEaGeYxe)):
+
+    ```c++
+    #include <bitset>
+    #include <fmt/std.h>
+
+    int main() {
+      fmt::print("{}\n", std::bitset<6>(42)); // prints "101010"
+    }
+    ```
+
+    Thanks @muggenhor.
+
+-   Added an experimental `nested_formatter` that provides an easy way of
+    applying a formatter to one or more subobjects while automatically handling
+    width, fill and alignment. For example:
+
+    ```c++
+    #include <fmt/format.h>
+
+    struct point {
+      double x, y;
+    };
+
+    template <>
+    struct fmt::formatter<point> : nested_formatter<double> {
+      auto format(point p, format_context& ctx) const {
+        return write_padded(ctx, [=](auto out) {
+          return format_to(out, "({}, {})", nested(p.x), nested(p.y));
+        });
+      }
+    };
+
+    int main() {
+      fmt::print("[{:>20.2f}]", point{1, 2});
+    }
+    ```
+
+    prints
+
+    ```
+    [          (1.00, 2.00)]
+    ```
+
+-   Added the generic representation (`g`) to `std::filesystem::path`
+    (https://github.com/fmtlib/fmt/issues/3715,
+    https://github.com/fmtlib/fmt/pull/3729). For example:
+
+    ```c++
+    #include <filesystem>
+    #include <fmt/std.h>
+
+    int main() {
+      fmt::print("{:g}\n", std::filesystem::path("C:\\foo"));
+    }
+    ```
+
+    prints `"C:/foo"` on Windows.
+
+    Thanks @js324.
+
+-   Made `format_as` work with references
+    (https://github.com/fmtlib/fmt/pull/3739). Thanks @tchaikov.
+
+-   Fixed formatting of invalid UTF-8 with precision
+    (https://github.com/fmtlib/fmt/issues/3284).
+
+-   Fixed an inconsistency between `fmt::to_string` and `fmt::format`
+    (https://github.com/fmtlib/fmt/issues/3684).
+
+-   Disallowed unsafe uses of `fmt::styled`
+    (https://github.com/fmtlib/fmt/issues/3625):
+
+    ```c++
+    auto s = fmt::styled(std::string("dangle"), fmt::emphasis::bold);
+    fmt::print("{}\n", s); // compile error
+    ```
+
+    Pass `fmt::styled(...)` as a parameter instead.
+
+-   Added a null check when formatting a C string with the `s` specifier
+    (https://github.com/fmtlib/fmt/issues/3706).
+
+-   Disallowed the `c` specifier for `bool`
+    (https://github.com/fmtlib/fmt/issues/3726,
+    https://github.com/fmtlib/fmt/pull/3734). Thanks @js324.
+
+-   Made the default formatting unlocalized in `fmt::ostream_formatter` for
+    consistency with the rest of the library
+    (https://github.com/fmtlib/fmt/issues/3460).
+
+-   Fixed localized formatting in bases other than decimal
+    (https://github.com/fmtlib/fmt/issues/3693,
+    https://github.com/fmtlib/fmt/pull/3750). Thanks @js324.
+
+-   Fixed a performance regression in experimental `fmt::ostream::print`
+    (https://github.com/fmtlib/fmt/issues/3674).
+
+-   Added synchronization with the underlying output stream when writing to
+    the Windows console
+    (https://github.com/fmtlib/fmt/pull/3668,
+    https://github.com/fmtlib/fmt/issues/3688,
+    https://github.com/fmtlib/fmt/pull/3689).
+    Thanks @Roman-Koshelev and @dimztimz.
+
+-   Changed to only export `format_error` when {fmt} is built as a shared
+    library (https://github.com/fmtlib/fmt/issues/3626,
+    https://github.com/fmtlib/fmt/pull/3627). Thanks @phprus.
+
+-   Made `fmt::streamed` `constexpr`.
+    (https://github.com/fmtlib/fmt/pull/3650). Thanks @muggenhor.
+
+-   Enabled `consteval` on older versions of MSVC
+    (https://github.com/fmtlib/fmt/pull/3757). Thanks @phprus.
+
+-   Added an option to build without `wchar_t` support on Windows
+    (https://github.com/fmtlib/fmt/issues/3631,
+    https://github.com/fmtlib/fmt/pull/3636). Thanks @glebm.
+
+-   Improved build and CI configuration
+    (https://github.com/fmtlib/fmt/pull/3679,
+    https://github.com/fmtlib/fmt/issues/3701,
+    https://github.com/fmtlib/fmt/pull/3702,
+    https://github.com/fmtlib/fmt/pull/3749).
+    Thanks @jcar87, @pklima and @tchaikov.
+
+-   Fixed various warnings, compilation and test issues
+    (https://github.com/fmtlib/fmt/issues/3607,
+    https://github.com/fmtlib/fmt/pull/3610,
+    https://github.com/fmtlib/fmt/pull/3624,
+    https://github.com/fmtlib/fmt/pull/3630,
+    https://github.com/fmtlib/fmt/pull/3634,
+    https://github.com/fmtlib/fmt/pull/3638,
+    https://github.com/fmtlib/fmt/issues/3645,
+    https://github.com/fmtlib/fmt/issues/3646,
+    https://github.com/fmtlib/fmt/pull/3647,
+    https://github.com/fmtlib/fmt/pull/3652,
+    https://github.com/fmtlib/fmt/issues/3654,
+    https://github.com/fmtlib/fmt/pull/3663,
+    https://github.com/fmtlib/fmt/issues/3670,
+    https://github.com/fmtlib/fmt/pull/3680,
+    https://github.com/fmtlib/fmt/issues/3694,
+    https://github.com/fmtlib/fmt/pull/3695,
+    https://github.com/fmtlib/fmt/pull/3699,
+    https://github.com/fmtlib/fmt/issues/3705,
+    https://github.com/fmtlib/fmt/issues/3710,
+    https://github.com/fmtlib/fmt/issues/3712,
+    https://github.com/fmtlib/fmt/pull/3713,
+    https://github.com/fmtlib/fmt/issues/3714,
+    https://github.com/fmtlib/fmt/pull/3716,
+    https://github.com/fmtlib/fmt/pull/3723,
+    https://github.com/fmtlib/fmt/issues/3738,
+    https://github.com/fmtlib/fmt/issues/3740,
+    https://github.com/fmtlib/fmt/pull/3741,
+    https://github.com/fmtlib/fmt/pull/3743,
+    https://github.com/fmtlib/fmt/issues/3745,
+    https://github.com/fmtlib/fmt/pull/3747,
+    https://github.com/fmtlib/fmt/pull/3748,
+    https://github.com/fmtlib/fmt/pull/3751,
+    https://github.com/fmtlib/fmt/pull/3754,
+    https://github.com/fmtlib/fmt/pull/3755,
+    https://github.com/fmtlib/fmt/issues/3760,
+    https://github.com/fmtlib/fmt/pull/3762,
+    https://github.com/fmtlib/fmt/issues/3763,
+    https://github.com/fmtlib/fmt/pull/3764,
+    https://github.com/fmtlib/fmt/issues/3774,
+    https://github.com/fmtlib/fmt/pull/3779).
+    Thanks @danakj, @vinayyadav3016, @cyyever, @phprus, @qimiko, @saschasc,
+    @gsjaardema, @lazka, @Zhaojun-Liu, @carlsmedstad, @hotwatermorning,
+    @cptFracassa, @kuguma, @PeterJohnson, @H1X4Dev, @asantoni, @eltociear,
+    @msimberg, @tchaikov, @waywardmonkeys.
+
+-   Improved documentation and README
+    (https://github.com/fmtlib/fmt/issues/2086,
+    https://github.com/fmtlib/fmt/issues/3637,
+    https://github.com/fmtlib/fmt/pull/3642,
+    https://github.com/fmtlib/fmt/pull/3653,
+    https://github.com/fmtlib/fmt/pull/3655,
+    https://github.com/fmtlib/fmt/pull/3661,
+    https://github.com/fmtlib/fmt/issues/3673,
+    https://github.com/fmtlib/fmt/pull/3677,
+    https://github.com/fmtlib/fmt/pull/3737,
+    https://github.com/fmtlib/fmt/issues/3742,
+    https://github.com/fmtlib/fmt/pull/3744).
+    Thanks @idzm, @perlun, @joycebrum, @fennewald, @reinhardt1053, @GeorgeLS.
+
+-   Updated CI dependencies
+    (https://github.com/fmtlib/fmt/pull/3615,
+    https://github.com/fmtlib/fmt/pull/3622,
+    https://github.com/fmtlib/fmt/pull/3623,
+    https://github.com/fmtlib/fmt/pull/3666,
+    https://github.com/fmtlib/fmt/pull/3696,
+    https://github.com/fmtlib/fmt/pull/3697,
+    https://github.com/fmtlib/fmt/pull/3759,
+    https://github.com/fmtlib/fmt/pull/3782).
+
+# 10.1.1 - 2023-08-28
+
+-   Added formatters for `std::atomic` and `atomic_flag`
+    (https://github.com/fmtlib/fmt/pull/3574,
+    https://github.com/fmtlib/fmt/pull/3594).
+    Thanks @wangzw and @AlexGuteniev.
+-   Fixed an error about partial specialization of `formatter<string>`
+    after instantiation when compiled with gcc and C++20
+    (https://github.com/fmtlib/fmt/issues/3584).
+-   Fixed compilation as a C++20 module with gcc and clang
+    (https://github.com/fmtlib/fmt/issues/3587,
+    https://github.com/fmtlib/fmt/pull/3597,
+    https://github.com/fmtlib/fmt/pull/3605).
+    Thanks @MathewBensonCode.
+-   Made `fmt::to_string` work with types that have `format_as`
+    overloads (https://github.com/fmtlib/fmt/pull/3575). Thanks @phprus.
+-   Made `formatted_size` work with integral format specifiers at
+    compile time (https://github.com/fmtlib/fmt/pull/3591).
+    Thanks @elbeno.
+-   Fixed a warning about the `no_unique_address` attribute on clang-cl
+    (https://github.com/fmtlib/fmt/pull/3599). Thanks @lukester1975.
+-   Improved compatibility with the legacy GBK encoding
+    (https://github.com/fmtlib/fmt/issues/3598,
+    https://github.com/fmtlib/fmt/pull/3599). Thanks @YuHuanTin.
+-   Added OpenSSF Scorecard analysis
+    (https://github.com/fmtlib/fmt/issues/3530,
+    https://github.com/fmtlib/fmt/pull/3571). Thanks @joycebrum.
+-   Updated CI dependencies
+    (https://github.com/fmtlib/fmt/pull/3591,
+    https://github.com/fmtlib/fmt/pull/3592,
+    https://github.com/fmtlib/fmt/pull/3593,
+    https://github.com/fmtlib/fmt/pull/3602).
+
+# 10.1.0 - 2023-08-12
+
+-   Optimized format string compilation resulting in up to 40% speed up
+    in compiled `format_to` and \~4x speed up in compiled `format_to_n`
+    on a concatenation benchmark
+    (https://github.com/fmtlib/fmt/issues/3133,
+    https://github.com/fmtlib/fmt/issues/3484).
+
+    {fmt} 10.0:
+
+        ---------------------------------------------------------
+        Benchmark               Time             CPU   Iterations
+        ---------------------------------------------------------
+        BM_format_to         78.9 ns         78.9 ns      8881746
+        BM_format_to_n        568 ns          568 ns      1232089
+
+    {fmt} 10.1:
+
+        ---------------------------------------------------------
+        Benchmark               Time             CPU   Iterations
+        ---------------------------------------------------------
+        BM_format_to         54.9 ns         54.9 ns     12727944
+        BM_format_to_n        133 ns          133 ns      5257795
+
+-   Optimized storage of an empty allocator in `basic_memory_buffer`
+    (https://github.com/fmtlib/fmt/pull/3485). Thanks @Minty-Meeo.
+
+-   Added formatters for proxy references to elements of
+    `std::vector<bool>` and `std::bitset<N>`
+    (https://github.com/fmtlib/fmt/issues/3567,
+    https://github.com/fmtlib/fmt/pull/3570). For example
+    ([godbolt](https://godbolt.org/z/zYb79Pvn8)):
+
+    ```c++
+    #include <vector>
+    #include <fmt/std.h>
+
+    int main() {
+      auto v = std::vector<bool>{true};
+      fmt::print("{}", v[0]);
+    }
+    ```
+
+    Thanks @phprus and @felix642.
+
+-   Fixed an ambiguous formatter specialization for containers that look
+    like container adaptors such as `boost::flat_set`
+    (https://github.com/fmtlib/fmt/issues/3556,
+    https://github.com/fmtlib/fmt/pull/3561). Thanks @5chmidti.
+
+-   Fixed compilation when formatting durations not convertible from
+    `std::chrono::seconds`
+    (https://github.com/fmtlib/fmt/pull/3430). Thanks @patlkli.
+
+-   Made the `formatter` specialization for `char*` const-correct
+    (https://github.com/fmtlib/fmt/pull/3432). Thanks @timsong-cpp.
+
+-   Made `{}` and `{:}` handled consistently during compile-time checks
+    (https://github.com/fmtlib/fmt/issues/3526).
+
+-   Disallowed passing temporaries to `make_format_args` to improve API
+    safety by preventing dangling references.
+
+-   Improved the compile-time error for unformattable types
+    (https://github.com/fmtlib/fmt/pull/3478). Thanks @BRevzin.
+
+-   Improved the floating-point formatter
+    (https://github.com/fmtlib/fmt/pull/3448,
+    https://github.com/fmtlib/fmt/pull/3450).
+    Thanks @florimond-collette.
+
+-   Fixed handling of precision for `long double` larger than 64 bits.
+    (https://github.com/fmtlib/fmt/issues/3539,
+    https://github.com/fmtlib/fmt/issues/3564).
+
+-   Made floating-point and chrono tests less platform-dependent
+    (https://github.com/fmtlib/fmt/issues/3337,
+    https://github.com/fmtlib/fmt/issues/3433,
+    https://github.com/fmtlib/fmt/pull/3434). Thanks @phprus.
+
+-   Removed the remnants of the Grisu floating-point formatter that has
+    been replaced by Dragonbox in earlier versions.
+
+-   Added `throw_format_error` to the public API
+    (https://github.com/fmtlib/fmt/pull/3551). Thanks @mjerabek.
+
+-   Made `FMT_THROW` assert even if assertions are disabled when
+    compiling with exceptions disabled
+    (https://github.com/fmtlib/fmt/issues/3418,
+    https://github.com/fmtlib/fmt/pull/3439). Thanks @BRevzin.
+
+-   Made `format_as` and `std::filesystem::path` formatter work with
+    exotic code unit types.
+    (https://github.com/fmtlib/fmt/pull/3457,
+    https://github.com/fmtlib/fmt/pull/3476). Thanks @gix and @hmbj.
+
+-   Added support for the `?` format specifier to
+    `std::filesystem::path` and made the default unescaped for
+    consistency with strings.
+
+-   Deprecated the wide stream overload of `printf`.
+
+-   Removed unused `basic_printf_parse_context`.
+
+-   Improved RTTI detection used when formatting exceptions
+    (https://github.com/fmtlib/fmt/pull/3468). Thanks @danakj.
+
+-   Improved compatibility with VxWorks7
+    (https://github.com/fmtlib/fmt/pull/3467). Thanks @wenshan1.
+
+-   Improved documentation
+    (https://github.com/fmtlib/fmt/issues/3174,
+    https://github.com/fmtlib/fmt/issues/3423,
+    https://github.com/fmtlib/fmt/pull/3454,
+    https://github.com/fmtlib/fmt/issues/3458,
+    https://github.com/fmtlib/fmt/pull/3461,
+    https://github.com/fmtlib/fmt/issues/3487,
+    https://github.com/fmtlib/fmt/pull/3515).
+    Thanks @zencatalyst, @rlalik and @mikecrowe.
+
+-   Improved build and CI configurations
+    (https://github.com/fmtlib/fmt/issues/3449,
+    https://github.com/fmtlib/fmt/pull/3451,
+    https://github.com/fmtlib/fmt/pull/3452,
+    https://github.com/fmtlib/fmt/pull/3453,
+    https://github.com/fmtlib/fmt/pull/3459,
+    https://github.com/fmtlib/fmt/issues/3481,
+    https://github.com/fmtlib/fmt/pull/3486,
+    https://github.com/fmtlib/fmt/issues/3489,
+    https://github.com/fmtlib/fmt/pull/3496,
+    https://github.com/fmtlib/fmt/issues/3517,
+    https://github.com/fmtlib/fmt/pull/3523,
+    https://github.com/fmtlib/fmt/pull/3563).
+    Thanks @joycebrum, @glebm, @phprus, @petrmanek, @setoye and @abouvier.
+
+-   Fixed various warnings and compilation issues
+    (https://github.com/fmtlib/fmt/issues/3408,
+    https://github.com/fmtlib/fmt/issues/3424,
+    https://github.com/fmtlib/fmt/issues/3444,
+    https://github.com/fmtlib/fmt/pull/3446,
+    https://github.com/fmtlib/fmt/pull/3475,
+    https://github.com/fmtlib/fmt/pull/3482,
+    https://github.com/fmtlib/fmt/issues/3492,
+    https://github.com/fmtlib/fmt/pull/3493,
+    https://github.com/fmtlib/fmt/pull/3508,
+    https://github.com/fmtlib/fmt/issues/3509,
+    https://github.com/fmtlib/fmt/issues/3533,
+    https://github.com/fmtlib/fmt/pull/3542,
+    https://github.com/fmtlib/fmt/issues/3543,
+    https://github.com/fmtlib/fmt/issues/3540,
+    https://github.com/fmtlib/fmt/pull/3544,
+    https://github.com/fmtlib/fmt/issues/3548,
+    https://github.com/fmtlib/fmt/pull/3549,
+    https://github.com/fmtlib/fmt/pull/3550,
+    https://github.com/fmtlib/fmt/pull/3552).
+    Thanks @adesitter, @hmbj, @Minty-Meeo, @phprus, @TobiSchluter,
+    @kieranclancy, @alexeedm, @jurihock, @Ozomahtli and @razaqq.
+
+# 10.0.0 - 2023-05-09
+
+-   Replaced Grisu with a new floating-point formatting algorithm for
+    given precision (https://github.com/fmtlib/fmt/issues/3262,
+    https://github.com/fmtlib/fmt/issues/2750,
+    https://github.com/fmtlib/fmt/pull/3269,
+    https://github.com/fmtlib/fmt/pull/3276). The new algorithm
+    is based on Dragonbox already used for the shortest representation
+    and gives substantial performance improvement:
+
+    ![](https://user-images.githubusercontent.com/33922675/211956670-84891a09-6867-47d9-82fc-3230da7abe0f.png)
+
+    -   Red: new algorithm
+    -   Green: new algorithm with `FMT_USE_FULL_CACHE_DRAGONBOX` defined
+        to 1
+    -   Blue: old algorithm
+
+    Thanks @jk-jeon.
+
+-   Replaced `snprintf`-based hex float formatter with an internal
+    implementation (https://github.com/fmtlib/fmt/pull/3179,
+    https://github.com/fmtlib/fmt/pull/3203). This removes the
+    last usage of `s(n)printf` in {fmt}. Thanks @phprus.
+
+-   Fixed alignment of floating-point numbers with localization
+    (https://github.com/fmtlib/fmt/issues/3263,
+    https://github.com/fmtlib/fmt/pull/3272). Thanks @ShawnZhong.
+
+-   Made handling of `#` consistent with `std::format`.
+
+-   Improved C++20 module support
+    (https://github.com/fmtlib/fmt/pull/3134,
+    https://github.com/fmtlib/fmt/pull/3254,
+    https://github.com/fmtlib/fmt/pull/3386,
+    https://github.com/fmtlib/fmt/pull/3387,
+    https://github.com/fmtlib/fmt/pull/3388,
+    https://github.com/fmtlib/fmt/pull/3392,
+    https://github.com/fmtlib/fmt/pull/3397,
+    https://github.com/fmtlib/fmt/pull/3399,
+    https://github.com/fmtlib/fmt/pull/3400).
+    Thanks @laitingsheng, @Orvid and @DanielaE.
+    
+-   Switched to the [modules CMake library](https://github.com/vitaut/modules)
+    which allows building {fmt} as a C++20 module with clang:
+
+        CXX=clang++ cmake -DFMT_MODULE=ON .
+        make
+
+-   Made `format_as` work with any user-defined type and not just enums.
+    For example ([godbolt](https://godbolt.org/z/b7rqhq5Kh)):
+
+    ```c++
+    #include <fmt/format.h>
+
+    struct floaty_mc_floatface {
+      double value;
+    };
+
+    auto format_as(floaty_mc_floatface f) { return f.value; }
+
+    int main() {
+      fmt::print("{:8}\n", floaty_mc_floatface{0.42}); // prints "    0.42"
+    }
+    ```
+
+-   Removed deprecated implicit conversions for enums and conversions to
+    primitive types for compatibility with `std::format` and to prevent
+    potential ODR violations. Use `format_as` instead.
+
+-   Added support for fill, align and width to the time point formatter
+    (https://github.com/fmtlib/fmt/issues/3237,
+    https://github.com/fmtlib/fmt/pull/3260,
+    https://github.com/fmtlib/fmt/pull/3275). For example
+    ([godbolt](https://godbolt.org/z/rKP6MGz6c)):
+
+    ```c++
+    #include <fmt/chrono.h>
+
+    int main() {
+      // prints "    2023"
+      fmt::print("{:>8%Y}\n", std::chrono::system_clock::now());
+    }
+    ```
+
+    Thanks @ShawnZhong.
+
+-   Implemented formatting of subseconds
+    (https://github.com/fmtlib/fmt/issues/2207,
+    https://github.com/fmtlib/fmt/issues/3117,
+    https://github.com/fmtlib/fmt/pull/3115,
+    https://github.com/fmtlib/fmt/pull/3143,
+    https://github.com/fmtlib/fmt/pull/3144,
+    https://github.com/fmtlib/fmt/pull/3349). For example
+    ([godbolt](https://godbolt.org/z/45738oGEo)):
+
+    ```c++
+    #include <fmt/chrono.h>
+
+    int main() {
+      // prints 01.234567
+      fmt::print("{:%S}\n", std::chrono::microseconds(1234567));
+    }
+    ```
+
+    Thanks @patrickroocks @phprus and @BRevzin.
+
+-   Added precision support to `%S`
+    (https://github.com/fmtlib/fmt/pull/3148). Thanks @SappyJoy
+
+-   Added support for `std::utc_time`
+    (https://github.com/fmtlib/fmt/issues/3098,
+    https://github.com/fmtlib/fmt/pull/3110). Thanks @patrickroocks.
+
+-   Switched formatting of `std::chrono::system_clock` from local time
+    to UTC for compatibility with the standard
+    (https://github.com/fmtlib/fmt/issues/3199,
+    https://github.com/fmtlib/fmt/pull/3230). Thanks @ned14.
+
+-   Added support for `%Ez` and `%Oz` to chrono formatters.
+    (https://github.com/fmtlib/fmt/issues/3220,
+    https://github.com/fmtlib/fmt/pull/3222). Thanks @phprus.
+
+-   Improved validation of format specifiers for `std::chrono::duration`
+    (https://github.com/fmtlib/fmt/issues/3219,
+    https://github.com/fmtlib/fmt/pull/3232). Thanks @ShawnZhong.
+
+-   Fixed formatting of time points before the epoch
+    (https://github.com/fmtlib/fmt/issues/3117,
+    https://github.com/fmtlib/fmt/pull/3261). For example
+    ([godbolt](https://godbolt.org/z/f7bcznb3W)):
+
+    ```c++
+    #include <fmt/chrono.h>
+
+    int main() {
+      auto t = std::chrono::system_clock::from_time_t(0) -
+               std::chrono::milliseconds(250);
+      fmt::print("{:%S}\n", t); // prints 59.750000000
+    }
+    ```
+
+    Thanks @ShawnZhong.
+
+-   Experimental: implemented glibc extension for padding seconds,
+    minutes and hours
+    (https://github.com/fmtlib/fmt/issues/2959,
+    https://github.com/fmtlib/fmt/pull/3271). Thanks @ShawnZhong.
+
+-   Added a formatter for `std::exception`
+    (https://github.com/fmtlib/fmt/issues/2977,
+    https://github.com/fmtlib/fmt/issues/3012,
+    https://github.com/fmtlib/fmt/pull/3062,
+    https://github.com/fmtlib/fmt/pull/3076,
+    https://github.com/fmtlib/fmt/pull/3119). For example
+    ([godbolt](https://godbolt.org/z/8xoWGs9e4)):
+
+    ```c++
+    #include <fmt/std.h>
+    #include <vector>
+
+    int main() {
+      try {
+        std::vector<bool>().at(0);
+      } catch(const std::exception& e) {
+        fmt::print("{}", e);
+      }
+    }
+    ```
+
+    prints:
+
+        vector<bool>::_M_range_check: __n (which is 0) >= this->size() (which is 0)
+
+    on libstdc++. Thanks @zach2good and @phprus.
+
+-   Moved `std::error_code` formatter from `fmt/os.h` to `fmt/std.h`.
+    (https://github.com/fmtlib/fmt/pull/3125). Thanks @phprus.
+
+-   Added formatters for standard container adapters:
+    `std::priority_queue`, `std::queue` and `std::stack`
+    (https://github.com/fmtlib/fmt/issues/3215,
+    https://github.com/fmtlib/fmt/pull/3279). For example
+    ([godbolt](https://godbolt.org/z/74h1xY9qK)):
+
+    ```c++
+    #include <fmt/ranges.h>
+    #include <stack>
+    #include <vector>
+
+    int main() {
+      auto s = std::stack<bool, std::vector<bool>>();
+      for (auto b: {true, false, true}) s.push(b);
+      fmt::print("{}\n", s); // prints [true, false, true]
+    }
+    ```
+
+    Thanks @ShawnZhong.
+
+-   Added a formatter for `std::optional` to `fmt/std.h`
+    (https://github.com/fmtlib/fmt/issues/1367,
+    https://github.com/fmtlib/fmt/pull/3303).
+    Thanks @tom-huntington.
+
+-   Fixed formatting of valueless by exception variants
+    (https://github.com/fmtlib/fmt/pull/3347). Thanks @TheOmegaCarrot.
+
+-   Made `fmt::ptr` accept `unique_ptr` with a custom deleter
+    (https://github.com/fmtlib/fmt/pull/3177). Thanks @hmbj.
+
+-   Fixed formatting of noncopyable ranges and nested ranges of chars
+    (https://github.com/fmtlib/fmt/pull/3158
+    https://github.com/fmtlib/fmt/issues/3286,
+    https://github.com/fmtlib/fmt/pull/3290). Thanks @BRevzin.
+
+-   Fixed issues with formatting of paths and ranges of paths
+    (https://github.com/fmtlib/fmt/issues/3319,
+    https://github.com/fmtlib/fmt/pull/3321
+    https://github.com/fmtlib/fmt/issues/3322). Thanks @phprus.
+
+-   Improved handling of invalid Unicode in paths.
+
+-   Enabled compile-time checks on Apple clang 14 and later
+    (https://github.com/fmtlib/fmt/pull/3331). Thanks @cloyce.
+
+-   Improved compile-time checks of named arguments
+    (https://github.com/fmtlib/fmt/issues/3105,
+    https://github.com/fmtlib/fmt/pull/3214). Thanks @rbrich.
+
+-   Fixed formatting when both alignment and `0` are given
+    (https://github.com/fmtlib/fmt/issues/3236,
+    https://github.com/fmtlib/fmt/pull/3248). Thanks @ShawnZhong.
+
+-   Improved Unicode support in the experimental file API on Windows
+    (https://github.com/fmtlib/fmt/issues/3234,
+    https://github.com/fmtlib/fmt/pull/3293). Thanks @Fros1er.
+
+-   Unified UTF transcoding
+    (https://github.com/fmtlib/fmt/pull/3416). Thanks @phprus.
+
+-   Added support for UTF-8 digit separators via an experimental locale
+    facet (https://github.com/fmtlib/fmt/issues/1861). For
+    example ([godbolt](https://godbolt.org/z/f7bcznb3W)):
+
+    ```c++
+    auto loc = std::locale(
+      std::locale(), new fmt::format_facet<std::locale>("’"));
+    auto s = fmt::format(loc, "{:L}", 1000);
+    ```
+
+    where `’` is U+2019 used as a digit separator in the de_CH locale.
+
+-   Added an overload of `formatted_size` that takes a locale
+    (https://github.com/fmtlib/fmt/issues/3084,
+    https://github.com/fmtlib/fmt/pull/3087). Thanks @gerboengels.
+
+-   Removed the deprecated `FMT_DEPRECATED_OSTREAM`.
+
+-   Fixed a UB when using a null `std::string_view` with
+    `fmt::to_string` or format string compilation
+    (https://github.com/fmtlib/fmt/issues/3241,
+    https://github.com/fmtlib/fmt/pull/3244). Thanks @phprus.
+
+-   Added `starts_with` to the fallback `string_view` implementation
+    (https://github.com/fmtlib/fmt/pull/3080). Thanks @phprus.
+
+-   Added `fmt::basic_format_string::get()` for compatibility with
+    `basic_format_string`
+    (https://github.com/fmtlib/fmt/pull/3111). Thanks @huangqinjin.
+
+-   Added `println` for compatibility with C++23
+    (https://github.com/fmtlib/fmt/pull/3267). Thanks @ShawnZhong.
+
+-   Renamed the `FMT_EXPORT` macro for shared library usage to
+    `FMT_LIB_EXPORT`.
+
+-   Improved documentation
+    (https://github.com/fmtlib/fmt/issues/3108,
+    https://github.com/fmtlib/fmt/issues/3169,
+    https://github.com/fmtlib/fmt/pull/3243).
+    https://github.com/fmtlib/fmt/pull/3404).
+    Thanks @Cleroth and @Vertexwahn.
+
+-   Improved build configuration and tests
+    (https://github.com/fmtlib/fmt/pull/3118,
+    https://github.com/fmtlib/fmt/pull/3120,
+    https://github.com/fmtlib/fmt/pull/3188,
+    https://github.com/fmtlib/fmt/issues/3189,
+    https://github.com/fmtlib/fmt/pull/3198,
+    https://github.com/fmtlib/fmt/pull/3205,
+    https://github.com/fmtlib/fmt/pull/3207,
+    https://github.com/fmtlib/fmt/pull/3210,
+    https://github.com/fmtlib/fmt/pull/3240,
+    https://github.com/fmtlib/fmt/pull/3256,
+    https://github.com/fmtlib/fmt/pull/3264,
+    https://github.com/fmtlib/fmt/issues/3299,
+    https://github.com/fmtlib/fmt/pull/3302,
+    https://github.com/fmtlib/fmt/pull/3312,
+    https://github.com/fmtlib/fmt/issues/3317,
+    https://github.com/fmtlib/fmt/pull/3328,
+    https://github.com/fmtlib/fmt/pull/3333,
+    https://github.com/fmtlib/fmt/pull/3369,
+    https://github.com/fmtlib/fmt/issues/3373,
+    https://github.com/fmtlib/fmt/pull/3395,
+    https://github.com/fmtlib/fmt/pull/3406,
+    https://github.com/fmtlib/fmt/pull/3411).
+    Thanks @dimztimz, @phprus, @DavidKorczynski, @ChrisThrasher,
+    @FrancoisCarouge, @kennyweiss, @luzpaz, @codeinred, @Mixaill, @joycebrum,
+    @kevinhwang and @Vertexwahn.
+
+-   Fixed a regression in handling empty format specifiers after a colon
+    (`{:}`) (https://github.com/fmtlib/fmt/pull/3086). Thanks @oxidase.
+
+-   Worked around a broken implementation of
+    `std::is_constant_evaluated` in some versions of libstdc++ on clang
+    (https://github.com/fmtlib/fmt/issues/3247,
+    https://github.com/fmtlib/fmt/pull/3281). Thanks @phprus.
+
+-   Fixed formatting of volatile variables
+    (https://github.com/fmtlib/fmt/pull/3068).
+
+-   Fixed various warnings and compilation issues
+    (https://github.com/fmtlib/fmt/pull/3057,
+    https://github.com/fmtlib/fmt/pull/3066,
+    https://github.com/fmtlib/fmt/pull/3072,
+    https://github.com/fmtlib/fmt/pull/3082,
+    https://github.com/fmtlib/fmt/pull/3091,
+    https://github.com/fmtlib/fmt/issues/3092,
+    https://github.com/fmtlib/fmt/pull/3093,
+    https://github.com/fmtlib/fmt/pull/3095,
+    https://github.com/fmtlib/fmt/issues/3096,
+    https://github.com/fmtlib/fmt/pull/3097,
+    https://github.com/fmtlib/fmt/issues/3128,
+    https://github.com/fmtlib/fmt/pull/3129,
+    https://github.com/fmtlib/fmt/pull/3137,
+    https://github.com/fmtlib/fmt/pull/3139,
+    https://github.com/fmtlib/fmt/issues/3140,
+    https://github.com/fmtlib/fmt/pull/3142,
+    https://github.com/fmtlib/fmt/issues/3149,
+    https://github.com/fmtlib/fmt/pull/3150,
+    https://github.com/fmtlib/fmt/issues/3154,
+    https://github.com/fmtlib/fmt/issues/3163,
+    https://github.com/fmtlib/fmt/issues/3178,
+    https://github.com/fmtlib/fmt/pull/3184,
+    https://github.com/fmtlib/fmt/pull/3196,
+    https://github.com/fmtlib/fmt/issues/3204,
+    https://github.com/fmtlib/fmt/pull/3206,
+    https://github.com/fmtlib/fmt/pull/3208,
+    https://github.com/fmtlib/fmt/issues/3213,
+    https://github.com/fmtlib/fmt/pull/3216,
+    https://github.com/fmtlib/fmt/issues/3224,
+    https://github.com/fmtlib/fmt/issues/3226,
+    https://github.com/fmtlib/fmt/issues/3228,
+    https://github.com/fmtlib/fmt/pull/3229,
+    https://github.com/fmtlib/fmt/pull/3259,
+    https://github.com/fmtlib/fmt/issues/3274,
+    https://github.com/fmtlib/fmt/issues/3287,
+    https://github.com/fmtlib/fmt/pull/3288,
+    https://github.com/fmtlib/fmt/issues/3292,
+    https://github.com/fmtlib/fmt/pull/3295,
+    https://github.com/fmtlib/fmt/pull/3296,
+    https://github.com/fmtlib/fmt/issues/3298,
+    https://github.com/fmtlib/fmt/issues/3325,
+    https://github.com/fmtlib/fmt/pull/3326,
+    https://github.com/fmtlib/fmt/issues/3334,
+    https://github.com/fmtlib/fmt/issues/3342,
+    https://github.com/fmtlib/fmt/pull/3343,
+    https://github.com/fmtlib/fmt/issues/3351,
+    https://github.com/fmtlib/fmt/pull/3352,
+    https://github.com/fmtlib/fmt/pull/3362,
+    https://github.com/fmtlib/fmt/issues/3365,
+    https://github.com/fmtlib/fmt/pull/3366,
+    https://github.com/fmtlib/fmt/pull/3374,
+    https://github.com/fmtlib/fmt/issues/3377,
+    https://github.com/fmtlib/fmt/pull/3378,
+    https://github.com/fmtlib/fmt/issues/3381,
+    https://github.com/fmtlib/fmt/pull/3398,
+    https://github.com/fmtlib/fmt/pull/3413,
+    https://github.com/fmtlib/fmt/issues/3415).
+    Thanks @phprus, @gsjaardema, @NewbieOrange, @EngineLessCC, @asmaloney,
+    @HazardyKnusperkeks, @sergiud, @Youw, @thesmurph, @czudziakm,
+    @Roman-Koshelev, @chronoxor, @ShawnZhong, @russelltg, @glebm, @tmartin-gh,
+    @Zhaojun-Liu, @louiswins and @mogemimi.
+
+# 9.1.0 - 2022-08-27
+
+-   `fmt::formatted_size` now works at compile time
+    (https://github.com/fmtlib/fmt/pull/3026). For example
+    ([godbolt](https://godbolt.org/z/1MW5rMdf8)):
+
+    ```c++
+    #include <fmt/compile.h>
+
+    int main() {
+      using namespace fmt::literals;
+      constexpr size_t n = fmt::formatted_size("{}"_cf, 42);
+      fmt::print("{}\n", n); // prints 2
+    }
+    ```
+
+    Thanks @marksantaniello.
+
+-   Fixed handling of invalid UTF-8
+    (https://github.com/fmtlib/fmt/pull/3038,
+    https://github.com/fmtlib/fmt/pull/3044,
+    https://github.com/fmtlib/fmt/pull/3056).
+    Thanks @phprus and @skeeto.
+
+-   Improved Unicode support in `ostream` overloads of `print`
+    (https://github.com/fmtlib/fmt/pull/2994,
+    https://github.com/fmtlib/fmt/pull/3001,
+    https://github.com/fmtlib/fmt/pull/3025). Thanks @dimztimz.
+
+-   Fixed handling of the sign specifier in localized formatting on
+    systems with 32-bit `wchar_t`
+    (https://github.com/fmtlib/fmt/issues/3041).
+
+-   Added support for wide streams to `fmt::streamed`
+    (https://github.com/fmtlib/fmt/pull/2994). Thanks @phprus.
+
+-   Added the `n` specifier that disables the output of delimiters when
+    formatting ranges (https://github.com/fmtlib/fmt/pull/2981,
+    https://github.com/fmtlib/fmt/pull/2983). For example
+    ([godbolt](https://godbolt.org/z/roKqGdj8c)):
+
+    ```c++
+    #include <fmt/ranges.h>
+    #include <vector>
+
+    int main() {
+      auto v = std::vector{1, 2, 3};
+      fmt::print("{:n}\n", v); // prints 1, 2, 3
+    }
+    ```
+
+    Thanks @BRevzin.
+
+-   Worked around problematic `std::string_view` constructors introduced
+    in C++23 (https://github.com/fmtlib/fmt/issues/3030,
+    https://github.com/fmtlib/fmt/issues/3050). Thanks @strega-nil-ms.
+
+-   Improve handling (exclusion) of recursive ranges
+    (https://github.com/fmtlib/fmt/issues/2968,
+    https://github.com/fmtlib/fmt/pull/2974). Thanks @Dani-Hub.
+
+-   Improved error reporting in format string compilation
+    (https://github.com/fmtlib/fmt/issues/3055).
+
+-   Improved the implementation of
+    [Dragonbox](https://github.com/jk-jeon/dragonbox), the algorithm
+    used for the default floating-point formatting
+    (https://github.com/fmtlib/fmt/pull/2984). Thanks @jk-jeon.
+
+-   Fixed issues with floating-point formatting on exotic platforms.
+
+-   Improved the implementation of chrono formatting
+    (https://github.com/fmtlib/fmt/pull/3010). Thanks @phprus.
+
+-   Improved documentation
+    (https://github.com/fmtlib/fmt/pull/2966,
+    https://github.com/fmtlib/fmt/pull/3009,
+    https://github.com/fmtlib/fmt/issues/3020,
+    https://github.com/fmtlib/fmt/pull/3037).
+    Thanks @mwinterb, @jcelerier and @remiburtin.
+
+-   Improved build configuration
+    (https://github.com/fmtlib/fmt/pull/2991,
+    https://github.com/fmtlib/fmt/pull/2995,
+    https://github.com/fmtlib/fmt/issues/3004,
+    https://github.com/fmtlib/fmt/pull/3007,
+    https://github.com/fmtlib/fmt/pull/3040).
+    Thanks @dimztimz and @hwhsu1231.
+
+-   Fixed various warnings and compilation issues
+    (https://github.com/fmtlib/fmt/issues/2969,
+    https://github.com/fmtlib/fmt/pull/2971,
+    https://github.com/fmtlib/fmt/issues/2975,
+    https://github.com/fmtlib/fmt/pull/2982,
+    https://github.com/fmtlib/fmt/pull/2985,
+    https://github.com/fmtlib/fmt/issues/2988,
+    https://github.com/fmtlib/fmt/issues/2989,
+    https://github.com/fmtlib/fmt/issues/3000,
+    https://github.com/fmtlib/fmt/issues/3006,
+    https://github.com/fmtlib/fmt/issues/3014,
+    https://github.com/fmtlib/fmt/issues/3015,
+    https://github.com/fmtlib/fmt/pull/3021,
+    https://github.com/fmtlib/fmt/issues/3023,
+    https://github.com/fmtlib/fmt/pull/3024,
+    https://github.com/fmtlib/fmt/pull/3029,
+    https://github.com/fmtlib/fmt/pull/3043,
+    https://github.com/fmtlib/fmt/issues/3052,
+    https://github.com/fmtlib/fmt/pull/3053,
+    https://github.com/fmtlib/fmt/pull/3054).
+    Thanks @h-friederich, @dimztimz, @olupton, @bernhardmgruber and @phprus.
+
+# 9.0.0 - 2022-07-04
+
+-   Switched to the internal floating point formatter for all decimal
+    presentation formats. In particular this results in consistent
+    rounding on all platforms and removing the `s[n]printf` fallback for
+    decimal FP formatting.
+
+-   Compile-time floating point formatting no longer requires the
+    header-only mode. For example
+    ([godbolt](https://godbolt.org/z/G37PTeG3b)):
+
+    ```c++
+    #include <array>
+    #include <fmt/compile.h>
+
+    consteval auto compile_time_dtoa(double value) -> std::array<char, 10> {
+      auto result = std::array<char, 10>();
+      fmt::format_to(result.data(), FMT_COMPILE("{}"), value);
+      return result;
+    }
+
+    constexpr auto answer = compile_time_dtoa(0.42);
+    ```
+
+    works with the default settings.
+
+-   Improved the implementation of
+    [Dragonbox](https://github.com/jk-jeon/dragonbox), the algorithm
+    used for the default floating-point formatting
+    (https://github.com/fmtlib/fmt/pull/2713,
+    https://github.com/fmtlib/fmt/pull/2750). Thanks @jk-jeon.
+
+-   Made `fmt::to_string` work with `__float128`. This uses the internal
+    FP formatter and works even on system without `__float128` support
+    in `[s]printf`.
+
+-   Disabled automatic `std::ostream` insertion operator (`operator<<`)
+    discovery when `fmt/ostream.h` is included to prevent ODR
+    violations. You can get the old behavior by defining
+    `FMT_DEPRECATED_OSTREAM` but this will be removed in the next major
+    release. Use `fmt::streamed` or `fmt::ostream_formatter` to enable
+    formatting via `std::ostream` instead.
+
+-   Added `fmt::ostream_formatter` that can be used to write `formatter`
+    specializations that perform formatting via `std::ostream`. For
+    example ([godbolt](https://godbolt.org/z/5sEc5qMsf)):
+
+    ```c++
+    #include <fmt/ostream.h>
+
+    struct date {
+      int year, month, day;
+
+      friend std::ostream& operator<<(std::ostream& os, const date& d) {
+        return os << d.year << '-' << d.month << '-' << d.day;
+      }
+    };
+
+    template <> struct fmt::formatter<date> : ostream_formatter {};
+
+    std::string s = fmt::format("The date is {}", date{2012, 12, 9});
+    // s == "The date is 2012-12-9"
+    ```
+
+-   Added the `fmt::streamed` function that takes an object and formats
+    it via `std::ostream`. For example
+    ([godbolt](https://godbolt.org/z/5G3346G1f)):
+
+    ```c++
+    #include <thread>
+    #include <fmt/ostream.h>
+
+    int main() {
+      fmt::print("Current thread id: {}\n",
+                 fmt::streamed(std::this_thread::get_id()));
+    }
+    ```
+
+    Note that `fmt/std.h` provides a `formatter` specialization for
+    `std::thread::id` so you don\'t need to format it via
+    `std::ostream`.
+
+-   Deprecated implicit conversions of unscoped enums to integers for
+    consistency with scoped enums.
+
+-   Added an argument-dependent lookup based `format_as` extension API
+    to simplify formatting of enums.
+
+-   Added experimental `std::variant` formatting support
+    (https://github.com/fmtlib/fmt/pull/2941). For example
+    ([godbolt](https://godbolt.org/z/KG9z6cq68)):
+
+    ```c++
+    #include <variant>
+    #include <fmt/std.h>
+
+    int main() {
+      auto v = std::variant<int, std::string>(42);
+      fmt::print("{}\n", v);
+    }
+    ```
+
+    prints:
+
+        variant(42)
+
+    Thanks @jehelset.
+
+-   Added experimental `std::filesystem::path` formatting support
+    (https://github.com/fmtlib/fmt/issues/2865,
+    https://github.com/fmtlib/fmt/pull/2902,
+    https://github.com/fmtlib/fmt/issues/2917,
+    https://github.com/fmtlib/fmt/pull/2918). For example
+    ([godbolt](https://godbolt.org/z/o44dMexEb)):
+
+    ```c++
+    #include <filesystem>
+    #include <fmt/std.h>
+
+    int main() {
+      fmt::print("There is no place like {}.", std::filesystem::path("/home"));
+    }
+    ```
+
+    prints:
+
+        There is no place like "/home".
+
+    Thanks @phprus.
+
+-   Added a `std::thread::id` formatter to `fmt/std.h`. For example
+    ([godbolt](https://godbolt.org/z/j1azbYf3E)):
+
+    ```c++
+    #include <thread>
+    #include <fmt/std.h>
+
+    int main() {
+      fmt::print("Current thread id: {}\n", std::this_thread::get_id());
+    }
+    ```
+
+-   Added `fmt::styled` that applies a text style to an individual
+    argument (https://github.com/fmtlib/fmt/pull/2793). For
+    example ([godbolt](https://godbolt.org/z/vWGW7v5M6)):
+
+    ```c++
+    #include <fmt/chrono.h>
+    #include <fmt/color.h>
+
+    int main() {
+      auto now = std::chrono::system_clock::now();
+      fmt::print(
+        "[{}] {}: {}\n",
+        fmt::styled(now, fmt::emphasis::bold),
+        fmt::styled("error", fg(fmt::color::red)),
+        "something went wrong");
+    }
+    ```
+
+    prints
+
+    ![](https://user-images.githubusercontent.com/576385/175071215-12809244-dab0-4005-96d8-7cd911c964d5.png)
+
+    Thanks @rbrugo.
+
+-   Made `fmt::print` overload for text styles correctly handle UTF-8
+    (https://github.com/fmtlib/fmt/issues/2681,
+    https://github.com/fmtlib/fmt/pull/2701). Thanks @AlexGuteniev.
+
+-   Fixed Unicode handling when writing to an ostream.
+
+-   Added support for nested specifiers to range formatting
+    (https://github.com/fmtlib/fmt/pull/2673). For example
+    ([godbolt](https://godbolt.org/z/xd3Gj38cf)):
+
+    ```c++
+    #include <vector>
+    #include <fmt/ranges.h>
+
+    int main() {
+      fmt::print("{::#x}\n", std::vector{10, 20, 30});
+    }
+    ```
+
+    prints `[0xa, 0x14, 0x1e]`.
+
+    Thanks @BRevzin.
+
+-   Implemented escaping of wide strings in ranges
+    (https://github.com/fmtlib/fmt/pull/2904). Thanks @phprus.
+
+-   Added support for ranges with `begin` / `end` found via the
+    argument-dependent lookup
+    (https://github.com/fmtlib/fmt/pull/2807). Thanks @rbrugo.
+
+-   Fixed formatting of certain kinds of ranges of ranges
+    (https://github.com/fmtlib/fmt/pull/2787). Thanks @BRevzin.
+
+-   Fixed handling of maps with element types other than `std::pair`
+    (https://github.com/fmtlib/fmt/pull/2944). Thanks @BrukerJWD.
+
+-   Made tuple formatter enabled only if elements are formattable
+    (https://github.com/fmtlib/fmt/issues/2939,
+    https://github.com/fmtlib/fmt/pull/2940). Thanks @jehelset.
+
+-   Made `fmt::join` compatible with format string compilation
+    (https://github.com/fmtlib/fmt/issues/2719,
+    https://github.com/fmtlib/fmt/pull/2720). Thanks @phprus.
+
+-   Made compile-time checks work with named arguments of custom types
+    and `std::ostream` `print` overloads
+    (https://github.com/fmtlib/fmt/issues/2816,
+    https://github.com/fmtlib/fmt/issues/2817,
+    https://github.com/fmtlib/fmt/pull/2819). Thanks @timsong-cpp.
+
+-   Removed `make_args_checked` because it is no longer needed for
+    compile-time checks
+    (https://github.com/fmtlib/fmt/pull/2760). Thanks @phprus.
+
+-   Removed the following deprecated APIs: `_format`, `arg_join`, the
+    `format_to` overload that takes a memory buffer, `[v]fprintf` that
+    takes an `ostream`.
+
+-   Removed the deprecated implicit conversion of `[const] signed char*`
+    and `[const] unsigned char*` to C strings.
+
+-   Removed the deprecated `fmt/locale.h`.
+
+-   Replaced the deprecated `fileno()` with `descriptor()` in
+    `buffered_file`.
+
+-   Moved `to_string_view` to the `detail` namespace since it\'s an
+    implementation detail.
+
+-   Made access mode of a created file consistent with `fopen` by
+    setting `S_IWGRP` and `S_IWOTH`
+    (https://github.com/fmtlib/fmt/pull/2733). Thanks @arogge.
+
+-   Removed a redundant buffer resize when formatting to `std::ostream`
+    (https://github.com/fmtlib/fmt/issues/2842,
+    https://github.com/fmtlib/fmt/pull/2843). Thanks @jcelerier.
+
+-   Made precision computation for strings consistent with width
+    (https://github.com/fmtlib/fmt/issues/2888).
+
+-   Fixed handling of locale separators in floating point formatting
+    (https://github.com/fmtlib/fmt/issues/2830).
+
+-   Made sign specifiers work with `__int128_t`
+    (https://github.com/fmtlib/fmt/issues/2773).
+
+-   Improved support for systems such as CHERI with extra data stored in
+    pointers (https://github.com/fmtlib/fmt/pull/2932).
+    Thanks @davidchisnall.
+
+-   Improved documentation
+    (https://github.com/fmtlib/fmt/pull/2706,
+    https://github.com/fmtlib/fmt/pull/2712,
+    https://github.com/fmtlib/fmt/pull/2789,
+    https://github.com/fmtlib/fmt/pull/2803,
+    https://github.com/fmtlib/fmt/pull/2805,
+    https://github.com/fmtlib/fmt/pull/2815,
+    https://github.com/fmtlib/fmt/pull/2924).
+    Thanks @BRevzin, @Pokechu22, @setoye, @rtobar, @rbrugo, @anoonD and
+    @leha-bot.
+
+-   Improved build configuration
+    (https://github.com/fmtlib/fmt/pull/2766,
+    https://github.com/fmtlib/fmt/pull/2772,
+    https://github.com/fmtlib/fmt/pull/2836,
+    https://github.com/fmtlib/fmt/pull/2852,
+    https://github.com/fmtlib/fmt/pull/2907,
+    https://github.com/fmtlib/fmt/pull/2913,
+    https://github.com/fmtlib/fmt/pull/2914).
+    Thanks @kambala-decapitator, @mattiasljungstrom, @kieselnb, @nathannaveen
+    and @Vertexwahn.
+
+-   Fixed various warnings and compilation issues
+    (https://github.com/fmtlib/fmt/issues/2408,
+    https://github.com/fmtlib/fmt/issues/2507,
+    https://github.com/fmtlib/fmt/issues/2697,
+    https://github.com/fmtlib/fmt/issues/2715,
+    https://github.com/fmtlib/fmt/issues/2717,
+    https://github.com/fmtlib/fmt/pull/2722,
+    https://github.com/fmtlib/fmt/pull/2724,
+    https://github.com/fmtlib/fmt/pull/2725,
+    https://github.com/fmtlib/fmt/issues/2726,
+    https://github.com/fmtlib/fmt/pull/2728,
+    https://github.com/fmtlib/fmt/pull/2732,
+    https://github.com/fmtlib/fmt/issues/2738,
+    https://github.com/fmtlib/fmt/pull/2742,
+    https://github.com/fmtlib/fmt/issues/2744,
+    https://github.com/fmtlib/fmt/issues/2745,
+    https://github.com/fmtlib/fmt/issues/2746,
+    https://github.com/fmtlib/fmt/issues/2754,
+    https://github.com/fmtlib/fmt/pull/2755,
+    https://github.com/fmtlib/fmt/issues/2757,
+    https://github.com/fmtlib/fmt/pull/2758,
+    https://github.com/fmtlib/fmt/issues/2761,
+    https://github.com/fmtlib/fmt/pull/2762,
+    https://github.com/fmtlib/fmt/issues/2763,
+    https://github.com/fmtlib/fmt/pull/2765,
+    https://github.com/fmtlib/fmt/issues/2769,
+    https://github.com/fmtlib/fmt/pull/2770,
+    https://github.com/fmtlib/fmt/issues/2771,
+    https://github.com/fmtlib/fmt/issues/2777,
+    https://github.com/fmtlib/fmt/pull/2779,
+    https://github.com/fmtlib/fmt/pull/2782,
+    https://github.com/fmtlib/fmt/pull/2783,
+    https://github.com/fmtlib/fmt/issues/2794,
+    https://github.com/fmtlib/fmt/issues/2796,
+    https://github.com/fmtlib/fmt/pull/2797,
+    https://github.com/fmtlib/fmt/pull/2801,
+    https://github.com/fmtlib/fmt/pull/2802,
+    https://github.com/fmtlib/fmt/issues/2808,
+    https://github.com/fmtlib/fmt/issues/2818,
+    https://github.com/fmtlib/fmt/pull/2819,
+    https://github.com/fmtlib/fmt/issues/2829,
+    https://github.com/fmtlib/fmt/issues/2835,
+    https://github.com/fmtlib/fmt/issues/2848,
+    https://github.com/fmtlib/fmt/issues/2860,
+    https://github.com/fmtlib/fmt/pull/2861,
+    https://github.com/fmtlib/fmt/pull/2882,
+    https://github.com/fmtlib/fmt/issues/2886,
+    https://github.com/fmtlib/fmt/issues/2891,
+    https://github.com/fmtlib/fmt/pull/2892,
+    https://github.com/fmtlib/fmt/issues/2895,
+    https://github.com/fmtlib/fmt/issues/2896,
+    https://github.com/fmtlib/fmt/pull/2903,
+    https://github.com/fmtlib/fmt/issues/2906,
+    https://github.com/fmtlib/fmt/issues/2908,
+    https://github.com/fmtlib/fmt/pull/2909,
+    https://github.com/fmtlib/fmt/issues/2920,
+    https://github.com/fmtlib/fmt/pull/2922,
+    https://github.com/fmtlib/fmt/pull/2927,
+    https://github.com/fmtlib/fmt/pull/2929,
+    https://github.com/fmtlib/fmt/issues/2936,
+    https://github.com/fmtlib/fmt/pull/2937,
+    https://github.com/fmtlib/fmt/pull/2938,
+    https://github.com/fmtlib/fmt/pull/2951,
+    https://github.com/fmtlib/fmt/issues/2954,
+    https://github.com/fmtlib/fmt/pull/2957,
+    https://github.com/fmtlib/fmt/issues/2958,
+    https://github.com/fmtlib/fmt/pull/2960).
+    Thanks @matrackif @Tobi823, @ivan-volnov, @VasiliPupkin256,
+    @federico-busato, @barcharcraz, @jk-jeon, @HazardyKnusperkeks, @dalboris,
+    @seanm, @gsjaardema, @timsong-cpp, @seanm, @frithrah, @chronoxor, @Agga,
+    @madmaxoft, @JurajX, @phprus and @Dani-Hub.
+
+# 8.1.1 - 2022-01-06
+
+-   Restored ABI compatibility with version 8.0.x
+    (https://github.com/fmtlib/fmt/issues/2695,
+    https://github.com/fmtlib/fmt/pull/2696). Thanks @saraedum.
+-   Fixed chrono formatting on big endian systems
+    (https://github.com/fmtlib/fmt/issues/2698,
+    https://github.com/fmtlib/fmt/pull/2699).
+    Thanks @phprus and @xvitaly.
+-   Fixed a linkage error with mingw
+    (https://github.com/fmtlib/fmt/issues/2691,
+    https://github.com/fmtlib/fmt/pull/2692). Thanks @rbberger.
+
+# 8.1.0 - 2022-01-02
+
+-   Optimized chrono formatting
+    (https://github.com/fmtlib/fmt/pull/2500,
+    https://github.com/fmtlib/fmt/pull/2537,
+    https://github.com/fmtlib/fmt/issues/2541,
+    https://github.com/fmtlib/fmt/pull/2544,
+    https://github.com/fmtlib/fmt/pull/2550,
+    https://github.com/fmtlib/fmt/pull/2551,
+    https://github.com/fmtlib/fmt/pull/2576,
+    https://github.com/fmtlib/fmt/issues/2577,
+    https://github.com/fmtlib/fmt/pull/2586,
+    https://github.com/fmtlib/fmt/pull/2591,
+    https://github.com/fmtlib/fmt/pull/2594,
+    https://github.com/fmtlib/fmt/pull/2602,
+    https://github.com/fmtlib/fmt/pull/2617,
+    https://github.com/fmtlib/fmt/issues/2628,
+    https://github.com/fmtlib/fmt/pull/2633,
+    https://github.com/fmtlib/fmt/issues/2670,
+    https://github.com/fmtlib/fmt/pull/2671).
+
+    Processing of some specifiers such as `%z` and `%Y` is now up to
+    10-20 times faster, for example on GCC 11 with libstdc++:
+
+        ----------------------------------------------------------------------------
+        Benchmark                                  Before             After
+        ----------------------------------------------------------------------------
+        FMTFormatter_z                             261 ns             26.3 ns
+        FMTFormatterCompile_z                      246 ns             11.6 ns
+        FMTFormatter_Y                             263 ns             26.1 ns
+        FMTFormatterCompile_Y                      244 ns             10.5 ns
+        ----------------------------------------------------------------------------
+
+    Thanks @phprus and @toughengineer.
+
+-   Implemented subsecond formatting for chrono durations
+    (https://github.com/fmtlib/fmt/pull/2623). For example
+    ([godbolt](https://godbolt.org/z/es7vWTETe)):
+
+    ```c++
+    #include <fmt/chrono.h>
+
+    int main() {
+      fmt::print("{:%S}", std::chrono::milliseconds(1234));
+    }
+    ```
+
+    prints \"01.234\".
+
+    Thanks @matrackif.
+
+-   Fixed handling of precision 0 when formatting chrono durations
+    (https://github.com/fmtlib/fmt/issues/2587,
+    https://github.com/fmtlib/fmt/pull/2588). Thanks @lukester1975.
+
+-   Fixed an overflow on invalid inputs in the `tm` formatter
+    (https://github.com/fmtlib/fmt/pull/2564). Thanks @phprus.
+
+-   Added `fmt::group_digits` that formats integers with a non-localized
+    digit separator (comma) for groups of three digits. For example
+    ([godbolt](https://godbolt.org/z/TxGxG9Poq)):
+
+    ```c++
+    #include <fmt/format.h>
+
+    int main() {
+      fmt::print("{} dollars", fmt::group_digits(1000000));
+    }
+    ```
+
+    prints \"1,000,000 dollars\".
+
+-   Added support for faint, conceal, reverse and blink text styles
+    (https://github.com/fmtlib/fmt/pull/2394):
+
+    <https://user-images.githubusercontent.com/576385/147710227-c68f5317-f8fa-42c3-9123-7c4ba3c398cb.mp4>
+
+    Thanks @benit8 and @data-man.
+
+-   Added experimental support for compile-time floating point
+    formatting (https://github.com/fmtlib/fmt/pull/2426,
+    https://github.com/fmtlib/fmt/pull/2470). It is currently
+    limited to the header-only mode. Thanks @alexezeder.
+
+-   Added UDL-based named argument support to compile-time format string
+    checks (https://github.com/fmtlib/fmt/issues/2640,
+    https://github.com/fmtlib/fmt/pull/2649). For example
+    ([godbolt](https://godbolt.org/z/ohGbbvonv)):
+
+    ```c++
+    #include <fmt/format.h>
+
+    int main() {
+      using namespace fmt::literals;
+      fmt::print("{answer:s}", "answer"_a=42);
+    }
+    ```
+
+    gives a compile-time error on compilers with C++20 `consteval` and
+    non-type template parameter support (gcc 10+) because `s` is not a
+    valid format specifier for an integer.
+
+    Thanks @alexezeder.
+
+-   Implemented escaping of string range elements. For example
+    ([godbolt](https://godbolt.org/z/rKvM1vKf3)):
+
+    ```c++
+    #include <fmt/ranges.h>
+    #include <vector>
+
+    int main() {
+      fmt::print("{}", std::vector<std::string>{"\naan"});
+    }
+    ```
+
+    is now printed as:
+
+        ["\naan"]
+
+    instead of:
+
+        ["
+        aan"]
+
+-   Added an experimental `?` specifier for escaping strings.
+    (https://github.com/fmtlib/fmt/pull/2674). Thanks @BRevzin.
+
+-   Switched to JSON-like representation of maps and sets for
+    consistency with Python\'s `str.format`. For example
+    ([godbolt](https://godbolt.org/z/seKjoY9W5)):
+
+    ```c++
+    #include <fmt/ranges.h>
+    #include <map>
+
+    int main() {
+      fmt::print("{}", std::map<std::string, int>{{"answer", 42}});
+    }
+    ```
+
+    is now printed as:
+
+        {"answer": 42}
+
+-   Extended `fmt::join` to support C++20-only ranges
+    (https://github.com/fmtlib/fmt/pull/2549). Thanks @BRevzin.
+
+-   Optimized handling of non-const-iterable ranges and implemented
+    initial support for non-const-formattable types.
+
+-   Disabled implicit conversions of scoped enums to integers that was
+    accidentally introduced in earlier versions
+    (https://github.com/fmtlib/fmt/pull/1841).
+
+-   Deprecated implicit conversion of `[const] signed char*` and
+    `[const] unsigned char*` to C strings.
+
+-   Deprecated `_format`, a legacy UDL-based format API
+    (https://github.com/fmtlib/fmt/pull/2646). Thanks @alexezeder.
+
+-   Marked `format`, `formatted_size` and `to_string` as `[[nodiscard]]`
+    (https://github.com/fmtlib/fmt/pull/2612). @0x8000-0000.
+
+-   Added missing diagnostic when trying to format function and member
+    pointers as well as objects convertible to pointers which is
+    explicitly disallowed
+    (https://github.com/fmtlib/fmt/issues/2598,
+    https://github.com/fmtlib/fmt/pull/2609,
+    https://github.com/fmtlib/fmt/pull/2610). Thanks @AlexGuteniev.
+
+-   Optimized writing to a contiguous buffer with `format_to_n`
+    (https://github.com/fmtlib/fmt/pull/2489). Thanks @Roman-Koshelev.
+
+-   Optimized writing to non-`char` buffers
+    (https://github.com/fmtlib/fmt/pull/2477). Thanks @Roman-Koshelev.
+
+-   Decimal point is now localized when using the `L` specifier.
+
+-   Improved floating point formatter implementation
+    (https://github.com/fmtlib/fmt/pull/2498,
+    https://github.com/fmtlib/fmt/pull/2499). Thanks @Roman-Koshelev.
+
+-   Fixed handling of very large precision in fixed format
+    (https://github.com/fmtlib/fmt/pull/2616).
+
+-   Made a table of cached powers used in FP formatting static
+    (https://github.com/fmtlib/fmt/pull/2509). Thanks @jk-jeon.
+
+-   Resolved a lookup ambiguity with C++20 format-related functions due
+    to ADL (https://github.com/fmtlib/fmt/issues/2639,
+    https://github.com/fmtlib/fmt/pull/2641). Thanks @mkurdej.
+
+-   Removed unnecessary inline namespace qualification
+    (https://github.com/fmtlib/fmt/issues/2642,
+    https://github.com/fmtlib/fmt/pull/2643). Thanks @mkurdej.
+
+-   Implemented argument forwarding in `format_to_n`
+    (https://github.com/fmtlib/fmt/issues/2462,
+    https://github.com/fmtlib/fmt/pull/2463). Thanks @owent.
+
+-   Fixed handling of implicit conversions in `fmt::to_string` and
+    format string compilation
+    (https://github.com/fmtlib/fmt/issues/2565).
+
+-   Changed the default access mode of files created by
+    `fmt::output_file` to `-rw-r--r--` for consistency with `fopen`
+    (https://github.com/fmtlib/fmt/issues/2530).
+
+-   Make `fmt::ostream::flush` public
+    (https://github.com/fmtlib/fmt/issues/2435).
+
+-   Improved C++14/17 attribute detection
+    (https://github.com/fmtlib/fmt/pull/2615). Thanks @AlexGuteniev.
+
+-   Improved `consteval` detection for MSVC
+    (https://github.com/fmtlib/fmt/pull/2559). Thanks @DanielaE.
+
+-   Improved documentation
+    (https://github.com/fmtlib/fmt/issues/2406,
+    https://github.com/fmtlib/fmt/pull/2446,
+    https://github.com/fmtlib/fmt/issues/2493,
+    https://github.com/fmtlib/fmt/issues/2513,
+    https://github.com/fmtlib/fmt/pull/2515,
+    https://github.com/fmtlib/fmt/issues/2522,
+    https://github.com/fmtlib/fmt/pull/2562,
+    https://github.com/fmtlib/fmt/pull/2575,
+    https://github.com/fmtlib/fmt/pull/2606,
+    https://github.com/fmtlib/fmt/pull/2620,
+    https://github.com/fmtlib/fmt/issues/2676).
+    Thanks @sobolevn, @UnePierre, @zhsj, @phprus, @ericcurtin and @Lounarok.
+
+-   Improved fuzzers and added a fuzzer for chrono timepoint formatting
+    (https://github.com/fmtlib/fmt/pull/2461,
+    https://github.com/fmtlib/fmt/pull/2469). @pauldreik,
+
+-   Added the `FMT_SYSTEM_HEADERS` CMake option setting which marks
+    {fmt}\'s headers as system. It can be used to suppress warnings
+    (https://github.com/fmtlib/fmt/issues/2644,
+    https://github.com/fmtlib/fmt/pull/2651). Thanks @alexezeder.
+
+-   Added the Bazel build system support
+    (https://github.com/fmtlib/fmt/pull/2505,
+    https://github.com/fmtlib/fmt/pull/2516). Thanks @Vertexwahn.
+
+-   Improved build configuration and tests
+    (https://github.com/fmtlib/fmt/issues/2437,
+    https://github.com/fmtlib/fmt/pull/2558,
+    https://github.com/fmtlib/fmt/pull/2648,
+    https://github.com/fmtlib/fmt/pull/2650,
+    https://github.com/fmtlib/fmt/pull/2663,
+    https://github.com/fmtlib/fmt/pull/2677).
+    Thanks @DanielaE, @alexezeder and @phprus.
+
+-   Fixed various warnings and compilation issues
+    (https://github.com/fmtlib/fmt/pull/2353,
+    https://github.com/fmtlib/fmt/pull/2356,
+    https://github.com/fmtlib/fmt/pull/2399,
+    https://github.com/fmtlib/fmt/issues/2408,
+    https://github.com/fmtlib/fmt/pull/2414,
+    https://github.com/fmtlib/fmt/pull/2427,
+    https://github.com/fmtlib/fmt/pull/2432,
+    https://github.com/fmtlib/fmt/pull/2442,
+    https://github.com/fmtlib/fmt/pull/2434,
+    https://github.com/fmtlib/fmt/issues/2439,
+    https://github.com/fmtlib/fmt/pull/2447,
+    https://github.com/fmtlib/fmt/pull/2450,
+    https://github.com/fmtlib/fmt/issues/2455,
+    https://github.com/fmtlib/fmt/issues/2465,
+    https://github.com/fmtlib/fmt/issues/2472,
+    https://github.com/fmtlib/fmt/issues/2474,
+    https://github.com/fmtlib/fmt/pull/2476,
+    https://github.com/fmtlib/fmt/issues/2478,
+    https://github.com/fmtlib/fmt/issues/2479,
+    https://github.com/fmtlib/fmt/issues/2481,
+    https://github.com/fmtlib/fmt/pull/2482,
+    https://github.com/fmtlib/fmt/pull/2483,
+    https://github.com/fmtlib/fmt/issues/2490,
+    https://github.com/fmtlib/fmt/pull/2491,
+    https://github.com/fmtlib/fmt/pull/2510,
+    https://github.com/fmtlib/fmt/pull/2518,
+    https://github.com/fmtlib/fmt/issues/2528,
+    https://github.com/fmtlib/fmt/pull/2529,
+    https://github.com/fmtlib/fmt/pull/2539,
+    https://github.com/fmtlib/fmt/issues/2540,
+    https://github.com/fmtlib/fmt/pull/2545,
+    https://github.com/fmtlib/fmt/pull/2555,
+    https://github.com/fmtlib/fmt/issues/2557,
+    https://github.com/fmtlib/fmt/issues/2570,
+    https://github.com/fmtlib/fmt/pull/2573,
+    https://github.com/fmtlib/fmt/pull/2582,
+    https://github.com/fmtlib/fmt/issues/2605,
+    https://github.com/fmtlib/fmt/pull/2611,
+    https://github.com/fmtlib/fmt/pull/2647,
+    https://github.com/fmtlib/fmt/issues/2627,
+    https://github.com/fmtlib/fmt/pull/2630,
+    https://github.com/fmtlib/fmt/issues/2635,
+    https://github.com/fmtlib/fmt/issues/2638,
+    https://github.com/fmtlib/fmt/issues/2653,
+    https://github.com/fmtlib/fmt/issues/2654,
+    https://github.com/fmtlib/fmt/issues/2661,
+    https://github.com/fmtlib/fmt/pull/2664,
+    https://github.com/fmtlib/fmt/pull/2684).
+    Thanks @DanielaE, @mwinterb, @cdacamar, @TrebledJ, @bodomartin, @cquammen,
+    @white238, @mmarkeloff, @palacaze, @jcelerier, @mborn-adi, @BrukerJWD,
+    @spyridon97, @phprus, @oliverlee, @joshessman-llnl, @akohlmey, @timkalu,
+    @olupton, @Acretock, @alexezeder, @andrewcorrigan, @lucpelletier and
+    @HazardyKnusperkeks.
+
+# 8.0.1 - 2021-07-02
+
+-   Fixed the version number in the inline namespace
+    (https://github.com/fmtlib/fmt/issues/2374).
+-   Added a missing presentation type check for `std::string`
+    (https://github.com/fmtlib/fmt/issues/2402).
+-   Fixed a linkage error when mixing code built with clang and gcc
+    (https://github.com/fmtlib/fmt/issues/2377).
+-   Fixed documentation issues
+    (https://github.com/fmtlib/fmt/pull/2396,
+    https://github.com/fmtlib/fmt/issues/2403,
+    https://github.com/fmtlib/fmt/issues/2406). Thanks @mkurdej.
+-   Removed dead code in FP formatter (
+    https://github.com/fmtlib/fmt/pull/2398). Thanks @javierhonduco.
+-   Fixed various warnings and compilation issues
+    (https://github.com/fmtlib/fmt/issues/2351,
+    https://github.com/fmtlib/fmt/issues/2359,
+    https://github.com/fmtlib/fmt/pull/2365,
+    https://github.com/fmtlib/fmt/issues/2368,
+    https://github.com/fmtlib/fmt/pull/2370,
+    https://github.com/fmtlib/fmt/pull/2376,
+    https://github.com/fmtlib/fmt/pull/2381,
+    https://github.com/fmtlib/fmt/pull/2382,
+    https://github.com/fmtlib/fmt/issues/2386,
+    https://github.com/fmtlib/fmt/pull/2389,
+    https://github.com/fmtlib/fmt/pull/2395,
+    https://github.com/fmtlib/fmt/pull/2397,
+    https://github.com/fmtlib/fmt/issues/2400,
+    https://github.com/fmtlib/fmt/issues/2401,
+    https://github.com/fmtlib/fmt/pull/2407).
+    Thanks @zx2c4, @AidanSun05, @mattiasljungstrom, @joemmett, @erengy,
+    @patlkli, @gsjaardema and @phprus.
+
+# 8.0.0 - 2021-06-21
+
+-   Enabled compile-time format string checks by default. For example
+    ([godbolt](https://godbolt.org/z/sMxcohGjz)):
+
+    ```c++
+    #include <fmt/core.h>
+
+    int main() {
+      fmt::print("{:d}", "I am not a number");
+    }
+    ```
+
+    gives a compile-time error on compilers with C++20 `consteval`
+    support (gcc 10+, clang 11+) because `d` is not a valid format
+    specifier for a string.
+
+    To pass a runtime string wrap it in `fmt::runtime`:
+
+    ```c++
+    fmt::print(fmt::runtime("{:d}"), "I am not a number");
+    ```
+
+-   Added compile-time formatting
+    (https://github.com/fmtlib/fmt/pull/2019,
+    https://github.com/fmtlib/fmt/pull/2044,
+    https://github.com/fmtlib/fmt/pull/2056,
+    https://github.com/fmtlib/fmt/pull/2072,
+    https://github.com/fmtlib/fmt/pull/2075,
+    https://github.com/fmtlib/fmt/issues/2078,
+    https://github.com/fmtlib/fmt/pull/2129,
+    https://github.com/fmtlib/fmt/pull/2326). For example
+    ([godbolt](https://godbolt.org/z/Mxx9d89jM)):
+
+    ```c++
+    #include <fmt/compile.h>
+
+    consteval auto compile_time_itoa(int value) -> std::array<char, 10> {
+      auto result = std::array<char, 10>();
+      fmt::format_to(result.data(), FMT_COMPILE("{}"), value);
+      return result;
+    }
+
+    constexpr auto answer = compile_time_itoa(42);
+    ```
+
+    Most of the formatting functionality is available at compile time
+    with a notable exception of floating-point numbers and pointers.
+    Thanks @alexezeder.
+
+-   Optimized handling of format specifiers during format string
+    compilation. For example, hexadecimal formatting (`"{:x}"`) is now
+    3-7x faster than before when using `format_to` with format string
+    compilation and a stack-allocated buffer
+    (https://github.com/fmtlib/fmt/issues/1944).
+
+    Before (7.1.3):
+
+        ----------------------------------------------------------------------------
+        Benchmark                                  Time             CPU   Iterations
+        ----------------------------------------------------------------------------
+        FMTCompileOld/0                         15.5 ns         15.5 ns     43302898
+        FMTCompileOld/42                        16.6 ns         16.6 ns     43278267
+        FMTCompileOld/273123                    18.7 ns         18.6 ns     37035861
+        FMTCompileOld/9223372036854775807       19.4 ns         19.4 ns     35243000
+        ----------------------------------------------------------------------------
+
+    After (8.x):
+
+        ----------------------------------------------------------------------------
+        Benchmark                                  Time             CPU   Iterations
+        ----------------------------------------------------------------------------
+        FMTCompileNew/0                         1.99 ns         1.99 ns    360523686
+        FMTCompileNew/42                        2.33 ns         2.33 ns    279865664
+        FMTCompileNew/273123                    3.72 ns         3.71 ns    190230315
+        FMTCompileNew/9223372036854775807       5.28 ns         5.26 ns    130711631
+        ----------------------------------------------------------------------------
+
+    It is even faster than `std::to_chars` from libc++ compiled with
+    clang on macOS:
+
+        ----------------------------------------------------------------------------
+        Benchmark                                  Time             CPU   Iterations
+        ----------------------------------------------------------------------------
+        ToChars/0                               4.42 ns         4.41 ns    160196630
+        ToChars/42                              5.00 ns         4.98 ns    140735201
+        ToChars/273123                          7.26 ns         7.24 ns     95784130
+        ToChars/9223372036854775807             8.77 ns         8.75 ns     75872534
+        ----------------------------------------------------------------------------
+
+    In other cases, especially involving `std::string` construction, the
+    speed up is usually lower because handling format specifiers takes a
+    smaller fraction of the total time.
+
+-   Added the `_cf` user-defined literal to represent a compiled format
+    string. It can be used instead of the `FMT_COMPILE` macro
+    (https://github.com/fmtlib/fmt/pull/2043,
+    https://github.com/fmtlib/fmt/pull/2242):
+
+    ```c++
+    #include <fmt/compile.h>
+
+    using namespace fmt::literals;
+    auto s = fmt::format(FMT_COMPILE("{}"), 42); // 🙁 not modern
+    auto s = fmt::format("{}"_cf, 42);           // 🙂 modern as hell
+    ```
+
+    It requires compiler support for class types in non-type template
+    parameters (a C++20 feature) which is available in GCC 9.3+.
+    Thanks @alexezeder.
+
+-   Format string compilation now requires `format` functions of
+    `formatter` specializations for user-defined types to be `const`:
+
+    ```c++
+    template <> struct fmt::formatter<my_type>: formatter<string_view> {
+      template <typename FormatContext>
+      auto format(my_type obj, FormatContext& ctx) const {  // Note const here.
+        // ...
+      }
+    };
+    ```
+
+-   Added UDL-based named argument support to format string compilation
+    (https://github.com/fmtlib/fmt/pull/2243,
+    https://github.com/fmtlib/fmt/pull/2281). For example:
+
+    ```c++
+    #include <fmt/compile.h>
+
+    using namespace fmt::literals;
+    auto s = fmt::format(FMT_COMPILE("{answer}"), "answer"_a = 42);
+    ```
+
+    Here the argument named \"answer\" is resolved at compile time with
+    no runtime overhead. Thanks @alexezeder.
+
+-   Added format string compilation support to `fmt::print`
+    (https://github.com/fmtlib/fmt/issues/2280,
+    https://github.com/fmtlib/fmt/pull/2304). Thanks @alexezeder.
+
+-   Added initial support for compiling {fmt} as a C++20 module
+    (https://github.com/fmtlib/fmt/pull/2235,
+    https://github.com/fmtlib/fmt/pull/2240,
+    https://github.com/fmtlib/fmt/pull/2260,
+    https://github.com/fmtlib/fmt/pull/2282,
+    https://github.com/fmtlib/fmt/pull/2283,
+    https://github.com/fmtlib/fmt/pull/2288,
+    https://github.com/fmtlib/fmt/pull/2298,
+    https://github.com/fmtlib/fmt/pull/2306,
+    https://github.com/fmtlib/fmt/pull/2307,
+    https://github.com/fmtlib/fmt/pull/2309,
+    https://github.com/fmtlib/fmt/pull/2318,
+    https://github.com/fmtlib/fmt/pull/2324,
+    https://github.com/fmtlib/fmt/pull/2332,
+    https://github.com/fmtlib/fmt/pull/2340). Thanks @DanielaE.
+
+-   Made symbols private by default reducing shared library size
+    (https://github.com/fmtlib/fmt/pull/2301). For example
+    there was a \~15% reported reduction on one platform. Thanks @sergiud.
+
+-   Optimized includes making the result of preprocessing `fmt/format.h`
+    \~20% smaller with libstdc++/C++20 and slightly improving build
+    times (https://github.com/fmtlib/fmt/issues/1998).
+
+-   Added support of ranges with non-const `begin` / `end`
+    (https://github.com/fmtlib/fmt/pull/1953). Thanks @kitegi.
+
+-   Added support of `std::byte` and other formattable types to
+    `fmt::join` (https://github.com/fmtlib/fmt/issues/1981,
+    https://github.com/fmtlib/fmt/issues/2040,
+    https://github.com/fmtlib/fmt/pull/2050,
+    https://github.com/fmtlib/fmt/issues/2262). For example:
+
+    ```c++
+    #include <fmt/format.h>
+    #include <cstddef>
+    #include <vector>
+
+    int main() {
+      auto bytes = std::vector{std::byte(4), std::byte(2)};
+      fmt::print("{}", fmt::join(bytes, ""));
+    }
+    ```
+
+    prints \"42\".
+
+    Thanks @kamibo.
+
+-   Implemented the default format for `std::chrono::system_clock`
+    (https://github.com/fmtlib/fmt/issues/2319,
+    https://github.com/fmtlib/fmt/pull/2345). For example:
+
+    ```c++
+    #include <fmt/chrono.h>
+
+    int main() {
+      fmt::print("{}", std::chrono::system_clock::now());
+    }
+    ```
+
+    prints \"2021-06-18 15:22:00\" (the output depends on the current
+    date and time). Thanks @sunmy2019.
+
+-   Made more chrono specifiers locale independent by default. Use the
+    `'L'` specifier to get localized formatting. For example:
+
+    ```c++
+    #include <fmt/chrono.h>
+
+    int main() {
+      std::locale::global(std::locale("ru_RU.UTF-8"));
+      auto monday = std::chrono::weekday(1);
+      fmt::print("{}\n", monday);   // prints "Mon"
+      fmt::print("{:L}\n", monday); // prints "пн"
+    }
+    ```
+
+-   Improved locale handling in chrono formatting
+    (https://github.com/fmtlib/fmt/issues/2337,
+    https://github.com/fmtlib/fmt/pull/2349,
+    https://github.com/fmtlib/fmt/pull/2350). Thanks @phprus.
+
+-   Deprecated `fmt/locale.h` moving the formatting functions that take
+    a locale to `fmt/format.h` (`char`) and `fmt/xchar` (other
+    overloads). This doesn\'t introduce a dependency on `<locale>` so
+    there is virtually no compile time effect.
+
+-   Deprecated an undocumented `format_to` overload that takes
+    `basic_memory_buffer`.
+
+-   Made parameter order in `vformat_to` consistent with `format_to`
+    (https://github.com/fmtlib/fmt/issues/2327).
+
+-   Added support for time points with arbitrary durations
+    (https://github.com/fmtlib/fmt/issues/2208). For example:
+
+    ```c++
+    #include <fmt/chrono.h>
+
+    int main() {
+      using tp = std::chrono::time_point<
+        std::chrono::system_clock, std::chrono::seconds>;
+      fmt::print("{:%S}", tp(std::chrono::seconds(42)));
+    }
+    ```
+
+    prints \"42\".
+
+-   Formatting floating-point numbers no longer produces trailing zeros
+    by default for consistency with `std::format`. For example:
+
+    ```c++
+    #include <fmt/core.h>
+
+    int main() {
+      fmt::print("{0:.3}", 1.1);
+    }
+    ```
+
+    prints \"1.1\". Use the `'#'` specifier to keep trailing zeros.
+
+-   Dropped a limit on the number of elements in a range and replaced
+    `{}` with `[]` as range delimiters for consistency with Python\'s
+    `str.format`.
+
+-   The `'L'` specifier for locale-specific numeric formatting can now
+    be combined with presentation specifiers as in `std::format`. For
+    example:
+
+    ```c++
+    #include <fmt/core.h>
+    #include <locale>
+
+    int main() {
+      std::locale::global(std::locale("fr_FR.UTF-8"));
+      fmt::print("{0:.2Lf}", 0.42);
+    }
+    ```
+
+    prints \"0,42\". The deprecated `'n'` specifier has been removed.
+
+-   Made the `0` specifier ignored for infinity and NaN
+    (https://github.com/fmtlib/fmt/issues/2305,
+    https://github.com/fmtlib/fmt/pull/2310). Thanks @Liedtke.
+
+-   Made the hexfloat formatting use the right alignment by default
+    (https://github.com/fmtlib/fmt/issues/2308,
+    https://github.com/fmtlib/fmt/pull/2317). Thanks @Liedtke.
+
+-   Removed the deprecated numeric alignment (`'='`). Use the `'0'`
+    specifier instead.
+
+-   Removed the deprecated `fmt/posix.h` header that has been replaced
+    with `fmt/os.h`.
+
+-   Removed the deprecated `format_to_n_context`, `format_to_n_args` and
+    `make_format_to_n_args`. They have been replaced with
+    `format_context`, `` format_args` and ``make_format_args\`\`
+    respectively.
+
+-   Moved `wchar_t`-specific functions and types to `fmt/xchar.h`. You
+    can define `FMT_DEPRECATED_INCLUDE_XCHAR` to automatically include
+    `fmt/xchar.h` from `fmt/format.h` but this will be disabled in the
+    next major release.
+
+-   Fixed handling of the `'+'` specifier in localized formatting
+    (https://github.com/fmtlib/fmt/issues/2133).
+
+-   Added support for the `'s'` format specifier that gives textual
+    representation of `bool`
+    (https://github.com/fmtlib/fmt/issues/2094,
+    https://github.com/fmtlib/fmt/pull/2109). For example:
+
+    ```c++
+    #include <fmt/core.h>
+
+    int main() {
+      fmt::print("{:s}", true);
+    }
+    ```
+
+    prints \"true\". Thanks @powercoderlol.
+
+-   Made `fmt::ptr` work with function pointers
+    (https://github.com/fmtlib/fmt/pull/2131). For example:
+
+    ```c++
+    #include <fmt/format.h>
+
+    int main() {
+      fmt::print("My main: {}\n", fmt::ptr(main));
+    }
+    ```
+
+    Thanks @mikecrowe.
+
+-   The undocumented support for specializing `formatter` for pointer
+    types has been removed.
+
+-   Fixed `fmt::formatted_size` with format string compilation
+    (https://github.com/fmtlib/fmt/pull/2141,
+    https://github.com/fmtlib/fmt/pull/2161). Thanks @alexezeder.
+
+-   Fixed handling of empty format strings during format string
+    compilation (https://github.com/fmtlib/fmt/issues/2042):
+
+    ```c++
+    auto s = fmt::format(FMT_COMPILE(""));
+    ```
+
+    Thanks @alexezeder.
+
+-   Fixed handling of enums in `fmt::to_string`
+    (https://github.com/fmtlib/fmt/issues/2036).
+
+-   Improved width computation
+    (https://github.com/fmtlib/fmt/issues/2033,
+    https://github.com/fmtlib/fmt/issues/2091). For example:
+
+    ```c++
+    #include <fmt/core.h>
+
+    int main() {
+      fmt::print("{:-<10}{}\n", "你好", "世界");
+      fmt::print("{:-<10}{}\n", "hello", "world");
+    }
+    ```
+
+    prints
+
+    ![](https://user-images.githubusercontent.com/576385/119840373-cea3ca80-beb9-11eb-91e0-54266c48e181.png)
+
+    on a modern terminal.
+
+-   The experimental fast output stream (`fmt::ostream`) is now
+    truncated by default for consistency with `fopen`
+    (https://github.com/fmtlib/fmt/issues/2018). For example:
+
+    ```c++
+    #include <fmt/os.h>
+
+    int main() {
+      fmt::ostream out1 = fmt::output_file("guide");
+      out1.print("Zaphod");
+      out1.close();
+      fmt::ostream out2 = fmt::output_file("guide");
+      out2.print("Ford");
+    }
+    ```
+
+    writes \"Ford\" to the file \"guide\". To preserve the old file
+    content if any pass `fmt::file::WRONLY | fmt::file::CREATE` flags to
+    `fmt::output_file`.
+
+-   Fixed moving of `fmt::ostream` that holds buffered data
+    (https://github.com/fmtlib/fmt/issues/2197,
+    https://github.com/fmtlib/fmt/pull/2198). Thanks @vtta.
+
+-   Replaced the `fmt::system_error` exception with a function of the
+    same name that constructs `std::system_error`
+    (https://github.com/fmtlib/fmt/issues/2266).
+
+-   Replaced the `fmt::windows_error` exception with a function of the
+    same name that constructs `std::system_error` with the category
+    returned by `fmt::system_category()`
+    (https://github.com/fmtlib/fmt/issues/2274,
+    https://github.com/fmtlib/fmt/pull/2275). The latter is
+    similar to `std::sytem_category` but correctly handles UTF-8.
+    Thanks @phprus.
+
+-   Replaced `fmt::error_code` with `std::error_code` and made it
+    formattable (https://github.com/fmtlib/fmt/issues/2269,
+    https://github.com/fmtlib/fmt/pull/2270,
+    https://github.com/fmtlib/fmt/pull/2273). Thanks @phprus.
+
+-   Added speech synthesis support
+    (https://github.com/fmtlib/fmt/pull/2206).
+
+-   Made `format_to` work with a memory buffer that has a custom
+    allocator (https://github.com/fmtlib/fmt/pull/2300).
+    Thanks @voxmea.
+
+-   Added `Allocator::max_size` support to `basic_memory_buffer`.
+    (https://github.com/fmtlib/fmt/pull/1960). Thanks @phprus.
+
+-   Added wide string support to `fmt::join`
+    (https://github.com/fmtlib/fmt/pull/2236). Thanks @crbrz.
+
+-   Made iterators passed to `formatter` specializations via a format
+    context satisfy C++20 `std::output_iterator` requirements
+    (https://github.com/fmtlib/fmt/issues/2156,
+    https://github.com/fmtlib/fmt/pull/2158,
+    https://github.com/fmtlib/fmt/issues/2195,
+    https://github.com/fmtlib/fmt/pull/2204). Thanks @randomnetcat.
+
+-   Optimized the `printf` implementation
+    (https://github.com/fmtlib/fmt/pull/1982,
+    https://github.com/fmtlib/fmt/pull/1984,
+    https://github.com/fmtlib/fmt/pull/2016,
+    https://github.com/fmtlib/fmt/pull/2164).
+    Thanks @rimathia and @moiwi.
+
+-   Improved detection of `constexpr` `char_traits`
+    (https://github.com/fmtlib/fmt/pull/2246,
+    https://github.com/fmtlib/fmt/pull/2257). Thanks @phprus.
+
+-   Fixed writing to `stdout` when it is redirected to `NUL` on Windows
+    (https://github.com/fmtlib/fmt/issues/2080).
+
+-   Fixed exception propagation from iterators
+    (https://github.com/fmtlib/fmt/issues/2097).
+
+-   Improved `strftime` error handling
+    (https://github.com/fmtlib/fmt/issues/2238,
+    https://github.com/fmtlib/fmt/pull/2244). Thanks @yumeyao.
+
+-   Stopped using deprecated GCC UDL template extension.
+
+-   Added `fmt/args.h` to the install target
+    (https://github.com/fmtlib/fmt/issues/2096).
+
+-   Error messages are now passed to assert when exceptions are disabled
+    (https://github.com/fmtlib/fmt/pull/2145). Thanks @NobodyXu.
+
+-   Added the `FMT_MASTER_PROJECT` CMake option to control build and
+    install targets when {fmt} is included via `add_subdirectory`
+    (https://github.com/fmtlib/fmt/issues/2098,
+    https://github.com/fmtlib/fmt/pull/2100).
+    Thanks @randomizedthinking.
+
+-   Improved build configuration
+    (https://github.com/fmtlib/fmt/pull/2026,
+    https://github.com/fmtlib/fmt/pull/2122).
+    Thanks @luncliff and @ibaned.
+
+-   Fixed various warnings and compilation issues
+    (https://github.com/fmtlib/fmt/issues/1947,
+    https://github.com/fmtlib/fmt/pull/1959,
+    https://github.com/fmtlib/fmt/pull/1963,
+    https://github.com/fmtlib/fmt/pull/1965,
+    https://github.com/fmtlib/fmt/issues/1966,
+    https://github.com/fmtlib/fmt/pull/1974,
+    https://github.com/fmtlib/fmt/pull/1975,
+    https://github.com/fmtlib/fmt/pull/1990,
+    https://github.com/fmtlib/fmt/issues/2000,
+    https://github.com/fmtlib/fmt/pull/2001,
+    https://github.com/fmtlib/fmt/issues/2002,
+    https://github.com/fmtlib/fmt/issues/2004,
+    https://github.com/fmtlib/fmt/pull/2006,
+    https://github.com/fmtlib/fmt/pull/2009,
+    https://github.com/fmtlib/fmt/pull/2010,
+    https://github.com/fmtlib/fmt/issues/2038,
+    https://github.com/fmtlib/fmt/issues/2039,
+    https://github.com/fmtlib/fmt/issues/2047,
+    https://github.com/fmtlib/fmt/pull/2053,
+    https://github.com/fmtlib/fmt/issues/2059,
+    https://github.com/fmtlib/fmt/pull/2065,
+    https://github.com/fmtlib/fmt/pull/2067,
+    https://github.com/fmtlib/fmt/pull/2068,
+    https://github.com/fmtlib/fmt/pull/2073,
+    https://github.com/fmtlib/fmt/issues/2103,
+    https://github.com/fmtlib/fmt/issues/2105,
+    https://github.com/fmtlib/fmt/pull/2106,
+    https://github.com/fmtlib/fmt/pull/2107,
+    https://github.com/fmtlib/fmt/issues/2116,
+    https://github.com/fmtlib/fmt/pull/2117,
+    https://github.com/fmtlib/fmt/issues/2118,
+    https://github.com/fmtlib/fmt/pull/2119,
+    https://github.com/fmtlib/fmt/issues/2127,
+    https://github.com/fmtlib/fmt/pull/2128,
+    https://github.com/fmtlib/fmt/issues/2140,
+    https://github.com/fmtlib/fmt/issues/2142,
+    https://github.com/fmtlib/fmt/pull/2143,
+    https://github.com/fmtlib/fmt/pull/2144,
+    https://github.com/fmtlib/fmt/issues/2147,
+    https://github.com/fmtlib/fmt/issues/2148,
+    https://github.com/fmtlib/fmt/issues/2149,
+    https://github.com/fmtlib/fmt/pull/2152,
+    https://github.com/fmtlib/fmt/pull/2160,
+    https://github.com/fmtlib/fmt/issues/2170,
+    https://github.com/fmtlib/fmt/issues/2175,
+    https://github.com/fmtlib/fmt/issues/2176,
+    https://github.com/fmtlib/fmt/pull/2177,
+    https://github.com/fmtlib/fmt/issues/2178,
+    https://github.com/fmtlib/fmt/pull/2179,
+    https://github.com/fmtlib/fmt/issues/2180,
+    https://github.com/fmtlib/fmt/issues/2181,
+    https://github.com/fmtlib/fmt/pull/2183,
+    https://github.com/fmtlib/fmt/issues/2184,
+    https://github.com/fmtlib/fmt/issues/2185,
+    https://github.com/fmtlib/fmt/pull/2186,
+    https://github.com/fmtlib/fmt/pull/2187,
+    https://github.com/fmtlib/fmt/pull/2190,
+    https://github.com/fmtlib/fmt/pull/2192,
+    https://github.com/fmtlib/fmt/pull/2194,
+    https://github.com/fmtlib/fmt/pull/2205,
+    https://github.com/fmtlib/fmt/issues/2210,
+    https://github.com/fmtlib/fmt/pull/2211,
+    https://github.com/fmtlib/fmt/pull/2215,
+    https://github.com/fmtlib/fmt/pull/2216,
+    https://github.com/fmtlib/fmt/pull/2218,
+    https://github.com/fmtlib/fmt/pull/2220,
+    https://github.com/fmtlib/fmt/issues/2228,
+    https://github.com/fmtlib/fmt/pull/2229,
+    https://github.com/fmtlib/fmt/pull/2230,
+    https://github.com/fmtlib/fmt/issues/2233,
+    https://github.com/fmtlib/fmt/pull/2239,
+    https://github.com/fmtlib/fmt/issues/2248,
+    https://github.com/fmtlib/fmt/issues/2252,
+    https://github.com/fmtlib/fmt/pull/2253,
+    https://github.com/fmtlib/fmt/pull/2255,
+    https://github.com/fmtlib/fmt/issues/2261,
+    https://github.com/fmtlib/fmt/issues/2278,
+    https://github.com/fmtlib/fmt/issues/2284,
+    https://github.com/fmtlib/fmt/pull/2287,
+    https://github.com/fmtlib/fmt/pull/2289,
+    https://github.com/fmtlib/fmt/pull/2290,
+    https://github.com/fmtlib/fmt/pull/2293,
+    https://github.com/fmtlib/fmt/issues/2295,
+    https://github.com/fmtlib/fmt/pull/2296,
+    https://github.com/fmtlib/fmt/pull/2297,
+    https://github.com/fmtlib/fmt/issues/2311,
+    https://github.com/fmtlib/fmt/pull/2313,
+    https://github.com/fmtlib/fmt/pull/2315,
+    https://github.com/fmtlib/fmt/issues/2320,
+    https://github.com/fmtlib/fmt/pull/2321,
+    https://github.com/fmtlib/fmt/pull/2323,
+    https://github.com/fmtlib/fmt/issues/2328,
+    https://github.com/fmtlib/fmt/pull/2329,
+    https://github.com/fmtlib/fmt/pull/2333,
+    https://github.com/fmtlib/fmt/pull/2338,
+    https://github.com/fmtlib/fmt/pull/2341).
+    Thanks @darklukee, @fagg, @killerbot242, @jgopel, @yeswalrus, @Finkman,
+    @HazardyKnusperkeks, @dkavolis, @concatime, @chronoxor, @summivox, @yNeo,
+    @Apache-HB, @alexezeder, @toojays, @Brainy0207, @vadz, @imsherlock, @phprus,
+    @white238, @yafshar, @BillyDonahue, @jstaahl, @denchat, @DanielaE,
+    @ilyakurdyukov, @ilmai, @JessyDL, @sergiud, @mwinterb, @sven-herrmann,
+    @jmelas, @twoixter, @crbrz and @upsj.
+
+-   Improved documentation
+    (https://github.com/fmtlib/fmt/issues/1986,
+    https://github.com/fmtlib/fmt/pull/2051,
+    https://github.com/fmtlib/fmt/issues/2057,
+    https://github.com/fmtlib/fmt/pull/2081,
+    https://github.com/fmtlib/fmt/issues/2084,
+    https://github.com/fmtlib/fmt/pull/2312).
+    Thanks @imba-tjd, @0x416c69 and @mordante.
+
+-   Continuous integration and test improvements
+    (https://github.com/fmtlib/fmt/issues/1969,
+    https://github.com/fmtlib/fmt/pull/1991,
+    https://github.com/fmtlib/fmt/pull/2020,
+    https://github.com/fmtlib/fmt/pull/2110,
+    https://github.com/fmtlib/fmt/pull/2114,
+    https://github.com/fmtlib/fmt/issues/2196,
+    https://github.com/fmtlib/fmt/pull/2217,
+    https://github.com/fmtlib/fmt/pull/2247,
+    https://github.com/fmtlib/fmt/pull/2256,
+    https://github.com/fmtlib/fmt/pull/2336,
+    https://github.com/fmtlib/fmt/pull/2346).
+    Thanks @jgopel, @alexezeder and @DanielaE.
+
+# 7.1.3 - 2020-11-24
+
+-   Fixed handling of buffer boundaries in `format_to_n`
+    (https://github.com/fmtlib/fmt/issues/1996,
+    https://github.com/fmtlib/fmt/issues/2029).
+-   Fixed linkage errors when linking with a shared library
+    (https://github.com/fmtlib/fmt/issues/2011).
+-   Reintroduced ostream support to range formatters
+    (https://github.com/fmtlib/fmt/issues/2014).
+-   Worked around an issue with mixing std versions in gcc
+    (https://github.com/fmtlib/fmt/issues/2017).
+
+# 7.1.2 - 2020-11-04
+
+-   Fixed floating point formatting with large precision
+    (https://github.com/fmtlib/fmt/issues/1976).
+
+# 7.1.1 - 2020-11-01
+
+-   Fixed ABI compatibility with 7.0.x
+    (https://github.com/fmtlib/fmt/issues/1961).
+-   Added the `FMT_ARM_ABI_COMPATIBILITY` macro to work around ABI
+    incompatibility between GCC and Clang on ARM
+    (https://github.com/fmtlib/fmt/issues/1919).
+-   Worked around a SFINAE bug in GCC 8
+    (https://github.com/fmtlib/fmt/issues/1957).
+-   Fixed linkage errors when building with GCC\'s LTO
+    (https://github.com/fmtlib/fmt/issues/1955).
+-   Fixed a compilation error when building without `__builtin_clz` or
+    equivalent (https://github.com/fmtlib/fmt/pull/1968).
+    Thanks @tohammer.
+-   Fixed a sign conversion warning
+    (https://github.com/fmtlib/fmt/pull/1964). Thanks @OptoCloud.
+
+# 7.1.0 - 2020-10-25
+
+-   Switched from
+    [Grisu3](https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf)
+    to [Dragonbox](https://github.com/jk-jeon/dragonbox) for the default
+    floating-point formatting which gives the shortest decimal
+    representation with round-trip guarantee and correct rounding
+    (https://github.com/fmtlib/fmt/pull/1882,
+    https://github.com/fmtlib/fmt/pull/1887,
+    https://github.com/fmtlib/fmt/pull/1894). This makes {fmt}
+    up to 20-30x faster than common implementations of
+    `std::ostringstream` and `sprintf` on
+    [dtoa-benchmark](https://github.com/fmtlib/dtoa-benchmark) and
+    faster than double-conversion and Ryū:
+
+    ![](https://user-images.githubusercontent.com/576385/95684665-11719600-0ba8-11eb-8e5b-972ff4e49428.png)
+
+    It is possible to get even better performance at the cost of larger
+    binary size by compiling with the `FMT_USE_FULL_CACHE_DRAGONBOX`
+    macro set to 1.
+
+    Thanks @jk-jeon.
+
+-   Added an experimental unsynchronized file output API which, together
+    with [format string
+    compilation](https://fmt.dev/latest/api.html#compile-api), can give
+    [5-9 times speed up compared to
+    fprintf](https://www.zverovich.net/2020/08/04/optimal-file-buffer-size.html)
+    on common platforms ([godbolt](https://godbolt.org/z/nsTcG8)):
+
+    ```c++
+    #include <fmt/os.h>
+
+    int main() {
+      auto f = fmt::output_file("guide");
+      f.print("The answer is {}.", 42);
+    }
+    ```
+
+-   Added a formatter for `std::chrono::time_point<system_clock>`
+    (https://github.com/fmtlib/fmt/issues/1819,
+    https://github.com/fmtlib/fmt/pull/1837). For example
+    ([godbolt](https://godbolt.org/z/c4M6fh)):
+
+    ```c++
+    #include <fmt/chrono.h>
+
+    int main() {
+      auto now = std::chrono::system_clock::now();
+      fmt::print("The time is {:%H:%M:%S}.\n", now);
+    }
+    ```
+
+    Thanks @adamburgess.
+
+-   Added support for ranges with non-const `begin`/`end` to `fmt::join`
+    (https://github.com/fmtlib/fmt/issues/1784,
+    https://github.com/fmtlib/fmt/pull/1786). For example
+    ([godbolt](https://godbolt.org/z/jP63Tv)):
+
+    ```c++
+    #include <fmt/ranges.h>
+    #include <range/v3/view/filter.hpp>
+
+    int main() {
+      using std::literals::string_literals::operator""s;
+      auto strs = std::array{"a"s, "bb"s, "ccc"s};
+      auto range = strs | ranges::views::filter(
+        [] (const std::string &x) { return x.size() != 2; }
+      );
+      fmt::print("{}\n", fmt::join(range, ""));
+    }
+    ```
+
+    prints \"accc\".
+
+    Thanks @tonyelewis.
+
+-   Added a `memory_buffer::append` overload that takes a range
+    (https://github.com/fmtlib/fmt/pull/1806). Thanks @BRevzin.
+
+-   Improved handling of single code units in `FMT_COMPILE`. For
+    example:
+
+    ```c++
+    #include <fmt/compile.h>
+
+    char* f(char* buf) {
+      return fmt::format_to(buf, FMT_COMPILE("x{}"), 42);
+    }
+    ```
+
+    compiles to just ([godbolt](https://godbolt.org/z/5vncz3)):
+
+    ```asm
+    _Z1fPc:
+      movb $120, (%rdi)
+      xorl %edx, %edx
+      cmpl $42, _ZN3fmt2v76detail10basic_dataIvE23zero_or_powers_of_10_32E+8(%rip)
+      movl $3, %eax
+      seta %dl
+      subl %edx, %eax
+      movzwl _ZN3fmt2v76detail10basic_dataIvE6digitsE+84(%rip), %edx
+      cltq
+      addq %rdi, %rax
+      movw %dx, -2(%rax)
+      ret
+    ```
+
+    Here a single `mov` instruction writes `'x'` (`$120`) to the output
+    buffer.
+
+-   Added dynamic width support to format string compilation
+    (https://github.com/fmtlib/fmt/issues/1809).
+
+-   Improved error reporting for unformattable types: now you\'ll get
+    the type name directly in the error message instead of the note:
+
+    ```c++
+    #include <fmt/core.h>
+
+    struct how_about_no {};
+
+    int main() {
+      fmt::print("{}", how_about_no());
+    }
+    ```
+
+    Error ([godbolt](https://godbolt.org/z/GoxM4e)):
+
+    `fmt/core.h:1438:3: error: static_assert failed due to requirement 'fmt::v7::formattable<how_about_no>()' "Cannot format an argument. To make type T formattable provide a formatter<T> specialization: https://fmt.dev/latest/api.html#udt" ...`
+
+-   Added the
+    [make_args_checked](https://fmt.dev/7.1.0/api.html#argument-lists)
+    function template that allows you to write formatting functions with
+    compile-time format string checks and avoid binary code bloat
+    ([godbolt](https://godbolt.org/z/PEf9qr)):
+
+    ```c++
+    void vlog(const char* file, int line, fmt::string_view format,
+              fmt::format_args args) {
+      fmt::print("{}: {}: ", file, line);
+      fmt::vprint(format, args);
+    }
+
+    template <typename S, typename... Args>
+    void log(const char* file, int line, const S& format, Args&&... args) {
+      vlog(file, line, format,
+          fmt::make_args_checked<Args...>(format, args...));
+    }
+
+    #define MY_LOG(format, ...) \
+      log(__FILE__, __LINE__, FMT_STRING(format), __VA_ARGS__)
+
+    MY_LOG("invalid squishiness: {}", 42);
+    ```
+
+-   Replaced `snprintf` fallback with a faster internal IEEE 754 `float`
+    and `double` formatter for arbitrary precision. For example
+    ([godbolt](https://godbolt.org/z/dPhWvj)):
+
+    ```c++
+    #include <fmt/core.h>
+
+    int main() {
+      fmt::print("{:.500}\n", 4.9406564584124654E-324);
+    }
+    ```
+
+    prints
+
+    `4.9406564584124654417656879286822137236505980261432476442558568250067550727020875186529983636163599237979656469544571773092665671035593979639877479601078187812630071319031140452784581716784898210368871863605699873072305000638740915356498438731247339727316961514003171538539807412623856559117102665855668676818703956031062493194527159149245532930545654440112748012970999954193198940908041656332452475714786901472678015935523861155013480352649347201937902681071074917033322268447533357208324319360923829e-324`.
+
+-   Made `format_to_n` and `formatted_size` part of the [core
+    API](https://fmt.dev/latest/api.html#core-api)
+    ([godbolt](https://godbolt.org/z/sPjY1K)):
+
+    ```c++
+    #include <fmt/core.h>
+
+    int main() {
+      char buffer[10];
+      auto result = fmt::format_to_n(buffer, sizeof(buffer), "{}", 42);
+    }
+    ```
+
+-   Added `fmt::format_to_n` overload with format string compilation
+    (https://github.com/fmtlib/fmt/issues/1764,
+    https://github.com/fmtlib/fmt/pull/1767,
+    https://github.com/fmtlib/fmt/pull/1869). For example
+    ([godbolt](https://godbolt.org/z/93h86q)):
+
+    ```c++
+    #include <fmt/compile.h>
+
+    int main() {
+      char buffer[8];
+      fmt::format_to_n(buffer, sizeof(buffer), FMT_COMPILE("{}"), 42);
+    }
+    ```
+
+    Thanks @Kurkin and @alexezeder.
+
+-   Added `fmt::format_to` overload that take `text_style`
+    (https://github.com/fmtlib/fmt/issues/1593,
+    https://github.com/fmtlib/fmt/issues/1842,
+    https://github.com/fmtlib/fmt/pull/1843). For example
+    ([godbolt](https://godbolt.org/z/91153r)):
+
+    ```c++
+    #include <fmt/color.h>
+
+    int main() {
+      std::string out;
+      fmt::format_to(std::back_inserter(out),
+                     fmt::emphasis::bold | fg(fmt::color::red),
+                     "The answer is {}.", 42);
+    }
+    ```
+
+    Thanks @Naios.
+
+-   Made the `'#'` specifier emit trailing zeros in addition to the
+    decimal point (https://github.com/fmtlib/fmt/issues/1797).
+    For example ([godbolt](https://godbolt.org/z/bhdcW9)):
+
+    ```c++
+    #include <fmt/core.h>
+
+    int main() {
+      fmt::print("{:#.2g}", 0.5);
+    }
+    ```
+
+    prints `0.50`.
+
+-   Changed the default floating point format to not include `.0` for
+    consistency with `std::format` and `std::to_chars`
+    (https://github.com/fmtlib/fmt/issues/1893,
+    https://github.com/fmtlib/fmt/issues/1943). It is possible
+    to get the decimal point and trailing zero with the `#` specifier.
+
+-   Fixed an issue with floating-point formatting that could result in
+    addition of a non-significant trailing zero in rare cases e.g.
+    `1.00e-34` instead of `1.0e-34`
+    (https://github.com/fmtlib/fmt/issues/1873,
+    https://github.com/fmtlib/fmt/issues/1917).
+
+-   Made `fmt::to_string` fallback on `ostream` insertion operator if
+    the `formatter` specialization is not provided
+    (https://github.com/fmtlib/fmt/issues/1815,
+    https://github.com/fmtlib/fmt/pull/1829). Thanks @alexezeder.
+
+-   Added support for the append mode to the experimental file API and
+    improved `fcntl.h` detection.
+    (https://github.com/fmtlib/fmt/pull/1847,
+    https://github.com/fmtlib/fmt/pull/1848). Thanks @t-wiser.
+
+-   Fixed handling of types that have both an implicit conversion
+    operator and an overloaded `ostream` insertion operator
+    (https://github.com/fmtlib/fmt/issues/1766).
+
+-   Fixed a slicing issue in an internal iterator type
+    (https://github.com/fmtlib/fmt/pull/1822). Thanks @BRevzin.
+
+-   Fixed an issue in locale-specific integer formatting
+    (https://github.com/fmtlib/fmt/issues/1927).
+
+-   Fixed handling of exotic code unit types
+    (https://github.com/fmtlib/fmt/issues/1870,
+    https://github.com/fmtlib/fmt/issues/1932).
+
+-   Improved `FMT_ALWAYS_INLINE`
+    (https://github.com/fmtlib/fmt/pull/1878). Thanks @jk-jeon.
+
+-   Removed dependency on `windows.h`
+    (https://github.com/fmtlib/fmt/pull/1900). Thanks @bernd5.
+
+-   Optimized counting of decimal digits on MSVC
+    (https://github.com/fmtlib/fmt/pull/1890). Thanks @mwinterb.
+
+-   Improved documentation
+    (https://github.com/fmtlib/fmt/issues/1772,
+    https://github.com/fmtlib/fmt/pull/1775,
+    https://github.com/fmtlib/fmt/pull/1792,
+    https://github.com/fmtlib/fmt/pull/1838,
+    https://github.com/fmtlib/fmt/pull/1888,
+    https://github.com/fmtlib/fmt/pull/1918,
+    https://github.com/fmtlib/fmt/pull/1939).
+    Thanks @leolchat, @pepsiman, @Klaim, @ravijanjam, @francesco-st and @udnaan.
+
+-   Added the `FMT_REDUCE_INT_INSTANTIATIONS` CMake option that reduces
+    the binary code size at the cost of some integer formatting
+    performance. This can be useful for extremely memory-constrained
+    embedded systems
+    (https://github.com/fmtlib/fmt/issues/1778,
+    https://github.com/fmtlib/fmt/pull/1781). Thanks @kammce.
+
+-   Added the `FMT_USE_INLINE_NAMESPACES` macro to control usage of
+    inline namespaces
+    (https://github.com/fmtlib/fmt/pull/1945). Thanks @darklukee.
+
+-   Improved build configuration
+    (https://github.com/fmtlib/fmt/pull/1760,
+    https://github.com/fmtlib/fmt/pull/1770,
+    https://github.com/fmtlib/fmt/issues/1779,
+    https://github.com/fmtlib/fmt/pull/1783,
+    https://github.com/fmtlib/fmt/pull/1823).
+    Thanks @dvetutnev, @xvitaly, @tambry, @medithe and @martinwuehrer.
+
+-   Fixed various warnings and compilation issues
+    (https://github.com/fmtlib/fmt/pull/1790,
+    https://github.com/fmtlib/fmt/pull/1802,
+    https://github.com/fmtlib/fmt/pull/1808,
+    https://github.com/fmtlib/fmt/issues/1810,
+    https://github.com/fmtlib/fmt/issues/1811,
+    https://github.com/fmtlib/fmt/pull/1812,
+    https://github.com/fmtlib/fmt/pull/1814,
+    https://github.com/fmtlib/fmt/pull/1816,
+    https://github.com/fmtlib/fmt/pull/1817,
+    https://github.com/fmtlib/fmt/pull/1818,
+    https://github.com/fmtlib/fmt/issues/1825,
+    https://github.com/fmtlib/fmt/pull/1836,
+    https://github.com/fmtlib/fmt/pull/1855,
+    https://github.com/fmtlib/fmt/pull/1856,
+    https://github.com/fmtlib/fmt/pull/1860,
+    https://github.com/fmtlib/fmt/pull/1877,
+    https://github.com/fmtlib/fmt/pull/1879,
+    https://github.com/fmtlib/fmt/pull/1880,
+    https://github.com/fmtlib/fmt/issues/1896,
+    https://github.com/fmtlib/fmt/pull/1897,
+    https://github.com/fmtlib/fmt/pull/1898,
+    https://github.com/fmtlib/fmt/issues/1904,
+    https://github.com/fmtlib/fmt/pull/1908,
+    https://github.com/fmtlib/fmt/issues/1911,
+    https://github.com/fmtlib/fmt/issues/1912,
+    https://github.com/fmtlib/fmt/issues/1928,
+    https://github.com/fmtlib/fmt/pull/1929,
+    https://github.com/fmtlib/fmt/issues/1935,
+    https://github.com/fmtlib/fmt/pull/1937,
+    https://github.com/fmtlib/fmt/pull/1942,
+    https://github.com/fmtlib/fmt/issues/1949).
+    Thanks @TheQwertiest, @medithe, @martinwuehrer, @n16h7hunt3r, @Othereum,
+    @gsjaardema, @AlexanderLanin, @gcerretani, @chronoxor, @noizefloor,
+    @akohlmey, @jk-jeon, @rimathia, @rglarix, @moiwi, @heckad, @MarcDirven.
+    @BartSiwek and @darklukee.
+
+# 7.0.3 - 2020-08-06
+
+-   Worked around broken `numeric_limits` for 128-bit integers
+    (https://github.com/fmtlib/fmt/issues/1787).
+-   Added error reporting on missing named arguments
+    (https://github.com/fmtlib/fmt/issues/1796).
+-   Stopped using 128-bit integers with clang-cl
+    (https://github.com/fmtlib/fmt/pull/1800). Thanks @Kingcom.
+-   Fixed issues in locale-specific integer formatting
+    (https://github.com/fmtlib/fmt/issues/1782,
+    https://github.com/fmtlib/fmt/issues/1801).
+
+# 7.0.2 - 2020-07-29
+
+-   Worked around broken `numeric_limits` for 128-bit integers
+    (https://github.com/fmtlib/fmt/issues/1725).
+-   Fixed compatibility with CMake 3.4
+    (https://github.com/fmtlib/fmt/issues/1779).
+-   Fixed handling of digit separators in locale-specific formatting
+    (https://github.com/fmtlib/fmt/issues/1782).
+
+# 7.0.1 - 2020-07-07
+
+-   Updated the inline version namespace name.
+-   Worked around a gcc bug in mangling of alias templates
+    (https://github.com/fmtlib/fmt/issues/1753).
+-   Fixed a linkage error on Windows
+    (https://github.com/fmtlib/fmt/issues/1757). Thanks @Kurkin.
+-   Fixed minor issues with the documentation.
+
+# 7.0.0 - 2020-07-05
+
+-   Reduced the library size. For example, on macOS a stripped test
+    binary statically linked with {fmt} [shrank from \~368k to less than
+    100k](http://www.zverovich.net/2020/05/21/reducing-library-size.html).
+
+-   Added a simpler and more efficient [format string compilation
+    API](https://fmt.dev/7.0.0/api.html#compile-api):
+
+    ```c++
+    #include <fmt/compile.h>
+
+    // Converts 42 into std::string using the most efficient method and no
+    // runtime format string processing.
+    std::string s = fmt::format(FMT_COMPILE("{}"), 42);
+    ```
+
+    The old `fmt::compile` API is now deprecated.
+
+-   Optimized integer formatting: `format_to` with format string
+    compilation and a stack-allocated buffer is now [faster than
+    to_chars on both libc++ and
+    libstdc++](http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html).
+
+-   Optimized handling of small format strings. For example,
+
+    ```c++
+    fmt::format("Result: {}: ({},{},{},{})", str1, str2, str3, str4, str5)
+    ```
+
+    is now \~40% faster
+    (https://github.com/fmtlib/fmt/issues/1685).
+
+-   Applied extern templates to improve compile times when using the
+    core API and `fmt/format.h`
+    (https://github.com/fmtlib/fmt/issues/1452). For example,
+    on macOS with clang the compile time of a test translation unit
+    dropped from 2.3s to 0.3s with `-O2` and from 0.6s to 0.3s with the
+    default settings (`-O0`).
+
+    Before (`-O2`):
+
+        % time c++ -c test.cc -I include -std=c++17 -O2
+        c++ -c test.cc -I include -std=c++17 -O2  2.22s user 0.08s system 99% cpu 2.311 total
+
+    After (`-O2`):
+
+        % time c++ -c test.cc -I include -std=c++17 -O2
+        c++ -c test.cc -I include -std=c++17 -O2  0.26s user 0.04s system 98% cpu 0.303 total
+
+    Before (default):
+
+        % time c++ -c test.cc -I include -std=c++17
+        c++ -c test.cc -I include -std=c++17  0.53s user 0.06s system 98% cpu 0.601 total
+
+    After (default):
+
+        % time c++ -c test.cc -I include -std=c++17
+        c++ -c test.cc -I include -std=c++17  0.24s user 0.06s system 98% cpu 0.301 total
+
+    It is still recommended to use `fmt/core.h` instead of
+    `fmt/format.h` but the compile time difference is now smaller.
+    Thanks @alex3d for the suggestion.
+
+-   Named arguments are now stored on stack (no dynamic memory
+    allocations) and the compiled code is more compact and efficient.
+    For example
+
+    ```c++
+    #include <fmt/core.h>
+
+    int main() {
+      fmt::print("The answer is {answer}\n", fmt::arg("answer", 42));
+    }
+    ```
+
+    compiles to just ([godbolt](https://godbolt.org/z/NcfEp_))
+
+    ```asm
+    .LC0:
+            .string "answer"
+    .LC1:
+            .string "The answer is {answer}\n"
+    main:
+            sub     rsp, 56
+            mov     edi, OFFSET FLAT:.LC1
+            mov     esi, 23
+            movabs  rdx, 4611686018427387905
+            lea     rax, [rsp+32]
+            lea     rcx, [rsp+16]
+            mov     QWORD PTR [rsp+8], 1
+            mov     QWORD PTR [rsp], rax
+            mov     DWORD PTR [rsp+16], 42
+            mov     QWORD PTR [rsp+32], OFFSET FLAT:.LC0
+            mov     DWORD PTR [rsp+40], 0
+            call    fmt::v6::vprint(fmt::v6::basic_string_view<char>,
+                                    fmt::v6::format_args)
+            xor     eax, eax
+            add     rsp, 56
+            ret
+
+        .L.str.1:
+                .asciz  "answer"
+    ```
+
+-   Implemented compile-time checks for dynamic width and precision
+    (https://github.com/fmtlib/fmt/issues/1614):
+
+    ```c++
+    #include <fmt/format.h>
+
+    int main() {
+      fmt::print(FMT_STRING("{0:{1}}"), 42);
+    }
+    ```
+
+    now gives a compilation error because argument 1 doesn\'t exist:
+
+        In file included from test.cc:1:
+        include/fmt/format.h:2726:27: error: constexpr variable 'invalid_format' must be
+        initialized by a constant expression
+          FMT_CONSTEXPR_DECL bool invalid_format =
+                                  ^
+        ...
+        include/fmt/core.h:569:26: note: in call to
+        '&checker(s, {}).context_->on_error(&"argument not found"[0])'
+            if (id >= num_args_) on_error("argument not found");
+                                ^
+
+-   Added sentinel support to `fmt::join`
+    (https://github.com/fmtlib/fmt/pull/1689)
+
+    ```c++
+    struct zstring_sentinel {};
+    bool operator==(const char* p, zstring_sentinel) { return *p == '\0'; }
+    bool operator!=(const char* p, zstring_sentinel) { return *p != '\0'; }
+
+    struct zstring {
+      const char* p;
+      const char* begin() const { return p; }
+      zstring_sentinel end() const { return {}; }
+    };
+
+    auto s = fmt::format("{}", fmt::join(zstring{"hello"}, "_"));
+    // s == "h_e_l_l_o"
+    ```
+
+    Thanks @BRevzin.
+
+-   Added support for named arguments, `clear` and `reserve` to
+    `dynamic_format_arg_store`
+    (https://github.com/fmtlib/fmt/issues/1655,
+    https://github.com/fmtlib/fmt/pull/1663,
+    https://github.com/fmtlib/fmt/pull/1674,
+    https://github.com/fmtlib/fmt/pull/1677). Thanks @vsolontsov-ll.
+
+-   Added support for the `'c'` format specifier to integral types for
+    compatibility with `std::format`
+    (https://github.com/fmtlib/fmt/issues/1652).
+
+-   Replaced the `'n'` format specifier with `'L'` for compatibility
+    with `std::format`
+    (https://github.com/fmtlib/fmt/issues/1624). The `'n'`
+    specifier can be enabled via the `FMT_DEPRECATED_N_SPECIFIER` macro.
+
+-   The `'='` format specifier is now disabled by default for
+    compatibility with `std::format`. It can be enabled via the
+    `FMT_DEPRECATED_NUMERIC_ALIGN` macro.
+
+-   Removed the following deprecated APIs:
+
+    -   `FMT_STRING_ALIAS` and `fmt` macros - replaced by `FMT_STRING`
+    -   `fmt::basic_string_view::char_type` - replaced by
+        `fmt::basic_string_view::value_type`
+    -   `convert_to_int`
+    -   `format_arg_store::types`
+    -   `*parse_context` - replaced by `*format_parse_context`
+    -   `FMT_DEPRECATED_INCLUDE_OS`
+    -   `FMT_DEPRECATED_PERCENT` - incompatible with `std::format`
+    -   `*writer` - replaced by compiled format API
+
+-   Renamed the `internal` namespace to `detail`
+    (https://github.com/fmtlib/fmt/issues/1538). The former is
+    still provided as an alias if the `FMT_USE_INTERNAL` macro is
+    defined.
+
+-   Improved compatibility between `fmt::printf` with the standard specs
+    (https://github.com/fmtlib/fmt/issues/1595,
+    https://github.com/fmtlib/fmt/pull/1682,
+    https://github.com/fmtlib/fmt/pull/1683,
+    https://github.com/fmtlib/fmt/pull/1687,
+    https://github.com/fmtlib/fmt/pull/1699). Thanks @rimathia.
+
+-   Fixed handling of `operator<<` overloads that use `copyfmt`
+    (https://github.com/fmtlib/fmt/issues/1666).
+
+-   Added the `FMT_OS` CMake option to control inclusion of OS-specific
+    APIs in the fmt target. This can be useful for embedded platforms
+    (https://github.com/fmtlib/fmt/issues/1654,
+    https://github.com/fmtlib/fmt/pull/1656). Thanks @kwesolowski.
+
+-   Replaced `FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION` with the
+    `FMT_FUZZ` macro to prevent interfering with fuzzing of projects
+    using {fmt} (https://github.com/fmtlib/fmt/pull/1650).
+    Thanks @asraa.
+
+-   Fixed compatibility with emscripten
+    (https://github.com/fmtlib/fmt/issues/1636,
+    https://github.com/fmtlib/fmt/pull/1637). Thanks @ArthurSonzogni.
+
+-   Improved documentation
+    (https://github.com/fmtlib/fmt/issues/704,
+    https://github.com/fmtlib/fmt/pull/1643,
+    https://github.com/fmtlib/fmt/pull/1660,
+    https://github.com/fmtlib/fmt/pull/1681,
+    https://github.com/fmtlib/fmt/pull/1691,
+    https://github.com/fmtlib/fmt/pull/1706,
+    https://github.com/fmtlib/fmt/pull/1714,
+    https://github.com/fmtlib/fmt/pull/1721,
+    https://github.com/fmtlib/fmt/pull/1739,
+    https://github.com/fmtlib/fmt/pull/1740,
+    https://github.com/fmtlib/fmt/pull/1741,
+    https://github.com/fmtlib/fmt/pull/1751).
+    Thanks @senior7515, @lsr0, @puetzk, @fpelliccioni, Alexey Kuzmenko, @jelly,
+    @claremacrae, @jiapengwen, @gsjaardema and @alexey-milovidov.
+
+-   Implemented various build configuration fixes and improvements
+    (https://github.com/fmtlib/fmt/pull/1603,
+    https://github.com/fmtlib/fmt/pull/1657,
+    https://github.com/fmtlib/fmt/pull/1702,
+    https://github.com/fmtlib/fmt/pull/1728).
+    Thanks @scramsby, @jtojnar, @orivej and @flagarde.
+
+-   Fixed various warnings and compilation issues
+    (https://github.com/fmtlib/fmt/pull/1616,
+    https://github.com/fmtlib/fmt/issues/1620,
+    https://github.com/fmtlib/fmt/issues/1622,
+    https://github.com/fmtlib/fmt/issues/1625,
+    https://github.com/fmtlib/fmt/pull/1627,
+    https://github.com/fmtlib/fmt/issues/1628,
+    https://github.com/fmtlib/fmt/pull/1629,
+    https://github.com/fmtlib/fmt/issues/1631,
+    https://github.com/fmtlib/fmt/pull/1633,
+    https://github.com/fmtlib/fmt/pull/1649,
+    https://github.com/fmtlib/fmt/issues/1658,
+    https://github.com/fmtlib/fmt/pull/1661,
+    https://github.com/fmtlib/fmt/pull/1667,
+    https://github.com/fmtlib/fmt/issues/1668,
+    https://github.com/fmtlib/fmt/pull/1669,
+    https://github.com/fmtlib/fmt/issues/1692,
+    https://github.com/fmtlib/fmt/pull/1696,
+    https://github.com/fmtlib/fmt/pull/1697,
+    https://github.com/fmtlib/fmt/issues/1707,
+    https://github.com/fmtlib/fmt/pull/1712,
+    https://github.com/fmtlib/fmt/pull/1716,
+    https://github.com/fmtlib/fmt/pull/1722,
+    https://github.com/fmtlib/fmt/issues/1724,
+    https://github.com/fmtlib/fmt/pull/1729,
+    https://github.com/fmtlib/fmt/pull/1738,
+    https://github.com/fmtlib/fmt/issues/1742,
+    https://github.com/fmtlib/fmt/issues/1743,
+    https://github.com/fmtlib/fmt/pull/1744,
+    https://github.com/fmtlib/fmt/issues/1747,
+    https://github.com/fmtlib/fmt/pull/1750).
+    Thanks @gsjaardema, @gabime, @johnor, @Kurkin, @invexed, @peterbell10,
+    @daixtrose, @petrutlucian94, @Neargye, @ambitslix, @gabime, @erthink,
+    @tohammer and @0x8000-0000.
+
+# 6.2.1 - 2020-05-09
+
+-   Fixed ostream support in `sprintf`
+    (https://github.com/fmtlib/fmt/issues/1631).
+-   Fixed type detection when using implicit conversion to `string_view`
+    and ostream `operator<<` inconsistently
+    (https://github.com/fmtlib/fmt/issues/1662).
+
+# 6.2.0 - 2020-04-05
+
+-   Improved error reporting when trying to format an object of a
+    non-formattable type:
+
+    ```c++
+    fmt::format("{}", S());
+    ```
+
+    now gives:
+
+        include/fmt/core.h:1015:5: error: static_assert failed due to requirement
+        'formattable' "Cannot format argument. To make type T formattable provide a
+        formatter<T> specialization:
+        https://fmt.dev/latest/api.html#formatting-user-defined-types"
+            static_assert(
+            ^
+        ...
+        note: in instantiation of function template specialization
+        'fmt::v6::format<char [3], S, char>' requested here
+          fmt::format("{}", S());
+               ^
+
+    if `S` is not formattable.
+
+-   Reduced the library size by \~10%.
+
+-   Always print decimal point if `#` is specified
+    (https://github.com/fmtlib/fmt/issues/1476,
+    https://github.com/fmtlib/fmt/issues/1498):
+
+    ```c++
+    fmt::print("{:#.0f}", 42.0);
+    ```
+
+    now prints `42.`
+
+-   Implemented the `'L'` specifier for locale-specific numeric
+    formatting to improve compatibility with `std::format`. The `'n'`
+    specifier is now deprecated and will be removed in the next major
+    release.
+
+-   Moved OS-specific APIs such as `windows_error` from `fmt/format.h`
+    to `fmt/os.h`. You can define `FMT_DEPRECATED_INCLUDE_OS` to
+    automatically include `fmt/os.h` from `fmt/format.h` for
+    compatibility but this will be disabled in the next major release.
+
+-   Added precision overflow detection in floating-point formatting.
+
+-   Implemented detection of invalid use of `fmt::arg`.
+
+-   Used `type_identity` to block unnecessary template argument
+    deduction. Thanks Tim Song.
+
+-   Improved UTF-8 handling
+    (https://github.com/fmtlib/fmt/issues/1109):
+
+    ```c++
+    fmt::print("┌{0:─^{2}}┐\n"
+               "│{1: ^{2}}│\n"
+               "└{0:─^{2}}┘\n", "", "Привет, мир!", 20);
+    ```
+
+    now prints:
+
+        ┌────────────────────┐
+        │    Привет, мир!    │
+        └────────────────────┘
+
+    on systems that support Unicode.
+
+-   Added experimental dynamic argument storage
+    (https://github.com/fmtlib/fmt/issues/1170,
+    https://github.com/fmtlib/fmt/pull/1584):
+
+    ```c++
+    fmt::dynamic_format_arg_store<fmt::format_context> store;
+    store.push_back("answer");
+    store.push_back(42);
+    fmt::vprint("The {} is {}.\n", store);
+    ```
+
+    prints:
+
+        The answer is 42.
+
+    Thanks @vsolontsov-ll.
+
+-   Made `fmt::join` accept `initializer_list`
+    (https://github.com/fmtlib/fmt/pull/1591). Thanks @Rapotkinnik.
+
+-   Fixed handling of empty tuples
+    (https://github.com/fmtlib/fmt/issues/1588).
+
+-   Fixed handling of output iterators in `format_to_n`
+    (https://github.com/fmtlib/fmt/issues/1506).
+
+-   Fixed formatting of `std::chrono::duration` types to wide output
+    (https://github.com/fmtlib/fmt/pull/1533). Thanks @zeffy.
+
+-   Added const `begin` and `end` overload to buffers
+    (https://github.com/fmtlib/fmt/pull/1553). Thanks @dominicpoeschko.
+
+-   Added the ability to disable floating-point formatting via
+    `FMT_USE_FLOAT`, `FMT_USE_DOUBLE` and `FMT_USE_LONG_DOUBLE` macros
+    for extremely memory-constrained embedded system
+    (https://github.com/fmtlib/fmt/pull/1590). Thanks @albaguirre.
+
+-   Made `FMT_STRING` work with `constexpr` `string_view`
+    (https://github.com/fmtlib/fmt/pull/1589). Thanks @scramsby.
+
+-   Implemented a minor optimization in the format string parser
+    (https://github.com/fmtlib/fmt/pull/1560). Thanks @IkarusDeveloper.
+
+-   Improved attribute detection
+    (https://github.com/fmtlib/fmt/pull/1469,
+    https://github.com/fmtlib/fmt/pull/1475,
+    https://github.com/fmtlib/fmt/pull/1576).
+    Thanks @federico-busato, @chronoxor and @refnum.
+
+-   Improved documentation
+    (https://github.com/fmtlib/fmt/pull/1481,
+    https://github.com/fmtlib/fmt/pull/1523).
+    Thanks @JackBoosY and @imba-tjd.
+
+-   Fixed symbol visibility on Linux when compiling with
+    `-fvisibility=hidden`
+    (https://github.com/fmtlib/fmt/pull/1535). Thanks @milianw.
+
+-   Implemented various build configuration fixes and improvements
+    (https://github.com/fmtlib/fmt/issues/1264,
+    https://github.com/fmtlib/fmt/issues/1460,
+    https://github.com/fmtlib/fmt/pull/1534,
+    https://github.com/fmtlib/fmt/issues/1536,
+    https://github.com/fmtlib/fmt/issues/1545,
+    https://github.com/fmtlib/fmt/pull/1546,
+    https://github.com/fmtlib/fmt/issues/1566,
+    https://github.com/fmtlib/fmt/pull/1582,
+    https://github.com/fmtlib/fmt/issues/1597,
+    https://github.com/fmtlib/fmt/pull/1598).
+    Thanks @ambitslix, @jwillikers and @stac47.
+
+-   Fixed various warnings and compilation issues
+    (https://github.com/fmtlib/fmt/pull/1433,
+    https://github.com/fmtlib/fmt/issues/1461,
+    https://github.com/fmtlib/fmt/pull/1470,
+    https://github.com/fmtlib/fmt/pull/1480,
+    https://github.com/fmtlib/fmt/pull/1485,
+    https://github.com/fmtlib/fmt/pull/1492,
+    https://github.com/fmtlib/fmt/issues/1493,
+    https://github.com/fmtlib/fmt/issues/1504,
+    https://github.com/fmtlib/fmt/pull/1505,
+    https://github.com/fmtlib/fmt/pull/1512,
+    https://github.com/fmtlib/fmt/issues/1515,
+    https://github.com/fmtlib/fmt/pull/1516,
+    https://github.com/fmtlib/fmt/pull/1518,
+    https://github.com/fmtlib/fmt/pull/1519,
+    https://github.com/fmtlib/fmt/pull/1520,
+    https://github.com/fmtlib/fmt/pull/1521,
+    https://github.com/fmtlib/fmt/pull/1522,
+    https://github.com/fmtlib/fmt/issues/1524,
+    https://github.com/fmtlib/fmt/pull/1530,
+    https://github.com/fmtlib/fmt/issues/1531,
+    https://github.com/fmtlib/fmt/pull/1532,
+    https://github.com/fmtlib/fmt/issues/1539,
+    https://github.com/fmtlib/fmt/issues/1547,
+    https://github.com/fmtlib/fmt/issues/1548,
+    https://github.com/fmtlib/fmt/pull/1554,
+    https://github.com/fmtlib/fmt/issues/1567,
+    https://github.com/fmtlib/fmt/pull/1568,
+    https://github.com/fmtlib/fmt/pull/1569,
+    https://github.com/fmtlib/fmt/pull/1571,
+    https://github.com/fmtlib/fmt/pull/1573,
+    https://github.com/fmtlib/fmt/pull/1575,
+    https://github.com/fmtlib/fmt/pull/1581,
+    https://github.com/fmtlib/fmt/issues/1583,
+    https://github.com/fmtlib/fmt/issues/1586,
+    https://github.com/fmtlib/fmt/issues/1587,
+    https://github.com/fmtlib/fmt/issues/1594,
+    https://github.com/fmtlib/fmt/pull/1596,
+    https://github.com/fmtlib/fmt/issues/1604,
+    https://github.com/fmtlib/fmt/pull/1606,
+    https://github.com/fmtlib/fmt/issues/1607,
+    https://github.com/fmtlib/fmt/issues/1609).
+    Thanks @marti4d, @iPherian, @parkertomatoes, @gsjaardema, @chronoxor,
+    @DanielaE, @torsten48, @tohammer, @lefticus, @ryusakki, @adnsv, @fghzxm,
+    @refnum, @pramodk, @Spirrwell and @scramsby.
+
+# 6.1.2 - 2019-12-11
+
+-   Fixed ABI compatibility with `libfmt.so.6.0.0`
+    (https://github.com/fmtlib/fmt/issues/1471).
+-   Fixed handling types convertible to `std::string_view`
+    (https://github.com/fmtlib/fmt/pull/1451). Thanks @denizevrenci.
+-   Made CUDA test an opt-in enabled via the `FMT_CUDA_TEST` CMake
+    option.
+-   Fixed sign conversion warnings
+    (https://github.com/fmtlib/fmt/pull/1440). Thanks @0x8000-0000.
+
+# 6.1.1 - 2019-12-04
+
+-   Fixed shared library build on Windows
+    (https://github.com/fmtlib/fmt/pull/1443,
+    https://github.com/fmtlib/fmt/issues/1445,
+    https://github.com/fmtlib/fmt/pull/1446,
+    https://github.com/fmtlib/fmt/issues/1450).
+    Thanks @egorpugin and @bbolli.
+-   Added a missing decimal point in exponent notation with trailing
+    zeros.
+-   Removed deprecated `format_arg_store::TYPES`.
+
+# 6.1.0 - 2019-12-01
+
+-   {fmt} now formats IEEE 754 `float` and `double` using the shortest
+    decimal representation with correct rounding by default:
+
+    ```c++
+    #include <cmath>
+    #include <fmt/core.h>
+
+    int main() {
+      fmt::print("{}", M_PI);
+    }
+    ```
+
+    prints `3.141592653589793`.
+
+-   Made the fast binary to decimal floating-point formatter the
+    default, simplified it and improved performance. {fmt} is now 15
+    times faster than libc++\'s `std::ostringstream`, 11 times faster
+    than `printf` and 10% faster than double-conversion on
+    [dtoa-benchmark](https://github.com/fmtlib/dtoa-benchmark):
+
+    | Function      | Time (ns) | Speedup |
+    | ------------- | --------: | ------: |
+    | ostringstream | 1,346.30  | 1.00x   |
+    | ostrstream    | 1,195.74  | 1.13x   |
+    | sprintf       | 995.08    | 1.35x   |
+    | doubleconv    | 99.10     | 13.59x  |
+    | fmt           | 88.34     | 15.24x  |
+
+    ![](https://user-images.githubusercontent.com/576385/69767160-cdaca400-112f-11ea-9fc5-347c9f83caad.png)
+
+-   {fmt} no longer converts `float` arguments to `double`. In
+    particular this improves the default (shortest) representation of
+    floats and makes `fmt::format` consistent with `std::format` specs
+    (https://github.com/fmtlib/fmt/issues/1336,
+    https://github.com/fmtlib/fmt/issues/1353,
+    https://github.com/fmtlib/fmt/pull/1360,
+    https://github.com/fmtlib/fmt/pull/1361):
+
+    ```c++
+    fmt::print("{}", 0.1f);
+    ```
+
+    prints `0.1` instead of `0.10000000149011612`.
+
+    Thanks @orivej.
+
+-   Made floating-point formatting output consistent with
+    `printf`/iostreams
+    (https://github.com/fmtlib/fmt/issues/1376,
+    https://github.com/fmtlib/fmt/issues/1417).
+
+-   Added support for 128-bit integers
+    (https://github.com/fmtlib/fmt/pull/1287):
+
+    ```c++
+    fmt::print("{}", std::numeric_limits<__int128_t>::max());
+    ```
+
+    prints `170141183460469231731687303715884105727`.
+
+    Thanks @denizevrenci.
+
+-   The overload of `print` that takes `text_style` is now atomic, i.e.
+    the output from different threads doesn\'t interleave
+    (https://github.com/fmtlib/fmt/pull/1351). Thanks @tankiJong.
+
+-   Made compile time in the header-only mode \~20% faster by reducing
+    the number of template instantiations. `wchar_t` overload of
+    `vprint` was moved from `fmt/core.h` to `fmt/format.h`.
+
+-   Added an overload of `fmt::join` that works with tuples
+    (https://github.com/fmtlib/fmt/issues/1322,
+    https://github.com/fmtlib/fmt/pull/1330):
+
+    ```c++
+    #include <tuple>
+    #include <fmt/ranges.h>
+
+    int main() {
+      std::tuple<char, int, float> t{'a', 1, 2.0f};
+      fmt::print("{}", t);
+    }
+    ```
+
+    prints `('a', 1, 2.0)`.
+
+    Thanks @jeremyong.
+
+-   Changed formatting of octal zero with prefix from \"00\" to \"0\":
+
+    ```c++
+    fmt::print("{:#o}", 0);
+    ```
+
+    prints `0`.
+
+-   The locale is now passed to ostream insertion (`<<`) operators
+    (https://github.com/fmtlib/fmt/pull/1406):
+
+    ```c++
+    #include <fmt/locale.h>
+    #include <fmt/ostream.h>
+
+    struct S {
+      double value;
+    };
+
+    std::ostream& operator<<(std::ostream& os, S s) {
+      return os << s.value;
+    }
+
+    int main() {
+      auto s = fmt::format(std::locale("fr_FR.UTF-8"), "{}", S{0.42});
+      // s == "0,42"
+    }
+    ```
+
+    Thanks @dlaugt.
+
+-   Locale-specific number formatting now uses grouping
+    (https://github.com/fmtlib/fmt/issues/1393,
+    https://github.com/fmtlib/fmt/pull/1394). Thanks @skrdaniel.
+
+-   Fixed handling of types with deleted implicit rvalue conversion to
+    `const char**` (https://github.com/fmtlib/fmt/issues/1421):
+
+    ```c++
+    struct mystring {
+      operator const char*() const&;
+      operator const char*() &;
+      operator const char*() const&& = delete;
+      operator const char*() && = delete;
+    };
+    mystring str;
+    fmt::print("{}", str); // now compiles
+    ```
+
+-   Enums are now mapped to correct underlying types instead of `int`
+    (https://github.com/fmtlib/fmt/pull/1286). Thanks @agmt.
+
+-   Enum classes are no longer implicitly converted to `int`
+    (https://github.com/fmtlib/fmt/issues/1424).
+
+-   Added `basic_format_parse_context` for consistency with C++20
+    `std::format` and deprecated `basic_parse_context`.
+
+-   Fixed handling of UTF-8 in precision
+    (https://github.com/fmtlib/fmt/issues/1389,
+    https://github.com/fmtlib/fmt/pull/1390). Thanks @tajtiattila.
+
+-   {fmt} can now be installed on Linux, macOS and Windows with
+    [Conda](https://docs.conda.io/en/latest/) using its
+    [conda-forge](https://conda-forge.org)
+    [package](https://github.com/conda-forge/fmt-feedstock)
+    (https://github.com/fmtlib/fmt/pull/1410):
+
+        conda install -c conda-forge fmt
+
+    Thanks @tdegeus.
+
+-   Added a CUDA test (https://github.com/fmtlib/fmt/pull/1285,
+    https://github.com/fmtlib/fmt/pull/1317).
+    Thanks @luncliff and @risa2000.
+
+-   Improved documentation
+    (https://github.com/fmtlib/fmt/pull/1276,
+    https://github.com/fmtlib/fmt/issues/1291,
+    https://github.com/fmtlib/fmt/issues/1296,
+    https://github.com/fmtlib/fmt/pull/1315,
+    https://github.com/fmtlib/fmt/pull/1332,
+    https://github.com/fmtlib/fmt/pull/1337,
+    https://github.com/fmtlib/fmt/issues/1395
+    https://github.com/fmtlib/fmt/pull/1418).
+    Thanks @waywardmonkeys, @pauldreik and @jackoalan.
+
+-   Various code improvements
+    (https://github.com/fmtlib/fmt/pull/1358,
+    https://github.com/fmtlib/fmt/pull/1407).
+    Thanks @orivej and @dpacbach.
+
+-   Fixed compile-time format string checks for user-defined types
+    (https://github.com/fmtlib/fmt/issues/1292).
+
+-   Worked around a false positive in `unsigned-integer-overflow` sanitizer
+    (https://github.com/fmtlib/fmt/issues/1377).
+
+-   Fixed various warnings and compilation issues
+    (https://github.com/fmtlib/fmt/issues/1273,
+    https://github.com/fmtlib/fmt/pull/1278,
+    https://github.com/fmtlib/fmt/pull/1280,
+    https://github.com/fmtlib/fmt/issues/1281,
+    https://github.com/fmtlib/fmt/issues/1288,
+    https://github.com/fmtlib/fmt/pull/1290,
+    https://github.com/fmtlib/fmt/pull/1301,
+    https://github.com/fmtlib/fmt/issues/1305,
+    https://github.com/fmtlib/fmt/issues/1306,
+    https://github.com/fmtlib/fmt/issues/1309,
+    https://github.com/fmtlib/fmt/pull/1312,
+    https://github.com/fmtlib/fmt/issues/1313,
+    https://github.com/fmtlib/fmt/issues/1316,
+    https://github.com/fmtlib/fmt/issues/1319,
+    https://github.com/fmtlib/fmt/pull/1320,
+    https://github.com/fmtlib/fmt/pull/1326,
+    https://github.com/fmtlib/fmt/pull/1328,
+    https://github.com/fmtlib/fmt/issues/1344,
+    https://github.com/fmtlib/fmt/pull/1345,
+    https://github.com/fmtlib/fmt/pull/1347,
+    https://github.com/fmtlib/fmt/pull/1349,
+    https://github.com/fmtlib/fmt/issues/1354,
+    https://github.com/fmtlib/fmt/issues/1362,
+    https://github.com/fmtlib/fmt/issues/1366,
+    https://github.com/fmtlib/fmt/pull/1364,
+    https://github.com/fmtlib/fmt/pull/1370,
+    https://github.com/fmtlib/fmt/pull/1371,
+    https://github.com/fmtlib/fmt/issues/1385,
+    https://github.com/fmtlib/fmt/issues/1388,
+    https://github.com/fmtlib/fmt/pull/1397,
+    https://github.com/fmtlib/fmt/pull/1414,
+    https://github.com/fmtlib/fmt/pull/1416,
+    https://github.com/fmtlib/fmt/issues/1422
+    https://github.com/fmtlib/fmt/pull/1427,
+    https://github.com/fmtlib/fmt/issues/1431,
+    https://github.com/fmtlib/fmt/pull/1433).
+    Thanks @hhb, @gsjaardema, @gabime, @neheb, @vedranmiletic, @dkavolis,
+    @mwinterb, @orivej, @denizevrenci, @leonklingele, @chronoxor, @kent-tri,
+    @0x8000-0000 and @marti4d.
+
+# 6.0.0 - 2019-08-26
+
+-   Switched to the [MIT license](
+    https://github.com/fmtlib/fmt/blob/5a4b24613ba16cc689977c3b5bd8274a3ba1dd1f/LICENSE.rst)
+    with an optional exception that allows distributing binary code
+    without attribution.
+
+-   Floating-point formatting is now locale-independent by default:
+
+    ```c++
+    #include <locale>
+    #include <fmt/core.h>
+
+    int main() {
+      std::locale::global(std::locale("ru_RU.UTF-8"));
+      fmt::print("value = {}", 4.2);
+    }
+    ```
+
+    prints \"value = 4.2\" regardless of the locale.
+
+    For locale-specific formatting use the `n` specifier:
+
+    ```c++
+    std::locale::global(std::locale("ru_RU.UTF-8"));
+    fmt::print("value = {:n}", 4.2);
+    ```
+
+    prints \"value = 4,2\".
+
+-   Added an experimental Grisu floating-point formatting algorithm
+    implementation (disabled by default). To enable it compile with the
+    `FMT_USE_GRISU` macro defined to 1:
+
+    ```c++
+    #define FMT_USE_GRISU 1
+    #include <fmt/format.h>
+
+    auto s = fmt::format("{}", 4.2); // formats 4.2 using Grisu
+    ```
+
+    With Grisu enabled, {fmt} is 13x faster than `std::ostringstream`
+    (libc++) and 10x faster than `sprintf` on
+    [dtoa-benchmark](https://github.com/fmtlib/dtoa-benchmark) ([full
+    results](https://fmt.dev/unknown_mac64_clang10.0.html)):
+
+    ![](https://user-images.githubusercontent.com/576385/54883977-9fe8c000-4e28-11e9-8bde-272d122e7c52.jpg)
+
+-   Separated formatting and parsing contexts for consistency with
+    [C++20 std::format](http://eel.is/c++draft/format), removing the
+    undocumented `basic_format_context::parse_context()` function.
+
+-   Added [oss-fuzz](https://github.com/google/oss-fuzz) support
+    (https://github.com/fmtlib/fmt/pull/1199). Thanks @pauldreik.
+
+-   `formatter` specializations now always take precedence over
+    `operator<<` (https://github.com/fmtlib/fmt/issues/952):
+
+    ```c++
+    #include <iostream>
+    #include <fmt/ostream.h>
+
+    struct S {};
+
+    std::ostream& operator<<(std::ostream& os, S) {
+      return os << 1;
+    }
+
+    template <>
+    struct fmt::formatter<S> : fmt::formatter<int> {
+      auto format(S, format_context& ctx) {
+        return formatter<int>::format(2, ctx);
+      }
+    };
+
+    int main() {
+      std::cout << S() << "\n"; // prints 1 using operator<<
+      fmt::print("{}\n", S());  // prints 2 using formatter
+    }
+    ```
+
+-   Introduced the experimental `fmt::compile` function that does format
+    string compilation
+    (https://github.com/fmtlib/fmt/issues/618,
+    https://github.com/fmtlib/fmt/issues/1169,
+    https://github.com/fmtlib/fmt/pull/1171):
+
+    ```c++
+    #include <fmt/compile.h>
+
+    auto f = fmt::compile<int>("{}");
+    std::string s = fmt::format(f, 42); // can be called multiple times to
+                                        // format different values
+    // s == "42"
+    ```
+
+    It moves the cost of parsing a format string outside of the format
+    function which can be beneficial when identically formatting many
+    objects of the same types. Thanks @stryku.
+
+-   Added experimental `%` format specifier that formats floating-point
+    values as percentages
+    (https://github.com/fmtlib/fmt/pull/1060,
+    https://github.com/fmtlib/fmt/pull/1069,
+    https://github.com/fmtlib/fmt/pull/1071):
+
+    ```c++
+    auto s = fmt::format("{:.1%}", 0.42); // s == "42.0%"
+    ```
+
+    Thanks @gawain-bolton.
+
+-   Implemented precision for floating-point durations
+    (https://github.com/fmtlib/fmt/issues/1004,
+    https://github.com/fmtlib/fmt/pull/1012):
+
+    ```c++
+    auto s = fmt::format("{:.1}", std::chrono::duration<double>(1.234));
+    // s == 1.2s
+    ```
+
+    Thanks @DanielaE.
+
+-   Implemented `chrono` format specifiers `%Q` and `%q` that give the
+    value and the unit respectively
+    (https://github.com/fmtlib/fmt/pull/1019):
+
+    ```c++
+    auto value = fmt::format("{:%Q}", 42s); // value == "42"
+    auto unit  = fmt::format("{:%q}", 42s); // unit == "s"
+    ```
+
+    Thanks @DanielaE.
+
+-   Fixed handling of dynamic width in chrono formatter:
+
+    ```c++
+    auto s = fmt::format("{0:{1}%H:%M:%S}", std::chrono::seconds(12345), 12);
+    //                        ^ width argument index                     ^ width
+    // s == "03:25:45    "
+    ```
+
+    Thanks Howard Hinnant.
+
+-   Removed deprecated `fmt/time.h`. Use `fmt/chrono.h` instead.
+
+-   Added `fmt::format` and `fmt::vformat` overloads that take
+    `text_style` (https://github.com/fmtlib/fmt/issues/993,
+    https://github.com/fmtlib/fmt/pull/994):
+
+    ```c++
+    #include <fmt/color.h>
+
+    std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
+                                      "The answer is {}.", 42);
+    ```
+
+    Thanks @Naios.
+
+-   Removed the deprecated color API (`print_colored`). Use the new API,
+    namely `print` overloads that take `text_style` instead.
+
+-   Made `std::unique_ptr` and `std::shared_ptr` formattable as pointers
+    via `fmt::ptr` (https://github.com/fmtlib/fmt/pull/1121):
+
+    ```c++
+    std::unique_ptr<int> p = ...;
+    fmt::print("{}", fmt::ptr(p)); // prints p as a pointer
+    ```
+
+    Thanks @sighingnow.
+
+-   Made `print` and `vprint` report I/O errors
+    (https://github.com/fmtlib/fmt/issues/1098,
+    https://github.com/fmtlib/fmt/pull/1099). Thanks @BillyDonahue.
+
+-   Marked deprecated APIs with the `[[deprecated]]` attribute and
+    removed internal uses of deprecated APIs
+    (https://github.com/fmtlib/fmt/pull/1022). Thanks @eliaskosunen.
+
+-   Modernized the codebase using more C++11 features and removing
+    workarounds. Most importantly, `buffer_context` is now an alias
+    template, so use `buffer_context<T>` instead of
+    `buffer_context<T>::type`. These features require GCC 4.8 or later.
+
+-   `formatter` specializations now always take precedence over implicit
+    conversions to `int` and the undocumented `convert_to_int` trait is
+    now deprecated.
+
+-   Moved the undocumented `basic_writer`, `writer`, and `wwriter` types
+    to the `internal` namespace.
+
+-   Removed deprecated `basic_format_context::begin()`. Use `out()`
+    instead.
+
+-   Disallowed passing the result of `join` as an lvalue to prevent
+    misuse.
+
+-   Refactored the undocumented structs that represent parsed format
+    specifiers to simplify the API and allow multibyte fill.
+
+-   Moved SFINAE to template parameters to reduce symbol sizes.
+
+-   Switched to `fputws` for writing wide strings so that it\'s no
+    longer required to call `_setmode` on Windows
+    (https://github.com/fmtlib/fmt/issues/1229,
+    https://github.com/fmtlib/fmt/pull/1243). Thanks @jackoalan.
+
+-   Improved literal-based API
+    (https://github.com/fmtlib/fmt/pull/1254). Thanks @sylveon.
+
+-   Added support for exotic platforms without `uintptr_t` such as IBM i
+    (AS/400) which has 128-bit pointers and only 64-bit integers
+    (https://github.com/fmtlib/fmt/issues/1059).
+
+-   Added [Sublime Text syntax highlighting config](
+    https://github.com/fmtlib/fmt/blob/master/support/C%2B%2B.sublime-syntax)
+    (https://github.com/fmtlib/fmt/issues/1037). Thanks @Kronuz.
+
+-   Added the `FMT_ENFORCE_COMPILE_STRING` macro to enforce the use of
+    compile-time format strings
+    (https://github.com/fmtlib/fmt/pull/1231). Thanks @jackoalan.
+
+-   Stopped setting `CMAKE_BUILD_TYPE` if {fmt} is a subproject
+    (https://github.com/fmtlib/fmt/issues/1081).
+
+-   Various build improvements
+    (https://github.com/fmtlib/fmt/pull/1039,
+    https://github.com/fmtlib/fmt/pull/1078,
+    https://github.com/fmtlib/fmt/pull/1091,
+    https://github.com/fmtlib/fmt/pull/1103,
+    https://github.com/fmtlib/fmt/pull/1177).
+    Thanks @luncliff, @jasonszang, @olafhering, @Lecetem and @pauldreik.
+
+-   Improved documentation
+    (https://github.com/fmtlib/fmt/issues/1049,
+    https://github.com/fmtlib/fmt/pull/1051,
+    https://github.com/fmtlib/fmt/pull/1083,
+    https://github.com/fmtlib/fmt/pull/1113,
+    https://github.com/fmtlib/fmt/pull/1114,
+    https://github.com/fmtlib/fmt/issues/1146,
+    https://github.com/fmtlib/fmt/issues/1180,
+    https://github.com/fmtlib/fmt/pull/1250,
+    https://github.com/fmtlib/fmt/pull/1252,
+    https://github.com/fmtlib/fmt/pull/1265).
+    Thanks @mikelui, @foonathan, @BillyDonahue, @jwakely, @kaisbe and
+    @sdebionne.
+
+-   Fixed ambiguous formatter specialization in `fmt/ranges.h`
+    (https://github.com/fmtlib/fmt/issues/1123).
+
+-   Fixed formatting of a non-empty `std::filesystem::path` which is an
+    infinitely deep range of its components
+    (https://github.com/fmtlib/fmt/issues/1268).
+
+-   Fixed handling of general output iterators when formatting
+    characters (https://github.com/fmtlib/fmt/issues/1056,
+    https://github.com/fmtlib/fmt/pull/1058). Thanks @abolz.
+
+-   Fixed handling of output iterators in `formatter` specialization for
+    ranges (https://github.com/fmtlib/fmt/issues/1064).
+
+-   Fixed handling of exotic character types
+    (https://github.com/fmtlib/fmt/issues/1188).
+
+-   Made chrono formatting work with exceptions disabled
+    (https://github.com/fmtlib/fmt/issues/1062).
+
+-   Fixed DLL visibility issues
+    (https://github.com/fmtlib/fmt/pull/1134,
+    https://github.com/fmtlib/fmt/pull/1147). Thanks @denchat.
+
+-   Disabled the use of UDL template extension on GCC 9
+    (https://github.com/fmtlib/fmt/issues/1148).
+
+-   Removed misplaced `format` compile-time checks from `printf`
+    (https://github.com/fmtlib/fmt/issues/1173).
+
+-   Fixed issues in the experimental floating-point formatter
+    (https://github.com/fmtlib/fmt/issues/1072,
+    https://github.com/fmtlib/fmt/issues/1129,
+    https://github.com/fmtlib/fmt/issues/1153,
+    https://github.com/fmtlib/fmt/pull/1155,
+    https://github.com/fmtlib/fmt/issues/1210,
+    https://github.com/fmtlib/fmt/issues/1222). Thanks @alabuzhev.
+
+-   Fixed bugs discovered by fuzzing or during fuzzing integration
+    (https://github.com/fmtlib/fmt/issues/1124,
+    https://github.com/fmtlib/fmt/issues/1127,
+    https://github.com/fmtlib/fmt/issues/1132,
+    https://github.com/fmtlib/fmt/pull/1135,
+    https://github.com/fmtlib/fmt/issues/1136,
+    https://github.com/fmtlib/fmt/issues/1141,
+    https://github.com/fmtlib/fmt/issues/1142,
+    https://github.com/fmtlib/fmt/issues/1178,
+    https://github.com/fmtlib/fmt/issues/1179,
+    https://github.com/fmtlib/fmt/issues/1194). Thanks @pauldreik.
+
+-   Fixed building tests on FreeBSD and Hurd
+    (https://github.com/fmtlib/fmt/issues/1043). Thanks @jackyf.
+
+-   Fixed various warnings and compilation issues
+    (https://github.com/fmtlib/fmt/pull/998,
+    https://github.com/fmtlib/fmt/pull/1006,
+    https://github.com/fmtlib/fmt/issues/1008,
+    https://github.com/fmtlib/fmt/issues/1011,
+    https://github.com/fmtlib/fmt/issues/1025,
+    https://github.com/fmtlib/fmt/pull/1027,
+    https://github.com/fmtlib/fmt/pull/1028,
+    https://github.com/fmtlib/fmt/pull/1029,
+    https://github.com/fmtlib/fmt/pull/1030,
+    https://github.com/fmtlib/fmt/pull/1031,
+    https://github.com/fmtlib/fmt/pull/1054,
+    https://github.com/fmtlib/fmt/issues/1063,
+    https://github.com/fmtlib/fmt/pull/1068,
+    https://github.com/fmtlib/fmt/pull/1074,
+    https://github.com/fmtlib/fmt/pull/1075,
+    https://github.com/fmtlib/fmt/pull/1079,
+    https://github.com/fmtlib/fmt/pull/1086,
+    https://github.com/fmtlib/fmt/issues/1088,
+    https://github.com/fmtlib/fmt/pull/1089,
+    https://github.com/fmtlib/fmt/pull/1094,
+    https://github.com/fmtlib/fmt/issues/1101,
+    https://github.com/fmtlib/fmt/pull/1102,
+    https://github.com/fmtlib/fmt/issues/1105,
+    https://github.com/fmtlib/fmt/pull/1107,
+    https://github.com/fmtlib/fmt/issues/1115,
+    https://github.com/fmtlib/fmt/issues/1117,
+    https://github.com/fmtlib/fmt/issues/1118,
+    https://github.com/fmtlib/fmt/issues/1120,
+    https://github.com/fmtlib/fmt/issues/1123,
+    https://github.com/fmtlib/fmt/pull/1139,
+    https://github.com/fmtlib/fmt/issues/1140,
+    https://github.com/fmtlib/fmt/issues/1143,
+    https://github.com/fmtlib/fmt/pull/1144,
+    https://github.com/fmtlib/fmt/pull/1150,
+    https://github.com/fmtlib/fmt/pull/1151,
+    https://github.com/fmtlib/fmt/issues/1152,
+    https://github.com/fmtlib/fmt/issues/1154,
+    https://github.com/fmtlib/fmt/issues/1156,
+    https://github.com/fmtlib/fmt/pull/1159,
+    https://github.com/fmtlib/fmt/issues/1175,
+    https://github.com/fmtlib/fmt/issues/1181,
+    https://github.com/fmtlib/fmt/issues/1186,
+    https://github.com/fmtlib/fmt/pull/1187,
+    https://github.com/fmtlib/fmt/pull/1191,
+    https://github.com/fmtlib/fmt/issues/1197,
+    https://github.com/fmtlib/fmt/issues/1200,
+    https://github.com/fmtlib/fmt/issues/1203,
+    https://github.com/fmtlib/fmt/issues/1205,
+    https://github.com/fmtlib/fmt/pull/1206,
+    https://github.com/fmtlib/fmt/issues/1213,
+    https://github.com/fmtlib/fmt/issues/1214,
+    https://github.com/fmtlib/fmt/pull/1217,
+    https://github.com/fmtlib/fmt/issues/1228,
+    https://github.com/fmtlib/fmt/pull/1230,
+    https://github.com/fmtlib/fmt/issues/1232,
+    https://github.com/fmtlib/fmt/pull/1235,
+    https://github.com/fmtlib/fmt/pull/1236,
+    https://github.com/fmtlib/fmt/issues/1240).
+    Thanks @DanielaE, @mwinterb, @eliaskosunen, @morinmorin, @ricco19,
+    @waywardmonkeys, @chronoxor, @remyabel, @pauldreik, @gsjaardema, @rcane,
+    @mocabe, @denchat, @cjdb, @HazardyKnusperkeks, @vedranmiletic, @jackoalan,
+    @DaanDeMeyer and @starkmapper.
+
+# 5.3.0 - 2018-12-28
+
+-   Introduced experimental chrono formatting support:
+
+    ```c++
+    #include <fmt/chrono.h>
+
+    int main() {
+      using namespace std::literals::chrono_literals;
+      fmt::print("Default format: {} {}\n", 42s, 100ms);
+      fmt::print("strftime-like format: {:%H:%M:%S}\n", 3h + 15min + 30s);
+    }
+    ```
+
+    prints:
+
+        Default format: 42s 100ms
+        strftime-like format: 03:15:30
+
+-   Added experimental support for emphasis (bold, italic, underline,
+    strikethrough), colored output to a file stream, and improved
+    colored formatting API
+    (https://github.com/fmtlib/fmt/pull/961,
+    https://github.com/fmtlib/fmt/pull/967,
+    https://github.com/fmtlib/fmt/pull/973):
+
+    ```c++
+    #include <fmt/color.h>
+
+    int main() {
+      print(fg(fmt::color::crimson) | fmt::emphasis::bold,
+            "Hello, {}!\n", "world");
+      print(fg(fmt::color::floral_white) | bg(fmt::color::slate_gray) |
+            fmt::emphasis::underline, "Hello, {}!\n", "мир");
+      print(fg(fmt::color::steel_blue) | fmt::emphasis::italic,
+            "Hello, {}!\n", "世界");
+    }
+    ```
+
+    prints the following on modern terminals with RGB color support:
+
+    ![](https://user-images.githubusercontent.com/576385/50405788-b66e7500-076e-11e9-9592-7324d1f951d8.png)
+
+    Thanks @Rakete1111.
+
+-   Added support for 4-bit terminal colors
+    (https://github.com/fmtlib/fmt/issues/968,
+    https://github.com/fmtlib/fmt/pull/974)
+
+    ```c++
+    #include <fmt/color.h>
+
+    int main() {
+      print(fg(fmt::terminal_color::red), "stop\n");
+    }
+    ```
+
+    Note that these colors vary by terminal:
+
+    ![](https://user-images.githubusercontent.com/576385/50405925-dbfc7e00-0770-11e9-9b85-333fab0af9ac.png)
+
+    Thanks @Rakete1111.
+
+-   Parameterized formatting functions on the type of the format string
+    (https://github.com/fmtlib/fmt/issues/880,
+    https://github.com/fmtlib/fmt/pull/881,
+    https://github.com/fmtlib/fmt/pull/883,
+    https://github.com/fmtlib/fmt/pull/885,
+    https://github.com/fmtlib/fmt/pull/897,
+    https://github.com/fmtlib/fmt/issues/920). Any object of
+    type `S` that has an overloaded `to_string_view(const S&)` returning
+    `fmt::string_view` can be used as a format string:
+
+    ```c++
+    namespace my_ns {
+    inline string_view to_string_view(const my_string& s) {
+      return {s.data(), s.length()};
+    }
+    }
+
+    std::string message = fmt::format(my_string("The answer is {}."), 42);
+    ```
+
+    Thanks @DanielaE.
+
+-   Made `std::string_view` work as a format string
+    (https://github.com/fmtlib/fmt/pull/898):
+
+    ```c++
+    auto message = fmt::format(std::string_view("The answer is {}."), 42);
+    ```
+
+    Thanks @DanielaE.
+
+-   Added wide string support to compile-time format string checks
+    (https://github.com/fmtlib/fmt/pull/924):
+
+    ```c++
+    print(fmt(L"{:f}"), 42); // compile-time error: invalid type specifier
+    ```
+
+    Thanks @XZiar.
+
+-   Made colored print functions work with wide strings
+    (https://github.com/fmtlib/fmt/pull/867):
+
+    ```c++
+    #include <fmt/color.h>
+
+    int main() {
+      print(fg(fmt::color::red), L"{}\n", 42);
+    }
+    ```
+
+    Thanks @DanielaE.
+
+-   Introduced experimental Unicode support
+    (https://github.com/fmtlib/fmt/issues/628,
+    https://github.com/fmtlib/fmt/pull/891):
+
+    ```c++
+    using namespace fmt::literals;
+    auto s = fmt::format("{:*^5}"_u, "🤡"_u); // s == "**🤡**"_u
+    ```
+
+-   Improved locale support:
+
+    ```c++
+    #include <fmt/locale.h>
+
+    struct numpunct : std::numpunct<char> {
+     protected:
+      char do_thousands_sep() const override { return '~'; }
+    };
+
+    std::locale loc;
+    auto s = fmt::format(std::locale(loc, new numpunct()), "{:n}", 1234567);
+    // s == "1~234~567"
+    ```
+
+-   Constrained formatting functions on proper iterator types
+    (https://github.com/fmtlib/fmt/pull/921). Thanks @DanielaE.
+
+-   Added `make_printf_args` and `make_wprintf_args` functions
+    (https://github.com/fmtlib/fmt/pull/934). Thanks @tnovotny.
+
+-   Deprecated `fmt::visit`, `parse_context`, and `wparse_context`. Use
+    `fmt::visit_format_arg`, `format_parse_context`, and
+    `wformat_parse_context` instead.
+
+-   Removed undocumented `basic_fixed_buffer` which has been superseded
+    by the iterator-based API
+    (https://github.com/fmtlib/fmt/issues/873,
+    https://github.com/fmtlib/fmt/pull/902). Thanks @superfunc.
+
+-   Disallowed repeated leading zeros in an argument ID:
+
+    ```c++
+    fmt::print("{000}", 42); // error
+    ```
+
+-   Reintroduced support for gcc 4.4.
+
+-   Fixed compilation on platforms with exotic `double`
+    (https://github.com/fmtlib/fmt/issues/878).
+
+-   Improved documentation
+    (https://github.com/fmtlib/fmt/issues/164,
+    https://github.com/fmtlib/fmt/issues/877,
+    https://github.com/fmtlib/fmt/pull/901,
+    https://github.com/fmtlib/fmt/pull/906,
+    https://github.com/fmtlib/fmt/pull/979).
+    Thanks @kookjr, @DarkDimius and @HecticSerenity.
+
+-   Added pkgconfig support which makes it easier to consume the library
+    from meson and other build systems
+    (https://github.com/fmtlib/fmt/pull/916). Thanks @colemickens.
+
+-   Various build improvements
+    (https://github.com/fmtlib/fmt/pull/909,
+    https://github.com/fmtlib/fmt/pull/926,
+    https://github.com/fmtlib/fmt/pull/937,
+    https://github.com/fmtlib/fmt/pull/953,
+    https://github.com/fmtlib/fmt/pull/959).
+    Thanks @tchaikov, @luncliff, @AndreasSchoenle, @hotwatermorning and @Zefz.
+
+-   Improved `string_view` construction performance
+    (https://github.com/fmtlib/fmt/pull/914). Thanks @gabime.
+
+-   Fixed non-matching char types
+    (https://github.com/fmtlib/fmt/pull/895). Thanks @DanielaE.
+
+-   Fixed `format_to_n` with `std::back_insert_iterator`
+    (https://github.com/fmtlib/fmt/pull/913). Thanks @DanielaE.
+
+-   Fixed locale-dependent formatting
+    (https://github.com/fmtlib/fmt/issues/905).
+
+-   Fixed various compiler warnings and errors
+    (https://github.com/fmtlib/fmt/pull/882,
+    https://github.com/fmtlib/fmt/pull/886,
+    https://github.com/fmtlib/fmt/pull/933,
+    https://github.com/fmtlib/fmt/pull/941,
+    https://github.com/fmtlib/fmt/issues/931,
+    https://github.com/fmtlib/fmt/pull/943,
+    https://github.com/fmtlib/fmt/pull/954,
+    https://github.com/fmtlib/fmt/pull/956,
+    https://github.com/fmtlib/fmt/pull/962,
+    https://github.com/fmtlib/fmt/issues/965,
+    https://github.com/fmtlib/fmt/issues/977,
+    https://github.com/fmtlib/fmt/pull/983,
+    https://github.com/fmtlib/fmt/pull/989).
+    Thanks @Luthaf, @stevenhoving, @christinaa, @lgritz, @DanielaE,
+    @0x8000-0000 and @liuping1997.
+
+# 5.2.1 - 2018-09-21
+
+-   Fixed `visit` lookup issues on gcc 7 & 8
+    (https://github.com/fmtlib/fmt/pull/870). Thanks @medithe.
+-   Fixed linkage errors on older gcc.
+-   Prevented `fmt/range.h` from specializing `fmt::basic_string_view`
+    (https://github.com/fmtlib/fmt/issues/865,
+    https://github.com/fmtlib/fmt/pull/868). Thanks @hhggit.
+-   Improved error message when formatting unknown types
+    (https://github.com/fmtlib/fmt/pull/872). Thanks @foonathan.
+-   Disabled templated user-defined literals when compiled under nvcc
+    (https://github.com/fmtlib/fmt/pull/875). Thanks @CandyGumdrop.
+-   Fixed `format_to` formatting to `wmemory_buffer`
+    (https://github.com/fmtlib/fmt/issues/874).
+
+# 5.2.0 - 2018-09-13
+
+-   Optimized format string parsing and argument processing which
+    resulted in up to 5x speed up on long format strings and significant
+    performance boost on various benchmarks. For example, version 5.2 is
+    2.22x faster than 5.1 on decimal integer formatting with `format_to`
+    (macOS, clang-902.0.39.2):
+
+    | Method                     | Time, s         | Speedup |
+    | -------------------------- | --------------: | ------: |
+    | fmt::format 5.1            | 0.58            |         |
+    | fmt::format 5.2            | 0.35            |   1.66x |
+    | fmt::format_to 5.1         | 0.51            |         |
+    | fmt::format_to 5.2         | 0.23            |   2.22x |
+    | sprintf                    | 0.71            |         |
+    | std::to_string             | 1.01            |         |
+    | std::stringstream          | 1.73            |         |
+
+-   Changed the `fmt` macro from opt-out to opt-in to prevent name
+    collisions. To enable it define the `FMT_STRING_ALIAS` macro to 1
+    before including `fmt/format.h`:
+
+    ```c++
+    #define FMT_STRING_ALIAS 1
+    #include <fmt/format.h>
+    std::string answer = format(fmt("{}"), 42);
+    ```
+
+-   Added compile-time format string checks to `format_to` overload that
+    takes `fmt::memory_buffer`
+    (https://github.com/fmtlib/fmt/issues/783):
+
+    ```c++
+    fmt::memory_buffer buf;
+    // Compile-time error: invalid type specifier.
+    fmt::format_to(buf, fmt("{:d}"), "foo");
+    ```
+
+-   Moved experimental color support to `fmt/color.h` and enabled the
+    new API by default. The old API can be enabled by defining the
+    `FMT_DEPRECATED_COLORS` macro.
+
+-   Added formatting support for types explicitly convertible to
+    `fmt::string_view`:
+
+    ```c++
+    struct foo {
+      explicit operator fmt::string_view() const { return "foo"; }
+    };
+    auto s = format("{}", foo());
+    ```
+
+    In particular, this makes formatting function work with
+    `folly::StringPiece`.
+
+-   Implemented preliminary support for `char*_t` by replacing the
+    `format` function overloads with a single function template
+    parameterized on the string type.
+
+-   Added support for dynamic argument lists
+    (https://github.com/fmtlib/fmt/issues/814,
+    https://github.com/fmtlib/fmt/pull/819). Thanks @MikePopoloski.
+
+-   Reduced executable size overhead for embedded targets using newlib
+    nano by making locale dependency optional
+    (https://github.com/fmtlib/fmt/pull/839). Thanks @teajay-fr.
+
+-   Keep `noexcept` specifier when exceptions are disabled
+    (https://github.com/fmtlib/fmt/issues/801,
+    https://github.com/fmtlib/fmt/pull/810). Thanks @qis.
+
+-   Fixed formatting of user-defined types providing `operator<<` with
+    `format_to_n` (https://github.com/fmtlib/fmt/pull/806).
+    Thanks @mkurdej.
+
+-   Fixed dynamic linkage of new symbols
+    (https://github.com/fmtlib/fmt/issues/808).
+
+-   Fixed global initialization issue
+    (https://github.com/fmtlib/fmt/issues/807):
+
+    ```c++
+    // This works on compilers with constexpr support.
+    static const std::string answer = fmt::format("{}", 42);
+    ```
+
+-   Fixed various compiler warnings and errors
+    (https://github.com/fmtlib/fmt/pull/804,
+    https://github.com/fmtlib/fmt/issues/809,
+    https://github.com/fmtlib/fmt/pull/811,
+    https://github.com/fmtlib/fmt/issues/822,
+    https://github.com/fmtlib/fmt/pull/827,
+    https://github.com/fmtlib/fmt/issues/830,
+    https://github.com/fmtlib/fmt/pull/838,
+    https://github.com/fmtlib/fmt/issues/843,
+    https://github.com/fmtlib/fmt/pull/844,
+    https://github.com/fmtlib/fmt/issues/851,
+    https://github.com/fmtlib/fmt/pull/852,
+    https://github.com/fmtlib/fmt/pull/854).
+    Thanks @henryiii, @medithe, and @eliasdaler.
+
+# 5.1.0 - 2018-07-05
+
+-   Added experimental support for RGB color output enabled with the
+    `FMT_EXTENDED_COLORS` macro:
+
+    ```c++
+    #define FMT_EXTENDED_COLORS
+    #define FMT_HEADER_ONLY // or compile fmt with FMT_EXTENDED_COLORS defined
+    #include <fmt/format.h>
+
+    fmt::print(fmt::color::steel_blue, "Some beautiful text");
+    ```
+
+    The old API (the `print_colored` and `vprint_colored` functions and
+    the `color` enum) is now deprecated.
+    (https://github.com/fmtlib/fmt/issues/762
+    https://github.com/fmtlib/fmt/pull/767). thanks @Remotion.
+
+-   Added quotes to strings in ranges and tuples
+    (https://github.com/fmtlib/fmt/pull/766). Thanks @Remotion.
+
+-   Made `format_to` work with `basic_memory_buffer`
+    (https://github.com/fmtlib/fmt/issues/776).
+
+-   Added `vformat_to_n` and `wchar_t` overload of `format_to_n`
+    (https://github.com/fmtlib/fmt/issues/764,
+    https://github.com/fmtlib/fmt/issues/769).
+
+-   Made `is_range` and `is_tuple_like` part of public (experimental)
+    API to allow specialization for user-defined types
+    (https://github.com/fmtlib/fmt/issues/751,
+    https://github.com/fmtlib/fmt/pull/759). Thanks @drrlvn.
+
+-   Added more compilers to continuous integration and increased
+    `FMT_PEDANTIC` warning levels
+    (https://github.com/fmtlib/fmt/pull/736). Thanks @eliaskosunen.
+
+-   Fixed compilation with MSVC 2013.
+
+-   Fixed handling of user-defined types in `format_to`
+    (https://github.com/fmtlib/fmt/issues/793).
+
+-   Forced linking of inline `vformat` functions into the library
+    (https://github.com/fmtlib/fmt/issues/795).
+
+-   Fixed incorrect call to on_align in `'{:}='`
+    (https://github.com/fmtlib/fmt/issues/750).
+
+-   Fixed floating-point formatting to a non-back_insert_iterator with
+    sign & numeric alignment specified
+    (https://github.com/fmtlib/fmt/issues/756).
+
+-   Fixed formatting to an array with `format_to_n`
+    (https://github.com/fmtlib/fmt/issues/778).
+
+-   Fixed formatting of more than 15 named arguments
+    (https://github.com/fmtlib/fmt/issues/754).
+
+-   Fixed handling of compile-time strings when including
+    `fmt/ostream.h`. (https://github.com/fmtlib/fmt/issues/768).
+
+-   Fixed various compiler warnings and errors
+    (https://github.com/fmtlib/fmt/issues/742,
+    https://github.com/fmtlib/fmt/issues/748,
+    https://github.com/fmtlib/fmt/issues/752,
+    https://github.com/fmtlib/fmt/issues/770,
+    https://github.com/fmtlib/fmt/pull/775,
+    https://github.com/fmtlib/fmt/issues/779,
+    https://github.com/fmtlib/fmt/pull/780,
+    https://github.com/fmtlib/fmt/pull/790,
+    https://github.com/fmtlib/fmt/pull/792,
+    https://github.com/fmtlib/fmt/pull/800).
+    Thanks @Remotion, @gabime, @foonathan, @Dark-Passenger and @0x8000-0000.
+
+# 5.0.0 - 2018-05-21
+
+-   Added a requirement for partial C++11 support, most importantly
+    variadic templates and type traits, and dropped `FMT_VARIADIC_*`
+    emulation macros. Variadic templates are available since GCC 4.4,
+    Clang 2.9 and MSVC 18.0 (2013). For older compilers use {fmt}
+    [version 4.x](https://github.com/fmtlib/fmt/releases/tag/4.1.0)
+    which continues to be maintained and works with C++98 compilers.
+
+-   Renamed symbols to follow standard C++ naming conventions and
+    proposed a subset of the library for standardization in [P0645R2
+    Text Formatting](https://wg21.link/P0645).
+
+-   Implemented `constexpr` parsing of format strings and [compile-time
+    format string
+    checks](https://fmt.dev/latest/api.html#compile-time-format-string-checks).
+    For example
+
+    ```c++
+    #include <fmt/format.h>
+
+    std::string s = format(fmt("{:d}"), "foo");
+    ```
+
+    gives a compile-time error because `d` is an invalid specifier for
+    strings ([godbolt](https://godbolt.org/g/rnCy9Q)):
+
+        ...
+        <source>:4:19: note: in instantiation of function template specialization 'fmt::v5::format<S, char [4]>' requested here
+          std::string s = format(fmt("{:d}"), "foo");
+                          ^
+        format.h:1337:13: note: non-constexpr function 'on_error' cannot be used in a constant expression
+            handler.on_error("invalid type specifier");
+
+    Compile-time checks require relaxed `constexpr` (C++14 feature)
+    support. If the latter is not available, checks will be performed at
+    runtime.
+
+-   Separated format string parsing and formatting in the extension API
+    to enable compile-time format string processing. For example
+
+    ```c++
+    struct Answer {};
+
+    namespace fmt {
+    template <>
+    struct formatter<Answer> {
+      constexpr auto parse(parse_context& ctx) {
+        auto it = ctx.begin();
+        spec = *it;
+        if (spec != 'd' && spec != 's')
+          throw format_error("invalid specifier");
+        return ++it;
+      }
+
+      template <typename FormatContext>
+      auto format(Answer, FormatContext& ctx) {
+        return spec == 's' ?
+          format_to(ctx.begin(), "{}", "fourty-two") :
+          format_to(ctx.begin(), "{}", 42);
+      }
+
+      char spec = 0;
+    };
+    }
+
+    std::string s = format(fmt("{:x}"), Answer());
+    ```
+
+    gives a compile-time error due to invalid format specifier
+    ([godbolt](https://godbolt.org/g/2jQ1Dv)):
+
+        ...
+        <source>:12:45: error: expression '<throw-expression>' is not a constant expression
+               throw format_error("invalid specifier");
+
+-   Added [iterator
+    support](https://fmt.dev/latest/api.html#output-iterator-support):
+
+    ```c++
+    #include <vector>
+    #include <fmt/format.h>
+
+    std::vector<char> out;
+    fmt::format_to(std::back_inserter(out), "{}", 42);
+    ```
+
+-   Added the
+    [format_to_n](https://fmt.dev/latest/api.html#_CPPv2N3fmt11format_to_nE8OutputItNSt6size_tE11string_viewDpRK4Args)
+    function that restricts the output to the specified number of
+    characters (https://github.com/fmtlib/fmt/issues/298):
+
+    ```c++
+    char out[4];
+    fmt::format_to_n(out, sizeof(out), "{}", 12345);
+    // out == "1234" (without terminating '\0')
+    ```
+
+-   Added the [formatted_size](
+    https://fmt.dev/latest/api.html#_CPPv2N3fmt14formatted_sizeE11string_viewDpRK4Args)
+    function for computing the output size:
+
+    ```c++
+    #include <fmt/format.h>
+
+    auto size = fmt::formatted_size("{}", 12345); // size == 5
+    ```
+
+-   Improved compile times by reducing dependencies on standard headers
+    and providing a lightweight [core
+    API](https://fmt.dev/latest/api.html#core-api):
+
+    ```c++
+    #include <fmt/core.h>
+
+    fmt::print("The answer is {}.", 42);
+    ```
+
+    See [Compile time and code
+    bloat](https://github.com/fmtlib/fmt#compile-time-and-code-bloat).
+
+-   Added the [make_format_args](
+    https://fmt.dev/latest/api.html#_CPPv2N3fmt16make_format_argsEDpRK4Args)
+    function for capturing formatting arguments:
+
+    ```c++
+    // Prints formatted error message.
+    void vreport_error(const char *format, fmt::format_args args) {
+      fmt::print("Error: ");
+      fmt::vprint(format, args);
+    }
+    template <typename... Args>
+    void report_error(const char *format, const Args & ... args) {
+      vreport_error(format, fmt::make_format_args(args...));
+    }
+    ```
+
+-   Added the `make_printf_args` function for capturing `printf`
+    arguments (https://github.com/fmtlib/fmt/issues/687,
+    https://github.com/fmtlib/fmt/pull/694). Thanks @Kronuz.
+
+-   Added prefix `v` to non-variadic functions taking `format_args` to
+    distinguish them from variadic ones:
+
+    ```c++
+    std::string vformat(string_view format_str, format_args args);
+
+    template <typename... Args>
+    std::string format(string_view format_str, const Args & ... args);
+    ```
+
+-   Added experimental support for formatting ranges, containers and
+    tuple-like types in `fmt/ranges.h`
+    (https://github.com/fmtlib/fmt/pull/735):
+
+    ```c++
+    #include <fmt/ranges.h>
+
+    std::vector<int> v = {1, 2, 3};
+    fmt::print("{}", v); // prints {1, 2, 3}
+    ```
+
+    Thanks @Remotion.
+
+-   Implemented `wchar_t` date and time formatting
+    (https://github.com/fmtlib/fmt/pull/712):
+
+    ```c++
+    #include <fmt/time.h>
+
+    std::time_t t = std::time(nullptr);
+    auto s = fmt::format(L"The date is {:%Y-%m-%d}.", *std::localtime(&t));
+    ```
+
+    Thanks @DanielaE.
+
+-   Provided more wide string overloads
+    (https://github.com/fmtlib/fmt/pull/724). Thanks @DanielaE.
+
+-   Switched from a custom null-terminated string view class to
+    `string_view` in the format API and provided `fmt::string_view`
+    which implements a subset of `std::string_view` API for pre-C++17
+    systems.
+
+-   Added support for `std::experimental::string_view`
+    (https://github.com/fmtlib/fmt/pull/607):
+
+    ```c++
+    #include <fmt/core.h>
+    #include <experimental/string_view>
+
+    fmt::print("{}", std::experimental::string_view("foo"));
+    ```
+
+    Thanks @virgiliofornazin.
+
+-   Allowed mixing named and automatic arguments:
+
+    ```c++
+    fmt::format("{} {two}", 1, fmt::arg("two", 2));
+    ```
+
+-   Removed the write API in favor of the [format
+    API](https://fmt.dev/latest/api.html#format-api) with compile-time
+    handling of format strings.
+
+-   Disallowed formatting of multibyte strings into a wide character
+    target (https://github.com/fmtlib/fmt/pull/606).
+
+-   Improved documentation
+    (https://github.com/fmtlib/fmt/pull/515,
+    https://github.com/fmtlib/fmt/issues/614,
+    https://github.com/fmtlib/fmt/pull/617,
+    https://github.com/fmtlib/fmt/pull/661,
+    https://github.com/fmtlib/fmt/pull/680).
+    Thanks @ibell, @mihaitodor and @johnthagen.
+
+-   Implemented more efficient handling of large number of format
+    arguments.
+
+-   Introduced an inline namespace for symbol versioning.
+
+-   Added debug postfix `d` to the `fmt` library name
+    (https://github.com/fmtlib/fmt/issues/636).
+
+-   Removed unnecessary `fmt/` prefix in includes
+    (https://github.com/fmtlib/fmt/pull/397). Thanks @chronoxor.
+
+-   Moved `fmt/*.h` to `include/fmt/*.h` to prevent irrelevant files and
+    directories appearing on the include search paths when fmt is used
+    as a subproject and moved source files to the `src` directory.
+
+-   Added qmake project file `support/fmt.pro`
+    (https://github.com/fmtlib/fmt/pull/641). Thanks @cowo78.
+
+-   Added Gradle build file `support/build.gradle`
+    (https://github.com/fmtlib/fmt/pull/649). Thanks @luncliff.
+
+-   Removed `FMT_CPPFORMAT` CMake option.
+
+-   Fixed a name conflict with the macro `CHAR_WIDTH` in glibc
+    (https://github.com/fmtlib/fmt/pull/616). Thanks @aroig.
+
+-   Fixed handling of nested braces in `fmt::join`
+    (https://github.com/fmtlib/fmt/issues/638).
+
+-   Added `SOURCELINK_SUFFIX` for compatibility with Sphinx 1.5
+    (https://github.com/fmtlib/fmt/pull/497). Thanks @ginggs.
+
+-   Added a missing `inline` in the header-only mode
+    (https://github.com/fmtlib/fmt/pull/626). Thanks @aroig.
+
+-   Fixed various compiler warnings
+    (https://github.com/fmtlib/fmt/pull/640,
+    https://github.com/fmtlib/fmt/pull/656,
+    https://github.com/fmtlib/fmt/pull/679,
+    https://github.com/fmtlib/fmt/pull/681,
+    https://github.com/fmtlib/fmt/pull/705,
+    https://github.com/fmtlib/fmt/issues/715,
+    https://github.com/fmtlib/fmt/pull/717,
+    https://github.com/fmtlib/fmt/pull/720,
+    https://github.com/fmtlib/fmt/pull/723,
+    https://github.com/fmtlib/fmt/pull/726,
+    https://github.com/fmtlib/fmt/pull/730,
+    https://github.com/fmtlib/fmt/pull/739).
+    Thanks @peterbell10, @LarsGullik, @foonathan, @eliaskosunen,
+    @christianparpart, @DanielaE and @mwinterb.
+
+-   Worked around an MSVC bug and fixed several warnings
+    (https://github.com/fmtlib/fmt/pull/653). Thanks @alabuzhev.
+
+-   Worked around GCC bug 67371
+    (https://github.com/fmtlib/fmt/issues/682).
+
+-   Fixed compilation with `-fno-exceptions`
+    (https://github.com/fmtlib/fmt/pull/655). Thanks @chenxiaolong.
+
+-   Made `constexpr remove_prefix` gcc version check tighter
+    (https://github.com/fmtlib/fmt/issues/648).
+
+-   Renamed internal type enum constants to prevent collision with
+    poorly written C libraries
+    (https://github.com/fmtlib/fmt/issues/644).
+
+-   Added detection of `wostream operator<<`
+    (https://github.com/fmtlib/fmt/issues/650).
+
+-   Fixed compilation on OpenBSD
+    (https://github.com/fmtlib/fmt/pull/660). Thanks @hubslave.
+
+-   Fixed compilation on FreeBSD 12
+    (https://github.com/fmtlib/fmt/pull/732). Thanks @dankm.
+
+-   Fixed compilation when there is a mismatch between `-std` options
+    between the library and user code
+    (https://github.com/fmtlib/fmt/issues/664).
+
+-   Fixed compilation with GCC 7 and `-std=c++11`
+    (https://github.com/fmtlib/fmt/issues/734).
+
+-   Improved generated binary code on GCC 7 and older
+    (https://github.com/fmtlib/fmt/issues/668).
+
+-   Fixed handling of numeric alignment with no width
+    (https://github.com/fmtlib/fmt/issues/675).
+
+-   Fixed handling of empty strings in UTF8/16 converters
+    (https://github.com/fmtlib/fmt/pull/676). Thanks @vgalka-sl.
+
+-   Fixed formatting of an empty `string_view`
+    (https://github.com/fmtlib/fmt/issues/689).
+
+-   Fixed detection of `string_view` on libc++
+    (https://github.com/fmtlib/fmt/issues/686).
+
+-   Fixed DLL issues (https://github.com/fmtlib/fmt/pull/696).
+    Thanks @sebkoenig.
+
+-   Fixed compile checks for mixing narrow and wide strings
+    (https://github.com/fmtlib/fmt/issues/690).
+
+-   Disabled unsafe implicit conversion to `std::string`
+    (https://github.com/fmtlib/fmt/issues/729).
+
+-   Fixed handling of reused format specs (as in `fmt::join`) for
+    pointers (https://github.com/fmtlib/fmt/pull/725). Thanks @mwinterb.
+
+-   Fixed installation of `fmt/ranges.h`
+    (https://github.com/fmtlib/fmt/pull/738). Thanks @sv1990.
+
+# 4.1.0 - 2017-12-20
+
+-   Added `fmt::to_wstring()` in addition to `fmt::to_string()`
+    (https://github.com/fmtlib/fmt/pull/559). Thanks @alabuzhev.
+-   Added support for C++17 `std::string_view`
+    (https://github.com/fmtlib/fmt/pull/571 and
+    https://github.com/fmtlib/fmt/pull/578).
+    Thanks @thelostt and @mwinterb.
+-   Enabled stream exceptions to catch errors
+    (https://github.com/fmtlib/fmt/issues/581). Thanks @crusader-mike.
+-   Allowed formatting of class hierarchies with `fmt::format_arg()`
+    (https://github.com/fmtlib/fmt/pull/547). Thanks @rollbear.
+-   Removed limitations on character types
+    (https://github.com/fmtlib/fmt/pull/563). Thanks @Yelnats321.
+-   Conditionally enabled use of `std::allocator_traits`
+    (https://github.com/fmtlib/fmt/pull/583). Thanks @mwinterb.
+-   Added support for `const` variadic member function emulation with
+    `FMT_VARIADIC_CONST`
+    (https://github.com/fmtlib/fmt/pull/591). Thanks @ludekvodicka.
+-   Various bugfixes: bad overflow check, unsupported implicit type
+    conversion when determining formatting function, test segfaults
+    (https://github.com/fmtlib/fmt/issues/551), ill-formed
+    macros (https://github.com/fmtlib/fmt/pull/542) and
+    ambiguous overloads
+    (https://github.com/fmtlib/fmt/issues/580). Thanks @xylosper.
+-   Prevented warnings on MSVC
+    (https://github.com/fmtlib/fmt/pull/605,
+    https://github.com/fmtlib/fmt/pull/602, and
+    https://github.com/fmtlib/fmt/pull/545), clang
+    (https://github.com/fmtlib/fmt/pull/582), GCC
+    (https://github.com/fmtlib/fmt/issues/573), various
+    conversion warnings (https://github.com/fmtlib/fmt/pull/609,
+    https://github.com/fmtlib/fmt/pull/567,
+    https://github.com/fmtlib/fmt/pull/553 and
+    https://github.com/fmtlib/fmt/pull/553), and added
+    `override` and `[[noreturn]]`
+    (https://github.com/fmtlib/fmt/pull/549 and
+    https://github.com/fmtlib/fmt/issues/555).
+    Thanks @alabuzhev, @virgiliofornazin, @alexanderbock, @yumetodo, @VaderY,
+    @jpcima, @thelostt and @Manu343726.
+-   Improved CMake: Used `GNUInstallDirs` to set installation location
+    (https://github.com/fmtlib/fmt/pull/610) and fixed warnings
+    (https://github.com/fmtlib/fmt/pull/536 and
+    https://github.com/fmtlib/fmt/pull/556).
+    Thanks @mikecrowe, @evgen231 and @henryiii.
+
+# 4.0.0 - 2017-06-27
+
+-   Removed old compatibility headers `cppformat/*.h` and CMake options
+    (https://github.com/fmtlib/fmt/pull/527). Thanks @maddinat0r.
+
+-   Added `string.h` containing `fmt::to_string()` as alternative to
+    `std::to_string()` as well as other string writer functionality
+    (https://github.com/fmtlib/fmt/issues/326 and
+    https://github.com/fmtlib/fmt/pull/441):
+
+    ```c++
+    #include "fmt/string.h"
+
+    std::string answer = fmt::to_string(42);
+    ```
+
+    Thanks @glebov-andrey.
+
+-   Moved `fmt::printf()` to new `printf.h` header and allowed `%s` as
+    generic specifier (https://github.com/fmtlib/fmt/pull/453),
+    made `%.f` more conformant to regular `printf()`
+    (https://github.com/fmtlib/fmt/pull/490), added custom
+    writer support (https://github.com/fmtlib/fmt/issues/476)
+    and implemented missing custom argument formatting
+    (https://github.com/fmtlib/fmt/pull/339 and
+    https://github.com/fmtlib/fmt/pull/340):
+
+    ```c++
+    #include "fmt/printf.h"
+
+    // %s format specifier can be used with any argument type.
+    fmt::printf("%s", 42);
+    ```
+
+    Thanks @mojoBrendan, @manylegged and @spacemoose.
+    See also https://github.com/fmtlib/fmt/issues/360,
+    https://github.com/fmtlib/fmt/issues/335 and
+    https://github.com/fmtlib/fmt/issues/331.
+
+-   Added `container.h` containing a `BasicContainerWriter` to write to
+    containers like `std::vector`
+    (https://github.com/fmtlib/fmt/pull/450). Thanks @polyvertex.
+
+-   Added `fmt::join()` function that takes a range and formats its
+    elements separated by a given string
+    (https://github.com/fmtlib/fmt/pull/466):
+
+    ```c++
+    #include "fmt/format.h"
+
+    std::vector<double> v = {1.2, 3.4, 5.6};
+    // Prints "(+01.20, +03.40, +05.60)".
+    fmt::print("({:+06.2f})", fmt::join(v.begin(), v.end(), ", "));
+    ```
+
+    Thanks @olivier80.
+
+-   Added support for custom formatting specifications to simplify
+    customization of built-in formatting
+    (https://github.com/fmtlib/fmt/pull/444). Thanks @polyvertex.
+    See also https://github.com/fmtlib/fmt/issues/439.
+
+-   Added `fmt::format_system_error()` for error code formatting
+    (https://github.com/fmtlib/fmt/issues/323 and
+    https://github.com/fmtlib/fmt/pull/526). Thanks @maddinat0r.
+
+-   Added thread-safe `fmt::localtime()` and `fmt::gmtime()` as
+    replacement for the standard version to `time.h`
+    (https://github.com/fmtlib/fmt/pull/396). Thanks @codicodi.
+
+-   Internal improvements to `NamedArg` and `ArgLists`
+    (https://github.com/fmtlib/fmt/pull/389 and
+    https://github.com/fmtlib/fmt/pull/390). Thanks @chronoxor.
+
+-   Fixed crash due to bug in `FormatBuf`
+    (https://github.com/fmtlib/fmt/pull/493). Thanks @effzeh. See also
+    https://github.com/fmtlib/fmt/issues/480 and
+    https://github.com/fmtlib/fmt/issues/491.
+
+-   Fixed handling of wide strings in `fmt::StringWriter`.
+
+-   Improved compiler error messages
+    (https://github.com/fmtlib/fmt/issues/357).
+
+-   Fixed various warnings and issues with various compilers
+    (https://github.com/fmtlib/fmt/pull/494,
+    https://github.com/fmtlib/fmt/pull/499,
+    https://github.com/fmtlib/fmt/pull/483,
+    https://github.com/fmtlib/fmt/pull/485,
+    https://github.com/fmtlib/fmt/pull/482,
+    https://github.com/fmtlib/fmt/pull/475,
+    https://github.com/fmtlib/fmt/pull/473 and
+    https://github.com/fmtlib/fmt/pull/414).
+    Thanks @chronoxor, @zhaohuaxishi, @pkestene, @dschmidt and @0x414c.
+
+-   Improved CMake: targets are now namespaced
+    (https://github.com/fmtlib/fmt/pull/511 and
+    https://github.com/fmtlib/fmt/pull/513), supported
+    header-only `printf.h`
+    (https://github.com/fmtlib/fmt/pull/354), fixed issue with
+    minimal supported library subset
+    (https://github.com/fmtlib/fmt/issues/418,
+    https://github.com/fmtlib/fmt/pull/419 and
+    https://github.com/fmtlib/fmt/pull/420).
+    Thanks @bjoernthiel, @niosHD, @LogicalKnight and @alabuzhev.
+
+-   Improved documentation (https://github.com/fmtlib/fmt/pull/393).
+    Thanks @pwm1234.
+
+# 3.0.2 - 2017-06-14
+
+-   Added `FMT_VERSION` macro
+    (https://github.com/fmtlib/fmt/issues/411).
+-   Used `FMT_NULL` instead of literal `0`
+    (https://github.com/fmtlib/fmt/pull/409). Thanks @alabuzhev.
+-   Added extern templates for `format_float`
+    (https://github.com/fmtlib/fmt/issues/413).
+-   Fixed implicit conversion issue
+    (https://github.com/fmtlib/fmt/issues/507).
+-   Fixed signbit detection
+    (https://github.com/fmtlib/fmt/issues/423).
+-   Fixed naming collision
+    (https://github.com/fmtlib/fmt/issues/425).
+-   Fixed missing intrinsic for C++/CLI
+    (https://github.com/fmtlib/fmt/pull/457). Thanks @calumr.
+-   Fixed Android detection
+    (https://github.com/fmtlib/fmt/pull/458). Thanks @Gachapen.
+-   Use lean `windows.h` if not in header-only mode
+    (https://github.com/fmtlib/fmt/pull/503). Thanks @Quentin01.
+-   Fixed issue with CMake exporting C++11 flag
+    (https://github.com/fmtlib/fmt/pull/455). Thanks @EricWF.
+-   Fixed issue with nvcc and MSVC compiler bug and MinGW
+    (https://github.com/fmtlib/fmt/issues/505).
+-   Fixed DLL issues (https://github.com/fmtlib/fmt/pull/469 and
+    https://github.com/fmtlib/fmt/pull/502).
+    Thanks @richardeakin and @AndreasSchoenle.
+-   Fixed test compilation under FreeBSD
+    (https://github.com/fmtlib/fmt/issues/433).
+-   Fixed various warnings
+    (https://github.com/fmtlib/fmt/pull/403,
+    https://github.com/fmtlib/fmt/pull/410 and
+    https://github.com/fmtlib/fmt/pull/510).
+    Thanks @Lecetem, @chenhayat and @trozen.
+-   Worked around a broken `__builtin_clz` in clang with MS codegen
+    (https://github.com/fmtlib/fmt/issues/519).
+-   Removed redundant include
+    (https://github.com/fmtlib/fmt/issues/479).
+-   Fixed documentation issues.
+
+# 3.0.1 - 2016-11-01
+
+-   Fixed handling of thousands separator
+    (https://github.com/fmtlib/fmt/issues/353).
+-   Fixed handling of `unsigned char` strings
+    (https://github.com/fmtlib/fmt/issues/373).
+-   Corrected buffer growth when formatting time
+    (https://github.com/fmtlib/fmt/issues/367).
+-   Removed warnings under MSVC and clang
+    (https://github.com/fmtlib/fmt/issues/318,
+    https://github.com/fmtlib/fmt/issues/250, also merged
+    https://github.com/fmtlib/fmt/pull/385 and
+    https://github.com/fmtlib/fmt/pull/361).
+    Thanks @jcelerier and @nmoehrle.
+-   Fixed compilation issues under Android
+    (https://github.com/fmtlib/fmt/pull/327,
+    https://github.com/fmtlib/fmt/issues/345 and
+    https://github.com/fmtlib/fmt/pull/381), FreeBSD
+    (https://github.com/fmtlib/fmt/pull/358), Cygwin
+    (https://github.com/fmtlib/fmt/issues/388), MinGW
+    (https://github.com/fmtlib/fmt/issues/355) as well as other
+    issues (https://github.com/fmtlib/fmt/issues/350,
+    https://github.com/fmtlib/fmt/issues/355,
+    https://github.com/fmtlib/fmt/pull/348,
+    https://github.com/fmtlib/fmt/pull/402,
+    https://github.com/fmtlib/fmt/pull/405).
+    Thanks @dpantele, @hghwng, @arvedarved, @LogicalKnight and @JanHellwig.
+-   Fixed some documentation issues and extended specification
+    (https://github.com/fmtlib/fmt/issues/320,
+    https://github.com/fmtlib/fmt/pull/333,
+    https://github.com/fmtlib/fmt/issues/347,
+    https://github.com/fmtlib/fmt/pull/362). Thanks @smellman.
+
+# 3.0.0 - 2016-05-07
+
+-   The project has been renamed from C++ Format (cppformat) to fmt for
+    consistency with the used namespace and macro prefix
+    (https://github.com/fmtlib/fmt/issues/307). Library headers
+    are now located in the `fmt` directory:
+
+    ```c++
+    #include "fmt/format.h"
+    ```
+
+    Including `format.h` from the `cppformat` directory is deprecated
+    but works via a proxy header which will be removed in the next major
+    version.
+
+    The documentation is now available at <https://fmt.dev>.
+
+-   Added support for
+    [strftime](http://en.cppreference.com/w/cpp/chrono/c/strftime)-like
+    [date and time
+    formatting](https://fmt.dev/3.0.0/api.html#date-and-time-formatting)
+    (https://github.com/fmtlib/fmt/issues/283):
+
+    ```c++
+    #include "fmt/time.h"
+
+    std::time_t t = std::time(nullptr);
+    // Prints "The date is 2016-04-29." (with the current date)
+    fmt::print("The date is {:%Y-%m-%d}.", *std::localtime(&t));
+    ```
+
+-   `std::ostream` support including formatting of user-defined types
+    that provide overloaded `operator<<` has been moved to
+    `fmt/ostream.h`:
+
+    ```c++
+    #include "fmt/ostream.h"
+
+    class Date {
+      int year_, month_, day_;
+    public:
+      Date(int year, int month, int day) : year_(year), month_(month), day_(day) {}
+
+      friend std::ostream &operator<<(std::ostream &os, const Date &d) {
+        return os << d.year_ << '-' << d.month_ << '-' << d.day_;
+      }
+    };
+
+    std::string s = fmt::format("The date is {}", Date(2012, 12, 9));
+    // s == "The date is 2012-12-9"
+    ```
+
+-   Added support for [custom argument
+    formatters](https://fmt.dev/3.0.0/api.html#argument-formatters)
+    (https://github.com/fmtlib/fmt/issues/235).
+
+-   Added support for locale-specific integer formatting with the `n`
+    specifier (https://github.com/fmtlib/fmt/issues/305):
+
+    ```c++
+    std::setlocale(LC_ALL, "en_US.utf8");
+    fmt::print("cppformat: {:n}\n", 1234567); // prints 1,234,567
+    ```
+
+-   Sign is now preserved when formatting an integer with an incorrect
+    `printf` format specifier
+    (https://github.com/fmtlib/fmt/issues/265):
+
+    ```c++
+    fmt::printf("%lld", -42); // prints -42
+    ```
+
+    Note that it would be an undefined behavior in `std::printf`.
+
+-   Length modifiers such as `ll` are now optional in printf formatting
+    functions and the correct type is determined automatically
+    (https://github.com/fmtlib/fmt/issues/255):
+
+    ```c++
+    fmt::printf("%d", std::numeric_limits<long long>::max());
+    ```
+
+    Note that it would be an undefined behavior in `std::printf`.
+
+-   Added initial support for custom formatters
+    (https://github.com/fmtlib/fmt/issues/231).
+
+-   Fixed detection of user-defined literal support on Intel C++
+    compiler (https://github.com/fmtlib/fmt/issues/311,
+    https://github.com/fmtlib/fmt/pull/312).
+    Thanks @dean0x7d and @speth.
+
+-   Reduced compile time
+    (https://github.com/fmtlib/fmt/pull/243,
+    https://github.com/fmtlib/fmt/pull/249,
+    https://github.com/fmtlib/fmt/issues/317):
+
+    ![](https://cloud.githubusercontent.com/assets/4831417/11614060/b9e826d2-9c36-11e5-8666-d4131bf503ef.png)
+
+    ![](https://cloud.githubusercontent.com/assets/4831417/11614080/6ac903cc-9c37-11e5-8165-26df6efae364.png)
+
+    Thanks @dean0x7d.
+
+-   Compile test fixes (https://github.com/fmtlib/fmt/pull/313).
+    Thanks @dean0x7d.
+
+-   Documentation fixes (https://github.com/fmtlib/fmt/pull/239,
+    https://github.com/fmtlib/fmt/issues/248,
+    https://github.com/fmtlib/fmt/issues/252,
+    https://github.com/fmtlib/fmt/pull/258,
+    https://github.com/fmtlib/fmt/issues/260,
+    https://github.com/fmtlib/fmt/issues/301,
+    https://github.com/fmtlib/fmt/pull/309).
+    Thanks @ReadmeCritic @Gachapen and @jwilk.
+
+-   Fixed compiler and sanitizer warnings
+    (https://github.com/fmtlib/fmt/issues/244,
+    https://github.com/fmtlib/fmt/pull/256,
+    https://github.com/fmtlib/fmt/pull/259,
+    https://github.com/fmtlib/fmt/issues/263,
+    https://github.com/fmtlib/fmt/issues/274,
+    https://github.com/fmtlib/fmt/pull/277,
+    https://github.com/fmtlib/fmt/pull/286,
+    https://github.com/fmtlib/fmt/issues/291,
+    https://github.com/fmtlib/fmt/issues/296,
+    https://github.com/fmtlib/fmt/issues/308).
+    Thanks @mwinterb, @pweiskircher and @Naios.
+
+-   Improved compatibility with Windows Store apps
+    (https://github.com/fmtlib/fmt/issues/280,
+    https://github.com/fmtlib/fmt/pull/285) Thanks @mwinterb.
+
+-   Added tests of compatibility with older C++ standards
+    (https://github.com/fmtlib/fmt/pull/273). Thanks @niosHD.
+
+-   Fixed Android build
+    (https://github.com/fmtlib/fmt/pull/271). Thanks @newnon.
+
+-   Changed `ArgMap` to be backed by a vector instead of a map.
+    (https://github.com/fmtlib/fmt/issues/261,
+    https://github.com/fmtlib/fmt/pull/262). Thanks @mwinterb.
+
+-   Added `fprintf` overload that writes to a `std::ostream`
+    (https://github.com/fmtlib/fmt/pull/251).
+    Thanks @nickhutchinson.
+
+-   Export symbols when building a Windows DLL
+    (https://github.com/fmtlib/fmt/pull/245).
+    Thanks @macdems.
+
+-   Fixed compilation on Cygwin
+    (https://github.com/fmtlib/fmt/issues/304).
+
+-   Implemented a workaround for a bug in Apple LLVM version 4.2 of
+    clang (https://github.com/fmtlib/fmt/issues/276).
+
+-   Implemented a workaround for Google Test bug
+    https://github.com/google/googletest/issues/705 on gcc 6
+    (https://github.com/fmtlib/fmt/issues/268). Thanks @octoploid.
+
+-   Removed Biicode support because the latter has been discontinued.
+
+# 2.1.1 - 2016-04-11
+
+-   The install location for generated CMake files is now configurable
+    via the `FMT_CMAKE_DIR` CMake variable
+    (https://github.com/fmtlib/fmt/pull/299). Thanks @niosHD.
+-   Documentation fixes
+    (https://github.com/fmtlib/fmt/issues/252).
+
+# 2.1.0 - 2016-03-21
+
+-   Project layout and build system improvements
+    (https://github.com/fmtlib/fmt/pull/267):
+
+    -   The code have been moved to the `cppformat` directory. Including
+        `format.h` from the top-level directory is deprecated but works
+        via a proxy header which will be removed in the next major
+        version.
+    -   C++ Format CMake targets now have proper interface definitions.
+    -   Installed version of the library now supports the header-only
+        configuration.
+    -   Targets `doc`, `install`, and `test` are now disabled if C++
+        Format is included as a CMake subproject. They can be enabled by
+        setting `FMT_DOC`, `FMT_INSTALL`, and `FMT_TEST` in the parent
+        project.
+
+    Thanks @niosHD.
+
+# 2.0.1 - 2016-03-13
+
+-   Improved CMake find and package support
+    (https://github.com/fmtlib/fmt/issues/264). Thanks @niosHD.
+-   Fix compile error with Android NDK and mingw32
+    (https://github.com/fmtlib/fmt/issues/241). Thanks @Gachapen.
+-   Documentation fixes
+    (https://github.com/fmtlib/fmt/issues/248,
+    https://github.com/fmtlib/fmt/issues/260).
+
+# 2.0.0 - 2015-12-01
+
+## General
+
+-   \[Breaking\] Named arguments
+    (https://github.com/fmtlib/fmt/pull/169,
+    https://github.com/fmtlib/fmt/pull/173,
+    https://github.com/fmtlib/fmt/pull/174):
+
+    ```c++
+    fmt::print("The answer is {answer}.", fmt::arg("answer", 42));
+    ```
+
+    Thanks @jamboree.
+
+-   \[Experimental\] User-defined literals for format and named
+    arguments (https://github.com/fmtlib/fmt/pull/204,
+    https://github.com/fmtlib/fmt/pull/206,
+    https://github.com/fmtlib/fmt/pull/207):
+
+    ```c++
+    using namespace fmt::literals;
+    fmt::print("The answer is {answer}.", "answer"_a=42);
+    ```
+
+    Thanks @dean0x7d.
+
+-   \[Breaking\] Formatting of more than 16 arguments is now supported
+    when using variadic templates
+    (https://github.com/fmtlib/fmt/issues/141). Thanks @Shauren.
+
+-   Runtime width specification
+    (https://github.com/fmtlib/fmt/pull/168):
+
+    ```c++
+    fmt::format("{0:{1}}", 42, 5); // gives "   42"
+    ```
+
+    Thanks @jamboree.
+
+-   \[Breaking\] Enums are now formatted with an overloaded
+    `std::ostream` insertion operator (`operator<<`) if available
+    (https://github.com/fmtlib/fmt/issues/232).
+
+-   \[Breaking\] Changed default `bool` format to textual, \"true\" or
+    \"false\" (https://github.com/fmtlib/fmt/issues/170):
+
+    ```c++
+    fmt::print("{}", true); // prints "true"
+    ```
+
+    To print `bool` as a number use numeric format specifier such as
+    `d`:
+
+    ```c++
+    fmt::print("{:d}", true); // prints "1"
+    ```
+
+-   `fmt::printf` and `fmt::sprintf` now support formatting of `bool`
+    with the `%s` specifier giving textual output, \"true\" or \"false\"
+    (https://github.com/fmtlib/fmt/pull/223):
+
+    ```c++
+    fmt::printf("%s", true); // prints "true"
+    ```
+
+    Thanks @LarsGullik.
+
+-   \[Breaking\] `signed char` and `unsigned char` are now formatted as
+    integers by default
+    (https://github.com/fmtlib/fmt/pull/217).
+
+-   \[Breaking\] Pointers to C strings can now be formatted with the `p`
+    specifier (https://github.com/fmtlib/fmt/pull/223):
+
+    ```c++
+    fmt::print("{:p}", "test"); // prints pointer value
+    ```
+
+    Thanks @LarsGullik.
+
+-   \[Breaking\] `fmt::printf` and `fmt::sprintf` now print null
+    pointers as `(nil)` and null strings as `(null)` for consistency
+    with glibc (https://github.com/fmtlib/fmt/pull/226).
+    Thanks @LarsGullik.
+
+-   \[Breaking\] `fmt::(s)printf` now supports formatting of objects of
+    user-defined types that provide an overloaded `std::ostream`
+    insertion operator (`operator<<`)
+    (https://github.com/fmtlib/fmt/issues/201):
+
+    ```c++
+    fmt::printf("The date is %s", Date(2012, 12, 9));
+    ```
+
+-   \[Breaking\] The `Buffer` template is now part of the public API and
+    can be used to implement custom memory buffers
+    (https://github.com/fmtlib/fmt/issues/140). Thanks @polyvertex.
+
+-   \[Breaking\] Improved compatibility between `BasicStringRef` and
+    [std::experimental::basic_string_view](
+    http://en.cppreference.com/w/cpp/experimental/basic_string_view)
+    (https://github.com/fmtlib/fmt/issues/100,
+    https://github.com/fmtlib/fmt/issues/159,
+    https://github.com/fmtlib/fmt/issues/183):
+
+    -   Comparison operators now compare string content, not pointers
+    -   `BasicStringRef::c_str` replaced by `BasicStringRef::data`
+    -   `BasicStringRef` is no longer assumed to be null-terminated
+
+    References to null-terminated strings are now represented by a new
+    class, `BasicCStringRef`.
+
+-   Dependency on pthreads introduced by Google Test is now optional
+    (https://github.com/fmtlib/fmt/issues/185).
+
+-   New CMake options `FMT_DOC`, `FMT_INSTALL` and `FMT_TEST` to control
+    generation of `doc`, `install` and `test` targets respectively, on
+    by default (https://github.com/fmtlib/fmt/issues/197,
+    https://github.com/fmtlib/fmt/issues/198,
+    https://github.com/fmtlib/fmt/issues/200). Thanks @maddinat0r.
+
+-   `noexcept` is now used when compiling with MSVC2015
+    (https://github.com/fmtlib/fmt/pull/215). Thanks @dmkrepo.
+
+-   Added an option to disable use of `windows.h` when
+    `FMT_USE_WINDOWS_H` is defined as 0 before including `format.h`
+    (https://github.com/fmtlib/fmt/issues/171). Thanks @alfps.
+
+-   \[Breaking\] `windows.h` is now included with `NOMINMAX` unless
+    `FMT_WIN_MINMAX` is defined. This is done to prevent breaking code
+    using `std::min` and `std::max` and only affects the header-only
+    configuration (https://github.com/fmtlib/fmt/issues/152,
+    https://github.com/fmtlib/fmt/pull/153,
+    https://github.com/fmtlib/fmt/pull/154). Thanks @DevO2012.
+
+-   Improved support for custom character types
+    (https://github.com/fmtlib/fmt/issues/171). Thanks @alfps.
+
+-   Added an option to disable use of IOStreams when `FMT_USE_IOSTREAMS`
+    is defined as 0 before including `format.h`
+    (https://github.com/fmtlib/fmt/issues/205,
+    https://github.com/fmtlib/fmt/pull/208). Thanks @JodiTheTigger.
+
+-   Improved detection of `isnan`, `isinf` and `signbit`.
+
+## Optimization
+
+-   Made formatting of user-defined types more efficient with a custom
+    stream buffer (https://github.com/fmtlib/fmt/issues/92,
+    https://github.com/fmtlib/fmt/pull/230). Thanks @NotImplemented.
+-   Further improved performance of `fmt::Writer` on integer formatting
+    and fixed a minor regression. Now it is \~7% faster than
+    `karma::generate` on Karma\'s benchmark
+    (https://github.com/fmtlib/fmt/issues/186).
+-   \[Breaking\] Reduced [compiled code
+    size](https://github.com/fmtlib/fmt#compile-time-and-code-bloat)
+    (https://github.com/fmtlib/fmt/issues/143,
+    https://github.com/fmtlib/fmt/pull/149).
+
+## Distribution
+
+-   \[Breaking\] Headers are now installed in
+    `${CMAKE_INSTALL_PREFIX}/include/cppformat`
+    (https://github.com/fmtlib/fmt/issues/178). Thanks @jackyf.
+
+-   \[Breaking\] Changed the library name from `format` to `cppformat`
+    for consistency with the project name and to avoid potential
+    conflicts (https://github.com/fmtlib/fmt/issues/178).
+    Thanks @jackyf.
+
+-   C++ Format is now available in [Debian](https://www.debian.org/)
+    GNU/Linux
+    ([stretch](https://packages.debian.org/source/stretch/cppformat),
+    [sid](https://packages.debian.org/source/sid/cppformat)) and derived
+    distributions such as
+    [Ubuntu](https://launchpad.net/ubuntu/+source/cppformat) 15.10 and
+    later (https://github.com/fmtlib/fmt/issues/155):
+
+        $ sudo apt-get install libcppformat1-dev
+
+    Thanks @jackyf.
+
+-   [Packages for Fedora and
+    RHEL](https://admin.fedoraproject.org/pkgdb/package/cppformat/) are
+    now available. Thanks Dave Johansen.
+
+-   C++ Format can now be installed via [Homebrew](http://brew.sh/) on
+    OS X (https://github.com/fmtlib/fmt/issues/157):
+
+        $ brew install cppformat
+
+    Thanks @ortho and Anatoliy Bulukin.
+
+## Documentation
+
+-   Migrated from ReadTheDocs to GitHub Pages for better responsiveness
+    and reliability (https://github.com/fmtlib/fmt/issues/128).
+    New documentation address is <http://cppformat.github.io/>.
+-   Added [Building thedocumentation](
+    https://fmt.dev/2.0.0/usage.html#building-the-documentation)
+    section to the documentation.
+-   Documentation build script is now compatible with Python 3 and newer
+    pip versions. (https://github.com/fmtlib/fmt/pull/189,
+    https://github.com/fmtlib/fmt/issues/209).
+    Thanks @JodiTheTigger and @xentec.
+-   Documentation fixes and improvements
+    (https://github.com/fmtlib/fmt/issues/36,
+    https://github.com/fmtlib/fmt/issues/75,
+    https://github.com/fmtlib/fmt/issues/125,
+    https://github.com/fmtlib/fmt/pull/160,
+    https://github.com/fmtlib/fmt/pull/161,
+    https://github.com/fmtlib/fmt/issues/162,
+    https://github.com/fmtlib/fmt/issues/165,
+    https://github.com/fmtlib/fmt/issues/210). 
+    Thanks @syohex.
+-   Fixed out-of-tree documentation build
+    (https://github.com/fmtlib/fmt/issues/177). Thanks @jackyf.
+
+## Fixes
+
+-   Fixed `initializer_list` detection
+    (https://github.com/fmtlib/fmt/issues/136). Thanks @Gachapen.
+
+-   \[Breaking\] Fixed formatting of enums with numeric format
+    specifiers in `fmt::(s)printf`
+    (https://github.com/fmtlib/fmt/issues/131,
+    https://github.com/fmtlib/fmt/issues/139):
+
+    ```c++
+    enum { ANSWER = 42 };
+    fmt::printf("%d", ANSWER);
+    ```
+
+    Thanks @Naios.
+
+-   Improved compatibility with old versions of MinGW
+    (https://github.com/fmtlib/fmt/issues/129,
+    https://github.com/fmtlib/fmt/pull/130,
+    https://github.com/fmtlib/fmt/issues/132). Thanks @cstamford.
+
+-   Fixed a compile error on MSVC with disabled exceptions
+    (https://github.com/fmtlib/fmt/issues/144).
+
+-   Added a workaround for broken implementation of variadic templates
+    in MSVC2012 (https://github.com/fmtlib/fmt/issues/148).
+
+-   Placed the anonymous namespace within `fmt` namespace for the
+    header-only configuration (https://github.com/fmtlib/fmt/issues/171).
+    Thanks @alfps.
+
+-   Fixed issues reported by Coverity Scan
+    (https://github.com/fmtlib/fmt/issues/187,
+    https://github.com/fmtlib/fmt/issues/192).
+
+-   Implemented a workaround for a name lookup bug in MSVC2010
+    (https://github.com/fmtlib/fmt/issues/188).
+
+-   Fixed compiler warnings
+    (https://github.com/fmtlib/fmt/issues/95,
+    https://github.com/fmtlib/fmt/issues/96,
+    https://github.com/fmtlib/fmt/pull/114,
+    https://github.com/fmtlib/fmt/issues/135,
+    https://github.com/fmtlib/fmt/issues/142,
+    https://github.com/fmtlib/fmt/issues/145,
+    https://github.com/fmtlib/fmt/issues/146,
+    https://github.com/fmtlib/fmt/issues/158,
+    https://github.com/fmtlib/fmt/issues/163,
+    https://github.com/fmtlib/fmt/issues/175,
+    https://github.com/fmtlib/fmt/issues/190,
+    https://github.com/fmtlib/fmt/pull/191,
+    https://github.com/fmtlib/fmt/issues/194,
+    https://github.com/fmtlib/fmt/pull/196,
+    https://github.com/fmtlib/fmt/issues/216,
+    https://github.com/fmtlib/fmt/pull/218,
+    https://github.com/fmtlib/fmt/pull/220,
+    https://github.com/fmtlib/fmt/pull/229,
+    https://github.com/fmtlib/fmt/issues/233,
+    https://github.com/fmtlib/fmt/issues/234,
+    https://github.com/fmtlib/fmt/pull/236,
+    https://github.com/fmtlib/fmt/issues/281,
+    https://github.com/fmtlib/fmt/issues/289).
+    Thanks @seanmiddleditch, @dixlorenz, @CarterLi, @Naios, @fmatthew5876,
+    @LevskiWeng, @rpopescu, @gabime, @cubicool, @jkflying, @LogicalKnight,
+    @inguin and @Jopie64.
+
+-   Fixed portability issues (mostly causing test failures) on ARM,
+    ppc64, ppc64le, s390x and SunOS 5.11 i386
+    (https://github.com/fmtlib/fmt/issues/138,
+    https://github.com/fmtlib/fmt/issues/179,
+    https://github.com/fmtlib/fmt/issues/180,
+    https://github.com/fmtlib/fmt/issues/202,
+    https://github.com/fmtlib/fmt/issues/225, [Red Hat Bugzilla
+    Bug 1260297](https://bugzilla.redhat.com/show_bug.cgi?id=1260297)).
+    Thanks @Naios, @jackyf and Dave Johansen.
+
+-   Fixed a name conflict with macro `free` defined in `crtdbg.h` when
+    `_CRTDBG_MAP_ALLOC` is set (https://github.com/fmtlib/fmt/issues/211).
+
+-   Fixed shared library build on OS X
+    (https://github.com/fmtlib/fmt/pull/212). Thanks @dean0x7d.
+
+-   Fixed an overload conflict on MSVC when `/Zc:wchar_t-` option is
+    specified (https://github.com/fmtlib/fmt/pull/214).
+    Thanks @slavanap.
+
+-   Improved compatibility with MSVC 2008
+    (https://github.com/fmtlib/fmt/pull/236). Thanks @Jopie64.
+
+-   Improved compatibility with bcc32
+    (https://github.com/fmtlib/fmt/issues/227).
+
+-   Fixed `static_assert` detection on Clang
+    (https://github.com/fmtlib/fmt/pull/228). Thanks @dean0x7d.
+
+# 1.1.0 - 2015-03-06
+
+-   Added `BasicArrayWriter`, a class template that provides operations
+    for formatting and writing data into a fixed-size array
+    (https://github.com/fmtlib/fmt/issues/105 and
+    https://github.com/fmtlib/fmt/issues/122):
+
+    ```c++
+    char buffer[100];
+    fmt::ArrayWriter w(buffer);
+    w.write("The answer is {}", 42);
+    ```
+
+-   Added [0 A.D.](http://play0ad.com/) and [PenUltima Online
+    (POL)](http://www.polserver.com/) to the list of notable projects
+    using C++ Format.
+
+-   C++ Format now uses MSVC intrinsics for better formatting performance
+    (https://github.com/fmtlib/fmt/pull/115,
+    https://github.com/fmtlib/fmt/pull/116,
+    https://github.com/fmtlib/fmt/pull/118 and
+    https://github.com/fmtlib/fmt/pull/121). Previously these
+    optimizations where only used on GCC and Clang.
+    Thanks @CarterLi and @objectx.
+
+-   CMake install target
+    (https://github.com/fmtlib/fmt/pull/119). Thanks @TrentHouliston.
+
+    You can now install C++ Format with `make install` command.
+
+-   Improved [Biicode](http://www.biicode.com/) support
+    (https://github.com/fmtlib/fmt/pull/98 and
+    https://github.com/fmtlib/fmt/pull/104).
+    Thanks @MariadeAnton and @franramirez688.
+
+-   Improved support for building with [Android NDK](
+    https://developer.android.com/tools/sdk/ndk/index.html)
+    (https://github.com/fmtlib/fmt/pull/107). Thanks @newnon.
+
+    The [android-ndk-example](https://github.com/fmtlib/android-ndk-example)
+    repository provides and example of using C++ Format with Android NDK:
+
+    ![](https://raw.githubusercontent.com/fmtlib/android-ndk-example/master/screenshot.png)
+
+-   Improved documentation of `SystemError` and `WindowsError`
+    (https://github.com/fmtlib/fmt/issues/54).
+
+-   Various code improvements
+    (https://github.com/fmtlib/fmt/pull/110,
+    https://github.com/fmtlib/fmt/pull/111
+    https://github.com/fmtlib/fmt/pull/112). Thanks @CarterLi.
+
+-   Improved compile-time errors when formatting wide into narrow
+    strings (https://github.com/fmtlib/fmt/issues/117).
+
+-   Fixed `BasicWriter::write` without formatting arguments when C++11
+    support is disabled
+    (https://github.com/fmtlib/fmt/issues/109).
+
+-   Fixed header-only build on OS X with GCC 4.9
+    (https://github.com/fmtlib/fmt/issues/124).
+
+-   Fixed packaging issues (https://github.com/fmtlib/fmt/issues/94).
+
+-   Added [changelog](https://github.com/fmtlib/fmt/blob/master/ChangeLog.md)
+    (https://github.com/fmtlib/fmt/issues/103).
+
+# 1.0.0 - 2015-02-05
+
+-   Add support for a header-only configuration when `FMT_HEADER_ONLY`
+    is defined before including `format.h`:
+
+    ```c++
+    #define FMT_HEADER_ONLY
+    #include "format.h"
+    ```
+
+-   Compute string length in the constructor of `BasicStringRef` instead
+    of the `size` method
+    (https://github.com/fmtlib/fmt/issues/79). This eliminates
+    size computation for string literals on reasonable optimizing
+    compilers.
+
+-   Fix formatting of types with overloaded `operator <<` for
+    `std::wostream` (https://github.com/fmtlib/fmt/issues/86):
+
+    ```c++
+    fmt::format(L"The date is {0}", Date(2012, 12, 9));
+    ```
+
+-   Fix linkage of tests on Arch Linux
+    (https://github.com/fmtlib/fmt/issues/89).
+
+-   Allow precision specifier for non-float arguments
+    (https://github.com/fmtlib/fmt/issues/90):
+
+    ```c++
+    fmt::print("{:.3}\n", "Carpet"); // prints "Car"
+    ```
+
+-   Fix build on Android NDK (https://github.com/fmtlib/fmt/issues/93).
+
+-   Improvements to documentation build procedure.
+
+-   Remove `FMT_SHARED` CMake variable in favor of standard [BUILD_SHARED_LIBS](
+    http://www.cmake.org/cmake/help/v3.0/variable/BUILD_SHARED_LIBS.html).
+
+-   Fix error handling in `fmt::fprintf`.
+
+-   Fix a number of warnings.
+
+# 0.12.0 - 2014-10-25
+
+-   \[Breaking\] Improved separation between formatting and buffer
+    management. `Writer` is now a base class that cannot be instantiated
+    directly. The new `MemoryWriter` class implements the default buffer
+    management with small allocations done on stack. So `fmt::Writer`
+    should be replaced with `fmt::MemoryWriter` in variable
+    declarations.
+
+    Old code:
+
+    ```c++
+    fmt::Writer w;
+    ```
+
+    New code:
+
+    ```c++
+    fmt::MemoryWriter w;
+    ```
+
+    If you pass `fmt::Writer` by reference, you can continue to do so:
+
+    ```c++
+    void f(fmt::Writer &w);
+    ```
+
+    This doesn\'t affect the formatting API.
+
+-   Support for custom memory allocators
+    (https://github.com/fmtlib/fmt/issues/69)
+
+-   Formatting functions now accept [signed char]{.title-ref} and
+    [unsigned char]{.title-ref} strings as arguments
+    (https://github.com/fmtlib/fmt/issues/73):
+
+    ```c++
+    auto s = format("GLSL version: {}", glGetString(GL_VERSION));
+    ```
+
+-   Reduced code bloat. According to the new [benchmark
+    results](https://github.com/fmtlib/fmt#compile-time-and-code-bloat),
+    cppformat is close to `printf` and by the order of magnitude better
+    than Boost Format in terms of compiled code size.
+
+-   Improved appearance of the documentation on mobile by using the
+    [Sphinx Bootstrap
+    theme](http://ryan-roemer.github.io/sphinx-bootstrap-theme/):
+
+    | Old | New |
+    | --- | --- |
+    | ![](https://cloud.githubusercontent.com/assets/576385/4792130/cd256436-5de3-11e4-9a62-c077d0c2b003.png) | ![](https://cloud.githubusercontent.com/assets/576385/4792131/cd29896c-5de3-11e4-8f59-cac952942bf0.png) |
+
+# 0.11.0 - 2014-08-21
+
+-   Safe printf implementation with a POSIX extension for positional
+    arguments:
+
+    ```c++
+    fmt::printf("Elapsed time: %.2f seconds", 1.23);
+    fmt::printf("%1$s, %3$d %2$s", weekday, month, day);
+    ```
+
+-   Arguments of `char` type can now be formatted as integers (Issue
+    https://github.com/fmtlib/fmt/issues/55):
+
+    ```c++
+    fmt::format("0x{0:02X}", 'a');
+    ```
+
+-   Deprecated parts of the API removed.
+
+-   The library is now built and tested on MinGW with Appveyor in
+    addition to existing test platforms Linux/GCC, OS X/Clang,
+    Windows/MSVC.
+
+# 0.10.0 - 2014-07-01
+
+**Improved API**
+
+-   All formatting methods are now implemented as variadic functions
+    instead of using `operator<<` for feeding arbitrary arguments into a
+    temporary formatter object. This works both with C++11 where
+    variadic templates are used and with older standards where variadic
+    functions are emulated by providing lightweight wrapper functions
+    defined with the `FMT_VARIADIC` macro. You can use this macro for
+    defining your own portable variadic functions:
+
+    ```c++
+    void report_error(const char *format, const fmt::ArgList &args) {
+      fmt::print("Error: {}");
+      fmt::print(format, args);
+    }
+    FMT_VARIADIC(void, report_error, const char *)
+
+    report_error("file not found: {}", path);
+    ```
+
+    Apart from a more natural syntax, this also improves performance as
+    there is no need to construct temporary formatter objects and
+    control arguments\' lifetimes. Because the wrapper functions are
+    very lightweight, this doesn\'t cause code bloat even in pre-C++11
+    mode.
+
+-   Simplified common case of formatting an `std::string`. Now it
+    requires a single function call:
+
+    ```c++
+    std::string s = format("The answer is {}.", 42);
+    ```
+
+    Previously it required 2 function calls:
+
+    ```c++
+    std::string s = str(Format("The answer is {}.") << 42);
+    ```
+
+    Instead of unsafe `c_str` function, `fmt::Writer` should be used
+    directly to bypass creation of `std::string`:
+
+    ```c++
+    fmt::Writer w;
+    w.write("The answer is {}.", 42);
+    w.c_str();  // returns a C string
+    ```
+
+    This doesn\'t do dynamic memory allocation for small strings and is
+    less error prone as the lifetime of the string is the same as for
+    `std::string::c_str` which is well understood (hopefully).
+
+-   Improved consistency in naming functions that are a part of the
+    public API. Now all public functions are lowercase following the
+    standard library conventions. Previously it was a combination of
+    lowercase and CapitalizedWords. Issue
+    https://github.com/fmtlib/fmt/issues/50.
+
+-   Old functions are marked as deprecated and will be removed in the
+    next release.
+
+**Other Changes**
+
+-   Experimental support for printf format specifications (work in
+    progress):
+
+    ```c++
+    fmt::printf("The answer is %d.", 42);
+    std::string s = fmt::sprintf("Look, a %s!", "string");
+    ```
+
+-   Support for hexadecimal floating point format specifiers `a` and
+    `A`:
+
+    ```c++
+    print("{:a}", -42.0); // Prints -0x1.5p+5
+    print("{:A}", -42.0); // Prints -0X1.5P+5
+    ```
+
+-   CMake option `FMT_SHARED` that specifies whether to build format as
+    a shared library (off by default).
+
+# 0.9.0 - 2014-05-13
+
+-   More efficient implementation of variadic formatting functions.
+
+-   `Writer::Format` now has a variadic overload:
+
+    ```c++
+    Writer out;
+    out.Format("Look, I'm {}!", "variadic");
+    ```
+
+-   For efficiency and consistency with other overloads, variadic
+    overload of the `Format` function now returns `Writer` instead of
+    `std::string`. Use the `str` function to convert it to
+    `std::string`:
+
+    ```c++
+    std::string s = str(Format("Look, I'm {}!", "variadic"));
+    ```
+
+-   Replaced formatter actions with output sinks: `NoAction` -\>
+    `NullSink`, `Write` -\> `FileSink`, `ColorWriter` -\>
+    `ANSITerminalSink`. This improves naming consistency and shouldn\'t
+    affect client code unless these classes are used directly which
+    should be rarely needed.
+
+-   Added `ThrowSystemError` function that formats a message and throws
+    `SystemError` containing the formatted message and system-specific
+    error description. For example, the following code
+
+    ```c++
+    FILE *f = fopen(filename, "r");
+    if (!f)
+      ThrowSystemError(errno, "Failed to open file '{}'") << filename;
+    ```
+
+    will throw `SystemError` exception with description \"Failed to open
+    file \'\<filename\>\': No such file or directory\" if file doesn\'t
+    exist.
+
+-   Support for AppVeyor continuous integration platform.
+
+-   `Format` now throws `SystemError` in case of I/O errors.
+
+-   Improve test infrastructure. Print functions are now tested by
+    redirecting the output to a pipe.
+
+# 0.8.0 - 2014-04-14
+
+-   Initial release
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/LICENSE b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..1cd1ef92696b65b2ecb0e560e622f0a0e869dcf3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+--- Optional exception to the license ---
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into a machine-executable object form of such
+source code, you may redistribute such embedded portions in such object form
+without including the above copyright and permission notices.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/README.md b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..dcfb16ec22086251c57dfa7ac91eab08844da05f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/README.md
@@ -0,0 +1,490 @@
+<img src="https://user-images.githubusercontent.com/576385/156254208-f5b743a9-88cf-439d-b0c0-923d53e8d551.png" alt="{fmt}" width="25%"/>
+
+[![image](https://github.com/fmtlib/fmt/workflows/linux/badge.svg)](https://github.com/fmtlib/fmt/actions?query=workflow%3Alinux)
+[![image](https://github.com/fmtlib/fmt/workflows/macos/badge.svg)](https://github.com/fmtlib/fmt/actions?query=workflow%3Amacos)
+[![image](https://github.com/fmtlib/fmt/workflows/windows/badge.svg)](https://github.com/fmtlib/fmt/actions?query=workflow%3Awindows)
+[![fmt is continuously fuzzed at oss-fuzz](https://oss-fuzz-build-logs.storage.googleapis.com/badges/fmt.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?\%0Acolspec=ID%20Type%20Component%20Status%20Proj%20Reported%20Owner%20\%0ASummary&q=proj%3Dfmt&can=1)
+[![Ask questions at StackOverflow with the tag fmt](https://img.shields.io/badge/stackoverflow-fmt-blue.svg)](https://stackoverflow.com/questions/tagged/fmt)
+[![image](https://api.securityscorecards.dev/projects/github.com/fmtlib/fmt/badge)](https://securityscorecards.dev/viewer/?uri=github.com/fmtlib/fmt)
+
+**{fmt}** is an open-source formatting library providing a fast and safe
+alternative to C stdio and C++ iostreams.
+
+If you like this project, please consider donating to one of the funds
+that help victims of the war in Ukraine: <https://www.stopputin.net/>.
+
+[Documentation](https://fmt.dev)
+
+[Cheat Sheets](https://hackingcpp.com/cpp/libs/fmt.html)
+
+Q&A: ask questions on [StackOverflow with the tag
+fmt](https://stackoverflow.com/questions/tagged/fmt).
+
+Try {fmt} in [Compiler Explorer](https://godbolt.org/z/Eq5763).
+
+# Features
+
+- Simple [format API](https://fmt.dev/latest/api.html) with positional
+  arguments for localization
+- Implementation of [C++20
+  std::format](https://en.cppreference.com/w/cpp/utility/format) and
+  [C++23 std::print](https://en.cppreference.com/w/cpp/io/print)
+- [Format string syntax](https://fmt.dev/latest/syntax.html) similar
+  to Python\'s
+  [format](https://docs.python.org/3/library/stdtypes.html#str.format)
+- Fast IEEE 754 floating-point formatter with correct rounding,
+  shortness and round-trip guarantees using the
+  [Dragonbox](https://github.com/jk-jeon/dragonbox) algorithm
+- Portable Unicode support
+- Safe [printf
+  implementation](https://fmt.dev/latest/api.html#printf-formatting)
+  including the POSIX extension for positional arguments
+- Extensibility: [support for user-defined
+  types](https://fmt.dev/latest/api.html#formatting-user-defined-types)
+- High performance: faster than common standard library
+  implementations of `(s)printf`, iostreams, `to_string` and
+  `to_chars`, see [Speed tests](#speed-tests) and [Converting a
+  hundred million integers to strings per
+  second](http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html)
+- Small code size both in terms of source code with the minimum
+  configuration consisting of just three files, `core.h`, `format.h`
+  and `format-inl.h`, and compiled code; see [Compile time and code
+  bloat](#compile-time-and-code-bloat)
+- Reliability: the library has an extensive set of
+  [tests](https://github.com/fmtlib/fmt/tree/master/test) and is
+  [continuously fuzzed](https://bugs.chromium.org/p/oss-fuzz/issues/list?colspec=ID%20Type%20Component%20Status%20Proj%20Reported%20Owner%20Summary&q=proj%3Dfmt&can=1)
+- Safety: the library is fully type-safe, errors in format strings can
+  be reported at compile time, automatic memory management prevents
+  buffer overflow errors
+- Ease of use: small self-contained code base, no external
+  dependencies, permissive MIT
+  [license](https://github.com/fmtlib/fmt/blob/master/LICENSE.rst)
+- [Portability](https://fmt.dev/latest/index.html#portability) with
+  consistent output across platforms and support for older compilers
+- Clean warning-free codebase even on high warning levels such as
+  `-Wall -Wextra -pedantic`
+- Locale independence by default
+- Optional header-only configuration enabled with the
+  `FMT_HEADER_ONLY` macro
+
+See the [documentation](https://fmt.dev) for more details.
+
+# Examples
+
+**Print to stdout** ([run](https://godbolt.org/z/Tevcjh))
+
+``` c++
+#include <fmt/core.h>
+
+int main() {
+  fmt::print("Hello, world!\n");
+}
+```
+
+**Format a string** ([run](https://godbolt.org/z/oK8h33))
+
+``` c++
+std::string s = fmt::format("The answer is {}.", 42);
+// s == "The answer is 42."
+```
+
+**Format a string using positional arguments**
+([run](https://godbolt.org/z/Yn7Txe))
+
+``` c++
+std::string s = fmt::format("I'd rather be {1} than {0}.", "right", "happy");
+// s == "I'd rather be happy than right."
+```
+
+**Print dates and times** ([run](https://godbolt.org/z/c31ExdY3W))
+
+``` c++
+#include <fmt/chrono.h>
+
+int main() {
+  auto now = std::chrono::system_clock::now();
+  fmt::print("Date and time: {}\n", now);
+  fmt::print("Time: {:%H:%M}\n", now);
+}
+```
+
+Output:
+
+    Date and time: 2023-12-26 19:10:31.557195597
+    Time: 19:10
+
+**Print a container** ([run](https://godbolt.org/z/MxM1YqjE7))
+
+``` c++
+#include <vector>
+#include <fmt/ranges.h>
+
+int main() {
+  std::vector<int> v = {1, 2, 3};
+  fmt::print("{}\n", v);
+}
+```
+
+Output:
+
+    [1, 2, 3]
+
+**Check a format string at compile time**
+
+``` c++
+std::string s = fmt::format("{:d}", "I am not a number");
+```
+
+This gives a compile-time error in C++20 because `d` is an invalid
+format specifier for a string.
+
+**Write a file from a single thread**
+
+``` c++
+#include <fmt/os.h>
+
+int main() {
+  auto out = fmt::output_file("guide.txt");
+  out.print("Don't {}", "Panic");
+}
+```
+
+This can be [5 to 9 times faster than
+fprintf](http://www.zverovich.net/2020/08/04/optimal-file-buffer-size.html).
+
+**Print with colors and text styles**
+
+``` c++
+#include <fmt/color.h>
+
+int main() {
+  fmt::print(fg(fmt::color::crimson) | fmt::emphasis::bold,
+             "Hello, {}!\n", "world");
+  fmt::print(fg(fmt::color::floral_white) | bg(fmt::color::slate_gray) |
+             fmt::emphasis::underline, "Olá, {}!\n", "Mundo");
+  fmt::print(fg(fmt::color::steel_blue) | fmt::emphasis::italic,
+             "你好{}！\n", "世界");
+}
+```
+
+Output on a modern terminal with Unicode support:
+
+![image](https://github.com/fmtlib/fmt/assets/%0A576385/2a93c904-d6fa-4aa6-b453-2618e1c327d7)
+
+# Benchmarks
+
+## Speed tests
+
+| Library           | Method        | Run Time, s |
+|-------------------|---------------|-------------|
+| libc              | printf        |   0.91      |
+| libc++            | std::ostream  |   2.49      |
+| {fmt} 9.1         | fmt::print    |   0.74      |
+| Boost Format 1.80 | boost::format |   6.26      |
+| Folly Format      | folly::format |   1.87      |
+
+{fmt} is the fastest of the benchmarked methods, \~20% faster than
+`printf`.
+
+The above results were generated by building `tinyformat_test.cpp` on
+macOS 12.6.1 with `clang++ -O3 -DNDEBUG -DSPEED_TEST -DHAVE_FORMAT`, and
+taking the best of three runs. In the test, the format string
+`"%0.10f:%04d:%+g:%s:%p:%c:%%\n"` or equivalent is filled 2,000,000
+times with output sent to `/dev/null`; for further details refer to the
+[source](https://github.com/fmtlib/format-benchmark/blob/master/src/tinyformat-test.cc).
+
+{fmt} is up to 20-30x faster than `std::ostringstream` and `sprintf` on
+IEEE754 `float` and `double` formatting
+([dtoa-benchmark](https://github.com/fmtlib/dtoa-benchmark)) and faster
+than [double-conversion](https://github.com/google/double-conversion)
+and [ryu](https://github.com/ulfjack/ryu):
+
+[![image](https://user-images.githubusercontent.com/576385/95684665-11719600-0ba8-11eb-8e5b-972ff4e49428.png)](https://fmt.dev/unknown_mac64_clang12.0.html)
+
+## Compile time and code bloat
+
+The script
+[bloat-test.py](https://github.com/fmtlib/format-benchmark/blob/master/bloat-test.py)
+from [format-benchmark](https://github.com/fmtlib/format-benchmark)
+tests compile time and code bloat for nontrivial projects. It generates
+100 translation units and uses `printf()` or its alternative five times
+in each to simulate a medium-sized project. The resulting executable
+size and compile time (Apple LLVM version 8.1.0 (clang-802.0.42), macOS
+Sierra, best of three) is shown in the following tables.
+
+**Optimized build (-O3)**
+
+| Method        | Compile Time, s | Executable size, KiB | Stripped size, KiB |
+|---------------|-----------------|----------------------|--------------------|
+| printf        |   2.6           |   29                 |   26               |
+| printf+string |   16.4          |   29                 |   26               |
+| iostreams     |   31.1          |   59                 |   55               |
+| {fmt}         |   19.0          |   37                 |   34               |
+| Boost Format  |   91.9          |   226                |   203              |
+| Folly Format  |   115.7         |   101                |   88               |
+
+As you can see, {fmt} has 60% less overhead in terms of resulting binary
+code size compared to iostreams and comes pretty close to `printf`.
+Boost Format and Folly Format have the largest overheads.
+
+`printf+string` is the same as `printf` but with an extra `<string>`
+include to measure the overhead of the latter.
+
+**Non-optimized build**
+
+| Method        | Compile Time, s | Executable size, KiB | Stripped size, KiB |
+|---------------|-----------------|----------------------|--------------------|
+| printf        |   2.2           |   33                 |   30               |
+| printf+string |   16.0          |   33                 |   30               |
+| iostreams     |   28.3          |   56                 |   52               |
+| {fmt}         |   18.2          |   59                 |   50               |
+| Boost Format  |   54.1          |   365                |   303              |
+| Folly Format  |   79.9          |   445                |   430              |
+
+`libc`, `lib(std)c++`, and `libfmt` are all linked as shared libraries
+to compare formatting function overhead only. Boost Format is a
+header-only library so it doesn\'t provide any linkage options.
+
+## Running the tests
+
+Please refer to [Building the
+library](https://fmt.dev/latest/usage.html#building-the-library) for
+instructions on how to build the library and run the unit tests.
+
+Benchmarks reside in a separate repository,
+[format-benchmarks](https://github.com/fmtlib/format-benchmark), so to
+run the benchmarks you first need to clone this repository and generate
+Makefiles with CMake:
+
+    $ git clone --recursive https://github.com/fmtlib/format-benchmark.git
+    $ cd format-benchmark
+    $ cmake .
+
+Then you can run the speed test:
+
+    $ make speed-test
+
+or the bloat test:
+
+    $ make bloat-test
+
+# Migrating code
+
+[clang-tidy](https://clang.llvm.org/extra/clang-tidy/) v17 (not yet
+released) provides the
+[modernize-use-std-print](https://clang.llvm.org/extra/clang-tidy/checks/modernize/use-std-print.html)
+check that is capable of converting occurrences of `printf` and
+`fprintf` to `fmt::print` if configured to do so. (By default it
+converts to `std::print`.)
+
+# Notable projects using this library
+
+- [0 A.D.](https://play0ad.com/): a free, open-source, cross-platform
+  real-time strategy game
+- [AMPL/MP](https://github.com/ampl/mp): an open-source library for
+  mathematical programming
+- [Apple's FoundationDB](https://github.com/apple/foundationdb): an open-source,
+  distributed, transactional key-value store
+- [Aseprite](https://github.com/aseprite/aseprite): animated sprite
+  editor & pixel art tool
+- [AvioBook](https://www.aviobook.aero/en): a comprehensive aircraft
+  operations suite
+- [Blizzard Battle.net](https://battle.net/): an online gaming
+  platform
+- [Celestia](https://celestia.space/): real-time 3D visualization of
+  space
+- [Ceph](https://ceph.com/): a scalable distributed storage system
+- [ccache](https://ccache.dev/): a compiler cache
+- [ClickHouse](https://github.com/ClickHouse/ClickHouse): an
+  analytical database management system
+- [Contour](https://github.com/contour-terminal/contour/): a modern
+  terminal emulator
+- [CUAUV](https://cuauv.org/): Cornell University\'s autonomous
+  underwater vehicle
+- [Drake](https://drake.mit.edu/): a planning, control, and analysis
+  toolbox for nonlinear dynamical systems (MIT)
+- [Envoy](https://lyft.github.io/envoy/): C++ L7 proxy and
+  communication bus (Lyft)
+- [FiveM](https://fivem.net/): a modification framework for GTA V
+- [fmtlog](https://github.com/MengRao/fmtlog): a performant
+  fmtlib-style logging library with latency in nanoseconds
+- [Folly](https://github.com/facebook/folly): Facebook open-source
+  library
+- [GemRB](https://gemrb.org/): a portable open-source implementation
+  of Bioware's Infinity Engine
+- [Grand Mountain
+  Adventure](https://store.steampowered.com/app/1247360/Grand_Mountain_Adventure/):
+  a beautiful open-world ski & snowboarding game
+- [HarpyWar/pvpgn](https://github.com/pvpgn/pvpgn-server): Player vs
+  Player Gaming Network with tweaks
+- [KBEngine](https://github.com/kbengine/kbengine): an open-source
+  MMOG server engine
+- [Keypirinha](https://keypirinha.com/): a semantic launcher for
+  Windows
+- [Kodi](https://kodi.tv/) (formerly xbmc): home theater software
+- [Knuth](https://kth.cash/): high-performance Bitcoin full-node
+- [libunicode](https://github.com/contour-terminal/libunicode/): a
+  modern C++17 Unicode library
+- [MariaDB](https://mariadb.org/): relational database management
+  system
+- [Microsoft Verona](https://github.com/microsoft/verona): research
+  programming language for concurrent ownership
+- [MongoDB](https://mongodb.com/): distributed document database
+- [MongoDB Smasher](https://github.com/duckie/mongo_smasher): a small
+  tool to generate randomized datasets
+- [OpenSpace](https://openspaceproject.com/): an open-source
+  astrovisualization framework
+- [PenUltima Online (POL)](https://www.polserver.com/): an MMO server,
+  compatible with most Ultima Online clients
+- [PyTorch](https://github.com/pytorch/pytorch): an open-source
+  machine learning library
+- [quasardb](https://www.quasardb.net/): a distributed,
+  high-performance, associative database
+- [Quill](https://github.com/odygrd/quill): asynchronous low-latency
+  logging library
+- [QKW](https://github.com/ravijanjam/qkw): generalizing aliasing to
+  simplify navigation, and executing complex multi-line terminal
+  command sequences
+- [redis-cerberus](https://github.com/HunanTV/redis-cerberus): a Redis
+  cluster proxy
+- [redpanda](https://vectorized.io/redpanda): a 10x faster Kafka®
+  replacement for mission-critical systems written in C++
+- [rpclib](http://rpclib.net/): a modern C++ msgpack-RPC server and
+  client library
+- [Salesforce Analytics
+  Cloud](https://www.salesforce.com/analytics-cloud/overview/):
+  business intelligence software
+- [Scylla](https://www.scylladb.com/): a Cassandra-compatible NoSQL
+  data store that can handle 1 million transactions per second on a
+  single server
+- [Seastar](http://www.seastar-project.org/): an advanced, open-source
+  C++ framework for high-performance server applications on modern
+  hardware
+- [spdlog](https://github.com/gabime/spdlog): super fast C++ logging
+  library
+- [Stellar](https://www.stellar.org/): financial platform
+- [Touch Surgery](https://www.touchsurgery.com/): surgery simulator
+- [TrinityCore](https://github.com/TrinityCore/TrinityCore):
+  open-source MMORPG framework
+- [🐙 userver framework](https://userver.tech/): open-source
+  asynchronous framework with a rich set of abstractions and database
+  drivers
+- [Windows Terminal](https://github.com/microsoft/terminal): the new
+  Windows terminal
+
+[More\...](https://github.com/search?q=fmtlib&type=Code)
+
+If you are aware of other projects using this library, please let me
+know by [email](mailto:victor.zverovich@gmail.com) or by submitting an
+[issue](https://github.com/fmtlib/fmt/issues).
+
+# Motivation
+
+So why yet another formatting library?
+
+There are plenty of methods for doing this task, from standard ones like
+the printf family of function and iostreams to Boost Format and
+FastFormat libraries. The reason for creating a new library is that
+every existing solution that I found either had serious issues or
+didn\'t provide all the features I needed.
+
+## printf
+
+The good thing about `printf` is that it is pretty fast and readily
+available being a part of the C standard library. The main drawback is
+that it doesn\'t support user-defined types. `printf` also has safety
+issues although they are somewhat mitigated with [\_\_attribute\_\_
+((format (printf,
+\...))](https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html) in
+GCC. There is a POSIX extension that adds positional arguments required
+for
+[i18n](https://en.wikipedia.org/wiki/Internationalization_and_localization)
+to `printf` but it is not a part of C99 and may not be available on some
+platforms.
+
+## iostreams
+
+The main issue with iostreams is best illustrated with an example:
+
+``` c++
+std::cout << std::setprecision(2) << std::fixed << 1.23456 << "\n";
+```
+
+which is a lot of typing compared to printf:
+
+``` c++
+printf("%.2f\n", 1.23456);
+```
+
+Matthew Wilson, the author of FastFormat, called this \"chevron hell\".
+iostreams don\'t support positional arguments by design.
+
+The good part is that iostreams support user-defined types and are safe
+although error handling is awkward.
+
+## Boost Format
+
+This is a very powerful library that supports both `printf`-like format
+strings and positional arguments. Its main drawback is performance.
+According to various benchmarks, it is much slower than other methods
+considered here. Boost Format also has excessive build times and severe
+code bloat issues (see [Benchmarks](#benchmarks)).
+
+## FastFormat
+
+This is an interesting library that is fast, safe, and has positional
+arguments. However, it has significant limitations, citing its author:
+
+> Three features that have no hope of being accommodated within the
+> current design are:
+>
+> - Leading zeros (or any other non-space padding)
+> - Octal/hexadecimal encoding
+> - Runtime width/alignment specification
+
+It is also quite big and has a heavy dependency, STLSoft, which might be
+too restrictive for using it in some projects.
+
+## Boost Spirit.Karma
+
+This is not a formatting library but I decided to include it here for
+completeness. As iostreams, it suffers from the problem of mixing
+verbatim text with arguments. The library is pretty fast, but slower on
+integer formatting than `fmt::format_to` with format string compilation
+on Karma\'s own benchmark, see [Converting a hundred million integers to
+strings per
+second](http://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html).
+
+# License
+
+{fmt} is distributed under the MIT
+[license](https://github.com/fmtlib/fmt/blob/master/LICENSE).
+
+# Documentation License
+
+The [Format String Syntax](https://fmt.dev/latest/syntax.html) section
+in the documentation is based on the one from Python [string module
+documentation](https://docs.python.org/3/library/string.html#module-string).
+For this reason, the documentation is distributed under the Python
+Software Foundation license available in
+[doc/python-license.txt](https://raw.github.com/fmtlib/fmt/master/doc/python-license.txt).
+It only applies if you distribute the documentation of {fmt}.
+
+# Maintainers
+
+The {fmt} library is maintained by Victor Zverovich
+([vitaut](https://github.com/vitaut)) with contributions from many other
+people. See
+[Contributors](https://github.com/fmtlib/fmt/graphs/contributors) and
+[Releases](https://github.com/fmtlib/fmt/releases) for some of the
+names. Let us know if your contribution is not listed or mentioned
+incorrectly and we\'ll make it right.
+
+# Security Policy
+
+To report a security issue, please disclose it at [security
+advisory](https://github.com/fmtlib/fmt/security/advisories/new).
+
+This project is maintained by a team of volunteers on a
+reasonable-effort basis. As such, please give us at least 90 days to
+work on a fix before public exposure.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fd9f4d1e42848780b8a2b0c13d7c1b1814bd4656
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/CMakeLists.txt
@@ -0,0 +1,26 @@
+find_program(DOXYGEN doxygen
+  PATHS "$ENV{ProgramFiles}/doxygen/bin"
+        "$ENV{ProgramFiles\(x86\)}/doxygen/bin")
+if (NOT DOXYGEN)
+  message(STATUS "Target 'doc' disabled (requires doxygen)")
+  return ()
+endif ()
+
+# Find the Python interpreter and set the PYTHON_EXECUTABLE variable.
+if (CMAKE_VERSION VERSION_LESS 3.12)
+  # This logic is deprecated in CMake after 3.12.
+  find_package(PythonInterp QUIET REQUIRED)
+else ()
+  find_package(Python QUIET REQUIRED)
+  set(PYTHON_EXECUTABLE ${Python_EXECUTABLE})
+endif ()
+
+add_custom_target(doc
+  COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/build.py
+                               ${FMT_VERSION}
+  SOURCES api.rst syntax.rst usage.rst build.py conf.py _templates/layout.html)
+
+include(GNUInstallDirs)
+install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/
+        DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/doc/fmt OPTIONAL
+        PATTERN ".doctrees" EXCLUDE)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/bootstrap.min.js b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/bootstrap.min.js
new file mode 100644
index 0000000000000000000000000000000000000000..c35e1da131ba699bf78a3bbb2979ce9fb4688597
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/bootstrap.min.js
@@ -0,0 +1,7 @@
+/*!
+  * Bootstrap v5.3.2 (https://getbootstrap.com/)
+  * Copyright 2011-2023 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
+  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+  */
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e(require("@popperjs/core")):"function"==typeof define&&define.amd?define(["@popperjs/core"],e):(t="undefined"!=typeof globalThis?globalThis:t||self).bootstrap=e(t.Popper)}(this,(function(t){"use strict";function e(t){const e=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(t)for(const i in t)if("default"!==i){const s=Object.getOwnPropertyDescriptor(t,i);Object.defineProperty(e,i,s.get?s:{enumerable:!0,get:()=>t[i]})}return e.default=t,Object.freeze(e)}const i=e(t),s=new Map,n={set(t,e,i){s.has(t)||s.set(t,new Map);const n=s.get(t);n.has(e)||0===n.size?n.set(e,i):console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(n.keys())[0]}.`)},get:(t,e)=>s.has(t)&&s.get(t).get(e)||null,remove(t,e){if(!s.has(t))return;const i=s.get(t);i.delete(e),0===i.size&&s.delete(t)}},o="transitionend",r=t=>(t&&window.CSS&&window.CSS.escape&&(t=t.replace(/#([^\s"#']+)/g,((t,e)=>`#${CSS.escape(e)}`))),t),a=t=>{t.dispatchEvent(new Event(o))},l=t=>!(!t||"object"!=typeof t)&&(void 0!==t.jquery&&(t=t[0]),void 0!==t.nodeType),c=t=>l(t)?t.jquery?t[0]:t:"string"==typeof t&&t.length>0?document.querySelector(r(t)):null,h=t=>{if(!l(t)||0===t.getClientRects().length)return!1;const e="visible"===getComputedStyle(t).getPropertyValue("visibility"),i=t.closest("details:not([open])");if(!i)return e;if(i!==t){const e=t.closest("summary");if(e&&e.parentNode!==i)return!1;if(null===e)return!1}return e},d=t=>!t||t.nodeType!==Node.ELEMENT_NODE||!!t.classList.contains("disabled")||(void 0!==t.disabled?t.disabled:t.hasAttribute("disabled")&&"false"!==t.getAttribute("disabled")),u=t=>{if(!document.documentElement.attachShadow)return null;if("function"==typeof t.getRootNode){const e=t.getRootNode();return e instanceof ShadowRoot?e:null}return t instanceof ShadowRoot?t:t.parentNode?u(t.parentNode):null},_=()=>{},g=t=>{t.offsetHeight},f=()=>window.jQuery&&!document.body.hasAttribute("data-bs-no-jquery")?window.jQuery:null,m=[],p=()=>"rtl"===document.documentElement.dir,b=t=>{var e;e=()=>{const e=f();if(e){const i=t.NAME,s=e.fn[i];e.fn[i]=t.jQueryInterface,e.fn[i].Constructor=t,e.fn[i].noConflict=()=>(e.fn[i]=s,t.jQueryInterface)}},"loading"===document.readyState?(m.length||document.addEventListener("DOMContentLoaded",(()=>{for(const t of m)t()})),m.push(e)):e()},v=(t,e=[],i=t)=>"function"==typeof t?t(...e):i,y=(t,e,i=!0)=>{if(!i)return void v(t);const s=(t=>{if(!t)return 0;let{transitionDuration:e,transitionDelay:i}=window.getComputedStyle(t);const s=Number.parseFloat(e),n=Number.parseFloat(i);return s||n?(e=e.split(",")[0],i=i.split(",")[0],1e3*(Number.parseFloat(e)+Number.parseFloat(i))):0})(e)+5;let n=!1;const r=({target:i})=>{i===e&&(n=!0,e.removeEventListener(o,r),v(t))};e.addEventListener(o,r),setTimeout((()=>{n||a(e)}),s)},w=(t,e,i,s)=>{const n=t.length;let o=t.indexOf(e);return-1===o?!i&&s?t[n-1]:t[0]:(o+=i?1:-1,s&&(o=(o+n)%n),t[Math.max(0,Math.min(o,n-1))])},A=/[^.]*(?=\..*)\.|.*/,E=/\..*/,C=/::\d+$/,T={};let k=1;const $={mouseenter:"mouseover",mouseleave:"mouseout"},S=new Set(["click","dblclick","mouseup","mousedown","contextmenu","mousewheel","DOMMouseScroll","mouseover","mouseout","mousemove","selectstart","selectend","keydown","keypress","keyup","orientationchange","touchstart","touchmove","touchend","touchcancel","pointerdown","pointermove","pointerup","pointerleave","pointercancel","gesturestart","gesturechange","gestureend","focus","blur","change","reset","select","submit","focusin","focusout","load","unload","beforeunload","resize","move","DOMContentLoaded","readystatechange","error","abort","scroll"]);function L(t,e){return e&&`${e}::${k++}`||t.uidEvent||k++}function O(t){const e=L(t);return t.uidEvent=e,T[e]=T[e]||{},T[e]}function I(t,e,i=null){return Object.values(t).find((t=>t.callable===e&&t.delegationSelector===i))}function D(t,e,i){const s="string"==typeof e,n=s?i:e||i;let o=M(t);return S.has(o)||(o=t),[s,n,o]}function N(t,e,i,s,n){if("string"!=typeof e||!t)return;let[o,r,a]=D(e,i,s);if(e in $){const t=t=>function(e){if(!e.relatedTarget||e.relatedTarget!==e.delegateTarget&&!e.delegateTarget.contains(e.relatedTarget))return t.call(this,e)};r=t(r)}const l=O(t),c=l[a]||(l[a]={}),h=I(c,r,o?i:null);if(h)return void(h.oneOff=h.oneOff&&n);const d=L(r,e.replace(A,"")),u=o?function(t,e,i){return function s(n){const o=t.querySelectorAll(e);for(let{target:r}=n;r&&r!==this;r=r.parentNode)for(const a of o)if(a===r)return F(n,{delegateTarget:r}),s.oneOff&&j.off(t,n.type,e,i),i.apply(r,[n])}}(t,i,r):function(t,e){return function i(s){return F(s,{delegateTarget:t}),i.oneOff&&j.off(t,s.type,e),e.apply(t,[s])}}(t,r);u.delegationSelector=o?i:null,u.callable=r,u.oneOff=n,u.uidEvent=d,c[d]=u,t.addEventListener(a,u,o)}function P(t,e,i,s,n){const o=I(e[i],s,n);o&&(t.removeEventListener(i,o,Boolean(n)),delete e[i][o.uidEvent])}function x(t,e,i,s){const n=e[i]||{};for(const[o,r]of Object.entries(n))o.includes(s)&&P(t,e,i,r.callable,r.delegationSelector)}function M(t){return t=t.replace(E,""),$[t]||t}const j={on(t,e,i,s){N(t,e,i,s,!1)},one(t,e,i,s){N(t,e,i,s,!0)},off(t,e,i,s){if("string"!=typeof e||!t)return;const[n,o,r]=D(e,i,s),a=r!==e,l=O(t),c=l[r]||{},h=e.startsWith(".");if(void 0===o){if(h)for(const i of Object.keys(l))x(t,l,i,e.slice(1));for(const[i,s]of Object.entries(c)){const n=i.replace(C,"");a&&!e.includes(n)||P(t,l,r,s.callable,s.delegationSelector)}}else{if(!Object.keys(c).length)return;P(t,l,r,o,n?i:null)}},trigger(t,e,i){if("string"!=typeof e||!t)return null;const s=f();let n=null,o=!0,r=!0,a=!1;e!==M(e)&&s&&(n=s.Event(e,i),s(t).trigger(n),o=!n.isPropagationStopped(),r=!n.isImmediatePropagationStopped(),a=n.isDefaultPrevented());const l=F(new Event(e,{bubbles:o,cancelable:!0}),i);return a&&l.preventDefault(),r&&t.dispatchEvent(l),l.defaultPrevented&&n&&n.preventDefault(),l}};function F(t,e={}){for(const[i,s]of Object.entries(e))try{t[i]=s}catch(e){Object.defineProperty(t,i,{configurable:!0,get:()=>s})}return t}function z(t){if("true"===t)return!0;if("false"===t)return!1;if(t===Number(t).toString())return Number(t);if(""===t||"null"===t)return null;if("string"!=typeof t)return t;try{return JSON.parse(decodeURIComponent(t))}catch(e){return t}}function H(t){return t.replace(/[A-Z]/g,(t=>`-${t.toLowerCase()}`))}const B={setDataAttribute(t,e,i){t.setAttribute(`data-bs-${H(e)}`,i)},removeDataAttribute(t,e){t.removeAttribute(`data-bs-${H(e)}`)},getDataAttributes(t){if(!t)return{};const e={},i=Object.keys(t.dataset).filter((t=>t.startsWith("bs")&&!t.startsWith("bsConfig")));for(const s of i){let i=s.replace(/^bs/,"");i=i.charAt(0).toLowerCase()+i.slice(1,i.length),e[i]=z(t.dataset[s])}return e},getDataAttribute:(t,e)=>z(t.getAttribute(`data-bs-${H(e)}`))};class q{static get Default(){return{}}static get DefaultType(){return{}}static get NAME(){throw new Error('You have to implement the static method "NAME", for each component!')}_getConfig(t){return t=this._mergeConfigObj(t),t=this._configAfterMerge(t),this._typeCheckConfig(t),t}_configAfterMerge(t){return t}_mergeConfigObj(t,e){const i=l(e)?B.getDataAttribute(e,"config"):{};return{...this.constructor.Default,..."object"==typeof i?i:{},...l(e)?B.getDataAttributes(e):{},..."object"==typeof t?t:{}}}_typeCheckConfig(t,e=this.constructor.DefaultType){for(const[s,n]of Object.entries(e)){const e=t[s],o=l(e)?"element":null==(i=e)?`${i}`:Object.prototype.toString.call(i).match(/\s([a-z]+)/i)[1].toLowerCase();if(!new RegExp(n).test(o))throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option "${s}" provided type "${o}" but expected type "${n}".`)}var i}}class W extends q{constructor(t,e){super(),(t=c(t))&&(this._element=t,this._config=this._getConfig(e),n.set(this._element,this.constructor.DATA_KEY,this))}dispose(){n.remove(this._element,this.constructor.DATA_KEY),j.off(this._element,this.constructor.EVENT_KEY);for(const t of Object.getOwnPropertyNames(this))this[t]=null}_queueCallback(t,e,i=!0){y(t,e,i)}_getConfig(t){return t=this._mergeConfigObj(t,this._element),t=this._configAfterMerge(t),this._typeCheckConfig(t),t}static getInstance(t){return n.get(c(t),this.DATA_KEY)}static getOrCreateInstance(t,e={}){return this.getInstance(t)||new this(t,"object"==typeof e?e:null)}static get VERSION(){return"5.3.2"}static get DATA_KEY(){return`bs.${this.NAME}`}static get EVENT_KEY(){return`.${this.DATA_KEY}`}static eventName(t){return`${t}${this.EVENT_KEY}`}}const R=t=>{let e=t.getAttribute("data-bs-target");if(!e||"#"===e){let i=t.getAttribute("href");if(!i||!i.includes("#")&&!i.startsWith("."))return null;i.includes("#")&&!i.startsWith("#")&&(i=`#${i.split("#")[1]}`),e=i&&"#"!==i?r(i.trim()):null}return e},K={find:(t,e=document.documentElement)=>[].concat(...Element.prototype.querySelectorAll.call(e,t)),findOne:(t,e=document.documentElement)=>Element.prototype.querySelector.call(e,t),children:(t,e)=>[].concat(...t.children).filter((t=>t.matches(e))),parents(t,e){const i=[];let s=t.parentNode.closest(e);for(;s;)i.push(s),s=s.parentNode.closest(e);return i},prev(t,e){let i=t.previousElementSibling;for(;i;){if(i.matches(e))return[i];i=i.previousElementSibling}return[]},next(t,e){let i=t.nextElementSibling;for(;i;){if(i.matches(e))return[i];i=i.nextElementSibling}return[]},focusableChildren(t){const e=["a","button","input","textarea","select","details","[tabindex]",'[contenteditable="true"]'].map((t=>`${t}:not([tabindex^="-"])`)).join(",");return this.find(e,t).filter((t=>!d(t)&&h(t)))},getSelectorFromElement(t){const e=R(t);return e&&K.findOne(e)?e:null},getElementFromSelector(t){const e=R(t);return e?K.findOne(e):null},getMultipleElementsFromSelector(t){const e=R(t);return e?K.find(e):[]}},V=(t,e="hide")=>{const i=`click.dismiss${t.EVENT_KEY}`,s=t.NAME;j.on(document,i,`[data-bs-dismiss="${s}"]`,(function(i){if(["A","AREA"].includes(this.tagName)&&i.preventDefault(),d(this))return;const n=K.getElementFromSelector(this)||this.closest(`.${s}`);t.getOrCreateInstance(n)[e]()}))},Q=".bs.alert",X=`close${Q}`,Y=`closed${Q}`;class U extends W{static get NAME(){return"alert"}close(){if(j.trigger(this._element,X).defaultPrevented)return;this._element.classList.remove("show");const t=this._element.classList.contains("fade");this._queueCallback((()=>this._destroyElement()),this._element,t)}_destroyElement(){this._element.remove(),j.trigger(this._element,Y),this.dispose()}static jQueryInterface(t){return this.each((function(){const e=U.getOrCreateInstance(this);if("string"==typeof t){if(void 0===e[t]||t.startsWith("_")||"constructor"===t)throw new TypeError(`No method named "${t}"`);e[t](this)}}))}}V(U,"close"),b(U);const G='[data-bs-toggle="button"]';class J extends W{static get NAME(){return"button"}toggle(){this._element.setAttribute("aria-pressed",this._element.classList.toggle("active"))}static jQueryInterface(t){return this.each((function(){const e=J.getOrCreateInstance(this);"toggle"===t&&e[t]()}))}}j.on(document,"click.bs.button.data-api",G,(t=>{t.preventDefault();const e=t.target.closest(G);J.getOrCreateInstance(e).toggle()})),b(J);const Z=".bs.swipe",tt=`touchstart${Z}`,et=`touchmove${Z}`,it=`touchend${Z}`,st=`pointerdown${Z}`,nt=`pointerup${Z}`,ot={endCallback:null,leftCallback:null,rightCallback:null},rt={endCallback:"(function|null)",leftCallback:"(function|null)",rightCallback:"(function|null)"};class at extends q{constructor(t,e){super(),this._element=t,t&&at.isSupported()&&(this._config=this._getConfig(e),this._deltaX=0,this._supportPointerEvents=Boolean(window.PointerEvent),this._initEvents())}static get Default(){return ot}static get DefaultType(){return rt}static get NAME(){return"swipe"}dispose(){j.off(this._element,Z)}_start(t){this._supportPointerEvents?this._eventIsPointerPenTouch(t)&&(this._deltaX=t.clientX):this._deltaX=t.touches[0].clientX}_end(t){this._eventIsPointerPenTouch(t)&&(this._deltaX=t.clientX-this._deltaX),this._handleSwipe(),v(this._config.endCallback)}_move(t){this._deltaX=t.touches&&t.touches.length>1?0:t.touches[0].clientX-this._deltaX}_handleSwipe(){const t=Math.abs(this._deltaX);if(t<=40)return;const e=t/this._deltaX;this._deltaX=0,e&&v(e>0?this._config.rightCallback:this._config.leftCallback)}_initEvents(){this._supportPointerEvents?(j.on(this._element,st,(t=>this._start(t))),j.on(this._element,nt,(t=>this._end(t))),this._element.classList.add("pointer-event")):(j.on(this._element,tt,(t=>this._start(t))),j.on(this._element,et,(t=>this._move(t))),j.on(this._element,it,(t=>this._end(t))))}_eventIsPointerPenTouch(t){return this._supportPointerEvents&&("pen"===t.pointerType||"touch"===t.pointerType)}static isSupported(){return"ontouchstart"in document.documentElement||navigator.maxTouchPoints>0}}const lt=".bs.carousel",ct=".data-api",ht="next",dt="prev",ut="left",_t="right",gt=`slide${lt}`,ft=`slid${lt}`,mt=`keydown${lt}`,pt=`mouseenter${lt}`,bt=`mouseleave${lt}`,vt=`dragstart${lt}`,yt=`load${lt}${ct}`,wt=`click${lt}${ct}`,At="carousel",Et="active",Ct=".active",Tt=".carousel-item",kt=Ct+Tt,$t={ArrowLeft:_t,ArrowRight:ut},St={interval:5e3,keyboard:!0,pause:"hover",ride:!1,touch:!0,wrap:!0},Lt={interval:"(number|boolean)",keyboard:"boolean",pause:"(string|boolean)",ride:"(boolean|string)",touch:"boolean",wrap:"boolean"};class Ot extends W{constructor(t,e){super(t,e),this._interval=null,this._activeElement=null,this._isSliding=!1,this.touchTimeout=null,this._swipeHelper=null,this._indicatorsElement=K.findOne(".carousel-indicators",this._element),this._addEventListeners(),this._config.ride===At&&this.cycle()}static get Default(){return St}static get DefaultType(){return Lt}static get NAME(){return"carousel"}next(){this._slide(ht)}nextWhenVisible(){!document.hidden&&h(this._element)&&this.next()}prev(){this._slide(dt)}pause(){this._isSliding&&a(this._element),this._clearInterval()}cycle(){this._clearInterval(),this._updateInterval(),this._interval=setInterval((()=>this.nextWhenVisible()),this._config.interval)}_maybeEnableCycle(){this._config.ride&&(this._isSliding?j.one(this._element,ft,(()=>this.cycle())):this.cycle())}to(t){const e=this._getItems();if(t>e.length-1||t<0)return;if(this._isSliding)return void j.one(this._element,ft,(()=>this.to(t)));const i=this._getItemIndex(this._getActive());if(i===t)return;const s=t>i?ht:dt;this._slide(s,e[t])}dispose(){this._swipeHelper&&this._swipeHelper.dispose(),super.dispose()}_configAfterMerge(t){return t.defaultInterval=t.interval,t}_addEventListeners(){this._config.keyboard&&j.on(this._element,mt,(t=>this._keydown(t))),"hover"===this._config.pause&&(j.on(this._element,pt,(()=>this.pause())),j.on(this._element,bt,(()=>this._maybeEnableCycle()))),this._config.touch&&at.isSupported()&&this._addTouchEventListeners()}_addTouchEventListeners(){for(const t of K.find(".carousel-item img",this._element))j.on(t,vt,(t=>t.preventDefault()));const t={leftCallback:()=>this._slide(this._directionToOrder(ut)),rightCallback:()=>this._slide(this._directionToOrder(_t)),endCallback:()=>{"hover"===this._config.pause&&(this.pause(),this.touchTimeout&&clearTimeout(this.touchTimeout),this.touchTimeout=setTimeout((()=>this._maybeEnableCycle()),500+this._config.interval))}};this._swipeHelper=new at(this._element,t)}_keydown(t){if(/input|textarea/i.test(t.target.tagName))return;const e=$t[t.key];e&&(t.preventDefault(),this._slide(this._directionToOrder(e)))}_getItemIndex(t){return this._getItems().indexOf(t)}_setActiveIndicatorElement(t){if(!this._indicatorsElement)return;const e=K.findOne(Ct,this._indicatorsElement);e.classList.remove(Et),e.removeAttribute("aria-current");const i=K.findOne(`[data-bs-slide-to="${t}"]`,this._indicatorsElement);i&&(i.classList.add(Et),i.setAttribute("aria-current","true"))}_updateInterval(){const t=this._activeElement||this._getActive();if(!t)return;const e=Number.parseInt(t.getAttribute("data-bs-interval"),10);this._config.interval=e||this._config.defaultInterval}_slide(t,e=null){if(this._isSliding)return;const i=this._getActive(),s=t===ht,n=e||w(this._getItems(),i,s,this._config.wrap);if(n===i)return;const o=this._getItemIndex(n),r=e=>j.trigger(this._element,e,{relatedTarget:n,direction:this._orderToDirection(t),from:this._getItemIndex(i),to:o});if(r(gt).defaultPrevented)return;if(!i||!n)return;const a=Boolean(this._interval);this.pause(),this._isSliding=!0,this._setActiveIndicatorElement(o),this._activeElement=n;const l=s?"carousel-item-start":"carousel-item-end",c=s?"carousel-item-next":"carousel-item-prev";n.classList.add(c),g(n),i.classList.add(l),n.classList.add(l),this._queueCallback((()=>{n.classList.remove(l,c),n.classList.add(Et),i.classList.remove(Et,c,l),this._isSliding=!1,r(ft)}),i,this._isAnimated()),a&&this.cycle()}_isAnimated(){return this._element.classList.contains("slide")}_getActive(){return K.findOne(kt,this._element)}_getItems(){return K.find(Tt,this._element)}_clearInterval(){this._interval&&(clearInterval(this._interval),this._interval=null)}_directionToOrder(t){return p()?t===ut?dt:ht:t===ut?ht:dt}_orderToDirection(t){return p()?t===dt?ut:_t:t===dt?_t:ut}static jQueryInterface(t){return this.each((function(){const e=Ot.getOrCreateInstance(this,t);if("number"!=typeof t){if("string"==typeof t){if(void 0===e[t]||t.startsWith("_")||"constructor"===t)throw new TypeError(`No method named "${t}"`);e[t]()}}else e.to(t)}))}}j.on(document,wt,"[data-bs-slide], [data-bs-slide-to]",(function(t){const e=K.getElementFromSelector(this);if(!e||!e.classList.contains(At))return;t.preventDefault();const i=Ot.getOrCreateInstance(e),s=this.getAttribute("data-bs-slide-to");return s?(i.to(s),void i._maybeEnableCycle()):"next"===B.getDataAttribute(this,"slide")?(i.next(),void i._maybeEnableCycle()):(i.prev(),void i._maybeEnableCycle())})),j.on(window,yt,(()=>{const t=K.find('[data-bs-ride="carousel"]');for(const e of t)Ot.getOrCreateInstance(e)})),b(Ot);const It=".bs.collapse",Dt=`show${It}`,Nt=`shown${It}`,Pt=`hide${It}`,xt=`hidden${It}`,Mt=`click${It}.data-api`,jt="show",Ft="collapse",zt="collapsing",Ht=`:scope .${Ft} .${Ft}`,Bt='[data-bs-toggle="collapse"]',qt={parent:null,toggle:!0},Wt={parent:"(null|element)",toggle:"boolean"};class Rt extends W{constructor(t,e){super(t,e),this._isTransitioning=!1,this._triggerArray=[];const i=K.find(Bt);for(const t of i){const e=K.getSelectorFromElement(t),i=K.find(e).filter((t=>t===this._element));null!==e&&i.length&&this._triggerArray.push(t)}this._initializeChildren(),this._config.parent||this._addAriaAndCollapsedClass(this._triggerArray,this._isShown()),this._config.toggle&&this.toggle()}static get Default(){return qt}static get DefaultType(){return Wt}static get NAME(){return"collapse"}toggle(){this._isShown()?this.hide():this.show()}show(){if(this._isTransitioning||this._isShown())return;let t=[];if(this._config.parent&&(t=this._getFirstLevelChildren(".collapse.show, .collapse.collapsing").filter((t=>t!==this._element)).map((t=>Rt.getOrCreateInstance(t,{toggle:!1})))),t.length&&t[0]._isTransitioning)return;if(j.trigger(this._element,Dt).defaultPrevented)return;for(const e of t)e.hide();const e=this._getDimension();this._element.classList.remove(Ft),this._element.classList.add(zt),this._element.style[e]=0,this._addAriaAndCollapsedClass(this._triggerArray,!0),this._isTransitioning=!0;const i=`scroll${e[0].toUpperCase()+e.slice(1)}`;this._queueCallback((()=>{this._isTransitioning=!1,this._element.classList.remove(zt),this._element.classList.add(Ft,jt),this._element.style[e]="",j.trigger(this._element,Nt)}),this._element,!0),this._element.style[e]=`${this._element[i]}px`}hide(){if(this._isTransitioning||!this._isShown())return;if(j.trigger(this._element,Pt).defaultPrevented)return;const t=this._getDimension();this._element.style[t]=`${this._element.getBoundingClientRect()[t]}px`,g(this._element),this._element.classList.add(zt),this._element.classList.remove(Ft,jt);for(const t of this._triggerArray){const e=K.getElementFromSelector(t);e&&!this._isShown(e)&&this._addAriaAndCollapsedClass([t],!1)}this._isTransitioning=!0,this._element.style[t]="",this._queueCallback((()=>{this._isTransitioning=!1,this._element.classList.remove(zt),this._element.classList.add(Ft),j.trigger(this._element,xt)}),this._element,!0)}_isShown(t=this._element){return t.classList.contains(jt)}_configAfterMerge(t){return t.toggle=Boolean(t.toggle),t.parent=c(t.parent),t}_getDimension(){return this._element.classList.contains("collapse-horizontal")?"width":"height"}_initializeChildren(){if(!this._config.parent)return;const t=this._getFirstLevelChildren(Bt);for(const e of t){const t=K.getElementFromSelector(e);t&&this._addAriaAndCollapsedClass([e],this._isShown(t))}}_getFirstLevelChildren(t){const e=K.find(Ht,this._config.parent);return K.find(t,this._config.parent).filter((t=>!e.includes(t)))}_addAriaAndCollapsedClass(t,e){if(t.length)for(const i of t)i.classList.toggle("collapsed",!e),i.setAttribute("aria-expanded",e)}static jQueryInterface(t){const e={};return"string"==typeof t&&/show|hide/.test(t)&&(e.toggle=!1),this.each((function(){const i=Rt.getOrCreateInstance(this,e);if("string"==typeof t){if(void 0===i[t])throw new TypeError(`No method named "${t}"`);i[t]()}}))}}j.on(document,Mt,Bt,(function(t){("A"===t.target.tagName||t.delegateTarget&&"A"===t.delegateTarget.tagName)&&t.preventDefault();for(const t of K.getMultipleElementsFromSelector(this))Rt.getOrCreateInstance(t,{toggle:!1}).toggle()})),b(Rt);const Kt="dropdown",Vt=".bs.dropdown",Qt=".data-api",Xt="ArrowUp",Yt="ArrowDown",Ut=`hide${Vt}`,Gt=`hidden${Vt}`,Jt=`show${Vt}`,Zt=`shown${Vt}`,te=`click${Vt}${Qt}`,ee=`keydown${Vt}${Qt}`,ie=`keyup${Vt}${Qt}`,se="show",ne='[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled)',oe=`${ne}.${se}`,re=".dropdown-menu",ae=p()?"top-end":"top-start",le=p()?"top-start":"top-end",ce=p()?"bottom-end":"bottom-start",he=p()?"bottom-start":"bottom-end",de=p()?"left-start":"right-start",ue=p()?"right-start":"left-start",_e={autoClose:!0,boundary:"clippingParents",display:"dynamic",offset:[0,2],popperConfig:null,reference:"toggle"},ge={autoClose:"(boolean|string)",boundary:"(string|element)",display:"string",offset:"(array|string|function)",popperConfig:"(null|object|function)",reference:"(string|element|object)"};class fe extends W{constructor(t,e){super(t,e),this._popper=null,this._parent=this._element.parentNode,this._menu=K.next(this._element,re)[0]||K.prev(this._element,re)[0]||K.findOne(re,this._parent),this._inNavbar=this._detectNavbar()}static get Default(){return _e}static get DefaultType(){return ge}static get NAME(){return Kt}toggle(){return this._isShown()?this.hide():this.show()}show(){if(d(this._element)||this._isShown())return;const t={relatedTarget:this._element};if(!j.trigger(this._element,Jt,t).defaultPrevented){if(this._createPopper(),"ontouchstart"in document.documentElement&&!this._parent.closest(".navbar-nav"))for(const t of[].concat(...document.body.children))j.on(t,"mouseover",_);this._element.focus(),this._element.setAttribute("aria-expanded",!0),this._menu.classList.add(se),this._element.classList.add(se),j.trigger(this._element,Zt,t)}}hide(){if(d(this._element)||!this._isShown())return;const t={relatedTarget:this._element};this._completeHide(t)}dispose(){this._popper&&this._popper.destroy(),super.dispose()}update(){this._inNavbar=this._detectNavbar(),this._popper&&this._popper.update()}_completeHide(t){if(!j.trigger(this._element,Ut,t).defaultPrevented){if("ontouchstart"in document.documentElement)for(const t of[].concat(...document.body.children))j.off(t,"mouseover",_);this._popper&&this._popper.destroy(),this._menu.classList.remove(se),this._element.classList.remove(se),this._element.setAttribute("aria-expanded","false"),B.removeDataAttribute(this._menu,"popper"),j.trigger(this._element,Gt,t)}}_getConfig(t){if("object"==typeof(t=super._getConfig(t)).reference&&!l(t.reference)&&"function"!=typeof t.reference.getBoundingClientRect)throw new TypeError(`${Kt.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);return t}_createPopper(){if(void 0===i)throw new TypeError("Bootstrap's dropdowns require Popper (https://popper.js.org)");let t=this._element;"parent"===this._config.reference?t=this._parent:l(this._config.reference)?t=c(this._config.reference):"object"==typeof this._config.reference&&(t=this._config.reference);const e=this._getPopperConfig();this._popper=i.createPopper(t,this._menu,e)}_isShown(){return this._menu.classList.contains(se)}_getPlacement(){const t=this._parent;if(t.classList.contains("dropend"))return de;if(t.classList.contains("dropstart"))return ue;if(t.classList.contains("dropup-center"))return"top";if(t.classList.contains("dropdown-center"))return"bottom";const e="end"===getComputedStyle(this._menu).getPropertyValue("--bs-position").trim();return t.classList.contains("dropup")?e?le:ae:e?he:ce}_detectNavbar(){return null!==this._element.closest(".navbar")}_getOffset(){const{offset:t}=this._config;return"string"==typeof t?t.split(",").map((t=>Number.parseInt(t,10))):"function"==typeof t?e=>t(e,this._element):t}_getPopperConfig(){const t={placement:this._getPlacement(),modifiers:[{name:"preventOverflow",options:{boundary:this._config.boundary}},{name:"offset",options:{offset:this._getOffset()}}]};return(this._inNavbar||"static"===this._config.display)&&(B.setDataAttribute(this._menu,"popper","static"),t.modifiers=[{name:"applyStyles",enabled:!1}]),{...t,...v(this._config.popperConfig,[t])}}_selectMenuItem({key:t,target:e}){const i=K.find(".dropdown-menu .dropdown-item:not(.disabled):not(:disabled)",this._menu).filter((t=>h(t)));i.length&&w(i,e,t===Yt,!i.includes(e)).focus()}static jQueryInterface(t){return this.each((function(){const e=fe.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t]()}}))}static clearMenus(t){if(2===t.button||"keyup"===t.type&&"Tab"!==t.key)return;const e=K.find(oe);for(const i of e){const e=fe.getInstance(i);if(!e||!1===e._config.autoClose)continue;const s=t.composedPath(),n=s.includes(e._menu);if(s.includes(e._element)||"inside"===e._config.autoClose&&!n||"outside"===e._config.autoClose&&n)continue;if(e._menu.contains(t.target)&&("keyup"===t.type&&"Tab"===t.key||/input|select|option|textarea|form/i.test(t.target.tagName)))continue;const o={relatedTarget:e._element};"click"===t.type&&(o.clickEvent=t),e._completeHide(o)}}static dataApiKeydownHandler(t){const e=/input|textarea/i.test(t.target.tagName),i="Escape"===t.key,s=[Xt,Yt].includes(t.key);if(!s&&!i)return;if(e&&!i)return;t.preventDefault();const n=this.matches(ne)?this:K.prev(this,ne)[0]||K.next(this,ne)[0]||K.findOne(ne,t.delegateTarget.parentNode),o=fe.getOrCreateInstance(n);if(s)return t.stopPropagation(),o.show(),void o._selectMenuItem(t);o._isShown()&&(t.stopPropagation(),o.hide(),n.focus())}}j.on(document,ee,ne,fe.dataApiKeydownHandler),j.on(document,ee,re,fe.dataApiKeydownHandler),j.on(document,te,fe.clearMenus),j.on(document,ie,fe.clearMenus),j.on(document,te,ne,(function(t){t.preventDefault(),fe.getOrCreateInstance(this).toggle()})),b(fe);const me="backdrop",pe="show",be=`mousedown.bs.${me}`,ve={className:"modal-backdrop",clickCallback:null,isAnimated:!1,isVisible:!0,rootElement:"body"},ye={className:"string",clickCallback:"(function|null)",isAnimated:"boolean",isVisible:"boolean",rootElement:"(element|string)"};class we extends q{constructor(t){super(),this._config=this._getConfig(t),this._isAppended=!1,this._element=null}static get Default(){return ve}static get DefaultType(){return ye}static get NAME(){return me}show(t){if(!this._config.isVisible)return void v(t);this._append();const e=this._getElement();this._config.isAnimated&&g(e),e.classList.add(pe),this._emulateAnimation((()=>{v(t)}))}hide(t){this._config.isVisible?(this._getElement().classList.remove(pe),this._emulateAnimation((()=>{this.dispose(),v(t)}))):v(t)}dispose(){this._isAppended&&(j.off(this._element,be),this._element.remove(),this._isAppended=!1)}_getElement(){if(!this._element){const t=document.createElement("div");t.className=this._config.className,this._config.isAnimated&&t.classList.add("fade"),this._element=t}return this._element}_configAfterMerge(t){return t.rootElement=c(t.rootElement),t}_append(){if(this._isAppended)return;const t=this._getElement();this._config.rootElement.append(t),j.on(t,be,(()=>{v(this._config.clickCallback)})),this._isAppended=!0}_emulateAnimation(t){y(t,this._getElement(),this._config.isAnimated)}}const Ae=".bs.focustrap",Ee=`focusin${Ae}`,Ce=`keydown.tab${Ae}`,Te="backward",ke={autofocus:!0,trapElement:null},$e={autofocus:"boolean",trapElement:"element"};class Se extends q{constructor(t){super(),this._config=this._getConfig(t),this._isActive=!1,this._lastTabNavDirection=null}static get Default(){return ke}static get DefaultType(){return $e}static get NAME(){return"focustrap"}activate(){this._isActive||(this._config.autofocus&&this._config.trapElement.focus(),j.off(document,Ae),j.on(document,Ee,(t=>this._handleFocusin(t))),j.on(document,Ce,(t=>this._handleKeydown(t))),this._isActive=!0)}deactivate(){this._isActive&&(this._isActive=!1,j.off(document,Ae))}_handleFocusin(t){const{trapElement:e}=this._config;if(t.target===document||t.target===e||e.contains(t.target))return;const i=K.focusableChildren(e);0===i.length?e.focus():this._lastTabNavDirection===Te?i[i.length-1].focus():i[0].focus()}_handleKeydown(t){"Tab"===t.key&&(this._lastTabNavDirection=t.shiftKey?Te:"forward")}}const Le=".fixed-top, .fixed-bottom, .is-fixed, .sticky-top",Oe=".sticky-top",Ie="padding-right",De="margin-right";class Ne{constructor(){this._element=document.body}getWidth(){const t=document.documentElement.clientWidth;return Math.abs(window.innerWidth-t)}hide(){const t=this.getWidth();this._disableOverFlow(),this._setElementAttributes(this._element,Ie,(e=>e+t)),this._setElementAttributes(Le,Ie,(e=>e+t)),this._setElementAttributes(Oe,De,(e=>e-t))}reset(){this._resetElementAttributes(this._element,"overflow"),this._resetElementAttributes(this._element,Ie),this._resetElementAttributes(Le,Ie),this._resetElementAttributes(Oe,De)}isOverflowing(){return this.getWidth()>0}_disableOverFlow(){this._saveInitialAttribute(this._element,"overflow"),this._element.style.overflow="hidden"}_setElementAttributes(t,e,i){const s=this.getWidth();this._applyManipulationCallback(t,(t=>{if(t!==this._element&&window.innerWidth>t.clientWidth+s)return;this._saveInitialAttribute(t,e);const n=window.getComputedStyle(t).getPropertyValue(e);t.style.setProperty(e,`${i(Number.parseFloat(n))}px`)}))}_saveInitialAttribute(t,e){const i=t.style.getPropertyValue(e);i&&B.setDataAttribute(t,e,i)}_resetElementAttributes(t,e){this._applyManipulationCallback(t,(t=>{const i=B.getDataAttribute(t,e);null!==i?(B.removeDataAttribute(t,e),t.style.setProperty(e,i)):t.style.removeProperty(e)}))}_applyManipulationCallback(t,e){if(l(t))e(t);else for(const i of K.find(t,this._element))e(i)}}const Pe=".bs.modal",xe=`hide${Pe}`,Me=`hidePrevented${Pe}`,je=`hidden${Pe}`,Fe=`show${Pe}`,ze=`shown${Pe}`,He=`resize${Pe}`,Be=`click.dismiss${Pe}`,qe=`mousedown.dismiss${Pe}`,We=`keydown.dismiss${Pe}`,Re=`click${Pe}.data-api`,Ke="modal-open",Ve="show",Qe="modal-static",Xe={backdrop:!0,focus:!0,keyboard:!0},Ye={backdrop:"(boolean|string)",focus:"boolean",keyboard:"boolean"};class Ue extends W{constructor(t,e){super(t,e),this._dialog=K.findOne(".modal-dialog",this._element),this._backdrop=this._initializeBackDrop(),this._focustrap=this._initializeFocusTrap(),this._isShown=!1,this._isTransitioning=!1,this._scrollBar=new Ne,this._addEventListeners()}static get Default(){return Xe}static get DefaultType(){return Ye}static get NAME(){return"modal"}toggle(t){return this._isShown?this.hide():this.show(t)}show(t){this._isShown||this._isTransitioning||j.trigger(this._element,Fe,{relatedTarget:t}).defaultPrevented||(this._isShown=!0,this._isTransitioning=!0,this._scrollBar.hide(),document.body.classList.add(Ke),this._adjustDialog(),this._backdrop.show((()=>this._showElement(t))))}hide(){this._isShown&&!this._isTransitioning&&(j.trigger(this._element,xe).defaultPrevented||(this._isShown=!1,this._isTransitioning=!0,this._focustrap.deactivate(),this._element.classList.remove(Ve),this._queueCallback((()=>this._hideModal()),this._element,this._isAnimated())))}dispose(){j.off(window,Pe),j.off(this._dialog,Pe),this._backdrop.dispose(),this._focustrap.deactivate(),super.dispose()}handleUpdate(){this._adjustDialog()}_initializeBackDrop(){return new we({isVisible:Boolean(this._config.backdrop),isAnimated:this._isAnimated()})}_initializeFocusTrap(){return new Se({trapElement:this._element})}_showElement(t){document.body.contains(this._element)||document.body.append(this._element),this._element.style.display="block",this._element.removeAttribute("aria-hidden"),this._element.setAttribute("aria-modal",!0),this._element.setAttribute("role","dialog"),this._element.scrollTop=0;const e=K.findOne(".modal-body",this._dialog);e&&(e.scrollTop=0),g(this._element),this._element.classList.add(Ve),this._queueCallback((()=>{this._config.focus&&this._focustrap.activate(),this._isTransitioning=!1,j.trigger(this._element,ze,{relatedTarget:t})}),this._dialog,this._isAnimated())}_addEventListeners(){j.on(this._element,We,(t=>{"Escape"===t.key&&(this._config.keyboard?this.hide():this._triggerBackdropTransition())})),j.on(window,He,(()=>{this._isShown&&!this._isTransitioning&&this._adjustDialog()})),j.on(this._element,qe,(t=>{j.one(this._element,Be,(e=>{this._element===t.target&&this._element===e.target&&("static"!==this._config.backdrop?this._config.backdrop&&this.hide():this._triggerBackdropTransition())}))}))}_hideModal(){this._element.style.display="none",this._element.setAttribute("aria-hidden",!0),this._element.removeAttribute("aria-modal"),this._element.removeAttribute("role"),this._isTransitioning=!1,this._backdrop.hide((()=>{document.body.classList.remove(Ke),this._resetAdjustments(),this._scrollBar.reset(),j.trigger(this._element,je)}))}_isAnimated(){return this._element.classList.contains("fade")}_triggerBackdropTransition(){if(j.trigger(this._element,Me).defaultPrevented)return;const t=this._element.scrollHeight>document.documentElement.clientHeight,e=this._element.style.overflowY;"hidden"===e||this._element.classList.contains(Qe)||(t||(this._element.style.overflowY="hidden"),this._element.classList.add(Qe),this._queueCallback((()=>{this._element.classList.remove(Qe),this._queueCallback((()=>{this._element.style.overflowY=e}),this._dialog)}),this._dialog),this._element.focus())}_adjustDialog(){const t=this._element.scrollHeight>document.documentElement.clientHeight,e=this._scrollBar.getWidth(),i=e>0;if(i&&!t){const t=p()?"paddingLeft":"paddingRight";this._element.style[t]=`${e}px`}if(!i&&t){const t=p()?"paddingRight":"paddingLeft";this._element.style[t]=`${e}px`}}_resetAdjustments(){this._element.style.paddingLeft="",this._element.style.paddingRight=""}static jQueryInterface(t,e){return this.each((function(){const i=Ue.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===i[t])throw new TypeError(`No method named "${t}"`);i[t](e)}}))}}j.on(document,Re,'[data-bs-toggle="modal"]',(function(t){const e=K.getElementFromSelector(this);["A","AREA"].includes(this.tagName)&&t.preventDefault(),j.one(e,Fe,(t=>{t.defaultPrevented||j.one(e,je,(()=>{h(this)&&this.focus()}))}));const i=K.findOne(".modal.show");i&&Ue.getInstance(i).hide(),Ue.getOrCreateInstance(e).toggle(this)})),V(Ue),b(Ue);const Ge=".bs.offcanvas",Je=".data-api",Ze=`load${Ge}${Je}`,ti="show",ei="showing",ii="hiding",si=".offcanvas.show",ni=`show${Ge}`,oi=`shown${Ge}`,ri=`hide${Ge}`,ai=`hidePrevented${Ge}`,li=`hidden${Ge}`,ci=`resize${Ge}`,hi=`click${Ge}${Je}`,di=`keydown.dismiss${Ge}`,ui={backdrop:!0,keyboard:!0,scroll:!1},_i={backdrop:"(boolean|string)",keyboard:"boolean",scroll:"boolean"};class gi extends W{constructor(t,e){super(t,e),this._isShown=!1,this._backdrop=this._initializeBackDrop(),this._focustrap=this._initializeFocusTrap(),this._addEventListeners()}static get Default(){return ui}static get DefaultType(){return _i}static get NAME(){return"offcanvas"}toggle(t){return this._isShown?this.hide():this.show(t)}show(t){this._isShown||j.trigger(this._element,ni,{relatedTarget:t}).defaultPrevented||(this._isShown=!0,this._backdrop.show(),this._config.scroll||(new Ne).hide(),this._element.setAttribute("aria-modal",!0),this._element.setAttribute("role","dialog"),this._element.classList.add(ei),this._queueCallback((()=>{this._config.scroll&&!this._config.backdrop||this._focustrap.activate(),this._element.classList.add(ti),this._element.classList.remove(ei),j.trigger(this._element,oi,{relatedTarget:t})}),this._element,!0))}hide(){this._isShown&&(j.trigger(this._element,ri).defaultPrevented||(this._focustrap.deactivate(),this._element.blur(),this._isShown=!1,this._element.classList.add(ii),this._backdrop.hide(),this._queueCallback((()=>{this._element.classList.remove(ti,ii),this._element.removeAttribute("aria-modal"),this._element.removeAttribute("role"),this._config.scroll||(new Ne).reset(),j.trigger(this._element,li)}),this._element,!0)))}dispose(){this._backdrop.dispose(),this._focustrap.deactivate(),super.dispose()}_initializeBackDrop(){const t=Boolean(this._config.backdrop);return new we({className:"offcanvas-backdrop",isVisible:t,isAnimated:!0,rootElement:this._element.parentNode,clickCallback:t?()=>{"static"!==this._config.backdrop?this.hide():j.trigger(this._element,ai)}:null})}_initializeFocusTrap(){return new Se({trapElement:this._element})}_addEventListeners(){j.on(this._element,di,(t=>{"Escape"===t.key&&(this._config.keyboard?this.hide():j.trigger(this._element,ai))}))}static jQueryInterface(t){return this.each((function(){const e=gi.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t]||t.startsWith("_")||"constructor"===t)throw new TypeError(`No method named "${t}"`);e[t](this)}}))}}j.on(document,hi,'[data-bs-toggle="offcanvas"]',(function(t){const e=K.getElementFromSelector(this);if(["A","AREA"].includes(this.tagName)&&t.preventDefault(),d(this))return;j.one(e,li,(()=>{h(this)&&this.focus()}));const i=K.findOne(si);i&&i!==e&&gi.getInstance(i).hide(),gi.getOrCreateInstance(e).toggle(this)})),j.on(window,Ze,(()=>{for(const t of K.find(si))gi.getOrCreateInstance(t).show()})),j.on(window,ci,(()=>{for(const t of K.find("[aria-modal][class*=show][class*=offcanvas-]"))"fixed"!==getComputedStyle(t).position&&gi.getOrCreateInstance(t).hide()})),V(gi),b(gi);const fi={"*":["class","dir","id","lang","role",/^aria-[\w-]*$/i],a:["target","href","title","rel"],area:[],b:[],br:[],col:[],code:[],div:[],em:[],hr:[],h1:[],h2:[],h3:[],h4:[],h5:[],h6:[],i:[],img:["src","srcset","alt","title","width","height"],li:[],ol:[],p:[],pre:[],s:[],small:[],span:[],sub:[],sup:[],strong:[],u:[],ul:[]},mi=new Set(["background","cite","href","itemtype","longdesc","poster","src","xlink:href"]),pi=/^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:/?#]*(?:[/?#]|$))/i,bi=(t,e)=>{const i=t.nodeName.toLowerCase();return e.includes(i)?!mi.has(i)||Boolean(pi.test(t.nodeValue)):e.filter((t=>t instanceof RegExp)).some((t=>t.test(i)))},vi={allowList:fi,content:{},extraClass:"",html:!1,sanitize:!0,sanitizeFn:null,template:"<div></div>"},yi={allowList:"object",content:"object",extraClass:"(string|function)",html:"boolean",sanitize:"boolean",sanitizeFn:"(null|function)",template:"string"},wi={entry:"(string|element|function|null)",selector:"(string|element)"};class Ai extends q{constructor(t){super(),this._config=this._getConfig(t)}static get Default(){return vi}static get DefaultType(){return yi}static get NAME(){return"TemplateFactory"}getContent(){return Object.values(this._config.content).map((t=>this._resolvePossibleFunction(t))).filter(Boolean)}hasContent(){return this.getContent().length>0}changeContent(t){return this._checkContent(t),this._config.content={...this._config.content,...t},this}toHtml(){const t=document.createElement("div");t.innerHTML=this._maybeSanitize(this._config.template);for(const[e,i]of Object.entries(this._config.content))this._setContent(t,i,e);const e=t.children[0],i=this._resolvePossibleFunction(this._config.extraClass);return i&&e.classList.add(...i.split(" ")),e}_typeCheckConfig(t){super._typeCheckConfig(t),this._checkContent(t.content)}_checkContent(t){for(const[e,i]of Object.entries(t))super._typeCheckConfig({selector:e,entry:i},wi)}_setContent(t,e,i){const s=K.findOne(i,t);s&&((e=this._resolvePossibleFunction(e))?l(e)?this._putElementInTemplate(c(e),s):this._config.html?s.innerHTML=this._maybeSanitize(e):s.textContent=e:s.remove())}_maybeSanitize(t){return this._config.sanitize?function(t,e,i){if(!t.length)return t;if(i&&"function"==typeof i)return i(t);const s=(new window.DOMParser).parseFromString(t,"text/html"),n=[].concat(...s.body.querySelectorAll("*"));for(const t of n){const i=t.nodeName.toLowerCase();if(!Object.keys(e).includes(i)){t.remove();continue}const s=[].concat(...t.attributes),n=[].concat(e["*"]||[],e[i]||[]);for(const e of s)bi(e,n)||t.removeAttribute(e.nodeName)}return s.body.innerHTML}(t,this._config.allowList,this._config.sanitizeFn):t}_resolvePossibleFunction(t){return v(t,[this])}_putElementInTemplate(t,e){if(this._config.html)return e.innerHTML="",void e.append(t);e.textContent=t.textContent}}const Ei=new Set(["sanitize","allowList","sanitizeFn"]),Ci="fade",Ti="show",ki=".modal",$i="hide.bs.modal",Si="hover",Li="focus",Oi={AUTO:"auto",TOP:"top",RIGHT:p()?"left":"right",BOTTOM:"bottom",LEFT:p()?"right":"left"},Ii={allowList:fi,animation:!0,boundary:"clippingParents",container:!1,customClass:"",delay:0,fallbackPlacements:["top","right","bottom","left"],html:!1,offset:[0,6],placement:"top",popperConfig:null,sanitize:!0,sanitizeFn:null,selector:!1,template:'<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',title:"",trigger:"hover focus"},Di={allowList:"object",animation:"boolean",boundary:"(string|element)",container:"(string|element|boolean)",customClass:"(string|function)",delay:"(number|object)",fallbackPlacements:"array",html:"boolean",offset:"(array|string|function)",placement:"(string|function)",popperConfig:"(null|object|function)",sanitize:"boolean",sanitizeFn:"(null|function)",selector:"(string|boolean)",template:"string",title:"(string|element|function)",trigger:"string"};class Ni extends W{constructor(t,e){if(void 0===i)throw new TypeError("Bootstrap's tooltips require Popper (https://popper.js.org)");super(t,e),this._isEnabled=!0,this._timeout=0,this._isHovered=null,this._activeTrigger={},this._popper=null,this._templateFactory=null,this._newContent=null,this.tip=null,this._setListeners(),this._config.selector||this._fixTitle()}static get Default(){return Ii}static get DefaultType(){return Di}static get NAME(){return"tooltip"}enable(){this._isEnabled=!0}disable(){this._isEnabled=!1}toggleEnabled(){this._isEnabled=!this._isEnabled}toggle(){this._isEnabled&&(this._activeTrigger.click=!this._activeTrigger.click,this._isShown()?this._leave():this._enter())}dispose(){clearTimeout(this._timeout),j.off(this._element.closest(ki),$i,this._hideModalHandler),this._element.getAttribute("data-bs-original-title")&&this._element.setAttribute("title",this._element.getAttribute("data-bs-original-title")),this._disposePopper(),super.dispose()}show(){if("none"===this._element.style.display)throw new Error("Please use show on visible elements");if(!this._isWithContent()||!this._isEnabled)return;const t=j.trigger(this._element,this.constructor.eventName("show")),e=(u(this._element)||this._element.ownerDocument.documentElement).contains(this._element);if(t.defaultPrevented||!e)return;this._disposePopper();const i=this._getTipElement();this._element.setAttribute("aria-describedby",i.getAttribute("id"));const{container:s}=this._config;if(this._element.ownerDocument.documentElement.contains(this.tip)||(s.append(i),j.trigger(this._element,this.constructor.eventName("inserted"))),this._popper=this._createPopper(i),i.classList.add(Ti),"ontouchstart"in document.documentElement)for(const t of[].concat(...document.body.children))j.on(t,"mouseover",_);this._queueCallback((()=>{j.trigger(this._element,this.constructor.eventName("shown")),!1===this._isHovered&&this._leave(),this._isHovered=!1}),this.tip,this._isAnimated())}hide(){if(this._isShown()&&!j.trigger(this._element,this.constructor.eventName("hide")).defaultPrevented){if(this._getTipElement().classList.remove(Ti),"ontouchstart"in document.documentElement)for(const t of[].concat(...document.body.children))j.off(t,"mouseover",_);this._activeTrigger.click=!1,this._activeTrigger[Li]=!1,this._activeTrigger[Si]=!1,this._isHovered=null,this._queueCallback((()=>{this._isWithActiveTrigger()||(this._isHovered||this._disposePopper(),this._element.removeAttribute("aria-describedby"),j.trigger(this._element,this.constructor.eventName("hidden")))}),this.tip,this._isAnimated())}}update(){this._popper&&this._popper.update()}_isWithContent(){return Boolean(this._getTitle())}_getTipElement(){return this.tip||(this.tip=this._createTipElement(this._newContent||this._getContentForTemplate())),this.tip}_createTipElement(t){const e=this._getTemplateFactory(t).toHtml();if(!e)return null;e.classList.remove(Ci,Ti),e.classList.add(`bs-${this.constructor.NAME}-auto`);const i=(t=>{do{t+=Math.floor(1e6*Math.random())}while(document.getElementById(t));return t})(this.constructor.NAME).toString();return e.setAttribute("id",i),this._isAnimated()&&e.classList.add(Ci),e}setContent(t){this._newContent=t,this._isShown()&&(this._disposePopper(),this.show())}_getTemplateFactory(t){return this._templateFactory?this._templateFactory.changeContent(t):this._templateFactory=new Ai({...this._config,content:t,extraClass:this._resolvePossibleFunction(this._config.customClass)}),this._templateFactory}_getContentForTemplate(){return{".tooltip-inner":this._getTitle()}}_getTitle(){return this._resolvePossibleFunction(this._config.title)||this._element.getAttribute("data-bs-original-title")}_initializeOnDelegatedTarget(t){return this.constructor.getOrCreateInstance(t.delegateTarget,this._getDelegateConfig())}_isAnimated(){return this._config.animation||this.tip&&this.tip.classList.contains(Ci)}_isShown(){return this.tip&&this.tip.classList.contains(Ti)}_createPopper(t){const e=v(this._config.placement,[this,t,this._element]),s=Oi[e.toUpperCase()];return i.createPopper(this._element,t,this._getPopperConfig(s))}_getOffset(){const{offset:t}=this._config;return"string"==typeof t?t.split(",").map((t=>Number.parseInt(t,10))):"function"==typeof t?e=>t(e,this._element):t}_resolvePossibleFunction(t){return v(t,[this._element])}_getPopperConfig(t){const e={placement:t,modifiers:[{name:"flip",options:{fallbackPlacements:this._config.fallbackPlacements}},{name:"offset",options:{offset:this._getOffset()}},{name:"preventOverflow",options:{boundary:this._config.boundary}},{name:"arrow",options:{element:`.${this.constructor.NAME}-arrow`}},{name:"preSetPlacement",enabled:!0,phase:"beforeMain",fn:t=>{this._getTipElement().setAttribute("data-popper-placement",t.state.placement)}}]};return{...e,...v(this._config.popperConfig,[e])}}_setListeners(){const t=this._config.trigger.split(" ");for(const e of t)if("click"===e)j.on(this._element,this.constructor.eventName("click"),this._config.selector,(t=>{this._initializeOnDelegatedTarget(t).toggle()}));else if("manual"!==e){const t=e===Si?this.constructor.eventName("mouseenter"):this.constructor.eventName("focusin"),i=e===Si?this.constructor.eventName("mouseleave"):this.constructor.eventName("focusout");j.on(this._element,t,this._config.selector,(t=>{const e=this._initializeOnDelegatedTarget(t);e._activeTrigger["focusin"===t.type?Li:Si]=!0,e._enter()})),j.on(this._element,i,this._config.selector,(t=>{const e=this._initializeOnDelegatedTarget(t);e._activeTrigger["focusout"===t.type?Li:Si]=e._element.contains(t.relatedTarget),e._leave()}))}this._hideModalHandler=()=>{this._element&&this.hide()},j.on(this._element.closest(ki),$i,this._hideModalHandler)}_fixTitle(){const t=this._element.getAttribute("title");t&&(this._element.getAttribute("aria-label")||this._element.textContent.trim()||this._element.setAttribute("aria-label",t),this._element.setAttribute("data-bs-original-title",t),this._element.removeAttribute("title"))}_enter(){this._isShown()||this._isHovered?this._isHovered=!0:(this._isHovered=!0,this._setTimeout((()=>{this._isHovered&&this.show()}),this._config.delay.show))}_leave(){this._isWithActiveTrigger()||(this._isHovered=!1,this._setTimeout((()=>{this._isHovered||this.hide()}),this._config.delay.hide))}_setTimeout(t,e){clearTimeout(this._timeout),this._timeout=setTimeout(t,e)}_isWithActiveTrigger(){return Object.values(this._activeTrigger).includes(!0)}_getConfig(t){const e=B.getDataAttributes(this._element);for(const t of Object.keys(e))Ei.has(t)&&delete e[t];return t={...e,..."object"==typeof t&&t?t:{}},t=this._mergeConfigObj(t),t=this._configAfterMerge(t),this._typeCheckConfig(t),t}_configAfterMerge(t){return t.container=!1===t.container?document.body:c(t.container),"number"==typeof t.delay&&(t.delay={show:t.delay,hide:t.delay}),"number"==typeof t.title&&(t.title=t.title.toString()),"number"==typeof t.content&&(t.content=t.content.toString()),t}_getDelegateConfig(){const t={};for(const[e,i]of Object.entries(this._config))this.constructor.Default[e]!==i&&(t[e]=i);return t.selector=!1,t.trigger="manual",t}_disposePopper(){this._popper&&(this._popper.destroy(),this._popper=null),this.tip&&(this.tip.remove(),this.tip=null)}static jQueryInterface(t){return this.each((function(){const e=Ni.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t]()}}))}}b(Ni);const Pi={...Ni.Default,content:"",offset:[0,8],placement:"right",template:'<div class="popover" role="tooltip"><div class="popover-arrow"></div><h3 class="popover-header"></h3><div class="popover-body"></div></div>',trigger:"click"},xi={...Ni.DefaultType,content:"(null|string|element|function)"};class Mi extends Ni{static get Default(){return Pi}static get DefaultType(){return xi}static get NAME(){return"popover"}_isWithContent(){return this._getTitle()||this._getContent()}_getContentForTemplate(){return{".popover-header":this._getTitle(),".popover-body":this._getContent()}}_getContent(){return this._resolvePossibleFunction(this._config.content)}static jQueryInterface(t){return this.each((function(){const e=Mi.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t]()}}))}}b(Mi);const ji=".bs.scrollspy",Fi=`activate${ji}`,zi=`click${ji}`,Hi=`load${ji}.data-api`,Bi="active",qi="[href]",Wi=".nav-link",Ri=`${Wi}, .nav-item > ${Wi}, .list-group-item`,Ki={offset:null,rootMargin:"0px 0px -25%",smoothScroll:!1,target:null,threshold:[.1,.5,1]},Vi={offset:"(number|null)",rootMargin:"string",smoothScroll:"boolean",target:"element",threshold:"array"};class Qi extends W{constructor(t,e){super(t,e),this._targetLinks=new Map,this._observableSections=new Map,this._rootElement="visible"===getComputedStyle(this._element).overflowY?null:this._element,this._activeTarget=null,this._observer=null,this._previousScrollData={visibleEntryTop:0,parentScrollTop:0},this.refresh()}static get Default(){return Ki}static get DefaultType(){return Vi}static get NAME(){return"scrollspy"}refresh(){this._initializeTargetsAndObservables(),this._maybeEnableSmoothScroll(),this._observer?this._observer.disconnect():this._observer=this._getNewObserver();for(const t of this._observableSections.values())this._observer.observe(t)}dispose(){this._observer.disconnect(),super.dispose()}_configAfterMerge(t){return t.target=c(t.target)||document.body,t.rootMargin=t.offset?`${t.offset}px 0px -30%`:t.rootMargin,"string"==typeof t.threshold&&(t.threshold=t.threshold.split(",").map((t=>Number.parseFloat(t)))),t}_maybeEnableSmoothScroll(){this._config.smoothScroll&&(j.off(this._config.target,zi),j.on(this._config.target,zi,qi,(t=>{const e=this._observableSections.get(t.target.hash);if(e){t.preventDefault();const i=this._rootElement||window,s=e.offsetTop-this._element.offsetTop;if(i.scrollTo)return void i.scrollTo({top:s,behavior:"smooth"});i.scrollTop=s}})))}_getNewObserver(){const t={root:this._rootElement,threshold:this._config.threshold,rootMargin:this._config.rootMargin};return new IntersectionObserver((t=>this._observerCallback(t)),t)}_observerCallback(t){const e=t=>this._targetLinks.get(`#${t.target.id}`),i=t=>{this._previousScrollData.visibleEntryTop=t.target.offsetTop,this._process(e(t))},s=(this._rootElement||document.documentElement).scrollTop,n=s>=this._previousScrollData.parentScrollTop;this._previousScrollData.parentScrollTop=s;for(const o of t){if(!o.isIntersecting){this._activeTarget=null,this._clearActiveClass(e(o));continue}const t=o.target.offsetTop>=this._previousScrollData.visibleEntryTop;if(n&&t){if(i(o),!s)return}else n||t||i(o)}}_initializeTargetsAndObservables(){this._targetLinks=new Map,this._observableSections=new Map;const t=K.find(qi,this._config.target);for(const e of t){if(!e.hash||d(e))continue;const t=K.findOne(decodeURI(e.hash),this._element);h(t)&&(this._targetLinks.set(decodeURI(e.hash),e),this._observableSections.set(e.hash,t))}}_process(t){this._activeTarget!==t&&(this._clearActiveClass(this._config.target),this._activeTarget=t,t.classList.add(Bi),this._activateParents(t),j.trigger(this._element,Fi,{relatedTarget:t}))}_activateParents(t){if(t.classList.contains("dropdown-item"))K.findOne(".dropdown-toggle",t.closest(".dropdown")).classList.add(Bi);else for(const e of K.parents(t,".nav, .list-group"))for(const t of K.prev(e,Ri))t.classList.add(Bi)}_clearActiveClass(t){t.classList.remove(Bi);const e=K.find(`${qi}.${Bi}`,t);for(const t of e)t.classList.remove(Bi)}static jQueryInterface(t){return this.each((function(){const e=Qi.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t]||t.startsWith("_")||"constructor"===t)throw new TypeError(`No method named "${t}"`);e[t]()}}))}}j.on(window,Hi,(()=>{for(const t of K.find('[data-bs-spy="scroll"]'))Qi.getOrCreateInstance(t)})),b(Qi);const Xi=".bs.tab",Yi=`hide${Xi}`,Ui=`hidden${Xi}`,Gi=`show${Xi}`,Ji=`shown${Xi}`,Zi=`click${Xi}`,ts=`keydown${Xi}`,es=`load${Xi}`,is="ArrowLeft",ss="ArrowRight",ns="ArrowUp",os="ArrowDown",rs="Home",as="End",ls="active",cs="fade",hs="show",ds=".dropdown-toggle",us=`:not(${ds})`,_s='[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]',gs=`.nav-link${us}, .list-group-item${us}, [role="tab"]${us}, ${_s}`,fs=`.${ls}[data-bs-toggle="tab"], .${ls}[data-bs-toggle="pill"], .${ls}[data-bs-toggle="list"]`;class ms extends W{constructor(t){super(t),this._parent=this._element.closest('.list-group, .nav, [role="tablist"]'),this._parent&&(this._setInitialAttributes(this._parent,this._getChildren()),j.on(this._element,ts,(t=>this._keydown(t))))}static get NAME(){return"tab"}show(){const t=this._element;if(this._elemIsActive(t))return;const e=this._getActiveElem(),i=e?j.trigger(e,Yi,{relatedTarget:t}):null;j.trigger(t,Gi,{relatedTarget:e}).defaultPrevented||i&&i.defaultPrevented||(this._deactivate(e,t),this._activate(t,e))}_activate(t,e){t&&(t.classList.add(ls),this._activate(K.getElementFromSelector(t)),this._queueCallback((()=>{"tab"===t.getAttribute("role")?(t.removeAttribute("tabindex"),t.setAttribute("aria-selected",!0),this._toggleDropDown(t,!0),j.trigger(t,Ji,{relatedTarget:e})):t.classList.add(hs)}),t,t.classList.contains(cs)))}_deactivate(t,e){t&&(t.classList.remove(ls),t.blur(),this._deactivate(K.getElementFromSelector(t)),this._queueCallback((()=>{"tab"===t.getAttribute("role")?(t.setAttribute("aria-selected",!1),t.setAttribute("tabindex","-1"),this._toggleDropDown(t,!1),j.trigger(t,Ui,{relatedTarget:e})):t.classList.remove(hs)}),t,t.classList.contains(cs)))}_keydown(t){if(![is,ss,ns,os,rs,as].includes(t.key))return;t.stopPropagation(),t.preventDefault();const e=this._getChildren().filter((t=>!d(t)));let i;if([rs,as].includes(t.key))i=e[t.key===rs?0:e.length-1];else{const s=[ss,os].includes(t.key);i=w(e,t.target,s,!0)}i&&(i.focus({preventScroll:!0}),ms.getOrCreateInstance(i).show())}_getChildren(){return K.find(gs,this._parent)}_getActiveElem(){return this._getChildren().find((t=>this._elemIsActive(t)))||null}_setInitialAttributes(t,e){this._setAttributeIfNotExists(t,"role","tablist");for(const t of e)this._setInitialAttributesOnChild(t)}_setInitialAttributesOnChild(t){t=this._getInnerElement(t);const e=this._elemIsActive(t),i=this._getOuterElement(t);t.setAttribute("aria-selected",e),i!==t&&this._setAttributeIfNotExists(i,"role","presentation"),e||t.setAttribute("tabindex","-1"),this._setAttributeIfNotExists(t,"role","tab"),this._setInitialAttributesOnTargetPanel(t)}_setInitialAttributesOnTargetPanel(t){const e=K.getElementFromSelector(t);e&&(this._setAttributeIfNotExists(e,"role","tabpanel"),t.id&&this._setAttributeIfNotExists(e,"aria-labelledby",`${t.id}`))}_toggleDropDown(t,e){const i=this._getOuterElement(t);if(!i.classList.contains("dropdown"))return;const s=(t,s)=>{const n=K.findOne(t,i);n&&n.classList.toggle(s,e)};s(ds,ls),s(".dropdown-menu",hs),i.setAttribute("aria-expanded",e)}_setAttributeIfNotExists(t,e,i){t.hasAttribute(e)||t.setAttribute(e,i)}_elemIsActive(t){return t.classList.contains(ls)}_getInnerElement(t){return t.matches(gs)?t:K.findOne(gs,t)}_getOuterElement(t){return t.closest(".nav-item, .list-group-item")||t}static jQueryInterface(t){return this.each((function(){const e=ms.getOrCreateInstance(this);if("string"==typeof t){if(void 0===e[t]||t.startsWith("_")||"constructor"===t)throw new TypeError(`No method named "${t}"`);e[t]()}}))}}j.on(document,Zi,_s,(function(t){["A","AREA"].includes(this.tagName)&&t.preventDefault(),d(this)||ms.getOrCreateInstance(this).show()})),j.on(window,es,(()=>{for(const t of K.find(fs))ms.getOrCreateInstance(t)})),b(ms);const ps=".bs.toast",bs=`mouseover${ps}`,vs=`mouseout${ps}`,ys=`focusin${ps}`,ws=`focusout${ps}`,As=`hide${ps}`,Es=`hidden${ps}`,Cs=`show${ps}`,Ts=`shown${ps}`,ks="hide",$s="show",Ss="showing",Ls={animation:"boolean",autohide:"boolean",delay:"number"},Os={animation:!0,autohide:!0,delay:5e3};class Is extends W{constructor(t,e){super(t,e),this._timeout=null,this._hasMouseInteraction=!1,this._hasKeyboardInteraction=!1,this._setListeners()}static get Default(){return Os}static get DefaultType(){return Ls}static get NAME(){return"toast"}show(){j.trigger(this._element,Cs).defaultPrevented||(this._clearTimeout(),this._config.animation&&this._element.classList.add("fade"),this._element.classList.remove(ks),g(this._element),this._element.classList.add($s,Ss),this._queueCallback((()=>{this._element.classList.remove(Ss),j.trigger(this._element,Ts),this._maybeScheduleHide()}),this._element,this._config.animation))}hide(){this.isShown()&&(j.trigger(this._element,As).defaultPrevented||(this._element.classList.add(Ss),this._queueCallback((()=>{this._element.classList.add(ks),this._element.classList.remove(Ss,$s),j.trigger(this._element,Es)}),this._element,this._config.animation)))}dispose(){this._clearTimeout(),this.isShown()&&this._element.classList.remove($s),super.dispose()}isShown(){return this._element.classList.contains($s)}_maybeScheduleHide(){this._config.autohide&&(this._hasMouseInteraction||this._hasKeyboardInteraction||(this._timeout=setTimeout((()=>{this.hide()}),this._config.delay)))}_onInteraction(t,e){switch(t.type){case"mouseover":case"mouseout":this._hasMouseInteraction=e;break;case"focusin":case"focusout":this._hasKeyboardInteraction=e}if(e)return void this._clearTimeout();const i=t.relatedTarget;this._element===i||this._element.contains(i)||this._maybeScheduleHide()}_setListeners(){j.on(this._element,bs,(t=>this._onInteraction(t,!0))),j.on(this._element,vs,(t=>this._onInteraction(t,!1))),j.on(this._element,ys,(t=>this._onInteraction(t,!0))),j.on(this._element,ws,(t=>this._onInteraction(t,!1)))}_clearTimeout(){clearTimeout(this._timeout),this._timeout=null}static jQueryInterface(t){return this.each((function(){const e=Is.getOrCreateInstance(this,t);if("string"==typeof t){if(void 0===e[t])throw new TypeError(`No method named "${t}"`);e[t](this)}}))}}return V(Is),b(Is),{Alert:U,Button:J,Carousel:Ot,Collapse:Rt,Dropdown:fe,Modal:Ue,Offcanvas:gi,Popover:Mi,ScrollSpy:Qi,Tab:ms,Toast:Is,Tooltip:Ni}}));
+//# sourceMappingURL=bootstrap.min.js.map
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/breathe.css b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/breathe.css
new file mode 100644
index 0000000000000000000000000000000000000000..2a1534b0aedd5625352b8802fe4c9de761775225
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/breathe.css
@@ -0,0 +1,28 @@
+
+/* -- breathe specific styles ----------------------------------------------- */
+
+/* So enum value descriptions are displayed inline to the item */
+.breatheenumvalues li tt + p {
+  display: inline;
+}
+
+/* So parameter descriptions are displayed inline to the item */
+.breatheparameterlist li tt + p {
+  display: inline;
+}
+
+.container .breathe-sectiondef {
+  width: inherit;
+}
+
+.github-btn {
+  border: 0;
+  overflow: hidden;
+}
+
+.jumbotron {
+  background-size: 100% 4px;
+  background-repeat: repeat-y;
+  color: white;
+  text-align: center;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/fonts/glyphicons-halflings-regular.eot b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/fonts/glyphicons-halflings-regular.eot
new file mode 100644
index 0000000000000000000000000000000000000000..4a4ca865d67e86f961bc6e2ef00bffa4e34bb9ed
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/fonts/glyphicons-halflings-regular.eot differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/fonts/glyphicons-halflings-regular.svg b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/fonts/glyphicons-halflings-regular.svg
new file mode 100644
index 0000000000000000000000000000000000000000..e3e2dc739dd851f2d7d291be032e30b909e3e95f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/fonts/glyphicons-halflings-regular.svg
@@ -0,0 +1,229 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
+<svg xmlns="http://www.w3.org/2000/svg">
+<metadata></metadata>
+<defs>
+<font id="glyphicons_halflingsregular" horiz-adv-x="1200" >
+<font-face units-per-em="1200" ascent="960" descent="-240" />
+<missing-glyph horiz-adv-x="500" />
+<glyph />
+<glyph />
+<glyph unicode="&#xd;" />
+<glyph unicode=" " />
+<glyph unicode="*" d="M100 500v200h259l-183 183l141 141l183 -183v259h200v-259l183 183l141 -141l-183 -183h259v-200h-259l183 -183l-141 -141l-183 183v-259h-200v259l-183 -183l-141 141l183 183h-259z" />
+<glyph unicode="+" d="M0 400v300h400v400h300v-400h400v-300h-400v-400h-300v400h-400z" />
+<glyph unicode="&#xa0;" />
+<glyph unicode="&#x2000;" horiz-adv-x="652" />
+<glyph unicode="&#x2001;" horiz-adv-x="1304" />
+<glyph unicode="&#x2002;" horiz-adv-x="652" />
+<glyph unicode="&#x2003;" horiz-adv-x="1304" />
+<glyph unicode="&#x2004;" horiz-adv-x="434" />
+<glyph unicode="&#x2005;" horiz-adv-x="326" />
+<glyph unicode="&#x2006;" horiz-adv-x="217" />
+<glyph unicode="&#x2007;" horiz-adv-x="217" />
+<glyph unicode="&#x2008;" horiz-adv-x="163" />
+<glyph unicode="&#x2009;" horiz-adv-x="260" />
+<glyph unicode="&#x200a;" horiz-adv-x="72" />
+<glyph unicode="&#x202f;" horiz-adv-x="260" />
+<glyph unicode="&#x205f;" horiz-adv-x="326" />
+<glyph unicode="&#x20ac;" d="M100 500l100 100h113q0 47 5 100h-218l100 100h135q37 167 112 257q117 141 297 141q242 0 354 -189q60 -103 66 -209h-181q0 55 -25.5 99t-63.5 68t-75 36.5t-67 12.5q-24 0 -52.5 -10t-62.5 -32t-65.5 -67t-50.5 -107h379l-100 -100h-300q-6 -46 -6 -100h406l-100 -100 h-300q9 -74 33 -132t52.5 -91t62 -54.5t59 -29t46.5 -7.5q29 0 66 13t75 37t63.5 67.5t25.5 96.5h174q-31 -172 -128 -278q-107 -117 -274 -117q-205 0 -324 158q-36 46 -69 131.5t-45 205.5h-217z" />
+<glyph unicode="&#x2212;" d="M200 400h900v300h-900v-300z" />
+<glyph unicode="&#x25fc;" horiz-adv-x="500" d="M0 0z" />
+<glyph unicode="&#x2601;" d="M-14 494q0 -80 56.5 -137t135.5 -57h750q120 0 205 86.5t85 207.5t-85 207t-205 86q-46 0 -90 -14q-44 97 -134.5 156.5t-200.5 59.5q-152 0 -260 -107.5t-108 -260.5q0 -25 2 -37q-66 -14 -108.5 -67.5t-42.5 -122.5z" />
+<glyph unicode="&#x2709;" d="M0 100l400 400l200 -200l200 200l400 -400h-1200zM0 300v600l300 -300zM0 1100l600 -603l600 603h-1200zM900 600l300 300v-600z" />
+<glyph unicode="&#x270f;" d="M-13 -13l333 112l-223 223zM187 403l214 -214l614 614l-214 214zM887 1103l214 -214l99 92q13 13 13 32.5t-13 33.5l-153 153q-15 13 -33 13t-33 -13z" />
+<glyph unicode="&#xe001;" d="M0 1200h1200l-500 -550v-550h300v-100h-800v100h300v550z" />
+<glyph unicode="&#xe002;" d="M14 84q18 -55 86 -75.5t147 5.5q65 21 109 69t44 90v606l600 155v-521q-64 16 -138 -7q-79 -26 -122.5 -83t-25.5 -111q18 -55 86 -75.5t147 4.5q70 23 111.5 63.5t41.5 95.5v881q0 10 -7 15.5t-17 2.5l-752 -193q-10 -3 -17 -12.5t-7 -19.5v-689q-64 17 -138 -7 q-79 -25 -122.5 -82t-25.5 -112z" />
+<glyph unicode="&#xe003;" d="M23 693q0 200 142 342t342 142t342 -142t142 -342q0 -142 -78 -261l300 -300q7 -8 7 -18t-7 -18l-109 -109q-8 -7 -18 -7t-18 7l-300 300q-119 -78 -261 -78q-200 0 -342 142t-142 342zM176 693q0 -136 97 -233t234 -97t233.5 96.5t96.5 233.5t-96.5 233.5t-233.5 96.5 t-234 -97t-97 -233z" />
+<glyph unicode="&#xe005;" d="M100 784q0 64 28 123t73 100.5t104.5 64t119 20.5t120 -38.5t104.5 -104.5q48 69 109.5 105t121.5 38t118.5 -20.5t102.5 -64t71 -100.5t27 -123q0 -57 -33.5 -117.5t-94 -124.5t-126.5 -127.5t-150 -152.5t-146 -174q-62 85 -145.5 174t-149.5 152.5t-126.5 127.5 t-94 124.5t-33.5 117.5z" />
+<glyph unicode="&#xe006;" d="M-72 800h479l146 400h2l146 -400h472l-382 -278l145 -449l-384 275l-382 -275l146 447zM168 71l2 1z" />
+<glyph unicode="&#xe007;" d="M-72 800h479l146 400h2l146 -400h472l-382 -278l145 -449l-384 275l-382 -275l146 447zM168 71l2 1zM237 700l196 -142l-73 -226l192 140l195 -141l-74 229l193 140h-235l-77 211l-78 -211h-239z" />
+<glyph unicode="&#xe008;" d="M0 0v143l400 257v100q-37 0 -68.5 74.5t-31.5 125.5v200q0 124 88 212t212 88t212 -88t88 -212v-200q0 -51 -31.5 -125.5t-68.5 -74.5v-100l400 -257v-143h-1200z" />
+<glyph unicode="&#xe009;" d="M0 0v1100h1200v-1100h-1200zM100 100h100v100h-100v-100zM100 300h100v100h-100v-100zM100 500h100v100h-100v-100zM100 700h100v100h-100v-100zM100 900h100v100h-100v-100zM300 100h600v400h-600v-400zM300 600h600v400h-600v-400zM1000 100h100v100h-100v-100z M1000 300h100v100h-100v-100zM1000 500h100v100h-100v-100zM1000 700h100v100h-100v-100zM1000 900h100v100h-100v-100z" />
+<glyph unicode="&#xe010;" d="M0 50v400q0 21 14.5 35.5t35.5 14.5h400q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-400q-21 0 -35.5 14.5t-14.5 35.5zM0 650v400q0 21 14.5 35.5t35.5 14.5h400q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-400 q-21 0 -35.5 14.5t-14.5 35.5zM600 50v400q0 21 14.5 35.5t35.5 14.5h400q21 0 35.5 -14.5t14.5 -35.5v-400q0 -21 -14.5 -35.5t-35.5 -14.5h-400q-21 0 -35.5 14.5t-14.5 35.5zM600 650v400q0 21 14.5 35.5t35.5 14.5h400q21 0 35.5 -14.5t14.5 -35.5v-400 q0 -21 -14.5 -35.5t-35.5 -14.5h-400q-21 0 -35.5 14.5t-14.5 35.5z" />
+<glyph unicode="&#xe011;" d="M0 50v200q0 21 14.5 35.5t35.5 14.5h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5zM0 450v200q0 21 14.5 35.5t35.5 14.5h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200 q-21 0 -35.5 14.5t-14.5 35.5zM0 850v200q0 21 14.5 35.5t35.5 14.5h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5zM400 50v200q0 21 14.5 35.5t35.5 14.5h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5 t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5zM400 450v200q0 21 14.5 35.5t35.5 14.5h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5zM400 850v200q0 21 14.5 35.5t35.5 14.5h200q21 0 35.5 -14.5t14.5 -35.5 v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5zM800 50v200q0 21 14.5 35.5t35.5 14.5h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5zM800 450v200q0 21 14.5 35.5t35.5 14.5h200 q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5zM800 850v200q0 21 14.5 35.5t35.5 14.5h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5z" />
+<glyph unicode="&#xe012;" d="M0 50v200q0 21 14.5 35.5t35.5 14.5h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5zM0 450q0 -21 14.5 -35.5t35.5 -14.5h200q21 0 35.5 14.5t14.5 35.5v200q0 21 -14.5 35.5t-35.5 14.5h-200q-21 0 -35.5 -14.5 t-14.5 -35.5v-200zM0 850v200q0 21 14.5 35.5t35.5 14.5h200q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5zM400 50v200q0 21 14.5 35.5t35.5 14.5h700q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5 t-35.5 -14.5h-700q-21 0 -35.5 14.5t-14.5 35.5zM400 450v200q0 21 14.5 35.5t35.5 14.5h700q21 0 35.5 -14.5t14.5 -35.5v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-700q-21 0 -35.5 14.5t-14.5 35.5zM400 850v200q0 21 14.5 35.5t35.5 14.5h700q21 0 35.5 -14.5t14.5 -35.5 v-200q0 -21 -14.5 -35.5t-35.5 -14.5h-700q-21 0 -35.5 14.5t-14.5 35.5z" />
+<glyph unicode="&#xe013;" d="M29 454l419 -420l818 820l-212 212l-607 -607l-206 207z" />
+<glyph unicode="&#xe014;" d="M106 318l282 282l-282 282l212 212l282 -282l282 282l212 -212l-282 -282l282 -282l-212 -212l-282 282l-282 -282z" />
+<glyph unicode="&#xe015;" d="M23 693q0 200 142 342t342 142t342 -142t142 -342q0 -142 -78 -261l300 -300q7 -8 7 -18t-7 -18l-109 -109q-8 -7 -18 -7t-18 7l-300 300q-119 -78 -261 -78q-200 0 -342 142t-142 342zM176 693q0 -136 97 -233t234 -97t233.5 96.5t96.5 233.5t-96.5 233.5t-233.5 96.5 t-234 -97t-97 -233zM300 600v200h100v100h200v-100h100v-200h-100v-100h-200v100h-100z" />
+<glyph unicode="&#xe016;" d="M23 694q0 200 142 342t342 142t342 -142t142 -342q0 -141 -78 -262l300 -299q7 -7 7 -18t-7 -18l-109 -109q-8 -8 -18 -8t-18 8l-300 300q-119 -78 -261 -78q-200 0 -342 142t-142 342zM176 694q0 -136 97 -233t234 -97t233.5 97t96.5 233t-96.5 233t-233.5 97t-234 -97 t-97 -233zM300 601h400v200h-400v-200z" />
+<glyph unicode="&#xe017;" d="M23 600q0 183 105 331t272 210v-166q-103 -55 -165 -155t-62 -220q0 -177 125 -302t302 -125t302 125t125 302q0 120 -62 220t-165 155v166q167 -62 272 -210t105 -331q0 -118 -45.5 -224.5t-123 -184t-184 -123t-224.5 -45.5t-224.5 45.5t-184 123t-123 184t-45.5 224.5 zM500 750q0 -21 14.5 -35.5t35.5 -14.5h100q21 0 35.5 14.5t14.5 35.5v400q0 21 -14.5 35.5t-35.5 14.5h-100q-21 0 -35.5 -14.5t-14.5 -35.5v-400z" />
+<glyph unicode="&#xe018;" d="M100 1h200v300h-200v-300zM400 1v500h200v-500h-200zM700 1v800h200v-800h-200zM1000 1v1200h200v-1200h-200z" />
+<glyph unicode="&#xe019;" d="M26 601q0 -33 6 -74l151 -38l2 -6q14 -49 38 -93l3 -5l-80 -134q45 -59 105 -105l133 81l5 -3q45 -26 94 -39l5 -2l38 -151q40 -5 74 -5q27 0 74 5l38 151l6 2q46 13 93 39l5 3l134 -81q56 44 104 105l-80 134l3 5q24 44 39 93l1 6l152 38q5 40 5 74q0 28 -5 73l-152 38 l-1 6q-16 51 -39 93l-3 5l80 134q-44 58 -104 105l-134 -81l-5 3q-45 25 -93 39l-6 1l-38 152q-40 5 -74 5q-27 0 -74 -5l-38 -152l-5 -1q-50 -14 -94 -39l-5 -3l-133 81q-59 -47 -105 -105l80 -134l-3 -5q-25 -47 -38 -93l-2 -6l-151 -38q-6 -48 -6 -73zM385 601 q0 88 63 151t152 63t152 -63t63 -151q0 -89 -63 -152t-152 -63t-152 63t-63 152z" />
+<glyph unicode="&#xe020;" d="M100 1025v50q0 10 7.5 17.5t17.5 7.5h275v100q0 41 29.5 70.5t70.5 29.5h300q41 0 70.5 -29.5t29.5 -70.5v-100h275q10 0 17.5 -7.5t7.5 -17.5v-50q0 -11 -7 -18t-18 -7h-1050q-11 0 -18 7t-7 18zM200 100v800h900v-800q0 -41 -29.5 -71t-70.5 -30h-700q-41 0 -70.5 30 t-29.5 71zM300 100h100v700h-100v-700zM500 100h100v700h-100v-700zM500 1100h300v100h-300v-100zM700 100h100v700h-100v-700zM900 100h100v700h-100v-700z" />
+<glyph unicode="&#xe021;" d="M1 601l656 644l644 -644h-200v-600h-300v400h-300v-400h-300v600h-200z" />
+<glyph unicode="&#xe022;" d="M100 25v1150q0 11 7 18t18 7h475v-500h400v-675q0 -11 -7 -18t-18 -7h-850q-11 0 -18 7t-7 18zM700 800v300l300 -300h-300z" />
+<glyph unicode="&#xe023;" d="M4 600q0 162 80 299t217 217t299 80t299 -80t217 -217t80 -299t-80 -299t-217 -217t-299 -80t-299 80t-217 217t-80 299zM186 600q0 -171 121.5 -292.5t292.5 -121.5t292.5 121.5t121.5 292.5t-121.5 292.5t-292.5 121.5t-292.5 -121.5t-121.5 -292.5zM500 500v400h100 v-300h200v-100h-300z" />
+<glyph unicode="&#xe024;" d="M-100 0l431 1200h209l-21 -300h162l-20 300h208l431 -1200h-538l-41 400h-242l-40 -400h-539zM488 500h224l-27 300h-170z" />
+<glyph unicode="&#xe025;" d="M0 0v400h490l-290 300h200v500h300v-500h200l-290 -300h490v-400h-1100zM813 200h175v100h-175v-100z" />
+<glyph unicode="&#xe026;" d="M1 600q0 122 47.5 233t127.5 191t191 127.5t233 47.5t233 -47.5t191 -127.5t127.5 -191t47.5 -233t-47.5 -233t-127.5 -191t-191 -127.5t-233 -47.5t-233 47.5t-191 127.5t-127.5 191t-47.5 233zM188 600q0 -170 121 -291t291 -121t291 121t121 291t-121 291t-291 121 t-291 -121t-121 -291zM350 600h150v300h200v-300h150l-250 -300z" />
+<glyph unicode="&#xe027;" d="M4 600q0 162 80 299t217 217t299 80t299 -80t217 -217t80 -299t-80 -299t-217 -217t-299 -80t-299 80t-217 217t-80 299zM186 600q0 -171 121.5 -292.5t292.5 -121.5t292.5 121.5t121.5 292.5t-121.5 292.5t-292.5 121.5t-292.5 -121.5t-121.5 -292.5zM350 600l250 300 l250 -300h-150v-300h-200v300h-150z" />
+<glyph unicode="&#xe028;" d="M0 25v475l200 700h800l199 -700l1 -475q0 -11 -7 -18t-18 -7h-1150q-11 0 -18 7t-7 18zM200 500h200l50 -200h300l50 200h200l-97 500h-606z" />
+<glyph unicode="&#xe029;" d="M4 600q0 162 80 299t217 217t299 80t299 -80t217 -217t80 -299t-80 -299t-217 -217t-299 -80t-299 80t-217 217t-80 299zM186 600q0 -172 121.5 -293t292.5 -121t292.5 121t121.5 293q0 171 -121.5 292.5t-292.5 121.5t-292.5 -121.5t-121.5 -292.5zM500 397v401 l297 -200z" />
+<glyph unicode="&#xe030;" d="M23 600q0 -118 45.5 -224.5t123 -184t184 -123t224.5 -45.5t224.5 45.5t184 123t123 184t45.5 224.5h-150q0 -177 -125 -302t-302 -125t-302 125t-125 302t125 302t302 125q136 0 246 -81l-146 -146h400v400l-145 -145q-157 122 -355 122q-118 0 -224.5 -45.5t-184 -123 t-123 -184t-45.5 -224.5z" />
+<glyph unicode="&#xe031;" d="M23 600q0 118 45.5 224.5t123 184t184 123t224.5 45.5q198 0 355 -122l145 145v-400h-400l147 147q-112 80 -247 80q-177 0 -302 -125t-125 -302h-150zM100 0v400h400l-147 -147q112 -80 247 -80q177 0 302 125t125 302h150q0 -118 -45.5 -224.5t-123 -184t-184 -123 t-224.5 -45.5q-198 0 -355 122z" />
+<glyph unicode="&#xe032;" d="M100 0h1100v1200h-1100v-1200zM200 100v900h900v-900h-900zM300 200v100h100v-100h-100zM300 400v100h100v-100h-100zM300 600v100h100v-100h-100zM300 800v100h100v-100h-100zM500 200h500v100h-500v-100zM500 400v100h500v-100h-500zM500 600v100h500v-100h-500z M500 800v100h500v-100h-500z" />
+<glyph unicode="&#xe033;" d="M0 100v600q0 41 29.5 70.5t70.5 29.5h100v200q0 82 59 141t141 59h300q82 0 141 -59t59 -141v-200h100q41 0 70.5 -29.5t29.5 -70.5v-600q0 -41 -29.5 -70.5t-70.5 -29.5h-900q-41 0 -70.5 29.5t-29.5 70.5zM400 800h300v150q0 21 -14.5 35.5t-35.5 14.5h-200 q-21 0 -35.5 -14.5t-14.5 -35.5v-150z" />
+<glyph unicode="&#xe034;" d="M100 0v1100h100v-1100h-100zM300 400q60 60 127.5 84t127.5 17.5t122 -23t119 -30t110 -11t103 42t91 120.5v500q-40 -81 -101.5 -115.5t-127.5 -29.5t-138 25t-139.5 40t-125.5 25t-103 -29.5t-65 -115.5v-500z" />
+<glyph unicode="&#xe035;" d="M0 275q0 -11 7 -18t18 -7h50q11 0 18 7t7 18v300q0 127 70.5 231.5t184.5 161.5t245 57t245 -57t184.5 -161.5t70.5 -231.5v-300q0 -11 7 -18t18 -7h50q11 0 18 7t7 18v300q0 116 -49.5 227t-131 192.5t-192.5 131t-227 49.5t-227 -49.5t-192.5 -131t-131 -192.5 t-49.5 -227v-300zM200 20v460q0 8 6 14t14 6h160q8 0 14 -6t6 -14v-460q0 -8 -6 -14t-14 -6h-160q-8 0 -14 6t-6 14zM800 20v460q0 8 6 14t14 6h160q8 0 14 -6t6 -14v-460q0 -8 -6 -14t-14 -6h-160q-8 0 -14 6t-6 14z" />
+<glyph unicode="&#xe036;" d="M0 400h300l300 -200v800l-300 -200h-300v-400zM688 459l141 141l-141 141l71 71l141 -141l141 141l71 -71l-141 -141l141 -141l-71 -71l-141 141l-141 -141z" />
+<glyph unicode="&#xe037;" d="M0 400h300l300 -200v800l-300 -200h-300v-400zM700 857l69 53q111 -135 111 -310q0 -169 -106 -302l-67 54q86 110 86 248q0 146 -93 257z" />
+<glyph unicode="&#xe038;" d="M0 401v400h300l300 200v-800l-300 200h-300zM702 858l69 53q111 -135 111 -310q0 -170 -106 -303l-67 55q86 110 86 248q0 145 -93 257zM889 951l7 -8q123 -151 123 -344q0 -189 -119 -339l-7 -8l81 -66l6 8q142 178 142 405q0 230 -144 408l-6 8z" />
+<glyph unicode="&#xe039;" d="M0 0h500v500h-200v100h-100v-100h-200v-500zM0 600h100v100h400v100h100v100h-100v300h-500v-600zM100 100v300h300v-300h-300zM100 800v300h300v-300h-300zM200 200v100h100v-100h-100zM200 900h100v100h-100v-100zM500 500v100h300v-300h200v-100h-100v-100h-200v100 h-100v100h100v200h-200zM600 0v100h100v-100h-100zM600 1000h100v-300h200v-300h300v200h-200v100h200v500h-600v-200zM800 800v300h300v-300h-300zM900 0v100h300v-100h-300zM900 900v100h100v-100h-100zM1100 200v100h100v-100h-100z" />
+<glyph unicode="&#xe040;" d="M0 200h100v1000h-100v-1000zM100 0v100h300v-100h-300zM200 200v1000h100v-1000h-100zM500 0v91h100v-91h-100zM500 200v1000h200v-1000h-200zM700 0v91h100v-91h-100zM800 200v1000h100v-1000h-100zM900 0v91h200v-91h-200zM1000 200v1000h200v-1000h-200z" />
+<glyph unicode="&#xe041;" d="M0 700l1 475q0 10 7.5 17.5t17.5 7.5h474l700 -700l-500 -500zM148 953q0 -42 29 -71q30 -30 71.5 -30t71.5 30q29 29 29 71t-29 71q-30 30 -71.5 30t-71.5 -30q-29 -29 -29 -71z" />
+<glyph unicode="&#xe042;" d="M1 700l1 475q0 11 7 18t18 7h474l700 -700l-500 -500zM148 953q0 -42 30 -71q29 -30 71 -30t71 30q30 29 30 71t-30 71q-29 30 -71 30t-71 -30q-30 -29 -30 -71zM701 1200h100l700 -700l-500 -500l-50 50l450 450z" />
+<glyph unicode="&#xe043;" d="M100 0v1025l175 175h925v-1000l-100 -100v1000h-750l-100 -100h750v-1000h-900z" />
+<glyph unicode="&#xe044;" d="M200 0l450 444l450 -443v1150q0 20 -14.5 35t-35.5 15h-800q-21 0 -35.5 -15t-14.5 -35v-1151z" />
+<glyph unicode="&#xe045;" d="M0 100v700h200l100 -200h600l100 200h200v-700h-200v200h-800v-200h-200zM253 829l40 -124h592l62 124l-94 346q-2 11 -10 18t-18 7h-450q-10 0 -18 -7t-10 -18zM281 24l38 152q2 10 11.5 17t19.5 7h500q10 0 19.5 -7t11.5 -17l38 -152q2 -10 -3.5 -17t-15.5 -7h-600 q-10 0 -15.5 7t-3.5 17z" />
+<glyph unicode="&#xe046;" d="M0 200q0 -41 29.5 -70.5t70.5 -29.5h1000q41 0 70.5 29.5t29.5 70.5v600q0 41 -29.5 70.5t-70.5 29.5h-150q-4 8 -11.5 21.5t-33 48t-53 61t-69 48t-83.5 21.5h-200q-41 0 -82 -20.5t-70 -50t-52 -59t-34 -50.5l-12 -20h-150q-41 0 -70.5 -29.5t-29.5 -70.5v-600z M356 500q0 100 72 172t172 72t172 -72t72 -172t-72 -172t-172 -72t-172 72t-72 172zM494 500q0 -44 31 -75t75 -31t75 31t31 75t-31 75t-75 31t-75 -31t-31 -75zM900 700v100h100v-100h-100z" />
+<glyph unicode="&#xe047;" d="M53 0h365v66q-41 0 -72 11t-49 38t1 71l92 234h391l82 -222q16 -45 -5.5 -88.5t-74.5 -43.5v-66h417v66q-34 1 -74 43q-18 19 -33 42t-21 37l-6 13l-385 998h-93l-399 -1006q-24 -48 -52 -75q-12 -12 -33 -25t-36 -20l-15 -7v-66zM416 521l178 457l46 -140l116 -317h-340 z" />
+<glyph unicode="&#xe048;" d="M100 0v89q41 7 70.5 32.5t29.5 65.5v827q0 28 -1 39.5t-5.5 26t-15.5 21t-29 14t-49 14.5v71l471 -1q120 0 213 -88t93 -228q0 -55 -11.5 -101.5t-28 -74t-33.5 -47.5t-28 -28l-12 -7q8 -3 21.5 -9t48 -31.5t60.5 -58t47.5 -91.5t21.5 -129q0 -84 -59 -156.5t-142 -111 t-162 -38.5h-500zM400 200h161q89 0 153 48.5t64 132.5q0 90 -62.5 154.5t-156.5 64.5h-159v-400zM400 700h139q76 0 130 61.5t54 138.5q0 82 -84 130.5t-239 48.5v-379z" />
+<glyph unicode="&#xe049;" d="M200 0v57q77 7 134.5 40.5t65.5 80.5l173 849q10 56 -10 74t-91 37q-6 1 -10.5 2.5t-9.5 2.5v57h425l2 -57q-33 -8 -62 -25.5t-46 -37t-29.5 -38t-17.5 -30.5l-5 -12l-128 -825q-10 -52 14 -82t95 -36v-57h-500z" />
+<glyph unicode="&#xe050;" d="M-75 200h75v800h-75l125 167l125 -167h-75v-800h75l-125 -167zM300 900v300h150h700h150v-300h-50q0 29 -8 48.5t-18.5 30t-33.5 15t-39.5 5.5t-50.5 1h-200v-850l100 -50v-100h-400v100l100 50v850h-200q-34 0 -50.5 -1t-40 -5.5t-33.5 -15t-18.5 -30t-8.5 -48.5h-49z " />
+<glyph unicode="&#xe051;" d="M33 51l167 125v-75h800v75l167 -125l-167 -125v75h-800v-75zM100 901v300h150h700h150v-300h-50q0 29 -8 48.5t-18 30t-33.5 15t-40 5.5t-50.5 1h-200v-650l100 -50v-100h-400v100l100 50v650h-200q-34 0 -50.5 -1t-39.5 -5.5t-33.5 -15t-18.5 -30t-8 -48.5h-50z" />
+<glyph unicode="&#xe052;" d="M0 50q0 -20 14.5 -35t35.5 -15h1100q21 0 35.5 15t14.5 35v100q0 21 -14.5 35.5t-35.5 14.5h-1100q-21 0 -35.5 -14.5t-14.5 -35.5v-100zM0 350q0 -20 14.5 -35t35.5 -15h800q21 0 35.5 15t14.5 35v100q0 21 -14.5 35.5t-35.5 14.5h-800q-21 0 -35.5 -14.5t-14.5 -35.5 v-100zM0 650q0 -20 14.5 -35t35.5 -15h1000q21 0 35.5 15t14.5 35v100q0 21 -14.5 35.5t-35.5 14.5h-1000q-21 0 -35.5 -14.5t-14.5 -35.5v-100zM0 950q0 -20 14.5 -35t35.5 -15h600q21 0 35.5 15t14.5 35v100q0 21 -14.5 35.5t-35.5 14.5h-600q-21 0 -35.5 -14.5 t-14.5 -35.5v-100z" />
+<glyph unicode="&#xe053;" d="M0 50q0 -20 14.5 -35t35.5 -15h1100q21 0 35.5 15t14.5 35v100q0 21 -14.5 35.5t-35.5 14.5h-1100q-21 0 -35.5 -14.5t-14.5 -35.5v-100zM0 650q0 -20 14.5 -35t35.5 -15h1100q21 0 35.5 15t14.5 35v100q0 21 -14.5 35.5t-35.5 14.5h-1100q-21 0 -35.5 -14.5t-14.5 -35.5 v-100zM200 350q0 -20 14.5 -35t35.5 -15h700q21 0 35.5 15t14.5 35v100q0 21 -14.5 35.5t-35.5 14.5h-700q-21 0 -35.5 -14.5t-14.5 -35.5v-100zM200 950q0 -20 14.5 -35t35.5 -15h700q21 0 35.5 15t14.5 35v100q0 21 -14.5 35.5t-35.5 14.5h-700q-21 0 -35.5 -14.5 t-14.5 -35.5v-100z" />
+<glyph unicode="&#xe054;" d="M0 50v100q0 21 14.5 35.5t35.5 14.5h1100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-1100q-21 0 -35.5 15t-14.5 35zM100 650v100q0 21 14.5 35.5t35.5 14.5h1000q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-1000q-21 0 -35.5 15 t-14.5 35zM300 350v100q0 21 14.5 35.5t35.5 14.5h800q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-800q-21 0 -35.5 15t-14.5 35zM500 950v100q0 21 14.5 35.5t35.5 14.5h600q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-600 q-21 0 -35.5 15t-14.5 35z" />
+<glyph unicode="&#xe055;" d="M0 50v100q0 21 14.5 35.5t35.5 14.5h1100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-1100q-21 0 -35.5 15t-14.5 35zM0 350v100q0 21 14.5 35.5t35.5 14.5h1100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-1100q-21 0 -35.5 15 t-14.5 35zM0 650v100q0 21 14.5 35.5t35.5 14.5h1100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-1100q-21 0 -35.5 15t-14.5 35zM0 950v100q0 21 14.5 35.5t35.5 14.5h1100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-1100 q-21 0 -35.5 15t-14.5 35z" />
+<glyph unicode="&#xe056;" d="M0 50v100q0 21 14.5 35.5t35.5 14.5h100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-100q-21 0 -35.5 15t-14.5 35zM0 350v100q0 21 14.5 35.5t35.5 14.5h100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-100q-21 0 -35.5 15 t-14.5 35zM0 650v100q0 21 14.5 35.5t35.5 14.5h100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-100q-21 0 -35.5 15t-14.5 35zM0 950v100q0 21 14.5 35.5t35.5 14.5h100q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-100q-21 0 -35.5 15 t-14.5 35zM300 50v100q0 21 14.5 35.5t35.5 14.5h800q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-800q-21 0 -35.5 15t-14.5 35zM300 350v100q0 21 14.5 35.5t35.5 14.5h800q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-800 q-21 0 -35.5 15t-14.5 35zM300 650v100q0 21 14.5 35.5t35.5 14.5h800q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15h-800q-21 0 -35.5 15t-14.5 35zM300 950v100q0 21 14.5 35.5t35.5 14.5h800q21 0 35.5 -14.5t14.5 -35.5v-100q0 -20 -14.5 -35t-35.5 -15 h-800q-21 0 -35.5 15t-14.5 35z" />
+<glyph unicode="&#xe057;" d="M-101 500v100h201v75l166 -125l-166 -125v75h-201zM300 0h100v1100h-100v-1100zM500 50q0 -20 14.5 -35t35.5 -15h600q20 0 35 15t15 35v100q0 21 -15 35.5t-35 14.5h-600q-21 0 -35.5 -14.5t-14.5 -35.5v-100zM500 350q0 -20 14.5 -35t35.5 -15h300q20 0 35 15t15 35 v100q0 21 -15 35.5t-35 14.5h-300q-21 0 -35.5 -14.5t-14.5 -35.5v-100zM500 650q0 -20 14.5 -35t35.5 -15h500q20 0 35 15t15 35v100q0 21 -15 35.5t-35 14.5h-500q-21 0 -35.5 -14.5t-14.5 -35.5v-100zM500 950q0 -20 14.5 -35t35.5 -15h100q20 0 35 15t15 35v100 q0 21 -15 35.5t-35 14.5h-100q-21 0 -35.5 -14.5t-14.5 -35.5v-100z" />
+<glyph unicode="&#xe058;" d="M1 50q0 -20 14.5 -35t35.5 -15h600q20 0 35 15t15 35v100q0 21 -15 35.5t-35 14.5h-600q-21 0 -35.5 -14.5t-14.5 -35.5v-100zM1 350q0 -20 14.5 -35t35.5 -15h300q20 0 35 15t15 35v100q0 21 -15 35.5t-35 14.5h-300q-21 0 -35.5 -14.5t-14.5 -35.5v-100zM1 650 q0 -20 14.5 -35t35.5 -15h500q20 0 35 15t15 35v100q0 21 -15 35.5t-35 14.5h-500q-21 0 -35.5 -14.5t-14.5 -35.5v-100zM1 950q0 -20 14.5 -35t35.5 -15h100q20 0 35 15t15 35v100q0 21 -15 35.5t-35 14.5h-100q-21 0 -35.5 -14.5t-14.5 -35.5v-100zM801 0v1100h100v-1100 h-100zM934 550l167 -125v75h200v100h-200v75z" />
+<glyph unicode="&#xe059;" d="M0 275v650q0 31 22 53t53 22h750q31 0 53 -22t22 -53v-650q0 -31 -22 -53t-53 -22h-750q-31 0 -53 22t-22 53zM900 600l300 300v-600z" />
+<glyph unicode="&#xe060;" d="M0 44v1012q0 18 13 31t31 13h1112q19 0 31.5 -13t12.5 -31v-1012q0 -18 -12.5 -31t-31.5 -13h-1112q-18 0 -31 13t-13 31zM100 263l247 182l298 -131l-74 156l293 318l236 -288v500h-1000v-737zM208 750q0 56 39 95t95 39t95 -39t39 -95t-39 -95t-95 -39t-95 39t-39 95z " />
+<glyph unicode="&#xe062;" d="M148 745q0 124 60.5 231.5t165 172t226.5 64.5q123 0 227 -63t164.5 -169.5t60.5 -229.5t-73 -272q-73 -114 -166.5 -237t-150.5 -189l-57 -66q-10 9 -27 26t-66.5 70.5t-96 109t-104 135.5t-100.5 155q-63 139 -63 262zM342 772q0 -107 75.5 -182.5t181.5 -75.5 q107 0 182.5 75.5t75.5 182.5t-75.5 182t-182.5 75t-182 -75.5t-75 -181.5z" />
+<glyph unicode="&#xe063;" d="M1 600q0 122 47.5 233t127.5 191t191 127.5t233 47.5t233 -47.5t191 -127.5t127.5 -191t47.5 -233t-47.5 -233t-127.5 -191t-191 -127.5t-233 -47.5t-233 47.5t-191 127.5t-127.5 191t-47.5 233zM173 600q0 -177 125.5 -302t301.5 -125v854q-176 0 -301.5 -125 t-125.5 -302z" />
+<glyph unicode="&#xe064;" d="M117 406q0 94 34 186t88.5 172.5t112 159t115 177t87.5 194.5q21 -71 57.5 -142.5t76 -130.5t83 -118.5t82 -117t70 -116t50 -125.5t18.5 -136q0 -89 -39 -165.5t-102 -126.5t-140 -79.5t-156 -33.5q-114 6 -211.5 53t-161.5 139t-64 210zM243 414q14 -82 59.5 -136 t136.5 -80l16 98q-7 6 -18 17t-34 48t-33 77q-15 73 -14 143.5t10 122.5l9 51q-92 -110 -119.5 -185t-12.5 -156z" />
+<glyph unicode="&#xe065;" d="M0 400v300q0 165 117.5 282.5t282.5 117.5q366 -6 397 -14l-186 -186h-311q-41 0 -70.5 -29.5t-29.5 -70.5v-500q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5v125l200 200v-225q0 -165 -117.5 -282.5t-282.5 -117.5h-300q-165 0 -282.5 117.5 t-117.5 282.5zM436 341l161 50l412 412l-114 113l-405 -405zM995 1015l113 -113l113 113l-21 85l-92 28z" />
+<glyph unicode="&#xe066;" d="M0 400v300q0 165 117.5 282.5t282.5 117.5h261l2 -80q-133 -32 -218 -120h-145q-41 0 -70.5 -29.5t-29.5 -70.5v-500q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5l200 153v-53q0 -165 -117.5 -282.5t-282.5 -117.5h-300q-165 0 -282.5 117.5t-117.5 282.5 zM423 524q30 38 81.5 64t103 35.5t99 14t77.5 3.5l29 -1v-209l360 324l-359 318v-216q-7 0 -19 -1t-48 -8t-69.5 -18.5t-76.5 -37t-76.5 -59t-62 -88t-39.5 -121.5z" />
+<glyph unicode="&#xe067;" d="M0 400v300q0 165 117.5 282.5t282.5 117.5h300q61 0 127 -23l-178 -177h-349q-41 0 -70.5 -29.5t-29.5 -70.5v-500q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5v69l200 200v-169q0 -165 -117.5 -282.5t-282.5 -117.5h-300q-165 0 -282.5 117.5 t-117.5 282.5zM342 632l283 -284l567 567l-137 137l-430 -431l-146 147z" />
+<glyph unicode="&#xe068;" d="M0 603l300 296v-198h200v200h-200l300 300l295 -300h-195v-200h200v198l300 -296l-300 -300v198h-200v-200h195l-295 -300l-300 300h200v200h-200v-198z" />
+<glyph unicode="&#xe069;" d="M200 50v1000q0 21 14.5 35.5t35.5 14.5h100q21 0 35.5 -14.5t14.5 -35.5v-437l500 487v-1100l-500 488v-438q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5z" />
+<glyph unicode="&#xe070;" d="M0 50v1000q0 21 14.5 35.5t35.5 14.5h100q21 0 35.5 -14.5t14.5 -35.5v-437l500 487v-487l500 487v-1100l-500 488v-488l-500 488v-438q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5z" />
+<glyph unicode="&#xe071;" d="M136 550l564 550v-487l500 487v-1100l-500 488v-488z" />
+<glyph unicode="&#xe072;" d="M200 0l900 550l-900 550v-1100z" />
+<glyph unicode="&#xe073;" d="M200 150q0 -21 14.5 -35.5t35.5 -14.5h200q21 0 35.5 14.5t14.5 35.5v800q0 21 -14.5 35.5t-35.5 14.5h-200q-21 0 -35.5 -14.5t-14.5 -35.5v-800zM600 150q0 -21 14.5 -35.5t35.5 -14.5h200q21 0 35.5 14.5t14.5 35.5v800q0 21 -14.5 35.5t-35.5 14.5h-200 q-21 0 -35.5 -14.5t-14.5 -35.5v-800z" />
+<glyph unicode="&#xe074;" d="M200 150q0 -20 14.5 -35t35.5 -15h800q21 0 35.5 15t14.5 35v800q0 21 -14.5 35.5t-35.5 14.5h-800q-21 0 -35.5 -14.5t-14.5 -35.5v-800z" />
+<glyph unicode="&#xe075;" d="M0 0v1100l500 -487v487l564 -550l-564 -550v488z" />
+<glyph unicode="&#xe076;" d="M0 0v1100l500 -487v487l500 -487v437q0 21 14.5 35.5t35.5 14.5h100q21 0 35.5 -14.5t14.5 -35.5v-1000q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v438l-500 -488v488z" />
+<glyph unicode="&#xe077;" d="M300 0v1100l500 -487v437q0 21 14.5 35.5t35.5 14.5h100q21 0 35.5 -14.5t14.5 -35.5v-1000q0 -21 -14.5 -35.5t-35.5 -14.5h-100q-21 0 -35.5 14.5t-14.5 35.5v438z" />
+<glyph unicode="&#xe078;" d="M100 250v100q0 21 14.5 35.5t35.5 14.5h1000q21 0 35.5 -14.5t14.5 -35.5v-100q0 -21 -14.5 -35.5t-35.5 -14.5h-1000q-21 0 -35.5 14.5t-14.5 35.5zM100 500h1100l-550 564z" />
+<glyph unicode="&#xe079;" d="M185 599l592 -592l240 240l-353 353l353 353l-240 240z" />
+<glyph unicode="&#xe080;" d="M272 194l353 353l-353 353l241 240l572 -571l21 -22l-1 -1v-1l-592 -591z" />
+<glyph unicode="&#xe081;" d="M3 600q0 162 80 299.5t217.5 217.5t299.5 80t299.5 -80t217.5 -217.5t80 -299.5t-80 -299.5t-217.5 -217.5t-299.5 -80t-299.5 80t-217.5 217.5t-80 299.5zM300 500h200v-200h200v200h200v200h-200v200h-200v-200h-200v-200z" />
+<glyph unicode="&#xe082;" d="M3 600q0 162 80 299.5t217.5 217.5t299.5 80t299.5 -80t217.5 -217.5t80 -299.5t-80 -299.5t-217.5 -217.5t-299.5 -80t-299.5 80t-217.5 217.5t-80 299.5zM300 500h600v200h-600v-200z" />
+<glyph unicode="&#xe083;" d="M3 600q0 162 80 299.5t217.5 217.5t299.5 80t299.5 -80t217.5 -217.5t80 -299.5t-80 -299.5t-217.5 -217.5t-299.5 -80t-299.5 80t-217.5 217.5t-80 299.5zM246 459l213 -213l141 142l141 -142l213 213l-142 141l142 141l-213 212l-141 -141l-141 142l-212 -213l141 -141 z" />
+<glyph unicode="&#xe084;" d="M3 600q0 162 80 299.5t217.5 217.5t299.5 80t299.5 -80t217.5 -217.5t80 -299.5t-80 -299.5t-217.5 -217.5t-299.5 -80t-299.5 80t-217.5 217.5t-80 299.5zM270 551l276 -277l411 411l-175 174l-236 -236l-102 102z" />
+<glyph unicode="&#xe085;" d="M3 600q0 162 80 299.5t217.5 217.5t299.5 80t299.5 -80t217.5 -217.5t80 -299.5t-80 -299.5t-217.5 -217.5t-299.5 -80t-299.5 80t-217.5 217.5t-80 299.5zM364 700h143q4 0 11.5 -1t11 -1t6.5 3t3 9t1 11t3.5 8.5t3.5 6t5.5 4t6.5 2.5t9 1.5t9 0.5h11.5h12.5 q19 0 30 -10t11 -26q0 -22 -4 -28t-27 -22q-5 -1 -12.5 -3t-27 -13.5t-34 -27t-26.5 -46t-11 -68.5h200q5 3 14 8t31.5 25.5t39.5 45.5t31 69t14 94q0 51 -17.5 89t-42 58t-58.5 32t-58.5 15t-51.5 3q-50 0 -90.5 -12t-75 -38.5t-53.5 -74.5t-19 -114zM500 300h200v100h-200 v-100z" />
+<glyph unicode="&#xe086;" d="M3 600q0 162 80 299.5t217.5 217.5t299.5 80t299.5 -80t217.5 -217.5t80 -299.5t-80 -299.5t-217.5 -217.5t-299.5 -80t-299.5 80t-217.5 217.5t-80 299.5zM400 300h400v100h-100v300h-300v-100h100v-200h-100v-100zM500 800h200v100h-200v-100z" />
+<glyph unicode="&#xe087;" d="M0 500v200h195q31 125 98.5 199.5t206.5 100.5v200h200v-200q54 -20 113 -60t112.5 -105.5t71.5 -134.5h203v-200h-203q-25 -102 -116.5 -186t-180.5 -117v-197h-200v197q-140 27 -208 102.5t-98 200.5h-194zM290 500q24 -73 79.5 -127.5t130.5 -78.5v206h200v-206 q149 48 201 206h-201v200h200q-25 74 -75.5 127t-124.5 77v-204h-200v203q-75 -23 -130 -77t-79 -126h209v-200h-210z" />
+<glyph unicode="&#xe088;" d="M4 600q0 162 80 299t217 217t299 80t299 -80t217 -217t80 -299t-80 -299t-217 -217t-299 -80t-299 80t-217 217t-80 299zM186 600q0 -171 121.5 -292.5t292.5 -121.5t292.5 121.5t121.5 292.5t-121.5 292.5t-292.5 121.5t-292.5 -121.5t-121.5 -292.5zM356 465l135 135 l-135 135l109 109l135 -135l135 135l109 -109l-135 -135l135 -135l-109 -109l-135 135l-135 -135z" />
+<glyph unicode="&#xe089;" d="M4 600q0 162 80 299t217 217t299 80t299 -80t217 -217t80 -299t-80 -299t-217 -217t-299 -80t-299 80t-217 217t-80 299zM186 600q0 -171 121.5 -292.5t292.5 -121.5t292.5 121.5t121.5 292.5t-121.5 292.5t-292.5 121.5t-292.5 -121.5t-121.5 -292.5zM322 537l141 141 l87 -87l204 205l142 -142l-346 -345z" />
+<glyph unicode="&#xe090;" d="M4 600q0 162 80 299t217 217t299 80t299 -80t217 -217t80 -299t-80 -299t-217 -217t-299 -80t-299 80t-217 217t-80 299zM186 600q0 -115 62 -215l568 567q-100 62 -216 62q-171 0 -292.5 -121.5t-121.5 -292.5zM391 245q97 -59 209 -59q171 0 292.5 121.5t121.5 292.5 q0 112 -59 209z" />
+<glyph unicode="&#xe091;" d="M0 547l600 453v-300h600v-300h-600v-301z" />
+<glyph unicode="&#xe092;" d="M0 400v300h600v300l600 -453l-600 -448v301h-600z" />
+<glyph unicode="&#xe093;" d="M204 600l450 600l444 -600h-298v-600h-300v600h-296z" />
+<glyph unicode="&#xe094;" d="M104 600h296v600h300v-600h298l-449 -600z" />
+<glyph unicode="&#xe095;" d="M0 200q6 132 41 238.5t103.5 193t184 138t271.5 59.5v271l600 -453l-600 -448v301q-95 -2 -183 -20t-170 -52t-147 -92.5t-100 -135.5z" />
+<glyph unicode="&#xe096;" d="M0 0v400l129 -129l294 294l142 -142l-294 -294l129 -129h-400zM635 777l142 -142l294 294l129 -129v400h-400l129 -129z" />
+<glyph unicode="&#xe097;" d="M34 176l295 295l-129 129h400v-400l-129 130l-295 -295zM600 600v400l129 -129l295 295l142 -141l-295 -295l129 -130h-400z" />
+<glyph unicode="&#xe101;" d="M23 600q0 118 45.5 224.5t123 184t184 123t224.5 45.5t224.5 -45.5t184 -123t123 -184t45.5 -224.5t-45.5 -224.5t-123 -184t-184 -123t-224.5 -45.5t-224.5 45.5t-184 123t-123 184t-45.5 224.5zM456 851l58 -302q4 -20 21.5 -34.5t37.5 -14.5h54q20 0 37.5 14.5 t21.5 34.5l58 302q4 20 -8 34.5t-32 14.5h-207q-21 0 -33 -14.5t-8 -34.5zM500 300h200v100h-200v-100z" />
+<glyph unicode="&#xe102;" d="M0 800h100v-200h400v300h200v-300h400v200h100v100h-111q1 1 1 6.5t-1.5 15t-3.5 17.5l-34 172q-11 39 -41.5 63t-69.5 24q-32 0 -61 -17l-239 -144q-22 -13 -40 -35q-19 24 -40 36l-238 144q-33 18 -62 18q-39 0 -69.5 -23t-40.5 -61l-35 -177q-2 -8 -3 -18t-1 -15v-6 h-111v-100zM100 0h400v400h-400v-400zM200 900q-3 0 14 48t36 96l18 47l213 -191h-281zM700 0v400h400v-400h-400zM731 900l202 197q5 -12 12 -32.5t23 -64t25 -72t7 -28.5h-269z" />
+<glyph unicode="&#xe103;" d="M0 -22v143l216 193q-9 53 -13 83t-5.5 94t9 113t38.5 114t74 124q47 60 99.5 102.5t103 68t127.5 48t145.5 37.5t184.5 43.5t220 58.5q0 -189 -22 -343t-59 -258t-89 -181.5t-108.5 -120t-122 -68t-125.5 -30t-121.5 -1.5t-107.5 12.5t-87.5 17t-56.5 7.5l-99 -55z M238.5 300.5q19.5 -6.5 86.5 76.5q55 66 367 234q70 38 118.5 69.5t102 79t99 111.5t86.5 148q22 50 24 60t-6 19q-7 5 -17 5t-26.5 -14.5t-33.5 -39.5q-35 -51 -113.5 -108.5t-139.5 -89.5l-61 -32q-369 -197 -458 -401q-48 -111 -28.5 -117.5z" />
+<glyph unicode="&#xe104;" d="M111 408q0 -33 5 -63q9 -56 44 -119.5t105 -108.5q31 -21 64 -16t62 23.5t57 49.5t48 61.5t35 60.5q32 66 39 184.5t-13 157.5q79 -80 122 -164t26 -184q-5 -33 -20.5 -69.5t-37.5 -80.5q-10 -19 -14.5 -29t-12 -26t-9 -23.5t-3 -19t2.5 -15.5t11 -9.5t19.5 -5t30.5 2.5 t42 8q57 20 91 34t87.5 44.5t87 64t65.5 88.5t47 122q38 172 -44.5 341.5t-246.5 278.5q22 -44 43 -129q39 -159 -32 -154q-15 2 -33 9q-79 33 -120.5 100t-44 175.5t48.5 257.5q-13 -8 -34 -23.5t-72.5 -66.5t-88.5 -105.5t-60 -138t-8 -166.5q2 -12 8 -41.5t8 -43t6 -39.5 t3.5 -39.5t-1 -33.5t-6 -31.5t-13.5 -24t-21 -20.5t-31 -12q-38 -10 -67 13t-40.5 61.5t-15 81.5t10.5 75q-52 -46 -83.5 -101t-39 -107t-7.5 -85z" />
+<glyph unicode="&#xe105;" d="M-61 600l26 40q6 10 20 30t49 63.5t74.5 85.5t97 90t116.5 83.5t132.5 59t145.5 23.5t145.5 -23.5t132.5 -59t116.5 -83.5t97 -90t74.5 -85.5t49 -63.5t20 -30l26 -40l-26 -40q-6 -10 -20 -30t-49 -63.5t-74.5 -85.5t-97 -90t-116.5 -83.5t-132.5 -59t-145.5 -23.5 t-145.5 23.5t-132.5 59t-116.5 83.5t-97 90t-74.5 85.5t-49 63.5t-20 30zM120 600q7 -10 40.5 -58t56 -78.5t68 -77.5t87.5 -75t103 -49.5t125 -21.5t123.5 20t100.5 45.5t85.5 71.5t66.5 75.5t58 81.5t47 66q-1 1 -28.5 37.5t-42 55t-43.5 53t-57.5 63.5t-58.5 54 q49 -74 49 -163q0 -124 -88 -212t-212 -88t-212 88t-88 212q0 85 46 158q-102 -87 -226 -258zM377 656q49 -124 154 -191l105 105q-37 24 -75 72t-57 84l-20 36z" />
+<glyph unicode="&#xe106;" d="M-61 600l26 40q6 10 20 30t49 63.5t74.5 85.5t97 90t116.5 83.5t132.5 59t145.5 23.5q61 0 121 -17l37 142h148l-314 -1200h-148l37 143q-82 21 -165 71.5t-140 102t-109.5 112t-72 88.5t-29.5 43zM120 600q210 -282 393 -336l37 141q-107 18 -178.5 101.5t-71.5 193.5 q0 85 46 158q-102 -87 -226 -258zM377 656q49 -124 154 -191l47 47l23 87q-30 28 -59 69t-44 68l-14 26zM780 161l38 145q22 15 44.5 34t46 44t40.5 44t41 50.5t33.5 43.5t33 44t24.5 34q-97 127 -140 175l39 146q67 -54 131.5 -125.5t87.5 -103.5t36 -52l26 -40l-26 -40 q-7 -12 -25.5 -38t-63.5 -79.5t-95.5 -102.5t-124 -100t-146.5 -79z" />
+<glyph unicode="&#xe107;" d="M-97.5 34q13.5 -34 50.5 -34h1294q37 0 50.5 35.5t-7.5 67.5l-642 1056q-20 34 -48 36.5t-48 -29.5l-642 -1066q-21 -32 -7.5 -66zM155 200l445 723l445 -723h-345v100h-200v-100h-345zM500 600l100 -300l100 300v100h-200v-100z" />
+<glyph unicode="&#xe108;" d="M100 262v41q0 20 11 44.5t26 38.5l363 325v339q0 62 44 106t106 44t106 -44t44 -106v-339l363 -325q15 -14 26 -38.5t11 -44.5v-41q0 -20 -12 -26.5t-29 5.5l-359 249v-263q100 -91 100 -113v-64q0 -20 -13 -28.5t-32 0.5l-94 78h-222l-94 -78q-19 -9 -32 -0.5t-13 28.5 v64q0 22 100 113v263l-359 -249q-17 -12 -29 -5.5t-12 26.5z" />
+<glyph unicode="&#xe109;" d="M0 50q0 -20 14.5 -35t35.5 -15h1000q21 0 35.5 15t14.5 35v750h-1100v-750zM0 900h1100v150q0 21 -14.5 35.5t-35.5 14.5h-150v100h-100v-100h-500v100h-100v-100h-150q-21 0 -35.5 -14.5t-14.5 -35.5v-150zM100 100v100h100v-100h-100zM100 300v100h100v-100h-100z M100 500v100h100v-100h-100zM300 100v100h100v-100h-100zM300 300v100h100v-100h-100zM300 500v100h100v-100h-100zM500 100v100h100v-100h-100zM500 300v100h100v-100h-100zM500 500v100h100v-100h-100zM700 100v100h100v-100h-100zM700 300v100h100v-100h-100zM700 500 v100h100v-100h-100zM900 100v100h100v-100h-100zM900 300v100h100v-100h-100zM900 500v100h100v-100h-100z" />
+<glyph unicode="&#xe110;" d="M0 200v200h259l600 600h241v198l300 -295l-300 -300v197h-159l-600 -600h-341zM0 800h259l122 -122l141 142l-181 180h-341v-200zM678 381l141 142l122 -123h159v198l300 -295l-300 -300v197h-241z" />
+<glyph unicode="&#xe111;" d="M0 400v600q0 41 29.5 70.5t70.5 29.5h1000q41 0 70.5 -29.5t29.5 -70.5v-600q0 -41 -29.5 -70.5t-70.5 -29.5h-596l-304 -300v300h-100q-41 0 -70.5 29.5t-29.5 70.5z" />
+<glyph unicode="&#xe112;" d="M100 600v200h300v-250q0 -113 6 -145q17 -92 102 -117q39 -11 92 -11q37 0 66.5 5.5t50 15.5t36 24t24 31.5t14 37.5t7 42t2.5 45t0 47v25v250h300v-200q0 -42 -3 -83t-15 -104t-31.5 -116t-58 -109.5t-89 -96.5t-129 -65.5t-174.5 -25.5t-174.5 25.5t-129 65.5t-89 96.5 t-58 109.5t-31.5 116t-15 104t-3 83zM100 900v300h300v-300h-300zM800 900v300h300v-300h-300z" />
+<glyph unicode="&#xe113;" d="M-30 411l227 -227l352 353l353 -353l226 227l-578 579z" />
+<glyph unicode="&#xe114;" d="M70 797l580 -579l578 579l-226 227l-353 -353l-352 353z" />
+<glyph unicode="&#xe115;" d="M-198 700l299 283l300 -283h-203v-400h385l215 -200h-800v600h-196zM402 1000l215 -200h381v-400h-198l299 -283l299 283h-200v600h-796z" />
+<glyph unicode="&#xe116;" d="M18 939q-5 24 10 42q14 19 39 19h896l38 162q5 17 18.5 27.5t30.5 10.5h94q20 0 35 -14.5t15 -35.5t-15 -35.5t-35 -14.5h-54l-201 -961q-2 -4 -6 -10.5t-19 -17.5t-33 -11h-31v-50q0 -20 -14.5 -35t-35.5 -15t-35.5 15t-14.5 35v50h-300v-50q0 -20 -14.5 -35t-35.5 -15 t-35.5 15t-14.5 35v50h-50q-21 0 -35.5 15t-14.5 35q0 21 14.5 35.5t35.5 14.5h535l48 200h-633q-32 0 -54.5 21t-27.5 43z" />
+<glyph unicode="&#xe117;" d="M0 0v800h1200v-800h-1200zM0 900v100h200q0 41 29.5 70.5t70.5 29.5h300q41 0 70.5 -29.5t29.5 -70.5h500v-100h-1200z" />
+<glyph unicode="&#xe118;" d="M1 0l300 700h1200l-300 -700h-1200zM1 400v600h200q0 41 29.5 70.5t70.5 29.5h300q41 0 70.5 -29.5t29.5 -70.5h500v-200h-1000z" />
+<glyph unicode="&#xe119;" d="M302 300h198v600h-198l298 300l298 -300h-198v-600h198l-298 -300z" />
+<glyph unicode="&#xe120;" d="M0 600l300 298v-198h600v198l300 -298l-300 -297v197h-600v-197z" />
+<glyph unicode="&#xe121;" d="M0 100v100q0 41 29.5 70.5t70.5 29.5h1000q41 0 70.5 -29.5t29.5 -70.5v-100q0 -41 -29.5 -70.5t-70.5 -29.5h-1000q-41 0 -70.5 29.5t-29.5 70.5zM31 400l172 739q5 22 23 41.5t38 19.5h672q19 0 37.5 -22.5t23.5 -45.5l172 -732h-1138zM800 100h100v100h-100v-100z M1000 100h100v100h-100v-100z" />
+<glyph unicode="&#xe122;" d="M-101 600v50q0 24 25 49t50 38l25 13v-250l-11 5.5t-24 14t-30 21.5t-24 27.5t-11 31.5zM100 500v250v8v8v7t0.5 7t1.5 5.5t2 5t3 4t4.5 3.5t6 1.5t7.5 0.5h200l675 250v-850l-675 200h-38l47 -276q2 -12 -3 -17.5t-11 -6t-21 -0.5h-8h-83q-20 0 -34.5 14t-18.5 35 q-55 337 -55 351zM1100 200v850q0 21 14.5 35.5t35.5 14.5q20 0 35 -14.5t15 -35.5v-850q0 -20 -15 -35t-35 -15q-21 0 -35.5 15t-14.5 35z" />
+<glyph unicode="&#xe123;" d="M74 350q0 21 13.5 35.5t33.5 14.5h18l117 173l63 327q15 77 76 140t144 83l-18 32q-6 19 3 32t29 13h94q20 0 29 -10.5t3 -29.5q-18 -36 -18 -37q83 -19 144 -82.5t76 -140.5l63 -327l118 -173h17q20 0 33.5 -14.5t13.5 -35.5q0 -20 -13 -40t-31 -27q-8 -3 -23 -8.5 t-65 -20t-103 -25t-132.5 -19.5t-158.5 -9q-125 0 -245.5 20.5t-178.5 40.5l-58 20q-18 7 -31 27.5t-13 40.5zM497 110q12 -49 40 -79.5t63 -30.5t63 30.5t39 79.5q-48 -6 -102 -6t-103 6z" />
+<glyph unicode="&#xe124;" d="M21 445l233 -45l-78 -224l224 78l45 -233l155 179l155 -179l45 233l224 -78l-78 224l234 45l-180 155l180 156l-234 44l78 225l-224 -78l-45 233l-155 -180l-155 180l-45 -233l-224 78l78 -225l-233 -44l179 -156z" />
+<glyph unicode="&#xe125;" d="M0 200h200v600h-200v-600zM300 275q0 -75 100 -75h61q124 -100 139 -100h250q46 0 83 57l238 344q29 31 29 74v100q0 44 -30.5 84.5t-69.5 40.5h-328q28 118 28 125v150q0 44 -30.5 84.5t-69.5 40.5h-50q-27 0 -51 -20t-38 -48l-96 -198l-145 -196q-20 -26 -20 -63v-400z M400 300v375l150 213l100 212h50v-175l-50 -225h450v-125l-250 -375h-214l-136 100h-100z" />
+<glyph unicode="&#xe126;" d="M0 400v600h200v-600h-200zM300 525v400q0 75 100 75h61q124 100 139 100h250q46 0 83 -57l238 -344q29 -31 29 -74v-100q0 -44 -30.5 -84.5t-69.5 -40.5h-328q28 -118 28 -125v-150q0 -44 -30.5 -84.5t-69.5 -40.5h-50q-27 0 -51 20t-38 48l-96 198l-145 196 q-20 26 -20 63zM400 525l150 -212l100 -213h50v175l-50 225h450v125l-250 375h-214l-136 -100h-100v-375z" />
+<glyph unicode="&#xe127;" d="M8 200v600h200v-600h-200zM308 275v525q0 17 14 35.5t28 28.5l14 9l362 230q14 6 25 6q17 0 29 -12l109 -112q14 -14 14 -34q0 -18 -11 -32l-85 -121h302q85 0 138.5 -38t53.5 -110t-54.5 -111t-138.5 -39h-107l-130 -339q-7 -22 -20.5 -41.5t-28.5 -19.5h-341 q-7 0 -90 81t-83 94zM408 289l100 -89h293l131 339q6 21 19.5 41t28.5 20h203q16 0 25 15t9 36q0 20 -9 34.5t-25 14.5h-457h-6.5h-7.5t-6.5 0.5t-6 1t-5 1.5t-5.5 2.5t-4 4t-4 5.5q-5 12 -5 20q0 14 10 27l147 183l-86 83l-339 -236v-503z" />
+<glyph unicode="&#xe128;" d="M-101 651q0 72 54 110t139 38l302 -1l-85 121q-11 16 -11 32q0 21 14 34l109 113q13 12 29 12q11 0 25 -6l365 -230q7 -4 17 -10.5t26.5 -26t16.5 -36.5v-526q0 -13 -86 -93.5t-94 -80.5h-341q-16 0 -29.5 20t-19.5 41l-130 339h-107q-84 0 -139 39t-55 111zM-1 601h222 q15 0 28.5 -20.5t19.5 -40.5l131 -339h293l107 89v502l-343 237l-87 -83l145 -184q10 -11 10 -26q0 -11 -5 -20q-1 -3 -3.5 -5.5l-4 -4t-5 -2.5t-5.5 -1.5t-6.5 -1t-6.5 -0.5h-7.5h-6.5h-476v-100zM1000 201v600h200v-600h-200z" />
+<glyph unicode="&#xe129;" d="M97 719l230 -363q4 -6 10.5 -15.5t26 -25t36.5 -15.5h525q13 0 94 83t81 90v342q0 15 -20 28.5t-41 19.5l-339 131v106q0 84 -39 139t-111 55t-110 -53.5t-38 -138.5v-302l-121 84q-15 12 -33.5 11.5t-32.5 -13.5l-112 -110q-22 -22 -6 -53zM172 739l83 86l183 -146 q22 -18 47 -5q3 1 5.5 3.5l4 4t2.5 5t1.5 5.5t1 6.5t0.5 6.5v7.5v6.5v456q0 22 25 31t50 -0.5t25 -30.5v-202q0 -16 20 -29.5t41 -19.5l339 -130v-294l-89 -100h-503zM400 0v200h600v-200h-600z" />
+<glyph unicode="&#xe130;" d="M2 585q-16 -31 6 -53l112 -110q13 -13 32 -13.5t34 10.5l121 85q0 -51 -0.5 -153.5t-0.5 -148.5q0 -84 38.5 -138t110.5 -54t111 55t39 139v106l339 131q20 6 40.5 19.5t20.5 28.5v342q0 7 -81 90t-94 83h-525q-17 0 -35.5 -14t-28.5 -28l-10 -15zM77 565l236 339h503 l89 -100v-294l-340 -130q-20 -6 -40 -20t-20 -29v-202q0 -22 -25 -31t-50 0t-25 31v456v14.5t-1.5 11.5t-5 12t-9.5 7q-24 13 -46 -5l-184 -146zM305 1104v200h600v-200h-600z" />
+<glyph unicode="&#xe131;" d="M5 597q0 122 47.5 232.5t127.5 190.5t190.5 127.5t232.5 47.5q162 0 299.5 -80t217.5 -218t80 -300t-80 -299.5t-217.5 -217.5t-299.5 -80t-300 80t-218 217.5t-80 299.5zM298 701l2 -201h300l-2 -194l402 294l-402 298v-197h-300z" />
+<glyph unicode="&#xe132;" d="M0 597q0 122 47.5 232.5t127.5 190.5t190.5 127.5t231.5 47.5q122 0 232.5 -47.5t190.5 -127.5t127.5 -190.5t47.5 -232.5q0 -162 -80 -299.5t-218 -217.5t-300 -80t-299.5 80t-217.5 217.5t-80 299.5zM200 600l402 -294l-2 194h300l2 201h-300v197z" />
+<glyph unicode="&#xe133;" d="M5 597q0 122 47.5 232.5t127.5 190.5t190.5 127.5t232.5 47.5q162 0 299.5 -80t217.5 -218t80 -300t-80 -299.5t-217.5 -217.5t-299.5 -80t-300 80t-218 217.5t-80 299.5zM300 600h200v-300h200v300h200l-300 400z" />
+<glyph unicode="&#xe134;" d="M5 597q0 122 47.5 232.5t127.5 190.5t190.5 127.5t232.5 47.5q162 0 299.5 -80t217.5 -218t80 -300t-80 -299.5t-217.5 -217.5t-299.5 -80t-300 80t-218 217.5t-80 299.5zM300 600l300 -400l300 400h-200v300h-200v-300h-200z" />
+<glyph unicode="&#xe135;" d="M5 597q0 122 47.5 232.5t127.5 190.5t190.5 127.5t232.5 47.5q121 0 231.5 -47.5t190.5 -127.5t127.5 -190.5t47.5 -232.5q0 -162 -80 -299.5t-217.5 -217.5t-299.5 -80t-300 80t-218 217.5t-80 299.5zM254 780q-8 -33 5.5 -92.5t7.5 -87.5q0 -9 17 -44t16 -60 q12 0 23 -5.5t23 -15t20 -13.5q24 -12 108 -42q22 -8 53 -31.5t59.5 -38.5t57.5 -11q8 -18 -15 -55t-20 -57q42 -71 87 -80q0 -6 -3 -15.5t-3.5 -14.5t4.5 -17q104 -3 221 112q30 29 47 47t34.5 49t20.5 62q-14 9 -37 9.5t-36 7.5q-14 7 -49 15t-52 19q-9 0 -39.5 -0.5 t-46.5 -1.5t-39 -6.5t-39 -16.5q-50 -35 -66 -12q-4 2 -3.5 25.5t0.5 25.5q-6 13 -26.5 17t-24.5 7q2 22 -2 41t-16.5 28t-38.5 -20q-23 -25 -42 4q-19 28 -8 58q6 16 22 22q6 -1 26 -1.5t33.5 -4t19.5 -13.5q12 -19 32 -37.5t34 -27.5l14 -8q0 3 9.5 39.5t5.5 57.5 q-4 23 14.5 44.5t22.5 31.5q5 14 10 35t8.5 31t15.5 22.5t34 21.5q-6 18 10 37q8 0 23.5 -1.5t24.5 -1.5t20.5 4.5t20.5 15.5q-10 23 -30.5 42.5t-38 30t-49 26.5t-43.5 23q11 39 2 44q31 -13 58 -14.5t39 3.5l11 4q7 36 -16.5 53.5t-64.5 28.5t-56 23q-19 -3 -37 0 q-15 -12 -36.5 -21t-34.5 -12t-44 -8t-39 -6q-15 -3 -45.5 0.5t-45.5 -2.5q-21 -7 -52 -26.5t-34 -34.5q-3 -11 6.5 -22.5t8.5 -18.5q-3 -34 -27.5 -90.5t-29.5 -79.5zM518 916q3 12 16 30t16 25q10 -10 18.5 -10t14 6t14.5 14.5t16 12.5q0 -24 17 -66.5t17 -43.5 q-9 2 -31 5t-36 5t-32 8t-30 14zM692 1003h1h-1z" />
+<glyph unicode="&#xe136;" d="M0 164.5q0 21.5 15 37.5l600 599q-33 101 6 201.5t135 154.5q164 92 306 -9l-259 -138l145 -232l251 126q13 -175 -151 -267q-123 -70 -253 -23l-596 -596q-15 -16 -36.5 -16t-36.5 16l-111 110q-15 15 -15 36.5z" />
+<glyph unicode="&#xe137;" horiz-adv-x="1220" d="M0 196v100q0 41 29.5 70.5t70.5 29.5h1000q41 0 70.5 -29.5t29.5 -70.5v-100q0 -41 -29.5 -70.5t-70.5 -29.5h-1000q-41 0 -70.5 29.5t-29.5 70.5zM0 596v100q0 41 29.5 70.5t70.5 29.5h1000q41 0 70.5 -29.5t29.5 -70.5v-100q0 -41 -29.5 -70.5t-70.5 -29.5h-1000 q-41 0 -70.5 29.5t-29.5 70.5zM0 996v100q0 41 29.5 70.5t70.5 29.5h1000q41 0 70.5 -29.5t29.5 -70.5v-100q0 -41 -29.5 -70.5t-70.5 -29.5h-1000q-41 0 -70.5 29.5t-29.5 70.5zM600 596h500v100h-500v-100zM800 196h300v100h-300v-100zM900 996h200v100h-200v-100z" />
+<glyph unicode="&#xe138;" d="M100 1100v100h1000v-100h-1000zM150 1000h900l-350 -500v-300l-200 -200v500z" />
+<glyph unicode="&#xe139;" d="M0 200v200h1200v-200q0 -41 -29.5 -70.5t-70.5 -29.5h-1000q-41 0 -70.5 29.5t-29.5 70.5zM0 500v400q0 41 29.5 70.5t70.5 29.5h300v100q0 41 29.5 70.5t70.5 29.5h200q41 0 70.5 -29.5t29.5 -70.5v-100h300q41 0 70.5 -29.5t29.5 -70.5v-400h-500v100h-200v-100h-500z M500 1000h200v100h-200v-100z" />
+<glyph unicode="&#xe140;" d="M0 0v400l129 -129l200 200l142 -142l-200 -200l129 -129h-400zM0 800l129 129l200 -200l142 142l-200 200l129 129h-400v-400zM729 329l142 142l200 -200l129 129v-400h-400l129 129zM729 871l200 200l-129 129h400v-400l-129 129l-200 -200z" />
+<glyph unicode="&#xe141;" d="M0 596q0 162 80 299t217 217t299 80t299 -80t217 -217t80 -299t-80 -299t-217 -217t-299 -80t-299 80t-217 217t-80 299zM182 596q0 -172 121.5 -293t292.5 -121t292.5 121t121.5 293q0 171 -121.5 292.5t-292.5 121.5t-292.5 -121.5t-121.5 -292.5zM291 655 q0 23 15.5 38.5t38.5 15.5t39 -16t16 -38q0 -23 -16 -39t-39 -16q-22 0 -38 16t-16 39zM400 850q0 22 16 38.5t39 16.5q22 0 38 -16t16 -39t-16 -39t-38 -16q-23 0 -39 16.5t-16 38.5zM514 609q0 32 20.5 56.5t51.5 29.5l122 126l1 1q-9 14 -9 28q0 22 16 38.5t39 16.5 q22 0 38 -16t16 -39t-16 -39t-38 -16q-14 0 -29 10l-55 -145q17 -22 17 -51q0 -36 -25.5 -61.5t-61.5 -25.5t-61.5 25.5t-25.5 61.5zM800 655q0 22 16 38t39 16t38.5 -15.5t15.5 -38.5t-16 -39t-38 -16q-23 0 -39 16t-16 39z" />
+<glyph unicode="&#xe142;" d="M-40 375q-13 -95 35 -173q35 -57 94 -89t129 -32q63 0 119 28q33 16 65 40.5t52.5 45.5t59.5 64q40 44 57 61l394 394q35 35 47 84t-3 96q-27 87 -117 104q-20 2 -29 2q-46 0 -78.5 -16.5t-67.5 -51.5l-389 -396l-7 -7l69 -67l377 373q20 22 39 38q23 23 50 23 q38 0 53 -36q16 -39 -20 -75l-547 -547q-52 -52 -125 -52q-55 0 -100 33t-54 96q-5 35 2.5 66t31.5 63t42 50t56 54q24 21 44 41l348 348q52 52 82.5 79.5t84 54t107.5 26.5q25 0 48 -4q95 -17 154 -94.5t51 -175.5q-7 -101 -98 -192l-252 -249l-253 -256l7 -7l69 -60 l517 511q67 67 95 157t11 183q-16 87 -67 154t-130 103q-69 33 -152 33q-107 0 -197 -55q-40 -24 -111 -95l-512 -512q-68 -68 -81 -163z" />
+<glyph unicode="&#xe143;" d="M80 784q0 131 98.5 229.5t230.5 98.5q143 0 241 -129q103 129 246 129q129 0 226 -98.5t97 -229.5q0 -46 -17.5 -91t-61 -99t-77 -89.5t-104.5 -105.5q-197 -191 -293 -322l-17 -23l-16 23q-43 58 -100 122.5t-92 99.5t-101 100q-71 70 -104.5 105.5t-77 89.5t-61 99 t-17.5 91zM250 784q0 -27 30.5 -70t61.5 -75.5t95 -94.5l22 -22q93 -90 190 -201q82 92 195 203l12 12q64 62 97.5 97t64.5 79t31 72q0 71 -48 119.5t-105 48.5q-74 0 -132 -83l-118 -171l-114 174q-51 80 -123 80q-60 0 -109.5 -49.5t-49.5 -118.5z" />
+<glyph unicode="&#xe144;" d="M57 353q0 -95 66 -159l141 -142q68 -66 159 -66q93 0 159 66l283 283q66 66 66 159t-66 159l-141 141q-8 9 -19 17l-105 -105l212 -212l-389 -389l-247 248l95 95l-18 18q-46 45 -75 101l-55 -55q-66 -66 -66 -159zM269 706q0 -93 66 -159l141 -141q7 -7 19 -17l105 105 l-212 212l389 389l247 -247l-95 -96l18 -17q47 -49 77 -100l29 29q35 35 62.5 88t27.5 96q0 93 -66 159l-141 141q-66 66 -159 66q-95 0 -159 -66l-283 -283q-66 -64 -66 -159z" />
+<glyph unicode="&#xe145;" d="M200 100v953q0 21 30 46t81 48t129 38t163 15t162 -15t127 -38t79 -48t29 -46v-953q0 -41 -29.5 -70.5t-70.5 -29.5h-600q-41 0 -70.5 29.5t-29.5 70.5zM300 300h600v700h-600v-700zM496 150q0 -43 30.5 -73.5t73.5 -30.5t73.5 30.5t30.5 73.5t-30.5 73.5t-73.5 30.5 t-73.5 -30.5t-30.5 -73.5z" />
+<glyph unicode="&#xe146;" d="M0 0l303 380l207 208l-210 212h300l267 279l-35 36q-15 14 -15 35t15 35q14 15 35 15t35 -15l283 -282q15 -15 15 -36t-15 -35q-14 -15 -35 -15t-35 15l-36 35l-279 -267v-300l-212 210l-208 -207z" />
+<glyph unicode="&#xe148;" d="M295 433h139q5 -77 48.5 -126.5t117.5 -64.5v335q-6 1 -15.5 4t-11.5 3q-46 14 -79 26.5t-72 36t-62.5 52t-40 72.5t-16.5 99q0 92 44 159.5t109 101t144 40.5v78h100v-79q38 -4 72.5 -13.5t75.5 -31.5t71 -53.5t51.5 -84t24.5 -118.5h-159q-8 72 -35 109.5t-101 50.5 v-307l64 -14q34 -7 64 -16.5t70 -31.5t67.5 -52t47.5 -80.5t20 -112.5q0 -139 -89 -224t-244 -96v-77h-100v78q-152 17 -237 104q-40 40 -52.5 93.5t-15.5 139.5zM466 889q0 -29 8 -51t16.5 -34t29.5 -22.5t31 -13.5t38 -10q7 -2 11 -3v274q-61 -8 -97.5 -37.5t-36.5 -102.5 zM700 237q170 18 170 151q0 64 -44 99.5t-126 60.5v-311z" />
+<glyph unicode="&#xe149;" d="M100 600v100h166q-24 49 -44 104q-10 26 -14.5 55.5t-3 72.5t25 90t68.5 87q97 88 263 88q129 0 230 -89t101 -208h-153q0 52 -34 89.5t-74 51.5t-76 14q-37 0 -79 -14.5t-62 -35.5q-41 -44 -41 -101q0 -28 16.5 -69.5t28 -62.5t41.5 -72h241v-100h-197q8 -50 -2.5 -115 t-31.5 -94q-41 -59 -99 -113q35 11 84 18t70 7q33 1 103 -16t103 -17q76 0 136 30l50 -147q-41 -25 -80.5 -36.5t-59 -13t-61.5 -1.5q-23 0 -128 33t-155 29q-39 -4 -82 -17t-66 -25l-24 -11l-55 145l16.5 11t15.5 10t13.5 9.5t14.5 12t14.5 14t17.5 18.5q48 55 54 126.5 t-30 142.5h-221z" />
+<glyph unicode="&#xe150;" d="M2 300l298 -300l298 300h-198v900h-200v-900h-198zM602 900l298 300l298 -300h-198v-900h-200v900h-198z" />
+<glyph unicode="&#xe151;" d="M2 300h198v900h200v-900h198l-298 -300zM700 0v200h100v-100h200v-100h-300zM700 400v100h300v-200h-99v-100h-100v100h99v100h-200zM700 700v500h300v-500h-100v100h-100v-100h-100zM801 900h100v200h-100v-200z" />
+<glyph unicode="&#xe152;" d="M2 300h198v900h200v-900h198l-298 -300zM700 0v500h300v-500h-100v100h-100v-100h-100zM700 700v200h100v-100h200v-100h-300zM700 1100v100h300v-200h-99v-100h-100v100h99v100h-200zM801 200h100v200h-100v-200z" />
+<glyph unicode="&#xe153;" d="M2 300l298 -300l298 300h-198v900h-200v-900h-198zM800 100v400h300v-500h-100v100h-200zM800 1100v100h200v-500h-100v400h-100zM901 200h100v200h-100v-200z" />
+<glyph unicode="&#xe154;" d="M2 300l298 -300l298 300h-198v900h-200v-900h-198zM800 400v100h200v-500h-100v400h-100zM800 800v400h300v-500h-100v100h-200zM901 900h100v200h-100v-200z" />
+<glyph unicode="&#xe155;" d="M2 300l298 -300l298 300h-198v900h-200v-900h-198zM700 100v200h500v-200h-500zM700 400v200h400v-200h-400zM700 700v200h300v-200h-300zM700 1000v200h200v-200h-200z" />
+<glyph unicode="&#xe156;" d="M2 300l298 -300l298 300h-198v900h-200v-900h-198zM700 100v200h200v-200h-200zM700 400v200h300v-200h-300zM700 700v200h400v-200h-400zM700 1000v200h500v-200h-500z" />
+<glyph unicode="&#xe157;" d="M0 400v300q0 165 117.5 282.5t282.5 117.5h300q162 0 281 -118.5t119 -281.5v-300q0 -165 -118.5 -282.5t-281.5 -117.5h-300q-165 0 -282.5 117.5t-117.5 282.5zM200 300q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5v500q0 41 -29.5 70.5t-70.5 29.5 h-500q-41 0 -70.5 -29.5t-29.5 -70.5v-500z" />
+<glyph unicode="&#xe158;" d="M0 400v300q0 163 119 281.5t281 118.5h300q165 0 282.5 -117.5t117.5 -282.5v-300q0 -165 -117.5 -282.5t-282.5 -117.5h-300q-163 0 -281.5 117.5t-118.5 282.5zM200 300q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5v500q0 41 -29.5 70.5t-70.5 29.5 h-500q-41 0 -70.5 -29.5t-29.5 -70.5v-500zM400 300l333 250l-333 250v-500z" />
+<glyph unicode="&#xe159;" d="M0 400v300q0 163 117.5 281.5t282.5 118.5h300q163 0 281.5 -119t118.5 -281v-300q0 -165 -117.5 -282.5t-282.5 -117.5h-300q-165 0 -282.5 117.5t-117.5 282.5zM200 300q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5v500q0 41 -29.5 70.5t-70.5 29.5 h-500q-41 0 -70.5 -29.5t-29.5 -70.5v-500zM300 700l250 -333l250 333h-500z" />
+<glyph unicode="&#xe160;" d="M0 400v300q0 165 117.5 282.5t282.5 117.5h300q165 0 282.5 -117.5t117.5 -282.5v-300q0 -162 -118.5 -281t-281.5 -119h-300q-165 0 -282.5 118.5t-117.5 281.5zM200 300q0 -41 29.5 -70.5t70.5 -29.5h500q41 0 70.5 29.5t29.5 70.5v500q0 41 -29.5 70.5t-70.5 29.5 h-500q-41 0 -70.5 -29.5t-29.5 -70.5v-500zM300 400h500l-250 333z" />
+<glyph unicode="&#xe161;" d="M0 400v300h300v200l400 -350l-400 -350v200h-300zM500 0v200h500q41 0 70.5 29.5t29.5 70.5v500q0 41 -29.5 70.5t-70.5 29.5h-500v200h400q165 0 282.5 -117.5t117.5 -282.5v-300q0 -165 -117.5 -282.5t-282.5 -117.5h-400z" />
+<glyph unicode="&#xe162;" d="M217 519q8 -19 31 -19h302q-155 -438 -160 -458q-5 -21 4 -32l9 -8h9q14 0 26 15q11 13 274.5 321.5t264.5 308.5q14 19 5 36q-8 17 -31 17l-301 -1q1 4 78 219.5t79 227.5q2 15 -5 27l-9 9h-9q-15 0 -25 -16q-4 -6 -98 -111.5t-228.5 -257t-209.5 -237.5q-16 -19 -6 -41 z" />
+<glyph unicode="&#xe163;" d="M0 400q0 -165 117.5 -282.5t282.5 -117.5h300q47 0 100 15v185h-500q-41 0 -70.5 29.5t-29.5 70.5v500q0 41 29.5 70.5t70.5 29.5h500v185q-14 4 -114 7.5t-193 5.5l-93 2q-165 0 -282.5 -117.5t-117.5 -282.5v-300zM600 400v300h300v200l400 -350l-400 -350v200h-300z " />
+<glyph unicode="&#xe164;" d="M0 400q0 -165 117.5 -282.5t282.5 -117.5h300q163 0 281.5 117.5t118.5 282.5v98l-78 73l-122 -123v-148q0 -41 -29.5 -70.5t-70.5 -29.5h-500q-41 0 -70.5 29.5t-29.5 70.5v500q0 41 29.5 70.5t70.5 29.5h156l118 122l-74 78h-100q-165 0 -282.5 -117.5t-117.5 -282.5 v-300zM496 709l353 342l-149 149h500v-500l-149 149l-342 -353z" />
+<glyph unicode="&#xe165;" d="M4 600q0 162 80 299t217 217t299 80t299 -80t217 -217t80 -299t-80 -299t-217 -217t-299 -80t-299 80t-217 217t-80 299zM186 600q0 -171 121.5 -292.5t292.5 -121.5t292.5 121.5t121.5 292.5t-121.5 292.5t-292.5 121.5t-292.5 -121.5t-121.5 -292.5zM406 600 q0 80 57 137t137 57t137 -57t57 -137t-57 -137t-137 -57t-137 57t-57 137z" />
+<glyph unicode="&#xe166;" d="M0 0v275q0 11 7 18t18 7h1048q11 0 19 -7.5t8 -17.5v-275h-1100zM100 800l445 -500l450 500h-295v400h-300v-400h-300zM900 150h100v50h-100v-50z" />
+<glyph unicode="&#xe167;" d="M0 0v275q0 11 7 18t18 7h1048q11 0 19 -7.5t8 -17.5v-275h-1100zM100 700h300v-300h300v300h295l-445 500zM900 150h100v50h-100v-50z" />
+<glyph unicode="&#xe168;" d="M0 0v275q0 11 7 18t18 7h1048q11 0 19 -7.5t8 -17.5v-275h-1100zM100 705l305 -305l596 596l-154 155l-442 -442l-150 151zM900 150h100v50h-100v-50z" />
+<glyph unicode="&#xe169;" d="M0 0v275q0 11 7 18t18 7h1048q11 0 19 -7.5t8 -17.5v-275h-1100zM100 988l97 -98l212 213l-97 97zM200 400l697 1l3 699l-250 -239l-149 149l-212 -212l149 -149zM900 150h100v50h-100v-50z" />
+<glyph unicode="&#xe170;" d="M0 0v275q0 11 7 18t18 7h1048q11 0 19 -7.5t8 -17.5v-275h-1100zM200 612l212 -212l98 97l-213 212zM300 1200l239 -250l-149 -149l212 -212l149 148l249 -237l-1 697zM900 150h100v50h-100v-50z" />
+<glyph unicode="&#xe171;" d="M23 415l1177 784v-1079l-475 272l-310 -393v416h-392zM494 210l672 938l-672 -712v-226z" />
+<glyph unicode="&#xe172;" d="M0 150v1000q0 20 14.5 35t35.5 15h250v-300h500v300h100l200 -200v-850q0 -21 -15 -35.5t-35 -14.5h-150v400h-700v-400h-150q-21 0 -35.5 14.5t-14.5 35.5zM600 1000h100v200h-100v-200z" />
+<glyph unicode="&#xe173;" d="M0 150v1000q0 20 14.5 35t35.5 15h250v-300h500v300h100l200 -200v-218l-276 -275l-120 120l-126 -127h-378v-400h-150q-21 0 -35.5 14.5t-14.5 35.5zM581 306l123 123l120 -120l353 352l123 -123l-475 -476zM600 1000h100v200h-100v-200z" />
+<glyph unicode="&#xe174;" d="M0 150v1000q0 20 14.5 35t35.5 15h250v-300h500v300h100l200 -200v-269l-103 -103l-170 170l-298 -298h-329v-400h-150q-21 0 -35.5 14.5t-14.5 35.5zM600 1000h100v200h-100v-200zM700 133l170 170l-170 170l127 127l170 -170l170 170l127 -128l-170 -169l170 -170 l-127 -127l-170 170l-170 -170z" />
+<glyph unicode="&#xe175;" d="M0 150v1000q0 20 14.5 35t35.5 15h250v-300h500v300h100l200 -200v-300h-400v-200h-500v-400h-150q-21 0 -35.5 14.5t-14.5 35.5zM600 300l300 -300l300 300h-200v300h-200v-300h-200zM600 1000v200h100v-200h-100z" />
+<glyph unicode="&#xe176;" d="M0 150v1000q0 20 14.5 35t35.5 15h250v-300h500v300h100l200 -200v-402l-200 200l-298 -298h-402v-400h-150q-21 0 -35.5 14.5t-14.5 35.5zM600 300h200v-300h200v300h200l-300 300zM600 1000v200h100v-200h-100z" />
+<glyph unicode="&#xe177;" d="M0 250q0 -21 14.5 -35.5t35.5 -14.5h1100q21 0 35.5 14.5t14.5 35.5v550h-1200v-550zM0 900h1200v150q0 21 -14.5 35.5t-35.5 14.5h-1100q-21 0 -35.5 -14.5t-14.5 -35.5v-150zM100 300v200h400v-200h-400z" />
+<glyph unicode="&#xe178;" d="M0 400l300 298v-198h400v-200h-400v-198zM100 800v200h100v-200h-100zM300 800v200h100v-200h-100zM500 800v200h400v198l300 -298l-300 -298v198h-400zM800 300v200h100v-200h-100zM1000 300h100v200h-100v-200z" />
+<glyph unicode="&#xe179;" d="M100 700v400l50 100l50 -100v-300h100v300l50 100l50 -100v-300h100v300l50 100l50 -100v-400l-100 -203v-447q0 -21 -14.5 -35.5t-35.5 -14.5h-200q-21 0 -35.5 14.5t-14.5 35.5v447zM800 597q0 -29 10.5 -55.5t25 -43t29 -28.5t25.5 -18l10 -5v-397q0 -21 14.5 -35.5 t35.5 -14.5h200q21 0 35.5 14.5t14.5 35.5v1106q0 31 -18 40.5t-44 -7.5l-276 -116q-25 -17 -43.5 -51.5t-18.5 -65.5v-359z" />
+<glyph unicode="&#xe180;" d="M100 0h400v56q-75 0 -87.5 6t-12.5 44v394h500v-394q0 -38 -12.5 -44t-87.5 -6v-56h400v56q-4 0 -11 0.5t-24 3t-30 7t-24 15t-11 24.5v888q0 22 25 34.5t50 13.5l25 2v56h-400v-56q75 0 87.5 -6t12.5 -44v-394h-500v394q0 38 12.5 44t87.5 6v56h-400v-56q4 0 11 -0.5 t24 -3t30 -7t24 -15t11 -24.5v-888q0 -22 -25 -34.5t-50 -13.5l-25 -2v-56z" />
+<glyph unicode="&#xe181;" d="M0 300q0 -41 29.5 -70.5t70.5 -29.5h300q41 0 70.5 29.5t29.5 70.5v500q0 41 -29.5 70.5t-70.5 29.5h-300q-41 0 -70.5 -29.5t-29.5 -70.5v-500zM100 100h400l200 200h105l295 98v-298h-425l-100 -100h-375zM100 300v200h300v-200h-300zM100 600v200h300v-200h-300z M100 1000h400l200 -200v-98l295 98h105v200h-425l-100 100h-375zM700 402v163l400 133v-163z" />
+<glyph unicode="&#xe182;" d="M16.5 974.5q0.5 -21.5 16 -90t46.5 -140t104 -177.5t175 -208q103 -103 207.5 -176t180 -103.5t137 -47t92.5 -16.5l31 1l163 162q17 18 13.5 41t-22.5 37l-192 136q-19 14 -45 12t-42 -19l-118 -118q-142 101 -268 227t-227 268l118 118q17 17 20 41.5t-11 44.5 l-139 194q-14 19 -36.5 22t-40.5 -14l-162 -162q-1 -11 -0.5 -32.5z" />
+<glyph unicode="&#xe183;" d="M0 50v212q0 20 10.5 45.5t24.5 39.5l365 303v50q0 4 1 10.5t12 22.5t30 28.5t60 23t97 10.5t97 -10t60 -23.5t30 -27.5t12 -24l1 -10v-50l365 -303q14 -14 24.5 -39.5t10.5 -45.5v-212q0 -21 -14.5 -35.5t-35.5 -14.5h-1100q-20 0 -35 14.5t-15 35.5zM0 712 q0 -21 14.5 -33.5t34.5 -8.5l202 33q20 4 34.5 21t14.5 38v146q141 24 300 24t300 -24v-146q0 -21 14.5 -38t34.5 -21l202 -33q20 -4 34.5 8.5t14.5 33.5v200q-6 8 -19 20.5t-63 45t-112 57t-171 45t-235 20.5q-92 0 -175 -10.5t-141.5 -27t-108.5 -36.5t-81.5 -40 t-53.5 -36.5t-31 -27.5l-9 -10v-200z" />
+<glyph unicode="&#xe184;" d="M100 0v100h1100v-100h-1100zM175 200h950l-125 150v250l100 100v400h-100v-200h-100v200h-200v-200h-100v200h-200v-200h-100v200h-100v-400l100 -100v-250z" />
+<glyph unicode="&#xe185;" d="M100 0h300v400q0 41 -29.5 70.5t-70.5 29.5h-100q-41 0 -70.5 -29.5t-29.5 -70.5v-400zM500 0v1000q0 41 29.5 70.5t70.5 29.5h100q41 0 70.5 -29.5t29.5 -70.5v-1000h-300zM900 0v700q0 41 29.5 70.5t70.5 29.5h100q41 0 70.5 -29.5t29.5 -70.5v-700h-300z" />
+<glyph unicode="&#xe186;" d="M-100 300v500q0 124 88 212t212 88h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212zM100 200h900v700h-900v-700zM200 300h300v300h-200v100h200v100h-300v-300h200v-100h-200v-100zM600 300h200v100h100v300h-100v100h-200v-500 zM700 400v300h100v-300h-100z" />
+<glyph unicode="&#xe187;" d="M-100 300v500q0 124 88 212t212 88h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212zM100 200h900v700h-900v-700zM200 300h100v200h100v-200h100v500h-100v-200h-100v200h-100v-500zM600 300h200v100h100v300h-100v100h-200v-500 zM700 400v300h100v-300h-100z" />
+<glyph unicode="&#xe188;" d="M-100 300v500q0 124 88 212t212 88h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212zM100 200h900v700h-900v-700zM200 300h300v100h-200v300h200v100h-300v-500zM600 300h300v100h-200v300h200v100h-300v-500z" />
+<glyph unicode="&#xe189;" d="M-100 300v500q0 124 88 212t212 88h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212zM100 200h900v700h-900v-700zM200 550l300 -150v300zM600 400l300 150l-300 150v-300z" />
+<glyph unicode="&#xe190;" d="M-100 300v500q0 124 88 212t212 88h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212zM100 200h900v700h-900v-700zM200 300v500h700v-500h-700zM300 400h130q41 0 68 42t27 107t-28.5 108t-66.5 43h-130v-300zM575 549 q0 -65 27 -107t68 -42h130v300h-130q-38 0 -66.5 -43t-28.5 -108z" />
+<glyph unicode="&#xe191;" d="M-100 300v500q0 124 88 212t212 88h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212zM100 200h900v700h-900v-700zM200 300h300v300h-200v100h200v100h-300v-300h200v-100h-200v-100zM601 300h100v100h-100v-100zM700 700h100 v-400h100v500h-200v-100z" />
+<glyph unicode="&#xe192;" d="M-100 300v500q0 124 88 212t212 88h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212zM100 200h900v700h-900v-700zM200 300h300v400h-200v100h-100v-500zM301 400v200h100v-200h-100zM601 300h100v100h-100v-100zM700 700h100 v-400h100v500h-200v-100z" />
+<glyph unicode="&#xe193;" d="M-100 300v500q0 124 88 212t212 88h700q124 0 212 -88t88 -212v-500q0 -124 -88 -212t-212 -88h-700q-124 0 -212 88t-88 212zM100 200h900v700h-900v-700zM200 700v100h300v-300h-99v-100h-100v100h99v200h-200zM201 300v100h100v-100h-100zM601 300v100h100v-100h-100z M700 700v100h200v-500h-100v400h-100z" />
+<glyph unicode="&#xe194;" d="M4 600q0 162 80 299t217 217t299 80t299 -80t217 -217t80 -299t-80 -299t-217 -217t-299 -80t-299 80t-217 217t-80 299zM186 600q0 -171 121.5 -292.5t292.5 -121.5t292.5 121.5t121.5 292.5t-121.5 292.5t-292.5 121.5t-292.5 -121.5t-121.5 -292.5zM400 500v200 l100 100h300v-100h-300v-200h300v-100h-300z" />
+<glyph unicode="&#xe195;" d="M0 600q0 162 80 299t217 217t299 80t299 -80t217 -217t80 -299t-80 -299t-217 -217t-299 -80t-299 80t-217 217t-80 299zM182 600q0 -171 121.5 -292.5t292.5 -121.5t292.5 121.5t121.5 292.5t-121.5 292.5t-292.5 121.5t-292.5 -121.5t-121.5 -292.5zM400 400v400h300 l100 -100v-100h-100v100h-200v-100h200v-100h-200v-100h-100zM700 400v100h100v-100h-100z" />
+<glyph unicode="&#xe197;" d="M-14 494q0 -80 56.5 -137t135.5 -57h222v300h400v-300h128q120 0 205 86.5t85 207.5t-85 207t-205 86q-46 0 -90 -14q-44 97 -134.5 156.5t-200.5 59.5q-152 0 -260 -107.5t-108 -260.5q0 -25 2 -37q-66 -14 -108.5 -67.5t-42.5 -122.5zM300 200h200v300h200v-300h200 l-300 -300z" />
+<glyph unicode="&#xe198;" d="M-14 494q0 -80 56.5 -137t135.5 -57h8l414 414l403 -403q94 26 154.5 104.5t60.5 178.5q0 120 -85 206.5t-205 86.5q-46 0 -90 -14q-44 97 -134.5 156.5t-200.5 59.5q-152 0 -260 -107.5t-108 -260.5q0 -25 2 -37q-66 -14 -108.5 -67.5t-42.5 -122.5zM300 200l300 300 l300 -300h-200v-300h-200v300h-200z" />
+<glyph unicode="&#xe199;" d="M100 200h400v-155l-75 -45h350l-75 45v155h400l-270 300h170l-270 300h170l-300 333l-300 -333h170l-270 -300h170z" />
+<glyph unicode="&#xe200;" d="M121 700q0 -53 28.5 -97t75.5 -65q-4 -16 -4 -38q0 -74 52.5 -126.5t126.5 -52.5q56 0 100 30v-306l-75 -45h350l-75 45v306q46 -30 100 -30q74 0 126.5 52.5t52.5 126.5q0 24 -9 55q50 32 79.5 83t29.5 112q0 90 -61.5 155.5t-150.5 71.5q-26 89 -99.5 145.5 t-167.5 56.5q-116 0 -197.5 -81.5t-81.5 -197.5q0 -4 1 -11.5t1 -11.5q-14 2 -23 2q-74 0 -126.5 -52.5t-52.5 -126.5z" />
+</font>
+</defs></svg> 
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/fonts/glyphicons-halflings-regular.ttf b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/fonts/glyphicons-halflings-regular.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..67fa00bf83801d2fa568546b982c80d27f6ef74e
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/fonts/glyphicons-halflings-regular.ttf differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/fonts/glyphicons-halflings-regular.woff b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/fonts/glyphicons-halflings-regular.woff
new file mode 100644
index 0000000000000000000000000000000000000000..8c54182aa5d4d1ab3c9171976b615c1dcb1dc187
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_static/fonts/glyphicons-halflings-regular.woff differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_templates/layout.html b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_templates/layout.html
new file mode 100644
index 0000000000000000000000000000000000000000..333a606c88fa1bc872595842e1e13485c78b639f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_templates/layout.html
@@ -0,0 +1,148 @@
+{% extends "!layout.html" %}
+
+{% block extrahead %}
+<meta name="description" content="Small, safe and fast formatting library">
+<meta name="keywords" content="C++, formatting, printf, string, library">
+<meta name="author" content="Victor Zverovich">
+<link rel="stylesheet" href="_static/fmt.css">
+{# Google Analytics #}
+<script async src="https://www.googletagmanager.com/gtag/js?id=UA-20116650-4"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'UA-20116650-4');
+</script>
+{% endblock %}
+
+{%- macro searchform(classes, button) %}
+<form class="{{classes}}" role="search" action="{{ pathto('search') }}"
+      method="get">
+  <div class="form-group">
+    <input type="text" name="q" class="form-control"
+           {{ 'placeholder="Search"' if not button }} >
+  </div>
+  <input type="hidden" name="check_keywords" value="yes" />
+  <input type="hidden" name="area" value="default" />
+  {% if button %}
+    <input type="submit" class="btn btn-default" value="search">
+  {% endif %}
+</form>
+{%- endmacro %}
+
+{% block header %}
+<nav class="navbar navbar-inverse">
+  <div class="tb-container">
+    <div class="row">
+      <div class="navbar-content">
+        {# Brand and toggle get grouped for better mobile display #}
+        <div class="navbar-header">
+          <button type="button" class="navbar-toggle collapsed"
+                  data-toggle="collapse" data-target=".navbar-collapse">
+            <span class="sr-only">Toggle navigation</span>
+            <span class="icon-bar"></span>
+            <span class="icon-bar"></span>
+            <span class="icon-bar"></span>
+          </button>
+          <a class="navbar-brand" href="index.html">{fmt}</a>
+        </div>
+
+        {# Collect the nav links, forms, and other content for toggling #}
+        <div class="collapse navbar-collapse">
+          <ul class="nav navbar-nav">
+            <li class="dropdown">
+              <a href="#" class="dropdown-toggle" data-toggle="dropdown"
+                 role="button" aria-expanded="false">{{ version }}
+                <span class="caret"></span></a>
+              <ul class="dropdown-menu" role="menu">
+                {% for v in versions.split(',') %}
+                <li><a href="https://fmt.dev/{{v}}">{{v}}</a></li>
+                {% endfor %}
+              </ul>
+            </li>
+            {% for name in ['Contents', 'Usage', 'API', 'Syntax'] %}
+              {% if pagename == name.lower() %}
+              <li class="active"><a href="{{name.lower()}}.html">{{name}}
+                <span class="sr-only">(current)</span></a></li>
+              {%else%}
+              <li><a href="{{name.lower()}}.html">{{name}}</a></li>
+              {%endif%}
+            {% endfor %}
+          </ul>
+          {% if pagename != 'search' %}
+            {{ searchform('navbar-form navbar-right', False) }}
+          {%endif%}
+        </div> {# /.navbar-collapse #}
+      </div> {# /.col-md-offset-2 #}
+    </div> {# /.row #}
+  </div> {# /.tb-container #}
+</nav>
+{% if pagename == "index" %}
+{% set download_url = 'https://github.com/fmtlib/fmt/releases/download' %}
+<div class="jumbotron">
+  <div class="tb-container">
+    <h1>{fmt}</h1>
+    <p class="lead">A modern formatting library</p>
+    <div class="btn-group" role="group">
+      {% set name = 'fmt' if version.split('.')[0]|int >= 3 else 'cppformat' %}
+      <a class="btn btn-success"
+         href="{{download_url}}/{{version}}/{{name}}-{{version}}.zip">
+           <span class="glyphicon glyphicon-download"></span> Download
+      </a>
+      <button type="button" class="btn btn-success dropdown-toggle"
+        data-toggle="dropdown"><span class="caret"></span></button>
+      <ul class="dropdown-menu">
+      {% for v in versions.split(',') %}
+      {% set name = 'fmt' if v.split('.')[0]|int >= 3 else 'cppformat' %}
+        <li><a href="{{download_url}}/{{v}}/{{name}}-{{v}}.zip">Version {{v}}
+          </a></li>
+      {% endfor %}
+      </ul>
+    </div>
+  </div>
+</div>
+{% endif %}
+{% endblock %}
+
+{# Disable relbars. #}
+{% block relbar1 %}
+{% endblock %}
+{% block relbar2 %}
+{% endblock %}
+
+{% block content %}
+<div class="tb-container">
+  <div class="row">
+    {# Sidebar is currently disabled.
+    <div class="bs-sidebar">
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+          {%- block sidebarlogo %}
+          {%- if logo %}
+            <p class="logo"><a href="{{ pathto(master_doc) }}">
+              <img class="logo" src="{{ pathto('_static/' + logo, 1) }}"
+                   alt="Logo"/>
+            </a></p>
+          {%- endif %}
+          {%- endblock %}
+          {%- for sidebartemplate in sidebars %}
+          {%- include sidebartemplate %}
+          {%- endfor %}
+        </div>
+      </div>
+    </div>
+    #}
+
+    <div class="content">
+      {% block body %} {% endblock %}
+    </div>
+  </div>
+</div>
+{% endblock %}
+
+{% block footer %}
+{{ super() }}
+{# Placed at the end of the document so the pages load faster. #}
+<script src="_static/bootstrap.min.js"></script>
+{% endblock %}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_templates/search.html b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_templates/search.html
new file mode 100644
index 0000000000000000000000000000000000000000..488e0b5d255af5a803b7339bf40beba4eb6d0aa5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/_templates/search.html
@@ -0,0 +1,55 @@
+{#
+    basic/search.html
+    ~~~~~~~~~~~~~~~~~
+
+    Template for the search page.
+
+    :copyright: Copyright 2007-2015 by the Sphinx team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+#}
+{%- extends "layout.html" %}
+{% set title = _('Search') %}
+{% set script_files = script_files + ['_static/searchtools.js'] %}
+{% block extrahead %}
+  <script type="text/javascript">
+    jQuery(function() { Search.loadIndex("{{ pathto('searchindex.js', 1) }}"); });
+  </script>
+  {# this is used when loading the search index using $.ajax fails,
+     such as on Chrome for documents on localhost #}
+  <script type="text/javascript" id="searchindexloader"></script>
+  {{ super() }}
+{% endblock %}
+{% block body %}
+  <h1 id="search-documentation">{{ _('Search') }}</h1>
+  <div id="fallback" class="admonition warning">
+  <script type="text/javascript">$('#fallback').hide();</script>
+  <p>
+    {% trans %}Please activate JavaScript to enable the search
+    functionality.{% endtrans %}
+  </p>
+  </div>
+  <p>
+    {% trans %}From here you can search these documents. Enter your search
+    words into the box below and click "search". Note that the search
+    function will automatically search for all of the words. Pages
+    containing fewer words won't appear in the result list.{% endtrans %}
+  </p>
+  {{ searchform('form-inline', True) }}
+  {% if search_performed %}
+    <h2>{{ _('Search Results') }}</h2>
+    {% if not search_results %}
+      <p>{{ _('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.') }}</p>
+    {% endif %}
+  {% endif %}
+  <div id="search-results">
+  {% if search_results %}
+    <ul>
+    {% for href, caption, context in search_results %}
+      <li><a href="{{ pathto(item.href) }}">{{ caption }}</a>
+        <div class="context">{{ context|e }}</div>
+      </li>
+    {% endfor %}
+    </ul>
+  {% endif %}
+  </div>
+{% endblock %}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/api.rst b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/api.rst
new file mode 100644
index 0000000000000000000000000000000000000000..31b0328dea2bb789995591a69e705625a754c454
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/api.rst
@@ -0,0 +1,678 @@
+.. _string-formatting-api:
+
+*************
+API Reference
+*************
+
+The {fmt} library API consists of the following parts:
+
+* :ref:`fmt/core.h <core-api>`: the core API providing main formatting functions
+  for ``char``/UTF-8 with C++20 compile-time checks and minimal dependencies
+* :ref:`fmt/format.h <format-api>`: the full format API providing additional
+  formatting functions and locale support
+* :ref:`fmt/ranges.h <ranges-api>`: formatting of ranges and tuples
+* :ref:`fmt/chrono.h <chrono-api>`: date and time formatting
+* :ref:`fmt/std.h <std-api>`: formatters for standard library types
+* :ref:`fmt/compile.h <compile-api>`: format string compilation
+* :ref:`fmt/color.h <color-api>`: terminal color and text style
+* :ref:`fmt/os.h <os-api>`: system APIs
+* :ref:`fmt/ostream.h <ostream-api>`: ``std::ostream`` support
+* :ref:`fmt/args.h <args-api>`: dynamic argument lists
+* :ref:`fmt/printf.h <printf-api>`: ``printf`` formatting
+* :ref:`fmt/xchar.h <xchar-api>`: optional ``wchar_t`` support 
+
+All functions and types provided by the library reside in namespace ``fmt`` and
+macros have prefix ``FMT_``.
+
+.. _core-api:
+
+Core API
+========
+
+``fmt/core.h`` defines the core API which provides main formatting functions
+for ``char``/UTF-8 with C++20 compile-time checks. It has minimal include
+dependencies for better compile times. This header is only beneficial when
+using {fmt} as a library (the default) and not in the header-only mode.
+It also provides ``formatter`` specializations for built-in and string types.
+
+The following functions use :ref:`format string syntax <syntax>`
+similar to that of Python's `str.format
+<https://docs.python.org/3/library/stdtypes.html#str.format>`_.
+They take *fmt* and *args* as arguments.
+
+*fmt* is a format string that contains literal text and replacement fields
+surrounded by braces ``{}``. The fields are replaced with formatted arguments
+in the resulting string. `~fmt::format_string` is a format string which can be
+implicitly constructed from a string literal or a ``constexpr`` string and is
+checked at compile time in C++20. To pass a runtime format string wrap it in
+`fmt::runtime`.
+
+*args* is an argument list representing objects to be formatted.
+
+I/O errors are reported as `std::system_error
+<https://en.cppreference.com/w/cpp/error/system_error>`_ exceptions unless
+specified otherwise.
+
+.. _format:
+
+.. doxygenfunction:: format(format_string<T...> fmt, T&&... args) -> std::string
+.. doxygenfunction:: vformat(string_view fmt, format_args args) -> std::string
+
+.. doxygenfunction:: format_to(OutputIt out, format_string<T...> fmt, T&&... args) -> OutputIt
+.. doxygenfunction:: format_to_n(OutputIt out, size_t n, format_string<T...> fmt, T&&... args) -> format_to_n_result<OutputIt>
+.. doxygenfunction:: formatted_size(format_string<T...> fmt, T&&... args) -> size_t
+
+.. doxygenstruct:: fmt::format_to_n_result
+   :members:
+
+.. _print:
+
+.. doxygenfunction:: fmt::print(format_string<T...> fmt, T&&... args)
+.. doxygenfunction:: fmt::vprint(string_view fmt, format_args args)
+
+.. doxygenfunction:: print(std::FILE *f, format_string<T...> fmt, T&&... args)
+.. doxygenfunction:: vprint(std::FILE *f, string_view fmt, format_args args)
+
+Compile-Time Format String Checks
+---------------------------------
+
+Compile-time format string checks are enabled by default on compilers
+that support C++20 ``consteval``. On older compilers you can use the
+:ref:`FMT_STRING <legacy-checks>`: macro defined in ``fmt/format.h`` instead.
+
+Unused arguments are allowed as in Python's `str.format` and ordinary functions.
+
+.. doxygenclass:: fmt::basic_format_string
+   :members:
+
+.. doxygentypedef:: fmt::format_string
+
+.. doxygenfunction:: fmt::runtime(string_view) -> runtime_format_string<>
+
+.. _udt:
+
+Formatting User-Defined Types
+-----------------------------
+
+The {fmt} library provides formatters for many standard C++ types.
+See :ref:`fmt/ranges.h <ranges-api>` for ranges and tuples including standard
+containers such as ``std::vector``, :ref:`fmt/chrono.h <chrono-api>` for date
+and time formatting and :ref:`fmt/std.h <std-api>` for other standard library
+types.
+
+There are two ways to make a user-defined type formattable: providing a
+``format_as`` function or specializing the ``formatter`` struct template.
+
+Use ``format_as`` if you want to make your type formattable as some other type
+with the same format specifiers. The ``format_as`` function should take an
+object of your type and return an object of a formattable type. It should be
+defined in the same namespace as your type.
+
+Example (https://godbolt.org/z/nvME4arz8)::
+
+  #include <fmt/format.h>
+
+  namespace kevin_namespacy {
+  enum class film {
+    house_of_cards, american_beauty, se7en = 7
+  };
+  auto format_as(film f) { return fmt::underlying(f); }
+  }
+
+  int main() {
+    fmt::print("{}\n", kevin_namespacy::film::se7en); // prints "7"
+  }
+
+Using specialization is more complex but gives you full control over parsing and
+formatting. To use this method specialize the ``formatter`` struct template for
+your type and implement ``parse`` and ``format`` methods.
+
+The recommended way of defining a formatter is by reusing an existing one via
+inheritance or composition. This way you can support standard format specifiers
+without implementing them yourself. For example::
+
+  // color.h:
+  #include <fmt/core.h>
+
+  enum class color {red, green, blue};
+
+  template <> struct fmt::formatter<color>: formatter<string_view> {
+    // parse is inherited from formatter<string_view>.
+
+    auto format(color c, format_context& ctx) const;
+  };
+
+  // color.cc:
+  #include "color.h"
+  #include <fmt/format.h>
+
+  auto fmt::formatter<color>::format(color c, format_context& ctx) const {
+    string_view name = "unknown";
+    switch (c) {
+    case color::red:   name = "red"; break;
+    case color::green: name = "green"; break;
+    case color::blue:  name = "blue"; break;
+    }
+    return formatter<string_view>::format(name, ctx);
+  }
+
+Note that ``formatter<string_view>::format`` is defined in ``fmt/format.h`` so
+it has to be included in the source file. Since ``parse`` is inherited from
+``formatter<string_view>`` it will recognize all string format specifications,
+for example
+
+.. code-block:: c++
+
+   fmt::format("{:>10}", color::blue)
+
+will return ``"      blue"``.
+
+The experimental ``nested_formatter`` provides an easy way of applying a
+formatter to one or more subobjects.
+
+For example::
+
+  #include <fmt/format.h>
+
+  struct point {
+    double x, y;
+  };
+
+  template <>
+  struct fmt::formatter<point> : nested_formatter<double> {
+    auto format(point p, format_context& ctx) const {
+      return write_padded(ctx, [=](auto out) {
+        return format_to(out, "({}, {})", nested(p.x), nested(p.y));
+      });
+    }
+  };
+
+  int main() {
+    fmt::print("[{:>20.2f}]", point{1, 2});
+  }
+
+prints::
+
+  [          (1.00, 2.00)]
+
+Notice that fill, align and width are applied to the whole object which is the
+recommended behavior while the remaining specifiers apply to elements.
+
+In general the formatter has the following form::
+
+  template <> struct fmt::formatter<T> {
+    // Parses format specifiers and stores them in the formatter.
+    //
+    // [ctx.begin(), ctx.end()) is a, possibly empty, character range that
+    // contains a part of the format string starting from the format
+    // specifications to be parsed, e.g. in
+    //
+    //   fmt::format("{:f} continued", ...);
+    //
+    // the range will contain "f} continued". The formatter should parse
+    // specifiers until '}' or the end of the range. In this example the
+    // formatter should parse the 'f' specifier and return an iterator
+    // pointing to '}'.
+    constexpr auto parse(format_parse_context& ctx)
+      -> format_parse_context::iterator;
+
+    // Formats value using the parsed format specification stored in this
+    // formatter and writes the output to ctx.out().
+    auto format(const T& value, format_context& ctx) const
+      -> format_context::iterator;
+  };
+
+It is recommended to at least support fill, align and width that apply to the
+whole object and have the same semantics as in standard formatters.
+
+You can also write a formatter for a hierarchy of classes::
+
+  // demo.h:
+  #include <type_traits>
+  #include <fmt/core.h>
+
+  struct A {
+    virtual ~A() {}
+    virtual std::string name() const { return "A"; }
+  };
+
+  struct B : A {
+    virtual std::string name() const { return "B"; }
+  };
+
+  template <typename T>
+  struct fmt::formatter<T, std::enable_if_t<std::is_base_of<A, T>::value, char>> :
+      fmt::formatter<std::string> {
+    auto format(const A& a, format_context& ctx) const {
+      return fmt::formatter<std::string>::format(a.name(), ctx);
+    }
+  };
+
+  // demo.cc:
+  #include "demo.h"
+  #include <fmt/format.h>
+
+  int main() {
+    B b;
+    A& a = b;
+    fmt::print("{}", a); // prints "B"
+  }
+
+Providing both a ``formatter`` specialization and a ``format_as`` overload is
+disallowed.
+
+Named Arguments
+---------------
+
+.. doxygenfunction:: fmt::arg(const S&, const T&)
+
+Named arguments are not supported in compile-time checks at the moment.
+
+Argument Lists
+--------------
+
+You can create your own formatting function with compile-time checks and small
+binary footprint, for example (https://godbolt.org/z/vajfWEG4b):
+
+.. code:: c++
+
+    #include <fmt/core.h>
+
+    void vlog(const char* file, int line, fmt::string_view format,
+              fmt::format_args args) {
+      fmt::print("{}: {}: ", file, line);
+      fmt::vprint(format, args);
+    }
+
+    template <typename... T>
+    void log(const char* file, int line, fmt::format_string<T...> format, T&&... args) {
+      vlog(file, line, format, fmt::make_format_args(args...));
+    }
+
+    #define MY_LOG(format, ...) log(__FILE__, __LINE__, format, __VA_ARGS__)
+
+    MY_LOG("invalid squishiness: {}", 42);
+
+Note that ``vlog`` is not parameterized on argument types which improves compile
+times and reduces binary code size compared to a fully parameterized version.
+
+.. doxygenfunction:: fmt::make_format_args(const Args&...)
+
+.. doxygenclass:: fmt::format_arg_store
+   :members:
+
+.. doxygenclass:: fmt::basic_format_args
+   :members:
+
+.. doxygentypedef:: fmt::format_args
+
+.. doxygenclass:: fmt::basic_format_arg
+   :members:
+
+.. doxygenclass:: fmt::basic_format_parse_context
+   :members:
+
+.. doxygenclass:: fmt::basic_format_context
+   :members:
+
+.. doxygentypedef:: fmt::format_context
+
+.. _args-api:
+
+Dynamic Argument Lists
+----------------------
+
+The header ``fmt/args.h`` provides ``dynamic_format_arg_store``, a builder-like
+API that can be used to construct format argument lists dynamically.
+
+.. doxygenclass:: fmt::dynamic_format_arg_store
+   :members:
+
+Compatibility
+-------------
+
+.. doxygenclass:: fmt::basic_string_view
+   :members:
+
+.. doxygentypedef:: fmt::string_view
+
+.. _format-api:
+
+Format API
+==========
+
+``fmt/format.h`` defines the full format API providing additional formatting
+functions and locale support.
+
+Literal-Based API
+-----------------
+
+The following user-defined literals are defined in ``fmt/format.h``.
+
+.. doxygenfunction:: operator""_a()
+
+Utilities
+---------
+
+.. doxygenfunction:: fmt::ptr(T p) -> const void*
+.. doxygenfunction:: fmt::ptr(const std::unique_ptr<T, Deleter> &p) -> const void*
+.. doxygenfunction:: fmt::ptr(const std::shared_ptr<T> &p) -> const void*
+
+.. doxygenfunction:: fmt::underlying(Enum e) -> typename std::underlying_type<Enum>::type
+
+.. doxygenfunction:: fmt::to_string(const T &value) -> std::string
+
+.. doxygenfunction:: fmt::join(Range &&range, string_view sep) -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>>
+
+.. doxygenfunction:: fmt::join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel>
+
+.. doxygenfunction:: fmt::group_digits(T value) -> group_digits_view<T>
+
+.. doxygenclass:: fmt::detail::buffer
+   :members:
+
+.. doxygenclass:: fmt::basic_memory_buffer
+   :protected-members:
+   :members:
+
+System Errors
+-------------
+
+{fmt} does not use ``errno`` to communicate errors to the user, but it may call
+system functions which set ``errno``. Users should not make any assumptions
+about the value of ``errno`` being preserved by library functions.
+
+.. doxygenfunction:: fmt::system_error
+
+.. doxygenfunction:: fmt::format_system_error
+
+Custom Allocators
+-----------------
+
+The {fmt} library supports custom dynamic memory allocators.
+A custom allocator class can be specified as a template argument to
+:class:`fmt::basic_memory_buffer`::
+
+    using custom_memory_buffer = 
+      fmt::basic_memory_buffer<char, fmt::inline_buffer_size, custom_allocator>;
+
+It is also possible to write a formatting function that uses a custom
+allocator::
+
+    using custom_string =
+      std::basic_string<char, std::char_traits<char>, custom_allocator>;
+
+    custom_string vformat(custom_allocator alloc, fmt::string_view format_str,
+                          fmt::format_args args) {
+      auto buf = custom_memory_buffer(alloc);
+      fmt::vformat_to(std::back_inserter(buf), format_str, args);
+      return custom_string(buf.data(), buf.size(), alloc);
+    }
+
+    template <typename ...Args>
+    inline custom_string format(custom_allocator alloc,
+                                fmt::string_view format_str,
+                                const Args& ... args) {
+      return vformat(alloc, format_str, fmt::make_format_args(args...));
+    }
+
+The allocator will be used for the output container only. Formatting functions
+normally don't do any allocations for built-in and string types except for
+non-default floating-point formatting that occasionally falls back on
+``sprintf``.
+
+Locale
+------
+
+All formatting is locale-independent by default. Use the ``'L'`` format
+specifier to insert the appropriate number separator characters from the
+locale::
+
+  #include <fmt/core.h>
+  #include <locale>
+
+  std::locale::global(std::locale("en_US.UTF-8"));
+  auto s = fmt::format("{:L}", 1000000);  // s == "1,000,000"
+
+``fmt/format.h`` provides the following overloads of formatting functions that
+take ``std::locale`` as a parameter. The locale type is a template parameter to
+avoid the expensive ``<locale>`` include.
+
+.. doxygenfunction:: format(const Locale& loc, format_string<T...> fmt, T&&... args) -> std::string
+.. doxygenfunction:: format_to(OutputIt out, const Locale& loc, format_string<T...> fmt, T&&... args) -> OutputIt
+.. doxygenfunction:: formatted_size(const Locale& loc, format_string<T...> fmt, T&&... args) -> size_t
+
+.. _legacy-checks:
+
+Legacy Compile-Time Format String Checks
+----------------------------------------
+
+``FMT_STRING`` enables compile-time checks on older compilers. It requires C++14
+or later and is a no-op in C++11.
+
+.. doxygendefine:: FMT_STRING
+
+To force the use of legacy compile-time checks, define the preprocessor variable
+``FMT_ENFORCE_COMPILE_STRING``. When set, functions accepting ``FMT_STRING``
+will fail to compile with regular strings.
+
+.. _ranges-api:
+
+Range and Tuple Formatting
+==========================
+
+The library also supports convenient formatting of ranges and tuples::
+
+  #include <fmt/ranges.h>
+
+  std::tuple<char, int, float> t{'a', 1, 2.0f};
+  // Prints "('a', 1, 2.0)"
+  fmt::print("{}", t);
+
+
+NOTE: currently, the overload of ``fmt::join`` for iterables exists in the main
+``format.h`` header, but expect this to change in the future.
+
+Using ``fmt::join``, you can separate tuple elements with a custom separator::
+
+  #include <fmt/ranges.h>
+
+  std::tuple<int, char> t = {1, 'a'};
+  // Prints "1, a"
+  fmt::print("{}", fmt::join(t, ", "));
+
+.. _chrono-api:
+
+Date and Time Formatting
+========================
+
+``fmt/chrono.h`` provides formatters for
+
+* `std::chrono::duration <https://en.cppreference.com/w/cpp/chrono/duration>`_
+* `std::chrono::time_point
+  <https://en.cppreference.com/w/cpp/chrono/time_point>`_
+* `std::tm <https://en.cppreference.com/w/cpp/chrono/c/tm>`_
+
+The format syntax is described in :ref:`chrono-specs`.
+
+**Example**::
+
+  #include <fmt/chrono.h>
+
+  int main() {
+    std::time_t t = std::time(nullptr);
+
+    // Prints "The date is 2020-11-07." (with the current date):
+    fmt::print("The date is {:%Y-%m-%d}.", fmt::localtime(t));
+
+    using namespace std::literals::chrono_literals;
+
+    // Prints "Default format: 42s 100ms":
+    fmt::print("Default format: {} {}\n", 42s, 100ms);
+
+    // Prints "strftime-like format: 03:15:30":
+    fmt::print("strftime-like format: {:%H:%M:%S}\n", 3h + 15min + 30s);
+  }
+
+.. doxygenfunction:: localtime(std::time_t time)
+
+.. doxygenfunction:: gmtime(std::time_t time)
+
+.. _std-api:
+
+Standard Library Types Formatting
+=================================
+
+``fmt/std.h`` provides formatters for:
+
+* `std::filesystem::path <https://en.cppreference.com/w/cpp/filesystem/path>`_
+* `std::thread::id <https://en.cppreference.com/w/cpp/thread/thread/id>`_
+* `std::monostate <https://en.cppreference.com/w/cpp/utility/variant/monostate>`_
+* `std::variant <https://en.cppreference.com/w/cpp/utility/variant/variant>`_
+* `std::optional <https://en.cppreference.com/w/cpp/utility/optional>`_
+
+Formatting Variants
+-------------------
+
+A ``std::variant`` is only formattable if every variant alternative is formattable, and requires the
+``__cpp_lib_variant`` `library feature <https://en.cppreference.com/w/cpp/feature_test>`_.
+  
+**Example**::
+
+  #include <fmt/std.h>
+
+  std::variant<char, float> v0{'x'};
+  // Prints "variant('x')"
+  fmt::print("{}", v0);
+
+  std::variant<std::monostate, char> v1;
+  // Prints "variant(monostate)"
+
+.. _compile-api:
+
+Format String Compilation
+=========================
+
+``fmt/compile.h`` provides format string compilation enabled via the
+``FMT_COMPILE`` macro or the ``_cf`` user-defined literal. Format strings
+marked with ``FMT_COMPILE`` or ``_cf`` are parsed, checked and converted into
+efficient formatting code at compile-time. This supports arguments of built-in
+and string types as well as user-defined types with ``format`` functions taking
+the format context type as a template parameter in their ``formatter``
+specializations. For example::
+
+  template <> struct fmt::formatter<point> {
+    constexpr auto parse(format_parse_context& ctx);
+
+    template <typename FormatContext>
+    auto format(const point& p, FormatContext& ctx) const;
+  };
+
+Format string compilation can generate more binary code compared to the default
+API and is only recommended in places where formatting is a performance
+bottleneck.
+
+.. doxygendefine:: FMT_COMPILE
+
+.. doxygenfunction:: operator""_cf()
+
+.. _color-api:
+
+Terminal Color and Text Style
+=============================
+
+``fmt/color.h`` provides support for terminal color and text style output.
+
+.. doxygenfunction:: print(const text_style &ts, const S &format_str, const Args&... args)
+
+.. doxygenfunction:: fg(detail::color_type)
+
+.. doxygenfunction:: bg(detail::color_type)
+
+.. doxygenfunction:: styled(const T& value, text_style ts)
+
+.. _os-api:
+
+System APIs
+===========
+
+.. doxygenclass:: fmt::ostream
+   :members:
+
+.. doxygenfunction:: fmt::windows_error
+
+.. _ostream-api:
+
+``std::ostream`` Support
+========================
+
+``fmt/ostream.h`` provides ``std::ostream`` support including formatting of
+user-defined types that have an overloaded insertion operator (``operator<<``).
+In order to make a type formattable via ``std::ostream`` you should provide a
+``formatter`` specialization inherited from ``ostream_formatter``::
+
+  #include <fmt/ostream.h>
+
+  struct date {
+    int year, month, day;
+
+    friend std::ostream& operator<<(std::ostream& os, const date& d) {
+      return os << d.year << '-' << d.month << '-' << d.day;
+    }
+  };
+
+  template <> struct fmt::formatter<date> : ostream_formatter {};
+
+  std::string s = fmt::format("The date is {}", date{2012, 12, 9});
+  // s == "The date is 2012-12-9"
+
+.. doxygenfunction:: streamed(const T &)
+
+.. doxygenfunction:: print(std::ostream &os, format_string<T...> fmt, T&&... args)
+
+.. _printf-api:
+
+``printf`` Formatting
+=====================
+
+The header ``fmt/printf.h`` provides ``printf``-like formatting functionality.
+The following functions use `printf format string syntax
+<https://pubs.opengroup.org/onlinepubs/009695399/functions/fprintf.html>`_ with
+the POSIX extension for positional arguments. Unlike their standard
+counterparts, the ``fmt`` functions are type-safe and throw an exception if an
+argument type doesn't match its format specification.
+
+.. doxygenfunction:: printf(string_view fmt, const T&... args) -> int
+
+.. doxygenfunction:: fprintf(std::FILE *f, const S &fmt, const T&... args) -> int
+
+.. doxygenfunction:: sprintf(const S&, const T&...)
+
+.. _xchar-api:
+
+``wchar_t`` Support
+===================
+
+The optional header ``fmt/xchar.h`` provides support for ``wchar_t`` and exotic
+character types.
+
+.. doxygenstruct:: fmt::is_char
+
+.. doxygentypedef:: fmt::wstring_view
+
+.. doxygentypedef:: fmt::wformat_context
+
+.. doxygenfunction:: fmt::to_wstring(const T &value)
+
+Compatibility with C++20 ``std::format``
+========================================
+
+{fmt} implements nearly all of the `C++20 formatting library
+<https://en.cppreference.com/w/cpp/utility/format>`_ with the following
+differences:
+
+* Names are defined in the ``fmt`` namespace instead of ``std`` to avoid
+  collisions with standard library implementations.
+* Width calculation doesn't use grapheme clusterization. The latter has been
+  implemented in a separate branch but hasn't been integrated yet.
+* Most C++20 chrono types are not supported yet.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/basic-bootstrap/README b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/basic-bootstrap/README
new file mode 100644
index 0000000000000000000000000000000000000000..ba67700dfd0229e1883f5a10ba3dce838269c4a5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/basic-bootstrap/README
@@ -0,0 +1,2 @@
+Sphinx basic theme with Bootstrap support. Modifications are kept to
+a minimum to simplify integration in case of changes to Sphinx theming.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/basic-bootstrap/layout.html b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/basic-bootstrap/layout.html
new file mode 100644
index 0000000000000000000000000000000000000000..5519c4b5cea89198ad682193fd029cf5c7df5a62
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/basic-bootstrap/layout.html
@@ -0,0 +1,208 @@
+{#
+    basic/layout.html
+    ~~~~~~~~~~~~~~~~~
+
+    Master layout template for Sphinx themes.
+
+    :copyright: Copyright 2007-2015 by the Sphinx team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+#}
+{%- block doctype -%}
+<!DOCTYPE html>
+{%- endblock %}
+{%- set reldelim1 = reldelim1 is not defined and ' &raquo;' or reldelim1 %}
+{%- set reldelim2 = reldelim2 is not defined and ' |' or reldelim2 %}
+{%- set render_sidebar = (not embedded) and (not theme_nosidebar|tobool) and
+                         (sidebars != []) %}
+{%- set url_root = pathto('', 1) %}
+{# XXX necessary? #}
+{%- if url_root == '#' %}{% set url_root = '' %}{% endif %}
+{%- if not embedded and docstitle %}
+  {%- set titlesuffix = " &mdash; "|safe + docstitle|e %}
+{%- else %}
+  {%- set titlesuffix = "" %}
+{%- endif %}
+
+{%- macro relbar() %}
+    <div class="related" role="navigation" aria-label="related navigation">
+      <h3>{{ _('Navigation') }}</h3>
+      <ul>
+        {%- for rellink in rellinks %}
+        <li class="right" {% if loop.first %}style="margin-right: 10px"{% endif %}>
+          <a href="{{ pathto(rellink[0]) }}" title="{{ rellink[1]|striptags|e }}"
+             {{ accesskey(rellink[2]) }}>{{ rellink[3] }}</a>
+          {%- if not loop.first %}{{ reldelim2 }}{% endif %}</li>
+        {%- endfor %}
+        {%- block rootrellink %}
+        <li class="nav-item nav-item-0"><a href="{{ pathto(master_doc) }}">{{ shorttitle|e }}</a>{{ reldelim1 }}</li>
+        {%- endblock %}
+        {%- for parent in parents %}
+          <li class="nav-item nav-item-{{ loop.index }}"><a href="{{ parent.link|e }}" {% if loop.last %}{{ accesskey("U") }}{% endif %}>{{ parent.title }}</a>{{ reldelim1 }}</li>
+        {%- endfor %}
+        {%- block relbaritems %} {% endblock %}
+      </ul>
+    </div>
+{%- endmacro %}
+
+{%- macro sidebar() %}
+      {%- if render_sidebar %}
+      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
+        <div class="sphinxsidebarwrapper">
+          {%- block sidebarlogo %}
+          {%- if logo %}
+            <p class="logo"><a href="{{ pathto(master_doc) }}">
+              <img class="logo" src="{{ pathto('_static/' + logo, 1) }}" alt="Logo"/>
+            </a></p>
+          {%- endif %}
+          {%- endblock %}
+          {%- if sidebars != None %}
+            {#- new style sidebar: explicitly include/exclude templates #}
+            {%- for sidebartemplate in sidebars %}
+            {%- include sidebartemplate %}
+            {%- endfor %}
+          {%- else %}
+            {#- old style sidebars: using blocks -- should be deprecated #}
+            {%- block sidebartoc %}
+            {%- include "localtoc.html" %}
+            {%- endblock %}
+            {%- block sidebarrel %}
+            {%- include "relations.html" %}
+            {%- endblock %}
+            {%- block sidebarsourcelink %}
+            {%- include "sourcelink.html" %}
+            {%- endblock %}
+            {%- if customsidebar %}
+            {%- include customsidebar %}
+            {%- endif %}
+            {%- block sidebarsearch %}
+            {%- include "searchbox.html" %}
+            {%- endblock %}
+          {%- endif %}
+        </div>
+      </div>
+      {%- endif %}
+{%- endmacro %}
+
+{%- macro script() %}
+    <script type="text/javascript">
+      var DOCUMENTATION_OPTIONS = {
+        URL_ROOT:    '{{ url_root }}',
+        VERSION:     '{{ release|e }}',
+        COLLAPSE_INDEX: false,
+        FILE_SUFFIX: '{{ '' if no_search_suffix else file_suffix }}',
+        LINK_SUFFIX: '{{ link_suffix }}',
+        SOURCELINK_SUFFIX: '{{ sourcelink_suffix }}',
+        HAS_SOURCE:  {{ has_source|lower }},
+        SOURCELINK_SUFFIX:  '{{ sourcelink_suffix }}'
+      };
+    </script>
+    {%- for scriptfile in script_files %}
+    {{ js_tag(scriptfile) }}
+    {%- endfor %}
+{%- endmacro %}
+
+{%- macro css() %}
+    <link rel="stylesheet" href="{{ pathto('_static/' + style, 1) }}" type="text/css" />
+    <link rel="stylesheet" href="{{ pathto('_static/pygments.css', 1) }}" type="text/css" />
+    {%- for cssfile in css_files %}
+    <link rel="stylesheet" href="{{ pathto(cssfile, 1) }}" type="text/css" />
+    {%- endfor %}
+{%- endmacro %}
+
+<html lang="en">
+  <head>
+    <meta charset="{{ encoding }}">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    {# The above 3 meta tags *must* come first in the head; any other head content
+       must come *after* these tags. #}
+    {{ metatags }}
+    {%- block htmltitle %}
+    <title>{{ title|striptags|e }}{{ titlesuffix }}</title>
+    {%- endblock %}
+    {{ css() }}
+    {%- if not embedded %}
+    {{ script() }}
+    {%- if use_opensearch %}
+    <link rel="search" type="application/opensearchdescription+xml"
+          title="{% trans docstitle=docstitle|e %}Search within {{ docstitle }}{% endtrans %}"
+          href="{{ pathto('_static/opensearch.xml', 1) }}"/>
+    {%- endif %}
+    {%- if favicon %}
+    <link rel="shortcut icon" href="{{ pathto('_static/' + favicon, 1) }}"/>
+    {%- endif %}
+    {%- endif %}
+{%- block linktags %}
+    {%- if hasdoc('about') %}
+    <link rel="author" title="{{ _('About these documents') }}" href="{{ pathto('about') }}" />
+    {%- endif %}
+    {%- if hasdoc('genindex') %}
+    <link rel="index" title="{{ _('Index') }}" href="{{ pathto('genindex') }}" />
+    {%- endif %}
+    {%- if hasdoc('search') %}
+    <link rel="search" title="{{ _('Search') }}" href="{{ pathto('search') }}" />
+    {%- endif %}
+    {%- if hasdoc('copyright') %}
+    <link rel="copyright" title="{{ _('Copyright') }}" href="{{ pathto('copyright') }}" />
+    {%- endif %}
+    {%- if parents %}
+    <link rel="up" title="{{ parents[-1].title|striptags|e }}" href="{{ parents[-1].link|e }}" />
+    {%- endif %}
+    {%- if next %}
+    <link rel="next" title="{{ next.title|striptags|e }}" href="{{ next.link|e }}" />
+    {%- endif %}
+    {%- if prev %}
+    <link rel="prev" title="{{ prev.title|striptags|e }}" href="{{ prev.link|e }}" />
+    {%- endif %}
+{%- endblock %}
+{%- block extrahead %} {% endblock %}
+  </head>
+  <body role="document">
+{%- block header %}{% endblock %}
+
+{%- block relbar1 %}{{ relbar() }}{% endblock %}
+
+{%- block content %}
+  {%- block sidebar1 %} {# possible location for sidebar #} {% endblock %}
+
+    <div class="document">
+  {%- block document %}
+      <div class="documentwrapper">
+      {%- if render_sidebar %}
+        <div class="bodywrapper">
+      {%- endif %}
+          <div class="body" role="main">
+            {% block body %} {% endblock %}
+          </div>
+      {%- if render_sidebar %}
+        </div>
+      {%- endif %}
+      </div>
+  {%- endblock %}
+
+  {%- block sidebar2 %}{{ sidebar() }}{% endblock %}
+      <div class="clearer"></div>
+    </div>
+{%- endblock %}
+
+{%- block relbar2 %}{{ relbar() }}{% endblock %}
+
+{%- block footer %}
+    <div class="footer" role="contentinfo">
+    {%- if show_copyright %}
+      {%- if hasdoc('copyright') %}
+        {% trans path=pathto('copyright'), copyright=copyright|e %}&copy; <a href="{{ path }}">Copyright</a> {{ copyright }}.{% endtrans %}
+      {%- else %}
+        {% trans copyright=copyright|e %}&copy; Copyright {{ copyright }}.{% endtrans %}
+      {%- endif %}
+    {%- endif %}
+    {%- if last_updated %}
+      {% trans last_updated=last_updated|e %}Last updated on {{ last_updated }}.{% endtrans %}
+    {%- endif %}
+    {%- if show_sphinx %}
+      {% trans sphinx_version=sphinx_version|e %}Created using <a href="http://sphinx-doc.org/">Sphinx</a> {{ sphinx_version }}.{% endtrans %}
+    {%- endif %}
+    </div>
+{%- endblock %}
+  </body>
+</html>
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/basic-bootstrap/theme.conf b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/basic-bootstrap/theme.conf
new file mode 100644
index 0000000000000000000000000000000000000000..89e03bbdac5e2ff5c08eb4bc4918067516932c5c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/basic-bootstrap/theme.conf
@@ -0,0 +1,2 @@
+[theme]
+inherit = basic
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/alerts.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/alerts.less
new file mode 100644
index 0000000000000000000000000000000000000000..c4199db927e795b6d7d35a39d475ef3087e2dfec
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/alerts.less
@@ -0,0 +1,73 @@
+//
+// Alerts
+// --------------------------------------------------
+
+
+// Base styles
+// -------------------------
+
+.alert {
+  padding: @alert-padding;
+  margin-bottom: @line-height-computed;
+  border: 1px solid transparent;
+  border-radius: @alert-border-radius;
+
+  // Headings for larger alerts
+  h4 {
+    margin-top: 0;
+    // Specified for the h4 to prevent conflicts of changing @headings-color
+    color: inherit;
+  }
+
+  // Provide class for links that match alerts
+  .alert-link {
+    font-weight: @alert-link-font-weight;
+  }
+
+  // Improve alignment and spacing of inner content
+  > p,
+  > ul {
+    margin-bottom: 0;
+  }
+
+  > p + p {
+    margin-top: 5px;
+  }
+}
+
+// Dismissible alerts
+//
+// Expand the right padding and account for the close button's positioning.
+
+.alert-dismissable, // The misspelled .alert-dismissable was deprecated in 3.2.0.
+.alert-dismissible {
+  padding-right: (@alert-padding + 20);
+
+  // Adjust close link position
+  .close {
+    position: relative;
+    top: -2px;
+    right: -21px;
+    color: inherit;
+  }
+}
+
+// Alternate styles
+//
+// Generate contextual modifier classes for colorizing the alert.
+
+.alert-success {
+  .alert-variant(@alert-success-bg; @alert-success-border; @alert-success-text);
+}
+
+.alert-info {
+  .alert-variant(@alert-info-bg; @alert-info-border; @alert-info-text);
+}
+
+.alert-warning {
+  .alert-variant(@alert-warning-bg; @alert-warning-border; @alert-warning-text);
+}
+
+.alert-danger {
+  .alert-variant(@alert-danger-bg; @alert-danger-border; @alert-danger-text);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/badges.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/badges.less
new file mode 100644
index 0000000000000000000000000000000000000000..c70bb939ebe253a17a39419d595d0038c7a683bc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/badges.less
@@ -0,0 +1,66 @@
+//
+// Badges
+// --------------------------------------------------
+
+
+// Base class
+.badge {
+  display: inline-block;
+  min-width: 10px;
+  padding: 3px 7px;
+  font-size: @font-size-small;
+  font-weight: @badge-font-weight;
+  color: @badge-color;
+  line-height: @badge-line-height;
+  vertical-align: baseline;
+  white-space: nowrap;
+  text-align: center;
+  background-color: @badge-bg;
+  border-radius: @badge-border-radius;
+
+  // Empty badges collapse automatically (not available in IE8)
+  &:empty {
+    display: none;
+  }
+
+  // Quick fix for badges in buttons
+  .btn & {
+    position: relative;
+    top: -1px;
+  }
+
+  .btn-xs &,
+  .btn-group-xs > .btn & {
+    top: 0;
+    padding: 1px 5px;
+  }
+
+  // Hover state, but only for links
+  a& {
+    &:hover,
+    &:focus {
+      color: @badge-link-hover-color;
+      text-decoration: none;
+      cursor: pointer;
+    }
+  }
+
+  // Account for badges in navs
+  .list-group-item.active > &,
+  .nav-pills > .active > a > & {
+    color: @badge-active-color;
+    background-color: @badge-active-bg;
+  }
+
+  .list-group-item > & {
+    float: right;
+  }
+
+  .list-group-item > & + & {
+    margin-right: 5px;
+  }
+
+  .nav-pills > li > a > & {
+    margin-left: 3px;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/bootstrap.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/bootstrap.less
new file mode 100644
index 0000000000000000000000000000000000000000..61b77474f9ad6ec9f9b5dda2ed67703f7580fde2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/bootstrap.less
@@ -0,0 +1,50 @@
+// Core variables and mixins
+@import "variables.less";
+@import "mixins.less";
+
+// Reset and dependencies
+@import "normalize.less";
+@import "print.less";
+@import "glyphicons.less";
+
+// Core CSS
+@import "scaffolding.less";
+@import "type.less";
+@import "code.less";
+@import "grid.less";
+@import "tables.less";
+@import "forms.less";
+@import "buttons.less";
+
+// Components
+@import "component-animations.less";
+@import "dropdowns.less";
+@import "button-groups.less";
+@import "input-groups.less";
+@import "navs.less";
+@import "navbar.less";
+@import "breadcrumbs.less";
+@import "pagination.less";
+@import "pager.less";
+@import "labels.less";
+@import "badges.less";
+@import "jumbotron.less";
+@import "thumbnails.less";
+@import "alerts.less";
+@import "progress-bars.less";
+@import "media.less";
+@import "list-group.less";
+@import "panels.less";
+@import "responsive-embed.less";
+@import "wells.less";
+@import "close.less";
+
+// Components w/ JavaScript
+@import "modals.less";
+@import "tooltip.less";
+@import "popovers.less";
+@import "carousel.less";
+
+// Utility classes
+@import "utilities.less";
+@import "responsive-utilities.less";
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/breadcrumbs.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/breadcrumbs.less
new file mode 100644
index 0000000000000000000000000000000000000000..cb01d503fbe5f7615e53c989bbee20c07c86e7ef
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/breadcrumbs.less
@@ -0,0 +1,26 @@
+//
+// Breadcrumbs
+// --------------------------------------------------
+
+
+.breadcrumb {
+  padding: @breadcrumb-padding-vertical @breadcrumb-padding-horizontal;
+  margin-bottom: @line-height-computed;
+  list-style: none;
+  background-color: @breadcrumb-bg;
+  border-radius: @border-radius-base;
+
+  > li {
+    display: inline-block;
+
+    + li:before {
+      content: "@{breadcrumb-separator}\00a0"; // Unicode space added since inline-block means non-collapsing white-space
+      padding: 0 5px;
+      color: @breadcrumb-color;
+    }
+  }
+
+  > .active {
+    color: @breadcrumb-active-color;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/button-groups.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/button-groups.less
new file mode 100644
index 0000000000000000000000000000000000000000..13c1800deaaacf739cdb3a4eaba95ee986f656c4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/button-groups.less
@@ -0,0 +1,243 @@
+//
+// Button groups
+// --------------------------------------------------
+
+// Make the div behave like a button
+.btn-group,
+.btn-group-vertical {
+  position: relative;
+  display: inline-block;
+  vertical-align: middle; // match .btn alignment given font-size hack above
+  > .btn {
+    position: relative;
+    float: left;
+    // Bring the "active" button to the front
+    &:hover,
+    &:focus,
+    &:active,
+    &.active {
+      z-index: 2;
+    }
+  }
+}
+
+// Prevent double borders when buttons are next to each other
+.btn-group {
+  .btn + .btn,
+  .btn + .btn-group,
+  .btn-group + .btn,
+  .btn-group + .btn-group {
+    margin-left: -1px;
+  }
+}
+
+// Optional: Group multiple button groups together for a toolbar
+.btn-toolbar {
+  margin-left: -5px; // Offset the first child's margin
+  &:extend(.clearfix all);
+
+  .btn-group,
+  .input-group {
+    float: left;
+  }
+  > .btn,
+  > .btn-group,
+  > .input-group {
+    margin-left: 5px;
+  }
+}
+
+.btn-group > .btn:not(:first-child):not(:last-child):not(.dropdown-toggle) {
+  border-radius: 0;
+}
+
+// Set corners individual because sometimes a single button can be in a .btn-group and we need :first-child and :last-child to both match
+.btn-group > .btn:first-child {
+  margin-left: 0;
+  &:not(:last-child):not(.dropdown-toggle) {
+    .border-right-radius(0);
+  }
+}
+// Need .dropdown-toggle since :last-child doesn't apply given a .dropdown-menu immediately after it
+.btn-group > .btn:last-child:not(:first-child),
+.btn-group > .dropdown-toggle:not(:first-child) {
+  .border-left-radius(0);
+}
+
+// Custom edits for including btn-groups within btn-groups (useful for including dropdown buttons within a btn-group)
+.btn-group > .btn-group {
+  float: left;
+}
+.btn-group > .btn-group:not(:first-child):not(:last-child) > .btn {
+  border-radius: 0;
+}
+.btn-group > .btn-group:first-child:not(:last-child) {
+  > .btn:last-child,
+  > .dropdown-toggle {
+    .border-right-radius(0);
+  }
+}
+.btn-group > .btn-group:last-child:not(:first-child) > .btn:first-child {
+  .border-left-radius(0);
+}
+
+// On active and open, don't show outline
+.btn-group .dropdown-toggle:active,
+.btn-group.open .dropdown-toggle {
+  outline: 0;
+}
+
+
+// Sizing
+//
+// Remix the default button sizing classes into new ones for easier manipulation.
+
+.btn-group-xs > .btn { &:extend(.btn-xs); }
+.btn-group-sm > .btn { &:extend(.btn-sm); }
+.btn-group-lg > .btn { &:extend(.btn-lg); }
+
+
+// Split button dropdowns
+// ----------------------
+
+// Give the line between buttons some depth
+.btn-group > .btn + .dropdown-toggle {
+  padding-left: 8px;
+  padding-right: 8px;
+}
+.btn-group > .btn-lg + .dropdown-toggle {
+  padding-left: 12px;
+  padding-right: 12px;
+}
+
+// The clickable button for toggling the menu
+// Remove the gradient and set the same inset shadow as the :active state
+.btn-group.open .dropdown-toggle {
+  .box-shadow(inset 0 3px 5px rgba(0,0,0,.125));
+
+  // Show no shadow for `.btn-link` since it has no other button styles.
+  &.btn-link {
+    .box-shadow(none);
+  }
+}
+
+
+// Reposition the caret
+.btn .caret {
+  margin-left: 0;
+}
+// Carets in other button sizes
+.btn-lg .caret {
+  border-width: @caret-width-large @caret-width-large 0;
+  border-bottom-width: 0;
+}
+// Upside down carets for .dropup
+.dropup .btn-lg .caret {
+  border-width: 0 @caret-width-large @caret-width-large;
+}
+
+
+// Vertical button groups
+// ----------------------
+
+.btn-group-vertical {
+  > .btn,
+  > .btn-group,
+  > .btn-group > .btn {
+    display: block;
+    float: none;
+    width: 100%;
+    max-width: 100%;
+  }
+
+  // Clear floats so dropdown menus can be properly placed
+  > .btn-group {
+    &:extend(.clearfix all);
+    > .btn {
+      float: none;
+    }
+  }
+
+  > .btn + .btn,
+  > .btn + .btn-group,
+  > .btn-group + .btn,
+  > .btn-group + .btn-group {
+    margin-top: -1px;
+    margin-left: 0;
+  }
+}
+
+.btn-group-vertical > .btn {
+  &:not(:first-child):not(:last-child) {
+    border-radius: 0;
+  }
+  &:first-child:not(:last-child) {
+    border-top-right-radius: @border-radius-base;
+    .border-bottom-radius(0);
+  }
+  &:last-child:not(:first-child) {
+    border-bottom-left-radius: @border-radius-base;
+    .border-top-radius(0);
+  }
+}
+.btn-group-vertical > .btn-group:not(:first-child):not(:last-child) > .btn {
+  border-radius: 0;
+}
+.btn-group-vertical > .btn-group:first-child:not(:last-child) {
+  > .btn:last-child,
+  > .dropdown-toggle {
+    .border-bottom-radius(0);
+  }
+}
+.btn-group-vertical > .btn-group:last-child:not(:first-child) > .btn:first-child {
+  .border-top-radius(0);
+}
+
+
+// Justified button groups
+// ----------------------
+
+.btn-group-justified {
+  display: table;
+  width: 100%;
+  table-layout: fixed;
+  border-collapse: separate;
+  > .btn,
+  > .btn-group {
+    float: none;
+    display: table-cell;
+    width: 1%;
+  }
+  > .btn-group .btn {
+    width: 100%;
+  }
+
+  > .btn-group .dropdown-menu {
+    left: auto;
+  }
+}
+
+
+// Checkbox and radio options
+//
+// In order to support the browser's form validation feedback, powered by the
+// `required` attribute, we have to "hide" the inputs via `clip`. We cannot use
+// `display: none;` or `visibility: hidden;` as that also hides the popover.
+// Simply visually hiding the inputs via `opacity` would leave them clickable in
+// certain cases which is prevented by using `clip` and `pointer-events`.
+// This way, we ensure a DOM element is visible to position the popover from.
+//
+// See https://github.com/twbs/bootstrap/pull/12794 and
+// https://github.com/twbs/bootstrap/pull/14559 for more information.
+
+[data-toggle="buttons"] {
+  > .btn,
+  > .btn-group > .btn {
+    input[type="radio"],
+    input[type="checkbox"] {
+      position: absolute;
+      clip: rect(0,0,0,0);
+      pointer-events: none;
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/buttons.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/buttons.less
new file mode 100644
index 0000000000000000000000000000000000000000..5a746049e3cea5c5f912144e11850d56a36cf0d2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/buttons.less
@@ -0,0 +1,160 @@
+//
+// Buttons
+// --------------------------------------------------
+
+
+// Base styles
+// --------------------------------------------------
+
+.btn {
+  display: inline-block;
+  margin-bottom: 0; // For input.btn
+  font-weight: @btn-font-weight;
+  text-align: center;
+  vertical-align: middle;
+  touch-action: manipulation;
+  cursor: pointer;
+  background-image: none; // Reset unusual Firefox-on-Android default style; see https://github.com/necolas/normalize.css/issues/214
+  border: 1px solid transparent;
+  white-space: nowrap;
+  .button-size(@padding-base-vertical; @padding-base-horizontal; @font-size-base; @line-height-base; @border-radius-base);
+  .user-select(none);
+
+  &,
+  &:active,
+  &.active {
+    &:focus,
+    &.focus {
+      .tab-focus();
+    }
+  }
+
+  &:hover,
+  &:focus,
+  &.focus {
+    color: @btn-default-color;
+    text-decoration: none;
+  }
+
+  &:active,
+  &.active {
+    outline: 0;
+    background-image: none;
+    .box-shadow(inset 0 3px 5px rgba(0,0,0,.125));
+  }
+
+  &.disabled,
+  &[disabled],
+  fieldset[disabled] & {
+    cursor: @cursor-disabled;
+    pointer-events: none; // Future-proof disabling of clicks
+    .opacity(.65);
+    .box-shadow(none);
+  }
+}
+
+
+// Alternate buttons
+// --------------------------------------------------
+
+.btn-default {
+  .button-variant(@btn-default-color; @btn-default-bg; @btn-default-border);
+}
+.btn-primary {
+  .button-variant(@btn-primary-color; @btn-primary-bg; @btn-primary-border);
+}
+// Success appears as green
+.btn-success {
+  .button-variant(@btn-success-color; @btn-success-bg; @btn-success-border);
+}
+// Info appears as blue-green
+.btn-info {
+  .button-variant(@btn-info-color; @btn-info-bg; @btn-info-border);
+}
+// Warning appears as orange
+.btn-warning {
+  .button-variant(@btn-warning-color; @btn-warning-bg; @btn-warning-border);
+}
+// Danger and error appear as red
+.btn-danger {
+  .button-variant(@btn-danger-color; @btn-danger-bg; @btn-danger-border);
+}
+
+
+// Link buttons
+// -------------------------
+
+// Make a button look and behave like a link
+.btn-link {
+  color: @link-color;
+  font-weight: normal;
+  border-radius: 0;
+
+  &,
+  &:active,
+  &.active,
+  &[disabled],
+  fieldset[disabled] & {
+    background-color: transparent;
+    .box-shadow(none);
+  }
+  &,
+  &:hover,
+  &:focus,
+  &:active {
+    border-color: transparent;
+  }
+  &:hover,
+  &:focus {
+    color: @link-hover-color;
+    text-decoration: @link-hover-decoration;
+    background-color: transparent;
+  }
+  &[disabled],
+  fieldset[disabled] & {
+    &:hover,
+    &:focus {
+      color: @btn-link-disabled-color;
+      text-decoration: none;
+    }
+  }
+}
+
+
+// Button Sizes
+// --------------------------------------------------
+
+.btn-lg {
+  // line-height: ensure even-numbered height of button next to large input
+  .button-size(@padding-large-vertical; @padding-large-horizontal; @font-size-large; @line-height-large; @border-radius-large);
+}
+.btn-sm {
+  // line-height: ensure proper height of button next to small input
+  .button-size(@padding-small-vertical; @padding-small-horizontal; @font-size-small; @line-height-small; @border-radius-small);
+}
+.btn-xs {
+  .button-size(@padding-xs-vertical; @padding-xs-horizontal; @font-size-small; @line-height-small; @border-radius-small);
+}
+
+
+// Block button
+// --------------------------------------------------
+
+.btn-block {
+  display: block;
+  width: 100%;
+}
+
+// Vertically space out multiple block buttons
+.btn-block + .btn-block {
+  margin-top: 5px;
+}
+
+// Specificity overrides
+input[type="submit"],
+input[type="reset"],
+input[type="button"] {
+  &.btn-block {
+    width: 100%;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/carousel.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/carousel.less
new file mode 100644
index 0000000000000000000000000000000000000000..4bbe946d3aa8f36a49c9dd77306e02888634be87
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/carousel.less
@@ -0,0 +1,269 @@
+//
+// Carousel
+// --------------------------------------------------
+
+
+// Wrapper for the slide container and indicators
+.carousel {
+  position: relative;
+}
+
+.carousel-inner {
+  position: relative;
+  overflow: hidden;
+  width: 100%;
+
+  > .item {
+    display: none;
+    position: relative;
+    .transition(.6s ease-in-out left);
+
+    // Account for jankitude on images
+    > img,
+    > a > img {
+      &:extend(.img-responsive);
+      line-height: 1;
+    }
+
+    // WebKit CSS3 transforms for supported devices
+    @media all and (transform-3d), (-webkit-transform-3d) {
+      .transition-transform(~'0.6s ease-in-out');
+      .backface-visibility(~'hidden');
+      .perspective(1000);
+
+      &.next,
+      &.active.right {
+        .translate3d(100%, 0, 0);
+        left: 0;
+      }
+      &.prev,
+      &.active.left {
+        .translate3d(-100%, 0, 0);
+        left: 0;
+      }
+      &.next.left,
+      &.prev.right,
+      &.active {
+        .translate3d(0, 0, 0);
+        left: 0;
+      }
+    }
+  }
+
+  > .active,
+  > .next,
+  > .prev {
+    display: block;
+  }
+
+  > .active {
+    left: 0;
+  }
+
+  > .next,
+  > .prev {
+    position: absolute;
+    top: 0;
+    width: 100%;
+  }
+
+  > .next {
+    left: 100%;
+  }
+  > .prev {
+    left: -100%;
+  }
+  > .next.left,
+  > .prev.right {
+    left: 0;
+  }
+
+  > .active.left {
+    left: -100%;
+  }
+  > .active.right {
+    left: 100%;
+  }
+
+}
+
+// Left/right controls for nav
+// ---------------------------
+
+.carousel-control {
+  position: absolute;
+  top: 0;
+  left: 0;
+  bottom: 0;
+  width: @carousel-control-width;
+  .opacity(@carousel-control-opacity);
+  font-size: @carousel-control-font-size;
+  color: @carousel-control-color;
+  text-align: center;
+  text-shadow: @carousel-text-shadow;
+  // We can't have this transition here because WebKit cancels the carousel
+  // animation if you trip this while in the middle of another animation.
+
+  // Set gradients for backgrounds
+  &.left {
+    #gradient > .horizontal(@start-color: rgba(0,0,0,.5); @end-color: rgba(0,0,0,.0001));
+  }
+  &.right {
+    left: auto;
+    right: 0;
+    #gradient > .horizontal(@start-color: rgba(0,0,0,.0001); @end-color: rgba(0,0,0,.5));
+  }
+
+  // Hover/focus state
+  &:hover,
+  &:focus {
+    outline: 0;
+    color: @carousel-control-color;
+    text-decoration: none;
+    .opacity(.9);
+  }
+
+  // Toggles
+  .icon-prev,
+  .icon-next,
+  .glyphicon-chevron-left,
+  .glyphicon-chevron-right {
+    position: absolute;
+    top: 50%;
+    z-index: 5;
+    display: inline-block;
+  }
+  .icon-prev,
+  .glyphicon-chevron-left {
+    left: 50%;
+    margin-left: -10px;
+  }
+  .icon-next,
+  .glyphicon-chevron-right {
+    right: 50%;
+    margin-right: -10px;
+  }
+  .icon-prev,
+  .icon-next {
+    width:  20px;
+    height: 20px;
+    margin-top: -10px;
+    line-height: 1;
+    font-family: serif;
+  }
+
+
+  .icon-prev {
+    &:before {
+      content: '\2039';// SINGLE LEFT-POINTING ANGLE QUOTATION MARK (U+2039)
+    }
+  }
+  .icon-next {
+    &:before {
+      content: '\203a';// SINGLE RIGHT-POINTING ANGLE QUOTATION MARK (U+203A)
+    }
+  }
+}
+
+// Optional indicator pips
+//
+// Add an unordered list with the following class and add a list item for each
+// slide your carousel holds.
+
+.carousel-indicators {
+  position: absolute;
+  bottom: 10px;
+  left: 50%;
+  z-index: 15;
+  width: 60%;
+  margin-left: -30%;
+  padding-left: 0;
+  list-style: none;
+  text-align: center;
+
+  li {
+    display: inline-block;
+    width:  10px;
+    height: 10px;
+    margin: 1px;
+    text-indent: -999px;
+    border: 1px solid @carousel-indicator-border-color;
+    border-radius: 10px;
+    cursor: pointer;
+
+    // IE8-9 hack for event handling
+    //
+    // Internet Explorer 8-9 does not support clicks on elements without a set
+    // `background-color`. We cannot use `filter` since that's not viewed as a
+    // background color by the browser. Thus, a hack is needed.
+    // See https://developer.mozilla.org/en-US/docs/Web/Events/click#Internet_Explorer
+    //
+    // For IE8, we set solid black as it doesn't support `rgba()`. For IE9, we
+    // set alpha transparency for the best results possible.
+    background-color: #000 \9; // IE8
+    background-color: rgba(0,0,0,0); // IE9
+  }
+  .active {
+    margin: 0;
+    width:  12px;
+    height: 12px;
+    background-color: @carousel-indicator-active-bg;
+  }
+}
+
+// Optional captions
+// -----------------------------
+// Hidden by default for smaller viewports
+.carousel-caption {
+  position: absolute;
+  left: 15%;
+  right: 15%;
+  bottom: 20px;
+  z-index: 10;
+  padding-top: 20px;
+  padding-bottom: 20px;
+  color: @carousel-caption-color;
+  text-align: center;
+  text-shadow: @carousel-text-shadow;
+  & .btn {
+    text-shadow: none; // No shadow for button elements in carousel-caption
+  }
+}
+
+
+// Scale up controls for tablets and up
+@media screen and (min-width: @screen-sm-min) {
+
+  // Scale up the controls a smidge
+  .carousel-control {
+    .glyphicon-chevron-left,
+    .glyphicon-chevron-right,
+    .icon-prev,
+    .icon-next {
+      width: 30px;
+      height: 30px;
+      margin-top: -15px;
+      font-size: 30px;
+    }
+    .glyphicon-chevron-left,
+    .icon-prev {
+      margin-left: -15px;
+    }
+    .glyphicon-chevron-right,
+    .icon-next {
+      margin-right: -15px;
+    }
+  }
+
+  // Show and left align the captions
+  .carousel-caption {
+    left: 20%;
+    right: 20%;
+    padding-bottom: 30px;
+  }
+
+  // Move up the indicators
+  .carousel-indicators {
+    bottom: 20px;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/close.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/close.less
new file mode 100644
index 0000000000000000000000000000000000000000..6d5bfe087aed3342270b1de9d70d034c474a3779
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/close.less
@@ -0,0 +1,34 @@
+//
+// Close icons
+// --------------------------------------------------
+
+
+.close {
+  float: right;
+  font-size: (@font-size-base * 1.5);
+  font-weight: @close-font-weight;
+  line-height: 1;
+  color: @close-color;
+  text-shadow: @close-text-shadow;
+  .opacity(.2);
+
+  &:hover,
+  &:focus {
+    color: @close-color;
+    text-decoration: none;
+    cursor: pointer;
+    .opacity(.5);
+  }
+
+  // Additional properties for button version
+  // iOS requires the button element instead of an anchor tag.
+  // If you want the anchor version, it requires `href="#"`.
+  // See https://developer.mozilla.org/en-US/docs/Web/Events/click#Safari_Mobile
+  button& {
+    padding: 0;
+    cursor: pointer;
+    background: transparent;
+    border: 0;
+    -webkit-appearance: none;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/code.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/code.less
new file mode 100644
index 0000000000000000000000000000000000000000..a08b4d48c4c8715dac93a5422f0d340ae9cc6bff
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/code.less
@@ -0,0 +1,69 @@
+//
+// Code (inline and block)
+// --------------------------------------------------
+
+
+// Inline and block code styles
+code,
+kbd,
+pre,
+samp {
+  font-family: @font-family-monospace;
+}
+
+// Inline code
+code {
+  padding: 2px 4px;
+  font-size: 90%;
+  color: @code-color;
+  background-color: @code-bg;
+  border-radius: @border-radius-base;
+}
+
+// User input typically entered via keyboard
+kbd {
+  padding: 2px 4px;
+  font-size: 90%;
+  color: @kbd-color;
+  background-color: @kbd-bg;
+  border-radius: @border-radius-small;
+  box-shadow: inset 0 -1px 0 rgba(0,0,0,.25);
+
+  kbd {
+    padding: 0;
+    font-size: 100%;
+    font-weight: bold;
+    box-shadow: none;
+  }
+}
+
+// Blocks of code
+pre {
+  display: block;
+  padding: ((@line-height-computed - 1) / 2);
+  margin: 0 0 (@line-height-computed / 2);
+  font-size: (@font-size-base - 1); // 14px to 13px
+  line-height: @line-height-base;
+  word-break: break-all;
+  word-wrap: break-word;
+  color: @pre-color;
+  background-color: @pre-bg;
+  border: 1px solid @pre-border-color;
+  border-radius: @border-radius-base;
+
+  // Account for some code outputs that place code tags in pre tags
+  code {
+    padding: 0;
+    font-size: inherit;
+    color: inherit;
+    white-space: pre-wrap;
+    background-color: transparent;
+    border-radius: 0;
+  }
+}
+
+// Enable scrollable blocks of code
+.pre-scrollable {
+  max-height: @pre-scrollable-max-height;
+  overflow-y: scroll;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/component-animations.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/component-animations.less
new file mode 100644
index 0000000000000000000000000000000000000000..0bcee910ac5f2c249cd6280d1e69fd03d178b24e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/component-animations.less
@@ -0,0 +1,33 @@
+//
+// Component animations
+// --------------------------------------------------
+
+// Heads up!
+//
+// We don't use the `.opacity()` mixin here since it causes a bug with text
+// fields in IE7-8. Source: https://github.com/twbs/bootstrap/pull/3552.
+
+.fade {
+  opacity: 0;
+  .transition(opacity .15s linear);
+  &.in {
+    opacity: 1;
+  }
+}
+
+.collapse {
+  display: none;
+
+  &.in      { display: block; }
+  tr&.in    { display: table-row; }
+  tbody&.in { display: table-row-group; }
+}
+
+.collapsing {
+  position: relative;
+  height: 0;
+  overflow: hidden;
+  .transition-property(~"height, visibility");
+  .transition-duration(.35s);
+  .transition-timing-function(ease);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/dropdowns.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/dropdowns.less
new file mode 100644
index 0000000000000000000000000000000000000000..af344607bd967350aab19a91d8f069eee20b4230
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/dropdowns.less
@@ -0,0 +1,214 @@
+//
+// Dropdown menus
+// --------------------------------------------------
+
+
+// Dropdown arrow/caret
+.caret {
+  display: inline-block;
+  width: 0;
+  height: 0;
+  margin-left: 2px;
+  vertical-align: middle;
+  border-top:   @caret-width-base dashed;
+  border-right: @caret-width-base solid transparent;
+  border-left:  @caret-width-base solid transparent;
+}
+
+// The dropdown wrapper (div)
+.dropup,
+.dropdown {
+  position: relative;
+}
+
+// Prevent the focus on the dropdown toggle when closing dropdowns
+.dropdown-toggle:focus {
+  outline: 0;
+}
+
+// The dropdown menu (ul)
+.dropdown-menu {
+  position: absolute;
+  top: 100%;
+  left: 0;
+  z-index: @zindex-dropdown;
+  display: none; // none by default, but block on "open" of the menu
+  float: left;
+  min-width: 160px;
+  padding: 5px 0;
+  margin: 2px 0 0; // override default ul
+  list-style: none;
+  font-size: @font-size-base;
+  text-align: left; // Ensures proper alignment if parent has it changed (e.g., modal footer)
+  background-color: @dropdown-bg;
+  border: 1px solid @dropdown-fallback-border; // IE8 fallback
+  border: 1px solid @dropdown-border;
+  border-radius: @border-radius-base;
+  .box-shadow(0 6px 12px rgba(0,0,0,.175));
+  background-clip: padding-box;
+
+  // Aligns the dropdown menu to right
+  //
+  // Deprecated as of 3.1.0 in favor of `.dropdown-menu-[dir]`
+  &.pull-right {
+    right: 0;
+    left: auto;
+  }
+
+  // Dividers (basically an hr) within the dropdown
+  .divider {
+    .nav-divider(@dropdown-divider-bg);
+  }
+
+  // Links within the dropdown menu
+  > li > a {
+    display: block;
+    padding: 3px 20px;
+    clear: both;
+    font-weight: normal;
+    line-height: @line-height-base;
+    color: @dropdown-link-color;
+    white-space: nowrap; // prevent links from randomly breaking onto new lines
+  }
+}
+
+// Hover/Focus state
+.dropdown-menu > li > a {
+  &:hover,
+  &:focus {
+    text-decoration: none;
+    color: @dropdown-link-hover-color;
+    background-color: @dropdown-link-hover-bg;
+  }
+}
+
+// Active state
+.dropdown-menu > .active > a {
+  &,
+  &:hover,
+  &:focus {
+    color: @dropdown-link-active-color;
+    text-decoration: none;
+    outline: 0;
+    background-color: @dropdown-link-active-bg;
+  }
+}
+
+// Disabled state
+//
+// Gray out text and ensure the hover/focus state remains gray
+
+.dropdown-menu > .disabled > a {
+  &,
+  &:hover,
+  &:focus {
+    color: @dropdown-link-disabled-color;
+  }
+
+  // Nuke hover/focus effects
+  &:hover,
+  &:focus {
+    text-decoration: none;
+    background-color: transparent;
+    background-image: none; // Remove CSS gradient
+    .reset-filter();
+    cursor: @cursor-disabled;
+  }
+}
+
+// Open state for the dropdown
+.open {
+  // Show the menu
+  > .dropdown-menu {
+    display: block;
+  }
+
+  // Remove the outline when :focus is triggered
+  > a {
+    outline: 0;
+  }
+}
+
+// Menu positioning
+//
+// Add extra class to `.dropdown-menu` to flip the alignment of the dropdown
+// menu with the parent.
+.dropdown-menu-right {
+  left: auto; // Reset the default from `.dropdown-menu`
+  right: 0;
+}
+// With v3, we enabled auto-flipping if you have a dropdown within a right
+// aligned nav component. To enable the undoing of that, we provide an override
+// to restore the default dropdown menu alignment.
+//
+// This is only for left-aligning a dropdown menu within a `.navbar-right` or
+// `.pull-right` nav component.
+.dropdown-menu-left {
+  left: 0;
+  right: auto;
+}
+
+// Dropdown section headers
+.dropdown-header {
+  display: block;
+  padding: 3px 20px;
+  font-size: @font-size-small;
+  line-height: @line-height-base;
+  color: @dropdown-header-color;
+  white-space: nowrap; // as with > li > a
+}
+
+// Backdrop to catch body clicks on mobile, etc.
+.dropdown-backdrop {
+  position: fixed;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  top: 0;
+  z-index: (@zindex-dropdown - 10);
+}
+
+// Right aligned dropdowns
+.pull-right > .dropdown-menu {
+  right: 0;
+  left: auto;
+}
+
+// Allow for dropdowns to go bottom up (aka, dropup-menu)
+//
+// Just add .dropup after the standard .dropdown class and you're set, bro.
+// TODO: abstract this so that the navbar fixed styles are not placed here?
+
+.dropup,
+.navbar-fixed-bottom .dropdown {
+  // Reverse the caret
+  .caret {
+    border-top: 0;
+    border-bottom: @caret-width-base solid;
+    content: "";
+  }
+  // Different positioning for bottom up menu
+  .dropdown-menu {
+    top: auto;
+    bottom: 100%;
+    margin-bottom: 2px;
+  }
+}
+
+
+// Component alignment
+//
+// Reiterate per navbar.less and the modified component alignment there.
+
+@media (min-width: @grid-float-breakpoint) {
+  .navbar-right {
+    .dropdown-menu {
+      .dropdown-menu-right();
+    }
+    // Necessary for overrides of the default right aligned menu.
+    // Will remove come v4 in all likelihood.
+    .dropdown-menu-left {
+      .dropdown-menu-left();
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/forms.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/forms.less
new file mode 100644
index 0000000000000000000000000000000000000000..e4b50629e97cd9bbac46c4c2d9d36a55f3f9686d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/forms.less
@@ -0,0 +1,574 @@
+//
+// Forms
+// --------------------------------------------------
+
+
+// Normalize non-controls
+//
+// Restyle and baseline non-control form elements.
+
+fieldset {
+  padding: 0;
+  margin: 0;
+  border: 0;
+  // Chrome and Firefox set a `min-width: min-content;` on fieldsets,
+  // so we reset that to ensure it behaves more like a standard block element.
+  // See https://github.com/twbs/bootstrap/issues/12359.
+  min-width: 0;
+}
+
+legend {
+  display: block;
+  width: 100%;
+  padding: 0;
+  margin-bottom: @line-height-computed;
+  font-size: (@font-size-base * 1.5);
+  line-height: inherit;
+  color: @legend-color;
+  border: 0;
+  border-bottom: 1px solid @legend-border-color;
+}
+
+label {
+  display: inline-block;
+  max-width: 100%; // Force IE8 to wrap long content (see https://github.com/twbs/bootstrap/issues/13141)
+  margin-bottom: 5px;
+  font-weight: bold;
+}
+
+
+// Normalize form controls
+//
+// While most of our form styles require extra classes, some basic normalization
+// is required to ensure optimum display with or without those classes to better
+// address browser inconsistencies.
+
+// Override content-box in Normalize (* isn't specific enough)
+input[type="search"] {
+  .box-sizing(border-box);
+}
+
+// Position radios and checkboxes better
+input[type="radio"],
+input[type="checkbox"] {
+  margin: 4px 0 0;
+  margin-top: 1px \9; // IE8-9
+  line-height: normal;
+}
+
+// Set the height of file controls to match text inputs
+input[type="file"] {
+  display: block;
+}
+
+// Make range inputs behave like textual form controls
+input[type="range"] {
+  display: block;
+  width: 100%;
+}
+
+// Make multiple select elements height not fixed
+select[multiple],
+select[size] {
+  height: auto;
+}
+
+// Focus for file, radio, and checkbox
+input[type="file"]:focus,
+input[type="radio"]:focus,
+input[type="checkbox"]:focus {
+  .tab-focus();
+}
+
+// Adjust output element
+output {
+  display: block;
+  padding-top: (@padding-base-vertical + 1);
+  font-size: @font-size-base;
+  line-height: @line-height-base;
+  color: @input-color;
+}
+
+
+// Common form controls
+//
+// Shared size and type resets for form controls. Apply `.form-control` to any
+// of the following form controls:
+//
+// select
+// textarea
+// input[type="text"]
+// input[type="password"]
+// input[type="datetime"]
+// input[type="datetime-local"]
+// input[type="date"]
+// input[type="month"]
+// input[type="time"]
+// input[type="week"]
+// input[type="number"]
+// input[type="email"]
+// input[type="url"]
+// input[type="search"]
+// input[type="tel"]
+// input[type="color"]
+
+.form-control {
+  display: block;
+  width: 100%;
+  height: @input-height-base; // Make inputs at least the height of their button counterpart (base line-height + padding + border)
+  padding: @padding-base-vertical @padding-base-horizontal;
+  font-size: @font-size-base;
+  line-height: @line-height-base;
+  color: @input-color;
+  background-color: @input-bg;
+  background-image: none; // Reset unusual Firefox-on-Android default style; see https://github.com/necolas/normalize.css/issues/214
+  border: 1px solid @input-border;
+  border-radius: @input-border-radius; // Note: This has no effect on <select>s in some browsers, due to the limited stylability of <select>s in CSS.
+  .box-shadow(inset 0 1px 1px rgba(0,0,0,.075));
+  .transition(~"border-color ease-in-out .15s, box-shadow ease-in-out .15s");
+
+  // Customize the `:focus` state to imitate native WebKit styles.
+  .form-control-focus();
+
+  // Placeholder
+  .placeholder();
+
+  // Disabled and read-only inputs
+  //
+  // HTML5 says that controls under a fieldset > legend:first-child won't be
+  // disabled if the fieldset is disabled. Due to implementation difficulty, we
+  // don't honor that edge case; we style them as disabled anyway.
+  &[disabled],
+  &[readonly],
+  fieldset[disabled] & {
+    background-color: @input-bg-disabled;
+    opacity: 1; // iOS fix for unreadable disabled content; see https://github.com/twbs/bootstrap/issues/11655
+  }
+
+  &[disabled],
+  fieldset[disabled] & {
+    cursor: @cursor-disabled;
+  }
+
+  // Reset height for `textarea`s
+  textarea& {
+    height: auto;
+  }
+}
+
+
+// Search inputs in iOS
+//
+// This overrides the extra rounded corners on search inputs in iOS so that our
+// `.form-control` class can properly style them. Note that this cannot simply
+// be added to `.form-control` as it's not specific enough. For details, see
+// https://github.com/twbs/bootstrap/issues/11586.
+
+input[type="search"] {
+  -webkit-appearance: none;
+}
+
+
+// Special styles for iOS temporal inputs
+//
+// In Mobile Safari, setting `display: block` on temporal inputs causes the
+// text within the input to become vertically misaligned. As a workaround, we
+// set a pixel line-height that matches the given height of the input, but only
+// for Safari. See https://bugs.webkit.org/show_bug.cgi?id=139848
+
+@media screen and (-webkit-min-device-pixel-ratio: 0) {
+  input[type="date"],
+  input[type="time"],
+  input[type="datetime-local"],
+  input[type="month"] {
+    line-height: @input-height-base;
+
+    &.input-sm,
+    .input-group-sm & {
+      line-height: @input-height-small;
+    }
+
+    &.input-lg,
+    .input-group-lg & {
+      line-height: @input-height-large;
+    }
+  }
+}
+
+
+// Form groups
+//
+// Designed to help with the organization and spacing of vertical forms. For
+// horizontal forms, use the predefined grid classes.
+
+.form-group {
+  margin-bottom: @form-group-margin-bottom;
+}
+
+
+// Checkboxes and radios
+//
+// Indent the labels to position radios/checkboxes as hanging controls.
+
+.radio,
+.checkbox {
+  position: relative;
+  display: block;
+  margin-top: 10px;
+  margin-bottom: 10px;
+
+  label {
+    min-height: @line-height-computed; // Ensure the input doesn't jump when there is no text
+    padding-left: 20px;
+    margin-bottom: 0;
+    font-weight: normal;
+    cursor: pointer;
+  }
+}
+.radio input[type="radio"],
+.radio-inline input[type="radio"],
+.checkbox input[type="checkbox"],
+.checkbox-inline input[type="checkbox"] {
+  position: absolute;
+  margin-left: -20px;
+  margin-top: 4px \9;
+}
+
+.radio + .radio,
+.checkbox + .checkbox {
+  margin-top: -5px; // Move up sibling radios or checkboxes for tighter spacing
+}
+
+// Radios and checkboxes on same line
+.radio-inline,
+.checkbox-inline {
+  position: relative;
+  display: inline-block;
+  padding-left: 20px;
+  margin-bottom: 0;
+  vertical-align: middle;
+  font-weight: normal;
+  cursor: pointer;
+}
+.radio-inline + .radio-inline,
+.checkbox-inline + .checkbox-inline {
+  margin-top: 0;
+  margin-left: 10px; // space out consecutive inline controls
+}
+
+// Apply same disabled cursor tweak as for inputs
+// Some special care is needed because <label>s don't inherit their parent's `cursor`.
+//
+// Note: Neither radios nor checkboxes can be readonly.
+input[type="radio"],
+input[type="checkbox"] {
+  &[disabled],
+  &.disabled,
+  fieldset[disabled] & {
+    cursor: @cursor-disabled;
+  }
+}
+// These classes are used directly on <label>s
+.radio-inline,
+.checkbox-inline {
+  &.disabled,
+  fieldset[disabled] & {
+    cursor: @cursor-disabled;
+  }
+}
+// These classes are used on elements with <label> descendants
+.radio,
+.checkbox {
+  &.disabled,
+  fieldset[disabled] & {
+    label {
+      cursor: @cursor-disabled;
+    }
+  }
+}
+
+
+// Static form control text
+//
+// Apply class to a `p` element to make any string of text align with labels in
+// a horizontal form layout.
+
+.form-control-static {
+  // Size it appropriately next to real form controls
+  padding-top: (@padding-base-vertical + 1);
+  padding-bottom: (@padding-base-vertical + 1);
+  // Remove default margin from `p`
+  margin-bottom: 0;
+  min-height: (@line-height-computed + @font-size-base);
+
+  &.input-lg,
+  &.input-sm {
+    padding-left: 0;
+    padding-right: 0;
+  }
+}
+
+
+// Form control sizing
+//
+// Build on `.form-control` with modifier classes to decrease or increase the
+// height and font-size of form controls.
+//
+// The `.form-group-* form-control` variations are sadly duplicated to avoid the
+// issue documented in https://github.com/twbs/bootstrap/issues/15074.
+
+.input-sm {
+  .input-size(@input-height-small; @padding-small-vertical; @padding-small-horizontal; @font-size-small; @line-height-small; @input-border-radius-small);
+}
+.form-group-sm {
+  .form-control {
+    .input-size(@input-height-small; @padding-small-vertical; @padding-small-horizontal; @font-size-small; @line-height-small; @input-border-radius-small);
+  }
+  .form-control-static {
+    height: @input-height-small;
+    padding: @padding-small-vertical @padding-small-horizontal;
+    font-size: @font-size-small;
+    line-height: @line-height-small;
+    min-height: (@line-height-computed + @font-size-small);
+  }
+}
+
+.input-lg {
+  .input-size(@input-height-large; @padding-large-vertical; @padding-large-horizontal; @font-size-large; @line-height-large; @input-border-radius-large);
+}
+.form-group-lg {
+  .form-control {
+    .input-size(@input-height-large; @padding-large-vertical; @padding-large-horizontal; @font-size-large; @line-height-large; @input-border-radius-large);
+  }
+  .form-control-static {
+    height: @input-height-large;
+    padding: @padding-large-vertical @padding-large-horizontal;
+    font-size: @font-size-large;
+    line-height: @line-height-large;
+    min-height: (@line-height-computed + @font-size-large);
+  }
+}
+
+
+// Form control feedback states
+//
+// Apply contextual and semantic states to individual form controls.
+
+.has-feedback {
+  // Enable absolute positioning
+  position: relative;
+
+  // Ensure icons don't overlap text
+  .form-control {
+    padding-right: (@input-height-base * 1.25);
+  }
+}
+// Feedback icon (requires .glyphicon classes)
+.form-control-feedback {
+  position: absolute;
+  top: 0;
+  right: 0;
+  z-index: 2; // Ensure icon is above input groups
+  display: block;
+  width: @input-height-base;
+  height: @input-height-base;
+  line-height: @input-height-base;
+  text-align: center;
+  pointer-events: none;
+}
+.input-lg + .form-control-feedback {
+  width: @input-height-large;
+  height: @input-height-large;
+  line-height: @input-height-large;
+}
+.input-sm + .form-control-feedback {
+  width: @input-height-small;
+  height: @input-height-small;
+  line-height: @input-height-small;
+}
+
+// Feedback states
+.has-success {
+  .form-control-validation(@state-success-text; @state-success-text; @state-success-bg);
+}
+.has-warning {
+  .form-control-validation(@state-warning-text; @state-warning-text; @state-warning-bg);
+}
+.has-error {
+  .form-control-validation(@state-danger-text; @state-danger-text; @state-danger-bg);
+}
+
+// Reposition feedback icon if input has visible label above
+.has-feedback label {
+
+  & ~ .form-control-feedback {
+     top: (@line-height-computed + 5); // Height of the `label` and its margin
+  }
+  &.sr-only ~ .form-control-feedback {
+     top: 0;
+  }
+}
+
+
+// Help text
+//
+// Apply to any element you wish to create light text for placement immediately
+// below a form control. Use for general help, formatting, or instructional text.
+
+.help-block {
+  display: block; // account for any element using help-block
+  margin-top: 5px;
+  margin-bottom: 10px;
+  color: lighten(@text-color, 25%); // lighten the text some for contrast
+}
+
+
+// Inline forms
+//
+// Make forms appear inline(-block) by adding the `.form-inline` class. Inline
+// forms begin stacked on extra small (mobile) devices and then go inline when
+// viewports reach <768px.
+//
+// Requires wrapping inputs and labels with `.form-group` for proper display of
+// default HTML form controls and our custom form controls (e.g., input groups).
+//
+// Heads up! This is mixin-ed into `.navbar-form` in navbars.less.
+
+.form-inline {
+
+  // Kick in the inline
+  @media (min-width: @screen-sm-min) {
+    // Inline-block all the things for "inline"
+    .form-group {
+      display: inline-block;
+      margin-bottom: 0;
+      vertical-align: middle;
+    }
+
+    // In navbar-form, allow folks to *not* use `.form-group`
+    .form-control {
+      display: inline-block;
+      width: auto; // Prevent labels from stacking above inputs in `.form-group`
+      vertical-align: middle;
+    }
+
+    // Make static controls behave like regular ones
+    .form-control-static {
+      display: inline-block;
+    }
+
+    .input-group {
+      display: inline-table;
+      vertical-align: middle;
+
+      .input-group-addon,
+      .input-group-btn,
+      .form-control {
+        width: auto;
+      }
+    }
+
+    // Input groups need that 100% width though
+    .input-group > .form-control {
+      width: 100%;
+    }
+
+    .control-label {
+      margin-bottom: 0;
+      vertical-align: middle;
+    }
+
+    // Remove default margin on radios/checkboxes that were used for stacking, and
+    // then undo the floating of radios and checkboxes to match.
+    .radio,
+    .checkbox {
+      display: inline-block;
+      margin-top: 0;
+      margin-bottom: 0;
+      vertical-align: middle;
+
+      label {
+        padding-left: 0;
+      }
+    }
+    .radio input[type="radio"],
+    .checkbox input[type="checkbox"] {
+      position: relative;
+      margin-left: 0;
+    }
+
+    // Re-override the feedback icon.
+    .has-feedback .form-control-feedback {
+      top: 0;
+    }
+  }
+}
+
+
+// Horizontal forms
+//
+// Horizontal forms are built on grid classes and allow you to create forms with
+// labels on the left and inputs on the right.
+
+.form-horizontal {
+
+  // Consistent vertical alignment of radios and checkboxes
+  //
+  // Labels also get some reset styles, but that is scoped to a media query below.
+  .radio,
+  .checkbox,
+  .radio-inline,
+  .checkbox-inline {
+    margin-top: 0;
+    margin-bottom: 0;
+    padding-top: (@padding-base-vertical + 1); // Default padding plus a border
+  }
+  // Account for padding we're adding to ensure the alignment and of help text
+  // and other content below items
+  .radio,
+  .checkbox {
+    min-height: (@line-height-computed + (@padding-base-vertical + 1));
+  }
+
+  // Make form groups behave like rows
+  .form-group {
+    .make-row();
+  }
+
+  // Reset spacing and right align labels, but scope to media queries so that
+  // labels on narrow viewports stack the same as a default form example.
+  @media (min-width: @screen-sm-min) {
+    .control-label {
+      text-align: right;
+      margin-bottom: 0;
+      padding-top: (@padding-base-vertical + 1); // Default padding plus a border
+    }
+  }
+
+  // Validation states
+  //
+  // Reposition the icon because it's now within a grid column and columns have
+  // `position: relative;` on them. Also accounts for the grid gutter padding.
+  .has-feedback .form-control-feedback {
+    right: (@grid-gutter-width / 2);
+  }
+
+  // Form group sizes
+  //
+  // Quick utility class for applying `.input-lg` and `.input-sm` styles to the
+  // inputs and labels within a `.form-group`.
+  .form-group-lg {
+    @media (min-width: @screen-sm-min) {
+      .control-label {
+        padding-top: ((@padding-large-vertical * @line-height-large) + 1);
+      }
+    }
+  }
+  .form-group-sm {
+    @media (min-width: @screen-sm-min) {
+      .control-label {
+        padding-top: (@padding-small-vertical + 1);
+      }
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/glyphicons.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/glyphicons.less
new file mode 100644
index 0000000000000000000000000000000000000000..335d80aa6bfebfc5bd64b60f75a9d49ea79687be
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/glyphicons.less
@@ -0,0 +1,305 @@
+//
+// Glyphicons for Bootstrap
+//
+// Since icons are fonts, they can be placed anywhere text is placed and are
+// thus automatically sized to match the surrounding child. To use, create an
+// inline element with the appropriate classes, like so:
+//
+// <a href="#"><span class="glyphicon glyphicon-star"></span> Star</a>
+
+// Import the fonts
+@font-face {
+  font-family: 'Glyphicons Halflings';
+  src: url('@{icon-font-path}@{icon-font-name}.eot');
+  src: url('@{icon-font-path}@{icon-font-name}.eot?#iefix') format('embedded-opentype'),
+       url('@{icon-font-path}@{icon-font-name}.woff2') format('woff2'),
+       url('@{icon-font-path}@{icon-font-name}.woff') format('woff'),
+       url('@{icon-font-path}@{icon-font-name}.ttf') format('truetype'),
+       url('@{icon-font-path}@{icon-font-name}.svg#@{icon-font-svg-id}') format('svg');
+}
+
+// Catchall baseclass
+.glyphicon {
+  position: relative;
+  top: 1px;
+  display: inline-block;
+  font-family: 'Glyphicons Halflings';
+  font-style: normal;
+  font-weight: normal;
+  line-height: 1;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+// Individual icons
+.glyphicon-asterisk               { &:before { content: "\2a"; } }
+.glyphicon-plus                   { &:before { content: "\2b"; } }
+.glyphicon-euro,
+.glyphicon-eur                    { &:before { content: "\20ac"; } }
+.glyphicon-minus                  { &:before { content: "\2212"; } }
+.glyphicon-cloud                  { &:before { content: "\2601"; } }
+.glyphicon-envelope               { &:before { content: "\2709"; } }
+.glyphicon-pencil                 { &:before { content: "\270f"; } }
+.glyphicon-glass                  { &:before { content: "\e001"; } }
+.glyphicon-music                  { &:before { content: "\e002"; } }
+.glyphicon-search                 { &:before { content: "\e003"; } }
+.glyphicon-heart                  { &:before { content: "\e005"; } }
+.glyphicon-star                   { &:before { content: "\e006"; } }
+.glyphicon-star-empty             { &:before { content: "\e007"; } }
+.glyphicon-user                   { &:before { content: "\e008"; } }
+.glyphicon-film                   { &:before { content: "\e009"; } }
+.glyphicon-th-large               { &:before { content: "\e010"; } }
+.glyphicon-th                     { &:before { content: "\e011"; } }
+.glyphicon-th-list                { &:before { content: "\e012"; } }
+.glyphicon-ok                     { &:before { content: "\e013"; } }
+.glyphicon-remove                 { &:before { content: "\e014"; } }
+.glyphicon-zoom-in                { &:before { content: "\e015"; } }
+.glyphicon-zoom-out               { &:before { content: "\e016"; } }
+.glyphicon-off                    { &:before { content: "\e017"; } }
+.glyphicon-signal                 { &:before { content: "\e018"; } }
+.glyphicon-cog                    { &:before { content: "\e019"; } }
+.glyphicon-trash                  { &:before { content: "\e020"; } }
+.glyphicon-home                   { &:before { content: "\e021"; } }
+.glyphicon-file                   { &:before { content: "\e022"; } }
+.glyphicon-time                   { &:before { content: "\e023"; } }
+.glyphicon-road                   { &:before { content: "\e024"; } }
+.glyphicon-download-alt           { &:before { content: "\e025"; } }
+.glyphicon-download               { &:before { content: "\e026"; } }
+.glyphicon-upload                 { &:before { content: "\e027"; } }
+.glyphicon-inbox                  { &:before { content: "\e028"; } }
+.glyphicon-play-circle            { &:before { content: "\e029"; } }
+.glyphicon-repeat                 { &:before { content: "\e030"; } }
+.glyphicon-refresh                { &:before { content: "\e031"; } }
+.glyphicon-list-alt               { &:before { content: "\e032"; } }
+.glyphicon-lock                   { &:before { content: "\e033"; } }
+.glyphicon-flag                   { &:before { content: "\e034"; } }
+.glyphicon-headphones             { &:before { content: "\e035"; } }
+.glyphicon-volume-off             { &:before { content: "\e036"; } }
+.glyphicon-volume-down            { &:before { content: "\e037"; } }
+.glyphicon-volume-up              { &:before { content: "\e038"; } }
+.glyphicon-qrcode                 { &:before { content: "\e039"; } }
+.glyphicon-barcode                { &:before { content: "\e040"; } }
+.glyphicon-tag                    { &:before { content: "\e041"; } }
+.glyphicon-tags                   { &:before { content: "\e042"; } }
+.glyphicon-book                   { &:before { content: "\e043"; } }
+.glyphicon-bookmark               { &:before { content: "\e044"; } }
+.glyphicon-print                  { &:before { content: "\e045"; } }
+.glyphicon-camera                 { &:before { content: "\e046"; } }
+.glyphicon-font                   { &:before { content: "\e047"; } }
+.glyphicon-bold                   { &:before { content: "\e048"; } }
+.glyphicon-italic                 { &:before { content: "\e049"; } }
+.glyphicon-text-height            { &:before { content: "\e050"; } }
+.glyphicon-text-width             { &:before { content: "\e051"; } }
+.glyphicon-align-left             { &:before { content: "\e052"; } }
+.glyphicon-align-center           { &:before { content: "\e053"; } }
+.glyphicon-align-right            { &:before { content: "\e054"; } }
+.glyphicon-align-justify          { &:before { content: "\e055"; } }
+.glyphicon-list                   { &:before { content: "\e056"; } }
+.glyphicon-indent-left            { &:before { content: "\e057"; } }
+.glyphicon-indent-right           { &:before { content: "\e058"; } }
+.glyphicon-facetime-video         { &:before { content: "\e059"; } }
+.glyphicon-picture                { &:before { content: "\e060"; } }
+.glyphicon-map-marker             { &:before { content: "\e062"; } }
+.glyphicon-adjust                 { &:before { content: "\e063"; } }
+.glyphicon-tint                   { &:before { content: "\e064"; } }
+.glyphicon-edit                   { &:before { content: "\e065"; } }
+.glyphicon-share                  { &:before { content: "\e066"; } }
+.glyphicon-check                  { &:before { content: "\e067"; } }
+.glyphicon-move                   { &:before { content: "\e068"; } }
+.glyphicon-step-backward          { &:before { content: "\e069"; } }
+.glyphicon-fast-backward          { &:before { content: "\e070"; } }
+.glyphicon-backward               { &:before { content: "\e071"; } }
+.glyphicon-play                   { &:before { content: "\e072"; } }
+.glyphicon-pause                  { &:before { content: "\e073"; } }
+.glyphicon-stop                   { &:before { content: "\e074"; } }
+.glyphicon-forward                { &:before { content: "\e075"; } }
+.glyphicon-fast-forward           { &:before { content: "\e076"; } }
+.glyphicon-step-forward           { &:before { content: "\e077"; } }
+.glyphicon-eject                  { &:before { content: "\e078"; } }
+.glyphicon-chevron-left           { &:before { content: "\e079"; } }
+.glyphicon-chevron-right          { &:before { content: "\e080"; } }
+.glyphicon-plus-sign              { &:before { content: "\e081"; } }
+.glyphicon-minus-sign             { &:before { content: "\e082"; } }
+.glyphicon-remove-sign            { &:before { content: "\e083"; } }
+.glyphicon-ok-sign                { &:before { content: "\e084"; } }
+.glyphicon-question-sign          { &:before { content: "\e085"; } }
+.glyphicon-info-sign              { &:before { content: "\e086"; } }
+.glyphicon-screenshot             { &:before { content: "\e087"; } }
+.glyphicon-remove-circle          { &:before { content: "\e088"; } }
+.glyphicon-ok-circle              { &:before { content: "\e089"; } }
+.glyphicon-ban-circle             { &:before { content: "\e090"; } }
+.glyphicon-arrow-left             { &:before { content: "\e091"; } }
+.glyphicon-arrow-right            { &:before { content: "\e092"; } }
+.glyphicon-arrow-up               { &:before { content: "\e093"; } }
+.glyphicon-arrow-down             { &:before { content: "\e094"; } }
+.glyphicon-share-alt              { &:before { content: "\e095"; } }
+.glyphicon-resize-full            { &:before { content: "\e096"; } }
+.glyphicon-resize-small           { &:before { content: "\e097"; } }
+.glyphicon-exclamation-sign       { &:before { content: "\e101"; } }
+.glyphicon-gift                   { &:before { content: "\e102"; } }
+.glyphicon-leaf                   { &:before { content: "\e103"; } }
+.glyphicon-fire                   { &:before { content: "\e104"; } }
+.glyphicon-eye-open               { &:before { content: "\e105"; } }
+.glyphicon-eye-close              { &:before { content: "\e106"; } }
+.glyphicon-warning-sign           { &:before { content: "\e107"; } }
+.glyphicon-plane                  { &:before { content: "\e108"; } }
+.glyphicon-calendar               { &:before { content: "\e109"; } }
+.glyphicon-random                 { &:before { content: "\e110"; } }
+.glyphicon-comment                { &:before { content: "\e111"; } }
+.glyphicon-magnet                 { &:before { content: "\e112"; } }
+.glyphicon-chevron-up             { &:before { content: "\e113"; } }
+.glyphicon-chevron-down           { &:before { content: "\e114"; } }
+.glyphicon-retweet                { &:before { content: "\e115"; } }
+.glyphicon-shopping-cart          { &:before { content: "\e116"; } }
+.glyphicon-folder-close           { &:before { content: "\e117"; } }
+.glyphicon-folder-open            { &:before { content: "\e118"; } }
+.glyphicon-resize-vertical        { &:before { content: "\e119"; } }
+.glyphicon-resize-horizontal      { &:before { content: "\e120"; } }
+.glyphicon-hdd                    { &:before { content: "\e121"; } }
+.glyphicon-bullhorn               { &:before { content: "\e122"; } }
+.glyphicon-bell                   { &:before { content: "\e123"; } }
+.glyphicon-certificate            { &:before { content: "\e124"; } }
+.glyphicon-thumbs-up              { &:before { content: "\e125"; } }
+.glyphicon-thumbs-down            { &:before { content: "\e126"; } }
+.glyphicon-hand-right             { &:before { content: "\e127"; } }
+.glyphicon-hand-left              { &:before { content: "\e128"; } }
+.glyphicon-hand-up                { &:before { content: "\e129"; } }
+.glyphicon-hand-down              { &:before { content: "\e130"; } }
+.glyphicon-circle-arrow-right     { &:before { content: "\e131"; } }
+.glyphicon-circle-arrow-left      { &:before { content: "\e132"; } }
+.glyphicon-circle-arrow-up        { &:before { content: "\e133"; } }
+.glyphicon-circle-arrow-down      { &:before { content: "\e134"; } }
+.glyphicon-globe                  { &:before { content: "\e135"; } }
+.glyphicon-wrench                 { &:before { content: "\e136"; } }
+.glyphicon-tasks                  { &:before { content: "\e137"; } }
+.glyphicon-filter                 { &:before { content: "\e138"; } }
+.glyphicon-briefcase              { &:before { content: "\e139"; } }
+.glyphicon-fullscreen             { &:before { content: "\e140"; } }
+.glyphicon-dashboard              { &:before { content: "\e141"; } }
+.glyphicon-paperclip              { &:before { content: "\e142"; } }
+.glyphicon-heart-empty            { &:before { content: "\e143"; } }
+.glyphicon-link                   { &:before { content: "\e144"; } }
+.glyphicon-phone                  { &:before { content: "\e145"; } }
+.glyphicon-pushpin                { &:before { content: "\e146"; } }
+.glyphicon-usd                    { &:before { content: "\e148"; } }
+.glyphicon-gbp                    { &:before { content: "\e149"; } }
+.glyphicon-sort                   { &:before { content: "\e150"; } }
+.glyphicon-sort-by-alphabet       { &:before { content: "\e151"; } }
+.glyphicon-sort-by-alphabet-alt   { &:before { content: "\e152"; } }
+.glyphicon-sort-by-order          { &:before { content: "\e153"; } }
+.glyphicon-sort-by-order-alt      { &:before { content: "\e154"; } }
+.glyphicon-sort-by-attributes     { &:before { content: "\e155"; } }
+.glyphicon-sort-by-attributes-alt { &:before { content: "\e156"; } }
+.glyphicon-unchecked              { &:before { content: "\e157"; } }
+.glyphicon-expand                 { &:before { content: "\e158"; } }
+.glyphicon-collapse-down          { &:before { content: "\e159"; } }
+.glyphicon-collapse-up            { &:before { content: "\e160"; } }
+.glyphicon-log-in                 { &:before { content: "\e161"; } }
+.glyphicon-flash                  { &:before { content: "\e162"; } }
+.glyphicon-log-out                { &:before { content: "\e163"; } }
+.glyphicon-new-window             { &:before { content: "\e164"; } }
+.glyphicon-record                 { &:before { content: "\e165"; } }
+.glyphicon-save                   { &:before { content: "\e166"; } }
+.glyphicon-open                   { &:before { content: "\e167"; } }
+.glyphicon-saved                  { &:before { content: "\e168"; } }
+.glyphicon-import                 { &:before { content: "\e169"; } }
+.glyphicon-export                 { &:before { content: "\e170"; } }
+.glyphicon-send                   { &:before { content: "\e171"; } }
+.glyphicon-floppy-disk            { &:before { content: "\e172"; } }
+.glyphicon-floppy-saved           { &:before { content: "\e173"; } }
+.glyphicon-floppy-remove          { &:before { content: "\e174"; } }
+.glyphicon-floppy-save            { &:before { content: "\e175"; } }
+.glyphicon-floppy-open            { &:before { content: "\e176"; } }
+.glyphicon-credit-card            { &:before { content: "\e177"; } }
+.glyphicon-transfer               { &:before { content: "\e178"; } }
+.glyphicon-cutlery                { &:before { content: "\e179"; } }
+.glyphicon-header                 { &:before { content: "\e180"; } }
+.glyphicon-compressed             { &:before { content: "\e181"; } }
+.glyphicon-earphone               { &:before { content: "\e182"; } }
+.glyphicon-phone-alt              { &:before { content: "\e183"; } }
+.glyphicon-tower                  { &:before { content: "\e184"; } }
+.glyphicon-stats                  { &:before { content: "\e185"; } }
+.glyphicon-sd-video               { &:before { content: "\e186"; } }
+.glyphicon-hd-video               { &:before { content: "\e187"; } }
+.glyphicon-subtitles              { &:before { content: "\e188"; } }
+.glyphicon-sound-stereo           { &:before { content: "\e189"; } }
+.glyphicon-sound-dolby            { &:before { content: "\e190"; } }
+.glyphicon-sound-5-1              { &:before { content: "\e191"; } }
+.glyphicon-sound-6-1              { &:before { content: "\e192"; } }
+.glyphicon-sound-7-1              { &:before { content: "\e193"; } }
+.glyphicon-copyright-mark         { &:before { content: "\e194"; } }
+.glyphicon-registration-mark      { &:before { content: "\e195"; } }
+.glyphicon-cloud-download         { &:before { content: "\e197"; } }
+.glyphicon-cloud-upload           { &:before { content: "\e198"; } }
+.glyphicon-tree-conifer           { &:before { content: "\e199"; } }
+.glyphicon-tree-deciduous         { &:before { content: "\e200"; } }
+.glyphicon-cd                     { &:before { content: "\e201"; } }
+.glyphicon-save-file              { &:before { content: "\e202"; } }
+.glyphicon-open-file              { &:before { content: "\e203"; } }
+.glyphicon-level-up               { &:before { content: "\e204"; } }
+.glyphicon-copy                   { &:before { content: "\e205"; } }
+.glyphicon-paste                  { &:before { content: "\e206"; } }
+// The following 2 Glyphicons are omitted for the time being because
+// they currently use Unicode codepoints that are outside the
+// Basic Multilingual Plane (BMP). Older buggy versions of WebKit can't handle
+// non-BMP codepoints in CSS string escapes, and thus can't display these two icons.
+// Notably, the bug affects some older versions of the Android Browser.
+// More info: https://github.com/twbs/bootstrap/issues/10106
+// .glyphicon-door                   { &:before { content: "\1f6aa"; } }
+// .glyphicon-key                    { &:before { content: "\1f511"; } }
+.glyphicon-alert                  { &:before { content: "\e209"; } }
+.glyphicon-equalizer              { &:before { content: "\e210"; } }
+.glyphicon-king                   { &:before { content: "\e211"; } }
+.glyphicon-queen                  { &:before { content: "\e212"; } }
+.glyphicon-pawn                   { &:before { content: "\e213"; } }
+.glyphicon-bishop                 { &:before { content: "\e214"; } }
+.glyphicon-knight                 { &:before { content: "\e215"; } }
+.glyphicon-baby-formula           { &:before { content: "\e216"; } }
+.glyphicon-tent                   { &:before { content: "\26fa"; } }
+.glyphicon-blackboard             { &:before { content: "\e218"; } }
+.glyphicon-bed                    { &:before { content: "\e219"; } }
+.glyphicon-apple                  { &:before { content: "\f8ff"; } }
+.glyphicon-erase                  { &:before { content: "\e221"; } }
+.glyphicon-hourglass              { &:before { content: "\231b"; } }
+.glyphicon-lamp                   { &:before { content: "\e223"; } }
+.glyphicon-duplicate              { &:before { content: "\e224"; } }
+.glyphicon-piggy-bank             { &:before { content: "\e225"; } }
+.glyphicon-scissors               { &:before { content: "\e226"; } }
+.glyphicon-bitcoin                { &:before { content: "\e227"; } }
+.glyphicon-btc                    { &:before { content: "\e227"; } }
+.glyphicon-xbt                    { &:before { content: "\e227"; } }
+.glyphicon-yen                    { &:before { content: "\00a5"; } }
+.glyphicon-jpy                    { &:before { content: "\00a5"; } }
+.glyphicon-ruble                  { &:before { content: "\20bd"; } }
+.glyphicon-rub                    { &:before { content: "\20bd"; } }
+.glyphicon-scale                  { &:before { content: "\e230"; } }
+.glyphicon-ice-lolly              { &:before { content: "\e231"; } }
+.glyphicon-ice-lolly-tasted       { &:before { content: "\e232"; } }
+.glyphicon-education              { &:before { content: "\e233"; } }
+.glyphicon-option-horizontal      { &:before { content: "\e234"; } }
+.glyphicon-option-vertical        { &:before { content: "\e235"; } }
+.glyphicon-menu-hamburger         { &:before { content: "\e236"; } }
+.glyphicon-modal-window           { &:before { content: "\e237"; } }
+.glyphicon-oil                    { &:before { content: "\e238"; } }
+.glyphicon-grain                  { &:before { content: "\e239"; } }
+.glyphicon-sunglasses             { &:before { content: "\e240"; } }
+.glyphicon-text-size              { &:before { content: "\e241"; } }
+.glyphicon-text-color             { &:before { content: "\e242"; } }
+.glyphicon-text-background        { &:before { content: "\e243"; } }
+.glyphicon-object-align-top       { &:before { content: "\e244"; } }
+.glyphicon-object-align-bottom    { &:before { content: "\e245"; } }
+.glyphicon-object-align-horizontal{ &:before { content: "\e246"; } }
+.glyphicon-object-align-left      { &:before { content: "\e247"; } }
+.glyphicon-object-align-vertical  { &:before { content: "\e248"; } }
+.glyphicon-object-align-right     { &:before { content: "\e249"; } }
+.glyphicon-triangle-right         { &:before { content: "\e250"; } }
+.glyphicon-triangle-left          { &:before { content: "\e251"; } }
+.glyphicon-triangle-bottom        { &:before { content: "\e252"; } }
+.glyphicon-triangle-top           { &:before { content: "\e253"; } }
+.glyphicon-console                { &:before { content: "\e254"; } }
+.glyphicon-superscript            { &:before { content: "\e255"; } }
+.glyphicon-subscript              { &:before { content: "\e256"; } }
+.glyphicon-menu-left              { &:before { content: "\e257"; } }
+.glyphicon-menu-right             { &:before { content: "\e258"; } }
+.glyphicon-menu-down              { &:before { content: "\e259"; } }
+.glyphicon-menu-up                { &:before { content: "\e260"; } }
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/grid.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/grid.less
new file mode 100644
index 0000000000000000000000000000000000000000..2e61c942611cbfcdb79293a3fe86e6e938db0e66
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/grid.less
@@ -0,0 +1,84 @@
+//
+// Grid system
+// --------------------------------------------------
+
+
+// Container widths
+//
+// Set the container width, and override it for fixed navbars in media queries.
+
+.tb-container {
+  .container-fixed();
+
+  @media (min-width: @screen-sm-min) {
+    width: @container-sm;
+  }
+  @media (min-width: @screen-md-min) {
+    width: @container-md;
+  }
+  @media (min-width: @screen-lg-min) {
+    width: @container-lg;
+  }
+}
+
+
+// Fluid container
+//
+// Utilizes the mixin meant for fixed width containers, but without any defined
+// width for fluid, full width layouts.
+
+.container-fluid {
+  .container-fixed();
+}
+
+
+// Row
+//
+// Rows contain and clear the floats of your columns.
+
+.row {
+  .make-row();
+}
+
+
+// Columns
+//
+// Common styles for small and large grid columns
+
+.make-grid-columns();
+
+
+// Extra small grid
+//
+// Columns, offsets, pushes, and pulls for extra small devices like
+// smartphones.
+
+.make-grid(xs);
+
+
+// Small grid
+//
+// Columns, offsets, pushes, and pulls for the small device range, from phones
+// to tablets.
+
+@media (min-width: @screen-sm-min) {
+  .make-grid(sm);
+}
+
+
+// Medium grid
+//
+// Columns, offsets, pushes, and pulls for the desktop device range.
+
+@media (min-width: @screen-md-min) {
+  .make-grid(md);
+}
+
+
+// Large grid
+//
+// Columns, offsets, pushes, and pulls for the large desktop device range.
+
+@media (min-width: @screen-lg-min) {
+  .make-grid(lg);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/input-groups.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/input-groups.less
new file mode 100644
index 0000000000000000000000000000000000000000..a8712f25b935f6d13e3d7ea9471d354a7bccd4df
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/input-groups.less
@@ -0,0 +1,166 @@
+//
+// Input groups
+// --------------------------------------------------
+
+// Base styles
+// -------------------------
+.input-group {
+  position: relative; // For dropdowns
+  display: table;
+  border-collapse: separate; // prevent input groups from inheriting border styles from table cells when placed within a table
+
+  // Undo padding and float of grid classes
+  &[class*="col-"] {
+    float: none;
+    padding-left: 0;
+    padding-right: 0;
+  }
+
+  .form-control {
+    // Ensure that the input is always above the *appended* addon button for
+    // proper border colors.
+    position: relative;
+    z-index: 2;
+
+    // IE9 fubars the placeholder attribute in text inputs and the arrows on
+    // select elements in input groups. To fix it, we float the input. Details:
+    // https://github.com/twbs/bootstrap/issues/11561#issuecomment-28936855
+    float: left;
+
+    width: 100%;
+    margin-bottom: 0;
+  }
+}
+
+// Sizing options
+//
+// Remix the default form control sizing classes into new ones for easier
+// manipulation.
+
+.input-group-lg > .form-control,
+.input-group-lg > .input-group-addon,
+.input-group-lg > .input-group-btn > .btn {
+  .input-lg();
+}
+.input-group-sm > .form-control,
+.input-group-sm > .input-group-addon,
+.input-group-sm > .input-group-btn > .btn {
+  .input-sm();
+}
+
+
+// Display as table-cell
+// -------------------------
+.input-group-addon,
+.input-group-btn,
+.input-group .form-control {
+  display: table-cell;
+
+  &:not(:first-child):not(:last-child) {
+    border-radius: 0;
+  }
+}
+// Addon and addon wrapper for buttons
+.input-group-addon,
+.input-group-btn {
+  width: 1%;
+  white-space: nowrap;
+  vertical-align: middle; // Match the inputs
+}
+
+// Text input groups
+// -------------------------
+.input-group-addon {
+  padding: @padding-base-vertical @padding-base-horizontal;
+  font-size: @font-size-base;
+  font-weight: normal;
+  line-height: 1;
+  color: @input-color;
+  text-align: center;
+  background-color: @input-group-addon-bg;
+  border: 1px solid @input-group-addon-border-color;
+  border-radius: @border-radius-base;
+
+  // Sizing
+  &.input-sm {
+    padding: @padding-small-vertical @padding-small-horizontal;
+    font-size: @font-size-small;
+    border-radius: @border-radius-small;
+  }
+  &.input-lg {
+    padding: @padding-large-vertical @padding-large-horizontal;
+    font-size: @font-size-large;
+    border-radius: @border-radius-large;
+  }
+
+  // Nuke default margins from checkboxes and radios to vertically center within.
+  input[type="radio"],
+  input[type="checkbox"] {
+    margin-top: 0;
+  }
+}
+
+// Reset rounded corners
+.input-group .form-control:first-child,
+.input-group-addon:first-child,
+.input-group-btn:first-child > .btn,
+.input-group-btn:first-child > .btn-group > .btn,
+.input-group-btn:first-child > .dropdown-toggle,
+.input-group-btn:last-child > .btn:not(:last-child):not(.dropdown-toggle),
+.input-group-btn:last-child > .btn-group:not(:last-child) > .btn {
+  .border-right-radius(0);
+}
+.input-group-addon:first-child {
+  border-right: 0;
+}
+.input-group .form-control:last-child,
+.input-group-addon:last-child,
+.input-group-btn:last-child > .btn,
+.input-group-btn:last-child > .btn-group > .btn,
+.input-group-btn:last-child > .dropdown-toggle,
+.input-group-btn:first-child > .btn:not(:first-child),
+.input-group-btn:first-child > .btn-group:not(:first-child) > .btn {
+  .border-left-radius(0);
+}
+.input-group-addon:last-child {
+  border-left: 0;
+}
+
+// Button input groups
+// -------------------------
+.input-group-btn {
+  position: relative;
+  // Jankily prevent input button groups from wrapping with `white-space` and
+  // `font-size` in combination with `inline-block` on buttons.
+  font-size: 0;
+  white-space: nowrap;
+
+  // Negative margin for spacing, position for bringing hovered/focused/actived
+  // element above the siblings.
+  > .btn {
+    position: relative;
+    + .btn {
+      margin-left: -1px;
+    }
+    // Bring the "active" button to the front
+    &:hover,
+    &:focus,
+    &:active {
+      z-index: 2;
+    }
+  }
+
+  // Negative margin to only have a 1px border between the two
+  &:first-child {
+    > .btn,
+    > .btn-group {
+      margin-right: -1px;
+    }
+  }
+  &:last-child {
+    > .btn,
+    > .btn-group {
+      margin-left: -1px;
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/jumbotron.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/jumbotron.less
new file mode 100644
index 0000000000000000000000000000000000000000..909580f9810298dfd9922f1c24f1422a0f51f0b2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/jumbotron.less
@@ -0,0 +1,50 @@
+//
+// Jumbotron
+// --------------------------------------------------
+
+
+.jumbotron {
+  padding: @jumbotron-padding (@jumbotron-padding / 2);
+  margin-bottom: @jumbotron-padding;
+  color: @jumbotron-color;
+  background-color: @jumbotron-bg;
+
+  h1,
+  .h1 {
+    color: @jumbotron-heading-color;
+  }
+
+  p {
+    margin-bottom: (@jumbotron-padding / 2);
+    font-size: @jumbotron-font-size;
+    font-weight: 200;
+  }
+
+  > hr {
+    border-top-color: darken(@jumbotron-bg, 10%);
+  }
+
+  .tb-container &,
+  .container-fluid & {
+    border-radius: @border-radius-large; // Only round corners at higher resolutions if contained in a container
+  }
+
+  .tb-container {
+    max-width: 100%;
+  }
+
+  @media screen and (min-width: @screen-sm-min) {
+    padding: (@jumbotron-padding * 1.6) 0;
+
+    .tb-container &,
+    .container-fluid & {
+      padding-left:  (@jumbotron-padding * 2);
+      padding-right: (@jumbotron-padding * 2);
+    }
+
+    h1,
+    .h1 {
+      font-size: (@font-size-base * 4.5);
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/labels.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/labels.less
new file mode 100644
index 0000000000000000000000000000000000000000..9a5a27006a51f4ac0d350cf11060aa548cd6ef6b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/labels.less
@@ -0,0 +1,64 @@
+//
+// Labels
+// --------------------------------------------------
+
+.label {
+  display: inline;
+  padding: .2em .6em .3em;
+  font-size: 75%;
+  font-weight: bold;
+  line-height: 1;
+  color: @label-color;
+  text-align: center;
+  white-space: nowrap;
+  vertical-align: baseline;
+  border-radius: .25em;
+
+  // Add hover effects, but only for links
+  a& {
+    &:hover,
+    &:focus {
+      color: @label-link-hover-color;
+      text-decoration: none;
+      cursor: pointer;
+    }
+  }
+
+  // Empty labels collapse automatically (not available in IE8)
+  &:empty {
+    display: none;
+  }
+
+  // Quick fix for labels in buttons
+  .btn & {
+    position: relative;
+    top: -1px;
+  }
+}
+
+// Colors
+// Contextual variations (linked labels get darker on :hover)
+
+.label-default {
+  .label-variant(@label-default-bg);
+}
+
+.label-primary {
+  .label-variant(@label-primary-bg);
+}
+
+.label-success {
+  .label-variant(@label-success-bg);
+}
+
+.label-info {
+  .label-variant(@label-info-bg);
+}
+
+.label-warning {
+  .label-variant(@label-warning-bg);
+}
+
+.label-danger {
+  .label-variant(@label-danger-bg);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/list-group.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/list-group.less
new file mode 100644
index 0000000000000000000000000000000000000000..1462ce16b325082f98f78d8e28535fe96e86f1da
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/list-group.less
@@ -0,0 +1,124 @@
+//
+// List groups
+// --------------------------------------------------
+
+
+// Base class
+//
+// Easily usable on <ul>, <ol>, or <div>.
+
+.list-group {
+  // No need to set list-style: none; since .list-group-item is block level
+  margin-bottom: 20px;
+  padding-left: 0; // reset padding because ul and ol
+}
+
+
+// Individual list items
+//
+// Use on `li`s or `div`s within the `.list-group` parent.
+
+.list-group-item {
+  position: relative;
+  display: block;
+  padding: 10px 15px;
+  // Place the border on the list items and negative margin up for better styling
+  margin-bottom: -1px;
+  background-color: @list-group-bg;
+  border: 1px solid @list-group-border;
+
+  // Round the first and last items
+  &:first-child {
+    .border-top-radius(@list-group-border-radius);
+  }
+  &:last-child {
+    margin-bottom: 0;
+    .border-bottom-radius(@list-group-border-radius);
+  }
+}
+
+
+// Linked list items
+//
+// Use anchor elements instead of `li`s or `div`s to create linked list items.
+// Includes an extra `.active` modifier class for showing selected items.
+
+a.list-group-item {
+  color: @list-group-link-color;
+
+  .list-group-item-heading {
+    color: @list-group-link-heading-color;
+  }
+
+  // Hover state
+  &:hover,
+  &:focus {
+    text-decoration: none;
+    color: @list-group-link-hover-color;
+    background-color: @list-group-hover-bg;
+  }
+}
+
+.list-group-item {
+  // Disabled state
+  &.disabled,
+  &.disabled:hover,
+  &.disabled:focus {
+    background-color: @list-group-disabled-bg;
+    color: @list-group-disabled-color;
+    cursor: @cursor-disabled;
+
+    // Force color to inherit for custom content
+    .list-group-item-heading {
+      color: inherit;
+    }
+    .list-group-item-text {
+      color: @list-group-disabled-text-color;
+    }
+  }
+
+  // Active class on item itself, not parent
+  &.active,
+  &.active:hover,
+  &.active:focus {
+    z-index: 2; // Place active items above their siblings for proper border styling
+    color: @list-group-active-color;
+    background-color: @list-group-active-bg;
+    border-color: @list-group-active-border;
+
+    // Force color to inherit for custom content
+    .list-group-item-heading,
+    .list-group-item-heading > small,
+    .list-group-item-heading > .small {
+      color: inherit;
+    }
+    .list-group-item-text {
+      color: @list-group-active-text-color;
+    }
+  }
+}
+
+
+// Contextual variants
+//
+// Add modifier classes to change text and background color on individual items.
+// Organizationally, this must come after the `:hover` states.
+
+.list-group-item-variant(success; @state-success-bg; @state-success-text);
+.list-group-item-variant(info; @state-info-bg; @state-info-text);
+.list-group-item-variant(warning; @state-warning-bg; @state-warning-text);
+.list-group-item-variant(danger; @state-danger-bg; @state-danger-text);
+
+
+// Custom content options
+//
+// Extra classes for creating well-formatted content within `.list-group-item`s.
+
+.list-group-item-heading {
+  margin-top: 0;
+  margin-bottom: 5px;
+}
+.list-group-item-text {
+  margin-bottom: 0;
+  line-height: 1.3;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/media.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/media.less
new file mode 100644
index 0000000000000000000000000000000000000000..a6bf78192469c48166b7ddcd494ba2cbec376233
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/media.less
@@ -0,0 +1,61 @@
+.media {
+  // Proper spacing between instances of .media
+  margin-top: 15px;
+
+  &:first-child {
+    margin-top: 0;
+  }
+}
+
+.media,
+.media-body {
+  zoom: 1;
+  overflow: hidden;
+}
+
+.media-body {
+  width: 10000px;
+}
+
+.media-object {
+  display: block;
+}
+
+.media-right,
+.media > .pull-right {
+  padding-left: 10px;
+}
+
+.media-left,
+.media > .pull-left {
+  padding-right: 10px;
+}
+
+.media-left,
+.media-right,
+.media-body {
+  display: table-cell;
+  vertical-align: top;
+}
+
+.media-middle {
+  vertical-align: middle;
+}
+
+.media-bottom {
+  vertical-align: bottom;
+}
+
+// Reset margins on headings for tighter default spacing
+.media-heading {
+  margin-top: 0;
+  margin-bottom: 5px;
+}
+
+// Media list variation
+//
+// Undo default ul/ol styles
+.media-list {
+  padding-left: 0;
+  list-style: none;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins.less
new file mode 100644
index 0000000000000000000000000000000000000000..af4408fc2d6846b5656d9d0d12f2f4cbf4404cf6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins.less
@@ -0,0 +1,39 @@
+// Mixins
+// --------------------------------------------------
+
+// Utilities
+@import "mixins/hide-text.less";
+@import "mixins/opacity.less";
+@import "mixins/image.less";
+@import "mixins/labels.less";
+@import "mixins/reset-filter.less";
+@import "mixins/resize.less";
+@import "mixins/responsive-visibility.less";
+@import "mixins/size.less";
+@import "mixins/tab-focus.less";
+@import "mixins/text-emphasis.less";
+@import "mixins/text-overflow.less";
+@import "mixins/vendor-prefixes.less";
+
+// Components
+@import "mixins/alerts.less";
+@import "mixins/buttons.less";
+@import "mixins/panels.less";
+@import "mixins/pagination.less";
+@import "mixins/list-group.less";
+@import "mixins/nav-divider.less";
+@import "mixins/forms.less";
+@import "mixins/progress-bar.less";
+@import "mixins/table-row.less";
+
+// Skins
+@import "mixins/background-variant.less";
+@import "mixins/border-radius.less";
+@import "mixins/gradients.less";
+
+// Layout
+@import "mixins/clearfix.less";
+@import "mixins/center-block.less";
+@import "mixins/nav-vertical-align.less";
+@import "mixins/grid-framework.less";
+@import "mixins/grid.less";
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/alerts.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/alerts.less
new file mode 100644
index 0000000000000000000000000000000000000000..396196f438fd31e7757a0874ece4a99fe0cf9fd9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/alerts.less
@@ -0,0 +1,14 @@
+// Alerts
+
+.alert-variant(@background; @border; @text-color) {
+  background-color: @background;
+  border-color: @border;
+  color: @text-color;
+
+  hr {
+    border-top-color: darken(@border, 5%);
+  }
+  .alert-link {
+    color: darken(@text-color, 10%);
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/background-variant.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/background-variant.less
new file mode 100644
index 0000000000000000000000000000000000000000..556e490d45d004c4e4504153133c5c1050207b65
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/background-variant.less
@@ -0,0 +1,8 @@
+// Contextual backgrounds
+
+.bg-variant(@color) {
+  background-color: @color;
+  a&:hover {
+    background-color: darken(@color, 10%);
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/border-radius.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/border-radius.less
new file mode 100644
index 0000000000000000000000000000000000000000..ca05dbf457000d122a3b8afcc3847e44cffea421
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/border-radius.less
@@ -0,0 +1,18 @@
+// Single side border-radius
+
+.border-top-radius(@radius) {
+  border-top-right-radius: @radius;
+   border-top-left-radius: @radius;
+}
+.border-right-radius(@radius) {
+  border-bottom-right-radius: @radius;
+     border-top-right-radius: @radius;
+}
+.border-bottom-radius(@radius) {
+  border-bottom-right-radius: @radius;
+   border-bottom-left-radius: @radius;
+}
+.border-left-radius(@radius) {
+  border-bottom-left-radius: @radius;
+     border-top-left-radius: @radius;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/buttons.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/buttons.less
new file mode 100644
index 0000000000000000000000000000000000000000..92d8a056cd3b73c82937b0c9d478a86baa6d142a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/buttons.less
@@ -0,0 +1,52 @@
+// Button variants
+//
+// Easily pump out default styles, as well as :hover, :focus, :active,
+// and disabled options for all buttons
+
+.button-variant(@color; @background; @border) {
+  color: @color;
+  background-color: @background;
+  border-color: @border;
+
+  &:hover,
+  &:focus,
+  &.focus,
+  &:active,
+  &.active,
+  .open > .dropdown-toggle& {
+    color: @color;
+    background-color: darken(@background, 10%);
+        border-color: darken(@border, 12%);
+  }
+  &:active,
+  &.active,
+  .open > .dropdown-toggle& {
+    background-image: none;
+  }
+  &.disabled,
+  &[disabled],
+  fieldset[disabled] & {
+    &,
+    &:hover,
+    &:focus,
+    &.focus,
+    &:active,
+    &.active {
+      background-color: @background;
+          border-color: @border;
+    }
+  }
+
+  .badge {
+    color: @background;
+    background-color: @color;
+  }
+}
+
+// Button sizes
+.button-size(@padding-vertical; @padding-horizontal; @font-size; @line-height; @border-radius) {
+  padding: @padding-vertical @padding-horizontal;
+  font-size: @font-size;
+  line-height: @line-height;
+  border-radius: @border-radius;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/center-block.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/center-block.less
new file mode 100644
index 0000000000000000000000000000000000000000..d18d6de9ed6a7af49415277cb72e57b7dbd42d0f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/center-block.less
@@ -0,0 +1,7 @@
+// Center-align a block level element
+
+.center-block() {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/clearfix.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/clearfix.less
new file mode 100644
index 0000000000000000000000000000000000000000..3f7a3820c1cf7756322917982646352e77119f46
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/clearfix.less
@@ -0,0 +1,22 @@
+// Clearfix
+//
+// For modern browsers
+// 1. The space content is one way to avoid an Opera bug when the
+//    contenteditable attribute is included anywhere else in the document.
+//    Otherwise it causes space to appear at the top and bottom of elements
+//    that are clearfixed.
+// 2. The use of `table` rather than `block` is only necessary if using
+//    `:before` to contain the top-margins of child elements.
+//
+// Source: http://nicolasgallagher.com/micro-clearfix-hack/
+
+.clearfix() {
+  &:before,
+  &:after {
+    content: " "; // 1
+    display: table; // 2
+  }
+  &:after {
+    clear: both;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/forms.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/forms.less
new file mode 100644
index 0000000000000000000000000000000000000000..6f55ed967082caf4ef515f88c9d591f95036a470
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/forms.less
@@ -0,0 +1,85 @@
+// Form validation states
+//
+// Used in forms.less to generate the form validation CSS for warnings, errors,
+// and successes.
+
+.form-control-validation(@text-color: #555; @border-color: #ccc; @background-color: #f5f5f5) {
+  // Color the label and help text
+  .help-block,
+  .control-label,
+  .radio,
+  .checkbox,
+  .radio-inline,
+  .checkbox-inline,
+  &.radio label,
+  &.checkbox label,
+  &.radio-inline label,
+  &.checkbox-inline label  {
+    color: @text-color;
+  }
+  // Set the border and box shadow on specific inputs to match
+  .form-control {
+    border-color: @border-color;
+    .box-shadow(inset 0 1px 1px rgba(0,0,0,.075)); // Redeclare so transitions work
+    &:focus {
+      border-color: darken(@border-color, 10%);
+      @shadow: inset 0 1px 1px rgba(0,0,0,.075), 0 0 6px lighten(@border-color, 20%);
+      .box-shadow(@shadow);
+    }
+  }
+  // Set validation states also for addons
+  .input-group-addon {
+    color: @text-color;
+    border-color: @border-color;
+    background-color: @background-color;
+  }
+  // Optional feedback icon
+  .form-control-feedback {
+    color: @text-color;
+  }
+}
+
+
+// Form control focus state
+//
+// Generate a customized focus state and for any input with the specified color,
+// which defaults to the `@input-border-focus` variable.
+//
+// We highly encourage you to not customize the default value, but instead use
+// this to tweak colors on an as-needed basis. This aesthetic change is based on
+// WebKit's default styles, but applicable to a wider range of browsers. Its
+// usability and accessibility should be taken into account with any change.
+//
+// Example usage: change the default blue border and shadow to white for better
+// contrast against a dark gray background.
+.form-control-focus(@color: @input-border-focus) {
+  @color-rgba: rgba(red(@color), green(@color), blue(@color), .6);
+  &:focus {
+    border-color: @color;
+    outline: 0;
+    .box-shadow(~"inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px @{color-rgba}");
+  }
+}
+
+// Form control sizing
+//
+// Relative text size, padding, and border-radii changes for form controls. For
+// horizontal sizing, wrap controls in the predefined grid classes. `<select>`
+// element gets special love because it's special, and that's a fact!
+.input-size(@input-height; @padding-vertical; @padding-horizontal; @font-size; @line-height; @border-radius) {
+  height: @input-height;
+  padding: @padding-vertical @padding-horizontal;
+  font-size: @font-size;
+  line-height: @line-height;
+  border-radius: @border-radius;
+
+  select& {
+    height: @input-height;
+    line-height: @input-height;
+  }
+
+  textarea&,
+  select[multiple]& {
+    height: auto;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/gradients.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/gradients.less
new file mode 100644
index 0000000000000000000000000000000000000000..0b88a89cc56a63effe45558845122b077de03979
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/gradients.less
@@ -0,0 +1,59 @@
+// Gradients
+
+#gradient {
+
+  // Horizontal gradient, from left to right
+  //
+  // Creates two color stops, start and end, by specifying a color and position for each color stop.
+  // Color stops are not available in IE9 and below.
+  .horizontal(@start-color: #555; @end-color: #333; @start-percent: 0%; @end-percent: 100%) {
+    background-image: -webkit-linear-gradient(left, @start-color @start-percent, @end-color @end-percent); // Safari 5.1-6, Chrome 10+
+    background-image: -o-linear-gradient(left, @start-color @start-percent, @end-color @end-percent); // Opera 12
+    background-image: linear-gradient(to right, @start-color @start-percent, @end-color @end-percent); // Standard, IE10, Firefox 16+, Opera 12.10+, Safari 7+, Chrome 26+
+    background-repeat: repeat-x;
+    filter: e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d', endColorstr='%d', GradientType=1)",argb(@start-color),argb(@end-color))); // IE9 and down
+  }
+
+  // Vertical gradient, from top to bottom
+  //
+  // Creates two color stops, start and end, by specifying a color and position for each color stop.
+  // Color stops are not available in IE9 and below.
+  .vertical(@start-color: #555; @end-color: #333; @start-percent: 0%; @end-percent: 100%) {
+    background-image: -webkit-linear-gradient(top, @start-color @start-percent, @end-color @end-percent);  // Safari 5.1-6, Chrome 10+
+    background-image: -o-linear-gradient(top, @start-color @start-percent, @end-color @end-percent);  // Opera 12
+    background-image: linear-gradient(to bottom, @start-color @start-percent, @end-color @end-percent); // Standard, IE10, Firefox 16+, Opera 12.10+, Safari 7+, Chrome 26+
+    background-repeat: repeat-x;
+    filter: e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d', endColorstr='%d', GradientType=0)",argb(@start-color),argb(@end-color))); // IE9 and down
+  }
+
+  .directional(@start-color: #555; @end-color: #333; @deg: 45deg) {
+    background-repeat: repeat-x;
+    background-image: -webkit-linear-gradient(@deg, @start-color, @end-color); // Safari 5.1-6, Chrome 10+
+    background-image: -o-linear-gradient(@deg, @start-color, @end-color); // Opera 12
+    background-image: linear-gradient(@deg, @start-color, @end-color); // Standard, IE10, Firefox 16+, Opera 12.10+, Safari 7+, Chrome 26+
+  }
+  .horizontal-three-colors(@start-color: #00b3ee; @mid-color: #7a43b6; @color-stop: 50%; @end-color: #c3325f) {
+    background-image: -webkit-linear-gradient(left, @start-color, @mid-color @color-stop, @end-color);
+    background-image: -o-linear-gradient(left, @start-color, @mid-color @color-stop, @end-color);
+    background-image: linear-gradient(to right, @start-color, @mid-color @color-stop, @end-color);
+    background-repeat: no-repeat;
+    filter: e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d', endColorstr='%d', GradientType=1)",argb(@start-color),argb(@end-color))); // IE9 and down, gets no color-stop at all for proper fallback
+  }
+  .vertical-three-colors(@start-color: #00b3ee; @mid-color: #7a43b6; @color-stop: 50%; @end-color: #c3325f) {
+    background-image: -webkit-linear-gradient(@start-color, @mid-color @color-stop, @end-color);
+    background-image: -o-linear-gradient(@start-color, @mid-color @color-stop, @end-color);
+    background-image: linear-gradient(@start-color, @mid-color @color-stop, @end-color);
+    background-repeat: no-repeat;
+    filter: e(%("progid:DXImageTransform.Microsoft.gradient(startColorstr='%d', endColorstr='%d', GradientType=0)",argb(@start-color),argb(@end-color))); // IE9 and down, gets no color-stop at all for proper fallback
+  }
+  .radial(@inner-color: #555; @outer-color: #333) {
+    background-image: -webkit-radial-gradient(circle, @inner-color, @outer-color);
+    background-image: radial-gradient(circle, @inner-color, @outer-color);
+    background-repeat: no-repeat;
+  }
+  .striped(@color: rgba(255,255,255,.15); @angle: 45deg) {
+    background-image: -webkit-linear-gradient(@angle, @color 25%, transparent 25%, transparent 50%, @color 50%, @color 75%, transparent 75%, transparent);
+    background-image: -o-linear-gradient(@angle, @color 25%, transparent 25%, transparent 50%, @color 50%, @color 75%, transparent 75%, transparent);
+    background-image: linear-gradient(@angle, @color 25%, transparent 25%, transparent 50%, @color 50%, @color 75%, transparent 75%, transparent);
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/grid-framework.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/grid-framework.less
new file mode 100644
index 0000000000000000000000000000000000000000..f3b3929d6d0e55b9fffe1c2dbde5747b21eb0014
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/grid-framework.less
@@ -0,0 +1,91 @@
+// Framework grid generation
+//
+// Used only by Bootstrap to generate the correct number of grid classes given
+// any value of `@grid-columns`.
+
+.make-grid-columns() {
+  // Common styles for all sizes of grid columns, widths 1-12
+  .col(@index) { // initial
+    @item: ~".col-xs-@{index}, .col-sm-@{index}, .col-md-@{index}, .col-lg-@{index}";
+    .col((@index + 1), @item);
+  }
+  .col(@index, @list) when (@index =< @grid-columns) { // general; "=<" isn't a typo
+    @item: ~".col-xs-@{index}, .col-sm-@{index}, .col-md-@{index}, .col-lg-@{index}";
+    .col((@index + 1), ~"@{list}, @{item}");
+  }
+  .col(@index, @list) when (@index > @grid-columns) { // terminal
+    @{list} {
+      position: relative;
+      // Prevent columns from collapsing when empty
+      min-height: 1px;
+      // Inner gutter via padding
+      padding-left:  (@grid-gutter-width / 2);
+      padding-right: (@grid-gutter-width / 2);
+    }
+  }
+  .col(1); // kickstart it
+}
+
+.float-grid-columns(@class) {
+  .col(@index) { // initial
+    @item: ~".col-@{class}-@{index}";
+    .col((@index + 1), @item);
+  }
+  .col(@index, @list) when (@index =< @grid-columns) { // general
+    @item: ~".col-@{class}-@{index}";
+    .col((@index + 1), ~"@{list}, @{item}");
+  }
+  .col(@index, @list) when (@index > @grid-columns) { // terminal
+    @{list} {
+      float: left;
+    }
+  }
+  .col(1); // kickstart it
+}
+
+.calc-grid-column(@index, @class, @type) when (@type = width) and (@index > 0) {
+  .col-@{class}-@{index} {
+    width: percentage((@index / @grid-columns));
+  }
+}
+.calc-grid-column(@index, @class, @type) when (@type = push) and (@index > 0) {
+  .col-@{class}-push-@{index} {
+    left: percentage((@index / @grid-columns));
+  }
+}
+.calc-grid-column(@index, @class, @type) when (@type = push) and (@index = 0) {
+  .col-@{class}-push-0 {
+    left: auto;
+  }
+}
+.calc-grid-column(@index, @class, @type) when (@type = pull) and (@index > 0) {
+  .col-@{class}-pull-@{index} {
+    right: percentage((@index / @grid-columns));
+  }
+}
+.calc-grid-column(@index, @class, @type) when (@type = pull) and (@index = 0) {
+  .col-@{class}-pull-0 {
+    right: auto;
+  }
+}
+.calc-grid-column(@index, @class, @type) when (@type = offset) {
+  .col-@{class}-offset-@{index} {
+    margin-left: percentage((@index / @grid-columns));
+  }
+}
+
+// Basic looping in LESS
+.loop-grid-columns(@index, @class, @type) when (@index >= 0) {
+  .calc-grid-column(@index, @class, @type);
+  // next iteration
+  .loop-grid-columns((@index - 1), @class, @type);
+}
+
+// Create grid for specific class
+.make-grid(@class) {
+  .float-grid-columns(@class);
+  .loop-grid-columns(@grid-columns, @class, width);
+  .loop-grid-columns(@grid-columns, @class, pull);
+  .loop-grid-columns(@grid-columns, @class, push);
+  .loop-grid-columns(@grid-columns, @class, offset);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/grid.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/grid.less
new file mode 100644
index 0000000000000000000000000000000000000000..cae5eaff924fed1e4d5978952d9c8490faf8500c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/grid.less
@@ -0,0 +1,122 @@
+// Grid system
+//
+// Generate semantic grid columns with these mixins.
+
+// Centered container element
+.container-fixed(@gutter: @grid-gutter-width) {
+  margin-right: auto;
+  margin-left: auto;
+  padding-left:  (@gutter / 2);
+  padding-right: (@gutter / 2);
+  &:extend(.clearfix all);
+}
+
+// Creates a wrapper for a series of columns
+.make-row(@gutter: @grid-gutter-width) {
+  margin-left:  (@gutter / -2);
+  margin-right: (@gutter / -2);
+  &:extend(.clearfix all);
+}
+
+// Generate the extra small columns
+.make-xs-column(@columns; @gutter: @grid-gutter-width) {
+  position: relative;
+  float: left;
+  width: percentage((@columns / @grid-columns));
+  min-height: 1px;
+  padding-left:  (@gutter / 2);
+  padding-right: (@gutter / 2);
+}
+.make-xs-column-offset(@columns) {
+  margin-left: percentage((@columns / @grid-columns));
+}
+.make-xs-column-push(@columns) {
+  left: percentage((@columns / @grid-columns));
+}
+.make-xs-column-pull(@columns) {
+  right: percentage((@columns / @grid-columns));
+}
+
+// Generate the small columns
+.make-sm-column(@columns; @gutter: @grid-gutter-width) {
+  position: relative;
+  min-height: 1px;
+  padding-left:  (@gutter / 2);
+  padding-right: (@gutter / 2);
+
+  @media (min-width: @screen-sm-min) {
+    float: left;
+    width: percentage((@columns / @grid-columns));
+  }
+}
+.make-sm-column-offset(@columns) {
+  @media (min-width: @screen-sm-min) {
+    margin-left: percentage((@columns / @grid-columns));
+  }
+}
+.make-sm-column-push(@columns) {
+  @media (min-width: @screen-sm-min) {
+    left: percentage((@columns / @grid-columns));
+  }
+}
+.make-sm-column-pull(@columns) {
+  @media (min-width: @screen-sm-min) {
+    right: percentage((@columns / @grid-columns));
+  }
+}
+
+// Generate the medium columns
+.make-md-column(@columns; @gutter: @grid-gutter-width) {
+  position: relative;
+  min-height: 1px;
+  padding-left:  (@gutter / 2);
+  padding-right: (@gutter / 2);
+
+  @media (min-width: @screen-md-min) {
+    float: left;
+    width: percentage((@columns / @grid-columns));
+  }
+}
+.make-md-column-offset(@columns) {
+  @media (min-width: @screen-md-min) {
+    margin-left: percentage((@columns / @grid-columns));
+  }
+}
+.make-md-column-push(@columns) {
+  @media (min-width: @screen-md-min) {
+    left: percentage((@columns / @grid-columns));
+  }
+}
+.make-md-column-pull(@columns) {
+  @media (min-width: @screen-md-min) {
+    right: percentage((@columns / @grid-columns));
+  }
+}
+
+// Generate the large columns
+.make-lg-column(@columns; @gutter: @grid-gutter-width) {
+  position: relative;
+  min-height: 1px;
+  padding-left:  (@gutter / 2);
+  padding-right: (@gutter / 2);
+
+  @media (min-width: @screen-lg-min) {
+    float: left;
+    width: percentage((@columns / @grid-columns));
+  }
+}
+.make-lg-column-offset(@columns) {
+  @media (min-width: @screen-lg-min) {
+    margin-left: percentage((@columns / @grid-columns));
+  }
+}
+.make-lg-column-push(@columns) {
+  @media (min-width: @screen-lg-min) {
+    left: percentage((@columns / @grid-columns));
+  }
+}
+.make-lg-column-pull(@columns) {
+  @media (min-width: @screen-lg-min) {
+    right: percentage((@columns / @grid-columns));
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/hide-text.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/hide-text.less
new file mode 100644
index 0000000000000000000000000000000000000000..c2315e572f83385f10407cae46253526e0bb3dd7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/hide-text.less
@@ -0,0 +1,21 @@
+// CSS image replacement
+//
+// Heads up! v3 launched with with only `.hide-text()`, but per our pattern for
+// mixins being reused as classes with the same name, this doesn't hold up. As
+// of v3.0.1 we have added `.text-hide()` and deprecated `.hide-text()`.
+//
+// Source: https://github.com/h5bp/html5-boilerplate/commit/aa0396eae757
+
+// Deprecated as of v3.0.1 (will be removed in v4)
+.hide-text() {
+  font: ~"0/0" a;
+  color: transparent;
+  text-shadow: none;
+  background-color: transparent;
+  border: 0;
+}
+
+// New mixin to use as of v3.0.1
+.text-hide() {
+  .hide-text();
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/image.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/image.less
new file mode 100644
index 0000000000000000000000000000000000000000..f233cb3e199f21ac194212e10ebb1e12feb0682b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/image.less
@@ -0,0 +1,33 @@
+// Image Mixins
+// - Responsive image
+// - Retina image
+
+
+// Responsive image
+//
+// Keep images from scaling beyond the width of their parents.
+.img-responsive(@display: block) {
+  display: @display;
+  max-width: 100%; // Part 1: Set a maximum relative to the parent
+  height: auto; // Part 2: Scale the height according to the width, otherwise you get stretching
+}
+
+
+// Retina image
+//
+// Short retina mixin for setting background-image and -size. Note that the
+// spelling of `min--moz-device-pixel-ratio` is intentional.
+.img-retina(@file-1x; @file-2x; @width-1x; @height-1x) {
+  background-image: url("@{file-1x}");
+
+  @media
+  only screen and (-webkit-min-device-pixel-ratio: 2),
+  only screen and (   min--moz-device-pixel-ratio: 2),
+  only screen and (     -o-min-device-pixel-ratio: 2/1),
+  only screen and (        min-device-pixel-ratio: 2),
+  only screen and (                min-resolution: 192dpi),
+  only screen and (                min-resolution: 2dppx) {
+    background-image: url("@{file-2x}");
+    background-size: @width-1x @height-1x;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/labels.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/labels.less
new file mode 100644
index 0000000000000000000000000000000000000000..9f7a67ee3d08a03ad10277d703805d315cd43d54
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/labels.less
@@ -0,0 +1,12 @@
+// Labels
+
+.label-variant(@color) {
+  background-color: @color;
+
+  &[href] {
+    &:hover,
+    &:focus {
+      background-color: darken(@color, 10%);
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/list-group.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/list-group.less
new file mode 100644
index 0000000000000000000000000000000000000000..8b5b065cb84cec3364d028e046b3fd24878f20b1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/list-group.less
@@ -0,0 +1,29 @@
+// List Groups
+
+.list-group-item-variant(@state; @background; @color) {
+  .list-group-item-@{state} {
+    color: @color;
+    background-color: @background;
+
+    a& {
+      color: @color;
+
+      .list-group-item-heading {
+        color: inherit;
+      }
+
+      &:hover,
+      &:focus {
+        color: @color;
+        background-color: darken(@background, 5%);
+      }
+      &.active,
+      &.active:hover,
+      &.active:focus {
+        color: #fff;
+        background-color: @color;
+        border-color: @color;
+      }
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/nav-divider.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/nav-divider.less
new file mode 100644
index 0000000000000000000000000000000000000000..feb1e9ed0dad8d0db00ebb93b175591a88abf707
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/nav-divider.less
@@ -0,0 +1,10 @@
+// Horizontal dividers
+//
+// Dividers (basically an hr) within dropdowns and nav lists
+
+.nav-divider(@color: #e5e5e5) {
+  height: 1px;
+  margin: ((@line-height-computed / 2) - 1) 0;
+  overflow: hidden;
+  background-color: @color;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/nav-vertical-align.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/nav-vertical-align.less
new file mode 100644
index 0000000000000000000000000000000000000000..d458c78613e6dc082141783ef45d56a5a7d601c3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/nav-vertical-align.less
@@ -0,0 +1,9 @@
+// Navbar vertical align
+//
+// Vertically center elements in the navbar.
+// Example: an element has a height of 30px, so write out `.navbar-vertical-align(30px);` to calculate the appropriate top margin.
+
+.navbar-vertical-align(@element-height) {
+  margin-top: ((@navbar-height - @element-height) / 2);
+  margin-bottom: ((@navbar-height - @element-height) / 2);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/opacity.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/opacity.less
new file mode 100644
index 0000000000000000000000000000000000000000..33ed25ce6763de7f8ae195628c1eb168379d8435
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/opacity.less
@@ -0,0 +1,8 @@
+// Opacity
+
+.opacity(@opacity) {
+  opacity: @opacity;
+  // IE8 filter
+  @opacity-ie: (@opacity * 100);
+  filter: ~"alpha(opacity=@{opacity-ie})";
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/pagination.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/pagination.less
new file mode 100644
index 0000000000000000000000000000000000000000..7deb505d25f09cfc939beff303c0f6d52e83a9a2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/pagination.less
@@ -0,0 +1,23 @@
+// Pagination
+
+.pagination-size(@padding-vertical; @padding-horizontal; @font-size; @border-radius) {
+  > li {
+    > a,
+    > span {
+      padding: @padding-vertical @padding-horizontal;
+      font-size: @font-size;
+    }
+    &:first-child {
+      > a,
+      > span {
+        .border-left-radius(@border-radius);
+      }
+    }
+    &:last-child {
+      > a,
+      > span {
+        .border-right-radius(@border-radius);
+      }
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/panels.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/panels.less
new file mode 100644
index 0000000000000000000000000000000000000000..49ee10d4ad39de45e0983d01cbbc50949a1dac2e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/panels.less
@@ -0,0 +1,24 @@
+// Panels
+
+.panel-variant(@border; @heading-text-color; @heading-bg-color; @heading-border) {
+  border-color: @border;
+
+  & > .panel-heading {
+    color: @heading-text-color;
+    background-color: @heading-bg-color;
+    border-color: @heading-border;
+
+    + .panel-collapse > .panel-body {
+      border-top-color: @border;
+    }
+    .badge {
+      color: @heading-bg-color;
+      background-color: @heading-text-color;
+    }
+  }
+  & > .panel-footer {
+    + .panel-collapse > .panel-body {
+      border-bottom-color: @border;
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/progress-bar.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/progress-bar.less
new file mode 100644
index 0000000000000000000000000000000000000000..f07996a34dbc19a1acc1c024a2410eb2b1b25271
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/progress-bar.less
@@ -0,0 +1,10 @@
+// Progress bars
+
+.progress-bar-variant(@color) {
+  background-color: @color;
+
+  // Deprecated parent class requirement as of v3.2.0
+  .progress-striped & {
+    #gradient > .striped();
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/reset-filter.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/reset-filter.less
new file mode 100644
index 0000000000000000000000000000000000000000..68cdb5e18602af3ab8e3ddba57a06045ef1c65bb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/reset-filter.less
@@ -0,0 +1,8 @@
+// Reset filters for IE
+//
+// When you need to remove a gradient background, do not forget to use this to reset
+// the IE filter for IE9 and below.
+
+.reset-filter() {
+  filter: e(%("progid:DXImageTransform.Microsoft.gradient(enabled = false)"));
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/resize.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/resize.less
new file mode 100644
index 0000000000000000000000000000000000000000..3acd3afdbacbb7f642e04f7ff434c18107faad69
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/resize.less
@@ -0,0 +1,6 @@
+// Resize anything
+
+.resizable(@direction) {
+  resize: @direction; // Options: horizontal, vertical, both
+  overflow: auto; // Per CSS3 UI, `resize` only applies when `overflow` isn't `visible`
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/responsive-visibility.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/responsive-visibility.less
new file mode 100644
index 0000000000000000000000000000000000000000..f7951c3d75cbe6bb72ea5f7493920611a2800797
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/responsive-visibility.less
@@ -0,0 +1,15 @@
+// Responsive utilities
+
+//
+// More easily include all the states for responsive-utilities.less.
+.responsive-visibility() {
+  display: block !important;
+  table&  { display: table; }
+  tr&     { display: table-row !important; }
+  th&,
+  td&     { display: table-cell !important; }
+}
+
+.responsive-invisibility() {
+  display: none !important;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/size.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/size.less
new file mode 100644
index 0000000000000000000000000000000000000000..a8be65089606863ad878173e951b62fb387daf52
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/size.less
@@ -0,0 +1,10 @@
+// Sizing shortcuts
+
+.size(@width; @height) {
+  width: @width;
+  height: @height;
+}
+
+.square(@size) {
+  .size(@size; @size);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/tab-focus.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/tab-focus.less
new file mode 100644
index 0000000000000000000000000000000000000000..1f1f05ab054412684539a94423c097d6cdadd8ba
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/tab-focus.less
@@ -0,0 +1,9 @@
+// WebKit-style focus
+
+.tab-focus() {
+  // Default
+  outline: thin dotted;
+  // WebKit
+  outline: 5px auto -webkit-focus-ring-color;
+  outline-offset: -2px;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/table-row.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/table-row.less
new file mode 100644
index 0000000000000000000000000000000000000000..0f287f1a8bdf51607e91d0c8aa6a5be51d6df36e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/table-row.less
@@ -0,0 +1,28 @@
+// Tables
+
+.table-row-variant(@state; @background) {
+  // Exact selectors below required to override `.table-striped` and prevent
+  // inheritance to nested tables.
+  .table > thead > tr,
+  .table > tbody > tr,
+  .table > tfoot > tr {
+    > td.@{state},
+    > th.@{state},
+    &.@{state} > td,
+    &.@{state} > th {
+      background-color: @background;
+    }
+  }
+
+  // Hover states for `.table-hover`
+  // Note: this is not available for cells or rows within `thead` or `tfoot`.
+  .table-hover > tbody > tr {
+    > td.@{state}:hover,
+    > th.@{state}:hover,
+    &.@{state}:hover > td,
+    &:hover > .@{state},
+    &.@{state}:hover > th {
+      background-color: darken(@background, 5%);
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/text-emphasis.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/text-emphasis.less
new file mode 100644
index 0000000000000000000000000000000000000000..0868ef9f2caaf05c2fdbe9f3f3da1616fe221080
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/text-emphasis.less
@@ -0,0 +1,8 @@
+// Typography
+
+.text-emphasis-variant(@color) {
+  color: @color;
+  a&:hover {
+    color: darken(@color, 10%);
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/text-overflow.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/text-overflow.less
new file mode 100644
index 0000000000000000000000000000000000000000..c11ad2fb7471dd29ae781f1aefdfb8bb5e4a7d6c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/text-overflow.less
@@ -0,0 +1,8 @@
+// Text overflow
+// Requires inline-block or block for proper styling
+
+.text-overflow() {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/vendor-prefixes.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/vendor-prefixes.less
new file mode 100644
index 0000000000000000000000000000000000000000..afd3331c31da856f226b354916e21ebad9d3311a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/mixins/vendor-prefixes.less
@@ -0,0 +1,227 @@
+// Vendor Prefixes
+//
+// All vendor mixins are deprecated as of v3.2.0 due to the introduction of
+// Autoprefixer in our Gruntfile. They will be removed in v4.
+
+// - Animations
+// - Backface visibility
+// - Box shadow
+// - Box sizing
+// - Content columns
+// - Hyphens
+// - Placeholder text
+// - Transformations
+// - Transitions
+// - User Select
+
+
+// Animations
+.animation(@animation) {
+  -webkit-animation: @animation;
+       -o-animation: @animation;
+          animation: @animation;
+}
+.animation-name(@name) {
+  -webkit-animation-name: @name;
+          animation-name: @name;
+}
+.animation-duration(@duration) {
+  -webkit-animation-duration: @duration;
+          animation-duration: @duration;
+}
+.animation-timing-function(@timing-function) {
+  -webkit-animation-timing-function: @timing-function;
+          animation-timing-function: @timing-function;
+}
+.animation-delay(@delay) {
+  -webkit-animation-delay: @delay;
+          animation-delay: @delay;
+}
+.animation-iteration-count(@iteration-count) {
+  -webkit-animation-iteration-count: @iteration-count;
+          animation-iteration-count: @iteration-count;
+}
+.animation-direction(@direction) {
+  -webkit-animation-direction: @direction;
+          animation-direction: @direction;
+}
+.animation-fill-mode(@fill-mode) {
+  -webkit-animation-fill-mode: @fill-mode;
+          animation-fill-mode: @fill-mode;
+}
+
+// Backface visibility
+// Prevent browsers from flickering when using CSS 3D transforms.
+// Default value is `visible`, but can be changed to `hidden`
+
+.backface-visibility(@visibility){
+  -webkit-backface-visibility: @visibility;
+     -moz-backface-visibility: @visibility;
+          backface-visibility: @visibility;
+}
+
+// Drop shadows
+//
+// Note: Deprecated `.box-shadow()` as of v3.1.0 since all of Bootstrap's
+// supported browsers that have box shadow capabilities now support it.
+
+.box-shadow(@shadow) {
+  -webkit-box-shadow: @shadow; // iOS <4.3 & Android <4.1
+          box-shadow: @shadow;
+}
+
+// Box sizing
+.box-sizing(@boxmodel) {
+  -webkit-box-sizing: @boxmodel;
+     -moz-box-sizing: @boxmodel;
+          box-sizing: @boxmodel;
+}
+
+// CSS3 Content Columns
+.content-columns(@column-count; @column-gap: @grid-gutter-width) {
+  -webkit-column-count: @column-count;
+     -moz-column-count: @column-count;
+          column-count: @column-count;
+  -webkit-column-gap: @column-gap;
+     -moz-column-gap: @column-gap;
+          column-gap: @column-gap;
+}
+
+// Optional hyphenation
+.hyphens(@mode: auto) {
+  word-wrap: break-word;
+  -webkit-hyphens: @mode;
+     -moz-hyphens: @mode;
+      -ms-hyphens: @mode; // IE10+
+       -o-hyphens: @mode;
+          hyphens: @mode;
+}
+
+// Placeholder text
+.placeholder(@color: @input-color-placeholder) {
+  // Firefox
+  &::-moz-placeholder {
+    color: @color;
+    opacity: 1; // Override Firefox's unusual default opacity; see https://github.com/twbs/bootstrap/pull/11526
+  }
+  &:-ms-input-placeholder { color: @color; } // Internet Explorer 10+
+  &::-webkit-input-placeholder  { color: @color; } // Safari and Chrome
+}
+
+// Transformations
+.scale(@ratio) {
+  -webkit-transform: scale(@ratio);
+      -ms-transform: scale(@ratio); // IE9 only
+       -o-transform: scale(@ratio);
+          transform: scale(@ratio);
+}
+.scale(@ratioX; @ratioY) {
+  -webkit-transform: scale(@ratioX, @ratioY);
+      -ms-transform: scale(@ratioX, @ratioY); // IE9 only
+       -o-transform: scale(@ratioX, @ratioY);
+          transform: scale(@ratioX, @ratioY);
+}
+.scaleX(@ratio) {
+  -webkit-transform: scaleX(@ratio);
+      -ms-transform: scaleX(@ratio); // IE9 only
+       -o-transform: scaleX(@ratio);
+          transform: scaleX(@ratio);
+}
+.scaleY(@ratio) {
+  -webkit-transform: scaleY(@ratio);
+      -ms-transform: scaleY(@ratio); // IE9 only
+       -o-transform: scaleY(@ratio);
+          transform: scaleY(@ratio);
+}
+.skew(@x; @y) {
+  -webkit-transform: skewX(@x) skewY(@y);
+      -ms-transform: skewX(@x) skewY(@y); // See https://github.com/twbs/bootstrap/issues/4885; IE9+
+       -o-transform: skewX(@x) skewY(@y);
+          transform: skewX(@x) skewY(@y);
+}
+.translate(@x; @y) {
+  -webkit-transform: translate(@x, @y);
+      -ms-transform: translate(@x, @y); // IE9 only
+       -o-transform: translate(@x, @y);
+          transform: translate(@x, @y);
+}
+.translate3d(@x; @y; @z) {
+  -webkit-transform: translate3d(@x, @y, @z);
+          transform: translate3d(@x, @y, @z);
+}
+.rotate(@degrees) {
+  -webkit-transform: rotate(@degrees);
+      -ms-transform: rotate(@degrees); // IE9 only
+       -o-transform: rotate(@degrees);
+          transform: rotate(@degrees);
+}
+.rotateX(@degrees) {
+  -webkit-transform: rotateX(@degrees);
+      -ms-transform: rotateX(@degrees); // IE9 only
+       -o-transform: rotateX(@degrees);
+          transform: rotateX(@degrees);
+}
+.rotateY(@degrees) {
+  -webkit-transform: rotateY(@degrees);
+      -ms-transform: rotateY(@degrees); // IE9 only
+       -o-transform: rotateY(@degrees);
+          transform: rotateY(@degrees);
+}
+.perspective(@perspective) {
+  -webkit-perspective: @perspective;
+     -moz-perspective: @perspective;
+          perspective: @perspective;
+}
+.perspective-origin(@perspective) {
+  -webkit-perspective-origin: @perspective;
+     -moz-perspective-origin: @perspective;
+          perspective-origin: @perspective;
+}
+.transform-origin(@origin) {
+  -webkit-transform-origin: @origin;
+     -moz-transform-origin: @origin;
+      -ms-transform-origin: @origin; // IE9 only
+          transform-origin: @origin;
+}
+
+
+// Transitions
+
+.transition(@transition) {
+  -webkit-transition: @transition;
+       -o-transition: @transition;
+          transition: @transition;
+}
+.transition-property(@transition-property) {
+  -webkit-transition-property: @transition-property;
+          transition-property: @transition-property;
+}
+.transition-delay(@transition-delay) {
+  -webkit-transition-delay: @transition-delay;
+          transition-delay: @transition-delay;
+}
+.transition-duration(@transition-duration) {
+  -webkit-transition-duration: @transition-duration;
+          transition-duration: @transition-duration;
+}
+.transition-timing-function(@timing-function) {
+  -webkit-transition-timing-function: @timing-function;
+          transition-timing-function: @timing-function;
+}
+.transition-transform(@transition) {
+  -webkit-transition: -webkit-transform @transition;
+     -moz-transition: -moz-transform @transition;
+       -o-transition: -o-transform @transition;
+          transition: transform @transition;
+}
+
+
+// User select
+// For selecting text on the page
+
+.user-select(@select) {
+  -webkit-user-select: @select;
+     -moz-user-select: @select;
+      -ms-user-select: @select; // IE10+
+          user-select: @select;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/modals.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/modals.less
new file mode 100644
index 0000000000000000000000000000000000000000..1de622050e5ae83742ed1cfa93751c8a39377de2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/modals.less
@@ -0,0 +1,150 @@
+//
+// Modals
+// --------------------------------------------------
+
+// .modal-open      - body class for killing the scroll
+// .modal           - container to scroll within
+// .modal-dialog    - positioning shell for the actual modal
+// .modal-content   - actual modal w/ bg and corners and shit
+
+// Kill the scroll on the body
+.modal-open {
+  overflow: hidden;
+}
+
+// Container that the modal scrolls within
+.modal {
+  display: none;
+  overflow: hidden;
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: @zindex-modal;
+  -webkit-overflow-scrolling: touch;
+
+  // Prevent Chrome on Windows from adding a focus outline. For details, see
+  // https://github.com/twbs/bootstrap/pull/10951.
+  outline: 0;
+
+  // When fading in the modal, animate it to slide down
+  &.fade .modal-dialog {
+    .translate(0, -25%);
+    .transition-transform(~"0.3s ease-out");
+  }
+  &.in .modal-dialog { .translate(0, 0) }
+}
+.modal-open .modal {
+  overflow-x: hidden;
+  overflow-y: auto;
+}
+
+// Shell div to position the modal with bottom padding
+.modal-dialog {
+  position: relative;
+  width: auto;
+  margin: 10px;
+}
+
+// Actual modal
+.modal-content {
+  position: relative;
+  background-color: @modal-content-bg;
+  border: 1px solid @modal-content-fallback-border-color; //old browsers fallback (ie8 etc)
+  border: 1px solid @modal-content-border-color;
+  border-radius: @border-radius-large;
+  .box-shadow(0 3px 9px rgba(0,0,0,.5));
+  background-clip: padding-box;
+  // Remove focus outline from opened modal
+  outline: 0;
+}
+
+// Modal background
+.modal-backdrop {
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  z-index: @zindex-modal-background;
+  background-color: @modal-backdrop-bg;
+  // Fade for backdrop
+  &.fade { .opacity(0); }
+  &.in { .opacity(@modal-backdrop-opacity); }
+}
+
+// Modal header
+// Top section of the modal w/ title and dismiss
+.modal-header {
+  padding: @modal-title-padding;
+  border-bottom: 1px solid @modal-header-border-color;
+  min-height: (@modal-title-padding + @modal-title-line-height);
+}
+// Close icon
+.modal-header .close {
+  margin-top: -2px;
+}
+
+// Title text within header
+.modal-title {
+  margin: 0;
+  line-height: @modal-title-line-height;
+}
+
+// Modal body
+// Where all modal content resides (sibling of .modal-header and .modal-footer)
+.modal-body {
+  position: relative;
+  padding: @modal-inner-padding;
+}
+
+// Footer (for actions)
+.modal-footer {
+  padding: @modal-inner-padding;
+  text-align: right; // right align buttons
+  border-top: 1px solid @modal-footer-border-color;
+  &:extend(.clearfix all); // clear it in case folks use .pull-* classes on buttons
+
+  // Properly space out buttons
+  .btn + .btn {
+    margin-left: 5px;
+    margin-bottom: 0; // account for input[type="submit"] which gets the bottom margin like all other inputs
+  }
+  // but override that for button groups
+  .btn-group .btn + .btn {
+    margin-left: -1px;
+  }
+  // and override it for block buttons as well
+  .btn-block + .btn-block {
+    margin-left: 0;
+  }
+}
+
+// Measure scrollbar width for padding body during modal show/hide
+.modal-scrollbar-measure {
+  position: absolute;
+  top: -9999px;
+  width: 50px;
+  height: 50px;
+  overflow: scroll;
+}
+
+// Scale up the modal
+@media (min-width: @screen-sm-min) {
+  // Automatically set modal's width for larger viewports
+  .modal-dialog {
+    width: @modal-md;
+    margin: 30px auto;
+  }
+  .modal-content {
+    .box-shadow(0 5px 15px rgba(0,0,0,.5));
+  }
+
+  // Modal sizes
+  .modal-sm { width: @modal-sm; }
+}
+
+@media (min-width: @screen-md-min) {
+  .modal-lg { width: @modal-lg; }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/navbar.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/navbar.less
new file mode 100644
index 0000000000000000000000000000000000000000..03f4e2ac7a14bb0cce7e2a01d104ebcb2b0ff13b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/navbar.less
@@ -0,0 +1,660 @@
+//
+// Navbars
+// --------------------------------------------------
+
+
+// Wrapper and base class
+//
+// Provide a static navbar from which we expand to create full-width, fixed, and
+// other navbar variations.
+
+.navbar {
+  position: relative;
+  min-height: @navbar-height; // Ensure a navbar always shows (e.g., without a .navbar-brand in collapsed mode)
+  margin-bottom: @navbar-margin-bottom;
+  border: 1px solid transparent;
+
+  // Prevent floats from breaking the navbar
+  &:extend(.clearfix all);
+
+  @media (min-width: @grid-float-breakpoint) {
+    border-radius: @navbar-border-radius;
+  }
+}
+
+
+// Navbar heading
+//
+// Groups `.navbar-brand` and `.navbar-toggle` into a single component for easy
+// styling of responsive aspects.
+
+.navbar-header {
+  &:extend(.clearfix all);
+
+  @media (min-width: @grid-float-breakpoint) {
+    float: left;
+  }
+}
+
+
+// Navbar collapse (body)
+//
+// Group your navbar content into this for easy collapsing and expanding across
+// various device sizes. By default, this content is collapsed when <768px, but
+// will expand past that for a horizontal display.
+//
+// To start (on mobile devices) the navbar links, forms, and buttons are stacked
+// vertically and include a `max-height` to overflow in case you have too much
+// content for the user's viewport.
+
+.navbar-collapse {
+  overflow-x: visible;
+  padding-right: @navbar-padding-horizontal;
+  padding-left:  @navbar-padding-horizontal;
+  border-top: 1px solid transparent;
+  box-shadow: inset 0 1px 0 rgba(255,255,255,.1);
+  &:extend(.clearfix all);
+  -webkit-overflow-scrolling: touch;
+
+  &.in {
+    overflow-y: auto;
+  }
+
+  @media (min-width: @grid-float-breakpoint) {
+    width: auto;
+    border-top: 0;
+    box-shadow: none;
+
+    &.collapse {
+      display: block !important;
+      height: auto !important;
+      padding-bottom: 0; // Override default setting
+      overflow: visible !important;
+    }
+
+    &.in {
+      overflow-y: visible;
+    }
+
+    // Undo the collapse side padding for navbars with containers to ensure
+    // alignment of right-aligned contents.
+    .navbar-fixed-top &,
+    .navbar-static-top &,
+    .navbar-fixed-bottom & {
+      padding-left: 0;
+      padding-right: 0;
+    }
+  }
+}
+
+.navbar-fixed-top,
+.navbar-fixed-bottom {
+  .navbar-collapse {
+    max-height: @navbar-collapse-max-height;
+
+    @media (max-device-width: @screen-xs-min) and (orientation: landscape) {
+      max-height: 200px;
+    }
+  }
+}
+
+
+// Both navbar header and collapse
+//
+// When a container is present, change the behavior of the header and collapse.
+
+.tb-container,
+.container-fluid {
+  > .navbar-header,
+  > .navbar-collapse {
+    margin-right: -@navbar-padding-horizontal;
+    margin-left:  -@navbar-padding-horizontal;
+
+    @media (min-width: @grid-float-breakpoint) {
+      margin-right: 0;
+      margin-left:  0;
+    }
+  }
+}
+
+
+//
+// Navbar alignment options
+//
+// Display the navbar across the entirety of the page or fixed it to the top or
+// bottom of the page.
+
+// Static top (unfixed, but 100% wide) navbar
+.navbar-static-top {
+  z-index: @zindex-navbar;
+  border-width: 0 0 1px;
+
+  @media (min-width: @grid-float-breakpoint) {
+    border-radius: 0;
+  }
+}
+
+// Fix the top/bottom navbars when screen real estate supports it
+.navbar-fixed-top,
+.navbar-fixed-bottom {
+  position: fixed;
+  right: 0;
+  left: 0;
+  z-index: @zindex-navbar-fixed;
+
+  // Undo the rounded corners
+  @media (min-width: @grid-float-breakpoint) {
+    border-radius: 0;
+  }
+}
+.navbar-fixed-top {
+  top: 0;
+  border-width: 0 0 1px;
+}
+.navbar-fixed-bottom {
+  bottom: 0;
+  margin-bottom: 0; // override .navbar defaults
+  border-width: 1px 0 0;
+}
+
+
+// Brand/project name
+
+.navbar-brand {
+  float: left;
+  padding: @navbar-padding-vertical @navbar-padding-horizontal;
+  font-size: @font-size-large;
+  line-height: @line-height-computed;
+  height: @navbar-height;
+
+  &:hover,
+  &:focus {
+    text-decoration: none;
+  }
+
+  > img {
+    display: block;
+  }
+
+  @media (min-width: @grid-float-breakpoint) {
+    .navbar > .tb-container &,
+    .navbar > .container-fluid & {
+      margin-left: -@navbar-padding-horizontal;
+    }
+  }
+}
+
+
+// Navbar toggle
+//
+// Custom button for toggling the `.navbar-collapse`, powered by the collapse
+// JavaScript plugin.
+
+.navbar-toggle {
+  position: relative;
+  float: right;
+  margin-right: @navbar-padding-horizontal;
+  padding: 9px 10px;
+  .navbar-vertical-align(34px);
+  background-color: transparent;
+  background-image: none; // Reset unusual Firefox-on-Android default style; see https://github.com/necolas/normalize.css/issues/214
+  border: 1px solid transparent;
+  border-radius: @border-radius-base;
+
+  // We remove the `outline` here, but later compensate by attaching `:hover`
+  // styles to `:focus`.
+  &:focus {
+    outline: 0;
+  }
+
+  // Bars
+  .icon-bar {
+    display: block;
+    width: 22px;
+    height: 2px;
+    border-radius: 1px;
+  }
+  .icon-bar + .icon-bar {
+    margin-top: 4px;
+  }
+
+  @media (min-width: @grid-float-breakpoint) {
+    display: none;
+  }
+}
+
+
+// Navbar nav links
+//
+// Builds on top of the `.nav` components with its own modifier class to make
+// the nav the full height of the horizontal nav (above 768px).
+
+.navbar-nav {
+  margin: (@navbar-padding-vertical / 2) -@navbar-padding-horizontal;
+
+  > li > a {
+    padding-top:    10px;
+    padding-bottom: 10px;
+    line-height: @line-height-computed;
+  }
+
+  @media (max-width: @grid-float-breakpoint-max) {
+    // Dropdowns get custom display when collapsed
+    .open .dropdown-menu {
+      position: static;
+      float: none;
+      width: auto;
+      margin-top: 0;
+      background-color: transparent;
+      border: 0;
+      box-shadow: none;
+      > li > a,
+      .dropdown-header {
+        padding: 5px 15px 5px 25px;
+      }
+      > li > a {
+        line-height: @line-height-computed;
+        &:hover,
+        &:focus {
+          background-image: none;
+        }
+      }
+    }
+  }
+
+  // Uncollapse the nav
+  @media (min-width: @grid-float-breakpoint) {
+    float: left;
+    margin: 0;
+
+    > li {
+      float: left;
+      > a {
+        padding-top:    @navbar-padding-vertical;
+        padding-bottom: @navbar-padding-vertical;
+      }
+    }
+  }
+}
+
+
+// Navbar form
+//
+// Extension of the `.form-inline` with some extra flavor for optimum display in
+// our navbars.
+
+.navbar-form {
+  margin-left: -@navbar-padding-horizontal;
+  margin-right: -@navbar-padding-horizontal;
+  padding: 10px @navbar-padding-horizontal;
+  border-top: 1px solid transparent;
+  border-bottom: 1px solid transparent;
+  @shadow: inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.1);
+  .box-shadow(@shadow);
+
+  // Mixin behavior for optimum display
+  .form-inline();
+
+  .form-group {
+    @media (max-width: @grid-float-breakpoint-max) {
+      margin-bottom: 5px;
+
+      &:last-child {
+        margin-bottom: 0;
+      }
+    }
+  }
+
+  // Vertically center in expanded, horizontal navbar
+  .navbar-vertical-align(@input-height-base);
+
+  // Undo 100% width for pull classes
+  @media (min-width: @grid-float-breakpoint) {
+    width: auto;
+    border: 0;
+    margin-left: 0;
+    margin-right: 0;
+    padding-top: 0;
+    padding-bottom: 0;
+    .box-shadow(none);
+  }
+}
+
+
+// Dropdown menus
+
+// Menu position and menu carets
+.navbar-nav > li > .dropdown-menu {
+  margin-top: 0;
+  .border-top-radius(0);
+}
+// Menu position and menu caret support for dropups via extra dropup class
+.navbar-fixed-bottom .navbar-nav > li > .dropdown-menu {
+  margin-bottom: 0;
+  .border-top-radius(@navbar-border-radius);
+  .border-bottom-radius(0);
+}
+
+
+// Buttons in navbars
+//
+// Vertically center a button within a navbar (when *not* in a form).
+
+.navbar-btn {
+  .navbar-vertical-align(@input-height-base);
+
+  &.btn-sm {
+    .navbar-vertical-align(@input-height-small);
+  }
+  &.btn-xs {
+    .navbar-vertical-align(22);
+  }
+}
+
+
+// Text in navbars
+//
+// Add a class to make any element properly align itself vertically within the navbars.
+
+.navbar-text {
+  .navbar-vertical-align(@line-height-computed);
+
+  @media (min-width: @grid-float-breakpoint) {
+    float: left;
+    margin-left: @navbar-padding-horizontal;
+    margin-right: @navbar-padding-horizontal;
+  }
+}
+
+
+// Component alignment
+//
+// Repurpose the pull utilities as their own navbar utilities to avoid specificity
+// issues with parents and chaining. Only do this when the navbar is uncollapsed
+// though so that navbar contents properly stack and align in mobile.
+//
+// Declared after the navbar components to ensure more specificity on the margins.
+
+@media (min-width: @grid-float-breakpoint) {
+  .navbar-left  { .pull-left(); }
+  .navbar-right {
+    .pull-right();
+    margin-right: -@navbar-padding-horizontal;
+
+    ~ .navbar-right {
+      margin-right: 0;
+    }
+  }
+}
+
+
+// Alternate navbars
+// --------------------------------------------------
+
+// Default navbar
+.navbar-default {
+  background-color: @navbar-default-bg;
+  border-color: @navbar-default-border;
+
+  .navbar-brand {
+    color: @navbar-default-brand-color;
+    &:hover,
+    &:focus {
+      color: @navbar-default-brand-hover-color;
+      background-color: @navbar-default-brand-hover-bg;
+    }
+  }
+
+  .navbar-text {
+    color: @navbar-default-color;
+  }
+
+  .navbar-nav {
+    > li > a {
+      color: @navbar-default-link-color;
+
+      &:hover,
+      &:focus {
+        color: @navbar-default-link-hover-color;
+        background-color: @navbar-default-link-hover-bg;
+      }
+    }
+    > .active > a {
+      &,
+      &:hover,
+      &:focus {
+        color: @navbar-default-link-active-color;
+        background-color: @navbar-default-link-active-bg;
+      }
+    }
+    > .disabled > a {
+      &,
+      &:hover,
+      &:focus {
+        color: @navbar-default-link-disabled-color;
+        background-color: @navbar-default-link-disabled-bg;
+      }
+    }
+  }
+
+  .navbar-toggle {
+    border-color: @navbar-default-toggle-border-color;
+    &:hover,
+    &:focus {
+      background-color: @navbar-default-toggle-hover-bg;
+    }
+    .icon-bar {
+      background-color: @navbar-default-toggle-icon-bar-bg;
+    }
+  }
+
+  .navbar-collapse,
+  .navbar-form {
+    border-color: @navbar-default-border;
+  }
+
+  // Dropdown menu items
+  .navbar-nav {
+    // Remove background color from open dropdown
+    > .open > a {
+      &,
+      &:hover,
+      &:focus {
+        background-color: @navbar-default-link-active-bg;
+        color: @navbar-default-link-active-color;
+      }
+    }
+
+    @media (max-width: @grid-float-breakpoint-max) {
+      // Dropdowns get custom display when collapsed
+      .open .dropdown-menu {
+        > li > a {
+          color: @navbar-default-link-color;
+          &:hover,
+          &:focus {
+            color: @navbar-default-link-hover-color;
+            background-color: @navbar-default-link-hover-bg;
+          }
+        }
+        > .active > a {
+          &,
+          &:hover,
+          &:focus {
+            color: @navbar-default-link-active-color;
+            background-color: @navbar-default-link-active-bg;
+          }
+        }
+        > .disabled > a {
+          &,
+          &:hover,
+          &:focus {
+            color: @navbar-default-link-disabled-color;
+            background-color: @navbar-default-link-disabled-bg;
+          }
+        }
+      }
+    }
+  }
+
+
+  // Links in navbars
+  //
+  // Add a class to ensure links outside the navbar nav are colored correctly.
+
+  .navbar-link {
+    color: @navbar-default-link-color;
+    &:hover {
+      color: @navbar-default-link-hover-color;
+    }
+  }
+
+  .btn-link {
+    color: @navbar-default-link-color;
+    &:hover,
+    &:focus {
+      color: @navbar-default-link-hover-color;
+    }
+    &[disabled],
+    fieldset[disabled] & {
+      &:hover,
+      &:focus {
+        color: @navbar-default-link-disabled-color;
+      }
+    }
+  }
+}
+
+// Inverse navbar
+
+.navbar-inverse {
+  background-color: @navbar-inverse-bg;
+  border-color: @navbar-inverse-border;
+
+  .navbar-brand {
+    color: @navbar-inverse-brand-color;
+    &:hover,
+    &:focus {
+      color: @navbar-inverse-brand-hover-color;
+      background-color: @navbar-inverse-brand-hover-bg;
+    }
+  }
+
+  .navbar-text {
+    color: @navbar-inverse-color;
+  }
+
+  .navbar-nav {
+    > li > a {
+      color: @navbar-inverse-link-color;
+
+      &:hover,
+      &:focus {
+        color: @navbar-inverse-link-hover-color;
+        background-color: @navbar-inverse-link-hover-bg;
+      }
+    }
+    > .active > a {
+      &,
+      &:hover,
+      &:focus {
+        color: @navbar-inverse-link-active-color;
+        background-color: @navbar-inverse-link-active-bg;
+      }
+    }
+    > .disabled > a {
+      &,
+      &:hover,
+      &:focus {
+        color: @navbar-inverse-link-disabled-color;
+        background-color: @navbar-inverse-link-disabled-bg;
+      }
+    }
+  }
+
+  // Darken the responsive nav toggle
+  .navbar-toggle {
+    border-color: @navbar-inverse-toggle-border-color;
+    &:hover,
+    &:focus {
+      background-color: @navbar-inverse-toggle-hover-bg;
+    }
+    .icon-bar {
+      background-color: @navbar-inverse-toggle-icon-bar-bg;
+    }
+  }
+
+  .navbar-collapse,
+  .navbar-form {
+    border-color: darken(@navbar-inverse-bg, 7%);
+  }
+
+  // Dropdowns
+  .navbar-nav {
+    > .open > a {
+      &,
+      &:hover,
+      &:focus {
+        background-color: @navbar-inverse-link-active-bg;
+        color: @navbar-inverse-link-active-color;
+      }
+    }
+
+    @media (max-width: @grid-float-breakpoint-max) {
+      // Dropdowns get custom display
+      .open .dropdown-menu {
+        > .dropdown-header {
+          border-color: @navbar-inverse-border;
+        }
+        .divider {
+          background-color: @navbar-inverse-border;
+        }
+        > li > a {
+          color: @navbar-inverse-link-color;
+          &:hover,
+          &:focus {
+            color: @navbar-inverse-link-hover-color;
+            background-color: @navbar-inverse-link-hover-bg;
+          }
+        }
+        > .active > a {
+          &,
+          &:hover,
+          &:focus {
+            color: @navbar-inverse-link-active-color;
+            background-color: @navbar-inverse-link-active-bg;
+          }
+        }
+        > .disabled > a {
+          &,
+          &:hover,
+          &:focus {
+            color: @navbar-inverse-link-disabled-color;
+            background-color: @navbar-inverse-link-disabled-bg;
+          }
+        }
+      }
+    }
+  }
+
+  .navbar-link {
+    color: @navbar-inverse-link-color;
+    &:hover {
+      color: @navbar-inverse-link-hover-color;
+    }
+  }
+
+  .btn-link {
+    color: @navbar-inverse-link-color;
+    &:hover,
+    &:focus {
+      color: @navbar-inverse-link-hover-color;
+    }
+    &[disabled],
+    fieldset[disabled] & {
+      &:hover,
+      &:focus {
+        color: @navbar-inverse-link-disabled-color;
+      }
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/navs.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/navs.less
new file mode 100644
index 0000000000000000000000000000000000000000..a3d11b136211f3ee4a4d3beeb19c5ffba203b15b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/navs.less
@@ -0,0 +1,242 @@
+//
+// Navs
+// --------------------------------------------------
+
+
+// Base class
+// --------------------------------------------------
+
+.nav {
+  margin-bottom: 0;
+  padding-left: 0; // Override default ul/ol
+  list-style: none;
+  &:extend(.clearfix all);
+
+  > li {
+    position: relative;
+    display: block;
+
+    > a {
+      position: relative;
+      display: block;
+      padding: @nav-link-padding;
+      &:hover,
+      &:focus {
+        text-decoration: none;
+        background-color: @nav-link-hover-bg;
+      }
+    }
+
+    // Disabled state sets text to gray and nukes hover/tab effects
+    &.disabled > a {
+      color: @nav-disabled-link-color;
+
+      &:hover,
+      &:focus {
+        color: @nav-disabled-link-hover-color;
+        text-decoration: none;
+        background-color: transparent;
+        cursor: @cursor-disabled;
+      }
+    }
+  }
+
+  // Open dropdowns
+  .open > a {
+    &,
+    &:hover,
+    &:focus {
+      background-color: @nav-link-hover-bg;
+      border-color: @link-color;
+    }
+  }
+
+  // Nav dividers (deprecated with v3.0.1)
+  //
+  // This should have been removed in v3 with the dropping of `.nav-list`, but
+  // we missed it. We don't currently support this anywhere, but in the interest
+  // of maintaining backward compatibility in case you use it, it's deprecated.
+  .nav-divider {
+    .nav-divider();
+  }
+
+  // Prevent IE8 from misplacing imgs
+  //
+  // See https://github.com/h5bp/html5-boilerplate/issues/984#issuecomment-3985989
+  > li > a > img {
+    max-width: none;
+  }
+}
+
+
+// Tabs
+// -------------------------
+
+// Give the tabs something to sit on
+.nav-tabs {
+  border-bottom: 1px solid @nav-tabs-border-color;
+  > li {
+    float: left;
+    // Make the list-items overlay the bottom border
+    margin-bottom: -1px;
+
+    // Actual tabs (as links)
+    > a {
+      margin-right: 2px;
+      line-height: @line-height-base;
+      border: 1px solid transparent;
+      border-radius: @border-radius-base @border-radius-base 0 0;
+      &:hover {
+        border-color: @nav-tabs-link-hover-border-color @nav-tabs-link-hover-border-color @nav-tabs-border-color;
+      }
+    }
+
+    // Active state, and its :hover to override normal :hover
+    &.active > a {
+      &,
+      &:hover,
+      &:focus {
+        color: @nav-tabs-active-link-hover-color;
+        background-color: @nav-tabs-active-link-hover-bg;
+        border: 1px solid @nav-tabs-active-link-hover-border-color;
+        border-bottom-color: transparent;
+        cursor: default;
+      }
+    }
+  }
+  // pulling this in mainly for less shorthand
+  &.nav-justified {
+    .nav-justified();
+    .nav-tabs-justified();
+  }
+}
+
+
+// Pills
+// -------------------------
+.nav-pills {
+  > li {
+    float: left;
+
+    // Links rendered as pills
+    > a {
+      border-radius: @nav-pills-border-radius;
+    }
+    + li {
+      margin-left: 2px;
+    }
+
+    // Active state
+    &.active > a {
+      &,
+      &:hover,
+      &:focus {
+        color: @nav-pills-active-link-hover-color;
+        background-color: @nav-pills-active-link-hover-bg;
+      }
+    }
+  }
+}
+
+
+// Stacked pills
+.nav-stacked {
+  > li {
+    float: none;
+    + li {
+      margin-top: 2px;
+      margin-left: 0; // no need for this gap between nav items
+    }
+  }
+}
+
+
+// Nav variations
+// --------------------------------------------------
+
+// Justified nav links
+// -------------------------
+
+.nav-justified {
+  width: 100%;
+
+  > li {
+    float: none;
+    > a {
+      text-align: center;
+      margin-bottom: 5px;
+    }
+  }
+
+  > .dropdown .dropdown-menu {
+    top: auto;
+    left: auto;
+  }
+
+  @media (min-width: @screen-sm-min) {
+    > li {
+      display: table-cell;
+      width: 1%;
+      > a {
+        margin-bottom: 0;
+      }
+    }
+  }
+}
+
+// Move borders to anchors instead of bottom of list
+//
+// Mixin for adding on top the shared `.nav-justified` styles for our tabs
+.nav-tabs-justified {
+  border-bottom: 0;
+
+  > li > a {
+    // Override margin from .nav-tabs
+    margin-right: 0;
+    border-radius: @border-radius-base;
+  }
+
+  > .active > a,
+  > .active > a:hover,
+  > .active > a:focus {
+    border: 1px solid @nav-tabs-justified-link-border-color;
+  }
+
+  @media (min-width: @screen-sm-min) {
+    > li > a {
+      border-bottom: 1px solid @nav-tabs-justified-link-border-color;
+      border-radius: @border-radius-base @border-radius-base 0 0;
+    }
+    > .active > a,
+    > .active > a:hover,
+    > .active > a:focus {
+      border-bottom-color: @nav-tabs-justified-active-link-border-color;
+    }
+  }
+}
+
+
+// Tabbable tabs
+// -------------------------
+
+// Hide tabbable panes to start, show them when `.active`
+.tab-content {
+  > .tab-pane {
+    display: none;
+  }
+  > .active {
+    display: block;
+  }
+}
+
+
+// Dropdowns
+// -------------------------
+
+// Specific dropdowns
+.nav-tabs .dropdown-menu {
+  // make dropdown border overlap tab border
+  margin-top: -1px;
+  // Remove the top rounded corners here since there is a hard edge above the menu
+  .border-top-radius(0);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/normalize.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/normalize.less
new file mode 100644
index 0000000000000000000000000000000000000000..62a085a4841a536094f22943c9557240e2d8c19d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/normalize.less
@@ -0,0 +1,427 @@
+/*! normalize.css v3.0.2 | MIT License | git.io/normalize */
+
+//
+// 1. Set default font family to sans-serif.
+// 2. Prevent iOS text size adjust after orientation change, without disabling
+//    user zoom.
+//
+
+html {
+  font-family: sans-serif; // 1
+  -ms-text-size-adjust: 100%; // 2
+  -webkit-text-size-adjust: 100%; // 2
+}
+
+//
+// Remove default margin.
+//
+
+body {
+  margin: 0;
+}
+
+// HTML5 display definitions
+// ==========================================================================
+
+//
+// Correct `block` display not defined for any HTML5 element in IE 8/9.
+// Correct `block` display not defined for `details` or `summary` in IE 10/11
+// and Firefox.
+// Correct `block` display not defined for `main` in IE 11.
+//
+
+article,
+aside,
+details,
+figcaption,
+figure,
+footer,
+header,
+hgroup,
+main,
+menu,
+nav,
+section,
+summary {
+  display: block;
+}
+
+//
+// 1. Correct `inline-block` display not defined in IE 8/9.
+// 2. Normalize vertical alignment of `progress` in Chrome, Firefox, and Opera.
+//
+
+audio,
+canvas,
+progress,
+video {
+  display: inline-block; // 1
+  vertical-align: baseline; // 2
+}
+
+//
+// Prevent modern browsers from displaying `audio` without controls.
+// Remove excess height in iOS 5 devices.
+//
+
+audio:not([controls]) {
+  display: none;
+  height: 0;
+}
+
+//
+// Address `[hidden]` styling not present in IE 8/9/10.
+// Hide the `template` element in IE 8/9/11, Safari, and Firefox < 22.
+//
+
+[hidden],
+template {
+  display: none;
+}
+
+// Links
+// ==========================================================================
+
+//
+// Remove the gray background color from active links in IE 10.
+//
+
+a {
+  background-color: transparent;
+}
+
+//
+// Improve readability when focused and also mouse hovered in all browsers.
+//
+
+a:active,
+a:hover {
+  outline: 0;
+}
+
+// Text-level semantics
+// ==========================================================================
+
+//
+// Address styling not present in IE 8/9/10/11, Safari, and Chrome.
+//
+
+abbr[title] {
+  border-bottom: 1px dotted;
+}
+
+//
+// Address style set to `bolder` in Firefox 4+, Safari, and Chrome.
+//
+
+b,
+strong {
+  font-weight: bold;
+}
+
+//
+// Address styling not present in Safari and Chrome.
+//
+
+dfn {
+  font-style: italic;
+}
+
+//
+// Address variable `h1` font-size and margin within `section` and `article`
+// contexts in Firefox 4+, Safari, and Chrome.
+//
+
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+//
+// Address styling not present in IE 8/9.
+//
+
+mark {
+  background: #ff0;
+  color: #000;
+}
+
+//
+// Address inconsistent and variable font size in all browsers.
+//
+
+small {
+  font-size: 80%;
+}
+
+//
+// Prevent `sub` and `sup` affecting `line-height` in all browsers.
+//
+
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sup {
+  top: -0.5em;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+// Embedded content
+// ==========================================================================
+
+//
+// Remove border when inside `a` element in IE 8/9/10.
+//
+
+img {
+  border: 0;
+}
+
+//
+// Correct overflow not hidden in IE 9/10/11.
+//
+
+svg:not(:root) {
+  overflow: hidden;
+}
+
+// Grouping content
+// ==========================================================================
+
+//
+// Address margin not present in IE 8/9 and Safari.
+//
+
+figure {
+  margin: 1em 40px;
+}
+
+//
+// Address differences between Firefox and other browsers.
+//
+
+hr {
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+  height: 0;
+}
+
+//
+// Contain overflow in all browsers.
+//
+
+pre {
+  overflow: auto;
+}
+
+//
+// Address odd `em`-unit font size rendering in all browsers.
+//
+
+code,
+kbd,
+pre,
+samp {
+  font-family: monospace, monospace;
+  font-size: 1em;
+}
+
+// Forms
+// ==========================================================================
+
+//
+// Known limitation: by default, Chrome and Safari on OS X allow very limited
+// styling of `select`, unless a `border` property is set.
+//
+
+//
+// 1. Correct color not being inherited.
+//    Known issue: affects color of disabled elements.
+// 2. Correct font properties not being inherited.
+// 3. Address margins set differently in Firefox 4+, Safari, and Chrome.
+//
+
+button,
+input,
+optgroup,
+select,
+textarea {
+  color: inherit; // 1
+  font: inherit; // 2
+  margin: 0; // 3
+}
+
+//
+// Address `overflow` set to `hidden` in IE 8/9/10/11.
+//
+
+button {
+  overflow: visible;
+}
+
+//
+// Address inconsistent `text-transform` inheritance for `button` and `select`.
+// All other form control elements do not inherit `text-transform` values.
+// Correct `button` style inheritance in Firefox, IE 8/9/10/11, and Opera.
+// Correct `select` style inheritance in Firefox.
+//
+
+button,
+select {
+  text-transform: none;
+}
+
+//
+// 1. Avoid the WebKit bug in Android 4.0.* where (2) destroys native `audio`
+//    and `video` controls.
+// 2. Correct inability to style clickable `input` types in iOS.
+// 3. Improve usability and consistency of cursor style between image-type
+//    `input` and others.
+//
+
+button,
+html input[type="button"], // 1
+input[type="reset"],
+input[type="submit"] {
+  -webkit-appearance: button; // 2
+  cursor: pointer; // 3
+}
+
+//
+// Re-set default cursor for disabled elements.
+//
+
+button[disabled],
+html input[disabled] {
+  cursor: default;
+}
+
+//
+// Remove inner padding and border in Firefox 4+.
+//
+
+button::-moz-focus-inner,
+input::-moz-focus-inner {
+  border: 0;
+  padding: 0;
+}
+
+//
+// Address Firefox 4+ setting `line-height` on `input` using `!important` in
+// the UA stylesheet.
+//
+
+input {
+  line-height: normal;
+}
+
+//
+// It's recommended that you don't attempt to style these elements.
+// Firefox's implementation doesn't respect box-sizing, padding, or width.
+//
+// 1. Address box sizing set to `content-box` in IE 8/9/10.
+// 2. Remove excess padding in IE 8/9/10.
+//
+
+input[type="checkbox"],
+input[type="radio"] {
+  box-sizing: border-box; // 1
+  padding: 0; // 2
+}
+
+//
+// Fix the cursor style for Chrome's increment/decrement buttons. For certain
+// `font-size` values of the `input`, it causes the cursor style of the
+// decrement button to change from `default` to `text`.
+//
+
+input[type="number"]::-webkit-inner-spin-button,
+input[type="number"]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+//
+// 1. Address `appearance` set to `searchfield` in Safari and Chrome.
+// 2. Address `box-sizing` set to `border-box` in Safari and Chrome
+//    (include `-moz` to future-proof).
+//
+
+input[type="search"] {
+  -webkit-appearance: textfield; // 1
+  -moz-box-sizing: content-box;
+  -webkit-box-sizing: content-box; // 2
+  box-sizing: content-box;
+}
+
+//
+// Remove inner padding and search cancel button in Safari and Chrome on OS X.
+// Safari (but not Chrome) clips the cancel button when the search input has
+// padding (and `textfield` appearance).
+//
+
+input[type="search"]::-webkit-search-cancel-button,
+input[type="search"]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+//
+// Define consistent border, margin, and padding.
+//
+
+fieldset {
+  border: 1px solid #c0c0c0;
+  margin: 0 2px;
+  padding: 0.35em 0.625em 0.75em;
+}
+
+//
+// 1. Correct `color` not being inherited in IE 8/9/10/11.
+// 2. Remove padding so people aren't caught out if they zero out fieldsets.
+//
+
+legend {
+  border: 0; // 1
+  padding: 0; // 2
+}
+
+//
+// Remove default vertical scrollbar in IE 8/9/10/11.
+//
+
+textarea {
+  overflow: auto;
+}
+
+//
+// Don't inherit the `font-weight` (applied by a rule above).
+// NOTE: the default cannot safely be changed in Chrome and Safari on OS X.
+//
+
+optgroup {
+  font-weight: bold;
+}
+
+// Tables
+// ==========================================================================
+
+//
+// Remove most spacing between table cells.
+//
+
+table {
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+
+td,
+th {
+  padding: 0;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/pager.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/pager.less
new file mode 100644
index 0000000000000000000000000000000000000000..41abaaadc5dc605c75de869dab943599ef31fbbd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/pager.less
@@ -0,0 +1,54 @@
+//
+// Pager pagination
+// --------------------------------------------------
+
+
+.pager {
+  padding-left: 0;
+  margin: @line-height-computed 0;
+  list-style: none;
+  text-align: center;
+  &:extend(.clearfix all);
+  li {
+    display: inline;
+    > a,
+    > span {
+      display: inline-block;
+      padding: 5px 14px;
+      background-color: @pager-bg;
+      border: 1px solid @pager-border;
+      border-radius: @pager-border-radius;
+    }
+
+    > a:hover,
+    > a:focus {
+      text-decoration: none;
+      background-color: @pager-hover-bg;
+    }
+  }
+
+  .next {
+    > a,
+    > span {
+      float: right;
+    }
+  }
+
+  .previous {
+    > a,
+    > span {
+      float: left;
+    }
+  }
+
+  .disabled {
+    > a,
+    > a:hover,
+    > a:focus,
+    > span {
+      color: @pager-disabled-color;
+      background-color: @pager-bg;
+      cursor: @cursor-disabled;
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/pagination.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/pagination.less
new file mode 100644
index 0000000000000000000000000000000000000000..38c4c3d346f974278503a4596a6b6e96b845c0af
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/pagination.less
@@ -0,0 +1,88 @@
+//
+// Pagination (multiple pages)
+// --------------------------------------------------
+.pagination {
+  display: inline-block;
+  padding-left: 0;
+  margin: @line-height-computed 0;
+  border-radius: @border-radius-base;
+
+  > li {
+    display: inline; // Remove list-style and block-level defaults
+    > a,
+    > span {
+      position: relative;
+      float: left; // Collapse white-space
+      padding: @padding-base-vertical @padding-base-horizontal;
+      line-height: @line-height-base;
+      text-decoration: none;
+      color: @pagination-color;
+      background-color: @pagination-bg;
+      border: 1px solid @pagination-border;
+      margin-left: -1px;
+    }
+    &:first-child {
+      > a,
+      > span {
+        margin-left: 0;
+        .border-left-radius(@border-radius-base);
+      }
+    }
+    &:last-child {
+      > a,
+      > span {
+        .border-right-radius(@border-radius-base);
+      }
+    }
+  }
+
+  > li > a,
+  > li > span {
+    &:hover,
+    &:focus {
+      color: @pagination-hover-color;
+      background-color: @pagination-hover-bg;
+      border-color: @pagination-hover-border;
+    }
+  }
+
+  > .active > a,
+  > .active > span {
+    &,
+    &:hover,
+    &:focus {
+      z-index: 2;
+      color: @pagination-active-color;
+      background-color: @pagination-active-bg;
+      border-color: @pagination-active-border;
+      cursor: default;
+    }
+  }
+
+  > .disabled {
+    > span,
+    > span:hover,
+    > span:focus,
+    > a,
+    > a:hover,
+    > a:focus {
+      color: @pagination-disabled-color;
+      background-color: @pagination-disabled-bg;
+      border-color: @pagination-disabled-border;
+      cursor: @cursor-disabled;
+    }
+  }
+}
+
+// Sizing
+// --------------------------------------------------
+
+// Large
+.pagination-lg {
+  .pagination-size(@padding-large-vertical; @padding-large-horizontal; @font-size-large; @border-radius-large);
+}
+
+// Small
+.pagination-sm {
+  .pagination-size(@padding-small-vertical; @padding-small-horizontal; @font-size-small; @border-radius-small);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/panels.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/panels.less
new file mode 100644
index 0000000000000000000000000000000000000000..04eb2b39ca18d69945ed1e60e725fb30544bde3f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/panels.less
@@ -0,0 +1,265 @@
+//
+// Panels
+// --------------------------------------------------
+
+
+// Base class
+.panel {
+  margin-bottom: @line-height-computed;
+  background-color: @panel-bg;
+  border: 1px solid transparent;
+  border-radius: @panel-border-radius;
+  .box-shadow(0 1px 1px rgba(0,0,0,.05));
+}
+
+// Panel contents
+.panel-body {
+  padding: @panel-body-padding;
+  &:extend(.clearfix all);
+}
+
+// Optional heading
+.panel-heading {
+  padding: @panel-heading-padding;
+  border-bottom: 1px solid transparent;
+  .border-top-radius((@panel-border-radius - 1));
+
+  > .dropdown .dropdown-toggle {
+    color: inherit;
+  }
+}
+
+// Within heading, strip any `h*` tag of its default margins for spacing.
+.panel-title {
+  margin-top: 0;
+  margin-bottom: 0;
+  font-size: ceil((@font-size-base * 1.125));
+  color: inherit;
+
+  > a,
+  > small,
+  > .small,
+  > small > a,
+  > .small > a {
+    color: inherit;
+  }
+}
+
+// Optional footer (stays gray in every modifier class)
+.panel-footer {
+  padding: @panel-footer-padding;
+  background-color: @panel-footer-bg;
+  border-top: 1px solid @panel-inner-border;
+  .border-bottom-radius((@panel-border-radius - 1));
+}
+
+
+// List groups in panels
+//
+// By default, space out list group content from panel headings to account for
+// any kind of custom content between the two.
+
+.panel {
+  > .list-group,
+  > .panel-collapse > .list-group {
+    margin-bottom: 0;
+
+    .list-group-item {
+      border-width: 1px 0;
+      border-radius: 0;
+    }
+
+    // Add border top radius for first one
+    &:first-child {
+      .list-group-item:first-child {
+        border-top: 0;
+        .border-top-radius((@panel-border-radius - 1));
+      }
+    }
+    // Add border bottom radius for last one
+    &:last-child {
+      .list-group-item:last-child {
+        border-bottom: 0;
+        .border-bottom-radius((@panel-border-radius - 1));
+      }
+    }
+  }
+}
+// Collapse space between when there's no additional content.
+.panel-heading + .list-group {
+  .list-group-item:first-child {
+    border-top-width: 0;
+  }
+}
+.list-group + .panel-footer {
+  border-top-width: 0;
+}
+
+// Tables in panels
+//
+// Place a non-bordered `.table` within a panel (not within a `.panel-body`) and
+// watch it go full width.
+
+.panel {
+  > .table,
+  > .table-responsive > .table,
+  > .panel-collapse > .table {
+    margin-bottom: 0;
+
+    caption {
+      padding-left: @panel-body-padding;
+      padding-right: @panel-body-padding;
+    }
+  }
+  // Add border top radius for first one
+  > .table:first-child,
+  > .table-responsive:first-child > .table:first-child {
+    .border-top-radius((@panel-border-radius - 1));
+
+    > thead:first-child,
+    > tbody:first-child {
+      > tr:first-child {
+        border-top-left-radius: (@panel-border-radius - 1);
+        border-top-right-radius: (@panel-border-radius - 1);
+
+        td:first-child,
+        th:first-child {
+          border-top-left-radius: (@panel-border-radius - 1);
+        }
+        td:last-child,
+        th:last-child {
+          border-top-right-radius: (@panel-border-radius - 1);
+        }
+      }
+    }
+  }
+  // Add border bottom radius for last one
+  > .table:last-child,
+  > .table-responsive:last-child > .table:last-child {
+    .border-bottom-radius((@panel-border-radius - 1));
+
+    > tbody:last-child,
+    > tfoot:last-child {
+      > tr:last-child {
+        border-bottom-left-radius: (@panel-border-radius - 1);
+        border-bottom-right-radius: (@panel-border-radius - 1);
+
+        td:first-child,
+        th:first-child {
+          border-bottom-left-radius: (@panel-border-radius - 1);
+        }
+        td:last-child,
+        th:last-child {
+          border-bottom-right-radius: (@panel-border-radius - 1);
+        }
+      }
+    }
+  }
+  > .panel-body + .table,
+  > .panel-body + .table-responsive,
+  > .table + .panel-body,
+  > .table-responsive + .panel-body {
+    border-top: 1px solid @table-border-color;
+  }
+  > .table > tbody:first-child > tr:first-child th,
+  > .table > tbody:first-child > tr:first-child td {
+    border-top: 0;
+  }
+  > .table-bordered,
+  > .table-responsive > .table-bordered {
+    border: 0;
+    > thead,
+    > tbody,
+    > tfoot {
+      > tr {
+        > th:first-child,
+        > td:first-child {
+          border-left: 0;
+        }
+        > th:last-child,
+        > td:last-child {
+          border-right: 0;
+        }
+      }
+    }
+    > thead,
+    > tbody {
+      > tr:first-child {
+        > td,
+        > th {
+          border-bottom: 0;
+        }
+      }
+    }
+    > tbody,
+    > tfoot {
+      > tr:last-child {
+        > td,
+        > th {
+          border-bottom: 0;
+        }
+      }
+    }
+  }
+  > .table-responsive {
+    border: 0;
+    margin-bottom: 0;
+  }
+}
+
+
+// Collapsable panels (aka, accordion)
+//
+// Wrap a series of panels in `.panel-group` to turn them into an accordion with
+// the help of our collapse JavaScript plugin.
+
+.panel-group {
+  margin-bottom: @line-height-computed;
+
+  // Tighten up margin so it's only between panels
+  .panel {
+    margin-bottom: 0;
+    border-radius: @panel-border-radius;
+
+    + .panel {
+      margin-top: 5px;
+    }
+  }
+
+  .panel-heading {
+    border-bottom: 0;
+
+    + .panel-collapse > .panel-body,
+    + .panel-collapse > .list-group {
+      border-top: 1px solid @panel-inner-border;
+    }
+  }
+
+  .panel-footer {
+    border-top: 0;
+    + .panel-collapse .panel-body {
+      border-bottom: 1px solid @panel-inner-border;
+    }
+  }
+}
+
+
+// Contextual variations
+.panel-default {
+  .panel-variant(@panel-default-border; @panel-default-text; @panel-default-heading-bg; @panel-default-border);
+}
+.panel-primary {
+  .panel-variant(@panel-primary-border; @panel-primary-text; @panel-primary-heading-bg; @panel-primary-border);
+}
+.panel-success {
+  .panel-variant(@panel-success-border; @panel-success-text; @panel-success-heading-bg; @panel-success-border);
+}
+.panel-info {
+  .panel-variant(@panel-info-border; @panel-info-text; @panel-info-heading-bg; @panel-info-border);
+}
+.panel-warning {
+  .panel-variant(@panel-warning-border; @panel-warning-text; @panel-warning-heading-bg; @panel-warning-border);
+}
+.panel-danger {
+  .panel-variant(@panel-danger-border; @panel-danger-text; @panel-danger-heading-bg; @panel-danger-border);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/popovers.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/popovers.less
new file mode 100644
index 0000000000000000000000000000000000000000..2748eead13fa69dc8e7d32a1f0f64e6edb71e6e5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/popovers.less
@@ -0,0 +1,135 @@
+//
+// Popovers
+// --------------------------------------------------
+
+
+.popover {
+  position: absolute;
+  top: 0;
+  left: 0;
+  z-index: @zindex-popover;
+  display: none;
+  max-width: @popover-max-width;
+  padding: 1px;
+  // Reset font and text properties given new insertion method
+  font-family: @font-family-base;
+  font-size: @font-size-base;
+  font-weight: normal;
+  line-height: @line-height-base;
+  text-align: left;
+  background-color: @popover-bg;
+  background-clip: padding-box;
+  border: 1px solid @popover-fallback-border-color;
+  border: 1px solid @popover-border-color;
+  border-radius: @border-radius-large;
+  .box-shadow(0 5px 10px rgba(0,0,0,.2));
+
+  // Overrides for proper insertion
+  white-space: normal;
+
+  // Offset the popover to account for the popover arrow
+  &.top     { margin-top: -@popover-arrow-width; }
+  &.right   { margin-left: @popover-arrow-width; }
+  &.bottom  { margin-top: @popover-arrow-width; }
+  &.left    { margin-left: -@popover-arrow-width; }
+}
+
+.popover-title {
+  margin: 0; // reset heading margin
+  padding: 8px 14px;
+  font-size: @font-size-base;
+  background-color: @popover-title-bg;
+  border-bottom: 1px solid darken(@popover-title-bg, 5%);
+  border-radius: (@border-radius-large - 1) (@border-radius-large - 1) 0 0;
+}
+
+.popover-content {
+  padding: 9px 14px;
+}
+
+// Arrows
+//
+// .arrow is outer, .arrow:after is inner
+
+.popover > .arrow {
+  &,
+  &:after {
+    position: absolute;
+    display: block;
+    width: 0;
+    height: 0;
+    border-color: transparent;
+    border-style: solid;
+  }
+}
+.popover > .arrow {
+  border-width: @popover-arrow-outer-width;
+}
+.popover > .arrow:after {
+  border-width: @popover-arrow-width;
+  content: "";
+}
+
+.popover {
+  &.top > .arrow {
+    left: 50%;
+    margin-left: -@popover-arrow-outer-width;
+    border-bottom-width: 0;
+    border-top-color: @popover-arrow-outer-fallback-color; // IE8 fallback
+    border-top-color: @popover-arrow-outer-color;
+    bottom: -@popover-arrow-outer-width;
+    &:after {
+      content: " ";
+      bottom: 1px;
+      margin-left: -@popover-arrow-width;
+      border-bottom-width: 0;
+      border-top-color: @popover-arrow-color;
+    }
+  }
+  &.right > .arrow {
+    top: 50%;
+    left: -@popover-arrow-outer-width;
+    margin-top: -@popover-arrow-outer-width;
+    border-left-width: 0;
+    border-right-color: @popover-arrow-outer-fallback-color; // IE8 fallback
+    border-right-color: @popover-arrow-outer-color;
+    &:after {
+      content: " ";
+      left: 1px;
+      bottom: -@popover-arrow-width;
+      border-left-width: 0;
+      border-right-color: @popover-arrow-color;
+    }
+  }
+  &.bottom > .arrow {
+    left: 50%;
+    margin-left: -@popover-arrow-outer-width;
+    border-top-width: 0;
+    border-bottom-color: @popover-arrow-outer-fallback-color; // IE8 fallback
+    border-bottom-color: @popover-arrow-outer-color;
+    top: -@popover-arrow-outer-width;
+    &:after {
+      content: " ";
+      top: 1px;
+      margin-left: -@popover-arrow-width;
+      border-top-width: 0;
+      border-bottom-color: @popover-arrow-color;
+    }
+  }
+
+  &.left > .arrow {
+    top: 50%;
+    right: -@popover-arrow-outer-width;
+    margin-top: -@popover-arrow-outer-width;
+    border-right-width: 0;
+    border-left-color: @popover-arrow-outer-fallback-color; // IE8 fallback
+    border-left-color: @popover-arrow-outer-color;
+    &:after {
+      content: " ";
+      right: 1px;
+      border-right-width: 0;
+      border-left-color: @popover-arrow-color;
+      bottom: -@popover-arrow-width;
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/print.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/print.less
new file mode 100644
index 0000000000000000000000000000000000000000..94ca58f12a93ea0b3fb378b73eec63d8c9ee7372
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/print.less
@@ -0,0 +1,107 @@
+/*! Source: https://github.com/h5bp/html5-boilerplate/blob/master/src/css/main.css */
+
+// ==========================================================================
+// Print styles.
+// Inlined to avoid the additional HTTP request: h5bp.com/r
+// ==========================================================================
+
+@media print {
+    *,
+    *:before,
+    *:after {
+        background: transparent !important;
+        color: #000 !important; // Black prints faster: h5bp.com/s
+        box-shadow: none !important;
+        text-shadow: none !important;
+    }
+
+    a,
+    a:visited {
+        text-decoration: underline;
+    }
+
+    a[href]:after {
+        content: " (" attr(href) ")";
+    }
+
+    abbr[title]:after {
+        content: " (" attr(title) ")";
+    }
+
+    // Don't show links that are fragment identifiers,
+    // or use the `javascript:` pseudo protocol
+    a[href^="#"]:after,
+    a[href^="javascript:"]:after {
+        content: "";
+    }
+
+    pre,
+    blockquote {
+        border: 1px solid #999;
+        page-break-inside: avoid;
+    }
+
+    thead {
+        display: table-header-group; // h5bp.com/t
+    }
+
+    tr,
+    img {
+        page-break-inside: avoid;
+    }
+
+    img {
+        max-width: 100% !important;
+    }
+
+    p,
+    h2,
+    h3 {
+        orphans: 3;
+        widows: 3;
+    }
+
+    h2,
+    h3 {
+        page-break-after: avoid;
+    }
+
+    // Bootstrap specific changes start
+    //
+    // Chrome (OSX) fix for https://github.com/twbs/bootstrap/issues/11245
+    // Once fixed, we can just straight up remove this.
+    select {
+        background: #fff !important;
+    }
+
+    // Bootstrap components
+    .navbar {
+        display: none;
+    }
+    .btn,
+    .dropup > .btn {
+        > .caret {
+            border-top-color: #000 !important;
+        }
+    }
+    .label {
+        border: 1px solid #000;
+    }
+
+    .table {
+        border-collapse: collapse !important;
+
+        td,
+        th {
+            background-color: #fff !important;
+        }
+    }
+    .table-bordered {
+        th,
+        td {
+            border: 1px solid #ddd !important;
+        }
+    }
+
+    // Bootstrap specific changes end
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/progress-bars.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/progress-bars.less
new file mode 100644
index 0000000000000000000000000000000000000000..8868a1feef0f3a7a4b0fabe7548435bfeb481df2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/progress-bars.less
@@ -0,0 +1,87 @@
+//
+// Progress bars
+// --------------------------------------------------
+
+
+// Bar animations
+// -------------------------
+
+// WebKit
+@-webkit-keyframes progress-bar-stripes {
+  from  { background-position: 40px 0; }
+  to    { background-position: 0 0; }
+}
+
+// Spec and IE10+
+@keyframes progress-bar-stripes {
+  from  { background-position: 40px 0; }
+  to    { background-position: 0 0; }
+}
+
+
+// Bar itself
+// -------------------------
+
+// Outer container
+.progress {
+  overflow: hidden;
+  height: @line-height-computed;
+  margin-bottom: @line-height-computed;
+  background-color: @progress-bg;
+  border-radius: @progress-border-radius;
+  .box-shadow(inset 0 1px 2px rgba(0,0,0,.1));
+}
+
+// Bar of progress
+.progress-bar {
+  float: left;
+  width: 0%;
+  height: 100%;
+  font-size: @font-size-small;
+  line-height: @line-height-computed;
+  color: @progress-bar-color;
+  text-align: center;
+  background-color: @progress-bar-bg;
+  .box-shadow(inset 0 -1px 0 rgba(0,0,0,.15));
+  .transition(width .6s ease);
+}
+
+// Striped bars
+//
+// `.progress-striped .progress-bar` is deprecated as of v3.2.0 in favor of the
+// `.progress-bar-striped` class, which you just add to an existing
+// `.progress-bar`.
+.progress-striped .progress-bar,
+.progress-bar-striped {
+  #gradient > .striped();
+  background-size: 40px 40px;
+}
+
+// Call animation for the active one
+//
+// `.progress.active .progress-bar` is deprecated as of v3.2.0 in favor of the
+// `.progress-bar.active` approach.
+.progress.active .progress-bar,
+.progress-bar.active {
+  .animation(progress-bar-stripes 2s linear infinite);
+}
+
+
+// Variations
+// -------------------------
+
+.progress-bar-success {
+  .progress-bar-variant(@progress-bar-success-bg);
+}
+
+.progress-bar-info {
+  .progress-bar-variant(@progress-bar-info-bg);
+}
+
+.progress-bar-warning {
+  .progress-bar-variant(@progress-bar-warning-bg);
+}
+
+.progress-bar-danger {
+  .progress-bar-variant(@progress-bar-danger-bg);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/responsive-embed.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/responsive-embed.less
new file mode 100644
index 0000000000000000000000000000000000000000..080a5118fe9ab2af331e6b1444fff4be840ecc03
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/responsive-embed.less
@@ -0,0 +1,35 @@
+// Embeds responsive
+//
+// Credit: Nicolas Gallagher and SUIT CSS.
+
+.embed-responsive {
+  position: relative;
+  display: block;
+  height: 0;
+  padding: 0;
+  overflow: hidden;
+
+  .embed-responsive-item,
+  iframe,
+  embed,
+  object,
+  video {
+    position: absolute;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    height: 100%;
+    width: 100%;
+    border: 0;
+  }
+}
+
+// Modifier class for 16:9 aspect ratio
+.embed-responsive-16by9 {
+  padding-bottom: 56.25%;
+}
+
+// Modifier class for 4:3 aspect ratio
+.embed-responsive-4by3 {
+  padding-bottom: 75%;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/responsive-utilities.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/responsive-utilities.less
new file mode 100644
index 0000000000000000000000000000000000000000..b1db31d7bfc19a757d02fd773db765c4273549a1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/responsive-utilities.less
@@ -0,0 +1,194 @@
+//
+// Responsive: Utility classes
+// --------------------------------------------------
+
+
+// IE10 in Windows (Phone) 8
+//
+// Support for responsive views via media queries is kind of borked in IE10, for
+// Surface/desktop in split view and for Windows Phone 8. This particular fix
+// must be accompanied by a snippet of JavaScript to sniff the user agent and
+// apply some conditional CSS to *only* the Surface/desktop Windows 8. Look at
+// our Getting Started page for more information on this bug.
+//
+// For more information, see the following:
+//
+// Issue: https://github.com/twbs/bootstrap/issues/10497
+// Docs: http://getbootstrap.com/getting-started/#support-ie10-width
+// Source: http://timkadlec.com/2013/01/windows-phone-8-and-device-width/
+// Source: http://timkadlec.com/2012/10/ie10-snap-mode-and-responsive-design/
+
+@-ms-viewport {
+  width: device-width;
+}
+
+
+// Visibility utilities
+// Note: Deprecated .visible-xs, .visible-sm, .visible-md, and .visible-lg as of v3.2.0
+.visible-xs,
+.visible-sm,
+.visible-md,
+.visible-lg {
+  .responsive-invisibility();
+}
+
+.visible-xs-block,
+.visible-xs-inline,
+.visible-xs-inline-block,
+.visible-sm-block,
+.visible-sm-inline,
+.visible-sm-inline-block,
+.visible-md-block,
+.visible-md-inline,
+.visible-md-inline-block,
+.visible-lg-block,
+.visible-lg-inline,
+.visible-lg-inline-block {
+  display: none !important;
+}
+
+.visible-xs {
+  @media (max-width: @screen-xs-max) {
+    .responsive-visibility();
+  }
+}
+.visible-xs-block {
+  @media (max-width: @screen-xs-max) {
+    display: block !important;
+  }
+}
+.visible-xs-inline {
+  @media (max-width: @screen-xs-max) {
+    display: inline !important;
+  }
+}
+.visible-xs-inline-block {
+  @media (max-width: @screen-xs-max) {
+    display: inline-block !important;
+  }
+}
+
+.visible-sm {
+  @media (min-width: @screen-sm-min) and (max-width: @screen-sm-max) {
+    .responsive-visibility();
+  }
+}
+.visible-sm-block {
+  @media (min-width: @screen-sm-min) and (max-width: @screen-sm-max) {
+    display: block !important;
+  }
+}
+.visible-sm-inline {
+  @media (min-width: @screen-sm-min) and (max-width: @screen-sm-max) {
+    display: inline !important;
+  }
+}
+.visible-sm-inline-block {
+  @media (min-width: @screen-sm-min) and (max-width: @screen-sm-max) {
+    display: inline-block !important;
+  }
+}
+
+.visible-md {
+  @media (min-width: @screen-md-min) and (max-width: @screen-md-max) {
+    .responsive-visibility();
+  }
+}
+.visible-md-block {
+  @media (min-width: @screen-md-min) and (max-width: @screen-md-max) {
+    display: block !important;
+  }
+}
+.visible-md-inline {
+  @media (min-width: @screen-md-min) and (max-width: @screen-md-max) {
+    display: inline !important;
+  }
+}
+.visible-md-inline-block {
+  @media (min-width: @screen-md-min) and (max-width: @screen-md-max) {
+    display: inline-block !important;
+  }
+}
+
+.visible-lg {
+  @media (min-width: @screen-lg-min) {
+    .responsive-visibility();
+  }
+}
+.visible-lg-block {
+  @media (min-width: @screen-lg-min) {
+    display: block !important;
+  }
+}
+.visible-lg-inline {
+  @media (min-width: @screen-lg-min) {
+    display: inline !important;
+  }
+}
+.visible-lg-inline-block {
+  @media (min-width: @screen-lg-min) {
+    display: inline-block !important;
+  }
+}
+
+.hidden-xs {
+  @media (max-width: @screen-xs-max) {
+    .responsive-invisibility();
+  }
+}
+.hidden-sm {
+  @media (min-width: @screen-sm-min) and (max-width: @screen-sm-max) {
+    .responsive-invisibility();
+  }
+}
+.hidden-md {
+  @media (min-width: @screen-md-min) and (max-width: @screen-md-max) {
+    .responsive-invisibility();
+  }
+}
+.hidden-lg {
+  @media (min-width: @screen-lg-min) {
+    .responsive-invisibility();
+  }
+}
+
+
+// Print utilities
+//
+// Media queries are placed on the inside to be mixin-friendly.
+
+// Note: Deprecated .visible-print as of v3.2.0
+.visible-print {
+  .responsive-invisibility();
+
+  @media print {
+    .responsive-visibility();
+  }
+}
+.visible-print-block {
+  display: none !important;
+
+  @media print {
+    display: block !important;
+  }
+}
+.visible-print-inline {
+  display: none !important;
+
+  @media print {
+    display: inline !important;
+  }
+}
+.visible-print-inline-block {
+  display: none !important;
+
+  @media print {
+    display: inline-block !important;
+  }
+}
+
+.hidden-print {
+  @media print {
+    .responsive-invisibility();
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/scaffolding.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/scaffolding.less
new file mode 100644
index 0000000000000000000000000000000000000000..47b1d5a1aab384e993b689aaaec4212a85260e88
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/scaffolding.less
@@ -0,0 +1,162 @@
+//
+// Scaffolding
+// --------------------------------------------------
+
+
+// Reset the box-sizing
+//
+// Heads up! This reset may cause conflicts with some third-party widgets.
+// For recommendations on resolving such conflicts, see
+// http://getbootstrap.com/getting-started/#third-box-sizing
+* {
+  .box-sizing(border-box);
+}
+*:before,
+*:after {
+  .box-sizing(border-box);
+}
+
+
+// Body reset
+
+html {
+  font-size: 10px;
+  -webkit-tap-highlight-color: rgba(0,0,0,0);
+}
+
+body {
+  font-family: @font-family-base;
+  font-size: @font-size-base;
+  line-height: @line-height-base;
+  color: @text-color;
+  background-color: @body-bg;
+}
+
+// Reset fonts for relevant elements
+input,
+button,
+select,
+textarea {
+  font-family: inherit;
+  font-size: inherit;
+  line-height: inherit;
+}
+
+
+// Links
+
+a {
+  color: @link-color;
+  text-decoration: none;
+
+  &:hover,
+  &:focus {
+    color: @link-hover-color;
+    text-decoration: @link-hover-decoration;
+  }
+
+  &:focus {
+    .tab-focus();
+  }
+}
+
+
+// Figures
+//
+// We reset this here because previously Normalize had no `figure` margins. This
+// ensures we don't break anyone's use of the element.
+
+figure {
+  margin: 0;
+}
+
+
+// Images
+
+img {
+  vertical-align: middle;
+}
+
+// Responsive images (ensure images don't scale beyond their parents)
+.img-responsive {
+  .img-responsive();
+}
+
+// Rounded corners
+.img-rounded {
+  border-radius: @border-radius-large;
+}
+
+// Image thumbnails
+//
+// Heads up! This is mixin-ed into thumbnails.less for `.thumbnail`.
+.img-thumbnail {
+  padding: @thumbnail-padding;
+  line-height: @line-height-base;
+  background-color: @thumbnail-bg;
+  border: 1px solid @thumbnail-border;
+  border-radius: @thumbnail-border-radius;
+  .transition(all .2s ease-in-out);
+
+  // Keep them at most 100% wide
+  .img-responsive(inline-block);
+}
+
+// Perfect circle
+.img-circle {
+  border-radius: 50%; // set radius in percents
+}
+
+
+// Horizontal rules
+
+hr {
+  margin-top:    @line-height-computed;
+  margin-bottom: @line-height-computed;
+  border: 0;
+  border-top: 1px solid @hr-border;
+}
+
+
+// Only display content to screen readers
+//
+// See: http://a11yproject.com/posts/how-to-hide-content/
+
+.sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  margin: -1px;
+  padding: 0;
+  overflow: hidden;
+  clip: rect(0,0,0,0);
+  border: 0;
+}
+
+// Use in conjunction with .sr-only to only display content when it's focused.
+// Useful for "Skip to main content" links; see http://www.w3.org/TR/2013/NOTE-WCAG20-TECHS-20130905/G1
+// Credit: HTML5 Boilerplate
+
+.sr-only-focusable {
+  &:active,
+  &:focus {
+    position: static;
+    width: auto;
+    height: auto;
+    margin: 0;
+    overflow: visible;
+    clip: auto;
+  }
+}
+
+
+// iOS "clickable elements" fix for role="button"
+//
+// Fixes "clickability" issue (and more generally, the firing of events such as focus as well)
+// for traditionally non-focusable elements with role="button"
+// see https://developer.mozilla.org/en-US/docs/Web/Events/click#Safari_Mobile
+// Upstream patch for normalize.css submitted: https://github.com/necolas/normalize.css/pull/379 - remove this fix once that is merged
+
+[role="button"] {
+  cursor: pointer;
+}
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/tables.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/tables.less
new file mode 100644
index 0000000000000000000000000000000000000000..2242c036868d7358ad684313ccab2e4d4704ee94
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/tables.less
@@ -0,0 +1,234 @@
+//
+// Tables
+// --------------------------------------------------
+
+
+table {
+  background-color: @table-bg;
+}
+caption {
+  padding-top: @table-cell-padding;
+  padding-bottom: @table-cell-padding;
+  color: @text-muted;
+  text-align: left;
+}
+th {
+  text-align: left;
+}
+
+
+// Baseline styles
+
+.table {
+  width: 100%;
+  max-width: 100%;
+  margin-bottom: @line-height-computed;
+  // Cells
+  > thead,
+  > tbody,
+  > tfoot {
+    > tr {
+      > th,
+      > td {
+        padding: @table-cell-padding;
+        line-height: @line-height-base;
+        vertical-align: top;
+        border-top: 1px solid @table-border-color;
+      }
+    }
+  }
+  // Bottom align for column headings
+  > thead > tr > th {
+    vertical-align: bottom;
+    border-bottom: 2px solid @table-border-color;
+  }
+  // Remove top border from thead by default
+  > caption + thead,
+  > colgroup + thead,
+  > thead:first-child {
+    > tr:first-child {
+      > th,
+      > td {
+        border-top: 0;
+      }
+    }
+  }
+  // Account for multiple tbody instances
+  > tbody + tbody {
+    border-top: 2px solid @table-border-color;
+  }
+
+  // Nesting
+  .table {
+    background-color: @body-bg;
+  }
+}
+
+
+// Condensed table w/ half padding
+
+.table-condensed {
+  > thead,
+  > tbody,
+  > tfoot {
+    > tr {
+      > th,
+      > td {
+        padding: @table-condensed-cell-padding;
+      }
+    }
+  }
+}
+
+
+// Bordered version
+//
+// Add borders all around the table and between all the columns.
+
+.table-bordered {
+  border: 1px solid @table-border-color;
+  > thead,
+  > tbody,
+  > tfoot {
+    > tr {
+      > th,
+      > td {
+        border: 1px solid @table-border-color;
+      }
+    }
+  }
+  > thead > tr {
+    > th,
+    > td {
+      border-bottom-width: 2px;
+    }
+  }
+}
+
+
+// Zebra-striping
+//
+// Default zebra-stripe styles (alternating gray and transparent backgrounds)
+
+.table-striped {
+  > tbody > tr:nth-of-type(odd) {
+    background-color: @table-bg-accent;
+  }
+}
+
+
+// Hover effect
+//
+// Placed here since it has to come after the potential zebra striping
+
+.table-hover {
+  > tbody > tr:hover {
+    background-color: @table-bg-hover;
+  }
+}
+
+
+// Table cell sizing
+//
+// Reset default table behavior
+
+table col[class*="col-"] {
+  position: static; // Prevent border hiding in Firefox and IE9-11 (see https://github.com/twbs/bootstrap/issues/11623)
+  float: none;
+  display: table-column;
+}
+table {
+  td,
+  th {
+    &[class*="col-"] {
+      position: static; // Prevent border hiding in Firefox and IE9-11 (see https://github.com/twbs/bootstrap/issues/11623)
+      float: none;
+      display: table-cell;
+    }
+  }
+}
+
+
+// Table backgrounds
+//
+// Exact selectors below required to override `.table-striped` and prevent
+// inheritance to nested tables.
+
+// Generate the contextual variants
+.table-row-variant(active; @table-bg-active);
+.table-row-variant(success; @state-success-bg);
+.table-row-variant(info; @state-info-bg);
+.table-row-variant(warning; @state-warning-bg);
+.table-row-variant(danger; @state-danger-bg);
+
+
+// Responsive tables
+//
+// Wrap your tables in `.table-responsive` and we'll make them mobile friendly
+// by enabling horizontal scrolling. Only applies <768px. Everything above that
+// will display normally.
+
+.table-responsive {
+  overflow-x: auto;
+  min-height: 0.01%; // Workaround for IE9 bug (see https://github.com/twbs/bootstrap/issues/14837)
+
+  @media screen and (max-width: @screen-xs-max) {
+    width: 100%;
+    margin-bottom: (@line-height-computed * 0.75);
+    overflow-y: hidden;
+    -ms-overflow-style: -ms-autohiding-scrollbar;
+    border: 1px solid @table-border-color;
+
+    // Tighten up spacing
+    > .table {
+      margin-bottom: 0;
+
+      // Ensure the content doesn't wrap
+      > thead,
+      > tbody,
+      > tfoot {
+        > tr {
+          > th,
+          > td {
+            white-space: nowrap;
+          }
+        }
+      }
+    }
+
+    // Special overrides for the bordered tables
+    > .table-bordered {
+      border: 0;
+
+      // Nuke the appropriate borders so that the parent can handle them
+      > thead,
+      > tbody,
+      > tfoot {
+        > tr {
+          > th:first-child,
+          > td:first-child {
+            border-left: 0;
+          }
+          > th:last-child,
+          > td:last-child {
+            border-right: 0;
+          }
+        }
+      }
+
+      // Only nuke the last row's bottom-border in `tbody` and `tfoot` since
+      // chances are there will be only one `tr` in a `thead` and that would
+      // remove the border altogether.
+      > tbody,
+      > tfoot {
+        > tr:last-child {
+          > th,
+          > td {
+            border-bottom: 0;
+          }
+        }
+      }
+
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/theme.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/theme.less
new file mode 100644
index 0000000000000000000000000000000000000000..6f2eb62126f12b00cde15580964870c7c3e4eb4c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/theme.less
@@ -0,0 +1,273 @@
+
+//
+// Load core variables and mixins
+// --------------------------------------------------
+
+@import "variables.less";
+@import "mixins.less";
+
+
+//
+// Buttons
+// --------------------------------------------------
+
+// Common styles
+.btn-default,
+.btn-primary,
+.btn-success,
+.btn-info,
+.btn-warning,
+.btn-danger {
+  text-shadow: 0 -1px 0 rgba(0,0,0,.2);
+  @shadow: inset 0 1px 0 rgba(255,255,255,.15), 0 1px 1px rgba(0,0,0,.075);
+  .box-shadow(@shadow);
+
+  // Reset the shadow
+  &:active,
+  &.active {
+    .box-shadow(inset 0 3px 5px rgba(0,0,0,.125));
+  }
+
+  .badge {
+    text-shadow: none;
+  }
+}
+
+// Mixin for generating new styles
+.btn-styles(@btn-color: #555) {
+  #gradient > .vertical(@start-color: @btn-color; @end-color: darken(@btn-color, 12%));
+  .reset-filter(); // Disable gradients for IE9 because filter bleeds through rounded corners; see https://github.com/twbs/bootstrap/issues/10620
+  background-repeat: repeat-x;
+  border-color: darken(@btn-color, 14%);
+
+  &:hover,
+  &:focus  {
+    background-color: darken(@btn-color, 12%);
+    background-position: 0 -15px;
+  }
+
+  &:active,
+  &.active {
+    background-color: darken(@btn-color, 12%);
+    border-color: darken(@btn-color, 14%);
+  }
+
+  &.disabled,
+  &:disabled,
+  &[disabled] {
+    background-color: darken(@btn-color, 12%);
+    background-image: none;
+  }
+}
+
+// Common styles
+.btn {
+  // Remove the gradient for the pressed/active state
+  &:active,
+  &.active {
+    background-image: none;
+  }
+}
+
+// Apply the mixin to the buttons
+.btn-default { .btn-styles(@btn-default-bg); text-shadow: 0 1px 0 #fff; border-color: #ccc; }
+.btn-primary { .btn-styles(@btn-primary-bg); }
+.btn-success { .btn-styles(@btn-success-bg); }
+.btn-info    { .btn-styles(@btn-info-bg); }
+.btn-warning { .btn-styles(@btn-warning-bg); }
+.btn-danger  { .btn-styles(@btn-danger-bg); }
+
+
+//
+// Images
+// --------------------------------------------------
+
+.thumbnail,
+.img-thumbnail {
+  .box-shadow(0 1px 2px rgba(0,0,0,.075));
+}
+
+
+//
+// Dropdowns
+// --------------------------------------------------
+
+.dropdown-menu > li > a:hover,
+.dropdown-menu > li > a:focus {
+  #gradient > .vertical(@start-color: @dropdown-link-hover-bg; @end-color: darken(@dropdown-link-hover-bg, 5%));
+  background-color: darken(@dropdown-link-hover-bg, 5%);
+}
+.dropdown-menu > .active > a,
+.dropdown-menu > .active > a:hover,
+.dropdown-menu > .active > a:focus {
+  #gradient > .vertical(@start-color: @dropdown-link-active-bg; @end-color: darken(@dropdown-link-active-bg, 5%));
+  background-color: darken(@dropdown-link-active-bg, 5%);
+}
+
+
+//
+// Navbar
+// --------------------------------------------------
+
+// Default navbar
+.navbar-default {
+  #gradient > .vertical(@start-color: lighten(@navbar-default-bg, 10%); @end-color: @navbar-default-bg);
+  .reset-filter(); // Remove gradient in IE<10 to fix bug where dropdowns don't get triggered
+  border-radius: @navbar-border-radius;
+  @shadow: inset 0 1px 0 rgba(255,255,255,.15), 0 1px 5px rgba(0,0,0,.075);
+  .box-shadow(@shadow);
+
+  .navbar-nav > .open > a,
+  .navbar-nav > .active > a {
+    #gradient > .vertical(@start-color: darken(@navbar-default-link-active-bg, 5%); @end-color: darken(@navbar-default-link-active-bg, 2%));
+    .box-shadow(inset 0 3px 9px rgba(0,0,0,.075));
+  }
+}
+.navbar-brand,
+.navbar-nav > li > a {
+  text-shadow: 0 1px 0 rgba(255,255,255,.25);
+}
+
+// Inverted navbar
+.navbar-inverse {
+  #gradient > .vertical(@start-color: lighten(@navbar-inverse-bg, 10%); @end-color: @navbar-inverse-bg);
+  .reset-filter(); // Remove gradient in IE<10 to fix bug where dropdowns don't get triggered; see https://github.com/twbs/bootstrap/issues/10257
+
+  .navbar-nav > .open > a,
+  .navbar-nav > .active > a {
+    #gradient > .vertical(@start-color: @navbar-inverse-link-active-bg; @end-color: lighten(@navbar-inverse-link-active-bg, 2.5%));
+    .box-shadow(inset 0 3px 9px rgba(0,0,0,.25));
+  }
+
+  .navbar-brand,
+  .navbar-nav > li > a {
+    text-shadow: 0 -1px 0 rgba(0,0,0,.25);
+  }
+}
+
+// Undo rounded corners in static and fixed navbars
+.navbar-static-top,
+.navbar-fixed-top,
+.navbar-fixed-bottom {
+  border-radius: 0;
+}
+
+// Fix active state of dropdown items in collapsed mode
+@media (max-width: @grid-float-breakpoint-max) {
+  .navbar .navbar-nav .open .dropdown-menu > .active > a {
+    &,
+    &:hover,
+    &:focus {
+      color: #fff;
+      #gradient > .vertical(@start-color: @dropdown-link-active-bg; @end-color: darken(@dropdown-link-active-bg, 5%));
+    }
+  }
+}
+
+
+//
+// Alerts
+// --------------------------------------------------
+
+// Common styles
+.alert {
+  text-shadow: 0 1px 0 rgba(255,255,255,.2);
+  @shadow: inset 0 1px 0 rgba(255,255,255,.25), 0 1px 2px rgba(0,0,0,.05);
+  .box-shadow(@shadow);
+}
+
+// Mixin for generating new styles
+.alert-styles(@color) {
+  #gradient > .vertical(@start-color: @color; @end-color: darken(@color, 7.5%));
+  border-color: darken(@color, 15%);
+}
+
+// Apply the mixin to the alerts
+.alert-success    { .alert-styles(@alert-success-bg); }
+.alert-info       { .alert-styles(@alert-info-bg); }
+.alert-warning    { .alert-styles(@alert-warning-bg); }
+.alert-danger     { .alert-styles(@alert-danger-bg); }
+
+
+//
+// Progress bars
+// --------------------------------------------------
+
+// Give the progress background some depth
+.progress {
+  #gradient > .vertical(@start-color: darken(@progress-bg, 4%); @end-color: @progress-bg)
+}
+
+// Mixin for generating new styles
+.progress-bar-styles(@color) {
+  #gradient > .vertical(@start-color: @color; @end-color: darken(@color, 10%));
+}
+
+// Apply the mixin to the progress bars
+.progress-bar            { .progress-bar-styles(@progress-bar-bg); }
+.progress-bar-success    { .progress-bar-styles(@progress-bar-success-bg); }
+.progress-bar-info       { .progress-bar-styles(@progress-bar-info-bg); }
+.progress-bar-warning    { .progress-bar-styles(@progress-bar-warning-bg); }
+.progress-bar-danger     { .progress-bar-styles(@progress-bar-danger-bg); }
+
+// Reset the striped class because our mixins don't do multiple gradients and
+// the above custom styles override the new `.progress-bar-striped` in v3.2.0.
+.progress-bar-striped {
+  #gradient > .striped();
+}
+
+
+//
+// List groups
+// --------------------------------------------------
+
+.list-group {
+  border-radius: @border-radius-base;
+  .box-shadow(0 1px 2px rgba(0,0,0,.075));
+}
+.list-group-item.active,
+.list-group-item.active:hover,
+.list-group-item.active:focus {
+  text-shadow: 0 -1px 0 darken(@list-group-active-bg, 10%);
+  #gradient > .vertical(@start-color: @list-group-active-bg; @end-color: darken(@list-group-active-bg, 7.5%));
+  border-color: darken(@list-group-active-border, 7.5%);
+
+  .badge {
+    text-shadow: none;
+  }
+}
+
+
+//
+// Panels
+// --------------------------------------------------
+
+// Common styles
+.panel {
+  .box-shadow(0 1px 2px rgba(0,0,0,.05));
+}
+
+// Mixin for generating new styles
+.panel-heading-styles(@color) {
+  #gradient > .vertical(@start-color: @color; @end-color: darken(@color, 5%));
+}
+
+// Apply the mixin to the panel headings only
+.panel-default > .panel-heading   { .panel-heading-styles(@panel-default-heading-bg); }
+.panel-primary > .panel-heading   { .panel-heading-styles(@panel-primary-heading-bg); }
+.panel-success > .panel-heading   { .panel-heading-styles(@panel-success-heading-bg); }
+.panel-info > .panel-heading      { .panel-heading-styles(@panel-info-heading-bg); }
+.panel-warning > .panel-heading   { .panel-heading-styles(@panel-warning-heading-bg); }
+.panel-danger > .panel-heading    { .panel-heading-styles(@panel-danger-heading-bg); }
+
+
+//
+// Wells
+// --------------------------------------------------
+
+.well {
+  #gradient > .vertical(@start-color: darken(@well-bg, 5%); @end-color: @well-bg);
+  border-color: darken(@well-bg, 10%);
+  @shadow: inset 0 1px 3px rgba(0,0,0,.05), 0 1px 0 rgba(255,255,255,.1);
+  .box-shadow(@shadow);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/thumbnails.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/thumbnails.less
new file mode 100644
index 0000000000000000000000000000000000000000..0713e67d0068e9553c5e21bb6024122029cce520
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/thumbnails.less
@@ -0,0 +1,36 @@
+//
+// Thumbnails
+// --------------------------------------------------
+
+
+// Mixin and adjust the regular image class
+.thumbnail {
+  display: block;
+  padding: @thumbnail-padding;
+  margin-bottom: @line-height-computed;
+  line-height: @line-height-base;
+  background-color: @thumbnail-bg;
+  border: 1px solid @thumbnail-border;
+  border-radius: @thumbnail-border-radius;
+  .transition(border .2s ease-in-out);
+
+  > img,
+  a > img {
+    &:extend(.img-responsive);
+    margin-left: auto;
+    margin-right: auto;
+  }
+
+  // Add a hover state for linked versions only
+  a&:hover,
+  a&:focus,
+  a&.active {
+    border-color: @link-color;
+  }
+
+  // Image captions
+  .caption {
+    padding: @thumbnail-caption-padding;
+    color: @thumbnail-caption-color;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/tooltip.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/tooltip.less
new file mode 100644
index 0000000000000000000000000000000000000000..9d5684743309e74514cebc5e5a2e49d876f38c93
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/tooltip.less
@@ -0,0 +1,102 @@
+//
+// Tooltips
+// --------------------------------------------------
+
+
+// Base class
+.tooltip {
+  position: absolute;
+  z-index: @zindex-tooltip;
+  display: block;
+  // Reset font and text properties given new insertion method
+  font-family: @font-family-base;
+  font-size: @font-size-small;
+  font-weight: normal;
+  line-height: 1.4;
+  .opacity(0);
+
+  &.in     { .opacity(@tooltip-opacity); }
+  &.top    { margin-top:  -3px; padding: @tooltip-arrow-width 0; }
+  &.right  { margin-left:  3px; padding: 0 @tooltip-arrow-width; }
+  &.bottom { margin-top:   3px; padding: @tooltip-arrow-width 0; }
+  &.left   { margin-left: -3px; padding: 0 @tooltip-arrow-width; }
+}
+
+// Wrapper for the tooltip content
+.tooltip-inner {
+  max-width: @tooltip-max-width;
+  padding: 3px 8px;
+  color: @tooltip-color;
+  text-align: center;
+  text-decoration: none;
+  background-color: @tooltip-bg;
+  border-radius: @border-radius-base;
+}
+
+// Arrows
+.tooltip-arrow {
+  position: absolute;
+  width: 0;
+  height: 0;
+  border-color: transparent;
+  border-style: solid;
+}
+// Note: Deprecated .top-left, .top-right, .bottom-left, and .bottom-right as of v3.3.1
+.tooltip {
+  &.top .tooltip-arrow {
+    bottom: 0;
+    left: 50%;
+    margin-left: -@tooltip-arrow-width;
+    border-width: @tooltip-arrow-width @tooltip-arrow-width 0;
+    border-top-color: @tooltip-arrow-color;
+  }
+  &.top-left .tooltip-arrow {
+    bottom: 0;
+    right: @tooltip-arrow-width;
+    margin-bottom: -@tooltip-arrow-width;
+    border-width: @tooltip-arrow-width @tooltip-arrow-width 0;
+    border-top-color: @tooltip-arrow-color;
+  }
+  &.top-right .tooltip-arrow {
+    bottom: 0;
+    left: @tooltip-arrow-width;
+    margin-bottom: -@tooltip-arrow-width;
+    border-width: @tooltip-arrow-width @tooltip-arrow-width 0;
+    border-top-color: @tooltip-arrow-color;
+  }
+  &.right .tooltip-arrow {
+    top: 50%;
+    left: 0;
+    margin-top: -@tooltip-arrow-width;
+    border-width: @tooltip-arrow-width @tooltip-arrow-width @tooltip-arrow-width 0;
+    border-right-color: @tooltip-arrow-color;
+  }
+  &.left .tooltip-arrow {
+    top: 50%;
+    right: 0;
+    margin-top: -@tooltip-arrow-width;
+    border-width: @tooltip-arrow-width 0 @tooltip-arrow-width @tooltip-arrow-width;
+    border-left-color: @tooltip-arrow-color;
+  }
+  &.bottom .tooltip-arrow {
+    top: 0;
+    left: 50%;
+    margin-left: -@tooltip-arrow-width;
+    border-width: 0 @tooltip-arrow-width @tooltip-arrow-width;
+    border-bottom-color: @tooltip-arrow-color;
+  }
+  &.bottom-left .tooltip-arrow {
+    top: 0;
+    right: @tooltip-arrow-width;
+    margin-top: -@tooltip-arrow-width;
+    border-width: 0 @tooltip-arrow-width @tooltip-arrow-width;
+    border-bottom-color: @tooltip-arrow-color;
+  }
+  &.bottom-right .tooltip-arrow {
+    top: 0;
+    left: @tooltip-arrow-width;
+    margin-top: -@tooltip-arrow-width;
+    border-width: 0 @tooltip-arrow-width @tooltip-arrow-width;
+    border-bottom-color: @tooltip-arrow-color;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/type.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/type.less
new file mode 100644
index 0000000000000000000000000000000000000000..68ba6017bf184d805a39530f0acd5cbb1495e522
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/type.less
@@ -0,0 +1,302 @@
+//
+// Typography
+// --------------------------------------------------
+
+
+// Headings
+// -------------------------
+
+h1, h2, h3, h4, h5, h6,
+.h1, .h2, .h3, .h4, .h5, .h6 {
+  font-family: @headings-font-family;
+  font-weight: @headings-font-weight;
+  line-height: @headings-line-height;
+  color: @headings-color;
+
+  small,
+  .small {
+    font-weight: normal;
+    line-height: 1;
+    color: @headings-small-color;
+  }
+}
+
+h1, .h1,
+h2, .h2,
+h3, .h3 {
+  margin-top: @line-height-computed;
+  margin-bottom: (@line-height-computed / 2);
+
+  small,
+  .small {
+    font-size: 65%;
+  }
+}
+h4, .h4,
+h5, .h5,
+h6, .h6 {
+  margin-top: (@line-height-computed / 2);
+  margin-bottom: (@line-height-computed / 2);
+
+  small,
+  .small {
+    font-size: 75%;
+  }
+}
+
+h1, .h1 { font-size: @font-size-h1; }
+h2, .h2 { font-size: @font-size-h2; }
+h3, .h3 { font-size: @font-size-h3; }
+h4, .h4 { font-size: @font-size-h4; }
+h5, .h5 { font-size: @font-size-h5; }
+h6, .h6 { font-size: @font-size-h6; }
+
+
+// Body text
+// -------------------------
+
+p {
+  margin: 0 0 (@line-height-computed / 2);
+}
+
+.lead {
+  margin-bottom: @line-height-computed;
+  font-size: floor((@font-size-base * 1.15));
+  font-weight: 300;
+  line-height: 1.4;
+
+  @media (min-width: @screen-sm-min) {
+    font-size: (@font-size-base * 1.5);
+  }
+}
+
+
+// Emphasis & misc
+// -------------------------
+
+// Ex: (12px small font / 14px base font) * 100% = about 85%
+small,
+.small {
+  font-size: floor((100% * @font-size-small / @font-size-base));
+}
+
+mark,
+.mark {
+  background-color: @state-warning-bg;
+  padding: .2em;
+}
+
+// Alignment
+.text-left           { text-align: left; }
+.text-right          { text-align: right; }
+.text-center         { text-align: center; }
+.text-justify        { text-align: justify; }
+.text-nowrap         { white-space: nowrap; }
+
+// Transformation
+.text-lowercase      { text-transform: lowercase; }
+.text-uppercase      { text-transform: uppercase; }
+.text-capitalize     { text-transform: capitalize; }
+
+// Contextual colors
+.text-muted {
+  color: @text-muted;
+}
+.text-primary {
+  .text-emphasis-variant(@brand-primary);
+}
+.text-success {
+  .text-emphasis-variant(@state-success-text);
+}
+.text-info {
+  .text-emphasis-variant(@state-info-text);
+}
+.text-warning {
+  .text-emphasis-variant(@state-warning-text);
+}
+.text-danger {
+  .text-emphasis-variant(@state-danger-text);
+}
+
+// Contextual backgrounds
+// For now we'll leave these alongside the text classes until v4 when we can
+// safely shift things around (per SemVer rules).
+.bg-primary {
+  // Given the contrast here, this is the only class to have its color inverted
+  // automatically.
+  color: #fff;
+  .bg-variant(@brand-primary);
+}
+.bg-success {
+  .bg-variant(@state-success-bg);
+}
+.bg-info {
+  .bg-variant(@state-info-bg);
+}
+.bg-warning {
+  .bg-variant(@state-warning-bg);
+}
+.bg-danger {
+  .bg-variant(@state-danger-bg);
+}
+
+
+// Page header
+// -------------------------
+
+.page-header {
+  padding-bottom: ((@line-height-computed / 2) - 1);
+  margin: (@line-height-computed * 2) 0 @line-height-computed;
+  border-bottom: 1px solid @page-header-border-color;
+}
+
+
+// Lists
+// -------------------------
+
+// Unordered and Ordered lists
+ul,
+ol {
+  margin-top: 0;
+  margin-bottom: (@line-height-computed / 2);
+  ul,
+  ol {
+    margin-bottom: 0;
+  }
+}
+
+// List options
+
+// Unstyled keeps list items block level, just removes default browser padding and list-style
+.list-unstyled {
+  padding-left: 0;
+  list-style: none;
+}
+
+// Inline turns list items into inline-block
+.list-inline {
+  .list-unstyled();
+  margin-left: -5px;
+
+  > li {
+    display: inline-block;
+    padding-left: 5px;
+    padding-right: 5px;
+  }
+}
+
+// Description Lists
+dl {
+  margin-top: 0; // Remove browser default
+  margin-bottom: @line-height-computed;
+}
+dt,
+dd {
+  line-height: @line-height-base;
+}
+dt {
+  font-weight: bold;
+}
+dd {
+  margin-left: 0; // Undo browser default
+}
+
+// Horizontal description lists
+//
+// Defaults to being stacked without any of the below styles applied, until the
+// grid breakpoint is reached (default of ~768px).
+
+.dl-horizontal {
+  dd {
+    &:extend(.clearfix all); // Clear the floated `dt` if an empty `dd` is present
+  }
+
+  @media (min-width: @grid-float-breakpoint) {
+    dt {
+      float: left;
+      width: (@dl-horizontal-offset - 20);
+      clear: left;
+      text-align: right;
+      .text-overflow();
+    }
+    dd {
+      margin-left: @dl-horizontal-offset;
+    }
+  }
+}
+
+
+// Misc
+// -------------------------
+
+// Abbreviations and acronyms
+abbr[title],
+// Add data-* attribute to help out our tooltip plugin, per https://github.com/twbs/bootstrap/issues/5257
+abbr[data-original-title] {
+  cursor: help;
+  border-bottom: 1px dotted @abbr-border-color;
+}
+.initialism {
+  font-size: 90%;
+  .text-uppercase();
+}
+
+// Blockquotes
+blockquote {
+  padding: (@line-height-computed / 2) @line-height-computed;
+  margin: 0 0 @line-height-computed;
+  font-size: @blockquote-font-size;
+  border-left: 5px solid @blockquote-border-color;
+
+  p,
+  ul,
+  ol {
+    &:last-child {
+      margin-bottom: 0;
+    }
+  }
+
+  // Note: Deprecated small and .small as of v3.1.0
+  // Context: https://github.com/twbs/bootstrap/issues/11660
+  footer,
+  small,
+  .small {
+    display: block;
+    font-size: 80%; // back to default font-size
+    line-height: @line-height-base;
+    color: @blockquote-small-color;
+
+    &:before {
+      content: '\2014 \00A0'; // em dash, nbsp
+    }
+  }
+}
+
+// Opposite alignment of blockquote
+//
+// Heads up: `blockquote.pull-right` has been deprecated as of v3.1.0.
+.blockquote-reverse,
+blockquote.pull-right {
+  padding-right: 15px;
+  padding-left: 0;
+  border-right: 5px solid @blockquote-border-color;
+  border-left: 0;
+  text-align: right;
+
+  // Account for citation
+  footer,
+  small,
+  .small {
+    &:before { content: ''; }
+    &:after {
+      content: '\00A0 \2014'; // nbsp, em dash
+    }
+  }
+}
+
+// Addresses
+address {
+  margin-bottom: @line-height-computed;
+  font-style: normal;
+  line-height: @line-height-base;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/utilities.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/utilities.less
new file mode 100644
index 0000000000000000000000000000000000000000..7a8ca27a8ff54db1c439812d4b295d9a1c4f6f76
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/utilities.less
@@ -0,0 +1,55 @@
+//
+// Utility classes
+// --------------------------------------------------
+
+
+// Floats
+// -------------------------
+
+.clearfix {
+  .clearfix();
+}
+.center-block {
+  .center-block();
+}
+.pull-right {
+  float: right !important;
+}
+.pull-left {
+  float: left !important;
+}
+
+
+// Toggling content
+// -------------------------
+
+// Note: Deprecated .hide in favor of .hidden or .sr-only (as appropriate) in v3.0.1
+.hide {
+  display: none !important;
+}
+.show {
+  display: block !important;
+}
+.invisible {
+  visibility: hidden;
+}
+.text-hide {
+  .text-hide();
+}
+
+
+// Hide from screenreaders and browsers
+//
+// Credit: HTML5 Boilerplate
+
+.hidden {
+  display: none !important;
+}
+
+
+// For Affix plugin
+// -------------------------
+
+.affix {
+  position: fixed;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/variables.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/variables.less
new file mode 100644
index 0000000000000000000000000000000000000000..b5fb9d02cf5197e50517a60dae2e3447a032cfe5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/variables.less
@@ -0,0 +1,861 @@
+//
+// Variables
+// --------------------------------------------------
+
+
+//== Colors
+//
+//## Gray and brand colors for use across Bootstrap.
+
+@gray-base:              #000;
+@gray-darker:            lighten(@gray-base, 13.5%); // #222
+@gray-dark:              lighten(@gray-base, 20%);   // #333
+@gray:                   lighten(@gray-base, 33.5%); // #555
+@gray-light:             lighten(@gray-base, 46.7%); // #777
+@gray-lighter:           lighten(@gray-base, 93.5%); // #eee
+
+@brand-primary:         darken(#428bca, 6.5%); // #337ab7
+@brand-success:         #5cb85c;
+@brand-info:            #5bc0de;
+@brand-warning:         #f0ad4e;
+@brand-danger:          #d9534f;
+
+
+//== Scaffolding
+//
+//## Settings for some of the most global styles.
+
+//** Background color for `<body>`.
+@body-bg:               #fff;
+//** Global text color on `<body>`.
+@text-color:            @gray-dark;
+
+//** Global textual link color.
+@link-color:            @brand-primary;
+//** Link hover color set via `darken()` function.
+@link-hover-color:      darken(@link-color, 15%);
+//** Link hover decoration.
+@link-hover-decoration: underline;
+
+
+//== Typography
+//
+//## Font, line-height, and color for body text, headings, and more.
+
+@font-family-sans-serif:  "Helvetica Neue", Helvetica, Arial, sans-serif;
+@font-family-serif:       Georgia, "Times New Roman", Times, serif;
+//** Default monospace fonts for `<code>`, `<kbd>`, and `<pre>`.
+@font-family-monospace:   Menlo, Monaco, Consolas, "Courier New", monospace;
+@font-family-base:        @font-family-sans-serif;
+
+@font-size-base:          14px;
+@font-size-large:         ceil((@font-size-base * 1.25)); // ~18px
+@font-size-small:         ceil((@font-size-base * 0.85)); // ~12px
+
+@font-size-h1:            floor((@font-size-base * 2.6)); // ~36px
+@font-size-h2:            floor((@font-size-base * 2.15)); // ~30px
+@font-size-h3:            ceil((@font-size-base * 1.7)); // ~24px
+@font-size-h4:            ceil((@font-size-base * 1.25)); // ~18px
+@font-size-h5:            @font-size-base;
+@font-size-h6:            ceil((@font-size-base * 0.85)); // ~12px
+
+//** Unit-less `line-height` for use in components like buttons.
+@line-height-base:        1.428571429; // 20/14
+//** Computed "line-height" (`font-size` * `line-height`) for use with `margin`, `padding`, etc.
+@line-height-computed:    floor((@font-size-base * @line-height-base)); // ~20px
+
+//** By default, this inherits from the `<body>`.
+@headings-font-family:    inherit;
+@headings-font-weight:    500;
+@headings-line-height:    1.1;
+@headings-color:          inherit;
+
+
+//== Iconography
+//
+//## Specify custom location and filename of the included Glyphicons icon font. Useful for those including Bootstrap via Bower.
+
+//** Load fonts from this directory.
+@icon-font-path:          "../fonts/";
+//** File name for all font files.
+@icon-font-name:          "glyphicons-halflings-regular";
+//** Element ID within SVG icon file.
+@icon-font-svg-id:        "glyphicons_halflingsregular";
+
+
+//== Components
+//
+//## Define common padding and border radius sizes and more. Values based on 14px text and 1.428 line-height (~20px to start).
+
+@padding-base-vertical:     6px;
+@padding-base-horizontal:   12px;
+
+@padding-large-vertical:    10px;
+@padding-large-horizontal:  16px;
+
+@padding-small-vertical:    5px;
+@padding-small-horizontal:  10px;
+
+@padding-xs-vertical:       1px;
+@padding-xs-horizontal:     5px;
+
+@line-height-large:         1.3333333; // extra decimals for Win 8.1 Chrome
+@line-height-small:         1.5;
+
+@border-radius-base:        4px;
+@border-radius-large:       6px;
+@border-radius-small:       3px;
+
+//** Global color for active items (e.g., navs or dropdowns).
+@component-active-color:    #fff;
+//** Global background color for active items (e.g., navs or dropdowns).
+@component-active-bg:       @brand-primary;
+
+//** Width of the `border` for generating carets that indicator dropdowns.
+@caret-width-base:          4px;
+//** Carets increase slightly in size for larger components.
+@caret-width-large:         5px;
+
+
+//== Tables
+//
+//## Customizes the `.table` component with basic values, each used across all table variations.
+
+//** Padding for `<th>`s and `<td>`s.
+@table-cell-padding:            8px;
+//** Padding for cells in `.table-condensed`.
+@table-condensed-cell-padding:  5px;
+
+//** Default background color used for all tables.
+@table-bg:                      transparent;
+//** Background color used for `.table-striped`.
+@table-bg-accent:               #f9f9f9;
+//** Background color used for `.table-hover`.
+@table-bg-hover:                #f5f5f5;
+@table-bg-active:               @table-bg-hover;
+
+//** Border color for table and cell borders.
+@table-border-color:            #ddd;
+
+
+//== Buttons
+//
+//## For each of Bootstrap's buttons, define text, background and border color.
+
+@btn-font-weight:                normal;
+
+@btn-default-color:              #333;
+@btn-default-bg:                 #fff;
+@btn-default-border:             #ccc;
+
+@btn-primary-color:              #fff;
+@btn-primary-bg:                 @brand-primary;
+@btn-primary-border:             darken(@btn-primary-bg, 5%);
+
+@btn-success-color:              #fff;
+@btn-success-bg:                 @brand-success;
+@btn-success-border:             darken(@btn-success-bg, 5%);
+
+@btn-info-color:                 #fff;
+@btn-info-bg:                    @brand-info;
+@btn-info-border:                darken(@btn-info-bg, 5%);
+
+@btn-warning-color:              #fff;
+@btn-warning-bg:                 @brand-warning;
+@btn-warning-border:             darken(@btn-warning-bg, 5%);
+
+@btn-danger-color:               #fff;
+@btn-danger-bg:                  @brand-danger;
+@btn-danger-border:              darken(@btn-danger-bg, 5%);
+
+@btn-link-disabled-color:        @gray-light;
+
+
+//== Forms
+//
+//##
+
+//** `<input>` background color
+@input-bg:                       #fff;
+//** `<input disabled>` background color
+@input-bg-disabled:              @gray-lighter;
+
+//** Text color for `<input>`s
+@input-color:                    @gray;
+//** `<input>` border color
+@input-border:                   #ccc;
+
+// TODO: Rename `@input-border-radius` to `@input-border-radius-base` in v4
+//** Default `.form-control` border radius
+// This has no effect on `<select>`s in some browsers, due to the limited stylability of `<select>`s in CSS.
+@input-border-radius:            @border-radius-base;
+//** Large `.form-control` border radius
+@input-border-radius-large:      @border-radius-large;
+//** Small `.form-control` border radius
+@input-border-radius-small:      @border-radius-small;
+
+//** Border color for inputs on focus
+@input-border-focus:             #66afe9;
+
+//** Placeholder text color
+@input-color-placeholder:        #999;
+
+//** Default `.form-control` height
+@input-height-base:              (@line-height-computed + (@padding-base-vertical * 2) + 2);
+//** Large `.form-control` height
+@input-height-large:             (ceil(@font-size-large * @line-height-large) + (@padding-large-vertical * 2) + 2);
+//** Small `.form-control` height
+@input-height-small:             (floor(@font-size-small * @line-height-small) + (@padding-small-vertical * 2) + 2);
+
+//** `.form-group` margin
+@form-group-margin-bottom:       15px;
+
+@legend-color:                   @gray-dark;
+@legend-border-color:            #e5e5e5;
+
+//** Background color for textual input addons
+@input-group-addon-bg:           @gray-lighter;
+//** Border color for textual input addons
+@input-group-addon-border-color: @input-border;
+
+//** Disabled cursor for form controls and buttons.
+@cursor-disabled:                not-allowed;
+
+
+//== Dropdowns
+//
+//## Dropdown menu container and contents.
+
+//** Background for the dropdown menu.
+@dropdown-bg:                    #fff;
+//** Dropdown menu `border-color`.
+@dropdown-border:                rgba(0,0,0,.15);
+//** Dropdown menu `border-color` **for IE8**.
+@dropdown-fallback-border:       #ccc;
+//** Divider color for between dropdown items.
+@dropdown-divider-bg:            #e5e5e5;
+
+//** Dropdown link text color.
+@dropdown-link-color:            @gray-dark;
+//** Hover color for dropdown links.
+@dropdown-link-hover-color:      darken(@gray-dark, 5%);
+//** Hover background for dropdown links.
+@dropdown-link-hover-bg:         #f5f5f5;
+
+//** Active dropdown menu item text color.
+@dropdown-link-active-color:     @component-active-color;
+//** Active dropdown menu item background color.
+@dropdown-link-active-bg:        @component-active-bg;
+
+//** Disabled dropdown menu item background color.
+@dropdown-link-disabled-color:   @gray-light;
+
+//** Text color for headers within dropdown menus.
+@dropdown-header-color:          @gray-light;
+
+//** Deprecated `@dropdown-caret-color` as of v3.1.0
+@dropdown-caret-color:           #000;
+
+
+//-- Z-index master list
+//
+// Warning: Avoid customizing these values. They're used for a bird's eye view
+// of components dependent on the z-axis and are designed to all work together.
+//
+// Note: These variables are not generated into the Customizer.
+
+@zindex-navbar:            1000;
+@zindex-dropdown:          1000;
+@zindex-popover:           1060;
+@zindex-tooltip:           1070;
+@zindex-navbar-fixed:      1030;
+@zindex-modal-background:  1040;
+@zindex-modal:             1050;
+
+
+//== Media queries breakpoints
+//
+//## Define the breakpoints at which your layout will change, adapting to different screen sizes.
+
+// Extra small screen / phone
+//** Deprecated `@screen-xs` as of v3.0.1
+@screen-xs:                  480px;
+//** Deprecated `@screen-xs-min` as of v3.2.0
+@screen-xs-min:              @screen-xs;
+//** Deprecated `@screen-phone` as of v3.0.1
+@screen-phone:               @screen-xs-min;
+
+// Small screen / tablet
+//** Deprecated `@screen-sm` as of v3.0.1
+@screen-sm:                  768px;
+@screen-sm-min:              @screen-sm;
+//** Deprecated `@screen-tablet` as of v3.0.1
+@screen-tablet:              @screen-sm-min;
+
+// Medium screen / desktop
+//** Deprecated `@screen-md` as of v3.0.1
+@screen-md:                  992px;
+@screen-md-min:              @screen-md;
+//** Deprecated `@screen-desktop` as of v3.0.1
+@screen-desktop:             @screen-md-min;
+
+// Large screen / wide desktop
+//** Deprecated `@screen-lg` as of v3.0.1
+@screen-lg:                  1200px;
+@screen-lg-min:              @screen-lg;
+//** Deprecated `@screen-lg-desktop` as of v3.0.1
+@screen-lg-desktop:          @screen-lg-min;
+
+// So media queries don't overlap when required, provide a maximum
+@screen-xs-max:              (@screen-sm-min - 1);
+@screen-sm-max:              (@screen-md-min - 1);
+@screen-md-max:              (@screen-lg-min - 1);
+
+
+//== Grid system
+//
+//## Define your custom responsive grid.
+
+//** Number of columns in the grid.
+@grid-columns:              12;
+//** Padding between columns. Gets divided in half for the left and right.
+@grid-gutter-width:         30px;
+// Navbar collapse
+//** Point at which the navbar becomes uncollapsed.
+@grid-float-breakpoint:     @screen-sm-min;
+//** Point at which the navbar begins collapsing.
+@grid-float-breakpoint-max: (@grid-float-breakpoint - 1);
+
+
+//== Container sizes
+//
+//## Define the maximum width of `.container` for different screen sizes.
+
+// Small screen / tablet
+@container-tablet:             (720px + @grid-gutter-width);
+//** For `@screen-sm-min` and up.
+@container-sm:                 @container-tablet;
+
+// Medium screen / desktop
+@container-desktop:            (940px + @grid-gutter-width);
+//** For `@screen-md-min` and up.
+@container-md:                 @container-desktop;
+
+// Large screen / wide desktop
+@container-large-desktop:      (1140px + @grid-gutter-width);
+//** For `@screen-lg-min` and up.
+@container-lg:                 @container-large-desktop;
+
+
+//== Navbar
+//
+//##
+
+// Basics of a navbar
+@navbar-height:                    50px;
+@navbar-margin-bottom:             @line-height-computed;
+@navbar-border-radius:             @border-radius-base;
+@navbar-padding-horizontal:        floor((@grid-gutter-width / 2));
+@navbar-padding-vertical:          ((@navbar-height - @line-height-computed) / 2);
+@navbar-collapse-max-height:       340px;
+
+@navbar-default-color:             #777;
+@navbar-default-bg:                #f8f8f8;
+@navbar-default-border:            darken(@navbar-default-bg, 6.5%);
+
+// Navbar links
+@navbar-default-link-color:                #777;
+@navbar-default-link-hover-color:          #333;
+@navbar-default-link-hover-bg:             transparent;
+@navbar-default-link-active-color:         #555;
+@navbar-default-link-active-bg:            darken(@navbar-default-bg, 6.5%);
+@navbar-default-link-disabled-color:       #ccc;
+@navbar-default-link-disabled-bg:          transparent;
+
+// Navbar brand label
+@navbar-default-brand-color:               @navbar-default-link-color;
+@navbar-default-brand-hover-color:         darken(@navbar-default-brand-color, 10%);
+@navbar-default-brand-hover-bg:            transparent;
+
+// Navbar toggle
+@navbar-default-toggle-hover-bg:           #ddd;
+@navbar-default-toggle-icon-bar-bg:        #888;
+@navbar-default-toggle-border-color:       #ddd;
+
+
+// Inverted navbar
+// Reset inverted navbar basics
+@navbar-inverse-color:                      lighten(@gray-light, 15%);
+@navbar-inverse-bg:                         #222;
+@navbar-inverse-border:                     darken(@navbar-inverse-bg, 10%);
+
+// Inverted navbar links
+@navbar-inverse-link-color:                 lighten(@gray-light, 15%);
+@navbar-inverse-link-hover-color:           #fff;
+@navbar-inverse-link-hover-bg:              transparent;
+@navbar-inverse-link-active-color:          @navbar-inverse-link-hover-color;
+@navbar-inverse-link-active-bg:             darken(@navbar-inverse-bg, 10%);
+@navbar-inverse-link-disabled-color:        #444;
+@navbar-inverse-link-disabled-bg:           transparent;
+
+// Inverted navbar brand label
+@navbar-inverse-brand-color:                @navbar-inverse-link-color;
+@navbar-inverse-brand-hover-color:          #fff;
+@navbar-inverse-brand-hover-bg:             transparent;
+
+// Inverted navbar toggle
+@navbar-inverse-toggle-hover-bg:            #333;
+@navbar-inverse-toggle-icon-bar-bg:         #fff;
+@navbar-inverse-toggle-border-color:        #333;
+
+
+//== Navs
+//
+//##
+
+//=== Shared nav styles
+@nav-link-padding:                          10px 15px;
+@nav-link-hover-bg:                         @gray-lighter;
+
+@nav-disabled-link-color:                   @gray-light;
+@nav-disabled-link-hover-color:             @gray-light;
+
+//== Tabs
+@nav-tabs-border-color:                     #ddd;
+
+@nav-tabs-link-hover-border-color:          @gray-lighter;
+
+@nav-tabs-active-link-hover-bg:             @body-bg;
+@nav-tabs-active-link-hover-color:          @gray;
+@nav-tabs-active-link-hover-border-color:   #ddd;
+
+@nav-tabs-justified-link-border-color:            #ddd;
+@nav-tabs-justified-active-link-border-color:     @body-bg;
+
+//== Pills
+@nav-pills-border-radius:                   @border-radius-base;
+@nav-pills-active-link-hover-bg:            @component-active-bg;
+@nav-pills-active-link-hover-color:         @component-active-color;
+
+
+//== Pagination
+//
+//##
+
+@pagination-color:                     @link-color;
+@pagination-bg:                        #fff;
+@pagination-border:                    #ddd;
+
+@pagination-hover-color:               @link-hover-color;
+@pagination-hover-bg:                  @gray-lighter;
+@pagination-hover-border:              #ddd;
+
+@pagination-active-color:              #fff;
+@pagination-active-bg:                 @brand-primary;
+@pagination-active-border:             @brand-primary;
+
+@pagination-disabled-color:            @gray-light;
+@pagination-disabled-bg:               #fff;
+@pagination-disabled-border:           #ddd;
+
+
+//== Pager
+//
+//##
+
+@pager-bg:                             @pagination-bg;
+@pager-border:                         @pagination-border;
+@pager-border-radius:                  15px;
+
+@pager-hover-bg:                       @pagination-hover-bg;
+
+@pager-active-bg:                      @pagination-active-bg;
+@pager-active-color:                   @pagination-active-color;
+
+@pager-disabled-color:                 @pagination-disabled-color;
+
+
+//== Jumbotron
+//
+//##
+
+@jumbotron-padding:              30px;
+@jumbotron-color:                inherit;
+@jumbotron-bg:                   @gray-lighter;
+@jumbotron-heading-color:        inherit;
+@jumbotron-font-size:            ceil((@font-size-base * 1.5));
+
+
+//== Form states and alerts
+//
+//## Define colors for form feedback states and, by default, alerts.
+
+@state-success-text:             #3c763d;
+@state-success-bg:               #dff0d8;
+@state-success-border:           darken(spin(@state-success-bg, -10), 5%);
+
+@state-info-text:                #31708f;
+@state-info-bg:                  #d9edf7;
+@state-info-border:              darken(spin(@state-info-bg, -10), 7%);
+
+@state-warning-text:             #8a6d3b;
+@state-warning-bg:               #fcf8e3;
+@state-warning-border:           darken(spin(@state-warning-bg, -10), 5%);
+
+@state-danger-text:              #a94442;
+@state-danger-bg:                #f2dede;
+@state-danger-border:            darken(spin(@state-danger-bg, -10), 5%);
+
+
+//== Tooltips
+//
+//##
+
+//** Tooltip max width
+@tooltip-max-width:           200px;
+//** Tooltip text color
+@tooltip-color:               #fff;
+//** Tooltip background color
+@tooltip-bg:                  #000;
+@tooltip-opacity:             .9;
+
+//** Tooltip arrow width
+@tooltip-arrow-width:         5px;
+//** Tooltip arrow color
+@tooltip-arrow-color:         @tooltip-bg;
+
+
+//== Popovers
+//
+//##
+
+//** Popover body background color
+@popover-bg:                          #fff;
+//** Popover maximum width
+@popover-max-width:                   276px;
+//** Popover border color
+@popover-border-color:                rgba(0,0,0,.2);
+//** Popover fallback border color
+@popover-fallback-border-color:       #ccc;
+
+//** Popover title background color
+@popover-title-bg:                    darken(@popover-bg, 3%);
+
+//** Popover arrow width
+@popover-arrow-width:                 10px;
+//** Popover arrow color
+@popover-arrow-color:                 @popover-bg;
+
+//** Popover outer arrow width
+@popover-arrow-outer-width:           (@popover-arrow-width + 1);
+//** Popover outer arrow color
+@popover-arrow-outer-color:           fadein(@popover-border-color, 5%);
+//** Popover outer arrow fallback color
+@popover-arrow-outer-fallback-color:  darken(@popover-fallback-border-color, 20%);
+
+
+//== Labels
+//
+//##
+
+//** Default label background color
+@label-default-bg:            @gray-light;
+//** Primary label background color
+@label-primary-bg:            @brand-primary;
+//** Success label background color
+@label-success-bg:            @brand-success;
+//** Info label background color
+@label-info-bg:               @brand-info;
+//** Warning label background color
+@label-warning-bg:            @brand-warning;
+//** Danger label background color
+@label-danger-bg:             @brand-danger;
+
+//** Default label text color
+@label-color:                 #fff;
+//** Default text color of a linked label
+@label-link-hover-color:      #fff;
+
+
+//== Modals
+//
+//##
+
+//** Padding applied to the modal body
+@modal-inner-padding:         15px;
+
+//** Padding applied to the modal title
+@modal-title-padding:         15px;
+//** Modal title line-height
+@modal-title-line-height:     @line-height-base;
+
+//** Background color of modal content area
+@modal-content-bg:                             #fff;
+//** Modal content border color
+@modal-content-border-color:                   rgba(0,0,0,.2);
+//** Modal content border color **for IE8**
+@modal-content-fallback-border-color:          #999;
+
+//** Modal backdrop background color
+@modal-backdrop-bg:           #000;
+//** Modal backdrop opacity
+@modal-backdrop-opacity:      .5;
+//** Modal header border color
+@modal-header-border-color:   #e5e5e5;
+//** Modal footer border color
+@modal-footer-border-color:   @modal-header-border-color;
+
+@modal-lg:                    900px;
+@modal-md:                    600px;
+@modal-sm:                    300px;
+
+
+//== Alerts
+//
+//## Define alert colors, border radius, and padding.
+
+@alert-padding:               15px;
+@alert-border-radius:         @border-radius-base;
+@alert-link-font-weight:      bold;
+
+@alert-success-bg:            @state-success-bg;
+@alert-success-text:          @state-success-text;
+@alert-success-border:        @state-success-border;
+
+@alert-info-bg:               @state-info-bg;
+@alert-info-text:             @state-info-text;
+@alert-info-border:           @state-info-border;
+
+@alert-warning-bg:            @state-warning-bg;
+@alert-warning-text:          @state-warning-text;
+@alert-warning-border:        @state-warning-border;
+
+@alert-danger-bg:             @state-danger-bg;
+@alert-danger-text:           @state-danger-text;
+@alert-danger-border:         @state-danger-border;
+
+
+//== Progress bars
+//
+//##
+
+//** Background color of the whole progress component
+@progress-bg:                 #f5f5f5;
+//** Progress bar text color
+@progress-bar-color:          #fff;
+//** Variable for setting rounded corners on progress bar.
+@progress-border-radius:      @border-radius-base;
+
+//** Default progress bar color
+@progress-bar-bg:             @brand-primary;
+//** Success progress bar color
+@progress-bar-success-bg:     @brand-success;
+//** Warning progress bar color
+@progress-bar-warning-bg:     @brand-warning;
+//** Danger progress bar color
+@progress-bar-danger-bg:      @brand-danger;
+//** Info progress bar color
+@progress-bar-info-bg:        @brand-info;
+
+
+//== List group
+//
+//##
+
+//** Background color on `.list-group-item`
+@list-group-bg:                 #fff;
+//** `.list-group-item` border color
+@list-group-border:             #ddd;
+//** List group border radius
+@list-group-border-radius:      @border-radius-base;
+
+//** Background color of single list items on hover
+@list-group-hover-bg:           #f5f5f5;
+//** Text color of active list items
+@list-group-active-color:       @component-active-color;
+//** Background color of active list items
+@list-group-active-bg:          @component-active-bg;
+//** Border color of active list elements
+@list-group-active-border:      @list-group-active-bg;
+//** Text color for content within active list items
+@list-group-active-text-color:  lighten(@list-group-active-bg, 40%);
+
+//** Text color of disabled list items
+@list-group-disabled-color:      @gray-light;
+//** Background color of disabled list items
+@list-group-disabled-bg:         @gray-lighter;
+//** Text color for content within disabled list items
+@list-group-disabled-text-color: @list-group-disabled-color;
+
+@list-group-link-color:         #555;
+@list-group-link-hover-color:   @list-group-link-color;
+@list-group-link-heading-color: #333;
+
+
+//== Panels
+//
+//##
+
+@panel-bg:                    #fff;
+@panel-body-padding:          15px;
+@panel-heading-padding:       10px 15px;
+@panel-footer-padding:        @panel-heading-padding;
+@panel-border-radius:         @border-radius-base;
+
+//** Border color for elements within panels
+@panel-inner-border:          #ddd;
+@panel-footer-bg:             #f5f5f5;
+
+@panel-default-text:          @gray-dark;
+@panel-default-border:        #ddd;
+@panel-default-heading-bg:    #f5f5f5;
+
+@panel-primary-text:          #fff;
+@panel-primary-border:        @brand-primary;
+@panel-primary-heading-bg:    @brand-primary;
+
+@panel-success-text:          @state-success-text;
+@panel-success-border:        @state-success-border;
+@panel-success-heading-bg:    @state-success-bg;
+
+@panel-info-text:             @state-info-text;
+@panel-info-border:           @state-info-border;
+@panel-info-heading-bg:       @state-info-bg;
+
+@panel-warning-text:          @state-warning-text;
+@panel-warning-border:        @state-warning-border;
+@panel-warning-heading-bg:    @state-warning-bg;
+
+@panel-danger-text:           @state-danger-text;
+@panel-danger-border:         @state-danger-border;
+@panel-danger-heading-bg:     @state-danger-bg;
+
+
+//== Thumbnails
+//
+//##
+
+//** Padding around the thumbnail image
+@thumbnail-padding:           4px;
+//** Thumbnail background color
+@thumbnail-bg:                @body-bg;
+//** Thumbnail border color
+@thumbnail-border:            #ddd;
+//** Thumbnail border radius
+@thumbnail-border-radius:     @border-radius-base;
+
+//** Custom text color for thumbnail captions
+@thumbnail-caption-color:     @text-color;
+//** Padding around the thumbnail caption
+@thumbnail-caption-padding:   9px;
+
+
+//== Wells
+//
+//##
+
+@well-bg:                     #f5f5f5;
+@well-border:                 darken(@well-bg, 7%);
+
+
+//== Badges
+//
+//##
+
+@badge-color:                 #fff;
+//** Linked badge text color on hover
+@badge-link-hover-color:      #fff;
+@badge-bg:                    @gray-light;
+
+//** Badge text color in active nav link
+@badge-active-color:          @link-color;
+//** Badge background color in active nav link
+@badge-active-bg:             #fff;
+
+@badge-font-weight:           bold;
+@badge-line-height:           1;
+@badge-border-radius:         10px;
+
+
+//== Breadcrumbs
+//
+//##
+
+@breadcrumb-padding-vertical:   8px;
+@breadcrumb-padding-horizontal: 15px;
+//** Breadcrumb background color
+@breadcrumb-bg:                 #f5f5f5;
+//** Breadcrumb text color
+@breadcrumb-color:              #ccc;
+//** Text color of current page in the breadcrumb
+@breadcrumb-active-color:       @gray-light;
+//** Textual separator for between breadcrumb elements
+@breadcrumb-separator:          "/";
+
+
+//== Carousel
+//
+//##
+
+@carousel-text-shadow:                        0 1px 2px rgba(0,0,0,.6);
+
+@carousel-control-color:                      #fff;
+@carousel-control-width:                      15%;
+@carousel-control-opacity:                    .5;
+@carousel-control-font-size:                  20px;
+
+@carousel-indicator-active-bg:                #fff;
+@carousel-indicator-border-color:             #fff;
+
+@carousel-caption-color:                      #fff;
+
+
+//== Close
+//
+//##
+
+@close-font-weight:           bold;
+@close-color:                 #000;
+@close-text-shadow:           0 1px 0 #fff;
+
+
+//== Code
+//
+//##
+
+@code-color:                  #c7254e;
+@code-bg:                     #f9f2f4;
+
+@kbd-color:                   #fff;
+@kbd-bg:                      #333;
+
+@pre-bg:                      #f5f5f5;
+@pre-color:                   @gray-dark;
+@pre-border-color:            #ccc;
+@pre-scrollable-max-height:   340px;
+
+
+//== Type
+//
+//##
+
+//** Horizontal offset for forms and lists.
+@component-offset-horizontal: 180px;
+//** Text muted color
+@text-muted:                  @gray-light;
+//** Abbreviations and acronyms border color
+@abbr-border-color:           @gray-light;
+//** Headings small color
+@headings-small-color:        @gray-light;
+//** Blockquote small color
+@blockquote-small-color:      @gray-light;
+//** Blockquote font size
+@blockquote-font-size:        (@font-size-base * 1.25);
+//** Blockquote border color
+@blockquote-border-color:     @gray-lighter;
+//** Page header border color
+@page-header-border-color:    @gray-lighter;
+//** Width of horizontal description list titles
+@dl-horizontal-offset:        @component-offset-horizontal;
+//** Horizontal line color.
+@hr-border:                   @gray-lighter;
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/wells.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/wells.less
new file mode 100644
index 0000000000000000000000000000000000000000..15d072b0cd0e31d6bd40fad5aa1cb8fb1fbdefd9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/bootstrap/wells.less
@@ -0,0 +1,29 @@
+//
+// Wells
+// --------------------------------------------------
+
+
+// Base class
+.well {
+  min-height: 20px;
+  padding: 19px;
+  margin-bottom: 20px;
+  background-color: @well-bg;
+  border: 1px solid @well-border;
+  border-radius: @border-radius-base;
+  .box-shadow(inset 0 1px 1px rgba(0,0,0,.05));
+  blockquote {
+    border-color: #ddd;
+    border-color: rgba(0,0,0,.15);
+  }
+}
+
+// Sizes
+.well-lg {
+  padding: 24px;
+  border-radius: @border-radius-large;
+}
+.well-sm {
+  padding: 9px;
+  border-radius: @border-radius-small;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/build.py b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/build.py
new file mode 100644
index 0000000000000000000000000000000000000000..e50519a6e928558b85438baccd02bf065dacd69a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/build.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+# Build the documentation.
+
+import errno, os, re, sys
+from subprocess import check_call, CalledProcessError, Popen, PIPE, STDOUT
+
+versions = [
+  '1.0.0', '1.1.0', '2.0.0', '3.0.2', '4.0.0', '4.1.0', '5.0.0', '5.1.0',
+  '5.2.0', '5.2.1', '5.3.0', '6.0.0', '6.1.0', '6.1.1', '6.1.2', '6.2.0',
+  '6.2.1', '7.0.0', '7.0.1', '7.0.2', '7.0.3', '7.1.0', '7.1.1', '7.1.2',
+  '7.1.3', '8.0.0', '8.0.1', '8.1.0', '8.1.1', '9.0.0', '9.1.0']
+versions += ['10.0.0', '10.1.0', '10.1.1', '10.1.1', '10.2.0', '10.2.1']
+
+class Pip:
+  def __init__(self, venv_dir):
+    self.path = os.path.join(venv_dir, 'bin', 'pip')
+
+  def install(self, package, commit=None):
+    "Install package using pip."
+    if commit:
+      package = 'git+https://github.com/{0}.git@{1}'.format(package, commit)
+    print('Installing {0}'.format(package))
+    check_call([self.path, 'install', package])
+
+def create_build_env(venv_dir='virtualenv'):
+  # Create virtualenv.
+  if not os.path.exists(venv_dir):
+    check_call(['python3', '-m', 'venv', venv_dir])
+  # Install Sphinx and Breathe. Require the exact version of Sphinx which is
+  # compatible with Breathe.
+  pip = Pip(venv_dir)
+  pip.install('wheel')
+  pip.install('six')
+  # See: https://github.com/sphinx-doc/sphinx/issues/9777
+  pip.install('docutils==0.17.1')
+  # Jinja2 >= 3.1 incompatible with sphinx 3.3.0
+  # See: https://github.com/sphinx-doc/sphinx/issues/10291
+  pip.install('Jinja2<3.1')
+  pip.install('sphinx==3.3.0')
+  pip.install('michaeljones/breathe', 'v4.25.0')
+
+def build_docs(version='dev', **kwargs):
+  doc_dir = kwargs.get('doc_dir', os.path.dirname(os.path.realpath(__file__)))
+  work_dir = kwargs.get('work_dir', '.')
+  include_dir = kwargs.get(
+      'include_dir', os.path.join(os.path.dirname(doc_dir), 'include', 'fmt'))
+  # Build docs.
+  cmd = ['doxygen', '-']
+  p = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=STDOUT)
+  doxyxml_dir = os.path.join(work_dir, 'doxyxml')
+  out, _ = p.communicate(input=r'''
+      PROJECT_NAME      = fmt
+      GENERATE_LATEX    = NO
+      GENERATE_MAN      = NO
+      GENERATE_RTF      = NO
+      CASE_SENSE_NAMES  = NO
+      INPUT             = {0}/args.h {0}/chrono.h {0}/color.h {0}/core.h \
+                          {0}/compile.h {0}/format.h {0}/os.h {0}/ostream.h \
+                          {0}/printf.h {0}/xchar.h
+      QUIET             = YES
+      JAVADOC_AUTOBRIEF = YES
+      AUTOLINK_SUPPORT  = NO
+      GENERATE_HTML     = NO
+      GENERATE_XML      = YES
+      XML_OUTPUT        = {1}
+      ALIASES           = "rst=\verbatim embed:rst"
+      ALIASES          += "endrst=\endverbatim"
+      MACRO_EXPANSION   = YES
+      PREDEFINED        = _WIN32=1 \
+                          __linux__=1 \
+                          FMT_ENABLE_IF(...)= \
+                          FMT_USE_VARIADIC_TEMPLATES=1 \
+                          FMT_USE_RVALUE_REFERENCES=1 \
+                          FMT_USE_USER_DEFINED_LITERALS=1 \
+                          FMT_USE_ALIAS_TEMPLATES=1 \
+                          FMT_USE_NONTYPE_TEMPLATE_ARGS=1 \
+                          FMT_API= \
+                          "FMT_BEGIN_NAMESPACE=namespace fmt {{" \
+                          "FMT_END_NAMESPACE=}}" \
+                          "FMT_STRING_ALIAS=1" \
+                          "FMT_VARIADIC(...)=" \
+                          "FMT_VARIADIC_W(...)=" \
+                          "FMT_DOC=1"
+      EXCLUDE_SYMBOLS   = fmt::formatter fmt::printf_formatter fmt::arg_join \
+                          fmt::basic_format_arg::handle
+    '''.format(include_dir, doxyxml_dir).encode('UTF-8'))
+  out = out.decode('utf-8')
+  internal_symbols = [
+    'fmt::detail::.*',
+    'basic_data<>',
+    'fmt::type_identity'
+  ]
+  noisy_warnings = [
+    'warning: (Compound|Member .* of class) (' + '|'.join(internal_symbols) + \
+      ') is not documented.',
+    'warning: Internal inconsistency: .* does not belong to any container!'
+  ]
+  for w in noisy_warnings:
+      out = re.sub('.*' + w + '\n', '', out)
+  print(out)
+  if p.returncode != 0:
+    raise CalledProcessError(p.returncode, cmd)
+
+  html_dir = os.path.join(work_dir, 'html')
+  main_versions = reversed(versions[-3:])
+  check_call([os.path.join(work_dir, 'virtualenv', 'bin', 'sphinx-build'),
+              '-Dbreathe_projects.format=' + os.path.abspath(doxyxml_dir),
+              '-Dversion=' + version, '-Drelease=' + version,
+              '-Aversion=' + version, '-Aversions=' + ','.join(main_versions),
+              '-b', 'html', doc_dir, html_dir])
+  try:
+    check_call(['lessc', '--verbose', '--clean-css',
+                '--include-path=' + os.path.join(doc_dir, 'bootstrap'),
+                os.path.join(doc_dir, 'fmt.less'),
+                os.path.join(html_dir, '_static', 'fmt.css')])
+  except OSError as e:
+    if e.errno != errno.ENOENT:
+      raise
+    print('lessc not found; make sure that Less (http://lesscss.org/) ' +
+          'is installed')
+    sys.exit(1)
+  return html_dir
+
+if __name__ == '__main__':
+  create_build_env()
+  build_docs(sys.argv[1])
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/conf.py b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/conf.py
new file mode 100644
index 0000000000000000000000000000000000000000..0756192b6065f1b58f37b7aff42395f52278d83a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/conf.py
@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+#
+# format documentation build configuration file, created by
+# sphinx-quickstart on Tue Dec 18 06:46:16 2012.
+#
+# This file is execfile()d with the current directory set to its containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys, os, re, subprocess
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#sys.path.insert(0, os.path.abspath('.'))
+
+# -- General configuration -----------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+needs_sphinx = '1.2'
+
+if os.environ.get('READTHEDOCS', None) == 'True':
+  subprocess.call('doxygen')
+
+# Add any Sphinx extension module names here, as strings. They can be extensions
+# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+extensions = ['sphinx.ext.ifconfig', 'breathe']
+
+breathe_default_project = "format"
+breathe_domain_by_extension = {"h" : "cpp"}
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix of source filenames.
+source_suffix = '.rst'
+
+# The encoding of source files.
+#source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+#master_doc = 'contents'
+
+# General information about the project.
+project = u'fmt'
+copyright = u'2012-present, Victor Zverovich'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+
+# Version and release are passed from CMake.
+#version = None
+
+# The full version, including alpha/beta/rc tags.
+#release = version
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+#today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = ['virtualenv']
+
+# The reST default role (used for this markup: `text`) to use for all documents.
+default_role = 'cpp:any'
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+highlight_language = 'c++'
+
+primary_domain = 'cpp'
+
+# A list of ignored prefixes for module index sorting.
+#modindex_common_prefix = []
+
+
+# -- Options for HTML output ---------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = 'basic-bootstrap'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+html_theme_path = ['.']
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+#html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+#html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+html_sidebars = {
+  '**': ['localtoc.html', 'relations.html', 'sourcelink.html', 'searchbox.html']
+}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+#html_domain_indices = True
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+#html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+#html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = None
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'formatdoc'
+
+
+# -- Options for LaTeX output --------------------------------------------------
+
+latex_elements = {
+# The paper size ('letterpaper' or 'a4paper').
+#'papersize': 'letterpaper',
+
+# The font size ('10pt', '11pt' or '12pt').
+#'pointsize': '10pt',
+
+# Additional stuff for the LaTeX preamble.
+#'preamble': '',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, documentclass [howto/manual]).
+latex_documents = [
+  ('index', 'format.tex', u'fmt documentation',
+   u'Victor Zverovich', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# If true, show page references after internal links.
+#latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+#latex_show_urls = False
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+#latex_domain_indices = True
+
+
+# -- Options for manual page output --------------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    ('index', 'fmt', u'fmt documentation', [u'Victor Zverovich'], 1)
+]
+
+# If true, show URL addresses after external links.
+#man_show_urls = False
+
+
+# -- Options for Texinfo output ------------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+  ('index', 'fmt', u'fmt documentation',
+   u'Victor Zverovich', 'fmt', 'One line description of project.',
+   'Miscellaneous'),
+]
+
+# Documents to append as an appendix to all manuals.
+#texinfo_appendices = []
+
+# If false, no module index is generated.
+#texinfo_domain_indices = True
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#texinfo_show_urls = 'footnote'
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/contents.rst b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/contents.rst
new file mode 100644
index 0000000000000000000000000000000000000000..d38691e41b102cdab52a5c3d09909ed639859bda
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/contents.rst
@@ -0,0 +1,10 @@
+########
+Contents
+########
+
+.. toctree::
+   :maxdepth: 2
+
+   usage
+   api
+   syntax
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/fmt.less b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/fmt.less
new file mode 100644
index 0000000000000000000000000000000000000000..3a97b9fd84745a5b1a6c8d1b6b11096d86f744b9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/fmt.less
@@ -0,0 +1,71 @@
+@import 'bootstrap.less';
+
+@header-bg: #094d75;
+@icon-font-path: "fonts/";
+
+html {
+  overflow-y: scroll;
+}
+
+.navbar {
+  border-radius: 0;
+  margin-bottom: 0;
+  background-color: darken(@header-bg, 10%);
+}
+
+.jumbotron {
+  #gradient > .vertical(@header-bg; darken(@header-bg, 2%); 50%; 50%);
+  background-size: 100% 4px;
+  background-color: @header-bg;
+  background-repeat: repeat-y;
+  color: white;
+  text-align: center;
+}
+
+div.sphinxsidebar {
+  margin-left: 0;
+}
+
+// Keep content not too wide for better readability.
+.navbar-content, .content {
+  .make-md-column-offset(1);
+  .make-md-column(10);
+  .make-lg-column-offset(2);
+  .make-lg-column(8);
+}
+
+.footer {
+  padding-top: 20px;
+  padding-bottom: 20px;
+  border-top: 1px solid @gray-lighter;
+  text-align: center;
+}
+
+// Indent descriptions of classes, functions and macros.
+.class dd, .function dd, .macro dd {
+  margin-left: 20px;
+}
+
+// Remove Bootstrap padding for Sphinx containers.
+.breathe-sectiondef.container {
+  padding: 0;
+}
+
+// Remove Bootstrap padding for Sphinx code elements in API signatures.
+.descclassname, .descname {
+  padding: 0;
+}
+
+// Override center alignment in tables.
+td {
+  text-align: left;
+}
+
+p.rubric {
+  margin-top: 10px;
+}
+
+.github-btn {
+  border: 0;
+  overflow: hidden;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/index.rst b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/index.rst
new file mode 100644
index 0000000000000000000000000000000000000000..8d55c7a1c652f105fe60e6fcc63a5d897366c959
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/index.rst
@@ -0,0 +1,198 @@
+Overview
+========
+
+**{fmt}** is an open-source formatting library providing a fast and safe
+alternative to C stdio and C++ iostreams.
+
+.. raw:: html
+
+   <div class="panel panel-default">
+     <div class="panel-heading">What users say:</div>
+     <div class="panel-body">
+       Thanks for creating this library. It’s been a hole in C++ for
+       a long time. I’ve used both <code>boost::format</code> and
+       <code>loki::SPrintf</code>, and neither felt like the right answer.
+       This does.
+     </div>
+   </div>
+
+.. _format-api-intro:
+
+Format API
+----------
+
+The format API is similar in spirit to the C ``printf`` family of function but
+is safer, simpler and several times `faster
+<https://www.zverovich.net/2020/06/13/fast-int-to-string-revisited.html>`_
+than common standard library implementations.
+The `format string syntax <syntax.html>`_ is similar to the one used by
+`str.format <https://docs.python.org/3/library/stdtypes.html#str.format>`_ in
+Python:
+
+.. code:: c++
+
+  std::string s = fmt::format("The answer is {}.", 42);
+  
+The ``fmt::format`` function returns a string "The answer is 42.". You can use
+``fmt::memory_buffer`` to avoid constructing ``std::string``:
+
+.. code:: c++
+
+  auto out = fmt::memory_buffer();
+  fmt::format_to(std::back_inserter(out),
+            "For a moment, {} happened.", "nothing");
+  auto data = out.data(); // pointer to the formatted data
+  auto size = out.size(); // size of the formatted data
+
+The ``fmt::print`` function performs formatting and writes the result to a stream:
+
+.. code:: c++
+
+  fmt::print(stderr, "System error code = {}\n", errno);
+
+If you omit the file argument the function will print to ``stdout``:
+
+.. code:: c++
+
+  fmt::print("Don't {}\n", "panic");
+
+The format API also supports positional arguments useful for localization:
+
+.. code:: c++
+
+  fmt::print("I'd rather be {1} than {0}.", "right", "happy");
+
+You can pass named arguments with ``fmt::arg``:
+
+.. code:: c++
+
+  fmt::print("Hello, {name}! The answer is {number}. Goodbye, {name}.",
+             fmt::arg("name", "World"), fmt::arg("number", 42));
+
+If your compiler supports C++11 user-defined literals, the suffix ``_a`` offers 
+an alternative, slightly terser syntax for named arguments:
+
+.. code:: c++
+
+  using namespace fmt::literals;
+  fmt::print("Hello, {name}! The answer is {number}. Goodbye, {name}.",
+             "name"_a="World", "number"_a=42);
+
+.. _safety:
+
+Safety
+------
+
+The library is fully type safe, automatic memory management prevents buffer
+overflow, errors in format strings are reported using exceptions or at compile
+time. For example, the code
+
+.. code:: c++
+
+  fmt::format("The answer is {:d}", "forty-two");
+
+throws the ``format_error`` exception because the argument ``"forty-two"`` is a
+string while the format code ``d`` only applies to integers.
+
+The code
+
+.. code:: c++
+
+  format(FMT_STRING("The answer is {:d}"), "forty-two");
+
+reports a compile-time error on compilers that support relaxed ``constexpr``.
+See `here <api.html#compile-time-format-string-checks>`_ for details.
+
+The following code
+
+.. code:: c++
+
+  fmt::format("Cyrillic letter {}", L'\x42e');
+  
+produces a compile-time error because wide character ``L'\x42e'`` cannot be
+formatted into a narrow string. For comparison, writing a wide character to
+``std::ostream`` results in its numeric value being written to the stream
+(i.e. 1070 instead of letter 'ю' which is represented by ``L'\x42e'`` if we
+use Unicode) which is rarely desirable.
+
+Compact Binary Code
+-------------------
+
+The library produces compact per-call compiled code. For example
+(`godbolt <https://godbolt.org/g/TZU4KF>`_),
+
+.. code:: c++
+
+   #include <fmt/core.h>
+
+   int main() {
+     fmt::print("The answer is {}.", 42);
+   }
+
+compiles to just
+
+.. code:: asm
+
+   main: # @main
+     sub rsp, 24
+     mov qword ptr [rsp], 42
+     mov rcx, rsp
+     mov edi, offset .L.str
+     mov esi, 17
+     mov edx, 1
+     call fmt::v7::vprint(fmt::v7::basic_string_view<char>, fmt::v7::format_args)
+     xor eax, eax
+     add rsp, 24
+     ret
+   .L.str:
+     .asciz "The answer is {}."
+
+.. _portability:
+
+Portability
+-----------
+
+The library is highly portable and relies only on a small set of C++11 features:
+
+* variadic templates
+* type traits
+* rvalue references
+* decltype
+* trailing return types
+* deleted functions
+* alias templates
+
+These are available in GCC 4.8, Clang 3.4, MSVC 19.0 (2015) and more recent
+compiler version. For older compilers use {fmt} `version 4.x
+<https://github.com/fmtlib/fmt/releases/tag/4.1.0>`_ which is maintained and
+only requires C++98.
+
+The output of all formatting functions is consistent across platforms.
+For example,
+
+.. code::
+
+  fmt::print("{}", std::numeric_limits<double>::infinity());
+
+always prints ``inf`` while the output of ``printf`` is platform-dependent.
+
+.. _ease-of-use:
+
+Ease of Use
+-----------
+
+{fmt} has a small self-contained code base with the core library consisting of
+just three header files and no external dependencies.
+A permissive MIT `license <https://github.com/fmtlib/fmt#license>`_ allows
+using the library both in open-source and commercial projects.
+
+`Learn more... <contents.html>`_
+
+.. raw:: html
+
+  <a class="btn btn-success" href="https://github.com/fmtlib/fmt">GitHub Repository</a>
+
+  <div class="section footer">
+    <iframe src="https://ghbtns.com/github-btn.html?user=fmtlib&amp;repo=fmt&amp;type=watch&amp;count=true"
+            class="github-btn" width="100" height="20"></iframe>
+  </div>
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/python-license.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/python-license.txt
new file mode 100644
index 0000000000000000000000000000000000000000..88eed1f9cb05d3e5b248eee7915fd860885107a3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/python-license.txt
@@ -0,0 +1,290 @@
+A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
+as a successor of a language called ABC.  Guido remains Python's
+principal author, although it includes many contributions from others.
+
+In 1995, Guido continued his work on Python at the Corporation for
+National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
+in Reston, Virginia where he released several versions of the
+software.
+
+In May 2000, Guido and the Python core development team moved to
+BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
+year, the PythonLabs team moved to Digital Creations (now Zope
+Corporation, see http://www.zope.com).  In 2001, the Python Software
+Foundation (PSF, see http://www.python.org/psf/) was formed, a
+non-profit organization created specifically to own Python-related
+Intellectual Property.  Zope Corporation is a sponsoring member of
+the PSF.
+
+All Python releases are Open Source (see http://www.opensource.org for
+the Open Source Definition).  Historically, most, but not all, Python
+releases have also been GPL-compatible; the table below summarizes
+the various releases.
+
+    Release         Derived     Year        Owner       GPL-
+                    from                                compatible? (1)
+
+    0.9.0 thru 1.2              1991-1995   CWI         yes
+    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
+    1.6             1.5.2       2000        CNRI        no
+    2.0             1.6         2000        BeOpen.com  no
+    1.6.1           1.6         2001        CNRI        yes (2)
+    2.1             2.0+1.6.1   2001        PSF         no
+    2.0.1           2.0+1.6.1   2001        PSF         yes
+    2.1.1           2.1+2.0.1   2001        PSF         yes
+    2.2             2.1.1       2001        PSF         yes
+    2.1.2           2.1.1       2002        PSF         yes
+    2.1.3           2.1.2       2002        PSF         yes
+    2.2.1           2.2         2002        PSF         yes
+    2.2.2           2.2.1       2002        PSF         yes
+    2.2.3           2.2.2       2003        PSF         yes
+    2.3             2.2.2       2002-2003   PSF         yes
+    2.3.1           2.3         2002-2003   PSF         yes
+    2.3.2           2.3.1       2002-2003   PSF         yes
+    2.3.3           2.3.2       2002-2003   PSF         yes
+    2.3.4           2.3.3       2004        PSF         yes
+    2.3.5           2.3.4       2005        PSF         yes
+    2.4             2.3         2004        PSF         yes
+    2.4.1           2.4         2005        PSF         yes
+    2.4.2           2.4.1       2005        PSF         yes
+    2.4.3           2.4.2       2006        PSF         yes
+    2.4.4           2.4.3       2006        PSF         yes
+    2.5             2.4         2006        PSF         yes
+    2.5.1           2.5         2007        PSF         yes
+    2.5.2           2.5.1       2008        PSF         yes
+    2.5.3           2.5.2       2008        PSF         yes
+    2.6             2.5         2008        PSF         yes
+    2.6.1           2.6         2008        PSF         yes
+    2.6.2           2.6.1       2009        PSF         yes
+    2.6.3           2.6.2       2009        PSF         yes
+    2.6.4           2.6.3       2009        PSF         yes
+    2.6.5           2.6.4       2010        PSF         yes
+    3.0             2.6         2008        PSF         yes
+    3.0.1           3.0         2009        PSF         yes
+    3.1             3.0.1       2009        PSF         yes
+    3.1.1           3.1         2009        PSF         yes
+    3.1.2           3.1.1       2010        PSF         yes
+    3.1.3           3.1.2       2010        PSF         yes
+    3.1.4           3.1.3       2011        PSF         yes
+    3.2             3.1         2011        PSF         yes
+    3.2.1           3.2         2011        PSF         yes
+    3.2.2           3.2.1       2011        PSF         yes
+    3.2.3           3.2.2       2012        PSF         yes
+    3.3.0           3.2         2012        PSF         yes
+
+Footnotes:
+
+(1) GPL-compatible doesn't mean that we're distributing Python under
+    the GPL.  All Python licenses, unlike the GPL, let you distribute
+    a modified version without making your changes open source.  The
+    GPL-compatible licenses make it possible to combine Python with
+    other software that is released under the GPL; the others don't.
+
+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+    because its license has a choice of law clause.  According to
+    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+    is "not incompatible" with the GPL.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012 Python Software Foundation; All Rights Reserved" are retained in Python
+alone or in any derivative version prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions.  Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee.  This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party.  As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee.  Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement.  This Agreement together with
+Python 1.6.1 may be located on the Internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013.  This
+Agreement may also be obtained from a proxy server on the Internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee.  This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+        ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands.  All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, 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.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/syntax.rst b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/syntax.rst
new file mode 100644
index 0000000000000000000000000000000000000000..3c21902c78ed275ae72ea8f157b0609a834a1b5b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/syntax.rst
@@ -0,0 +1,647 @@
+.. _syntax:
+
+********************
+Format String Syntax
+********************
+
+Formatting functions such as :ref:`fmt::format() <format>` and
+:ref:`fmt::print() <print>` use the same format string syntax described in this
+section.
+
+Format strings contain "replacement fields" surrounded by curly braces ``{}``.
+Anything that is not contained in braces is considered literal text, which is
+copied unchanged to the output.  If you need to include a brace character in the
+literal text, it can be escaped by doubling: ``{{`` and ``}}``.
+
+The grammar for a replacement field is as follows:
+
+.. productionlist:: sf
+   replacement_field: "{" [`arg_id`] [":" (`format_spec` | `chrono_format_spec`)] "}"
+   arg_id: `integer` | `identifier`
+   integer: `digit`+
+   digit: "0"..."9"
+   identifier: `id_start` `id_continue`*
+   id_start: "a"..."z" | "A"..."Z" | "_"
+   id_continue: `id_start` | `digit`
+
+In less formal terms, the replacement field can start with an *arg_id*
+that specifies the argument whose value is to be formatted and inserted into
+the output instead of the replacement field.
+The *arg_id* is optionally followed by a *format_spec*, which is preceded by a
+colon ``':'``.  These specify a non-default format for the replacement value.
+
+See also the :ref:`formatspec` section.
+
+If the numerical arg_ids in a format string are 0, 1, 2, ... in sequence,
+they can all be omitted (not just some) and the numbers 0, 1, 2, ... will be
+automatically inserted in that order.
+
+Named arguments can be referred to by their names or indices.
+
+Some simple format string examples::
+
+   "First, thou shalt count to {0}" // References the first argument
+   "Bring me a {}"                  // Implicitly references the first argument
+   "From {} to {}"                  // Same as "From {0} to {1}"
+
+The *format_spec* field contains a specification of how the value should be
+presented, including such details as field width, alignment, padding, decimal
+precision and so on.  Each value type can define its own "formatting
+mini-language" or interpretation of the *format_spec*.
+
+Most built-in types support a common formatting mini-language, which is
+described in the next section.
+
+A *format_spec* field can also include nested replacement fields in certain
+positions within it. These nested replacement fields can contain only an
+argument id; format specifications are not allowed. This allows the formatting
+of a value to be dynamically specified.
+
+See the :ref:`formatexamples` section for some examples.
+
+.. _formatspec:
+
+Format Specification Mini-Language
+==================================
+
+"Format specifications" are used within replacement fields contained within a
+format string to define how individual values are presented (see
+:ref:`syntax`).  Each formattable type may define how the format
+specification is to be interpreted.
+
+Most built-in types implement the following options for format specifications,
+although some of the formatting options are only supported by the numeric types.
+
+The general form of a *standard format specifier* is:
+
+.. productionlist:: sf
+   format_spec: [[`fill`]`align`][`sign`]["#"]["0"][`width`]["." `precision`]["L"][`type`]
+   fill: <a character other than '{' or '}'>
+   align: "<" | ">" | "^"
+   sign: "+" | "-" | " "
+   width: `integer` | "{" [`arg_id`] "}"
+   precision: `integer` | "{" [`arg_id`] "}"
+   type: "a" | "A" | "b" | "B" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" |
+       : "o" | "p" | "s" | "x" | "X" | "?"
+
+The *fill* character can be any Unicode code point other than ``'{'`` or
+``'}'``. The presence of a fill character is signaled by the character following
+it, which must be one of the alignment options. If the second character of
+*format_spec* is not a valid alignment option, then it is assumed that both the
+fill character and the alignment option are absent.
+
+The meaning of the various alignment options is as follows:
+
++---------+----------------------------------------------------------+
+| Option  | Meaning                                                  |
++=========+==========================================================+
+| ``'<'`` | Forces the field to be left-aligned within the available |
+|         | space (this is the default for most objects).            |
++---------+----------------------------------------------------------+
+| ``'>'`` | Forces the field to be right-aligned within the          |
+|         | available space (this is the default for numbers).       |
++---------+----------------------------------------------------------+
+| ``'^'`` | Forces the field to be centered within the available     |
+|         | space.                                                   |
++---------+----------------------------------------------------------+
+
+Note that unless a minimum field width is defined, the field width will always
+be the same size as the data to fill it, so that the alignment option has no
+meaning in this case.
+
+The *sign* option is only valid for floating point and signed integer types,
+and can be one of the following:
+
++---------+------------------------------------------------------------+
+| Option  | Meaning                                                    |
++=========+============================================================+
+| ``'+'`` | indicates that a sign should be used for both              |
+|         | nonnegative as well as negative numbers.                   |
++---------+------------------------------------------------------------+
+| ``'-'`` | indicates that a sign should be used only for negative     |
+|         | numbers (this is the default behavior).                    |
++---------+------------------------------------------------------------+
+| space   | indicates that a leading space should be used on           |
+|         | nonnegative numbers, and a minus sign on negative numbers. |
++---------+------------------------------------------------------------+
+
+The ``'#'`` option causes the "alternate form" to be used for the
+conversion.  The alternate form is defined differently for different
+types.  This option is only valid for integer and floating-point types.
+For integers, when binary, octal, or hexadecimal output is used, this
+option adds the prefix respective ``"0b"`` (``"0B"``), ``"0"``, or
+``"0x"`` (``"0X"``) to the output value.  Whether the prefix is
+lower-case or upper-case is determined by the case of the type
+specifier, for example, the prefix ``"0x"`` is used for the type ``'x'``
+and ``"0X"`` is used for ``'X'``.  For floating-point numbers the
+alternate form causes the result of the conversion to always contain a
+decimal-point character, even if no digits follow it. Normally, a
+decimal-point character appears in the result of these conversions
+only if a digit follows it. In addition, for ``'g'`` and ``'G'``
+conversions, trailing zeros are not removed from the result.
+
+.. ifconfig:: False
+
+   The ``','`` option signals the use of a comma for a thousands separator.
+   For a locale aware separator, use the ``'L'`` integer presentation type
+   instead.
+
+*width* is a decimal integer defining the minimum field width.  If not
+specified, then the field width will be determined by the content.
+
+Preceding the *width* field by a zero (``'0'``) character enables sign-aware
+zero-padding for numeric types. It forces the padding to be placed after the
+sign or base (if any) but before the digits. This is used for printing fields in
+the form '+000000120'. This option is only valid for numeric types and it has no
+effect on formatting of infinity and NaN.
+
+The *precision* is a decimal number indicating how many digits should be
+displayed after the decimal point for a floating-point value formatted with
+``'f'`` and ``'F'``, or before and after the decimal point for a floating-point
+value formatted with ``'g'`` or ``'G'``.  For non-number types the field
+indicates the maximum field size - in other words, how many characters will be
+used from the field content. The *precision* is not allowed for integer,
+character, Boolean, and pointer values. Note that a C string must be
+null-terminated even if precision is specified.
+
+The ``'L'`` option uses the current locale setting to insert the appropriate
+number separator characters. This option is only valid for numeric types.
+
+Finally, the *type* determines how the data should be presented.
+
+The available string presentation types are:
+
++---------+----------------------------------------------------------+
+| Type    | Meaning                                                  |
++=========+==========================================================+
+| ``'s'`` | String format. This is the default type for strings and  |
+|         | may be omitted.                                          |
++---------+----------------------------------------------------------+
+| ``'?'`` | Debug format. The string is quoted and special           |
+|         | characters escaped.                                      |
++---------+----------------------------------------------------------+
+| none    | The same as ``'s'``.                                     |
++---------+----------------------------------------------------------+
+
+The available character presentation types are:
+
++---------+----------------------------------------------------------+
+| Type    | Meaning                                                  |
++=========+==========================================================+
+| ``'c'`` | Character format. This is the default type for           |
+|         | characters and may be omitted.                           |
++---------+----------------------------------------------------------+
+| ``'?'`` | Debug format. The character is quoted and special        |
+|         | characters escaped.                                      |
++---------+----------------------------------------------------------+
+| none    | The same as ``'c'``.                                     |
++---------+----------------------------------------------------------+
+
+The available integer presentation types are:
+
++---------+----------------------------------------------------------+
+| Type    | Meaning                                                  |
++=========+==========================================================+
+| ``'b'`` | Binary format. Outputs the number in base 2. Using the   |
+|         | ``'#'`` option with this type adds the prefix ``"0b"``   |
+|         | to the output value.                                     |
++---------+----------------------------------------------------------+
+| ``'B'`` | Binary format. Outputs the number in base 2. Using the   |
+|         | ``'#'`` option with this type adds the prefix ``"0B"``   |
+|         | to the output value.                                     |
++---------+----------------------------------------------------------+
+| ``'c'`` | Character format. Outputs the number as a character.     |
++---------+----------------------------------------------------------+
+| ``'d'`` | Decimal integer. Outputs the number in base 10.          |
++---------+----------------------------------------------------------+
+| ``'o'`` | Octal format. Outputs the number in base 8.              |
++---------+----------------------------------------------------------+
+| ``'x'`` | Hex format. Outputs the number in base 16, using         |
+|         | lower-case letters for the digits above 9. Using the     |
+|         | ``'#'`` option with this type adds the prefix ``"0x"``   |
+|         | to the output value.                                     |
++---------+----------------------------------------------------------+
+| ``'X'`` | Hex format. Outputs the number in base 16, using         |
+|         | upper-case letters for the digits above 9. Using the     |
+|         | ``'#'`` option with this type adds the prefix ``"0X"``   |
+|         | to the output value.                                     |
++---------+----------------------------------------------------------+
+| none    | The same as ``'d'``.                                     |
++---------+----------------------------------------------------------+
+
+Integer presentation types can also be used with character and Boolean values
+with the only exception that ``'c'`` cannot be used with `bool`. Boolean values
+are formatted using textual representation, either ``true`` or ``false``, if the
+presentation type is not specified.
+
+The available presentation types for floating-point values are:
+
++---------+----------------------------------------------------------+
+| Type    | Meaning                                                  |
++=========+==========================================================+
+| ``'a'`` | Hexadecimal floating point format. Prints the number in  |
+|         | base 16 with prefix ``"0x"`` and lower-case letters for  |
+|         | digits above 9. Uses ``'p'`` to indicate the exponent.   |
++---------+----------------------------------------------------------+
+| ``'A'`` | Same as ``'a'`` except it uses upper-case letters for    |
+|         | the prefix, digits above 9 and to indicate the exponent. |
++---------+----------------------------------------------------------+
+| ``'e'`` | Exponent notation. Prints the number in scientific       |
+|         | notation using the letter 'e' to indicate the exponent.  |
++---------+----------------------------------------------------------+
+| ``'E'`` | Exponent notation. Same as ``'e'`` except it uses an     |
+|         | upper-case ``'E'`` as the separator character.           |
++---------+----------------------------------------------------------+
+| ``'f'`` | Fixed point. Displays the number as a fixed-point        |
+|         | number.                                                  |
++---------+----------------------------------------------------------+
+| ``'F'`` | Fixed point. Same as ``'f'``, but converts ``nan`` to    |
+|         | ``NAN`` and ``inf`` to ``INF``.                          |
++---------+----------------------------------------------------------+
+| ``'g'`` | General format.  For a given precision ``p >= 1``,       |
+|         | this rounds the number to ``p`` significant digits and   |
+|         | then formats the result in either fixed-point format     |
+|         | or in scientific notation, depending on its magnitude.   |
+|         |                                                          |
+|         | A precision of ``0`` is treated as equivalent to a       |
+|         | precision of ``1``.                                      |
++---------+----------------------------------------------------------+
+| ``'G'`` | General format. Same as ``'g'`` except switches to       |
+|         | ``'E'`` if the number gets too large. The                |
+|         | representations of infinity and NaN are uppercased, too. |
++---------+----------------------------------------------------------+
+| none    | Similar to ``'g'``, except that the default precision is |
+|         | as high as needed to represent the particular value.     |
++---------+----------------------------------------------------------+
+
+.. ifconfig:: False
+
+   +---------+----------------------------------------------------------+
+   |         | The precise rules are as follows: suppose that the       |
+   |         | result formatted with presentation type ``'e'`` and      |
+   |         | precision ``p-1`` would have exponent ``exp``.  Then     |
+   |         | if ``-4 <= exp < p``, the number is formatted            |
+   |         | with presentation type ``'f'`` and precision             |
+   |         | ``p-1-exp``.  Otherwise, the number is formatted         |
+   |         | with presentation type ``'e'`` and precision ``p-1``.    |
+   |         | In both cases insignificant trailing zeros are removed   |
+   |         | from the significand, and the decimal point is also      |
+   |         | removed if there are no remaining digits following it.   |
+   |         |                                                          |
+   |         | Positive and negative infinity, positive and negative    |
+   |         | zero, and nans, are formatted as ``inf``, ``-inf``,      |
+   |         | ``0``, ``-0`` and ``nan`` respectively, regardless of    |
+   |         | the precision.                                           |
+   |         |                                                          |
+   +---------+----------------------------------------------------------+
+
+The available presentation types for pointers are:
+
++---------+----------------------------------------------------------+
+| Type    | Meaning                                                  |
++=========+==========================================================+
+| ``'p'`` | Pointer format. This is the default type for             |
+|         | pointers and may be omitted.                             |
++---------+----------------------------------------------------------+
+| none    | The same as ``'p'``.                                     |
++---------+----------------------------------------------------------+
+
+.. _chrono-specs:
+
+Chrono Format Specifications
+============================
+
+Format specifications for chrono duration and time point types as well as
+``std::tm`` have the following syntax:
+
+.. productionlist:: sf
+   chrono_format_spec: [[`fill`]`align`][`width`]["." `precision`][`chrono_specs`]
+   chrono_specs: [`chrono_specs`] `conversion_spec` | `chrono_specs` `literal_char`
+   conversion_spec: "%" [`modifier`] `chrono_type`
+   literal_char: <a character other than '{', '}' or '%'>
+   modifier: "E" | "O"
+   chrono_type: "a" | "A" | "b" | "B" | "c" | "C" | "d" | "D" | "e" | "F" |
+              : "g" | "G" | "h" | "H" | "I" | "j" | "m" | "M" | "n" | "p" |
+              : "q" | "Q" | "r" | "R" | "S" | "t" | "T" | "u" | "U" | "V" |
+              : "w" | "W" | "x" | "X" | "y" | "Y" | "z" | "Z" | "%"
+
+Literal chars are copied unchanged to the output. Precision is valid only for
+``std::chrono::duration`` types with a floating-point representation type.
+
+The available presentation types (*chrono_type*) are:
+
++---------+--------------------------------------------------------------------+
+| Type    | Meaning                                                            |
++=========+====================================================================+
+| ``'a'`` | The abbreviated weekday name, e.g. "Sat". If the value does not    |
+|         | contain a valid weekday, an exception of type ``format_error`` is  |
+|         | thrown.                                                            |
++---------+--------------------------------------------------------------------+
+| ``'A'`` | The full weekday name, e.g. "Saturday". If the value does not      |
+|         | contain a valid weekday, an exception of type ``format_error`` is  |
+|         | thrown.                                                            |
++---------+--------------------------------------------------------------------+
+| ``'b'`` | The abbreviated month name, e.g. "Nov". If the value does not      |
+|         | contain a valid month, an exception of type ``format_error`` is    |
+|         | thrown.                                                            |
++---------+--------------------------------------------------------------------+
+| ``'B'`` | The full month name, e.g. "November". If the value does not        |
+|         | contain a valid month, an exception of type ``format_error`` is    |
+|         | thrown.                                                            |
++---------+--------------------------------------------------------------------+
+| ``'c'`` | The date and time representation, e.g. "Sat Nov 12 22:04:00 1955". |
+|         | The modified command ``%Ec`` produces the locale's alternate date  |
+|         | and time representation.                                           |
++---------+--------------------------------------------------------------------+
+| ``'C'`` | The year divided by 100 using floored division, e.g. "55". If the  |
+|         | result is a single decimal digit, it is prefixed with 0.           |
+|         | The modified command ``%EC`` produces the locale's alternative     |
+|         | representation of the century.                                     |
++---------+--------------------------------------------------------------------+
+| ``'d'`` | The day of month as a decimal number. If the result is a single    |
+|         | decimal digit, it is prefixed with 0. The modified command ``%Od`` |
+|         | produces the locale's alternative representation.                  |
++---------+--------------------------------------------------------------------+
+| ``'D'`` | Equivalent to ``%m/%d/%y``, e.g. "11/12/55".                       |
++---------+--------------------------------------------------------------------+
+| ``'e'`` | The day of month as a decimal number. If the result is a single    |
+|         | decimal digit, it is prefixed with a space. The modified command   |
+|         | ``%Oe`` produces the locale's alternative representation.          |
++---------+--------------------------------------------------------------------+
+| ``'F'`` | Equivalent to ``%Y-%m-%d``, e.g. "1955-11-12".                     |
++---------+--------------------------------------------------------------------+
+| ``'g'`` | The last two decimal digits of the ISO week-based year. If the     |
+|         | result is a single digit it is prefixed by 0.                      |
++---------+--------------------------------------------------------------------+
+| ``'G'`` | The ISO week-based year as a decimal number. If the result is less |
+|         | than four digits it is left-padded with 0 to four digits.          |
++---------+--------------------------------------------------------------------+
+| ``'h'`` | Equivalent to ``%b``, e.g. "Nov".                                  |
++---------+--------------------------------------------------------------------+
+| ``'H'`` | The hour (24-hour clock) as a decimal number. If the result is a   |
+|         | single digit, it is prefixed with 0. The modified command ``%OH``  |
+|         | produces the locale's alternative representation.                  |
++---------+--------------------------------------------------------------------+
+| ``'I'`` | The hour (12-hour clock) as a decimal number. If the result is a   |
+|         | single digit, it is prefixed with 0. The modified command ``%OI``  |
+|         | produces the locale's alternative representation.                  |
++---------+--------------------------------------------------------------------+
+| ``'j'`` | If the type being formatted is a specialization of duration, the   |
+|         | decimal number of days without padding. Otherwise, the day of the  |
+|         | year as a decimal number. Jan 1 is 001. If the result is less than |
+|         | three digits, it is left-padded with 0 to three digits.            |
++---------+--------------------------------------------------------------------+
+| ``'m'`` | The month as a decimal number. Jan is 01. If the result is a       |
+|         | single digit, it is prefixed with 0. The modified command ``%Om``  |
+|         | produces the locale's alternative representation.                  |
++---------+--------------------------------------------------------------------+
+| ``'M'`` | The minute as a decimal number. If the result is a single digit,   |
+|         | it is prefixed with 0. The modified command ``%OM`` produces the   |
+|         | locale's alternative representation.                               |
++---------+--------------------------------------------------------------------+
+| ``'n'`` | A new-line character.                                              |
++---------+--------------------------------------------------------------------+
+| ``'p'`` | The AM/PM designations associated with a 12-hour clock.            |
++---------+--------------------------------------------------------------------+
+| ``'q'`` | The duration's unit suffix.                                        |
++---------+--------------------------------------------------------------------+
+| ``'Q'`` | The duration's numeric value (as if extracted via ``.count()``).   |
++---------+--------------------------------------------------------------------+
+| ``'r'`` | The 12-hour clock time, e.g. "10:04:00 PM".                        |
++---------+--------------------------------------------------------------------+
+| ``'R'`` | Equivalent to ``%H:%M``, e.g. "22:04".                             |
++---------+--------------------------------------------------------------------+
+| ``'S'`` | Seconds as a decimal number. If the number of seconds is less than |
+|         | 10, the result is prefixed with 0. If the precision of the input   |
+|         | cannot be exactly represented with seconds, then the format is a   |
+|         | decimal floating-point number with a fixed format and a precision  |
+|         | matching that of the precision of the input (or to a microseconds  |
+|         | precision if the conversion to floating-point decimal seconds      |
+|         | cannot be made within 18 fractional digits). The character for the |
+|         | decimal point is localized according to the locale. The modified   |
+|         | command ``%OS`` produces the locale's alternative representation.  |
++---------+--------------------------------------------------------------------+
+| ``'t'`` | A horizontal-tab character.                                        |
++---------+--------------------------------------------------------------------+
+| ``'T'`` | Equivalent to ``%H:%M:%S``.                                        |
++---------+--------------------------------------------------------------------+
+| ``'u'`` | The ISO weekday as a decimal number (1-7), where Monday is 1. The  |
+|         | modified command ``%Ou`` produces the locale's alternative         |
+|         | representation.                                                    |
++---------+--------------------------------------------------------------------+
+| ``'U'`` | The week number of the year as a decimal number. The first Sunday  |
+|         | of the year is the first day of week 01. Days of the same year     |
+|         | prior to that are in week 00. If the result is a single digit, it  |
+|         | is prefixed with 0. The modified command ``%OU`` produces the      |
+|         | locale's alternative representation.                               |
++---------+--------------------------------------------------------------------+
+| ``'V'`` | The ISO week-based week number as a decimal number. If the result  |
+|         | is a single digit, it is prefixed with 0. The modified command     |
+|         | ``%OV`` produces the locale's alternative representation.          |
++---------+--------------------------------------------------------------------+
+| ``'w'`` | The weekday as a decimal number (0-6), where Sunday is 0.          |
+|         | The modified command ``%Ow`` produces the locale's alternative     |
+|         | representation.                                                    |
++---------+--------------------------------------------------------------------+
+| ``'W'`` | The week number of the year as a decimal number. The first Monday  |
+|         | of the year is the first day of week 01. Days of the same year     |
+|         | prior to that are in week 00. If the result is a single digit, it  |
+|         | is prefixed with 0. The modified command ``%OW`` produces the      |
+|         | locale's alternative representation.                               |
++---------+--------------------------------------------------------------------+
+| ``'x'`` | The date representation, e.g. "11/12/55". The modified command     |
+|         | ``%Ex`` produces the locale's alternate date representation.       |
++---------+--------------------------------------------------------------------+
+| ``'X'`` | The time representation, e.g. "10:04:00". The modified command     |
+|         | ``%EX`` produces the locale's alternate time representation.       |
++---------+--------------------------------------------------------------------+
+| ``'y'`` | The last two decimal digits of the year. If the result is a single |
+|         | digit it is prefixed by 0. The modified command ``%Oy`` produces   |
+|         | the locale's alternative representation. The modified command      |
+|         | ``%Ey`` produces the locale's alternative representation of offset |
+|         | from ``%EC`` (year only).                                          |
++---------+--------------------------------------------------------------------+
+| ``'Y'`` | The year as a decimal number. If the result is less than four      |
+|         | digits it is left-padded with 0 to four digits. The modified       |
+|         | command ``%EY`` produces the locale's alternative full year        |
+|         | representation.                                                    |
++---------+--------------------------------------------------------------------+
+| ``'z'`` | The offset from UTC in the ISO 8601:2004 format. For example -0430 |
+|         | refers to 4 hours 30 minutes behind UTC. If the offset is zero,    |
+|         | +0000 is used. The modified commands ``%Ez`` and ``%Oz`` insert a  |
+|         | ``:`` between the hours and minutes: -04:30. If the offset         |
+|         | information is not available, an exception of type                 |
+|         | ``format_error`` is thrown.                                        |
++---------+--------------------------------------------------------------------+
+| ``'Z'`` | The time zone abbreviation. If the time zone abbreviation is not   |
+|         | available, an exception of type ``format_error`` is thrown.        |
++---------+--------------------------------------------------------------------+
+| ``'%'`` | A % character.                                                     |
++---------+--------------------------------------------------------------------+
+
+Specifiers that have a calendaric component such as ``'d'`` (the day of month)
+are valid only for ``std::tm`` and time points but not durations.
+
+.. range-specs:
+
+Range Format Specifications
+===========================
+
+Format specifications for range types have the following syntax:
+
+.. productionlist:: sf
+   range_format_spec: [":" [`underlying_spec`]]
+
+The `underlying_spec` is parsed based on the formatter of the range's
+reference type.
+
+By default, a range of characters or strings is printed escaped and quoted. But
+if any `underlying_spec` is provided (even if it is empty), then the characters
+or strings are printed according to the provided specification.
+
+Examples::
+
+  fmt::format("{}", std::vector{10, 20, 30});
+  // Result: [10, 20, 30]
+  fmt::format("{::#x}", std::vector{10, 20, 30});
+  // Result: [0xa, 0x14, 0x1e]
+  fmt::format("{}", vector{'h', 'e', 'l', 'l', 'o'});
+  // Result: ['h', 'e', 'l', 'l', 'o']
+  fmt::format("{::}", vector{'h', 'e', 'l', 'l', 'o'});
+  // Result: [h, e, l, l, o]
+  fmt::format("{::d}", vector{'h', 'e', 'l', 'l', 'o'});
+  // Result: [104, 101, 108, 108, 111]
+
+.. _formatexamples:
+
+Format Examples
+===============
+
+This section contains examples of the format syntax and comparison with
+the printf formatting.
+
+In most of the cases the syntax is similar to the printf formatting, with the
+addition of the ``{}`` and with ``:`` used instead of ``%``.
+For example, ``"%03.2f"`` can be translated to ``"{:03.2f}"``.
+
+The new format syntax also supports new and different options, shown in the
+following examples.
+
+Accessing arguments by position::
+
+   fmt::format("{0}, {1}, {2}", 'a', 'b', 'c');
+   // Result: "a, b, c"
+   fmt::format("{}, {}, {}", 'a', 'b', 'c');
+   // Result: "a, b, c"
+   fmt::format("{2}, {1}, {0}", 'a', 'b', 'c');
+   // Result: "c, b, a"
+   fmt::format("{0}{1}{0}", "abra", "cad");  // arguments' indices can be repeated
+   // Result: "abracadabra"
+
+Aligning the text and specifying a width::
+
+   fmt::format("{:<30}", "left aligned");
+   // Result: "left aligned                  "
+   fmt::format("{:>30}", "right aligned");
+   // Result: "                 right aligned"
+   fmt::format("{:^30}", "centered");
+   // Result: "           centered           "
+   fmt::format("{:*^30}", "centered");  // use '*' as a fill char
+   // Result: "***********centered***********"
+
+Dynamic width::
+
+   fmt::format("{:<{}}", "left aligned", 30);
+   // Result: "left aligned                  "
+
+Dynamic precision::
+
+   fmt::format("{:.{}f}", 3.14, 1);
+   // Result: "3.1"
+
+Replacing ``%+f``, ``%-f``, and ``% f`` and specifying a sign::
+
+   fmt::format("{:+f}; {:+f}", 3.14, -3.14);  // show it always
+   // Result: "+3.140000; -3.140000"
+   fmt::format("{: f}; {: f}", 3.14, -3.14);  // show a space for positive numbers
+   // Result: " 3.140000; -3.140000"
+   fmt::format("{:-f}; {:-f}", 3.14, -3.14);  // show only the minus -- same as '{:f}; {:f}'
+   // Result: "3.140000; -3.140000"
+
+Replacing ``%x`` and ``%o`` and converting the value to different bases::
+
+   fmt::format("int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
+   // Result: "int: 42;  hex: 2a;  oct: 52; bin: 101010"
+   // with 0x or 0 or 0b as prefix:
+   fmt::format("int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}", 42);
+   // Result: "int: 42;  hex: 0x2a;  oct: 052;  bin: 0b101010"
+
+Padded hex byte with prefix and always prints both hex characters::
+
+   fmt::format("{:#04x}", 0);
+   // Result: "0x00"
+
+Box drawing using Unicode fill::
+
+   fmt::print(
+     "┌{0:─^{2}}┐\n"
+     "│{1: ^{2}}│\n"
+     "└{0:─^{2}}┘\n", "", "Hello, world!", 20);
+
+prints::
+
+   ┌────────────────────┐
+   │   Hello, world!    │
+   └────────────────────┘
+
+Using type-specific formatting::
+
+   #include <fmt/chrono.h>
+
+   auto t = tm();
+   t.tm_year = 2010 - 1900;
+   t.tm_mon = 7;
+   t.tm_mday = 4;
+   t.tm_hour = 12;
+   t.tm_min = 15;
+   t.tm_sec = 58;
+   fmt::print("{:%Y-%m-%d %H:%M:%S}", t);
+   // Prints: 2010-08-04 12:15:58
+
+Using the comma as a thousands separator::
+
+   #include <fmt/format.h>
+
+   auto s = fmt::format(std::locale("en_US.UTF-8"), "{:L}", 1234567890);
+   // s == "1,234,567,890"
+
+.. ifconfig:: False
+
+   Nesting arguments and more complex examples::
+
+      >>> for align, text in zip('<^>', ['left', 'center', 'right']):
+      ...     '{0:{fill}{align}16}") << text, fill=align, align=align)
+      ...
+      'left<<<<<<<<<<<<'
+      '^^^^^center^^^^^'
+      '>>>>>>>>>>>right'
+      >>>
+      >>> octets = [192, 168, 0, 1]
+      Format("{:02X}{:02X}{:02X}{:02X}") << *octets)
+      'C0A80001'
+      >>> int(_, 16)
+      3232235521
+      >>>
+      >>> width = 5
+      >>> for num in range(5,12):
+      ...     for base in 'dXob':
+      ...         print('{0:{width}{base}}") << num, base=base, width=width), end=' ')
+      ...     print()
+      ...
+          5     5     5   101
+          6     6     6   110
+          7     7     7   111
+          8     8    10  1000
+          9     9    11  1001
+         10     A    12  1010
+         11     B    13  1011
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/usage.rst b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/usage.rst
new file mode 100644
index 0000000000000000000000000000000000000000..717fd1cdf9a7b890f46fa535cfc8aa3f88a69743
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/doc/usage.rst
@@ -0,0 +1,250 @@
+*****
+Usage
+*****
+
+To use the {fmt} library, add :file:`fmt/core.h`, :file:`fmt/format.h`,
+:file:`fmt/format-inl.h`, :file:`src/format.cc` and optionally other headers
+from a `release archive <https://github.com/fmtlib/fmt/releases/latest>`_ or
+the `Git repository <https://github.com/fmtlib/fmt>`_ to your project.
+Alternatively, you can :ref:`build the library with CMake <building>`.
+
+.. _building:
+
+Building the Library
+====================
+
+The included `CMake build script`__ can be used to build the fmt
+library on a wide range of platforms. CMake is freely available for
+download from https://www.cmake.org/download/.
+
+__ https://github.com/fmtlib/fmt/blob/master/CMakeLists.txt
+
+CMake works by generating native makefiles or project files that can
+be used in the compiler environment of your choice. The typical
+workflow starts with::
+
+  mkdir build          # Create a directory to hold the build output.
+  cd build
+  cmake ..  # Generate native build scripts.
+
+where :file:`{<path/to/fmt>}` is a path to the ``fmt`` repository.
+
+If you are on a \*nix system, you should now see a Makefile in the
+current directory. Now you can build the library by running :command:`make`.
+
+Once the library has been built you can invoke :command:`make test` to run
+the tests.
+
+You can control generation of the make ``test`` target with the ``FMT_TEST``
+CMake option. This can be useful if you include fmt as a subdirectory in
+your project but don't want to add fmt's tests to your ``test`` target.
+
+If you use Windows and have Visual Studio installed, a :file:`FMT.sln`
+file and several :file:`.vcproj` files will be created. You can then build them
+using Visual Studio or msbuild.
+
+On Mac OS X with Xcode installed, an :file:`.xcodeproj` file will be generated.
+
+To build a `shared library`__ set the ``BUILD_SHARED_LIBS`` CMake variable to
+``TRUE``::
+
+  cmake -DBUILD_SHARED_LIBS=TRUE ...
+
+__ https://en.wikipedia.org/wiki/Library_%28computing%29#Shared_libraries
+
+
+To build a `static library` with position independent code (required if the main
+consumer of the fmt library is a shared library i.e. a Python extension) set the
+``CMAKE_POSITION_INDEPENDENT_CODE`` CMake variable to ``TRUE``::
+
+  cmake -DCMAKE_POSITION_INDEPENDENT_CODE=TRUE ...
+
+
+Installing the Library
+======================
+
+After building the library you can install it on a Unix-like system by running
+:command:`sudo make install`.
+
+Usage with CMake
+================
+
+You can add the ``fmt`` library directory into your project and include it in
+your ``CMakeLists.txt`` file::
+
+   add_subdirectory(fmt)
+
+or
+
+::
+
+   add_subdirectory(fmt EXCLUDE_FROM_ALL)
+
+to exclude it from ``make``, ``make all``, or ``cmake --build .``.
+
+You can detect and use an installed version of {fmt} as follows::
+
+   find_package(fmt)
+   target_link_libraries(<your-target> fmt::fmt)
+
+Setting up your target to use a header-only version of ``fmt`` is equally easy::
+
+   target_link_libraries(<your-target> PRIVATE fmt::fmt-header-only)
+
+Usage with build2
+=================
+
+You can use `build2 <https://build2.org>`_, a dependency manager and a
+build-system combined, to use ``fmt``.
+
+Currently this package is available in these package repositories:
+
+- **https://cppget.org/fmt/** for released and published versions.
+- `The git repository with the sources of the build2 package of fmt <https://github.com/build2-packaging/fmt.git>`_
+  for unreleased or custom revisions of ``fmt``.
+
+**Usage:**
+
+- ``build2`` package name: ``fmt``
+- Library target name : ``lib{fmt}``
+
+For example, to make your ``build2`` project depend on ``fmt``:
+
+- Add one of the repositories to your configurations, or in your
+  ``repositories.manifest``, if not already there::
+
+    :
+    role: prerequisite
+    location: https://pkg.cppget.org/1/stable
+
+- Add this package as a dependency to your ``./manifest`` file
+  (example for ``v7.0.x``)::
+
+    depends: fmt ~7.0.0
+
+- Import the target and use it as a prerequisite to your own target
+  using `fmt` in the appropriate ``buildfile``::
+
+    import fmt = fmt%lib{fmt}
+    lib{mylib} : cxx{**} ... $fmt
+
+Then build your project as usual with `b` or `bdep update`.
+
+For ``build2`` newcomers or to get more details and use cases, you can read the
+``build2``
+`toolchain introduction <https://build2.org/build2-toolchain/doc/build2-toolchain-intro.xhtml>`_.
+
+Usage with Meson
+================
+
+`Meson's WrapDB <https://mesonbuild.com/Wrapdb-projects.html>` includes a ``fmt``
+package, which repackages fmt to be built by Meson as a subproject.
+
+**Usage:**
+
+- Install the ``fmt`` subproject from the WrapDB by running::
+
+    meson wrap install fmt
+
+  from the root of your project.
+
+- In your project's ``meson.build`` file, add an entry for the new subproject::
+
+    fmt = subproject('fmt')
+    fmt_dep = fmt.get_variable('fmt_dep')
+
+- Include the new dependency object to link with fmt::
+
+    my_build_target = executable('name', 'src/main.cc', dependencies: [fmt_dep])
+
+**Options:**
+
+If desired, ``fmt`` may be built as a static library, or as a header-only
+library.
+
+For a static build, use the following subproject definition::
+
+  fmt = subproject('fmt', default_options: 'default_library=static')
+  fmt_dep = fmt.get_variable('fmt_dep')
+
+For the header-only version, use::
+
+  fmt = subproject('fmt')
+  fmt_dep = fmt.get_variable('fmt_header_only_dep')
+
+Building the Documentation
+==========================
+
+To build the documentation you need the following software installed on your
+system:
+
+* `Python <https://www.python.org/>`_ with pip and virtualenv
+* `Doxygen <http://www.stack.nl/~dimitri/doxygen/>`_
+* `Less <http://lesscss.org/>`_ with ``less-plugin-clean-css``.
+  Ubuntu doesn't package the ``clean-css`` plugin so you should use ``npm``
+  instead of ``apt`` to install both ``less`` and the plugin::
+
+    sudo npm install -g less less-plugin-clean-css.
+
+First generate makefiles or project files using CMake as described in
+the previous section. Then compile the ``doc`` target/project, for example::
+
+  make doc
+
+This will generate the HTML documentation in ``doc/html``.
+
+Conda
+=====
+
+fmt can be installed on Linux, macOS and Windows with
+`Conda <https://docs.conda.io/en/latest/>`__, using its
+`conda-forge <https://conda-forge.org>`__
+`package <https://github.com/conda-forge/fmt-feedstock>`__, as follows::
+
+  conda install -c conda-forge fmt
+
+Vcpkg
+=====
+
+You can download and install fmt using the `vcpkg
+<https://github.com/Microsoft/vcpkg>`__ dependency manager::
+
+  git clone https://github.com/Microsoft/vcpkg.git
+  cd vcpkg
+  ./bootstrap-vcpkg.sh
+  ./vcpkg integrate install
+  ./vcpkg install fmt
+
+The fmt port in vcpkg is kept up to date by Microsoft team members and community
+contributors. If the version is out of date, please `create an issue or pull
+request <https://github.com/Microsoft/vcpkg>`__ on the vcpkg repository.
+
+LHelper
+=======
+
+You can download and install fmt using
+`lhelper <https://github.com/franko/lhelper>`__ dependency manager::
+
+  lhelper activate <some-environment>
+  lhelper install fmt
+
+All the recipes for lhelper are kept in the
+`lhelper's recipe <https://github.com/franko/lhelper-recipes>`__ repository.
+
+Android NDK
+===========
+
+fmt provides `Android.mk file`__ that can be used to build the library
+with `Android NDK <https://developer.android.com/tools/sdk/ndk/index.html>`_.
+For an example of using fmt with Android NDK, see the
+`android-ndk-example <https://github.com/fmtlib/android-ndk-example>`_
+repository.
+
+__ https://github.com/fmtlib/fmt/blob/master/support/Android.mk
+
+Homebrew
+========
+
+fmt can be installed on OS X using `Homebrew <https://brew.sh/>`_::
+
+  brew install fmt
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/args.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/args.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad1654bbb60064e0aee447376ddf0fa556c28f3c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/args.h
@@ -0,0 +1,235 @@
+// 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_
+
+#include <functional>  // std::reference_wrapper
+#include <memory>      // std::unique_ptr
+#include <vector>
+
+#include "core.h"
+
+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);
+}
+
+class dynamic_arg_list {
+  // 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 storage_node_base is made a fake template.
+  template <typename = void> struct node {
+    virtual ~node() = default;
+    std::unique_ptr<node<>> next;
+  };
+
+  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
+
+/**
+  \rst
+  A dynamic version of `fmt::format_arg_store`.
+  It's equipped with a storage to potentially temporary objects which lifetimes
+  could be shorter than the format arguments object.
+
+  It can be implicitly converted into `~fmt::basic_format_args` for passing
+  into type-erased formatting functions such as `~fmt::vformat`.
+  \endrst
+ */
+template <typename Context>
+class dynamic_format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
+ 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, Context>::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_type = 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 get_types() const -> unsigned long long {
+    return detail::is_unpacked_bit | data_.size() |
+           (named_info_.empty()
+                ? 0ULL
+                : static_cast<unsigned long long>(detail::has_named_args_bit));
+  }
+
+  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(detail::make_arg<Context>(arg));
+  }
+
+  template <typename T>
+  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
+    if (named_info_.empty()) {
+      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
+      data_.insert(data_.begin(), {zero_ptr, 0});
+    }
+    data_.emplace_back(detail::make_arg<Context>(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].value_.named_args = {named_info_.data(), named_info_.size()};
+    guard.release();
+  }
+
+ public:
+  constexpr dynamic_format_arg_store() = default;
+
+  /**
+    \rst
+    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);
+    \endrst
+  */
+  template <typename T> void push_back(const T& arg) {
+    if (detail::const_check(need_copy<T>::value))
+      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
+    else
+      emplace_arg(detail::unwrap(arg));
+  }
+
+  /**
+    \rst
+    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"
+    \endrst
+  */
+  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_type<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_ = detail::dynamic_arg_list();
+  }
+
+  /**
+    \rst
+    Reserves space to store at least *new_cap* arguments including
+    *new_cap_named* named arguments.
+    \endrst
+  */
+  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);
+  }
+};
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_ARGS_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/chrono.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/chrono.h
new file mode 100644
index 0000000000000000000000000000000000000000..9d54574e1682ce662718b31d6e3d660c6781c779
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/chrono.h
@@ -0,0 +1,2240 @@
+// Formatting library for C++ - chrono support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_CHRONO_H_
+#define FMT_CHRONO_H_
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>    // std::isfinite
+#include <cstring>  // std::memcpy
+#include <ctime>
+#include <iterator>
+#include <locale>
+#include <ostream>
+#include <type_traits>
+
+#include "ostream.h"  // formatbuf
+
+FMT_BEGIN_NAMESPACE
+
+// Check if std::chrono::local_t is available.
+#ifndef FMT_USE_LOCAL_TIME
+#  ifdef __cpp_lib_chrono
+#    define FMT_USE_LOCAL_TIME (__cpp_lib_chrono >= 201907L)
+#  else
+#    define FMT_USE_LOCAL_TIME 0
+#  endif
+#endif
+
+// Check if std::chrono::utc_timestamp is available.
+#ifndef FMT_USE_UTC_TIME
+#  ifdef __cpp_lib_chrono
+#    define FMT_USE_UTC_TIME (__cpp_lib_chrono >= 201907L)
+#  else
+#    define FMT_USE_UTC_TIME 0
+#  endif
+#endif
+
+// Enable tzset.
+#ifndef FMT_USE_TZSET
+// UWP doesn't provide _tzset.
+#  if FMT_HAS_INCLUDE("winapifamily.h")
+#    include <winapifamily.h>
+#  endif
+#  if defined(_WIN32) && (!defined(WINAPI_FAMILY) || \
+                          (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+#    define FMT_USE_TZSET 1
+#  else
+#    define FMT_USE_TZSET 0
+#  endif
+#endif
+
+// Enable safe chrono durations, unless explicitly disabled.
+#ifndef FMT_SAFE_DURATION_CAST
+#  define FMT_SAFE_DURATION_CAST 1
+#endif
+#if FMT_SAFE_DURATION_CAST
+
+// For conversion between std::chrono::durations without undefined
+// behaviour or erroneous results.
+// This is a stripped down version of duration_cast, for inclusion in fmt.
+// See https://github.com/pauldreik/safe_duration_cast
+//
+// Copyright Paul Dreik 2019
+namespace safe_duration_cast {
+
+template <typename To, typename From,
+          FMT_ENABLE_IF(!std::is_same<From, To>::value &&
+                        std::numeric_limits<From>::is_signed ==
+                            std::numeric_limits<To>::is_signed)>
+FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
+    -> To {
+  ec = 0;
+  using F = std::numeric_limits<From>;
+  using T = std::numeric_limits<To>;
+  static_assert(F::is_integer, "From must be integral");
+  static_assert(T::is_integer, "To must be integral");
+
+  // A and B are both signed, or both unsigned.
+  if (detail::const_check(F::digits <= T::digits)) {
+    // From fits in To without any problem.
+  } else {
+    // From does not always fit in To, resort to a dynamic check.
+    if (from < (T::min)() || from > (T::max)()) {
+      // outside range.
+      ec = 1;
+      return {};
+    }
+  }
+  return static_cast<To>(from);
+}
+
+/**
+ * converts From to To, without loss. If the dynamic value of from
+ * can't be converted to To without loss, ec is set.
+ */
+template <typename To, typename From,
+          FMT_ENABLE_IF(!std::is_same<From, To>::value &&
+                        std::numeric_limits<From>::is_signed !=
+                            std::numeric_limits<To>::is_signed)>
+FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
+    -> To {
+  ec = 0;
+  using F = std::numeric_limits<From>;
+  using T = std::numeric_limits<To>;
+  static_assert(F::is_integer, "From must be integral");
+  static_assert(T::is_integer, "To must be integral");
+
+  if (detail::const_check(F::is_signed && !T::is_signed)) {
+    // From may be negative, not allowed!
+    if (fmt::detail::is_negative(from)) {
+      ec = 1;
+      return {};
+    }
+    // From is positive. Can it always fit in To?
+    if (detail::const_check(F::digits > T::digits) &&
+        from > static_cast<From>(detail::max_value<To>())) {
+      ec = 1;
+      return {};
+    }
+  }
+
+  if (detail::const_check(!F::is_signed && T::is_signed &&
+                          F::digits >= T::digits) &&
+      from > static_cast<From>(detail::max_value<To>())) {
+    ec = 1;
+    return {};
+  }
+  return static_cast<To>(from);  // Lossless conversion.
+}
+
+template <typename To, typename From,
+          FMT_ENABLE_IF(std::is_same<From, To>::value)>
+FMT_CONSTEXPR auto lossless_integral_conversion(const From from, int& ec)
+    -> To {
+  ec = 0;
+  return from;
+}  // function
+
+// clang-format off
+/**
+ * converts From to To if possible, otherwise ec is set.
+ *
+ * input                            |    output
+ * ---------------------------------|---------------
+ * NaN                              | NaN
+ * Inf                              | Inf
+ * normal, fits in output           | converted (possibly lossy)
+ * normal, does not fit in output   | ec is set
+ * subnormal                        | best effort
+ * -Inf                             | -Inf
+ */
+// clang-format on
+template <typename To, typename From,
+          FMT_ENABLE_IF(!std::is_same<From, To>::value)>
+FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {
+  ec = 0;
+  using T = std::numeric_limits<To>;
+  static_assert(std::is_floating_point<From>::value, "From must be floating");
+  static_assert(std::is_floating_point<To>::value, "To must be floating");
+
+  // catch the only happy case
+  if (std::isfinite(from)) {
+    if (from >= T::lowest() && from <= (T::max)()) {
+      return static_cast<To>(from);
+    }
+    // not within range.
+    ec = 1;
+    return {};
+  }
+
+  // nan and inf will be preserved
+  return static_cast<To>(from);
+}  // function
+
+template <typename To, typename From,
+          FMT_ENABLE_IF(std::is_same<From, To>::value)>
+FMT_CONSTEXPR auto safe_float_conversion(const From from, int& ec) -> To {
+  ec = 0;
+  static_assert(std::is_floating_point<From>::value, "From must be floating");
+  return from;
+}
+
+/**
+ * safe duration cast between integral durations
+ */
+template <typename To, typename FromRep, typename FromPeriod,
+          FMT_ENABLE_IF(std::is_integral<FromRep>::value),
+          FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)>
+auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
+                        int& ec) -> To {
+  using From = std::chrono::duration<FromRep, FromPeriod>;
+  ec = 0;
+  // the basic idea is that we need to convert from count() in the from type
+  // to count() in the To type, by multiplying it with this:
+  struct Factor
+      : std::ratio_divide<typename From::period, typename To::period> {};
+
+  static_assert(Factor::num > 0, "num must be positive");
+  static_assert(Factor::den > 0, "den must be positive");
+
+  // the conversion is like this: multiply from.count() with Factor::num
+  // /Factor::den and convert it to To::rep, all this without
+  // overflow/underflow. let's start by finding a suitable type that can hold
+  // both To, From and Factor::num
+  using IntermediateRep =
+      typename std::common_type<typename From::rep, typename To::rep,
+                                decltype(Factor::num)>::type;
+
+  // safe conversion to IntermediateRep
+  IntermediateRep count =
+      lossless_integral_conversion<IntermediateRep>(from.count(), ec);
+  if (ec) return {};
+  // multiply with Factor::num without overflow or underflow
+  if (detail::const_check(Factor::num != 1)) {
+    const auto max1 = detail::max_value<IntermediateRep>() / Factor::num;
+    if (count > max1) {
+      ec = 1;
+      return {};
+    }
+    const auto min1 =
+        (std::numeric_limits<IntermediateRep>::min)() / Factor::num;
+    if (detail::const_check(!std::is_unsigned<IntermediateRep>::value) &&
+        count < min1) {
+      ec = 1;
+      return {};
+    }
+    count *= Factor::num;
+  }
+
+  if (detail::const_check(Factor::den != 1)) count /= Factor::den;
+  auto tocount = lossless_integral_conversion<typename To::rep>(count, ec);
+  return ec ? To() : To(tocount);
+}
+
+/**
+ * safe duration_cast between floating point durations
+ */
+template <typename To, typename FromRep, typename FromPeriod,
+          FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),
+          FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>
+auto safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,
+                        int& ec) -> To {
+  using From = std::chrono::duration<FromRep, FromPeriod>;
+  ec = 0;
+  if (std::isnan(from.count())) {
+    // nan in, gives nan out. easy.
+    return To{std::numeric_limits<typename To::rep>::quiet_NaN()};
+  }
+  // maybe we should also check if from is denormal, and decide what to do about
+  // it.
+
+  // +-inf should be preserved.
+  if (std::isinf(from.count())) {
+    return To{from.count()};
+  }
+
+  // the basic idea is that we need to convert from count() in the from type
+  // to count() in the To type, by multiplying it with this:
+  struct Factor
+      : std::ratio_divide<typename From::period, typename To::period> {};
+
+  static_assert(Factor::num > 0, "num must be positive");
+  static_assert(Factor::den > 0, "den must be positive");
+
+  // the conversion is like this: multiply from.count() with Factor::num
+  // /Factor::den and convert it to To::rep, all this without
+  // overflow/underflow. let's start by finding a suitable type that can hold
+  // both To, From and Factor::num
+  using IntermediateRep =
+      typename std::common_type<typename From::rep, typename To::rep,
+                                decltype(Factor::num)>::type;
+
+  // force conversion of From::rep -> IntermediateRep to be safe,
+  // even if it will never happen be narrowing in this context.
+  IntermediateRep count =
+      safe_float_conversion<IntermediateRep>(from.count(), ec);
+  if (ec) {
+    return {};
+  }
+
+  // multiply with Factor::num without overflow or underflow
+  if (detail::const_check(Factor::num != 1)) {
+    constexpr auto max1 = detail::max_value<IntermediateRep>() /
+                          static_cast<IntermediateRep>(Factor::num);
+    if (count > max1) {
+      ec = 1;
+      return {};
+    }
+    constexpr auto min1 = std::numeric_limits<IntermediateRep>::lowest() /
+                          static_cast<IntermediateRep>(Factor::num);
+    if (count < min1) {
+      ec = 1;
+      return {};
+    }
+    count *= static_cast<IntermediateRep>(Factor::num);
+  }
+
+  // this can't go wrong, right? den>0 is checked earlier.
+  if (detail::const_check(Factor::den != 1)) {
+    using common_t = typename std::common_type<IntermediateRep, intmax_t>::type;
+    count /= static_cast<common_t>(Factor::den);
+  }
+
+  // convert to the to type, safely
+  using ToRep = typename To::rep;
+
+  const ToRep tocount = safe_float_conversion<ToRep>(count, ec);
+  if (ec) {
+    return {};
+  }
+  return To{tocount};
+}
+}  // namespace safe_duration_cast
+#endif
+
+// Prevents expansion of a preceding token as a function-style macro.
+// Usage: f FMT_NOMACRO()
+#define FMT_NOMACRO
+
+namespace detail {
+template <typename T = void> struct null {};
+inline auto localtime_r FMT_NOMACRO(...) -> null<> { return null<>(); }
+inline auto localtime_s(...) -> null<> { return null<>(); }
+inline auto gmtime_r(...) -> null<> { return null<>(); }
+inline auto gmtime_s(...) -> null<> { return null<>(); }
+
+inline auto get_classic_locale() -> const std::locale& {
+  static const auto& locale = std::locale::classic();
+  return locale;
+}
+
+template <typename CodeUnit> struct codecvt_result {
+  static constexpr const size_t max_size = 32;
+  CodeUnit buf[max_size];
+  CodeUnit* end;
+};
+
+template <typename CodeUnit>
+void write_codecvt(codecvt_result<CodeUnit>& out, string_view in_buf,
+                   const std::locale& loc) {
+#if FMT_CLANG_VERSION
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wdeprecated"
+  auto& f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc);
+#  pragma clang diagnostic pop
+#else
+  auto& f = std::use_facet<std::codecvt<CodeUnit, char, std::mbstate_t>>(loc);
+#endif
+  auto mb = std::mbstate_t();
+  const char* from_next = nullptr;
+  auto result = f.in(mb, in_buf.begin(), in_buf.end(), from_next,
+                     std::begin(out.buf), std::end(out.buf), out.end);
+  if (result != std::codecvt_base::ok)
+    FMT_THROW(format_error("failed to format time"));
+}
+
+template <typename OutputIt>
+auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc)
+    -> OutputIt {
+  if (detail::is_utf8() && loc != get_classic_locale()) {
+    // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and
+    // gcc-4.
+#if FMT_MSC_VERSION != 0 || \
+    (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI))
+    // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5
+    // and newer.
+    using code_unit = wchar_t;
+#else
+    using code_unit = char32_t;
+#endif
+
+    using unit_t = codecvt_result<code_unit>;
+    unit_t unit;
+    write_codecvt(unit, in, loc);
+    // In UTF-8 is used one to four one-byte code units.
+    auto u =
+        to_utf8<code_unit, basic_memory_buffer<char, unit_t::max_size * 4>>();
+    if (!u.convert({unit.buf, to_unsigned(unit.end - unit.buf)}))
+      FMT_THROW(format_error("failed to format time"));
+    return copy_str<char>(u.c_str(), u.c_str() + u.size(), out);
+  }
+  return copy_str<char>(in.data(), in.data() + in.size(), out);
+}
+
+template <typename Char, typename OutputIt,
+          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc)
+    -> OutputIt {
+  codecvt_result<Char> unit;
+  write_codecvt(unit, sv, loc);
+  return copy_str<Char>(unit.buf, unit.end, out);
+}
+
+template <typename Char, typename OutputIt,
+          FMT_ENABLE_IF(std::is_same<Char, char>::value)>
+auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc)
+    -> OutputIt {
+  return write_encoded_tm_str(out, sv, loc);
+}
+
+template <typename Char>
+inline void do_write(buffer<Char>& buf, const std::tm& time,
+                     const std::locale& loc, char format, char modifier) {
+  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
+  auto&& os = std::basic_ostream<Char>(&format_buf);
+  os.imbue(loc);
+  const auto& facet = std::use_facet<std::time_put<Char>>(loc);
+  auto end = facet.put(os, os, Char(' '), &time, format, modifier);
+  if (end.failed()) FMT_THROW(format_error("failed to format time"));
+}
+
+template <typename Char, typename OutputIt,
+          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+auto write(OutputIt out, const std::tm& time, const std::locale& loc,
+           char format, char modifier = 0) -> OutputIt {
+  auto&& buf = get_buffer<Char>(out);
+  do_write<Char>(buf, time, loc, format, modifier);
+  return get_iterator(buf, out);
+}
+
+template <typename Char, typename OutputIt,
+          FMT_ENABLE_IF(std::is_same<Char, char>::value)>
+auto write(OutputIt out, const std::tm& time, const std::locale& loc,
+           char format, char modifier = 0) -> OutputIt {
+  auto&& buf = basic_memory_buffer<Char>();
+  do_write<char>(buf, time, loc, format, modifier);
+  return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc);
+}
+
+template <typename Rep1, typename Rep2>
+struct is_same_arithmetic_type
+    : public std::integral_constant<bool,
+                                    (std::is_integral<Rep1>::value &&
+                                     std::is_integral<Rep2>::value) ||
+                                        (std::is_floating_point<Rep1>::value &&
+                                         std::is_floating_point<Rep2>::value)> {
+};
+
+template <
+    typename To, typename FromRep, typename FromPeriod,
+    FMT_ENABLE_IF(is_same_arithmetic_type<FromRep, typename To::rep>::value)>
+auto fmt_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To {
+#if FMT_SAFE_DURATION_CAST
+  // Throwing version of safe_duration_cast is only available for
+  // integer to integer or float to float casts.
+  int ec;
+  To to = safe_duration_cast::safe_duration_cast<To>(from, ec);
+  if (ec) FMT_THROW(format_error("cannot format duration"));
+  return to;
+#else
+  // Standard duration cast, may overflow.
+  return std::chrono::duration_cast<To>(from);
+#endif
+}
+
+template <
+    typename To, typename FromRep, typename FromPeriod,
+    FMT_ENABLE_IF(!is_same_arithmetic_type<FromRep, typename To::rep>::value)>
+auto fmt_duration_cast(std::chrono::duration<FromRep, FromPeriod> from) -> To {
+  // Mixed integer <-> float cast is not supported by safe_duration_cast.
+  return std::chrono::duration_cast<To>(from);
+}
+
+template <typename Duration>
+auto to_time_t(
+    std::chrono::time_point<std::chrono::system_clock, Duration> time_point)
+    -> std::time_t {
+  // Cannot use std::chrono::system_clock::to_time_t since this would first
+  // require a cast to std::chrono::system_clock::time_point, which could
+  // overflow.
+  return fmt_duration_cast<std::chrono::duration<std::time_t>>(
+             time_point.time_since_epoch())
+      .count();
+}
+}  // namespace detail
+
+FMT_BEGIN_EXPORT
+
+/**
+  Converts given time since epoch as ``std::time_t`` value into calendar time,
+  expressed in local time. Unlike ``std::localtime``, this function is
+  thread-safe on most platforms.
+ */
+inline auto localtime(std::time_t time) -> std::tm {
+  struct dispatcher {
+    std::time_t time_;
+    std::tm tm_;
+
+    dispatcher(std::time_t t) : time_(t) {}
+
+    auto run() -> bool {
+      using namespace fmt::detail;
+      return handle(localtime_r(&time_, &tm_));
+    }
+
+    auto handle(std::tm* tm) -> bool { return tm != nullptr; }
+
+    auto handle(detail::null<>) -> bool {
+      using namespace fmt::detail;
+      return fallback(localtime_s(&tm_, &time_));
+    }
+
+    auto fallback(int res) -> bool { return res == 0; }
+
+#if !FMT_MSC_VERSION
+    auto fallback(detail::null<>) -> bool {
+      using namespace fmt::detail;
+      std::tm* tm = std::localtime(&time_);
+      if (tm) tm_ = *tm;
+      return tm != nullptr;
+    }
+#endif
+  };
+  dispatcher lt(time);
+  // Too big time values may be unsupported.
+  if (!lt.run()) FMT_THROW(format_error("time_t value out of range"));
+  return lt.tm_;
+}
+
+#if FMT_USE_LOCAL_TIME
+template <typename Duration>
+inline auto localtime(std::chrono::local_time<Duration> time) -> std::tm {
+  return localtime(
+      detail::to_time_t(std::chrono::current_zone()->to_sys(time)));
+}
+#endif
+
+/**
+  Converts given time since epoch as ``std::time_t`` value into calendar time,
+  expressed in Coordinated Universal Time (UTC). Unlike ``std::gmtime``, this
+  function is thread-safe on most platforms.
+ */
+inline auto gmtime(std::time_t time) -> std::tm {
+  struct dispatcher {
+    std::time_t time_;
+    std::tm tm_;
+
+    dispatcher(std::time_t t) : time_(t) {}
+
+    auto run() -> bool {
+      using namespace fmt::detail;
+      return handle(gmtime_r(&time_, &tm_));
+    }
+
+    auto handle(std::tm* tm) -> bool { return tm != nullptr; }
+
+    auto handle(detail::null<>) -> bool {
+      using namespace fmt::detail;
+      return fallback(gmtime_s(&tm_, &time_));
+    }
+
+    auto fallback(int res) -> bool { return res == 0; }
+
+#if !FMT_MSC_VERSION
+    auto fallback(detail::null<>) -> bool {
+      std::tm* tm = std::gmtime(&time_);
+      if (tm) tm_ = *tm;
+      return tm != nullptr;
+    }
+#endif
+  };
+  auto gt = dispatcher(time);
+  // Too big time values may be unsupported.
+  if (!gt.run()) FMT_THROW(format_error("time_t value out of range"));
+  return gt.tm_;
+}
+
+template <typename Duration>
+inline auto gmtime(
+    std::chrono::time_point<std::chrono::system_clock, Duration> time_point)
+    -> std::tm {
+  return gmtime(detail::to_time_t(time_point));
+}
+
+namespace detail {
+
+// Writes two-digit numbers a, b and c separated by sep to buf.
+// The method by Pavel Novikov based on
+// https://johnnylee-sde.github.io/Fast-unsigned-integer-to-time-string/.
+inline void write_digit2_separated(char* buf, unsigned a, unsigned b,
+                                   unsigned c, char sep) {
+  unsigned long long digits =
+      a | (b << 24) | (static_cast<unsigned long long>(c) << 48);
+  // Convert each value to BCD.
+  // We have x = a * 10 + b and we want to convert it to BCD y = a * 16 + b.
+  // The difference is
+  //   y - x = a * 6
+  // a can be found from x:
+  //   a = floor(x / 10)
+  // then
+  //   y = x + a * 6 = x + floor(x / 10) * 6
+  // floor(x / 10) is (x * 205) >> 11 (needs 16 bits).
+  digits += (((digits * 205) >> 11) & 0x000f00000f00000f) * 6;
+  // Put low nibbles to high bytes and high nibbles to low bytes.
+  digits = ((digits & 0x00f00000f00000f0) >> 4) |
+           ((digits & 0x000f00000f00000f) << 8);
+  auto usep = static_cast<unsigned long long>(sep);
+  // Add ASCII '0' to each digit byte and insert separators.
+  digits |= 0x3030003030003030 | (usep << 16) | (usep << 40);
+
+  constexpr const size_t len = 8;
+  if (const_check(is_big_endian())) {
+    char tmp[len];
+    std::memcpy(tmp, &digits, len);
+    std::reverse_copy(tmp, tmp + len, buf);
+  } else {
+    std::memcpy(buf, &digits, len);
+  }
+}
+
+template <typename Period>
+FMT_CONSTEXPR inline auto get_units() -> const char* {
+  if (std::is_same<Period, std::atto>::value) return "as";
+  if (std::is_same<Period, std::femto>::value) return "fs";
+  if (std::is_same<Period, std::pico>::value) return "ps";
+  if (std::is_same<Period, std::nano>::value) return "ns";
+  if (std::is_same<Period, std::micro>::value) return "µs";
+  if (std::is_same<Period, std::milli>::value) return "ms";
+  if (std::is_same<Period, std::centi>::value) return "cs";
+  if (std::is_same<Period, std::deci>::value) return "ds";
+  if (std::is_same<Period, std::ratio<1>>::value) return "s";
+  if (std::is_same<Period, std::deca>::value) return "das";
+  if (std::is_same<Period, std::hecto>::value) return "hs";
+  if (std::is_same<Period, std::kilo>::value) return "ks";
+  if (std::is_same<Period, std::mega>::value) return "Ms";
+  if (std::is_same<Period, std::giga>::value) return "Gs";
+  if (std::is_same<Period, std::tera>::value) return "Ts";
+  if (std::is_same<Period, std::peta>::value) return "Ps";
+  if (std::is_same<Period, std::exa>::value) return "Es";
+  if (std::is_same<Period, std::ratio<60>>::value) return "min";
+  if (std::is_same<Period, std::ratio<3600>>::value) return "h";
+  if (std::is_same<Period, std::ratio<86400>>::value) return "d";
+  return nullptr;
+}
+
+enum class numeric_system {
+  standard,
+  // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.
+  alternative
+};
+
+// Glibc extensions for formatting numeric values.
+enum class pad_type {
+  unspecified,
+  // Do not pad a numeric result string.
+  none,
+  // Pad a numeric result string with zeros even if the conversion specifier
+  // character uses space-padding by default.
+  zero,
+  // Pad a numeric result string with spaces.
+  space,
+};
+
+template <typename OutputIt>
+auto write_padding(OutputIt out, pad_type pad, int width) -> OutputIt {
+  if (pad == pad_type::none) return out;
+  return std::fill_n(out, width, pad == pad_type::space ? ' ' : '0');
+}
+
+template <typename OutputIt>
+auto write_padding(OutputIt out, pad_type pad) -> OutputIt {
+  if (pad != pad_type::none) *out++ = pad == pad_type::space ? ' ' : '0';
+  return out;
+}
+
+// Parses a put_time-like format string and invokes handler actions.
+template <typename Char, typename Handler>
+FMT_CONSTEXPR auto parse_chrono_format(const Char* begin, const Char* end,
+                                       Handler&& handler) -> const Char* {
+  if (begin == end || *begin == '}') return begin;
+  if (*begin != '%') FMT_THROW(format_error("invalid format"));
+  auto ptr = begin;
+  pad_type pad = pad_type::unspecified;
+  while (ptr != end) {
+    auto c = *ptr;
+    if (c == '}') break;
+    if (c != '%') {
+      ++ptr;
+      continue;
+    }
+    if (begin != ptr) handler.on_text(begin, ptr);
+    ++ptr;  // consume '%'
+    if (ptr == end) FMT_THROW(format_error("invalid format"));
+    c = *ptr;
+    switch (c) {
+    case '_':
+      pad = pad_type::space;
+      ++ptr;
+      break;
+    case '-':
+      pad = pad_type::none;
+      ++ptr;
+      break;
+    case '0':
+      pad = pad_type::zero;
+      ++ptr;
+      break;
+    }
+    if (ptr == end) FMT_THROW(format_error("invalid format"));
+    c = *ptr++;
+    switch (c) {
+    case '%':
+      handler.on_text(ptr - 1, ptr);
+      break;
+    case 'n': {
+      const Char newline[] = {'\n'};
+      handler.on_text(newline, newline + 1);
+      break;
+    }
+    case 't': {
+      const Char tab[] = {'\t'};
+      handler.on_text(tab, tab + 1);
+      break;
+    }
+    // Year:
+    case 'Y':
+      handler.on_year(numeric_system::standard);
+      break;
+    case 'y':
+      handler.on_short_year(numeric_system::standard);
+      break;
+    case 'C':
+      handler.on_century(numeric_system::standard);
+      break;
+    case 'G':
+      handler.on_iso_week_based_year();
+      break;
+    case 'g':
+      handler.on_iso_week_based_short_year();
+      break;
+    // Day of the week:
+    case 'a':
+      handler.on_abbr_weekday();
+      break;
+    case 'A':
+      handler.on_full_weekday();
+      break;
+    case 'w':
+      handler.on_dec0_weekday(numeric_system::standard);
+      break;
+    case 'u':
+      handler.on_dec1_weekday(numeric_system::standard);
+      break;
+    // Month:
+    case 'b':
+    case 'h':
+      handler.on_abbr_month();
+      break;
+    case 'B':
+      handler.on_full_month();
+      break;
+    case 'm':
+      handler.on_dec_month(numeric_system::standard);
+      break;
+    // Day of the year/month:
+    case 'U':
+      handler.on_dec0_week_of_year(numeric_system::standard);
+      break;
+    case 'W':
+      handler.on_dec1_week_of_year(numeric_system::standard);
+      break;
+    case 'V':
+      handler.on_iso_week_of_year(numeric_system::standard);
+      break;
+    case 'j':
+      handler.on_day_of_year();
+      break;
+    case 'd':
+      handler.on_day_of_month(numeric_system::standard);
+      break;
+    case 'e':
+      handler.on_day_of_month_space(numeric_system::standard);
+      break;
+    // Hour, minute, second:
+    case 'H':
+      handler.on_24_hour(numeric_system::standard, pad);
+      break;
+    case 'I':
+      handler.on_12_hour(numeric_system::standard, pad);
+      break;
+    case 'M':
+      handler.on_minute(numeric_system::standard, pad);
+      break;
+    case 'S':
+      handler.on_second(numeric_system::standard, pad);
+      break;
+    // Other:
+    case 'c':
+      handler.on_datetime(numeric_system::standard);
+      break;
+    case 'x':
+      handler.on_loc_date(numeric_system::standard);
+      break;
+    case 'X':
+      handler.on_loc_time(numeric_system::standard);
+      break;
+    case 'D':
+      handler.on_us_date();
+      break;
+    case 'F':
+      handler.on_iso_date();
+      break;
+    case 'r':
+      handler.on_12_hour_time();
+      break;
+    case 'R':
+      handler.on_24_hour_time();
+      break;
+    case 'T':
+      handler.on_iso_time();
+      break;
+    case 'p':
+      handler.on_am_pm();
+      break;
+    case 'Q':
+      handler.on_duration_value();
+      break;
+    case 'q':
+      handler.on_duration_unit();
+      break;
+    case 'z':
+      handler.on_utc_offset(numeric_system::standard);
+      break;
+    case 'Z':
+      handler.on_tz_name();
+      break;
+    // Alternative representation:
+    case 'E': {
+      if (ptr == end) FMT_THROW(format_error("invalid format"));
+      c = *ptr++;
+      switch (c) {
+      case 'Y':
+        handler.on_year(numeric_system::alternative);
+        break;
+      case 'y':
+        handler.on_offset_year();
+        break;
+      case 'C':
+        handler.on_century(numeric_system::alternative);
+        break;
+      case 'c':
+        handler.on_datetime(numeric_system::alternative);
+        break;
+      case 'x':
+        handler.on_loc_date(numeric_system::alternative);
+        break;
+      case 'X':
+        handler.on_loc_time(numeric_system::alternative);
+        break;
+      case 'z':
+        handler.on_utc_offset(numeric_system::alternative);
+        break;
+      default:
+        FMT_THROW(format_error("invalid format"));
+      }
+      break;
+    }
+    case 'O':
+      if (ptr == end) FMT_THROW(format_error("invalid format"));
+      c = *ptr++;
+      switch (c) {
+      case 'y':
+        handler.on_short_year(numeric_system::alternative);
+        break;
+      case 'm':
+        handler.on_dec_month(numeric_system::alternative);
+        break;
+      case 'U':
+        handler.on_dec0_week_of_year(numeric_system::alternative);
+        break;
+      case 'W':
+        handler.on_dec1_week_of_year(numeric_system::alternative);
+        break;
+      case 'V':
+        handler.on_iso_week_of_year(numeric_system::alternative);
+        break;
+      case 'd':
+        handler.on_day_of_month(numeric_system::alternative);
+        break;
+      case 'e':
+        handler.on_day_of_month_space(numeric_system::alternative);
+        break;
+      case 'w':
+        handler.on_dec0_weekday(numeric_system::alternative);
+        break;
+      case 'u':
+        handler.on_dec1_weekday(numeric_system::alternative);
+        break;
+      case 'H':
+        handler.on_24_hour(numeric_system::alternative, pad);
+        break;
+      case 'I':
+        handler.on_12_hour(numeric_system::alternative, pad);
+        break;
+      case 'M':
+        handler.on_minute(numeric_system::alternative, pad);
+        break;
+      case 'S':
+        handler.on_second(numeric_system::alternative, pad);
+        break;
+      case 'z':
+        handler.on_utc_offset(numeric_system::alternative);
+        break;
+      default:
+        FMT_THROW(format_error("invalid format"));
+      }
+      break;
+    default:
+      FMT_THROW(format_error("invalid format"));
+    }
+    begin = ptr;
+  }
+  if (begin != ptr) handler.on_text(begin, ptr);
+  return ptr;
+}
+
+template <typename Derived> struct null_chrono_spec_handler {
+  FMT_CONSTEXPR void unsupported() {
+    static_cast<Derived*>(this)->unsupported();
+  }
+  FMT_CONSTEXPR void on_year(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_short_year(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_offset_year() { unsupported(); }
+  FMT_CONSTEXPR void on_century(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_iso_week_based_year() { unsupported(); }
+  FMT_CONSTEXPR void on_iso_week_based_short_year() { unsupported(); }
+  FMT_CONSTEXPR void on_abbr_weekday() { unsupported(); }
+  FMT_CONSTEXPR void on_full_weekday() { unsupported(); }
+  FMT_CONSTEXPR void on_dec0_weekday(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_dec1_weekday(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_abbr_month() { unsupported(); }
+  FMT_CONSTEXPR void on_full_month() { unsupported(); }
+  FMT_CONSTEXPR void on_dec_month(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_day_of_year() { unsupported(); }
+  FMT_CONSTEXPR void on_day_of_month(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_day_of_month_space(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_second(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_datetime(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_loc_date(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_loc_time(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_us_date() { unsupported(); }
+  FMT_CONSTEXPR void on_iso_date() { unsupported(); }
+  FMT_CONSTEXPR void on_12_hour_time() { unsupported(); }
+  FMT_CONSTEXPR void on_24_hour_time() { unsupported(); }
+  FMT_CONSTEXPR void on_iso_time() { unsupported(); }
+  FMT_CONSTEXPR void on_am_pm() { unsupported(); }
+  FMT_CONSTEXPR void on_duration_value() { unsupported(); }
+  FMT_CONSTEXPR void on_duration_unit() { unsupported(); }
+  FMT_CONSTEXPR void on_utc_offset(numeric_system) { unsupported(); }
+  FMT_CONSTEXPR void on_tz_name() { unsupported(); }
+};
+
+struct tm_format_checker : null_chrono_spec_handler<tm_format_checker> {
+  FMT_NORETURN void unsupported() { FMT_THROW(format_error("no format")); }
+
+  template <typename Char>
+  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
+  FMT_CONSTEXPR void on_year(numeric_system) {}
+  FMT_CONSTEXPR void on_short_year(numeric_system) {}
+  FMT_CONSTEXPR void on_offset_year() {}
+  FMT_CONSTEXPR void on_century(numeric_system) {}
+  FMT_CONSTEXPR void on_iso_week_based_year() {}
+  FMT_CONSTEXPR void on_iso_week_based_short_year() {}
+  FMT_CONSTEXPR void on_abbr_weekday() {}
+  FMT_CONSTEXPR void on_full_weekday() {}
+  FMT_CONSTEXPR void on_dec0_weekday(numeric_system) {}
+  FMT_CONSTEXPR void on_dec1_weekday(numeric_system) {}
+  FMT_CONSTEXPR void on_abbr_month() {}
+  FMT_CONSTEXPR void on_full_month() {}
+  FMT_CONSTEXPR void on_dec_month(numeric_system) {}
+  FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) {}
+  FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) {}
+  FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) {}
+  FMT_CONSTEXPR void on_day_of_year() {}
+  FMT_CONSTEXPR void on_day_of_month(numeric_system) {}
+  FMT_CONSTEXPR void on_day_of_month_space(numeric_system) {}
+  FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {}
+  FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {}
+  FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {}
+  FMT_CONSTEXPR void on_second(numeric_system, pad_type) {}
+  FMT_CONSTEXPR void on_datetime(numeric_system) {}
+  FMT_CONSTEXPR void on_loc_date(numeric_system) {}
+  FMT_CONSTEXPR void on_loc_time(numeric_system) {}
+  FMT_CONSTEXPR void on_us_date() {}
+  FMT_CONSTEXPR void on_iso_date() {}
+  FMT_CONSTEXPR void on_12_hour_time() {}
+  FMT_CONSTEXPR void on_24_hour_time() {}
+  FMT_CONSTEXPR void on_iso_time() {}
+  FMT_CONSTEXPR void on_am_pm() {}
+  FMT_CONSTEXPR void on_utc_offset(numeric_system) {}
+  FMT_CONSTEXPR void on_tz_name() {}
+};
+
+inline auto tm_wday_full_name(int wday) -> const char* {
+  static constexpr const char* full_name_list[] = {
+      "Sunday",   "Monday", "Tuesday", "Wednesday",
+      "Thursday", "Friday", "Saturday"};
+  return wday >= 0 && wday <= 6 ? full_name_list[wday] : "?";
+}
+inline auto tm_wday_short_name(int wday) -> const char* {
+  static constexpr const char* short_name_list[] = {"Sun", "Mon", "Tue", "Wed",
+                                                    "Thu", "Fri", "Sat"};
+  return wday >= 0 && wday <= 6 ? short_name_list[wday] : "???";
+}
+
+inline auto tm_mon_full_name(int mon) -> const char* {
+  static constexpr const char* full_name_list[] = {
+      "January", "February", "March",     "April",   "May",      "June",
+      "July",    "August",   "September", "October", "November", "December"};
+  return mon >= 0 && mon <= 11 ? full_name_list[mon] : "?";
+}
+inline auto tm_mon_short_name(int mon) -> const char* {
+  static constexpr const char* short_name_list[] = {
+      "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+      "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+  };
+  return mon >= 0 && mon <= 11 ? short_name_list[mon] : "???";
+}
+
+template <typename T, typename = void>
+struct has_member_data_tm_gmtoff : std::false_type {};
+template <typename T>
+struct has_member_data_tm_gmtoff<T, void_t<decltype(T::tm_gmtoff)>>
+    : std::true_type {};
+
+template <typename T, typename = void>
+struct has_member_data_tm_zone : std::false_type {};
+template <typename T>
+struct has_member_data_tm_zone<T, void_t<decltype(T::tm_zone)>>
+    : std::true_type {};
+
+#if FMT_USE_TZSET
+inline void tzset_once() {
+  static bool init = []() -> bool {
+    _tzset();
+    return true;
+  }();
+  ignore_unused(init);
+}
+#endif
+
+// Converts value to Int and checks that it's in the range [0, upper).
+template <typename T, typename Int, FMT_ENABLE_IF(std::is_integral<T>::value)>
+inline auto to_nonnegative_int(T value, Int upper) -> Int {
+  if (!std::is_unsigned<Int>::value &&
+      (value < 0 || to_unsigned(value) > to_unsigned(upper))) {
+    FMT_THROW(fmt::format_error("chrono value is out of range"));
+  }
+  return static_cast<Int>(value);
+}
+template <typename T, typename Int, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+inline auto to_nonnegative_int(T value, Int upper) -> Int {
+  if (value < 0 || value > static_cast<T>(upper))
+    FMT_THROW(format_error("invalid value"));
+  return static_cast<Int>(value);
+}
+
+constexpr auto pow10(std::uint32_t n) -> long long {
+  return n == 0 ? 1 : 10 * pow10(n - 1);
+}
+
+// Counts the number of fractional digits in the range [0, 18] according to the
+// C++20 spec. If more than 18 fractional digits are required then returns 6 for
+// microseconds precision.
+template <long long Num, long long Den, int N = 0,
+          bool Enabled = (N < 19) && (Num <= max_value<long long>() / 10)>
+struct count_fractional_digits {
+  static constexpr int value =
+      Num % Den == 0 ? N : count_fractional_digits<Num * 10, Den, N + 1>::value;
+};
+
+// Base case that doesn't instantiate any more templates
+// in order to avoid overflow.
+template <long long Num, long long Den, int N>
+struct count_fractional_digits<Num, Den, N, false> {
+  static constexpr int value = (Num % Den == 0) ? N : 6;
+};
+
+// Format subseconds which are given as an integer type with an appropriate
+// number of digits.
+template <typename Char, typename OutputIt, typename Duration>
+void write_fractional_seconds(OutputIt& out, Duration d, int precision = -1) {
+  constexpr auto num_fractional_digits =
+      count_fractional_digits<Duration::period::num,
+                              Duration::period::den>::value;
+
+  using subsecond_precision = std::chrono::duration<
+      typename std::common_type<typename Duration::rep,
+                                std::chrono::seconds::rep>::type,
+      std::ratio<1, detail::pow10(num_fractional_digits)>>;
+
+  const auto fractional = d - fmt_duration_cast<std::chrono::seconds>(d);
+  const auto subseconds =
+      std::chrono::treat_as_floating_point<
+          typename subsecond_precision::rep>::value
+          ? fractional.count()
+          : fmt_duration_cast<subsecond_precision>(fractional).count();
+  auto n = static_cast<uint32_or_64_or_128_t<long long>>(subseconds);
+  const int num_digits = detail::count_digits(n);
+
+  int leading_zeroes = (std::max)(0, num_fractional_digits - num_digits);
+  if (precision < 0) {
+    FMT_ASSERT(!std::is_floating_point<typename Duration::rep>::value, "");
+    if (std::ratio_less<typename subsecond_precision::period,
+                        std::chrono::seconds::period>::value) {
+      *out++ = '.';
+      out = std::fill_n(out, leading_zeroes, '0');
+      out = format_decimal<Char>(out, n, num_digits).end;
+    }
+  } else {
+    *out++ = '.';
+    leading_zeroes = (std::min)(leading_zeroes, precision);
+    out = std::fill_n(out, leading_zeroes, '0');
+    int remaining = precision - leading_zeroes;
+    if (remaining != 0 && remaining < num_digits) {
+      n /= to_unsigned(detail::pow10(to_unsigned(num_digits - remaining)));
+      out = format_decimal<Char>(out, n, remaining).end;
+      return;
+    }
+    out = format_decimal<Char>(out, n, num_digits).end;
+    remaining -= num_digits;
+    out = std::fill_n(out, remaining, '0');
+  }
+}
+
+// Format subseconds which are given as a floating point type with an
+// appropriate number of digits. We cannot pass the Duration here, as we
+// explicitly need to pass the Rep value in the chrono_formatter.
+template <typename Duration>
+void write_floating_seconds(memory_buffer& buf, Duration duration,
+                            int num_fractional_digits = -1) {
+  using rep = typename Duration::rep;
+  FMT_ASSERT(std::is_floating_point<rep>::value, "");
+
+  auto val = duration.count();
+
+  if (num_fractional_digits < 0) {
+    // For `std::round` with fallback to `round`:
+    // On some toolchains `std::round` is not available (e.g. GCC 6).
+    using namespace std;
+    num_fractional_digits =
+        count_fractional_digits<Duration::period::num,
+                                Duration::period::den>::value;
+    if (num_fractional_digits < 6 && static_cast<rep>(round(val)) != val)
+      num_fractional_digits = 6;
+  }
+
+  fmt::format_to(std::back_inserter(buf), FMT_STRING("{:.{}f}"),
+                 std::fmod(val * static_cast<rep>(Duration::period::num) /
+                               static_cast<rep>(Duration::period::den),
+                           static_cast<rep>(60)),
+                 num_fractional_digits);
+}
+
+template <typename OutputIt, typename Char,
+          typename Duration = std::chrono::seconds>
+class tm_writer {
+ private:
+  static constexpr int days_per_week = 7;
+
+  const std::locale& loc_;
+  const bool is_classic_;
+  OutputIt out_;
+  const Duration* subsecs_;
+  const std::tm& tm_;
+
+  auto tm_sec() const noexcept -> int {
+    FMT_ASSERT(tm_.tm_sec >= 0 && tm_.tm_sec <= 61, "");
+    return tm_.tm_sec;
+  }
+  auto tm_min() const noexcept -> int {
+    FMT_ASSERT(tm_.tm_min >= 0 && tm_.tm_min <= 59, "");
+    return tm_.tm_min;
+  }
+  auto tm_hour() const noexcept -> int {
+    FMT_ASSERT(tm_.tm_hour >= 0 && tm_.tm_hour <= 23, "");
+    return tm_.tm_hour;
+  }
+  auto tm_mday() const noexcept -> int {
+    FMT_ASSERT(tm_.tm_mday >= 1 && tm_.tm_mday <= 31, "");
+    return tm_.tm_mday;
+  }
+  auto tm_mon() const noexcept -> int {
+    FMT_ASSERT(tm_.tm_mon >= 0 && tm_.tm_mon <= 11, "");
+    return tm_.tm_mon;
+  }
+  auto tm_year() const noexcept -> long long { return 1900ll + tm_.tm_year; }
+  auto tm_wday() const noexcept -> int {
+    FMT_ASSERT(tm_.tm_wday >= 0 && tm_.tm_wday <= 6, "");
+    return tm_.tm_wday;
+  }
+  auto tm_yday() const noexcept -> int {
+    FMT_ASSERT(tm_.tm_yday >= 0 && tm_.tm_yday <= 365, "");
+    return tm_.tm_yday;
+  }
+
+  auto tm_hour12() const noexcept -> int {
+    const auto h = tm_hour();
+    const auto z = h < 12 ? h : h - 12;
+    return z == 0 ? 12 : z;
+  }
+
+  // POSIX and the C Standard are unclear or inconsistent about what %C and %y
+  // do if the year is negative or exceeds 9999. Use the convention that %C
+  // concatenated with %y yields the same output as %Y, and that %Y contains at
+  // least 4 characters, with more only if necessary.
+  auto split_year_lower(long long year) const noexcept -> int {
+    auto l = year % 100;
+    if (l < 0) l = -l;  // l in [0, 99]
+    return static_cast<int>(l);
+  }
+
+  // Algorithm: https://en.wikipedia.org/wiki/ISO_week_date.
+  auto iso_year_weeks(long long curr_year) const noexcept -> int {
+    const auto prev_year = curr_year - 1;
+    const auto curr_p =
+        (curr_year + curr_year / 4 - curr_year / 100 + curr_year / 400) %
+        days_per_week;
+    const auto prev_p =
+        (prev_year + prev_year / 4 - prev_year / 100 + prev_year / 400) %
+        days_per_week;
+    return 52 + ((curr_p == 4 || prev_p == 3) ? 1 : 0);
+  }
+  auto iso_week_num(int tm_yday, int tm_wday) const noexcept -> int {
+    return (tm_yday + 11 - (tm_wday == 0 ? days_per_week : tm_wday)) /
+           days_per_week;
+  }
+  auto tm_iso_week_year() const noexcept -> long long {
+    const auto year = tm_year();
+    const auto w = iso_week_num(tm_yday(), tm_wday());
+    if (w < 1) return year - 1;
+    if (w > iso_year_weeks(year)) return year + 1;
+    return year;
+  }
+  auto tm_iso_week_of_year() const noexcept -> int {
+    const auto year = tm_year();
+    const auto w = iso_week_num(tm_yday(), tm_wday());
+    if (w < 1) return iso_year_weeks(year - 1);
+    if (w > iso_year_weeks(year)) return 1;
+    return w;
+  }
+
+  void write1(int value) {
+    *out_++ = static_cast<char>('0' + to_unsigned(value) % 10);
+  }
+  void write2(int value) {
+    const char* d = digits2(to_unsigned(value) % 100);
+    *out_++ = *d++;
+    *out_++ = *d;
+  }
+  void write2(int value, pad_type pad) {
+    unsigned int v = to_unsigned(value) % 100;
+    if (v >= 10) {
+      const char* d = digits2(v);
+      *out_++ = *d++;
+      *out_++ = *d;
+    } else {
+      out_ = detail::write_padding(out_, pad);
+      *out_++ = static_cast<char>('0' + v);
+    }
+  }
+
+  void write_year_extended(long long year) {
+    // At least 4 characters.
+    int width = 4;
+    if (year < 0) {
+      *out_++ = '-';
+      year = 0 - year;
+      --width;
+    }
+    uint32_or_64_or_128_t<long long> n = to_unsigned(year);
+    const int num_digits = count_digits(n);
+    if (width > num_digits) out_ = std::fill_n(out_, width - num_digits, '0');
+    out_ = format_decimal<Char>(out_, n, num_digits).end;
+  }
+  void write_year(long long year) {
+    if (year >= 0 && year < 10000) {
+      write2(static_cast<int>(year / 100));
+      write2(static_cast<int>(year % 100));
+    } else {
+      write_year_extended(year);
+    }
+  }
+
+  void write_utc_offset(long offset, numeric_system ns) {
+    if (offset < 0) {
+      *out_++ = '-';
+      offset = -offset;
+    } else {
+      *out_++ = '+';
+    }
+    offset /= 60;
+    write2(static_cast<int>(offset / 60));
+    if (ns != numeric_system::standard) *out_++ = ':';
+    write2(static_cast<int>(offset % 60));
+  }
+  template <typename T, FMT_ENABLE_IF(has_member_data_tm_gmtoff<T>::value)>
+  void format_utc_offset_impl(const T& tm, numeric_system ns) {
+    write_utc_offset(tm.tm_gmtoff, ns);
+  }
+  template <typename T, FMT_ENABLE_IF(!has_member_data_tm_gmtoff<T>::value)>
+  void format_utc_offset_impl(const T& tm, numeric_system ns) {
+#if defined(_WIN32) && defined(_UCRT)
+#  if FMT_USE_TZSET
+    tzset_once();
+#  endif
+    long offset = 0;
+    _get_timezone(&offset);
+    if (tm.tm_isdst) {
+      long dstbias = 0;
+      _get_dstbias(&dstbias);
+      offset += dstbias;
+    }
+    write_utc_offset(-offset, ns);
+#else
+    if (ns == numeric_system::standard) return format_localized('z');
+
+    // Extract timezone offset from timezone conversion functions.
+    std::tm gtm = tm;
+    std::time_t gt = std::mktime(&gtm);
+    std::tm ltm = gmtime(gt);
+    std::time_t lt = std::mktime(&ltm);
+    long offset = gt - lt;
+    write_utc_offset(offset, ns);
+#endif
+  }
+
+  template <typename T, FMT_ENABLE_IF(has_member_data_tm_zone<T>::value)>
+  void format_tz_name_impl(const T& tm) {
+    if (is_classic_)
+      out_ = write_tm_str<Char>(out_, tm.tm_zone, loc_);
+    else
+      format_localized('Z');
+  }
+  template <typename T, FMT_ENABLE_IF(!has_member_data_tm_zone<T>::value)>
+  void format_tz_name_impl(const T&) {
+    format_localized('Z');
+  }
+
+  void format_localized(char format, char modifier = 0) {
+    out_ = write<Char>(out_, tm_, loc_, format, modifier);
+  }
+
+ public:
+  tm_writer(const std::locale& loc, OutputIt out, const std::tm& tm,
+            const Duration* subsecs = nullptr)
+      : loc_(loc),
+        is_classic_(loc_ == get_classic_locale()),
+        out_(out),
+        subsecs_(subsecs),
+        tm_(tm) {}
+
+  auto out() const -> OutputIt { return out_; }
+
+  FMT_CONSTEXPR void on_text(const Char* begin, const Char* end) {
+    out_ = copy_str<Char>(begin, end, out_);
+  }
+
+  void on_abbr_weekday() {
+    if (is_classic_)
+      out_ = write(out_, tm_wday_short_name(tm_wday()));
+    else
+      format_localized('a');
+  }
+  void on_full_weekday() {
+    if (is_classic_)
+      out_ = write(out_, tm_wday_full_name(tm_wday()));
+    else
+      format_localized('A');
+  }
+  void on_dec0_weekday(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard) return write1(tm_wday());
+    format_localized('w', 'O');
+  }
+  void on_dec1_weekday(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard) {
+      auto wday = tm_wday();
+      write1(wday == 0 ? days_per_week : wday);
+    } else {
+      format_localized('u', 'O');
+    }
+  }
+
+  void on_abbr_month() {
+    if (is_classic_)
+      out_ = write(out_, tm_mon_short_name(tm_mon()));
+    else
+      format_localized('b');
+  }
+  void on_full_month() {
+    if (is_classic_)
+      out_ = write(out_, tm_mon_full_name(tm_mon()));
+    else
+      format_localized('B');
+  }
+
+  void on_datetime(numeric_system ns) {
+    if (is_classic_) {
+      on_abbr_weekday();
+      *out_++ = ' ';
+      on_abbr_month();
+      *out_++ = ' ';
+      on_day_of_month_space(numeric_system::standard);
+      *out_++ = ' ';
+      on_iso_time();
+      *out_++ = ' ';
+      on_year(numeric_system::standard);
+    } else {
+      format_localized('c', ns == numeric_system::standard ? '\0' : 'E');
+    }
+  }
+  void on_loc_date(numeric_system ns) {
+    if (is_classic_)
+      on_us_date();
+    else
+      format_localized('x', ns == numeric_system::standard ? '\0' : 'E');
+  }
+  void on_loc_time(numeric_system ns) {
+    if (is_classic_)
+      on_iso_time();
+    else
+      format_localized('X', ns == numeric_system::standard ? '\0' : 'E');
+  }
+  void on_us_date() {
+    char buf[8];
+    write_digit2_separated(buf, to_unsigned(tm_mon() + 1),
+                           to_unsigned(tm_mday()),
+                           to_unsigned(split_year_lower(tm_year())), '/');
+    out_ = copy_str<Char>(std::begin(buf), std::end(buf), out_);
+  }
+  void on_iso_date() {
+    auto year = tm_year();
+    char buf[10];
+    size_t offset = 0;
+    if (year >= 0 && year < 10000) {
+      copy2(buf, digits2(static_cast<size_t>(year / 100)));
+    } else {
+      offset = 4;
+      write_year_extended(year);
+      year = 0;
+    }
+    write_digit2_separated(buf + 2, static_cast<unsigned>(year % 100),
+                           to_unsigned(tm_mon() + 1), to_unsigned(tm_mday()),
+                           '-');
+    out_ = copy_str<Char>(std::begin(buf) + offset, std::end(buf), out_);
+  }
+
+  void on_utc_offset(numeric_system ns) { format_utc_offset_impl(tm_, ns); }
+  void on_tz_name() { format_tz_name_impl(tm_); }
+
+  void on_year(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard)
+      return write_year(tm_year());
+    format_localized('Y', 'E');
+  }
+  void on_short_year(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard)
+      return write2(split_year_lower(tm_year()));
+    format_localized('y', 'O');
+  }
+  void on_offset_year() {
+    if (is_classic_) return write2(split_year_lower(tm_year()));
+    format_localized('y', 'E');
+  }
+
+  void on_century(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard) {
+      auto year = tm_year();
+      auto upper = year / 100;
+      if (year >= -99 && year < 0) {
+        // Zero upper on negative year.
+        *out_++ = '-';
+        *out_++ = '0';
+      } else if (upper >= 0 && upper < 100) {
+        write2(static_cast<int>(upper));
+      } else {
+        out_ = write<Char>(out_, upper);
+      }
+    } else {
+      format_localized('C', 'E');
+    }
+  }
+
+  void on_dec_month(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard)
+      return write2(tm_mon() + 1);
+    format_localized('m', 'O');
+  }
+
+  void on_dec0_week_of_year(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard)
+      return write2((tm_yday() + days_per_week - tm_wday()) / days_per_week);
+    format_localized('U', 'O');
+  }
+  void on_dec1_week_of_year(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard) {
+      auto wday = tm_wday();
+      write2((tm_yday() + days_per_week -
+              (wday == 0 ? (days_per_week - 1) : (wday - 1))) /
+             days_per_week);
+    } else {
+      format_localized('W', 'O');
+    }
+  }
+  void on_iso_week_of_year(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard)
+      return write2(tm_iso_week_of_year());
+    format_localized('V', 'O');
+  }
+
+  void on_iso_week_based_year() { write_year(tm_iso_week_year()); }
+  void on_iso_week_based_short_year() {
+    write2(split_year_lower(tm_iso_week_year()));
+  }
+
+  void on_day_of_year() {
+    auto yday = tm_yday() + 1;
+    write1(yday / 100);
+    write2(yday % 100);
+  }
+  void on_day_of_month(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard) return write2(tm_mday());
+    format_localized('d', 'O');
+  }
+  void on_day_of_month_space(numeric_system ns) {
+    if (is_classic_ || ns == numeric_system::standard) {
+      auto mday = to_unsigned(tm_mday()) % 100;
+      const char* d2 = digits2(mday);
+      *out_++ = mday < 10 ? ' ' : d2[0];
+      *out_++ = d2[1];
+    } else {
+      format_localized('e', 'O');
+    }
+  }
+
+  void on_24_hour(numeric_system ns, pad_type pad) {
+    if (is_classic_ || ns == numeric_system::standard)
+      return write2(tm_hour(), pad);
+    format_localized('H', 'O');
+  }
+  void on_12_hour(numeric_system ns, pad_type pad) {
+    if (is_classic_ || ns == numeric_system::standard)
+      return write2(tm_hour12(), pad);
+    format_localized('I', 'O');
+  }
+  void on_minute(numeric_system ns, pad_type pad) {
+    if (is_classic_ || ns == numeric_system::standard)
+      return write2(tm_min(), pad);
+    format_localized('M', 'O');
+  }
+
+  void on_second(numeric_system ns, pad_type pad) {
+    if (is_classic_ || ns == numeric_system::standard) {
+      write2(tm_sec(), pad);
+      if (subsecs_) {
+        if (std::is_floating_point<typename Duration::rep>::value) {
+          auto buf = memory_buffer();
+          write_floating_seconds(buf, *subsecs_);
+          if (buf.size() > 1) {
+            // Remove the leading "0", write something like ".123".
+            out_ = std::copy(buf.begin() + 1, buf.end(), out_);
+          }
+        } else {
+          write_fractional_seconds<Char>(out_, *subsecs_);
+        }
+      }
+    } else {
+      // Currently no formatting of subseconds when a locale is set.
+      format_localized('S', 'O');
+    }
+  }
+
+  void on_12_hour_time() {
+    if (is_classic_) {
+      char buf[8];
+      write_digit2_separated(buf, to_unsigned(tm_hour12()),
+                             to_unsigned(tm_min()), to_unsigned(tm_sec()), ':');
+      out_ = copy_str<Char>(std::begin(buf), std::end(buf), out_);
+      *out_++ = ' ';
+      on_am_pm();
+    } else {
+      format_localized('r');
+    }
+  }
+  void on_24_hour_time() {
+    write2(tm_hour());
+    *out_++ = ':';
+    write2(tm_min());
+  }
+  void on_iso_time() {
+    on_24_hour_time();
+    *out_++ = ':';
+    on_second(numeric_system::standard, pad_type::unspecified);
+  }
+
+  void on_am_pm() {
+    if (is_classic_) {
+      *out_++ = tm_hour() < 12 ? 'A' : 'P';
+      *out_++ = 'M';
+    } else {
+      format_localized('p');
+    }
+  }
+
+  // These apply to chrono durations but not tm.
+  void on_duration_value() {}
+  void on_duration_unit() {}
+};
+
+struct chrono_format_checker : null_chrono_spec_handler<chrono_format_checker> {
+  bool has_precision_integral = false;
+
+  FMT_NORETURN void unsupported() { FMT_THROW(format_error("no date")); }
+
+  template <typename Char>
+  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
+  FMT_CONSTEXPR void on_day_of_year() {}
+  FMT_CONSTEXPR void on_24_hour(numeric_system, pad_type) {}
+  FMT_CONSTEXPR void on_12_hour(numeric_system, pad_type) {}
+  FMT_CONSTEXPR void on_minute(numeric_system, pad_type) {}
+  FMT_CONSTEXPR void on_second(numeric_system, pad_type) {}
+  FMT_CONSTEXPR void on_12_hour_time() {}
+  FMT_CONSTEXPR void on_24_hour_time() {}
+  FMT_CONSTEXPR void on_iso_time() {}
+  FMT_CONSTEXPR void on_am_pm() {}
+  FMT_CONSTEXPR void on_duration_value() const {
+    if (has_precision_integral) {
+      FMT_THROW(format_error("precision not allowed for this argument type"));
+    }
+  }
+  FMT_CONSTEXPR void on_duration_unit() {}
+};
+
+template <typename T,
+          FMT_ENABLE_IF(std::is_integral<T>::value&& has_isfinite<T>::value)>
+inline auto isfinite(T) -> bool {
+  return true;
+}
+
+template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+inline auto mod(T x, int y) -> T {
+  return x % static_cast<T>(y);
+}
+template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+inline auto mod(T x, int y) -> T {
+  return std::fmod(x, static_cast<T>(y));
+}
+
+// If T is an integral type, maps T to its unsigned counterpart, otherwise
+// leaves it unchanged (unlike std::make_unsigned).
+template <typename T, bool INTEGRAL = std::is_integral<T>::value>
+struct make_unsigned_or_unchanged {
+  using type = T;
+};
+
+template <typename T> struct make_unsigned_or_unchanged<T, true> {
+  using type = typename std::make_unsigned<T>::type;
+};
+
+template <typename Rep, typename Period,
+          FMT_ENABLE_IF(std::is_integral<Rep>::value)>
+inline auto get_milliseconds(std::chrono::duration<Rep, Period> d)
+    -> std::chrono::duration<Rep, std::milli> {
+  // this may overflow and/or the result may not fit in the
+  // target type.
+#if FMT_SAFE_DURATION_CAST
+  using CommonSecondsType =
+      typename std::common_type<decltype(d), std::chrono::seconds>::type;
+  const auto d_as_common = fmt_duration_cast<CommonSecondsType>(d);
+  const auto d_as_whole_seconds =
+      fmt_duration_cast<std::chrono::seconds>(d_as_common);
+  // this conversion should be nonproblematic
+  const auto diff = d_as_common - d_as_whole_seconds;
+  const auto ms =
+      fmt_duration_cast<std::chrono::duration<Rep, std::milli>>(diff);
+  return ms;
+#else
+  auto s = fmt_duration_cast<std::chrono::seconds>(d);
+  return fmt_duration_cast<std::chrono::milliseconds>(d - s);
+#endif
+}
+
+template <typename Char, typename Rep, typename OutputIt,
+          FMT_ENABLE_IF(std::is_integral<Rep>::value)>
+auto format_duration_value(OutputIt out, Rep val, int) -> OutputIt {
+  return write<Char>(out, val);
+}
+
+template <typename Char, typename Rep, typename OutputIt,
+          FMT_ENABLE_IF(std::is_floating_point<Rep>::value)>
+auto format_duration_value(OutputIt out, Rep val, int precision) -> OutputIt {
+  auto specs = format_specs<Char>();
+  specs.precision = precision;
+  specs.type = precision >= 0 ? presentation_type::fixed_lower
+                              : presentation_type::general_lower;
+  return write<Char>(out, val, specs);
+}
+
+template <typename Char, typename OutputIt>
+auto copy_unit(string_view unit, OutputIt out, Char) -> OutputIt {
+  return std::copy(unit.begin(), unit.end(), out);
+}
+
+template <typename OutputIt>
+auto copy_unit(string_view unit, OutputIt out, wchar_t) -> OutputIt {
+  // This works when wchar_t is UTF-32 because units only contain characters
+  // that have the same representation in UTF-16 and UTF-32.
+  utf8_to_utf16 u(unit);
+  return std::copy(u.c_str(), u.c_str() + u.size(), out);
+}
+
+template <typename Char, typename Period, typename OutputIt>
+auto format_duration_unit(OutputIt out) -> OutputIt {
+  if (const char* unit = get_units<Period>())
+    return copy_unit(string_view(unit), out, Char());
+  *out++ = '[';
+  out = write<Char>(out, Period::num);
+  if (const_check(Period::den != 1)) {
+    *out++ = '/';
+    out = write<Char>(out, Period::den);
+  }
+  *out++ = ']';
+  *out++ = 's';
+  return out;
+}
+
+class get_locale {
+ private:
+  union {
+    std::locale locale_;
+  };
+  bool has_locale_ = false;
+
+ public:
+  get_locale(bool localized, locale_ref loc) : has_locale_(localized) {
+    if (localized)
+      ::new (&locale_) std::locale(loc.template get<std::locale>());
+  }
+  ~get_locale() {
+    if (has_locale_) locale_.~locale();
+  }
+  operator const std::locale&() const {
+    return has_locale_ ? locale_ : get_classic_locale();
+  }
+};
+
+template <typename FormatContext, typename OutputIt, typename Rep,
+          typename Period>
+struct chrono_formatter {
+  FormatContext& context;
+  OutputIt out;
+  int precision;
+  bool localized = false;
+  // rep is unsigned to avoid overflow.
+  using rep =
+      conditional_t<std::is_integral<Rep>::value && sizeof(Rep) < sizeof(int),
+                    unsigned, typename make_unsigned_or_unchanged<Rep>::type>;
+  rep val;
+  using seconds = std::chrono::duration<rep>;
+  seconds s;
+  using milliseconds = std::chrono::duration<rep, std::milli>;
+  bool negative;
+
+  using char_type = typename FormatContext::char_type;
+  using tm_writer_type = tm_writer<OutputIt, char_type>;
+
+  chrono_formatter(FormatContext& ctx, OutputIt o,
+                   std::chrono::duration<Rep, Period> d)
+      : context(ctx),
+        out(o),
+        val(static_cast<rep>(d.count())),
+        negative(false) {
+    if (d.count() < 0) {
+      val = 0 - val;
+      negative = true;
+    }
+
+    // this may overflow and/or the result may not fit in the
+    // target type.
+    // might need checked conversion (rep!=Rep)
+    s = fmt_duration_cast<seconds>(std::chrono::duration<rep, Period>(val));
+  }
+
+  // returns true if nan or inf, writes to out.
+  auto handle_nan_inf() -> bool {
+    if (isfinite(val)) {
+      return false;
+    }
+    if (isnan(val)) {
+      write_nan();
+      return true;
+    }
+    // must be +-inf
+    if (val > 0) {
+      write_pinf();
+    } else {
+      write_ninf();
+    }
+    return true;
+  }
+
+  auto days() const -> Rep { return static_cast<Rep>(s.count() / 86400); }
+  auto hour() const -> Rep {
+    return static_cast<Rep>(mod((s.count() / 3600), 24));
+  }
+
+  auto hour12() const -> Rep {
+    Rep hour = static_cast<Rep>(mod((s.count() / 3600), 12));
+    return hour <= 0 ? 12 : hour;
+  }
+
+  auto minute() const -> Rep {
+    return static_cast<Rep>(mod((s.count() / 60), 60));
+  }
+  auto second() const -> Rep { return static_cast<Rep>(mod(s.count(), 60)); }
+
+  auto time() const -> std::tm {
+    auto time = std::tm();
+    time.tm_hour = to_nonnegative_int(hour(), 24);
+    time.tm_min = to_nonnegative_int(minute(), 60);
+    time.tm_sec = to_nonnegative_int(second(), 60);
+    return time;
+  }
+
+  void write_sign() {
+    if (negative) {
+      *out++ = '-';
+      negative = false;
+    }
+  }
+
+  void write(Rep value, int width, pad_type pad = pad_type::unspecified) {
+    write_sign();
+    if (isnan(value)) return write_nan();
+    uint32_or_64_or_128_t<int> n =
+        to_unsigned(to_nonnegative_int(value, max_value<int>()));
+    int num_digits = detail::count_digits(n);
+    if (width > num_digits) {
+      out = detail::write_padding(out, pad, width - num_digits);
+    }
+    out = format_decimal<char_type>(out, n, num_digits).end;
+  }
+
+  void write_nan() { std::copy_n("nan", 3, out); }
+  void write_pinf() { std::copy_n("inf", 3, out); }
+  void write_ninf() { std::copy_n("-inf", 4, out); }
+
+  template <typename Callback, typename... Args>
+  void format_tm(const tm& time, Callback cb, Args... args) {
+    if (isnan(val)) return write_nan();
+    get_locale loc(localized, context.locale());
+    auto w = tm_writer_type(loc, out, time);
+    (w.*cb)(args...);
+    out = w.out();
+  }
+
+  void on_text(const char_type* begin, const char_type* end) {
+    std::copy(begin, end, out);
+  }
+
+  // These are not implemented because durations don't have date information.
+  void on_abbr_weekday() {}
+  void on_full_weekday() {}
+  void on_dec0_weekday(numeric_system) {}
+  void on_dec1_weekday(numeric_system) {}
+  void on_abbr_month() {}
+  void on_full_month() {}
+  void on_datetime(numeric_system) {}
+  void on_loc_date(numeric_system) {}
+  void on_loc_time(numeric_system) {}
+  void on_us_date() {}
+  void on_iso_date() {}
+  void on_utc_offset(numeric_system) {}
+  void on_tz_name() {}
+  void on_year(numeric_system) {}
+  void on_short_year(numeric_system) {}
+  void on_offset_year() {}
+  void on_century(numeric_system) {}
+  void on_iso_week_based_year() {}
+  void on_iso_week_based_short_year() {}
+  void on_dec_month(numeric_system) {}
+  void on_dec0_week_of_year(numeric_system) {}
+  void on_dec1_week_of_year(numeric_system) {}
+  void on_iso_week_of_year(numeric_system) {}
+  void on_day_of_month(numeric_system) {}
+  void on_day_of_month_space(numeric_system) {}
+
+  void on_day_of_year() {
+    if (handle_nan_inf()) return;
+    write(days(), 0);
+  }
+
+  void on_24_hour(numeric_system ns, pad_type pad) {
+    if (handle_nan_inf()) return;
+
+    if (ns == numeric_system::standard) return write(hour(), 2, pad);
+    auto time = tm();
+    time.tm_hour = to_nonnegative_int(hour(), 24);
+    format_tm(time, &tm_writer_type::on_24_hour, ns, pad);
+  }
+
+  void on_12_hour(numeric_system ns, pad_type pad) {
+    if (handle_nan_inf()) return;
+
+    if (ns == numeric_system::standard) return write(hour12(), 2, pad);
+    auto time = tm();
+    time.tm_hour = to_nonnegative_int(hour12(), 12);
+    format_tm(time, &tm_writer_type::on_12_hour, ns, pad);
+  }
+
+  void on_minute(numeric_system ns, pad_type pad) {
+    if (handle_nan_inf()) return;
+
+    if (ns == numeric_system::standard) return write(minute(), 2, pad);
+    auto time = tm();
+    time.tm_min = to_nonnegative_int(minute(), 60);
+    format_tm(time, &tm_writer_type::on_minute, ns, pad);
+  }
+
+  void on_second(numeric_system ns, pad_type pad) {
+    if (handle_nan_inf()) return;
+
+    if (ns == numeric_system::standard) {
+      if (std::is_floating_point<rep>::value) {
+        auto buf = memory_buffer();
+        write_floating_seconds(buf, std::chrono::duration<rep, Period>(val),
+                               precision);
+        if (negative) *out++ = '-';
+        if (buf.size() < 2 || buf[1] == '.') {
+          out = detail::write_padding(out, pad);
+        }
+        out = std::copy(buf.begin(), buf.end(), out);
+      } else {
+        write(second(), 2, pad);
+        write_fractional_seconds<char_type>(
+            out, std::chrono::duration<rep, Period>(val), precision);
+      }
+      return;
+    }
+    auto time = tm();
+    time.tm_sec = to_nonnegative_int(second(), 60);
+    format_tm(time, &tm_writer_type::on_second, ns, pad);
+  }
+
+  void on_12_hour_time() {
+    if (handle_nan_inf()) return;
+    format_tm(time(), &tm_writer_type::on_12_hour_time);
+  }
+
+  void on_24_hour_time() {
+    if (handle_nan_inf()) {
+      *out++ = ':';
+      handle_nan_inf();
+      return;
+    }
+
+    write(hour(), 2);
+    *out++ = ':';
+    write(minute(), 2);
+  }
+
+  void on_iso_time() {
+    on_24_hour_time();
+    *out++ = ':';
+    if (handle_nan_inf()) return;
+    on_second(numeric_system::standard, pad_type::unspecified);
+  }
+
+  void on_am_pm() {
+    if (handle_nan_inf()) return;
+    format_tm(time(), &tm_writer_type::on_am_pm);
+  }
+
+  void on_duration_value() {
+    if (handle_nan_inf()) return;
+    write_sign();
+    out = format_duration_value<char_type>(out, val, precision);
+  }
+
+  void on_duration_unit() {
+    out = format_duration_unit<char_type, Period>(out);
+  }
+};
+
+}  // namespace detail
+
+#if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907
+using weekday = std::chrono::weekday;
+#else
+// A fallback version of weekday.
+class weekday {
+ private:
+  unsigned char value;
+
+ public:
+  weekday() = default;
+  explicit constexpr weekday(unsigned wd) noexcept
+      : value(static_cast<unsigned char>(wd != 7 ? wd : 0)) {}
+  constexpr auto c_encoding() const noexcept -> unsigned { return value; }
+};
+
+class year_month_day {};
+#endif
+
+// A rudimentary weekday formatter.
+template <typename Char> struct formatter<weekday, Char> {
+ private:
+  bool localized = false;
+
+ public:
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto begin = ctx.begin(), end = ctx.end();
+    if (begin != end && *begin == 'L') {
+      ++begin;
+      localized = true;
+    }
+    return begin;
+  }
+
+  template <typename FormatContext>
+  auto format(weekday wd, FormatContext& ctx) const -> decltype(ctx.out()) {
+    auto time = std::tm();
+    time.tm_wday = static_cast<int>(wd.c_encoding());
+    detail::get_locale loc(localized, ctx.locale());
+    auto w = detail::tm_writer<decltype(ctx.out()), Char>(loc, ctx.out(), time);
+    w.on_abbr_weekday();
+    return w.out();
+  }
+};
+
+template <typename Rep, typename Period, typename Char>
+struct formatter<std::chrono::duration<Rep, Period>, Char> {
+ private:
+  format_specs<Char> specs_;
+  detail::arg_ref<Char> width_ref_;
+  detail::arg_ref<Char> precision_ref_;
+  bool localized_ = false;
+  basic_string_view<Char> format_str_;
+
+ public:
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto it = ctx.begin(), end = ctx.end();
+    if (it == end || *it == '}') return it;
+
+    it = detail::parse_align(it, end, specs_);
+    if (it == end) return it;
+
+    it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
+    if (it == end) return it;
+
+    auto checker = detail::chrono_format_checker();
+    if (*it == '.') {
+      checker.has_precision_integral = !std::is_floating_point<Rep>::value;
+      it = detail::parse_precision(it, end, specs_.precision, precision_ref_,
+                                   ctx);
+    }
+    if (it != end && *it == 'L') {
+      localized_ = true;
+      ++it;
+    }
+    end = detail::parse_chrono_format(it, end, checker);
+    format_str_ = {it, detail::to_unsigned(end - it)};
+    return end;
+  }
+
+  template <typename FormatContext>
+  auto format(std::chrono::duration<Rep, Period> d, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto specs = specs_;
+    auto precision = specs.precision;
+    specs.precision = -1;
+    auto begin = format_str_.begin(), end = format_str_.end();
+    // As a possible future optimization, we could avoid extra copying if width
+    // is not specified.
+    auto buf = basic_memory_buffer<Char>();
+    auto out = std::back_inserter(buf);
+    detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
+                                                       ctx);
+    detail::handle_dynamic_spec<detail::precision_checker>(precision,
+                                                           precision_ref_, ctx);
+    if (begin == end || *begin == '}') {
+      out = detail::format_duration_value<Char>(out, d.count(), precision);
+      detail::format_duration_unit<Char, Period>(out);
+    } else {
+      using chrono_formatter =
+          detail::chrono_formatter<FormatContext, decltype(out), Rep, Period>;
+      auto f = chrono_formatter(ctx, out, d);
+      f.precision = precision;
+      f.localized = localized_;
+      detail::parse_chrono_format(begin, end, f);
+    }
+    return detail::write(
+        ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs);
+  }
+};
+
+template <typename Char, typename Duration>
+struct formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
+                 Char> : formatter<std::tm, Char> {
+  FMT_CONSTEXPR formatter() {
+    this->format_str_ = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{};
+  }
+
+  template <typename FormatContext>
+  auto format(std::chrono::time_point<std::chrono::system_clock, Duration> val,
+              FormatContext& ctx) const -> decltype(ctx.out()) {
+    using period = typename Duration::period;
+    if (detail::const_check(
+            period::num != 1 || period::den != 1 ||
+            std::is_floating_point<typename Duration::rep>::value)) {
+      const auto epoch = val.time_since_epoch();
+      auto subsecs = detail::fmt_duration_cast<Duration>(
+          epoch - detail::fmt_duration_cast<std::chrono::seconds>(epoch));
+
+      if (subsecs.count() < 0) {
+        auto second =
+            detail::fmt_duration_cast<Duration>(std::chrono::seconds(1));
+        if (epoch.count() < ((Duration::min)() + second).count())
+          FMT_THROW(format_error("duration is too small"));
+        subsecs += second;
+        val -= second;
+      }
+
+      return formatter<std::tm, Char>::do_format(gmtime(val), ctx, &subsecs);
+    }
+
+    return formatter<std::tm, Char>::format(gmtime(val), ctx);
+  }
+};
+
+#if FMT_USE_LOCAL_TIME
+template <typename Char, typename Duration>
+struct formatter<std::chrono::local_time<Duration>, Char>
+    : formatter<std::tm, Char> {
+  FMT_CONSTEXPR formatter() {
+    this->format_str_ = detail::string_literal<Char, '%', 'F', ' ', '%', 'T'>{};
+  }
+
+  template <typename FormatContext>
+  auto format(std::chrono::local_time<Duration> val, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    using period = typename Duration::period;
+    if (period::num != 1 || period::den != 1 ||
+        std::is_floating_point<typename Duration::rep>::value) {
+      const auto epoch = val.time_since_epoch();
+      const auto subsecs = detail::fmt_duration_cast<Duration>(
+          epoch - detail::fmt_duration_cast<std::chrono::seconds>(epoch));
+
+      return formatter<std::tm, Char>::do_format(localtime(val), ctx, &subsecs);
+    }
+
+    return formatter<std::tm, Char>::format(localtime(val), ctx);
+  }
+};
+#endif
+
+#if FMT_USE_UTC_TIME
+template <typename Char, typename Duration>
+struct formatter<std::chrono::time_point<std::chrono::utc_clock, Duration>,
+                 Char>
+    : formatter<std::chrono::time_point<std::chrono::system_clock, Duration>,
+                Char> {
+  template <typename FormatContext>
+  auto format(std::chrono::time_point<std::chrono::utc_clock, Duration> val,
+              FormatContext& ctx) const -> decltype(ctx.out()) {
+    return formatter<
+        std::chrono::time_point<std::chrono::system_clock, Duration>,
+        Char>::format(std::chrono::utc_clock::to_sys(val), ctx);
+  }
+};
+#endif
+
+template <typename Char> struct formatter<std::tm, Char> {
+ private:
+  format_specs<Char> specs_;
+  detail::arg_ref<Char> width_ref_;
+
+ protected:
+  basic_string_view<Char> format_str_;
+
+  template <typename FormatContext, typename Duration>
+  auto do_format(const std::tm& tm, FormatContext& ctx,
+                 const Duration* subsecs) const -> decltype(ctx.out()) {
+    auto specs = specs_;
+    auto buf = basic_memory_buffer<Char>();
+    auto out = std::back_inserter(buf);
+    detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
+                                                       ctx);
+
+    auto loc_ref = ctx.locale();
+    detail::get_locale loc(static_cast<bool>(loc_ref), loc_ref);
+    auto w =
+        detail::tm_writer<decltype(out), Char, Duration>(loc, out, tm, subsecs);
+    detail::parse_chrono_format(format_str_.begin(), format_str_.end(), w);
+    return detail::write(
+        ctx.out(), basic_string_view<Char>(buf.data(), buf.size()), specs);
+  }
+
+ public:
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto it = ctx.begin(), end = ctx.end();
+    if (it == end || *it == '}') return it;
+
+    it = detail::parse_align(it, end, specs_);
+    if (it == end) return it;
+
+    it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
+    if (it == end) return it;
+
+    end = detail::parse_chrono_format(it, end, detail::tm_format_checker());
+    // Replace the default format_str only if the new spec is not empty.
+    if (end != it) format_str_ = {it, detail::to_unsigned(end - it)};
+    return end;
+  }
+
+  template <typename FormatContext>
+  auto format(const std::tm& tm, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return do_format<FormatContext, std::chrono::seconds>(tm, ctx, nullptr);
+  }
+};
+
+FMT_END_EXPORT
+FMT_END_NAMESPACE
+
+#endif  // FMT_CHRONO_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/color.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/color.h
new file mode 100644
index 0000000000000000000000000000000000000000..367849a86a7c06b72deb786a3de1bb85a11da8a5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/color.h
@@ -0,0 +1,643 @@
+// 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 {
+  FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {}
+  FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
+  FMT_CONSTEXPR rgb(uint32_t hex)
+      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
+  FMT_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 {
+
+// color is a struct of either a rgb color or a terminal color.
+struct color_type {
+  FMT_CONSTEXPR color_type() noexcept : is_rgb(), value{} {}
+  FMT_CONSTEXPR color_type(color rgb_color) noexcept : is_rgb(true), value{} {
+    value.rgb_color = static_cast<uint32_t>(rgb_color);
+  }
+  FMT_CONSTEXPR color_type(rgb rgb_color) noexcept : is_rgb(true), value{} {
+    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
+                      (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
+  }
+  FMT_CONSTEXPR color_type(terminal_color term_color) noexcept
+      : is_rgb(), value{} {
+    value.term_color = static_cast<uint8_t>(term_color);
+  }
+  bool is_rgb;
+  union color_union {
+    uint8_t term_color;
+    uint32_t rgb_color;
+  } value;
+};
+}  // namespace detail
+
+/** A text style consisting of foreground and background colors and emphasis. */
+class text_style {
+ public:
+  FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
+      : set_foreground_color(), set_background_color(), ems(em) {}
+
+  FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& {
+    if (!set_foreground_color) {
+      set_foreground_color = rhs.set_foreground_color;
+      foreground_color = rhs.foreground_color;
+    } else if (rhs.set_foreground_color) {
+      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
+    }
+
+    if (!set_background_color) {
+      set_background_color = rhs.set_background_color;
+      background_color = rhs.background_color;
+    } else if (rhs.set_background_color) {
+      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
+    }
+
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
+                                static_cast<uint8_t>(rhs.ems));
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs)
+      -> text_style {
+    return lhs |= rhs;
+  }
+
+  FMT_CONSTEXPR auto has_foreground() const noexcept -> bool {
+    return set_foreground_color;
+  }
+  FMT_CONSTEXPR auto has_background() const noexcept -> bool {
+    return set_background_color;
+  }
+  FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool {
+    return static_cast<uint8_t>(ems) != 0;
+  }
+  FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {
+    FMT_ASSERT(has_foreground(), "no foreground specified for this style");
+    return foreground_color;
+  }
+  FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type {
+    FMT_ASSERT(has_background(), "no background specified for this style");
+    return background_color;
+  }
+  FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {
+    FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
+    return ems;
+  }
+
+ private:
+  FMT_CONSTEXPR text_style(bool is_foreground,
+                           detail::color_type text_color) noexcept
+      : set_foreground_color(), set_background_color(), ems() {
+    if (is_foreground) {
+      foreground_color = text_color;
+      set_foreground_color = true;
+    } else {
+      background_color = text_color;
+      set_background_color = true;
+    }
+  }
+
+  friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept
+      -> text_style;
+
+  friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept
+      -> text_style;
+
+  detail::color_type foreground_color;
+  detail::color_type background_color;
+  bool set_foreground_color;
+  bool set_background_color;
+  emphasis ems;
+};
+
+/** Creates a text style from the foreground (text) color. */
+FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
+    -> text_style {
+  return text_style(true, foreground);
+}
+
+/** Creates a text style from the background color. */
+FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept
+    -> text_style {
+  return text_style(false, background);
+}
+
+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(detail::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_rgb) {
+      bool is_background = esc == string_view("\x1b[48;2;");
+      uint32_t value = text_color.value.term_color;
+      // 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.rgb_color);
+    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_CONSTEXPR_CHAR_TRAITS auto end() const noexcept -> const Char* {
+    return buffer + std::char_traits<Char>::length(buffer);
+  }
+
+ 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(detail::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(detail::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 : detail::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, const text_style& ts,
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  bool has_style = false;
+  if (ts.has_emphasis()) {
+    has_style = true;
+    auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
+    buf.append(emphasis.begin(), emphasis.end());
+  }
+  if (ts.has_foreground()) {
+    has_style = true;
+    auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
+    buf.append(foreground.begin(), foreground.end());
+  }
+  if (ts.has_background()) {
+    has_style = true;
+    auto background = detail::make_background_color<Char>(ts.get_background());
+    buf.append(background.begin(), background.end());
+  }
+  detail::vformat_to(buf, format_str, args, {});
+  if (has_style) detail::reset_color<Char>(buf);
+}
+
+}  // namespace detail
+
+inline void vprint(std::FILE* f, const text_style& ts, string_view fmt,
+                   format_args args) {
+  // Legacy wide streams are not supported.
+  auto buf = memory_buffer();
+  detail::vformat_to(buf, ts, fmt, args);
+  if (detail::is_utf8()) {
+    detail::print(f, string_view(buf.begin(), buf.size()));
+    return;
+  }
+  buf.push_back('\0');
+  int result = std::fputs(buf.data(), f);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+/**
+  \rst
+  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);
+  \endrst
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(std::FILE* f, const text_style& ts, const S& format_str,
+           const Args&... args) {
+  vprint(f, ts, format_str,
+         fmt::make_format_args<buffer_context<char_t<S>>>(args...));
+}
+
+/**
+  \rst
+  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);
+  \endrst
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(const text_style& ts, const S& format_str, const Args&... args) {
+  return print(stdout, ts, format_str, args...);
+}
+
+template <typename S, typename Char = char_t<S>>
+inline auto vformat(
+    const text_style& ts, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  basic_memory_buffer<Char> buf;
+  detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
+  return fmt::to_string(buf);
+}
+
+/**
+  \rst
+  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);
+  \endrst
+*/
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline auto format(const text_style& ts, const S& format_str,
+                   const Args&... args) -> std::basic_string<Char> {
+  return fmt::vformat(ts, detail::to_string_view(format_str),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+/**
+  Formats a string with the given text_style and writes the output to ``out``.
+ */
+template <typename OutputIt, typename Char,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
+auto vformat_to(OutputIt out, const text_style& ts,
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> OutputIt {
+  auto&& buf = detail::get_buffer<Char>(out);
+  detail::vformat_to(buf, ts, format_str, args);
+  return detail::get_iterator(buf, out);
+}
+
+/**
+  \rst
+  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);
+  \endrst
+*/
+template <
+    typename OutputIt, typename S, typename... Args,
+    bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value &&
+                  detail::is_string<S>::value>
+inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
+                      Args&&... args) ->
+    typename std::enable_if<enable, OutputIt>::type {
+  return vformat_to(out, ts, detail::to_string_view(format_str),
+                    fmt::make_format_args<buffer_context<char_t<S>>>(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;
+    const auto& value = arg.value;
+    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 = std::copy(emphasis.begin(), emphasis.end(), out);
+    }
+    if (ts.has_foreground()) {
+      has_style = true;
+      auto foreground =
+          detail::make_foreground_color<Char>(ts.get_foreground());
+      out = std::copy(foreground.begin(), foreground.end(), out);
+    }
+    if (ts.has_background()) {
+      has_style = true;
+      auto background =
+          detail::make_background_color<Char>(ts.get_background());
+      out = std::copy(background.begin(), background.end(), out);
+    }
+    out = formatter<T, Char>::format(value, ctx);
+    if (has_style) {
+      auto reset_color = string_view("\x1b[0m");
+      out = std::copy(reset_color.begin(), reset_color.end(), out);
+    }
+    return out;
+  }
+};
+
+/**
+  \rst
+  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)));
+  \endrst
+ */
+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_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/compile.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/compile.h
new file mode 100644
index 0000000000000000000000000000000000000000..3b3f166e0cd0cb156e1c2cc5061c4a5f6b893d0f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/compile.h
@@ -0,0 +1,535 @@
+// 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_
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template <typename Char, typename InputIt>
+FMT_CONSTEXPR inline auto copy_str(InputIt begin, InputIt end,
+                                   counting_iterator it) -> counting_iterator {
+  return it + (end - begin);
+}
+
+// A compile-time string which is compiled into fast formatting code.
+class compiled_string {};
+
+template <typename S>
+struct is_compiled_string : std::is_base_of<compiled_string, S> {};
+
+/**
+  \rst
+  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);
+  \endrst
+ */
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+#  define FMT_COMPILE(s) \
+    FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit)
+#else
+#  define FMT_COMPILE(s) FMT_STRING(s)
+#endif
+
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template <typename Char, size_t N,
+          fmt::detail_exported::fixed_string<Char, N> Str>
+struct udl_compiled_string : compiled_string {
+  using char_type = Char;
+  explicit constexpr operator basic_string_view<char_type>() const {
+    return {Str.data, N - 1};
+  }
+};
+#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...);
+}
+
+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_v<T, basic_string_view<Char>>) {
+      auto s = basic_string_view<Char>(arg);
+      return copy_str<Char>(s.begin(), s.end(), out);
+    }
+    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 format_str);
+
+template <typename Args, size_t POS, int ID, typename T, typename S>
+constexpr auto parse_tail(T head, S format_str) {
+  if constexpr (POS !=
+                basic_string_view<typename S::char_type>(format_str).size()) {
+    constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
+    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_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) {
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+  constexpr int on_name(basic_string_view<Char> id) {
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+};
+
+template <typename Char> struct parse_arg_id_result {
+  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_ref<Char>{}};
+  auto arg_id_end = parse_arg_id(begin, end, handler);
+  return parse_arg_id_result<Char>{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 format_str) {
+  using char_type = typename S::char_type;
+  constexpr auto str = basic_string_view<char_type>(format_str);
+  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>(),
+        format_str);
+  } 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},
+          format_str);
+    }
+  }
+}
+
+// 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 format_str) {
+  using char_type = typename S::char_type;
+  constexpr auto str = basic_string_view<char_type>(format_str);
+  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), format_str);
+    } 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>(
+          format_str);
+    } 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.arg_id.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.val.index;
+        return parse_replacement_field_then_tail<get_type<arg_index, Args>,
+                                                 Args, arg_id_end_pos,
+                                                 arg_index, manual_indexing_id>(
+            format_str);
+      } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
+        constexpr auto arg_index =
+            get_arg_index_by_name(arg_id_result.arg_id.val.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>(format_str);
+        } else if constexpr (c == '}') {
+          return parse_tail<Args, arg_id_end_pos + 1, ID>(
+              runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
+              format_str);
+        } 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), format_str);
+  } 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),
+                                       format_str);
+    } else {
+      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]},
+                                       format_str);
+    }
+  }
+}
+
+template <typename... Args, typename S,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+constexpr auto compile(S format_str) {
+  constexpr auto str = basic_string_view<typename S::char_type>(format_str);
+  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>(
+            format_str);
+    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(detail::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(detail::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(detail::is_compiled_string<S>::value)>
+auto format_to_n(OutputIt out, size_t n, const S& format_str, 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), format_str,
+                 std::forward<Args>(args)...);
+  return {buf.out(), buf.count()};
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+FMT_CONSTEXPR20 auto formatted_size(const S& format_str, const Args&... args)
+    -> size_t {
+  return fmt::format_to(detail::counting_iterator(), format_str, args...)
+      .count();
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(std::FILE* f, const S& format_str, const Args&... args) {
+  memory_buffer buffer;
+  fmt::format_to(std::back_inserter(buffer), format_str, args...);
+  detail::print(f, {buffer.data(), buffer.size()});
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(const S& format_str, const Args&... args) {
+  print(stdout, format_str, args...);
+}
+
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+inline namespace literals {
+template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
+  using char_t = remove_cvref_t<decltype(Str.data[0])>;
+  return detail::udl_compiled_string<char_t, sizeof(Str.data) / sizeof(char_t),
+                                     Str>();
+}
+}  // namespace literals
+#endif
+
+FMT_END_EXPORT
+FMT_END_NAMESPACE
+
+#endif  // FMT_COMPILE_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/core.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/core.h
new file mode 100644
index 0000000000000000000000000000000000000000..b51c1406a9907d6d612099c0c123d0df77930239
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/core.h
@@ -0,0 +1,2969 @@
+// Formatting library for C++ - the core API for char/UTF-8
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_CORE_H_
+#define FMT_CORE_H_
+
+#include <cstddef>  // std::byte
+#include <cstdio>   // std::FILE
+#include <cstring>  // std::strlen
+#include <iterator>
+#include <limits>
+#include <memory>  // std::addressof
+#include <string>
+#include <type_traits>
+
+// The fmt library version in the form major * 10000 + minor * 100 + patch.
+#define FMT_VERSION 100201
+
+#if defined(__clang__) && !defined(__ibmxl__)
+#  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
+#else
+#  define FMT_CLANG_VERSION 0
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER) && \
+    !defined(__NVCOMPILER)
+#  define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+#else
+#  define FMT_GCC_VERSION 0
+#endif
+
+#ifndef FMT_GCC_PRAGMA
+// Workaround _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884.
+#  if FMT_GCC_VERSION >= 504
+#    define FMT_GCC_PRAGMA(arg) _Pragma(arg)
+#  else
+#    define FMT_GCC_PRAGMA(arg)
+#  endif
+#endif
+
+#ifdef __ICL
+#  define FMT_ICC_VERSION __ICL
+#elif defined(__INTEL_COMPILER)
+#  define FMT_ICC_VERSION __INTEL_COMPILER
+#else
+#  define FMT_ICC_VERSION 0
+#endif
+
+#ifdef _MSC_VER
+#  define FMT_MSC_VERSION _MSC_VER
+#  define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__))
+#else
+#  define FMT_MSC_VERSION 0
+#  define FMT_MSC_WARNING(...)
+#endif
+
+#ifdef _MSVC_LANG
+#  define FMT_CPLUSPLUS _MSVC_LANG
+#else
+#  define FMT_CPLUSPLUS __cplusplus
+#endif
+
+#ifdef __has_feature
+#  define FMT_HAS_FEATURE(x) __has_feature(x)
+#else
+#  define FMT_HAS_FEATURE(x) 0
+#endif
+
+#if defined(__has_include) || FMT_ICC_VERSION >= 1600 || FMT_MSC_VERSION > 1900
+#  define FMT_HAS_INCLUDE(x) __has_include(x)
+#else
+#  define FMT_HAS_INCLUDE(x) 0
+#endif
+
+#ifdef __has_cpp_attribute
+#  define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+#  define FMT_HAS_CPP_ATTRIBUTE(x) 0
+#endif
+
+#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \
+  (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))
+
+#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \
+  (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))
+
+// Check if relaxed C++14 constexpr is supported.
+// GCC doesn't allow throw in constexpr until version 6 (bug 67371).
+#ifndef FMT_USE_CONSTEXPR
+#  if (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912 || \
+       (FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L)) &&             \
+      !FMT_ICC_VERSION && (!defined(__NVCC__) || FMT_CPLUSPLUS >= 202002L)
+#    define FMT_USE_CONSTEXPR 1
+#  else
+#    define FMT_USE_CONSTEXPR 0
+#  endif
+#endif
+#if FMT_USE_CONSTEXPR
+#  define FMT_CONSTEXPR constexpr
+#else
+#  define FMT_CONSTEXPR
+#endif
+
+#if (FMT_CPLUSPLUS >= 202002L ||                                \
+     (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)) &&  \
+    ((!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 10) &&  \
+     (!defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 10000) && \
+     (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1928)) &&          \
+    defined(__cpp_lib_is_constant_evaluated)
+#  define FMT_CONSTEXPR20 constexpr
+#else
+#  define FMT_CONSTEXPR20
+#endif
+
+// Check if constexpr std::char_traits<>::{compare,length} are supported.
+#if defined(__GLIBCXX__)
+#  if FMT_CPLUSPLUS >= 201703L && defined(_GLIBCXX_RELEASE) && \
+      _GLIBCXX_RELEASE >= 7  // GCC 7+ libstdc++ has _GLIBCXX_RELEASE.
+#    define FMT_CONSTEXPR_CHAR_TRAITS constexpr
+#  endif
+#elif defined(_LIBCPP_VERSION) && FMT_CPLUSPLUS >= 201703L && \
+    _LIBCPP_VERSION >= 4000
+#  define FMT_CONSTEXPR_CHAR_TRAITS constexpr
+#elif FMT_MSC_VERSION >= 1914 && FMT_CPLUSPLUS >= 201703L
+#  define FMT_CONSTEXPR_CHAR_TRAITS constexpr
+#endif
+#ifndef FMT_CONSTEXPR_CHAR_TRAITS
+#  define FMT_CONSTEXPR_CHAR_TRAITS
+#endif
+
+// Check if exceptions are disabled.
+#ifndef FMT_EXCEPTIONS
+#  if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
+      (FMT_MSC_VERSION && !_HAS_EXCEPTIONS)
+#    define FMT_EXCEPTIONS 0
+#  else
+#    define FMT_EXCEPTIONS 1
+#  endif
+#endif
+
+// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings.
+#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && \
+    !defined(__NVCC__)
+#  define FMT_NORETURN [[noreturn]]
+#else
+#  define FMT_NORETURN
+#endif
+
+#ifndef FMT_NODISCARD
+#  if FMT_HAS_CPP17_ATTRIBUTE(nodiscard)
+#    define FMT_NODISCARD [[nodiscard]]
+#  else
+#    define FMT_NODISCARD
+#  endif
+#endif
+
+#ifndef FMT_INLINE
+#  if FMT_GCC_VERSION || FMT_CLANG_VERSION
+#    define FMT_INLINE inline __attribute__((always_inline))
+#  else
+#    define FMT_INLINE inline
+#  endif
+#endif
+
+#ifdef _MSC_VER
+#  define FMT_UNCHECKED_ITERATOR(It) \
+    using _Unchecked_type = It  // Mark iterator as checked.
+#else
+#  define FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It
+#endif
+
+#ifndef FMT_BEGIN_NAMESPACE
+#  define FMT_BEGIN_NAMESPACE \
+    namespace fmt {           \
+    inline namespace v10 {
+#  define FMT_END_NAMESPACE \
+    }                       \
+    }
+#endif
+
+#ifndef FMT_EXPORT
+#  define FMT_EXPORT
+#  define FMT_BEGIN_EXPORT
+#  define FMT_END_EXPORT
+#endif
+
+#if FMT_GCC_VERSION || FMT_CLANG_VERSION
+#  define FMT_VISIBILITY(value) __attribute__((visibility(value)))
+#else
+#  define FMT_VISIBILITY(value)
+#endif
+
+#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
+#  if defined(FMT_LIB_EXPORT)
+#    define FMT_API __declspec(dllexport)
+#  elif defined(FMT_SHARED)
+#    define FMT_API __declspec(dllimport)
+#  endif
+#elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
+#  define FMT_API FMT_VISIBILITY("default")
+#endif
+#ifndef FMT_API
+#  define FMT_API
+#endif
+
+// libc++ supports string_view in pre-c++17.
+#if FMT_HAS_INCLUDE(<string_view>) && \
+    (FMT_CPLUSPLUS >= 201703L || defined(_LIBCPP_VERSION))
+#  include <string_view>
+#  define FMT_USE_STRING_VIEW
+#elif FMT_HAS_INCLUDE("experimental/string_view") && FMT_CPLUSPLUS >= 201402L
+#  include <experimental/string_view>
+#  define FMT_USE_EXPERIMENTAL_STRING_VIEW
+#endif
+
+#ifndef FMT_UNICODE
+#  define FMT_UNICODE !FMT_MSC_VERSION
+#endif
+
+#ifndef FMT_CONSTEVAL
+#  if ((FMT_GCC_VERSION >= 1000 || FMT_CLANG_VERSION >= 1101) && \
+       (!defined(__apple_build_version__) ||                     \
+        __apple_build_version__ >= 14000029L) &&                 \
+       FMT_CPLUSPLUS >= 202002L) ||                              \
+      (defined(__cpp_consteval) &&                               \
+       (!FMT_MSC_VERSION || FMT_MSC_VERSION >= 1929))
+// consteval is broken in MSVC before VS2019 version 16.10 and Apple clang
+// before 14.
+#    define FMT_CONSTEVAL consteval
+#    define FMT_HAS_CONSTEVAL
+#  else
+#    define FMT_CONSTEVAL
+#  endif
+#endif
+
+#ifndef FMT_USE_NONTYPE_TEMPLATE_ARGS
+#  if defined(__cpp_nontype_template_args) &&                  \
+      ((FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L) || \
+       __cpp_nontype_template_args >= 201911L) &&              \
+      !defined(__NVCOMPILER) && !defined(__LCC__)
+#    define FMT_USE_NONTYPE_TEMPLATE_ARGS 1
+#  else
+#    define FMT_USE_NONTYPE_TEMPLATE_ARGS 0
+#  endif
+#endif
+
+// GCC < 5 requires this-> in decltype
+#ifndef FMT_DECLTYPE_THIS
+#  if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
+#    define FMT_DECLTYPE_THIS this->
+#  else
+#    define FMT_DECLTYPE_THIS
+#  endif
+#endif
+
+// Enable minimal optimizations for more compact code in debug mode.
+FMT_GCC_PRAGMA("GCC push_options")
+#if !defined(__OPTIMIZE__) && !defined(__NVCOMPILER) && !defined(__LCC__) && \
+    !defined(__CUDACC__)
+FMT_GCC_PRAGMA("GCC optimize(\"Og\")")
+#endif
+
+FMT_BEGIN_NAMESPACE
+
+// Implementations of enable_if_t and other metafunctions for older systems.
+template <bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+template <bool B, typename T, typename F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+template <bool B> using bool_constant = std::integral_constant<bool, B>;
+template <typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+template <typename T>
+using remove_const_t = typename std::remove_const<T>::type;
+template <typename T>
+using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
+template <typename T> struct type_identity {
+  using type = T;
+};
+template <typename T> using type_identity_t = typename type_identity<T>::type;
+template <typename T>
+using underlying_t = typename std::underlying_type<T>::type;
+
+// Checks whether T is a container with contiguous storage.
+template <typename T> struct is_contiguous : std::false_type {};
+template <typename Char>
+struct is_contiguous<std::basic_string<Char>> : std::true_type {};
+
+struct monostate {
+  constexpr monostate() {}
+};
+
+// An enable_if helper to be used in template parameters which results in much
+// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
+// to workaround a bug in MSVC 2019 (see #1140 and #1186).
+#ifdef FMT_DOC
+#  define FMT_ENABLE_IF(...)
+#else
+#  define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0
+#endif
+
+// This is defined in core.h instead of format.h to avoid injecting in std.
+// It is a template to avoid undesirable implicit conversions to std::byte.
+#ifdef __cpp_lib_byte
+template <typename T, FMT_ENABLE_IF(std::is_same<T, std::byte>::value)>
+inline auto format_as(T b) -> unsigned char {
+  return static_cast<unsigned char>(b);
+}
+#endif
+
+namespace detail {
+// Suppresses "unused variable" warnings with the method described in
+// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/.
+// (void)var does not work on many Intel compilers.
+template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {}
+
+constexpr FMT_INLINE auto is_constant_evaluated(
+    bool default_value = false) noexcept -> bool {
+// Workaround for incompatibility between libstdc++ consteval-based
+// std::is_constant_evaluated() implementation and clang-14.
+// https://github.com/fmtlib/fmt/issues/3247
+#if FMT_CPLUSPLUS >= 202002L && defined(_GLIBCXX_RELEASE) && \
+    _GLIBCXX_RELEASE >= 12 &&                                \
+    (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500)
+  ignore_unused(default_value);
+  return __builtin_is_constant_evaluated();
+#elif defined(__cpp_lib_is_constant_evaluated)
+  ignore_unused(default_value);
+  return std::is_constant_evaluated();
+#else
+  return default_value;
+#endif
+}
+
+// Suppresses "conditional expression is constant" warnings.
+template <typename T> constexpr FMT_INLINE auto const_check(T value) -> T {
+  return value;
+}
+
+FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
+                                      const char* message);
+
+#ifndef FMT_ASSERT
+#  ifdef NDEBUG
+// FMT_ASSERT is not empty to avoid -Wempty-body.
+#    define FMT_ASSERT(condition, message) \
+      fmt::detail::ignore_unused((condition), (message))
+#  else
+#    define FMT_ASSERT(condition, message)                                    \
+      ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
+           ? (void)0                                                          \
+           : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
+#  endif
+#endif
+
+#if defined(FMT_USE_STRING_VIEW)
+template <typename Char> using std_string_view = std::basic_string_view<Char>;
+#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
+template <typename Char>
+using std_string_view = std::experimental::basic_string_view<Char>;
+#else
+template <typename T> struct std_string_view {};
+#endif
+
+#ifdef FMT_USE_INT128
+// Do nothing.
+#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \
+    !(FMT_CLANG_VERSION && FMT_MSC_VERSION)
+#  define FMT_USE_INT128 1
+using int128_opt = __int128_t;  // An optional native 128-bit integer.
+using uint128_opt = __uint128_t;
+template <typename T> inline auto convert_for_visit(T value) -> T {
+  return value;
+}
+#else
+#  define FMT_USE_INT128 0
+#endif
+#if !FMT_USE_INT128
+enum class int128_opt {};
+enum class uint128_opt {};
+// Reduce template instantiations.
+template <typename T> auto convert_for_visit(T) -> monostate { return {}; }
+#endif
+
+// Casts a nonnegative integer to unsigned.
+template <typename Int>
+FMT_CONSTEXPR auto to_unsigned(Int value) ->
+    typename std::make_unsigned<Int>::type {
+  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
+  return static_cast<typename std::make_unsigned<Int>::type>(value);
+}
+
+FMT_CONSTEXPR inline auto is_utf8() -> bool {
+  FMT_MSC_WARNING(suppress : 4566) constexpr unsigned char section[] = "\u00A7";
+
+  // Avoid buggy sign extensions in MSVC's constant evaluation mode (#2297).
+  using uchar = unsigned char;
+  return FMT_UNICODE || (sizeof(section) == 3 && uchar(section[0]) == 0xC2 &&
+                         uchar(section[1]) == 0xA7);
+}
+}  // namespace detail
+
+/**
+  An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
+  subset of the API. ``fmt::basic_string_view`` is used for format strings even
+  if ``std::string_view`` is available to prevent issues when a library is
+  compiled with a different ``-std`` option than the client code (which is not
+  recommended).
+ */
+FMT_EXPORT
+template <typename Char> class basic_string_view {
+ private:
+  const Char* data_;
+  size_t size_;
+
+ public:
+  using value_type = Char;
+  using iterator = const Char*;
+
+  constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {}
+
+  /** Constructs a string reference object from a C string and a size. */
+  constexpr basic_string_view(const Char* s, size_t count) noexcept
+      : data_(s), size_(count) {}
+
+  /**
+    \rst
+    Constructs a string reference object from a C string computing
+    the size with ``std::char_traits<Char>::length``.
+    \endrst
+   */
+  FMT_CONSTEXPR_CHAR_TRAITS
+  FMT_INLINE
+  basic_string_view(const Char* s)
+      : data_(s),
+        size_(detail::const_check(std::is_same<Char, char>::value &&
+                                  !detail::is_constant_evaluated(true))
+                  ? std::strlen(reinterpret_cast<const char*>(s))
+                  : std::char_traits<Char>::length(s)) {}
+
+  /** Constructs a string reference from a ``std::basic_string`` object. */
+  template <typename Traits, typename Alloc>
+  FMT_CONSTEXPR basic_string_view(
+      const std::basic_string<Char, Traits, Alloc>& s) noexcept
+      : data_(s.data()), size_(s.size()) {}
+
+  template <typename S, FMT_ENABLE_IF(std::is_same<
+                                      S, detail::std_string_view<Char>>::value)>
+  FMT_CONSTEXPR basic_string_view(S s) noexcept
+      : data_(s.data()), size_(s.size()) {}
+
+  /** Returns a pointer to the string data. */
+  constexpr auto data() const noexcept -> const Char* { return data_; }
+
+  /** Returns the string size. */
+  constexpr auto size() const noexcept -> size_t { return size_; }
+
+  constexpr auto begin() const noexcept -> iterator { return data_; }
+  constexpr auto end() const noexcept -> iterator { return data_ + size_; }
+
+  constexpr auto operator[](size_t pos) const noexcept -> const Char& {
+    return data_[pos];
+  }
+
+  FMT_CONSTEXPR void remove_prefix(size_t n) noexcept {
+    data_ += n;
+    size_ -= n;
+  }
+
+  FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(
+      basic_string_view<Char> sv) const noexcept -> bool {
+    return size_ >= sv.size_ &&
+           std::char_traits<Char>::compare(data_, sv.data_, sv.size_) == 0;
+  }
+  FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(Char c) const noexcept -> bool {
+    return size_ >= 1 && std::char_traits<Char>::eq(*data_, c);
+  }
+  FMT_CONSTEXPR_CHAR_TRAITS auto starts_with(const Char* s) const -> bool {
+    return starts_with(basic_string_view<Char>(s));
+  }
+
+  // Lexicographically compare this string reference to other.
+  FMT_CONSTEXPR_CHAR_TRAITS auto compare(basic_string_view other) const -> int {
+    size_t str_size = size_ < other.size_ ? size_ : other.size_;
+    int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
+    if (result == 0)
+      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
+    return result;
+  }
+
+  FMT_CONSTEXPR_CHAR_TRAITS friend auto operator==(basic_string_view lhs,
+                                                   basic_string_view rhs)
+      -> bool {
+    return lhs.compare(rhs) == 0;
+  }
+  friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {
+    return lhs.compare(rhs) != 0;
+  }
+  friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool {
+    return lhs.compare(rhs) < 0;
+  }
+  friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool {
+    return lhs.compare(rhs) <= 0;
+  }
+  friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool {
+    return lhs.compare(rhs) > 0;
+  }
+  friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool {
+    return lhs.compare(rhs) >= 0;
+  }
+};
+
+FMT_EXPORT
+using string_view = basic_string_view<char>;
+
+/** Specifies if ``T`` is a character type. Can be specialized by users. */
+FMT_EXPORT
+template <typename T> struct is_char : std::false_type {};
+template <> struct is_char<char> : std::true_type {};
+
+namespace detail {
+
+// A base class for compile-time strings.
+struct compile_string {};
+
+template <typename S>
+struct is_compile_string : std::is_base_of<compile_string, S> {};
+
+template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
+FMT_INLINE auto to_string_view(const Char* s) -> basic_string_view<Char> {
+  return s;
+}
+template <typename Char, typename Traits, typename Alloc>
+inline auto to_string_view(const std::basic_string<Char, Traits, Alloc>& s)
+    -> basic_string_view<Char> {
+  return s;
+}
+template <typename Char>
+constexpr auto to_string_view(basic_string_view<Char> s)
+    -> basic_string_view<Char> {
+  return s;
+}
+template <typename Char,
+          FMT_ENABLE_IF(!std::is_empty<std_string_view<Char>>::value)>
+inline auto to_string_view(std_string_view<Char> s) -> basic_string_view<Char> {
+  return s;
+}
+template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
+constexpr auto to_string_view(const S& s)
+    -> basic_string_view<typename S::char_type> {
+  return basic_string_view<typename S::char_type>(s);
+}
+void to_string_view(...);
+
+// Specifies whether S is a string type convertible to fmt::basic_string_view.
+// It should be a constexpr function but MSVC 2017 fails to compile it in
+// enable_if and MSVC 2015 fails to compile it as an alias template.
+// ADL is intentionally disabled as to_string_view is not an extension point.
+template <typename S>
+struct is_string
+    : std::is_class<decltype(detail::to_string_view(std::declval<S>()))> {};
+
+template <typename S, typename = void> struct char_t_impl {};
+template <typename S> struct char_t_impl<S, enable_if_t<is_string<S>::value>> {
+  using result = decltype(to_string_view(std::declval<S>()));
+  using type = typename result::value_type;
+};
+
+enum class type {
+  none_type,
+  // Integer types should go first,
+  int_type,
+  uint_type,
+  long_long_type,
+  ulong_long_type,
+  int128_type,
+  uint128_type,
+  bool_type,
+  char_type,
+  last_integer_type = char_type,
+  // followed by floating-point types.
+  float_type,
+  double_type,
+  long_double_type,
+  last_numeric_type = long_double_type,
+  cstring_type,
+  string_type,
+  pointer_type,
+  custom_type
+};
+
+// Maps core type T to the corresponding type enum constant.
+template <typename T, typename Char>
+struct type_constant : std::integral_constant<type, type::custom_type> {};
+
+#define FMT_TYPE_CONSTANT(Type, constant) \
+  template <typename Char>                \
+  struct type_constant<Type, Char>        \
+      : std::integral_constant<type, type::constant> {}
+
+FMT_TYPE_CONSTANT(int, int_type);
+FMT_TYPE_CONSTANT(unsigned, uint_type);
+FMT_TYPE_CONSTANT(long long, long_long_type);
+FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
+FMT_TYPE_CONSTANT(int128_opt, int128_type);
+FMT_TYPE_CONSTANT(uint128_opt, uint128_type);
+FMT_TYPE_CONSTANT(bool, bool_type);
+FMT_TYPE_CONSTANT(Char, char_type);
+FMT_TYPE_CONSTANT(float, float_type);
+FMT_TYPE_CONSTANT(double, double_type);
+FMT_TYPE_CONSTANT(long double, long_double_type);
+FMT_TYPE_CONSTANT(const Char*, cstring_type);
+FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
+FMT_TYPE_CONSTANT(const void*, pointer_type);
+
+constexpr auto is_integral_type(type t) -> bool {
+  return t > type::none_type && t <= type::last_integer_type;
+}
+constexpr auto is_arithmetic_type(type t) -> bool {
+  return t > type::none_type && t <= type::last_numeric_type;
+}
+
+constexpr auto set(type rhs) -> int { return 1 << static_cast<int>(rhs); }
+constexpr auto in(type t, int set) -> bool {
+  return ((set >> static_cast<int>(t)) & 1) != 0;
+}
+
+// Bitsets of types.
+enum {
+  sint_set =
+      set(type::int_type) | set(type::long_long_type) | set(type::int128_type),
+  uint_set = set(type::uint_type) | set(type::ulong_long_type) |
+             set(type::uint128_type),
+  bool_set = set(type::bool_type),
+  char_set = set(type::char_type),
+  float_set = set(type::float_type) | set(type::double_type) |
+              set(type::long_double_type),
+  string_set = set(type::string_type),
+  cstring_set = set(type::cstring_type),
+  pointer_set = set(type::pointer_type)
+};
+
+// DEPRECATED!
+FMT_NORETURN FMT_API void throw_format_error(const char* message);
+
+struct error_handler {
+  constexpr error_handler() = default;
+
+  // This function is intentionally not constexpr to give a compile-time error.
+  FMT_NORETURN void on_error(const char* message) {
+    throw_format_error(message);
+  }
+};
+}  // namespace detail
+
+/** Throws ``format_error`` with a given message. */
+using detail::throw_format_error;
+
+/** String's character type. */
+template <typename S> using char_t = typename detail::char_t_impl<S>::type;
+
+/**
+  \rst
+  Parsing context consisting of a format string range being parsed and an
+  argument counter for automatic indexing.
+  You can use the ``format_parse_context`` type alias for ``char`` instead.
+  \endrst
+ */
+FMT_EXPORT
+template <typename Char> class basic_format_parse_context {
+ private:
+  basic_string_view<Char> format_str_;
+  int next_arg_id_;
+
+  FMT_CONSTEXPR void do_check_arg_id(int id);
+
+ public:
+  using char_type = Char;
+  using iterator = const Char*;
+
+  explicit constexpr basic_format_parse_context(
+      basic_string_view<Char> format_str, int next_arg_id = 0)
+      : format_str_(format_str), next_arg_id_(next_arg_id) {}
+
+  /**
+    Returns an iterator to the beginning of the format string range being
+    parsed.
+   */
+  constexpr auto begin() const noexcept -> iterator {
+    return format_str_.begin();
+  }
+
+  /**
+    Returns an iterator past the end of the format string range being parsed.
+   */
+  constexpr auto end() const noexcept -> iterator { return format_str_.end(); }
+
+  /** Advances the begin iterator to ``it``. */
+  FMT_CONSTEXPR void advance_to(iterator it) {
+    format_str_.remove_prefix(detail::to_unsigned(it - begin()));
+  }
+
+  /**
+    Reports an error if using the manual argument indexing; otherwise returns
+    the next argument index and switches to the automatic indexing.
+   */
+  FMT_CONSTEXPR auto next_arg_id() -> int {
+    if (next_arg_id_ < 0) {
+      detail::throw_format_error(
+          "cannot switch from manual to automatic argument indexing");
+      return 0;
+    }
+    int id = next_arg_id_++;
+    do_check_arg_id(id);
+    return id;
+  }
+
+  /**
+    Reports an error if using the automatic argument indexing; otherwise
+    switches to the manual indexing.
+   */
+  FMT_CONSTEXPR void check_arg_id(int id) {
+    if (next_arg_id_ > 0) {
+      detail::throw_format_error(
+          "cannot switch from automatic to manual argument indexing");
+      return;
+    }
+    next_arg_id_ = -1;
+    do_check_arg_id(id);
+  }
+  FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}
+  FMT_CONSTEXPR void check_dynamic_spec(int arg_id);
+};
+
+FMT_EXPORT
+using format_parse_context = basic_format_parse_context<char>;
+
+namespace detail {
+// A parse context with extra data used only in compile-time checks.
+template <typename Char>
+class compile_parse_context : public basic_format_parse_context<Char> {
+ private:
+  int num_args_;
+  const type* types_;
+  using base = basic_format_parse_context<Char>;
+
+ public:
+  explicit FMT_CONSTEXPR compile_parse_context(
+      basic_string_view<Char> format_str, int num_args, const type* types,
+      int next_arg_id = 0)
+      : base(format_str, next_arg_id), num_args_(num_args), types_(types) {}
+
+  constexpr auto num_args() const -> int { return num_args_; }
+  constexpr auto arg_type(int id) const -> type { return types_[id]; }
+
+  FMT_CONSTEXPR auto next_arg_id() -> int {
+    int id = base::next_arg_id();
+    if (id >= num_args_) throw_format_error("argument not found");
+    return id;
+  }
+
+  FMT_CONSTEXPR void check_arg_id(int id) {
+    base::check_arg_id(id);
+    if (id >= num_args_) throw_format_error("argument not found");
+  }
+  using base::check_arg_id;
+
+  FMT_CONSTEXPR void check_dynamic_spec(int arg_id) {
+    detail::ignore_unused(arg_id);
+#if !defined(__LCC__)
+    if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id]))
+      throw_format_error("width/precision is not integer");
+#endif
+  }
+};
+
+// Extracts a reference to the container from back_insert_iterator.
+template <typename Container>
+inline auto get_container(std::back_insert_iterator<Container> it)
+    -> Container& {
+  using base = std::back_insert_iterator<Container>;
+  struct accessor : base {
+    accessor(base b) : base(b) {}
+    using base::container;
+  };
+  return *accessor(it).container;
+}
+
+template <typename Char, typename InputIt, typename OutputIt>
+FMT_CONSTEXPR auto copy_str(InputIt begin, InputIt end, OutputIt out)
+    -> OutputIt {
+  while (begin != end) *out++ = static_cast<Char>(*begin++);
+  return out;
+}
+
+template <typename Char, typename T, typename U,
+          FMT_ENABLE_IF(
+              std::is_same<remove_const_t<T>, U>::value&& is_char<U>::value)>
+FMT_CONSTEXPR auto copy_str(T* begin, T* end, U* out) -> U* {
+  if (is_constant_evaluated()) return copy_str<Char, T*, U*>(begin, end, out);
+  auto size = to_unsigned(end - begin);
+  if (size > 0) memcpy(out, begin, size * sizeof(U));
+  return out + size;
+}
+
+/**
+  \rst
+  A contiguous memory buffer with an optional growing ability. It is an internal
+  class and shouldn't be used directly, only via `~fmt::basic_memory_buffer`.
+  \endrst
+ */
+template <typename T> class buffer {
+ private:
+  T* ptr_;
+  size_t size_;
+  size_t capacity_;
+
+ protected:
+  // Don't initialize ptr_ since it is not accessed to save a few cycles.
+  FMT_MSC_WARNING(suppress : 26495)
+  FMT_CONSTEXPR buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {}
+
+  FMT_CONSTEXPR20 buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept
+      : ptr_(p), size_(sz), capacity_(cap) {}
+
+  FMT_CONSTEXPR20 ~buffer() = default;
+  buffer(buffer&&) = default;
+
+  /** Sets the buffer data and capacity. */
+  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
+    ptr_ = buf_data;
+    capacity_ = buf_capacity;
+  }
+
+  /** Increases the buffer capacity to hold at least *capacity* elements. */
+  // DEPRECATED!
+  virtual FMT_CONSTEXPR20 void grow(size_t capacity) = 0;
+
+ public:
+  using value_type = T;
+  using const_reference = const T&;
+
+  buffer(const buffer&) = delete;
+  void operator=(const buffer&) = delete;
+
+  FMT_INLINE auto begin() noexcept -> T* { return ptr_; }
+  FMT_INLINE auto end() noexcept -> T* { return ptr_ + size_; }
+
+  FMT_INLINE auto begin() const noexcept -> const T* { return ptr_; }
+  FMT_INLINE auto end() const noexcept -> const T* { return ptr_ + size_; }
+
+  /** Returns the size of this buffer. */
+  constexpr auto size() const noexcept -> size_t { return size_; }
+
+  /** Returns the capacity of this buffer. */
+  constexpr auto capacity() const noexcept -> size_t { return capacity_; }
+
+  /** Returns a pointer to the buffer data (not null-terminated). */
+  FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
+  FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }
+
+  /** Clears this buffer. */
+  void clear() { size_ = 0; }
+
+  // Tries resizing the buffer to contain *count* elements. If T is a POD type
+  // the new elements may not be initialized.
+  FMT_CONSTEXPR20 void try_resize(size_t count) {
+    try_reserve(count);
+    size_ = count <= capacity_ ? count : capacity_;
+  }
+
+  // Tries increasing the buffer capacity to *new_capacity*. It can increase the
+  // capacity by a smaller amount than requested but guarantees there is space
+  // for at least one additional element either by increasing the capacity or by
+  // flushing the buffer if it is full.
+  FMT_CONSTEXPR20 void try_reserve(size_t new_capacity) {
+    if (new_capacity > capacity_) grow(new_capacity);
+  }
+
+  FMT_CONSTEXPR20 void push_back(const T& value) {
+    try_reserve(size_ + 1);
+    ptr_[size_++] = value;
+  }
+
+  /** Appends data to the end of the buffer. */
+  template <typename U> void append(const U* begin, const U* end);
+
+  template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
+    return ptr_[index];
+  }
+  template <typename Idx>
+  FMT_CONSTEXPR auto operator[](Idx index) const -> const T& {
+    return ptr_[index];
+  }
+};
+
+struct buffer_traits {
+  explicit buffer_traits(size_t) {}
+  auto count() const -> size_t { return 0; }
+  auto limit(size_t size) -> size_t { return size; }
+};
+
+class fixed_buffer_traits {
+ private:
+  size_t count_ = 0;
+  size_t limit_;
+
+ public:
+  explicit fixed_buffer_traits(size_t limit) : limit_(limit) {}
+  auto count() const -> size_t { return count_; }
+  auto limit(size_t size) -> size_t {
+    size_t n = limit_ > count_ ? limit_ - count_ : 0;
+    count_ += size;
+    return size < n ? size : n;
+  }
+};
+
+// A buffer that writes to an output iterator when flushed.
+template <typename OutputIt, typename T, typename Traits = buffer_traits>
+class iterator_buffer final : public Traits, public buffer<T> {
+ private:
+  OutputIt out_;
+  enum { buffer_size = 256 };
+  T data_[buffer_size];
+
+ protected:
+  FMT_CONSTEXPR20 void grow(size_t) override {
+    if (this->size() == buffer_size) flush();
+  }
+
+  void flush() {
+    auto size = this->size();
+    this->clear();
+    out_ = copy_str<T>(data_, data_ + this->limit(size), out_);
+  }
+
+ public:
+  explicit iterator_buffer(OutputIt out, size_t n = buffer_size)
+      : Traits(n), buffer<T>(data_, 0, buffer_size), out_(out) {}
+  iterator_buffer(iterator_buffer&& other)
+      : Traits(other), buffer<T>(data_, 0, buffer_size), out_(other.out_) {}
+  ~iterator_buffer() { flush(); }
+
+  auto out() -> OutputIt {
+    flush();
+    return out_;
+  }
+  auto count() const -> size_t { return Traits::count() + this->size(); }
+};
+
+template <typename T>
+class iterator_buffer<T*, T, fixed_buffer_traits> final
+    : public fixed_buffer_traits,
+      public buffer<T> {
+ private:
+  T* out_;
+  enum { buffer_size = 256 };
+  T data_[buffer_size];
+
+ protected:
+  FMT_CONSTEXPR20 void grow(size_t) override {
+    if (this->size() == this->capacity()) flush();
+  }
+
+  void flush() {
+    size_t n = this->limit(this->size());
+    if (this->data() == out_) {
+      out_ += n;
+      this->set(data_, buffer_size);
+    }
+    this->clear();
+  }
+
+ public:
+  explicit iterator_buffer(T* out, size_t n = buffer_size)
+      : fixed_buffer_traits(n), buffer<T>(out, 0, n), out_(out) {}
+  iterator_buffer(iterator_buffer&& other)
+      : fixed_buffer_traits(other),
+        buffer<T>(std::move(other)),
+        out_(other.out_) {
+    if (this->data() != out_) {
+      this->set(data_, buffer_size);
+      this->clear();
+    }
+  }
+  ~iterator_buffer() { flush(); }
+
+  auto out() -> T* {
+    flush();
+    return out_;
+  }
+  auto count() const -> size_t {
+    return fixed_buffer_traits::count() + this->size();
+  }
+};
+
+template <typename T> class iterator_buffer<T*, T> final : public buffer<T> {
+ protected:
+  FMT_CONSTEXPR20 void grow(size_t) override {}
+
+ public:
+  explicit iterator_buffer(T* out, size_t = 0) : buffer<T>(out, 0, ~size_t()) {}
+
+  auto out() -> T* { return &*this->end(); }
+};
+
+// A buffer that writes to a container with the contiguous storage.
+template <typename Container>
+class iterator_buffer<std::back_insert_iterator<Container>,
+                      enable_if_t<is_contiguous<Container>::value,
+                                  typename Container::value_type>>
+    final : public buffer<typename Container::value_type> {
+ private:
+  Container& container_;
+
+ protected:
+  FMT_CONSTEXPR20 void grow(size_t capacity) override {
+    container_.resize(capacity);
+    this->set(&container_[0], capacity);
+  }
+
+ public:
+  explicit iterator_buffer(Container& c)
+      : buffer<typename Container::value_type>(c.size()), container_(c) {}
+  explicit iterator_buffer(std::back_insert_iterator<Container> out, size_t = 0)
+      : iterator_buffer(get_container(out)) {}
+
+  auto out() -> std::back_insert_iterator<Container> {
+    return std::back_inserter(container_);
+  }
+};
+
+// A buffer that counts the number of code units written discarding the output.
+template <typename T = char> class counting_buffer final : public buffer<T> {
+ private:
+  enum { buffer_size = 256 };
+  T data_[buffer_size];
+  size_t count_ = 0;
+
+ protected:
+  FMT_CONSTEXPR20 void grow(size_t) override {
+    if (this->size() != buffer_size) return;
+    count_ += this->size();
+    this->clear();
+  }
+
+ public:
+  counting_buffer() : buffer<T>(data_, 0, buffer_size) {}
+
+  auto count() -> size_t { return count_ + this->size(); }
+};
+}  // namespace detail
+
+template <typename Char>
+FMT_CONSTEXPR void basic_format_parse_context<Char>::do_check_arg_id(int id) {
+  // Argument id is only checked at compile-time during parsing because
+  // formatting has its own validation.
+  if (detail::is_constant_evaluated() &&
+      (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) {
+    using context = detail::compile_parse_context<Char>;
+    if (id >= static_cast<context*>(this)->num_args())
+      detail::throw_format_error("argument not found");
+  }
+}
+
+template <typename Char>
+FMT_CONSTEXPR void basic_format_parse_context<Char>::check_dynamic_spec(
+    int arg_id) {
+  if (detail::is_constant_evaluated() &&
+      (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200)) {
+    using context = detail::compile_parse_context<Char>;
+    static_cast<context*>(this)->check_dynamic_spec(arg_id);
+  }
+}
+
+FMT_EXPORT template <typename Context> class basic_format_arg;
+FMT_EXPORT template <typename Context> class basic_format_args;
+FMT_EXPORT template <typename Context> class dynamic_format_arg_store;
+
+// A formatter for objects of type T.
+FMT_EXPORT
+template <typename T, typename Char = char, typename Enable = void>
+struct formatter {
+  // A deleted default constructor indicates a disabled formatter.
+  formatter() = delete;
+};
+
+// Specifies if T has an enabled formatter specialization. A type can be
+// formattable even if it doesn't have a formatter e.g. via a conversion.
+template <typename T, typename Context>
+using has_formatter =
+    std::is_constructible<typename Context::template formatter_type<T>>;
+
+// An output iterator that appends to a buffer.
+// It is used to reduce symbol sizes for the common case.
+class appender : public std::back_insert_iterator<detail::buffer<char>> {
+  using base = std::back_insert_iterator<detail::buffer<char>>;
+
+ public:
+  using std::back_insert_iterator<detail::buffer<char>>::back_insert_iterator;
+  appender(base it) noexcept : base(it) {}
+  FMT_UNCHECKED_ITERATOR(appender);
+
+  auto operator++() noexcept -> appender& { return *this; }
+  auto operator++(int) noexcept -> appender { return *this; }
+};
+
+namespace detail {
+
+template <typename Context, typename T>
+constexpr auto has_const_formatter_impl(T*)
+    -> decltype(typename Context::template formatter_type<T>().format(
+                    std::declval<const T&>(), std::declval<Context&>()),
+                true) {
+  return true;
+}
+template <typename Context>
+constexpr auto has_const_formatter_impl(...) -> bool {
+  return false;
+}
+template <typename T, typename Context>
+constexpr auto has_const_formatter() -> bool {
+  return has_const_formatter_impl<Context>(static_cast<T*>(nullptr));
+}
+
+template <typename T>
+using buffer_appender = conditional_t<std::is_same<T, char>::value, appender,
+                                      std::back_insert_iterator<buffer<T>>>;
+
+// Maps an output iterator to a buffer.
+template <typename T, typename OutputIt>
+auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> {
+  return iterator_buffer<OutputIt, T>(out);
+}
+template <typename T, typename Buf,
+          FMT_ENABLE_IF(std::is_base_of<buffer<char>, Buf>::value)>
+auto get_buffer(std::back_insert_iterator<Buf> out) -> buffer<char>& {
+  return get_container(out);
+}
+
+template <typename Buf, typename OutputIt>
+FMT_INLINE auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) {
+  return buf.out();
+}
+template <typename T, typename OutputIt>
+auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt {
+  return out;
+}
+
+struct view {};
+
+template <typename Char, typename T> struct named_arg : view {
+  const Char* name;
+  const T& value;
+  named_arg(const Char* n, const T& v) : name(n), value(v) {}
+};
+
+template <typename Char> struct named_arg_info {
+  const Char* name;
+  int id;
+};
+
+template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
+struct arg_data {
+  // args_[0].named_args points to named_args_ to avoid bloating format_args.
+  // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
+  T args_[1 + (NUM_ARGS != 0 ? NUM_ARGS : +1)];
+  named_arg_info<Char> named_args_[NUM_NAMED_ARGS];
+
+  template <typename... U>
+  arg_data(const U&... init) : args_{T(named_args_, NUM_NAMED_ARGS), init...} {}
+  arg_data(const arg_data& other) = delete;
+  auto args() const -> const T* { return args_ + 1; }
+  auto named_args() -> named_arg_info<Char>* { return named_args_; }
+};
+
+template <typename T, typename Char, size_t NUM_ARGS>
+struct arg_data<T, Char, NUM_ARGS, 0> {
+  // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
+  T args_[NUM_ARGS != 0 ? NUM_ARGS : +1];
+
+  template <typename... U>
+  FMT_CONSTEXPR FMT_INLINE arg_data(const U&... init) : args_{init...} {}
+  FMT_CONSTEXPR FMT_INLINE auto args() const -> const T* { return args_; }
+  FMT_CONSTEXPR FMT_INLINE auto named_args() -> std::nullptr_t {
+    return nullptr;
+  }
+};
+
+template <typename Char>
+inline void init_named_args(named_arg_info<Char>*, int, int) {}
+
+template <typename T> struct is_named_arg : std::false_type {};
+template <typename T> struct is_statically_named_arg : std::false_type {};
+
+template <typename T, typename Char>
+struct is_named_arg<named_arg<Char, T>> : std::true_type {};
+
+template <typename Char, typename T, typename... Tail,
+          FMT_ENABLE_IF(!is_named_arg<T>::value)>
+void init_named_args(named_arg_info<Char>* named_args, int arg_count,
+                     int named_arg_count, const T&, const Tail&... args) {
+  init_named_args(named_args, arg_count + 1, named_arg_count, args...);
+}
+
+template <typename Char, typename T, typename... Tail,
+          FMT_ENABLE_IF(is_named_arg<T>::value)>
+void init_named_args(named_arg_info<Char>* named_args, int arg_count,
+                     int named_arg_count, const T& arg, const Tail&... args) {
+  named_args[named_arg_count++] = {arg.name, arg_count};
+  init_named_args(named_args, arg_count + 1, named_arg_count, args...);
+}
+
+template <typename... Args>
+FMT_CONSTEXPR FMT_INLINE void init_named_args(std::nullptr_t, int, int,
+                                              const Args&...) {}
+
+template <bool B = false> constexpr auto count() -> size_t { return B ? 1 : 0; }
+template <bool B1, bool B2, bool... Tail> constexpr auto count() -> size_t {
+  return (B1 ? 1 : 0) + count<B2, Tail...>();
+}
+
+template <typename... Args> constexpr auto count_named_args() -> size_t {
+  return count<is_named_arg<Args>::value...>();
+}
+
+template <typename... Args>
+constexpr auto count_statically_named_args() -> size_t {
+  return count<is_statically_named_arg<Args>::value...>();
+}
+
+struct unformattable {};
+struct unformattable_char : unformattable {};
+struct unformattable_pointer : unformattable {};
+
+template <typename Char> struct string_value {
+  const Char* data;
+  size_t size;
+};
+
+template <typename Char> struct named_arg_value {
+  const named_arg_info<Char>* data;
+  size_t size;
+};
+
+template <typename Context> struct custom_value {
+  using parse_context = typename Context::parse_context_type;
+  void* value;
+  void (*format)(void* arg, parse_context& parse_ctx, Context& ctx);
+};
+
+// A formatting argument value.
+template <typename Context> class value {
+ public:
+  using char_type = typename Context::char_type;
+
+  union {
+    monostate no_value;
+    int int_value;
+    unsigned uint_value;
+    long long long_long_value;
+    unsigned long long ulong_long_value;
+    int128_opt int128_value;
+    uint128_opt uint128_value;
+    bool bool_value;
+    char_type char_value;
+    float float_value;
+    double double_value;
+    long double long_double_value;
+    const void* pointer;
+    string_value<char_type> string;
+    custom_value<Context> custom;
+    named_arg_value<char_type> named_args;
+  };
+
+  constexpr FMT_INLINE value() : no_value() {}
+  constexpr FMT_INLINE value(int val) : int_value(val) {}
+  constexpr FMT_INLINE value(unsigned val) : uint_value(val) {}
+  constexpr FMT_INLINE value(long long val) : long_long_value(val) {}
+  constexpr FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {}
+  FMT_INLINE value(int128_opt val) : int128_value(val) {}
+  FMT_INLINE value(uint128_opt val) : uint128_value(val) {}
+  constexpr FMT_INLINE value(float val) : float_value(val) {}
+  constexpr FMT_INLINE value(double val) : double_value(val) {}
+  FMT_INLINE value(long double val) : long_double_value(val) {}
+  constexpr FMT_INLINE value(bool val) : bool_value(val) {}
+  constexpr FMT_INLINE value(char_type val) : char_value(val) {}
+  FMT_CONSTEXPR FMT_INLINE value(const char_type* val) {
+    string.data = val;
+    if (is_constant_evaluated()) string.size = {};
+  }
+  FMT_CONSTEXPR FMT_INLINE value(basic_string_view<char_type> val) {
+    string.data = val.data();
+    string.size = val.size();
+  }
+  FMT_INLINE value(const void* val) : pointer(val) {}
+  FMT_INLINE value(const named_arg_info<char_type>* args, size_t size)
+      : named_args{args, size} {}
+
+  template <typename T> FMT_CONSTEXPR20 FMT_INLINE value(T& val) {
+    using value_type = remove_const_t<T>;
+    custom.value = const_cast<value_type*>(std::addressof(val));
+    // Get the formatter type through the context to allow different contexts
+    // have different extension points, e.g. `formatter<T>` for `format` and
+    // `printf_formatter<T>` for `printf`.
+    custom.format = format_custom_arg<
+        value_type, typename Context::template formatter_type<value_type>>;
+  }
+  value(unformattable);
+  value(unformattable_char);
+  value(unformattable_pointer);
+
+ private:
+  // Formats an argument of a custom type, such as a user-defined class.
+  template <typename T, typename Formatter>
+  static void format_custom_arg(void* arg,
+                                typename Context::parse_context_type& parse_ctx,
+                                Context& ctx) {
+    auto f = Formatter();
+    parse_ctx.advance_to(f.parse(parse_ctx));
+    using qualified_type =
+        conditional_t<has_const_formatter<T, Context>(), const T, T>;
+    // Calling format through a mutable reference is deprecated.
+    ctx.advance_to(f.format(*static_cast<qualified_type*>(arg), ctx));
+  }
+};
+
+// To minimize the number of types we need to deal with, long is translated
+// either to int or to long long depending on its size.
+enum { long_short = sizeof(long) == sizeof(int) };
+using long_type = conditional_t<long_short, int, long long>;
+using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;
+
+template <typename T> struct format_as_result {
+  template <typename U,
+            FMT_ENABLE_IF(std::is_enum<U>::value || std::is_class<U>::value)>
+  static auto map(U*) -> remove_cvref_t<decltype(format_as(std::declval<U>()))>;
+  static auto map(...) -> void;
+
+  using type = decltype(map(static_cast<T*>(nullptr)));
+};
+template <typename T> using format_as_t = typename format_as_result<T>::type;
+
+template <typename T>
+struct has_format_as
+    : bool_constant<!std::is_same<format_as_t<T>, void>::value> {};
+
+// Maps formatting arguments to core types.
+// arg_mapper reports errors by returning unformattable instead of using
+// static_assert because it's used in the is_formattable trait.
+template <typename Context> struct arg_mapper {
+  using char_type = typename Context::char_type;
+
+  FMT_CONSTEXPR FMT_INLINE auto map(signed char val) -> int { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(unsigned char val) -> unsigned {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(short val) -> int { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(unsigned short val) -> unsigned {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(int val) -> int { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(unsigned val) -> unsigned { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(long val) -> long_type { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(unsigned long val) -> ulong_type {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(long long val) -> long long { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(unsigned long long val)
+      -> unsigned long long {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(int128_opt val) -> int128_opt {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(uint128_opt val) -> uint128_opt {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(bool val) -> bool { return val; }
+
+  template <typename T, FMT_ENABLE_IF(std::is_same<T, char>::value ||
+                                      std::is_same<T, char_type>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(T val) -> char_type {
+    return val;
+  }
+  template <typename T, enable_if_t<(std::is_same<T, wchar_t>::value ||
+#ifdef __cpp_char8_t
+                                     std::is_same<T, char8_t>::value ||
+#endif
+                                     std::is_same<T, char16_t>::value ||
+                                     std::is_same<T, char32_t>::value) &&
+                                        !std::is_same<T, char_type>::value,
+                                    int> = 0>
+  FMT_CONSTEXPR FMT_INLINE auto map(T) -> unformattable_char {
+    return {};
+  }
+
+  FMT_CONSTEXPR FMT_INLINE auto map(float val) -> float { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(double val) -> double { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(long double val) -> long double {
+    return val;
+  }
+
+  FMT_CONSTEXPR FMT_INLINE auto map(char_type* val) -> const char_type* {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(const char_type* val) -> const char_type* {
+    return val;
+  }
+  template <typename T,
+            FMT_ENABLE_IF(is_string<T>::value && !std::is_pointer<T>::value &&
+                          std::is_same<char_type, char_t<T>>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
+      -> basic_string_view<char_type> {
+    return to_string_view(val);
+  }
+  template <typename T,
+            FMT_ENABLE_IF(is_string<T>::value && !std::is_pointer<T>::value &&
+                          !std::is_same<char_type, char_t<T>>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(const T&) -> unformattable_char {
+    return {};
+  }
+
+  FMT_CONSTEXPR FMT_INLINE auto map(void* val) -> const void* { return val; }
+  FMT_CONSTEXPR FMT_INLINE auto map(const void* val) -> const void* {
+    return val;
+  }
+  FMT_CONSTEXPR FMT_INLINE auto map(std::nullptr_t val) -> const void* {
+    return val;
+  }
+
+  // Use SFINAE instead of a const T* parameter to avoid a conflict with the
+  // array overload.
+  template <
+      typename T,
+      FMT_ENABLE_IF(
+          std::is_pointer<T>::value || std::is_member_pointer<T>::value ||
+          std::is_function<typename std::remove_pointer<T>::type>::value ||
+          (std::is_array<T>::value &&
+           !std::is_convertible<T, const char_type*>::value))>
+  FMT_CONSTEXPR auto map(const T&) -> unformattable_pointer {
+    return {};
+  }
+
+  template <typename T, std::size_t N,
+            FMT_ENABLE_IF(!std::is_same<T, wchar_t>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(const T (&values)[N]) -> const T (&)[N] {
+    return values;
+  }
+
+  // Only map owning types because mapping views can be unsafe.
+  template <typename T, typename U = format_as_t<T>,
+            FMT_ENABLE_IF(std::is_arithmetic<U>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(const T& val)
+      -> decltype(FMT_DECLTYPE_THIS map(U())) {
+    return map(format_as(val));
+  }
+
+  template <typename T, typename U = remove_const_t<T>>
+  struct formattable : bool_constant<has_const_formatter<U, Context>() ||
+                                     (has_formatter<U, Context>::value &&
+                                      !std::is_const<T>::value)> {};
+
+  template <typename T, FMT_ENABLE_IF(formattable<T>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto do_map(T& val) -> T& {
+    return val;
+  }
+  template <typename T, FMT_ENABLE_IF(!formattable<T>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto do_map(T&) -> unformattable {
+    return {};
+  }
+
+  template <typename T, typename U = remove_const_t<T>,
+            FMT_ENABLE_IF((std::is_class<U>::value || std::is_enum<U>::value ||
+                           std::is_union<U>::value) &&
+                          !is_string<U>::value && !is_char<U>::value &&
+                          !is_named_arg<U>::value &&
+                          !std::is_arithmetic<format_as_t<U>>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(T& val)
+      -> decltype(FMT_DECLTYPE_THIS do_map(val)) {
+    return do_map(val);
+  }
+
+  template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
+  FMT_CONSTEXPR FMT_INLINE auto map(const T& named_arg)
+      -> decltype(FMT_DECLTYPE_THIS map(named_arg.value)) {
+    return map(named_arg.value);
+  }
+
+  auto map(...) -> unformattable { return {}; }
+};
+
+// A type constant after applying arg_mapper<Context>.
+template <typename T, typename Context>
+using mapped_type_constant =
+    type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())),
+                  typename Context::char_type>;
+
+enum { packed_arg_bits = 4 };
+// Maximum number of arguments with packed types.
+enum { max_packed_args = 62 / packed_arg_bits };
+enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
+enum : unsigned long long { has_named_args_bit = 1ULL << 62 };
+
+template <typename Char, typename InputIt>
+auto copy_str(InputIt begin, InputIt end, appender out) -> appender {
+  get_container(out).append(begin, end);
+  return out;
+}
+template <typename Char, typename InputIt>
+auto copy_str(InputIt begin, InputIt end,
+              std::back_insert_iterator<std::string> out)
+    -> std::back_insert_iterator<std::string> {
+  get_container(out).append(begin, end);
+  return out;
+}
+
+template <typename Char, typename R, typename OutputIt>
+FMT_CONSTEXPR auto copy_str(R&& rng, OutputIt out) -> OutputIt {
+  return detail::copy_str<Char>(rng.begin(), rng.end(), out);
+}
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
+// A workaround for gcc 4.8 to make void_t work in a SFINAE context.
+template <typename...> struct void_t_impl {
+  using type = void;
+};
+template <typename... T> using void_t = typename void_t_impl<T...>::type;
+#else
+template <typename...> using void_t = void;
+#endif
+
+template <typename It, typename T, typename Enable = void>
+struct is_output_iterator : std::false_type {};
+
+template <typename It, typename T>
+struct is_output_iterator<
+    It, T,
+    void_t<typename std::iterator_traits<It>::iterator_category,
+           decltype(*std::declval<It>() = std::declval<T>())>>
+    : std::true_type {};
+
+template <typename It> struct is_back_insert_iterator : std::false_type {};
+template <typename Container>
+struct is_back_insert_iterator<std::back_insert_iterator<Container>>
+    : std::true_type {};
+
+// A type-erased reference to an std::locale to avoid a heavy <locale> include.
+class locale_ref {
+ private:
+  const void* locale_;  // A type-erased pointer to std::locale.
+
+ public:
+  constexpr FMT_INLINE locale_ref() : locale_(nullptr) {}
+  template <typename Locale> explicit locale_ref(const Locale& loc);
+
+  explicit operator bool() const noexcept { return locale_ != nullptr; }
+
+  template <typename Locale> auto get() const -> Locale;
+};
+
+template <typename> constexpr auto encode_types() -> unsigned long long {
+  return 0;
+}
+
+template <typename Context, typename Arg, typename... Args>
+constexpr auto encode_types() -> unsigned long long {
+  return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) |
+         (encode_types<Context, Args...>() << packed_arg_bits);
+}
+
+#if defined(__cpp_if_constexpr)
+// This type is intentionally undefined, only used for errors
+template <typename T, typename Char> struct type_is_unformattable_for;
+#endif
+
+template <bool PACKED, typename Context, typename T, FMT_ENABLE_IF(PACKED)>
+FMT_CONSTEXPR FMT_INLINE auto make_arg(T& val) -> value<Context> {
+  using arg_type = remove_cvref_t<decltype(arg_mapper<Context>().map(val))>;
+
+  constexpr bool formattable_char =
+      !std::is_same<arg_type, unformattable_char>::value;
+  static_assert(formattable_char, "Mixing character types is disallowed.");
+
+  // Formatting of arbitrary pointers is disallowed. If you want to format a
+  // pointer cast it to `void*` or `const void*`. In particular, this forbids
+  // formatting of `[const] volatile char*` printed as bool by iostreams.
+  constexpr bool formattable_pointer =
+      !std::is_same<arg_type, unformattable_pointer>::value;
+  static_assert(formattable_pointer,
+                "Formatting of non-void pointers is disallowed.");
+
+  constexpr bool formattable = !std::is_same<arg_type, unformattable>::value;
+#if defined(__cpp_if_constexpr)
+  if constexpr (!formattable) {
+    type_is_unformattable_for<T, typename Context::char_type> _;
+  }
+#endif
+  static_assert(
+      formattable,
+      "Cannot format an argument. To make type T formattable provide a "
+      "formatter<T> specialization: https://fmt.dev/latest/api.html#udt");
+  return {arg_mapper<Context>().map(val)};
+}
+
+template <typename Context, typename T>
+FMT_CONSTEXPR auto make_arg(T& val) -> basic_format_arg<Context> {
+  auto arg = basic_format_arg<Context>();
+  arg.type_ = mapped_type_constant<T, Context>::value;
+  arg.value_ = make_arg<true, Context>(val);
+  return arg;
+}
+
+template <bool PACKED, typename Context, typename T, FMT_ENABLE_IF(!PACKED)>
+FMT_CONSTEXPR inline auto make_arg(T& val) -> basic_format_arg<Context> {
+  return make_arg<Context>(val);
+}
+}  // namespace detail
+FMT_BEGIN_EXPORT
+
+// A formatting argument. Context is a template parameter for the compiled API
+// where output can be unbuffered.
+template <typename Context> class basic_format_arg {
+ private:
+  detail::value<Context> value_;
+  detail::type type_;
+
+  template <typename ContextType, typename T>
+  friend FMT_CONSTEXPR auto detail::make_arg(T& value)
+      -> basic_format_arg<ContextType>;
+
+  template <typename Visitor, typename Ctx>
+  friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
+                                             const basic_format_arg<Ctx>& arg)
+      -> decltype(vis(0));
+
+  friend class basic_format_args<Context>;
+  friend class dynamic_format_arg_store<Context>;
+
+  using char_type = typename Context::char_type;
+
+  template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
+  friend struct detail::arg_data;
+
+  basic_format_arg(const detail::named_arg_info<char_type>* args, size_t size)
+      : value_(args, size) {}
+
+ public:
+  class handle {
+   public:
+    explicit handle(detail::custom_value<Context> custom) : custom_(custom) {}
+
+    void format(typename Context::parse_context_type& parse_ctx,
+                Context& ctx) const {
+      custom_.format(custom_.value, parse_ctx, ctx);
+    }
+
+   private:
+    detail::custom_value<Context> custom_;
+  };
+
+  constexpr basic_format_arg() : type_(detail::type::none_type) {}
+
+  constexpr explicit operator bool() const noexcept {
+    return type_ != detail::type::none_type;
+  }
+
+  auto type() const -> detail::type { return type_; }
+
+  auto is_integral() const -> bool { return detail::is_integral_type(type_); }
+  auto is_arithmetic() const -> bool {
+    return detail::is_arithmetic_type(type_);
+  }
+
+  FMT_INLINE auto format_custom(const char_type* parse_begin,
+                                typename Context::parse_context_type& parse_ctx,
+                                Context& ctx) -> bool {
+    if (type_ != detail::type::custom_type) return false;
+    parse_ctx.advance_to(parse_begin);
+    value_.custom.format(value_.custom.value, parse_ctx, ctx);
+    return true;
+  }
+};
+
+/**
+  \rst
+  Visits an argument dispatching to the appropriate visit method based on
+  the argument type. For example, if the argument type is ``double`` then
+  ``vis(value)`` will be called with the value of type ``double``.
+  \endrst
+ */
+// DEPRECATED!
+template <typename Visitor, typename Context>
+FMT_CONSTEXPR FMT_INLINE auto visit_format_arg(
+    Visitor&& vis, const basic_format_arg<Context>& arg) -> decltype(vis(0)) {
+  switch (arg.type_) {
+  case detail::type::none_type:
+    break;
+  case detail::type::int_type:
+    return vis(arg.value_.int_value);
+  case detail::type::uint_type:
+    return vis(arg.value_.uint_value);
+  case detail::type::long_long_type:
+    return vis(arg.value_.long_long_value);
+  case detail::type::ulong_long_type:
+    return vis(arg.value_.ulong_long_value);
+  case detail::type::int128_type:
+    return vis(detail::convert_for_visit(arg.value_.int128_value));
+  case detail::type::uint128_type:
+    return vis(detail::convert_for_visit(arg.value_.uint128_value));
+  case detail::type::bool_type:
+    return vis(arg.value_.bool_value);
+  case detail::type::char_type:
+    return vis(arg.value_.char_value);
+  case detail::type::float_type:
+    return vis(arg.value_.float_value);
+  case detail::type::double_type:
+    return vis(arg.value_.double_value);
+  case detail::type::long_double_type:
+    return vis(arg.value_.long_double_value);
+  case detail::type::cstring_type:
+    return vis(arg.value_.string.data);
+  case detail::type::string_type:
+    using sv = basic_string_view<typename Context::char_type>;
+    return vis(sv(arg.value_.string.data, arg.value_.string.size));
+  case detail::type::pointer_type:
+    return vis(arg.value_.pointer);
+  case detail::type::custom_type:
+    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
+  }
+  return vis(monostate());
+}
+
+// Formatting context.
+template <typename OutputIt, typename Char> class basic_format_context {
+ private:
+  OutputIt out_;
+  basic_format_args<basic_format_context> args_;
+  detail::locale_ref loc_;
+
+ public:
+  using iterator = OutputIt;
+  using format_arg = basic_format_arg<basic_format_context>;
+  using format_args = basic_format_args<basic_format_context>;
+  using parse_context_type = basic_format_parse_context<Char>;
+  template <typename T> using formatter_type = formatter<T, Char>;
+
+  /** The character type for the output. */
+  using char_type = Char;
+
+  basic_format_context(basic_format_context&&) = default;
+  basic_format_context(const basic_format_context&) = delete;
+  void operator=(const basic_format_context&) = delete;
+  /**
+    Constructs a ``basic_format_context`` object. References to the arguments
+    are stored in the object so make sure they have appropriate lifetimes.
+   */
+  constexpr basic_format_context(OutputIt out, format_args ctx_args,
+                                 detail::locale_ref loc = {})
+      : out_(out), args_(ctx_args), loc_(loc) {}
+
+  constexpr auto arg(int id) const -> format_arg { return args_.get(id); }
+  FMT_CONSTEXPR auto arg(basic_string_view<Char> name) -> format_arg {
+    return args_.get(name);
+  }
+  FMT_CONSTEXPR auto arg_id(basic_string_view<Char> name) -> int {
+    return args_.get_id(name);
+  }
+  auto args() const -> const format_args& { return args_; }
+
+  // DEPRECATED!
+  FMT_CONSTEXPR auto error_handler() -> detail::error_handler { return {}; }
+  void on_error(const char* message) { error_handler().on_error(message); }
+
+  // Returns an iterator to the beginning of the output range.
+  FMT_CONSTEXPR auto out() -> iterator { return out_; }
+
+  // Advances the begin iterator to ``it``.
+  void advance_to(iterator it) {
+    if (!detail::is_back_insert_iterator<iterator>()) out_ = it;
+  }
+
+  FMT_CONSTEXPR auto locale() -> detail::locale_ref { return loc_; }
+};
+
+template <typename Char>
+using buffer_context =
+    basic_format_context<detail::buffer_appender<Char>, Char>;
+using format_context = buffer_context<char>;
+
+template <typename T, typename Char = char>
+using is_formattable = bool_constant<!std::is_base_of<
+    detail::unformattable, decltype(detail::arg_mapper<buffer_context<Char>>()
+                                        .map(std::declval<T&>()))>::value>;
+
+/**
+  \rst
+  An array of references to arguments. It can be implicitly converted into
+  `~fmt::basic_format_args` for passing into type-erased formatting functions
+  such as `~fmt::vformat`.
+  \endrst
+ */
+template <typename Context, typename... Args>
+class format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
+ private:
+  static const size_t num_args = sizeof...(Args);
+  static constexpr size_t num_named_args = detail::count_named_args<Args...>();
+  static const bool is_packed = num_args <= detail::max_packed_args;
+
+  using value_type = conditional_t<is_packed, detail::value<Context>,
+                                   basic_format_arg<Context>>;
+
+  detail::arg_data<value_type, typename Context::char_type, num_args,
+                   num_named_args>
+      data_;
+
+  friend class basic_format_args<Context>;
+
+  static constexpr unsigned long long desc =
+      (is_packed ? detail::encode_types<Context, Args...>()
+                 : detail::is_unpacked_bit | num_args) |
+      (num_named_args != 0
+           ? static_cast<unsigned long long>(detail::has_named_args_bit)
+           : 0);
+
+ public:
+  template <typename... T>
+  FMT_CONSTEXPR FMT_INLINE format_arg_store(T&... args)
+      :
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+        basic_format_args<Context>(*this),
+#endif
+        data_{detail::make_arg<is_packed, Context>(args)...} {
+    if (detail::const_check(num_named_args != 0))
+      detail::init_named_args(data_.named_args(), 0, 0, args...);
+  }
+};
+
+/**
+  \rst
+  Constructs a `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::format_args`. `Context`
+  can be omitted in which case it defaults to `~fmt::format_context`.
+  See `~fmt::arg` for lifetime considerations.
+  \endrst
+ */
+// Arguments are taken by lvalue references to avoid some lifetime issues.
+template <typename Context = format_context, typename... T>
+constexpr auto make_format_args(T&... args)
+    -> format_arg_store<Context, remove_cvref_t<T>...> {
+  return {args...};
+}
+
+/**
+  \rst
+  Returns a named argument to be used in a formatting function.
+  It should only be used in a call to a formatting function or
+  `dynamic_format_arg_store::push_back`.
+
+  **Example**::
+
+    fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
+  \endrst
+ */
+template <typename Char, typename T>
+inline auto arg(const Char* name, const T& arg) -> detail::named_arg<Char, T> {
+  static_assert(!detail::is_named_arg<T>(), "nested named arguments");
+  return {name, arg};
+}
+FMT_END_EXPORT
+
+/**
+  \rst
+  A view of a collection of formatting arguments. To avoid lifetime issues it
+  should only be used as a parameter type in type-erased functions such as
+  ``vformat``::
+
+    void vlog(string_view format_str, format_args args);  // OK
+    format_args args = make_format_args();  // Error: dangling reference
+  \endrst
+ */
+template <typename Context> class basic_format_args {
+ public:
+  using size_type = int;
+  using format_arg = basic_format_arg<Context>;
+
+ private:
+  // A descriptor that contains information about formatting arguments.
+  // If the number of arguments is less or equal to max_packed_args then
+  // argument types are passed in the descriptor. This reduces binary code size
+  // per formatting function call.
+  unsigned long long desc_;
+  union {
+    // If is_packed() returns true then argument values are stored in values_;
+    // otherwise they are stored in args_. This is done to improve cache
+    // locality and reduce compiled code size since storing larger objects
+    // may require more code (at least on x86-64) even if the same amount of
+    // data is actually copied to stack. It saves ~10% on the bloat test.
+    const detail::value<Context>* values_;
+    const format_arg* args_;
+  };
+
+  constexpr auto is_packed() const -> bool {
+    return (desc_ & detail::is_unpacked_bit) == 0;
+  }
+  auto has_named_args() const -> bool {
+    return (desc_ & detail::has_named_args_bit) != 0;
+  }
+
+  FMT_CONSTEXPR auto type(int index) const -> detail::type {
+    int shift = index * detail::packed_arg_bits;
+    unsigned int mask = (1 << detail::packed_arg_bits) - 1;
+    return static_cast<detail::type>((desc_ >> shift) & mask);
+  }
+
+  constexpr FMT_INLINE basic_format_args(unsigned long long desc,
+                                         const detail::value<Context>* values)
+      : desc_(desc), values_(values) {}
+  constexpr basic_format_args(unsigned long long desc, const format_arg* args)
+      : desc_(desc), args_(args) {}
+
+ public:
+  constexpr basic_format_args() : desc_(0), args_(nullptr) {}
+
+  /**
+   \rst
+   Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
+   \endrst
+   */
+  template <typename... Args>
+  constexpr FMT_INLINE basic_format_args(
+      const format_arg_store<Context, Args...>& store)
+      : basic_format_args(format_arg_store<Context, Args...>::desc,
+                          store.data_.args()) {}
+
+  /**
+   \rst
+   Constructs a `basic_format_args` object from
+   `~fmt::dynamic_format_arg_store`.
+   \endrst
+   */
+  constexpr FMT_INLINE basic_format_args(
+      const dynamic_format_arg_store<Context>& store)
+      : basic_format_args(store.get_types(), store.data()) {}
+
+  /**
+   \rst
+   Constructs a `basic_format_args` object from a dynamic set of arguments.
+   \endrst
+   */
+  constexpr basic_format_args(const format_arg* args, int count)
+      : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count),
+                          args) {}
+
+  /** Returns the argument with the specified id. */
+  FMT_CONSTEXPR auto get(int id) const -> format_arg {
+    format_arg arg;
+    if (!is_packed()) {
+      if (id < max_size()) arg = args_[id];
+      return arg;
+    }
+    if (id >= detail::max_packed_args) return arg;
+    arg.type_ = type(id);
+    if (arg.type_ == detail::type::none_type) return arg;
+    arg.value_ = values_[id];
+    return arg;
+  }
+
+  template <typename Char>
+  auto get(basic_string_view<Char> name) const -> format_arg {
+    int id = get_id(name);
+    return id >= 0 ? get(id) : format_arg();
+  }
+
+  template <typename Char>
+  auto get_id(basic_string_view<Char> name) const -> int {
+    if (!has_named_args()) return -1;
+    const auto& named_args =
+        (is_packed() ? values_[-1] : args_[-1].value_).named_args;
+    for (size_t i = 0; i < named_args.size; ++i) {
+      if (named_args.data[i].name == name) return named_args.data[i].id;
+    }
+    return -1;
+  }
+
+  auto max_size() const -> int {
+    unsigned long long max_packed = detail::max_packed_args;
+    return static_cast<int>(is_packed() ? max_packed
+                                        : desc_ & ~detail::is_unpacked_bit);
+  }
+};
+
+/** An alias to ``basic_format_args<format_context>``. */
+// A separate type would result in shorter symbols but break ABI compatibility
+// between clang and gcc on ARM (#1919).
+FMT_EXPORT using format_args = basic_format_args<format_context>;
+
+// We cannot use enum classes as bit fields because of a gcc bug, so we put them
+// in namespaces instead (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414).
+// Additionally, if an underlying type is specified, older gcc incorrectly warns
+// that the type is too small. Both bugs are fixed in gcc 9.3.
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 903
+#  define FMT_ENUM_UNDERLYING_TYPE(type)
+#else
+#  define FMT_ENUM_UNDERLYING_TYPE(type) : type
+#endif
+namespace align {
+enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, left, right, center,
+                                                  numeric};
+}
+using align_t = align::type;
+namespace sign {
+enum type FMT_ENUM_UNDERLYING_TYPE(unsigned char){none, minus, plus, space};
+}
+using sign_t = sign::type;
+
+namespace detail {
+
+// Workaround an array initialization issue in gcc 4.8.
+template <typename Char> struct fill_t {
+ private:
+  enum { max_size = 4 };
+  Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)};
+  unsigned char size_ = 1;
+
+ public:
+  FMT_CONSTEXPR void operator=(basic_string_view<Char> s) {
+    auto size = s.size();
+    FMT_ASSERT(size <= max_size, "invalid fill");
+    for (size_t i = 0; i < size; ++i) data_[i] = s[i];
+    size_ = static_cast<unsigned char>(size);
+  }
+
+  constexpr auto size() const -> size_t { return size_; }
+  constexpr auto data() const -> const Char* { return data_; }
+
+  FMT_CONSTEXPR auto operator[](size_t index) -> Char& { return data_[index]; }
+  FMT_CONSTEXPR auto operator[](size_t index) const -> const Char& {
+    return data_[index];
+  }
+};
+}  // namespace detail
+
+enum class presentation_type : unsigned char {
+  none,
+  dec,             // 'd'
+  oct,             // 'o'
+  hex_lower,       // 'x'
+  hex_upper,       // 'X'
+  bin_lower,       // 'b'
+  bin_upper,       // 'B'
+  hexfloat_lower,  // 'a'
+  hexfloat_upper,  // 'A'
+  exp_lower,       // 'e'
+  exp_upper,       // 'E'
+  fixed_lower,     // 'f'
+  fixed_upper,     // 'F'
+  general_lower,   // 'g'
+  general_upper,   // 'G'
+  chr,             // 'c'
+  string,          // 's'
+  pointer,         // 'p'
+  debug            // '?'
+};
+
+// Format specifiers for built-in and string types.
+template <typename Char = char> struct format_specs {
+  int width;
+  int precision;
+  presentation_type type;
+  align_t align : 4;
+  sign_t sign : 3;
+  bool alt : 1;  // Alternate form ('#').
+  bool localized : 1;
+  detail::fill_t<Char> fill;
+
+  constexpr format_specs()
+      : width(0),
+        precision(-1),
+        type(presentation_type::none),
+        align(align::none),
+        sign(sign::none),
+        alt(false),
+        localized(false) {}
+};
+
+namespace detail {
+
+enum class arg_id_kind { none, index, name };
+
+// An argument reference.
+template <typename Char> struct arg_ref {
+  FMT_CONSTEXPR arg_ref() : kind(arg_id_kind::none), val() {}
+
+  FMT_CONSTEXPR explicit arg_ref(int index)
+      : kind(arg_id_kind::index), val(index) {}
+  FMT_CONSTEXPR explicit arg_ref(basic_string_view<Char> name)
+      : kind(arg_id_kind::name), val(name) {}
+
+  FMT_CONSTEXPR auto operator=(int idx) -> arg_ref& {
+    kind = arg_id_kind::index;
+    val.index = idx;
+    return *this;
+  }
+
+  arg_id_kind kind;
+  union value {
+    FMT_CONSTEXPR value(int idx = 0) : index(idx) {}
+    FMT_CONSTEXPR value(basic_string_view<Char> n) : name(n) {}
+
+    int index;
+    basic_string_view<Char> name;
+  } val;
+};
+
+// Format specifiers with width and precision resolved at formatting rather
+// than parsing time to allow reusing the same parsed specifiers with
+// different sets of arguments (precompilation of format strings).
+template <typename Char = char>
+struct dynamic_format_specs : format_specs<Char> {
+  arg_ref<Char> width_ref;
+  arg_ref<Char> precision_ref;
+};
+
+// Converts a character to ASCII. Returns '\0' on conversion failure.
+template <typename Char, FMT_ENABLE_IF(std::is_integral<Char>::value)>
+constexpr auto to_ascii(Char c) -> char {
+  return c <= 0xff ? static_cast<char>(c) : '\0';
+}
+template <typename Char, FMT_ENABLE_IF(std::is_enum<Char>::value)>
+constexpr auto to_ascii(Char c) -> char {
+  return c <= 0xff ? static_cast<char>(c) : '\0';
+}
+
+// Returns the number of code units in a code point or 1 on error.
+template <typename Char>
+FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int {
+  if (const_check(sizeof(Char) != 1)) return 1;
+  auto c = static_cast<unsigned char>(*begin);
+  return static_cast<int>((0x3a55000000000000ull >> (2 * (c >> 3))) & 0x3) + 1;
+}
+
+// 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*>(
+      std::memchr(first, value, to_unsigned(last - first)));
+  return out != nullptr;
+}
+
+// Parses the range [begin, end) as an unsigned integer. This function assumes
+// that the range is non-empty and the first character is a digit.
+template <typename Char>
+FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end,
+                                         int error_value) noexcept -> int {
+  FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
+  unsigned value = 0, prev = 0;
+  auto p = begin;
+  do {
+    prev = value;
+    value = value * 10 + unsigned(*p - '0');
+    ++p;
+  } while (p != end && '0' <= *p && *p <= '9');
+  auto num_digits = p - begin;
+  begin = p;
+  if (num_digits <= std::numeric_limits<int>::digits10)
+    return static_cast<int>(value);
+  // Check for overflow.
+  const unsigned max = to_unsigned((std::numeric_limits<int>::max)());
+  return num_digits == std::numeric_limits<int>::digits10 + 1 &&
+                 prev * 10ull + unsigned(p[-1] - '0') <= max
+             ? static_cast<int>(value)
+             : error_value;
+}
+
+FMT_CONSTEXPR inline auto parse_align(char c) -> align_t {
+  switch (c) {
+  case '<':
+    return align::left;
+  case '>':
+    return align::right;
+  case '^':
+    return align::center;
+  }
+  return align::none;
+}
+
+template <typename Char> constexpr auto is_name_start(Char c) -> bool {
+  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_';
+}
+
+template <typename Char, typename Handler>
+FMT_CONSTEXPR auto do_parse_arg_id(const Char* begin, const Char* end,
+                                   Handler&& handler) -> const Char* {
+  Char c = *begin;
+  if (c >= '0' && c <= '9') {
+    int index = 0;
+    constexpr int max = (std::numeric_limits<int>::max)();
+    if (c != '0')
+      index = parse_nonnegative_int(begin, end, max);
+    else
+      ++begin;
+    if (begin == end || (*begin != '}' && *begin != ':'))
+      throw_format_error("invalid format string");
+    else
+      handler.on_index(index);
+    return begin;
+  }
+  if (!is_name_start(c)) {
+    throw_format_error("invalid format string");
+    return begin;
+  }
+  auto it = begin;
+  do {
+    ++it;
+  } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9')));
+  handler.on_name({begin, to_unsigned(it - begin)});
+  return it;
+}
+
+template <typename Char, typename Handler>
+FMT_CONSTEXPR FMT_INLINE auto parse_arg_id(const Char* begin, const Char* end,
+                                           Handler&& handler) -> const Char* {
+  FMT_ASSERT(begin != end, "");
+  Char c = *begin;
+  if (c != '}' && c != ':') return do_parse_arg_id(begin, end, handler);
+  handler.on_auto();
+  return begin;
+}
+
+template <typename Char> struct dynamic_spec_id_handler {
+  basic_format_parse_context<Char>& ctx;
+  arg_ref<Char>& ref;
+
+  FMT_CONSTEXPR void on_auto() {
+    int id = ctx.next_arg_id();
+    ref = arg_ref<Char>(id);
+    ctx.check_dynamic_spec(id);
+  }
+  FMT_CONSTEXPR void on_index(int id) {
+    ref = arg_ref<Char>(id);
+    ctx.check_arg_id(id);
+    ctx.check_dynamic_spec(id);
+  }
+  FMT_CONSTEXPR void on_name(basic_string_view<Char> id) {
+    ref = arg_ref<Char>(id);
+    ctx.check_arg_id(id);
+  }
+};
+
+// Parses [integer | "{" [arg_id] "}"].
+template <typename Char>
+FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end,
+                                      int& value, arg_ref<Char>& ref,
+                                      basic_format_parse_context<Char>& ctx)
+    -> const Char* {
+  FMT_ASSERT(begin != end, "");
+  if ('0' <= *begin && *begin <= '9') {
+    int val = parse_nonnegative_int(begin, end, -1);
+    if (val != -1)
+      value = val;
+    else
+      throw_format_error("number is too big");
+  } else if (*begin == '{') {
+    ++begin;
+    auto handler = dynamic_spec_id_handler<Char>{ctx, ref};
+    if (begin != end) begin = parse_arg_id(begin, end, handler);
+    if (begin != end && *begin == '}') return ++begin;
+    throw_format_error("invalid format string");
+  }
+  return begin;
+}
+
+template <typename Char>
+FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end,
+                                   int& value, arg_ref<Char>& ref,
+                                   basic_format_parse_context<Char>& ctx)
+    -> const Char* {
+  ++begin;
+  if (begin == end || *begin == '}') {
+    throw_format_error("invalid precision");
+    return begin;
+  }
+  return parse_dynamic_spec(begin, end, value, ref, ctx);
+}
+
+enum class state { start, align, sign, hash, zero, width, precision, locale };
+
+// Parses standard format specifiers.
+template <typename Char>
+FMT_CONSTEXPR FMT_INLINE auto parse_format_specs(
+    const Char* begin, const Char* end, dynamic_format_specs<Char>& specs,
+    basic_format_parse_context<Char>& ctx, type arg_type) -> const Char* {
+  auto c = '\0';
+  if (end - begin > 1) {
+    auto next = to_ascii(begin[1]);
+    c = parse_align(next) == align::none ? to_ascii(*begin) : '\0';
+  } else {
+    if (begin == end) return begin;
+    c = to_ascii(*begin);
+  }
+
+  struct {
+    state current_state = state::start;
+    FMT_CONSTEXPR void operator()(state s, bool valid = true) {
+      if (current_state >= s || !valid)
+        throw_format_error("invalid format specifier");
+      current_state = s;
+    }
+  } enter_state;
+
+  using pres = presentation_type;
+  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
+  struct {
+    const Char*& begin;
+    dynamic_format_specs<Char>& specs;
+    type arg_type;
+
+    FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
+      if (!in(arg_type, set)) {
+        if (arg_type == type::none_type) return begin;
+        throw_format_error("invalid format specifier");
+      }
+      specs.type = pres_type;
+      return begin + 1;
+    }
+  } parse_presentation_type{begin, specs, arg_type};
+
+  for (;;) {
+    switch (c) {
+    case '<':
+    case '>':
+    case '^':
+      enter_state(state::align);
+      specs.align = parse_align(c);
+      ++begin;
+      break;
+    case '+':
+    case '-':
+    case ' ':
+      if (arg_type == type::none_type) return begin;
+      enter_state(state::sign, in(arg_type, sint_set | float_set));
+      switch (c) {
+      case '+':
+        specs.sign = sign::plus;
+        break;
+      case '-':
+        specs.sign = sign::minus;
+        break;
+      case ' ':
+        specs.sign = sign::space;
+        break;
+      }
+      ++begin;
+      break;
+    case '#':
+      if (arg_type == type::none_type) return begin;
+      enter_state(state::hash, is_arithmetic_type(arg_type));
+      specs.alt = true;
+      ++begin;
+      break;
+    case '0':
+      enter_state(state::zero);
+      if (!is_arithmetic_type(arg_type)) {
+        if (arg_type == type::none_type) return begin;
+        throw_format_error("format specifier requires numeric argument");
+      }
+      if (specs.align == align::none) {
+        // Ignore 0 if align is specified for compatibility with std::format.
+        specs.align = align::numeric;
+        specs.fill[0] = Char('0');
+      }
+      ++begin;
+      break;
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+    case '{':
+      enter_state(state::width);
+      begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx);
+      break;
+    case '.':
+      if (arg_type == type::none_type) return begin;
+      enter_state(state::precision,
+                  in(arg_type, float_set | string_set | cstring_set));
+      begin = parse_precision(begin, end, specs.precision, specs.precision_ref,
+                              ctx);
+      break;
+    case 'L':
+      if (arg_type == type::none_type) return begin;
+      enter_state(state::locale, is_arithmetic_type(arg_type));
+      specs.localized = true;
+      ++begin;
+      break;
+    case 'd':
+      return parse_presentation_type(pres::dec, integral_set);
+    case 'o':
+      return parse_presentation_type(pres::oct, integral_set);
+    case 'x':
+      return parse_presentation_type(pres::hex_lower, integral_set);
+    case 'X':
+      return parse_presentation_type(pres::hex_upper, integral_set);
+    case 'b':
+      return parse_presentation_type(pres::bin_lower, integral_set);
+    case 'B':
+      return parse_presentation_type(pres::bin_upper, integral_set);
+    case 'a':
+      return parse_presentation_type(pres::hexfloat_lower, float_set);
+    case 'A':
+      return parse_presentation_type(pres::hexfloat_upper, float_set);
+    case 'e':
+      return parse_presentation_type(pres::exp_lower, float_set);
+    case 'E':
+      return parse_presentation_type(pres::exp_upper, float_set);
+    case 'f':
+      return parse_presentation_type(pres::fixed_lower, float_set);
+    case 'F':
+      return parse_presentation_type(pres::fixed_upper, float_set);
+    case 'g':
+      return parse_presentation_type(pres::general_lower, float_set);
+    case 'G':
+      return parse_presentation_type(pres::general_upper, float_set);
+    case 'c':
+      if (arg_type == type::bool_type)
+        throw_format_error("invalid format specifier");
+      return parse_presentation_type(pres::chr, integral_set);
+    case 's':
+      return parse_presentation_type(pres::string,
+                                     bool_set | string_set | cstring_set);
+    case 'p':
+      return parse_presentation_type(pres::pointer, pointer_set | cstring_set);
+    case '?':
+      return parse_presentation_type(pres::debug,
+                                     char_set | string_set | cstring_set);
+    case '}':
+      return begin;
+    default: {
+      if (*begin == '}') return begin;
+      // Parse fill and alignment.
+      auto fill_end = begin + code_point_length(begin);
+      if (end - fill_end <= 0) {
+        throw_format_error("invalid format specifier");
+        return begin;
+      }
+      if (*begin == '{') {
+        throw_format_error("invalid fill character '{'");
+        return begin;
+      }
+      auto align = parse_align(to_ascii(*fill_end));
+      enter_state(state::align, align != align::none);
+      specs.fill = {begin, to_unsigned(fill_end - begin)};
+      specs.align = align;
+      begin = fill_end + 1;
+    }
+    }
+    if (begin == end) return begin;
+    c = to_ascii(*begin);
+  }
+}
+
+template <typename Char, typename Handler>
+FMT_CONSTEXPR auto parse_replacement_field(const Char* begin, const Char* end,
+                                           Handler&& handler) -> const Char* {
+  struct id_adapter {
+    Handler& handler;
+    int arg_id;
+
+    FMT_CONSTEXPR void on_auto() { arg_id = handler.on_arg_id(); }
+    FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); }
+    FMT_CONSTEXPR void on_name(basic_string_view<Char> id) {
+      arg_id = handler.on_arg_id(id);
+    }
+  };
+
+  ++begin;
+  if (begin == end) return handler.on_error("invalid format string"), end;
+  if (*begin == '}') {
+    handler.on_replacement_field(handler.on_arg_id(), begin);
+  } else if (*begin == '{') {
+    handler.on_text(begin, begin + 1);
+  } else {
+    auto adapter = id_adapter{handler, 0};
+    begin = parse_arg_id(begin, end, adapter);
+    Char c = begin != end ? *begin : Char();
+    if (c == '}') {
+      handler.on_replacement_field(adapter.arg_id, begin);
+    } else if (c == ':') {
+      begin = handler.on_format_specs(adapter.arg_id, begin + 1, end);
+      if (begin == end || *begin != '}')
+        return handler.on_error("unknown format specifier"), end;
+    } else {
+      return handler.on_error("missing '}' in format string"), end;
+    }
+  }
+  return begin + 1;
+}
+
+template <bool IS_CONSTEXPR, typename Char, typename Handler>
+FMT_CONSTEXPR FMT_INLINE void parse_format_string(
+    basic_string_view<Char> format_str, Handler&& handler) {
+  auto begin = format_str.data();
+  auto end = begin + format_str.size();
+  if (end - begin < 32) {
+    // Use a simple loop instead of memchr for small strings.
+    const Char* p = begin;
+    while (p != end) {
+      auto c = *p++;
+      if (c == '{') {
+        handler.on_text(begin, p - 1);
+        begin = p = parse_replacement_field(p - 1, end, handler);
+      } else if (c == '}') {
+        if (p == end || *p != '}')
+          return handler.on_error("unmatched '}' in format string");
+        handler.on_text(begin, p);
+        begin = ++p;
+      }
+    }
+    handler.on_text(begin, end);
+    return;
+  }
+  struct writer {
+    FMT_CONSTEXPR void operator()(const Char* from, const Char* to) {
+      if (from == to) return;
+      for (;;) {
+        const Char* p = nullptr;
+        if (!find<IS_CONSTEXPR>(from, to, Char('}'), p))
+          return handler_.on_text(from, to);
+        ++p;
+        if (p == to || *p != '}')
+          return handler_.on_error("unmatched '}' in format string");
+        handler_.on_text(from, p);
+        from = p + 1;
+      }
+    }
+    Handler& handler_;
+  } write = {handler};
+  while (begin != end) {
+    // Doing two passes with memchr (one for '{' and another for '}') is up to
+    // 2.5x faster than the naive one-pass implementation on big format strings.
+    const Char* p = begin;
+    if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, Char('{'), p))
+      return write(begin, end);
+    write(begin, p);
+    begin = parse_replacement_field(p, end, handler);
+  }
+}
+
+template <typename T, bool = is_named_arg<T>::value> struct strip_named_arg {
+  using type = T;
+};
+template <typename T> struct strip_named_arg<T, true> {
+  using type = remove_cvref_t<decltype(T::value)>;
+};
+
+template <typename T, typename ParseContext>
+FMT_CONSTEXPR auto parse_format_specs(ParseContext& ctx)
+    -> decltype(ctx.begin()) {
+  using char_type = typename ParseContext::char_type;
+  using context = buffer_context<char_type>;
+  using mapped_type = conditional_t<
+      mapped_type_constant<T, context>::value != type::custom_type,
+      decltype(arg_mapper<context>().map(std::declval<const T&>())),
+      typename strip_named_arg<T>::type>;
+#if defined(__cpp_if_constexpr)
+  if constexpr (std::is_default_constructible<
+                    formatter<mapped_type, char_type>>::value) {
+    return formatter<mapped_type, char_type>().parse(ctx);
+  } else {
+    type_is_unformattable_for<T, char_type> _;
+    return ctx.begin();
+  }
+#else
+  return formatter<mapped_type, char_type>().parse(ctx);
+#endif
+}
+
+// Checks char specs and returns true iff the presentation type is char-like.
+template <typename Char>
+FMT_CONSTEXPR auto check_char_specs(const format_specs<Char>& specs) -> bool {
+  if (specs.type != presentation_type::none &&
+      specs.type != presentation_type::chr &&
+      specs.type != presentation_type::debug) {
+    return false;
+  }
+  if (specs.align == align::numeric || specs.sign != sign::none || specs.alt)
+    throw_format_error("invalid format specifier for char");
+  return true;
+}
+
+#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_statically_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> class format_string_checker {
+ private:
+  using parse_context_type = compile_parse_context<Char>;
+  static constexpr int num_args = sizeof...(Args);
+
+  // Format specifier parsing function.
+  // In the future basic_format_parse_context will replace compile_parse_context
+  // here and will use is_constant_evaluated and downcasting to access the data
+  // needed for compile-time checks: https://godbolt.org/z/GvWzcTjh1.
+  using parse_func = const Char* (*)(parse_context_type&);
+
+  type types_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
+  parse_context_type context_;
+  parse_func parse_funcs_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
+
+ public:
+  explicit FMT_CONSTEXPR format_string_checker(basic_string_view<Char> fmt)
+      : types_{mapped_type_constant<Args, buffer_context<Char>>::value...},
+        context_(fmt, num_args, types_),
+        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
+
+  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
+
+  FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); }
+  FMT_CONSTEXPR auto on_arg_id(int id) -> int {
+    return context_.check_arg_id(id), id;
+  }
+  FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+    auto index = get_arg_index_by_name<Args...>(id);
+    if (index < 0) on_error("named argument is not found");
+    return index;
+#else
+    (void)id;
+    on_error("compile-time checks for named arguments require C++20 support");
+    return 0;
+#endif
+  }
+
+  FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) {
+    on_format_specs(id, begin, begin);  // Call parse() on empty specs.
+  }
+
+  FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char*)
+      -> const Char* {
+    context_.advance_to(begin);
+    // id >= 0 check is a workaround for gcc 10 bug (#2065).
+    return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin;
+  }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    throw_format_error(message);
+  }
+};
+
+// Reports a compile-time error if S is not a valid format string.
+template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)>
+FMT_INLINE void check_format_string(const S&) {
+#ifdef FMT_ENFORCE_COMPILE_STRING
+  static_assert(is_compile_string<S>::value,
+                "FMT_ENFORCE_COMPILE_STRING requires all format strings to use "
+                "FMT_STRING.");
+#endif
+}
+template <typename... Args, typename S,
+          FMT_ENABLE_IF(is_compile_string<S>::value)>
+void check_format_string(S format_str) {
+  using char_t = typename S::char_type;
+  FMT_CONSTEXPR auto s = basic_string_view<char_t>(format_str);
+  using checker = format_string_checker<char_t, remove_cvref_t<Args>...>;
+  FMT_CONSTEXPR bool error = (parse_format_string<true>(s, checker(s)), true);
+  ignore_unused(error);
+}
+
+template <typename Char = char> struct vformat_args {
+  using type = basic_format_args<
+      basic_format_context<std::back_insert_iterator<buffer<Char>>, Char>>;
+};
+template <> struct vformat_args<char> {
+  using type = format_args;
+};
+
+// Use vformat_args and avoid type_identity to keep symbols short.
+template <typename Char>
+void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
+                typename vformat_args<Char>::type args, locale_ref loc = {});
+
+FMT_API void vprint_mojibake(std::FILE*, string_view, format_args);
+#ifndef _WIN32
+inline void vprint_mojibake(std::FILE*, string_view, format_args) {}
+#endif
+}  // namespace detail
+
+FMT_BEGIN_EXPORT
+
+// A formatter specialization for natively supported types.
+template <typename T, typename Char>
+struct formatter<T, Char,
+                 enable_if_t<detail::type_constant<T, Char>::value !=
+                             detail::type::custom_type>> {
+ private:
+  detail::dynamic_format_specs<Char> specs_;
+
+ public:
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* {
+    auto type = detail::type_constant<T, Char>::value;
+    auto end =
+        detail::parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, type);
+    if (type == detail::type::char_type) detail::check_char_specs(specs_);
+    return end;
+  }
+
+  template <detail::type U = detail::type_constant<T, Char>::value,
+            FMT_ENABLE_IF(U == detail::type::string_type ||
+                          U == detail::type::cstring_type ||
+                          U == detail::type::char_type)>
+  FMT_CONSTEXPR void set_debug_format(bool set = true) {
+    specs_.type = set ? presentation_type::debug : presentation_type::none;
+  }
+
+  template <typename FormatContext>
+  FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const
+      -> decltype(ctx.out());
+};
+
+template <typename Char = char> struct runtime_format_string {
+  basic_string_view<Char> str;
+};
+
+/** A compile-time format string. */
+template <typename Char, typename... Args> class basic_format_string {
+ private:
+  basic_string_view<Char> str_;
+
+ public:
+  template <typename S,
+            FMT_ENABLE_IF(
+                std::is_convertible<const S&, basic_string_view<Char>>::value)>
+  FMT_CONSTEVAL FMT_INLINE basic_format_string(const S& s) : str_(s) {
+    static_assert(
+        detail::count<
+            (std::is_base_of<detail::view, remove_reference_t<Args>>::value &&
+             std::is_reference<Args>::value)...>() == 0,
+        "passing views as lvalues is disallowed");
+#ifdef FMT_HAS_CONSTEVAL
+    if constexpr (detail::count_named_args<Args...>() ==
+                  detail::count_statically_named_args<Args...>()) {
+      using checker =
+          detail::format_string_checker<Char, remove_cvref_t<Args>...>;
+      detail::parse_format_string<true>(str_, checker(s));
+    }
+#else
+    detail::check_format_string<Args...>(s);
+#endif
+  }
+  basic_format_string(runtime_format_string<Char> fmt) : str_(fmt.str) {}
+
+  FMT_INLINE operator basic_string_view<Char>() const { return str_; }
+  FMT_INLINE auto get() const -> basic_string_view<Char> { return str_; }
+};
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+// Workaround broken conversion on older gcc.
+template <typename...> using format_string = string_view;
+inline auto runtime(string_view s) -> string_view { return s; }
+#else
+template <typename... Args>
+using format_string = basic_format_string<char, type_identity_t<Args>...>;
+/**
+  \rst
+  Creates a runtime format string.
+
+  **Example**::
+
+    // Check format string at runtime instead of compile-time.
+    fmt::print(fmt::runtime("{:d}"), "I am not a number");
+  \endrst
+ */
+inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; }
+#endif
+
+FMT_API auto vformat(string_view fmt, format_args args) -> std::string;
+
+/**
+  \rst
+  Formats ``args`` according to specifications in ``fmt`` and returns the result
+  as a string.
+
+  **Example**::
+
+    #include <fmt/core.h>
+    std::string message = fmt::format("The answer is {}.", 42);
+  \endrst
+*/
+template <typename... T>
+FMT_NODISCARD FMT_INLINE auto format(format_string<T...> fmt, T&&... args)
+    -> std::string {
+  return vformat(fmt, fmt::make_format_args(args...));
+}
+
+/** Formats a string and writes the output to ``out``. */
+template <typename OutputIt,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt {
+  auto&& buf = detail::get_buffer<char>(out);
+  detail::vformat_to(buf, fmt, args, {});
+  return detail::get_iterator(buf, out);
+}
+
+/**
+ \rst
+ Formats ``args`` according to specifications in ``fmt``, writes the result to
+ the output iterator ``out`` and returns the iterator past the end of the output
+ range. `format_to` does not append a terminating null character.
+
+ **Example**::
+
+   auto out = std::vector<char>();
+   fmt::format_to(std::back_inserter(out), "{}", 42);
+ \endrst
+ */
+template <typename OutputIt, typename... T,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+FMT_INLINE auto format_to(OutputIt out, format_string<T...> fmt, T&&... args)
+    -> OutputIt {
+  return vformat_to(out, fmt, fmt::make_format_args(args...));
+}
+
+template <typename OutputIt> struct format_to_n_result {
+  /** Iterator past the end of the output range. */
+  OutputIt out;
+  /** Total (not truncated) output size. */
+  size_t size;
+};
+
+template <typename OutputIt, typename... T,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args 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()};
+}
+
+/**
+  \rst
+  Formats ``args`` according to specifications in ``fmt``, writes up to ``n``
+  characters of the result to the output iterator ``out`` and returns the total
+  (not truncated) output size and the iterator past the end of the output range.
+  `format_to_n` does not append a terminating null character.
+  \endrst
+ */
+template <typename OutputIt, typename... T,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt,
+                            T&&... args) -> format_to_n_result<OutputIt> {
+  return vformat_to_n(out, n, fmt, fmt::make_format_args(args...));
+}
+
+/** Returns the number of chars in the output of ``format(fmt, args...)``. */
+template <typename... T>
+FMT_NODISCARD FMT_INLINE auto formatted_size(format_string<T...> fmt,
+                                             T&&... args) -> size_t {
+  auto buf = detail::counting_buffer<>();
+  detail::vformat_to<char>(buf, fmt, fmt::make_format_args(args...), {});
+  return buf.count();
+}
+
+FMT_API void vprint(string_view fmt, format_args args);
+FMT_API void vprint(std::FILE* f, string_view fmt, format_args args);
+
+/**
+  \rst
+  Formats ``args`` according to specifications in ``fmt`` and writes the output
+  to ``stdout``.
+
+  **Example**::
+
+    fmt::print("Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
+ */
+template <typename... T>
+FMT_INLINE void print(format_string<T...> fmt, T&&... args) {
+  const auto& vargs = fmt::make_format_args(args...);
+  return detail::is_utf8() ? vprint(fmt, vargs)
+                           : detail::vprint_mojibake(stdout, fmt, vargs);
+}
+
+/**
+  \rst
+  Formats ``args`` according to specifications in ``fmt`` and writes the
+  output to the file ``f``.
+
+  **Example**::
+
+    fmt::print(stderr, "Don't {}!", "panic");
+  \endrst
+ */
+template <typename... T>
+FMT_INLINE void print(std::FILE* f, format_string<T...> fmt, T&&... args) {
+  const auto& vargs = fmt::make_format_args(args...);
+  return detail::is_utf8() ? vprint(f, fmt, vargs)
+                           : detail::vprint_mojibake(f, fmt, vargs);
+}
+
+/**
+  Formats ``args`` according to specifications in ``fmt`` and writes the
+  output to the file ``f`` followed by a newline.
+ */
+template <typename... T>
+FMT_INLINE void println(std::FILE* f, format_string<T...> fmt, T&&... args) {
+  return fmt::print(f, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
+}
+
+/**
+  Formats ``args`` according to specifications in ``fmt`` and writes the output
+  to ``stdout`` followed by a newline.
+ */
+template <typename... T>
+FMT_INLINE void println(format_string<T...> fmt, T&&... args) {
+  return fmt::println(stdout, fmt, std::forward<T>(args)...);
+}
+
+FMT_END_EXPORT
+FMT_GCC_PRAGMA("GCC pop_options")
+FMT_END_NAMESPACE
+
+#ifdef FMT_HEADER_ONLY
+#  include "format.h"
+#endif
+#endif  // FMT_CORE_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format-inl.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format-inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..efac5d1f88fef3f9f074ccb46e13bc78caaa762c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format-inl.h
@@ -0,0 +1,1678 @@
+// Formatting library for C++ - implementation
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_FORMAT_INL_H_
+#define FMT_FORMAT_INL_H_
+
+#include <algorithm>
+#include <cerrno>  // errno
+#include <climits>
+#include <cmath>
+#include <exception>
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+#  include <locale>
+#endif
+
+#if defined(_WIN32) && !defined(FMT_WINDOWS_NO_WCHAR)
+#  include <io.h>  // _isatty
+#endif
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
+  // Use unchecked std::fprintf to avoid triggering another assertion when
+  // writing to stderr fails
+  std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
+  // Chosen instead of std::abort to satisfy Clang in CUDA mode during device
+  // code pass.
+  std::terminate();
+}
+
+FMT_FUNC void throw_format_error(const char* message) {
+  FMT_THROW(format_error(message));
+}
+
+FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
+                                string_view message) noexcept {
+  // Report error code making sure that the output fits into
+  // inline_buffer_size to avoid dynamic memory allocation and potential
+  // bad_alloc.
+  out.try_resize(0);
+  static const char SEP[] = ": ";
+  static const char ERROR_STR[] = "error ";
+  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
+  size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
+  auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code);
+  if (detail::is_negative(error_code)) {
+    abs_value = 0 - abs_value;
+    ++error_code_size;
+  }
+  error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
+  auto it = buffer_appender<char>(out);
+  if (message.size() <= inline_buffer_size - error_code_size)
+    fmt::format_to(it, FMT_STRING("{}{}"), message, SEP);
+  fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
+  FMT_ASSERT(out.size() <= inline_buffer_size, "");
+}
+
+FMT_FUNC void report_error(format_func func, int error_code,
+                           const char* message) noexcept {
+  memory_buffer full_message;
+  func(full_message, error_code, message);
+  // Don't use fwrite_fully because the latter may throw.
+  if (std::fwrite(full_message.data(), full_message.size(), 1, stderr) > 0)
+    std::fputc('\n', stderr);
+}
+
+// A wrapper around fwrite that throws on error.
+inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) {
+  size_t written = std::fwrite(ptr, 1, count, stream);
+  if (written < count)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+template <typename Locale>
+locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
+  static_assert(std::is_same<Locale, std::locale>::value, "");
+}
+
+template <typename Locale> auto locale_ref::get() const -> Locale {
+  static_assert(std::is_same<Locale, std::locale>::value, "");
+  return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
+}
+
+template <typename Char>
+FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
+  auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
+  auto grouping = facet.grouping();
+  auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
+  return {std::move(grouping), thousands_sep};
+}
+template <typename Char>
+FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char {
+  return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
+      .decimal_point();
+}
+#else
+template <typename Char>
+FMT_FUNC auto thousands_sep_impl(locale_ref) -> thousands_sep_result<Char> {
+  return {"\03", FMT_STATIC_THOUSANDS_SEPARATOR};
+}
+template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
+  return '.';
+}
+#endif
+
+FMT_FUNC auto write_loc(appender out, loc_value value,
+                        const format_specs<>& specs, locale_ref loc) -> bool {
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+  auto locale = loc.get<std::locale>();
+  // We cannot use the num_put<char> facet because it may produce output in
+  // a wrong encoding.
+  using facet = format_facet<std::locale>;
+  if (std::has_facet<facet>(locale))
+    return std::use_facet<facet>(locale).put(out, value, specs);
+  return facet(locale).put(out, value, specs);
+#endif
+  return false;
+}
+}  // namespace detail
+
+template <typename Locale> typename Locale::id format_facet<Locale>::id;
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+template <typename Locale> format_facet<Locale>::format_facet(Locale& loc) {
+  auto& numpunct = std::use_facet<std::numpunct<char>>(loc);
+  grouping_ = numpunct.grouping();
+  if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep());
+}
+
+template <>
+FMT_API FMT_FUNC auto format_facet<std::locale>::do_put(
+    appender out, loc_value val, const format_specs<>& specs) const -> bool {
+  return val.visit(
+      detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_});
+}
+#endif
+
+FMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args)
+    -> std::system_error {
+  auto ec = std::error_code(error_code, std::generic_category());
+  return std::system_error(ec, vformat(fmt, args));
+}
+
+namespace detail {
+
+template <typename F>
+inline auto operator==(basic_fp<F> x, basic_fp<F> y) -> bool {
+  return x.f == y.f && x.e == y.e;
+}
+
+// Compilers should be able to optimize this into the ror instruction.
+FMT_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t {
+  r &= 31;
+  return (n >> r) | (n << (32 - r));
+}
+FMT_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t {
+  r &= 63;
+  return (n >> r) | (n << (64 - r));
+}
+
+// Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
+namespace dragonbox {
+// Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a
+// 64-bit unsigned integer.
+inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t {
+  return umul128_upper64(static_cast<uint64_t>(x) << 32, y);
+}
+
+// Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a
+// 128-bit unsigned integer.
+inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept
+    -> uint128_fallback {
+  uint64_t high = x * y.high();
+  uint128_fallback high_low = umul128(x, y.low());
+  return {high + high_low.high(), high_low.low()};
+}
+
+// Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
+// 64-bit unsigned integer.
+inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t {
+  return x * y;
+}
+
+// Various fast log computations.
+inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int {
+  FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
+  return (e * 631305 - 261663) >> 21;
+}
+
+FMT_INLINE_VARIABLE constexpr struct {
+  uint32_t divisor;
+  int shift_amount;
+} div_small_pow10_infos[] = {{10, 16}, {100, 16}};
+
+// Replaces n by floor(n / pow(10, N)) returning true if and only if n is
+// divisible by pow(10, N).
+// Precondition: n <= pow(10, N + 1).
+template <int N>
+auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool {
+  // The numbers below are chosen such that:
+  //   1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100,
+  //   2. nm mod 2^k < m if and only if n is divisible by d,
+  // where m is magic_number, k is shift_amount
+  // and d is divisor.
+  //
+  // Item 1 is a common technique of replacing division by a constant with
+  // multiplication, see e.g. "Division by Invariant Integers Using
+  // Multiplication" by Granlund and Montgomery (1994). magic_number (m) is set
+  // to ceil(2^k/d) for large enough k.
+  // The idea for item 2 originates from Schubfach.
+  constexpr auto info = div_small_pow10_infos[N - 1];
+  FMT_ASSERT(n <= info.divisor * 10, "n is too large");
+  constexpr uint32_t magic_number =
+      (1u << info.shift_amount) / info.divisor + 1;
+  n *= magic_number;
+  const uint32_t comparison_mask = (1u << info.shift_amount) - 1;
+  bool result = (n & comparison_mask) < magic_number;
+  n >>= info.shift_amount;
+  return result;
+}
+
+// Computes floor(n / pow(10, N)) for small n and N.
+// Precondition: n <= pow(10, N + 1).
+template <int N> auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t {
+  constexpr auto info = div_small_pow10_infos[N - 1];
+  FMT_ASSERT(n <= info.divisor * 10, "n is too large");
+  constexpr uint32_t magic_number =
+      (1u << info.shift_amount) / info.divisor + 1;
+  return (n * magic_number) >> info.shift_amount;
+}
+
+// Computes floor(n / 10^(kappa + 1)) (float)
+inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t {
+  // 1374389535 = ceil(2^37/100)
+  return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37);
+}
+// Computes floor(n / 10^(kappa + 1)) (double)
+inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t {
+  // 2361183241434822607 = ceil(2^(64+7)/1000)
+  return umul128_upper64(n, 2361183241434822607ull) >> 7;
+}
+
+// Various subroutines using pow10 cache
+template <typename T> struct cache_accessor;
+
+template <> struct cache_accessor<float> {
+  using carrier_uint = float_info<float>::carrier_uint;
+  using cache_entry_type = uint64_t;
+
+  static auto get_cached_power(int k) noexcept -> uint64_t {
+    FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k,
+               "k is out of range");
+    static constexpr const uint64_t pow10_significands[] = {
+        0x81ceb32c4b43fcf5, 0xa2425ff75e14fc32, 0xcad2f7f5359a3b3f,
+        0xfd87b5f28300ca0e, 0x9e74d1b791e07e49, 0xc612062576589ddb,
+        0xf79687aed3eec552, 0x9abe14cd44753b53, 0xc16d9a0095928a28,
+        0xf1c90080baf72cb2, 0x971da05074da7bef, 0xbce5086492111aeb,
+        0xec1e4a7db69561a6, 0x9392ee8e921d5d08, 0xb877aa3236a4b44a,
+        0xe69594bec44de15c, 0x901d7cf73ab0acda, 0xb424dc35095cd810,
+        0xe12e13424bb40e14, 0x8cbccc096f5088cc, 0xafebff0bcb24aaff,
+        0xdbe6fecebdedd5bf, 0x89705f4136b4a598, 0xabcc77118461cefd,
+        0xd6bf94d5e57a42bd, 0x8637bd05af6c69b6, 0xa7c5ac471b478424,
+        0xd1b71758e219652c, 0x83126e978d4fdf3c, 0xa3d70a3d70a3d70b,
+        0xcccccccccccccccd, 0x8000000000000000, 0xa000000000000000,
+        0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000,
+        0xc350000000000000, 0xf424000000000000, 0x9896800000000000,
+        0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000,
+        0xba43b74000000000, 0xe8d4a51000000000, 0x9184e72a00000000,
+        0xb5e620f480000000, 0xe35fa931a0000000, 0x8e1bc9bf04000000,
+        0xb1a2bc2ec5000000, 0xde0b6b3a76400000, 0x8ac7230489e80000,
+        0xad78ebc5ac620000, 0xd8d726b7177a8000, 0x878678326eac9000,
+        0xa968163f0a57b400, 0xd3c21bcecceda100, 0x84595161401484a0,
+        0xa56fa5b99019a5c8, 0xcecb8f27f4200f3a, 0x813f3978f8940985,
+        0xa18f07d736b90be6, 0xc9f2c9cd04674edf, 0xfc6f7c4045812297,
+        0x9dc5ada82b70b59e, 0xc5371912364ce306, 0xf684df56c3e01bc7,
+        0x9a130b963a6c115d, 0xc097ce7bc90715b4, 0xf0bdc21abb48db21,
+        0x96769950b50d88f5, 0xbc143fa4e250eb32, 0xeb194f8e1ae525fe,
+        0x92efd1b8d0cf37bf, 0xb7abc627050305ae, 0xe596b7b0c643c71a,
+        0x8f7e32ce7bea5c70, 0xb35dbf821ae4f38c, 0xe0352f62a19e306f};
+    return pow10_significands[k - float_info<float>::min_k];
+  }
+
+  struct compute_mul_result {
+    carrier_uint result;
+    bool is_integer;
+  };
+  struct compute_mul_parity_result {
+    bool parity;
+    bool is_integer;
+  };
+
+  static auto compute_mul(carrier_uint u,
+                          const cache_entry_type& cache) noexcept
+      -> compute_mul_result {
+    auto r = umul96_upper64(u, cache);
+    return {static_cast<carrier_uint>(r >> 32),
+            static_cast<carrier_uint>(r) == 0};
+  }
+
+  static auto compute_delta(const cache_entry_type& cache, int beta) noexcept
+      -> uint32_t {
+    return static_cast<uint32_t>(cache >> (64 - 1 - beta));
+  }
+
+  static auto compute_mul_parity(carrier_uint two_f,
+                                 const cache_entry_type& cache,
+                                 int beta) noexcept
+      -> compute_mul_parity_result {
+    FMT_ASSERT(beta >= 1, "");
+    FMT_ASSERT(beta < 64, "");
+
+    auto r = umul96_lower64(two_f, cache);
+    return {((r >> (64 - beta)) & 1) != 0,
+            static_cast<uint32_t>(r >> (32 - beta)) == 0};
+  }
+
+  static auto compute_left_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
+    return static_cast<carrier_uint>(
+        (cache - (cache >> (num_significand_bits<float>() + 2))) >>
+        (64 - num_significand_bits<float>() - 1 - beta));
+  }
+
+  static auto compute_right_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
+    return static_cast<carrier_uint>(
+        (cache + (cache >> (num_significand_bits<float>() + 1))) >>
+        (64 - num_significand_bits<float>() - 1 - beta));
+  }
+
+  static auto compute_round_up_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
+    return (static_cast<carrier_uint>(
+                cache >> (64 - num_significand_bits<float>() - 2 - beta)) +
+            1) /
+           2;
+  }
+};
+
+template <> struct cache_accessor<double> {
+  using carrier_uint = float_info<double>::carrier_uint;
+  using cache_entry_type = uint128_fallback;
+
+  static auto get_cached_power(int k) noexcept -> uint128_fallback {
+    FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
+               "k is out of range");
+
+    static constexpr const uint128_fallback pow10_significands[] = {
+#if FMT_USE_FULL_CACHE_DRAGONBOX
+      {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
+      {0x9faacf3df73609b1, 0x77b191618c54e9ad},
+      {0xc795830d75038c1d, 0xd59df5b9ef6a2418},
+      {0xf97ae3d0d2446f25, 0x4b0573286b44ad1e},
+      {0x9becce62836ac577, 0x4ee367f9430aec33},
+      {0xc2e801fb244576d5, 0x229c41f793cda740},
+      {0xf3a20279ed56d48a, 0x6b43527578c11110},
+      {0x9845418c345644d6, 0x830a13896b78aaaa},
+      {0xbe5691ef416bd60c, 0x23cc986bc656d554},
+      {0xedec366b11c6cb8f, 0x2cbfbe86b7ec8aa9},
+      {0x94b3a202eb1c3f39, 0x7bf7d71432f3d6aa},
+      {0xb9e08a83a5e34f07, 0xdaf5ccd93fb0cc54},
+      {0xe858ad248f5c22c9, 0xd1b3400f8f9cff69},
+      {0x91376c36d99995be, 0x23100809b9c21fa2},
+      {0xb58547448ffffb2d, 0xabd40a0c2832a78b},
+      {0xe2e69915b3fff9f9, 0x16c90c8f323f516d},
+      {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4},
+      {0xb1442798f49ffb4a, 0x99cd11cfdf41779d},
+      {0xdd95317f31c7fa1d, 0x40405643d711d584},
+      {0x8a7d3eef7f1cfc52, 0x482835ea666b2573},
+      {0xad1c8eab5ee43b66, 0xda3243650005eed0},
+      {0xd863b256369d4a40, 0x90bed43e40076a83},
+      {0x873e4f75e2224e68, 0x5a7744a6e804a292},
+      {0xa90de3535aaae202, 0x711515d0a205cb37},
+      {0xd3515c2831559a83, 0x0d5a5b44ca873e04},
+      {0x8412d9991ed58091, 0xe858790afe9486c3},
+      {0xa5178fff668ae0b6, 0x626e974dbe39a873},
+      {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
+      {0x80fa687f881c7f8e, 0x7ce66634bc9d0b9a},
+      {0xa139029f6a239f72, 0x1c1fffc1ebc44e81},
+      {0xc987434744ac874e, 0xa327ffb266b56221},
+      {0xfbe9141915d7a922, 0x4bf1ff9f0062baa9},
+      {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa},
+      {0xc4ce17b399107c22, 0xcb550fb4384d21d4},
+      {0xf6019da07f549b2b, 0x7e2a53a146606a49},
+      {0x99c102844f94e0fb, 0x2eda7444cbfc426e},
+      {0xc0314325637a1939, 0xfa911155fefb5309},
+      {0xf03d93eebc589f88, 0x793555ab7eba27cb},
+      {0x96267c7535b763b5, 0x4bc1558b2f3458df},
+      {0xbbb01b9283253ca2, 0x9eb1aaedfb016f17},
+      {0xea9c227723ee8bcb, 0x465e15a979c1cadd},
+      {0x92a1958a7675175f, 0x0bfacd89ec191eca},
+      {0xb749faed14125d36, 0xcef980ec671f667c},
+      {0xe51c79a85916f484, 0x82b7e12780e7401b},
+      {0x8f31cc0937ae58d2, 0xd1b2ecb8b0908811},
+      {0xb2fe3f0b8599ef07, 0x861fa7e6dcb4aa16},
+      {0xdfbdcece67006ac9, 0x67a791e093e1d49b},
+      {0x8bd6a141006042bd, 0xe0c8bb2c5c6d24e1},
+      {0xaecc49914078536d, 0x58fae9f773886e19},
+      {0xda7f5bf590966848, 0xaf39a475506a899f},
+      {0x888f99797a5e012d, 0x6d8406c952429604},
+      {0xaab37fd7d8f58178, 0xc8e5087ba6d33b84},
+      {0xd5605fcdcf32e1d6, 0xfb1e4a9a90880a65},
+      {0x855c3be0a17fcd26, 0x5cf2eea09a550680},
+      {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
+      {0xd0601d8efc57b08b, 0xf13b94daf124da27},
+      {0x823c12795db6ce57, 0x76c53d08d6b70859},
+      {0xa2cb1717b52481ed, 0x54768c4b0c64ca6f},
+      {0xcb7ddcdda26da268, 0xa9942f5dcf7dfd0a},
+      {0xfe5d54150b090b02, 0xd3f93b35435d7c4d},
+      {0x9efa548d26e5a6e1, 0xc47bc5014a1a6db0},
+      {0xc6b8e9b0709f109a, 0x359ab6419ca1091c},
+      {0xf867241c8cc6d4c0, 0xc30163d203c94b63},
+      {0x9b407691d7fc44f8, 0x79e0de63425dcf1e},
+      {0xc21094364dfb5636, 0x985915fc12f542e5},
+      {0xf294b943e17a2bc4, 0x3e6f5b7b17b2939e},
+      {0x979cf3ca6cec5b5a, 0xa705992ceecf9c43},
+      {0xbd8430bd08277231, 0x50c6ff782a838354},
+      {0xece53cec4a314ebd, 0xa4f8bf5635246429},
+      {0x940f4613ae5ed136, 0x871b7795e136be9a},
+      {0xb913179899f68584, 0x28e2557b59846e40},
+      {0xe757dd7ec07426e5, 0x331aeada2fe589d0},
+      {0x9096ea6f3848984f, 0x3ff0d2c85def7622},
+      {0xb4bca50b065abe63, 0x0fed077a756b53aa},
+      {0xe1ebce4dc7f16dfb, 0xd3e8495912c62895},
+      {0x8d3360f09cf6e4bd, 0x64712dd7abbbd95d},
+      {0xb080392cc4349dec, 0xbd8d794d96aacfb4},
+      {0xdca04777f541c567, 0xecf0d7a0fc5583a1},
+      {0x89e42caaf9491b60, 0xf41686c49db57245},
+      {0xac5d37d5b79b6239, 0x311c2875c522ced6},
+      {0xd77485cb25823ac7, 0x7d633293366b828c},
+      {0x86a8d39ef77164bc, 0xae5dff9c02033198},
+      {0xa8530886b54dbdeb, 0xd9f57f830283fdfd},
+      {0xd267caa862a12d66, 0xd072df63c324fd7c},
+      {0x8380dea93da4bc60, 0x4247cb9e59f71e6e},
+      {0xa46116538d0deb78, 0x52d9be85f074e609},
+      {0xcd795be870516656, 0x67902e276c921f8c},
+      {0x806bd9714632dff6, 0x00ba1cd8a3db53b7},
+      {0xa086cfcd97bf97f3, 0x80e8a40eccd228a5},
+      {0xc8a883c0fdaf7df0, 0x6122cd128006b2ce},
+      {0xfad2a4b13d1b5d6c, 0x796b805720085f82},
+      {0x9cc3a6eec6311a63, 0xcbe3303674053bb1},
+      {0xc3f490aa77bd60fc, 0xbedbfc4411068a9d},
+      {0xf4f1b4d515acb93b, 0xee92fb5515482d45},
+      {0x991711052d8bf3c5, 0x751bdd152d4d1c4b},
+      {0xbf5cd54678eef0b6, 0xd262d45a78a0635e},
+      {0xef340a98172aace4, 0x86fb897116c87c35},
+      {0x9580869f0e7aac0e, 0xd45d35e6ae3d4da1},
+      {0xbae0a846d2195712, 0x8974836059cca10a},
+      {0xe998d258869facd7, 0x2bd1a438703fc94c},
+      {0x91ff83775423cc06, 0x7b6306a34627ddd0},
+      {0xb67f6455292cbf08, 0x1a3bc84c17b1d543},
+      {0xe41f3d6a7377eeca, 0x20caba5f1d9e4a94},
+      {0x8e938662882af53e, 0x547eb47b7282ee9d},
+      {0xb23867fb2a35b28d, 0xe99e619a4f23aa44},
+      {0xdec681f9f4c31f31, 0x6405fa00e2ec94d5},
+      {0x8b3c113c38f9f37e, 0xde83bc408dd3dd05},
+      {0xae0b158b4738705e, 0x9624ab50b148d446},
+      {0xd98ddaee19068c76, 0x3badd624dd9b0958},
+      {0x87f8a8d4cfa417c9, 0xe54ca5d70a80e5d7},
+      {0xa9f6d30a038d1dbc, 0x5e9fcf4ccd211f4d},
+      {0xd47487cc8470652b, 0x7647c32000696720},
+      {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074},
+      {0xa5fb0a17c777cf09, 0xf468107100525891},
+      {0xcf79cc9db955c2cc, 0x7182148d4066eeb5},
+      {0x81ac1fe293d599bf, 0xc6f14cd848405531},
+      {0xa21727db38cb002f, 0xb8ada00e5a506a7d},
+      {0xca9cf1d206fdc03b, 0xa6d90811f0e4851d},
+      {0xfd442e4688bd304a, 0x908f4a166d1da664},
+      {0x9e4a9cec15763e2e, 0x9a598e4e043287ff},
+      {0xc5dd44271ad3cdba, 0x40eff1e1853f29fe},
+      {0xf7549530e188c128, 0xd12bee59e68ef47d},
+      {0x9a94dd3e8cf578b9, 0x82bb74f8301958cf},
+      {0xc13a148e3032d6e7, 0xe36a52363c1faf02},
+      {0xf18899b1bc3f8ca1, 0xdc44e6c3cb279ac2},
+      {0x96f5600f15a7b7e5, 0x29ab103a5ef8c0ba},
+      {0xbcb2b812db11a5de, 0x7415d448f6b6f0e8},
+      {0xebdf661791d60f56, 0x111b495b3464ad22},
+      {0x936b9fcebb25c995, 0xcab10dd900beec35},
+      {0xb84687c269ef3bfb, 0x3d5d514f40eea743},
+      {0xe65829b3046b0afa, 0x0cb4a5a3112a5113},
+      {0x8ff71a0fe2c2e6dc, 0x47f0e785eaba72ac},
+      {0xb3f4e093db73a093, 0x59ed216765690f57},
+      {0xe0f218b8d25088b8, 0x306869c13ec3532d},
+      {0x8c974f7383725573, 0x1e414218c73a13fc},
+      {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
+      {0xdbac6c247d62a583, 0xdf45f746b74abf3a},
+      {0x894bc396ce5da772, 0x6b8bba8c328eb784},
+      {0xab9eb47c81f5114f, 0x066ea92f3f326565},
+      {0xd686619ba27255a2, 0xc80a537b0efefebe},
+      {0x8613fd0145877585, 0xbd06742ce95f5f37},
+      {0xa798fc4196e952e7, 0x2c48113823b73705},
+      {0xd17f3b51fca3a7a0, 0xf75a15862ca504c6},
+      {0x82ef85133de648c4, 0x9a984d73dbe722fc},
+      {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb},
+      {0xcc963fee10b7d1b3, 0x318df905079926a9},
+      {0xffbbcfe994e5c61f, 0xfdf17746497f7053},
+      {0x9fd561f1fd0f9bd3, 0xfeb6ea8bedefa634},
+      {0xc7caba6e7c5382c8, 0xfe64a52ee96b8fc1},
+      {0xf9bd690a1b68637b, 0x3dfdce7aa3c673b1},
+      {0x9c1661a651213e2d, 0x06bea10ca65c084f},
+      {0xc31bfa0fe5698db8, 0x486e494fcff30a63},
+      {0xf3e2f893dec3f126, 0x5a89dba3c3efccfb},
+      {0x986ddb5c6b3a76b7, 0xf89629465a75e01d},
+      {0xbe89523386091465, 0xf6bbb397f1135824},
+      {0xee2ba6c0678b597f, 0x746aa07ded582e2d},
+      {0x94db483840b717ef, 0xa8c2a44eb4571cdd},
+      {0xba121a4650e4ddeb, 0x92f34d62616ce414},
+      {0xe896a0d7e51e1566, 0x77b020baf9c81d18},
+      {0x915e2486ef32cd60, 0x0ace1474dc1d122f},
+      {0xb5b5ada8aaff80b8, 0x0d819992132456bb},
+      {0xe3231912d5bf60e6, 0x10e1fff697ed6c6a},
+      {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
+      {0xb1736b96b6fd83b3, 0xbd308ff8a6b17cb3},
+      {0xddd0467c64bce4a0, 0xac7cb3f6d05ddbdf},
+      {0x8aa22c0dbef60ee4, 0x6bcdf07a423aa96c},
+      {0xad4ab7112eb3929d, 0x86c16c98d2c953c7},
+      {0xd89d64d57a607744, 0xe871c7bf077ba8b8},
+      {0x87625f056c7c4a8b, 0x11471cd764ad4973},
+      {0xa93af6c6c79b5d2d, 0xd598e40d3dd89bd0},
+      {0xd389b47879823479, 0x4aff1d108d4ec2c4},
+      {0x843610cb4bf160cb, 0xcedf722a585139bb},
+      {0xa54394fe1eedb8fe, 0xc2974eb4ee658829},
+      {0xce947a3da6a9273e, 0x733d226229feea33},
+      {0x811ccc668829b887, 0x0806357d5a3f5260},
+      {0xa163ff802a3426a8, 0xca07c2dcb0cf26f8},
+      {0xc9bcff6034c13052, 0xfc89b393dd02f0b6},
+      {0xfc2c3f3841f17c67, 0xbbac2078d443ace3},
+      {0x9d9ba7832936edc0, 0xd54b944b84aa4c0e},
+      {0xc5029163f384a931, 0x0a9e795e65d4df12},
+      {0xf64335bcf065d37d, 0x4d4617b5ff4a16d6},
+      {0x99ea0196163fa42e, 0x504bced1bf8e4e46},
+      {0xc06481fb9bcf8d39, 0xe45ec2862f71e1d7},
+      {0xf07da27a82c37088, 0x5d767327bb4e5a4d},
+      {0x964e858c91ba2655, 0x3a6a07f8d510f870},
+      {0xbbe226efb628afea, 0x890489f70a55368c},
+      {0xeadab0aba3b2dbe5, 0x2b45ac74ccea842f},
+      {0x92c8ae6b464fc96f, 0x3b0b8bc90012929e},
+      {0xb77ada0617e3bbcb, 0x09ce6ebb40173745},
+      {0xe55990879ddcaabd, 0xcc420a6a101d0516},
+      {0x8f57fa54c2a9eab6, 0x9fa946824a12232e},
+      {0xb32df8e9f3546564, 0x47939822dc96abfa},
+      {0xdff9772470297ebd, 0x59787e2b93bc56f8},
+      {0x8bfbea76c619ef36, 0x57eb4edb3c55b65b},
+      {0xaefae51477a06b03, 0xede622920b6b23f2},
+      {0xdab99e59958885c4, 0xe95fab368e45ecee},
+      {0x88b402f7fd75539b, 0x11dbcb0218ebb415},
+      {0xaae103b5fcd2a881, 0xd652bdc29f26a11a},
+      {0xd59944a37c0752a2, 0x4be76d3346f04960},
+      {0x857fcae62d8493a5, 0x6f70a4400c562ddc},
+      {0xa6dfbd9fb8e5b88e, 0xcb4ccd500f6bb953},
+      {0xd097ad07a71f26b2, 0x7e2000a41346a7a8},
+      {0x825ecc24c873782f, 0x8ed400668c0c28c9},
+      {0xa2f67f2dfa90563b, 0x728900802f0f32fb},
+      {0xcbb41ef979346bca, 0x4f2b40a03ad2ffba},
+      {0xfea126b7d78186bc, 0xe2f610c84987bfa9},
+      {0x9f24b832e6b0f436, 0x0dd9ca7d2df4d7ca},
+      {0xc6ede63fa05d3143, 0x91503d1c79720dbc},
+      {0xf8a95fcf88747d94, 0x75a44c6397ce912b},
+      {0x9b69dbe1b548ce7c, 0xc986afbe3ee11abb},
+      {0xc24452da229b021b, 0xfbe85badce996169},
+      {0xf2d56790ab41c2a2, 0xfae27299423fb9c4},
+      {0x97c560ba6b0919a5, 0xdccd879fc967d41b},
+      {0xbdb6b8e905cb600f, 0x5400e987bbc1c921},
+      {0xed246723473e3813, 0x290123e9aab23b69},
+      {0x9436c0760c86e30b, 0xf9a0b6720aaf6522},
+      {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
+      {0xe7958cb87392c2c2, 0xb60b1d1230b20e05},
+      {0x90bd77f3483bb9b9, 0xb1c6f22b5e6f48c3},
+      {0xb4ecd5f01a4aa828, 0x1e38aeb6360b1af4},
+      {0xe2280b6c20dd5232, 0x25c6da63c38de1b1},
+      {0x8d590723948a535f, 0x579c487e5a38ad0f},
+      {0xb0af48ec79ace837, 0x2d835a9df0c6d852},
+      {0xdcdb1b2798182244, 0xf8e431456cf88e66},
+      {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900},
+      {0xac8b2d36eed2dac5, 0xe272467e3d222f40},
+      {0xd7adf884aa879177, 0x5b0ed81dcc6abb10},
+      {0x86ccbb52ea94baea, 0x98e947129fc2b4ea},
+      {0xa87fea27a539e9a5, 0x3f2398d747b36225},
+      {0xd29fe4b18e88640e, 0x8eec7f0d19a03aae},
+      {0x83a3eeeef9153e89, 0x1953cf68300424ad},
+      {0xa48ceaaab75a8e2b, 0x5fa8c3423c052dd8},
+      {0xcdb02555653131b6, 0x3792f412cb06794e},
+      {0x808e17555f3ebf11, 0xe2bbd88bbee40bd1},
+      {0xa0b19d2ab70e6ed6, 0x5b6aceaeae9d0ec5},
+      {0xc8de047564d20a8b, 0xf245825a5a445276},
+      {0xfb158592be068d2e, 0xeed6e2f0f0d56713},
+      {0x9ced737bb6c4183d, 0x55464dd69685606c},
+      {0xc428d05aa4751e4c, 0xaa97e14c3c26b887},
+      {0xf53304714d9265df, 0xd53dd99f4b3066a9},
+      {0x993fe2c6d07b7fab, 0xe546a8038efe402a},
+      {0xbf8fdb78849a5f96, 0xde98520472bdd034},
+      {0xef73d256a5c0f77c, 0x963e66858f6d4441},
+      {0x95a8637627989aad, 0xdde7001379a44aa9},
+      {0xbb127c53b17ec159, 0x5560c018580d5d53},
+      {0xe9d71b689dde71af, 0xaab8f01e6e10b4a7},
+      {0x9226712162ab070d, 0xcab3961304ca70e9},
+      {0xb6b00d69bb55c8d1, 0x3d607b97c5fd0d23},
+      {0xe45c10c42a2b3b05, 0x8cb89a7db77c506b},
+      {0x8eb98a7a9a5b04e3, 0x77f3608e92adb243},
+      {0xb267ed1940f1c61c, 0x55f038b237591ed4},
+      {0xdf01e85f912e37a3, 0x6b6c46dec52f6689},
+      {0x8b61313bbabce2c6, 0x2323ac4b3b3da016},
+      {0xae397d8aa96c1b77, 0xabec975e0a0d081b},
+      {0xd9c7dced53c72255, 0x96e7bd358c904a22},
+      {0x881cea14545c7575, 0x7e50d64177da2e55},
+      {0xaa242499697392d2, 0xdde50bd1d5d0b9ea},
+      {0xd4ad2dbfc3d07787, 0x955e4ec64b44e865},
+      {0x84ec3c97da624ab4, 0xbd5af13bef0b113f},
+      {0xa6274bbdd0fadd61, 0xecb1ad8aeacdd58f},
+      {0xcfb11ead453994ba, 0x67de18eda5814af3},
+      {0x81ceb32c4b43fcf4, 0x80eacf948770ced8},
+      {0xa2425ff75e14fc31, 0xa1258379a94d028e},
+      {0xcad2f7f5359a3b3e, 0x096ee45813a04331},
+      {0xfd87b5f28300ca0d, 0x8bca9d6e188853fd},
+      {0x9e74d1b791e07e48, 0x775ea264cf55347e},
+      {0xc612062576589dda, 0x95364afe032a819e},
+      {0xf79687aed3eec551, 0x3a83ddbd83f52205},
+      {0x9abe14cd44753b52, 0xc4926a9672793543},
+      {0xc16d9a0095928a27, 0x75b7053c0f178294},
+      {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
+      {0x971da05074da7bee, 0xd3f6fc16ebca5e04},
+      {0xbce5086492111aea, 0x88f4bb1ca6bcf585},
+      {0xec1e4a7db69561a5, 0x2b31e9e3d06c32e6},
+      {0x9392ee8e921d5d07, 0x3aff322e62439fd0},
+      {0xb877aa3236a4b449, 0x09befeb9fad487c3},
+      {0xe69594bec44de15b, 0x4c2ebe687989a9b4},
+      {0x901d7cf73ab0acd9, 0x0f9d37014bf60a11},
+      {0xb424dc35095cd80f, 0x538484c19ef38c95},
+      {0xe12e13424bb40e13, 0x2865a5f206b06fba},
+      {0x8cbccc096f5088cb, 0xf93f87b7442e45d4},
+      {0xafebff0bcb24aafe, 0xf78f69a51539d749},
+      {0xdbe6fecebdedd5be, 0xb573440e5a884d1c},
+      {0x89705f4136b4a597, 0x31680a88f8953031},
+      {0xabcc77118461cefc, 0xfdc20d2b36ba7c3e},
+      {0xd6bf94d5e57a42bc, 0x3d32907604691b4d},
+      {0x8637bd05af6c69b5, 0xa63f9a49c2c1b110},
+      {0xa7c5ac471b478423, 0x0fcf80dc33721d54},
+      {0xd1b71758e219652b, 0xd3c36113404ea4a9},
+      {0x83126e978d4fdf3b, 0x645a1cac083126ea},
+      {0xa3d70a3d70a3d70a, 0x3d70a3d70a3d70a4},
+      {0xcccccccccccccccc, 0xcccccccccccccccd},
+      {0x8000000000000000, 0x0000000000000000},
+      {0xa000000000000000, 0x0000000000000000},
+      {0xc800000000000000, 0x0000000000000000},
+      {0xfa00000000000000, 0x0000000000000000},
+      {0x9c40000000000000, 0x0000000000000000},
+      {0xc350000000000000, 0x0000000000000000},
+      {0xf424000000000000, 0x0000000000000000},
+      {0x9896800000000000, 0x0000000000000000},
+      {0xbebc200000000000, 0x0000000000000000},
+      {0xee6b280000000000, 0x0000000000000000},
+      {0x9502f90000000000, 0x0000000000000000},
+      {0xba43b74000000000, 0x0000000000000000},
+      {0xe8d4a51000000000, 0x0000000000000000},
+      {0x9184e72a00000000, 0x0000000000000000},
+      {0xb5e620f480000000, 0x0000000000000000},
+      {0xe35fa931a0000000, 0x0000000000000000},
+      {0x8e1bc9bf04000000, 0x0000000000000000},
+      {0xb1a2bc2ec5000000, 0x0000000000000000},
+      {0xde0b6b3a76400000, 0x0000000000000000},
+      {0x8ac7230489e80000, 0x0000000000000000},
+      {0xad78ebc5ac620000, 0x0000000000000000},
+      {0xd8d726b7177a8000, 0x0000000000000000},
+      {0x878678326eac9000, 0x0000000000000000},
+      {0xa968163f0a57b400, 0x0000000000000000},
+      {0xd3c21bcecceda100, 0x0000000000000000},
+      {0x84595161401484a0, 0x0000000000000000},
+      {0xa56fa5b99019a5c8, 0x0000000000000000},
+      {0xcecb8f27f4200f3a, 0x0000000000000000},
+      {0x813f3978f8940984, 0x4000000000000000},
+      {0xa18f07d736b90be5, 0x5000000000000000},
+      {0xc9f2c9cd04674ede, 0xa400000000000000},
+      {0xfc6f7c4045812296, 0x4d00000000000000},
+      {0x9dc5ada82b70b59d, 0xf020000000000000},
+      {0xc5371912364ce305, 0x6c28000000000000},
+      {0xf684df56c3e01bc6, 0xc732000000000000},
+      {0x9a130b963a6c115c, 0x3c7f400000000000},
+      {0xc097ce7bc90715b3, 0x4b9f100000000000},
+      {0xf0bdc21abb48db20, 0x1e86d40000000000},
+      {0x96769950b50d88f4, 0x1314448000000000},
+      {0xbc143fa4e250eb31, 0x17d955a000000000},
+      {0xeb194f8e1ae525fd, 0x5dcfab0800000000},
+      {0x92efd1b8d0cf37be, 0x5aa1cae500000000},
+      {0xb7abc627050305ad, 0xf14a3d9e40000000},
+      {0xe596b7b0c643c719, 0x6d9ccd05d0000000},
+      {0x8f7e32ce7bea5c6f, 0xe4820023a2000000},
+      {0xb35dbf821ae4f38b, 0xdda2802c8a800000},
+      {0xe0352f62a19e306e, 0xd50b2037ad200000},
+      {0x8c213d9da502de45, 0x4526f422cc340000},
+      {0xaf298d050e4395d6, 0x9670b12b7f410000},
+      {0xdaf3f04651d47b4c, 0x3c0cdd765f114000},
+      {0x88d8762bf324cd0f, 0xa5880a69fb6ac800},
+      {0xab0e93b6efee0053, 0x8eea0d047a457a00},
+      {0xd5d238a4abe98068, 0x72a4904598d6d880},
+      {0x85a36366eb71f041, 0x47a6da2b7f864750},
+      {0xa70c3c40a64e6c51, 0x999090b65f67d924},
+      {0xd0cf4b50cfe20765, 0xfff4b4e3f741cf6d},
+      {0x82818f1281ed449f, 0xbff8f10e7a8921a5},
+      {0xa321f2d7226895c7, 0xaff72d52192b6a0e},
+      {0xcbea6f8ceb02bb39, 0x9bf4f8a69f764491},
+      {0xfee50b7025c36a08, 0x02f236d04753d5b5},
+      {0x9f4f2726179a2245, 0x01d762422c946591},
+      {0xc722f0ef9d80aad6, 0x424d3ad2b7b97ef6},
+      {0xf8ebad2b84e0d58b, 0xd2e0898765a7deb3},
+      {0x9b934c3b330c8577, 0x63cc55f49f88eb30},
+      {0xc2781f49ffcfa6d5, 0x3cbf6b71c76b25fc},
+      {0xf316271c7fc3908a, 0x8bef464e3945ef7b},
+      {0x97edd871cfda3a56, 0x97758bf0e3cbb5ad},
+      {0xbde94e8e43d0c8ec, 0x3d52eeed1cbea318},
+      {0xed63a231d4c4fb27, 0x4ca7aaa863ee4bde},
+      {0x945e455f24fb1cf8, 0x8fe8caa93e74ef6b},
+      {0xb975d6b6ee39e436, 0xb3e2fd538e122b45},
+      {0xe7d34c64a9c85d44, 0x60dbbca87196b617},
+      {0x90e40fbeea1d3a4a, 0xbc8955e946fe31ce},
+      {0xb51d13aea4a488dd, 0x6babab6398bdbe42},
+      {0xe264589a4dcdab14, 0xc696963c7eed2dd2},
+      {0x8d7eb76070a08aec, 0xfc1e1de5cf543ca3},
+      {0xb0de65388cc8ada8, 0x3b25a55f43294bcc},
+      {0xdd15fe86affad912, 0x49ef0eb713f39ebf},
+      {0x8a2dbf142dfcc7ab, 0x6e3569326c784338},
+      {0xacb92ed9397bf996, 0x49c2c37f07965405},
+      {0xd7e77a8f87daf7fb, 0xdc33745ec97be907},
+      {0x86f0ac99b4e8dafd, 0x69a028bb3ded71a4},
+      {0xa8acd7c0222311bc, 0xc40832ea0d68ce0d},
+      {0xd2d80db02aabd62b, 0xf50a3fa490c30191},
+      {0x83c7088e1aab65db, 0x792667c6da79e0fb},
+      {0xa4b8cab1a1563f52, 0x577001b891185939},
+      {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
+      {0x80b05e5ac60b6178, 0x544f8158315b05b5},
+      {0xa0dc75f1778e39d6, 0x696361ae3db1c722},
+      {0xc913936dd571c84c, 0x03bc3a19cd1e38ea},
+      {0xfb5878494ace3a5f, 0x04ab48a04065c724},
+      {0x9d174b2dcec0e47b, 0x62eb0d64283f9c77},
+      {0xc45d1df942711d9a, 0x3ba5d0bd324f8395},
+      {0xf5746577930d6500, 0xca8f44ec7ee3647a},
+      {0x9968bf6abbe85f20, 0x7e998b13cf4e1ecc},
+      {0xbfc2ef456ae276e8, 0x9e3fedd8c321a67f},
+      {0xefb3ab16c59b14a2, 0xc5cfe94ef3ea101f},
+      {0x95d04aee3b80ece5, 0xbba1f1d158724a13},
+      {0xbb445da9ca61281f, 0x2a8a6e45ae8edc98},
+      {0xea1575143cf97226, 0xf52d09d71a3293be},
+      {0x924d692ca61be758, 0x593c2626705f9c57},
+      {0xb6e0c377cfa2e12e, 0x6f8b2fb00c77836d},
+      {0xe498f455c38b997a, 0x0b6dfb9c0f956448},
+      {0x8edf98b59a373fec, 0x4724bd4189bd5ead},
+      {0xb2977ee300c50fe7, 0x58edec91ec2cb658},
+      {0xdf3d5e9bc0f653e1, 0x2f2967b66737e3ee},
+      {0x8b865b215899f46c, 0xbd79e0d20082ee75},
+      {0xae67f1e9aec07187, 0xecd8590680a3aa12},
+      {0xda01ee641a708de9, 0xe80e6f4820cc9496},
+      {0x884134fe908658b2, 0x3109058d147fdcde},
+      {0xaa51823e34a7eede, 0xbd4b46f0599fd416},
+      {0xd4e5e2cdc1d1ea96, 0x6c9e18ac7007c91b},
+      {0x850fadc09923329e, 0x03e2cf6bc604ddb1},
+      {0xa6539930bf6bff45, 0x84db8346b786151d},
+      {0xcfe87f7cef46ff16, 0xe612641865679a64},
+      {0x81f14fae158c5f6e, 0x4fcb7e8f3f60c07f},
+      {0xa26da3999aef7749, 0xe3be5e330f38f09e},
+      {0xcb090c8001ab551c, 0x5cadf5bfd3072cc6},
+      {0xfdcb4fa002162a63, 0x73d9732fc7c8f7f7},
+      {0x9e9f11c4014dda7e, 0x2867e7fddcdd9afb},
+      {0xc646d63501a1511d, 0xb281e1fd541501b9},
+      {0xf7d88bc24209a565, 0x1f225a7ca91a4227},
+      {0x9ae757596946075f, 0x3375788de9b06959},
+      {0xc1a12d2fc3978937, 0x0052d6b1641c83af},
+      {0xf209787bb47d6b84, 0xc0678c5dbd23a49b},
+      {0x9745eb4d50ce6332, 0xf840b7ba963646e1},
+      {0xbd176620a501fbff, 0xb650e5a93bc3d899},
+      {0xec5d3fa8ce427aff, 0xa3e51f138ab4cebf},
+      {0x93ba47c980e98cdf, 0xc66f336c36b10138},
+      {0xb8a8d9bbe123f017, 0xb80b0047445d4185},
+      {0xe6d3102ad96cec1d, 0xa60dc059157491e6},
+      {0x9043ea1ac7e41392, 0x87c89837ad68db30},
+      {0xb454e4a179dd1877, 0x29babe4598c311fc},
+      {0xe16a1dc9d8545e94, 0xf4296dd6fef3d67b},
+      {0x8ce2529e2734bb1d, 0x1899e4a65f58660d},
+      {0xb01ae745b101e9e4, 0x5ec05dcff72e7f90},
+      {0xdc21a1171d42645d, 0x76707543f4fa1f74},
+      {0x899504ae72497eba, 0x6a06494a791c53a9},
+      {0xabfa45da0edbde69, 0x0487db9d17636893},
+      {0xd6f8d7509292d603, 0x45a9d2845d3c42b7},
+      {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
+      {0xa7f26836f282b732, 0x8e6cac7768d7141f},
+      {0xd1ef0244af2364ff, 0x3207d795430cd927},
+      {0x8335616aed761f1f, 0x7f44e6bd49e807b9},
+      {0xa402b9c5a8d3a6e7, 0x5f16206c9c6209a7},
+      {0xcd036837130890a1, 0x36dba887c37a8c10},
+      {0x802221226be55a64, 0xc2494954da2c978a},
+      {0xa02aa96b06deb0fd, 0xf2db9baa10b7bd6d},
+      {0xc83553c5c8965d3d, 0x6f92829494e5acc8},
+      {0xfa42a8b73abbf48c, 0xcb772339ba1f17fa},
+      {0x9c69a97284b578d7, 0xff2a760414536efc},
+      {0xc38413cf25e2d70d, 0xfef5138519684abb},
+      {0xf46518c2ef5b8cd1, 0x7eb258665fc25d6a},
+      {0x98bf2f79d5993802, 0xef2f773ffbd97a62},
+      {0xbeeefb584aff8603, 0xaafb550ffacfd8fb},
+      {0xeeaaba2e5dbf6784, 0x95ba2a53f983cf39},
+      {0x952ab45cfa97a0b2, 0xdd945a747bf26184},
+      {0xba756174393d88df, 0x94f971119aeef9e5},
+      {0xe912b9d1478ceb17, 0x7a37cd5601aab85e},
+      {0x91abb422ccb812ee, 0xac62e055c10ab33b},
+      {0xb616a12b7fe617aa, 0x577b986b314d600a},
+      {0xe39c49765fdf9d94, 0xed5a7e85fda0b80c},
+      {0x8e41ade9fbebc27d, 0x14588f13be847308},
+      {0xb1d219647ae6b31c, 0x596eb2d8ae258fc9},
+      {0xde469fbd99a05fe3, 0x6fca5f8ed9aef3bc},
+      {0x8aec23d680043bee, 0x25de7bb9480d5855},
+      {0xada72ccc20054ae9, 0xaf561aa79a10ae6b},
+      {0xd910f7ff28069da4, 0x1b2ba1518094da05},
+      {0x87aa9aff79042286, 0x90fb44d2f05d0843},
+      {0xa99541bf57452b28, 0x353a1607ac744a54},
+      {0xd3fa922f2d1675f2, 0x42889b8997915ce9},
+      {0x847c9b5d7c2e09b7, 0x69956135febada12},
+      {0xa59bc234db398c25, 0x43fab9837e699096},
+      {0xcf02b2c21207ef2e, 0x94f967e45e03f4bc},
+      {0x8161afb94b44f57d, 0x1d1be0eebac278f6},
+      {0xa1ba1ba79e1632dc, 0x6462d92a69731733},
+      {0xca28a291859bbf93, 0x7d7b8f7503cfdcff},
+      {0xfcb2cb35e702af78, 0x5cda735244c3d43f},
+      {0x9defbf01b061adab, 0x3a0888136afa64a8},
+      {0xc56baec21c7a1916, 0x088aaa1845b8fdd1},
+      {0xf6c69a72a3989f5b, 0x8aad549e57273d46},
+      {0x9a3c2087a63f6399, 0x36ac54e2f678864c},
+      {0xc0cb28a98fcf3c7f, 0x84576a1bb416a7de},
+      {0xf0fdf2d3f3c30b9f, 0x656d44a2a11c51d6},
+      {0x969eb7c47859e743, 0x9f644ae5a4b1b326},
+      {0xbc4665b596706114, 0x873d5d9f0dde1fef},
+      {0xeb57ff22fc0c7959, 0xa90cb506d155a7eb},
+      {0x9316ff75dd87cbd8, 0x09a7f12442d588f3},
+      {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30},
+      {0xe5d3ef282a242e81, 0x8f1668c8a86da5fb},
+      {0x8fa475791a569d10, 0xf96e017d694487bd},
+      {0xb38d92d760ec4455, 0x37c981dcc395a9ad},
+      {0xe070f78d3927556a, 0x85bbe253f47b1418},
+      {0x8c469ab843b89562, 0x93956d7478ccec8f},
+      {0xaf58416654a6babb, 0x387ac8d1970027b3},
+      {0xdb2e51bfe9d0696a, 0x06997b05fcc0319f},
+      {0x88fcf317f22241e2, 0x441fece3bdf81f04},
+      {0xab3c2fddeeaad25a, 0xd527e81cad7626c4},
+      {0xd60b3bd56a5586f1, 0x8a71e223d8d3b075},
+      {0x85c7056562757456, 0xf6872d5667844e4a},
+      {0xa738c6bebb12d16c, 0xb428f8ac016561dc},
+      {0xd106f86e69d785c7, 0xe13336d701beba53},
+      {0x82a45b450226b39c, 0xecc0024661173474},
+      {0xa34d721642b06084, 0x27f002d7f95d0191},
+      {0xcc20ce9bd35c78a5, 0x31ec038df7b441f5},
+      {0xff290242c83396ce, 0x7e67047175a15272},
+      {0x9f79a169bd203e41, 0x0f0062c6e984d387},
+      {0xc75809c42c684dd1, 0x52c07b78a3e60869},
+      {0xf92e0c3537826145, 0xa7709a56ccdf8a83},
+      {0x9bbcc7a142b17ccb, 0x88a66076400bb692},
+      {0xc2abf989935ddbfe, 0x6acff893d00ea436},
+      {0xf356f7ebf83552fe, 0x0583f6b8c4124d44},
+      {0x98165af37b2153de, 0xc3727a337a8b704b},
+      {0xbe1bf1b059e9a8d6, 0x744f18c0592e4c5d},
+      {0xeda2ee1c7064130c, 0x1162def06f79df74},
+      {0x9485d4d1c63e8be7, 0x8addcb5645ac2ba9},
+      {0xb9a74a0637ce2ee1, 0x6d953e2bd7173693},
+      {0xe8111c87c5c1ba99, 0xc8fa8db6ccdd0438},
+      {0x910ab1d4db9914a0, 0x1d9c9892400a22a3},
+      {0xb54d5e4a127f59c8, 0x2503beb6d00cab4c},
+      {0xe2a0b5dc971f303a, 0x2e44ae64840fd61e},
+      {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
+      {0xb10d8e1456105dad, 0x7425a83e872c5f48},
+      {0xdd50f1996b947518, 0xd12f124e28f7771a},
+      {0x8a5296ffe33cc92f, 0x82bd6b70d99aaa70},
+      {0xace73cbfdc0bfb7b, 0x636cc64d1001550c},
+      {0xd8210befd30efa5a, 0x3c47f7e05401aa4f},
+      {0x8714a775e3e95c78, 0x65acfaec34810a72},
+      {0xa8d9d1535ce3b396, 0x7f1839a741a14d0e},
+      {0xd31045a8341ca07c, 0x1ede48111209a051},
+      {0x83ea2b892091e44d, 0x934aed0aab460433},
+      {0xa4e4b66b68b65d60, 0xf81da84d56178540},
+      {0xce1de40642e3f4b9, 0x36251260ab9d668f},
+      {0x80d2ae83e9ce78f3, 0xc1d72b7c6b42601a},
+      {0xa1075a24e4421730, 0xb24cf65b8612f820},
+      {0xc94930ae1d529cfc, 0xdee033f26797b628},
+      {0xfb9b7cd9a4a7443c, 0x169840ef017da3b2},
+      {0x9d412e0806e88aa5, 0x8e1f289560ee864f},
+      {0xc491798a08a2ad4e, 0xf1a6f2bab92a27e3},
+      {0xf5b5d7ec8acb58a2, 0xae10af696774b1dc},
+      {0x9991a6f3d6bf1765, 0xacca6da1e0a8ef2a},
+      {0xbff610b0cc6edd3f, 0x17fd090a58d32af4},
+      {0xeff394dcff8a948e, 0xddfc4b4cef07f5b1},
+      {0x95f83d0a1fb69cd9, 0x4abdaf101564f98f},
+      {0xbb764c4ca7a4440f, 0x9d6d1ad41abe37f2},
+      {0xea53df5fd18d5513, 0x84c86189216dc5ee},
+      {0x92746b9be2f8552c, 0x32fd3cf5b4e49bb5},
+      {0xb7118682dbb66a77, 0x3fbc8c33221dc2a2},
+      {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
+      {0x8f05b1163ba6832d, 0x29cb4d87f2a7400f},
+      {0xb2c71d5bca9023f8, 0x743e20e9ef511013},
+      {0xdf78e4b2bd342cf6, 0x914da9246b255417},
+      {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f},
+      {0xae9672aba3d0c320, 0xa184ac2473b529b2},
+      {0xda3c0f568cc4f3e8, 0xc9e5d72d90a2741f},
+      {0x8865899617fb1871, 0x7e2fa67c7a658893},
+      {0xaa7eebfb9df9de8d, 0xddbb901b98feeab8},
+      {0xd51ea6fa85785631, 0x552a74227f3ea566},
+      {0x8533285c936b35de, 0xd53a88958f872760},
+      {0xa67ff273b8460356, 0x8a892abaf368f138},
+      {0xd01fef10a657842c, 0x2d2b7569b0432d86},
+      {0x8213f56a67f6b29b, 0x9c3b29620e29fc74},
+      {0xa298f2c501f45f42, 0x8349f3ba91b47b90},
+      {0xcb3f2f7642717713, 0x241c70a936219a74},
+      {0xfe0efb53d30dd4d7, 0xed238cd383aa0111},
+      {0x9ec95d1463e8a506, 0xf4363804324a40ab},
+      {0xc67bb4597ce2ce48, 0xb143c6053edcd0d6},
+      {0xf81aa16fdc1b81da, 0xdd94b7868e94050b},
+      {0x9b10a4e5e9913128, 0xca7cf2b4191c8327},
+      {0xc1d4ce1f63f57d72, 0xfd1c2f611f63a3f1},
+      {0xf24a01a73cf2dccf, 0xbc633b39673c8ced},
+      {0x976e41088617ca01, 0xd5be0503e085d814},
+      {0xbd49d14aa79dbc82, 0x4b2d8644d8a74e19},
+      {0xec9c459d51852ba2, 0xddf8e7d60ed1219f},
+      {0x93e1ab8252f33b45, 0xcabb90e5c942b504},
+      {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
+      {0xe7109bfba19c0c9d, 0x0cc512670a783ad5},
+      {0x906a617d450187e2, 0x27fb2b80668b24c6},
+      {0xb484f9dc9641e9da, 0xb1f9f660802dedf7},
+      {0xe1a63853bbd26451, 0x5e7873f8a0396974},
+      {0x8d07e33455637eb2, 0xdb0b487b6423e1e9},
+      {0xb049dc016abc5e5f, 0x91ce1a9a3d2cda63},
+      {0xdc5c5301c56b75f7, 0x7641a140cc7810fc},
+      {0x89b9b3e11b6329ba, 0xa9e904c87fcb0a9e},
+      {0xac2820d9623bf429, 0x546345fa9fbdcd45},
+      {0xd732290fbacaf133, 0xa97c177947ad4096},
+      {0x867f59a9d4bed6c0, 0x49ed8eabcccc485e},
+      {0xa81f301449ee8c70, 0x5c68f256bfff5a75},
+      {0xd226fc195c6a2f8c, 0x73832eec6fff3112},
+      {0x83585d8fd9c25db7, 0xc831fd53c5ff7eac},
+      {0xa42e74f3d032f525, 0xba3e7ca8b77f5e56},
+      {0xcd3a1230c43fb26f, 0x28ce1bd2e55f35ec},
+      {0x80444b5e7aa7cf85, 0x7980d163cf5b81b4},
+      {0xa0555e361951c366, 0xd7e105bcc3326220},
+      {0xc86ab5c39fa63440, 0x8dd9472bf3fefaa8},
+      {0xfa856334878fc150, 0xb14f98f6f0feb952},
+      {0x9c935e00d4b9d8d2, 0x6ed1bf9a569f33d4},
+      {0xc3b8358109e84f07, 0x0a862f80ec4700c9},
+      {0xf4a642e14c6262c8, 0xcd27bb612758c0fb},
+      {0x98e7e9cccfbd7dbd, 0x8038d51cb897789d},
+      {0xbf21e44003acdd2c, 0xe0470a63e6bd56c4},
+      {0xeeea5d5004981478, 0x1858ccfce06cac75},
+      {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
+      {0xbaa718e68396cffd, 0xd30560258f54e6bb},
+      {0xe950df20247c83fd, 0x47c6b82ef32a206a},
+      {0x91d28b7416cdd27e, 0x4cdc331d57fa5442},
+      {0xb6472e511c81471d, 0xe0133fe4adf8e953},
+      {0xe3d8f9e563a198e5, 0x58180fddd97723a7},
+      {0x8e679c2f5e44ff8f, 0x570f09eaa7ea7649},
+      {0xb201833b35d63f73, 0x2cd2cc6551e513db},
+      {0xde81e40a034bcf4f, 0xf8077f7ea65e58d2},
+      {0x8b112e86420f6191, 0xfb04afaf27faf783},
+      {0xadd57a27d29339f6, 0x79c5db9af1f9b564},
+      {0xd94ad8b1c7380874, 0x18375281ae7822bd},
+      {0x87cec76f1c830548, 0x8f2293910d0b15b6},
+      {0xa9c2794ae3a3c69a, 0xb2eb3875504ddb23},
+      {0xd433179d9c8cb841, 0x5fa60692a46151ec},
+      {0x849feec281d7f328, 0xdbc7c41ba6bcd334},
+      {0xa5c7ea73224deff3, 0x12b9b522906c0801},
+      {0xcf39e50feae16bef, 0xd768226b34870a01},
+      {0x81842f29f2cce375, 0xe6a1158300d46641},
+      {0xa1e53af46f801c53, 0x60495ae3c1097fd1},
+      {0xca5e89b18b602368, 0x385bb19cb14bdfc5},
+      {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6},
+      {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2},
+      {0xc5a05277621be293, 0xc7098b7305241886},
+      {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8},
+      {0x9a65406d44a5c903, 0x737f74f1dc043329},
+      {0xc0fe908895cf3b44, 0x505f522e53053ff3},
+      {0xf13e34aabb430a15, 0x647726b9e7c68ff0},
+      {0x96c6e0eab509e64d, 0x5eca783430dc19f6},
+      {0xbc789925624c5fe0, 0xb67d16413d132073},
+      {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890},
+      {0x933e37a534cbaae7, 0x8e91b962f7b6f15a},
+      {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1},
+      {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d},
+      {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2},
+      {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e},
+      {0xe0accfa875af45a7, 0x93eb1b80a33b8606},
+      {0x8c6c01c9498d8b88, 0xbc72f130660533c4},
+      {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
+      {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2},
+#else
+      {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
+      {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
+      {0xa6b34ad8c9dfc06f, 0xf42faa48c0ea481f},
+      {0x86a8d39ef77164bc, 0xae5dff9c02033198},
+      {0xd98ddaee19068c76, 0x3badd624dd9b0958},
+      {0xafbd2350644eeacf, 0xe5d1929ef90898fb},
+      {0x8df5efabc5979c8f, 0xca8d3ffa1ef463c2},
+      {0xe55990879ddcaabd, 0xcc420a6a101d0516},
+      {0xb94470938fa89bce, 0xf808e40e8d5b3e6a},
+      {0x95a8637627989aad, 0xdde7001379a44aa9},
+      {0xf1c90080baf72cb1, 0x5324c68b12dd6339},
+      {0xc350000000000000, 0x0000000000000000},
+      {0x9dc5ada82b70b59d, 0xf020000000000000},
+      {0xfee50b7025c36a08, 0x02f236d04753d5b5},
+      {0xcde6fd5e09abcf26, 0xed4c0226b55e6f87},
+      {0xa6539930bf6bff45, 0x84db8346b786151d},
+      {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3},
+      {0xd910f7ff28069da4, 0x1b2ba1518094da05},
+      {0xaf58416654a6babb, 0x387ac8d1970027b3},
+      {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
+      {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
+      {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
+      {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
+      {0xf13e34aabb430a15, 0x647726b9e7c68ff0}
+#endif
+    };
+
+#if FMT_USE_FULL_CACHE_DRAGONBOX
+    return pow10_significands[k - float_info<double>::min_k];
+#else
+    static constexpr const uint64_t powers_of_5_64[] = {
+        0x0000000000000001, 0x0000000000000005, 0x0000000000000019,
+        0x000000000000007d, 0x0000000000000271, 0x0000000000000c35,
+        0x0000000000003d09, 0x000000000001312d, 0x000000000005f5e1,
+        0x00000000001dcd65, 0x00000000009502f9, 0x0000000002e90edd,
+        0x000000000e8d4a51, 0x0000000048c27395, 0x000000016bcc41e9,
+        0x000000071afd498d, 0x0000002386f26fc1, 0x000000b1a2bc2ec5,
+        0x000003782dace9d9, 0x00001158e460913d, 0x000056bc75e2d631,
+        0x0001b1ae4d6e2ef5, 0x000878678326eac9, 0x002a5a058fc295ed,
+        0x00d3c21bcecceda1, 0x0422ca8b0a00a425, 0x14adf4b7320334b9};
+
+    static const int compression_ratio = 27;
+
+    // Compute base index.
+    int cache_index = (k - float_info<double>::min_k) / compression_ratio;
+    int kb = cache_index * compression_ratio + float_info<double>::min_k;
+    int offset = k - kb;
+
+    // Get base cache.
+    uint128_fallback base_cache = pow10_significands[cache_index];
+    if (offset == 0) return base_cache;
+
+    // Compute the required amount of bit-shift.
+    int alpha = floor_log2_pow10(kb + offset) - floor_log2_pow10(kb) - offset;
+    FMT_ASSERT(alpha > 0 && alpha < 64, "shifting error detected");
+
+    // Try to recover the real cache.
+    uint64_t pow5 = powers_of_5_64[offset];
+    uint128_fallback recovered_cache = umul128(base_cache.high(), pow5);
+    uint128_fallback middle_low = umul128(base_cache.low(), pow5);
+
+    recovered_cache += middle_low.high();
+
+    uint64_t high_to_middle = recovered_cache.high() << (64 - alpha);
+    uint64_t middle_to_low = recovered_cache.low() << (64 - alpha);
+
+    recovered_cache =
+        uint128_fallback{(recovered_cache.low() >> alpha) | high_to_middle,
+                         ((middle_low.low() >> alpha) | middle_to_low)};
+    FMT_ASSERT(recovered_cache.low() + 1 != 0, "");
+    return {recovered_cache.high(), recovered_cache.low() + 1};
+#endif
+  }
+
+  struct compute_mul_result {
+    carrier_uint result;
+    bool is_integer;
+  };
+  struct compute_mul_parity_result {
+    bool parity;
+    bool is_integer;
+  };
+
+  static auto compute_mul(carrier_uint u,
+                          const cache_entry_type& cache) noexcept
+      -> compute_mul_result {
+    auto r = umul192_upper128(u, cache);
+    return {r.high(), r.low() == 0};
+  }
+
+  static auto compute_delta(cache_entry_type const& cache, int beta) noexcept
+      -> uint32_t {
+    return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta));
+  }
+
+  static auto compute_mul_parity(carrier_uint two_f,
+                                 const cache_entry_type& cache,
+                                 int beta) noexcept
+      -> compute_mul_parity_result {
+    FMT_ASSERT(beta >= 1, "");
+    FMT_ASSERT(beta < 64, "");
+
+    auto r = umul192_lower128(two_f, cache);
+    return {((r.high() >> (64 - beta)) & 1) != 0,
+            ((r.high() << beta) | (r.low() >> (64 - beta))) == 0};
+  }
+
+  static auto compute_left_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
+    return (cache.high() -
+            (cache.high() >> (num_significand_bits<double>() + 2))) >>
+           (64 - num_significand_bits<double>() - 1 - beta);
+  }
+
+  static auto compute_right_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
+    return (cache.high() +
+            (cache.high() >> (num_significand_bits<double>() + 1))) >>
+           (64 - num_significand_bits<double>() - 1 - beta);
+  }
+
+  static auto compute_round_up_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
+    return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) +
+            1) /
+           2;
+  }
+};
+
+FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback {
+  return cache_accessor<double>::get_cached_power(k);
+}
+
+// Various integer checks
+template <typename T>
+auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool {
+  const int case_shorter_interval_left_endpoint_lower_threshold = 2;
+  const int case_shorter_interval_left_endpoint_upper_threshold = 3;
+  return exponent >= case_shorter_interval_left_endpoint_lower_threshold &&
+         exponent <= case_shorter_interval_left_endpoint_upper_threshold;
+}
+
+// Remove trailing zeros from n and return the number of zeros removed (float)
+FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept {
+  FMT_ASSERT(n != 0, "");
+  // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1.
+  constexpr uint32_t mod_inv_5 = 0xcccccccd;
+  constexpr uint32_t mod_inv_25 = 0xc28f5c29;  // = mod_inv_5 * mod_inv_5
+
+  while (true) {
+    auto q = rotr(n * mod_inv_25, 2);
+    if (q > max_value<uint32_t>() / 100) break;
+    n = q;
+    s += 2;
+  }
+  auto q = rotr(n * mod_inv_5, 1);
+  if (q <= max_value<uint32_t>() / 10) {
+    n = q;
+    s |= 1;
+  }
+  return s;
+}
+
+// Removes trailing zeros and returns the number of zeros removed (double)
+FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
+  FMT_ASSERT(n != 0, "");
+
+  // This magic number is ceil(2^90 / 10^8).
+  constexpr uint64_t magic_number = 12379400392853802749ull;
+  auto nm = umul128(n, magic_number);
+
+  // Is n is divisible by 10^8?
+  if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) {
+    // If yes, work with the quotient...
+    auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64));
+    // ... and use the 32 bit variant of the function
+    int s = remove_trailing_zeros(n32, 8);
+    n = n32;
+    return s;
+  }
+
+  // If n is not divisible by 10^8, work with n itself.
+  constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd;
+  constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29;  // mod_inv_5 * mod_inv_5
+
+  int s = 0;
+  while (true) {
+    auto q = rotr(n * mod_inv_25, 2);
+    if (q > max_value<uint64_t>() / 100) break;
+    n = q;
+    s += 2;
+  }
+  auto q = rotr(n * mod_inv_5, 1);
+  if (q <= max_value<uint64_t>() / 10) {
+    n = q;
+    s |= 1;
+  }
+
+  return s;
+}
+
+// The main algorithm for shorter interval case
+template <typename T>
+FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
+  decimal_fp<T> ret_value;
+  // Compute k and beta
+  const int minus_k = floor_log10_pow2_minus_log10_4_over_3(exponent);
+  const int beta = exponent + floor_log2_pow10(-minus_k);
+
+  // Compute xi and zi
+  using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
+  const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
+
+  auto xi = cache_accessor<T>::compute_left_endpoint_for_shorter_interval_case(
+      cache, beta);
+  auto zi = cache_accessor<T>::compute_right_endpoint_for_shorter_interval_case(
+      cache, beta);
+
+  // If the left endpoint is not an integer, increase it
+  if (!is_left_endpoint_integer_shorter_interval<T>(exponent)) ++xi;
+
+  // Try bigger divisor
+  ret_value.significand = zi / 10;
+
+  // If succeed, remove trailing zeros if necessary and return
+  if (ret_value.significand * 10 >= xi) {
+    ret_value.exponent = minus_k + 1;
+    ret_value.exponent += remove_trailing_zeros(ret_value.significand);
+    return ret_value;
+  }
+
+  // Otherwise, compute the round-up of y
+  ret_value.significand =
+      cache_accessor<T>::compute_round_up_for_shorter_interval_case(cache,
+                                                                    beta);
+  ret_value.exponent = minus_k;
+
+  // When tie occurs, choose one of them according to the rule
+  if (exponent >= float_info<T>::shorter_interval_tie_lower_threshold &&
+      exponent <= float_info<T>::shorter_interval_tie_upper_threshold) {
+    ret_value.significand = ret_value.significand % 2 == 0
+                                ? ret_value.significand
+                                : ret_value.significand - 1;
+  } else if (ret_value.significand < xi) {
+    ++ret_value.significand;
+  }
+  return ret_value;
+}
+
+template <typename T> auto to_decimal(T x) noexcept -> decimal_fp<T> {
+  // Step 1: integer promotion & Schubfach multiplier calculation.
+
+  using carrier_uint = typename float_info<T>::carrier_uint;
+  using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
+  auto br = bit_cast<carrier_uint>(x);
+
+  // Extract significand bits and exponent bits.
+  const carrier_uint significand_mask =
+      (static_cast<carrier_uint>(1) << num_significand_bits<T>()) - 1;
+  carrier_uint significand = (br & significand_mask);
+  int exponent =
+      static_cast<int>((br & exponent_mask<T>()) >> num_significand_bits<T>());
+
+  if (exponent != 0) {  // Check if normal.
+    exponent -= exponent_bias<T>() + num_significand_bits<T>();
+
+    // Shorter interval case; proceed like Schubfach.
+    // In fact, when exponent == 1 and significand == 0, the interval is
+    // regular. However, it can be shown that the end-results are anyway same.
+    if (significand == 0) return shorter_interval_case<T>(exponent);
+
+    significand |= (static_cast<carrier_uint>(1) << num_significand_bits<T>());
+  } else {
+    // Subnormal case; the interval is always regular.
+    if (significand == 0) return {0, 0};
+    exponent =
+        std::numeric_limits<T>::min_exponent - num_significand_bits<T>() - 1;
+  }
+
+  const bool include_left_endpoint = (significand % 2 == 0);
+  const bool include_right_endpoint = include_left_endpoint;
+
+  // Compute k and beta.
+  const int minus_k = floor_log10_pow2(exponent) - float_info<T>::kappa;
+  const cache_entry_type cache = cache_accessor<T>::get_cached_power(-minus_k);
+  const int beta = exponent + floor_log2_pow10(-minus_k);
+
+  // Compute zi and deltai.
+  // 10^kappa <= deltai < 10^(kappa + 1)
+  const uint32_t deltai = cache_accessor<T>::compute_delta(cache, beta);
+  const carrier_uint two_fc = significand << 1;
+
+  // For the case of binary32, the result of integer check is not correct for
+  // 29711844 * 2^-82
+  // = 6.1442653300000000008655037797566933477355632930994033813476... * 10^-18
+  // and 29711844 * 2^-81
+  // = 1.2288530660000000001731007559513386695471126586198806762695... * 10^-17,
+  // and they are the unique counterexamples. However, since 29711844 is even,
+  // this does not cause any problem for the endpoints calculations; it can only
+  // cause a problem when we need to perform integer check for the center.
+  // Fortunately, with these inputs, that branch is never executed, so we are
+  // fine.
+  const typename cache_accessor<T>::compute_mul_result z_mul =
+      cache_accessor<T>::compute_mul((two_fc | 1) << beta, cache);
+
+  // Step 2: Try larger divisor; remove trailing zeros if necessary.
+
+  // Using an upper bound on zi, we might be able to optimize the division
+  // better than the compiler; we are computing zi / big_divisor here.
+  decimal_fp<T> ret_value;
+  ret_value.significand = divide_by_10_to_kappa_plus_1(z_mul.result);
+  uint32_t r = static_cast<uint32_t>(z_mul.result - float_info<T>::big_divisor *
+                                                        ret_value.significand);
+
+  if (r < deltai) {
+    // Exclude the right endpoint if necessary.
+    if (r == 0 && (z_mul.is_integer & !include_right_endpoint)) {
+      --ret_value.significand;
+      r = float_info<T>::big_divisor;
+      goto small_divisor_case_label;
+    }
+  } else if (r > deltai) {
+    goto small_divisor_case_label;
+  } else {
+    // r == deltai; compare fractional parts.
+    const typename cache_accessor<T>::compute_mul_parity_result x_mul =
+        cache_accessor<T>::compute_mul_parity(two_fc - 1, cache, beta);
+
+    if (!(x_mul.parity | (x_mul.is_integer & include_left_endpoint)))
+      goto small_divisor_case_label;
+  }
+  ret_value.exponent = minus_k + float_info<T>::kappa + 1;
+
+  // We may need to remove trailing zeros.
+  ret_value.exponent += remove_trailing_zeros(ret_value.significand);
+  return ret_value;
+
+  // Step 3: Find the significand with the smaller divisor.
+
+small_divisor_case_label:
+  ret_value.significand *= 10;
+  ret_value.exponent = minus_k + float_info<T>::kappa;
+
+  uint32_t dist = r - (deltai / 2) + (float_info<T>::small_divisor / 2);
+  const bool approx_y_parity =
+      ((dist ^ (float_info<T>::small_divisor / 2)) & 1) != 0;
+
+  // Is dist divisible by 10^kappa?
+  const bool divisible_by_small_divisor =
+      check_divisibility_and_divide_by_pow10<float_info<T>::kappa>(dist);
+
+  // Add dist / 10^kappa to the significand.
+  ret_value.significand += dist;
+
+  if (!divisible_by_small_divisor) return ret_value;
+
+  // Check z^(f) >= epsilon^(f).
+  // We have either yi == zi - epsiloni or yi == (zi - epsiloni) - 1,
+  // where yi == zi - epsiloni if and only if z^(f) >= epsilon^(f).
+  // Since there are only 2 possibilities, we only need to care about the
+  // parity. Also, zi and r should have the same parity since the divisor
+  // is an even number.
+  const auto y_mul = cache_accessor<T>::compute_mul_parity(two_fc, cache, beta);
+
+  // If z^(f) >= epsilon^(f), we might have a tie when z^(f) == epsilon^(f),
+  // or equivalently, when y is an integer.
+  if (y_mul.parity != approx_y_parity)
+    --ret_value.significand;
+  else if (y_mul.is_integer & (ret_value.significand % 2 != 0))
+    --ret_value.significand;
+  return ret_value;
+}
+}  // namespace dragonbox
+}  // namespace detail
+
+template <> struct formatter<detail::bigint> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx)
+      -> format_parse_context::iterator {
+    return ctx.begin();
+  }
+
+  auto format(const detail::bigint& n, format_context& ctx) const
+      -> format_context::iterator {
+    auto out = ctx.out();
+    bool first = true;
+    for (auto i = n.bigits_.size(); i > 0; --i) {
+      auto value = n.bigits_[i - 1u];
+      if (first) {
+        out = fmt::format_to(out, FMT_STRING("{:x}"), value);
+        first = false;
+        continue;
+      }
+      out = fmt::format_to(out, FMT_STRING("{:08x}"), value);
+    }
+    if (n.exp_ > 0)
+      out = fmt::format_to(out, FMT_STRING("p{}"),
+                           n.exp_ * detail::bigint::bigit_bits);
+    return out;
+  }
+};
+
+FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) {
+  for_each_codepoint(s, [this](uint32_t cp, string_view) {
+    if (cp == invalid_code_point) FMT_THROW(std::runtime_error("invalid utf8"));
+    if (cp <= 0xFFFF) {
+      buffer_.push_back(static_cast<wchar_t>(cp));
+    } else {
+      cp -= 0x10000;
+      buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10)));
+      buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF)));
+    }
+    return true;
+  });
+  buffer_.push_back(0);
+}
+
+FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code,
+                                  const char* message) noexcept {
+  FMT_TRY {
+    auto ec = std::error_code(error_code, std::generic_category());
+    write(std::back_inserter(out), std::system_error(ec, message).what());
+    return;
+  }
+  FMT_CATCH(...) {}
+  format_error_code(out, error_code, message);
+}
+
+FMT_FUNC void report_system_error(int error_code,
+                                  const char* message) noexcept {
+  report_error(format_system_error, error_code, message);
+}
+
+FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {
+  // Don't optimize the "{}" case to keep the binary size small and because it
+  // can be better optimized in fmt::format anyway.
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, fmt, args);
+  return to_string(buffer);
+}
+
+namespace detail {
+#if !defined(_WIN32) || defined(FMT_WINDOWS_NO_WCHAR)
+FMT_FUNC auto write_console(int, string_view) -> bool { return false; }
+FMT_FUNC auto write_console(std::FILE*, string_view) -> bool { return false; }
+#else
+using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
+extern "C" __declspec(dllimport) int __stdcall WriteConsoleW(  //
+    void*, const void*, dword, dword*, void*);
+
+FMT_FUNC bool write_console(int fd, string_view text) {
+  auto u16 = utf8_to_utf16(text);
+  return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
+                       static_cast<dword>(u16.size()), nullptr, nullptr) != 0;
+}
+
+FMT_FUNC auto write_console(std::FILE* f, string_view text) -> bool {
+  return write_console(_fileno(f), text);
+}
+#endif
+
+#ifdef _WIN32
+// Print assuming legacy (non-Unicode) encoding.
+FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, fmt, args);
+  fwrite_fully(buffer.data(), buffer.size(), f);
+}
+#endif
+
+FMT_FUNC void print(std::FILE* f, string_view text) {
+#ifdef _WIN32
+  int fd = _fileno(f);
+  if (_isatty(fd)) {
+    std::fflush(f);
+    if (write_console(fd, text)) return;
+  }
+#endif
+  fwrite_fully(text.data(), text.size(), f);
+}
+}  // namespace detail
+
+FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) {
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, fmt, args);
+  detail::print(f, {buffer.data(), buffer.size()});
+}
+
+FMT_FUNC void vprint(string_view fmt, format_args args) {
+  vprint(stdout, fmt, args);
+}
+
+namespace detail {
+
+struct singleton {
+  unsigned char upper;
+  unsigned char lower_count;
+};
+
+inline auto is_printable(uint16_t x, const singleton* singletons,
+                         size_t singletons_size,
+                         const unsigned char* singleton_lowers,
+                         const unsigned char* normal, size_t normal_size)
+    -> bool {
+  auto upper = x >> 8;
+  auto lower_start = 0;
+  for (size_t i = 0; i < singletons_size; ++i) {
+    auto s = singletons[i];
+    auto lower_end = lower_start + s.lower_count;
+    if (upper < s.upper) break;
+    if (upper == s.upper) {
+      for (auto j = lower_start; j < lower_end; ++j) {
+        if (singleton_lowers[j] == (x & 0xff)) return false;
+      }
+    }
+    lower_start = lower_end;
+  }
+
+  auto xsigned = static_cast<int>(x);
+  auto current = true;
+  for (size_t i = 0; i < normal_size; ++i) {
+    auto v = static_cast<int>(normal[i]);
+    auto len = (v & 0x80) != 0 ? (v & 0x7f) << 8 | normal[++i] : v;
+    xsigned -= len;
+    if (xsigned < 0) break;
+    current = !current;
+  }
+  return current;
+}
+
+// This code is generated by support/printable.py.
+FMT_FUNC auto is_printable(uint32_t cp) -> bool {
+  static constexpr singleton singletons0[] = {
+      {0x00, 1},  {0x03, 5},  {0x05, 6},  {0x06, 3},  {0x07, 6},  {0x08, 8},
+      {0x09, 17}, {0x0a, 28}, {0x0b, 25}, {0x0c, 20}, {0x0d, 16}, {0x0e, 13},
+      {0x0f, 4},  {0x10, 3},  {0x12, 18}, {0x13, 9},  {0x16, 1},  {0x17, 5},
+      {0x18, 2},  {0x19, 3},  {0x1a, 7},  {0x1c, 2},  {0x1d, 1},  {0x1f, 22},
+      {0x20, 3},  {0x2b, 3},  {0x2c, 2},  {0x2d, 11}, {0x2e, 1},  {0x30, 3},
+      {0x31, 2},  {0x32, 1},  {0xa7, 2},  {0xa9, 2},  {0xaa, 4},  {0xab, 8},
+      {0xfa, 2},  {0xfb, 5},  {0xfd, 4},  {0xfe, 3},  {0xff, 9},
+  };
+  static constexpr unsigned char singletons0_lower[] = {
+      0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57, 0x58, 0x8b, 0x8c, 0x90,
+      0x1c, 0x1d, 0xdd, 0x0e, 0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f,
+      0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e, 0x91, 0x92, 0xa9, 0xb1,
+      0xba, 0xbb, 0xc5, 0xc6, 0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04,
+      0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b, 0x3d, 0x49, 0x4a, 0x5d,
+      0x84, 0x8e, 0x92, 0xa9, 0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf,
+      0xe4, 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,
+      0x3b, 0x45, 0x46, 0x49, 0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d,
+      0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49, 0x57, 0x64, 0x65, 0x8d,
+      0x91, 0xa9, 0xb4, 0xba, 0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x0d,
+      0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5,
+      0xd7, 0xf0, 0xf1, 0x83, 0x85, 0x8b, 0xa4, 0xa6, 0xbe, 0xbf, 0xc5, 0xc7,
+      0xce, 0xcf, 0xda, 0xdb, 0x48, 0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49,
+      0x4e, 0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f, 0xb1, 0xb6, 0xb7,
+      0xbf, 0xc1, 0xc6, 0xc7, 0xd7, 0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7,
+      0xfe, 0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e, 0x0f, 0x1f, 0x6e,
+      0x6f, 0x1c, 0x1d, 0x5f, 0x7d, 0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16,
+      0x17, 0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a, 0x5c, 0x5e, 0x7e,
+      0x7f, 0xb5, 0xc5, 0xd4, 0xd5, 0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f,
+      0x74, 0x75, 0x96, 0x2f, 0x5f, 0x26, 0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf,
+      0xc7, 0xcf, 0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f, 0x1f, 0xc0,
+      0xc1, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b, 0x07, 0x08, 0x0f, 0x10, 0x27,
+      0x2f, 0xee, 0xef, 0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90, 0x91,
+      0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9, 0xd0, 0xd1, 0xd8, 0xd9, 0xe7,
+      0xfe, 0xff,
+  };
+  static constexpr singleton singletons1[] = {
+      {0x00, 6},  {0x01, 1}, {0x03, 1},  {0x04, 2}, {0x08, 8},  {0x09, 2},
+      {0x0a, 5},  {0x0b, 2}, {0x0e, 4},  {0x10, 1}, {0x11, 2},  {0x12, 5},
+      {0x13, 17}, {0x14, 1}, {0x15, 2},  {0x17, 2}, {0x19, 13}, {0x1c, 5},
+      {0x1d, 8},  {0x24, 1}, {0x6a, 3},  {0x6b, 2}, {0xbc, 2},  {0xd1, 2},
+      {0xd4, 12}, {0xd5, 9}, {0xd6, 2},  {0xd7, 2}, {0xda, 1},  {0xe0, 5},
+      {0xe1, 2},  {0xe8, 2}, {0xee, 32}, {0xf0, 4}, {0xf8, 2},  {0xf9, 2},
+      {0xfa, 2},  {0xfb, 1},
+  };
+  static constexpr unsigned char singletons1_lower[] = {
+      0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e, 0x9e, 0x9f, 0x06, 0x07,
+      0x09, 0x36, 0x3d, 0x3e, 0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36,
+      0x37, 0x56, 0x57, 0x7f, 0xaa, 0xae, 0xaf, 0xbd, 0x35, 0xe0, 0x12, 0x87,
+      0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e, 0x11, 0x12, 0x29, 0x31, 0x34, 0x3a,
+      0x45, 0x46, 0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5c, 0xb6, 0xb7, 0x1b,
+      0x1c, 0x07, 0x08, 0x0a, 0x0b, 0x14, 0x17, 0x36, 0x39, 0x3a, 0xa8, 0xa9,
+      0xd8, 0xd9, 0x09, 0x37, 0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66,
+      0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a, 0x62, 0x9a, 0x9b, 0x27,
+      0x28, 0x55, 0x9d, 0xa0, 0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc,
+      0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f, 0x45, 0x51, 0xa6, 0xa7,
+      0xcc, 0xcd, 0xa0, 0x07, 0x19, 0x1a, 0x22, 0x25, 0x3e, 0x3f, 0xc5, 0xc6,
+      0x04, 0x20, 0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48, 0x4a, 0x4c,
+      0x50, 0x53, 0x55, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66,
+      0x6b, 0x73, 0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0, 0xc0, 0xd0,
+      0xae, 0xaf, 0x79, 0xcc, 0x6e, 0x6f, 0x93,
+  };
+  static constexpr unsigned char normal0[] = {
+      0x00, 0x20, 0x5f, 0x22, 0x82, 0xdf, 0x04, 0x82, 0x44, 0x08, 0x1b, 0x04,
+      0x06, 0x11, 0x81, 0xac, 0x0e, 0x80, 0xab, 0x35, 0x28, 0x0b, 0x80, 0xe0,
+      0x03, 0x19, 0x08, 0x01, 0x04, 0x2f, 0x04, 0x34, 0x04, 0x07, 0x03, 0x01,
+      0x07, 0x06, 0x07, 0x11, 0x0a, 0x50, 0x0f, 0x12, 0x07, 0x55, 0x07, 0x03,
+      0x04, 0x1c, 0x0a, 0x09, 0x03, 0x08, 0x03, 0x07, 0x03, 0x02, 0x03, 0x03,
+      0x03, 0x0c, 0x04, 0x05, 0x03, 0x0b, 0x06, 0x01, 0x0e, 0x15, 0x05, 0x3a,
+      0x03, 0x11, 0x07, 0x06, 0x05, 0x10, 0x07, 0x57, 0x07, 0x02, 0x07, 0x15,
+      0x0d, 0x50, 0x04, 0x43, 0x03, 0x2d, 0x03, 0x01, 0x04, 0x11, 0x06, 0x0f,
+      0x0c, 0x3a, 0x04, 0x1d, 0x25, 0x5f, 0x20, 0x6d, 0x04, 0x6a, 0x25, 0x80,
+      0xc8, 0x05, 0x82, 0xb0, 0x03, 0x1a, 0x06, 0x82, 0xfd, 0x03, 0x59, 0x07,
+      0x15, 0x0b, 0x17, 0x09, 0x14, 0x0c, 0x14, 0x0c, 0x6a, 0x06, 0x0a, 0x06,
+      0x1a, 0x06, 0x59, 0x07, 0x2b, 0x05, 0x46, 0x0a, 0x2c, 0x04, 0x0c, 0x04,
+      0x01, 0x03, 0x31, 0x0b, 0x2c, 0x04, 0x1a, 0x06, 0x0b, 0x03, 0x80, 0xac,
+      0x06, 0x0a, 0x06, 0x21, 0x3f, 0x4c, 0x04, 0x2d, 0x03, 0x74, 0x08, 0x3c,
+      0x03, 0x0f, 0x03, 0x3c, 0x07, 0x38, 0x08, 0x2b, 0x05, 0x82, 0xff, 0x11,
+      0x18, 0x08, 0x2f, 0x11, 0x2d, 0x03, 0x20, 0x10, 0x21, 0x0f, 0x80, 0x8c,
+      0x04, 0x82, 0x97, 0x19, 0x0b, 0x15, 0x88, 0x94, 0x05, 0x2f, 0x05, 0x3b,
+      0x07, 0x02, 0x0e, 0x18, 0x09, 0x80, 0xb3, 0x2d, 0x74, 0x0c, 0x80, 0xd6,
+      0x1a, 0x0c, 0x05, 0x80, 0xff, 0x05, 0x80, 0xdf, 0x0c, 0xee, 0x0d, 0x03,
+      0x84, 0x8d, 0x03, 0x37, 0x09, 0x81, 0x5c, 0x14, 0x80, 0xb8, 0x08, 0x80,
+      0xcb, 0x2a, 0x38, 0x03, 0x0a, 0x06, 0x38, 0x08, 0x46, 0x08, 0x0c, 0x06,
+      0x74, 0x0b, 0x1e, 0x03, 0x5a, 0x04, 0x59, 0x09, 0x80, 0x83, 0x18, 0x1c,
+      0x0a, 0x16, 0x09, 0x4c, 0x04, 0x80, 0x8a, 0x06, 0xab, 0xa4, 0x0c, 0x17,
+      0x04, 0x31, 0xa1, 0x04, 0x81, 0xda, 0x26, 0x07, 0x0c, 0x05, 0x05, 0x80,
+      0xa5, 0x11, 0x81, 0x6d, 0x10, 0x78, 0x28, 0x2a, 0x06, 0x4c, 0x04, 0x80,
+      0x8d, 0x04, 0x80, 0xbe, 0x03, 0x1b, 0x03, 0x0f, 0x0d,
+  };
+  static constexpr unsigned char normal1[] = {
+      0x5e, 0x22, 0x7b, 0x05, 0x03, 0x04, 0x2d, 0x03, 0x66, 0x03, 0x01, 0x2f,
+      0x2e, 0x80, 0x82, 0x1d, 0x03, 0x31, 0x0f, 0x1c, 0x04, 0x24, 0x09, 0x1e,
+      0x05, 0x2b, 0x05, 0x44, 0x04, 0x0e, 0x2a, 0x80, 0xaa, 0x06, 0x24, 0x04,
+      0x24, 0x04, 0x28, 0x08, 0x34, 0x0b, 0x01, 0x80, 0x90, 0x81, 0x37, 0x09,
+      0x16, 0x0a, 0x08, 0x80, 0x98, 0x39, 0x03, 0x63, 0x08, 0x09, 0x30, 0x16,
+      0x05, 0x21, 0x03, 0x1b, 0x05, 0x01, 0x40, 0x38, 0x04, 0x4b, 0x05, 0x2f,
+      0x04, 0x0a, 0x07, 0x09, 0x07, 0x40, 0x20, 0x27, 0x04, 0x0c, 0x09, 0x36,
+      0x03, 0x3a, 0x05, 0x1a, 0x07, 0x04, 0x0c, 0x07, 0x50, 0x49, 0x37, 0x33,
+      0x0d, 0x33, 0x07, 0x2e, 0x08, 0x0a, 0x81, 0x26, 0x52, 0x4e, 0x28, 0x08,
+      0x2a, 0x56, 0x1c, 0x14, 0x17, 0x09, 0x4e, 0x04, 0x1e, 0x0f, 0x43, 0x0e,
+      0x19, 0x07, 0x0a, 0x06, 0x48, 0x08, 0x27, 0x09, 0x75, 0x0b, 0x3f, 0x41,
+      0x2a, 0x06, 0x3b, 0x05, 0x0a, 0x06, 0x51, 0x06, 0x01, 0x05, 0x10, 0x03,
+      0x05, 0x80, 0x8b, 0x62, 0x1e, 0x48, 0x08, 0x0a, 0x80, 0xa6, 0x5e, 0x22,
+      0x45, 0x0b, 0x0a, 0x06, 0x0d, 0x13, 0x39, 0x07, 0x0a, 0x36, 0x2c, 0x04,
+      0x10, 0x80, 0xc0, 0x3c, 0x64, 0x53, 0x0c, 0x48, 0x09, 0x0a, 0x46, 0x45,
+      0x1b, 0x48, 0x08, 0x53, 0x1d, 0x39, 0x81, 0x07, 0x46, 0x0a, 0x1d, 0x03,
+      0x47, 0x49, 0x37, 0x03, 0x0e, 0x08, 0x0a, 0x06, 0x39, 0x07, 0x0a, 0x81,
+      0x36, 0x19, 0x80, 0xb7, 0x01, 0x0f, 0x32, 0x0d, 0x83, 0x9b, 0x66, 0x75,
+      0x0b, 0x80, 0xc4, 0x8a, 0xbc, 0x84, 0x2f, 0x8f, 0xd1, 0x82, 0x47, 0xa1,
+      0xb9, 0x82, 0x39, 0x07, 0x2a, 0x04, 0x02, 0x60, 0x26, 0x0a, 0x46, 0x0a,
+      0x28, 0x05, 0x13, 0x82, 0xb0, 0x5b, 0x65, 0x4b, 0x04, 0x39, 0x07, 0x11,
+      0x40, 0x05, 0x0b, 0x02, 0x0e, 0x97, 0xf8, 0x08, 0x84, 0xd6, 0x2a, 0x09,
+      0xa2, 0xf7, 0x81, 0x1f, 0x31, 0x03, 0x11, 0x04, 0x08, 0x81, 0x8c, 0x89,
+      0x04, 0x6b, 0x05, 0x0d, 0x03, 0x09, 0x07, 0x10, 0x93, 0x60, 0x80, 0xf6,
+      0x0a, 0x73, 0x08, 0x6e, 0x17, 0x46, 0x80, 0x9a, 0x14, 0x0c, 0x57, 0x09,
+      0x19, 0x80, 0x87, 0x81, 0x47, 0x03, 0x85, 0x42, 0x0f, 0x15, 0x85, 0x50,
+      0x2b, 0x80, 0xd5, 0x2d, 0x03, 0x1a, 0x04, 0x02, 0x81, 0x70, 0x3a, 0x05,
+      0x01, 0x85, 0x00, 0x80, 0xd7, 0x29, 0x4c, 0x04, 0x0a, 0x04, 0x02, 0x83,
+      0x11, 0x44, 0x4c, 0x3d, 0x80, 0xc2, 0x3c, 0x06, 0x01, 0x04, 0x55, 0x05,
+      0x1b, 0x34, 0x02, 0x81, 0x0e, 0x2c, 0x04, 0x64, 0x0c, 0x56, 0x0a, 0x80,
+      0xae, 0x38, 0x1d, 0x0d, 0x2c, 0x04, 0x09, 0x07, 0x02, 0x0e, 0x06, 0x80,
+      0x9a, 0x83, 0xd8, 0x08, 0x0d, 0x03, 0x0d, 0x03, 0x74, 0x0c, 0x59, 0x07,
+      0x0c, 0x14, 0x0c, 0x04, 0x38, 0x08, 0x0a, 0x06, 0x28, 0x08, 0x22, 0x4e,
+      0x81, 0x54, 0x0c, 0x15, 0x03, 0x03, 0x05, 0x07, 0x09, 0x19, 0x07, 0x07,
+      0x09, 0x03, 0x0d, 0x07, 0x29, 0x80, 0xcb, 0x25, 0x0a, 0x84, 0x06,
+  };
+  auto lower = static_cast<uint16_t>(cp);
+  if (cp < 0x10000) {
+    return is_printable(lower, singletons0,
+                        sizeof(singletons0) / sizeof(*singletons0),
+                        singletons0_lower, normal0, sizeof(normal0));
+  }
+  if (cp < 0x20000) {
+    return is_printable(lower, singletons1,
+                        sizeof(singletons1) / sizeof(*singletons1),
+                        singletons1_lower, normal1, sizeof(normal1));
+  }
+  if (0x2a6de <= cp && cp < 0x2a700) return false;
+  if (0x2b735 <= cp && cp < 0x2b740) return false;
+  if (0x2b81e <= cp && cp < 0x2b820) return false;
+  if (0x2cea2 <= cp && cp < 0x2ceb0) return false;
+  if (0x2ebe1 <= cp && cp < 0x2f800) return false;
+  if (0x2fa1e <= cp && cp < 0x30000) return false;
+  if (0x3134b <= cp && cp < 0xe0100) return false;
+  if (0xe01f0 <= cp && cp < 0x110000) return false;
+  return cp < 0x110000;
+}
+
+}  // namespace detail
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_FORMAT_INL_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format.h
new file mode 100644
index 0000000000000000000000000000000000000000..7637c8a0d0687ae3b77a145c2e1ceadf7fe5f67d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/format.h
@@ -0,0 +1,4535 @@
+/*
+  Formatting library for C++
+
+  Copyright (c) 2012 - present, Victor Zverovich
+
+  Permission is hereby granted, free of charge, to any person obtaining
+  a copy of this software and associated documentation files (the
+  "Software"), to deal in the Software without restriction, including
+  without limitation the rights to use, copy, modify, merge, publish,
+  distribute, sublicense, and/or sell copies of the Software, and to
+  permit persons to whom the Software is furnished to do so, subject to
+  the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+  --- Optional exception to the license ---
+
+  As an exception, if, as a result of your compiling your source code, portions
+  of this Software are embedded into a machine-executable object form of such
+  source code, you may redistribute such embedded portions in such object form
+  without including the above copyright and permission notices.
+ */
+
+#ifndef FMT_FORMAT_H_
+#define FMT_FORMAT_H_
+
+#include <cmath>             // std::signbit
+#include <cstdint>           // uint32_t
+#include <cstring>           // std::memcpy
+#include <initializer_list>  // std::initializer_list
+#include <limits>            // std::numeric_limits
+#include <memory>            // std::uninitialized_copy
+#include <stdexcept>         // std::runtime_error
+#include <system_error>      // std::system_error
+
+#ifdef __cpp_lib_bit_cast
+#  include <bit>  // std::bit_cast
+#endif
+
+#include "core.h"
+
+#if defined __cpp_inline_variables && __cpp_inline_variables >= 201606L
+#  define FMT_INLINE_VARIABLE inline
+#else
+#  define FMT_INLINE_VARIABLE
+#endif
+
+#if FMT_HAS_CPP17_ATTRIBUTE(fallthrough)
+#  define FMT_FALLTHROUGH [[fallthrough]]
+#elif defined(__clang__)
+#  define FMT_FALLTHROUGH [[clang::fallthrough]]
+#elif FMT_GCC_VERSION >= 700 && \
+    (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520)
+#  define FMT_FALLTHROUGH [[gnu::fallthrough]]
+#else
+#  define FMT_FALLTHROUGH
+#endif
+
+#ifndef FMT_DEPRECATED
+#  if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VERSION >= 1900
+#    define FMT_DEPRECATED [[deprecated]]
+#  else
+#    if (defined(__GNUC__) && !defined(__LCC__)) || defined(__clang__)
+#      define FMT_DEPRECATED __attribute__((deprecated))
+#    elif FMT_MSC_VERSION
+#      define FMT_DEPRECATED __declspec(deprecated)
+#    else
+#      define FMT_DEPRECATED /* deprecated */
+#    endif
+#  endif
+#endif
+
+#ifndef FMT_NO_UNIQUE_ADDRESS
+#  if FMT_CPLUSPLUS >= 202002L
+#    if FMT_HAS_CPP_ATTRIBUTE(no_unique_address)
+#      define FMT_NO_UNIQUE_ADDRESS [[no_unique_address]]
+// VS2019 v16.10 and later except clang-cl (https://reviews.llvm.org/D110485)
+#    elif (FMT_MSC_VERSION >= 1929) && !FMT_CLANG_VERSION
+#      define FMT_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
+#    endif
+#  endif
+#endif
+#ifndef FMT_NO_UNIQUE_ADDRESS
+#  define FMT_NO_UNIQUE_ADDRESS
+#endif
+
+// Visibility when compiled as a shared library/object.
+#if defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
+#  define FMT_SO_VISIBILITY(value) FMT_VISIBILITY(value)
+#else
+#  define FMT_SO_VISIBILITY(value)
+#endif
+
+#ifdef __has_builtin
+#  define FMT_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#  define FMT_HAS_BUILTIN(x) 0
+#endif
+
+#if FMT_GCC_VERSION || FMT_CLANG_VERSION
+#  define FMT_NOINLINE __attribute__((noinline))
+#else
+#  define FMT_NOINLINE
+#endif
+
+#ifndef FMT_THROW
+#  if FMT_EXCEPTIONS
+#    if FMT_MSC_VERSION || defined(__NVCC__)
+FMT_BEGIN_NAMESPACE
+namespace detail {
+template <typename Exception> inline void do_throw(const Exception& x) {
+  // Silence unreachable code warnings in MSVC and NVCC because these
+  // are nearly impossible to fix in a generic code.
+  volatile bool b = true;
+  if (b) throw x;
+}
+}  // namespace detail
+FMT_END_NAMESPACE
+#      define FMT_THROW(x) detail::do_throw(x)
+#    else
+#      define FMT_THROW(x) throw x
+#    endif
+#  else
+#    define FMT_THROW(x) \
+      ::fmt::detail::assert_fail(__FILE__, __LINE__, (x).what())
+#  endif
+#endif
+
+#if FMT_EXCEPTIONS
+#  define FMT_TRY try
+#  define FMT_CATCH(x) catch (x)
+#else
+#  define FMT_TRY if (true)
+#  define FMT_CATCH(x) if (false)
+#endif
+
+#ifndef FMT_MAYBE_UNUSED
+#  if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused)
+#    define FMT_MAYBE_UNUSED [[maybe_unused]]
+#  else
+#    define FMT_MAYBE_UNUSED
+#  endif
+#endif
+
+#ifndef FMT_USE_USER_DEFINED_LITERALS
+// EDG based compilers (Intel, NVIDIA, Elbrus, etc), GCC and MSVC support UDLs.
+//
+// GCC before 4.9 requires a space in `operator"" _a` which is invalid in later
+// compiler versions.
+#  if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 409 || \
+       FMT_MSC_VERSION >= 1900) &&                                     \
+      (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= /* UDL feature */ 480)
+#    define FMT_USE_USER_DEFINED_LITERALS 1
+#  else
+#    define FMT_USE_USER_DEFINED_LITERALS 0
+#  endif
+#endif
+
+// Defining FMT_REDUCE_INT_INSTANTIATIONS to 1, will reduce the number of
+// integer formatter template instantiations to just one by only using the
+// largest integer type. This results in a reduction in binary size but will
+// cause a decrease in integer formatting performance.
+#if !defined(FMT_REDUCE_INT_INSTANTIATIONS)
+#  define FMT_REDUCE_INT_INSTANTIATIONS 0
+#endif
+
+// __builtin_clz is broken in clang with Microsoft CodeGen:
+// https://github.com/fmtlib/fmt/issues/519.
+#if !FMT_MSC_VERSION
+#  if FMT_HAS_BUILTIN(__builtin_clz) || FMT_GCC_VERSION || FMT_ICC_VERSION
+#    define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
+#  endif
+#  if FMT_HAS_BUILTIN(__builtin_clzll) || FMT_GCC_VERSION || FMT_ICC_VERSION
+#    define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
+#  endif
+#endif
+
+// __builtin_ctz is broken in Intel Compiler Classic on Windows:
+// https://github.com/fmtlib/fmt/issues/2510.
+#ifndef __ICL
+#  if FMT_HAS_BUILTIN(__builtin_ctz) || FMT_GCC_VERSION || FMT_ICC_VERSION || \
+      defined(__NVCOMPILER)
+#    define FMT_BUILTIN_CTZ(n) __builtin_ctz(n)
+#  endif
+#  if FMT_HAS_BUILTIN(__builtin_ctzll) || FMT_GCC_VERSION || \
+      FMT_ICC_VERSION || defined(__NVCOMPILER)
+#    define FMT_BUILTIN_CTZLL(n) __builtin_ctzll(n)
+#  endif
+#endif
+
+#if FMT_MSC_VERSION
+#  include <intrin.h>  // _BitScanReverse[64], _BitScanForward[64], _umul128
+#endif
+
+// Some compilers masquerade as both MSVC and GCC-likes or otherwise support
+// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the
+// MSVC intrinsics if the clz and clzll builtins are not available.
+#if FMT_MSC_VERSION && !defined(FMT_BUILTIN_CLZLL) && \
+    !defined(FMT_BUILTIN_CTZLL)
+FMT_BEGIN_NAMESPACE
+namespace detail {
+// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
+#  if !defined(__clang__)
+#    pragma intrinsic(_BitScanForward)
+#    pragma intrinsic(_BitScanReverse)
+#    if defined(_WIN64)
+#      pragma intrinsic(_BitScanForward64)
+#      pragma intrinsic(_BitScanReverse64)
+#    endif
+#  endif
+
+inline auto clz(uint32_t x) -> int {
+  unsigned long r = 0;
+  _BitScanReverse(&r, x);
+  FMT_ASSERT(x != 0, "");
+  // Static analysis complains about using uninitialized data
+  // "r", but the only way that can happen is if "x" is 0,
+  // which the callers guarantee to not happen.
+  FMT_MSC_WARNING(suppress : 6102)
+  return 31 ^ static_cast<int>(r);
+}
+#  define FMT_BUILTIN_CLZ(n) detail::clz(n)
+
+inline auto clzll(uint64_t x) -> int {
+  unsigned long r = 0;
+#  ifdef _WIN64
+  _BitScanReverse64(&r, x);
+#  else
+  // Scan the high 32 bits.
+  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
+    return 63 ^ static_cast<int>(r + 32);
+  // Scan the low 32 bits.
+  _BitScanReverse(&r, static_cast<uint32_t>(x));
+#  endif
+  FMT_ASSERT(x != 0, "");
+  FMT_MSC_WARNING(suppress : 6102)  // Suppress a bogus static analysis warning.
+  return 63 ^ static_cast<int>(r);
+}
+#  define FMT_BUILTIN_CLZLL(n) detail::clzll(n)
+
+inline auto ctz(uint32_t x) -> int {
+  unsigned long r = 0;
+  _BitScanForward(&r, x);
+  FMT_ASSERT(x != 0, "");
+  FMT_MSC_WARNING(suppress : 6102)  // Suppress a bogus static analysis warning.
+  return static_cast<int>(r);
+}
+#  define FMT_BUILTIN_CTZ(n) detail::ctz(n)
+
+inline auto ctzll(uint64_t x) -> int {
+  unsigned long r = 0;
+  FMT_ASSERT(x != 0, "");
+  FMT_MSC_WARNING(suppress : 6102)  // Suppress a bogus static analysis warning.
+#  ifdef _WIN64
+  _BitScanForward64(&r, x);
+#  else
+  // Scan the low 32 bits.
+  if (_BitScanForward(&r, static_cast<uint32_t>(x))) return static_cast<int>(r);
+  // Scan the high 32 bits.
+  _BitScanForward(&r, static_cast<uint32_t>(x >> 32));
+  r += 32;
+#  endif
+  return static_cast<int>(r);
+}
+#  define FMT_BUILTIN_CTZLL(n) detail::ctzll(n)
+}  // namespace detail
+FMT_END_NAMESPACE
+#endif
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+FMT_CONSTEXPR inline void abort_fuzzing_if(bool condition) {
+  ignore_unused(condition);
+#ifdef FMT_FUZZ
+  if (condition) throw std::runtime_error("fuzzing limit reached");
+#endif
+}
+
+template <typename CharT, CharT... C> struct string_literal {
+  static constexpr CharT value[sizeof...(C)] = {C...};
+  constexpr operator basic_string_view<CharT>() const {
+    return {value, sizeof...(C)};
+  }
+};
+
+#if FMT_CPLUSPLUS < 201703L
+template <typename CharT, CharT... C>
+constexpr CharT string_literal<CharT, C...>::value[sizeof...(C)];
+#endif
+
+// Implementation of std::bit_cast for pre-C++20.
+template <typename To, typename From, FMT_ENABLE_IF(sizeof(To) == sizeof(From))>
+FMT_CONSTEXPR20 auto bit_cast(const From& from) -> To {
+#ifdef __cpp_lib_bit_cast
+  if (is_constant_evaluated()) return std::bit_cast<To>(from);
+#endif
+  auto to = To();
+  // The cast suppresses a bogus -Wclass-memaccess on GCC.
+  std::memcpy(static_cast<void*>(&to), &from, sizeof(to));
+  return to;
+}
+
+inline auto is_big_endian() -> bool {
+#ifdef _WIN32
+  return false;
+#elif defined(__BIG_ENDIAN__)
+  return true;
+#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__)
+  return __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__;
+#else
+  struct bytes {
+    char data[sizeof(int)];
+  };
+  return bit_cast<bytes>(1).data[0] == 0;
+#endif
+}
+
+class uint128_fallback {
+ private:
+  uint64_t lo_, hi_;
+
+ public:
+  constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {}
+  constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {}
+
+  constexpr auto high() const noexcept -> uint64_t { return hi_; }
+  constexpr auto low() const noexcept -> uint64_t { return lo_; }
+
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  constexpr explicit operator T() const {
+    return static_cast<T>(lo_);
+  }
+
+  friend constexpr auto operator==(const uint128_fallback& lhs,
+                                   const uint128_fallback& rhs) -> bool {
+    return lhs.hi_ == rhs.hi_ && lhs.lo_ == rhs.lo_;
+  }
+  friend constexpr auto operator!=(const uint128_fallback& lhs,
+                                   const uint128_fallback& rhs) -> bool {
+    return !(lhs == rhs);
+  }
+  friend constexpr auto operator>(const uint128_fallback& lhs,
+                                  const uint128_fallback& rhs) -> bool {
+    return lhs.hi_ != rhs.hi_ ? lhs.hi_ > rhs.hi_ : lhs.lo_ > rhs.lo_;
+  }
+  friend constexpr auto operator|(const uint128_fallback& lhs,
+                                  const uint128_fallback& rhs)
+      -> uint128_fallback {
+    return {lhs.hi_ | rhs.hi_, lhs.lo_ | rhs.lo_};
+  }
+  friend constexpr auto operator&(const uint128_fallback& lhs,
+                                  const uint128_fallback& rhs)
+      -> uint128_fallback {
+    return {lhs.hi_ & rhs.hi_, lhs.lo_ & rhs.lo_};
+  }
+  friend constexpr auto operator~(const uint128_fallback& n)
+      -> uint128_fallback {
+    return {~n.hi_, ~n.lo_};
+  }
+  friend auto operator+(const uint128_fallback& lhs,
+                        const uint128_fallback& rhs) -> uint128_fallback {
+    auto result = uint128_fallback(lhs);
+    result += rhs;
+    return result;
+  }
+  friend auto operator*(const uint128_fallback& lhs, uint32_t rhs)
+      -> uint128_fallback {
+    FMT_ASSERT(lhs.hi_ == 0, "");
+    uint64_t hi = (lhs.lo_ >> 32) * rhs;
+    uint64_t lo = (lhs.lo_ & ~uint32_t()) * rhs;
+    uint64_t new_lo = (hi << 32) + lo;
+    return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo};
+  }
+  friend auto operator-(const uint128_fallback& lhs, uint64_t rhs)
+      -> uint128_fallback {
+    return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs};
+  }
+  FMT_CONSTEXPR auto operator>>(int shift) const -> uint128_fallback {
+    if (shift == 64) return {0, hi_};
+    if (shift > 64) return uint128_fallback(0, hi_) >> (shift - 64);
+    return {hi_ >> shift, (hi_ << (64 - shift)) | (lo_ >> shift)};
+  }
+  FMT_CONSTEXPR auto operator<<(int shift) const -> uint128_fallback {
+    if (shift == 64) return {lo_, 0};
+    if (shift > 64) return uint128_fallback(lo_, 0) << (shift - 64);
+    return {hi_ << shift | (lo_ >> (64 - shift)), (lo_ << shift)};
+  }
+  FMT_CONSTEXPR auto operator>>=(int shift) -> uint128_fallback& {
+    return *this = *this >> shift;
+  }
+  FMT_CONSTEXPR void operator+=(uint128_fallback n) {
+    uint64_t new_lo = lo_ + n.lo_;
+    uint64_t new_hi = hi_ + n.hi_ + (new_lo < lo_ ? 1 : 0);
+    FMT_ASSERT(new_hi >= hi_, "");
+    lo_ = new_lo;
+    hi_ = new_hi;
+  }
+  FMT_CONSTEXPR void operator&=(uint128_fallback n) {
+    lo_ &= n.lo_;
+    hi_ &= n.hi_;
+  }
+
+  FMT_CONSTEXPR20 auto operator+=(uint64_t n) noexcept -> uint128_fallback& {
+    if (is_constant_evaluated()) {
+      lo_ += n;
+      hi_ += (lo_ < n ? 1 : 0);
+      return *this;
+    }
+#if FMT_HAS_BUILTIN(__builtin_addcll) && !defined(__ibmxl__)
+    unsigned long long carry;
+    lo_ = __builtin_addcll(lo_, n, 0, &carry);
+    hi_ += carry;
+#elif FMT_HAS_BUILTIN(__builtin_ia32_addcarryx_u64) && !defined(__ibmxl__)
+    unsigned long long result;
+    auto carry = __builtin_ia32_addcarryx_u64(0, lo_, n, &result);
+    lo_ = result;
+    hi_ += carry;
+#elif defined(_MSC_VER) && defined(_M_X64)
+    auto carry = _addcarry_u64(0, lo_, n, &lo_);
+    _addcarry_u64(carry, hi_, 0, &hi_);
+#else
+    lo_ += n;
+    hi_ += (lo_ < n ? 1 : 0);
+#endif
+    return *this;
+  }
+};
+
+using uint128_t = conditional_t<FMT_USE_INT128, uint128_opt, uint128_fallback>;
+
+#ifdef UINTPTR_MAX
+using uintptr_t = ::uintptr_t;
+#else
+using uintptr_t = uint128_t;
+#endif
+
+// Returns the largest possible value for type T. Same as
+// std::numeric_limits<T>::max() but shorter and not affected by the max macro.
+template <typename T> constexpr auto max_value() -> T {
+  return (std::numeric_limits<T>::max)();
+}
+template <typename T> constexpr auto num_bits() -> int {
+  return std::numeric_limits<T>::digits;
+}
+// std::numeric_limits<T>::digits may return 0 for 128-bit ints.
+template <> constexpr auto num_bits<int128_opt>() -> int { return 128; }
+template <> constexpr auto num_bits<uint128_t>() -> int { return 128; }
+
+// A heterogeneous bit_cast used for converting 96-bit long double to uint128_t
+// and 128-bit pointers to uint128_fallback.
+template <typename To, typename From, FMT_ENABLE_IF(sizeof(To) > sizeof(From))>
+inline auto bit_cast(const From& from) -> To {
+  constexpr auto size = static_cast<int>(sizeof(From) / sizeof(unsigned));
+  struct data_t {
+    unsigned value[static_cast<unsigned>(size)];
+  } data = bit_cast<data_t>(from);
+  auto result = To();
+  if (const_check(is_big_endian())) {
+    for (int i = 0; i < size; ++i)
+      result = (result << num_bits<unsigned>()) | data.value[i];
+  } else {
+    for (int i = size - 1; i >= 0; --i)
+      result = (result << num_bits<unsigned>()) | data.value[i];
+  }
+  return result;
+}
+
+template <typename UInt>
+FMT_CONSTEXPR20 inline auto countl_zero_fallback(UInt n) -> int {
+  int lz = 0;
+  constexpr UInt msb_mask = static_cast<UInt>(1) << (num_bits<UInt>() - 1);
+  for (; (n & msb_mask) == 0; n <<= 1) lz++;
+  return lz;
+}
+
+FMT_CONSTEXPR20 inline auto countl_zero(uint32_t n) -> int {
+#ifdef FMT_BUILTIN_CLZ
+  if (!is_constant_evaluated()) return FMT_BUILTIN_CLZ(n);
+#endif
+  return countl_zero_fallback(n);
+}
+
+FMT_CONSTEXPR20 inline auto countl_zero(uint64_t n) -> int {
+#ifdef FMT_BUILTIN_CLZLL
+  if (!is_constant_evaluated()) return FMT_BUILTIN_CLZLL(n);
+#endif
+  return countl_zero_fallback(n);
+}
+
+FMT_INLINE void assume(bool condition) {
+  (void)condition;
+#if FMT_HAS_BUILTIN(__builtin_assume) && !FMT_ICC_VERSION
+  __builtin_assume(condition);
+#elif FMT_GCC_VERSION
+  if (!condition) __builtin_unreachable();
+#endif
+}
+
+// An approximation of iterator_t for pre-C++20 systems.
+template <typename T>
+using iterator_t = decltype(std::begin(std::declval<T&>()));
+template <typename T> using sentinel_t = decltype(std::end(std::declval<T&>()));
+
+// A workaround for std::string not having mutable data() until C++17.
+template <typename Char>
+inline auto get_data(std::basic_string<Char>& s) -> Char* {
+  return &s[0];
+}
+template <typename Container>
+inline auto get_data(Container& c) -> typename Container::value_type* {
+  return c.data();
+}
+
+// Attempts to reserve space for n extra characters in the output range.
+// Returns a pointer to the reserved range or a reference to it.
+template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
+#if FMT_CLANG_VERSION >= 307 && !FMT_ICC_VERSION
+__attribute__((no_sanitize("undefined")))
+#endif
+inline auto
+reserve(std::back_insert_iterator<Container> it, size_t n) ->
+    typename Container::value_type* {
+  Container& c = get_container(it);
+  size_t size = c.size();
+  c.resize(size + n);
+  return get_data(c) + size;
+}
+
+template <typename T>
+inline auto reserve(buffer_appender<T> it, size_t n) -> buffer_appender<T> {
+  buffer<T>& buf = get_container(it);
+  buf.try_reserve(buf.size() + n);
+  return it;
+}
+
+template <typename Iterator>
+constexpr auto reserve(Iterator& it, size_t) -> Iterator& {
+  return it;
+}
+
+template <typename OutputIt>
+using reserve_iterator =
+    remove_reference_t<decltype(reserve(std::declval<OutputIt&>(), 0))>;
+
+template <typename T, typename OutputIt>
+constexpr auto to_pointer(OutputIt, size_t) -> T* {
+  return nullptr;
+}
+template <typename T> auto to_pointer(buffer_appender<T> it, size_t n) -> T* {
+  buffer<T>& buf = get_container(it);
+  auto size = buf.size();
+  if (buf.capacity() < size + n) return nullptr;
+  buf.try_resize(size + n);
+  return buf.data() + size;
+}
+
+template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
+inline auto base_iterator(std::back_insert_iterator<Container> it,
+                          typename Container::value_type*)
+    -> std::back_insert_iterator<Container> {
+  return it;
+}
+
+template <typename Iterator>
+constexpr auto base_iterator(Iterator, Iterator it) -> Iterator {
+  return it;
+}
+
+// <algorithm> is spectacularly slow to compile in C++20 so use a simple fill_n
+// instead (#1998).
+template <typename OutputIt, typename Size, typename T>
+FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value)
+    -> OutputIt {
+  for (Size i = 0; i < count; ++i) *out++ = value;
+  return out;
+}
+template <typename T, typename Size>
+FMT_CONSTEXPR20 auto fill_n(T* out, Size count, char value) -> T* {
+  if (is_constant_evaluated()) {
+    return fill_n<T*, Size, T>(out, count, value);
+  }
+  std::memset(out, value, to_unsigned(count));
+  return out + count;
+}
+
+#ifdef __cpp_char8_t
+using char8_type = char8_t;
+#else
+enum char8_type : unsigned char {};
+#endif
+
+template <typename OutChar, typename InputIt, typename OutputIt>
+FMT_CONSTEXPR FMT_NOINLINE auto copy_str_noinline(InputIt begin, InputIt end,
+                                                  OutputIt out) -> OutputIt {
+  return copy_str<OutChar>(begin, end, out);
+}
+
+// A public domain branchless UTF-8 decoder by Christopher Wellons:
+// https://github.com/skeeto/branchless-utf8
+/* Decode the next character, c, from s, reporting errors in e.
+ *
+ * Since this is a branchless decoder, four bytes will be read from the
+ * buffer regardless of the actual length of the next character. This
+ * means the buffer _must_ have at least three bytes of zero padding
+ * following the end of the data stream.
+ *
+ * Errors are reported in e, which will be non-zero if the parsed
+ * character was somehow invalid: invalid byte sequence, non-canonical
+ * encoding, or a surrogate half.
+ *
+ * The function returns a pointer to the next character. When an error
+ * occurs, this pointer will be a guess that depends on the particular
+ * error, but it will always advance at least one byte.
+ */
+FMT_CONSTEXPR inline auto utf8_decode(const char* s, uint32_t* c, int* e)
+    -> const char* {
+  constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};
+  constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};
+  constexpr const int shiftc[] = {0, 18, 12, 6, 0};
+  constexpr const int shifte[] = {0, 6, 4, 2, 0};
+
+  int len = "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0\0\0\2\2\2\2\3\3\4"
+      [static_cast<unsigned char>(*s) >> 3];
+  // Compute the pointer to the next character early so that the next
+  // iteration can start working on the next character. Neither Clang
+  // nor GCC figure out this reordering on their own.
+  const char* next = s + len + !len;
+
+  using uchar = unsigned char;
+
+  // Assume a four-byte character and load four bytes. Unused bits are
+  // shifted out.
+  *c = uint32_t(uchar(s[0]) & masks[len]) << 18;
+  *c |= uint32_t(uchar(s[1]) & 0x3f) << 12;
+  *c |= uint32_t(uchar(s[2]) & 0x3f) << 6;
+  *c |= uint32_t(uchar(s[3]) & 0x3f) << 0;
+  *c >>= shiftc[len];
+
+  // Accumulate the various error conditions.
+  *e = (*c < mins[len]) << 6;       // non-canonical encoding
+  *e |= ((*c >> 11) == 0x1b) << 7;  // surrogate half?
+  *e |= (*c > 0x10FFFF) << 8;       // out of range?
+  *e |= (uchar(s[1]) & 0xc0) >> 2;
+  *e |= (uchar(s[2]) & 0xc0) >> 4;
+  *e |= uchar(s[3]) >> 6;
+  *e ^= 0x2a;  // top two bits of each tail byte correct?
+  *e >>= shifte[len];
+
+  return next;
+}
+
+constexpr FMT_INLINE_VARIABLE uint32_t invalid_code_point = ~uint32_t();
+
+// Invokes f(cp, sv) for every code point cp in s with sv being the string view
+// corresponding to the code point. cp is invalid_code_point on error.
+template <typename F>
+FMT_CONSTEXPR void for_each_codepoint(string_view s, F f) {
+  auto decode = [f](const char* buf_ptr, const char* ptr) {
+    auto cp = uint32_t();
+    auto error = 0;
+    auto end = utf8_decode(buf_ptr, &cp, &error);
+    bool result = f(error ? invalid_code_point : cp,
+                    string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr)));
+    return result ? (error ? buf_ptr + 1 : end) : nullptr;
+  };
+  auto p = s.data();
+  const size_t block_size = 4;  // utf8_decode always reads blocks of 4 chars.
+  if (s.size() >= block_size) {
+    for (auto end = p + s.size() - block_size + 1; p < end;) {
+      p = decode(p, p);
+      if (!p) return;
+    }
+  }
+  if (auto num_chars_left = s.data() + s.size() - p) {
+    char buf[2 * block_size - 1] = {};
+    copy_str<char>(p, p + num_chars_left, buf);
+    const char* buf_ptr = buf;
+    do {
+      auto end = decode(buf_ptr, p);
+      if (!end) return;
+      p += end - buf_ptr;
+      buf_ptr = end;
+    } while (buf_ptr - buf < num_chars_left);
+  }
+}
+
+template <typename Char>
+inline auto compute_width(basic_string_view<Char> s) -> size_t {
+  return s.size();
+}
+
+// Computes approximate display width of a UTF-8 string.
+FMT_CONSTEXPR inline auto compute_width(string_view s) -> size_t {
+  size_t num_code_points = 0;
+  // It is not a lambda for compatibility with C++14.
+  struct count_code_points {
+    size_t* count;
+    FMT_CONSTEXPR auto operator()(uint32_t cp, string_view) const -> bool {
+      *count += detail::to_unsigned(
+          1 +
+          (cp >= 0x1100 &&
+           (cp <= 0x115f ||  // Hangul Jamo init. consonants
+            cp == 0x2329 ||  // LEFT-POINTING ANGLE BRACKET
+            cp == 0x232a ||  // RIGHT-POINTING ANGLE BRACKET
+            // CJK ... Yi except IDEOGRAPHIC HALF FILL SPACE:
+            (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) ||
+            (cp >= 0xac00 && cp <= 0xd7a3) ||    // Hangul Syllables
+            (cp >= 0xf900 && cp <= 0xfaff) ||    // CJK Compatibility Ideographs
+            (cp >= 0xfe10 && cp <= 0xfe19) ||    // Vertical Forms
+            (cp >= 0xfe30 && cp <= 0xfe6f) ||    // CJK Compatibility Forms
+            (cp >= 0xff00 && cp <= 0xff60) ||    // Fullwidth Forms
+            (cp >= 0xffe0 && cp <= 0xffe6) ||    // Fullwidth Forms
+            (cp >= 0x20000 && cp <= 0x2fffd) ||  // CJK
+            (cp >= 0x30000 && cp <= 0x3fffd) ||
+            // Miscellaneous Symbols and Pictographs + Emoticons:
+            (cp >= 0x1f300 && cp <= 0x1f64f) ||
+            // Supplemental Symbols and Pictographs:
+            (cp >= 0x1f900 && cp <= 0x1f9ff))));
+      return true;
+    }
+  };
+  // We could avoid branches by using utf8_decode directly.
+  for_each_codepoint(s, count_code_points{&num_code_points});
+  return num_code_points;
+}
+
+inline auto compute_width(basic_string_view<char8_type> s) -> size_t {
+  return compute_width(
+      string_view(reinterpret_cast<const char*>(s.data()), s.size()));
+}
+
+template <typename Char>
+inline auto code_point_index(basic_string_view<Char> s, size_t n) -> size_t {
+  size_t size = s.size();
+  return n < size ? n : size;
+}
+
+// Calculates the index of the nth code point in a UTF-8 string.
+inline auto code_point_index(string_view s, size_t n) -> size_t {
+  size_t result = s.size();
+  const char* begin = s.begin();
+  for_each_codepoint(s, [begin, &n, &result](uint32_t, string_view sv) {
+    if (n != 0) {
+      --n;
+      return true;
+    }
+    result = to_unsigned(sv.begin() - begin);
+    return false;
+  });
+  return result;
+}
+
+inline auto code_point_index(basic_string_view<char8_type> s, size_t n)
+    -> size_t {
+  return code_point_index(
+      string_view(reinterpret_cast<const char*>(s.data()), s.size()), n);
+}
+
+template <typename T> struct is_integral : std::is_integral<T> {};
+template <> struct is_integral<int128_opt> : std::true_type {};
+template <> struct is_integral<uint128_t> : std::true_type {};
+
+template <typename T>
+using is_signed =
+    std::integral_constant<bool, std::numeric_limits<T>::is_signed ||
+                                     std::is_same<T, int128_opt>::value>;
+
+template <typename T>
+using is_integer =
+    bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
+                  !std::is_same<T, char>::value &&
+                  !std::is_same<T, wchar_t>::value>;
+
+#ifndef FMT_USE_FLOAT
+#  define FMT_USE_FLOAT 1
+#endif
+#ifndef FMT_USE_DOUBLE
+#  define FMT_USE_DOUBLE 1
+#endif
+#ifndef FMT_USE_LONG_DOUBLE
+#  define FMT_USE_LONG_DOUBLE 1
+#endif
+
+#ifndef FMT_USE_FLOAT128
+#  ifdef __clang__
+// Clang emulates GCC, so it has to appear early.
+#    if FMT_HAS_INCLUDE(<quadmath.h>)
+#      define FMT_USE_FLOAT128 1
+#    endif
+#  elif defined(__GNUC__)
+// GNU C++:
+#    if defined(_GLIBCXX_USE_FLOAT128) && !defined(__STRICT_ANSI__)
+#      define FMT_USE_FLOAT128 1
+#    endif
+#  endif
+#  ifndef FMT_USE_FLOAT128
+#    define FMT_USE_FLOAT128 0
+#  endif
+#endif
+
+#if FMT_USE_FLOAT128
+using float128 = __float128;
+#else
+using float128 = void;
+#endif
+template <typename T> using is_float128 = std::is_same<T, float128>;
+
+template <typename T>
+using is_floating_point =
+    bool_constant<std::is_floating_point<T>::value || is_float128<T>::value>;
+
+template <typename T, bool = std::is_floating_point<T>::value>
+struct is_fast_float : bool_constant<std::numeric_limits<T>::is_iec559 &&
+                                     sizeof(T) <= sizeof(double)> {};
+template <typename T> struct is_fast_float<T, false> : std::false_type {};
+
+template <typename T>
+using is_double_double = bool_constant<std::numeric_limits<T>::digits == 106>;
+
+#ifndef FMT_USE_FULL_CACHE_DRAGONBOX
+#  define FMT_USE_FULL_CACHE_DRAGONBOX 0
+#endif
+
+template <typename T>
+template <typename U>
+void buffer<T>::append(const U* begin, const U* end) {
+  while (begin != end) {
+    auto count = to_unsigned(end - begin);
+    try_reserve(size_ + count);
+    auto free_cap = capacity_ - size_;
+    if (free_cap < count) count = free_cap;
+    std::uninitialized_copy_n(begin, count, ptr_ + size_);
+    size_ += count;
+    begin += count;
+  }
+}
+
+template <typename T, typename Enable = void>
+struct is_locale : std::false_type {};
+template <typename T>
+struct is_locale<T, void_t<decltype(T::classic())>> : std::true_type {};
+}  // namespace detail
+
+FMT_BEGIN_EXPORT
+
+// The number of characters to store in the basic_memory_buffer object itself
+// to avoid dynamic memory allocation.
+enum { inline_buffer_size = 500 };
+
+/**
+  \rst
+  A dynamically growing memory buffer for trivially copyable/constructible types
+  with the first ``SIZE`` elements stored in the object itself.
+
+  You can use the ``memory_buffer`` type alias for ``char`` instead.
+
+  **Example**::
+
+     auto out = fmt::memory_buffer();
+     fmt::format_to(std::back_inserter(out), "The answer is {}.", 42);
+
+  This will append the following output to the ``out`` object:
+
+  .. code-block:: none
+
+     The answer is 42.
+
+  The output can be converted to an ``std::string`` with ``to_string(out)``.
+  \endrst
+ */
+template <typename T, size_t SIZE = inline_buffer_size,
+          typename Allocator = std::allocator<T>>
+class basic_memory_buffer final : public detail::buffer<T> {
+ private:
+  T store_[SIZE];
+
+  // Don't inherit from Allocator to avoid generating type_info for it.
+  FMT_NO_UNIQUE_ADDRESS Allocator alloc_;
+
+  // Deallocate memory allocated by the buffer.
+  FMT_CONSTEXPR20 void deallocate() {
+    T* data = this->data();
+    if (data != store_) alloc_.deallocate(data, this->capacity());
+  }
+
+ protected:
+  FMT_CONSTEXPR20 void grow(size_t size) override {
+    detail::abort_fuzzing_if(size > 5000);
+    const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
+    size_t old_capacity = this->capacity();
+    size_t new_capacity = old_capacity + old_capacity / 2;
+    if (size > new_capacity)
+      new_capacity = size;
+    else if (new_capacity > max_size)
+      new_capacity = size > max_size ? size : max_size;
+    T* old_data = this->data();
+    T* new_data =
+        std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);
+    // Suppress a bogus -Wstringop-overflow in gcc 13.1 (#3481).
+    detail::assume(this->size() <= new_capacity);
+    // The following code doesn't throw, so the raw pointer above doesn't leak.
+    std::uninitialized_copy_n(old_data, this->size(), new_data);
+    this->set(new_data, new_capacity);
+    // deallocate must not throw according to the standard, but even if it does,
+    // the buffer already uses the new storage and will deallocate it in
+    // destructor.
+    if (old_data != store_) alloc_.deallocate(old_data, old_capacity);
+  }
+
+ public:
+  using value_type = T;
+  using const_reference = const T&;
+
+  FMT_CONSTEXPR20 explicit basic_memory_buffer(
+      const Allocator& alloc = Allocator())
+      : alloc_(alloc) {
+    this->set(store_, SIZE);
+    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
+  }
+  FMT_CONSTEXPR20 ~basic_memory_buffer() { deallocate(); }
+
+ private:
+  // Move data from other to this buffer.
+  FMT_CONSTEXPR20 void move(basic_memory_buffer& other) {
+    alloc_ = std::move(other.alloc_);
+    T* data = other.data();
+    size_t size = other.size(), capacity = other.capacity();
+    if (data == other.store_) {
+      this->set(store_, capacity);
+      detail::copy_str<T>(other.store_, other.store_ + size, store_);
+    } else {
+      this->set(data, capacity);
+      // Set pointer to the inline array so that delete is not called
+      // when deallocating.
+      other.set(other.store_, 0);
+      other.clear();
+    }
+    this->resize(size);
+  }
+
+ public:
+  /**
+    \rst
+    Constructs a :class:`fmt::basic_memory_buffer` object moving the content
+    of the other object to it.
+    \endrst
+   */
+  FMT_CONSTEXPR20 basic_memory_buffer(basic_memory_buffer&& other) noexcept {
+    move(other);
+  }
+
+  /**
+    \rst
+    Moves the content of the other ``basic_memory_buffer`` object to this one.
+    \endrst
+   */
+  auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& {
+    FMT_ASSERT(this != &other, "");
+    deallocate();
+    move(other);
+    return *this;
+  }
+
+  // Returns a copy of the allocator associated with this buffer.
+  auto get_allocator() const -> Allocator { return alloc_; }
+
+  /**
+    Resizes the buffer to contain *count* elements. If T is a POD type new
+    elements may not be initialized.
+   */
+  FMT_CONSTEXPR20 void resize(size_t count) { this->try_resize(count); }
+
+  /** Increases the buffer capacity to *new_capacity*. */
+  void reserve(size_t new_capacity) { this->try_reserve(new_capacity); }
+
+  using detail::buffer<T>::append;
+  template <typename ContiguousRange>
+  void append(const ContiguousRange& range) {
+    append(range.data(), range.data() + range.size());
+  }
+};
+
+using memory_buffer = basic_memory_buffer<char>;
+
+template <typename T, size_t SIZE, typename Allocator>
+struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>> : std::true_type {
+};
+
+FMT_END_EXPORT
+namespace detail {
+FMT_API auto write_console(int fd, string_view text) -> bool;
+FMT_API auto write_console(std::FILE* f, string_view text) -> bool;
+FMT_API void print(std::FILE*, string_view);
+}  // namespace detail
+
+FMT_BEGIN_EXPORT
+
+// Suppress a misleading warning in older versions of clang.
+#if FMT_CLANG_VERSION
+#  pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+/** An error reported from a formatting function. */
+class FMT_SO_VISIBILITY("default") format_error : public std::runtime_error {
+ public:
+  using std::runtime_error::runtime_error;
+};
+
+namespace detail_exported {
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template <typename Char, size_t N> struct fixed_string {
+  constexpr fixed_string(const Char (&str)[N]) {
+    detail::copy_str<Char, const Char*, Char*>(static_cast<const Char*>(str),
+                                               str + N, data);
+  }
+  Char data[N] = {};
+};
+#endif
+
+// Converts a compile-time string to basic_string_view.
+template <typename Char, size_t N>
+constexpr auto compile_string_to_view(const Char (&s)[N])
+    -> basic_string_view<Char> {
+  // Remove trailing NUL character if needed. Won't be present if this is used
+  // with a raw character array (i.e. not defined as a string).
+  return {s, N - (std::char_traits<Char>::to_int_type(s[N - 1]) == 0 ? 1 : 0)};
+}
+template <typename Char>
+constexpr auto compile_string_to_view(detail::std_string_view<Char> s)
+    -> basic_string_view<Char> {
+  return {s.data(), s.size()};
+}
+}  // namespace detail_exported
+
+class loc_value {
+ private:
+  basic_format_arg<format_context> value_;
+
+ public:
+  template <typename T, FMT_ENABLE_IF(!detail::is_float128<T>::value)>
+  loc_value(T value) : value_(detail::make_arg<format_context>(value)) {}
+
+  template <typename T, FMT_ENABLE_IF(detail::is_float128<T>::value)>
+  loc_value(T) {}
+
+  template <typename Visitor> auto visit(Visitor&& vis) -> decltype(vis(0)) {
+    return visit_format_arg(vis, value_);
+  }
+};
+
+// A locale facet that formats values in UTF-8.
+// It is parameterized on the locale to avoid the heavy <locale> include.
+template <typename Locale> class format_facet : public Locale::facet {
+ private:
+  std::string separator_;
+  std::string grouping_;
+  std::string decimal_point_;
+
+ protected:
+  virtual auto do_put(appender out, loc_value val,
+                      const format_specs<>& specs) const -> bool;
+
+ public:
+  static FMT_API typename Locale::id id;
+
+  explicit format_facet(Locale& loc);
+  explicit format_facet(string_view sep = "",
+                        std::initializer_list<unsigned char> g = {3},
+                        std::string decimal_point = ".")
+      : separator_(sep.data(), sep.size()),
+        grouping_(g.begin(), g.end()),
+        decimal_point_(decimal_point) {}
+
+  auto put(appender out, loc_value val, const format_specs<>& specs) const
+      -> bool {
+    return do_put(out, val, specs);
+  }
+};
+
+namespace detail {
+
+// Returns true if value is negative, false otherwise.
+// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.
+template <typename T, FMT_ENABLE_IF(is_signed<T>::value)>
+constexpr auto is_negative(T value) -> bool {
+  return value < 0;
+}
+template <typename T, FMT_ENABLE_IF(!is_signed<T>::value)>
+constexpr auto is_negative(T) -> bool {
+  return false;
+}
+
+template <typename T>
+FMT_CONSTEXPR auto is_supported_floating_point(T) -> bool {
+  if (std::is_same<T, float>()) return FMT_USE_FLOAT;
+  if (std::is_same<T, double>()) return FMT_USE_DOUBLE;
+  if (std::is_same<T, long double>()) return FMT_USE_LONG_DOUBLE;
+  return true;
+}
+
+// Smallest of uint32_t, uint64_t, uint128_t that is large enough to
+// represent all values of an integral type T.
+template <typename T>
+using uint32_or_64_or_128_t =
+    conditional_t<num_bits<T>() <= 32 && !FMT_REDUCE_INT_INSTANTIATIONS,
+                  uint32_t,
+                  conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>>;
+template <typename T>
+using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>;
+
+#define FMT_POWERS_OF_10(factor)                                  \
+  factor * 10, (factor) * 100, (factor) * 1000, (factor) * 10000, \
+      (factor) * 100000, (factor) * 1000000, (factor) * 10000000, \
+      (factor) * 100000000, (factor) * 1000000000
+
+// Converts value in the range [0, 100) to a string.
+constexpr auto digits2(size_t value) -> const char* {
+  // GCC generates slightly better code when value is pointer-size.
+  return &"0001020304050607080910111213141516171819"
+         "2021222324252627282930313233343536373839"
+         "4041424344454647484950515253545556575859"
+         "6061626364656667686970717273747576777879"
+         "8081828384858687888990919293949596979899"[value * 2];
+}
+
+// Sign is a template parameter to workaround a bug in gcc 4.8.
+template <typename Char, typename Sign> constexpr auto sign(Sign s) -> Char {
+#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 604
+  static_assert(std::is_same<Sign, sign_t>::value, "");
+#endif
+  return static_cast<Char>("\0-+ "[s]);
+}
+
+template <typename T> FMT_CONSTEXPR auto count_digits_fallback(T n) -> int {
+  int count = 1;
+  for (;;) {
+    // Integer division is slow so do it for a group of four digits instead
+    // of for every digit. The idea comes from the talk by Alexandrescu
+    // "Three Optimization Tips for C++". See speed-test for a comparison.
+    if (n < 10) return count;
+    if (n < 100) return count + 1;
+    if (n < 1000) return count + 2;
+    if (n < 10000) return count + 3;
+    n /= 10000u;
+    count += 4;
+  }
+}
+#if FMT_USE_INT128
+FMT_CONSTEXPR inline auto count_digits(uint128_opt n) -> int {
+  return count_digits_fallback(n);
+}
+#endif
+
+#ifdef FMT_BUILTIN_CLZLL
+// It is a separate function rather than a part of count_digits to workaround
+// the lack of static constexpr in constexpr functions.
+inline auto do_count_digits(uint64_t n) -> int {
+  // This has comparable performance to the version by Kendall Willets
+  // (https://github.com/fmtlib/format-benchmark/blob/master/digits10)
+  // but uses smaller tables.
+  // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).
+  static constexpr uint8_t bsr2log10[] = {
+      1,  1,  1,  2,  2,  2,  3,  3,  3,  4,  4,  4,  4,  5,  5,  5,
+      6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9,  10, 10, 10,
+      10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
+      15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};
+  auto t = bsr2log10[FMT_BUILTIN_CLZLL(n | 1) ^ 63];
+  static constexpr const uint64_t zero_or_powers_of_10[] = {
+      0, 0, FMT_POWERS_OF_10(1U), FMT_POWERS_OF_10(1000000000ULL),
+      10000000000000000000ULL};
+  return t - (n < zero_or_powers_of_10[t]);
+}
+#endif
+
+// Returns the number of decimal digits in n. Leading zeros are not counted
+// except for n == 0 in which case count_digits returns 1.
+FMT_CONSTEXPR20 inline auto count_digits(uint64_t n) -> int {
+#ifdef FMT_BUILTIN_CLZLL
+  if (!is_constant_evaluated()) {
+    return do_count_digits(n);
+  }
+#endif
+  return count_digits_fallback(n);
+}
+
+// Counts the number of digits in n. BITS = log2(radix).
+template <int BITS, typename UInt>
+FMT_CONSTEXPR auto count_digits(UInt n) -> int {
+#ifdef FMT_BUILTIN_CLZ
+  if (!is_constant_evaluated() && num_bits<UInt>() == 32)
+    return (FMT_BUILTIN_CLZ(static_cast<uint32_t>(n) | 1) ^ 31) / BITS + 1;
+#endif
+  // Lambda avoids unreachable code warnings from NVHPC.
+  return [](UInt m) {
+    int num_digits = 0;
+    do {
+      ++num_digits;
+    } while ((m >>= BITS) != 0);
+    return num_digits;
+  }(n);
+}
+
+#ifdef FMT_BUILTIN_CLZ
+// It is a separate function rather than a part of count_digits to workaround
+// the lack of static constexpr in constexpr functions.
+FMT_INLINE auto do_count_digits(uint32_t n) -> int {
+// An optimization by Kendall Willets from https://bit.ly/3uOIQrB.
+// This increments the upper 32 bits (log10(T) - 1) when >= T is added.
+#  define FMT_INC(T) (((sizeof(#T) - 1ull) << 32) - T)
+  static constexpr uint64_t table[] = {
+      FMT_INC(0),          FMT_INC(0),          FMT_INC(0),           // 8
+      FMT_INC(10),         FMT_INC(10),         FMT_INC(10),          // 64
+      FMT_INC(100),        FMT_INC(100),        FMT_INC(100),         // 512
+      FMT_INC(1000),       FMT_INC(1000),       FMT_INC(1000),        // 4096
+      FMT_INC(10000),      FMT_INC(10000),      FMT_INC(10000),       // 32k
+      FMT_INC(100000),     FMT_INC(100000),     FMT_INC(100000),      // 256k
+      FMT_INC(1000000),    FMT_INC(1000000),    FMT_INC(1000000),     // 2048k
+      FMT_INC(10000000),   FMT_INC(10000000),   FMT_INC(10000000),    // 16M
+      FMT_INC(100000000),  FMT_INC(100000000),  FMT_INC(100000000),   // 128M
+      FMT_INC(1000000000), FMT_INC(1000000000), FMT_INC(1000000000),  // 1024M
+      FMT_INC(1000000000), FMT_INC(1000000000)                        // 4B
+  };
+  auto inc = table[FMT_BUILTIN_CLZ(n | 1) ^ 31];
+  return static_cast<int>((n + inc) >> 32);
+}
+#endif
+
+// Optional version of count_digits for better performance on 32-bit platforms.
+FMT_CONSTEXPR20 inline auto count_digits(uint32_t n) -> int {
+#ifdef FMT_BUILTIN_CLZ
+  if (!is_constant_evaluated()) {
+    return do_count_digits(n);
+  }
+#endif
+  return count_digits_fallback(n);
+}
+
+template <typename Int> constexpr auto digits10() noexcept -> int {
+  return std::numeric_limits<Int>::digits10;
+}
+template <> constexpr auto digits10<int128_opt>() noexcept -> int { return 38; }
+template <> constexpr auto digits10<uint128_t>() noexcept -> int { return 38; }
+
+template <typename Char> struct thousands_sep_result {
+  std::string grouping;
+  Char thousands_sep;
+};
+
+template <typename Char>
+FMT_API auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char>;
+template <typename Char>
+inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<Char> {
+  auto result = thousands_sep_impl<char>(loc);
+  return {result.grouping, Char(result.thousands_sep)};
+}
+template <>
+inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<wchar_t> {
+  return thousands_sep_impl<wchar_t>(loc);
+}
+
+template <typename Char>
+FMT_API auto decimal_point_impl(locale_ref loc) -> Char;
+template <typename Char> inline auto decimal_point(locale_ref loc) -> Char {
+  return Char(decimal_point_impl<char>(loc));
+}
+template <> inline auto decimal_point(locale_ref loc) -> wchar_t {
+  return decimal_point_impl<wchar_t>(loc);
+}
+
+// Compares two characters for equality.
+template <typename Char> auto equal2(const Char* lhs, const char* rhs) -> bool {
+  return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]);
+}
+inline auto equal2(const char* lhs, const char* rhs) -> bool {
+  return memcmp(lhs, rhs, 2) == 0;
+}
+
+// Copies two characters from src to dst.
+template <typename Char>
+FMT_CONSTEXPR20 FMT_INLINE void copy2(Char* dst, const char* src) {
+  if (!is_constant_evaluated() && sizeof(Char) == sizeof(char)) {
+    memcpy(dst, src, 2);
+    return;
+  }
+  *dst++ = static_cast<Char>(*src++);
+  *dst = static_cast<Char>(*src);
+}
+
+template <typename Iterator> struct format_decimal_result {
+  Iterator begin;
+  Iterator end;
+};
+
+// Formats a decimal unsigned integer value writing into out pointing to a
+// buffer of specified size. The caller must ensure that the buffer is large
+// enough.
+template <typename Char, typename UInt>
+FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size)
+    -> format_decimal_result<Char*> {
+  FMT_ASSERT(size >= count_digits(value), "invalid digit count");
+  out += size;
+  Char* end = out;
+  while (value >= 100) {
+    // Integer division is slow so do it for a group of two digits instead
+    // of for every digit. The idea comes from the talk by Alexandrescu
+    // "Three Optimization Tips for C++". See speed-test for a comparison.
+    out -= 2;
+    copy2(out, digits2(static_cast<size_t>(value % 100)));
+    value /= 100;
+  }
+  if (value < 10) {
+    *--out = static_cast<Char>('0' + value);
+    return {out, end};
+  }
+  out -= 2;
+  copy2(out, digits2(static_cast<size_t>(value)));
+  return {out, end};
+}
+
+template <typename Char, typename UInt, typename Iterator,
+          FMT_ENABLE_IF(!std::is_pointer<remove_cvref_t<Iterator>>::value)>
+FMT_CONSTEXPR inline auto format_decimal(Iterator out, UInt value, int size)
+    -> format_decimal_result<Iterator> {
+  // Buffer is large enough to hold all digits (digits10 + 1).
+  Char buffer[digits10<UInt>() + 1] = {};
+  auto end = format_decimal(buffer, value, size).end;
+  return {out, detail::copy_str_noinline<Char>(buffer, end, out)};
+}
+
+template <unsigned BASE_BITS, typename Char, typename UInt>
+FMT_CONSTEXPR auto format_uint(Char* buffer, UInt value, int num_digits,
+                               bool upper = false) -> Char* {
+  buffer += num_digits;
+  Char* end = buffer;
+  do {
+    const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
+    unsigned digit = static_cast<unsigned>(value & ((1 << BASE_BITS) - 1));
+    *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
+                                                : digits[digit]);
+  } while ((value >>= BASE_BITS) != 0);
+  return end;
+}
+
+template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
+FMT_CONSTEXPR inline auto format_uint(It out, UInt value, int num_digits,
+                                      bool upper = false) -> It {
+  if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
+    format_uint<BASE_BITS>(ptr, value, num_digits, upper);
+    return out;
+  }
+  // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).
+  char buffer[num_bits<UInt>() / BASE_BITS + 1] = {};
+  format_uint<BASE_BITS>(buffer, value, num_digits, upper);
+  return detail::copy_str_noinline<Char>(buffer, buffer + num_digits, out);
+}
+
+// A converter from UTF-8 to UTF-16.
+class utf8_to_utf16 {
+ private:
+  basic_memory_buffer<wchar_t> buffer_;
+
+ public:
+  FMT_API explicit utf8_to_utf16(string_view s);
+  operator basic_string_view<wchar_t>() const { return {&buffer_[0], size()}; }
+  auto size() const -> size_t { return buffer_.size() - 1; }
+  auto c_str() const -> const wchar_t* { return &buffer_[0]; }
+  auto str() const -> std::wstring { return {&buffer_[0], size()}; }
+};
+
+enum class to_utf8_error_policy { abort, replace };
+
+// A converter from UTF-16/UTF-32 (host endian) to UTF-8.
+template <typename WChar, typename Buffer = memory_buffer> class to_utf8 {
+ private:
+  Buffer buffer_;
+
+ public:
+  to_utf8() {}
+  explicit to_utf8(basic_string_view<WChar> s,
+                   to_utf8_error_policy policy = to_utf8_error_policy::abort) {
+    static_assert(sizeof(WChar) == 2 || sizeof(WChar) == 4,
+                  "Expect utf16 or utf32");
+    if (!convert(s, policy))
+      FMT_THROW(std::runtime_error(sizeof(WChar) == 2 ? "invalid utf16"
+                                                      : "invalid utf32"));
+  }
+  operator string_view() const { return string_view(&buffer_[0], size()); }
+  auto size() const -> size_t { return buffer_.size() - 1; }
+  auto c_str() const -> const char* { return &buffer_[0]; }
+  auto str() const -> std::string { return std::string(&buffer_[0], size()); }
+
+  // Performs conversion returning a bool instead of throwing exception on
+  // conversion error. This method may still throw in case of memory allocation
+  // error.
+  auto convert(basic_string_view<WChar> s,
+               to_utf8_error_policy policy = to_utf8_error_policy::abort)
+      -> bool {
+    if (!convert(buffer_, s, policy)) return false;
+    buffer_.push_back(0);
+    return true;
+  }
+  static auto convert(Buffer& buf, basic_string_view<WChar> s,
+                      to_utf8_error_policy policy = to_utf8_error_policy::abort)
+      -> bool {
+    for (auto p = s.begin(); p != s.end(); ++p) {
+      uint32_t c = static_cast<uint32_t>(*p);
+      if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) {
+        // Handle a surrogate pair.
+        ++p;
+        if (p == s.end() || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) {
+          if (policy == to_utf8_error_policy::abort) return false;
+          buf.append(string_view("\xEF\xBF\xBD"));
+          --p;
+        } else {
+          c = (c << 10) + static_cast<uint32_t>(*p) - 0x35fdc00;
+        }
+      } else if (c < 0x80) {
+        buf.push_back(static_cast<char>(c));
+      } else if (c < 0x800) {
+        buf.push_back(static_cast<char>(0xc0 | (c >> 6)));
+        buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
+      } else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff)) {
+        buf.push_back(static_cast<char>(0xe0 | (c >> 12)));
+        buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));
+        buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
+      } else if (c >= 0x10000 && c <= 0x10ffff) {
+        buf.push_back(static_cast<char>(0xf0 | (c >> 18)));
+        buf.push_back(static_cast<char>(0x80 | ((c & 0x3ffff) >> 12)));
+        buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));
+        buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// Computes 128-bit result of multiplication of two 64-bit unsigned integers.
+inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback {
+#if FMT_USE_INT128
+  auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
+  return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
+#elif defined(_MSC_VER) && defined(_M_X64)
+  auto hi = uint64_t();
+  auto lo = _umul128(x, y, &hi);
+  return {hi, lo};
+#else
+  const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
+
+  uint64_t a = x >> 32;
+  uint64_t b = x & mask;
+  uint64_t c = y >> 32;
+  uint64_t d = y & mask;
+
+  uint64_t ac = a * c;
+  uint64_t bc = b * c;
+  uint64_t ad = a * d;
+  uint64_t bd = b * d;
+
+  uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
+
+  return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
+          (intermediate << 32) + (bd & mask)};
+#endif
+}
+
+namespace dragonbox {
+// Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from
+// https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1.
+inline auto floor_log10_pow2(int e) noexcept -> int {
+  FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
+  static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
+  return (e * 315653) >> 20;
+}
+
+inline auto floor_log2_pow10(int e) noexcept -> int {
+  FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
+  return (e * 1741647) >> 19;
+}
+
+// Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
+inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t {
+#if FMT_USE_INT128
+  auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
+  return static_cast<uint64_t>(p >> 64);
+#elif defined(_MSC_VER) && defined(_M_X64)
+  return __umulh(x, y);
+#else
+  return umul128(x, y).high();
+#endif
+}
+
+// Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a
+// 128-bit unsigned integer.
+inline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept
+    -> uint128_fallback {
+  uint128_fallback r = umul128(x, y.high());
+  r += umul128_upper64(x, y.low());
+  return r;
+}
+
+FMT_API auto get_cached_power(int k) noexcept -> uint128_fallback;
+
+// Type-specific information that Dragonbox uses.
+template <typename T, typename Enable = void> struct float_info;
+
+template <> struct float_info<float> {
+  using carrier_uint = uint32_t;
+  static const int exponent_bits = 8;
+  static const int kappa = 1;
+  static const int big_divisor = 100;
+  static const int small_divisor = 10;
+  static const int min_k = -31;
+  static const int max_k = 46;
+  static const int shorter_interval_tie_lower_threshold = -35;
+  static const int shorter_interval_tie_upper_threshold = -35;
+};
+
+template <> struct float_info<double> {
+  using carrier_uint = uint64_t;
+  static const int exponent_bits = 11;
+  static const int kappa = 2;
+  static const int big_divisor = 1000;
+  static const int small_divisor = 100;
+  static const int min_k = -292;
+  static const int max_k = 341;
+  static const int shorter_interval_tie_lower_threshold = -77;
+  static const int shorter_interval_tie_upper_threshold = -77;
+};
+
+// An 80- or 128-bit floating point number.
+template <typename T>
+struct float_info<T, enable_if_t<std::numeric_limits<T>::digits == 64 ||
+                                 std::numeric_limits<T>::digits == 113 ||
+                                 is_float128<T>::value>> {
+  using carrier_uint = detail::uint128_t;
+  static const int exponent_bits = 15;
+};
+
+// A double-double floating point number.
+template <typename T>
+struct float_info<T, enable_if_t<is_double_double<T>::value>> {
+  using carrier_uint = detail::uint128_t;
+};
+
+template <typename T> struct decimal_fp {
+  using significand_type = typename float_info<T>::carrier_uint;
+  significand_type significand;
+  int exponent;
+};
+
+template <typename T> FMT_API auto to_decimal(T x) noexcept -> decimal_fp<T>;
+}  // namespace dragonbox
+
+// Returns true iff Float has the implicit bit which is not stored.
+template <typename Float> constexpr auto has_implicit_bit() -> bool {
+  // An 80-bit FP number has a 64-bit significand an no implicit bit.
+  return std::numeric_limits<Float>::digits != 64;
+}
+
+// Returns the number of significand bits stored in Float. The implicit bit is
+// not counted since it is not stored.
+template <typename Float> constexpr auto num_significand_bits() -> int {
+  // std::numeric_limits may not support __float128.
+  return is_float128<Float>() ? 112
+                              : (std::numeric_limits<Float>::digits -
+                                 (has_implicit_bit<Float>() ? 1 : 0));
+}
+
+template <typename Float>
+constexpr auto exponent_mask() ->
+    typename dragonbox::float_info<Float>::carrier_uint {
+  using float_uint = typename dragonbox::float_info<Float>::carrier_uint;
+  return ((float_uint(1) << dragonbox::float_info<Float>::exponent_bits) - 1)
+         << num_significand_bits<Float>();
+}
+template <typename Float> constexpr auto exponent_bias() -> int {
+  // std::numeric_limits may not support __float128.
+  return is_float128<Float>() ? 16383
+                              : std::numeric_limits<Float>::max_exponent - 1;
+}
+
+// Writes the exponent exp in the form "[+-]d{2,3}" to buffer.
+template <typename Char, typename It>
+FMT_CONSTEXPR auto write_exponent(int exp, It it) -> It {
+  FMT_ASSERT(-10000 < exp && exp < 10000, "exponent out of range");
+  if (exp < 0) {
+    *it++ = static_cast<Char>('-');
+    exp = -exp;
+  } else {
+    *it++ = static_cast<Char>('+');
+  }
+  if (exp >= 100) {
+    const char* top = digits2(to_unsigned(exp / 100));
+    if (exp >= 1000) *it++ = static_cast<Char>(top[0]);
+    *it++ = static_cast<Char>(top[1]);
+    exp %= 100;
+  }
+  const char* d = digits2(to_unsigned(exp));
+  *it++ = static_cast<Char>(d[0]);
+  *it++ = static_cast<Char>(d[1]);
+  return it;
+}
+
+// A floating-point number f * pow(2, e) where F is an unsigned type.
+template <typename F> struct basic_fp {
+  F f;
+  int e;
+
+  static constexpr const int num_significand_bits =
+      static_cast<int>(sizeof(F) * num_bits<unsigned char>());
+
+  constexpr basic_fp() : f(0), e(0) {}
+  constexpr basic_fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
+
+  // Constructs fp from an IEEE754 floating-point number.
+  template <typename Float> FMT_CONSTEXPR basic_fp(Float n) { assign(n); }
+
+  // Assigns n to this and return true iff predecessor is closer than successor.
+  template <typename Float, FMT_ENABLE_IF(!is_double_double<Float>::value)>
+  FMT_CONSTEXPR auto assign(Float n) -> bool {
+    static_assert(std::numeric_limits<Float>::digits <= 113, "unsupported FP");
+    // Assume Float is in the format [sign][exponent][significand].
+    using carrier_uint = typename dragonbox::float_info<Float>::carrier_uint;
+    const auto num_float_significand_bits =
+        detail::num_significand_bits<Float>();
+    const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
+    const auto significand_mask = implicit_bit - 1;
+    auto u = bit_cast<carrier_uint>(n);
+    f = static_cast<F>(u & significand_mask);
+    auto biased_e = static_cast<int>((u & exponent_mask<Float>()) >>
+                                     num_float_significand_bits);
+    // The predecessor is closer if n is a normalized power of 2 (f == 0)
+    // other than the smallest normalized number (biased_e > 1).
+    auto is_predecessor_closer = f == 0 && biased_e > 1;
+    if (biased_e == 0)
+      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
+    else if (has_implicit_bit<Float>())
+      f += static_cast<F>(implicit_bit);
+    e = biased_e - exponent_bias<Float>() - num_float_significand_bits;
+    if (!has_implicit_bit<Float>()) ++e;
+    return is_predecessor_closer;
+  }
+
+  template <typename Float, FMT_ENABLE_IF(is_double_double<Float>::value)>
+  FMT_CONSTEXPR auto assign(Float n) -> bool {
+    static_assert(std::numeric_limits<double>::is_iec559, "unsupported FP");
+    return assign(static_cast<double>(n));
+  }
+};
+
+using fp = basic_fp<unsigned long long>;
+
+// Normalizes the value converted from double and multiplied by (1 << SHIFT).
+template <int SHIFT = 0, typename F>
+FMT_CONSTEXPR auto normalize(basic_fp<F> value) -> basic_fp<F> {
+  // Handle subnormals.
+  const auto implicit_bit = F(1) << num_significand_bits<double>();
+  const auto shifted_implicit_bit = implicit_bit << SHIFT;
+  while ((value.f & shifted_implicit_bit) == 0) {
+    value.f <<= 1;
+    --value.e;
+  }
+  // Subtract 1 to account for hidden bit.
+  const auto offset = basic_fp<F>::num_significand_bits -
+                      num_significand_bits<double>() - SHIFT - 1;
+  value.f <<= offset;
+  value.e -= offset;
+  return value;
+}
+
+// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
+FMT_CONSTEXPR inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t {
+#if FMT_USE_INT128
+  auto product = static_cast<__uint128_t>(lhs) * rhs;
+  auto f = static_cast<uint64_t>(product >> 64);
+  return (static_cast<uint64_t>(product) & (1ULL << 63)) != 0 ? f + 1 : f;
+#else
+  // Multiply 32-bit parts of significands.
+  uint64_t mask = (1ULL << 32) - 1;
+  uint64_t a = lhs >> 32, b = lhs & mask;
+  uint64_t c = rhs >> 32, d = rhs & mask;
+  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
+  // Compute mid 64-bit of result and round.
+  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
+  return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);
+#endif
+}
+
+FMT_CONSTEXPR inline auto operator*(fp x, fp y) -> fp {
+  return {multiply(x.f, y.f), x.e + y.e + 64};
+}
+
+template <typename T, bool doublish = num_bits<T>() == num_bits<double>()>
+using convert_float_result =
+    conditional_t<std::is_same<T, float>::value || doublish, double, T>;
+
+template <typename T>
+constexpr auto convert_float(T value) -> convert_float_result<T> {
+  return static_cast<convert_float_result<T>>(value);
+}
+
+template <typename OutputIt, typename Char>
+FMT_NOINLINE FMT_CONSTEXPR auto fill(OutputIt it, size_t n,
+                                     const fill_t<Char>& fill) -> OutputIt {
+  auto fill_size = fill.size();
+  if (fill_size == 1) return detail::fill_n(it, n, fill[0]);
+  auto data = fill.data();
+  for (size_t i = 0; i < n; ++i)
+    it = copy_str<Char>(data, data + fill_size, it);
+  return it;
+}
+
+// Writes the output of f, padded according to format specifications in specs.
+// size: output size in code units.
+// width: output display width in (terminal) column positions.
+template <align::type align = align::left, typename OutputIt, typename Char,
+          typename F>
+FMT_CONSTEXPR auto write_padded(OutputIt out, const format_specs<Char>& specs,
+                                size_t size, size_t width, F&& f) -> OutputIt {
+  static_assert(align == align::left || align == align::right, "");
+  unsigned spec_width = to_unsigned(specs.width);
+  size_t padding = spec_width > width ? spec_width - width : 0;
+  // Shifts are encoded as string literals because static constexpr is not
+  // supported in constexpr functions.
+  auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
+  size_t left_padding = padding >> shifts[specs.align];
+  size_t right_padding = padding - left_padding;
+  auto it = reserve(out, size + padding * specs.fill.size());
+  if (left_padding != 0) it = fill(it, left_padding, specs.fill);
+  it = f(it);
+  if (right_padding != 0) it = fill(it, right_padding, specs.fill);
+  return base_iterator(out, it);
+}
+
+template <align::type align = align::left, typename OutputIt, typename Char,
+          typename F>
+constexpr auto write_padded(OutputIt out, const format_specs<Char>& specs,
+                            size_t size, F&& f) -> OutputIt {
+  return write_padded<align>(out, specs, size, size, f);
+}
+
+template <align::type align = align::left, typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write_bytes(OutputIt out, string_view bytes,
+                               const format_specs<Char>& specs) -> OutputIt {
+  return write_padded<align>(
+      out, specs, bytes.size(), [bytes](reserve_iterator<OutputIt> it) {
+        const char* data = bytes.data();
+        return copy_str<Char>(data, data + bytes.size(), it);
+      });
+}
+
+template <typename Char, typename OutputIt, typename UIntPtr>
+auto write_ptr(OutputIt out, UIntPtr value, const format_specs<Char>* specs)
+    -> OutputIt {
+  int num_digits = count_digits<4>(value);
+  auto size = to_unsigned(num_digits) + size_t(2);
+  auto write = [=](reserve_iterator<OutputIt> it) {
+    *it++ = static_cast<Char>('0');
+    *it++ = static_cast<Char>('x');
+    return format_uint<4, Char>(it, value, num_digits);
+  };
+  return specs ? write_padded<align::right>(out, *specs, size, write)
+               : base_iterator(out, write(reserve(out, size)));
+}
+
+// Returns true iff the code point cp is printable.
+FMT_API auto is_printable(uint32_t cp) -> bool;
+
+inline auto needs_escape(uint32_t cp) -> bool {
+  return cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\' ||
+         !is_printable(cp);
+}
+
+template <typename Char> struct find_escape_result {
+  const Char* begin;
+  const Char* end;
+  uint32_t cp;
+};
+
+template <typename Char>
+using make_unsigned_char =
+    typename conditional_t<std::is_integral<Char>::value,
+                           std::make_unsigned<Char>,
+                           type_identity<uint32_t>>::type;
+
+template <typename Char>
+auto find_escape(const Char* begin, const Char* end)
+    -> find_escape_result<Char> {
+  for (; begin != end; ++begin) {
+    uint32_t cp = static_cast<make_unsigned_char<Char>>(*begin);
+    if (const_check(sizeof(Char) == 1) && cp >= 0x80) continue;
+    if (needs_escape(cp)) return {begin, begin + 1, cp};
+  }
+  return {begin, nullptr, 0};
+}
+
+inline auto find_escape(const char* begin, const char* end)
+    -> find_escape_result<char> {
+  if (!is_utf8()) return find_escape<char>(begin, end);
+  auto result = find_escape_result<char>{end, nullptr, 0};
+  for_each_codepoint(string_view(begin, to_unsigned(end - begin)),
+                     [&](uint32_t cp, string_view sv) {
+                       if (needs_escape(cp)) {
+                         result = {sv.begin(), sv.end(), cp};
+                         return false;
+                       }
+                       return true;
+                     });
+  return result;
+}
+
+#define FMT_STRING_IMPL(s, base, explicit)                                    \
+  [] {                                                                        \
+    /* Use the hidden visibility as a workaround for a GCC bug (#1973). */    \
+    /* Use a macro-like name to avoid shadowing warnings. */                  \
+    struct FMT_VISIBILITY("hidden") FMT_COMPILE_STRING : base {               \
+      using char_type FMT_MAYBE_UNUSED = fmt::remove_cvref_t<decltype(s[0])>; \
+      FMT_MAYBE_UNUSED FMT_CONSTEXPR explicit                                 \
+      operator fmt::basic_string_view<char_type>() const {                    \
+        return fmt::detail_exported::compile_string_to_view<char_type>(s);    \
+      }                                                                       \
+    };                                                                        \
+    return FMT_COMPILE_STRING();                                              \
+  }()
+
+/**
+  \rst
+  Constructs a compile-time format string from a string literal *s*.
+
+  **Example**::
+
+    // A compile-time error because 'd' is an invalid specifier for strings.
+    std::string s = fmt::format(FMT_STRING("{:d}"), "foo");
+  \endrst
+ */
+#define FMT_STRING(s) FMT_STRING_IMPL(s, fmt::detail::compile_string, )
+
+template <size_t width, typename Char, typename OutputIt>
+auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt {
+  *out++ = static_cast<Char>('\\');
+  *out++ = static_cast<Char>(prefix);
+  Char buf[width];
+  fill_n(buf, width, static_cast<Char>('0'));
+  format_uint<4>(buf, cp, width);
+  return copy_str<Char>(buf, buf + width, out);
+}
+
+template <typename OutputIt, typename Char>
+auto write_escaped_cp(OutputIt out, const find_escape_result<Char>& escape)
+    -> OutputIt {
+  auto c = static_cast<Char>(escape.cp);
+  switch (escape.cp) {
+  case '\n':
+    *out++ = static_cast<Char>('\\');
+    c = static_cast<Char>('n');
+    break;
+  case '\r':
+    *out++ = static_cast<Char>('\\');
+    c = static_cast<Char>('r');
+    break;
+  case '\t':
+    *out++ = static_cast<Char>('\\');
+    c = static_cast<Char>('t');
+    break;
+  case '"':
+    FMT_FALLTHROUGH;
+  case '\'':
+    FMT_FALLTHROUGH;
+  case '\\':
+    *out++ = static_cast<Char>('\\');
+    break;
+  default:
+    if (escape.cp < 0x100) {
+      return write_codepoint<2, Char>(out, 'x', escape.cp);
+    }
+    if (escape.cp < 0x10000) {
+      return write_codepoint<4, Char>(out, 'u', escape.cp);
+    }
+    if (escape.cp < 0x110000) {
+      return write_codepoint<8, Char>(out, 'U', escape.cp);
+    }
+    for (Char escape_char : basic_string_view<Char>(
+             escape.begin, to_unsigned(escape.end - escape.begin))) {
+      out = write_codepoint<2, Char>(out, 'x',
+                                     static_cast<uint32_t>(escape_char) & 0xFF);
+    }
+    return out;
+  }
+  *out++ = c;
+  return out;
+}
+
+template <typename Char, typename OutputIt>
+auto write_escaped_string(OutputIt out, basic_string_view<Char> str)
+    -> OutputIt {
+  *out++ = static_cast<Char>('"');
+  auto begin = str.begin(), end = str.end();
+  do {
+    auto escape = find_escape(begin, end);
+    out = copy_str<Char>(begin, escape.begin, out);
+    begin = escape.end;
+    if (!begin) break;
+    out = write_escaped_cp<OutputIt, Char>(out, escape);
+  } while (begin != end);
+  *out++ = static_cast<Char>('"');
+  return out;
+}
+
+template <typename Char, typename OutputIt>
+auto write_escaped_char(OutputIt out, Char v) -> OutputIt {
+  Char v_array[1] = {v};
+  *out++ = static_cast<Char>('\'');
+  if ((needs_escape(static_cast<uint32_t>(v)) && v != static_cast<Char>('"')) ||
+      v == static_cast<Char>('\'')) {
+    out = write_escaped_cp(out,
+                           find_escape_result<Char>{v_array, v_array + 1,
+                                                    static_cast<uint32_t>(v)});
+  } else {
+    *out++ = v;
+  }
+  *out++ = static_cast<Char>('\'');
+  return out;
+}
+
+template <typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write_char(OutputIt out, Char value,
+                              const format_specs<Char>& specs) -> OutputIt {
+  bool is_debug = specs.type == presentation_type::debug;
+  return write_padded(out, specs, 1, [=](reserve_iterator<OutputIt> it) {
+    if (is_debug) return write_escaped_char(it, value);
+    *it++ = value;
+    return it;
+  });
+}
+template <typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, Char value,
+                         const format_specs<Char>& specs, locale_ref loc = {})
+    -> OutputIt {
+  // char is formatted as unsigned char for consistency across platforms.
+  using unsigned_type =
+      conditional_t<std::is_same<Char, char>::value, unsigned char, unsigned>;
+  return check_char_specs(specs)
+             ? write_char(out, value, specs)
+             : write(out, static_cast<unsigned_type>(value), specs, loc);
+}
+
+// Data for write_int that doesn't depend on output iterator type. It is used to
+// avoid template code bloat.
+template <typename Char> struct write_int_data {
+  size_t size;
+  size_t padding;
+
+  FMT_CONSTEXPR write_int_data(int num_digits, unsigned prefix,
+                               const format_specs<Char>& specs)
+      : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) {
+    if (specs.align == align::numeric) {
+      auto width = to_unsigned(specs.width);
+      if (width > size) {
+        padding = width - size;
+        size = width;
+      }
+    } else if (specs.precision > num_digits) {
+      size = (prefix >> 24) + to_unsigned(specs.precision);
+      padding = to_unsigned(specs.precision - num_digits);
+    }
+  }
+};
+
+// Writes an integer in the format
+//   <left-padding><prefix><numeric-padding><digits><right-padding>
+// where <digits> are written by write_digits(it).
+// prefix contains chars in three lower bytes and the size in the fourth byte.
+template <typename OutputIt, typename Char, typename W>
+FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, int num_digits,
+                                        unsigned prefix,
+                                        const format_specs<Char>& specs,
+                                        W write_digits) -> OutputIt {
+  // Slightly faster check for specs.width == 0 && specs.precision == -1.
+  if ((specs.width | (specs.precision + 1)) == 0) {
+    auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24));
+    if (prefix != 0) {
+      for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
+        *it++ = static_cast<Char>(p & 0xff);
+    }
+    return base_iterator(out, write_digits(it));
+  }
+  auto data = write_int_data<Char>(num_digits, prefix, specs);
+  return write_padded<align::right>(
+      out, specs, data.size, [=](reserve_iterator<OutputIt> it) {
+        for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
+          *it++ = static_cast<Char>(p & 0xff);
+        it = detail::fill_n(it, data.padding, static_cast<Char>('0'));
+        return write_digits(it);
+      });
+}
+
+template <typename Char> class digit_grouping {
+ private:
+  std::string grouping_;
+  std::basic_string<Char> thousands_sep_;
+
+  struct next_state {
+    std::string::const_iterator group;
+    int pos;
+  };
+  auto initial_state() const -> next_state { return {grouping_.begin(), 0}; }
+
+  // Returns the next digit group separator position.
+  auto next(next_state& state) const -> int {
+    if (thousands_sep_.empty()) return max_value<int>();
+    if (state.group == grouping_.end()) return state.pos += grouping_.back();
+    if (*state.group <= 0 || *state.group == max_value<char>())
+      return max_value<int>();
+    state.pos += *state.group++;
+    return state.pos;
+  }
+
+ public:
+  explicit digit_grouping(locale_ref loc, bool localized = true) {
+    if (!localized) return;
+    auto sep = thousands_sep<Char>(loc);
+    grouping_ = sep.grouping;
+    if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep);
+  }
+  digit_grouping(std::string grouping, std::basic_string<Char> sep)
+      : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {}
+
+  auto has_separator() const -> bool { return !thousands_sep_.empty(); }
+
+  auto count_separators(int num_digits) const -> int {
+    int count = 0;
+    auto state = initial_state();
+    while (num_digits > next(state)) ++count;
+    return count;
+  }
+
+  // Applies grouping to digits and write the output to out.
+  template <typename Out, typename C>
+  auto apply(Out out, basic_string_view<C> digits) const -> Out {
+    auto num_digits = static_cast<int>(digits.size());
+    auto separators = basic_memory_buffer<int>();
+    separators.push_back(0);
+    auto state = initial_state();
+    while (int i = next(state)) {
+      if (i >= num_digits) break;
+      separators.push_back(i);
+    }
+    for (int i = 0, sep_index = static_cast<int>(separators.size() - 1);
+         i < num_digits; ++i) {
+      if (num_digits - i == separators[sep_index]) {
+        out =
+            copy_str<Char>(thousands_sep_.data(),
+                           thousands_sep_.data() + thousands_sep_.size(), out);
+        --sep_index;
+      }
+      *out++ = static_cast<Char>(digits[to_unsigned(i)]);
+    }
+    return out;
+  }
+};
+
+FMT_CONSTEXPR inline void prefix_append(unsigned& prefix, unsigned value) {
+  prefix |= prefix != 0 ? value << 8 : value;
+  prefix += (1u + (value > 0xff ? 1 : 0)) << 24;
+}
+
+// Writes a decimal integer with digit grouping.
+template <typename OutputIt, typename UInt, typename Char>
+auto write_int(OutputIt out, UInt value, unsigned prefix,
+               const format_specs<Char>& specs,
+               const digit_grouping<Char>& grouping) -> OutputIt {
+  static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
+  int num_digits = 0;
+  auto buffer = memory_buffer();
+  switch (specs.type) {
+  case presentation_type::none:
+  case presentation_type::dec: {
+    num_digits = count_digits(value);
+    format_decimal<char>(appender(buffer), value, num_digits);
+    break;
+  }
+  case presentation_type::hex_lower:
+  case presentation_type::hex_upper: {
+    bool upper = specs.type == presentation_type::hex_upper;
+    if (specs.alt)
+      prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0');
+    num_digits = count_digits<4>(value);
+    format_uint<4, char>(appender(buffer), value, num_digits, upper);
+    break;
+  }
+  case presentation_type::bin_lower:
+  case presentation_type::bin_upper: {
+    bool upper = specs.type == presentation_type::bin_upper;
+    if (specs.alt)
+      prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0');
+    num_digits = count_digits<1>(value);
+    format_uint<1, char>(appender(buffer), value, num_digits);
+    break;
+  }
+  case presentation_type::oct: {
+    num_digits = count_digits<3>(value);
+    // Octal prefix '0' is counted as a digit, so only add it if precision
+    // is not greater than the number of digits.
+    if (specs.alt && specs.precision <= num_digits && value != 0)
+      prefix_append(prefix, '0');
+    format_uint<3, char>(appender(buffer), value, num_digits);
+    break;
+  }
+  case presentation_type::chr:
+    return write_char(out, static_cast<Char>(value), specs);
+  default:
+    throw_format_error("invalid format specifier");
+  }
+
+  unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) +
+                  to_unsigned(grouping.count_separators(num_digits));
+  return write_padded<align::right>(
+      out, specs, size, size, [&](reserve_iterator<OutputIt> it) {
+        for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
+          *it++ = static_cast<Char>(p & 0xff);
+        return grouping.apply(it, string_view(buffer.data(), buffer.size()));
+      });
+}
+
+// Writes a localized value.
+FMT_API auto write_loc(appender out, loc_value value,
+                       const format_specs<>& specs, locale_ref loc) -> bool;
+template <typename OutputIt, typename Char>
+inline auto write_loc(OutputIt, loc_value, const format_specs<Char>&,
+                      locale_ref) -> bool {
+  return false;
+}
+
+template <typename UInt> struct write_int_arg {
+  UInt abs_value;
+  unsigned prefix;
+};
+
+template <typename T>
+FMT_CONSTEXPR auto make_write_int_arg(T value, sign_t sign)
+    -> write_int_arg<uint32_or_64_or_128_t<T>> {
+  auto prefix = 0u;
+  auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
+  if (is_negative(value)) {
+    prefix = 0x01000000 | '-';
+    abs_value = 0 - abs_value;
+  } else {
+    constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+',
+                                            0x1000000u | ' '};
+    prefix = prefixes[sign];
+  }
+  return {abs_value, prefix};
+}
+
+template <typename Char = char> struct loc_writer {
+  buffer_appender<Char> out;
+  const format_specs<Char>& specs;
+  std::basic_string<Char> sep;
+  std::string grouping;
+  std::basic_string<Char> decimal_point;
+
+  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
+  auto operator()(T value) -> bool {
+    auto arg = make_write_int_arg(value, specs.sign);
+    write_int(out, static_cast<uint64_or_128_t<T>>(arg.abs_value), arg.prefix,
+              specs, digit_grouping<Char>(grouping, sep));
+    return true;
+  }
+
+  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
+  auto operator()(T) -> bool {
+    return false;
+  }
+};
+
+template <typename Char, typename OutputIt, typename T>
+FMT_CONSTEXPR FMT_INLINE auto write_int(OutputIt out, write_int_arg<T> arg,
+                                        const format_specs<Char>& specs,
+                                        locale_ref) -> OutputIt {
+  static_assert(std::is_same<T, uint32_or_64_or_128_t<T>>::value, "");
+  auto abs_value = arg.abs_value;
+  auto prefix = arg.prefix;
+  switch (specs.type) {
+  case presentation_type::none:
+  case presentation_type::dec: {
+    auto num_digits = count_digits(abs_value);
+    return write_int(
+        out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
+          return format_decimal<Char>(it, abs_value, num_digits).end;
+        });
+  }
+  case presentation_type::hex_lower:
+  case presentation_type::hex_upper: {
+    bool upper = specs.type == presentation_type::hex_upper;
+    if (specs.alt)
+      prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0');
+    int num_digits = count_digits<4>(abs_value);
+    return write_int(
+        out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
+          return format_uint<4, Char>(it, abs_value, num_digits, upper);
+        });
+  }
+  case presentation_type::bin_lower:
+  case presentation_type::bin_upper: {
+    bool upper = specs.type == presentation_type::bin_upper;
+    if (specs.alt)
+      prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0');
+    int num_digits = count_digits<1>(abs_value);
+    return write_int(out, num_digits, prefix, specs,
+                     [=](reserve_iterator<OutputIt> it) {
+                       return format_uint<1, Char>(it, abs_value, num_digits);
+                     });
+  }
+  case presentation_type::oct: {
+    int num_digits = count_digits<3>(abs_value);
+    // Octal prefix '0' is counted as a digit, so only add it if precision
+    // is not greater than the number of digits.
+    if (specs.alt && specs.precision <= num_digits && abs_value != 0)
+      prefix_append(prefix, '0');
+    return write_int(out, num_digits, prefix, specs,
+                     [=](reserve_iterator<OutputIt> it) {
+                       return format_uint<3, Char>(it, abs_value, num_digits);
+                     });
+  }
+  case presentation_type::chr:
+    return write_char(out, static_cast<Char>(abs_value), specs);
+  default:
+    throw_format_error("invalid format specifier");
+  }
+  return out;
+}
+template <typename Char, typename OutputIt, typename T>
+FMT_CONSTEXPR FMT_NOINLINE auto write_int_noinline(
+    OutputIt out, write_int_arg<T> arg, const format_specs<Char>& specs,
+    locale_ref loc) -> OutputIt {
+  return write_int(out, arg, specs, loc);
+}
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(is_integral<T>::value &&
+                        !std::is_same<T, bool>::value &&
+                        std::is_same<OutputIt, buffer_appender<Char>>::value)>
+FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value,
+                                    const format_specs<Char>& specs,
+                                    locale_ref loc) -> OutputIt {
+  if (specs.localized && write_loc(out, value, specs, loc)) return out;
+  return write_int_noinline(out, make_write_int_arg(value, specs.sign), specs,
+                            loc);
+}
+// An inlined version of write used in format string compilation.
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(is_integral<T>::value &&
+                        !std::is_same<T, bool>::value &&
+                        !std::is_same<OutputIt, buffer_appender<Char>>::value)>
+FMT_CONSTEXPR FMT_INLINE auto write(OutputIt out, T value,
+                                    const format_specs<Char>& specs,
+                                    locale_ref loc) -> OutputIt {
+  if (specs.localized && write_loc(out, value, specs, loc)) return out;
+  return write_int(out, make_write_int_arg(value, specs.sign), specs, loc);
+}
+
+// An output iterator that counts the number of objects written to it and
+// discards them.
+class counting_iterator {
+ private:
+  size_t count_;
+
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using difference_type = std::ptrdiff_t;
+  using pointer = void;
+  using reference = void;
+  FMT_UNCHECKED_ITERATOR(counting_iterator);
+
+  struct value_type {
+    template <typename T> FMT_CONSTEXPR void operator=(const T&) {}
+  };
+
+  FMT_CONSTEXPR counting_iterator() : count_(0) {}
+
+  FMT_CONSTEXPR auto count() const -> size_t { return count_; }
+
+  FMT_CONSTEXPR auto operator++() -> counting_iterator& {
+    ++count_;
+    return *this;
+  }
+  FMT_CONSTEXPR auto operator++(int) -> counting_iterator {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
+
+  FMT_CONSTEXPR friend auto operator+(counting_iterator it, difference_type n)
+      -> counting_iterator {
+    it.count_ += static_cast<size_t>(n);
+    return it;
+  }
+
+  FMT_CONSTEXPR auto operator*() const -> value_type { return {}; }
+};
+
+template <typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> s,
+                         const format_specs<Char>& specs) -> OutputIt {
+  auto data = s.data();
+  auto size = s.size();
+  if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
+    size = code_point_index(s, to_unsigned(specs.precision));
+  bool is_debug = specs.type == presentation_type::debug;
+  size_t width = 0;
+  if (specs.width != 0) {
+    if (is_debug)
+      width = write_escaped_string(counting_iterator{}, s).count();
+    else
+      width = compute_width(basic_string_view<Char>(data, size));
+  }
+  return write_padded(out, specs, size, width,
+                      [=](reserve_iterator<OutputIt> it) {
+                        if (is_debug) return write_escaped_string(it, s);
+                        return copy_str<Char>(data, data + size, it);
+                      });
+}
+template <typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out,
+                         basic_string_view<type_identity_t<Char>> s,
+                         const format_specs<Char>& specs, locale_ref)
+    -> OutputIt {
+  return write(out, s, specs);
+}
+template <typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, const Char* s,
+                         const format_specs<Char>& specs, locale_ref)
+    -> OutputIt {
+  if (specs.type == presentation_type::pointer)
+    return write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs);
+  if (!s) throw_format_error("string pointer is null");
+  return write(out, basic_string_view<Char>(s), specs, {});
+}
+
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(is_integral<T>::value &&
+                        !std::is_same<T, bool>::value &&
+                        !std::is_same<T, Char>::value)>
+FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
+  auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
+  bool negative = is_negative(value);
+  // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
+  if (negative) abs_value = ~abs_value + 1;
+  int num_digits = count_digits(abs_value);
+  auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits);
+  auto it = reserve(out, size);
+  if (auto ptr = to_pointer<Char>(it, size)) {
+    if (negative) *ptr++ = static_cast<Char>('-');
+    format_decimal<Char>(ptr, abs_value, num_digits);
+    return out;
+  }
+  if (negative) *it++ = static_cast<Char>('-');
+  it = format_decimal<Char>(it, abs_value, num_digits).end;
+  return base_iterator(out, it);
+}
+
+// DEPRECATED!
+template <typename Char>
+FMT_CONSTEXPR auto parse_align(const Char* begin, const Char* end,
+                               format_specs<Char>& specs) -> const Char* {
+  FMT_ASSERT(begin != end, "");
+  auto align = align::none;
+  auto p = begin + code_point_length(begin);
+  if (end - p <= 0) p = begin;
+  for (;;) {
+    switch (to_ascii(*p)) {
+    case '<':
+      align = align::left;
+      break;
+    case '>':
+      align = align::right;
+      break;
+    case '^':
+      align = align::center;
+      break;
+    }
+    if (align != align::none) {
+      if (p != begin) {
+        auto c = *begin;
+        if (c == '}') return begin;
+        if (c == '{') {
+          throw_format_error("invalid fill character '{'");
+          return begin;
+        }
+        specs.fill = {begin, to_unsigned(p - begin)};
+        begin = p + 1;
+      } else {
+        ++begin;
+      }
+      break;
+    } else if (p == begin) {
+      break;
+    }
+    p = begin;
+  }
+  specs.align = align;
+  return begin;
+}
+
+// A floating-point presentation format.
+enum class float_format : unsigned char {
+  general,  // General: exponent notation or fixed point based on magnitude.
+  exp,      // Exponent notation with the default precision of 6, e.g. 1.2e-3.
+  fixed,    // Fixed point with the default precision of 6, e.g. 0.0012.
+  hex
+};
+
+struct float_specs {
+  int precision;
+  float_format format : 8;
+  sign_t sign : 8;
+  bool upper : 1;
+  bool locale : 1;
+  bool binary32 : 1;
+  bool showpoint : 1;
+};
+
+template <typename Char>
+FMT_CONSTEXPR auto parse_float_type_spec(const format_specs<Char>& specs)
+    -> float_specs {
+  auto result = float_specs();
+  result.showpoint = specs.alt;
+  result.locale = specs.localized;
+  switch (specs.type) {
+  case presentation_type::none:
+    result.format = float_format::general;
+    break;
+  case presentation_type::general_upper:
+    result.upper = true;
+    FMT_FALLTHROUGH;
+  case presentation_type::general_lower:
+    result.format = float_format::general;
+    break;
+  case presentation_type::exp_upper:
+    result.upper = true;
+    FMT_FALLTHROUGH;
+  case presentation_type::exp_lower:
+    result.format = float_format::exp;
+    result.showpoint |= specs.precision != 0;
+    break;
+  case presentation_type::fixed_upper:
+    result.upper = true;
+    FMT_FALLTHROUGH;
+  case presentation_type::fixed_lower:
+    result.format = float_format::fixed;
+    result.showpoint |= specs.precision != 0;
+    break;
+  case presentation_type::hexfloat_upper:
+    result.upper = true;
+    FMT_FALLTHROUGH;
+  case presentation_type::hexfloat_lower:
+    result.format = float_format::hex;
+    break;
+  default:
+    throw_format_error("invalid format specifier");
+    break;
+  }
+  return result;
+}
+
+template <typename Char, typename OutputIt>
+FMT_CONSTEXPR20 auto write_nonfinite(OutputIt out, bool isnan,
+                                     format_specs<Char> specs,
+                                     const float_specs& fspecs) -> OutputIt {
+  auto str =
+      isnan ? (fspecs.upper ? "NAN" : "nan") : (fspecs.upper ? "INF" : "inf");
+  constexpr size_t str_size = 3;
+  auto sign = fspecs.sign;
+  auto size = str_size + (sign ? 1 : 0);
+  // Replace '0'-padding with space for non-finite values.
+  const bool is_zero_fill =
+      specs.fill.size() == 1 && *specs.fill.data() == static_cast<Char>('0');
+  if (is_zero_fill) specs.fill[0] = static_cast<Char>(' ');
+  return write_padded(out, specs, size, [=](reserve_iterator<OutputIt> it) {
+    if (sign) *it++ = detail::sign<Char>(sign);
+    return copy_str<Char>(str, str + str_size, it);
+  });
+}
+
+// A decimal floating-point number significand * pow(10, exp).
+struct big_decimal_fp {
+  const char* significand;
+  int significand_size;
+  int exponent;
+};
+
+constexpr auto get_significand_size(const big_decimal_fp& f) -> int {
+  return f.significand_size;
+}
+template <typename T>
+inline auto get_significand_size(const dragonbox::decimal_fp<T>& f) -> int {
+  return count_digits(f.significand);
+}
+
+template <typename Char, typename OutputIt>
+constexpr auto write_significand(OutputIt out, const char* significand,
+                                 int significand_size) -> OutputIt {
+  return copy_str<Char>(significand, significand + significand_size, out);
+}
+template <typename Char, typename OutputIt, typename UInt>
+inline auto write_significand(OutputIt out, UInt significand,
+                              int significand_size) -> OutputIt {
+  return format_decimal<Char>(out, significand, significand_size).end;
+}
+template <typename Char, typename OutputIt, typename T, typename Grouping>
+FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
+                                       int significand_size, int exponent,
+                                       const Grouping& grouping) -> OutputIt {
+  if (!grouping.has_separator()) {
+    out = write_significand<Char>(out, significand, significand_size);
+    return detail::fill_n(out, exponent, static_cast<Char>('0'));
+  }
+  auto buffer = memory_buffer();
+  write_significand<char>(appender(buffer), significand, significand_size);
+  detail::fill_n(appender(buffer), exponent, '0');
+  return grouping.apply(out, string_view(buffer.data(), buffer.size()));
+}
+
+template <typename Char, typename UInt,
+          FMT_ENABLE_IF(std::is_integral<UInt>::value)>
+inline auto write_significand(Char* out, UInt significand, int significand_size,
+                              int integral_size, Char decimal_point) -> Char* {
+  if (!decimal_point)
+    return format_decimal(out, significand, significand_size).end;
+  out += significand_size + 1;
+  Char* end = out;
+  int floating_size = significand_size - integral_size;
+  for (int i = floating_size / 2; i > 0; --i) {
+    out -= 2;
+    copy2(out, digits2(static_cast<std::size_t>(significand % 100)));
+    significand /= 100;
+  }
+  if (floating_size % 2 != 0) {
+    *--out = static_cast<Char>('0' + significand % 10);
+    significand /= 10;
+  }
+  *--out = decimal_point;
+  format_decimal(out - integral_size, significand, integral_size);
+  return end;
+}
+
+template <typename OutputIt, typename UInt, typename Char,
+          FMT_ENABLE_IF(!std::is_pointer<remove_cvref_t<OutputIt>>::value)>
+inline auto write_significand(OutputIt out, UInt significand,
+                              int significand_size, int integral_size,
+                              Char decimal_point) -> OutputIt {
+  // Buffer is large enough to hold digits (digits10 + 1) and a decimal point.
+  Char buffer[digits10<UInt>() + 2];
+  auto end = write_significand(buffer, significand, significand_size,
+                               integral_size, decimal_point);
+  return detail::copy_str_noinline<Char>(buffer, end, out);
+}
+
+template <typename OutputIt, typename Char>
+FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand,
+                                     int significand_size, int integral_size,
+                                     Char decimal_point) -> OutputIt {
+  out = detail::copy_str_noinline<Char>(significand,
+                                        significand + integral_size, out);
+  if (!decimal_point) return out;
+  *out++ = decimal_point;
+  return detail::copy_str_noinline<Char>(significand + integral_size,
+                                         significand + significand_size, out);
+}
+
+template <typename OutputIt, typename Char, typename T, typename Grouping>
+FMT_CONSTEXPR20 auto write_significand(OutputIt out, T significand,
+                                       int significand_size, int integral_size,
+                                       Char decimal_point,
+                                       const Grouping& grouping) -> OutputIt {
+  if (!grouping.has_separator()) {
+    return write_significand(out, significand, significand_size, integral_size,
+                             decimal_point);
+  }
+  auto buffer = basic_memory_buffer<Char>();
+  write_significand(buffer_appender<Char>(buffer), significand,
+                    significand_size, integral_size, decimal_point);
+  grouping.apply(
+      out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
+  return detail::copy_str_noinline<Char>(buffer.data() + integral_size,
+                                         buffer.end(), out);
+}
+
+template <typename OutputIt, typename DecimalFP, typename Char,
+          typename Grouping = digit_grouping<Char>>
+FMT_CONSTEXPR20 auto do_write_float(OutputIt out, const DecimalFP& f,
+                                    const format_specs<Char>& specs,
+                                    float_specs fspecs, locale_ref loc)
+    -> OutputIt {
+  auto significand = f.significand;
+  int significand_size = get_significand_size(f);
+  const Char zero = static_cast<Char>('0');
+  auto sign = fspecs.sign;
+  size_t size = to_unsigned(significand_size) + (sign ? 1 : 0);
+  using iterator = reserve_iterator<OutputIt>;
+
+  Char decimal_point =
+      fspecs.locale ? detail::decimal_point<Char>(loc) : static_cast<Char>('.');
+
+  int output_exp = f.exponent + significand_size - 1;
+  auto use_exp_format = [=]() {
+    if (fspecs.format == float_format::exp) return true;
+    if (fspecs.format != float_format::general) return false;
+    // Use the fixed notation if the exponent is in [exp_lower, exp_upper),
+    // e.g. 0.0001 instead of 1e-04. Otherwise use the exponent notation.
+    const int exp_lower = -4, exp_upper = 16;
+    return output_exp < exp_lower ||
+           output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper);
+  };
+  if (use_exp_format()) {
+    int num_zeros = 0;
+    if (fspecs.showpoint) {
+      num_zeros = fspecs.precision - significand_size;
+      if (num_zeros < 0) num_zeros = 0;
+      size += to_unsigned(num_zeros);
+    } else if (significand_size == 1) {
+      decimal_point = Char();
+    }
+    auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
+    int exp_digits = 2;
+    if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;
+
+    size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
+    char exp_char = fspecs.upper ? 'E' : 'e';
+    auto write = [=](iterator it) {
+      if (sign) *it++ = detail::sign<Char>(sign);
+      // Insert a decimal point after the first digit and add an exponent.
+      it = write_significand(it, significand, significand_size, 1,
+                             decimal_point);
+      if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero);
+      *it++ = static_cast<Char>(exp_char);
+      return write_exponent<Char>(output_exp, it);
+    };
+    return specs.width > 0 ? write_padded<align::right>(out, specs, size, write)
+                           : base_iterator(out, write(reserve(out, size)));
+  }
+
+  int exp = f.exponent + significand_size;
+  if (f.exponent >= 0) {
+    // 1234e5 -> 123400000[.0+]
+    size += to_unsigned(f.exponent);
+    int num_zeros = fspecs.precision - exp;
+    abort_fuzzing_if(num_zeros > 5000);
+    if (fspecs.showpoint) {
+      ++size;
+      if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 0;
+      if (num_zeros > 0) size += to_unsigned(num_zeros);
+    }
+    auto grouping = Grouping(loc, fspecs.locale);
+    size += to_unsigned(grouping.count_separators(exp));
+    return write_padded<align::right>(out, specs, size, [&](iterator it) {
+      if (sign) *it++ = detail::sign<Char>(sign);
+      it = write_significand<Char>(it, significand, significand_size,
+                                   f.exponent, grouping);
+      if (!fspecs.showpoint) return it;
+      *it++ = decimal_point;
+      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
+    });
+  } else if (exp > 0) {
+    // 1234e-2 -> 12.34[0+]
+    int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0;
+    size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0);
+    auto grouping = Grouping(loc, fspecs.locale);
+    size += to_unsigned(grouping.count_separators(exp));
+    return write_padded<align::right>(out, specs, size, [&](iterator it) {
+      if (sign) *it++ = detail::sign<Char>(sign);
+      it = write_significand(it, significand, significand_size, exp,
+                             decimal_point, grouping);
+      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
+    });
+  }
+  // 1234e-6 -> 0.001234
+  int num_zeros = -exp;
+  if (significand_size == 0 && fspecs.precision >= 0 &&
+      fspecs.precision < num_zeros) {
+    num_zeros = fspecs.precision;
+  }
+  bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint;
+  size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros);
+  return write_padded<align::right>(out, specs, size, [&](iterator it) {
+    if (sign) *it++ = detail::sign<Char>(sign);
+    *it++ = zero;
+    if (!pointy) return it;
+    *it++ = decimal_point;
+    it = detail::fill_n(it, num_zeros, zero);
+    return write_significand<Char>(it, significand, significand_size);
+  });
+}
+
+template <typename Char> class fallback_digit_grouping {
+ public:
+  constexpr fallback_digit_grouping(locale_ref, bool) {}
+
+  constexpr auto has_separator() const -> bool { return false; }
+
+  constexpr auto count_separators(int) const -> int { return 0; }
+
+  template <typename Out, typename C>
+  constexpr auto apply(Out out, basic_string_view<C>) const -> Out {
+    return out;
+  }
+};
+
+template <typename OutputIt, typename DecimalFP, typename Char>
+FMT_CONSTEXPR20 auto write_float(OutputIt out, const DecimalFP& f,
+                                 const format_specs<Char>& specs,
+                                 float_specs fspecs, locale_ref loc)
+    -> OutputIt {
+  if (is_constant_evaluated()) {
+    return do_write_float<OutputIt, DecimalFP, Char,
+                          fallback_digit_grouping<Char>>(out, f, specs, fspecs,
+                                                         loc);
+  } else {
+    return do_write_float(out, f, specs, fspecs, loc);
+  }
+}
+
+template <typename T> constexpr auto isnan(T value) -> bool {
+  return !(value >= value);  // std::isnan doesn't support __float128.
+}
+
+template <typename T, typename Enable = void>
+struct has_isfinite : std::false_type {};
+
+template <typename T>
+struct has_isfinite<T, enable_if_t<sizeof(std::isfinite(T())) != 0>>
+    : std::true_type {};
+
+template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value&&
+                                        has_isfinite<T>::value)>
+FMT_CONSTEXPR20 auto isfinite(T value) -> bool {
+  constexpr T inf = T(std::numeric_limits<double>::infinity());
+  if (is_constant_evaluated())
+    return !detail::isnan(value) && value < inf && value > -inf;
+  return std::isfinite(value);
+}
+template <typename T, FMT_ENABLE_IF(!has_isfinite<T>::value)>
+FMT_CONSTEXPR auto isfinite(T value) -> bool {
+  T inf = T(std::numeric_limits<double>::infinity());
+  // std::isfinite doesn't support __float128.
+  return !detail::isnan(value) && value < inf && value > -inf;
+}
+
+template <typename T, FMT_ENABLE_IF(is_floating_point<T>::value)>
+FMT_INLINE FMT_CONSTEXPR bool signbit(T value) {
+  if (is_constant_evaluated()) {
+#ifdef __cpp_if_constexpr
+    if constexpr (std::numeric_limits<double>::is_iec559) {
+      auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value));
+      return (bits >> (num_bits<uint64_t>() - 1)) != 0;
+    }
+#endif
+  }
+  return std::signbit(static_cast<double>(value));
+}
+
+inline FMT_CONSTEXPR20 void adjust_precision(int& precision, int exp10) {
+  // Adjust fixed precision by exponent because it is relative to decimal
+  // point.
+  if (exp10 > 0 && precision > max_value<int>() - exp10)
+    FMT_THROW(format_error("number is too big"));
+  precision += exp10;
+}
+
+class bigint {
+ private:
+  // A bigint is stored as an array of bigits (big digits), with bigit at index
+  // 0 being the least significant one.
+  using bigit = uint32_t;
+  using double_bigit = uint64_t;
+  enum { bigits_capacity = 32 };
+  basic_memory_buffer<bigit, bigits_capacity> bigits_;
+  int exp_;
+
+  FMT_CONSTEXPR20 auto operator[](int index) const -> bigit {
+    return bigits_[to_unsigned(index)];
+  }
+  FMT_CONSTEXPR20 auto operator[](int index) -> bigit& {
+    return bigits_[to_unsigned(index)];
+  }
+
+  static constexpr const int bigit_bits = num_bits<bigit>();
+
+  friend struct formatter<bigint>;
+
+  FMT_CONSTEXPR20 void subtract_bigits(int index, bigit other, bigit& borrow) {
+    auto result = static_cast<double_bigit>((*this)[index]) - other - borrow;
+    (*this)[index] = static_cast<bigit>(result);
+    borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
+  }
+
+  FMT_CONSTEXPR20 void remove_leading_zeros() {
+    int num_bigits = static_cast<int>(bigits_.size()) - 1;
+    while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;
+    bigits_.resize(to_unsigned(num_bigits + 1));
+  }
+
+  // Computes *this -= other assuming aligned bigints and *this >= other.
+  FMT_CONSTEXPR20 void subtract_aligned(const bigint& other) {
+    FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
+    FMT_ASSERT(compare(*this, other) >= 0, "");
+    bigit borrow = 0;
+    int i = other.exp_ - exp_;
+    for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
+      subtract_bigits(i, other.bigits_[j], borrow);
+    while (borrow > 0) subtract_bigits(i, 0, borrow);
+    remove_leading_zeros();
+  }
+
+  FMT_CONSTEXPR20 void multiply(uint32_t value) {
+    const double_bigit wide_value = value;
+    bigit carry = 0;
+    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
+      double_bigit result = bigits_[i] * wide_value + carry;
+      bigits_[i] = static_cast<bigit>(result);
+      carry = static_cast<bigit>(result >> bigit_bits);
+    }
+    if (carry != 0) bigits_.push_back(carry);
+  }
+
+  template <typename UInt, FMT_ENABLE_IF(std::is_same<UInt, uint64_t>::value ||
+                                         std::is_same<UInt, uint128_t>::value)>
+  FMT_CONSTEXPR20 void multiply(UInt value) {
+    using half_uint =
+        conditional_t<std::is_same<UInt, uint128_t>::value, uint64_t, uint32_t>;
+    const int shift = num_bits<half_uint>() - bigit_bits;
+    const UInt lower = static_cast<half_uint>(value);
+    const UInt upper = value >> num_bits<half_uint>();
+    UInt carry = 0;
+    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
+      UInt result = lower * bigits_[i] + static_cast<bigit>(carry);
+      carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) +
+              (carry >> bigit_bits);
+      bigits_[i] = static_cast<bigit>(result);
+    }
+    while (carry != 0) {
+      bigits_.push_back(static_cast<bigit>(carry));
+      carry >>= bigit_bits;
+    }
+  }
+
+  template <typename UInt, FMT_ENABLE_IF(std::is_same<UInt, uint64_t>::value ||
+                                         std::is_same<UInt, uint128_t>::value)>
+  FMT_CONSTEXPR20 void assign(UInt n) {
+    size_t num_bigits = 0;
+    do {
+      bigits_[num_bigits++] = static_cast<bigit>(n);
+      n >>= bigit_bits;
+    } while (n != 0);
+    bigits_.resize(num_bigits);
+    exp_ = 0;
+  }
+
+ public:
+  FMT_CONSTEXPR20 bigint() : exp_(0) {}
+  explicit bigint(uint64_t n) { assign(n); }
+
+  bigint(const bigint&) = delete;
+  void operator=(const bigint&) = delete;
+
+  FMT_CONSTEXPR20 void assign(const bigint& other) {
+    auto size = other.bigits_.size();
+    bigits_.resize(size);
+    auto data = other.bigits_.data();
+    copy_str<bigit>(data, data + size, bigits_.data());
+    exp_ = other.exp_;
+  }
+
+  template <typename Int> FMT_CONSTEXPR20 void operator=(Int n) {
+    FMT_ASSERT(n > 0, "");
+    assign(uint64_or_128_t<Int>(n));
+  }
+
+  FMT_CONSTEXPR20 auto num_bigits() const -> int {
+    return static_cast<int>(bigits_.size()) + exp_;
+  }
+
+  FMT_NOINLINE FMT_CONSTEXPR20 auto operator<<=(int shift) -> bigint& {
+    FMT_ASSERT(shift >= 0, "");
+    exp_ += shift / bigit_bits;
+    shift %= bigit_bits;
+    if (shift == 0) return *this;
+    bigit carry = 0;
+    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
+      bigit c = bigits_[i] >> (bigit_bits - shift);
+      bigits_[i] = (bigits_[i] << shift) + carry;
+      carry = c;
+    }
+    if (carry != 0) bigits_.push_back(carry);
+    return *this;
+  }
+
+  template <typename Int>
+  FMT_CONSTEXPR20 auto operator*=(Int value) -> bigint& {
+    FMT_ASSERT(value > 0, "");
+    multiply(uint32_or_64_or_128_t<Int>(value));
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR20 auto compare(const bigint& lhs, const bigint& rhs)
+      -> int {
+    int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
+    if (num_lhs_bigits != num_rhs_bigits)
+      return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
+    int i = static_cast<int>(lhs.bigits_.size()) - 1;
+    int j = static_cast<int>(rhs.bigits_.size()) - 1;
+    int end = i - j;
+    if (end < 0) end = 0;
+    for (; i >= end; --i, --j) {
+      bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j];
+      if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1;
+    }
+    if (i != j) return i > j ? 1 : -1;
+    return 0;
+  }
+
+  // Returns compare(lhs1 + lhs2, rhs).
+  friend FMT_CONSTEXPR20 auto add_compare(const bigint& lhs1,
+                                          const bigint& lhs2, const bigint& rhs)
+      -> int {
+    auto minimum = [](int a, int b) { return a < b ? a : b; };
+    auto maximum = [](int a, int b) { return a > b ? a : b; };
+    int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits());
+    int num_rhs_bigits = rhs.num_bigits();
+    if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
+    if (max_lhs_bigits > num_rhs_bigits) return 1;
+    auto get_bigit = [](const bigint& n, int i) -> bigit {
+      return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0;
+    };
+    double_bigit borrow = 0;
+    int min_exp = minimum(minimum(lhs1.exp_, lhs2.exp_), rhs.exp_);
+    for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
+      double_bigit sum =
+          static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
+      bigit rhs_bigit = get_bigit(rhs, i);
+      if (sum > rhs_bigit + borrow) return 1;
+      borrow = rhs_bigit + borrow - sum;
+      if (borrow > 1) return -1;
+      borrow <<= bigit_bits;
+    }
+    return borrow != 0 ? -1 : 0;
+  }
+
+  // Assigns pow(10, exp) to this bigint.
+  FMT_CONSTEXPR20 void assign_pow10(int exp) {
+    FMT_ASSERT(exp >= 0, "");
+    if (exp == 0) return *this = 1;
+    // Find the top bit.
+    int bitmask = 1;
+    while (exp >= bitmask) bitmask <<= 1;
+    bitmask >>= 1;
+    // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
+    // repeated squaring and multiplication.
+    *this = 5;
+    bitmask >>= 1;
+    while (bitmask != 0) {
+      square();
+      if ((exp & bitmask) != 0) *this *= 5;
+      bitmask >>= 1;
+    }
+    *this <<= exp;  // Multiply by pow(2, exp) by shifting.
+  }
+
+  FMT_CONSTEXPR20 void square() {
+    int num_bigits = static_cast<int>(bigits_.size());
+    int num_result_bigits = 2 * num_bigits;
+    basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
+    bigits_.resize(to_unsigned(num_result_bigits));
+    auto sum = uint128_t();
+    for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
+      // Compute bigit at position bigit_index of the result by adding
+      // cross-product terms n[i] * n[j] such that i + j == bigit_index.
+      for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
+        // Most terms are multiplied twice which can be optimized in the future.
+        sum += static_cast<double_bigit>(n[i]) * n[j];
+      }
+      (*this)[bigit_index] = static_cast<bigit>(sum);
+      sum >>= num_bits<bigit>();  // Compute the carry.
+    }
+    // Do the same for the top half.
+    for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
+         ++bigit_index) {
+      for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
+        sum += static_cast<double_bigit>(n[i++]) * n[j--];
+      (*this)[bigit_index] = static_cast<bigit>(sum);
+      sum >>= num_bits<bigit>();
+    }
+    remove_leading_zeros();
+    exp_ *= 2;
+  }
+
+  // If this bigint has a bigger exponent than other, adds trailing zero to make
+  // exponents equal. This simplifies some operations such as subtraction.
+  FMT_CONSTEXPR20 void align(const bigint& other) {
+    int exp_difference = exp_ - other.exp_;
+    if (exp_difference <= 0) return;
+    int num_bigits = static_cast<int>(bigits_.size());
+    bigits_.resize(to_unsigned(num_bigits + exp_difference));
+    for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
+      bigits_[j] = bigits_[i];
+    std::uninitialized_fill_n(bigits_.data(), exp_difference, 0u);
+    exp_ -= exp_difference;
+  }
+
+  // Divides this bignum by divisor, assigning the remainder to this and
+  // returning the quotient.
+  FMT_CONSTEXPR20 auto divmod_assign(const bigint& divisor) -> int {
+    FMT_ASSERT(this != &divisor, "");
+    if (compare(*this, divisor) < 0) return 0;
+    FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
+    align(divisor);
+    int quotient = 0;
+    do {
+      subtract_aligned(divisor);
+      ++quotient;
+    } while (compare(*this, divisor) >= 0);
+    return quotient;
+  }
+};
+
+// format_dragon flags.
+enum dragon {
+  predecessor_closer = 1,
+  fixup = 2,  // Run fixup to correct exp10 which can be off by one.
+  fixed = 4,
+};
+
+// Formats a floating-point number using a variation of the Fixed-Precision
+// Positive Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
+// https://fmt.dev/papers/p372-steele.pdf.
+FMT_CONSTEXPR20 inline void format_dragon(basic_fp<uint128_t> value,
+                                          unsigned flags, int num_digits,
+                                          buffer<char>& buf, int& exp10) {
+  bigint numerator;    // 2 * R in (FPP)^2.
+  bigint denominator;  // 2 * S in (FPP)^2.
+  // lower and upper are differences between value and corresponding boundaries.
+  bigint lower;             // (M^- in (FPP)^2).
+  bigint upper_store;       // upper's value if different from lower.
+  bigint* upper = nullptr;  // (M^+ in (FPP)^2).
+  // Shift numerator and denominator by an extra bit or two (if lower boundary
+  // is closer) to make lower and upper integers. This eliminates multiplication
+  // by 2 during later computations.
+  bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0;
+  int shift = is_predecessor_closer ? 2 : 1;
+  if (value.e >= 0) {
+    numerator = value.f;
+    numerator <<= value.e + shift;
+    lower = 1;
+    lower <<= value.e;
+    if (is_predecessor_closer) {
+      upper_store = 1;
+      upper_store <<= value.e + 1;
+      upper = &upper_store;
+    }
+    denominator.assign_pow10(exp10);
+    denominator <<= shift;
+  } else if (exp10 < 0) {
+    numerator.assign_pow10(-exp10);
+    lower.assign(numerator);
+    if (is_predecessor_closer) {
+      upper_store.assign(numerator);
+      upper_store <<= 1;
+      upper = &upper_store;
+    }
+    numerator *= value.f;
+    numerator <<= shift;
+    denominator = 1;
+    denominator <<= shift - value.e;
+  } else {
+    numerator = value.f;
+    numerator <<= shift;
+    denominator.assign_pow10(exp10);
+    denominator <<= shift - value.e;
+    lower = 1;
+    if (is_predecessor_closer) {
+      upper_store = 1ULL << 1;
+      upper = &upper_store;
+    }
+  }
+  int even = static_cast<int>((value.f & 1) == 0);
+  if (!upper) upper = &lower;
+  bool shortest = num_digits < 0;
+  if ((flags & dragon::fixup) != 0) {
+    if (add_compare(numerator, *upper, denominator) + even <= 0) {
+      --exp10;
+      numerator *= 10;
+      if (num_digits < 0) {
+        lower *= 10;
+        if (upper != &lower) *upper *= 10;
+      }
+    }
+    if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1);
+  }
+  // Invariant: value == (numerator / denominator) * pow(10, exp10).
+  if (shortest) {
+    // Generate the shortest representation.
+    num_digits = 0;
+    char* data = buf.data();
+    for (;;) {
+      int digit = numerator.divmod_assign(denominator);
+      bool low = compare(numerator, lower) - even < 0;  // numerator <[=] lower.
+      // numerator + upper >[=] pow10:
+      bool high = add_compare(numerator, *upper, denominator) + even > 0;
+      data[num_digits++] = static_cast<char>('0' + digit);
+      if (low || high) {
+        if (!low) {
+          ++data[num_digits - 1];
+        } else if (high) {
+          int result = add_compare(numerator, numerator, denominator);
+          // Round half to even.
+          if (result > 0 || (result == 0 && (digit % 2) != 0))
+            ++data[num_digits - 1];
+        }
+        buf.try_resize(to_unsigned(num_digits));
+        exp10 -= num_digits - 1;
+        return;
+      }
+      numerator *= 10;
+      lower *= 10;
+      if (upper != &lower) *upper *= 10;
+    }
+  }
+  // Generate the given number of digits.
+  exp10 -= num_digits - 1;
+  if (num_digits <= 0) {
+    denominator *= 10;
+    auto digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
+    buf.push_back(digit);
+    return;
+  }
+  buf.try_resize(to_unsigned(num_digits));
+  for (int i = 0; i < num_digits - 1; ++i) {
+    int digit = numerator.divmod_assign(denominator);
+    buf[i] = static_cast<char>('0' + digit);
+    numerator *= 10;
+  }
+  int digit = numerator.divmod_assign(denominator);
+  auto result = add_compare(numerator, numerator, denominator);
+  if (result > 0 || (result == 0 && (digit % 2) != 0)) {
+    if (digit == 9) {
+      const auto overflow = '0' + 10;
+      buf[num_digits - 1] = overflow;
+      // Propagate the carry.
+      for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) {
+        buf[i] = '0';
+        ++buf[i - 1];
+      }
+      if (buf[0] == overflow) {
+        buf[0] = '1';
+        if ((flags & dragon::fixed) != 0)
+          buf.push_back('0');
+        else
+          ++exp10;
+      }
+      return;
+    }
+    ++digit;
+  }
+  buf[num_digits - 1] = static_cast<char>('0' + digit);
+}
+
+// Formats a floating-point number using the hexfloat format.
+template <typename Float, FMT_ENABLE_IF(!is_double_double<Float>::value)>
+FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision,
+                                     float_specs specs, buffer<char>& buf) {
+  // float is passed as double to reduce the number of instantiations and to
+  // simplify implementation.
+  static_assert(!std::is_same<Float, float>::value, "");
+
+  using info = dragonbox::float_info<Float>;
+
+  // Assume Float is in the format [sign][exponent][significand].
+  using carrier_uint = typename info::carrier_uint;
+
+  constexpr auto num_float_significand_bits =
+      detail::num_significand_bits<Float>();
+
+  basic_fp<carrier_uint> f(value);
+  f.e += num_float_significand_bits;
+  if (!has_implicit_bit<Float>()) --f.e;
+
+  constexpr auto num_fraction_bits =
+      num_float_significand_bits + (has_implicit_bit<Float>() ? 1 : 0);
+  constexpr auto num_xdigits = (num_fraction_bits + 3) / 4;
+
+  constexpr auto leading_shift = ((num_xdigits - 1) * 4);
+  const auto leading_mask = carrier_uint(0xF) << leading_shift;
+  const auto leading_xdigit =
+      static_cast<uint32_t>((f.f & leading_mask) >> leading_shift);
+  if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1);
+
+  int print_xdigits = num_xdigits - 1;
+  if (precision >= 0 && print_xdigits > precision) {
+    const int shift = ((print_xdigits - precision - 1) * 4);
+    const auto mask = carrier_uint(0xF) << shift;
+    const auto v = static_cast<uint32_t>((f.f & mask) >> shift);
+
+    if (v >= 8) {
+      const auto inc = carrier_uint(1) << (shift + 4);
+      f.f += inc;
+      f.f &= ~(inc - 1);
+    }
+
+    // Check long double overflow
+    if (!has_implicit_bit<Float>()) {
+      const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
+      if ((f.f & implicit_bit) == implicit_bit) {
+        f.f >>= 4;
+        f.e += 4;
+      }
+    }
+
+    print_xdigits = precision;
+  }
+
+  char xdigits[num_bits<carrier_uint>() / 4];
+  detail::fill_n(xdigits, sizeof(xdigits), '0');
+  format_uint<4>(xdigits, f.f, num_xdigits, specs.upper);
+
+  // Remove zero tail
+  while (print_xdigits > 0 && xdigits[print_xdigits] == '0') --print_xdigits;
+
+  buf.push_back('0');
+  buf.push_back(specs.upper ? 'X' : 'x');
+  buf.push_back(xdigits[0]);
+  if (specs.showpoint || print_xdigits > 0 || print_xdigits < precision)
+    buf.push_back('.');
+  buf.append(xdigits + 1, xdigits + 1 + print_xdigits);
+  for (; print_xdigits < precision; ++print_xdigits) buf.push_back('0');
+
+  buf.push_back(specs.upper ? 'P' : 'p');
+
+  uint32_t abs_e;
+  if (f.e < 0) {
+    buf.push_back('-');
+    abs_e = static_cast<uint32_t>(-f.e);
+  } else {
+    buf.push_back('+');
+    abs_e = static_cast<uint32_t>(f.e);
+  }
+  format_decimal<char>(appender(buf), abs_e, detail::count_digits(abs_e));
+}
+
+template <typename Float, FMT_ENABLE_IF(is_double_double<Float>::value)>
+FMT_CONSTEXPR20 void format_hexfloat(Float value, int precision,
+                                     float_specs specs, buffer<char>& buf) {
+  format_hexfloat(static_cast<double>(value), precision, specs, buf);
+}
+
+constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t {
+  // For checking rounding thresholds.
+  // The kth entry is chosen to be the smallest integer such that the
+  // upper 32-bits of 10^(k+1) times it is strictly bigger than 5 * 10^k.
+  // It is equal to ceil(2^31 + 2^32/10^(k + 1)).
+  // These are stored in a string literal because we cannot have static arrays
+  // in constexpr functions and non-static ones are poorly optimized.
+  return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7"
+         U"\x800001ae\x8000002b"[index];
+}
+
+template <typename Float>
+FMT_CONSTEXPR20 auto format_float(Float value, int precision, float_specs specs,
+                                  buffer<char>& buf) -> int {
+  // float is passed as double to reduce the number of instantiations.
+  static_assert(!std::is_same<Float, float>::value, "");
+  FMT_ASSERT(value >= 0, "value is negative");
+  auto converted_value = convert_float(value);
+
+  const bool fixed = specs.format == float_format::fixed;
+  if (value <= 0) {  // <= instead of == to silence a warning.
+    if (precision <= 0 || !fixed) {
+      buf.push_back('0');
+      return 0;
+    }
+    buf.try_resize(to_unsigned(precision));
+    fill_n(buf.data(), precision, '0');
+    return -precision;
+  }
+
+  int exp = 0;
+  bool use_dragon = true;
+  unsigned dragon_flags = 0;
+  if (!is_fast_float<Float>() || is_constant_evaluated()) {
+    const auto inv_log2_10 = 0.3010299956639812;  // 1 / log2(10)
+    using info = dragonbox::float_info<decltype(converted_value)>;
+    const auto f = basic_fp<typename info::carrier_uint>(converted_value);
+    // Compute exp, an approximate power of 10, such that
+    //   10^(exp - 1) <= value < 10^exp or 10^exp <= value < 10^(exp + 1).
+    // This is based on log10(value) == log2(value) / log2(10) and approximation
+    // of log2(value) by e + num_fraction_bits idea from double-conversion.
+    auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10;
+    exp = static_cast<int>(e);
+    if (e > exp) ++exp;  // Compute ceil.
+    dragon_flags = dragon::fixup;
+  } else if (precision < 0) {
+    // Use Dragonbox for the shortest format.
+    if (specs.binary32) {
+      auto dec = dragonbox::to_decimal(static_cast<float>(value));
+      write<char>(buffer_appender<char>(buf), dec.significand);
+      return dec.exponent;
+    }
+    auto dec = dragonbox::to_decimal(static_cast<double>(value));
+    write<char>(buffer_appender<char>(buf), dec.significand);
+    return dec.exponent;
+  } else {
+    // Extract significand bits and exponent bits.
+    using info = dragonbox::float_info<double>;
+    auto br = bit_cast<uint64_t>(static_cast<double>(value));
+
+    const uint64_t significand_mask =
+        (static_cast<uint64_t>(1) << num_significand_bits<double>()) - 1;
+    uint64_t significand = (br & significand_mask);
+    int exponent = static_cast<int>((br & exponent_mask<double>()) >>
+                                    num_significand_bits<double>());
+
+    if (exponent != 0) {  // Check if normal.
+      exponent -= exponent_bias<double>() + num_significand_bits<double>();
+      significand |=
+          (static_cast<uint64_t>(1) << num_significand_bits<double>());
+      significand <<= 1;
+    } else {
+      // Normalize subnormal inputs.
+      FMT_ASSERT(significand != 0, "zeros should not appear here");
+      int shift = countl_zero(significand);
+      FMT_ASSERT(shift >= num_bits<uint64_t>() - num_significand_bits<double>(),
+                 "");
+      shift -= (num_bits<uint64_t>() - num_significand_bits<double>() - 2);
+      exponent = (std::numeric_limits<double>::min_exponent -
+                  num_significand_bits<double>()) -
+                 shift;
+      significand <<= shift;
+    }
+
+    // Compute the first several nonzero decimal significand digits.
+    // We call the number we get the first segment.
+    const int k = info::kappa - dragonbox::floor_log10_pow2(exponent);
+    exp = -k;
+    const int beta = exponent + dragonbox::floor_log2_pow10(k);
+    uint64_t first_segment;
+    bool has_more_segments;
+    int digits_in_the_first_segment;
+    {
+      const auto r = dragonbox::umul192_upper128(
+          significand << beta, dragonbox::get_cached_power(k));
+      first_segment = r.high();
+      has_more_segments = r.low() != 0;
+
+      // The first segment can have 18 ~ 19 digits.
+      if (first_segment >= 1000000000000000000ULL) {
+        digits_in_the_first_segment = 19;
+      } else {
+        // When it is of 18-digits, we align it to 19-digits by adding a bogus
+        // zero at the end.
+        digits_in_the_first_segment = 18;
+        first_segment *= 10;
+      }
+    }
+
+    // Compute the actual number of decimal digits to print.
+    if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment);
+
+    // Use Dragon4 only when there might be not enough digits in the first
+    // segment.
+    if (digits_in_the_first_segment > precision) {
+      use_dragon = false;
+
+      if (precision <= 0) {
+        exp += digits_in_the_first_segment;
+
+        if (precision < 0) {
+          // Nothing to do, since all we have are just leading zeros.
+          buf.try_resize(0);
+        } else {
+          // We may need to round-up.
+          buf.try_resize(1);
+          if ((first_segment | static_cast<uint64_t>(has_more_segments)) >
+              5000000000000000000ULL) {
+            buf[0] = '1';
+          } else {
+            buf[0] = '0';
+          }
+        }
+      }  // precision <= 0
+      else {
+        exp += digits_in_the_first_segment - precision;
+
+        // When precision > 0, we divide the first segment into three
+        // subsegments, each with 9, 9, and 0 ~ 1 digits so that each fits
+        // in 32-bits which usually allows faster calculation than in
+        // 64-bits. Since some compiler (e.g. MSVC) doesn't know how to optimize
+        // division-by-constant for large 64-bit divisors, we do it here
+        // manually. The magic number 7922816251426433760 below is equal to
+        // ceil(2^(64+32) / 10^10).
+        const uint32_t first_subsegment = static_cast<uint32_t>(
+            dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >>
+            32);
+        const uint64_t second_third_subsegments =
+            first_segment - first_subsegment * 10000000000ULL;
+
+        uint64_t prod;
+        uint32_t digits;
+        bool should_round_up;
+        int number_of_digits_to_print = precision > 9 ? 9 : precision;
+
+        // Print a 9-digits subsegment, either the first or the second.
+        auto print_subsegment = [&](uint32_t subsegment, char* buffer) {
+          int number_of_digits_printed = 0;
+
+          // If we want to print an odd number of digits from the subsegment,
+          if ((number_of_digits_to_print & 1) != 0) {
+            // Convert to 64-bit fixed-point fractional form with 1-digit
+            // integer part. The magic number 720575941 is a good enough
+            // approximation of 2^(32 + 24) / 10^8; see
+            // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
+            // for details.
+            prod = ((subsegment * static_cast<uint64_t>(720575941)) >> 24) + 1;
+            digits = static_cast<uint32_t>(prod >> 32);
+            *buffer = static_cast<char>('0' + digits);
+            number_of_digits_printed++;
+          }
+          // If we want to print an even number of digits from the
+          // first_subsegment,
+          else {
+            // Convert to 64-bit fixed-point fractional form with 2-digits
+            // integer part. The magic number 450359963 is a good enough
+            // approximation of 2^(32 + 20) / 10^7; see
+            // https://jk-jeon.github.io/posts/2022/12/fixed-precision-formatting/#fixed-length-case
+            // for details.
+            prod = ((subsegment * static_cast<uint64_t>(450359963)) >> 20) + 1;
+            digits = static_cast<uint32_t>(prod >> 32);
+            copy2(buffer, digits2(digits));
+            number_of_digits_printed += 2;
+          }
+
+          // Print all digit pairs.
+          while (number_of_digits_printed < number_of_digits_to_print) {
+            prod = static_cast<uint32_t>(prod) * static_cast<uint64_t>(100);
+            digits = static_cast<uint32_t>(prod >> 32);
+            copy2(buffer + number_of_digits_printed, digits2(digits));
+            number_of_digits_printed += 2;
+          }
+        };
+
+        // Print first subsegment.
+        print_subsegment(first_subsegment, buf.data());
+
+        // Perform rounding if the first subsegment is the last subsegment to
+        // print.
+        if (precision <= 9) {
+          // Rounding inside the subsegment.
+          // We round-up if:
+          //  - either the fractional part is strictly larger than 1/2, or
+          //  - the fractional part is exactly 1/2 and the last digit is odd.
+          // We rely on the following observations:
+          //  - If fractional_part >= threshold, then the fractional part is
+          //    strictly larger than 1/2.
+          //  - If the MSB of fractional_part is set, then the fractional part
+          //    must be at least 1/2.
+          //  - When the MSB of fractional_part is set, either
+          //    second_third_subsegments being nonzero or has_more_segments
+          //    being true means there are further digits not printed, so the
+          //    fractional part is strictly larger than 1/2.
+          if (precision < 9) {
+            uint32_t fractional_part = static_cast<uint32_t>(prod);
+            should_round_up =
+                fractional_part >= fractional_part_rounding_thresholds(
+                                       8 - number_of_digits_to_print) ||
+                ((fractional_part >> 31) &
+                 ((digits & 1) | (second_third_subsegments != 0) |
+                  has_more_segments)) != 0;
+          }
+          // Rounding at the subsegment boundary.
+          // In this case, the fractional part is at least 1/2 if and only if
+          // second_third_subsegments >= 5000000000ULL, and is strictly larger
+          // than 1/2 if we further have either second_third_subsegments >
+          // 5000000000ULL or has_more_segments == true.
+          else {
+            should_round_up = second_third_subsegments > 5000000000ULL ||
+                              (second_third_subsegments == 5000000000ULL &&
+                               ((digits & 1) != 0 || has_more_segments));
+          }
+        }
+        // Otherwise, print the second subsegment.
+        else {
+          // Compilers are not aware of how to leverage the maximum value of
+          // second_third_subsegments to find out a better magic number which
+          // allows us to eliminate an additional shift. 1844674407370955162 =
+          // ceil(2^64/10) < ceil(2^64*(10^9/(10^10 - 1))).
+          const uint32_t second_subsegment =
+              static_cast<uint32_t>(dragonbox::umul128_upper64(
+                  second_third_subsegments, 1844674407370955162ULL));
+          const uint32_t third_subsegment =
+              static_cast<uint32_t>(second_third_subsegments) -
+              second_subsegment * 10;
+
+          number_of_digits_to_print = precision - 9;
+          print_subsegment(second_subsegment, buf.data() + 9);
+
+          // Rounding inside the subsegment.
+          if (precision < 18) {
+            // The condition third_subsegment != 0 implies that the segment was
+            // of 19 digits, so in this case the third segment should be
+            // consisting of a genuine digit from the input.
+            uint32_t fractional_part = static_cast<uint32_t>(prod);
+            should_round_up =
+                fractional_part >= fractional_part_rounding_thresholds(
+                                       8 - number_of_digits_to_print) ||
+                ((fractional_part >> 31) &
+                 ((digits & 1) | (third_subsegment != 0) |
+                  has_more_segments)) != 0;
+          }
+          // Rounding at the subsegment boundary.
+          else {
+            // In this case, the segment must be of 19 digits, thus
+            // the third subsegment should be consisting of a genuine digit from
+            // the input.
+            should_round_up = third_subsegment > 5 ||
+                              (third_subsegment == 5 &&
+                               ((digits & 1) != 0 || has_more_segments));
+          }
+        }
+
+        // Round-up if necessary.
+        if (should_round_up) {
+          ++buf[precision - 1];
+          for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) {
+            buf[i] = '0';
+            ++buf[i - 1];
+          }
+          if (buf[0] > '9') {
+            buf[0] = '1';
+            if (fixed)
+              buf[precision++] = '0';
+            else
+              ++exp;
+          }
+        }
+        buf.try_resize(to_unsigned(precision));
+      }
+    }  // if (digits_in_the_first_segment > precision)
+    else {
+      // Adjust the exponent for its use in Dragon4.
+      exp += digits_in_the_first_segment - 1;
+    }
+  }
+  if (use_dragon) {
+    auto f = basic_fp<uint128_t>();
+    bool is_predecessor_closer = specs.binary32
+                                     ? f.assign(static_cast<float>(value))
+                                     : f.assign(converted_value);
+    if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer;
+    if (fixed) dragon_flags |= dragon::fixed;
+    // Limit precision to the maximum possible number of significant digits in
+    // an IEEE754 double because we don't need to generate zeros.
+    const int max_double_digits = 767;
+    if (precision > max_double_digits) precision = max_double_digits;
+    format_dragon(f, dragon_flags, precision, buf, exp);
+  }
+  if (!fixed && !specs.showpoint) {
+    // Remove trailing zeros.
+    auto num_digits = buf.size();
+    while (num_digits > 0 && buf[num_digits - 1] == '0') {
+      --num_digits;
+      ++exp;
+    }
+    buf.try_resize(num_digits);
+  }
+  return exp;
+}
+template <typename Char, typename OutputIt, typename T>
+FMT_CONSTEXPR20 auto write_float(OutputIt out, T value,
+                                 format_specs<Char> specs, locale_ref loc)
+    -> OutputIt {
+  float_specs fspecs = parse_float_type_spec(specs);
+  fspecs.sign = specs.sign;
+  if (detail::signbit(value)) {  // value < 0 is false for NaN so use signbit.
+    fspecs.sign = sign::minus;
+    value = -value;
+  } else if (fspecs.sign == sign::minus) {
+    fspecs.sign = sign::none;
+  }
+
+  if (!detail::isfinite(value))
+    return write_nonfinite(out, detail::isnan(value), specs, fspecs);
+
+  if (specs.align == align::numeric && fspecs.sign) {
+    auto it = reserve(out, 1);
+    *it++ = detail::sign<Char>(fspecs.sign);
+    out = base_iterator(out, it);
+    fspecs.sign = sign::none;
+    if (specs.width != 0) --specs.width;
+  }
+
+  memory_buffer buffer;
+  if (fspecs.format == float_format::hex) {
+    if (fspecs.sign) buffer.push_back(detail::sign<char>(fspecs.sign));
+    format_hexfloat(convert_float(value), specs.precision, fspecs, buffer);
+    return write_bytes<align::right>(out, {buffer.data(), buffer.size()},
+                                     specs);
+  }
+  int precision = specs.precision >= 0 || specs.type == presentation_type::none
+                      ? specs.precision
+                      : 6;
+  if (fspecs.format == float_format::exp) {
+    if (precision == max_value<int>())
+      throw_format_error("number is too big");
+    else
+      ++precision;
+  } else if (fspecs.format != float_format::fixed && precision == 0) {
+    precision = 1;
+  }
+  if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
+  int exp = format_float(convert_float(value), precision, fspecs, buffer);
+  fspecs.precision = precision;
+  auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
+  return write_float(out, f, specs, fspecs, loc);
+}
+
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(is_floating_point<T>::value)>
+FMT_CONSTEXPR20 auto write(OutputIt out, T value, format_specs<Char> specs,
+                           locale_ref loc = {}) -> OutputIt {
+  if (const_check(!is_supported_floating_point(value))) return out;
+  return specs.localized && write_loc(out, value, specs, loc)
+             ? out
+             : write_float(out, value, specs, loc);
+}
+
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(is_fast_float<T>::value)>
+FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
+  if (is_constant_evaluated()) return write(out, value, format_specs<Char>());
+  if (const_check(!is_supported_floating_point(value))) return out;
+
+  auto fspecs = float_specs();
+  if (detail::signbit(value)) {
+    fspecs.sign = sign::minus;
+    value = -value;
+  }
+
+  constexpr auto specs = format_specs<Char>();
+  using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
+  using floaty_uint = typename dragonbox::float_info<floaty>::carrier_uint;
+  floaty_uint mask = exponent_mask<floaty>();
+  if ((bit_cast<floaty_uint>(value) & mask) == mask)
+    return write_nonfinite(out, std::isnan(value), specs, fspecs);
+
+  auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
+  return write_float(out, dec, specs, fspecs, {});
+}
+
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(is_floating_point<T>::value &&
+                        !is_fast_float<T>::value)>
+inline auto write(OutputIt out, T value) -> OutputIt {
+  return write(out, value, format_specs<Char>());
+}
+
+template <typename Char, typename OutputIt>
+auto write(OutputIt out, monostate, format_specs<Char> = {}, locale_ref = {})
+    -> OutputIt {
+  FMT_ASSERT(false, "");
+  return out;
+}
+
+template <typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, basic_string_view<Char> value)
+    -> OutputIt {
+  auto it = reserve(out, value.size());
+  it = copy_str_noinline<Char>(value.begin(), value.end(), it);
+  return base_iterator(out, it);
+}
+
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(is_string<T>::value)>
+constexpr auto write(OutputIt out, const T& value) -> OutputIt {
+  return write<Char>(out, to_string_view(value));
+}
+
+// FMT_ENABLE_IF() condition separated to workaround an MSVC bug.
+template <
+    typename Char, typename OutputIt, typename T,
+    bool check =
+        std::is_enum<T>::value && !std::is_same<T, Char>::value &&
+        mapped_type_constant<T, basic_format_context<OutputIt, Char>>::value !=
+            type::custom_type,
+    FMT_ENABLE_IF(check)>
+FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
+  return write<Char>(out, static_cast<underlying_t<T>>(value));
+}
+
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(std::is_same<T, bool>::value)>
+FMT_CONSTEXPR auto write(OutputIt out, T value,
+                         const format_specs<Char>& specs = {}, locale_ref = {})
+    -> OutputIt {
+  return specs.type != presentation_type::none &&
+                 specs.type != presentation_type::string
+             ? write(out, value ? 1 : 0, specs, {})
+             : write_bytes(out, value ? "true" : "false", specs);
+}
+
+template <typename Char, typename OutputIt>
+FMT_CONSTEXPR auto write(OutputIt out, Char value) -> OutputIt {
+  auto it = reserve(out, 1);
+  *it++ = value;
+  return base_iterator(out, it);
+}
+
+template <typename Char, typename OutputIt>
+FMT_CONSTEXPR_CHAR_TRAITS auto write(OutputIt out, const Char* value)
+    -> OutputIt {
+  if (value) return write(out, basic_string_view<Char>(value));
+  throw_format_error("string pointer is null");
+  return out;
+}
+
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(std::is_same<T, void>::value)>
+auto write(OutputIt out, const T* value, const format_specs<Char>& specs = {},
+           locale_ref = {}) -> OutputIt {
+  return write_ptr<Char>(out, bit_cast<uintptr_t>(value), &specs);
+}
+
+// A write overload that handles implicit conversions.
+template <typename Char, typename OutputIt, typename T,
+          typename Context = basic_format_context<OutputIt, Char>>
+FMT_CONSTEXPR auto write(OutputIt out, const T& value) -> enable_if_t<
+    std::is_class<T>::value && !is_string<T>::value &&
+        !is_floating_point<T>::value && !std::is_same<T, Char>::value &&
+        !std::is_same<T, remove_cvref_t<decltype(arg_mapper<Context>().map(
+                             value))>>::value,
+    OutputIt> {
+  return write<Char>(out, arg_mapper<Context>().map(value));
+}
+
+template <typename Char, typename OutputIt, typename T,
+          typename Context = basic_format_context<OutputIt, Char>>
+FMT_CONSTEXPR auto write(OutputIt out, const T& value)
+    -> enable_if_t<mapped_type_constant<T, Context>::value == type::custom_type,
+                   OutputIt> {
+  auto formatter = typename Context::template formatter_type<T>();
+  auto parse_ctx = typename Context::parse_context_type({});
+  formatter.parse(parse_ctx);
+  auto ctx = Context(out, {}, {});
+  return formatter.format(value, ctx);
+}
+
+// An argument visitor that formats the argument and writes it via the output
+// iterator. It's a class and not a generic lambda for compatibility with C++11.
+template <typename Char> struct default_arg_formatter {
+  using iterator = buffer_appender<Char>;
+  using context = buffer_context<Char>;
+
+  iterator out;
+  basic_format_args<context> args;
+  locale_ref loc;
+
+  template <typename T> auto operator()(T value) -> iterator {
+    return write<Char>(out, value);
+  }
+  auto operator()(typename basic_format_arg<context>::handle h) -> iterator {
+    basic_format_parse_context<Char> parse_ctx({});
+    context format_ctx(out, args, loc);
+    h.format(parse_ctx, format_ctx);
+    return format_ctx.out();
+  }
+};
+
+template <typename Char> struct arg_formatter {
+  using iterator = buffer_appender<Char>;
+  using context = buffer_context<Char>;
+
+  iterator out;
+  const format_specs<Char>& specs;
+  locale_ref locale;
+
+  template <typename T>
+  FMT_CONSTEXPR FMT_INLINE auto operator()(T value) -> iterator {
+    return detail::write(out, value, specs, locale);
+  }
+  auto operator()(typename basic_format_arg<context>::handle) -> iterator {
+    // User-defined types are handled separately because they require access
+    // to the parse context.
+    return out;
+  }
+};
+
+struct width_checker {
+  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
+  FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
+    if (is_negative(value)) throw_format_error("negative width");
+    return static_cast<unsigned long long>(value);
+  }
+
+  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
+  FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
+    throw_format_error("width is not integer");
+    return 0;
+  }
+};
+
+struct precision_checker {
+  template <typename T, FMT_ENABLE_IF(is_integer<T>::value)>
+  FMT_CONSTEXPR auto operator()(T value) -> unsigned long long {
+    if (is_negative(value)) throw_format_error("negative precision");
+    return static_cast<unsigned long long>(value);
+  }
+
+  template <typename T, FMT_ENABLE_IF(!is_integer<T>::value)>
+  FMT_CONSTEXPR auto operator()(T) -> unsigned long long {
+    throw_format_error("precision is not integer");
+    return 0;
+  }
+};
+
+template <typename Handler, typename FormatArg>
+FMT_CONSTEXPR auto get_dynamic_spec(FormatArg arg) -> int {
+  unsigned long long value = visit_format_arg(Handler(), arg);
+  if (value > to_unsigned(max_value<int>()))
+    throw_format_error("number is too big");
+  return static_cast<int>(value);
+}
+
+template <typename Context, typename ID>
+FMT_CONSTEXPR auto get_arg(Context& ctx, ID id) -> decltype(ctx.arg(id)) {
+  auto arg = ctx.arg(id);
+  if (!arg) ctx.on_error("argument not found");
+  return arg;
+}
+
+template <typename Handler, typename Context>
+FMT_CONSTEXPR void handle_dynamic_spec(int& value,
+                                       arg_ref<typename Context::char_type> ref,
+                                       Context& ctx) {
+  switch (ref.kind) {
+  case arg_id_kind::none:
+    break;
+  case arg_id_kind::index:
+    value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.index));
+    break;
+  case arg_id_kind::name:
+    value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.name));
+    break;
+  }
+}
+
+#if FMT_USE_USER_DEFINED_LITERALS
+#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template <typename T, typename Char, size_t N,
+          fmt::detail_exported::fixed_string<Char, N> Str>
+struct statically_named_arg : view {
+  static constexpr auto name = Str.data;
+
+  const T& value;
+  statically_named_arg(const T& v) : value(v) {}
+};
+
+template <typename T, typename Char, size_t N,
+          fmt::detail_exported::fixed_string<Char, N> Str>
+struct is_named_arg<statically_named_arg<T, Char, N, Str>> : std::true_type {};
+
+template <typename T, typename Char, size_t N,
+          fmt::detail_exported::fixed_string<Char, N> Str>
+struct is_statically_named_arg<statically_named_arg<T, Char, N, Str>>
+    : std::true_type {};
+
+template <typename Char, size_t N,
+          fmt::detail_exported::fixed_string<Char, N> Str>
+struct udl_arg {
+  template <typename T> auto operator=(T&& value) const {
+    return statically_named_arg<T, Char, N, Str>(std::forward<T>(value));
+  }
+};
+#  else
+template <typename Char> struct udl_arg {
+  const Char* str;
+
+  template <typename T> auto operator=(T&& value) const -> named_arg<Char, T> {
+    return {str, std::forward<T>(value)};
+  }
+};
+#  endif
+#endif  // FMT_USE_USER_DEFINED_LITERALS
+
+template <typename Locale, typename Char>
+auto vformat(const Locale& loc, basic_string_view<Char> fmt,
+             basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  auto buf = basic_memory_buffer<Char>();
+  detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
+  return {buf.data(), buf.size()};
+}
+
+using format_func = void (*)(detail::buffer<char>&, int, const char*);
+
+FMT_API void format_error_code(buffer<char>& out, int error_code,
+                               string_view message) noexcept;
+
+FMT_API void report_error(format_func func, int error_code,
+                          const char* message) noexcept;
+}  // namespace detail
+
+FMT_API auto vsystem_error(int error_code, string_view format_str,
+                           format_args args) -> std::system_error;
+
+/**
+  \rst
+  Constructs :class:`std::system_error` with a message formatted with
+  ``fmt::format(fmt, args...)``.
+  *error_code* is a system error code as given by ``errno``.
+
+  **Example**::
+
+    // This throws std::system_error with the description
+    //   cannot open file 'madeup': No such file or directory
+    // or similar (system message may vary).
+    const char* filename = "madeup";
+    std::FILE* file = std::fopen(filename, "r");
+    if (!file)
+      throw fmt::system_error(errno, "cannot open file '{}'", filename);
+  \endrst
+ */
+template <typename... T>
+auto system_error(int error_code, format_string<T...> fmt, T&&... args)
+    -> std::system_error {
+  return vsystem_error(error_code, fmt, fmt::make_format_args(args...));
+}
+
+/**
+  \rst
+  Formats an error message for an error returned by an operating system or a
+  language runtime, for example a file opening error, and writes it to *out*.
+  The format is the same as the one used by ``std::system_error(ec, message)``
+  where ``ec`` is ``std::error_code(error_code, std::generic_category()})``.
+  It is implementation-defined but normally looks like:
+
+  .. parsed-literal::
+     *<message>*: *<system-message>*
+
+  where *<message>* is the passed message and *<system-message>* is the system
+  message corresponding to the error code.
+  *error_code* is a system error code as given by ``errno``.
+  \endrst
+ */
+FMT_API void format_system_error(detail::buffer<char>& out, int error_code,
+                                 const char* message) noexcept;
+
+// Reports a system error without throwing an exception.
+// Can be used to report errors from destructors.
+FMT_API void report_system_error(int error_code, const char* message) noexcept;
+
+/** Fast integer formatter. */
+class format_int {
+ private:
+  // Buffer should be large enough to hold all digits (digits10 + 1),
+  // a sign and a null character.
+  enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 };
+  mutable char buffer_[buffer_size];
+  char* str_;
+
+  template <typename UInt> auto format_unsigned(UInt value) -> char* {
+    auto n = static_cast<detail::uint32_or_64_or_128_t<UInt>>(value);
+    return detail::format_decimal(buffer_, n, buffer_size - 1).begin;
+  }
+
+  template <typename Int> auto format_signed(Int value) -> char* {
+    auto abs_value = static_cast<detail::uint32_or_64_or_128_t<Int>>(value);
+    bool negative = value < 0;
+    if (negative) abs_value = 0 - abs_value;
+    auto begin = format_unsigned(abs_value);
+    if (negative) *--begin = '-';
+    return begin;
+  }
+
+ public:
+  explicit format_int(int value) : str_(format_signed(value)) {}
+  explicit format_int(long value) : str_(format_signed(value)) {}
+  explicit format_int(long long value) : str_(format_signed(value)) {}
+  explicit format_int(unsigned value) : str_(format_unsigned(value)) {}
+  explicit format_int(unsigned long value) : str_(format_unsigned(value)) {}
+  explicit format_int(unsigned long long value)
+      : str_(format_unsigned(value)) {}
+
+  /** Returns the number of characters written to the output buffer. */
+  auto size() const -> size_t {
+    return detail::to_unsigned(buffer_ - str_ + buffer_size - 1);
+  }
+
+  /**
+    Returns a pointer to the output buffer content. No terminating null
+    character is appended.
+   */
+  auto data() const -> const char* { return str_; }
+
+  /**
+    Returns a pointer to the output buffer content with terminating null
+    character appended.
+   */
+  auto c_str() const -> const char* {
+    buffer_[buffer_size - 1] = '\0';
+    return str_;
+  }
+
+  /**
+    \rst
+    Returns the content of the output buffer as an ``std::string``.
+    \endrst
+   */
+  auto str() const -> std::string { return std::string(str_, size()); }
+};
+
+template <typename T, typename Char>
+struct formatter<T, Char, enable_if_t<detail::has_format_as<T>::value>>
+    : formatter<detail::format_as_t<T>, Char> {
+  template <typename FormatContext>
+  auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) {
+    using base = formatter<detail::format_as_t<T>, Char>;
+    return base::format(format_as(value), ctx);
+  }
+};
+
+#define FMT_FORMAT_AS(Type, Base) \
+  template <typename Char>        \
+  struct formatter<Type, Char> : formatter<Base, Char> {}
+
+FMT_FORMAT_AS(signed char, int);
+FMT_FORMAT_AS(unsigned char, unsigned);
+FMT_FORMAT_AS(short, int);
+FMT_FORMAT_AS(unsigned short, unsigned);
+FMT_FORMAT_AS(long, detail::long_type);
+FMT_FORMAT_AS(unsigned long, detail::ulong_type);
+FMT_FORMAT_AS(Char*, const Char*);
+FMT_FORMAT_AS(std::basic_string<Char>, basic_string_view<Char>);
+FMT_FORMAT_AS(std::nullptr_t, const void*);
+FMT_FORMAT_AS(detail::std_string_view<Char>, basic_string_view<Char>);
+FMT_FORMAT_AS(void*, const void*);
+
+template <typename Char, size_t N>
+struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {};
+
+/**
+  \rst
+  Converts ``p`` to ``const void*`` for pointer formatting.
+
+  **Example**::
+
+    auto s = fmt::format("{}", fmt::ptr(p));
+  \endrst
+ */
+template <typename T> auto ptr(T p) -> const void* {
+  static_assert(std::is_pointer<T>::value, "");
+  return detail::bit_cast<const void*>(p);
+}
+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();
+}
+
+/**
+  \rst
+  Converts ``e`` to the underlying type.
+
+  **Example**::
+
+    enum class color { red, green, blue };
+    auto s = fmt::format("{}", fmt::underlying(color::red));
+  \endrst
+ */
+template <typename Enum>
+constexpr auto underlying(Enum e) noexcept -> underlying_t<Enum> {
+  return static_cast<underlying_t<Enum>>(e);
+}
+
+namespace enums {
+template <typename Enum, FMT_ENABLE_IF(std::is_enum<Enum>::value)>
+constexpr auto format_as(Enum e) noexcept -> underlying_t<Enum> {
+  return static_cast<underlying_t<Enum>>(e);
+}
+}  // namespace enums
+
+class bytes {
+ private:
+  string_view data_;
+  friend struct formatter<bytes>;
+
+ public:
+  explicit bytes(string_view data) : data_(data) {}
+};
+
+template <> struct formatter<bytes> {
+ private:
+  detail::dynamic_format_specs<> specs_;
+
+ public:
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const char* {
+    return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
+                              detail::type::string_type);
+  }
+
+  template <typename FormatContext>
+  auto format(bytes b, FormatContext& ctx) -> decltype(ctx.out()) {
+    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
+                                                       specs_.width_ref, ctx);
+    detail::handle_dynamic_spec<detail::precision_checker>(
+        specs_.precision, specs_.precision_ref, ctx);
+    return detail::write_bytes(ctx.out(), b.data_, specs_);
+  }
+};
+
+// group_digits_view is not derived from view because it copies the argument.
+template <typename T> struct group_digits_view {
+  T value;
+};
+
+/**
+  \rst
+  Returns a view that formats an integer value using ',' as a locale-independent
+  thousands separator.
+
+  **Example**::
+
+    fmt::print("{}", fmt::group_digits(12345));
+    // Output: "12,345"
+  \endrst
+ */
+template <typename T> auto group_digits(T value) -> group_digits_view<T> {
+  return {value};
+}
+
+template <typename T> struct formatter<group_digits_view<T>> : formatter<T> {
+ private:
+  detail::dynamic_format_specs<> specs_;
+
+ public:
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const char* {
+    return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
+                              detail::type::int_type);
+  }
+
+  template <typename FormatContext>
+  auto format(group_digits_view<T> t, FormatContext& ctx)
+      -> decltype(ctx.out()) {
+    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
+                                                       specs_.width_ref, ctx);
+    detail::handle_dynamic_spec<detail::precision_checker>(
+        specs_.precision, specs_.precision_ref, ctx);
+    return detail::write_int(
+        ctx.out(), static_cast<detail::uint64_or_128_t<T>>(t.value), 0, specs_,
+        detail::digit_grouping<char>("\3", ","));
+  }
+};
+
+template <typename T> struct nested_view {
+  const formatter<T>* fmt;
+  const T* value;
+};
+
+template <typename T> struct formatter<nested_view<T>> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* {
+    return ctx.begin();
+  }
+  auto format(nested_view<T> view, format_context& ctx) const
+      -> decltype(ctx.out()) {
+    return view.fmt->format(*view.value, ctx);
+  }
+};
+
+template <typename T> struct nested_formatter {
+ private:
+  int width_;
+  detail::fill_t<char> fill_;
+  align_t align_ : 4;
+  formatter<T> formatter_;
+
+ public:
+  constexpr nested_formatter() : width_(0), align_(align_t::none) {}
+
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> const char* {
+    auto specs = detail::dynamic_format_specs<char>();
+    auto it = parse_format_specs(ctx.begin(), ctx.end(), specs, ctx,
+                                 detail::type::none_type);
+    width_ = specs.width;
+    fill_ = specs.fill;
+    align_ = specs.align;
+    ctx.advance_to(it);
+    return formatter_.parse(ctx);
+  }
+
+  template <typename F>
+  auto write_padded(format_context& ctx, F write) const -> decltype(ctx.out()) {
+    if (width_ == 0) return write(ctx.out());
+    auto buf = memory_buffer();
+    write(std::back_inserter(buf));
+    auto specs = format_specs<>();
+    specs.width = width_;
+    specs.fill = fill_;
+    specs.align = align_;
+    return detail::write(ctx.out(), string_view(buf.data(), buf.size()), specs);
+  }
+
+  auto nested(const T& value) const -> nested_view<T> {
+    return nested_view<T>{&formatter_, &value};
+  }
+};
+
+// DEPRECATED! join_view will be moved to ranges.h.
+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(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_;
+
+ public:
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> const Char* {
+    return value_formatter_.parse(ctx);
+  }
+
+  template <typename FormatContext>
+  auto format(const join_view<It, Sentinel, Char>& value,
+              FormatContext& ctx) const -> decltype(ctx.out()) {
+    auto it = value.begin;
+    auto out = ctx.out();
+    if (it != value.end) {
+      out = value_formatter_.format(*it, ctx);
+      ++it;
+      while (it != value.end) {
+        out = detail::copy_str<Char>(value.sep.begin(), value.sep.end(), out);
+        ctx.advance_to(out);
+        out = value_formatter_.format(*it, ctx);
+        ++it;
+      }
+    }
+    return out;
+  }
+};
+
+/**
+  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 {begin, end, sep};
+}
+
+/**
+  \rst
+  Returns a view that formats `range` with elements separated by `sep`.
+
+  **Example**::
+
+    std::vector<int> v = {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"
+  \endrst
+ */
+template <typename Range>
+auto join(Range&& range, string_view sep)
+    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>> {
+  return join(std::begin(range), std::end(range), sep);
+}
+
+/**
+  \rst
+  Converts *value* to ``std::string`` using the default format for type *T*.
+
+  **Example**::
+
+    #include <fmt/format.h>
+
+    std::string answer = fmt::to_string(42);
+  \endrst
+ */
+template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value &&
+                                    !detail::has_format_as<T>::value)>
+inline auto to_string(const T& value) -> std::string {
+  auto buffer = memory_buffer();
+  detail::write<char>(appender(buffer), value);
+  return {buffer.data(), buffer.size()};
+}
+
+template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+FMT_NODISCARD inline auto to_string(T value) -> std::string {
+  // The buffer should be large enough to store the number including the sign
+  // or "false" for bool.
+  constexpr int max_size = detail::digits10<T>() + 2;
+  char buffer[max_size > 5 ? static_cast<unsigned>(max_size) : 5];
+  char* begin = buffer;
+  return std::string(begin, detail::write<char>(begin, value));
+}
+
+template <typename Char, size_t SIZE>
+FMT_NODISCARD auto to_string(const basic_memory_buffer<Char, SIZE>& buf)
+    -> std::basic_string<Char> {
+  auto size = buf.size();
+  detail::assume(size < std::basic_string<Char>().max_size());
+  return std::basic_string<Char>(buf.data(), size);
+}
+
+template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value &&
+                                    detail::has_format_as<T>::value)>
+inline auto to_string(const T& value) -> std::string {
+  return to_string(format_as(value));
+}
+
+FMT_END_EXPORT
+
+namespace detail {
+
+template <typename Char>
+void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
+                typename vformat_args<Char>::type args, locale_ref loc) {
+  auto out = buffer_appender<Char>(buf);
+  if (fmt.size() == 2 && equal2(fmt.data(), "{}")) {
+    auto arg = args.get(0);
+    if (!arg) throw_format_error("argument not found");
+    visit_format_arg(default_arg_formatter<Char>{out, args, loc}, arg);
+    return;
+  }
+
+  struct format_handler : error_handler {
+    basic_format_parse_context<Char> parse_context;
+    buffer_context<Char> context;
+
+    format_handler(buffer_appender<Char> p_out, basic_string_view<Char> str,
+                   basic_format_args<buffer_context<Char>> p_args,
+                   locale_ref p_loc)
+        : parse_context(str), context(p_out, p_args, p_loc) {}
+
+    void on_text(const Char* begin, const Char* end) {
+      auto text = basic_string_view<Char>(begin, to_unsigned(end - begin));
+      context.advance_to(write<Char>(context.out(), text));
+    }
+
+    FMT_CONSTEXPR auto on_arg_id() -> int {
+      return parse_context.next_arg_id();
+    }
+    FMT_CONSTEXPR auto on_arg_id(int id) -> int {
+      return parse_context.check_arg_id(id), id;
+    }
+    FMT_CONSTEXPR auto on_arg_id(basic_string_view<Char> id) -> int {
+      int arg_id = context.arg_id(id);
+      if (arg_id < 0) throw_format_error("argument not found");
+      return arg_id;
+    }
+
+    FMT_INLINE void on_replacement_field(int id, const Char*) {
+      auto arg = get_arg(context, id);
+      context.advance_to(visit_format_arg(
+          default_arg_formatter<Char>{context.out(), context.args(),
+                                      context.locale()},
+          arg));
+    }
+
+    auto on_format_specs(int id, const Char* begin, const Char* end)
+        -> const Char* {
+      auto arg = get_arg(context, id);
+      // Not using a visitor for custom types gives better codegen.
+      if (arg.format_custom(begin, parse_context, context))
+        return parse_context.begin();
+      auto specs = detail::dynamic_format_specs<Char>();
+      begin = parse_format_specs(begin, end, specs, parse_context, arg.type());
+      detail::handle_dynamic_spec<detail::width_checker>(
+          specs.width, specs.width_ref, context);
+      detail::handle_dynamic_spec<detail::precision_checker>(
+          specs.precision, specs.precision_ref, context);
+      if (begin == end || *begin != '}')
+        throw_format_error("missing '}' in format string");
+      auto f = arg_formatter<Char>{context.out(), specs, context.locale()};
+      context.advance_to(visit_format_arg(f, arg));
+      return begin;
+    }
+  };
+  detail::parse_format_string<false>(fmt, format_handler(out, fmt, args, loc));
+}
+
+FMT_BEGIN_EXPORT
+
+#ifndef FMT_HEADER_ONLY
+extern template FMT_API void vformat_to(buffer<char>&, string_view,
+                                        typename vformat_args<>::type,
+                                        locale_ref);
+extern template FMT_API auto thousands_sep_impl<char>(locale_ref)
+    -> thousands_sep_result<char>;
+extern template FMT_API auto thousands_sep_impl<wchar_t>(locale_ref)
+    -> thousands_sep_result<wchar_t>;
+extern template FMT_API auto decimal_point_impl(locale_ref) -> char;
+extern template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
+#endif  // FMT_HEADER_ONLY
+
+}  // namespace detail
+
+#if FMT_USE_USER_DEFINED_LITERALS
+inline namespace literals {
+/**
+  \rst
+  User-defined literal equivalent of :func:`fmt::arg`.
+
+  **Example**::
+
+    using namespace fmt::literals;
+    fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
+  \endrst
+ */
+#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template <detail_exported::fixed_string Str> constexpr auto operator""_a() {
+  using char_t = remove_cvref_t<decltype(Str.data[0])>;
+  return detail::udl_arg<char_t, sizeof(Str.data) / sizeof(char_t), Str>();
+}
+#  else
+constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg<char> {
+  return {s};
+}
+#  endif
+}  // namespace literals
+#endif  // FMT_USE_USER_DEFINED_LITERALS
+
+template <typename Locale, FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
+inline auto vformat(const Locale& loc, string_view fmt, format_args args)
+    -> std::string {
+  return detail::vformat(loc, fmt, args);
+}
+
+template <typename Locale, typename... T,
+          FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
+inline auto format(const Locale& loc, format_string<T...> fmt, T&&... args)
+    -> std::string {
+  return fmt::vformat(loc, string_view(fmt), fmt::make_format_args(args...));
+}
+
+template <typename OutputIt, typename Locale,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value&&
+                            detail::is_locale<Locale>::value)>
+auto vformat_to(OutputIt out, const Locale& loc, string_view fmt,
+                format_args args) -> OutputIt {
+  using detail::get_buffer;
+  auto&& buf = get_buffer<char>(out);
+  detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
+  return detail::get_iterator(buf, out);
+}
+
+template <typename OutputIt, typename Locale, typename... T,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value&&
+                            detail::is_locale<Locale>::value)>
+FMT_INLINE auto format_to(OutputIt out, const Locale& loc,
+                          format_string<T...> fmt, T&&... args) -> OutputIt {
+  return vformat_to(out, loc, fmt, fmt::make_format_args(args...));
+}
+
+template <typename Locale, typename... T,
+          FMT_ENABLE_IF(detail::is_locale<Locale>::value)>
+FMT_NODISCARD FMT_INLINE auto formatted_size(const Locale& loc,
+                                             format_string<T...> fmt,
+                                             T&&... args) -> size_t {
+  auto buf = detail::counting_buffer<>();
+  detail::vformat_to<char>(buf, fmt, fmt::make_format_args(args...),
+                           detail::locale_ref(loc));
+  return buf.count();
+}
+
+FMT_END_EXPORT
+
+template <typename T, typename Char>
+template <typename FormatContext>
+FMT_CONSTEXPR FMT_INLINE auto
+formatter<T, Char,
+          enable_if_t<detail::type_constant<T, Char>::value !=
+                      detail::type::custom_type>>::format(const T& val,
+                                                          FormatContext& ctx)
+    const -> decltype(ctx.out()) {
+  if (specs_.width_ref.kind == detail::arg_id_kind::none &&
+      specs_.precision_ref.kind == detail::arg_id_kind::none) {
+    return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
+  }
+  auto specs = specs_;
+  detail::handle_dynamic_spec<detail::width_checker>(specs.width,
+                                                     specs.width_ref, ctx);
+  detail::handle_dynamic_spec<detail::precision_checker>(
+      specs.precision, specs.precision_ref, ctx);
+  return detail::write<Char>(ctx.out(), val, specs, ctx.locale());
+}
+
+FMT_END_NAMESPACE
+
+#ifdef FMT_HEADER_ONLY
+#  define FMT_FUNC inline
+#  include "format-inl.h"
+#else
+#  define FMT_FUNC
+#endif
+
+#endif  // FMT_FORMAT_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/os.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/os.h
new file mode 100644
index 0000000000000000000000000000000000000000..3c7b3ccb481eced0fc2903765752508c255ca534
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/os.h
@@ -0,0 +1,455 @@
+// 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 <cerrno>
+#include <cstddef>
+#include <cstdio>
+#include <system_error>  // std::system_error
+
+#include "format.h"
+
+#if defined __APPLE__ || defined(__FreeBSD__)
+#  if FMT_HAS_INCLUDE(<xlocale.h>)
+#    include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
+#  endif
+#endif
+
+#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
+
+/**
+  \rst
+  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 to allow passing
+  different types of strings to a function, for example::
+
+    template <typename... Args>
+    std::string format(cstring_view format_str, const Args & ... args);
+
+    format("{}", 42);
+    format(std::string("{}"), 42);
+  \endrst
+ */
+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) {}
+
+  /**
+    \rst
+    Constructs a string reference from an ``std::string`` object.
+    \endrst
+   */
+  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 format_str,
+                                         format_args args);
+
+/**
+ \rst
+ Constructs a :class:`std::system_error` object with the description
+ of the form
+
+ .. parsed-literal::
+   *<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);
+   }
+ \endrst
+*/
+template <typename... Args>
+std::system_error windows_error(int error_code, string_view message,
+                                const Args&... args) {
+  return vwindows_error(error_code, message, fmt::make_format_args(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& format_str, Args&&... args) {
+  std::system(format("say \"{}\"", format(format_str, args...)).c_str());
+}
+#endif
+
+// A buffered file.
+class buffered_file {
+ private:
+  FILE* file_;
+
+  friend class file;
+
+  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.
+  buffered_file() noexcept : file_(nullptr) {}
+
+  // Destroys the object closing the file it represents if any.
+  FMT_API ~buffered_file() noexcept;
+
+ public:
+  buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
+    other.file_ = nullptr;
+  }
+
+  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.
+  auto get() const noexcept -> FILE* { return file_; }
+
+  FMT_API auto descriptor() const -> int;
+
+  void vprint(string_view format_str, format_args args) {
+    fmt::vprint(file_, format_str, args);
+  }
+
+  template <typename... Args>
+  inline void print(string_view format_str, const Args&... args) {
+    vprint(format_str, fmt::make_format_args(args...));
+  }
+};
+
+#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) {}
+
+ 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.
+  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;
+
+  file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
+
+  // Move assignment is not noexcept because close may throw.
+  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.
+  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 pipe setting up read_end and write_end file objects for reading
+  // and writing respectively.
+  // DEPRECATED! Taking files as out parameters is deprecated.
+  static void pipe(file& read_end, file& write_end);
+
+  // 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
+};
+
+// Returns the memory page size.
+auto getpagesize() -> long;
+
+namespace detail {
+
+struct buffer_size {
+  buffer_size() = default;
+  size_t value = 0;
+  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;
+
+  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
+};
+
+class file_buffer final : public buffer<char> {
+  file file_;
+
+  FMT_API void grow(size_t) override;
+
+ public:
+  FMT_API file_buffer(cstring_view path, const ostream_params& params);
+  FMT_API file_buffer(file_buffer&& other);
+  FMT_API ~file_buffer();
+
+  void flush() {
+    if (size() == 0) return;
+    file_.write(data(), size() * sizeof(data()[0]));
+    clear();
+  }
+
+  void close() {
+    flush();
+    file_.close();
+  }
+};
+
+}  // namespace detail
+
+// Added {} below to work around default constructor error known to
+// occur in Xcode versions 7.2.1 and 8.2.1.
+constexpr detail::buffer_size buffer_size{};
+
+/** A fast output stream which is not thread-safe. */
+class FMT_API ostream {
+ private:
+  FMT_MSC_WARNING(suppress : 4251)
+  detail::file_buffer buffer_;
+
+  ostream(cstring_view path, const detail::ostream_params& params)
+      : buffer_(path, params) {}
+
+ public:
+  ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {}
+
+  ~ostream();
+
+  void flush() { buffer_.flush(); }
+
+  template <typename... T>
+  friend auto output_file(cstring_view path, T... params) -> ostream;
+
+  void close() { buffer_.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(std::back_inserter(buffer_), fmt,
+               fmt::make_format_args(args...));
+  }
+};
+
+/**
+  \rst
+  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");
+  \endrst
+ */
+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_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/ostream.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/ostream.h
new file mode 100644
index 0000000000000000000000000000000000000000..26fb3b5ac071aa950edad9bf5069e35e358e6a16
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/ostream.h
@@ -0,0 +1,245 @@
+// 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_
+
+#include <fstream>  // std::filebuf
+
+#ifdef _WIN32
+#  ifdef __GLIBCXX__
+#    include <ext/stdio_filebuf.h>
+#    include <ext/stdio_sync_filebuf.h>
+#  endif
+#  include <io.h>
+#endif
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template <typename Streambuf> class formatbuf : public Streambuf {
+ private:
+  using char_type = typename Streambuf::char_type;
+  using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
+  using int_type = typename Streambuf::int_type;
+  using traits_type = typename Streambuf::traits_type;
+
+  buffer<char_type>& buffer_;
+
+ public:
+  explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}
+
+ protected:
+  // The put area is always empty. This makes the implementation simpler and has
+  // the advantage that the streambuf and the buffer are always in sync and
+  // sputc never writes into uninitialized memory. A disadvantage is that each
+  // call to sputc always results in a (virtual) call to overflow. There is no
+  // disadvantage here for sputn since this always results in a call to xsputn.
+
+  auto overflow(int_type ch) -> int_type override {
+    if (!traits_type::eq_int_type(ch, traits_type::eof()))
+      buffer_.push_back(static_cast<char_type>(ch));
+    return ch;
+  }
+
+  auto xsputn(const char_type* s, streamsize count) -> streamsize override {
+    buffer_.append(s, s + count);
+    return count;
+  }
+};
+
+// 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_MSC_VERSION
+template class file_access<file_access_tag, std::filebuf,
+                           &std::filebuf::_Myfile>;
+auto get_file(std::filebuf&) -> FILE*;
+#endif
+
+inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data)
+    -> bool {
+  FILE* f = nullptr;
+#if FMT_MSC_VERSION
+  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
+    f = get_file(*buf);
+  else
+    return false;
+#elif defined(_WIN32) && defined(__GLIBCXX__)
+  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();
+  else
+    return false;
+#else
+  ignore_unused(os, data, f);
+#endif
+#ifdef _WIN32
+  if (f) {
+    int fd = _fileno(f);
+    if (_isatty(fd)) {
+      os.flush();
+      return write_console(fd, data);
+    }
+  }
+#endif
+  return false;
+}
+inline auto write_ostream_unicode(std::wostream&,
+                                  fmt::basic_string_view<wchar_t>) -> bool {
+  return false;
+}
+
+// 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 = std::make_unsigned<std::streamsize>::type;
+  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 Char, typename T>
+void format_value(buffer<Char>& buf, const T& value) {
+  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
+  auto&& output = std::basic_ostream<Char>(&format_buf);
+#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+  output.imbue(std::locale::classic());  // The default is always unlocalized.
+#endif
+  output << value;
+  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+}
+
+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 OutputIt>
+  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
+      -> OutputIt {
+    auto buffer = basic_memory_buffer<Char>();
+    detail::format_value(buffer, value);
+    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 OutputIt>
+  auto format(detail::streamed_view<T> view,
+              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
+    return basic_ostream_formatter<Char>::format(view.value, ctx);
+  }
+};
+
+/**
+  \rst
+  Returns a view that formats `value` via an ostream ``operator<<``.
+
+  **Example**::
+
+    fmt::print("Current thread id: {}\n",
+               fmt::streamed(std::this_thread::get_id()));
+  \endrst
+ */
+template <typename T>
+constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
+  return {value};
+}
+
+namespace detail {
+
+inline void vprint_directly(std::ostream& os, string_view format_str,
+                            format_args args) {
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, format_str, args);
+  detail::write_buffer(os, buffer);
+}
+
+}  // namespace detail
+
+FMT_EXPORT template <typename Char>
+void vprint(std::basic_ostream<Char>& os,
+            basic_string_view<type_identity_t<Char>> format_str,
+            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  auto buffer = basic_memory_buffer<Char>();
+  detail::vformat_to(buffer, format_str, args);
+  if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return;
+  detail::write_buffer(os, buffer);
+}
+
+/**
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    fmt::print(cerr, "Don't {}!", "panic");
+  \endrst
+ */
+FMT_EXPORT template <typename... T>
+void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
+  const auto& vargs = fmt::make_format_args(args...);
+  if (detail::is_utf8())
+    vprint(os, fmt, vargs);
+  else
+    detail::vprint_directly(os, fmt, vargs);
+}
+
+FMT_EXPORT
+template <typename... Args>
+void print(std::wostream& os,
+           basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
+           Args&&... args) {
+  vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
+}
+
+FMT_EXPORT template <typename... T>
+void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
+  fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
+}
+
+FMT_EXPORT
+template <typename... Args>
+void println(std::wostream& os,
+             basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
+             Args&&... args) {
+  print(os, L"{}\n", fmt::format(fmt, std::forward<Args>(args)...));
+}
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_OSTREAM_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/printf.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/printf.h
new file mode 100644
index 0000000000000000000000000000000000000000..07e81577cf3209bb09b1dc35ef1ef4233a2356fc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/printf.h
@@ -0,0 +1,675 @@
+// 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_
+
+#include <algorithm>  // std::max
+#include <limits>     // std::numeric_limits
+
+#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:
+  detail::buffer_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 = basic_format_parse_context<Char>;
+  template <typename T> using formatter_type = printf_formatter<T>;
+
+  /**
+    \rst
+    Constructs a ``printf_context`` object. References to the arguments are
+    stored in the context object so make sure they have appropriate lifetimes.
+    \endrst
+   */
+  basic_printf_context(detail::buffer_appender<Char> out,
+                       basic_format_args<basic_printf_context> args)
+      : out_(out), args_(args) {}
+
+  auto out() -> detail::buffer_appender<Char> { return out_; }
+  void advance_to(detail::buffer_appender<Char>) {}
+
+  auto locale() -> detail::locale_ref { return {}; }
+
+  auto arg(int id) const -> basic_format_arg<basic_printf_context> {
+    return args_.get(id);
+  }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    detail::error_handler().on_error(message);
+  }
+};
+
+namespace detail {
+
+// 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 = max_value<int>();
+    return value <= max;
+  }
+  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>();
+  }
+  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))
+      throw_format_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 {
+    throw_format_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.
+      if (is_signed) {
+        auto n = static_cast<int>(static_cast<target_type>(value));
+        arg_ = detail::make_arg<Context>(n);
+      } else {
+        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+        auto n = static_cast<unsigned>(static_cast<unsigned_type>(value));
+        arg_ = detail::make_arg<Context>(n);
+      }
+    } else {
+      if (is_signed) {
+        // 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.
+        auto n = static_cast<long long>(value);
+        arg_ = detail::make_arg<Context>(n);
+      } else {
+        auto n = static_cast<typename make_unsigned_or_bool<U>::type>(value);
+        arg_ = detail::make_arg<Context>(n);
+      }
+    }
+  }
+
+  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) {
+  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
+}
+
+// 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) {
+    auto c = static_cast<typename Context::char_type>(value);
+    arg_ = detail::make_arg<Context>(c);
+  }
+
+  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.
+template <typename Char> class printf_width_handler {
+ private:
+  format_specs<Char>& specs_;
+
+ public:
+  explicit printf_width_handler(format_specs<Char>& 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_.align = align::left;
+      width = 0 - width;
+    }
+    unsigned int_max = max_value<int>();
+    if (width > int_max) throw_format_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 {
+    throw_format_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(buffer_appender<Char> iter, format_specs<Char>& 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.type = presentation_type::none;
+    write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
+  }
+
+ public:
+  printf_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s,
+                       context_type& ctx)
+      : base(make_arg_formatter(iter, s)), context_(ctx) {}
+
+  void operator()(monostate value) { base::operator()(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) {
+      base::operator()(value);
+      return;
+    }
+    format_specs<Char> fmt_specs = this->specs;
+    if (fmt_specs.type != presentation_type::none &&
+        fmt_specs.type != presentation_type::chr) {
+      return (*this)(static_cast<int>(value));
+    }
+    fmt_specs.sign = sign::none;
+    fmt_specs.alt = false;
+    fmt_specs.fill[0] = ' ';  // Ignore '0' flag for char types.
+    // align::numeric needs to be overwritten here since the '0' flag is
+    // ignored for non-numeric types
+    if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
+      fmt_specs.align = align::right;
+    write<Char>(this->out, static_cast<Char>(value), fmt_specs);
+  }
+
+  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+  void operator()(T value) {
+    base::operator()(value);
+  }
+
+  /** Formats a null-terminated C string. */
+  void operator()(const char* value) {
+    if (value)
+      base::operator()(value);
+    else
+      write_null_pointer(this->specs.type != presentation_type::pointer);
+  }
+
+  /** Formats a null-terminated wide C string. */
+  void operator()(const wchar_t* value) {
+    if (value)
+      base::operator()(value);
+    else
+      write_null_pointer(this->specs.type != presentation_type::pointer);
+  }
+
+  void operator()(basic_string_view<Char> value) { base::operator()(value); }
+
+  /** Formats a pointer. */
+  void operator()(const void* value) {
+    if (value)
+      base::operator()(value);
+    else
+      write_null_pointer();
+  }
+
+  /** Formats an argument of a custom (user-defined) type. */
+  void operator()(typename basic_format_arg<context_type>::handle handle) {
+    auto parse_ctx = basic_format_parse_context<Char>({});
+    handle.format(parse_ctx, context_);
+  }
+};
+
+template <typename Char>
+void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) {
+  for (; it != end; ++it) {
+    switch (*it) {
+    case '-':
+      specs.align = align::left;
+      break;
+    case '+':
+      specs.sign = sign::plus;
+      break;
+    case '0':
+      specs.fill[0] = '0';
+      break;
+    case ' ':
+      if (specs.sign != sign::plus) specs.sign = sign::space;
+      break;
+    case '#':
+      specs.alt = true;
+      break;
+    default:
+      return;
+    }
+  }
+}
+
+template <typename Char, typename GetArg>
+auto parse_header(const Char*& it, const Char* end, format_specs<Char>& 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.fill[0] = '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) throw_format_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) throw_format_error("number is too big");
+    } else if (*it == '*') {
+      ++it;
+      specs.width = static_cast<int>(visit_format_arg(
+          detail::printf_width_handler<Char>(specs), get_arg(-1)));
+    }
+  }
+  return arg_index;
+}
+
+inline auto parse_printf_presentation_type(char c, type t)
+    -> 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':
+    return in(t, integral_set) ? pt::hex_lower : pt::none;
+  case 'X':
+    return in(t, integral_set) ? pt::hex_upper : pt::none;
+  case 'a':
+    return in(t, float_set) ? pt::hexfloat_lower : pt::none;
+  case 'A':
+    return in(t, float_set) ? pt::hexfloat_upper : pt::none;
+  case 'e':
+    return in(t, float_set) ? pt::exp_lower : pt::none;
+  case 'E':
+    return in(t, float_set) ? pt::exp_upper : pt::none;
+  case 'f':
+    return in(t, float_set) ? pt::fixed_lower : pt::none;
+  case 'F':
+    return in(t, float_set) ? pt::fixed_upper : pt::none;
+  case 'g':
+    return in(t, float_set) ? pt::general_lower : pt::none;
+  case 'G':
+    return in(t, float_set) ? pt::general_upper : 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 = buffer_appender<Char>;
+  auto out = iterator(buf);
+  auto context = basic_printf_context<Char>(out, args);
+  auto parse_ctx = basic_format_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<Char>();
+    specs.align = align::right;
+
+    // Parse argument index, flags and width.
+    int arg_index = parse_header(it, end, specs, get_arg);
+    if (arg_index == 0) throw_format_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>(
+            visit_format_arg(printf_precision_handler(), get_arg(-1)));
+      } 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 && arg.is_integral()) {
+      // Ignore '0' for non-numeric types or if '-' present.
+      specs.fill[0] = ' ';
+    }
+    if (specs.precision >= 0 && arg.type() == type::cstring_type) {
+      auto str = visit_format_arg(get_cstring<Char>(), arg);
+      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 = make_arg<basic_printf_context<Char>>(sv);
+    }
+    if (specs.alt && visit_format_arg(is_zero_int(), arg)) specs.alt = false;
+    if (specs.fill[0] == '0') {
+      if (arg.is_arithmetic() && specs.align != align::left)
+        specs.align = align::numeric;
+      else
+        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types or if '-'
+                              // flag is also present.
+    }
+
+    // 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) throw_format_error("invalid format string");
+    char type = static_cast<char>(*it++);
+    if (arg.is_integral()) {
+      // Normalize type.
+      switch (type) {
+      case 'i':
+      case 'u':
+        type = 'd';
+        break;
+      case 'c':
+        visit_format_arg(char_converter<basic_printf_context<Char>>(arg), arg);
+        break;
+      }
+    }
+    specs.type = parse_printf_presentation_type(type, arg.type());
+    if (specs.type == presentation_type::none)
+      throw_format_error("invalid format specifier");
+
+    start = it;
+
+    // Format argument.
+    visit_format_arg(printf_arg_formatter<Char>(out, specs, context), arg);
+  }
+  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>;
+
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::printf_args`.
+  \endrst
+ */
+template <typename... T>
+inline auto make_printf_args(const T&... args)
+    -> format_arg_store<printf_context, T...> {
+  return {args...};
+}
+
+// DEPRECATED!
+template <typename... T>
+inline auto make_wprintf_args(const T&... args)
+    -> format_arg_store<wprintf_context, T...> {
+  return {args...};
+}
+
+template <typename Char>
+inline auto vsprintf(
+    basic_string_view<Char> fmt,
+    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  auto buf = basic_memory_buffer<Char>();
+  detail::vprintf(buf, fmt, args);
+  return to_string(buf);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string.
+
+  **Example**::
+
+    std::string message = fmt::sprintf("The answer is %d", 42);
+  \endrst
+*/
+template <typename S, typename... T,
+          typename Char = enable_if_t<detail::is_string<S>::value, 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,
+    basic_format_args<basic_printf_context<type_identity_t<Char>>> 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);
+}
+
+/**
+  \rst
+  Prints formatted data to the file *f*.
+
+  **Example**::
+
+    fmt::fprintf(stderr, "Don't %s!", "panic");
+  \endrst
+ */
+template <typename S, typename... T, typename Char = char_t<S>>
+inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
+  return vfprintf(f, detail::to_string_view(fmt),
+                  fmt::make_format_args<basic_printf_context<Char>>(args...));
+}
+
+template <typename Char>
+FMT_DEPRECATED inline auto vprintf(
+    basic_string_view<Char> fmt,
+    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
+    -> int {
+  return vfprintf(stdout, fmt, args);
+}
+
+/**
+  \rst
+  Prints formatted data to ``stdout``.
+
+  **Example**::
+
+    fmt::printf("Elapsed time: %.2f seconds", 1.23);
+  \endrst
+ */
+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_wprintf_args(args...));
+}
+
+FMT_END_EXPORT
+FMT_END_NAMESPACE
+
+#endif  // FMT_PRINTF_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/ranges.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/ranges.h
new file mode 100644
index 0000000000000000000000000000000000000000..3638fffb83bce6035c13659f26fe13749c8b19ea
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/ranges.h
@@ -0,0 +1,738 @@
+// 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_
+
+#include <initializer_list>
+#include <tuple>
+#include <type_traits>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+namespace detail {
+
+template <typename Range, typename OutputIt>
+auto copy(const Range& range, OutputIt out) -> OutputIt {
+  for (auto it = range.begin(), end = range.end(); it != end; ++it)
+    *out++ = *it;
+  return out;
+}
+
+template <typename OutputIt>
+auto copy(const char* str, OutputIt out) -> OutputIt {
+  while (*str) *out++ = *str++;
+  return out;
+}
+
+template <typename OutputIt> auto copy(char ch, OutputIt out) -> OutputIt {
+  *out++ = ch;
+  return out;
+}
+
+template <typename OutputIt> auto copy(wchar_t ch, OutputIt out) -> OutputIt {
+  *out++ = ch;
+  return out;
+}
+
+// Returns true if T has a std::string-like interface, like std::string_view.
+template <typename T> class is_std_string_like {
+  template <typename U>
+  static auto check(U* p)
+      -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
+  template <typename> static void check(...);
+
+ public:
+  static constexpr const bool value =
+      is_string<T>::value ||
+      std::is_convertible<T, std_string_view<char>>::value ||
+      !std::is_void<decltype(check<T>(nullptr))>::value;
+};
+
+template <typename Char>
+struct is_std_string_like<fmt::basic_string_view<Char>> : std::true_type {};
+
+template <typename T> class is_map {
+  template <typename U> static auto check(U*) -> typename U::mapped_type;
+  template <typename> static void check(...);
+
+ public:
+#ifdef FMT_FORMAT_MAP_AS_LIST  // DEPRECATED!
+  static constexpr const bool value = false;
+#else
+  static constexpr const bool value =
+      !std::is_void<decltype(check<T>(nullptr))>::value;
+#endif
+};
+
+template <typename T> class is_set {
+  template <typename U> static auto check(U*) -> typename U::key_type;
+  template <typename> static void check(...);
+
+ public:
+#ifdef FMT_FORMAT_SET_AS_LIST  // DEPRECATED!
+  static constexpr const bool value = false;
+#else
+  static constexpr const bool value =
+      !std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value;
+#endif
+};
+
+template <typename... Ts> struct conditional_helper {};
+
+template <typename T, typename _ = void> struct is_range_ : std::false_type {};
+
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION > 1800
+
+#  define FMT_DECLTYPE_RETURN(val)  \
+    ->decltype(val) { return val; } \
+    static_assert(                  \
+        true, "")  // This makes it so that a semicolon is required after the
+                   // macro, which helps clang-format handle the formatting.
+
+// 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 overload
+template <typename T>
+auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).begin());
+template <typename T>
+auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).end());
+
+// ADL overload. Only participates 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>
+struct is_range_<T, void>
+    : std::integral_constant<bool, (has_const_begin_end<T>::value ||
+                                    has_mutable_begin_end<T>::value)> {};
+#  undef FMT_DECLTYPE_RETURN
+#endif
+
+// tuple_size and tuple_element check.
+template <typename T> class is_tuple_like_ {
+  template <typename U>
+  static auto check(U* p) -> decltype(std::tuple_size<U>::value, int());
+  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 <std::size_t... Is>
+  static auto check2(index_sequence<Is...>,
+                     integer_sequence<bool, (Is == Is)...>) -> std::true_type;
+  static auto check2(...) -> std::false_type;
+  template <std::size_t... Is>
+  static auto check(index_sequence<Is...>) -> decltype(check2(
+      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&, ...) {}
+
+// These are not generic lambdas for compatibility with C++11.
+template <typename ParseContext> struct parse_empty_specs {
+  template <typename Formatter> FMT_CONSTEXPR void operator()(Formatter& f) {
+    f.parse(ctx);
+    detail::maybe_set_debug_format(f, true);
+  }
+  ParseContext& 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_str<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;
+  }
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    auto it = ctx.begin();
+    if (it != ctx.end() && *it != '}')
+      FMT_THROW(format_error("invalid format specifier"));
+    detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
+    return it;
+  }
+
+  template <typename FormatContext>
+  auto format(const Tuple& value, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    ctx.advance_to(detail::copy_str<Char>(opening_bracket_, ctx.out()));
+    detail::for_each2(
+        formatters_, value,
+        detail::format_tuple_element<FormatContext>{0, ctx, separator_});
+    return detail::copy_str<Char>(closing_bracket_, ctx.out());
+  }
+};
+
+template <typename T, typename Char> struct is_range {
+  static constexpr const bool value =
+      detail::is_range_<T>::value && !detail::is_std_string_like<T>::value &&
+      !std::is_convertible<T, std::basic_string<Char>>::value &&
+      !std::is_convertible<T, detail::std_string_view<Char>>::value;
+};
+
+namespace detail {
+template <typename Context> struct range_mapper {
+  using mapper = arg_mapper<Context>;
+
+  template <typename T,
+            FMT_ENABLE_IF(has_formatter<remove_cvref_t<T>, Context>::value)>
+  static auto map(T&& value) -> T&& {
+    return static_cast<T&&>(value);
+  }
+  template <typename T,
+            FMT_ENABLE_IF(!has_formatter<remove_cvref_t<T>, Context>::value)>
+  static auto map(T&& value)
+      -> decltype(mapper().map(static_cast<T&&>(value))) {
+    return mapper().map(static_cast<T&&>(value));
+  }
+};
+
+template <typename Char, typename Element>
+using range_formatter_type =
+    formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map(
+                  std::declval<Element>()))>,
+              Char>;
+
+template <typename R>
+using maybe_const_range =
+    conditional_t<has_const_begin_end<R>::value, const R, R>;
+
+// Workaround a bug in MSVC 2015 and earlier.
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
+template <typename R, typename Char>
+struct is_formattable_delayed
+    : is_formattable<uncvref_type<maybe_const_range<R>>, Char> {};
+#endif
+}  // 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, ']'>{};
+
+ 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;
+  }
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    auto it = ctx.begin();
+    auto end = ctx.end();
+
+    if (it != end && *it == 'n') {
+      set_brackets({}, {});
+      ++it;
+    }
+
+    if (it != end && *it != '}') {
+      if (*it != ':') FMT_THROW(format_error("invalid format specifier"));
+      ++it;
+    } else {
+      detail::maybe_set_debug_format(underlying_, true);
+    }
+
+    ctx.advance_to(it);
+    return underlying_.parse(ctx);
+  }
+
+  template <typename R, typename FormatContext>
+  auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
+    detail::range_mapper<buffer_context<Char>> mapper;
+    auto out = ctx.out();
+    out = detail::copy_str<Char>(opening_bracket_, out);
+    int i = 0;
+    auto it = detail::range_begin(range);
+    auto end = detail::range_end(range);
+    for (; it != end; ++it) {
+      if (i > 0) out = detail::copy_str<Char>(separator_, out);
+      ctx.advance_to(out);
+      auto&& item = *it;
+      out = underlying_.format(mapper.map(item), ctx);
+      ++i;
+    }
+    out = detail::copy_str<Char>(closing_bracket_, out);
+    return out;
+  }
+};
+
+enum class range_format { disabled, map, set, sequence, string, debug_string };
+
+namespace detail {
+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, typename R, typename Char, typename Enable = void>
+struct range_default_formatter;
+
+template <range_format K>
+using range_format_constant = std::integral_constant<range_format, K>;
+
+template <range_format K, typename R, typename Char>
+struct range_default_formatter<
+    K, R, Char,
+    enable_if_t<(K == range_format::sequence || K == range_format::map ||
+                 K == range_format::set)>> {
+  using range_type = detail::maybe_const_range<R>;
+  range_formatter<detail::uncvref_type<range_type>, Char> underlying_;
+
+  FMT_CONSTEXPR range_default_formatter() { init(range_format_constant<K>()); }
+
+  FMT_CONSTEXPR void init(range_format_constant<range_format::set>) {
+    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
+                             detail::string_literal<Char, '}'>{});
+  }
+
+  FMT_CONSTEXPR void init(range_format_constant<range_format::map>) {
+    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
+                             detail::string_literal<Char, '}'>{});
+    underlying_.underlying().set_brackets({}, {});
+    underlying_.underlying().set_separator(
+        detail::string_literal<Char, ':', ' '>{});
+  }
+
+  FMT_CONSTEXPR void init(range_format_constant<range_format::sequence>) {}
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return underlying_.parse(ctx);
+  }
+
+  template <typename FormatContext>
+  auto format(range_type& range, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return underlying_.format(range, ctx);
+  }
+};
+}  // namespace detail
+
+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>
+// Workaround a bug in MSVC 2015 and earlier.
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
+                            ,
+                            detail::is_formattable_delayed<R, Char>
+#endif
+                            >::value>>
+    : detail::range_default_formatter<range_format_kind<R, Char>::value, R,
+                                      Char> {
+};
+
+template <typename Char, typename... T> struct tuple_join_view : detail::view {
+  const std::tuple<T...>& tuple;
+  basic_string_view<Char> sep;
+
+  tuple_join_view(const std::tuple<T...>& 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... T>
+struct formatter<tuple_join_view<Char, T...>, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return do_parse(ctx, std::integral_constant<size_t, sizeof...(T)>());
+  }
+
+  template <typename FormatContext>
+  auto format(const tuple_join_view<Char, T...>& value,
+              FormatContext& ctx) const -> typename FormatContext::iterator {
+    return do_format(value, ctx,
+                     std::integral_constant<size_t, sizeof...(T)>());
+  }
+
+ private:
+  std::tuple<formatter<typename std::decay<T>::type, Char>...> formatters_;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto do_parse(ParseContext& ctx,
+                              std::integral_constant<size_t, 0>)
+      -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename ParseContext, size_t N>
+  FMT_CONSTEXPR auto do_parse(ParseContext& ctx,
+                              std::integral_constant<size_t, N>)
+      -> decltype(ctx.begin()) {
+    auto end = ctx.begin();
+#if FMT_TUPLE_JOIN_SPECIFIERS
+    end = std::get<sizeof...(T) - N>(formatters_).parse(ctx);
+    if (N > 1) {
+      auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>());
+      if (end != end1)
+        FMT_THROW(format_error("incompatible format specs for tuple elements"));
+    }
+#endif
+    return end;
+  }
+
+  template <typename FormatContext>
+  auto do_format(const tuple_join_view<Char, T...>&, 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, T...>& value, FormatContext& ctx,
+                 std::integral_constant<size_t, N>) const ->
+      typename FormatContext::iterator {
+    auto out = std::get<sizeof...(T) - N>(formatters_)
+                   .format(std::get<sizeof...(T) - N>(value.tuple), ctx);
+    if (N > 1) {
+      out = std::copy(value.sep.begin(), value.sep.end(), out);
+      ctx.advance_to(out);
+      return do_format(value, ctx, std::integral_constant<size_t, N - 1>());
+    }
+    return out;
+  }
+};
+
+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& t, FormatContext& ctx) const -> decltype(ctx.out()) {
+    struct getter : T {
+      static auto get(const T& t) -> all {
+        return {t.*(&getter::c)};  // Access c through the derived class.
+      }
+    };
+    return formatter<all>::format(getter::get(t), ctx);
+  }
+};
+
+FMT_BEGIN_EXPORT
+
+/**
+  \rst
+  Returns an object that formats `tuple` with elements separated by `sep`.
+
+  **Example**::
+
+    std::tuple<int, char> t = {1, 'a'};
+    fmt::print("{}", fmt::join(t, ", "));
+    // Output: "1, a"
+  \endrst
+ */
+template <typename... T>
+FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
+    -> tuple_join_view<char, T...> {
+  return {tuple, sep};
+}
+
+template <typename... T>
+FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple,
+                        basic_string_view<wchar_t> sep)
+    -> tuple_join_view<wchar_t, T...> {
+  return {tuple, sep};
+}
+
+/**
+  \rst
+  Returns an object that formats `initializer_list` with elements separated by
+  `sep`.
+
+  **Example**::
+
+    fmt::print("{}", fmt::join({1, 2, 3}, ", "));
+    // Output: "1, 2, 3"
+  \endrst
+ */
+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_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/std.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/std.h
new file mode 100644
index 0000000000000000000000000000000000000000..7cff1159201d2d821df89f5276d85d78b6d2e603
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/std.h
@@ -0,0 +1,537 @@
+// 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 <atomic>
+#include <bitset>
+#include <cstdlib>
+#include <exception>
+#include <memory>
+#include <thread>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+#include <vector>
+
+#include "format.h"
+#include "ostream.h"
+
+#if FMT_HAS_INCLUDE(<version>)
+#  include <version>
+#endif
+// Checking FMT_CPLUSPLUS for warning suppression in MSVC.
+#if FMT_CPLUSPLUS >= 201703L
+#  if FMT_HAS_INCLUDE(<filesystem>)
+#    include <filesystem>
+#  endif
+#  if FMT_HAS_INCLUDE(<variant>)
+#    include <variant>
+#  endif
+#  if FMT_HAS_INCLUDE(<optional>)
+#    include <optional>
+#  endif
+#endif
+
+#if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
+#  include <source_location>
+#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
+
+// Check if typeid is available.
+#ifndef FMT_USE_TYPEID
+// __RTTI is for EDG compilers. In MSVC typeid is available without RTTI.
+#  if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || FMT_MSC_VERSION || \
+      defined(__INTEL_RTTI__) || defined(__RTTI)
+#    define FMT_USE_TYPEID 1
+#  else
+#    define FMT_USE_TYPEID 0
+#  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
+
+FMT_EXPORT
+template <typename Char> struct formatter<std::filesystem::path, Char> {
+ private:
+  format_specs<Char> 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; }
+
+  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& 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;
+
+    it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
+    if (it != end && *it == '?') {
+      debug_ = true;
+      ++it;
+    }
+    if (it != end && (*it == 'g')) path_type_ = *it++;
+    return it;
+  }
+
+  template <typename FormatContext>
+  auto format(const std::filesystem::path& p, FormatContext& ctx) const {
+    auto specs = specs_;
+#  ifdef _WIN32
+    auto path_string = !path_type_ ? p.native() : p.generic_wstring();
+#  else
+    auto path_string = !path_type_ ? p.native() : p.generic_string();
+#  endif
+
+    detail::handle_dynamic_spec<detail::width_checker>(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);
+  }
+};
+FMT_END_NAMESPACE
+#endif  // FMT_CPP_LIB_FILESYSTEM
+
+FMT_BEGIN_NAMESPACE
+FMT_EXPORT
+template <std::size_t N, typename Char>
+struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> {
+ 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 write_padded(ctx, writer{bs});
+  }
+};
+
+FMT_EXPORT
+template <typename Char>
+struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
+FMT_END_NAMESPACE
+
+#ifdef __cpp_lib_optional
+FMT_BEGIN_NAMESPACE
+FMT_EXPORT
+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:
+  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& 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
+
+#ifdef __cpp_lib_source_location
+FMT_BEGIN_NAMESPACE
+FMT_EXPORT
+template <> struct formatter<std::source_location> {
+  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& 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;
+};
+
+template <typename Char, typename OutputIt, typename T>
+auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt {
+  if constexpr (is_string<T>::value)
+    return write_escaped_string<Char>(out, detail::to_string_view(v));
+  else if constexpr (std::is_same_v<T, Char>)
+    return write_escaped_char(out, v);
+  else
+    return write<Char>(out, v);
+}
+
+}  // 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;
+};
+
+FMT_EXPORT
+template <typename Char> struct formatter<std::monostate, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const std::monostate&, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return detail::write<Char>(ctx.out(), "monostate");
+  }
+};
+
+FMT_EXPORT
+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>>>> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    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_variant_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
+FMT_EXPORT
+template <typename Char> struct formatter<std::error_code, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    out = detail::write_bytes(out, ec.category().name(), format_specs<Char>());
+    out = detail::write<Char>(out, Char(':'));
+    out = detail::write<Char>(out, ec.value());
+    return out;
+  }
+};
+
+FMT_EXPORT
+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(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto it = ctx.begin();
+    auto end = ctx.end();
+    if (it == end || *it == '}') return it;
+    if (*it == 't') {
+      ++it;
+      with_typename_ = FMT_USE_TYPEID != 0;
+    }
+    return it;
+  }
+
+  template <typename OutputIt>
+  auto format(const std::exception& ex,
+              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
+    format_specs<Char> spec;
+    auto out = ctx.out();
+    if (!with_typename_)
+      return detail::write_bytes(out, string_view(ex.what()), spec);
+
+#if FMT_USE_TYPEID
+    const std::type_info& ti = typeid(ex);
+#  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());
+    }
+    out = detail::write_bytes(out, demangled_name_view, spec);
+#  elif FMT_MSC_VERSION
+    string_view demangled_name_view(ti.name());
+    if (demangled_name_view.starts_with("class "))
+      demangled_name_view.remove_prefix(6);
+    else if (demangled_name_view.starts_with("struct "))
+      demangled_name_view.remove_prefix(7);
+    out = detail::write_bytes(out, demangled_name_view, spec);
+#  else
+    out = detail::write_bytes(out, string_view(ti.name()), spec);
+#  endif
+    *out++ = ':';
+    *out++ = ' ';
+    return detail::write_bytes(out, string_view(ex.what()), spec);
+#endif
+  }
+};
+
+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.
+FMT_EXPORT
+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);
+  }
+};
+
+FMT_EXPORT
+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
+FMT_EXPORT
+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
+
+FMT_END_NAMESPACE
+#endif  // FMT_STD_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/xchar.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/xchar.h
new file mode 100644
index 0000000000000000000000000000000000000000..f609c5c41a22925c46a44953b22857a17a8dda5d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include/fmt/xchar.h
@@ -0,0 +1,259 @@
+// 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 <cwchar>
+
+#include "format.h"
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+#  include <locale>
+#endif
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template <typename T>
+using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
+
+inline auto write_loc(std::back_insert_iterator<detail::buffer<wchar_t>> out,
+                      loc_value value, const format_specs<wchar_t>& specs,
+                      locale_ref loc) -> bool {
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+  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 = basic_format_parse_context<wchar_t>;
+using wformat_context = buffer_context<wchar_t>;
+using wformat_args = basic_format_args<wformat_context>;
+using wmemory_buffer = basic_memory_buffer<wchar_t>;
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+// Workaround broken conversion on older gcc.
+template <typename... Args> using wformat_string = wstring_view;
+inline auto runtime(wstring_view s) -> wstring_view { return s; }
+#else
+template <typename... Args>
+using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
+inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
+  return {{s}};
+}
+#endif
+
+template <> struct is_char<wchar_t> : std::true_type {};
+template <> struct is_char<detail::char8_type> : std::true_type {};
+template <> struct is_char<char16_t> : std::true_type {};
+template <> struct is_char<char32_t> : std::true_type {};
+
+template <typename... T>
+constexpr auto make_wformat_args(const T&... args)
+    -> format_arg_store<wformat_context, T...> {
+  return {args...};
+}
+
+inline namespace literals {
+#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS
+constexpr auto operator""_a(const wchar_t* s, size_t)
+    -> detail::udl_arg<wchar_t> {
+  return {s};
+}
+#endif
+}  // namespace literals
+
+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>
+auto join(Range&& range, wstring_view sep)
+    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<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 Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+auto vformat(basic_string_view<Char> format_str,
+             basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  auto buf = basic_memory_buffer<Char>();
+  detail::vformat_to(buf, format_str, args);
+  return to_string(buf);
+}
+
+template <typename... T>
+auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
+  return vformat(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 = char_t<S>,
+          FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
+                        !std::is_same<Char, wchar_t>::value)>
+auto format(const S& format_str, T&&... args) -> std::basic_string<Char> {
+  return vformat(detail::to_string_view(format_str),
+                 fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+template <typename Locale, typename S, typename Char = 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& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  return detail::vformat(loc, detail::to_string_view(format_str), args);
+}
+
+template <typename Locale, typename S, typename... T, typename Char = 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& format_str, T&&... args)
+    -> std::basic_string<Char> {
+  return detail::vformat(loc, detail::to_string_view(format_str),
+                         fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+template <typename OutputIt, typename S, typename Char = 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& format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> OutputIt {
+  auto&& buf = detail::get_buffer<Char>(out);
+  detail::vformat_to(buf, detail::to_string_view(format_str), args);
+  return detail::get_iterator(buf, out);
+}
+
+template <typename OutputIt, typename S, typename... T,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::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<buffer_context<Char>>(args...));
+}
+
+template <typename Locale, typename S, typename OutputIt, typename... Args,
+          typename Char = 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& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt {
+  auto&& buf = detail::get_buffer<Char>(out);
+  vformat_to(buf, detail::to_string_view(format_str), args,
+             detail::locale_ref(loc));
+  return detail::get_iterator(buf, out);
+}
+
+template <typename OutputIt, typename Locale, typename S, typename... T,
+          typename Char = 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& format_str,
+                      T&&... args) ->
+    typename std::enable_if<enable, OutputIt>::type {
+  return vformat_to(out, loc, detail::to_string_view(format_str),
+                    fmt::make_format_args<buffer_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> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> 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, format_str, args);
+  return {buf.out(), buf.count()};
+}
+
+template <typename OutputIt, typename S, typename... T,
+          typename Char = 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, detail::to_string_view(fmt),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+template <typename S, typename... T, typename Char = 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<buffer_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)...));
+}
+
+/**
+  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_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/fmt.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/fmt.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5330463a932cf51c1f9d9848dd652b20dabbed7e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/fmt.cc
@@ -0,0 +1,108 @@
+module;
+
+// Put all implementation-provided headers into the global module fragment
+// to prevent attachment to this module.
+#include <algorithm>
+#include <cerrno>
+#include <chrono>
+#include <climits>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <exception>
+#include <filesystem>
+#include <fstream>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <locale>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <system_error>
+#include <thread>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+#include <variant>
+#include <vector>
+#include <version>
+
+#if __has_include(<cxxabi.h>)
+#  include <cxxabi.h>
+#endif
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#  include <intrin.h>
+#endif
+#if defined __APPLE__ || defined(__FreeBSD__)
+#  include <xlocale.h>
+#endif
+#if __has_include(<winapifamily.h>)
+#  include <winapifamily.h>
+#endif
+#if (__has_include(<fcntl.h>) || defined(__APPLE__) || \
+     defined(__linux__)) &&                            \
+    (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+#  include <fcntl.h>
+#  include <sys/stat.h>
+#  include <sys/types.h>
+#  ifndef _WIN32
+#    include <unistd.h>
+#  else
+#    include <io.h>
+#  endif
+#endif
+#ifdef _WIN32
+#  if defined(__GLIBCXX__)
+#    include <ext/stdio_filebuf.h>
+#    include <ext/stdio_sync_filebuf.h>
+#  endif
+#  define WIN32_LEAN_AND_MEAN
+#  include <windows.h>
+#endif
+
+export module fmt;
+
+#define FMT_EXPORT export
+#define FMT_BEGIN_EXPORT export {
+#define FMT_END_EXPORT }
+
+// If you define FMT_ATTACH_TO_GLOBAL_MODULE
+//  - all declarations are detached from module 'fmt'
+//  - the module behaves like a traditional static library, too
+//  - all library symbols are mangled traditionally
+//  - you can mix TUs with either importing or #including the {fmt} API
+#ifdef FMT_ATTACH_TO_GLOBAL_MODULE
+extern "C++" {
+#endif
+
+// All library-provided declarations and definitions must be in the module
+// purview to be exported.
+#include "fmt/args.h"
+#include "fmt/chrono.h"
+#include "fmt/color.h"
+#include "fmt/compile.h"
+#include "fmt/format.h"
+#include "fmt/os.h"
+#include "fmt/printf.h"
+#include "fmt/std.h"
+#include "fmt/xchar.h"
+
+#ifdef FMT_ATTACH_TO_GLOBAL_MODULE
+}
+#endif
+
+// gcc doesn't yet implement private module fragments
+#if !FMT_GCC_VERSION
+module :private;
+#endif
+
+#include "format.cc"
+#include "os.cc"
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/format.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/format.cc
new file mode 100644
index 0000000000000000000000000000000000000000..391d3a248c26110e3bb165c6515b2a61ebd50bf7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/format.cc
@@ -0,0 +1,43 @@
+// Formatting library for C++
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/format-inl.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template FMT_API auto dragonbox::to_decimal(float x) noexcept
+    -> dragonbox::decimal_fp<float>;
+template FMT_API auto dragonbox::to_decimal(double x) noexcept
+    -> dragonbox::decimal_fp<double>;
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+template FMT_API locale_ref::locale_ref(const std::locale& loc);
+template FMT_API auto locale_ref::get<std::locale>() const -> std::locale;
+#endif
+
+// Explicit instantiations for char.
+
+template FMT_API auto thousands_sep_impl(locale_ref)
+    -> thousands_sep_result<char>;
+template FMT_API auto decimal_point_impl(locale_ref) -> char;
+
+template FMT_API void buffer<char>::append(const char*, const char*);
+
+template FMT_API void vformat_to(buffer<char>&, string_view,
+                                 typename vformat_args<>::type, locale_ref);
+
+// Explicit instantiations for wchar_t.
+
+template FMT_API auto thousands_sep_impl(locale_ref)
+    -> thousands_sep_result<wchar_t>;
+template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
+
+template FMT_API void buffer<wchar_t>::append(const wchar_t*, const wchar_t*);
+
+}  // namespace detail
+FMT_END_NAMESPACE
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/os.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/os.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a639e78c6028efd4cf64f2d53149e8794681d507
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/os.cc
@@ -0,0 +1,402 @@
+// Formatting library for C++ - optional OS-specific functionality
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+// Disable bogus MSVC warnings.
+#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
+#  define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "fmt/os.h"
+
+#include <climits>
+
+#if FMT_USE_FCNTL
+#  include <sys/stat.h>
+#  include <sys/types.h>
+
+#  ifdef _WRS_KERNEL    // VxWorks7 kernel
+#    include <ioLib.h>  // getpagesize
+#  endif
+
+#  ifndef _WIN32
+#    include <unistd.h>
+#  else
+#    ifndef WIN32_LEAN_AND_MEAN
+#      define WIN32_LEAN_AND_MEAN
+#    endif
+#    include <io.h>
+
+#    ifndef S_IRUSR
+#      define S_IRUSR _S_IREAD
+#    endif
+#    ifndef S_IWUSR
+#      define S_IWUSR _S_IWRITE
+#    endif
+#    ifndef S_IRGRP
+#      define S_IRGRP 0
+#    endif
+#    ifndef S_IWGRP
+#      define S_IWGRP 0
+#    endif
+#    ifndef S_IROTH
+#      define S_IROTH 0
+#    endif
+#    ifndef S_IWOTH
+#      define S_IWOTH 0
+#    endif
+#  endif  // _WIN32
+#endif    // FMT_USE_FCNTL
+
+#ifdef _WIN32
+#  include <windows.h>
+#endif
+
+namespace {
+#ifdef _WIN32
+// Return type of read and write functions.
+using rwresult = int;
+
+// On Windows the count argument to read and write is unsigned, so convert
+// it from size_t preventing integer overflow.
+inline unsigned convert_rwcount(std::size_t count) {
+  return count <= UINT_MAX ? static_cast<unsigned>(count) : UINT_MAX;
+}
+#elif FMT_USE_FCNTL
+// Return type of read and write functions.
+using rwresult = ssize_t;
+
+inline std::size_t convert_rwcount(std::size_t count) { return count; }
+#endif
+}  // namespace
+
+FMT_BEGIN_NAMESPACE
+
+#ifdef _WIN32
+namespace detail {
+
+class system_message {
+  system_message(const system_message&) = delete;
+  void operator=(const system_message&) = delete;
+
+  unsigned long result_;
+  wchar_t* message_;
+
+  static bool is_whitespace(wchar_t c) noexcept {
+    return c == L' ' || c == L'\n' || c == L'\r' || c == L'\t' || c == L'\0';
+  }
+
+ public:
+  explicit system_message(unsigned long error_code)
+      : result_(0), message_(nullptr) {
+    result_ = FormatMessageW(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+            FORMAT_MESSAGE_IGNORE_INSERTS,
+        nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        reinterpret_cast<wchar_t*>(&message_), 0, nullptr);
+    if (result_ != 0) {
+      while (result_ != 0 && is_whitespace(message_[result_ - 1])) {
+        --result_;
+      }
+    }
+  }
+  ~system_message() { LocalFree(message_); }
+  explicit operator bool() const noexcept { return result_ != 0; }
+  operator basic_string_view<wchar_t>() const noexcept {
+    return basic_string_view<wchar_t>(message_, result_);
+  }
+};
+
+class utf8_system_category final : public std::error_category {
+ public:
+  const char* name() const noexcept override { return "system"; }
+  std::string message(int error_code) const override {
+    auto&& msg = system_message(error_code);
+    if (msg) {
+      auto utf8_message = to_utf8<wchar_t>();
+      if (utf8_message.convert(msg)) {
+        return utf8_message.str();
+      }
+    }
+    return "unknown error";
+  }
+};
+
+}  // namespace detail
+
+FMT_API const std::error_category& system_category() noexcept {
+  static const detail::utf8_system_category category;
+  return category;
+}
+
+std::system_error vwindows_error(int err_code, string_view format_str,
+                                 format_args args) {
+  auto ec = std::error_code(err_code, system_category());
+  return std::system_error(ec, vformat(format_str, args));
+}
+
+void detail::format_windows_error(detail::buffer<char>& out, int error_code,
+                                  const char* message) noexcept {
+  FMT_TRY {
+    auto&& msg = system_message(error_code);
+    if (msg) {
+      auto utf8_message = to_utf8<wchar_t>();
+      if (utf8_message.convert(msg)) {
+        fmt::format_to(appender(out), FMT_STRING("{}: {}"), message,
+                       string_view(utf8_message));
+        return;
+      }
+    }
+  }
+  FMT_CATCH(...) {}
+  format_error_code(out, error_code, message);
+}
+
+void report_windows_error(int error_code, const char* message) noexcept {
+  report_error(detail::format_windows_error, error_code, message);
+}
+#endif  // _WIN32
+
+buffered_file::~buffered_file() noexcept {
+  if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
+    report_system_error(errno, "cannot close file");
+}
+
+buffered_file::buffered_file(cstring_view filename, cstring_view mode) {
+  FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())),
+                nullptr);
+  if (!file_)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot open file {}"),
+                           filename.c_str()));
+}
+
+void buffered_file::close() {
+  if (!file_) return;
+  int result = FMT_SYSTEM(fclose(file_));
+  file_ = nullptr;
+  if (result != 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot close file")));
+}
+
+int buffered_file::descriptor() const {
+#if !defined(fileno)
+  int fd = FMT_POSIX_CALL(fileno(file_));
+#elif defined(FMT_HAS_SYSTEM)
+  // fileno is a macro on OpenBSD so we cannot use FMT_POSIX_CALL.
+#  define FMT_DISABLE_MACRO
+  int fd = FMT_SYSTEM(fileno FMT_DISABLE_MACRO(file_));
+#else
+  int fd = fileno(file_);
+#endif
+  if (fd == -1)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot get file descriptor")));
+  return fd;
+}
+
+#if FMT_USE_FCNTL
+#  ifdef _WIN32
+using mode_t = int;
+#  endif
+constexpr mode_t default_open_mode =
+    S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
+
+file::file(cstring_view path, int oflag) {
+#  if defined(_WIN32) && !defined(__MINGW32__)
+  fd_ = -1;
+  auto converted = detail::utf8_to_utf16(string_view(path.c_str()));
+  *this = file::open_windows_file(converted.c_str(), oflag);
+#  else
+  FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, default_open_mode)));
+  if (fd_ == -1)
+    FMT_THROW(
+        system_error(errno, FMT_STRING("cannot open file {}"), path.c_str()));
+#  endif
+}
+
+file::~file() noexcept {
+  // Don't retry close in case of EINTR!
+  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
+  if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0)
+    report_system_error(errno, "cannot close file");
+}
+
+void file::close() {
+  if (fd_ == -1) return;
+  // Don't retry close in case of EINTR!
+  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
+  int result = FMT_POSIX_CALL(close(fd_));
+  fd_ = -1;
+  if (result != 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot close file")));
+}
+
+long long file::size() const {
+#  ifdef _WIN32
+  // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT
+  // is less than 0x0500 as is the case with some default MinGW builds.
+  // Both functions support large file sizes.
+  DWORD size_upper = 0;
+  HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd_));
+  DWORD size_lower = FMT_SYSTEM(GetFileSize(handle, &size_upper));
+  if (size_lower == INVALID_FILE_SIZE) {
+    DWORD error = GetLastError();
+    if (error != NO_ERROR)
+      FMT_THROW(windows_error(GetLastError(), "cannot get file size"));
+  }
+  unsigned long long long_size = size_upper;
+  return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower;
+#  else
+  using Stat = struct stat;
+  Stat file_stat = Stat();
+  if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot get file attributes")));
+  static_assert(sizeof(long long) >= sizeof(file_stat.st_size),
+                "return type of file::size is not large enough");
+  return file_stat.st_size;
+#  endif
+}
+
+std::size_t file::read(void* buffer, std::size_t count) {
+  rwresult result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot read from file")));
+  return detail::to_unsigned(result);
+}
+
+std::size_t file::write(const void* buffer, std::size_t count) {
+  rwresult result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+  return detail::to_unsigned(result);
+}
+
+file file::dup(int fd) {
+  // Don't retry as dup doesn't return EINTR.
+  // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
+  int new_fd = FMT_POSIX_CALL(dup(fd));
+  if (new_fd == -1)
+    FMT_THROW(system_error(
+        errno, FMT_STRING("cannot duplicate file descriptor {}"), fd));
+  return file(new_fd);
+}
+
+void file::dup2(int fd) {
+  int result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
+  if (result == -1) {
+    FMT_THROW(system_error(
+        errno, FMT_STRING("cannot duplicate file descriptor {} to {}"), fd_,
+        fd));
+  }
+}
+
+void file::dup2(int fd, std::error_code& ec) noexcept {
+  int result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
+  if (result == -1) ec = std::error_code(errno, std::generic_category());
+}
+
+void file::pipe(file& read_end, file& write_end) {
+  // Close the descriptors first to make sure that assignments don't throw
+  // and there are no leaks.
+  read_end.close();
+  write_end.close();
+  int fds[2] = {};
+#  ifdef _WIN32
+  // Make the default pipe capacity same as on Linux 2.6.11+.
+  enum { DEFAULT_CAPACITY = 65536 };
+  int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY));
+#  else
+  // Don't retry as the pipe function doesn't return EINTR.
+  // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
+  int result = FMT_POSIX_CALL(pipe(fds));
+#  endif
+  if (result != 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot create pipe")));
+  // The following assignments don't throw because read_fd and write_fd
+  // are closed.
+  read_end = file(fds[0]);
+  write_end = file(fds[1]);
+}
+
+buffered_file file::fdopen(const char* mode) {
+// Don't retry as fdopen doesn't return EINTR.
+#  if defined(__MINGW32__) && defined(_POSIX_)
+  FILE* f = ::fdopen(fd_, mode);
+#  else
+  FILE* f = FMT_POSIX_CALL(fdopen(fd_, mode));
+#  endif
+  if (!f) {
+    FMT_THROW(system_error(
+        errno, FMT_STRING("cannot associate stream with file descriptor")));
+  }
+  buffered_file bf(f);
+  fd_ = -1;
+  return bf;
+}
+
+#  if defined(_WIN32) && !defined(__MINGW32__)
+file file::open_windows_file(wcstring_view path, int oflag) {
+  int fd = -1;
+  auto err = _wsopen_s(&fd, path.c_str(), oflag, _SH_DENYNO, default_open_mode);
+  if (fd == -1) {
+    FMT_THROW(system_error(err, FMT_STRING("cannot open file {}"),
+                           detail::to_utf8<wchar_t>(path.c_str()).c_str()));
+  }
+  return file(fd);
+}
+#  endif
+
+#  if !defined(__MSDOS__)
+long getpagesize() {
+#    ifdef _WIN32
+  SYSTEM_INFO si;
+  GetSystemInfo(&si);
+  return si.dwPageSize;
+#    else
+#      ifdef _WRS_KERNEL
+  long size = FMT_POSIX_CALL(getpagesize());
+#      else
+  long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE));
+#      endif
+
+  if (size < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot get memory page size")));
+  return size;
+#    endif
+}
+#  endif
+
+namespace detail {
+
+void file_buffer::grow(size_t) {
+  if (this->size() == this->capacity()) flush();
+}
+
+file_buffer::file_buffer(cstring_view path,
+                         const detail::ostream_params& params)
+    : file_(path, params.oflag) {
+  set(new char[params.buffer_size], params.buffer_size);
+}
+
+file_buffer::file_buffer(file_buffer&& other)
+    : detail::buffer<char>(other.data(), other.size(), other.capacity()),
+      file_(std::move(other.file_)) {
+  other.clear();
+  other.set(nullptr, 0);
+}
+
+file_buffer::~file_buffer() {
+  flush();
+  delete[] data();
+}
+}  // namespace detail
+
+ostream::~ostream() = default;
+#endif  // FMT_USE_FCNTL
+FMT_END_NAMESPACE
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/Android.mk b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/Android.mk
new file mode 100644
index 0000000000000000000000000000000000000000..84a3e32f07181cfc2f4d66875cd919c2f844ee71
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/Android.mk
@@ -0,0 +1,15 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := fmt_static
+LOCAL_MODULE_FILENAME := libfmt
+
+LOCAL_SRC_FILES := ../src/format.cc
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
+
+LOCAL_CFLAGS += -std=c++11 -fexceptions
+
+include $(BUILD_STATIC_LIBRARY)
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/AndroidManifest.xml b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/AndroidManifest.xml
new file mode 100644
index 0000000000000000000000000000000000000000..c282ef5a5429065feec76bde3615800caa6ada9d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/AndroidManifest.xml
@@ -0,0 +1 @@
+<manifest package="dev.fmt" />
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/C++.sublime-syntax b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/C++.sublime-syntax
new file mode 100644
index 0000000000000000000000000000000000000000..9dfb5cbe4324c81808fd02d0c7e371265a5141cf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/C++.sublime-syntax
@@ -0,0 +1,2061 @@
+%YAML 1.2
+---
+# http://www.sublimetext.com/docs/3/syntax.html
+name: C++ (fmt)
+comment: I don't think anyone uses .hp. .cp tends to be paired with .h. (I could be wrong. :) -- chris
+file_extensions:
+  - cpp
+  - cc
+  - cp
+  - cxx
+  - c++
+  - C
+  - h
+  - hh
+  - hpp
+  - hxx
+  - h++
+  - inl
+  - ipp
+first_line_match: '-\*- C\+\+ -\*-'
+scope: source.c++
+variables:
+  identifier: \b[[:alpha:]_][[:alnum:]_]*\b # upper and lowercase
+  macro_identifier: \b[[:upper:]_][[:upper:][:digit:]_]{2,}\b # only uppercase, at least 3 chars
+  path_lookahead: '(?:::\s*)?(?:{{identifier}}\s*::\s*)*(?:template\s+)?{{identifier}}'
+  operator_method_name: '\boperator\s*(?:[-+*/%^&|~!=<>]|[-+*/%^&|=!<>]=|<<=?|>>=?|&&|\|\||\+\+|--|,|->\*?|\(\)|\[\]|""\s*{{identifier}})'
+  casts: 'const_cast|dynamic_cast|reinterpret_cast|static_cast'
+  operator_keywords: 'and|and_eq|bitand|bitor|compl|not|not_eq|or|or_eq|xor|xor_eq|noexcept'
+  control_keywords: 'break|case|catch|continue|default|do|else|for|goto|if|_Pragma|return|switch|throw|try|while'
+  memory_operators: 'new|delete'
+  basic_types: 'asm|__asm__|auto|bool|_Bool|char|_Complex|double|float|_Imaginary|int|long|short|signed|unsigned|void'
+  before_tag: 'struct|union|enum\s+class|enum\s+struct|enum|class'
+  declspec: '__declspec\(\s*\w+(?:\([^)]+\))?\s*\)'
+  storage_classes: 'static|export|extern|friend|explicit|virtual|register|thread_local'
+  type_qualifier: 'const|constexpr|mutable|typename|volatile'
+  compiler_directive: 'inline|restrict|__restrict__|__restrict'
+  visibility_modifiers: 'private|protected|public'
+  other_keywords: 'typedef|nullptr|{{visibility_modifiers}}|static_assert|sizeof|using|typeid|alignof|alignas|namespace|template'
+  modifiers: '{{storage_classes}}|{{type_qualifier}}|{{compiler_directive}}'
+  non_angle_brackets: '(?=<<|<=)'
+
+  regular: '[^(){}&;*^%=<>-]*'
+  paren_open: (?:\(
+  paren_close: '\))?'
+  generic_open: (?:<
+  generic_close: '>)?'
+  balance_parentheses: '{{regular}}{{paren_open}}{{regular}}{{paren_close}}{{regular}}'
+  generic_lookahead: <{{regular}}{{generic_open}}{{regular}}{{generic_open}}{{regular}}{{generic_close}}\s*{{generic_close}}{{balance_parentheses}}>
+
+  data_structures_forward_decl_lookahead: '(\s+{{macro_identifier}})*\s*(:\s*({{path_lookahead}}|{{visibility_modifiers}}|,|\s|<[^;]*>)+)?;'
+  non_func_keywords: 'if|for|switch|while|decltype|sizeof|__declspec|__attribute__|typeid|alignof|alignas|static_assert'
+
+  format_spec: |-
+    (?x:
+      (?:.? [<>=^])?     # fill align
+      [ +-]?             # sign
+      \#?                # alternate form
+      # technically, octal and hexadecimal integers are also supported as 'width', but rarely used
+      \d*                # width
+      ,?                 # thousands separator
+      (?:\.\d+)?         # precision
+      [bcdeEfFgGnosxX%]? # type
+    )
+
+contexts:
+  main:
+    - include: preprocessor-global
+    - include: global
+
+  #############################################################################
+  # Reusable contexts
+  #
+  # The follow contexts are currently constructed to be reused in the
+  # Objetive-C++ syntax. They are specifically constructed to not push into
+  # sub-contexts, which ensures that Objective-C++ code isn't accidentally
+  # lexed as plain C++.
+  #
+  # The "unique-*" contexts are additions that C++ makes over C, and thus can
+  # be directly reused in Objective-C++ along with contexts from Objective-C
+  # and C.
+  #############################################################################
+
+  unique-late-expressions:
+    # This is highlighted after all of the other control keywords
+    # to allow operator overloading to be lexed properly
+    - match: \boperator\b
+      scope: keyword.control.c++
+
+  unique-modifiers:
+    - match: \b({{modifiers}})\b
+      scope: storage.modifier.c++
+
+  unique-variables:
+    - match: \bthis\b
+      scope: variable.language.c++
+    # common C++ instance var naming idiom -- fMemberName
+    - match: '\b(f|m)[[:upper:]]\w*\b'
+      scope: variable.other.readwrite.member.c++
+    # common C++ instance var naming idiom -- m_member_name
+    - match: '\bm_[[:alnum:]_]+\b'
+      scope: variable.other.readwrite.member.c++
+
+  unique-constants:
+    - match: \bnullptr\b
+      scope: constant.language.c++
+
+  unique-keywords:
+    - match: \busing\b
+      scope: keyword.control.c++
+    - match: \bbreak\b
+      scope: keyword.control.flow.break.c++
+    - match: \bcontinue\b
+      scope: keyword.control.flow.continue.c++
+    - match: \bgoto\b
+      scope: keyword.control.flow.goto.c++
+    - match: \breturn\b
+      scope: keyword.control.flow.return.c++
+    - match: \bthrow\b
+      scope: keyword.control.flow.throw.c++
+    - match: \b({{control_keywords}})\b
+      scope: keyword.control.c++
+    - match: '\bdelete\b(\s*\[\])?|\bnew\b(?!])'
+      scope: keyword.control.c++
+    - match: \b({{operator_keywords}})\b
+      scope: keyword.operator.word.c++
+
+  unique-types:
+    - match: \b(char16_t|char32_t|wchar_t|nullptr_t)\b
+      scope: storage.type.c++
+    - match: \bclass\b
+      scope: storage.type.c++
+
+  unique-strings:
+    - match: '((?:L|u8|u|U)?R)("([^\(\)\\ ]{0,16})\()'
+      captures:
+        1: storage.type.string.c++
+        2: punctuation.definition.string.begin.c++
+      push:
+        - meta_scope: string.quoted.double.c++
+        - match: '\)\3"'
+          scope: punctuation.definition.string.end.c++
+          pop: true
+        - match: '\{\{|\}\}'
+          scope: constant.character.escape.c++
+        - include: formatting-syntax
+
+  unique-numbers:
+    - match: |-
+        (?x)
+        (?:
+        # floats
+          (?:
+          (?:\b\d(?:[\d']*\d)?\.\d(?:[\d']*\d)?|\B\.\d(?:[\d']*\d)?)(?:[Ee][+-]?\d(?:[\d']*\d)?)?(?:[fFlL]|(?:i[fl]?|h|min|[mun]?s|_\w*))?\b
+          |
+          (?:\b\d(?:[\d']*\d)?\.)(?:\B|(?:[fFlL]|(?:i[fl]?|h|min|[mun]?s|_\w*))\b|(?:[Ee][+-]?\d(?:[\d']*\d)?)(?:[fFlL]|(?:i[fl]?|h|min|[mun]?s|_\w*))?\b)
+          |
+          \b\d(?:[\d']*\d)?(?:[Ee][+-]?\d(?:[\d']*\d)?)(?:[fFlL]|(?:i[fl]?|h|min|[mun]?s|_\w*))?\b
+          )
+        |
+        # ints
+          \b(?:
+          (?:
+          # dec
+          [1-9](?:[\d']*\d)?
+          |
+          # oct
+          0(?:[0-7']*[0-7])?
+          |
+          # hex
+          0[Xx][\da-fA-F](?:[\da-fA-F']*[\da-fA-F])?
+          |
+          # bin
+          0[Bb][01](?:[01']*[01])?
+          )
+          # int suffixes
+          (?:(?:l{1,2}|L{1,2})[uU]?|[uU](?:l{0,2}|L{0,2})|(?:i[fl]?|h|min|[mun]?s|_\w*))?)\b
+        )
+        (?!\.) # Number must not be followed by a decimal point
+      scope: constant.numeric.c++
+
+  identifiers:
+    - match: '{{identifier}}\s*(::)\s*'
+      captures:
+        1: punctuation.accessor.c++
+    - match: '(?:(::)\s*)?{{identifier}}'
+      captures:
+        1: punctuation.accessor.c++
+
+  function-specifiers:
+    - match: \b(const|final|noexcept|override)\b
+      scope: storage.modifier.c++
+
+  #############################################################################
+  # The following are C++-specific contexts that should not be reused. This is
+  # because they push into subcontexts and use variables that are C++-specific.
+  #############################################################################
+
+  ## Common context layout
+
+  global:
+    - match: '(?=\btemplate\b)'
+      push:
+        - include: template
+        - match: (?=\S)
+          set: global-modifier
+    - include: namespace
+    - include: keywords-angle-brackets
+    - match: '(?={{path_lookahead}}\s*<)'
+      push: global-modifier
+    # Take care of comments just before a function definition.
+    - match: /\*
+      scope: punctuation.definition.comment.c
+      push:
+        - - match: \s*(?=\w)
+            set: global-modifier
+          - match: ""
+            pop: true
+        - - meta_scope: comment.block.c
+          - match: \*/
+            scope: punctuation.definition.comment.c
+            pop: true
+    - include: early-expressions
+    - match: ^\s*\b(extern)(?=\s+"C(\+\+)?")
+      scope: storage.modifier.c++
+      push:
+        - include: comments
+        - include: strings
+        - match: '\{'
+          scope: punctuation.section.block.begin.c++
+          set:
+            - meta_scope: meta.extern-c.c++
+            - match: '^\s*(#\s*ifdef)\s*__cplusplus\s*'
+              scope: meta.preprocessor.c++
+              captures:
+                1: keyword.control.import.c++
+              set:
+                - match: '\}'
+                  scope: punctuation.section.block.end.c++
+                  pop: true
+                - include: preprocessor-global
+                - include: global
+            - match: '\}'
+              scope: punctuation.section.block.end.c++
+              pop: true
+            - include: preprocessor-global
+            - include: global
+        - match: (?=\S)
+          set: global-modifier
+    - match: ^\s*(?=\w)
+      push: global-modifier
+    - include: late-expressions
+
+  statements:
+    - include: preprocessor-statements
+    - include: scope:source.c#label
+    - include: expressions
+
+  expressions:
+    - include: early-expressions
+    - include: late-expressions
+
+  early-expressions:
+    - include: early-expressions-before-generic-type
+    - include: generic-type
+    - include: early-expressions-after-generic-type
+
+  early-expressions-before-generic-type:
+    - include: preprocessor-expressions
+    - include: comments
+    - include: case-default
+    - include: typedef
+    - include: keywords-angle-brackets
+    - include: keywords-parens
+    - include: keywords
+    - include: numbers
+    # Prevent a '<' from getting scoped as the start of another template
+    # parameter list, if in reality a less-than-or-equals sign is meant.
+    - match: <=
+      scope: keyword.operator.comparison.c
+
+  early-expressions-after-generic-type:
+    - include: members-arrow
+    - include: operators
+    - include: members-dot
+    - include: strings
+    - include: parens
+    - include: brackets
+    - include: block
+    - include: variables
+    - include: constants
+    - match: ','
+      scope: punctuation.separator.c++
+    - match: '\)|\}'
+      scope: invalid.illegal.stray-bracket-end.c++
+
+  expressions-minus-generic-type:
+    - include: early-expressions-before-generic-type
+    - include: angle-brackets
+    - include: early-expressions-after-generic-type
+    - include: late-expressions
+
+  expressions-minus-generic-type-function-call:
+    - include: early-expressions-before-generic-type
+    - include: angle-brackets
+    - include: early-expressions-after-generic-type
+    - include: late-expressions-before-function-call
+    - include: identifiers
+    - match: ';'
+      scope: punctuation.terminator.c++
+
+  late-expressions:
+    - include: late-expressions-before-function-call
+    - include: function-call
+    - include: identifiers
+    - match: ';'
+      scope: punctuation.terminator.c++
+
+  late-expressions-before-function-call:
+    - include: unique-late-expressions
+    - include: modifiers-parens
+    - include: modifiers
+    - include: types
+
+  expressions-minus-function-call:
+    - include: early-expressions
+    - include: late-expressions-before-function-call
+    - include: identifiers
+    - match: ';'
+      scope: punctuation.terminator.c++
+
+  comments:
+    - include: scope:source.c#comments
+
+  operators:
+    - include: scope:source.c#operators
+
+  modifiers:
+    - include: unique-modifiers
+    - include: scope:source.c#modifiers
+
+  variables:
+    - include: unique-variables
+    - include: scope:source.c#variables
+
+  constants:
+    - include: unique-constants
+    - include: scope:source.c#constants
+
+  keywords:
+    - include: unique-keywords
+    - include: scope:source.c#keywords
+
+  types:
+    - include: unique-types
+    - include: types-parens
+    - include: scope:source.c#types
+
+  strings:
+    - include: unique-strings
+    - match: '(L|u8|u|U)?(")'
+      captures:
+        1: storage.type.string.c++
+        2: punctuation.definition.string.begin.c++
+      push:
+        - meta_scope: string.quoted.double.c++
+        - match: '"'
+          scope: punctuation.definition.string.end.c++
+          pop: true
+        - include: scope:source.c#string_escaped_char
+        - match: |-
+            (?x)%
+              (\d+\$)?                                      # field (argument #)
+              [#0\- +']*                                    # flags
+              [,;:_]?                                       # separator character (AltiVec)
+              ((-?\d+)|\*(-?\d+\$)?)?                       # minimum field width
+              (\.((-?\d+)|\*(-?\d+\$)?)?)?                  # precision
+              (hh|h|ll|l|j|t|z|q|L|vh|vl|v|hv|hl)?          # length modifier
+              (\[[^\]]+\]|[am]s|[diouxXDOUeEfFgGaACcSspn%]) # conversion type
+          scope: constant.other.placeholder.c++
+        - match: '\{\{|\}\}'
+          scope: constant.character.escape.c++
+        - include: formatting-syntax
+    - include: scope:source.c#strings
+
+  formatting-syntax:
+    # https://docs.python.org/3.6/library/string.html#formatstrings
+    - match: |- # simple form
+        (?x)
+        (\{)
+          (?: [\w.\[\]]+)?             # field_name
+          (   ! [ars])?                # conversion
+          (   : (?:{{format_spec}}|    # format_spec OR
+                   [^}%]*%.[^}]*)      # any format-like string
+          )?
+        (\})
+      scope: constant.other.placeholder.c++
+      captures:
+        1: punctuation.definition.placeholder.begin.c++
+        2: storage.modifier.c++onversion.c++
+        3: constant.other.format-spec.c++
+        4: punctuation.definition.placeholder.end.c++
+    - match: \{(?=[^\}"']+\{[^"']*\}) # complex (nested) form
+      scope: punctuation.definition.placeholder.begin.c++
+      push:
+        - meta_scope: constant.other.placeholder.c++
+        - match: \}
+          scope: punctuation.definition.placeholder.end.c++
+          pop: true
+        - match: '[\w.\[\]]+'
+        - match: '![ars]'
+          scope: storage.modifier.conversion.c++
+        - match: ':'
+          push:
+            - meta_scope: meta.format-spec.c++ constant.other.format-spec.c++
+            - match: (?=\})
+              pop: true
+            - include: formatting-syntax
+
+  numbers:
+    - include: unique-numbers
+    - include: scope:source.c#numbers
+
+  ## C++-specific contexts
+
+  case-default:
+    - match: '\b(default|case)\b'
+      scope: keyword.control.c++
+      push:
+        - match: (?=[);,])
+          pop: true
+        - match: ':'
+          scope: punctuation.separator.c++
+          pop: true
+        - include: expressions
+
+  modifiers-parens:
+    - match: '\b(alignas)\b\s*(\()'
+      captures:
+        1: storage.modifier.c++
+        2: meta.group.c++ punctuation.section.group.begin.c++
+      push:
+        - meta_content_scope: meta.group.c++
+        - match: '\)'
+          scope: meta.group.c++ punctuation.section.group.end.c++
+          pop: true
+        - include: expressions
+    - match: \b(__attribute__)\s*(\(\()
+      captures:
+        1: storage.modifier.c++
+        2: meta.group.c++ punctuation.section.group.begin.c++
+      push :
+        - meta_scope: meta.attribute.c++
+        - meta_content_scope: meta.group.c++
+        - include: parens
+        - include: strings
+        - match: \)\)
+          scope: meta.group.c++ punctuation.section.group.end.c++
+          pop: true
+    - match: \b(__declspec)(\()
+      captures:
+        1: storage.modifier.c++
+        2: meta.group.c++ punctuation.section.group.begin.c++
+      push:
+        - meta_content_scope: meta.group.c++
+        - match: '\)'
+          scope: meta.group.c++ punctuation.section.group.end.c++
+          pop: true
+        - match: '\b(align|allocate|code_seg|deprecated|property|uuid)\b\s*(\()'
+          captures:
+            1: storage.modifier.c++
+            2: meta.group.c++ punctuation.section.group.begin.c++
+          push:
+            - meta_content_scope: meta.group.c++
+            - match: '\)'
+              scope: meta.group.c++ punctuation.section.group.end.c++
+              pop: true
+            - include: numbers
+            - include: strings
+            - match: \b(get|put)\b
+              scope: variable.parameter.c++
+            - match: ','
+              scope: punctuation.separator.c++
+            - match: '='
+              scope: keyword.operator.assignment.c++
+        - match: '\b(appdomain|deprecated|dllimport|dllexport|jintrinsic|naked|noalias|noinline|noreturn|nothrow|novtable|process|restrict|safebuffers|selectany|thread)\b'
+          scope: constant.other.c++
+
+  types-parens:
+    - match: '\b(decltype)\b\s*(\()'
+      captures:
+        1: storage.type.c++
+        2: meta.group.c++ punctuation.section.group.begin.c++
+      push:
+        - meta_content_scope: meta.group.c++
+        - match: '\)'
+          scope: meta.group.c++ punctuation.section.group.end.c++
+          pop: true
+        - include: expressions
+
+  keywords-angle-brackets:
+    - match: \b({{casts}})\b\s*
+      scope: keyword.operator.word.cast.c++
+      push:
+        - match: '>'
+          scope: punctuation.section.generic.end.c++
+          pop: true
+        - match: '<'
+          scope: punctuation.section.generic.begin.c++
+          push:
+            - match: '(?=>)'
+              pop: true
+            - include: expressions-minus-generic-type-function-call
+
+  keywords-parens:
+    - match: '\b(alignof|typeid|static_assert|sizeof)\b\s*(\()'
+      captures:
+        1: keyword.operator.word.c++
+        2: meta.group.c++ punctuation.section.group.begin.c++
+      push:
+        - meta_content_scope: meta.group.c++
+        - match: '\)'
+          scope: meta.group.c++ punctuation.section.group.end.c++
+          pop: true
+        - include: expressions
+
+  namespace:
+    - match: '\b(using)\s+(namespace)\s+(?={{path_lookahead}})'
+      captures:
+        1: keyword.control.c++
+        2: keyword.control.c++
+      push:
+        - include: identifiers
+        - match: ''
+          pop: true
+    - match: '\b(namespace)\s+(?=({{path_lookahead}})?(?!\s*[;,]))'
+      scope: meta.namespace.c++
+      captures:
+        1: keyword.control.c++
+      push:
+        - meta_content_scope: meta.namespace.c++ entity.name.namespace.c++
+        - include: identifiers
+        - match: ''
+          set:
+            - meta_scope: meta.namespace.c++
+            - include: comments
+            - match: '='
+              scope: keyword.operator.alias.c++
+            - match: '(?=;)'
+              pop: true
+            - match: '\}'
+              scope: meta.block.c++ punctuation.section.block.end.c++
+              pop: true
+            - match: '\{'
+              scope: punctuation.section.block.begin.c++
+              push:
+                - meta_scope: meta.block.c++
+                - match: '(?=\})'
+                  pop: true
+                - include: preprocessor-global
+                - include: global
+            - include: expressions
+
+  template-common:
+    # Exit the template scope if we hit some basic invalid characters. This
+    # helps when a user is in the middle of typing their template types and
+    # prevents re-highlighting the whole file until the next > is found.
+    - match: (?=[{};])
+      pop: true
+    - include: expressions
+
+  template:
+    - match: \btemplate\b
+      scope: storage.type.template.c++
+      push:
+        - meta_scope: meta.template.c++
+        # Explicitly include comments here at the top, in order to NOT match the
+        # \S lookahead in the case of comments.
+        - include: comments
+        - match: <
+          scope: punctuation.section.generic.begin.c++
+          set:
+            - meta_content_scope: meta.template.c++
+            - match: '>'
+              scope: meta.template.c++ punctuation.section.generic.end.c++
+              pop: true
+            - match: \.{3}
+              scope: keyword.operator.variadic.c++
+            - match: \b(typename|{{before_tag}})\b
+              scope: storage.type.c++
+            - include: template # include template here for nested templates
+            - include: template-common
+        - match: (?=\S)
+          set:
+            - meta_content_scope: meta.template.c++
+            - match: \b({{before_tag}})\b
+              scope: storage.type.c++
+            - include: template-common
+
+  generic-type:
+    - match: '(?=(?!template){{path_lookahead}}\s*{{generic_lookahead}}\s*\()'
+      push:
+        - meta_scope: meta.function-call.c++
+        - match: \btemplate\b
+          scope: storage.type.template.c++
+        - match: '(?:(::)\s*)?{{identifier}}\s*(::)\s*'
+          captures:
+            1: punctuation.accessor.double-colon.c++
+            2: punctuation.accessor.double-colon.c++
+        - match: (?:(::)\s*)?({{identifier}})\s*(<)
+          captures:
+            1: punctuation.accessor.double-colon.c++
+            2: variable.function.c++
+            3: punctuation.section.generic.begin.c++
+          push:
+            - match: '>'
+              scope: punctuation.section.generic.end.c++
+              pop: true
+            - include: expressions-minus-generic-type-function-call
+        - match: (?:(::)\s*)?({{identifier}})\s*(\()
+          captures:
+            1: punctuation.accessor.double-colon.c++
+            2: variable.function.c++
+            3: punctuation.section.group.begin.c++
+          set:
+            - meta_scope: meta.function-call.c++
+            - meta_content_scope: meta.group.c++
+            - match: '\)'
+              scope: meta.group.c++ punctuation.section.group.end.c++
+              pop: true
+            - include: expressions
+        - include: angle-brackets
+        - match: '\('
+          scope: meta.group.c++ punctuation.section.group.begin.c++
+          set:
+            - meta_scope: meta.function-call.c++
+            - meta_content_scope: meta.group.c++
+            - match: '\)'
+              scope: meta.group.c++ punctuation.section.group.end.c++
+              pop: true
+            - include: expressions
+    - match: '(?=(?!template){{path_lookahead}}\s*{{generic_lookahead}})'
+      push:
+        - include: identifiers
+        - match: '<'
+          scope: punctuation.section.generic.begin.c++
+          set:
+            - match: '>'
+              scope: punctuation.section.generic.end.c++
+              pop: true
+            - include: expressions-minus-generic-type-function-call
+
+  angle-brackets:
+    - match: '<(?!<)'
+      scope: punctuation.section.generic.begin.c++
+      push:
+        - match: '>'
+          scope: punctuation.section.generic.end.c++
+          pop: true
+        - include: expressions-minus-generic-type-function-call
+
+  block:
+    - match: '\{'
+      scope: punctuation.section.block.begin.c++
+      push:
+        - meta_scope: meta.block.c++
+        - match: (?=^\s*#\s*(elif|else|endif)\b)
+          pop: true
+        - match: '\}'
+          scope: punctuation.section.block.end.c++
+          pop: true
+        - include: statements
+
+  function-call:
+    - match: (?={{path_lookahead}}\s*\()
+      push:
+        - meta_scope: meta.function-call.c++
+        - include: scope:source.c#c99
+        - match: '(?:(::)\s*)?{{identifier}}\s*(::)\s*'
+          scope: variable.function.c++
+          captures:
+            1: punctuation.accessor.c++
+            2: punctuation.accessor.c++
+        - match: '(?:(::)\s*)?{{identifier}}'
+          scope: variable.function.c++
+          captures:
+            1: punctuation.accessor.c++
+        - match: '\('
+          scope: meta.group.c++ punctuation.section.group.begin.c++
+          set:
+            - meta_content_scope: meta.function-call.c++ meta.group.c++
+            - match: '\)'
+              scope: meta.function-call.c++ meta.group.c++ punctuation.section.group.end.c++
+              pop: true
+            - include: expressions
+
+  members-inside-function-call:
+    - meta_content_scope: meta.method-call.c++ meta.group.c++
+    - match: \)
+      scope: meta.method-call.c++ meta.group.c++ punctuation.section.group.end.c++
+      pop: true
+    - include: expressions
+
+  members-after-accessor-junction:
+    # After we've seen an accessor (dot or arrow), this context decides what
+    # kind of entity we're accessing.
+    - include: comments
+    - match: \btemplate\b
+      scope: meta.method-call.c++ storage.type.template.c++
+      # Guaranteed to be a template member function call after we match this
+      set:
+        - meta_content_scope: meta.method-call.c++
+        - include: comments
+        - match: '{{identifier}}'
+          scope: variable.function.member.c++
+          set:
+            - meta_content_scope: meta.method-call.c++
+            - match: \(
+              scope: meta.group.c++ punctuation.section.group.begin.c++
+              set: members-inside-function-call
+            - include: comments
+            - include: angle-brackets
+            - match: (?=\S) # safety pop
+              pop: true
+        - match: (?=\S) # safety pop
+          pop: true
+    # Operator overloading
+    - match: '({{operator_method_name}})\s*(\()'
+      captures:
+        0: meta.method-call.c++
+        1: variable.function.member.c++
+        2: meta.group.c++ punctuation.section.group.begin.c++
+      set: members-inside-function-call
+    # Non-templated member function call
+    - match: (~?{{identifier}})\s*(\()
+      captures:
+        0: meta.method-call.c++
+        1: variable.function.member.c++
+        2: meta.group.c++ punctuation.section.group.begin.c++
+      set: members-inside-function-call
+    # Templated member function call
+    - match: (~?{{identifier}})\s*(?={{generic_lookahead}})
+      captures:
+        1: variable.function.member.c++
+      set:
+        - meta_scope: meta.method-call.c++
+        - match: <
+          scope: punctuation.section.generic.begin.c++
+          set:
+            - meta_content_scope: meta.method-call.c++
+            - match: '>'
+              scope: punctuation.section.generic.end.c++
+              set:
+                - meta_content_scope: meta.method-call.c++
+                - include: comments
+                - match: \(
+                  scope: punctuation.section.group.begin.c++
+                  set: members-inside-function-call
+                - match: (?=\S) # safety pop
+                  pop: true
+            - include: expressions
+    # Explicit base-class access
+    - match: ({{identifier}})\s*(::)
+      captures:
+        1: variable.other.base-class.c++
+        2: punctuation.accessor.double-colon.c++
+      set: members-after-accessor-junction # reset
+    # Just a regular member variable
+    - match: '{{identifier}}'
+      scope: variable.other.readwrite.member.c++
+      pop: true
+
+  members-dot:
+    - include: scope:source.c#access-illegal
+    # No lookahead required because members-dot goes after operators in the
+    # early-expressions-after-generic-type context. This means triple dots
+    # (i.e. "..." or "variadic") is attempted first.
+    - match: \.
+      scope: punctuation.accessor.dot.c++
+      push: members-after-accessor-junction
+
+  members-arrow:
+    # This needs to be before operators in the
+    # early-expressions-after-generic-type context because otherwise the "->"
+    # from the C language will match.
+    - match: ->
+      scope: punctuation.accessor.arrow.c++
+      push: members-after-accessor-junction
+
+  typedef:
+    - match: \btypedef\b
+      scope: storage.type.c++
+      push:
+        - match: ({{identifier}})?\s*(?=;)
+          captures:
+            1: entity.name.type.typedef.c++
+          pop: true
+        - match: \b(struct)\s+({{identifier}})\b
+          captures:
+            1: storage.type.c++
+        - include: expressions-minus-generic-type
+
+  parens:
+    - match: \(
+      scope: punctuation.section.group.begin.c++
+      push:
+        - meta_scope: meta.group.c++
+        - match: \)
+          scope: punctuation.section.group.end.c++
+          pop: true
+        - include: expressions
+
+  brackets:
+    - match: \[
+      scope: punctuation.section.brackets.begin.c++
+      push:
+        - meta_scope: meta.brackets.c++
+        - match: \]
+          scope: punctuation.section.brackets.end.c++
+          pop: true
+        - include: expressions
+
+  function-trailing-return-type:
+    - match: '{{non_angle_brackets}}'
+      pop: true
+    - include: angle-brackets
+    - include: types
+    - include: modifiers-parens
+    - include: modifiers
+    - include: identifiers
+    - match: \*|&
+      scope: keyword.operator.c++
+    - include: function-trailing-return-type-parens
+    - match: '(?=\S)'
+      pop: true
+
+  function-trailing-return-type-parens:
+    - match: \(
+      scope: punctuation.section.group.begin.c++
+      push:
+        - meta_scope: meta.group.c++
+        - match: \)
+          scope: punctuation.section.group.end.c++
+          pop: true
+        - include: function-trailing-return-type
+
+  ## Detection of function and data structure definitions at the global level
+
+  global-modifier:
+    - include: comments
+    - include: modifiers-parens
+    - include: modifiers
+    # Constructors and destructors don't have a type
+    - match: '(?={{path_lookahead}}\s*::\s*{{identifier}}\s*(\(|$))'
+      set:
+        - meta_content_scope: meta.function.c++ entity.name.function.constructor.c++
+        - include: identifiers
+        - match: '(?=[^\w\s])'
+          set: function-definition-params
+    - match: '(?={{path_lookahead}}\s*::\s*~{{identifier}}\s*(\(|$))'
+      set:
+        - meta_content_scope: meta.function.c++ entity.name.function.destructor.c++
+        - include: identifiers
+        - match: '~{{identifier}}'
+        - match: '(?=[^\w\s])'
+          set: function-definition-params
+    # If we see a path ending in :: before a newline, we don't know if it is
+    # a constructor or destructor, or a long return type, so we are just going
+    # to treat it like a regular function. Most likely it is a constructor,
+    # since it doesn't seem most developers would create such a long typename.
+    - match: '(?={{path_lookahead}}\s*::\s*$)'
+      set:
+        - meta_content_scope: meta.function.c++ entity.name.function.c++
+        - include: identifiers
+        - match: '~{{identifier}}'
+        - match: '(?=[^\w\s])'
+          set: function-definition-params
+    - include: unique-strings
+    - match: '(?=\S)'
+      set: global-type
+
+  global-type:
+    - include: comments
+    - match: \*|&
+      scope: keyword.operator.c++
+    - match: '(?=\b({{control_keywords}}|{{operator_keywords}}|{{casts}}|{{memory_operators}}|{{other_keywords}}|operator)\b)'
+      pop: true
+    - match: '(?=\s)'
+      set: global-maybe-function
+    # If a class/struct/enum followed by a name that is not a macro or declspec
+    # then this is likely a return type of a function. This is uncommon.
+    - match: |-
+        (?x:
+          ({{before_tag}})
+          \s+
+          (?=
+            (?![[:upper:][:digit:]_]+\b|__declspec|{{before_tag}})
+            {{path_lookahead}}
+            (\s+{{identifier}}\s*\(|\s*[*&])
+          )
+        )
+      captures:
+        1: storage.type.c++
+      set:
+        - include: identifiers
+        - match: ''
+          set: global-maybe-function
+    # The previous match handles return types of struct/enum/etc from a func,
+    # there this one exits the context to allow matching an actual struct/class
+    - match: '(?=\b({{before_tag}})\b)'
+      set: data-structures
+    - match: '(?=\b({{casts}})\b\s*<)'
+      pop: true
+    - match: '{{non_angle_brackets}}'
+      pop: true
+    - include: angle-brackets
+    - include: types
+    # Allow a macro call
+    - match: '({{identifier}})\s*(\()(?=[^\)]+\))'
+      captures:
+        1: variable.function.c++
+        2: meta.group.c++ punctuation.section.group.begin.c++
+      push:
+        - meta_scope: meta.function-call.c++
+        - meta_content_scope: meta.group.c++
+        - match: '\)'
+          scope: meta.group.c++ punctuation.section.group.end.c++
+          pop: true
+        - include: expressions
+    - match: '(?={{path_lookahead}}\s*\()'
+      set:
+        - include: function-call
+        - match: ''
+          pop: true
+    - include: variables
+    - include: constants
+    - include: identifiers
+    - match: (?=\W)
+      pop: true
+
+  global-maybe-function:
+    - include: comments
+    # Consume pointer info, macros and any type info that was offset by macros
+    - match: \*|&
+      scope: keyword.operator.c++
+    - match: '(?=\b({{control_keywords}}|{{operator_keywords}}|{{casts}}|{{memory_operators}}|{{other_keywords}})\b)'
+      pop: true
+    - match: '\b({{type_qualifier}})\b'
+      scope: storage.modifier.c++
+    - match: '{{non_angle_brackets}}'
+      pop: true
+    - include: angle-brackets
+    - include: types
+    - include: modifiers-parens
+    - include: modifiers
+    # All uppercase identifier just before a newline is most likely a macro
+    - match: '[[:upper:][:digit:]_]+\s*$'
+    # Operator overloading
+    - match: '(?=({{path_lookahead}}\s*(?:{{generic_lookahead}})?::\s*)?{{operator_method_name}}\s*(\(|$))'
+      set:
+        - meta_content_scope: meta.function.c++ entity.name.function.c++
+        - include: identifiers
+        - match: '(?=\s*(\(|$))'
+          set: function-definition-params
+    # Identifier that is not the function name - likely a macro or type
+    - match: '(?={{path_lookahead}}([ \t]+|[*&])(?!\s*(<|::|\(|$)))'
+      push:
+        - include: identifiers
+        - match: ''
+          pop: true
+    # Real function definition
+    - match: '(?={{path_lookahead}}({{generic_lookahead}}({{path_lookahead}})?)\s*(\(|$))'
+      set: [function-definition-params, global-function-identifier-generic]
+    - match: '(?={{path_lookahead}}\s*(\(|$))'
+      set: [function-definition-params, global-function-identifier]
+    - match: '(?={{path_lookahead}}\s*::\s*$)'
+      set: [function-definition-params, global-function-identifier]
+    - match: '(?=\S)'
+      pop: true
+
+  global-function-identifier-generic:
+    - include: angle-brackets
+    - match: '::'
+      scope: punctuation.accessor.c++
+    - match: '(?={{identifier}}<.*>\s*\()'
+      push:
+        - meta_content_scope: entity.name.function.c++
+        - include: identifiers
+        - match: '(?=<)'
+          pop: true
+    - match: '(?={{identifier}}\s*\()'
+      push:
+        - meta_content_scope: entity.name.function.c++
+        - include: identifiers
+        - match: ''
+          pop: true
+    - match: '(?=\()'
+      pop: true
+
+  global-function-identifier:
+    - meta_content_scope: entity.name.function.c++
+    - include: identifiers
+    - match: '(?=\S)'
+      pop: true
+
+  function-definition-params:
+    - meta_content_scope: meta.function.c++
+    - include: comments
+    - match: '(?=\()'
+      set:
+        - match: \(
+          scope: meta.function.parameters.c++ meta.group.c++ punctuation.section.group.begin.c++
+          set:
+            - meta_content_scope: meta.function.parameters.c++ meta.group.c++
+            - match : \)
+              scope: punctuation.section.group.end.c++
+              set: function-definition-continue
+            - match: '\bvoid\b'
+              scope: storage.type.c++
+            - match: '{{identifier}}(?=\s*(\[|,|\)|=))'
+              scope: variable.parameter.c++
+            - match: '='
+              scope: keyword.operator.assignment.c++
+              push:
+                - match: '(?=,|\))'
+                  pop: true
+                - include: expressions-minus-generic-type
+                - include: scope:source.c#preprocessor-line-continuation
+            - include: expressions-minus-generic-type
+            - include: scope:source.c#preprocessor-line-continuation
+    - match: (?=\S)
+      pop: true
+
+  function-definition-continue:
+    - meta_content_scope: meta.function.c++
+    - include: comments
+    - match: '(?=;)'
+      pop: true
+    - match: '->'
+      scope: punctuation.separator.c++
+      set: function-definition-trailing-return
+    - include: function-specifiers
+    - match: '='
+      scope: keyword.operator.assignment.c++
+    - match: '&'
+      scope: keyword.operator.c++
+    - match: \b0\b
+      scope: constant.numeric.c++
+    - match: \b(default|delete)\b
+      scope: storage.modifier.c++
+    - match: '(?=\{)'
+      set: function-definition-body
+    - match: '(?=\S)'
+      pop: true
+
+  function-definition-trailing-return:
+    - include: comments
+    - match: '(?=;)'
+      pop: true
+    - match: '(?=\{)'
+      set: function-definition-body
+    - include: function-specifiers
+    - include: function-trailing-return-type
+
+  function-definition-body:
+    - meta_content_scope: meta.function.c++ meta.block.c++
+    - match: '\{'
+      scope: punctuation.section.block.begin.c++
+      set:
+        - meta_content_scope: meta.function.c++ meta.block.c++
+        - match: '\}'
+          scope: meta.function.c++ meta.block.c++ punctuation.section.block.end.c++
+          pop: true
+        - match: (?=^\s*#\s*(elif|else|endif)\b)
+          pop: true
+        - match: '(?=({{before_tag}})([^(;]+$|.*\{))'
+          push: data-structures
+        - include: statements
+
+  ## Data structures including classes, structs, unions and enums
+
+  data-structures:
+    - match: '\bclass\b'
+      scope: storage.type.c++
+      set: data-structures-class-definition
+    # Detect variable type definitions using struct/enum/union followed by a tag
+    - match: '\b({{before_tag}})(?=\s+{{path_lookahead}}\s+{{path_lookahead}}\s*[=;\[])'
+      scope: storage.type.c++
+    - match: '\bstruct\b'
+      scope: storage.type.c++
+      set: data-structures-struct-definition
+    - match: '\benum(\s+(class|struct))?\b'
+      scope: storage.type.c++
+      set: data-structures-enum-definition
+    - match: '\bunion\b'
+      scope: storage.type.c++
+      set: data-structures-union-definition
+    - match: '(?=\S)'
+      pop: true
+
+  preprocessor-workaround-eat-macro-before-identifier:
+    # Handle macros so they aren't matched as the class name
+    - match: ({{macro_identifier}})(?=\s+~?{{identifier}})
+      captures:
+        1: meta.assumed-macro.c
+
+  data-structures-class-definition:
+    - meta_scope: meta.class.c++
+    - include: data-structures-definition-common-begin
+    - match: '{{identifier}}(?={{data_structures_forward_decl_lookahead}})'
+      scope: entity.name.class.forward-decl.c++
+      set: data-structures-class-definition-after-identifier
+    - match: '{{identifier}}'
+      scope: entity.name.class.c++
+      set: data-structures-class-definition-after-identifier
+    - match: '(?=[:{])'
+      set: data-structures-class-definition-after-identifier
+    - match: '(?=;)'
+      pop: true
+
+  data-structures-class-definition-after-identifier:
+    - meta_content_scope: meta.class.c++
+    - include: data-structures-definition-common-begin
+    # No matching of identifiers since they should all be macros at this point
+    - include: data-structures-definition-common-end
+    - match: '\{'
+      scope: meta.block.c++ punctuation.section.block.begin.c++
+      set:
+        - meta_content_scope: meta.class.c++ meta.block.c++
+        - match: '\}'
+          scope: meta.class.c++ meta.block.c++ punctuation.section.block.end.c++
+          pop: true
+        - include: data-structures-body
+
+  data-structures-struct-definition:
+    - meta_scope: meta.struct.c++
+    - include: data-structures-definition-common-begin
+    - match: '{{identifier}}(?={{data_structures_forward_decl_lookahead}})'
+      scope: entity.name.struct.forward-decl.c++
+      set: data-structures-struct-definition-after-identifier
+    - match: '{{identifier}}'
+      scope: entity.name.struct.c++
+      set: data-structures-struct-definition-after-identifier
+    - match: '(?=[:{])'
+      set: data-structures-struct-definition-after-identifier
+    - match: '(?=;)'
+      pop: true
+
+  data-structures-struct-definition-after-identifier:
+    - meta_content_scope: meta.struct.c++
+    - include: data-structures-definition-common-begin
+    # No matching of identifiers since they should all be macros at this point
+    - include: data-structures-definition-common-end
+    - match: '\{'
+      scope: meta.block.c++ punctuation.section.block.begin.c++
+      set:
+        - meta_content_scope: meta.struct.c++ meta.block.c++
+        - match: '\}'
+          scope: meta.struct.c++ meta.block.c++ punctuation.section.block.end.c++
+          pop: true
+        - include: data-structures-body
+
+  data-structures-enum-definition:
+    - meta_scope: meta.enum.c++
+    - include: data-structures-definition-common-begin
+    - match: '{{identifier}}(?={{data_structures_forward_decl_lookahead}})'
+      scope: entity.name.enum.forward-decl.c++
+      set: data-structures-enum-definition-after-identifier
+    - match: '{{identifier}}'
+      scope: entity.name.enum.c++
+      set: data-structures-enum-definition-after-identifier
+    - match: '(?=[:{])'
+      set: data-structures-enum-definition-after-identifier
+    - match: '(?=;)'
+      pop: true
+
+  data-structures-enum-definition-after-identifier:
+    - meta_content_scope: meta.enum.c++
+    - include: data-structures-definition-common-begin
+    # No matching of identifiers since they should all be macros at this point
+    - include: data-structures-definition-common-end
+    - match: '\{'
+      scope: meta.block.c++ punctuation.section.block.begin.c++
+      set:
+        - meta_content_scope: meta.enum.c++ meta.block.c++
+        # Enums don't support methods so we have a simplified body
+        - match: '\}'
+          scope: meta.enum.c++ meta.block.c++ punctuation.section.block.end.c++
+          pop: true
+        - include: statements
+
+  data-structures-union-definition:
+    - meta_scope: meta.union.c++
+    - include: data-structures-definition-common-begin
+    - match: '{{identifier}}(?={{data_structures_forward_decl_lookahead}})'
+      scope: entity.name.union.forward-decl.c++
+      set: data-structures-union-definition-after-identifier
+    - match: '{{identifier}}'
+      scope: entity.name.union.c++
+      set: data-structures-union-definition-after-identifier
+    - match: '(?=[{])'
+      set: data-structures-union-definition-after-identifier
+    - match: '(?=;)'
+      pop: true
+
+  data-structures-union-definition-after-identifier:
+    - meta_content_scope: meta.union.c++
+    - include: data-structures-definition-common-begin
+    # No matching of identifiers since they should all be macros at this point
+    # Unions don't support base classes
+    - include: angle-brackets
+    - match: '\{'
+      scope: meta.block.c++ punctuation.section.block.begin.c++
+      set:
+        - meta_content_scope: meta.union.c++ meta.block.c++
+        - match: '\}'
+          scope: meta.union.c++ meta.block.c++ punctuation.section.block.end.c++
+          pop: true
+        - include: data-structures-body
+    - match: '(?=;)'
+      pop: true
+
+  data-structures-definition-common-begin:
+    - include: comments
+    - match: '(?=\b(?:{{before_tag}}|{{control_keywords}})\b)'
+      pop: true
+    - include: preprocessor-other
+    - include: modifiers-parens
+    - include: modifiers
+    - include: preprocessor-workaround-eat-macro-before-identifier
+
+  data-structures-definition-common-end:
+    - include: angle-brackets
+    - match: \bfinal\b
+      scope: storage.modifier.c++
+    - match: ':'
+      scope: punctuation.separator.c++
+      push:
+        - include: comments
+        - include: preprocessor-other
+        - include: modifiers-parens
+        - include: modifiers
+        - match: '\b(virtual|{{visibility_modifiers}})\b'
+          scope: storage.modifier.c++
+        - match: (?={{path_lookahead}})
+          push:
+            - meta_scope: entity.other.inherited-class.c++
+            - include: identifiers
+            - match: ''
+              pop: true
+        - include: angle-brackets
+        - match: ','
+          scope: punctuation.separator.c++
+        - match: (?=\{|;)
+          pop: true
+    - match: '(?=;)'
+      pop: true
+
+  data-structures-body:
+    - include: preprocessor-data-structures
+    - match: '(?=\btemplate\b)'
+      push:
+        - include: template
+        - match: (?=\S)
+          set: data-structures-modifier
+    - include: typedef
+    - match: \b({{visibility_modifiers}})\s*(:)(?!:)
+      captures:
+        1: storage.modifier.c++
+        2: punctuation.section.class.c++
+    - match: '^\s*(?=(?:~?\w+|::))'
+      push: data-structures-modifier
+    - include: expressions-minus-generic-type
+
+  data-structures-modifier:
+    - match: '\bfriend\b'
+      scope: storage.modifier.c++
+      push:
+        - match: (?=;)
+          pop: true
+        - match: '\{'
+          scope: punctuation.section.block.begin.c++
+          set:
+            - meta_scope: meta.block.c++
+            - match: '\}'
+              scope: punctuation.section.block.end.c++
+              pop: true
+            - include: statements
+        - match: '\b({{before_tag}})\b'
+          scope: storage.type.c++
+        - include: expressions-minus-function-call
+    - include: comments
+    - include: modifiers-parens
+    - include: modifiers
+    - match: '\bstatic_assert(?=\s*\()'
+      scope: meta.static-assert.c++ keyword.operator.word.c++
+      push:
+        - match: '\('
+          scope: meta.group.c++ punctuation.section.group.begin.c++
+          set:
+            - meta_content_scope: meta.function-call.c++ meta.group.c++
+            - match: '\)'
+              scope: meta.function-call.c++ meta.group.c++ punctuation.section.group.end.c++
+              pop: true
+            - include: expressions
+    # Destructor
+    - match: '(?:{{identifier}}\s*(::)\s*)?~{{identifier}}(?=\s*(\(|$))'
+      scope: meta.method.destructor.c++ entity.name.function.destructor.c++
+      captures:
+        1: punctuation.accessor.c++
+      set: method-definition-params
+    # It's a macro, not a constructor if there is no type in the first param
+    - match: '({{identifier}})\s*(\()(?=\s*(?!void){{identifier}}\s*[),])'
+      captures:
+        1: variable.function.c++
+        2: meta.group.c++ punctuation.section.group.begin.c++
+      push:
+        - meta_scope: meta.function-call.c++
+        - meta_content_scope: meta.group.c++
+        - match: '\)'
+          scope: meta.group.c++ punctuation.section.group.end.c++
+          pop: true
+        - include: expressions
+    # Constructor
+    - include: preprocessor-workaround-eat-macro-before-identifier
+    - match: '((?!{{before_tag}}|template){{identifier}})(?=\s*\()'
+      scope: meta.method.constructor.c++ entity.name.function.constructor.c++
+      set: method-definition-params
+    # Long form constructor
+    - match: '({{identifier}}\s*(::)\s*{{identifier}})(?=\s*\()'
+      captures:
+        1: meta.method.constructor.c++ entity.name.function.constructor.c++
+        2: punctuation.accessor.c++
+      push: method-definition-params
+    - match: '(?=\S)'
+      set: data-structures-type
+
+  data-structures-type:
+    - include: comments
+    - match: \*|&
+      scope: keyword.operator.c++
+      # Cast methods
+    - match: '(operator)\s+({{identifier}})(?=\s*(\(|$))'
+      captures:
+        1: keyword.control.c++
+        2: meta.method.c++ entity.name.function.c++
+      set: method-definition-params
+    - match: '(?=\b({{control_keywords}}|{{operator_keywords}}|{{casts}}|{{memory_operators}}|{{other_keywords}}|operator)\b)'
+      pop: true
+    - match: '(?=\s)'
+      set: data-structures-maybe-method
+    # If a class/struct/enum followed by a name that is not a macro or declspec
+    # then this is likely a return type of a function. This is uncommon.
+    - match: |-
+        (?x:
+          ({{before_tag}})
+          \s+
+          (?=
+            (?![[:upper:][:digit:]_]+\b|__declspec|{{before_tag}})
+            {{path_lookahead}}
+            (\s+{{identifier}}\s*\(|\s*[*&])
+          )
+        )
+      captures:
+        1: storage.type.c++
+      set:
+        - include: identifiers
+        - match: ''
+          set: data-structures-maybe-method
+    # The previous match handles return types of struct/enum/etc from a func,
+    # there this one exits the context to allow matching an actual struct/class
+    - match: '(?=\b({{before_tag}})\b)'
+      set: data-structures
+    - match: '(?=\b({{casts}})\b\s*<)'
+      pop: true
+    - match: '{{non_angle_brackets}}'
+      pop: true
+    - include: angle-brackets
+    - include: types
+    - include: variables
+    - include: constants
+    - include: identifiers
+    - match: (?=[&*])
+      set: data-structures-maybe-method
+    - match: (?=\W)
+      pop: true
+
+  data-structures-maybe-method:
+    - include: comments
+    # Consume pointer info, macros and any type info that was offset by macros
+    - match: \*|&
+      scope: keyword.operator.c++
+    - match: '(?=\b({{control_keywords}}|{{operator_keywords}}|{{casts}}|{{memory_operators}}|{{other_keywords}})\b)'
+      pop: true
+    - match: '\b({{type_qualifier}})\b'
+      scope: storage.modifier.c++
+    - match: '{{non_angle_brackets}}'
+      pop: true
+    - include: angle-brackets
+    - include: types
+    - include: modifiers-parens
+    - include: modifiers
+    # Operator overloading
+    - match: '{{operator_method_name}}(?=\s*(\(|$))'
+      scope: meta.method.c++ entity.name.function.c++
+      set: method-definition-params
+    # Identifier that is not the function name - likely a macro or type
+    - match: '(?={{path_lookahead}}([ \t]+|[*&])(?!\s*(<|::|\()))'
+      push:
+        - include: identifiers
+        - match: ''
+          pop: true
+    # Real function definition
+    - match: '(?={{path_lookahead}}({{generic_lookahead}})\s*(\())'
+      set: [method-definition-params, data-structures-function-identifier-generic]
+    - match: '(?={{path_lookahead}}\s*(\())'
+      set: [method-definition-params, data-structures-function-identifier]
+    - match: '(?={{path_lookahead}}\s*::\s*$)'
+      set: [method-definition-params, data-structures-function-identifier]
+    - match: '(?=\S)'
+      pop: true
+
+  data-structures-function-identifier-generic:
+    - include: angle-brackets
+    - match: '(?={{identifier}})'
+      push:
+        - meta_content_scope: entity.name.function.c++
+        - include: identifiers
+        - match: '(?=<)'
+          pop: true
+    - match: '(?=\()'
+      pop: true
+
+  data-structures-function-identifier:
+    - meta_content_scope: entity.name.function.c++
+    - include: identifiers
+    - match: '(?=\S)'
+      pop: true
+
+  method-definition-params:
+    - meta_content_scope: meta.method.c++
+    - include: comments
+    - match: '(?=\()'
+      set:
+        - match: \(
+          scope: meta.method.parameters.c++ meta.group.c++ punctuation.section.group.begin.c++
+          set:
+            - meta_content_scope: meta.method.parameters.c++ meta.group.c++
+            - match : \)
+              scope: punctuation.section.group.end.c++
+              set: method-definition-continue
+            - match: '\bvoid\b'
+              scope: storage.type.c++
+            - match: '{{identifier}}(?=\s*(\[|,|\)|=))'
+              scope: variable.parameter.c++
+            - match: '='
+              scope: keyword.operator.assignment.c++
+              push:
+                - match: '(?=,|\))'
+                  pop: true
+                - include: expressions-minus-generic-type
+            - include: expressions-minus-generic-type
+    - match: '(?=\S)'
+      pop: true
+
+  method-definition-continue:
+    - meta_content_scope: meta.method.c++
+    - include: comments
+    - match: '(?=;)'
+      pop: true
+    - match: '->'
+      scope: punctuation.separator.c++
+      set: method-definition-trailing-return
+    - include: function-specifiers
+    - match: '='
+      scope: keyword.operator.assignment.c++
+    - match: '&'
+      scope: keyword.operator.c++
+    - match: \b0\b
+      scope: constant.numeric.c++
+    - match: \b(default|delete)\b
+      scope: storage.modifier.c++
+    - match: '(?=:)'
+      set:
+        - match: ':'
+          scope: punctuation.separator.initializer-list.c++
+          set:
+            - meta_scope: meta.method.constructor.initializer-list.c++
+            - match: '{{identifier}}'
+              scope: variable.other.readwrite.member.c++
+              push:
+                - match: \(
+                  scope: meta.group.c++ punctuation.section.group.begin.c++
+                  set:
+                    - meta_content_scope: meta.group.c++
+                    - match: \)
+                      scope: meta.group.c++ punctuation.section.group.end.c++
+                      pop: true
+                    - include: expressions
+                - match: \{
+                  scope: meta.group.c++ punctuation.section.group.begin.c++
+                  set:
+                    - meta_content_scope: meta.group.c++
+                    - match: \}
+                      scope: meta.group.c++ punctuation.section.group.end.c++
+                      pop: true
+                    - include: expressions
+                - include: comments
+            - match: (?=\{|;)
+              set: method-definition-continue
+            - include: expressions
+    - match: '(?=\{)'
+      set: method-definition-body
+    - match: '(?=\S)'
+      pop: true
+
+  method-definition-trailing-return:
+    - include: comments
+    - match: '(?=;)'
+      pop: true
+    - match: '(?=\{)'
+      set: method-definition-body
+    - include: function-specifiers
+    - include: function-trailing-return-type
+
+  method-definition-body:
+    - meta_content_scope: meta.method.c++ meta.block.c++
+    - match: '\{'
+      scope: punctuation.section.block.begin.c++
+      set:
+        - meta_content_scope: meta.method.c++ meta.block.c++
+        - match: '\}'
+          scope: meta.method.c++ meta.block.c++ punctuation.section.block.end.c++
+          pop: true
+        - match: (?=^\s*#\s*(elif|else|endif)\b)
+          pop: true
+        - match: '(?=({{before_tag}})([^(;]+$|.*\{))'
+          push: data-structures
+        - include: statements
+
+  ## Preprocessor for data-structures
+
+  preprocessor-data-structures:
+    - include: preprocessor-rule-enabled-data-structures
+    - include: preprocessor-rule-disabled-data-structures
+    - include: preprocessor-practical-workarounds
+
+  preprocessor-rule-disabled-data-structures:
+    - match: ^\s*((#if)\s+(0))\b
+      captures:
+        1: meta.preprocessor.c++
+        2: keyword.control.import.c++
+        3: constant.numeric.preprocessor.c++
+      push:
+        - match: ^\s*(#\s*endif)\b
+          captures:
+            1: meta.preprocessor.c++ keyword.control.import.c++
+          pop: true
+        - match: ^\s*(#\s*else)\b
+          captures:
+            1: meta.preprocessor.c++ keyword.control.import.else.c++
+          push:
+            - match: (?=^\s*#\s*endif\b)
+              pop: true
+            - include: negated-block
+            - include: data-structures-body
+        - match: ""
+          push:
+            - meta_scope: comment.block.preprocessor.if-branch.c++
+            - match: (?=^\s*#\s*(else|endif)\b)
+              pop: true
+            - include: scope:source.c#preprocessor-disabled
+
+  preprocessor-rule-enabled-data-structures:
+    - match: ^\s*((#if)\s+(0*1))\b
+      captures:
+        1: meta.preprocessor.c++
+        2: keyword.control.import.c++
+        3: constant.numeric.preprocessor.c++
+      push:
+        - match: ^\s*(#\s*endif)\b
+          captures:
+            1: meta.preprocessor.c++ keyword.control.import.c++
+          pop: true
+        - match: ^\s*(#\s*else)\b
+          captures:
+            1: meta.preprocessor.c++ keyword.control.import.else.c++
+          push:
+            - meta_content_scope: comment.block.preprocessor.else-branch.c++
+            - match: (?=^\s*#\s*endif\b)
+              pop: true
+            - include: scope:source.c#preprocessor-disabled
+        - match: ""
+          push:
+            - match: (?=^\s*#\s*(else|endif)\b)
+              pop: true
+            - include: negated-block
+            - include: data-structures-body
+
+  ## Preprocessor for global
+
+  preprocessor-global:
+    - include: preprocessor-rule-enabled-global
+    - include: preprocessor-rule-disabled-global
+    - include: preprocessor-rule-other-global
+
+  preprocessor-statements:
+    - include: preprocessor-rule-enabled-statements
+    - include: preprocessor-rule-disabled-statements
+    - include: preprocessor-rule-other-statements
+
+  preprocessor-expressions:
+    - include: scope:source.c#incomplete-inc
+    - include: preprocessor-macro-define
+    - include: scope:source.c#pragma-mark
+    - include: preprocessor-other
+
+  preprocessor-rule-disabled-global:
+    - match: ^\s*((#if)\s+(0))\b
+      captures:
+        1: meta.preprocessor.c++
+        2: keyword.control.import.c++
+        3: constant.numeric.preprocessor.c++
+      push:
+        - match: ^\s*(#\s*endif)\b
+          captures:
+            1: meta.preprocessor.c++ keyword.control.import.c++
+          pop: true
+        - match: ^\s*(#\s*else)\b
+          captures:
+            1: meta.preprocessor.c++ keyword.control.import.else.c++
+          push:
+            - match: (?=^\s*#\s*endif\b)
+              pop: true
+            - include: preprocessor-global
+            - include: negated-block
+            - include: global
+        - match: ""
+          push:
+            - meta_scope: comment.block.preprocessor.if-branch.c++
+            - match: (?=^\s*#\s*(else|endif)\b)
+              pop: true
+            - include: scope:source.c#preprocessor-disabled
+
+  preprocessor-rule-enabled-global:
+    - match: ^\s*((#if)\s+(0*1))\b
+      captures:
+        1: meta.preprocessor.c++
+        2: keyword.control.import.c++
+        3: constant.numeric.preprocessor.c++
+      push:
+        - match: ^\s*(#\s*endif)\b
+          captures:
+            1: meta.preprocessor.c++ keyword.control.import.c++
+          pop: true
+        - match: ^\s*(#\s*else)\b
+          captures:
+            1: meta.preprocessor.c++ keyword.control.import.else.c++
+          push:
+            - meta_content_scope: comment.block.preprocessor.else-branch.c++
+            - match: (?=^\s*#\s*endif\b)
+              pop: true
+            - include: scope:source.c#preprocessor-disabled
+        - match: ""
+          push:
+            - match: (?=^\s*#\s*(else|endif)\b)
+              pop: true
+            - include: preprocessor-global
+            - include: negated-block
+            - include: global
+
+  preprocessor-rule-other-global:
+    - match: ^\s*(#\s*(?:if|ifdef|ifndef))\b
+      captures:
+        1: keyword.control.import.c++
+      push:
+        - meta_scope: meta.preprocessor.c++
+        - include: scope:source.c#preprocessor-line-continuation
+        - include: scope:source.c#preprocessor-comments
+        - match: \bdefined\b
+          scope: keyword.control.c++
+        # Enter a new scope where all elif/else branches have their
+        # contexts popped by a subsequent elif/else/endif. This ensures that
+        # preprocessor branches don't push multiple meta.block scopes on
+        # the stack, thus messing up the "global" context's detection of
+        # functions.
+        - match: $\n
+          set: preprocessor-if-branch-global
+
+  # These gymnastics here ensure that we are properly handling scope even
+  # when the preprocessor is used to create different scope beginnings, such
+  # as a different if/while condition
+  preprocessor-if-branch-global:
+    - match: ^\s*(#\s*endif)\b
+      captures:
+        1: meta.preprocessor.c++ keyword.control.import.c++
+      pop: true
+    - match: (?=^\s*#\s*(elif|else)\b)
+      push: preprocessor-elif-else-branch-global
+    - match: \{
+      scope: punctuation.section.block.begin.c++
+      set: preprocessor-block-if-branch-global
+    - include: preprocessor-global
+    - include: negated-block
+    - include: global
+
+  preprocessor-block-if-branch-global:
+    - meta_scope: meta.block.c++
+    - match: ^\s*(#\s*endif)\b
+      captures:
+        1: meta.preprocessor.c++ keyword.control.import.c++
+      set: preprocessor-block-finish-global
+    - match: (?=^\s*#\s*(elif|else)\b)
+      push: preprocessor-elif-else-branch-global
+    - match: \}
+      scope: punctuation.section.block.end.c++
+      set: preprocessor-if-branch-global
+    - include: statements
+
+  preprocessor-block-finish-global:
+    - meta_scope: meta.block.c++
+    - match: ^\s*(#\s*(?:if|ifdef|ifndef))\b
+      captures:
+        1: meta.preprocessor.c++ keyword.control.import.c++
+      set: preprocessor-block-finish-if-branch-global
+    - match: \}
+      scope: punctuation.section.block.end.c++
+      pop: true
+    - include: statements
+
+  preprocessor-block-finish-if-branch-global:
+    - match: ^\s*(#\s*endif)\b
+      captures:
+        1: keyword.control.import.c++
+      pop: true
+    - match: \}
+      scope: punctuation.section.block.end.c++
+      set: preprocessor-if-branch-global
+    - include: statements
+
+  preprocessor-elif-else-branch-global:
+    - match: (?=^\s*#\s*(endif)\b)
+      pop: true
+    - include: preprocessor-global
+    - include: negated-block
+    - include: global
+
+  ## Preprocessor for statements
+
+  preprocessor-rule-disabled-statements:
+    - match: ^\s*((#if)\s+(0))\b
+      captures:
+        1: meta.preprocessor.c++
+        2: keyword.control.import.c++
+        3: constant.numeric.preprocessor.c++
+      push:
+        - match: ^\s*(#\s*endif)\b
+          captures:
+            1: meta.preprocessor.c++ keyword.control.import.c++
+          pop: true
+        - match: ^\s*(#\s*else)\b
+          captures:
+            1: meta.preprocessor.c++ keyword.control.import.else.c++
+          push:
+            - match: (?=^\s*#\s*endif\b)
+              pop: true
+            - include: negated-block
+            - include: statements
+        - match: ""
+          push:
+            - meta_scope: comment.block.preprocessor.if-branch.c++
+            - match: (?=^\s*#\s*(else|endif)\b)
+              pop: true
+            - include: scope:source.c#preprocessor-disabled
+
+  preprocessor-rule-enabled-statements:
+    - match: ^\s*((#if)\s+(0*1))\b
+      captures:
+        1: meta.preprocessor.c++
+        2: keyword.control.import.c++
+        3: constant.numeric.preprocessor.c++
+      push:
+        - match: ^\s*(#\s*endif)\b
+          captures:
+            1: meta.preprocessor.c++ keyword.control.import.c++
+          pop: true
+        - match: ^\s*(#\s*else)\b
+          captures:
+            1: meta.preprocessor.c++ keyword.control.import.else.c++
+          push:
+            - meta_content_scope: comment.block.preprocessor.else-branch.c++
+            - match: (?=^\s*#\s*endif\b)
+              pop: true
+            - include: scope:source.c#preprocessor-disabled
+        - match: ""
+          push:
+            - match: (?=^\s*#\s*(else|endif)\b)
+              pop: true
+            - include: negated-block
+            - include: statements
+
+  preprocessor-rule-other-statements:
+    - match: ^\s*(#\s*(?:if|ifdef|ifndef))\b
+      captures:
+        1: keyword.control.import.c++
+      push:
+        - meta_scope: meta.preprocessor.c++
+        - include: scope:source.c#preprocessor-line-continuation
+        - include: scope:source.c#preprocessor-comments
+        - match: \bdefined\b
+          scope: keyword.control.c++
+        # Enter a new scope where all elif/else branches have their
+        # contexts popped by a subsequent elif/else/endif. This ensures that
+        # preprocessor branches don't push multiple meta.block scopes on
+        # the stack, thus messing up the "global" context's detection of
+        # functions.
+        - match: $\n
+          set: preprocessor-if-branch-statements
+
+  # These gymnastics here ensure that we are properly handling scope even
+  # when the preprocessor is used to create different scope beginnings, such
+  # as a different if/while condition
+  preprocessor-if-branch-statements:
+    - match: ^\s*(#\s*endif)\b
+      captures:
+        1: meta.preprocessor.c++ keyword.control.import.c++
+      pop: true
+    - match: (?=^\s*#\s*(elif|else)\b)
+      push: preprocessor-elif-else-branch-statements
+    - match: \{
+      scope: punctuation.section.block.begin.c++
+      set: preprocessor-block-if-branch-statements
+    - match: (?=(?!{{non_func_keywords}}){{path_lookahead}}\s*\()
+      set: preprocessor-if-branch-function-call
+    - include: negated-block
+    - include: statements
+
+  preprocessor-if-branch-function-call:
+    - meta_content_scope: meta.function-call.c++
+    - include: scope:source.c#c99
+    - match: '(?:(::)\s*)?{{identifier}}\s*(::)\s*'
+      scope: variable.function.c++
+      captures:
+        1: punctuation.accessor.c++
+        2: punctuation.accessor.c++
+    - match: '(?:(::)\s*)?{{identifier}}'
+      scope: variable.function.c++
+      captures:
+        1: punctuation.accessor.c++
+    - match: '\('
+      scope: meta.group.c++ punctuation.section.group.begin.c++
+      set: preprocessor-if-branch-function-call-arguments
+
+  preprocessor-if-branch-function-call-arguments:
+    - meta_content_scope: meta.function-call.c++ meta.group.c++
+    - match : \)
+      scope: meta.function-call.c++ meta.group.c++ punctuation.section.group.end.c++
+      set: preprocessor-if-branch-statements
+    - match: ^\s*(#\s*(?:elif|else))\b
+      captures:
+        1: meta.preprocessor.c++ keyword.control.import.c++
+      set: preprocessor-if-branch-statements
+    - match: ^\s*(#\s*endif)\b
+      captures:
+        1: meta.preprocessor.c++ keyword.control.import.c++
+      set: preprocessor-if-branch-function-call-arguments-finish
+    - include: expressions
+
+  preprocessor-if-branch-function-call-arguments-finish:
+    - meta_content_scope: meta.function-call.c++ meta.group.c++
+    - match: \)
+      scope: meta.function-call.c++ meta.group.c++ punctuation.section.group.end.c++
+      pop: true
+    - include: expressions
+
+  preprocessor-block-if-branch-statements:
+    - meta_scope: meta.block.c++
+    - match: ^\s*(#\s*endif)\b
+      captures:
+        1: meta.preprocessor.c++ keyword.control.import.c++
+      set: preprocessor-block-finish-statements
+    - match: (?=^\s*#\s*(elif|else)\b)
+      push: preprocessor-elif-else-branch-statements
+    - match: \}
+      scope: punctuation.section.block.end.c++
+      set: preprocessor-if-branch-statements
+    - include: statements
+
+  preprocessor-block-finish-statements:
+    - meta_scope: meta.block.c++
+    - match: ^\s*(#\s*(?:if|ifdef|ifndef))\b
+      captures:
+        1: meta.preprocessor.c++ keyword.control.import.c++
+      set: preprocessor-block-finish-if-branch-statements
+    - match: \}
+      scope: punctuation.section.block.end.c++
+      pop: true
+    - include: statements
+
+  preprocessor-block-finish-if-branch-statements:
+    - match: ^\s*(#\s*endif)\b
+      captures:
+        1: keyword.control.import.c++
+      pop: true
+    - match: \}
+      scope: meta.block.c++ punctuation.section.block.end.c++
+      set: preprocessor-if-branch-statements
+    - include: statements
+
+  preprocessor-elif-else-branch-statements:
+    - match: (?=^\s*#\s*endif\b)
+      pop: true
+    - include: negated-block
+    - include: statements
+
+  ## Preprocessor other
+
+  negated-block:
+    - match: '\}'
+      scope: punctuation.section.block.end.c++
+      push:
+        - match: '\{'
+          scope: punctuation.section.block.begin.c++
+          pop: true
+        - match: (?=^\s*#\s*(elif|else|endif)\b)
+          pop: true
+        - include: statements
+
+  preprocessor-macro-define:
+    - match: ^\s*(\#\s*define)\b
+      captures:
+        1: meta.preprocessor.macro.c++ keyword.control.import.define.c++
+      push:
+        - meta_content_scope: meta.preprocessor.macro.c++
+        - include: scope:source.c#preprocessor-line-continuation
+        - include: scope:source.c#preprocessor-line-ending
+        - include: scope:source.c#preprocessor-comments
+        - match: '({{identifier}})(?=\()'
+          scope: entity.name.function.preprocessor.c++
+          set:
+            - match: '\('
+              scope: punctuation.section.group.begin.c++
+              set: preprocessor-macro-params
+        - match: '{{identifier}}'
+          scope: entity.name.constant.preprocessor.c++
+          set: preprocessor-macro-definition
+
+  preprocessor-macro-params:
+    - meta_scope: meta.preprocessor.macro.parameters.c++ meta.group.c++
+    - match: '{{identifier}}'
+      scope: variable.parameter.c++
+    - match: \)
+      scope: punctuation.section.group.end.c++
+      set: preprocessor-macro-definition
+    - match: ','
+      scope: punctuation.separator.c++
+      push:
+        - match: '{{identifier}}'
+          scope: variable.parameter.c++
+          pop: true
+        - include: scope:source.c#preprocessor-line-continuation
+        - include: scope:source.c#preprocessor-comments
+        - match: '\.\.\.'
+          scope: keyword.operator.variadic.c++
+        - match: '(?=\))'
+          pop: true
+        - match: (/\*).*(\*/)
+          scope: comment.block.c++
+          captures:
+            1: punctuation.definition.comment.c++
+            2: punctuation.definition.comment.c++
+        - match: '\S+'
+          scope: invalid.illegal.unexpected-character.c++
+    - include: scope:source.c#preprocessor-line-continuation
+    - include: scope:source.c#preprocessor-comments
+    - match: '\.\.\.'
+      scope: keyword.operator.variadic.c++
+    - match: (/\*).*(\*/)
+      scope: comment.block.c++
+      captures:
+        1: punctuation.definition.comment.c++
+        2: punctuation.definition.comment.c++
+    - match: $\n
+      scope: invalid.illegal.unexpected-end-of-line.c++
+
+  preprocessor-macro-definition:
+    - meta_content_scope: meta.preprocessor.macro.c++
+    - include: scope:source.c#preprocessor-line-continuation
+    - include: scope:source.c#preprocessor-line-ending
+    - include: scope:source.c#preprocessor-comments
+    # Don't define blocks in define statements
+    - match: '\{'
+      scope: punctuation.section.block.begin.c++
+    - match: '\}'
+      scope: punctuation.section.block.end.c++
+    - include: expressions
+
+  preprocessor-practical-workarounds:
+    - include: preprocessor-convention-ignore-uppercase-ident-lines
+    - include: scope:source.c#preprocessor-convention-ignore-uppercase-calls-without-semicolon
+
+  preprocessor-convention-ignore-uppercase-ident-lines:
+    - match: ^(\s*{{macro_identifier}})+\s*$
+      scope: meta.assumed-macro.c++
+      push:
+        # It's possible that we are dealing with a function return type on its own line, and the
+        # name of the function is on the subsequent line.
+        - match: '(?={{path_lookahead}}({{generic_lookahead}}({{path_lookahead}})?)\s*\()'
+          set: [function-definition-params, global-function-identifier-generic]
+        - match: '(?={{path_lookahead}}\s*\()'
+          set: [function-definition-params, global-function-identifier]
+        - match: ^
+          pop: true
+
+  preprocessor-other:
+    - match: ^\s*(#\s*(?:if|ifdef|ifndef|elif|else|line|pragma|undef))\b
+      captures:
+        1: keyword.control.import.c++
+      push:
+        - meta_scope: meta.preprocessor.c++
+        - include: scope:source.c#preprocessor-line-continuation
+        - include: scope:source.c#preprocessor-line-ending
+        - include: scope:source.c#preprocessor-comments
+        - match: \bdefined\b
+          scope: keyword.control.c++
+    - match: ^\s*(#\s*endif)\b
+      captures:
+        1: meta.preprocessor.c++ keyword.control.import.c++
+    - match: ^\s*(#\s*(?:error|warning))\b
+      captures:
+        1: keyword.control.import.error.c++
+      push:
+        - meta_scope: meta.preprocessor.diagnostic.c++
+        - include: scope:source.c#preprocessor-line-continuation
+        - include: scope:source.c#preprocessor-line-ending
+        - include: scope:source.c#preprocessor-comments
+        - include: strings
+        - match: '\S+'
+          scope: string.unquoted.c++
+    - match: ^\s*(#\s*(?:include|include_next|import))\b
+      captures:
+        1: keyword.control.import.include.c++
+      push:
+        - meta_scope: meta.preprocessor.include.c++
+        - include: scope:source.c#preprocessor-line-continuation
+        - include: scope:source.c#preprocessor-line-ending
+        - include: scope:source.c#preprocessor-comments
+        - match: '"'
+          scope: punctuation.definition.string.begin.c++
+          push:
+            - meta_scope: string.quoted.double.include.c++
+            - match: '"'
+              scope: punctuation.definition.string.end.c++
+              pop: true
+        - match: <
+          scope: punctuation.definition.string.begin.c++
+          push:
+            - meta_scope: string.quoted.other.lt-gt.include.c++
+            - match: '>'
+              scope: punctuation.definition.string.end.c++
+              pop: true
+    - include: preprocessor-practical-workarounds
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/README b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/README
new file mode 100644
index 0000000000000000000000000000000000000000..468f5485d9e476c547b65ea92b31fcbc1fef9b31
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/README
@@ -0,0 +1,4 @@
+This directory contains build support files such as
+
+* CMake modules
+* Build scripts
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/Vagrantfile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/Vagrantfile
new file mode 100644
index 0000000000000000000000000000000000000000..9680a1a184abb4e151cafcdad49af6b92749b333
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/Vagrantfile
@@ -0,0 +1,20 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# A vagrant config for testing against gcc-4.8.
+Vagrant.configure("2") do |config|
+  config.vm.box = "ubuntu/xenial64"
+  config.disksize.size = '15GB'
+
+  config.vm.provider "virtualbox" do |vb|
+    vb.memory = "4096"
+  end
+
+  config.vm.provision "shell", inline: <<-SHELL
+    apt-get update
+    apt-get install -y g++ make wget git
+    wget -q https://github.com/Kitware/CMake/releases/download/v3.26.0/cmake-3.26.0-Linux-x86_64.tar.gz
+    tar xzf cmake-3.26.0-Linux-x86_64.tar.gz
+    ln -s `pwd`/cmake-3.26.0-Linux-x86_64/bin/cmake /usr/local/bin
+  SHELL
+end
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/bazel/.bazelversion b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/bazel/.bazelversion
new file mode 100644
index 0000000000000000000000000000000000000000..5e3254243a3b271c531c00916b750411d9dad34e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/bazel/.bazelversion
@@ -0,0 +1 @@
+6.1.2
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/bazel/BUILD.bazel b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/bazel/BUILD.bazel
new file mode 100644
index 0000000000000000000000000000000000000000..29f639becd5e9c6695fc02cfbdc7ab704a145de5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/bazel/BUILD.bazel
@@ -0,0 +1,28 @@
+cc_library(
+    name = "fmt",
+    srcs = [
+        #"src/fmt.cc", # No C++ module support
+        "src/format.cc",
+        "src/os.cc",
+    ],
+    hdrs = [
+        "include/fmt/args.h",
+        "include/fmt/chrono.h",
+        "include/fmt/color.h",
+        "include/fmt/compile.h",
+        "include/fmt/core.h",
+        "include/fmt/format.h",
+        "include/fmt/format-inl.h",
+        "include/fmt/os.h",
+        "include/fmt/ostream.h",
+        "include/fmt/printf.h",
+        "include/fmt/ranges.h",
+        "include/fmt/std.h",
+        "include/fmt/xchar.h",
+    ],
+    includes = [
+        "include",
+    ],
+    strip_include_prefix = "include",
+    visibility = ["//visibility:public"],
+)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/bazel/README.md b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/bazel/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4c29febb1eba4d483dfdb9639e26ed81e18152f9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/bazel/README.md
@@ -0,0 +1,74 @@
+# Bazel support
+
+To get [Bazel](https://bazel.build/) working with {fmt} you can copy the files `BUILD.bazel`, `WORKSPACE.bazel`, and `.bazelversion` from this folder (`support/bazel`) to the root folder of this project. This way {fmt} gets bazelized and can be used with Bazel (e.g. doing a `bazel build //...` on {fmt}). 
+
+## Using {fmt} as a dependency
+
+The following minimal example shows how to use {fmt} as a dependency within a Bazel project.
+
+The following file structure is assumed:
+
+```
+example
+├── BUILD.bazel
+├── main.cpp
+└── WORKSPACE.bazel
+```
+
+*main.cpp*:
+
+```c++
+#include "fmt/core.h"
+
+int main() {
+  fmt::print("The answer is {}\n", 42);
+}
+```
+
+The expected output of this example is `The answer is 42`.
+
+*WORKSPACE.bazel*:
+
+```python
+load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
+
+git_repository(
+    name = "fmt",
+    branch = "master",
+    remote = "https://github.com/fmtlib/fmt",
+    patch_cmds = [
+        "mv support/bazel/.bazelversion .bazelversion",
+        "mv support/bazel/BUILD.bazel BUILD.bazel",
+        "mv support/bazel/WORKSPACE.bazel WORKSPACE.bazel",
+    ],
+    # Windows-related patch commands are only needed in the case MSYS2 is not installed.
+    # More details about the installation process of MSYS2 on Windows systems can be found here:
+    # https://docs.bazel.build/versions/main/install-windows.html#installing-compilers-and-language-runtimes
+    # Even if MSYS2 is installed the Windows related patch commands can still be used.
+    patch_cmds_win = [
+        "Move-Item -Path support/bazel/.bazelversion -Destination .bazelversion",
+        "Move-Item -Path support/bazel/BUILD.bazel -Destination BUILD.bazel",
+        "Move-Item -Path support/bazel/WORKSPACE.bazel -Destination WORKSPACE.bazel",
+    ],
+)
+```
+
+In the *WORKSPACE* file, the {fmt} GitHub repository is fetched. Using the attribute `patch_cmds` the  files `BUILD.bazel`, `WORKSPACE.bazel`, and `.bazelversion` are moved to the root of the {fmt} repository. This way the {fmt} repository is recognized as a bazelized workspace. 
+
+*BUILD.bazel*:
+
+```python
+cc_binary(
+    name = "Demo",
+    srcs = ["main.cpp"],
+    deps = ["@fmt"],
+)
+```
+
+The *BUILD* file defines a binary named `Demo` that has a dependency to {fmt}.
+
+To execute the binary you can run `bazel run //:Demo`.
+
+# Using Bzlmod
+
+The [Bazel Central Registry](https://github.com/bazelbuild/bazel-central-registry/tree/main/modules/fmt) also provides support for {fmt}.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/bazel/WORKSPACE.bazel b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/bazel/WORKSPACE.bazel
new file mode 100644
index 0000000000000000000000000000000000000000..5be77811bd117dc1d2fc3b5fd7f99ff71c0a4cef
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/bazel/WORKSPACE.bazel
@@ -0,0 +1 @@
+workspace(name = "fmt")
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/build-docs.py b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/build-docs.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1395cd6cd592b843114cfbd7d63eedc3da8ffe1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/build-docs.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+# Build the documentation in CI.
+
+from __future__ import print_function
+import errno, os, shutil, subprocess, sys, urllib
+from subprocess import call, check_call, Popen, PIPE, STDOUT
+
+def rmtree_if_exists(dir):
+    try:
+        shutil.rmtree(dir)
+    except OSError as e:
+        if e.errno == errno.ENOENT:
+            pass
+
+# Build the docs.
+fmt_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+sys.path.insert(0, os.path.join(fmt_dir, 'doc'))
+import build
+build.create_build_env()
+html_dir = build.build_docs()
+
+repo = 'fmtlib.github.io'
+branch = os.environ['GITHUB_REF']
+is_ci = 'CI' in os.environ
+if is_ci and branch != 'refs/heads/master':
+    print('Branch: ' + branch)
+    exit(0) # Ignore non-master branches
+if is_ci and 'KEY' not in os.environ:
+    # Don't update the repo if building in CI from an account that doesn't have
+    # push access.
+    print('Skipping update of ' + repo)
+    exit(0)
+
+# Clone the fmtlib.github.io repo.
+rmtree_if_exists(repo)
+git_url = 'https://github.com/' if is_ci else 'git@github.com:'
+check_call(['git', 'clone', git_url + 'fmtlib/{}.git'.format(repo)])
+
+# Copy docs to the repo.
+target_dir = os.path.join(repo, 'dev')
+rmtree_if_exists(target_dir)
+shutil.copytree(html_dir, target_dir, ignore=shutil.ignore_patterns('.*'))
+if is_ci:
+    check_call(['git', 'config', '--global', 'user.name', 'fmtbot'])
+    check_call(['git', 'config', '--global', 'user.email', 'viz@fmt.dev'])
+
+# Push docs to GitHub pages.
+check_call(['git', 'add', '--all'], cwd=repo)
+if call(['git', 'diff-index', '--quiet', 'HEAD'], cwd=repo):
+    check_call(['git', 'commit', '-m', 'Update documentation'], cwd=repo)
+    cmd = 'git push'
+    if is_ci:
+        cmd += ' https://$KEY@github.com/fmtlib/fmtlib.github.io.git master'
+    p = Popen(cmd, shell=True, stdout=PIPE, stderr=STDOUT, cwd=repo)
+    # Print the output without the key.
+    print(p.communicate()[0].decode('utf-8').replace(os.environ['KEY'], '$KEY'))
+    if p.returncode != 0:
+        raise subprocess.CalledProcessError(p.returncode, cmd)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/build.gradle b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/build.gradle
new file mode 100644
index 0000000000000000000000000000000000000000..c5126d0583b37e2f5d9c6d8d281b26833fd2d55d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/build.gradle
@@ -0,0 +1,132 @@
+import java.nio.file.Paths
+
+// General gradle arguments for root project
+buildscript {    
+    repositories {
+        google()
+        jcenter()
+    }
+    dependencies {
+        //
+        // https://developer.android.com/studio/releases/gradle-plugin#updating-gradle
+        //
+        // Notice that 4.0.0 here is the version of [Android Gradle Plugin]
+        // According to URL above you will need Gradle 6.1 or higher
+        //
+        classpath "com.android.tools.build:gradle:4.1.1"
+    }
+}
+repositories {
+    google()
+    jcenter()
+}
+
+// Project's root where CMakeLists.txt exists: rootDir/support/.cxx -> rootDir
+def rootDir = Paths.get(project.buildDir.getParent()).getParent()
+println("rootDir: ${rootDir}")
+
+// Output: Shared library (.so) for Android 
+apply plugin: "com.android.library"
+android {
+    compileSdkVersion 25    // Android 7.0
+
+    // Target ABI
+    //  - This option controls target platform of module
+    //  - The platform might be limited by compiler's support
+    //    some can work with Clang(default), but some can work only with GCC...
+    //    if bad, both toolchains might not support it
+    splits {
+        abi {
+            enable true
+            // Specify platforms for Application
+            reset()
+            include  "arm64-v8a", "armeabi-v7a", "x86_64"
+        }
+    }
+    ndkVersion "21.3.6528147" // ANDROID_NDK_HOME is deprecated. Be explicit
+
+    defaultConfig {
+        minSdkVersion 21    // Android 5.0+
+        targetSdkVersion 25 // Follow Compile SDK
+        versionCode 34      // Follow release count
+        versionName "7.1.2" // Follow Official version
+        
+        externalNativeBuild {
+            cmake {
+                arguments "-DANDROID_STL=c++_shared"    // Specify Android STL
+                arguments "-DBUILD_SHARED_LIBS=true"    // Build shared object
+                arguments "-DFMT_TEST=false"            // Skip test
+                arguments "-DFMT_DOC=false"             // Skip document
+                cppFlags  "-std=c++17"
+                targets   "fmt"
+            }
+        }
+        println(externalNativeBuild.cmake.cppFlags)
+        println(externalNativeBuild.cmake.arguments)
+    }
+
+    // External Native build
+    //  - Use existing CMakeList.txt
+    //  - Give path to CMake. This gradle file should be 
+    //    neighbor of the top level cmake
+    externalNativeBuild {
+        cmake {
+            version "3.10.0+"
+            path "${rootDir}/CMakeLists.txt"
+            // buildStagingDirectory "./build"  // Custom path for cmake output
+        }
+    }
+    
+    sourceSets{
+        // Android Manifest for Gradle
+        main {
+            manifest.srcFile "AndroidManifest.xml"
+        }
+    }
+
+    // https://developer.android.com/studio/build/native-dependencies#build_system_configuration
+    buildFeatures {
+        prefab true
+        prefabPublishing true
+    }
+    prefab {
+        fmt {
+            headers "${rootDir}/include"
+        }
+    }
+}
+
+assemble.doLast
+{
+    // Instead of `ninja install`, Gradle will deploy the files.
+    // We are doing this since FMT is dependent to the ANDROID_STL after build
+    copy {
+        from "build/intermediates/cmake"
+        into "${rootDir}/libs"
+    }
+    // Copy debug binaries
+    copy {
+        from "${rootDir}/libs/debug/obj"
+        into "${rootDir}/libs/debug"
+    }
+    // Copy Release binaries
+    copy {
+        from "${rootDir}/libs/release/obj"
+        into "${rootDir}/libs/release"
+    }
+    // Remove empty directory
+    delete "${rootDir}/libs/debug/obj"
+    delete "${rootDir}/libs/release/obj"
+
+    // Copy AAR files. Notice that the aar is named after the folder of this script.
+    copy {
+        from "build/outputs/aar/support-release.aar"
+        into "${rootDir}/libs"
+        rename "support-release.aar", "fmt-release.aar"
+    }
+    copy {
+        from "build/outputs/aar/support-debug.aar"
+        into "${rootDir}/libs"
+        rename "support-debug.aar", "fmt-debug.aar"
+    }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/cmake/FindSetEnv.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/cmake/FindSetEnv.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..4e2da5408ac3c54975ff9acc7091ffdbb6c83b0d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/cmake/FindSetEnv.cmake
@@ -0,0 +1,7 @@
+# A CMake script to find SetEnv.cmd.
+
+find_program(WINSDK_SETENV NAMES SetEnv.cmd
+  PATHS "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]/bin")
+if (WINSDK_SETENV AND PRINT_PATH)
+  execute_process(COMMAND ${CMAKE_COMMAND} -E echo "${WINSDK_SETENV}")
+endif ()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/cmake/JoinPaths.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/cmake/JoinPaths.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..32d6d6685c06e84a18ff23c8eec8cf0f9eec9bff
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/cmake/JoinPaths.cmake
@@ -0,0 +1,26 @@
+# This module provides function for joining paths
+# known from from most languages
+#
+# Original license:
+# SPDX-License-Identifier: (MIT OR CC0-1.0)
+# Explicit permission given to distribute this module under
+# the terms of the project as described in /LICENSE.rst.
+# Copyright 2020 Jan Tojnar
+# https://github.com/jtojnar/cmake-snips
+#
+# Modelled after Python’s os.path.join
+# https://docs.python.org/3.7/library/os.path.html#os.path.join
+# Windows not supported
+function(join_paths joined_path first_path_segment)
+    set(temp_path "${first_path_segment}")
+    foreach(current_segment IN LISTS ARGN)
+        if(NOT ("${current_segment}" STREQUAL ""))
+            if(IS_ABSOLUTE "${current_segment}")
+                set(temp_path "${current_segment}")
+            else()
+                set(temp_path "${temp_path}/${current_segment}")
+            endif()
+        endif()
+    endforeach()
+    set(${joined_path} "${temp_path}" PARENT_SCOPE)
+endfunction()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/cmake/fmt-config.cmake.in b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/cmake/fmt-config.cmake.in
new file mode 100644
index 0000000000000000000000000000000000000000..bc1684f245c4f1a18879441578bec039343615fd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/cmake/fmt-config.cmake.in
@@ -0,0 +1,7 @@
+@PACKAGE_INIT@
+
+if (NOT TARGET fmt::fmt)
+  include(${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake)
+endif ()
+
+check_required_components(fmt)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/cmake/fmt.pc.in b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/cmake/fmt.pc.in
new file mode 100644
index 0000000000000000000000000000000000000000..29976a8af0b241881fd6ba30c27582f619821c95
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/cmake/fmt.pc.in
@@ -0,0 +1,11 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@libdir_for_pc_file@
+includedir=@includedir_for_pc_file@
+
+Name: fmt
+Description: A modern formatting library
+Version: @FMT_VERSION@
+Libs: -L${libdir} -l@FMT_LIB_NAME@
+Cflags: -I${includedir}
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/compute-powers.py b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/compute-powers.py
new file mode 100644
index 0000000000000000000000000000000000000000..601063d4248f47858f51d854de627d70c307bbe0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/compute-powers.py
@@ -0,0 +1,53 @@
+#!/usr/bin/env python
+# Compute 10 ** exp with exp in the range [min_exponent, max_exponent] and print
+# normalized (with most-significant bit equal to 1) significands in hexadecimal.
+
+from __future__ import print_function
+
+min_exponent = -348
+max_exponent = 340
+step = 8
+significand_size = 64
+exp_offset = 2000
+
+class fp:
+    pass
+
+powers = []
+for i, exp in enumerate(range(min_exponent, max_exponent + 1, step)):
+    result = fp()
+    n = 10 ** exp if exp >= 0 else 2 ** exp_offset / 10 ** -exp
+    k = significand_size + 1
+    # Convert to binary and round.
+    binary = '{:b}'.format(n)
+    result.f = (int('{:0<{}}'.format(binary[:k], k), 2) + 1) / 2
+    result.e = len(binary) - (exp_offset if exp < 0 else 0) - significand_size
+    powers.append(result)
+    # Sanity check.
+    exp_offset10 = 400
+    actual = result.f * 10 ** exp_offset10
+    if result.e > 0:
+        actual *= 2 ** result.e
+    else:
+        for j in range(-result.e):
+            actual /= 2
+    expected = 10 ** (exp_offset10 + exp)
+    precision = len('{}'.format(expected)) - len('{}'.format(actual - expected))
+    if precision < 19:
+        print('low precision:', precision)
+        exit(1)
+
+print('Significands:', end='')
+for i, fp in enumerate(powers):
+    if i % 3 == 0:
+        print(end='\n ')
+    print(' {:0<#16x}'.format(fp.f, ), end=',')
+
+print('\n\nExponents:', end='')
+for i, fp in enumerate(powers):
+    if i % 11 == 0:
+        print(end='\n ')
+    print(' {:5}'.format(fp.e), end=',')
+
+print('\n\nMax exponent difference:',
+      max([x.e - powers[i - 1].e for i, x in enumerate(powers)][1:]))
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/docopt.py b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/docopt.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e43f7cef8193b2273e687e27204c98115078d57
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/docopt.py
@@ -0,0 +1,581 @@
+"""Pythonic command-line interface parser that will make you smile.
+
+ * http://docopt.org
+ * Repository and issue-tracker: https://github.com/docopt/docopt
+ * Licensed under terms of MIT license (see LICENSE-MIT)
+ * Copyright (c) 2013 Vladimir Keleshev, vladimir@keleshev.com
+
+"""
+import sys
+import re
+
+
+__all__ = ['docopt']
+__version__ = '0.6.1'
+
+
+class DocoptLanguageError(Exception):
+
+    """Error in construction of usage-message by developer."""
+
+
+class DocoptExit(SystemExit):
+
+    """Exit in case user invoked program with incorrect arguments."""
+
+    usage = ''
+
+    def __init__(self, message=''):
+        SystemExit.__init__(self, (message + '\n' + self.usage).strip())
+
+
+class Pattern(object):
+
+    def __eq__(self, other):
+        return repr(self) == repr(other)
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def fix(self):
+        self.fix_identities()
+        self.fix_repeating_arguments()
+        return self
+
+    def fix_identities(self, uniq=None):
+        """Make pattern-tree tips point to same object if they are equal."""
+        if not hasattr(self, 'children'):
+            return self
+        uniq = list(set(self.flat())) if uniq is None else uniq
+        for i, child in enumerate(self.children):
+            if not hasattr(child, 'children'):
+                assert child in uniq
+                self.children[i] = uniq[uniq.index(child)]
+            else:
+                child.fix_identities(uniq)
+
+    def fix_repeating_arguments(self):
+        """Fix elements that should accumulate/increment values."""
+        either = [list(child.children) for child in transform(self).children]
+        for case in either:
+            for e in [child for child in case if case.count(child) > 1]:
+                if type(e) is Argument or type(e) is Option and e.argcount:
+                    if e.value is None:
+                        e.value = []
+                    elif type(e.value) is not list:
+                        e.value = e.value.split()
+                if type(e) is Command or type(e) is Option and e.argcount == 0:
+                    e.value = 0
+        return self
+
+
+def transform(pattern):
+    """Expand pattern into an (almost) equivalent one, but with single Either.
+
+    Example: ((-a | -b) (-c | -d)) => (-a -c | -a -d | -b -c | -b -d)
+    Quirks: [-a] => (-a), (-a...) => (-a -a)
+
+    """
+    result = []
+    groups = [[pattern]]
+    while groups:
+        children = groups.pop(0)
+        parents = [Required, Optional, OptionsShortcut, Either, OneOrMore]
+        if any(t in map(type, children) for t in parents):
+            child = [c for c in children if type(c) in parents][0]
+            children.remove(child)
+            if type(child) is Either:
+                for c in child.children:
+                    groups.append([c] + children)
+            elif type(child) is OneOrMore:
+                groups.append(child.children * 2 + children)
+            else:
+                groups.append(child.children + children)
+        else:
+            result.append(children)
+    return Either(*[Required(*e) for e in result])
+
+
+class LeafPattern(Pattern):
+
+    """Leaf/terminal node of a pattern tree."""
+
+    def __init__(self, name, value=None):
+        self.name, self.value = name, value
+
+    def __repr__(self):
+        return '%s(%r, %r)' % (self.__class__.__name__, self.name, self.value)
+
+    def flat(self, *types):
+        return [self] if not types or type(self) in types else []
+
+    def match(self, left, collected=None):
+        collected = [] if collected is None else collected
+        pos, match = self.single_match(left)
+        if match is None:
+            return False, left, collected
+        left_ = left[:pos] + left[pos + 1:]
+        same_name = [a for a in collected if a.name == self.name]
+        if type(self.value) in (int, list):
+            if type(self.value) is int:
+                increment = 1
+            else:
+                increment = ([match.value] if type(match.value) is str
+                             else match.value)
+            if not same_name:
+                match.value = increment
+                return True, left_, collected + [match]
+            same_name[0].value += increment
+            return True, left_, collected
+        return True, left_, collected + [match]
+
+
+class BranchPattern(Pattern):
+
+    """Branch/inner node of a pattern tree."""
+
+    def __init__(self, *children):
+        self.children = list(children)
+
+    def __repr__(self):
+        return '%s(%s)' % (self.__class__.__name__,
+                           ', '.join(repr(a) for a in self.children))
+
+    def flat(self, *types):
+        if type(self) in types:
+            return [self]
+        return sum([child.flat(*types) for child in self.children], [])
+
+
+class Argument(LeafPattern):
+
+    def single_match(self, left):
+        for n, pattern in enumerate(left):
+            if type(pattern) is Argument:
+                return n, Argument(self.name, pattern.value)
+        return None, None
+
+    @classmethod
+    def parse(class_, source):
+        name = re.findall('(<\S*?>)', source)[0]
+        value = re.findall('\[default: (.*)\]', source, flags=re.I)
+        return class_(name, value[0] if value else None)
+
+
+class Command(Argument):
+
+    def __init__(self, name, value=False):
+        self.name, self.value = name, value
+
+    def single_match(self, left):
+        for n, pattern in enumerate(left):
+            if type(pattern) is Argument:
+                if pattern.value == self.name:
+                    return n, Command(self.name, True)
+                else:
+                    break
+        return None, None
+
+
+class Option(LeafPattern):
+
+    def __init__(self, short=None, long=None, argcount=0, value=False):
+        assert argcount in (0, 1)
+        self.short, self.long, self.argcount = short, long, argcount
+        self.value = None if value is False and argcount else value
+
+    @classmethod
+    def parse(class_, option_description):
+        short, long, argcount, value = None, None, 0, False
+        options, _, description = option_description.strip().partition('  ')
+        options = options.replace(',', ' ').replace('=', ' ')
+        for s in options.split():
+            if s.startswith('--'):
+                long = s
+            elif s.startswith('-'):
+                short = s
+            else:
+                argcount = 1
+        if argcount:
+            matched = re.findall('\[default: (.*)\]', description, flags=re.I)
+            value = matched[0] if matched else None
+        return class_(short, long, argcount, value)
+
+    def single_match(self, left):
+        for n, pattern in enumerate(left):
+            if self.name == pattern.name:
+                return n, pattern
+        return None, None
+
+    @property
+    def name(self):
+        return self.long or self.short
+
+    def __repr__(self):
+        return 'Option(%r, %r, %r, %r)' % (self.short, self.long,
+                                           self.argcount, self.value)
+
+
+class Required(BranchPattern):
+
+    def match(self, left, collected=None):
+        collected = [] if collected is None else collected
+        l = left
+        c = collected
+        for pattern in self.children:
+            matched, l, c = pattern.match(l, c)
+            if not matched:
+                return False, left, collected
+        return True, l, c
+
+
+class Optional(BranchPattern):
+
+    def match(self, left, collected=None):
+        collected = [] if collected is None else collected
+        for pattern in self.children:
+            m, left, collected = pattern.match(left, collected)
+        return True, left, collected
+
+
+class OptionsShortcut(Optional):
+
+    """Marker/placeholder for [options] shortcut."""
+
+
+class OneOrMore(BranchPattern):
+
+    def match(self, left, collected=None):
+        assert len(self.children) == 1
+        collected = [] if collected is None else collected
+        l = left
+        c = collected
+        l_ = None
+        matched = True
+        times = 0
+        while matched:
+            # could it be that something didn't match but changed l or c?
+            matched, l, c = self.children[0].match(l, c)
+            times += 1 if matched else 0
+            if l_ == l:
+                break
+            l_ = l
+        if times >= 1:
+            return True, l, c
+        return False, left, collected
+
+
+class Either(BranchPattern):
+
+    def match(self, left, collected=None):
+        collected = [] if collected is None else collected
+        outcomes = []
+        for pattern in self.children:
+            matched, _, _ = outcome = pattern.match(left, collected)
+            if matched:
+                outcomes.append(outcome)
+        if outcomes:
+            return min(outcomes, key=lambda outcome: len(outcome[1]))
+        return False, left, collected
+
+
+class Tokens(list):
+
+    def __init__(self, source, error=DocoptExit):
+        self += source.split() if hasattr(source, 'split') else source
+        self.error = error
+
+    @staticmethod
+    def from_pattern(source):
+        source = re.sub(r'([\[\]\(\)\|]|\.\.\.)', r' \1 ', source)
+        source = [s for s in re.split('\s+|(\S*<.*?>)', source) if s]
+        return Tokens(source, error=DocoptLanguageError)
+
+    def move(self):
+        return self.pop(0) if len(self) else None
+
+    def current(self):
+        return self[0] if len(self) else None
+
+
+def parse_long(tokens, options):
+    """long ::= '--' chars [ ( ' ' | '=' ) chars ] ;"""
+    long, eq, value = tokens.move().partition('=')
+    assert long.startswith('--')
+    value = None if eq == value == '' else value
+    similar = [o for o in options if o.long == long]
+    if tokens.error is DocoptExit and similar == []:  # if no exact match
+        similar = [o for o in options if o.long and o.long.startswith(long)]
+    if len(similar) > 1:  # might be simply specified ambiguously 2+ times?
+        raise tokens.error('%s is not a unique prefix: %s?' %
+                           (long, ', '.join(o.long for o in similar)))
+    elif len(similar) < 1:
+        argcount = 1 if eq == '=' else 0
+        o = Option(None, long, argcount)
+        options.append(o)
+        if tokens.error is DocoptExit:
+            o = Option(None, long, argcount, value if argcount else True)
+    else:
+        o = Option(similar[0].short, similar[0].long,
+                   similar[0].argcount, similar[0].value)
+        if o.argcount == 0:
+            if value is not None:
+                raise tokens.error('%s must not have an argument' % o.long)
+        else:
+            if value is None:
+                if tokens.current() in [None, '--']:
+                    raise tokens.error('%s requires argument' % o.long)
+                value = tokens.move()
+        if tokens.error is DocoptExit:
+            o.value = value if value is not None else True
+    return [o]
+
+
+def parse_shorts(tokens, options):
+    """shorts ::= '-' ( chars )* [ [ ' ' ] chars ] ;"""
+    token = tokens.move()
+    assert token.startswith('-') and not token.startswith('--')
+    left = token.lstrip('-')
+    parsed = []
+    while left != '':
+        short, left = '-' + left[0], left[1:]
+        similar = [o for o in options if o.short == short]
+        if len(similar) > 1:
+            raise tokens.error('%s is specified ambiguously %d times' %
+                               (short, len(similar)))
+        elif len(similar) < 1:
+            o = Option(short, None, 0)
+            options.append(o)
+            if tokens.error is DocoptExit:
+                o = Option(short, None, 0, True)
+        else:  # why copying is necessary here?
+            o = Option(short, similar[0].long,
+                       similar[0].argcount, similar[0].value)
+            value = None
+            if o.argcount != 0:
+                if left == '':
+                    if tokens.current() in [None, '--']:
+                        raise tokens.error('%s requires argument' % short)
+                    value = tokens.move()
+                else:
+                    value = left
+                    left = ''
+            if tokens.error is DocoptExit:
+                o.value = value if value is not None else True
+        parsed.append(o)
+    return parsed
+
+
+def parse_pattern(source, options):
+    tokens = Tokens.from_pattern(source)
+    result = parse_expr(tokens, options)
+    if tokens.current() is not None:
+        raise tokens.error('unexpected ending: %r' % ' '.join(tokens))
+    return Required(*result)
+
+
+def parse_expr(tokens, options):
+    """expr ::= seq ( '|' seq )* ;"""
+    seq = parse_seq(tokens, options)
+    if tokens.current() != '|':
+        return seq
+    result = [Required(*seq)] if len(seq) > 1 else seq
+    while tokens.current() == '|':
+        tokens.move()
+        seq = parse_seq(tokens, options)
+        result += [Required(*seq)] if len(seq) > 1 else seq
+    return [Either(*result)] if len(result) > 1 else result
+
+
+def parse_seq(tokens, options):
+    """seq ::= ( atom [ '...' ] )* ;"""
+    result = []
+    while tokens.current() not in [None, ']', ')', '|']:
+        atom = parse_atom(tokens, options)
+        if tokens.current() == '...':
+            atom = [OneOrMore(*atom)]
+            tokens.move()
+        result += atom
+    return result
+
+
+def parse_atom(tokens, options):
+    """atom ::= '(' expr ')' | '[' expr ']' | 'options'
+             | long | shorts | argument | command ;
+    """
+    token = tokens.current()
+    result = []
+    if token in '([':
+        tokens.move()
+        matching, pattern = {'(': [')', Required], '[': [']', Optional]}[token]
+        result = pattern(*parse_expr(tokens, options))
+        if tokens.move() != matching:
+            raise tokens.error("unmatched '%s'" % token)
+        return [result]
+    elif token == 'options':
+        tokens.move()
+        return [OptionsShortcut()]
+    elif token.startswith('--') and token != '--':
+        return parse_long(tokens, options)
+    elif token.startswith('-') and token not in ('-', '--'):
+        return parse_shorts(tokens, options)
+    elif token.startswith('<') and token.endswith('>') or token.isupper():
+        return [Argument(tokens.move())]
+    else:
+        return [Command(tokens.move())]
+
+
+def parse_argv(tokens, options, options_first=False):
+    """Parse command-line argument vector.
+
+    If options_first:
+        argv ::= [ long | shorts ]* [ argument ]* [ '--' [ argument ]* ] ;
+    else:
+        argv ::= [ long | shorts | argument ]* [ '--' [ argument ]* ] ;
+
+    """
+    parsed = []
+    while tokens.current() is not None:
+        if tokens.current() == '--':
+            return parsed + [Argument(None, v) for v in tokens]
+        elif tokens.current().startswith('--'):
+            parsed += parse_long(tokens, options)
+        elif tokens.current().startswith('-') and tokens.current() != '-':
+            parsed += parse_shorts(tokens, options)
+        elif options_first:
+            return parsed + [Argument(None, v) for v in tokens]
+        else:
+            parsed.append(Argument(None, tokens.move()))
+    return parsed
+
+
+def parse_defaults(doc):
+    defaults = []
+    for s in parse_section('options:', doc):
+        # FIXME corner case "bla: options: --foo"
+        _, _, s = s.partition(':')  # get rid of "options:"
+        split = re.split('\n[ \t]*(-\S+?)', '\n' + s)[1:]
+        split = [s1 + s2 for s1, s2 in zip(split[::2], split[1::2])]
+        options = [Option.parse(s) for s in split if s.startswith('-')]
+        defaults += options
+    return defaults
+
+
+def parse_section(name, source):
+    pattern = re.compile('^([^\n]*' + name + '[^\n]*\n?(?:[ \t].*?(?:\n|$))*)',
+                         re.IGNORECASE | re.MULTILINE)
+    return [s.strip() for s in pattern.findall(source)]
+
+
+def formal_usage(section):
+    _, _, section = section.partition(':')  # drop "usage:"
+    pu = section.split()
+    return '( ' + ' '.join(') | (' if s == pu[0] else s for s in pu[1:]) + ' )'
+
+
+def extras(help, version, options, doc):
+    if help and any((o.name in ('-h', '--help')) and o.value for o in options):
+        print(doc.strip("\n"))
+        sys.exit()
+    if version and any(o.name == '--version' and o.value for o in options):
+        print(version)
+        sys.exit()
+
+
+class Dict(dict):
+    def __repr__(self):
+        return '{%s}' % ',\n '.join('%r: %r' % i for i in sorted(self.items()))
+
+
+def docopt(doc, argv=None, help=True, version=None, options_first=False):
+    """Parse `argv` based on command-line interface described in `doc`.
+
+    `docopt` creates your command-line interface based on its
+    description that you pass as `doc`. Such description can contain
+    --options, <positional-argument>, commands, which could be
+    [optional], (required), (mutually | exclusive) or repeated...
+
+    Parameters
+    ----------
+    doc : str
+        Description of your command-line interface.
+    argv : list of str, optional
+        Argument vector to be parsed. sys.argv[1:] is used if not
+        provided.
+    help : bool (default: True)
+        Set to False to disable automatic help on -h or --help
+        options.
+    version : any object
+        If passed, the object will be printed if --version is in
+        `argv`.
+    options_first : bool (default: False)
+        Set to True to require options precede positional arguments,
+        i.e. to forbid options and positional arguments intermix.
+
+    Returns
+    -------
+    args : dict
+        A dictionary, where keys are names of command-line elements
+        such as e.g. "--verbose" and "<path>", and values are the
+        parsed values of those elements.
+
+    Example
+    -------
+    >>> from docopt import docopt
+    >>> doc = '''
+    ... Usage:
+    ...     my_program tcp <host> <port> [--timeout=<seconds>]
+    ...     my_program serial <port> [--baud=<n>] [--timeout=<seconds>]
+    ...     my_program (-h | --help | --version)
+    ...
+    ... Options:
+    ...     -h, --help  Show this screen and exit.
+    ...     --baud=<n>  Baudrate [default: 9600]
+    ... '''
+    >>> argv = ['tcp', '127.0.0.1', '80', '--timeout', '30']
+    >>> docopt(doc, argv)
+    {'--baud': '9600',
+     '--help': False,
+     '--timeout': '30',
+     '--version': False,
+     '<host>': '127.0.0.1',
+     '<port>': '80',
+     'serial': False,
+     'tcp': True}
+
+    See also
+    --------
+    * For video introduction see http://docopt.org
+    * Full documentation is available in README.rst as well as online
+      at https://github.com/docopt/docopt#readme
+
+    """
+    argv = sys.argv[1:] if argv is None else argv
+
+    usage_sections = parse_section('usage:', doc)
+    if len(usage_sections) == 0:
+        raise DocoptLanguageError('"usage:" (case-insensitive) not found.')
+    if len(usage_sections) > 1:
+        raise DocoptLanguageError('More than one "usage:" (case-insensitive).')
+    DocoptExit.usage = usage_sections[0]
+
+    options = parse_defaults(doc)
+    pattern = parse_pattern(formal_usage(DocoptExit.usage), options)
+    # [default] syntax for argument is disabled
+    #for a in pattern.flat(Argument):
+    #    same_name = [d for d in arguments if d.name == a.name]
+    #    if same_name:
+    #        a.value = same_name[0].value
+    argv = parse_argv(Tokens(argv), list(options), options_first)
+    pattern_options = set(pattern.flat(Option))
+    for options_shortcut in pattern.flat(OptionsShortcut):
+        doc_options = parse_defaults(doc)
+        options_shortcut.children = list(set(doc_options) - pattern_options)
+        #if any_options:
+        #    options_shortcut.children += [Option(o.short, o.long, o.argcount)
+        #                    for o in argv if type(o) is Option]
+    extras(help, version, argv, doc)
+    matched, left, collected = pattern.fix().match(argv)
+    if matched and left == []:  # better error message if left?
+        return Dict((a.name, a.value) for a in (pattern.flat() + collected))
+    raise DocoptExit()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/manage.py b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/manage.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfb49797d79858e02234daed2eb6b4668d9b94c3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/manage.py
@@ -0,0 +1,329 @@
+#!/usr/bin/env python3
+
+"""Manage site and releases.
+
+Usage:
+  manage.py release [<branch>]
+  manage.py site
+
+For the release command $FMT_TOKEN should contain a GitHub personal access token
+obtained from https://github.com/settings/tokens.
+"""
+
+from __future__ import print_function
+import datetime, docopt, errno, fileinput, json, os
+import re, requests, shutil, sys
+from contextlib import contextmanager
+from distutils.version import LooseVersion
+from subprocess import check_call
+
+
+class Git:
+    def __init__(self, dir):
+        self.dir = dir
+
+    def call(self, method, args, **kwargs):
+        return check_call(['git', method] + list(args), **kwargs)
+
+    def add(self, *args):
+        return self.call('add', args, cwd=self.dir)
+
+    def checkout(self, *args):
+        return self.call('checkout', args, cwd=self.dir)
+
+    def clean(self, *args):
+        return self.call('clean', args, cwd=self.dir)
+
+    def clone(self, *args):
+        return self.call('clone', list(args) + [self.dir])
+
+    def commit(self, *args):
+        return self.call('commit', args, cwd=self.dir)
+
+    def pull(self, *args):
+        return self.call('pull', args, cwd=self.dir)
+
+    def push(self, *args):
+        return self.call('push', args, cwd=self.dir)
+
+    def reset(self, *args):
+        return self.call('reset', args, cwd=self.dir)
+
+    def update(self, *args):
+        clone = not os.path.exists(self.dir)
+        if clone:
+            self.clone(*args)
+        return clone
+
+
+def clean_checkout(repo, branch):
+    repo.clean('-f', '-d')
+    repo.reset('--hard')
+    repo.checkout(branch)
+
+
+class Runner:
+    def __init__(self, cwd):
+        self.cwd = cwd
+
+    def __call__(self, *args, **kwargs):
+        kwargs['cwd'] = kwargs.get('cwd', self.cwd)
+        check_call(args, **kwargs)
+
+
+def create_build_env():
+    """Create a build environment."""
+    class Env:
+        pass
+    env = Env()
+
+    # Import the documentation build module.
+    env.fmt_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    sys.path.insert(0, os.path.join(env.fmt_dir, 'doc'))
+    import build
+
+    env.build_dir = 'build'
+    env.versions = build.versions
+
+    # Virtualenv and repos are cached to speed up builds.
+    build.create_build_env(os.path.join(env.build_dir, 'virtualenv'))
+
+    env.fmt_repo = Git(os.path.join(env.build_dir, 'fmt'))
+    return env
+
+
+@contextmanager
+def rewrite(filename):
+    class Buffer:
+        pass
+    buffer = Buffer()
+    if not os.path.exists(filename):
+        buffer.data = ''
+        yield buffer
+        return
+    with open(filename) as f:
+        buffer.data = f.read()
+    yield buffer
+    with open(filename, 'w') as f:
+        f.write(buffer.data)
+
+
+fmt_repo_url = 'git@github.com:fmtlib/fmt'
+
+
+def update_site(env):
+    env.fmt_repo.update(fmt_repo_url)
+
+    doc_repo = Git(os.path.join(env.build_dir, 'fmtlib.github.io'))
+    doc_repo.update('git@github.com:fmtlib/fmtlib.github.io')
+
+    for version in env.versions:
+        clean_checkout(env.fmt_repo, version)
+        target_doc_dir = os.path.join(env.fmt_repo.dir, 'doc')
+        # Remove the old theme.
+        for entry in os.listdir(target_doc_dir):
+            path = os.path.join(target_doc_dir, entry)
+            if os.path.isdir(path):
+                shutil.rmtree(path)
+        # Copy the new theme.
+        for entry in ['_static', '_templates', 'basic-bootstrap', 'bootstrap',
+                      'conf.py', 'fmt.less']:
+            src = os.path.join(env.fmt_dir, 'doc', entry)
+            dst = os.path.join(target_doc_dir, entry)
+            copy = shutil.copytree if os.path.isdir(src) else shutil.copyfile
+            copy(src, dst)
+        # Rename index to contents.
+        contents = os.path.join(target_doc_dir, 'contents.rst')
+        if not os.path.exists(contents):
+            os.rename(os.path.join(target_doc_dir, 'index.rst'), contents)
+        # Fix issues in reference.rst/api.rst.
+        for filename in ['reference.rst', 'api.rst', 'index.rst']:
+            pattern = re.compile('doxygenfunction.. (bin|oct|hexu|hex)$', re.M)
+            with rewrite(os.path.join(target_doc_dir, filename)) as b:
+                b.data = b.data.replace('std::ostream &', 'std::ostream&')
+                b.data = re.sub(pattern, r'doxygenfunction:: \1(int)', b.data)
+                b.data = b.data.replace('std::FILE*', 'std::FILE *')
+                b.data = b.data.replace('unsigned int', 'unsigned')
+                #b.data = b.data.replace('operator""_', 'operator"" _')
+                b.data = b.data.replace(
+                    'format_to_n(OutputIt, size_t, string_view, Args&&',
+                    'format_to_n(OutputIt, size_t, const S&, const Args&')
+                b.data = b.data.replace(
+                    'format_to_n(OutputIt, std::size_t, string_view, Args&&',
+                    'format_to_n(OutputIt, std::size_t, const S&, const Args&')
+                if version == ('3.0.2'):
+                    b.data = b.data.replace(
+                        'fprintf(std::ostream&', 'fprintf(std::ostream &')
+                if version == ('5.3.0'):
+                    b.data = b.data.replace(
+                        'format_to(OutputIt, const S&, const Args&...)',
+                        'format_to(OutputIt, const S &, const Args &...)')
+                if version.startswith('5.') or version.startswith('6.'):
+                    b.data = b.data.replace(', size_t', ', std::size_t')
+                if version.startswith('7.'):
+                    b.data = b.data.replace(', std::size_t', ', size_t')
+                    b.data = b.data.replace('join(It, It', 'join(It, Sentinel')
+                if version.startswith('7.1.'):
+                    b.data = b.data.replace(', std::size_t', ', size_t')
+                    b.data = b.data.replace('join(It, It', 'join(It, Sentinel')
+                    b.data = b.data.replace(
+                        'fmt::format_to(OutputIt, const S&, Args&&...)',
+                        'fmt::format_to(OutputIt, const S&, Args&&...) -> ' +
+                        'typename std::enable_if<enable, OutputIt>::type')
+                b.data = b.data.replace('aa long', 'a long')
+                b.data = b.data.replace('serveral', 'several')
+                if version.startswith('6.2.'):
+                    b.data = b.data.replace(
+                        'vformat(const S&, basic_format_args<' +
+                        'buffer_context<Char>>)',
+                        'vformat(const S&, basic_format_args<' +
+                        'buffer_context<type_identity_t<Char>>>)')
+        # Fix a broken link in index.rst.
+        index = os.path.join(target_doc_dir, 'index.rst')
+        with rewrite(index) as b:
+            b.data = b.data.replace(
+                'doc/latest/index.html#format-string-syntax', 'syntax.html')
+        # Fix issues in syntax.rst.
+        index = os.path.join(target_doc_dir, 'syntax.rst')
+        with rewrite(index) as b:
+            b.data = b.data.replace(
+                '..productionlist:: sf\n', '.. productionlist:: sf\n ')
+            b.data = b.data.replace('Examples:\n', 'Examples::\n')
+        # Build the docs.
+        html_dir = os.path.join(env.build_dir, 'html')
+        if os.path.exists(html_dir):
+            shutil.rmtree(html_dir)
+        include_dir = env.fmt_repo.dir
+        if LooseVersion(version) >= LooseVersion('5.0.0'):
+            include_dir = os.path.join(include_dir, 'include', 'fmt')
+        elif LooseVersion(version) >= LooseVersion('3.0.0'):
+            include_dir = os.path.join(include_dir, 'fmt')
+        import build
+        build.build_docs(version, doc_dir=target_doc_dir,
+                         include_dir=include_dir, work_dir=env.build_dir)
+        shutil.rmtree(os.path.join(html_dir, '.doctrees'))
+        # Create symlinks for older versions.
+        for link, target in {'index': 'contents', 'api': 'reference'}.items():
+            link = os.path.join(html_dir, link) + '.html'
+            target += '.html'
+            if os.path.exists(os.path.join(html_dir, target)) and \
+               not os.path.exists(link):
+                os.symlink(target, link)
+        # Copy docs to the website.
+        version_doc_dir = os.path.join(doc_repo.dir, version)
+        try:
+            shutil.rmtree(version_doc_dir)
+        except OSError as e:
+            if e.errno != errno.ENOENT:
+                raise
+        shutil.move(html_dir, version_doc_dir)
+
+
+def release(args):
+    env = create_build_env()
+    fmt_repo = env.fmt_repo
+
+    branch = args.get('<branch>')
+    if branch is None:
+        branch = 'master'
+    if not fmt_repo.update('-b', branch, fmt_repo_url):
+        clean_checkout(fmt_repo, branch)
+
+    # Update the date in the changelog and extract the version and the first
+    # section content.
+    changelog = 'ChangeLog.md'
+    changelog_path = os.path.join(fmt_repo.dir, changelog)
+    is_first_section = True
+    first_section = []
+    for i, line in enumerate(fileinput.input(changelog_path, inplace=True)):
+        if i == 0:
+            version = re.match(r'# (.*) - TBD', line).group(1)
+            line = '# {} - {}\n'.format(
+                version, datetime.date.today().isoformat())
+        elif not is_first_section:
+            pass
+        elif line.startswith('#'):
+            is_first_section = False
+        else:
+            first_section.append(line)
+        sys.stdout.write(line)
+    if first_section[0] == '\n':
+        first_section.pop(0)
+
+    changes = ''
+    code_block = False
+    stripped = False
+    for line in first_section:
+        if re.match(r'^\s*```', line):
+            code_block = not code_block
+            changes += line
+            stripped = False
+            continue
+        if code_block:
+            changes += line
+            continue
+        if line == '\n':
+            changes += line
+            if stripped:
+                changes += line
+                stripped = False
+            continue
+        if stripped:
+            line = ' ' + line.lstrip()
+        changes += line.rstrip()
+        stripped = True
+
+    cmakelists = 'CMakeLists.txt'
+    for line in fileinput.input(os.path.join(fmt_repo.dir, cmakelists),
+                                inplace=True):
+        prefix = 'set(FMT_VERSION '
+        if line.startswith(prefix):
+            line = prefix + version + ')\n'
+        sys.stdout.write(line)
+
+    # Add the version to the build script.
+    script = os.path.join('doc', 'build.py')
+    script_path = os.path.join(fmt_repo.dir, script)
+    for line in fileinput.input(script_path, inplace=True):
+      m = re.match(r'( *versions \+= )\[(.+)\]', line)
+      if m:
+        line = '{}[{}, \'{}\']\n'.format(m.group(1), m.group(2), version)
+      sys.stdout.write(line)
+
+    fmt_repo.checkout('-B', 'release')
+    fmt_repo.add(changelog, cmakelists, script)
+    fmt_repo.commit('-m', 'Update version')
+
+    # Build the docs and package.
+    run = Runner(fmt_repo.dir)
+    run('cmake', '.')
+    run('make', 'doc', 'package_source')
+    update_site(env)
+
+    # Create a release on GitHub.
+    fmt_repo.push('origin', 'release')
+    auth_headers = {'Authorization': 'token ' + os.getenv('FMT_TOKEN')}
+    r = requests.post('https://api.github.com/repos/fmtlib/fmt/releases',
+                      headers=auth_headers,
+                      data=json.dumps({'tag_name': version,
+                                       'target_commitish': 'release',
+                                       'body': changes, 'draft': True}))
+    if r.status_code != 201:
+        raise Exception('Failed to create a release ' + str(r))
+    id = r.json()['id']
+    uploads_url = 'https://uploads.github.com/repos/fmtlib/fmt/releases'
+    package = 'fmt-{}.zip'.format(version)
+    r = requests.post(
+        '{}/{}/assets?name={}'.format(uploads_url, id, package),
+        headers={'Content-Type': 'application/zip'} | auth_headers,
+        data=open('build/fmt/' + package, 'rb'))
+    if r.status_code != 201:
+        raise Exception('Failed to upload an asset ' + str(r))
+
+
+if __name__ == '__main__':
+    args = docopt.docopt(__doc__)
+    if args.get('release'):
+        release(args)
+    elif args.get('site'):
+        update_site(create_build_env())
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/printable.py b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/printable.py
new file mode 100644
index 0000000000000000000000000000000000000000..8fa86b30017a7b055adc9b44ddf7c372493967e9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/printable.py
@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+
+# This script is based on
+# https://github.com/rust-lang/rust/blob/master/library/core/src/unicode/printable.py
+# distributed under https://github.com/rust-lang/rust/blob/master/LICENSE-MIT.
+
+# This script uses the following Unicode tables:
+# - UnicodeData.txt
+
+
+from collections import namedtuple
+import csv
+import os
+import subprocess
+
+NUM_CODEPOINTS=0x110000
+
+def to_ranges(iter):
+    current = None
+    for i in iter:
+        if current is None or i != current[1] or i in (0x10000, 0x20000):
+            if current is not None:
+                yield tuple(current)
+            current = [i, i + 1]
+        else:
+            current[1] += 1
+    if current is not None:
+        yield tuple(current)
+
+def get_escaped(codepoints):
+    for c in codepoints:
+        if (c.class_ or "Cn") in "Cc Cf Cs Co Cn Zl Zp Zs".split() and c.value != ord(' '):
+            yield c.value
+
+def get_file(f):
+    try:
+        return open(os.path.basename(f))
+    except FileNotFoundError:
+        subprocess.run(["curl", "-O", f], check=True)
+        return open(os.path.basename(f))
+
+Codepoint = namedtuple('Codepoint', 'value class_')
+
+def get_codepoints(f):
+    r = csv.reader(f, delimiter=";")
+    prev_codepoint = 0
+    class_first = None
+    for row in r:
+        codepoint = int(row[0], 16)
+        name = row[1]
+        class_ = row[2]
+
+        if class_first is not None:
+            if not name.endswith("Last>"):
+                raise ValueError("Missing Last after First")
+
+        for c in range(prev_codepoint + 1, codepoint):
+            yield Codepoint(c, class_first)
+
+        class_first = None
+        if name.endswith("First>"):
+            class_first = class_
+
+        yield Codepoint(codepoint, class_)
+        prev_codepoint = codepoint
+
+    if class_first is not None:
+        raise ValueError("Missing Last after First")
+
+    for c in range(prev_codepoint + 1, NUM_CODEPOINTS):
+        yield Codepoint(c, None)
+
+def compress_singletons(singletons):
+    uppers = [] # (upper, # items in lowers)
+    lowers = []
+
+    for i in singletons:
+        upper = i >> 8
+        lower = i & 0xff
+        if len(uppers) == 0 or uppers[-1][0] != upper:
+            uppers.append((upper, 1))
+        else:
+            upper, count = uppers[-1]
+            uppers[-1] = upper, count + 1
+        lowers.append(lower)
+
+    return uppers, lowers
+
+def compress_normal(normal):
+    # lengths 0x00..0x7f are encoded as 00, 01, ..., 7e, 7f
+    # lengths 0x80..0x7fff are encoded as 80 80, 80 81, ..., ff fe, ff ff
+    compressed = [] # [truelen, (truelenaux), falselen, (falselenaux)]
+
+    prev_start = 0
+    for start, count in normal:
+        truelen = start - prev_start
+        falselen = count
+        prev_start = start + count
+
+        assert truelen < 0x8000 and falselen < 0x8000
+        entry = []
+        if truelen > 0x7f:
+            entry.append(0x80 | (truelen >> 8))
+            entry.append(truelen & 0xff)
+        else:
+            entry.append(truelen & 0x7f)
+        if falselen > 0x7f:
+            entry.append(0x80 | (falselen >> 8))
+            entry.append(falselen & 0xff)
+        else:
+            entry.append(falselen & 0x7f)
+
+        compressed.append(entry)
+
+    return compressed
+
+def print_singletons(uppers, lowers, uppersname, lowersname):
+    print("  static constexpr singleton {}[] = {{".format(uppersname))
+    for u, c in uppers:
+        print("    {{{:#04x}, {}}},".format(u, c))
+    print("  };")
+    print("  static constexpr unsigned char {}[] = {{".format(lowersname))
+    for i in range(0, len(lowers), 8):
+        print("    {}".format(" ".join("{:#04x},".format(l) for l in lowers[i:i+8])))
+    print("  };")
+
+def print_normal(normal, normalname):
+    print("  static constexpr unsigned char {}[] = {{".format(normalname))
+    for v in normal:
+        print("    {}".format(" ".join("{:#04x},".format(i) for i in v)))
+    print("  };")
+
+def main():
+    file = get_file("https://www.unicode.org/Public/UNIDATA/UnicodeData.txt")
+
+    codepoints = get_codepoints(file)
+
+    CUTOFF=0x10000
+    singletons0 = []
+    singletons1 = []
+    normal0 = []
+    normal1 = []
+    extra = []
+
+    for a, b in to_ranges(get_escaped(codepoints)):
+        if a > 2 * CUTOFF:
+            extra.append((a, b - a))
+        elif a == b - 1:
+            if a & CUTOFF:
+                singletons1.append(a & ~CUTOFF)
+            else:
+                singletons0.append(a)
+        elif a == b - 2:
+            if a & CUTOFF:
+                singletons1.append(a & ~CUTOFF)
+                singletons1.append((a + 1) & ~CUTOFF)
+            else:
+                singletons0.append(a)
+                singletons0.append(a + 1)
+        else:
+            if a >= 2 * CUTOFF:
+                extra.append((a, b - a))
+            elif a & CUTOFF:
+                normal1.append((a & ~CUTOFF, b - a))
+            else:
+                normal0.append((a, b - a))
+
+    singletons0u, singletons0l = compress_singletons(singletons0)
+    singletons1u, singletons1l = compress_singletons(singletons1)
+    normal0 = compress_normal(normal0)
+    normal1 = compress_normal(normal1)
+
+    print("""\
+FMT_FUNC auto is_printable(uint32_t cp) -> bool {\
+""")
+    print_singletons(singletons0u, singletons0l, 'singletons0', 'singletons0_lower')
+    print_singletons(singletons1u, singletons1l, 'singletons1', 'singletons1_lower')
+    print_normal(normal0, 'normal0')
+    print_normal(normal1, 'normal1')
+    print("""\
+  auto lower = static_cast<uint16_t>(cp);
+  if (cp < 0x10000) {
+    return is_printable(lower, singletons0,
+                        sizeof(singletons0) / sizeof(*singletons0),
+                        singletons0_lower, normal0, sizeof(normal0));
+  }
+  if (cp < 0x20000) {
+    return is_printable(lower, singletons1,
+                        sizeof(singletons1) / sizeof(*singletons1),
+                        singletons1_lower, normal1, sizeof(normal1));
+  }\
+""")
+    for a, b in extra:
+        print("  if (0x{:x} <= cp && cp < 0x{:x}) return false;".format(a, a + b))
+    print("""\
+  return cp < 0x{:x};
+}}\
+""".format(NUM_CODEPOINTS))
+
+if __name__ == '__main__':
+    main()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/rtd/conf.py b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/rtd/conf.py
new file mode 100644
index 0000000000000000000000000000000000000000..124fb9d4c84c3a15623552056a2adafdfffe46b7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/rtd/conf.py
@@ -0,0 +1,7 @@
+# Sphinx configuration for readthedocs.
+
+import os, sys
+
+master_doc = 'index'
+html_theme = 'theme'
+html_theme_path = ["."]
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/rtd/index.rst b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/rtd/index.rst
new file mode 100644
index 0000000000000000000000000000000000000000..7c88322f6246a9f66b9ade5f62d70e76bbf0d347
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/rtd/index.rst
@@ -0,0 +1,2 @@
+If you are not redirected automatically, follow the
+`link to the fmt documentation <https://fmt.dev/latest/>`_.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/rtd/theme/layout.html b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/rtd/theme/layout.html
new file mode 100644
index 0000000000000000000000000000000000000000..29ebc55bb42e51977b1aba567d629efafcfa2eae
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/rtd/theme/layout.html
@@ -0,0 +1,17 @@
+{% extends "basic/layout.html" %}
+
+{% block extrahead %}
+<meta charset="UTF-8">
+<meta http-equiv="refresh" content="1;url=https://fmt.dev/latest/">
+<script type="text/javascript">
+    window.location.href = "https://fmt.dev/latest/"
+</script>
+<title>Page Redirection</title>
+{% endblock %}
+
+{% block document %}
+If you are not redirected automatically, follow the <a href='https://fmt.dev/latest/'>link to the fmt documentation</a>.
+{% endblock %}
+
+{% block footer %}
+{% endblock %}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/rtd/theme/theme.conf b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/rtd/theme/theme.conf
new file mode 100644
index 0000000000000000000000000000000000000000..89e03bbdac5e2ff5c08eb4bc4918067516932c5c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/support/rtd/theme/theme.conf
@@ -0,0 +1,2 @@
+[theme]
+inherit = basic
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ec97ac29a724e987318141fd75fc345a90021722
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/CMakeLists.txt
@@ -0,0 +1,262 @@
+add_subdirectory(gtest)
+
+include(CheckSymbolExists)
+
+set(TEST_MAIN_SRC test-main.cc gtest-extra.cc gtest-extra.h util.cc)
+add_library(test-main STATIC ${TEST_MAIN_SRC})
+target_include_directories(test-main PUBLIC
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
+target_link_libraries(test-main gtest fmt)
+
+function(add_fmt_executable name)
+  add_executable(${name} ${ARGN})
+  # (Wstringop-overflow) - [meta-bug] bogus/missing -Wstringop-overflow warnings
+  #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=88443
+  # Bogus -Wstringop-overflow warning
+  #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100395
+  # [10 Regression] spurious -Wstringop-overflow writing to a trailing array plus offset
+  #   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=95353
+  if (CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND
+      NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0)
+    target_compile_options(${name} PRIVATE -Wno-stringop-overflow)
+    # The linker flag is needed for LTO.
+    target_link_libraries(${name} -Wno-stringop-overflow)
+  endif ()
+endfunction()
+
+# Adds a test.
+# Usage: add_fmt_test(name srcs...)
+function(add_fmt_test name)
+  cmake_parse_arguments(ADD_FMT_TEST "HEADER_ONLY;MODULE" "" "" ${ARGN})
+
+  set(sources ${name}.cc ${ADD_FMT_TEST_UNPARSED_ARGUMENTS})
+  if (ADD_FMT_TEST_HEADER_ONLY)
+    set(sources ${sources} ${TEST_MAIN_SRC} ../src/os.cc)
+    set(libs gtest fmt-header-only)
+    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wno-weak-vtables)
+    endif ()
+  elseif (ADD_FMT_TEST_MODULE)
+    set(libs test-main test-module)
+    set_source_files_properties(${name}.cc PROPERTIES OBJECT_DEPENDS test-module)
+  else ()
+    set(libs test-main fmt)
+  endif ()
+  add_fmt_executable(${name} ${sources})
+  target_link_libraries(${name} ${libs})
+
+  # Define if certain C++ features can be used.
+  if (FMT_PEDANTIC)
+    target_compile_options(${name} PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+  endif ()
+  if (FMT_WERROR)
+    target_compile_options(${name} PRIVATE ${WERROR_FLAG})
+  endif ()
+  add_test(NAME ${name} COMMAND ${name})
+endfunction()
+
+if (FMT_MODULE)
+  return ()
+endif ()
+
+add_fmt_test(args-test)
+add_fmt_test(assert-test)
+add_fmt_test(chrono-test)
+add_fmt_test(color-test)
+add_fmt_test(core-test)
+add_fmt_test(gtest-extra-test)
+add_fmt_test(format-test mock-allocator.h)
+if (MSVC)
+  target_compile_options(format-test PRIVATE /bigobj)
+endif ()
+if (NOT (MSVC AND BUILD_SHARED_LIBS))
+  add_fmt_test(format-impl-test HEADER_ONLY header-only-test.cc)
+endif ()
+add_fmt_test(ostream-test)
+add_fmt_test(compile-test)
+add_fmt_test(compile-fp-test HEADER_ONLY)
+if (MSVC)
+  # Without this option, MSVC returns 199711L for the __cplusplus macro.
+  target_compile_options(compile-fp-test PRIVATE /Zc:__cplusplus)
+endif()
+add_fmt_test(printf-test)
+add_fmt_test(ranges-test ranges-odr-test.cc)
+
+add_fmt_test(scan-test)
+check_symbol_exists(strptime "time.h" HAVE_STRPTIME)
+if (HAVE_STRPTIME)
+  target_compile_definitions(scan-test PRIVATE FMT_HAVE_STRPTIME)
+endif ()
+
+add_fmt_test(std-test)
+try_compile(compile_result_unused
+            ${CMAKE_CURRENT_BINARY_DIR}
+            SOURCES ${CMAKE_CURRENT_LIST_DIR}/detect-stdfs.cc
+            OUTPUT_VARIABLE RAWOUTPUT)
+string(REGEX REPLACE ".*libfound \"([^\"]*)\".*" "\\1" STDLIBFS "${RAWOUTPUT}")
+if (STDLIBFS)
+  target_link_libraries(std-test ${STDLIBFS})
+endif ()
+add_fmt_test(unicode-test HEADER_ONLY)
+if (MSVC)
+  target_compile_options(unicode-test PRIVATE /utf-8)
+endif ()
+add_fmt_test(xchar-test)
+add_fmt_test(enforce-checks-test)
+target_compile_definitions(enforce-checks-test PRIVATE
+                           -DFMT_ENFORCE_COMPILE_STRING)
+
+if (FMT_MODULE)
+  # The tests need {fmt} to be compiled as traditional library
+  # because of visibility of implementation details.
+  # If module support is present the module tests require a
+  # test-only module to be built from {fmt}
+  add_library(test-module OBJECT ${CMAKE_SOURCE_DIR}/src/fmt.cc)
+  target_compile_features(test-module PUBLIC cxx_std_11)
+  target_include_directories(test-module PUBLIC
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>)
+  enable_module(test-module)
+
+  add_fmt_test(module-test MODULE test-main.cc)
+  if (MSVC)
+    target_compile_options(test-module PRIVATE /utf-8 /Zc:__cplusplus
+                           /Zc:externConstexpr /Zc:inline)
+    target_compile_options(module-test PRIVATE /utf-8 /Zc:__cplusplus
+                           /Zc:externConstexpr /Zc:inline)
+  endif ()
+endif ()
+
+if (NOT DEFINED MSVC_STATIC_RUNTIME AND MSVC)
+  foreach (flag_var
+			 CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+			 CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+	if (${flag_var} MATCHES "^(/|-)(MT|MTd)")
+	  set(MSVC_STATIC_RUNTIME ON)
+	  break()
+	endif()
+  endforeach()
+endif()
+
+if (NOT MSVC_STATIC_RUNTIME)
+  add_fmt_executable(posix-mock-test
+    posix-mock-test.cc ../src/format.cc ${TEST_MAIN_SRC})
+  target_include_directories(
+    posix-mock-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
+  target_link_libraries(posix-mock-test gtest)
+  if (FMT_PEDANTIC)
+    target_compile_options(posix-mock-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+  endif ()
+  add_test(NAME posix-mock-test COMMAND posix-mock-test)
+  add_fmt_test(os-test)
+endif ()
+
+message(STATUS "FMT_PEDANTIC: ${FMT_PEDANTIC}")
+
+if (FMT_PEDANTIC)
+  # Test that the library can be compiled with exceptions disabled.
+  # -fno-exception is broken in icc: https://github.com/fmtlib/fmt/issues/822.
+  if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+    check_cxx_compiler_flag(-fno-exceptions HAVE_FNO_EXCEPTIONS_FLAG)
+  endif ()
+  if (HAVE_FNO_EXCEPTIONS_FLAG)
+    add_library(noexception-test ../src/format.cc noexception-test.cc)
+    target_include_directories(
+      noexception-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
+    target_compile_options(noexception-test PRIVATE -fno-exceptions)
+    target_compile_options(noexception-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+  endif ()
+
+  # Test that the library compiles without locale.
+  add_library(nolocale-test ../src/format.cc)
+  target_include_directories(
+    nolocale-test PRIVATE ${PROJECT_SOURCE_DIR}/include)
+  target_compile_definitions(
+    nolocale-test PRIVATE FMT_STATIC_THOUSANDS_SEPARATOR=1)
+endif ()
+
+# These tests are disabled on Windows because they take too long.
+# They are disabled on GCC < 4.9 because it can not parse UDLs without
+# a space after `operator""` but that is an incorrect syntax for any more
+# modern compiler.
+if (FMT_PEDANTIC AND NOT WIN32 AND NOT (
+    CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND
+    CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9))
+  # Test if incorrect API usages produce compilation error.
+  add_test(compile-error-test ${CMAKE_CTEST_COMMAND}
+    --build-and-test
+    "${CMAKE_CURRENT_SOURCE_DIR}/compile-error-test"
+    "${CMAKE_CURRENT_BINARY_DIR}/compile-error-test"
+    --build-generator ${CMAKE_GENERATOR}
+    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    --build-options
+    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+    "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
+    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
+    "-DCXX_STANDARD_FLAG=${CXX_STANDARD_FLAG}"
+    "-DFMT_DIR=${CMAKE_SOURCE_DIR}")
+
+  # Test if the targets are found from the build directory.
+  add_test(find-package-test ${CMAKE_CTEST_COMMAND}
+    -C ${CMAKE_BUILD_TYPE}
+    --build-and-test
+    "${CMAKE_CURRENT_SOURCE_DIR}/find-package-test"
+    "${CMAKE_CURRENT_BINARY_DIR}/find-package-test"
+    --build-generator ${CMAKE_GENERATOR}
+    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    --build-options
+    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+    "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
+    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
+    "-DFMT_DIR=${PROJECT_BINARY_DIR}"
+    "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}"
+    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+
+  # Test if the targets are found when add_subdirectory is used.
+  add_test(add-subdirectory-test ${CMAKE_CTEST_COMMAND}
+    -C ${CMAKE_BUILD_TYPE}
+    --build-and-test
+    "${CMAKE_CURRENT_SOURCE_DIR}/add-subdirectory-test"
+    "${CMAKE_CURRENT_BINARY_DIR}/add-subdirectory-test"
+    --build-generator ${CMAKE_GENERATOR}
+    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    --build-options
+    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
+    "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}"
+    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+endif ()
+
+# This test are disabled on Windows because it is only *NIX issue.
+if (FMT_PEDANTIC AND NOT WIN32)
+  add_test(static-export-test ${CMAKE_CTEST_COMMAND}
+    -C ${CMAKE_BUILD_TYPE}
+    --build-and-test
+    "${CMAKE_CURRENT_SOURCE_DIR}/static-export-test"
+    "${CMAKE_CURRENT_BINARY_DIR}/static-export-test"
+    --build-generator ${CMAKE_GENERATOR}
+    --build-makeprogram ${CMAKE_MAKE_PROGRAM}
+    --build-options
+    "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+    "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
+    "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}")
+endif ()
+
+# Activate optional CUDA tests if CUDA is found. For version selection see
+# https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#cpp14-language-features
+if (FMT_CUDA_TEST)
+  if (${CMAKE_VERSION} VERSION_LESS 3.15)
+    find_package(CUDA 9.0)
+  else ()
+    include(CheckLanguage)
+    check_language(CUDA)
+    if (CMAKE_CUDA_COMPILER)
+      enable_language(CUDA OPTIONAL)
+      set(CUDA_FOUND TRUE)
+    endif ()
+  endif ()
+
+  if (CUDA_FOUND)
+    add_subdirectory(cuda-test)
+    add_test(NAME cuda-test COMMAND fmt-in-cuda-test)
+  endif ()
+endif ()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/add-subdirectory-test/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/add-subdirectory-test/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..362b0494502f93f34a424e03910e4b7a23ded142
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/add-subdirectory-test/CMakeLists.txt
@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.8...3.25)
+
+project(fmt-test CXX)
+
+add_subdirectory(../.. fmt)
+
+add_executable(library-test main.cc)
+target_include_directories(library-test PUBLIC SYSTEM .)
+target_compile_options(library-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+target_link_libraries(library-test fmt::fmt)
+
+if (TARGET fmt::fmt-header-only)
+  add_executable(header-only-test main.cc)
+  target_include_directories(header-only-test PUBLIC SYSTEM .)
+  target_compile_options(header-only-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+  target_link_libraries(header-only-test fmt::fmt-header-only)
+endif ()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/add-subdirectory-test/main.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/add-subdirectory-test/main.cc
new file mode 100644
index 0000000000000000000000000000000000000000..fcdf232e05e30746918561ea8d501f17a7d1bbbd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/add-subdirectory-test/main.cc
@@ -0,0 +1,5 @@
+#include "fmt/core.h"
+
+int main(int argc, char** argv) {
+  for (int i = 0; i < argc; ++i) fmt::print("{}: {}\n", i, argv[i]);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/args-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/args-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3ab31335986091be1f6714c332e6f328fd01da39
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/args-test.cc
@@ -0,0 +1,186 @@
+// Formatting library for C++ - dynamic argument store tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/args.h"
+
+#include <memory>
+
+#include "gtest/gtest.h"
+
+TEST(args_test, basic) {
+  fmt::dynamic_format_arg_store<fmt::format_context> store;
+  store.push_back(42);
+  store.push_back("abc1");
+  store.push_back(1.5f);
+  EXPECT_EQ("42 and abc1 and 1.5", fmt::vformat("{} and {} and {}", store));
+}
+
+TEST(args_test, strings_and_refs) {
+  // Unfortunately the tests are compiled with old ABI so strings use COW.
+  fmt::dynamic_format_arg_store<fmt::format_context> store;
+  char str[] = "1234567890";
+  store.push_back(str);
+  store.push_back(std::cref(str));
+  store.push_back(fmt::string_view{str});
+  str[0] = 'X';
+
+  auto result = fmt::vformat("{} and {} and {}", store);
+  EXPECT_EQ("1234567890 and X234567890 and X234567890", result);
+}
+
+struct custom_type {
+  int i = 0;
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<custom_type> {
+  auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const custom_type& p, FormatContext& ctx) -> decltype(ctx.out()) {
+    return fmt::format_to(ctx.out(), "cust={}", p.i);
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(args_test, custom_format) {
+  fmt::dynamic_format_arg_store<fmt::format_context> store;
+  auto c = custom_type();
+  store.push_back(c);
+  ++c.i;
+  store.push_back(c);
+  ++c.i;
+  store.push_back(std::cref(c));
+  ++c.i;
+  auto result = fmt::vformat("{} and {} and {}", store);
+  EXPECT_EQ("cust=0 and cust=1 and cust=3", result);
+}
+
+struct to_stringable {
+  friend fmt::string_view to_string_view(to_stringable) { return {}; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<to_stringable> {
+  auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  auto format(to_stringable, format_context& ctx) -> decltype(ctx.out()) {
+    return ctx.out();
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(args_test, to_string_and_formatter) {
+  fmt::dynamic_format_arg_store<fmt::format_context> store;
+  auto s = to_stringable();
+  store.push_back(s);
+  store.push_back(std::cref(s));
+  fmt::vformat("", store);
+}
+
+TEST(args_test, named_int) {
+  fmt::dynamic_format_arg_store<fmt::format_context> store;
+  store.push_back(fmt::arg("a1", 42));
+  EXPECT_EQ("42", fmt::vformat("{a1}", store));
+}
+
+TEST(args_test, named_strings) {
+  fmt::dynamic_format_arg_store<fmt::format_context> store;
+  char str[] = "1234567890";
+  store.push_back(fmt::arg("a1", str));
+  store.push_back(fmt::arg("a2", std::cref(str)));
+  str[0] = 'X';
+  EXPECT_EQ("1234567890 and X234567890", fmt::vformat("{a1} and {a2}", store));
+}
+
+TEST(args_test, named_arg_by_ref) {
+  fmt::dynamic_format_arg_store<fmt::format_context> store;
+  char band[] = "Rolling Stones";
+  store.push_back(fmt::arg("band", std::cref(band)));
+  band[9] = 'c';  // Changing band affects the output.
+  EXPECT_EQ(fmt::vformat("{band}", store), "Rolling Scones");
+}
+
+TEST(args_test, named_custom_format) {
+  fmt::dynamic_format_arg_store<fmt::format_context> store;
+  auto c = custom_type();
+  store.push_back(fmt::arg("c1", c));
+  ++c.i;
+  store.push_back(fmt::arg("c2", c));
+  ++c.i;
+  store.push_back(fmt::arg("c_ref", std::cref(c)));
+  ++c.i;
+  auto result = fmt::vformat("{c1} and {c2} and {c_ref}", store);
+  EXPECT_EQ("cust=0 and cust=1 and cust=3", result);
+}
+
+TEST(args_test, clear) {
+  fmt::dynamic_format_arg_store<fmt::format_context> store;
+  store.push_back(42);
+
+  auto result = fmt::vformat("{}", store);
+  EXPECT_EQ("42", result);
+
+  store.push_back(43);
+  result = fmt::vformat("{} and {}", store);
+  EXPECT_EQ("42 and 43", result);
+
+  store.clear();
+  store.push_back(44);
+  result = fmt::vformat("{}", store);
+  EXPECT_EQ("44", result);
+}
+
+TEST(args_test, reserve) {
+  fmt::dynamic_format_arg_store<fmt::format_context> store;
+  store.reserve(2, 1);
+  store.push_back(1.5f);
+  store.push_back(fmt::arg("a1", 42));
+  auto result = fmt::vformat("{a1} and {}", store);
+  EXPECT_EQ("42 and 1.5", result);
+}
+
+struct copy_throwable {
+  copy_throwable() {}
+  copy_throwable(const copy_throwable&) { throw "deal with it"; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<copy_throwable> {
+  auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+  auto format(copy_throwable, format_context& ctx) -> decltype(ctx.out()) {
+    return ctx.out();
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(args_test, throw_on_copy) {
+  fmt::dynamic_format_arg_store<fmt::format_context> store;
+  store.push_back(std::string("foo"));
+  try {
+    store.push_back(copy_throwable());
+  } catch (...) {
+  }
+  EXPECT_EQ(fmt::vformat("{}", store), "foo");
+}
+
+TEST(args_test, move_constructor) {
+  using store_type = fmt::dynamic_format_arg_store<fmt::format_context>;
+  auto store = std::unique_ptr<store_type>(new store_type());
+  store->push_back(42);
+  store->push_back(std::string("foo"));
+  store->push_back(fmt::arg("a1", "foo"));
+  auto moved_store = std::move(*store);
+  store.reset();
+  EXPECT_EQ(fmt::vformat("{} {} {a1}", moved_store), "42 foo foo");
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/assert-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/assert-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c74e617e68f35024919149826a011916a827cd46
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/assert-test.cc
@@ -0,0 +1,31 @@
+// Formatting library for C++ - FMT_ASSERT test
+//
+// It is a separate test to minimize the number of EXPECT_DEBUG_DEATH checks
+// which are slow on some platforms. In other tests FMT_ASSERT is made to throw
+// an exception which is much faster and easier to check.
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/core.h"
+#include "gtest/gtest.h"
+
+TEST(assert_test, fail) {
+#if GTEST_HAS_DEATH_TEST
+  EXPECT_DEBUG_DEATH(FMT_ASSERT(false, "don't panic!"), "don't panic!");
+#else
+  fmt::print("warning: death tests are not supported\n");
+#endif
+}
+
+TEST(assert_test, dangling_else) {
+  bool test_condition = false;
+  bool executed_else = false;
+  if (test_condition)
+    FMT_ASSERT(true, "");
+  else
+    executed_else = true;
+  EXPECT_TRUE(executed_else);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/chrono-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/chrono-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b2d03f979578e80353f6dbf5c8697631d8f3d68e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/chrono-test.cc
@@ -0,0 +1,999 @@
+// Formatting library for C++ - time formatting tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/chrono.h"
+
+#include <algorithm>
+#include <ctime>
+#include <vector>
+
+#include "gtest-extra.h"  // EXPECT_THROW_MSG
+#include "util.h"         // get_locale
+
+using fmt::runtime;
+using testing::Contains;
+
+template <typename Duration>
+using sys_time = std::chrono::time_point<std::chrono::system_clock, Duration>;
+
+#if defined(__MINGW32__) && !defined(_UCRT)
+// Only C89 conversion specifiers when using MSVCRT instead of UCRT
+#  define FMT_HAS_C99_STRFTIME 0
+#else
+#  define FMT_HAS_C99_STRFTIME 1
+#endif
+
+#if defined(__cpp_lib_chrono) && __cpp_lib_chrono >= 201907L
+using days = std::chrono::days;
+#else
+using days = std::chrono::duration<std::chrono::hours::rep, std::ratio<86400>>;
+#endif
+
+auto make_tm() -> std::tm {
+  auto time = std::tm();
+  time.tm_mday = 1;
+  return time;
+}
+
+auto make_hour(int h) -> std::tm {
+  auto time = make_tm();
+  time.tm_hour = h;
+  return time;
+}
+
+auto make_minute(int m) -> std::tm {
+  auto time = make_tm();
+  time.tm_min = m;
+  return time;
+}
+
+auto make_second(int s) -> std::tm {
+  auto time = make_tm();
+  time.tm_sec = s;
+  return time;
+}
+
+std::string system_strftime(const std::string& format, const std::tm* timeptr,
+                            std::locale* locptr = nullptr) {
+  auto loc = locptr ? *locptr : std::locale::classic();
+  auto& facet = std::use_facet<std::time_put<char>>(loc);
+  std::ostringstream os;
+  os.imbue(loc);
+  facet.put(os, os, ' ', timeptr, format.c_str(),
+            format.c_str() + format.size());
+#ifdef _WIN32
+  // Workaround a bug in older versions of Universal CRT.
+  auto str = os.str();
+  if (str == "-0000") str = "+0000";
+  return str;
+#else
+  return os.str();
+#endif
+}
+
+FMT_CONSTEXPR std::tm make_tm(int year, int mon, int mday, int hour, int min,
+                              int sec) {
+  auto tm = std::tm();
+  tm.tm_sec = sec;
+  tm.tm_min = min;
+  tm.tm_hour = hour;
+  tm.tm_mday = mday;
+  tm.tm_mon = mon - 1;
+  tm.tm_year = year - 1900;
+  return tm;
+}
+
+TEST(chrono_test, format_tm) {
+  auto tm = std::tm();
+  tm.tm_year = 116;
+  tm.tm_mon = 3;
+  tm.tm_mday = 25;
+  tm.tm_hour = 11;
+  tm.tm_min = 22;
+  tm.tm_sec = 33;
+  EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm),
+            "The date is 2016-04-25 11:22:33.");
+  EXPECT_EQ(fmt::format("{:%Y}", tm), "2016");
+  EXPECT_EQ(fmt::format("{:%C}", tm), "20");
+  EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm));
+  EXPECT_EQ(fmt::format("{:%e}", tm), "25");
+  EXPECT_EQ(fmt::format("{:%D}", tm), "04/25/16");
+  EXPECT_EQ(fmt::format("{:%F}", tm), "2016-04-25");
+  EXPECT_EQ(fmt::format("{:%T}", tm), "11:22:33");
+
+  // Short year
+  tm.tm_year = 999 - 1900;
+  tm.tm_mon = 0;   // for %G
+  tm.tm_mday = 2;  // for %G
+  tm.tm_wday = 3;  // for %G
+  tm.tm_yday = 1;  // for %G
+  EXPECT_EQ(fmt::format("{:%Y}", tm), "0999");
+  EXPECT_EQ(fmt::format("{:%C%y}", tm), "0999");
+  EXPECT_EQ(fmt::format("{:%G}", tm), "0999");
+
+  tm.tm_year = 27 - 1900;
+  EXPECT_EQ(fmt::format("{:%Y}", tm), "0027");
+  EXPECT_EQ(fmt::format("{:%C%y}", tm), "0027");
+
+  // Overflow year
+  tm.tm_year = 2147483647;
+  EXPECT_EQ(fmt::format("{:%Y}", tm), "2147485547");
+
+  tm.tm_year = -2147483648;
+  EXPECT_EQ(fmt::format("{:%Y}", tm), "-2147481748");
+
+  // for week on the year
+  // https://www.cl.cam.ac.uk/~mgk25/iso-time.html
+  std::vector<std::tm> tm_list = {
+      make_tm(1975, 12, 29, 12, 14, 16),  // W01
+      make_tm(1977, 1, 2, 12, 14, 16),    // W53
+      make_tm(1999, 12, 27, 12, 14, 16),  // W52
+      make_tm(1999, 12, 31, 12, 14, 16),  // W52
+      make_tm(2000, 1, 1, 12, 14, 16),    // W52
+      make_tm(2000, 1, 2, 12, 14, 16),    // W52
+      make_tm(2000, 1, 3, 12, 14, 16)     // W1
+  };
+
+#if !FMT_HAS_C99_STRFTIME
+  GTEST_SKIP() << "Skip the rest of this test because it relies on strftime() "
+                  "conforming to C99, but on this platform, MINGW + MSVCRT, "
+                  "the function conforms only to C89.";
+#endif
+
+  const std::string iso_week_spec = "%Y-%m-%d: %G %g %V";
+  for (auto ctm : tm_list) {
+    // Calculate tm_yday, tm_wday, etc.
+    std::time_t t = std::mktime(&ctm);
+    tm = *std::localtime(&t);
+
+    auto fmt_spec = fmt::format("{{:{}}}", iso_week_spec);
+    EXPECT_EQ(system_strftime(iso_week_spec, &tm),
+              fmt::format(fmt::runtime(fmt_spec), tm));
+  }
+
+  // Every day from 1970-01-01
+  std::time_t time_now = std::time(nullptr);
+  for (std::time_t t = 6 * 3600; t < time_now; t += 86400) {
+    tm = *std::localtime(&t);
+
+    auto fmt_spec = fmt::format("{{:{}}}", iso_week_spec);
+    EXPECT_EQ(system_strftime(iso_week_spec, &tm),
+              fmt::format(fmt::runtime(fmt_spec), tm));
+  }
+}
+
+// MSVC:
+//  minkernel\crts\ucrt\src\appcrt\time\wcsftime.cpp(971) : Assertion failed:
+//  timeptr->tm_year >= -1900 && timeptr->tm_year <= 8099
+#ifndef _WIN32
+TEST(chrono_test, format_tm_future) {
+  auto tm = std::tm();
+  tm.tm_year = 10445;  // 10000+ years
+  tm.tm_mon = 3;
+  tm.tm_mday = 25;
+  tm.tm_hour = 11;
+  tm.tm_min = 22;
+  tm.tm_sec = 33;
+  EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm),
+            "The date is 12345-04-25 11:22:33.");
+  EXPECT_EQ(fmt::format("{:%Y}", tm), "12345");
+  EXPECT_EQ(fmt::format("{:%C}", tm), "123");
+  EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm));
+  EXPECT_EQ(fmt::format("{:%D}", tm), "04/25/45");
+  EXPECT_EQ(fmt::format("{:%F}", tm), "12345-04-25");
+  EXPECT_EQ(fmt::format("{:%T}", tm), "11:22:33");
+}
+
+TEST(chrono_test, format_tm_past) {
+  auto tm = std::tm();
+  tm.tm_year = -2001;
+  tm.tm_mon = 3;
+  tm.tm_mday = 25;
+  tm.tm_hour = 11;
+  tm.tm_min = 22;
+  tm.tm_sec = 33;
+  EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm),
+            "The date is -101-04-25 11:22:33.");
+  EXPECT_EQ(fmt::format("{:%Y}", tm), "-101");
+
+  // macOS  %C - "-1"
+  // Linux  %C - "-2"
+  // fmt    %C - "-1"
+  EXPECT_EQ(fmt::format("{:%C}", tm), "-1");
+  EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm));
+
+  // macOS  %D - "04/25/01" (%y)
+  // Linux  %D - "04/25/99" (%y)
+  // fmt    %D - "04/25/01" (%y)
+  EXPECT_EQ(fmt::format("{:%D}", tm), "04/25/01");
+
+  EXPECT_EQ(fmt::format("{:%F}", tm), "-101-04-25");
+  EXPECT_EQ(fmt::format("{:%T}", tm), "11:22:33");
+
+  tm.tm_year = -1901;  // -1
+  EXPECT_EQ(fmt::format("{:%Y}", tm), "-001");
+  EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm));
+
+  tm.tm_year = -1911;  // -11
+  EXPECT_EQ(fmt::format("{:%Y}", tm), "-011");
+  EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm));
+}
+#endif
+
+TEST(chrono_test, grow_buffer) {
+  auto s = std::string("{:");
+  for (int i = 0; i < 30; ++i) s += "%c";
+  s += "}\n";
+  auto t = std::time(nullptr);
+  (void)fmt::format(fmt::runtime(s), *std::localtime(&t));
+}
+
+TEST(chrono_test, format_to_empty_container) {
+  auto time = std::tm();
+  time.tm_sec = 42;
+  auto s = std::string();
+  fmt::format_to(std::back_inserter(s), "{:%S}", time);
+  EXPECT_EQ(s, "42");
+}
+
+TEST(chrono_test, empty_result) { EXPECT_EQ(fmt::format("{}", std::tm()), ""); }
+
+auto equal(const std::tm& lhs, const std::tm& rhs) -> bool {
+  return lhs.tm_sec == rhs.tm_sec && lhs.tm_min == rhs.tm_min &&
+         lhs.tm_hour == rhs.tm_hour && lhs.tm_mday == rhs.tm_mday &&
+         lhs.tm_mon == rhs.tm_mon && lhs.tm_year == rhs.tm_year &&
+         lhs.tm_wday == rhs.tm_wday && lhs.tm_yday == rhs.tm_yday &&
+         lhs.tm_isdst == rhs.tm_isdst;
+}
+
+TEST(chrono_test, gmtime) {
+  auto t = std::time(nullptr);
+  auto tm = *std::gmtime(&t);
+  EXPECT_TRUE(equal(tm, fmt::gmtime(t)));
+}
+
+template <typename TimePoint>
+auto strftime_full_utc(TimePoint tp) -> std::string {
+  auto t = std::chrono::system_clock::to_time_t(tp);
+  auto tm = *std::gmtime(&t);
+  return system_strftime("%Y-%m-%d %H:%M:%S", &tm);
+}
+
+TEST(chrono_test, system_clock_time_point) {
+  auto t1 = std::chrono::time_point_cast<std::chrono::seconds>(
+      std::chrono::system_clock::now());
+  EXPECT_EQ(strftime_full_utc(t1), fmt::format("{:%Y-%m-%d %H:%M:%S}", t1));
+  EXPECT_EQ(strftime_full_utc(t1), fmt::format("{}", t1));
+  EXPECT_EQ(strftime_full_utc(t1), fmt::format("{:}", t1));
+
+  auto t2 = sys_time<std::chrono::seconds>(std::chrono::seconds(42));
+  EXPECT_EQ(strftime_full_utc(t2), fmt::format("{:%Y-%m-%d %H:%M:%S}", t2));
+
+  std::vector<std::string> spec_list = {
+      "%%",  "%n",  "%t",  "%Y",  "%EY", "%y",  "%Oy", "%Ey", "%C",
+      "%EC", "%G",  "%g",  "%b",  "%h",  "%B",  "%m",  "%Om", "%U",
+      "%OU", "%W",  "%OW", "%V",  "%OV", "%j",  "%d",  "%Od", "%e",
+      "%Oe", "%a",  "%A",  "%w",  "%Ow", "%u",  "%Ou", "%H",  "%OH",
+      "%I",  "%OI", "%M",  "%OM", "%S",  "%OS", "%x",  "%Ex", "%X",
+      "%EX", "%D",  "%F",  "%R",  "%T",  "%p"};
+#ifndef _WIN32
+  // Disabled on Windows because these formats are not consistent among
+  // platforms.
+  spec_list.insert(spec_list.end(), {"%c", "%Ec", "%r"});
+#elif !FMT_HAS_C99_STRFTIME
+  // Only C89 conversion specifiers when using MSVCRT instead of UCRT
+  spec_list = {"%%", "%Y", "%y", "%b", "%B", "%m", "%U", "%W", "%j", "%d",
+               "%a", "%A", "%w", "%H", "%I", "%M", "%S", "%x", "%X", "%p"};
+#endif
+  spec_list.push_back("%Y-%m-%d %H:%M:%S");
+
+  for (const auto& spec : spec_list) {
+    auto t = std::chrono::system_clock::to_time_t(t1);
+    auto tm = *std::gmtime(&t);
+
+    auto sys_output = system_strftime(spec, &tm);
+
+    auto fmt_spec = fmt::format("{{:{}}}", spec);
+    EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), t1));
+    EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), tm));
+  }
+
+  // Timezone formatters tests makes sense for localtime.
+#if FMT_HAS_C99_STRFTIME
+  spec_list = {"%z", "%Z"};
+#else
+  spec_list = {"%Z"};
+#endif
+  for (const auto& spec : spec_list) {
+    auto t = std::chrono::system_clock::to_time_t(t1);
+    auto tm = *std::localtime(&t);
+
+    auto sys_output = system_strftime(spec, &tm);
+
+    auto fmt_spec = fmt::format("{{:{}}}", spec);
+    EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), tm));
+
+    if (spec == "%z") {
+      sys_output.insert(sys_output.end() - 2, 1, ':');
+      EXPECT_EQ(sys_output, fmt::format("{:%Ez}", tm));
+      EXPECT_EQ(sys_output, fmt::format("{:%Oz}", tm));
+    }
+  }
+
+  // Separate tests for UTC, since std::time_put can use local time and ignoring
+  // the timezone in std::tm (if it presents on platform).
+  if (fmt::detail::has_member_data_tm_zone<std::tm>::value) {
+    auto t = std::chrono::system_clock::to_time_t(t1);
+    auto tm = *std::gmtime(&t);
+
+    std::vector<std::string> tz_names = {"GMT", "UTC"};
+    EXPECT_THAT(tz_names, Contains(fmt::format("{:%Z}", t1)));
+    EXPECT_THAT(tz_names, Contains(fmt::format("{:%Z}", tm)));
+  }
+
+  if (fmt::detail::has_member_data_tm_gmtoff<std::tm>::value) {
+    auto t = std::chrono::system_clock::to_time_t(t1);
+    auto tm = *std::gmtime(&t);
+
+    EXPECT_EQ(fmt::format("{:%z}", t1), "+0000");
+    EXPECT_EQ(fmt::format("{:%z}", tm), "+0000");
+
+    EXPECT_EQ(fmt::format("{:%Ez}", t1), "+00:00");
+    EXPECT_EQ(fmt::format("{:%Ez}", tm), "+00:00");
+
+    EXPECT_EQ(fmt::format("{:%Oz}", t1), "+00:00");
+    EXPECT_EQ(fmt::format("{:%Oz}", tm), "+00:00");
+  }
+}
+
+#if FMT_USE_LOCAL_TIME
+
+TEST(chrono_test, localtime) {
+  auto t = std::time(nullptr);
+  auto tm = *std::localtime(&t);
+  EXPECT_TRUE(equal(tm, fmt::localtime(t)));
+}
+
+template <typename Duration>
+auto strftime_full_local(std::chrono::local_time<Duration> tp) -> std::string {
+  auto t = std::chrono::system_clock::to_time_t(
+      std::chrono::current_zone()->to_sys(tp));
+  auto tm = *std::localtime(&t);
+  return system_strftime("%Y-%m-%d %H:%M:%S", &tm);
+}
+
+TEST(chrono_test, local_system_clock_time_point) {
+#  ifdef _WIN32
+  return;  // Not supported on Windows.
+#  endif
+  auto t1 = std::chrono::time_point_cast<std::chrono::seconds>(
+      std::chrono::current_zone()->to_local(std::chrono::system_clock::now()));
+  EXPECT_EQ(strftime_full_local(t1), fmt::format("{:%Y-%m-%d %H:%M:%S}", t1));
+  EXPECT_EQ(strftime_full_local(t1), fmt::format("{}", t1));
+  EXPECT_EQ(strftime_full_local(t1), fmt::format("{:}", t1));
+  using time_point = std::chrono::local_time<std::chrono::seconds>;
+  auto t2 = time_point(std::chrono::seconds(86400 + 42));
+  EXPECT_EQ(strftime_full_local(t2), fmt::format("{:%Y-%m-%d %H:%M:%S}", t2));
+
+  std::vector<std::string> spec_list = {
+      "%%",  "%n",  "%t",  "%Y",  "%EY", "%y",  "%Oy", "%Ey", "%C",
+      "%EC", "%G",  "%g",  "%b",  "%h",  "%B",  "%m",  "%Om", "%U",
+      "%OU", "%W",  "%OW", "%V",  "%OV", "%j",  "%d",  "%Od", "%e",
+      "%Oe", "%a",  "%A",  "%w",  "%Ow", "%u",  "%Ou", "%H",  "%OH",
+      "%I",  "%OI", "%M",  "%OM", "%S",  "%OS", "%x",  "%Ex", "%X",
+      "%EX", "%D",  "%F",  "%R",  "%T",  "%p",  "%z",  "%Z"};
+#  ifndef _WIN32
+  // Disabled on Windows because these formats are not consistent among
+  // platforms.
+  spec_list.insert(spec_list.end(), {"%c", "%Ec", "%r"});
+#  elif !FMT_HAS_C99_STRFTIME
+  // Only C89 conversion specifiers when using MSVCRT instead of UCRT
+  spec_list = {"%%", "%Y", "%y", "%b", "%B", "%m", "%U", "%W", "%j", "%d", "%a",
+               "%A", "%w", "%H", "%I", "%M", "%S", "%x", "%X", "%p", "%Z"};
+#  endif
+  spec_list.push_back("%Y-%m-%d %H:%M:%S");
+
+  for (const auto& spec : spec_list) {
+    auto t = std::chrono::system_clock::to_time_t(
+        std::chrono::current_zone()->to_sys(t1));
+    auto tm = *std::localtime(&t);
+
+    auto sys_output = system_strftime(spec, &tm);
+
+    auto fmt_spec = fmt::format("{{:{}}}", spec);
+    EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), t1));
+    EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), tm));
+  }
+
+  if (std::find(spec_list.cbegin(), spec_list.cend(), "%z") !=
+      spec_list.cend()) {
+    auto t = std::chrono::system_clock::to_time_t(
+        std::chrono::current_zone()->to_sys(t1));
+    auto tm = *std::localtime(&t);
+
+    auto sys_output = system_strftime("%z", &tm);
+    sys_output.insert(sys_output.end() - 2, 1, ':');
+
+    EXPECT_EQ(sys_output, fmt::format("{:%Ez}", t1));
+    EXPECT_EQ(sys_output, fmt::format("{:%Ez}", tm));
+
+    EXPECT_EQ(sys_output, fmt::format("{:%Oz}", t1));
+    EXPECT_EQ(sys_output, fmt::format("{:%Oz}", tm));
+  }
+}
+
+#endif  // FMT_USE_LOCAL_TIME
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+
+TEST(chrono_test, format_default) {
+  EXPECT_EQ(fmt::format("{}", std::chrono::seconds(42)), "42s");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::atto>(42)),
+            "42as");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::femto>(42)),
+            "42fs");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::pico>(42)),
+            "42ps");
+  EXPECT_EQ(fmt::format("{}", std::chrono::nanoseconds(42)), "42ns");
+  EXPECT_EQ(fmt::format("{}", std::chrono::microseconds(42)), "42µs");
+  EXPECT_EQ(fmt::format("{}", std::chrono::milliseconds(42)), "42ms");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::centi>(42)),
+            "42cs");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::deci>(42)),
+            "42ds");
+  EXPECT_EQ(fmt::format("{}", std::chrono::seconds(42)), "42s");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::deca>(42)),
+            "42das");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::hecto>(42)),
+            "42hs");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::kilo>(42)),
+            "42ks");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::mega>(42)),
+            "42Ms");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::giga>(42)),
+            "42Gs");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::tera>(42)),
+            "42Ts");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::peta>(42)),
+            "42Ps");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<int, std::exa>(42)),
+            "42Es");
+  EXPECT_EQ(fmt::format("{}", std::chrono::minutes(42)), "42min");
+  EXPECT_EQ(fmt::format("{}", std::chrono::hours(42)), "42h");
+  EXPECT_EQ(fmt::format("{}", days(42)), "42d");
+  EXPECT_EQ(
+      fmt::format("{}", std::chrono::duration<int, std::ratio<15, 1>>(42)),
+      "42[15]s");
+  EXPECT_EQ(
+      fmt::format("{}", std::chrono::duration<int, std::ratio<15, 4>>(42)),
+      "42[15/4]s");
+}
+
+TEST(chrono_test, duration_align) {
+  auto s = std::chrono::seconds(42);
+  EXPECT_EQ(fmt::format("{:5}", s), "42s  ");
+  EXPECT_EQ(fmt::format("{:{}}", s, 5), "42s  ");
+  EXPECT_EQ(fmt::format("{:>5}", s), "  42s");
+  EXPECT_EQ(fmt::format("{:*^7}", s), "**42s**");
+  EXPECT_EQ(fmt::format("{:12%H:%M:%S}", std::chrono::seconds(12345)),
+            "03:25:45    ");
+  EXPECT_EQ(fmt::format("{:>12%H:%M:%S}", std::chrono::seconds(12345)),
+            "    03:25:45");
+  EXPECT_EQ(fmt::format("{:~^12%H:%M:%S}", std::chrono::seconds(12345)),
+            "~~03:25:45~~");
+  EXPECT_EQ(fmt::format("{:{}%H:%M:%S}", std::chrono::seconds(12345), 12),
+            "03:25:45    ");
+}
+
+TEST(chrono_test, tm_align) {
+  auto t = make_tm(1975, 12, 29, 12, 14, 16);
+  EXPECT_EQ(fmt::format("{:%F %T}", t), "1975-12-29 12:14:16");
+  EXPECT_EQ(fmt::format("{:30%F %T}", t), "1975-12-29 12:14:16           ");
+  EXPECT_EQ(fmt::format("{:{}%F %T}", t, 30), "1975-12-29 12:14:16           ");
+  EXPECT_EQ(fmt::format("{:<30%F %T}", t), "1975-12-29 12:14:16           ");
+  EXPECT_EQ(fmt::format("{:^30%F %T}", t), "     1975-12-29 12:14:16      ");
+  EXPECT_EQ(fmt::format("{:>30%F %T}", t), "           1975-12-29 12:14:16");
+
+  EXPECT_EQ(fmt::format("{:*<30%F %T}", t), "1975-12-29 12:14:16***********");
+  EXPECT_EQ(fmt::format("{:*^30%F %T}", t), "*****1975-12-29 12:14:16******");
+  EXPECT_EQ(fmt::format("{:*>30%F %T}", t), "***********1975-12-29 12:14:16");
+}
+
+TEST(chrono_test, tp_align) {
+  auto tp = std::chrono::time_point_cast<std::chrono::microseconds>(
+      std::chrono::system_clock::from_time_t(0));
+  EXPECT_EQ(fmt::format("{:%M:%S}", tp), "00:00.000000");
+  EXPECT_EQ(fmt::format("{:15%M:%S}", tp), "00:00.000000   ");
+  EXPECT_EQ(fmt::format("{:{}%M:%S}", tp, 15), "00:00.000000   ");
+  EXPECT_EQ(fmt::format("{:<15%M:%S}", tp), "00:00.000000   ");
+  EXPECT_EQ(fmt::format("{:^15%M:%S}", tp), " 00:00.000000  ");
+  EXPECT_EQ(fmt::format("{:>15%M:%S}", tp), "   00:00.000000");
+
+  EXPECT_EQ(fmt::format("{:*<15%M:%S}", tp), "00:00.000000***");
+  EXPECT_EQ(fmt::format("{:*^15%M:%S}", tp), "*00:00.000000**");
+  EXPECT_EQ(fmt::format("{:*>15%M:%S}", tp), "***00:00.000000");
+}
+
+TEST(chrono_test, format_specs) {
+  EXPECT_EQ(fmt::format("{:%%}", std::chrono::seconds(0)), "%");
+  EXPECT_EQ(fmt::format("{:%n}", std::chrono::seconds(0)), "\n");
+  EXPECT_EQ(fmt::format("{:%t}", std::chrono::seconds(0)), "\t");
+  EXPECT_EQ(fmt::format("{:%S}", std::chrono::seconds(0)), "00");
+  EXPECT_EQ(fmt::format("{:%S}", std::chrono::seconds(60)), "00");
+  EXPECT_EQ(fmt::format("{:%S}", std::chrono::seconds(42)), "42");
+  EXPECT_EQ(fmt::format("{:%S}", std::chrono::milliseconds(1234)), "01.234");
+  EXPECT_EQ(fmt::format("{:%M}", std::chrono::minutes(0)), "00");
+  EXPECT_EQ(fmt::format("{:%M}", std::chrono::minutes(60)), "00");
+  EXPECT_EQ(fmt::format("{:%M}", std::chrono::minutes(42)), "42");
+  EXPECT_EQ(fmt::format("{:%M}", std::chrono::seconds(61)), "01");
+  EXPECT_EQ(fmt::format("{:%H}", std::chrono::hours(0)), "00");
+  EXPECT_EQ(fmt::format("{:%H}", std::chrono::hours(24)), "00");
+  EXPECT_EQ(fmt::format("{:%H}", std::chrono::hours(14)), "14");
+  EXPECT_EQ(fmt::format("{:%H}", std::chrono::minutes(61)), "01");
+  EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(0)), "12");
+  EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(12)), "12");
+  EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(24)), "12");
+  EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(4)), "04");
+  EXPECT_EQ(fmt::format("{:%I}", std::chrono::hours(14)), "02");
+  EXPECT_EQ(fmt::format("{:%j}", days(12345)), "12345");
+  EXPECT_EQ(fmt::format("{:%j}", std::chrono::hours(12345 * 24 + 12)), "12345");
+  EXPECT_EQ(fmt::format("{:%H:%M:%S}", std::chrono::seconds(12345)),
+            "03:25:45");
+  EXPECT_EQ(fmt::format("{:%R}", std::chrono::seconds(12345)), "03:25");
+  EXPECT_EQ(fmt::format("{:%T}", std::chrono::seconds(12345)), "03:25:45");
+  EXPECT_EQ(fmt::format("{:%Q}", std::chrono::seconds(12345)), "12345");
+  EXPECT_EQ(fmt::format("{:%q}", std::chrono::seconds(12345)), "s");
+}
+
+TEST(chrono_test, invalid_specs) {
+  auto sec = std::chrono::seconds(0);
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%a}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%A}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%c}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%x}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Ex}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%X}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%EX}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%D}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%F}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Ec}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%w}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%u}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%b}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%B}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%z}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Z}"), sec), fmt::format_error,
+                   "no date");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Eq}"), sec), fmt::format_error,
+                   "invalid format");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Oq}"), sec), fmt::format_error,
+                   "invalid format");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:abc}"), sec), fmt::format_error,
+                   "invalid format");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:.2f}"), sec), fmt::format_error,
+                   "invalid format");
+}
+
+auto format_tm(const std::tm& time, fmt::string_view spec,
+               const std::locale& loc) -> std::string {
+  auto& facet = std::use_facet<std::time_put<char>>(loc);
+  std::ostringstream os;
+  os.imbue(loc);
+  facet.put(os, os, ' ', &time, spec.begin(), spec.end());
+  return os.str();
+}
+
+TEST(chrono_test, locale) {
+  auto loc = get_locale("ja_JP.utf8");
+  if (loc == std::locale::classic()) return;
+#  define EXPECT_TIME(spec, time, duration)                     \
+    {                                                           \
+      auto jp_loc = std::locale("ja_JP.utf8");                  \
+      EXPECT_EQ(format_tm(time, spec, jp_loc),                  \
+                fmt::format(jp_loc, "{:L" spec "}", duration)); \
+    }
+  EXPECT_TIME("%OH", make_hour(14), std::chrono::hours(14));
+  EXPECT_TIME("%OI", make_hour(14), std::chrono::hours(14));
+  EXPECT_TIME("%OM", make_minute(42), std::chrono::minutes(42));
+  EXPECT_TIME("%OS", make_second(42), std::chrono::seconds(42));
+  auto time = make_tm();
+  time.tm_hour = 3;
+  time.tm_min = 25;
+  time.tm_sec = 45;
+  auto sec = std::chrono::seconds(12345);
+  EXPECT_TIME("%r", time, sec);
+  EXPECT_TIME("%p", time, sec);
+}
+
+using dms = std::chrono::duration<double, std::milli>;
+
+TEST(chrono_test, format_default_fp) {
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<float>(1.234)), "1.234s");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::milli>(1.234)),
+            "1.234ms");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<double>(1.234)), "1.234s");
+  EXPECT_EQ(fmt::format("{}", dms(1.234)), "1.234ms");
+}
+
+TEST(chrono_test, format_precision) {
+  EXPECT_THROW_MSG(
+      (void)fmt::format(runtime("{:.2%Q}"), std::chrono::seconds(42)),
+      fmt::format_error, "precision not allowed for this argument type");
+  EXPECT_EQ(fmt::format("{:.0}", dms(1.234)), "1ms");
+  EXPECT_EQ(fmt::format("{:.1}", dms(1.234)), "1.2ms");
+  EXPECT_EQ(fmt::format("{:.{}}", dms(1.234), 2), "1.23ms");
+
+  EXPECT_EQ(fmt::format("{:.0}", dms(12.56)), "13ms");
+  EXPECT_EQ(fmt::format("{:.1}", dms(12.56)), "12.6ms");
+  EXPECT_EQ(fmt::format("{:.2}", dms(12.56)), "12.56ms");
+}
+
+TEST(chrono_test, format_full_specs) {
+  EXPECT_EQ(fmt::format("{:6.0}", dms(1.234)), "1ms   ");
+  EXPECT_EQ(fmt::format("{:6.1}", dms(1.234)), "1.2ms ");
+  EXPECT_EQ(fmt::format("{:>8.{}}", dms(1.234), 2), "  1.23ms");
+  EXPECT_EQ(fmt::format("{:^{}.{}}", dms(1.234), 7, 1), " 1.2ms ");
+  EXPECT_EQ(fmt::format("{0:^{2}.{1}}", dms(1.234), 2, 8), " 1.23ms ");
+  EXPECT_EQ(fmt::format("{:=^{}.{}}", dms(1.234), 9, 3), "=1.234ms=");
+  EXPECT_EQ(fmt::format("{:*^10.4}", dms(1.234)), "*1.2340ms*");
+
+  EXPECT_EQ(fmt::format("{:6.0}", dms(12.56)), "13ms  ");
+  EXPECT_EQ(fmt::format("{:>8.{}}", dms(12.56), 0), "    13ms");
+  EXPECT_EQ(fmt::format("{:^{}.{}}", dms(12.56), 6, 0), " 13ms ");
+  EXPECT_EQ(fmt::format("{0:^{2}.{1}}", dms(12.56), 0, 8), "  13ms  ");
+  EXPECT_EQ(fmt::format("{:=^{}.{}}", dms(12.56), 9, 0), "==13ms===");
+  EXPECT_EQ(fmt::format("{:*^10.0}", dms(12.56)), "***13ms***");
+}
+
+TEST(chrono_test, format_simple_q) {
+  EXPECT_EQ(fmt::format("{:%Q %q}", std::chrono::duration<float>(1.234)),
+            "1.234 s");
+  EXPECT_EQ(
+      fmt::format("{:%Q %q}", std::chrono::duration<float, std::milli>(1.234)),
+      "1.234 ms");
+  EXPECT_EQ(fmt::format("{:%Q %q}", std::chrono::duration<double>(1.234)),
+            "1.234 s");
+  EXPECT_EQ(fmt::format("{:%Q %q}", dms(1.234)), "1.234 ms");
+}
+
+TEST(chrono_test, format_precision_q) {
+  EXPECT_THROW_MSG(
+      (void)fmt::format(runtime("{:.2%Q %q}"), std::chrono::seconds(42)),
+      fmt::format_error, "precision not allowed for this argument type");
+  EXPECT_EQ(fmt::format("{:.1%Q %q}", dms(1.234)), "1.2 ms");
+  EXPECT_EQ(fmt::format("{:.{}%Q %q}", dms(1.234), 2), "1.23 ms");
+}
+
+TEST(chrono_test, format_full_specs_q) {
+  EXPECT_EQ(fmt::format("{:7.0%Q %q}", dms(1.234)), "1 ms   ");
+  EXPECT_EQ(fmt::format("{:7.1%Q %q}", dms(1.234)), "1.2 ms ");
+  EXPECT_EQ(fmt::format("{:>8.{}%Q %q}", dms(1.234), 2), " 1.23 ms");
+  EXPECT_EQ(fmt::format("{:^{}.{}%Q %q}", dms(1.234), 8, 1), " 1.2 ms ");
+  EXPECT_EQ(fmt::format("{0:^{2}.{1}%Q %q}", dms(1.234), 2, 9), " 1.23 ms ");
+  EXPECT_EQ(fmt::format("{:=^{}.{}%Q %q}", dms(1.234), 10, 3), "=1.234 ms=");
+  EXPECT_EQ(fmt::format("{:*^11.4%Q %q}", dms(1.234)), "*1.2340 ms*");
+
+  EXPECT_EQ(fmt::format("{:7.0%Q %q}", dms(12.56)), "13 ms  ");
+  EXPECT_EQ(fmt::format("{:>8.{}%Q %q}", dms(12.56), 0), "   13 ms");
+  EXPECT_EQ(fmt::format("{:^{}.{}%Q %q}", dms(12.56), 8, 0), " 13 ms  ");
+  EXPECT_EQ(fmt::format("{0:^{2}.{1}%Q %q}", dms(12.56), 0, 9), "  13 ms  ");
+  EXPECT_EQ(fmt::format("{:=^{}.{}%Q %q}", dms(12.56), 9, 0), "==13 ms==");
+  EXPECT_EQ(fmt::format("{:*^11.0%Q %q}", dms(12.56)), "***13 ms***");
+}
+
+TEST(chrono_test, invalid_width_id) {
+  EXPECT_THROW((void)fmt::format(runtime("{:{o}"), std::chrono::seconds(0)),
+               fmt::format_error);
+}
+
+TEST(chrono_test, invalid_colons) {
+  EXPECT_THROW((void)fmt::format(runtime("{0}=:{0::"), std::chrono::seconds(0)),
+               fmt::format_error);
+}
+
+TEST(chrono_test, negative_durations) {
+  EXPECT_EQ(fmt::format("{:%Q}", std::chrono::seconds(-12345)), "-12345");
+  EXPECT_EQ(fmt::format("{:%H:%M:%S}", std::chrono::seconds(-12345)),
+            "-03:25:45");
+  EXPECT_EQ(fmt::format("{:%M:%S}", std::chrono::duration<double>(-1)),
+            "-00:01");
+  EXPECT_EQ(fmt::format("{:%q}", std::chrono::seconds(-12345)), "s");
+  EXPECT_EQ(fmt::format("{:%S}",
+                        std::chrono::duration<signed char, std::milli>(-127)),
+            "-00.127");
+  auto min = std::numeric_limits<int>::min();
+  EXPECT_EQ(fmt::format("{}", min),
+            fmt::format("{:%Q}", std::chrono::duration<int>(min)));
+}
+
+TEST(chrono_test, special_durations) {
+  EXPECT_EQ(fmt::format("{:%S}", std::chrono::duration<double>(1e20)), "40");
+  auto nan = std::numeric_limits<double>::quiet_NaN();
+  EXPECT_EQ(
+      fmt::format("{:%I %H %M %S %R %r}", std::chrono::duration<double>(nan)),
+      "nan nan nan nan nan:nan nan");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::exa>(1)),
+            "1Es");
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<float, std::atto>(1)),
+            "1as");
+  EXPECT_EQ(fmt::format("{:%R}", std::chrono::duration<char, std::mega>{2}),
+            "03:33");
+  EXPECT_EQ(fmt::format("{:%T}", std::chrono::duration<char, std::mega>{2}),
+            "03:33:20");
+  EXPECT_EQ(
+      fmt::format("{:.3%S}", std::chrono::duration<float, std::pico>(1.234e12)),
+      "01.234");
+}
+
+TEST(chrono_test, unsigned_duration) {
+  EXPECT_EQ(fmt::format("{}", std::chrono::duration<unsigned>(42)), "42s");
+}
+
+TEST(chrono_test, weekday) {
+  auto loc = get_locale("es_ES.UTF-8");
+  std::locale::global(loc);
+  auto sat = fmt::weekday(6);
+
+  auto tm = std::tm();
+  tm.tm_wday = static_cast<int>(sat.c_encoding());
+
+  EXPECT_EQ(fmt::format("{}", sat), "Sat");
+  EXPECT_EQ(fmt::format("{:%a}", tm), "Sat");
+
+  if (loc != std::locale::classic()) {
+    auto saturdays = std::vector<std::string>{"sáb", "sá."};
+    EXPECT_THAT(saturdays, Contains(fmt::format(loc, "{:L}", sat)));
+    EXPECT_THAT(saturdays, Contains(fmt::format(loc, "{:%a}", tm)));
+  }
+}
+
+TEST(chrono_test, cpp20_duration_subsecond_support) {
+  using attoseconds = std::chrono::duration<long long, std::atto>;
+  // Check that 18 digits of subsecond precision are supported.
+  EXPECT_EQ(fmt::format("{:%S}", attoseconds{999999999999999999}),
+            "00.999999999999999999");
+  EXPECT_EQ(fmt::format("{:%S}", attoseconds{673231113420148734}),
+            "00.673231113420148734");
+  EXPECT_EQ(fmt::format("{:%S}", attoseconds{-673231113420148734}),
+            "-00.673231113420148734");
+  EXPECT_EQ(fmt::format("{:%S}", std::chrono::nanoseconds{13420148734}),
+            "13.420148734");
+  EXPECT_EQ(fmt::format("{:%S}", std::chrono::nanoseconds{-13420148734}),
+            "-13.420148734");
+  EXPECT_EQ(fmt::format("{:%S}", std::chrono::milliseconds{1234}), "01.234");
+  // Check subsecond presision modifier.
+  EXPECT_EQ(fmt::format("{:.6%S}", std::chrono::nanoseconds{1234}),
+            "00.000001");
+  EXPECT_EQ(fmt::format("{:.18%S}", std::chrono::nanoseconds{1234}),
+            "00.000001234000000000");
+  EXPECT_EQ(fmt::format("{:.{}%S}", std::chrono::nanoseconds{1234}, 6),
+            "00.000001");
+  EXPECT_EQ(fmt::format("{:.6%S}", std::chrono::milliseconds{1234}),
+            "01.234000");
+  EXPECT_EQ(fmt::format("{:.6%S}", std::chrono::milliseconds{-1234}),
+            "-01.234000");
+  EXPECT_EQ(fmt::format("{:.3%S}", std::chrono::seconds{1234}), "34.000");
+  EXPECT_EQ(fmt::format("{:.3%S}", std::chrono::hours{1234}), "00.000");
+  EXPECT_EQ(fmt::format("{:.5%S}", dms(1.234)), "00.00123");
+  EXPECT_EQ(fmt::format("{:.8%S}", dms(1.234)), "00.00123400");
+  {
+    // Check that {:%H:%M:%S} is equivalent to {:%T}.
+    auto dur = std::chrono::milliseconds{3601234};
+    auto formatted_dur = fmt::format("{:%T}", dur);
+    EXPECT_EQ(formatted_dur, "01:00:01.234");
+    EXPECT_EQ(fmt::format("{:%H:%M:%S}", dur), formatted_dur);
+    EXPECT_EQ(fmt::format("{:.6%H:%M:%S}", dur), "01:00:01.234000");
+  }
+  using nanoseconds_dbl = std::chrono::duration<double, std::nano>;
+  EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl{-123456789}), "-00.123456789");
+  EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl{9123456789}), "09.123456789");
+  // Verify that only the seconds part is extracted and printed.
+  EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl{99123456789}), "39.123456789");
+  EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl{99123000000}), "39.123000000");
+  {
+    // Now the hour is printed, and we also test if negative doubles work.
+    auto dur = nanoseconds_dbl{-99123456789};
+    auto formatted_dur = fmt::format("{:%T}", dur);
+    EXPECT_EQ(formatted_dur, "-00:01:39.123456789");
+    EXPECT_EQ(fmt::format("{:%H:%M:%S}", dur), formatted_dur);
+    EXPECT_EQ(fmt::format("{:.3%H:%M:%S}", dur), "-00:01:39.123");
+  }
+  // Check that durations with precision greater than std::chrono::seconds have
+  // fixed precision, and print zeros even if there is no fractional part.
+  EXPECT_EQ(fmt::format("{:%S}", std::chrono::microseconds{7000000}),
+            "07.000000");
+  EXPECT_EQ(fmt::format("{:%S}",
+                        std::chrono::duration<long long, std::ratio<1, 3>>(1)),
+            "00.333333");
+  EXPECT_EQ(fmt::format("{:%S}",
+                        std::chrono::duration<long long, std::ratio<1, 7>>(1)),
+            "00.142857");
+
+  EXPECT_EQ(
+      fmt::format("{:%S}",
+                  std::chrono::duration<signed char, std::ratio<1, 100>>(0x80)),
+      "-01.28");
+
+  EXPECT_EQ(
+      fmt::format("{:%M:%S}",
+                  std::chrono::duration<short, std::ratio<1, 100>>(0x8000)),
+      "-05:27.68");
+
+  // Check that floating point seconds with ratio<1,1> are printed.
+  EXPECT_EQ(fmt::format("{:%S}", std::chrono::duration<double>{1.5}),
+            "01.500000");
+  EXPECT_EQ(fmt::format("{:%M:%S}", std::chrono::duration<double>{-61.25}),
+            "-01:01.250000");
+}
+
+#endif  // FMT_STATIC_THOUSANDS_SEPARATOR
+
+// Disable the utc_clock test for windows, as the icu.dll used for tzdb
+// (time zone database) is not shipped with many windows versions.
+#if FMT_USE_UTC_TIME && !defined(_WIN32)
+TEST(chrono_test, utc_clock) {
+  auto t1 = std::chrono::system_clock::now();
+  auto t1_utc = std::chrono::utc_clock::from_sys(t1);
+  EXPECT_EQ(fmt::format("{:%Y-%m-%d %H:%M:%S}", t1),
+            fmt::format("{:%Y-%m-%d %H:%M:%S}", t1_utc));
+}
+#endif
+
+TEST(chrono_test, timestamp_ratios) {
+  auto t1 =
+      sys_time<std::chrono::milliseconds>(std::chrono::milliseconds(67890));
+  EXPECT_EQ(fmt::format("{:%M:%S}", t1), "01:07.890");
+
+  auto t2 = sys_time<std::chrono::minutes>(std::chrono::minutes(7));
+  EXPECT_EQ(fmt::format("{:%M:%S}", t2), "07:00");
+
+  auto t3 = sys_time<std::chrono::duration<int, std::ratio<9>>>(
+      std::chrono::duration<int, std::ratio<9>>(7));
+  EXPECT_EQ(fmt::format("{:%M:%S}", t3), "01:03");
+
+  auto t4 = sys_time<std::chrono::duration<int, std::ratio<63>>>(
+      std::chrono::duration<int, std::ratio<63>>(1));
+  EXPECT_EQ(fmt::format("{:%M:%S}", t4), "01:03");
+
+  if (sizeof(time_t) > 4) {
+    auto tp =
+        sys_time<std::chrono::milliseconds>(std::chrono::seconds(32503680000));
+    EXPECT_EQ(fmt::format("{:%Y-%m-%d}", tp), "3000-01-01");
+  }
+
+  if (FMT_SAFE_DURATION_CAST) {
+    using years = std::chrono::duration<std::int64_t, std::ratio<31556952>>;
+    auto tp = sys_time<years>(years(std::numeric_limits<std::int64_t>::max()));
+    EXPECT_THROW_MSG((void)fmt::format("{:%Y-%m-%d}", tp), fmt::format_error,
+                     "cannot format duration");
+  }
+}
+
+TEST(chrono_test, timestamp_sub_seconds) {
+  auto t1 = sys_time<std::chrono::duration<long long, std::ratio<1, 3>>>(
+      std::chrono::duration<long long, std::ratio<1, 3>>(4));
+  EXPECT_EQ(fmt::format("{:%S}", t1), "01.333333");
+
+  auto t2 = sys_time<std::chrono::duration<double, std::ratio<1, 3>>>(
+      std::chrono::duration<double, std::ratio<1, 3>>(4));
+  EXPECT_EQ(fmt::format("{:%S}", t2), "01.333333");
+
+  auto t3 = sys_time<std::chrono::seconds>(std::chrono::seconds(2));
+  EXPECT_EQ(fmt::format("{:%S}", t3), "02");
+
+  auto t4 = sys_time<std::chrono::duration<double>>(
+      std::chrono::duration<double, std::ratio<1, 1>>(9.5));
+  EXPECT_EQ(fmt::format("{:%S}", t4), "09.500000");
+
+  auto t5 = sys_time<std::chrono::duration<double>>(
+      std::chrono::duration<double, std::ratio<1, 1>>(9));
+  EXPECT_EQ(fmt::format("{:%S}", t5), "09");
+
+  auto t6 = sys_time<std::chrono::milliseconds>(std::chrono::seconds(1) +
+                                                std::chrono::milliseconds(120));
+  EXPECT_EQ(fmt::format("{:%S}", t6), "01.120");
+
+  auto t7 =
+      sys_time<std::chrono::microseconds>(std::chrono::microseconds(1234567));
+  EXPECT_EQ(fmt::format("{:%S}", t7), "01.234567");
+
+  auto t8 =
+      sys_time<std::chrono::nanoseconds>(std::chrono::nanoseconds(123456789));
+  EXPECT_EQ(fmt::format("{:%S}", t8), "00.123456789");
+
+  auto t9 = std::chrono::time_point_cast<std::chrono::nanoseconds>(
+      std::chrono::system_clock::now());
+  auto t9_sec = std::chrono::time_point_cast<std::chrono::seconds>(t9);
+  auto t9_sub_sec_part = fmt::format("{0:09}", (t9 - t9_sec).count());
+  EXPECT_EQ(fmt::format("{}.{}", strftime_full_utc(t9_sec), t9_sub_sec_part),
+            fmt::format("{:%Y-%m-%d %H:%M:%S}", t9));
+  EXPECT_EQ(fmt::format("{}.{}", strftime_full_utc(t9_sec), t9_sub_sec_part),
+            fmt::format("{:%Y-%m-%d %T}", t9));
+
+  auto t10 =
+      sys_time<std::chrono::milliseconds>(std::chrono::milliseconds(2000));
+  EXPECT_EQ(fmt::format("{:%S}", t10), "02.000");
+
+  auto epoch = sys_time<std::chrono::milliseconds>();
+  auto d = std::chrono::milliseconds(250);
+  EXPECT_EQ(fmt::format("{:%S}", epoch - d), "59.750");
+  EXPECT_EQ(fmt::format("{:%S}", epoch), "00.000");
+  EXPECT_EQ(fmt::format("{:%S}", epoch + d), "00.250");
+}
+
+TEST(chrono_test, glibc_extensions) {
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%0}"), std::chrono::seconds()),
+                   fmt::format_error, "invalid format");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%_}"), std::chrono::seconds()),
+                   fmt::format_error, "invalid format");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:%-}"), std::chrono::seconds()),
+                   fmt::format_error, "invalid format");
+
+  {
+    const auto d = std::chrono::hours(1) + std::chrono::minutes(2) +
+                   std::chrono::seconds(3);
+
+    EXPECT_EQ(fmt::format("{:%I,%H,%M,%S}", d), "01,01,02,03");
+    EXPECT_EQ(fmt::format("{:%0I,%0H,%0M,%0S}", d), "01,01,02,03");
+    EXPECT_EQ(fmt::format("{:%_I,%_H,%_M,%_S}", d), " 1, 1, 2, 3");
+    EXPECT_EQ(fmt::format("{:%-I,%-H,%-M,%-S}", d), "1,1,2,3");
+
+    EXPECT_EQ(fmt::format("{:%OI,%OH,%OM,%OS}", d), "01,01,02,03");
+    EXPECT_EQ(fmt::format("{:%0OI,%0OH,%0OM,%0OS}", d), "01,01,02,03");
+    EXPECT_EQ(fmt::format("{:%_OI,%_OH,%_OM,%_OS}", d), " 1, 1, 2, 3");
+    EXPECT_EQ(fmt::format("{:%-OI,%-OH,%-OM,%-OS}", d), "1,1,2,3");
+  }
+
+  {
+    const auto tm = make_tm(1970, 1, 1, 1, 2, 3);
+    EXPECT_EQ(fmt::format("{:%I,%H,%M,%S}", tm), "01,01,02,03");
+    EXPECT_EQ(fmt::format("{:%0I,%0H,%0M,%0S}", tm), "01,01,02,03");
+    EXPECT_EQ(fmt::format("{:%_I,%_H,%_M,%_S}", tm), " 1, 1, 2, 3");
+    EXPECT_EQ(fmt::format("{:%-I,%-H,%-M,%-S}", tm), "1,1,2,3");
+
+    EXPECT_EQ(fmt::format("{:%OI,%OH,%OM,%OS}", tm), "01,01,02,03");
+    EXPECT_EQ(fmt::format("{:%0OI,%0OH,%0OM,%0OS}", tm), "01,01,02,03");
+    EXPECT_EQ(fmt::format("{:%_OI,%_OH,%_OM,%_OS}", tm), " 1, 1, 2, 3");
+    EXPECT_EQ(fmt::format("{:%-OI,%-OH,%-OM,%-OS}", tm), "1,1,2,3");
+  }
+
+  {
+    const auto d = std::chrono::seconds(3) + std::chrono::milliseconds(140);
+    EXPECT_EQ(fmt::format("{:%S}", d), "03.140");
+    EXPECT_EQ(fmt::format("{:%0S}", d), "03.140");
+    EXPECT_EQ(fmt::format("{:%_S}", d), " 3.140");
+    EXPECT_EQ(fmt::format("{:%-S}", d), "3.140");
+  }
+
+  {
+    const auto d = std::chrono::duration<double>(3.14);
+    EXPECT_EQ(fmt::format("{:%S}", d), "03.140000");
+    EXPECT_EQ(fmt::format("{:%0S}", d), "03.140000");
+    EXPECT_EQ(fmt::format("{:%_S}", d), " 3.140000");
+    EXPECT_EQ(fmt::format("{:%-S}", d), "3.140000");
+  }
+}
+
+TEST(chrono_test, out_of_range) {
+  auto d = std::chrono::duration<unsigned long, std::giga>(538976288);
+  EXPECT_THROW((void)fmt::format("{:%j}", d), fmt::format_error);
+}
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/color-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/color-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c2ba13a977dba3a7dea69197f9aef3f98ba1b476
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/color-test.cc
@@ -0,0 +1,72 @@
+// Formatting library for C++ - color tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/color.h"
+
+#include <iterator>  // std::back_inserter
+
+#include "gtest-extra.h"  // EXPECT_WRITE
+
+TEST(color_test, format) {
+  EXPECT_EQ(fmt::format(fg(fmt::rgb(255, 20, 30)), "rgb(255,20,30)"),
+            "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m");
+  EXPECT_EQ(fmt::format(fg(fmt::color::blue), "blue"),
+            "\x1b[38;2;000;000;255mblue\x1b[0m");
+  EXPECT_EQ(
+      fmt::format(fg(fmt::color::blue) | bg(fmt::color::red), "two color"),
+      "\x1b[38;2;000;000;255m\x1b[48;2;255;000;000mtwo color\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::bold, "bold"), "\x1b[1mbold\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::faint, "faint"), "\x1b[2mfaint\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::italic, "italic"),
+            "\x1b[3mitalic\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::underline, "underline"),
+            "\x1b[4munderline\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::blink, "blink"), "\x1b[5mblink\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::reverse, "reverse"),
+            "\x1b[7mreverse\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::conceal, "conceal"),
+            "\x1b[8mconceal\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::strikethrough, "strikethrough"),
+            "\x1b[9mstrikethrough\x1b[0m");
+  EXPECT_EQ(
+      fmt::format(fg(fmt::color::blue) | fmt::emphasis::bold, "blue/bold"),
+      "\x1b[1m\x1b[38;2;000;000;255mblue/bold\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::emphasis::bold, "bold error"),
+            "\x1b[1mbold error\x1b[0m");
+  EXPECT_EQ(fmt::format(fg(fmt::color::blue), "blue log"),
+            "\x1b[38;2;000;000;255mblue log\x1b[0m");
+  EXPECT_EQ(fmt::format(fmt::text_style(), "hi"), "hi");
+  EXPECT_EQ(fmt::format(fg(fmt::terminal_color::red), "tred"),
+            "\x1b[31mtred\x1b[0m");
+  EXPECT_EQ(fmt::format(bg(fmt::terminal_color::cyan), "tcyan"),
+            "\x1b[46mtcyan\x1b[0m");
+  EXPECT_EQ(fmt::format(fg(fmt::terminal_color::bright_green), "tbgreen"),
+            "\x1b[92mtbgreen\x1b[0m");
+  EXPECT_EQ(fmt::format(bg(fmt::terminal_color::bright_magenta), "tbmagenta"),
+            "\x1b[105mtbmagenta\x1b[0m");
+  EXPECT_EQ(fmt::format(fg(fmt::terminal_color::red), "{}", "foo"),
+            "\x1b[31mfoo\x1b[0m");
+  EXPECT_EQ(fmt::format("{}{}", fmt::styled("red", fg(fmt::color::red)),
+                        fmt::styled("bold", fmt::emphasis::bold)),
+            "\x1b[38;2;255;000;000mred\x1b[0m\x1b[1mbold\x1b[0m");
+  EXPECT_EQ(fmt::format("{}", fmt::styled("bar", fg(fmt::color::blue) |
+                                                     fmt::emphasis::underline)),
+            "\x1b[4m\x1b[38;2;000;000;255mbar\x1b[0m");
+}
+
+TEST(color_test, format_to) {
+  auto out = std::string();
+  fmt::format_to(std::back_inserter(out), fg(fmt::rgb(255, 20, 30)),
+                 "rgb(255,20,30){}{}{}", 1, 2, 3);
+  EXPECT_EQ(fmt::to_string(out),
+            "\x1b[38;2;255;020;030mrgb(255,20,30)123\x1b[0m");
+}
+
+TEST(color_test, print) {
+  EXPECT_WRITE(stdout, fmt::print(fg(fmt::rgb(255, 20, 30)), "rgb(255,20,30)"),
+               "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m");
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/compile-error-test/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/compile-error-test/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c4a160688d4c2c12e59f3bfb8dfd9f4710e3f048
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/compile-error-test/CMakeLists.txt
@@ -0,0 +1,241 @@
+# Test if compile errors are produced where necessary.
+
+cmake_minimum_required(VERSION 3.8...3.25)
+project(compile-error-test CXX)
+
+set(fmt_headers "
+  #include <fmt/format.h>
+  #include <fmt/xchar.h>
+  #include <fmt/ostream.h>
+  #include <iostream>
+")
+
+set(error_test_names "")
+set(non_error_test_content "")
+
+# For error tests (we expect them to produce compilation error):
+#  * adds a name of test into `error_test_names` list
+#  * generates a single source file (with the same name) for each test
+# For non-error tests (we expect them to compile successfully):
+#  * adds a code segment as separate function to `non_error_test_content`
+function (expect_compile name code_fragment)
+  cmake_parse_arguments(EXPECT_COMPILE "ERROR" "" "" ${ARGN})
+  string(MAKE_C_IDENTIFIER "${name}" test_name)
+
+  if (EXPECT_COMPILE_ERROR)
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/test/${test_name}.cc" "
+      ${fmt_headers}
+      void ${test_name}() {
+        ${code_fragment}
+      }
+    ")
+    set(error_test_names_copy "${error_test_names}")
+    list(APPEND error_test_names_copy "${test_name}")
+    set(error_test_names "${error_test_names_copy}" PARENT_SCOPE)
+  else()
+    set(non_error_test_content "
+      ${non_error_test_content}
+      void ${test_name}() {
+        ${code_fragment}
+      }" PARENT_SCOPE)
+  endif()
+endfunction ()
+
+# Generates a source file for non-error test with `non_error_test_content` and
+# CMake project file with all error and single non-error test targets.
+function (run_tests)
+  set(cmake_targets "")
+  foreach(test_name IN LISTS error_test_names)
+    set(cmake_targets "
+      ${cmake_targets}
+      add_library(test-${test_name} ${test_name}.cc)
+      target_link_libraries(test-${test_name} PRIVATE fmt::fmt)
+    ")
+  endforeach()
+
+  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/test/non_error_test.cc" "
+    ${fmt_headers}
+    ${non_error_test_content}
+  ")
+  set(cmake_targets "
+    ${cmake_targets}
+    add_library(non-error-test non_error_test.cc)
+    target_link_libraries(non-error-test PRIVATE fmt::fmt)
+  ")
+
+  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/test/CMakeLists.txt" "
+    cmake_minimum_required(VERSION 3.8...3.25)
+    project(tests CXX)
+    add_subdirectory(${FMT_DIR} fmt)
+    ${cmake_targets}
+  ")
+
+  set(build_directory "${CMAKE_CURRENT_BINARY_DIR}/test/build")
+  file(MAKE_DIRECTORY "${build_directory}")
+  execute_process(
+    COMMAND
+      "${CMAKE_COMMAND}"
+      "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
+      "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
+      "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}"
+      "-DCMAKE_GENERATOR=${CMAKE_GENERATOR}"
+      "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
+      "-DFMT_DIR=${FMT_DIR}"
+      "${CMAKE_CURRENT_BINARY_DIR}/test"
+    WORKING_DIRECTORY "${build_directory}"
+    RESULT_VARIABLE result_var
+    OUTPUT_VARIABLE output_var
+    ERROR_VARIABLE output_var)
+  if (NOT result_var EQUAL 0)
+    message(FATAL_ERROR "Unable to configure:\n${output_var}")
+  endif()
+
+  foreach(test_name IN LISTS error_test_names)
+    execute_process(
+      COMMAND
+        "${CMAKE_COMMAND}" --build "${build_directory}" --target "test-${test_name}"
+      WORKING_DIRECTORY "${build_directory}"
+      RESULT_VARIABLE result_var
+      OUTPUT_VARIABLE output_var
+      ERROR_QUIET)
+    if (result_var EQUAL 0)
+      message(SEND_ERROR "No compile error for \"${test_name}\":\n${output_var}")
+    endif ()
+  endforeach()
+
+  execute_process(
+    COMMAND
+      "${CMAKE_COMMAND}" --build "${build_directory}" --target "non-error-test"
+    WORKING_DIRECTORY "${build_directory}"
+    RESULT_VARIABLE result_var
+    OUTPUT_VARIABLE output_var
+    ERROR_VARIABLE output_var)
+  if (NOT result_var EQUAL 0)
+    message(SEND_ERROR "Compile error for combined non-error test:\n${output_var}")
+  endif ()
+endfunction ()
+
+
+# check if the source file skeleton compiles
+expect_compile(check "")
+expect_compile(check-error "compilation_error" ERROR)
+
+# Formatting a wide character with a narrow format string is forbidden.
+expect_compile(wide-character-narrow-format-string "fmt::format(L\"{}\", L'a');")
+expect_compile(wide-character-narrow-format-string-error "fmt::format(\"{}\", L'a');" ERROR)
+
+# Formatting a wide string with a narrow format string is forbidden.
+expect_compile(wide-string-narrow-format-string "fmt::format(L\"{}\", L\"foo\");")
+expect_compile(wide-string-narrow-format-string-error "fmt::format(\"{}\", L\"foo\");" ERROR)
+
+# Formatting a narrow string with a wide format string is forbidden because
+# mixing UTF-8 with UTF-16/32 can result in an invalid output.
+expect_compile(narrow-string-wide-format-string "fmt::format(L\"{}\", L\"foo\");")
+expect_compile(narrow-string-wide-format-string-error "fmt::format(L\"{}\", \"foo\");" ERROR)
+
+expect_compile(cast-to-string "
+  struct S {
+    operator std::string() const { return std::string(); }
+  };
+  fmt::format(\"{}\", std::string(S()));
+")
+expect_compile(cast-to-string-error "
+  struct S {
+    operator std::string() const { return std::string(); }
+  };
+  fmt::format(\"{}\", S());
+" ERROR)
+
+# Formatting a function
+expect_compile(format-function "
+  void (*f)();
+  fmt::format(\"{}\", fmt::ptr(f));
+")
+expect_compile(format-function-error "
+  void (*f)();
+  fmt::format(\"{}\", f);
+" ERROR)
+
+# Formatting an unformattable argument should always be a compile time error
+expect_compile(format-lots-of-arguments-with-unformattable "
+  struct E {};
+  fmt::format(\"\", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, E());
+" ERROR)
+expect_compile(format-lots-of-arguments-with-function "
+  void (*f)();
+  fmt::format(\"\", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, f);
+" ERROR)
+
+# Check if user-defined literals are available
+include(CheckCXXSourceCompiles)
+set(CMAKE_REQUIRED_FLAGS ${CXX_STANDARD_FLAG})
+check_cxx_source_compiles("
+  void operator\"\" _udl(long double);
+  int main() {}"
+  SUPPORTS_USER_DEFINED_LITERALS)
+set(CMAKE_REQUIRED_FLAGS )
+if (NOT SUPPORTS_USER_DEFINED_LITERALS)
+  set (SUPPORTS_USER_DEFINED_LITERALS OFF)
+endif ()
+
+# Make sure that compiler features detected in the header
+# match the features detected in CMake.
+if (SUPPORTS_USER_DEFINED_LITERALS)
+  set(supports_udl 1)
+else ()
+  set(supports_udl 0)
+endif ()
+expect_compile(udl-check "
+  #if FMT_USE_USER_DEFINED_LITERALS != ${supports_udl}
+  # error
+  #endif
+")
+
+if (CMAKE_CXX_STANDARD GREATER_EQUAL 20)
+  # Compile-time argument type check
+  expect_compile(format-string-number-spec "
+    #ifdef FMT_HAS_CONSTEVAL
+      fmt::format(\"{:d}\", 42);
+    #endif
+  ")
+  expect_compile(format-string-number-spec-error "
+    #ifdef FMT_HAS_CONSTEVAL
+      fmt::format(\"{:d}\", \"I am not a number\");
+    #else
+      #error
+    #endif
+  " ERROR)
+  expect_compile(print-string-number-spec-error "
+    #ifdef FMT_HAS_CONSTEVAL
+      fmt::print(\"{:d}\", \"I am not a number\");
+    #else
+      #error
+    #endif
+  " ERROR)
+  expect_compile(print-stream-string-number-spec-error "
+  #ifdef FMT_HAS_CONSTEVAL
+    fmt::print(std::cout, \"{:d}\", \"I am not a number\");
+  #else
+    #error
+  #endif
+  " ERROR)
+
+  # Compile-time argument name check
+  expect_compile(format-string-name "
+    #if defined(FMT_HAS_CONSTEVAL) && FMT_USE_NONTYPE_TEMPLATE_ARGS
+      using namespace fmt::literals;
+      fmt::print(\"{foo}\", \"foo\"_a=42);
+    #endif
+  ")
+  expect_compile(format-string-name-error "
+    #if defined(FMT_HAS_CONSTEVAL) && FMT_USE_NONTYPE_TEMPLATE_ARGS
+      using namespace fmt::literals;
+      fmt::print(\"{foo}\", \"bar\"_a=42);
+    #else
+      #error
+    #endif
+  " ERROR)
+endif ()
+
+# Run all tests
+run_tests()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/compile-fp-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/compile-fp-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5b46d74bcd0ca44e9dd8e3a8a7b8d561205e10e2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/compile-fp-test.cc
@@ -0,0 +1,63 @@
+// Formatting library for C++ - formatting library tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/compile.h"
+#include "gmock/gmock.h"
+
+#if defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806 && \
+    defined(__cpp_constexpr) && __cpp_constexpr >= 201907 &&       \
+    defined(__cpp_constexpr_dynamic_alloc) &&                      \
+    __cpp_constexpr_dynamic_alloc >= 201907 && FMT_CPLUSPLUS >= 202002L
+
+template <size_t max_string_length, typename Char = char> struct test_string {
+  template <typename T> constexpr bool operator==(const T& rhs) const noexcept {
+    return fmt::basic_string_view<Char>(rhs).compare(buffer) == 0;
+  }
+  Char buffer[max_string_length]{};
+};
+
+template <size_t max_string_length, typename Char = char, typename... Args>
+consteval auto test_format(auto format, const Args&... args) {
+  test_string<max_string_length, Char> string{};
+  fmt::format_to(string.buffer, format, args...);
+  return string;
+}
+
+TEST(compile_time_formatting_test, floating_point) {
+  EXPECT_EQ("0", test_format<2>(FMT_COMPILE("{}"), 0.0f));
+  EXPECT_EQ("392.500000", test_format<11>(FMT_COMPILE("{0:f}"), 392.5f));
+
+  EXPECT_EQ("0", test_format<2>(FMT_COMPILE("{:}"), 0.0));
+  EXPECT_EQ("0.000000", test_format<9>(FMT_COMPILE("{:f}"), 0.0));
+  EXPECT_EQ("0", test_format<2>(FMT_COMPILE("{:g}"), 0.0));
+  EXPECT_EQ("392.65", test_format<7>(FMT_COMPILE("{:}"), 392.65));
+  EXPECT_EQ("392.65", test_format<7>(FMT_COMPILE("{:g}"), 392.65));
+  EXPECT_EQ("392.65", test_format<7>(FMT_COMPILE("{:G}"), 392.65));
+  EXPECT_EQ("4.9014e+06", test_format<11>(FMT_COMPILE("{:g}"), 4.9014e6));
+  EXPECT_EQ("-392.650000", test_format<12>(FMT_COMPILE("{:f}"), -392.65));
+  EXPECT_EQ("-392.650000", test_format<12>(FMT_COMPILE("{:F}"), -392.65));
+
+  EXPECT_EQ("3.926500e+02", test_format<13>(FMT_COMPILE("{0:e}"), 392.65));
+  EXPECT_EQ("3.926500E+02", test_format<13>(FMT_COMPILE("{0:E}"), 392.65));
+  EXPECT_EQ("+0000392.6", test_format<11>(FMT_COMPILE("{0:+010.4g}"), 392.65));
+  EXPECT_EQ("9223372036854775808.000000",
+            test_format<27>(FMT_COMPILE("{:f}"), 9223372036854775807.0));
+
+  constexpr double nan = std::numeric_limits<double>::quiet_NaN();
+  EXPECT_EQ("nan", test_format<4>(FMT_COMPILE("{}"), nan));
+  EXPECT_EQ("+nan", test_format<5>(FMT_COMPILE("{:+}"), nan));
+  if (std::signbit(-nan))
+    EXPECT_EQ("-nan", test_format<5>(FMT_COMPILE("{}"), -nan));
+  else
+    fmt::print("Warning: compiler doesn't handle negative NaN correctly");
+
+  constexpr double inf = std::numeric_limits<double>::infinity();
+  EXPECT_EQ("inf", test_format<4>(FMT_COMPILE("{}"), inf));
+  EXPECT_EQ("+inf", test_format<5>(FMT_COMPILE("{:+}"), inf));
+  EXPECT_EQ("-inf", test_format<5>(FMT_COMPILE("{}"), -inf));
+}
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/compile-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/compile-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8551303efce3842c17e43321f8f3a10855b61ab5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/compile-test.cc
@@ -0,0 +1,377 @@
+// Formatting library for C++ - formatting library tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/compile.h"
+
+#include <type_traits>
+
+#include "fmt/chrono.h"
+#include "gmock/gmock.h"
+#include "gtest-extra.h"
+
+TEST(iterator_test, counting_iterator) {
+  auto it = fmt::detail::counting_iterator();
+  auto prev = it++;
+  EXPECT_EQ(prev.count(), 0);
+  EXPECT_EQ(it.count(), 1);
+  EXPECT_EQ((it + 41).count(), 42);
+}
+
+TEST(compile_test, compile_fallback) {
+  // FMT_COMPILE should fallback on runtime formatting when `if constexpr` is
+  // not available.
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42));
+}
+
+struct type_with_get {
+  template <int> friend void get(type_with_get);
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<type_with_get> : formatter<int> {
+  template <typename FormatContext>
+  auto format(type_with_get, FormatContext& ctx) -> decltype(ctx.out()) {
+    return formatter<int>::format(42, ctx);
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(compile_test, compile_type_with_get) {
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), type_with_get()));
+}
+
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+struct test_formattable {};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<test_formattable> : formatter<const char*> {
+  char word_spec = 'f';
+  constexpr auto parse(format_parse_context& ctx) {
+    auto it = ctx.begin(), end = ctx.end();
+    if (it == end || *it == '}') return it;
+    if (it != end && (*it == 'f' || *it == 'b')) word_spec = *it++;
+    if (it != end && *it != '}') throw format_error("invalid format");
+    return it;
+  }
+  template <typename FormatContext>
+  constexpr auto format(test_formattable, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return formatter<const char*>::format(word_spec == 'f' ? "foo" : "bar",
+                                          ctx);
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(compile_test, format_default) {
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42));
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42u));
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ll));
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ull));
+  EXPECT_EQ("true", fmt::format(FMT_COMPILE("{}"), true));
+  EXPECT_EQ("x", fmt::format(FMT_COMPILE("{}"), 'x'));
+  EXPECT_EQ("4.2", fmt::format(FMT_COMPILE("{}"), 4.2));
+  EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), "foo"));
+  EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), std::string("foo")));
+  EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), test_formattable()));
+  auto t = std::chrono::system_clock::now();
+  EXPECT_EQ(fmt::format("{}", t), fmt::format(FMT_COMPILE("{}"), t));
+#  ifdef __cpp_lib_byte
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), std::byte{42}));
+#  endif
+}
+
+TEST(compile_test, format_wide_string) {
+  EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{}"), 42));
+}
+
+TEST(compile_test, format_specs) {
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{:x}"), 0x42));
+  EXPECT_EQ("1.2 ms ",
+            fmt::format(FMT_COMPILE("{:7.1%Q %q}"),
+                        std::chrono::duration<double, std::milli>(1.234)));
+}
+
+TEST(compile_test, dynamic_format_specs) {
+  EXPECT_EQ("foo  ", fmt::format(FMT_COMPILE("{:{}}"), "foo", 5));
+  EXPECT_EQ("  3.14", fmt::format(FMT_COMPILE("{:{}.{}f}"), 3.141592, 6, 2));
+  EXPECT_EQ(
+      "=1.234ms=",
+      fmt::format(FMT_COMPILE("{:=^{}.{}}"),
+                  std::chrono::duration<double, std::milli>(1.234), 9, 3));
+}
+
+TEST(compile_test, manual_ordering) {
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{0}"), 42));
+  EXPECT_EQ(" -42", fmt::format(FMT_COMPILE("{0:4}"), -42));
+  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {1}"), 41, 43));
+  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{1} {0}"), 43, 41));
+  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {2}"), 41, 42, 43));
+  EXPECT_EQ("  41   43", fmt::format(FMT_COMPILE("{1:{2}} {0:4}"), 43, 41, 4));
+  EXPECT_EQ("42 1.2 ms ",
+            fmt::format(FMT_COMPILE("{0} {1:7.1%Q %q}"), 42,
+                        std::chrono::duration<double, std::milli>(1.234)));
+  EXPECT_EQ(
+      "true 42 42 foo 0x1234 foo",
+      fmt::format(FMT_COMPILE("{0} {1} {2} {3} {4} {5}"), true, 42, 42.0f,
+                  "foo", reinterpret_cast<void*>(0x1234), test_formattable()));
+  EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{0}"), 42));
+}
+
+TEST(compile_test, named) {
+  auto runtime_named_field_compiled =
+      fmt::detail::compile<decltype(fmt::arg("arg", 42))>(FMT_COMPILE("{arg}"));
+  static_assert(std::is_same_v<decltype(runtime_named_field_compiled),
+                               fmt::detail::runtime_named_field<char>>);
+
+  EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), fmt::arg("arg", 42)));
+  EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{} {}"), fmt::arg("arg", 41),
+                                 fmt::arg("arg", 43)));
+
+  EXPECT_EQ("foobar",
+            fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a0", "foo"),
+                        fmt::arg("a1", "bar")));
+  EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{}{a1}"), fmt::arg("a0", "foo"),
+                                  fmt::arg("a1", "bar")));
+  EXPECT_EQ("foofoo", fmt::format(FMT_COMPILE("{a0}{}"), fmt::arg("a0", "foo"),
+                                  fmt::arg("a1", "bar")));
+  EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{0}{a1}"), fmt::arg("a0", "foo"),
+                                  fmt::arg("a1", "bar")));
+  EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{a0}{1}"), fmt::arg("a0", "foo"),
+                                  fmt::arg("a1", "bar")));
+
+  EXPECT_EQ("foobar",
+            fmt::format(FMT_COMPILE("{}{a1}"), "foo", fmt::arg("a1", "bar")));
+  EXPECT_EQ("foobar",
+            fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a1", "bar"),
+                        fmt::arg("a2", "baz"), fmt::arg("a0", "foo")));
+  EXPECT_EQ(" bar foo ",
+            fmt::format(FMT_COMPILE(" {foo} {bar} "), fmt::arg("foo", "bar"),
+                        fmt::arg("bar", "foo")));
+
+  EXPECT_THROW(fmt::format(FMT_COMPILE("{invalid}"), fmt::arg("valid", 42)),
+               fmt::format_error);
+
+#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
+  using namespace fmt::literals;
+  auto statically_named_field_compiled =
+      fmt::detail::compile<decltype("arg"_a = 42)>(FMT_COMPILE("{arg}"));
+  static_assert(std::is_same_v<decltype(statically_named_field_compiled),
+                               fmt::detail::field<char, int, 0>>);
+
+  EXPECT_EQ("41 43",
+            fmt::format(FMT_COMPILE("{a0} {a1}"), "a0"_a = 41, "a1"_a = 43));
+  EXPECT_EQ("41 43",
+            fmt::format(FMT_COMPILE("{a1} {a0}"), "a0"_a = 43, "a1"_a = 41));
+#  endif
+}
+
+TEST(compile_test, join) {
+  unsigned char data[] = {0x1, 0x2, 0xaf};
+  EXPECT_EQ("0102af", fmt::format(FMT_COMPILE("{:02x}"), fmt::join(data, "")));
+}
+
+TEST(compile_test, format_to) {
+  char buf[8];
+  auto end = fmt::format_to(buf, FMT_COMPILE("{}"), 42);
+  *end = '\0';
+  EXPECT_STREQ("42", buf);
+  end = fmt::format_to(buf, FMT_COMPILE("{:x}"), 42);
+  *end = '\0';
+  EXPECT_STREQ("2a", buf);
+}
+
+TEST(compile_test, format_to_n) {
+  constexpr auto buffer_size = 8;
+  char buffer[buffer_size];
+  auto res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{}"), 42);
+  *res.out = '\0';
+  EXPECT_STREQ("42", buffer);
+  res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{:x}"), 42);
+  *res.out = '\0';
+  EXPECT_STREQ("2a", buffer);
+}
+
+#  ifdef __cpp_lib_bit_cast
+TEST(compile_test, constexpr_formatted_size) {
+  FMT_CONSTEXPR20 size_t size = fmt::formatted_size(FMT_COMPILE("{}"), 42);
+  EXPECT_EQ(size, 2);
+  FMT_CONSTEXPR20 size_t hex_size =
+      fmt::formatted_size(FMT_COMPILE("{:x}"), 15);
+  EXPECT_EQ(hex_size, 1);
+  FMT_CONSTEXPR20 size_t binary_size =
+      fmt::formatted_size(FMT_COMPILE("{:b}"), 15);
+  EXPECT_EQ(binary_size, 4);
+  FMT_CONSTEXPR20 size_t padded_size =
+      fmt::formatted_size(FMT_COMPILE("{:*^6}"), 42);
+  EXPECT_EQ(padded_size, 6);
+  FMT_CONSTEXPR20 size_t float_size =
+      fmt::formatted_size(FMT_COMPILE("{:.3}"), 12.345);
+  EXPECT_EQ(float_size, 4);
+  FMT_CONSTEXPR20 size_t str_size =
+      fmt::formatted_size(FMT_COMPILE("{:s}"), "abc");
+  EXPECT_EQ(str_size, 3);
+}
+#  endif
+
+TEST(compile_test, text_and_arg) {
+  EXPECT_EQ(">>>42<<<", fmt::format(FMT_COMPILE(">>>{}<<<"), 42));
+  EXPECT_EQ("42!", fmt::format(FMT_COMPILE("{}!"), 42));
+}
+
+TEST(compile_test, unknown_format_fallback) {
+  EXPECT_EQ(" 42 ",
+            fmt::format(FMT_COMPILE("{name:^4}"), fmt::arg("name", 42)));
+
+  std::vector<char> v;
+  fmt::format_to(std::back_inserter(v), FMT_COMPILE("{name:^4}"),
+                 fmt::arg("name", 42));
+  EXPECT_EQ(" 42 ", fmt::string_view(v.data(), v.size()));
+
+  char buffer[4];
+  auto result = fmt::format_to_n(buffer, 4, FMT_COMPILE("{name:^5}"),
+                                 fmt::arg("name", 42));
+  EXPECT_EQ(5u, result.size);
+  EXPECT_EQ(buffer + 4, result.out);
+  EXPECT_EQ(" 42 ", fmt::string_view(buffer, 4));
+}
+
+TEST(compile_test, empty) { EXPECT_EQ("", fmt::format(FMT_COMPILE(""))); }
+
+struct to_stringable {
+  friend fmt::string_view to_string_view(to_stringable) { return {}; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<to_stringable> {
+  auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const to_stringable&, FormatContext& ctx) -> decltype(ctx.out()) {
+    return ctx.out();
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(compile_test, to_string_and_formatter) {
+  fmt::format(FMT_COMPILE("{}"), to_stringable());
+}
+
+TEST(compile_test, print) {
+  EXPECT_WRITE(stdout, fmt::print(FMT_COMPILE("Don't {}!"), "panic"),
+               "Don't panic!");
+  EXPECT_WRITE(stderr, fmt::print(stderr, FMT_COMPILE("Don't {}!"), "panic"),
+               "Don't panic!");
+}
+#endif
+
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+TEST(compile_test, compile_format_string_literal) {
+  using namespace fmt::literals;
+  EXPECT_EQ("", fmt::format(""_cf));
+  EXPECT_EQ("42", fmt::format("{}"_cf, 42));
+  EXPECT_EQ(L"42", fmt::format(L"{}"_cf, 42));
+}
+#endif
+
+// MSVS 2019 19.29.30145.0 - Support C++20 and OK.
+// MSVS 2022 19.32.31332.0, 19.37.32826.1 - compile-test.cc(362,3): fatal error
+// C1001: Internal compiler error.
+//  (compiler file
+//  'D:\a\_work\1\s\src\vctools\Compiler\CxxFE\sl\p1\c\constexpr\constexpr.cpp',
+//  line 8635)
+#if (FMT_CPLUSPLUS >= 202002L ||                                \
+     (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002)) &&  \
+    ((!defined(_GLIBCXX_RELEASE) || _GLIBCXX_RELEASE >= 10) &&  \
+     (!defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 10000) && \
+     (!FMT_MSC_VERSION ||                                       \
+      (FMT_MSC_VERSION >= 1928 && FMT_MSC_VERSION < 1930))) &&  \
+    defined(__cpp_lib_is_constant_evaluated)
+template <size_t max_string_length, typename Char = char> struct test_string {
+  template <typename T> constexpr bool operator==(const T& rhs) const noexcept {
+    return fmt::basic_string_view<Char>(rhs).compare(buffer) == 0;
+  }
+  Char buffer[max_string_length]{};
+};
+
+template <size_t max_string_length, typename Char = char, typename... Args>
+consteval auto test_format(auto format, const Args&... args) {
+  test_string<max_string_length, Char> string{};
+  fmt::format_to(string.buffer, format, args...);
+  return string;
+}
+
+TEST(compile_time_formatting_test, bool) {
+  EXPECT_EQ("true", test_format<5>(FMT_COMPILE("{}"), true));
+  EXPECT_EQ("false", test_format<6>(FMT_COMPILE("{}"), false));
+  EXPECT_EQ("true ", test_format<6>(FMT_COMPILE("{:5}"), true));
+  EXPECT_EQ("1", test_format<2>(FMT_COMPILE("{:d}"), true));
+}
+
+TEST(compile_time_formatting_test, integer) {
+  EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), 42));
+  EXPECT_EQ("420", test_format<4>(FMT_COMPILE("{}"), 420));
+  EXPECT_EQ("42 42", test_format<6>(FMT_COMPILE("{} {}"), 42, 42));
+  EXPECT_EQ("42 42",
+            test_format<6>(FMT_COMPILE("{} {}"), uint32_t{42}, uint64_t{42}));
+
+  EXPECT_EQ("+42", test_format<4>(FMT_COMPILE("{:+}"), 42));
+  EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{:-}"), 42));
+  EXPECT_EQ(" 42", test_format<4>(FMT_COMPILE("{: }"), 42));
+
+  EXPECT_EQ("-0042", test_format<6>(FMT_COMPILE("{:05}"), -42));
+
+  EXPECT_EQ("101010", test_format<7>(FMT_COMPILE("{:b}"), 42));
+  EXPECT_EQ("0b101010", test_format<9>(FMT_COMPILE("{:#b}"), 42));
+  EXPECT_EQ("0B101010", test_format<9>(FMT_COMPILE("{:#B}"), 42));
+  EXPECT_EQ("042", test_format<4>(FMT_COMPILE("{:#o}"), 042));
+  EXPECT_EQ("0x4a", test_format<5>(FMT_COMPILE("{:#x}"), 0x4a));
+  EXPECT_EQ("0X4A", test_format<5>(FMT_COMPILE("{:#X}"), 0x4a));
+
+  EXPECT_EQ("   42", test_format<6>(FMT_COMPILE("{:5}"), 42));
+  EXPECT_EQ("   42", test_format<6>(FMT_COMPILE("{:5}"), 42ll));
+  EXPECT_EQ("   42", test_format<6>(FMT_COMPILE("{:5}"), 42ull));
+
+  EXPECT_EQ("42  ", test_format<5>(FMT_COMPILE("{:<4}"), 42));
+  EXPECT_EQ("  42", test_format<5>(FMT_COMPILE("{:>4}"), 42));
+  EXPECT_EQ(" 42 ", test_format<5>(FMT_COMPILE("{:^4}"), 42));
+  EXPECT_EQ("**-42", test_format<6>(FMT_COMPILE("{:*>5}"), -42));
+}
+
+TEST(compile_time_formatting_test, char) {
+  EXPECT_EQ("c", test_format<2>(FMT_COMPILE("{}"), 'c'));
+
+  EXPECT_EQ("c  ", test_format<4>(FMT_COMPILE("{:3}"), 'c'));
+  EXPECT_EQ("99", test_format<3>(FMT_COMPILE("{:d}"), 'c'));
+}
+
+TEST(compile_time_formatting_test, string) {
+  EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), "42"));
+  EXPECT_EQ("The answer is 42",
+            test_format<17>(FMT_COMPILE("{} is {}"), "The answer", "42"));
+
+  EXPECT_EQ("abc**", test_format<6>(FMT_COMPILE("{:*<5}"), "abc"));
+  EXPECT_EQ("**🤡**", test_format<9>(FMT_COMPILE("{:*^6}"), "🤡"));
+}
+
+TEST(compile_time_formatting_test, combination) {
+  EXPECT_EQ("420, true, answer",
+            test_format<18>(FMT_COMPILE("{}, {}, {}"), 420, true, "answer"));
+
+  EXPECT_EQ(" -42", test_format<5>(FMT_COMPILE("{:{}}"), -42, 4));
+}
+
+TEST(compile_time_formatting_test, custom_type) {
+  EXPECT_EQ("foo", test_format<4>(FMT_COMPILE("{}"), test_formattable()));
+  EXPECT_EQ("bar", test_format<4>(FMT_COMPILE("{:b}"), test_formattable()));
+}
+
+TEST(compile_time_formatting_test, multibyte_fill) {
+  EXPECT_EQ("жж42", test_format<8>(FMT_COMPILE("{:ж>4}"), 42));
+}
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/core-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/core-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1d84ffd774660609202efa6facda2f2846bce43e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/core-test.cc
@@ -0,0 +1,858 @@
+// Formatting library for C++ - core tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+// clang-format off
+#include "test-assert.h"
+// clang-format on
+
+#include "fmt/core.h"
+
+#include <algorithm>    // std::copy_n
+#include <climits>      // INT_MAX
+#include <cstring>      // std::strlen
+#include <functional>   // std::equal_to
+#include <iterator>     // std::back_insert_iterator
+#include <limits>       // std::numeric_limits
+#include <string>       // std::string
+#include <type_traits>  // std::is_same
+
+#include "gmock/gmock.h"
+
+using fmt::string_view;
+using fmt::detail::buffer;
+
+using testing::_;
+using testing::Invoke;
+using testing::Return;
+
+#ifdef FMT_FORMAT_H_
+#  error core-test includes format.h
+#endif
+
+TEST(string_view_test, value_type) {
+  static_assert(std::is_same<string_view::value_type, char>::value, "");
+}
+
+TEST(string_view_test, ctor) {
+  EXPECT_STREQ("abc", fmt::string_view("abc").data());
+  EXPECT_EQ(3u, fmt::string_view("abc").size());
+
+  EXPECT_STREQ("defg", fmt::string_view(std::string("defg")).data());
+  EXPECT_EQ(4u, fmt::string_view(std::string("defg")).size());
+}
+
+TEST(string_view_test, length) {
+  // Test that string_view::size() returns string length, not buffer size.
+  char str[100] = "some string";
+  EXPECT_EQ(std::strlen(str), string_view(str).size());
+  EXPECT_LT(std::strlen(str), sizeof(str));
+}
+
+// Check string_view's comparison operator.
+template <template <typename> class Op> void check_op() {
+  const char* inputs[] = {"foo", "fop", "fo"};
+  size_t num_inputs = sizeof(inputs) / sizeof(*inputs);
+  for (size_t i = 0; i < num_inputs; ++i) {
+    for (size_t j = 0; j < num_inputs; ++j) {
+      string_view lhs(inputs[i]), rhs(inputs[j]);
+      EXPECT_EQ(Op<int>()(lhs.compare(rhs), 0), Op<string_view>()(lhs, rhs));
+    }
+  }
+}
+
+TEST(string_view_test, compare) {
+  EXPECT_EQ(string_view("foo").compare(string_view("foo")), 0);
+  EXPECT_GT(string_view("fop").compare(string_view("foo")), 0);
+  EXPECT_LT(string_view("foo").compare(string_view("fop")), 0);
+  EXPECT_GT(string_view("foo").compare(string_view("fo")), 0);
+  EXPECT_LT(string_view("fo").compare(string_view("foo")), 0);
+
+  EXPECT_TRUE(string_view("foo").starts_with('f'));
+  EXPECT_FALSE(string_view("foo").starts_with('o'));
+  EXPECT_FALSE(string_view().starts_with('o'));
+
+  EXPECT_TRUE(string_view("foo").starts_with("fo"));
+  EXPECT_TRUE(string_view("foo").starts_with("foo"));
+  EXPECT_FALSE(string_view("foo").starts_with("fooo"));
+  EXPECT_FALSE(string_view().starts_with("fooo"));
+
+  check_op<std::equal_to>();
+  check_op<std::not_equal_to>();
+  check_op<std::less>();
+  check_op<std::less_equal>();
+  check_op<std::greater>();
+  check_op<std::greater_equal>();
+}
+
+TEST(core_test, is_output_iterator) {
+  EXPECT_TRUE((fmt::detail::is_output_iterator<char*, char>::value));
+  EXPECT_FALSE((fmt::detail::is_output_iterator<const char*, char>::value));
+  EXPECT_FALSE((fmt::detail::is_output_iterator<std::string, char>::value));
+  EXPECT_TRUE(
+      (fmt::detail::is_output_iterator<std::back_insert_iterator<std::string>,
+                                       char>::value));
+  EXPECT_TRUE(
+      (fmt::detail::is_output_iterator<std::string::iterator, char>::value));
+  EXPECT_FALSE((fmt::detail::is_output_iterator<std::string::const_iterator,
+                                                char>::value));
+}
+
+TEST(core_test, buffer_appender) {
+  // back_insert_iterator is not default-constructible before C++20, so
+  // buffer_appender can only be default-constructible when back_insert_iterator
+  // is.
+  static_assert(
+      std::is_default_constructible<
+          std::back_insert_iterator<fmt::detail::buffer<char>>>::value ==
+          std::is_default_constructible<
+              fmt::detail::buffer_appender<char>>::value,
+      "");
+
+#ifdef __cpp_lib_ranges
+  static_assert(std::output_iterator<fmt::detail::buffer_appender<char>, char>);
+#endif
+}
+
+#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 470
+TEST(buffer_test, noncopyable) {
+  EXPECT_FALSE(std::is_copy_constructible<buffer<char>>::value);
+#  if !FMT_MSC_VERSION
+  // std::is_copy_assignable is broken in MSVC2013.
+  EXPECT_FALSE(std::is_copy_assignable<buffer<char>>::value);
+#  endif
+}
+
+TEST(buffer_test, nonmoveable) {
+  EXPECT_FALSE(std::is_move_constructible<buffer<char>>::value);
+#  if !FMT_MSC_VERSION
+  // std::is_move_assignable is broken in MSVC2013.
+  EXPECT_FALSE(std::is_move_assignable<buffer<char>>::value);
+#  endif
+}
+#endif
+
+TEST(buffer_test, indestructible) {
+  static_assert(!std::is_destructible<fmt::detail::buffer<int>>(),
+                "buffer's destructor is protected");
+}
+
+template <typename T> struct mock_buffer final : buffer<T> {
+  MOCK_METHOD(size_t, do_grow, (size_t));
+
+  void grow(size_t capacity) override {
+    this->set(this->data(), do_grow(capacity));
+  }
+
+  mock_buffer(T* data = nullptr, size_t buf_capacity = 0) {
+    this->set(data, buf_capacity);
+    ON_CALL(*this, do_grow(_)).WillByDefault(Invoke([](size_t capacity) {
+      return capacity;
+    }));
+  }
+};
+
+TEST(buffer_test, ctor) {
+  {
+    mock_buffer<int> buffer;
+    EXPECT_EQ(nullptr, buffer.data());
+    EXPECT_EQ(static_cast<size_t>(0), buffer.size());
+    EXPECT_EQ(static_cast<size_t>(0), buffer.capacity());
+  }
+  {
+    int dummy;
+    mock_buffer<int> buffer(&dummy);
+    EXPECT_EQ(&dummy, &buffer[0]);
+    EXPECT_EQ(static_cast<size_t>(0), buffer.size());
+    EXPECT_EQ(static_cast<size_t>(0), buffer.capacity());
+  }
+  {
+    int dummy;
+    size_t capacity = std::numeric_limits<size_t>::max();
+    mock_buffer<int> buffer(&dummy, capacity);
+    EXPECT_EQ(&dummy, &buffer[0]);
+    EXPECT_EQ(static_cast<size_t>(0), buffer.size());
+    EXPECT_EQ(capacity, buffer.capacity());
+  }
+}
+
+TEST(buffer_test, access) {
+  char data[10];
+  mock_buffer<char> buffer(data, sizeof(data));
+  buffer[0] = 11;
+  EXPECT_EQ(11, buffer[0]);
+  buffer[3] = 42;
+  EXPECT_EQ(42, *(&buffer[0] + 3));
+  const fmt::detail::buffer<char>& const_buffer = buffer;
+  EXPECT_EQ(42, const_buffer[3]);
+}
+
+TEST(buffer_test, try_resize) {
+  char data[123];
+  mock_buffer<char> buffer(data, sizeof(data));
+  buffer[10] = 42;
+  EXPECT_EQ(42, buffer[10]);
+  buffer.try_resize(20);
+  EXPECT_EQ(20u, buffer.size());
+  EXPECT_EQ(123u, buffer.capacity());
+  EXPECT_EQ(42, buffer[10]);
+  buffer.try_resize(5);
+  EXPECT_EQ(5u, buffer.size());
+  EXPECT_EQ(123u, buffer.capacity());
+  EXPECT_EQ(42, buffer[10]);
+  // Check if try_resize calls grow.
+  EXPECT_CALL(buffer, do_grow(124));
+  buffer.try_resize(124);
+  EXPECT_CALL(buffer, do_grow(200));
+  buffer.try_resize(200);
+}
+
+TEST(buffer_test, try_resize_partial) {
+  char data[10];
+  mock_buffer<char> buffer(data, sizeof(data));
+  EXPECT_CALL(buffer, do_grow(20)).WillOnce(Return(15));
+  buffer.try_resize(20);
+  EXPECT_EQ(buffer.capacity(), 15);
+  EXPECT_EQ(buffer.size(), 15);
+}
+
+TEST(buffer_test, clear) {
+  mock_buffer<char> buffer;
+  EXPECT_CALL(buffer, do_grow(20));
+  buffer.try_resize(20);
+  buffer.try_resize(0);
+  EXPECT_EQ(static_cast<size_t>(0), buffer.size());
+  EXPECT_EQ(20u, buffer.capacity());
+}
+
+TEST(buffer_test, append) {
+  char data[15];
+  mock_buffer<char> buffer(data, 10);
+  auto test = "test";
+  buffer.append(test, test + 5);
+  EXPECT_STREQ(test, &buffer[0]);
+  EXPECT_EQ(5u, buffer.size());
+  buffer.try_resize(10);
+  EXPECT_CALL(buffer, do_grow(12));
+  buffer.append(test, test + 2);
+  EXPECT_EQ('t', buffer[10]);
+  EXPECT_EQ('e', buffer[11]);
+  EXPECT_EQ(12u, buffer.size());
+}
+
+TEST(buffer_test, append_partial) {
+  char data[10];
+  mock_buffer<char> buffer(data, sizeof(data));
+  testing::InSequence seq;
+  EXPECT_CALL(buffer, do_grow(15)).WillOnce(Return(10));
+  EXPECT_CALL(buffer, do_grow(15)).WillOnce(Invoke([&buffer](size_t) {
+    EXPECT_EQ(fmt::string_view(buffer.data(), buffer.size()), "0123456789");
+    buffer.clear();
+    return 10;
+  }));
+  auto test = "0123456789abcde";
+  buffer.append(test, test + 15);
+}
+
+TEST(buffer_test, append_allocates_enough_storage) {
+  char data[19];
+  mock_buffer<char> buffer(data, 10);
+  auto test = "abcdefgh";
+  buffer.try_resize(10);
+  EXPECT_CALL(buffer, do_grow(19));
+  buffer.append(test, test + 9);
+}
+
+struct custom_context {
+  using char_type = char;
+  using parse_context_type = fmt::format_parse_context;
+
+  bool called = false;
+
+  template <typename T> struct formatter_type {
+    FMT_CONSTEXPR auto parse(fmt::format_parse_context& ctx) -> decltype(ctx.begin()) {
+      return ctx.begin();
+    }
+
+    const char* format(const T&, custom_context& ctx) {
+      ctx.called = true;
+      return nullptr;
+    }
+  };
+
+  void advance_to(const char*) {}
+};
+
+struct test_struct {};
+
+FMT_BEGIN_NAMESPACE
+template <typename Char> struct formatter<test_struct, Char> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  auto format(test_struct, format_context& ctx) const -> decltype(ctx.out()) {
+    auto test = string_view("test");
+    return std::copy_n(test.data(), test.size(), ctx.out());
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(arg_test, format_args) {
+  auto args = fmt::format_args();
+  EXPECT_FALSE(args.get(1));
+}
+
+TEST(arg_test, make_value_with_custom_context) {
+  auto t = test_struct();
+  auto arg = fmt::detail::value<custom_context>(
+      fmt::detail::arg_mapper<custom_context>().map(t));
+  auto ctx = custom_context();
+  auto parse_ctx = fmt::format_parse_context("");
+  arg.custom.format(&t, parse_ctx, ctx);
+  EXPECT_TRUE(ctx.called);
+}
+
+// Use a unique result type to make sure that there are no undesirable
+// conversions.
+struct test_result {};
+
+template <typename T> struct mock_visitor {
+  template <typename U> struct result { using type = test_result; };
+
+  mock_visitor() {
+    ON_CALL(*this, visit(_)).WillByDefault(Return(test_result()));
+  }
+
+  MOCK_METHOD(test_result, visit, (T));
+  MOCK_METHOD(void, unexpected, ());
+
+  auto operator()(T value) -> test_result { return visit(value); }
+
+  template <typename U> auto operator()(U) -> test_result {
+    unexpected();
+    return test_result();
+  }
+};
+
+template <typename T> struct visit_type { using type = T; };
+
+#define VISIT_TYPE(type_, visit_type_) \
+  template <> struct visit_type<type_> { using type = visit_type_; }
+
+VISIT_TYPE(signed char, int);
+VISIT_TYPE(unsigned char, unsigned);
+VISIT_TYPE(short, int);
+VISIT_TYPE(unsigned short, unsigned);
+
+#if LONG_MAX == INT_MAX
+VISIT_TYPE(long, int);
+VISIT_TYPE(unsigned long, unsigned);
+#else
+VISIT_TYPE(long, long long);
+VISIT_TYPE(unsigned long, unsigned long long);
+#endif
+
+#define CHECK_ARG(Char, expected, value)                                  \
+  {                                                                       \
+    testing::StrictMock<mock_visitor<decltype(expected)>> visitor;        \
+    EXPECT_CALL(visitor, visit(expected));                                \
+    using iterator = std::back_insert_iterator<buffer<Char>>;             \
+    auto var = value;                                                     \
+    fmt::visit_format_arg(                                                \
+        visitor,                                                          \
+        fmt::detail::make_arg<fmt::basic_format_context<iterator, Char>>( \
+            var));                                                        \
+  }
+
+#define CHECK_ARG_SIMPLE(value)                             \
+  {                                                         \
+    using value_type = decltype(value);                     \
+    typename visit_type<value_type>::type expected = value; \
+    CHECK_ARG(char, expected, value)                        \
+    CHECK_ARG(wchar_t, expected, value)                     \
+  }
+
+template <typename T> class numeric_arg_test : public testing::Test {};
+
+using test_types =
+    testing::Types<bool, signed char, unsigned char, short, unsigned short, int,
+                   unsigned, long, unsigned long, long long, unsigned long long,
+                   float, double, long double>;
+TYPED_TEST_SUITE(numeric_arg_test, test_types);
+
+template <typename T, fmt::enable_if_t<std::is_integral<T>::value, int> = 0>
+auto test_value() -> T {
+  return static_cast<T>(42);
+}
+
+template <typename T,
+          fmt::enable_if_t<std::is_floating_point<T>::value, int> = 0>
+auto test_value() -> T {
+  return static_cast<T>(4.2);
+}
+
+TYPED_TEST(numeric_arg_test, make_and_visit) {
+  CHECK_ARG_SIMPLE(test_value<TypeParam>());
+  CHECK_ARG_SIMPLE(std::numeric_limits<TypeParam>::min());
+  CHECK_ARG_SIMPLE(std::numeric_limits<TypeParam>::max());
+}
+
+TEST(arg_test, char_arg) { CHECK_ARG(char, 'a', 'a'); }
+
+TEST(arg_test, string_arg) {
+  char str_data[] = "test";
+  char* str = str_data;
+  const char* cstr = str;
+  CHECK_ARG(char, cstr, str);
+
+  auto sv = fmt::string_view(str);
+  CHECK_ARG(char, sv, std::string(str));
+}
+
+TEST(arg_test, wstring_arg) {
+  wchar_t str_data[] = L"test";
+  wchar_t* str = str_data;
+  const wchar_t* cstr = str;
+
+  auto sv = fmt::basic_string_view<wchar_t>(str);
+  CHECK_ARG(wchar_t, cstr, str);
+  CHECK_ARG(wchar_t, cstr, cstr);
+  CHECK_ARG(wchar_t, sv, std::wstring(str));
+  CHECK_ARG(wchar_t, sv, fmt::basic_string_view<wchar_t>(str));
+}
+
+TEST(arg_test, pointer_arg) {
+  void* p = nullptr;
+  const void* cp = nullptr;
+  CHECK_ARG(char, cp, p);
+  CHECK_ARG(wchar_t, cp, p);
+  CHECK_ARG_SIMPLE(cp);
+}
+
+struct check_custom {
+  auto operator()(fmt::basic_format_arg<fmt::format_context>::handle h) const
+      -> test_result {
+    struct test_buffer final : fmt::detail::buffer<char> {
+      char data[10];
+      test_buffer() : fmt::detail::buffer<char>(data, 0, 10) {}
+      void grow(size_t) override {}
+    } buffer;
+    auto parse_ctx = fmt::format_parse_context("");
+    auto ctx = fmt::format_context(fmt::detail::buffer_appender<char>(buffer),
+                                   fmt::format_args());
+    h.format(parse_ctx, ctx);
+    EXPECT_EQ("test", std::string(buffer.data, buffer.size()));
+    return test_result();
+  }
+};
+
+TEST(arg_test, custom_arg) {
+  auto test = test_struct();
+  using visitor =
+      mock_visitor<fmt::basic_format_arg<fmt::format_context>::handle>;
+  auto&& v = testing::StrictMock<visitor>();
+  EXPECT_CALL(v, visit(_)).WillOnce(Invoke(check_custom()));
+  fmt::visit_format_arg(v, fmt::detail::make_arg<fmt::format_context>(test));
+}
+
+TEST(arg_test, visit_invalid_arg) {
+  auto&& visitor = testing::StrictMock<mock_visitor<fmt::monostate>>();
+  EXPECT_CALL(visitor, visit(_));
+  auto arg = fmt::basic_format_arg<fmt::format_context>();
+  fmt::visit_format_arg(visitor, arg);
+}
+
+#if FMT_USE_CONSTEXPR
+
+enum class arg_id_result { none, empty, index, name };
+struct test_arg_id_handler {
+  arg_id_result res = arg_id_result::none;
+  int index = 0;
+  string_view name;
+
+  constexpr void on_auto() { res = arg_id_result::empty; }
+
+  constexpr void on_index(int i) {
+    res = arg_id_result::index;
+    index = i;
+  }
+
+  constexpr void on_name(string_view n) {
+    res = arg_id_result::name;
+    name = n;
+  }
+};
+
+template <size_t N>
+constexpr test_arg_id_handler parse_arg_id(const char (&s)[N]) {
+  auto h = test_arg_id_handler();
+  fmt::detail::parse_arg_id(s, s + N, h);
+  return h;
+}
+
+TEST(core_test, constexpr_parse_arg_id) {
+  static_assert(parse_arg_id(":").res == arg_id_result::empty, "");
+  static_assert(parse_arg_id("}").res == arg_id_result::empty, "");
+  static_assert(parse_arg_id("42:").res == arg_id_result::index, "");
+  static_assert(parse_arg_id("42:").index == 42, "");
+  static_assert(parse_arg_id("foo:").res == arg_id_result::name, "");
+  static_assert(parse_arg_id("foo:").name.size() == 3, "");
+}
+
+template <size_t N> constexpr auto parse_test_specs(const char (&s)[N]) {
+  auto ctx = fmt::detail::compile_parse_context<char>(fmt::string_view(s, N),
+                                                      43, nullptr);
+  auto specs = fmt::detail::dynamic_format_specs<>();
+  fmt::detail::parse_format_specs(s, s + N - 1, specs, ctx,
+                                  fmt::detail::type::float_type);
+  return specs;
+}
+
+TEST(core_test, constexpr_parse_format_specs) {
+  static_assert(parse_test_specs("<").align == fmt::align::left, "");
+  static_assert(parse_test_specs("*^").fill[0] == '*', "");
+  static_assert(parse_test_specs("+").sign == fmt::sign::plus, "");
+  static_assert(parse_test_specs("-").sign == fmt::sign::minus, "");
+  static_assert(parse_test_specs(" ").sign == fmt::sign::space, "");
+  static_assert(parse_test_specs("#").alt, "");
+  static_assert(parse_test_specs("0").align == fmt::align::numeric, "");
+  static_assert(parse_test_specs("L").localized, "");
+  static_assert(parse_test_specs("42").width == 42, "");
+  static_assert(parse_test_specs("{42}").width_ref.val.index == 42, "");
+  static_assert(parse_test_specs(".42").precision == 42, "");
+  static_assert(parse_test_specs(".{42}").precision_ref.val.index == 42, "");
+  static_assert(
+      parse_test_specs("f").type == fmt::presentation_type::fixed_lower, "");
+}
+
+struct test_format_string_handler {
+  constexpr void on_text(const char*, const char*) {}
+
+  constexpr auto on_arg_id() -> int { return 0; }
+
+  template <typename T> constexpr auto on_arg_id(T) -> int { return 0; }
+
+  constexpr void on_replacement_field(int, const char*) {}
+
+  constexpr auto on_format_specs(int, const char* begin, const char*) -> const
+      char* {
+    return begin;
+  }
+
+  constexpr void on_error(const char*) { error = true; }
+
+  bool error = false;
+};
+
+template <size_t N> constexpr bool parse_string(const char (&s)[N]) {
+  auto h = test_format_string_handler();
+  fmt::detail::parse_format_string<true>(fmt::string_view(s, N - 1), h);
+  return !h.error;
+}
+
+TEST(core_test, constexpr_parse_format_string) {
+  static_assert(parse_string("foo"), "");
+  static_assert(!parse_string("}"), "");
+  static_assert(parse_string("{}"), "");
+  static_assert(parse_string("{42}"), "");
+  static_assert(parse_string("{foo}"), "");
+  static_assert(parse_string("{:}"), "");
+}
+#endif  // FMT_USE_CONSTEXPR
+
+struct enabled_formatter {};
+struct enabled_ptr_formatter {};
+struct disabled_formatter {};
+struct disabled_formatter_convertible {
+  operator int() const { return 42; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<enabled_formatter> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+  auto format(enabled_formatter, format_context& ctx) const
+      -> decltype(ctx.out()) {
+    return ctx.out();
+  }
+};
+
+template <> struct formatter<enabled_ptr_formatter*> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+  auto format(enabled_ptr_formatter*, format_context& ctx) const
+      -> decltype(ctx.out()) {
+    return ctx.out();
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(core_test, has_formatter) {
+  using fmt::has_formatter;
+  using context = fmt::format_context;
+  static_assert(has_formatter<enabled_formatter, context>::value, "");
+  static_assert(!has_formatter<disabled_formatter, context>::value, "");
+  static_assert(!has_formatter<disabled_formatter_convertible, context>::value,
+                "");
+}
+
+struct const_formattable {};
+struct nonconst_formattable {};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<const_formattable> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  auto format(const const_formattable&, format_context& ctx)
+      -> decltype(ctx.out()) {
+    auto test = string_view("test");
+    return std::copy_n(test.data(), test.size(), ctx.out());
+  }
+};
+
+template <> struct formatter<nonconst_formattable> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  auto format(nonconst_formattable&, format_context& ctx)
+      -> decltype(ctx.out()) {
+    auto test = string_view("test");
+    return std::copy_n(test.data(), test.size(), ctx.out());
+  }
+};
+FMT_END_NAMESPACE
+
+struct convertible_to_pointer {
+  operator const int*() const { return nullptr; }
+};
+
+struct convertible_to_pointer_formattable {
+  operator const int*() const { return nullptr; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<convertible_to_pointer_formattable> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  auto format(convertible_to_pointer_formattable, format_context& ctx) const
+      -> decltype(ctx.out()) {
+    auto test = string_view("test");
+    return std::copy_n(test.data(), test.size(), ctx.out());
+  }
+};
+FMT_END_NAMESPACE
+
+enum class unformattable_scoped_enum {};
+
+TEST(core_test, is_formattable) {
+  static_assert(!fmt::is_formattable<wchar_t>::value, "");
+#ifdef __cpp_char8_t
+  static_assert(!fmt::is_formattable<char8_t>::value, "");
+#endif
+  static_assert(!fmt::is_formattable<char16_t>::value, "");
+  static_assert(!fmt::is_formattable<char32_t>::value, "");
+  static_assert(!fmt::is_formattable<signed char*>::value, "");
+  static_assert(!fmt::is_formattable<unsigned char*>::value, "");
+  static_assert(!fmt::is_formattable<const signed char*>::value, "");
+  static_assert(!fmt::is_formattable<const unsigned char*>::value, "");
+  static_assert(!fmt::is_formattable<const wchar_t*>::value, "");
+  static_assert(!fmt::is_formattable<const wchar_t[3]>::value, "");
+  static_assert(!fmt::is_formattable<fmt::basic_string_view<wchar_t>>::value,
+                "");
+  static_assert(fmt::is_formattable<enabled_formatter>::value, "");
+  static_assert(!fmt::is_formattable<enabled_ptr_formatter*>::value, "");
+  static_assert(!fmt::is_formattable<disabled_formatter>::value, "");
+  static_assert(!fmt::is_formattable<disabled_formatter_convertible>::value,
+                "");
+
+  static_assert(fmt::is_formattable<const_formattable&>::value, "");
+  static_assert(fmt::is_formattable<const const_formattable&>::value, "");
+
+  static_assert(fmt::is_formattable<nonconst_formattable&>::value, "");
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
+  static_assert(!fmt::is_formattable<const nonconst_formattable&>::value, "");
+#endif
+
+  static_assert(!fmt::is_formattable<convertible_to_pointer>::value, "");
+  const auto f = convertible_to_pointer_formattable();
+  EXPECT_EQ(fmt::format("{}", f), "test");
+
+  static_assert(!fmt::is_formattable<void (*)()>::value, "");
+
+  struct s;
+  static_assert(!fmt::is_formattable<int(s::*)>::value, "");
+  static_assert(!fmt::is_formattable<int (s::*)()>::value, "");
+  static_assert(!fmt::is_formattable<unformattable_scoped_enum>::value, "");
+  static_assert(!fmt::is_formattable<unformattable_scoped_enum>::value, "");
+}
+
+TEST(core_test, format) { EXPECT_EQ(fmt::format("{}", 42), "42"); }
+
+TEST(core_test, format_to) {
+  auto s = std::string();
+  fmt::format_to(std::back_inserter(s), "{}", 42);
+  EXPECT_EQ(s, "42");
+}
+
+#ifdef __cpp_lib_byte
+TEST(core_test, format_byte) {
+  EXPECT_EQ(fmt::format("{}", std::byte(42)), "42");
+}
+#endif
+
+struct convertible_to_int {
+  operator int() const { return 42; }
+};
+
+struct convertible_to_cstring {
+  operator const char*() const { return "foo"; }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<convertible_to_int> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+  auto format(convertible_to_int, format_context& ctx) const
+      -> decltype(ctx.out()) {
+    return std::copy_n("foo", 3, ctx.out());
+  }
+};
+
+template <> struct formatter<convertible_to_cstring> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+  auto format(convertible_to_cstring, format_context& ctx) const
+      -> decltype(ctx.out()) {
+    return std::copy_n("bar", 3, ctx.out());
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(core_test, formatter_overrides_implicit_conversion) {
+  EXPECT_EQ(fmt::format("{}", convertible_to_int()), "foo");
+  EXPECT_EQ(fmt::format("{}", convertible_to_cstring()), "bar");
+}
+
+// Test that check is not found by ADL.
+template <typename T> void check(T);
+TEST(core_test, adl_check) {
+  EXPECT_EQ(fmt::format("{}", test_struct()), "test");
+}
+
+struct implicitly_convertible_to_string_view {
+  operator fmt::string_view() const { return "foo"; }
+};
+
+TEST(core_test, no_implicit_conversion_to_string_view) {
+  EXPECT_FALSE(
+      fmt::is_formattable<implicitly_convertible_to_string_view>::value);
+}
+
+#ifdef FMT_USE_STRING_VIEW
+struct implicitly_convertible_to_std_string_view {
+  operator std::string_view() const { return "foo"; }
+};
+
+TEST(core_test, no_implicit_conversion_to_std_string_view) {
+  EXPECT_FALSE(
+      fmt::is_formattable<implicitly_convertible_to_std_string_view>::value);
+}
+#endif
+
+// std::is_constructible is broken in MSVC until version 2015.
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1900
+struct explicitly_convertible_to_string_view {
+  explicit operator fmt::string_view() const { return "foo"; }
+};
+
+TEST(core_test, format_explicitly_convertible_to_string_view) {
+  // Types explicitly convertible to string_view are not formattable by
+  // default because it may introduce ODR violations.
+  static_assert(
+      !fmt::is_formattable<explicitly_convertible_to_string_view>::value, "");
+}
+
+#  ifdef FMT_USE_STRING_VIEW
+struct explicitly_convertible_to_std_string_view {
+  explicit operator std::string_view() const { return "foo"; }
+};
+
+TEST(core_test, format_explicitly_convertible_to_std_string_view) {
+  // Types explicitly convertible to string_view are not formattable by
+  // default because it may introduce ODR violations.
+  static_assert(
+      !fmt::is_formattable<explicitly_convertible_to_std_string_view>::value,
+      "");
+}
+#  endif
+#endif
+
+namespace adl_test {
+template <typename... T> void make_format_args(const T&...) = delete;
+
+struct string : std::string {};
+}  // namespace adl_test
+
+// Test that formatting functions compile when make_format_args is found by ADL.
+TEST(core_test, adl) {
+  // Only check compilation and don't run the code to avoid polluting the output
+  // and since the output is tested elsewhere.
+  if (fmt::detail::const_check(true)) return;
+  auto s = adl_test::string();
+  char buf[10];
+  (void)fmt::format("{}", s);
+  fmt::format_to(buf, "{}", s);
+  fmt::format_to_n(buf, 10, "{}", s);
+  (void)fmt::formatted_size("{}", s);
+  fmt::print("{}", s);
+  fmt::print(stdout, "{}", s);
+}
+
+TEST(core_test, has_const_formatter) {
+  EXPECT_TRUE((fmt::detail::has_const_formatter<const_formattable,
+                                                fmt::format_context>()));
+  EXPECT_FALSE((fmt::detail::has_const_formatter<nonconst_formattable,
+                                                 fmt::format_context>()));
+}
+
+TEST(core_test, format_nonconst) {
+  EXPECT_EQ(fmt::format("{}", nonconst_formattable()), "test");
+}
+
+struct its_a_trap {
+  template <typename T> operator T() const {
+    auto v = T();
+    v.x = 42;
+    return v;
+  }
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<its_a_trap> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  auto format(its_a_trap, format_context& ctx) const -> decltype(ctx.out()) {
+    auto s = string_view("42");
+    return std::copy(s.begin(), s.end(), ctx.out());
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(core_test, trappy_conversion) {
+  EXPECT_EQ(fmt::format("{}", its_a_trap()), "42");
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/cuda-test/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/cuda-test/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..be8685b897ec3d3618878b4f28ab10a53831e283
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/cuda-test/CMakeLists.txt
@@ -0,0 +1,73 @@
+# We can find some usecases which follow the guide of CMake which uses
+# `enable_language(CUDA)` instead of `find_package(CUDA)` and let the CMake
+# built-in functions use NVCC.
+
+# See: https://cmake.org/cmake/help/latest/module/FindCUDA.html#replacement
+#
+# However, this requires CMake version 3.10 or higher and we can't be sure most
+# of the CUDA projects are using those.
+#
+# This test relies on `find_package(CUDA)` in the parent CMake config.
+
+# These can be updated when NVCC becomes ready for C++ 17 features
+# https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#cpp14-language-features
+set(CMAKE_CUDA_STANDARD 14)
+set(CMAKE_CUDA_STANDARD_REQUIRED 14)
+
+# In this test, we assume that the user is going to compile CUDA source code
+# with some libraries (fmt in this case).
+#
+# In addition to that, this test invokes both the C++ host compiler and NVCC
+# by providing another (non-CUDA) C++ source code.
+if (${CMAKE_VERSION} VERSION_LESS 3.15)
+  # https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html
+  list(APPEND CUDA_NVCC_FLAGS "-std=c++14")
+  if (MSVC)
+    # This is the solution of pytorch:
+    # https://github.com/pytorch/pytorch/pull/7118
+    list(APPEND CUDA_NVCC_FLAGS "-Xcompiler" "/std:c++14")
+    list(APPEND CUDA_NVCC_FLAGS "-Xcompiler" "/Zc:__cplusplus")
+    # for the reason of this -Xcompiler options, see below.
+  endif ()
+  cuda_add_executable(fmt-in-cuda-test cuda-cpp14.cu cpp14.cc)
+  target_compile_features(fmt-in-cuda-test PRIVATE cxx_std_14)
+  if (MSVC)
+    # This part is for (non-CUDA) C++ code. MSVC can define incorrect
+    # `__cplusplus` macro. Fix for the issue is to use additional compiler flag. 
+    #
+    # See Also:
+    # https://devblogs.microsoft.com/cppblog/msvc-now-correctly-reports-__cplusplus/
+    # https://github.com/Microsoft/vscode-cpptools/issues/2595
+    target_compile_options(fmt-in-cuda-test PRIVATE /Zc:__cplusplus /permissive-)
+  endif ()
+else()
+  # now using a "new" way of handling CUDA
+  add_executable(fmt-in-cuda-test cuda-cpp14.cu cpp14.cc)
+  set_target_properties(fmt-in-cuda-test PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+  target_compile_features(fmt-in-cuda-test PRIVATE cxx_std_14)
+  if (MSVC)
+    # with MSVC, 'cxx_std_14' will only propagate to the host code (MSVC), but will
+    # not set __cplusplus correctly anyway, while nvcc will ignore it.
+    # If specified for nvcc on the command line as '-std=c++14' nvcc will emit this
+    # message instead:
+    # nvcc warning : The -std=c++14 flag is not supported with the configured host
+    #                compiler. Flag will be ignored.
+    set_property(SOURCE cuda-cpp14.cu APPEND PROPERTY
+      COMPILE_OPTIONS -Xcompiler /std:c++14 -Xcompiler /Zc:__cplusplus)
+    set_property(SOURCE cpp14.cc APPEND PROPERTY
+      COMPILE_OPTIONS /std:c++14 /Zc:__cplusplus)
+  endif()
+endif()
+
+get_target_property(IN_USE_CUDA_STANDARD fmt-in-cuda-test CUDA_STANDARD)
+message(STATUS "cuda_standard:          ${IN_USE_CUDA_STANDARD}")
+
+get_target_property(IN_USE_CUDA_STANDARD_REQUIRED
+    fmt-in-cuda-test CUDA_STANDARD_REQUIRED)
+message(STATUS "cuda_standard_required: ${IN_USE_CUDA_STANDARD_REQUIRED}")
+
+# We don't use PUBLIC or other keyword for reasons explained in the
+# CUDA_LINK_LIBRARIES_KEYWORD section in
+# https://cmake.org/cmake/help/latest/module/FindCUDA.html
+target_link_libraries(fmt-in-cuda-test fmt::fmt)
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/cuda-test/cpp14.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/cuda-test/cpp14.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ad8463962f58200df35eacbc897d4b9d1c3aeed0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/cuda-test/cpp14.cc
@@ -0,0 +1,11 @@
+#include <fmt/core.h>
+
+// The purpose of this part is to ensure NVCC's host compiler also supports
+// the standard version. See 'cuda-cpp14.cu'.
+//
+// https://en.cppreference.com/w/cpp/preprocessor/replace#Predefined_macros
+static_assert(__cplusplus >= 201402L, "expect C++ 2014 for host compiler");
+
+auto make_message_cpp() -> std::string {
+  return fmt::format("host compiler \t: __cplusplus == {}", __cplusplus);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/cuda-test/cuda-cpp14.cu b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/cuda-test/cuda-cpp14.cu
new file mode 100644
index 0000000000000000000000000000000000000000..76a9d08836f6c6a3fa1c64e28bd43cae0392fc93
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/cuda-test/cuda-cpp14.cu
@@ -0,0 +1,28 @@
+//  Direct NVCC command line example:
+//
+//  nvcc ./cuda-cpp14.cu -x cu -I"../include" -l"fmtd" -L"../build/Debug" \
+//       -std=c++14 -Xcompiler /std:c++14 -Xcompiler /Zc:__cplusplus
+
+// Ensure that we are using the latest C++ standard for NVCC
+// The version is C++14
+//
+// https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#c-cplusplus-language-support
+// https://en.cppreference.com/w/cpp/preprocessor/replace#Predefined_macros
+static_assert(__cplusplus >= 201402L, "expect C++ 2014 for nvcc");
+
+#include <fmt/core.h>
+
+#include <cuda.h>
+#include <iostream>
+
+extern auto make_message_cpp() -> std::string;
+extern auto make_message_cuda() -> std::string;
+
+int main() {
+  std::cout << make_message_cuda() << std::endl;
+  std::cout << make_message_cpp() << std::endl;
+}
+
+auto make_message_cuda() -> std::string {
+  return fmt::format("nvcc compiler \t: __cplusplus == {}", __cplusplus);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/detect-stdfs.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/detect-stdfs.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2dc6653830abca6db2cf461c990b34fd909aeabc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/detect-stdfs.cc
@@ -0,0 +1,18 @@
+// Formatting library for C++ - tests of formatters for standard library types
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <exception>  // _GLIBCXX_RELEASE & _LIBCPP_VERSION
+
+#if defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE == 8
+#  error libfound "stdc++fs"
+#elif !defined(__apple_build_version__) && defined(_LIBCPP_VERSION) && \
+    _LIBCPP_VERSION >= 7000 && _LIBCPP_VERSION < 9000
+#  error libfound "c++fs"
+#else
+// none if std::filesystem does not require additional libraries
+#  error libfound ""
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/enforce-checks-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/enforce-checks-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..960a7fcda10a8fd2bd4f44153d2c521dc2d93dbe
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/enforce-checks-test.cc
@@ -0,0 +1,65 @@
+// Formatting library for C++ - formatting library tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <iterator>
+#include <vector>
+
+#define I 42  // simulate https://en.cppreference.com/w/c/numeric/complex/I
+#include "fmt/chrono.h"
+#include "fmt/color.h"
+#include "fmt/format.h"
+#include "fmt/ostream.h"
+#include "fmt/ranges.h"
+#include "fmt/xchar.h"
+#undef I
+
+// Exercise the API to verify that everything we expect to can compile.
+void test_format_api() {
+  (void)fmt::format(FMT_STRING("{}"), 42);
+  (void)fmt::format(FMT_STRING(L"{}"), 42);
+  (void)fmt::format(FMT_STRING("noop"));
+
+  (void)fmt::to_string(42);
+  (void)fmt::to_wstring(42);
+
+  std::vector<char> out;
+  fmt::format_to(std::back_inserter(out), FMT_STRING("{}"), 42);
+
+  char buffer[4];
+  fmt::format_to_n(buffer, 3, FMT_STRING("{}"), 12345);
+
+  wchar_t wbuffer[4];
+  fmt::format_to_n(wbuffer, 3, FMT_STRING(L"{}"), 12345);
+}
+
+void test_chrono() {
+  (void)fmt::format(FMT_STRING("{}"), std::chrono::seconds(42));
+  (void)fmt::format(FMT_STRING(L"{}"), std::chrono::seconds(42));
+}
+
+void test_text_style() {
+  fmt::print(fg(fmt::rgb(255, 20, 30)), FMT_STRING("{}"), "rgb(255,20,30)");
+  (void)fmt::format(fg(fmt::rgb(255, 20, 30)), FMT_STRING("{}"),
+                    "rgb(255,20,30)");
+
+  fmt::text_style ts = fg(fmt::rgb(255, 20, 30));
+  std::string out;
+  fmt::format_to(std::back_inserter(out), ts,
+                 FMT_STRING("rgb(255,20,30){}{}{}"), 1, 2, 3);
+}
+
+void test_range() {
+  std::vector<char> hello = {'h', 'e', 'l', 'l', 'o'};
+  (void)fmt::format(FMT_STRING("{}"), hello);
+}
+
+int main() {
+  test_format_api();
+  test_chrono();
+  test_text_style();
+  test_range();
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/find-package-test/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/find-package-test/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eb2ea25f02530f5f004dc77b5f7e4f5715a4bd41
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/find-package-test/CMakeLists.txt
@@ -0,0 +1,17 @@
+cmake_minimum_required(VERSION 3.8...3.25)
+
+project(fmt-test)
+
+find_package(FMT REQUIRED)
+
+add_executable(library-test main.cc)
+target_link_libraries(library-test fmt::fmt)
+target_compile_options(library-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+target_include_directories(library-test PUBLIC SYSTEM .)
+
+if (TARGET fmt::fmt-header-only)
+  add_executable(header-only-test main.cc)
+  target_link_libraries(header-only-test fmt::fmt-header-only)
+  target_compile_options(header-only-test PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+  target_include_directories(header-only-test PUBLIC SYSTEM .)
+endif ()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/find-package-test/main.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/find-package-test/main.cc
new file mode 100644
index 0000000000000000000000000000000000000000..911e0e8d1a74712f171b0fea1b5ef5057c71516a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/find-package-test/main.cc
@@ -0,0 +1,5 @@
+#include "fmt/format.h"
+
+int main(int argc, char** argv) {
+  for (int i = 0; i < argc; ++i) fmt::print("{}: {}\n", i, argv[i]);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/format-impl-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/format-impl-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..eda1f239580242827b2f51ff6a27b94d4d822a57
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/format-impl-test.cc
@@ -0,0 +1,476 @@
+// Formatting library for C++ - formatting library implementation tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <algorithm>
+#include <cstring>
+
+// clang-format off
+#include "test-assert.h"
+// clang-format on
+
+#include "fmt/format.h"
+#include "gmock/gmock.h"
+#include "util.h"
+
+using fmt::detail::bigint;
+using fmt::detail::fp;
+using fmt::detail::max_value;
+
+static_assert(!std::is_copy_constructible<bigint>::value, "");
+static_assert(!std::is_copy_assignable<bigint>::value, "");
+
+TEST(bigint_test, construct) {
+  EXPECT_EQ(fmt::to_string(bigint()), "");
+  EXPECT_EQ(fmt::to_string(bigint(0x42)), "42");
+  EXPECT_EQ(fmt::to_string(bigint(0x123456789abcedf0)), "123456789abcedf0");
+}
+
+TEST(bigint_test, compare) {
+  bigint n1(42);
+  bigint n2(42);
+  EXPECT_EQ(compare(n1, n2), 0);
+  n2 <<= 32;
+  EXPECT_LT(compare(n1, n2), 0);
+  bigint n3(43);
+  EXPECT_LT(compare(n1, n3), 0);
+  EXPECT_GT(compare(n3, n1), 0);
+  bigint n4(42 * 0x100000001);
+  EXPECT_LT(compare(n2, n4), 0);
+  EXPECT_GT(compare(n4, n2), 0);
+}
+
+TEST(bigint_test, add_compare) {
+  EXPECT_LT(
+      add_compare(bigint(0xffffffff), bigint(0xffffffff), bigint(1) <<= 64), 0);
+  EXPECT_LT(add_compare(bigint(1) <<= 32, bigint(1), bigint(1) <<= 96), 0);
+  EXPECT_GT(add_compare(bigint(1) <<= 32, bigint(0), bigint(0xffffffff)), 0);
+  EXPECT_GT(add_compare(bigint(0), bigint(1) <<= 32, bigint(0xffffffff)), 0);
+  EXPECT_GT(add_compare(bigint(42), bigint(1), bigint(42)), 0);
+  EXPECT_GT(add_compare(bigint(0xffffffff), bigint(1), bigint(0xffffffff)), 0);
+  EXPECT_LT(add_compare(bigint(10), bigint(10), bigint(22)), 0);
+  EXPECT_LT(add_compare(bigint(0x100000010), bigint(0x100000010),
+                        bigint(0x300000010)),
+            0);
+  EXPECT_GT(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
+                        bigint(0x300000000)),
+            0);
+  EXPECT_EQ(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
+                        bigint(0x300000001)),
+            0);
+  EXPECT_LT(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
+                        bigint(0x300000002)),
+            0);
+  EXPECT_LT(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
+                        bigint(0x300000003)),
+            0);
+}
+
+TEST(bigint_test, shift_left) {
+  bigint n(0x42);
+  n <<= 0;
+  EXPECT_EQ(fmt::to_string(n), "42");
+  n <<= 1;
+  EXPECT_EQ(fmt::to_string(n), "84");
+  n <<= 25;
+  EXPECT_EQ(fmt::to_string(n), "108000000");
+}
+
+TEST(bigint_test, multiply) {
+  bigint n(0x42);
+  EXPECT_THROW(n *= 0, assertion_failure);
+  n *= 1;
+  EXPECT_EQ(fmt::to_string(n), "42");
+
+  n *= 2;
+  EXPECT_EQ(fmt::to_string(n), "84");
+  n *= 0x12345678;
+  EXPECT_EQ(fmt::to_string(n), "962fc95e0");
+
+  bigint bigmax(max_value<uint32_t>());
+  bigmax *= max_value<uint32_t>();
+  EXPECT_EQ(fmt::to_string(bigmax), "fffffffe00000001");
+
+  const auto max64 = max_value<uint64_t>();
+  bigmax = max64;
+  bigmax *= max64;
+  EXPECT_EQ(fmt::to_string(bigmax), "fffffffffffffffe0000000000000001");
+
+  const auto max128 = (fmt::detail::uint128_t(max64) << 64) | max64;
+  bigmax = max128;
+  bigmax *= max128;
+  EXPECT_EQ(fmt::to_string(bigmax),
+            "fffffffffffffffffffffffffffffffe00000000000000000000000000000001");
+}
+
+TEST(bigint_test, square) {
+  bigint n0(0);
+  n0.square();
+  EXPECT_EQ(fmt::to_string(n0), "0");
+  bigint n1(0x100);
+  n1.square();
+  EXPECT_EQ(fmt::to_string(n1), "10000");
+  bigint n2(0xfffffffff);
+  n2.square();
+  EXPECT_EQ(fmt::to_string(n2), "ffffffffe000000001");
+  bigint n3(max_value<uint64_t>());
+  n3.square();
+  EXPECT_EQ(fmt::to_string(n3), "fffffffffffffffe0000000000000001");
+  bigint n4;
+  n4.assign_pow10(10);
+  EXPECT_EQ(fmt::to_string(n4), "2540be400");
+}
+
+TEST(bigint_test, divmod_assign_zero_divisor) {
+  bigint zero(0);
+  EXPECT_THROW(bigint(0).divmod_assign(zero), assertion_failure);
+  EXPECT_THROW(bigint(42).divmod_assign(zero), assertion_failure);
+}
+
+TEST(bigint_test, divmod_assign_self) {
+  bigint n(100);
+  EXPECT_THROW(n.divmod_assign(n), assertion_failure);
+}
+
+TEST(bigint_test, divmod_assign_unaligned) {
+  // (42 << 340) / pow(10, 100):
+  bigint n1(42);
+  n1 <<= 340;
+  bigint n2;
+  n2.assign_pow10(100);
+  int result = n1.divmod_assign(n2);
+  EXPECT_EQ(result, 9406);
+  EXPECT_EQ(fmt::to_string(n1),
+            "10f8353019583bfc29ffc8f564e1b9f9d819dbb4cf783e4507eca1539220p96");
+}
+
+TEST(bigint_test, divmod_assign) {
+  // 100 / 10:
+  bigint n1(100);
+  int result = n1.divmod_assign(bigint(10));
+  EXPECT_EQ(result, 10);
+  EXPECT_EQ(fmt::to_string(n1), "0");
+  // pow(10, 100) / (42 << 320):
+  n1.assign_pow10(100);
+  result = n1.divmod_assign(bigint(42) <<= 320);
+  EXPECT_EQ(result, 111);
+  EXPECT_EQ(fmt::to_string(n1),
+            "13ad2594c37ceb0b2784c4ce0bf38ace408e211a7caab24308a82e8f10p96");
+  // 42 / 100:
+  bigint n2(42);
+  n1.assign_pow10(2);
+  result = n2.divmod_assign(n1);
+  EXPECT_EQ(result, 0);
+  EXPECT_EQ(fmt::to_string(n2), "2a");
+}
+
+template <bool is_iec559> void run_double_tests() {
+  fmt::print("warning: double is not IEC559, skipping FP tests\n");
+}
+
+template <> void run_double_tests<true>() {
+  // Construct from double.
+  EXPECT_EQ(fp(1.23), fp(0x13ae147ae147aeu, -52));
+}
+
+TEST(fp_test, double_tests) {
+  run_double_tests<std::numeric_limits<double>::is_iec559>();
+}
+
+TEST(fp_test, normalize) {
+  const auto v = fp(0xbeef, 42);
+  auto normalized = normalize(v);
+  EXPECT_EQ(normalized.f, 0xbeef000000000000);
+  EXPECT_EQ(normalized.e, -6);
+}
+
+TEST(fp_test, multiply) {
+  auto v = fp(123ULL << 32, 4) * fp(56ULL << 32, 7);
+  EXPECT_EQ(v.f, 123u * 56u);
+  EXPECT_EQ(v.e, 4 + 7 + 64);
+  v = fp(123ULL << 32, 4) * fp(567ULL << 31, 8);
+  EXPECT_EQ(v.f, (123 * 567 + 1u) / 2);
+  EXPECT_EQ(v.e, 4 + 8 + 64);
+}
+
+TEST(fp_test, dragonbox_max_k) {
+  using fmt::detail::dragonbox::floor_log10_pow2;
+  using float_info = fmt::detail::dragonbox::float_info<float>;
+  EXPECT_EQ(
+      fmt::detail::const_check(float_info::max_k),
+      float_info::kappa -
+          floor_log10_pow2(std::numeric_limits<float>::min_exponent -
+                           fmt::detail::num_significand_bits<float>() - 1));
+  using double_info = fmt::detail::dragonbox::float_info<double>;
+  EXPECT_EQ(fmt::detail::const_check(double_info::max_k),
+            double_info::kappa -
+                floor_log10_pow2(
+                    std::numeric_limits<double>::min_exponent -
+                    2 * fmt::detail::num_significand_bits<double>() - 1));
+}
+
+TEST(format_impl_test, format_error_code) {
+  std::string msg = "error 42", sep = ": ";
+  {
+    auto buffer = fmt::memory_buffer();
+    fmt::format_to(fmt::appender(buffer), "garbage");
+    fmt::detail::format_error_code(buffer, 42, "test");
+    EXPECT_EQ(to_string(buffer), "test: " + msg);
+  }
+  {
+    auto buffer = fmt::memory_buffer();
+    auto prefix =
+        std::string(fmt::inline_buffer_size - msg.size() - sep.size() + 1, 'x');
+    fmt::detail::format_error_code(buffer, 42, prefix);
+    EXPECT_EQ(msg, to_string(buffer));
+  }
+  int codes[] = {42, -1};
+  for (size_t i = 0, n = sizeof(codes) / sizeof(*codes); i < n; ++i) {
+    // Test maximum buffer size.
+    msg = fmt::format("error {}", codes[i]);
+    fmt::memory_buffer buffer;
+    auto prefix =
+        std::string(fmt::inline_buffer_size - msg.size() - sep.size(), 'x');
+    fmt::detail::format_error_code(buffer, codes[i], prefix);
+    EXPECT_EQ(prefix + sep + msg, to_string(buffer));
+    size_t size = fmt::inline_buffer_size;
+    EXPECT_EQ(size, buffer.size());
+    buffer.resize(0);
+    // Test with a message that doesn't fit into the buffer.
+    prefix += 'x';
+    fmt::detail::format_error_code(buffer, codes[i], prefix);
+    EXPECT_EQ(to_string(buffer), msg);
+  }
+}
+
+// Tests fmt::detail::count_digits for integer type Int.
+template <typename Int> void test_count_digits() {
+  for (Int i = 0; i < 10; ++i) EXPECT_EQ(1u, fmt::detail::count_digits(i));
+  for (Int i = 1, n = 1, end = max_value<Int>() / 10; n <= end; ++i) {
+    n *= 10;
+    EXPECT_EQ(fmt::detail::count_digits(n - 1), i);
+    EXPECT_EQ(fmt::detail::count_digits(n), i + 1);
+  }
+}
+
+TEST(format_impl_test, count_digits) {
+  test_count_digits<uint32_t>();
+  test_count_digits<uint64_t>();
+}
+
+TEST(format_impl_test, countl_zero) {
+  constexpr auto num_bits = fmt::detail::num_bits<uint32_t>();
+  uint32_t n = 1u;
+  for (int i = 1; i < num_bits - 1; i++) {
+    n <<= 1;
+    EXPECT_EQ(fmt::detail::countl_zero(n - 1), num_bits - i);
+    EXPECT_EQ(fmt::detail::countl_zero(n), num_bits - i - 1);
+  }
+}
+
+#if FMT_USE_FLOAT128
+TEST(format_impl_test, write_float128) {
+  auto s = std::string();
+  fmt::detail::write<char>(std::back_inserter(s), __float128(42));
+  EXPECT_EQ(s, "42");
+}
+#endif
+
+struct double_double {
+  double a;
+  double b;
+
+  explicit constexpr double_double(double a_val = 0, double b_val = 0)
+      : a(a_val), b(b_val) {}
+
+  operator double() const { return a + b; }
+  auto operator-() const -> double_double { return double_double(-a, -b); }
+};
+
+auto format_as(double_double d) -> double { return d; }
+
+bool operator>=(const double_double& lhs, const double_double& rhs) {
+  return lhs.a + lhs.b >= rhs.a + rhs.b;
+}
+
+struct slow_float {
+  float value;
+
+  explicit constexpr slow_float(float val = 0) : value(val) {}
+  operator float() const { return value; }
+  auto operator-() const -> slow_float { return slow_float(-value); }
+};
+
+auto format_as(slow_float f) -> float { return f; }
+
+namespace std {
+template <> struct is_floating_point<double_double> : std::true_type {};
+template <> struct numeric_limits<double_double> {
+  // is_iec559 is true for double-double in libstdc++.
+  static constexpr bool is_iec559 = true;
+  static constexpr int digits = 106;
+};
+
+template <> struct is_floating_point<slow_float> : std::true_type {};
+template <> struct numeric_limits<slow_float> : numeric_limits<float> {};
+}  // namespace std
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+template <> struct is_fast_float<slow_float> : std::false_type {};
+namespace dragonbox {
+template <> struct float_info<slow_float> {
+  using carrier_uint = uint32_t;
+  static const int exponent_bits = 8;
+};
+}  // namespace dragonbox
+}  // namespace detail
+FMT_END_NAMESPACE
+
+TEST(format_impl_test, write_double_double) {
+  auto s = std::string();
+  fmt::detail::write<char>(std::back_inserter(s), double_double(42), {});
+  // Specializing is_floating_point is broken in MSVC.
+  if (!FMT_MSC_VERSION) EXPECT_EQ(s, "42");
+}
+
+TEST(format_impl_test, write_dragon_even) {
+  auto s = std::string();
+  fmt::detail::write<char>(std::back_inserter(s), slow_float(33554450.0f), {});
+  // Specializing is_floating_point is broken in MSVC.
+  if (!FMT_MSC_VERSION) EXPECT_EQ(s, "33554450");
+}
+
+#if defined(_WIN32) && !defined(FMT_WINDOWS_NO_WCHAR)
+#  include <windows.h>
+
+TEST(format_impl_test, write_console_signature) {
+  decltype(::WriteConsoleW)* p = fmt::detail::WriteConsoleW;
+  (void)p;
+}
+#endif
+
+// A public domain branchless UTF-8 decoder by Christopher Wellons:
+// https://github.com/skeeto/branchless-utf8
+constexpr bool unicode_is_surrogate(uint32_t c) {
+  return c >= 0xD800U && c <= 0xDFFFU;
+}
+
+FMT_CONSTEXPR char* utf8_encode(char* s, uint32_t c) {
+  if (c >= (1UL << 16)) {
+    s[0] = static_cast<char>(0xf0 | (c >> 18));
+    s[1] = static_cast<char>(0x80 | ((c >> 12) & 0x3f));
+    s[2] = static_cast<char>(0x80 | ((c >> 6) & 0x3f));
+    s[3] = static_cast<char>(0x80 | ((c >> 0) & 0x3f));
+    return s + 4;
+  } else if (c >= (1UL << 11)) {
+    s[0] = static_cast<char>(0xe0 | (c >> 12));
+    s[1] = static_cast<char>(0x80 | ((c >> 6) & 0x3f));
+    s[2] = static_cast<char>(0x80 | ((c >> 0) & 0x3f));
+    return s + 3;
+  } else if (c >= (1UL << 7)) {
+    s[0] = static_cast<char>(0xc0 | (c >> 6));
+    s[1] = static_cast<char>(0x80 | ((c >> 0) & 0x3f));
+    return s + 2;
+  } else {
+    s[0] = static_cast<char>(c);
+    return s + 1;
+  }
+}
+
+// Make sure it can decode every character
+TEST(format_impl_test, utf8_decode_decode_all) {
+  for (uint32_t i = 0; i < 0x10ffff; i++) {
+    if (!unicode_is_surrogate(i)) {
+      int e;
+      uint32_t c;
+      char buf[8] = {0};
+      char* end = utf8_encode(buf, i);
+      const char* res = fmt::detail::utf8_decode(buf, &c, &e);
+      EXPECT_EQ(end, res);
+      EXPECT_EQ(c, i);
+      EXPECT_EQ(e, 0);
+    }
+  }
+}
+
+// Reject everything outside of U+0000..U+10FFFF
+TEST(format_impl_test, utf8_decode_out_of_range) {
+  for (uint32_t i = 0x110000; i < 0x1fffff; i++) {
+    int e;
+    uint32_t c;
+    char buf[8] = {0};
+    utf8_encode(buf, i);
+    const char* end = fmt::detail::utf8_decode(buf, &c, &e);
+    EXPECT_NE(e, 0);
+    EXPECT_EQ(end - buf, 4);
+  }
+}
+
+// Does it reject all surrogate halves?
+TEST(format_impl_test, utf8_decode_surrogate_halves) {
+  for (uint32_t i = 0xd800; i <= 0xdfff; i++) {
+    int e;
+    uint32_t c;
+    char buf[8] = {0};
+    utf8_encode(buf, i);
+    fmt::detail::utf8_decode(buf, &c, &e);
+    EXPECT_NE(e, 0);
+  }
+}
+
+// How about non-canonical encodings?
+TEST(format_impl_test, utf8_decode_non_canonical_encodings) {
+  int e;
+  uint32_t c;
+  const char* end;
+
+  char buf2[8] = {char(0xc0), char(0xA4)};
+  end = fmt::detail::utf8_decode(buf2, &c, &e);
+  EXPECT_NE(e, 0);           // non-canonical len 2
+  EXPECT_EQ(end, buf2 + 2);  // non-canonical recover 2
+
+  char buf3[8] = {char(0xe0), char(0x80), char(0xA4)};
+  end = fmt::detail::utf8_decode(buf3, &c, &e);
+  EXPECT_NE(e, 0);           // non-canonical len 3
+  EXPECT_EQ(end, buf3 + 3);  // non-canonical recover 3
+
+  char buf4[8] = {char(0xf0), char(0x80), char(0x80), char(0xA4)};
+  end = fmt::detail::utf8_decode(buf4, &c, &e);
+  EXPECT_NE(e, 0);           // non-canonical encoding len 4
+  EXPECT_EQ(end, buf4 + 4);  // non-canonical recover 4
+}
+
+// Let's try some bogus byte sequences
+TEST(format_impl_test, utf8_decode_bogus_byte_sequences) {
+  int e;
+  uint32_t c;
+
+  // Invalid first byte
+  char buf0[4] = {char(0xff)};
+  auto len = fmt::detail::utf8_decode(buf0, &c, &e) - buf0;
+  EXPECT_NE(e, 0);    // "bogus [ff] 0x%02x U+%04lx", e, (unsigned long)c);
+  EXPECT_EQ(len, 1);  // "bogus [ff] recovery %d", len);
+
+  // Invalid first byte
+  char buf1[4] = {char(0x80)};
+  len = fmt::detail::utf8_decode(buf1, &c, &e) - buf1;
+  EXPECT_NE(e, 0);    // "bogus [80] 0x%02x U+%04lx", e, (unsigned long)c);
+  EXPECT_EQ(len, 1);  // "bogus [80] recovery %d", len);
+
+  // Looks like a two-byte sequence but second byte is wrong
+  char buf2[4] = {char(0xc0), char(0x0a)};
+  len = fmt::detail::utf8_decode(buf2, &c, &e) - buf2;
+  EXPECT_NE(e, 0);    // "bogus [c0 0a] 0x%02x U+%04lx", e, (unsigned long)c
+  EXPECT_EQ(len, 2);  // "bogus [c0 0a] recovery %d", len);
+}
+
+TEST(format_impl_test, to_utf8) {
+  auto s = std::string("ёжик");
+  auto u = fmt::detail::to_utf8<wchar_t>(L"\x0451\x0436\x0438\x043A");
+  EXPECT_EQ(s, u.str());
+  EXPECT_EQ(s.size(), u.size());
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/format-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/format-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..325bef996b9fad36c30ffe3a4a15a9260380fbed
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/format-test.cc
@@ -0,0 +1,2295 @@
+// Formatting library for C++ - formatting library tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+// Check if fmt/format.h compiles with windows.h included before it.
+#ifdef _WIN32
+#  include <windows.h>
+#endif
+// clang-format off
+#include "fmt/format.h"
+// clang-format on
+
+#include <stdint.h>  // uint32_t
+
+#include <climits>      // INT_MAX
+#include <cmath>        // std::signbit
+#include <cstring>      // std::strlen
+#include <iterator>     // std::back_inserter
+#include <list>         // std::list
+#include <memory>       // std::unique_ptr
+#include <type_traits>  // std::is_default_constructible
+
+#include "gtest-extra.h"
+#include "mock-allocator.h"
+#include "util.h"
+
+using fmt::basic_memory_buffer;
+using fmt::format_error;
+using fmt::memory_buffer;
+using fmt::runtime;
+using fmt::string_view;
+using fmt::detail::max_value;
+using fmt::detail::uint128_fallback;
+
+using testing::Return;
+using testing::StrictMock;
+
+enum { buffer_size = 256 };
+
+TEST(uint128_test, ctor) {
+  auto n = uint128_fallback();
+  EXPECT_EQ(n, 0);
+  n = uint128_fallback(42);
+  EXPECT_EQ(n, 42);
+  EXPECT_EQ(static_cast<uint64_t>(n), 42);
+}
+
+TEST(uint128_test, shift) {
+  auto n = uint128_fallback(42);
+  n = n << 64;
+  EXPECT_EQ(static_cast<uint64_t>(n), 0);
+  n = n >> 64;
+  EXPECT_EQ(static_cast<uint64_t>(n), 42);
+  n = n << 62;
+  EXPECT_EQ(static_cast<uint64_t>(n >> 64), 0xa);
+  EXPECT_EQ(static_cast<uint64_t>(n), 0x8000000000000000);
+  n = n >> 62;
+  EXPECT_EQ(static_cast<uint64_t>(n), 42);
+  EXPECT_EQ(uint128_fallback(1) << 112, uint128_fallback(0x1000000000000, 0));
+  EXPECT_EQ(uint128_fallback(0x1000000000000, 0) >> 112, uint128_fallback(1));
+}
+
+TEST(uint128_test, minus) {
+  auto n = uint128_fallback(42);
+  EXPECT_EQ(n - 2, 40);
+}
+
+TEST(uint128_test, plus_assign) {
+  auto n = uint128_fallback(32);
+  n += uint128_fallback(10);
+  EXPECT_EQ(n, 42);
+  n = uint128_fallback(max_value<uint64_t>());
+  n += uint128_fallback(1);
+  EXPECT_EQ(n, uint128_fallback(1) << 64);
+}
+
+TEST(uint128_test, multiply) {
+  auto n = uint128_fallback(2251799813685247);
+  n = n * 3611864890;
+  EXPECT_EQ(static_cast<uint64_t>(n >> 64), 440901);
+}
+
+template <typename Float> void check_isfinite() {
+  using fmt::detail::isfinite;
+  EXPECT_TRUE(isfinite(Float(0.0)));
+  EXPECT_TRUE(isfinite(Float(42.0)));
+  EXPECT_TRUE(isfinite(Float(-42.0)));
+  EXPECT_TRUE(isfinite(Float(fmt::detail::max_value<double>())));
+  // Use double because std::numeric_limits is broken for __float128.
+  using limits = std::numeric_limits<double>;
+  FMT_CONSTEXPR20 auto result = isfinite(Float(limits::infinity()));
+  EXPECT_FALSE(result);
+  EXPECT_FALSE(isfinite(Float(limits::infinity())));
+  EXPECT_FALSE(isfinite(Float(-limits::infinity())));
+  EXPECT_FALSE(isfinite(Float(limits::quiet_NaN())));
+  EXPECT_FALSE(isfinite(Float(-limits::quiet_NaN())));
+}
+
+TEST(float_test, isfinite) {
+  check_isfinite<double>();
+#if FMT_USE_FLOAT128
+  check_isfinite<fmt::detail::float128>();
+#endif
+}
+
+template <typename Float> void check_isnan() {
+  using fmt::detail::isnan;
+  EXPECT_FALSE(isnan(Float(0.0)));
+  EXPECT_FALSE(isnan(Float(42.0)));
+  EXPECT_FALSE(isnan(Float(-42.0)));
+  EXPECT_FALSE(isnan(Float(fmt::detail::max_value<double>())));
+  // Use double because std::numeric_limits is broken for __float128.
+  using limits = std::numeric_limits<double>;
+  EXPECT_FALSE(isnan(Float(limits::infinity())));
+  EXPECT_FALSE(isnan(Float(-limits::infinity())));
+  EXPECT_TRUE(isnan(Float(limits::quiet_NaN())));
+  EXPECT_TRUE(isnan(Float(-limits::quiet_NaN())));
+}
+
+TEST(float_test, isnan) {
+  check_isnan<double>();
+#if FMT_USE_FLOAT128
+  check_isnan<fmt::detail::float128>();
+#endif
+}
+
+struct uint32_pair {
+  uint32_t u[2];
+};
+
+TEST(util_test, bit_cast) {
+  auto s = fmt::detail::bit_cast<uint32_pair>(uint64_t{42});
+  EXPECT_EQ(fmt::detail::bit_cast<uint64_t>(s), 42ull);
+  s = fmt::detail::bit_cast<uint32_pair>(~uint64_t{0});
+  EXPECT_EQ(fmt::detail::bit_cast<uint64_t>(s), ~0ull);
+}
+
+// Increment a number in a string.
+void increment(char* s) {
+  for (int i = static_cast<int>(std::strlen(s)) - 1; i >= 0; --i) {
+    if (s[i] != '9') {
+      ++s[i];
+      break;
+    }
+    s[i] = '0';
+  }
+}
+
+TEST(util_test, increment) {
+  char s[10] = "123";
+  increment(s);
+  EXPECT_STREQ("124", s);
+  s[2] = '8';
+  increment(s);
+  EXPECT_STREQ("129", s);
+  increment(s);
+  EXPECT_STREQ("130", s);
+  s[1] = s[2] = '9';
+  increment(s);
+  EXPECT_STREQ("200", s);
+}
+
+TEST(util_test, parse_nonnegative_int) {
+  auto s = fmt::string_view("10000000000");
+  auto begin = s.begin(), end = s.end();
+  EXPECT_EQ(fmt::detail::parse_nonnegative_int(begin, end, -1), -1);
+  s = "2147483649";
+  begin = s.begin();
+  end = s.end();
+  EXPECT_EQ(fmt::detail::parse_nonnegative_int(begin, end, -1), -1);
+}
+
+TEST(format_impl_test, compute_width) {
+  EXPECT_EQ(fmt::detail::compute_width("вожык"), 5);
+}
+
+TEST(util_test, utf8_to_utf16) {
+  auto u = fmt::detail::utf8_to_utf16("лошадка");
+  EXPECT_EQ(L"\x043B\x043E\x0448\x0430\x0434\x043A\x0430", u.str());
+  EXPECT_EQ(7, u.size());
+  // U+10437 { DESERET SMALL LETTER YEE }
+  EXPECT_EQ(L"\xD801\xDC37", fmt::detail::utf8_to_utf16("𐐷").str());
+  EXPECT_THROW_MSG(fmt::detail::utf8_to_utf16("\xc3\x28"), std::runtime_error,
+                   "invalid utf8");
+  EXPECT_THROW_MSG(fmt::detail::utf8_to_utf16(fmt::string_view("л", 1)),
+                   std::runtime_error, "invalid utf8");
+  EXPECT_EQ(L"123456", fmt::detail::utf8_to_utf16("123456").str());
+}
+
+TEST(util_test, utf8_to_utf16_empty_string) {
+  auto s = std::string();
+  auto u = fmt::detail::utf8_to_utf16(s.c_str());
+  EXPECT_EQ(L"", u.str());
+  EXPECT_EQ(s.size(), u.size());
+}
+
+TEST(util_test, allocator_ref) {
+  using test_allocator_ref = allocator_ref<mock_allocator<int>>;
+  auto check_forwarding = [](mock_allocator<int>& alloc,
+                             test_allocator_ref& ref) {
+    int mem;
+    // Check if value_type is properly defined.
+    allocator_ref<mock_allocator<int>>::value_type* ptr = &mem;
+    // Check forwarding.
+    EXPECT_CALL(alloc, allocate(42)).WillOnce(Return(ptr));
+    ref.allocate(42);
+    EXPECT_CALL(alloc, deallocate(ptr, 42));
+    ref.deallocate(ptr, 42);
+  };
+
+  StrictMock<mock_allocator<int>> alloc;
+  auto ref = test_allocator_ref(&alloc);
+  // Check if allocator_ref forwards to the underlying allocator.
+  check_forwarding(alloc, ref);
+  test_allocator_ref ref2(ref);
+  check_forwarding(alloc, ref2);
+  test_allocator_ref ref3;
+  EXPECT_EQ(nullptr, ref3.get());
+  ref3 = ref;
+  check_forwarding(alloc, ref3);
+}
+
+TEST(util_test, format_system_error) {
+  fmt::memory_buffer message;
+  fmt::format_system_error(message, EDOM, "test");
+  auto ec = std::error_code(EDOM, std::generic_category());
+  EXPECT_EQ(to_string(message), std::system_error(ec, "test").what());
+  message = fmt::memory_buffer();
+
+  // Check if std::allocator throws on allocating max size_t / 2 chars.
+  size_t max_size = max_value<size_t>() / 2;
+  bool throws_on_alloc = false;
+  try {
+    auto alloc = std::allocator<char>();
+    alloc.deallocate(alloc.allocate(max_size), max_size);
+  } catch (const std::bad_alloc&) {
+    throws_on_alloc = true;
+  }
+  if (!throws_on_alloc) {
+    fmt::print("warning: std::allocator allocates {} chars\n", max_size);
+    return;
+  }
+}
+
+TEST(util_test, system_error) {
+  auto test_error = fmt::system_error(EDOM, "test");
+  auto ec = std::error_code(EDOM, std::generic_category());
+  EXPECT_STREQ(test_error.what(), std::system_error(ec, "test").what());
+  EXPECT_EQ(test_error.code(), ec);
+
+  auto error = std::system_error(std::error_code());
+  try {
+    throw fmt::system_error(EDOM, "test {}", "error");
+  } catch (const std::system_error& e) {
+    error = e;
+  }
+  fmt::memory_buffer message;
+  fmt::format_system_error(message, EDOM, "test error");
+  EXPECT_EQ(error.what(), to_string(message));
+  EXPECT_EQ(error.code(), std::error_code(EDOM, std::generic_category()));
+}
+
+TEST(util_test, report_system_error) {
+  fmt::memory_buffer out;
+  fmt::format_system_error(out, EDOM, "test error");
+  out.push_back('\n');
+  EXPECT_WRITE(stderr, fmt::report_system_error(EDOM, "test error"),
+               to_string(out));
+}
+
+TEST(memory_buffer_test, ctor) {
+  basic_memory_buffer<char, 123> buffer;
+  EXPECT_EQ(static_cast<size_t>(0), buffer.size());
+  EXPECT_EQ(123u, buffer.capacity());
+}
+
+using std_allocator = allocator_ref<std::allocator<char>>;
+
+TEST(memory_buffer_test, move_ctor_inline_buffer) {
+  auto check_move_buffer =
+      [](const char* str, basic_memory_buffer<char, 5, std_allocator>& buffer) {
+        std::allocator<char>* alloc = buffer.get_allocator().get();
+        basic_memory_buffer<char, 5, std_allocator> buffer2(std::move(buffer));
+        // Move shouldn't destroy the inline content of the first buffer.
+        EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
+        EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
+        EXPECT_EQ(5u, buffer2.capacity());
+        // Move should transfer allocator.
+        EXPECT_EQ(nullptr, buffer.get_allocator().get());
+        EXPECT_EQ(alloc, buffer2.get_allocator().get());
+      };
+
+  auto alloc = std::allocator<char>();
+  basic_memory_buffer<char, 5, std_allocator> buffer((std_allocator(&alloc)));
+  const char test[] = "test";
+  buffer.append(string_view(test, 4));
+  check_move_buffer("test", buffer);
+  // Adding one more character fills the inline buffer, but doesn't cause
+  // dynamic allocation.
+  buffer.push_back('a');
+  check_move_buffer("testa", buffer);
+}
+
+TEST(memory_buffer_test, move_ctor_dynamic_buffer) {
+  auto alloc = std::allocator<char>();
+  basic_memory_buffer<char, 4, std_allocator> buffer((std_allocator(&alloc)));
+  const char test[] = "test";
+  buffer.append(test, test + 4);
+  const char* inline_buffer_ptr = &buffer[0];
+  // Adding one more character causes the content to move from the inline to
+  // a dynamically allocated buffer.
+  buffer.push_back('a');
+  basic_memory_buffer<char, 4, std_allocator> buffer2(std::move(buffer));
+  // Move should rip the guts of the first buffer.
+  EXPECT_EQ(&buffer[0], inline_buffer_ptr);
+  EXPECT_EQ(buffer.size(), 0);
+  EXPECT_EQ(std::string(&buffer2[0], buffer2.size()), "testa");
+  EXPECT_GT(buffer2.capacity(), 4u);
+}
+
+void check_move_assign_buffer(const char* str,
+                              basic_memory_buffer<char, 5>& buffer) {
+  basic_memory_buffer<char, 5> buffer2;
+  buffer2 = std::move(buffer);
+  // Move shouldn't destroy the inline content of the first buffer.
+  EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
+  EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
+  EXPECT_EQ(5u, buffer2.capacity());
+}
+
+TEST(memory_buffer_test, move_assignment) {
+  basic_memory_buffer<char, 5> buffer;
+  const char test[] = "test";
+  buffer.append(test, test + 4);
+  check_move_assign_buffer("test", buffer);
+  // Adding one more character fills the inline buffer, but doesn't cause
+  // dynamic allocation.
+  buffer.push_back('a');
+  check_move_assign_buffer("testa", buffer);
+  const char* inline_buffer_ptr = &buffer[0];
+  // Adding one more character causes the content to move from the inline to
+  // a dynamically allocated buffer.
+  buffer.push_back('b');
+  basic_memory_buffer<char, 5> buffer2;
+  buffer2 = std::move(buffer);
+  // Move should rip the guts of the first buffer.
+  EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
+  EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size()));
+  EXPECT_GT(buffer2.capacity(), 5u);
+}
+
+TEST(memory_buffer_test, grow) {
+  using allocator = allocator_ref<mock_allocator<int>>;
+  mock_allocator<int> alloc;
+  basic_memory_buffer<int, 10, allocator> buffer((allocator(&alloc)));
+  buffer.resize(7);
+  using fmt::detail::to_unsigned;
+  for (int i = 0; i < 7; ++i) buffer[to_unsigned(i)] = i * i;
+  EXPECT_EQ(10u, buffer.capacity());
+  int mem[20];
+  mem[7] = 0xdead;
+  EXPECT_CALL(alloc, allocate(20)).WillOnce(Return(mem));
+  buffer.try_reserve(20);
+  EXPECT_EQ(20u, buffer.capacity());
+  // Check if size elements have been copied
+  for (int i = 0; i < 7; ++i) EXPECT_EQ(i * i, buffer[to_unsigned(i)]);
+  // and no more than that.
+  EXPECT_EQ(0xdead, buffer[7]);
+  EXPECT_CALL(alloc, deallocate(mem, 20));
+}
+
+TEST(memory_buffer_test, allocator) {
+  using test_allocator = allocator_ref<mock_allocator<char>>;
+  basic_memory_buffer<char, 10, test_allocator> buffer;
+  EXPECT_EQ(nullptr, buffer.get_allocator().get());
+  StrictMock<mock_allocator<char>> alloc;
+  char mem;
+  {
+    basic_memory_buffer<char, 10, test_allocator> buffer2(
+        (test_allocator(&alloc)));
+    EXPECT_EQ(&alloc, buffer2.get_allocator().get());
+    size_t size = 2 * fmt::inline_buffer_size;
+    EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem));
+    buffer2.reserve(size);
+    EXPECT_CALL(alloc, deallocate(&mem, size));
+  }
+}
+
+TEST(memory_buffer_test, exception_in_deallocate) {
+  using test_allocator = allocator_ref<mock_allocator<char>>;
+  StrictMock<mock_allocator<char>> alloc;
+  basic_memory_buffer<char, 10, test_allocator> buffer(
+      (test_allocator(&alloc)));
+  size_t size = 2 * fmt::inline_buffer_size;
+  auto mem = std::vector<char>(size);
+  {
+    EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem[0]));
+    buffer.resize(size);
+    std::fill(&buffer[0], &buffer[0] + size, 'x');
+  }
+  auto mem2 = std::vector<char>(2 * size);
+  {
+    EXPECT_CALL(alloc, allocate(2 * size)).WillOnce(Return(&mem2[0]));
+    auto e = std::exception();
+    EXPECT_CALL(alloc, deallocate(&mem[0], size)).WillOnce(testing::Throw(e));
+    EXPECT_THROW(buffer.reserve(2 * size), std::exception);
+    EXPECT_EQ(&mem2[0], &buffer[0]);
+    // Check that the data has been copied.
+    for (size_t i = 0; i < size; ++i) EXPECT_EQ('x', buffer[i]);
+  }
+  EXPECT_CALL(alloc, deallocate(&mem2[0], 2 * size));
+}
+
+template <typename Allocator, size_t MaxSize>
+class max_size_allocator : public Allocator {
+ public:
+  using typename Allocator::value_type;
+  size_t max_size() const noexcept { return MaxSize; }
+  value_type* allocate(size_t n) {
+    if (n > max_size()) {
+      throw std::length_error("size > max_size");
+    }
+    return std::allocator_traits<Allocator>::allocate(
+        *static_cast<Allocator*>(this), n);
+  }
+  void deallocate(value_type* p, size_t n) {
+    std::allocator_traits<Allocator>::deallocate(*static_cast<Allocator*>(this),
+                                                 p, n);
+  }
+};
+
+TEST(memory_buffer_test, max_size_allocator) {
+  // 160 = 128 + 32
+  using test_allocator = max_size_allocator<std::allocator<char>, 160>;
+  basic_memory_buffer<char, 10, test_allocator> buffer;
+  buffer.resize(128);
+  // new_capacity = 128 + 128/2 = 192 > 160
+  buffer.resize(160);  // Shouldn't throw.
+}
+
+TEST(memory_buffer_test, max_size_allocator_overflow) {
+  using test_allocator = max_size_allocator<std::allocator<char>, 160>;
+  basic_memory_buffer<char, 10, test_allocator> buffer;
+  EXPECT_THROW(buffer.resize(161), std::exception);
+}
+
+TEST(format_test, exception_from_lib) {
+  EXPECT_THROW_MSG(fmt::throw_format_error("test"), format_error, "test");
+}
+
+TEST(format_test, escape) {
+  EXPECT_EQ(fmt::format("{{"), "{");
+  EXPECT_EQ(fmt::format("before {{"), "before {");
+  EXPECT_EQ(fmt::format("{{ after"), "{ after");
+  EXPECT_EQ(fmt::format("before {{ after"), "before { after");
+
+  EXPECT_EQ(fmt::format("}}"), "}");
+  EXPECT_EQ(fmt::format("before }}"), "before }");
+  EXPECT_EQ(fmt::format("}} after"), "} after");
+  EXPECT_EQ(fmt::format("before }} after"), "before } after");
+
+  EXPECT_EQ(fmt::format("{{}}"), "{}");
+  EXPECT_EQ(fmt::format("{{{0}}}", 42), "{42}");
+}
+
+TEST(format_test, unmatched_braces) {
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{")), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("}")), format_error,
+                   "unmatched '}' in format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0{}")), format_error,
+                   "invalid format string");
+}
+
+TEST(format_test, no_args) { EXPECT_EQ(fmt::format("test"), "test"); }
+
+TEST(format_test, args_in_different_positions) {
+  EXPECT_EQ(fmt::format("{0}", 42), "42");
+  EXPECT_EQ(fmt::format("before {0}", 42), "before 42");
+  EXPECT_EQ(fmt::format("{0} after", 42), "42 after");
+  EXPECT_EQ(fmt::format("before {0} after", 42), "before 42 after");
+  EXPECT_EQ(fmt::format("{0} = {1}", "answer", 42), "answer = 42");
+  EXPECT_EQ(fmt::format("{1} is the {0}", "answer", 42), "42 is the answer");
+  EXPECT_EQ(fmt::format("{0}{1}{0}", "abra", "cad"), "abracadabra");
+}
+
+TEST(format_test, arg_errors) {
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{")), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{?}")), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0")), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0}")), format_error,
+                   "argument not found");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{00}"), 42), format_error,
+                   "invalid format string");
+
+  auto int_max = std::to_string(INT_MAX);
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{" + int_max)), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{" + int_max + "}")),
+                   format_error, "argument not found");
+
+  auto int_maxer = std::to_string(INT_MAX + 1u);
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{" + int_maxer)), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{" + int_maxer + "}")),
+                   format_error, "argument not found");
+}
+
+template <int N> struct test_format {
+  template <typename... T>
+  static auto format(fmt::string_view fmt, const T&... args) -> std::string {
+    return test_format<N - 1>::format(fmt, N - 1, args...);
+  }
+};
+
+template <> struct test_format<0> {
+  template <typename... T>
+  static auto format(fmt::string_view fmt, const T&... args) -> std::string {
+    return fmt::format(runtime(fmt), args...);
+  }
+};
+
+TEST(format_test, many_args) {
+  EXPECT_EQ("19", test_format<20>::format("{19}"));
+  EXPECT_THROW_MSG(test_format<20>::format("{20}"), format_error,
+                   "argument not found");
+  EXPECT_THROW_MSG(test_format<21>::format("{21}"), format_error,
+                   "argument not found");
+  using fmt::detail::max_packed_args;
+  std::string format_str = fmt::format("{{{}}}", max_packed_args + 1);
+  EXPECT_THROW_MSG(test_format<max_packed_args>::format(format_str),
+                   format_error, "argument not found");
+}
+
+TEST(format_test, named_arg) {
+  EXPECT_EQ("1/a/A", fmt::format("{_1}/{a_}/{A_}", fmt::arg("a_", 'a'),
+                                 fmt::arg("A_", "A"), fmt::arg("_1", 1)));
+  EXPECT_EQ(fmt::format("{0:{width}}", -42, fmt::arg("width", 4)), " -42");
+  EXPECT_EQ("st",
+            fmt::format("{0:.{precision}}", "str", fmt::arg("precision", 2)));
+  EXPECT_EQ(fmt::format("{} {two}", 1, fmt::arg("two", 2)), "1 2");
+  EXPECT_EQ("42",
+            fmt::format("{c}", fmt::arg("a", 0), fmt::arg("b", 0),
+                        fmt::arg("c", 42), fmt::arg("d", 0), fmt::arg("e", 0),
+                        fmt::arg("f", 0), fmt::arg("g", 0), fmt::arg("h", 0),
+                        fmt::arg("i", 0), fmt::arg("j", 0), fmt::arg("k", 0),
+                        fmt::arg("l", 0), fmt::arg("m", 0), fmt::arg("n", 0),
+                        fmt::arg("o", 0), fmt::arg("p", 0)));
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{a}")), format_error,
+                   "argument not found");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{a}"), 42), format_error,
+                   "argument not found");
+}
+
+TEST(format_test, auto_arg_index) {
+  EXPECT_EQ(fmt::format("{}{}{}", 'a', 'b', 'c'), "abc");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0}{}"), 'a', 'b'), format_error,
+                   "cannot switch from manual to automatic argument indexing");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{}{0}"), 'a', 'b'), format_error,
+                   "cannot switch from automatic to manual argument indexing");
+  EXPECT_EQ(fmt::format("{:.{}}", 1.2345, 2), "1.2");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0}:.{}"), 1.2345, 2),
+                   format_error,
+                   "cannot switch from manual to automatic argument indexing");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:.{0}}"), 1.2345, 2),
+                   format_error,
+                   "cannot switch from automatic to manual argument indexing");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{}")), format_error,
+                   "argument not found");
+}
+
+TEST(format_test, empty_specs) { EXPECT_EQ(fmt::format("{0:}", 42), "42"); }
+
+TEST(format_test, left_align) {
+  EXPECT_EQ(fmt::format("{0:<4}", 42), "42  ");
+  EXPECT_EQ(fmt::format("{0:<4o}", 042), "42  ");
+  EXPECT_EQ(fmt::format("{0:<4x}", 0x42), "42  ");
+  EXPECT_EQ(fmt::format("{0:<5}", -42), "-42  ");
+  EXPECT_EQ(fmt::format("{0:<5}", 42u), "42   ");
+  EXPECT_EQ(fmt::format("{0:<5}", -42l), "-42  ");
+  EXPECT_EQ(fmt::format("{0:<5}", 42ul), "42   ");
+  EXPECT_EQ(fmt::format("{0:<5}", -42ll), "-42  ");
+  EXPECT_EQ(fmt::format("{0:<5}", 42ull), "42   ");
+  EXPECT_EQ(fmt::format("{0:<5}", -42.0), "-42  ");
+  EXPECT_EQ(fmt::format("{0:<5}", -42.0l), "-42  ");
+  EXPECT_EQ(fmt::format("{0:<5}", 'c'), "c    ");
+  EXPECT_EQ(fmt::format("{0:<5}", "abc"), "abc  ");
+  EXPECT_EQ(fmt::format("{0:<8}", reinterpret_cast<void*>(0xface)), "0xface  ");
+}
+
+TEST(format_test, right_align) {
+  EXPECT_EQ(fmt::format("{0:>4}", 42), "  42");
+  EXPECT_EQ(fmt::format("{0:>4o}", 042), "  42");
+  EXPECT_EQ(fmt::format("{0:>4x}", 0x42), "  42");
+  EXPECT_EQ(fmt::format("{0:>5}", -42), "  -42");
+  EXPECT_EQ(fmt::format("{0:>5}", 42u), "   42");
+  EXPECT_EQ(fmt::format("{0:>5}", -42l), "  -42");
+  EXPECT_EQ(fmt::format("{0:>5}", 42ul), "   42");
+  EXPECT_EQ(fmt::format("{0:>5}", -42ll), "  -42");
+  EXPECT_EQ(fmt::format("{0:>5}", 42ull), "   42");
+  EXPECT_EQ(fmt::format("{0:>5}", -42.0), "  -42");
+  EXPECT_EQ(fmt::format("{0:>5}", -42.0l), "  -42");
+  EXPECT_EQ(fmt::format("{0:>5}", 'c'), "    c");
+  EXPECT_EQ(fmt::format("{0:>5}", "abc"), "  abc");
+  EXPECT_EQ(fmt::format("{0:>8}", reinterpret_cast<void*>(0xface)), "  0xface");
+}
+
+TEST(format_test, center_align) {
+  EXPECT_EQ(fmt::format("{0:^5}", 42), " 42  ");
+  EXPECT_EQ(fmt::format("{0:^5o}", 042), " 42  ");
+  EXPECT_EQ(fmt::format("{0:^5x}", 0x42), " 42  ");
+  EXPECT_EQ(fmt::format("{0:^5}", -42), " -42 ");
+  EXPECT_EQ(fmt::format("{0:^5}", 42u), " 42  ");
+  EXPECT_EQ(fmt::format("{0:^5}", -42l), " -42 ");
+  EXPECT_EQ(fmt::format("{0:^5}", 42ul), " 42  ");
+  EXPECT_EQ(fmt::format("{0:^5}", -42ll), " -42 ");
+  EXPECT_EQ(fmt::format("{0:^5}", 42ull), " 42  ");
+  EXPECT_EQ(fmt::format("{0:^5}", -42.0), " -42 ");
+  EXPECT_EQ(fmt::format("{0:^5}", -42.0l), " -42 ");
+  EXPECT_EQ(fmt::format("{0:^5}", 'c'), "  c  ");
+  EXPECT_EQ(fmt::format("{0:^6}", "abc"), " abc  ");
+  EXPECT_EQ(fmt::format("{0:^8}", reinterpret_cast<void*>(0xface)), " 0xface ");
+}
+
+TEST(format_test, fill) {
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{<5}"), 'c'), format_error,
+                   "invalid fill character '{'");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{<5}}"), 'c'), format_error,
+                   "invalid fill character '{'");
+  EXPECT_EQ(fmt::format("{0:*>4}", 42), "**42");
+  EXPECT_EQ(fmt::format("{0:*>5}", -42), "**-42");
+  EXPECT_EQ(fmt::format("{0:*>5}", 42u), "***42");
+  EXPECT_EQ(fmt::format("{0:*>5}", -42l), "**-42");
+  EXPECT_EQ(fmt::format("{0:*>5}", 42ul), "***42");
+  EXPECT_EQ(fmt::format("{0:*>5}", -42ll), "**-42");
+  EXPECT_EQ(fmt::format("{0:*>5}", 42ull), "***42");
+  EXPECT_EQ(fmt::format("{0:*>5}", -42.0), "**-42");
+  EXPECT_EQ(fmt::format("{0:*>5}", -42.0l), "**-42");
+  EXPECT_EQ(fmt::format("{0:*<5}", 'c'), "c****");
+  EXPECT_EQ(fmt::format("{0:*<5}", "abc"), "abc**");
+  EXPECT_EQ("**0xface",
+            fmt::format("{0:*>8}", reinterpret_cast<void*>(0xface)));
+  EXPECT_EQ(fmt::format("{:}=", "foo"), "foo=");
+  EXPECT_EQ(std::string("\0\0\0*", 4),
+            fmt::format(string_view("{:\0>4}", 6), '*'));
+  EXPECT_EQ(fmt::format("{0:ж>4}", 42), "жж42");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:\x80\x80\x80\x80\x80>}"), 0),
+                   format_error, "invalid format specifier");
+}
+
+TEST(format_test, plus_sign) {
+  EXPECT_EQ(fmt::format("{0:+}", 42), "+42");
+  EXPECT_EQ(fmt::format("{0:+}", -42), "-42");
+  EXPECT_EQ(fmt::format("{0:+}", 42), "+42");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 42u), format_error,
+                   "invalid format specifier");
+  EXPECT_EQ(fmt::format("{0:+}", 42l), "+42");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 42ul), format_error,
+                   "invalid format specifier");
+  EXPECT_EQ(fmt::format("{0:+}", 42ll), "+42");
+#if FMT_USE_INT128
+  EXPECT_EQ(fmt::format("{0:+}", __int128_t(42)), "+42");
+#endif
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 42ull), format_error,
+                   "invalid format specifier");
+  EXPECT_EQ(fmt::format("{0:+}", 42.0), "+42");
+  EXPECT_EQ(fmt::format("{0:+}", 42.0l), "+42");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), 'c'), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), "abc"), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG(
+      (void)fmt::format(runtime("{0:+}"), reinterpret_cast<void*>(0x42)),
+      format_error, "invalid format specifier");
+}
+
+TEST(format_test, minus_sign) {
+  EXPECT_EQ(fmt::format("{0:-}", 42), "42");
+  EXPECT_EQ(fmt::format("{0:-}", -42), "-42");
+  EXPECT_EQ(fmt::format("{0:-}", 42), "42");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 42u), format_error,
+                   "invalid format specifier");
+  EXPECT_EQ(fmt::format("{0:-}", 42l), "42");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 42ul), format_error,
+                   "invalid format specifier");
+  EXPECT_EQ(fmt::format("{0:-}", 42ll), "42");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 42ull), format_error,
+                   "invalid format specifier");
+  EXPECT_EQ(fmt::format("{0:-}", 42.0), "42");
+  EXPECT_EQ(fmt::format("{0:-}", 42.0l), "42");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), 'c'), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), "abc"), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG(
+      (void)fmt::format(runtime("{0:-}"), reinterpret_cast<void*>(0x42)),
+      format_error, "invalid format specifier");
+}
+
+TEST(format_test, space_sign) {
+  EXPECT_EQ(fmt::format("{0: }", 42), " 42");
+  EXPECT_EQ(fmt::format("{0: }", -42), "-42");
+  EXPECT_EQ(fmt::format("{0: }", 42), " 42");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 42u), format_error,
+                   "invalid format specifier");
+  EXPECT_EQ(fmt::format("{0: }", 42l), " 42");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 42ul), format_error,
+                   "invalid format specifier");
+  EXPECT_EQ(fmt::format("{0: }", 42ll), " 42");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 42ull), format_error,
+                   "invalid format specifier");
+  EXPECT_EQ(fmt::format("{0: }", 42.0), " 42");
+  EXPECT_EQ(fmt::format("{0: }", 42.0l), " 42");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), 'c'), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), "abc"), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG(
+      (void)fmt::format(runtime("{0: }"), reinterpret_cast<void*>(0x42)),
+      format_error, "invalid format specifier");
+}
+
+TEST(format_test, hash_flag) {
+  EXPECT_EQ(fmt::format("{0:#}", 42), "42");
+  EXPECT_EQ(fmt::format("{0:#}", -42), "-42");
+  EXPECT_EQ(fmt::format("{0:#b}", 42), "0b101010");
+  EXPECT_EQ(fmt::format("{0:#B}", 42), "0B101010");
+  EXPECT_EQ(fmt::format("{0:#b}", -42), "-0b101010");
+  EXPECT_EQ(fmt::format("{0:#x}", 0x42), "0x42");
+  EXPECT_EQ(fmt::format("{0:#X}", 0x42), "0X42");
+  EXPECT_EQ(fmt::format("{0:#x}", -0x42), "-0x42");
+  EXPECT_EQ(fmt::format("{0:#o}", 0), "0");
+  EXPECT_EQ(fmt::format("{0:#o}", 042), "042");
+  EXPECT_EQ(fmt::format("{0:#o}", -042), "-042");
+  EXPECT_EQ(fmt::format("{0:#}", 42u), "42");
+  EXPECT_EQ(fmt::format("{0:#x}", 0x42u), "0x42");
+  EXPECT_EQ(fmt::format("{0:#o}", 042u), "042");
+
+  EXPECT_EQ(fmt::format("{0:#}", -42l), "-42");
+  EXPECT_EQ(fmt::format("{0:#x}", 0x42l), "0x42");
+  EXPECT_EQ(fmt::format("{0:#x}", -0x42l), "-0x42");
+  EXPECT_EQ(fmt::format("{0:#o}", 042l), "042");
+  EXPECT_EQ(fmt::format("{0:#o}", -042l), "-042");
+  EXPECT_EQ(fmt::format("{0:#}", 42ul), "42");
+  EXPECT_EQ(fmt::format("{0:#x}", 0x42ul), "0x42");
+  EXPECT_EQ(fmt::format("{0:#o}", 042ul), "042");
+
+  EXPECT_EQ(fmt::format("{0:#}", -42ll), "-42");
+  EXPECT_EQ(fmt::format("{0:#x}", 0x42ll), "0x42");
+  EXPECT_EQ(fmt::format("{0:#x}", -0x42ll), "-0x42");
+  EXPECT_EQ(fmt::format("{0:#o}", 042ll), "042");
+  EXPECT_EQ(fmt::format("{0:#o}", -042ll), "-042");
+  EXPECT_EQ(fmt::format("{0:#}", 42ull), "42");
+  EXPECT_EQ(fmt::format("{0:#x}", 0x42ull), "0x42");
+  EXPECT_EQ(fmt::format("{0:#o}", 042ull), "042");
+
+  EXPECT_EQ(fmt::format("{0:#}", -42.0), "-42.");
+  EXPECT_EQ(fmt::format("{0:#}", -42.0l), "-42.");
+  EXPECT_EQ(fmt::format("{:#.0e}", 42.0), "4.e+01");
+  EXPECT_EQ(fmt::format("{:#.0f}", 0.01), "0.");
+  EXPECT_EQ(fmt::format("{:#.2g}", 0.5), "0.50");
+  EXPECT_EQ(fmt::format("{:#.0f}", 0.5), "0.");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#"), 'c'), format_error,
+                   "missing '}' in format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#}"), 'c'), format_error,
+                   "invalid format specifier for char");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#}"), "abc"), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG(
+      (void)fmt::format(runtime("{0:#}"), reinterpret_cast<void*>(0x42)),
+      format_error, "invalid format specifier");
+}
+
+TEST(format_test, zero_flag) {
+  EXPECT_EQ(fmt::format("{0:0}", 42), "42");
+  EXPECT_EQ(fmt::format("{0:05}", -42), "-0042");
+  EXPECT_EQ(fmt::format("{0:05}", 42u), "00042");
+  EXPECT_EQ(fmt::format("{0:05}", -42l), "-0042");
+  EXPECT_EQ(fmt::format("{0:05}", 42ul), "00042");
+  EXPECT_EQ(fmt::format("{0:05}", -42ll), "-0042");
+  EXPECT_EQ(fmt::format("{0:05}", 42ull), "00042");
+  EXPECT_EQ(fmt::format("{0:07}", -42.0), "-000042");
+  EXPECT_EQ(fmt::format("{0:07}", -42.0l), "-000042");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:0"), 'c'), format_error,
+                   "missing '}' in format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:05}"), 'c'), format_error,
+                   "invalid format specifier for char");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:05}"), "abc"), format_error,
+                   "format specifier requires numeric argument");
+  EXPECT_THROW_MSG(
+      (void)fmt::format(runtime("{0:05}"), reinterpret_cast<void*>(0x42)),
+      format_error, "format specifier requires numeric argument");
+}
+
+TEST(format_test, zero_flag_and_align) {
+  // If the 0 character and an align option both appear, the 0 character is
+  // ignored.
+  EXPECT_EQ(fmt::format("{:<05}", 42), "42   ");
+  EXPECT_EQ(fmt::format("{:<05}", -42), "-42  ");
+  EXPECT_EQ(fmt::format("{:^05}", 42), " 42  ");
+  EXPECT_EQ(fmt::format("{:^05}", -42), " -42 ");
+  EXPECT_EQ(fmt::format("{:>05}", 42), "   42");
+  EXPECT_EQ(fmt::format("{:>05}", -42), "  -42");
+}
+
+TEST(format_test, width) {
+  auto int_maxer = std::to_string(INT_MAX + 1u);
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:" + int_maxer), 0),
+                   format_error, "number is too big");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:" + int_maxer + "}"), 0),
+                   format_error, "number is too big");
+
+  EXPECT_EQ(fmt::format("{:4}", -42), " -42");
+  EXPECT_EQ(fmt::format("{:5}", 42u), "   42");
+  EXPECT_EQ(fmt::format("{:6}", -42l), "   -42");
+  EXPECT_EQ(fmt::format("{:7}", 42ul), "     42");
+  EXPECT_EQ(fmt::format("{:6}", -42ll), "   -42");
+  EXPECT_EQ(fmt::format("{:7}", 42ull), "     42");
+  EXPECT_EQ(fmt::format("{:8}", -1.23), "   -1.23");
+  EXPECT_EQ(fmt::format("{:9}", -1.23l), "    -1.23");
+  EXPECT_EQ(fmt::format("{:10}", reinterpret_cast<void*>(0xcafe)),
+            "    0xcafe");
+  EXPECT_EQ(fmt::format("{:11}", 'x'), "x          ");
+  EXPECT_EQ(fmt::format("{:12}", "str"), "str         ");
+  EXPECT_EQ(fmt::format("{:*^6}", "🤡"), "**🤡**");
+  EXPECT_EQ(fmt::format("{:*^8}", "你好"), "**你好**");
+  EXPECT_EQ(fmt::format("{:#6}", 42.0), "   42.");
+  EXPECT_EQ(fmt::format("{:6c}", static_cast<int>('x')), "x     ");
+  EXPECT_EQ(fmt::format("{:>06.0f}", 0.00884311), "     0");
+}
+
+TEST(format_test, runtime_width) {
+  auto int_maxer = std::to_string(INT_MAX + 1u);
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{" + int_maxer), 0),
+                   format_error, "invalid format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{" + int_maxer + "}"), 0),
+                   format_error, "argument not found");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{" + int_maxer + "}}"), 0),
+                   format_error, "argument not found");
+
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{"), 0), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{}"), 0), format_error,
+                   "cannot switch from manual to automatic argument indexing");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{?}}"), 0), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0), format_error,
+                   "argument not found");
+
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{0:}}"), 0), format_error,
+                   "invalid format string");
+
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, -1), format_error,
+                   "negative width");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, (INT_MAX + 1u)),
+                   format_error, "number is too big");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, -1l), format_error,
+                   "negative width");
+  if (fmt::detail::const_check(sizeof(long) > sizeof(int))) {
+    long value = INT_MAX;
+    EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, (value + 1)),
+                     format_error, "number is too big");
+  }
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, (INT_MAX + 1ul)),
+                   format_error, "number is too big");
+
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, '0'), format_error,
+                   "width is not integer");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:{1}}"), 0, 0.0), format_error,
+                   "width is not integer");
+
+  EXPECT_EQ(fmt::format("{0:{1}}", -42, 4), " -42");
+  EXPECT_EQ(fmt::format("{0:{1}}", 42u, 5), "   42");
+  EXPECT_EQ(fmt::format("{0:{1}}", -42l, 6), "   -42");
+  EXPECT_EQ(fmt::format("{0:{1}}", 42ul, 7), "     42");
+  EXPECT_EQ(fmt::format("{0:{1}}", -42ll, 6), "   -42");
+  EXPECT_EQ(fmt::format("{0:{1}}", 42ull, 7), "     42");
+  EXPECT_EQ(fmt::format("{0:{1}}", -1.23, 8), "   -1.23");
+  EXPECT_EQ(fmt::format("{0:{1}}", -1.23l, 9), "    -1.23");
+  EXPECT_EQ("    0xcafe",
+            fmt::format("{0:{1}}", reinterpret_cast<void*>(0xcafe), 10));
+  EXPECT_EQ(fmt::format("{0:{1}}", 'x', 11), "x          ");
+  EXPECT_EQ(fmt::format("{0:{1}}", "str", 12), "str         ");
+  EXPECT_EQ(fmt::format("{:{}}", 42, short(4)), "  42");
+}
+
+TEST(format_test, precision) {
+  char format_str[buffer_size];
+  safe_sprintf(format_str, "{0:.%u", UINT_MAX);
+  increment(format_str + 4);
+  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error,
+                   "number is too big");
+  size_t size = std::strlen(format_str);
+  format_str[size] = '}';
+  format_str[size + 1] = 0;
+  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error,
+                   "number is too big");
+
+  safe_sprintf(format_str, "{0:.%u", INT_MAX + 1u);
+  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error,
+                   "number is too big");
+  safe_sprintf(format_str, "{0:.%u}", INT_MAX + 1u);
+  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error,
+                   "number is too big");
+
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:."), 0.0), format_error,
+                   "invalid precision");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.}"), 0.0), format_error,
+                   "invalid precision");
+
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2"), 0), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42u), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42u), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42l), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42l), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42ul), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42ul), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42ll), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42ll), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2}"), 42ull), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.2f}"), 42ull), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:3.0}"), 'x'), format_error,
+                   "invalid format specifier");
+  EXPECT_EQ(fmt::format("{0:.2}", 1.2345), "1.2");
+  EXPECT_EQ(fmt::format("{0:.2}", 1.2345l), "1.2");
+  EXPECT_EQ(fmt::format("{:.2}", 1.234e56), "1.2e+56");
+  EXPECT_EQ(fmt::format("{0:.3}", 1.1), "1.1");
+  EXPECT_EQ(fmt::format("{:.0e}", 1.0L), "1e+00");
+  EXPECT_EQ(fmt::format("{:9.1e}", 0.0), "  0.0e+00");
+  EXPECT_EQ(
+      fmt::format("{:.494}", 4.9406564584124654E-324),
+      "4.9406564584124654417656879286822137236505980261432476442558568250067550"
+      "727020875186529983636163599237979656469544571773092665671035593979639877"
+      "479601078187812630071319031140452784581716784898210368871863605699873072"
+      "305000638740915356498438731247339727316961514003171538539807412623856559"
+      "117102665855668676818703956031062493194527159149245532930545654440112748"
+      "012970999954193198940908041656332452475714786901472678015935523861155013"
+      "480352649347201937902681071074917033322268447533357208324319361e-324");
+  EXPECT_EQ(
+      fmt::format("{:.1074f}", 1.1125369292536e-308),
+      "0.0000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000111253692925360019747947051741965785554081512200979"
+      "355021686109411883779182127659725163430929750364498219730822952552570601"
+      "152163505899912777129583674906301179059298598412303893909188340988729019"
+      "014361467448914817838555156840459458527907308695109202499990850735085304"
+      "478476991912072201449236975063640913461919914396877093174125167509869762"
+      "482369631100360266123742648159508919592746619553246586039571522788247697"
+      "156360766271842991667238355464496455107749716934387136380536472531224398"
+      "559833794807213172371254492216255558078524900147957309382830827524104234"
+      "530961756787819847850302379672357738807808384667004752163416921762619527"
+      "462847642037420991432005657440259928195996762610375541867198059294212446"
+      "81962777939941034720757232455434770912461317493580281734466552734375");
+
+  std::string outputs[] = {
+      "-0X1.41FE3FFE71C9E000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000P+127",
+      "-0XA.0FF1FFF38E4F0000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000000000000000000000000"
+      "000000000000000000000000000000000000000000000000000P+124"};
+  EXPECT_THAT(outputs,
+              testing::Contains(fmt::format("{:.838A}", -2.14001164E+38)));
+
+  if (std::numeric_limits<long double>::digits == 64) {
+    auto ld = (std::numeric_limits<long double>::min)();
+    EXPECT_EQ(fmt::format("{:.0}", ld), "3e-4932");
+    EXPECT_EQ(
+        fmt::format("{:0g}", std::numeric_limits<long double>::denorm_min()),
+        "3.6452e-4951");
+  }
+
+  EXPECT_EQ(fmt::format("{:#.0f}", 123.0), "123.");
+  EXPECT_EQ(fmt::format("{:.02f}", 1.234), "1.23");
+  EXPECT_EQ(fmt::format("{:.1g}", 0.001), "0.001");
+  EXPECT_EQ(fmt::format("{}", 1019666432.0f), "1019666400");
+  EXPECT_EQ(fmt::format("{:.0e}", 9.5), "1e+01");
+  EXPECT_EQ(fmt::format("{:.1e}", 1e-34), "1.0e-34");
+
+  EXPECT_THROW_MSG(
+      (void)fmt::format(runtime("{0:.2}"), reinterpret_cast<void*>(0xcafe)),
+      format_error, "invalid format specifier");
+  EXPECT_THROW_MSG(
+      (void)fmt::format(runtime("{0:.2f}"), reinterpret_cast<void*>(0xcafe)),
+      format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:.{}e}"), 42.0,
+                                     fmt::detail::max_value<int>()),
+                   format_error, "number is too big");
+  EXPECT_THROW_MSG(
+      (void)fmt::format("{:.2147483646f}", -2.2121295195081227E+304),
+      format_error, "number is too big");
+
+  EXPECT_EQ(fmt::format("{0:.2}", "str"), "st");
+  EXPECT_EQ(fmt::format("{0:.5}", "вожыкі"), "вожык");
+  EXPECT_EQ(fmt::format("{0:.6}", "123456\xad"), "123456");
+}
+
+TEST(xchar_test, utf8_precision) {
+  auto result = fmt::format("{:.4}", "caf\u00e9s");  // cafés
+  EXPECT_EQ(fmt::detail::compute_width(result), 4);
+  EXPECT_EQ(result, "caf\u00e9");
+}
+
+TEST(format_test, runtime_precision) {
+  char format_str[buffer_size];
+  safe_sprintf(format_str, "{0:.{%u", UINT_MAX);
+  increment(format_str + 5);
+  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error,
+                   "invalid format string");
+  size_t size = std::strlen(format_str);
+  format_str[size] = '}';
+  format_str[size + 1] = 0;
+  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error,
+                   "argument not found");
+  format_str[size + 1] = '}';
+  format_str[size + 2] = 0;
+  EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), 0.0), format_error,
+                   "argument not found");
+
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{"), 0.0), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{}"), 0.0), format_error,
+                   "cannot switch from manual to automatic argument indexing");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{?}}"), 0.0), format_error,
+                   "invalid format string");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}"), 0, 0), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0), format_error,
+                   "argument not found");
+
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{0:}}"), 0.0), format_error,
+                   "invalid format string");
+
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, -1),
+                   format_error, "negative precision");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, (INT_MAX + 1u)),
+                   format_error, "number is too big");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, -1l),
+                   format_error, "negative precision");
+  if (fmt::detail::const_check(sizeof(long) > sizeof(int))) {
+    long value = INT_MAX;
+    EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, (value + 1)),
+                     format_error, "number is too big");
+  }
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, (INT_MAX + 1ul)),
+                   format_error, "number is too big");
+
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, '0'),
+                   format_error, "precision is not integer");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 0.0, 0.0),
+                   format_error, "precision is not integer");
+
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42, 2), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42, 2), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42u, 2), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42u, 2),
+                   format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42l, 2), format_error,
+                   "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42l, 2),
+                   format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42ul, 2),
+                   format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42ul, 2),
+                   format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42ll, 2),
+                   format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42ll, 2),
+                   format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"), 42ull, 2),
+                   format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"), 42ull, 2),
+                   format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:3.{1}}"), 'x', 0),
+                   format_error, "invalid format specifier");
+  EXPECT_EQ(fmt::format("{0:.{1}}", 1.2345, 2), "1.2");
+  EXPECT_EQ(fmt::format("{1:.{0}}", 2, 1.2345l), "1.2");
+
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}}"),
+                                     reinterpret_cast<void*>(0xcafe), 2),
+                   format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:.{1}f}"),
+                                     reinterpret_cast<void*>(0xcafe), 2),
+                   format_error, "invalid format specifier");
+
+  EXPECT_EQ(fmt::format("{0:.{1}}", "str", 2), "st");
+}
+
+TEST(format_test, format_bool) {
+  EXPECT_EQ(fmt::format("{}", true), "true");
+  EXPECT_EQ(fmt::format("{}", false), "false");
+  EXPECT_EQ(fmt::format("{:d}", true), "1");
+  EXPECT_EQ(fmt::format("{:5}", true), "true ");
+  EXPECT_EQ(fmt::format("{:s}", true), "true");
+  EXPECT_EQ(fmt::format("{:s}", false), "false");
+  EXPECT_EQ(fmt::format("{:6s}", false), "false ");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:c}"), false), format_error,
+                   "invalid format specifier");
+}
+
+TEST(format_test, format_short) {
+  short s = 42;
+  EXPECT_EQ(fmt::format("{0:d}", s), "42");
+  unsigned short us = 42;
+  EXPECT_EQ(fmt::format("{0:d}", us), "42");
+}
+
+template <typename T>
+void check_unknown_types(const T& value, const char* types, const char*) {
+  char format_str[buffer_size];
+  const char* special = ".0123456789L?}";
+  for (int i = CHAR_MIN; i <= CHAR_MAX; ++i) {
+    char c = static_cast<char>(i);
+    if (std::strchr(types, c) || std::strchr(special, c) || !c) continue;
+    safe_sprintf(format_str, "{0:10%c}", c);
+    const char* message = "invalid format specifier";
+    EXPECT_THROW_MSG((void)fmt::format(runtime(format_str), value),
+                     format_error, message)
+        << format_str << " " << message;
+  }
+}
+
+TEST(format_test, format_int) {
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:v"), 42), format_error,
+                   "invalid format specifier");
+  check_unknown_types(42, "bBdoxXnLc", "integer");
+  EXPECT_EQ(fmt::format("{:c}", static_cast<int>('x')), "x");
+}
+
+TEST(format_test, format_bin) {
+  EXPECT_EQ(fmt::format("{0:b}", 0), "0");
+  EXPECT_EQ(fmt::format("{0:b}", 42), "101010");
+  EXPECT_EQ(fmt::format("{0:b}", 42u), "101010");
+  EXPECT_EQ(fmt::format("{0:b}", -42), "-101010");
+  EXPECT_EQ(fmt::format("{0:b}", 12345), "11000000111001");
+  EXPECT_EQ(fmt::format("{0:b}", 0x12345678), "10010001101000101011001111000");
+  EXPECT_EQ("10010000101010111100110111101111",
+            fmt::format("{0:b}", 0x90ABCDEF));
+  EXPECT_EQ("11111111111111111111111111111111",
+            fmt::format("{0:b}", max_value<uint32_t>()));
+}
+
+#if FMT_USE_INT128
+constexpr auto int128_max = static_cast<__int128_t>(
+    (static_cast<__uint128_t>(1) << ((__SIZEOF_INT128__ * CHAR_BIT) - 1)) - 1);
+constexpr auto int128_min = -int128_max - 1;
+
+constexpr auto uint128_max = ~static_cast<__uint128_t>(0);
+#endif
+
+TEST(format_test, format_dec) {
+  EXPECT_EQ(fmt::format("{0}", 0), "0");
+  EXPECT_EQ(fmt::format("{0}", 42), "42");
+  EXPECT_EQ(fmt::format("{:}>", 42), "42>");
+  EXPECT_EQ(fmt::format("{0:d}", 42), "42");
+  EXPECT_EQ(fmt::format("{0}", 42u), "42");
+  EXPECT_EQ(fmt::format("{0}", -42), "-42");
+  EXPECT_EQ(fmt::format("{0}", 12345), "12345");
+  EXPECT_EQ(fmt::format("{0}", 67890), "67890");
+#if FMT_USE_INT128
+  EXPECT_EQ(fmt::format("{0}", static_cast<__int128_t>(0)), "0");
+  EXPECT_EQ(fmt::format("{0}", static_cast<__uint128_t>(0)), "0");
+  EXPECT_EQ("9223372036854775808",
+            fmt::format("{0}", static_cast<__int128_t>(INT64_MAX) + 1));
+  EXPECT_EQ("-9223372036854775809",
+            fmt::format("{0}", static_cast<__int128_t>(INT64_MIN) - 1));
+  EXPECT_EQ("18446744073709551616",
+            fmt::format("{0}", static_cast<__int128_t>(UINT64_MAX) + 1));
+  EXPECT_EQ("170141183460469231731687303715884105727",
+            fmt::format("{0}", int128_max));
+  EXPECT_EQ("-170141183460469231731687303715884105728",
+            fmt::format("{0}", int128_min));
+  EXPECT_EQ("340282366920938463463374607431768211455",
+            fmt::format("{0}", uint128_max));
+#endif
+
+  char buffer[buffer_size];
+  safe_sprintf(buffer, "%d", INT_MIN);
+  EXPECT_EQ(buffer, fmt::format("{0}", INT_MIN));
+  safe_sprintf(buffer, "%d", INT_MAX);
+  EXPECT_EQ(buffer, fmt::format("{0}", INT_MAX));
+  safe_sprintf(buffer, "%u", UINT_MAX);
+  EXPECT_EQ(buffer, fmt::format("{0}", UINT_MAX));
+  safe_sprintf(buffer, "%ld", 0 - static_cast<unsigned long>(LONG_MIN));
+  EXPECT_EQ(buffer, fmt::format("{0}", LONG_MIN));
+  safe_sprintf(buffer, "%ld", LONG_MAX);
+  EXPECT_EQ(buffer, fmt::format("{0}", LONG_MAX));
+  safe_sprintf(buffer, "%lu", ULONG_MAX);
+  EXPECT_EQ(buffer, fmt::format("{0}", ULONG_MAX));
+}
+
+TEST(format_test, format_hex) {
+  EXPECT_EQ(fmt::format("{0:x}", 0), "0");
+  EXPECT_EQ(fmt::format("{0:x}", 0x42), "42");
+  EXPECT_EQ(fmt::format("{0:x}", 0x42u), "42");
+  EXPECT_EQ(fmt::format("{0:x}", -0x42), "-42");
+  EXPECT_EQ(fmt::format("{0:x}", 0x12345678), "12345678");
+  EXPECT_EQ(fmt::format("{0:x}", 0x90abcdef), "90abcdef");
+  EXPECT_EQ(fmt::format("{0:X}", 0x12345678), "12345678");
+  EXPECT_EQ(fmt::format("{0:X}", 0x90ABCDEF), "90ABCDEF");
+#if FMT_USE_INT128
+  EXPECT_EQ(fmt::format("{0:x}", static_cast<__int128_t>(0)), "0");
+  EXPECT_EQ(fmt::format("{0:x}", static_cast<__uint128_t>(0)), "0");
+  EXPECT_EQ("8000000000000000",
+            fmt::format("{0:x}", static_cast<__int128_t>(INT64_MAX) + 1));
+  EXPECT_EQ("-8000000000000001",
+            fmt::format("{0:x}", static_cast<__int128_t>(INT64_MIN) - 1));
+  EXPECT_EQ("10000000000000000",
+            fmt::format("{0:x}", static_cast<__int128_t>(UINT64_MAX) + 1));
+  EXPECT_EQ("7fffffffffffffffffffffffffffffff",
+            fmt::format("{0:x}", int128_max));
+  EXPECT_EQ("-80000000000000000000000000000000",
+            fmt::format("{0:x}", int128_min));
+  EXPECT_EQ("ffffffffffffffffffffffffffffffff",
+            fmt::format("{0:x}", uint128_max));
+#endif
+
+  char buffer[buffer_size];
+  safe_sprintf(buffer, "-%x", 0 - static_cast<unsigned>(INT_MIN));
+  EXPECT_EQ(buffer, fmt::format("{0:x}", INT_MIN));
+  safe_sprintf(buffer, "%x", INT_MAX);
+  EXPECT_EQ(buffer, fmt::format("{0:x}", INT_MAX));
+  safe_sprintf(buffer, "%x", UINT_MAX);
+  EXPECT_EQ(buffer, fmt::format("{0:x}", UINT_MAX));
+  safe_sprintf(buffer, "-%lx", 0 - static_cast<unsigned long>(LONG_MIN));
+  EXPECT_EQ(buffer, fmt::format("{0:x}", LONG_MIN));
+  safe_sprintf(buffer, "%lx", LONG_MAX);
+  EXPECT_EQ(buffer, fmt::format("{0:x}", LONG_MAX));
+  safe_sprintf(buffer, "%lx", ULONG_MAX);
+  EXPECT_EQ(buffer, fmt::format("{0:x}", ULONG_MAX));
+}
+
+TEST(format_test, format_oct) {
+  EXPECT_EQ(fmt::format("{0:o}", 0), "0");
+  EXPECT_EQ(fmt::format("{0:o}", 042), "42");
+  EXPECT_EQ(fmt::format("{0:o}", 042u), "42");
+  EXPECT_EQ(fmt::format("{0:o}", -042), "-42");
+  EXPECT_EQ(fmt::format("{0:o}", 012345670), "12345670");
+#if FMT_USE_INT128
+  EXPECT_EQ(fmt::format("{0:o}", static_cast<__int128_t>(0)), "0");
+  EXPECT_EQ(fmt::format("{0:o}", static_cast<__uint128_t>(0)), "0");
+  EXPECT_EQ("1000000000000000000000",
+            fmt::format("{0:o}", static_cast<__int128_t>(INT64_MAX) + 1));
+  EXPECT_EQ("-1000000000000000000001",
+            fmt::format("{0:o}", static_cast<__int128_t>(INT64_MIN) - 1));
+  EXPECT_EQ("2000000000000000000000",
+            fmt::format("{0:o}", static_cast<__int128_t>(UINT64_MAX) + 1));
+  EXPECT_EQ("1777777777777777777777777777777777777777777",
+            fmt::format("{0:o}", int128_max));
+  EXPECT_EQ("-2000000000000000000000000000000000000000000",
+            fmt::format("{0:o}", int128_min));
+  EXPECT_EQ("3777777777777777777777777777777777777777777",
+            fmt::format("{0:o}", uint128_max));
+#endif
+
+  char buffer[buffer_size];
+  safe_sprintf(buffer, "-%o", 0 - static_cast<unsigned>(INT_MIN));
+  EXPECT_EQ(buffer, fmt::format("{0:o}", INT_MIN));
+  safe_sprintf(buffer, "%o", INT_MAX);
+  EXPECT_EQ(buffer, fmt::format("{0:o}", INT_MAX));
+  safe_sprintf(buffer, "%o", UINT_MAX);
+  EXPECT_EQ(buffer, fmt::format("{0:o}", UINT_MAX));
+  safe_sprintf(buffer, "-%lo", 0 - static_cast<unsigned long>(LONG_MIN));
+  EXPECT_EQ(buffer, fmt::format("{0:o}", LONG_MIN));
+  safe_sprintf(buffer, "%lo", LONG_MAX);
+  EXPECT_EQ(buffer, fmt::format("{0:o}", LONG_MAX));
+  safe_sprintf(buffer, "%lo", ULONG_MAX);
+  EXPECT_EQ(buffer, fmt::format("{0:o}", ULONG_MAX));
+}
+
+TEST(format_test, format_int_locale) {
+  EXPECT_EQ(fmt::format("{:L}", 1234), "1234");
+}
+
+TEST(format_test, format_float) {
+  EXPECT_EQ(fmt::format("{}", 0.0f), "0");
+  EXPECT_EQ(fmt::format("{0:f}", 392.5f), "392.500000");
+}
+
+TEST(format_test, format_double) {
+  EXPECT_EQ(fmt::format("{}", 0.0), "0");
+  check_unknown_types(1.2, "eEfFgGaAnL%", "double");
+  EXPECT_EQ(fmt::format("{:}", 0.0), "0");
+  EXPECT_EQ(fmt::format("{:f}", 0.0), "0.000000");
+  EXPECT_EQ(fmt::format("{:g}", 0.0), "0");
+  EXPECT_EQ(fmt::format("{:}", 392.65), "392.65");
+  EXPECT_EQ(fmt::format("{:g}", 392.65), "392.65");
+  EXPECT_EQ(fmt::format("{:G}", 392.65), "392.65");
+  EXPECT_EQ(fmt::format("{:g}", 4.9014e6), "4.9014e+06");
+  EXPECT_EQ(fmt::format("{:f}", 392.65), "392.650000");
+  EXPECT_EQ(fmt::format("{:F}", 392.65), "392.650000");
+  EXPECT_EQ(fmt::format("{:L}", 42.0), "42");
+  EXPECT_EQ(fmt::format("{:24a}", 4.2f), "           0x1.0cccccp+2");
+  EXPECT_EQ(fmt::format("{:24a}", 4.2), "    0x1.0cccccccccccdp+2");
+  EXPECT_EQ(fmt::format("{:<24a}", 4.2), "0x1.0cccccccccccdp+2    ");
+  EXPECT_EQ(fmt::format("{0:e}", 392.65), "3.926500e+02");
+  EXPECT_EQ(fmt::format("{0:E}", 392.65), "3.926500E+02");
+  EXPECT_EQ(fmt::format("{0:+010.4g}", 392.65), "+0000392.6");
+
+#if FMT_CPLUSPLUS >= 201703L
+  double xd = 0x1.ffffffffffp+2;
+  EXPECT_EQ(fmt::format("{:.10a}", xd), "0x1.ffffffffffp+2");
+  EXPECT_EQ(fmt::format("{:.9a}", xd), "0x2.000000000p+2");
+
+  if (std::numeric_limits<long double>::digits == 64) {
+    auto ld = 0xf.ffffffffffp-3l;
+    EXPECT_EQ(fmt::format("{:a}", ld), "0xf.ffffffffffp-3");
+    EXPECT_EQ(fmt::format("{:.10a}", ld), "0xf.ffffffffffp-3");
+    EXPECT_EQ(fmt::format("{:.9a}", ld), "0x1.000000000p+1");
+  }
+#endif
+
+  if (fmt::detail::const_check(std::numeric_limits<double>::is_iec559)) {
+    double d = (std::numeric_limits<double>::min)();
+    EXPECT_EQ(fmt::format("{:a}", d), "0x1p-1022");
+    EXPECT_EQ(fmt::format("{:#a}", d), "0x1.p-1022");
+
+    d = (std::numeric_limits<double>::max)();
+    EXPECT_EQ(fmt::format("{:a}", d), "0x1.fffffffffffffp+1023");
+
+    d = std::numeric_limits<double>::denorm_min();
+    EXPECT_EQ(fmt::format("{:a}", d), "0x0.0000000000001p-1022");
+  }
+
+  if (std::numeric_limits<long double>::digits == 64) {
+    auto ld = (std::numeric_limits<long double>::min)();
+    EXPECT_EQ(fmt::format("{:a}", ld), "0x8p-16385");
+
+    ld = (std::numeric_limits<long double>::max)();
+    EXPECT_EQ(fmt::format("{:a}", ld), "0xf.fffffffffffffffp+16380");
+
+    ld = std::numeric_limits<long double>::denorm_min();
+    EXPECT_EQ(fmt::format("{:a}", ld), "0x0.000000000000001p-16382");
+  }
+
+  EXPECT_EQ(fmt::format("{:.10a}", 4.2), "0x1.0ccccccccdp+2");
+
+  EXPECT_EQ(fmt::format("{:a}", -42.0), "-0x1.5p+5");
+  EXPECT_EQ(fmt::format("{:A}", -42.0), "-0X1.5P+5");
+
+  EXPECT_EQ(fmt::format("{:f}", 9223372036854775807.0),
+            "9223372036854775808.000000");
+}
+
+TEST(format_test, precision_rounding) {
+  EXPECT_EQ(fmt::format("{:.0f}", 0.0), "0");
+  EXPECT_EQ(fmt::format("{:.0f}", 0.01), "0");
+  EXPECT_EQ(fmt::format("{:.0f}", 0.1), "0");
+  EXPECT_EQ(fmt::format("{:.3f}", 0.00049), "0.000");
+  EXPECT_EQ(fmt::format("{:.3f}", 0.0005), "0.001");
+  EXPECT_EQ(fmt::format("{:.3f}", 0.00149), "0.001");
+  EXPECT_EQ(fmt::format("{:.3f}", 0.0015), "0.002");
+  EXPECT_EQ(fmt::format("{:.3f}", 0.9999), "1.000");
+  EXPECT_EQ(fmt::format("{:.3}", 0.00123), "0.00123");
+  EXPECT_EQ(fmt::format("{:.16g}", 0.1), "0.1");
+  EXPECT_EQ(fmt::format("{:.0}", 1.0), "1");
+  EXPECT_EQ("225.51575035152063720",
+            fmt::format("{:.17f}", 225.51575035152064));
+  EXPECT_EQ(fmt::format("{:.1f}", -761519619559038.2), "-761519619559038.2");
+  EXPECT_EQ("1.9156918820264798e-56",
+            fmt::format("{}", 1.9156918820264798e-56));
+  EXPECT_EQ(fmt::format("{:.4f}", 7.2809479766055470e-15), "0.0000");
+}
+
+TEST(format_test, prettify_float) {
+  EXPECT_EQ(fmt::format("{}", 1e-4), "0.0001");
+  EXPECT_EQ(fmt::format("{}", 1e-5), "1e-05");
+  EXPECT_EQ(fmt::format("{}", 1e15), "1000000000000000");
+  EXPECT_EQ(fmt::format("{}", 1e16), "1e+16");
+  EXPECT_EQ(fmt::format("{}", 9.999e-5), "9.999e-05");
+  EXPECT_EQ(fmt::format("{}", 1e10), "10000000000");
+  EXPECT_EQ(fmt::format("{}", 1e11), "100000000000");
+  EXPECT_EQ(fmt::format("{}", 1234e7), "12340000000");
+  EXPECT_EQ(fmt::format("{}", 1234e-2), "12.34");
+  EXPECT_EQ(fmt::format("{}", 1234e-6), "0.001234");
+  EXPECT_EQ(fmt::format("{}", 0.1f), "0.1");
+  EXPECT_EQ(fmt::format("{}", 1.35631564e-19f), "1.3563156e-19");
+}
+
+TEST(format_test, format_nan) {
+  double nan = std::numeric_limits<double>::quiet_NaN();
+  EXPECT_EQ(fmt::format("{}", nan), "nan");
+  EXPECT_EQ(fmt::format("{:+}", nan), "+nan");
+  EXPECT_EQ(fmt::format("{:+06}", nan), "  +nan");
+  EXPECT_EQ(fmt::format("{:<+06}", nan), "+nan  ");
+  EXPECT_EQ(fmt::format("{:^+06}", nan), " +nan ");
+  EXPECT_EQ(fmt::format("{:>+06}", nan), "  +nan");
+  if (std::signbit(-nan)) {
+    EXPECT_EQ(fmt::format("{}", -nan), "-nan");
+    EXPECT_EQ(fmt::format("{:+06}", -nan), "  -nan");
+  } else {
+    fmt::print("Warning: compiler doesn't handle negative NaN correctly");
+  }
+  EXPECT_EQ(fmt::format("{: }", nan), " nan");
+  EXPECT_EQ(fmt::format("{:F}", nan), "NAN");
+  EXPECT_EQ(fmt::format("{:<7}", nan), "nan    ");
+  EXPECT_EQ(fmt::format("{:^7}", nan), "  nan  ");
+  EXPECT_EQ(fmt::format("{:>7}", nan), "    nan");
+}
+
+TEST(format_test, format_infinity) {
+  double inf = std::numeric_limits<double>::infinity();
+  EXPECT_EQ(fmt::format("{}", inf), "inf");
+  EXPECT_EQ(fmt::format("{:+}", inf), "+inf");
+  EXPECT_EQ(fmt::format("{}", -inf), "-inf");
+  EXPECT_EQ(fmt::format("{:+06}", inf), "  +inf");
+  EXPECT_EQ(fmt::format("{:+06}", -inf), "  -inf");
+  EXPECT_EQ(fmt::format("{:<+06}", inf), "+inf  ");
+  EXPECT_EQ(fmt::format("{:^+06}", inf), " +inf ");
+  EXPECT_EQ(fmt::format("{:>+06}", inf), "  +inf");
+  EXPECT_EQ(fmt::format("{: }", inf), " inf");
+  EXPECT_EQ(fmt::format("{:F}", inf), "INF");
+  EXPECT_EQ(fmt::format("{:<7}", inf), "inf    ");
+  EXPECT_EQ(fmt::format("{:^7}", inf), "  inf  ");
+  EXPECT_EQ(fmt::format("{:>7}", inf), "    inf");
+}
+
+TEST(format_test, format_long_double) {
+  EXPECT_EQ(fmt::format("{0:}", 0.0l), "0");
+  EXPECT_EQ(fmt::format("{0:f}", 0.0l), "0.000000");
+  EXPECT_EQ(fmt::format("{:.1f}", 0.000000001l), "0.0");
+  EXPECT_EQ(fmt::format("{:.2f}", 0.099l), "0.10");
+  EXPECT_EQ(fmt::format("{0:}", 392.65l), "392.65");
+  EXPECT_EQ(fmt::format("{0:g}", 392.65l), "392.65");
+  EXPECT_EQ(fmt::format("{0:G}", 392.65l), "392.65");
+  EXPECT_EQ(fmt::format("{0:f}", 392.65l), "392.650000");
+  EXPECT_EQ(fmt::format("{0:F}", 392.65l), "392.650000");
+  char buffer[buffer_size];
+  safe_sprintf(buffer, "%Le", 392.65l);
+  EXPECT_EQ(buffer, fmt::format("{0:e}", 392.65l));
+  EXPECT_EQ(fmt::format("{0:+010.4g}", 392.64l), "+0000392.6");
+
+  auto ld = 3.31l;
+  if (fmt::detail::is_double_double<decltype(ld)>::value) {
+    safe_sprintf(buffer, "%a", static_cast<double>(ld));
+    EXPECT_EQ(buffer, fmt::format("{:a}", ld));
+  } else if (std::numeric_limits<long double>::digits == 64) {
+    EXPECT_EQ(fmt::format("{:a}", ld), "0xd.3d70a3d70a3d70ap-2");
+  }
+}
+
+TEST(format_test, format_char) {
+  const char types[] = "cbBdoxX";
+  check_unknown_types('a', types, "char");
+  EXPECT_EQ(fmt::format("{0}", 'a'), "a");
+  EXPECT_EQ(fmt::format("{0:c}", 'z'), "z");
+  int n = 'x';
+  for (const char* type = types + 1; *type; ++type) {
+    std::string format_str = fmt::format("{{:{}}}", *type);
+    EXPECT_EQ(fmt::format(runtime(format_str), n),
+              fmt::format(runtime(format_str), 'x'))
+        << format_str;
+  }
+  EXPECT_EQ(fmt::format("{:02X}", n), fmt::format("{:02X}", 'x'));
+
+  EXPECT_EQ(fmt::format("{}", '\n'), "\n");
+  EXPECT_EQ(fmt::format("{:?}", '\n'), "'\\n'");
+  EXPECT_EQ(fmt::format("{:x}", '\xff'), "ff");
+}
+
+TEST(format_test, format_volatile_char) {
+  volatile char c = 'x';
+  EXPECT_EQ(fmt::format("{}", c), "x");
+}
+
+TEST(format_test, format_unsigned_char) {
+  EXPECT_EQ(fmt::format("{}", static_cast<unsigned char>(42)), "42");
+  EXPECT_EQ(fmt::format("{}", static_cast<uint8_t>(42)), "42");
+}
+
+TEST(format_test, format_cstring) {
+  check_unknown_types("test", "sp", "string");
+  EXPECT_EQ(fmt::format("{0}", "test"), "test");
+  EXPECT_EQ(fmt::format("{0:s}", "test"), "test");
+  char nonconst[] = "nonconst";
+  EXPECT_EQ(fmt::format("{0}", nonconst), "nonconst");
+  auto nullstr = static_cast<const char*>(nullptr);
+  EXPECT_THROW_MSG((void)fmt::format("{}", nullstr), format_error,
+                   "string pointer is null");
+  EXPECT_THROW_MSG((void)fmt::format("{:s}", nullstr), format_error,
+                   "string pointer is null");
+}
+
+void function_pointer_test(int, double, std::string) {}
+
+TEST(format_test, format_pointer) {
+  check_unknown_types(reinterpret_cast<void*>(0x1234), "p", "pointer");
+  EXPECT_EQ(fmt::format("{0}", static_cast<void*>(nullptr)), "0x0");
+  EXPECT_EQ(fmt::format("{0}", reinterpret_cast<void*>(0x1234)), "0x1234");
+  EXPECT_EQ(fmt::format("{0:p}", reinterpret_cast<void*>(0x1234)), "0x1234");
+  // On CHERI (or other fat-pointer) systems, the size of a pointer is greater
+  // than the size an integer that can hold a virtual address.  There is no
+  // portable address-as-an-integer type (yet) in C++, so we use `size_t` as
+  // the closest equivalent for now.
+  EXPECT_EQ("0x" + std::string(sizeof(size_t) * CHAR_BIT / 4, 'f'),
+            fmt::format("{0}", reinterpret_cast<void*>(~uintptr_t())));
+  EXPECT_EQ("0x1234",
+            fmt::format("{}", fmt::ptr(reinterpret_cast<int*>(0x1234))));
+  std::unique_ptr<int> up(new int(1));
+  EXPECT_EQ(fmt::format("{}", fmt::ptr(up.get())),
+            fmt::format("{}", fmt::ptr(up)));
+  struct custom_deleter {
+    void operator()(int* p) const { delete p; }
+  };
+  std::unique_ptr<int, custom_deleter> upcd(new int(1));
+  EXPECT_EQ(fmt::format("{}", fmt::ptr(upcd.get())),
+            fmt::format("{}", fmt::ptr(upcd)));
+  std::shared_ptr<int> sp(new int(1));
+  EXPECT_EQ(fmt::format("{}", fmt::ptr(sp.get())),
+            fmt::format("{}", fmt::ptr(sp)));
+  EXPECT_EQ(fmt::format("{}", fmt::detail::bit_cast<const void*>(
+                                  &function_pointer_test)),
+            fmt::format("{}", fmt::ptr(function_pointer_test)));
+  EXPECT_EQ(fmt::format("{}", nullptr), "0x0");
+}
+
+TEST(format_test, write_uintptr_fallback) {
+  // Test that formatting a pointer by converting it to uint128_fallback works.
+  // This is needed to support systems without uintptr_t.
+  auto s = std::string();
+  fmt::detail::write_ptr<char>(
+      std::back_inserter(s),
+      fmt::detail::bit_cast<fmt::detail::uint128_fallback>(
+          reinterpret_cast<void*>(0xface)),
+      nullptr);
+  EXPECT_EQ(s, "0xface");
+}
+
+enum class color { red, green, blue };
+
+namespace test_ns {
+enum class color { red, green, blue };
+using fmt::enums::format_as;
+}  // namespace test_ns
+
+TEST(format_test, format_enum_class) {
+  EXPECT_EQ(fmt::format("{}", fmt::underlying(color::red)), "0");
+  EXPECT_EQ(fmt::format("{}", test_ns::color::red), "0");
+}
+
+TEST(format_test, format_string) {
+  EXPECT_EQ(fmt::format("{0}", std::string("test")), "test");
+  EXPECT_EQ(fmt::format("{0}", std::string("test")), "test");
+  EXPECT_EQ(fmt::format("{:?}", std::string("test")), "\"test\"");
+  EXPECT_EQ(fmt::format("{:*^10?}", std::string("test")), "**\"test\"**");
+  EXPECT_EQ(fmt::format("{:?}", std::string("\test")), "\"\\test\"");
+  EXPECT_THROW((void)fmt::format(fmt::runtime("{:x}"), std::string("test")),
+               fmt::format_error);
+}
+
+TEST(format_test, format_string_view) {
+  EXPECT_EQ(fmt::format("{}", string_view("test")), "test");
+  EXPECT_EQ(fmt::format("{:?}", string_view("t\nst")), "\"t\\nst\"");
+  EXPECT_EQ(fmt::format("{}", string_view()), "");
+}
+
+#ifdef FMT_USE_STRING_VIEW
+struct string_viewable {};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<string_viewable> : formatter<std::string_view> {
+  auto format(string_viewable, format_context& ctx) -> decltype(ctx.out()) {
+    return formatter<std::string_view>::format("foo", ctx);
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(format_test, format_std_string_view) {
+  EXPECT_EQ(fmt::format("{}", std::string_view("test")), "test");
+  EXPECT_EQ(fmt::format("{}", string_viewable()), "foo");
+}
+
+struct explicitly_convertible_to_std_string_view {
+  explicit operator std::string_view() const { return "foo"; }
+};
+
+template <>
+struct fmt::formatter<explicitly_convertible_to_std_string_view>
+    : formatter<std::string_view> {
+  auto format(explicitly_convertible_to_std_string_view v, format_context& ctx)
+      -> decltype(ctx.out()) {
+    return fmt::format_to(ctx.out(), "'{}'", std::string_view(v));
+  }
+};
+
+TEST(format_test, format_explicitly_convertible_to_std_string_view) {
+  EXPECT_EQ("'foo'",
+            fmt::format("{}", explicitly_convertible_to_std_string_view()));
+}
+#endif
+
+class Answer {};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<date> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    auto it = ctx.begin();
+    if (it != ctx.end() && *it == 'd') ++it;
+    return it;
+  }
+
+  auto format(const date& d, format_context& ctx) -> decltype(ctx.out()) {
+    // Namespace-qualify to avoid ambiguity with std::format_to.
+    fmt::format_to(ctx.out(), "{}-{}-{}", d.year(), d.month(), d.day());
+    return ctx.out();
+  }
+};
+
+template <> struct formatter<Answer> : formatter<int> {
+  template <typename FormatContext>
+  auto format(Answer, FormatContext& ctx) -> decltype(ctx.out()) {
+    return formatter<int>::format(42, ctx);
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(format_test, format_custom) {
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{:s}"), date(2012, 12, 9)),
+                   format_error, "unknown format specifier");
+  EXPECT_EQ(fmt::format("{0}", Answer()), "42");
+  EXPECT_EQ(fmt::format("{:04}", Answer()), "0042");
+}
+
+TEST(format_test, format_to_custom) {
+  char buf[10] = {};
+  auto end = fmt::format_to(buf, "{}", Answer());
+  EXPECT_EQ(end, buf + 2);
+  EXPECT_STREQ(buf, "42");
+}
+
+TEST(format_test, format_string_from_speed_test) {
+  EXPECT_EQ("1.2340000000:0042:+3.13:str:0x3e8:X:%",
+            fmt::format("{0:0.10f}:{1:04}:{2:+g}:{3}:{4}:{5}:%", 1.234, 42,
+                        3.13, "str", reinterpret_cast<void*>(1000), 'X'));
+}
+
+TEST(format_test, format_examples) {
+  std::string message = fmt::format("The answer is {}", 42);
+  EXPECT_EQ("The answer is 42", message);
+
+  EXPECT_EQ(fmt::format("{}", 42), "42");
+
+  memory_buffer out;
+  fmt::format_to(std::back_inserter(out), "The answer is {}.", 42);
+  EXPECT_EQ("The answer is 42.", to_string(out));
+
+  const char* filename = "nonexistent";
+  FILE* ftest = safe_fopen(filename, "r");
+  if (ftest) fclose(ftest);
+  int error_code = errno;
+  EXPECT_TRUE(ftest == nullptr);
+  EXPECT_SYSTEM_ERROR(
+      {
+        FILE* f = safe_fopen(filename, "r");
+        if (!f)
+          throw fmt::system_error(errno, "Cannot open file '{}'", filename);
+        fclose(f);
+      },
+      error_code, "Cannot open file 'nonexistent'");
+
+  EXPECT_EQ("First, thou shalt count to three",
+            fmt::format("First, thou shalt count to {0}", "three"));
+  EXPECT_EQ(fmt::format("Bring me a {}", "shrubbery"), "Bring me a shrubbery");
+  EXPECT_EQ(fmt::format("From {} to {}", 1, 3), "From 1 to 3");
+
+  char buffer[buffer_size];
+  safe_sprintf(buffer, "%03.2f", -1.2);
+  EXPECT_EQ(buffer, fmt::format("{:03.2f}", -1.2));
+
+  EXPECT_EQ(fmt::format("{0}, {1}, {2}", 'a', 'b', 'c'), "a, b, c");
+  EXPECT_EQ(fmt::format("{}, {}, {}", 'a', 'b', 'c'), "a, b, c");
+  EXPECT_EQ(fmt::format("{2}, {1}, {0}", 'a', 'b', 'c'), "c, b, a");
+  EXPECT_EQ(fmt::format("{0}{1}{0}", "abra", "cad"), "abracadabra");
+
+  EXPECT_EQ("left aligned                  ",
+            fmt::format("{:<30}", "left aligned"));
+  EXPECT_EQ("                 right aligned",
+            fmt::format("{:>30}", "right aligned"));
+  EXPECT_EQ("           centered           ",
+            fmt::format("{:^30}", "centered"));
+  EXPECT_EQ("***********centered***********",
+            fmt::format("{:*^30}", "centered"));
+
+  EXPECT_EQ(fmt::format("{:+f}; {:+f}", 3.14, -3.14), "+3.140000; -3.140000");
+  EXPECT_EQ(fmt::format("{: f}; {: f}", 3.14, -3.14), " 3.140000; -3.140000");
+  EXPECT_EQ(fmt::format("{:-f}; {:-f}", 3.14, -3.14), "3.140000; -3.140000");
+
+  EXPECT_EQ("int: 42;  hex: 2a;  oct: 52",
+            fmt::format("int: {0:d};  hex: {0:x};  oct: {0:o}", 42));
+  EXPECT_EQ("int: 42;  hex: 0x2a;  oct: 052",
+            fmt::format("int: {0:d};  hex: {0:#x};  oct: {0:#o}", 42));
+
+  EXPECT_EQ(fmt::format("The answer is {}", 42), "The answer is 42");
+  EXPECT_THROW_MSG(
+      (void)fmt::format(runtime("The answer is {:d}"), "forty-two"),
+      format_error, "invalid format specifier");
+
+  EXPECT_WRITE(
+      stdout, fmt::print("{}", std::numeric_limits<double>::infinity()), "inf");
+}
+
+TEST(format_test, print) {
+  EXPECT_WRITE(stdout, fmt::print("Don't {}!", "panic"), "Don't panic!");
+  EXPECT_WRITE(stderr, fmt::print(stderr, "Don't {}!", "panic"),
+               "Don't panic!");
+  EXPECT_WRITE(stdout, fmt::println("Don't {}!", "panic"), "Don't panic!\n");
+  EXPECT_WRITE(stderr, fmt::println(stderr, "Don't {}!", "panic"),
+               "Don't panic!\n");
+}
+
+TEST(format_test, variadic) {
+  EXPECT_EQ(fmt::format("{}c{}", "ab", 1), "abc1");
+}
+
+TEST(format_test, bytes) {
+  auto s = fmt::format("{:10}", fmt::bytes("ёжик"));
+  EXPECT_EQ("ёжик  ", s);
+  EXPECT_EQ(10, s.size());
+}
+
+TEST(format_test, group_digits_view) {
+  EXPECT_EQ(fmt::format("{}", fmt::group_digits(10000000)), "10,000,000");
+  EXPECT_EQ(fmt::format("{:8}", fmt::group_digits(1000)), "   1,000");
+}
+
+#ifdef __cpp_generic_lambdas
+struct point {
+  double x, y;
+};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<point> : nested_formatter<double> {
+  auto format(point p, format_context& ctx) const -> decltype(ctx.out()) {
+    return write_padded(ctx, [this, p](auto out) -> decltype(out) {
+      return fmt::format_to(out, "({}, {})", nested(p.x), nested(p.y));
+    });
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(format_test, nested_formatter) {
+  EXPECT_EQ(fmt::format("{:>16.2f}", point{1, 2}), "    (1.00, 2.00)");
+}
+#endif  // __cpp_generic_lambdas
+
+enum test_enum { foo, bar };
+auto format_as(test_enum e) -> int { return e; }
+
+TEST(format_test, join) {
+  using fmt::join;
+  int v1[3] = {1, 2, 3};
+  auto v2 = std::vector<float>();
+  v2.push_back(1.2f);
+  v2.push_back(3.4f);
+  void* v3[2] = {&v1[0], &v1[1]};
+
+  EXPECT_EQ(fmt::format("({})", join(v1, v1 + 3, ", ")), "(1, 2, 3)");
+  EXPECT_EQ(fmt::format("({})", join(v1, v1 + 1, ", ")), "(1)");
+  EXPECT_EQ(fmt::format("({})", join(v1, v1, ", ")), "()");
+  EXPECT_EQ(fmt::format("({:03})", join(v1, v1 + 3, ", ")), "(001, 002, 003)");
+  EXPECT_EQ("(+01.20, +03.40)",
+            fmt::format("({:+06.2f})", join(v2.begin(), v2.end(), ", ")));
+
+  EXPECT_EQ(fmt::format("{0:{1}}", join(v1, v1 + 3, ", "), 1), "1, 2, 3");
+
+  EXPECT_EQ(fmt::format("{}, {}", v3[0], v3[1]),
+            fmt::format("{}", join(v3, v3 + 2, ", ")));
+
+  EXPECT_EQ(fmt::format("({})", join(v1, ", ")), "(1, 2, 3)");
+  EXPECT_EQ(fmt::format("({:+06.2f})", join(v2, ", ")), "(+01.20, +03.40)");
+
+  auto v4 = std::vector<test_enum>{foo, bar, foo};
+  EXPECT_EQ(fmt::format("{}", join(v4, " ")), "0 1 0");
+}
+
+#ifdef __cpp_lib_byte
+TEST(format_test, join_bytes) {
+  auto v = std::vector<std::byte>{std::byte(1), std::byte(2), std::byte(3)};
+  EXPECT_EQ(fmt::format("{}", fmt::join(v, ", ")), "1, 2, 3");
+}
+#endif
+
+std::string vformat_message(int id, const char* format, fmt::format_args args) {
+  auto buffer = fmt::memory_buffer();
+  fmt::format_to(fmt::appender(buffer), "[{}] ", id);
+  vformat_to(fmt::appender(buffer), format, args);
+  return to_string(buffer);
+}
+
+template <typename... Args>
+std::string format_message(int id, const char* format, const Args&... args) {
+  auto va = fmt::make_format_args(args...);
+  return vformat_message(id, format, va);
+}
+
+TEST(format_test, format_message_example) {
+  EXPECT_EQ("[42] something happened",
+            format_message(42, "{} happened", "something"));
+}
+
+template <typename... Args>
+void print_error(const char* file, int line, const char* format,
+                 const Args&... args) {
+  fmt::print("{}: {}: ", file, line);
+  fmt::print(format, args...);
+}
+
+TEST(format_test, unpacked_args) {
+  EXPECT_EQ("0123456789abcdefg",
+            fmt::format("{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}", 0, 1, 2, 3, 4, 5,
+                        6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e', 'f', 'g'));
+}
+
+constexpr char with_null[3] = {'{', '}', '\0'};
+constexpr char no_null[2] = {'{', '}'};
+static constexpr const char static_with_null[3] = {'{', '}', '\0'};
+static constexpr const char static_no_null[2] = {'{', '}'};
+
+TEST(format_test, compile_time_string) {
+  EXPECT_EQ(fmt::format(FMT_STRING("foo")), "foo");
+  EXPECT_EQ(fmt::format(FMT_STRING("{}"), 42), "42");
+
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+  using namespace fmt::literals;
+  EXPECT_EQ("foobar", fmt::format(FMT_STRING("{foo}{bar}"), "bar"_a = "bar",
+                                  "foo"_a = "foo"));
+  EXPECT_EQ(fmt::format(FMT_STRING("")), "");
+  EXPECT_EQ(fmt::format(FMT_STRING(""), "arg"_a = 42), "");
+  EXPECT_EQ(fmt::format(FMT_STRING("{answer}"), "answer"_a = Answer()), "42");
+  EXPECT_EQ(fmt::format(FMT_STRING("{} {two}"), 1, "two"_a = 2), "1 2");
+#endif
+
+  (void)static_with_null;
+  (void)static_no_null;
+#ifndef _MSC_VER
+  EXPECT_EQ(fmt::format(FMT_STRING(static_with_null), 42), "42");
+  EXPECT_EQ(fmt::format(FMT_STRING(static_no_null), 42), "42");
+#endif
+
+  (void)with_null;
+  (void)no_null;
+#if FMT_CPLUSPLUS >= 201703L
+  EXPECT_EQ(fmt::format(FMT_STRING(with_null), 42), "42");
+  EXPECT_EQ(fmt::format(FMT_STRING(no_null), 42), "42");
+#endif
+#if defined(FMT_USE_STRING_VIEW) && FMT_CPLUSPLUS >= 201703L
+  EXPECT_EQ(fmt::format(FMT_STRING(std::string_view("{}")), 42), "42");
+#endif
+}
+
+TEST(format_test, custom_format_compile_time_string) {
+  EXPECT_EQ(fmt::format(FMT_STRING("{}"), Answer()), "42");
+  auto answer = Answer();
+  EXPECT_EQ(fmt::format(FMT_STRING("{}"), answer), "42");
+  char buf[10] = {};
+  fmt::format_to(buf, FMT_STRING("{}"), answer);
+  const Answer const_answer = Answer();
+  EXPECT_EQ(fmt::format(FMT_STRING("{}"), const_answer), "42");
+}
+
+#if FMT_USE_USER_DEFINED_LITERALS
+TEST(format_test, named_arg_udl) {
+  using namespace fmt::literals;
+  auto udl_a = fmt::format("{first}{second}{first}{third}", "first"_a = "abra",
+                           "second"_a = "cad", "third"_a = 99);
+  EXPECT_EQ(
+      fmt::format("{first}{second}{first}{third}", fmt::arg("first", "abra"),
+                  fmt::arg("second", "cad"), fmt::arg("third", 99)),
+      udl_a);
+
+  EXPECT_EQ(fmt::format("{answer}", "answer"_a = Answer()), "42");
+}
+#endif  // FMT_USE_USER_DEFINED_LITERALS
+
+TEST(format_test, enum) { EXPECT_EQ(fmt::format("{}", foo), "0"); }
+
+TEST(format_test, formatter_not_specialized) {
+  static_assert(!fmt::has_formatter<fmt::formatter<test_enum>,
+                                    fmt::format_context>::value,
+                "");
+}
+
+#if FMT_HAS_FEATURE(cxx_strong_enums)
+enum big_enum : unsigned long long { big_enum_value = 5000000000ULL };
+auto format_as(big_enum e) -> unsigned long long { return e; }
+
+TEST(format_test, strong_enum) {
+  EXPECT_EQ(fmt::format("{}", big_enum_value), "5000000000");
+}
+#endif
+
+TEST(format_test, non_null_terminated_format_string) {
+  EXPECT_EQ(fmt::format(string_view("{}foo", 2), 42), "42");
+}
+
+namespace adl_test {
+namespace fmt {
+namespace detail {
+struct foo {};
+template <typename, typename OutputIt> void write(OutputIt, foo) = delete;
+}  // namespace detail
+}  // namespace fmt
+}  // namespace adl_test
+
+FMT_BEGIN_NAMESPACE
+template <>
+struct formatter<adl_test::fmt::detail::foo> : formatter<std::string> {
+  auto format(adl_test::fmt::detail::foo, format_context& ctx)
+      -> decltype(ctx.out()) {
+    return formatter<std::string>::format("foo", ctx);
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(format_test, to_string) {
+  EXPECT_EQ(fmt::to_string(42), "42");
+  EXPECT_EQ(fmt::to_string(reinterpret_cast<void*>(0x1234)), "0x1234");
+  EXPECT_EQ(fmt::to_string(adl_test::fmt::detail::foo()), "foo");
+  EXPECT_EQ(fmt::to_string(foo), "0");
+
+#if FMT_USE_FLOAT128
+  EXPECT_EQ(fmt::to_string(__float128(0.5)), "0.5");
+#endif
+
+#if defined(FMT_USE_STRING_VIEW) && FMT_CPLUSPLUS >= 201703L
+  EXPECT_EQ(fmt::to_string(std::string_view()), "");
+#endif
+}
+
+TEST(format_test, output_iterators) {
+  std::list<char> out;
+  fmt::format_to(std::back_inserter(out), "{}", 42);
+  EXPECT_EQ("42", std::string(out.begin(), out.end()));
+  std::stringstream s;
+  fmt::format_to(std::ostream_iterator<char>(s), "{}", 42);
+  EXPECT_EQ("42", s.str());
+}
+
+TEST(format_test, formatted_size) {
+  EXPECT_EQ(2u, fmt::formatted_size("{}", 42));
+  EXPECT_EQ(2u, fmt::formatted_size(std::locale(), "{}", 42));
+}
+
+TEST(format_test, format_to_no_args) {
+  std::string s;
+  fmt::format_to(std::back_inserter(s), "test");
+  EXPECT_EQ("test", s);
+}
+
+TEST(format_test, format_to) {
+  std::string s;
+  fmt::format_to(std::back_inserter(s), "part{0}", 1);
+  EXPECT_EQ("part1", s);
+  fmt::format_to(std::back_inserter(s), "part{0}", 2);
+  EXPECT_EQ("part1part2", s);
+}
+
+TEST(format_test, format_to_memory_buffer) {
+  auto buf = fmt::basic_memory_buffer<char, 100>();
+  fmt::format_to(fmt::appender(buf), "{}", "foo");
+  EXPECT_EQ("foo", to_string(buf));
+}
+
+TEST(format_test, format_to_vector) {
+  std::vector<char> v;
+  fmt::format_to(std::back_inserter(v), "{}", "foo");
+  EXPECT_EQ(string_view(v.data(), v.size()), "foo");
+}
+
+struct nongrowing_container {
+  using value_type = char;
+  void push_back(char) { throw std::runtime_error("can't take it any more"); }
+};
+
+TEST(format_test, format_to_propagates_exceptions) {
+  auto c = nongrowing_container();
+  EXPECT_THROW(fmt::format_to(std::back_inserter(c), "{}", 42),
+               std::runtime_error);
+}
+
+TEST(format_test, format_to_n) {
+  char buffer[4];
+  buffer[3] = 'x';
+  auto result = fmt::format_to_n(buffer, 3, "{}", 12345);
+  EXPECT_EQ(5u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ("123x", fmt::string_view(buffer, 4));
+
+  result = fmt::format_to_n(buffer, 3, "{:s}", "foobar");
+  EXPECT_EQ(6u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ("foox", fmt::string_view(buffer, 4));
+
+  buffer[0] = 'x';
+  buffer[1] = 'x';
+  buffer[2] = 'x';
+  result = fmt::format_to_n(buffer, 3, "{}", 'A');
+  EXPECT_EQ(1u, result.size);
+  EXPECT_EQ(buffer + 1, result.out);
+  EXPECT_EQ("Axxx", fmt::string_view(buffer, 4));
+
+  result = fmt::format_to_n(buffer, 3, "{}{} ", 'B', 'C');
+  EXPECT_EQ(3u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ("BC x", fmt::string_view(buffer, 4));
+
+  result = fmt::format_to_n(buffer, 4, "{}", "ABCDE");
+  EXPECT_EQ(5u, result.size);
+  EXPECT_EQ("ABCD", fmt::string_view(buffer, 4));
+
+  buffer[3] = 'x';
+  result = fmt::format_to_n(buffer, 3, "{}", std::string(1000, '*'));
+  EXPECT_EQ(1000u, result.size);
+  EXPECT_EQ("***x", fmt::string_view(buffer, 4));
+}
+
+struct test_output_iterator {
+  char* data;
+
+  using iterator_category = std::output_iterator_tag;
+  using value_type = void;
+  using difference_type = void;
+  using pointer = void;
+  using reference = void;
+
+  auto operator++() -> test_output_iterator& {
+    ++data;
+    return *this;
+  }
+  auto operator++(int) -> test_output_iterator {
+    auto tmp = *this;
+    ++data;
+    return tmp;
+  }
+  auto operator*() -> char& { return *data; }
+};
+
+TEST(format_test, format_to_n_output_iterator) {
+  char buf[10] = {};
+  fmt::format_to_n(test_output_iterator{buf}, 10, "{}", 42);
+  EXPECT_STREQ(buf, "42");
+}
+
+TEST(format_test, vformat_to) {
+  using context = fmt::format_context;
+  int n = 42;
+  auto args = fmt::make_format_args<context>(n);
+  auto s = std::string();
+  fmt::vformat_to(std::back_inserter(s), "{}", args);
+  EXPECT_EQ(s, "42");
+  s.clear();
+  fmt::vformat_to(std::back_inserter(s), FMT_STRING("{}"), args);
+  EXPECT_EQ(s, "42");
+}
+
+TEST(format_test, char_traits_not_ambiguous) {
+  // Test that we don't inject detail names into the std namespace.
+  using namespace std;
+  auto c = char_traits<char>::char_type();
+  (void)c;
+#if FMT_CPLUSPLUS >= 201103L
+  auto s = std::string();
+  auto lval = begin(s);
+  (void)lval;
+#endif
+}
+
+struct check_back_appender {};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<check_back_appender> {
+  FMT_CONSTEXPR auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename Context>
+  auto format(check_back_appender, Context& ctx) -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    static_assert(std::is_same<decltype(++out), decltype(out)&>::value,
+                  "needs to satisfy weakly_incrementable");
+    *out = 'y';
+    return ++out;
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(format_test, back_insert_slicing) {
+  EXPECT_EQ(fmt::format("{}", check_back_appender{}), "y");
+}
+
+namespace test {
+enum class scoped_enum_as_int {};
+auto format_as(scoped_enum_as_int) -> int { return 42; }
+
+enum class scoped_enum_as_string_view {};
+auto format_as(scoped_enum_as_string_view) -> fmt::string_view { return "foo"; }
+
+enum class scoped_enum_as_string {};
+auto format_as(scoped_enum_as_string) -> std::string { return "foo"; }
+
+struct struct_as_int {};
+auto format_as(struct_as_int) -> int { return 42; }
+
+struct struct_as_const_reference {
+  const std::string name = "foo";
+};
+auto format_as(const struct_as_const_reference& s) -> const std::string& {
+  return s.name;
+}
+}  // namespace test
+
+TEST(format_test, format_as) {
+  EXPECT_EQ(fmt::format("{}", test::scoped_enum_as_int()), "42");
+  EXPECT_EQ(fmt::format("{}", test::scoped_enum_as_string_view()), "foo");
+  EXPECT_EQ(fmt::format("{}", test::scoped_enum_as_string()), "foo");
+  EXPECT_EQ(fmt::format("{}", test::struct_as_int()), "42");
+  EXPECT_EQ(fmt::format("{}", test::struct_as_const_reference()), "foo");
+}
+
+TEST(format_test, format_as_to_string) {
+  EXPECT_EQ(fmt::to_string(test::scoped_enum_as_int()), "42");
+  EXPECT_EQ(fmt::to_string(test::scoped_enum_as_string_view()), "foo");
+  EXPECT_EQ(fmt::to_string(test::scoped_enum_as_string()), "foo");
+  EXPECT_EQ(fmt::to_string(test::struct_as_int()), "42");
+}
+
+template <typename Char, typename T> auto check_enabled_formatter() -> bool {
+  static_assert(std::is_default_constructible<fmt::formatter<T, Char>>::value,
+                "");
+  return true;
+}
+
+template <typename Char, typename... T> void check_enabled_formatters() {
+  auto dummy = {check_enabled_formatter<Char, T>()...};
+  (void)dummy;
+}
+
+TEST(format_test, test_formatters_enabled) {
+  check_enabled_formatters<char, bool, char, signed char, unsigned char, short,
+                           unsigned short, int, unsigned, long, unsigned long,
+                           long long, unsigned long long, float, double,
+                           long double, void*, const void*, char*, const char*,
+                           std::string, std::nullptr_t>();
+  check_enabled_formatters<wchar_t, bool, wchar_t, signed char, unsigned char,
+                           short, unsigned short, int, unsigned, long,
+                           unsigned long, long long, unsigned long long, float,
+                           double, long double, void*, const void*, wchar_t*,
+                           const wchar_t*, std::wstring, std::nullptr_t>();
+}
+
+TEST(format_int_test, data) {
+  fmt::format_int format_int(42);
+  EXPECT_EQ(std::string(format_int.data(), format_int.size()), "42");
+}
+
+TEST(format_int_test, format_int) {
+  EXPECT_EQ(fmt::format_int(42).str(), "42");
+  EXPECT_EQ(fmt::format_int(42).size(), 2u);
+  EXPECT_EQ(fmt::format_int(-42).str(), "-42");
+  EXPECT_EQ(fmt::format_int(-42).size(), 3u);
+  EXPECT_EQ(fmt::format_int(42ul).str(), "42");
+  EXPECT_EQ(fmt::format_int(-42l).str(), "-42");
+  EXPECT_EQ(fmt::format_int(42ull).str(), "42");
+  EXPECT_EQ(fmt::format_int(-42ll).str(), "-42");\
+  EXPECT_EQ(fmt::format_int(max_value<int64_t>()).str(),
+            std::to_string(max_value<int64_t>()));
+}
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+
+#  include <locale>
+
+class format_facet : public fmt::format_facet<std::locale> {
+ protected:
+  struct int_formatter {
+    fmt::appender out;
+
+    template <typename T, FMT_ENABLE_IF(fmt::detail::is_integer<T>::value)>
+    auto operator()(T value) -> bool {
+      fmt::format_to(out, "[{}]", value);
+      return true;
+    }
+
+    template <typename T, FMT_ENABLE_IF(!fmt::detail::is_integer<T>::value)>
+    auto operator()(T) -> bool {
+      return false;
+    }
+  };
+
+  auto do_put(fmt::appender out, fmt::loc_value val,
+              const fmt::format_specs<>&) const -> bool override;
+};
+
+auto format_facet::do_put(fmt::appender out, fmt::loc_value val,
+                          const fmt::format_specs<>&) const -> bool {
+  return val.visit(int_formatter{out});
+}
+
+TEST(format_test, format_facet) {
+  auto loc = std::locale(std::locale(), new format_facet());
+  EXPECT_EQ(fmt::format(loc, "{:L}", 42), "[42]");
+  EXPECT_EQ(fmt::format(loc, "{:L}", -42), "[-42]");
+}
+
+TEST(format_test, format_facet_separator) {
+  // U+2019 RIGHT SINGLE QUOTATION MARK is a digit separator in the de_CH
+  // locale.
+  auto loc =
+      std::locale({}, new fmt::format_facet<std::locale>("\xe2\x80\x99"));
+  EXPECT_EQ(fmt::format(loc, "{:L}", 1000),
+            "1\xe2\x80\x99"
+            "000");
+}
+
+TEST(format_test, format_facet_grouping) {
+  auto loc =
+      std::locale({}, new fmt::format_facet<std::locale>(",", {1, 2, 3}));
+  EXPECT_EQ(fmt::format(loc, "{:L}", 1234567890), "1,234,567,89,0");
+}
+
+TEST(format_test, format_named_arg_with_locale) {
+  EXPECT_EQ(fmt::format(std::locale(), "{answer}", fmt::arg("answer", 42)),
+            "42");
+}
+
+TEST(format_test, format_locale) {
+  auto loc = std::locale({}, new fmt::format_facet<std::locale>(","));
+  EXPECT_EQ(fmt::format(loc, "{:Lx}", 123456789), "7,5bc,d15");
+  EXPECT_EQ(fmt::format(loc, "{:#Lb}", -123456789),
+            "-0b111,010,110,111,100,110,100,010,101");
+  EXPECT_EQ(fmt::format(loc, "{:10Lo}", 12345), "    30,071");
+}
+
+#endif  // FMT_STATIC_THOUSANDS_SEPARATOR
+
+struct convertible_to_nonconst_cstring {
+  operator char*() const {
+    static char c[] = "bar";
+    return c;
+  }
+};
+
+FMT_BEGIN_NAMESPACE
+template <>
+struct formatter<convertible_to_nonconst_cstring> : formatter<char*> {};
+FMT_END_NAMESPACE
+
+TEST(format_test, formatter_nonconst_char) {
+  EXPECT_EQ(fmt::format("{}", convertible_to_nonconst_cstring()), "bar");
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/.gitignore b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..ea4104026128ae8a2930bfbc01a91d33d3b6f920
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/.gitignore
@@ -0,0 +1,3 @@
+# ignore artifacts from the build.sh script
+build-*/
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..afcf9df102d083a2ac5d6a58f76f639ba9f0af3a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/CMakeLists.txt
@@ -0,0 +1,30 @@
+# Copyright (c) 2019, Paul Dreik
+# License: see LICENSE.rst in the fmt root directory
+
+# Link in the main function. Useful for reproducing, kcov, gdb, afl, valgrind.
+# (Note that libFuzzer can also reproduce, just pass it the files.)
+option(FMT_FUZZ_LINKMAIN "Enables the reproduce mode, instead of libFuzzer" On)
+
+# For oss-fuzz - insert $LIB_FUZZING_ENGINE into the link flags, but only for
+# the fuzz targets, otherwise the CMake configuration step fails.
+set(FMT_FUZZ_LDFLAGS "" CACHE STRING "LDFLAGS for the fuzz targets")
+
+# Adds a binary for reproducing, i.e. no fuzzing, just enables replaying data
+# through the fuzzers.
+function(add_fuzzer source)
+  get_filename_component(basename ${source} NAME_WE)
+  set(name ${basename}-fuzzer)
+  add_executable(${name} ${source} fuzzer-common.h)
+  if (FMT_FUZZ_LINKMAIN)
+    target_sources(${name} PRIVATE main.cc)
+  endif ()
+  target_link_libraries(${name} PRIVATE fmt)
+  if (FMT_FUZZ_LDFLAGS)
+    target_link_libraries(${name} PRIVATE ${FMT_FUZZ_LDFLAGS})
+  endif ()
+  target_compile_features(${name} PRIVATE cxx_std_14)
+endfunction()
+
+foreach (source chrono-duration.cc chrono-timepoint.cc float.cc named-arg.cc one-arg.cc two-args.cc)
+  add_fuzzer(${source})
+endforeach ()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/README.md b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..bb3d0e04f19bed04852e7154f56857d466064646
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/README.md
@@ -0,0 +1,25 @@
+# Running the fuzzers locally
+
+There is a [helper script](build.sh) to build the fuzzers, which has only been
+tested on Debian and Ubuntu linux so far. There should be no problems fuzzing on
+Windows (using clang>=8) or on Mac, but the script will probably not work out of
+the box.
+
+Something along
+```sh
+mkdir build
+cd build
+export CXX=clang++
+export CXXFLAGS="-fsanitize=fuzzer-no-link -DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION= -g"
+cmake .. -DFMT_SAFE_DURATION_CAST=On -DFMT_FUZZ=On -DFMT_FUZZ_LINKMAIN=Off -DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer"
+cmake --build .
+```
+should work to build the fuzzers for all platforms which clang supports.
+
+Execute a fuzzer with for instance
+```sh
+cd build
+export UBSAN_OPTIONS=halt_on_error=1
+mkdir out_chrono
+bin/fuzzer_chrono_duration out_chrono
+```
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/build.sh b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/build.sh
new file mode 100644
index 0000000000000000000000000000000000000000..4497b62c11bf295e218a32874fef047b6d83811d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/build.sh
@@ -0,0 +1,90 @@
+#!/bin/sh
+#
+# Creates fuzzer builds of various kinds
+# - oss-fuzz emulated mode (makes sure a simulated invocation by oss-fuzz works)
+# - libFuzzer build (you will need clang)
+# - afl build (you will need afl)
+#
+#
+# Copyright (c) 2019 Paul Dreik
+#
+# For the license information refer to format.h.
+
+set -e
+me=$(basename $0)
+root=$(readlink -f "$(dirname "$0")/../..")
+
+
+echo $me: root=$root
+
+here=$(pwd)
+
+CXXFLAGSALL="-DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION= -g"
+CMAKEFLAGSALL="$root -GNinja -DCMAKE_BUILD_TYPE=Debug -DFMT_DOC=Off -DFMT_TEST=Off -DFMT_FUZZ=On -DCMAKE_CXX_STANDARD=17"
+
+CLANG=clang++-11
+
+# For performance analysis of the fuzzers.
+builddir=$here/build-fuzzers-perfanalysis
+mkdir -p $builddir
+cd $builddir
+CXX="ccache g++" CXXFLAGS="$CXXFLAGSALL -g" cmake \
+$CMAKEFLAGSALL \
+-DFMT_FUZZ_LINKMAIN=On \
+-DCMAKE_BUILD_TYPE=Release
+
+cmake --build $builddir
+
+# Builds the fuzzers as oss-fuzz does.
+builddir=$here/build-fuzzers-ossfuzz
+mkdir -p $builddir
+cd $builddir
+CXX=$CLANG \
+CXXFLAGS="$CXXFLAGSALL -fsanitize=fuzzer-no-link" cmake \
+cmake $CMAKEFLAGSALL \
+-DFMT_FUZZ_LINKMAIN=Off \
+-DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer"
+
+cmake --build $builddir
+
+
+# Builds fuzzers for local fuzzing with libfuzzer with asan+usan.
+builddir=$here/build-fuzzers-libfuzzer
+mkdir -p $builddir
+cd $builddir
+CXX=$CLANG \
+CXXFLAGS="$CXXFLAGSALL -fsanitize=fuzzer-no-link,address,undefined" cmake \
+cmake $CMAKEFLAGSALL \
+-DFMT_FUZZ_LINKMAIN=Off \
+-DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer"
+
+cmake --build $builddir
+
+# Builds a fast fuzzer for making coverage fast.
+builddir=$here/build-fuzzers-fast
+mkdir -p $builddir
+cd $builddir
+CXX=$CLANG \
+CXXFLAGS="$CXXFLAGSALL -fsanitize=fuzzer-no-link -O3" cmake \
+cmake $CMAKEFLAGSALL \
+-DFMT_FUZZ_LINKMAIN=Off \
+-DFMT_FUZZ_LDFLAGS="-fsanitize=fuzzer" \
+ -DCMAKE_BUILD_TYPE=Release
+
+cmake --build $builddir
+
+
+# Builds fuzzers for local fuzzing with afl.
+builddir=$here/build-fuzzers-afl
+mkdir -p $builddir
+cd $builddir
+CXX="afl-g++" \
+CXXFLAGS="$CXXFLAGSALL -fsanitize=address,undefined" \
+cmake $CMAKEFLAGSALL \
+-DFMT_FUZZ_LINKMAIN=On
+
+cmake --build $builddir
+
+
+echo $me: all good
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/chrono-duration.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/chrono-duration.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d66068d9c030ea7d502c7bc865115ca9777116d6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/chrono-duration.cc
@@ -0,0 +1,136 @@
+// Copyright (c) 2019, Paul Dreik
+// For the license information refer to format.h.
+
+#include <fmt/chrono.h>
+
+#include <cstdint>
+
+#include "fuzzer-common.h"
+
+template <typename Period, typename Rep>
+void invoke_inner(fmt::string_view format_str, Rep rep) {
+  auto value = std::chrono::duration<Rep, Period>(rep);
+  try {
+#if FMT_FUZZ_FORMAT_TO_STRING
+    std::string message = fmt::format(format_str, value);
+#else
+    auto buf = fmt::memory_buffer();
+    fmt::format_to(std::back_inserter(buf), format_str, value);
+#endif
+  } catch (std::exception&) {
+  }
+}
+
+// Rep is a duration's representation type.
+template <typename Rep>
+void invoke_outer(const uint8_t* data, size_t size, int period) {
+  // Always use a fixed location of the data.
+  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
+  if (size <= fixed_size + 1) return;
+
+  const Rep rep = assign_from_buf<Rep>(data);
+  data += fixed_size;
+  size -= fixed_size;
+
+  // data is already allocated separately in libFuzzer so reading past the end
+  // will most likely be detected anyway.
+  const auto format_str = fmt::string_view(as_chars(data), size);
+
+  // yocto, zepto, zetta and yotta are not handled.
+  switch (period) {
+  case 1:
+    invoke_inner<std::atto>(format_str, rep);
+    break;
+  case 2:
+    invoke_inner<std::femto>(format_str, rep);
+    break;
+  case 3:
+    invoke_inner<std::pico>(format_str, rep);
+    break;
+  case 4:
+    invoke_inner<std::nano>(format_str, rep);
+    break;
+  case 5:
+    invoke_inner<std::micro>(format_str, rep);
+    break;
+  case 6:
+    invoke_inner<std::milli>(format_str, rep);
+    break;
+  case 7:
+    invoke_inner<std::centi>(format_str, rep);
+    break;
+  case 8:
+    invoke_inner<std::deci>(format_str, rep);
+    break;
+  case 9:
+    invoke_inner<std::deca>(format_str, rep);
+    break;
+  case 10:
+    invoke_inner<std::kilo>(format_str, rep);
+    break;
+  case 11:
+    invoke_inner<std::mega>(format_str, rep);
+    break;
+  case 12:
+    invoke_inner<std::giga>(format_str, rep);
+    break;
+  case 13:
+    invoke_inner<std::tera>(format_str, rep);
+    break;
+  case 14:
+    invoke_inner<std::peta>(format_str, rep);
+    break;
+  case 15:
+    invoke_inner<std::exa>(format_str, rep);
+    break;
+  }
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  if (size <= 4) return 0;
+
+  const auto representation = data[0];
+  const auto period = data[1];
+  data += 2;
+  size -= 2;
+
+  switch (representation) {
+  case 1:
+    invoke_outer<char>(data, size, period);
+    break;
+  case 2:
+    invoke_outer<signed char>(data, size, period);
+    break;
+  case 3:
+    invoke_outer<unsigned char>(data, size, period);
+    break;
+  case 4:
+    invoke_outer<short>(data, size, period);
+    break;
+  case 5:
+    invoke_outer<unsigned short>(data, size, period);
+    break;
+  case 6:
+    invoke_outer<int>(data, size, period);
+    break;
+  case 7:
+    invoke_outer<unsigned int>(data, size, period);
+    break;
+  case 8:
+    invoke_outer<long>(data, size, period);
+    break;
+  case 9:
+    invoke_outer<unsigned long>(data, size, period);
+    break;
+  case 10:
+    invoke_outer<float>(data, size, period);
+    break;
+  case 11:
+    invoke_outer<double>(data, size, period);
+    break;
+  case 12:
+    invoke_outer<long double>(data, size, period);
+    break;
+  }
+  return 0;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/chrono-timepoint.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/chrono-timepoint.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8a1b24d29458105db7189f3508ffebbd90eeb668
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/chrono-timepoint.cc
@@ -0,0 +1,32 @@
+// Copyright (c) 2021, Paul Dreik
+// For license information refer to format.h.
+#include <fmt/chrono.h>
+
+#include "fuzzer-common.h"
+
+/*
+ * a fuzzer for the chrono timepoints formatters
+ * C is a clock (std::chrono::system_clock etc)
+ */
+template <typename C> void doit(const uint8_t* data, size_t size) {
+  using Rep = typename C::time_point::rep;
+  constexpr auto N = sizeof(Rep);
+  if (size < N) return;
+
+  const auto x = assign_from_buf<Rep>(data);
+  typename C::duration dur{x};
+  typename C::time_point timepoint{dur};
+  data += N;
+  size -= N;
+  data_to_string format_str(data, size);
+
+  std::string message = fmt::format(format_str.get(), timepoint);
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  try {
+    doit<std::chrono::system_clock>(data, size);
+  } catch (...) {
+  }
+  return 0;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/float.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/float.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d4c9e4f579e50a325ca1f3334978789cb10a97d3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/float.cc
@@ -0,0 +1,39 @@
+// A fuzzer for floating-point formatter.
+// For the license information refer to format.h.
+
+#include <fmt/format.h>
+
+#include <cstdint>
+#include <cstdlib>
+#include <limits>
+#include <stdexcept>
+
+#include "fuzzer-common.h"
+
+void check_round_trip(fmt::string_view format_str, double value) {
+  auto buffer = fmt::memory_buffer();
+  fmt::format_to(std::back_inserter(buffer), format_str, value);
+
+  if (std::isnan(value)) {
+    auto nan = std::signbit(value) ? "-nan" : "nan";
+    if (fmt::string_view(buffer.data(), buffer.size()) != nan)
+      throw std::runtime_error("round trip failure");
+    return;
+  }
+
+  buffer.push_back('\0');
+  char* ptr = nullptr;
+  if (std::strtod(buffer.data(), &ptr) != value)
+    throw std::runtime_error("round trip failure");
+  if (ptr + 1 != buffer.end()) throw std::runtime_error("unparsed output");
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  if (size <= sizeof(double) || !std::numeric_limits<double>::is_iec559)
+    return 0;
+  check_round_trip("{}", assign_from_buf<double>(data));
+  // A larger than necessary precision is used to trigger the fallback
+  // formatter.
+  check_round_trip("{:.50g}", assign_from_buf<double>(data));
+  return 0;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/fuzzer-common.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/fuzzer-common.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0a2467228974a060b1726204dd42d276b21c5a1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/fuzzer-common.h
@@ -0,0 +1,77 @@
+// Copyright (c) 2019, Paul Dreik
+// For the license information refer to format.h.
+
+#ifndef FUZZER_COMMON_H
+#define FUZZER_COMMON_H
+
+#include <fmt/core.h>
+
+#include <cstdint>  // std::uint8_t
+#include <cstring>  // memcpy
+#include <vector>
+
+// One can format to either a string, or a buffer. The latter is faster, but
+// one may be interested in formatting to a string instead to verify it works
+// as intended. To avoid a combinatoric explosion, select this at compile time
+// instead of dynamically from the fuzz data.
+#define FMT_FUZZ_FORMAT_TO_STRING 0
+
+// If {fmt} is given a buffer that is separately allocated, chances that address
+// sanitizer detects out of bound reads is much higher. However, it slows down
+// the fuzzing.
+#define FMT_FUZZ_SEPARATE_ALLOCATION 1
+
+// The size of the largest possible type in use.
+// To let the the fuzzer mutation be efficient at cross pollinating between
+// different types, use a fixed size format. The same bit pattern, interpreted
+// as another type, is likely interesting.
+constexpr auto fixed_size = 16;
+
+// Casts data to a char pointer.
+template <typename T> inline const char* as_chars(const T* data) {
+  return reinterpret_cast<const char*>(data);
+}
+
+// Casts data to a byte pointer.
+template <typename T> inline const std::uint8_t* as_bytes(const T* data) {
+  return reinterpret_cast<const std::uint8_t*>(data);
+}
+
+// Blits bytes from data to form an (assumed trivially constructible) object
+// of type Item.
+template <class Item> inline Item assign_from_buf(const std::uint8_t* data) {
+  auto item = Item();
+  std::memcpy(&item, data, sizeof(Item));
+  return item;
+}
+
+// Reads a boolean value by looking at the first byte from data.
+template <> inline bool assign_from_buf<bool>(const std::uint8_t* data) {
+  return *data != 0;
+}
+
+struct data_to_string {
+#if FMT_FUZZ_SEPARATE_ALLOCATION
+  std::vector<char> buffer;
+
+  data_to_string(const uint8_t* data, size_t size, bool add_terminator = false)
+      : buffer(size + (add_terminator ? 1 : 0)) {
+    if (size) {
+      std::memcpy(buffer.data(), data, size);
+    }
+  }
+
+  fmt::string_view get() const { return {buffer.data(), buffer.size()}; }
+#else
+  fmt::string_view sv;
+
+  data_to_string(const uint8_t* data, size_t size, bool = false)
+      : str(as_chars(data), size) {}
+
+  fmt::string_view get() const { return sv; }
+#endif
+
+  const char* data() const { return get().data(); }
+};
+
+#endif  // FUZZER_COMMON_H
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/main.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/main.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8f8c719b7263ec5328f9277cf53efd0156f51ef7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/main.cc
@@ -0,0 +1,22 @@
+#include <cassert>
+#include <fstream>
+#include <vector>
+
+#include "fuzzer-common.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
+
+int main(int argc, char** argv) {
+  for (int i = 1; i < argc; ++i) {
+    std::ifstream in(argv[i]);
+    assert(in);
+    in.seekg(0, std::ios_base::end);
+    const auto size = in.tellg();
+    assert(size >= 0);
+    in.seekg(0, std::ios_base::beg);
+    std::vector<char> buf(static_cast<size_t>(size));
+    in.read(buf.data(), size);
+    assert(in.gcount() == size);
+    LLVMFuzzerTestOneInput(as_bytes(buf.data()), buf.size());
+  }
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/named-arg.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/named-arg.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3bee1ae3b2e9d2fa99a69f70147763a37b8626f9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/named-arg.cc
@@ -0,0 +1,102 @@
+// Copyright (c) 2019, Paul Dreik
+// For the license information refer to format.h.
+
+#include <fmt/chrono.h>
+
+#include <cstdint>
+#include <type_traits>
+#include <vector>
+
+#include "fuzzer-common.h"
+
+template <typename T>
+void invoke_fmt(const uint8_t* data, size_t size, unsigned arg_name_size) {
+  static_assert(sizeof(T) <= fixed_size, "fixed_size too small");
+  if (size <= fixed_size) return;
+  const T value = assign_from_buf<T>(data);
+  data += fixed_size;
+  size -= fixed_size;
+
+  if (arg_name_size <= 0 || arg_name_size >= size) return;
+  data_to_string arg_name(data, arg_name_size, true);
+  data += arg_name_size;
+  size -= arg_name_size;
+
+  data_to_string format_str(data, size);
+  try {
+#if FMT_FUZZ_FORMAT_TO_STRING
+    std::string message =
+        fmt::format(format_str.get(), fmt::arg(arg_name.data(), value));
+#else
+    fmt::memory_buffer out;
+    fmt::format_to(std::back_inserter(out), format_str.get(),
+                   fmt::arg(arg_name.data(), value));
+#endif
+  } catch (std::exception&) {
+  }
+}
+
+// For dynamic dispatching to an explicit instantiation.
+template <typename Callback> void invoke(int type, Callback callback) {
+  switch (type) {
+  case 0:
+    callback(bool());
+    break;
+  case 1:
+    callback(char());
+    break;
+  case 2:
+    using sc = signed char;
+    callback(sc());
+    break;
+  case 3:
+    using uc = unsigned char;
+    callback(uc());
+    break;
+  case 4:
+    callback(short());
+    break;
+  case 5:
+    using us = unsigned short;
+    callback(us());
+    break;
+  case 6:
+    callback(int());
+    break;
+  case 7:
+    callback(unsigned());
+    break;
+  case 8:
+    callback(long());
+    break;
+  case 9:
+    using ul = unsigned long;
+    callback(ul());
+    break;
+  case 10:
+    callback(float());
+    break;
+  case 11:
+    callback(double());
+    break;
+  case 12:
+    using LD = long double;
+    callback(LD());
+    break;
+  }
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  if (size <= 3) return 0;
+
+  // Switch types depending on the first byte of the input.
+  const auto type = data[0] & 0x0F;
+  const unsigned arg_name_size = (data[0] & 0xF0) >> 4;
+  data++;
+  size--;
+
+  invoke(type, [=](auto arg) {
+    invoke_fmt<decltype(arg)>(data, size, arg_name_size);
+  });
+  return 0;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/one-arg.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/one-arg.cc
new file mode 100644
index 0000000000000000000000000000000000000000..af9787f81e9e447c39db997746b1f09023e732b7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/one-arg.cc
@@ -0,0 +1,92 @@
+// Copyright (c) 2019, Paul Dreik
+// For the license information refer to format.h.
+
+#include <fmt/chrono.h>
+
+#include <cstdint>
+#include <exception>
+
+#include "fuzzer-common.h"
+
+template <typename T, typename Repr> const T* from_repr(const Repr& r) {
+  return &r;
+}
+
+template <> const std::tm* from_repr<std::tm>(const std::time_t& t) {
+  return std::localtime(&t);
+}
+
+template <typename T, typename Repr = T>
+void invoke_fmt(const uint8_t* data, size_t size) {
+  static_assert(sizeof(Repr) <= fixed_size, "Nfixed is too small");
+  if (size <= fixed_size) return;
+  auto repr = assign_from_buf<Repr>(data);
+  const T* value = from_repr<T>(repr);
+  if (!value) return;
+  data += fixed_size;
+  size -= fixed_size;
+  data_to_string format_str(data, size);
+  try {
+#if FMT_FUZZ_FORMAT_TO_STRING
+    std::string message = fmt::format(format_str.get(), *value);
+#else
+    auto buf = fmt::memory_buffer();
+    fmt::format_to(std::back_inserter(buf), format_str.get(), *value);
+#endif
+  } catch (std::exception&) {
+  }
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  if (size <= 3) return 0;
+
+  const auto first = data[0];
+  data++;
+  size--;
+
+  switch (first) {
+  case 0:
+    invoke_fmt<bool>(data, size);
+    break;
+  case 1:
+    invoke_fmt<char>(data, size);
+    break;
+  case 2:
+    invoke_fmt<unsigned char>(data, size);
+    break;
+  case 3:
+    invoke_fmt<signed char>(data, size);
+    break;
+  case 4:
+    invoke_fmt<short>(data, size);
+    break;
+  case 5:
+    invoke_fmt<unsigned short>(data, size);
+    break;
+  case 6:
+    invoke_fmt<int>(data, size);
+    break;
+  case 7:
+    invoke_fmt<unsigned int>(data, size);
+    break;
+  case 8:
+    invoke_fmt<long>(data, size);
+    break;
+  case 9:
+    invoke_fmt<unsigned long>(data, size);
+    break;
+  case 10:
+    invoke_fmt<float>(data, size);
+    break;
+  case 11:
+    invoke_fmt<double>(data, size);
+    break;
+  case 12:
+    invoke_fmt<long double>(data, size);
+    break;
+  case 13:
+    invoke_fmt<std::tm, std::time_t>(data, size);
+    break;
+  }
+  return 0;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/two-args.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/two-args.cc
new file mode 100644
index 0000000000000000000000000000000000000000..931c6465651d2c29bc41eded973e732390e43b0a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/fuzzing/two-args.cc
@@ -0,0 +1,106 @@
+// Copyright (c) 2019, Paul Dreik
+// For the license information refer to format.h.
+
+#include <fmt/format.h>
+
+#include <cstdint>
+#include <exception>
+#include <string>
+
+#include "fuzzer-common.h"
+
+template <typename Item1, typename Item2>
+void invoke_fmt(const uint8_t* data, size_t size) {
+  static_assert(sizeof(Item1) <= fixed_size, "size1 exceeded");
+  static_assert(sizeof(Item2) <= fixed_size, "size2 exceeded");
+  if (size <= fixed_size + fixed_size) return;
+
+  const Item1 item1 = assign_from_buf<Item1>(data);
+  data += fixed_size;
+  size -= fixed_size;
+
+  const Item2 item2 = assign_from_buf<Item2>(data);
+  data += fixed_size;
+  size -= fixed_size;
+
+  auto format_str = fmt::string_view(as_chars(data), size);
+#if FMT_FUZZ_FORMAT_TO_STRING
+  std::string message = fmt::format(format_str, item1, item2);
+#else
+  auto buf = fmt::memory_buffer();
+  fmt::format_to(std::back_inserter(buf), format_str, item1, item2);
+#endif
+}
+
+// For dynamic dispatching to an explicit instantiation.
+template <typename Callback> void invoke(int index, Callback callback) {
+  switch (index) {
+  case 0:
+    callback(bool());
+    break;
+  case 1:
+    callback(char());
+    break;
+  case 2:
+    using sc = signed char;
+    callback(sc());
+    break;
+  case 3:
+    using uc = unsigned char;
+    callback(uc());
+    break;
+  case 4:
+    callback(short());
+    break;
+  case 5:
+    using us = unsigned short;
+    callback(us());
+    break;
+  case 6:
+    callback(int());
+    break;
+  case 7:
+    callback(unsigned());
+    break;
+  case 8:
+    callback(long());
+    break;
+  case 9:
+    using ul = unsigned long;
+    callback(ul());
+    break;
+  case 10:
+    callback(float());
+    break;
+  case 11:
+    callback(double());
+    break;
+  case 12:
+    using LD = long double;
+    callback(LD());
+    break;
+  case 13:
+    using ptr = void*;
+    callback(ptr());
+    break;
+  }
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  if (size <= 3) return 0;
+
+  // Switch types depending on the first byte of the input.
+  const auto type1 = data[0] & 0x0F;
+  const auto type2 = (data[0] & 0xF0) >> 4;
+  data++;
+  size--;
+  try {
+    invoke(type1, [=](auto param1) {
+      invoke(type2, [=](auto param2) {
+        invoke_fmt<decltype(param1), decltype(param2)>(data, size);
+      });
+    });
+  } catch (std::exception&) {
+  }
+  return 0;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest-extra-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest-extra-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..34054b68700611a6a3e5d273e5ea1d14670f0a59
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest-extra-test.cc
@@ -0,0 +1,415 @@
+// Formatting library for C++ - tests of custom Google Test assertions
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "gtest-extra.h"
+
+#include <gtest/gtest-spi.h>
+
+#include <cstring>
+#include <memory>
+#include <stdexcept>
+
+#include "fmt/os.h"
+#include "util.h"
+
+// Tests that assertion macros evaluate their arguments exactly once.
+namespace {
+class single_evaluation_test : public ::testing::Test {
+ protected:
+  single_evaluation_test() {
+    p_ = s_;
+    a_ = 0;
+    b_ = 0;
+  }
+
+  static const char* const s_;
+  static const char* p_;
+
+  static int a_;
+  static int b_;
+};
+}  // namespace
+
+const char* const single_evaluation_test::s_ = "01234";
+const char* single_evaluation_test::p_;
+int single_evaluation_test::a_;
+int single_evaluation_test::b_;
+
+void do_nothing() {}
+
+FMT_NORETURN void throw_exception() { throw std::runtime_error("test"); }
+
+FMT_NORETURN void throw_system_error() {
+  throw fmt::system_error(EDOM, "test");
+}
+
+// Tests that when EXPECT_THROW_MSG fails, it evaluates its message argument
+// exactly once.
+TEST_F(single_evaluation_test, failed_expect_throw_msg) {
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(throw_exception(), std::exception, p_++), "01234");
+  EXPECT_EQ(s_ + 1, p_);
+}
+
+// Tests that when EXPECT_SYSTEM_ERROR fails, it evaluates its message argument
+// exactly once.
+TEST_F(single_evaluation_test, failed_expect_system_error) {
+  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, p_++),
+                          "01234");
+  EXPECT_EQ(s_ + 1, p_);
+}
+
+// Tests that assertion arguments are evaluated exactly once.
+TEST_F(single_evaluation_test, exception_tests) {
+  // successful EXPECT_THROW_MSG
+  EXPECT_THROW_MSG(
+      {  // NOLINT
+        a_++;
+        throw_exception();
+      },
+      std::exception, (b_++, "test"));
+  EXPECT_EQ(1, a_);
+  EXPECT_EQ(1, b_);
+
+  // failed EXPECT_THROW_MSG, throws different type
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(
+                              {  // NOLINT
+                                a_++;
+                                throw_exception();
+                              },
+                              std::logic_error, (b_++, "test")),
+                          "throws a different type");
+  EXPECT_EQ(2, a_);
+  EXPECT_EQ(2, b_);
+
+  // failed EXPECT_THROW_MSG, throws an exception with different message
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(
+                              {  // NOLINT
+                                a_++;
+                                throw_exception();
+                              },
+                              std::exception, (b_++, "other")),
+                          "throws an exception with a different message");
+  EXPECT_EQ(3, a_);
+  EXPECT_EQ(3, b_);
+
+  // failed EXPECT_THROW_MSG, throws nothing
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(a_++, std::exception, (b_++, "test")), "throws nothing");
+  EXPECT_EQ(4, a_);
+  EXPECT_EQ(4, b_);
+}
+
+TEST_F(single_evaluation_test, system_error_tests) {
+  // successful EXPECT_SYSTEM_ERROR
+  EXPECT_SYSTEM_ERROR(
+      {  // NOLINT
+        a_++;
+        throw_system_error();
+      },
+      EDOM, (b_++, "test"));
+  EXPECT_EQ(1, a_);
+  EXPECT_EQ(1, b_);
+
+  // failed EXPECT_SYSTEM_ERROR, throws different type
+  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(
+                              {  // NOLINT
+                                a_++;
+                                throw_exception();
+                              },
+                              EDOM, (b_++, "test")),
+                          "throws a different type");
+  EXPECT_EQ(2, a_);
+  EXPECT_EQ(2, b_);
+
+  // failed EXPECT_SYSTEM_ERROR, throws an exception with different message
+  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(
+                              {  // NOLINT
+                                a_++;
+                                throw_system_error();
+                              },
+                              EDOM, (b_++, "other")),
+                          "throws an exception with a different message");
+  EXPECT_EQ(3, a_);
+  EXPECT_EQ(3, b_);
+
+  // failed EXPECT_SYSTEM_ERROR, throws nothing
+  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(a_++, EDOM, (b_++, "test")),
+                          "throws nothing");
+  EXPECT_EQ(4, a_);
+  EXPECT_EQ(4, b_);
+}
+
+#if FMT_USE_FCNTL
+// Tests that when EXPECT_WRITE fails, it evaluates its message argument
+// exactly once.
+TEST_F(single_evaluation_test, failed_expect_write) {
+  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(stdout, std::printf("test"), p_++),
+                          "01234");
+  EXPECT_EQ(s_ + 1, p_);
+}
+
+// Tests that assertion arguments are evaluated exactly once.
+TEST_F(single_evaluation_test, write_tests) {
+  // successful EXPECT_WRITE
+  EXPECT_WRITE(
+      stdout,
+      {  // NOLINT
+        a_++;
+        std::printf("test");
+      },
+      (b_++, "test"));
+  EXPECT_EQ(1, a_);
+  EXPECT_EQ(1, b_);
+
+  // failed EXPECT_WRITE
+  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(
+                              stdout,
+                              {  // NOLINT
+                                a_++;
+                                std::printf("test");
+                              },
+                              (b_++, "other")),
+                          "Actual: test");
+  EXPECT_EQ(2, a_);
+  EXPECT_EQ(2, b_);
+}
+
+// Tests EXPECT_WRITE.
+TEST(gtest_extra_test, expect_write) {
+  EXPECT_WRITE(stdout, do_nothing(), "");
+  EXPECT_WRITE(stdout, std::printf("test"), "test");
+  EXPECT_WRITE(stderr, std::fprintf(stderr, "test"), "test");
+  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(stdout, std::printf("that"), "this"),
+                          "Expected: this\n"
+                          "  Actual: that");
+}
+
+TEST(gtest_extra_test, expect_write_streaming) {
+  EXPECT_WRITE(stdout, std::printf("test"), "test") << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(EXPECT_WRITE(stdout, std::printf("test"), "other")
+                              << "expected failure",
+                          "expected failure");
+}
+#endif  // FMT_USE_FCNTL
+
+// Tests that the compiler will not complain about unreachable code in the
+// EXPECT_THROW_MSG macro.
+TEST(gtest_extra_test, expect_throw_no_unreachable_code_warning) {
+  int n = 0;
+  (void)n;
+  using std::runtime_error;
+  EXPECT_THROW_MSG(throw runtime_error(""), runtime_error, "");
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(n++, runtime_error, ""), "");
+  EXPECT_NONFATAL_FAILURE(EXPECT_THROW_MSG(throw 1, runtime_error, ""), "");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(throw runtime_error("a"), runtime_error, "b"), "");
+}
+
+// Tests that the compiler will not complain about unreachable code in the
+// EXPECT_SYSTEM_ERROR macro.
+TEST(gtest_extra_test, expect_system_error_no_unreachable_code_warning) {
+  int n = 0;
+  (void)n;
+  EXPECT_SYSTEM_ERROR(throw fmt::system_error(EDOM, "test"), EDOM, "test");
+  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(n++, EDOM, ""), "");
+  EXPECT_NONFATAL_FAILURE(EXPECT_SYSTEM_ERROR(throw 1, EDOM, ""), "");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_SYSTEM_ERROR(throw fmt::system_error(EDOM, "aaa"), EDOM, "bbb"),
+      "");
+}
+
+TEST(gtest_extra_test, expect_throw_behaves_like_single_statement) {
+  if (::testing::internal::AlwaysFalse())
+    EXPECT_THROW_MSG(do_nothing(), std::exception, "");
+
+  if (::testing::internal::AlwaysTrue())
+    EXPECT_THROW_MSG(throw_exception(), std::exception, "test");
+  else
+    do_nothing();
+}
+
+TEST(gtest_extra_test, expect_system_error_behaves_like_single_statement) {
+  if (::testing::internal::AlwaysFalse())
+    EXPECT_SYSTEM_ERROR(do_nothing(), EDOM, "");
+
+  if (::testing::internal::AlwaysTrue())
+    EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "test");
+  else
+    do_nothing();
+}
+
+TEST(gtest_extra_test, expect_write_behaves_like_single_statement) {
+  if (::testing::internal::AlwaysFalse())
+    EXPECT_WRITE(stdout, std::printf("x"), "x");
+
+  if (::testing::internal::AlwaysTrue())
+    EXPECT_WRITE(stdout, std::printf("x"), "x");
+  else
+    do_nothing();
+}
+
+// Tests EXPECT_THROW_MSG.
+TEST(gtest_extra_test, expect_throw_msg) {
+  EXPECT_THROW_MSG(throw_exception(), std::exception, "test");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(throw_exception(), std::logic_error, "test"),
+      "Expected: throw_exception() throws an exception of "
+      "type std::logic_error.\n  Actual: it throws a different type.");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(do_nothing(), std::exception, "test"),
+      "Expected: do_nothing() throws an exception of type std::exception.\n"
+      "  Actual: it throws nothing.");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(throw_exception(), std::exception, "other"),
+      "throw_exception() throws an exception with a different message.\n"
+      "Expected: other\n"
+      "  Actual: test");
+}
+
+// Tests EXPECT_SYSTEM_ERROR.
+TEST(gtest_extra_test, expect_system_error) {
+  EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "test");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_SYSTEM_ERROR(throw_exception(), EDOM, "test"),
+      "Expected: throw_exception() throws an exception of "
+      "type std::system_error.\n  Actual: it throws a different type.");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_SYSTEM_ERROR(do_nothing(), EDOM, "test"),
+      "Expected: do_nothing() throws an exception of type std::system_error.\n"
+      "  Actual: it throws nothing.");
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "other"),
+      fmt::format(
+          "throw_system_error() throws an exception with a different message.\n"
+          "Expected: {}\n"
+          "  Actual: {}",
+          system_error_message(EDOM, "other"),
+          system_error_message(EDOM, "test")));
+}
+
+TEST(gtest_extra_test, expect_throw_msg_streaming) {
+  EXPECT_THROW_MSG(throw_exception(), std::exception, "test")
+      << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_THROW_MSG(throw_exception(), std::exception, "other")
+          << "expected failure",
+      "expected failure");
+}
+
+TEST(gtest_extra_test, expect_system_error_streaming) {
+  EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "test")
+      << "unexpected failure";
+  EXPECT_NONFATAL_FAILURE(
+      EXPECT_SYSTEM_ERROR(throw_system_error(), EDOM, "other")
+          << "expected failure",
+      "expected failure");
+}
+
+#if FMT_USE_FCNTL
+
+using fmt::buffered_file;
+using fmt::file;
+
+TEST(output_redirect_test, scoped_redirect) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  {
+    buffered_file file(write_end.fdopen("w"));
+    std::fprintf(file.get(), "[[[");
+    {
+      output_redirect redir(file.get());
+      std::fprintf(file.get(), "censored");
+    }
+    std::fprintf(file.get(), "]]]");
+  }
+  EXPECT_READ(read_end, "[[[]]]");
+}
+
+// Test that output_redirect handles errors in flush correctly.
+TEST(output_redirect_test, flush_error_in_ctor) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  int write_fd = write_end.descriptor();
+  file write_copy = write_end.dup(write_fd);
+  buffered_file f = write_end.fdopen("w");
+  // Put a character in a file buffer.
+  EXPECT_EQ('x', fputc('x', f.get()));
+  FMT_POSIX(close(write_fd));
+  std::unique_ptr<output_redirect> redir{nullptr};
+  EXPECT_SYSTEM_ERROR_NOASSERT(redir.reset(new output_redirect(f.get())), EBADF,
+                               "cannot flush stream");
+  redir.reset(nullptr);
+  write_copy.dup2(write_fd);  // "undo" close or dtor will fail
+}
+
+TEST(output_redirect_test, dup_error_in_ctor) {
+  buffered_file f = open_buffered_file();
+  int fd = (f.descriptor)();
+  file copy = file::dup(fd);
+  FMT_POSIX(close(fd));
+  std::unique_ptr<output_redirect> redir{nullptr};
+  EXPECT_SYSTEM_ERROR_NOASSERT(
+      redir.reset(new output_redirect(f.get(), false)), EBADF,
+      fmt::format("cannot duplicate file descriptor {}", fd));
+  copy.dup2(fd);  // "undo" close or dtor will fail
+}
+
+TEST(output_redirect_test, restore_and_read) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  buffered_file file(write_end.fdopen("w"));
+  std::fprintf(file.get(), "[[[");
+  output_redirect redir(file.get());
+  std::fprintf(file.get(), "censored");
+  EXPECT_EQ("censored", redir.restore_and_read());
+  EXPECT_EQ("", redir.restore_and_read());
+  std::fprintf(file.get(), "]]]");
+  file = buffered_file();
+  EXPECT_READ(read_end, "[[[]]]");
+}
+
+// Test that OutputRedirect handles errors in flush correctly.
+TEST(output_redirect_test, flush_error_in_restore_and_read) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  int write_fd = write_end.descriptor();
+  file write_copy = write_end.dup(write_fd);
+  buffered_file f = write_end.fdopen("w");
+  output_redirect redir(f.get());
+  // Put a character in a file buffer.
+  EXPECT_EQ('x', fputc('x', f.get()));
+  FMT_POSIX(close(write_fd));
+  EXPECT_SYSTEM_ERROR_NOASSERT(redir.restore_and_read(), EBADF,
+                               "cannot flush stream");
+  write_copy.dup2(write_fd);  // "undo" close or dtor will fail
+}
+
+TEST(output_redirect_test, error_in_dtor) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  int write_fd = write_end.descriptor();
+  file write_copy = write_end.dup(write_fd);
+  buffered_file f = write_end.fdopen("w");
+  std::unique_ptr<output_redirect> redir(new output_redirect(f.get()));
+  // Put a character in a file buffer.
+  EXPECT_EQ('x', fputc('x', f.get()));
+  EXPECT_WRITE(
+      stderr,
+      {
+        // The close function must be called inside EXPECT_WRITE,
+        // otherwise the system may recycle closed file descriptor when
+        // redirecting the output in EXPECT_STDERR and the second close
+        // will break output redirection.
+        FMT_POSIX(close(write_fd));
+        SUPPRESS_ASSERT(redir.reset(nullptr));
+      },
+      system_error_message(EBADF, "cannot flush stream"));
+  write_copy.dup2(write_fd);  // "undo" close or dtor of buffered_file will fail
+}
+
+#endif  // FMT_USE_FCNTL
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest-extra.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest-extra.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3d27cf96b3509f1a536436601316b1b346c2f63a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest-extra.cc
@@ -0,0 +1,80 @@
+// Formatting library for C++ - custom Google Test assertions
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "gtest-extra.h"
+
+#if FMT_USE_FCNTL
+
+using fmt::file;
+
+output_redirect::output_redirect(FILE* f, bool flush) : file_(f) {
+  if (flush) this->flush();
+  int fd = FMT_POSIX(fileno(f));
+  // Create a file object referring to the original file.
+  original_ = file::dup(fd);
+  // Create a pipe.
+  file write_end;
+  file::pipe(read_end_, write_end);
+  // Connect the passed FILE object to the write end of the pipe.
+  write_end.dup2(fd);
+}
+
+output_redirect::~output_redirect() noexcept {
+  try {
+    restore();
+  } catch (const std::exception& e) {
+    std::fputs(e.what(), stderr);
+  }
+}
+
+void output_redirect::flush() {
+  int result = 0;
+  do {
+    result = fflush(file_);
+  } while (result == EOF && errno == EINTR);
+  if (result != 0) throw fmt::system_error(errno, "cannot flush stream");
+}
+
+void output_redirect::restore() {
+  if (original_.descriptor() == -1) return;  // Already restored.
+  flush();
+  // Restore the original file.
+  original_.dup2(FMT_POSIX(fileno(file_)));
+  original_.close();
+}
+
+std::string output_redirect::restore_and_read() {
+  // Restore output.
+  restore();
+
+  // Read everything from the pipe.
+  std::string content;
+  if (read_end_.descriptor() == -1) return content;  // Already read.
+  enum { BUFFER_SIZE = 4096 };
+  char buffer[BUFFER_SIZE];
+  size_t count = 0;
+  do {
+    count = read_end_.read(buffer, BUFFER_SIZE);
+    content.append(buffer, count);
+  } while (count != 0);
+  read_end_.close();
+  return content;
+}
+
+std::string read(file& f, size_t count) {
+  std::string buffer(count, '\0');
+  size_t n = 0, offset = 0;
+  do {
+    n = f.read(&buffer[offset], count - offset);
+    // We can't read more than size_t bytes since count has type size_t.
+    offset += n;
+  } while (offset < count && n != 0);
+  buffer.resize(offset);
+  return buffer;
+}
+
+#endif  // FMT_USE_FCNTL
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest-extra.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest-extra.h
new file mode 100644
index 0000000000000000000000000000000000000000..e08c94c0529e6e0357731dabb2a650a634eabb59
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest-extra.h
@@ -0,0 +1,165 @@
+// Formatting library for C++ - custom Google Test assertions
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_GTEST_EXTRA_H_
+#define FMT_GTEST_EXTRA_H_
+
+#include <stdlib.h>  // _invalid_parameter_handler
+
+#include <string>
+
+#include "fmt/os.h"
+#include "gmock/gmock.h"
+
+#define FMT_TEST_THROW_(statement, expected_exception, expected_message, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
+  if (::testing::AssertionResult gtest_ar = ::testing::AssertionSuccess()) {   \
+    std::string gtest_expected_message = expected_message;                     \
+    bool gtest_caught_expected = false;                                        \
+    try {                                                                      \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);               \
+    } catch (expected_exception const& e) {                                    \
+      if (gtest_expected_message != e.what()) {                                \
+        gtest_ar << #statement                                                 \
+            " throws an exception with a different message.\n"                 \
+                 << "Expected: " << gtest_expected_message << "\n"             \
+                 << "  Actual: " << e.what();                                  \
+        goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);            \
+      }                                                                        \
+      gtest_caught_expected = true;                                            \
+    } catch (...) {                                                            \
+      gtest_ar << "Expected: " #statement                                      \
+                  " throws an exception of type " #expected_exception          \
+                  ".\n  Actual: it throws a different type.";                  \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);              \
+    }                                                                          \
+    if (!gtest_caught_expected) {                                              \
+      gtest_ar << "Expected: " #statement                                      \
+                  " throws an exception of type " #expected_exception          \
+                  ".\n  Actual: it throws nothing.";                           \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);              \
+    }                                                                          \
+  } else                                                                       \
+    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__)                      \
+        : fail(gtest_ar.failure_message())
+
+// Tests that the statement throws the expected exception and the exception's
+// what() method returns expected message.
+#define EXPECT_THROW_MSG(statement, expected_exception, expected_message) \
+  FMT_TEST_THROW_(statement, expected_exception, expected_message,        \
+                  GTEST_NONFATAL_FAILURE_)
+
+inline std::string system_error_message(int error_code,
+                                        const std::string& message) {
+  auto ec = std::error_code(error_code, std::generic_category());
+  return std::system_error(ec, message).what();
+}
+
+#define EXPECT_SYSTEM_ERROR(statement, error_code, message) \
+  EXPECT_THROW_MSG(statement, std::system_error,            \
+                   system_error_message(error_code, message))
+
+#if FMT_USE_FCNTL
+
+// Captures file output by redirecting it to a pipe.
+// The output it can handle is limited by the pipe capacity.
+class output_redirect {
+ private:
+  FILE* file_;
+  fmt::file original_;  // Original file passed to redirector.
+  fmt::file read_end_;  // Read end of the pipe where the output is redirected.
+
+  void flush();
+  void restore();
+
+ public:
+  explicit output_redirect(FILE* file, bool flush = true);
+  ~output_redirect() noexcept;
+
+  output_redirect(const output_redirect&) = delete;
+  void operator=(const output_redirect&) = delete;
+
+  // Restores the original file, reads output from the pipe into a string
+  // and returns it.
+  std::string restore_and_read();
+};
+
+#  define FMT_TEST_WRITE_(statement, expected_output, file, fail)              \
+    GTEST_AMBIGUOUS_ELSE_BLOCKER_                                              \
+    if (::testing::AssertionResult gtest_ar = ::testing::AssertionSuccess()) { \
+      std::string gtest_expected_output = expected_output;                     \
+      output_redirect gtest_redir(file);                                       \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);               \
+      std::string gtest_output = gtest_redir.restore_and_read();               \
+      if (gtest_output != gtest_expected_output) {                             \
+        gtest_ar << #statement " produces different output.\n"                 \
+                 << "Expected: " << gtest_expected_output << "\n"              \
+                 << "  Actual: " << gtest_output;                              \
+        goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);            \
+      }                                                                        \
+    } else                                                                     \
+      GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__)                    \
+          : fail(gtest_ar.failure_message())
+
+// Tests that the statement writes the expected output to file.
+#  define EXPECT_WRITE(file, statement, expected_output) \
+    FMT_TEST_WRITE_(statement, expected_output, file, GTEST_NONFATAL_FAILURE_)
+
+#  ifdef _MSC_VER
+
+// Suppresses Windows assertions on invalid file descriptors, making
+// POSIX functions return proper error codes instead of crashing on Windows.
+class suppress_assert {
+ private:
+  _invalid_parameter_handler original_handler_;
+  int original_report_mode_;
+
+  static void handle_invalid_parameter(const wchar_t*, const wchar_t*,
+                                       const wchar_t*, unsigned, uintptr_t) {}
+
+ public:
+  suppress_assert()
+      : original_handler_(
+            _set_invalid_parameter_handler(handle_invalid_parameter)),
+        original_report_mode_(_CrtSetReportMode(_CRT_ASSERT, 0)) {}
+  ~suppress_assert() {
+    _set_invalid_parameter_handler(original_handler_);
+    _CrtSetReportMode(_CRT_ASSERT, original_report_mode_);
+    (void)original_report_mode_;
+  }
+};
+
+#    define SUPPRESS_ASSERT(statement) \
+      {                                \
+        suppress_assert sa;            \
+        statement;                     \
+      }
+#  else
+#    define SUPPRESS_ASSERT(statement) statement
+#  endif  // _MSC_VER
+
+#  define EXPECT_SYSTEM_ERROR_NOASSERT(statement, error_code, message) \
+    EXPECT_SYSTEM_ERROR(SUPPRESS_ASSERT(statement), error_code, message)
+
+// Attempts to read count characters from a file.
+std::string read(fmt::file& f, size_t count);
+
+#  define EXPECT_READ(file, expected_content) \
+    EXPECT_EQ(expected_content,               \
+              read(file, fmt::string_view(expected_content).size()))
+
+#else
+#  define EXPECT_WRITE(file, statement, expected_output) \
+    do {                                                 \
+      (void)(file);                                      \
+      (void)(statement);                                 \
+      (void)(expected_output);                           \
+      SUCCEED();                                         \
+    } while (false)
+#endif  // FMT_USE_FCNTL
+
+#endif  // FMT_GTEST_EXTRA_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/.clang-format b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/.clang-format
new file mode 100644
index 0000000000000000000000000000000000000000..ec09b9b6bb1af079f4918169ee0255d8558ad400
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/.clang-format
@@ -0,0 +1,3 @@
+# Disable clang-format here
+DisableFormat: true
+SortIncludes: Never
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0cccc61fec5a823d494ec8505c194de4539cf434
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/CMakeLists.txt
@@ -0,0 +1,32 @@
+#------------------------------------------------------------------------------
+# Build the google test library
+
+# We compile Google Test ourselves instead of using pre-compiled libraries.
+# See the Google Test FAQ "Why is it not recommended to install a
+# pre-compiled copy of Google Test (for example, into /usr/local)?"
+# at http://code.google.com/p/googletest/wiki/FAQ for more details.
+add_library(gtest STATIC
+  gmock-gtest-all.cc gmock/gmock.h gtest/gtest.h gtest/gtest-spi.h)
+target_compile_definitions(gtest PUBLIC GTEST_HAS_STD_WSTRING=1)
+target_include_directories(gtest SYSTEM PUBLIC .)
+target_compile_features(gtest PUBLIC cxx_std_11)
+
+find_package(Threads)
+if (Threads_FOUND)
+  target_link_libraries(gtest ${CMAKE_THREAD_LIBS_INIT})
+else ()
+  target_compile_definitions(gtest PUBLIC GTEST_HAS_PTHREAD=0)
+endif ()
+
+if (MSVC)
+  # Disable MSVC warnings of _CRT_INSECURE_DEPRECATE functions.
+  target_compile_definitions(gtest PRIVATE _CRT_SECURE_NO_WARNINGS)
+  if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    # Disable MSVC warnings of POSIX functions.
+    target_compile_options(gtest PUBLIC -Wno-deprecated-declarations)
+  endif ()
+endif ()
+
+# Silence MSVC tr1 deprecation warning in gmock.
+target_compile_definitions(gtest
+  PUBLIC _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING=1)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/gmock-gtest-all.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/gmock-gtest-all.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9d3b9bc1c917062ab7dfcea5705ae5c54f715bf4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/gmock-gtest-all.cc
@@ -0,0 +1,14434 @@
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+//
+// Google C++ Testing and Mocking Framework (Google Test)
+//
+// Sometimes it's desirable to build Google Test by compiling a single file.
+// This file serves this purpose.
+
+// This line ensures that gtest.h can be compiled on its own, even
+// when it's fused.
+#include "gtest/gtest.h"
+
+// The following lines pull in the real gtest *.cc files.
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+//
+// Utilities for testing Google Test itself and code that uses Google Test
+// (e.g. frameworks built on top of Google Test).
+
+// GOOGLETEST_CM0004 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
+
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// This helper class can be used to mock out Google Test failure reporting
+// so that we can test Google Test or code that builds on Google Test.
+//
+// An object of this class appends a TestPartResult object to the
+// TestPartResultArray object given in the constructor whenever a Google Test
+// failure is reported. It can either intercept only failures that are
+// generated in the same thread that created this object or it can intercept
+// all generated failures. The scope of this mock object can be controlled with
+// the second argument to the two arguments constructor.
+class GTEST_API_ ScopedFakeTestPartResultReporter
+    : public TestPartResultReporterInterface {
+ public:
+  // The two possible mocking modes of this object.
+  enum InterceptMode {
+    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
+    INTERCEPT_ALL_THREADS           // Intercepts all failures.
+  };
+
+  // The c'tor sets this object as the test part result reporter used
+  // by Google Test.  The 'result' parameter specifies where to report the
+  // results. This reporter will only catch failures generated in the current
+  // thread. DEPRECATED
+  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
+
+  // Same as above, but you can choose the interception scope of this object.
+  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
+                                   TestPartResultArray* result);
+
+  // The d'tor restores the previous test part result reporter.
+  ~ScopedFakeTestPartResultReporter() override;
+
+  // Appends the TestPartResult object to the TestPartResultArray
+  // received in the constructor.
+  //
+  // This method is from the TestPartResultReporterInterface
+  // interface.
+  void ReportTestPartResult(const TestPartResult& result) override;
+
+ private:
+  void Init();
+
+  const InterceptMode intercept_mode_;
+  TestPartResultReporterInterface* old_reporter_;
+  TestPartResultArray* const result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
+};
+
+namespace internal {
+
+// A helper class for implementing EXPECT_FATAL_FAILURE() and
+// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
+// TestPartResultArray contains exactly one failure that has the given
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+class GTEST_API_ SingleFailureChecker {
+ public:
+  // The constructor remembers the arguments.
+  SingleFailureChecker(const TestPartResultArray* results,
+                       TestPartResult::Type type, const std::string& substr);
+  ~SingleFailureChecker();
+ private:
+  const TestPartResultArray* const results_;
+  const TestPartResult::Type type_;
+  const std::string substr_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// A set of macros for testing Google Test assertions or code that's expected
+// to generate Google Test fatal failures.  It verifies that the given
+// statement will cause exactly one fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - 'statement' cannot reference local non-static variables or
+//     non-static members of the current object.
+//   - 'statement' cannot return a value.
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
+// gtest_unittest.cc will fail to compile if we do that.
+#define EXPECT_FATAL_FAILURE(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ALL_THREADS, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+// A macro for testing Google Test assertions or code that's expected to
+// generate Google Test non-fatal failures.  It asserts that the given
+// statement will cause exactly one non-fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// 'statement' is allowed to reference local variables and members of
+// the current object.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  If we do that, the code won't compile when the user gives
+// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
+// expands to code containing an unprotected comma.  The
+// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
+// catches that.
+//
+// For the same reason, we have to write
+//   if (::testing::internal::AlwaysTrue()) { statement; }
+// instead of
+//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
+// to avoid an MSVC warning on unreachable code.
+#define EXPECT_NONFATAL_FAILURE(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
+          &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
+
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <wchar.h>
+#include <wctype.h>
+
+#include <algorithm>
+#include <chrono>  // NOLINT
+#include <cmath>
+#include <cstdint>
+#include <iomanip>
+#include <limits>
+#include <list>
+#include <map>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <vector>
+
+#if GTEST_OS_LINUX
+
+# include <fcntl.h>  // NOLINT
+# include <limits.h>  // NOLINT
+# include <sched.h>  // NOLINT
+// Declares vsnprintf().  This header is not available on Windows.
+# include <strings.h>  // NOLINT
+# include <sys/mman.h>  // NOLINT
+# include <sys/time.h>  // NOLINT
+# include <unistd.h>  // NOLINT
+# include <string>
+
+#elif GTEST_OS_ZOS
+# include <sys/time.h>  // NOLINT
+
+// On z/OS we additionally need strings.h for strcasecmp.
+# include <strings.h>  // NOLINT
+
+#elif GTEST_OS_WINDOWS_MOBILE  // We are on Windows CE.
+
+# include <windows.h>  // NOLINT
+# undef min
+
+#elif GTEST_OS_WINDOWS  // We are on Windows proper.
+
+# include <windows.h>  // NOLINT
+# undef min
+
+#ifdef _MSC_VER
+# include <crtdbg.h>  // NOLINT
+#endif
+
+# include <io.h>  // NOLINT
+# include <sys/timeb.h>  // NOLINT
+# include <sys/types.h>  // NOLINT
+# include <sys/stat.h>  // NOLINT
+
+# if GTEST_OS_WINDOWS_MINGW
+#  include <sys/time.h>  // NOLINT
+# endif  // GTEST_OS_WINDOWS_MINGW
+
+#else
+
+// cpplint thinks that the header is already included, so we want to
+// silence it.
+# include <sys/time.h>  // NOLINT
+# include <unistd.h>  // NOLINT
+
+#endif  // GTEST_OS_LINUX
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>
+#endif
+
+#if GTEST_CAN_STREAM_RESULTS_
+# include <arpa/inet.h>  // NOLINT
+# include <netdb.h>  // NOLINT
+# include <sys/socket.h>  // NOLINT
+# include <sys/types.h>  // NOLINT
+#endif
+
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Utility functions and classes used by the Google C++ testing framework.//
+// This file contains purely Google Test's internal implementation.  Please
+// DO NOT #INCLUDE IT IN A USER PROGRAM.
+
+#ifndef GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_
+#define GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_
+
+#ifndef _WIN32_WCE
+# include <errno.h>
+#endif  // !_WIN32_WCE
+#include <stddef.h>
+#include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.
+#include <string.h>  // For memmove.
+
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+
+#if GTEST_CAN_STREAM_RESULTS_
+# include <arpa/inet.h>  // NOLINT
+# include <netdb.h>  // NOLINT
+#endif
+
+#if GTEST_OS_WINDOWS
+# include <windows.h>  // NOLINT
+#endif  // GTEST_OS_WINDOWS
+
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// Declares the flags.
+//
+// We don't want the users to modify this flag in the code, but want
+// Google Test's own unit tests to be able to access it. Therefore we
+// declare it here as opposed to in gtest.h.
+GTEST_DECLARE_bool_(death_test_use_fork);
+
+namespace internal {
+
+// The value of GetTestTypeId() as seen from within the Google Test
+// library.  This is solely for testing GetTestTypeId().
+GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;
+
+// Names of the flags (needed for parsing Google Test flags).
+const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";
+const char kBreakOnFailureFlag[] = "break_on_failure";
+const char kCatchExceptionsFlag[] = "catch_exceptions";
+const char kColorFlag[] = "color";
+const char kFailFast[] = "fail_fast";
+const char kFilterFlag[] = "filter";
+const char kListTestsFlag[] = "list_tests";
+const char kOutputFlag[] = "output";
+const char kBriefFlag[] = "brief";
+const char kPrintTimeFlag[] = "print_time";
+const char kPrintUTF8Flag[] = "print_utf8";
+const char kRandomSeedFlag[] = "random_seed";
+const char kRepeatFlag[] = "repeat";
+const char kShuffleFlag[] = "shuffle";
+const char kStackTraceDepthFlag[] = "stack_trace_depth";
+const char kStreamResultToFlag[] = "stream_result_to";
+const char kThrowOnFailureFlag[] = "throw_on_failure";
+const char kFlagfileFlag[] = "flagfile";
+
+// A valid random seed must be in [1, kMaxRandomSeed].
+const int kMaxRandomSeed = 99999;
+
+// g_help_flag is true if and only if the --help flag or an equivalent form
+// is specified on the command line.
+GTEST_API_ extern bool g_help_flag;
+
+// Returns the current time in milliseconds.
+GTEST_API_ TimeInMillis GetTimeInMillis();
+
+// Returns true if and only if Google Test should use colors in the output.
+GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);
+
+// Formats the given time in milliseconds as seconds.
+GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);
+
+// Converts the given time in milliseconds to a date string in the ISO 8601
+// format, without the timezone information.  N.B.: due to the use the
+// non-reentrant localtime() function, this function is not thread safe.  Do
+// not use it in any code that can be called from multiple threads.
+GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);
+
+// Parses a string for an Int32 flag, in the form of "--flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+GTEST_API_ bool ParseInt32Flag(
+    const char* str, const char* flag, int32_t* value);
+
+// Returns a random seed in range [1, kMaxRandomSeed] based on the
+// given --gtest_random_seed flag value.
+inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {
+  const unsigned int raw_seed = (random_seed_flag == 0) ?
+      static_cast<unsigned int>(GetTimeInMillis()) :
+      static_cast<unsigned int>(random_seed_flag);
+
+  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
+  // it's easy to type.
+  const int normalized_seed =
+      static_cast<int>((raw_seed - 1U) %
+                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
+  return normalized_seed;
+}
+
+// Returns the first valid random seed after 'seed'.  The behavior is
+// undefined if 'seed' is invalid.  The seed after kMaxRandomSeed is
+// considered to be 1.
+inline int GetNextRandomSeed(int seed) {
+  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
+      << "Invalid random seed " << seed << " - must be in [1, "
+      << kMaxRandomSeed << "].";
+  const int next_seed = seed + 1;
+  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
+}
+
+// This class saves the values of all Google Test flags in its c'tor, and
+// restores them in its d'tor.
+class GTestFlagSaver {
+ public:
+  // The c'tor.
+  GTestFlagSaver() {
+    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
+    break_on_failure_ = GTEST_FLAG(break_on_failure);
+    catch_exceptions_ = GTEST_FLAG(catch_exceptions);
+    color_ = GTEST_FLAG(color);
+    death_test_style_ = GTEST_FLAG(death_test_style);
+    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
+    fail_fast_ = GTEST_FLAG(fail_fast);
+    filter_ = GTEST_FLAG(filter);
+    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
+    list_tests_ = GTEST_FLAG(list_tests);
+    output_ = GTEST_FLAG(output);
+    brief_ = GTEST_FLAG(brief);
+    print_time_ = GTEST_FLAG(print_time);
+    print_utf8_ = GTEST_FLAG(print_utf8);
+    random_seed_ = GTEST_FLAG(random_seed);
+    repeat_ = GTEST_FLAG(repeat);
+    shuffle_ = GTEST_FLAG(shuffle);
+    stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
+    stream_result_to_ = GTEST_FLAG(stream_result_to);
+    throw_on_failure_ = GTEST_FLAG(throw_on_failure);
+  }
+
+  // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
+  ~GTestFlagSaver() {
+    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
+    GTEST_FLAG(break_on_failure) = break_on_failure_;
+    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
+    GTEST_FLAG(color) = color_;
+    GTEST_FLAG(death_test_style) = death_test_style_;
+    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
+    GTEST_FLAG(filter) = filter_;
+    GTEST_FLAG(fail_fast) = fail_fast_;
+    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
+    GTEST_FLAG(list_tests) = list_tests_;
+    GTEST_FLAG(output) = output_;
+    GTEST_FLAG(brief) = brief_;
+    GTEST_FLAG(print_time) = print_time_;
+    GTEST_FLAG(print_utf8) = print_utf8_;
+    GTEST_FLAG(random_seed) = random_seed_;
+    GTEST_FLAG(repeat) = repeat_;
+    GTEST_FLAG(shuffle) = shuffle_;
+    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
+    GTEST_FLAG(stream_result_to) = stream_result_to_;
+    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
+  }
+
+ private:
+  // Fields for saving the original values of flags.
+  bool also_run_disabled_tests_;
+  bool break_on_failure_;
+  bool catch_exceptions_;
+  std::string color_;
+  std::string death_test_style_;
+  bool death_test_use_fork_;
+  bool fail_fast_;
+  std::string filter_;
+  std::string internal_run_death_test_;
+  bool list_tests_;
+  std::string output_;
+  bool brief_;
+  bool print_time_;
+  bool print_utf8_;
+  int32_t random_seed_;
+  int32_t repeat_;
+  bool shuffle_;
+  int32_t stack_trace_depth_;
+  std::string stream_result_to_;
+  bool throw_on_failure_;
+} GTEST_ATTRIBUTE_UNUSED_;
+
+// Converts a Unicode code point to a narrow string in UTF-8 encoding.
+// code_point parameter is of type UInt32 because wchar_t may not be
+// wide enough to contain a code point.
+// If the code_point is not a valid Unicode code point
+// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
+// to "(Invalid Unicode 0xXXXXXXXX)".
+GTEST_API_ std::string CodePointToUtf8(uint32_t code_point);
+
+// Converts a wide string to a narrow string in UTF-8 encoding.
+// The wide string is assumed to have the following encoding:
+//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
+//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
+// Parameter str points to a null-terminated wide string.
+// Parameter num_chars may additionally limit the number
+// of wchar_t characters processed. -1 is used when the entire string
+// should be processed.
+// If the string contains code points that are not valid Unicode code points
+// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
+// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
+// and contains invalid UTF-16 surrogate pairs, values in those pairs
+// will be encoded as individual Unicode characters from Basic Normal Plane.
+GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars);
+
+// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
+// if the variable is present. If a file already exists at this location, this
+// function will write over it. If the variable is present, but the file cannot
+// be created, prints an error and exits.
+void WriteToShardStatusFileIfNeeded();
+
+// Checks whether sharding is enabled by examining the relevant
+// environment variable values. If the variables are present,
+// but inconsistent (e.g., shard_index >= total_shards), prints
+// an error and exits. If in_subprocess_for_death_test, sharding is
+// disabled because it must only be applied to the original test
+// process. Otherwise, we could filter out death tests we intended to execute.
+GTEST_API_ bool ShouldShard(const char* total_shards_str,
+                            const char* shard_index_str,
+                            bool in_subprocess_for_death_test);
+
+// Parses the environment variable var as a 32-bit integer. If it is unset,
+// returns default_val. If it is not a 32-bit integer, prints an error and
+// and aborts.
+GTEST_API_ int32_t Int32FromEnvOrDie(const char* env_var, int32_t default_val);
+
+// Given the total number of shards, the shard index, and the test id,
+// returns true if and only if the test should be run on this shard. The test id
+// is some arbitrary but unique non-negative integer assigned to each test
+// method. Assumes that 0 <= shard_index < total_shards.
+GTEST_API_ bool ShouldRunTestOnShard(
+    int total_shards, int shard_index, int test_id);
+
+// STL container utilities.
+
+// Returns the number of elements in the given container that satisfy
+// the given predicate.
+template <class Container, typename Predicate>
+inline int CountIf(const Container& c, Predicate predicate) {
+  // Implemented as an explicit loop since std::count_if() in libCstd on
+  // Solaris has a non-standard signature.
+  int count = 0;
+  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
+    if (predicate(*it))
+      ++count;
+  }
+  return count;
+}
+
+// Applies a function/functor to each element in the container.
+template <class Container, typename Functor>
+void ForEach(const Container& c, Functor functor) {
+  std::for_each(c.begin(), c.end(), functor);
+}
+
+// Returns the i-th element of the vector, or default_value if i is not
+// in range [0, v.size()).
+template <typename E>
+inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
+  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
+                                                    : v[static_cast<size_t>(i)];
+}
+
+// Performs an in-place shuffle of a range of the vector's elements.
+// 'begin' and 'end' are element indices as an STL-style range;
+// i.e. [begin, end) are shuffled, where 'end' == size() means to
+// shuffle to the end of the vector.
+template <typename E>
+void ShuffleRange(internal::Random* random, int begin, int end,
+                  std::vector<E>* v) {
+  const int size = static_cast<int>(v->size());
+  GTEST_CHECK_(0 <= begin && begin <= size)
+      << "Invalid shuffle range start " << begin << ": must be in range [0, "
+      << size << "].";
+  GTEST_CHECK_(begin <= end && end <= size)
+      << "Invalid shuffle range finish " << end << ": must be in range ["
+      << begin << ", " << size << "].";
+
+  // Fisher-Yates shuffle, from
+  // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
+  for (int range_width = end - begin; range_width >= 2; range_width--) {
+    const int last_in_range = begin + range_width - 1;
+    const int selected =
+        begin +
+        static_cast<int>(random->Generate(static_cast<uint32_t>(range_width)));
+    std::swap((*v)[static_cast<size_t>(selected)],
+              (*v)[static_cast<size_t>(last_in_range)]);
+  }
+}
+
+// Performs an in-place shuffle of the vector's elements.
+template <typename E>
+inline void Shuffle(internal::Random* random, std::vector<E>* v) {
+  ShuffleRange(random, 0, static_cast<int>(v->size()), v);
+}
+
+// A function for deleting an object.  Handy for being used as a
+// functor.
+template <typename T>
+static void Delete(T* x) {
+  delete x;
+}
+
+// A predicate that checks the key of a TestProperty against a known key.
+//
+// TestPropertyKeyIs is copyable.
+class TestPropertyKeyIs {
+ public:
+  // Constructor.
+  //
+  // TestPropertyKeyIs has NO default constructor.
+  explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
+
+  // Returns true if and only if the test name of test property matches on key_.
+  bool operator()(const TestProperty& test_property) const {
+    return test_property.key() == key_;
+  }
+
+ private:
+  std::string key_;
+};
+
+// Class UnitTestOptions.
+//
+// This class contains functions for processing options the user
+// specifies when running the tests.  It has only static members.
+//
+// In most cases, the user can specify an option using either an
+// environment variable or a command line flag.  E.g. you can set the
+// test filter using either GTEST_FILTER or --gtest_filter.  If both
+// the variable and the flag are present, the latter overrides the
+// former.
+class GTEST_API_ UnitTestOptions {
+ public:
+  // Functions for processing the gtest_output flag.
+
+  // Returns the output format, or "" for normal printed output.
+  static std::string GetOutputFormat();
+
+  // Returns the absolute path of the requested output file, or the
+  // default (test_detail.xml in the original working directory) if
+  // none was explicitly specified.
+  static std::string GetAbsolutePathToOutputFile();
+
+  // Functions for processing the gtest_filter flag.
+
+  // Returns true if and only if the user-specified filter matches the test
+  // suite name and the test name.
+  static bool FilterMatchesTest(const std::string& test_suite_name,
+                                const std::string& test_name);
+
+#if GTEST_OS_WINDOWS
+  // Function for supporting the gtest_catch_exception flag.
+
+  // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
+  // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
+  // This function is useful as an __except condition.
+  static int GTestShouldProcessSEH(DWORD exception_code);
+#endif  // GTEST_OS_WINDOWS
+
+  // Returns true if "name" matches the ':' separated list of glob-style
+  // filters in "filter".
+  static bool MatchesFilter(const std::string& name, const char* filter);
+};
+
+// Returns the current application's name, removing directory path if that
+// is present.  Used by UnitTestOptions::GetOutputFile.
+GTEST_API_ FilePath GetCurrentExecutableName();
+
+// The role interface for getting the OS stack trace as a string.
+class OsStackTraceGetterInterface {
+ public:
+  OsStackTraceGetterInterface() {}
+  virtual ~OsStackTraceGetterInterface() {}
+
+  // Returns the current OS stack trace as an std::string.  Parameters:
+  //
+  //   max_depth  - the maximum number of stack frames to be included
+  //                in the trace.
+  //   skip_count - the number of top frames to be skipped; doesn't count
+  //                against max_depth.
+  virtual std::string CurrentStackTrace(int max_depth, int skip_count) = 0;
+
+  // UponLeavingGTest() should be called immediately before Google Test calls
+  // user code. It saves some information about the current stack that
+  // CurrentStackTrace() will use to find and hide Google Test stack frames.
+  virtual void UponLeavingGTest() = 0;
+
+  // This string is inserted in place of stack frames that are part of
+  // Google Test's implementation.
+  static const char* const kElidedFramesMarker;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
+};
+
+// A working implementation of the OsStackTraceGetterInterface interface.
+class OsStackTraceGetter : public OsStackTraceGetterInterface {
+ public:
+  OsStackTraceGetter() {}
+
+  std::string CurrentStackTrace(int max_depth, int skip_count) override;
+  void UponLeavingGTest() override;
+
+ private:
+#if GTEST_HAS_ABSL
+  Mutex mutex_;  // Protects all internal state.
+
+  // We save the stack frame below the frame that calls user code.
+  // We do this because the address of the frame immediately below
+  // the user code changes between the call to UponLeavingGTest()
+  // and any calls to the stack trace code from within the user code.
+  void* caller_frame_ = nullptr;
+#endif  // GTEST_HAS_ABSL
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
+};
+
+// Information about a Google Test trace point.
+struct TraceInfo {
+  const char* file;
+  int line;
+  std::string message;
+};
+
+// This is the default global test part result reporter used in UnitTestImpl.
+// This class should only be used by UnitTestImpl.
+class DefaultGlobalTestPartResultReporter
+  : public TestPartResultReporterInterface {
+ public:
+  explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);
+  // Implements the TestPartResultReporterInterface. Reports the test part
+  // result in the current test.
+  void ReportTestPartResult(const TestPartResult& result) override;
+
+ private:
+  UnitTestImpl* const unit_test_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
+};
+
+// This is the default per thread test part result reporter used in
+// UnitTestImpl. This class should only be used by UnitTestImpl.
+class DefaultPerThreadTestPartResultReporter
+    : public TestPartResultReporterInterface {
+ public:
+  explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test);
+  // Implements the TestPartResultReporterInterface. The implementation just
+  // delegates to the current global test part result reporter of *unit_test_.
+  void ReportTestPartResult(const TestPartResult& result) override;
+
+ private:
+  UnitTestImpl* const unit_test_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
+};
+
+// The private implementation of the UnitTest class.  We don't protect
+// the methods under a mutex, as this class is not accessible by a
+// user and the UnitTest class that delegates work to this class does
+// proper locking.
+class GTEST_API_ UnitTestImpl {
+ public:
+  explicit UnitTestImpl(UnitTest* parent);
+  virtual ~UnitTestImpl();
+
+  // There are two different ways to register your own TestPartResultReporter.
+  // You can register your own repoter to listen either only for test results
+  // from the current thread or for results from all threads.
+  // By default, each per-thread test result repoter just passes a new
+  // TestPartResult to the global test result reporter, which registers the
+  // test part result for the currently running test.
+
+  // Returns the global test part result reporter.
+  TestPartResultReporterInterface* GetGlobalTestPartResultReporter();
+
+  // Sets the global test part result reporter.
+  void SetGlobalTestPartResultReporter(
+      TestPartResultReporterInterface* reporter);
+
+  // Returns the test part result reporter for the current thread.
+  TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread();
+
+  // Sets the test part result reporter for the current thread.
+  void SetTestPartResultReporterForCurrentThread(
+      TestPartResultReporterInterface* reporter);
+
+  // Gets the number of successful test suites.
+  int successful_test_suite_count() const;
+
+  // Gets the number of failed test suites.
+  int failed_test_suite_count() const;
+
+  // Gets the number of all test suites.
+  int total_test_suite_count() const;
+
+  // Gets the number of all test suites that contain at least one test
+  // that should run.
+  int test_suite_to_run_count() const;
+
+  // Gets the number of successful tests.
+  int successful_test_count() const;
+
+  // Gets the number of skipped tests.
+  int skipped_test_count() const;
+
+  // Gets the number of failed tests.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
+  // Gets the number of disabled tests.
+  int disabled_test_count() const;
+
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
+  // Gets the number of all tests.
+  int total_test_count() const;
+
+  // Gets the number of tests that should run.
+  int test_to_run_count() const;
+
+  // Gets the time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const { return start_timestamp_; }
+
+  // Gets the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Returns true if and only if the unit test passed (i.e. all test suites
+  // passed).
+  bool Passed() const { return !Failed(); }
+
+  // Returns true if and only if the unit test failed (i.e. some test suite
+  // failed or something outside of all tests failed).
+  bool Failed() const {
+    return failed_test_suite_count() > 0 || ad_hoc_test_result()->Failed();
+  }
+
+  // Gets the i-th test suite among all the test suites. i can range from 0 to
+  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
+  const TestSuite* GetTestSuite(int i) const {
+    const int index = GetElementOr(test_suite_indices_, i, -1);
+    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(i)];
+  }
+
+  //  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  const TestCase* GetTestCase(int i) const { return GetTestSuite(i); }
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Gets the i-th test suite among all the test suites. i can range from 0 to
+  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
+  TestSuite* GetMutableSuiteCase(int i) {
+    const int index = GetElementOr(test_suite_indices_, i, -1);
+    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(index)];
+  }
+
+  // Provides access to the event listener list.
+  TestEventListeners* listeners() { return &listeners_; }
+
+  // Returns the TestResult for the test that's currently running, or
+  // the TestResult for the ad hoc test if no test is running.
+  TestResult* current_test_result();
+
+  // Returns the TestResult for the ad hoc test.
+  const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; }
+
+  // Sets the OS stack trace getter.
+  //
+  // Does nothing if the input and the current OS stack trace getter
+  // are the same; otherwise, deletes the old getter and makes the
+  // input the current getter.
+  void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter);
+
+  // Returns the current OS stack trace getter if it is not NULL;
+  // otherwise, creates an OsStackTraceGetter, makes it the current
+  // getter, and returns it.
+  OsStackTraceGetterInterface* os_stack_trace_getter();
+
+  // Returns the current OS stack trace as an std::string.
+  //
+  // The maximum number of stack frames to be included is specified by
+  // the gtest_stack_trace_depth flag.  The skip_count parameter
+  // specifies the number of top frames to be skipped, which doesn't
+  // count against the number of frames to be included.
+  //
+  // For example, if Foo() calls Bar(), which in turn calls
+  // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
+  // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
+  std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_;
+
+  // Finds and returns a TestSuite with the given name.  If one doesn't
+  // exist, creates one and returns it.
+  //
+  // Arguments:
+  //
+  //   test_suite_name: name of the test suite
+  //   type_param:      the name of the test's type parameter, or NULL if
+  //                    this is not a typed or a type-parameterized test.
+  //   set_up_tc:       pointer to the function that sets up the test suite
+  //   tear_down_tc:    pointer to the function that tears down the test suite
+  TestSuite* GetTestSuite(const char* test_suite_name, const char* type_param,
+                          internal::SetUpTestSuiteFunc set_up_tc,
+                          internal::TearDownTestSuiteFunc tear_down_tc);
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  TestCase* GetTestCase(const char* test_case_name, const char* type_param,
+                        internal::SetUpTestSuiteFunc set_up_tc,
+                        internal::TearDownTestSuiteFunc tear_down_tc) {
+    return GetTestSuite(test_case_name, type_param, set_up_tc, tear_down_tc);
+  }
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Adds a TestInfo to the unit test.
+  //
+  // Arguments:
+  //
+  //   set_up_tc:    pointer to the function that sets up the test suite
+  //   tear_down_tc: pointer to the function that tears down the test suite
+  //   test_info:    the TestInfo object
+  void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
+                   internal::TearDownTestSuiteFunc tear_down_tc,
+                   TestInfo* test_info) {
+#if GTEST_HAS_DEATH_TEST
+    // In order to support thread-safe death tests, we need to
+    // remember the original working directory when the test program
+    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
+    // the user may have changed the current directory before calling
+    // RUN_ALL_TESTS().  Therefore we capture the current directory in
+    // AddTestInfo(), which is called to register a TEST or TEST_F
+    // before main() is reached.
+    if (original_working_dir_.IsEmpty()) {
+      original_working_dir_.Set(FilePath::GetCurrentDir());
+      GTEST_CHECK_(!original_working_dir_.IsEmpty())
+          << "Failed to get the current working directory.";
+    }
+#endif  // GTEST_HAS_DEATH_TEST
+
+    GetTestSuite(test_info->test_suite_name(), test_info->type_param(),
+                 set_up_tc, tear_down_tc)
+        ->AddTestInfo(test_info);
+  }
+
+  // Returns ParameterizedTestSuiteRegistry object used to keep track of
+  // value-parameterized tests and instantiate and register them.
+  internal::ParameterizedTestSuiteRegistry& parameterized_test_registry() {
+    return parameterized_test_registry_;
+  }
+
+  std::set<std::string>* ignored_parameterized_test_suites() {
+    return &ignored_parameterized_test_suites_;
+  }
+
+  // Returns TypeParameterizedTestSuiteRegistry object used to keep track of
+  // type-parameterized tests and instantiations of them.
+  internal::TypeParameterizedTestSuiteRegistry&
+  type_parameterized_test_registry() {
+    return type_parameterized_test_registry_;
+  }
+
+  // Sets the TestSuite object for the test that's currently running.
+  void set_current_test_suite(TestSuite* a_current_test_suite) {
+    current_test_suite_ = a_current_test_suite;
+  }
+
+  // Sets the TestInfo object for the test that's currently running.  If
+  // current_test_info is NULL, the assertion results will be stored in
+  // ad_hoc_test_result_.
+  void set_current_test_info(TestInfo* a_current_test_info) {
+    current_test_info_ = a_current_test_info;
+  }
+
+  // Registers all parameterized tests defined using TEST_P and
+  // INSTANTIATE_TEST_SUITE_P, creating regular tests for each test/parameter
+  // combination. This method can be called more then once; it has guards
+  // protecting from registering the tests more then once.  If
+  // value-parameterized tests are disabled, RegisterParameterizedTests is
+  // present but does nothing.
+  void RegisterParameterizedTests();
+
+  // Runs all tests in this UnitTest object, prints the result, and
+  // returns true if all tests are successful.  If any exception is
+  // thrown during a test, this test is considered to be failed, but
+  // the rest of the tests will still be run.
+  bool RunAllTests();
+
+  // Clears the results of all tests, except the ad hoc tests.
+  void ClearNonAdHocTestResult() {
+    ForEach(test_suites_, TestSuite::ClearTestSuiteResult);
+  }
+
+  // Clears the results of ad-hoc test assertions.
+  void ClearAdHocTestResult() {
+    ad_hoc_test_result_.Clear();
+  }
+
+  // Adds a TestProperty to the current TestResult object when invoked in a
+  // context of a test or a test suite, or to the global property set. If the
+  // result already contains a property with the same key, the value will be
+  // updated.
+  void RecordProperty(const TestProperty& test_property);
+
+  enum ReactionToSharding {
+    HONOR_SHARDING_PROTOCOL,
+    IGNORE_SHARDING_PROTOCOL
+  };
+
+  // Matches the full name of each test against the user-specified
+  // filter to decide whether the test should run, then records the
+  // result in each TestSuite and TestInfo object.
+  // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests
+  // based on sharding variables in the environment.
+  // Returns the number of tests that should run.
+  int FilterTests(ReactionToSharding shard_tests);
+
+  // Prints the names of the tests matching the user-specified filter flag.
+  void ListTestsMatchingFilter();
+
+  const TestSuite* current_test_suite() const { return current_test_suite_; }
+  TestInfo* current_test_info() { return current_test_info_; }
+  const TestInfo* current_test_info() const { return current_test_info_; }
+
+  // Returns the vector of environments that need to be set-up/torn-down
+  // before/after the tests are run.
+  std::vector<Environment*>& environments() { return environments_; }
+
+  // Getters for the per-thread Google Test trace stack.
+  std::vector<TraceInfo>& gtest_trace_stack() {
+    return *(gtest_trace_stack_.pointer());
+  }
+  const std::vector<TraceInfo>& gtest_trace_stack() const {
+    return gtest_trace_stack_.get();
+  }
+
+#if GTEST_HAS_DEATH_TEST
+  void InitDeathTestSubprocessControlInfo() {
+    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
+  }
+  // Returns a pointer to the parsed --gtest_internal_run_death_test
+  // flag, or NULL if that flag was not specified.
+  // This information is useful only in a death test child process.
+  // Must not be called before a call to InitGoogleTest.
+  const InternalRunDeathTestFlag* internal_run_death_test_flag() const {
+    return internal_run_death_test_flag_.get();
+  }
+
+  // Returns a pointer to the current death test factory.
+  internal::DeathTestFactory* death_test_factory() {
+    return death_test_factory_.get();
+  }
+
+  void SuppressTestEventsIfInSubprocess();
+
+  friend class ReplaceDeathTestFactory;
+#endif  // GTEST_HAS_DEATH_TEST
+
+  // Initializes the event listener performing XML output as specified by
+  // UnitTestOptions. Must not be called before InitGoogleTest.
+  void ConfigureXmlOutput();
+
+#if GTEST_CAN_STREAM_RESULTS_
+  // Initializes the event listener for streaming test results to a socket.
+  // Must not be called before InitGoogleTest.
+  void ConfigureStreamingOutput();
+#endif
+
+  // Performs initialization dependent upon flag values obtained in
+  // ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
+  // ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
+  // this function is also called from RunAllTests.  Since this function can be
+  // called more than once, it has to be idempotent.
+  void PostFlagParsingInit();
+
+  // Gets the random seed used at the start of the current test iteration.
+  int random_seed() const { return random_seed_; }
+
+  // Gets the random number generator.
+  internal::Random* random() { return &random_; }
+
+  // Shuffles all test suites, and the tests within each test suite,
+  // making sure that death tests are still run first.
+  void ShuffleTests();
+
+  // Restores the test suites and tests to their order before the first shuffle.
+  void UnshuffleTests();
+
+  // Returns the value of GTEST_FLAG(catch_exceptions) at the moment
+  // UnitTest::Run() starts.
+  bool catch_exceptions() const { return catch_exceptions_; }
+
+ private:
+  friend class ::testing::UnitTest;
+
+  // Used by UnitTest::Run() to capture the state of
+  // GTEST_FLAG(catch_exceptions) at the moment it starts.
+  void set_catch_exceptions(bool value) { catch_exceptions_ = value; }
+
+  // The UnitTest object that owns this implementation object.
+  UnitTest* const parent_;
+
+  // The working directory when the first TEST() or TEST_F() was
+  // executed.
+  internal::FilePath original_working_dir_;
+
+  // The default test part result reporters.
+  DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_;
+  DefaultPerThreadTestPartResultReporter
+      default_per_thread_test_part_result_reporter_;
+
+  // Points to (but doesn't own) the global test part result reporter.
+  TestPartResultReporterInterface* global_test_part_result_repoter_;
+
+  // Protects read and write access to global_test_part_result_reporter_.
+  internal::Mutex global_test_part_result_reporter_mutex_;
+
+  // Points to (but doesn't own) the per-thread test part result reporter.
+  internal::ThreadLocal<TestPartResultReporterInterface*>
+      per_thread_test_part_result_reporter_;
+
+  // The vector of environments that need to be set-up/torn-down
+  // before/after the tests are run.
+  std::vector<Environment*> environments_;
+
+  // The vector of TestSuites in their original order.  It owns the
+  // elements in the vector.
+  std::vector<TestSuite*> test_suites_;
+
+  // Provides a level of indirection for the test suite list to allow
+  // easy shuffling and restoring the test suite order.  The i-th
+  // element of this vector is the index of the i-th test suite in the
+  // shuffled order.
+  std::vector<int> test_suite_indices_;
+
+  // ParameterizedTestRegistry object used to register value-parameterized
+  // tests.
+  internal::ParameterizedTestSuiteRegistry parameterized_test_registry_;
+  internal::TypeParameterizedTestSuiteRegistry
+      type_parameterized_test_registry_;
+
+  // The set holding the name of parameterized
+  // test suites that may go uninstantiated.
+  std::set<std::string> ignored_parameterized_test_suites_;
+
+  // Indicates whether RegisterParameterizedTests() has been called already.
+  bool parameterized_tests_registered_;
+
+  // Index of the last death test suite registered.  Initially -1.
+  int last_death_test_suite_;
+
+  // This points to the TestSuite for the currently running test.  It
+  // changes as Google Test goes through one test suite after another.
+  // When no test is running, this is set to NULL and Google Test
+  // stores assertion results in ad_hoc_test_result_.  Initially NULL.
+  TestSuite* current_test_suite_;
+
+  // This points to the TestInfo for the currently running test.  It
+  // changes as Google Test goes through one test after another.  When
+  // no test is running, this is set to NULL and Google Test stores
+  // assertion results in ad_hoc_test_result_.  Initially NULL.
+  TestInfo* current_test_info_;
+
+  // Normally, a user only writes assertions inside a TEST or TEST_F,
+  // or inside a function called by a TEST or TEST_F.  Since Google
+  // Test keeps track of which test is current running, it can
+  // associate such an assertion with the test it belongs to.
+  //
+  // If an assertion is encountered when no TEST or TEST_F is running,
+  // Google Test attributes the assertion result to an imaginary "ad hoc"
+  // test, and records the result in ad_hoc_test_result_.
+  TestResult ad_hoc_test_result_;
+
+  // The list of event listeners that can be used to track events inside
+  // Google Test.
+  TestEventListeners listeners_;
+
+  // The OS stack trace getter.  Will be deleted when the UnitTest
+  // object is destructed.  By default, an OsStackTraceGetter is used,
+  // but the user can set this field to use a custom getter if that is
+  // desired.
+  OsStackTraceGetterInterface* os_stack_trace_getter_;
+
+  // True if and only if PostFlagParsingInit() has been called.
+  bool post_flag_parse_init_performed_;
+
+  // The random number seed used at the beginning of the test run.
+  int random_seed_;
+
+  // Our random number generator.
+  internal::Random random_;
+
+  // The time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp_;
+
+  // How long the test took to run, in milliseconds.
+  TimeInMillis elapsed_time_;
+
+#if GTEST_HAS_DEATH_TEST
+  // The decomposed components of the gtest_internal_run_death_test flag,
+  // parsed when RUN_ALL_TESTS is called.
+  std::unique_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
+  std::unique_ptr<internal::DeathTestFactory> death_test_factory_;
+#endif  // GTEST_HAS_DEATH_TEST
+
+  // A per-thread stack of traces created by the SCOPED_TRACE() macro.
+  internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_;
+
+  // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests()
+  // starts.
+  bool catch_exceptions_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
+};  // class UnitTestImpl
+
+// Convenience function for accessing the global UnitTest
+// implementation object.
+inline UnitTestImpl* GetUnitTestImpl() {
+  return UnitTest::GetInstance()->impl();
+}
+
+#if GTEST_USES_SIMPLE_RE
+
+// Internal helper functions for implementing the simple regular
+// expression matcher.
+GTEST_API_ bool IsInSet(char ch, const char* str);
+GTEST_API_ bool IsAsciiDigit(char ch);
+GTEST_API_ bool IsAsciiPunct(char ch);
+GTEST_API_ bool IsRepeat(char ch);
+GTEST_API_ bool IsAsciiWhiteSpace(char ch);
+GTEST_API_ bool IsAsciiWordChar(char ch);
+GTEST_API_ bool IsValidEscape(char ch);
+GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch);
+GTEST_API_ bool ValidateRegex(const char* regex);
+GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str);
+GTEST_API_ bool MatchRepetitionAndRegexAtHead(
+    bool escaped, char ch, char repeat, const char* regex, const char* str);
+GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str);
+
+#endif  // GTEST_USES_SIMPLE_RE
+
+// Parses the command line for Google Test flags, without initializing
+// other parts of Google Test.
+GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv);
+GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
+
+#if GTEST_HAS_DEATH_TEST
+
+// Returns the message describing the last system error, regardless of the
+// platform.
+GTEST_API_ std::string GetLastErrnoDescription();
+
+// Attempts to parse a string into a positive integer pointed to by the
+// number parameter.  Returns true if that is possible.
+// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use
+// it here.
+template <typename Integer>
+bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
+  // Fail fast if the given string does not begin with a digit;
+  // this bypasses strtoXXX's "optional leading whitespace and plus
+  // or minus sign" semantics, which are undesirable here.
+  if (str.empty() || !IsDigit(str[0])) {
+    return false;
+  }
+  errno = 0;
+
+  char* end;
+  // BiggestConvertible is the largest integer type that system-provided
+  // string-to-number conversion routines can return.
+  using BiggestConvertible = unsigned long long;  // NOLINT
+
+  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);  // NOLINT
+  const bool parse_success = *end == '\0' && errno == 0;
+
+  GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));
+
+  const Integer result = static_cast<Integer>(parsed);
+  if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
+    *number = result;
+    return true;
+  }
+  return false;
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+// TestResult contains some private methods that should be hidden from
+// Google Test user but are required for testing. This class allow our tests
+// to access them.
+//
+// This class is supplied only for the purpose of testing Google Test's own
+// constructs. Do not use it in user tests, either directly or indirectly.
+class TestResultAccessor {
+ public:
+  static void RecordProperty(TestResult* test_result,
+                             const std::string& xml_element,
+                             const TestProperty& property) {
+    test_result->RecordProperty(xml_element, property);
+  }
+
+  static void ClearTestPartResults(TestResult* test_result) {
+    test_result->ClearTestPartResults();
+  }
+
+  static const std::vector<testing::TestPartResult>& test_part_results(
+      const TestResult& test_result) {
+    return test_result.test_part_results();
+  }
+};
+
+#if GTEST_CAN_STREAM_RESULTS_
+
+// Streams test results to the given port on the given host machine.
+class StreamingListener : public EmptyTestEventListener {
+ public:
+  // Abstract base class for writing strings to a socket.
+  class AbstractSocketWriter {
+   public:
+    virtual ~AbstractSocketWriter() {}
+
+    // Sends a string to the socket.
+    virtual void Send(const std::string& message) = 0;
+
+    // Closes the socket.
+    virtual void CloseConnection() {}
+
+    // Sends a string and a newline to the socket.
+    void SendLn(const std::string& message) { Send(message + "\n"); }
+  };
+
+  // Concrete class for actually writing strings to a socket.
+  class SocketWriter : public AbstractSocketWriter {
+   public:
+    SocketWriter(const std::string& host, const std::string& port)
+        : sockfd_(-1), host_name_(host), port_num_(port) {
+      MakeConnection();
+    }
+
+    ~SocketWriter() override {
+      if (sockfd_ != -1)
+        CloseConnection();
+    }
+
+    // Sends a string to the socket.
+    void Send(const std::string& message) override {
+      GTEST_CHECK_(sockfd_ != -1)
+          << "Send() can be called only when there is a connection.";
+
+      const auto len = static_cast<size_t>(message.length());
+      if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) {
+        GTEST_LOG_(WARNING)
+            << "stream_result_to: failed to stream to "
+            << host_name_ << ":" << port_num_;
+      }
+    }
+
+   private:
+    // Creates a client socket and connects to the server.
+    void MakeConnection();
+
+    // Closes the socket.
+    void CloseConnection() override {
+      GTEST_CHECK_(sockfd_ != -1)
+          << "CloseConnection() can be called only when there is a connection.";
+
+      close(sockfd_);
+      sockfd_ = -1;
+    }
+
+    int sockfd_;  // socket file descriptor
+    const std::string host_name_;
+    const std::string port_num_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
+  };  // class SocketWriter
+
+  // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
+  static std::string UrlEncode(const char* str);
+
+  StreamingListener(const std::string& host, const std::string& port)
+      : socket_writer_(new SocketWriter(host, port)) {
+    Start();
+  }
+
+  explicit StreamingListener(AbstractSocketWriter* socket_writer)
+      : socket_writer_(socket_writer) { Start(); }
+
+  void OnTestProgramStart(const UnitTest& /* unit_test */) override {
+    SendLn("event=TestProgramStart");
+  }
+
+  void OnTestProgramEnd(const UnitTest& unit_test) override {
+    // Note that Google Test current only report elapsed time for each
+    // test iteration, not for the entire test program.
+    SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));
+
+    // Notify the streaming server to stop.
+    socket_writer_->CloseConnection();
+  }
+
+  void OnTestIterationStart(const UnitTest& /* unit_test */,
+                            int iteration) override {
+    SendLn("event=TestIterationStart&iteration=" +
+           StreamableToString(iteration));
+  }
+
+  void OnTestIterationEnd(const UnitTest& unit_test,
+                          int /* iteration */) override {
+    SendLn("event=TestIterationEnd&passed=" +
+           FormatBool(unit_test.Passed()) + "&elapsed_time=" +
+           StreamableToString(unit_test.elapsed_time()) + "ms");
+  }
+
+  // Note that "event=TestCaseStart" is a wire format and has to remain
+  // "case" for compatibility
+  void OnTestCaseStart(const TestCase& test_case) override {
+    SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
+  }
+
+  // Note that "event=TestCaseEnd" is a wire format and has to remain
+  // "case" for compatibility
+  void OnTestCaseEnd(const TestCase& test_case) override {
+    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) +
+           "&elapsed_time=" + StreamableToString(test_case.elapsed_time()) +
+           "ms");
+  }
+
+  void OnTestStart(const TestInfo& test_info) override {
+    SendLn(std::string("event=TestStart&name=") + test_info.name());
+  }
+
+  void OnTestEnd(const TestInfo& test_info) override {
+    SendLn("event=TestEnd&passed=" +
+           FormatBool((test_info.result())->Passed()) +
+           "&elapsed_time=" +
+           StreamableToString((test_info.result())->elapsed_time()) + "ms");
+  }
+
+  void OnTestPartResult(const TestPartResult& test_part_result) override {
+    const char* file_name = test_part_result.file_name();
+    if (file_name == nullptr) file_name = "";
+    SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
+           "&line=" + StreamableToString(test_part_result.line_number()) +
+           "&message=" + UrlEncode(test_part_result.message()));
+  }
+
+ private:
+  // Sends the given message and a newline to the socket.
+  void SendLn(const std::string& message) { socket_writer_->SendLn(message); }
+
+  // Called at the start of streaming to notify the receiver what
+  // protocol we are using.
+  void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }
+
+  std::string FormatBool(bool value) { return value ? "1" : "0"; }
+
+  const std::unique_ptr<AbstractSocketWriter> socket_writer_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
+};  // class StreamingListener
+
+#endif  // GTEST_CAN_STREAM_RESULTS_
+
+}  // namespace internal
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_
+
+#if GTEST_OS_WINDOWS
+# define vsnprintf _vsnprintf
+#endif  // GTEST_OS_WINDOWS
+
+#if GTEST_OS_MAC
+#ifndef GTEST_OS_IOS
+#include <crt_externs.h>
+#endif
+#endif
+
+#if GTEST_HAS_ABSL
+#include "absl/debugging/failure_signal_handler.h"
+#include "absl/debugging/stacktrace.h"
+#include "absl/debugging/symbolize.h"
+#include "absl/strings/str_cat.h"
+#endif  // GTEST_HAS_ABSL
+
+namespace testing {
+
+using internal::CountIf;
+using internal::ForEach;
+using internal::GetElementOr;
+using internal::Shuffle;
+
+// Constants.
+
+// A test whose test suite name or test name matches this filter is
+// disabled and not run.
+static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";
+
+// A test suite whose name matches this filter is considered a death
+// test suite and will be run before test suites whose name doesn't
+// match this filter.
+static const char kDeathTestSuiteFilter[] = "*DeathTest:*DeathTest/*";
+
+// A test filter that matches everything.
+static const char kUniversalFilter[] = "*";
+
+// The default output format.
+static const char kDefaultOutputFormat[] = "xml";
+// The default output file.
+static const char kDefaultOutputFile[] = "test_detail";
+
+// The environment variable name for the test shard index.
+static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
+// The environment variable name for the total number of test shards.
+static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
+// The environment variable name for the test shard status file.
+static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";
+
+namespace internal {
+
+// The text used in failure messages to indicate the start of the
+// stack trace.
+const char kStackTraceMarker[] = "\nStack trace:\n";
+
+// g_help_flag is true if and only if the --help flag or an equivalent form
+// is specified on the command line.
+bool g_help_flag = false;
+
+// Utilty function to Open File for Writing
+static FILE* OpenFileForWriting(const std::string& output_file) {
+  FILE* fileout = nullptr;
+  FilePath output_file_path(output_file);
+  FilePath output_dir(output_file_path.RemoveFileName());
+
+  if (output_dir.CreateDirectoriesRecursively()) {
+    fileout = posix::FOpen(output_file.c_str(), "w");
+  }
+  if (fileout == nullptr) {
+    GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
+  }
+  return fileout;
+}
+
+}  // namespace internal
+
+// Bazel passes in the argument to '--test_filter' via the TESTBRIDGE_TEST_ONLY
+// environment variable.
+static const char* GetDefaultFilter() {
+  const char* const testbridge_test_only =
+      internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
+  if (testbridge_test_only != nullptr) {
+    return testbridge_test_only;
+  }
+  return kUniversalFilter;
+}
+
+// Bazel passes in the argument to '--test_runner_fail_fast' via the
+// TESTBRIDGE_TEST_RUNNER_FAIL_FAST environment variable.
+static bool GetDefaultFailFast() {
+  const char* const testbridge_test_runner_fail_fast =
+      internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST");
+  if (testbridge_test_runner_fail_fast != nullptr) {
+    return strcmp(testbridge_test_runner_fail_fast, "1") == 0;
+  }
+  return false;
+}
+
+GTEST_DEFINE_bool_(
+    fail_fast, internal::BoolFromGTestEnv("fail_fast", GetDefaultFailFast()),
+    "True if and only if a test failure should stop further test execution.");
+
+GTEST_DEFINE_bool_(
+    also_run_disabled_tests,
+    internal::BoolFromGTestEnv("also_run_disabled_tests", false),
+    "Run disabled tests too, in addition to the tests normally being run.");
+
+GTEST_DEFINE_bool_(
+    break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false),
+    "True if and only if a failed assertion should be a debugger "
+    "break-point.");
+
+GTEST_DEFINE_bool_(catch_exceptions,
+                   internal::BoolFromGTestEnv("catch_exceptions", true),
+                   "True if and only if " GTEST_NAME_
+                   " should catch exceptions and treat them as test failures.");
+
+GTEST_DEFINE_string_(
+    color,
+    internal::StringFromGTestEnv("color", "auto"),
+    "Whether to use colors in the output.  Valid values: yes, no, "
+    "and auto.  'auto' means to use colors if the output is "
+    "being sent to a terminal and the TERM environment variable "
+    "is set to a terminal type that supports colors.");
+
+GTEST_DEFINE_string_(
+    filter,
+    internal::StringFromGTestEnv("filter", GetDefaultFilter()),
+    "A colon-separated list of glob (not regex) patterns "
+    "for filtering the tests to run, optionally followed by a "
+    "'-' and a : separated list of negative patterns (tests to "
+    "exclude).  A test is run if it matches one of the positive "
+    "patterns and does not match any of the negative patterns.");
+
+GTEST_DEFINE_bool_(
+    install_failure_signal_handler,
+    internal::BoolFromGTestEnv("install_failure_signal_handler", false),
+    "If true and supported on the current platform, " GTEST_NAME_ " should "
+    "install a signal handler that dumps debugging information when fatal "
+    "signals are raised.");
+
+GTEST_DEFINE_bool_(list_tests, false,
+                   "List all tests without running them.");
+
+// The net priority order after flag processing is thus:
+//   --gtest_output command line flag
+//   GTEST_OUTPUT environment variable
+//   XML_OUTPUT_FILE environment variable
+//   ''
+GTEST_DEFINE_string_(
+    output,
+    internal::StringFromGTestEnv("output",
+      internal::OutputFlagAlsoCheckEnvVar().c_str()),
+    "A format (defaults to \"xml\" but can be specified to be \"json\"), "
+    "optionally followed by a colon and an output file name or directory. "
+    "A directory is indicated by a trailing pathname separator. "
+    "Examples: \"xml:filename.xml\", \"xml::directoryname/\". "
+    "If a directory is specified, output files will be created "
+    "within that directory, with file-names based on the test "
+    "executable's name and, if necessary, made unique by adding "
+    "digits.");
+
+GTEST_DEFINE_bool_(
+    brief, internal::BoolFromGTestEnv("brief", false),
+    "True if only test failures should be displayed in text output.");
+
+GTEST_DEFINE_bool_(print_time, internal::BoolFromGTestEnv("print_time", true),
+                   "True if and only if " GTEST_NAME_
+                   " should display elapsed time in text output.");
+
+GTEST_DEFINE_bool_(print_utf8, internal::BoolFromGTestEnv("print_utf8", true),
+                   "True if and only if " GTEST_NAME_
+                   " prints UTF8 characters as text.");
+
+GTEST_DEFINE_int32_(
+    random_seed,
+    internal::Int32FromGTestEnv("random_seed", 0),
+    "Random number seed to use when shuffling test orders.  Must be in range "
+    "[1, 99999], or 0 to use a seed based on the current time.");
+
+GTEST_DEFINE_int32_(
+    repeat,
+    internal::Int32FromGTestEnv("repeat", 1),
+    "How many times to repeat each test.  Specify a negative number "
+    "for repeating forever.  Useful for shaking out flaky tests.");
+
+GTEST_DEFINE_bool_(show_internal_stack_frames, false,
+                   "True if and only if " GTEST_NAME_
+                   " should include internal stack frames when "
+                   "printing test failure stack traces.");
+
+GTEST_DEFINE_bool_(shuffle, internal::BoolFromGTestEnv("shuffle", false),
+                   "True if and only if " GTEST_NAME_
+                   " should randomize tests' order on every run.");
+
+GTEST_DEFINE_int32_(
+    stack_trace_depth,
+    internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),
+    "The maximum number of stack frames to print when an "
+    "assertion fails.  The valid range is 0 through 100, inclusive.");
+
+GTEST_DEFINE_string_(
+    stream_result_to,
+    internal::StringFromGTestEnv("stream_result_to", ""),
+    "This flag specifies the host name and the port number on which to stream "
+    "test results. Example: \"localhost:555\". The flag is effective only on "
+    "Linux.");
+
+GTEST_DEFINE_bool_(
+    throw_on_failure,
+    internal::BoolFromGTestEnv("throw_on_failure", false),
+    "When this flag is specified, a failed assertion will throw an exception "
+    "if exceptions are enabled or exit the program with a non-zero code "
+    "otherwise. For use with an external test framework.");
+
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+GTEST_DEFINE_string_(
+    flagfile,
+    internal::StringFromGTestEnv("flagfile", ""),
+    "This flag specifies the flagfile to read command-line flags from.");
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+
+namespace internal {
+
+// Generates a random number from [0, range), using a Linear
+// Congruential Generator (LCG).  Crashes if 'range' is 0 or greater
+// than kMaxRange.
+uint32_t Random::Generate(uint32_t range) {
+  // These constants are the same as are used in glibc's rand(3).
+  // Use wider types than necessary to prevent unsigned overflow diagnostics.
+  state_ = static_cast<uint32_t>(1103515245ULL*state_ + 12345U) % kMaxRange;
+
+  GTEST_CHECK_(range > 0)
+      << "Cannot generate a number in the range [0, 0).";
+  GTEST_CHECK_(range <= kMaxRange)
+      << "Generation of a number in [0, " << range << ") was requested, "
+      << "but this can only generate numbers in [0, " << kMaxRange << ").";
+
+  // Converting via modulus introduces a bit of downward bias, but
+  // it's simple, and a linear congruential generator isn't too good
+  // to begin with.
+  return state_ % range;
+}
+
+// GTestIsInitialized() returns true if and only if the user has initialized
+// Google Test.  Useful for catching the user mistake of not initializing
+// Google Test before calling RUN_ALL_TESTS().
+static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
+
+// Iterates over a vector of TestSuites, keeping a running sum of the
+// results of calling a given int-returning method on each.
+// Returns the sum.
+static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list,
+                                int (TestSuite::*method)() const) {
+  int sum = 0;
+  for (size_t i = 0; i < case_list.size(); i++) {
+    sum += (case_list[i]->*method)();
+  }
+  return sum;
+}
+
+// Returns true if and only if the test suite passed.
+static bool TestSuitePassed(const TestSuite* test_suite) {
+  return test_suite->should_run() && test_suite->Passed();
+}
+
+// Returns true if and only if the test suite failed.
+static bool TestSuiteFailed(const TestSuite* test_suite) {
+  return test_suite->should_run() && test_suite->Failed();
+}
+
+// Returns true if and only if test_suite contains at least one test that
+// should run.
+static bool ShouldRunTestSuite(const TestSuite* test_suite) {
+  return test_suite->should_run();
+}
+
+// AssertHelper constructor.
+AssertHelper::AssertHelper(TestPartResult::Type type,
+                           const char* file,
+                           int line,
+                           const char* message)
+    : data_(new AssertHelperData(type, file, line, message)) {
+}
+
+AssertHelper::~AssertHelper() {
+  delete data_;
+}
+
+// Message assignment, for assertion streaming support.
+void AssertHelper::operator=(const Message& message) const {
+  UnitTest::GetInstance()->
+    AddTestPartResult(data_->type, data_->file, data_->line,
+                      AppendUserMessage(data_->message, message),
+                      UnitTest::GetInstance()->impl()
+                      ->CurrentOsStackTraceExceptTop(1)
+                      // Skips the stack frame for this function itself.
+                      );  // NOLINT
+}
+
+namespace {
+
+// When TEST_P is found without a matching INSTANTIATE_TEST_SUITE_P
+// to creates test cases for it, a synthetic test case is
+// inserted to report ether an error or a log message.
+//
+// This configuration bit will likely be removed at some point.
+constexpr bool kErrorOnUninstantiatedParameterizedTest = true;
+constexpr bool kErrorOnUninstantiatedTypeParameterizedTest = true;
+
+// A test that fails at a given file/line location with a given message.
+class FailureTest : public Test {
+ public:
+  explicit FailureTest(const CodeLocation& loc, std::string error_message,
+                       bool as_error)
+      : loc_(loc),
+        error_message_(std::move(error_message)),
+        as_error_(as_error) {}
+
+  void TestBody() override {
+    if (as_error_) {
+      AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),
+                   loc_.line, "") = Message() << error_message_;
+    } else {
+      std::cout << error_message_ << std::endl;
+    }
+  }
+
+ private:
+  const CodeLocation loc_;
+  const std::string error_message_;
+  const bool as_error_;
+};
+
+
+}  // namespace
+
+std::set<std::string>* GetIgnoredParameterizedTestSuites() {
+  return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites();
+}
+
+// Add a given test_suit to the list of them allow to go un-instantiated.
+MarkAsIgnored::MarkAsIgnored(const char* test_suite) {
+  GetIgnoredParameterizedTestSuites()->insert(test_suite);
+}
+
+// If this parameterized test suite has no instantiations (and that
+// has not been marked as okay), emit a test case reporting that.
+void InsertSyntheticTestCase(const std::string& name, CodeLocation location,
+                             bool has_test_p) {
+  const auto& ignored = *GetIgnoredParameterizedTestSuites();
+  if (ignored.find(name) != ignored.end()) return;
+
+  const char kMissingInstantiation[] =  //
+      " is defined via TEST_P, but never instantiated. None of the test cases "
+      "will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only "
+      "ones provided expand to nothing."
+      "\n\n"
+      "Ideally, TEST_P definitions should only ever be included as part of "
+      "binaries that intend to use them. (As opposed to, for example, being "
+      "placed in a library that may be linked in to get other utilities.)";
+
+  const char kMissingTestCase[] =  //
+      " is instantiated via INSTANTIATE_TEST_SUITE_P, but no tests are "
+      "defined via TEST_P . No test cases will run."
+      "\n\n"
+      "Ideally, INSTANTIATE_TEST_SUITE_P should only ever be invoked from "
+      "code that always depend on code that provides TEST_P. Failing to do "
+      "so is often an indication of dead code, e.g. the last TEST_P was "
+      "removed but the rest got left behind.";
+
+  std::string message =
+      "Parameterized test suite " + name +
+      (has_test_p ? kMissingInstantiation : kMissingTestCase) +
+      "\n\n"
+      "To suppress this error for this test suite, insert the following line "
+      "(in a non-header) in the namespace it is defined in:"
+      "\n\n"
+      "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" + name + ");";
+
+  std::string full_name = "UninstantiatedParameterizedTestSuite<" + name + ">";
+  RegisterTest(  //
+      "GoogleTestVerification", full_name.c_str(),
+      nullptr,  // No type parameter.
+      nullptr,  // No value parameter.
+      location.file.c_str(), location.line, [message, location] {
+        return new FailureTest(location, message,
+                               kErrorOnUninstantiatedParameterizedTest);
+      });
+}
+
+void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
+                                        CodeLocation code_location) {
+  GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
+      test_suite_name, code_location);
+}
+
+void RegisterTypeParameterizedTestSuiteInstantiation(const char* case_name) {
+  GetUnitTestImpl()
+      ->type_parameterized_test_registry()
+      .RegisterInstantiation(case_name);
+}
+
+void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(
+    const char* test_suite_name, CodeLocation code_location) {
+  suites_.emplace(std::string(test_suite_name),
+                 TypeParameterizedTestSuiteInfo(code_location));
+}
+
+void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
+        const char* test_suite_name) {
+  auto it = suites_.find(std::string(test_suite_name));
+  if (it != suites_.end()) {
+    it->second.instantiated = true;
+  } else {
+    GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '"
+                      << test_suite_name << "'";
+  }
+}
+
+void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
+  const auto& ignored = *GetIgnoredParameterizedTestSuites();
+  for (const auto& testcase : suites_) {
+    if (testcase.second.instantiated) continue;
+    if (ignored.find(testcase.first) != ignored.end()) continue;
+
+    std::string message =
+        "Type parameterized test suite " + testcase.first +
+        " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated "
+        "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run."
+        "\n\n"
+        "Ideally, TYPED_TEST_P definitions should only ever be included as "
+        "part of binaries that intend to use them. (As opposed to, for "
+        "example, being placed in a library that may be linked in to get other "
+        "utilities.)"
+        "\n\n"
+        "To suppress this error for this test suite, insert the following line "
+        "(in a non-header) in the namespace it is defined in:"
+        "\n\n"
+        "GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
+        testcase.first + ");";
+
+    std::string full_name =
+        "UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">";
+    RegisterTest(  //
+        "GoogleTestVerification", full_name.c_str(),
+        nullptr,  // No type parameter.
+        nullptr,  // No value parameter.
+        testcase.second.code_location.file.c_str(),
+        testcase.second.code_location.line, [message, testcase] {
+          return new FailureTest(testcase.second.code_location, message,
+                                 kErrorOnUninstantiatedTypeParameterizedTest);
+        });
+  }
+}
+
+// A copy of all command line arguments.  Set by InitGoogleTest().
+static ::std::vector<std::string> g_argvs;
+
+::std::vector<std::string> GetArgvs() {
+#if defined(GTEST_CUSTOM_GET_ARGVS_)
+  // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or
+  // ::string. This code converts it to the appropriate type.
+  const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
+  return ::std::vector<std::string>(custom.begin(), custom.end());
+#else   // defined(GTEST_CUSTOM_GET_ARGVS_)
+  return g_argvs;
+#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
+}
+
+// Returns the current application's name, removing directory path if that
+// is present.
+FilePath GetCurrentExecutableName() {
+  FilePath result;
+
+#if GTEST_OS_WINDOWS || GTEST_OS_OS2
+  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
+#else
+  result.Set(FilePath(GetArgvs()[0]));
+#endif  // GTEST_OS_WINDOWS
+
+  return result.RemoveDirectoryName();
+}
+
+// Functions for processing the gtest_output flag.
+
+// Returns the output format, or "" for normal printed output.
+std::string UnitTestOptions::GetOutputFormat() {
+  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
+  const char* const colon = strchr(gtest_output_flag, ':');
+  return (colon == nullptr)
+             ? std::string(gtest_output_flag)
+             : std::string(gtest_output_flag,
+                           static_cast<size_t>(colon - gtest_output_flag));
+}
+
+// Returns the name of the requested output file, or the default if none
+// was explicitly specified.
+std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
+  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
+
+  std::string format = GetOutputFormat();
+  if (format.empty())
+    format = std::string(kDefaultOutputFormat);
+
+  const char* const colon = strchr(gtest_output_flag, ':');
+  if (colon == nullptr)
+    return internal::FilePath::MakeFileName(
+        internal::FilePath(
+            UnitTest::GetInstance()->original_working_dir()),
+        internal::FilePath(kDefaultOutputFile), 0,
+        format.c_str()).string();
+
+  internal::FilePath output_name(colon + 1);
+  if (!output_name.IsAbsolutePath())
+    output_name = internal::FilePath::ConcatPaths(
+        internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
+        internal::FilePath(colon + 1));
+
+  if (!output_name.IsDirectory())
+    return output_name.string();
+
+  internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
+      output_name, internal::GetCurrentExecutableName(),
+      GetOutputFormat().c_str()));
+  return result.string();
+}
+
+// Returns true if and only if the wildcard pattern matches the string. Each
+// pattern consists of regular characters, single-character wildcards (?), and
+// multi-character wildcards (*).
+//
+// This function implements a linear-time string globbing algorithm based on
+// https://research.swtch.com/glob.
+static bool PatternMatchesString(const std::string& name_str,
+                                 const char* pattern, const char* pattern_end) {
+  const char* name = name_str.c_str();
+  const char* const name_begin = name;
+  const char* const name_end = name + name_str.size();
+
+  const char* pattern_next = pattern;
+  const char* name_next = name;
+
+  while (pattern < pattern_end || name < name_end) {
+    if (pattern < pattern_end) {
+      switch (*pattern) {
+        default:  // Match an ordinary character.
+          if (name < name_end && *name == *pattern) {
+            ++pattern;
+            ++name;
+            continue;
+          }
+          break;
+        case '?':  // Match any single character.
+          if (name < name_end) {
+            ++pattern;
+            ++name;
+            continue;
+          }
+          break;
+        case '*':
+          // Match zero or more characters. Start by skipping over the wildcard
+          // and matching zero characters from name. If that fails, restart and
+          // match one more character than the last attempt.
+          pattern_next = pattern;
+          name_next = name + 1;
+          ++pattern;
+          continue;
+      }
+    }
+    // Failed to match a character. Restart if possible.
+    if (name_begin < name_next && name_next <= name_end) {
+      pattern = pattern_next;
+      name = name_next;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+
+bool UnitTestOptions::MatchesFilter(const std::string& name_str,
+                                    const char* filter) {
+  // The filter is a list of patterns separated by colons (:).
+  const char* pattern = filter;
+  while (true) {
+    // Find the bounds of this pattern.
+    const char* const next_sep = strchr(pattern, ':');
+    const char* const pattern_end =
+        next_sep != nullptr ? next_sep : pattern + strlen(pattern);
+
+    // Check if this pattern matches name_str.
+    if (PatternMatchesString(name_str, pattern, pattern_end)) {
+      break;
+    }
+
+    // Give up on this pattern. However, if we found a pattern separator (:),
+    // advance to the next pattern (skipping over the separator) and restart.
+    if (next_sep == nullptr) {
+      return false;
+    }
+    pattern = next_sep + 1;
+  }
+  return true;
+}
+
+// Returns true if and only if the user-specified filter matches the test
+// suite name and the test name.
+bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,
+                                        const std::string& test_name) {
+  const std::string& full_name = test_suite_name + "." + test_name.c_str();
+
+  // Split --gtest_filter at '-', if there is one, to separate into
+  // positive filter and negative filter portions
+  const char* const p = GTEST_FLAG(filter).c_str();
+  const char* const dash = strchr(p, '-');
+  std::string positive;
+  std::string negative;
+  if (dash == nullptr) {
+    positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
+    negative = "";
+  } else {
+    positive = std::string(p, dash);   // Everything up to the dash
+    negative = std::string(dash + 1);  // Everything after the dash
+    if (positive.empty()) {
+      // Treat '-test1' as the same as '*-test1'
+      positive = kUniversalFilter;
+    }
+  }
+
+  // A filter is a colon-separated list of patterns.  It matches a
+  // test if any pattern in it matches the test.
+  return (MatchesFilter(full_name, positive.c_str()) &&
+          !MatchesFilter(full_name, negative.c_str()));
+}
+
+#if GTEST_HAS_SEH
+// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
+// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
+// This function is useful as an __except condition.
+int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
+  // Google Test should handle a SEH exception if:
+  //   1. the user wants it to, AND
+  //   2. this is not a breakpoint exception, AND
+  //   3. this is not a C++ exception (VC++ implements them via SEH,
+  //      apparently).
+  //
+  // SEH exception code for C++ exceptions.
+  // (see http://support.microsoft.com/kb/185294 for more information).
+  const DWORD kCxxExceptionCode = 0xe06d7363;
+
+  bool should_handle = true;
+
+  if (!GTEST_FLAG(catch_exceptions))
+    should_handle = false;
+  else if (exception_code == EXCEPTION_BREAKPOINT)
+    should_handle = false;
+  else if (exception_code == kCxxExceptionCode)
+    should_handle = false;
+
+  return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
+}
+#endif  // GTEST_HAS_SEH
+
+}  // namespace internal
+
+// The c'tor sets this object as the test part result reporter used by
+// Google Test.  The 'result' parameter specifies where to report the
+// results. Intercepts only failures from the current thread.
+ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
+    TestPartResultArray* result)
+    : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),
+      result_(result) {
+  Init();
+}
+
+// The c'tor sets this object as the test part result reporter used by
+// Google Test.  The 'result' parameter specifies where to report the
+// results.
+ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
+    InterceptMode intercept_mode, TestPartResultArray* result)
+    : intercept_mode_(intercept_mode),
+      result_(result) {
+  Init();
+}
+
+void ScopedFakeTestPartResultReporter::Init() {
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
+    old_reporter_ = impl->GetGlobalTestPartResultReporter();
+    impl->SetGlobalTestPartResultReporter(this);
+  } else {
+    old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
+    impl->SetTestPartResultReporterForCurrentThread(this);
+  }
+}
+
+// The d'tor restores the test part result reporter used by Google Test
+// before.
+ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
+    impl->SetGlobalTestPartResultReporter(old_reporter_);
+  } else {
+    impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
+  }
+}
+
+// Increments the test part result count and remembers the result.
+// This method is from the TestPartResultReporterInterface interface.
+void ScopedFakeTestPartResultReporter::ReportTestPartResult(
+    const TestPartResult& result) {
+  result_->Append(result);
+}
+
+namespace internal {
+
+// Returns the type ID of ::testing::Test.  We should always call this
+// instead of GetTypeId< ::testing::Test>() to get the type ID of
+// testing::Test.  This is to work around a suspected linker bug when
+// using Google Test as a framework on Mac OS X.  The bug causes
+// GetTypeId< ::testing::Test>() to return different values depending
+// on whether the call is from the Google Test framework itself or
+// from user test code.  GetTestTypeId() is guaranteed to always
+// return the same value, as it always calls GetTypeId<>() from the
+// gtest.cc, which is within the Google Test framework.
+TypeId GetTestTypeId() {
+  return GetTypeId<Test>();
+}
+
+// The value of GetTestTypeId() as seen from within the Google Test
+// library.  This is solely for testing GetTestTypeId().
+extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId();
+
+// This predicate-formatter checks that 'results' contains a test part
+// failure of the given type and that the failure message contains the
+// given substring.
+static AssertionResult HasOneFailure(const char* /* results_expr */,
+                                     const char* /* type_expr */,
+                                     const char* /* substr_expr */,
+                                     const TestPartResultArray& results,
+                                     TestPartResult::Type type,
+                                     const std::string& substr) {
+  const std::string expected(type == TestPartResult::kFatalFailure ?
+                        "1 fatal failure" :
+                        "1 non-fatal failure");
+  Message msg;
+  if (results.size() != 1) {
+    msg << "Expected: " << expected << "\n"
+        << "  Actual: " << results.size() << " failures";
+    for (int i = 0; i < results.size(); i++) {
+      msg << "\n" << results.GetTestPartResult(i);
+    }
+    return AssertionFailure() << msg;
+  }
+
+  const TestPartResult& r = results.GetTestPartResult(0);
+  if (r.type() != type) {
+    return AssertionFailure() << "Expected: " << expected << "\n"
+                              << "  Actual:\n"
+                              << r;
+  }
+
+  if (strstr(r.message(), substr.c_str()) == nullptr) {
+    return AssertionFailure() << "Expected: " << expected << " containing \""
+                              << substr << "\"\n"
+                              << "  Actual:\n"
+                              << r;
+  }
+
+  return AssertionSuccess();
+}
+
+// The constructor of SingleFailureChecker remembers where to look up
+// test part results, what type of failure we expect, and what
+// substring the failure message should contain.
+SingleFailureChecker::SingleFailureChecker(const TestPartResultArray* results,
+                                           TestPartResult::Type type,
+                                           const std::string& substr)
+    : results_(results), type_(type), substr_(substr) {}
+
+// The destructor of SingleFailureChecker verifies that the given
+// TestPartResultArray contains exactly one failure that has the given
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+SingleFailureChecker::~SingleFailureChecker() {
+  EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
+}
+
+DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
+    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
+
+void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
+    const TestPartResult& result) {
+  unit_test_->current_test_result()->AddTestPartResult(result);
+  unit_test_->listeners()->repeater()->OnTestPartResult(result);
+}
+
+DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
+    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
+
+void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
+    const TestPartResult& result) {
+  unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);
+}
+
+// Returns the global test part result reporter.
+TestPartResultReporterInterface*
+UnitTestImpl::GetGlobalTestPartResultReporter() {
+  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
+  return global_test_part_result_repoter_;
+}
+
+// Sets the global test part result reporter.
+void UnitTestImpl::SetGlobalTestPartResultReporter(
+    TestPartResultReporterInterface* reporter) {
+  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
+  global_test_part_result_repoter_ = reporter;
+}
+
+// Returns the test part result reporter for the current thread.
+TestPartResultReporterInterface*
+UnitTestImpl::GetTestPartResultReporterForCurrentThread() {
+  return per_thread_test_part_result_reporter_.get();
+}
+
+// Sets the test part result reporter for the current thread.
+void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
+    TestPartResultReporterInterface* reporter) {
+  per_thread_test_part_result_reporter_.set(reporter);
+}
+
+// Gets the number of successful test suites.
+int UnitTestImpl::successful_test_suite_count() const {
+  return CountIf(test_suites_, TestSuitePassed);
+}
+
+// Gets the number of failed test suites.
+int UnitTestImpl::failed_test_suite_count() const {
+  return CountIf(test_suites_, TestSuiteFailed);
+}
+
+// Gets the number of all test suites.
+int UnitTestImpl::total_test_suite_count() const {
+  return static_cast<int>(test_suites_.size());
+}
+
+// Gets the number of all test suites that contain at least one test
+// that should run.
+int UnitTestImpl::test_suite_to_run_count() const {
+  return CountIf(test_suites_, ShouldRunTestSuite);
+}
+
+// Gets the number of successful tests.
+int UnitTestImpl::successful_test_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::successful_test_count);
+}
+
+// Gets the number of skipped tests.
+int UnitTestImpl::skipped_test_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::skipped_test_count);
+}
+
+// Gets the number of failed tests.
+int UnitTestImpl::failed_test_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::failed_test_count);
+}
+
+// Gets the number of disabled tests that will be reported in the XML report.
+int UnitTestImpl::reportable_disabled_test_count() const {
+  return SumOverTestSuiteList(test_suites_,
+                              &TestSuite::reportable_disabled_test_count);
+}
+
+// Gets the number of disabled tests.
+int UnitTestImpl::disabled_test_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::disabled_test_count);
+}
+
+// Gets the number of tests to be printed in the XML report.
+int UnitTestImpl::reportable_test_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::reportable_test_count);
+}
+
+// Gets the number of all tests.
+int UnitTestImpl::total_test_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count);
+}
+
+// Gets the number of tests that should run.
+int UnitTestImpl::test_to_run_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);
+}
+
+// Returns the current OS stack trace as an std::string.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// CurrentOsStackTraceExceptTop(1), Foo() will be included in the
+// trace but Bar() and CurrentOsStackTraceExceptTop() won't.
+std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
+  return os_stack_trace_getter()->CurrentStackTrace(
+      static_cast<int>(GTEST_FLAG(stack_trace_depth)),
+      skip_count + 1
+      // Skips the user-specified number of frames plus this function
+      // itself.
+      );  // NOLINT
+}
+
+// A helper class for measuring elapsed times.
+class Timer {
+ public:
+  Timer() : start_(std::chrono::steady_clock::now()) {}
+
+  // Return time elapsed in milliseconds since the timer was created.
+  TimeInMillis Elapsed() {
+    return std::chrono::duration_cast<std::chrono::milliseconds>(
+               std::chrono::steady_clock::now() - start_)
+        .count();
+  }
+
+ private:
+  std::chrono::steady_clock::time_point start_;
+};
+
+// Returns a timestamp as milliseconds since the epoch. Note this time may jump
+// around subject to adjustments by the system, to measure elapsed time use
+// Timer instead.
+TimeInMillis GetTimeInMillis() {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(
+             std::chrono::system_clock::now() -
+             std::chrono::system_clock::from_time_t(0))
+      .count();
+}
+
+// Utilities
+
+// class String.
+
+#if GTEST_OS_WINDOWS_MOBILE
+// Creates a UTF-16 wide string from the given ANSI string, allocating
+// memory using new. The caller is responsible for deleting the return
+// value using delete[]. Returns the wide string, or NULL if the
+// input is NULL.
+LPCWSTR String::AnsiToUtf16(const char* ansi) {
+  if (!ansi) return nullptr;
+  const int length = strlen(ansi);
+  const int unicode_length =
+      MultiByteToWideChar(CP_ACP, 0, ansi, length, nullptr, 0);
+  WCHAR* unicode = new WCHAR[unicode_length + 1];
+  MultiByteToWideChar(CP_ACP, 0, ansi, length,
+                      unicode, unicode_length);
+  unicode[unicode_length] = 0;
+  return unicode;
+}
+
+// Creates an ANSI string from the given wide string, allocating
+// memory using new. The caller is responsible for deleting the return
+// value using delete[]. Returns the ANSI string, or NULL if the
+// input is NULL.
+const char* String::Utf16ToAnsi(LPCWSTR utf16_str)  {
+  if (!utf16_str) return nullptr;
+  const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, nullptr,
+                                              0, nullptr, nullptr);
+  char* ansi = new char[ansi_length + 1];
+  WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, ansi, ansi_length, nullptr,
+                      nullptr);
+  ansi[ansi_length] = 0;
+  return ansi;
+}
+
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+// Compares two C strings.  Returns true if and only if they have the same
+// content.
+//
+// Unlike strcmp(), this function can handle NULL argument(s).  A NULL
+// C string is considered different to any non-NULL C string,
+// including the empty string.
+bool String::CStringEquals(const char * lhs, const char * rhs) {
+  if (lhs == nullptr) return rhs == nullptr;
+
+  if (rhs == nullptr) return false;
+
+  return strcmp(lhs, rhs) == 0;
+}
+
+#if GTEST_HAS_STD_WSTRING
+
+// Converts an array of wide chars to a narrow string using the UTF-8
+// encoding, and streams the result to the given Message object.
+static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
+                                     Message* msg) {
+  for (size_t i = 0; i != length; ) {  // NOLINT
+    if (wstr[i] != L'\0') {
+      *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
+      while (i != length && wstr[i] != L'\0')
+        i++;
+    } else {
+      *msg << '\0';
+      i++;
+    }
+  }
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+void SplitString(const ::std::string& str, char delimiter,
+                 ::std::vector< ::std::string>* dest) {
+  ::std::vector< ::std::string> parsed;
+  ::std::string::size_type pos = 0;
+  while (::testing::internal::AlwaysTrue()) {
+    const ::std::string::size_type colon = str.find(delimiter, pos);
+    if (colon == ::std::string::npos) {
+      parsed.push_back(str.substr(pos));
+      break;
+    } else {
+      parsed.push_back(str.substr(pos, colon - pos));
+      pos = colon + 1;
+    }
+  }
+  dest->swap(parsed);
+}
+
+}  // namespace internal
+
+// Constructs an empty Message.
+// We allocate the stringstream separately because otherwise each use of
+// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
+// stack frame leading to huge stack frames in some cases; gcc does not reuse
+// the stack space.
+Message::Message() : ss_(new ::std::stringstream) {
+  // By default, we want there to be enough precision when printing
+  // a double to a Message.
+  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
+}
+
+// These two overloads allow streaming a wide C string to a Message
+// using the UTF-8 encoding.
+Message& Message::operator <<(const wchar_t* wide_c_str) {
+  return *this << internal::String::ShowWideCString(wide_c_str);
+}
+Message& Message::operator <<(wchar_t* wide_c_str) {
+  return *this << internal::String::ShowWideCString(wide_c_str);
+}
+
+#if GTEST_HAS_STD_WSTRING
+// Converts the given wide string to a narrow string using the UTF-8
+// encoding, and streams the result to this Message object.
+Message& Message::operator <<(const ::std::wstring& wstr) {
+  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
+  return *this;
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+// Gets the text streamed to this object so far as an std::string.
+// Each '\0' character in the buffer is replaced with "\\0".
+std::string Message::GetString() const {
+  return internal::StringStreamToString(ss_.get());
+}
+
+// AssertionResult constructors.
+// Used in EXPECT_TRUE/FALSE(assertion_result).
+AssertionResult::AssertionResult(const AssertionResult& other)
+    : success_(other.success_),
+      message_(other.message_.get() != nullptr
+                   ? new ::std::string(*other.message_)
+                   : static_cast< ::std::string*>(nullptr)) {}
+
+// Swaps two AssertionResults.
+void AssertionResult::swap(AssertionResult& other) {
+  using std::swap;
+  swap(success_, other.success_);
+  swap(message_, other.message_);
+}
+
+// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
+AssertionResult AssertionResult::operator!() const {
+  AssertionResult negation(!success_);
+  if (message_.get() != nullptr) negation << *message_;
+  return negation;
+}
+
+// Makes a successful assertion result.
+AssertionResult AssertionSuccess() {
+  return AssertionResult(true);
+}
+
+// Makes a failed assertion result.
+AssertionResult AssertionFailure() {
+  return AssertionResult(false);
+}
+
+// Makes a failed assertion result with the given failure message.
+// Deprecated; use AssertionFailure() << message.
+AssertionResult AssertionFailure(const Message& message) {
+  return AssertionFailure() << message;
+}
+
+namespace internal {
+
+namespace edit_distance {
+std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
+                                            const std::vector<size_t>& right) {
+  std::vector<std::vector<double> > costs(
+      left.size() + 1, std::vector<double>(right.size() + 1));
+  std::vector<std::vector<EditType> > best_move(
+      left.size() + 1, std::vector<EditType>(right.size() + 1));
+
+  // Populate for empty right.
+  for (size_t l_i = 0; l_i < costs.size(); ++l_i) {
+    costs[l_i][0] = static_cast<double>(l_i);
+    best_move[l_i][0] = kRemove;
+  }
+  // Populate for empty left.
+  for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) {
+    costs[0][r_i] = static_cast<double>(r_i);
+    best_move[0][r_i] = kAdd;
+  }
+
+  for (size_t l_i = 0; l_i < left.size(); ++l_i) {
+    for (size_t r_i = 0; r_i < right.size(); ++r_i) {
+      if (left[l_i] == right[r_i]) {
+        // Found a match. Consume it.
+        costs[l_i + 1][r_i + 1] = costs[l_i][r_i];
+        best_move[l_i + 1][r_i + 1] = kMatch;
+        continue;
+      }
+
+      const double add = costs[l_i + 1][r_i];
+      const double remove = costs[l_i][r_i + 1];
+      const double replace = costs[l_i][r_i];
+      if (add < remove && add < replace) {
+        costs[l_i + 1][r_i + 1] = add + 1;
+        best_move[l_i + 1][r_i + 1] = kAdd;
+      } else if (remove < add && remove < replace) {
+        costs[l_i + 1][r_i + 1] = remove + 1;
+        best_move[l_i + 1][r_i + 1] = kRemove;
+      } else {
+        // We make replace a little more expensive than add/remove to lower
+        // their priority.
+        costs[l_i + 1][r_i + 1] = replace + 1.00001;
+        best_move[l_i + 1][r_i + 1] = kReplace;
+      }
+    }
+  }
+
+  // Reconstruct the best path. We do it in reverse order.
+  std::vector<EditType> best_path;
+  for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) {
+    EditType move = best_move[l_i][r_i];
+    best_path.push_back(move);
+    l_i -= move != kAdd;
+    r_i -= move != kRemove;
+  }
+  std::reverse(best_path.begin(), best_path.end());
+  return best_path;
+}
+
+namespace {
+
+// Helper class to convert string into ids with deduplication.
+class InternalStrings {
+ public:
+  size_t GetId(const std::string& str) {
+    IdMap::iterator it = ids_.find(str);
+    if (it != ids_.end()) return it->second;
+    size_t id = ids_.size();
+    return ids_[str] = id;
+  }
+
+ private:
+  typedef std::map<std::string, size_t> IdMap;
+  IdMap ids_;
+};
+
+}  // namespace
+
+std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<std::string>& left,
+    const std::vector<std::string>& right) {
+  std::vector<size_t> left_ids, right_ids;
+  {
+    InternalStrings intern_table;
+    for (size_t i = 0; i < left.size(); ++i) {
+      left_ids.push_back(intern_table.GetId(left[i]));
+    }
+    for (size_t i = 0; i < right.size(); ++i) {
+      right_ids.push_back(intern_table.GetId(right[i]));
+    }
+  }
+  return CalculateOptimalEdits(left_ids, right_ids);
+}
+
+namespace {
+
+// Helper class that holds the state for one hunk and prints it out to the
+// stream.
+// It reorders adds/removes when possible to group all removes before all
+// adds. It also adds the hunk header before printint into the stream.
+class Hunk {
+ public:
+  Hunk(size_t left_start, size_t right_start)
+      : left_start_(left_start),
+        right_start_(right_start),
+        adds_(),
+        removes_(),
+        common_() {}
+
+  void PushLine(char edit, const char* line) {
+    switch (edit) {
+      case ' ':
+        ++common_;
+        FlushEdits();
+        hunk_.push_back(std::make_pair(' ', line));
+        break;
+      case '-':
+        ++removes_;
+        hunk_removes_.push_back(std::make_pair('-', line));
+        break;
+      case '+':
+        ++adds_;
+        hunk_adds_.push_back(std::make_pair('+', line));
+        break;
+    }
+  }
+
+  void PrintTo(std::ostream* os) {
+    PrintHeader(os);
+    FlushEdits();
+    for (std::list<std::pair<char, const char*> >::const_iterator it =
+             hunk_.begin();
+         it != hunk_.end(); ++it) {
+      *os << it->first << it->second << "\n";
+    }
+  }
+
+  bool has_edits() const { return adds_ || removes_; }
+
+ private:
+  void FlushEdits() {
+    hunk_.splice(hunk_.end(), hunk_removes_);
+    hunk_.splice(hunk_.end(), hunk_adds_);
+  }
+
+  // Print a unified diff header for one hunk.
+  // The format is
+  //   "@@ -<left_start>,<left_length> +<right_start>,<right_length> @@"
+  // where the left/right parts are omitted if unnecessary.
+  void PrintHeader(std::ostream* ss) const {
+    *ss << "@@ ";
+    if (removes_) {
+      *ss << "-" << left_start_ << "," << (removes_ + common_);
+    }
+    if (removes_ && adds_) {
+      *ss << " ";
+    }
+    if (adds_) {
+      *ss << "+" << right_start_ << "," << (adds_ + common_);
+    }
+    *ss << " @@\n";
+  }
+
+  size_t left_start_, right_start_;
+  size_t adds_, removes_, common_;
+  std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_;
+};
+
+}  // namespace
+
+// Create a list of diff hunks in Unified diff format.
+// Each hunk has a header generated by PrintHeader above plus a body with
+// lines prefixed with ' ' for no change, '-' for deletion and '+' for
+// addition.
+// 'context' represents the desired unchanged prefix/suffix around the diff.
+// If two hunks are close enough that their contexts overlap, then they are
+// joined into one hunk.
+std::string CreateUnifiedDiff(const std::vector<std::string>& left,
+                              const std::vector<std::string>& right,
+                              size_t context) {
+  const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
+
+  size_t l_i = 0, r_i = 0, edit_i = 0;
+  std::stringstream ss;
+  while (edit_i < edits.size()) {
+    // Find first edit.
+    while (edit_i < edits.size() && edits[edit_i] == kMatch) {
+      ++l_i;
+      ++r_i;
+      ++edit_i;
+    }
+
+    // Find the first line to include in the hunk.
+    const size_t prefix_context = std::min(l_i, context);
+    Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);
+    for (size_t i = prefix_context; i > 0; --i) {
+      hunk.PushLine(' ', left[l_i - i].c_str());
+    }
+
+    // Iterate the edits until we found enough suffix for the hunk or the input
+    // is over.
+    size_t n_suffix = 0;
+    for (; edit_i < edits.size(); ++edit_i) {
+      if (n_suffix >= context) {
+        // Continue only if the next hunk is very close.
+        auto it = edits.begin() + static_cast<int>(edit_i);
+        while (it != edits.end() && *it == kMatch) ++it;
+        if (it == edits.end() ||
+            static_cast<size_t>(it - edits.begin()) - edit_i >= context) {
+          // There is no next edit or it is too far away.
+          break;
+        }
+      }
+
+      EditType edit = edits[edit_i];
+      // Reset count when a non match is found.
+      n_suffix = edit == kMatch ? n_suffix + 1 : 0;
+
+      if (edit == kMatch || edit == kRemove || edit == kReplace) {
+        hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str());
+      }
+      if (edit == kAdd || edit == kReplace) {
+        hunk.PushLine('+', right[r_i].c_str());
+      }
+
+      // Advance indices, depending on edit type.
+      l_i += edit != kAdd;
+      r_i += edit != kRemove;
+    }
+
+    if (!hunk.has_edits()) {
+      // We are done. We don't want this hunk.
+      break;
+    }
+
+    hunk.PrintTo(&ss);
+  }
+  return ss.str();
+}
+
+}  // namespace edit_distance
+
+namespace {
+
+// The string representation of the values received in EqFailure() are already
+// escaped. Split them on escaped '\n' boundaries. Leave all other escaped
+// characters the same.
+std::vector<std::string> SplitEscapedString(const std::string& str) {
+  std::vector<std::string> lines;
+  size_t start = 0, end = str.size();
+  if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
+    ++start;
+    --end;
+  }
+  bool escaped = false;
+  for (size_t i = start; i + 1 < end; ++i) {
+    if (escaped) {
+      escaped = false;
+      if (str[i] == 'n') {
+        lines.push_back(str.substr(start, i - start - 1));
+        start = i + 1;
+      }
+    } else {
+      escaped = str[i] == '\\';
+    }
+  }
+  lines.push_back(str.substr(start, end - start));
+  return lines;
+}
+
+}  // namespace
+
+// Constructs and returns the message for an equality assertion
+// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
+//
+// The first four parameters are the expressions used in the assertion
+// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
+// where foo is 5 and bar is 6, we have:
+//
+//   lhs_expression: "foo"
+//   rhs_expression: "bar"
+//   lhs_value:      "5"
+//   rhs_value:      "6"
+//
+// The ignoring_case parameter is true if and only if the assertion is a
+// *_STRCASEEQ*.  When it's true, the string "Ignoring case" will
+// be inserted into the message.
+AssertionResult EqFailure(const char* lhs_expression,
+                          const char* rhs_expression,
+                          const std::string& lhs_value,
+                          const std::string& rhs_value,
+                          bool ignoring_case) {
+  Message msg;
+  msg << "Expected equality of these values:";
+  msg << "\n  " << lhs_expression;
+  if (lhs_value != lhs_expression) {
+    msg << "\n    Which is: " << lhs_value;
+  }
+  msg << "\n  " << rhs_expression;
+  if (rhs_value != rhs_expression) {
+    msg << "\n    Which is: " << rhs_value;
+  }
+
+  if (ignoring_case) {
+    msg << "\nIgnoring case";
+  }
+
+  if (!lhs_value.empty() && !rhs_value.empty()) {
+    const std::vector<std::string> lhs_lines =
+        SplitEscapedString(lhs_value);
+    const std::vector<std::string> rhs_lines =
+        SplitEscapedString(rhs_value);
+    if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
+      msg << "\nWith diff:\n"
+          << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
+    }
+  }
+
+  return AssertionFailure() << msg;
+}
+
+// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
+std::string GetBoolAssertionFailureMessage(
+    const AssertionResult& assertion_result,
+    const char* expression_text,
+    const char* actual_predicate_value,
+    const char* expected_predicate_value) {
+  const char* actual_message = assertion_result.message();
+  Message msg;
+  msg << "Value of: " << expression_text
+      << "\n  Actual: " << actual_predicate_value;
+  if (actual_message[0] != '\0')
+    msg << " (" << actual_message << ")";
+  msg << "\nExpected: " << expected_predicate_value;
+  return msg.GetString();
+}
+
+// Helper function for implementing ASSERT_NEAR.
+AssertionResult DoubleNearPredFormat(const char* expr1,
+                                     const char* expr2,
+                                     const char* abs_error_expr,
+                                     double val1,
+                                     double val2,
+                                     double abs_error) {
+  const double diff = fabs(val1 - val2);
+  if (diff <= abs_error) return AssertionSuccess();
+
+  // Find the value which is closest to zero.
+  const double min_abs = std::min(fabs(val1), fabs(val2));
+  // Find the distance to the next double from that value.
+  const double epsilon =
+      nextafter(min_abs, std::numeric_limits<double>::infinity()) - min_abs;
+  // Detect the case where abs_error is so small that EXPECT_NEAR is
+  // effectively the same as EXPECT_EQUAL, and give an informative error
+  // message so that the situation can be more easily understood without
+  // requiring exotic floating-point knowledge.
+  // Don't do an epsilon check if abs_error is zero because that implies
+  // that an equality check was actually intended.
+  if (!(std::isnan)(val1) && !(std::isnan)(val2) && abs_error > 0 &&
+      abs_error < epsilon) {
+    return AssertionFailure()
+           << "The difference between " << expr1 << " and " << expr2 << " is "
+           << diff << ", where\n"
+           << expr1 << " evaluates to " << val1 << ",\n"
+           << expr2 << " evaluates to " << val2 << ".\nThe abs_error parameter "
+           << abs_error_expr << " evaluates to " << abs_error
+           << " which is smaller than the minimum distance between doubles for "
+              "numbers of this magnitude which is "
+           << epsilon
+           << ", thus making this EXPECT_NEAR check equivalent to "
+              "EXPECT_EQUAL. Consider using EXPECT_DOUBLE_EQ instead.";
+  }
+  return AssertionFailure()
+      << "The difference between " << expr1 << " and " << expr2
+      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
+      << expr1 << " evaluates to " << val1 << ",\n"
+      << expr2 << " evaluates to " << val2 << ", and\n"
+      << abs_error_expr << " evaluates to " << abs_error << ".";
+}
+
+
+// Helper template for implementing FloatLE() and DoubleLE().
+template <typename RawType>
+AssertionResult FloatingPointLE(const char* expr1,
+                                const char* expr2,
+                                RawType val1,
+                                RawType val2) {
+  // Returns success if val1 is less than val2,
+  if (val1 < val2) {
+    return AssertionSuccess();
+  }
+
+  // or if val1 is almost equal to val2.
+  const FloatingPoint<RawType> lhs(val1), rhs(val2);
+  if (lhs.AlmostEquals(rhs)) {
+    return AssertionSuccess();
+  }
+
+  // Note that the above two checks will both fail if either val1 or
+  // val2 is NaN, as the IEEE floating-point standard requires that
+  // any predicate involving a NaN must return false.
+
+  ::std::stringstream val1_ss;
+  val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+          << val1;
+
+  ::std::stringstream val2_ss;
+  val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+          << val2;
+
+  return AssertionFailure()
+      << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
+      << "  Actual: " << StringStreamToString(&val1_ss) << " vs "
+      << StringStreamToString(&val2_ss);
+}
+
+}  // namespace internal
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+AssertionResult FloatLE(const char* expr1, const char* expr2,
+                        float val1, float val2) {
+  return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
+}
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+AssertionResult DoubleLE(const char* expr1, const char* expr2,
+                         double val1, double val2) {
+  return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
+}
+
+namespace internal {
+
+// The helper function for {ASSERT|EXPECT}_STREQ.
+AssertionResult CmpHelperSTREQ(const char* lhs_expression,
+                               const char* rhs_expression,
+                               const char* lhs,
+                               const char* rhs) {
+  if (String::CStringEquals(lhs, rhs)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   PrintToString(lhs),
+                   PrintToString(rhs),
+                   false);
+}
+
+// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
+AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
+                                   const char* rhs_expression,
+                                   const char* lhs,
+                                   const char* rhs) {
+  if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   PrintToString(lhs),
+                   PrintToString(rhs),
+                   true);
+}
+
+// The helper function for {ASSERT|EXPECT}_STRNE.
+AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                               const char* s2_expression,
+                               const char* s1,
+                               const char* s2) {
+  if (!String::CStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  } else {
+    return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
+                              << s2_expression << "), actual: \""
+                              << s1 << "\" vs \"" << s2 << "\"";
+  }
+}
+
+// The helper function for {ASSERT|EXPECT}_STRCASENE.
+AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
+                                   const char* s2_expression,
+                                   const char* s1,
+                                   const char* s2) {
+  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  } else {
+    return AssertionFailure()
+        << "Expected: (" << s1_expression << ") != ("
+        << s2_expression << ") (ignoring case), actual: \""
+        << s1 << "\" vs \"" << s2 << "\"";
+  }
+}
+
+}  // namespace internal
+
+namespace {
+
+// Helper functions for implementing IsSubString() and IsNotSubstring().
+
+// This group of overloaded functions return true if and only if needle
+// is a substring of haystack.  NULL is considered a substring of
+// itself only.
+
+bool IsSubstringPred(const char* needle, const char* haystack) {
+  if (needle == nullptr || haystack == nullptr) return needle == haystack;
+
+  return strstr(haystack, needle) != nullptr;
+}
+
+bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
+  if (needle == nullptr || haystack == nullptr) return needle == haystack;
+
+  return wcsstr(haystack, needle) != nullptr;
+}
+
+// StringType here can be either ::std::string or ::std::wstring.
+template <typename StringType>
+bool IsSubstringPred(const StringType& needle,
+                     const StringType& haystack) {
+  return haystack.find(needle) != StringType::npos;
+}
+
+// This function implements either IsSubstring() or IsNotSubstring(),
+// depending on the value of the expected_to_be_substring parameter.
+// StringType here can be const char*, const wchar_t*, ::std::string,
+// or ::std::wstring.
+template <typename StringType>
+AssertionResult IsSubstringImpl(
+    bool expected_to_be_substring,
+    const char* needle_expr, const char* haystack_expr,
+    const StringType& needle, const StringType& haystack) {
+  if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
+    return AssertionSuccess();
+
+  const bool is_wide_string = sizeof(needle[0]) > 1;
+  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
+  return AssertionFailure()
+      << "Value of: " << needle_expr << "\n"
+      << "  Actual: " << begin_string_quote << needle << "\"\n"
+      << "Expected: " << (expected_to_be_substring ? "" : "not ")
+      << "a substring of " << haystack_expr << "\n"
+      << "Which is: " << begin_string_quote << haystack << "\"";
+}
+
+}  // namespace
+
+// IsSubstring() and IsNotSubstring() check whether needle is a
+// substring of haystack (NULL is considered a substring of itself
+// only), and return an appropriate error message when they fail.
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+#if GTEST_HAS_STD_WSTRING
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+namespace internal {
+
+#if GTEST_OS_WINDOWS
+
+namespace {
+
+// Helper function for IsHRESULT{SuccessFailure} predicates
+AssertionResult HRESULTFailureHelper(const char* expr,
+                                     const char* expected,
+                                     long hr) {  // NOLINT
+# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_TV_TITLE
+
+  // Windows CE doesn't support FormatMessage.
+  const char error_text[] = "";
+
+# else
+
+  // Looks up the human-readable system message for the HRESULT code
+  // and since we're not passing any params to FormatMessage, we don't
+  // want inserts expanded.
+  const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
+                       FORMAT_MESSAGE_IGNORE_INSERTS;
+  const DWORD kBufSize = 4096;
+  // Gets the system's human readable message string for this HRESULT.
+  char error_text[kBufSize] = { '\0' };
+  DWORD message_length = ::FormatMessageA(kFlags,
+                                          0,   // no source, we're asking system
+                                          static_cast<DWORD>(hr),  // the error
+                                          0,   // no line width restrictions
+                                          error_text,  // output buffer
+                                          kBufSize,    // buf size
+                                          nullptr);  // no arguments for inserts
+  // Trims tailing white space (FormatMessage leaves a trailing CR-LF)
+  for (; message_length && IsSpace(error_text[message_length - 1]);
+          --message_length) {
+    error_text[message_length - 1] = '\0';
+  }
+
+# endif  // GTEST_OS_WINDOWS_MOBILE
+
+  const std::string error_hex("0x" + String::FormatHexInt(hr));
+  return ::testing::AssertionFailure()
+      << "Expected: " << expr << " " << expected << ".\n"
+      << "  Actual: " << error_hex << " " << error_text << "\n";
+}
+
+}  // namespace
+
+AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
+  if (SUCCEEDED(hr)) {
+    return AssertionSuccess();
+  }
+  return HRESULTFailureHelper(expr, "succeeds", hr);
+}
+
+AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
+  if (FAILED(hr)) {
+    return AssertionSuccess();
+  }
+  return HRESULTFailureHelper(expr, "fails", hr);
+}
+
+#endif  // GTEST_OS_WINDOWS
+
+// Utility functions for encoding Unicode text (wide strings) in
+// UTF-8.
+
+// A Unicode code-point can have up to 21 bits, and is encoded in UTF-8
+// like this:
+//
+// Code-point length   Encoding
+//   0 -  7 bits       0xxxxxxx
+//   8 - 11 bits       110xxxxx 10xxxxxx
+//  12 - 16 bits       1110xxxx 10xxxxxx 10xxxxxx
+//  17 - 21 bits       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+
+// The maximum code-point a one-byte UTF-8 sequence can represent.
+constexpr uint32_t kMaxCodePoint1 = (static_cast<uint32_t>(1) <<  7) - 1;
+
+// The maximum code-point a two-byte UTF-8 sequence can represent.
+constexpr uint32_t kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1;
+
+// The maximum code-point a three-byte UTF-8 sequence can represent.
+constexpr uint32_t kMaxCodePoint3 = (static_cast<uint32_t>(1) << (4 + 2*6)) - 1;
+
+// The maximum code-point a four-byte UTF-8 sequence can represent.
+constexpr uint32_t kMaxCodePoint4 = (static_cast<uint32_t>(1) << (3 + 3*6)) - 1;
+
+// Chops off the n lowest bits from a bit pattern.  Returns the n
+// lowest bits.  As a side effect, the original bit pattern will be
+// shifted to the right by n bits.
+inline uint32_t ChopLowBits(uint32_t* bits, int n) {
+  const uint32_t low_bits = *bits & ((static_cast<uint32_t>(1) << n) - 1);
+  *bits >>= n;
+  return low_bits;
+}
+
+// Converts a Unicode code point to a narrow string in UTF-8 encoding.
+// code_point parameter is of type uint32_t because wchar_t may not be
+// wide enough to contain a code point.
+// If the code_point is not a valid Unicode code point
+// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
+// to "(Invalid Unicode 0xXXXXXXXX)".
+std::string CodePointToUtf8(uint32_t code_point) {
+  if (code_point > kMaxCodePoint4) {
+    return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) + ")";
+  }
+
+  char str[5];  // Big enough for the largest valid code point.
+  if (code_point <= kMaxCodePoint1) {
+    str[1] = '\0';
+    str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
+  } else if (code_point <= kMaxCodePoint2) {
+    str[2] = '\0';
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xC0 | code_point);                   // 110xxxxx
+  } else if (code_point <= kMaxCodePoint3) {
+    str[3] = '\0';
+    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
+  } else {  // code_point <= kMaxCodePoint4
+    str[4] = '\0';
+    str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
+  }
+  return str;
+}
+
+// The following two functions only make sense if the system
+// uses UTF-16 for wide string encoding. All supported systems
+// with 16 bit wchar_t (Windows, Cygwin) do use UTF-16.
+
+// Determines if the arguments constitute UTF-16 surrogate pair
+// and thus should be combined into a single Unicode code point
+// using CreateCodePointFromUtf16SurrogatePair.
+inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
+  return sizeof(wchar_t) == 2 &&
+      (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
+}
+
+// Creates a Unicode code point from UTF16 surrogate pair.
+inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
+                                                      wchar_t second) {
+  const auto first_u = static_cast<uint32_t>(first);
+  const auto second_u = static_cast<uint32_t>(second);
+  const uint32_t mask = (1 << 10) - 1;
+  return (sizeof(wchar_t) == 2)
+             ? (((first_u & mask) << 10) | (second_u & mask)) + 0x10000
+             :
+             // This function should not be called when the condition is
+             // false, but we provide a sensible default in case it is.
+             first_u;
+}
+
+// Converts a wide string to a narrow string in UTF-8 encoding.
+// The wide string is assumed to have the following encoding:
+//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
+//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
+// Parameter str points to a null-terminated wide string.
+// Parameter num_chars may additionally limit the number
+// of wchar_t characters processed. -1 is used when the entire string
+// should be processed.
+// If the string contains code points that are not valid Unicode code points
+// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
+// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
+// and contains invalid UTF-16 surrogate pairs, values in those pairs
+// will be encoded as individual Unicode characters from Basic Normal Plane.
+std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
+  if (num_chars == -1)
+    num_chars = static_cast<int>(wcslen(str));
+
+  ::std::stringstream stream;
+  for (int i = 0; i < num_chars; ++i) {
+    uint32_t unicode_code_point;
+
+    if (str[i] == L'\0') {
+      break;
+    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
+      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
+                                                                 str[i + 1]);
+      i++;
+    } else {
+      unicode_code_point = static_cast<uint32_t>(str[i]);
+    }
+
+    stream << CodePointToUtf8(unicode_code_point);
+  }
+  return StringStreamToString(&stream);
+}
+
+// Converts a wide C string to an std::string using the UTF-8 encoding.
+// NULL will be converted to "(null)".
+std::string String::ShowWideCString(const wchar_t * wide_c_str) {
+  if (wide_c_str == nullptr) return "(null)";
+
+  return internal::WideStringToUtf8(wide_c_str, -1);
+}
+
+// Compares two wide C strings.  Returns true if and only if they have the
+// same content.
+//
+// Unlike wcscmp(), this function can handle NULL argument(s).  A NULL
+// C string is considered different to any non-NULL C string,
+// including the empty string.
+bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
+  if (lhs == nullptr) return rhs == nullptr;
+
+  if (rhs == nullptr) return false;
+
+  return wcscmp(lhs, rhs) == 0;
+}
+
+// Helper function for *_STREQ on wide strings.
+AssertionResult CmpHelperSTREQ(const char* lhs_expression,
+                               const char* rhs_expression,
+                               const wchar_t* lhs,
+                               const wchar_t* rhs) {
+  if (String::WideCStringEquals(lhs, rhs)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   PrintToString(lhs),
+                   PrintToString(rhs),
+                   false);
+}
+
+// Helper function for *_STRNE on wide strings.
+AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                               const char* s2_expression,
+                               const wchar_t* s1,
+                               const wchar_t* s2) {
+  if (!String::WideCStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  }
+
+  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
+                            << s2_expression << "), actual: "
+                            << PrintToString(s1)
+                            << " vs " << PrintToString(s2);
+}
+
+// Compares two C strings, ignoring case.  Returns true if and only if they have
+// the same content.
+//
+// Unlike strcasecmp(), this function can handle NULL argument(s).  A
+// NULL C string is considered different to any non-NULL C string,
+// including the empty string.
+bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
+  if (lhs == nullptr) return rhs == nullptr;
+  if (rhs == nullptr) return false;
+  return posix::StrCaseCmp(lhs, rhs) == 0;
+}
+
+// Compares two wide C strings, ignoring case.  Returns true if and only if they
+// have the same content.
+//
+// Unlike wcscasecmp(), this function can handle NULL argument(s).
+// A NULL C string is considered different to any non-NULL wide C string,
+// including the empty string.
+// NB: The implementations on different platforms slightly differ.
+// On windows, this method uses _wcsicmp which compares according to LC_CTYPE
+// environment variable. On GNU platform this method uses wcscasecmp
+// which compares according to LC_CTYPE category of the current locale.
+// On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
+// current locale.
+bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
+                                              const wchar_t* rhs) {
+  if (lhs == nullptr) return rhs == nullptr;
+
+  if (rhs == nullptr) return false;
+
+#if GTEST_OS_WINDOWS
+  return _wcsicmp(lhs, rhs) == 0;
+#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
+  return wcscasecmp(lhs, rhs) == 0;
+#else
+  // Android, Mac OS X and Cygwin don't define wcscasecmp.
+  // Other unknown OSes may not define it either.
+  wint_t left, right;
+  do {
+    left = towlower(static_cast<wint_t>(*lhs++));
+    right = towlower(static_cast<wint_t>(*rhs++));
+  } while (left && left == right);
+  return left == right;
+#endif  // OS selector
+}
+
+// Returns true if and only if str ends with the given suffix, ignoring case.
+// Any string is considered to end with an empty suffix.
+bool String::EndsWithCaseInsensitive(
+    const std::string& str, const std::string& suffix) {
+  const size_t str_len = str.length();
+  const size_t suffix_len = suffix.length();
+  return (str_len >= suffix_len) &&
+         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
+                                      suffix.c_str());
+}
+
+// Formats an int value as "%02d".
+std::string String::FormatIntWidth2(int value) {
+  return FormatIntWidthN(value, 2);
+}
+
+// Formats an int value to given width with leading zeros.
+std::string String::FormatIntWidthN(int value, int width) {
+  std::stringstream ss;
+  ss << std::setfill('0') << std::setw(width) << value;
+  return ss.str();
+}
+
+// Formats an int value as "%X".
+std::string String::FormatHexUInt32(uint32_t value) {
+  std::stringstream ss;
+  ss << std::hex << std::uppercase << value;
+  return ss.str();
+}
+
+// Formats an int value as "%X".
+std::string String::FormatHexInt(int value) {
+  return FormatHexUInt32(static_cast<uint32_t>(value));
+}
+
+// Formats a byte as "%02X".
+std::string String::FormatByte(unsigned char value) {
+  std::stringstream ss;
+  ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
+     << static_cast<unsigned int>(value);
+  return ss.str();
+}
+
+// Converts the buffer in a stringstream to an std::string, converting NUL
+// bytes to "\\0" along the way.
+std::string StringStreamToString(::std::stringstream* ss) {
+  const ::std::string& str = ss->str();
+  const char* const start = str.c_str();
+  const char* const end = start + str.length();
+
+  std::string result;
+  result.reserve(static_cast<size_t>(2 * (end - start)));
+  for (const char* ch = start; ch != end; ++ch) {
+    if (*ch == '\0') {
+      result += "\\0";  // Replaces NUL with "\\0";
+    } else {
+      result += *ch;
+    }
+  }
+
+  return result;
+}
+
+// Appends the user-supplied message to the Google-Test-generated message.
+std::string AppendUserMessage(const std::string& gtest_msg,
+                              const Message& user_msg) {
+  // Appends the user message if it's non-empty.
+  const std::string user_msg_string = user_msg.GetString();
+  if (user_msg_string.empty()) {
+    return gtest_msg;
+  }
+  if (gtest_msg.empty()) {
+    return user_msg_string;
+  }
+  return gtest_msg + "\n" + user_msg_string;
+}
+
+}  // namespace internal
+
+// class TestResult
+
+// Creates an empty TestResult.
+TestResult::TestResult()
+    : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}
+
+// D'tor.
+TestResult::~TestResult() {
+}
+
+// Returns the i-th test part result among all the results. i can
+// range from 0 to total_part_count() - 1. If i is not in that range,
+// aborts the program.
+const TestPartResult& TestResult::GetTestPartResult(int i) const {
+  if (i < 0 || i >= total_part_count())
+    internal::posix::Abort();
+  return test_part_results_.at(static_cast<size_t>(i));
+}
+
+// Returns the i-th test property. i can range from 0 to
+// test_property_count() - 1. If i is not in that range, aborts the
+// program.
+const TestProperty& TestResult::GetTestProperty(int i) const {
+  if (i < 0 || i >= test_property_count())
+    internal::posix::Abort();
+  return test_properties_.at(static_cast<size_t>(i));
+}
+
+// Clears the test part results.
+void TestResult::ClearTestPartResults() {
+  test_part_results_.clear();
+}
+
+// Adds a test part result to the list.
+void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
+  test_part_results_.push_back(test_part_result);
+}
+
+// Adds a test property to the list. If a property with the same key as the
+// supplied property is already represented, the value of this test_property
+// replaces the old value for that key.
+void TestResult::RecordProperty(const std::string& xml_element,
+                                const TestProperty& test_property) {
+  if (!ValidateTestProperty(xml_element, test_property)) {
+    return;
+  }
+  internal::MutexLock lock(&test_properties_mutex_);
+  const std::vector<TestProperty>::iterator property_with_matching_key =
+      std::find_if(test_properties_.begin(), test_properties_.end(),
+                   internal::TestPropertyKeyIs(test_property.key()));
+  if (property_with_matching_key == test_properties_.end()) {
+    test_properties_.push_back(test_property);
+    return;
+  }
+  property_with_matching_key->SetValue(test_property.value());
+}
+
+// The list of reserved attributes used in the <testsuites> element of XML
+// output.
+static const char* const kReservedTestSuitesAttributes[] = {
+  "disabled",
+  "errors",
+  "failures",
+  "name",
+  "random_seed",
+  "tests",
+  "time",
+  "timestamp"
+};
+
+// The list of reserved attributes used in the <testsuite> element of XML
+// output.
+static const char* const kReservedTestSuiteAttributes[] = {
+    "disabled", "errors", "failures",  "name",
+    "tests",    "time",   "timestamp", "skipped"};
+
+// The list of reserved attributes used in the <testcase> element of XML output.
+static const char* const kReservedTestCaseAttributes[] = {
+    "classname",   "name", "status", "time",  "type_param",
+    "value_param", "file", "line"};
+
+// Use a slightly different set for allowed output to ensure existing tests can
+// still RecordProperty("result") or "RecordProperty(timestamp")
+static const char* const kReservedOutputTestCaseAttributes[] = {
+    "classname",   "name", "status", "time",   "type_param",
+    "value_param", "file", "line",   "result", "timestamp"};
+
+template <size_t kSize>
+std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
+  return std::vector<std::string>(array, array + kSize);
+}
+
+static std::vector<std::string> GetReservedAttributesForElement(
+    const std::string& xml_element) {
+  if (xml_element == "testsuites") {
+    return ArrayAsVector(kReservedTestSuitesAttributes);
+  } else if (xml_element == "testsuite") {
+    return ArrayAsVector(kReservedTestSuiteAttributes);
+  } else if (xml_element == "testcase") {
+    return ArrayAsVector(kReservedTestCaseAttributes);
+  } else {
+    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
+  }
+  // This code is unreachable but some compilers may not realizes that.
+  return std::vector<std::string>();
+}
+
+// TODO(jdesprez): Merge the two getReserved attributes once skip is improved
+static std::vector<std::string> GetReservedOutputAttributesForElement(
+    const std::string& xml_element) {
+  if (xml_element == "testsuites") {
+    return ArrayAsVector(kReservedTestSuitesAttributes);
+  } else if (xml_element == "testsuite") {
+    return ArrayAsVector(kReservedTestSuiteAttributes);
+  } else if (xml_element == "testcase") {
+    return ArrayAsVector(kReservedOutputTestCaseAttributes);
+  } else {
+    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
+  }
+  // This code is unreachable but some compilers may not realizes that.
+  return std::vector<std::string>();
+}
+
+static std::string FormatWordList(const std::vector<std::string>& words) {
+  Message word_list;
+  for (size_t i = 0; i < words.size(); ++i) {
+    if (i > 0 && words.size() > 2) {
+      word_list << ", ";
+    }
+    if (i == words.size() - 1) {
+      word_list << "and ";
+    }
+    word_list << "'" << words[i] << "'";
+  }
+  return word_list.GetString();
+}
+
+static bool ValidateTestPropertyName(
+    const std::string& property_name,
+    const std::vector<std::string>& reserved_names) {
+  if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
+          reserved_names.end()) {
+    ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
+                  << " (" << FormatWordList(reserved_names)
+                  << " are reserved by " << GTEST_NAME_ << ")";
+    return false;
+  }
+  return true;
+}
+
+// Adds a failure if the key is a reserved attribute of the element named
+// xml_element.  Returns true if the property is valid.
+bool TestResult::ValidateTestProperty(const std::string& xml_element,
+                                      const TestProperty& test_property) {
+  return ValidateTestPropertyName(test_property.key(),
+                                  GetReservedAttributesForElement(xml_element));
+}
+
+// Clears the object.
+void TestResult::Clear() {
+  test_part_results_.clear();
+  test_properties_.clear();
+  death_test_count_ = 0;
+  elapsed_time_ = 0;
+}
+
+// Returns true off the test part was skipped.
+static bool TestPartSkipped(const TestPartResult& result) {
+  return result.skipped();
+}
+
+// Returns true if and only if the test was skipped.
+bool TestResult::Skipped() const {
+  return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
+}
+
+// Returns true if and only if the test failed.
+bool TestResult::Failed() const {
+  for (int i = 0; i < total_part_count(); ++i) {
+    if (GetTestPartResult(i).failed())
+      return true;
+  }
+  return false;
+}
+
+// Returns true if and only if the test part fatally failed.
+static bool TestPartFatallyFailed(const TestPartResult& result) {
+  return result.fatally_failed();
+}
+
+// Returns true if and only if the test fatally failed.
+bool TestResult::HasFatalFailure() const {
+  return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
+}
+
+// Returns true if and only if the test part non-fatally failed.
+static bool TestPartNonfatallyFailed(const TestPartResult& result) {
+  return result.nonfatally_failed();
+}
+
+// Returns true if and only if the test has a non-fatal failure.
+bool TestResult::HasNonfatalFailure() const {
+  return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
+}
+
+// Gets the number of all test parts.  This is the sum of the number
+// of successful test parts and the number of failed test parts.
+int TestResult::total_part_count() const {
+  return static_cast<int>(test_part_results_.size());
+}
+
+// Returns the number of the test properties.
+int TestResult::test_property_count() const {
+  return static_cast<int>(test_properties_.size());
+}
+
+// class Test
+
+// Creates a Test object.
+
+// The c'tor saves the states of all flags.
+Test::Test()
+    : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {
+}
+
+// The d'tor restores the states of all flags.  The actual work is
+// done by the d'tor of the gtest_flag_saver_ field, and thus not
+// visible here.
+Test::~Test() {
+}
+
+// Sets up the test fixture.
+//
+// A sub-class may override this.
+void Test::SetUp() {
+}
+
+// Tears down the test fixture.
+//
+// A sub-class may override this.
+void Test::TearDown() {
+}
+
+// Allows user supplied key value pairs to be recorded for later output.
+void Test::RecordProperty(const std::string& key, const std::string& value) {
+  UnitTest::GetInstance()->RecordProperty(key, value);
+}
+
+// Allows user supplied key value pairs to be recorded for later output.
+void Test::RecordProperty(const std::string& key, int value) {
+  Message value_message;
+  value_message << value;
+  RecordProperty(key, value_message.GetString().c_str());
+}
+
+namespace internal {
+
+void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
+                                    const std::string& message) {
+  // This function is a friend of UnitTest and as such has access to
+  // AddTestPartResult.
+  UnitTest::GetInstance()->AddTestPartResult(
+      result_type,
+      nullptr,  // No info about the source file where the exception occurred.
+      -1,       // We have no info on which line caused the exception.
+      message,
+      "");  // No stack trace, either.
+}
+
+}  // namespace internal
+
+// Google Test requires all tests in the same test suite to use the same test
+// fixture class.  This function checks if the current test has the
+// same fixture class as the first test in the current test suite.  If
+// yes, it returns true; otherwise it generates a Google Test failure and
+// returns false.
+bool Test::HasSameFixtureClass() {
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  const TestSuite* const test_suite = impl->current_test_suite();
+
+  // Info about the first test in the current test suite.
+  const TestInfo* const first_test_info = test_suite->test_info_list()[0];
+  const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
+  const char* const first_test_name = first_test_info->name();
+
+  // Info about the current test.
+  const TestInfo* const this_test_info = impl->current_test_info();
+  const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
+  const char* const this_test_name = this_test_info->name();
+
+  if (this_fixture_id != first_fixture_id) {
+    // Is the first test defined using TEST?
+    const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
+    // Is this test defined using TEST?
+    const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
+
+    if (first_is_TEST || this_is_TEST) {
+      // Both TEST and TEST_F appear in same test suite, which is incorrect.
+      // Tell the user how to fix this.
+
+      // Gets the name of the TEST and the name of the TEST_F.  Note
+      // that first_is_TEST and this_is_TEST cannot both be true, as
+      // the fixture IDs are different for the two tests.
+      const char* const TEST_name =
+          first_is_TEST ? first_test_name : this_test_name;
+      const char* const TEST_F_name =
+          first_is_TEST ? this_test_name : first_test_name;
+
+      ADD_FAILURE()
+          << "All tests in the same test suite must use the same test fixture\n"
+          << "class, so mixing TEST_F and TEST in the same test suite is\n"
+          << "illegal.  In test suite " << this_test_info->test_suite_name()
+          << ",\n"
+          << "test " << TEST_F_name << " is defined using TEST_F but\n"
+          << "test " << TEST_name << " is defined using TEST.  You probably\n"
+          << "want to change the TEST to TEST_F or move it to another test\n"
+          << "case.";
+    } else {
+      // Two fixture classes with the same name appear in two different
+      // namespaces, which is not allowed. Tell the user how to fix this.
+      ADD_FAILURE()
+          << "All tests in the same test suite must use the same test fixture\n"
+          << "class.  However, in test suite "
+          << this_test_info->test_suite_name() << ",\n"
+          << "you defined test " << first_test_name << " and test "
+          << this_test_name << "\n"
+          << "using two different test fixture classes.  This can happen if\n"
+          << "the two classes are from different namespaces or translation\n"
+          << "units and have the same name.  You should probably rename one\n"
+          << "of the classes to put the tests into different test suites.";
+    }
+    return false;
+  }
+
+  return true;
+}
+
+#if GTEST_HAS_SEH
+
+// Adds an "exception thrown" fatal failure to the current test.  This
+// function returns its result via an output parameter pointer because VC++
+// prohibits creation of objects with destructors on stack in functions
+// using __try (see error C2712).
+static std::string* FormatSehExceptionMessage(DWORD exception_code,
+                                              const char* location) {
+  Message message;
+  message << "SEH exception with code 0x" << std::setbase(16) <<
+    exception_code << std::setbase(10) << " thrown in " << location << ".";
+
+  return new std::string(message.GetString());
+}
+
+#endif  // GTEST_HAS_SEH
+
+namespace internal {
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Adds an "exception thrown" fatal failure to the current test.
+static std::string FormatCxxExceptionMessage(const char* description,
+                                             const char* location) {
+  Message message;
+  if (description != nullptr) {
+    message << "C++ exception with description \"" << description << "\"";
+  } else {
+    message << "Unknown C++ exception";
+  }
+  message << " thrown in " << location << ".";
+
+  return message.GetString();
+}
+
+static std::string PrintTestPartResultToString(
+    const TestPartResult& test_part_result);
+
+GoogleTestFailureException::GoogleTestFailureException(
+    const TestPartResult& failure)
+    : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// We put these helper functions in the internal namespace as IBM's xlC
+// compiler rejects the code if they were declared static.
+
+// Runs the given method and handles SEH exceptions it throws, when
+// SEH is supported; returns the 0-value for type Result in case of an
+// SEH exception.  (Microsoft compilers cannot handle SEH and C++
+// exceptions in the same function.  Therefore, we provide a separate
+// wrapper function for handling SEH exceptions.)
+template <class T, typename Result>
+Result HandleSehExceptionsInMethodIfSupported(
+    T* object, Result (T::*method)(), const char* location) {
+#if GTEST_HAS_SEH
+  __try {
+    return (object->*method)();
+  } __except (internal::UnitTestOptions::GTestShouldProcessSEH(  // NOLINT
+      GetExceptionCode())) {
+    // We create the exception message on the heap because VC++ prohibits
+    // creation of objects with destructors on stack in functions using __try
+    // (see error C2712).
+    std::string* exception_message = FormatSehExceptionMessage(
+        GetExceptionCode(), location);
+    internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
+                                             *exception_message);
+    delete exception_message;
+    return static_cast<Result>(0);
+  }
+#else
+  (void)location;
+  return (object->*method)();
+#endif  // GTEST_HAS_SEH
+}
+
+// Runs the given method and catches and reports C++ and/or SEH-style
+// exceptions, if they are supported; returns the 0-value for type
+// Result in case of an SEH exception.
+template <class T, typename Result>
+Result HandleExceptionsInMethodIfSupported(
+    T* object, Result (T::*method)(), const char* location) {
+  // NOTE: The user code can affect the way in which Google Test handles
+  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
+  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
+  // after the exception is caught and either report or re-throw the
+  // exception based on the flag's value:
+  //
+  // try {
+  //   // Perform the test method.
+  // } catch (...) {
+  //   if (GTEST_FLAG(catch_exceptions))
+  //     // Report the exception as failure.
+  //   else
+  //     throw;  // Re-throws the original exception.
+  // }
+  //
+  // However, the purpose of this flag is to allow the program to drop into
+  // the debugger when the exception is thrown. On most platforms, once the
+  // control enters the catch block, the exception origin information is
+  // lost and the debugger will stop the program at the point of the
+  // re-throw in this function -- instead of at the point of the original
+  // throw statement in the code under test.  For this reason, we perform
+  // the check early, sacrificing the ability to affect Google Test's
+  // exception handling in the method where the exception is thrown.
+  if (internal::GetUnitTestImpl()->catch_exceptions()) {
+#if GTEST_HAS_EXCEPTIONS
+    try {
+      return HandleSehExceptionsInMethodIfSupported(object, method, location);
+    } catch (const AssertionException&) {  // NOLINT
+      // This failure was reported already.
+    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
+      // This exception type can only be thrown by a failed Google
+      // Test assertion with the intention of letting another testing
+      // framework catch it.  Therefore we just re-throw it.
+      throw;
+    } catch (const std::exception& e) {  // NOLINT
+      internal::ReportFailureInUnknownLocation(
+          TestPartResult::kFatalFailure,
+          FormatCxxExceptionMessage(e.what(), location));
+    } catch (...) {  // NOLINT
+      internal::ReportFailureInUnknownLocation(
+          TestPartResult::kFatalFailure,
+          FormatCxxExceptionMessage(nullptr, location));
+    }
+    return static_cast<Result>(0);
+#else
+    return HandleSehExceptionsInMethodIfSupported(object, method, location);
+#endif  // GTEST_HAS_EXCEPTIONS
+  } else {
+    return (object->*method)();
+  }
+}
+
+}  // namespace internal
+
+// Runs the test and updates the test result.
+void Test::Run() {
+  if (!HasSameFixtureClass()) return;
+
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
+  // We will run the test only if SetUp() was successful and didn't call
+  // GTEST_SKIP().
+  if (!HasFatalFailure() && !IsSkipped()) {
+    impl->os_stack_trace_getter()->UponLeavingGTest();
+    internal::HandleExceptionsInMethodIfSupported(
+        this, &Test::TestBody, "the test body");
+  }
+
+  // However, we want to clean up as much as possible.  Hence we will
+  // always call TearDown(), even if SetUp() or the test body has
+  // failed.
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      this, &Test::TearDown, "TearDown()");
+}
+
+// Returns true if and only if the current test has a fatal failure.
+bool Test::HasFatalFailure() {
+  return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
+}
+
+// Returns true if and only if the current test has a non-fatal failure.
+bool Test::HasNonfatalFailure() {
+  return internal::GetUnitTestImpl()->current_test_result()->
+      HasNonfatalFailure();
+}
+
+// Returns true if and only if the current test was skipped.
+bool Test::IsSkipped() {
+  return internal::GetUnitTestImpl()->current_test_result()->Skipped();
+}
+
+// class TestInfo
+
+// Constructs a TestInfo object. It assumes ownership of the test factory
+// object.
+TestInfo::TestInfo(const std::string& a_test_suite_name,
+                   const std::string& a_name, const char* a_type_param,
+                   const char* a_value_param,
+                   internal::CodeLocation a_code_location,
+                   internal::TypeId fixture_class_id,
+                   internal::TestFactoryBase* factory)
+    : test_suite_name_(a_test_suite_name),
+      name_(a_name),
+      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
+      value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
+      location_(a_code_location),
+      fixture_class_id_(fixture_class_id),
+      should_run_(false),
+      is_disabled_(false),
+      matches_filter_(false),
+      is_in_another_shard_(false),
+      factory_(factory),
+      result_() {}
+
+// Destructs a TestInfo object.
+TestInfo::~TestInfo() { delete factory_; }
+
+namespace internal {
+
+// Creates a new TestInfo object and registers it with Google Test;
+// returns the created object.
+//
+// Arguments:
+//
+//   test_suite_name:  name of the test suite
+//   name:             name of the test
+//   type_param:       the name of the test's type parameter, or NULL if
+//                     this is not a typed or a type-parameterized test.
+//   value_param:      text representation of the test's value parameter,
+//                     or NULL if this is not a value-parameterized test.
+//   code_location:    code location where the test is defined
+//   fixture_class_id: ID of the test fixture class
+//   set_up_tc:        pointer to the function that sets up the test suite
+//   tear_down_tc:     pointer to the function that tears down the test suite
+//   factory:          pointer to the factory that creates a test object.
+//                     The newly created TestInfo instance will assume
+//                     ownership of the factory object.
+TestInfo* MakeAndRegisterTestInfo(
+    const char* test_suite_name, const char* name, const char* type_param,
+    const char* value_param, CodeLocation code_location,
+    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
+    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
+  TestInfo* const test_info =
+      new TestInfo(test_suite_name, name, type_param, value_param,
+                   code_location, fixture_class_id, factory);
+  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
+  return test_info;
+}
+
+void ReportInvalidTestSuiteType(const char* test_suite_name,
+                                CodeLocation code_location) {
+  Message errors;
+  errors
+      << "Attempted redefinition of test suite " << test_suite_name << ".\n"
+      << "All tests in the same test suite must use the same test fixture\n"
+      << "class.  However, in test suite " << test_suite_name << ", you tried\n"
+      << "to define a test using a fixture class different from the one\n"
+      << "used earlier. This can happen if the two fixture classes are\n"
+      << "from different namespaces and have the same name. You should\n"
+      << "probably rename one of the classes to put the tests into different\n"
+      << "test suites.";
+
+  GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),
+                                          code_location.line)
+                    << " " << errors.GetString();
+}
+}  // namespace internal
+
+namespace {
+
+// A predicate that checks the test name of a TestInfo against a known
+// value.
+//
+// This is used for implementation of the TestSuite class only.  We put
+// it in the anonymous namespace to prevent polluting the outer
+// namespace.
+//
+// TestNameIs is copyable.
+class TestNameIs {
+ public:
+  // Constructor.
+  //
+  // TestNameIs has NO default constructor.
+  explicit TestNameIs(const char* name)
+      : name_(name) {}
+
+  // Returns true if and only if the test name of test_info matches name_.
+  bool operator()(const TestInfo * test_info) const {
+    return test_info && test_info->name() == name_;
+  }
+
+ private:
+  std::string name_;
+};
+
+}  // namespace
+
+namespace internal {
+
+// This method expands all parameterized tests registered with macros TEST_P
+// and INSTANTIATE_TEST_SUITE_P into regular tests and registers those.
+// This will be done just once during the program runtime.
+void UnitTestImpl::RegisterParameterizedTests() {
+  if (!parameterized_tests_registered_) {
+    parameterized_test_registry_.RegisterTests();
+    type_parameterized_test_registry_.CheckForInstantiations();
+    parameterized_tests_registered_ = true;
+  }
+}
+
+}  // namespace internal
+
+// Creates the test object, runs it, records its result, and then
+// deletes it.
+void TestInfo::Run() {
+  if (!should_run_) return;
+
+  // Tells UnitTest where to store test result.
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_info(this);
+
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
+
+  // Notifies the unit test event listeners that a test is about to start.
+  repeater->OnTestStart(*this);
+
+  result_.set_start_timestamp(internal::GetTimeInMillis());
+  internal::Timer timer;
+
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+
+  // Creates the test object.
+  Test* const test = internal::HandleExceptionsInMethodIfSupported(
+      factory_, &internal::TestFactoryBase::CreateTest,
+      "the test fixture's constructor");
+
+  // Runs the test if the constructor didn't generate a fatal failure or invoke
+  // GTEST_SKIP().
+  // Note that the object will not be null
+  if (!Test::HasFatalFailure() && !Test::IsSkipped()) {
+    // This doesn't throw as all user code that can throw are wrapped into
+    // exception handling code.
+    test->Run();
+  }
+
+  if (test != nullptr) {
+    // Deletes the test object.
+    impl->os_stack_trace_getter()->UponLeavingGTest();
+    internal::HandleExceptionsInMethodIfSupported(
+        test, &Test::DeleteSelf_, "the test fixture's destructor");
+  }
+
+  result_.set_elapsed_time(timer.Elapsed());
+
+  // Notifies the unit test event listener that a test has just finished.
+  repeater->OnTestEnd(*this);
+
+  // Tells UnitTest to stop associating assertion results to this
+  // test.
+  impl->set_current_test_info(nullptr);
+}
+
+// Skip and records a skipped test result for this object.
+void TestInfo::Skip() {
+  if (!should_run_) return;
+
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_info(this);
+
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
+
+  // Notifies the unit test event listeners that a test is about to start.
+  repeater->OnTestStart(*this);
+
+  const TestPartResult test_part_result =
+      TestPartResult(TestPartResult::kSkip, this->file(), this->line(), "");
+  impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(
+      test_part_result);
+
+  // Notifies the unit test event listener that a test has just finished.
+  repeater->OnTestEnd(*this);
+  impl->set_current_test_info(nullptr);
+}
+
+// class TestSuite
+
+// Gets the number of successful tests in this test suite.
+int TestSuite::successful_test_count() const {
+  return CountIf(test_info_list_, TestPassed);
+}
+
+// Gets the number of successful tests in this test suite.
+int TestSuite::skipped_test_count() const {
+  return CountIf(test_info_list_, TestSkipped);
+}
+
+// Gets the number of failed tests in this test suite.
+int TestSuite::failed_test_count() const {
+  return CountIf(test_info_list_, TestFailed);
+}
+
+// Gets the number of disabled tests that will be reported in the XML report.
+int TestSuite::reportable_disabled_test_count() const {
+  return CountIf(test_info_list_, TestReportableDisabled);
+}
+
+// Gets the number of disabled tests in this test suite.
+int TestSuite::disabled_test_count() const {
+  return CountIf(test_info_list_, TestDisabled);
+}
+
+// Gets the number of tests to be printed in the XML report.
+int TestSuite::reportable_test_count() const {
+  return CountIf(test_info_list_, TestReportable);
+}
+
+// Get the number of tests in this test suite that should run.
+int TestSuite::test_to_run_count() const {
+  return CountIf(test_info_list_, ShouldRunTest);
+}
+
+// Gets the number of all tests.
+int TestSuite::total_test_count() const {
+  return static_cast<int>(test_info_list_.size());
+}
+
+// Creates a TestSuite with the given name.
+//
+// Arguments:
+//
+//   a_name:       name of the test suite
+//   a_type_param: the name of the test suite's type parameter, or NULL if
+//                 this is not a typed or a type-parameterized test suite.
+//   set_up_tc:    pointer to the function that sets up the test suite
+//   tear_down_tc: pointer to the function that tears down the test suite
+TestSuite::TestSuite(const char* a_name, const char* a_type_param,
+                     internal::SetUpTestSuiteFunc set_up_tc,
+                     internal::TearDownTestSuiteFunc tear_down_tc)
+    : name_(a_name),
+      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
+      set_up_tc_(set_up_tc),
+      tear_down_tc_(tear_down_tc),
+      should_run_(false),
+      start_timestamp_(0),
+      elapsed_time_(0) {}
+
+// Destructor of TestSuite.
+TestSuite::~TestSuite() {
+  // Deletes every Test in the collection.
+  ForEach(test_info_list_, internal::Delete<TestInfo>);
+}
+
+// Returns the i-th test among all the tests. i can range from 0 to
+// total_test_count() - 1. If i is not in that range, returns NULL.
+const TestInfo* TestSuite::GetTestInfo(int i) const {
+  const int index = GetElementOr(test_indices_, i, -1);
+  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
+}
+
+// Returns the i-th test among all the tests. i can range from 0 to
+// total_test_count() - 1. If i is not in that range, returns NULL.
+TestInfo* TestSuite::GetMutableTestInfo(int i) {
+  const int index = GetElementOr(test_indices_, i, -1);
+  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
+}
+
+// Adds a test to this test suite.  Will delete the test upon
+// destruction of the TestSuite object.
+void TestSuite::AddTestInfo(TestInfo* test_info) {
+  test_info_list_.push_back(test_info);
+  test_indices_.push_back(static_cast<int>(test_indices_.size()));
+}
+
+// Runs every test in this TestSuite.
+void TestSuite::Run() {
+  if (!should_run_) return;
+
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_suite(this);
+
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
+
+  // Call both legacy and the new API
+  repeater->OnTestSuiteStart(*this);
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  repeater->OnTestCaseStart(*this);
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");
+
+  start_timestamp_ = internal::GetTimeInMillis();
+  internal::Timer timer;
+  for (int i = 0; i < total_test_count(); i++) {
+    GetMutableTestInfo(i)->Run();
+    if (GTEST_FLAG(fail_fast) && GetMutableTestInfo(i)->result()->Failed()) {
+      for (int j = i + 1; j < total_test_count(); j++) {
+        GetMutableTestInfo(j)->Skip();
+      }
+      break;
+    }
+  }
+  elapsed_time_ = timer.Elapsed();
+
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");
+
+  // Call both legacy and the new API
+  repeater->OnTestSuiteEnd(*this);
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  repeater->OnTestCaseEnd(*this);
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  impl->set_current_test_suite(nullptr);
+}
+
+// Skips all tests under this TestSuite.
+void TestSuite::Skip() {
+  if (!should_run_) return;
+
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_suite(this);
+
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
+
+  // Call both legacy and the new API
+  repeater->OnTestSuiteStart(*this);
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  repeater->OnTestCaseStart(*this);
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  for (int i = 0; i < total_test_count(); i++) {
+    GetMutableTestInfo(i)->Skip();
+  }
+
+  // Call both legacy and the new API
+  repeater->OnTestSuiteEnd(*this);
+  // Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  repeater->OnTestCaseEnd(*this);
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  impl->set_current_test_suite(nullptr);
+}
+
+// Clears the results of all tests in this test suite.
+void TestSuite::ClearResult() {
+  ad_hoc_test_result_.Clear();
+  ForEach(test_info_list_, TestInfo::ClearTestResult);
+}
+
+// Shuffles the tests in this test suite.
+void TestSuite::ShuffleTests(internal::Random* random) {
+  Shuffle(random, &test_indices_);
+}
+
+// Restores the test order to before the first shuffle.
+void TestSuite::UnshuffleTests() {
+  for (size_t i = 0; i < test_indices_.size(); i++) {
+    test_indices_[i] = static_cast<int>(i);
+  }
+}
+
+// Formats a countable noun.  Depending on its quantity, either the
+// singular form or the plural form is used. e.g.
+//
+// FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
+// FormatCountableNoun(5, "book", "books") returns "5 books".
+static std::string FormatCountableNoun(int count,
+                                       const char * singular_form,
+                                       const char * plural_form) {
+  return internal::StreamableToString(count) + " " +
+      (count == 1 ? singular_form : plural_form);
+}
+
+// Formats the count of tests.
+static std::string FormatTestCount(int test_count) {
+  return FormatCountableNoun(test_count, "test", "tests");
+}
+
+// Formats the count of test suites.
+static std::string FormatTestSuiteCount(int test_suite_count) {
+  return FormatCountableNoun(test_suite_count, "test suite", "test suites");
+}
+
+// Converts a TestPartResult::Type enum to human-friendly string
+// representation.  Both kNonFatalFailure and kFatalFailure are translated
+// to "Failure", as the user usually doesn't care about the difference
+// between the two when viewing the test result.
+static const char * TestPartResultTypeToString(TestPartResult::Type type) {
+  switch (type) {
+    case TestPartResult::kSkip:
+      return "Skipped\n";
+    case TestPartResult::kSuccess:
+      return "Success";
+
+    case TestPartResult::kNonFatalFailure:
+    case TestPartResult::kFatalFailure:
+#ifdef _MSC_VER
+      return "error: ";
+#else
+      return "Failure\n";
+#endif
+    default:
+      return "Unknown result type";
+  }
+}
+
+namespace internal {
+namespace {
+enum class GTestColor { kDefault, kRed, kGreen, kYellow };
+}  // namespace
+
+// Prints a TestPartResult to an std::string.
+static std::string PrintTestPartResultToString(
+    const TestPartResult& test_part_result) {
+  return (Message()
+          << internal::FormatFileLocation(test_part_result.file_name(),
+                                          test_part_result.line_number())
+          << " " << TestPartResultTypeToString(test_part_result.type())
+          << test_part_result.message()).GetString();
+}
+
+// Prints a TestPartResult.
+static void PrintTestPartResult(const TestPartResult& test_part_result) {
+  const std::string& result =
+      PrintTestPartResultToString(test_part_result);
+  printf("%s\n", result.c_str());
+  fflush(stdout);
+  // If the test program runs in Visual Studio or a debugger, the
+  // following statements add the test part result message to the Output
+  // window such that the user can double-click on it to jump to the
+  // corresponding source code location; otherwise they do nothing.
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
+  // We don't call OutputDebugString*() on Windows Mobile, as printing
+  // to stdout is done by OutputDebugString() there already - we don't
+  // want the same message printed twice.
+  ::OutputDebugStringA(result.c_str());
+  ::OutputDebugStringA("\n");
+#endif
+}
+
+// class PrettyUnitTestResultPrinter
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
+    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
+
+// Returns the character attribute for the given color.
+static WORD GetColorAttribute(GTestColor color) {
+  switch (color) {
+    case GTestColor::kRed:
+      return FOREGROUND_RED;
+    case GTestColor::kGreen:
+      return FOREGROUND_GREEN;
+    case GTestColor::kYellow:
+      return FOREGROUND_RED | FOREGROUND_GREEN;
+    default:           return 0;
+  }
+}
+
+static int GetBitOffset(WORD color_mask) {
+  if (color_mask == 0) return 0;
+
+  int bitOffset = 0;
+  while ((color_mask & 1) == 0) {
+    color_mask >>= 1;
+    ++bitOffset;
+  }
+  return bitOffset;
+}
+
+static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
+  // Let's reuse the BG
+  static const WORD background_mask = BACKGROUND_BLUE | BACKGROUND_GREEN |
+                                      BACKGROUND_RED | BACKGROUND_INTENSITY;
+  static const WORD foreground_mask = FOREGROUND_BLUE | FOREGROUND_GREEN |
+                                      FOREGROUND_RED | FOREGROUND_INTENSITY;
+  const WORD existing_bg = old_color_attrs & background_mask;
+
+  WORD new_color =
+      GetColorAttribute(color) | existing_bg | FOREGROUND_INTENSITY;
+  static const int bg_bitOffset = GetBitOffset(background_mask);
+  static const int fg_bitOffset = GetBitOffset(foreground_mask);
+
+  if (((new_color & background_mask) >> bg_bitOffset) ==
+      ((new_color & foreground_mask) >> fg_bitOffset)) {
+    new_color ^= FOREGROUND_INTENSITY;  // invert intensity
+  }
+  return new_color;
+}
+
+#else
+
+// Returns the ANSI color code for the given color. GTestColor::kDefault is
+// an invalid input.
+static const char* GetAnsiColorCode(GTestColor color) {
+  switch (color) {
+    case GTestColor::kRed:
+      return "1";
+    case GTestColor::kGreen:
+      return "2";
+    case GTestColor::kYellow:
+      return "3";
+    default:
+      return nullptr;
+  }
+}
+
+#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
+
+// Returns true if and only if Google Test should use colors in the output.
+bool ShouldUseColor(bool stdout_is_tty) {
+  const char* const gtest_color = GTEST_FLAG(color).c_str();
+
+  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+    // On Windows the TERM variable is usually not set, but the
+    // console there does support colors.
+    return stdout_is_tty;
+#else
+    // On non-Windows platforms, we rely on the TERM variable.
+    const char* const term = posix::GetEnv("TERM");
+    const bool term_supports_color =
+        String::CStringEquals(term, "xterm") ||
+        String::CStringEquals(term, "xterm-color") ||
+        String::CStringEquals(term, "xterm-256color") ||
+        String::CStringEquals(term, "screen") ||
+        String::CStringEquals(term, "screen-256color") ||
+        String::CStringEquals(term, "tmux") ||
+        String::CStringEquals(term, "tmux-256color") ||
+        String::CStringEquals(term, "rxvt-unicode") ||
+        String::CStringEquals(term, "rxvt-unicode-256color") ||
+        String::CStringEquals(term, "linux") ||
+        String::CStringEquals(term, "cygwin");
+    return stdout_is_tty && term_supports_color;
+#endif  // GTEST_OS_WINDOWS
+  }
+
+  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
+      String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
+      String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
+      String::CStringEquals(gtest_color, "1");
+  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
+  // value is neither one of these nor "auto", we treat it as "no" to
+  // be conservative.
+}
+
+// Helpers for printing colored strings to stdout. Note that on Windows, we
+// cannot simply emit special characters and have the terminal change colors.
+// This routine must actually emit the characters rather than return a string
+// that would be colored when printed, as can be done on Linux.
+
+GTEST_ATTRIBUTE_PRINTF_(2, 3)
+static void ColoredPrintf(GTestColor color, const char *fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
+    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
+  const bool use_color = AlwaysFalse();
+#else
+  static const bool in_color_mode =
+      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
+  const bool use_color = in_color_mode && (color != GTestColor::kDefault);
+#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS
+
+  if (!use_color) {
+    vprintf(fmt, args);
+    va_end(args);
+    return;
+  }
+
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
+    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
+  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
+
+  // Gets the current text color.
+  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
+  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
+  const WORD old_color_attrs = buffer_info.wAttributes;
+  const WORD new_color = GetNewColor(color, old_color_attrs);
+
+  // We need to flush the stream buffers into the console before each
+  // SetConsoleTextAttribute call lest it affect the text that is already
+  // printed but has not yet reached the console.
+  fflush(stdout);
+  SetConsoleTextAttribute(stdout_handle, new_color);
+
+  vprintf(fmt, args);
+
+  fflush(stdout);
+  // Restores the text color.
+  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
+#else
+  printf("\033[0;3%sm", GetAnsiColorCode(color));
+  vprintf(fmt, args);
+  printf("\033[m");  // Resets the terminal to default.
+#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
+  va_end(args);
+}
+
+// Text printed in Google Test's text output and --gtest_list_tests
+// output to label the type parameter and value parameter for a test.
+static const char kTypeParamLabel[] = "TypeParam";
+static const char kValueParamLabel[] = "GetParam()";
+
+static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
+  const char* const type_param = test_info.type_param();
+  const char* const value_param = test_info.value_param();
+
+  if (type_param != nullptr || value_param != nullptr) {
+    printf(", where ");
+    if (type_param != nullptr) {
+      printf("%s = %s", kTypeParamLabel, type_param);
+      if (value_param != nullptr) printf(" and ");
+    }
+    if (value_param != nullptr) {
+      printf("%s = %s", kValueParamLabel, value_param);
+    }
+  }
+}
+
+// This class implements the TestEventListener interface.
+//
+// Class PrettyUnitTestResultPrinter is copyable.
+class PrettyUnitTestResultPrinter : public TestEventListener {
+ public:
+  PrettyUnitTestResultPrinter() {}
+  static void PrintTestName(const char* test_suite, const char* test) {
+    printf("%s.%s", test_suite, test);
+  }
+
+  // The following methods override what's in the TestEventListener class.
+  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;
+  void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;
+  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseStart(const TestCase& test_case) override;
+#else
+  void OnTestSuiteStart(const TestSuite& test_suite) override;
+#endif  // OnTestCaseStart
+
+  void OnTestStart(const TestInfo& test_info) override;
+
+  void OnTestPartResult(const TestPartResult& result) override;
+  void OnTestEnd(const TestInfo& test_info) override;
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseEnd(const TestCase& test_case) override;
+#else
+  void OnTestSuiteEnd(const TestSuite& test_suite) override;
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
+  void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
+  void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
+
+ private:
+  static void PrintFailedTests(const UnitTest& unit_test);
+  static void PrintFailedTestSuites(const UnitTest& unit_test);
+  static void PrintSkippedTests(const UnitTest& unit_test);
+};
+
+  // Fired before each iteration of tests starts.
+void PrettyUnitTestResultPrinter::OnTestIterationStart(
+    const UnitTest& unit_test, int iteration) {
+  if (GTEST_FLAG(repeat) != 1)
+    printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
+
+  const char* const filter = GTEST_FLAG(filter).c_str();
+
+  // Prints the filter if it's not *.  This reminds the user that some
+  // tests may be skipped.
+  if (!String::CStringEquals(filter, kUniversalFilter)) {
+    ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_,
+                  filter);
+  }
+
+  if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
+    const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
+    ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n",
+                  static_cast<int>(shard_index) + 1,
+                  internal::posix::GetEnv(kTestTotalShards));
+  }
+
+  if (GTEST_FLAG(shuffle)) {
+    ColoredPrintf(GTestColor::kYellow,
+                  "Note: Randomizing tests' orders with a seed of %d .\n",
+                  unit_test.random_seed());
+  }
+
+  ColoredPrintf(GTestColor::kGreen, "[==========] ");
+  printf("Running %s from %s.\n",
+         FormatTestCount(unit_test.test_to_run_count()).c_str(),
+         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
+    const UnitTest& /*unit_test*/) {
+  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  printf("Global test environment set-up.\n");
+  fflush(stdout);
+}
+
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
+  const std::string counts =
+      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
+  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  printf("%s from %s", counts.c_str(), test_case.name());
+  if (test_case.type_param() == nullptr) {
+    printf("\n");
+  } else {
+    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
+  }
+  fflush(stdout);
+}
+#else
+void PrettyUnitTestResultPrinter::OnTestSuiteStart(
+    const TestSuite& test_suite) {
+  const std::string counts =
+      FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
+  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  printf("%s from %s", counts.c_str(), test_suite.name());
+  if (test_suite.type_param() == nullptr) {
+    printf("\n");
+  } else {
+    printf(", where %s = %s\n", kTypeParamLabel, test_suite.type_param());
+  }
+  fflush(stdout);
+}
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
+  ColoredPrintf(GTestColor::kGreen, "[ RUN      ] ");
+  PrintTestName(test_info.test_suite_name(), test_info.name());
+  printf("\n");
+  fflush(stdout);
+}
+
+// Called after an assertion failure.
+void PrettyUnitTestResultPrinter::OnTestPartResult(
+    const TestPartResult& result) {
+  switch (result.type()) {
+    // If the test part succeeded, we don't need to do anything.
+    case TestPartResult::kSuccess:
+      return;
+    default:
+      // Print failure message from the assertion
+      // (e.g. expected this and got that).
+      PrintTestPartResult(result);
+      fflush(stdout);
+  }
+}
+
+void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
+  if (test_info.result()->Passed()) {
+    ColoredPrintf(GTestColor::kGreen, "[       OK ] ");
+  } else if (test_info.result()->Skipped()) {
+    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
+  } else {
+    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+  }
+  PrintTestName(test_info.test_suite_name(), test_info.name());
+  if (test_info.result()->Failed())
+    PrintFullTestCommentIfPresent(test_info);
+
+  if (GTEST_FLAG(print_time)) {
+    printf(" (%s ms)\n", internal::StreamableToString(
+           test_info.result()->elapsed_time()).c_str());
+  } else {
+    printf("\n");
+  }
+  fflush(stdout);
+}
+
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
+  if (!GTEST_FLAG(print_time)) return;
+
+  const std::string counts =
+      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
+  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_case.name(),
+         internal::StreamableToString(test_case.elapsed_time()).c_str());
+  fflush(stdout);
+}
+#else
+void PrettyUnitTestResultPrinter::OnTestSuiteEnd(const TestSuite& test_suite) {
+  if (!GTEST_FLAG(print_time)) return;
+
+  const std::string counts =
+      FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
+  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_suite.name(),
+         internal::StreamableToString(test_suite.elapsed_time()).c_str());
+  fflush(stdout);
+}
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
+    const UnitTest& /*unit_test*/) {
+  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  printf("Global test environment tear-down\n");
+  fflush(stdout);
+}
+
+// Internal helper for printing the list of failed tests.
+void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
+  const int failed_test_count = unit_test.failed_test_count();
+  ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+  printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
+
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
+    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
+    if (!test_suite.should_run() || (test_suite.failed_test_count() == 0)) {
+      continue;
+    }
+    for (int j = 0; j < test_suite.total_test_count(); ++j) {
+      const TestInfo& test_info = *test_suite.GetTestInfo(j);
+      if (!test_info.should_run() || !test_info.result()->Failed()) {
+        continue;
+      }
+      ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+      printf("%s.%s", test_suite.name(), test_info.name());
+      PrintFullTestCommentIfPresent(test_info);
+      printf("\n");
+    }
+  }
+  printf("\n%2d FAILED %s\n", failed_test_count,
+         failed_test_count == 1 ? "TEST" : "TESTS");
+}
+
+// Internal helper for printing the list of test suite failures not covered by
+// PrintFailedTests.
+void PrettyUnitTestResultPrinter::PrintFailedTestSuites(
+    const UnitTest& unit_test) {
+  int suite_failure_count = 0;
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
+    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
+    if (!test_suite.should_run()) {
+      continue;
+    }
+    if (test_suite.ad_hoc_test_result().Failed()) {
+      ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+      printf("%s: SetUpTestSuite or TearDownTestSuite\n", test_suite.name());
+      ++suite_failure_count;
+    }
+  }
+  if (suite_failure_count > 0) {
+    printf("\n%2d FAILED TEST %s\n", suite_failure_count,
+           suite_failure_count == 1 ? "SUITE" : "SUITES");
+  }
+}
+
+// Internal helper for printing the list of skipped tests.
+void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) {
+  const int skipped_test_count = unit_test.skipped_test_count();
+  if (skipped_test_count == 0) {
+    return;
+  }
+
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
+    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
+    if (!test_suite.should_run() || (test_suite.skipped_test_count() == 0)) {
+      continue;
+    }
+    for (int j = 0; j < test_suite.total_test_count(); ++j) {
+      const TestInfo& test_info = *test_suite.GetTestInfo(j);
+      if (!test_info.should_run() || !test_info.result()->Skipped()) {
+        continue;
+      }
+      ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
+      printf("%s.%s", test_suite.name(), test_info.name());
+      printf("\n");
+    }
+  }
+}
+
+void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
+                                                     int /*iteration*/) {
+  ColoredPrintf(GTestColor::kGreen, "[==========] ");
+  printf("%s from %s ran.",
+         FormatTestCount(unit_test.test_to_run_count()).c_str(),
+         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
+  if (GTEST_FLAG(print_time)) {
+    printf(" (%s ms total)",
+           internal::StreamableToString(unit_test.elapsed_time()).c_str());
+  }
+  printf("\n");
+  ColoredPrintf(GTestColor::kGreen, "[  PASSED  ] ");
+  printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
+
+  const int skipped_test_count = unit_test.skipped_test_count();
+  if (skipped_test_count > 0) {
+    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
+    printf("%s, listed below:\n", FormatTestCount(skipped_test_count).c_str());
+    PrintSkippedTests(unit_test);
+  }
+
+  if (!unit_test.Passed()) {
+    PrintFailedTests(unit_test);
+    PrintFailedTestSuites(unit_test);
+  }
+
+  int num_disabled = unit_test.reportable_disabled_test_count();
+  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
+    if (unit_test.Passed()) {
+      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
+    }
+    ColoredPrintf(GTestColor::kYellow, "  YOU HAVE %d DISABLED %s\n\n",
+                  num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
+  }
+  // Ensure that Google Test output is printed before, e.g., heapchecker output.
+  fflush(stdout);
+}
+
+// End PrettyUnitTestResultPrinter
+
+// This class implements the TestEventListener interface.
+//
+// Class BriefUnitTestResultPrinter is copyable.
+class BriefUnitTestResultPrinter : public TestEventListener {
+ public:
+  BriefUnitTestResultPrinter() {}
+  static void PrintTestName(const char* test_suite, const char* test) {
+    printf("%s.%s", test_suite, test);
+  }
+
+  // The following methods override what's in the TestEventListener class.
+  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationStart(const UnitTest& /*unit_test*/,
+                            int /*iteration*/) override {}
+  void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}
+  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseStart(const TestCase& /*test_case*/) override {}
+#else
+  void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
+#endif  // OnTestCaseStart
+
+  void OnTestStart(const TestInfo& /*test_info*/) override {}
+
+  void OnTestPartResult(const TestPartResult& result) override;
+  void OnTestEnd(const TestInfo& test_info) override;
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
+#else
+  void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {}
+  void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
+  void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
+};
+
+// Called after an assertion failure.
+void BriefUnitTestResultPrinter::OnTestPartResult(
+    const TestPartResult& result) {
+  switch (result.type()) {
+    // If the test part succeeded, we don't need to do anything.
+    case TestPartResult::kSuccess:
+      return;
+    default:
+      // Print failure message from the assertion
+      // (e.g. expected this and got that).
+      PrintTestPartResult(result);
+      fflush(stdout);
+  }
+}
+
+void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
+  if (test_info.result()->Failed()) {
+    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+    PrintTestName(test_info.test_suite_name(), test_info.name());
+    PrintFullTestCommentIfPresent(test_info);
+
+    if (GTEST_FLAG(print_time)) {
+      printf(" (%s ms)\n",
+             internal::StreamableToString(test_info.result()->elapsed_time())
+                 .c_str());
+    } else {
+      printf("\n");
+    }
+    fflush(stdout);
+  }
+}
+
+void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
+                                                    int /*iteration*/) {
+  ColoredPrintf(GTestColor::kGreen, "[==========] ");
+  printf("%s from %s ran.",
+         FormatTestCount(unit_test.test_to_run_count()).c_str(),
+         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
+  if (GTEST_FLAG(print_time)) {
+    printf(" (%s ms total)",
+           internal::StreamableToString(unit_test.elapsed_time()).c_str());
+  }
+  printf("\n");
+  ColoredPrintf(GTestColor::kGreen, "[  PASSED  ] ");
+  printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
+
+  const int skipped_test_count = unit_test.skipped_test_count();
+  if (skipped_test_count > 0) {
+    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
+    printf("%s.\n", FormatTestCount(skipped_test_count).c_str());
+  }
+
+  int num_disabled = unit_test.reportable_disabled_test_count();
+  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
+    if (unit_test.Passed()) {
+      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
+    }
+    ColoredPrintf(GTestColor::kYellow, "  YOU HAVE %d DISABLED %s\n\n",
+                  num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
+  }
+  // Ensure that Google Test output is printed before, e.g., heapchecker output.
+  fflush(stdout);
+}
+
+// End BriefUnitTestResultPrinter
+
+// class TestEventRepeater
+//
+// This class forwards events to other event listeners.
+class TestEventRepeater : public TestEventListener {
+ public:
+  TestEventRepeater() : forwarding_enabled_(true) {}
+  ~TestEventRepeater() override;
+  void Append(TestEventListener *listener);
+  TestEventListener* Release(TestEventListener* listener);
+
+  // Controls whether events will be forwarded to listeners_. Set to false
+  // in death test child processes.
+  bool forwarding_enabled() const { return forwarding_enabled_; }
+  void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; }
+
+  void OnTestProgramStart(const UnitTest& unit_test) override;
+  void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;
+  void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;
+  void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) override;
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseStart(const TestSuite& parameter) override;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestSuiteStart(const TestSuite& parameter) override;
+  void OnTestStart(const TestInfo& test_info) override;
+  void OnTestPartResult(const TestPartResult& result) override;
+  void OnTestEnd(const TestInfo& test_info) override;
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseEnd(const TestCase& parameter) override;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestSuiteEnd(const TestSuite& parameter) override;
+  void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
+  void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) override;
+  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
+  void OnTestProgramEnd(const UnitTest& unit_test) override;
+
+ private:
+  // Controls whether events will be forwarded to listeners_. Set to false
+  // in death test child processes.
+  bool forwarding_enabled_;
+  // The list of listeners that receive events.
+  std::vector<TestEventListener*> listeners_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater);
+};
+
+TestEventRepeater::~TestEventRepeater() {
+  ForEach(listeners_, Delete<TestEventListener>);
+}
+
+void TestEventRepeater::Append(TestEventListener *listener) {
+  listeners_.push_back(listener);
+}
+
+TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
+  for (size_t i = 0; i < listeners_.size(); ++i) {
+    if (listeners_[i] == listener) {
+      listeners_.erase(listeners_.begin() + static_cast<int>(i));
+      return listener;
+    }
+  }
+
+  return nullptr;
+}
+
+// Since most methods are very similar, use macros to reduce boilerplate.
+// This defines a member that forwards the call to all listeners.
+#define GTEST_REPEATER_METHOD_(Name, Type) \
+void TestEventRepeater::Name(const Type& parameter) { \
+  if (forwarding_enabled_) { \
+    for (size_t i = 0; i < listeners_.size(); i++) { \
+      listeners_[i]->Name(parameter); \
+    } \
+  } \
+}
+// This defines a member that forwards the call to all listeners in reverse
+// order.
+#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type)      \
+  void TestEventRepeater::Name(const Type& parameter) { \
+    if (forwarding_enabled_) {                          \
+      for (size_t i = listeners_.size(); i != 0; i--) { \
+        listeners_[i - 1]->Name(parameter);             \
+      }                                                 \
+    }                                                   \
+  }
+
+GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
+GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+GTEST_REPEATER_METHOD_(OnTestCaseStart, TestSuite)
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+GTEST_REPEATER_METHOD_(OnTestSuiteStart, TestSuite)
+GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)
+GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)
+GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)
+GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)
+GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest)
+GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo)
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestSuite)
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+GTEST_REVERSE_REPEATER_METHOD_(OnTestSuiteEnd, TestSuite)
+GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)
+
+#undef GTEST_REPEATER_METHOD_
+#undef GTEST_REVERSE_REPEATER_METHOD_
+
+void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
+                                             int iteration) {
+  if (forwarding_enabled_) {
+    for (size_t i = 0; i < listeners_.size(); i++) {
+      listeners_[i]->OnTestIterationStart(unit_test, iteration);
+    }
+  }
+}
+
+void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
+                                           int iteration) {
+  if (forwarding_enabled_) {
+    for (size_t i = listeners_.size(); i > 0; i--) {
+      listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration);
+    }
+  }
+}
+
+// End TestEventRepeater
+
+// This class generates an XML output file.
+class XmlUnitTestResultPrinter : public EmptyTestEventListener {
+ public:
+  explicit XmlUnitTestResultPrinter(const char* output_file);
+
+  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
+  void ListTestsMatchingFilter(const std::vector<TestSuite*>& test_suites);
+
+  // Prints an XML summary of all unit tests.
+  static void PrintXmlTestsList(std::ostream* stream,
+                                const std::vector<TestSuite*>& test_suites);
+
+ private:
+  // Is c a whitespace character that is normalized to a space character
+  // when it appears in an XML attribute value?
+  static bool IsNormalizableWhitespace(char c) {
+    return c == 0x9 || c == 0xA || c == 0xD;
+  }
+
+  // May c appear in a well-formed XML document?
+  static bool IsValidXmlCharacter(char c) {
+    return IsNormalizableWhitespace(c) || c >= 0x20;
+  }
+
+  // Returns an XML-escaped copy of the input string str.  If
+  // is_attribute is true, the text is meant to appear as an attribute
+  // value, and normalizable whitespace is preserved by replacing it
+  // with character references.
+  static std::string EscapeXml(const std::string& str, bool is_attribute);
+
+  // Returns the given string with all characters invalid in XML removed.
+  static std::string RemoveInvalidXmlCharacters(const std::string& str);
+
+  // Convenience wrapper around EscapeXml when str is an attribute value.
+  static std::string EscapeXmlAttribute(const std::string& str) {
+    return EscapeXml(str, true);
+  }
+
+  // Convenience wrapper around EscapeXml when str is not an attribute value.
+  static std::string EscapeXmlText(const char* str) {
+    return EscapeXml(str, false);
+  }
+
+  // Verifies that the given attribute belongs to the given element and
+  // streams the attribute as XML.
+  static void OutputXmlAttribute(std::ostream* stream,
+                                 const std::string& element_name,
+                                 const std::string& name,
+                                 const std::string& value);
+
+  // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
+  static void OutputXmlCDataSection(::std::ostream* stream, const char* data);
+
+  // Streams a test suite XML stanza containing the given test result.
+  //
+  // Requires: result.Failed()
+  static void OutputXmlTestSuiteForTestResult(::std::ostream* stream,
+                                              const TestResult& result);
+
+  // Streams an XML representation of a TestResult object.
+  static void OutputXmlTestResult(::std::ostream* stream,
+                                  const TestResult& result);
+
+  // Streams an XML representation of a TestInfo object.
+  static void OutputXmlTestInfo(::std::ostream* stream,
+                                const char* test_suite_name,
+                                const TestInfo& test_info);
+
+  // Prints an XML representation of a TestSuite object
+  static void PrintXmlTestSuite(::std::ostream* stream,
+                                const TestSuite& test_suite);
+
+  // Prints an XML summary of unit_test to output stream out.
+  static void PrintXmlUnitTest(::std::ostream* stream,
+                               const UnitTest& unit_test);
+
+  // Produces a string representing the test properties in a result as space
+  // delimited XML attributes based on the property key="value" pairs.
+  // When the std::string is not empty, it includes a space at the beginning,
+  // to delimit this attribute from prior attributes.
+  static std::string TestPropertiesAsXmlAttributes(const TestResult& result);
+
+  // Streams an XML representation of the test properties of a TestResult
+  // object.
+  static void OutputXmlTestProperties(std::ostream* stream,
+                                      const TestResult& result);
+
+  // The output file.
+  const std::string output_file_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
+};
+
+// Creates a new XmlUnitTestResultPrinter.
+XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
+    : output_file_(output_file) {
+  if (output_file_.empty()) {
+    GTEST_LOG_(FATAL) << "XML output file may not be null";
+  }
+}
+
+// Called after the unit test ends.
+void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
+                                                  int /*iteration*/) {
+  FILE* xmlout = OpenFileForWriting(output_file_);
+  std::stringstream stream;
+  PrintXmlUnitTest(&stream, unit_test);
+  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
+  fclose(xmlout);
+}
+
+void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
+    const std::vector<TestSuite*>& test_suites) {
+  FILE* xmlout = OpenFileForWriting(output_file_);
+  std::stringstream stream;
+  PrintXmlTestsList(&stream, test_suites);
+  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
+  fclose(xmlout);
+}
+
+// Returns an XML-escaped copy of the input string str.  If is_attribute
+// is true, the text is meant to appear as an attribute value, and
+// normalizable whitespace is preserved by replacing it with character
+// references.
+//
+// Invalid XML characters in str, if any, are stripped from the output.
+// It is expected that most, if not all, of the text processed by this
+// module will consist of ordinary English text.
+// If this module is ever modified to produce version 1.1 XML output,
+// most invalid characters can be retained using character references.
+std::string XmlUnitTestResultPrinter::EscapeXml(
+    const std::string& str, bool is_attribute) {
+  Message m;
+
+  for (size_t i = 0; i < str.size(); ++i) {
+    const char ch = str[i];
+    switch (ch) {
+      case '<':
+        m << "&lt;";
+        break;
+      case '>':
+        m << "&gt;";
+        break;
+      case '&':
+        m << "&amp;";
+        break;
+      case '\'':
+        if (is_attribute)
+          m << "&apos;";
+        else
+          m << '\'';
+        break;
+      case '"':
+        if (is_attribute)
+          m << "&quot;";
+        else
+          m << '"';
+        break;
+      default:
+        if (IsValidXmlCharacter(ch)) {
+          if (is_attribute && IsNormalizableWhitespace(ch))
+            m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
+              << ";";
+          else
+            m << ch;
+        }
+        break;
+    }
+  }
+
+  return m.GetString();
+}
+
+// Returns the given string with all characters invalid in XML removed.
+// Currently invalid characters are dropped from the string. An
+// alternative is to replace them with certain characters such as . or ?.
+std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
+    const std::string& str) {
+  std::string output;
+  output.reserve(str.size());
+  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
+    if (IsValidXmlCharacter(*it))
+      output.push_back(*it);
+
+  return output;
+}
+
+// The following routines generate an XML representation of a UnitTest
+// object.
+// GOOGLETEST_CM0009 DO NOT DELETE
+//
+// This is how Google Test concepts map to the DTD:
+//
+// <testsuites name="AllTests">        <-- corresponds to a UnitTest object
+//   <testsuite name="testcase-name">  <-- corresponds to a TestSuite object
+//     <testcase name="test-name">     <-- corresponds to a TestInfo object
+//       <failure message="...">...</failure>
+//       <failure message="...">...</failure>
+//       <failure message="...">...</failure>
+//                                     <-- individual assertion failures
+//     </testcase>
+//   </testsuite>
+// </testsuites>
+
+// Formats the given time in milliseconds as seconds.
+std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
+  ::std::stringstream ss;
+  ss << (static_cast<double>(ms) * 1e-3);
+  return ss.str();
+}
+
+static bool PortableLocaltime(time_t seconds, struct tm* out) {
+#if defined(_MSC_VER)
+  return localtime_s(out, &seconds) == 0;
+#elif defined(__MINGW32__) || defined(__MINGW64__)
+  // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
+  // Windows' localtime(), which has a thread-local tm buffer.
+  struct tm* tm_ptr = localtime(&seconds);  // NOLINT
+  if (tm_ptr == nullptr) return false;
+  *out = *tm_ptr;
+  return true;
+#elif defined(__STDC_LIB_EXT1__)
+  // Uses localtime_s when available as localtime_r is only available from
+  // C23 standard.
+  return localtime_s(&seconds, out) != nullptr;
+#else
+  return localtime_r(&seconds, out) != nullptr;
+#endif
+}
+
+// Converts the given epoch time in milliseconds to a date string in the ISO
+// 8601 format, without the timezone information.
+std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
+  struct tm time_struct;
+  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
+    return "";
+  // YYYY-MM-DDThh:mm:ss.sss
+  return StreamableToString(time_struct.tm_year + 1900) + "-" +
+      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
+      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
+      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
+      String::FormatIntWidth2(time_struct.tm_min) + ":" +
+      String::FormatIntWidth2(time_struct.tm_sec) + "." +
+      String::FormatIntWidthN(static_cast<int>(ms % 1000), 3);
+}
+
+// Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
+void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
+                                                     const char* data) {
+  const char* segment = data;
+  *stream << "<![CDATA[";
+  for (;;) {
+    const char* const next_segment = strstr(segment, "]]>");
+    if (next_segment != nullptr) {
+      stream->write(
+          segment, static_cast<std::streamsize>(next_segment - segment));
+      *stream << "]]>]]&gt;<![CDATA[";
+      segment = next_segment + strlen("]]>");
+    } else {
+      *stream << segment;
+      break;
+    }
+  }
+  *stream << "]]>";
+}
+
+void XmlUnitTestResultPrinter::OutputXmlAttribute(
+    std::ostream* stream,
+    const std::string& element_name,
+    const std::string& name,
+    const std::string& value) {
+  const std::vector<std::string>& allowed_names =
+      GetReservedOutputAttributesForElement(element_name);
+
+  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
+                   allowed_names.end())
+      << "Attribute " << name << " is not allowed for element <" << element_name
+      << ">.";
+
+  *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
+}
+
+// Streams a test suite XML stanza containing the given test result.
+void XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult(
+    ::std::ostream* stream, const TestResult& result) {
+  // Output the boilerplate for a minimal test suite with one test.
+  *stream << "  <testsuite";
+  OutputXmlAttribute(stream, "testsuite", "name", "NonTestSuiteFailure");
+  OutputXmlAttribute(stream, "testsuite", "tests", "1");
+  OutputXmlAttribute(stream, "testsuite", "failures", "1");
+  OutputXmlAttribute(stream, "testsuite", "disabled", "0");
+  OutputXmlAttribute(stream, "testsuite", "skipped", "0");
+  OutputXmlAttribute(stream, "testsuite", "errors", "0");
+  OutputXmlAttribute(stream, "testsuite", "time",
+                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
+  OutputXmlAttribute(
+      stream, "testsuite", "timestamp",
+      FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
+  *stream << ">";
+
+  // Output the boilerplate for a minimal test case with a single test.
+  *stream << "    <testcase";
+  OutputXmlAttribute(stream, "testcase", "name", "");
+  OutputXmlAttribute(stream, "testcase", "status", "run");
+  OutputXmlAttribute(stream, "testcase", "result", "completed");
+  OutputXmlAttribute(stream, "testcase", "classname", "");
+  OutputXmlAttribute(stream, "testcase", "time",
+                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
+  OutputXmlAttribute(
+      stream, "testcase", "timestamp",
+      FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
+
+  // Output the actual test result.
+  OutputXmlTestResult(stream, result);
+
+  // Complete the test suite.
+  *stream << "  </testsuite>\n";
+}
+
+// Prints an XML representation of a TestInfo object.
+void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
+                                                 const char* test_suite_name,
+                                                 const TestInfo& test_info) {
+  const TestResult& result = *test_info.result();
+  const std::string kTestsuite = "testcase";
+
+  if (test_info.is_in_another_shard()) {
+    return;
+  }
+
+  *stream << "    <testcase";
+  OutputXmlAttribute(stream, kTestsuite, "name", test_info.name());
+
+  if (test_info.value_param() != nullptr) {
+    OutputXmlAttribute(stream, kTestsuite, "value_param",
+                       test_info.value_param());
+  }
+  if (test_info.type_param() != nullptr) {
+    OutputXmlAttribute(stream, kTestsuite, "type_param",
+                       test_info.type_param());
+  }
+  if (GTEST_FLAG(list_tests)) {
+    OutputXmlAttribute(stream, kTestsuite, "file", test_info.file());
+    OutputXmlAttribute(stream, kTestsuite, "line",
+                       StreamableToString(test_info.line()));
+    *stream << " />\n";
+    return;
+  }
+
+  OutputXmlAttribute(stream, kTestsuite, "status",
+                     test_info.should_run() ? "run" : "notrun");
+  OutputXmlAttribute(stream, kTestsuite, "result",
+                     test_info.should_run()
+                         ? (result.Skipped() ? "skipped" : "completed")
+                         : "suppressed");
+  OutputXmlAttribute(stream, kTestsuite, "time",
+                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
+  OutputXmlAttribute(
+      stream, kTestsuite, "timestamp",
+      FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
+  OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name);
+
+  OutputXmlTestResult(stream, result);
+}
+
+void XmlUnitTestResultPrinter::OutputXmlTestResult(::std::ostream* stream,
+                                                   const TestResult& result) {
+  int failures = 0;
+  int skips = 0;
+  for (int i = 0; i < result.total_part_count(); ++i) {
+    const TestPartResult& part = result.GetTestPartResult(i);
+    if (part.failed()) {
+      if (++failures == 1 && skips == 0) {
+        *stream << ">\n";
+      }
+      const std::string location =
+          internal::FormatCompilerIndependentFileLocation(part.file_name(),
+                                                          part.line_number());
+      const std::string summary = location + "\n" + part.summary();
+      *stream << "      <failure message=\""
+              << EscapeXmlAttribute(summary)
+              << "\" type=\"\">";
+      const std::string detail = location + "\n" + part.message();
+      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
+      *stream << "</failure>\n";
+    } else if (part.skipped()) {
+      if (++skips == 1 && failures == 0) {
+        *stream << ">\n";
+      }
+      const std::string location =
+          internal::FormatCompilerIndependentFileLocation(part.file_name(),
+                                                          part.line_number());
+      const std::string summary = location + "\n" + part.summary();
+      *stream << "      <skipped message=\""
+              << EscapeXmlAttribute(summary.c_str()) << "\">";
+      const std::string detail = location + "\n" + part.message();
+      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
+      *stream << "</skipped>\n";
+    }
+  }
+
+  if (failures == 0 && skips == 0 && result.test_property_count() == 0) {
+    *stream << " />\n";
+  } else {
+    if (failures == 0 && skips == 0) {
+      *stream << ">\n";
+    }
+    OutputXmlTestProperties(stream, result);
+    *stream << "    </testcase>\n";
+  }
+}
+
+// Prints an XML representation of a TestSuite object
+void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
+                                                 const TestSuite& test_suite) {
+  const std::string kTestsuite = "testsuite";
+  *stream << "  <" << kTestsuite;
+  OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
+  OutputXmlAttribute(stream, kTestsuite, "tests",
+                     StreamableToString(test_suite.reportable_test_count()));
+  if (!GTEST_FLAG(list_tests)) {
+    OutputXmlAttribute(stream, kTestsuite, "failures",
+                       StreamableToString(test_suite.failed_test_count()));
+    OutputXmlAttribute(
+        stream, kTestsuite, "disabled",
+        StreamableToString(test_suite.reportable_disabled_test_count()));
+    OutputXmlAttribute(stream, kTestsuite, "skipped",
+                       StreamableToString(test_suite.skipped_test_count()));
+
+    OutputXmlAttribute(stream, kTestsuite, "errors", "0");
+
+    OutputXmlAttribute(stream, kTestsuite, "time",
+                       FormatTimeInMillisAsSeconds(test_suite.elapsed_time()));
+    OutputXmlAttribute(
+        stream, kTestsuite, "timestamp",
+        FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp()));
+    *stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result());
+  }
+  *stream << ">\n";
+  for (int i = 0; i < test_suite.total_test_count(); ++i) {
+    if (test_suite.GetTestInfo(i)->is_reportable())
+      OutputXmlTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
+  }
+  *stream << "  </" << kTestsuite << ">\n";
+}
+
+// Prints an XML summary of unit_test to output stream out.
+void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
+                                                const UnitTest& unit_test) {
+  const std::string kTestsuites = "testsuites";
+
+  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+  *stream << "<" << kTestsuites;
+
+  OutputXmlAttribute(stream, kTestsuites, "tests",
+                     StreamableToString(unit_test.reportable_test_count()));
+  OutputXmlAttribute(stream, kTestsuites, "failures",
+                     StreamableToString(unit_test.failed_test_count()));
+  OutputXmlAttribute(
+      stream, kTestsuites, "disabled",
+      StreamableToString(unit_test.reportable_disabled_test_count()));
+  OutputXmlAttribute(stream, kTestsuites, "errors", "0");
+  OutputXmlAttribute(stream, kTestsuites, "time",
+                     FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
+  OutputXmlAttribute(
+      stream, kTestsuites, "timestamp",
+      FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
+
+  if (GTEST_FLAG(shuffle)) {
+    OutputXmlAttribute(stream, kTestsuites, "random_seed",
+                       StreamableToString(unit_test.random_seed()));
+  }
+  *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());
+
+  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
+  *stream << ">\n";
+
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
+    if (unit_test.GetTestSuite(i)->reportable_test_count() > 0)
+      PrintXmlTestSuite(stream, *unit_test.GetTestSuite(i));
+  }
+
+  // If there was a test failure outside of one of the test suites (like in a
+  // test environment) include that in the output.
+  if (unit_test.ad_hoc_test_result().Failed()) {
+    OutputXmlTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
+  }
+
+  *stream << "</" << kTestsuites << ">\n";
+}
+
+void XmlUnitTestResultPrinter::PrintXmlTestsList(
+    std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
+  const std::string kTestsuites = "testsuites";
+
+  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+  *stream << "<" << kTestsuites;
+
+  int total_tests = 0;
+  for (auto test_suite : test_suites) {
+    total_tests += test_suite->total_test_count();
+  }
+  OutputXmlAttribute(stream, kTestsuites, "tests",
+                     StreamableToString(total_tests));
+  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
+  *stream << ">\n";
+
+  for (auto test_suite : test_suites) {
+    PrintXmlTestSuite(stream, *test_suite);
+  }
+  *stream << "</" << kTestsuites << ">\n";
+}
+
+// Produces a string representing the test properties in a result as space
+// delimited XML attributes based on the property key="value" pairs.
+std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
+    const TestResult& result) {
+  Message attributes;
+  for (int i = 0; i < result.test_property_count(); ++i) {
+    const TestProperty& property = result.GetTestProperty(i);
+    attributes << " " << property.key() << "="
+        << "\"" << EscapeXmlAttribute(property.value()) << "\"";
+  }
+  return attributes.GetString();
+}
+
+void XmlUnitTestResultPrinter::OutputXmlTestProperties(
+    std::ostream* stream, const TestResult& result) {
+  const std::string kProperties = "properties";
+  const std::string kProperty = "property";
+
+  if (result.test_property_count() <= 0) {
+    return;
+  }
+
+  *stream << "<" << kProperties << ">\n";
+  for (int i = 0; i < result.test_property_count(); ++i) {
+    const TestProperty& property = result.GetTestProperty(i);
+    *stream << "<" << kProperty;
+    *stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\"";
+    *stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\"";
+    *stream << "/>\n";
+  }
+  *stream << "</" << kProperties << ">\n";
+}
+
+// End XmlUnitTestResultPrinter
+
+// This class generates an JSON output file.
+class JsonUnitTestResultPrinter : public EmptyTestEventListener {
+ public:
+  explicit JsonUnitTestResultPrinter(const char* output_file);
+
+  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
+
+  // Prints an JSON summary of all unit tests.
+  static void PrintJsonTestList(::std::ostream* stream,
+                                const std::vector<TestSuite*>& test_suites);
+
+ private:
+  // Returns an JSON-escaped copy of the input string str.
+  static std::string EscapeJson(const std::string& str);
+
+  //// Verifies that the given attribute belongs to the given element and
+  //// streams the attribute as JSON.
+  static void OutputJsonKey(std::ostream* stream,
+                            const std::string& element_name,
+                            const std::string& name,
+                            const std::string& value,
+                            const std::string& indent,
+                            bool comma = true);
+  static void OutputJsonKey(std::ostream* stream,
+                            const std::string& element_name,
+                            const std::string& name,
+                            int value,
+                            const std::string& indent,
+                            bool comma = true);
+
+  // Streams a test suite JSON stanza containing the given test result.
+  //
+  // Requires: result.Failed()
+  static void OutputJsonTestSuiteForTestResult(::std::ostream* stream,
+                                               const TestResult& result);
+
+  // Streams a JSON representation of a TestResult object.
+  static void OutputJsonTestResult(::std::ostream* stream,
+                                   const TestResult& result);
+
+  // Streams a JSON representation of a TestInfo object.
+  static void OutputJsonTestInfo(::std::ostream* stream,
+                                 const char* test_suite_name,
+                                 const TestInfo& test_info);
+
+  // Prints a JSON representation of a TestSuite object
+  static void PrintJsonTestSuite(::std::ostream* stream,
+                                 const TestSuite& test_suite);
+
+  // Prints a JSON summary of unit_test to output stream out.
+  static void PrintJsonUnitTest(::std::ostream* stream,
+                                const UnitTest& unit_test);
+
+  // Produces a string representing the test properties in a result as
+  // a JSON dictionary.
+  static std::string TestPropertiesAsJson(const TestResult& result,
+                                          const std::string& indent);
+
+  // The output file.
+  const std::string output_file_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(JsonUnitTestResultPrinter);
+};
+
+// Creates a new JsonUnitTestResultPrinter.
+JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file)
+    : output_file_(output_file) {
+  if (output_file_.empty()) {
+    GTEST_LOG_(FATAL) << "JSON output file may not be null";
+  }
+}
+
+void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
+                                                  int /*iteration*/) {
+  FILE* jsonout = OpenFileForWriting(output_file_);
+  std::stringstream stream;
+  PrintJsonUnitTest(&stream, unit_test);
+  fprintf(jsonout, "%s", StringStreamToString(&stream).c_str());
+  fclose(jsonout);
+}
+
+// Returns an JSON-escaped copy of the input string str.
+std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {
+  Message m;
+
+  for (size_t i = 0; i < str.size(); ++i) {
+    const char ch = str[i];
+    switch (ch) {
+      case '\\':
+      case '"':
+      case '/':
+        m << '\\' << ch;
+        break;
+      case '\b':
+        m << "\\b";
+        break;
+      case '\t':
+        m << "\\t";
+        break;
+      case '\n':
+        m << "\\n";
+        break;
+      case '\f':
+        m << "\\f";
+        break;
+      case '\r':
+        m << "\\r";
+        break;
+      default:
+        if (ch < ' ') {
+          m << "\\u00" << String::FormatByte(static_cast<unsigned char>(ch));
+        } else {
+          m << ch;
+        }
+        break;
+    }
+  }
+
+  return m.GetString();
+}
+
+// The following routines generate an JSON representation of a UnitTest
+// object.
+
+// Formats the given time in milliseconds as seconds.
+static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
+  ::std::stringstream ss;
+  ss << (static_cast<double>(ms) * 1e-3) << "s";
+  return ss.str();
+}
+
+// Converts the given epoch time in milliseconds to a date string in the
+// RFC3339 format, without the timezone information.
+static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
+  struct tm time_struct;
+  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
+    return "";
+  // YYYY-MM-DDThh:mm:ss
+  return StreamableToString(time_struct.tm_year + 1900) + "-" +
+      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
+      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
+      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
+      String::FormatIntWidth2(time_struct.tm_min) + ":" +
+      String::FormatIntWidth2(time_struct.tm_sec) + "Z";
+}
+
+static inline std::string Indent(size_t width) {
+  return std::string(width, ' ');
+}
+
+void JsonUnitTestResultPrinter::OutputJsonKey(
+    std::ostream* stream,
+    const std::string& element_name,
+    const std::string& name,
+    const std::string& value,
+    const std::string& indent,
+    bool comma) {
+  const std::vector<std::string>& allowed_names =
+      GetReservedOutputAttributesForElement(element_name);
+
+  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
+                   allowed_names.end())
+      << "Key \"" << name << "\" is not allowed for value \"" << element_name
+      << "\".";
+
+  *stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\"";
+  if (comma)
+    *stream << ",\n";
+}
+
+void JsonUnitTestResultPrinter::OutputJsonKey(
+    std::ostream* stream,
+    const std::string& element_name,
+    const std::string& name,
+    int value,
+    const std::string& indent,
+    bool comma) {
+  const std::vector<std::string>& allowed_names =
+      GetReservedOutputAttributesForElement(element_name);
+
+  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
+                   allowed_names.end())
+      << "Key \"" << name << "\" is not allowed for value \"" << element_name
+      << "\".";
+
+  *stream << indent << "\"" << name << "\": " << StreamableToString(value);
+  if (comma)
+    *stream << ",\n";
+}
+
+// Streams a test suite JSON stanza containing the given test result.
+void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(
+    ::std::ostream* stream, const TestResult& result) {
+  // Output the boilerplate for a new test suite.
+  *stream << Indent(4) << "{\n";
+  OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6));
+  OutputJsonKey(stream, "testsuite", "tests", 1, Indent(6));
+  if (!GTEST_FLAG(list_tests)) {
+    OutputJsonKey(stream, "testsuite", "failures", 1, Indent(6));
+    OutputJsonKey(stream, "testsuite", "disabled", 0, Indent(6));
+    OutputJsonKey(stream, "testsuite", "skipped", 0, Indent(6));
+    OutputJsonKey(stream, "testsuite", "errors", 0, Indent(6));
+    OutputJsonKey(stream, "testsuite", "time",
+                  FormatTimeInMillisAsDuration(result.elapsed_time()),
+                  Indent(6));
+    OutputJsonKey(stream, "testsuite", "timestamp",
+                  FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
+                  Indent(6));
+  }
+  *stream << Indent(6) << "\"testsuite\": [\n";
+
+  // Output the boilerplate for a new test case.
+  *stream << Indent(8) << "{\n";
+  OutputJsonKey(stream, "testcase", "name", "", Indent(10));
+  OutputJsonKey(stream, "testcase", "status", "RUN", Indent(10));
+  OutputJsonKey(stream, "testcase", "result", "COMPLETED", Indent(10));
+  OutputJsonKey(stream, "testcase", "timestamp",
+                FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
+                Indent(10));
+  OutputJsonKey(stream, "testcase", "time",
+                FormatTimeInMillisAsDuration(result.elapsed_time()),
+                Indent(10));
+  OutputJsonKey(stream, "testcase", "classname", "", Indent(10), false);
+  *stream << TestPropertiesAsJson(result, Indent(10));
+
+  // Output the actual test result.
+  OutputJsonTestResult(stream, result);
+
+  // Finish the test suite.
+  *stream << "\n" << Indent(6) << "]\n" << Indent(4) << "}";
+}
+
+// Prints a JSON representation of a TestInfo object.
+void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
+                                                   const char* test_suite_name,
+                                                   const TestInfo& test_info) {
+  const TestResult& result = *test_info.result();
+  const std::string kTestsuite = "testcase";
+  const std::string kIndent = Indent(10);
+
+  *stream << Indent(8) << "{\n";
+  OutputJsonKey(stream, kTestsuite, "name", test_info.name(), kIndent);
+
+  if (test_info.value_param() != nullptr) {
+    OutputJsonKey(stream, kTestsuite, "value_param", test_info.value_param(),
+                  kIndent);
+  }
+  if (test_info.type_param() != nullptr) {
+    OutputJsonKey(stream, kTestsuite, "type_param", test_info.type_param(),
+                  kIndent);
+  }
+  if (GTEST_FLAG(list_tests)) {
+    OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent);
+    OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent, false);
+    *stream << "\n" << Indent(8) << "}";
+    return;
+  }
+
+  OutputJsonKey(stream, kTestsuite, "status",
+                test_info.should_run() ? "RUN" : "NOTRUN", kIndent);
+  OutputJsonKey(stream, kTestsuite, "result",
+                test_info.should_run()
+                    ? (result.Skipped() ? "SKIPPED" : "COMPLETED")
+                    : "SUPPRESSED",
+                kIndent);
+  OutputJsonKey(stream, kTestsuite, "timestamp",
+                FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
+                kIndent);
+  OutputJsonKey(stream, kTestsuite, "time",
+                FormatTimeInMillisAsDuration(result.elapsed_time()), kIndent);
+  OutputJsonKey(stream, kTestsuite, "classname", test_suite_name, kIndent,
+                false);
+  *stream << TestPropertiesAsJson(result, kIndent);
+
+  OutputJsonTestResult(stream, result);
+}
+
+void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,
+                                                     const TestResult& result) {
+  const std::string kIndent = Indent(10);
+
+  int failures = 0;
+  for (int i = 0; i < result.total_part_count(); ++i) {
+    const TestPartResult& part = result.GetTestPartResult(i);
+    if (part.failed()) {
+      *stream << ",\n";
+      if (++failures == 1) {
+        *stream << kIndent << "\"" << "failures" << "\": [\n";
+      }
+      const std::string location =
+          internal::FormatCompilerIndependentFileLocation(part.file_name(),
+                                                          part.line_number());
+      const std::string message = EscapeJson(location + "\n" + part.message());
+      *stream << kIndent << "  {\n"
+              << kIndent << "    \"failure\": \"" << message << "\",\n"
+              << kIndent << "    \"type\": \"\"\n"
+              << kIndent << "  }";
+    }
+  }
+
+  if (failures > 0)
+    *stream << "\n" << kIndent << "]";
+  *stream << "\n" << Indent(8) << "}";
+}
+
+// Prints an JSON representation of a TestSuite object
+void JsonUnitTestResultPrinter::PrintJsonTestSuite(
+    std::ostream* stream, const TestSuite& test_suite) {
+  const std::string kTestsuite = "testsuite";
+  const std::string kIndent = Indent(6);
+
+  *stream << Indent(4) << "{\n";
+  OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
+  OutputJsonKey(stream, kTestsuite, "tests", test_suite.reportable_test_count(),
+                kIndent);
+  if (!GTEST_FLAG(list_tests)) {
+    OutputJsonKey(stream, kTestsuite, "failures",
+                  test_suite.failed_test_count(), kIndent);
+    OutputJsonKey(stream, kTestsuite, "disabled",
+                  test_suite.reportable_disabled_test_count(), kIndent);
+    OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent);
+    OutputJsonKey(
+        stream, kTestsuite, "timestamp",
+        FormatEpochTimeInMillisAsRFC3339(test_suite.start_timestamp()),
+        kIndent);
+    OutputJsonKey(stream, kTestsuite, "time",
+                  FormatTimeInMillisAsDuration(test_suite.elapsed_time()),
+                  kIndent, false);
+    *stream << TestPropertiesAsJson(test_suite.ad_hoc_test_result(), kIndent)
+            << ",\n";
+  }
+
+  *stream << kIndent << "\"" << kTestsuite << "\": [\n";
+
+  bool comma = false;
+  for (int i = 0; i < test_suite.total_test_count(); ++i) {
+    if (test_suite.GetTestInfo(i)->is_reportable()) {
+      if (comma) {
+        *stream << ",\n";
+      } else {
+        comma = true;
+      }
+      OutputJsonTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
+    }
+  }
+  *stream << "\n" << kIndent << "]\n" << Indent(4) << "}";
+}
+
+// Prints a JSON summary of unit_test to output stream out.
+void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
+                                                  const UnitTest& unit_test) {
+  const std::string kTestsuites = "testsuites";
+  const std::string kIndent = Indent(2);
+  *stream << "{\n";
+
+  OutputJsonKey(stream, kTestsuites, "tests", unit_test.reportable_test_count(),
+                kIndent);
+  OutputJsonKey(stream, kTestsuites, "failures", unit_test.failed_test_count(),
+                kIndent);
+  OutputJsonKey(stream, kTestsuites, "disabled",
+                unit_test.reportable_disabled_test_count(), kIndent);
+  OutputJsonKey(stream, kTestsuites, "errors", 0, kIndent);
+  if (GTEST_FLAG(shuffle)) {
+    OutputJsonKey(stream, kTestsuites, "random_seed", unit_test.random_seed(),
+                  kIndent);
+  }
+  OutputJsonKey(stream, kTestsuites, "timestamp",
+                FormatEpochTimeInMillisAsRFC3339(unit_test.start_timestamp()),
+                kIndent);
+  OutputJsonKey(stream, kTestsuites, "time",
+                FormatTimeInMillisAsDuration(unit_test.elapsed_time()), kIndent,
+                false);
+
+  *stream << TestPropertiesAsJson(unit_test.ad_hoc_test_result(), kIndent)
+          << ",\n";
+
+  OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
+  *stream << kIndent << "\"" << kTestsuites << "\": [\n";
+
+  bool comma = false;
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
+    if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) {
+      if (comma) {
+        *stream << ",\n";
+      } else {
+        comma = true;
+      }
+      PrintJsonTestSuite(stream, *unit_test.GetTestSuite(i));
+    }
+  }
+
+  // If there was a test failure outside of one of the test suites (like in a
+  // test environment) include that in the output.
+  if (unit_test.ad_hoc_test_result().Failed()) {
+    OutputJsonTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
+  }
+
+  *stream << "\n" << kIndent << "]\n" << "}\n";
+}
+
+void JsonUnitTestResultPrinter::PrintJsonTestList(
+    std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
+  const std::string kTestsuites = "testsuites";
+  const std::string kIndent = Indent(2);
+  *stream << "{\n";
+  int total_tests = 0;
+  for (auto test_suite : test_suites) {
+    total_tests += test_suite->total_test_count();
+  }
+  OutputJsonKey(stream, kTestsuites, "tests", total_tests, kIndent);
+
+  OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
+  *stream << kIndent << "\"" << kTestsuites << "\": [\n";
+
+  for (size_t i = 0; i < test_suites.size(); ++i) {
+    if (i != 0) {
+      *stream << ",\n";
+    }
+    PrintJsonTestSuite(stream, *test_suites[i]);
+  }
+
+  *stream << "\n"
+          << kIndent << "]\n"
+          << "}\n";
+}
+// Produces a string representing the test properties in a result as
+// a JSON dictionary.
+std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
+    const TestResult& result, const std::string& indent) {
+  Message attributes;
+  for (int i = 0; i < result.test_property_count(); ++i) {
+    const TestProperty& property = result.GetTestProperty(i);
+    attributes << ",\n" << indent << "\"" << property.key() << "\": "
+               << "\"" << EscapeJson(property.value()) << "\"";
+  }
+  return attributes.GetString();
+}
+
+// End JsonUnitTestResultPrinter
+
+#if GTEST_CAN_STREAM_RESULTS_
+
+// Checks if str contains '=', '&', '%' or '\n' characters. If yes,
+// replaces them by "%xx" where xx is their hexadecimal value. For
+// example, replaces "=" with "%3D".  This algorithm is O(strlen(str))
+// in both time and space -- important as the input str may contain an
+// arbitrarily long test failure message and stack trace.
+std::string StreamingListener::UrlEncode(const char* str) {
+  std::string result;
+  result.reserve(strlen(str) + 1);
+  for (char ch = *str; ch != '\0'; ch = *++str) {
+    switch (ch) {
+      case '%':
+      case '=':
+      case '&':
+      case '\n':
+        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
+        break;
+      default:
+        result.push_back(ch);
+        break;
+    }
+  }
+  return result;
+}
+
+void StreamingListener::SocketWriter::MakeConnection() {
+  GTEST_CHECK_(sockfd_ == -1)
+      << "MakeConnection() can't be called when there is already a connection.";
+
+  addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;    // To allow both IPv4 and IPv6 addresses.
+  hints.ai_socktype = SOCK_STREAM;
+  addrinfo* servinfo = nullptr;
+
+  // Use the getaddrinfo() to get a linked list of IP addresses for
+  // the given host name.
+  const int error_num = getaddrinfo(
+      host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
+  if (error_num != 0) {
+    GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
+                        << gai_strerror(error_num);
+  }
+
+  // Loop through all the results and connect to the first we can.
+  for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr;
+       cur_addr = cur_addr->ai_next) {
+    sockfd_ = socket(
+        cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
+    if (sockfd_ != -1) {
+      // Connect the client socket to the server socket.
+      if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
+        close(sockfd_);
+        sockfd_ = -1;
+      }
+    }
+  }
+
+  freeaddrinfo(servinfo);  // all done with this structure
+
+  if (sockfd_ == -1) {
+    GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "
+                        << host_name_ << ":" << port_num_;
+  }
+}
+
+// End of class Streaming Listener
+#endif  // GTEST_CAN_STREAM_RESULTS__
+
+// class OsStackTraceGetter
+
+const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
+    "... " GTEST_NAME_ " internal frames ...";
+
+std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+#if GTEST_HAS_ABSL
+  std::string result;
+
+  if (max_depth <= 0) {
+    return result;
+  }
+
+  max_depth = std::min(max_depth, kMaxStackTraceDepth);
+
+  std::vector<void*> raw_stack(max_depth);
+  // Skips the frames requested by the caller, plus this function.
+  const int raw_stack_size =
+      absl::GetStackTrace(&raw_stack[0], max_depth, skip_count + 1);
+
+  void* caller_frame = nullptr;
+  {
+    MutexLock lock(&mutex_);
+    caller_frame = caller_frame_;
+  }
+
+  for (int i = 0; i < raw_stack_size; ++i) {
+    if (raw_stack[i] == caller_frame &&
+        !GTEST_FLAG(show_internal_stack_frames)) {
+      // Add a marker to the trace and stop adding frames.
+      absl::StrAppend(&result, kElidedFramesMarker, "\n");
+      break;
+    }
+
+    char tmp[1024];
+    const char* symbol = "(unknown)";
+    if (absl::Symbolize(raw_stack[i], tmp, sizeof(tmp))) {
+      symbol = tmp;
+    }
+
+    char line[1024];
+    snprintf(line, sizeof(line), "  %p: %s\n", raw_stack[i], symbol);
+    result += line;
+  }
+
+  return result;
+
+#else  // !GTEST_HAS_ABSL
+  static_cast<void>(max_depth);
+  static_cast<void>(skip_count);
+  return "";
+#endif  // GTEST_HAS_ABSL
+}
+
+void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
+#if GTEST_HAS_ABSL
+  void* caller_frame = nullptr;
+  if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
+    caller_frame = nullptr;
+  }
+
+  MutexLock lock(&mutex_);
+  caller_frame_ = caller_frame;
+#endif  // GTEST_HAS_ABSL
+}
+
+// A helper class that creates the premature-exit file in its
+// constructor and deletes the file in its destructor.
+class ScopedPrematureExitFile {
+ public:
+  explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
+      : premature_exit_filepath_(premature_exit_filepath ?
+                                 premature_exit_filepath : "") {
+    // If a path to the premature-exit file is specified...
+    if (!premature_exit_filepath_.empty()) {
+      // create the file with a single "0" character in it.  I/O
+      // errors are ignored as there's nothing better we can do and we
+      // don't want to fail the test because of this.
+      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
+      fwrite("0", 1, 1, pfile);
+      fclose(pfile);
+    }
+  }
+
+  ~ScopedPrematureExitFile() {
+#if !defined GTEST_OS_ESP8266
+    if (!premature_exit_filepath_.empty()) {
+      int retval = remove(premature_exit_filepath_.c_str());
+      if (retval) {
+        GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""
+                          << premature_exit_filepath_ << "\" with error "
+                          << retval;
+      }
+    }
+#endif
+  }
+
+ private:
+  const std::string premature_exit_filepath_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
+};
+
+}  // namespace internal
+
+// class TestEventListeners
+
+TestEventListeners::TestEventListeners()
+    : repeater_(new internal::TestEventRepeater()),
+      default_result_printer_(nullptr),
+      default_xml_generator_(nullptr) {}
+
+TestEventListeners::~TestEventListeners() { delete repeater_; }
+
+// Returns the standard listener responsible for the default console
+// output.  Can be removed from the listeners list to shut down default
+// console output.  Note that removing this object from the listener list
+// with Release transfers its ownership to the user.
+void TestEventListeners::Append(TestEventListener* listener) {
+  repeater_->Append(listener);
+}
+
+// Removes the given event listener from the list and returns it.  It then
+// becomes the caller's responsibility to delete the listener. Returns
+// NULL if the listener is not found in the list.
+TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
+  if (listener == default_result_printer_)
+    default_result_printer_ = nullptr;
+  else if (listener == default_xml_generator_)
+    default_xml_generator_ = nullptr;
+  return repeater_->Release(listener);
+}
+
+// Returns repeater that broadcasts the TestEventListener events to all
+// subscribers.
+TestEventListener* TestEventListeners::repeater() { return repeater_; }
+
+// Sets the default_result_printer attribute to the provided listener.
+// The listener is also added to the listener list and previous
+// default_result_printer is removed from it and deleted. The listener can
+// also be NULL in which case it will not be added to the list. Does
+// nothing if the previous and the current listener objects are the same.
+void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
+  if (default_result_printer_ != listener) {
+    // It is an error to pass this method a listener that is already in the
+    // list.
+    delete Release(default_result_printer_);
+    default_result_printer_ = listener;
+    if (listener != nullptr) Append(listener);
+  }
+}
+
+// Sets the default_xml_generator attribute to the provided listener.  The
+// listener is also added to the listener list and previous
+// default_xml_generator is removed from it and deleted. The listener can
+// also be NULL in which case it will not be added to the list. Does
+// nothing if the previous and the current listener objects are the same.
+void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
+  if (default_xml_generator_ != listener) {
+    // It is an error to pass this method a listener that is already in the
+    // list.
+    delete Release(default_xml_generator_);
+    default_xml_generator_ = listener;
+    if (listener != nullptr) Append(listener);
+  }
+}
+
+// Controls whether events will be forwarded by the repeater to the
+// listeners in the list.
+bool TestEventListeners::EventForwardingEnabled() const {
+  return repeater_->forwarding_enabled();
+}
+
+void TestEventListeners::SuppressEventForwarding() {
+  repeater_->set_forwarding_enabled(false);
+}
+
+// class UnitTest
+
+// Gets the singleton UnitTest object.  The first time this method is
+// called, a UnitTest object is constructed and returned.  Consecutive
+// calls will return the same object.
+//
+// We don't protect this under mutex_ as a user is not supposed to
+// call this before main() starts, from which point on the return
+// value will never change.
+UnitTest* UnitTest::GetInstance() {
+  // CodeGear C++Builder insists on a public destructor for the
+  // default implementation.  Use this implementation to keep good OO
+  // design with private destructor.
+
+#if defined(__BORLANDC__)
+  static UnitTest* const instance = new UnitTest;
+  return instance;
+#else
+  static UnitTest instance;
+  return &instance;
+#endif  // defined(__BORLANDC__)
+}
+
+// Gets the number of successful test suites.
+int UnitTest::successful_test_suite_count() const {
+  return impl()->successful_test_suite_count();
+}
+
+// Gets the number of failed test suites.
+int UnitTest::failed_test_suite_count() const {
+  return impl()->failed_test_suite_count();
+}
+
+// Gets the number of all test suites.
+int UnitTest::total_test_suite_count() const {
+  return impl()->total_test_suite_count();
+}
+
+// Gets the number of all test suites that contain at least one test
+// that should run.
+int UnitTest::test_suite_to_run_count() const {
+  return impl()->test_suite_to_run_count();
+}
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+int UnitTest::successful_test_case_count() const {
+  return impl()->successful_test_suite_count();
+}
+int UnitTest::failed_test_case_count() const {
+  return impl()->failed_test_suite_count();
+}
+int UnitTest::total_test_case_count() const {
+  return impl()->total_test_suite_count();
+}
+int UnitTest::test_case_to_run_count() const {
+  return impl()->test_suite_to_run_count();
+}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+// Gets the number of successful tests.
+int UnitTest::successful_test_count() const {
+  return impl()->successful_test_count();
+}
+
+// Gets the number of skipped tests.
+int UnitTest::skipped_test_count() const {
+  return impl()->skipped_test_count();
+}
+
+// Gets the number of failed tests.
+int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }
+
+// Gets the number of disabled tests that will be reported in the XML report.
+int UnitTest::reportable_disabled_test_count() const {
+  return impl()->reportable_disabled_test_count();
+}
+
+// Gets the number of disabled tests.
+int UnitTest::disabled_test_count() const {
+  return impl()->disabled_test_count();
+}
+
+// Gets the number of tests to be printed in the XML report.
+int UnitTest::reportable_test_count() const {
+  return impl()->reportable_test_count();
+}
+
+// Gets the number of all tests.
+int UnitTest::total_test_count() const { return impl()->total_test_count(); }
+
+// Gets the number of tests that should run.
+int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
+
+// Gets the time of the test program start, in ms from the start of the
+// UNIX epoch.
+internal::TimeInMillis UnitTest::start_timestamp() const {
+    return impl()->start_timestamp();
+}
+
+// Gets the elapsed time, in milliseconds.
+internal::TimeInMillis UnitTest::elapsed_time() const {
+  return impl()->elapsed_time();
+}
+
+// Returns true if and only if the unit test passed (i.e. all test suites
+// passed).
+bool UnitTest::Passed() const { return impl()->Passed(); }
+
+// Returns true if and only if the unit test failed (i.e. some test suite
+// failed or something outside of all tests failed).
+bool UnitTest::Failed() const { return impl()->Failed(); }
+
+// Gets the i-th test suite among all the test suites. i can range from 0 to
+// total_test_suite_count() - 1. If i is not in that range, returns NULL.
+const TestSuite* UnitTest::GetTestSuite(int i) const {
+  return impl()->GetTestSuite(i);
+}
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+const TestCase* UnitTest::GetTestCase(int i) const {
+  return impl()->GetTestCase(i);
+}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+// Returns the TestResult containing information on test failures and
+// properties logged outside of individual test suites.
+const TestResult& UnitTest::ad_hoc_test_result() const {
+  return *impl()->ad_hoc_test_result();
+}
+
+// Gets the i-th test suite among all the test suites. i can range from 0 to
+// total_test_suite_count() - 1. If i is not in that range, returns NULL.
+TestSuite* UnitTest::GetMutableTestSuite(int i) {
+  return impl()->GetMutableSuiteCase(i);
+}
+
+// Returns the list of event listeners that can be used to track events
+// inside Google Test.
+TestEventListeners& UnitTest::listeners() {
+  return *impl()->listeners();
+}
+
+// Registers and returns a global test environment.  When a test
+// program is run, all global test environments will be set-up in the
+// order they were registered.  After all tests in the program have
+// finished, all global test environments will be torn-down in the
+// *reverse* order they were registered.
+//
+// The UnitTest object takes ownership of the given environment.
+//
+// We don't protect this under mutex_, as we only support calling it
+// from the main thread.
+Environment* UnitTest::AddEnvironment(Environment* env) {
+  if (env == nullptr) {
+    return nullptr;
+  }
+
+  impl_->environments().push_back(env);
+  return env;
+}
+
+// Adds a TestPartResult to the current TestResult object.  All Google Test
+// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
+// this to report their results.  The user code should use the
+// assertion macros instead of calling this directly.
+void UnitTest::AddTestPartResult(
+    TestPartResult::Type result_type,
+    const char* file_name,
+    int line_number,
+    const std::string& message,
+    const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
+  Message msg;
+  msg << message;
+
+  internal::MutexLock lock(&mutex_);
+  if (impl_->gtest_trace_stack().size() > 0) {
+    msg << "\n" << GTEST_NAME_ << " trace:";
+
+    for (size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) {
+      const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1];
+      msg << "\n" << internal::FormatFileLocation(trace.file, trace.line)
+          << " " << trace.message;
+    }
+  }
+
+  if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) {
+    msg << internal::kStackTraceMarker << os_stack_trace;
+  }
+
+  const TestPartResult result = TestPartResult(
+      result_type, file_name, line_number, msg.GetString().c_str());
+  impl_->GetTestPartResultReporterForCurrentThread()->
+      ReportTestPartResult(result);
+
+  if (result_type != TestPartResult::kSuccess &&
+      result_type != TestPartResult::kSkip) {
+    // gtest_break_on_failure takes precedence over
+    // gtest_throw_on_failure.  This allows a user to set the latter
+    // in the code (perhaps in order to use Google Test assertions
+    // with another testing framework) and specify the former on the
+    // command line for debugging.
+    if (GTEST_FLAG(break_on_failure)) {
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+      // Using DebugBreak on Windows allows gtest to still break into a debugger
+      // when a failure happens and both the --gtest_break_on_failure and
+      // the --gtest_catch_exceptions flags are specified.
+      DebugBreak();
+#elif (!defined(__native_client__)) &&            \
+    ((defined(__clang__) || defined(__GNUC__)) && \
+     (defined(__x86_64__) || defined(__i386__)))
+      // with clang/gcc we can achieve the same effect on x86 by invoking int3
+      asm("int3");
+#else
+      // Dereference nullptr through a volatile pointer to prevent the compiler
+      // from removing. We use this rather than abort() or __builtin_trap() for
+      // portability: some debuggers don't correctly trap abort().
+      *static_cast<volatile int*>(nullptr) = 1;
+#endif  // GTEST_OS_WINDOWS
+    } else if (GTEST_FLAG(throw_on_failure)) {
+#if GTEST_HAS_EXCEPTIONS
+      throw internal::GoogleTestFailureException(result);
+#else
+      // We cannot call abort() as it generates a pop-up in debug mode
+      // that cannot be suppressed in VC 7.1 or below.
+      exit(1);
+#endif
+    }
+  }
+}
+
+// Adds a TestProperty to the current TestResult object when invoked from
+// inside a test, to current TestSuite's ad_hoc_test_result_ when invoked
+// from SetUpTestSuite or TearDownTestSuite, or to the global property set
+// when invoked elsewhere.  If the result already contains a property with
+// the same key, the value will be updated.
+void UnitTest::RecordProperty(const std::string& key,
+                              const std::string& value) {
+  impl_->RecordProperty(TestProperty(key, value));
+}
+
+// Runs all tests in this UnitTest object and prints the result.
+// Returns 0 if successful, or 1 otherwise.
+//
+// We don't protect this under mutex_, as we only support calling it
+// from the main thread.
+int UnitTest::Run() {
+  const bool in_death_test_child_process =
+      internal::GTEST_FLAG(internal_run_death_test).length() > 0;
+
+  // Google Test implements this protocol for catching that a test
+  // program exits before returning control to Google Test:
+  //
+  //   1. Upon start, Google Test creates a file whose absolute path
+  //      is specified by the environment variable
+  //      TEST_PREMATURE_EXIT_FILE.
+  //   2. When Google Test has finished its work, it deletes the file.
+  //
+  // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
+  // running a Google-Test-based test program and check the existence
+  // of the file at the end of the test execution to see if it has
+  // exited prematurely.
+
+  // If we are in the child process of a death test, don't
+  // create/delete the premature exit file, as doing so is unnecessary
+  // and will confuse the parent process.  Otherwise, create/delete
+  // the file upon entering/leaving this function.  If the program
+  // somehow exits before this function has a chance to return, the
+  // premature-exit file will be left undeleted, causing a test runner
+  // that understands the premature-exit-file protocol to report the
+  // test as having failed.
+  const internal::ScopedPrematureExitFile premature_exit_file(
+      in_death_test_child_process
+          ? nullptr
+          : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
+
+  // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
+  // used for the duration of the program.
+  impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
+
+#if GTEST_OS_WINDOWS
+  // Either the user wants Google Test to catch exceptions thrown by the
+  // tests or this is executing in the context of death test child
+  // process. In either case the user does not want to see pop-up dialogs
+  // about crashes - they are expected.
+  if (impl()->catch_exceptions() || in_death_test_child_process) {
+# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+    // SetErrorMode doesn't exist on CE.
+    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
+                 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
+# endif  // !GTEST_OS_WINDOWS_MOBILE
+
+# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
+    // Death test children can be terminated with _abort().  On Windows,
+    // _abort() can show a dialog with a warning message.  This forces the
+    // abort message to go to stderr instead.
+    _set_error_mode(_OUT_TO_STDERR);
+# endif
+
+# if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
+    // In the debug version, Visual Studio pops up a separate dialog
+    // offering a choice to debug the aborted program. We need to suppress
+    // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
+    // executed. Google Test will notify the user of any unexpected
+    // failure via stderr.
+    if (!GTEST_FLAG(break_on_failure))
+      _set_abort_behavior(
+          0x0,                                    // Clear the following flags:
+          _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
+
+    // In debug mode, the Windows CRT can crash with an assertion over invalid
+    // input (e.g. passing an invalid file descriptor).  The default handling
+    // for these assertions is to pop up a dialog and wait for user input.
+    // Instead ask the CRT to dump such assertions to stderr non-interactively.
+    if (!IsDebuggerPresent()) {
+      (void)_CrtSetReportMode(_CRT_ASSERT,
+                              _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+      (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
+    }
+# endif
+  }
+#endif  // GTEST_OS_WINDOWS
+
+  return internal::HandleExceptionsInMethodIfSupported(
+      impl(),
+      &internal::UnitTestImpl::RunAllTests,
+      "auxiliary test code (environments or event listeners)") ? 0 : 1;
+}
+
+// Returns the working directory when the first TEST() or TEST_F() was
+// executed.
+const char* UnitTest::original_working_dir() const {
+  return impl_->original_working_dir_.c_str();
+}
+
+// Returns the TestSuite object for the test that's currently running,
+// or NULL if no test is running.
+const TestSuite* UnitTest::current_test_suite() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  return impl_->current_test_suite();
+}
+
+// Legacy API is still available but deprecated
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+const TestCase* UnitTest::current_test_case() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  return impl_->current_test_suite();
+}
+#endif
+
+// Returns the TestInfo object for the test that's currently running,
+// or NULL if no test is running.
+const TestInfo* UnitTest::current_test_info() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  return impl_->current_test_info();
+}
+
+// Returns the random seed used at the start of the current test run.
+int UnitTest::random_seed() const { return impl_->random_seed(); }
+
+// Returns ParameterizedTestSuiteRegistry object used to keep track of
+// value-parameterized tests and instantiate and register them.
+internal::ParameterizedTestSuiteRegistry&
+UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) {
+  return impl_->parameterized_test_registry();
+}
+
+// Creates an empty UnitTest.
+UnitTest::UnitTest() {
+  impl_ = new internal::UnitTestImpl(this);
+}
+
+// Destructor of UnitTest.
+UnitTest::~UnitTest() {
+  delete impl_;
+}
+
+// Pushes a trace defined by SCOPED_TRACE() on to the per-thread
+// Google Test trace stack.
+void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  impl_->gtest_trace_stack().push_back(trace);
+}
+
+// Pops a trace from the per-thread Google Test trace stack.
+void UnitTest::PopGTestTrace()
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  impl_->gtest_trace_stack().pop_back();
+}
+
+namespace internal {
+
+UnitTestImpl::UnitTestImpl(UnitTest* parent)
+    : parent_(parent),
+      GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
+          default_global_test_part_result_reporter_(this),
+      default_per_thread_test_part_result_reporter_(this),
+      GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_(
+          &default_global_test_part_result_reporter_),
+      per_thread_test_part_result_reporter_(
+          &default_per_thread_test_part_result_reporter_),
+      parameterized_test_registry_(),
+      parameterized_tests_registered_(false),
+      last_death_test_suite_(-1),
+      current_test_suite_(nullptr),
+      current_test_info_(nullptr),
+      ad_hoc_test_result_(),
+      os_stack_trace_getter_(nullptr),
+      post_flag_parse_init_performed_(false),
+      random_seed_(0),  // Will be overridden by the flag before first use.
+      random_(0),       // Will be reseeded before first use.
+      start_timestamp_(0),
+      elapsed_time_(0),
+#if GTEST_HAS_DEATH_TEST
+      death_test_factory_(new DefaultDeathTestFactory),
+#endif
+      // Will be overridden by the flag before first use.
+      catch_exceptions_(false) {
+  listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
+}
+
+UnitTestImpl::~UnitTestImpl() {
+  // Deletes every TestSuite.
+  ForEach(test_suites_, internal::Delete<TestSuite>);
+
+  // Deletes every Environment.
+  ForEach(environments_, internal::Delete<Environment>);
+
+  delete os_stack_trace_getter_;
+}
+
+// Adds a TestProperty to the current TestResult object when invoked in a
+// context of a test, to current test suite's ad_hoc_test_result when invoke
+// from SetUpTestSuite/TearDownTestSuite, or to the global property set
+// otherwise.  If the result already contains a property with the same key,
+// the value will be updated.
+void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
+  std::string xml_element;
+  TestResult* test_result;  // TestResult appropriate for property recording.
+
+  if (current_test_info_ != nullptr) {
+    xml_element = "testcase";
+    test_result = &(current_test_info_->result_);
+  } else if (current_test_suite_ != nullptr) {
+    xml_element = "testsuite";
+    test_result = &(current_test_suite_->ad_hoc_test_result_);
+  } else {
+    xml_element = "testsuites";
+    test_result = &ad_hoc_test_result_;
+  }
+  test_result->RecordProperty(xml_element, test_property);
+}
+
+#if GTEST_HAS_DEATH_TEST
+// Disables event forwarding if the control is currently in a death test
+// subprocess. Must not be called before InitGoogleTest.
+void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
+  if (internal_run_death_test_flag_.get() != nullptr)
+    listeners()->SuppressEventForwarding();
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Initializes event listeners performing XML output as specified by
+// UnitTestOptions. Must not be called before InitGoogleTest.
+void UnitTestImpl::ConfigureXmlOutput() {
+  const std::string& output_format = UnitTestOptions::GetOutputFormat();
+  if (output_format == "xml") {
+    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
+        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
+  } else if (output_format == "json") {
+    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
+        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
+  } else if (output_format != "") {
+    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
+                        << output_format << "\" ignored.";
+  }
+}
+
+#if GTEST_CAN_STREAM_RESULTS_
+// Initializes event listeners for streaming test results in string form.
+// Must not be called before InitGoogleTest.
+void UnitTestImpl::ConfigureStreamingOutput() {
+  const std::string& target = GTEST_FLAG(stream_result_to);
+  if (!target.empty()) {
+    const size_t pos = target.find(':');
+    if (pos != std::string::npos) {
+      listeners()->Append(new StreamingListener(target.substr(0, pos),
+                                                target.substr(pos+1)));
+    } else {
+      GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target
+                          << "\" ignored.";
+    }
+  }
+}
+#endif  // GTEST_CAN_STREAM_RESULTS_
+
+// Performs initialization dependent upon flag values obtained in
+// ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
+// ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
+// this function is also called from RunAllTests.  Since this function can be
+// called more than once, it has to be idempotent.
+void UnitTestImpl::PostFlagParsingInit() {
+  // Ensures that this function does not execute more than once.
+  if (!post_flag_parse_init_performed_) {
+    post_flag_parse_init_performed_ = true;
+
+#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
+    // Register to send notifications about key process state changes.
+    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
+#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
+
+#if GTEST_HAS_DEATH_TEST
+    InitDeathTestSubprocessControlInfo();
+    SuppressTestEventsIfInSubprocess();
+#endif  // GTEST_HAS_DEATH_TEST
+
+    // Registers parameterized tests. This makes parameterized tests
+    // available to the UnitTest reflection API without running
+    // RUN_ALL_TESTS.
+    RegisterParameterizedTests();
+
+    // Configures listeners for XML output. This makes it possible for users
+    // to shut down the default XML output before invoking RUN_ALL_TESTS.
+    ConfigureXmlOutput();
+
+    if (GTEST_FLAG(brief)) {
+      listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter);
+    }
+
+#if GTEST_CAN_STREAM_RESULTS_
+    // Configures listeners for streaming test results to the specified server.
+    ConfigureStreamingOutput();
+#endif  // GTEST_CAN_STREAM_RESULTS_
+
+#if GTEST_HAS_ABSL
+    if (GTEST_FLAG(install_failure_signal_handler)) {
+      absl::FailureSignalHandlerOptions options;
+      absl::InstallFailureSignalHandler(options);
+    }
+#endif  // GTEST_HAS_ABSL
+  }
+}
+
+// A predicate that checks the name of a TestSuite against a known
+// value.
+//
+// This is used for implementation of the UnitTest class only.  We put
+// it in the anonymous namespace to prevent polluting the outer
+// namespace.
+//
+// TestSuiteNameIs is copyable.
+class TestSuiteNameIs {
+ public:
+  // Constructor.
+  explicit TestSuiteNameIs(const std::string& name) : name_(name) {}
+
+  // Returns true if and only if the name of test_suite matches name_.
+  bool operator()(const TestSuite* test_suite) const {
+    return test_suite != nullptr &&
+           strcmp(test_suite->name(), name_.c_str()) == 0;
+  }
+
+ private:
+  std::string name_;
+};
+
+// Finds and returns a TestSuite with the given name.  If one doesn't
+// exist, creates one and returns it.  It's the CALLER'S
+// RESPONSIBILITY to ensure that this function is only called WHEN THE
+// TESTS ARE NOT SHUFFLED.
+//
+// Arguments:
+//
+//   test_suite_name: name of the test suite
+//   type_param:      the name of the test suite's type parameter, or NULL if
+//                    this is not a typed or a type-parameterized test suite.
+//   set_up_tc:       pointer to the function that sets up the test suite
+//   tear_down_tc:    pointer to the function that tears down the test suite
+TestSuite* UnitTestImpl::GetTestSuite(
+    const char* test_suite_name, const char* type_param,
+    internal::SetUpTestSuiteFunc set_up_tc,
+    internal::TearDownTestSuiteFunc tear_down_tc) {
+  // Can we find a TestSuite with the given name?
+  const auto test_suite =
+      std::find_if(test_suites_.rbegin(), test_suites_.rend(),
+                   TestSuiteNameIs(test_suite_name));
+
+  if (test_suite != test_suites_.rend()) return *test_suite;
+
+  // No.  Let's create one.
+  auto* const new_test_suite =
+      new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
+
+  // Is this a death test suite?
+  if (internal::UnitTestOptions::MatchesFilter(test_suite_name,
+                                               kDeathTestSuiteFilter)) {
+    // Yes.  Inserts the test suite after the last death test suite
+    // defined so far.  This only works when the test suites haven't
+    // been shuffled.  Otherwise we may end up running a death test
+    // after a non-death test.
+    ++last_death_test_suite_;
+    test_suites_.insert(test_suites_.begin() + last_death_test_suite_,
+                        new_test_suite);
+  } else {
+    // No.  Appends to the end of the list.
+    test_suites_.push_back(new_test_suite);
+  }
+
+  test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size()));
+  return new_test_suite;
+}
+
+// Helpers for setting up / tearing down the given environment.  They
+// are for use in the ForEach() function.
+static void SetUpEnvironment(Environment* env) { env->SetUp(); }
+static void TearDownEnvironment(Environment* env) { env->TearDown(); }
+
+// Runs all tests in this UnitTest object, prints the result, and
+// returns true if all tests are successful.  If any exception is
+// thrown during a test, the test is considered to be failed, but the
+// rest of the tests will still be run.
+//
+// When parameterized tests are enabled, it expands and registers
+// parameterized tests first in RegisterParameterizedTests().
+// All other functions called from RunAllTests() may safely assume that
+// parameterized tests are ready to be counted and run.
+bool UnitTestImpl::RunAllTests() {
+  // True if and only if Google Test is initialized before RUN_ALL_TESTS() is
+  // called.
+  const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
+
+  // Do not run any test if the --help flag was specified.
+  if (g_help_flag)
+    return true;
+
+  // Repeats the call to the post-flag parsing initialization in case the
+  // user didn't call InitGoogleTest.
+  PostFlagParsingInit();
+
+  // Even if sharding is not on, test runners may want to use the
+  // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
+  // protocol.
+  internal::WriteToShardStatusFileIfNeeded();
+
+  // True if and only if we are in a subprocess for running a thread-safe-style
+  // death test.
+  bool in_subprocess_for_death_test = false;
+
+#if GTEST_HAS_DEATH_TEST
+  in_subprocess_for_death_test =
+      (internal_run_death_test_flag_.get() != nullptr);
+# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
+  if (in_subprocess_for_death_test) {
+    GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
+  }
+# endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
+#endif  // GTEST_HAS_DEATH_TEST
+
+  const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
+                                        in_subprocess_for_death_test);
+
+  // Compares the full test names with the filter to decide which
+  // tests to run.
+  const bool has_tests_to_run = FilterTests(should_shard
+                                              ? HONOR_SHARDING_PROTOCOL
+                                              : IGNORE_SHARDING_PROTOCOL) > 0;
+
+  // Lists the tests and exits if the --gtest_list_tests flag was specified.
+  if (GTEST_FLAG(list_tests)) {
+    // This must be called *after* FilterTests() has been called.
+    ListTestsMatchingFilter();
+    return true;
+  }
+
+  random_seed_ = GTEST_FLAG(shuffle) ?
+      GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
+
+  // True if and only if at least one test has failed.
+  bool failed = false;
+
+  TestEventListener* repeater = listeners()->repeater();
+
+  start_timestamp_ = GetTimeInMillis();
+  repeater->OnTestProgramStart(*parent_);
+
+  // How many times to repeat the tests?  We don't want to repeat them
+  // when we are inside the subprocess of a death test.
+  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
+  // Repeats forever if the repeat count is negative.
+  const bool gtest_repeat_forever = repeat < 0;
+  for (int i = 0; gtest_repeat_forever || i != repeat; i++) {
+    // We want to preserve failures generated by ad-hoc test
+    // assertions executed before RUN_ALL_TESTS().
+    ClearNonAdHocTestResult();
+
+    Timer timer;
+
+    // Shuffles test suites and tests if requested.
+    if (has_tests_to_run && GTEST_FLAG(shuffle)) {
+      random()->Reseed(static_cast<uint32_t>(random_seed_));
+      // This should be done before calling OnTestIterationStart(),
+      // such that a test event listener can see the actual test order
+      // in the event.
+      ShuffleTests();
+    }
+
+    // Tells the unit test event listeners that the tests are about to start.
+    repeater->OnTestIterationStart(*parent_, i);
+
+    // Runs each test suite if there is at least one test to run.
+    if (has_tests_to_run) {
+      // Sets up all environments beforehand.
+      repeater->OnEnvironmentsSetUpStart(*parent_);
+      ForEach(environments_, SetUpEnvironment);
+      repeater->OnEnvironmentsSetUpEnd(*parent_);
+
+      // Runs the tests only if there was no fatal failure or skip triggered
+      // during global set-up.
+      if (Test::IsSkipped()) {
+        // Emit diagnostics when global set-up calls skip, as it will not be
+        // emitted by default.
+        TestResult& test_result =
+            *internal::GetUnitTestImpl()->current_test_result();
+        for (int j = 0; j < test_result.total_part_count(); ++j) {
+          const TestPartResult& test_part_result =
+              test_result.GetTestPartResult(j);
+          if (test_part_result.type() == TestPartResult::kSkip) {
+            const std::string& result = test_part_result.message();
+            printf("%s\n", result.c_str());
+          }
+        }
+        fflush(stdout);
+      } else if (!Test::HasFatalFailure()) {
+        for (int test_index = 0; test_index < total_test_suite_count();
+             test_index++) {
+          GetMutableSuiteCase(test_index)->Run();
+          if (GTEST_FLAG(fail_fast) &&
+              GetMutableSuiteCase(test_index)->Failed()) {
+            for (int j = test_index + 1; j < total_test_suite_count(); j++) {
+              GetMutableSuiteCase(j)->Skip();
+            }
+            break;
+          }
+        }
+      } else if (Test::HasFatalFailure()) {
+        // If there was a fatal failure during the global setup then we know we
+        // aren't going to run any tests. Explicitly mark all of the tests as
+        // skipped to make this obvious in the output.
+        for (int test_index = 0; test_index < total_test_suite_count();
+             test_index++) {
+          GetMutableSuiteCase(test_index)->Skip();
+        }
+      }
+
+      // Tears down all environments in reverse order afterwards.
+      repeater->OnEnvironmentsTearDownStart(*parent_);
+      std::for_each(environments_.rbegin(), environments_.rend(),
+                    TearDownEnvironment);
+      repeater->OnEnvironmentsTearDownEnd(*parent_);
+    }
+
+    elapsed_time_ = timer.Elapsed();
+
+    // Tells the unit test event listener that the tests have just finished.
+    repeater->OnTestIterationEnd(*parent_, i);
+
+    // Gets the result and clears it.
+    if (!Passed()) {
+      failed = true;
+    }
+
+    // Restores the original test order after the iteration.  This
+    // allows the user to quickly repro a failure that happens in the
+    // N-th iteration without repeating the first (N - 1) iterations.
+    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
+    // case the user somehow changes the value of the flag somewhere
+    // (it's always safe to unshuffle the tests).
+    UnshuffleTests();
+
+    if (GTEST_FLAG(shuffle)) {
+      // Picks a new random seed for each iteration.
+      random_seed_ = GetNextRandomSeed(random_seed_);
+    }
+  }
+
+  repeater->OnTestProgramEnd(*parent_);
+
+  if (!gtest_is_initialized_before_run_all_tests) {
+    ColoredPrintf(
+        GTestColor::kRed,
+        "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
+        "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
+        "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
+        " will start to enforce the valid usage. "
+        "Please fix it ASAP, or IT WILL START TO FAIL.\n");  // NOLINT
+#if GTEST_FOR_GOOGLE_
+    ColoredPrintf(GTestColor::kRed,
+                  "For more details, see http://wiki/Main/ValidGUnitMain.\n");
+#endif  // GTEST_FOR_GOOGLE_
+  }
+
+  return !failed;
+}
+
+// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
+// if the variable is present. If a file already exists at this location, this
+// function will write over it. If the variable is present, but the file cannot
+// be created, prints an error and exits.
+void WriteToShardStatusFileIfNeeded() {
+  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
+  if (test_shard_file != nullptr) {
+    FILE* const file = posix::FOpen(test_shard_file, "w");
+    if (file == nullptr) {
+      ColoredPrintf(GTestColor::kRed,
+                    "Could not write to the test shard status file \"%s\" "
+                    "specified by the %s environment variable.\n",
+                    test_shard_file, kTestShardStatusFile);
+      fflush(stdout);
+      exit(EXIT_FAILURE);
+    }
+    fclose(file);
+  }
+}
+
+// Checks whether sharding is enabled by examining the relevant
+// environment variable values. If the variables are present,
+// but inconsistent (i.e., shard_index >= total_shards), prints
+// an error and exits. If in_subprocess_for_death_test, sharding is
+// disabled because it must only be applied to the original test
+// process. Otherwise, we could filter out death tests we intended to execute.
+bool ShouldShard(const char* total_shards_env,
+                 const char* shard_index_env,
+                 bool in_subprocess_for_death_test) {
+  if (in_subprocess_for_death_test) {
+    return false;
+  }
+
+  const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
+  const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1);
+
+  if (total_shards == -1 && shard_index == -1) {
+    return false;
+  } else if (total_shards == -1 && shard_index != -1) {
+    const Message msg = Message()
+      << "Invalid environment variables: you have "
+      << kTestShardIndex << " = " << shard_index
+      << ", but have left " << kTestTotalShards << " unset.\n";
+    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
+    fflush(stdout);
+    exit(EXIT_FAILURE);
+  } else if (total_shards != -1 && shard_index == -1) {
+    const Message msg = Message()
+      << "Invalid environment variables: you have "
+      << kTestTotalShards << " = " << total_shards
+      << ", but have left " << kTestShardIndex << " unset.\n";
+    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
+    fflush(stdout);
+    exit(EXIT_FAILURE);
+  } else if (shard_index < 0 || shard_index >= total_shards) {
+    const Message msg = Message()
+      << "Invalid environment variables: we require 0 <= "
+      << kTestShardIndex << " < " << kTestTotalShards
+      << ", but you have " << kTestShardIndex << "=" << shard_index
+      << ", " << kTestTotalShards << "=" << total_shards << ".\n";
+    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
+    fflush(stdout);
+    exit(EXIT_FAILURE);
+  }
+
+  return total_shards > 1;
+}
+
+// Parses the environment variable var as an Int32. If it is unset,
+// returns default_val. If it is not an Int32, prints an error
+// and aborts.
+int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
+  const char* str_val = posix::GetEnv(var);
+  if (str_val == nullptr) {
+    return default_val;
+  }
+
+  int32_t result;
+  if (!ParseInt32(Message() << "The value of environment variable " << var,
+                  str_val, &result)) {
+    exit(EXIT_FAILURE);
+  }
+  return result;
+}
+
+// Given the total number of shards, the shard index, and the test id,
+// returns true if and only if the test should be run on this shard. The test id
+// is some arbitrary but unique non-negative integer assigned to each test
+// method. Assumes that 0 <= shard_index < total_shards.
+bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {
+  return (test_id % total_shards) == shard_index;
+}
+
+// Compares the name of each test with the user-specified filter to
+// decide whether the test should be run, then records the result in
+// each TestSuite and TestInfo object.
+// If shard_tests == true, further filters tests based on sharding
+// variables in the environment - see
+// https://github.com/google/googletest/blob/master/googletest/docs/advanced.md
+// . Returns the number of tests that should run.
+int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
+  const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
+      Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
+  const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
+      Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
+
+  // num_runnable_tests are the number of tests that will
+  // run across all shards (i.e., match filter and are not disabled).
+  // num_selected_tests are the number of tests to be run on
+  // this shard.
+  int num_runnable_tests = 0;
+  int num_selected_tests = 0;
+  for (auto* test_suite : test_suites_) {
+    const std::string& test_suite_name = test_suite->name();
+    test_suite->set_should_run(false);
+
+    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
+      TestInfo* const test_info = test_suite->test_info_list()[j];
+      const std::string test_name(test_info->name());
+      // A test is disabled if test suite name or test name matches
+      // kDisableTestFilter.
+      const bool is_disabled = internal::UnitTestOptions::MatchesFilter(
+                                   test_suite_name, kDisableTestFilter) ||
+                               internal::UnitTestOptions::MatchesFilter(
+                                   test_name, kDisableTestFilter);
+      test_info->is_disabled_ = is_disabled;
+
+      const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest(
+          test_suite_name, test_name);
+      test_info->matches_filter_ = matches_filter;
+
+      const bool is_runnable =
+          (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
+          matches_filter;
+
+      const bool is_in_another_shard =
+          shard_tests != IGNORE_SHARDING_PROTOCOL &&
+          !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
+      test_info->is_in_another_shard_ = is_in_another_shard;
+      const bool is_selected = is_runnable && !is_in_another_shard;
+
+      num_runnable_tests += is_runnable;
+      num_selected_tests += is_selected;
+
+      test_info->should_run_ = is_selected;
+      test_suite->set_should_run(test_suite->should_run() || is_selected);
+    }
+  }
+  return num_selected_tests;
+}
+
+// Prints the given C-string on a single line by replacing all '\n'
+// characters with string "\\n".  If the output takes more than
+// max_length characters, only prints the first max_length characters
+// and "...".
+static void PrintOnOneLine(const char* str, int max_length) {
+  if (str != nullptr) {
+    for (int i = 0; *str != '\0'; ++str) {
+      if (i >= max_length) {
+        printf("...");
+        break;
+      }
+      if (*str == '\n') {
+        printf("\\n");
+        i += 2;
+      } else {
+        printf("%c", *str);
+        ++i;
+      }
+    }
+  }
+}
+
+// Prints the names of the tests matching the user-specified filter flag.
+void UnitTestImpl::ListTestsMatchingFilter() {
+  // Print at most this many characters for each type/value parameter.
+  const int kMaxParamLength = 250;
+
+  for (auto* test_suite : test_suites_) {
+    bool printed_test_suite_name = false;
+
+    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
+      const TestInfo* const test_info = test_suite->test_info_list()[j];
+      if (test_info->matches_filter_) {
+        if (!printed_test_suite_name) {
+          printed_test_suite_name = true;
+          printf("%s.", test_suite->name());
+          if (test_suite->type_param() != nullptr) {
+            printf("  # %s = ", kTypeParamLabel);
+            // We print the type parameter on a single line to make
+            // the output easy to parse by a program.
+            PrintOnOneLine(test_suite->type_param(), kMaxParamLength);
+          }
+          printf("\n");
+        }
+        printf("  %s", test_info->name());
+        if (test_info->value_param() != nullptr) {
+          printf("  # %s = ", kValueParamLabel);
+          // We print the value parameter on a single line to make the
+          // output easy to parse by a program.
+          PrintOnOneLine(test_info->value_param(), kMaxParamLength);
+        }
+        printf("\n");
+      }
+    }
+  }
+  fflush(stdout);
+  const std::string& output_format = UnitTestOptions::GetOutputFormat();
+  if (output_format == "xml" || output_format == "json") {
+    FILE* fileout = OpenFileForWriting(
+        UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
+    std::stringstream stream;
+    if (output_format == "xml") {
+      XmlUnitTestResultPrinter(
+          UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
+          .PrintXmlTestsList(&stream, test_suites_);
+    } else if (output_format == "json") {
+      JsonUnitTestResultPrinter(
+          UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
+          .PrintJsonTestList(&stream, test_suites_);
+    }
+    fprintf(fileout, "%s", StringStreamToString(&stream).c_str());
+    fclose(fileout);
+  }
+}
+
+// Sets the OS stack trace getter.
+//
+// Does nothing if the input and the current OS stack trace getter are
+// the same; otherwise, deletes the old getter and makes the input the
+// current getter.
+void UnitTestImpl::set_os_stack_trace_getter(
+    OsStackTraceGetterInterface* getter) {
+  if (os_stack_trace_getter_ != getter) {
+    delete os_stack_trace_getter_;
+    os_stack_trace_getter_ = getter;
+  }
+}
+
+// Returns the current OS stack trace getter if it is not NULL;
+// otherwise, creates an OsStackTraceGetter, makes it the current
+// getter, and returns it.
+OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
+  if (os_stack_trace_getter_ == nullptr) {
+#ifdef GTEST_OS_STACK_TRACE_GETTER_
+    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
+#else
+    os_stack_trace_getter_ = new OsStackTraceGetter;
+#endif  // GTEST_OS_STACK_TRACE_GETTER_
+  }
+
+  return os_stack_trace_getter_;
+}
+
+// Returns the most specific TestResult currently running.
+TestResult* UnitTestImpl::current_test_result() {
+  if (current_test_info_ != nullptr) {
+    return &current_test_info_->result_;
+  }
+  if (current_test_suite_ != nullptr) {
+    return &current_test_suite_->ad_hoc_test_result_;
+  }
+  return &ad_hoc_test_result_;
+}
+
+// Shuffles all test suites, and the tests within each test suite,
+// making sure that death tests are still run first.
+void UnitTestImpl::ShuffleTests() {
+  // Shuffles the death test suites.
+  ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);
+
+  // Shuffles the non-death test suites.
+  ShuffleRange(random(), last_death_test_suite_ + 1,
+               static_cast<int>(test_suites_.size()), &test_suite_indices_);
+
+  // Shuffles the tests inside each test suite.
+  for (auto& test_suite : test_suites_) {
+    test_suite->ShuffleTests(random());
+  }
+}
+
+// Restores the test suites and tests to their order before the first shuffle.
+void UnitTestImpl::UnshuffleTests() {
+  for (size_t i = 0; i < test_suites_.size(); i++) {
+    // Unshuffles the tests in each test suite.
+    test_suites_[i]->UnshuffleTests();
+    // Resets the index of each test suite.
+    test_suite_indices_[i] = static_cast<int>(i);
+  }
+}
+
+// Returns the current OS stack trace as an std::string.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
+// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
+std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
+                                            int skip_count) {
+  // We pass skip_count + 1 to skip this wrapper function in addition
+  // to what the user really wants to skip.
+  return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
+}
+
+// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to
+// suppress unreachable code warnings.
+namespace {
+class ClassUniqueToAlwaysTrue {};
+}
+
+bool IsTrue(bool condition) { return condition; }
+
+bool AlwaysTrue() {
+#if GTEST_HAS_EXCEPTIONS
+  // This condition is always false so AlwaysTrue() never actually throws,
+  // but it makes the compiler think that it may throw.
+  if (IsTrue(false))
+    throw ClassUniqueToAlwaysTrue();
+#endif  // GTEST_HAS_EXCEPTIONS
+  return true;
+}
+
+// If *pstr starts with the given prefix, modifies *pstr to be right
+// past the prefix and returns true; otherwise leaves *pstr unchanged
+// and returns false.  None of pstr, *pstr, and prefix can be NULL.
+bool SkipPrefix(const char* prefix, const char** pstr) {
+  const size_t prefix_len = strlen(prefix);
+  if (strncmp(*pstr, prefix, prefix_len) == 0) {
+    *pstr += prefix_len;
+    return true;
+  }
+  return false;
+}
+
+// Parses a string as a command line flag.  The string should have
+// the format "--flag=value".  When def_optional is true, the "=value"
+// part can be omitted.
+//
+// Returns the value of the flag, or NULL if the parsing failed.
+static const char* ParseFlagValue(const char* str, const char* flag,
+                                  bool def_optional) {
+  // str and flag must not be NULL.
+  if (str == nullptr || flag == nullptr) return nullptr;
+
+  // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
+  const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
+  const size_t flag_len = flag_str.length();
+  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
+
+  // Skips the flag name.
+  const char* flag_end = str + flag_len;
+
+  // When def_optional is true, it's OK to not have a "=value" part.
+  if (def_optional && (flag_end[0] == '\0')) {
+    return flag_end;
+  }
+
+  // If def_optional is true and there are more characters after the
+  // flag name, or if def_optional is false, there must be a '=' after
+  // the flag name.
+  if (flag_end[0] != '=') return nullptr;
+
+  // Returns the string after "=".
+  return flag_end + 1;
+}
+
+// Parses a string for a bool flag, in the form of either
+// "--flag=value" or "--flag".
+//
+// In the former case, the value is taken as true as long as it does
+// not start with '0', 'f', or 'F'.
+//
+// In the latter case, the value is taken as true.
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+static bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseFlagValue(str, flag, true);
+
+  // Aborts if the parsing failed.
+  if (value_str == nullptr) return false;
+
+  // Converts the string value to a bool.
+  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
+  return true;
+}
+
+// Parses a string for an int32_t flag, in the form of "--flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseFlagValue(str, flag, false);
+
+  // Aborts if the parsing failed.
+  if (value_str == nullptr) return false;
+
+  // Sets *value to the value of the flag.
+  return ParseInt32(Message() << "The value of flag --" << flag,
+                    value_str, value);
+}
+
+// Parses a string for a string flag, in the form of "--flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+template <typename String>
+static bool ParseStringFlag(const char* str, const char* flag, String* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseFlagValue(str, flag, false);
+
+  // Aborts if the parsing failed.
+  if (value_str == nullptr) return false;
+
+  // Sets *value to the value of the flag.
+  *value = value_str;
+  return true;
+}
+
+// Determines whether a string has a prefix that Google Test uses for its
+// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_.
+// If Google Test detects that a command line flag has its prefix but is not
+// recognized, it will print its help message. Flags starting with
+// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test
+// internal flags and do not trigger the help message.
+static bool HasGoogleTestFlagPrefix(const char* str) {
+  return (SkipPrefix("--", &str) ||
+          SkipPrefix("-", &str) ||
+          SkipPrefix("/", &str)) &&
+         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
+         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
+          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
+}
+
+// Prints a string containing code-encoded text.  The following escape
+// sequences can be used in the string to control the text color:
+//
+//   @@    prints a single '@' character.
+//   @R    changes the color to red.
+//   @G    changes the color to green.
+//   @Y    changes the color to yellow.
+//   @D    changes to the default terminal text color.
+//
+static void PrintColorEncoded(const char* str) {
+  GTestColor color = GTestColor::kDefault;  // The current color.
+
+  // Conceptually, we split the string into segments divided by escape
+  // sequences.  Then we print one segment at a time.  At the end of
+  // each iteration, the str pointer advances to the beginning of the
+  // next segment.
+  for (;;) {
+    const char* p = strchr(str, '@');
+    if (p == nullptr) {
+      ColoredPrintf(color, "%s", str);
+      return;
+    }
+
+    ColoredPrintf(color, "%s", std::string(str, p).c_str());
+
+    const char ch = p[1];
+    str = p + 2;
+    if (ch == '@') {
+      ColoredPrintf(color, "@");
+    } else if (ch == 'D') {
+      color = GTestColor::kDefault;
+    } else if (ch == 'R') {
+      color = GTestColor::kRed;
+    } else if (ch == 'G') {
+      color = GTestColor::kGreen;
+    } else if (ch == 'Y') {
+      color = GTestColor::kYellow;
+    } else {
+      --str;
+    }
+  }
+}
+
+static const char kColorEncodedHelpMessage[] =
+    "This program contains tests written using " GTEST_NAME_
+    ". You can use the\n"
+    "following command line flags to control its behavior:\n"
+    "\n"
+    "Test Selection:\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "list_tests@D\n"
+    "      List the names of all tests instead of running them. The name of\n"
+    "      TEST(Foo, Bar) is \"Foo.Bar\".\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "filter=@YPOSITIVE_PATTERNS"
+    "[@G-@YNEGATIVE_PATTERNS]@D\n"
+    "      Run only the tests whose name matches one of the positive patterns "
+    "but\n"
+    "      none of the negative patterns. '?' matches any single character; "
+    "'*'\n"
+    "      matches any substring; ':' separates two patterns.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "also_run_disabled_tests@D\n"
+    "      Run all disabled tests too.\n"
+    "\n"
+    "Test Execution:\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "repeat=@Y[COUNT]@D\n"
+    "      Run the tests repeatedly; use a negative count to repeat forever.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "shuffle@D\n"
+    "      Randomize tests' orders on every iteration.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "random_seed=@Y[NUMBER]@D\n"
+    "      Random number seed to use for shuffling test orders (between 1 and\n"
+    "      99999, or 0 to use a seed based on the current time).\n"
+    "\n"
+    "Test Output:\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n"
+    "      Enable/disable colored output. The default is @Gauto@D.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "brief=1@D\n"
+    "      Only print test failures.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "print_time=0@D\n"
+    "      Don't print the elapsed time of each test.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "output=@Y(@Gjson@Y|@Gxml@Y)[@G:@YDIRECTORY_PATH@G" GTEST_PATH_SEP_
+    "@Y|@G:@YFILE_PATH]@D\n"
+    "      Generate a JSON or XML report in the given directory or with the "
+    "given\n"
+    "      file name. @YFILE_PATH@D defaults to @Gtest_detail.xml@D.\n"
+# if GTEST_CAN_STREAM_RESULTS_
+    "  @G--" GTEST_FLAG_PREFIX_
+    "stream_result_to=@YHOST@G:@YPORT@D\n"
+    "      Stream test results to the given server.\n"
+# endif  // GTEST_CAN_STREAM_RESULTS_
+    "\n"
+    "Assertion Behavior:\n"
+# if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
+    "  @G--" GTEST_FLAG_PREFIX_
+    "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
+    "      Set the default death test style.\n"
+# endif  // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
+    "  @G--" GTEST_FLAG_PREFIX_
+    "break_on_failure@D\n"
+    "      Turn assertion failures into debugger break-points.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "throw_on_failure@D\n"
+    "      Turn assertion failures into C++ exceptions for use by an external\n"
+    "      test framework.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "catch_exceptions=0@D\n"
+    "      Do not report exceptions as test failures. Instead, allow them\n"
+    "      to crash the program or throw a pop-up (on Windows).\n"
+    "\n"
+    "Except for @G--" GTEST_FLAG_PREFIX_
+    "list_tests@D, you can alternatively set "
+    "the corresponding\n"
+    "environment variable of a flag (all letters in upper-case). For example, "
+    "to\n"
+    "disable colored text output, you can either specify "
+    "@G--" GTEST_FLAG_PREFIX_
+    "color=no@D or set\n"
+    "the @G" GTEST_FLAG_PREFIX_UPPER_
+    "COLOR@D environment variable to @Gno@D.\n"
+    "\n"
+    "For more information, please read the " GTEST_NAME_
+    " documentation at\n"
+    "@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_
+    "\n"
+    "(not one in your own code or tests), please report it to\n"
+    "@G<" GTEST_DEV_EMAIL_ ">@D.\n";
+
+static bool ParseGoogleTestFlag(const char* const arg) {
+  return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
+                       &GTEST_FLAG(also_run_disabled_tests)) ||
+         ParseBoolFlag(arg, kBreakOnFailureFlag,
+                       &GTEST_FLAG(break_on_failure)) ||
+         ParseBoolFlag(arg, kCatchExceptionsFlag,
+                       &GTEST_FLAG(catch_exceptions)) ||
+         ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
+         ParseStringFlag(arg, kDeathTestStyleFlag,
+                         &GTEST_FLAG(death_test_style)) ||
+         ParseBoolFlag(arg, kDeathTestUseFork,
+                       &GTEST_FLAG(death_test_use_fork)) ||
+         ParseBoolFlag(arg, kFailFast, &GTEST_FLAG(fail_fast)) ||
+         ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
+         ParseStringFlag(arg, kInternalRunDeathTestFlag,
+                         &GTEST_FLAG(internal_run_death_test)) ||
+         ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
+         ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
+         ParseBoolFlag(arg, kBriefFlag, &GTEST_FLAG(brief)) ||
+         ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
+         ParseBoolFlag(arg, kPrintUTF8Flag, &GTEST_FLAG(print_utf8)) ||
+         ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
+         ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
+         ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
+         ParseInt32Flag(arg, kStackTraceDepthFlag,
+                        &GTEST_FLAG(stack_trace_depth)) ||
+         ParseStringFlag(arg, kStreamResultToFlag,
+                         &GTEST_FLAG(stream_result_to)) ||
+         ParseBoolFlag(arg, kThrowOnFailureFlag, &GTEST_FLAG(throw_on_failure));
+}
+
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+static void LoadFlagsFromFile(const std::string& path) {
+  FILE* flagfile = posix::FOpen(path.c_str(), "r");
+  if (!flagfile) {
+    GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG(flagfile)
+                      << "\"";
+  }
+  std::string contents(ReadEntireFile(flagfile));
+  posix::FClose(flagfile);
+  std::vector<std::string> lines;
+  SplitString(contents, '\n', &lines);
+  for (size_t i = 0; i < lines.size(); ++i) {
+    if (lines[i].empty())
+      continue;
+    if (!ParseGoogleTestFlag(lines[i].c_str()))
+      g_help_flag = true;
+  }
+}
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+
+// Parses the command line for Google Test flags, without initializing
+// other parts of Google Test.  The type parameter CharType can be
+// instantiated to either char or wchar_t.
+template <typename CharType>
+void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
+  for (int i = 1; i < *argc; i++) {
+    const std::string arg_string = StreamableToString(argv[i]);
+    const char* const arg = arg_string.c_str();
+
+    using internal::ParseBoolFlag;
+    using internal::ParseInt32Flag;
+    using internal::ParseStringFlag;
+
+    bool remove_flag = false;
+    if (ParseGoogleTestFlag(arg)) {
+      remove_flag = true;
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+    } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) {
+      LoadFlagsFromFile(GTEST_FLAG(flagfile));
+      remove_flag = true;
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+    } else if (arg_string == "--help" || arg_string == "-h" ||
+               arg_string == "-?" || arg_string == "/?" ||
+               HasGoogleTestFlagPrefix(arg)) {
+      // Both help flag and unrecognized Google Test flags (excluding
+      // internal ones) trigger help display.
+      g_help_flag = true;
+    }
+
+    if (remove_flag) {
+      // Shift the remainder of the argv list left by one.  Note
+      // that argv has (*argc + 1) elements, the last one always being
+      // NULL.  The following loop moves the trailing NULL element as
+      // well.
+      for (int j = i; j != *argc; j++) {
+        argv[j] = argv[j + 1];
+      }
+
+      // Decrements the argument count.
+      (*argc)--;
+
+      // We also need to decrement the iterator as we just removed
+      // an element.
+      i--;
+    }
+  }
+
+  if (g_help_flag) {
+    // We print the help here instead of in RUN_ALL_TESTS(), as the
+    // latter may not be called at all if the user is using Google
+    // Test with another testing framework.
+    PrintColorEncoded(kColorEncodedHelpMessage);
+  }
+}
+
+// Parses the command line for Google Test flags, without initializing
+// other parts of Google Test.
+void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
+  ParseGoogleTestFlagsOnlyImpl(argc, argv);
+
+  // Fix the value of *_NSGetArgc() on macOS, but if and only if
+  // *_NSGetArgv() == argv
+  // Only applicable to char** version of argv
+#if GTEST_OS_MAC
+#ifndef GTEST_OS_IOS
+  if (*_NSGetArgv() == argv) {
+    *_NSGetArgc() = *argc;
+  }
+#endif
+#endif
+}
+void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
+  ParseGoogleTestFlagsOnlyImpl(argc, argv);
+}
+
+// The internal implementation of InitGoogleTest().
+//
+// The type parameter CharType can be instantiated to either char or
+// wchar_t.
+template <typename CharType>
+void InitGoogleTestImpl(int* argc, CharType** argv) {
+  // We don't want to run the initialization code twice.
+  if (GTestIsInitialized()) return;
+
+  if (*argc <= 0) return;
+
+  g_argvs.clear();
+  for (int i = 0; i != *argc; i++) {
+    g_argvs.push_back(StreamableToString(argv[i]));
+  }
+
+#if GTEST_HAS_ABSL
+  absl::InitializeSymbolizer(g_argvs[0].c_str());
+#endif  // GTEST_HAS_ABSL
+
+  ParseGoogleTestFlagsOnly(argc, argv);
+  GetUnitTestImpl()->PostFlagParsingInit();
+}
+
+}  // namespace internal
+
+// Initializes Google Test.  This must be called before calling
+// RUN_ALL_TESTS().  In particular, it parses a command line for the
+// flags that Google Test recognizes.  Whenever a Google Test flag is
+// seen, it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Test flag variables are
+// updated.
+//
+// Calling the function for the second time has no user-visible effect.
+void InitGoogleTest(int* argc, char** argv) {
+#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
+#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  internal::InitGoogleTestImpl(argc, argv);
+#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+}
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+void InitGoogleTest(int* argc, wchar_t** argv) {
+#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
+#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  internal::InitGoogleTestImpl(argc, argv);
+#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+}
+
+// This overloaded version can be used on Arduino/embedded platforms where
+// there is no argc/argv.
+void InitGoogleTest() {
+  // Since Arduino doesn't have a command line, fake out the argc/argv arguments
+  int argc = 1;
+  const auto arg0 = "dummy";
+  char* argv0 = const_cast<char*>(arg0);
+  char** argv = &argv0;
+
+#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
+#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  internal::InitGoogleTestImpl(&argc, argv);
+#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+}
+
+std::string TempDir() {
+#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
+  return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
+#elif GTEST_OS_WINDOWS_MOBILE
+  return "\\temp\\";
+#elif GTEST_OS_WINDOWS
+  const char* temp_dir = internal::posix::GetEnv("TEMP");
+  if (temp_dir == nullptr || temp_dir[0] == '\0') {
+    return "\\temp\\";
+  } else if (temp_dir[strlen(temp_dir) - 1] == '\\') {
+    return temp_dir;
+  } else {
+    return std::string(temp_dir) + "\\";
+  }
+#elif GTEST_OS_LINUX_ANDROID
+  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
+  if (temp_dir == nullptr || temp_dir[0] == '\0') {
+    return "/data/local/tmp/";
+  } else {
+    return temp_dir;
+  }
+#elif GTEST_OS_LINUX
+  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
+  if (temp_dir == nullptr || temp_dir[0] == '\0') {
+    return "/tmp/";
+  } else {
+    return temp_dir;
+  }
+#else
+  return "/tmp/";
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+// Class ScopedTrace
+
+// Pushes the given source file location and message onto a per-thread
+// trace stack maintained by Google Test.
+void ScopedTrace::PushTrace(const char* file, int line, std::string message) {
+  internal::TraceInfo trace;
+  trace.file = file;
+  trace.line = line;
+  trace.message.swap(message);
+
+  UnitTest::GetInstance()->PushGTestTrace(trace);
+}
+
+// Pops the info pushed by the c'tor.
+ScopedTrace::~ScopedTrace()
+    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
+  UnitTest::GetInstance()->PopGTestTrace();
+}
+
+}  // namespace testing
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+//
+// This file implements death tests.
+
+
+#include <functional>
+#include <utility>
+
+
+#if GTEST_HAS_DEATH_TEST
+
+# if GTEST_OS_MAC
+#  include <crt_externs.h>
+# endif  // GTEST_OS_MAC
+
+# include <errno.h>
+# include <fcntl.h>
+# include <limits.h>
+
+# if GTEST_OS_LINUX
+#  include <signal.h>
+# endif  // GTEST_OS_LINUX
+
+# include <stdarg.h>
+
+# if GTEST_OS_WINDOWS
+#  include <windows.h>
+# else
+#  include <sys/mman.h>
+#  include <sys/wait.h>
+# endif  // GTEST_OS_WINDOWS
+
+# if GTEST_OS_QNX
+#  include <spawn.h>
+# endif  // GTEST_OS_QNX
+
+# if GTEST_OS_FUCHSIA
+#  include <lib/fdio/fd.h>
+#  include <lib/fdio/io.h>
+#  include <lib/fdio/spawn.h>
+#  include <lib/zx/channel.h>
+#  include <lib/zx/port.h>
+#  include <lib/zx/process.h>
+#  include <lib/zx/socket.h>
+#  include <zircon/processargs.h>
+#  include <zircon/syscalls.h>
+#  include <zircon/syscalls/policy.h>
+#  include <zircon/syscalls/port.h>
+# endif  // GTEST_OS_FUCHSIA
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+
+namespace testing {
+
+// Constants.
+
+// The default death test style.
+//
+// This is defined in internal/gtest-port.h as "fast", but can be overridden by
+// a definition in internal/custom/gtest-port.h. The recommended value, which is
+// used internally at Google, is "threadsafe".
+static const char kDefaultDeathTestStyle[] = GTEST_DEFAULT_DEATH_TEST_STYLE;
+
+GTEST_DEFINE_string_(
+    death_test_style,
+    internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),
+    "Indicates how to run a death test in a forked child process: "
+    "\"threadsafe\" (child process re-executes the test binary "
+    "from the beginning, running only the specific death test) or "
+    "\"fast\" (child process runs the death test immediately "
+    "after forking).");
+
+GTEST_DEFINE_bool_(
+    death_test_use_fork,
+    internal::BoolFromGTestEnv("death_test_use_fork", false),
+    "Instructs to use fork()/_exit() instead of clone() in death tests. "
+    "Ignored and always uses fork() on POSIX systems where clone() is not "
+    "implemented. Useful when running under valgrind or similar tools if "
+    "those do not support clone(). Valgrind 3.3.1 will just fail if "
+    "it sees an unsupported combination of clone() flags. "
+    "It is not recommended to use this flag w/o valgrind though it will "
+    "work in 99% of the cases. Once valgrind is fixed, this flag will "
+    "most likely be removed.");
+
+namespace internal {
+GTEST_DEFINE_string_(
+    internal_run_death_test, "",
+    "Indicates the file, line number, temporal index of "
+    "the single death test to run, and a file descriptor to "
+    "which a success code may be sent, all separated by "
+    "the '|' characters.  This flag is specified if and only if the "
+    "current process is a sub-process launched for running a thread-safe "
+    "death test.  FOR INTERNAL USE ONLY.");
+}  // namespace internal
+
+#if GTEST_HAS_DEATH_TEST
+
+namespace internal {
+
+// Valid only for fast death tests. Indicates the code is running in the
+// child process of a fast style death test.
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+static bool g_in_fast_death_test_child = false;
+# endif
+
+// Returns a Boolean value indicating whether the caller is currently
+// executing in the context of the death test child process.  Tools such as
+// Valgrind heap checkers may need this to modify their behavior in death
+// tests.  IMPORTANT: This is an internal utility.  Using it may break the
+// implementation of death tests.  User code MUST NOT use it.
+bool InDeathTestChild() {
+# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+
+  // On Windows and Fuchsia, death tests are thread-safe regardless of the value
+  // of the death_test_style flag.
+  return !GTEST_FLAG(internal_run_death_test).empty();
+
+# else
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe")
+    return !GTEST_FLAG(internal_run_death_test).empty();
+  else
+    return g_in_fast_death_test_child;
+#endif
+}
+
+}  // namespace internal
+
+// ExitedWithCode constructor.
+ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
+}
+
+// ExitedWithCode function-call operator.
+bool ExitedWithCode::operator()(int exit_status) const {
+# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+
+  return exit_status == exit_code_;
+
+# else
+
+  return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;
+
+# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+}
+
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+// KilledBySignal constructor.
+KilledBySignal::KilledBySignal(int signum) : signum_(signum) {
+}
+
+// KilledBySignal function-call operator.
+bool KilledBySignal::operator()(int exit_status) const {
+#  if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
+  {
+    bool result;
+    if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
+      return result;
+    }
+  }
+#  endif  // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
+  return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
+}
+# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+
+namespace internal {
+
+// Utilities needed for death tests.
+
+// Generates a textual description of a given exit code, in the format
+// specified by wait(2).
+static std::string ExitSummary(int exit_code) {
+  Message m;
+
+# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+
+  m << "Exited with exit status " << exit_code;
+
+# else
+
+  if (WIFEXITED(exit_code)) {
+    m << "Exited with exit status " << WEXITSTATUS(exit_code);
+  } else if (WIFSIGNALED(exit_code)) {
+    m << "Terminated by signal " << WTERMSIG(exit_code);
+  }
+#  ifdef WCOREDUMP
+  if (WCOREDUMP(exit_code)) {
+    m << " (core dumped)";
+  }
+#  endif
+# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+
+  return m.GetString();
+}
+
+// Returns true if exit_status describes a process that was terminated
+// by a signal, or exited normally with a nonzero exit code.
+bool ExitedUnsuccessfully(int exit_status) {
+  return !ExitedWithCode(0)(exit_status);
+}
+
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+// Generates a textual failure message when a death test finds more than
+// one thread running, or cannot determine the number of threads, prior
+// to executing the given statement.  It is the responsibility of the
+// caller not to pass a thread_count of 1.
+static std::string DeathTestThreadWarning(size_t thread_count) {
+  Message msg;
+  msg << "Death tests use fork(), which is unsafe particularly"
+      << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
+  if (thread_count == 0) {
+    msg << "couldn't detect the number of threads.";
+  } else {
+    msg << "detected " << thread_count << " threads.";
+  }
+  msg << " See "
+         "https://github.com/google/googletest/blob/master/docs/"
+         "advanced.md#death-tests-and-threads"
+      << " for more explanation and suggested solutions, especially if"
+      << " this is the last message you see before your test times out.";
+  return msg.GetString();
+}
+# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+
+// Flag characters for reporting a death test that did not die.
+static const char kDeathTestLived = 'L';
+static const char kDeathTestReturned = 'R';
+static const char kDeathTestThrew = 'T';
+static const char kDeathTestInternalError = 'I';
+
+#if GTEST_OS_FUCHSIA
+
+// File descriptor used for the pipe in the child process.
+static const int kFuchsiaReadPipeFd = 3;
+
+#endif
+
+// An enumeration describing all of the possible ways that a death test can
+// conclude.  DIED means that the process died while executing the test
+// code; LIVED means that process lived beyond the end of the test code;
+// RETURNED means that the test statement attempted to execute a return
+// statement, which is not allowed; THREW means that the test statement
+// returned control by throwing an exception.  IN_PROGRESS means the test
+// has not yet concluded.
+enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
+
+// Routine for aborting the program which is safe to call from an
+// exec-style death test child process, in which case the error
+// message is propagated back to the parent process.  Otherwise, the
+// message is simply printed to stderr.  In either case, the program
+// then exits with status 1.
+static void DeathTestAbort(const std::string& message) {
+  // On a POSIX system, this function may be called from a threadsafe-style
+  // death test child process, which operates on a very small stack.  Use
+  // the heap for any additional non-minuscule memory requirements.
+  const InternalRunDeathTestFlag* const flag =
+      GetUnitTestImpl()->internal_run_death_test_flag();
+  if (flag != nullptr) {
+    FILE* parent = posix::FDOpen(flag->write_fd(), "w");
+    fputc(kDeathTestInternalError, parent);
+    fprintf(parent, "%s", message.c_str());
+    fflush(parent);
+    _exit(1);
+  } else {
+    fprintf(stderr, "%s", message.c_str());
+    fflush(stderr);
+    posix::Abort();
+  }
+}
+
+// A replacement for CHECK that calls DeathTestAbort if the assertion
+// fails.
+# define GTEST_DEATH_TEST_CHECK_(expression) \
+  do { \
+    if (!::testing::internal::IsTrue(expression)) { \
+      DeathTestAbort( \
+          ::std::string("CHECK failed: File ") + __FILE__ +  ", line " \
+          + ::testing::internal::StreamableToString(__LINE__) + ": " \
+          + #expression); \
+    } \
+  } while (::testing::internal::AlwaysFalse())
+
+// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for
+// evaluating any system call that fulfills two conditions: it must return
+// -1 on failure, and set errno to EINTR when it is interrupted and
+// should be tried again.  The macro expands to a loop that repeatedly
+// evaluates the expression as long as it evaluates to -1 and sets
+// errno to EINTR.  If the expression evaluates to -1 but errno is
+// something other than EINTR, DeathTestAbort is called.
+# define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \
+  do { \
+    int gtest_retval; \
+    do { \
+      gtest_retval = (expression); \
+    } while (gtest_retval == -1 && errno == EINTR); \
+    if (gtest_retval == -1) { \
+      DeathTestAbort( \
+          ::std::string("CHECK failed: File ") + __FILE__ + ", line " \
+          + ::testing::internal::StreamableToString(__LINE__) + ": " \
+          + #expression + " != -1"); \
+    } \
+  } while (::testing::internal::AlwaysFalse())
+
+// Returns the message describing the last system error in errno.
+std::string GetLastErrnoDescription() {
+    return errno == 0 ? "" : posix::StrError(errno);
+}
+
+// This is called from a death test parent process to read a failure
+// message from the death test child process and log it with the FATAL
+// severity. On Windows, the message is read from a pipe handle. On other
+// platforms, it is read from a file descriptor.
+static void FailFromInternalError(int fd) {
+  Message error;
+  char buffer[256];
+  int num_read;
+
+  do {
+    while ((num_read = posix::Read(fd, buffer, 255)) > 0) {
+      buffer[num_read] = '\0';
+      error << buffer;
+    }
+  } while (num_read == -1 && errno == EINTR);
+
+  if (num_read == 0) {
+    GTEST_LOG_(FATAL) << error.GetString();
+  } else {
+    const int last_error = errno;
+    GTEST_LOG_(FATAL) << "Error while reading death test internal: "
+                      << GetLastErrnoDescription() << " [" << last_error << "]";
+  }
+}
+
+// Death test constructor.  Increments the running death test count
+// for the current test.
+DeathTest::DeathTest() {
+  TestInfo* const info = GetUnitTestImpl()->current_test_info();
+  if (info == nullptr) {
+    DeathTestAbort("Cannot run a death test outside of a TEST or "
+                   "TEST_F construct");
+  }
+}
+
+// Creates and returns a death test by dispatching to the current
+// death test factory.
+bool DeathTest::Create(const char* statement,
+                       Matcher<const std::string&> matcher, const char* file,
+                       int line, DeathTest** test) {
+  return GetUnitTestImpl()->death_test_factory()->Create(
+      statement, std::move(matcher), file, line, test);
+}
+
+const char* DeathTest::LastMessage() {
+  return last_death_test_message_.c_str();
+}
+
+void DeathTest::set_last_death_test_message(const std::string& message) {
+  last_death_test_message_ = message;
+}
+
+std::string DeathTest::last_death_test_message_;
+
+// Provides cross platform implementation for some death functionality.
+class DeathTestImpl : public DeathTest {
+ protected:
+  DeathTestImpl(const char* a_statement, Matcher<const std::string&> matcher)
+      : statement_(a_statement),
+        matcher_(std::move(matcher)),
+        spawned_(false),
+        status_(-1),
+        outcome_(IN_PROGRESS),
+        read_fd_(-1),
+        write_fd_(-1) {}
+
+  // read_fd_ is expected to be closed and cleared by a derived class.
+  ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }
+
+  void Abort(AbortReason reason) override;
+  bool Passed(bool status_ok) override;
+
+  const char* statement() const { return statement_; }
+  bool spawned() const { return spawned_; }
+  void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
+  int status() const { return status_; }
+  void set_status(int a_status) { status_ = a_status; }
+  DeathTestOutcome outcome() const { return outcome_; }
+  void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; }
+  int read_fd() const { return read_fd_; }
+  void set_read_fd(int fd) { read_fd_ = fd; }
+  int write_fd() const { return write_fd_; }
+  void set_write_fd(int fd) { write_fd_ = fd; }
+
+  // Called in the parent process only. Reads the result code of the death
+  // test child process via a pipe, interprets it to set the outcome_
+  // member, and closes read_fd_.  Outputs diagnostics and terminates in
+  // case of unexpected codes.
+  void ReadAndInterpretStatusByte();
+
+  // Returns stderr output from the child process.
+  virtual std::string GetErrorLogs();
+
+ private:
+  // The textual content of the code this object is testing.  This class
+  // doesn't own this string and should not attempt to delete it.
+  const char* const statement_;
+  // A matcher that's expected to match the stderr output by the child process.
+  Matcher<const std::string&> matcher_;
+  // True if the death test child process has been successfully spawned.
+  bool spawned_;
+  // The exit status of the child process.
+  int status_;
+  // How the death test concluded.
+  DeathTestOutcome outcome_;
+  // Descriptor to the read end of the pipe to the child process.  It is
+  // always -1 in the child process.  The child keeps its write end of the
+  // pipe in write_fd_.
+  int read_fd_;
+  // Descriptor to the child's write end of the pipe to the parent process.
+  // It is always -1 in the parent process.  The parent keeps its end of the
+  // pipe in read_fd_.
+  int write_fd_;
+};
+
+// Called in the parent process only. Reads the result code of the death
+// test child process via a pipe, interprets it to set the outcome_
+// member, and closes read_fd_.  Outputs diagnostics and terminates in
+// case of unexpected codes.
+void DeathTestImpl::ReadAndInterpretStatusByte() {
+  char flag;
+  int bytes_read;
+
+  // The read() here blocks until data is available (signifying the
+  // failure of the death test) or until the pipe is closed (signifying
+  // its success), so it's okay to call this in the parent before
+  // the child process has exited.
+  do {
+    bytes_read = posix::Read(read_fd(), &flag, 1);
+  } while (bytes_read == -1 && errno == EINTR);
+
+  if (bytes_read == 0) {
+    set_outcome(DIED);
+  } else if (bytes_read == 1) {
+    switch (flag) {
+      case kDeathTestReturned:
+        set_outcome(RETURNED);
+        break;
+      case kDeathTestThrew:
+        set_outcome(THREW);
+        break;
+      case kDeathTestLived:
+        set_outcome(LIVED);
+        break;
+      case kDeathTestInternalError:
+        FailFromInternalError(read_fd());  // Does not return.
+        break;
+      default:
+        GTEST_LOG_(FATAL) << "Death test child process reported "
+                          << "unexpected status byte ("
+                          << static_cast<unsigned int>(flag) << ")";
+    }
+  } else {
+    GTEST_LOG_(FATAL) << "Read from death test child process failed: "
+                      << GetLastErrnoDescription();
+  }
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd()));
+  set_read_fd(-1);
+}
+
+std::string DeathTestImpl::GetErrorLogs() {
+  return GetCapturedStderr();
+}
+
+// Signals that the death test code which should have exited, didn't.
+// Should be called only in a death test child process.
+// Writes a status byte to the child's status file descriptor, then
+// calls _exit(1).
+void DeathTestImpl::Abort(AbortReason reason) {
+  // The parent process considers the death test to be a failure if
+  // it finds any data in our pipe.  So, here we write a single flag byte
+  // to the pipe, then exit.
+  const char status_ch =
+      reason == TEST_DID_NOT_DIE ? kDeathTestLived :
+      reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned;
+
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
+  // We are leaking the descriptor here because on some platforms (i.e.,
+  // when built as Windows DLL), destructors of global objects will still
+  // run after calling _exit(). On such systems, write_fd_ will be
+  // indirectly closed from the destructor of UnitTestImpl, causing double
+  // close if it is also closed here. On debug configurations, double close
+  // may assert. As there are no in-process buffers to flush here, we are
+  // relying on the OS to close the descriptor after the process terminates
+  // when the destructors are not run.
+  _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
+}
+
+// Returns an indented copy of stderr output for a death test.
+// This makes distinguishing death test output lines from regular log lines
+// much easier.
+static ::std::string FormatDeathTestOutput(const ::std::string& output) {
+  ::std::string ret;
+  for (size_t at = 0; ; ) {
+    const size_t line_end = output.find('\n', at);
+    ret += "[  DEATH   ] ";
+    if (line_end == ::std::string::npos) {
+      ret += output.substr(at);
+      break;
+    }
+    ret += output.substr(at, line_end + 1 - at);
+    at = line_end + 1;
+  }
+  return ret;
+}
+
+// Assesses the success or failure of a death test, using both private
+// members which have previously been set, and one argument:
+//
+// Private data members:
+//   outcome:  An enumeration describing how the death test
+//             concluded: DIED, LIVED, THREW, or RETURNED.  The death test
+//             fails in the latter three cases.
+//   status:   The exit status of the child process. On *nix, it is in the
+//             in the format specified by wait(2). On Windows, this is the
+//             value supplied to the ExitProcess() API or a numeric code
+//             of the exception that terminated the program.
+//   matcher_: A matcher that's expected to match the stderr output by the child
+//             process.
+//
+// Argument:
+//   status_ok: true if exit_status is acceptable in the context of
+//              this particular death test, which fails if it is false
+//
+// Returns true if and only if all of the above conditions are met.  Otherwise,
+// the first failing condition, in the order given above, is the one that is
+// reported. Also sets the last death test message string.
+bool DeathTestImpl::Passed(bool status_ok) {
+  if (!spawned())
+    return false;
+
+  const std::string error_message = GetErrorLogs();
+
+  bool success = false;
+  Message buffer;
+
+  buffer << "Death test: " << statement() << "\n";
+  switch (outcome()) {
+    case LIVED:
+      buffer << "    Result: failed to die.\n"
+             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+      break;
+    case THREW:
+      buffer << "    Result: threw an exception.\n"
+             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+      break;
+    case RETURNED:
+      buffer << "    Result: illegal return in test statement.\n"
+             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+      break;
+    case DIED:
+      if (status_ok) {
+        if (matcher_.Matches(error_message)) {
+          success = true;
+        } else {
+          std::ostringstream stream;
+          matcher_.DescribeTo(&stream);
+          buffer << "    Result: died but not with expected error.\n"
+                 << "  Expected: " << stream.str() << "\n"
+                 << "Actual msg:\n"
+                 << FormatDeathTestOutput(error_message);
+        }
+      } else {
+        buffer << "    Result: died but not with expected exit code:\n"
+               << "            " << ExitSummary(status()) << "\n"
+               << "Actual msg:\n" << FormatDeathTestOutput(error_message);
+      }
+      break;
+    case IN_PROGRESS:
+    default:
+      GTEST_LOG_(FATAL)
+          << "DeathTest::Passed somehow called before conclusion of test";
+  }
+
+  DeathTest::set_last_death_test_message(buffer.GetString());
+  return success;
+}
+
+# if GTEST_OS_WINDOWS
+// WindowsDeathTest implements death tests on Windows. Due to the
+// specifics of starting new processes on Windows, death tests there are
+// always threadsafe, and Google Test considers the
+// --gtest_death_test_style=fast setting to be equivalent to
+// --gtest_death_test_style=threadsafe there.
+//
+// A few implementation notes:  Like the Linux version, the Windows
+// implementation uses pipes for child-to-parent communication. But due to
+// the specifics of pipes on Windows, some extra steps are required:
+//
+// 1. The parent creates a communication pipe and stores handles to both
+//    ends of it.
+// 2. The parent starts the child and provides it with the information
+//    necessary to acquire the handle to the write end of the pipe.
+// 3. The child acquires the write end of the pipe and signals the parent
+//    using a Windows event.
+// 4. Now the parent can release the write end of the pipe on its side. If
+//    this is done before step 3, the object's reference count goes down to
+//    0 and it is destroyed, preventing the child from acquiring it. The
+//    parent now has to release it, or read operations on the read end of
+//    the pipe will not return when the child terminates.
+// 5. The parent reads child's output through the pipe (outcome code and
+//    any possible error messages) from the pipe, and its stderr and then
+//    determines whether to fail the test.
+//
+// Note: to distinguish Win32 API calls from the local method and function
+// calls, the former are explicitly resolved in the global namespace.
+//
+class WindowsDeathTest : public DeathTestImpl {
+ public:
+  WindowsDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
+                   const char* file, int line)
+      : DeathTestImpl(a_statement, std::move(matcher)),
+        file_(file),
+        line_(line) {}
+
+  // All of these virtual functions are inherited from DeathTest.
+  virtual int Wait();
+  virtual TestRole AssumeRole();
+
+ private:
+  // The name of the file in which the death test is located.
+  const char* const file_;
+  // The line number on which the death test is located.
+  const int line_;
+  // Handle to the write end of the pipe to the child process.
+  AutoHandle write_handle_;
+  // Child process handle.
+  AutoHandle child_handle_;
+  // Event the child process uses to signal the parent that it has
+  // acquired the handle to the write end of the pipe. After seeing this
+  // event the parent can release its own handles to make sure its
+  // ReadFile() calls return when the child terminates.
+  AutoHandle event_handle_;
+};
+
+// Waits for the child in a death test to exit, returning its exit
+// status, or 0 if no child process exists.  As a side effect, sets the
+// outcome data member.
+int WindowsDeathTest::Wait() {
+  if (!spawned())
+    return 0;
+
+  // Wait until the child either signals that it has acquired the write end
+  // of the pipe or it dies.
+  const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() };
+  switch (::WaitForMultipleObjects(2,
+                                   wait_handles,
+                                   FALSE,  // Waits for any of the handles.
+                                   INFINITE)) {
+    case WAIT_OBJECT_0:
+    case WAIT_OBJECT_0 + 1:
+      break;
+    default:
+      GTEST_DEATH_TEST_CHECK_(false);  // Should not get here.
+  }
+
+  // The child has acquired the write end of the pipe or exited.
+  // We release the handle on our side and continue.
+  write_handle_.Reset();
+  event_handle_.Reset();
+
+  ReadAndInterpretStatusByte();
+
+  // Waits for the child process to exit if it haven't already. This
+  // returns immediately if the child has already exited, regardless of
+  // whether previous calls to WaitForMultipleObjects synchronized on this
+  // handle or not.
+  GTEST_DEATH_TEST_CHECK_(
+      WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(),
+                                             INFINITE));
+  DWORD status_code;
+  GTEST_DEATH_TEST_CHECK_(
+      ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE);
+  child_handle_.Reset();
+  set_status(static_cast<int>(status_code));
+  return status();
+}
+
+// The AssumeRole process for a Windows death test.  It creates a child
+// process with the same executable as the current process to run the
+// death test.  The child process is given the --gtest_filter and
+// --gtest_internal_run_death_test flags such that it knows to run the
+// current death test only.
+DeathTest::TestRole WindowsDeathTest::AssumeRole() {
+  const UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const TestInfo* const info = impl->current_test_info();
+  const int death_test_index = info->result()->death_test_count();
+
+  if (flag != nullptr) {
+    // ParseInternalRunDeathTestFlag() has performed all the necessary
+    // processing.
+    set_write_fd(flag->write_fd());
+    return EXECUTE_TEST;
+  }
+
+  // WindowsDeathTest uses an anonymous pipe to communicate results of
+  // a death test.
+  SECURITY_ATTRIBUTES handles_are_inheritable = {sizeof(SECURITY_ATTRIBUTES),
+                                                 nullptr, TRUE};
+  HANDLE read_handle, write_handle;
+  GTEST_DEATH_TEST_CHECK_(
+      ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable,
+                   0)  // Default buffer size.
+      != FALSE);
+  set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle),
+                                O_RDONLY));
+  write_handle_.Reset(write_handle);
+  event_handle_.Reset(::CreateEvent(
+      &handles_are_inheritable,
+      TRUE,       // The event will automatically reset to non-signaled state.
+      FALSE,      // The initial state is non-signalled.
+      nullptr));  // The even is unnamed.
+  GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != nullptr);
+  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
+                                  kFilterFlag + "=" + info->test_suite_name() +
+                                  "." + info->name();
+  const std::string internal_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag +
+      "=" + file_ + "|" + StreamableToString(line_) + "|" +
+      StreamableToString(death_test_index) + "|" +
+      StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) +
+      // size_t has the same width as pointers on both 32-bit and 64-bit
+      // Windows platforms.
+      // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
+      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) +
+      "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
+
+  char executable_path[_MAX_PATH + 1];  // NOLINT
+  GTEST_DEATH_TEST_CHECK_(_MAX_PATH + 1 != ::GetModuleFileNameA(nullptr,
+                                                                executable_path,
+                                                                _MAX_PATH));
+
+  std::string command_line =
+      std::string(::GetCommandLineA()) + " " + filter_flag + " \"" +
+      internal_flag + "\"";
+
+  DeathTest::set_last_death_test_message("");
+
+  CaptureStderr();
+  // Flush the log buffers since the log streams are shared with the child.
+  FlushInfoLog();
+
+  // The child process will share the standard handles with the parent.
+  STARTUPINFOA startup_info;
+  memset(&startup_info, 0, sizeof(STARTUPINFO));
+  startup_info.dwFlags = STARTF_USESTDHANDLES;
+  startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE);
+  startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE);
+  startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
+
+  PROCESS_INFORMATION process_info;
+  GTEST_DEATH_TEST_CHECK_(
+      ::CreateProcessA(
+          executable_path, const_cast<char*>(command_line.c_str()),
+          nullptr,  // Retuned process handle is not inheritable.
+          nullptr,  // Retuned thread handle is not inheritable.
+          TRUE,  // Child inherits all inheritable handles (for write_handle_).
+          0x0,   // Default creation flags.
+          nullptr,  // Inherit the parent's environment.
+          UnitTest::GetInstance()->original_working_dir(), &startup_info,
+          &process_info) != FALSE);
+  child_handle_.Reset(process_info.hProcess);
+  ::CloseHandle(process_info.hThread);
+  set_spawned(true);
+  return OVERSEE_TEST;
+}
+
+# elif GTEST_OS_FUCHSIA
+
+class FuchsiaDeathTest : public DeathTestImpl {
+ public:
+  FuchsiaDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
+                   const char* file, int line)
+      : DeathTestImpl(a_statement, std::move(matcher)),
+        file_(file),
+        line_(line) {}
+
+  // All of these virtual functions are inherited from DeathTest.
+  int Wait() override;
+  TestRole AssumeRole() override;
+  std::string GetErrorLogs() override;
+
+ private:
+  // The name of the file in which the death test is located.
+  const char* const file_;
+  // The line number on which the death test is located.
+  const int line_;
+  // The stderr data captured by the child process.
+  std::string captured_stderr_;
+
+  zx::process child_process_;
+  zx::channel exception_channel_;
+  zx::socket stderr_socket_;
+};
+
+// Utility class for accumulating command-line arguments.
+class Arguments {
+ public:
+  Arguments() { args_.push_back(nullptr); }
+
+  ~Arguments() {
+    for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
+         ++i) {
+      free(*i);
+    }
+  }
+  void AddArgument(const char* argument) {
+    args_.insert(args_.end() - 1, posix::StrDup(argument));
+  }
+
+  template <typename Str>
+  void AddArguments(const ::std::vector<Str>& arguments) {
+    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
+         i != arguments.end();
+         ++i) {
+      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
+    }
+  }
+  char* const* Argv() {
+    return &args_[0];
+  }
+
+  int size() {
+    return static_cast<int>(args_.size()) - 1;
+  }
+
+ private:
+  std::vector<char*> args_;
+};
+
+// Waits for the child in a death test to exit, returning its exit
+// status, or 0 if no child process exists.  As a side effect, sets the
+// outcome data member.
+int FuchsiaDeathTest::Wait() {
+  const int kProcessKey = 0;
+  const int kSocketKey = 1;
+  const int kExceptionKey = 2;
+
+  if (!spawned())
+    return 0;
+
+  // Create a port to wait for socket/task/exception events.
+  zx_status_t status_zx;
+  zx::port port;
+  status_zx = zx::port::create(0, &port);
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+  // Register to wait for the child process to terminate.
+  status_zx = child_process_.wait_async(
+      port, kProcessKey, ZX_PROCESS_TERMINATED, 0);
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+  // Register to wait for the socket to be readable or closed.
+  status_zx = stderr_socket_.wait_async(
+      port, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED, 0);
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+  // Register to wait for an exception.
+  status_zx = exception_channel_.wait_async(
+      port, kExceptionKey, ZX_CHANNEL_READABLE, 0);
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+  bool process_terminated = false;
+  bool socket_closed = false;
+  do {
+    zx_port_packet_t packet = {};
+    status_zx = port.wait(zx::time::infinite(), &packet);
+    GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+    if (packet.key == kExceptionKey) {
+      // Process encountered an exception. Kill it directly rather than
+      // letting other handlers process the event. We will get a kProcessKey
+      // event when the process actually terminates.
+      status_zx = child_process_.kill();
+      GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+    } else if (packet.key == kProcessKey) {
+      // Process terminated.
+      GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type));
+      GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_PROCESS_TERMINATED);
+      process_terminated = true;
+    } else if (packet.key == kSocketKey) {
+      GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type));
+      if (packet.signal.observed & ZX_SOCKET_READABLE) {
+        // Read data from the socket.
+        constexpr size_t kBufferSize = 1024;
+        do {
+          size_t old_length = captured_stderr_.length();
+          size_t bytes_read = 0;
+          captured_stderr_.resize(old_length + kBufferSize);
+          status_zx = stderr_socket_.read(
+              0, &captured_stderr_.front() + old_length, kBufferSize,
+              &bytes_read);
+          captured_stderr_.resize(old_length + bytes_read);
+        } while (status_zx == ZX_OK);
+        if (status_zx == ZX_ERR_PEER_CLOSED) {
+          socket_closed = true;
+        } else {
+          GTEST_DEATH_TEST_CHECK_(status_zx == ZX_ERR_SHOULD_WAIT);
+          status_zx = stderr_socket_.wait_async(
+              port, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED, 0);
+          GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+        }
+      } else {
+        GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_SOCKET_PEER_CLOSED);
+        socket_closed = true;
+      }
+    }
+  } while (!process_terminated && !socket_closed);
+
+  ReadAndInterpretStatusByte();
+
+  zx_info_process_v2_t buffer;
+  status_zx = child_process_.get_info(
+      ZX_INFO_PROCESS_V2, &buffer, sizeof(buffer), nullptr, nullptr);
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+  GTEST_DEATH_TEST_CHECK_(buffer.flags & ZX_INFO_PROCESS_FLAG_EXITED);
+  set_status(static_cast<int>(buffer.return_code));
+  return status();
+}
+
+// The AssumeRole process for a Fuchsia death test.  It creates a child
+// process with the same executable as the current process to run the
+// death test.  The child process is given the --gtest_filter and
+// --gtest_internal_run_death_test flags such that it knows to run the
+// current death test only.
+DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
+  const UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const TestInfo* const info = impl->current_test_info();
+  const int death_test_index = info->result()->death_test_count();
+
+  if (flag != nullptr) {
+    // ParseInternalRunDeathTestFlag() has performed all the necessary
+    // processing.
+    set_write_fd(kFuchsiaReadPipeFd);
+    return EXECUTE_TEST;
+  }
+
+  // Flush the log buffers since the log streams are shared with the child.
+  FlushInfoLog();
+
+  // Build the child process command line.
+  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
+                                  kFilterFlag + "=" + info->test_suite_name() +
+                                  "." + info->name();
+  const std::string internal_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
+      + file_ + "|"
+      + StreamableToString(line_) + "|"
+      + StreamableToString(death_test_index);
+  Arguments args;
+  args.AddArguments(GetInjectableArgvs());
+  args.AddArgument(filter_flag.c_str());
+  args.AddArgument(internal_flag.c_str());
+
+  // Build the pipe for communication with the child.
+  zx_status_t status;
+  zx_handle_t child_pipe_handle;
+  int child_pipe_fd;
+  status = fdio_pipe_half(&child_pipe_fd, &child_pipe_handle);
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+  set_read_fd(child_pipe_fd);
+
+  // Set the pipe handle for the child.
+  fdio_spawn_action_t spawn_actions[2] = {};
+  fdio_spawn_action_t* add_handle_action = &spawn_actions[0];
+  add_handle_action->action = FDIO_SPAWN_ACTION_ADD_HANDLE;
+  add_handle_action->h.id = PA_HND(PA_FD, kFuchsiaReadPipeFd);
+  add_handle_action->h.handle = child_pipe_handle;
+
+  // Create a socket pair will be used to receive the child process' stderr.
+  zx::socket stderr_producer_socket;
+  status =
+      zx::socket::create(0, &stderr_producer_socket, &stderr_socket_);
+  GTEST_DEATH_TEST_CHECK_(status >= 0);
+  int stderr_producer_fd = -1;
+  status =
+      fdio_fd_create(stderr_producer_socket.release(), &stderr_producer_fd);
+  GTEST_DEATH_TEST_CHECK_(status >= 0);
+
+  // Make the stderr socket nonblocking.
+  GTEST_DEATH_TEST_CHECK_(fcntl(stderr_producer_fd, F_SETFL, 0) == 0);
+
+  fdio_spawn_action_t* add_stderr_action = &spawn_actions[1];
+  add_stderr_action->action = FDIO_SPAWN_ACTION_CLONE_FD;
+  add_stderr_action->fd.local_fd = stderr_producer_fd;
+  add_stderr_action->fd.target_fd = STDERR_FILENO;
+
+  // Create a child job.
+  zx_handle_t child_job = ZX_HANDLE_INVALID;
+  status = zx_job_create(zx_job_default(), 0, & child_job);
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+  zx_policy_basic_t policy;
+  policy.condition = ZX_POL_NEW_ANY;
+  policy.policy = ZX_POL_ACTION_ALLOW;
+  status = zx_job_set_policy(
+      child_job, ZX_JOB_POL_RELATIVE, ZX_JOB_POL_BASIC, &policy, 1);
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+
+  // Create an exception channel attached to the |child_job|, to allow
+  // us to suppress the system default exception handler from firing.
+  status =
+      zx_task_create_exception_channel(
+          child_job, 0, exception_channel_.reset_and_get_address());
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+
+  // Spawn the child process.
+  status = fdio_spawn_etc(
+      child_job, FDIO_SPAWN_CLONE_ALL, args.Argv()[0], args.Argv(), nullptr,
+      2, spawn_actions, child_process_.reset_and_get_address(), nullptr);
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+
+  set_spawned(true);
+  return OVERSEE_TEST;
+}
+
+std::string FuchsiaDeathTest::GetErrorLogs() {
+  return captured_stderr_;
+}
+
+#else  // We are neither on Windows, nor on Fuchsia.
+
+// ForkingDeathTest provides implementations for most of the abstract
+// methods of the DeathTest interface.  Only the AssumeRole method is
+// left undefined.
+class ForkingDeathTest : public DeathTestImpl {
+ public:
+  ForkingDeathTest(const char* statement, Matcher<const std::string&> matcher);
+
+  // All of these virtual functions are inherited from DeathTest.
+  int Wait() override;
+
+ protected:
+  void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
+
+ private:
+  // PID of child process during death test; 0 in the child process itself.
+  pid_t child_pid_;
+};
+
+// Constructs a ForkingDeathTest.
+ForkingDeathTest::ForkingDeathTest(const char* a_statement,
+                                   Matcher<const std::string&> matcher)
+    : DeathTestImpl(a_statement, std::move(matcher)), child_pid_(-1) {}
+
+// Waits for the child in a death test to exit, returning its exit
+// status, or 0 if no child process exists.  As a side effect, sets the
+// outcome data member.
+int ForkingDeathTest::Wait() {
+  if (!spawned())
+    return 0;
+
+  ReadAndInterpretStatusByte();
+
+  int status_value;
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
+  set_status(status_value);
+  return status_value;
+}
+
+// A concrete death test class that forks, then immediately runs the test
+// in the child process.
+class NoExecDeathTest : public ForkingDeathTest {
+ public:
+  NoExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher)
+      : ForkingDeathTest(a_statement, std::move(matcher)) {}
+  TestRole AssumeRole() override;
+};
+
+// The AssumeRole process for a fork-and-run death test.  It implements a
+// straightforward fork, with a simple pipe to transmit the status byte.
+DeathTest::TestRole NoExecDeathTest::AssumeRole() {
+  const size_t thread_count = GetThreadCount();
+  if (thread_count != 1) {
+    GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count);
+  }
+
+  int pipe_fd[2];
+  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
+
+  DeathTest::set_last_death_test_message("");
+  CaptureStderr();
+  // When we fork the process below, the log file buffers are copied, but the
+  // file descriptors are shared.  We flush all log files here so that closing
+  // the file descriptors in the child process doesn't throw off the
+  // synchronization between descriptors and buffers in the parent process.
+  // This is as close to the fork as possible to avoid a race condition in case
+  // there are multiple threads running before the death test, and another
+  // thread writes to the log file.
+  FlushInfoLog();
+
+  const pid_t child_pid = fork();
+  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
+  set_child_pid(child_pid);
+  if (child_pid == 0) {
+    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0]));
+    set_write_fd(pipe_fd[1]);
+    // Redirects all logging to stderr in the child process to prevent
+    // concurrent writes to the log files.  We capture stderr in the parent
+    // process and append the child process' output to a log.
+    LogToStderr();
+    // Event forwarding to the listeners of event listener API mush be shut
+    // down in death test subprocesses.
+    GetUnitTestImpl()->listeners()->SuppressEventForwarding();
+    g_in_fast_death_test_child = true;
+    return EXECUTE_TEST;
+  } else {
+    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
+    set_read_fd(pipe_fd[0]);
+    set_spawned(true);
+    return OVERSEE_TEST;
+  }
+}
+
+// A concrete death test class that forks and re-executes the main
+// program from the beginning, with command-line flags set that cause
+// only this specific death test to be run.
+class ExecDeathTest : public ForkingDeathTest {
+ public:
+  ExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
+                const char* file, int line)
+      : ForkingDeathTest(a_statement, std::move(matcher)),
+        file_(file),
+        line_(line) {}
+  TestRole AssumeRole() override;
+
+ private:
+  static ::std::vector<std::string> GetArgvsForDeathTestChildProcess() {
+    ::std::vector<std::string> args = GetInjectableArgvs();
+#  if defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
+    ::std::vector<std::string> extra_args =
+        GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_();
+    args.insert(args.end(), extra_args.begin(), extra_args.end());
+#  endif  // defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
+    return args;
+  }
+  // The name of the file in which the death test is located.
+  const char* const file_;
+  // The line number on which the death test is located.
+  const int line_;
+};
+
+// Utility class for accumulating command-line arguments.
+class Arguments {
+ public:
+  Arguments() { args_.push_back(nullptr); }
+
+  ~Arguments() {
+    for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
+         ++i) {
+      free(*i);
+    }
+  }
+  void AddArgument(const char* argument) {
+    args_.insert(args_.end() - 1, posix::StrDup(argument));
+  }
+
+  template <typename Str>
+  void AddArguments(const ::std::vector<Str>& arguments) {
+    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
+         i != arguments.end();
+         ++i) {
+      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
+    }
+  }
+  char* const* Argv() {
+    return &args_[0];
+  }
+
+ private:
+  std::vector<char*> args_;
+};
+
+// A struct that encompasses the arguments to the child process of a
+// threadsafe-style death test process.
+struct ExecDeathTestArgs {
+  char* const* argv;  // Command-line arguments for the child's call to exec
+  int close_fd;       // File descriptor to close; the read end of a pipe
+};
+
+#  if GTEST_OS_QNX
+extern "C" char** environ;
+#  else  // GTEST_OS_QNX
+// The main function for a threadsafe-style death test child process.
+// This function is called in a clone()-ed process and thus must avoid
+// any potentially unsafe operations like malloc or libc functions.
+static int ExecDeathTestChildMain(void* child_arg) {
+  ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
+
+  // We need to execute the test program in the same environment where
+  // it was originally invoked.  Therefore we change to the original
+  // working directory first.
+  const char* const original_dir =
+      UnitTest::GetInstance()->original_working_dir();
+  // We can safely call chdir() as it's a direct system call.
+  if (chdir(original_dir) != 0) {
+    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
+                   GetLastErrnoDescription());
+    return EXIT_FAILURE;
+  }
+
+  // We can safely call execv() as it's almost a direct system call. We
+  // cannot use execvp() as it's a libc function and thus potentially
+  // unsafe.  Since execv() doesn't search the PATH, the user must
+  // invoke the test program via a valid path that contains at least
+  // one path separator.
+  execv(args->argv[0], args->argv);
+  DeathTestAbort(std::string("execv(") + args->argv[0] + ", ...) in " +
+                 original_dir + " failed: " +
+                 GetLastErrnoDescription());
+  return EXIT_FAILURE;
+}
+#  endif  // GTEST_OS_QNX
+
+#  if GTEST_HAS_CLONE
+// Two utility routines that together determine the direction the stack
+// grows.
+// This could be accomplished more elegantly by a single recursive
+// function, but we want to guard against the unlikely possibility of
+// a smart compiler optimizing the recursion away.
+//
+// GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining
+// StackLowerThanAddress into StackGrowsDown, which then doesn't give
+// correct answer.
+static void StackLowerThanAddress(const void* ptr,
+                                  bool* result) GTEST_NO_INLINE_;
+// Make sure sanitizers do not tamper with the stack here.
+// Ideally, we want to use `__builtin_frame_address` instead of a local variable
+// address with sanitizer disabled, but it does not work when the
+// compiler optimizes the stack frame out, which happens on PowerPC targets.
+// HWAddressSanitizer add a random tag to the MSB of the local variable address,
+// making comparison result unpredictable.
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+static void StackLowerThanAddress(const void* ptr, bool* result) {
+  int dummy = 0;
+  *result = std::less<const void*>()(&dummy, ptr);
+}
+
+// Make sure AddressSanitizer does not tamper with the stack here.
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+static bool StackGrowsDown() {
+  int dummy = 0;
+  bool result;
+  StackLowerThanAddress(&dummy, &result);
+  return result;
+}
+#  endif  // GTEST_HAS_CLONE
+
+// Spawns a child process with the same executable as the current process in
+// a thread-safe manner and instructs it to run the death test.  The
+// implementation uses fork(2) + exec.  On systems where clone(2) is
+// available, it is used instead, being slightly more thread-safe.  On QNX,
+// fork supports only single-threaded environments, so this function uses
+// spawn(2) there instead.  The function dies with an error message if
+// anything goes wrong.
+static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
+  ExecDeathTestArgs args = { argv, close_fd };
+  pid_t child_pid = -1;
+
+#  if GTEST_OS_QNX
+  // Obtains the current directory and sets it to be closed in the child
+  // process.
+  const int cwd_fd = open(".", O_RDONLY);
+  GTEST_DEATH_TEST_CHECK_(cwd_fd != -1);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC));
+  // We need to execute the test program in the same environment where
+  // it was originally invoked.  Therefore we change to the original
+  // working directory first.
+  const char* const original_dir =
+      UnitTest::GetInstance()->original_working_dir();
+  // We can safely call chdir() as it's a direct system call.
+  if (chdir(original_dir) != 0) {
+    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
+                   GetLastErrnoDescription());
+    return EXIT_FAILURE;
+  }
+
+  int fd_flags;
+  // Set close_fd to be closed after spawn.
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD));
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD,
+                                        fd_flags | FD_CLOEXEC));
+  struct inheritance inherit = {0};
+  // spawn is a system call.
+  child_pid = spawn(args.argv[0], 0, nullptr, &inherit, args.argv, environ);
+  // Restores the current working directory.
+  GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
+
+#  else   // GTEST_OS_QNX
+#   if GTEST_OS_LINUX
+  // When a SIGPROF signal is received while fork() or clone() are executing,
+  // the process may hang. To avoid this, we ignore SIGPROF here and re-enable
+  // it after the call to fork()/clone() is complete.
+  struct sigaction saved_sigprof_action;
+  struct sigaction ignore_sigprof_action;
+  memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action));
+  sigemptyset(&ignore_sigprof_action.sa_mask);
+  ignore_sigprof_action.sa_handler = SIG_IGN;
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction(
+      SIGPROF, &ignore_sigprof_action, &saved_sigprof_action));
+#   endif  // GTEST_OS_LINUX
+
+#   if GTEST_HAS_CLONE
+  const bool use_fork = GTEST_FLAG(death_test_use_fork);
+
+  if (!use_fork) {
+    static const bool stack_grows_down = StackGrowsDown();
+    const auto stack_size = static_cast<size_t>(getpagesize() * 2);
+    // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
+    void* const stack = mmap(nullptr, stack_size, PROT_READ | PROT_WRITE,
+                             MAP_ANON | MAP_PRIVATE, -1, 0);
+    GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
+
+    // Maximum stack alignment in bytes:  For a downward-growing stack, this
+    // amount is subtracted from size of the stack space to get an address
+    // that is within the stack space and is aligned on all systems we care
+    // about.  As far as I know there is no ABI with stack alignment greater
+    // than 64.  We assume stack and stack_size already have alignment of
+    // kMaxStackAlignment.
+    const size_t kMaxStackAlignment = 64;
+    void* const stack_top =
+        static_cast<char*>(stack) +
+            (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
+    GTEST_DEATH_TEST_CHECK_(
+        static_cast<size_t>(stack_size) > kMaxStackAlignment &&
+        reinterpret_cast<uintptr_t>(stack_top) % kMaxStackAlignment == 0);
+
+    child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);
+
+    GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
+  }
+#   else
+  const bool use_fork = true;
+#   endif  // GTEST_HAS_CLONE
+
+  if (use_fork && (child_pid = fork()) == 0) {
+      ExecDeathTestChildMain(&args);
+      _exit(0);
+  }
+#  endif  // GTEST_OS_QNX
+#  if GTEST_OS_LINUX
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(
+      sigaction(SIGPROF, &saved_sigprof_action, nullptr));
+#  endif  // GTEST_OS_LINUX
+
+  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
+  return child_pid;
+}
+
+// The AssumeRole process for a fork-and-exec death test.  It re-executes the
+// main program from the beginning, setting the --gtest_filter
+// and --gtest_internal_run_death_test flags to cause only the current
+// death test to be re-run.
+DeathTest::TestRole ExecDeathTest::AssumeRole() {
+  const UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const TestInfo* const info = impl->current_test_info();
+  const int death_test_index = info->result()->death_test_count();
+
+  if (flag != nullptr) {
+    set_write_fd(flag->write_fd());
+    return EXECUTE_TEST;
+  }
+
+  int pipe_fd[2];
+  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
+  // Clear the close-on-exec flag on the write end of the pipe, lest
+  // it be closed when the child process does an exec:
+  GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
+
+  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
+                                  kFilterFlag + "=" + info->test_suite_name() +
+                                  "." + info->name();
+  const std::string internal_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
+      + file_ + "|" + StreamableToString(line_) + "|"
+      + StreamableToString(death_test_index) + "|"
+      + StreamableToString(pipe_fd[1]);
+  Arguments args;
+  args.AddArguments(GetArgvsForDeathTestChildProcess());
+  args.AddArgument(filter_flag.c_str());
+  args.AddArgument(internal_flag.c_str());
+
+  DeathTest::set_last_death_test_message("");
+
+  CaptureStderr();
+  // See the comment in NoExecDeathTest::AssumeRole for why the next line
+  // is necessary.
+  FlushInfoLog();
+
+  const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
+  set_child_pid(child_pid);
+  set_read_fd(pipe_fd[0]);
+  set_spawned(true);
+  return OVERSEE_TEST;
+}
+
+# endif  // !GTEST_OS_WINDOWS
+
+// Creates a concrete DeathTest-derived class that depends on the
+// --gtest_death_test_style flag, and sets the pointer pointed to
+// by the "test" argument to its address.  If the test should be
+// skipped, sets that pointer to NULL.  Returns true, unless the
+// flag is set to an invalid value.
+bool DefaultDeathTestFactory::Create(const char* statement,
+                                     Matcher<const std::string&> matcher,
+                                     const char* file, int line,
+                                     DeathTest** test) {
+  UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const int death_test_index = impl->current_test_info()
+      ->increment_death_test_count();
+
+  if (flag != nullptr) {
+    if (death_test_index > flag->index()) {
+      DeathTest::set_last_death_test_message(
+          "Death test count (" + StreamableToString(death_test_index)
+          + ") somehow exceeded expected maximum ("
+          + StreamableToString(flag->index()) + ")");
+      return false;
+    }
+
+    if (!(flag->file() == file && flag->line() == line &&
+          flag->index() == death_test_index)) {
+      *test = nullptr;
+      return true;
+    }
+  }
+
+# if GTEST_OS_WINDOWS
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
+      GTEST_FLAG(death_test_style) == "fast") {
+    *test = new WindowsDeathTest(statement, std::move(matcher), file, line);
+  }
+
+# elif GTEST_OS_FUCHSIA
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
+      GTEST_FLAG(death_test_style) == "fast") {
+    *test = new FuchsiaDeathTest(statement, std::move(matcher), file, line);
+  }
+
+# else
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe") {
+    *test = new ExecDeathTest(statement, std::move(matcher), file, line);
+  } else if (GTEST_FLAG(death_test_style) == "fast") {
+    *test = new NoExecDeathTest(statement, std::move(matcher));
+  }
+
+# endif  // GTEST_OS_WINDOWS
+
+  else {  // NOLINT - this is more readable than unbalanced brackets inside #if.
+    DeathTest::set_last_death_test_message(
+        "Unknown death test style \"" + GTEST_FLAG(death_test_style)
+        + "\" encountered");
+    return false;
+  }
+
+  return true;
+}
+
+# if GTEST_OS_WINDOWS
+// Recreates the pipe and event handles from the provided parameters,
+// signals the event, and returns a file descriptor wrapped around the pipe
+// handle. This function is called in the child process only.
+static int GetStatusFileDescriptor(unsigned int parent_process_id,
+                            size_t write_handle_as_size_t,
+                            size_t event_handle_as_size_t) {
+  AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE,
+                                                   FALSE,  // Non-inheritable.
+                                                   parent_process_id));
+  if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) {
+    DeathTestAbort("Unable to open parent process " +
+                   StreamableToString(parent_process_id));
+  }
+
+  GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t));
+
+  const HANDLE write_handle =
+      reinterpret_cast<HANDLE>(write_handle_as_size_t);
+  HANDLE dup_write_handle;
+
+  // The newly initialized handle is accessible only in the parent
+  // process. To obtain one accessible within the child, we need to use
+  // DuplicateHandle.
+  if (!::DuplicateHandle(parent_process_handle.Get(), write_handle,
+                         ::GetCurrentProcess(), &dup_write_handle,
+                         0x0,    // Requested privileges ignored since
+                                 // DUPLICATE_SAME_ACCESS is used.
+                         FALSE,  // Request non-inheritable handler.
+                         DUPLICATE_SAME_ACCESS)) {
+    DeathTestAbort("Unable to duplicate the pipe handle " +
+                   StreamableToString(write_handle_as_size_t) +
+                   " from the parent process " +
+                   StreamableToString(parent_process_id));
+  }
+
+  const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t);
+  HANDLE dup_event_handle;
+
+  if (!::DuplicateHandle(parent_process_handle.Get(), event_handle,
+                         ::GetCurrentProcess(), &dup_event_handle,
+                         0x0,
+                         FALSE,
+                         DUPLICATE_SAME_ACCESS)) {
+    DeathTestAbort("Unable to duplicate the event handle " +
+                   StreamableToString(event_handle_as_size_t) +
+                   " from the parent process " +
+                   StreamableToString(parent_process_id));
+  }
+
+  const int write_fd =
+      ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND);
+  if (write_fd == -1) {
+    DeathTestAbort("Unable to convert pipe handle " +
+                   StreamableToString(write_handle_as_size_t) +
+                   " to a file descriptor");
+  }
+
+  // Signals the parent that the write end of the pipe has been acquired
+  // so the parent can release its own write end.
+  ::SetEvent(dup_event_handle);
+
+  return write_fd;
+}
+# endif  // GTEST_OS_WINDOWS
+
+// Returns a newly created InternalRunDeathTestFlag object with fields
+// initialized from the GTEST_FLAG(internal_run_death_test) flag if
+// the flag is specified; otherwise returns NULL.
+InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
+  if (GTEST_FLAG(internal_run_death_test) == "") return nullptr;
+
+  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
+  // can use it here.
+  int line = -1;
+  int index = -1;
+  ::std::vector< ::std::string> fields;
+  SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields);
+  int write_fd = -1;
+
+# if GTEST_OS_WINDOWS
+
+  unsigned int parent_process_id = 0;
+  size_t write_handle_as_size_t = 0;
+  size_t event_handle_as_size_t = 0;
+
+  if (fields.size() != 6
+      || !ParseNaturalNumber(fields[1], &line)
+      || !ParseNaturalNumber(fields[2], &index)
+      || !ParseNaturalNumber(fields[3], &parent_process_id)
+      || !ParseNaturalNumber(fields[4], &write_handle_as_size_t)
+      || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
+                   GTEST_FLAG(internal_run_death_test));
+  }
+  write_fd = GetStatusFileDescriptor(parent_process_id,
+                                     write_handle_as_size_t,
+                                     event_handle_as_size_t);
+
+# elif GTEST_OS_FUCHSIA
+
+  if (fields.size() != 3
+      || !ParseNaturalNumber(fields[1], &line)
+      || !ParseNaturalNumber(fields[2], &index)) {
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
+        + GTEST_FLAG(internal_run_death_test));
+  }
+
+# else
+
+  if (fields.size() != 4
+      || !ParseNaturalNumber(fields[1], &line)
+      || !ParseNaturalNumber(fields[2], &index)
+      || !ParseNaturalNumber(fields[3], &write_fd)) {
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
+        + GTEST_FLAG(internal_run_death_test));
+  }
+
+# endif  // GTEST_OS_WINDOWS
+
+  return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
+}
+
+}  // namespace internal
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  // namespace testing
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#include <stdlib.h>
+
+#if GTEST_OS_WINDOWS_MOBILE
+# include <windows.h>
+#elif GTEST_OS_WINDOWS
+# include <direct.h>
+# include <io.h>
+#else
+# include <limits.h>
+# include <climits>  // Some Linux distributions define PATH_MAX here.
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+
+#if GTEST_OS_WINDOWS
+# define GTEST_PATH_MAX_ _MAX_PATH
+#elif defined(PATH_MAX)
+# define GTEST_PATH_MAX_ PATH_MAX
+#elif defined(_XOPEN_PATH_MAX)
+# define GTEST_PATH_MAX_ _XOPEN_PATH_MAX
+#else
+# define GTEST_PATH_MAX_ _POSIX_PATH_MAX
+#endif  // GTEST_OS_WINDOWS
+
+namespace testing {
+namespace internal {
+
+#if GTEST_OS_WINDOWS
+// On Windows, '\\' is the standard path separator, but many tools and the
+// Windows API also accept '/' as an alternate path separator. Unless otherwise
+// noted, a file path can contain either kind of path separators, or a mixture
+// of them.
+const char kPathSeparator = '\\';
+const char kAlternatePathSeparator = '/';
+const char kAlternatePathSeparatorString[] = "/";
+# if GTEST_OS_WINDOWS_MOBILE
+// Windows CE doesn't have a current directory. You should not use
+// the current directory in tests on Windows CE, but this at least
+// provides a reasonable fallback.
+const char kCurrentDirectoryString[] = "\\";
+// Windows CE doesn't define INVALID_FILE_ATTRIBUTES
+const DWORD kInvalidFileAttributes = 0xffffffff;
+# else
+const char kCurrentDirectoryString[] = ".\\";
+# endif  // GTEST_OS_WINDOWS_MOBILE
+#else
+const char kPathSeparator = '/';
+const char kCurrentDirectoryString[] = "./";
+#endif  // GTEST_OS_WINDOWS
+
+// Returns whether the given character is a valid path separator.
+static bool IsPathSeparator(char c) {
+#if GTEST_HAS_ALT_PATH_SEP_
+  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
+#else
+  return c == kPathSeparator;
+#endif
+}
+
+// Returns the current working directory, or "" if unsuccessful.
+FilePath FilePath::GetCurrentDir() {
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE ||         \
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_ESP32 || \
+    GTEST_OS_XTENSA
+  // These platforms do not have a current directory, so we just return
+  // something reasonable.
+  return FilePath(kCurrentDirectoryString);
+#elif GTEST_OS_WINDOWS
+  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
+  return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd);
+#else
+  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
+  char* result = getcwd(cwd, sizeof(cwd));
+# if GTEST_OS_NACL
+  // getcwd will likely fail in NaCl due to the sandbox, so return something
+  // reasonable. The user may have provided a shim implementation for getcwd,
+  // however, so fallback only when failure is detected.
+  return FilePath(result == nullptr ? kCurrentDirectoryString : cwd);
+# endif  // GTEST_OS_NACL
+  return FilePath(result == nullptr ? "" : cwd);
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+// Returns a copy of the FilePath with the case-insensitive extension removed.
+// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
+// FilePath("dir/file"). If a case-insensitive extension is not
+// found, returns a copy of the original FilePath.
+FilePath FilePath::RemoveExtension(const char* extension) const {
+  const std::string dot_extension = std::string(".") + extension;
+  if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
+    return FilePath(pathname_.substr(
+        0, pathname_.length() - dot_extension.length()));
+  }
+  return *this;
+}
+
+// Returns a pointer to the last occurrence of a valid path separator in
+// the FilePath. On Windows, for example, both '/' and '\' are valid path
+// separators. Returns NULL if no path separator was found.
+const char* FilePath::FindLastPathSeparator() const {
+  const char* const last_sep = strrchr(c_str(), kPathSeparator);
+#if GTEST_HAS_ALT_PATH_SEP_
+  const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator);
+  // Comparing two pointers of which only one is NULL is undefined.
+  if (last_alt_sep != nullptr &&
+      (last_sep == nullptr || last_alt_sep > last_sep)) {
+    return last_alt_sep;
+  }
+#endif
+  return last_sep;
+}
+
+// Returns a copy of the FilePath with the directory part removed.
+// Example: FilePath("path/to/file").RemoveDirectoryName() returns
+// FilePath("file"). If there is no directory part ("just_a_file"), it returns
+// the FilePath unmodified. If there is no file part ("just_a_dir/") it
+// returns an empty FilePath ("").
+// On Windows platform, '\' is the path separator, otherwise it is '/'.
+FilePath FilePath::RemoveDirectoryName() const {
+  const char* const last_sep = FindLastPathSeparator();
+  return last_sep ? FilePath(last_sep + 1) : *this;
+}
+
+// RemoveFileName returns the directory path with the filename removed.
+// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
+// If the FilePath is "a_file" or "/a_file", RemoveFileName returns
+// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
+// not have a file, like "just/a/dir/", it returns the FilePath unmodified.
+// On Windows platform, '\' is the path separator, otherwise it is '/'.
+FilePath FilePath::RemoveFileName() const {
+  const char* const last_sep = FindLastPathSeparator();
+  std::string dir;
+  if (last_sep) {
+    dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 - c_str()));
+  } else {
+    dir = kCurrentDirectoryString;
+  }
+  return FilePath(dir);
+}
+
+// Helper functions for naming files in a directory for xml output.
+
+// Given directory = "dir", base_name = "test", number = 0,
+// extension = "xml", returns "dir/test.xml". If number is greater
+// than zero (e.g., 12), returns "dir/test_12.xml".
+// On Windows platform, uses \ as the separator rather than /.
+FilePath FilePath::MakeFileName(const FilePath& directory,
+                                const FilePath& base_name,
+                                int number,
+                                const char* extension) {
+  std::string file;
+  if (number == 0) {
+    file = base_name.string() + "." + extension;
+  } else {
+    file = base_name.string() + "_" + StreamableToString(number)
+        + "." + extension;
+  }
+  return ConcatPaths(directory, FilePath(file));
+}
+
+// Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml".
+// On Windows, uses \ as the separator rather than /.
+FilePath FilePath::ConcatPaths(const FilePath& directory,
+                               const FilePath& relative_path) {
+  if (directory.IsEmpty())
+    return relative_path;
+  const FilePath dir(directory.RemoveTrailingPathSeparator());
+  return FilePath(dir.string() + kPathSeparator + relative_path.string());
+}
+
+// Returns true if pathname describes something findable in the file-system,
+// either a file, directory, or whatever.
+bool FilePath::FileOrDirectoryExists() const {
+#if GTEST_OS_WINDOWS_MOBILE
+  LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
+  const DWORD attributes = GetFileAttributes(unicode);
+  delete [] unicode;
+  return attributes != kInvalidFileAttributes;
+#else
+  posix::StatStruct file_stat;
+  return posix::Stat(pathname_.c_str(), &file_stat) == 0;
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+// Returns true if pathname describes a directory in the file-system
+// that exists.
+bool FilePath::DirectoryExists() const {
+  bool result = false;
+#if GTEST_OS_WINDOWS
+  // Don't strip off trailing separator if path is a root directory on
+  // Windows (like "C:\\").
+  const FilePath& path(IsRootDirectory() ? *this :
+                                           RemoveTrailingPathSeparator());
+#else
+  const FilePath& path(*this);
+#endif
+
+#if GTEST_OS_WINDOWS_MOBILE
+  LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
+  const DWORD attributes = GetFileAttributes(unicode);
+  delete [] unicode;
+  if ((attributes != kInvalidFileAttributes) &&
+      (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
+    result = true;
+  }
+#else
+  posix::StatStruct file_stat;
+  result = posix::Stat(path.c_str(), &file_stat) == 0 &&
+      posix::IsDir(file_stat);
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+  return result;
+}
+
+// Returns true if pathname describes a root directory. (Windows has one
+// root directory per disk drive.)
+bool FilePath::IsRootDirectory() const {
+#if GTEST_OS_WINDOWS
+  return pathname_.length() == 3 && IsAbsolutePath();
+#else
+  return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
+#endif
+}
+
+// Returns true if pathname describes an absolute path.
+bool FilePath::IsAbsolutePath() const {
+  const char* const name = pathname_.c_str();
+#if GTEST_OS_WINDOWS
+  return pathname_.length() >= 3 &&
+     ((name[0] >= 'a' && name[0] <= 'z') ||
+      (name[0] >= 'A' && name[0] <= 'Z')) &&
+     name[1] == ':' &&
+     IsPathSeparator(name[2]);
+#else
+  return IsPathSeparator(name[0]);
+#endif
+}
+
+// Returns a pathname for a file that does not currently exist. The pathname
+// will be directory/base_name.extension or
+// directory/base_name_<number>.extension if directory/base_name.extension
+// already exists. The number will be incremented until a pathname is found
+// that does not already exist.
+// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
+// There could be a race condition if two or more processes are calling this
+// function at the same time -- they could both pick the same filename.
+FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
+                                          const FilePath& base_name,
+                                          const char* extension) {
+  FilePath full_pathname;
+  int number = 0;
+  do {
+    full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
+  } while (full_pathname.FileOrDirectoryExists());
+  return full_pathname;
+}
+
+// Returns true if FilePath ends with a path separator, which indicates that
+// it is intended to represent a directory. Returns false otherwise.
+// This does NOT check that a directory (or file) actually exists.
+bool FilePath::IsDirectory() const {
+  return !pathname_.empty() &&
+         IsPathSeparator(pathname_.c_str()[pathname_.length() - 1]);
+}
+
+// Create directories so that path exists. Returns true if successful or if
+// the directories already exist; returns false if unable to create directories
+// for any reason.
+bool FilePath::CreateDirectoriesRecursively() const {
+  if (!this->IsDirectory()) {
+    return false;
+  }
+
+  if (pathname_.length() == 0 || this->DirectoryExists()) {
+    return true;
+  }
+
+  const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
+  return parent.CreateDirectoriesRecursively() && this->CreateFolder();
+}
+
+// Create the directory so that path exists. Returns true if successful or
+// if the directory already exists; returns false if unable to create the
+// directory for any reason, including if the parent directory does not
+// exist. Not named "CreateDirectory" because that's a macro on Windows.
+bool FilePath::CreateFolder() const {
+#if GTEST_OS_WINDOWS_MOBILE
+  FilePath removed_sep(this->RemoveTrailingPathSeparator());
+  LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
+  int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
+  delete [] unicode;
+#elif GTEST_OS_WINDOWS
+  int result = _mkdir(pathname_.c_str());
+#elif GTEST_OS_ESP8266 || GTEST_OS_XTENSA
+  // do nothing
+  int result = 0;
+#else
+  int result = mkdir(pathname_.c_str(), 0777);
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+  if (result == -1) {
+    return this->DirectoryExists();  // An error is OK if the directory exists.
+  }
+  return true;  // No error.
+}
+
+// If input name has a trailing separator character, remove it and return the
+// name, otherwise return the name string unmodified.
+// On Windows platform, uses \ as the separator, other platforms use /.
+FilePath FilePath::RemoveTrailingPathSeparator() const {
+  return IsDirectory()
+      ? FilePath(pathname_.substr(0, pathname_.length() - 1))
+      : *this;
+}
+
+// Removes any redundant separators that might be in the pathname.
+// For example, "bar///foo" becomes "bar/foo". Does not eliminate other
+// redundancies that might be in a pathname involving "." or "..".
+void FilePath::Normalize() {
+  auto out = pathname_.begin();
+
+  for (const char character : pathname_) {
+    if (!IsPathSeparator(character)) {
+      *(out++) = character;
+    } else if (out == pathname_.begin() || *std::prev(out) != kPathSeparator) {
+      *(out++) = kPathSeparator;
+    } else {
+      continue;
+    }
+  }
+
+  pathname_.erase(out, pathname_.end());
+}
+
+}  // namespace internal
+}  // namespace testing
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This file implements just enough of the matcher interface to allow
+// EXPECT_DEATH and friends to accept a matcher argument.
+
+
+#include <string>
+
+namespace testing {
+
+// Constructs a matcher that matches a const std::string& whose value is
+// equal to s.
+Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); }
+
+// Constructs a matcher that matches a const std::string& whose value is
+// equal to s.
+Matcher<const std::string&>::Matcher(const char* s) {
+  *this = Eq(std::string(s));
+}
+
+// Constructs a matcher that matches a std::string whose value is equal to
+// s.
+Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); }
+
+// Constructs a matcher that matches a std::string whose value is equal to
+// s.
+Matcher<std::string>::Matcher(const char* s) { *this = Eq(std::string(s)); }
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+// Constructs a matcher that matches a const StringView& whose value is
+// equal to s.
+Matcher<const internal::StringView&>::Matcher(const std::string& s) {
+  *this = Eq(s);
+}
+
+// Constructs a matcher that matches a const StringView& whose value is
+// equal to s.
+Matcher<const internal::StringView&>::Matcher(const char* s) {
+  *this = Eq(std::string(s));
+}
+
+// Constructs a matcher that matches a const StringView& whose value is
+// equal to s.
+Matcher<const internal::StringView&>::Matcher(internal::StringView s) {
+  *this = Eq(std::string(s));
+}
+
+// Constructs a matcher that matches a StringView whose value is equal to
+// s.
+Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); }
+
+// Constructs a matcher that matches a StringView whose value is equal to
+// s.
+Matcher<internal::StringView>::Matcher(const char* s) {
+  *this = Eq(std::string(s));
+}
+
+// Constructs a matcher that matches a StringView whose value is equal to
+// s.
+Matcher<internal::StringView>::Matcher(internal::StringView s) {
+  *this = Eq(std::string(s));
+}
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+}  // namespace testing
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <cstdint>
+#include <fstream>
+#include <memory>
+
+#if GTEST_OS_WINDOWS
+# include <windows.h>
+# include <io.h>
+# include <sys/stat.h>
+# include <map>  // Used in ThreadLocal.
+# ifdef _MSC_VER
+#  include <crtdbg.h>
+# endif  // _MSC_VER
+#else
+# include <unistd.h>
+#endif  // GTEST_OS_WINDOWS
+
+#if GTEST_OS_MAC
+# include <mach/mach_init.h>
+# include <mach/task.h>
+# include <mach/vm_map.h>
+#endif  // GTEST_OS_MAC
+
+#if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
+    GTEST_OS_NETBSD || GTEST_OS_OPENBSD
+# include <sys/sysctl.h>
+# if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
+#  include <sys/user.h>
+# endif
+#endif
+
+#if GTEST_OS_QNX
+# include <devctl.h>
+# include <fcntl.h>
+# include <sys/procfs.h>
+#endif  // GTEST_OS_QNX
+
+#if GTEST_OS_AIX
+# include <procinfo.h>
+# include <sys/types.h>
+#endif  // GTEST_OS_AIX
+
+#if GTEST_OS_FUCHSIA
+# include <zircon/process.h>
+# include <zircon/syscalls.h>
+#endif  // GTEST_OS_FUCHSIA
+
+
+namespace testing {
+namespace internal {
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
+const int kStdOutFileno = 1;
+const int kStdErrFileno = 2;
+#else
+const int kStdOutFileno = STDOUT_FILENO;
+const int kStdErrFileno = STDERR_FILENO;
+#endif  // _MSC_VER
+
+#if GTEST_OS_LINUX
+
+namespace {
+template <typename T>
+T ReadProcFileField(const std::string& filename, int field) {
+  std::string dummy;
+  std::ifstream file(filename.c_str());
+  while (field-- > 0) {
+    file >> dummy;
+  }
+  T output = 0;
+  file >> output;
+  return output;
+}
+}  // namespace
+
+// Returns the number of active threads, or 0 when there is an error.
+size_t GetThreadCount() {
+  const std::string filename =
+      (Message() << "/proc/" << getpid() << "/stat").GetString();
+  return ReadProcFileField<size_t>(filename, 19);
+}
+
+#elif GTEST_OS_MAC
+
+size_t GetThreadCount() {
+  const task_t task = mach_task_self();
+  mach_msg_type_number_t thread_count;
+  thread_act_array_t thread_list;
+  const kern_return_t status = task_threads(task, &thread_list, &thread_count);
+  if (status == KERN_SUCCESS) {
+    // task_threads allocates resources in thread_list and we need to free them
+    // to avoid leaks.
+    vm_deallocate(task,
+                  reinterpret_cast<vm_address_t>(thread_list),
+                  sizeof(thread_t) * thread_count);
+    return static_cast<size_t>(thread_count);
+  } else {
+    return 0;
+  }
+}
+
+#elif GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
+      GTEST_OS_NETBSD
+
+#if GTEST_OS_NETBSD
+#undef KERN_PROC
+#define KERN_PROC KERN_PROC2
+#define kinfo_proc kinfo_proc2
+#endif
+
+#if GTEST_OS_DRAGONFLY
+#define KP_NLWP(kp) (kp.kp_nthreads)
+#elif GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
+#define KP_NLWP(kp) (kp.ki_numthreads)
+#elif GTEST_OS_NETBSD
+#define KP_NLWP(kp) (kp.p_nlwps)
+#endif
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+size_t GetThreadCount() {
+  int mib[] = {
+    CTL_KERN,
+    KERN_PROC,
+    KERN_PROC_PID,
+    getpid(),
+#if GTEST_OS_NETBSD
+    sizeof(struct kinfo_proc),
+    1,
+#endif
+  };
+  u_int miblen = sizeof(mib) / sizeof(mib[0]);
+  struct kinfo_proc info;
+  size_t size = sizeof(info);
+  if (sysctl(mib, miblen, &info, &size, NULL, 0)) {
+    return 0;
+  }
+  return static_cast<size_t>(KP_NLWP(info));
+}
+#elif GTEST_OS_OPENBSD
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+size_t GetThreadCount() {
+  int mib[] = {
+    CTL_KERN,
+    KERN_PROC,
+    KERN_PROC_PID | KERN_PROC_SHOW_THREADS,
+    getpid(),
+    sizeof(struct kinfo_proc),
+    0,
+  };
+  u_int miblen = sizeof(mib) / sizeof(mib[0]);
+
+  // get number of structs
+  size_t size;
+  if (sysctl(mib, miblen, NULL, &size, NULL, 0)) {
+    return 0;
+  }
+
+  mib[5] = static_cast<int>(size / static_cast<size_t>(mib[4]));
+
+  // populate array of structs
+  struct kinfo_proc info[mib[5]];
+  if (sysctl(mib, miblen, &info, &size, NULL, 0)) {
+    return 0;
+  }
+
+  // exclude empty members
+  size_t nthreads = 0;
+  for (size_t i = 0; i < size / static_cast<size_t>(mib[4]); i++) {
+    if (info[i].p_tid != -1)
+      nthreads++;
+  }
+  return nthreads;
+}
+
+#elif GTEST_OS_QNX
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+size_t GetThreadCount() {
+  const int fd = open("/proc/self/as", O_RDONLY);
+  if (fd < 0) {
+    return 0;
+  }
+  procfs_info process_info;
+  const int status =
+      devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), nullptr);
+  close(fd);
+  if (status == EOK) {
+    return static_cast<size_t>(process_info.num_threads);
+  } else {
+    return 0;
+  }
+}
+
+#elif GTEST_OS_AIX
+
+size_t GetThreadCount() {
+  struct procentry64 entry;
+  pid_t pid = getpid();
+  int status = getprocs64(&entry, sizeof(entry), nullptr, 0, &pid, 1);
+  if (status == 1) {
+    return entry.pi_thcount;
+  } else {
+    return 0;
+  }
+}
+
+#elif GTEST_OS_FUCHSIA
+
+size_t GetThreadCount() {
+  int dummy_buffer;
+  size_t avail;
+  zx_status_t status = zx_object_get_info(
+      zx_process_self(),
+      ZX_INFO_PROCESS_THREADS,
+      &dummy_buffer,
+      0,
+      nullptr,
+      &avail);
+  if (status == ZX_OK) {
+    return avail;
+  } else {
+    return 0;
+  }
+}
+
+#else
+
+size_t GetThreadCount() {
+  // There's no portable way to detect the number of threads, so we just
+  // return 0 to indicate that we cannot detect it.
+  return 0;
+}
+
+#endif  // GTEST_OS_LINUX
+
+#if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
+
+void SleepMilliseconds(int n) {
+  ::Sleep(static_cast<DWORD>(n));
+}
+
+AutoHandle::AutoHandle()
+    : handle_(INVALID_HANDLE_VALUE) {}
+
+AutoHandle::AutoHandle(Handle handle)
+    : handle_(handle) {}
+
+AutoHandle::~AutoHandle() {
+  Reset();
+}
+
+AutoHandle::Handle AutoHandle::Get() const {
+  return handle_;
+}
+
+void AutoHandle::Reset() {
+  Reset(INVALID_HANDLE_VALUE);
+}
+
+void AutoHandle::Reset(HANDLE handle) {
+  // Resetting with the same handle we already own is invalid.
+  if (handle_ != handle) {
+    if (IsCloseable()) {
+      ::CloseHandle(handle_);
+    }
+    handle_ = handle;
+  } else {
+    GTEST_CHECK_(!IsCloseable())
+        << "Resetting a valid handle to itself is likely a programmer error "
+            "and thus not allowed.";
+  }
+}
+
+bool AutoHandle::IsCloseable() const {
+  // Different Windows APIs may use either of these values to represent an
+  // invalid handle.
+  return handle_ != nullptr && handle_ != INVALID_HANDLE_VALUE;
+}
+
+Notification::Notification()
+    : event_(::CreateEvent(nullptr,     // Default security attributes.
+                           TRUE,        // Do not reset automatically.
+                           FALSE,       // Initially unset.
+                           nullptr)) {  // Anonymous event.
+  GTEST_CHECK_(event_.Get() != nullptr);
+}
+
+void Notification::Notify() {
+  GTEST_CHECK_(::SetEvent(event_.Get()) != FALSE);
+}
+
+void Notification::WaitForNotification() {
+  GTEST_CHECK_(
+      ::WaitForSingleObject(event_.Get(), INFINITE) == WAIT_OBJECT_0);
+}
+
+Mutex::Mutex()
+    : owner_thread_id_(0),
+      type_(kDynamic),
+      critical_section_init_phase_(0),
+      critical_section_(new CRITICAL_SECTION) {
+  ::InitializeCriticalSection(critical_section_);
+}
+
+Mutex::~Mutex() {
+  // Static mutexes are leaked intentionally. It is not thread-safe to try
+  // to clean them up.
+  if (type_ == kDynamic) {
+    ::DeleteCriticalSection(critical_section_);
+    delete critical_section_;
+    critical_section_ = nullptr;
+  }
+}
+
+void Mutex::Lock() {
+  ThreadSafeLazyInit();
+  ::EnterCriticalSection(critical_section_);
+  owner_thread_id_ = ::GetCurrentThreadId();
+}
+
+void Mutex::Unlock() {
+  ThreadSafeLazyInit();
+  // We don't protect writing to owner_thread_id_ here, as it's the
+  // caller's responsibility to ensure that the current thread holds the
+  // mutex when this is called.
+  owner_thread_id_ = 0;
+  ::LeaveCriticalSection(critical_section_);
+}
+
+// Does nothing if the current thread holds the mutex. Otherwise, crashes
+// with high probability.
+void Mutex::AssertHeld() {
+  ThreadSafeLazyInit();
+  GTEST_CHECK_(owner_thread_id_ == ::GetCurrentThreadId())
+      << "The current thread is not holding the mutex @" << this;
+}
+
+namespace {
+
+#ifdef _MSC_VER
+// Use the RAII idiom to flag mem allocs that are intentionally never
+// deallocated. The motivation is to silence the false positive mem leaks
+// that are reported by the debug version of MS's CRT which can only detect
+// if an alloc is missing a matching deallocation.
+// Example:
+//    MemoryIsNotDeallocated memory_is_not_deallocated;
+//    critical_section_ = new CRITICAL_SECTION;
+//
+class MemoryIsNotDeallocated
+{
+ public:
+  MemoryIsNotDeallocated() : old_crtdbg_flag_(0) {
+    old_crtdbg_flag_ = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+    // Set heap allocation block type to _IGNORE_BLOCK so that MS debug CRT
+    // doesn't report mem leak if there's no matching deallocation.
+    _CrtSetDbgFlag(old_crtdbg_flag_ & ~_CRTDBG_ALLOC_MEM_DF);
+  }
+
+  ~MemoryIsNotDeallocated() {
+    // Restore the original _CRTDBG_ALLOC_MEM_DF flag
+    _CrtSetDbgFlag(old_crtdbg_flag_);
+  }
+
+ private:
+  int old_crtdbg_flag_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MemoryIsNotDeallocated);
+};
+#endif  // _MSC_VER
+
+}  // namespace
+
+// Initializes owner_thread_id_ and critical_section_ in static mutexes.
+void Mutex::ThreadSafeLazyInit() {
+  // Dynamic mutexes are initialized in the constructor.
+  if (type_ == kStatic) {
+    switch (
+        ::InterlockedCompareExchange(&critical_section_init_phase_, 1L, 0L)) {
+      case 0:
+        // If critical_section_init_phase_ was 0 before the exchange, we
+        // are the first to test it and need to perform the initialization.
+        owner_thread_id_ = 0;
+        {
+          // Use RAII to flag that following mem alloc is never deallocated.
+#ifdef _MSC_VER
+          MemoryIsNotDeallocated memory_is_not_deallocated;
+#endif  // _MSC_VER
+          critical_section_ = new CRITICAL_SECTION;
+        }
+        ::InitializeCriticalSection(critical_section_);
+        // Updates the critical_section_init_phase_ to 2 to signal
+        // initialization complete.
+        GTEST_CHECK_(::InterlockedCompareExchange(
+                          &critical_section_init_phase_, 2L, 1L) ==
+                      1L);
+        break;
+      case 1:
+        // Somebody else is already initializing the mutex; spin until they
+        // are done.
+        while (::InterlockedCompareExchange(&critical_section_init_phase_,
+                                            2L,
+                                            2L) != 2L) {
+          // Possibly yields the rest of the thread's time slice to other
+          // threads.
+          ::Sleep(0);
+        }
+        break;
+
+      case 2:
+        break;  // The mutex is already initialized and ready for use.
+
+      default:
+        GTEST_CHECK_(false)
+            << "Unexpected value of critical_section_init_phase_ "
+            << "while initializing a static mutex.";
+    }
+  }
+}
+
+namespace {
+
+class ThreadWithParamSupport : public ThreadWithParamBase {
+ public:
+  static HANDLE CreateThread(Runnable* runnable,
+                             Notification* thread_can_start) {
+    ThreadMainParam* param = new ThreadMainParam(runnable, thread_can_start);
+    DWORD thread_id;
+    HANDLE thread_handle = ::CreateThread(
+        nullptr,  // Default security.
+        0,        // Default stack size.
+        &ThreadWithParamSupport::ThreadMain,
+        param,        // Parameter to ThreadMainStatic
+        0x0,          // Default creation flags.
+        &thread_id);  // Need a valid pointer for the call to work under Win98.
+    GTEST_CHECK_(thread_handle != nullptr)
+        << "CreateThread failed with error " << ::GetLastError() << ".";
+    if (thread_handle == nullptr) {
+      delete param;
+    }
+    return thread_handle;
+  }
+
+ private:
+  struct ThreadMainParam {
+    ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
+        : runnable_(runnable),
+          thread_can_start_(thread_can_start) {
+    }
+    std::unique_ptr<Runnable> runnable_;
+    // Does not own.
+    Notification* thread_can_start_;
+  };
+
+  static DWORD WINAPI ThreadMain(void* ptr) {
+    // Transfers ownership.
+    std::unique_ptr<ThreadMainParam> param(static_cast<ThreadMainParam*>(ptr));
+    if (param->thread_can_start_ != nullptr)
+      param->thread_can_start_->WaitForNotification();
+    param->runnable_->Run();
+    return 0;
+  }
+
+  // Prohibit instantiation.
+  ThreadWithParamSupport();
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParamSupport);
+};
+
+}  // namespace
+
+ThreadWithParamBase::ThreadWithParamBase(Runnable *runnable,
+                                         Notification* thread_can_start)
+      : thread_(ThreadWithParamSupport::CreateThread(runnable,
+                                                     thread_can_start)) {
+}
+
+ThreadWithParamBase::~ThreadWithParamBase() {
+  Join();
+}
+
+void ThreadWithParamBase::Join() {
+  GTEST_CHECK_(::WaitForSingleObject(thread_.Get(), INFINITE) == WAIT_OBJECT_0)
+      << "Failed to join the thread with error " << ::GetLastError() << ".";
+}
+
+// Maps a thread to a set of ThreadIdToThreadLocals that have values
+// instantiated on that thread and notifies them when the thread exits.  A
+// ThreadLocal instance is expected to persist until all threads it has
+// values on have terminated.
+class ThreadLocalRegistryImpl {
+ public:
+  // Registers thread_local_instance as having value on the current thread.
+  // Returns a value that can be used to identify the thread from other threads.
+  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
+      const ThreadLocalBase* thread_local_instance) {
+#ifdef _MSC_VER
+    MemoryIsNotDeallocated memory_is_not_deallocated;
+#endif  // _MSC_VER
+    DWORD current_thread = ::GetCurrentThreadId();
+    MutexLock lock(&mutex_);
+    ThreadIdToThreadLocals* const thread_to_thread_locals =
+        GetThreadLocalsMapLocked();
+    ThreadIdToThreadLocals::iterator thread_local_pos =
+        thread_to_thread_locals->find(current_thread);
+    if (thread_local_pos == thread_to_thread_locals->end()) {
+      thread_local_pos = thread_to_thread_locals->insert(
+          std::make_pair(current_thread, ThreadLocalValues())).first;
+      StartWatcherThreadFor(current_thread);
+    }
+    ThreadLocalValues& thread_local_values = thread_local_pos->second;
+    ThreadLocalValues::iterator value_pos =
+        thread_local_values.find(thread_local_instance);
+    if (value_pos == thread_local_values.end()) {
+      value_pos =
+          thread_local_values
+              .insert(std::make_pair(
+                  thread_local_instance,
+                  std::shared_ptr<ThreadLocalValueHolderBase>(
+                      thread_local_instance->NewValueForCurrentThread())))
+              .first;
+    }
+    return value_pos->second.get();
+  }
+
+  static void OnThreadLocalDestroyed(
+      const ThreadLocalBase* thread_local_instance) {
+    std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders;
+    // Clean up the ThreadLocalValues data structure while holding the lock, but
+    // defer the destruction of the ThreadLocalValueHolderBases.
+    {
+      MutexLock lock(&mutex_);
+      ThreadIdToThreadLocals* const thread_to_thread_locals =
+          GetThreadLocalsMapLocked();
+      for (ThreadIdToThreadLocals::iterator it =
+          thread_to_thread_locals->begin();
+          it != thread_to_thread_locals->end();
+          ++it) {
+        ThreadLocalValues& thread_local_values = it->second;
+        ThreadLocalValues::iterator value_pos =
+            thread_local_values.find(thread_local_instance);
+        if (value_pos != thread_local_values.end()) {
+          value_holders.push_back(value_pos->second);
+          thread_local_values.erase(value_pos);
+          // This 'if' can only be successful at most once, so theoretically we
+          // could break out of the loop here, but we don't bother doing so.
+        }
+      }
+    }
+    // Outside the lock, let the destructor for 'value_holders' deallocate the
+    // ThreadLocalValueHolderBases.
+  }
+
+  static void OnThreadExit(DWORD thread_id) {
+    GTEST_CHECK_(thread_id != 0) << ::GetLastError();
+    std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders;
+    // Clean up the ThreadIdToThreadLocals data structure while holding the
+    // lock, but defer the destruction of the ThreadLocalValueHolderBases.
+    {
+      MutexLock lock(&mutex_);
+      ThreadIdToThreadLocals* const thread_to_thread_locals =
+          GetThreadLocalsMapLocked();
+      ThreadIdToThreadLocals::iterator thread_local_pos =
+          thread_to_thread_locals->find(thread_id);
+      if (thread_local_pos != thread_to_thread_locals->end()) {
+        ThreadLocalValues& thread_local_values = thread_local_pos->second;
+        for (ThreadLocalValues::iterator value_pos =
+            thread_local_values.begin();
+            value_pos != thread_local_values.end();
+            ++value_pos) {
+          value_holders.push_back(value_pos->second);
+        }
+        thread_to_thread_locals->erase(thread_local_pos);
+      }
+    }
+    // Outside the lock, let the destructor for 'value_holders' deallocate the
+    // ThreadLocalValueHolderBases.
+  }
+
+ private:
+  // In a particular thread, maps a ThreadLocal object to its value.
+  typedef std::map<const ThreadLocalBase*,
+                   std::shared_ptr<ThreadLocalValueHolderBase> >
+      ThreadLocalValues;
+  // Stores all ThreadIdToThreadLocals having values in a thread, indexed by
+  // thread's ID.
+  typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals;
+
+  // Holds the thread id and thread handle that we pass from
+  // StartWatcherThreadFor to WatcherThreadFunc.
+  typedef std::pair<DWORD, HANDLE> ThreadIdAndHandle;
+
+  static void StartWatcherThreadFor(DWORD thread_id) {
+    // The returned handle will be kept in thread_map and closed by
+    // watcher_thread in WatcherThreadFunc.
+    HANDLE thread = ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION,
+                                 FALSE,
+                                 thread_id);
+    GTEST_CHECK_(thread != nullptr);
+    // We need to pass a valid thread ID pointer into CreateThread for it
+    // to work correctly under Win98.
+    DWORD watcher_thread_id;
+    HANDLE watcher_thread = ::CreateThread(
+        nullptr,  // Default security.
+        0,        // Default stack size
+        &ThreadLocalRegistryImpl::WatcherThreadFunc,
+        reinterpret_cast<LPVOID>(new ThreadIdAndHandle(thread_id, thread)),
+        CREATE_SUSPENDED, &watcher_thread_id);
+    GTEST_CHECK_(watcher_thread != nullptr);
+    // Give the watcher thread the same priority as ours to avoid being
+    // blocked by it.
+    ::SetThreadPriority(watcher_thread,
+                        ::GetThreadPriority(::GetCurrentThread()));
+    ::ResumeThread(watcher_thread);
+    ::CloseHandle(watcher_thread);
+  }
+
+  // Monitors exit from a given thread and notifies those
+  // ThreadIdToThreadLocals about thread termination.
+  static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
+    const ThreadIdAndHandle* tah =
+        reinterpret_cast<const ThreadIdAndHandle*>(param);
+    GTEST_CHECK_(
+        ::WaitForSingleObject(tah->second, INFINITE) == WAIT_OBJECT_0);
+    OnThreadExit(tah->first);
+    ::CloseHandle(tah->second);
+    delete tah;
+    return 0;
+  }
+
+  // Returns map of thread local instances.
+  static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
+    mutex_.AssertHeld();
+#ifdef _MSC_VER
+    MemoryIsNotDeallocated memory_is_not_deallocated;
+#endif  // _MSC_VER
+    static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals();
+    return map;
+  }
+
+  // Protects access to GetThreadLocalsMapLocked() and its return value.
+  static Mutex mutex_;
+  // Protects access to GetThreadMapLocked() and its return value.
+  static Mutex thread_map_mutex_;
+};
+
+Mutex ThreadLocalRegistryImpl::mutex_(Mutex::kStaticMutex);
+Mutex ThreadLocalRegistryImpl::thread_map_mutex_(Mutex::kStaticMutex);
+
+ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentThread(
+      const ThreadLocalBase* thread_local_instance) {
+  return ThreadLocalRegistryImpl::GetValueOnCurrentThread(
+      thread_local_instance);
+}
+
+void ThreadLocalRegistry::OnThreadLocalDestroyed(
+      const ThreadLocalBase* thread_local_instance) {
+  ThreadLocalRegistryImpl::OnThreadLocalDestroyed(thread_local_instance);
+}
+
+#endif  // GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
+
+#if GTEST_USES_POSIX_RE
+
+// Implements RE.  Currently only needed for death tests.
+
+RE::~RE() {
+  if (is_valid_) {
+    // regfree'ing an invalid regex might crash because the content
+    // of the regex is undefined. Since the regex's are essentially
+    // the same, one cannot be valid (or invalid) without the other
+    // being so too.
+    regfree(&partial_regex_);
+    regfree(&full_regex_);
+  }
+  free(const_cast<char*>(pattern_));
+}
+
+// Returns true if and only if regular expression re matches the entire str.
+bool RE::FullMatch(const char* str, const RE& re) {
+  if (!re.is_valid_) return false;
+
+  regmatch_t match;
+  return regexec(&re.full_regex_, str, 1, &match, 0) == 0;
+}
+
+// Returns true if and only if regular expression re matches a substring of
+// str (including str itself).
+bool RE::PartialMatch(const char* str, const RE& re) {
+  if (!re.is_valid_) return false;
+
+  regmatch_t match;
+  return regexec(&re.partial_regex_, str, 1, &match, 0) == 0;
+}
+
+// Initializes an RE from its string representation.
+void RE::Init(const char* regex) {
+  pattern_ = posix::StrDup(regex);
+
+  // Reserves enough bytes to hold the regular expression used for a
+  // full match.
+  const size_t full_regex_len = strlen(regex) + 10;
+  char* const full_pattern = new char[full_regex_len];
+
+  snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
+  is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0;
+  // We want to call regcomp(&partial_regex_, ...) even if the
+  // previous expression returns false.  Otherwise partial_regex_ may
+  // not be properly initialized can may cause trouble when it's
+  // freed.
+  //
+  // Some implementation of POSIX regex (e.g. on at least some
+  // versions of Cygwin) doesn't accept the empty string as a valid
+  // regex.  We change it to an equivalent form "()" to be safe.
+  if (is_valid_) {
+    const char* const partial_regex = (*regex == '\0') ? "()" : regex;
+    is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0;
+  }
+  EXPECT_TRUE(is_valid_)
+      << "Regular expression \"" << regex
+      << "\" is not a valid POSIX Extended regular expression.";
+
+  delete[] full_pattern;
+}
+
+#elif GTEST_USES_SIMPLE_RE
+
+// Returns true if and only if ch appears anywhere in str (excluding the
+// terminating '\0' character).
+bool IsInSet(char ch, const char* str) {
+  return ch != '\0' && strchr(str, ch) != nullptr;
+}
+
+// Returns true if and only if ch belongs to the given classification.
+// Unlike similar functions in <ctype.h>, these aren't affected by the
+// current locale.
+bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
+bool IsAsciiPunct(char ch) {
+  return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~");
+}
+bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
+bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
+bool IsAsciiWordChar(char ch) {
+  return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') ||
+      ('0' <= ch && ch <= '9') || ch == '_';
+}
+
+// Returns true if and only if "\\c" is a supported escape sequence.
+bool IsValidEscape(char c) {
+  return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW"));
+}
+
+// Returns true if and only if the given atom (specified by escaped and
+// pattern) matches ch.  The result is undefined if the atom is invalid.
+bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
+  if (escaped) {  // "\\p" where p is pattern_char.
+    switch (pattern_char) {
+      case 'd': return IsAsciiDigit(ch);
+      case 'D': return !IsAsciiDigit(ch);
+      case 'f': return ch == '\f';
+      case 'n': return ch == '\n';
+      case 'r': return ch == '\r';
+      case 's': return IsAsciiWhiteSpace(ch);
+      case 'S': return !IsAsciiWhiteSpace(ch);
+      case 't': return ch == '\t';
+      case 'v': return ch == '\v';
+      case 'w': return IsAsciiWordChar(ch);
+      case 'W': return !IsAsciiWordChar(ch);
+    }
+    return IsAsciiPunct(pattern_char) && pattern_char == ch;
+  }
+
+  return (pattern_char == '.' && ch != '\n') || pattern_char == ch;
+}
+
+// Helper function used by ValidateRegex() to format error messages.
+static std::string FormatRegexSyntaxError(const char* regex, int index) {
+  return (Message() << "Syntax error at index " << index
+          << " in simple regular expression \"" << regex << "\": ").GetString();
+}
+
+// Generates non-fatal failures and returns false if regex is invalid;
+// otherwise returns true.
+bool ValidateRegex(const char* regex) {
+  if (regex == nullptr) {
+    ADD_FAILURE() << "NULL is not a valid simple regular expression.";
+    return false;
+  }
+
+  bool is_valid = true;
+
+  // True if and only if ?, *, or + can follow the previous atom.
+  bool prev_repeatable = false;
+  for (int i = 0; regex[i]; i++) {
+    if (regex[i] == '\\') {  // An escape sequence
+      i++;
+      if (regex[i] == '\0') {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
+                      << "'\\' cannot appear at the end.";
+        return false;
+      }
+
+      if (!IsValidEscape(regex[i])) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
+                      << "invalid escape sequence \"\\" << regex[i] << "\".";
+        is_valid = false;
+      }
+      prev_repeatable = true;
+    } else {  // Not an escape sequence.
+      const char ch = regex[i];
+
+      if (ch == '^' && i > 0) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'^' can only appear at the beginning.";
+        is_valid = false;
+      } else if (ch == '$' && regex[i + 1] != '\0') {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'$' can only appear at the end.";
+        is_valid = false;
+      } else if (IsInSet(ch, "()[]{}|")) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'" << ch << "' is unsupported.";
+        is_valid = false;
+      } else if (IsRepeat(ch) && !prev_repeatable) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'" << ch << "' can only follow a repeatable token.";
+        is_valid = false;
+      }
+
+      prev_repeatable = !IsInSet(ch, "^$?*+");
+    }
+  }
+
+  return is_valid;
+}
+
+// Matches a repeated regex atom followed by a valid simple regular
+// expression.  The regex atom is defined as c if escaped is false,
+// or \c otherwise.  repeat is the repetition meta character (?, *,
+// or +).  The behavior is undefined if str contains too many
+// characters to be indexable by size_t, in which case the test will
+// probably time out anyway.  We are fine with this limitation as
+// std::string has it too.
+bool MatchRepetitionAndRegexAtHead(
+    bool escaped, char c, char repeat, const char* regex,
+    const char* str) {
+  const size_t min_count = (repeat == '+') ? 1 : 0;
+  const size_t max_count = (repeat == '?') ? 1 :
+      static_cast<size_t>(-1) - 1;
+  // We cannot call numeric_limits::max() as it conflicts with the
+  // max() macro on Windows.
+
+  for (size_t i = 0; i <= max_count; ++i) {
+    // We know that the atom matches each of the first i characters in str.
+    if (i >= min_count && MatchRegexAtHead(regex, str + i)) {
+      // We have enough matches at the head, and the tail matches too.
+      // Since we only care about *whether* the pattern matches str
+      // (as opposed to *how* it matches), there is no need to find a
+      // greedy match.
+      return true;
+    }
+    if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i]))
+      return false;
+  }
+  return false;
+}
+
+// Returns true if and only if regex matches a prefix of str. regex must
+// be a valid simple regular expression and not start with "^", or the
+// result is undefined.
+bool MatchRegexAtHead(const char* regex, const char* str) {
+  if (*regex == '\0')  // An empty regex matches a prefix of anything.
+    return true;
+
+  // "$" only matches the end of a string.  Note that regex being
+  // valid guarantees that there's nothing after "$" in it.
+  if (*regex == '$')
+    return *str == '\0';
+
+  // Is the first thing in regex an escape sequence?
+  const bool escaped = *regex == '\\';
+  if (escaped)
+    ++regex;
+  if (IsRepeat(regex[1])) {
+    // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so
+    // here's an indirect recursion.  It terminates as the regex gets
+    // shorter in each recursion.
+    return MatchRepetitionAndRegexAtHead(
+        escaped, regex[0], regex[1], regex + 2, str);
+  } else {
+    // regex isn't empty, isn't "$", and doesn't start with a
+    // repetition.  We match the first atom of regex with the first
+    // character of str and recurse.
+    return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) &&
+        MatchRegexAtHead(regex + 1, str + 1);
+  }
+}
+
+// Returns true if and only if regex matches any substring of str.  regex must
+// be a valid simple regular expression, or the result is undefined.
+//
+// The algorithm is recursive, but the recursion depth doesn't exceed
+// the regex length, so we won't need to worry about running out of
+// stack space normally.  In rare cases the time complexity can be
+// exponential with respect to the regex length + the string length,
+// but usually it's must faster (often close to linear).
+bool MatchRegexAnywhere(const char* regex, const char* str) {
+  if (regex == nullptr || str == nullptr) return false;
+
+  if (*regex == '^')
+    return MatchRegexAtHead(regex + 1, str);
+
+  // A successful match can be anywhere in str.
+  do {
+    if (MatchRegexAtHead(regex, str))
+      return true;
+  } while (*str++ != '\0');
+  return false;
+}
+
+// Implements the RE class.
+
+RE::~RE() {
+  free(const_cast<char*>(pattern_));
+  free(const_cast<char*>(full_pattern_));
+}
+
+// Returns true if and only if regular expression re matches the entire str.
+bool RE::FullMatch(const char* str, const RE& re) {
+  return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str);
+}
+
+// Returns true if and only if regular expression re matches a substring of
+// str (including str itself).
+bool RE::PartialMatch(const char* str, const RE& re) {
+  return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str);
+}
+
+// Initializes an RE from its string representation.
+void RE::Init(const char* regex) {
+  pattern_ = full_pattern_ = nullptr;
+  if (regex != nullptr) {
+    pattern_ = posix::StrDup(regex);
+  }
+
+  is_valid_ = ValidateRegex(regex);
+  if (!is_valid_) {
+    // No need to calculate the full pattern when the regex is invalid.
+    return;
+  }
+
+  const size_t len = strlen(regex);
+  // Reserves enough bytes to hold the regular expression used for a
+  // full match: we need space to prepend a '^', append a '$', and
+  // terminate the string with '\0'.
+  char* buffer = static_cast<char*>(malloc(len + 3));
+  full_pattern_ = buffer;
+
+  if (*regex != '^')
+    *buffer++ = '^';  // Makes sure full_pattern_ starts with '^'.
+
+  // We don't use snprintf or strncpy, as they trigger a warning when
+  // compiled with VC++ 8.0.
+  memcpy(buffer, regex, len);
+  buffer += len;
+
+  if (len == 0 || regex[len - 1] != '$')
+    *buffer++ = '$';  // Makes sure full_pattern_ ends with '$'.
+
+  *buffer = '\0';
+}
+
+#endif  // GTEST_USES_POSIX_RE
+
+const char kUnknownFile[] = "unknown file";
+
+// Formats a source file path and a line number as they would appear
+// in an error message from the compiler used to compile this code.
+GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
+  const std::string file_name(file == nullptr ? kUnknownFile : file);
+
+  if (line < 0) {
+    return file_name + ":";
+  }
+#ifdef _MSC_VER
+  return file_name + "(" + StreamableToString(line) + "):";
+#else
+  return file_name + ":" + StreamableToString(line) + ":";
+#endif  // _MSC_VER
+}
+
+// Formats a file location for compiler-independent XML output.
+// Although this function is not platform dependent, we put it next to
+// FormatFileLocation in order to contrast the two functions.
+// Note that FormatCompilerIndependentFileLocation() does NOT append colon
+// to the file location it produces, unlike FormatFileLocation().
+GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
+    const char* file, int line) {
+  const std::string file_name(file == nullptr ? kUnknownFile : file);
+
+  if (line < 0)
+    return file_name;
+  else
+    return file_name + ":" + StreamableToString(line);
+}
+
+GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
+    : severity_(severity) {
+  const char* const marker =
+      severity == GTEST_INFO ?    "[  INFO ]" :
+      severity == GTEST_WARNING ? "[WARNING]" :
+      severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
+  GetStream() << ::std::endl << marker << " "
+              << FormatFileLocation(file, line).c_str() << ": ";
+}
+
+// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
+GTestLog::~GTestLog() {
+  GetStream() << ::std::endl;
+  if (severity_ == GTEST_FATAL) {
+    fflush(stderr);
+    posix::Abort();
+  }
+}
+
+// Disable Microsoft deprecation warnings for POSIX functions called from
+// this class (creat, dup, dup2, and close)
+GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Object that captures an output stream (stdout/stderr).
+class CapturedStream {
+ public:
+  // The ctor redirects the stream to a temporary file.
+  explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
+# if GTEST_OS_WINDOWS
+    char temp_dir_path[MAX_PATH + 1] = { '\0' };  // NOLINT
+    char temp_file_path[MAX_PATH + 1] = { '\0' };  // NOLINT
+
+    ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
+    const UINT success = ::GetTempFileNameA(temp_dir_path,
+                                            "gtest_redir",
+                                            0,  // Generate unique file name.
+                                            temp_file_path);
+    GTEST_CHECK_(success != 0)
+        << "Unable to create a temporary file in " << temp_dir_path;
+    const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
+    GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file "
+                                    << temp_file_path;
+    filename_ = temp_file_path;
+# else
+    // There's no guarantee that a test has write access to the current
+    // directory, so we create the temporary file in the /tmp directory
+    // instead. We use /tmp on most systems, and /sdcard on Android.
+    // That's because Android doesn't have /tmp.
+#  if GTEST_OS_LINUX_ANDROID
+    // Note: Android applications are expected to call the framework's
+    // Context.getExternalStorageDirectory() method through JNI to get
+    // the location of the world-writable SD Card directory. However,
+    // this requires a Context handle, which cannot be retrieved
+    // globally from native code. Doing so also precludes running the
+    // code as part of a regular standalone executable, which doesn't
+    // run in a Dalvik process (e.g. when running it through 'adb shell').
+    //
+    // The location /data/local/tmp is directly accessible from native code.
+    // '/sdcard' and other variants cannot be relied on, as they are not
+    // guaranteed to be mounted, or may have a delay in mounting.
+    char name_template[] = "/data/local/tmp/gtest_captured_stream.XXXXXX";
+#  else
+    char name_template[] = "/tmp/captured_stream.XXXXXX";
+#  endif  // GTEST_OS_LINUX_ANDROID
+    const int captured_fd = mkstemp(name_template);
+    if (captured_fd == -1) {
+      GTEST_LOG_(WARNING)
+          << "Failed to create tmp file " << name_template
+          << " for test; does the test have access to the /tmp directory?";
+    }
+    filename_ = name_template;
+# endif  // GTEST_OS_WINDOWS
+    fflush(nullptr);
+    dup2(captured_fd, fd_);
+    close(captured_fd);
+  }
+
+  ~CapturedStream() {
+    remove(filename_.c_str());
+  }
+
+  std::string GetCapturedString() {
+    if (uncaptured_fd_ != -1) {
+      // Restores the original stream.
+      fflush(nullptr);
+      dup2(uncaptured_fd_, fd_);
+      close(uncaptured_fd_);
+      uncaptured_fd_ = -1;
+    }
+
+    FILE* const file = posix::FOpen(filename_.c_str(), "r");
+    if (file == nullptr) {
+      GTEST_LOG_(FATAL) << "Failed to open tmp file " << filename_
+                        << " for capturing stream.";
+    }
+    const std::string content = ReadEntireFile(file);
+    posix::FClose(file);
+    return content;
+  }
+
+ private:
+  const int fd_;  // A stream to capture.
+  int uncaptured_fd_;
+  // Name of the temporary file holding the stderr output.
+  ::std::string filename_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
+};
+
+GTEST_DISABLE_MSC_DEPRECATED_POP_()
+
+static CapturedStream* g_captured_stderr = nullptr;
+static CapturedStream* g_captured_stdout = nullptr;
+
+// Starts capturing an output stream (stdout/stderr).
+static void CaptureStream(int fd, const char* stream_name,
+                          CapturedStream** stream) {
+  if (*stream != nullptr) {
+    GTEST_LOG_(FATAL) << "Only one " << stream_name
+                      << " capturer can exist at a time.";
+  }
+  *stream = new CapturedStream(fd);
+}
+
+// Stops capturing the output stream and returns the captured string.
+static std::string GetCapturedStream(CapturedStream** captured_stream) {
+  const std::string content = (*captured_stream)->GetCapturedString();
+
+  delete *captured_stream;
+  *captured_stream = nullptr;
+
+  return content;
+}
+
+// Starts capturing stdout.
+void CaptureStdout() {
+  CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout);
+}
+
+// Starts capturing stderr.
+void CaptureStderr() {
+  CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr);
+}
+
+// Stops capturing stdout and returns the captured string.
+std::string GetCapturedStdout() {
+  return GetCapturedStream(&g_captured_stdout);
+}
+
+// Stops capturing stderr and returns the captured string.
+std::string GetCapturedStderr() {
+  return GetCapturedStream(&g_captured_stderr);
+}
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+
+
+
+
+size_t GetFileSize(FILE* file) {
+  fseek(file, 0, SEEK_END);
+  return static_cast<size_t>(ftell(file));
+}
+
+std::string ReadEntireFile(FILE* file) {
+  const size_t file_size = GetFileSize(file);
+  char* const buffer = new char[file_size];
+
+  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
+  size_t bytes_read = 0;       // # of bytes read so far
+
+  fseek(file, 0, SEEK_SET);
+
+  // Keeps reading the file until we cannot read further or the
+  // pre-determined file size is reached.
+  do {
+    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
+    bytes_read += bytes_last_read;
+  } while (bytes_last_read > 0 && bytes_read < file_size);
+
+  const std::string content(buffer, bytes_read);
+  delete[] buffer;
+
+  return content;
+}
+
+#if GTEST_HAS_DEATH_TEST
+static const std::vector<std::string>* g_injected_test_argvs =
+    nullptr;  // Owned.
+
+std::vector<std::string> GetInjectableArgvs() {
+  if (g_injected_test_argvs != nullptr) {
+    return *g_injected_test_argvs;
+  }
+  return GetArgvs();
+}
+
+void SetInjectableArgvs(const std::vector<std::string>* new_argvs) {
+  if (g_injected_test_argvs != new_argvs) delete g_injected_test_argvs;
+  g_injected_test_argvs = new_argvs;
+}
+
+void SetInjectableArgvs(const std::vector<std::string>& new_argvs) {
+  SetInjectableArgvs(
+      new std::vector<std::string>(new_argvs.begin(), new_argvs.end()));
+}
+
+void ClearInjectableArgvs() {
+  delete g_injected_test_argvs;
+  g_injected_test_argvs = nullptr;
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+#if GTEST_OS_WINDOWS_MOBILE
+namespace posix {
+void Abort() {
+  DebugBreak();
+  TerminateProcess(GetCurrentProcess(), 1);
+}
+}  // namespace posix
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+// Returns the name of the environment variable corresponding to the
+// given flag.  For example, FlagToEnvVar("foo") will return
+// "GTEST_FOO" in the open-source version.
+static std::string FlagToEnvVar(const char* flag) {
+  const std::string full_flag =
+      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
+
+  Message env_var;
+  for (size_t i = 0; i != full_flag.length(); i++) {
+    env_var << ToUpper(full_flag.c_str()[i]);
+  }
+
+  return env_var.GetString();
+}
+
+// Parses 'str' for a 32-bit signed integer.  If successful, writes
+// the result to *value and returns true; otherwise leaves *value
+// unchanged and returns false.
+bool ParseInt32(const Message& src_text, const char* str, int32_t* value) {
+  // Parses the environment variable as a decimal integer.
+  char* end = nullptr;
+  const long long_value = strtol(str, &end, 10);  // NOLINT
+
+  // Has strtol() consumed all characters in the string?
+  if (*end != '\0') {
+    // No - an invalid character was encountered.
+    Message msg;
+    msg << "WARNING: " << src_text
+        << " is expected to be a 32-bit integer, but actually"
+        << " has value \"" << str << "\".\n";
+    printf("%s", msg.GetString().c_str());
+    fflush(stdout);
+    return false;
+  }
+
+  // Is the parsed value in the range of an int32_t?
+  const auto result = static_cast<int32_t>(long_value);
+  if (long_value == LONG_MAX || long_value == LONG_MIN ||
+      // The parsed value overflows as a long.  (strtol() returns
+      // LONG_MAX or LONG_MIN when the input overflows.)
+      result != long_value
+      // The parsed value overflows as an int32_t.
+      ) {
+    Message msg;
+    msg << "WARNING: " << src_text
+        << " is expected to be a 32-bit integer, but actually"
+        << " has value " << str << ", which overflows.\n";
+    printf("%s", msg.GetString().c_str());
+    fflush(stdout);
+    return false;
+  }
+
+  *value = result;
+  return true;
+}
+
+// Reads and returns the Boolean environment variable corresponding to
+// the given flag; if it's not set, returns default_value.
+//
+// The value is considered true if and only if it's not "0".
+bool BoolFromGTestEnv(const char* flag, bool default_value) {
+#if defined(GTEST_GET_BOOL_FROM_ENV_)
+  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
+#else
+  const std::string env_var = FlagToEnvVar(flag);
+  const char* const string_value = posix::GetEnv(env_var.c_str());
+  return string_value == nullptr ? default_value
+                                 : strcmp(string_value, "0") != 0;
+#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
+}
+
+// Reads and returns a 32-bit integer stored in the environment
+// variable corresponding to the given flag; if it isn't set or
+// doesn't represent a valid 32-bit integer, returns default_value.
+int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
+#if defined(GTEST_GET_INT32_FROM_ENV_)
+  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
+#else
+  const std::string env_var = FlagToEnvVar(flag);
+  const char* const string_value = posix::GetEnv(env_var.c_str());
+  if (string_value == nullptr) {
+    // The environment variable is not set.
+    return default_value;
+  }
+
+  int32_t result = default_value;
+  if (!ParseInt32(Message() << "Environment variable " << env_var,
+                  string_value, &result)) {
+    printf("The default value %s is used.\n",
+           (Message() << default_value).GetString().c_str());
+    fflush(stdout);
+    return default_value;
+  }
+
+  return result;
+#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
+}
+
+// As a special case for the 'output' flag, if GTEST_OUTPUT is not
+// set, we look for XML_OUTPUT_FILE, which is set by the Bazel build
+// system.  The value of XML_OUTPUT_FILE is a filename without the
+// "xml:" prefix of GTEST_OUTPUT.
+// Note that this is meant to be called at the call site so it does
+// not check that the flag is 'output'
+// In essence this checks an env variable called XML_OUTPUT_FILE
+// and if it is set we prepend "xml:" to its value, if it not set we return ""
+std::string OutputFlagAlsoCheckEnvVar(){
+  std::string default_value_for_output_flag = "";
+  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
+  if (nullptr != xml_output_file_env) {
+    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
+  }
+  return default_value_for_output_flag;
+}
+
+// Reads and returns the string environment variable corresponding to
+// the given flag; if it's not set, returns default_value.
+const char* StringFromGTestEnv(const char* flag, const char* default_value) {
+#if defined(GTEST_GET_STRING_FROM_ENV_)
+  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
+#else
+  const std::string env_var = FlagToEnvVar(flag);
+  const char* const value = posix::GetEnv(env_var.c_str());
+  return value == nullptr ? default_value : value;
+#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
+}
+
+}  // namespace internal
+}  // namespace testing
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Test - The Google C++ Testing and Mocking Framework
+//
+// This file implements a universal value printer that can print a
+// value of any type T:
+//
+//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
+//
+// It uses the << operator when possible, and prints the bytes in the
+// object otherwise.  A user can override its behavior for a class
+// type Foo by defining either operator<<(::std::ostream&, const Foo&)
+// or void PrintTo(const Foo&, ::std::ostream*) in the namespace that
+// defines Foo.
+
+
+#include <stdio.h>
+
+#include <cctype>
+#include <cstdint>
+#include <cwchar>
+#include <ostream>  // NOLINT
+#include <string>
+#include <type_traits>
+
+
+namespace testing {
+
+namespace {
+
+using ::std::ostream;
+
+// Prints a segment of bytes in the given object.
+GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
+                                size_t count, ostream* os) {
+  char text[5] = "";
+  for (size_t i = 0; i != count; i++) {
+    const size_t j = start + i;
+    if (i != 0) {
+      // Organizes the bytes into groups of 2 for easy parsing by
+      // human.
+      if ((j % 2) == 0)
+        *os << ' ';
+      else
+        *os << '-';
+    }
+    GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
+    *os << text;
+  }
+}
+
+// Prints the bytes in the given value to the given ostream.
+void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
+                              ostream* os) {
+  // Tells the user how big the object is.
+  *os << count << "-byte object <";
+
+  const size_t kThreshold = 132;
+  const size_t kChunkSize = 64;
+  // If the object size is bigger than kThreshold, we'll have to omit
+  // some details by printing only the first and the last kChunkSize
+  // bytes.
+  if (count < kThreshold) {
+    PrintByteSegmentInObjectTo(obj_bytes, 0, count, os);
+  } else {
+    PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os);
+    *os << " ... ";
+    // Rounds up to 2-byte boundary.
+    const size_t resume_pos = (count - kChunkSize + 1)/2*2;
+    PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os);
+  }
+  *os << ">";
+}
+
+// Helpers for widening a character to char32_t. Since the standard does not
+// specify if char / wchar_t is signed or unsigned, it is important to first
+// convert it to the unsigned type of the same width before widening it to
+// char32_t.
+template <typename CharType>
+char32_t ToChar32(CharType in) {
+  return static_cast<char32_t>(
+      static_cast<typename std::make_unsigned<CharType>::type>(in));
+}
+
+}  // namespace
+
+namespace internal {
+
+// Delegates to PrintBytesInObjectToImpl() to print the bytes in the
+// given object.  The delegation simplifies the implementation, which
+// uses the << operator and thus is easier done outside of the
+// ::testing::internal namespace, which contains a << operator that
+// sometimes conflicts with the one in STL.
+void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
+                          ostream* os) {
+  PrintBytesInObjectToImpl(obj_bytes, count, os);
+}
+
+// Depending on the value of a char (or wchar_t), we print it in one
+// of three formats:
+//   - as is if it's a printable ASCII (e.g. 'a', '2', ' '),
+//   - as a hexadecimal escape sequence (e.g. '\x7F'), or
+//   - as a special escape sequence (e.g. '\r', '\n').
+enum CharFormat {
+  kAsIs,
+  kHexEscape,
+  kSpecialEscape
+};
+
+// Returns true if c is a printable ASCII character.  We test the
+// value of c directly instead of calling isprint(), which is buggy on
+// Windows Mobile.
+inline bool IsPrintableAscii(char32_t c) { return 0x20 <= c && c <= 0x7E; }
+
+// Prints c (of type char, char8_t, char16_t, char32_t, or wchar_t) as a
+// character literal without the quotes, escaping it when necessary; returns how
+// c was formatted.
+template <typename Char>
+static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
+  const char32_t u_c = ToChar32(c);
+  switch (u_c) {
+    case L'\0':
+      *os << "\\0";
+      break;
+    case L'\'':
+      *os << "\\'";
+      break;
+    case L'\\':
+      *os << "\\\\";
+      break;
+    case L'\a':
+      *os << "\\a";
+      break;
+    case L'\b':
+      *os << "\\b";
+      break;
+    case L'\f':
+      *os << "\\f";
+      break;
+    case L'\n':
+      *os << "\\n";
+      break;
+    case L'\r':
+      *os << "\\r";
+      break;
+    case L'\t':
+      *os << "\\t";
+      break;
+    case L'\v':
+      *os << "\\v";
+      break;
+    default:
+      if (IsPrintableAscii(u_c)) {
+        *os << static_cast<char>(c);
+        return kAsIs;
+      } else {
+        ostream::fmtflags flags = os->flags();
+        *os << "\\x" << std::hex << std::uppercase << static_cast<int>(u_c);
+        os->flags(flags);
+        return kHexEscape;
+      }
+  }
+  return kSpecialEscape;
+}
+
+// Prints a char32_t c as if it's part of a string literal, escaping it when
+// necessary; returns how c was formatted.
+static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
+  switch (c) {
+    case L'\'':
+      *os << "'";
+      return kAsIs;
+    case L'"':
+      *os << "\\\"";
+      return kSpecialEscape;
+    default:
+      return PrintAsCharLiteralTo(c, os);
+  }
+}
+
+static const char* GetCharWidthPrefix(char) {
+  return "";
+}
+
+static const char* GetCharWidthPrefix(signed char) {
+  return "";
+}
+
+static const char* GetCharWidthPrefix(unsigned char) {
+  return "";
+}
+
+#ifdef __cpp_char8_t
+static const char* GetCharWidthPrefix(char8_t) {
+  return "u8";
+}
+#endif
+
+static const char* GetCharWidthPrefix(char16_t) {
+  return "u";
+}
+
+static const char* GetCharWidthPrefix(char32_t) {
+  return "U";
+}
+
+static const char* GetCharWidthPrefix(wchar_t) {
+  return "L";
+}
+
+// Prints a char c as if it's part of a string literal, escaping it when
+// necessary; returns how c was formatted.
+static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
+  return PrintAsStringLiteralTo(ToChar32(c), os);
+}
+
+#ifdef __cpp_char8_t
+static CharFormat PrintAsStringLiteralTo(char8_t c, ostream* os) {
+  return PrintAsStringLiteralTo(ToChar32(c), os);
+}
+#endif
+
+static CharFormat PrintAsStringLiteralTo(char16_t c, ostream* os) {
+  return PrintAsStringLiteralTo(ToChar32(c), os);
+}
+
+static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
+  return PrintAsStringLiteralTo(ToChar32(c), os);
+}
+
+// Prints a character c (of type char, char8_t, char16_t, char32_t, or wchar_t)
+// and its code. '\0' is printed as "'\\0'", other unprintable characters are
+// also properly escaped using the standard C++ escape sequence.
+template <typename Char>
+void PrintCharAndCodeTo(Char c, ostream* os) {
+  // First, print c as a literal in the most readable form we can find.
+  *os << GetCharWidthPrefix(c) << "'";
+  const CharFormat format = PrintAsCharLiteralTo(c, os);
+  *os << "'";
+
+  // To aid user debugging, we also print c's code in decimal, unless
+  // it's 0 (in which case c was printed as '\\0', making the code
+  // obvious).
+  if (c == 0)
+    return;
+  *os << " (" << static_cast<int>(c);
+
+  // For more convenience, we print c's code again in hexadecimal,
+  // unless c was already printed in the form '\x##' or the code is in
+  // [1, 9].
+  if (format == kHexEscape || (1 <= c && c <= 9)) {
+    // Do nothing.
+  } else {
+    *os << ", 0x" << String::FormatHexInt(static_cast<int>(c));
+  }
+  *os << ")";
+}
+
+void PrintTo(unsigned char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); }
+void PrintTo(signed char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); }
+
+// Prints a wchar_t as a symbol if it is printable or as its internal
+// code otherwise and also as its code.  L'\0' is printed as "L'\\0'".
+void PrintTo(wchar_t wc, ostream* os) { PrintCharAndCodeTo(wc, os); }
+
+// TODO(dcheng): Consider making this delegate to PrintCharAndCodeTo() as well.
+void PrintTo(char32_t c, ::std::ostream* os) {
+  *os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4)
+      << static_cast<uint32_t>(c);
+}
+
+// Prints the given array of characters to the ostream.  CharType must be either
+// char, char8_t, char16_t, char32_t, or wchar_t.
+// The array starts at begin, the length is len, it may include '\0' characters
+// and may not be NUL-terminated.
+template <typename CharType>
+GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+static CharFormat PrintCharsAsStringTo(
+    const CharType* begin, size_t len, ostream* os) {
+  const char* const quote_prefix = GetCharWidthPrefix(*begin);
+  *os << quote_prefix << "\"";
+  bool is_previous_hex = false;
+  CharFormat print_format = kAsIs;
+  for (size_t index = 0; index < len; ++index) {
+    const CharType cur = begin[index];
+    if (is_previous_hex && IsXDigit(cur)) {
+      // Previous character is of '\x..' form and this character can be
+      // interpreted as another hexadecimal digit in its number. Break string to
+      // disambiguate.
+      *os << "\" " << quote_prefix << "\"";
+    }
+    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
+    // Remember if any characters required hex escaping.
+    if (is_previous_hex) {
+      print_format = kHexEscape;
+    }
+  }
+  *os << "\"";
+  return print_format;
+}
+
+// Prints a (const) char/wchar_t array of 'len' elements, starting at address
+// 'begin'.  CharType must be either char or wchar_t.
+template <typename CharType>
+GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+static void UniversalPrintCharArray(
+    const CharType* begin, size_t len, ostream* os) {
+  // The code
+  //   const char kFoo[] = "foo";
+  // generates an array of 4, not 3, elements, with the last one being '\0'.
+  //
+  // Therefore when printing a char array, we don't print the last element if
+  // it's '\0', such that the output matches the string literal as it's
+  // written in the source code.
+  if (len > 0 && begin[len - 1] == '\0') {
+    PrintCharsAsStringTo(begin, len - 1, os);
+    return;
+  }
+
+  // If, however, the last element in the array is not '\0', e.g.
+  //    const char kFoo[] = { 'f', 'o', 'o' };
+  // we must print the entire array.  We also print a message to indicate
+  // that the array is not NUL-terminated.
+  PrintCharsAsStringTo(begin, len, os);
+  *os << " (no terminating NUL)";
+}
+
+// Prints a (const) char array of 'len' elements, starting at address 'begin'.
+void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
+  UniversalPrintCharArray(begin, len, os);
+}
+
+#ifdef __cpp_char8_t
+// Prints a (const) char8_t array of 'len' elements, starting at address
+// 'begin'.
+void UniversalPrintArray(const char8_t* begin, size_t len, ostream* os) {
+  UniversalPrintCharArray(begin, len, os);
+}
+#endif
+
+// Prints a (const) char16_t array of 'len' elements, starting at address
+// 'begin'.
+void UniversalPrintArray(const char16_t* begin, size_t len, ostream* os) {
+  UniversalPrintCharArray(begin, len, os);
+}
+
+// Prints a (const) char32_t array of 'len' elements, starting at address
+// 'begin'.
+void UniversalPrintArray(const char32_t* begin, size_t len, ostream* os) {
+  UniversalPrintCharArray(begin, len, os);
+}
+
+// Prints a (const) wchar_t array of 'len' elements, starting at address
+// 'begin'.
+void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) {
+  UniversalPrintCharArray(begin, len, os);
+}
+
+namespace {
+
+// Prints a null-terminated C-style string to the ostream.
+template <typename Char>
+void PrintCStringTo(const Char* s, ostream* os) {
+  if (s == nullptr) {
+    *os << "NULL";
+  } else {
+    *os << ImplicitCast_<const void*>(s) << " pointing to ";
+    PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
+  }
+}
+
+}  // anonymous namespace
+
+void PrintTo(const char* s, ostream* os) { PrintCStringTo(s, os); }
+
+#ifdef __cpp_char8_t
+void PrintTo(const char8_t* s, ostream* os) { PrintCStringTo(s, os); }
+#endif
+
+void PrintTo(const char16_t* s, ostream* os) { PrintCStringTo(s, os); }
+
+void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); }
+
+// MSVC compiler can be configured to define whar_t as a typedef
+// of unsigned short. Defining an overload for const wchar_t* in that case
+// would cause pointers to unsigned shorts be printed as wide strings,
+// possibly accessing more memory than intended and causing invalid
+// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
+// wchar_t is implemented as a native type.
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+// Prints the given wide C string to the ostream.
+void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); }
+#endif  // wchar_t is native
+
+namespace {
+
+bool ContainsUnprintableControlCodes(const char* str, size_t length) {
+  const unsigned char *s = reinterpret_cast<const unsigned char *>(str);
+
+  for (size_t i = 0; i < length; i++) {
+    unsigned char ch = *s++;
+    if (std::iscntrl(ch)) {
+        switch (ch) {
+        case '\t':
+        case '\n':
+        case '\r':
+          break;
+        default:
+          return true;
+        }
+      }
+  }
+  return false;
+}
+
+bool IsUTF8TrailByte(unsigned char t) { return 0x80 <= t && t<= 0xbf; }
+
+bool IsValidUTF8(const char* str, size_t length) {
+  const unsigned char *s = reinterpret_cast<const unsigned char *>(str);
+
+  for (size_t i = 0; i < length;) {
+    unsigned char lead = s[i++];
+
+    if (lead <= 0x7f) {
+      continue;  // single-byte character (ASCII) 0..7F
+    }
+    if (lead < 0xc2) {
+      return false;  // trail byte or non-shortest form
+    } else if (lead <= 0xdf && (i + 1) <= length && IsUTF8TrailByte(s[i])) {
+      ++i;  // 2-byte character
+    } else if (0xe0 <= lead && lead <= 0xef && (i + 2) <= length &&
+               IsUTF8TrailByte(s[i]) &&
+               IsUTF8TrailByte(s[i + 1]) &&
+               // check for non-shortest form and surrogate
+               (lead != 0xe0 || s[i] >= 0xa0) &&
+               (lead != 0xed || s[i] < 0xa0)) {
+      i += 2;  // 3-byte character
+    } else if (0xf0 <= lead && lead <= 0xf4 && (i + 3) <= length &&
+               IsUTF8TrailByte(s[i]) &&
+               IsUTF8TrailByte(s[i + 1]) &&
+               IsUTF8TrailByte(s[i + 2]) &&
+               // check for non-shortest form
+               (lead != 0xf0 || s[i] >= 0x90) &&
+               (lead != 0xf4 || s[i] < 0x90)) {
+      i += 3;  // 4-byte character
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+void ConditionalPrintAsText(const char* str, size_t length, ostream* os) {
+  if (!ContainsUnprintableControlCodes(str, length) &&
+      IsValidUTF8(str, length)) {
+    *os << "\n    As Text: \"" << str << "\"";
+  }
+}
+
+}  // anonymous namespace
+
+void PrintStringTo(const ::std::string& s, ostream* os) {
+  if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
+    if (GTEST_FLAG(print_utf8)) {
+      ConditionalPrintAsText(s.data(), s.size(), os);
+    }
+  }
+}
+
+#ifdef __cpp_char8_t
+void PrintU8StringTo(const ::std::u8string& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+#endif
+
+void PrintU16StringTo(const ::std::u16string& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+
+void PrintU32StringTo(const ::std::u32string& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+
+#if GTEST_HAS_STD_WSTRING
+void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+}  // namespace internal
+
+}  // namespace testing
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+
+
+
+namespace testing {
+
+using internal::GetUnitTestImpl;
+
+// Gets the summary of the failure message by omitting the stack trace
+// in it.
+std::string TestPartResult::ExtractSummary(const char* message) {
+  const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
+  return stack_trace == nullptr ? message : std::string(message, stack_trace);
+}
+
+// Prints a TestPartResult object.
+std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
+  return os << internal::FormatFileLocation(result.file_name(),
+                                            result.line_number())
+            << " "
+            << (result.type() == TestPartResult::kSuccess
+                    ? "Success"
+                    : result.type() == TestPartResult::kSkip
+                          ? "Skipped"
+                          : result.type() == TestPartResult::kFatalFailure
+                                ? "Fatal failure"
+                                : "Non-fatal failure")
+            << ":\n"
+            << result.message() << std::endl;
+}
+
+// Appends a TestPartResult to the array.
+void TestPartResultArray::Append(const TestPartResult& result) {
+  array_.push_back(result);
+}
+
+// Returns the TestPartResult at the given index (0-based).
+const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
+  if (index < 0 || index >= size()) {
+    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
+    internal::posix::Abort();
+  }
+
+  return array_[static_cast<size_t>(index)];
+}
+
+// Returns the number of TestPartResult objects in the array.
+int TestPartResultArray::size() const {
+  return static_cast<int>(array_.size());
+}
+
+namespace internal {
+
+HasNewFatalFailureHelper::HasNewFatalFailureHelper()
+    : has_new_fatal_failure_(false),
+      original_reporter_(GetUnitTestImpl()->
+                         GetTestPartResultReporterForCurrentThread()) {
+  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this);
+}
+
+HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
+  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
+      original_reporter_);
+}
+
+void HasNewFatalFailureHelper::ReportTestPartResult(
+    const TestPartResult& result) {
+  if (result.fatally_failed())
+    has_new_fatal_failure_ = true;
+  original_reporter_->ReportTestPartResult(result);
+}
+
+}  // namespace internal
+
+}  // namespace testing
+// Copyright 2008 Google Inc.
+// All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+
+namespace testing {
+namespace internal {
+
+// Skips to the first non-space char in str. Returns an empty string if str
+// contains only whitespace characters.
+static const char* SkipSpaces(const char* str) {
+  while (IsSpace(*str))
+    str++;
+  return str;
+}
+
+static std::vector<std::string> SplitIntoTestNames(const char* src) {
+  std::vector<std::string> name_vec;
+  src = SkipSpaces(src);
+  for (; src != nullptr; src = SkipComma(src)) {
+    name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src)));
+  }
+  return name_vec;
+}
+
+// Verifies that registered_tests match the test names in
+// registered_tests_; returns registered_tests if successful, or
+// aborts the program otherwise.
+const char* TypedTestSuitePState::VerifyRegisteredTestNames(
+    const char* test_suite_name, const char* file, int line,
+    const char* registered_tests) {
+  RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line));
+
+  typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
+  registered_ = true;
+
+  std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests);
+
+  Message errors;
+
+  std::set<std::string> tests;
+  for (std::vector<std::string>::const_iterator name_it = name_vec.begin();
+       name_it != name_vec.end(); ++name_it) {
+    const std::string& name = *name_it;
+    if (tests.count(name) != 0) {
+      errors << "Test " << name << " is listed more than once.\n";
+      continue;
+    }
+
+    if (registered_tests_.count(name) != 0) {
+      tests.insert(name);
+    } else {
+      errors << "No test named " << name
+             << " can be found in this test suite.\n";
+    }
+  }
+
+  for (RegisteredTestIter it = registered_tests_.begin();
+       it != registered_tests_.end();
+       ++it) {
+    if (tests.count(it->first) == 0) {
+      errors << "You forgot to list test " << it->first << ".\n";
+    }
+  }
+
+  const std::string& errors_str = errors.GetString();
+  if (errors_str != "") {
+    fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
+            errors_str.c_str());
+    fflush(stderr);
+    posix::Abort();
+  }
+
+  return registered_tests;
+}
+
+}  // namespace internal
+}  // namespace testing
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+//
+// Google C++ Mocking Framework (Google Mock)
+//
+// This file #includes all Google Mock implementation .cc files.  The
+// purpose is to allow a user to build Google Mock by compiling this
+// file alone.
+
+// This line ensures that gmock.h can be compiled on its own, even
+// when it's fused.
+#include "gmock/gmock.h"
+
+// The following lines pull in the real gmock *.cc files.
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements cardinalities.
+
+
+#include <limits.h>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+
+namespace testing {
+
+namespace {
+
+// Implements the Between(m, n) cardinality.
+class BetweenCardinalityImpl : public CardinalityInterface {
+ public:
+  BetweenCardinalityImpl(int min, int max)
+      : min_(min >= 0 ? min : 0),
+        max_(max >= min_ ? max : min_) {
+    std::stringstream ss;
+    if (min < 0) {
+      ss << "The invocation lower bound must be >= 0, "
+         << "but is actually " << min << ".";
+      internal::Expect(false, __FILE__, __LINE__, ss.str());
+    } else if (max < 0) {
+      ss << "The invocation upper bound must be >= 0, "
+         << "but is actually " << max << ".";
+      internal::Expect(false, __FILE__, __LINE__, ss.str());
+    } else if (min > max) {
+      ss << "The invocation upper bound (" << max
+         << ") must be >= the invocation lower bound (" << min
+         << ").";
+      internal::Expect(false, __FILE__, __LINE__, ss.str());
+    }
+  }
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  int ConservativeLowerBound() const override { return min_; }
+  int ConservativeUpperBound() const override { return max_; }
+
+  bool IsSatisfiedByCallCount(int call_count) const override {
+    return min_ <= call_count && call_count <= max_;
+  }
+
+  bool IsSaturatedByCallCount(int call_count) const override {
+    return call_count >= max_;
+  }
+
+  void DescribeTo(::std::ostream* os) const override;
+
+ private:
+  const int min_;
+  const int max_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(BetweenCardinalityImpl);
+};
+
+// Formats "n times" in a human-friendly way.
+inline std::string FormatTimes(int n) {
+  if (n == 1) {
+    return "once";
+  } else if (n == 2) {
+    return "twice";
+  } else {
+    std::stringstream ss;
+    ss << n << " times";
+    return ss.str();
+  }
+}
+
+// Describes the Between(m, n) cardinality in human-friendly text.
+void BetweenCardinalityImpl::DescribeTo(::std::ostream* os) const {
+  if (min_ == 0) {
+    if (max_ == 0) {
+      *os << "never called";
+    } else if (max_ == INT_MAX) {
+      *os << "called any number of times";
+    } else {
+      *os << "called at most " << FormatTimes(max_);
+    }
+  } else if (min_ == max_) {
+    *os << "called " << FormatTimes(min_);
+  } else if (max_ == INT_MAX) {
+    *os << "called at least " << FormatTimes(min_);
+  } else {
+    // 0 < min_ < max_ < INT_MAX
+    *os << "called between " << min_ << " and " << max_ << " times";
+  }
+}
+
+}  // Unnamed namespace
+
+// Describes the given call count to an ostream.
+void Cardinality::DescribeActualCallCountTo(int actual_call_count,
+                                            ::std::ostream* os) {
+  if (actual_call_count > 0) {
+    *os << "called " << FormatTimes(actual_call_count);
+  } else {
+    *os << "never called";
+  }
+}
+
+// Creates a cardinality that allows at least n calls.
+GTEST_API_ Cardinality AtLeast(int n) { return Between(n, INT_MAX); }
+
+// Creates a cardinality that allows at most n calls.
+GTEST_API_ Cardinality AtMost(int n) { return Between(0, n); }
+
+// Creates a cardinality that allows any number of calls.
+GTEST_API_ Cardinality AnyNumber() { return AtLeast(0); }
+
+// Creates a cardinality that allows between min and max calls.
+GTEST_API_ Cardinality Between(int min, int max) {
+  return Cardinality(new BetweenCardinalityImpl(min, max));
+}
+
+// Creates a cardinality that allows exactly n calls.
+GTEST_API_ Cardinality Exactly(int n) { return Between(n, n); }
+
+}  // namespace testing
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file defines some utilities useful for implementing Google
+// Mock.  They are subject to change without notice, so please DO NOT
+// USE THEM IN USER CODE.
+
+
+#include <ctype.h>
+#include <ostream>  // NOLINT
+#include <string>
+
+namespace testing {
+namespace internal {
+
+// Joins a vector of strings as if they are fields of a tuple; returns
+// the joined string.
+GTEST_API_ std::string JoinAsTuple(const Strings& fields) {
+  switch (fields.size()) {
+    case 0:
+      return "";
+    case 1:
+      return fields[0];
+    default:
+      std::string result = "(" + fields[0];
+      for (size_t i = 1; i < fields.size(); i++) {
+        result += ", ";
+        result += fields[i];
+      }
+      result += ")";
+      return result;
+  }
+}
+
+// Converts an identifier name to a space-separated list of lower-case
+// words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
+// treated as one word.  For example, both "FooBar123" and
+// "foo_bar_123" are converted to "foo bar 123".
+GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name) {
+  std::string result;
+  char prev_char = '\0';
+  for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) {
+    // We don't care about the current locale as the input is
+    // guaranteed to be a valid C++ identifier name.
+    const bool starts_new_word = IsUpper(*p) ||
+        (!IsAlpha(prev_char) && IsLower(*p)) ||
+        (!IsDigit(prev_char) && IsDigit(*p));
+
+    if (IsAlNum(*p)) {
+      if (starts_new_word && result != "")
+        result += ' ';
+      result += ToLower(*p);
+    }
+  }
+  return result;
+}
+
+// This class reports Google Mock failures as Google Test failures.  A
+// user can define another class in a similar fashion if they intend to
+// use Google Mock with a testing framework other than Google Test.
+class GoogleTestFailureReporter : public FailureReporterInterface {
+ public:
+  void ReportFailure(FailureType type, const char* file, int line,
+                     const std::string& message) override {
+    AssertHelper(type == kFatal ?
+                 TestPartResult::kFatalFailure :
+                 TestPartResult::kNonFatalFailure,
+                 file,
+                 line,
+                 message.c_str()) = Message();
+    if (type == kFatal) {
+      posix::Abort();
+    }
+  }
+};
+
+// Returns the global failure reporter.  Will create a
+// GoogleTestFailureReporter and return it the first time called.
+GTEST_API_ FailureReporterInterface* GetFailureReporter() {
+  // Points to the global failure reporter used by Google Mock.  gcc
+  // guarantees that the following use of failure_reporter is
+  // thread-safe.  We may need to add additional synchronization to
+  // protect failure_reporter if we port Google Mock to other
+  // compilers.
+  static FailureReporterInterface* const failure_reporter =
+      new GoogleTestFailureReporter();
+  return failure_reporter;
+}
+
+// Protects global resources (stdout in particular) used by Log().
+static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex);
+
+// Returns true if and only if a log with the given severity is visible
+// according to the --gmock_verbose flag.
+GTEST_API_ bool LogIsVisible(LogSeverity severity) {
+  if (GMOCK_FLAG(verbose) == kInfoVerbosity) {
+    // Always show the log if --gmock_verbose=info.
+    return true;
+  } else if (GMOCK_FLAG(verbose) == kErrorVerbosity) {
+    // Always hide it if --gmock_verbose=error.
+    return false;
+  } else {
+    // If --gmock_verbose is neither "info" nor "error", we treat it
+    // as "warning" (its default value).
+    return severity == kWarning;
+  }
+}
+
+// Prints the given message to stdout if and only if 'severity' >= the level
+// specified by the --gmock_verbose flag.  If stack_frames_to_skip >=
+// 0, also prints the stack trace excluding the top
+// stack_frames_to_skip frames.  In opt mode, any positive
+// stack_frames_to_skip is treated as 0, since we don't know which
+// function calls will be inlined by the compiler and need to be
+// conservative.
+GTEST_API_ void Log(LogSeverity severity, const std::string& message,
+                    int stack_frames_to_skip) {
+  if (!LogIsVisible(severity))
+    return;
+
+  // Ensures that logs from different threads don't interleave.
+  MutexLock l(&g_log_mutex);
+
+  if (severity == kWarning) {
+    // Prints a GMOCK WARNING marker to make the warnings easily searchable.
+    std::cout << "\nGMOCK WARNING:";
+  }
+  // Pre-pends a new-line to message if it doesn't start with one.
+  if (message.empty() || message[0] != '\n') {
+    std::cout << "\n";
+  }
+  std::cout << message;
+  if (stack_frames_to_skip >= 0) {
+#ifdef NDEBUG
+    // In opt mode, we have to be conservative and skip no stack frame.
+    const int actual_to_skip = 0;
+#else
+    // In dbg mode, we can do what the caller tell us to do (plus one
+    // for skipping this function's stack frame).
+    const int actual_to_skip = stack_frames_to_skip + 1;
+#endif  // NDEBUG
+
+    // Appends a new-line to message if it doesn't end with one.
+    if (!message.empty() && *message.rbegin() != '\n') {
+      std::cout << "\n";
+    }
+    std::cout << "Stack trace:\n"
+         << ::testing::internal::GetCurrentOsStackTraceExceptTop(
+             ::testing::UnitTest::GetInstance(), actual_to_skip);
+  }
+  std::cout << ::std::flush;
+}
+
+GTEST_API_ WithoutMatchers GetWithoutMatchers() { return WithoutMatchers(); }
+
+GTEST_API_ void IllegalDoDefault(const char* file, int line) {
+  internal::Assert(
+      false, file, line,
+      "You are using DoDefault() inside a composite action like "
+      "DoAll() or WithArgs().  This is not supported for technical "
+      "reasons.  Please instead spell out the default action, or "
+      "assign the default action to an Action variable and use "
+      "the variable in various places.");
+}
+
+}  // namespace internal
+}  // namespace testing
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements Matcher<const string&>, Matcher<string>, and
+// utilities for defining matchers.
+
+
+#include <string.h>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+namespace testing {
+namespace internal {
+
+// Returns the description for a matcher defined using the MATCHER*()
+// macro where the user-supplied description string is "", if
+// 'negation' is false; otherwise returns the description of the
+// negation of the matcher.  'param_values' contains a list of strings
+// that are the print-out of the matcher's parameters.
+GTEST_API_ std::string FormatMatcherDescription(bool negation,
+                                                const char* matcher_name,
+                                                const Strings& param_values) {
+  std::string result = ConvertIdentifierNameToWords(matcher_name);
+  if (param_values.size() >= 1) result += " " + JoinAsTuple(param_values);
+  return negation ? "not (" + result + ")" : result;
+}
+
+// FindMaxBipartiteMatching and its helper class.
+//
+// Uses the well-known Ford-Fulkerson max flow method to find a maximum
+// bipartite matching. Flow is considered to be from left to right.
+// There is an implicit source node that is connected to all of the left
+// nodes, and an implicit sink node that is connected to all of the
+// right nodes. All edges have unit capacity.
+//
+// Neither the flow graph nor the residual flow graph are represented
+// explicitly. Instead, they are implied by the information in 'graph' and
+// a vector<int> called 'left_' whose elements are initialized to the
+// value kUnused. This represents the initial state of the algorithm,
+// where the flow graph is empty, and the residual flow graph has the
+// following edges:
+//   - An edge from source to each left_ node
+//   - An edge from each right_ node to sink
+//   - An edge from each left_ node to each right_ node, if the
+//     corresponding edge exists in 'graph'.
+//
+// When the TryAugment() method adds a flow, it sets left_[l] = r for some
+// nodes l and r. This induces the following changes:
+//   - The edges (source, l), (l, r), and (r, sink) are added to the
+//     flow graph.
+//   - The same three edges are removed from the residual flow graph.
+//   - The reverse edges (l, source), (r, l), and (sink, r) are added
+//     to the residual flow graph, which is a directional graph
+//     representing unused flow capacity.
+//
+// When the method augments a flow (moving left_[l] from some r1 to some
+// other r2), this can be thought of as "undoing" the above steps with
+// respect to r1 and "redoing" them with respect to r2.
+//
+// It bears repeating that the flow graph and residual flow graph are
+// never represented explicitly, but can be derived by looking at the
+// information in 'graph' and in left_.
+//
+// As an optimization, there is a second vector<int> called right_ which
+// does not provide any new information. Instead, it enables more
+// efficient queries about edges entering or leaving the right-side nodes
+// of the flow or residual flow graphs. The following invariants are
+// maintained:
+//
+// left[l] == kUnused or right[left[l]] == l
+// right[r] == kUnused or left[right[r]] == r
+//
+// . [ source ]                                        .
+// .   |||                                             .
+// .   |||                                             .
+// .   ||\--> left[0]=1  ---\    right[0]=-1 ----\     .
+// .   ||                   |                    |     .
+// .   |\---> left[1]=-1    \--> right[1]=0  ---\|     .
+// .   |                                        ||     .
+// .   \----> left[2]=2  ------> right[2]=2  --\||     .
+// .                                           |||     .
+// .         elements           matchers       vvv     .
+// .                                         [ sink ]  .
+//
+// See Also:
+//   [1] Cormen, et al (2001). "Section 26.2: The Ford-Fulkerson method".
+//       "Introduction to Algorithms (Second ed.)", pp. 651-664.
+//   [2] "Ford-Fulkerson algorithm", Wikipedia,
+//       'http://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm'
+class MaxBipartiteMatchState {
+ public:
+  explicit MaxBipartiteMatchState(const MatchMatrix& graph)
+      : graph_(&graph),
+        left_(graph_->LhsSize(), kUnused),
+        right_(graph_->RhsSize(), kUnused) {}
+
+  // Returns the edges of a maximal match, each in the form {left, right}.
+  ElementMatcherPairs Compute() {
+    // 'seen' is used for path finding { 0: unseen, 1: seen }.
+    ::std::vector<char> seen;
+    // Searches the residual flow graph for a path from each left node to
+    // the sink in the residual flow graph, and if one is found, add flow
+    // to the graph. It's okay to search through the left nodes once. The
+    // edge from the implicit source node to each previously-visited left
+    // node will have flow if that left node has any path to the sink
+    // whatsoever. Subsequent augmentations can only add flow to the
+    // network, and cannot take away that previous flow unit from the source.
+    // Since the source-to-left edge can only carry one flow unit (or,
+    // each element can be matched to only one matcher), there is no need
+    // to visit the left nodes more than once looking for augmented paths.
+    // The flow is known to be possible or impossible by looking at the
+    // node once.
+    for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) {
+      // Reset the path-marking vector and try to find a path from
+      // source to sink starting at the left_[ilhs] node.
+      GTEST_CHECK_(left_[ilhs] == kUnused)
+          << "ilhs: " << ilhs << ", left_[ilhs]: " << left_[ilhs];
+      // 'seen' initialized to 'graph_->RhsSize()' copies of 0.
+      seen.assign(graph_->RhsSize(), 0);
+      TryAugment(ilhs, &seen);
+    }
+    ElementMatcherPairs result;
+    for (size_t ilhs = 0; ilhs < left_.size(); ++ilhs) {
+      size_t irhs = left_[ilhs];
+      if (irhs == kUnused) continue;
+      result.push_back(ElementMatcherPair(ilhs, irhs));
+    }
+    return result;
+  }
+
+ private:
+  static const size_t kUnused = static_cast<size_t>(-1);
+
+  // Perform a depth-first search from left node ilhs to the sink.  If a
+  // path is found, flow is added to the network by linking the left and
+  // right vector elements corresponding each segment of the path.
+  // Returns true if a path to sink was found, which means that a unit of
+  // flow was added to the network. The 'seen' vector elements correspond
+  // to right nodes and are marked to eliminate cycles from the search.
+  //
+  // Left nodes will only be explored at most once because they
+  // are accessible from at most one right node in the residual flow
+  // graph.
+  //
+  // Note that left_[ilhs] is the only element of left_ that TryAugment will
+  // potentially transition from kUnused to another value. Any other
+  // left_ element holding kUnused before TryAugment will be holding it
+  // when TryAugment returns.
+  //
+  bool TryAugment(size_t ilhs, ::std::vector<char>* seen) {
+    for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) {
+      if ((*seen)[irhs]) continue;
+      if (!graph_->HasEdge(ilhs, irhs)) continue;
+      // There's an available edge from ilhs to irhs.
+      (*seen)[irhs] = 1;
+      // Next a search is performed to determine whether
+      // this edge is a dead end or leads to the sink.
+      //
+      // right_[irhs] == kUnused means that there is residual flow from
+      // right node irhs to the sink, so we can use that to finish this
+      // flow path and return success.
+      //
+      // Otherwise there is residual flow to some ilhs. We push flow
+      // along that path and call ourselves recursively to see if this
+      // ultimately leads to sink.
+      if (right_[irhs] == kUnused || TryAugment(right_[irhs], seen)) {
+        // Add flow from left_[ilhs] to right_[irhs].
+        left_[ilhs] = irhs;
+        right_[irhs] = ilhs;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  const MatchMatrix* graph_;  // not owned
+  // Each element of the left_ vector represents a left hand side node
+  // (i.e. an element) and each element of right_ is a right hand side
+  // node (i.e. a matcher). The values in the left_ vector indicate
+  // outflow from that node to a node on the right_ side. The values
+  // in the right_ indicate inflow, and specify which left_ node is
+  // feeding that right_ node, if any. For example, left_[3] == 1 means
+  // there's a flow from element #3 to matcher #1. Such a flow would also
+  // be redundantly represented in the right_ vector as right_[1] == 3.
+  // Elements of left_ and right_ are either kUnused or mutually
+  // referent. Mutually referent means that left_[right_[i]] = i and
+  // right_[left_[i]] = i.
+  ::std::vector<size_t> left_;
+  ::std::vector<size_t> right_;
+};
+
+const size_t MaxBipartiteMatchState::kUnused;
+
+GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchMatrix& g) {
+  return MaxBipartiteMatchState(g).Compute();
+}
+
+static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
+                                     ::std::ostream* stream) {
+  typedef ElementMatcherPairs::const_iterator Iter;
+  ::std::ostream& os = *stream;
+  os << "{";
+  const char* sep = "";
+  for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
+    os << sep << "\n  ("
+       << "element #" << it->first << ", "
+       << "matcher #" << it->second << ")";
+    sep = ",";
+  }
+  os << "\n}";
+}
+
+bool MatchMatrix::NextGraph() {
+  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
+    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
+      char& b = matched_[SpaceIndex(ilhs, irhs)];
+      if (!b) {
+        b = 1;
+        return true;
+      }
+      b = 0;
+    }
+  }
+  return false;
+}
+
+void MatchMatrix::Randomize() {
+  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
+    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
+      char& b = matched_[SpaceIndex(ilhs, irhs)];
+      b = static_cast<char>(rand() & 1);  // NOLINT
+    }
+  }
+}
+
+std::string MatchMatrix::DebugString() const {
+  ::std::stringstream ss;
+  const char* sep = "";
+  for (size_t i = 0; i < LhsSize(); ++i) {
+    ss << sep;
+    for (size_t j = 0; j < RhsSize(); ++j) {
+      ss << HasEdge(i, j);
+    }
+    sep = ";";
+  }
+  return ss.str();
+}
+
+void UnorderedElementsAreMatcherImplBase::DescribeToImpl(
+    ::std::ostream* os) const {
+  switch (match_flags()) {
+    case UnorderedMatcherRequire::ExactMatch:
+      if (matcher_describers_.empty()) {
+        *os << "is empty";
+        return;
+      }
+      if (matcher_describers_.size() == 1) {
+        *os << "has " << Elements(1) << " and that element ";
+        matcher_describers_[0]->DescribeTo(os);
+        return;
+      }
+      *os << "has " << Elements(matcher_describers_.size())
+          << " and there exists some permutation of elements such that:\n";
+      break;
+    case UnorderedMatcherRequire::Superset:
+      *os << "a surjection from elements to requirements exists such that:\n";
+      break;
+    case UnorderedMatcherRequire::Subset:
+      *os << "an injection from elements to requirements exists such that:\n";
+      break;
+  }
+
+  const char* sep = "";
+  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
+    *os << sep;
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+      *os << " - element #" << i << " ";
+    } else {
+      *os << " - an element ";
+    }
+    matcher_describers_[i]->DescribeTo(os);
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+      sep = ", and\n";
+    } else {
+      sep = "\n";
+    }
+  }
+}
+
+void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(
+    ::std::ostream* os) const {
+  switch (match_flags()) {
+    case UnorderedMatcherRequire::ExactMatch:
+      if (matcher_describers_.empty()) {
+        *os << "isn't empty";
+        return;
+      }
+      if (matcher_describers_.size() == 1) {
+        *os << "doesn't have " << Elements(1) << ", or has " << Elements(1)
+            << " that ";
+        matcher_describers_[0]->DescribeNegationTo(os);
+        return;
+      }
+      *os << "doesn't have " << Elements(matcher_describers_.size())
+          << ", or there exists no permutation of elements such that:\n";
+      break;
+    case UnorderedMatcherRequire::Superset:
+      *os << "no surjection from elements to requirements exists such that:\n";
+      break;
+    case UnorderedMatcherRequire::Subset:
+      *os << "no injection from elements to requirements exists such that:\n";
+      break;
+  }
+  const char* sep = "";
+  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
+    *os << sep;
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+      *os << " - element #" << i << " ";
+    } else {
+      *os << " - an element ";
+    }
+    matcher_describers_[i]->DescribeTo(os);
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+      sep = ", and\n";
+    } else {
+      sep = "\n";
+    }
+  }
+}
+
+// Checks that all matchers match at least one element, and that all
+// elements match at least one matcher. This enables faster matching
+// and better error reporting.
+// Returns false, writing an explanation to 'listener', if and only
+// if the success criteria are not met.
+bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix(
+    const ::std::vector<std::string>& element_printouts,
+    const MatchMatrix& matrix, MatchResultListener* listener) const {
+  bool result = true;
+  ::std::vector<char> element_matched(matrix.LhsSize(), 0);
+  ::std::vector<char> matcher_matched(matrix.RhsSize(), 0);
+
+  for (size_t ilhs = 0; ilhs < matrix.LhsSize(); ilhs++) {
+    for (size_t irhs = 0; irhs < matrix.RhsSize(); irhs++) {
+      char matched = matrix.HasEdge(ilhs, irhs);
+      element_matched[ilhs] |= matched;
+      matcher_matched[irhs] |= matched;
+    }
+  }
+
+  if (match_flags() & UnorderedMatcherRequire::Superset) {
+    const char* sep =
+        "where the following matchers don't match any elements:\n";
+    for (size_t mi = 0; mi < matcher_matched.size(); ++mi) {
+      if (matcher_matched[mi]) continue;
+      result = false;
+      if (listener->IsInterested()) {
+        *listener << sep << "matcher #" << mi << ": ";
+        matcher_describers_[mi]->DescribeTo(listener->stream());
+        sep = ",\n";
+      }
+    }
+  }
+
+  if (match_flags() & UnorderedMatcherRequire::Subset) {
+    const char* sep =
+        "where the following elements don't match any matchers:\n";
+    const char* outer_sep = "";
+    if (!result) {
+      outer_sep = "\nand ";
+    }
+    for (size_t ei = 0; ei < element_matched.size(); ++ei) {
+      if (element_matched[ei]) continue;
+      result = false;
+      if (listener->IsInterested()) {
+        *listener << outer_sep << sep << "element #" << ei << ": "
+                  << element_printouts[ei];
+        sep = ",\n";
+        outer_sep = "";
+      }
+    }
+  }
+  return result;
+}
+
+bool UnorderedElementsAreMatcherImplBase::FindPairing(
+    const MatchMatrix& matrix, MatchResultListener* listener) const {
+  ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix);
+
+  size_t max_flow = matches.size();
+  if ((match_flags() & UnorderedMatcherRequire::Superset) &&
+      max_flow < matrix.RhsSize()) {
+    if (listener->IsInterested()) {
+      *listener << "where no permutation of the elements can satisfy all "
+                   "matchers, and the closest match is "
+                << max_flow << " of " << matrix.RhsSize()
+                << " matchers with the pairings:\n";
+      LogElementMatcherPairVec(matches, listener->stream());
+    }
+    return false;
+  }
+  if ((match_flags() & UnorderedMatcherRequire::Subset) &&
+      max_flow < matrix.LhsSize()) {
+    if (listener->IsInterested()) {
+      *listener
+          << "where not all elements can be matched, and the closest match is "
+          << max_flow << " of " << matrix.RhsSize()
+          << " matchers with the pairings:\n";
+      LogElementMatcherPairVec(matches, listener->stream());
+    }
+    return false;
+  }
+
+  if (matches.size() > 1) {
+    if (listener->IsInterested()) {
+      const char* sep = "where:\n";
+      for (size_t mi = 0; mi < matches.size(); ++mi) {
+        *listener << sep << " - element #" << matches[mi].first
+                  << " is matched by matcher #" << matches[mi].second;
+        sep = ",\n";
+      }
+    }
+  }
+  return true;
+}
+
+}  // namespace internal
+}  // namespace testing
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements the spec builder syntax (ON_CALL and
+// EXPECT_CALL).
+
+
+#include <stdlib.h>
+
+#include <iostream>  // NOLINT
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+
+#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC
+# include <unistd.h>  // NOLINT
+#endif
+
+// Silence C4800 (C4800: 'int *const ': forcing value
+// to bool 'true' or 'false') for MSVC 15
+#ifdef _MSC_VER
+#if _MSC_VER == 1900
+#  pragma warning(push)
+#  pragma warning(disable:4800)
+#endif
+#endif
+
+namespace testing {
+namespace internal {
+
+// Protects the mock object registry (in class Mock), all function
+// mockers, and all expectations.
+GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_gmock_mutex);
+
+// Logs a message including file and line number information.
+GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
+                                const char* file, int line,
+                                const std::string& message) {
+  ::std::ostringstream s;
+  s << internal::FormatFileLocation(file, line) << " " << message
+    << ::std::endl;
+  Log(severity, s.str(), 0);
+}
+
+// Constructs an ExpectationBase object.
+ExpectationBase::ExpectationBase(const char* a_file, int a_line,
+                                 const std::string& a_source_text)
+    : file_(a_file),
+      line_(a_line),
+      source_text_(a_source_text),
+      cardinality_specified_(false),
+      cardinality_(Exactly(1)),
+      call_count_(0),
+      retired_(false),
+      extra_matcher_specified_(false),
+      repeated_action_specified_(false),
+      retires_on_saturation_(false),
+      last_clause_(kNone),
+      action_count_checked_(false) {}
+
+// Destructs an ExpectationBase object.
+ExpectationBase::~ExpectationBase() {}
+
+// Explicitly specifies the cardinality of this expectation.  Used by
+// the subclasses to implement the .Times() clause.
+void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) {
+  cardinality_specified_ = true;
+  cardinality_ = a_cardinality;
+}
+
+// Retires all pre-requisites of this expectation.
+void ExpectationBase::RetireAllPreRequisites()
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  if (is_retired()) {
+    // We can take this short-cut as we never retire an expectation
+    // until we have retired all its pre-requisites.
+    return;
+  }
+
+  ::std::vector<ExpectationBase*> expectations(1, this);
+  while (!expectations.empty()) {
+    ExpectationBase* exp = expectations.back();
+    expectations.pop_back();
+
+    for (ExpectationSet::const_iterator it =
+             exp->immediate_prerequisites_.begin();
+         it != exp->immediate_prerequisites_.end(); ++it) {
+      ExpectationBase* next = it->expectation_base().get();
+      if (!next->is_retired()) {
+        next->Retire();
+        expectations.push_back(next);
+      }
+    }
+  }
+}
+
+// Returns true if and only if all pre-requisites of this expectation
+// have been satisfied.
+bool ExpectationBase::AllPrerequisitesAreSatisfied() const
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+  ::std::vector<const ExpectationBase*> expectations(1, this);
+  while (!expectations.empty()) {
+    const ExpectationBase* exp = expectations.back();
+    expectations.pop_back();
+
+    for (ExpectationSet::const_iterator it =
+             exp->immediate_prerequisites_.begin();
+         it != exp->immediate_prerequisites_.end(); ++it) {
+      const ExpectationBase* next = it->expectation_base().get();
+      if (!next->IsSatisfied()) return false;
+      expectations.push_back(next);
+    }
+  }
+  return true;
+}
+
+// Adds unsatisfied pre-requisites of this expectation to 'result'.
+void ExpectationBase::FindUnsatisfiedPrerequisites(ExpectationSet* result) const
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+  ::std::vector<const ExpectationBase*> expectations(1, this);
+  while (!expectations.empty()) {
+    const ExpectationBase* exp = expectations.back();
+    expectations.pop_back();
+
+    for (ExpectationSet::const_iterator it =
+             exp->immediate_prerequisites_.begin();
+         it != exp->immediate_prerequisites_.end(); ++it) {
+      const ExpectationBase* next = it->expectation_base().get();
+
+      if (next->IsSatisfied()) {
+        // If *it is satisfied and has a call count of 0, some of its
+        // pre-requisites may not be satisfied yet.
+        if (next->call_count_ == 0) {
+          expectations.push_back(next);
+        }
+      } else {
+        // Now that we know next is unsatisfied, we are not so interested
+        // in whether its pre-requisites are satisfied.  Therefore we
+        // don't iterate into it here.
+        *result += *it;
+      }
+    }
+  }
+}
+
+// Describes how many times a function call matching this
+// expectation has occurred.
+void ExpectationBase::DescribeCallCountTo(::std::ostream* os) const
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+
+  // Describes how many times the function is expected to be called.
+  *os << "         Expected: to be ";
+  cardinality().DescribeTo(os);
+  *os << "\n           Actual: ";
+  Cardinality::DescribeActualCallCountTo(call_count(), os);
+
+  // Describes the state of the expectation (e.g. is it satisfied?
+  // is it active?).
+  *os << " - " << (IsOverSaturated() ? "over-saturated" :
+                   IsSaturated() ? "saturated" :
+                   IsSatisfied() ? "satisfied" : "unsatisfied")
+      << " and "
+      << (is_retired() ? "retired" : "active");
+}
+
+// Checks the action count (i.e. the number of WillOnce() and
+// WillRepeatedly() clauses) against the cardinality if this hasn't
+// been done before.  Prints a warning if there are too many or too
+// few actions.
+void ExpectationBase::CheckActionCountIfNotDone() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  bool should_check = false;
+  {
+    MutexLock l(&mutex_);
+    if (!action_count_checked_) {
+      action_count_checked_ = true;
+      should_check = true;
+    }
+  }
+
+  if (should_check) {
+    if (!cardinality_specified_) {
+      // The cardinality was inferred - no need to check the action
+      // count against it.
+      return;
+    }
+
+    // The cardinality was explicitly specified.
+    const int action_count = static_cast<int>(untyped_actions_.size());
+    const int upper_bound = cardinality().ConservativeUpperBound();
+    const int lower_bound = cardinality().ConservativeLowerBound();
+    bool too_many;  // True if there are too many actions, or false
+    // if there are too few.
+    if (action_count > upper_bound ||
+        (action_count == upper_bound && repeated_action_specified_)) {
+      too_many = true;
+    } else if (0 < action_count && action_count < lower_bound &&
+               !repeated_action_specified_) {
+      too_many = false;
+    } else {
+      return;
+    }
+
+    ::std::stringstream ss;
+    DescribeLocationTo(&ss);
+    ss << "Too " << (too_many ? "many" : "few")
+       << " actions specified in " << source_text() << "...\n"
+       << "Expected to be ";
+    cardinality().DescribeTo(&ss);
+    ss << ", but has " << (too_many ? "" : "only ")
+       << action_count << " WillOnce()"
+       << (action_count == 1 ? "" : "s");
+    if (repeated_action_specified_) {
+      ss << " and a WillRepeatedly()";
+    }
+    ss << ".";
+    Log(kWarning, ss.str(), -1);  // -1 means "don't print stack trace".
+  }
+}
+
+// Implements the .Times() clause.
+void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) {
+  if (last_clause_ == kTimes) {
+    ExpectSpecProperty(false,
+                       ".Times() cannot appear "
+                       "more than once in an EXPECT_CALL().");
+  } else {
+    ExpectSpecProperty(last_clause_ < kTimes,
+                       ".Times() cannot appear after "
+                       ".InSequence(), .WillOnce(), .WillRepeatedly(), "
+                       "or .RetiresOnSaturation().");
+  }
+  last_clause_ = kTimes;
+
+  SpecifyCardinality(a_cardinality);
+}
+
+// Points to the implicit sequence introduced by a living InSequence
+// object (if any) in the current thread or NULL.
+GTEST_API_ ThreadLocal<Sequence*> g_gmock_implicit_sequence;
+
+// Reports an uninteresting call (whose description is in msg) in the
+// manner specified by 'reaction'.
+void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
+  // Include a stack trace only if --gmock_verbose=info is specified.
+  const int stack_frames_to_skip =
+      GMOCK_FLAG(verbose) == kInfoVerbosity ? 3 : -1;
+  switch (reaction) {
+    case kAllow:
+      Log(kInfo, msg, stack_frames_to_skip);
+      break;
+    case kWarn:
+      Log(kWarning,
+          msg +
+              "\nNOTE: You can safely ignore the above warning unless this "
+              "call should not happen.  Do not suppress it by blindly adding "
+              "an EXPECT_CALL() if you don't mean to enforce the call.  "
+              "See "
+              "https://github.com/google/googletest/blob/master/docs/"
+              "gmock_cook_book.md#"
+              "knowing-when-to-expect for details.\n",
+          stack_frames_to_skip);
+      break;
+    default:  // FAIL
+      Expect(false, nullptr, -1, msg);
+  }
+}
+
+UntypedFunctionMockerBase::UntypedFunctionMockerBase()
+    : mock_obj_(nullptr), name_("") {}
+
+UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}
+
+// Sets the mock object this mock method belongs to, and registers
+// this information in the global mock registry.  Will be called
+// whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
+// method.
+void UntypedFunctionMockerBase::RegisterOwner(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  {
+    MutexLock l(&g_gmock_mutex);
+    mock_obj_ = mock_obj;
+  }
+  Mock::Register(mock_obj, this);
+}
+
+// Sets the mock object this mock method belongs to, and sets the name
+// of the mock function.  Will be called upon each invocation of this
+// mock function.
+void UntypedFunctionMockerBase::SetOwnerAndName(const void* mock_obj,
+                                                const char* name)
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  // We protect name_ under g_gmock_mutex in case this mock function
+  // is called from two threads concurrently.
+  MutexLock l(&g_gmock_mutex);
+  mock_obj_ = mock_obj;
+  name_ = name;
+}
+
+// Returns the name of the function being mocked.  Must be called
+// after RegisterOwner() or SetOwnerAndName() has been called.
+const void* UntypedFunctionMockerBase::MockObject() const
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  const void* mock_obj;
+  {
+    // We protect mock_obj_ under g_gmock_mutex in case this mock
+    // function is called from two threads concurrently.
+    MutexLock l(&g_gmock_mutex);
+    Assert(mock_obj_ != nullptr, __FILE__, __LINE__,
+           "MockObject() must not be called before RegisterOwner() or "
+           "SetOwnerAndName() has been called.");
+    mock_obj = mock_obj_;
+  }
+  return mock_obj;
+}
+
+// Returns the name of this mock method.  Must be called after
+// SetOwnerAndName() has been called.
+const char* UntypedFunctionMockerBase::Name() const
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  const char* name;
+  {
+    // We protect name_ under g_gmock_mutex in case this mock
+    // function is called from two threads concurrently.
+    MutexLock l(&g_gmock_mutex);
+    Assert(name_ != nullptr, __FILE__, __LINE__,
+           "Name() must not be called before SetOwnerAndName() has "
+           "been called.");
+    name = name_;
+  }
+  return name;
+}
+
+// Calculates the result of invoking this mock function with the given
+// arguments, prints it, and returns it.  The caller is responsible
+// for deleting the result.
+UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
+    void* const untyped_args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  // See the definition of untyped_expectations_ for why access to it
+  // is unprotected here.
+  if (untyped_expectations_.size() == 0) {
+    // No expectation is set on this mock method - we have an
+    // uninteresting call.
+
+    // We must get Google Mock's reaction on uninteresting calls
+    // made on this mock object BEFORE performing the action,
+    // because the action may DELETE the mock object and make the
+    // following expression meaningless.
+    const CallReaction reaction =
+        Mock::GetReactionOnUninterestingCalls(MockObject());
+
+    // True if and only if we need to print this call's arguments and return
+    // value.  This definition must be kept in sync with
+    // the behavior of ReportUninterestingCall().
+    const bool need_to_report_uninteresting_call =
+        // If the user allows this uninteresting call, we print it
+        // only when they want informational messages.
+        reaction == kAllow ? LogIsVisible(kInfo) :
+                           // If the user wants this to be a warning, we print
+                           // it only when they want to see warnings.
+            reaction == kWarn
+                ? LogIsVisible(kWarning)
+                :
+                // Otherwise, the user wants this to be an error, and we
+                // should always print detailed information in the error.
+                true;
+
+    if (!need_to_report_uninteresting_call) {
+      // Perform the action without printing the call information.
+      return this->UntypedPerformDefaultAction(
+          untyped_args, "Function call: " + std::string(Name()));
+    }
+
+    // Warns about the uninteresting call.
+    ::std::stringstream ss;
+    this->UntypedDescribeUninterestingCall(untyped_args, &ss);
+
+    // Calculates the function result.
+    UntypedActionResultHolderBase* const result =
+        this->UntypedPerformDefaultAction(untyped_args, ss.str());
+
+    // Prints the function result.
+    if (result != nullptr) result->PrintAsActionResult(&ss);
+
+    ReportUninterestingCall(reaction, ss.str());
+    return result;
+  }
+
+  bool is_excessive = false;
+  ::std::stringstream ss;
+  ::std::stringstream why;
+  ::std::stringstream loc;
+  const void* untyped_action = nullptr;
+
+  // The UntypedFindMatchingExpectation() function acquires and
+  // releases g_gmock_mutex.
+
+  const ExpectationBase* const untyped_expectation =
+      this->UntypedFindMatchingExpectation(untyped_args, &untyped_action,
+                                           &is_excessive, &ss, &why);
+  const bool found = untyped_expectation != nullptr;
+
+  // True if and only if we need to print the call's arguments
+  // and return value.
+  // This definition must be kept in sync with the uses of Expect()
+  // and Log() in this function.
+  const bool need_to_report_call =
+      !found || is_excessive || LogIsVisible(kInfo);
+  if (!need_to_report_call) {
+    // Perform the action without printing the call information.
+    return untyped_action == nullptr
+               ? this->UntypedPerformDefaultAction(untyped_args, "")
+               : this->UntypedPerformAction(untyped_action, untyped_args);
+  }
+
+  ss << "    Function call: " << Name();
+  this->UntypedPrintArgs(untyped_args, &ss);
+
+  // In case the action deletes a piece of the expectation, we
+  // generate the message beforehand.
+  if (found && !is_excessive) {
+    untyped_expectation->DescribeLocationTo(&loc);
+  }
+
+  UntypedActionResultHolderBase* result = nullptr;
+
+  auto perform_action = [&, this] {
+    return untyped_action == nullptr
+               ? this->UntypedPerformDefaultAction(untyped_args, ss.str())
+               : this->UntypedPerformAction(untyped_action, untyped_args);
+  };
+  auto handle_failures = [&] {
+    ss << "\n" << why.str();
+
+    if (!found) {
+      // No expectation matches this call - reports a failure.
+      Expect(false, nullptr, -1, ss.str());
+    } else if (is_excessive) {
+      // We had an upper-bound violation and the failure message is in ss.
+      Expect(false, untyped_expectation->file(), untyped_expectation->line(),
+             ss.str());
+    } else {
+      // We had an expected call and the matching expectation is
+      // described in ss.
+      Log(kInfo, loc.str() + ss.str(), 2);
+    }
+  };
+#if GTEST_HAS_EXCEPTIONS
+  try {
+    result = perform_action();
+  } catch (...) {
+    handle_failures();
+    throw;
+  }
+#else
+  result = perform_action();
+#endif
+
+  if (result != nullptr) result->PrintAsActionResult(&ss);
+  handle_failures();
+  return result;
+}
+
+// Returns an Expectation object that references and co-owns exp,
+// which must be an expectation on this mock function.
+Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) {
+  // See the definition of untyped_expectations_ for why access to it
+  // is unprotected here.
+  for (UntypedExpectations::const_iterator it =
+           untyped_expectations_.begin();
+       it != untyped_expectations_.end(); ++it) {
+    if (it->get() == exp) {
+      return Expectation(*it);
+    }
+  }
+
+  Assert(false, __FILE__, __LINE__, "Cannot find expectation.");
+  return Expectation();
+  // The above statement is just to make the code compile, and will
+  // never be executed.
+}
+
+// Verifies that all expectations on this mock function have been
+// satisfied.  Reports one or more Google Test non-fatal failures
+// and returns false if not.
+bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+  bool expectations_met = true;
+  for (UntypedExpectations::const_iterator it =
+           untyped_expectations_.begin();
+       it != untyped_expectations_.end(); ++it) {
+    ExpectationBase* const untyped_expectation = it->get();
+    if (untyped_expectation->IsOverSaturated()) {
+      // There was an upper-bound violation.  Since the error was
+      // already reported when it occurred, there is no need to do
+      // anything here.
+      expectations_met = false;
+    } else if (!untyped_expectation->IsSatisfied()) {
+      expectations_met = false;
+      ::std::stringstream ss;
+      ss  << "Actual function call count doesn't match "
+          << untyped_expectation->source_text() << "...\n";
+      // No need to show the source file location of the expectation
+      // in the description, as the Expect() call that follows already
+      // takes care of it.
+      untyped_expectation->MaybeDescribeExtraMatcherTo(&ss);
+      untyped_expectation->DescribeCallCountTo(&ss);
+      Expect(false, untyped_expectation->file(),
+             untyped_expectation->line(), ss.str());
+    }
+  }
+
+  // Deleting our expectations may trigger other mock objects to be deleted, for
+  // example if an action contains a reference counted smart pointer to that
+  // mock object, and that is the last reference. So if we delete our
+  // expectations within the context of the global mutex we may deadlock when
+  // this method is called again. Instead, make a copy of the set of
+  // expectations to delete, clear our set within the mutex, and then clear the
+  // copied set outside of it.
+  UntypedExpectations expectations_to_delete;
+  untyped_expectations_.swap(expectations_to_delete);
+
+  g_gmock_mutex.Unlock();
+  expectations_to_delete.clear();
+  g_gmock_mutex.Lock();
+
+  return expectations_met;
+}
+
+CallReaction intToCallReaction(int mock_behavior) {
+  if (mock_behavior >= kAllow && mock_behavior <= kFail) {
+    return static_cast<internal::CallReaction>(mock_behavior);
+  }
+  return kWarn;
+}
+
+}  // namespace internal
+
+// Class Mock.
+
+namespace {
+
+typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers;
+
+// The current state of a mock object.  Such information is needed for
+// detecting leaked mock objects and explicitly verifying a mock's
+// expectations.
+struct MockObjectState {
+  MockObjectState()
+      : first_used_file(nullptr), first_used_line(-1), leakable(false) {}
+
+  // Where in the source file an ON_CALL or EXPECT_CALL is first
+  // invoked on this mock object.
+  const char* first_used_file;
+  int first_used_line;
+  ::std::string first_used_test_suite;
+  ::std::string first_used_test;
+  bool leakable;  // true if and only if it's OK to leak the object.
+  FunctionMockers function_mockers;  // All registered methods of the object.
+};
+
+// A global registry holding the state of all mock objects that are
+// alive.  A mock object is added to this registry the first time
+// Mock::AllowLeak(), ON_CALL(), or EXPECT_CALL() is called on it.  It
+// is removed from the registry in the mock object's destructor.
+class MockObjectRegistry {
+ public:
+  // Maps a mock object (identified by its address) to its state.
+  typedef std::map<const void*, MockObjectState> StateMap;
+
+  // This destructor will be called when a program exits, after all
+  // tests in it have been run.  By then, there should be no mock
+  // object alive.  Therefore we report any living object as test
+  // failure, unless the user explicitly asked us to ignore it.
+  ~MockObjectRegistry() {
+    if (!GMOCK_FLAG(catch_leaked_mocks))
+      return;
+
+    int leaked_count = 0;
+    for (StateMap::const_iterator it = states_.begin(); it != states_.end();
+         ++it) {
+      if (it->second.leakable)  // The user said it's fine to leak this object.
+        continue;
+
+      // FIXME: Print the type of the leaked object.
+      // This can help the user identify the leaked object.
+      std::cout << "\n";
+      const MockObjectState& state = it->second;
+      std::cout << internal::FormatFileLocation(state.first_used_file,
+                                                state.first_used_line);
+      std::cout << " ERROR: this mock object";
+      if (state.first_used_test != "") {
+        std::cout << " (used in test " << state.first_used_test_suite << "."
+                  << state.first_used_test << ")";
+      }
+      std::cout << " should be deleted but never is. Its address is @"
+           << it->first << ".";
+      leaked_count++;
+    }
+    if (leaked_count > 0) {
+      std::cout << "\nERROR: " << leaked_count << " leaked mock "
+                << (leaked_count == 1 ? "object" : "objects")
+                << " found at program exit. Expectations on a mock object are "
+                   "verified when the object is destructed. Leaking a mock "
+                   "means that its expectations aren't verified, which is "
+                   "usually a test bug. If you really intend to leak a mock, "
+                   "you can suppress this error using "
+                   "testing::Mock::AllowLeak(mock_object), or you may use a "
+                   "fake or stub instead of a mock.\n";
+      std::cout.flush();
+      ::std::cerr.flush();
+      // RUN_ALL_TESTS() has already returned when this destructor is
+      // called.  Therefore we cannot use the normal Google Test
+      // failure reporting mechanism.
+      _exit(1);  // We cannot call exit() as it is not reentrant and
+                 // may already have been called.
+    }
+  }
+
+  StateMap& states() { return states_; }
+
+ private:
+  StateMap states_;
+};
+
+// Protected by g_gmock_mutex.
+MockObjectRegistry g_mock_object_registry;
+
+// Maps a mock object to the reaction Google Mock should have when an
+// uninteresting method is called.  Protected by g_gmock_mutex.
+std::map<const void*, internal::CallReaction> g_uninteresting_call_reaction;
+
+// Sets the reaction Google Mock should have when an uninteresting
+// method of the given mock object is called.
+void SetReactionOnUninterestingCalls(const void* mock_obj,
+                                     internal::CallReaction reaction)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_uninteresting_call_reaction[mock_obj] = reaction;
+}
+
+}  // namespace
+
+// Tells Google Mock to allow uninteresting calls on the given mock
+// object.
+void Mock::AllowUninterestingCalls(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  SetReactionOnUninterestingCalls(mock_obj, internal::kAllow);
+}
+
+// Tells Google Mock to warn the user about uninteresting calls on the
+// given mock object.
+void Mock::WarnUninterestingCalls(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  SetReactionOnUninterestingCalls(mock_obj, internal::kWarn);
+}
+
+// Tells Google Mock to fail uninteresting calls on the given mock
+// object.
+void Mock::FailUninterestingCalls(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  SetReactionOnUninterestingCalls(mock_obj, internal::kFail);
+}
+
+// Tells Google Mock the given mock object is being destroyed and its
+// entry in the call-reaction table should be removed.
+void Mock::UnregisterCallReaction(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_uninteresting_call_reaction.erase(mock_obj);
+}
+
+// Returns the reaction Google Mock will have on uninteresting calls
+// made on the given mock object.
+internal::CallReaction Mock::GetReactionOnUninterestingCalls(
+    const void* mock_obj)
+        GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  return (g_uninteresting_call_reaction.count(mock_obj) == 0) ?
+      internal::intToCallReaction(GMOCK_FLAG(default_mock_behavior)) :
+      g_uninteresting_call_reaction[mock_obj];
+}
+
+// Tells Google Mock to ignore mock_obj when checking for leaked mock
+// objects.
+void Mock::AllowLeak(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_mock_object_registry.states()[mock_obj].leakable = true;
+}
+
+// Verifies and clears all expectations on the given mock object.  If
+// the expectations aren't satisfied, generates one or more Google
+// Test non-fatal failures and returns false.
+bool Mock::VerifyAndClearExpectations(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  return VerifyAndClearExpectationsLocked(mock_obj);
+}
+
+// Verifies all expectations on the given mock object and clears its
+// default actions and expectations.  Returns true if and only if the
+// verification was successful.
+bool Mock::VerifyAndClear(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  ClearDefaultActionsLocked(mock_obj);
+  return VerifyAndClearExpectationsLocked(mock_obj);
+}
+
+// Verifies and clears all expectations on the given mock object.  If
+// the expectations aren't satisfied, generates one or more Google
+// Test non-fatal failures and returns false.
+bool Mock::VerifyAndClearExpectationsLocked(void* mock_obj)
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
+  internal::g_gmock_mutex.AssertHeld();
+  if (g_mock_object_registry.states().count(mock_obj) == 0) {
+    // No EXPECT_CALL() was set on the given mock object.
+    return true;
+  }
+
+  // Verifies and clears the expectations on each mock method in the
+  // given mock object.
+  bool expectations_met = true;
+  FunctionMockers& mockers =
+      g_mock_object_registry.states()[mock_obj].function_mockers;
+  for (FunctionMockers::const_iterator it = mockers.begin();
+       it != mockers.end(); ++it) {
+    if (!(*it)->VerifyAndClearExpectationsLocked()) {
+      expectations_met = false;
+    }
+  }
+
+  // We don't clear the content of mockers, as they may still be
+  // needed by ClearDefaultActionsLocked().
+  return expectations_met;
+}
+
+bool Mock::IsNaggy(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kWarn;
+}
+bool Mock::IsNice(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kAllow;
+}
+bool Mock::IsStrict(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kFail;
+}
+
+// Registers a mock object and a mock method it owns.
+void Mock::Register(const void* mock_obj,
+                    internal::UntypedFunctionMockerBase* mocker)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker);
+}
+
+// Tells Google Mock where in the source code mock_obj is used in an
+// ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
+// information helps the user identify which object it is.
+void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj,
+                                           const char* file, int line)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  MockObjectState& state = g_mock_object_registry.states()[mock_obj];
+  if (state.first_used_file == nullptr) {
+    state.first_used_file = file;
+    state.first_used_line = line;
+    const TestInfo* const test_info =
+        UnitTest::GetInstance()->current_test_info();
+    if (test_info != nullptr) {
+      state.first_used_test_suite = test_info->test_suite_name();
+      state.first_used_test = test_info->name();
+    }
+  }
+}
+
+// Unregisters a mock method; removes the owning mock object from the
+// registry when the last mock method associated with it has been
+// unregistered.  This is called only in the destructor of
+// FunctionMockerBase.
+void Mock::UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
+  internal::g_gmock_mutex.AssertHeld();
+  for (MockObjectRegistry::StateMap::iterator it =
+           g_mock_object_registry.states().begin();
+       it != g_mock_object_registry.states().end(); ++it) {
+    FunctionMockers& mockers = it->second.function_mockers;
+    if (mockers.erase(mocker) > 0) {
+      // mocker was in mockers and has been just removed.
+      if (mockers.empty()) {
+        g_mock_object_registry.states().erase(it);
+      }
+      return;
+    }
+  }
+}
+
+// Clears all ON_CALL()s set on the given mock object.
+void Mock::ClearDefaultActionsLocked(void* mock_obj)
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
+  internal::g_gmock_mutex.AssertHeld();
+
+  if (g_mock_object_registry.states().count(mock_obj) == 0) {
+    // No ON_CALL() was set on the given mock object.
+    return;
+  }
+
+  // Clears the default actions for each mock method in the given mock
+  // object.
+  FunctionMockers& mockers =
+      g_mock_object_registry.states()[mock_obj].function_mockers;
+  for (FunctionMockers::const_iterator it = mockers.begin();
+       it != mockers.end(); ++it) {
+    (*it)->ClearDefaultActionsLocked();
+  }
+
+  // We don't clear the content of mockers, as they may still be
+  // needed by VerifyAndClearExpectationsLocked().
+}
+
+Expectation::Expectation() {}
+
+Expectation::Expectation(
+    const std::shared_ptr<internal::ExpectationBase>& an_expectation_base)
+    : expectation_base_(an_expectation_base) {}
+
+Expectation::~Expectation() {}
+
+// Adds an expectation to a sequence.
+void Sequence::AddExpectation(const Expectation& expectation) const {
+  if (*last_expectation_ != expectation) {
+    if (last_expectation_->expectation_base() != nullptr) {
+      expectation.expectation_base()->immediate_prerequisites_
+          += *last_expectation_;
+    }
+    *last_expectation_ = expectation;
+  }
+}
+
+// Creates the implicit sequence if there isn't one.
+InSequence::InSequence() {
+  if (internal::g_gmock_implicit_sequence.get() == nullptr) {
+    internal::g_gmock_implicit_sequence.set(new Sequence);
+    sequence_created_ = true;
+  } else {
+    sequence_created_ = false;
+  }
+}
+
+// Deletes the implicit sequence if it was created by the constructor
+// of this object.
+InSequence::~InSequence() {
+  if (sequence_created_) {
+    delete internal::g_gmock_implicit_sequence.get();
+    internal::g_gmock_implicit_sequence.set(nullptr);
+  }
+}
+
+}  // namespace testing
+
+#ifdef _MSC_VER
+#if _MSC_VER == 1900
+#  pragma warning(pop)
+#endif
+#endif
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+namespace testing {
+
+GMOCK_DEFINE_bool_(catch_leaked_mocks, true,
+                   "true if and only if Google Mock should report leaked "
+                   "mock objects as failures.");
+
+GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity,
+                     "Controls how verbose Google Mock's output is."
+                     "  Valid values:\n"
+                     "  info    - prints all messages.\n"
+                     "  warning - prints warnings and errors.\n"
+                     "  error   - prints errors only.");
+
+GMOCK_DEFINE_int32_(default_mock_behavior, 1,
+                    "Controls the default behavior of mocks."
+                    "  Valid values:\n"
+                    "  0 - by default, mocks act as NiceMocks.\n"
+                    "  1 - by default, mocks act as NaggyMocks.\n"
+                    "  2 - by default, mocks act as StrictMocks.");
+
+namespace internal {
+
+// Parses a string as a command line flag.  The string should have the
+// format "--gmock_flag=value".  When def_optional is true, the
+// "=value" part can be omitted.
+//
+// Returns the value of the flag, or NULL if the parsing failed.
+static const char* ParseGoogleMockFlagValue(const char* str,
+                                            const char* flag,
+                                            bool def_optional) {
+  // str and flag must not be NULL.
+  if (str == nullptr || flag == nullptr) return nullptr;
+
+  // The flag must start with "--gmock_".
+  const std::string flag_str = std::string("--gmock_") + flag;
+  const size_t flag_len = flag_str.length();
+  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
+
+  // Skips the flag name.
+  const char* flag_end = str + flag_len;
+
+  // When def_optional is true, it's OK to not have a "=value" part.
+  if (def_optional && (flag_end[0] == '\0')) {
+    return flag_end;
+  }
+
+  // If def_optional is true and there are more characters after the
+  // flag name, or if def_optional is false, there must be a '=' after
+  // the flag name.
+  if (flag_end[0] != '=') return nullptr;
+
+  // Returns the string after "=".
+  return flag_end + 1;
+}
+
+// Parses a string for a Google Mock bool flag, in the form of
+// "--gmock_flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
+                                    bool* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
+
+  // Aborts if the parsing failed.
+  if (value_str == nullptr) return false;
+
+  // Converts the string value to a bool.
+  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
+  return true;
+}
+
+// Parses a string for a Google Mock string flag, in the form of
+// "--gmock_flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+template <typename String>
+static bool ParseGoogleMockStringFlag(const char* str, const char* flag,
+                                      String* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);
+
+  // Aborts if the parsing failed.
+  if (value_str == nullptr) return false;
+
+  // Sets *value to the value of the flag.
+  *value = value_str;
+  return true;
+}
+
+static bool ParseGoogleMockIntFlag(const char* str, const char* flag,
+                                   int32_t* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
+
+  // Aborts if the parsing failed.
+  if (value_str == nullptr) return false;
+
+  // Sets *value to the value of the flag.
+  return ParseInt32(Message() << "The value of flag --" << flag,
+                    value_str, value);
+}
+
+// The internal implementation of InitGoogleMock().
+//
+// The type parameter CharType can be instantiated to either char or
+// wchar_t.
+template <typename CharType>
+void InitGoogleMockImpl(int* argc, CharType** argv) {
+  // Makes sure Google Test is initialized.  InitGoogleTest() is
+  // idempotent, so it's fine if the user has already called it.
+  InitGoogleTest(argc, argv);
+  if (*argc <= 0) return;
+
+  for (int i = 1; i != *argc; i++) {
+    const std::string arg_string = StreamableToString(argv[i]);
+    const char* const arg = arg_string.c_str();
+
+    // Do we see a Google Mock flag?
+    if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
+                                &GMOCK_FLAG(catch_leaked_mocks)) ||
+        ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose)) ||
+        ParseGoogleMockIntFlag(arg, "default_mock_behavior",
+                               &GMOCK_FLAG(default_mock_behavior))) {
+      // Yes.  Shift the remainder of the argv list left by one.  Note
+      // that argv has (*argc + 1) elements, the last one always being
+      // NULL.  The following loop moves the trailing NULL element as
+      // well.
+      for (int j = i; j != *argc; j++) {
+        argv[j] = argv[j + 1];
+      }
+
+      // Decrements the argument count.
+      (*argc)--;
+
+      // We also need to decrement the iterator as we just removed
+      // an element.
+      i--;
+    }
+  }
+}
+
+}  // namespace internal
+
+// Initializes Google Mock.  This must be called before running the
+// tests.  In particular, it parses a command line for the flags that
+// Google Mock recognizes.  Whenever a Google Mock flag is seen, it is
+// removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Mock flag variables are
+// updated.
+//
+// Since Google Test is needed for Google Mock to work, this function
+// also initializes Google Test and parses its flags, if that hasn't
+// been done.
+GTEST_API_ void InitGoogleMock(int* argc, char** argv) {
+  internal::InitGoogleMockImpl(argc, argv);
+}
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv) {
+  internal::InitGoogleMockImpl(argc, argv);
+}
+
+// This overloaded version can be used on Arduino/embedded platforms where
+// there is no argc/argv.
+GTEST_API_ void InitGoogleMock() {
+  // Since Arduino doesn't have a command line, fake out the argc/argv arguments
+  int argc = 1;
+  const auto arg0 = "dummy";
+  char* argv0 = const_cast<char*>(arg0);
+  char** argv = &argv0;
+
+  internal::InitGoogleMockImpl(&argc, argv);
+}
+
+}  // namespace testing
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/gmock/gmock.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/gmock/gmock.h
new file mode 100644
index 0000000000000000000000000000000000000000..d121f7df2b7b470fc9f8490ecf0985bbe0ebf7d7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/gmock/gmock.h
@@ -0,0 +1,11645 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This is the main header file a user should include.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
+
+// This file implements the following syntax:
+//
+//   ON_CALL(mock_object, Method(...))
+//     .With(...) ?
+//     .WillByDefault(...);
+//
+// where With() is optional and WillByDefault() must appear exactly
+// once.
+//
+//   EXPECT_CALL(mock_object, Method(...))
+//     .With(...) ?
+//     .Times(...) ?
+//     .InSequence(...) *
+//     .WillOnce(...) *
+//     .WillRepeatedly(...) ?
+//     .RetiresOnSaturation() ? ;
+//
+// where all clauses are optional and WillOnce() can be repeated.
+
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// The ACTION* family of macros can be used in a namespace scope to
+// define custom actions easily.  The syntax:
+//
+//   ACTION(name) { statements; }
+//
+// will define an action with the given name that executes the
+// statements.  The value returned by the statements will be used as
+// the return value of the action.  Inside the statements, you can
+// refer to the K-th (0-based) argument of the mock function by
+// 'argK', and refer to its type by 'argK_type'.  For example:
+//
+//   ACTION(IncrementArg1) {
+//     arg1_type temp = arg1;
+//     return ++(*temp);
+//   }
+//
+// allows you to write
+//
+//   ...WillOnce(IncrementArg1());
+//
+// You can also refer to the entire argument tuple and its type by
+// 'args' and 'args_type', and refer to the mock function type and its
+// return type by 'function_type' and 'return_type'.
+//
+// Note that you don't need to specify the types of the mock function
+// arguments.  However rest assured that your code is still type-safe:
+// you'll get a compiler error if *arg1 doesn't support the ++
+// operator, or if the type of ++(*arg1) isn't compatible with the
+// mock function's return type, for example.
+//
+// Sometimes you'll want to parameterize the action.   For that you can use
+// another macro:
+//
+//   ACTION_P(name, param_name) { statements; }
+//
+// For example:
+//
+//   ACTION_P(Add, n) { return arg0 + n; }
+//
+// will allow you to write:
+//
+//   ...WillOnce(Add(5));
+//
+// Note that you don't need to provide the type of the parameter
+// either.  If you need to reference the type of a parameter named
+// 'foo', you can write 'foo_type'.  For example, in the body of
+// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type
+// of 'n'.
+//
+// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support
+// multi-parameter actions.
+//
+// For the purpose of typing, you can view
+//
+//   ACTION_Pk(Foo, p1, ..., pk) { ... }
+//
+// as shorthand for
+//
+//   template <typename p1_type, ..., typename pk_type>
+//   FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }
+//
+// In particular, you can provide the template type arguments
+// explicitly when invoking Foo(), as in Foo<long, bool>(5, false);
+// although usually you can rely on the compiler to infer the types
+// for you automatically.  You can assign the result of expression
+// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,
+// pk_type>.  This can be useful when composing actions.
+//
+// You can also overload actions with different numbers of parameters:
+//
+//   ACTION_P(Plus, a) { ... }
+//   ACTION_P2(Plus, a, b) { ... }
+//
+// While it's tempting to always use the ACTION* macros when defining
+// a new action, you should also consider implementing ActionInterface
+// or using MakePolymorphicAction() instead, especially if you need to
+// use the action a lot.  While these approaches require more work,
+// they give you more control on the types of the mock function
+// arguments and the action parameters, which in general leads to
+// better compiler error messages that pay off in the long run.  They
+// also allow overloading actions based on parameter types (as opposed
+// to just based on the number of parameters).
+//
+// CAVEAT:
+//
+// ACTION*() can only be used in a namespace scope as templates cannot be
+// declared inside of a local class.
+// Users can, however, define any local functors (e.g. a lambda) that
+// can be used as actions.
+//
+// MORE INFORMATION:
+//
+// To learn more about using these macros, please search for 'ACTION' on
+// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+
+#ifndef _WIN32_WCE
+# include <errno.h>
+#endif
+
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file defines some utilities useful for implementing Google
+// Mock.  They are subject to change without notice, so please DO NOT
+// USE THEM IN USER CODE.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+
+#include <stdio.h>
+#include <ostream>  // NOLINT
+#include <string>
+#include <type_traits>
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+//
+// Low-level types and utilities for porting Google Mock to various
+// platforms.  All macros ending with _ and symbols defined in an
+// internal namespace are subject to change without notice.  Code
+// outside Google Mock MUST NOT USE THEM DIRECTLY.  Macros that don't
+// end with _ are part of Google Mock's public API and can be used by
+// code outside Google Mock.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+
+#include <assert.h>
+#include <stdlib.h>
+#include <cstdint>
+#include <iostream>
+
+// Most of the utilities needed for porting Google Mock are also
+// required for Google Test and are defined in gtest-port.h.
+//
+// Note to maintainers: to reduce code duplication, prefer adding
+// portability utilities to Google Test's gtest-port.h instead of
+// here, as Google Mock depends on Google Test.  Only add a utility
+// here if it's truly specific to Google Mock.
+
+#include "gtest/gtest.h"
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Injection point for custom user configurations. See README for details
+//
+// ** Custom implementation starts here **
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
+
+// For MS Visual C++, check the compiler version. At least VS 2015 is
+// required to compile Google Mock.
+#if defined(_MSC_VER) && _MSC_VER < 1900
+# error "At least Visual C++ 2015 (14.0) is required to compile Google Mock."
+#endif
+
+// Macro for referencing flags.  This is public as we want the user to
+// use this syntax to reference Google Mock flags.
+#define GMOCK_FLAG(name) FLAGS_gmock_##name
+
+#if !defined(GMOCK_DECLARE_bool_)
+
+// Macros for declaring flags.
+# define GMOCK_DECLARE_bool_(name) extern GTEST_API_ bool GMOCK_FLAG(name)
+# define GMOCK_DECLARE_int32_(name) extern GTEST_API_ int32_t GMOCK_FLAG(name)
+# define GMOCK_DECLARE_string_(name) \
+    extern GTEST_API_ ::std::string GMOCK_FLAG(name)
+
+// Macros for defining flags.
+# define GMOCK_DEFINE_bool_(name, default_val, doc) \
+    GTEST_API_ bool GMOCK_FLAG(name) = (default_val)
+# define GMOCK_DEFINE_int32_(name, default_val, doc) \
+    GTEST_API_ int32_t GMOCK_FLAG(name) = (default_val)
+# define GMOCK_DEFINE_string_(name, default_val, doc) \
+    GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val)
+
+#endif  // !defined(GMOCK_DECLARE_bool_)
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+
+namespace testing {
+
+template <typename>
+class Matcher;
+
+namespace internal {
+
+// Silence MSVC C4100 (unreferenced formal parameter) and
+// C4805('==': unsafe mix of type 'const int' and type 'const bool')
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+# pragma warning(disable:4805)
+#endif
+
+// Joins a vector of strings as if they are fields of a tuple; returns
+// the joined string.
+GTEST_API_ std::string JoinAsTuple(const Strings& fields);
+
+// Converts an identifier name to a space-separated list of lower-case
+// words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
+// treated as one word.  For example, both "FooBar123" and
+// "foo_bar_123" are converted to "foo bar 123".
+GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name);
+
+// GetRawPointer(p) returns the raw pointer underlying p when p is a
+// smart pointer, or returns p itself when p is already a raw pointer.
+// The following default implementation is for the smart pointer case.
+template <typename Pointer>
+inline const typename Pointer::element_type* GetRawPointer(const Pointer& p) {
+  return p.get();
+}
+// This overloaded version is for the raw pointer case.
+template <typename Element>
+inline Element* GetRawPointer(Element* p) { return p; }
+
+// MSVC treats wchar_t as a native type usually, but treats it as the
+// same as unsigned short when the compiler option /Zc:wchar_t- is
+// specified.  It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t
+// is a native type.
+#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)
+// wchar_t is a typedef.
+#else
+# define GMOCK_WCHAR_T_IS_NATIVE_ 1
+#endif
+
+// In what follows, we use the term "kind" to indicate whether a type
+// is bool, an integer type (excluding bool), a floating-point type,
+// or none of them.  This categorization is useful for determining
+// when a matcher argument type can be safely converted to another
+// type in the implementation of SafeMatcherCast.
+enum TypeKind {
+  kBool, kInteger, kFloatingPoint, kOther
+};
+
+// KindOf<T>::value is the kind of type T.
+template <typename T> struct KindOf {
+  enum { value = kOther };  // The default kind.
+};
+
+// This macro declares that the kind of 'type' is 'kind'.
+#define GMOCK_DECLARE_KIND_(type, kind) \
+  template <> struct KindOf<type> { enum { value = kind }; }
+
+GMOCK_DECLARE_KIND_(bool, kBool);
+
+// All standard integer types.
+GMOCK_DECLARE_KIND_(char, kInteger);
+GMOCK_DECLARE_KIND_(signed char, kInteger);
+GMOCK_DECLARE_KIND_(unsigned char, kInteger);
+GMOCK_DECLARE_KIND_(short, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned short, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(int, kInteger);
+GMOCK_DECLARE_KIND_(unsigned int, kInteger);
+GMOCK_DECLARE_KIND_(long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(long long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned long long, kInteger);  // NOLINT
+
+#if GMOCK_WCHAR_T_IS_NATIVE_
+GMOCK_DECLARE_KIND_(wchar_t, kInteger);
+#endif
+
+// All standard floating-point types.
+GMOCK_DECLARE_KIND_(float, kFloatingPoint);
+GMOCK_DECLARE_KIND_(double, kFloatingPoint);
+GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
+
+#undef GMOCK_DECLARE_KIND_
+
+// Evaluates to the kind of 'type'.
+#define GMOCK_KIND_OF_(type) \
+  static_cast< ::testing::internal::TypeKind>( \
+      ::testing::internal::KindOf<type>::value)
+
+// LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value
+// is true if and only if arithmetic type From can be losslessly converted to
+// arithmetic type To.
+//
+// It's the user's responsibility to ensure that both From and To are
+// raw (i.e. has no CV modifier, is not a pointer, and is not a
+// reference) built-in arithmetic types, kFromKind is the kind of
+// From, and kToKind is the kind of To; the value is
+// implementation-defined when the above pre-condition is violated.
+template <TypeKind kFromKind, typename From, TypeKind kToKind, typename To>
+using LosslessArithmeticConvertibleImpl = std::integral_constant<
+    bool,
+    // clang-format off
+      // Converting from bool is always lossless
+      (kFromKind == kBool) ? true
+      // Converting between any other type kinds will be lossy if the type
+      // kinds are not the same.
+    : (kFromKind != kToKind) ? false
+    : (kFromKind == kInteger &&
+       // Converting between integers of different widths is allowed so long
+       // as the conversion does not go from signed to unsigned.
+      (((sizeof(From) < sizeof(To)) &&
+        !(std::is_signed<From>::value && !std::is_signed<To>::value)) ||
+       // Converting between integers of the same width only requires the
+       // two types to have the same signedness.
+       ((sizeof(From) == sizeof(To)) &&
+        (std::is_signed<From>::value == std::is_signed<To>::value)))
+       ) ? true
+      // Floating point conversions are lossless if and only if `To` is at least
+      // as wide as `From`.
+    : (kFromKind == kFloatingPoint && (sizeof(From) <= sizeof(To))) ? true
+    : false
+    // clang-format on
+    >;
+
+// LosslessArithmeticConvertible<From, To>::value is true if and only if
+// arithmetic type From can be losslessly converted to arithmetic type To.
+//
+// It's the user's responsibility to ensure that both From and To are
+// raw (i.e. has no CV modifier, is not a pointer, and is not a
+// reference) built-in arithmetic types; the value is
+// implementation-defined when the above pre-condition is violated.
+template <typename From, typename To>
+using LosslessArithmeticConvertible =
+    LosslessArithmeticConvertibleImpl<GMOCK_KIND_OF_(From), From,
+                                      GMOCK_KIND_OF_(To), To>;
+
+// This interface knows how to report a Google Mock failure (either
+// non-fatal or fatal).
+class FailureReporterInterface {
+ public:
+  // The type of a failure (either non-fatal or fatal).
+  enum FailureType {
+    kNonfatal, kFatal
+  };
+
+  virtual ~FailureReporterInterface() {}
+
+  // Reports a failure that occurred at the given source file location.
+  virtual void ReportFailure(FailureType type, const char* file, int line,
+                             const std::string& message) = 0;
+};
+
+// Returns the failure reporter used by Google Mock.
+GTEST_API_ FailureReporterInterface* GetFailureReporter();
+
+// Asserts that condition is true; aborts the process with the given
+// message if condition is false.  We cannot use LOG(FATAL) or CHECK()
+// as Google Mock might be used to mock the log sink itself.  We
+// inline this function to prevent it from showing up in the stack
+// trace.
+inline void Assert(bool condition, const char* file, int line,
+                   const std::string& msg) {
+  if (!condition) {
+    GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal,
+                                        file, line, msg);
+  }
+}
+inline void Assert(bool condition, const char* file, int line) {
+  Assert(condition, file, line, "Assertion failed.");
+}
+
+// Verifies that condition is true; generates a non-fatal failure if
+// condition is false.
+inline void Expect(bool condition, const char* file, int line,
+                   const std::string& msg) {
+  if (!condition) {
+    GetFailureReporter()->ReportFailure(FailureReporterInterface::kNonfatal,
+                                        file, line, msg);
+  }
+}
+inline void Expect(bool condition, const char* file, int line) {
+  Expect(condition, file, line, "Expectation failed.");
+}
+
+// Severity level of a log.
+enum LogSeverity {
+  kInfo = 0,
+  kWarning = 1
+};
+
+// Valid values for the --gmock_verbose flag.
+
+// All logs (informational and warnings) are printed.
+const char kInfoVerbosity[] = "info";
+// Only warnings are printed.
+const char kWarningVerbosity[] = "warning";
+// No logs are printed.
+const char kErrorVerbosity[] = "error";
+
+// Returns true if and only if a log with the given severity is visible
+// according to the --gmock_verbose flag.
+GTEST_API_ bool LogIsVisible(LogSeverity severity);
+
+// Prints the given message to stdout if and only if 'severity' >= the level
+// specified by the --gmock_verbose flag.  If stack_frames_to_skip >=
+// 0, also prints the stack trace excluding the top
+// stack_frames_to_skip frames.  In opt mode, any positive
+// stack_frames_to_skip is treated as 0, since we don't know which
+// function calls will be inlined by the compiler and need to be
+// conservative.
+GTEST_API_ void Log(LogSeverity severity, const std::string& message,
+                    int stack_frames_to_skip);
+
+// A marker class that is used to resolve parameterless expectations to the
+// correct overload. This must not be instantiable, to prevent client code from
+// accidentally resolving to the overload; for example:
+//
+//    ON_CALL(mock, Method({}, nullptr))...
+//
+class WithoutMatchers {
+ private:
+  WithoutMatchers() {}
+  friend GTEST_API_ WithoutMatchers GetWithoutMatchers();
+};
+
+// Internal use only: access the singleton instance of WithoutMatchers.
+GTEST_API_ WithoutMatchers GetWithoutMatchers();
+
+// Disable MSVC warnings for infinite recursion, since in this case the
+// the recursion is unreachable.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4717)
+#endif
+
+// Invalid<T>() is usable as an expression of type T, but will terminate
+// the program with an assertion failure if actually run.  This is useful
+// when a value of type T is needed for compilation, but the statement
+// will not really be executed (or we don't care if the statement
+// crashes).
+template <typename T>
+inline T Invalid() {
+  Assert(false, "", -1, "Internal error: attempt to return invalid value");
+  // This statement is unreachable, and would never terminate even if it
+  // could be reached. It is provided only to placate compiler warnings
+  // about missing return statements.
+  return Invalid<T>();
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+// Given a raw type (i.e. having no top-level reference or const
+// modifier) RawContainer that's either an STL-style container or a
+// native array, class StlContainerView<RawContainer> has the
+// following members:
+//
+//   - type is a type that provides an STL-style container view to
+//     (i.e. implements the STL container concept for) RawContainer;
+//   - const_reference is a type that provides a reference to a const
+//     RawContainer;
+//   - ConstReference(raw_container) returns a const reference to an STL-style
+//     container view to raw_container, which is a RawContainer.
+//   - Copy(raw_container) returns an STL-style container view of a
+//     copy of raw_container, which is a RawContainer.
+//
+// This generic version is used when RawContainer itself is already an
+// STL-style container.
+template <class RawContainer>
+class StlContainerView {
+ public:
+  typedef RawContainer type;
+  typedef const type& const_reference;
+
+  static const_reference ConstReference(const RawContainer& container) {
+    static_assert(!std::is_const<RawContainer>::value,
+                  "RawContainer type must not be const");
+    return container;
+  }
+  static type Copy(const RawContainer& container) { return container; }
+};
+
+// This specialization is used when RawContainer is a native array type.
+template <typename Element, size_t N>
+class StlContainerView<Element[N]> {
+ public:
+  typedef typename std::remove_const<Element>::type RawElement;
+  typedef internal::NativeArray<RawElement> type;
+  // NativeArray<T> can represent a native array either by value or by
+  // reference (selected by a constructor argument), so 'const type'
+  // can be used to reference a const native array.  We cannot
+  // 'typedef const type& const_reference' here, as that would mean
+  // ConstReference() has to return a reference to a local variable.
+  typedef const type const_reference;
+
+  static const_reference ConstReference(const Element (&array)[N]) {
+    static_assert(std::is_same<Element, RawElement>::value,
+                  "Element type must not be const");
+    return type(array, N, RelationToSourceReference());
+  }
+  static type Copy(const Element (&array)[N]) {
+    return type(array, N, RelationToSourceCopy());
+  }
+};
+
+// This specialization is used when RawContainer is a native array
+// represented as a (pointer, size) tuple.
+template <typename ElementPointer, typename Size>
+class StlContainerView< ::std::tuple<ElementPointer, Size> > {
+ public:
+  typedef typename std::remove_const<
+      typename std::pointer_traits<ElementPointer>::element_type>::type
+      RawElement;
+  typedef internal::NativeArray<RawElement> type;
+  typedef const type const_reference;
+
+  static const_reference ConstReference(
+      const ::std::tuple<ElementPointer, Size>& array) {
+    return type(std::get<0>(array), std::get<1>(array),
+                RelationToSourceReference());
+  }
+  static type Copy(const ::std::tuple<ElementPointer, Size>& array) {
+    return type(std::get<0>(array), std::get<1>(array), RelationToSourceCopy());
+  }
+};
+
+// The following specialization prevents the user from instantiating
+// StlContainer with a reference type.
+template <typename T> class StlContainerView<T&>;
+
+// A type transform to remove constness from the first part of a pair.
+// Pairs like that are used as the value_type of associative containers,
+// and this transform produces a similar but assignable pair.
+template <typename T>
+struct RemoveConstFromKey {
+  typedef T type;
+};
+
+// Partially specialized to remove constness from std::pair<const K, V>.
+template <typename K, typename V>
+struct RemoveConstFromKey<std::pair<const K, V> > {
+  typedef std::pair<K, V> type;
+};
+
+// Emit an assertion failure due to incorrect DoDefault() usage. Out-of-lined to
+// reduce code size.
+GTEST_API_ void IllegalDoDefault(const char* file, int line);
+
+template <typename F, typename Tuple, size_t... Idx>
+auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>) -> decltype(
+    std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...)) {
+  return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...);
+}
+
+// Apply the function to a tuple of arguments.
+template <typename F, typename Tuple>
+auto Apply(F&& f, Tuple&& args) -> decltype(
+    ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
+              MakeIndexSequence<std::tuple_size<
+                  typename std::remove_reference<Tuple>::type>::value>())) {
+  return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
+                   MakeIndexSequence<std::tuple_size<
+                       typename std::remove_reference<Tuple>::type>::value>());
+}
+
+// Template struct Function<F>, where F must be a function type, contains
+// the following typedefs:
+//
+//   Result:               the function's return type.
+//   Arg<N>:               the type of the N-th argument, where N starts with 0.
+//   ArgumentTuple:        the tuple type consisting of all parameters of F.
+//   ArgumentMatcherTuple: the tuple type consisting of Matchers for all
+//                         parameters of F.
+//   MakeResultVoid:       the function type obtained by substituting void
+//                         for the return type of F.
+//   MakeResultIgnoredValue:
+//                         the function type obtained by substituting Something
+//                         for the return type of F.
+template <typename T>
+struct Function;
+
+template <typename R, typename... Args>
+struct Function<R(Args...)> {
+  using Result = R;
+  static constexpr size_t ArgumentCount = sizeof...(Args);
+  template <size_t I>
+  using Arg = ElemFromList<I, Args...>;
+  using ArgumentTuple = std::tuple<Args...>;
+  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
+  using MakeResultVoid = void(Args...);
+  using MakeResultIgnoredValue = IgnoredValue(Args...);
+};
+
+template <typename R, typename... Args>
+constexpr size_t Function<R(Args...)>::ArgumentCount;
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
+
+// Expands and concatenates the arguments. Constructed macros reevaluate.
+#define GMOCK_PP_CAT(_1, _2) GMOCK_PP_INTERNAL_CAT(_1, _2)
+
+// Expands and stringifies the only argument.
+#define GMOCK_PP_STRINGIZE(...) GMOCK_PP_INTERNAL_STRINGIZE(__VA_ARGS__)
+
+// Returns empty. Given a variadic number of arguments.
+#define GMOCK_PP_EMPTY(...)
+
+// Returns a comma. Given a variadic number of arguments.
+#define GMOCK_PP_COMMA(...) ,
+
+// Returns the only argument.
+#define GMOCK_PP_IDENTITY(_1) _1
+
+// Evaluates to the number of arguments after expansion.
+//
+//   #define PAIR x, y
+//
+//   GMOCK_PP_NARG() => 1
+//   GMOCK_PP_NARG(x) => 1
+//   GMOCK_PP_NARG(x, y) => 2
+//   GMOCK_PP_NARG(PAIR) => 2
+//
+// Requires: the number of arguments after expansion is at most 15.
+#define GMOCK_PP_NARG(...) \
+  GMOCK_PP_INTERNAL_16TH(  \
+      (__VA_ARGS__, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
+
+// Returns 1 if the expansion of arguments has an unprotected comma. Otherwise
+// returns 0. Requires no more than 15 unprotected commas.
+#define GMOCK_PP_HAS_COMMA(...) \
+  GMOCK_PP_INTERNAL_16TH(       \
+      (__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0))
+
+// Returns the first argument.
+#define GMOCK_PP_HEAD(...) GMOCK_PP_INTERNAL_HEAD((__VA_ARGS__, unusedArg))
+
+// Returns the tail. A variadic list of all arguments minus the first. Requires
+// at least one argument.
+#define GMOCK_PP_TAIL(...) GMOCK_PP_INTERNAL_TAIL((__VA_ARGS__))
+
+// Calls CAT(_Macro, NARG(__VA_ARGS__))(__VA_ARGS__)
+#define GMOCK_PP_VARIADIC_CALL(_Macro, ...) \
+  GMOCK_PP_IDENTITY(                        \
+      GMOCK_PP_CAT(_Macro, GMOCK_PP_NARG(__VA_ARGS__))(__VA_ARGS__))
+
+// If the arguments after expansion have no tokens, evaluates to `1`. Otherwise
+// evaluates to `0`.
+//
+// Requires: * the number of arguments after expansion is at most 15.
+//           * If the argument is a macro, it must be able to be called with one
+//             argument.
+//
+// Implementation details:
+//
+// There is one case when it generates a compile error: if the argument is macro
+// that cannot be called with one argument.
+//
+//   #define M(a, b)  // it doesn't matter what it expands to
+//
+//   // Expected: expands to `0`.
+//   // Actual: compile error.
+//   GMOCK_PP_IS_EMPTY(M)
+//
+// There are 4 cases tested:
+//
+// * __VA_ARGS__ possible expansion has no unparen'd commas. Expected 0.
+// * __VA_ARGS__ possible expansion is not enclosed in parenthesis. Expected 0.
+// * __VA_ARGS__ possible expansion is not a macro that ()-evaluates to a comma.
+//   Expected 0
+// * __VA_ARGS__ is empty, or has unparen'd commas, or is enclosed in
+//   parenthesis, or is a macro that ()-evaluates to comma. Expected 1.
+//
+// We trigger detection on '0001', i.e. on empty.
+#define GMOCK_PP_IS_EMPTY(...)                                               \
+  GMOCK_PP_INTERNAL_IS_EMPTY(GMOCK_PP_HAS_COMMA(__VA_ARGS__),                \
+                             GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__), \
+                             GMOCK_PP_HAS_COMMA(__VA_ARGS__()),              \
+                             GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__()))
+
+// Evaluates to _Then if _Cond is 1 and _Else if _Cond is 0.
+#define GMOCK_PP_IF(_Cond, _Then, _Else) \
+  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IF_, _Cond)(_Then, _Else)
+
+// Similar to GMOCK_PP_IF but takes _Then and _Else in parentheses.
+//
+// GMOCK_PP_GENERIC_IF(1, (a, b, c), (d, e, f)) => a, b, c
+// GMOCK_PP_GENERIC_IF(0, (a, b, c), (d, e, f)) => d, e, f
+//
+#define GMOCK_PP_GENERIC_IF(_Cond, _Then, _Else) \
+  GMOCK_PP_REMOVE_PARENS(GMOCK_PP_IF(_Cond, _Then, _Else))
+
+// Evaluates to the number of arguments after expansion. Identifies 'empty' as
+// 0.
+//
+//   #define PAIR x, y
+//
+//   GMOCK_PP_NARG0() => 0
+//   GMOCK_PP_NARG0(x) => 1
+//   GMOCK_PP_NARG0(x, y) => 2
+//   GMOCK_PP_NARG0(PAIR) => 2
+//
+// Requires: * the number of arguments after expansion is at most 15.
+//           * If the argument is a macro, it must be able to be called with one
+//             argument.
+#define GMOCK_PP_NARG0(...) \
+  GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(__VA_ARGS__), 0, GMOCK_PP_NARG(__VA_ARGS__))
+
+// Expands to 1 if the first argument starts with something in parentheses,
+// otherwise to 0.
+#define GMOCK_PP_IS_BEGIN_PARENS(...)                              \
+  GMOCK_PP_HEAD(GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_, \
+                             GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C __VA_ARGS__))
+
+// Expands to 1 is there is only one argument and it is enclosed in parentheses.
+#define GMOCK_PP_IS_ENCLOSED_PARENS(...)             \
+  GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(__VA_ARGS__), \
+              GMOCK_PP_IS_EMPTY(GMOCK_PP_EMPTY __VA_ARGS__), 0)
+
+// Remove the parens, requires GMOCK_PP_IS_ENCLOSED_PARENS(args) => 1.
+#define GMOCK_PP_REMOVE_PARENS(...) GMOCK_PP_INTERNAL_REMOVE_PARENS __VA_ARGS__
+
+// Expands to _Macro(0, _Data, e1) _Macro(1, _Data, e2) ... _Macro(K -1, _Data,
+// eK) as many of GMOCK_INTERNAL_NARG0 _Tuple.
+// Requires: * |_Macro| can be called with 3 arguments.
+//           * |_Tuple| expansion has no more than 15 elements.
+#define GMOCK_PP_FOR_EACH(_Macro, _Data, _Tuple)                        \
+  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, GMOCK_PP_NARG0 _Tuple) \
+  (0, _Macro, _Data, _Tuple)
+
+// Expands to _Macro(0, _Data, ) _Macro(1, _Data, ) ... _Macro(K - 1, _Data, )
+// Empty if _K = 0.
+// Requires: * |_Macro| can be called with 3 arguments.
+//           * |_K| literal between 0 and 15
+#define GMOCK_PP_REPEAT(_Macro, _Data, _N)           \
+  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, _N) \
+  (0, _Macro, _Data, GMOCK_PP_INTENRAL_EMPTY_TUPLE)
+
+// Increments the argument, requires the argument to be between 0 and 15.
+#define GMOCK_PP_INC(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_INC_, _i)
+
+// Returns comma if _i != 0. Requires _i to be between 0 and 15.
+#define GMOCK_PP_COMMA_IF(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_COMMA_IF_, _i)
+
+// Internal details follow. Do not use any of these symbols outside of this
+// file or we will break your code.
+#define GMOCK_PP_INTENRAL_EMPTY_TUPLE (, , , , , , , , , , , , , , , )
+#define GMOCK_PP_INTERNAL_CAT(_1, _2) _1##_2
+#define GMOCK_PP_INTERNAL_STRINGIZE(...) #__VA_ARGS__
+#define GMOCK_PP_INTERNAL_CAT_5(_1, _2, _3, _4, _5) _1##_2##_3##_4##_5
+#define GMOCK_PP_INTERNAL_IS_EMPTY(_1, _2, _3, _4)                             \
+  GMOCK_PP_HAS_COMMA(GMOCK_PP_INTERNAL_CAT_5(GMOCK_PP_INTERNAL_IS_EMPTY_CASE_, \
+                                             _1, _2, _3, _4))
+#define GMOCK_PP_INTERNAL_IS_EMPTY_CASE_0001 ,
+#define GMOCK_PP_INTERNAL_IF_1(_Then, _Else) _Then
+#define GMOCK_PP_INTERNAL_IF_0(_Then, _Else) _Else
+
+// Because of MSVC treating a token with a comma in it as a single token when
+// passed to another macro, we need to force it to evaluate it as multiple
+// tokens. We do that by using a "IDENTITY(MACRO PARENTHESIZED_ARGS)" macro. We
+// define one per possible macro that relies on this behavior. Note "_Args" must
+// be parenthesized.
+#define GMOCK_PP_INTERNAL_INTERNAL_16TH(_1, _2, _3, _4, _5, _6, _7, _8, _9, \
+                                        _10, _11, _12, _13, _14, _15, _16,  \
+                                        ...)                                \
+  _16
+#define GMOCK_PP_INTERNAL_16TH(_Args) \
+  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_16TH _Args)
+#define GMOCK_PP_INTERNAL_INTERNAL_HEAD(_1, ...) _1
+#define GMOCK_PP_INTERNAL_HEAD(_Args) \
+  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_HEAD _Args)
+#define GMOCK_PP_INTERNAL_INTERNAL_TAIL(_1, ...) __VA_ARGS__
+#define GMOCK_PP_INTERNAL_TAIL(_Args) \
+  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_TAIL _Args)
+
+#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C(...) 1 _
+#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_1 1,
+#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C \
+  0,
+#define GMOCK_PP_INTERNAL_REMOVE_PARENS(...) __VA_ARGS__
+#define GMOCK_PP_INTERNAL_INC_0 1
+#define GMOCK_PP_INTERNAL_INC_1 2
+#define GMOCK_PP_INTERNAL_INC_2 3
+#define GMOCK_PP_INTERNAL_INC_3 4
+#define GMOCK_PP_INTERNAL_INC_4 5
+#define GMOCK_PP_INTERNAL_INC_5 6
+#define GMOCK_PP_INTERNAL_INC_6 7
+#define GMOCK_PP_INTERNAL_INC_7 8
+#define GMOCK_PP_INTERNAL_INC_8 9
+#define GMOCK_PP_INTERNAL_INC_9 10
+#define GMOCK_PP_INTERNAL_INC_10 11
+#define GMOCK_PP_INTERNAL_INC_11 12
+#define GMOCK_PP_INTERNAL_INC_12 13
+#define GMOCK_PP_INTERNAL_INC_13 14
+#define GMOCK_PP_INTERNAL_INC_14 15
+#define GMOCK_PP_INTERNAL_INC_15 16
+#define GMOCK_PP_INTERNAL_COMMA_IF_0
+#define GMOCK_PP_INTERNAL_COMMA_IF_1 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_2 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_3 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_4 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_5 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_6 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_7 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_8 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_9 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_10 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_11 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_12 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_13 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_14 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_15 ,
+#define GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, _element) \
+  _Macro(_i, _Data, _element)
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_0(_i, _Macro, _Data, _Tuple)
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(_i, _Macro, _Data, _Tuple) \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple)
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_15(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+namespace testing {
+
+// To implement an action Foo, define:
+//   1. a class FooAction that implements the ActionInterface interface, and
+//   2. a factory function that creates an Action object from a
+//      const FooAction*.
+//
+// The two-level delegation design follows that of Matcher, providing
+// consistency for extension developers.  It also eases ownership
+// management as Action objects can now be copied like plain values.
+
+namespace internal {
+
+// BuiltInDefaultValueGetter<T, true>::Get() returns a
+// default-constructed T value.  BuiltInDefaultValueGetter<T,
+// false>::Get() crashes with an error.
+//
+// This primary template is used when kDefaultConstructible is true.
+template <typename T, bool kDefaultConstructible>
+struct BuiltInDefaultValueGetter {
+  static T Get() { return T(); }
+};
+template <typename T>
+struct BuiltInDefaultValueGetter<T, false> {
+  static T Get() {
+    Assert(false, __FILE__, __LINE__,
+           "Default action undefined for the function return type.");
+    return internal::Invalid<T>();
+    // The above statement will never be reached, but is required in
+    // order for this function to compile.
+  }
+};
+
+// BuiltInDefaultValue<T>::Get() returns the "built-in" default value
+// for type T, which is NULL when T is a raw pointer type, 0 when T is
+// a numeric type, false when T is bool, or "" when T is string or
+// std::string.  In addition, in C++11 and above, it turns a
+// default-constructed T value if T is default constructible.  For any
+// other type T, the built-in default T value is undefined, and the
+// function will abort the process.
+template <typename T>
+class BuiltInDefaultValue {
+ public:
+  // This function returns true if and only if type T has a built-in default
+  // value.
+  static bool Exists() {
+    return ::std::is_default_constructible<T>::value;
+  }
+
+  static T Get() {
+    return BuiltInDefaultValueGetter<
+        T, ::std::is_default_constructible<T>::value>::Get();
+  }
+};
+
+// This partial specialization says that we use the same built-in
+// default value for T and const T.
+template <typename T>
+class BuiltInDefaultValue<const T> {
+ public:
+  static bool Exists() { return BuiltInDefaultValue<T>::Exists(); }
+  static T Get() { return BuiltInDefaultValue<T>::Get(); }
+};
+
+// This partial specialization defines the default values for pointer
+// types.
+template <typename T>
+class BuiltInDefaultValue<T*> {
+ public:
+  static bool Exists() { return true; }
+  static T* Get() { return nullptr; }
+};
+
+// The following specializations define the default values for
+// specific types we care about.
+#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
+  template <> \
+  class BuiltInDefaultValue<type> { \
+   public: \
+    static bool Exists() { return true; } \
+    static type Get() { return value; } \
+  }
+
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, );  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, "");
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0');
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0');
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0');
+
+// There's no need for a default action for signed wchar_t, as that
+// type is the same as wchar_t for gcc, and invalid for MSVC.
+//
+// There's also no need for a default action for unsigned wchar_t, as
+// that type is the same as unsigned int for gcc, and invalid for
+// MSVC.
+#if GMOCK_WCHAR_T_IS_NATIVE_
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U);  // NOLINT
+#endif
+
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0);     // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L);     // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0);
+
+#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_
+
+// Simple two-arg form of std::disjunction.
+template <typename P, typename Q>
+using disjunction = typename ::std::conditional<P::value, P, Q>::type;
+
+}  // namespace internal
+
+// When an unexpected function call is encountered, Google Mock will
+// let it return a default value if the user has specified one for its
+// return type, or if the return type has a built-in default value;
+// otherwise Google Mock won't know what value to return and will have
+// to abort the process.
+//
+// The DefaultValue<T> class allows a user to specify the
+// default value for a type T that is both copyable and publicly
+// destructible (i.e. anything that can be used as a function return
+// type).  The usage is:
+//
+//   // Sets the default value for type T to be foo.
+//   DefaultValue<T>::Set(foo);
+template <typename T>
+class DefaultValue {
+ public:
+  // Sets the default value for type T; requires T to be
+  // copy-constructable and have a public destructor.
+  static void Set(T x) {
+    delete producer_;
+    producer_ = new FixedValueProducer(x);
+  }
+
+  // Provides a factory function to be called to generate the default value.
+  // This method can be used even if T is only move-constructible, but it is not
+  // limited to that case.
+  typedef T (*FactoryFunction)();
+  static void SetFactory(FactoryFunction factory) {
+    delete producer_;
+    producer_ = new FactoryValueProducer(factory);
+  }
+
+  // Unsets the default value for type T.
+  static void Clear() {
+    delete producer_;
+    producer_ = nullptr;
+  }
+
+  // Returns true if and only if the user has set the default value for type T.
+  static bool IsSet() { return producer_ != nullptr; }
+
+  // Returns true if T has a default return value set by the user or there
+  // exists a built-in default value.
+  static bool Exists() {
+    return IsSet() || internal::BuiltInDefaultValue<T>::Exists();
+  }
+
+  // Returns the default value for type T if the user has set one;
+  // otherwise returns the built-in default value. Requires that Exists()
+  // is true, which ensures that the return value is well-defined.
+  static T Get() {
+    return producer_ == nullptr ? internal::BuiltInDefaultValue<T>::Get()
+                                : producer_->Produce();
+  }
+
+ private:
+  class ValueProducer {
+   public:
+    virtual ~ValueProducer() {}
+    virtual T Produce() = 0;
+  };
+
+  class FixedValueProducer : public ValueProducer {
+   public:
+    explicit FixedValueProducer(T value) : value_(value) {}
+    T Produce() override { return value_; }
+
+   private:
+    const T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer);
+  };
+
+  class FactoryValueProducer : public ValueProducer {
+   public:
+    explicit FactoryValueProducer(FactoryFunction factory)
+        : factory_(factory) {}
+    T Produce() override { return factory_(); }
+
+   private:
+    const FactoryFunction factory_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer);
+  };
+
+  static ValueProducer* producer_;
+};
+
+// This partial specialization allows a user to set default values for
+// reference types.
+template <typename T>
+class DefaultValue<T&> {
+ public:
+  // Sets the default value for type T&.
+  static void Set(T& x) {  // NOLINT
+    address_ = &x;
+  }
+
+  // Unsets the default value for type T&.
+  static void Clear() { address_ = nullptr; }
+
+  // Returns true if and only if the user has set the default value for type T&.
+  static bool IsSet() { return address_ != nullptr; }
+
+  // Returns true if T has a default return value set by the user or there
+  // exists a built-in default value.
+  static bool Exists() {
+    return IsSet() || internal::BuiltInDefaultValue<T&>::Exists();
+  }
+
+  // Returns the default value for type T& if the user has set one;
+  // otherwise returns the built-in default value if there is one;
+  // otherwise aborts the process.
+  static T& Get() {
+    return address_ == nullptr ? internal::BuiltInDefaultValue<T&>::Get()
+                               : *address_;
+  }
+
+ private:
+  static T* address_;
+};
+
+// This specialization allows DefaultValue<void>::Get() to
+// compile.
+template <>
+class DefaultValue<void> {
+ public:
+  static bool Exists() { return true; }
+  static void Get() {}
+};
+
+// Points to the user-set default value for type T.
+template <typename T>
+typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = nullptr;
+
+// Points to the user-set default value for type T&.
+template <typename T>
+T* DefaultValue<T&>::address_ = nullptr;
+
+// Implement this interface to define an action for function type F.
+template <typename F>
+class ActionInterface {
+ public:
+  typedef typename internal::Function<F>::Result Result;
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  ActionInterface() {}
+  virtual ~ActionInterface() {}
+
+  // Performs the action.  This method is not const, as in general an
+  // action can have side effects and be stateful.  For example, a
+  // get-the-next-element-from-the-collection action will need to
+  // remember the current element.
+  virtual Result Perform(const ArgumentTuple& args) = 0;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface);
+};
+
+// An Action<F> is a copyable and IMMUTABLE (except by assignment)
+// object that represents an action to be taken when a mock function
+// of type F is called.  The implementation of Action<T> is just a
+// std::shared_ptr to const ActionInterface<T>. Don't inherit from Action!
+// You can view an object implementing ActionInterface<F> as a
+// concrete action (including its current state), and an Action<F>
+// object as a handle to it.
+template <typename F>
+class Action {
+  // Adapter class to allow constructing Action from a legacy ActionInterface.
+  // New code should create Actions from functors instead.
+  struct ActionAdapter {
+    // Adapter must be copyable to satisfy std::function requirements.
+    ::std::shared_ptr<ActionInterface<F>> impl_;
+
+    template <typename... Args>
+    typename internal::Function<F>::Result operator()(Args&&... args) {
+      return impl_->Perform(
+          ::std::forward_as_tuple(::std::forward<Args>(args)...));
+    }
+  };
+
+  template <typename G>
+  using IsCompatibleFunctor = std::is_constructible<std::function<F>, G>;
+
+ public:
+  typedef typename internal::Function<F>::Result Result;
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  // Constructs a null Action.  Needed for storing Action objects in
+  // STL containers.
+  Action() {}
+
+  // Construct an Action from a specified callable.
+  // This cannot take std::function directly, because then Action would not be
+  // directly constructible from lambda (it would require two conversions).
+  template <
+      typename G,
+      typename = typename std::enable_if<internal::disjunction<
+          IsCompatibleFunctor<G>, std::is_constructible<std::function<Result()>,
+                                                        G>>::value>::type>
+  Action(G&& fun) {  // NOLINT
+    Init(::std::forward<G>(fun), IsCompatibleFunctor<G>());
+  }
+
+  // Constructs an Action from its implementation.
+  explicit Action(ActionInterface<F>* impl)
+      : fun_(ActionAdapter{::std::shared_ptr<ActionInterface<F>>(impl)}) {}
+
+  // This constructor allows us to turn an Action<Func> object into an
+  // Action<F>, as long as F's arguments can be implicitly converted
+  // to Func's and Func's return type can be implicitly converted to F's.
+  template <typename Func>
+  explicit Action(const Action<Func>& action) : fun_(action.fun_) {}
+
+  // Returns true if and only if this is the DoDefault() action.
+  bool IsDoDefault() const { return fun_ == nullptr; }
+
+  // Performs the action.  Note that this method is const even though
+  // the corresponding method in ActionInterface is not.  The reason
+  // is that a const Action<F> means that it cannot be re-bound to
+  // another concrete action, not that the concrete action it binds to
+  // cannot change state.  (Think of the difference between a const
+  // pointer and a pointer to const.)
+  Result Perform(ArgumentTuple args) const {
+    if (IsDoDefault()) {
+      internal::IllegalDoDefault(__FILE__, __LINE__);
+    }
+    return internal::Apply(fun_, ::std::move(args));
+  }
+
+ private:
+  template <typename G>
+  friend class Action;
+
+  template <typename G>
+  void Init(G&& g, ::std::true_type) {
+    fun_ = ::std::forward<G>(g);
+  }
+
+  template <typename G>
+  void Init(G&& g, ::std::false_type) {
+    fun_ = IgnoreArgs<typename ::std::decay<G>::type>{::std::forward<G>(g)};
+  }
+
+  template <typename FunctionImpl>
+  struct IgnoreArgs {
+    template <typename... Args>
+    Result operator()(const Args&...) const {
+      return function_impl();
+    }
+
+    FunctionImpl function_impl;
+  };
+
+  // fun_ is an empty function if and only if this is the DoDefault() action.
+  ::std::function<F> fun_;
+};
+
+// The PolymorphicAction class template makes it easy to implement a
+// polymorphic action (i.e. an action that can be used in mock
+// functions of than one type, e.g. Return()).
+//
+// To define a polymorphic action, a user first provides a COPYABLE
+// implementation class that has a Perform() method template:
+//
+//   class FooAction {
+//    public:
+//     template <typename Result, typename ArgumentTuple>
+//     Result Perform(const ArgumentTuple& args) const {
+//       // Processes the arguments and returns a result, using
+//       // std::get<N>(args) to get the N-th (0-based) argument in the tuple.
+//     }
+//     ...
+//   };
+//
+// Then the user creates the polymorphic action using
+// MakePolymorphicAction(object) where object has type FooAction.  See
+// the definition of Return(void) and SetArgumentPointee<N>(value) for
+// complete examples.
+template <typename Impl>
+class PolymorphicAction {
+ public:
+  explicit PolymorphicAction(const Impl& impl) : impl_(impl) {}
+
+  template <typename F>
+  operator Action<F>() const {
+    return Action<F>(new MonomorphicImpl<F>(impl_));
+  }
+
+ private:
+  template <typename F>
+  class MonomorphicImpl : public ActionInterface<F> {
+   public:
+    typedef typename internal::Function<F>::Result Result;
+    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
+
+    Result Perform(const ArgumentTuple& args) override {
+      return impl_.template Perform<Result>(args);
+    }
+
+   private:
+    Impl impl_;
+  };
+
+  Impl impl_;
+};
+
+// Creates an Action from its implementation and returns it.  The
+// created Action object owns the implementation.
+template <typename F>
+Action<F> MakeAction(ActionInterface<F>* impl) {
+  return Action<F>(impl);
+}
+
+// Creates a polymorphic action from its implementation.  This is
+// easier to use than the PolymorphicAction<Impl> constructor as it
+// doesn't require you to explicitly write the template argument, e.g.
+//
+//   MakePolymorphicAction(foo);
+// vs
+//   PolymorphicAction<TypeOfFoo>(foo);
+template <typename Impl>
+inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) {
+  return PolymorphicAction<Impl>(impl);
+}
+
+namespace internal {
+
+// Helper struct to specialize ReturnAction to execute a move instead of a copy
+// on return. Useful for move-only types, but could be used on any type.
+template <typename T>
+struct ByMoveWrapper {
+  explicit ByMoveWrapper(T value) : payload(std::move(value)) {}
+  T payload;
+};
+
+// Implements the polymorphic Return(x) action, which can be used in
+// any function that returns the type of x, regardless of the argument
+// types.
+//
+// Note: The value passed into Return must be converted into
+// Function<F>::Result when this action is cast to Action<F> rather than
+// when that action is performed. This is important in scenarios like
+//
+// MOCK_METHOD1(Method, T(U));
+// ...
+// {
+//   Foo foo;
+//   X x(&foo);
+//   EXPECT_CALL(mock, Method(_)).WillOnce(Return(x));
+// }
+//
+// In the example above the variable x holds reference to foo which leaves
+// scope and gets destroyed.  If copying X just copies a reference to foo,
+// that copy will be left with a hanging reference.  If conversion to T
+// makes a copy of foo, the above code is safe. To support that scenario, we
+// need to make sure that the type conversion happens inside the EXPECT_CALL
+// statement, and conversion of the result of Return to Action<T(U)> is a
+// good place for that.
+//
+// The real life example of the above scenario happens when an invocation
+// of gtl::Container() is passed into Return.
+//
+template <typename R>
+class ReturnAction {
+ public:
+  // Constructs a ReturnAction object from the value to be returned.
+  // 'value' is passed by value instead of by const reference in order
+  // to allow Return("string literal") to compile.
+  explicit ReturnAction(R value) : value_(new R(std::move(value))) {}
+
+  // This template type conversion operator allows Return(x) to be
+  // used in ANY function that returns x's type.
+  template <typename F>
+  operator Action<F>() const {  // NOLINT
+    // Assert statement belongs here because this is the best place to verify
+    // conditions on F. It produces the clearest error messages
+    // in most compilers.
+    // Impl really belongs in this scope as a local class but can't
+    // because MSVC produces duplicate symbols in different translation units
+    // in this case. Until MS fixes that bug we put Impl into the class scope
+    // and put the typedef both here (for use in assert statement) and
+    // in the Impl class. But both definitions must be the same.
+    typedef typename Function<F>::Result Result;
+    GTEST_COMPILE_ASSERT_(
+        !std::is_reference<Result>::value,
+        use_ReturnRef_instead_of_Return_to_return_a_reference);
+    static_assert(!std::is_void<Result>::value,
+                  "Can't use Return() on an action expected to return `void`.");
+    return Action<F>(new Impl<R, F>(value_));
+  }
+
+ private:
+  // Implements the Return(x) action for a particular function type F.
+  template <typename R_, typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    // The implicit cast is necessary when Result has more than one
+    // single-argument constructor (e.g. Result is std::vector<int>) and R
+    // has a type conversion operator template.  In that case, value_(value)
+    // won't compile as the compiler doesn't known which constructor of
+    // Result to call.  ImplicitCast_ forces the compiler to convert R to
+    // Result without considering explicit constructors, thus resolving the
+    // ambiguity. value_ is then initialized using its copy constructor.
+    explicit Impl(const std::shared_ptr<R>& value)
+        : value_before_cast_(*value),
+          value_(ImplicitCast_<Result>(value_before_cast_)) {}
+
+    Result Perform(const ArgumentTuple&) override { return value_; }
+
+   private:
+    GTEST_COMPILE_ASSERT_(!std::is_reference<Result>::value,
+                          Result_cannot_be_a_reference_type);
+    // We save the value before casting just in case it is being cast to a
+    // wrapper type.
+    R value_before_cast_;
+    Result value_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
+  };
+
+  // Partially specialize for ByMoveWrapper. This version of ReturnAction will
+  // move its contents instead.
+  template <typename R_, typename F>
+  class Impl<ByMoveWrapper<R_>, F> : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const std::shared_ptr<R>& wrapper)
+        : performed_(false), wrapper_(wrapper) {}
+
+    Result Perform(const ArgumentTuple&) override {
+      GTEST_CHECK_(!performed_)
+          << "A ByMove() action should only be performed once.";
+      performed_ = true;
+      return std::move(wrapper_->payload);
+    }
+
+   private:
+    bool performed_;
+    const std::shared_ptr<R> wrapper_;
+  };
+
+  const std::shared_ptr<R> value_;
+};
+
+// Implements the ReturnNull() action.
+class ReturnNullAction {
+ public:
+  // Allows ReturnNull() to be used in any pointer-returning function. In C++11
+  // this is enforced by returning nullptr, and in non-C++11 by asserting a
+  // pointer type on compile time.
+  template <typename Result, typename ArgumentTuple>
+  static Result Perform(const ArgumentTuple&) {
+    return nullptr;
+  }
+};
+
+// Implements the Return() action.
+class ReturnVoidAction {
+ public:
+  // Allows Return() to be used in any void-returning function.
+  template <typename Result, typename ArgumentTuple>
+  static void Perform(const ArgumentTuple&) {
+    static_assert(std::is_void<Result>::value, "Result should be void.");
+  }
+};
+
+// Implements the polymorphic ReturnRef(x) action, which can be used
+// in any function that returns a reference to the type of x,
+// regardless of the argument types.
+template <typename T>
+class ReturnRefAction {
+ public:
+  // Constructs a ReturnRefAction object from the reference to be returned.
+  explicit ReturnRefAction(T& ref) : ref_(ref) {}  // NOLINT
+
+  // This template type conversion operator allows ReturnRef(x) to be
+  // used in ANY function that returns a reference to x's type.
+  template <typename F>
+  operator Action<F>() const {
+    typedef typename Function<F>::Result Result;
+    // Asserts that the function return type is a reference.  This
+    // catches the user error of using ReturnRef(x) when Return(x)
+    // should be used, and generates some helpful error message.
+    GTEST_COMPILE_ASSERT_(std::is_reference<Result>::value,
+                          use_Return_instead_of_ReturnRef_to_return_a_value);
+    return Action<F>(new Impl<F>(ref_));
+  }
+
+ private:
+  // Implements the ReturnRef(x) action for a particular function type F.
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(T& ref) : ref_(ref) {}  // NOLINT
+
+    Result Perform(const ArgumentTuple&) override { return ref_; }
+
+   private:
+    T& ref_;
+  };
+
+  T& ref_;
+};
+
+// Implements the polymorphic ReturnRefOfCopy(x) action, which can be
+// used in any function that returns a reference to the type of x,
+// regardless of the argument types.
+template <typename T>
+class ReturnRefOfCopyAction {
+ public:
+  // Constructs a ReturnRefOfCopyAction object from the reference to
+  // be returned.
+  explicit ReturnRefOfCopyAction(const T& value) : value_(value) {}  // NOLINT
+
+  // This template type conversion operator allows ReturnRefOfCopy(x) to be
+  // used in ANY function that returns a reference to x's type.
+  template <typename F>
+  operator Action<F>() const {
+    typedef typename Function<F>::Result Result;
+    // Asserts that the function return type is a reference.  This
+    // catches the user error of using ReturnRefOfCopy(x) when Return(x)
+    // should be used, and generates some helpful error message.
+    GTEST_COMPILE_ASSERT_(
+        std::is_reference<Result>::value,
+        use_Return_instead_of_ReturnRefOfCopy_to_return_a_value);
+    return Action<F>(new Impl<F>(value_));
+  }
+
+ private:
+  // Implements the ReturnRefOfCopy(x) action for a particular function type F.
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const T& value) : value_(value) {}  // NOLINT
+
+    Result Perform(const ArgumentTuple&) override { return value_; }
+
+   private:
+    T value_;
+  };
+
+  const T value_;
+};
+
+// Implements the polymorphic ReturnRoundRobin(v) action, which can be
+// used in any function that returns the element_type of v.
+template <typename T>
+class ReturnRoundRobinAction {
+ public:
+  explicit ReturnRoundRobinAction(std::vector<T> values) {
+    GTEST_CHECK_(!values.empty())
+        << "ReturnRoundRobin requires at least one element.";
+    state_->values = std::move(values);
+  }
+
+  template <typename... Args>
+  T operator()(Args&&...) const {
+     return state_->Next();
+  }
+
+ private:
+  struct State {
+    T Next() {
+      T ret_val = values[i++];
+      if (i == values.size()) i = 0;
+      return ret_val;
+    }
+
+    std::vector<T> values;
+    size_t i = 0;
+  };
+  std::shared_ptr<State> state_ = std::make_shared<State>();
+};
+
+// Implements the polymorphic DoDefault() action.
+class DoDefaultAction {
+ public:
+  // This template type conversion operator allows DoDefault() to be
+  // used in any function.
+  template <typename F>
+  operator Action<F>() const { return Action<F>(); }  // NOLINT
+};
+
+// Implements the Assign action to set a given pointer referent to a
+// particular value.
+template <typename T1, typename T2>
+class AssignAction {
+ public:
+  AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}
+
+  template <typename Result, typename ArgumentTuple>
+  void Perform(const ArgumentTuple& /* args */) const {
+    *ptr_ = value_;
+  }
+
+ private:
+  T1* const ptr_;
+  const T2 value_;
+};
+
+#if !GTEST_OS_WINDOWS_MOBILE
+
+// Implements the SetErrnoAndReturn action to simulate return from
+// various system calls and libc functions.
+template <typename T>
+class SetErrnoAndReturnAction {
+ public:
+  SetErrnoAndReturnAction(int errno_value, T result)
+      : errno_(errno_value),
+        result_(result) {}
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& /* args */) const {
+    errno = errno_;
+    return result_;
+  }
+
+ private:
+  const int errno_;
+  const T result_;
+};
+
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Implements the SetArgumentPointee<N>(x) action for any function
+// whose N-th argument (0-based) is a pointer to x's type.
+template <size_t N, typename A, typename = void>
+struct SetArgumentPointeeAction {
+  A value;
+
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    *::std::get<N>(std::tie(args...)) = value;
+  }
+};
+
+// Implements the Invoke(object_ptr, &Class::Method) action.
+template <class Class, typename MethodPtr>
+struct InvokeMethodAction {
+  Class* const obj_ptr;
+  const MethodPtr method_ptr;
+
+  template <typename... Args>
+  auto operator()(Args&&... args) const
+      -> decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) {
+    return (obj_ptr->*method_ptr)(std::forward<Args>(args)...);
+  }
+};
+
+// Implements the InvokeWithoutArgs(f) action.  The template argument
+// FunctionImpl is the implementation type of f, which can be either a
+// function pointer or a functor.  InvokeWithoutArgs(f) can be used as an
+// Action<F> as long as f's type is compatible with F.
+template <typename FunctionImpl>
+struct InvokeWithoutArgsAction {
+  FunctionImpl function_impl;
+
+  // Allows InvokeWithoutArgs(f) to be used as any action whose type is
+  // compatible with f.
+  template <typename... Args>
+  auto operator()(const Args&...) -> decltype(function_impl()) {
+    return function_impl();
+  }
+};
+
+// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
+template <class Class, typename MethodPtr>
+struct InvokeMethodWithoutArgsAction {
+  Class* const obj_ptr;
+  const MethodPtr method_ptr;
+
+  using ReturnType =
+      decltype((std::declval<Class*>()->*std::declval<MethodPtr>())());
+
+  template <typename... Args>
+  ReturnType operator()(const Args&...) const {
+    return (obj_ptr->*method_ptr)();
+  }
+};
+
+// Implements the IgnoreResult(action) action.
+template <typename A>
+class IgnoreResultAction {
+ public:
+  explicit IgnoreResultAction(const A& action) : action_(action) {}
+
+  template <typename F>
+  operator Action<F>() const {
+    // Assert statement belongs here because this is the best place to verify
+    // conditions on F. It produces the clearest error messages
+    // in most compilers.
+    // Impl really belongs in this scope as a local class but can't
+    // because MSVC produces duplicate symbols in different translation units
+    // in this case. Until MS fixes that bug we put Impl into the class scope
+    // and put the typedef both here (for use in assert statement) and
+    // in the Impl class. But both definitions must be the same.
+    typedef typename internal::Function<F>::Result Result;
+
+    // Asserts at compile time that F returns void.
+    static_assert(std::is_void<Result>::value, "Result type should be void.");
+
+    return Action<F>(new Impl<F>(action_));
+  }
+
+ private:
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename internal::Function<F>::Result Result;
+    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const A& action) : action_(action) {}
+
+    void Perform(const ArgumentTuple& args) override {
+      // Performs the action and ignores its result.
+      action_.Perform(args);
+    }
+
+   private:
+    // Type OriginalFunction is the same as F except that its return
+    // type is IgnoredValue.
+    typedef typename internal::Function<F>::MakeResultIgnoredValue
+        OriginalFunction;
+
+    const Action<OriginalFunction> action_;
+  };
+
+  const A action_;
+};
+
+template <typename InnerAction, size_t... I>
+struct WithArgsAction {
+  InnerAction action;
+
+  // The inner action could be anything convertible to Action<X>.
+  // We use the conversion operator to detect the signature of the inner Action.
+  template <typename R, typename... Args>
+  operator Action<R(Args...)>() const {  // NOLINT
+    using TupleType = std::tuple<Args...>;
+    Action<R(typename std::tuple_element<I, TupleType>::type...)>
+        converted(action);
+
+    return [converted](Args... args) -> R {
+      return converted.Perform(std::forward_as_tuple(
+        std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...));
+    };
+  }
+};
+
+template <typename... Actions>
+struct DoAllAction {
+ private:
+  template <typename T>
+  using NonFinalType =
+      typename std::conditional<std::is_scalar<T>::value, T, const T&>::type;
+
+  template <typename ActionT, size_t... I>
+  std::vector<ActionT> Convert(IndexSequence<I...>) const {
+    return {ActionT(std::get<I>(actions))...};
+  }
+
+ public:
+  std::tuple<Actions...> actions;
+
+  template <typename R, typename... Args>
+  operator Action<R(Args...)>() const {  // NOLINT
+    struct Op {
+      std::vector<Action<void(NonFinalType<Args>...)>> converted;
+      Action<R(Args...)> last;
+      R operator()(Args... args) const {
+        auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...);
+        for (auto& a : converted) {
+          a.Perform(tuple_args);
+        }
+        return last.Perform(std::move(tuple_args));
+      }
+    };
+    return Op{Convert<Action<void(NonFinalType<Args>...)>>(
+                  MakeIndexSequence<sizeof...(Actions) - 1>()),
+              std::get<sizeof...(Actions) - 1>(actions)};
+  }
+};
+
+template <typename T, typename... Params>
+struct ReturnNewAction {
+  T* operator()() const {
+    return internal::Apply(
+        [](const Params&... unpacked_params) {
+          return new T(unpacked_params...);
+        },
+        params);
+  }
+  std::tuple<Params...> params;
+};
+
+template <size_t k>
+struct ReturnArgAction {
+  template <typename... Args>
+  auto operator()(const Args&... args) const ->
+      typename std::tuple_element<k, std::tuple<Args...>>::type {
+    return std::get<k>(std::tie(args...));
+  }
+};
+
+template <size_t k, typename Ptr>
+struct SaveArgAction {
+  Ptr pointer;
+
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    *pointer = std::get<k>(std::tie(args...));
+  }
+};
+
+template <size_t k, typename Ptr>
+struct SaveArgPointeeAction {
+  Ptr pointer;
+
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    *pointer = *std::get<k>(std::tie(args...));
+  }
+};
+
+template <size_t k, typename T>
+struct SetArgRefereeAction {
+  T value;
+
+  template <typename... Args>
+  void operator()(Args&&... args) const {
+    using argk_type =
+        typename ::std::tuple_element<k, std::tuple<Args...>>::type;
+    static_assert(std::is_lvalue_reference<argk_type>::value,
+                  "Argument must be a reference type.");
+    std::get<k>(std::tie(args...)) = value;
+  }
+};
+
+template <size_t k, typename I1, typename I2>
+struct SetArrayArgumentAction {
+  I1 first;
+  I2 last;
+
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    auto value = std::get<k>(std::tie(args...));
+    for (auto it = first; it != last; ++it, (void)++value) {
+      *value = *it;
+    }
+  }
+};
+
+template <size_t k>
+struct DeleteArgAction {
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    delete std::get<k>(std::tie(args...));
+  }
+};
+
+template <typename Ptr>
+struct ReturnPointeeAction {
+  Ptr pointer;
+  template <typename... Args>
+  auto operator()(const Args&...) const -> decltype(*pointer) {
+    return *pointer;
+  }
+};
+
+#if GTEST_HAS_EXCEPTIONS
+template <typename T>
+struct ThrowAction {
+  T exception;
+  // We use a conversion operator to adapt to any return type.
+  template <typename R, typename... Args>
+  operator Action<R(Args...)>() const {  // NOLINT
+    T copy = exception;
+    return [copy](Args...) -> R { throw copy; };
+  }
+};
+#endif  // GTEST_HAS_EXCEPTIONS
+
+}  // namespace internal
+
+// An Unused object can be implicitly constructed from ANY value.
+// This is handy when defining actions that ignore some or all of the
+// mock function arguments.  For example, given
+//
+//   MOCK_METHOD3(Foo, double(const string& label, double x, double y));
+//   MOCK_METHOD3(Bar, double(int index, double x, double y));
+//
+// instead of
+//
+//   double DistanceToOriginWithLabel(const string& label, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   double DistanceToOriginWithIndex(int index, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   ...
+//   EXPECT_CALL(mock, Foo("abc", _, _))
+//       .WillOnce(Invoke(DistanceToOriginWithLabel));
+//   EXPECT_CALL(mock, Bar(5, _, _))
+//       .WillOnce(Invoke(DistanceToOriginWithIndex));
+//
+// you could write
+//
+//   // We can declare any uninteresting argument as Unused.
+//   double DistanceToOrigin(Unused, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   ...
+//   EXPECT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin));
+//   EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
+typedef internal::IgnoredValue Unused;
+
+// Creates an action that does actions a1, a2, ..., sequentially in
+// each invocation. All but the last action will have a readonly view of the
+// arguments.
+template <typename... Action>
+internal::DoAllAction<typename std::decay<Action>::type...> DoAll(
+    Action&&... action) {
+  return {std::forward_as_tuple(std::forward<Action>(action)...)};
+}
+
+// WithArg<k>(an_action) creates an action that passes the k-th
+// (0-based) argument of the mock function to an_action and performs
+// it.  It adapts an action accepting one argument to one that accepts
+// multiple arguments.  For convenience, we also provide
+// WithArgs<k>(an_action) (defined below) as a synonym.
+template <size_t k, typename InnerAction>
+internal::WithArgsAction<typename std::decay<InnerAction>::type, k>
+WithArg(InnerAction&& action) {
+  return {std::forward<InnerAction>(action)};
+}
+
+// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
+// the selected arguments of the mock function to an_action and
+// performs it.  It serves as an adaptor between actions with
+// different argument lists.
+template <size_t k, size_t... ks, typename InnerAction>
+internal::WithArgsAction<typename std::decay<InnerAction>::type, k, ks...>
+WithArgs(InnerAction&& action) {
+  return {std::forward<InnerAction>(action)};
+}
+
+// WithoutArgs(inner_action) can be used in a mock function with a
+// non-empty argument list to perform inner_action, which takes no
+// argument.  In other words, it adapts an action accepting no
+// argument to one that accepts (and ignores) arguments.
+template <typename InnerAction>
+internal::WithArgsAction<typename std::decay<InnerAction>::type>
+WithoutArgs(InnerAction&& action) {
+  return {std::forward<InnerAction>(action)};
+}
+
+// Creates an action that returns 'value'.  'value' is passed by value
+// instead of const reference - otherwise Return("string literal")
+// will trigger a compiler error about using array as initializer.
+template <typename R>
+internal::ReturnAction<R> Return(R value) {
+  return internal::ReturnAction<R>(std::move(value));
+}
+
+// Creates an action that returns NULL.
+inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
+  return MakePolymorphicAction(internal::ReturnNullAction());
+}
+
+// Creates an action that returns from a void function.
+inline PolymorphicAction<internal::ReturnVoidAction> Return() {
+  return MakePolymorphicAction(internal::ReturnVoidAction());
+}
+
+// Creates an action that returns the reference to a variable.
+template <typename R>
+inline internal::ReturnRefAction<R> ReturnRef(R& x) {  // NOLINT
+  return internal::ReturnRefAction<R>(x);
+}
+
+// Prevent using ReturnRef on reference to temporary.
+template <typename R, R* = nullptr>
+internal::ReturnRefAction<R> ReturnRef(R&&) = delete;
+
+// Creates an action that returns the reference to a copy of the
+// argument.  The copy is created when the action is constructed and
+// lives as long as the action.
+template <typename R>
+inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) {
+  return internal::ReturnRefOfCopyAction<R>(x);
+}
+
+// Modifies the parent action (a Return() action) to perform a move of the
+// argument instead of a copy.
+// Return(ByMove()) actions can only be executed once and will assert this
+// invariant.
+template <typename R>
+internal::ByMoveWrapper<R> ByMove(R x) {
+  return internal::ByMoveWrapper<R>(std::move(x));
+}
+
+// Creates an action that returns an element of `vals`. Calling this action will
+// repeatedly return the next value from `vals` until it reaches the end and
+// will restart from the beginning.
+template <typename T>
+internal::ReturnRoundRobinAction<T> ReturnRoundRobin(std::vector<T> vals) {
+  return internal::ReturnRoundRobinAction<T>(std::move(vals));
+}
+
+// Creates an action that returns an element of `vals`. Calling this action will
+// repeatedly return the next value from `vals` until it reaches the end and
+// will restart from the beginning.
+template <typename T>
+internal::ReturnRoundRobinAction<T> ReturnRoundRobin(
+    std::initializer_list<T> vals) {
+  return internal::ReturnRoundRobinAction<T>(std::vector<T>(vals));
+}
+
+// Creates an action that does the default action for the give mock function.
+inline internal::DoDefaultAction DoDefault() {
+  return internal::DoDefaultAction();
+}
+
+// Creates an action that sets the variable pointed by the N-th
+// (0-based) function argument to 'value'.
+template <size_t N, typename T>
+internal::SetArgumentPointeeAction<N, T> SetArgPointee(T value) {
+  return {std::move(value)};
+}
+
+// The following version is DEPRECATED.
+template <size_t N, typename T>
+internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T value) {
+  return {std::move(value)};
+}
+
+// Creates an action that sets a pointer referent to a given value.
+template <typename T1, typename T2>
+PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) {
+  return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
+}
+
+#if !GTEST_OS_WINDOWS_MOBILE
+
+// Creates an action that sets errno and returns the appropriate error.
+template <typename T>
+PolymorphicAction<internal::SetErrnoAndReturnAction<T> >
+SetErrnoAndReturn(int errval, T result) {
+  return MakePolymorphicAction(
+      internal::SetErrnoAndReturnAction<T>(errval, result));
+}
+
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Various overloads for Invoke().
+
+// Legacy function.
+// Actions can now be implicitly constructed from callables. No need to create
+// wrapper objects.
+// This function exists for backwards compatibility.
+template <typename FunctionImpl>
+typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&& function_impl) {
+  return std::forward<FunctionImpl>(function_impl);
+}
+
+// Creates an action that invokes the given method on the given object
+// with the mock function's arguments.
+template <class Class, typename MethodPtr>
+internal::InvokeMethodAction<Class, MethodPtr> Invoke(Class* obj_ptr,
+                                                      MethodPtr method_ptr) {
+  return {obj_ptr, method_ptr};
+}
+
+// Creates an action that invokes 'function_impl' with no argument.
+template <typename FunctionImpl>
+internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type>
+InvokeWithoutArgs(FunctionImpl function_impl) {
+  return {std::move(function_impl)};
+}
+
+// Creates an action that invokes the given method on the given object
+// with no argument.
+template <class Class, typename MethodPtr>
+internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> InvokeWithoutArgs(
+    Class* obj_ptr, MethodPtr method_ptr) {
+  return {obj_ptr, method_ptr};
+}
+
+// Creates an action that performs an_action and throws away its
+// result.  In other words, it changes the return type of an_action to
+// void.  an_action MUST NOT return void, or the code won't compile.
+template <typename A>
+inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) {
+  return internal::IgnoreResultAction<A>(an_action);
+}
+
+// Creates a reference wrapper for the given L-value.  If necessary,
+// you can explicitly specify the type of the reference.  For example,
+// suppose 'derived' is an object of type Derived, ByRef(derived)
+// would wrap a Derived&.  If you want to wrap a const Base& instead,
+// where Base is a base class of Derived, just write:
+//
+//   ByRef<const Base>(derived)
+//
+// N.B. ByRef is redundant with std::ref, std::cref and std::reference_wrapper.
+// However, it may still be used for consistency with ByMove().
+template <typename T>
+inline ::std::reference_wrapper<T> ByRef(T& l_value) {  // NOLINT
+  return ::std::reference_wrapper<T>(l_value);
+}
+
+// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
+// instance of type T, constructed on the heap with constructor arguments
+// a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
+template <typename T, typename... Params>
+internal::ReturnNewAction<T, typename std::decay<Params>::type...> ReturnNew(
+    Params&&... params) {
+  return {std::forward_as_tuple(std::forward<Params>(params)...)};
+}
+
+// Action ReturnArg<k>() returns the k-th argument of the mock function.
+template <size_t k>
+internal::ReturnArgAction<k> ReturnArg() {
+  return {};
+}
+
+// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
+// mock function to *pointer.
+template <size_t k, typename Ptr>
+internal::SaveArgAction<k, Ptr> SaveArg(Ptr pointer) {
+  return {pointer};
+}
+
+// Action SaveArgPointee<k>(pointer) saves the value pointed to
+// by the k-th (0-based) argument of the mock function to *pointer.
+template <size_t k, typename Ptr>
+internal::SaveArgPointeeAction<k, Ptr> SaveArgPointee(Ptr pointer) {
+  return {pointer};
+}
+
+// Action SetArgReferee<k>(value) assigns 'value' to the variable
+// referenced by the k-th (0-based) argument of the mock function.
+template <size_t k, typename T>
+internal::SetArgRefereeAction<k, typename std::decay<T>::type> SetArgReferee(
+    T&& value) {
+  return {std::forward<T>(value)};
+}
+
+// Action SetArrayArgument<k>(first, last) copies the elements in
+// source range [first, last) to the array pointed to by the k-th
+// (0-based) argument, which can be either a pointer or an
+// iterator. The action does not take ownership of the elements in the
+// source range.
+template <size_t k, typename I1, typename I2>
+internal::SetArrayArgumentAction<k, I1, I2> SetArrayArgument(I1 first,
+                                                             I2 last) {
+  return {first, last};
+}
+
+// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
+// function.
+template <size_t k>
+internal::DeleteArgAction<k> DeleteArg() {
+  return {};
+}
+
+// This action returns the value pointed to by 'pointer'.
+template <typename Ptr>
+internal::ReturnPointeeAction<Ptr> ReturnPointee(Ptr pointer) {
+  return {pointer};
+}
+
+// Action Throw(exception) can be used in a mock function of any type
+// to throw the given exception.  Any copyable value can be thrown.
+#if GTEST_HAS_EXCEPTIONS
+template <typename T>
+internal::ThrowAction<typename std::decay<T>::type> Throw(T&& exception) {
+  return {std::forward<T>(exception)};
+}
+#endif  // GTEST_HAS_EXCEPTIONS
+
+namespace internal {
+
+// A macro from the ACTION* family (defined later in gmock-generated-actions.h)
+// defines an action that can be used in a mock function.  Typically,
+// these actions only care about a subset of the arguments of the mock
+// function.  For example, if such an action only uses the second
+// argument, it can be used in any mock function that takes >= 2
+// arguments where the type of the second argument is compatible.
+//
+// Therefore, the action implementation must be prepared to take more
+// arguments than it needs.  The ExcessiveArg type is used to
+// represent those excessive arguments.  In order to keep the compiler
+// error messages tractable, we define it in the testing namespace
+// instead of testing::internal.  However, this is an INTERNAL TYPE
+// and subject to change without notice, so a user MUST NOT USE THIS
+// TYPE DIRECTLY.
+struct ExcessiveArg {};
+
+// Builds an implementation of an Action<> for some particular signature, using
+// a class defined by an ACTION* macro.
+template <typename F, typename Impl> struct ActionImpl;
+
+template <typename Impl>
+struct ImplBase {
+  struct Holder {
+    // Allows each copy of the Action<> to get to the Impl.
+    explicit operator const Impl&() const { return *ptr; }
+    std::shared_ptr<Impl> ptr;
+  };
+  using type = typename std::conditional<std::is_constructible<Impl>::value,
+                                         Impl, Holder>::type;
+};
+
+template <typename R, typename... Args, typename Impl>
+struct ActionImpl<R(Args...), Impl> : ImplBase<Impl>::type {
+  using Base = typename ImplBase<Impl>::type;
+  using function_type = R(Args...);
+  using args_type = std::tuple<Args...>;
+
+  ActionImpl() = default;  // Only defined if appropriate for Base.
+  explicit ActionImpl(std::shared_ptr<Impl> impl) : Base{std::move(impl)} { }
+
+  R operator()(Args&&... arg) const {
+    static constexpr size_t kMaxArgs =
+        sizeof...(Args) <= 10 ? sizeof...(Args) : 10;
+    return Apply(MakeIndexSequence<kMaxArgs>{},
+                 MakeIndexSequence<10 - kMaxArgs>{},
+                 args_type{std::forward<Args>(arg)...});
+  }
+
+  template <std::size_t... arg_id, std::size_t... excess_id>
+  R Apply(IndexSequence<arg_id...>, IndexSequence<excess_id...>,
+          const args_type& args) const {
+    // Impl need not be specific to the signature of action being implemented;
+    // only the implementing function body needs to have all of the specific
+    // types instantiated.  Up to 10 of the args that are provided by the
+    // args_type get passed, followed by a dummy of unspecified type for the
+    // remainder up to 10 explicit args.
+    static constexpr ExcessiveArg kExcessArg{};
+    return static_cast<const Impl&>(*this).template gmock_PerformImpl<
+        /*function_type=*/function_type, /*return_type=*/R,
+        /*args_type=*/args_type,
+        /*argN_type=*/typename std::tuple_element<arg_id, args_type>::type...>(
+        /*args=*/args, std::get<arg_id>(args)...,
+        ((void)excess_id, kExcessArg)...);
+  }
+};
+
+// Stores a default-constructed Impl as part of the Action<>'s
+// std::function<>. The Impl should be trivial to copy.
+template <typename F, typename Impl>
+::testing::Action<F> MakeAction() {
+  return ::testing::Action<F>(ActionImpl<F, Impl>());
+}
+
+// Stores just the one given instance of Impl.
+template <typename F, typename Impl>
+::testing::Action<F> MakeAction(std::shared_ptr<Impl> impl) {
+  return ::testing::Action<F>(ActionImpl<F, Impl>(std::move(impl)));
+}
+
+#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \
+  , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_
+#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_           \
+  const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \
+      GMOCK_INTERNAL_ARG_UNUSED, , 10)
+
+#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i
+#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \
+  const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10)
+
+#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type
+#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \
+  GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10))
+
+#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type
+#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params))
+
+#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type
+#define GMOCK_ACTION_TYPE_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params))
+
+#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \
+  , param##_type gmock_p##i
+#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params))
+
+#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \
+  , std::forward<param##_type>(gmock_p##i)
+#define GMOCK_ACTION_GVALUE_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params))
+
+#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \
+  , param(::std::forward<param##_type>(gmock_p##i))
+#define GMOCK_ACTION_INIT_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params))
+
+#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param;
+#define GMOCK_ACTION_FIELD_PARAMS_(params) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params)
+
+#define GMOCK_INTERNAL_ACTION(name, full_name, params)                        \
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
+  class full_name {                                                           \
+   public:                                                                    \
+    explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))              \
+        : impl_(std::make_shared<gmock_Impl>(                                 \
+                GMOCK_ACTION_GVALUE_PARAMS_(params))) { }                     \
+    full_name(const full_name&) = default;                                    \
+    full_name(full_name&&) noexcept = default;                                \
+    template <typename F>                                                     \
+    operator ::testing::Action<F>() const {                                   \
+      return ::testing::internal::MakeAction<F>(impl_);                       \
+    }                                                                         \
+   private:                                                                   \
+    class gmock_Impl {                                                        \
+     public:                                                                  \
+      explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))           \
+          : GMOCK_ACTION_INIT_PARAMS_(params) {}                              \
+      template <typename function_type, typename return_type,                 \
+                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>        \
+      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
+      GMOCK_ACTION_FIELD_PARAMS_(params)                                      \
+    };                                                                        \
+    std::shared_ptr<const gmock_Impl> impl_;                                  \
+  };                                                                          \
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
+  inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(                   \
+      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) {                             \
+    return full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>(                      \
+        GMOCK_ACTION_GVALUE_PARAMS_(params));                                 \
+  }                                                                           \
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
+  template <typename function_type, typename return_type, typename args_type, \
+            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
+  return_type full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>::gmock_Impl::      \
+  gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+}  // namespace internal
+
+// Similar to GMOCK_INTERNAL_ACTION, but no bound parameters are stored.
+#define ACTION(name)                                                          \
+  class name##Action {                                                        \
+   public:                                                                    \
+   explicit name##Action() noexcept {}                                        \
+   name##Action(const name##Action&) noexcept {}                              \
+    template <typename F>                                                     \
+    operator ::testing::Action<F>() const {                                   \
+      return ::testing::internal::MakeAction<F, gmock_Impl>();                \
+    }                                                                         \
+   private:                                                                   \
+    class gmock_Impl {                                                        \
+     public:                                                                  \
+      template <typename function_type, typename return_type,                 \
+                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>        \
+      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
+    };                                                                        \
+  };                                                                          \
+  inline name##Action name() GTEST_MUST_USE_RESULT_;                          \
+  inline name##Action name() { return name##Action(); }                       \
+  template <typename function_type, typename return_type, typename args_type, \
+            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
+  return_type name##Action::gmock_Impl::gmock_PerformImpl(                    \
+      GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__))
+
+#define ACTION_P2(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__))
+
+#define ACTION_P3(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__))
+
+#define ACTION_P4(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__))
+
+#define ACTION_P5(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__))
+
+#define ACTION_P6(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__))
+
+#define ACTION_P7(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__))
+
+#define ACTION_P8(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__))
+
+#define ACTION_P9(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__))
+
+#define ACTION_P10(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__))
+
+}  // namespace testing
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used cardinalities.  More
+// cardinalities can be defined by the user implementing the
+// CardinalityInterface interface if necessary.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+
+#include <limits.h>
+#include <memory>
+#include <ostream>  // NOLINT
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// To implement a cardinality Foo, define:
+//   1. a class FooCardinality that implements the
+//      CardinalityInterface interface, and
+//   2. a factory function that creates a Cardinality object from a
+//      const FooCardinality*.
+//
+// The two-level delegation design follows that of Matcher, providing
+// consistency for extension developers.  It also eases ownership
+// management as Cardinality objects can now be copied like plain values.
+
+// The implementation of a cardinality.
+class CardinalityInterface {
+ public:
+  virtual ~CardinalityInterface() {}
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  virtual int ConservativeLowerBound() const { return 0; }
+  virtual int ConservativeUpperBound() const { return INT_MAX; }
+
+  // Returns true if and only if call_count calls will satisfy this
+  // cardinality.
+  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
+
+  // Returns true if and only if call_count calls will saturate this
+  // cardinality.
+  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
+
+  // Describes self to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+};
+
+// A Cardinality is a copyable and IMMUTABLE (except by assignment)
+// object that specifies how many times a mock function is expected to
+// be called.  The implementation of Cardinality is just a std::shared_ptr
+// to const CardinalityInterface. Don't inherit from Cardinality!
+class GTEST_API_ Cardinality {
+ public:
+  // Constructs a null cardinality.  Needed for storing Cardinality
+  // objects in STL containers.
+  Cardinality() {}
+
+  // Constructs a Cardinality from its implementation.
+  explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); }
+  int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); }
+
+  // Returns true if and only if call_count calls will satisfy this
+  // cardinality.
+  bool IsSatisfiedByCallCount(int call_count) const {
+    return impl_->IsSatisfiedByCallCount(call_count);
+  }
+
+  // Returns true if and only if call_count calls will saturate this
+  // cardinality.
+  bool IsSaturatedByCallCount(int call_count) const {
+    return impl_->IsSaturatedByCallCount(call_count);
+  }
+
+  // Returns true if and only if call_count calls will over-saturate this
+  // cardinality, i.e. exceed the maximum number of allowed calls.
+  bool IsOverSaturatedByCallCount(int call_count) const {
+    return impl_->IsSaturatedByCallCount(call_count) &&
+        !impl_->IsSatisfiedByCallCount(call_count);
+  }
+
+  // Describes self to an ostream
+  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
+
+  // Describes the given actual call count to an ostream.
+  static void DescribeActualCallCountTo(int actual_call_count,
+                                        ::std::ostream* os);
+
+ private:
+  std::shared_ptr<const CardinalityInterface> impl_;
+};
+
+// Creates a cardinality that allows at least n calls.
+GTEST_API_ Cardinality AtLeast(int n);
+
+// Creates a cardinality that allows at most n calls.
+GTEST_API_ Cardinality AtMost(int n);
+
+// Creates a cardinality that allows any number of calls.
+GTEST_API_ Cardinality AnyNumber();
+
+// Creates a cardinality that allows between min and max calls.
+GTEST_API_ Cardinality Between(int min, int max);
+
+// Creates a cardinality that allows exactly n calls.
+GTEST_API_ Cardinality Exactly(int n);
+
+// Creates a cardinality from its implementation.
+inline Cardinality MakeCardinality(const CardinalityInterface* c) {
+  return Cardinality(c);
+}
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements MOCK_METHOD.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT
+
+#include <type_traits>  // IWYU pragma: keep
+#include <utility>      // IWYU pragma: keep
+
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements the ON_CALL() and EXPECT_CALL() macros.
+//
+// A user can use the ON_CALL() macro to specify the default action of
+// a mock method.  The syntax is:
+//
+//   ON_CALL(mock_object, Method(argument-matchers))
+//       .With(multi-argument-matcher)
+//       .WillByDefault(action);
+//
+//  where the .With() clause is optional.
+//
+// A user can use the EXPECT_CALL() macro to specify an expectation on
+// a mock method.  The syntax is:
+//
+//   EXPECT_CALL(mock_object, Method(argument-matchers))
+//       .With(multi-argument-matchers)
+//       .Times(cardinality)
+//       .InSequence(sequences)
+//       .After(expectations)
+//       .WillOnce(action)
+//       .WillRepeatedly(action)
+//       .RetiresOnSaturation();
+//
+// where all clauses are optional, and .InSequence()/.After()/
+// .WillOnce() can appear any number of times.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// The MATCHER* family of macros can be used in a namespace scope to
+// define custom matchers easily.
+//
+// Basic Usage
+// ===========
+//
+// The syntax
+//
+//   MATCHER(name, description_string) { statements; }
+//
+// defines a matcher with the given name that executes the statements,
+// which must return a bool to indicate if the match succeeds.  Inside
+// the statements, you can refer to the value being matched by 'arg',
+// and refer to its type by 'arg_type'.
+//
+// The description string documents what the matcher does, and is used
+// to generate the failure message when the match fails.  Since a
+// MATCHER() is usually defined in a header file shared by multiple
+// C++ source files, we require the description to be a C-string
+// literal to avoid possible side effects.  It can be empty, in which
+// case we'll use the sequence of words in the matcher name as the
+// description.
+//
+// For example:
+//
+//   MATCHER(IsEven, "") { return (arg % 2) == 0; }
+//
+// allows you to write
+//
+//   // Expects mock_foo.Bar(n) to be called where n is even.
+//   EXPECT_CALL(mock_foo, Bar(IsEven()));
+//
+// or,
+//
+//   // Verifies that the value of some_expression is even.
+//   EXPECT_THAT(some_expression, IsEven());
+//
+// If the above assertion fails, it will print something like:
+//
+//   Value of: some_expression
+//   Expected: is even
+//     Actual: 7
+//
+// where the description "is even" is automatically calculated from the
+// matcher name IsEven.
+//
+// Argument Type
+// =============
+//
+// Note that the type of the value being matched (arg_type) is
+// determined by the context in which you use the matcher and is
+// supplied to you by the compiler, so you don't need to worry about
+// declaring it (nor can you).  This allows the matcher to be
+// polymorphic.  For example, IsEven() can be used to match any type
+// where the value of "(arg % 2) == 0" can be implicitly converted to
+// a bool.  In the "Bar(IsEven())" example above, if method Bar()
+// takes an int, 'arg_type' will be int; if it takes an unsigned long,
+// 'arg_type' will be unsigned long; and so on.
+//
+// Parameterizing Matchers
+// =======================
+//
+// Sometimes you'll want to parameterize the matcher.  For that you
+// can use another macro:
+//
+//   MATCHER_P(name, param_name, description_string) { statements; }
+//
+// For example:
+//
+//   MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
+//
+// will allow you to write:
+//
+//   EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
+//
+// which may lead to this message (assuming n is 10):
+//
+//   Value of: Blah("a")
+//   Expected: has absolute value 10
+//     Actual: -9
+//
+// Note that both the matcher description and its parameter are
+// printed, making the message human-friendly.
+//
+// In the matcher definition body, you can write 'foo_type' to
+// reference the type of a parameter named 'foo'.  For example, in the
+// body of MATCHER_P(HasAbsoluteValue, value) above, you can write
+// 'value_type' to refer to the type of 'value'.
+//
+// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to
+// support multi-parameter matchers.
+//
+// Describing Parameterized Matchers
+// =================================
+//
+// The last argument to MATCHER*() is a string-typed expression.  The
+// expression can reference all of the matcher's parameters and a
+// special bool-typed variable named 'negation'.  When 'negation' is
+// false, the expression should evaluate to the matcher's description;
+// otherwise it should evaluate to the description of the negation of
+// the matcher.  For example,
+//
+//   using testing::PrintToString;
+//
+//   MATCHER_P2(InClosedRange, low, hi,
+//       std::string(negation ? "is not" : "is") + " in range [" +
+//       PrintToString(low) + ", " + PrintToString(hi) + "]") {
+//     return low <= arg && arg <= hi;
+//   }
+//   ...
+//   EXPECT_THAT(3, InClosedRange(4, 6));
+//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
+//
+// would generate two failures that contain the text:
+//
+//   Expected: is in range [4, 6]
+//   ...
+//   Expected: is not in range [2, 4]
+//
+// If you specify "" as the description, the failure message will
+// contain the sequence of words in the matcher name followed by the
+// parameter values printed as a tuple.  For example,
+//
+//   MATCHER_P2(InClosedRange, low, hi, "") { ... }
+//   ...
+//   EXPECT_THAT(3, InClosedRange(4, 6));
+//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
+//
+// would generate two failures that contain the text:
+//
+//   Expected: in closed range (4, 6)
+//   ...
+//   Expected: not (in closed range (2, 4))
+//
+// Types of Matcher Parameters
+// ===========================
+//
+// For the purpose of typing, you can view
+//
+//   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
+//
+// as shorthand for
+//
+//   template <typename p1_type, ..., typename pk_type>
+//   FooMatcherPk<p1_type, ..., pk_type>
+//   Foo(p1_type p1, ..., pk_type pk) { ... }
+//
+// When you write Foo(v1, ..., vk), the compiler infers the types of
+// the parameters v1, ..., and vk for you.  If you are not happy with
+// the result of the type inference, you can specify the types by
+// explicitly instantiating the template, as in Foo<long, bool>(5,
+// false).  As said earlier, you don't get to (or need to) specify
+// 'arg_type' as that's determined by the context in which the matcher
+// is used.  You can assign the result of expression Foo(p1, ..., pk)
+// to a variable of type FooMatcherPk<p1_type, ..., pk_type>.  This
+// can be useful when composing matchers.
+//
+// While you can instantiate a matcher template with reference types,
+// passing the parameters by pointer usually makes your code more
+// readable.  If, however, you still want to pass a parameter by
+// reference, be aware that in the failure message generated by the
+// matcher you will see the value of the referenced object but not its
+// address.
+//
+// Explaining Match Results
+// ========================
+//
+// Sometimes the matcher description alone isn't enough to explain why
+// the match has failed or succeeded.  For example, when expecting a
+// long string, it can be very helpful to also print the diff between
+// the expected string and the actual one.  To achieve that, you can
+// optionally stream additional information to a special variable
+// named result_listener, whose type is a pointer to class
+// MatchResultListener:
+//
+//   MATCHER_P(EqualsLongString, str, "") {
+//     if (arg == str) return true;
+//
+//     *result_listener << "the difference: "
+///                     << DiffStrings(str, arg);
+//     return false;
+//   }
+//
+// Overloading Matchers
+// ====================
+//
+// You can overload matchers with different numbers of parameters:
+//
+//   MATCHER_P(Blah, a, description_string1) { ... }
+//   MATCHER_P2(Blah, a, b, description_string2) { ... }
+//
+// Caveats
+// =======
+//
+// When defining a new matcher, you should also consider implementing
+// MatcherInterface or using MakePolymorphicMatcher().  These
+// approaches require more work than the MATCHER* macros, but also
+// give you more control on the types of the value being matched and
+// the matcher parameters, which may leads to better compiler error
+// messages when the matcher is used wrong.  They also allow
+// overloading matchers based on parameter types (as opposed to just
+// based on the number of parameters).
+//
+// MATCHER*() can only be used in a namespace scope as templates cannot be
+// declared inside of a local class.
+//
+// More Information
+// ================
+//
+// To learn more about using these macros, please search for 'MATCHER'
+// on
+// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md
+//
+// This file also implements some commonly used argument matchers.  More
+// matchers can be defined by the user implementing the
+// MatcherInterface<T> interface if necessary.
+//
+// See googletest/include/gtest/gtest-matchers.h for the definition of class
+// Matcher, class MatcherInterface, and others.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+
+#include <algorithm>
+#include <cmath>
+#include <initializer_list>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+
+// MSVC warning C5046 is new as of VS2017 version 15.8.
+#if defined(_MSC_VER) && _MSC_VER >= 1915
+#define GMOCK_MAYBE_5046_ 5046
+#else
+#define GMOCK_MAYBE_5046_
+#endif
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(
+    4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be used by
+                              clients of class B */
+    /* Symbol involving type with internal linkage not defined */)
+
+namespace testing {
+
+// To implement a matcher Foo for type T, define:
+//   1. a class FooMatcherImpl that implements the
+//      MatcherInterface<T> interface, and
+//   2. a factory function that creates a Matcher<T> object from a
+//      FooMatcherImpl*.
+//
+// The two-level delegation design makes it possible to allow a user
+// to write "v" instead of "Eq(v)" where a Matcher is expected, which
+// is impossible if we pass matchers by pointers.  It also eases
+// ownership management as Matcher objects can now be copied like
+// plain values.
+
+// A match result listener that stores the explanation in a string.
+class StringMatchResultListener : public MatchResultListener {
+ public:
+  StringMatchResultListener() : MatchResultListener(&ss_) {}
+
+  // Returns the explanation accumulated so far.
+  std::string str() const { return ss_.str(); }
+
+  // Clears the explanation accumulated so far.
+  void Clear() { ss_.str(""); }
+
+ private:
+  ::std::stringstream ss_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener);
+};
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// The MatcherCastImpl class template is a helper for implementing
+// MatcherCast().  We need this helper in order to partially
+// specialize the implementation of MatcherCast() (C++ allows
+// class/struct templates to be partially specialized, but not
+// function templates.).
+
+// This general version is used when MatcherCast()'s argument is a
+// polymorphic matcher (i.e. something that can be converted to a
+// Matcher but is not one yet; for example, Eq(value)) or a value (for
+// example, "hello").
+template <typename T, typename M>
+class MatcherCastImpl {
+ public:
+  static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
+    // M can be a polymorphic matcher, in which case we want to use
+    // its conversion operator to create Matcher<T>.  Or it can be a value
+    // that should be passed to the Matcher<T>'s constructor.
+    //
+    // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a
+    // polymorphic matcher because it'll be ambiguous if T has an implicit
+    // constructor from M (this usually happens when T has an implicit
+    // constructor from any type).
+    //
+    // It won't work to unconditionally implicit_cast
+    // polymorphic_matcher_or_value to Matcher<T> because it won't trigger
+    // a user-defined conversion from M to T if one exists (assuming M is
+    // a value).
+    return CastImpl(polymorphic_matcher_or_value,
+                    std::is_convertible<M, Matcher<T>>{},
+                    std::is_convertible<M, T>{});
+  }
+
+ private:
+  template <bool Ignore>
+  static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value,
+                             std::true_type /* convertible_to_matcher */,
+                             std::integral_constant<bool, Ignore>) {
+    // M is implicitly convertible to Matcher<T>, which means that either
+    // M is a polymorphic matcher or Matcher<T> has an implicit constructor
+    // from M.  In both cases using the implicit conversion will produce a
+    // matcher.
+    //
+    // Even if T has an implicit constructor from M, it won't be called because
+    // creating Matcher<T> would require a chain of two user-defined conversions
+    // (first to create T from M and then to create Matcher<T> from T).
+    return polymorphic_matcher_or_value;
+  }
+
+  // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic
+  // matcher. It's a value of a type implicitly convertible to T. Use direct
+  // initialization to create a matcher.
+  static Matcher<T> CastImpl(const M& value,
+                             std::false_type /* convertible_to_matcher */,
+                             std::true_type /* convertible_to_T */) {
+    return Matcher<T>(ImplicitCast_<T>(value));
+  }
+
+  // M can't be implicitly converted to either Matcher<T> or T. Attempt to use
+  // polymorphic matcher Eq(value) in this case.
+  //
+  // Note that we first attempt to perform an implicit cast on the value and
+  // only fall back to the polymorphic Eq() matcher afterwards because the
+  // latter calls bool operator==(const Lhs& lhs, const Rhs& rhs) in the end
+  // which might be undefined even when Rhs is implicitly convertible to Lhs
+  // (e.g. std::pair<const int, int> vs. std::pair<int, int>).
+  //
+  // We don't define this method inline as we need the declaration of Eq().
+  static Matcher<T> CastImpl(const M& value,
+                             std::false_type /* convertible_to_matcher */,
+                             std::false_type /* convertible_to_T */);
+};
+
+// This more specialized version is used when MatcherCast()'s argument
+// is already a Matcher.  This only compiles when type T can be
+// statically converted to type U.
+template <typename T, typename U>
+class MatcherCastImpl<T, Matcher<U> > {
+ public:
+  static Matcher<T> Cast(const Matcher<U>& source_matcher) {
+    return Matcher<T>(new Impl(source_matcher));
+  }
+
+ private:
+  class Impl : public MatcherInterface<T> {
+   public:
+    explicit Impl(const Matcher<U>& source_matcher)
+        : source_matcher_(source_matcher) {}
+
+    // We delegate the matching logic to the source matcher.
+    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
+      using FromType = typename std::remove_cv<typename std::remove_pointer<
+          typename std::remove_reference<T>::type>::type>::type;
+      using ToType = typename std::remove_cv<typename std::remove_pointer<
+          typename std::remove_reference<U>::type>::type>::type;
+      // Do not allow implicitly converting base*/& to derived*/&.
+      static_assert(
+          // Do not trigger if only one of them is a pointer. That implies a
+          // regular conversion and not a down_cast.
+          (std::is_pointer<typename std::remove_reference<T>::type>::value !=
+           std::is_pointer<typename std::remove_reference<U>::type>::value) ||
+              std::is_same<FromType, ToType>::value ||
+              !std::is_base_of<FromType, ToType>::value,
+          "Can't implicitly convert from <base> to <derived>");
+
+      // Do the cast to `U` explicitly if necessary.
+      // Otherwise, let implicit conversions do the trick.
+      using CastType =
+          typename std::conditional<std::is_convertible<T&, const U&>::value,
+                                    T&, U>::type;
+
+      return source_matcher_.MatchAndExplain(static_cast<CastType>(x),
+                                             listener);
+    }
+
+    void DescribeTo(::std::ostream* os) const override {
+      source_matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      source_matcher_.DescribeNegationTo(os);
+    }
+
+   private:
+    const Matcher<U> source_matcher_;
+  };
+};
+
+// This even more specialized version is used for efficiently casting
+// a matcher to its own type.
+template <typename T>
+class MatcherCastImpl<T, Matcher<T> > {
+ public:
+  static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; }
+};
+
+// Template specialization for parameterless Matcher.
+template <typename Derived>
+class MatcherBaseImpl {
+ public:
+  MatcherBaseImpl() = default;
+
+  template <typename T>
+  operator ::testing::Matcher<T>() const {  // NOLINT(runtime/explicit)
+    return ::testing::Matcher<T>(new
+                                 typename Derived::template gmock_Impl<T>());
+  }
+};
+
+// Template specialization for Matcher with parameters.
+template <template <typename...> class Derived, typename... Ts>
+class MatcherBaseImpl<Derived<Ts...>> {
+ public:
+  // Mark the constructor explicit for single argument T to avoid implicit
+  // conversions.
+  template <typename E = std::enable_if<sizeof...(Ts) == 1>,
+            typename E::type* = nullptr>
+  explicit MatcherBaseImpl(Ts... params)
+      : params_(std::forward<Ts>(params)...) {}
+  template <typename E = std::enable_if<sizeof...(Ts) != 1>,
+            typename = typename E::type>
+  MatcherBaseImpl(Ts... params)  // NOLINT
+      : params_(std::forward<Ts>(params)...) {}
+
+  template <typename F>
+  operator ::testing::Matcher<F>() const {  // NOLINT(runtime/explicit)
+    return Apply<F>(MakeIndexSequence<sizeof...(Ts)>{});
+  }
+
+ private:
+  template <typename F, std::size_t... tuple_ids>
+  ::testing::Matcher<F> Apply(IndexSequence<tuple_ids...>) const {
+    return ::testing::Matcher<F>(
+        new typename Derived<Ts...>::template gmock_Impl<F>(
+            std::get<tuple_ids>(params_)...));
+  }
+
+  const std::tuple<Ts...> params_;
+};
+
+}  // namespace internal
+
+// In order to be safe and clear, casting between different matcher
+// types is done explicitly via MatcherCast<T>(m), which takes a
+// matcher m and returns a Matcher<T>.  It compiles only when T can be
+// statically converted to the argument type of m.
+template <typename T, typename M>
+inline Matcher<T> MatcherCast(const M& matcher) {
+  return internal::MatcherCastImpl<T, M>::Cast(matcher);
+}
+
+// This overload handles polymorphic matchers and values only since
+// monomorphic matchers are handled by the next one.
+template <typename T, typename M>
+inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher_or_value) {
+  return MatcherCast<T>(polymorphic_matcher_or_value);
+}
+
+// This overload handles monomorphic matchers.
+//
+// In general, if type T can be implicitly converted to type U, we can
+// safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is
+// contravariant): just keep a copy of the original Matcher<U>, convert the
+// argument from type T to U, and then pass it to the underlying Matcher<U>.
+// The only exception is when U is a reference and T is not, as the
+// underlying Matcher<U> may be interested in the argument's address, which
+// is not preserved in the conversion from T to U.
+template <typename T, typename U>
+inline Matcher<T> SafeMatcherCast(const Matcher<U>& matcher) {
+  // Enforce that T can be implicitly converted to U.
+  static_assert(std::is_convertible<const T&, const U&>::value,
+                "T must be implicitly convertible to U");
+  // Enforce that we are not converting a non-reference type T to a reference
+  // type U.
+  GTEST_COMPILE_ASSERT_(
+      std::is_reference<T>::value || !std::is_reference<U>::value,
+      cannot_convert_non_reference_arg_to_reference);
+  // In case both T and U are arithmetic types, enforce that the
+  // conversion is not lossy.
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
+  constexpr bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
+  constexpr bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
+  GTEST_COMPILE_ASSERT_(
+      kTIsOther || kUIsOther ||
+      (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
+      conversion_of_arithmetic_types_must_be_lossless);
+  return MatcherCast<T>(matcher);
+}
+
+// A<T>() returns a matcher that matches any value of type T.
+template <typename T>
+Matcher<T> A();
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// If the explanation is not empty, prints it to the ostream.
+inline void PrintIfNotEmpty(const std::string& explanation,
+                            ::std::ostream* os) {
+  if (explanation != "" && os != nullptr) {
+    *os << ", " << explanation;
+  }
+}
+
+// Returns true if the given type name is easy to read by a human.
+// This is used to decide whether printing the type of a value might
+// be helpful.
+inline bool IsReadableTypeName(const std::string& type_name) {
+  // We consider a type name readable if it's short or doesn't contain
+  // a template or function type.
+  return (type_name.length() <= 20 ||
+          type_name.find_first_of("<(") == std::string::npos);
+}
+
+// Matches the value against the given matcher, prints the value and explains
+// the match result to the listener. Returns the match result.
+// 'listener' must not be NULL.
+// Value cannot be passed by const reference, because some matchers take a
+// non-const argument.
+template <typename Value, typename T>
+bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,
+                          MatchResultListener* listener) {
+  if (!listener->IsInterested()) {
+    // If the listener is not interested, we do not need to construct the
+    // inner explanation.
+    return matcher.Matches(value);
+  }
+
+  StringMatchResultListener inner_listener;
+  const bool match = matcher.MatchAndExplain(value, &inner_listener);
+
+  UniversalPrint(value, listener->stream());
+#if GTEST_HAS_RTTI
+  const std::string& type_name = GetTypeName<Value>();
+  if (IsReadableTypeName(type_name))
+    *listener->stream() << " (of type " << type_name << ")";
+#endif
+  PrintIfNotEmpty(inner_listener.str(), listener->stream());
+
+  return match;
+}
+
+// An internal helper class for doing compile-time loop on a tuple's
+// fields.
+template <size_t N>
+class TuplePrefix {
+ public:
+  // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true
+  // if and only if the first N fields of matcher_tuple matches
+  // the first N fields of value_tuple, respectively.
+  template <typename MatcherTuple, typename ValueTuple>
+  static bool Matches(const MatcherTuple& matcher_tuple,
+                      const ValueTuple& value_tuple) {
+    return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple) &&
+           std::get<N - 1>(matcher_tuple).Matches(std::get<N - 1>(value_tuple));
+  }
+
+  // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)
+  // describes failures in matching the first N fields of matchers
+  // against the first N fields of values.  If there is no failure,
+  // nothing will be streamed to os.
+  template <typename MatcherTuple, typename ValueTuple>
+  static void ExplainMatchFailuresTo(const MatcherTuple& matchers,
+                                     const ValueTuple& values,
+                                     ::std::ostream* os) {
+    // First, describes failures in the first N - 1 fields.
+    TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os);
+
+    // Then describes the failure (if any) in the (N - 1)-th (0-based)
+    // field.
+    typename std::tuple_element<N - 1, MatcherTuple>::type matcher =
+        std::get<N - 1>(matchers);
+    typedef typename std::tuple_element<N - 1, ValueTuple>::type Value;
+    const Value& value = std::get<N - 1>(values);
+    StringMatchResultListener listener;
+    if (!matcher.MatchAndExplain(value, &listener)) {
+      *os << "  Expected arg #" << N - 1 << ": ";
+      std::get<N - 1>(matchers).DescribeTo(os);
+      *os << "\n           Actual: ";
+      // We remove the reference in type Value to prevent the
+      // universal printer from printing the address of value, which
+      // isn't interesting to the user most of the time.  The
+      // matcher's MatchAndExplain() method handles the case when
+      // the address is interesting.
+      internal::UniversalPrint(value, os);
+      PrintIfNotEmpty(listener.str(), os);
+      *os << "\n";
+    }
+  }
+};
+
+// The base case.
+template <>
+class TuplePrefix<0> {
+ public:
+  template <typename MatcherTuple, typename ValueTuple>
+  static bool Matches(const MatcherTuple& /* matcher_tuple */,
+                      const ValueTuple& /* value_tuple */) {
+    return true;
+  }
+
+  template <typename MatcherTuple, typename ValueTuple>
+  static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */,
+                                     const ValueTuple& /* values */,
+                                     ::std::ostream* /* os */) {}
+};
+
+// TupleMatches(matcher_tuple, value_tuple) returns true if and only if
+// all matchers in matcher_tuple match the corresponding fields in
+// value_tuple.  It is a compiler error if matcher_tuple and
+// value_tuple have different number of fields or incompatible field
+// types.
+template <typename MatcherTuple, typename ValueTuple>
+bool TupleMatches(const MatcherTuple& matcher_tuple,
+                  const ValueTuple& value_tuple) {
+  // Makes sure that matcher_tuple and value_tuple have the same
+  // number of fields.
+  GTEST_COMPILE_ASSERT_(std::tuple_size<MatcherTuple>::value ==
+                            std::tuple_size<ValueTuple>::value,
+                        matcher_and_value_have_different_numbers_of_fields);
+  return TuplePrefix<std::tuple_size<ValueTuple>::value>::Matches(matcher_tuple,
+                                                                  value_tuple);
+}
+
+// Describes failures in matching matchers against values.  If there
+// is no failure, nothing will be streamed to os.
+template <typename MatcherTuple, typename ValueTuple>
+void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
+                                const ValueTuple& values,
+                                ::std::ostream* os) {
+  TuplePrefix<std::tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
+      matchers, values, os);
+}
+
+// TransformTupleValues and its helper.
+//
+// TransformTupleValuesHelper hides the internal machinery that
+// TransformTupleValues uses to implement a tuple traversal.
+template <typename Tuple, typename Func, typename OutIter>
+class TransformTupleValuesHelper {
+ private:
+  typedef ::std::tuple_size<Tuple> TupleSize;
+
+ public:
+  // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'.
+  // Returns the final value of 'out' in case the caller needs it.
+  static OutIter Run(Func f, const Tuple& t, OutIter out) {
+    return IterateOverTuple<Tuple, TupleSize::value>()(f, t, out);
+  }
+
+ private:
+  template <typename Tup, size_t kRemainingSize>
+  struct IterateOverTuple {
+    OutIter operator() (Func f, const Tup& t, OutIter out) const {
+      *out++ = f(::std::get<TupleSize::value - kRemainingSize>(t));
+      return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);
+    }
+  };
+  template <typename Tup>
+  struct IterateOverTuple<Tup, 0> {
+    OutIter operator() (Func /* f */, const Tup& /* t */, OutIter out) const {
+      return out;
+    }
+  };
+};
+
+// Successively invokes 'f(element)' on each element of the tuple 't',
+// appending each result to the 'out' iterator. Returns the final value
+// of 'out'.
+template <typename Tuple, typename Func, typename OutIter>
+OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) {
+  return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out);
+}
+
+// Implements _, a matcher that matches any value of any
+// type.  This is a polymorphic matcher, so we need a template type
+// conversion operator to make it appearing as a Matcher<T> for any
+// type T.
+class AnythingMatcher {
+ public:
+  using is_gtest_matcher = void;
+
+  template <typename T>
+  bool MatchAndExplain(const T& /* x */, std::ostream* /* listener */) const {
+    return true;
+  }
+  void DescribeTo(std::ostream* os) const { *os << "is anything"; }
+  void DescribeNegationTo(::std::ostream* os) const {
+    // This is mostly for completeness' sake, as it's not very useful
+    // to write Not(A<bool>()).  However we cannot completely rule out
+    // such a possibility, and it doesn't hurt to be prepared.
+    *os << "never matches";
+  }
+};
+
+// Implements the polymorphic IsNull() matcher, which matches any raw or smart
+// pointer that is NULL.
+class IsNullMatcher {
+ public:
+  template <typename Pointer>
+  bool MatchAndExplain(const Pointer& p,
+                       MatchResultListener* /* listener */) const {
+    return p == nullptr;
+  }
+
+  void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "isn't NULL";
+  }
+};
+
+// Implements the polymorphic NotNull() matcher, which matches any raw or smart
+// pointer that is not NULL.
+class NotNullMatcher {
+ public:
+  template <typename Pointer>
+  bool MatchAndExplain(const Pointer& p,
+                       MatchResultListener* /* listener */) const {
+    return p != nullptr;
+  }
+
+  void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is NULL";
+  }
+};
+
+// Ref(variable) matches any argument that is a reference to
+// 'variable'.  This matcher is polymorphic as it can match any
+// super type of the type of 'variable'.
+//
+// The RefMatcher template class implements Ref(variable).  It can
+// only be instantiated with a reference type.  This prevents a user
+// from mistakenly using Ref(x) to match a non-reference function
+// argument.  For example, the following will righteously cause a
+// compiler error:
+//
+//   int n;
+//   Matcher<int> m1 = Ref(n);   // This won't compile.
+//   Matcher<int&> m2 = Ref(n);  // This will compile.
+template <typename T>
+class RefMatcher;
+
+template <typename T>
+class RefMatcher<T&> {
+  // Google Mock is a generic framework and thus needs to support
+  // mocking any function types, including those that take non-const
+  // reference arguments.  Therefore the template parameter T (and
+  // Super below) can be instantiated to either a const type or a
+  // non-const type.
+ public:
+  // RefMatcher() takes a T& instead of const T&, as we want the
+  // compiler to catch using Ref(const_value) as a matcher for a
+  // non-const reference.
+  explicit RefMatcher(T& x) : object_(x) {}  // NOLINT
+
+  template <typename Super>
+  operator Matcher<Super&>() const {
+    // By passing object_ (type T&) to Impl(), which expects a Super&,
+    // we make sure that Super is a super type of T.  In particular,
+    // this catches using Ref(const_value) as a matcher for a
+    // non-const reference, as you cannot implicitly convert a const
+    // reference to a non-const reference.
+    return MakeMatcher(new Impl<Super>(object_));
+  }
+
+ private:
+  template <typename Super>
+  class Impl : public MatcherInterface<Super&> {
+   public:
+    explicit Impl(Super& x) : object_(x) {}  // NOLINT
+
+    // MatchAndExplain() takes a Super& (as opposed to const Super&)
+    // in order to match the interface MatcherInterface<Super&>.
+    bool MatchAndExplain(Super& x,
+                         MatchResultListener* listener) const override {
+      *listener << "which is located @" << static_cast<const void*>(&x);
+      return &x == &object_;
+    }
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "references the variable ";
+      UniversalPrinter<Super&>::Print(object_, os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "does not reference the variable ";
+      UniversalPrinter<Super&>::Print(object_, os);
+    }
+
+   private:
+    const Super& object_;
+  };
+
+  T& object_;
+};
+
+// Polymorphic helper functions for narrow and wide string matchers.
+inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
+  return String::CaseInsensitiveCStringEquals(lhs, rhs);
+}
+
+inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,
+                                         const wchar_t* rhs) {
+  return String::CaseInsensitiveWideCStringEquals(lhs, rhs);
+}
+
+// String comparison for narrow or wide strings that can have embedded NUL
+// characters.
+template <typename StringType>
+bool CaseInsensitiveStringEquals(const StringType& s1,
+                                 const StringType& s2) {
+  // Are the heads equal?
+  if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) {
+    return false;
+  }
+
+  // Skip the equal heads.
+  const typename StringType::value_type nul = 0;
+  const size_t i1 = s1.find(nul), i2 = s2.find(nul);
+
+  // Are we at the end of either s1 or s2?
+  if (i1 == StringType::npos || i2 == StringType::npos) {
+    return i1 == i2;
+  }
+
+  // Are the tails equal?
+  return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1));
+}
+
+// String matchers.
+
+// Implements equality-based string matchers like StrEq, StrCaseNe, and etc.
+template <typename StringType>
+class StrEqualityMatcher {
+ public:
+  StrEqualityMatcher(StringType str, bool expect_eq, bool case_sensitive)
+      : string_(std::move(str)),
+        expect_eq_(expect_eq),
+        case_sensitive_(case_sensitive) {}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    // This should fail to compile if StringView is used with wide
+    // strings.
+    const StringType& str = std::string(s);
+    return MatchAndExplain(str, listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    if (s == nullptr) {
+      return !expect_eq_;
+    }
+    return MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringView has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType s2(s);
+    const bool eq = case_sensitive_ ? s2 == string_ :
+        CaseInsensitiveStringEquals(s2, string_);
+    return expect_eq_ == eq;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    DescribeToHelper(expect_eq_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    DescribeToHelper(!expect_eq_, os);
+  }
+
+ private:
+  void DescribeToHelper(bool expect_eq, ::std::ostream* os) const {
+    *os << (expect_eq ? "is " : "isn't ");
+    *os << "equal to ";
+    if (!case_sensitive_) {
+      *os << "(ignoring case) ";
+    }
+    UniversalPrint(string_, os);
+  }
+
+  const StringType string_;
+  const bool expect_eq_;
+  const bool case_sensitive_;
+};
+
+// Implements the polymorphic HasSubstr(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class HasSubstrMatcher {
+ public:
+  explicit HasSubstrMatcher(const StringType& substring)
+      : substring_(substring) {}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    // This should fail to compile if StringView is used with wide
+    // strings.
+    const StringType& str = std::string(s);
+    return MatchAndExplain(str, listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != nullptr && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringView has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    return StringType(s).find(substring_) != StringType::npos;
+  }
+
+  // Describes what this matcher matches.
+  void DescribeTo(::std::ostream* os) const {
+    *os << "has substring ";
+    UniversalPrint(substring_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "has no substring ";
+    UniversalPrint(substring_, os);
+  }
+
+ private:
+  const StringType substring_;
+};
+
+// Implements the polymorphic StartsWith(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class StartsWithMatcher {
+ public:
+  explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {
+  }
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    // This should fail to compile if StringView is used with wide
+    // strings.
+    const StringType& str = std::string(s);
+    return MatchAndExplain(str, listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != nullptr && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringView has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    return s2.length() >= prefix_.length() &&
+        s2.substr(0, prefix_.length()) == prefix_;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "starts with ";
+    UniversalPrint(prefix_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't start with ";
+    UniversalPrint(prefix_, os);
+  }
+
+ private:
+  const StringType prefix_;
+};
+
+// Implements the polymorphic EndsWith(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class EndsWithMatcher {
+ public:
+  explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    // This should fail to compile if StringView is used with wide
+    // strings.
+    const StringType& str = std::string(s);
+    return MatchAndExplain(str, listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != nullptr && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringView has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    return s2.length() >= suffix_.length() &&
+        s2.substr(s2.length() - suffix_.length()) == suffix_;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "ends with ";
+    UniversalPrint(suffix_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't end with ";
+    UniversalPrint(suffix_, os);
+  }
+
+ private:
+  const StringType suffix_;
+};
+
+// Implements a matcher that compares the two fields of a 2-tuple
+// using one of the ==, <=, <, etc, operators.  The two fields being
+// compared don't have to have the same type.
+//
+// The matcher defined here is polymorphic (for example, Eq() can be
+// used to match a std::tuple<int, short>, a std::tuple<const long&, double>,
+// etc).  Therefore we use a template type conversion operator in the
+// implementation.
+template <typename D, typename Op>
+class PairMatchBase {
+ public:
+  template <typename T1, typename T2>
+  operator Matcher<::std::tuple<T1, T2>>() const {
+    return Matcher<::std::tuple<T1, T2>>(new Impl<const ::std::tuple<T1, T2>&>);
+  }
+  template <typename T1, typename T2>
+  operator Matcher<const ::std::tuple<T1, T2>&>() const {
+    return MakeMatcher(new Impl<const ::std::tuple<T1, T2>&>);
+  }
+
+ private:
+  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT
+    return os << D::Desc();
+  }
+
+  template <typename Tuple>
+  class Impl : public MatcherInterface<Tuple> {
+   public:
+    bool MatchAndExplain(Tuple args,
+                         MatchResultListener* /* listener */) const override {
+      return Op()(::std::get<0>(args), ::std::get<1>(args));
+    }
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "are " << GetDesc;
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "aren't " << GetDesc;
+    }
+  };
+};
+
+class Eq2Matcher : public PairMatchBase<Eq2Matcher, AnyEq> {
+ public:
+  static const char* Desc() { return "an equal pair"; }
+};
+class Ne2Matcher : public PairMatchBase<Ne2Matcher, AnyNe> {
+ public:
+  static const char* Desc() { return "an unequal pair"; }
+};
+class Lt2Matcher : public PairMatchBase<Lt2Matcher, AnyLt> {
+ public:
+  static const char* Desc() { return "a pair where the first < the second"; }
+};
+class Gt2Matcher : public PairMatchBase<Gt2Matcher, AnyGt> {
+ public:
+  static const char* Desc() { return "a pair where the first > the second"; }
+};
+class Le2Matcher : public PairMatchBase<Le2Matcher, AnyLe> {
+ public:
+  static const char* Desc() { return "a pair where the first <= the second"; }
+};
+class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> {
+ public:
+  static const char* Desc() { return "a pair where the first >= the second"; }
+};
+
+// Implements the Not(...) matcher for a particular argument type T.
+// We do not nest it inside the NotMatcher class template, as that
+// will prevent different instantiations of NotMatcher from sharing
+// the same NotMatcherImpl<T> class.
+template <typename T>
+class NotMatcherImpl : public MatcherInterface<const T&> {
+ public:
+  explicit NotMatcherImpl(const Matcher<T>& matcher)
+      : matcher_(matcher) {}
+
+  bool MatchAndExplain(const T& x,
+                       MatchResultListener* listener) const override {
+    return !matcher_.MatchAndExplain(x, listener);
+  }
+
+  void DescribeTo(::std::ostream* os) const override {
+    matcher_.DescribeNegationTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    matcher_.DescribeTo(os);
+  }
+
+ private:
+  const Matcher<T> matcher_;
+};
+
+// Implements the Not(m) matcher, which matches a value that doesn't
+// match matcher m.
+template <typename InnerMatcher>
+class NotMatcher {
+ public:
+  explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {}
+
+  // This template type conversion operator allows Not(m) to be used
+  // to match any type m can match.
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));
+  }
+
+ private:
+  InnerMatcher matcher_;
+};
+
+// Implements the AllOf(m1, m2) matcher for a particular argument type
+// T. We do not nest it inside the BothOfMatcher class template, as
+// that will prevent different instantiations of BothOfMatcher from
+// sharing the same BothOfMatcherImpl<T> class.
+template <typename T>
+class AllOfMatcherImpl : public MatcherInterface<const T&> {
+ public:
+  explicit AllOfMatcherImpl(std::vector<Matcher<T> > matchers)
+      : matchers_(std::move(matchers)) {}
+
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "(";
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      if (i != 0) *os << ") and (";
+      matchers_[i].DescribeTo(os);
+    }
+    *os << ")";
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "(";
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      if (i != 0) *os << ") or (";
+      matchers_[i].DescribeNegationTo(os);
+    }
+    *os << ")";
+  }
+
+  bool MatchAndExplain(const T& x,
+                       MatchResultListener* listener) const override {
+    // If either matcher1_ or matcher2_ doesn't match x, we only need
+    // to explain why one of them fails.
+    std::string all_match_result;
+
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      StringMatchResultListener slistener;
+      if (matchers_[i].MatchAndExplain(x, &slistener)) {
+        if (all_match_result.empty()) {
+          all_match_result = slistener.str();
+        } else {
+          std::string result = slistener.str();
+          if (!result.empty()) {
+            all_match_result += ", and ";
+            all_match_result += result;
+          }
+        }
+      } else {
+        *listener << slistener.str();
+        return false;
+      }
+    }
+
+    // Otherwise we need to explain why *both* of them match.
+    *listener << all_match_result;
+    return true;
+  }
+
+ private:
+  const std::vector<Matcher<T> > matchers_;
+};
+
+// VariadicMatcher is used for the variadic implementation of
+// AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...).
+// CombiningMatcher<T> is used to recursively combine the provided matchers
+// (of type Args...).
+template <template <typename T> class CombiningMatcher, typename... Args>
+class VariadicMatcher {
+ public:
+  VariadicMatcher(const Args&... matchers)  // NOLINT
+      : matchers_(matchers...) {
+    static_assert(sizeof...(Args) > 0, "Must have at least one matcher.");
+  }
+
+  VariadicMatcher(const VariadicMatcher&) = default;
+  VariadicMatcher& operator=(const VariadicMatcher&) = delete;
+
+  // This template type conversion operator allows an
+  // VariadicMatcher<Matcher1, Matcher2...> object to match any type that
+  // all of the provided matchers (Matcher1, Matcher2, ...) can match.
+  template <typename T>
+  operator Matcher<T>() const {
+    std::vector<Matcher<T> > values;
+    CreateVariadicMatcher<T>(&values, std::integral_constant<size_t, 0>());
+    return Matcher<T>(new CombiningMatcher<T>(std::move(values)));
+  }
+
+ private:
+  template <typename T, size_t I>
+  void CreateVariadicMatcher(std::vector<Matcher<T> >* values,
+                             std::integral_constant<size_t, I>) const {
+    values->push_back(SafeMatcherCast<T>(std::get<I>(matchers_)));
+    CreateVariadicMatcher<T>(values, std::integral_constant<size_t, I + 1>());
+  }
+
+  template <typename T>
+  void CreateVariadicMatcher(
+      std::vector<Matcher<T> >*,
+      std::integral_constant<size_t, sizeof...(Args)>) const {}
+
+  std::tuple<Args...> matchers_;
+};
+
+template <typename... Args>
+using AllOfMatcher = VariadicMatcher<AllOfMatcherImpl, Args...>;
+
+// Implements the AnyOf(m1, m2) matcher for a particular argument type
+// T.  We do not nest it inside the AnyOfMatcher class template, as
+// that will prevent different instantiations of AnyOfMatcher from
+// sharing the same EitherOfMatcherImpl<T> class.
+template <typename T>
+class AnyOfMatcherImpl : public MatcherInterface<const T&> {
+ public:
+  explicit AnyOfMatcherImpl(std::vector<Matcher<T> > matchers)
+      : matchers_(std::move(matchers)) {}
+
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "(";
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      if (i != 0) *os << ") or (";
+      matchers_[i].DescribeTo(os);
+    }
+    *os << ")";
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "(";
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      if (i != 0) *os << ") and (";
+      matchers_[i].DescribeNegationTo(os);
+    }
+    *os << ")";
+  }
+
+  bool MatchAndExplain(const T& x,
+                       MatchResultListener* listener) const override {
+    std::string no_match_result;
+
+    // If either matcher1_ or matcher2_ matches x, we just need to
+    // explain why *one* of them matches.
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      StringMatchResultListener slistener;
+      if (matchers_[i].MatchAndExplain(x, &slistener)) {
+        *listener << slistener.str();
+        return true;
+      } else {
+        if (no_match_result.empty()) {
+          no_match_result = slistener.str();
+        } else {
+          std::string result = slistener.str();
+          if (!result.empty()) {
+            no_match_result += ", and ";
+            no_match_result += result;
+          }
+        }
+      }
+    }
+
+    // Otherwise we need to explain why *both* of them fail.
+    *listener << no_match_result;
+    return false;
+  }
+
+ private:
+  const std::vector<Matcher<T> > matchers_;
+};
+
+// AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...).
+template <typename... Args>
+using AnyOfMatcher = VariadicMatcher<AnyOfMatcherImpl, Args...>;
+
+// Wrapper for implementation of Any/AllOfArray().
+template <template <class> class MatcherImpl, typename T>
+class SomeOfArrayMatcher {
+ public:
+  // Constructs the matcher from a sequence of element values or
+  // element matchers.
+  template <typename Iter>
+  SomeOfArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}
+
+  template <typename U>
+  operator Matcher<U>() const {  // NOLINT
+    using RawU = typename std::decay<U>::type;
+    std::vector<Matcher<RawU>> matchers;
+    for (const auto& matcher : matchers_) {
+      matchers.push_back(MatcherCast<RawU>(matcher));
+    }
+    return Matcher<U>(new MatcherImpl<RawU>(std::move(matchers)));
+  }
+
+ private:
+  const ::std::vector<T> matchers_;
+};
+
+template <typename T>
+using AllOfArrayMatcher = SomeOfArrayMatcher<AllOfMatcherImpl, T>;
+
+template <typename T>
+using AnyOfArrayMatcher = SomeOfArrayMatcher<AnyOfMatcherImpl, T>;
+
+// Used for implementing Truly(pred), which turns a predicate into a
+// matcher.
+template <typename Predicate>
+class TrulyMatcher {
+ public:
+  explicit TrulyMatcher(Predicate pred) : predicate_(pred) {}
+
+  // This method template allows Truly(pred) to be used as a matcher
+  // for type T where T is the argument type of predicate 'pred'.  The
+  // argument is passed by reference as the predicate may be
+  // interested in the address of the argument.
+  template <typename T>
+  bool MatchAndExplain(T& x,  // NOLINT
+                       MatchResultListener* listener) const {
+    // Without the if-statement, MSVC sometimes warns about converting
+    // a value to bool (warning 4800).
+    //
+    // We cannot write 'return !!predicate_(x);' as that doesn't work
+    // when predicate_(x) returns a class convertible to bool but
+    // having no operator!().
+    if (predicate_(x))
+      return true;
+    *listener << "didn't satisfy the given predicate";
+    return false;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "satisfies the given predicate";
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't satisfy the given predicate";
+  }
+
+ private:
+  Predicate predicate_;
+};
+
+// Used for implementing Matches(matcher), which turns a matcher into
+// a predicate.
+template <typename M>
+class MatcherAsPredicate {
+ public:
+  explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {}
+
+  // This template operator() allows Matches(m) to be used as a
+  // predicate on type T where m is a matcher on type T.
+  //
+  // The argument x is passed by reference instead of by value, as
+  // some matcher may be interested in its address (e.g. as in
+  // Matches(Ref(n))(x)).
+  template <typename T>
+  bool operator()(const T& x) const {
+    // We let matcher_ commit to a particular type here instead of
+    // when the MatcherAsPredicate object was constructed.  This
+    // allows us to write Matches(m) where m is a polymorphic matcher
+    // (e.g. Eq(5)).
+    //
+    // If we write Matcher<T>(matcher_).Matches(x) here, it won't
+    // compile when matcher_ has type Matcher<const T&>; if we write
+    // Matcher<const T&>(matcher_).Matches(x) here, it won't compile
+    // when matcher_ has type Matcher<T>; if we just write
+    // matcher_.Matches(x), it won't compile when matcher_ is
+    // polymorphic, e.g. Eq(5).
+    //
+    // MatcherCast<const T&>() is necessary for making the code work
+    // in all of the above situations.
+    return MatcherCast<const T&>(matcher_).Matches(x);
+  }
+
+ private:
+  M matcher_;
+};
+
+// For implementing ASSERT_THAT() and EXPECT_THAT().  The template
+// argument M must be a type that can be converted to a matcher.
+template <typename M>
+class PredicateFormatterFromMatcher {
+ public:
+  explicit PredicateFormatterFromMatcher(M m) : matcher_(std::move(m)) {}
+
+  // This template () operator allows a PredicateFormatterFromMatcher
+  // object to act as a predicate-formatter suitable for using with
+  // Google Test's EXPECT_PRED_FORMAT1() macro.
+  template <typename T>
+  AssertionResult operator()(const char* value_text, const T& x) const {
+    // We convert matcher_ to a Matcher<const T&> *now* instead of
+    // when the PredicateFormatterFromMatcher object was constructed,
+    // as matcher_ may be polymorphic (e.g. NotNull()) and we won't
+    // know which type to instantiate it to until we actually see the
+    // type of x here.
+    //
+    // We write SafeMatcherCast<const T&>(matcher_) instead of
+    // Matcher<const T&>(matcher_), as the latter won't compile when
+    // matcher_ has type Matcher<T> (e.g. An<int>()).
+    // We don't write MatcherCast<const T&> either, as that allows
+    // potentially unsafe downcasting of the matcher argument.
+    const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);
+
+    // The expected path here is that the matcher should match (i.e. that most
+    // tests pass) so optimize for this case.
+    if (matcher.Matches(x)) {
+      return AssertionSuccess();
+    }
+
+    ::std::stringstream ss;
+    ss << "Value of: " << value_text << "\n"
+       << "Expected: ";
+    matcher.DescribeTo(&ss);
+
+    // Rerun the matcher to "PrintAndExplain" the failure.
+    StringMatchResultListener listener;
+    if (MatchPrintAndExplain(x, matcher, &listener)) {
+      ss << "\n  The matcher failed on the initial attempt; but passed when "
+            "rerun to generate the explanation.";
+    }
+    ss << "\n  Actual: " << listener.str();
+    return AssertionFailure() << ss.str();
+  }
+
+ private:
+  const M matcher_;
+};
+
+// A helper function for converting a matcher to a predicate-formatter
+// without the user needing to explicitly write the type.  This is
+// used for implementing ASSERT_THAT() and EXPECT_THAT().
+// Implementation detail: 'matcher' is received by-value to force decaying.
+template <typename M>
+inline PredicateFormatterFromMatcher<M>
+MakePredicateFormatterFromMatcher(M matcher) {
+  return PredicateFormatterFromMatcher<M>(std::move(matcher));
+}
+
+// Implements the polymorphic IsNan() matcher, which matches any floating type
+// value that is Nan.
+class IsNanMatcher {
+ public:
+  template <typename FloatType>
+  bool MatchAndExplain(const FloatType& f,
+                       MatchResultListener* /* listener */) const {
+    return (::std::isnan)(f);
+  }
+
+  void DescribeTo(::std::ostream* os) const { *os << "is NaN"; }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "isn't NaN";
+  }
+};
+
+// Implements the polymorphic floating point equality matcher, which matches
+// two float values using ULP-based approximation or, optionally, a
+// user-specified epsilon.  The template is meant to be instantiated with
+// FloatType being either float or double.
+template <typename FloatType>
+class FloatingEqMatcher {
+ public:
+  // Constructor for FloatingEqMatcher.
+  // The matcher's input will be compared with expected.  The matcher treats two
+  // NANs as equal if nan_eq_nan is true.  Otherwise, under IEEE standards,
+  // equality comparisons between NANs will always return false.  We specify a
+  // negative max_abs_error_ term to indicate that ULP-based approximation will
+  // be used for comparison.
+  FloatingEqMatcher(FloatType expected, bool nan_eq_nan) :
+    expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {
+  }
+
+  // Constructor that supports a user-specified max_abs_error that will be used
+  // for comparison instead of ULP-based approximation.  The max absolute
+  // should be non-negative.
+  FloatingEqMatcher(FloatType expected, bool nan_eq_nan,
+                    FloatType max_abs_error)
+      : expected_(expected),
+        nan_eq_nan_(nan_eq_nan),
+        max_abs_error_(max_abs_error) {
+    GTEST_CHECK_(max_abs_error >= 0)
+        << ", where max_abs_error is" << max_abs_error;
+  }
+
+  // Implements floating point equality matcher as a Matcher<T>.
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+   public:
+    Impl(FloatType expected, bool nan_eq_nan, FloatType max_abs_error)
+        : expected_(expected),
+          nan_eq_nan_(nan_eq_nan),
+          max_abs_error_(max_abs_error) {}
+
+    bool MatchAndExplain(T value,
+                         MatchResultListener* listener) const override {
+      const FloatingPoint<FloatType> actual(value), expected(expected_);
+
+      // Compares NaNs first, if nan_eq_nan_ is true.
+      if (actual.is_nan() || expected.is_nan()) {
+        if (actual.is_nan() && expected.is_nan()) {
+          return nan_eq_nan_;
+        }
+        // One is nan; the other is not nan.
+        return false;
+      }
+      if (HasMaxAbsError()) {
+        // We perform an equality check so that inf will match inf, regardless
+        // of error bounds.  If the result of value - expected_ would result in
+        // overflow or if either value is inf, the default result is infinity,
+        // which should only match if max_abs_error_ is also infinity.
+        if (value == expected_) {
+          return true;
+        }
+
+        const FloatType diff = value - expected_;
+        if (::std::fabs(diff) <= max_abs_error_) {
+          return true;
+        }
+
+        if (listener->IsInterested()) {
+          *listener << "which is " << diff << " from " << expected_;
+        }
+        return false;
+      } else {
+        return actual.AlmostEquals(expected);
+      }
+    }
+
+    void DescribeTo(::std::ostream* os) const override {
+      // os->precision() returns the previously set precision, which we
+      // store to restore the ostream to its original configuration
+      // after outputting.
+      const ::std::streamsize old_precision = os->precision(
+          ::std::numeric_limits<FloatType>::digits10 + 2);
+      if (FloatingPoint<FloatType>(expected_).is_nan()) {
+        if (nan_eq_nan_) {
+          *os << "is NaN";
+        } else {
+          *os << "never matches";
+        }
+      } else {
+        *os << "is approximately " << expected_;
+        if (HasMaxAbsError()) {
+          *os << " (absolute error <= " << max_abs_error_ << ")";
+        }
+      }
+      os->precision(old_precision);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      // As before, get original precision.
+      const ::std::streamsize old_precision = os->precision(
+          ::std::numeric_limits<FloatType>::digits10 + 2);
+      if (FloatingPoint<FloatType>(expected_).is_nan()) {
+        if (nan_eq_nan_) {
+          *os << "isn't NaN";
+        } else {
+          *os << "is anything";
+        }
+      } else {
+        *os << "isn't approximately " << expected_;
+        if (HasMaxAbsError()) {
+          *os << " (absolute error > " << max_abs_error_ << ")";
+        }
+      }
+      // Restore original precision.
+      os->precision(old_precision);
+    }
+
+   private:
+    bool HasMaxAbsError() const {
+      return max_abs_error_ >= 0;
+    }
+
+    const FloatType expected_;
+    const bool nan_eq_nan_;
+    // max_abs_error will be used for value comparison when >= 0.
+    const FloatType max_abs_error_;
+  };
+
+  // The following 3 type conversion operators allow FloatEq(expected) and
+  // NanSensitiveFloatEq(expected) to be used as a Matcher<float>, a
+  // Matcher<const float&>, or a Matcher<float&>, but nothing else.
+  operator Matcher<FloatType>() const {
+    return MakeMatcher(
+        new Impl<FloatType>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+  operator Matcher<const FloatType&>() const {
+    return MakeMatcher(
+        new Impl<const FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+  operator Matcher<FloatType&>() const {
+    return MakeMatcher(
+        new Impl<FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+ private:
+  const FloatType expected_;
+  const bool nan_eq_nan_;
+  // max_abs_error will be used for value comparison when >= 0.
+  const FloatType max_abs_error_;
+};
+
+// A 2-tuple ("binary") wrapper around FloatingEqMatcher:
+// FloatingEq2Matcher() matches (x, y) by matching FloatingEqMatcher(x, false)
+// against y, and FloatingEq2Matcher(e) matches FloatingEqMatcher(x, false, e)
+// against y. The former implements "Eq", the latter "Near". At present, there
+// is no version that compares NaNs as equal.
+template <typename FloatType>
+class FloatingEq2Matcher {
+ public:
+  FloatingEq2Matcher() { Init(-1, false); }
+
+  explicit FloatingEq2Matcher(bool nan_eq_nan) { Init(-1, nan_eq_nan); }
+
+  explicit FloatingEq2Matcher(FloatType max_abs_error) {
+    Init(max_abs_error, false);
+  }
+
+  FloatingEq2Matcher(FloatType max_abs_error, bool nan_eq_nan) {
+    Init(max_abs_error, nan_eq_nan);
+  }
+
+  template <typename T1, typename T2>
+  operator Matcher<::std::tuple<T1, T2>>() const {
+    return MakeMatcher(
+        new Impl<::std::tuple<T1, T2>>(max_abs_error_, nan_eq_nan_));
+  }
+  template <typename T1, typename T2>
+  operator Matcher<const ::std::tuple<T1, T2>&>() const {
+    return MakeMatcher(
+        new Impl<const ::std::tuple<T1, T2>&>(max_abs_error_, nan_eq_nan_));
+  }
+
+ private:
+  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT
+    return os << "an almost-equal pair";
+  }
+
+  template <typename Tuple>
+  class Impl : public MatcherInterface<Tuple> {
+   public:
+    Impl(FloatType max_abs_error, bool nan_eq_nan) :
+        max_abs_error_(max_abs_error),
+        nan_eq_nan_(nan_eq_nan) {}
+
+    bool MatchAndExplain(Tuple args,
+                         MatchResultListener* listener) const override {
+      if (max_abs_error_ == -1) {
+        FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_);
+        return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(
+            ::std::get<1>(args), listener);
+      } else {
+        FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_,
+                                        max_abs_error_);
+        return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(
+            ::std::get<1>(args), listener);
+      }
+    }
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "are " << GetDesc;
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "aren't " << GetDesc;
+    }
+
+   private:
+    FloatType max_abs_error_;
+    const bool nan_eq_nan_;
+  };
+
+  void Init(FloatType max_abs_error_val, bool nan_eq_nan_val) {
+    max_abs_error_ = max_abs_error_val;
+    nan_eq_nan_ = nan_eq_nan_val;
+  }
+  FloatType max_abs_error_;
+  bool nan_eq_nan_;
+};
+
+// Implements the Pointee(m) matcher for matching a pointer whose
+// pointee matches matcher m.  The pointer can be either raw or smart.
+template <typename InnerMatcher>
+class PointeeMatcher {
+ public:
+  explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
+
+  // This type conversion operator template allows Pointee(m) to be
+  // used as a matcher for any pointer type whose pointee type is
+  // compatible with the inner matcher, where type Pointer can be
+  // either a raw pointer or a smart pointer.
+  //
+  // The reason we do this instead of relying on
+  // MakePolymorphicMatcher() is that the latter is not flexible
+  // enough for implementing the DescribeTo() method of Pointee().
+  template <typename Pointer>
+  operator Matcher<Pointer>() const {
+    return Matcher<Pointer>(new Impl<const Pointer&>(matcher_));
+  }
+
+ private:
+  // The monomorphic implementation that works for a particular pointer type.
+  template <typename Pointer>
+  class Impl : public MatcherInterface<Pointer> {
+   public:
+    using Pointee =
+        typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
+            Pointer)>::element_type;
+
+    explicit Impl(const InnerMatcher& matcher)
+        : matcher_(MatcherCast<const Pointee&>(matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "points to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "does not point to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    bool MatchAndExplain(Pointer pointer,
+                         MatchResultListener* listener) const override {
+      if (GetRawPointer(pointer) == nullptr) return false;
+
+      *listener << "which points to ";
+      return MatchPrintAndExplain(*pointer, matcher_, listener);
+    }
+
+   private:
+    const Matcher<const Pointee&> matcher_;
+  };
+
+  const InnerMatcher matcher_;
+};
+
+// Implements the Pointer(m) matcher
+// Implements the Pointer(m) matcher for matching a pointer that matches matcher
+// m.  The pointer can be either raw or smart, and will match `m` against the
+// raw pointer.
+template <typename InnerMatcher>
+class PointerMatcher {
+ public:
+  explicit PointerMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
+
+  // This type conversion operator template allows Pointer(m) to be
+  // used as a matcher for any pointer type whose pointer type is
+  // compatible with the inner matcher, where type PointerType can be
+  // either a raw pointer or a smart pointer.
+  //
+  // The reason we do this instead of relying on
+  // MakePolymorphicMatcher() is that the latter is not flexible
+  // enough for implementing the DescribeTo() method of Pointer().
+  template <typename PointerType>
+  operator Matcher<PointerType>() const {  // NOLINT
+    return Matcher<PointerType>(new Impl<const PointerType&>(matcher_));
+  }
+
+ private:
+  // The monomorphic implementation that works for a particular pointer type.
+  template <typename PointerType>
+  class Impl : public MatcherInterface<PointerType> {
+   public:
+    using Pointer =
+        const typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
+            PointerType)>::element_type*;
+
+    explicit Impl(const InnerMatcher& matcher)
+        : matcher_(MatcherCast<Pointer>(matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "is a pointer that ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "is not a pointer that ";
+      matcher_.DescribeTo(os);
+    }
+
+    bool MatchAndExplain(PointerType pointer,
+                         MatchResultListener* listener) const override {
+      *listener << "which is a pointer that ";
+      Pointer p = GetRawPointer(pointer);
+      return MatchPrintAndExplain(p, matcher_, listener);
+    }
+
+   private:
+    Matcher<Pointer> matcher_;
+  };
+
+  const InnerMatcher matcher_;
+};
+
+#if GTEST_HAS_RTTI
+// Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or
+// reference that matches inner_matcher when dynamic_cast<T> is applied.
+// The result of dynamic_cast<To> is forwarded to the inner matcher.
+// If To is a pointer and the cast fails, the inner matcher will receive NULL.
+// If To is a reference and the cast fails, this matcher returns false
+// immediately.
+template <typename To>
+class WhenDynamicCastToMatcherBase {
+ public:
+  explicit WhenDynamicCastToMatcherBase(const Matcher<To>& matcher)
+      : matcher_(matcher) {}
+
+  void DescribeTo(::std::ostream* os) const {
+    GetCastTypeDescription(os);
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    GetCastTypeDescription(os);
+    matcher_.DescribeNegationTo(os);
+  }
+
+ protected:
+  const Matcher<To> matcher_;
+
+  static std::string GetToName() {
+    return GetTypeName<To>();
+  }
+
+ private:
+  static void GetCastTypeDescription(::std::ostream* os) {
+    *os << "when dynamic_cast to " << GetToName() << ", ";
+  }
+};
+
+// Primary template.
+// To is a pointer. Cast and forward the result.
+template <typename To>
+class WhenDynamicCastToMatcher : public WhenDynamicCastToMatcherBase<To> {
+ public:
+  explicit WhenDynamicCastToMatcher(const Matcher<To>& matcher)
+      : WhenDynamicCastToMatcherBase<To>(matcher) {}
+
+  template <typename From>
+  bool MatchAndExplain(From from, MatchResultListener* listener) const {
+    To to = dynamic_cast<To>(from);
+    return MatchPrintAndExplain(to, this->matcher_, listener);
+  }
+};
+
+// Specialize for references.
+// In this case we return false if the dynamic_cast fails.
+template <typename To>
+class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> {
+ public:
+  explicit WhenDynamicCastToMatcher(const Matcher<To&>& matcher)
+      : WhenDynamicCastToMatcherBase<To&>(matcher) {}
+
+  template <typename From>
+  bool MatchAndExplain(From& from, MatchResultListener* listener) const {
+    // We don't want an std::bad_cast here, so do the cast with pointers.
+    To* to = dynamic_cast<To*>(&from);
+    if (to == nullptr) {
+      *listener << "which cannot be dynamic_cast to " << this->GetToName();
+      return false;
+    }
+    return MatchPrintAndExplain(*to, this->matcher_, listener);
+  }
+};
+#endif  // GTEST_HAS_RTTI
+
+// Implements the Field() matcher for matching a field (i.e. member
+// variable) of an object.
+template <typename Class, typename FieldType>
+class FieldMatcher {
+ public:
+  FieldMatcher(FieldType Class::*field,
+               const Matcher<const FieldType&>& matcher)
+      : field_(field), matcher_(matcher), whose_field_("whose given field ") {}
+
+  FieldMatcher(const std::string& field_name, FieldType Class::*field,
+               const Matcher<const FieldType&>& matcher)
+      : field_(field),
+        matcher_(matcher),
+        whose_field_("whose field `" + field_name + "` ") {}
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "is an object " << whose_field_;
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is an object " << whose_field_;
+    matcher_.DescribeNegationTo(os);
+  }
+
+  template <typename T>
+  bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
+    // FIXME: The dispatch on std::is_pointer was introduced as a workaround for
+    // a compiler bug, and can now be removed.
+    return MatchAndExplainImpl(
+        typename std::is_pointer<typename std::remove_const<T>::type>::type(),
+        value, listener);
+  }
+
+ private:
+  bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,
+                           const Class& obj,
+                           MatchResultListener* listener) const {
+    *listener << whose_field_ << "is ";
+    return MatchPrintAndExplain(obj.*field_, matcher_, listener);
+  }
+
+  bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
+                           MatchResultListener* listener) const {
+    if (p == nullptr) return false;
+
+    *listener << "which points to an object ";
+    // Since *p has a field, it must be a class/struct/union type and
+    // thus cannot be a pointer.  Therefore we pass false_type() as
+    // the first argument.
+    return MatchAndExplainImpl(std::false_type(), *p, listener);
+  }
+
+  const FieldType Class::*field_;
+  const Matcher<const FieldType&> matcher_;
+
+  // Contains either "whose given field " if the name of the field is unknown
+  // or "whose field `name_of_field` " if the name is known.
+  const std::string whose_field_;
+};
+
+// Implements the Property() matcher for matching a property
+// (i.e. return value of a getter method) of an object.
+//
+// Property is a const-qualified member function of Class returning
+// PropertyType.
+template <typename Class, typename PropertyType, typename Property>
+class PropertyMatcher {
+ public:
+  typedef const PropertyType& RefToConstProperty;
+
+  PropertyMatcher(Property property, const Matcher<RefToConstProperty>& matcher)
+      : property_(property),
+        matcher_(matcher),
+        whose_property_("whose given property ") {}
+
+  PropertyMatcher(const std::string& property_name, Property property,
+                  const Matcher<RefToConstProperty>& matcher)
+      : property_(property),
+        matcher_(matcher),
+        whose_property_("whose property `" + property_name + "` ") {}
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "is an object " << whose_property_;
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is an object " << whose_property_;
+    matcher_.DescribeNegationTo(os);
+  }
+
+  template <typename T>
+  bool MatchAndExplain(const T&value, MatchResultListener* listener) const {
+    return MatchAndExplainImpl(
+        typename std::is_pointer<typename std::remove_const<T>::type>::type(),
+        value, listener);
+  }
+
+ private:
+  bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,
+                           const Class& obj,
+                           MatchResultListener* listener) const {
+    *listener << whose_property_ << "is ";
+    // Cannot pass the return value (for example, int) to MatchPrintAndExplain,
+    // which takes a non-const reference as argument.
+    RefToConstProperty result = (obj.*property_)();
+    return MatchPrintAndExplain(result, matcher_, listener);
+  }
+
+  bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
+                           MatchResultListener* listener) const {
+    if (p == nullptr) return false;
+
+    *listener << "which points to an object ";
+    // Since *p has a property method, it must be a class/struct/union
+    // type and thus cannot be a pointer.  Therefore we pass
+    // false_type() as the first argument.
+    return MatchAndExplainImpl(std::false_type(), *p, listener);
+  }
+
+  Property property_;
+  const Matcher<RefToConstProperty> matcher_;
+
+  // Contains either "whose given property " if the name of the property is
+  // unknown or "whose property `name_of_property` " if the name is known.
+  const std::string whose_property_;
+};
+
+// Type traits specifying various features of different functors for ResultOf.
+// The default template specifies features for functor objects.
+template <typename Functor>
+struct CallableTraits {
+  typedef Functor StorageType;
+
+  static void CheckIsValid(Functor /* functor */) {}
+
+  template <typename T>
+  static auto Invoke(Functor f, const T& arg) -> decltype(f(arg)) {
+    return f(arg);
+  }
+};
+
+// Specialization for function pointers.
+template <typename ArgType, typename ResType>
+struct CallableTraits<ResType(*)(ArgType)> {
+  typedef ResType ResultType;
+  typedef ResType(*StorageType)(ArgType);
+
+  static void CheckIsValid(ResType(*f)(ArgType)) {
+    GTEST_CHECK_(f != nullptr)
+        << "NULL function pointer is passed into ResultOf().";
+  }
+  template <typename T>
+  static ResType Invoke(ResType(*f)(ArgType), T arg) {
+    return (*f)(arg);
+  }
+};
+
+// Implements the ResultOf() matcher for matching a return value of a
+// unary function of an object.
+template <typename Callable, typename InnerMatcher>
+class ResultOfMatcher {
+ public:
+  ResultOfMatcher(Callable callable, InnerMatcher matcher)
+      : callable_(std::move(callable)), matcher_(std::move(matcher)) {
+    CallableTraits<Callable>::CheckIsValid(callable_);
+  }
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new Impl<const T&>(callable_, matcher_));
+  }
+
+ private:
+  typedef typename CallableTraits<Callable>::StorageType CallableStorageType;
+
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+    using ResultType = decltype(CallableTraits<Callable>::template Invoke<T>(
+        std::declval<CallableStorageType>(), std::declval<T>()));
+
+   public:
+    template <typename M>
+    Impl(const CallableStorageType& callable, const M& matcher)
+        : callable_(callable), matcher_(MatcherCast<ResultType>(matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "is mapped by the given callable to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "is mapped by the given callable to a value that ";
+      matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(T obj, MatchResultListener* listener) const override {
+      *listener << "which is mapped by the given callable to ";
+      // Cannot pass the return value directly to MatchPrintAndExplain, which
+      // takes a non-const reference as argument.
+      // Also, specifying template argument explicitly is needed because T could
+      // be a non-const reference (e.g. Matcher<Uncopyable&>).
+      ResultType result =
+          CallableTraits<Callable>::template Invoke<T>(callable_, obj);
+      return MatchPrintAndExplain(result, matcher_, listener);
+    }
+
+   private:
+    // Functors often define operator() as non-const method even though
+    // they are actually stateless. But we need to use them even when
+    // 'this' is a const pointer. It's the user's responsibility not to
+    // use stateful callables with ResultOf(), which doesn't guarantee
+    // how many times the callable will be invoked.
+    mutable CallableStorageType callable_;
+    const Matcher<ResultType> matcher_;
+  };  // class Impl
+
+  const CallableStorageType callable_;
+  const InnerMatcher matcher_;
+};
+
+// Implements a matcher that checks the size of an STL-style container.
+template <typename SizeMatcher>
+class SizeIsMatcher {
+ public:
+  explicit SizeIsMatcher(const SizeMatcher& size_matcher)
+       : size_matcher_(size_matcher) {
+  }
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return Matcher<Container>(new Impl<const Container&>(size_matcher_));
+  }
+
+  template <typename Container>
+  class Impl : public MatcherInterface<Container> {
+   public:
+    using SizeType = decltype(std::declval<Container>().size());
+    explicit Impl(const SizeMatcher& size_matcher)
+        : size_matcher_(MatcherCast<SizeType>(size_matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "size ";
+      size_matcher_.DescribeTo(os);
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "size ";
+      size_matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(Container container,
+                         MatchResultListener* listener) const override {
+      SizeType size = container.size();
+      StringMatchResultListener size_listener;
+      const bool result = size_matcher_.MatchAndExplain(size, &size_listener);
+      *listener
+          << "whose size " << size << (result ? " matches" : " doesn't match");
+      PrintIfNotEmpty(size_listener.str(), listener->stream());
+      return result;
+    }
+
+   private:
+    const Matcher<SizeType> size_matcher_;
+  };
+
+ private:
+  const SizeMatcher size_matcher_;
+};
+
+// Implements a matcher that checks the begin()..end() distance of an STL-style
+// container.
+template <typename DistanceMatcher>
+class BeginEndDistanceIsMatcher {
+ public:
+  explicit BeginEndDistanceIsMatcher(const DistanceMatcher& distance_matcher)
+      : distance_matcher_(distance_matcher) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return Matcher<Container>(new Impl<const Container&>(distance_matcher_));
+  }
+
+  template <typename Container>
+  class Impl : public MatcherInterface<Container> {
+   public:
+    typedef internal::StlContainerView<
+        GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
+    typedef typename std::iterator_traits<
+        typename ContainerView::type::const_iterator>::difference_type
+        DistanceType;
+    explicit Impl(const DistanceMatcher& distance_matcher)
+        : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "distance between begin() and end() ";
+      distance_matcher_.DescribeTo(os);
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "distance between begin() and end() ";
+      distance_matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(Container container,
+                         MatchResultListener* listener) const override {
+      using std::begin;
+      using std::end;
+      DistanceType distance = std::distance(begin(container), end(container));
+      StringMatchResultListener distance_listener;
+      const bool result =
+          distance_matcher_.MatchAndExplain(distance, &distance_listener);
+      *listener << "whose distance between begin() and end() " << distance
+                << (result ? " matches" : " doesn't match");
+      PrintIfNotEmpty(distance_listener.str(), listener->stream());
+      return result;
+    }
+
+   private:
+    const Matcher<DistanceType> distance_matcher_;
+  };
+
+ private:
+  const DistanceMatcher distance_matcher_;
+};
+
+// Implements an equality matcher for any STL-style container whose elements
+// support ==. This matcher is like Eq(), but its failure explanations provide
+// more detailed information that is useful when the container is used as a set.
+// The failure message reports elements that are in one of the operands but not
+// the other. The failure messages do not report duplicate or out-of-order
+// elements in the containers (which don't properly matter to sets, but can
+// occur if the containers are vectors or lists, for example).
+//
+// Uses the container's const_iterator, value_type, operator ==,
+// begin(), and end().
+template <typename Container>
+class ContainerEqMatcher {
+ public:
+  typedef internal::StlContainerView<Container> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+
+  static_assert(!std::is_const<Container>::value,
+                "Container type must not be const");
+  static_assert(!std::is_reference<Container>::value,
+                "Container type must not be a reference");
+
+  // We make a copy of expected in case the elements in it are modified
+  // after this matcher is created.
+  explicit ContainerEqMatcher(const Container& expected)
+      : expected_(View::Copy(expected)) {}
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "equals ";
+    UniversalPrint(expected_, os);
+  }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "does not equal ";
+    UniversalPrint(expected_, os);
+  }
+
+  template <typename LhsContainer>
+  bool MatchAndExplain(const LhsContainer& lhs,
+                       MatchResultListener* listener) const {
+    typedef internal::StlContainerView<
+        typename std::remove_const<LhsContainer>::type>
+        LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+    if (lhs_stl_container == expected_)
+      return true;
+
+    ::std::ostream* const os = listener->stream();
+    if (os != nullptr) {
+      // Something is different. Check for extra values first.
+      bool printed_header = false;
+      for (typename LhsStlContainer::const_iterator it =
+               lhs_stl_container.begin();
+           it != lhs_stl_container.end(); ++it) {
+        if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) ==
+            expected_.end()) {
+          if (printed_header) {
+            *os << ", ";
+          } else {
+            *os << "which has these unexpected elements: ";
+            printed_header = true;
+          }
+          UniversalPrint(*it, os);
+        }
+      }
+
+      // Now check for missing values.
+      bool printed_header2 = false;
+      for (typename StlContainer::const_iterator it = expected_.begin();
+           it != expected_.end(); ++it) {
+        if (internal::ArrayAwareFind(
+                lhs_stl_container.begin(), lhs_stl_container.end(), *it) ==
+            lhs_stl_container.end()) {
+          if (printed_header2) {
+            *os << ", ";
+          } else {
+            *os << (printed_header ? ",\nand" : "which")
+                << " doesn't have these expected elements: ";
+            printed_header2 = true;
+          }
+          UniversalPrint(*it, os);
+        }
+      }
+    }
+
+    return false;
+  }
+
+ private:
+  const StlContainer expected_;
+};
+
+// A comparator functor that uses the < operator to compare two values.
+struct LessComparator {
+  template <typename T, typename U>
+  bool operator()(const T& lhs, const U& rhs) const { return lhs < rhs; }
+};
+
+// Implements WhenSortedBy(comparator, container_matcher).
+template <typename Comparator, typename ContainerMatcher>
+class WhenSortedByMatcher {
+ public:
+  WhenSortedByMatcher(const Comparator& comparator,
+                      const ContainerMatcher& matcher)
+      : comparator_(comparator), matcher_(matcher) {}
+
+  template <typename LhsContainer>
+  operator Matcher<LhsContainer>() const {
+    return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_));
+  }
+
+  template <typename LhsContainer>
+  class Impl : public MatcherInterface<LhsContainer> {
+   public:
+    typedef internal::StlContainerView<
+         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    typedef typename LhsView::const_reference LhsStlContainerReference;
+    // Transforms std::pair<const Key, Value> into std::pair<Key, Value>
+    // so that we can match associative containers.
+    typedef typename RemoveConstFromKey<
+        typename LhsStlContainer::value_type>::type LhsValue;
+
+    Impl(const Comparator& comparator, const ContainerMatcher& matcher)
+        : comparator_(comparator), matcher_(matcher) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "(when sorted) ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "(when sorted) ";
+      matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(LhsContainer lhs,
+                         MatchResultListener* listener) const override {
+      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+      ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),
+                                               lhs_stl_container.end());
+      ::std::sort(
+           sorted_container.begin(), sorted_container.end(), comparator_);
+
+      if (!listener->IsInterested()) {
+        // If the listener is not interested, we do not need to
+        // construct the inner explanation.
+        return matcher_.Matches(sorted_container);
+      }
+
+      *listener << "which is ";
+      UniversalPrint(sorted_container, listener->stream());
+      *listener << " when sorted";
+
+      StringMatchResultListener inner_listener;
+      const bool match = matcher_.MatchAndExplain(sorted_container,
+                                                  &inner_listener);
+      PrintIfNotEmpty(inner_listener.str(), listener->stream());
+      return match;
+    }
+
+   private:
+    const Comparator comparator_;
+    const Matcher<const ::std::vector<LhsValue>&> matcher_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
+  };
+
+ private:
+  const Comparator comparator_;
+  const ContainerMatcher matcher_;
+};
+
+// Implements Pointwise(tuple_matcher, rhs_container).  tuple_matcher
+// must be able to be safely cast to Matcher<std::tuple<const T1&, const
+// T2&> >, where T1 and T2 are the types of elements in the LHS
+// container and the RHS container respectively.
+template <typename TupleMatcher, typename RhsContainer>
+class PointwiseMatcher {
+  GTEST_COMPILE_ASSERT_(
+      !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>::value,
+      use_UnorderedPointwise_with_hash_tables);
+
+ public:
+  typedef internal::StlContainerView<RhsContainer> RhsView;
+  typedef typename RhsView::type RhsStlContainer;
+  typedef typename RhsStlContainer::value_type RhsValue;
+
+  static_assert(!std::is_const<RhsContainer>::value,
+                "RhsContainer type must not be const");
+  static_assert(!std::is_reference<RhsContainer>::value,
+                "RhsContainer type must not be a reference");
+
+  // Like ContainerEq, we make a copy of rhs in case the elements in
+  // it are modified after this matcher is created.
+  PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer& rhs)
+      : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {}
+
+  template <typename LhsContainer>
+  operator Matcher<LhsContainer>() const {
+    GTEST_COMPILE_ASSERT_(
+        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)>::value,
+        use_UnorderedPointwise_with_hash_tables);
+
+    return Matcher<LhsContainer>(
+        new Impl<const LhsContainer&>(tuple_matcher_, rhs_));
+  }
+
+  template <typename LhsContainer>
+  class Impl : public MatcherInterface<LhsContainer> {
+   public:
+    typedef internal::StlContainerView<
+         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    typedef typename LhsView::const_reference LhsStlContainerReference;
+    typedef typename LhsStlContainer::value_type LhsValue;
+    // We pass the LHS value and the RHS value to the inner matcher by
+    // reference, as they may be expensive to copy.  We must use tuple
+    // instead of pair here, as a pair cannot hold references (C++ 98,
+    // 20.2.2 [lib.pairs]).
+    typedef ::std::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg;
+
+    Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs)
+        // mono_tuple_matcher_ holds a monomorphic version of the tuple matcher.
+        : mono_tuple_matcher_(SafeMatcherCast<InnerMatcherArg>(tuple_matcher)),
+          rhs_(rhs) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "contains " << rhs_.size()
+          << " values, where each value and its corresponding value in ";
+      UniversalPrinter<RhsStlContainer>::Print(rhs_, os);
+      *os << " ";
+      mono_tuple_matcher_.DescribeTo(os);
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "doesn't contain exactly " << rhs_.size()
+          << " values, or contains a value x at some index i"
+          << " where x and the i-th value of ";
+      UniversalPrint(rhs_, os);
+      *os << " ";
+      mono_tuple_matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(LhsContainer lhs,
+                         MatchResultListener* listener) const override {
+      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+      const size_t actual_size = lhs_stl_container.size();
+      if (actual_size != rhs_.size()) {
+        *listener << "which contains " << actual_size << " values";
+        return false;
+      }
+
+      typename LhsStlContainer::const_iterator left = lhs_stl_container.begin();
+      typename RhsStlContainer::const_iterator right = rhs_.begin();
+      for (size_t i = 0; i != actual_size; ++i, ++left, ++right) {
+        if (listener->IsInterested()) {
+          StringMatchResultListener inner_listener;
+          // Create InnerMatcherArg as a temporarily object to avoid it outlives
+          // *left and *right. Dereference or the conversion to `const T&` may
+          // return temp objects, e.g for vector<bool>.
+          if (!mono_tuple_matcher_.MatchAndExplain(
+                  InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left),
+                                  ImplicitCast_<const RhsValue&>(*right)),
+                  &inner_listener)) {
+            *listener << "where the value pair (";
+            UniversalPrint(*left, listener->stream());
+            *listener << ", ";
+            UniversalPrint(*right, listener->stream());
+            *listener << ") at index #" << i << " don't match";
+            PrintIfNotEmpty(inner_listener.str(), listener->stream());
+            return false;
+          }
+        } else {
+          if (!mono_tuple_matcher_.Matches(
+                  InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left),
+                                  ImplicitCast_<const RhsValue&>(*right))))
+            return false;
+        }
+      }
+
+      return true;
+    }
+
+   private:
+    const Matcher<InnerMatcherArg> mono_tuple_matcher_;
+    const RhsStlContainer rhs_;
+  };
+
+ private:
+  const TupleMatcher tuple_matcher_;
+  const RhsStlContainer rhs_;
+};
+
+// Holds the logic common to ContainsMatcherImpl and EachMatcherImpl.
+template <typename Container>
+class QuantifierMatcherImpl : public MatcherInterface<Container> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::value_type Element;
+
+  template <typename InnerMatcher>
+  explicit QuantifierMatcherImpl(InnerMatcher inner_matcher)
+      : inner_matcher_(
+           testing::SafeMatcherCast<const Element&>(inner_matcher)) {}
+
+  // Checks whether:
+  // * All elements in the container match, if all_elements_should_match.
+  // * Any element in the container matches, if !all_elements_should_match.
+  bool MatchAndExplainImpl(bool all_elements_should_match,
+                           Container container,
+                           MatchResultListener* listener) const {
+    StlContainerReference stl_container = View::ConstReference(container);
+    size_t i = 0;
+    for (typename StlContainer::const_iterator it = stl_container.begin();
+         it != stl_container.end(); ++it, ++i) {
+      StringMatchResultListener inner_listener;
+      const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);
+
+      if (matches != all_elements_should_match) {
+        *listener << "whose element #" << i
+                  << (matches ? " matches" : " doesn't match");
+        PrintIfNotEmpty(inner_listener.str(), listener->stream());
+        return !all_elements_should_match;
+      }
+    }
+    return all_elements_should_match;
+  }
+
+ protected:
+  const Matcher<const Element&> inner_matcher_;
+};
+
+// Implements Contains(element_matcher) for the given argument type Container.
+// Symmetric to EachMatcherImpl.
+template <typename Container>
+class ContainsMatcherImpl : public QuantifierMatcherImpl<Container> {
+ public:
+  template <typename InnerMatcher>
+  explicit ContainsMatcherImpl(InnerMatcher inner_matcher)
+      : QuantifierMatcherImpl<Container>(inner_matcher) {}
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "contains at least one element that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "doesn't contain any element that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    return this->MatchAndExplainImpl(false, container, listener);
+  }
+};
+
+// Implements Each(element_matcher) for the given argument type Container.
+// Symmetric to ContainsMatcherImpl.
+template <typename Container>
+class EachMatcherImpl : public QuantifierMatcherImpl<Container> {
+ public:
+  template <typename InnerMatcher>
+  explicit EachMatcherImpl(InnerMatcher inner_matcher)
+      : QuantifierMatcherImpl<Container>(inner_matcher) {}
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "only contains elements that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "contains some element that ";
+    this->inner_matcher_.DescribeNegationTo(os);
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    return this->MatchAndExplainImpl(true, container, listener);
+  }
+};
+
+// Implements polymorphic Contains(element_matcher).
+template <typename M>
+class ContainsMatcher {
+ public:
+  explicit ContainsMatcher(M m) : inner_matcher_(m) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return Matcher<Container>(
+        new ContainsMatcherImpl<const Container&>(inner_matcher_));
+  }
+
+ private:
+  const M inner_matcher_;
+};
+
+// Implements polymorphic Each(element_matcher).
+template <typename M>
+class EachMatcher {
+ public:
+  explicit EachMatcher(M m) : inner_matcher_(m) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return Matcher<Container>(
+        new EachMatcherImpl<const Container&>(inner_matcher_));
+  }
+
+ private:
+  const M inner_matcher_;
+};
+
+struct Rank1 {};
+struct Rank0 : Rank1 {};
+
+namespace pair_getters {
+using std::get;
+template <typename T>
+auto First(T& x, Rank1) -> decltype(get<0>(x)) {  // NOLINT
+  return get<0>(x);
+}
+template <typename T>
+auto First(T& x, Rank0) -> decltype((x.first)) {  // NOLINT
+  return x.first;
+}
+
+template <typename T>
+auto Second(T& x, Rank1) -> decltype(get<1>(x)) {  // NOLINT
+  return get<1>(x);
+}
+template <typename T>
+auto Second(T& x, Rank0) -> decltype((x.second)) {  // NOLINT
+  return x.second;
+}
+}  // namespace pair_getters
+
+// Implements Key(inner_matcher) for the given argument pair type.
+// Key(inner_matcher) matches an std::pair whose 'first' field matches
+// inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
+// std::map that contains at least one element whose key is >= 5.
+template <typename PairType>
+class KeyMatcherImpl : public MatcherInterface<PairType> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
+  typedef typename RawPairType::first_type KeyType;
+
+  template <typename InnerMatcher>
+  explicit KeyMatcherImpl(InnerMatcher inner_matcher)
+      : inner_matcher_(
+          testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {
+  }
+
+  // Returns true if and only if 'key_value.first' (the key) matches the inner
+  // matcher.
+  bool MatchAndExplain(PairType key_value,
+                       MatchResultListener* listener) const override {
+    StringMatchResultListener inner_listener;
+    const bool match = inner_matcher_.MatchAndExplain(
+        pair_getters::First(key_value, Rank0()), &inner_listener);
+    const std::string explanation = inner_listener.str();
+    if (explanation != "") {
+      *listener << "whose first field is a value " << explanation;
+    }
+    return match;
+  }
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "has a key that ";
+    inner_matcher_.DescribeTo(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "doesn't have a key that ";
+    inner_matcher_.DescribeTo(os);
+  }
+
+ private:
+  const Matcher<const KeyType&> inner_matcher_;
+};
+
+// Implements polymorphic Key(matcher_for_key).
+template <typename M>
+class KeyMatcher {
+ public:
+  explicit KeyMatcher(M m) : matcher_for_key_(m) {}
+
+  template <typename PairType>
+  operator Matcher<PairType>() const {
+    return Matcher<PairType>(
+        new KeyMatcherImpl<const PairType&>(matcher_for_key_));
+  }
+
+ private:
+  const M matcher_for_key_;
+};
+
+// Implements polymorphic Address(matcher_for_address).
+template <typename InnerMatcher>
+class AddressMatcher {
+ public:
+  explicit AddressMatcher(InnerMatcher m) : matcher_(m) {}
+
+  template <typename Type>
+  operator Matcher<Type>() const {  // NOLINT
+    return Matcher<Type>(new Impl<const Type&>(matcher_));
+  }
+
+ private:
+  // The monomorphic implementation that works for a particular object type.
+  template <typename Type>
+  class Impl : public MatcherInterface<Type> {
+   public:
+    using Address = const GTEST_REMOVE_REFERENCE_AND_CONST_(Type) *;
+    explicit Impl(const InnerMatcher& matcher)
+        : matcher_(MatcherCast<Address>(matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "has address that ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "does not have address that ";
+      matcher_.DescribeTo(os);
+    }
+
+    bool MatchAndExplain(Type object,
+                         MatchResultListener* listener) const override {
+      *listener << "which has address ";
+      Address address = std::addressof(object);
+      return MatchPrintAndExplain(address, matcher_, listener);
+    }
+
+   private:
+    const Matcher<Address> matcher_;
+  };
+  const InnerMatcher matcher_;
+};
+
+// Implements Pair(first_matcher, second_matcher) for the given argument pair
+// type with its two matchers. See Pair() function below.
+template <typename PairType>
+class PairMatcherImpl : public MatcherInterface<PairType> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
+  typedef typename RawPairType::first_type FirstType;
+  typedef typename RawPairType::second_type SecondType;
+
+  template <typename FirstMatcher, typename SecondMatcher>
+  PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher)
+      : first_matcher_(
+            testing::SafeMatcherCast<const FirstType&>(first_matcher)),
+        second_matcher_(
+            testing::SafeMatcherCast<const SecondType&>(second_matcher)) {
+  }
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "has a first field that ";
+    first_matcher_.DescribeTo(os);
+    *os << ", and has a second field that ";
+    second_matcher_.DescribeTo(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "has a first field that ";
+    first_matcher_.DescribeNegationTo(os);
+    *os << ", or has a second field that ";
+    second_matcher_.DescribeNegationTo(os);
+  }
+
+  // Returns true if and only if 'a_pair.first' matches first_matcher and
+  // 'a_pair.second' matches second_matcher.
+  bool MatchAndExplain(PairType a_pair,
+                       MatchResultListener* listener) const override {
+    if (!listener->IsInterested()) {
+      // If the listener is not interested, we don't need to construct the
+      // explanation.
+      return first_matcher_.Matches(pair_getters::First(a_pair, Rank0())) &&
+             second_matcher_.Matches(pair_getters::Second(a_pair, Rank0()));
+    }
+    StringMatchResultListener first_inner_listener;
+    if (!first_matcher_.MatchAndExplain(pair_getters::First(a_pair, Rank0()),
+                                        &first_inner_listener)) {
+      *listener << "whose first field does not match";
+      PrintIfNotEmpty(first_inner_listener.str(), listener->stream());
+      return false;
+    }
+    StringMatchResultListener second_inner_listener;
+    if (!second_matcher_.MatchAndExplain(pair_getters::Second(a_pair, Rank0()),
+                                         &second_inner_listener)) {
+      *listener << "whose second field does not match";
+      PrintIfNotEmpty(second_inner_listener.str(), listener->stream());
+      return false;
+    }
+    ExplainSuccess(first_inner_listener.str(), second_inner_listener.str(),
+                   listener);
+    return true;
+  }
+
+ private:
+  void ExplainSuccess(const std::string& first_explanation,
+                      const std::string& second_explanation,
+                      MatchResultListener* listener) const {
+    *listener << "whose both fields match";
+    if (first_explanation != "") {
+      *listener << ", where the first field is a value " << first_explanation;
+    }
+    if (second_explanation != "") {
+      *listener << ", ";
+      if (first_explanation != "") {
+        *listener << "and ";
+      } else {
+        *listener << "where ";
+      }
+      *listener << "the second field is a value " << second_explanation;
+    }
+  }
+
+  const Matcher<const FirstType&> first_matcher_;
+  const Matcher<const SecondType&> second_matcher_;
+};
+
+// Implements polymorphic Pair(first_matcher, second_matcher).
+template <typename FirstMatcher, typename SecondMatcher>
+class PairMatcher {
+ public:
+  PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher)
+      : first_matcher_(first_matcher), second_matcher_(second_matcher) {}
+
+  template <typename PairType>
+  operator Matcher<PairType> () const {
+    return Matcher<PairType>(
+        new PairMatcherImpl<const PairType&>(first_matcher_, second_matcher_));
+  }
+
+ private:
+  const FirstMatcher first_matcher_;
+  const SecondMatcher second_matcher_;
+};
+
+template <typename T, size_t... I>
+auto UnpackStructImpl(const T& t, IndexSequence<I...>, int)
+    -> decltype(std::tie(get<I>(t)...)) {
+  static_assert(std::tuple_size<T>::value == sizeof...(I),
+                "Number of arguments doesn't match the number of fields.");
+  return std::tie(get<I>(t)...);
+}
+
+#if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 201606
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<1>, char) {
+  const auto& [a] = t;
+  return std::tie(a);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<2>, char) {
+  const auto& [a, b] = t;
+  return std::tie(a, b);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<3>, char) {
+  const auto& [a, b, c] = t;
+  return std::tie(a, b, c);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<4>, char) {
+  const auto& [a, b, c, d] = t;
+  return std::tie(a, b, c, d);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<5>, char) {
+  const auto& [a, b, c, d, e] = t;
+  return std::tie(a, b, c, d, e);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<6>, char) {
+  const auto& [a, b, c, d, e, f] = t;
+  return std::tie(a, b, c, d, e, f);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<7>, char) {
+  const auto& [a, b, c, d, e, f, g] = t;
+  return std::tie(a, b, c, d, e, f, g);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<8>, char) {
+  const auto& [a, b, c, d, e, f, g, h] = t;
+  return std::tie(a, b, c, d, e, f, g, h);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<9>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<10>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<11>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<12>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<13>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<14>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<15>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<16>, char) {
+  const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = t;
+  return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
+}
+#endif  // defined(__cpp_structured_bindings)
+
+template <size_t I, typename T>
+auto UnpackStruct(const T& t)
+    -> decltype((UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0)) {
+  return (UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0);
+}
+
+// Helper function to do comma folding in C++11.
+// The array ensures left-to-right order of evaluation.
+// Usage: VariadicExpand({expr...});
+template <typename T, size_t N>
+void VariadicExpand(const T (&)[N]) {}
+
+template <typename Struct, typename StructSize>
+class FieldsAreMatcherImpl;
+
+template <typename Struct, size_t... I>
+class FieldsAreMatcherImpl<Struct, IndexSequence<I...>>
+    : public MatcherInterface<Struct> {
+  using UnpackedType =
+      decltype(UnpackStruct<sizeof...(I)>(std::declval<const Struct&>()));
+  using MatchersType = std::tuple<
+      Matcher<const typename std::tuple_element<I, UnpackedType>::type&>...>;
+
+ public:
+  template <typename Inner>
+  explicit FieldsAreMatcherImpl(const Inner& matchers)
+      : matchers_(testing::SafeMatcherCast<
+                  const typename std::tuple_element<I, UnpackedType>::type&>(
+            std::get<I>(matchers))...) {}
+
+  void DescribeTo(::std::ostream* os) const override {
+    const char* separator = "";
+    VariadicExpand(
+        {(*os << separator << "has field #" << I << " that ",
+          std::get<I>(matchers_).DescribeTo(os), separator = ", and ")...});
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    const char* separator = "";
+    VariadicExpand({(*os << separator << "has field #" << I << " that ",
+                     std::get<I>(matchers_).DescribeNegationTo(os),
+                     separator = ", or ")...});
+  }
+
+  bool MatchAndExplain(Struct t, MatchResultListener* listener) const override {
+    return MatchInternal((UnpackStruct<sizeof...(I)>)(t), listener);
+  }
+
+ private:
+  bool MatchInternal(UnpackedType tuple, MatchResultListener* listener) const {
+    if (!listener->IsInterested()) {
+      // If the listener is not interested, we don't need to construct the
+      // explanation.
+      bool good = true;
+      VariadicExpand({good = good && std::get<I>(matchers_).Matches(
+                                         std::get<I>(tuple))...});
+      return good;
+    }
+
+    size_t failed_pos = ~size_t{};
+
+    std::vector<StringMatchResultListener> inner_listener(sizeof...(I));
+
+    VariadicExpand(
+        {failed_pos == ~size_t{} && !std::get<I>(matchers_).MatchAndExplain(
+                                        std::get<I>(tuple), &inner_listener[I])
+             ? failed_pos = I
+             : 0 ...});
+    if (failed_pos != ~size_t{}) {
+      *listener << "whose field #" << failed_pos << " does not match";
+      PrintIfNotEmpty(inner_listener[failed_pos].str(), listener->stream());
+      return false;
+    }
+
+    *listener << "whose all elements match";
+    const char* separator = ", where";
+    for (size_t index = 0; index < sizeof...(I); ++index) {
+      const std::string str = inner_listener[index].str();
+      if (!str.empty()) {
+        *listener << separator << " field #" << index << " is a value " << str;
+        separator = ", and";
+      }
+    }
+
+    return true;
+  }
+
+  MatchersType matchers_;
+};
+
+template <typename... Inner>
+class FieldsAreMatcher {
+ public:
+  explicit FieldsAreMatcher(Inner... inner) : matchers_(std::move(inner)...) {}
+
+  template <typename Struct>
+  operator Matcher<Struct>() const {  // NOLINT
+    return Matcher<Struct>(
+        new FieldsAreMatcherImpl<const Struct&, IndexSequenceFor<Inner...>>(
+            matchers_));
+  }
+
+ private:
+  std::tuple<Inner...> matchers_;
+};
+
+// Implements ElementsAre() and ElementsAreArray().
+template <typename Container>
+class ElementsAreMatcherImpl : public MatcherInterface<Container> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef internal::StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::value_type Element;
+
+  // Constructs the matcher from a sequence of element values or
+  // element matchers.
+  template <typename InputIter>
+  ElementsAreMatcherImpl(InputIter first, InputIter last) {
+    while (first != last) {
+      matchers_.push_back(MatcherCast<const Element&>(*first++));
+    }
+  }
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    if (count() == 0) {
+      *os << "is empty";
+    } else if (count() == 1) {
+      *os << "has 1 element that ";
+      matchers_[0].DescribeTo(os);
+    } else {
+      *os << "has " << Elements(count()) << " where\n";
+      for (size_t i = 0; i != count(); ++i) {
+        *os << "element #" << i << " ";
+        matchers_[i].DescribeTo(os);
+        if (i + 1 < count()) {
+          *os << ",\n";
+        }
+      }
+    }
+  }
+
+  // Describes what the negation of this matcher does.
+  void DescribeNegationTo(::std::ostream* os) const override {
+    if (count() == 0) {
+      *os << "isn't empty";
+      return;
+    }
+
+    *os << "doesn't have " << Elements(count()) << ", or\n";
+    for (size_t i = 0; i != count(); ++i) {
+      *os << "element #" << i << " ";
+      matchers_[i].DescribeNegationTo(os);
+      if (i + 1 < count()) {
+        *os << ", or\n";
+      }
+    }
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    // To work with stream-like "containers", we must only walk
+    // through the elements in one pass.
+
+    const bool listener_interested = listener->IsInterested();
+
+    // explanations[i] is the explanation of the element at index i.
+    ::std::vector<std::string> explanations(count());
+    StlContainerReference stl_container = View::ConstReference(container);
+    typename StlContainer::const_iterator it = stl_container.begin();
+    size_t exam_pos = 0;
+    bool mismatch_found = false;  // Have we found a mismatched element yet?
+
+    // Go through the elements and matchers in pairs, until we reach
+    // the end of either the elements or the matchers, or until we find a
+    // mismatch.
+    for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) {
+      bool match;  // Does the current element match the current matcher?
+      if (listener_interested) {
+        StringMatchResultListener s;
+        match = matchers_[exam_pos].MatchAndExplain(*it, &s);
+        explanations[exam_pos] = s.str();
+      } else {
+        match = matchers_[exam_pos].Matches(*it);
+      }
+
+      if (!match) {
+        mismatch_found = true;
+        break;
+      }
+    }
+    // If mismatch_found is true, 'exam_pos' is the index of the mismatch.
+
+    // Find how many elements the actual container has.  We avoid
+    // calling size() s.t. this code works for stream-like "containers"
+    // that don't define size().
+    size_t actual_count = exam_pos;
+    for (; it != stl_container.end(); ++it) {
+      ++actual_count;
+    }
+
+    if (actual_count != count()) {
+      // The element count doesn't match.  If the container is empty,
+      // there's no need to explain anything as Google Mock already
+      // prints the empty container.  Otherwise we just need to show
+      // how many elements there actually are.
+      if (listener_interested && (actual_count != 0)) {
+        *listener << "which has " << Elements(actual_count);
+      }
+      return false;
+    }
+
+    if (mismatch_found) {
+      // The element count matches, but the exam_pos-th element doesn't match.
+      if (listener_interested) {
+        *listener << "whose element #" << exam_pos << " doesn't match";
+        PrintIfNotEmpty(explanations[exam_pos], listener->stream());
+      }
+      return false;
+    }
+
+    // Every element matches its expectation.  We need to explain why
+    // (the obvious ones can be skipped).
+    if (listener_interested) {
+      bool reason_printed = false;
+      for (size_t i = 0; i != count(); ++i) {
+        const std::string& s = explanations[i];
+        if (!s.empty()) {
+          if (reason_printed) {
+            *listener << ",\nand ";
+          }
+          *listener << "whose element #" << i << " matches, " << s;
+          reason_printed = true;
+        }
+      }
+    }
+    return true;
+  }
+
+ private:
+  static Message Elements(size_t count) {
+    return Message() << count << (count == 1 ? " element" : " elements");
+  }
+
+  size_t count() const { return matchers_.size(); }
+
+  ::std::vector<Matcher<const Element&> > matchers_;
+};
+
+// Connectivity matrix of (elements X matchers), in element-major order.
+// Initially, there are no edges.
+// Use NextGraph() to iterate over all possible edge configurations.
+// Use Randomize() to generate a random edge configuration.
+class GTEST_API_ MatchMatrix {
+ public:
+  MatchMatrix(size_t num_elements, size_t num_matchers)
+      : num_elements_(num_elements),
+        num_matchers_(num_matchers),
+        matched_(num_elements_* num_matchers_, 0) {
+  }
+
+  size_t LhsSize() const { return num_elements_; }
+  size_t RhsSize() const { return num_matchers_; }
+  bool HasEdge(size_t ilhs, size_t irhs) const {
+    return matched_[SpaceIndex(ilhs, irhs)] == 1;
+  }
+  void SetEdge(size_t ilhs, size_t irhs, bool b) {
+    matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0;
+  }
+
+  // Treating the connectivity matrix as a (LhsSize()*RhsSize())-bit number,
+  // adds 1 to that number; returns false if incrementing the graph left it
+  // empty.
+  bool NextGraph();
+
+  void Randomize();
+
+  std::string DebugString() const;
+
+ private:
+  size_t SpaceIndex(size_t ilhs, size_t irhs) const {
+    return ilhs * num_matchers_ + irhs;
+  }
+
+  size_t num_elements_;
+  size_t num_matchers_;
+
+  // Each element is a char interpreted as bool. They are stored as a
+  // flattened array in lhs-major order, use 'SpaceIndex()' to translate
+  // a (ilhs, irhs) matrix coordinate into an offset.
+  ::std::vector<char> matched_;
+};
+
+typedef ::std::pair<size_t, size_t> ElementMatcherPair;
+typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs;
+
+// Returns a maximum bipartite matching for the specified graph 'g'.
+// The matching is represented as a vector of {element, matcher} pairs.
+GTEST_API_ ElementMatcherPairs
+FindMaxBipartiteMatching(const MatchMatrix& g);
+
+struct UnorderedMatcherRequire {
+  enum Flags {
+    Superset = 1 << 0,
+    Subset = 1 << 1,
+    ExactMatch = Superset | Subset,
+  };
+};
+
+// Untyped base class for implementing UnorderedElementsAre.  By
+// putting logic that's not specific to the element type here, we
+// reduce binary bloat and increase compilation speed.
+class GTEST_API_ UnorderedElementsAreMatcherImplBase {
+ protected:
+  explicit UnorderedElementsAreMatcherImplBase(
+      UnorderedMatcherRequire::Flags matcher_flags)
+      : match_flags_(matcher_flags) {}
+
+  // A vector of matcher describers, one for each element matcher.
+  // Does not own the describers (and thus can be used only when the
+  // element matchers are alive).
+  typedef ::std::vector<const MatcherDescriberInterface*> MatcherDescriberVec;
+
+  // Describes this UnorderedElementsAre matcher.
+  void DescribeToImpl(::std::ostream* os) const;
+
+  // Describes the negation of this UnorderedElementsAre matcher.
+  void DescribeNegationToImpl(::std::ostream* os) const;
+
+  bool VerifyMatchMatrix(const ::std::vector<std::string>& element_printouts,
+                         const MatchMatrix& matrix,
+                         MatchResultListener* listener) const;
+
+  bool FindPairing(const MatchMatrix& matrix,
+                   MatchResultListener* listener) const;
+
+  MatcherDescriberVec& matcher_describers() {
+    return matcher_describers_;
+  }
+
+  static Message Elements(size_t n) {
+    return Message() << n << " element" << (n == 1 ? "" : "s");
+  }
+
+  UnorderedMatcherRequire::Flags match_flags() const { return match_flags_; }
+
+ private:
+  UnorderedMatcherRequire::Flags match_flags_;
+  MatcherDescriberVec matcher_describers_;
+};
+
+// Implements UnorderedElementsAre, UnorderedElementsAreArray, IsSubsetOf, and
+// IsSupersetOf.
+template <typename Container>
+class UnorderedElementsAreMatcherImpl
+    : public MatcherInterface<Container>,
+      public UnorderedElementsAreMatcherImplBase {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef internal::StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::const_iterator StlContainerConstIterator;
+  typedef typename StlContainer::value_type Element;
+
+  template <typename InputIter>
+  UnorderedElementsAreMatcherImpl(UnorderedMatcherRequire::Flags matcher_flags,
+                                  InputIter first, InputIter last)
+      : UnorderedElementsAreMatcherImplBase(matcher_flags) {
+    for (; first != last; ++first) {
+      matchers_.push_back(MatcherCast<const Element&>(*first));
+    }
+    for (const auto& m : matchers_) {
+      matcher_describers().push_back(m.GetDescriber());
+    }
+  }
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  void DescribeNegationTo(::std::ostream* os) const override {
+    return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os);
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    StlContainerReference stl_container = View::ConstReference(container);
+    ::std::vector<std::string> element_printouts;
+    MatchMatrix matrix =
+        AnalyzeElements(stl_container.begin(), stl_container.end(),
+                        &element_printouts, listener);
+
+    if (matrix.LhsSize() == 0 && matrix.RhsSize() == 0) {
+      return true;
+    }
+
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+      if (matrix.LhsSize() != matrix.RhsSize()) {
+        // The element count doesn't match.  If the container is empty,
+        // there's no need to explain anything as Google Mock already
+        // prints the empty container. Otherwise we just need to show
+        // how many elements there actually are.
+        if (matrix.LhsSize() != 0 && listener->IsInterested()) {
+          *listener << "which has " << Elements(matrix.LhsSize());
+        }
+        return false;
+      }
+    }
+
+    return VerifyMatchMatrix(element_printouts, matrix, listener) &&
+           FindPairing(matrix, listener);
+  }
+
+ private:
+  template <typename ElementIter>
+  MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last,
+                              ::std::vector<std::string>* element_printouts,
+                              MatchResultListener* listener) const {
+    element_printouts->clear();
+    ::std::vector<char> did_match;
+    size_t num_elements = 0;
+    DummyMatchResultListener dummy;
+    for (; elem_first != elem_last; ++num_elements, ++elem_first) {
+      if (listener->IsInterested()) {
+        element_printouts->push_back(PrintToString(*elem_first));
+      }
+      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
+        did_match.push_back(
+            matchers_[irhs].MatchAndExplain(*elem_first, &dummy));
+      }
+    }
+
+    MatchMatrix matrix(num_elements, matchers_.size());
+    ::std::vector<char>::const_iterator did_match_iter = did_match.begin();
+    for (size_t ilhs = 0; ilhs != num_elements; ++ilhs) {
+      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
+        matrix.SetEdge(ilhs, irhs, *did_match_iter++ != 0);
+      }
+    }
+    return matrix;
+  }
+
+  ::std::vector<Matcher<const Element&> > matchers_;
+};
+
+// Functor for use in TransformTuple.
+// Performs MatcherCast<Target> on an input argument of any type.
+template <typename Target>
+struct CastAndAppendTransform {
+  template <typename Arg>
+  Matcher<Target> operator()(const Arg& a) const {
+    return MatcherCast<Target>(a);
+  }
+};
+
+// Implements UnorderedElementsAre.
+template <typename MatcherTuple>
+class UnorderedElementsAreMatcher {
+ public:
+  explicit UnorderedElementsAreMatcher(const MatcherTuple& args)
+      : matchers_(args) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+    typedef typename internal::StlContainerView<RawContainer>::type View;
+    typedef typename View::value_type Element;
+    typedef ::std::vector<Matcher<const Element&> > MatcherVec;
+    MatcherVec matchers;
+    matchers.reserve(::std::tuple_size<MatcherTuple>::value);
+    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
+                         ::std::back_inserter(matchers));
+    return Matcher<Container>(
+        new UnorderedElementsAreMatcherImpl<const Container&>(
+            UnorderedMatcherRequire::ExactMatch, matchers.begin(),
+            matchers.end()));
+  }
+
+ private:
+  const MatcherTuple matchers_;
+};
+
+// Implements ElementsAre.
+template <typename MatcherTuple>
+class ElementsAreMatcher {
+ public:
+  explicit ElementsAreMatcher(const MatcherTuple& args) : matchers_(args) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    GTEST_COMPILE_ASSERT_(
+        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value ||
+            ::std::tuple_size<MatcherTuple>::value < 2,
+        use_UnorderedElementsAre_with_hash_tables);
+
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+    typedef typename internal::StlContainerView<RawContainer>::type View;
+    typedef typename View::value_type Element;
+    typedef ::std::vector<Matcher<const Element&> > MatcherVec;
+    MatcherVec matchers;
+    matchers.reserve(::std::tuple_size<MatcherTuple>::value);
+    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
+                         ::std::back_inserter(matchers));
+    return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(
+        matchers.begin(), matchers.end()));
+  }
+
+ private:
+  const MatcherTuple matchers_;
+};
+
+// Implements UnorderedElementsAreArray(), IsSubsetOf(), and IsSupersetOf().
+template <typename T>
+class UnorderedElementsAreArrayMatcher {
+ public:
+  template <typename Iter>
+  UnorderedElementsAreArrayMatcher(UnorderedMatcherRequire::Flags match_flags,
+                                   Iter first, Iter last)
+      : match_flags_(match_flags), matchers_(first, last) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return Matcher<Container>(
+        new UnorderedElementsAreMatcherImpl<const Container&>(
+            match_flags_, matchers_.begin(), matchers_.end()));
+  }
+
+ private:
+  UnorderedMatcherRequire::Flags match_flags_;
+  ::std::vector<T> matchers_;
+};
+
+// Implements ElementsAreArray().
+template <typename T>
+class ElementsAreArrayMatcher {
+ public:
+  template <typename Iter>
+  ElementsAreArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    GTEST_COMPILE_ASSERT_(
+        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value,
+        use_UnorderedElementsAreArray_with_hash_tables);
+
+    return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(
+        matchers_.begin(), matchers_.end()));
+  }
+
+ private:
+  const ::std::vector<T> matchers_;
+};
+
+// Given a 2-tuple matcher tm of type Tuple2Matcher and a value second
+// of type Second, BoundSecondMatcher<Tuple2Matcher, Second>(tm,
+// second) is a polymorphic matcher that matches a value x if and only if
+// tm matches tuple (x, second).  Useful for implementing
+// UnorderedPointwise() in terms of UnorderedElementsAreArray().
+//
+// BoundSecondMatcher is copyable and assignable, as we need to put
+// instances of this class in a vector when implementing
+// UnorderedPointwise().
+template <typename Tuple2Matcher, typename Second>
+class BoundSecondMatcher {
+ public:
+  BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second)
+      : tuple2_matcher_(tm), second_value_(second) {}
+
+  BoundSecondMatcher(const BoundSecondMatcher& other) = default;
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_));
+  }
+
+  // We have to define this for UnorderedPointwise() to compile in
+  // C++98 mode, as it puts BoundSecondMatcher instances in a vector,
+  // which requires the elements to be assignable in C++98.  The
+  // compiler cannot generate the operator= for us, as Tuple2Matcher
+  // and Second may not be assignable.
+  //
+  // However, this should never be called, so the implementation just
+  // need to assert.
+  void operator=(const BoundSecondMatcher& /*rhs*/) {
+    GTEST_LOG_(FATAL) << "BoundSecondMatcher should never be assigned.";
+  }
+
+ private:
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+   public:
+    typedef ::std::tuple<T, Second> ArgTuple;
+
+    Impl(const Tuple2Matcher& tm, const Second& second)
+        : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)),
+          second_value_(second) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "and ";
+      UniversalPrint(second_value_, os);
+      *os << " ";
+      mono_tuple2_matcher_.DescribeTo(os);
+    }
+
+    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
+      return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_),
+                                                  listener);
+    }
+
+   private:
+    const Matcher<const ArgTuple&> mono_tuple2_matcher_;
+    const Second second_value_;
+  };
+
+  const Tuple2Matcher tuple2_matcher_;
+  const Second second_value_;
+};
+
+// Given a 2-tuple matcher tm and a value second,
+// MatcherBindSecond(tm, second) returns a matcher that matches a
+// value x if and only if tm matches tuple (x, second).  Useful for
+// implementing UnorderedPointwise() in terms of UnorderedElementsAreArray().
+template <typename Tuple2Matcher, typename Second>
+BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond(
+    const Tuple2Matcher& tm, const Second& second) {
+  return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second);
+}
+
+// Returns the description for a matcher defined using the MATCHER*()
+// macro where the user-supplied description string is "", if
+// 'negation' is false; otherwise returns the description of the
+// negation of the matcher.  'param_values' contains a list of strings
+// that are the print-out of the matcher's parameters.
+GTEST_API_ std::string FormatMatcherDescription(bool negation,
+                                                const char* matcher_name,
+                                                const Strings& param_values);
+
+// Implements a matcher that checks the value of a optional<> type variable.
+template <typename ValueMatcher>
+class OptionalMatcher {
+ public:
+  explicit OptionalMatcher(const ValueMatcher& value_matcher)
+      : value_matcher_(value_matcher) {}
+
+  template <typename Optional>
+  operator Matcher<Optional>() const {
+    return Matcher<Optional>(new Impl<const Optional&>(value_matcher_));
+  }
+
+  template <typename Optional>
+  class Impl : public MatcherInterface<Optional> {
+   public:
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Optional) OptionalView;
+    typedef typename OptionalView::value_type ValueType;
+    explicit Impl(const ValueMatcher& value_matcher)
+        : value_matcher_(MatcherCast<ValueType>(value_matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "value ";
+      value_matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "value ";
+      value_matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(Optional optional,
+                         MatchResultListener* listener) const override {
+      if (!optional) {
+        *listener << "which is not engaged";
+        return false;
+      }
+      const ValueType& value = *optional;
+      StringMatchResultListener value_listener;
+      const bool match = value_matcher_.MatchAndExplain(value, &value_listener);
+      *listener << "whose value " << PrintToString(value)
+                << (match ? " matches" : " doesn't match");
+      PrintIfNotEmpty(value_listener.str(), listener->stream());
+      return match;
+    }
+
+   private:
+    const Matcher<ValueType> value_matcher_;
+  };
+
+ private:
+  const ValueMatcher value_matcher_;
+};
+
+namespace variant_matcher {
+// Overloads to allow VariantMatcher to do proper ADL lookup.
+template <typename T>
+void holds_alternative() {}
+template <typename T>
+void get() {}
+
+// Implements a matcher that checks the value of a variant<> type variable.
+template <typename T>
+class VariantMatcher {
+ public:
+  explicit VariantMatcher(::testing::Matcher<const T&> matcher)
+      : matcher_(std::move(matcher)) {}
+
+  template <typename Variant>
+  bool MatchAndExplain(const Variant& value,
+                       ::testing::MatchResultListener* listener) const {
+    using std::get;
+    if (!listener->IsInterested()) {
+      return holds_alternative<T>(value) && matcher_.Matches(get<T>(value));
+    }
+
+    if (!holds_alternative<T>(value)) {
+      *listener << "whose value is not of type '" << GetTypeName() << "'";
+      return false;
+    }
+
+    const T& elem = get<T>(value);
+    StringMatchResultListener elem_listener;
+    const bool match = matcher_.MatchAndExplain(elem, &elem_listener);
+    *listener << "whose value " << PrintToString(elem)
+              << (match ? " matches" : " doesn't match");
+    PrintIfNotEmpty(elem_listener.str(), listener->stream());
+    return match;
+  }
+
+  void DescribeTo(std::ostream* os) const {
+    *os << "is a variant<> with value of type '" << GetTypeName()
+        << "' and the value ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "is a variant<> with value of type other than '" << GetTypeName()
+        << "' or the value ";
+    matcher_.DescribeNegationTo(os);
+  }
+
+ private:
+  static std::string GetTypeName() {
+#if GTEST_HAS_RTTI
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
+        return internal::GetTypeName<T>());
+#endif
+    return "the element type";
+  }
+
+  const ::testing::Matcher<const T&> matcher_;
+};
+
+}  // namespace variant_matcher
+
+namespace any_cast_matcher {
+
+// Overloads to allow AnyCastMatcher to do proper ADL lookup.
+template <typename T>
+void any_cast() {}
+
+// Implements a matcher that any_casts the value.
+template <typename T>
+class AnyCastMatcher {
+ public:
+  explicit AnyCastMatcher(const ::testing::Matcher<const T&>& matcher)
+      : matcher_(matcher) {}
+
+  template <typename AnyType>
+  bool MatchAndExplain(const AnyType& value,
+                       ::testing::MatchResultListener* listener) const {
+    if (!listener->IsInterested()) {
+      const T* ptr = any_cast<T>(&value);
+      return ptr != nullptr && matcher_.Matches(*ptr);
+    }
+
+    const T* elem = any_cast<T>(&value);
+    if (elem == nullptr) {
+      *listener << "whose value is not of type '" << GetTypeName() << "'";
+      return false;
+    }
+
+    StringMatchResultListener elem_listener;
+    const bool match = matcher_.MatchAndExplain(*elem, &elem_listener);
+    *listener << "whose value " << PrintToString(*elem)
+              << (match ? " matches" : " doesn't match");
+    PrintIfNotEmpty(elem_listener.str(), listener->stream());
+    return match;
+  }
+
+  void DescribeTo(std::ostream* os) const {
+    *os << "is an 'any' type with value of type '" << GetTypeName()
+        << "' and the value ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "is an 'any' type with value of type other than '" << GetTypeName()
+        << "' or the value ";
+    matcher_.DescribeNegationTo(os);
+  }
+
+ private:
+  static std::string GetTypeName() {
+#if GTEST_HAS_RTTI
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
+        return internal::GetTypeName<T>());
+#endif
+    return "the element type";
+  }
+
+  const ::testing::Matcher<const T&> matcher_;
+};
+
+}  // namespace any_cast_matcher
+
+// Implements the Args() matcher.
+template <class ArgsTuple, size_t... k>
+class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
+ public:
+  using RawArgsTuple = typename std::decay<ArgsTuple>::type;
+  using SelectedArgs =
+      std::tuple<typename std::tuple_element<k, RawArgsTuple>::type...>;
+  using MonomorphicInnerMatcher = Matcher<const SelectedArgs&>;
+
+  template <typename InnerMatcher>
+  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
+      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
+
+  bool MatchAndExplain(ArgsTuple args,
+                       MatchResultListener* listener) const override {
+    // Workaround spurious C4100 on MSVC<=15.7 when k is empty.
+    (void)args;
+    const SelectedArgs& selected_args =
+        std::forward_as_tuple(std::get<k>(args)...);
+    if (!listener->IsInterested()) return inner_matcher_.Matches(selected_args);
+
+    PrintIndices(listener->stream());
+    *listener << "are " << PrintToString(selected_args);
+
+    StringMatchResultListener inner_listener;
+    const bool match =
+        inner_matcher_.MatchAndExplain(selected_args, &inner_listener);
+    PrintIfNotEmpty(inner_listener.str(), listener->stream());
+    return match;
+  }
+
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "are a tuple ";
+    PrintIndices(os);
+    inner_matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "are a tuple ";
+    PrintIndices(os);
+    inner_matcher_.DescribeNegationTo(os);
+  }
+
+ private:
+  // Prints the indices of the selected fields.
+  static void PrintIndices(::std::ostream* os) {
+    *os << "whose fields (";
+    const char* sep = "";
+    // Workaround spurious C4189 on MSVC<=15.7 when k is empty.
+    (void)sep;
+    const char* dummy[] = {"", (*os << sep << "#" << k, sep = ", ")...};
+    (void)dummy;
+    *os << ") ";
+  }
+
+  MonomorphicInnerMatcher inner_matcher_;
+};
+
+template <class InnerMatcher, size_t... k>
+class ArgsMatcher {
+ public:
+  explicit ArgsMatcher(InnerMatcher inner_matcher)
+      : inner_matcher_(std::move(inner_matcher)) {}
+
+  template <typename ArgsTuple>
+  operator Matcher<ArgsTuple>() const {  // NOLINT
+    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k...>(inner_matcher_));
+  }
+
+ private:
+  InnerMatcher inner_matcher_;
+};
+
+}  // namespace internal
+
+// ElementsAreArray(iterator_first, iterator_last)
+// ElementsAreArray(pointer, count)
+// ElementsAreArray(array)
+// ElementsAreArray(container)
+// ElementsAreArray({ e1, e2, ..., en })
+//
+// The ElementsAreArray() functions are like ElementsAre(...), except
+// that they are given a homogeneous sequence rather than taking each
+// element as a function argument. The sequence can be specified as an
+// array, a pointer and count, a vector, an initializer list, or an
+// STL iterator range. In each of these cases, the underlying sequence
+// can be either a sequence of values or a sequence of matchers.
+//
+// All forms of ElementsAreArray() make a copy of the input matcher sequence.
+
+template <typename Iter>
+inline internal::ElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+ElementsAreArray(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::ElementsAreArrayMatcher<T>(first, last);
+}
+
+template <typename T>
+inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
+    const T* pointer, size_t count) {
+  return ElementsAreArray(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
+    const T (&array)[N]) {
+  return ElementsAreArray(array, N);
+}
+
+template <typename Container>
+inline internal::ElementsAreArrayMatcher<typename Container::value_type>
+ElementsAreArray(const Container& container) {
+  return ElementsAreArray(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::ElementsAreArrayMatcher<T>
+ElementsAreArray(::std::initializer_list<T> xs) {
+  return ElementsAreArray(xs.begin(), xs.end());
+}
+
+// UnorderedElementsAreArray(iterator_first, iterator_last)
+// UnorderedElementsAreArray(pointer, count)
+// UnorderedElementsAreArray(array)
+// UnorderedElementsAreArray(container)
+// UnorderedElementsAreArray({ e1, e2, ..., en })
+//
+// UnorderedElementsAreArray() verifies that a bijective mapping onto a
+// collection of matchers exists.
+//
+// The matchers can be specified as an array, a pointer and count, a container,
+// an initializer list, or an STL iterator range. In each of these cases, the
+// underlying matchers can be either values or matchers.
+
+template <typename Iter>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+UnorderedElementsAreArray(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::UnorderedElementsAreArrayMatcher<T>(
+      internal::UnorderedMatcherRequire::ExactMatch, first, last);
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T>
+UnorderedElementsAreArray(const T* pointer, size_t count) {
+  return UnorderedElementsAreArray(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::UnorderedElementsAreArrayMatcher<T>
+UnorderedElementsAreArray(const T (&array)[N]) {
+  return UnorderedElementsAreArray(array, N);
+}
+
+template <typename Container>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename Container::value_type>
+UnorderedElementsAreArray(const Container& container) {
+  return UnorderedElementsAreArray(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T>
+UnorderedElementsAreArray(::std::initializer_list<T> xs) {
+  return UnorderedElementsAreArray(xs.begin(), xs.end());
+}
+
+// _ is a matcher that matches anything of any type.
+//
+// This definition is fine as:
+//
+//   1. The C++ standard permits using the name _ in a namespace that
+//      is not the global namespace or ::std.
+//   2. The AnythingMatcher class has no data member or constructor,
+//      so it's OK to create global variables of this type.
+//   3. c-style has approved of using _ in this case.
+const internal::AnythingMatcher _ = {};
+// Creates a matcher that matches any value of the given type T.
+template <typename T>
+inline Matcher<T> A() {
+  return _;
+}
+
+// Creates a matcher that matches any value of the given type T.
+template <typename T>
+inline Matcher<T> An() {
+  return _;
+}
+
+template <typename T, typename M>
+Matcher<T> internal::MatcherCastImpl<T, M>::CastImpl(
+    const M& value, std::false_type /* convertible_to_matcher */,
+    std::false_type /* convertible_to_T */) {
+  return Eq(value);
+}
+
+// Creates a polymorphic matcher that matches any NULL pointer.
+inline PolymorphicMatcher<internal::IsNullMatcher > IsNull() {
+  return MakePolymorphicMatcher(internal::IsNullMatcher());
+}
+
+// Creates a polymorphic matcher that matches any non-NULL pointer.
+// This is convenient as Not(NULL) doesn't compile (the compiler
+// thinks that that expression is comparing a pointer with an integer).
+inline PolymorphicMatcher<internal::NotNullMatcher > NotNull() {
+  return MakePolymorphicMatcher(internal::NotNullMatcher());
+}
+
+// Creates a polymorphic matcher that matches any argument that
+// references variable x.
+template <typename T>
+inline internal::RefMatcher<T&> Ref(T& x) {  // NOLINT
+  return internal::RefMatcher<T&>(x);
+}
+
+// Creates a polymorphic matcher that matches any NaN floating point.
+inline PolymorphicMatcher<internal::IsNanMatcher> IsNan() {
+  return MakePolymorphicMatcher(internal::IsNanMatcher());
+}
+
+// Creates a matcher that matches any double argument approximately
+// equal to rhs, where two NANs are considered unequal.
+inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) {
+  return internal::FloatingEqMatcher<double>(rhs, false);
+}
+
+// Creates a matcher that matches any double argument approximately
+// equal to rhs, including NaN values when rhs is NaN.
+inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) {
+  return internal::FloatingEqMatcher<double>(rhs, true);
+}
+
+// Creates a matcher that matches any double argument approximately equal to
+// rhs, up to the specified max absolute error bound, where two NANs are
+// considered unequal.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<double> DoubleNear(
+    double rhs, double max_abs_error) {
+  return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error);
+}
+
+// Creates a matcher that matches any double argument approximately equal to
+// rhs, up to the specified max absolute error bound, including NaN values when
+// rhs is NaN.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear(
+    double rhs, double max_abs_error) {
+  return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error);
+}
+
+// Creates a matcher that matches any float argument approximately
+// equal to rhs, where two NANs are considered unequal.
+inline internal::FloatingEqMatcher<float> FloatEq(float rhs) {
+  return internal::FloatingEqMatcher<float>(rhs, false);
+}
+
+// Creates a matcher that matches any float argument approximately
+// equal to rhs, including NaN values when rhs is NaN.
+inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {
+  return internal::FloatingEqMatcher<float>(rhs, true);
+}
+
+// Creates a matcher that matches any float argument approximately equal to
+// rhs, up to the specified max absolute error bound, where two NANs are
+// considered unequal.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<float> FloatNear(
+    float rhs, float max_abs_error) {
+  return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error);
+}
+
+// Creates a matcher that matches any float argument approximately equal to
+// rhs, up to the specified max absolute error bound, including NaN values when
+// rhs is NaN.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear(
+    float rhs, float max_abs_error) {
+  return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error);
+}
+
+// Creates a matcher that matches a pointer (raw or smart) that points
+// to a value that matches inner_matcher.
+template <typename InnerMatcher>
+inline internal::PointeeMatcher<InnerMatcher> Pointee(
+    const InnerMatcher& inner_matcher) {
+  return internal::PointeeMatcher<InnerMatcher>(inner_matcher);
+}
+
+#if GTEST_HAS_RTTI
+// Creates a matcher that matches a pointer or reference that matches
+// inner_matcher when dynamic_cast<To> is applied.
+// The result of dynamic_cast<To> is forwarded to the inner matcher.
+// If To is a pointer and the cast fails, the inner matcher will receive NULL.
+// If To is a reference and the cast fails, this matcher returns false
+// immediately.
+template <typename To>
+inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To> >
+WhenDynamicCastTo(const Matcher<To>& inner_matcher) {
+  return MakePolymorphicMatcher(
+      internal::WhenDynamicCastToMatcher<To>(inner_matcher));
+}
+#endif  // GTEST_HAS_RTTI
+
+// Creates a matcher that matches an object whose given field matches
+// 'matcher'.  For example,
+//   Field(&Foo::number, Ge(5))
+// matches a Foo object x if and only if x.number >= 5.
+template <typename Class, typename FieldType, typename FieldMatcher>
+inline PolymorphicMatcher<
+  internal::FieldMatcher<Class, FieldType> > Field(
+    FieldType Class::*field, const FieldMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::FieldMatcher<Class, FieldType>(
+          field, MatcherCast<const FieldType&>(matcher)));
+  // The call to MatcherCast() is required for supporting inner
+  // matchers of compatible types.  For example, it allows
+  //   Field(&Foo::bar, m)
+  // to compile where bar is an int32 and m is a matcher for int64.
+}
+
+// Same as Field() but also takes the name of the field to provide better error
+// messages.
+template <typename Class, typename FieldType, typename FieldMatcher>
+inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType> > Field(
+    const std::string& field_name, FieldType Class::*field,
+    const FieldMatcher& matcher) {
+  return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>(
+      field_name, field, MatcherCast<const FieldType&>(matcher)));
+}
+
+// Creates a matcher that matches an object whose given property
+// matches 'matcher'.  For example,
+//   Property(&Foo::str, StartsWith("hi"))
+// matches a Foo object x if and only if x.str() starts with "hi".
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<internal::PropertyMatcher<
+    Class, PropertyType, PropertyType (Class::*)() const> >
+Property(PropertyType (Class::*property)() const,
+         const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType,
+                                PropertyType (Class::*)() const>(
+          property, MatcherCast<const PropertyType&>(matcher)));
+  // The call to MatcherCast() is required for supporting inner
+  // matchers of compatible types.  For example, it allows
+  //   Property(&Foo::bar, m)
+  // to compile where bar() returns an int32 and m is a matcher for int64.
+}
+
+// Same as Property() above, but also takes the name of the property to provide
+// better error messages.
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<internal::PropertyMatcher<
+    Class, PropertyType, PropertyType (Class::*)() const> >
+Property(const std::string& property_name,
+         PropertyType (Class::*property)() const,
+         const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType,
+                                PropertyType (Class::*)() const>(
+          property_name, property, MatcherCast<const PropertyType&>(matcher)));
+}
+
+// The same as above but for reference-qualified member functions.
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<internal::PropertyMatcher<
+    Class, PropertyType, PropertyType (Class::*)() const &> >
+Property(PropertyType (Class::*property)() const &,
+         const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType,
+                                PropertyType (Class::*)() const&>(
+          property, MatcherCast<const PropertyType&>(matcher)));
+}
+
+// Three-argument form for reference-qualified member functions.
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<internal::PropertyMatcher<
+    Class, PropertyType, PropertyType (Class::*)() const &> >
+Property(const std::string& property_name,
+         PropertyType (Class::*property)() const &,
+         const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType,
+                                PropertyType (Class::*)() const&>(
+          property_name, property, MatcherCast<const PropertyType&>(matcher)));
+}
+
+// Creates a matcher that matches an object if and only if the result of
+// applying a callable to x matches 'matcher'. For example,
+//   ResultOf(f, StartsWith("hi"))
+// matches a Foo object x if and only if f(x) starts with "hi".
+// `callable` parameter can be a function, function pointer, or a functor. It is
+// required to keep no state affecting the results of the calls on it and make
+// no assumptions about how many calls will be made. Any state it keeps must be
+// protected from the concurrent access.
+template <typename Callable, typename InnerMatcher>
+internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf(
+    Callable callable, InnerMatcher matcher) {
+  return internal::ResultOfMatcher<Callable, InnerMatcher>(
+      std::move(callable), std::move(matcher));
+}
+
+// String matchers.
+
+// Matches a string equal to str.
+template <typename T = std::string>
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrEq(
+    const internal::StringLike<T>& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::string>(std::string(str), true, true));
+}
+
+// Matches a string not equal to str.
+template <typename T = std::string>
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrNe(
+    const internal::StringLike<T>& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::string>(std::string(str), false, true));
+}
+
+// Matches a string equal to str, ignoring case.
+template <typename T = std::string>
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseEq(
+    const internal::StringLike<T>& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::string>(std::string(str), true, false));
+}
+
+// Matches a string not equal to str, ignoring case.
+template <typename T = std::string>
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseNe(
+    const internal::StringLike<T>& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<std::string>(
+      std::string(str), false, false));
+}
+
+// Creates a matcher that matches any string, std::string, or C string
+// that contains the given substring.
+template <typename T = std::string>
+PolymorphicMatcher<internal::HasSubstrMatcher<std::string> > HasSubstr(
+    const internal::StringLike<T>& substring) {
+  return MakePolymorphicMatcher(
+      internal::HasSubstrMatcher<std::string>(std::string(substring)));
+}
+
+// Matches a string that starts with 'prefix' (case-sensitive).
+template <typename T = std::string>
+PolymorphicMatcher<internal::StartsWithMatcher<std::string> > StartsWith(
+    const internal::StringLike<T>& prefix) {
+  return MakePolymorphicMatcher(
+      internal::StartsWithMatcher<std::string>(std::string(prefix)));
+}
+
+// Matches a string that ends with 'suffix' (case-sensitive).
+template <typename T = std::string>
+PolymorphicMatcher<internal::EndsWithMatcher<std::string> > EndsWith(
+    const internal::StringLike<T>& suffix) {
+  return MakePolymorphicMatcher(
+      internal::EndsWithMatcher<std::string>(std::string(suffix)));
+}
+
+#if GTEST_HAS_STD_WSTRING
+// Wide string matchers.
+
+// Matches a string equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrEq(
+    const std::wstring& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::wstring>(str, true, true));
+}
+
+// Matches a string not equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrNe(
+    const std::wstring& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::wstring>(str, false, true));
+}
+
+// Matches a string equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> >
+StrCaseEq(const std::wstring& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::wstring>(str, true, false));
+}
+
+// Matches a string not equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> >
+StrCaseNe(const std::wstring& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::wstring>(str, false, false));
+}
+
+// Creates a matcher that matches any ::wstring, std::wstring, or C wide string
+// that contains the given substring.
+inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring> > HasSubstr(
+    const std::wstring& substring) {
+  return MakePolymorphicMatcher(
+      internal::HasSubstrMatcher<std::wstring>(substring));
+}
+
+// Matches a string that starts with 'prefix' (case-sensitive).
+inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring> >
+StartsWith(const std::wstring& prefix) {
+  return MakePolymorphicMatcher(
+      internal::StartsWithMatcher<std::wstring>(prefix));
+}
+
+// Matches a string that ends with 'suffix' (case-sensitive).
+inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring> > EndsWith(
+    const std::wstring& suffix) {
+  return MakePolymorphicMatcher(
+      internal::EndsWithMatcher<std::wstring>(suffix));
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field == the second field.
+inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field >= the second field.
+inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field > the second field.
+inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field <= the second field.
+inline internal::Le2Matcher Le() { return internal::Le2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field < the second field.
+inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field != the second field.
+inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// FloatEq(first field) matches the second field.
+inline internal::FloatingEq2Matcher<float> FloatEq() {
+  return internal::FloatingEq2Matcher<float>();
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// DoubleEq(first field) matches the second field.
+inline internal::FloatingEq2Matcher<double> DoubleEq() {
+  return internal::FloatingEq2Matcher<double>();
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// FloatEq(first field) matches the second field with NaN equality.
+inline internal::FloatingEq2Matcher<float> NanSensitiveFloatEq() {
+  return internal::FloatingEq2Matcher<float>(true);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// DoubleEq(first field) matches the second field with NaN equality.
+inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleEq() {
+  return internal::FloatingEq2Matcher<double>(true);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// FloatNear(first field, max_abs_error) matches the second field.
+inline internal::FloatingEq2Matcher<float> FloatNear(float max_abs_error) {
+  return internal::FloatingEq2Matcher<float>(max_abs_error);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// DoubleNear(first field, max_abs_error) matches the second field.
+inline internal::FloatingEq2Matcher<double> DoubleNear(double max_abs_error) {
+  return internal::FloatingEq2Matcher<double>(max_abs_error);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// FloatNear(first field, max_abs_error) matches the second field with NaN
+// equality.
+inline internal::FloatingEq2Matcher<float> NanSensitiveFloatNear(
+    float max_abs_error) {
+  return internal::FloatingEq2Matcher<float>(max_abs_error, true);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// DoubleNear(first field, max_abs_error) matches the second field with NaN
+// equality.
+inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleNear(
+    double max_abs_error) {
+  return internal::FloatingEq2Matcher<double>(max_abs_error, true);
+}
+
+// Creates a matcher that matches any value of type T that m doesn't
+// match.
+template <typename InnerMatcher>
+inline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) {
+  return internal::NotMatcher<InnerMatcher>(m);
+}
+
+// Returns a matcher that matches anything that satisfies the given
+// predicate.  The predicate can be any unary function or functor
+// whose return type can be implicitly converted to bool.
+template <typename Predicate>
+inline PolymorphicMatcher<internal::TrulyMatcher<Predicate> >
+Truly(Predicate pred) {
+  return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));
+}
+
+// Returns a matcher that matches the container size. The container must
+// support both size() and size_type which all STL-like containers provide.
+// Note that the parameter 'size' can be a value of type size_type as well as
+// matcher. For instance:
+//   EXPECT_THAT(container, SizeIs(2));     // Checks container has 2 elements.
+//   EXPECT_THAT(container, SizeIs(Le(2));  // Checks container has at most 2.
+template <typename SizeMatcher>
+inline internal::SizeIsMatcher<SizeMatcher>
+SizeIs(const SizeMatcher& size_matcher) {
+  return internal::SizeIsMatcher<SizeMatcher>(size_matcher);
+}
+
+// Returns a matcher that matches the distance between the container's begin()
+// iterator and its end() iterator, i.e. the size of the container. This matcher
+// can be used instead of SizeIs with containers such as std::forward_list which
+// do not implement size(). The container must provide const_iterator (with
+// valid iterator_traits), begin() and end().
+template <typename DistanceMatcher>
+inline internal::BeginEndDistanceIsMatcher<DistanceMatcher>
+BeginEndDistanceIs(const DistanceMatcher& distance_matcher) {
+  return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher);
+}
+
+// Returns a matcher that matches an equal container.
+// This matcher behaves like Eq(), but in the event of mismatch lists the
+// values that are included in one container but not the other. (Duplicate
+// values and order differences are not explained.)
+template <typename Container>
+inline PolymorphicMatcher<internal::ContainerEqMatcher<
+    typename std::remove_const<Container>::type>>
+ContainerEq(const Container& rhs) {
+  return MakePolymorphicMatcher(internal::ContainerEqMatcher<Container>(rhs));
+}
+
+// Returns a matcher that matches a container that, when sorted using
+// the given comparator, matches container_matcher.
+template <typename Comparator, typename ContainerMatcher>
+inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher>
+WhenSortedBy(const Comparator& comparator,
+             const ContainerMatcher& container_matcher) {
+  return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>(
+      comparator, container_matcher);
+}
+
+// Returns a matcher that matches a container that, when sorted using
+// the < operator, matches container_matcher.
+template <typename ContainerMatcher>
+inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>
+WhenSorted(const ContainerMatcher& container_matcher) {
+  return
+      internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>(
+          internal::LessComparator(), container_matcher);
+}
+
+// Matches an STL-style container or a native array that contains the
+// same number of elements as in rhs, where its i-th element and rhs's
+// i-th element (as a pair) satisfy the given pair matcher, for all i.
+// TupleMatcher must be able to be safely cast to Matcher<std::tuple<const
+// T1&, const T2&> >, where T1 and T2 are the types of elements in the
+// LHS container and the RHS container respectively.
+template <typename TupleMatcher, typename Container>
+inline internal::PointwiseMatcher<TupleMatcher,
+                                  typename std::remove_const<Container>::type>
+Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
+  return internal::PointwiseMatcher<TupleMatcher, Container>(tuple_matcher,
+                                                             rhs);
+}
+
+
+// Supports the Pointwise(m, {a, b, c}) syntax.
+template <typename TupleMatcher, typename T>
+inline internal::PointwiseMatcher<TupleMatcher, std::vector<T> > Pointwise(
+    const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) {
+  return Pointwise(tuple_matcher, std::vector<T>(rhs));
+}
+
+
+// UnorderedPointwise(pair_matcher, rhs) matches an STL-style
+// container or a native array that contains the same number of
+// elements as in rhs, where in some permutation of the container, its
+// i-th element and rhs's i-th element (as a pair) satisfy the given
+// pair matcher, for all i.  Tuple2Matcher must be able to be safely
+// cast to Matcher<std::tuple<const T1&, const T2&> >, where T1 and T2 are
+// the types of elements in the LHS container and the RHS container
+// respectively.
+//
+// This is like Pointwise(pair_matcher, rhs), except that the element
+// order doesn't matter.
+template <typename Tuple2Matcher, typename RhsContainer>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename internal::BoundSecondMatcher<
+        Tuple2Matcher,
+        typename internal::StlContainerView<
+            typename std::remove_const<RhsContainer>::type>::type::value_type>>
+UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
+                   const RhsContainer& rhs_container) {
+  // RhsView allows the same code to handle RhsContainer being a
+  // STL-style container and it being a native C-style array.
+  typedef typename internal::StlContainerView<RhsContainer> RhsView;
+  typedef typename RhsView::type RhsStlContainer;
+  typedef typename RhsStlContainer::value_type Second;
+  const RhsStlContainer& rhs_stl_container =
+      RhsView::ConstReference(rhs_container);
+
+  // Create a matcher for each element in rhs_container.
+  ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers;
+  for (typename RhsStlContainer::const_iterator it = rhs_stl_container.begin();
+       it != rhs_stl_container.end(); ++it) {
+    matchers.push_back(
+        internal::MatcherBindSecond(tuple2_matcher, *it));
+  }
+
+  // Delegate the work to UnorderedElementsAreArray().
+  return UnorderedElementsAreArray(matchers);
+}
+
+
+// Supports the UnorderedPointwise(m, {a, b, c}) syntax.
+template <typename Tuple2Matcher, typename T>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename internal::BoundSecondMatcher<Tuple2Matcher, T> >
+UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
+                   std::initializer_list<T> rhs) {
+  return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));
+}
+
+
+// Matches an STL-style container or a native array that contains at
+// least one element matching the given value or matcher.
+//
+// Examples:
+//   ::std::set<int> page_ids;
+//   page_ids.insert(3);
+//   page_ids.insert(1);
+//   EXPECT_THAT(page_ids, Contains(1));
+//   EXPECT_THAT(page_ids, Contains(Gt(2)));
+//   EXPECT_THAT(page_ids, Not(Contains(4)));
+//
+//   ::std::map<int, size_t> page_lengths;
+//   page_lengths[1] = 100;
+//   EXPECT_THAT(page_lengths,
+//               Contains(::std::pair<const int, size_t>(1, 100)));
+//
+//   const char* user_ids[] = { "joe", "mike", "tom" };
+//   EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom"))));
+template <typename M>
+inline internal::ContainsMatcher<M> Contains(M matcher) {
+  return internal::ContainsMatcher<M>(matcher);
+}
+
+// IsSupersetOf(iterator_first, iterator_last)
+// IsSupersetOf(pointer, count)
+// IsSupersetOf(array)
+// IsSupersetOf(container)
+// IsSupersetOf({e1, e2, ..., en})
+//
+// IsSupersetOf() verifies that a surjective partial mapping onto a collection
+// of matchers exists. In other words, a container matches
+// IsSupersetOf({e1, ..., en}) if and only if there is a permutation
+// {y1, ..., yn} of some of the container's elements where y1 matches e1,
+// ..., and yn matches en. Obviously, the size of the container must be >= n
+// in order to have a match. Examples:
+//
+// - {1, 2, 3} matches IsSupersetOf({Ge(3), Ne(0)}), as 3 matches Ge(3) and
+//   1 matches Ne(0).
+// - {1, 2} doesn't match IsSupersetOf({Eq(1), Lt(2)}), even though 1 matches
+//   both Eq(1) and Lt(2). The reason is that different matchers must be used
+//   for elements in different slots of the container.
+// - {1, 1, 2} matches IsSupersetOf({Eq(1), Lt(2)}), as (the first) 1 matches
+//   Eq(1) and (the second) 1 matches Lt(2).
+// - {1, 2, 3} matches IsSupersetOf(Gt(1), Gt(1)), as 2 matches (the first)
+//   Gt(1) and 3 matches (the second) Gt(1).
+//
+// The matchers can be specified as an array, a pointer and count, a container,
+// an initializer list, or an STL iterator range. In each of these cases, the
+// underlying matchers can be either values or matchers.
+
+template <typename Iter>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+IsSupersetOf(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::UnorderedElementsAreArrayMatcher<T>(
+      internal::UnorderedMatcherRequire::Superset, first, last);
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
+    const T* pointer, size_t count) {
+  return IsSupersetOf(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
+    const T (&array)[N]) {
+  return IsSupersetOf(array, N);
+}
+
+template <typename Container>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename Container::value_type>
+IsSupersetOf(const Container& container) {
+  return IsSupersetOf(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
+    ::std::initializer_list<T> xs) {
+  return IsSupersetOf(xs.begin(), xs.end());
+}
+
+// IsSubsetOf(iterator_first, iterator_last)
+// IsSubsetOf(pointer, count)
+// IsSubsetOf(array)
+// IsSubsetOf(container)
+// IsSubsetOf({e1, e2, ..., en})
+//
+// IsSubsetOf() verifies that an injective mapping onto a collection of matchers
+// exists.  In other words, a container matches IsSubsetOf({e1, ..., en}) if and
+// only if there is a subset of matchers {m1, ..., mk} which would match the
+// container using UnorderedElementsAre.  Obviously, the size of the container
+// must be <= n in order to have a match. Examples:
+//
+// - {1} matches IsSubsetOf({Gt(0), Lt(0)}), as 1 matches Gt(0).
+// - {1, -1} matches IsSubsetOf({Lt(0), Gt(0)}), as 1 matches Gt(0) and -1
+//   matches Lt(0).
+// - {1, 2} doesn't matches IsSubsetOf({Gt(0), Lt(0)}), even though 1 and 2 both
+//   match Gt(0). The reason is that different matchers must be used for
+//   elements in different slots of the container.
+//
+// The matchers can be specified as an array, a pointer and count, a container,
+// an initializer list, or an STL iterator range. In each of these cases, the
+// underlying matchers can be either values or matchers.
+
+template <typename Iter>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+IsSubsetOf(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::UnorderedElementsAreArrayMatcher<T>(
+      internal::UnorderedMatcherRequire::Subset, first, last);
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
+    const T* pointer, size_t count) {
+  return IsSubsetOf(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
+    const T (&array)[N]) {
+  return IsSubsetOf(array, N);
+}
+
+template <typename Container>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename Container::value_type>
+IsSubsetOf(const Container& container) {
+  return IsSubsetOf(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
+    ::std::initializer_list<T> xs) {
+  return IsSubsetOf(xs.begin(), xs.end());
+}
+
+// Matches an STL-style container or a native array that contains only
+// elements matching the given value or matcher.
+//
+// Each(m) is semantically equivalent to Not(Contains(Not(m))). Only
+// the messages are different.
+//
+// Examples:
+//   ::std::set<int> page_ids;
+//   // Each(m) matches an empty container, regardless of what m is.
+//   EXPECT_THAT(page_ids, Each(Eq(1)));
+//   EXPECT_THAT(page_ids, Each(Eq(77)));
+//
+//   page_ids.insert(3);
+//   EXPECT_THAT(page_ids, Each(Gt(0)));
+//   EXPECT_THAT(page_ids, Not(Each(Gt(4))));
+//   page_ids.insert(1);
+//   EXPECT_THAT(page_ids, Not(Each(Lt(2))));
+//
+//   ::std::map<int, size_t> page_lengths;
+//   page_lengths[1] = 100;
+//   page_lengths[2] = 200;
+//   page_lengths[3] = 300;
+//   EXPECT_THAT(page_lengths, Not(Each(Pair(1, 100))));
+//   EXPECT_THAT(page_lengths, Each(Key(Le(3))));
+//
+//   const char* user_ids[] = { "joe", "mike", "tom" };
+//   EXPECT_THAT(user_ids, Not(Each(Eq(::std::string("tom")))));
+template <typename M>
+inline internal::EachMatcher<M> Each(M matcher) {
+  return internal::EachMatcher<M>(matcher);
+}
+
+// Key(inner_matcher) matches an std::pair whose 'first' field matches
+// inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
+// std::map that contains at least one element whose key is >= 5.
+template <typename M>
+inline internal::KeyMatcher<M> Key(M inner_matcher) {
+  return internal::KeyMatcher<M>(inner_matcher);
+}
+
+// Pair(first_matcher, second_matcher) matches a std::pair whose 'first' field
+// matches first_matcher and whose 'second' field matches second_matcher.  For
+// example, EXPECT_THAT(map_type, ElementsAre(Pair(Ge(5), "foo"))) can be used
+// to match a std::map<int, string> that contains exactly one element whose key
+// is >= 5 and whose value equals "foo".
+template <typename FirstMatcher, typename SecondMatcher>
+inline internal::PairMatcher<FirstMatcher, SecondMatcher>
+Pair(FirstMatcher first_matcher, SecondMatcher second_matcher) {
+  return internal::PairMatcher<FirstMatcher, SecondMatcher>(
+      first_matcher, second_matcher);
+}
+
+namespace no_adl {
+// FieldsAre(matchers...) matches piecewise the fields of compatible structs.
+// These include those that support `get<I>(obj)`, and when structured bindings
+// are enabled any class that supports them.
+// In particular, `std::tuple`, `std::pair`, `std::array` and aggregate types.
+template <typename... M>
+internal::FieldsAreMatcher<typename std::decay<M>::type...> FieldsAre(
+    M&&... matchers) {
+  return internal::FieldsAreMatcher<typename std::decay<M>::type...>(
+      std::forward<M>(matchers)...);
+}
+
+// Creates a matcher that matches a pointer (raw or smart) that matches
+// inner_matcher.
+template <typename InnerMatcher>
+inline internal::PointerMatcher<InnerMatcher> Pointer(
+    const InnerMatcher& inner_matcher) {
+  return internal::PointerMatcher<InnerMatcher>(inner_matcher);
+}
+
+// Creates a matcher that matches an object that has an address that matches
+// inner_matcher.
+template <typename InnerMatcher>
+inline internal::AddressMatcher<InnerMatcher> Address(
+    const InnerMatcher& inner_matcher) {
+  return internal::AddressMatcher<InnerMatcher>(inner_matcher);
+}
+}  // namespace no_adl
+
+// Returns a predicate that is satisfied by anything that matches the
+// given matcher.
+template <typename M>
+inline internal::MatcherAsPredicate<M> Matches(M matcher) {
+  return internal::MatcherAsPredicate<M>(matcher);
+}
+
+// Returns true if and only if the value matches the matcher.
+template <typename T, typename M>
+inline bool Value(const T& value, M matcher) {
+  return testing::Matches(matcher)(value);
+}
+
+// Matches the value against the given matcher and explains the match
+// result to listener.
+template <typename T, typename M>
+inline bool ExplainMatchResult(
+    M matcher, const T& value, MatchResultListener* listener) {
+  return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);
+}
+
+// Returns a string representation of the given matcher.  Useful for description
+// strings of matchers defined using MATCHER_P* macros that accept matchers as
+// their arguments.  For example:
+//
+// MATCHER_P(XAndYThat, matcher,
+//           "X that " + DescribeMatcher<int>(matcher, negation) +
+//               " and Y that " + DescribeMatcher<double>(matcher, negation)) {
+//   return ExplainMatchResult(matcher, arg.x(), result_listener) &&
+//          ExplainMatchResult(matcher, arg.y(), result_listener);
+// }
+template <typename T, typename M>
+std::string DescribeMatcher(const M& matcher, bool negation = false) {
+  ::std::stringstream ss;
+  Matcher<T> monomorphic_matcher = SafeMatcherCast<T>(matcher);
+  if (negation) {
+    monomorphic_matcher.DescribeNegationTo(&ss);
+  } else {
+    monomorphic_matcher.DescribeTo(&ss);
+  }
+  return ss.str();
+}
+
+template <typename... Args>
+internal::ElementsAreMatcher<
+    std::tuple<typename std::decay<const Args&>::type...>>
+ElementsAre(const Args&... matchers) {
+  return internal::ElementsAreMatcher<
+      std::tuple<typename std::decay<const Args&>::type...>>(
+      std::make_tuple(matchers...));
+}
+
+template <typename... Args>
+internal::UnorderedElementsAreMatcher<
+    std::tuple<typename std::decay<const Args&>::type...>>
+UnorderedElementsAre(const Args&... matchers) {
+  return internal::UnorderedElementsAreMatcher<
+      std::tuple<typename std::decay<const Args&>::type...>>(
+      std::make_tuple(matchers...));
+}
+
+// Define variadic matcher versions.
+template <typename... Args>
+internal::AllOfMatcher<typename std::decay<const Args&>::type...> AllOf(
+    const Args&... matchers) {
+  return internal::AllOfMatcher<typename std::decay<const Args&>::type...>(
+      matchers...);
+}
+
+template <typename... Args>
+internal::AnyOfMatcher<typename std::decay<const Args&>::type...> AnyOf(
+    const Args&... matchers) {
+  return internal::AnyOfMatcher<typename std::decay<const Args&>::type...>(
+      matchers...);
+}
+
+// AnyOfArray(array)
+// AnyOfArray(pointer, count)
+// AnyOfArray(container)
+// AnyOfArray({ e1, e2, ..., en })
+// AnyOfArray(iterator_first, iterator_last)
+//
+// AnyOfArray() verifies whether a given value matches any member of a
+// collection of matchers.
+//
+// AllOfArray(array)
+// AllOfArray(pointer, count)
+// AllOfArray(container)
+// AllOfArray({ e1, e2, ..., en })
+// AllOfArray(iterator_first, iterator_last)
+//
+// AllOfArray() verifies whether a given value matches all members of a
+// collection of matchers.
+//
+// The matchers can be specified as an array, a pointer and count, a container,
+// an initializer list, or an STL iterator range. In each of these cases, the
+// underlying matchers can be either values or matchers.
+
+template <typename Iter>
+inline internal::AnyOfArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+AnyOfArray(Iter first, Iter last) {
+  return internal::AnyOfArrayMatcher<
+      typename ::std::iterator_traits<Iter>::value_type>(first, last);
+}
+
+template <typename Iter>
+inline internal::AllOfArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+AllOfArray(Iter first, Iter last) {
+  return internal::AllOfArrayMatcher<
+      typename ::std::iterator_traits<Iter>::value_type>(first, last);
+}
+
+template <typename T>
+inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T* ptr, size_t count) {
+  return AnyOfArray(ptr, ptr + count);
+}
+
+template <typename T>
+inline internal::AllOfArrayMatcher<T> AllOfArray(const T* ptr, size_t count) {
+  return AllOfArray(ptr, ptr + count);
+}
+
+template <typename T, size_t N>
+inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T (&array)[N]) {
+  return AnyOfArray(array, N);
+}
+
+template <typename T, size_t N>
+inline internal::AllOfArrayMatcher<T> AllOfArray(const T (&array)[N]) {
+  return AllOfArray(array, N);
+}
+
+template <typename Container>
+inline internal::AnyOfArrayMatcher<typename Container::value_type> AnyOfArray(
+    const Container& container) {
+  return AnyOfArray(container.begin(), container.end());
+}
+
+template <typename Container>
+inline internal::AllOfArrayMatcher<typename Container::value_type> AllOfArray(
+    const Container& container) {
+  return AllOfArray(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::AnyOfArrayMatcher<T> AnyOfArray(
+    ::std::initializer_list<T> xs) {
+  return AnyOfArray(xs.begin(), xs.end());
+}
+
+template <typename T>
+inline internal::AllOfArrayMatcher<T> AllOfArray(
+    ::std::initializer_list<T> xs) {
+  return AllOfArray(xs.begin(), xs.end());
+}
+
+// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
+// fields of it matches a_matcher.  C++ doesn't support default
+// arguments for function templates, so we have to overload it.
+template <size_t... k, typename InnerMatcher>
+internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...> Args(
+    InnerMatcher&& matcher) {
+  return internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...>(
+      std::forward<InnerMatcher>(matcher));
+}
+
+// AllArgs(m) is a synonym of m.  This is useful in
+//
+//   EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq()));
+//
+// which is easier to read than
+//
+//   EXPECT_CALL(foo, Bar(_, _)).With(Eq());
+template <typename InnerMatcher>
+inline InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; }
+
+// Returns a matcher that matches the value of an optional<> type variable.
+// The matcher implementation only uses '!arg' and requires that the optional<>
+// type has a 'value_type' member type and that '*arg' is of type 'value_type'
+// and is printable using 'PrintToString'. It is compatible with
+// std::optional/std::experimental::optional.
+// Note that to compare an optional type variable against nullopt you should
+// use Eq(nullopt) and not Eq(Optional(nullopt)). The latter implies that the
+// optional value contains an optional itself.
+template <typename ValueMatcher>
+inline internal::OptionalMatcher<ValueMatcher> Optional(
+    const ValueMatcher& value_matcher) {
+  return internal::OptionalMatcher<ValueMatcher>(value_matcher);
+}
+
+// Returns a matcher that matches the value of a absl::any type variable.
+template <typename T>
+PolymorphicMatcher<internal::any_cast_matcher::AnyCastMatcher<T> > AnyWith(
+    const Matcher<const T&>& matcher) {
+  return MakePolymorphicMatcher(
+      internal::any_cast_matcher::AnyCastMatcher<T>(matcher));
+}
+
+// Returns a matcher that matches the value of a variant<> type variable.
+// The matcher implementation uses ADL to find the holds_alternative and get
+// functions.
+// It is compatible with std::variant.
+template <typename T>
+PolymorphicMatcher<internal::variant_matcher::VariantMatcher<T> > VariantWith(
+    const Matcher<const T&>& matcher) {
+  return MakePolymorphicMatcher(
+      internal::variant_matcher::VariantMatcher<T>(matcher));
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Anything inside the `internal` namespace is internal to the implementation
+// and must not be used in user code!
+namespace internal {
+
+class WithWhatMatcherImpl {
+ public:
+  WithWhatMatcherImpl(Matcher<std::string> matcher)
+      : matcher_(std::move(matcher)) {}
+
+  void DescribeTo(std::ostream* os) const {
+    *os << "contains .what() that ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "contains .what() that does not ";
+    matcher_.DescribeTo(os);
+  }
+
+  template <typename Err>
+  bool MatchAndExplain(const Err& err, MatchResultListener* listener) const {
+    *listener << "which contains .what() that ";
+    return matcher_.MatchAndExplain(err.what(), listener);
+  }
+
+ private:
+  const Matcher<std::string> matcher_;
+};
+
+inline PolymorphicMatcher<WithWhatMatcherImpl> WithWhat(
+    Matcher<std::string> m) {
+  return MakePolymorphicMatcher(WithWhatMatcherImpl(std::move(m)));
+}
+
+template <typename Err>
+class ExceptionMatcherImpl {
+  class NeverThrown {
+   public:
+    const char* what() const noexcept {
+      return "this exception should never be thrown";
+    }
+  };
+
+  // If the matchee raises an exception of a wrong type, we'd like to
+  // catch it and print its message and type. To do that, we add an additional
+  // catch clause:
+  //
+  //     try { ... }
+  //     catch (const Err&) { /* an expected exception */ }
+  //     catch (const std::exception&) { /* exception of a wrong type */ }
+  //
+  // However, if the `Err` itself is `std::exception`, we'd end up with two
+  // identical `catch` clauses:
+  //
+  //     try { ... }
+  //     catch (const std::exception&) { /* an expected exception */ }
+  //     catch (const std::exception&) { /* exception of a wrong type */ }
+  //
+  // This can cause a warning or an error in some compilers. To resolve
+  // the issue, we use a fake error type whenever `Err` is `std::exception`:
+  //
+  //     try { ... }
+  //     catch (const std::exception&) { /* an expected exception */ }
+  //     catch (const NeverThrown&) { /* exception of a wrong type */ }
+  using DefaultExceptionType = typename std::conditional<
+      std::is_same<typename std::remove_cv<
+                       typename std::remove_reference<Err>::type>::type,
+                   std::exception>::value,
+      const NeverThrown&, const std::exception&>::type;
+
+ public:
+  ExceptionMatcherImpl(Matcher<const Err&> matcher)
+      : matcher_(std::move(matcher)) {}
+
+  void DescribeTo(std::ostream* os) const {
+    *os << "throws an exception which is a " << GetTypeName<Err>();
+    *os << " which ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "throws an exception which is not a " << GetTypeName<Err>();
+    *os << " which ";
+    matcher_.DescribeNegationTo(os);
+  }
+
+  template <typename T>
+  bool MatchAndExplain(T&& x, MatchResultListener* listener) const {
+    try {
+      (void)(std::forward<T>(x)());
+    } catch (const Err& err) {
+      *listener << "throws an exception which is a " << GetTypeName<Err>();
+      *listener << " ";
+      return matcher_.MatchAndExplain(err, listener);
+    } catch (DefaultExceptionType err) {
+#if GTEST_HAS_RTTI
+      *listener << "throws an exception of type " << GetTypeName(typeid(err));
+      *listener << " ";
+#else
+      *listener << "throws an std::exception-derived type ";
+#endif
+      *listener << "with description \"" << err.what() << "\"";
+      return false;
+    } catch (...) {
+      *listener << "throws an exception of an unknown type";
+      return false;
+    }
+
+    *listener << "does not throw any exception";
+    return false;
+  }
+
+ private:
+  const Matcher<const Err&> matcher_;
+};
+
+}  // namespace internal
+
+// Throws()
+// Throws(exceptionMatcher)
+// ThrowsMessage(messageMatcher)
+//
+// This matcher accepts a callable and verifies that when invoked, it throws
+// an exception with the given type and properties.
+//
+// Examples:
+//
+//   EXPECT_THAT(
+//       []() { throw std::runtime_error("message"); },
+//       Throws<std::runtime_error>());
+//
+//   EXPECT_THAT(
+//       []() { throw std::runtime_error("message"); },
+//       ThrowsMessage<std::runtime_error>(HasSubstr("message")));
+//
+//   EXPECT_THAT(
+//       []() { throw std::runtime_error("message"); },
+//       Throws<std::runtime_error>(
+//           Property(&std::runtime_error::what, HasSubstr("message"))));
+
+template <typename Err>
+PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws() {
+  return MakePolymorphicMatcher(
+      internal::ExceptionMatcherImpl<Err>(A<const Err&>()));
+}
+
+template <typename Err, typename ExceptionMatcher>
+PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws(
+    const ExceptionMatcher& exception_matcher) {
+  // Using matcher cast allows users to pass a matcher of a more broad type.
+  // For example user may want to pass Matcher<std::exception>
+  // to Throws<std::runtime_error>, or Matcher<int64> to Throws<int32>.
+  return MakePolymorphicMatcher(internal::ExceptionMatcherImpl<Err>(
+      SafeMatcherCast<const Err&>(exception_matcher)));
+}
+
+template <typename Err, typename MessageMatcher>
+PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(
+    MessageMatcher&& message_matcher) {
+  static_assert(std::is_base_of<std::exception, Err>::value,
+                "expected an std::exception-derived type");
+  return Throws<Err>(internal::WithWhat(
+      MatcherCast<std::string>(std::forward<MessageMatcher>(message_matcher))));
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// These macros allow using matchers to check values in Google Test
+// tests.  ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher)
+// succeed if and only if the value matches the matcher.  If the assertion
+// fails, the value and the description of the matcher will be printed.
+#define ASSERT_THAT(value, matcher) ASSERT_PRED_FORMAT1(\
+    ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
+#define EXPECT_THAT(value, matcher) EXPECT_PRED_FORMAT1(\
+    ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
+
+// MATCHER* macroses itself are listed below.
+#define MATCHER(name, description)                                             \
+  class name##Matcher                                                          \
+      : public ::testing::internal::MatcherBaseImpl<name##Matcher> {           \
+   public:                                                                     \
+    template <typename arg_type>                                               \
+    class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> {   \
+     public:                                                                   \
+      gmock_Impl() {}                                                          \
+      bool MatchAndExplain(                                                    \
+          const arg_type& arg,                                                 \
+          ::testing::MatchResultListener* result_listener) const override;     \
+      void DescribeTo(::std::ostream* gmock_os) const override {               \
+        *gmock_os << FormatDescription(false);                                 \
+      }                                                                        \
+      void DescribeNegationTo(::std::ostream* gmock_os) const override {       \
+        *gmock_os << FormatDescription(true);                                  \
+      }                                                                        \
+                                                                               \
+     private:                                                                  \
+      ::std::string FormatDescription(bool negation) const {                   \
+        ::std::string gmock_description = (description);                       \
+        if (!gmock_description.empty()) {                                      \
+          return gmock_description;                                            \
+        }                                                                      \
+        return ::testing::internal::FormatMatcherDescription(negation, #name,  \
+                                                             {});              \
+      }                                                                        \
+    };                                                                         \
+  };                                                                           \
+  GTEST_ATTRIBUTE_UNUSED_ inline name##Matcher name() { return {}; }           \
+  template <typename arg_type>                                                 \
+  bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain(                   \
+      const arg_type& arg,                                                     \
+      ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) \
+      const
+
+#define MATCHER_P(name, p0, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP, description, (p0))
+#define MATCHER_P2(name, p0, p1, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP2, description, (p0, p1))
+#define MATCHER_P3(name, p0, p1, p2, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP3, description, (p0, p1, p2))
+#define MATCHER_P4(name, p0, p1, p2, p3, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP4, description, (p0, p1, p2, p3))
+#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)    \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP5, description, \
+                         (p0, p1, p2, p3, p4))
+#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP6, description,  \
+                         (p0, p1, p2, p3, p4, p5))
+#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP7, description,      \
+                         (p0, p1, p2, p3, p4, p5, p6))
+#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP8, description,          \
+                         (p0, p1, p2, p3, p4, p5, p6, p7))
+#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP9, description,              \
+                         (p0, p1, p2, p3, p4, p5, p6, p7, p8))
+#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP10, description,                  \
+                         (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9))
+
+#define GMOCK_INTERNAL_MATCHER(name, full_name, description, args)             \
+  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
+  class full_name : public ::testing::internal::MatcherBaseImpl<               \
+                        full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>> { \
+   public:                                                                     \
+    using full_name::MatcherBaseImpl::MatcherBaseImpl;                         \
+    template <typename arg_type>                                               \
+    class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> {   \
+     public:                                                                   \
+      explicit gmock_Impl(GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args))          \
+          : GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) {}                       \
+      bool MatchAndExplain(                                                    \
+          const arg_type& arg,                                                 \
+          ::testing::MatchResultListener* result_listener) const override;     \
+      void DescribeTo(::std::ostream* gmock_os) const override {               \
+        *gmock_os << FormatDescription(false);                                 \
+      }                                                                        \
+      void DescribeNegationTo(::std::ostream* gmock_os) const override {       \
+        *gmock_os << FormatDescription(true);                                  \
+      }                                                                        \
+      GMOCK_INTERNAL_MATCHER_MEMBERS(args)                                     \
+                                                                               \
+     private:                                                                  \
+      ::std::string FormatDescription(bool negation) const {                   \
+        ::std::string gmock_description = (description);                       \
+        if (!gmock_description.empty()) {                                      \
+          return gmock_description;                                            \
+        }                                                                      \
+        return ::testing::internal::FormatMatcherDescription(                  \
+            negation, #name,                                                   \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(      \
+                ::std::tuple<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>(        \
+                    GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args))));             \
+      }                                                                        \
+    };                                                                         \
+  };                                                                           \
+  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
+  inline full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)> name(             \
+      GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args)) {                            \
+    return full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>(                \
+        GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args));                              \
+  }                                                                            \
+  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
+  template <typename arg_type>                                                 \
+  bool full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>::gmock_Impl<        \
+      arg_type>::MatchAndExplain(const arg_type& arg,                          \
+                                 ::testing::MatchResultListener*               \
+                                     result_listener GTEST_ATTRIBUTE_UNUSED_)  \
+      const
+
+#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args) \
+  GMOCK_PP_TAIL(                                     \
+      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM, , args))
+#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM(i_unused, data_unused, arg) \
+  , typename arg##_type
+
+#define GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TYPE_PARAM, , args))
+#define GMOCK_INTERNAL_MATCHER_TYPE_PARAM(i_unused, data_unused, arg) \
+  , arg##_type
+
+#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args) \
+  GMOCK_PP_TAIL(dummy_first GMOCK_PP_FOR_EACH(     \
+      GMOCK_INTERNAL_MATCHER_FUNCTION_ARG, , args))
+#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARG(i, data_unused, arg) \
+  , arg##_type gmock_p##i
+
+#define GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_FORWARD_ARG, , args))
+#define GMOCK_INTERNAL_MATCHER_FORWARD_ARG(i, data_unused, arg) \
+  , arg(::std::forward<arg##_type>(gmock_p##i))
+
+#define GMOCK_INTERNAL_MATCHER_MEMBERS(args) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER, , args)
+#define GMOCK_INTERNAL_MATCHER_MEMBER(i_unused, data_unused, arg) \
+  const arg##_type arg;
+
+#define GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER_USAGE, , args))
+#define GMOCK_INTERNAL_MATCHER_MEMBER_USAGE(i_unused, data_unused, arg) , arg
+
+#define GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_ARG_USAGE, , args))
+#define GMOCK_INTERNAL_MATCHER_ARG_USAGE(i, data_unused, arg_unused) \
+  , gmock_p##i
+
+// To prevent ADL on certain functions we put them on a separate namespace.
+using namespace no_adl;  // NOLINT
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 5046
+
+// Include any custom callback matchers added by the local installation.
+// We must include this header at the end to make sure it can use the
+// declarations from this file.
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Injection point for custom user configurations. See README for details
+//
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>  // NOLINT
+#endif
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// An abstract handle of an expectation.
+class Expectation;
+
+// A set of expectation handles.
+class ExpectationSet;
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// Implements a mock function.
+template <typename F> class FunctionMocker;
+
+// Base class for expectations.
+class ExpectationBase;
+
+// Implements an expectation.
+template <typename F> class TypedExpectation;
+
+// Helper class for testing the Expectation class template.
+class ExpectationTester;
+
+// Helper classes for implementing NiceMock, StrictMock, and NaggyMock.
+template <typename MockClass>
+class NiceMockImpl;
+template <typename MockClass>
+class StrictMockImpl;
+template <typename MockClass>
+class NaggyMockImpl;
+
+// Protects the mock object registry (in class Mock), all function
+// mockers, and all expectations.
+//
+// The reason we don't use more fine-grained protection is: when a
+// mock function Foo() is called, it needs to consult its expectations
+// to see which one should be picked.  If another thread is allowed to
+// call a mock function (either Foo() or a different one) at the same
+// time, it could affect the "retired" attributes of Foo()'s
+// expectations when InSequence() is used, and thus affect which
+// expectation gets picked.  Therefore, we sequence all mock function
+// calls to ensure the integrity of the mock objects' states.
+GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);
+
+// Untyped base class for ActionResultHolder<R>.
+class UntypedActionResultHolderBase;
+
+// Abstract base class of FunctionMocker.  This is the
+// type-agnostic part of the function mocker interface.  Its pure
+// virtual methods are implemented by FunctionMocker.
+class GTEST_API_ UntypedFunctionMockerBase {
+ public:
+  UntypedFunctionMockerBase();
+  virtual ~UntypedFunctionMockerBase();
+
+  // Verifies that all expectations on this mock function have been
+  // satisfied.  Reports one or more Google Test non-fatal failures
+  // and returns false if not.
+  bool VerifyAndClearExpectationsLocked()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Clears the ON_CALL()s set on this mock function.
+  virtual void ClearDefaultActionsLocked()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0;
+
+  // In all of the following Untyped* functions, it's the caller's
+  // responsibility to guarantee the correctness of the arguments'
+  // types.
+
+  // Performs the default action with the given arguments and returns
+  // the action's result.  The call description string will be used in
+  // the error message to describe the call in the case the default
+  // action fails.
+  // L = *
+  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
+      void* untyped_args, const std::string& call_description) const = 0;
+
+  // Performs the given action with the given arguments and returns
+  // the action's result.
+  // L = *
+  virtual UntypedActionResultHolderBase* UntypedPerformAction(
+      const void* untyped_action, void* untyped_args) const = 0;
+
+  // Writes a message that the call is uninteresting (i.e. neither
+  // explicitly expected nor explicitly unexpected) to the given
+  // ostream.
+  virtual void UntypedDescribeUninterestingCall(
+      const void* untyped_args,
+      ::std::ostream* os) const
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
+
+  // Returns the expectation that matches the given function arguments
+  // (or NULL is there's no match); when a match is found,
+  // untyped_action is set to point to the action that should be
+  // performed (or NULL if the action is "do default"), and
+  // is_excessive is modified to indicate whether the call exceeds the
+  // expected number.
+  virtual const ExpectationBase* UntypedFindMatchingExpectation(
+      const void* untyped_args,
+      const void** untyped_action, bool* is_excessive,
+      ::std::ostream* what, ::std::ostream* why)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
+
+  // Prints the given function arguments to the ostream.
+  virtual void UntypedPrintArgs(const void* untyped_args,
+                                ::std::ostream* os) const = 0;
+
+  // Sets the mock object this mock method belongs to, and registers
+  // this information in the global mock registry.  Will be called
+  // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
+  // method.
+  void RegisterOwner(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Sets the mock object this mock method belongs to, and sets the
+  // name of the mock function.  Will be called upon each invocation
+  // of this mock function.
+  void SetOwnerAndName(const void* mock_obj, const char* name)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the mock object this mock method belongs to.  Must be
+  // called after RegisterOwner() or SetOwnerAndName() has been
+  // called.
+  const void* MockObject() const
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the name of this mock method.  Must be called after
+  // SetOwnerAndName() has been called.
+  const char* Name() const
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the result of invoking this mock function with the given
+  // arguments.  This function can be safely called from multiple
+  // threads concurrently.  The caller is responsible for deleting the
+  // result.
+  UntypedActionResultHolderBase* UntypedInvokeWith(void* untyped_args)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+ protected:
+  typedef std::vector<const void*> UntypedOnCallSpecs;
+
+  using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>;
+
+  // Returns an Expectation object that references and co-owns exp,
+  // which must be an expectation on this mock function.
+  Expectation GetHandleOf(ExpectationBase* exp);
+
+  // Address of the mock object this mock method belongs to.  Only
+  // valid after this mock method has been called or
+  // ON_CALL/EXPECT_CALL has been invoked on it.
+  const void* mock_obj_;  // Protected by g_gmock_mutex.
+
+  // Name of the function being mocked.  Only valid after this mock
+  // method has been called.
+  const char* name_;  // Protected by g_gmock_mutex.
+
+  // All default action specs for this function mocker.
+  UntypedOnCallSpecs untyped_on_call_specs_;
+
+  // All expectations for this function mocker.
+  //
+  // It's undefined behavior to interleave expectations (EXPECT_CALLs
+  // or ON_CALLs) and mock function calls.  Also, the order of
+  // expectations is important.  Therefore it's a logic race condition
+  // to read/write untyped_expectations_ concurrently.  In order for
+  // tools like tsan to catch concurrent read/write accesses to
+  // untyped_expectations, we deliberately leave accesses to it
+  // unprotected.
+  UntypedExpectations untyped_expectations_;
+};  // class UntypedFunctionMockerBase
+
+// Untyped base class for OnCallSpec<F>.
+class UntypedOnCallSpecBase {
+ public:
+  // The arguments are the location of the ON_CALL() statement.
+  UntypedOnCallSpecBase(const char* a_file, int a_line)
+      : file_(a_file), line_(a_line), last_clause_(kNone) {}
+
+  // Where in the source file was the default action spec defined?
+  const char* file() const { return file_; }
+  int line() const { return line_; }
+
+ protected:
+  // Gives each clause in the ON_CALL() statement a name.
+  enum Clause {
+    // Do not change the order of the enum members!  The run-time
+    // syntax checking relies on it.
+    kNone,
+    kWith,
+    kWillByDefault
+  };
+
+  // Asserts that the ON_CALL() statement has a certain property.
+  void AssertSpecProperty(bool property,
+                          const std::string& failure_message) const {
+    Assert(property, file_, line_, failure_message);
+  }
+
+  // Expects that the ON_CALL() statement has a certain property.
+  void ExpectSpecProperty(bool property,
+                          const std::string& failure_message) const {
+    Expect(property, file_, line_, failure_message);
+  }
+
+  const char* file_;
+  int line_;
+
+  // The last clause in the ON_CALL() statement as seen so far.
+  // Initially kNone and changes as the statement is parsed.
+  Clause last_clause_;
+};  // class UntypedOnCallSpecBase
+
+// This template class implements an ON_CALL spec.
+template <typename F>
+class OnCallSpec : public UntypedOnCallSpecBase {
+ public:
+  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
+
+  // Constructs an OnCallSpec object from the information inside
+  // the parenthesis of an ON_CALL() statement.
+  OnCallSpec(const char* a_file, int a_line,
+             const ArgumentMatcherTuple& matchers)
+      : UntypedOnCallSpecBase(a_file, a_line),
+        matchers_(matchers),
+        // By default, extra_matcher_ should match anything.  However,
+        // we cannot initialize it with _ as that causes ambiguity between
+        // Matcher's copy and move constructor for some argument types.
+        extra_matcher_(A<const ArgumentTuple&>()) {}
+
+  // Implements the .With() clause.
+  OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) {
+    // Makes sure this is called at most once.
+    ExpectSpecProperty(last_clause_ < kWith,
+                       ".With() cannot appear "
+                       "more than once in an ON_CALL().");
+    last_clause_ = kWith;
+
+    extra_matcher_ = m;
+    return *this;
+  }
+
+  // Implements the .WillByDefault() clause.
+  OnCallSpec& WillByDefault(const Action<F>& action) {
+    ExpectSpecProperty(last_clause_ < kWillByDefault,
+                       ".WillByDefault() must appear "
+                       "exactly once in an ON_CALL().");
+    last_clause_ = kWillByDefault;
+
+    ExpectSpecProperty(!action.IsDoDefault(),
+                       "DoDefault() cannot be used in ON_CALL().");
+    action_ = action;
+    return *this;
+  }
+
+  // Returns true if and only if the given arguments match the matchers.
+  bool Matches(const ArgumentTuple& args) const {
+    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
+  }
+
+  // Returns the action specified by the user.
+  const Action<F>& GetAction() const {
+    AssertSpecProperty(last_clause_ == kWillByDefault,
+                       ".WillByDefault() must appear exactly "
+                       "once in an ON_CALL().");
+    return action_;
+  }
+
+ private:
+  // The information in statement
+  //
+  //   ON_CALL(mock_object, Method(matchers))
+  //       .With(multi-argument-matcher)
+  //       .WillByDefault(action);
+  //
+  // is recorded in the data members like this:
+  //
+  //   source file that contains the statement => file_
+  //   line number of the statement            => line_
+  //   matchers                                => matchers_
+  //   multi-argument-matcher                  => extra_matcher_
+  //   action                                  => action_
+  ArgumentMatcherTuple matchers_;
+  Matcher<const ArgumentTuple&> extra_matcher_;
+  Action<F> action_;
+};  // class OnCallSpec
+
+// Possible reactions on uninteresting calls.
+enum CallReaction {
+  kAllow,
+  kWarn,
+  kFail,
+};
+
+}  // namespace internal
+
+// Utilities for manipulating mock objects.
+class GTEST_API_ Mock {
+ public:
+  // The following public methods can be called concurrently.
+
+  // Tells Google Mock to ignore mock_obj when checking for leaked
+  // mock objects.
+  static void AllowLeak(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies and clears all expectations on the given mock object.
+  // If the expectations aren't satisfied, generates one or more
+  // Google Test non-fatal failures and returns false.
+  static bool VerifyAndClearExpectations(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies all expectations on the given mock object and clears its
+  // default actions and expectations.  Returns true if and only if the
+  // verification was successful.
+  static bool VerifyAndClear(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Returns whether the mock was created as a naggy mock (default)
+  static bool IsNaggy(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+  // Returns whether the mock was created as a nice mock
+  static bool IsNice(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+  // Returns whether the mock was created as a strict mock
+  static bool IsStrict(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+ private:
+  friend class internal::UntypedFunctionMockerBase;
+
+  // Needed for a function mocker to register itself (so that we know
+  // how to clear a mock object).
+  template <typename F>
+  friend class internal::FunctionMocker;
+
+  template <typename MockClass>
+  friend class internal::NiceMockImpl;
+  template <typename MockClass>
+  friend class internal::NaggyMockImpl;
+  template <typename MockClass>
+  friend class internal::StrictMockImpl;
+
+  // Tells Google Mock to allow uninteresting calls on the given mock
+  // object.
+  static void AllowUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock to warn the user about uninteresting calls on
+  // the given mock object.
+  static void WarnUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock to fail uninteresting calls on the given mock
+  // object.
+  static void FailUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock the given mock object is being destroyed and
+  // its entry in the call-reaction table should be removed.
+  static void UnregisterCallReaction(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Returns the reaction Google Mock will have on uninteresting calls
+  // made on the given mock object.
+  static internal::CallReaction GetReactionOnUninterestingCalls(
+      const void* mock_obj)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies that all expectations on the given mock object have been
+  // satisfied.  Reports one or more Google Test non-fatal failures
+  // and returns false if not.
+  static bool VerifyAndClearExpectationsLocked(void* mock_obj)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+
+  // Clears all ON_CALL()s set on the given mock object.
+  static void ClearDefaultActionsLocked(void* mock_obj)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+
+  // Registers a mock object and a mock method it owns.
+  static void Register(
+      const void* mock_obj,
+      internal::UntypedFunctionMockerBase* mocker)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock where in the source code mock_obj is used in an
+  // ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
+  // information helps the user identify which object it is.
+  static void RegisterUseByOnCallOrExpectCall(
+      const void* mock_obj, const char* file, int line)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Unregisters a mock method; removes the owning mock object from
+  // the registry when the last mock method associated with it has
+  // been unregistered.  This is called only in the destructor of
+  // FunctionMocker.
+  static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+};  // class Mock
+
+// An abstract handle of an expectation.  Useful in the .After()
+// clause of EXPECT_CALL() for setting the (partial) order of
+// expectations.  The syntax:
+//
+//   Expectation e1 = EXPECT_CALL(...)...;
+//   EXPECT_CALL(...).After(e1)...;
+//
+// sets two expectations where the latter can only be matched after
+// the former has been satisfied.
+//
+// Notes:
+//   - This class is copyable and has value semantics.
+//   - Constness is shallow: a const Expectation object itself cannot
+//     be modified, but the mutable methods of the ExpectationBase
+//     object it references can be called via expectation_base().
+
+class GTEST_API_ Expectation {
+ public:
+  // Constructs a null object that doesn't reference any expectation.
+  Expectation();
+  Expectation(Expectation&&) = default;
+  Expectation(const Expectation&) = default;
+  Expectation& operator=(Expectation&&) = default;
+  Expectation& operator=(const Expectation&) = default;
+  ~Expectation();
+
+  // This single-argument ctor must not be explicit, in order to support the
+  //   Expectation e = EXPECT_CALL(...);
+  // syntax.
+  //
+  // A TypedExpectation object stores its pre-requisites as
+  // Expectation objects, and needs to call the non-const Retire()
+  // method on the ExpectationBase objects they reference.  Therefore
+  // Expectation must receive a *non-const* reference to the
+  // ExpectationBase object.
+  Expectation(internal::ExpectationBase& exp);  // NOLINT
+
+  // The compiler-generated copy ctor and operator= work exactly as
+  // intended, so we don't need to define our own.
+
+  // Returns true if and only if rhs references the same expectation as this
+  // object does.
+  bool operator==(const Expectation& rhs) const {
+    return expectation_base_ == rhs.expectation_base_;
+  }
+
+  bool operator!=(const Expectation& rhs) const { return !(*this == rhs); }
+
+ private:
+  friend class ExpectationSet;
+  friend class Sequence;
+  friend class ::testing::internal::ExpectationBase;
+  friend class ::testing::internal::UntypedFunctionMockerBase;
+
+  template <typename F>
+  friend class ::testing::internal::FunctionMocker;
+
+  template <typename F>
+  friend class ::testing::internal::TypedExpectation;
+
+  // This comparator is needed for putting Expectation objects into a set.
+  class Less {
+   public:
+    bool operator()(const Expectation& lhs, const Expectation& rhs) const {
+      return lhs.expectation_base_.get() < rhs.expectation_base_.get();
+    }
+  };
+
+  typedef ::std::set<Expectation, Less> Set;
+
+  Expectation(
+      const std::shared_ptr<internal::ExpectationBase>& expectation_base);
+
+  // Returns the expectation this object references.
+  const std::shared_ptr<internal::ExpectationBase>& expectation_base() const {
+    return expectation_base_;
+  }
+
+  // A shared_ptr that co-owns the expectation this handle references.
+  std::shared_ptr<internal::ExpectationBase> expectation_base_;
+};
+
+// A set of expectation handles.  Useful in the .After() clause of
+// EXPECT_CALL() for setting the (partial) order of expectations.  The
+// syntax:
+//
+//   ExpectationSet es;
+//   es += EXPECT_CALL(...)...;
+//   es += EXPECT_CALL(...)...;
+//   EXPECT_CALL(...).After(es)...;
+//
+// sets three expectations where the last one can only be matched
+// after the first two have both been satisfied.
+//
+// This class is copyable and has value semantics.
+class ExpectationSet {
+ public:
+  // A bidirectional iterator that can read a const element in the set.
+  typedef Expectation::Set::const_iterator const_iterator;
+
+  // An object stored in the set.  This is an alias of Expectation.
+  typedef Expectation::Set::value_type value_type;
+
+  // Constructs an empty set.
+  ExpectationSet() {}
+
+  // This single-argument ctor must not be explicit, in order to support the
+  //   ExpectationSet es = EXPECT_CALL(...);
+  // syntax.
+  ExpectationSet(internal::ExpectationBase& exp) {  // NOLINT
+    *this += Expectation(exp);
+  }
+
+  // This single-argument ctor implements implicit conversion from
+  // Expectation and thus must not be explicit.  This allows either an
+  // Expectation or an ExpectationSet to be used in .After().
+  ExpectationSet(const Expectation& e) {  // NOLINT
+    *this += e;
+  }
+
+  // The compiler-generator ctor and operator= works exactly as
+  // intended, so we don't need to define our own.
+
+  // Returns true if and only if rhs contains the same set of Expectation
+  // objects as this does.
+  bool operator==(const ExpectationSet& rhs) const {
+    return expectations_ == rhs.expectations_;
+  }
+
+  bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); }
+
+  // Implements the syntax
+  //   expectation_set += EXPECT_CALL(...);
+  ExpectationSet& operator+=(const Expectation& e) {
+    expectations_.insert(e);
+    return *this;
+  }
+
+  int size() const { return static_cast<int>(expectations_.size()); }
+
+  const_iterator begin() const { return expectations_.begin(); }
+  const_iterator end() const { return expectations_.end(); }
+
+ private:
+  Expectation::Set expectations_;
+};
+
+
+// Sequence objects are used by a user to specify the relative order
+// in which the expectations should match.  They are copyable (we rely
+// on the compiler-defined copy constructor and assignment operator).
+class GTEST_API_ Sequence {
+ public:
+  // Constructs an empty sequence.
+  Sequence() : last_expectation_(new Expectation) {}
+
+  // Adds an expectation to this sequence.  The caller must ensure
+  // that no other thread is accessing this Sequence object.
+  void AddExpectation(const Expectation& expectation) const;
+
+ private:
+  // The last expectation in this sequence.
+  std::shared_ptr<Expectation> last_expectation_;
+};  // class Sequence
+
+// An object of this type causes all EXPECT_CALL() statements
+// encountered in its scope to be put in an anonymous sequence.  The
+// work is done in the constructor and destructor.  You should only
+// create an InSequence object on the stack.
+//
+// The sole purpose for this class is to support easy definition of
+// sequential expectations, e.g.
+//
+//   {
+//     InSequence dummy;  // The name of the object doesn't matter.
+//
+//     // The following expectations must match in the order they appear.
+//     EXPECT_CALL(a, Bar())...;
+//     EXPECT_CALL(a, Baz())...;
+//     ...
+//     EXPECT_CALL(b, Xyz())...;
+//   }
+//
+// You can create InSequence objects in multiple threads, as long as
+// they are used to affect different mock objects.  The idea is that
+// each thread can create and set up its own mocks as if it's the only
+// thread.  However, for clarity of your tests we recommend you to set
+// up mocks in the main thread unless you have a good reason not to do
+// so.
+class GTEST_API_ InSequence {
+ public:
+  InSequence();
+  ~InSequence();
+ private:
+  bool sequence_created_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence);  // NOLINT
+} GTEST_ATTRIBUTE_UNUSED_;
+
+namespace internal {
+
+// Points to the implicit sequence introduced by a living InSequence
+// object (if any) in the current thread or NULL.
+GTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence;
+
+// Base class for implementing expectations.
+//
+// There are two reasons for having a type-agnostic base class for
+// Expectation:
+//
+//   1. We need to store collections of expectations of different
+//   types (e.g. all pre-requisites of a particular expectation, all
+//   expectations in a sequence).  Therefore these expectation objects
+//   must share a common base class.
+//
+//   2. We can avoid binary code bloat by moving methods not depending
+//   on the template argument of Expectation to the base class.
+//
+// This class is internal and mustn't be used by user code directly.
+class GTEST_API_ ExpectationBase {
+ public:
+  // source_text is the EXPECT_CALL(...) source that created this Expectation.
+  ExpectationBase(const char* file, int line, const std::string& source_text);
+
+  virtual ~ExpectationBase();
+
+  // Where in the source file was the expectation spec defined?
+  const char* file() const { return file_; }
+  int line() const { return line_; }
+  const char* source_text() const { return source_text_.c_str(); }
+  // Returns the cardinality specified in the expectation spec.
+  const Cardinality& cardinality() const { return cardinality_; }
+
+  // Describes the source file location of this expectation.
+  void DescribeLocationTo(::std::ostream* os) const {
+    *os << FormatFileLocation(file(), line()) << " ";
+  }
+
+  // Describes how many times a function call matching this
+  // expectation has occurred.
+  void DescribeCallCountTo(::std::ostream* os) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // If this mock method has an extra matcher (i.e. .With(matcher)),
+  // describes it to the ostream.
+  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0;
+
+ protected:
+  friend class ::testing::Expectation;
+  friend class UntypedFunctionMockerBase;
+
+  enum Clause {
+    // Don't change the order of the enum members!
+    kNone,
+    kWith,
+    kTimes,
+    kInSequence,
+    kAfter,
+    kWillOnce,
+    kWillRepeatedly,
+    kRetiresOnSaturation
+  };
+
+  typedef std::vector<const void*> UntypedActions;
+
+  // Returns an Expectation object that references and co-owns this
+  // expectation.
+  virtual Expectation GetHandle() = 0;
+
+  // Asserts that the EXPECT_CALL() statement has the given property.
+  void AssertSpecProperty(bool property,
+                          const std::string& failure_message) const {
+    Assert(property, file_, line_, failure_message);
+  }
+
+  // Expects that the EXPECT_CALL() statement has the given property.
+  void ExpectSpecProperty(bool property,
+                          const std::string& failure_message) const {
+    Expect(property, file_, line_, failure_message);
+  }
+
+  // Explicitly specifies the cardinality of this expectation.  Used
+  // by the subclasses to implement the .Times() clause.
+  void SpecifyCardinality(const Cardinality& cardinality);
+
+  // Returns true if and only if the user specified the cardinality
+  // explicitly using a .Times().
+  bool cardinality_specified() const { return cardinality_specified_; }
+
+  // Sets the cardinality of this expectation spec.
+  void set_cardinality(const Cardinality& a_cardinality) {
+    cardinality_ = a_cardinality;
+  }
+
+  // The following group of methods should only be called after the
+  // EXPECT_CALL() statement, and only when g_gmock_mutex is held by
+  // the current thread.
+
+  // Retires all pre-requisites of this expectation.
+  void RetireAllPreRequisites()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Returns true if and only if this expectation is retired.
+  bool is_retired() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return retired_;
+  }
+
+  // Retires this expectation.
+  void Retire()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    retired_ = true;
+  }
+
+  // Returns true if and only if this expectation is satisfied.
+  bool IsSatisfied() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return cardinality().IsSatisfiedByCallCount(call_count_);
+  }
+
+  // Returns true if and only if this expectation is saturated.
+  bool IsSaturated() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return cardinality().IsSaturatedByCallCount(call_count_);
+  }
+
+  // Returns true if and only if this expectation is over-saturated.
+  bool IsOverSaturated() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return cardinality().IsOverSaturatedByCallCount(call_count_);
+  }
+
+  // Returns true if and only if all pre-requisites of this expectation are
+  // satisfied.
+  bool AllPrerequisitesAreSatisfied() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Adds unsatisfied pre-requisites of this expectation to 'result'.
+  void FindUnsatisfiedPrerequisites(ExpectationSet* result) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Returns the number this expectation has been invoked.
+  int call_count() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return call_count_;
+  }
+
+  // Increments the number this expectation has been invoked.
+  void IncrementCallCount()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    call_count_++;
+  }
+
+  // Checks the action count (i.e. the number of WillOnce() and
+  // WillRepeatedly() clauses) against the cardinality if this hasn't
+  // been done before.  Prints a warning if there are too many or too
+  // few actions.
+  void CheckActionCountIfNotDone() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  friend class ::testing::Sequence;
+  friend class ::testing::internal::ExpectationTester;
+
+  template <typename Function>
+  friend class TypedExpectation;
+
+  // Implements the .Times() clause.
+  void UntypedTimes(const Cardinality& a_cardinality);
+
+  // This group of fields are part of the spec and won't change after
+  // an EXPECT_CALL() statement finishes.
+  const char* file_;          // The file that contains the expectation.
+  int line_;                  // The line number of the expectation.
+  const std::string source_text_;  // The EXPECT_CALL(...) source text.
+  // True if and only if the cardinality is specified explicitly.
+  bool cardinality_specified_;
+  Cardinality cardinality_;            // The cardinality of the expectation.
+  // The immediate pre-requisites (i.e. expectations that must be
+  // satisfied before this expectation can be matched) of this
+  // expectation.  We use std::shared_ptr in the set because we want an
+  // Expectation object to be co-owned by its FunctionMocker and its
+  // successors.  This allows multiple mock objects to be deleted at
+  // different times.
+  ExpectationSet immediate_prerequisites_;
+
+  // This group of fields are the current state of the expectation,
+  // and can change as the mock function is called.
+  int call_count_;  // How many times this expectation has been invoked.
+  bool retired_;    // True if and only if this expectation has retired.
+  UntypedActions untyped_actions_;
+  bool extra_matcher_specified_;
+  bool repeated_action_specified_;  // True if a WillRepeatedly() was specified.
+  bool retires_on_saturation_;
+  Clause last_clause_;
+  mutable bool action_count_checked_;  // Under mutex_.
+  mutable Mutex mutex_;  // Protects action_count_checked_.
+};  // class ExpectationBase
+
+// Impements an expectation for the given function type.
+template <typename F>
+class TypedExpectation : public ExpectationBase {
+ public:
+  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
+  typedef typename Function<F>::Result Result;
+
+  TypedExpectation(FunctionMocker<F>* owner, const char* a_file, int a_line,
+                   const std::string& a_source_text,
+                   const ArgumentMatcherTuple& m)
+      : ExpectationBase(a_file, a_line, a_source_text),
+        owner_(owner),
+        matchers_(m),
+        // By default, extra_matcher_ should match anything.  However,
+        // we cannot initialize it with _ as that causes ambiguity between
+        // Matcher's copy and move constructor for some argument types.
+        extra_matcher_(A<const ArgumentTuple&>()),
+        repeated_action_(DoDefault()) {}
+
+  ~TypedExpectation() override {
+    // Check the validity of the action count if it hasn't been done
+    // yet (for example, if the expectation was never used).
+    CheckActionCountIfNotDone();
+    for (UntypedActions::const_iterator it = untyped_actions_.begin();
+         it != untyped_actions_.end(); ++it) {
+      delete static_cast<const Action<F>*>(*it);
+    }
+  }
+
+  // Implements the .With() clause.
+  TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) {
+    if (last_clause_ == kWith) {
+      ExpectSpecProperty(false,
+                         ".With() cannot appear "
+                         "more than once in an EXPECT_CALL().");
+    } else {
+      ExpectSpecProperty(last_clause_ < kWith,
+                         ".With() must be the first "
+                         "clause in an EXPECT_CALL().");
+    }
+    last_clause_ = kWith;
+
+    extra_matcher_ = m;
+    extra_matcher_specified_ = true;
+    return *this;
+  }
+
+  // Implements the .Times() clause.
+  TypedExpectation& Times(const Cardinality& a_cardinality) {
+    ExpectationBase::UntypedTimes(a_cardinality);
+    return *this;
+  }
+
+  // Implements the .Times() clause.
+  TypedExpectation& Times(int n) {
+    return Times(Exactly(n));
+  }
+
+  // Implements the .InSequence() clause.
+  TypedExpectation& InSequence(const Sequence& s) {
+    ExpectSpecProperty(last_clause_ <= kInSequence,
+                       ".InSequence() cannot appear after .After(),"
+                       " .WillOnce(), .WillRepeatedly(), or "
+                       ".RetiresOnSaturation().");
+    last_clause_ = kInSequence;
+
+    s.AddExpectation(GetHandle());
+    return *this;
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) {
+    return InSequence(s1).InSequence(s2);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3) {
+    return InSequence(s1, s2).InSequence(s3);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3, const Sequence& s4) {
+    return InSequence(s1, s2, s3).InSequence(s4);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3, const Sequence& s4,
+                               const Sequence& s5) {
+    return InSequence(s1, s2, s3, s4).InSequence(s5);
+  }
+
+  // Implements that .After() clause.
+  TypedExpectation& After(const ExpectationSet& s) {
+    ExpectSpecProperty(last_clause_ <= kAfter,
+                       ".After() cannot appear after .WillOnce(),"
+                       " .WillRepeatedly(), or "
+                       ".RetiresOnSaturation().");
+    last_clause_ = kAfter;
+
+    for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) {
+      immediate_prerequisites_ += *it;
+    }
+    return *this;
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) {
+    return After(s1).After(s2);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3) {
+    return After(s1, s2).After(s3);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3, const ExpectationSet& s4) {
+    return After(s1, s2, s3).After(s4);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3, const ExpectationSet& s4,
+                          const ExpectationSet& s5) {
+    return After(s1, s2, s3, s4).After(s5);
+  }
+
+  // Implements the .WillOnce() clause.
+  TypedExpectation& WillOnce(const Action<F>& action) {
+    ExpectSpecProperty(last_clause_ <= kWillOnce,
+                       ".WillOnce() cannot appear after "
+                       ".WillRepeatedly() or .RetiresOnSaturation().");
+    last_clause_ = kWillOnce;
+
+    untyped_actions_.push_back(new Action<F>(action));
+    if (!cardinality_specified()) {
+      set_cardinality(Exactly(static_cast<int>(untyped_actions_.size())));
+    }
+    return *this;
+  }
+
+  // Implements the .WillRepeatedly() clause.
+  TypedExpectation& WillRepeatedly(const Action<F>& action) {
+    if (last_clause_ == kWillRepeatedly) {
+      ExpectSpecProperty(false,
+                         ".WillRepeatedly() cannot appear "
+                         "more than once in an EXPECT_CALL().");
+    } else {
+      ExpectSpecProperty(last_clause_ < kWillRepeatedly,
+                         ".WillRepeatedly() cannot appear "
+                         "after .RetiresOnSaturation().");
+    }
+    last_clause_ = kWillRepeatedly;
+    repeated_action_specified_ = true;
+
+    repeated_action_ = action;
+    if (!cardinality_specified()) {
+      set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size())));
+    }
+
+    // Now that no more action clauses can be specified, we check
+    // whether their count makes sense.
+    CheckActionCountIfNotDone();
+    return *this;
+  }
+
+  // Implements the .RetiresOnSaturation() clause.
+  TypedExpectation& RetiresOnSaturation() {
+    ExpectSpecProperty(last_clause_ < kRetiresOnSaturation,
+                       ".RetiresOnSaturation() cannot appear "
+                       "more than once.");
+    last_clause_ = kRetiresOnSaturation;
+    retires_on_saturation_ = true;
+
+    // Now that no more action clauses can be specified, we check
+    // whether their count makes sense.
+    CheckActionCountIfNotDone();
+    return *this;
+  }
+
+  // Returns the matchers for the arguments as specified inside the
+  // EXPECT_CALL() macro.
+  const ArgumentMatcherTuple& matchers() const {
+    return matchers_;
+  }
+
+  // Returns the matcher specified by the .With() clause.
+  const Matcher<const ArgumentTuple&>& extra_matcher() const {
+    return extra_matcher_;
+  }
+
+  // Returns the action specified by the .WillRepeatedly() clause.
+  const Action<F>& repeated_action() const { return repeated_action_; }
+
+  // If this mock method has an extra matcher (i.e. .With(matcher)),
+  // describes it to the ostream.
+  void MaybeDescribeExtraMatcherTo(::std::ostream* os) override {
+    if (extra_matcher_specified_) {
+      *os << "    Expected args: ";
+      extra_matcher_.DescribeTo(os);
+      *os << "\n";
+    }
+  }
+
+ private:
+  template <typename Function>
+  friend class FunctionMocker;
+
+  // Returns an Expectation object that references and co-owns this
+  // expectation.
+  Expectation GetHandle() override { return owner_->GetHandleOf(this); }
+
+  // The following methods will be called only after the EXPECT_CALL()
+  // statement finishes and when the current thread holds
+  // g_gmock_mutex.
+
+  // Returns true if and only if this expectation matches the given arguments.
+  bool Matches(const ArgumentTuple& args) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
+  }
+
+  // Returns true if and only if this expectation should handle the given
+  // arguments.
+  bool ShouldHandleArguments(const ArgumentTuple& args) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    // In case the action count wasn't checked when the expectation
+    // was defined (e.g. if this expectation has no WillRepeatedly()
+    // or RetiresOnSaturation() clause), we check it when the
+    // expectation is used for the first time.
+    CheckActionCountIfNotDone();
+    return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args);
+  }
+
+  // Describes the result of matching the arguments against this
+  // expectation to the given ostream.
+  void ExplainMatchResultTo(
+      const ArgumentTuple& args,
+      ::std::ostream* os) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    if (is_retired()) {
+      *os << "         Expected: the expectation is active\n"
+          << "           Actual: it is retired\n";
+    } else if (!Matches(args)) {
+      if (!TupleMatches(matchers_, args)) {
+        ExplainMatchFailureTupleTo(matchers_, args, os);
+      }
+      StringMatchResultListener listener;
+      if (!extra_matcher_.MatchAndExplain(args, &listener)) {
+        *os << "    Expected args: ";
+        extra_matcher_.DescribeTo(os);
+        *os << "\n           Actual: don't match";
+
+        internal::PrintIfNotEmpty(listener.str(), os);
+        *os << "\n";
+      }
+    } else if (!AllPrerequisitesAreSatisfied()) {
+      *os << "         Expected: all pre-requisites are satisfied\n"
+          << "           Actual: the following immediate pre-requisites "
+          << "are not satisfied:\n";
+      ExpectationSet unsatisfied_prereqs;
+      FindUnsatisfiedPrerequisites(&unsatisfied_prereqs);
+      int i = 0;
+      for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin();
+           it != unsatisfied_prereqs.end(); ++it) {
+        it->expectation_base()->DescribeLocationTo(os);
+        *os << "pre-requisite #" << i++ << "\n";
+      }
+      *os << "                   (end of pre-requisites)\n";
+    } else {
+      // This line is here just for completeness' sake.  It will never
+      // be executed as currently the ExplainMatchResultTo() function
+      // is called only when the mock function call does NOT match the
+      // expectation.
+      *os << "The call matches the expectation.\n";
+    }
+  }
+
+  // Returns the action that should be taken for the current invocation.
+  const Action<F>& GetCurrentAction(const FunctionMocker<F>* mocker,
+                                    const ArgumentTuple& args) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    const int count = call_count();
+    Assert(count >= 1, __FILE__, __LINE__,
+           "call_count() is <= 0 when GetCurrentAction() is "
+           "called - this should never happen.");
+
+    const int action_count = static_cast<int>(untyped_actions_.size());
+    if (action_count > 0 && !repeated_action_specified_ &&
+        count > action_count) {
+      // If there is at least one WillOnce() and no WillRepeatedly(),
+      // we warn the user when the WillOnce() clauses ran out.
+      ::std::stringstream ss;
+      DescribeLocationTo(&ss);
+      ss << "Actions ran out in " << source_text() << "...\n"
+         << "Called " << count << " times, but only "
+         << action_count << " WillOnce()"
+         << (action_count == 1 ? " is" : "s are") << " specified - ";
+      mocker->DescribeDefaultActionTo(args, &ss);
+      Log(kWarning, ss.str(), 1);
+    }
+
+    return count <= action_count
+               ? *static_cast<const Action<F>*>(
+                     untyped_actions_[static_cast<size_t>(count - 1)])
+               : repeated_action();
+  }
+
+  // Given the arguments of a mock function call, if the call will
+  // over-saturate this expectation, returns the default action;
+  // otherwise, returns the next action in this expectation.  Also
+  // describes *what* happened to 'what', and explains *why* Google
+  // Mock does it to 'why'.  This method is not const as it calls
+  // IncrementCallCount().  A return value of NULL means the default
+  // action.
+  const Action<F>* GetActionForArguments(const FunctionMocker<F>* mocker,
+                                         const ArgumentTuple& args,
+                                         ::std::ostream* what,
+                                         ::std::ostream* why)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    if (IsSaturated()) {
+      // We have an excessive call.
+      IncrementCallCount();
+      *what << "Mock function called more times than expected - ";
+      mocker->DescribeDefaultActionTo(args, what);
+      DescribeCallCountTo(why);
+
+      return nullptr;
+    }
+
+    IncrementCallCount();
+    RetireAllPreRequisites();
+
+    if (retires_on_saturation_ && IsSaturated()) {
+      Retire();
+    }
+
+    // Must be done after IncrementCount()!
+    *what << "Mock function call matches " << source_text() <<"...\n";
+    return &(GetCurrentAction(mocker, args));
+  }
+
+  // All the fields below won't change once the EXPECT_CALL()
+  // statement finishes.
+  FunctionMocker<F>* const owner_;
+  ArgumentMatcherTuple matchers_;
+  Matcher<const ArgumentTuple&> extra_matcher_;
+  Action<F> repeated_action_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
+};  // class TypedExpectation
+
+// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
+// specifying the default behavior of, or expectation on, a mock
+// function.
+
+// Note: class MockSpec really belongs to the ::testing namespace.
+// However if we define it in ::testing, MSVC will complain when
+// classes in ::testing::internal declare it as a friend class
+// template.  To workaround this compiler bug, we define MockSpec in
+// ::testing::internal and import it into ::testing.
+
+// Logs a message including file and line number information.
+GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
+                                const char* file, int line,
+                                const std::string& message);
+
+template <typename F>
+class MockSpec {
+ public:
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename internal::Function<F>::ArgumentMatcherTuple
+      ArgumentMatcherTuple;
+
+  // Constructs a MockSpec object, given the function mocker object
+  // that the spec is associated with.
+  MockSpec(internal::FunctionMocker<F>* function_mocker,
+           const ArgumentMatcherTuple& matchers)
+      : function_mocker_(function_mocker), matchers_(matchers) {}
+
+  // Adds a new default action spec to the function mocker and returns
+  // the newly created spec.
+  internal::OnCallSpec<F>& InternalDefaultActionSetAt(
+      const char* file, int line, const char* obj, const char* call) {
+    LogWithLocation(internal::kInfo, file, line,
+                    std::string("ON_CALL(") + obj + ", " + call + ") invoked");
+    return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
+  }
+
+  // Adds a new expectation spec to the function mocker and returns
+  // the newly created spec.
+  internal::TypedExpectation<F>& InternalExpectedAt(
+      const char* file, int line, const char* obj, const char* call) {
+    const std::string source_text(std::string("EXPECT_CALL(") + obj + ", " +
+                                  call + ")");
+    LogWithLocation(internal::kInfo, file, line, source_text + " invoked");
+    return function_mocker_->AddNewExpectation(
+        file, line, source_text, matchers_);
+  }
+
+  // This operator overload is used to swallow the superfluous parameter list
+  // introduced by the ON/EXPECT_CALL macros. See the macro comments for more
+  // explanation.
+  MockSpec<F>& operator()(const internal::WithoutMatchers&, void* const) {
+    return *this;
+  }
+
+ private:
+  template <typename Function>
+  friend class internal::FunctionMocker;
+
+  // The function mocker that owns this spec.
+  internal::FunctionMocker<F>* const function_mocker_;
+  // The argument matchers specified in the spec.
+  ArgumentMatcherTuple matchers_;
+};  // class MockSpec
+
+// Wrapper type for generically holding an ordinary value or lvalue reference.
+// If T is not a reference type, it must be copyable or movable.
+// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless
+// T is a move-only value type (which means that it will always be copyable
+// if the current platform does not support move semantics).
+//
+// The primary template defines handling for values, but function header
+// comments describe the contract for the whole template (including
+// specializations).
+template <typename T>
+class ReferenceOrValueWrapper {
+ public:
+  // Constructs a wrapper from the given value/reference.
+  explicit ReferenceOrValueWrapper(T value)
+      : value_(std::move(value)) {
+  }
+
+  // Unwraps and returns the underlying value/reference, exactly as
+  // originally passed. The behavior of calling this more than once on
+  // the same object is unspecified.
+  T Unwrap() { return std::move(value_); }
+
+  // Provides nondestructive access to the underlying value/reference.
+  // Always returns a const reference (more precisely,
+  // const std::add_lvalue_reference<T>::type). The behavior of calling this
+  // after calling Unwrap on the same object is unspecified.
+  const T& Peek() const {
+    return value_;
+  }
+
+ private:
+  T value_;
+};
+
+// Specialization for lvalue reference types. See primary template
+// for documentation.
+template <typename T>
+class ReferenceOrValueWrapper<T&> {
+ public:
+  // Workaround for debatable pass-by-reference lint warning (c-library-team
+  // policy precludes NOLINT in this context)
+  typedef T& reference;
+  explicit ReferenceOrValueWrapper(reference ref)
+      : value_ptr_(&ref) {}
+  T& Unwrap() { return *value_ptr_; }
+  const T& Peek() const { return *value_ptr_; }
+
+ private:
+  T* value_ptr_;
+};
+
+// C++ treats the void type specially.  For example, you cannot define
+// a void-typed variable or pass a void value to a function.
+// ActionResultHolder<T> holds a value of type T, where T must be a
+// copyable type or void (T doesn't need to be default-constructable).
+// It hides the syntactic difference between void and other types, and
+// is used to unify the code for invoking both void-returning and
+// non-void-returning mock functions.
+
+// Untyped base class for ActionResultHolder<T>.
+class UntypedActionResultHolderBase {
+ public:
+  virtual ~UntypedActionResultHolderBase() {}
+
+  // Prints the held value as an action's result to os.
+  virtual void PrintAsActionResult(::std::ostream* os) const = 0;
+};
+
+// This generic definition is used when T is not void.
+template <typename T>
+class ActionResultHolder : public UntypedActionResultHolderBase {
+ public:
+  // Returns the held value. Must not be called more than once.
+  T Unwrap() {
+    return result_.Unwrap();
+  }
+
+  // Prints the held value as an action's result to os.
+  void PrintAsActionResult(::std::ostream* os) const override {
+    *os << "\n          Returns: ";
+    // T may be a reference type, so we don't use UniversalPrint().
+    UniversalPrinter<T>::Print(result_.Peek(), os);
+  }
+
+  // Performs the given mock function's default action and returns the
+  // result in a new-ed ActionResultHolder.
+  template <typename F>
+  static ActionResultHolder* PerformDefaultAction(
+      const FunctionMocker<F>* func_mocker,
+      typename Function<F>::ArgumentTuple&& args,
+      const std::string& call_description) {
+    return new ActionResultHolder(Wrapper(func_mocker->PerformDefaultAction(
+        std::move(args), call_description)));
+  }
+
+  // Performs the given action and returns the result in a new-ed
+  // ActionResultHolder.
+  template <typename F>
+  static ActionResultHolder* PerformAction(
+      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
+    return new ActionResultHolder(
+        Wrapper(action.Perform(std::move(args))));
+  }
+
+ private:
+  typedef ReferenceOrValueWrapper<T> Wrapper;
+
+  explicit ActionResultHolder(Wrapper result)
+      : result_(std::move(result)) {
+  }
+
+  Wrapper result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
+};
+
+// Specialization for T = void.
+template <>
+class ActionResultHolder<void> : public UntypedActionResultHolderBase {
+ public:
+  void Unwrap() { }
+
+  void PrintAsActionResult(::std::ostream* /* os */) const override {}
+
+  // Performs the given mock function's default action and returns ownership
+  // of an empty ActionResultHolder*.
+  template <typename F>
+  static ActionResultHolder* PerformDefaultAction(
+      const FunctionMocker<F>* func_mocker,
+      typename Function<F>::ArgumentTuple&& args,
+      const std::string& call_description) {
+    func_mocker->PerformDefaultAction(std::move(args), call_description);
+    return new ActionResultHolder;
+  }
+
+  // Performs the given action and returns ownership of an empty
+  // ActionResultHolder*.
+  template <typename F>
+  static ActionResultHolder* PerformAction(
+      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
+    action.Perform(std::move(args));
+    return new ActionResultHolder;
+  }
+
+ private:
+  ActionResultHolder() {}
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
+};
+
+template <typename F>
+class FunctionMocker;
+
+template <typename R, typename... Args>
+class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
+  using F = R(Args...);
+
+ public:
+  using Result = R;
+  using ArgumentTuple = std::tuple<Args...>;
+  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
+
+  FunctionMocker() {}
+
+  // There is no generally useful and implementable semantics of
+  // copying a mock object, so copying a mock is usually a user error.
+  // Thus we disallow copying function mockers.  If the user really
+  // wants to copy a mock object, they should implement their own copy
+  // operation, for example:
+  //
+  //   class MockFoo : public Foo {
+  //    public:
+  //     // Defines a copy constructor explicitly.
+  //     MockFoo(const MockFoo& src) {}
+  //     ...
+  //   };
+  FunctionMocker(const FunctionMocker&) = delete;
+  FunctionMocker& operator=(const FunctionMocker&) = delete;
+
+  // The destructor verifies that all expectations on this mock
+  // function have been satisfied.  If not, it will report Google Test
+  // non-fatal failures for the violations.
+  ~FunctionMocker() override GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    MutexLock l(&g_gmock_mutex);
+    VerifyAndClearExpectationsLocked();
+    Mock::UnregisterLocked(this);
+    ClearDefaultActionsLocked();
+  }
+
+  // Returns the ON_CALL spec that matches this mock function with the
+  // given arguments; returns NULL if no matching ON_CALL is found.
+  // L = *
+  const OnCallSpec<F>* FindOnCallSpec(
+      const ArgumentTuple& args) const {
+    for (UntypedOnCallSpecs::const_reverse_iterator it
+             = untyped_on_call_specs_.rbegin();
+         it != untyped_on_call_specs_.rend(); ++it) {
+      const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it);
+      if (spec->Matches(args))
+        return spec;
+    }
+
+    return nullptr;
+  }
+
+  // Performs the default action of this mock function on the given
+  // arguments and returns the result. Asserts (or throws if
+  // exceptions are enabled) with a helpful call descrption if there
+  // is no valid return value. This method doesn't depend on the
+  // mutable state of this object, and thus can be called concurrently
+  // without locking.
+  // L = *
+  Result PerformDefaultAction(ArgumentTuple&& args,
+                              const std::string& call_description) const {
+    const OnCallSpec<F>* const spec =
+        this->FindOnCallSpec(args);
+    if (spec != nullptr) {
+      return spec->GetAction().Perform(std::move(args));
+    }
+    const std::string message =
+        call_description +
+        "\n    The mock function has no default action "
+        "set, and its return type has no default value set.";
+#if GTEST_HAS_EXCEPTIONS
+    if (!DefaultValue<Result>::Exists()) {
+      throw std::runtime_error(message);
+    }
+#else
+    Assert(DefaultValue<Result>::Exists(), "", -1, message);
+#endif
+    return DefaultValue<Result>::Get();
+  }
+
+  // Performs the default action with the given arguments and returns
+  // the action's result.  The call description string will be used in
+  // the error message to describe the call in the case the default
+  // action fails.  The caller is responsible for deleting the result.
+  // L = *
+  UntypedActionResultHolderBase* UntypedPerformDefaultAction(
+      void* untyped_args,  // must point to an ArgumentTuple
+      const std::string& call_description) const override {
+    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
+    return ResultHolder::PerformDefaultAction(this, std::move(*args),
+                                              call_description);
+  }
+
+  // Performs the given action with the given arguments and returns
+  // the action's result.  The caller is responsible for deleting the
+  // result.
+  // L = *
+  UntypedActionResultHolderBase* UntypedPerformAction(
+      const void* untyped_action, void* untyped_args) const override {
+    // Make a copy of the action before performing it, in case the
+    // action deletes the mock object (and thus deletes itself).
+    const Action<F> action = *static_cast<const Action<F>*>(untyped_action);
+    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
+    return ResultHolder::PerformAction(action, std::move(*args));
+  }
+
+  // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
+  // clears the ON_CALL()s set on this mock function.
+  void ClearDefaultActionsLocked() override
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    // Deleting our default actions may trigger other mock objects to be
+    // deleted, for example if an action contains a reference counted smart
+    // pointer to that mock object, and that is the last reference. So if we
+    // delete our actions within the context of the global mutex we may deadlock
+    // when this method is called again. Instead, make a copy of the set of
+    // actions to delete, clear our set within the mutex, and then delete the
+    // actions outside of the mutex.
+    UntypedOnCallSpecs specs_to_delete;
+    untyped_on_call_specs_.swap(specs_to_delete);
+
+    g_gmock_mutex.Unlock();
+    for (UntypedOnCallSpecs::const_iterator it =
+             specs_to_delete.begin();
+         it != specs_to_delete.end(); ++it) {
+      delete static_cast<const OnCallSpec<F>*>(*it);
+    }
+
+    // Lock the mutex again, since the caller expects it to be locked when we
+    // return.
+    g_gmock_mutex.Lock();
+  }
+
+  // Returns the result of invoking this mock function with the given
+  // arguments.  This function can be safely called from multiple
+  // threads concurrently.
+  Result Invoke(Args... args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    ArgumentTuple tuple(std::forward<Args>(args)...);
+    std::unique_ptr<ResultHolder> holder(DownCast_<ResultHolder*>(
+        this->UntypedInvokeWith(static_cast<void*>(&tuple))));
+    return holder->Unwrap();
+  }
+
+  MockSpec<F> With(Matcher<Args>... m) {
+    return MockSpec<F>(this, ::std::make_tuple(std::move(m)...));
+  }
+
+ protected:
+  template <typename Function>
+  friend class MockSpec;
+
+  typedef ActionResultHolder<Result> ResultHolder;
+
+  // Adds and returns a default action spec for this mock function.
+  OnCallSpec<F>& AddNewOnCallSpec(
+      const char* file, int line,
+      const ArgumentMatcherTuple& m)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
+    OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m);
+    untyped_on_call_specs_.push_back(on_call_spec);
+    return *on_call_spec;
+  }
+
+  // Adds and returns an expectation spec for this mock function.
+  TypedExpectation<F>& AddNewExpectation(const char* file, int line,
+                                         const std::string& source_text,
+                                         const ArgumentMatcherTuple& m)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
+    TypedExpectation<F>* const expectation =
+        new TypedExpectation<F>(this, file, line, source_text, m);
+    const std::shared_ptr<ExpectationBase> untyped_expectation(expectation);
+    // See the definition of untyped_expectations_ for why access to
+    // it is unprotected here.
+    untyped_expectations_.push_back(untyped_expectation);
+
+    // Adds this expectation into the implicit sequence if there is one.
+    Sequence* const implicit_sequence = g_gmock_implicit_sequence.get();
+    if (implicit_sequence != nullptr) {
+      implicit_sequence->AddExpectation(Expectation(untyped_expectation));
+    }
+
+    return *expectation;
+  }
+
+ private:
+  template <typename Func> friend class TypedExpectation;
+
+  // Some utilities needed for implementing UntypedInvokeWith().
+
+  // Describes what default action will be performed for the given
+  // arguments.
+  // L = *
+  void DescribeDefaultActionTo(const ArgumentTuple& args,
+                               ::std::ostream* os) const {
+    const OnCallSpec<F>* const spec = FindOnCallSpec(args);
+
+    if (spec == nullptr) {
+      *os << (std::is_void<Result>::value ? "returning directly.\n"
+                                          : "returning default value.\n");
+    } else {
+      *os << "taking default action specified at:\n"
+          << FormatFileLocation(spec->file(), spec->line()) << "\n";
+    }
+  }
+
+  // Writes a message that the call is uninteresting (i.e. neither
+  // explicitly expected nor explicitly unexpected) to the given
+  // ostream.
+  void UntypedDescribeUninterestingCall(const void* untyped_args,
+                                        ::std::ostream* os) const override
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    *os << "Uninteresting mock function call - ";
+    DescribeDefaultActionTo(args, os);
+    *os << "    Function call: " << Name();
+    UniversalPrint(args, os);
+  }
+
+  // Returns the expectation that matches the given function arguments
+  // (or NULL is there's no match); when a match is found,
+  // untyped_action is set to point to the action that should be
+  // performed (or NULL if the action is "do default"), and
+  // is_excessive is modified to indicate whether the call exceeds the
+  // expected number.
+  //
+  // Critical section: We must find the matching expectation and the
+  // corresponding action that needs to be taken in an ATOMIC
+  // transaction.  Otherwise another thread may call this mock
+  // method in the middle and mess up the state.
+  //
+  // However, performing the action has to be left out of the critical
+  // section.  The reason is that we have no control on what the
+  // action does (it can invoke an arbitrary user function or even a
+  // mock function) and excessive locking could cause a dead lock.
+  const ExpectationBase* UntypedFindMatchingExpectation(
+      const void* untyped_args, const void** untyped_action, bool* is_excessive,
+      ::std::ostream* what, ::std::ostream* why) override
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    MutexLock l(&g_gmock_mutex);
+    TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args);
+    if (exp == nullptr) {  // A match wasn't found.
+      this->FormatUnexpectedCallMessageLocked(args, what, why);
+      return nullptr;
+    }
+
+    // This line must be done before calling GetActionForArguments(),
+    // which will increment the call count for *exp and thus affect
+    // its saturation status.
+    *is_excessive = exp->IsSaturated();
+    const Action<F>* action = exp->GetActionForArguments(this, args, what, why);
+    if (action != nullptr && action->IsDoDefault())
+      action = nullptr;  // Normalize "do default" to NULL.
+    *untyped_action = action;
+    return exp;
+  }
+
+  // Prints the given function arguments to the ostream.
+  void UntypedPrintArgs(const void* untyped_args,
+                        ::std::ostream* os) const override {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    UniversalPrint(args, os);
+  }
+
+  // Returns the expectation that matches the arguments, or NULL if no
+  // expectation matches them.
+  TypedExpectation<F>* FindMatchingExpectationLocked(
+      const ArgumentTuple& args) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    // See the definition of untyped_expectations_ for why access to
+    // it is unprotected here.
+    for (typename UntypedExpectations::const_reverse_iterator it =
+             untyped_expectations_.rbegin();
+         it != untyped_expectations_.rend(); ++it) {
+      TypedExpectation<F>* const exp =
+          static_cast<TypedExpectation<F>*>(it->get());
+      if (exp->ShouldHandleArguments(args)) {
+        return exp;
+      }
+    }
+    return nullptr;
+  }
+
+  // Returns a message that the arguments don't match any expectation.
+  void FormatUnexpectedCallMessageLocked(
+      const ArgumentTuple& args,
+      ::std::ostream* os,
+      ::std::ostream* why) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    *os << "\nUnexpected mock function call - ";
+    DescribeDefaultActionTo(args, os);
+    PrintTriedExpectationsLocked(args, why);
+  }
+
+  // Prints a list of expectations that have been tried against the
+  // current mock function call.
+  void PrintTriedExpectationsLocked(
+      const ArgumentTuple& args,
+      ::std::ostream* why) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    const size_t count = untyped_expectations_.size();
+    *why << "Google Mock tried the following " << count << " "
+         << (count == 1 ? "expectation, but it didn't match" :
+             "expectations, but none matched")
+         << ":\n";
+    for (size_t i = 0; i < count; i++) {
+      TypedExpectation<F>* const expectation =
+          static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get());
+      *why << "\n";
+      expectation->DescribeLocationTo(why);
+      if (count > 1) {
+        *why << "tried expectation #" << i << ": ";
+      }
+      *why << expectation->source_text() << "...\n";
+      expectation->ExplainMatchResultTo(args, why);
+      expectation->DescribeCallCountTo(why);
+    }
+  }
+};  // class FunctionMocker
+
+// Reports an uninteresting call (whose description is in msg) in the
+// manner specified by 'reaction'.
+void ReportUninterestingCall(CallReaction reaction, const std::string& msg);
+
+}  // namespace internal
+
+namespace internal {
+
+template <typename F>
+class MockFunction;
+
+template <typename R, typename... Args>
+class MockFunction<R(Args...)> {
+ public:
+  MockFunction(const MockFunction&) = delete;
+  MockFunction& operator=(const MockFunction&) = delete;
+
+  std::function<R(Args...)> AsStdFunction() {
+    return [this](Args... args) -> R {
+      return this->Call(std::forward<Args>(args)...);
+    };
+  }
+
+  // Implementation detail: the expansion of the MOCK_METHOD macro.
+  R Call(Args... args) {
+    mock_.SetOwnerAndName(this, "Call");
+    return mock_.Invoke(std::forward<Args>(args)...);
+  }
+
+  MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) {
+    mock_.RegisterOwner(this);
+    return mock_.With(std::move(m)...);
+  }
+
+  MockSpec<R(Args...)> gmock_Call(const WithoutMatchers&, R (*)(Args...)) {
+    return this->gmock_Call(::testing::A<Args>()...);
+  }
+
+ protected:
+  MockFunction() = default;
+  ~MockFunction() = default;
+
+ private:
+  FunctionMocker<R(Args...)> mock_;
+};
+
+/*
+The SignatureOf<F> struct is a meta-function returning function signature
+corresponding to the provided F argument.
+
+It makes use of MockFunction easier by allowing it to accept more F arguments
+than just function signatures.
+
+Specializations provided here cover only a signature type itself and
+std::function. However, if need be it can be easily extended to cover also other
+types (like for example boost::function).
+*/
+
+template <typename F>
+struct SignatureOf;
+
+template <typename R, typename... Args>
+struct SignatureOf<R(Args...)> {
+  using type = R(Args...);
+};
+
+template <typename F>
+struct SignatureOf<std::function<F>> : SignatureOf<F> {};
+
+template <typename F>
+using SignatureOfT = typename SignatureOf<F>::type;
+
+}  // namespace internal
+
+// A MockFunction<F> type has one mock method whose type is
+// internal::SignatureOfT<F>.  It is useful when you just want your
+// test code to emit some messages and have Google Mock verify the
+// right messages are sent (and perhaps at the right times).  For
+// example, if you are exercising code:
+//
+//   Foo(1);
+//   Foo(2);
+//   Foo(3);
+//
+// and want to verify that Foo(1) and Foo(3) both invoke
+// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
+//
+// TEST(FooTest, InvokesBarCorrectly) {
+//   MyMock mock;
+//   MockFunction<void(string check_point_name)> check;
+//   {
+//     InSequence s;
+//
+//     EXPECT_CALL(mock, Bar("a"));
+//     EXPECT_CALL(check, Call("1"));
+//     EXPECT_CALL(check, Call("2"));
+//     EXPECT_CALL(mock, Bar("a"));
+//   }
+//   Foo(1);
+//   check.Call("1");
+//   Foo(2);
+//   check.Call("2");
+//   Foo(3);
+// }
+//
+// The expectation spec says that the first Bar("a") must happen
+// before check point "1", the second Bar("a") must happen after check
+// point "2", and nothing should happen between the two check
+// points. The explicit check points make it easy to tell which
+// Bar("a") is called by which call to Foo().
+//
+// MockFunction<F> can also be used to exercise code that accepts
+// std::function<internal::SignatureOfT<F>> callbacks. To do so, use
+// AsStdFunction() method to create std::function proxy forwarding to
+// original object's Call. Example:
+//
+// TEST(FooTest, RunsCallbackWithBarArgument) {
+//   MockFunction<int(string)> callback;
+//   EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
+//   Foo(callback.AsStdFunction());
+// }
+//
+// The internal::SignatureOfT<F> indirection allows to use other types
+// than just function signature type. This is typically useful when
+// providing a mock for a predefined std::function type. Example:
+//
+// using FilterPredicate = std::function<bool(string)>;
+// void MyFilterAlgorithm(FilterPredicate predicate);
+//
+// TEST(FooTest, FilterPredicateAlwaysAccepts) {
+//   MockFunction<FilterPredicate> predicateMock;
+//   EXPECT_CALL(predicateMock, Call(_)).WillRepeatedly(Return(true));
+//   MyFilterAlgorithm(predicateMock.AsStdFunction());
+// }
+template <typename F>
+class MockFunction : public internal::MockFunction<internal::SignatureOfT<F>> {
+  using Base = internal::MockFunction<internal::SignatureOfT<F>>;
+
+ public:
+  using Base::Base;
+};
+
+// The style guide prohibits "using" statements in a namespace scope
+// inside a header file.  However, the MockSpec class template is
+// meant to be defined in the ::testing namespace.  The following line
+// is just a trick for working around a bug in MSVC 8.0, which cannot
+// handle it if we define MockSpec in ::testing.
+using internal::MockSpec;
+
+// Const(x) is a convenient function for obtaining a const reference
+// to x.  This is useful for setting expectations on an overloaded
+// const mock method, e.g.
+//
+//   class MockFoo : public FooInterface {
+//    public:
+//     MOCK_METHOD0(Bar, int());
+//     MOCK_CONST_METHOD0(Bar, int&());
+//   };
+//
+//   MockFoo foo;
+//   // Expects a call to non-const MockFoo::Bar().
+//   EXPECT_CALL(foo, Bar());
+//   // Expects a call to const MockFoo::Bar().
+//   EXPECT_CALL(Const(foo), Bar());
+template <typename T>
+inline const T& Const(const T& x) { return x; }
+
+// Constructs an Expectation object that references and co-owns exp.
+inline Expectation::Expectation(internal::ExpectationBase& exp)  // NOLINT
+    : expectation_base_(exp.GetHandle().expectation_base()) {}
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// Implementation for ON_CALL and EXPECT_CALL macros. A separate macro is
+// required to avoid compile errors when the name of the method used in call is
+// a result of macro expansion. See CompilesWithMethodNameExpandedFromMacro
+// tests in internal/gmock-spec-builders_test.cc for more details.
+//
+// This macro supports statements both with and without parameter matchers. If
+// the parameter list is omitted, gMock will accept any parameters, which allows
+// tests to be written that don't need to encode the number of method
+// parameter. This technique may only be used for non-overloaded methods.
+//
+//   // These are the same:
+//   ON_CALL(mock, NoArgsMethod()).WillByDefault(...);
+//   ON_CALL(mock, NoArgsMethod).WillByDefault(...);
+//
+//   // As are these:
+//   ON_CALL(mock, TwoArgsMethod(_, _)).WillByDefault(...);
+//   ON_CALL(mock, TwoArgsMethod).WillByDefault(...);
+//
+//   // Can also specify args if you want, of course:
+//   ON_CALL(mock, TwoArgsMethod(_, 45)).WillByDefault(...);
+//
+//   // Overloads work as long as you specify parameters:
+//   ON_CALL(mock, OverloadedMethod(_)).WillByDefault(...);
+//   ON_CALL(mock, OverloadedMethod(_, _)).WillByDefault(...);
+//
+//   // Oops! Which overload did you want?
+//   ON_CALL(mock, OverloadedMethod).WillByDefault(...);
+//     => ERROR: call to member function 'gmock_OverloadedMethod' is ambiguous
+//
+// How this works: The mock class uses two overloads of the gmock_Method
+// expectation setter method plus an operator() overload on the MockSpec object.
+// In the matcher list form, the macro expands to:
+//
+//   // This statement:
+//   ON_CALL(mock, TwoArgsMethod(_, 45))...
+//
+//   // ...expands to:
+//   mock.gmock_TwoArgsMethod(_, 45)(WithoutMatchers(), nullptr)...
+//   |-------------v---------------||------------v-------------|
+//       invokes first overload        swallowed by operator()
+//
+//   // ...which is essentially:
+//   mock.gmock_TwoArgsMethod(_, 45)...
+//
+// Whereas the form without a matcher list:
+//
+//   // This statement:
+//   ON_CALL(mock, TwoArgsMethod)...
+//
+//   // ...expands to:
+//   mock.gmock_TwoArgsMethod(WithoutMatchers(), nullptr)...
+//   |-----------------------v--------------------------|
+//                 invokes second overload
+//
+//   // ...which is essentially:
+//   mock.gmock_TwoArgsMethod(_, _)...
+//
+// The WithoutMatchers() argument is used to disambiguate overloads and to
+// block the caller from accidentally invoking the second overload directly. The
+// second argument is an internal type derived from the method signature. The
+// failure to disambiguate two overloads of this method in the ON_CALL statement
+// is how we block callers from setting expectations on overloaded methods.
+#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call)                    \
+  ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \
+                             nullptr)                                   \
+      .Setter(__FILE__, __LINE__, #mock_expr, #call)
+
+#define ON_CALL(obj, call) \
+  GMOCK_ON_CALL_IMPL_(obj, InternalDefaultActionSetAt, call)
+
+#define EXPECT_CALL(obj, call) \
+  GMOCK_ON_CALL_IMPL_(obj, InternalExpectedAt, call)
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+
+namespace testing {
+namespace internal {
+template <typename T>
+using identity_t = T;
+
+template <typename Pattern>
+struct ThisRefAdjuster {
+  template <typename T>
+  using AdjustT = typename std::conditional<
+      std::is_const<typename std::remove_reference<Pattern>::type>::value,
+      typename std::conditional<std::is_lvalue_reference<Pattern>::value,
+                                const T&, const T&&>::type,
+      typename std::conditional<std::is_lvalue_reference<Pattern>::value, T&,
+                                T&&>::type>::type;
+
+  template <typename MockType>
+  static AdjustT<MockType> Adjust(const MockType& mock) {
+    return static_cast<AdjustT<MockType>>(const_cast<MockType&>(mock));
+  }
+};
+
+}  // namespace internal
+
+// The style guide prohibits "using" statements in a namespace scope
+// inside a header file.  However, the FunctionMocker class template
+// is meant to be defined in the ::testing namespace.  The following
+// line is just a trick for working around a bug in MSVC 8.0, which
+// cannot handle it if we define FunctionMocker in ::testing.
+using internal::FunctionMocker;
+}  // namespace testing
+
+#define MOCK_METHOD(...) \
+  GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \
+  GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ())
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec)     \
+  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args);                                   \
+  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec);                                   \
+  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                      \
+      GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args));           \
+  GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec)                                     \
+  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                            \
+      GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec),     \
+      GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec),    \
+      GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec),                                \
+      GMOCK_INTERNAL_GET_CALLTYPE(_Spec), GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \
+      (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)))
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_WRONG_ARITY(...)                                      \
+  static_assert(                                                             \
+      false,                                                                 \
+      "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, "             \
+      "_MethodName, _Args and optionally _Spec. _Args and _Spec must be "    \
+      "enclosed in parentheses. If _Ret is a type with unprotected commas, " \
+      "it must also be enclosed in parentheses.")
+
+#define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \
+  static_assert(                                  \
+      GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple),        \
+      GMOCK_PP_STRINGIZE(_Tuple) " should be enclosed in parentheses.")
+
+#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...)                 \
+  static_assert(                                                       \
+      std::is_function<__VA_ARGS__>::value,                            \
+      "Signature must be a function type, maybe return type contains " \
+      "unprotected comma.");                                           \
+  static_assert(                                                       \
+      ::testing::tuple_size<typename ::testing::internal::Function<    \
+              __VA_ARGS__>::ArgumentTuple>::value == _N,               \
+      "This method does not take " GMOCK_PP_STRINGIZE(                 \
+          _N) " arguments. Parenthesize all types with unprotected commas.")
+
+#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness,           \
+                                        _Override, _Final, _NoexceptSpec,      \
+                                        _CallType, _RefSpec, _Signature)       \
+  typename ::testing::internal::Function<GMOCK_PP_REMOVE_PARENS(               \
+      _Signature)>::Result                                                     \
+  GMOCK_INTERNAL_EXPAND(_CallType)                                             \
+      _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N))   \
+          GMOCK_PP_IF(_Constness, const, ) _RefSpec _NoexceptSpec              \
+          GMOCK_PP_IF(_Override, override, ) GMOCK_PP_IF(_Final, final, ) {    \
+    GMOCK_MOCKER_(_N, _Constness, _MethodName)                                 \
+        .SetOwnerAndName(this, #_MethodName);                                  \
+    return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \
+        .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N));  \
+  }                                                                            \
+  ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \
+      GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N))       \
+      GMOCK_PP_IF(_Constness, const, ) _RefSpec {                              \
+    GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this);            \
+    return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \
+        .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N));         \
+  }                                                                            \
+  ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \
+      const ::testing::internal::WithoutMatchers&,                             \
+      GMOCK_PP_IF(_Constness, const, )::testing::internal::Function<           \
+          GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec { \
+    return ::testing::internal::ThisRefAdjuster<GMOCK_PP_IF(                   \
+        _Constness, const, ) int _RefSpec>::Adjust(*this)                      \
+        .gmock_##_MethodName(GMOCK_PP_REPEAT(                                  \
+            GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N));               \
+  }                                                                            \
+  mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)>        \
+      GMOCK_MOCKER_(_N, _Constness, _MethodName)
+
+#define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__
+
+// Five Valid modifiers.
+#define GMOCK_INTERNAL_HAS_CONST(_Tuple) \
+  GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple))
+
+#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \
+  GMOCK_PP_HAS_COMMA(                       \
+      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple))
+
+#define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \
+  GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple))
+
+#define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT, ~, _Tuple)
+
+#define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem)          \
+  GMOCK_PP_IF(                                                          \
+      GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \
+      _elem, )
+
+#define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple)
+
+#define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem)                       \
+  GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \
+              GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), )
+
+#define GMOCK_INTERNAL_GET_CALLTYPE(_Tuple) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_CALLTYPE_IMPL, ~, _Tuple)
+
+#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem)            \
+  static_assert(                                                          \
+      (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) +    \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) + \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) +    \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) + \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) +      \
+       GMOCK_INTERNAL_IS_CALLTYPE(_elem)) == 1,                           \
+      GMOCK_PP_STRINGIZE(                                                 \
+          _elem) " cannot be recognized as a valid specification modifier.");
+
+// Modifiers implementation.
+#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_CONST_I_const ,
+
+#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override ,
+
+#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_FINAL_I_final ,
+
+#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept ,
+
+#define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_REF_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_REF_I_ref ,
+
+#define GMOCK_INTERNAL_UNPACK_ref(x) x
+
+#define GMOCK_INTERNAL_GET_CALLTYPE_IMPL(_i, _, _elem)           \
+  GMOCK_PP_IF(GMOCK_INTERNAL_IS_CALLTYPE(_elem),                 \
+              GMOCK_INTERNAL_GET_VALUE_CALLTYPE, GMOCK_PP_EMPTY) \
+  (_elem)
+
+// TODO(iserna): GMOCK_INTERNAL_IS_CALLTYPE and
+// GMOCK_INTERNAL_GET_VALUE_CALLTYPE needed more expansions to work on windows
+// maybe they can be simplified somehow.
+#define GMOCK_INTERNAL_IS_CALLTYPE(_arg) \
+  GMOCK_INTERNAL_IS_CALLTYPE_I(          \
+      GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg))
+#define GMOCK_INTERNAL_IS_CALLTYPE_I(_arg) GMOCK_PP_IS_ENCLOSED_PARENS(_arg)
+
+#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE(_arg) \
+  GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(          \
+      GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg))
+#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(_arg) \
+  GMOCK_PP_IDENTITY _arg
+
+#define GMOCK_INTERNAL_IS_CALLTYPE_HELPER_Calltype
+
+// Note: The use of `identity_t` here allows _Ret to represent return types that
+// would normally need to be specified in a different way. For example, a method
+// returning a function pointer must be written as
+//
+// fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...)
+//
+// But we only support placing the return type at the beginning. To handle this,
+// we wrap all calls in identity_t, so that a declaration will be expanded to
+//
+// identity_t<fn_ptr_return_t (*)(fn_ptr_args_t...)> method(method_args_t...)
+//
+// This allows us to work around the syntactic oddities of function/method
+// types.
+#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)                                 \
+  ::testing::internal::identity_t<GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_Ret), \
+                                              GMOCK_PP_REMOVE_PARENS,         \
+                                              GMOCK_PP_IDENTITY)(_Ret)>(      \
+      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args))
+
+#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem)                          \
+  GMOCK_PP_COMMA_IF(_i)                                                \
+  GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \
+              GMOCK_PP_IDENTITY)                                       \
+  (_elem)
+
+#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _)            \
+  GMOCK_PP_COMMA_IF(_i)                                        \
+  GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \
+  gmock_a##_i
+
+#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \
+  GMOCK_PP_COMMA_IF(_i)                               \
+  ::std::forward<GMOCK_INTERNAL_ARG_O(                \
+      _i, GMOCK_PP_REMOVE_PARENS(_Signature))>(gmock_a##_i)
+
+#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _)        \
+  GMOCK_PP_COMMA_IF(_i)                                            \
+  GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \
+  gmock_a##_i
+
+#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \
+  GMOCK_PP_COMMA_IF(_i)                             \
+  gmock_a##_i
+
+#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \
+  GMOCK_PP_COMMA_IF(_i)                                      \
+  ::testing::A<GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature))>()
+
+#define GMOCK_INTERNAL_ARG_O(_i, ...) \
+  typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type
+
+#define GMOCK_INTERNAL_MATCHER_O(_i, ...)                          \
+  const ::testing::Matcher<typename ::testing::internal::Function< \
+      __VA_ARGS__>::template Arg<_i>::type>&
+
+#define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__)
+#define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__)
+#define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__)
+#define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_ARGS__)
+#define MOCK_METHOD4(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 4, __VA_ARGS__)
+#define MOCK_METHOD5(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 5, __VA_ARGS__)
+#define MOCK_METHOD6(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 6, __VA_ARGS__)
+#define MOCK_METHOD7(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 7, __VA_ARGS__)
+#define MOCK_METHOD8(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 8, __VA_ARGS__)
+#define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__)
+#define MOCK_METHOD10(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__)
+#define MOCK_CONST_METHOD1(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 1, __VA_ARGS__)
+#define MOCK_CONST_METHOD2(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 2, __VA_ARGS__)
+#define MOCK_CONST_METHOD3(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 3, __VA_ARGS__)
+#define MOCK_CONST_METHOD4(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 4, __VA_ARGS__)
+#define MOCK_CONST_METHOD5(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 5, __VA_ARGS__)
+#define MOCK_CONST_METHOD6(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 6, __VA_ARGS__)
+#define MOCK_CONST_METHOD7(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 7, __VA_ARGS__)
+#define MOCK_CONST_METHOD8(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 8, __VA_ARGS__)
+#define MOCK_CONST_METHOD9(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 9, __VA_ARGS__)
+#define MOCK_CONST_METHOD10(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 10, __VA_ARGS__)
+
+#define MOCK_METHOD0_T(m, ...) MOCK_METHOD0(m, __VA_ARGS__)
+#define MOCK_METHOD1_T(m, ...) MOCK_METHOD1(m, __VA_ARGS__)
+#define MOCK_METHOD2_T(m, ...) MOCK_METHOD2(m, __VA_ARGS__)
+#define MOCK_METHOD3_T(m, ...) MOCK_METHOD3(m, __VA_ARGS__)
+#define MOCK_METHOD4_T(m, ...) MOCK_METHOD4(m, __VA_ARGS__)
+#define MOCK_METHOD5_T(m, ...) MOCK_METHOD5(m, __VA_ARGS__)
+#define MOCK_METHOD6_T(m, ...) MOCK_METHOD6(m, __VA_ARGS__)
+#define MOCK_METHOD7_T(m, ...) MOCK_METHOD7(m, __VA_ARGS__)
+#define MOCK_METHOD8_T(m, ...) MOCK_METHOD8(m, __VA_ARGS__)
+#define MOCK_METHOD9_T(m, ...) MOCK_METHOD9(m, __VA_ARGS__)
+#define MOCK_METHOD10_T(m, ...) MOCK_METHOD10(m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_T(m, ...) MOCK_CONST_METHOD0(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_T(m, ...) MOCK_CONST_METHOD1(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_T(m, ...) MOCK_CONST_METHOD2(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_T(m, ...) MOCK_CONST_METHOD3(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_T(m, ...) MOCK_CONST_METHOD4(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_T(m, ...) MOCK_CONST_METHOD5(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_T(m, ...) MOCK_CONST_METHOD6(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_T(m, ...) MOCK_CONST_METHOD7(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_T(m, ...) MOCK_CONST_METHOD8(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_T(m, ...) MOCK_CONST_METHOD9(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_T(m, ...) MOCK_CONST_METHOD10(m, __VA_ARGS__)
+
+#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 0, __VA_ARGS__)
+#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 1, __VA_ARGS__)
+#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 2, __VA_ARGS__)
+#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 3, __VA_ARGS__)
+#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 4, __VA_ARGS__)
+#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 5, __VA_ARGS__)
+#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 6, __VA_ARGS__)
+#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 7, __VA_ARGS__)
+#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 8, __VA_ARGS__)
+#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 9, __VA_ARGS__)
+#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 10, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__)
+
+#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...) \
+  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                  \
+      args_num, ::testing::internal::identity_t<__VA_ARGS__>);            \
+  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                        \
+      args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, ,          \
+      (::testing::internal::identity_t<__VA_ARGS__>))
+
+#define GMOCK_MOCKER_(arity, constness, Method) \
+  GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used variadic actions.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+
+#include <memory>
+#include <utility>
+
+
+// Include any custom callback actions added by the local installation.
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+
+// Sometimes you want to give an action explicit template parameters
+// that cannot be inferred from its value parameters.  ACTION() and
+// ACTION_P*() don't support that.  ACTION_TEMPLATE() remedies that
+// and can be viewed as an extension to ACTION() and ACTION_P*().
+//
+// The syntax:
+//
+//   ACTION_TEMPLATE(ActionName,
+//                   HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m),
+//                   AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; }
+//
+// defines an action template that takes m explicit template
+// parameters and n value parameters.  name_i is the name of the i-th
+// template parameter, and kind_i specifies whether it's a typename,
+// an integral constant, or a template.  p_i is the name of the i-th
+// value parameter.
+//
+// Example:
+//
+//   // DuplicateArg<k, T>(output) converts the k-th argument of the mock
+//   // function to type T and copies it to *output.
+//   ACTION_TEMPLATE(DuplicateArg,
+//                   HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
+//                   AND_1_VALUE_PARAMS(output)) {
+//     *output = T(::std::get<k>(args));
+//   }
+//   ...
+//     int n;
+//     EXPECT_CALL(mock, Foo(_, _))
+//         .WillOnce(DuplicateArg<1, unsigned char>(&n));
+//
+// To create an instance of an action template, write:
+//
+//   ActionName<t1, ..., t_m>(v1, ..., v_n)
+//
+// where the ts are the template arguments and the vs are the value
+// arguments.  The value argument types are inferred by the compiler.
+// If you want to explicitly specify the value argument types, you can
+// provide additional template arguments:
+//
+//   ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n)
+//
+// where u_i is the desired type of v_i.
+//
+// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the
+// number of value parameters, but not on the number of template
+// parameters.  Without the restriction, the meaning of the following
+// is unclear:
+//
+//   OverloadedAction<int, bool>(x);
+//
+// Are we using a single-template-parameter action where 'bool' refers
+// to the type of x, or are we using a two-template-parameter action
+// where the compiler is asked to infer the type of x?
+//
+// Implementation notes:
+//
+// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and
+// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for
+// implementing ACTION_TEMPLATE.  The main trick we use is to create
+// new macro invocations when expanding a macro.  For example, we have
+//
+//   #define ACTION_TEMPLATE(name, template_params, value_params)
+//       ... GMOCK_INTERNAL_DECL_##template_params ...
+//
+// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...)
+// to expand to
+//
+//       ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ...
+//
+// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the
+// preprocessor will continue to expand it to
+//
+//       ... typename T ...
+//
+// This technique conforms to the C++ standard and is portable.  It
+// allows us to implement action templates using O(N) code, where N is
+// the maximum number of template/value parameters supported.  Without
+// using it, we'd have to devote O(N^2) amount of code to implement all
+// combinations of m and n.
+
+// Declares the template parameters.
+#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0
+#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1) kind0 name0, kind1 name1
+#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2) kind0 name0, kind1 name1, kind2 name2
+#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \
+    kind3 name3
+#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \
+    kind2 name2, kind3 name3, kind4 name4
+#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \
+    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5
+#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \
+    kind5 name5, kind6 name6
+#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \
+    kind4 name4, kind5 name5, kind6 name6, kind7 name7
+#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \
+    kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \
+    kind8 name8
+#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \
+    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \
+    kind6 name6, kind7 name7, kind8 name8, kind9 name9
+
+// Lists the template parameters.
+#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0
+#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1) name0, name1
+#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2) name0, name1, name2
+#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3) name0, name1, name2, name3
+#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \
+    name4
+#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \
+    name2, name3, name4, name5
+#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6) name0, name1, name2, name3, name4, name5, name6
+#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7
+#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \
+    name6, name7, name8
+#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \
+    name3, name4, name5, name6, name7, name8, name9
+
+// Declares the types of value parameters.
+#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \
+    typename p0##_type, typename p1##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \
+    typename p0##_type, typename p1##_type, typename p2##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
+    typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
+    typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
+    typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) , typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type, \
+    typename p6##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type, \
+    typename p6##_type, typename p7##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type, \
+    typename p6##_type, typename p7##_type, typename p8##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \
+    typename p2##_type, typename p3##_type, typename p4##_type, \
+    typename p5##_type, typename p6##_type, typename p7##_type, \
+    typename p8##_type, typename p9##_type
+
+// Initializes the value parameters.
+#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\
+    ()
+#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\
+    (p0##_type gmock_p0) : p0(::std::move(gmock_p0))
+#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
+    (p0##_type gmock_p0, p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1))
+#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2))
+#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3))
+#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4))
+#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5))
+#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6))
+#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6, p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
+        p7(::std::move(gmock_p7))
+#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6, p7##_type gmock_p7, \
+        p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
+        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8))
+#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
+        p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
+        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \
+        p9(::std::move(gmock_p9))
+
+// Defines the copy constructor
+#define GMOCK_INTERNAL_DEFN_COPY_AND_0_VALUE_PARAMS() \
+    {}  // Avoid https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82134
+#define GMOCK_INTERNAL_DEFN_COPY_AND_1_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_2_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_3_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_4_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_5_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_6_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_7_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_8_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_9_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_10_VALUE_PARAMS(...) = default;
+
+// Declares the fields for storing the value parameters.
+#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0;
+#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \
+    p1##_type p1;
+#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \
+    p1##_type p1; p2##_type p2;
+#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \
+    p1##_type p1; p2##_type p2; p3##_type p3;
+#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
+    p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4;
+#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
+    p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
+    p5##_type p5;
+#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
+    p5##_type p5; p6##_type p6;
+#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
+    p5##_type p5; p6##_type p6; p7##_type p7;
+#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
+    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8;
+#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
+    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \
+    p9##_type p9;
+
+// Lists the value parameters.
+#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0
+#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1
+#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2
+#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3
+#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \
+    p2, p3, p4
+#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \
+    p1, p2, p3, p4, p5
+#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) p0, p1, p2, p3, p4, p5, p6
+#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) p0, p1, p2, p3, p4, p5, p6, p7
+#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8
+#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9
+
+// Lists the value parameter types.
+#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \
+    p1##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \
+    p1##_type, p2##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
+    p0##_type, p1##_type, p2##_type, p3##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
+    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
+    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \
+    p6##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+    p5##_type, p6##_type, p7##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+    p5##_type, p6##_type, p7##_type, p8##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+    p5##_type, p6##_type, p7##_type, p8##_type, p9##_type
+
+// Declares the value parameters.
+#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0
+#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \
+    p1##_type p1
+#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \
+    p1##_type p1, p2##_type p2
+#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \
+    p1##_type p1, p2##_type p2, p3##_type p3
+#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
+    p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4
+#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
+    p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
+    p5##_type p5
+#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
+    p5##_type p5, p6##_type p6
+#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
+    p5##_type p5, p6##_type p6, p7##_type p7
+#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8
+#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
+    p9##_type p9
+
+// The suffix of the class template implementing the action template.
+#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P
+#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2
+#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3
+#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4
+#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5
+#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6
+#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7
+#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) P8
+#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) P9
+#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) P10
+
+// The name of the class template implementing the action template.
+#define GMOCK_ACTION_CLASS_(name, value_params)\
+    GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)
+
+#define ACTION_TEMPLATE(name, template_params, value_params)                   \
+  template <GMOCK_INTERNAL_DECL_##template_params                              \
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+  class GMOCK_ACTION_CLASS_(name, value_params) {                              \
+   public:                                                                     \
+    explicit GMOCK_ACTION_CLASS_(name, value_params)(                          \
+        GMOCK_INTERNAL_DECL_##value_params)                                    \
+        GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),    \
+                    = default; ,                                               \
+                    : impl_(std::make_shared<gmock_Impl>(                      \
+                                GMOCK_INTERNAL_LIST_##value_params)) { })      \
+    GMOCK_ACTION_CLASS_(name, value_params)(                                   \
+        const GMOCK_ACTION_CLASS_(name, value_params)&) noexcept               \
+        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \
+    GMOCK_ACTION_CLASS_(name, value_params)(                                   \
+        GMOCK_ACTION_CLASS_(name, value_params)&&) noexcept                    \
+        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \
+    template <typename F>                                                      \
+    operator ::testing::Action<F>() const {                                    \
+      return GMOCK_PP_IF(                                                      \
+          GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),              \
+                      (::testing::internal::MakeAction<F, gmock_Impl>()),      \
+                      (::testing::internal::MakeAction<F>(impl_)));            \
+    }                                                                          \
+   private:                                                                    \
+    class gmock_Impl {                                                         \
+     public:                                                                   \
+      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}                \
+      template <typename function_type, typename return_type,                  \
+                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>         \
+      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const;  \
+      GMOCK_INTERNAL_DEFN_##value_params                                       \
+    };                                                                         \
+    GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),        \
+                , std::shared_ptr<const gmock_Impl> impl_;)                    \
+  };                                                                           \
+  template <GMOCK_INTERNAL_DECL_##template_params                              \
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+  GMOCK_ACTION_CLASS_(name, value_params)<                                     \
+      GMOCK_INTERNAL_LIST_##template_params                                    \
+      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(                           \
+          GMOCK_INTERNAL_DECL_##value_params) GTEST_MUST_USE_RESULT_;          \
+  template <GMOCK_INTERNAL_DECL_##template_params                              \
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+  inline GMOCK_ACTION_CLASS_(name, value_params)<                              \
+      GMOCK_INTERNAL_LIST_##template_params                                    \
+      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(                           \
+          GMOCK_INTERNAL_DECL_##value_params) {                                \
+    return GMOCK_ACTION_CLASS_(name, value_params)<                            \
+        GMOCK_INTERNAL_LIST_##template_params                                  \
+        GMOCK_INTERNAL_LIST_TYPE_##value_params>(                              \
+            GMOCK_INTERNAL_LIST_##value_params);                               \
+  }                                                                            \
+  template <GMOCK_INTERNAL_DECL_##template_params                              \
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+  template <typename function_type, typename return_type, typename args_type,  \
+            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                 \
+  return_type GMOCK_ACTION_CLASS_(name, value_params)<                         \
+      GMOCK_INTERNAL_LIST_##template_params                                    \
+      GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl::gmock_PerformImpl( \
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+namespace testing {
+
+// The ACTION*() macros trigger warning C4100 (unreferenced formal
+// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
+// the macro definition, as the warnings are generated when the macro
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+namespace internal {
+
+// internal::InvokeArgument - a helper for InvokeArgument action.
+// The basic overloads are provided here for generic functors.
+// Overloads for other custom-callables are provided in the
+// internal/custom/gmock-generated-actions.h header.
+template <typename F, typename... Args>
+auto InvokeArgument(F f, Args... args) -> decltype(f(args...)) {
+  return f(args...);
+}
+
+template <std::size_t index, typename... Params>
+struct InvokeArgumentAction {
+  template <typename... Args>
+  auto operator()(Args&&... args) const -> decltype(internal::InvokeArgument(
+      std::get<index>(std::forward_as_tuple(std::forward<Args>(args)...)),
+      std::declval<const Params&>()...)) {
+    internal::FlatTuple<Args&&...> args_tuple(FlatTupleConstructTag{},
+                                              std::forward<Args>(args)...);
+    return params.Apply([&](const Params&... unpacked_params) {
+      auto&& callable = args_tuple.template Get<index>();
+      return internal::InvokeArgument(
+          std::forward<decltype(callable)>(callable), unpacked_params...);
+    });
+  }
+
+  internal::FlatTuple<Params...> params;
+};
+
+}  // namespace internal
+
+// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
+// (0-based) argument, which must be a k-ary callable, of the mock
+// function, with arguments a1, a2, ..., a_k.
+//
+// Notes:
+//
+//   1. The arguments are passed by value by default.  If you need to
+//   pass an argument by reference, wrap it inside std::ref().  For
+//   example,
+//
+//     InvokeArgument<1>(5, string("Hello"), std::ref(foo))
+//
+//   passes 5 and string("Hello") by value, and passes foo by
+//   reference.
+//
+//   2. If the callable takes an argument by reference but std::ref() is
+//   not used, it will receive the reference to a copy of the value,
+//   instead of the original value.  For example, when the 0-th
+//   argument of the mock function takes a const string&, the action
+//
+//     InvokeArgument<0>(string("Hello"))
+//
+//   makes a copy of the temporary string("Hello") object and passes a
+//   reference of the copy, instead of the original temporary object,
+//   to the callable.  This makes it easy for a user to define an
+//   InvokeArgument action from temporary values and have it performed
+//   later.
+template <std::size_t index, typename... Params>
+internal::InvokeArgumentAction<index, typename std::decay<Params>::type...>
+InvokeArgument(Params&&... params) {
+  return {internal::FlatTuple<typename std::decay<Params>::type...>(
+      internal::FlatTupleConstructTag{}, std::forward<Params>(params)...)};
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+// Copyright 2013, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some matchers that depend on gmock-matchers.h.
+//
+// Note that tests are implemented in gmock-matchers_test.cc rather than
+// gmock-more-matchers-test.cc.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
+
+
+namespace testing {
+
+// Silence C4100 (unreferenced formal
+// parameter) for MSVC
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#if (_MSC_VER == 1900)
+// and silence C4800 (C4800: 'int *const ': forcing value
+// to bool 'true' or 'false') for MSVC 14
+# pragma warning(disable:4800)
+  #endif
+#endif
+
+// Defines a matcher that matches an empty container. The container must
+// support both size() and empty(), which all STL-like containers provide.
+MATCHER(IsEmpty, negation ? "isn't empty" : "is empty") {
+  if (arg.empty()) {
+    return true;
+  }
+  *result_listener << "whose size is " << arg.size();
+  return false;
+}
+
+// Define a matcher that matches a value that evaluates in boolean
+// context to true.  Useful for types that define "explicit operator
+// bool" operators and so can't be compared for equality with true
+// and false.
+MATCHER(IsTrue, negation ? "is false" : "is true") {
+  return static_cast<bool>(arg);
+}
+
+// Define a matcher that matches a value that evaluates in boolean
+// context to false.  Useful for types that define "explicit operator
+// bool" operators and so can't be compared for equality with true
+// and false.
+MATCHER(IsFalse, negation ? "is true" : "is false") {
+  return !static_cast<bool>(arg);
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Implements class templates NiceMock, NaggyMock, and StrictMock.
+//
+// Given a mock class MockFoo that is created using Google Mock,
+// NiceMock<MockFoo> is a subclass of MockFoo that allows
+// uninteresting calls (i.e. calls to mock methods that have no
+// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
+// that prints a warning when an uninteresting call occurs, and
+// StrictMock<MockFoo> is a subclass of MockFoo that treats all
+// uninteresting calls as errors.
+//
+// Currently a mock is naggy by default, so MockFoo and
+// NaggyMock<MockFoo> behave like the same.  However, we will soon
+// switch the default behavior of mocks to be nice, as that in general
+// leads to more maintainable tests.  When that happens, MockFoo will
+// stop behaving like NaggyMock<MockFoo> and start behaving like
+// NiceMock<MockFoo>.
+//
+// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
+// their respective base class.  Therefore you can write
+// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo
+// has a constructor that accepts (int, const char*), for example.
+//
+// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
+// and StrictMock<MockFoo> only works for mock methods defined using
+// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
+// If a mock method is defined in a base class of MockFoo, the "nice"
+// or "strict" modifier may not affect it, depending on the compiler.
+// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
+// supported.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
+
+#include <type_traits>
+
+
+namespace testing {
+template <class MockClass>
+class NiceMock;
+template <class MockClass>
+class NaggyMock;
+template <class MockClass>
+class StrictMock;
+
+namespace internal {
+template <typename T>
+std::true_type StrictnessModifierProbe(const NiceMock<T>&);
+template <typename T>
+std::true_type StrictnessModifierProbe(const NaggyMock<T>&);
+template <typename T>
+std::true_type StrictnessModifierProbe(const StrictMock<T>&);
+std::false_type StrictnessModifierProbe(...);
+
+template <typename T>
+constexpr bool HasStrictnessModifier() {
+  return decltype(StrictnessModifierProbe(std::declval<const T&>()))::value;
+}
+
+// Base classes that register and deregister with testing::Mock to alter the
+// default behavior around uninteresting calls. Inheriting from one of these
+// classes first and then MockClass ensures the MockClass constructor is run
+// after registration, and that the MockClass destructor runs before
+// deregistration. This guarantees that MockClass's constructor and destructor
+// run with the same level of strictness as its instance methods.
+
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW && \
+    (defined(_MSC_VER) || defined(__clang__))
+// We need to mark these classes with this declspec to ensure that
+// the empty base class optimization is performed.
+#define GTEST_INTERNAL_EMPTY_BASE_CLASS __declspec(empty_bases)
+#else
+#define GTEST_INTERNAL_EMPTY_BASE_CLASS
+#endif
+
+template <typename Base>
+class NiceMockImpl {
+ public:
+  NiceMockImpl() { ::testing::Mock::AllowUninterestingCalls(this); }
+
+  ~NiceMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
+};
+
+template <typename Base>
+class NaggyMockImpl {
+ public:
+  NaggyMockImpl() { ::testing::Mock::WarnUninterestingCalls(this); }
+
+  ~NaggyMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
+};
+
+template <typename Base>
+class StrictMockImpl {
+ public:
+  StrictMockImpl() { ::testing::Mock::FailUninterestingCalls(this); }
+
+  ~StrictMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
+};
+
+}  // namespace internal
+
+template <class MockClass>
+class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock
+    : private internal::NiceMockImpl<MockClass>,
+      public MockClass {
+ public:
+  static_assert(!internal::HasStrictnessModifier<MockClass>(),
+                "Can't apply NiceMock to a class hierarchy that already has a "
+                "strictness modifier. See "
+                "https://google.github.io/googletest/"
+                "gmock_cook_book.html#NiceStrictNaggy");
+  NiceMock() : MockClass() {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  // Ideally, we would inherit base class's constructors through a using
+  // declaration, which would preserve their visibility. However, many existing
+  // tests rely on the fact that current implementation reexports protected
+  // constructors as public. These tests would need to be cleaned up first.
+
+  // Single argument constructor is special-cased so that it can be
+  // made explicit.
+  template <typename A>
+  explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  template <typename TArg1, typename TArg2, typename... An>
+  NiceMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
+      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
+                  std::forward<An>(args)...) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
+};
+
+template <class MockClass>
+class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
+    : private internal::NaggyMockImpl<MockClass>,
+      public MockClass {
+  static_assert(!internal::HasStrictnessModifier<MockClass>(),
+                "Can't apply NaggyMock to a class hierarchy that already has a "
+                "strictness modifier. See "
+                "https://google.github.io/googletest/"
+                "gmock_cook_book.html#NiceStrictNaggy");
+
+ public:
+  NaggyMock() : MockClass() {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  // Ideally, we would inherit base class's constructors through a using
+  // declaration, which would preserve their visibility. However, many existing
+  // tests rely on the fact that current implementation reexports protected
+  // constructors as public. These tests would need to be cleaned up first.
+
+  // Single argument constructor is special-cased so that it can be
+  // made explicit.
+  template <typename A>
+  explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  template <typename TArg1, typename TArg2, typename... An>
+  NaggyMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
+      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
+                  std::forward<An>(args)...) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
+};
+
+template <class MockClass>
+class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock
+    : private internal::StrictMockImpl<MockClass>,
+      public MockClass {
+ public:
+  static_assert(
+      !internal::HasStrictnessModifier<MockClass>(),
+      "Can't apply StrictMock to a class hierarchy that already has a "
+      "strictness modifier. See "
+      "https://google.github.io/googletest/"
+      "gmock_cook_book.html#NiceStrictNaggy");
+  StrictMock() : MockClass() {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  // Ideally, we would inherit base class's constructors through a using
+  // declaration, which would preserve their visibility. However, many existing
+  // tests rely on the fact that current implementation reexports protected
+  // constructors as public. These tests would need to be cleaned up first.
+
+  // Single argument constructor is special-cased so that it can be
+  // made explicit.
+  template <typename A>
+  explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  template <typename TArg1, typename TArg2, typename... An>
+  StrictMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
+      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
+                  std::forward<An>(args)...) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
+};
+
+#undef GTEST_INTERNAL_EMPTY_BASE_CLASS
+
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
+
+namespace testing {
+
+// Declares Google Mock flags that we want a user to use programmatically.
+GMOCK_DECLARE_bool_(catch_leaked_mocks);
+GMOCK_DECLARE_string_(verbose);
+GMOCK_DECLARE_int32_(default_mock_behavior);
+
+// Initializes Google Mock.  This must be called before running the
+// tests.  In particular, it parses the command line for the flags
+// that Google Mock recognizes.  Whenever a Google Mock flag is seen,
+// it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Mock flag variables are
+// updated.
+//
+// Since Google Test is needed for Google Mock to work, this function
+// also initializes Google Test and parses its flags, if that hasn't
+// been done.
+GTEST_API_ void InitGoogleMock(int* argc, char** argv);
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv);
+
+// This overloaded version can be used on Arduino/embedded platforms where
+// there is no argc/argv.
+GTEST_API_ void InitGoogleMock();
+
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/gtest/gtest-spi.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/gtest/gtest-spi.h
new file mode 100644
index 0000000000000000000000000000000000000000..eacef44669e8104a3d28daa054edadcdeb23c548
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/gtest/gtest-spi.h
@@ -0,0 +1,238 @@
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+//
+// Utilities for testing Google Test itself and code that uses Google Test
+// (e.g. frameworks built on top of Google Test).
+
+// GOOGLETEST_CM0004 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
+
+#include "gtest/gtest.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// This helper class can be used to mock out Google Test failure reporting
+// so that we can test Google Test or code that builds on Google Test.
+//
+// An object of this class appends a TestPartResult object to the
+// TestPartResultArray object given in the constructor whenever a Google Test
+// failure is reported. It can either intercept only failures that are
+// generated in the same thread that created this object or it can intercept
+// all generated failures. The scope of this mock object can be controlled with
+// the second argument to the two arguments constructor.
+class GTEST_API_ ScopedFakeTestPartResultReporter
+    : public TestPartResultReporterInterface {
+ public:
+  // The two possible mocking modes of this object.
+  enum InterceptMode {
+    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
+    INTERCEPT_ALL_THREADS           // Intercepts all failures.
+  };
+
+  // The c'tor sets this object as the test part result reporter used
+  // by Google Test.  The 'result' parameter specifies where to report the
+  // results. This reporter will only catch failures generated in the current
+  // thread. DEPRECATED
+  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
+
+  // Same as above, but you can choose the interception scope of this object.
+  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
+                                   TestPartResultArray* result);
+
+  // The d'tor restores the previous test part result reporter.
+  ~ScopedFakeTestPartResultReporter() override;
+
+  // Appends the TestPartResult object to the TestPartResultArray
+  // received in the constructor.
+  //
+  // This method is from the TestPartResultReporterInterface
+  // interface.
+  void ReportTestPartResult(const TestPartResult& result) override;
+
+ private:
+  void Init();
+
+  const InterceptMode intercept_mode_;
+  TestPartResultReporterInterface* old_reporter_;
+  TestPartResultArray* const result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
+};
+
+namespace internal {
+
+// A helper class for implementing EXPECT_FATAL_FAILURE() and
+// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
+// TestPartResultArray contains exactly one failure that has the given
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+class GTEST_API_ SingleFailureChecker {
+ public:
+  // The constructor remembers the arguments.
+  SingleFailureChecker(const TestPartResultArray* results,
+                       TestPartResult::Type type, const std::string& substr);
+  ~SingleFailureChecker();
+ private:
+  const TestPartResultArray* const results_;
+  const TestPartResult::Type type_;
+  const std::string substr_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// A set of macros for testing Google Test assertions or code that's expected
+// to generate Google Test fatal failures.  It verifies that the given
+// statement will cause exactly one fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - 'statement' cannot reference local non-static variables or
+//     non-static members of the current object.
+//   - 'statement' cannot return a value.
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
+// gtest_unittest.cc will fail to compile if we do that.
+#define EXPECT_FATAL_FAILURE(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ALL_THREADS, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+// A macro for testing Google Test assertions or code that's expected to
+// generate Google Test non-fatal failures.  It asserts that the given
+// statement will cause exactly one non-fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// 'statement' is allowed to reference local variables and members of
+// the current object.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  If we do that, the code won't compile when the user gives
+// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
+// expands to code containing an unprotected comma.  The
+// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
+// catches that.
+//
+// For the same reason, we have to write
+//   if (::testing::internal::AlwaysTrue()) { statement; }
+// instead of
+//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
+// to avoid an MSVC warning on unreachable code.
+#define EXPECT_NONFATAL_FAILURE(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
+          &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/gtest/gtest.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/gtest/gtest.h
new file mode 100644
index 0000000000000000000000000000000000000000..55a31d0a87dc788d2d10d7db17751632a5e4f4a6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/gtest/gtest/gtest.h
@@ -0,0 +1,12398 @@
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines the public API for Google Test.  It should be
+// included by any test program that uses Google Test.
+//
+// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
+// leave some internal implementation details in this header file.
+// They are clearly marked by comments like this:
+//
+//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+//
+// Such code is NOT meant to be used by a user directly, and is subject
+// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
+// program!
+//
+// Acknowledgment: Google Test borrowed the idea of automatic test
+// registration from Barthelemy Dagenais' (barthelemy@prologique.com)
+// easyUnit framework.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_H_
+
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <ostream>
+#include <type_traits>
+#include <vector>
+
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file declares functions and macros used internally by
+// Google Test.  They are subject to change without notice.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Low-level types and utilities for porting Google Test to various
+// platforms.  All macros ending with _ and symbols defined in an
+// internal namespace are subject to change without notice.  Code
+// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't
+// end with _ are part of Google Test's public API and can be used by
+// code outside Google Test.
+//
+// This file is fundamental to Google Test.  All other Google Test source
+// files are expected to #include this.  Therefore, it cannot #include
+// any other Google Test header.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+
+// Environment-describing macros
+// -----------------------------
+//
+// Google Test can be used in many different environments.  Macros in
+// this section tell Google Test what kind of environment it is being
+// used in, such that Google Test can provide environment-specific
+// features and implementations.
+//
+// Google Test tries to automatically detect the properties of its
+// environment, so users usually don't need to worry about these
+// macros.  However, the automatic detection is not perfect.
+// Sometimes it's necessary for a user to define some of the following
+// macros in the build script to override Google Test's decisions.
+//
+// If the user doesn't define a macro in the list, Google Test will
+// provide a default definition.  After this header is #included, all
+// macros in this list will be defined to either 1 or 0.
+//
+// Notes to maintainers:
+//   - Each macro here is a user-tweakable knob; do not grow the list
+//     lightly.
+//   - Use #if to key off these macros.  Don't use #ifdef or "#if
+//     defined(...)", which will not work as these macros are ALWAYS
+//     defined.
+//
+//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
+//                              is/isn't available.
+//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
+//                              are enabled.
+//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
+//                              expressions are/aren't available.
+//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
+//                              is/isn't available.
+//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
+//                              enabled.
+//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
+//                              std::wstring does/doesn't work (Google Test can
+//                              be used where std::wstring is unavailable).
+//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
+//                              compiler supports Microsoft's "Structured
+//                              Exception Handling".
+//   GTEST_HAS_STREAM_REDIRECTION
+//                            - Define it to 1/0 to indicate whether the
+//                              platform supports I/O stream redirection using
+//                              dup() and dup2().
+//   GTEST_LINKED_AS_SHARED_LIBRARY
+//                            - Define to 1 when compiling tests that use
+//                              Google Test as a shared library (known as
+//                              DLL on Windows).
+//   GTEST_CREATE_SHARED_LIBRARY
+//                            - Define to 1 when compiling Google Test itself
+//                              as a shared library.
+//   GTEST_DEFAULT_DEATH_TEST_STYLE
+//                            - The default value of --gtest_death_test_style.
+//                              The legacy default has been "fast" in the open
+//                              source version since 2008. The recommended value
+//                              is "threadsafe", and can be set in
+//                              custom/gtest-port.h.
+
+// Platform-indicating macros
+// --------------------------
+//
+// Macros indicating the platform on which Google Test is being used
+// (a macro is defined to 1 if compiled on the given platform;
+// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
+// defines these macros automatically.  Code outside Google Test MUST
+// NOT define them.
+//
+//   GTEST_OS_AIX      - IBM AIX
+//   GTEST_OS_CYGWIN   - Cygwin
+//   GTEST_OS_DRAGONFLY - DragonFlyBSD
+//   GTEST_OS_FREEBSD  - FreeBSD
+//   GTEST_OS_FUCHSIA  - Fuchsia
+//   GTEST_OS_GNU_KFREEBSD - GNU/kFreeBSD
+//   GTEST_OS_HAIKU    - Haiku
+//   GTEST_OS_HPUX     - HP-UX
+//   GTEST_OS_LINUX    - Linux
+//     GTEST_OS_LINUX_ANDROID - Google Android
+//   GTEST_OS_MAC      - Mac OS X
+//     GTEST_OS_IOS    - iOS
+//   GTEST_OS_NACL     - Google Native Client (NaCl)
+//   GTEST_OS_NETBSD   - NetBSD
+//   GTEST_OS_OPENBSD  - OpenBSD
+//   GTEST_OS_OS2      - OS/2
+//   GTEST_OS_QNX      - QNX
+//   GTEST_OS_SOLARIS  - Sun Solaris
+//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
+//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
+//     GTEST_OS_WINDOWS_MINGW    - MinGW
+//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
+//     GTEST_OS_WINDOWS_PHONE    - Windows Phone
+//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT
+//   GTEST_OS_ZOS      - z/OS
+//
+// Among the platforms, Cygwin, Linux, Mac OS X, and Windows have the
+// most stable support.  Since core members of the Google Test project
+// don't have access to other platforms, support for them may be less
+// stable.  If you notice any problems on your platform, please notify
+// googletestframework@googlegroups.com (patches for fixing them are
+// even more welcome!).
+//
+// It is possible that none of the GTEST_OS_* macros are defined.
+
+// Feature-indicating macros
+// -------------------------
+//
+// Macros indicating which Google Test features are available (a macro
+// is defined to 1 if the corresponding feature is supported;
+// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
+// defines these macros automatically.  Code outside Google Test MUST
+// NOT define them.
+//
+// These macros are public so that portable tests can be written.
+// Such tests typically surround code using a feature with an #if
+// which controls that code.  For example:
+//
+// #if GTEST_HAS_DEATH_TEST
+//   EXPECT_DEATH(DoSomethingDeadly());
+// #endif
+//
+//   GTEST_HAS_DEATH_TEST   - death tests
+//   GTEST_HAS_TYPED_TEST   - typed tests
+//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
+//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
+//   GOOGLETEST_CM0007 DO NOT DELETE
+//   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
+//                            GTEST_HAS_POSIX_RE (see above) which users can
+//                            define themselves.
+//   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
+//                            the above RE\b(s) are mutually exclusive.
+
+// Misc public macros
+// ------------------
+//
+//   GTEST_FLAG(flag_name)  - references the variable corresponding to
+//                            the given Google Test flag.
+
+// Internal utilities
+// ------------------
+//
+// The following macros and utilities are for Google Test's INTERNAL
+// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.
+//
+// Macros for basic C++ coding:
+//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
+//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
+//                              variable don't have to be used.
+//   GTEST_DISALLOW_ASSIGN_   - disables copy operator=.
+//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
+//   GTEST_DISALLOW_MOVE_ASSIGN_   - disables move operator=.
+//   GTEST_DISALLOW_MOVE_AND_ASSIGN_ - disables move ctor and operator=.
+//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
+//   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
+//                                        suppressed (constant conditional).
+//   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127
+//                                        is suppressed.
+//   GTEST_INTERNAL_HAS_ANY - for enabling UniversalPrinter<std::any> or
+//                            UniversalPrinter<absl::any> specializations.
+//   GTEST_INTERNAL_HAS_OPTIONAL - for enabling UniversalPrinter<std::optional>
+//   or
+//                                 UniversalPrinter<absl::optional>
+//                                 specializations.
+//   GTEST_INTERNAL_HAS_STRING_VIEW - for enabling Matcher<std::string_view> or
+//                                    Matcher<absl::string_view>
+//                                    specializations.
+//   GTEST_INTERNAL_HAS_VARIANT - for enabling UniversalPrinter<std::variant> or
+//                                UniversalPrinter<absl::variant>
+//                                specializations.
+//
+// Synchronization:
+//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
+//                            - synchronization primitives.
+//
+// Regular expressions:
+//   RE             - a simple regular expression class using the POSIX
+//                    Extended Regular Expression syntax on UNIX-like platforms
+//                    GOOGLETEST_CM0008 DO NOT DELETE
+//                    or a reduced regular exception syntax on other
+//                    platforms, including Windows.
+// Logging:
+//   GTEST_LOG_()   - logs messages at the specified severity level.
+//   LogToStderr()  - directs all log messages to stderr.
+//   FlushInfoLog() - flushes informational log messages.
+//
+// Stdout and stderr capturing:
+//   CaptureStdout()     - starts capturing stdout.
+//   GetCapturedStdout() - stops capturing stdout and returns the captured
+//                         string.
+//   CaptureStderr()     - starts capturing stderr.
+//   GetCapturedStderr() - stops capturing stderr and returns the captured
+//                         string.
+//
+// Integer types:
+//   TypeWithSize   - maps an integer to a int type.
+//   TimeInMillis   - integers of known sizes.
+//   BiggestInt     - the biggest signed integer type.
+//
+// Command-line utilities:
+//   GTEST_DECLARE_*()  - declares a flag.
+//   GTEST_DEFINE_*()   - defines a flag.
+//   GetInjectableArgvs() - returns the command line as a vector of strings.
+//
+// Environment variable utilities:
+//   GetEnv()             - gets the value of an environment variable.
+//   BoolFromGTestEnv()   - parses a bool environment variable.
+//   Int32FromGTestEnv()  - parses an int32_t environment variable.
+//   StringFromGTestEnv() - parses a string environment variable.
+//
+// Deprecation warnings:
+//   GTEST_INTERNAL_DEPRECATED(message) - attribute marking a function as
+//                                        deprecated; calling a marked function
+//                                        should generate a compiler warning
+
+#include <ctype.h>   // for isspace, etc
+#include <stddef.h>  // for ptrdiff_t
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <cerrno>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#ifndef _WIN32_WCE
+# include <sys/types.h>
+# include <sys/stat.h>
+#endif  // !_WIN32_WCE
+
+#if defined __APPLE__
+# include <AvailabilityMacros.h>
+# include <TargetConditionals.h>
+#endif
+
+#include <iostream>  // NOLINT
+#include <locale>
+#include <memory>
+#include <string>  // NOLINT
+#include <tuple>
+#include <vector>  // NOLINT
+
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Injection point for custom user configurations. See README for details
+//
+// ** Custom implementation starts here **
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines the GTEST_OS_* macro.
+// It is separate from gtest-port.h so that custom/gtest-port.h can include it.
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
+
+// Determines the platform on which Google Test is compiled.
+#ifdef __CYGWIN__
+# define GTEST_OS_CYGWIN 1
+# elif defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)
+#  define GTEST_OS_WINDOWS_MINGW 1
+#  define GTEST_OS_WINDOWS 1
+#elif defined _WIN32
+# define GTEST_OS_WINDOWS 1
+# ifdef _WIN32_WCE
+#  define GTEST_OS_WINDOWS_MOBILE 1
+# elif defined(WINAPI_FAMILY)
+#  include <winapifamily.h>
+#  if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#   define GTEST_OS_WINDOWS_DESKTOP 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
+#   define GTEST_OS_WINDOWS_PHONE 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+#   define GTEST_OS_WINDOWS_RT 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE)
+#   define GTEST_OS_WINDOWS_PHONE 1
+#   define GTEST_OS_WINDOWS_TV_TITLE 1
+#  else
+    // WINAPI_FAMILY defined but no known partition matched.
+    // Default to desktop.
+#   define GTEST_OS_WINDOWS_DESKTOP 1
+#  endif
+# else
+#  define GTEST_OS_WINDOWS_DESKTOP 1
+# endif  // _WIN32_WCE
+#elif defined __OS2__
+# define GTEST_OS_OS2 1
+#elif defined __APPLE__
+# define GTEST_OS_MAC 1
+# include <TargetConditionals.h>
+# if TARGET_OS_IPHONE
+#  define GTEST_OS_IOS 1
+# endif
+#elif defined __DragonFly__
+# define GTEST_OS_DRAGONFLY 1
+#elif defined __FreeBSD__
+# define GTEST_OS_FREEBSD 1
+#elif defined __Fuchsia__
+# define GTEST_OS_FUCHSIA 1
+#elif defined(__GLIBC__) && defined(__FreeBSD_kernel__)
+# define GTEST_OS_GNU_KFREEBSD 1
+#elif defined __linux__
+# define GTEST_OS_LINUX 1
+# if defined __ANDROID__
+#  define GTEST_OS_LINUX_ANDROID 1
+# endif
+#elif defined __MVS__
+# define GTEST_OS_ZOS 1
+#elif defined(__sun) && defined(__SVR4)
+# define GTEST_OS_SOLARIS 1
+#elif defined(_AIX)
+# define GTEST_OS_AIX 1
+#elif defined(__hpux)
+# define GTEST_OS_HPUX 1
+#elif defined __native_client__
+# define GTEST_OS_NACL 1
+#elif defined __NetBSD__
+# define GTEST_OS_NETBSD 1
+#elif defined __OpenBSD__
+# define GTEST_OS_OPENBSD 1
+#elif defined __QNX__
+# define GTEST_OS_QNX 1
+#elif defined(__HAIKU__)
+#define GTEST_OS_HAIKU 1
+#elif defined ESP8266
+#define GTEST_OS_ESP8266 1
+#elif defined ESP32
+#define GTEST_OS_ESP32 1
+#elif defined(__XTENSA__)
+#define GTEST_OS_XTENSA 1
+#endif  // __CYGWIN__
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
+
+#if !defined(GTEST_DEV_EMAIL_)
+# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
+# define GTEST_FLAG_PREFIX_ "gtest_"
+# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
+# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
+# define GTEST_NAME_ "Google Test"
+# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
+#endif  // !defined(GTEST_DEV_EMAIL_)
+
+#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
+# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
+#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
+
+// Determines the version of gcc that is used to compile this.
+#ifdef __GNUC__
+// 40302 means version 4.3.2.
+# define GTEST_GCC_VER_ \
+    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
+#endif  // __GNUC__
+
+// Macros for disabling Microsoft Visual C++ warnings.
+//
+//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
+//   /* code that triggers warnings C4800 and C4385 */
+//   GTEST_DISABLE_MSC_WARNINGS_POP_()
+#if defined(_MSC_VER)
+# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
+    __pragma(warning(push))                        \
+    __pragma(warning(disable: warnings))
+# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
+    __pragma(warning(pop))
+#else
+// Not all compilers are MSVC
+# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
+# define GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif
+
+// Clang on Windows does not understand MSVC's pragma warning.
+// We need clang-specific way to disable function deprecation warning.
+#ifdef __clang__
+# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_()                         \
+    _Pragma("clang diagnostic push")                                  \
+    _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \
+    _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"")
+#define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
+    _Pragma("clang diagnostic pop")
+#else
+# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \
+    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
+# define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
+    GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif
+
+// Brings in definitions for functions used in the testing::internal::posix
+// namespace (read, write, close, chdir, isatty, stat). We do not currently
+// use them on Windows Mobile.
+#if GTEST_OS_WINDOWS
+# if !GTEST_OS_WINDOWS_MOBILE
+#  include <direct.h>
+#  include <io.h>
+# endif
+// In order to avoid having to include <windows.h>, use forward declaration
+#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR)
+// MinGW defined _CRITICAL_SECTION and _RTL_CRITICAL_SECTION as two
+// separate (equivalent) structs, instead of using typedef
+typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION;
+#else
+// Assume CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION.
+// This assumption is verified by
+// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.
+typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
+#endif
+#elif GTEST_OS_XTENSA
+#include <unistd.h>
+// Xtensa toolchains define strcasecmp in the string.h header instead of
+// strings.h. string.h is already included.
+#else
+// This assumes that non-Windows OSes provide unistd.h. For OSes where this
+// is not the case, we need to include headers that provide the functions
+// mentioned above.
+# include <unistd.h>
+# include <strings.h>
+#endif  // GTEST_OS_WINDOWS
+
+#if GTEST_OS_LINUX_ANDROID
+// Used to define __ANDROID_API__ matching the target NDK API level.
+#  include <android/api-level.h>  // NOLINT
+#endif
+
+// Defines this to true if and only if Google Test can use POSIX regular
+// expressions.
+#ifndef GTEST_HAS_POSIX_RE
+# if GTEST_OS_LINUX_ANDROID
+// On Android, <regex.h> is only available starting with Gingerbread.
+#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
+# else
+#define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS && !GTEST_OS_XTENSA)
+# endif
+#endif
+
+#if GTEST_USES_PCRE
+// The appropriate headers have already been included.
+
+#elif GTEST_HAS_POSIX_RE
+
+// On some platforms, <regex.h> needs someone to define size_t, and
+// won't compile otherwise.  We can #include it here as we already
+// included <stdlib.h>, which is guaranteed to define size_t through
+// <stddef.h>.
+# include <regex.h>  // NOLINT
+
+# define GTEST_USES_POSIX_RE 1
+
+#elif GTEST_OS_WINDOWS
+
+// <regex.h> is not available on Windows.  Use our own simple regex
+// implementation instead.
+# define GTEST_USES_SIMPLE_RE 1
+
+#else
+
+// <regex.h> may not be available on this platform.  Use our own
+// simple regex implementation instead.
+# define GTEST_USES_SIMPLE_RE 1
+
+#endif  // GTEST_USES_PCRE
+
+#ifndef GTEST_HAS_EXCEPTIONS
+// The user didn't tell us whether exceptions are enabled, so we need
+// to figure it out.
+# if defined(_MSC_VER) && defined(_CPPUNWIND)
+// MSVC defines _CPPUNWIND to 1 if and only if exceptions are enabled.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__BORLANDC__)
+// C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS
+// macro to enable exceptions, so we'll do the same.
+// Assumes that exceptions are enabled by default.
+#  ifndef _HAS_EXCEPTIONS
+#   define _HAS_EXCEPTIONS 1
+#  endif  // _HAS_EXCEPTIONS
+#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
+# elif defined(__clang__)
+// clang defines __EXCEPTIONS if and only if exceptions are enabled before clang
+// 220714, but if and only if cleanups are enabled after that. In Obj-C++ files,
+// there can be cleanups for ObjC exceptions which also need cleanups, even if
+// C++ exceptions are disabled. clang has __has_feature(cxx_exceptions) which
+// checks for C++ exceptions starting at clang r206352, but which checked for
+// cleanups prior to that. To reliably check for C++ exception availability with
+// clang, check for
+// __EXCEPTIONS && __has_feature(cxx_exceptions).
+#  define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
+# elif defined(__GNUC__) && __EXCEPTIONS
+// gcc defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__SUNPRO_CC)
+// Sun Pro CC supports exceptions.  However, there is no compile-time way of
+// detecting whether they are enabled or not.  Therefore, we assume that
+// they are enabled unless the user tells us otherwise.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__IBMCPP__) && __EXCEPTIONS
+// xlC defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__HP_aCC)
+// Exception handling is in effect by default in HP aCC compiler. It has to
+// be turned of by +noeh compiler option if desired.
+#  define GTEST_HAS_EXCEPTIONS 1
+# else
+// For other compilers, we assume exceptions are disabled to be
+// conservative.
+#  define GTEST_HAS_EXCEPTIONS 0
+# endif  // defined(_MSC_VER) || defined(__BORLANDC__)
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#ifndef GTEST_HAS_STD_WSTRING
+// The user didn't tell us whether ::std::wstring is available, so we need
+// to figure it out.
+// Cygwin 1.7 and below doesn't support ::std::wstring.
+// Solaris' libc++ doesn't support it either.  Android has
+// no support for it at least as recent as Froyo (2.2).
+#define GTEST_HAS_STD_WSTRING                                         \
+  (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
+     GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 || GTEST_OS_XTENSA))
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+// Determines whether RTTI is available.
+#ifndef GTEST_HAS_RTTI
+// The user didn't tell us whether RTTI is enabled, so we need to
+// figure it out.
+
+# ifdef _MSC_VER
+
+#ifdef _CPPRTTI  // MSVC defines this macro if and only if RTTI is enabled.
+#   define GTEST_HAS_RTTI 1
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif
+
+// Starting with version 4.3.2, gcc defines __GXX_RTTI if and only if RTTI is
+// enabled.
+# elif defined(__GNUC__)
+
+#  ifdef __GXX_RTTI
+// When building against STLport with the Android NDK and with
+// -frtti -fno-exceptions, the build fails at link time with undefined
+// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
+// so disable RTTI when detected.
+#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
+       !defined(__EXCEPTIONS)
+#    define GTEST_HAS_RTTI 0
+#   else
+#    define GTEST_HAS_RTTI 1
+#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif  // __GXX_RTTI
+
+// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
+// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
+// first version with C++ support.
+# elif defined(__clang__)
+
+#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
+
+// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
+// both the typeid and dynamic_cast features are present.
+# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
+
+#  ifdef __RTTI_ALL__
+#   define GTEST_HAS_RTTI 1
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif
+
+# else
+
+// For all other compilers, we assume RTTI is enabled.
+#  define GTEST_HAS_RTTI 1
+
+# endif  // _MSC_VER
+
+#endif  // GTEST_HAS_RTTI
+
+// It's this header's responsibility to #include <typeinfo> when RTTI
+// is enabled.
+#if GTEST_HAS_RTTI
+# include <typeinfo>
+#endif
+
+// Determines whether Google Test can use the pthreads library.
+#ifndef GTEST_HAS_PTHREAD
+// The user didn't tell us explicitly, so we make reasonable assumptions about
+// which platforms have pthreads support.
+//
+// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
+// to your compiler flags.
+#define GTEST_HAS_PTHREAD                                                      \
+  (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX ||          \
+   GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \
+   GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD ||          \
+   GTEST_OS_HAIKU)
+#endif  // GTEST_HAS_PTHREAD
+
+#if GTEST_HAS_PTHREAD
+// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
+// true.
+# include <pthread.h>  // NOLINT
+
+// For timespec and nanosleep, used below.
+# include <time.h>  // NOLINT
+#endif
+
+// Determines whether clone(2) is supported.
+// Usually it will only be available on Linux, excluding
+// Linux on the Itanium architecture.
+// Also see http://linux.die.net/man/2/clone.
+#ifndef GTEST_HAS_CLONE
+// The user didn't tell us, so we need to figure it out.
+
+# if GTEST_OS_LINUX && !defined(__ia64__)
+#  if GTEST_OS_LINUX_ANDROID
+// On Android, clone() became available at different API levels for each 32-bit
+// architecture.
+#    if defined(__LP64__) || \
+        (defined(__arm__) && __ANDROID_API__ >= 9) || \
+        (defined(__mips__) && __ANDROID_API__ >= 12) || \
+        (defined(__i386__) && __ANDROID_API__ >= 17)
+#     define GTEST_HAS_CLONE 1
+#    else
+#     define GTEST_HAS_CLONE 0
+#    endif
+#  else
+#   define GTEST_HAS_CLONE 1
+#  endif
+# else
+#  define GTEST_HAS_CLONE 0
+# endif  // GTEST_OS_LINUX && !defined(__ia64__)
+
+#endif  // GTEST_HAS_CLONE
+
+// Determines whether to support stream redirection. This is used to test
+// output correctness and to implement death tests.
+#ifndef GTEST_HAS_STREAM_REDIRECTION
+// By default, we assume that stream redirection is supported on all
+// platforms except known mobile ones.
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
+#  define GTEST_HAS_STREAM_REDIRECTION 0
+# else
+#  define GTEST_HAS_STREAM_REDIRECTION 1
+# endif  // !GTEST_OS_WINDOWS_MOBILE
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+// Determines whether to support death tests.
+// pops up a dialog window that cannot be suppressed programmatically.
+#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS ||             \
+     (GTEST_OS_MAC && !GTEST_OS_IOS) ||                                   \
+     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW ||  \
+     GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \
+     GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA ||           \
+     GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU)
+# define GTEST_HAS_DEATH_TEST 1
+#endif
+
+// Determines whether to support type-driven tests.
+
+// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
+// Sun Pro CC, IBM Visual Age, and HP aCC support.
+#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \
+    defined(__IBMCPP__) || defined(__HP_aCC)
+# define GTEST_HAS_TYPED_TEST 1
+# define GTEST_HAS_TYPED_TEST_P 1
+#endif
+
+// Determines whether the system compiler uses UTF-16 for encoding wide strings.
+#define GTEST_WIDE_STRING_USES_UTF16_ \
+  (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2)
+
+// Determines whether test results can be streamed to a socket.
+#if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \
+    GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD
+# define GTEST_CAN_STREAM_RESULTS_ 1
+#endif
+
+// Defines some utility macros.
+
+// The GNU compiler emits a warning if nested "if" statements are followed by
+// an "else" statement and braces are not used to explicitly disambiguate the
+// "else" binding.  This leads to problems with code like:
+//
+//   if (gate)
+//     ASSERT_*(condition) << "Some message";
+//
+// The "switch (0) case 0:" idiom is used to suppress this.
+#ifdef __INTEL_COMPILER
+# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
+#else
+# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
+#endif
+
+// Use this annotation at the end of a struct/class definition to
+// prevent the compiler from optimizing away instances that are never
+// used.  This is useful when all interesting logic happens inside the
+// c'tor and / or d'tor.  Example:
+//
+//   struct Foo {
+//     Foo() { ... }
+//   } GTEST_ATTRIBUTE_UNUSED_;
+//
+// Also use it after a variable or parameter declaration to tell the
+// compiler the variable/parameter does not have to be used.
+#if defined(__GNUC__) && !defined(COMPILER_ICC)
+# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
+#elif defined(__clang__)
+# if __has_attribute(unused)
+#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
+# endif
+#endif
+#ifndef GTEST_ATTRIBUTE_UNUSED_
+# define GTEST_ATTRIBUTE_UNUSED_
+#endif
+
+// Use this annotation before a function that takes a printf format string.
+#if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC)
+# if defined(__MINGW_PRINTF_FORMAT)
+// MinGW has two different printf implementations. Ensure the format macro
+// matches the selected implementation. See
+// https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/.
+#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
+       __attribute__((__format__(__MINGW_PRINTF_FORMAT, string_index, \
+                                 first_to_check)))
+# else
+#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
+       __attribute__((__format__(__printf__, string_index, first_to_check)))
+# endif
+#else
+# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
+#endif
+
+
+// A macro to disallow copy operator=
+// This should be used in the private: declarations for a class.
+#define GTEST_DISALLOW_ASSIGN_(type) \
+  type& operator=(type const &) = delete
+
+// A macro to disallow copy constructor and operator=
+// This should be used in the private: declarations for a class.
+#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
+  type(type const&) = delete;                 \
+  type& operator=(type const&) = delete
+
+// A macro to disallow move operator=
+// This should be used in the private: declarations for a class.
+#define GTEST_DISALLOW_MOVE_ASSIGN_(type) \
+  type& operator=(type &&) noexcept = delete
+
+// A macro to disallow move constructor and operator=
+// This should be used in the private: declarations for a class.
+#define GTEST_DISALLOW_MOVE_AND_ASSIGN_(type) \
+  type(type&&) noexcept = delete;             \
+  type& operator=(type&&) noexcept = delete
+
+// Tell the compiler to warn about unused return values for functions declared
+// with this macro.  The macro should be used on function declarations
+// following the argument list:
+//
+//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
+#if defined(__GNUC__) && !defined(COMPILER_ICC)
+# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
+#else
+# define GTEST_MUST_USE_RESULT_
+#endif  // __GNUC__ && !COMPILER_ICC
+
+// MS C++ compiler emits warning when a conditional expression is compile time
+// constant. In some contexts this warning is false positive and needs to be
+// suppressed. Use the following two macros in such cases:
+//
+// GTEST_INTENTIONAL_CONST_COND_PUSH_()
+// while (true) {
+// GTEST_INTENTIONAL_CONST_COND_POP_()
+// }
+# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
+    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
+# define GTEST_INTENTIONAL_CONST_COND_POP_() \
+    GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+// Determine whether the compiler supports Microsoft's Structured Exception
+// Handling.  This is supported by several Windows compilers but generally
+// does not exist on any other system.
+#ifndef GTEST_HAS_SEH
+// The user didn't tell us, so we need to figure it out.
+
+# if defined(_MSC_VER) || defined(__BORLANDC__)
+// These two compilers are known to support SEH.
+#  define GTEST_HAS_SEH 1
+# else
+// Assume no SEH.
+#  define GTEST_HAS_SEH 0
+# endif
+
+#endif  // GTEST_HAS_SEH
+
+#ifndef GTEST_IS_THREADSAFE
+
+#define GTEST_IS_THREADSAFE                                                 \
+  (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ ||                                     \
+   (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \
+   GTEST_HAS_PTHREAD)
+
+#endif  // GTEST_IS_THREADSAFE
+
+// GTEST_API_ qualifies all symbols that must be exported. The definitions below
+// are guarded by #ifndef to give embedders a chance to define GTEST_API_ in
+// gtest/internal/custom/gtest-port.h
+#ifndef GTEST_API_
+
+#ifdef _MSC_VER
+# if GTEST_LINKED_AS_SHARED_LIBRARY
+#  define GTEST_API_ __declspec(dllimport)
+# elif GTEST_CREATE_SHARED_LIBRARY
+#  define GTEST_API_ __declspec(dllexport)
+# endif
+#elif __GNUC__ >= 4 || defined(__clang__)
+# define GTEST_API_ __attribute__((visibility ("default")))
+#endif  // _MSC_VER
+
+#endif  // GTEST_API_
+
+#ifndef GTEST_API_
+# define GTEST_API_
+#endif  // GTEST_API_
+
+#ifndef GTEST_DEFAULT_DEATH_TEST_STYLE
+# define GTEST_DEFAULT_DEATH_TEST_STYLE  "fast"
+#endif  // GTEST_DEFAULT_DEATH_TEST_STYLE
+
+#ifdef __GNUC__
+// Ask the compiler to never inline a given function.
+# define GTEST_NO_INLINE_ __attribute__((noinline))
+#else
+# define GTEST_NO_INLINE_
+#endif
+
+// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
+#if !defined(GTEST_HAS_CXXABI_H_)
+# if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
+#  define GTEST_HAS_CXXABI_H_ 1
+# else
+#  define GTEST_HAS_CXXABI_H_ 0
+# endif
+#endif
+
+// A function level attribute to disable checking for use of uninitialized
+// memory when built with MemorySanitizer.
+#if defined(__clang__)
+# if __has_feature(memory_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
+       __attribute__((no_sanitize_memory))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+# endif  // __has_feature(memory_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+#endif  // __clang__
+
+// A function level attribute to disable AddressSanitizer instrumentation.
+#if defined(__clang__)
+# if __has_feature(address_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
+       __attribute__((no_sanitize_address))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+# endif  // __has_feature(address_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+#endif  // __clang__
+
+// A function level attribute to disable HWAddressSanitizer instrumentation.
+#if defined(__clang__)
+# if __has_feature(hwaddress_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \
+       __attribute__((no_sanitize("hwaddress")))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+# endif  // __has_feature(hwaddress_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+#endif  // __clang__
+
+// A function level attribute to disable ThreadSanitizer instrumentation.
+#if defined(__clang__)
+# if __has_feature(thread_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
+       __attribute__((no_sanitize_thread))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+# endif  // __has_feature(thread_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+#endif  // __clang__
+
+namespace testing {
+
+class Message;
+
+// Legacy imports for backwards compatibility.
+// New code should use std:: names directly.
+using std::get;
+using std::make_tuple;
+using std::tuple;
+using std::tuple_element;
+using std::tuple_size;
+
+namespace internal {
+
+// A secret type that Google Test users don't know about.  It has no
+// definition on purpose.  Therefore it's impossible to create a
+// Secret object, which is what we want.
+class Secret;
+
+// The GTEST_COMPILE_ASSERT_ is a legacy macro used to verify that a compile
+// time expression is true (in new code, use static_assert instead). For
+// example, you could use it to verify the size of a static array:
+//
+//   GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
+//                         names_incorrect_size);
+//
+// The second argument to the macro must be a valid C++ identifier. If the
+// expression is false, compiler will issue an error containing this identifier.
+#define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
+
+// A helper for suppressing warnings on constant condition.  It just
+// returns 'condition'.
+GTEST_API_ bool IsTrue(bool condition);
+
+// Defines RE.
+
+#if GTEST_USES_PCRE
+// if used, PCRE is injected by custom/gtest-port.h
+#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE
+
+// A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
+// Regular Expression syntax.
+class GTEST_API_ RE {
+ public:
+  // A copy constructor is required by the Standard to initialize object
+  // references from r-values.
+  RE(const RE& other) { Init(other.pattern()); }
+
+  // Constructs an RE from a string.
+  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
+
+  RE(const char* regex) { Init(regex); }  // NOLINT
+  ~RE();
+
+  // Returns the string representation of the regex.
+  const char* pattern() const { return pattern_; }
+
+  // FullMatch(str, re) returns true if and only if regular expression re
+  // matches the entire str.
+  // PartialMatch(str, re) returns true if and only if regular expression re
+  // matches a substring of str (including str itself).
+  static bool FullMatch(const ::std::string& str, const RE& re) {
+    return FullMatch(str.c_str(), re);
+  }
+  static bool PartialMatch(const ::std::string& str, const RE& re) {
+    return PartialMatch(str.c_str(), re);
+  }
+
+  static bool FullMatch(const char* str, const RE& re);
+  static bool PartialMatch(const char* str, const RE& re);
+
+ private:
+  void Init(const char* regex);
+  const char* pattern_;
+  bool is_valid_;
+
+# if GTEST_USES_POSIX_RE
+
+  regex_t full_regex_;     // For FullMatch().
+  regex_t partial_regex_;  // For PartialMatch().
+
+# else  // GTEST_USES_SIMPLE_RE
+
+  const char* full_pattern_;  // For FullMatch();
+
+# endif
+};
+
+#endif  // GTEST_USES_PCRE
+
+// Formats a source file path and a line number as they would appear
+// in an error message from the compiler used to compile this code.
+GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);
+
+// Formats a file location for compiler-independent XML output.
+// Although this function is not platform dependent, we put it next to
+// FormatFileLocation in order to contrast the two functions.
+GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
+                                                               int line);
+
+// Defines logging utilities:
+//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
+//                          message itself is streamed into the macro.
+//   LogToStderr()  - directs all log messages to stderr.
+//   FlushInfoLog() - flushes informational log messages.
+
+enum GTestLogSeverity {
+  GTEST_INFO,
+  GTEST_WARNING,
+  GTEST_ERROR,
+  GTEST_FATAL
+};
+
+// Formats log entry severity, provides a stream object for streaming the
+// log message, and terminates the message with a newline when going out of
+// scope.
+class GTEST_API_ GTestLog {
+ public:
+  GTestLog(GTestLogSeverity severity, const char* file, int line);
+
+  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
+  ~GTestLog();
+
+  ::std::ostream& GetStream() { return ::std::cerr; }
+
+ private:
+  const GTestLogSeverity severity_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
+};
+
+#if !defined(GTEST_LOG_)
+
+# define GTEST_LOG_(severity) \
+    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
+                                  __FILE__, __LINE__).GetStream()
+
+inline void LogToStderr() {}
+inline void FlushInfoLog() { fflush(nullptr); }
+
+#endif  // !defined(GTEST_LOG_)
+
+#if !defined(GTEST_CHECK_)
+// INTERNAL IMPLEMENTATION - DO NOT USE.
+//
+// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
+// is not satisfied.
+//  Synopsys:
+//    GTEST_CHECK_(boolean_condition);
+//     or
+//    GTEST_CHECK_(boolean_condition) << "Additional message";
+//
+//    This checks the condition and if the condition is not satisfied
+//    it prints message about the condition violation, including the
+//    condition itself, plus additional message streamed into it, if any,
+//    and then it aborts the program. It aborts the program irrespective of
+//    whether it is built in the debug mode or not.
+# define GTEST_CHECK_(condition) \
+    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+    if (::testing::internal::IsTrue(condition)) \
+      ; \
+    else \
+      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
+#endif  // !defined(GTEST_CHECK_)
+
+// An all-mode assert to verify that the given POSIX-style function
+// call returns 0 (indicating success).  Known limitation: this
+// doesn't expand to a balanced 'if' statement, so enclose the macro
+// in {} if you need to use it as the only statement in an 'if'
+// branch.
+#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
+  if (const int gtest_error = (posix_call)) \
+    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
+                      << gtest_error
+
+// Transforms "T" into "const T&" according to standard reference collapsing
+// rules (this is only needed as a backport for C++98 compilers that do not
+// support reference collapsing). Specifically, it transforms:
+//
+//   char         ==> const char&
+//   const char   ==> const char&
+//   char&        ==> char&
+//   const char&  ==> const char&
+//
+// Note that the non-const reference will not have "const" added. This is
+// standard, and necessary so that "T" can always bind to "const T&".
+template <typename T>
+struct ConstRef { typedef const T& type; };
+template <typename T>
+struct ConstRef<T&> { typedef T& type; };
+
+// The argument T must depend on some template parameters.
+#define GTEST_REFERENCE_TO_CONST_(T) \
+  typename ::testing::internal::ConstRef<T>::type
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Use ImplicitCast_ as a safe version of static_cast for upcasting in
+// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
+// const Foo*).  When you use ImplicitCast_, the compiler checks that
+// the cast is safe.  Such explicit ImplicitCast_s are necessary in
+// surprisingly many situations where C++ demands an exact type match
+// instead of an argument type convertable to a target type.
+//
+// The syntax for using ImplicitCast_ is the same as for static_cast:
+//
+//   ImplicitCast_<ToType>(expr)
+//
+// ImplicitCast_ would have been part of the C++ standard library,
+// but the proposal was submitted too late.  It will probably make
+// its way into the language in the future.
+//
+// This relatively ugly name is intentional. It prevents clashes with
+// similar functions users may have (e.g., implicit_cast). The internal
+// namespace alone is not enough because the function can be found by ADL.
+template<typename To>
+inline To ImplicitCast_(To x) { return x; }
+
+// When you upcast (that is, cast a pointer from type Foo to type
+// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
+// always succeed.  When you downcast (that is, cast a pointer from
+// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
+// how do you know the pointer is really of type SubclassOfFoo?  It
+// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
+// when you downcast, you should use this macro.  In debug mode, we
+// use dynamic_cast<> to double-check the downcast is legal (we die
+// if it's not).  In normal mode, we do the efficient static_cast<>
+// instead.  Thus, it's important to test in debug mode to make sure
+// the cast is legal!
+//    This is the only place in the code we should use dynamic_cast<>.
+// In particular, you SHOULDN'T be using dynamic_cast<> in order to
+// do RTTI (eg code like this:
+//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
+//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
+// You should design the code some other way not to need this.
+//
+// This relatively ugly name is intentional. It prevents clashes with
+// similar functions users may have (e.g., down_cast). The internal
+// namespace alone is not enough because the function can be found by ADL.
+template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
+inline To DownCast_(From* f) {  // so we only accept pointers
+  // Ensures that To is a sub-type of From *.  This test is here only
+  // for compile-time type checking, and has no overhead in an
+  // optimized build at run-time, as it will be optimized away
+  // completely.
+  GTEST_INTENTIONAL_CONST_COND_PUSH_()
+  if (false) {
+  GTEST_INTENTIONAL_CONST_COND_POP_()
+  const To to = nullptr;
+  ::testing::internal::ImplicitCast_<From*>(to);
+  }
+
+#if GTEST_HAS_RTTI
+  // RTTI: debug mode only!
+  GTEST_CHECK_(f == nullptr || dynamic_cast<To>(f) != nullptr);
+#endif
+  return static_cast<To>(f);
+}
+
+// Downcasts the pointer of type Base to Derived.
+// Derived must be a subclass of Base. The parameter MUST
+// point to a class of type Derived, not any subclass of it.
+// When RTTI is available, the function performs a runtime
+// check to enforce this.
+template <class Derived, class Base>
+Derived* CheckedDowncastToActualType(Base* base) {
+#if GTEST_HAS_RTTI
+  GTEST_CHECK_(typeid(*base) == typeid(Derived));
+#endif
+
+#if GTEST_HAS_DOWNCAST_
+  return ::down_cast<Derived*>(base);
+#elif GTEST_HAS_RTTI
+  return dynamic_cast<Derived*>(base);  // NOLINT
+#else
+  return static_cast<Derived*>(base);  // Poor man's downcast.
+#endif
+}
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Defines the stderr capturer:
+//   CaptureStdout     - starts capturing stdout.
+//   GetCapturedStdout - stops capturing stdout and returns the captured string.
+//   CaptureStderr     - starts capturing stderr.
+//   GetCapturedStderr - stops capturing stderr and returns the captured string.
+//
+GTEST_API_ void CaptureStdout();
+GTEST_API_ std::string GetCapturedStdout();
+GTEST_API_ void CaptureStderr();
+GTEST_API_ std::string GetCapturedStderr();
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+// Returns the size (in bytes) of a file.
+GTEST_API_ size_t GetFileSize(FILE* file);
+
+// Reads the entire content of a file as a string.
+GTEST_API_ std::string ReadEntireFile(FILE* file);
+
+// All command line arguments.
+GTEST_API_ std::vector<std::string> GetArgvs();
+
+#if GTEST_HAS_DEATH_TEST
+
+std::vector<std::string> GetInjectableArgvs();
+// Deprecated: pass the args vector by value instead.
+void SetInjectableArgvs(const std::vector<std::string>* new_argvs);
+void SetInjectableArgvs(const std::vector<std::string>& new_argvs);
+void ClearInjectableArgvs();
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Defines synchronization primitives.
+#if GTEST_IS_THREADSAFE
+# if GTEST_HAS_PTHREAD
+// Sleeps for (roughly) n milliseconds.  This function is only for testing
+// Google Test's own constructs.  Don't use it in user tests, either
+// directly or indirectly.
+inline void SleepMilliseconds(int n) {
+  const timespec time = {
+    0,                  // 0 seconds.
+    n * 1000L * 1000L,  // And n ms.
+  };
+  nanosleep(&time, nullptr);
+}
+# endif  // GTEST_HAS_PTHREAD
+
+# if GTEST_HAS_NOTIFICATION_
+// Notification has already been imported into the namespace.
+// Nothing to do here.
+
+# elif GTEST_HAS_PTHREAD
+// Allows a controller thread to pause execution of newly created
+// threads until notified.  Instances of this class must be created
+// and destroyed in the controller thread.
+//
+// This class is only for testing Google Test's own constructs. Do not
+// use it in user tests, either directly or indirectly.
+class Notification {
+ public:
+  Notification() : notified_(false) {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
+  }
+  ~Notification() {
+    pthread_mutex_destroy(&mutex_);
+  }
+
+  // Notifies all threads created with this notification to start. Must
+  // be called from the controller thread.
+  void Notify() {
+    pthread_mutex_lock(&mutex_);
+    notified_ = true;
+    pthread_mutex_unlock(&mutex_);
+  }
+
+  // Blocks until the controller thread notifies. Must be called from a test
+  // thread.
+  void WaitForNotification() {
+    for (;;) {
+      pthread_mutex_lock(&mutex_);
+      const bool notified = notified_;
+      pthread_mutex_unlock(&mutex_);
+      if (notified)
+        break;
+      SleepMilliseconds(10);
+    }
+  }
+
+ private:
+  pthread_mutex_t mutex_;
+  bool notified_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
+};
+
+# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+
+GTEST_API_ void SleepMilliseconds(int n);
+
+// Provides leak-safe Windows kernel handle ownership.
+// Used in death tests and in threading support.
+class GTEST_API_ AutoHandle {
+ public:
+  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to
+  // avoid including <windows.h> in this header file. Including <windows.h> is
+  // undesirable because it defines a lot of symbols and macros that tend to
+  // conflict with client code. This assumption is verified by
+  // WindowsTypesTest.HANDLEIsVoidStar.
+  typedef void* Handle;
+  AutoHandle();
+  explicit AutoHandle(Handle handle);
+
+  ~AutoHandle();
+
+  Handle Get() const;
+  void Reset();
+  void Reset(Handle handle);
+
+ private:
+  // Returns true if and only if the handle is a valid handle object that can be
+  // closed.
+  bool IsCloseable() const;
+
+  Handle handle_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
+};
+
+// Allows a controller thread to pause execution of newly created
+// threads until notified.  Instances of this class must be created
+// and destroyed in the controller thread.
+//
+// This class is only for testing Google Test's own constructs. Do not
+// use it in user tests, either directly or indirectly.
+class GTEST_API_ Notification {
+ public:
+  Notification();
+  void Notify();
+  void WaitForNotification();
+
+ private:
+  AutoHandle event_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
+};
+# endif  // GTEST_HAS_NOTIFICATION_
+
+// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
+// defined, but we don't want to use MinGW's pthreads implementation, which
+// has conformance problems with some versions of the POSIX standard.
+# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
+
+// As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
+// Consequently, it cannot select a correct instantiation of ThreadWithParam
+// in order to call its Run(). Introducing ThreadWithParamBase as a
+// non-templated base class for ThreadWithParam allows us to bypass this
+// problem.
+class ThreadWithParamBase {
+ public:
+  virtual ~ThreadWithParamBase() {}
+  virtual void Run() = 0;
+};
+
+// pthread_create() accepts a pointer to a function type with the C linkage.
+// According to the Standard (7.5/1), function types with different linkages
+// are different even if they are otherwise identical.  Some compilers (for
+// example, SunStudio) treat them as different types.  Since class methods
+// cannot be defined with C-linkage we need to define a free C-function to
+// pass into pthread_create().
+extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
+  static_cast<ThreadWithParamBase*>(thread)->Run();
+  return nullptr;
+}
+
+// Helper class for testing Google Test's multi-threading constructs.
+// To use it, write:
+//
+//   void ThreadFunc(int param) { /* Do things with param */ }
+//   Notification thread_can_start;
+//   ...
+//   // The thread_can_start parameter is optional; you can supply NULL.
+//   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
+//   thread_can_start.Notify();
+//
+// These classes are only for testing Google Test's own constructs. Do
+// not use them in user tests, either directly or indirectly.
+template <typename T>
+class ThreadWithParam : public ThreadWithParamBase {
+ public:
+  typedef void UserThreadFunc(T);
+
+  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
+      : func_(func),
+        param_(param),
+        thread_can_start_(thread_can_start),
+        finished_(false) {
+    ThreadWithParamBase* const base = this;
+    // The thread can be created only after all fields except thread_
+    // have been initialized.
+    GTEST_CHECK_POSIX_SUCCESS_(
+        pthread_create(&thread_, nullptr, &ThreadFuncWithCLinkage, base));
+  }
+  ~ThreadWithParam() override { Join(); }
+
+  void Join() {
+    if (!finished_) {
+      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, nullptr));
+      finished_ = true;
+    }
+  }
+
+  void Run() override {
+    if (thread_can_start_ != nullptr) thread_can_start_->WaitForNotification();
+    func_(param_);
+  }
+
+ private:
+  UserThreadFunc* const func_;  // User-supplied thread function.
+  const T param_;  // User-supplied parameter to the thread function.
+  // When non-NULL, used to block execution until the controller thread
+  // notifies.
+  Notification* const thread_can_start_;
+  bool finished_;  // true if and only if we know that the thread function has
+                   // finished.
+  pthread_t thread_;  // The native thread object.
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
+};
+# endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
+         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+
+# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+// Mutex and ThreadLocal have already been imported into the namespace.
+// Nothing to do here.
+
+# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+
+// Mutex implements mutex on Windows platforms.  It is used in conjunction
+// with class MutexLock:
+//
+//   Mutex mutex;
+//   ...
+//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the
+//                            // end of the current scope.
+//
+// A static Mutex *must* be defined or declared using one of the following
+// macros:
+//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
+//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
+//
+// (A non-static Mutex is defined/declared in the usual way).
+class GTEST_API_ Mutex {
+ public:
+  enum MutexType { kStatic = 0, kDynamic = 1 };
+  // We rely on kStaticMutex being 0 as it is to what the linker initializes
+  // type_ in static mutexes.  critical_section_ will be initialized lazily
+  // in ThreadSafeLazyInit().
+  enum StaticConstructorSelector { kStaticMutex = 0 };
+
+  // This constructor intentionally does nothing.  It relies on type_ being
+  // statically initialized to 0 (effectively setting it to kStatic) and on
+  // ThreadSafeLazyInit() to lazily initialize the rest of the members.
+  explicit Mutex(StaticConstructorSelector /*dummy*/) {}
+
+  Mutex();
+  ~Mutex();
+
+  void Lock();
+
+  void Unlock();
+
+  // Does nothing if the current thread holds the mutex. Otherwise, crashes
+  // with high probability.
+  void AssertHeld();
+
+ private:
+  // Initializes owner_thread_id_ and critical_section_ in static mutexes.
+  void ThreadSafeLazyInit();
+
+  // Per https://blogs.msdn.microsoft.com/oldnewthing/20040223-00/?p=40503,
+  // we assume that 0 is an invalid value for thread IDs.
+  unsigned int owner_thread_id_;
+
+  // For static mutexes, we rely on these members being initialized to zeros
+  // by the linker.
+  MutexType type_;
+  long critical_section_init_phase_;  // NOLINT
+  GTEST_CRITICAL_SECTION* critical_section_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
+};
+
+# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+    extern ::testing::internal::Mutex mutex
+
+# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
+    ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(Mutex* mutex)
+      : mutex_(mutex) { mutex_->Lock(); }
+
+  ~GTestMutexLock() { mutex_->Unlock(); }
+
+ private:
+  Mutex* const mutex_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
+};
+
+typedef GTestMutexLock MutexLock;
+
+// Base class for ValueHolder<T>.  Allows a caller to hold and delete a value
+// without knowing its type.
+class ThreadLocalValueHolderBase {
+ public:
+  virtual ~ThreadLocalValueHolderBase() {}
+};
+
+// Provides a way for a thread to send notifications to a ThreadLocal
+// regardless of its parameter type.
+class ThreadLocalBase {
+ public:
+  // Creates a new ValueHolder<T> object holding a default value passed to
+  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's
+  // responsibility not to call this when the ThreadLocal<T> instance already
+  // has a value on the current thread.
+  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;
+
+ protected:
+  ThreadLocalBase() {}
+  virtual ~ThreadLocalBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
+};
+
+// Maps a thread to a set of ThreadLocals that have values instantiated on that
+// thread and notifies them when the thread exits.  A ThreadLocal instance is
+// expected to persist until all threads it has values on have terminated.
+class GTEST_API_ ThreadLocalRegistry {
+ public:
+  // Registers thread_local_instance as having value on the current thread.
+  // Returns a value that can be used to identify the thread from other threads.
+  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
+      const ThreadLocalBase* thread_local_instance);
+
+  // Invoked when a ThreadLocal instance is destroyed.
+  static void OnThreadLocalDestroyed(
+      const ThreadLocalBase* thread_local_instance);
+};
+
+class GTEST_API_ ThreadWithParamBase {
+ public:
+  void Join();
+
+ protected:
+  class Runnable {
+   public:
+    virtual ~Runnable() {}
+    virtual void Run() = 0;
+  };
+
+  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
+  virtual ~ThreadWithParamBase();
+
+ private:
+  AutoHandle thread_;
+};
+
+// Helper class for testing Google Test's multi-threading constructs.
+template <typename T>
+class ThreadWithParam : public ThreadWithParamBase {
+ public:
+  typedef void UserThreadFunc(T);
+
+  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
+      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
+  }
+  virtual ~ThreadWithParam() {}
+
+ private:
+  class RunnableImpl : public Runnable {
+   public:
+    RunnableImpl(UserThreadFunc* func, T param)
+        : func_(func),
+          param_(param) {
+    }
+    virtual ~RunnableImpl() {}
+    virtual void Run() {
+      func_(param_);
+    }
+
+   private:
+    UserThreadFunc* const func_;
+    const T param_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
+  };
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
+};
+
+// Implements thread-local storage on Windows systems.
+//
+//   // Thread 1
+//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
+//
+//   // Thread 2
+//   tl.set(150);  // Changes the value for thread 2 only.
+//   EXPECT_EQ(150, tl.get());
+//
+//   // Thread 1
+//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
+//   tl.set(200);
+//   EXPECT_EQ(200, tl.get());
+//
+// The template type argument T must have a public copy constructor.
+// In addition, the default ThreadLocal constructor requires T to have
+// a public default constructor.
+//
+// The users of a TheadLocal instance have to make sure that all but one
+// threads (including the main one) using that instance have exited before
+// destroying it. Otherwise, the per-thread objects managed for them by the
+// ThreadLocal instance are not guaranteed to be destroyed on all platforms.
+//
+// Google Test only uses global ThreadLocal objects.  That means they
+// will die after main() has returned.  Therefore, no per-thread
+// object managed by Google Test will be leaked as long as all threads
+// using Google Test have exited when main() returns.
+template <typename T>
+class ThreadLocal : public ThreadLocalBase {
+ public:
+  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
+  explicit ThreadLocal(const T& value)
+      : default_factory_(new InstanceValueHolderFactory(value)) {}
+
+  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
+
+  T* pointer() { return GetOrCreateValue(); }
+  const T* pointer() const { return GetOrCreateValue(); }
+  const T& get() const { return *pointer(); }
+  void set(const T& value) { *pointer() = value; }
+
+ private:
+  // Holds a value of T.  Can be deleted via its base class without the caller
+  // knowing the type of T.
+  class ValueHolder : public ThreadLocalValueHolderBase {
+   public:
+    ValueHolder() : value_() {}
+    explicit ValueHolder(const T& value) : value_(value) {}
+
+    T* pointer() { return &value_; }
+
+   private:
+    T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
+  };
+
+
+  T* GetOrCreateValue() const {
+    return static_cast<ValueHolder*>(
+        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();
+  }
+
+  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
+    return default_factory_->MakeNewHolder();
+  }
+
+  class ValueHolderFactory {
+   public:
+    ValueHolderFactory() {}
+    virtual ~ValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const = 0;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
+  };
+
+  class DefaultValueHolderFactory : public ValueHolderFactory {
+   public:
+    DefaultValueHolderFactory() {}
+    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
+  };
+
+  class InstanceValueHolderFactory : public ValueHolderFactory {
+   public:
+    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
+    ValueHolder* MakeNewHolder() const override {
+      return new ValueHolder(value_);
+    }
+
+   private:
+    const T value_;  // The value for each thread.
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
+  };
+
+  std::unique_ptr<ValueHolderFactory> default_factory_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
+};
+
+# elif GTEST_HAS_PTHREAD
+
+// MutexBase and Mutex implement mutex on pthreads-based platforms.
+class MutexBase {
+ public:
+  // Acquires this mutex.
+  void Lock() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
+    owner_ = pthread_self();
+    has_owner_ = true;
+  }
+
+  // Releases this mutex.
+  void Unlock() {
+    // Since the lock is being released the owner_ field should no longer be
+    // considered valid. We don't protect writing to has_owner_ here, as it's
+    // the caller's responsibility to ensure that the current thread holds the
+    // mutex when this is called.
+    has_owner_ = false;
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
+  }
+
+  // Does nothing if the current thread holds the mutex. Otherwise, crashes
+  // with high probability.
+  void AssertHeld() const {
+    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
+        << "The current thread is not holding the mutex @" << this;
+  }
+
+  // A static mutex may be used before main() is entered.  It may even
+  // be used before the dynamic initialization stage.  Therefore we
+  // must be able to initialize a static mutex object at link time.
+  // This means MutexBase has to be a POD and its member variables
+  // have to be public.
+ public:
+  pthread_mutex_t mutex_;  // The underlying pthread mutex.
+  // has_owner_ indicates whether the owner_ field below contains a valid thread
+  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
+  // accesses to the owner_ field should be protected by a check of this field.
+  // An alternative might be to memset() owner_ to all zeros, but there's no
+  // guarantee that a zero'd pthread_t is necessarily invalid or even different
+  // from pthread_self().
+  bool has_owner_;
+  pthread_t owner_;  // The thread holding the mutex.
+};
+
+// Forward-declares a static mutex.
+#  define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+     extern ::testing::internal::MutexBase mutex
+
+// Defines and statically (i.e. at link time) initializes a static mutex.
+// The initialization list here does not explicitly initialize each field,
+// instead relying on default initialization for the unspecified fields. In
+// particular, the owner_ field (a pthread_t) is not explicitly initialized.
+// This allows initialization to work whether pthread_t is a scalar or struct.
+// The flag -Wmissing-field-initializers must not be specified for this to work.
+#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
+  ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0}
+
+// The Mutex class can only be used for mutexes created at runtime. It
+// shares its API with MutexBase otherwise.
+class Mutex : public MutexBase {
+ public:
+  Mutex() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
+    has_owner_ = false;
+  }
+  ~Mutex() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
+};
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(MutexBase* mutex)
+      : mutex_(mutex) { mutex_->Lock(); }
+
+  ~GTestMutexLock() { mutex_->Unlock(); }
+
+ private:
+  MutexBase* const mutex_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
+};
+
+typedef GTestMutexLock MutexLock;
+
+// Helpers for ThreadLocal.
+
+// pthread_key_create() requires DeleteThreadLocalValue() to have
+// C-linkage.  Therefore it cannot be templatized to access
+// ThreadLocal<T>.  Hence the need for class
+// ThreadLocalValueHolderBase.
+class ThreadLocalValueHolderBase {
+ public:
+  virtual ~ThreadLocalValueHolderBase() {}
+};
+
+// Called by pthread to delete thread-local data stored by
+// pthread_setspecific().
+extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
+  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
+}
+
+// Implements thread-local storage on pthreads-based systems.
+template <typename T>
+class GTEST_API_ ThreadLocal {
+ public:
+  ThreadLocal()
+      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
+  explicit ThreadLocal(const T& value)
+      : key_(CreateKey()),
+        default_factory_(new InstanceValueHolderFactory(value)) {}
+
+  ~ThreadLocal() {
+    // Destroys the managed object for the current thread, if any.
+    DeleteThreadLocalValue(pthread_getspecific(key_));
+
+    // Releases resources associated with the key.  This will *not*
+    // delete managed objects for other threads.
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
+  }
+
+  T* pointer() { return GetOrCreateValue(); }
+  const T* pointer() const { return GetOrCreateValue(); }
+  const T& get() const { return *pointer(); }
+  void set(const T& value) { *pointer() = value; }
+
+ private:
+  // Holds a value of type T.
+  class ValueHolder : public ThreadLocalValueHolderBase {
+   public:
+    ValueHolder() : value_() {}
+    explicit ValueHolder(const T& value) : value_(value) {}
+
+    T* pointer() { return &value_; }
+
+   private:
+    T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
+  };
+
+  static pthread_key_t CreateKey() {
+    pthread_key_t key;
+    // When a thread exits, DeleteThreadLocalValue() will be called on
+    // the object managed for that thread.
+    GTEST_CHECK_POSIX_SUCCESS_(
+        pthread_key_create(&key, &DeleteThreadLocalValue));
+    return key;
+  }
+
+  T* GetOrCreateValue() const {
+    ThreadLocalValueHolderBase* const holder =
+        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
+    if (holder != nullptr) {
+      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
+    }
+
+    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
+    ThreadLocalValueHolderBase* const holder_base = new_holder;
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
+    return new_holder->pointer();
+  }
+
+  class ValueHolderFactory {
+   public:
+    ValueHolderFactory() {}
+    virtual ~ValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const = 0;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
+  };
+
+  class DefaultValueHolderFactory : public ValueHolderFactory {
+   public:
+    DefaultValueHolderFactory() {}
+    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
+  };
+
+  class InstanceValueHolderFactory : public ValueHolderFactory {
+   public:
+    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
+    ValueHolder* MakeNewHolder() const override {
+      return new ValueHolder(value_);
+    }
+
+   private:
+    const T value_;  // The value for each thread.
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
+  };
+
+  // A key pthreads uses for looking up per-thread values.
+  const pthread_key_t key_;
+  std::unique_ptr<ValueHolderFactory> default_factory_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
+};
+
+# endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+
+#else  // GTEST_IS_THREADSAFE
+
+// A dummy implementation of synchronization primitives (mutex, lock,
+// and thread-local variable).  Necessary for compiling Google Test where
+// mutex is not supported - using Google Test in multiple threads is not
+// supported on such platforms.
+
+class Mutex {
+ public:
+  Mutex() {}
+  void Lock() {}
+  void Unlock() {}
+  void AssertHeld() const {}
+};
+
+# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+  extern ::testing::internal::Mutex mutex
+
+# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(Mutex*) {}  // NOLINT
+};
+
+typedef GTestMutexLock MutexLock;
+
+template <typename T>
+class GTEST_API_ ThreadLocal {
+ public:
+  ThreadLocal() : value_() {}
+  explicit ThreadLocal(const T& value) : value_(value) {}
+  T* pointer() { return &value_; }
+  const T* pointer() const { return &value_; }
+  const T& get() const { return value_; }
+  void set(const T& value) { value_ = value; }
+ private:
+  T value_;
+};
+
+#endif  // GTEST_IS_THREADSAFE
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+GTEST_API_ size_t GetThreadCount();
+
+#if GTEST_OS_WINDOWS
+# define GTEST_PATH_SEP_ "\\"
+# define GTEST_HAS_ALT_PATH_SEP_ 1
+#else
+# define GTEST_PATH_SEP_ "/"
+# define GTEST_HAS_ALT_PATH_SEP_ 0
+#endif  // GTEST_OS_WINDOWS
+
+// Utilities for char.
+
+// isspace(int ch) and friends accept an unsigned char or EOF.  char
+// may be signed, depending on the compiler (or compiler flags).
+// Therefore we need to cast a char to unsigned char before calling
+// isspace(), etc.
+
+inline bool IsAlpha(char ch) {
+  return isalpha(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsAlNum(char ch) {
+  return isalnum(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsDigit(char ch) {
+  return isdigit(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsLower(char ch) {
+  return islower(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsSpace(char ch) {
+  return isspace(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsUpper(char ch) {
+  return isupper(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsXDigit(char ch) {
+  return isxdigit(static_cast<unsigned char>(ch)) != 0;
+}
+#ifdef __cpp_char8_t
+inline bool IsXDigit(char8_t ch) {
+  return isxdigit(static_cast<unsigned char>(ch)) != 0;
+}
+#endif
+inline bool IsXDigit(char16_t ch) {
+  const unsigned char low_byte = static_cast<unsigned char>(ch);
+  return ch == low_byte && isxdigit(low_byte) != 0;
+}
+inline bool IsXDigit(char32_t ch) {
+  const unsigned char low_byte = static_cast<unsigned char>(ch);
+  return ch == low_byte && isxdigit(low_byte) != 0;
+}
+inline bool IsXDigit(wchar_t ch) {
+  const unsigned char low_byte = static_cast<unsigned char>(ch);
+  return ch == low_byte && isxdigit(low_byte) != 0;
+}
+
+inline char ToLower(char ch) {
+  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
+}
+inline char ToUpper(char ch) {
+  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
+}
+
+inline std::string StripTrailingSpaces(std::string str) {
+  std::string::iterator it = str.end();
+  while (it != str.begin() && IsSpace(*--it))
+    it = str.erase(it);
+  return str;
+}
+
+// The testing::internal::posix namespace holds wrappers for common
+// POSIX functions.  These wrappers hide the differences between
+// Windows/MSVC and POSIX systems.  Since some compilers define these
+// standard functions as macros, the wrapper cannot have the same name
+// as the wrapped function.
+
+namespace posix {
+
+// Functions with a different name on Windows.
+
+#if GTEST_OS_WINDOWS
+
+typedef struct _stat StatStruct;
+
+# ifdef __BORLANDC__
+inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return stricmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return strdup(src); }
+# else  // !__BORLANDC__
+#  if GTEST_OS_WINDOWS_MOBILE
+inline int DoIsATTY(int /* fd */) { return 0; }
+#  else
+inline int DoIsATTY(int fd) { return _isatty(fd); }
+#  endif  // GTEST_OS_WINDOWS_MOBILE
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return _stricmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return _strdup(src); }
+# endif  // __BORLANDC__
+
+# if GTEST_OS_WINDOWS_MOBILE
+inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
+// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
+// time and thus not defined there.
+# else
+inline int FileNo(FILE* file) { return _fileno(file); }
+inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
+inline int RmDir(const char* dir) { return _rmdir(dir); }
+inline bool IsDir(const StatStruct& st) {
+  return (_S_IFDIR & st.st_mode) != 0;
+}
+# endif  // GTEST_OS_WINDOWS_MOBILE
+
+#elif GTEST_OS_ESP8266
+typedef struct stat StatStruct;
+
+inline int FileNo(FILE* file) { return fileno(file); }
+inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int Stat(const char* path, StatStruct* buf) {
+  // stat function not implemented on ESP8266
+  return 0;
+}
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return strcasecmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return strdup(src); }
+inline int RmDir(const char* dir) { return rmdir(dir); }
+inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
+
+#else
+
+typedef struct stat StatStruct;
+
+inline int FileNo(FILE* file) { return fileno(file); }
+inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return strcasecmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return strdup(src); }
+inline int RmDir(const char* dir) { return rmdir(dir); }
+inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
+
+#endif  // GTEST_OS_WINDOWS
+
+inline int IsATTY(int fd) {
+  // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout
+  // to a file on Linux), which is unexpected, so save the previous value, and
+  // restore it after the call.
+  int savedErrno = errno;
+  int isAttyValue = DoIsATTY(fd);
+  errno = savedErrno;
+
+  return isAttyValue;
+}
+
+// Functions deprecated by MSVC 8.0.
+
+GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
+
+// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
+// StrError() aren't needed on Windows CE at this time and thus not
+// defined there.
+
+#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \
+    !GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA
+inline int ChDir(const char* dir) { return chdir(dir); }
+#endif
+inline FILE* FOpen(const char* path, const char* mode) {
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+  struct wchar_codecvt : public std::codecvt<wchar_t, char, std::mbstate_t> {};
+  std::wstring_convert<wchar_codecvt> converter;
+  std::wstring wide_path = converter.from_bytes(path);
+  std::wstring wide_mode = converter.from_bytes(mode);
+  return _wfopen(wide_path.c_str(), wide_mode.c_str());
+#else  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+  return fopen(path, mode);
+#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+}
+#if !GTEST_OS_WINDOWS_MOBILE
+inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
+  return freopen(path, mode, stream);
+}
+inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
+#endif
+inline int FClose(FILE* fp) { return fclose(fp); }
+#if !GTEST_OS_WINDOWS_MOBILE
+inline int Read(int fd, void* buf, unsigned int count) {
+  return static_cast<int>(read(fd, buf, count));
+}
+inline int Write(int fd, const void* buf, unsigned int count) {
+  return static_cast<int>(write(fd, buf, count));
+}
+inline int Close(int fd) { return close(fd); }
+inline const char* StrError(int errnum) { return strerror(errnum); }
+#endif
+inline const char* GetEnv(const char* name) {
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
+  // We are on an embedded platform, which has no environment variables.
+  static_cast<void>(name);  // To prevent 'unused argument' warning.
+  return nullptr;
+#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
+  // Environment variables which we programmatically clear will be set to the
+  // empty string rather than unset (NULL).  Handle that case.
+  const char* const env = getenv(name);
+  return (env != nullptr && env[0] != '\0') ? env : nullptr;
+#else
+  return getenv(name);
+#endif
+}
+
+GTEST_DISABLE_MSC_DEPRECATED_POP_()
+
+#if GTEST_OS_WINDOWS_MOBILE
+// Windows CE has no C library. The abort() function is used in
+// several places in Google Test. This implementation provides a reasonable
+// imitation of standard behaviour.
+[[noreturn]] void Abort();
+#else
+[[noreturn]] inline void Abort() { abort(); }
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+}  // namespace posix
+
+// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
+// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
+// MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
+// function in order to achieve that.  We use macro definition here because
+// snprintf is a variadic function.
+#if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE
+// MSVC 2005 and above support variadic macros.
+# define GTEST_SNPRINTF_(buffer, size, format, ...) \
+     _snprintf_s(buffer, size, size, format, __VA_ARGS__)
+#elif defined(_MSC_VER)
+// Windows CE does not define _snprintf_s
+# define GTEST_SNPRINTF_ _snprintf
+#else
+# define GTEST_SNPRINTF_ snprintf
+#endif
+
+// The biggest signed integer type the compiler supports.
+//
+// long long is guaranteed to be at least 64-bits in C++11.
+using BiggestInt = long long;  // NOLINT
+
+// The maximum number a BiggestInt can represent.
+constexpr BiggestInt kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)();
+
+// This template class serves as a compile-time function from size to
+// type.  It maps a size in bytes to a primitive type with that
+// size. e.g.
+//
+//   TypeWithSize<4>::UInt
+//
+// is typedef-ed to be unsigned int (unsigned integer made up of 4
+// bytes).
+//
+// Such functionality should belong to STL, but I cannot find it
+// there.
+//
+// Google Test uses this class in the implementation of floating-point
+// comparison.
+//
+// For now it only handles UInt (unsigned int) as that's all Google Test
+// needs.  Other types can be easily added in the future if need
+// arises.
+template <size_t size>
+class TypeWithSize {
+ public:
+  // This prevents the user from using TypeWithSize<N> with incorrect
+  // values of N.
+  using UInt = void;
+};
+
+// The specialization for size 4.
+template <>
+class TypeWithSize<4> {
+ public:
+  using Int = std::int32_t;
+  using UInt = std::uint32_t;
+};
+
+// The specialization for size 8.
+template <>
+class TypeWithSize<8> {
+ public:
+  using Int = std::int64_t;
+  using UInt = std::uint64_t;
+};
+
+// Integer types of known sizes.
+using TimeInMillis = int64_t;  // Represents time in milliseconds.
+
+// Utilities for command line flags and environment variables.
+
+// Macro for referencing flags.
+#if !defined(GTEST_FLAG)
+# define GTEST_FLAG(name) FLAGS_gtest_##name
+#endif  // !defined(GTEST_FLAG)
+
+#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
+# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
+#endif  // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
+
+#if !defined(GTEST_DECLARE_bool_)
+# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
+
+// Macros for declaring flags.
+# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
+# define GTEST_DECLARE_int32_(name) \
+    GTEST_API_ extern std::int32_t GTEST_FLAG(name)
+# define GTEST_DECLARE_string_(name) \
+    GTEST_API_ extern ::std::string GTEST_FLAG(name)
+
+// Macros for defining flags.
+# define GTEST_DEFINE_bool_(name, default_val, doc) \
+    GTEST_API_ bool GTEST_FLAG(name) = (default_val)
+# define GTEST_DEFINE_int32_(name, default_val, doc) \
+    GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val)
+# define GTEST_DEFINE_string_(name, default_val, doc) \
+    GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
+
+#endif  // !defined(GTEST_DECLARE_bool_)
+
+// Thread annotations
+#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
+# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
+# define GTEST_LOCK_EXCLUDED_(locks)
+#endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
+
+// Parses 'str' for a 32-bit signed integer.  If successful, writes the result
+// to *value and returns true; otherwise leaves *value unchanged and returns
+// false.
+GTEST_API_ bool ParseInt32(const Message& src_text, const char* str,
+                           int32_t* value);
+
+// Parses a bool/int32_t/string from the environment variable
+// corresponding to the given Google Test flag.
+bool BoolFromGTestEnv(const char* flag, bool default_val);
+GTEST_API_ int32_t Int32FromGTestEnv(const char* flag, int32_t default_val);
+std::string OutputFlagAlsoCheckEnvVar();
+const char* StringFromGTestEnv(const char* flag, const char* default_val);
+
+}  // namespace internal
+}  // namespace testing
+
+#if !defined(GTEST_INTERNAL_DEPRECATED)
+
+// Internal Macro to mark an API deprecated, for googletest usage only
+// Usage: class GTEST_INTERNAL_DEPRECATED(message) MyClass or
+// GTEST_INTERNAL_DEPRECATED(message) <return_type> myFunction(); Every usage of
+// a deprecated entity will trigger a warning when compiled with
+// `-Wdeprecated-declarations` option (clang, gcc, any __GNUC__ compiler).
+// For msvc /W3 option will need to be used
+// Note that for 'other' compilers this macro evaluates to nothing to prevent
+// compilations errors.
+#if defined(_MSC_VER)
+#define GTEST_INTERNAL_DEPRECATED(message) __declspec(deprecated(message))
+#elif defined(__GNUC__)
+#define GTEST_INTERNAL_DEPRECATED(message) __attribute__((deprecated(message)))
+#else
+#define GTEST_INTERNAL_DEPRECATED(message)
+#endif
+
+#endif  // !defined(GTEST_INTERNAL_DEPRECATED)
+
+#if GTEST_HAS_ABSL
+// Always use absl::any for UniversalPrinter<> specializations if googletest
+// is built with absl support.
+#define GTEST_INTERNAL_HAS_ANY 1
+#include "absl/types/any.h"
+namespace testing {
+namespace internal {
+using Any = ::absl::any;
+}  // namespace internal
+}  // namespace testing
+#else
+#ifdef __has_include
+#if __has_include(<any>) && __cplusplus >= 201703L
+// Otherwise for C++17 and higher use std::any for UniversalPrinter<>
+// specializations.
+#define GTEST_INTERNAL_HAS_ANY 1
+#include <any>
+namespace testing {
+namespace internal {
+using Any = ::std::any;
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::any is not
+// supported.
+#endif  // __has_include(<any>) && __cplusplus >= 201703L
+#endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#if GTEST_HAS_ABSL
+// Always use absl::optional for UniversalPrinter<> specializations if
+// googletest is built with absl support.
+#define GTEST_INTERNAL_HAS_OPTIONAL 1
+#include "absl/types/optional.h"
+namespace testing {
+namespace internal {
+template <typename T>
+using Optional = ::absl::optional<T>;
+}  // namespace internal
+}  // namespace testing
+#else
+#ifdef __has_include
+#if __has_include(<optional>) && __cplusplus >= 201703L
+// Otherwise for C++17 and higher use std::optional for UniversalPrinter<>
+// specializations.
+#define GTEST_INTERNAL_HAS_OPTIONAL 1
+#include <optional>
+namespace testing {
+namespace internal {
+template <typename T>
+using Optional = ::std::optional<T>;
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::optional is not
+// supported.
+#endif  // __has_include(<optional>) && __cplusplus >= 201703L
+#endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#if GTEST_HAS_ABSL
+// Always use absl::string_view for Matcher<> specializations if googletest
+// is built with absl support.
+# define GTEST_INTERNAL_HAS_STRING_VIEW 1
+#include "absl/strings/string_view.h"
+namespace testing {
+namespace internal {
+using StringView = ::absl::string_view;
+}  // namespace internal
+}  // namespace testing
+#else
+# ifdef __has_include
+#   if __has_include(<string_view>) && __cplusplus >= 201703L
+// Otherwise for C++17 and higher use std::string_view for Matcher<>
+// specializations.
+#   define GTEST_INTERNAL_HAS_STRING_VIEW 1
+#include <string_view>
+namespace testing {
+namespace internal {
+using StringView = ::std::string_view;
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::string_view is not
+// supported.
+#  endif  // __has_include(<string_view>) && __cplusplus >= 201703L
+# endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#if GTEST_HAS_ABSL
+// Always use absl::variant for UniversalPrinter<> specializations if googletest
+// is built with absl support.
+#define GTEST_INTERNAL_HAS_VARIANT 1
+#include "absl/types/variant.h"
+namespace testing {
+namespace internal {
+template <typename... T>
+using Variant = ::absl::variant<T...>;
+}  // namespace internal
+}  // namespace testing
+#else
+#ifdef __has_include
+#if __has_include(<variant>) && __cplusplus >= 201703L
+// Otherwise for C++17 and higher use std::variant for UniversalPrinter<>
+// specializations.
+#define GTEST_INTERNAL_HAS_VARIANT 1
+#include <variant>
+namespace testing {
+namespace internal {
+template <typename... T>
+using Variant = ::std::variant<T...>;
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::variant is not supported.
+#endif  // __has_include(<variant>) && __cplusplus >= 201703L
+#endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+
+#if GTEST_OS_LINUX
+# include <stdlib.h>
+# include <sys/types.h>
+# include <sys/wait.h>
+# include <unistd.h>
+#endif  // GTEST_OS_LINUX
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>
+#endif
+
+#include <ctype.h>
+#include <float.h>
+#include <string.h>
+#include <cstdint>
+#include <iomanip>
+#include <limits>
+#include <map>
+#include <set>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines the Message class.
+//
+// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
+// leave some internal implementation details in this header file.
+// They are clearly marked by comments like this:
+//
+//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+//
+// Such code is NOT meant to be used by a user directly, and is subject
+// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
+// program!
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+
+#include <limits>
+#include <memory>
+#include <sstream>
+
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+// Ensures that there is at least one operator<< in the global namespace.
+// See Message& operator<<(...) below for why.
+void operator<<(const testing::internal::Secret&, int);
+
+namespace testing {
+
+// The Message class works like an ostream repeater.
+//
+// Typical usage:
+//
+//   1. You stream a bunch of values to a Message object.
+//      It will remember the text in a stringstream.
+//   2. Then you stream the Message object to an ostream.
+//      This causes the text in the Message to be streamed
+//      to the ostream.
+//
+// For example;
+//
+//   testing::Message foo;
+//   foo << 1 << " != " << 2;
+//   std::cout << foo;
+//
+// will print "1 != 2".
+//
+// Message is not intended to be inherited from.  In particular, its
+// destructor is not virtual.
+//
+// Note that stringstream behaves differently in gcc and in MSVC.  You
+// can stream a NULL char pointer to it in the former, but not in the
+// latter (it causes an access violation if you do).  The Message
+// class hides this difference by treating a NULL char pointer as
+// "(null)".
+class GTEST_API_ Message {
+ private:
+  // The type of basic IO manipulators (endl, ends, and flush) for
+  // narrow streams.
+  typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
+
+ public:
+  // Constructs an empty Message.
+  Message();
+
+  // Copy constructor.
+  Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
+    *ss_ << msg.GetString();
+  }
+
+  // Constructs a Message from a C-string.
+  explicit Message(const char* str) : ss_(new ::std::stringstream) {
+    *ss_ << str;
+  }
+
+  // Streams a non-pointer value to this object.
+  template <typename T>
+  inline Message& operator <<(const T& val) {
+    // Some libraries overload << for STL containers.  These
+    // overloads are defined in the global namespace instead of ::std.
+    //
+    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
+    // overloads are visible in either the std namespace or the global
+    // namespace, but not other namespaces, including the testing
+    // namespace which Google Test's Message class is in.
+    //
+    // To allow STL containers (and other types that has a << operator
+    // defined in the global namespace) to be used in Google Test
+    // assertions, testing::Message must access the custom << operator
+    // from the global namespace.  With this using declaration,
+    // overloads of << defined in the global namespace and those
+    // visible via Koenig lookup are both exposed in this function.
+    using ::operator <<;
+    *ss_ << val;
+    return *this;
+  }
+
+  // Streams a pointer value to this object.
+  //
+  // This function is an overload of the previous one.  When you
+  // stream a pointer to a Message, this definition will be used as it
+  // is more specialized.  (The C++ Standard, section
+  // [temp.func.order].)  If you stream a non-pointer, then the
+  // previous definition will be used.
+  //
+  // The reason for this overload is that streaming a NULL pointer to
+  // ostream is undefined behavior.  Depending on the compiler, you
+  // may get "0", "(nil)", "(null)", or an access violation.  To
+  // ensure consistent result across compilers, we always treat NULL
+  // as "(null)".
+  template <typename T>
+  inline Message& operator <<(T* const& pointer) {  // NOLINT
+    if (pointer == nullptr) {
+      *ss_ << "(null)";
+    } else {
+      *ss_ << pointer;
+    }
+    return *this;
+  }
+
+  // Since the basic IO manipulators are overloaded for both narrow
+  // and wide streams, we have to provide this specialized definition
+  // of operator <<, even though its body is the same as the
+  // templatized version above.  Without this definition, streaming
+  // endl or other basic IO manipulators to Message will confuse the
+  // compiler.
+  Message& operator <<(BasicNarrowIoManip val) {
+    *ss_ << val;
+    return *this;
+  }
+
+  // Instead of 1/0, we want to see true/false for bool values.
+  Message& operator <<(bool b) {
+    return *this << (b ? "true" : "false");
+  }
+
+  // These two overloads allow streaming a wide C string to a Message
+  // using the UTF-8 encoding.
+  Message& operator <<(const wchar_t* wide_c_str);
+  Message& operator <<(wchar_t* wide_c_str);
+
+#if GTEST_HAS_STD_WSTRING
+  // Converts the given wide string to a narrow string using the UTF-8
+  // encoding, and streams the result to this Message object.
+  Message& operator <<(const ::std::wstring& wstr);
+#endif  // GTEST_HAS_STD_WSTRING
+
+  // Gets the text streamed to this object so far as an std::string.
+  // Each '\0' character in the buffer is replaced with "\\0".
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  std::string GetString() const;
+
+ private:
+  // We'll hold the text streamed to this object here.
+  const std::unique_ptr< ::std::stringstream> ss_;
+
+  // We declare (but don't implement) this to prevent the compiler
+  // from implementing the assignment operator.
+  void operator=(const Message&);
+};
+
+// Streams a Message to an ostream.
+inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
+  return os << sb.GetString();
+}
+
+namespace internal {
+
+// Converts a streamable value to an std::string.  A NULL pointer is
+// converted to "(null)".  When the input value is a ::string,
+// ::std::string, ::wstring, or ::std::wstring object, each NUL
+// character in it is replaced with "\\0".
+template <typename T>
+std::string StreamableToString(const T& streamable) {
+  return (Message() << streamable).GetString();
+}
+
+}  // namespace internal
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Google Test filepath utilities
+//
+// This header file declares classes and functions used internally by
+// Google Test.  They are subject to change without notice.
+//
+// This file is #included in gtest/internal/gtest-internal.h.
+// Do not include this header file separately!
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file declares the String class and functions used internally by
+// Google Test.  They are subject to change without notice. They should not used
+// by code external to Google Test.
+//
+// This header file is #included by gtest-internal.h.
+// It should not be #included by other files.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+
+#ifdef __BORLANDC__
+// string.h is not guaranteed to provide strcpy on C++ Builder.
+# include <mem.h>
+#endif
+
+#include <string.h>
+#include <cstdint>
+#include <string>
+
+
+namespace testing {
+namespace internal {
+
+// String - an abstract class holding static string utilities.
+class GTEST_API_ String {
+ public:
+  // Static utility methods
+
+  // Clones a 0-terminated C string, allocating memory using new.  The
+  // caller is responsible for deleting the return value using
+  // delete[].  Returns the cloned string, or NULL if the input is
+  // NULL.
+  //
+  // This is different from strdup() in string.h, which allocates
+  // memory using malloc().
+  static const char* CloneCString(const char* c_str);
+
+#if GTEST_OS_WINDOWS_MOBILE
+  // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
+  // able to pass strings to Win32 APIs on CE we need to convert them
+  // to 'Unicode', UTF-16.
+
+  // Creates a UTF-16 wide string from the given ANSI string, allocating
+  // memory using new. The caller is responsible for deleting the return
+  // value using delete[]. Returns the wide string, or NULL if the
+  // input is NULL.
+  //
+  // The wide string is created using the ANSI codepage (CP_ACP) to
+  // match the behaviour of the ANSI versions of Win32 calls and the
+  // C runtime.
+  static LPCWSTR AnsiToUtf16(const char* c_str);
+
+  // Creates an ANSI string from the given wide string, allocating
+  // memory using new. The caller is responsible for deleting the return
+  // value using delete[]. Returns the ANSI string, or NULL if the
+  // input is NULL.
+  //
+  // The returned string is created using the ANSI codepage (CP_ACP) to
+  // match the behaviour of the ANSI versions of Win32 calls and the
+  // C runtime.
+  static const char* Utf16ToAnsi(LPCWSTR utf16_str);
+#endif
+
+  // Compares two C strings.  Returns true if and only if they have the same
+  // content.
+  //
+  // Unlike strcmp(), this function can handle NULL argument(s).  A
+  // NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool CStringEquals(const char* lhs, const char* rhs);
+
+  // Converts a wide C string to a String using the UTF-8 encoding.
+  // NULL will be converted to "(null)".  If an error occurred during
+  // the conversion, "(failed to convert from wide string)" is
+  // returned.
+  static std::string ShowWideCString(const wchar_t* wide_c_str);
+
+  // Compares two wide C strings.  Returns true if and only if they have the
+  // same content.
+  //
+  // Unlike wcscmp(), this function can handle NULL argument(s).  A
+  // NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
+
+  // Compares two C strings, ignoring case.  Returns true if and only if
+  // they have the same content.
+  //
+  // Unlike strcasecmp(), this function can handle NULL argument(s).
+  // A NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool CaseInsensitiveCStringEquals(const char* lhs,
+                                           const char* rhs);
+
+  // Compares two wide C strings, ignoring case.  Returns true if and only if
+  // they have the same content.
+  //
+  // Unlike wcscasecmp(), this function can handle NULL argument(s).
+  // A NULL C string is considered different to any non-NULL wide C string,
+  // including the empty string.
+  // NB: The implementations on different platforms slightly differ.
+  // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
+  // environment variable. On GNU platform this method uses wcscasecmp
+  // which compares according to LC_CTYPE category of the current locale.
+  // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
+  // current locale.
+  static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
+                                               const wchar_t* rhs);
+
+  // Returns true if and only if the given string ends with the given suffix,
+  // ignoring case. Any string is considered to end with an empty suffix.
+  static bool EndsWithCaseInsensitive(
+      const std::string& str, const std::string& suffix);
+
+  // Formats an int value as "%02d".
+  static std::string FormatIntWidth2(int value);  // "%02d" for width == 2
+
+  // Formats an int value to given width with leading zeros.
+  static std::string FormatIntWidthN(int value, int width);
+
+  // Formats an int value as "%X".
+  static std::string FormatHexInt(int value);
+
+  // Formats an int value as "%X".
+  static std::string FormatHexUInt32(uint32_t value);
+
+  // Formats a byte as "%02X".
+  static std::string FormatByte(unsigned char value);
+
+ private:
+  String();  // Not meant to be instantiated.
+};  // class String
+
+// Gets the content of the stringstream's buffer as an std::string.  Each '\0'
+// character in the buffer is replaced with "\\0".
+GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+namespace internal {
+
+// FilePath - a class for file and directory pathname manipulation which
+// handles platform-specific conventions (like the pathname separator).
+// Used for helper functions for naming files in a directory for xml output.
+// Except for Set methods, all methods are const or static, which provides an
+// "immutable value object" -- useful for peace of mind.
+// A FilePath with a value ending in a path separator ("like/this/") represents
+// a directory, otherwise it is assumed to represent a file. In either case,
+// it may or may not represent an actual file or directory in the file system.
+// Names are NOT checked for syntax correctness -- no checking for illegal
+// characters, malformed paths, etc.
+
+class GTEST_API_ FilePath {
+ public:
+  FilePath() : pathname_("") { }
+  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
+
+  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
+    Normalize();
+  }
+
+  FilePath& operator=(const FilePath& rhs) {
+    Set(rhs);
+    return *this;
+  }
+
+  void Set(const FilePath& rhs) {
+    pathname_ = rhs.pathname_;
+  }
+
+  const std::string& string() const { return pathname_; }
+  const char* c_str() const { return pathname_.c_str(); }
+
+  // Returns the current working directory, or "" if unsuccessful.
+  static FilePath GetCurrentDir();
+
+  // Given directory = "dir", base_name = "test", number = 0,
+  // extension = "xml", returns "dir/test.xml". If number is greater
+  // than zero (e.g., 12), returns "dir/test_12.xml".
+  // On Windows platform, uses \ as the separator rather than /.
+  static FilePath MakeFileName(const FilePath& directory,
+                               const FilePath& base_name,
+                               int number,
+                               const char* extension);
+
+  // Given directory = "dir", relative_path = "test.xml",
+  // returns "dir/test.xml".
+  // On Windows, uses \ as the separator rather than /.
+  static FilePath ConcatPaths(const FilePath& directory,
+                              const FilePath& relative_path);
+
+  // Returns a pathname for a file that does not currently exist. The pathname
+  // will be directory/base_name.extension or
+  // directory/base_name_<number>.extension if directory/base_name.extension
+  // already exists. The number will be incremented until a pathname is found
+  // that does not already exist.
+  // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
+  // There could be a race condition if two or more processes are calling this
+  // function at the same time -- they could both pick the same filename.
+  static FilePath GenerateUniqueFileName(const FilePath& directory,
+                                         const FilePath& base_name,
+                                         const char* extension);
+
+  // Returns true if and only if the path is "".
+  bool IsEmpty() const { return pathname_.empty(); }
+
+  // If input name has a trailing separator character, removes it and returns
+  // the name, otherwise return the name string unmodified.
+  // On Windows platform, uses \ as the separator, other platforms use /.
+  FilePath RemoveTrailingPathSeparator() const;
+
+  // Returns a copy of the FilePath with the directory part removed.
+  // Example: FilePath("path/to/file").RemoveDirectoryName() returns
+  // FilePath("file"). If there is no directory part ("just_a_file"), it returns
+  // the FilePath unmodified. If there is no file part ("just_a_dir/") it
+  // returns an empty FilePath ("").
+  // On Windows platform, '\' is the path separator, otherwise it is '/'.
+  FilePath RemoveDirectoryName() const;
+
+  // RemoveFileName returns the directory path with the filename removed.
+  // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
+  // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
+  // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
+  // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
+  // On Windows platform, '\' is the path separator, otherwise it is '/'.
+  FilePath RemoveFileName() const;
+
+  // Returns a copy of the FilePath with the case-insensitive extension removed.
+  // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
+  // FilePath("dir/file"). If a case-insensitive extension is not
+  // found, returns a copy of the original FilePath.
+  FilePath RemoveExtension(const char* extension) const;
+
+  // Creates directories so that path exists. Returns true if successful or if
+  // the directories already exist; returns false if unable to create
+  // directories for any reason. Will also return false if the FilePath does
+  // not represent a directory (that is, it doesn't end with a path separator).
+  bool CreateDirectoriesRecursively() const;
+
+  // Create the directory so that path exists. Returns true if successful or
+  // if the directory already exists; returns false if unable to create the
+  // directory for any reason, including if the parent directory does not
+  // exist. Not named "CreateDirectory" because that's a macro on Windows.
+  bool CreateFolder() const;
+
+  // Returns true if FilePath describes something in the file-system,
+  // either a file, directory, or whatever, and that something exists.
+  bool FileOrDirectoryExists() const;
+
+  // Returns true if pathname describes a directory in the file-system
+  // that exists.
+  bool DirectoryExists() const;
+
+  // Returns true if FilePath ends with a path separator, which indicates that
+  // it is intended to represent a directory. Returns false otherwise.
+  // This does NOT check that a directory (or file) actually exists.
+  bool IsDirectory() const;
+
+  // Returns true if pathname describes a root directory. (Windows has one
+  // root directory per disk drive.)
+  bool IsRootDirectory() const;
+
+  // Returns true if pathname describes an absolute path.
+  bool IsAbsolutePath() const;
+
+ private:
+  // Replaces multiple consecutive separators with a single separator.
+  // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
+  // redundancies that might be in a pathname involving "." or "..".
+  //
+  // A pathname with multiple consecutive separators may occur either through
+  // user error or as a result of some scripts or APIs that generate a pathname
+  // with a trailing separator. On other platforms the same API or script
+  // may NOT generate a pathname with a trailing "/". Then elsewhere that
+  // pathname may have another "/" and pathname components added to it,
+  // without checking for the separator already being there.
+  // The script language and operating system may allow paths like "foo//bar"
+  // but some of the functions in FilePath will not handle that correctly. In
+  // particular, RemoveTrailingPathSeparator() only removes one separator, and
+  // it is called in CreateDirectoriesRecursively() assuming that it will change
+  // a pathname from directory syntax (trailing separator) to filename syntax.
+  //
+  // On Windows this method also replaces the alternate path separator '/' with
+  // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
+  // "bar\\foo".
+
+  void Normalize();
+
+  // Returns a pointer to the last occurrence of a valid path separator in
+  // the FilePath. On Windows, for example, both '/' and '\' are valid path
+  // separators. Returns NULL if no path separator was found.
+  const char* FindLastPathSeparator() const;
+
+  std::string pathname_;
+};  // class FilePath
+
+}  // namespace internal
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+// Copyright 2008 Google Inc.
+// All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Type utilities needed for implementing typed and type-parameterized
+// tests.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+
+
+// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
+// libstdc++ (which is where cxxabi.h comes from).
+# if GTEST_HAS_CXXABI_H_
+#  include <cxxabi.h>
+# elif defined(__HP_aCC)
+#  include <acxx_demangle.h>
+# endif  // GTEST_HASH_CXXABI_H_
+
+namespace testing {
+namespace internal {
+
+// Canonicalizes a given name with respect to the Standard C++ Library.
+// This handles removing the inline namespace within `std` that is
+// used by various standard libraries (e.g., `std::__1`).  Names outside
+// of namespace std are returned unmodified.
+inline std::string CanonicalizeForStdLibVersioning(std::string s) {
+  static const char prefix[] = "std::__";
+  if (s.compare(0, strlen(prefix), prefix) == 0) {
+    std::string::size_type end = s.find("::", strlen(prefix));
+    if (end != s.npos) {
+      // Erase everything between the initial `std` and the second `::`.
+      s.erase(strlen("std"), end - strlen("std"));
+    }
+  }
+  return s;
+}
+
+#if GTEST_HAS_RTTI
+// GetTypeName(const std::type_info&) returns a human-readable name of type T.
+inline std::string GetTypeName(const std::type_info& type) {
+  const char* const name = type.name();
+#if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
+  int status = 0;
+  // gcc's implementation of typeid(T).name() mangles the type name,
+  // so we have to demangle it.
+#if GTEST_HAS_CXXABI_H_
+  using abi::__cxa_demangle;
+#endif  // GTEST_HAS_CXXABI_H_
+  char* const readable_name = __cxa_demangle(name, nullptr, nullptr, &status);
+  const std::string name_str(status == 0 ? readable_name : name);
+  free(readable_name);
+  return CanonicalizeForStdLibVersioning(name_str);
+#else
+  return name;
+#endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
+}
+#endif  // GTEST_HAS_RTTI
+
+// GetTypeName<T>() returns a human-readable name of type T if and only if
+// RTTI is enabled, otherwise it returns a dummy type name.
+// NB: This function is also used in Google Mock, so don't move it inside of
+// the typed-test-only section below.
+template <typename T>
+std::string GetTypeName() {
+#if GTEST_HAS_RTTI
+  return GetTypeName(typeid(T));
+#else
+  return "<type>";
+#endif  // GTEST_HAS_RTTI
+}
+
+// A unique type indicating an empty node
+struct None {};
+
+# define GTEST_TEMPLATE_ template <typename T> class
+
+// The template "selector" struct TemplateSel<Tmpl> is used to
+// represent Tmpl, which must be a class template with one type
+// parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
+// as the type Tmpl<T>.  This allows us to actually instantiate the
+// template "selected" by TemplateSel<Tmpl>.
+//
+// This trick is necessary for simulating typedef for class templates,
+// which C++ doesn't support directly.
+template <GTEST_TEMPLATE_ Tmpl>
+struct TemplateSel {
+  template <typename T>
+  struct Bind {
+    typedef Tmpl<T> type;
+  };
+};
+
+# define GTEST_BIND_(TmplSel, T) \
+  TmplSel::template Bind<T>::type
+
+template <GTEST_TEMPLATE_ Head_, GTEST_TEMPLATE_... Tail_>
+struct Templates {
+  using Head = TemplateSel<Head_>;
+  using Tail = Templates<Tail_...>;
+};
+
+template <GTEST_TEMPLATE_ Head_>
+struct Templates<Head_> {
+  using Head = TemplateSel<Head_>;
+  using Tail = None;
+};
+
+// Tuple-like type lists
+template <typename Head_, typename... Tail_>
+struct Types {
+  using Head = Head_;
+  using Tail = Types<Tail_...>;
+};
+
+template <typename Head_>
+struct Types<Head_> {
+  using Head = Head_;
+  using Tail = None;
+};
+
+// Helper metafunctions to tell apart a single type from types
+// generated by ::testing::Types
+template <typename... Ts>
+struct ProxyTypeList {
+  using type = Types<Ts...>;
+};
+
+template <typename>
+struct is_proxy_type_list : std::false_type {};
+
+template <typename... Ts>
+struct is_proxy_type_list<ProxyTypeList<Ts...>> : std::true_type {};
+
+// Generator which conditionally creates type lists.
+// It recognizes if a requested type list should be created
+// and prevents creating a new type list nested within another one.
+template <typename T>
+struct GenerateTypeList {
+ private:
+  using proxy = typename std::conditional<is_proxy_type_list<T>::value, T,
+                                          ProxyTypeList<T>>::type;
+
+ public:
+  using type = typename proxy::type;
+};
+
+}  // namespace internal
+
+template <typename... Ts>
+using Types = internal::ProxyTypeList<Ts...>;
+
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+
+// Due to C++ preprocessor weirdness, we need double indirection to
+// concatenate two tokens when one of them is __LINE__.  Writing
+//
+//   foo ## __LINE__
+//
+// will result in the token foo__LINE__, instead of foo followed by
+// the current line number.  For more details, see
+// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
+#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
+#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
+
+// Stringifies its argument.
+// Work around a bug in visual studio which doesn't accept code like this:
+//
+//   #define GTEST_STRINGIFY_(name) #name
+//   #define MACRO(a, b, c) ... GTEST_STRINGIFY_(a) ...
+//   MACRO(, x, y)
+//
+// Complaining about the argument to GTEST_STRINGIFY_ being empty.
+// This is allowed by the spec.
+#define GTEST_STRINGIFY_HELPER_(name, ...) #name
+#define GTEST_STRINGIFY_(...) GTEST_STRINGIFY_HELPER_(__VA_ARGS__, )
+
+namespace proto2 {
+class MessageLite;
+}
+
+namespace testing {
+
+// Forward declarations.
+
+class AssertionResult;                 // Result of an assertion.
+class Message;                         // Represents a failure message.
+class Test;                            // Represents a test.
+class TestInfo;                        // Information about a test.
+class TestPartResult;                  // Result of a test part.
+class UnitTest;                        // A collection of test suites.
+
+template <typename T>
+::std::string PrintToString(const T& value);
+
+namespace internal {
+
+struct TraceInfo;                      // Information about a trace point.
+class TestInfoImpl;                    // Opaque implementation of TestInfo
+class UnitTestImpl;                    // Opaque implementation of UnitTest
+
+// The text used in failure messages to indicate the start of the
+// stack trace.
+GTEST_API_ extern const char kStackTraceMarker[];
+
+// An IgnoredValue object can be implicitly constructed from ANY value.
+class IgnoredValue {
+  struct Sink {};
+ public:
+  // This constructor template allows any value to be implicitly
+  // converted to IgnoredValue.  The object has no data member and
+  // doesn't try to remember anything about the argument.  We
+  // deliberately omit the 'explicit' keyword in order to allow the
+  // conversion to be implicit.
+  // Disable the conversion if T already has a magical conversion operator.
+  // Otherwise we get ambiguity.
+  template <typename T,
+            typename std::enable_if<!std::is_convertible<T, Sink>::value,
+                                    int>::type = 0>
+  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit)
+};
+
+// Appends the user-supplied message to the Google-Test-generated message.
+GTEST_API_ std::string AppendUserMessage(
+    const std::string& gtest_msg, const Message& user_msg);
+
+#if GTEST_HAS_EXCEPTIONS
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4275 \
+/* an exported class was derived from a class that was not exported */)
+
+// This exception is thrown by (and only by) a failed Google Test
+// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
+// are enabled).  We derive it from std::runtime_error, which is for
+// errors presumably detectable only at run time.  Since
+// std::runtime_error inherits from std::exception, many testing
+// frameworks know how to extract and print the message inside it.
+class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
+ public:
+  explicit GoogleTestFailureException(const TestPartResult& failure);
+};
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4275
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+namespace edit_distance {
+// Returns the optimal edits to go from 'left' to 'right'.
+// All edits cost the same, with replace having lower priority than
+// add/remove.
+// Simple implementation of the Wagner-Fischer algorithm.
+// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
+enum EditType { kMatch, kAdd, kRemove, kReplace };
+GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<size_t>& left, const std::vector<size_t>& right);
+
+// Same as above, but the input is represented as strings.
+GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<std::string>& left,
+    const std::vector<std::string>& right);
+
+// Create a diff of the input strings in Unified diff format.
+GTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left,
+                                         const std::vector<std::string>& right,
+                                         size_t context = 2);
+
+}  // namespace edit_distance
+
+// Calculate the diff between 'left' and 'right' and return it in unified diff
+// format.
+// If not null, stores in 'total_line_count' the total number of lines found
+// in left + right.
+GTEST_API_ std::string DiffStrings(const std::string& left,
+                                   const std::string& right,
+                                   size_t* total_line_count);
+
+// Constructs and returns the message for an equality assertion
+// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
+//
+// The first four parameters are the expressions used in the assertion
+// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
+// where foo is 5 and bar is 6, we have:
+//
+//   expected_expression: "foo"
+//   actual_expression:   "bar"
+//   expected_value:      "5"
+//   actual_value:        "6"
+//
+// The ignoring_case parameter is true if and only if the assertion is a
+// *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
+// be inserted into the message.
+GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
+                                     const char* actual_expression,
+                                     const std::string& expected_value,
+                                     const std::string& actual_value,
+                                     bool ignoring_case);
+
+// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
+GTEST_API_ std::string GetBoolAssertionFailureMessage(
+    const AssertionResult& assertion_result,
+    const char* expression_text,
+    const char* actual_predicate_value,
+    const char* expected_predicate_value);
+
+// This template class represents an IEEE floating-point number
+// (either single-precision or double-precision, depending on the
+// template parameters).
+//
+// The purpose of this class is to do more sophisticated number
+// comparison.  (Due to round-off error, etc, it's very unlikely that
+// two floating-points will be equal exactly.  Hence a naive
+// comparison by the == operation often doesn't work.)
+//
+// Format of IEEE floating-point:
+//
+//   The most-significant bit being the leftmost, an IEEE
+//   floating-point looks like
+//
+//     sign_bit exponent_bits fraction_bits
+//
+//   Here, sign_bit is a single bit that designates the sign of the
+//   number.
+//
+//   For float, there are 8 exponent bits and 23 fraction bits.
+//
+//   For double, there are 11 exponent bits and 52 fraction bits.
+//
+//   More details can be found at
+//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
+//
+// Template parameter:
+//
+//   RawType: the raw floating-point type (either float or double)
+template <typename RawType>
+class FloatingPoint {
+ public:
+  // Defines the unsigned integer type that has the same size as the
+  // floating point number.
+  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;
+
+  // Constants.
+
+  // # of bits in a number.
+  static const size_t kBitCount = 8*sizeof(RawType);
+
+  // # of fraction bits in a number.
+  static const size_t kFractionBitCount =
+    std::numeric_limits<RawType>::digits - 1;
+
+  // # of exponent bits in a number.
+  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
+
+  // The mask for the sign bit.
+  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
+
+  // The mask for the fraction bits.
+  static const Bits kFractionBitMask =
+    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
+
+  // The mask for the exponent bits.
+  static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
+
+  // How many ULP's (Units in the Last Place) we want to tolerate when
+  // comparing two numbers.  The larger the value, the more error we
+  // allow.  A 0 value means that two numbers must be exactly the same
+  // to be considered equal.
+  //
+  // The maximum error of a single floating-point operation is 0.5
+  // units in the last place.  On Intel CPU's, all floating-point
+  // calculations are done with 80-bit precision, while double has 64
+  // bits.  Therefore, 4 should be enough for ordinary use.
+  //
+  // See the following article for more details on ULP:
+  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+  static const uint32_t kMaxUlps = 4;
+
+  // Constructs a FloatingPoint from a raw floating-point number.
+  //
+  // On an Intel CPU, passing a non-normalized NAN (Not a Number)
+  // around may change its bits, although the new value is guaranteed
+  // to be also a NAN.  Therefore, don't expect this constructor to
+  // preserve the bits in x when x is a NAN.
+  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }
+
+  // Static methods
+
+  // Reinterprets a bit pattern as a floating-point number.
+  //
+  // This function is needed to test the AlmostEquals() method.
+  static RawType ReinterpretBits(const Bits bits) {
+    FloatingPoint fp(0);
+    fp.u_.bits_ = bits;
+    return fp.u_.value_;
+  }
+
+  // Returns the floating-point number that represent positive infinity.
+  static RawType Infinity() {
+    return ReinterpretBits(kExponentBitMask);
+  }
+
+  // Returns the maximum representable finite floating-point number.
+  static RawType Max();
+
+  // Non-static methods
+
+  // Returns the bits that represents this number.
+  const Bits &bits() const { return u_.bits_; }
+
+  // Returns the exponent bits of this number.
+  Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
+
+  // Returns the fraction bits of this number.
+  Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }
+
+  // Returns the sign bit of this number.
+  Bits sign_bit() const { return kSignBitMask & u_.bits_; }
+
+  // Returns true if and only if this is NAN (not a number).
+  bool is_nan() const {
+    // It's a NAN if the exponent bits are all ones and the fraction
+    // bits are not entirely zeros.
+    return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
+  }
+
+  // Returns true if and only if this number is at most kMaxUlps ULP's away
+  // from rhs.  In particular, this function:
+  //
+  //   - returns false if either number is (or both are) NAN.
+  //   - treats really large numbers as almost equal to infinity.
+  //   - thinks +0.0 and -0.0 are 0 DLP's apart.
+  bool AlmostEquals(const FloatingPoint& rhs) const {
+    // The IEEE standard says that any comparison operation involving
+    // a NAN must return false.
+    if (is_nan() || rhs.is_nan()) return false;
+
+    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
+        <= kMaxUlps;
+  }
+
+ private:
+  // The data type used to store the actual floating-point number.
+  union FloatingPointUnion {
+    RawType value_;  // The raw floating-point number.
+    Bits bits_;      // The bits that represent the number.
+  };
+
+  // Converts an integer from the sign-and-magnitude representation to
+  // the biased representation.  More precisely, let N be 2 to the
+  // power of (kBitCount - 1), an integer x is represented by the
+  // unsigned number x + N.
+  //
+  // For instance,
+  //
+  //   -N + 1 (the most negative number representable using
+  //          sign-and-magnitude) is represented by 1;
+  //   0      is represented by N; and
+  //   N - 1  (the biggest number representable using
+  //          sign-and-magnitude) is represented by 2N - 1.
+  //
+  // Read http://en.wikipedia.org/wiki/Signed_number_representations
+  // for more details on signed number representations.
+  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
+    if (kSignBitMask & sam) {
+      // sam represents a negative number.
+      return ~sam + 1;
+    } else {
+      // sam represents a positive number.
+      return kSignBitMask | sam;
+    }
+  }
+
+  // Given two numbers in the sign-and-magnitude representation,
+  // returns the distance between them as an unsigned number.
+  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
+                                                     const Bits &sam2) {
+    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
+    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
+    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
+  }
+
+  FloatingPointUnion u_;
+};
+
+// We cannot use std::numeric_limits<T>::max() as it clashes with the max()
+// macro defined by <windows.h>.
+template <>
+inline float FloatingPoint<float>::Max() { return FLT_MAX; }
+template <>
+inline double FloatingPoint<double>::Max() { return DBL_MAX; }
+
+// Typedefs the instances of the FloatingPoint template class that we
+// care to use.
+typedef FloatingPoint<float> Float;
+typedef FloatingPoint<double> Double;
+
+// In order to catch the mistake of putting tests that use different
+// test fixture classes in the same test suite, we need to assign
+// unique IDs to fixture classes and compare them.  The TypeId type is
+// used to hold such IDs.  The user should treat TypeId as an opaque
+// type: the only operation allowed on TypeId values is to compare
+// them for equality using the == operator.
+typedef const void* TypeId;
+
+template <typename T>
+class TypeIdHelper {
+ public:
+  // dummy_ must not have a const type.  Otherwise an overly eager
+  // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
+  // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
+  static bool dummy_;
+};
+
+template <typename T>
+bool TypeIdHelper<T>::dummy_ = false;
+
+// GetTypeId<T>() returns the ID of type T.  Different values will be
+// returned for different types.  Calling the function twice with the
+// same type argument is guaranteed to return the same ID.
+template <typename T>
+TypeId GetTypeId() {
+  // The compiler is required to allocate a different
+  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
+  // the template.  Therefore, the address of dummy_ is guaranteed to
+  // be unique.
+  return &(TypeIdHelper<T>::dummy_);
+}
+
+// Returns the type ID of ::testing::Test.  Always call this instead
+// of GetTypeId< ::testing::Test>() to get the type ID of
+// ::testing::Test, as the latter may give the wrong result due to a
+// suspected linker bug when compiling Google Test as a Mac OS X
+// framework.
+GTEST_API_ TypeId GetTestTypeId();
+
+// Defines the abstract factory interface that creates instances
+// of a Test object.
+class TestFactoryBase {
+ public:
+  virtual ~TestFactoryBase() {}
+
+  // Creates a test instance to run. The instance is both created and destroyed
+  // within TestInfoImpl::Run()
+  virtual Test* CreateTest() = 0;
+
+ protected:
+  TestFactoryBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
+};
+
+// This class provides implementation of TeastFactoryBase interface.
+// It is used in TEST and TEST_F macros.
+template <class TestClass>
+class TestFactoryImpl : public TestFactoryBase {
+ public:
+  Test* CreateTest() override { return new TestClass; }
+};
+
+#if GTEST_OS_WINDOWS
+
+// Predicate-formatters for implementing the HRESULT checking macros
+// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
+// We pass a long instead of HRESULT to avoid causing an
+// include dependency for the HRESULT type.
+GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr,
+                                            long hr);  // NOLINT
+GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
+                                            long hr);  // NOLINT
+
+#endif  // GTEST_OS_WINDOWS
+
+// Types of SetUpTestSuite() and TearDownTestSuite() functions.
+using SetUpTestSuiteFunc = void (*)();
+using TearDownTestSuiteFunc = void (*)();
+
+struct CodeLocation {
+  CodeLocation(const std::string& a_file, int a_line)
+      : file(a_file), line(a_line) {}
+
+  std::string file;
+  int line;
+};
+
+//  Helper to identify which setup function for TestCase / TestSuite to call.
+//  Only one function is allowed, either TestCase or TestSute but not both.
+
+// Utility functions to help SuiteApiResolver
+using SetUpTearDownSuiteFuncType = void (*)();
+
+inline SetUpTearDownSuiteFuncType GetNotDefaultOrNull(
+    SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def) {
+  return a == def ? nullptr : a;
+}
+
+template <typename T>
+//  Note that SuiteApiResolver inherits from T because
+//  SetUpTestSuite()/TearDownTestSuite() could be protected. Ths way
+//  SuiteApiResolver can access them.
+struct SuiteApiResolver : T {
+  // testing::Test is only forward declared at this point. So we make it a
+  // dependend class for the compiler to be OK with it.
+  using Test =
+      typename std::conditional<sizeof(T) != 0, ::testing::Test, void>::type;
+
+  static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
+                                                        int line_num) {
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+    SetUpTearDownSuiteFuncType test_case_fp =
+        GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
+    SetUpTearDownSuiteFuncType test_suite_fp =
+        GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);
+
+    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
+        << "Test can not provide both SetUpTestSuite and SetUpTestCase, please "
+           "make sure there is only one present at "
+        << filename << ":" << line_num;
+
+    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
+#else
+    (void)(filename);
+    (void)(line_num);
+    return &T::SetUpTestSuite;
+#endif
+  }
+
+  static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
+                                                           int line_num) {
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+    SetUpTearDownSuiteFuncType test_case_fp =
+        GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
+    SetUpTearDownSuiteFuncType test_suite_fp =
+        GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);
+
+    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
+        << "Test can not provide both TearDownTestSuite and TearDownTestCase,"
+           " please make sure there is only one present at"
+        << filename << ":" << line_num;
+
+    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
+#else
+    (void)(filename);
+    (void)(line_num);
+    return &T::TearDownTestSuite;
+#endif
+  }
+};
+
+// Creates a new TestInfo object and registers it with Google Test;
+// returns the created object.
+//
+// Arguments:
+//
+//   test_suite_name:  name of the test suite
+//   name:             name of the test
+//   type_param:       the name of the test's type parameter, or NULL if
+//                     this is not a typed or a type-parameterized test.
+//   value_param:      text representation of the test's value parameter,
+//                     or NULL if this is not a type-parameterized test.
+//   code_location:    code location where the test is defined
+//   fixture_class_id: ID of the test fixture class
+//   set_up_tc:        pointer to the function that sets up the test suite
+//   tear_down_tc:     pointer to the function that tears down the test suite
+//   factory:          pointer to the factory that creates a test object.
+//                     The newly created TestInfo instance will assume
+//                     ownership of the factory object.
+GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
+    const char* test_suite_name, const char* name, const char* type_param,
+    const char* value_param, CodeLocation code_location,
+    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
+    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory);
+
+// If *pstr starts with the given prefix, modifies *pstr to be right
+// past the prefix and returns true; otherwise leaves *pstr unchanged
+// and returns false.  None of pstr, *pstr, and prefix can be NULL.
+GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr);
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+// State of the definition of a type-parameterized test suite.
+class GTEST_API_ TypedTestSuitePState {
+ public:
+  TypedTestSuitePState() : registered_(false) {}
+
+  // Adds the given test name to defined_test_names_ and return true
+  // if the test suite hasn't been registered; otherwise aborts the
+  // program.
+  bool AddTestName(const char* file, int line, const char* case_name,
+                   const char* test_name) {
+    if (registered_) {
+      fprintf(stderr,
+              "%s Test %s must be defined before "
+              "REGISTER_TYPED_TEST_SUITE_P(%s, ...).\n",
+              FormatFileLocation(file, line).c_str(), test_name, case_name);
+      fflush(stderr);
+      posix::Abort();
+    }
+    registered_tests_.insert(
+        ::std::make_pair(test_name, CodeLocation(file, line)));
+    return true;
+  }
+
+  bool TestExists(const std::string& test_name) const {
+    return registered_tests_.count(test_name) > 0;
+  }
+
+  const CodeLocation& GetCodeLocation(const std::string& test_name) const {
+    RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name);
+    GTEST_CHECK_(it != registered_tests_.end());
+    return it->second;
+  }
+
+  // Verifies that registered_tests match the test names in
+  // defined_test_names_; returns registered_tests if successful, or
+  // aborts the program otherwise.
+  const char* VerifyRegisteredTestNames(const char* test_suite_name,
+                                        const char* file, int line,
+                                        const char* registered_tests);
+
+ private:
+  typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap;
+
+  bool registered_;
+  RegisteredTestsMap registered_tests_;
+};
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+using TypedTestCasePState = TypedTestSuitePState;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// Skips to the first non-space char after the first comma in 'str';
+// returns NULL if no comma is found in 'str'.
+inline const char* SkipComma(const char* str) {
+  const char* comma = strchr(str, ',');
+  if (comma == nullptr) {
+    return nullptr;
+  }
+  while (IsSpace(*(++comma))) {}
+  return comma;
+}
+
+// Returns the prefix of 'str' before the first comma in it; returns
+// the entire string if it contains no comma.
+inline std::string GetPrefixUntilComma(const char* str) {
+  const char* comma = strchr(str, ',');
+  return comma == nullptr ? str : std::string(str, comma);
+}
+
+// Splits a given string on a given delimiter, populating a given
+// vector with the fields.
+void SplitString(const ::std::string& str, char delimiter,
+                 ::std::vector< ::std::string>* dest);
+
+// The default argument to the template below for the case when the user does
+// not provide a name generator.
+struct DefaultNameGenerator {
+  template <typename T>
+  static std::string GetName(int i) {
+    return StreamableToString(i);
+  }
+};
+
+template <typename Provided = DefaultNameGenerator>
+struct NameGeneratorSelector {
+  typedef Provided type;
+};
+
+template <typename NameGenerator>
+void GenerateNamesRecursively(internal::None, std::vector<std::string>*, int) {}
+
+template <typename NameGenerator, typename Types>
+void GenerateNamesRecursively(Types, std::vector<std::string>* result, int i) {
+  result->push_back(NameGenerator::template GetName<typename Types::Head>(i));
+  GenerateNamesRecursively<NameGenerator>(typename Types::Tail(), result,
+                                          i + 1);
+}
+
+template <typename NameGenerator, typename Types>
+std::vector<std::string> GenerateNames() {
+  std::vector<std::string> result;
+  GenerateNamesRecursively<NameGenerator>(Types(), &result, 0);
+  return result;
+}
+
+// TypeParameterizedTest<Fixture, TestSel, Types>::Register()
+// registers a list of type-parameterized tests with Google Test.  The
+// return value is insignificant - we just need to return something
+// such that we can call this function in a namespace scope.
+//
+// Implementation note: The GTEST_TEMPLATE_ macro declares a template
+// template parameter.  It's defined in gtest-type-util.h.
+template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
+class TypeParameterizedTest {
+ public:
+  // 'index' is the index of the test in the type list 'Types'
+  // specified in INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, TestSuite,
+  // Types).  Valid values for 'index' are [0, N - 1] where N is the
+  // length of Types.
+  static bool Register(const char* prefix, const CodeLocation& code_location,
+                       const char* case_name, const char* test_names, int index,
+                       const std::vector<std::string>& type_names =
+                           GenerateNames<DefaultNameGenerator, Types>()) {
+    typedef typename Types::Head Type;
+    typedef Fixture<Type> FixtureClass;
+    typedef typename GTEST_BIND_(TestSel, Type) TestClass;
+
+    // First, registers the first type-parameterized test in the type
+    // list.
+    MakeAndRegisterTestInfo(
+        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name +
+         "/" + type_names[static_cast<size_t>(index)])
+            .c_str(),
+        StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
+        GetTypeName<Type>().c_str(),
+        nullptr,  // No value parameter.
+        code_location, GetTypeId<FixtureClass>(),
+        SuiteApiResolver<TestClass>::GetSetUpCaseOrSuite(
+            code_location.file.c_str(), code_location.line),
+        SuiteApiResolver<TestClass>::GetTearDownCaseOrSuite(
+            code_location.file.c_str(), code_location.line),
+        new TestFactoryImpl<TestClass>);
+
+    // Next, recurses (at compile time) with the tail of the type list.
+    return TypeParameterizedTest<Fixture, TestSel,
+                                 typename Types::Tail>::Register(prefix,
+                                                                 code_location,
+                                                                 case_name,
+                                                                 test_names,
+                                                                 index + 1,
+                                                                 type_names);
+  }
+};
+
+// The base case for the compile time recursion.
+template <GTEST_TEMPLATE_ Fixture, class TestSel>
+class TypeParameterizedTest<Fixture, TestSel, internal::None> {
+ public:
+  static bool Register(const char* /*prefix*/, const CodeLocation&,
+                       const char* /*case_name*/, const char* /*test_names*/,
+                       int /*index*/,
+                       const std::vector<std::string>& =
+                           std::vector<std::string>() /*type_names*/) {
+    return true;
+  }
+};
+
+GTEST_API_ void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
+                                                   CodeLocation code_location);
+GTEST_API_ void RegisterTypeParameterizedTestSuiteInstantiation(
+    const char* case_name);
+
+// TypeParameterizedTestSuite<Fixture, Tests, Types>::Register()
+// registers *all combinations* of 'Tests' and 'Types' with Google
+// Test.  The return value is insignificant - we just need to return
+// something such that we can call this function in a namespace scope.
+template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
+class TypeParameterizedTestSuite {
+ public:
+  static bool Register(const char* prefix, CodeLocation code_location,
+                       const TypedTestSuitePState* state, const char* case_name,
+                       const char* test_names,
+                       const std::vector<std::string>& type_names =
+                           GenerateNames<DefaultNameGenerator, Types>()) {
+    RegisterTypeParameterizedTestSuiteInstantiation(case_name);
+    std::string test_name = StripTrailingSpaces(
+        GetPrefixUntilComma(test_names));
+    if (!state->TestExists(test_name)) {
+      fprintf(stderr, "Failed to get code location for test %s.%s at %s.",
+              case_name, test_name.c_str(),
+              FormatFileLocation(code_location.file.c_str(),
+                                 code_location.line).c_str());
+      fflush(stderr);
+      posix::Abort();
+    }
+    const CodeLocation& test_location = state->GetCodeLocation(test_name);
+
+    typedef typename Tests::Head Head;
+
+    // First, register the first test in 'Test' for each type in 'Types'.
+    TypeParameterizedTest<Fixture, Head, Types>::Register(
+        prefix, test_location, case_name, test_names, 0, type_names);
+
+    // Next, recurses (at compile time) with the tail of the test list.
+    return TypeParameterizedTestSuite<Fixture, typename Tests::Tail,
+                                      Types>::Register(prefix, code_location,
+                                                       state, case_name,
+                                                       SkipComma(test_names),
+                                                       type_names);
+  }
+};
+
+// The base case for the compile time recursion.
+template <GTEST_TEMPLATE_ Fixture, typename Types>
+class TypeParameterizedTestSuite<Fixture, internal::None, Types> {
+ public:
+  static bool Register(const char* /*prefix*/, const CodeLocation&,
+                       const TypedTestSuitePState* /*state*/,
+                       const char* /*case_name*/, const char* /*test_names*/,
+                       const std::vector<std::string>& =
+                           std::vector<std::string>() /*type_names*/) {
+    return true;
+  }
+};
+
+// Returns the current OS stack trace as an std::string.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
+// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
+GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
+    UnitTest* unit_test, int skip_count);
+
+// Helpers for suppressing warnings on unreachable code or constant
+// condition.
+
+// Always returns true.
+GTEST_API_ bool AlwaysTrue();
+
+// Always returns false.
+inline bool AlwaysFalse() { return !AlwaysTrue(); }
+
+// Helper for suppressing false warning from Clang on a const char*
+// variable declared in a conditional expression always being NULL in
+// the else branch.
+struct GTEST_API_ ConstCharPtr {
+  ConstCharPtr(const char* str) : value(str) {}
+  operator bool() const { return true; }
+  const char* value;
+};
+
+// Helper for declaring std::string within 'if' statement
+// in pre C++17 build environment.
+struct TrueWithString {
+  TrueWithString() = default;
+  explicit TrueWithString(const char* str) : value(str) {}
+  explicit TrueWithString(const std::string& str) : value(str) {}
+  explicit operator bool() const { return true; }
+  std::string value;
+};
+
+// A simple Linear Congruential Generator for generating random
+// numbers with a uniform distribution.  Unlike rand() and srand(), it
+// doesn't use global state (and therefore can't interfere with user
+// code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
+// but it's good enough for our purposes.
+class GTEST_API_ Random {
+ public:
+  static const uint32_t kMaxRange = 1u << 31;
+
+  explicit Random(uint32_t seed) : state_(seed) {}
+
+  void Reseed(uint32_t seed) { state_ = seed; }
+
+  // Generates a random number from [0, range).  Crashes if 'range' is
+  // 0 or greater than kMaxRange.
+  uint32_t Generate(uint32_t range);
+
+ private:
+  uint32_t state_;
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
+};
+
+// Turns const U&, U&, const U, and U all into U.
+#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
+  typename std::remove_const<typename std::remove_reference<T>::type>::type
+
+// HasDebugStringAndShortDebugString<T>::value is a compile-time bool constant
+// that's true if and only if T has methods DebugString() and ShortDebugString()
+// that return std::string.
+template <typename T>
+class HasDebugStringAndShortDebugString {
+ private:
+  template <typename C>
+  static auto CheckDebugString(C*) -> typename std::is_same<
+      std::string, decltype(std::declval<const C>().DebugString())>::type;
+  template <typename>
+  static std::false_type CheckDebugString(...);
+
+  template <typename C>
+  static auto CheckShortDebugString(C*) -> typename std::is_same<
+      std::string, decltype(std::declval<const C>().ShortDebugString())>::type;
+  template <typename>
+  static std::false_type CheckShortDebugString(...);
+
+  using HasDebugStringType = decltype(CheckDebugString<T>(nullptr));
+  using HasShortDebugStringType = decltype(CheckShortDebugString<T>(nullptr));
+
+ public:
+  static constexpr bool value =
+      HasDebugStringType::value && HasShortDebugStringType::value;
+};
+
+template <typename T>
+constexpr bool HasDebugStringAndShortDebugString<T>::value;
+
+// When the compiler sees expression IsContainerTest<C>(0), if C is an
+// STL-style container class, the first overload of IsContainerTest
+// will be viable (since both C::iterator* and C::const_iterator* are
+// valid types and NULL can be implicitly converted to them).  It will
+// be picked over the second overload as 'int' is a perfect match for
+// the type of argument 0.  If C::iterator or C::const_iterator is not
+// a valid type, the first overload is not viable, and the second
+// overload will be picked.  Therefore, we can determine whether C is
+// a container class by checking the type of IsContainerTest<C>(0).
+// The value of the expression is insignificant.
+//
+// In C++11 mode we check the existence of a const_iterator and that an
+// iterator is properly implemented for the container.
+//
+// For pre-C++11 that we look for both C::iterator and C::const_iterator.
+// The reason is that C++ injects the name of a class as a member of the
+// class itself (e.g. you can refer to class iterator as either
+// 'iterator' or 'iterator::iterator').  If we look for C::iterator
+// only, for example, we would mistakenly think that a class named
+// iterator is an STL container.
+//
+// Also note that the simpler approach of overloading
+// IsContainerTest(typename C::const_iterator*) and
+// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
+typedef int IsContainer;
+template <class C,
+          class Iterator = decltype(::std::declval<const C&>().begin()),
+          class = decltype(::std::declval<const C&>().end()),
+          class = decltype(++::std::declval<Iterator&>()),
+          class = decltype(*::std::declval<Iterator>()),
+          class = typename C::const_iterator>
+IsContainer IsContainerTest(int /* dummy */) {
+  return 0;
+}
+
+typedef char IsNotContainer;
+template <class C>
+IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
+
+// Trait to detect whether a type T is a hash table.
+// The heuristic used is that the type contains an inner type `hasher` and does
+// not contain an inner type `reverse_iterator`.
+// If the container is iterable in reverse, then order might actually matter.
+template <typename T>
+struct IsHashTable {
+ private:
+  template <typename U>
+  static char test(typename U::hasher*, typename U::reverse_iterator*);
+  template <typename U>
+  static int test(typename U::hasher*, ...);
+  template <typename U>
+  static char test(...);
+
+ public:
+  static const bool value = sizeof(test<T>(nullptr, nullptr)) == sizeof(int);
+};
+
+template <typename T>
+const bool IsHashTable<T>::value;
+
+template <typename C,
+          bool = sizeof(IsContainerTest<C>(0)) == sizeof(IsContainer)>
+struct IsRecursiveContainerImpl;
+
+template <typename C>
+struct IsRecursiveContainerImpl<C, false> : public std::false_type {};
+
+// Since the IsRecursiveContainerImpl depends on the IsContainerTest we need to
+// obey the same inconsistencies as the IsContainerTest, namely check if
+// something is a container is relying on only const_iterator in C++11 and
+// is relying on both const_iterator and iterator otherwise
+template <typename C>
+struct IsRecursiveContainerImpl<C, true> {
+  using value_type = decltype(*std::declval<typename C::const_iterator>());
+  using type =
+      std::is_same<typename std::remove_const<
+                       typename std::remove_reference<value_type>::type>::type,
+                   C>;
+};
+
+// IsRecursiveContainer<Type> is a unary compile-time predicate that
+// evaluates whether C is a recursive container type. A recursive container
+// type is a container type whose value_type is equal to the container type
+// itself. An example for a recursive container type is
+// boost::filesystem::path, whose iterator has a value_type that is equal to
+// boost::filesystem::path.
+template <typename C>
+struct IsRecursiveContainer : public IsRecursiveContainerImpl<C>::type {};
+
+// Utilities for native arrays.
+
+// ArrayEq() compares two k-dimensional native arrays using the
+// elements' operator==, where k can be any integer >= 0.  When k is
+// 0, ArrayEq() degenerates into comparing a single pair of values.
+
+template <typename T, typename U>
+bool ArrayEq(const T* lhs, size_t size, const U* rhs);
+
+// This generic version is used when k is 0.
+template <typename T, typename U>
+inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
+
+// This overload is used when k >= 1.
+template <typename T, typename U, size_t N>
+inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
+  return internal::ArrayEq(lhs, N, rhs);
+}
+
+// This helper reduces code bloat.  If we instead put its logic inside
+// the previous ArrayEq() function, arrays with different sizes would
+// lead to different copies of the template code.
+template <typename T, typename U>
+bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
+  for (size_t i = 0; i != size; i++) {
+    if (!internal::ArrayEq(lhs[i], rhs[i]))
+      return false;
+  }
+  return true;
+}
+
+// Finds the first element in the iterator range [begin, end) that
+// equals elem.  Element may be a native array type itself.
+template <typename Iter, typename Element>
+Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
+  for (Iter it = begin; it != end; ++it) {
+    if (internal::ArrayEq(*it, elem))
+      return it;
+  }
+  return end;
+}
+
+// CopyArray() copies a k-dimensional native array using the elements'
+// operator=, where k can be any integer >= 0.  When k is 0,
+// CopyArray() degenerates into copying a single value.
+
+template <typename T, typename U>
+void CopyArray(const T* from, size_t size, U* to);
+
+// This generic version is used when k is 0.
+template <typename T, typename U>
+inline void CopyArray(const T& from, U* to) { *to = from; }
+
+// This overload is used when k >= 1.
+template <typename T, typename U, size_t N>
+inline void CopyArray(const T(&from)[N], U(*to)[N]) {
+  internal::CopyArray(from, N, *to);
+}
+
+// This helper reduces code bloat.  If we instead put its logic inside
+// the previous CopyArray() function, arrays with different sizes
+// would lead to different copies of the template code.
+template <typename T, typename U>
+void CopyArray(const T* from, size_t size, U* to) {
+  for (size_t i = 0; i != size; i++) {
+    internal::CopyArray(from[i], to + i);
+  }
+}
+
+// The relation between an NativeArray object (see below) and the
+// native array it represents.
+// We use 2 different structs to allow non-copyable types to be used, as long
+// as RelationToSourceReference() is passed.
+struct RelationToSourceReference {};
+struct RelationToSourceCopy {};
+
+// Adapts a native array to a read-only STL-style container.  Instead
+// of the complete STL container concept, this adaptor only implements
+// members useful for Google Mock's container matchers.  New members
+// should be added as needed.  To simplify the implementation, we only
+// support Element being a raw type (i.e. having no top-level const or
+// reference modifier).  It's the client's responsibility to satisfy
+// this requirement.  Element can be an array type itself (hence
+// multi-dimensional arrays are supported).
+template <typename Element>
+class NativeArray {
+ public:
+  // STL-style container typedefs.
+  typedef Element value_type;
+  typedef Element* iterator;
+  typedef const Element* const_iterator;
+
+  // Constructs from a native array. References the source.
+  NativeArray(const Element* array, size_t count, RelationToSourceReference) {
+    InitRef(array, count);
+  }
+
+  // Constructs from a native array. Copies the source.
+  NativeArray(const Element* array, size_t count, RelationToSourceCopy) {
+    InitCopy(array, count);
+  }
+
+  // Copy constructor.
+  NativeArray(const NativeArray& rhs) {
+    (this->*rhs.clone_)(rhs.array_, rhs.size_);
+  }
+
+  ~NativeArray() {
+    if (clone_ != &NativeArray::InitRef)
+      delete[] array_;
+  }
+
+  // STL-style container methods.
+  size_t size() const { return size_; }
+  const_iterator begin() const { return array_; }
+  const_iterator end() const { return array_ + size_; }
+  bool operator==(const NativeArray& rhs) const {
+    return size() == rhs.size() &&
+        ArrayEq(begin(), size(), rhs.begin());
+  }
+
+ private:
+  static_assert(!std::is_const<Element>::value, "Type must not be const");
+  static_assert(!std::is_reference<Element>::value,
+                "Type must not be a reference");
+
+  // Initializes this object with a copy of the input.
+  void InitCopy(const Element* array, size_t a_size) {
+    Element* const copy = new Element[a_size];
+    CopyArray(array, a_size, copy);
+    array_ = copy;
+    size_ = a_size;
+    clone_ = &NativeArray::InitCopy;
+  }
+
+  // Initializes this object with a reference of the input.
+  void InitRef(const Element* array, size_t a_size) {
+    array_ = array;
+    size_ = a_size;
+    clone_ = &NativeArray::InitRef;
+  }
+
+  const Element* array_;
+  size_t size_;
+  void (NativeArray::*clone_)(const Element*, size_t);
+};
+
+// Backport of std::index_sequence.
+template <size_t... Is>
+struct IndexSequence {
+  using type = IndexSequence;
+};
+
+// Double the IndexSequence, and one if plus_one is true.
+template <bool plus_one, typename T, size_t sizeofT>
+struct DoubleSequence;
+template <size_t... I, size_t sizeofT>
+struct DoubleSequence<true, IndexSequence<I...>, sizeofT> {
+  using type = IndexSequence<I..., (sizeofT + I)..., 2 * sizeofT>;
+};
+template <size_t... I, size_t sizeofT>
+struct DoubleSequence<false, IndexSequence<I...>, sizeofT> {
+  using type = IndexSequence<I..., (sizeofT + I)...>;
+};
+
+// Backport of std::make_index_sequence.
+// It uses O(ln(N)) instantiation depth.
+template <size_t N>
+struct MakeIndexSequenceImpl
+    : DoubleSequence<N % 2 == 1, typename MakeIndexSequenceImpl<N / 2>::type,
+                     N / 2>::type {};
+
+template <>
+struct MakeIndexSequenceImpl<0> : IndexSequence<> {};
+
+template <size_t N>
+using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::type;
+
+template <typename... T>
+using IndexSequenceFor = typename MakeIndexSequence<sizeof...(T)>::type;
+
+template <size_t>
+struct Ignore {
+  Ignore(...);  // NOLINT
+};
+
+template <typename>
+struct ElemFromListImpl;
+template <size_t... I>
+struct ElemFromListImpl<IndexSequence<I...>> {
+  // We make Ignore a template to solve a problem with MSVC.
+  // A non-template Ignore would work fine with `decltype(Ignore(I))...`, but
+  // MSVC doesn't understand how to deal with that pack expansion.
+  // Use `0 * I` to have a single instantiation of Ignore.
+  template <typename R>
+  static R Apply(Ignore<0 * I>..., R (*)(), ...);
+};
+
+template <size_t N, typename... T>
+struct ElemFromList {
+  using type =
+      decltype(ElemFromListImpl<typename MakeIndexSequence<N>::type>::Apply(
+          static_cast<T (*)()>(nullptr)...));
+};
+
+struct FlatTupleConstructTag {};
+
+template <typename... T>
+class FlatTuple;
+
+template <typename Derived, size_t I>
+struct FlatTupleElemBase;
+
+template <typename... T, size_t I>
+struct FlatTupleElemBase<FlatTuple<T...>, I> {
+  using value_type = typename ElemFromList<I, T...>::type;
+  FlatTupleElemBase() = default;
+  template <typename Arg>
+  explicit FlatTupleElemBase(FlatTupleConstructTag, Arg&& t)
+      : value(std::forward<Arg>(t)) {}
+  value_type value;
+};
+
+template <typename Derived, typename Idx>
+struct FlatTupleBase;
+
+template <size_t... Idx, typename... T>
+struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>>
+    : FlatTupleElemBase<FlatTuple<T...>, Idx>... {
+  using Indices = IndexSequence<Idx...>;
+  FlatTupleBase() = default;
+  template <typename... Args>
+  explicit FlatTupleBase(FlatTupleConstructTag, Args&&... args)
+      : FlatTupleElemBase<FlatTuple<T...>, Idx>(FlatTupleConstructTag{},
+                                                std::forward<Args>(args))... {}
+
+  template <size_t I>
+  const typename ElemFromList<I, T...>::type& Get() const {
+    return FlatTupleElemBase<FlatTuple<T...>, I>::value;
+  }
+
+  template <size_t I>
+  typename ElemFromList<I, T...>::type& Get() {
+    return FlatTupleElemBase<FlatTuple<T...>, I>::value;
+  }
+
+  template <typename F>
+  auto Apply(F&& f) -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
+    return std::forward<F>(f)(Get<Idx>()...);
+  }
+
+  template <typename F>
+  auto Apply(F&& f) const -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
+    return std::forward<F>(f)(Get<Idx>()...);
+  }
+};
+
+// Analog to std::tuple but with different tradeoffs.
+// This class minimizes the template instantiation depth, thus allowing more
+// elements than std::tuple would. std::tuple has been seen to require an
+// instantiation depth of more than 10x the number of elements in some
+// implementations.
+// FlatTuple and ElemFromList are not recursive and have a fixed depth
+// regardless of T...
+// MakeIndexSequence, on the other hand, it is recursive but with an
+// instantiation depth of O(ln(N)).
+template <typename... T>
+class FlatTuple
+    : private FlatTupleBase<FlatTuple<T...>,
+                            typename MakeIndexSequence<sizeof...(T)>::type> {
+  using Indices = typename FlatTupleBase<
+      FlatTuple<T...>, typename MakeIndexSequence<sizeof...(T)>::type>::Indices;
+
+ public:
+  FlatTuple() = default;
+  template <typename... Args>
+  explicit FlatTuple(FlatTupleConstructTag tag, Args&&... args)
+      : FlatTuple::FlatTupleBase(tag, std::forward<Args>(args)...) {}
+
+  using FlatTuple::FlatTupleBase::Apply;
+  using FlatTuple::FlatTupleBase::Get;
+};
+
+// Utility functions to be called with static_assert to induce deprecation
+// warnings.
+GTEST_INTERNAL_DEPRECATED(
+    "INSTANTIATE_TEST_CASE_P is deprecated, please use "
+    "INSTANTIATE_TEST_SUITE_P")
+constexpr bool InstantiateTestCase_P_IsDeprecated() { return true; }
+
+GTEST_INTERNAL_DEPRECATED(
+    "TYPED_TEST_CASE_P is deprecated, please use "
+    "TYPED_TEST_SUITE_P")
+constexpr bool TypedTestCase_P_IsDeprecated() { return true; }
+
+GTEST_INTERNAL_DEPRECATED(
+    "TYPED_TEST_CASE is deprecated, please use "
+    "TYPED_TEST_SUITE")
+constexpr bool TypedTestCaseIsDeprecated() { return true; }
+
+GTEST_INTERNAL_DEPRECATED(
+    "REGISTER_TYPED_TEST_CASE_P is deprecated, please use "
+    "REGISTER_TYPED_TEST_SUITE_P")
+constexpr bool RegisterTypedTestCase_P_IsDeprecated() { return true; }
+
+GTEST_INTERNAL_DEPRECATED(
+    "INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use "
+    "INSTANTIATE_TYPED_TEST_SUITE_P")
+constexpr bool InstantiateTypedTestCase_P_IsDeprecated() { return true; }
+
+}  // namespace internal
+}  // namespace testing
+
+namespace std {
+// Some standard library implementations use `struct tuple_size` and some use
+// `class tuple_size`. Clang warns about the mismatch.
+// https://reviews.llvm.org/D55466
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+template <typename... Ts>
+struct tuple_size<testing::internal::FlatTuple<Ts...>>
+    : std::integral_constant<size_t, sizeof...(Ts)> {};
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+}  // namespace std
+
+#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
+  ::testing::internal::AssertHelper(result_type, file, line, message) \
+    = ::testing::Message()
+
+#define GTEST_MESSAGE_(message, result_type) \
+  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
+
+#define GTEST_FATAL_FAILURE_(message) \
+  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
+
+#define GTEST_NONFATAL_FAILURE_(message) \
+  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
+
+#define GTEST_SUCCESS_(message) \
+  GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
+
+#define GTEST_SKIP_(message) \
+  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSkip)
+
+// Suppress MSVC warning 4072 (unreachable code) for the code following
+// statement if it returns or throws (or doesn't return or throw in some
+// situations).
+// NOTE: The "else" is important to keep this expansion to prevent a top-level
+// "else" from attaching to our "if".
+#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
+  if (::testing::internal::AlwaysTrue()) {                        \
+    statement;                                                    \
+  } else                     /* NOLINT */                         \
+    static_assert(true, "")  // User must have a semicolon after expansion.
+
+#if GTEST_HAS_EXCEPTIONS
+
+namespace testing {
+namespace internal {
+
+class NeverThrown {
+ public:
+  const char* what() const noexcept {
+    return "this exception should never be thrown";
+  }
+};
+
+}  // namespace internal
+}  // namespace testing
+
+#if GTEST_HAS_RTTI
+
+#define GTEST_EXCEPTION_TYPE_(e) ::testing::internal::GetTypeName(typeid(e))
+
+#else  // GTEST_HAS_RTTI
+
+#define GTEST_EXCEPTION_TYPE_(e) \
+  std::string { "an std::exception-derived error" }
+
+#endif  // GTEST_HAS_RTTI
+
+#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)   \
+  catch (typename std::conditional<                                            \
+         std::is_same<typename std::remove_cv<typename std::remove_reference<  \
+                          expected_exception>::type>::type,                    \
+                      std::exception>::value,                                  \
+         const ::testing::internal::NeverThrown&, const std::exception&>::type \
+             e) {                                                              \
+    gtest_msg.value = "Expected: " #statement                                  \
+                      " throws an exception of type " #expected_exception      \
+                      ".\n  Actual: it throws ";                               \
+    gtest_msg.value += GTEST_EXCEPTION_TYPE_(e);                               \
+    gtest_msg.value += " with description \"";                                 \
+    gtest_msg.value += e.what();                                               \
+    gtest_msg.value += "\".";                                                  \
+    goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);                \
+  }
+
+#else  // GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_THROW_(statement, expected_exception, fail)              \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                             \
+  if (::testing::internal::TrueWithString gtest_msg{}) {                    \
+    bool gtest_caught_expected = false;                                     \
+    try {                                                                   \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);            \
+    } catch (expected_exception const&) {                                   \
+      gtest_caught_expected = true;                                         \
+    }                                                                       \
+    GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)    \
+    catch (...) {                                                           \
+      gtest_msg.value = "Expected: " #statement                             \
+                        " throws an exception of type " #expected_exception \
+                        ".\n  Actual: it throws a different type.";         \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);           \
+    }                                                                       \
+    if (!gtest_caught_expected) {                                           \
+      gtest_msg.value = "Expected: " #statement                             \
+                        " throws an exception of type " #expected_exception \
+                        ".\n  Actual: it throws nothing.";                  \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);           \
+    }                                                                       \
+  } else /*NOLINT*/                                                         \
+    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__)                   \
+        : fail(gtest_msg.value.c_str())
+
+#if GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()                \
+  catch (std::exception const& e) {                               \
+    gtest_msg.value = "it throws ";                               \
+    gtest_msg.value += GTEST_EXCEPTION_TYPE_(e);                  \
+    gtest_msg.value += " with description \"";                    \
+    gtest_msg.value += e.what();                                  \
+    gtest_msg.value += "\".";                                     \
+    goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
+  }
+
+#else  // GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_NO_THROW_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::TrueWithString gtest_msg{}) { \
+    try { \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    } \
+    GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \
+    catch (...) { \
+      gtest_msg.value = "it throws."; \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
+      fail(("Expected: " #statement " doesn't throw an exception.\n" \
+            "  Actual: " + gtest_msg.value).c_str())
+
+#define GTEST_TEST_ANY_THROW_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    bool gtest_caught_any = false; \
+    try { \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    } \
+    catch (...) { \
+      gtest_caught_any = true; \
+    } \
+    if (!gtest_caught_any) { \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
+      fail("Expected: " #statement " throws an exception.\n" \
+           "  Actual: it doesn't.")
+
+
+// Implements Boolean test assertions such as EXPECT_TRUE. expression can be
+// either a boolean expression or an AssertionResult. text is a textual
+// representation of expression as it was passed into the EXPECT_TRUE.
+#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (const ::testing::AssertionResult gtest_ar_ = \
+      ::testing::AssertionResult(expression)) \
+    ; \
+  else \
+    fail(::testing::internal::GetBoolAssertionFailureMessage(\
+        gtest_ar_, text, #actual, #expected).c_str())
+
+#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
+      fail("Expected: " #statement " doesn't generate new fatal " \
+           "failures in the current thread.\n" \
+           "  Actual: it does.")
+
+// Expands to the name of the class that implements the given test.
+#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
+  test_suite_name##_##test_name##_Test
+
+// Helper macro for defining tests.
+#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)      \
+  static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1,                \
+                "test_suite_name must not be empty");                         \
+  static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1,                      \
+                "test_name must not be empty");                               \
+  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                    \
+      : public parent_class {                                                 \
+   public:                                                                    \
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default;           \
+    ~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default; \
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
+                                                           test_name));       \
+    GTEST_DISALLOW_MOVE_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
+                                                           test_name));       \
+                                                                              \
+   private:                                                                   \
+    void TestBody() override;                                                 \
+    static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;     \
+  };                                                                          \
+                                                                              \
+  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,          \
+                                                    test_name)::test_info_ =  \
+      ::testing::internal::MakeAndRegisterTestInfo(                           \
+          #test_suite_name, #test_name, nullptr, nullptr,                     \
+          ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \
+          ::testing::internal::SuiteApiResolver<                              \
+              parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__),         \
+          ::testing::internal::SuiteApiResolver<                              \
+              parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__),      \
+          new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_(    \
+              test_suite_name, test_name)>);                                  \
+  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines the public API for death tests.  It is
+// #included by gtest.h so a user doesn't need to include this
+// directly.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+
+// Copyright 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines internal utilities needed for implementing
+// death tests.  They are subject to change without notice.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This file implements just enough of the matcher interface to allow
+// EXPECT_DEATH and friends to accept a matcher argument.
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
+
+#include <atomic>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <type_traits>
+
+// Copyright 2007, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Google Test - The Google C++ Testing and Mocking Framework
+//
+// This file implements a universal value printer that can print a
+// value of any type T:
+//
+//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
+//
+// A user can teach this function how to print a class type T by
+// defining either operator<<() or PrintTo() in the namespace that
+// defines T.  More specifically, the FIRST defined function in the
+// following list will be used (assuming T is defined in namespace
+// foo):
+//
+//   1. foo::PrintTo(const T&, ostream*)
+//   2. operator<<(ostream&, const T&) defined in either foo or the
+//      global namespace.
+//
+// However if T is an STL-style container then it is printed element-wise
+// unless foo::PrintTo(const T&, ostream*) is defined. Note that
+// operator<<() is ignored for container types.
+//
+// If none of the above is defined, it will print the debug string of
+// the value if it is a protocol buffer, or print the raw bytes in the
+// value otherwise.
+//
+// To aid debugging: when T is a reference type, the address of the
+// value is also printed; when T is a (const) char pointer, both the
+// pointer value and the NUL-terminated string it points to are
+// printed.
+//
+// We also provide some convenient wrappers:
+//
+//   // Prints a value to a string.  For a (const or not) char
+//   // pointer, the NUL-terminated string (but not the pointer) is
+//   // printed.
+//   std::string ::testing::PrintToString(const T& value);
+//
+//   // Prints a value tersely: for a reference type, the referenced
+//   // value (but not the address) is printed; for a (const or not) char
+//   // pointer, the NUL-terminated string (but not the pointer) is
+//   // printed.
+//   void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
+//
+//   // Prints value using the type inferred by the compiler.  The difference
+//   // from UniversalTersePrint() is that this function prints both the
+//   // pointer and the NUL-terminated string for a (const or not) char pointer.
+//   void ::testing::internal::UniversalPrint(const T& value, ostream*);
+//
+//   // Prints the fields of a tuple tersely to a string vector, one
+//   // element for each field. Tuple support must be enabled in
+//   // gtest-port.h.
+//   std::vector<string> UniversalTersePrintTupleFieldsToStrings(
+//       const Tuple& value);
+//
+// Known limitation:
+//
+// The print primitives print the elements of an STL-style container
+// using the compiler-inferred type of *iter where iter is a
+// const_iterator of the container.  When const_iterator is an input
+// iterator but not a forward iterator, this inferred type may not
+// match value_type, and the print output may be incorrect.  In
+// practice, this is rarely a problem as for most containers
+// const_iterator is a forward iterator.  We'll fix this if there's an
+// actual need for it.  Note that this fix cannot rely on value_type
+// being defined as many user-defined container types don't have
+// value_type.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+
+#include <functional>
+#include <memory>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+
+#if GTEST_HAS_RTTI
+#include <typeindex>
+#include <typeinfo>
+#endif  // GTEST_HAS_RTTI
+
+namespace testing {
+
+// Definitions in the internal* namespaces are subject to change without notice.
+// DO NOT USE THEM IN USER CODE!
+namespace internal {
+
+template <typename T>
+void UniversalPrint(const T& value, ::std::ostream* os);
+
+// Used to print an STL-style container when the user doesn't define
+// a PrintTo() for it.
+struct ContainerPrinter {
+  template <typename T,
+            typename = typename std::enable_if<
+                (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
+                !IsRecursiveContainer<T>::value>::type>
+  static void PrintValue(const T& container, std::ostream* os) {
+    const size_t kMaxCount = 32;  // The maximum number of elements to print.
+    *os << '{';
+    size_t count = 0;
+    for (auto&& elem : container) {
+      if (count > 0) {
+        *os << ',';
+        if (count == kMaxCount) {  // Enough has been printed.
+          *os << " ...";
+          break;
+        }
+      }
+      *os << ' ';
+      // We cannot call PrintTo(elem, os) here as PrintTo() doesn't
+      // handle `elem` being a native array.
+      internal::UniversalPrint(elem, os);
+      ++count;
+    }
+
+    if (count > 0) {
+      *os << ' ';
+    }
+    *os << '}';
+  }
+};
+
+// Used to print a pointer that is neither a char pointer nor a member
+// pointer, when the user doesn't define PrintTo() for it.  (A member
+// variable pointer or member function pointer doesn't really point to
+// a location in the address space.  Their representation is
+// implementation-defined.  Therefore they will be printed as raw
+// bytes.)
+struct FunctionPointerPrinter {
+  template <typename T, typename = typename std::enable_if<
+                            std::is_function<T>::value>::type>
+  static void PrintValue(T* p, ::std::ostream* os) {
+    if (p == nullptr) {
+      *os << "NULL";
+    } else {
+      // T is a function type, so '*os << p' doesn't do what we want
+      // (it just prints p as bool).  We want to print p as a const
+      // void*.
+      *os << reinterpret_cast<const void*>(p);
+    }
+  }
+};
+
+struct PointerPrinter {
+  template <typename T>
+  static void PrintValue(T* p, ::std::ostream* os) {
+    if (p == nullptr) {
+      *os << "NULL";
+    } else {
+      // T is not a function type.  We just call << to print p,
+      // relying on ADL to pick up user-defined << for their pointer
+      // types, if any.
+      *os << p;
+    }
+  }
+};
+
+namespace internal_stream_operator_without_lexical_name_lookup {
+
+// The presence of an operator<< here will terminate lexical scope lookup
+// straight away (even though it cannot be a match because of its argument
+// types). Thus, the two operator<< calls in StreamPrinter will find only ADL
+// candidates.
+struct LookupBlocker {};
+void operator<<(LookupBlocker, LookupBlocker);
+
+struct StreamPrinter {
+  template <typename T,
+            // Don't accept member pointers here. We'd print them via implicit
+            // conversion to bool, which isn't useful.
+            typename = typename std::enable_if<
+                !std::is_member_pointer<T>::value>::type,
+            // Only accept types for which we can find a streaming operator via
+            // ADL (possibly involving implicit conversions).
+            typename = decltype(std::declval<std::ostream&>()
+                                << std::declval<const T&>())>
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    // Call streaming operator found by ADL, possibly with implicit conversions
+    // of the arguments.
+    *os << value;
+  }
+};
+
+}  // namespace internal_stream_operator_without_lexical_name_lookup
+
+struct ProtobufPrinter {
+  // We print a protobuf using its ShortDebugString() when the string
+  // doesn't exceed this many characters; otherwise we print it using
+  // DebugString() for better readability.
+  static const size_t kProtobufOneLinerMaxLength = 50;
+
+  template <typename T,
+            typename = typename std::enable_if<
+                internal::HasDebugStringAndShortDebugString<T>::value>::type>
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    std::string pretty_str = value.ShortDebugString();
+    if (pretty_str.length() > kProtobufOneLinerMaxLength) {
+      pretty_str = "\n" + value.DebugString();
+    }
+    *os << ("<" + pretty_str + ">");
+  }
+};
+
+struct ConvertibleToIntegerPrinter {
+  // Since T has no << operator or PrintTo() but can be implicitly
+  // converted to BiggestInt, we print it as a BiggestInt.
+  //
+  // Most likely T is an enum type (either named or unnamed), in which
+  // case printing it as an integer is the desired behavior.  In case
+  // T is not an enum, printing it as an integer is the best we can do
+  // given that it has no user-defined printer.
+  static void PrintValue(internal::BiggestInt value, ::std::ostream* os) {
+    *os << value;
+  }
+};
+
+struct ConvertibleToStringViewPrinter {
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  static void PrintValue(internal::StringView value, ::std::ostream* os) {
+    internal::UniversalPrint(value, os);
+  }
+#endif
+};
+
+
+// Prints the given number of bytes in the given object to the given
+// ostream.
+GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
+                                     size_t count,
+                                     ::std::ostream* os);
+struct RawBytesPrinter {
+  // SFINAE on `sizeof` to make sure we have a complete type.
+  template <typename T, size_t = sizeof(T)>
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    PrintBytesInObjectTo(
+        static_cast<const unsigned char*>(
+            // Load bearing cast to void* to support iOS
+            reinterpret_cast<const void*>(std::addressof(value))),
+        sizeof(value), os);
+  }
+};
+
+struct FallbackPrinter {
+  template <typename T>
+  static void PrintValue(const T&, ::std::ostream* os) {
+    *os << "(incomplete type)";
+  }
+};
+
+// Try every printer in order and return the first one that works.
+template <typename T, typename E, typename Printer, typename... Printers>
+struct FindFirstPrinter : FindFirstPrinter<T, E, Printers...> {};
+
+template <typename T, typename Printer, typename... Printers>
+struct FindFirstPrinter<
+    T, decltype(Printer::PrintValue(std::declval<const T&>(), nullptr)),
+    Printer, Printers...> {
+  using type = Printer;
+};
+
+// Select the best printer in the following order:
+//  - Print containers (they have begin/end/etc).
+//  - Print function pointers.
+//  - Print object pointers.
+//  - Use the stream operator, if available.
+//  - Print protocol buffers.
+//  - Print types convertible to BiggestInt.
+//  - Print types convertible to StringView, if available.
+//  - Fallback to printing the raw bytes of the object.
+template <typename T>
+void PrintWithFallback(const T& value, ::std::ostream* os) {
+  using Printer = typename FindFirstPrinter<
+      T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter,
+      internal_stream_operator_without_lexical_name_lookup::StreamPrinter,
+      ProtobufPrinter, ConvertibleToIntegerPrinter,
+      ConvertibleToStringViewPrinter, RawBytesPrinter, FallbackPrinter>::type;
+  Printer::PrintValue(value, os);
+}
+
+// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
+// value of type ToPrint that is an operand of a comparison assertion
+// (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
+// the comparison, and is used to help determine the best way to
+// format the value.  In particular, when the value is a C string
+// (char pointer) and the other operand is an STL string object, we
+// want to format the C string as a string, since we know it is
+// compared by value with the string object.  If the value is a char
+// pointer but the other operand is not an STL string object, we don't
+// know whether the pointer is supposed to point to a NUL-terminated
+// string, and thus want to print it as a pointer to be safe.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+// The default case.
+template <typename ToPrint, typename OtherOperand>
+class FormatForComparison {
+ public:
+  static ::std::string Format(const ToPrint& value) {
+    return ::testing::PrintToString(value);
+  }
+};
+
+// Array.
+template <typename ToPrint, size_t N, typename OtherOperand>
+class FormatForComparison<ToPrint[N], OtherOperand> {
+ public:
+  static ::std::string Format(const ToPrint* value) {
+    return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
+  }
+};
+
+// By default, print C string as pointers to be safe, as we don't know
+// whether they actually point to a NUL-terminated string.
+
+#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
+  template <typename OtherOperand>                                      \
+  class FormatForComparison<CharType*, OtherOperand> {                  \
+   public:                                                              \
+    static ::std::string Format(CharType* value) {                      \
+      return ::testing::PrintToString(static_cast<const void*>(value)); \
+    }                                                                   \
+  }
+
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
+#ifdef __cpp_char8_t
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char8_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char8_t);
+#endif
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char16_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char16_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char32_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char32_t);
+
+#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
+
+// If a C string is compared with an STL string object, we know it's meant
+// to point to a NUL-terminated string, and thus can print it as a string.
+
+#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
+  template <>                                                           \
+  class FormatForComparison<CharType*, OtherStringType> {               \
+   public:                                                              \
+    static ::std::string Format(CharType* value) {                      \
+      return ::testing::PrintToString(value);                           \
+    }                                                                   \
+  }
+
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
+#ifdef __cpp_char8_t
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char8_t, ::std::u8string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char8_t, ::std::u8string);
+#endif
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char16_t, ::std::u16string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char16_t, ::std::u16string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char32_t, ::std::u32string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char32_t, ::std::u32string);
+
+#if GTEST_HAS_STD_WSTRING
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
+#endif
+
+#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
+
+// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
+// operand to be used in a failure message.  The type (but not value)
+// of the other operand may affect the format.  This allows us to
+// print a char* as a raw pointer when it is compared against another
+// char* or void*, and print it as a C string when it is compared
+// against an std::string object, for example.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+template <typename T1, typename T2>
+std::string FormatForComparisonFailureMessage(
+    const T1& value, const T2& /* other_operand */) {
+  return FormatForComparison<T1, T2>::Format(value);
+}
+
+// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
+// value to the given ostream.  The caller must ensure that
+// 'ostream_ptr' is not NULL, or the behavior is undefined.
+//
+// We define UniversalPrinter as a class template (as opposed to a
+// function template), as we need to partially specialize it for
+// reference types, which cannot be done with function templates.
+template <typename T>
+class UniversalPrinter;
+
+// Prints the given value using the << operator if it has one;
+// otherwise prints the bytes in it.  This is what
+// UniversalPrinter<T>::Print() does when PrintTo() is not specialized
+// or overloaded for type T.
+//
+// A user can override this behavior for a class type Foo by defining
+// an overload of PrintTo() in the namespace where Foo is defined.  We
+// give the user this option as sometimes defining a << operator for
+// Foo is not desirable (e.g. the coding style may prevent doing it,
+// or there is already a << operator but it doesn't do what the user
+// wants).
+template <typename T>
+void PrintTo(const T& value, ::std::ostream* os) {
+  internal::PrintWithFallback(value, os);
+}
+
+// The following list of PrintTo() overloads tells
+// UniversalPrinter<T>::Print() how to print standard types (built-in
+// types, strings, plain arrays, and pointers).
+
+// Overloads for various char types.
+GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
+GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
+inline void PrintTo(char c, ::std::ostream* os) {
+  // When printing a plain char, we always treat it as unsigned.  This
+  // way, the output won't be affected by whether the compiler thinks
+  // char is signed or not.
+  PrintTo(static_cast<unsigned char>(c), os);
+}
+
+// Overloads for other simple built-in types.
+inline void PrintTo(bool x, ::std::ostream* os) {
+  *os << (x ? "true" : "false");
+}
+
+// Overload for wchar_t type.
+// Prints a wchar_t as a symbol if it is printable or as its internal
+// code otherwise and also as its decimal code (except for L'\0').
+// The L'\0' char is printed as "L'\\0'". The decimal code is printed
+// as signed integer when wchar_t is implemented by the compiler
+// as a signed type and is printed as an unsigned integer when wchar_t
+// is implemented as an unsigned type.
+GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
+
+GTEST_API_ void PrintTo(char32_t c, ::std::ostream* os);
+inline void PrintTo(char16_t c, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<char32_t>(c), os);
+}
+#ifdef __cpp_char8_t
+inline void PrintTo(char8_t c, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<char32_t>(c), os);
+}
+#endif
+
+// Overloads for C strings.
+GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
+inline void PrintTo(char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char*>(s), os);
+}
+
+// signed/unsigned char is often used for representing binary data, so
+// we print pointers to it as void* to be safe.
+inline void PrintTo(const signed char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(signed char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(unsigned char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+#ifdef __cpp_char8_t
+// Overloads for u8 strings.
+void PrintTo(const char8_t* s, ::std::ostream* os);
+inline void PrintTo(char8_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char8_t*>(s), os);
+}
+#endif
+// Overloads for u16 strings.
+void PrintTo(const char16_t* s, ::std::ostream* os);
+inline void PrintTo(char16_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char16_t*>(s), os);
+}
+// Overloads for u32 strings.
+void PrintTo(const char32_t* s, ::std::ostream* os);
+inline void PrintTo(char32_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char32_t*>(s), os);
+}
+
+// MSVC can be configured to define wchar_t as a typedef of unsigned
+// short.  It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
+// type.  When wchar_t is a typedef, defining an overload for const
+// wchar_t* would cause unsigned short* be printed as a wide string,
+// possibly causing invalid memory accesses.
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+// Overloads for wide C strings
+GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
+inline void PrintTo(wchar_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const wchar_t*>(s), os);
+}
+#endif
+
+// Overload for C arrays.  Multi-dimensional arrays are printed
+// properly.
+
+// Prints the given number of elements in an array, without printing
+// the curly braces.
+template <typename T>
+void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
+  UniversalPrint(a[0], os);
+  for (size_t i = 1; i != count; i++) {
+    *os << ", ";
+    UniversalPrint(a[i], os);
+  }
+}
+
+// Overloads for ::std::string.
+GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
+inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
+  PrintStringTo(s, os);
+}
+
+// Overloads for ::std::u8string
+#ifdef __cpp_char8_t
+GTEST_API_ void PrintU8StringTo(const ::std::u8string& s, ::std::ostream* os);
+inline void PrintTo(const ::std::u8string& s, ::std::ostream* os) {
+  PrintU8StringTo(s, os);
+}
+#endif
+
+// Overloads for ::std::u16string
+GTEST_API_ void PrintU16StringTo(const ::std::u16string& s, ::std::ostream* os);
+inline void PrintTo(const ::std::u16string& s, ::std::ostream* os) {
+  PrintU16StringTo(s, os);
+}
+
+// Overloads for ::std::u32string
+GTEST_API_ void PrintU32StringTo(const ::std::u32string& s, ::std::ostream* os);
+inline void PrintTo(const ::std::u32string& s, ::std::ostream* os) {
+  PrintU32StringTo(s, os);
+}
+
+// Overloads for ::std::wstring.
+#if GTEST_HAS_STD_WSTRING
+GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
+inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
+  PrintWideStringTo(s, os);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+// Overload for internal::StringView.
+inline void PrintTo(internal::StringView sp, ::std::ostream* os) {
+  PrintTo(::std::string(sp), os);
+}
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }
+
+template <typename T>
+void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) {
+  UniversalPrinter<T&>::Print(ref.get(), os);
+}
+
+inline const void* VoidifyPointer(const void* p) { return p; }
+inline const void* VoidifyPointer(volatile const void* p) {
+  return const_cast<const void*>(p);
+}
+
+template <typename T, typename Ptr>
+void PrintSmartPointer(const Ptr& ptr, std::ostream* os, char) {
+  if (ptr == nullptr) {
+    *os << "(nullptr)";
+  } else {
+    // We can't print the value. Just print the pointer..
+    *os << "(" << (VoidifyPointer)(ptr.get()) << ")";
+  }
+}
+template <typename T, typename Ptr,
+          typename = typename std::enable_if<!std::is_void<T>::value &&
+                                             !std::is_array<T>::value>::type>
+void PrintSmartPointer(const Ptr& ptr, std::ostream* os, int) {
+  if (ptr == nullptr) {
+    *os << "(nullptr)";
+  } else {
+    *os << "(ptr = " << (VoidifyPointer)(ptr.get()) << ", value = ";
+    UniversalPrinter<T>::Print(*ptr, os);
+    *os << ")";
+  }
+}
+
+template <typename T, typename D>
+void PrintTo(const std::unique_ptr<T, D>& ptr, std::ostream* os) {
+  (PrintSmartPointer<T>)(ptr, os, 0);
+}
+
+template <typename T>
+void PrintTo(const std::shared_ptr<T>& ptr, std::ostream* os) {
+  (PrintSmartPointer<T>)(ptr, os, 0);
+}
+
+// Helper function for printing a tuple.  T must be instantiated with
+// a tuple type.
+template <typename T>
+void PrintTupleTo(const T&, std::integral_constant<size_t, 0>,
+                  ::std::ostream*) {}
+
+template <typename T, size_t I>
+void PrintTupleTo(const T& t, std::integral_constant<size_t, I>,
+                  ::std::ostream* os) {
+  PrintTupleTo(t, std::integral_constant<size_t, I - 1>(), os);
+  GTEST_INTENTIONAL_CONST_COND_PUSH_()
+  if (I > 1) {
+    GTEST_INTENTIONAL_CONST_COND_POP_()
+    *os << ", ";
+  }
+  UniversalPrinter<typename std::tuple_element<I - 1, T>::type>::Print(
+      std::get<I - 1>(t), os);
+}
+
+template <typename... Types>
+void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) {
+  *os << "(";
+  PrintTupleTo(t, std::integral_constant<size_t, sizeof...(Types)>(), os);
+  *os << ")";
+}
+
+// Overload for std::pair.
+template <typename T1, typename T2>
+void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
+  *os << '(';
+  // We cannot use UniversalPrint(value.first, os) here, as T1 may be
+  // a reference type.  The same for printing value.second.
+  UniversalPrinter<T1>::Print(value.first, os);
+  *os << ", ";
+  UniversalPrinter<T2>::Print(value.second, os);
+  *os << ')';
+}
+
+#if GTEST_HAS_RTTI
+inline void PrintTo(const ::std::type_info& value, ::std::ostream* os) {
+  internal::PrintTo<::std::type_info>(value, os);
+  *os << " (\"" << value.name() << "\")";
+}
+
+inline void PrintTo(const ::std::type_index& value, ::std::ostream* os) {
+  internal::PrintTo<::std::type_index>(value, os);
+  *os << " (\"" << value.name() << "\")";
+}
+#endif  // GTEST_HAS_RTTI
+
+// Implements printing a non-reference type T by letting the compiler
+// pick the right overload of PrintTo() for T.
+template <typename T>
+class UniversalPrinter {
+ public:
+  // MSVC warns about adding const to a function type, so we want to
+  // disable the warning.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
+
+  // Note: we deliberately don't call this PrintTo(), as that name
+  // conflicts with ::testing::internal::PrintTo in the body of the
+  // function.
+  static void Print(const T& value, ::std::ostream* os) {
+    // By default, ::testing::internal::PrintTo() is used for printing
+    // the value.
+    //
+    // Thanks to Koenig look-up, if T is a class and has its own
+    // PrintTo() function defined in its namespace, that function will
+    // be visible here.  Since it is more specific than the generic ones
+    // in ::testing::internal, it will be picked by the compiler in the
+    // following statement - exactly what we want.
+    PrintTo(value, os);
+  }
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+};
+
+// Remove any const-qualifiers before passing a type to UniversalPrinter.
+template <typename T>
+class UniversalPrinter<const T> : public UniversalPrinter<T> {};
+
+#if GTEST_INTERNAL_HAS_ANY
+
+// Printer for std::any / absl::any
+
+template <>
+class UniversalPrinter<Any> {
+ public:
+  static void Print(const Any& value, ::std::ostream* os) {
+    if (value.has_value()) {
+      *os << "value of type " << GetTypeName(value);
+    } else {
+      *os << "no value";
+    }
+  }
+
+ private:
+  static std::string GetTypeName(const Any& value) {
+#if GTEST_HAS_RTTI
+    return internal::GetTypeName(value.type());
+#else
+    static_cast<void>(value);  // possibly unused
+    return "<unknown_type>";
+#endif  // GTEST_HAS_RTTI
+  }
+};
+
+#endif  // GTEST_INTERNAL_HAS_ANY
+
+#if GTEST_INTERNAL_HAS_OPTIONAL
+
+// Printer for std::optional / absl::optional
+
+template <typename T>
+class UniversalPrinter<Optional<T>> {
+ public:
+  static void Print(const Optional<T>& value, ::std::ostream* os) {
+    *os << '(';
+    if (!value) {
+      *os << "nullopt";
+    } else {
+      UniversalPrint(*value, os);
+    }
+    *os << ')';
+  }
+};
+
+#endif  // GTEST_INTERNAL_HAS_OPTIONAL
+
+#if GTEST_INTERNAL_HAS_VARIANT
+
+// Printer for std::variant / absl::variant
+
+template <typename... T>
+class UniversalPrinter<Variant<T...>> {
+ public:
+  static void Print(const Variant<T...>& value, ::std::ostream* os) {
+    *os << '(';
+#if GTEST_HAS_ABSL
+    absl::visit(Visitor{os, value.index()}, value);
+#else
+    std::visit(Visitor{os, value.index()}, value);
+#endif  // GTEST_HAS_ABSL
+    *os << ')';
+  }
+
+ private:
+  struct Visitor {
+    template <typename U>
+    void operator()(const U& u) const {
+      *os << "'" << GetTypeName<U>() << "(index = " << index
+          << ")' with value ";
+      UniversalPrint(u, os);
+    }
+    ::std::ostream* os;
+    std::size_t index;
+  };
+};
+
+#endif  // GTEST_INTERNAL_HAS_VARIANT
+
+// UniversalPrintArray(begin, len, os) prints an array of 'len'
+// elements, starting at address 'begin'.
+template <typename T>
+void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
+  if (len == 0) {
+    *os << "{}";
+  } else {
+    *os << "{ ";
+    const size_t kThreshold = 18;
+    const size_t kChunkSize = 8;
+    // If the array has more than kThreshold elements, we'll have to
+    // omit some details by printing only the first and the last
+    // kChunkSize elements.
+    if (len <= kThreshold) {
+      PrintRawArrayTo(begin, len, os);
+    } else {
+      PrintRawArrayTo(begin, kChunkSize, os);
+      *os << ", ..., ";
+      PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
+    }
+    *os << " }";
+  }
+}
+// This overload prints a (const) char array compactly.
+GTEST_API_ void UniversalPrintArray(
+    const char* begin, size_t len, ::std::ostream* os);
+
+#ifdef __cpp_char8_t
+// This overload prints a (const) char8_t array compactly.
+GTEST_API_ void UniversalPrintArray(const char8_t* begin, size_t len,
+                                    ::std::ostream* os);
+#endif
+
+// This overload prints a (const) char16_t array compactly.
+GTEST_API_ void UniversalPrintArray(const char16_t* begin, size_t len,
+                                    ::std::ostream* os);
+
+// This overload prints a (const) char32_t array compactly.
+GTEST_API_ void UniversalPrintArray(const char32_t* begin, size_t len,
+                                    ::std::ostream* os);
+
+// This overload prints a (const) wchar_t array compactly.
+GTEST_API_ void UniversalPrintArray(
+    const wchar_t* begin, size_t len, ::std::ostream* os);
+
+// Implements printing an array type T[N].
+template <typename T, size_t N>
+class UniversalPrinter<T[N]> {
+ public:
+  // Prints the given array, omitting some elements when there are too
+  // many.
+  static void Print(const T (&a)[N], ::std::ostream* os) {
+    UniversalPrintArray(a, N, os);
+  }
+};
+
+// Implements printing a reference type T&.
+template <typename T>
+class UniversalPrinter<T&> {
+ public:
+  // MSVC warns about adding const to a function type, so we want to
+  // disable the warning.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
+
+  static void Print(const T& value, ::std::ostream* os) {
+    // Prints the address of the value.  We use reinterpret_cast here
+    // as static_cast doesn't compile when T is a function type.
+    *os << "@" << reinterpret_cast<const void*>(&value) << " ";
+
+    // Then prints the value itself.
+    UniversalPrint(value, os);
+  }
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+};
+
+// Prints a value tersely: for a reference type, the referenced value
+// (but not the address) is printed; for a (const) char pointer, the
+// NUL-terminated string (but not the pointer) is printed.
+
+template <typename T>
+class UniversalTersePrinter {
+ public:
+  static void Print(const T& value, ::std::ostream* os) {
+    UniversalPrint(value, os);
+  }
+};
+template <typename T>
+class UniversalTersePrinter<T&> {
+ public:
+  static void Print(const T& value, ::std::ostream* os) {
+    UniversalPrint(value, os);
+  }
+};
+template <typename T, size_t N>
+class UniversalTersePrinter<T[N]> {
+ public:
+  static void Print(const T (&value)[N], ::std::ostream* os) {
+    UniversalPrinter<T[N]>::Print(value, os);
+  }
+};
+template <>
+class UniversalTersePrinter<const char*> {
+ public:
+  static void Print(const char* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(std::string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char*> : public UniversalTersePrinter<const char*> {
+};
+
+#ifdef __cpp_char8_t
+template <>
+class UniversalTersePrinter<const char8_t*> {
+ public:
+  static void Print(const char8_t* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::u8string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char8_t*>
+    : public UniversalTersePrinter<const char8_t*> {};
+#endif
+
+template <>
+class UniversalTersePrinter<const char16_t*> {
+ public:
+  static void Print(const char16_t* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::u16string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char16_t*>
+    : public UniversalTersePrinter<const char16_t*> {};
+
+template <>
+class UniversalTersePrinter<const char32_t*> {
+ public:
+  static void Print(const char32_t* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::u32string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char32_t*>
+    : public UniversalTersePrinter<const char32_t*> {};
+
+#if GTEST_HAS_STD_WSTRING
+template <>
+class UniversalTersePrinter<const wchar_t*> {
+ public:
+  static void Print(const wchar_t* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::wstring(str), os);
+    }
+  }
+};
+#endif
+
+template <>
+class UniversalTersePrinter<wchar_t*> {
+ public:
+  static void Print(wchar_t* str, ::std::ostream* os) {
+    UniversalTersePrinter<const wchar_t*>::Print(str, os);
+  }
+};
+
+template <typename T>
+void UniversalTersePrint(const T& value, ::std::ostream* os) {
+  UniversalTersePrinter<T>::Print(value, os);
+}
+
+// Prints a value using the type inferred by the compiler.  The
+// difference between this and UniversalTersePrint() is that for a
+// (const) char pointer, this prints both the pointer and the
+// NUL-terminated string.
+template <typename T>
+void UniversalPrint(const T& value, ::std::ostream* os) {
+  // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
+  // UniversalPrinter with T directly.
+  typedef T T1;
+  UniversalPrinter<T1>::Print(value, os);
+}
+
+typedef ::std::vector< ::std::string> Strings;
+
+  // Tersely prints the first N fields of a tuple to a string vector,
+  // one element for each field.
+template <typename Tuple>
+void TersePrintPrefixToStrings(const Tuple&, std::integral_constant<size_t, 0>,
+                               Strings*) {}
+template <typename Tuple, size_t I>
+void TersePrintPrefixToStrings(const Tuple& t,
+                               std::integral_constant<size_t, I>,
+                               Strings* strings) {
+  TersePrintPrefixToStrings(t, std::integral_constant<size_t, I - 1>(),
+                            strings);
+  ::std::stringstream ss;
+  UniversalTersePrint(std::get<I - 1>(t), &ss);
+  strings->push_back(ss.str());
+}
+
+// Prints the fields of a tuple tersely to a string vector, one
+// element for each field.  See the comment before
+// UniversalTersePrint() for how we define "tersely".
+template <typename Tuple>
+Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
+  Strings result;
+  TersePrintPrefixToStrings(
+      value, std::integral_constant<size_t, std::tuple_size<Tuple>::value>(),
+      &result);
+  return result;
+}
+
+}  // namespace internal
+
+template <typename T>
+::std::string PrintToString(const T& value) {
+  ::std::stringstream ss;
+  internal::UniversalTersePrinter<T>::Print(value, &ss);
+  return ss.str();
+}
+
+}  // namespace testing
+
+// Include any custom printer added by the local installation.
+// We must include this header at the end to make sure it can use the
+// declarations from this file.
+// Copyright 2015, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// This file provides an injection point for custom printers in a local
+// installation of gTest.
+// It will be included from gtest-printers.h and the overrides in this file
+// will be visible to everyone.
+//
+// Injection point for custom user configurations. See README for details
+//
+// ** Custom implementation starts here **
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+
+// MSVC warning C5046 is new as of VS2017 version 15.8.
+#if defined(_MSC_VER) && _MSC_VER >= 1915
+#define GTEST_MAYBE_5046_ 5046
+#else
+#define GTEST_MAYBE_5046_
+#endif
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(
+    4251 GTEST_MAYBE_5046_ /* class A needs to have dll-interface to be used by
+                              clients of class B */
+    /* Symbol involving type with internal linkage not defined */)
+
+namespace testing {
+
+// To implement a matcher Foo for type T, define:
+//   1. a class FooMatcherMatcher that implements the matcher interface:
+//     using is_gtest_matcher = void;
+//     bool MatchAndExplain(const T&, std::ostream*);
+//       (MatchResultListener* can also be used instead of std::ostream*)
+//     void DescribeTo(std::ostream*);
+//     void DescribeNegationTo(std::ostream*);
+//
+//   2. a factory function that creates a Matcher<T> object from a
+//      FooMatcherMatcher.
+
+class MatchResultListener {
+ public:
+  // Creates a listener object with the given underlying ostream.  The
+  // listener does not own the ostream, and does not dereference it
+  // in the constructor or destructor.
+  explicit MatchResultListener(::std::ostream* os) : stream_(os) {}
+  virtual ~MatchResultListener() = 0;  // Makes this class abstract.
+
+  // Streams x to the underlying ostream; does nothing if the ostream
+  // is NULL.
+  template <typename T>
+  MatchResultListener& operator<<(const T& x) {
+    if (stream_ != nullptr) *stream_ << x;
+    return *this;
+  }
+
+  // Returns the underlying ostream.
+  ::std::ostream* stream() { return stream_; }
+
+  // Returns true if and only if the listener is interested in an explanation
+  // of the match result.  A matcher's MatchAndExplain() method can use
+  // this information to avoid generating the explanation when no one
+  // intends to hear it.
+  bool IsInterested() const { return stream_ != nullptr; }
+
+ private:
+  ::std::ostream* const stream_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
+};
+
+inline MatchResultListener::~MatchResultListener() {
+}
+
+// An instance of a subclass of this knows how to describe itself as a
+// matcher.
+class MatcherDescriberInterface {
+ public:
+  virtual ~MatcherDescriberInterface() {}
+
+  // Describes this matcher to an ostream.  The function should print
+  // a verb phrase that describes the property a value matching this
+  // matcher should have.  The subject of the verb phrase is the value
+  // being matched.  For example, the DescribeTo() method of the Gt(7)
+  // matcher prints "is greater than 7".
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+
+  // Describes the negation of this matcher to an ostream.  For
+  // example, if the description of this matcher is "is greater than
+  // 7", the negated description could be "is not greater than 7".
+  // You are not required to override this when implementing
+  // MatcherInterface, but it is highly advised so that your matcher
+  // can produce good error messages.
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "not (";
+    DescribeTo(os);
+    *os << ")";
+  }
+};
+
+// The implementation of a matcher.
+template <typename T>
+class MatcherInterface : public MatcherDescriberInterface {
+ public:
+  // Returns true if and only if the matcher matches x; also explains the
+  // match result to 'listener' if necessary (see the next paragraph), in
+  // the form of a non-restrictive relative clause ("which ...",
+  // "whose ...", etc) that describes x.  For example, the
+  // MatchAndExplain() method of the Pointee(...) matcher should
+  // generate an explanation like "which points to ...".
+  //
+  // Implementations of MatchAndExplain() should add an explanation of
+  // the match result *if and only if* they can provide additional
+  // information that's not already present (or not obvious) in the
+  // print-out of x and the matcher's description.  Whether the match
+  // succeeds is not a factor in deciding whether an explanation is
+  // needed, as sometimes the caller needs to print a failure message
+  // when the match succeeds (e.g. when the matcher is used inside
+  // Not()).
+  //
+  // For example, a "has at least 10 elements" matcher should explain
+  // what the actual element count is, regardless of the match result,
+  // as it is useful information to the reader; on the other hand, an
+  // "is empty" matcher probably only needs to explain what the actual
+  // size is when the match fails, as it's redundant to say that the
+  // size is 0 when the value is already known to be empty.
+  //
+  // You should override this method when defining a new matcher.
+  //
+  // It's the responsibility of the caller (Google Test) to guarantee
+  // that 'listener' is not NULL.  This helps to simplify a matcher's
+  // implementation when it doesn't care about the performance, as it
+  // can talk to 'listener' without checking its validity first.
+  // However, in order to implement dummy listeners efficiently,
+  // listener->stream() may be NULL.
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
+
+  // Inherits these methods from MatcherDescriberInterface:
+  //   virtual void DescribeTo(::std::ostream* os) const = 0;
+  //   virtual void DescribeNegationTo(::std::ostream* os) const;
+};
+
+namespace internal {
+
+struct AnyEq {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a == b; }
+};
+struct AnyNe {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a != b; }
+};
+struct AnyLt {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a < b; }
+};
+struct AnyGt {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a > b; }
+};
+struct AnyLe {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a <= b; }
+};
+struct AnyGe {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a >= b; }
+};
+
+// A match result listener that ignores the explanation.
+class DummyMatchResultListener : public MatchResultListener {
+ public:
+  DummyMatchResultListener() : MatchResultListener(nullptr) {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
+};
+
+// A match result listener that forwards the explanation to a given
+// ostream.  The difference between this and MatchResultListener is
+// that the former is concrete.
+class StreamMatchResultListener : public MatchResultListener {
+ public:
+  explicit StreamMatchResultListener(::std::ostream* os)
+      : MatchResultListener(os) {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
+};
+
+struct SharedPayloadBase {
+  std::atomic<int> ref{1};
+  void Ref() { ref.fetch_add(1, std::memory_order_relaxed); }
+  bool Unref() { return ref.fetch_sub(1, std::memory_order_acq_rel) == 1; }
+};
+
+template <typename T>
+struct SharedPayload : SharedPayloadBase {
+  explicit SharedPayload(const T& v) : value(v) {}
+  explicit SharedPayload(T&& v) : value(std::move(v)) {}
+
+  static void Destroy(SharedPayloadBase* shared) {
+    delete static_cast<SharedPayload*>(shared);
+  }
+
+  T value;
+};
+
+template <typename T>
+using is_trivially_copy_constructible =
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 5
+    std::has_trivial_copy_constructor<T>;
+#else
+    std::is_trivially_copy_constructible<T>;
+#endif
+
+// An internal class for implementing Matcher<T>, which will derive
+// from it.  We put functionalities common to all Matcher<T>
+// specializations here to avoid code duplication.
+template <typename T>
+class MatcherBase : private MatcherDescriberInterface {
+ public:
+  // Returns true if and only if the matcher matches x; also explains the
+  // match result to 'listener'.
+  bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
+    GTEST_CHECK_(vtable_ != nullptr);
+    return vtable_->match_and_explain(*this, x, listener);
+  }
+
+  // Returns true if and only if this matcher matches x.
+  bool Matches(const T& x) const {
+    DummyMatchResultListener dummy;
+    return MatchAndExplain(x, &dummy);
+  }
+
+  // Describes this matcher to an ostream.
+  void DescribeTo(::std::ostream* os) const final {
+    GTEST_CHECK_(vtable_ != nullptr);
+    vtable_->describe(*this, os, false);
+  }
+
+  // Describes the negation of this matcher to an ostream.
+  void DescribeNegationTo(::std::ostream* os) const final {
+    GTEST_CHECK_(vtable_ != nullptr);
+    vtable_->describe(*this, os, true);
+  }
+
+  // Explains why x matches, or doesn't match, the matcher.
+  void ExplainMatchResultTo(const T& x, ::std::ostream* os) const {
+    StreamMatchResultListener listener(os);
+    MatchAndExplain(x, &listener);
+  }
+
+  // Returns the describer for this matcher object; retains ownership
+  // of the describer, which is only guaranteed to be alive when
+  // this matcher object is alive.
+  const MatcherDescriberInterface* GetDescriber() const {
+    if (vtable_ == nullptr) return nullptr;
+    return vtable_->get_describer(*this);
+  }
+
+ protected:
+  MatcherBase() : vtable_(nullptr) {}
+
+  // Constructs a matcher from its implementation.
+  template <typename U>
+  explicit MatcherBase(const MatcherInterface<U>* impl) {
+    Init(impl);
+  }
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  MatcherBase(M&& m) {  // NOLINT
+    Init(std::forward<M>(m));
+  }
+
+  MatcherBase(const MatcherBase& other)
+      : vtable_(other.vtable_), buffer_(other.buffer_) {
+    if (IsShared()) buffer_.shared->Ref();
+  }
+
+  MatcherBase& operator=(const MatcherBase& other) {
+    if (this == &other) return *this;
+    Destroy();
+    vtable_ = other.vtable_;
+    buffer_ = other.buffer_;
+    if (IsShared()) buffer_.shared->Ref();
+    return *this;
+  }
+
+  MatcherBase(MatcherBase&& other)
+      : vtable_(other.vtable_), buffer_(other.buffer_) {
+    other.vtable_ = nullptr;
+  }
+
+  MatcherBase& operator=(MatcherBase&& other) {
+    if (this == &other) return *this;
+    Destroy();
+    vtable_ = other.vtable_;
+    buffer_ = other.buffer_;
+    other.vtable_ = nullptr;
+    return *this;
+  }
+
+  ~MatcherBase() override { Destroy(); }
+
+ private:
+  struct VTable {
+    bool (*match_and_explain)(const MatcherBase&, const T&,
+                              MatchResultListener*);
+    void (*describe)(const MatcherBase&, std::ostream*, bool negation);
+    // Returns the captured object if it implements the interface, otherwise
+    // returns the MatcherBase itself.
+    const MatcherDescriberInterface* (*get_describer)(const MatcherBase&);
+    // Called on shared instances when the reference count reaches 0.
+    void (*shared_destroy)(SharedPayloadBase*);
+  };
+
+  bool IsShared() const {
+    return vtable_ != nullptr && vtable_->shared_destroy != nullptr;
+  }
+
+  // If the implementation uses a listener, call that.
+  template <typename P>
+  static auto MatchAndExplainImpl(const MatcherBase& m, const T& value,
+                                  MatchResultListener* listener)
+      -> decltype(P::Get(m).MatchAndExplain(value, listener->stream())) {
+    return P::Get(m).MatchAndExplain(value, listener->stream());
+  }
+
+  template <typename P>
+  static auto MatchAndExplainImpl(const MatcherBase& m, const T& value,
+                                  MatchResultListener* listener)
+      -> decltype(P::Get(m).MatchAndExplain(value, listener)) {
+    return P::Get(m).MatchAndExplain(value, listener);
+  }
+
+  template <typename P>
+  static void DescribeImpl(const MatcherBase& m, std::ostream* os,
+                           bool negation) {
+    if (negation) {
+      P::Get(m).DescribeNegationTo(os);
+    } else {
+      P::Get(m).DescribeTo(os);
+    }
+  }
+
+  template <typename P>
+  static const MatcherDescriberInterface* GetDescriberImpl(
+      const MatcherBase& m) {
+    // If the impl is a MatcherDescriberInterface, then return it.
+    // Otherwise use MatcherBase itself.
+    // This allows us to implement the GetDescriber() function without support
+    // from the impl, but some users really want to get their impl back when
+    // they call GetDescriber().
+    // We use std::get on a tuple as a workaround of not having `if constexpr`.
+    return std::get<(
+        std::is_convertible<decltype(&P::Get(m)),
+                            const MatcherDescriberInterface*>::value
+            ? 1
+            : 0)>(std::make_tuple(&m, &P::Get(m)));
+  }
+
+  template <typename P>
+  const VTable* GetVTable() {
+    static constexpr VTable kVTable = {&MatchAndExplainImpl<P>,
+                                       &DescribeImpl<P>, &GetDescriberImpl<P>,
+                                       P::shared_destroy};
+    return &kVTable;
+  }
+
+  union Buffer {
+    // Add some types to give Buffer some common alignment/size use cases.
+    void* ptr;
+    double d;
+    int64_t i;
+    // And add one for the out-of-line cases.
+    SharedPayloadBase* shared;
+  };
+
+  void Destroy() {
+    if (IsShared() && buffer_.shared->Unref()) {
+      vtable_->shared_destroy(buffer_.shared);
+    }
+  }
+
+  template <typename M>
+  static constexpr bool IsInlined() {
+    return sizeof(M) <= sizeof(Buffer) && alignof(M) <= alignof(Buffer) &&
+           is_trivially_copy_constructible<M>::value &&
+           std::is_trivially_destructible<M>::value;
+  }
+
+  template <typename M, bool = MatcherBase::IsInlined<M>()>
+  struct ValuePolicy {
+    static const M& Get(const MatcherBase& m) {
+      // When inlined along with Init, need to be explicit to avoid violating
+      // strict aliasing rules.
+      const M *ptr = static_cast<const M*>(
+          static_cast<const void*>(&m.buffer_));
+      return *ptr;
+    }
+    static void Init(MatcherBase& m, M impl) {
+      ::new (static_cast<void*>(&m.buffer_)) M(impl);
+    }
+    static constexpr auto shared_destroy = nullptr;
+  };
+
+  template <typename M>
+  struct ValuePolicy<M, false> {
+    using Shared = SharedPayload<M>;
+    static const M& Get(const MatcherBase& m) {
+      return static_cast<Shared*>(m.buffer_.shared)->value;
+    }
+    template <typename Arg>
+    static void Init(MatcherBase& m, Arg&& arg) {
+      m.buffer_.shared = new Shared(std::forward<Arg>(arg));
+    }
+    static constexpr auto shared_destroy = &Shared::Destroy;
+  };
+
+  template <typename U, bool B>
+  struct ValuePolicy<const MatcherInterface<U>*, B> {
+    using M = const MatcherInterface<U>;
+    using Shared = SharedPayload<std::unique_ptr<M>>;
+    static const M& Get(const MatcherBase& m) {
+      return *static_cast<Shared*>(m.buffer_.shared)->value;
+    }
+    static void Init(MatcherBase& m, M* impl) {
+      m.buffer_.shared = new Shared(std::unique_ptr<M>(impl));
+    }
+
+    static constexpr auto shared_destroy = &Shared::Destroy;
+  };
+
+  template <typename M>
+  void Init(M&& m) {
+    using MM = typename std::decay<M>::type;
+    using Policy = ValuePolicy<MM>;
+    vtable_ = GetVTable<Policy>();
+    Policy::Init(*this, std::forward<M>(m));
+  }
+
+  const VTable* vtable_;
+  Buffer buffer_;
+};
+
+}  // namespace internal
+
+// A Matcher<T> is a copyable and IMMUTABLE (except by assignment)
+// object that can check whether a value of type T matches.  The
+// implementation of Matcher<T> is just a std::shared_ptr to const
+// MatcherInterface<T>.  Don't inherit from Matcher!
+template <typename T>
+class Matcher : public internal::MatcherBase<T> {
+ public:
+  // Constructs a null matcher.  Needed for storing Matcher objects in STL
+  // containers.  A default-constructed matcher is not yet initialized.  You
+  // cannot use it until a valid value has been assigned to it.
+  explicit Matcher() {}  // NOLINT
+
+  // Constructs a matcher from its implementation.
+  explicit Matcher(const MatcherInterface<const T&>* impl)
+      : internal::MatcherBase<T>(impl) {}
+
+  template <typename U>
+  explicit Matcher(
+      const MatcherInterface<U>* impl,
+      typename std::enable_if<!std::is_same<U, const U&>::value>::type* =
+          nullptr)
+      : internal::MatcherBase<T>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m) : internal::MatcherBase<T>(std::forward<M>(m)) {}  // NOLINT
+
+  // Implicit constructor here allows people to write
+  // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes
+  Matcher(T value);  // NOLINT
+};
+
+// The following two specializations allow the user to write str
+// instead of Eq(str) and "foo" instead of Eq("foo") when a std::string
+// matcher is expected.
+template <>
+class GTEST_API_ Matcher<const std::string&>
+    : public internal::MatcherBase<const std::string&> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const std::string&>* impl)
+      : internal::MatcherBase<const std::string&>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m)  // NOLINT
+      : internal::MatcherBase<const std::string&>(std::forward<M>(m)) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a std::string object.
+  Matcher(const std::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+};
+
+template <>
+class GTEST_API_ Matcher<std::string>
+    : public internal::MatcherBase<std::string> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const std::string&>* impl)
+      : internal::MatcherBase<std::string>(impl) {}
+  explicit Matcher(const MatcherInterface<std::string>* impl)
+      : internal::MatcherBase<std::string>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m)  // NOLINT
+      : internal::MatcherBase<std::string>(std::forward<M>(m)) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a string object.
+  Matcher(const std::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+};
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+// The following two specializations allow the user to write str
+// instead of Eq(str) and "foo" instead of Eq("foo") when a absl::string_view
+// matcher is expected.
+template <>
+class GTEST_API_ Matcher<const internal::StringView&>
+    : public internal::MatcherBase<const internal::StringView&> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
+      : internal::MatcherBase<const internal::StringView&>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m)  // NOLINT
+      : internal::MatcherBase<const internal::StringView&>(std::forward<M>(m)) {
+  }
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a std::string object.
+  Matcher(const std::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+
+  // Allows the user to pass absl::string_views or std::string_views directly.
+  Matcher(internal::StringView s);  // NOLINT
+};
+
+template <>
+class GTEST_API_ Matcher<internal::StringView>
+    : public internal::MatcherBase<internal::StringView> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
+      : internal::MatcherBase<internal::StringView>(impl) {}
+  explicit Matcher(const MatcherInterface<internal::StringView>* impl)
+      : internal::MatcherBase<internal::StringView>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m)  // NOLINT
+      : internal::MatcherBase<internal::StringView>(std::forward<M>(m)) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a std::string object.
+  Matcher(const std::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+
+  // Allows the user to pass absl::string_views or std::string_views directly.
+  Matcher(internal::StringView s);  // NOLINT
+};
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+// Prints a matcher in a human-readable format.
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const Matcher<T>& matcher) {
+  matcher.DescribeTo(&os);
+  return os;
+}
+
+// The PolymorphicMatcher class template makes it easy to implement a
+// polymorphic matcher (i.e. a matcher that can match values of more
+// than one type, e.g. Eq(n) and NotNull()).
+//
+// To define a polymorphic matcher, a user should provide an Impl
+// class that has a DescribeTo() method and a DescribeNegationTo()
+// method, and define a member function (or member function template)
+//
+//   bool MatchAndExplain(const Value& value,
+//                        MatchResultListener* listener) const;
+//
+// See the definition of NotNull() for a complete example.
+template <class Impl>
+class PolymorphicMatcher {
+ public:
+  explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
+
+  // Returns a mutable reference to the underlying matcher
+  // implementation object.
+  Impl& mutable_impl() { return impl_; }
+
+  // Returns an immutable reference to the underlying matcher
+  // implementation object.
+  const Impl& impl() const { return impl_; }
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new MonomorphicImpl<const T&>(impl_));
+  }
+
+ private:
+  template <typename T>
+  class MonomorphicImpl : public MatcherInterface<T> {
+   public:
+    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
+
+    void DescribeTo(::std::ostream* os) const override { impl_.DescribeTo(os); }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      impl_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
+      return impl_.MatchAndExplain(x, listener);
+    }
+
+   private:
+    const Impl impl_;
+  };
+
+  Impl impl_;
+};
+
+// Creates a matcher from its implementation.
+// DEPRECATED: Especially in the generic code, prefer:
+//   Matcher<T>(new MyMatcherImpl<const T&>(...));
+//
+// MakeMatcher may create a Matcher that accepts its argument by value, which
+// leads to unnecessary copies & lack of support for non-copyable types.
+template <typename T>
+inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
+  return Matcher<T>(impl);
+}
+
+// Creates a polymorphic matcher from its implementation.  This is
+// easier to use than the PolymorphicMatcher<Impl> constructor as it
+// doesn't require you to explicitly write the template argument, e.g.
+//
+//   MakePolymorphicMatcher(foo);
+// vs
+//   PolymorphicMatcher<TypeOfFoo>(foo);
+template <class Impl>
+inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
+  return PolymorphicMatcher<Impl>(impl);
+}
+
+namespace internal {
+// Implements a matcher that compares a given value with a
+// pre-supplied value using one of the ==, <=, <, etc, operators.  The
+// two values being compared don't have to have the same type.
+//
+// The matcher defined here is polymorphic (for example, Eq(5) can be
+// used to match an int, a short, a double, etc).  Therefore we use
+// a template type conversion operator in the implementation.
+//
+// The following template definition assumes that the Rhs parameter is
+// a "bare" type (i.e. neither 'const T' nor 'T&').
+template <typename D, typename Rhs, typename Op>
+class ComparisonBase {
+ public:
+  explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
+
+  using is_gtest_matcher = void;
+
+  template <typename Lhs>
+  bool MatchAndExplain(const Lhs& lhs, std::ostream*) const {
+    return Op()(lhs, Unwrap(rhs_));
+  }
+  void DescribeTo(std::ostream* os) const {
+    *os << D::Desc() << " ";
+    UniversalPrint(Unwrap(rhs_), os);
+  }
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << D::NegatedDesc() << " ";
+    UniversalPrint(Unwrap(rhs_), os);
+  }
+
+ private:
+  template <typename T>
+  static const T& Unwrap(const T& v) {
+    return v;
+  }
+  template <typename T>
+  static const T& Unwrap(std::reference_wrapper<T> v) {
+    return v;
+  }
+
+  Rhs rhs_;
+};
+
+template <typename Rhs>
+class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
+ public:
+  explicit EqMatcher(const Rhs& rhs)
+      : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
+  static const char* Desc() { return "is equal to"; }
+  static const char* NegatedDesc() { return "isn't equal to"; }
+};
+template <typename Rhs>
+class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
+ public:
+  explicit NeMatcher(const Rhs& rhs)
+      : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
+  static const char* Desc() { return "isn't equal to"; }
+  static const char* NegatedDesc() { return "is equal to"; }
+};
+template <typename Rhs>
+class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
+ public:
+  explicit LtMatcher(const Rhs& rhs)
+      : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
+  static const char* Desc() { return "is <"; }
+  static const char* NegatedDesc() { return "isn't <"; }
+};
+template <typename Rhs>
+class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
+ public:
+  explicit GtMatcher(const Rhs& rhs)
+      : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
+  static const char* Desc() { return "is >"; }
+  static const char* NegatedDesc() { return "isn't >"; }
+};
+template <typename Rhs>
+class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
+ public:
+  explicit LeMatcher(const Rhs& rhs)
+      : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
+  static const char* Desc() { return "is <="; }
+  static const char* NegatedDesc() { return "isn't <="; }
+};
+template <typename Rhs>
+class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
+ public:
+  explicit GeMatcher(const Rhs& rhs)
+      : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
+  static const char* Desc() { return "is >="; }
+  static const char* NegatedDesc() { return "isn't >="; }
+};
+
+template <typename T, typename = typename std::enable_if<
+                          std::is_constructible<std::string, T>::value>::type>
+using StringLike = T;
+
+// Implements polymorphic matchers MatchesRegex(regex) and
+// ContainsRegex(regex), which can be used as a Matcher<T> as long as
+// T can be converted to a string.
+class MatchesRegexMatcher {
+ public:
+  MatchesRegexMatcher(const RE* regex, bool full_match)
+      : regex_(regex), full_match_(full_match) {}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    return MatchAndExplain(std::string(s), listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != nullptr && MatchAndExplain(std::string(s), listener);
+  }
+
+  // Matches anything that can convert to std::string.
+  //
+  // This is a template, not just a plain function with const std::string&,
+  // because absl::string_view has some interfering non-explicit constructors.
+  template <class MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const std::string& s2(s);
+    return full_match_ ? RE::FullMatch(s2, *regex_)
+                       : RE::PartialMatch(s2, *regex_);
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << (full_match_ ? "matches" : "contains") << " regular expression ";
+    UniversalPrinter<std::string>::Print(regex_->pattern(), os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't " << (full_match_ ? "match" : "contain")
+        << " regular expression ";
+    UniversalPrinter<std::string>::Print(regex_->pattern(), os);
+  }
+
+ private:
+  const std::shared_ptr<const RE> regex_;
+  const bool full_match_;
+};
+}  // namespace internal
+
+// Matches a string that fully matches regular expression 'regex'.
+// The matcher takes ownership of 'regex'.
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
+    const internal::RE* regex) {
+  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
+}
+template <typename T = std::string>
+PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
+    const internal::StringLike<T>& regex) {
+  return MatchesRegex(new internal::RE(std::string(regex)));
+}
+
+// Matches a string that contains regular expression 'regex'.
+// The matcher takes ownership of 'regex'.
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
+    const internal::RE* regex) {
+  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
+}
+template <typename T = std::string>
+PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
+    const internal::StringLike<T>& regex) {
+  return ContainsRegex(new internal::RE(std::string(regex)));
+}
+
+// Creates a polymorphic matcher that matches anything equal to x.
+// Note: if the parameter of Eq() were declared as const T&, Eq("foo")
+// wouldn't compile.
+template <typename T>
+inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); }
+
+// Constructs a Matcher<T> from a 'value' of type T.  The constructed
+// matcher matches any value that's equal to 'value'.
+template <typename T>
+Matcher<T>::Matcher(T value) { *this = Eq(value); }
+
+// Creates a monomorphic matcher that matches anything with type Lhs
+// and equal to rhs.  A user may need to use this instead of Eq(...)
+// in order to resolve an overloading ambiguity.
+//
+// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x))
+// or Matcher<T>(x), but more readable than the latter.
+//
+// We could define similar monomorphic matchers for other comparison
+// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do
+// it yet as those are used much less than Eq() in practice.  A user
+// can always write Matcher<T>(Lt(5)) to be explicit about the type,
+// for example.
+template <typename Lhs, typename Rhs>
+inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }
+
+// Creates a polymorphic matcher that matches anything >= x.
+template <typename Rhs>
+inline internal::GeMatcher<Rhs> Ge(Rhs x) {
+  return internal::GeMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything > x.
+template <typename Rhs>
+inline internal::GtMatcher<Rhs> Gt(Rhs x) {
+  return internal::GtMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything <= x.
+template <typename Rhs>
+inline internal::LeMatcher<Rhs> Le(Rhs x) {
+  return internal::LeMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything < x.
+template <typename Rhs>
+inline internal::LtMatcher<Rhs> Lt(Rhs x) {
+  return internal::LtMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything != x.
+template <typename Rhs>
+inline internal::NeMatcher<Rhs> Ne(Rhs x) {
+  return internal::NeMatcher<Rhs>(x);
+}
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 5046
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
+
+#include <stdio.h>
+#include <memory>
+
+namespace testing {
+namespace internal {
+
+GTEST_DECLARE_string_(internal_run_death_test);
+
+// Names of the flags (needed for parsing Google Test flags).
+const char kDeathTestStyleFlag[] = "death_test_style";
+const char kDeathTestUseFork[] = "death_test_use_fork";
+const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
+
+#if GTEST_HAS_DEATH_TEST
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+// DeathTest is a class that hides much of the complexity of the
+// GTEST_DEATH_TEST_ macro.  It is abstract; its static Create method
+// returns a concrete class that depends on the prevailing death test
+// style, as defined by the --gtest_death_test_style and/or
+// --gtest_internal_run_death_test flags.
+
+// In describing the results of death tests, these terms are used with
+// the corresponding definitions:
+//
+// exit status:  The integer exit information in the format specified
+//               by wait(2)
+// exit code:    The integer code passed to exit(3), _exit(2), or
+//               returned from main()
+class GTEST_API_ DeathTest {
+ public:
+  // Create returns false if there was an error determining the
+  // appropriate action to take for the current death test; for example,
+  // if the gtest_death_test_style flag is set to an invalid value.
+  // The LastMessage method will return a more detailed message in that
+  // case.  Otherwise, the DeathTest pointer pointed to by the "test"
+  // argument is set.  If the death test should be skipped, the pointer
+  // is set to NULL; otherwise, it is set to the address of a new concrete
+  // DeathTest object that controls the execution of the current test.
+  static bool Create(const char* statement, Matcher<const std::string&> matcher,
+                     const char* file, int line, DeathTest** test);
+  DeathTest();
+  virtual ~DeathTest() { }
+
+  // A helper class that aborts a death test when it's deleted.
+  class ReturnSentinel {
+   public:
+    explicit ReturnSentinel(DeathTest* test) : test_(test) { }
+    ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
+   private:
+    DeathTest* const test_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel);
+  } GTEST_ATTRIBUTE_UNUSED_;
+
+  // An enumeration of possible roles that may be taken when a death
+  // test is encountered.  EXECUTE means that the death test logic should
+  // be executed immediately.  OVERSEE means that the program should prepare
+  // the appropriate environment for a child process to execute the death
+  // test, then wait for it to complete.
+  enum TestRole { OVERSEE_TEST, EXECUTE_TEST };
+
+  // An enumeration of the three reasons that a test might be aborted.
+  enum AbortReason {
+    TEST_ENCOUNTERED_RETURN_STATEMENT,
+    TEST_THREW_EXCEPTION,
+    TEST_DID_NOT_DIE
+  };
+
+  // Assumes one of the above roles.
+  virtual TestRole AssumeRole() = 0;
+
+  // Waits for the death test to finish and returns its status.
+  virtual int Wait() = 0;
+
+  // Returns true if the death test passed; that is, the test process
+  // exited during the test, its exit status matches a user-supplied
+  // predicate, and its stderr output matches a user-supplied regular
+  // expression.
+  // The user-supplied predicate may be a macro expression rather
+  // than a function pointer or functor, or else Wait and Passed could
+  // be combined.
+  virtual bool Passed(bool exit_status_ok) = 0;
+
+  // Signals that the death test did not die as expected.
+  virtual void Abort(AbortReason reason) = 0;
+
+  // Returns a human-readable outcome message regarding the outcome of
+  // the last death test.
+  static const char* LastMessage();
+
+  static void set_last_death_test_message(const std::string& message);
+
+ private:
+  // A string containing a description of the outcome of the last death test.
+  static std::string last_death_test_message_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
+};
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// Factory interface for death tests.  May be mocked out for testing.
+class DeathTestFactory {
+ public:
+  virtual ~DeathTestFactory() { }
+  virtual bool Create(const char* statement,
+                      Matcher<const std::string&> matcher, const char* file,
+                      int line, DeathTest** test) = 0;
+};
+
+// A concrete DeathTestFactory implementation for normal use.
+class DefaultDeathTestFactory : public DeathTestFactory {
+ public:
+  bool Create(const char* statement, Matcher<const std::string&> matcher,
+              const char* file, int line, DeathTest** test) override;
+};
+
+// Returns true if exit_status describes a process that was terminated
+// by a signal, or exited normally with a nonzero exit code.
+GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
+
+// A string passed to EXPECT_DEATH (etc.) is caught by one of these overloads
+// and interpreted as a regex (rather than an Eq matcher) for legacy
+// compatibility.
+inline Matcher<const ::std::string&> MakeDeathTestMatcher(
+    ::testing::internal::RE regex) {
+  return ContainsRegex(regex.pattern());
+}
+inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) {
+  return ContainsRegex(regex);
+}
+inline Matcher<const ::std::string&> MakeDeathTestMatcher(
+    const ::std::string& regex) {
+  return ContainsRegex(regex);
+}
+
+// If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.), it's
+// used directly.
+inline Matcher<const ::std::string&> MakeDeathTestMatcher(
+    Matcher<const ::std::string&> matcher) {
+  return matcher;
+}
+
+// Traps C++ exceptions escaping statement and reports them as test
+// failures. Note that trapping SEH exceptions is not implemented here.
+# if GTEST_HAS_EXCEPTIONS
+#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
+  try { \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+  } catch (const ::std::exception& gtest_exception) { \
+    fprintf(\
+        stderr, \
+        "\n%s: Caught std::exception-derived exception escaping the " \
+        "death test statement. Exception message: %s\n", \
+        ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
+        gtest_exception.what()); \
+    fflush(stderr); \
+    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
+  } catch (...) { \
+    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
+  }
+
+# else
+#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
+  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
+
+# endif
+
+// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
+// ASSERT_EXIT*, and EXPECT_EXIT*.
+#define GTEST_DEATH_TEST_(statement, predicate, regex_or_matcher, fail)        \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
+  if (::testing::internal::AlwaysTrue()) {                                     \
+    ::testing::internal::DeathTest* gtest_dt;                                  \
+    if (!::testing::internal::DeathTest::Create(                               \
+            #statement,                                                        \
+            ::testing::internal::MakeDeathTestMatcher(regex_or_matcher),       \
+            __FILE__, __LINE__, &gtest_dt)) {                                  \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                        \
+    }                                                                          \
+    if (gtest_dt != nullptr) {                                                 \
+      std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(gtest_dt); \
+      switch (gtest_dt->AssumeRole()) {                                        \
+        case ::testing::internal::DeathTest::OVERSEE_TEST:                     \
+          if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) {                \
+            goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                  \
+          }                                                                    \
+          break;                                                               \
+        case ::testing::internal::DeathTest::EXECUTE_TEST: {                   \
+          ::testing::internal::DeathTest::ReturnSentinel gtest_sentinel(       \
+              gtest_dt);                                                       \
+          GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt);            \
+          gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE);   \
+          break;                                                               \
+        }                                                                      \
+        default:                                                               \
+          break;                                                               \
+      }                                                                        \
+    }                                                                          \
+  } else                                                                       \
+    GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__)                                \
+        : fail(::testing::internal::DeathTest::LastMessage())
+// The symbol "fail" here expands to something into which a message
+// can be streamed.
+
+// This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in
+// NDEBUG mode. In this case we need the statements to be executed and the macro
+// must accept a streamed message even though the message is never printed.
+// The regex object is not evaluated, but it is used to prevent "unused"
+// warnings and to avoid an expression that doesn't compile in debug mode.
+#define GTEST_EXECUTE_STATEMENT_(statement, regex_or_matcher)    \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                  \
+  if (::testing::internal::AlwaysTrue()) {                       \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);   \
+  } else if (!::testing::internal::AlwaysTrue()) {               \
+    ::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \
+  } else                                                         \
+    ::testing::Message()
+
+// A class representing the parsed contents of the
+// --gtest_internal_run_death_test flag, as it existed when
+// RUN_ALL_TESTS was called.
+class InternalRunDeathTestFlag {
+ public:
+  InternalRunDeathTestFlag(const std::string& a_file,
+                           int a_line,
+                           int an_index,
+                           int a_write_fd)
+      : file_(a_file), line_(a_line), index_(an_index),
+        write_fd_(a_write_fd) {}
+
+  ~InternalRunDeathTestFlag() {
+    if (write_fd_ >= 0)
+      posix::Close(write_fd_);
+  }
+
+  const std::string& file() const { return file_; }
+  int line() const { return line_; }
+  int index() const { return index_; }
+  int write_fd() const { return write_fd_; }
+
+ private:
+  std::string file_;
+  int line_;
+  int index_;
+  int write_fd_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
+};
+
+// Returns a newly created InternalRunDeathTestFlag object with fields
+// initialized from the GTEST_FLAG(internal_run_death_test) flag if
+// the flag is specified; otherwise returns NULL.
+InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+
+namespace testing {
+
+// This flag controls the style of death tests.  Valid values are "threadsafe",
+// meaning that the death test child process will re-execute the test binary
+// from the start, running only a single death test, or "fast",
+// meaning that the child process will execute the test logic immediately
+// after forking.
+GTEST_DECLARE_string_(death_test_style);
+
+#if GTEST_HAS_DEATH_TEST
+
+namespace internal {
+
+// Returns a Boolean value indicating whether the caller is currently
+// executing in the context of the death test child process.  Tools such as
+// Valgrind heap checkers may need this to modify their behavior in death
+// tests.  IMPORTANT: This is an internal utility.  Using it may break the
+// implementation of death tests.  User code MUST NOT use it.
+GTEST_API_ bool InDeathTestChild();
+
+}  // namespace internal
+
+// The following macros are useful for writing death tests.
+
+// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
+// executed:
+//
+//   1. It generates a warning if there is more than one active
+//   thread.  This is because it's safe to fork() or clone() only
+//   when there is a single thread.
+//
+//   2. The parent process clone()s a sub-process and runs the death
+//   test in it; the sub-process exits with code 0 at the end of the
+//   death test, if it hasn't exited already.
+//
+//   3. The parent process waits for the sub-process to terminate.
+//
+//   4. The parent process checks the exit code and error message of
+//   the sub-process.
+//
+// Examples:
+//
+//   ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
+//   for (int i = 0; i < 5; i++) {
+//     EXPECT_DEATH(server.ProcessRequest(i),
+//                  "Invalid request .* in ProcessRequest()")
+//                  << "Failed to die on request " << i;
+//   }
+//
+//   ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
+//
+//   bool KilledBySIGHUP(int exit_code) {
+//     return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
+//   }
+//
+//   ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
+//
+// On the regular expressions used in death tests:
+//
+//   GOOGLETEST_CM0005 DO NOT DELETE
+//   On POSIX-compliant systems (*nix), we use the <regex.h> library,
+//   which uses the POSIX extended regex syntax.
+//
+//   On other platforms (e.g. Windows or Mac), we only support a simple regex
+//   syntax implemented as part of Google Test.  This limited
+//   implementation should be enough most of the time when writing
+//   death tests; though it lacks many features you can find in PCRE
+//   or POSIX extended regex syntax.  For example, we don't support
+//   union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and
+//   repetition count ("x{5,7}"), among others.
+//
+//   Below is the syntax that we do support.  We chose it to be a
+//   subset of both PCRE and POSIX extended regex, so it's easy to
+//   learn wherever you come from.  In the following: 'A' denotes a
+//   literal character, period (.), or a single \\ escape sequence;
+//   'x' and 'y' denote regular expressions; 'm' and 'n' are for
+//   natural numbers.
+//
+//     c     matches any literal character c
+//     \\d   matches any decimal digit
+//     \\D   matches any character that's not a decimal digit
+//     \\f   matches \f
+//     \\n   matches \n
+//     \\r   matches \r
+//     \\s   matches any ASCII whitespace, including \n
+//     \\S   matches any character that's not a whitespace
+//     \\t   matches \t
+//     \\v   matches \v
+//     \\w   matches any letter, _, or decimal digit
+//     \\W   matches any character that \\w doesn't match
+//     \\c   matches any literal character c, which must be a punctuation
+//     .     matches any single character except \n
+//     A?    matches 0 or 1 occurrences of A
+//     A*    matches 0 or many occurrences of A
+//     A+    matches 1 or many occurrences of A
+//     ^     matches the beginning of a string (not that of each line)
+//     $     matches the end of a string (not that of each line)
+//     xy    matches x followed by y
+//
+//   If you accidentally use PCRE or POSIX extended regex features
+//   not implemented by us, you will get a run-time failure.  In that
+//   case, please try to rewrite your regular expression within the
+//   above syntax.
+//
+//   This implementation is *not* meant to be as highly tuned or robust
+//   as a compiled regex library, but should perform well enough for a
+//   death test, which already incurs significant overhead by launching
+//   a child process.
+//
+// Known caveats:
+//
+//   A "threadsafe" style death test obtains the path to the test
+//   program from argv[0] and re-executes it in the sub-process.  For
+//   simplicity, the current implementation doesn't search the PATH
+//   when launching the sub-process.  This means that the user must
+//   invoke the test program via a path that contains at least one
+//   path separator (e.g. path/to/foo_test and
+//   /absolute/path/to/bar_test are fine, but foo_test is not).  This
+//   is rarely a problem as people usually don't put the test binary
+//   directory in PATH.
+//
+
+// Asserts that a given statement causes the program to exit, with an
+// integer exit status that satisfies predicate, and emitting error output
+// that matches regex.
+# define ASSERT_EXIT(statement, predicate, regex) \
+    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_)
+
+// Like ASSERT_EXIT, but continues on to successive tests in the
+// test suite, if any:
+# define EXPECT_EXIT(statement, predicate, regex) \
+    GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_)
+
+// Asserts that a given statement causes the program to exit, either by
+// explicitly exiting with a nonzero exit code or being killed by a
+// signal, and emitting error output that matches regex.
+# define ASSERT_DEATH(statement, regex) \
+    ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
+
+// Like ASSERT_DEATH, but continues on to successive tests in the
+// test suite, if any:
+# define EXPECT_DEATH(statement, regex) \
+    EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
+
+// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
+
+// Tests that an exit code describes a normal exit with a given exit code.
+class GTEST_API_ ExitedWithCode {
+ public:
+  explicit ExitedWithCode(int exit_code);
+  ExitedWithCode(const ExitedWithCode&) = default;
+  void operator=(const ExitedWithCode& other) = delete;
+  bool operator()(int exit_status) const;
+ private:
+  const int exit_code_;
+};
+
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+// Tests that an exit code describes an exit due to termination by a
+// given signal.
+// GOOGLETEST_CM0006 DO NOT DELETE
+class GTEST_API_ KilledBySignal {
+ public:
+  explicit KilledBySignal(int signum);
+  bool operator()(int exit_status) const;
+ private:
+  const int signum_;
+};
+# endif  // !GTEST_OS_WINDOWS
+
+// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
+// The death testing framework causes this to have interesting semantics,
+// since the sideeffects of the call are only visible in opt mode, and not
+// in debug mode.
+//
+// In practice, this can be used to test functions that utilize the
+// LOG(DFATAL) macro using the following style:
+//
+// int DieInDebugOr12(int* sideeffect) {
+//   if (sideeffect) {
+//     *sideeffect = 12;
+//   }
+//   LOG(DFATAL) << "death";
+//   return 12;
+// }
+//
+// TEST(TestSuite, TestDieOr12WorksInDgbAndOpt) {
+//   int sideeffect = 0;
+//   // Only asserts in dbg.
+//   EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
+//
+// #ifdef NDEBUG
+//   // opt-mode has sideeffect visible.
+//   EXPECT_EQ(12, sideeffect);
+// #else
+//   // dbg-mode no visible sideeffect.
+//   EXPECT_EQ(0, sideeffect);
+// #endif
+// }
+//
+// This will assert that DieInDebugReturn12InOpt() crashes in debug
+// mode, usually due to a DCHECK or LOG(DFATAL), but returns the
+// appropriate fallback value (12 in this case) in opt mode. If you
+// need to test that a function has appropriate side-effects in opt
+// mode, include assertions against the side-effects.  A general
+// pattern for this is:
+//
+// EXPECT_DEBUG_DEATH({
+//   // Side-effects here will have an effect after this statement in
+//   // opt mode, but none in debug mode.
+//   EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
+// }, "death");
+//
+# ifdef NDEBUG
+
+#  define EXPECT_DEBUG_DEATH(statement, regex) \
+  GTEST_EXECUTE_STATEMENT_(statement, regex)
+
+#  define ASSERT_DEBUG_DEATH(statement, regex) \
+  GTEST_EXECUTE_STATEMENT_(statement, regex)
+
+# else
+
+#  define EXPECT_DEBUG_DEATH(statement, regex) \
+  EXPECT_DEATH(statement, regex)
+
+#  define ASSERT_DEBUG_DEATH(statement, regex) \
+  ASSERT_DEATH(statement, regex)
+
+# endif  // NDEBUG for EXPECT_DEBUG_DEATH
+#endif  // GTEST_HAS_DEATH_TEST
+
+// This macro is used for implementing macros such as
+// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where
+// death tests are not supported. Those macros must compile on such systems
+// if and only if EXPECT_DEATH and ASSERT_DEATH compile with the same parameters
+// on systems that support death tests. This allows one to write such a macro on
+// a system that does not support death tests and be sure that it will compile
+// on a death-test supporting system. It is exposed publicly so that systems
+// that have death-tests with stricter requirements than GTEST_HAS_DEATH_TEST
+// can write their own equivalent of EXPECT_DEATH_IF_SUPPORTED and
+// ASSERT_DEATH_IF_SUPPORTED.
+//
+// Parameters:
+//   statement -  A statement that a macro such as EXPECT_DEATH would test
+//                for program termination. This macro has to make sure this
+//                statement is compiled but not executed, to ensure that
+//                EXPECT_DEATH_IF_SUPPORTED compiles with a certain
+//                parameter if and only if EXPECT_DEATH compiles with it.
+//   regex     -  A regex that a macro such as EXPECT_DEATH would use to test
+//                the output of statement.  This parameter has to be
+//                compiled but not evaluated by this macro, to ensure that
+//                this macro only accepts expressions that a macro such as
+//                EXPECT_DEATH would accept.
+//   terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED
+//                and a return statement for ASSERT_DEATH_IF_SUPPORTED.
+//                This ensures that ASSERT_DEATH_IF_SUPPORTED will not
+//                compile inside functions where ASSERT_DEATH doesn't
+//                compile.
+//
+//  The branch that has an always false condition is used to ensure that
+//  statement and regex are compiled (and thus syntactically correct) but
+//  never executed. The unreachable code macro protects the terminator
+//  statement from generating an 'unreachable code' warning in case
+//  statement unconditionally returns or throws. The Message constructor at
+//  the end allows the syntax of streaming additional messages into the
+//  macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
+# define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator) \
+    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+    if (::testing::internal::AlwaysTrue()) { \
+      GTEST_LOG_(WARNING) \
+          << "Death tests are not supported on this platform.\n" \
+          << "Statement '" #statement "' cannot be verified."; \
+    } else if (::testing::internal::AlwaysFalse()) { \
+      ::testing::internal::RE::PartialMatch(".*", (regex)); \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+      terminator; \
+    } else \
+      ::testing::Message()
+
+// EXPECT_DEATH_IF_SUPPORTED(statement, regex) and
+// ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if
+// death tests are supported; otherwise they just issue a warning.  This is
+// useful when you are combining death test assertions with normal test
+// assertions in one test.
+#if GTEST_HAS_DEATH_TEST
+# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
+    EXPECT_DEATH(statement, regex)
+# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
+    ASSERT_DEATH(statement, regex)
+#else
+# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
+    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, )
+# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
+    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return)
+#endif
+
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Macros and functions for implementing parameterized tests
+// in Google C++ Testing and Mocking Framework (Google Test)
+//
+// GOOGLETEST_CM0001 DO NOT DELETE
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+
+// Value-parameterized tests allow you to test your code with different
+// parameters without writing multiple copies of the same test.
+//
+// Here is how you use value-parameterized tests:
+
+#if 0
+
+// To write value-parameterized tests, first you should define a fixture
+// class. It is usually derived from testing::TestWithParam<T> (see below for
+// another inheritance scheme that's sometimes useful in more complicated
+// class hierarchies), where the type of your parameter values.
+// TestWithParam<T> is itself derived from testing::Test. T can be any
+// copyable type. If it's a raw pointer, you are responsible for managing the
+// lifespan of the pointed values.
+
+class FooTest : public ::testing::TestWithParam<const char*> {
+  // You can implement all the usual class fixture members here.
+};
+
+// Then, use the TEST_P macro to define as many parameterized tests
+// for this fixture as you want. The _P suffix is for "parameterized"
+// or "pattern", whichever you prefer to think.
+
+TEST_P(FooTest, DoesBlah) {
+  // Inside a test, access the test parameter with the GetParam() method
+  // of the TestWithParam<T> class:
+  EXPECT_TRUE(foo.Blah(GetParam()));
+  ...
+}
+
+TEST_P(FooTest, HasBlahBlah) {
+  ...
+}
+
+// Finally, you can use INSTANTIATE_TEST_SUITE_P to instantiate the test
+// case with any set of parameters you want. Google Test defines a number
+// of functions for generating test parameters. They return what we call
+// (surprise!) parameter generators. Here is a summary of them, which
+// are all in the testing namespace:
+//
+//
+//  Range(begin, end [, step]) - Yields values {begin, begin+step,
+//                               begin+step+step, ...}. The values do not
+//                               include end. step defaults to 1.
+//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
+//  ValuesIn(container)        - Yields values from a C-style array, an STL
+//  ValuesIn(begin,end)          container, or an iterator range [begin, end).
+//  Bool()                     - Yields sequence {false, true}.
+//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
+//                               for the math savvy) of the values generated
+//                               by the N generators.
+//
+// For more details, see comments at the definitions of these functions below
+// in this file.
+//
+// The following statement will instantiate tests from the FooTest test suite
+// each with parameter values "meeny", "miny", and "moe".
+
+INSTANTIATE_TEST_SUITE_P(InstantiationName,
+                         FooTest,
+                         Values("meeny", "miny", "moe"));
+
+// To distinguish different instances of the pattern, (yes, you
+// can instantiate it more than once) the first argument to the
+// INSTANTIATE_TEST_SUITE_P macro is a prefix that will be added to the
+// actual test suite name. Remember to pick unique prefixes for different
+// instantiations. The tests from the instantiation above will have
+// these names:
+//
+//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
+//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
+//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
+//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
+//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
+//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
+//
+// You can use these names in --gtest_filter.
+//
+// This statement will instantiate all tests from FooTest again, each
+// with parameter values "cat" and "dog":
+
+const char* pets[] = {"cat", "dog"};
+INSTANTIATE_TEST_SUITE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
+
+// The tests from the instantiation above will have these names:
+//
+//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
+//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
+//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
+//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
+//
+// Please note that INSTANTIATE_TEST_SUITE_P will instantiate all tests
+// in the given test suite, whether their definitions come before or
+// AFTER the INSTANTIATE_TEST_SUITE_P statement.
+//
+// Please also note that generator expressions (including parameters to the
+// generators) are evaluated in InitGoogleTest(), after main() has started.
+// This allows the user on one hand, to adjust generator parameters in order
+// to dynamically determine a set of tests to run and on the other hand,
+// give the user a chance to inspect the generated tests with Google Test
+// reflection API before RUN_ALL_TESTS() is executed.
+//
+// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
+// for more examples.
+//
+// In the future, we plan to publish the API for defining new parameter
+// generators. But for now this interface remains part of the internal
+// implementation and is subject to change.
+//
+//
+// A parameterized test fixture must be derived from testing::Test and from
+// testing::WithParamInterface<T>, where T is the type of the parameter
+// values. Inheriting from TestWithParam<T> satisfies that requirement because
+// TestWithParam<T> inherits from both Test and WithParamInterface. In more
+// complicated hierarchies, however, it is occasionally useful to inherit
+// separately from Test and WithParamInterface. For example:
+
+class BaseTest : public ::testing::Test {
+  // You can inherit all the usual members for a non-parameterized test
+  // fixture here.
+};
+
+class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
+  // The usual test fixture members go here too.
+};
+
+TEST_F(BaseTest, HasFoo) {
+  // This is an ordinary non-parameterized test.
+}
+
+TEST_P(DerivedTest, DoesBlah) {
+  // GetParam works just the same here as if you inherit from TestWithParam.
+  EXPECT_TRUE(foo.Blah(GetParam()));
+}
+
+#endif  // 0
+
+#include <iterator>
+#include <utility>
+
+// Copyright 2008 Google Inc.
+// All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+// Type and function utilities for implementing parameterized tests.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+
+#include <ctype.h>
+
+#include <cassert>
+#include <iterator>
+#include <memory>
+#include <set>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+// Copyright 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+
+#include <iosfwd>
+#include <vector>
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// A copyable object representing the result of a test part (i.e. an
+// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
+//
+// Don't inherit from TestPartResult as its destructor is not virtual.
+class GTEST_API_ TestPartResult {
+ public:
+  // The possible outcomes of a test part (i.e. an assertion or an
+  // explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
+  enum Type {
+    kSuccess,          // Succeeded.
+    kNonFatalFailure,  // Failed but the test can continue.
+    kFatalFailure,     // Failed and the test should be terminated.
+    kSkip              // Skipped.
+  };
+
+  // C'tor.  TestPartResult does NOT have a default constructor.
+  // Always use this constructor (with parameters) to create a
+  // TestPartResult object.
+  TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
+                 const char* a_message)
+      : type_(a_type),
+        file_name_(a_file_name == nullptr ? "" : a_file_name),
+        line_number_(a_line_number),
+        summary_(ExtractSummary(a_message)),
+        message_(a_message) {}
+
+  // Gets the outcome of the test part.
+  Type type() const { return type_; }
+
+  // Gets the name of the source file where the test part took place, or
+  // NULL if it's unknown.
+  const char* file_name() const {
+    return file_name_.empty() ? nullptr : file_name_.c_str();
+  }
+
+  // Gets the line in the source file where the test part took place,
+  // or -1 if it's unknown.
+  int line_number() const { return line_number_; }
+
+  // Gets the summary of the failure message.
+  const char* summary() const { return summary_.c_str(); }
+
+  // Gets the message associated with the test part.
+  const char* message() const { return message_.c_str(); }
+
+  // Returns true if and only if the test part was skipped.
+  bool skipped() const { return type_ == kSkip; }
+
+  // Returns true if and only if the test part passed.
+  bool passed() const { return type_ == kSuccess; }
+
+  // Returns true if and only if the test part non-fatally failed.
+  bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
+
+  // Returns true if and only if the test part fatally failed.
+  bool fatally_failed() const { return type_ == kFatalFailure; }
+
+  // Returns true if and only if the test part failed.
+  bool failed() const { return fatally_failed() || nonfatally_failed(); }
+
+ private:
+  Type type_;
+
+  // Gets the summary of the failure message by omitting the stack
+  // trace in it.
+  static std::string ExtractSummary(const char* message);
+
+  // The name of the source file where the test part took place, or
+  // "" if the source file is unknown.
+  std::string file_name_;
+  // The line in the source file where the test part took place, or -1
+  // if the line number is unknown.
+  int line_number_;
+  std::string summary_;  // The test failure summary.
+  std::string message_;  // The test failure message.
+};
+
+// Prints a TestPartResult object.
+std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
+
+// An array of TestPartResult objects.
+//
+// Don't inherit from TestPartResultArray as its destructor is not
+// virtual.
+class GTEST_API_ TestPartResultArray {
+ public:
+  TestPartResultArray() {}
+
+  // Appends the given TestPartResult to the array.
+  void Append(const TestPartResult& result);
+
+  // Returns the TestPartResult at the given index (0-based).
+  const TestPartResult& GetTestPartResult(int index) const;
+
+  // Returns the number of TestPartResult objects in the array.
+  int size() const;
+
+ private:
+  std::vector<TestPartResult> array_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
+};
+
+// This interface knows how to report a test part result.
+class GTEST_API_ TestPartResultReporterInterface {
+ public:
+  virtual ~TestPartResultReporterInterface() {}
+
+  virtual void ReportTestPartResult(const TestPartResult& result) = 0;
+};
+
+namespace internal {
+
+// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a
+// statement generates new fatal failures. To do so it registers itself as the
+// current test part result reporter. Besides checking if fatal failures were
+// reported, it only delegates the reporting to the former result reporter.
+// The original result reporter is restored in the destructor.
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+class GTEST_API_ HasNewFatalFailureHelper
+    : public TestPartResultReporterInterface {
+ public:
+  HasNewFatalFailureHelper();
+  ~HasNewFatalFailureHelper() override;
+  void ReportTestPartResult(const TestPartResult& result) override;
+  bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
+ private:
+  bool has_new_fatal_failure_;
+  TestPartResultReporterInterface* original_reporter_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+
+namespace testing {
+// Input to a parameterized test name generator, describing a test parameter.
+// Consists of the parameter value and the integer parameter index.
+template <class ParamType>
+struct TestParamInfo {
+  TestParamInfo(const ParamType& a_param, size_t an_index) :
+    param(a_param),
+    index(an_index) {}
+  ParamType param;
+  size_t index;
+};
+
+// A builtin parameterized test name generator which returns the result of
+// testing::PrintToString.
+struct PrintToStringParamName {
+  template <class ParamType>
+  std::string operator()(const TestParamInfo<ParamType>& info) const {
+    return PrintToString(info.param);
+  }
+};
+
+namespace internal {
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+// Utility Functions
+
+// Outputs a message explaining invalid registration of different
+// fixture class for the same test suite. This may happen when
+// TEST_P macro is used to define two tests with the same name
+// but in different namespaces.
+GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name,
+                                           CodeLocation code_location);
+
+template <typename> class ParamGeneratorInterface;
+template <typename> class ParamGenerator;
+
+// Interface for iterating over elements provided by an implementation
+// of ParamGeneratorInterface<T>.
+template <typename T>
+class ParamIteratorInterface {
+ public:
+  virtual ~ParamIteratorInterface() {}
+  // A pointer to the base generator instance.
+  // Used only for the purposes of iterator comparison
+  // to make sure that two iterators belong to the same generator.
+  virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
+  // Advances iterator to point to the next element
+  // provided by the generator. The caller is responsible
+  // for not calling Advance() on an iterator equal to
+  // BaseGenerator()->End().
+  virtual void Advance() = 0;
+  // Clones the iterator object. Used for implementing copy semantics
+  // of ParamIterator<T>.
+  virtual ParamIteratorInterface* Clone() const = 0;
+  // Dereferences the current iterator and provides (read-only) access
+  // to the pointed value. It is the caller's responsibility not to call
+  // Current() on an iterator equal to BaseGenerator()->End().
+  // Used for implementing ParamGenerator<T>::operator*().
+  virtual const T* Current() const = 0;
+  // Determines whether the given iterator and other point to the same
+  // element in the sequence generated by the generator.
+  // Used for implementing ParamGenerator<T>::operator==().
+  virtual bool Equals(const ParamIteratorInterface& other) const = 0;
+};
+
+// Class iterating over elements provided by an implementation of
+// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
+// and implements the const forward iterator concept.
+template <typename T>
+class ParamIterator {
+ public:
+  typedef T value_type;
+  typedef const T& reference;
+  typedef ptrdiff_t difference_type;
+
+  // ParamIterator assumes ownership of the impl_ pointer.
+  ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
+  ParamIterator& operator=(const ParamIterator& other) {
+    if (this != &other)
+      impl_.reset(other.impl_->Clone());
+    return *this;
+  }
+
+  const T& operator*() const { return *impl_->Current(); }
+  const T* operator->() const { return impl_->Current(); }
+  // Prefix version of operator++.
+  ParamIterator& operator++() {
+    impl_->Advance();
+    return *this;
+  }
+  // Postfix version of operator++.
+  ParamIterator operator++(int /*unused*/) {
+    ParamIteratorInterface<T>* clone = impl_->Clone();
+    impl_->Advance();
+    return ParamIterator(clone);
+  }
+  bool operator==(const ParamIterator& other) const {
+    return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
+  }
+  bool operator!=(const ParamIterator& other) const {
+    return !(*this == other);
+  }
+
+ private:
+  friend class ParamGenerator<T>;
+  explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
+  std::unique_ptr<ParamIteratorInterface<T> > impl_;
+};
+
+// ParamGeneratorInterface<T> is the binary interface to access generators
+// defined in other translation units.
+template <typename T>
+class ParamGeneratorInterface {
+ public:
+  typedef T ParamType;
+
+  virtual ~ParamGeneratorInterface() {}
+
+  // Generator interface definition
+  virtual ParamIteratorInterface<T>* Begin() const = 0;
+  virtual ParamIteratorInterface<T>* End() const = 0;
+};
+
+// Wraps ParamGeneratorInterface<T> and provides general generator syntax
+// compatible with the STL Container concept.
+// This class implements copy initialization semantics and the contained
+// ParamGeneratorInterface<T> instance is shared among all copies
+// of the original object. This is possible because that instance is immutable.
+template<typename T>
+class ParamGenerator {
+ public:
+  typedef ParamIterator<T> iterator;
+
+  explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
+  ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}
+
+  ParamGenerator& operator=(const ParamGenerator& other) {
+    impl_ = other.impl_;
+    return *this;
+  }
+
+  iterator begin() const { return iterator(impl_->Begin()); }
+  iterator end() const { return iterator(impl_->End()); }
+
+ private:
+  std::shared_ptr<const ParamGeneratorInterface<T> > impl_;
+};
+
+// Generates values from a range of two comparable values. Can be used to
+// generate sequences of user-defined types that implement operator+() and
+// operator<().
+// This class is used in the Range() function.
+template <typename T, typename IncrementT>
+class RangeGenerator : public ParamGeneratorInterface<T> {
+ public:
+  RangeGenerator(T begin, T end, IncrementT step)
+      : begin_(begin), end_(end),
+        step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
+  ~RangeGenerator() override {}
+
+  ParamIteratorInterface<T>* Begin() const override {
+    return new Iterator(this, begin_, 0, step_);
+  }
+  ParamIteratorInterface<T>* End() const override {
+    return new Iterator(this, end_, end_index_, step_);
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<T> {
+   public:
+    Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
+             IncrementT step)
+        : base_(base), value_(value), index_(index), step_(step) {}
+    ~Iterator() override {}
+
+    const ParamGeneratorInterface<T>* BaseGenerator() const override {
+      return base_;
+    }
+    void Advance() override {
+      value_ = static_cast<T>(value_ + step_);
+      index_++;
+    }
+    ParamIteratorInterface<T>* Clone() const override {
+      return new Iterator(*this);
+    }
+    const T* Current() const override { return &value_; }
+    bool Equals(const ParamIteratorInterface<T>& other) const override {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const int other_index =
+          CheckedDowncastToActualType<const Iterator>(&other)->index_;
+      return index_ == other_index;
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : ParamIteratorInterface<T>(),
+          base_(other.base_), value_(other.value_), index_(other.index_),
+          step_(other.step_) {}
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<T>* const base_;
+    T value_;
+    int index_;
+    const IncrementT step_;
+  };  // class RangeGenerator::Iterator
+
+  static int CalculateEndIndex(const T& begin,
+                               const T& end,
+                               const IncrementT& step) {
+    int end_index = 0;
+    for (T i = begin; i < end; i = static_cast<T>(i + step))
+      end_index++;
+    return end_index;
+  }
+
+  // No implementation - assignment is unsupported.
+  void operator=(const RangeGenerator& other);
+
+  const T begin_;
+  const T end_;
+  const IncrementT step_;
+  // The index for the end() iterator. All the elements in the generated
+  // sequence are indexed (0-based) to aid iterator comparison.
+  const int end_index_;
+};  // class RangeGenerator
+
+
+// Generates values from a pair of STL-style iterators. Used in the
+// ValuesIn() function. The elements are copied from the source range
+// since the source can be located on the stack, and the generator
+// is likely to persist beyond that stack frame.
+template <typename T>
+class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
+ public:
+  template <typename ForwardIterator>
+  ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
+      : container_(begin, end) {}
+  ~ValuesInIteratorRangeGenerator() override {}
+
+  ParamIteratorInterface<T>* Begin() const override {
+    return new Iterator(this, container_.begin());
+  }
+  ParamIteratorInterface<T>* End() const override {
+    return new Iterator(this, container_.end());
+  }
+
+ private:
+  typedef typename ::std::vector<T> ContainerType;
+
+  class Iterator : public ParamIteratorInterface<T> {
+   public:
+    Iterator(const ParamGeneratorInterface<T>* base,
+             typename ContainerType::const_iterator iterator)
+        : base_(base), iterator_(iterator) {}
+    ~Iterator() override {}
+
+    const ParamGeneratorInterface<T>* BaseGenerator() const override {
+      return base_;
+    }
+    void Advance() override {
+      ++iterator_;
+      value_.reset();
+    }
+    ParamIteratorInterface<T>* Clone() const override {
+      return new Iterator(*this);
+    }
+    // We need to use cached value referenced by iterator_ because *iterator_
+    // can return a temporary object (and of type other then T), so just
+    // having "return &*iterator_;" doesn't work.
+    // value_ is updated here and not in Advance() because Advance()
+    // can advance iterator_ beyond the end of the range, and we cannot
+    // detect that fact. The client code, on the other hand, is
+    // responsible for not calling Current() on an out-of-range iterator.
+    const T* Current() const override {
+      if (value_.get() == nullptr) value_.reset(new T(*iterator_));
+      return value_.get();
+    }
+    bool Equals(const ParamIteratorInterface<T>& other) const override {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      return iterator_ ==
+          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
+    }
+
+   private:
+    Iterator(const Iterator& other)
+          // The explicit constructor call suppresses a false warning
+          // emitted by gcc when supplied with the -Wextra option.
+        : ParamIteratorInterface<T>(),
+          base_(other.base_),
+          iterator_(other.iterator_) {}
+
+    const ParamGeneratorInterface<T>* const base_;
+    typename ContainerType::const_iterator iterator_;
+    // A cached value of *iterator_. We keep it here to allow access by
+    // pointer in the wrapping iterator's operator->().
+    // value_ needs to be mutable to be accessed in Current().
+    // Use of std::unique_ptr helps manage cached value's lifetime,
+    // which is bound by the lifespan of the iterator itself.
+    mutable std::unique_ptr<const T> value_;
+  };  // class ValuesInIteratorRangeGenerator::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const ValuesInIteratorRangeGenerator& other);
+
+  const ContainerType container_;
+};  // class ValuesInIteratorRangeGenerator
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Default parameterized test name generator, returns a string containing the
+// integer test parameter index.
+template <class ParamType>
+std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
+  Message name_stream;
+  name_stream << info.index;
+  return name_stream.GetString();
+}
+
+template <typename T = int>
+void TestNotEmpty() {
+  static_assert(sizeof(T) == 0, "Empty arguments are not allowed.");
+}
+template <typename T = int>
+void TestNotEmpty(const T&) {}
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Stores a parameter value and later creates tests parameterized with that
+// value.
+template <class TestClass>
+class ParameterizedTestFactory : public TestFactoryBase {
+ public:
+  typedef typename TestClass::ParamType ParamType;
+  explicit ParameterizedTestFactory(ParamType parameter) :
+      parameter_(parameter) {}
+  Test* CreateTest() override {
+    TestClass::SetParam(&parameter_);
+    return new TestClass();
+  }
+
+ private:
+  const ParamType parameter_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// TestMetaFactoryBase is a base class for meta-factories that create
+// test factories for passing into MakeAndRegisterTestInfo function.
+template <class ParamType>
+class TestMetaFactoryBase {
+ public:
+  virtual ~TestMetaFactoryBase() {}
+
+  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// TestMetaFactory creates test factories for passing into
+// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
+// ownership of test factory pointer, same factory object cannot be passed
+// into that method twice. But ParameterizedTestSuiteInfo is going to call
+// it for each Test/Parameter value combination. Thus it needs meta factory
+// creator class.
+template <class TestSuite>
+class TestMetaFactory
+    : public TestMetaFactoryBase<typename TestSuite::ParamType> {
+ public:
+  using ParamType = typename TestSuite::ParamType;
+
+  TestMetaFactory() {}
+
+  TestFactoryBase* CreateTestFactory(ParamType parameter) override {
+    return new ParameterizedTestFactory<TestSuite>(parameter);
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestSuiteInfoBase is a generic interface
+// to ParameterizedTestSuiteInfo classes. ParameterizedTestSuiteInfoBase
+// accumulates test information provided by TEST_P macro invocations
+// and generators provided by INSTANTIATE_TEST_SUITE_P macro invocations
+// and uses that information to register all resulting test instances
+// in RegisterTests method. The ParameterizeTestSuiteRegistry class holds
+// a collection of pointers to the ParameterizedTestSuiteInfo objects
+// and calls RegisterTests() on each of them when asked.
+class ParameterizedTestSuiteInfoBase {
+ public:
+  virtual ~ParameterizedTestSuiteInfoBase() {}
+
+  // Base part of test suite name for display purposes.
+  virtual const std::string& GetTestSuiteName() const = 0;
+  // Test suite id to verify identity.
+  virtual TypeId GetTestSuiteTypeId() const = 0;
+  // UnitTest class invokes this method to register tests in this
+  // test suite right before running them in RUN_ALL_TESTS macro.
+  // This method should not be called more than once on any single
+  // instance of a ParameterizedTestSuiteInfoBase derived class.
+  virtual void RegisterTests() = 0;
+
+ protected:
+  ParameterizedTestSuiteInfoBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfoBase);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Report a the name of a test_suit as safe to ignore
+// as the side effect of construction of this type.
+struct MarkAsIgnored {
+  explicit MarkAsIgnored(const char* test_suite);
+};
+
+GTEST_API_ void InsertSyntheticTestCase(const std::string& name,
+                                        CodeLocation location, bool has_test_p);
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestSuiteInfo accumulates tests obtained from TEST_P
+// macro invocations for a particular test suite and generators
+// obtained from INSTANTIATE_TEST_SUITE_P macro invocations for that
+// test suite. It registers tests with all values generated by all
+// generators when asked.
+template <class TestSuite>
+class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
+ public:
+  // ParamType and GeneratorCreationFunc are private types but are required
+  // for declarations of public methods AddTestPattern() and
+  // AddTestSuiteInstantiation().
+  using ParamType = typename TestSuite::ParamType;
+  // A function that returns an instance of appropriate generator type.
+  typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
+  using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&);
+
+  explicit ParameterizedTestSuiteInfo(const char* name,
+                                      CodeLocation code_location)
+      : test_suite_name_(name), code_location_(code_location) {}
+
+  // Test suite base name for display purposes.
+  const std::string& GetTestSuiteName() const override {
+    return test_suite_name_;
+  }
+  // Test suite id to verify identity.
+  TypeId GetTestSuiteTypeId() const override { return GetTypeId<TestSuite>(); }
+  // TEST_P macro uses AddTestPattern() to record information
+  // about a single test in a LocalTestInfo structure.
+  // test_suite_name is the base name of the test suite (without invocation
+  // prefix). test_base_name is the name of an individual test without
+  // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
+  // test suite base name and DoBar is test base name.
+  void AddTestPattern(const char* test_suite_name, const char* test_base_name,
+                      TestMetaFactoryBase<ParamType>* meta_factory,
+                      CodeLocation code_location) {
+    tests_.push_back(std::shared_ptr<TestInfo>(new TestInfo(
+        test_suite_name, test_base_name, meta_factory, code_location)));
+  }
+  // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information
+  // about a generator.
+  int AddTestSuiteInstantiation(const std::string& instantiation_name,
+                                GeneratorCreationFunc* func,
+                                ParamNameGeneratorFunc* name_func,
+                                const char* file, int line) {
+    instantiations_.push_back(
+        InstantiationInfo(instantiation_name, func, name_func, file, line));
+    return 0;  // Return value used only to run this method in namespace scope.
+  }
+  // UnitTest class invokes this method to register tests in this test suite
+  // right before running tests in RUN_ALL_TESTS macro.
+  // This method should not be called more than once on any single
+  // instance of a ParameterizedTestSuiteInfoBase derived class.
+  // UnitTest has a guard to prevent from calling this method more than once.
+  void RegisterTests() override {
+    bool generated_instantiations = false;
+
+    for (typename TestInfoContainer::iterator test_it = tests_.begin();
+         test_it != tests_.end(); ++test_it) {
+      std::shared_ptr<TestInfo> test_info = *test_it;
+      for (typename InstantiationContainer::iterator gen_it =
+               instantiations_.begin(); gen_it != instantiations_.end();
+               ++gen_it) {
+        const std::string& instantiation_name = gen_it->name;
+        ParamGenerator<ParamType> generator((*gen_it->generator)());
+        ParamNameGeneratorFunc* name_func = gen_it->name_func;
+        const char* file = gen_it->file;
+        int line = gen_it->line;
+
+        std::string test_suite_name;
+        if ( !instantiation_name.empty() )
+          test_suite_name = instantiation_name + "/";
+        test_suite_name += test_info->test_suite_base_name;
+
+        size_t i = 0;
+        std::set<std::string> test_param_names;
+        for (typename ParamGenerator<ParamType>::iterator param_it =
+                 generator.begin();
+             param_it != generator.end(); ++param_it, ++i) {
+          generated_instantiations = true;
+
+          Message test_name_stream;
+
+          std::string param_name = name_func(
+              TestParamInfo<ParamType>(*param_it, i));
+
+          GTEST_CHECK_(IsValidParamName(param_name))
+              << "Parameterized test name '" << param_name
+              << "' is invalid, in " << file
+              << " line " << line << std::endl;
+
+          GTEST_CHECK_(test_param_names.count(param_name) == 0)
+              << "Duplicate parameterized test name '" << param_name
+              << "', in " << file << " line " << line << std::endl;
+
+          test_param_names.insert(param_name);
+
+          if (!test_info->test_base_name.empty()) {
+            test_name_stream << test_info->test_base_name << "/";
+          }
+          test_name_stream << param_name;
+          MakeAndRegisterTestInfo(
+              test_suite_name.c_str(), test_name_stream.GetString().c_str(),
+              nullptr,  // No type parameter.
+              PrintToString(*param_it).c_str(), test_info->code_location,
+              GetTestSuiteTypeId(),
+              SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line),
+              SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line),
+              test_info->test_meta_factory->CreateTestFactory(*param_it));
+        }  // for param_it
+      }  // for gen_it
+    }  // for test_it
+
+    if (!generated_instantiations) {
+      // There are no generaotrs, or they all generate nothing ...
+      InsertSyntheticTestCase(GetTestSuiteName(), code_location_,
+                              !tests_.empty());
+    }
+  }    // RegisterTests
+
+ private:
+  // LocalTestInfo structure keeps information about a single test registered
+  // with TEST_P macro.
+  struct TestInfo {
+    TestInfo(const char* a_test_suite_base_name, const char* a_test_base_name,
+             TestMetaFactoryBase<ParamType>* a_test_meta_factory,
+             CodeLocation a_code_location)
+        : test_suite_base_name(a_test_suite_base_name),
+          test_base_name(a_test_base_name),
+          test_meta_factory(a_test_meta_factory),
+          code_location(a_code_location) {}
+
+    const std::string test_suite_base_name;
+    const std::string test_base_name;
+    const std::unique_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
+    const CodeLocation code_location;
+  };
+  using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo> >;
+  // Records data received from INSTANTIATE_TEST_SUITE_P macros:
+  //  <Instantiation name, Sequence generator creation function,
+  //     Name generator function, Source file, Source line>
+  struct InstantiationInfo {
+      InstantiationInfo(const std::string &name_in,
+                        GeneratorCreationFunc* generator_in,
+                        ParamNameGeneratorFunc* name_func_in,
+                        const char* file_in,
+                        int line_in)
+          : name(name_in),
+            generator(generator_in),
+            name_func(name_func_in),
+            file(file_in),
+            line(line_in) {}
+
+      std::string name;
+      GeneratorCreationFunc* generator;
+      ParamNameGeneratorFunc* name_func;
+      const char* file;
+      int line;
+  };
+  typedef ::std::vector<InstantiationInfo> InstantiationContainer;
+
+  static bool IsValidParamName(const std::string& name) {
+    // Check for empty string
+    if (name.empty())
+      return false;
+
+    // Check for invalid characters
+    for (std::string::size_type index = 0; index < name.size(); ++index) {
+      if (!isalnum(name[index]) && name[index] != '_')
+        return false;
+    }
+
+    return true;
+  }
+
+  const std::string test_suite_name_;
+  CodeLocation code_location_;
+  TestInfoContainer tests_;
+  InstantiationContainer instantiations_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfo);
+};  // class ParameterizedTestSuiteInfo
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+template <class TestCase>
+using ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestSuiteRegistry contains a map of
+// ParameterizedTestSuiteInfoBase classes accessed by test suite names. TEST_P
+// and INSTANTIATE_TEST_SUITE_P macros use it to locate their corresponding
+// ParameterizedTestSuiteInfo descriptors.
+class ParameterizedTestSuiteRegistry {
+ public:
+  ParameterizedTestSuiteRegistry() {}
+  ~ParameterizedTestSuiteRegistry() {
+    for (auto& test_suite_info : test_suite_infos_) {
+      delete test_suite_info;
+    }
+  }
+
+  // Looks up or creates and returns a structure containing information about
+  // tests and instantiations of a particular test suite.
+  template <class TestSuite>
+  ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder(
+      const char* test_suite_name, CodeLocation code_location) {
+    ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr;
+    for (auto& test_suite_info : test_suite_infos_) {
+      if (test_suite_info->GetTestSuiteName() == test_suite_name) {
+        if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) {
+          // Complain about incorrect usage of Google Test facilities
+          // and terminate the program since we cannot guaranty correct
+          // test suite setup and tear-down in this case.
+          ReportInvalidTestSuiteType(test_suite_name, code_location);
+          posix::Abort();
+        } else {
+          // At this point we are sure that the object we found is of the same
+          // type we are looking for, so we downcast it to that type
+          // without further checks.
+          typed_test_info = CheckedDowncastToActualType<
+              ParameterizedTestSuiteInfo<TestSuite> >(test_suite_info);
+        }
+        break;
+      }
+    }
+    if (typed_test_info == nullptr) {
+      typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>(
+          test_suite_name, code_location);
+      test_suite_infos_.push_back(typed_test_info);
+    }
+    return typed_test_info;
+  }
+  void RegisterTests() {
+    for (auto& test_suite_info : test_suite_infos_) {
+      test_suite_info->RegisterTests();
+    }
+  }
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  template <class TestCase>
+  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
+      const char* test_case_name, CodeLocation code_location) {
+    return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location);
+  }
+
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+ private:
+  using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>;
+
+  TestSuiteInfoContainer test_suite_infos_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteRegistry);
+};
+
+// Keep track of what type-parameterized test suite are defined and
+// where as well as which are intatiated. This allows susequently
+// identifying suits that are defined but never used.
+class TypeParameterizedTestSuiteRegistry {
+ public:
+  // Add a suite definition
+  void RegisterTestSuite(const char* test_suite_name,
+                         CodeLocation code_location);
+
+  // Add an instantiation of a suit.
+  void RegisterInstantiation(const char* test_suite_name);
+
+  // For each suit repored as defined but not reported as instantiation,
+  // emit a test that reports that fact (configurably, as an error).
+  void CheckForInstantiations();
+
+ private:
+  struct TypeParameterizedTestSuiteInfo {
+    explicit TypeParameterizedTestSuiteInfo(CodeLocation c)
+        : code_location(c), instantiated(false) {}
+
+    CodeLocation code_location;
+    bool instantiated;
+  };
+
+  std::map<std::string, TypeParameterizedTestSuiteInfo> suites_;
+};
+
+}  // namespace internal
+
+// Forward declarations of ValuesIn(), which is implemented in
+// include/gtest/gtest-param-test.h.
+template <class Container>
+internal::ParamGenerator<typename Container::value_type> ValuesIn(
+    const Container& container);
+
+namespace internal {
+// Used in the Values() function to provide polymorphic capabilities.
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#endif
+
+template <typename... Ts>
+class ValueArray {
+ public:
+  explicit ValueArray(Ts... v) : v_(FlatTupleConstructTag{}, std::move(v)...) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {  // NOLINT
+    return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>()));
+  }
+
+ private:
+  template <typename T, size_t... I>
+  std::vector<T> MakeVector(IndexSequence<I...>) const {
+    return std::vector<T>{static_cast<T>(v_.template Get<I>())...};
+  }
+
+  FlatTuple<Ts...> v_;
+};
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+template <typename... T>
+class CartesianProductGenerator
+    : public ParamGeneratorInterface<::std::tuple<T...>> {
+ public:
+  typedef ::std::tuple<T...> ParamType;
+
+  CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g)
+      : generators_(g) {}
+  ~CartesianProductGenerator() override {}
+
+  ParamIteratorInterface<ParamType>* Begin() const override {
+    return new Iterator(this, generators_, false);
+  }
+  ParamIteratorInterface<ParamType>* End() const override {
+    return new Iterator(this, generators_, true);
+  }
+
+ private:
+  template <class I>
+  class IteratorImpl;
+  template <size_t... I>
+  class IteratorImpl<IndexSequence<I...>>
+      : public ParamIteratorInterface<ParamType> {
+   public:
+    IteratorImpl(const ParamGeneratorInterface<ParamType>* base,
+             const std::tuple<ParamGenerator<T>...>& generators, bool is_end)
+        : base_(base),
+          begin_(std::get<I>(generators).begin()...),
+          end_(std::get<I>(generators).end()...),
+          current_(is_end ? end_ : begin_) {
+      ComputeCurrentValue();
+    }
+    ~IteratorImpl() override {}
+
+    const ParamGeneratorInterface<ParamType>* BaseGenerator() const override {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    void Advance() override {
+      assert(!AtEnd());
+      // Advance the last iterator.
+      ++std::get<sizeof...(T) - 1>(current_);
+      // if that reaches end, propagate that up.
+      AdvanceIfEnd<sizeof...(T) - 1>();
+      ComputeCurrentValue();
+    }
+    ParamIteratorInterface<ParamType>* Clone() const override {
+      return new IteratorImpl(*this);
+    }
+
+    const ParamType* Current() const override { return current_value_.get(); }
+
+    bool Equals(const ParamIteratorInterface<ParamType>& other) const override {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const IteratorImpl* typed_other =
+          CheckedDowncastToActualType<const IteratorImpl>(&other);
+
+      // We must report iterators equal if they both point beyond their
+      // respective ranges. That can happen in a variety of fashions,
+      // so we have to consult AtEnd().
+      if (AtEnd() && typed_other->AtEnd()) return true;
+
+      bool same = true;
+      bool dummy[] = {
+          (same = same && std::get<I>(current_) ==
+                              std::get<I>(typed_other->current_))...};
+      (void)dummy;
+      return same;
+    }
+
+   private:
+    template <size_t ThisI>
+    void AdvanceIfEnd() {
+      if (std::get<ThisI>(current_) != std::get<ThisI>(end_)) return;
+
+      bool last = ThisI == 0;
+      if (last) {
+        // We are done. Nothing else to propagate.
+        return;
+      }
+
+      constexpr size_t NextI = ThisI - (ThisI != 0);
+      std::get<ThisI>(current_) = std::get<ThisI>(begin_);
+      ++std::get<NextI>(current_);
+      AdvanceIfEnd<NextI>();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = std::make_shared<ParamType>(*std::get<I>(current_)...);
+    }
+    bool AtEnd() const {
+      bool at_end = false;
+      bool dummy[] = {
+          (at_end = at_end || std::get<I>(current_) == std::get<I>(end_))...};
+      (void)dummy;
+      return at_end;
+    }
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    std::tuple<typename ParamGenerator<T>::iterator...> begin_;
+    std::tuple<typename ParamGenerator<T>::iterator...> end_;
+    std::tuple<typename ParamGenerator<T>::iterator...> current_;
+    std::shared_ptr<ParamType> current_value_;
+  };
+
+  using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>;
+
+  std::tuple<ParamGenerator<T>...> generators_;
+};
+
+template <class... Gen>
+class CartesianProductHolder {
+ public:
+  CartesianProductHolder(const Gen&... g) : generators_(g...) {}
+  template <typename... T>
+  operator ParamGenerator<::std::tuple<T...>>() const {
+    return ParamGenerator<::std::tuple<T...>>(
+        new CartesianProductGenerator<T...>(generators_));
+  }
+
+ private:
+  std::tuple<Gen...> generators_;
+};
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+
+namespace testing {
+
+// Functions producing parameter generators.
+//
+// Google Test uses these generators to produce parameters for value-
+// parameterized tests. When a parameterized test suite is instantiated
+// with a particular generator, Google Test creates and runs tests
+// for each element in the sequence produced by the generator.
+//
+// In the following sample, tests from test suite FooTest are instantiated
+// each three times with parameter values 3, 5, and 8:
+//
+// class FooTest : public TestWithParam<int> { ... };
+//
+// TEST_P(FooTest, TestThis) {
+// }
+// TEST_P(FooTest, TestThat) {
+// }
+// INSTANTIATE_TEST_SUITE_P(TestSequence, FooTest, Values(3, 5, 8));
+//
+
+// Range() returns generators providing sequences of values in a range.
+//
+// Synopsis:
+// Range(start, end)
+//   - returns a generator producing a sequence of values {start, start+1,
+//     start+2, ..., }.
+// Range(start, end, step)
+//   - returns a generator producing a sequence of values {start, start+step,
+//     start+step+step, ..., }.
+// Notes:
+//   * The generated sequences never include end. For example, Range(1, 5)
+//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
+//     returns a generator producing {1, 3, 5, 7}.
+//   * start and end must have the same type. That type may be any integral or
+//     floating-point type or a user defined type satisfying these conditions:
+//     * It must be assignable (have operator=() defined).
+//     * It must have operator+() (operator+(int-compatible type) for
+//       two-operand version).
+//     * It must have operator<() defined.
+//     Elements in the resulting sequences will also have that type.
+//   * Condition start < end must be satisfied in order for resulting sequences
+//     to contain any elements.
+//
+template <typename T, typename IncrementT>
+internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
+  return internal::ParamGenerator<T>(
+      new internal::RangeGenerator<T, IncrementT>(start, end, step));
+}
+
+template <typename T>
+internal::ParamGenerator<T> Range(T start, T end) {
+  return Range(start, end, 1);
+}
+
+// ValuesIn() function allows generation of tests with parameters coming from
+// a container.
+//
+// Synopsis:
+// ValuesIn(const T (&array)[N])
+//   - returns a generator producing sequences with elements from
+//     a C-style array.
+// ValuesIn(const Container& container)
+//   - returns a generator producing sequences with elements from
+//     an STL-style container.
+// ValuesIn(Iterator begin, Iterator end)
+//   - returns a generator producing sequences with elements from
+//     a range [begin, end) defined by a pair of STL-style iterators. These
+//     iterators can also be plain C pointers.
+//
+// Please note that ValuesIn copies the values from the containers
+// passed in and keeps them to generate tests in RUN_ALL_TESTS().
+//
+// Examples:
+//
+// This instantiates tests from test suite StringTest
+// each with C-string values of "foo", "bar", and "baz":
+//
+// const char* strings[] = {"foo", "bar", "baz"};
+// INSTANTIATE_TEST_SUITE_P(StringSequence, StringTest, ValuesIn(strings));
+//
+// This instantiates tests from test suite StlStringTest
+// each with STL strings with values "a" and "b":
+//
+// ::std::vector< ::std::string> GetParameterStrings() {
+//   ::std::vector< ::std::string> v;
+//   v.push_back("a");
+//   v.push_back("b");
+//   return v;
+// }
+//
+// INSTANTIATE_TEST_SUITE_P(CharSequence,
+//                          StlStringTest,
+//                          ValuesIn(GetParameterStrings()));
+//
+//
+// This will also instantiate tests from CharTest
+// each with parameter values 'a' and 'b':
+//
+// ::std::list<char> GetParameterChars() {
+//   ::std::list<char> list;
+//   list.push_back('a');
+//   list.push_back('b');
+//   return list;
+// }
+// ::std::list<char> l = GetParameterChars();
+// INSTANTIATE_TEST_SUITE_P(CharSequence2,
+//                          CharTest,
+//                          ValuesIn(l.begin(), l.end()));
+//
+template <typename ForwardIterator>
+internal::ParamGenerator<
+    typename std::iterator_traits<ForwardIterator>::value_type>
+ValuesIn(ForwardIterator begin, ForwardIterator end) {
+  typedef typename std::iterator_traits<ForwardIterator>::value_type ParamType;
+  return internal::ParamGenerator<ParamType>(
+      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
+}
+
+template <typename T, size_t N>
+internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
+  return ValuesIn(array, array + N);
+}
+
+template <class Container>
+internal::ParamGenerator<typename Container::value_type> ValuesIn(
+    const Container& container) {
+  return ValuesIn(container.begin(), container.end());
+}
+
+// Values() allows generating tests from explicitly specified list of
+// parameters.
+//
+// Synopsis:
+// Values(T v1, T v2, ..., T vN)
+//   - returns a generator producing sequences with elements v1, v2, ..., vN.
+//
+// For example, this instantiates tests from test suite BarTest each
+// with values "one", "two", and "three":
+//
+// INSTANTIATE_TEST_SUITE_P(NumSequence,
+//                          BarTest,
+//                          Values("one", "two", "three"));
+//
+// This instantiates tests from test suite BazTest each with values 1, 2, 3.5.
+// The exact type of values will depend on the type of parameter in BazTest.
+//
+// INSTANTIATE_TEST_SUITE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
+//
+//
+template <typename... T>
+internal::ValueArray<T...> Values(T... v) {
+  return internal::ValueArray<T...>(std::move(v)...);
+}
+
+// Bool() allows generating tests with parameters in a set of (false, true).
+//
+// Synopsis:
+// Bool()
+//   - returns a generator producing sequences with elements {false, true}.
+//
+// It is useful when testing code that depends on Boolean flags. Combinations
+// of multiple flags can be tested when several Bool()'s are combined using
+// Combine() function.
+//
+// In the following example all tests in the test suite FlagDependentTest
+// will be instantiated twice with parameters false and true.
+//
+// class FlagDependentTest : public testing::TestWithParam<bool> {
+//   virtual void SetUp() {
+//     external_flag = GetParam();
+//   }
+// }
+// INSTANTIATE_TEST_SUITE_P(BoolSequence, FlagDependentTest, Bool());
+//
+inline internal::ParamGenerator<bool> Bool() {
+  return Values(false, true);
+}
+
+// Combine() allows the user to combine two or more sequences to produce
+// values of a Cartesian product of those sequences' elements.
+//
+// Synopsis:
+// Combine(gen1, gen2, ..., genN)
+//   - returns a generator producing sequences with elements coming from
+//     the Cartesian product of elements from the sequences generated by
+//     gen1, gen2, ..., genN. The sequence elements will have a type of
+//     std::tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
+//     of elements from sequences produces by gen1, gen2, ..., genN.
+//
+// Example:
+//
+// This will instantiate tests in test suite AnimalTest each one with
+// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
+// tuple("dog", BLACK), and tuple("dog", WHITE):
+//
+// enum Color { BLACK, GRAY, WHITE };
+// class AnimalTest
+//     : public testing::TestWithParam<std::tuple<const char*, Color> > {...};
+//
+// TEST_P(AnimalTest, AnimalLooksNice) {...}
+//
+// INSTANTIATE_TEST_SUITE_P(AnimalVariations, AnimalTest,
+//                          Combine(Values("cat", "dog"),
+//                                  Values(BLACK, WHITE)));
+//
+// This will instantiate tests in FlagDependentTest with all variations of two
+// Boolean flags:
+//
+// class FlagDependentTest
+//     : public testing::TestWithParam<std::tuple<bool, bool> > {
+//   virtual void SetUp() {
+//     // Assigns external_flag_1 and external_flag_2 values from the tuple.
+//     std::tie(external_flag_1, external_flag_2) = GetParam();
+//   }
+// };
+//
+// TEST_P(FlagDependentTest, TestFeature1) {
+//   // Test your code using external_flag_1 and external_flag_2 here.
+// }
+// INSTANTIATE_TEST_SUITE_P(TwoBoolSequence, FlagDependentTest,
+//                          Combine(Bool(), Bool()));
+//
+template <typename... Generator>
+internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
+  return internal::CartesianProductHolder<Generator...>(g...);
+}
+
+#define TEST_P(test_suite_name, test_name)                                     \
+  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                     \
+      : public test_suite_name {                                               \
+   public:                                                                     \
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() {}                    \
+    void TestBody() override;                                                  \
+                                                                               \
+   private:                                                                    \
+    static int AddToRegistry() {                                               \
+      ::testing::UnitTest::GetInstance()                                       \
+          ->parameterized_test_registry()                                      \
+          .GetTestSuitePatternHolder<test_suite_name>(                         \
+              GTEST_STRINGIFY_(test_suite_name),                               \
+              ::testing::internal::CodeLocation(__FILE__, __LINE__))           \
+          ->AddTestPattern(                                                    \
+              GTEST_STRINGIFY_(test_suite_name), GTEST_STRINGIFY_(test_name),  \
+              new ::testing::internal::TestMetaFactory<GTEST_TEST_CLASS_NAME_( \
+                  test_suite_name, test_name)>(),                              \
+              ::testing::internal::CodeLocation(__FILE__, __LINE__));          \
+      return 0;                                                                \
+    }                                                                          \
+    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_;               \
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,    \
+                                                           test_name));        \
+  };                                                                           \
+  int GTEST_TEST_CLASS_NAME_(test_suite_name,                                  \
+                             test_name)::gtest_registering_dummy_ =            \
+      GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::AddToRegistry();     \
+  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
+
+// The last argument to INSTANTIATE_TEST_SUITE_P allows the user to specify
+// generator and an optional function or functor that generates custom test name
+// suffixes based on the test parameters. Such a function or functor should
+// accept one argument of type testing::TestParamInfo<class ParamType>, and
+// return std::string.
+//
+// testing::PrintToStringParamName is a builtin test suffix generator that
+// returns the value of testing::PrintToString(GetParam()).
+//
+// Note: test names must be non-empty, unique, and may only contain ASCII
+// alphanumeric characters or underscore. Because PrintToString adds quotes
+// to std::string and C strings, it won't work for these types.
+
+#define GTEST_EXPAND_(arg) arg
+#define GTEST_GET_FIRST_(first, ...) first
+#define GTEST_GET_SECOND_(first, second, ...) second
+
+#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...)                \
+  static ::testing::internal::ParamGenerator<test_suite_name::ParamType>      \
+      gtest_##prefix##test_suite_name##_EvalGenerator_() {                    \
+    return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_));        \
+  }                                                                           \
+  static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_(   \
+      const ::testing::TestParamInfo<test_suite_name::ParamType>& info) {     \
+    if (::testing::internal::AlwaysFalse()) {                                 \
+      ::testing::internal::TestNotEmpty(GTEST_EXPAND_(GTEST_GET_SECOND_(      \
+          __VA_ARGS__,                                                        \
+          ::testing::internal::DefaultParamName<test_suite_name::ParamType>,  \
+          DUMMY_PARAM_)));                                                    \
+      auto t = std::make_tuple(__VA_ARGS__);                                  \
+      static_assert(std::tuple_size<decltype(t)>::value <= 2,                 \
+                    "Too Many Args!");                                        \
+    }                                                                         \
+    return ((GTEST_EXPAND_(GTEST_GET_SECOND_(                                 \
+        __VA_ARGS__,                                                          \
+        ::testing::internal::DefaultParamName<test_suite_name::ParamType>,    \
+        DUMMY_PARAM_))))(info);                                               \
+  }                                                                           \
+  static int gtest_##prefix##test_suite_name##_dummy_                         \
+      GTEST_ATTRIBUTE_UNUSED_ =                                               \
+          ::testing::UnitTest::GetInstance()                                  \
+              ->parameterized_test_registry()                                 \
+              .GetTestSuitePatternHolder<test_suite_name>(                    \
+                  GTEST_STRINGIFY_(test_suite_name),                          \
+                  ::testing::internal::CodeLocation(__FILE__, __LINE__))      \
+              ->AddTestSuiteInstantiation(                                    \
+                  GTEST_STRINGIFY_(prefix),                                   \
+                  &gtest_##prefix##test_suite_name##_EvalGenerator_,          \
+                  &gtest_##prefix##test_suite_name##_EvalGenerateName_,       \
+                  __FILE__, __LINE__)
+
+
+// Allow Marking a Parameterized test class as not needing to be instantiated.
+#define GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(T)                   \
+  namespace gtest_do_not_use_outside_namespace_scope {}                   \
+  static const ::testing::internal::MarkAsIgnored gtest_allow_ignore_##T( \
+      GTEST_STRINGIFY_(T))
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define INSTANTIATE_TEST_CASE_P                                            \
+  static_assert(::testing::internal::InstantiateTestCase_P_IsDeprecated(), \
+                "");                                                       \
+  INSTANTIATE_TEST_SUITE_P
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+// Copyright 2006, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+//
+// Google C++ Testing and Mocking Framework definitions useful in production code.
+// GOOGLETEST_CM0003 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
+
+// When you need to test the private or protected members of a class,
+// use the FRIEND_TEST macro to declare your tests as friends of the
+// class.  For example:
+//
+// class MyClass {
+//  private:
+//   void PrivateMethod();
+//   FRIEND_TEST(MyClassTest, PrivateMethodWorks);
+// };
+//
+// class MyClassTest : public testing::Test {
+//   // ...
+// };
+//
+// TEST_F(MyClassTest, PrivateMethodWorks) {
+//   // Can call MyClass::PrivateMethod() here.
+// }
+//
+// Note: The test class must be in the same namespace as the class being tested.
+// For example, putting MyClassTest in an anonymous namespace will not work.
+
+#define FRIEND_TEST(test_case_name, test_name)\
+friend class test_case_name##_##test_name##_Test
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
+// Copyright 2008 Google Inc.
+// All Rights Reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+
+// This header implements typed tests and type-parameterized tests.
+
+// Typed (aka type-driven) tests repeat the same test for types in a
+// list.  You must know which types you want to test with when writing
+// typed tests. Here's how you do it:
+
+#if 0
+
+// First, define a fixture class template.  It should be parameterized
+// by a type.  Remember to derive it from testing::Test.
+template <typename T>
+class FooTest : public testing::Test {
+ public:
+  ...
+  typedef std::list<T> List;
+  static T shared_;
+  T value_;
+};
+
+// Next, associate a list of types with the test suite, which will be
+// repeated for each type in the list.  The typedef is necessary for
+// the macro to parse correctly.
+typedef testing::Types<char, int, unsigned int> MyTypes;
+TYPED_TEST_SUITE(FooTest, MyTypes);
+
+// If the type list contains only one type, you can write that type
+// directly without Types<...>:
+//   TYPED_TEST_SUITE(FooTest, int);
+
+// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
+// tests for this test suite as you want.
+TYPED_TEST(FooTest, DoesBlah) {
+  // Inside a test, refer to the special name TypeParam to get the type
+  // parameter.  Since we are inside a derived class template, C++ requires
+  // us to visit the members of FooTest via 'this'.
+  TypeParam n = this->value_;
+
+  // To visit static members of the fixture, add the TestFixture::
+  // prefix.
+  n += TestFixture::shared_;
+
+  // To refer to typedefs in the fixture, add the "typename
+  // TestFixture::" prefix.
+  typename TestFixture::List values;
+  values.push_back(n);
+  ...
+}
+
+TYPED_TEST(FooTest, HasPropertyA) { ... }
+
+// TYPED_TEST_SUITE takes an optional third argument which allows to specify a
+// class that generates custom test name suffixes based on the type. This should
+// be a class which has a static template function GetName(int index) returning
+// a string for each type. The provided integer index equals the index of the
+// type in the provided type list. In many cases the index can be ignored.
+//
+// For example:
+//   class MyTypeNames {
+//    public:
+//     template <typename T>
+//     static std::string GetName(int) {
+//       if (std::is_same<T, char>()) return "char";
+//       if (std::is_same<T, int>()) return "int";
+//       if (std::is_same<T, unsigned int>()) return "unsignedInt";
+//     }
+//   };
+//   TYPED_TEST_SUITE(FooTest, MyTypes, MyTypeNames);
+
+#endif  // 0
+
+// Type-parameterized tests are abstract test patterns parameterized
+// by a type.  Compared with typed tests, type-parameterized tests
+// allow you to define the test pattern without knowing what the type
+// parameters are.  The defined pattern can be instantiated with
+// different types any number of times, in any number of translation
+// units.
+//
+// If you are designing an interface or concept, you can define a
+// suite of type-parameterized tests to verify properties that any
+// valid implementation of the interface/concept should have.  Then,
+// each implementation can easily instantiate the test suite to verify
+// that it conforms to the requirements, without having to write
+// similar tests repeatedly.  Here's an example:
+
+#if 0
+
+// First, define a fixture class template.  It should be parameterized
+// by a type.  Remember to derive it from testing::Test.
+template <typename T>
+class FooTest : public testing::Test {
+  ...
+};
+
+// Next, declare that you will define a type-parameterized test suite
+// (the _P suffix is for "parameterized" or "pattern", whichever you
+// prefer):
+TYPED_TEST_SUITE_P(FooTest);
+
+// Then, use TYPED_TEST_P() to define as many type-parameterized tests
+// for this type-parameterized test suite as you want.
+TYPED_TEST_P(FooTest, DoesBlah) {
+  // Inside a test, refer to TypeParam to get the type parameter.
+  TypeParam n = 0;
+  ...
+}
+
+TYPED_TEST_P(FooTest, HasPropertyA) { ... }
+
+// Now the tricky part: you need to register all test patterns before
+// you can instantiate them.  The first argument of the macro is the
+// test suite name; the rest are the names of the tests in this test
+// case.
+REGISTER_TYPED_TEST_SUITE_P(FooTest,
+                            DoesBlah, HasPropertyA);
+
+// Finally, you are free to instantiate the pattern with the types you
+// want.  If you put the above code in a header file, you can #include
+// it in multiple C++ source files and instantiate it multiple times.
+//
+// To distinguish different instances of the pattern, the first
+// argument to the INSTANTIATE_* macro is a prefix that will be added
+// to the actual test suite name.  Remember to pick unique prefixes for
+// different instances.
+typedef testing::Types<char, int, unsigned int> MyTypes;
+INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
+
+// If the type list contains only one type, you can write that type
+// directly without Types<...>:
+//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, int);
+//
+// Similar to the optional argument of TYPED_TEST_SUITE above,
+// INSTANTIATE_TEST_SUITE_P takes an optional fourth argument which allows to
+// generate custom names.
+//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes, MyTypeNames);
+
+#endif  // 0
+
+
+// Implements typed tests.
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the name of the typedef for the type parameters of the
+// given test suite.
+#define GTEST_TYPE_PARAMS_(TestSuiteName) gtest_type_params_##TestSuiteName##_
+
+// Expands to the name of the typedef for the NameGenerator, responsible for
+// creating the suffixes of the name.
+#define GTEST_NAME_GENERATOR_(TestSuiteName) \
+  gtest_type_params_##TestSuiteName##_NameGenerator
+
+#define TYPED_TEST_SUITE(CaseName, Types, ...)                          \
+  typedef ::testing::internal::GenerateTypeList<Types>::type            \
+      GTEST_TYPE_PARAMS_(CaseName);                                     \
+  typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type \
+      GTEST_NAME_GENERATOR_(CaseName)
+
+#define TYPED_TEST(CaseName, TestName)                                        \
+  static_assert(sizeof(GTEST_STRINGIFY_(TestName)) > 1,                       \
+                "test-name must not be empty");                               \
+  template <typename gtest_TypeParam_>                                        \
+  class GTEST_TEST_CLASS_NAME_(CaseName, TestName)                            \
+      : public CaseName<gtest_TypeParam_> {                                   \
+   private:                                                                   \
+    typedef CaseName<gtest_TypeParam_> TestFixture;                           \
+    typedef gtest_TypeParam_ TypeParam;                                       \
+    void TestBody() override;                                                 \
+  };                                                                          \
+  static bool gtest_##CaseName##_##TestName##_registered_                     \
+      GTEST_ATTRIBUTE_UNUSED_ = ::testing::internal::TypeParameterizedTest<   \
+          CaseName,                                                           \
+          ::testing::internal::TemplateSel<GTEST_TEST_CLASS_NAME_(CaseName,   \
+                                                                  TestName)>, \
+          GTEST_TYPE_PARAMS_(                                                 \
+              CaseName)>::Register("",                                        \
+                                   ::testing::internal::CodeLocation(         \
+                                       __FILE__, __LINE__),                   \
+                                   GTEST_STRINGIFY_(CaseName),                \
+                                   GTEST_STRINGIFY_(TestName), 0,             \
+                                   ::testing::internal::GenerateNames<        \
+                                       GTEST_NAME_GENERATOR_(CaseName),       \
+                                       GTEST_TYPE_PARAMS_(CaseName)>());      \
+  template <typename gtest_TypeParam_>                                        \
+  void GTEST_TEST_CLASS_NAME_(CaseName,                                       \
+                              TestName)<gtest_TypeParam_>::TestBody()
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define TYPED_TEST_CASE                                                \
+  static_assert(::testing::internal::TypedTestCaseIsDeprecated(), ""); \
+  TYPED_TEST_SUITE
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+// Implements type-parameterized tests.
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the namespace name that the type-parameterized tests for
+// the given type-parameterized test suite are defined in.  The exact
+// name of the namespace is subject to change without notice.
+#define GTEST_SUITE_NAMESPACE_(TestSuiteName) gtest_suite_##TestSuiteName##_
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the name of the variable used to remember the names of
+// the defined tests in the given test suite.
+#define GTEST_TYPED_TEST_SUITE_P_STATE_(TestSuiteName) \
+  gtest_typed_test_suite_p_state_##TestSuiteName##_
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
+//
+// Expands to the name of the variable used to remember the names of
+// the registered tests in the given test suite.
+#define GTEST_REGISTERED_TEST_NAMES_(TestSuiteName) \
+  gtest_registered_test_names_##TestSuiteName##_
+
+// The variables defined in the type-parameterized test macros are
+// static as typically these macros are used in a .h file that can be
+// #included in multiple translation units linked together.
+#define TYPED_TEST_SUITE_P(SuiteName)              \
+  static ::testing::internal::TypedTestSuitePState \
+      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName)
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define TYPED_TEST_CASE_P                                                 \
+  static_assert(::testing::internal::TypedTestCase_P_IsDeprecated(), ""); \
+  TYPED_TEST_SUITE_P
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+#define TYPED_TEST_P(SuiteName, TestName)                             \
+  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                       \
+    template <typename gtest_TypeParam_>                              \
+    class TestName : public SuiteName<gtest_TypeParam_> {             \
+     private:                                                         \
+      typedef SuiteName<gtest_TypeParam_> TestFixture;                \
+      typedef gtest_TypeParam_ TypeParam;                             \
+      void TestBody() override;                                       \
+    };                                                                \
+    static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
+        GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName(       \
+            __FILE__, __LINE__, GTEST_STRINGIFY_(SuiteName),          \
+            GTEST_STRINGIFY_(TestName));                              \
+  }                                                                   \
+  template <typename gtest_TypeParam_>                                \
+  void GTEST_SUITE_NAMESPACE_(                                        \
+      SuiteName)::TestName<gtest_TypeParam_>::TestBody()
+
+// Note: this won't work correctly if the trailing arguments are macros.
+#define REGISTER_TYPED_TEST_SUITE_P(SuiteName, ...)                         \
+  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                             \
+    typedef ::testing::internal::Templates<__VA_ARGS__> gtest_AllTests_;    \
+  }                                                                         \
+  static const char* const GTEST_REGISTERED_TEST_NAMES_(                    \
+      SuiteName) GTEST_ATTRIBUTE_UNUSED_ =                                  \
+      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).VerifyRegisteredTestNames( \
+          GTEST_STRINGIFY_(SuiteName), __FILE__, __LINE__, #__VA_ARGS__)
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define REGISTER_TYPED_TEST_CASE_P                                           \
+  static_assert(::testing::internal::RegisterTypedTestCase_P_IsDeprecated(), \
+                "");                                                         \
+  REGISTER_TYPED_TEST_SUITE_P
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+#define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...)       \
+  static_assert(sizeof(GTEST_STRINGIFY_(Prefix)) > 1,                       \
+                "test-suit-prefix must not be empty");                      \
+  static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ =        \
+      ::testing::internal::TypeParameterizedTestSuite<                      \
+          SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_,    \
+          ::testing::internal::GenerateTypeList<Types>::type>::             \
+          Register(GTEST_STRINGIFY_(Prefix),                                \
+                   ::testing::internal::CodeLocation(__FILE__, __LINE__),   \
+                   &GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName),             \
+                   GTEST_STRINGIFY_(SuiteName),                             \
+                   GTEST_REGISTERED_TEST_NAMES_(SuiteName),                 \
+                   ::testing::internal::GenerateNames<                      \
+                       ::testing::internal::NameGeneratorSelector<          \
+                           __VA_ARGS__>::type,                              \
+                       ::testing::internal::GenerateTypeList<Types>::type>())
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define INSTANTIATE_TYPED_TEST_CASE_P                                      \
+  static_assert(                                                           \
+      ::testing::internal::InstantiateTypedTestCase_P_IsDeprecated(), ""); \
+  INSTANTIATE_TYPED_TEST_SUITE_P
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// Silence C4100 (unreferenced formal parameter) and 4805
+// unsafe mix of type 'const int' and type 'const bool'
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4805)
+# pragma warning(disable:4100)
+#endif
+
+
+// Declares the flags.
+
+// This flag temporary enables the disabled tests.
+GTEST_DECLARE_bool_(also_run_disabled_tests);
+
+// This flag brings the debugger on an assertion failure.
+GTEST_DECLARE_bool_(break_on_failure);
+
+// This flag controls whether Google Test catches all test-thrown exceptions
+// and logs them as failures.
+GTEST_DECLARE_bool_(catch_exceptions);
+
+// This flag enables using colors in terminal output. Available values are
+// "yes" to enable colors, "no" (disable colors), or "auto" (the default)
+// to let Google Test decide.
+GTEST_DECLARE_string_(color);
+
+// This flag controls whether the test runner should continue execution past
+// first failure.
+GTEST_DECLARE_bool_(fail_fast);
+
+// This flag sets up the filter to select by name using a glob pattern
+// the tests to run. If the filter is not given all tests are executed.
+GTEST_DECLARE_string_(filter);
+
+// This flag controls whether Google Test installs a signal handler that dumps
+// debugging information when fatal signals are raised.
+GTEST_DECLARE_bool_(install_failure_signal_handler);
+
+// This flag causes the Google Test to list tests. None of the tests listed
+// are actually run if the flag is provided.
+GTEST_DECLARE_bool_(list_tests);
+
+// This flag controls whether Google Test emits a detailed XML report to a file
+// in addition to its normal textual output.
+GTEST_DECLARE_string_(output);
+
+// This flags control whether Google Test prints only test failures.
+GTEST_DECLARE_bool_(brief);
+
+// This flags control whether Google Test prints the elapsed time for each
+// test.
+GTEST_DECLARE_bool_(print_time);
+
+// This flags control whether Google Test prints UTF8 characters as text.
+GTEST_DECLARE_bool_(print_utf8);
+
+// This flag specifies the random number seed.
+GTEST_DECLARE_int32_(random_seed);
+
+// This flag sets how many times the tests are repeated. The default value
+// is 1. If the value is -1 the tests are repeating forever.
+GTEST_DECLARE_int32_(repeat);
+
+// This flag controls whether Google Test includes Google Test internal
+// stack frames in failure stack traces.
+GTEST_DECLARE_bool_(show_internal_stack_frames);
+
+// When this flag is specified, tests' order is randomized on every iteration.
+GTEST_DECLARE_bool_(shuffle);
+
+// This flag specifies the maximum number of stack frames to be
+// printed in a failure message.
+GTEST_DECLARE_int32_(stack_trace_depth);
+
+// When this flag is specified, a failed assertion will throw an
+// exception if exceptions are enabled, or exit the program with a
+// non-zero code otherwise. For use with an external test framework.
+GTEST_DECLARE_bool_(throw_on_failure);
+
+// When this flag is set with a "host:port" string, on supported
+// platforms test results are streamed to the specified port on
+// the specified host machine.
+GTEST_DECLARE_string_(stream_result_to);
+
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+GTEST_DECLARE_string_(flagfile);
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+
+// The upper limit for valid stack trace depths.
+const int kMaxStackTraceDepth = 100;
+
+namespace internal {
+
+class AssertHelper;
+class DefaultGlobalTestPartResultReporter;
+class ExecDeathTest;
+class NoExecDeathTest;
+class FinalSuccessChecker;
+class GTestFlagSaver;
+class StreamingListenerTest;
+class TestResultAccessor;
+class TestEventListenersAccessor;
+class TestEventRepeater;
+class UnitTestRecordPropertyTestHelper;
+class WindowsDeathTest;
+class FuchsiaDeathTest;
+class UnitTestImpl* GetUnitTestImpl();
+void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
+                                    const std::string& message);
+std::set<std::string>* GetIgnoredParameterizedTestSuites();
+
+}  // namespace internal
+
+// The friend relationship of some of these classes is cyclic.
+// If we don't forward declare them the compiler might confuse the classes
+// in friendship clauses with same named classes on the scope.
+class Test;
+class TestSuite;
+
+// Old API is still available but deprecated
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+using TestCase = TestSuite;
+#endif
+class TestInfo;
+class UnitTest;
+
+// A class for indicating whether an assertion was successful.  When
+// the assertion wasn't successful, the AssertionResult object
+// remembers a non-empty message that describes how it failed.
+//
+// To create an instance of this class, use one of the factory functions
+// (AssertionSuccess() and AssertionFailure()).
+//
+// This class is useful for two purposes:
+//   1. Defining predicate functions to be used with Boolean test assertions
+//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
+//   2. Defining predicate-format functions to be
+//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
+//
+// For example, if you define IsEven predicate:
+//
+//   testing::AssertionResult IsEven(int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess();
+//     else
+//       return testing::AssertionFailure() << n << " is odd";
+//   }
+//
+// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
+// will print the message
+//
+//   Value of: IsEven(Fib(5))
+//     Actual: false (5 is odd)
+//   Expected: true
+//
+// instead of a more opaque
+//
+//   Value of: IsEven(Fib(5))
+//     Actual: false
+//   Expected: true
+//
+// in case IsEven is a simple Boolean predicate.
+//
+// If you expect your predicate to be reused and want to support informative
+// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
+// about half as often as positive ones in our tests), supply messages for
+// both success and failure cases:
+//
+//   testing::AssertionResult IsEven(int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess() << n << " is even";
+//     else
+//       return testing::AssertionFailure() << n << " is odd";
+//   }
+//
+// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
+//
+//   Value of: IsEven(Fib(6))
+//     Actual: true (8 is even)
+//   Expected: false
+//
+// NB: Predicates that support negative Boolean assertions have reduced
+// performance in positive ones so be careful not to use them in tests
+// that have lots (tens of thousands) of positive Boolean assertions.
+//
+// To use this class with EXPECT_PRED_FORMAT assertions such as:
+//
+//   // Verifies that Foo() returns an even number.
+//   EXPECT_PRED_FORMAT1(IsEven, Foo());
+//
+// you need to define:
+//
+//   testing::AssertionResult IsEven(const char* expr, int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess();
+//     else
+//       return testing::AssertionFailure()
+//         << "Expected: " << expr << " is even\n  Actual: it's " << n;
+//   }
+//
+// If Foo() returns 5, you will see the following message:
+//
+//   Expected: Foo() is even
+//     Actual: it's 5
+//
+class GTEST_API_ AssertionResult {
+ public:
+  // Copy constructor.
+  // Used in EXPECT_TRUE/FALSE(assertion_result).
+  AssertionResult(const AssertionResult& other);
+
+// C4800 is a level 3 warning in Visual Studio 2015 and earlier.
+// This warning is not emitted in Visual Studio 2017.
+// This warning is off by default starting in Visual Studio 2019 but can be
+// enabled with command-line options.
+#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
+#endif
+
+  // Used in the EXPECT_TRUE/FALSE(bool_expression).
+  //
+  // T must be contextually convertible to bool.
+  //
+  // The second parameter prevents this overload from being considered if
+  // the argument is implicitly convertible to AssertionResult. In that case
+  // we want AssertionResult's copy constructor to be used.
+  template <typename T>
+  explicit AssertionResult(
+      const T& success,
+      typename std::enable_if<
+          !std::is_convertible<T, AssertionResult>::value>::type*
+      /*enabler*/
+      = nullptr)
+      : success_(success) {}
+
+#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif
+
+  // Assignment operator.
+  AssertionResult& operator=(AssertionResult other) {
+    swap(other);
+    return *this;
+  }
+
+  // Returns true if and only if the assertion succeeded.
+  operator bool() const { return success_; }  // NOLINT
+
+  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
+  AssertionResult operator!() const;
+
+  // Returns the text streamed into this AssertionResult. Test assertions
+  // use it when they fail (i.e., the predicate's outcome doesn't match the
+  // assertion's expectation). When nothing has been streamed into the
+  // object, returns an empty string.
+  const char* message() const {
+    return message_.get() != nullptr ? message_->c_str() : "";
+  }
+  // Deprecated; please use message() instead.
+  const char* failure_message() const { return message(); }
+
+  // Streams a custom failure message into this object.
+  template <typename T> AssertionResult& operator<<(const T& value) {
+    AppendMessage(Message() << value);
+    return *this;
+  }
+
+  // Allows streaming basic output manipulators such as endl or flush into
+  // this object.
+  AssertionResult& operator<<(
+      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
+    AppendMessage(Message() << basic_manipulator);
+    return *this;
+  }
+
+ private:
+  // Appends the contents of message to message_.
+  void AppendMessage(const Message& a_message) {
+    if (message_.get() == nullptr) message_.reset(new ::std::string);
+    message_->append(a_message.GetString().c_str());
+  }
+
+  // Swap the contents of this AssertionResult with other.
+  void swap(AssertionResult& other);
+
+  // Stores result of the assertion predicate.
+  bool success_;
+  // Stores the message describing the condition in case the expectation
+  // construct is not satisfied with the predicate's outcome.
+  // Referenced via a pointer to avoid taking too much stack frame space
+  // with test assertions.
+  std::unique_ptr< ::std::string> message_;
+};
+
+// Makes a successful assertion result.
+GTEST_API_ AssertionResult AssertionSuccess();
+
+// Makes a failed assertion result.
+GTEST_API_ AssertionResult AssertionFailure();
+
+// Makes a failed assertion result with the given failure message.
+// Deprecated; use AssertionFailure() << msg.
+GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
+
+}  // namespace testing
+
+// Includes the auto-generated header that implements a family of generic
+// predicate assertion macros. This include comes late because it relies on
+// APIs declared above.
+// Copyright 2006, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file is AUTOMATICALLY GENERATED on 01/02/2019 by command
+// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
+//
+// Implements a family of generic predicate assertion macros.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+
+
+namespace testing {
+
+// This header implements a family of generic predicate assertion
+// macros:
+//
+//   ASSERT_PRED_FORMAT1(pred_format, v1)
+//   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
+//   ...
+//
+// where pred_format is a function or functor that takes n (in the
+// case of ASSERT_PRED_FORMATn) values and their source expression
+// text, and returns a testing::AssertionResult.  See the definition
+// of ASSERT_EQ in gtest.h for an example.
+//
+// If you don't care about formatting, you can use the more
+// restrictive version:
+//
+//   ASSERT_PRED1(pred, v1)
+//   ASSERT_PRED2(pred, v1, v2)
+//   ...
+//
+// where pred is an n-ary function or functor that returns bool,
+// and the values v1, v2, ..., must support the << operator for
+// streaming to std::ostream.
+//
+// We also define the EXPECT_* variations.
+//
+// For now we only support predicates whose arity is at most 5.
+// Please email googletestframework@googlegroups.com if you need
+// support for higher arities.
+
+// GTEST_ASSERT_ is the basic statement to which all of the assertions
+// in this file reduce.  Don't use this in your code.
+
+#define GTEST_ASSERT_(expression, on_failure) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (const ::testing::AssertionResult gtest_ar = (expression)) \
+    ; \
+  else \
+    on_failure(gtest_ar.failure_message())
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1>
+AssertionResult AssertPred1Helper(const char* pred_text,
+                                  const char* e1,
+                                  Pred pred,
+                                  const T1& v1) {
+  if (pred(v1)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, v1), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
+// this in your code.
+#define GTEST_PRED1_(pred, v1, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
+                                             #v1, \
+                                             pred, \
+                                             v1), on_failure)
+
+// Unary predicate assertion macros.
+#define EXPECT_PRED_FORMAT1(pred_format, v1) \
+  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED1(pred, v1) \
+  GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT1(pred_format, v1) \
+  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED1(pred, v1) \
+  GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2>
+AssertionResult AssertPred2Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2) {
+  if (pred(v1, v2)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ", " << e2
+         << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
+         << e2 << " evaluates to " << ::testing::PrintToString(v2);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
+// this in your code.
+#define GTEST_PRED2_(pred, v1, v2, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             pred, \
+                                             v1, \
+                                             v2), on_failure)
+
+// Binary predicate assertion macros.
+#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
+  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED2(pred, v1, v2) \
+  GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
+  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED2(pred, v1, v2) \
+  GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3>
+AssertionResult AssertPred3Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3) {
+  if (pred(v1, v2, v3)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ", " << e2 << ", " << e3
+         << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
+         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
+         << e3 << " evaluates to " << ::testing::PrintToString(v3);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
+// this in your code.
+#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3), on_failure)
+
+// Ternary predicate assertion macros.
+#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
+  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED3(pred, v1, v2, v3) \
+  GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
+  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED3(pred, v1, v2, v3) \
+  GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4>
+AssertionResult AssertPred4Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  const char* e4,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3,
+                                  const T4& v4) {
+  if (pred(v1, v2, v3, v4)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
+         << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
+         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
+         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
+         << e4 << " evaluates to " << ::testing::PrintToString(v4);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
+// this in your code.
+#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             #v4, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3, \
+                                             v4), on_failure)
+
+// 4-ary predicate assertion macros.
+#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
+  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED4(pred, v1, v2, v3, v4) \
+  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
+  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED4(pred, v1, v2, v3, v4) \
+  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5>
+AssertionResult AssertPred5Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  const char* e4,
+                                  const char* e5,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3,
+                                  const T4& v4,
+                                  const T5& v5) {
+  if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
+         << ", " << e5 << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
+         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
+         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
+         << e4 << " evaluates to " << ::testing::PrintToString(v4) << "\n"
+         << e5 << " evaluates to " << ::testing::PrintToString(v5);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
+// this in your code.
+#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             #v4, \
+                                             #v5, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3, \
+                                             v4, \
+                                             v5), on_failure)
+
+// 5-ary predicate assertion macros.
+#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
+  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
+  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
+  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
+  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
+
+
+
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+
+namespace testing {
+
+// The abstract class that all tests inherit from.
+//
+// In Google Test, a unit test program contains one or many TestSuites, and
+// each TestSuite contains one or many Tests.
+//
+// When you define a test using the TEST macro, you don't need to
+// explicitly derive from Test - the TEST macro automatically does
+// this for you.
+//
+// The only time you derive from Test is when defining a test fixture
+// to be used in a TEST_F.  For example:
+//
+//   class FooTest : public testing::Test {
+//    protected:
+//     void SetUp() override { ... }
+//     void TearDown() override { ... }
+//     ...
+//   };
+//
+//   TEST_F(FooTest, Bar) { ... }
+//   TEST_F(FooTest, Baz) { ... }
+//
+// Test is not copyable.
+class GTEST_API_ Test {
+ public:
+  friend class TestInfo;
+
+  // The d'tor is virtual as we intend to inherit from Test.
+  virtual ~Test();
+
+  // Sets up the stuff shared by all tests in this test suite.
+  //
+  // Google Test will call Foo::SetUpTestSuite() before running the first
+  // test in test suite Foo.  Hence a sub-class can define its own
+  // SetUpTestSuite() method to shadow the one defined in the super
+  // class.
+  static void SetUpTestSuite() {}
+
+  // Tears down the stuff shared by all tests in this test suite.
+  //
+  // Google Test will call Foo::TearDownTestSuite() after running the last
+  // test in test suite Foo.  Hence a sub-class can define its own
+  // TearDownTestSuite() method to shadow the one defined in the super
+  // class.
+  static void TearDownTestSuite() {}
+
+  // Legacy API is deprecated but still available. Use SetUpTestSuite and
+  // TearDownTestSuite instead.
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  static void TearDownTestCase() {}
+  static void SetUpTestCase() {}
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Returns true if and only if the current test has a fatal failure.
+  static bool HasFatalFailure();
+
+  // Returns true if and only if the current test has a non-fatal failure.
+  static bool HasNonfatalFailure();
+
+  // Returns true if and only if the current test was skipped.
+  static bool IsSkipped();
+
+  // Returns true if and only if the current test has a (either fatal or
+  // non-fatal) failure.
+  static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
+
+  // Logs a property for the current test, test suite, or for the entire
+  // invocation of the test program when used outside of the context of a
+  // test suite.  Only the last value for a given key is remembered.  These
+  // are public static so they can be called from utility functions that are
+  // not members of the test fixture.  Calls to RecordProperty made during
+  // lifespan of the test (from the moment its constructor starts to the
+  // moment its destructor finishes) will be output in XML as attributes of
+  // the <testcase> element.  Properties recorded from fixture's
+  // SetUpTestSuite or TearDownTestSuite are logged as attributes of the
+  // corresponding <testsuite> element.  Calls to RecordProperty made in the
+  // global context (before or after invocation of RUN_ALL_TESTS and from
+  // SetUp/TearDown method of Environment objects registered with Google
+  // Test) will be output as attributes of the <testsuites> element.
+  static void RecordProperty(const std::string& key, const std::string& value);
+  static void RecordProperty(const std::string& key, int value);
+
+ protected:
+  // Creates a Test object.
+  Test();
+
+  // Sets up the test fixture.
+  virtual void SetUp();
+
+  // Tears down the test fixture.
+  virtual void TearDown();
+
+ private:
+  // Returns true if and only if the current test has the same fixture class
+  // as the first test in the current test suite.
+  static bool HasSameFixtureClass();
+
+  // Runs the test after the test fixture has been set up.
+  //
+  // A sub-class must implement this to define the test logic.
+  //
+  // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
+  // Instead, use the TEST or TEST_F macro.
+  virtual void TestBody() = 0;
+
+  // Sets up, executes, and tears down the test.
+  void Run();
+
+  // Deletes self.  We deliberately pick an unusual name for this
+  // internal method to avoid clashing with names used in user TESTs.
+  void DeleteSelf_() { delete this; }
+
+  const std::unique_ptr<GTEST_FLAG_SAVER_> gtest_flag_saver_;
+
+  // Often a user misspells SetUp() as Setup() and spends a long time
+  // wondering why it is never called by Google Test.  The declaration of
+  // the following method is solely for catching such an error at
+  // compile time:
+  //
+  //   - The return type is deliberately chosen to be not void, so it
+  //   will be a conflict if void Setup() is declared in the user's
+  //   test fixture.
+  //
+  //   - This method is private, so it will be another compiler error
+  //   if the method is called from the user's test fixture.
+  //
+  // DO NOT OVERRIDE THIS FUNCTION.
+  //
+  // If you see an error about overriding the following function or
+  // about it being private, you have mis-spelled SetUp() as Setup().
+  struct Setup_should_be_spelled_SetUp {};
+  virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
+
+  // We disallow copying Tests.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
+};
+
+typedef internal::TimeInMillis TimeInMillis;
+
+// A copyable object representing a user specified test property which can be
+// output as a key/value string pair.
+//
+// Don't inherit from TestProperty as its destructor is not virtual.
+class TestProperty {
+ public:
+  // C'tor.  TestProperty does NOT have a default constructor.
+  // Always use this constructor (with parameters) to create a
+  // TestProperty object.
+  TestProperty(const std::string& a_key, const std::string& a_value) :
+    key_(a_key), value_(a_value) {
+  }
+
+  // Gets the user supplied key.
+  const char* key() const {
+    return key_.c_str();
+  }
+
+  // Gets the user supplied value.
+  const char* value() const {
+    return value_.c_str();
+  }
+
+  // Sets a new value, overriding the one supplied in the constructor.
+  void SetValue(const std::string& new_value) {
+    value_ = new_value;
+  }
+
+ private:
+  // The key supplied by the user.
+  std::string key_;
+  // The value supplied by the user.
+  std::string value_;
+};
+
+// The result of a single Test.  This includes a list of
+// TestPartResults, a list of TestProperties, a count of how many
+// death tests there are in the Test, and how much time it took to run
+// the Test.
+//
+// TestResult is not copyable.
+class GTEST_API_ TestResult {
+ public:
+  // Creates an empty TestResult.
+  TestResult();
+
+  // D'tor.  Do not inherit from TestResult.
+  ~TestResult();
+
+  // Gets the number of all test parts.  This is the sum of the number
+  // of successful test parts and the number of failed test parts.
+  int total_part_count() const;
+
+  // Returns the number of the test properties.
+  int test_property_count() const;
+
+  // Returns true if and only if the test passed (i.e. no test part failed).
+  bool Passed() const { return !Skipped() && !Failed(); }
+
+  // Returns true if and only if the test was skipped.
+  bool Skipped() const;
+
+  // Returns true if and only if the test failed.
+  bool Failed() const;
+
+  // Returns true if and only if the test fatally failed.
+  bool HasFatalFailure() const;
+
+  // Returns true if and only if the test has a non-fatal failure.
+  bool HasNonfatalFailure() const;
+
+  // Returns the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Gets the time of the test case start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const { return start_timestamp_; }
+
+  // Returns the i-th test part result among all the results. i can range from 0
+  // to total_part_count() - 1. If i is not in that range, aborts the program.
+  const TestPartResult& GetTestPartResult(int i) const;
+
+  // Returns the i-th test property. i can range from 0 to
+  // test_property_count() - 1. If i is not in that range, aborts the
+  // program.
+  const TestProperty& GetTestProperty(int i) const;
+
+ private:
+  friend class TestInfo;
+  friend class TestSuite;
+  friend class UnitTest;
+  friend class internal::DefaultGlobalTestPartResultReporter;
+  friend class internal::ExecDeathTest;
+  friend class internal::TestResultAccessor;
+  friend class internal::UnitTestImpl;
+  friend class internal::WindowsDeathTest;
+  friend class internal::FuchsiaDeathTest;
+
+  // Gets the vector of TestPartResults.
+  const std::vector<TestPartResult>& test_part_results() const {
+    return test_part_results_;
+  }
+
+  // Gets the vector of TestProperties.
+  const std::vector<TestProperty>& test_properties() const {
+    return test_properties_;
+  }
+
+  // Sets the start time.
+  void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; }
+
+  // Sets the elapsed time.
+  void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
+
+  // Adds a test property to the list. The property is validated and may add
+  // a non-fatal failure if invalid (e.g., if it conflicts with reserved
+  // key names). If a property is already recorded for the same key, the
+  // value will be updated, rather than storing multiple values for the same
+  // key.  xml_element specifies the element for which the property is being
+  // recorded and is used for validation.
+  void RecordProperty(const std::string& xml_element,
+                      const TestProperty& test_property);
+
+  // Adds a failure if the key is a reserved attribute of Google Test
+  // testsuite tags.  Returns true if the property is valid.
+  // FIXME: Validate attribute names are legal and human readable.
+  static bool ValidateTestProperty(const std::string& xml_element,
+                                   const TestProperty& test_property);
+
+  // Adds a test part result to the list.
+  void AddTestPartResult(const TestPartResult& test_part_result);
+
+  // Returns the death test count.
+  int death_test_count() const { return death_test_count_; }
+
+  // Increments the death test count, returning the new count.
+  int increment_death_test_count() { return ++death_test_count_; }
+
+  // Clears the test part results.
+  void ClearTestPartResults();
+
+  // Clears the object.
+  void Clear();
+
+  // Protects mutable state of the property vector and of owned
+  // properties, whose values may be updated.
+  internal::Mutex test_properties_mutex_;
+
+  // The vector of TestPartResults
+  std::vector<TestPartResult> test_part_results_;
+  // The vector of TestProperties
+  std::vector<TestProperty> test_properties_;
+  // Running count of death tests.
+  int death_test_count_;
+  // The start time, in milliseconds since UNIX Epoch.
+  TimeInMillis start_timestamp_;
+  // The elapsed time, in milliseconds.
+  TimeInMillis elapsed_time_;
+
+  // We disallow copying TestResult.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
+};  // class TestResult
+
+// A TestInfo object stores the following information about a test:
+//
+//   Test suite name
+//   Test name
+//   Whether the test should be run
+//   A function pointer that creates the test object when invoked
+//   Test result
+//
+// The constructor of TestInfo registers itself with the UnitTest
+// singleton such that the RUN_ALL_TESTS() macro knows which tests to
+// run.
+class GTEST_API_ TestInfo {
+ public:
+  // Destructs a TestInfo object.  This function is not virtual, so
+  // don't inherit from TestInfo.
+  ~TestInfo();
+
+  // Returns the test suite name.
+  const char* test_suite_name() const { return test_suite_name_.c_str(); }
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  const char* test_case_name() const { return test_suite_name(); }
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Returns the test name.
+  const char* name() const { return name_.c_str(); }
+
+  // Returns the name of the parameter type, or NULL if this is not a typed
+  // or a type-parameterized test.
+  const char* type_param() const {
+    if (type_param_.get() != nullptr) return type_param_->c_str();
+    return nullptr;
+  }
+
+  // Returns the text representation of the value parameter, or NULL if this
+  // is not a value-parameterized test.
+  const char* value_param() const {
+    if (value_param_.get() != nullptr) return value_param_->c_str();
+    return nullptr;
+  }
+
+  // Returns the file name where this test is defined.
+  const char* file() const { return location_.file.c_str(); }
+
+  // Returns the line where this test is defined.
+  int line() const { return location_.line; }
+
+  // Return true if this test should not be run because it's in another shard.
+  bool is_in_another_shard() const { return is_in_another_shard_; }
+
+  // Returns true if this test should run, that is if the test is not
+  // disabled (or it is disabled but the also_run_disabled_tests flag has
+  // been specified) and its full name matches the user-specified filter.
+  //
+  // Google Test allows the user to filter the tests by their full names.
+  // The full name of a test Bar in test suite Foo is defined as
+  // "Foo.Bar".  Only the tests that match the filter will run.
+  //
+  // A filter is a colon-separated list of glob (not regex) patterns,
+  // optionally followed by a '-' and a colon-separated list of
+  // negative patterns (tests to exclude).  A test is run if it
+  // matches one of the positive patterns and does not match any of
+  // the negative patterns.
+  //
+  // For example, *A*:Foo.* is a filter that matches any string that
+  // contains the character 'A' or starts with "Foo.".
+  bool should_run() const { return should_run_; }
+
+  // Returns true if and only if this test will appear in the XML report.
+  bool is_reportable() const {
+    // The XML report includes tests matching the filter, excluding those
+    // run in other shards.
+    return matches_filter_ && !is_in_another_shard_;
+  }
+
+  // Returns the result of the test.
+  const TestResult* result() const { return &result_; }
+
+ private:
+#if GTEST_HAS_DEATH_TEST
+  friend class internal::DefaultDeathTestFactory;
+#endif  // GTEST_HAS_DEATH_TEST
+  friend class Test;
+  friend class TestSuite;
+  friend class internal::UnitTestImpl;
+  friend class internal::StreamingListenerTest;
+  friend TestInfo* internal::MakeAndRegisterTestInfo(
+      const char* test_suite_name, const char* name, const char* type_param,
+      const char* value_param, internal::CodeLocation code_location,
+      internal::TypeId fixture_class_id, internal::SetUpTestSuiteFunc set_up_tc,
+      internal::TearDownTestSuiteFunc tear_down_tc,
+      internal::TestFactoryBase* factory);
+
+  // Constructs a TestInfo object. The newly constructed instance assumes
+  // ownership of the factory object.
+  TestInfo(const std::string& test_suite_name, const std::string& name,
+           const char* a_type_param,   // NULL if not a type-parameterized test
+           const char* a_value_param,  // NULL if not a value-parameterized test
+           internal::CodeLocation a_code_location,
+           internal::TypeId fixture_class_id,
+           internal::TestFactoryBase* factory);
+
+  // Increments the number of death tests encountered in this test so
+  // far.
+  int increment_death_test_count() {
+    return result_.increment_death_test_count();
+  }
+
+  // Creates the test object, runs it, records its result, and then
+  // deletes it.
+  void Run();
+
+  // Skip and records the test result for this object.
+  void Skip();
+
+  static void ClearTestResult(TestInfo* test_info) {
+    test_info->result_.Clear();
+  }
+
+  // These fields are immutable properties of the test.
+  const std::string test_suite_name_;    // test suite name
+  const std::string name_;               // Test name
+  // Name of the parameter type, or NULL if this is not a typed or a
+  // type-parameterized test.
+  const std::unique_ptr<const ::std::string> type_param_;
+  // Text representation of the value parameter, or NULL if this is not a
+  // value-parameterized test.
+  const std::unique_ptr<const ::std::string> value_param_;
+  internal::CodeLocation location_;
+  const internal::TypeId fixture_class_id_;  // ID of the test fixture class
+  bool should_run_;           // True if and only if this test should run
+  bool is_disabled_;          // True if and only if this test is disabled
+  bool matches_filter_;       // True if this test matches the
+                              // user-specified filter.
+  bool is_in_another_shard_;  // Will be run in another shard.
+  internal::TestFactoryBase* const factory_;  // The factory that creates
+                                              // the test object
+
+  // This field is mutable and needs to be reset before running the
+  // test for the second time.
+  TestResult result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
+};
+
+// A test suite, which consists of a vector of TestInfos.
+//
+// TestSuite is not copyable.
+class GTEST_API_ TestSuite {
+ public:
+  // Creates a TestSuite with the given name.
+  //
+  // TestSuite does NOT have a default constructor.  Always use this
+  // constructor to create a TestSuite object.
+  //
+  // Arguments:
+  //
+  //   name:         name of the test suite
+  //   a_type_param: the name of the test's type parameter, or NULL if
+  //                 this is not a type-parameterized test.
+  //   set_up_tc:    pointer to the function that sets up the test suite
+  //   tear_down_tc: pointer to the function that tears down the test suite
+  TestSuite(const char* name, const char* a_type_param,
+            internal::SetUpTestSuiteFunc set_up_tc,
+            internal::TearDownTestSuiteFunc tear_down_tc);
+
+  // Destructor of TestSuite.
+  virtual ~TestSuite();
+
+  // Gets the name of the TestSuite.
+  const char* name() const { return name_.c_str(); }
+
+  // Returns the name of the parameter type, or NULL if this is not a
+  // type-parameterized test suite.
+  const char* type_param() const {
+    if (type_param_.get() != nullptr) return type_param_->c_str();
+    return nullptr;
+  }
+
+  // Returns true if any test in this test suite should run.
+  bool should_run() const { return should_run_; }
+
+  // Gets the number of successful tests in this test suite.
+  int successful_test_count() const;
+
+  // Gets the number of skipped tests in this test suite.
+  int skipped_test_count() const;
+
+  // Gets the number of failed tests in this test suite.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
+  // Gets the number of disabled tests in this test suite.
+  int disabled_test_count() const;
+
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
+  // Get the number of tests in this test suite that should run.
+  int test_to_run_count() const;
+
+  // Gets the number of all tests in this test suite.
+  int total_test_count() const;
+
+  // Returns true if and only if the test suite passed.
+  bool Passed() const { return !Failed(); }
+
+  // Returns true if and only if the test suite failed.
+  bool Failed() const {
+    return failed_test_count() > 0 || ad_hoc_test_result().Failed();
+  }
+
+  // Returns the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Gets the time of the test suite start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const { return start_timestamp_; }
+
+  // Returns the i-th test among all the tests. i can range from 0 to
+  // total_test_count() - 1. If i is not in that range, returns NULL.
+  const TestInfo* GetTestInfo(int i) const;
+
+  // Returns the TestResult that holds test properties recorded during
+  // execution of SetUpTestSuite and TearDownTestSuite.
+  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
+
+ private:
+  friend class Test;
+  friend class internal::UnitTestImpl;
+
+  // Gets the (mutable) vector of TestInfos in this TestSuite.
+  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
+
+  // Gets the (immutable) vector of TestInfos in this TestSuite.
+  const std::vector<TestInfo*>& test_info_list() const {
+    return test_info_list_;
+  }
+
+  // Returns the i-th test among all the tests. i can range from 0 to
+  // total_test_count() - 1. If i is not in that range, returns NULL.
+  TestInfo* GetMutableTestInfo(int i);
+
+  // Sets the should_run member.
+  void set_should_run(bool should) { should_run_ = should; }
+
+  // Adds a TestInfo to this test suite.  Will delete the TestInfo upon
+  // destruction of the TestSuite object.
+  void AddTestInfo(TestInfo * test_info);
+
+  // Clears the results of all tests in this test suite.
+  void ClearResult();
+
+  // Clears the results of all tests in the given test suite.
+  static void ClearTestSuiteResult(TestSuite* test_suite) {
+    test_suite->ClearResult();
+  }
+
+  // Runs every test in this TestSuite.
+  void Run();
+
+  // Skips the execution of tests under this TestSuite
+  void Skip();
+
+  // Runs SetUpTestSuite() for this TestSuite.  This wrapper is needed
+  // for catching exceptions thrown from SetUpTestSuite().
+  void RunSetUpTestSuite() {
+    if (set_up_tc_ != nullptr) {
+      (*set_up_tc_)();
+    }
+  }
+
+  // Runs TearDownTestSuite() for this TestSuite.  This wrapper is
+  // needed for catching exceptions thrown from TearDownTestSuite().
+  void RunTearDownTestSuite() {
+    if (tear_down_tc_ != nullptr) {
+      (*tear_down_tc_)();
+    }
+  }
+
+  // Returns true if and only if test passed.
+  static bool TestPassed(const TestInfo* test_info) {
+    return test_info->should_run() && test_info->result()->Passed();
+  }
+
+  // Returns true if and only if test skipped.
+  static bool TestSkipped(const TestInfo* test_info) {
+    return test_info->should_run() && test_info->result()->Skipped();
+  }
+
+  // Returns true if and only if test failed.
+  static bool TestFailed(const TestInfo* test_info) {
+    return test_info->should_run() && test_info->result()->Failed();
+  }
+
+  // Returns true if and only if the test is disabled and will be reported in
+  // the XML report.
+  static bool TestReportableDisabled(const TestInfo* test_info) {
+    return test_info->is_reportable() && test_info->is_disabled_;
+  }
+
+  // Returns true if and only if test is disabled.
+  static bool TestDisabled(const TestInfo* test_info) {
+    return test_info->is_disabled_;
+  }
+
+  // Returns true if and only if this test will appear in the XML report.
+  static bool TestReportable(const TestInfo* test_info) {
+    return test_info->is_reportable();
+  }
+
+  // Returns true if the given test should run.
+  static bool ShouldRunTest(const TestInfo* test_info) {
+    return test_info->should_run();
+  }
+
+  // Shuffles the tests in this test suite.
+  void ShuffleTests(internal::Random* random);
+
+  // Restores the test order to before the first shuffle.
+  void UnshuffleTests();
+
+  // Name of the test suite.
+  std::string name_;
+  // Name of the parameter type, or NULL if this is not a typed or a
+  // type-parameterized test.
+  const std::unique_ptr<const ::std::string> type_param_;
+  // The vector of TestInfos in their original order.  It owns the
+  // elements in the vector.
+  std::vector<TestInfo*> test_info_list_;
+  // Provides a level of indirection for the test list to allow easy
+  // shuffling and restoring the test order.  The i-th element in this
+  // vector is the index of the i-th test in the shuffled test list.
+  std::vector<int> test_indices_;
+  // Pointer to the function that sets up the test suite.
+  internal::SetUpTestSuiteFunc set_up_tc_;
+  // Pointer to the function that tears down the test suite.
+  internal::TearDownTestSuiteFunc tear_down_tc_;
+  // True if and only if any test in this test suite should run.
+  bool should_run_;
+  // The start time, in milliseconds since UNIX Epoch.
+  TimeInMillis start_timestamp_;
+  // Elapsed time, in milliseconds.
+  TimeInMillis elapsed_time_;
+  // Holds test properties recorded during execution of SetUpTestSuite and
+  // TearDownTestSuite.
+  TestResult ad_hoc_test_result_;
+
+  // We disallow copying TestSuites.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestSuite);
+};
+
+// An Environment object is capable of setting up and tearing down an
+// environment.  You should subclass this to define your own
+// environment(s).
+//
+// An Environment object does the set-up and tear-down in virtual
+// methods SetUp() and TearDown() instead of the constructor and the
+// destructor, as:
+//
+//   1. You cannot safely throw from a destructor.  This is a problem
+//      as in some cases Google Test is used where exceptions are enabled, and
+//      we may want to implement ASSERT_* using exceptions where they are
+//      available.
+//   2. You cannot use ASSERT_* directly in a constructor or
+//      destructor.
+class Environment {
+ public:
+  // The d'tor is virtual as we need to subclass Environment.
+  virtual ~Environment() {}
+
+  // Override this to define how to set up the environment.
+  virtual void SetUp() {}
+
+  // Override this to define how to tear down the environment.
+  virtual void TearDown() {}
+ private:
+  // If you see an error about overriding the following function or
+  // about it being private, you have mis-spelled SetUp() as Setup().
+  struct Setup_should_be_spelled_SetUp {};
+  virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
+};
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Exception which can be thrown from TestEventListener::OnTestPartResult.
+class GTEST_API_ AssertionException
+    : public internal::GoogleTestFailureException {
+ public:
+  explicit AssertionException(const TestPartResult& result)
+      : GoogleTestFailureException(result) {}
+};
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// The interface for tracing execution of tests. The methods are organized in
+// the order the corresponding events are fired.
+class TestEventListener {
+ public:
+  virtual ~TestEventListener() {}
+
+  // Fired before any test activity starts.
+  virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
+
+  // Fired before each iteration of tests starts.  There may be more than
+  // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
+  // index, starting from 0.
+  virtual void OnTestIterationStart(const UnitTest& unit_test,
+                                    int iteration) = 0;
+
+  // Fired before environment set-up for each iteration of tests starts.
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
+
+  // Fired after environment set-up for each iteration of tests ends.
+  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
+
+  // Fired before the test suite starts.
+  virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {}
+
+  //  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Fired before the test starts.
+  virtual void OnTestStart(const TestInfo& test_info) = 0;
+
+  // Fired after a failed assertion or a SUCCEED() invocation.
+  // If you want to throw an exception from this function to skip to the next
+  // TEST, it must be AssertionException defined above, or inherited from it.
+  virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;
+
+  // Fired after the test ends.
+  virtual void OnTestEnd(const TestInfo& test_info) = 0;
+
+  // Fired after the test suite ends.
+  virtual void OnTestSuiteEnd(const TestSuite& /*test_suite*/) {}
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Fired before environment tear-down for each iteration of tests starts.
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
+
+  // Fired after environment tear-down for each iteration of tests ends.
+  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
+
+  // Fired after each iteration of tests finishes.
+  virtual void OnTestIterationEnd(const UnitTest& unit_test,
+                                  int iteration) = 0;
+
+  // Fired after all test activities have ended.
+  virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
+};
+
+// The convenience class for users who need to override just one or two
+// methods and are not concerned that a possible change to a signature of
+// the methods they override will not be caught during the build.  For
+// comments about each method please see the definition of TestEventListener
+// above.
+class EmptyTestEventListener : public TestEventListener {
+ public:
+  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationStart(const UnitTest& /*unit_test*/,
+                            int /*iteration*/) override {}
+  void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}
+  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
+  void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseStart(const TestCase& /*test_case*/) override {}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  void OnTestStart(const TestInfo& /*test_info*/) override {}
+  void OnTestPartResult(const TestPartResult& /*test_part_result*/) override {}
+  void OnTestEnd(const TestInfo& /*test_info*/) override {}
+  void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {}
+  void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationEnd(const UnitTest& /*unit_test*/,
+                          int /*iteration*/) override {}
+  void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
+};
+
+// TestEventListeners lets users add listeners to track events in Google Test.
+class GTEST_API_ TestEventListeners {
+ public:
+  TestEventListeners();
+  ~TestEventListeners();
+
+  // Appends an event listener to the end of the list. Google Test assumes
+  // the ownership of the listener (i.e. it will delete the listener when
+  // the test program finishes).
+  void Append(TestEventListener* listener);
+
+  // Removes the given event listener from the list and returns it.  It then
+  // becomes the caller's responsibility to delete the listener. Returns
+  // NULL if the listener is not found in the list.
+  TestEventListener* Release(TestEventListener* listener);
+
+  // Returns the standard listener responsible for the default console
+  // output.  Can be removed from the listeners list to shut down default
+  // console output.  Note that removing this object from the listener list
+  // with Release transfers its ownership to the caller and makes this
+  // function return NULL the next time.
+  TestEventListener* default_result_printer() const {
+    return default_result_printer_;
+  }
+
+  // Returns the standard listener responsible for the default XML output
+  // controlled by the --gtest_output=xml flag.  Can be removed from the
+  // listeners list by users who want to shut down the default XML output
+  // controlled by this flag and substitute it with custom one.  Note that
+  // removing this object from the listener list with Release transfers its
+  // ownership to the caller and makes this function return NULL the next
+  // time.
+  TestEventListener* default_xml_generator() const {
+    return default_xml_generator_;
+  }
+
+ private:
+  friend class TestSuite;
+  friend class TestInfo;
+  friend class internal::DefaultGlobalTestPartResultReporter;
+  friend class internal::NoExecDeathTest;
+  friend class internal::TestEventListenersAccessor;
+  friend class internal::UnitTestImpl;
+
+  // Returns repeater that broadcasts the TestEventListener events to all
+  // subscribers.
+  TestEventListener* repeater();
+
+  // Sets the default_result_printer attribute to the provided listener.
+  // The listener is also added to the listener list and previous
+  // default_result_printer is removed from it and deleted. The listener can
+  // also be NULL in which case it will not be added to the list. Does
+  // nothing if the previous and the current listener objects are the same.
+  void SetDefaultResultPrinter(TestEventListener* listener);
+
+  // Sets the default_xml_generator attribute to the provided listener.  The
+  // listener is also added to the listener list and previous
+  // default_xml_generator is removed from it and deleted. The listener can
+  // also be NULL in which case it will not be added to the list. Does
+  // nothing if the previous and the current listener objects are the same.
+  void SetDefaultXmlGenerator(TestEventListener* listener);
+
+  // Controls whether events will be forwarded by the repeater to the
+  // listeners in the list.
+  bool EventForwardingEnabled() const;
+  void SuppressEventForwarding();
+
+  // The actual list of listeners.
+  internal::TestEventRepeater* repeater_;
+  // Listener responsible for the standard result output.
+  TestEventListener* default_result_printer_;
+  // Listener responsible for the creation of the XML output file.
+  TestEventListener* default_xml_generator_;
+
+  // We disallow copying TestEventListeners.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
+};
+
+// A UnitTest consists of a vector of TestSuites.
+//
+// This is a singleton class.  The only instance of UnitTest is
+// created when UnitTest::GetInstance() is first called.  This
+// instance is never deleted.
+//
+// UnitTest is not copyable.
+//
+// This class is thread-safe as long as the methods are called
+// according to their specification.
+class GTEST_API_ UnitTest {
+ public:
+  // Gets the singleton UnitTest object.  The first time this method
+  // is called, a UnitTest object is constructed and returned.
+  // Consecutive calls will return the same object.
+  static UnitTest* GetInstance();
+
+  // Runs all tests in this UnitTest object and prints the result.
+  // Returns 0 if successful, or 1 otherwise.
+  //
+  // This method can only be called from the main thread.
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  int Run() GTEST_MUST_USE_RESULT_;
+
+  // Returns the working directory when the first TEST() or TEST_F()
+  // was executed.  The UnitTest object owns the string.
+  const char* original_working_dir() const;
+
+  // Returns the TestSuite object for the test that's currently running,
+  // or NULL if no test is running.
+  const TestSuite* current_test_suite() const GTEST_LOCK_EXCLUDED_(mutex_);
+
+// Legacy API is still available but deprecated
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  const TestCase* current_test_case() const GTEST_LOCK_EXCLUDED_(mutex_);
+#endif
+
+  // Returns the TestInfo object for the test that's currently running,
+  // or NULL if no test is running.
+  const TestInfo* current_test_info() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Returns the random seed used at the start of the current test run.
+  int random_seed() const;
+
+  // Returns the ParameterizedTestSuiteRegistry object used to keep track of
+  // value-parameterized tests and instantiate and register them.
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  internal::ParameterizedTestSuiteRegistry& parameterized_test_registry()
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Gets the number of successful test suites.
+  int successful_test_suite_count() const;
+
+  // Gets the number of failed test suites.
+  int failed_test_suite_count() const;
+
+  // Gets the number of all test suites.
+  int total_test_suite_count() const;
+
+  // Gets the number of all test suites that contain at least one test
+  // that should run.
+  int test_suite_to_run_count() const;
+
+  //  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  int successful_test_case_count() const;
+  int failed_test_case_count() const;
+  int total_test_case_count() const;
+  int test_case_to_run_count() const;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Gets the number of successful tests.
+  int successful_test_count() const;
+
+  // Gets the number of skipped tests.
+  int skipped_test_count() const;
+
+  // Gets the number of failed tests.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
+  // Gets the number of disabled tests.
+  int disabled_test_count() const;
+
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
+  // Gets the number of all tests.
+  int total_test_count() const;
+
+  // Gets the number of tests that should run.
+  int test_to_run_count() const;
+
+  // Gets the time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const;
+
+  // Gets the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const;
+
+  // Returns true if and only if the unit test passed (i.e. all test suites
+  // passed).
+  bool Passed() const;
+
+  // Returns true if and only if the unit test failed (i.e. some test suite
+  // failed or something outside of all tests failed).
+  bool Failed() const;
+
+  // Gets the i-th test suite among all the test suites. i can range from 0 to
+  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
+  const TestSuite* GetTestSuite(int i) const;
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  const TestCase* GetTestCase(int i) const;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Returns the TestResult containing information on test failures and
+  // properties logged outside of individual test suites.
+  const TestResult& ad_hoc_test_result() const;
+
+  // Returns the list of event listeners that can be used to track events
+  // inside Google Test.
+  TestEventListeners& listeners();
+
+ private:
+  // Registers and returns a global test environment.  When a test
+  // program is run, all global test environments will be set-up in
+  // the order they were registered.  After all tests in the program
+  // have finished, all global test environments will be torn-down in
+  // the *reverse* order they were registered.
+  //
+  // The UnitTest object takes ownership of the given environment.
+  //
+  // This method can only be called from the main thread.
+  Environment* AddEnvironment(Environment* env);
+
+  // Adds a TestPartResult to the current TestResult object.  All
+  // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
+  // eventually call this to report their results.  The user code
+  // should use the assertion macros instead of calling this directly.
+  void AddTestPartResult(TestPartResult::Type result_type,
+                         const char* file_name,
+                         int line_number,
+                         const std::string& message,
+                         const std::string& os_stack_trace)
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Adds a TestProperty to the current TestResult object when invoked from
+  // inside a test, to current TestSuite's ad_hoc_test_result_ when invoked
+  // from SetUpTestSuite or TearDownTestSuite, or to the global property set
+  // when invoked elsewhere.  If the result already contains a property with
+  // the same key, the value will be updated.
+  void RecordProperty(const std::string& key, const std::string& value);
+
+  // Gets the i-th test suite among all the test suites. i can range from 0 to
+  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
+  TestSuite* GetMutableTestSuite(int i);
+
+  // Accessors for the implementation object.
+  internal::UnitTestImpl* impl() { return impl_; }
+  const internal::UnitTestImpl* impl() const { return impl_; }
+
+  // These classes and functions are friends as they need to access private
+  // members of UnitTest.
+  friend class ScopedTrace;
+  friend class Test;
+  friend class internal::AssertHelper;
+  friend class internal::StreamingListenerTest;
+  friend class internal::UnitTestRecordPropertyTestHelper;
+  friend Environment* AddGlobalTestEnvironment(Environment* env);
+  friend std::set<std::string>* internal::GetIgnoredParameterizedTestSuites();
+  friend internal::UnitTestImpl* internal::GetUnitTestImpl();
+  friend void internal::ReportFailureInUnknownLocation(
+      TestPartResult::Type result_type,
+      const std::string& message);
+
+  // Creates an empty UnitTest.
+  UnitTest();
+
+  // D'tor
+  virtual ~UnitTest();
+
+  // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
+  // Google Test trace stack.
+  void PushGTestTrace(const internal::TraceInfo& trace)
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Pops a trace from the per-thread Google Test trace stack.
+  void PopGTestTrace()
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Protects mutable state in *impl_.  This is mutable as some const
+  // methods need to lock it too.
+  mutable internal::Mutex mutex_;
+
+  // Opaque implementation object.  This field is never changed once
+  // the object is constructed.  We don't mark it as const here, as
+  // doing so will cause a warning in the constructor of UnitTest.
+  // Mutable state in *impl_ is protected by mutex_.
+  internal::UnitTestImpl* impl_;
+
+  // We disallow copying UnitTest.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
+};
+
+// A convenient wrapper for adding an environment for the test
+// program.
+//
+// You should call this before RUN_ALL_TESTS() is called, probably in
+// main().  If you use gtest_main, you need to call this before main()
+// starts for it to take effect.  For example, you can define a global
+// variable like this:
+//
+//   testing::Environment* const foo_env =
+//       testing::AddGlobalTestEnvironment(new FooEnvironment);
+//
+// However, we strongly recommend you to write your own main() and
+// call AddGlobalTestEnvironment() there, as relying on initialization
+// of global variables makes the code harder to read and may cause
+// problems when you register multiple environments from different
+// translation units and the environments have dependencies among them
+// (remember that the compiler doesn't guarantee the order in which
+// global variables from different translation units are initialized).
+inline Environment* AddGlobalTestEnvironment(Environment* env) {
+  return UnitTest::GetInstance()->AddEnvironment(env);
+}
+
+// Initializes Google Test.  This must be called before calling
+// RUN_ALL_TESTS().  In particular, it parses a command line for the
+// flags that Google Test recognizes.  Whenever a Google Test flag is
+// seen, it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Test flag variables are
+// updated.
+//
+// Calling the function for the second time has no user-visible effect.
+GTEST_API_ void InitGoogleTest(int* argc, char** argv);
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
+
+// This overloaded version can be used on Arduino/embedded platforms where
+// there is no argc/argv.
+GTEST_API_ void InitGoogleTest();
+
+namespace internal {
+
+// Separate the error generating code from the code path to reduce the stack
+// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers
+// when calling EXPECT_* in a tight loop.
+template <typename T1, typename T2>
+AssertionResult CmpHelperEQFailure(const char* lhs_expression,
+                                   const char* rhs_expression,
+                                   const T1& lhs, const T2& rhs) {
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   FormatForComparisonFailureMessage(lhs, rhs),
+                   FormatForComparisonFailureMessage(rhs, lhs),
+                   false);
+}
+
+// This block of code defines operator==/!=
+// to block lexical scope lookup.
+// It prevents using invalid operator==/!= defined at namespace scope.
+struct faketype {};
+inline bool operator==(faketype, faketype) { return true; }
+inline bool operator!=(faketype, faketype) { return false; }
+
+// The helper function for {ASSERT|EXPECT}_EQ.
+template <typename T1, typename T2>
+AssertionResult CmpHelperEQ(const char* lhs_expression,
+                            const char* rhs_expression,
+                            const T1& lhs,
+                            const T2& rhs) {
+  if (lhs == rhs) {
+    return AssertionSuccess();
+  }
+
+  return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
+}
+
+class EqHelper {
+ public:
+  // This templatized version is for the general case.
+  template <
+      typename T1, typename T2,
+      // Disable this overload for cases where one argument is a pointer
+      // and the other is the null pointer constant.
+      typename std::enable_if<!std::is_integral<T1>::value ||
+                              !std::is_pointer<T2>::value>::type* = nullptr>
+  static AssertionResult Compare(const char* lhs_expression,
+                                 const char* rhs_expression, const T1& lhs,
+                                 const T2& rhs) {
+    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
+  }
+
+  // With this overloaded version, we allow anonymous enums to be used
+  // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
+  // enums can be implicitly cast to BiggestInt.
+  //
+  // Even though its body looks the same as the above version, we
+  // cannot merge the two, as it will make anonymous enums unhappy.
+  static AssertionResult Compare(const char* lhs_expression,
+                                 const char* rhs_expression,
+                                 BiggestInt lhs,
+                                 BiggestInt rhs) {
+    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
+  }
+
+  template <typename T>
+  static AssertionResult Compare(
+      const char* lhs_expression, const char* rhs_expression,
+      // Handle cases where '0' is used as a null pointer literal.
+      std::nullptr_t /* lhs */, T* rhs) {
+    // We already know that 'lhs' is a null pointer.
+    return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr),
+                       rhs);
+  }
+};
+
+// Separate the error generating code from the code path to reduce the stack
+// frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers
+// when calling EXPECT_OP in a tight loop.
+template <typename T1, typename T2>
+AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
+                                   const T1& val1, const T2& val2,
+                                   const char* op) {
+  return AssertionFailure()
+         << "Expected: (" << expr1 << ") " << op << " (" << expr2
+         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
+         << " vs " << FormatForComparisonFailureMessage(val2, val1);
+}
+
+// A macro for implementing the helper functions needed to implement
+// ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
+// of similar code.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
+template <typename T1, typename T2>\
+AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
+                                   const T1& val1, const T2& val2) {\
+  if (val1 op val2) {\
+    return AssertionSuccess();\
+  } else {\
+    return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
+  }\
+}
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+// Implements the helper function for {ASSERT|EXPECT}_NE
+GTEST_IMPL_CMP_HELPER_(NE, !=)
+// Implements the helper function for {ASSERT|EXPECT}_LE
+GTEST_IMPL_CMP_HELPER_(LE, <=)
+// Implements the helper function for {ASSERT|EXPECT}_LT
+GTEST_IMPL_CMP_HELPER_(LT, <)
+// Implements the helper function for {ASSERT|EXPECT}_GE
+GTEST_IMPL_CMP_HELPER_(GE, >=)
+// Implements the helper function for {ASSERT|EXPECT}_GT
+GTEST_IMPL_CMP_HELPER_(GT, >)
+
+#undef GTEST_IMPL_CMP_HELPER_
+
+// The helper function for {ASSERT|EXPECT}_STREQ.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const char* s1,
+                                          const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression,
+                                              const char* s2_expression,
+                                              const char* s1,
+                                              const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRNE.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const char* s1,
+                                          const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRCASENE.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
+                                              const char* s2_expression,
+                                              const char* s1,
+                                              const char* s2);
+
+
+// Helper function for *_STREQ on wide strings.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const wchar_t* s1,
+                                          const wchar_t* s2);
+
+// Helper function for *_STRNE on wide strings.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const wchar_t* s1,
+                                          const wchar_t* s2);
+
+}  // namespace internal
+
+// IsSubstring() and IsNotSubstring() are intended to be used as the
+// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
+// themselves.  They check whether needle is a substring of haystack
+// (NULL is considered a substring of itself only), and return an
+// appropriate error message when they fail.
+//
+// The {needle,haystack}_expr arguments are the stringified
+// expressions that generated the two real arguments.
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack);
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack);
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack);
+
+#if GTEST_HAS_STD_WSTRING
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack);
+#endif  // GTEST_HAS_STD_WSTRING
+
+namespace internal {
+
+// Helper template function for comparing floating-points.
+//
+// Template parameter:
+//
+//   RawType: the raw floating-point type (either float or double)
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+template <typename RawType>
+AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
+                                         const char* rhs_expression,
+                                         RawType lhs_value,
+                                         RawType rhs_value) {
+  const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);
+
+  if (lhs.AlmostEquals(rhs)) {
+    return AssertionSuccess();
+  }
+
+  ::std::stringstream lhs_ss;
+  lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+         << lhs_value;
+
+  ::std::stringstream rhs_ss;
+  rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+         << rhs_value;
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   StringStreamToString(&lhs_ss),
+                   StringStreamToString(&rhs_ss),
+                   false);
+}
+
+// Helper function for implementing ASSERT_NEAR.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
+                                                const char* expr2,
+                                                const char* abs_error_expr,
+                                                double val1,
+                                                double val2,
+                                                double abs_error);
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+// A class that enables one to stream messages to assertion macros
+class GTEST_API_ AssertHelper {
+ public:
+  // Constructor.
+  AssertHelper(TestPartResult::Type type,
+               const char* file,
+               int line,
+               const char* message);
+  ~AssertHelper();
+
+  // Message assignment is a semantic trick to enable assertion
+  // streaming; see the GTEST_MESSAGE_ macro below.
+  void operator=(const Message& message) const;
+
+ private:
+  // We put our data in a struct so that the size of the AssertHelper class can
+  // be as small as possible.  This is important because gcc is incapable of
+  // re-using stack space even for temporary variables, so every EXPECT_EQ
+  // reserves stack space for another AssertHelper.
+  struct AssertHelperData {
+    AssertHelperData(TestPartResult::Type t,
+                     const char* srcfile,
+                     int line_num,
+                     const char* msg)
+        : type(t), file(srcfile), line(line_num), message(msg) { }
+
+    TestPartResult::Type const type;
+    const char* const file;
+    int const line;
+    std::string const message;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
+  };
+
+  AssertHelperData* const data_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
+};
+
+}  // namespace internal
+
+// The pure interface class that all value-parameterized tests inherit from.
+// A value-parameterized class must inherit from both ::testing::Test and
+// ::testing::WithParamInterface. In most cases that just means inheriting
+// from ::testing::TestWithParam, but more complicated test hierarchies
+// may need to inherit from Test and WithParamInterface at different levels.
+//
+// This interface has support for accessing the test parameter value via
+// the GetParam() method.
+//
+// Use it with one of the parameter generator defining functions, like Range(),
+// Values(), ValuesIn(), Bool(), and Combine().
+//
+// class FooTest : public ::testing::TestWithParam<int> {
+//  protected:
+//   FooTest() {
+//     // Can use GetParam() here.
+//   }
+//   ~FooTest() override {
+//     // Can use GetParam() here.
+//   }
+//   void SetUp() override {
+//     // Can use GetParam() here.
+//   }
+//   void TearDown override {
+//     // Can use GetParam() here.
+//   }
+// };
+// TEST_P(FooTest, DoesBar) {
+//   // Can use GetParam() method here.
+//   Foo foo;
+//   ASSERT_TRUE(foo.DoesBar(GetParam()));
+// }
+// INSTANTIATE_TEST_SUITE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
+
+template <typename T>
+class WithParamInterface {
+ public:
+  typedef T ParamType;
+  virtual ~WithParamInterface() {}
+
+  // The current parameter value. Is also available in the test fixture's
+  // constructor.
+  static const ParamType& GetParam() {
+    GTEST_CHECK_(parameter_ != nullptr)
+        << "GetParam() can only be called inside a value-parameterized test "
+        << "-- did you intend to write TEST_P instead of TEST_F?";
+    return *parameter_;
+  }
+
+ private:
+  // Sets parameter value. The caller is responsible for making sure the value
+  // remains alive and unchanged throughout the current test.
+  static void SetParam(const ParamType* parameter) {
+    parameter_ = parameter;
+  }
+
+  // Static value used for accessing parameter during a test lifetime.
+  static const ParamType* parameter_;
+
+  // TestClass must be a subclass of WithParamInterface<T> and Test.
+  template <class TestClass> friend class internal::ParameterizedTestFactory;
+};
+
+template <typename T>
+const T* WithParamInterface<T>::parameter_ = nullptr;
+
+// Most value-parameterized classes can ignore the existence of
+// WithParamInterface, and can just inherit from ::testing::TestWithParam.
+
+template <typename T>
+class TestWithParam : public Test, public WithParamInterface<T> {
+};
+
+// Macros for indicating success/failure in test code.
+
+// Skips test in runtime.
+// Skipping test aborts current function.
+// Skipped tests are neither successful nor failed.
+#define GTEST_SKIP() GTEST_SKIP_("")
+
+// ADD_FAILURE unconditionally adds a failure to the current test.
+// SUCCEED generates a success - it doesn't automatically make the
+// current test successful, as a test is only successful when it has
+// no failure.
+//
+// EXPECT_* verifies that a certain condition is satisfied.  If not,
+// it behaves like ADD_FAILURE.  In particular:
+//
+//   EXPECT_TRUE  verifies that a Boolean condition is true.
+//   EXPECT_FALSE verifies that a Boolean condition is false.
+//
+// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
+// that they will also abort the current function on failure.  People
+// usually want the fail-fast behavior of FAIL and ASSERT_*, but those
+// writing data-driven tests often find themselves using ADD_FAILURE
+// and EXPECT_* more.
+
+// Generates a nonfatal failure with a generic message.
+#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
+
+// Generates a nonfatal failure at the given source file location with
+// a generic message.
+#define ADD_FAILURE_AT(file, line) \
+  GTEST_MESSAGE_AT_(file, line, "Failed", \
+                    ::testing::TestPartResult::kNonFatalFailure)
+
+// Generates a fatal failure with a generic message.
+#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
+
+// Like GTEST_FAIL(), but at the given source file location.
+#define GTEST_FAIL_AT(file, line)         \
+  GTEST_MESSAGE_AT_(file, line, "Failed", \
+                    ::testing::TestPartResult::kFatalFailure)
+
+// Define this macro to 1 to omit the definition of FAIL(), which is a
+// generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_FAIL
+# define FAIL() GTEST_FAIL()
+#endif
+
+// Generates a success with a generic message.
+#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")
+
+// Define this macro to 1 to omit the definition of SUCCEED(), which
+// is a generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_SUCCEED
+# define SUCCEED() GTEST_SUCCEED()
+#endif
+
+// Macros for testing exceptions.
+//
+//    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
+//         Tests that the statement throws the expected exception.
+//    * {ASSERT|EXPECT}_NO_THROW(statement):
+//         Tests that the statement doesn't throw any exception.
+//    * {ASSERT|EXPECT}_ANY_THROW(statement):
+//         Tests that the statement throws an exception.
+
+#define EXPECT_THROW(statement, expected_exception) \
+  GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_NO_THROW(statement) \
+  GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_ANY_THROW(statement) \
+  GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_THROW(statement, expected_exception) \
+  GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
+#define ASSERT_NO_THROW(statement) \
+  GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
+#define ASSERT_ANY_THROW(statement) \
+  GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
+
+// Boolean assertions. Condition can be either a Boolean expression or an
+// AssertionResult. For more information on how to use AssertionResult with
+// these macros see comments on that class.
+#define GTEST_EXPECT_TRUE(condition) \
+  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
+                      GTEST_NONFATAL_FAILURE_)
+#define GTEST_EXPECT_FALSE(condition) \
+  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
+                      GTEST_NONFATAL_FAILURE_)
+#define GTEST_ASSERT_TRUE(condition) \
+  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
+                      GTEST_FATAL_FAILURE_)
+#define GTEST_ASSERT_FALSE(condition) \
+  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
+                      GTEST_FATAL_FAILURE_)
+
+// Define these macros to 1 to omit the definition of the corresponding
+// EXPECT or ASSERT, which clashes with some users' own code.
+
+#if !GTEST_DONT_DEFINE_EXPECT_TRUE
+#define EXPECT_TRUE(condition) GTEST_EXPECT_TRUE(condition)
+#endif
+
+#if !GTEST_DONT_DEFINE_EXPECT_FALSE
+#define EXPECT_FALSE(condition) GTEST_EXPECT_FALSE(condition)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_TRUE
+#define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_FALSE
+#define ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition)
+#endif
+
+// Macros for testing equalities and inequalities.
+//
+//    * {ASSERT|EXPECT}_EQ(v1, v2): Tests that v1 == v2
+//    * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2
+//    * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2
+//    * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2
+//    * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2
+//    * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2
+//
+// When they are not, Google Test prints both the tested expressions and
+// their actual values.  The values must be compatible built-in types,
+// or you will get a compiler error.  By "compatible" we mean that the
+// values can be compared by the respective operator.
+//
+// Note:
+//
+//   1. It is possible to make a user-defined type work with
+//   {ASSERT|EXPECT}_??(), but that requires overloading the
+//   comparison operators and is thus discouraged by the Google C++
+//   Usage Guide.  Therefore, you are advised to use the
+//   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
+//   equal.
+//
+//   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
+//   pointers (in particular, C strings).  Therefore, if you use it
+//   with two C strings, you are testing how their locations in memory
+//   are related, not how their content is related.  To compare two C
+//   strings by content, use {ASSERT|EXPECT}_STR*().
+//
+//   3. {ASSERT|EXPECT}_EQ(v1, v2) is preferred to
+//   {ASSERT|EXPECT}_TRUE(v1 == v2), as the former tells you
+//   what the actual value is when it fails, and similarly for the
+//   other comparisons.
+//
+//   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
+//   evaluate their arguments, which is undefined.
+//
+//   5. These macros evaluate their arguments exactly once.
+//
+// Examples:
+//
+//   EXPECT_NE(Foo(), 5);
+//   EXPECT_EQ(a_pointer, NULL);
+//   ASSERT_LT(i, array_size);
+//   ASSERT_GT(records.size(), 0) << "There is no record left.";
+
+#define EXPECT_EQ(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
+#define EXPECT_NE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
+#define EXPECT_LE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
+#define EXPECT_LT(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
+#define EXPECT_GE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
+#define EXPECT_GT(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
+
+#define GTEST_ASSERT_EQ(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
+#define GTEST_ASSERT_NE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
+#define GTEST_ASSERT_LE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
+#define GTEST_ASSERT_LT(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
+#define GTEST_ASSERT_GE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
+#define GTEST_ASSERT_GT(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
+
+// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
+// ASSERT_XY(), which clashes with some users' own code.
+
+#if !GTEST_DONT_DEFINE_ASSERT_EQ
+# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_NE
+# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_LE
+# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_LT
+# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_GE
+# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_GT
+# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
+#endif
+
+// C-string Comparisons.  All tests treat NULL and any non-NULL string
+// as different.  Two NULLs are equal.
+//
+//    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
+//    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
+//    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
+//    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
+//
+// For wide or narrow string objects, you can use the
+// {ASSERT|EXPECT}_??() macros.
+//
+// Don't depend on the order in which the arguments are evaluated,
+// which is undefined.
+//
+// These macros evaluate their arguments exactly once.
+
+#define EXPECT_STREQ(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
+#define EXPECT_STRNE(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
+#define EXPECT_STRCASEEQ(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
+#define EXPECT_STRCASENE(s1, s2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
+
+#define ASSERT_STREQ(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
+#define ASSERT_STRNE(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
+#define ASSERT_STRCASEEQ(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
+#define ASSERT_STRCASENE(s1, s2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
+
+// Macros for comparing floating-point numbers.
+//
+//    * {ASSERT|EXPECT}_FLOAT_EQ(val1, val2):
+//         Tests that two float values are almost equal.
+//    * {ASSERT|EXPECT}_DOUBLE_EQ(val1, val2):
+//         Tests that two double values are almost equal.
+//    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
+//         Tests that v1 and v2 are within the given distance to each other.
+//
+// Google Test uses ULP-based comparison to automatically pick a default
+// error bound that is appropriate for the operands.  See the
+// FloatingPoint template class in gtest-internal.h if you are
+// interested in the implementation details.
+
+#define EXPECT_FLOAT_EQ(val1, val2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
+                      val1, val2)
+
+#define EXPECT_DOUBLE_EQ(val1, val2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
+                      val1, val2)
+
+#define ASSERT_FLOAT_EQ(val1, val2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
+                      val1, val2)
+
+#define ASSERT_DOUBLE_EQ(val1, val2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
+                      val1, val2)
+
+#define EXPECT_NEAR(val1, val2, abs_error)\
+  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
+                      val1, val2, abs_error)
+
+#define ASSERT_NEAR(val1, val2, abs_error)\
+  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
+                      val1, val2, abs_error)
+
+// These predicate format functions work on floating-point values, and
+// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
+//
+//   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
+                                   float val1, float val2);
+GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
+                                    double val1, double val2);
+
+
+#if GTEST_OS_WINDOWS
+
+// Macros that test for HRESULT failure and success, these are only useful
+// on Windows, and rely on Windows SDK macros and APIs to compile.
+//
+//    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
+//
+// When expr unexpectedly fails or succeeds, Google Test prints the
+// expected result and the actual result with both a human-readable
+// string representation of the error, if available, as well as the
+// hex result code.
+# define EXPECT_HRESULT_SUCCEEDED(expr) \
+    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+
+# define ASSERT_HRESULT_SUCCEEDED(expr) \
+    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+
+# define EXPECT_HRESULT_FAILED(expr) \
+    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+
+# define ASSERT_HRESULT_FAILED(expr) \
+    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+
+#endif  // GTEST_OS_WINDOWS
+
+// Macros that execute statement and check that it doesn't generate new fatal
+// failures in the current thread.
+//
+//   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
+//
+// Examples:
+//
+//   EXPECT_NO_FATAL_FAILURE(Process());
+//   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
+//
+#define ASSERT_NO_FATAL_FAILURE(statement) \
+    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
+#define EXPECT_NO_FATAL_FAILURE(statement) \
+    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
+
+// Causes a trace (including the given source file path and line number,
+// and the given message) to be included in every test failure message generated
+// by code in the scope of the lifetime of an instance of this class. The effect
+// is undone with the destruction of the instance.
+//
+// The message argument can be anything streamable to std::ostream.
+//
+// Example:
+//   testing::ScopedTrace trace("file.cc", 123, "message");
+//
+class GTEST_API_ ScopedTrace {
+ public:
+  // The c'tor pushes the given source file location and message onto
+  // a trace stack maintained by Google Test.
+
+  // Template version. Uses Message() to convert the values into strings.
+  // Slow, but flexible.
+  template <typename T>
+  ScopedTrace(const char* file, int line, const T& message) {
+    PushTrace(file, line, (Message() << message).GetString());
+  }
+
+  // Optimize for some known types.
+  ScopedTrace(const char* file, int line, const char* message) {
+    PushTrace(file, line, message ? message : "(null)");
+  }
+
+  ScopedTrace(const char* file, int line, const std::string& message) {
+    PushTrace(file, line, message);
+  }
+
+  // The d'tor pops the info pushed by the c'tor.
+  //
+  // Note that the d'tor is not virtual in order to be efficient.
+  // Don't inherit from ScopedTrace!
+  ~ScopedTrace();
+
+ private:
+  void PushTrace(const char* file, int line, std::string message);
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
+} GTEST_ATTRIBUTE_UNUSED_;  // A ScopedTrace object does its job in its
+                            // c'tor and d'tor.  Therefore it doesn't
+                            // need to be used otherwise.
+
+// Causes a trace (including the source file path, the current line
+// number, and the given message) to be included in every test failure
+// message generated by code in the current scope.  The effect is
+// undone when the control leaves the current scope.
+//
+// The message argument can be anything streamable to std::ostream.
+//
+// In the implementation, we include the current line number as part
+// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
+// to appear in the same block - as long as they are on different
+// lines.
+//
+// Assuming that each thread maintains its own stack of traces.
+// Therefore, a SCOPED_TRACE() would (correctly) only affect the
+// assertions in its own thread.
+#define SCOPED_TRACE(message) \
+  ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
+    __FILE__, __LINE__, (message))
+
+// Compile-time assertion for type equality.
+// StaticAssertTypeEq<type1, type2>() compiles if and only if type1 and type2
+// are the same type.  The value it returns is not interesting.
+//
+// Instead of making StaticAssertTypeEq a class template, we make it a
+// function template that invokes a helper class template.  This
+// prevents a user from misusing StaticAssertTypeEq<T1, T2> by
+// defining objects of that type.
+//
+// CAVEAT:
+//
+// When used inside a method of a class template,
+// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
+// instantiated.  For example, given:
+//
+//   template <typename T> class Foo {
+//    public:
+//     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
+//   };
+//
+// the code:
+//
+//   void Test1() { Foo<bool> foo; }
+//
+// will NOT generate a compiler error, as Foo<bool>::Bar() is never
+// actually instantiated.  Instead, you need:
+//
+//   void Test2() { Foo<bool> foo; foo.Bar(); }
+//
+// to cause a compiler error.
+template <typename T1, typename T2>
+constexpr bool StaticAssertTypeEq() noexcept {
+  static_assert(std::is_same<T1, T2>::value, "T1 and T2 are not the same type");
+  return true;
+}
+
+// Defines a test.
+//
+// The first parameter is the name of the test suite, and the second
+// parameter is the name of the test within the test suite.
+//
+// The convention is to end the test suite name with "Test".  For
+// example, a test suite for the Foo class can be named FooTest.
+//
+// Test code should appear between braces after an invocation of
+// this macro.  Example:
+//
+//   TEST(FooTest, InitializesCorrectly) {
+//     Foo foo;
+//     EXPECT_TRUE(foo.StatusIsOK());
+//   }
+
+// Note that we call GetTestTypeId() instead of GetTypeId<
+// ::testing::Test>() here to get the type ID of testing::Test.  This
+// is to work around a suspected linker bug when using Google Test as
+// a framework on Mac OS X.  The bug causes GetTypeId<
+// ::testing::Test>() to return different values depending on whether
+// the call is from the Google Test framework itself or from user test
+// code.  GetTestTypeId() is guaranteed to always return the same
+// value, as it always calls GetTypeId<>() from the Google Test
+// framework.
+#define GTEST_TEST(test_suite_name, test_name)             \
+  GTEST_TEST_(test_suite_name, test_name, ::testing::Test, \
+              ::testing::internal::GetTestTypeId())
+
+// Define this macro to 1 to omit the definition of TEST(), which
+// is a generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_TEST
+#define TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name, test_name)
+#endif
+
+// Defines a test that uses a test fixture.
+//
+// The first parameter is the name of the test fixture class, which
+// also doubles as the test suite name.  The second parameter is the
+// name of the test within the test suite.
+//
+// A test fixture class must be declared earlier.  The user should put
+// the test code between braces after using this macro.  Example:
+//
+//   class FooTest : public testing::Test {
+//    protected:
+//     void SetUp() override { b_.AddElement(3); }
+//
+//     Foo a_;
+//     Foo b_;
+//   };
+//
+//   TEST_F(FooTest, InitializesCorrectly) {
+//     EXPECT_TRUE(a_.StatusIsOK());
+//   }
+//
+//   TEST_F(FooTest, ReturnsElementCountCorrectly) {
+//     EXPECT_EQ(a_.size(), 0);
+//     EXPECT_EQ(b_.size(), 1);
+//   }
+//
+// GOOGLETEST_CM0011 DO NOT DELETE
+#if !GTEST_DONT_DEFINE_TEST
+#define TEST_F(test_fixture, test_name)\
+  GTEST_TEST_(test_fixture, test_name, test_fixture, \
+              ::testing::internal::GetTypeId<test_fixture>())
+#endif  // !GTEST_DONT_DEFINE_TEST
+
+// Returns a path to temporary directory.
+// Tries to determine an appropriate directory for the platform.
+GTEST_API_ std::string TempDir();
+
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif
+
+// Dynamically registers a test with the framework.
+//
+// This is an advanced API only to be used when the `TEST` macros are
+// insufficient. The macros should be preferred when possible, as they avoid
+// most of the complexity of calling this function.
+//
+// The `factory` argument is a factory callable (move-constructible) object or
+// function pointer that creates a new instance of the Test object. It
+// handles ownership to the caller. The signature of the callable is
+// `Fixture*()`, where `Fixture` is the test fixture class for the test. All
+// tests registered with the same `test_suite_name` must return the same
+// fixture type. This is checked at runtime.
+//
+// The framework will infer the fixture class from the factory and will call
+// the `SetUpTestSuite` and `TearDownTestSuite` for it.
+//
+// Must be called before `RUN_ALL_TESTS()` is invoked, otherwise behavior is
+// undefined.
+//
+// Use case example:
+//
+// class MyFixture : public ::testing::Test {
+//  public:
+//   // All of these optional, just like in regular macro usage.
+//   static void SetUpTestSuite() { ... }
+//   static void TearDownTestSuite() { ... }
+//   void SetUp() override { ... }
+//   void TearDown() override { ... }
+// };
+//
+// class MyTest : public MyFixture {
+//  public:
+//   explicit MyTest(int data) : data_(data) {}
+//   void TestBody() override { ... }
+//
+//  private:
+//   int data_;
+// };
+//
+// void RegisterMyTests(const std::vector<int>& values) {
+//   for (int v : values) {
+//     ::testing::RegisterTest(
+//         "MyFixture", ("Test" + std::to_string(v)).c_str(), nullptr,
+//         std::to_string(v).c_str(),
+//         __FILE__, __LINE__,
+//         // Important to use the fixture type as the return type here.
+//         [=]() -> MyFixture* { return new MyTest(v); });
+//   }
+// }
+// ...
+// int main(int argc, char** argv) {
+//   std::vector<int> values_to_test = LoadValuesFromConfig();
+//   RegisterMyTests(values_to_test);
+//   ...
+//   return RUN_ALL_TESTS();
+// }
+//
+template <int&... ExplicitParameterBarrier, typename Factory>
+TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
+                       const char* type_param, const char* value_param,
+                       const char* file, int line, Factory factory) {
+  using TestT = typename std::remove_pointer<decltype(factory())>::type;
+
+  class FactoryImpl : public internal::TestFactoryBase {
+   public:
+    explicit FactoryImpl(Factory f) : factory_(std::move(f)) {}
+    Test* CreateTest() override { return factory_(); }
+
+   private:
+    Factory factory_;
+  };
+
+  return internal::MakeAndRegisterTestInfo(
+      test_suite_name, test_name, type_param, value_param,
+      internal::CodeLocation(file, line), internal::GetTypeId<TestT>(),
+      internal::SuiteApiResolver<TestT>::GetSetUpCaseOrSuite(file, line),
+      internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(file, line),
+      new FactoryImpl{std::move(factory)});
+}
+
+}  // namespace testing
+
+// Use this function in main() to run all tests.  It returns 0 if all
+// tests are successful, or 1 otherwise.
+//
+// RUN_ALL_TESTS() should be invoked after the command line has been
+// parsed by InitGoogleTest().
+//
+// This function was formerly a macro; thus, it is in the global
+// namespace and has an all-caps name.
+int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
+
+inline int RUN_ALL_TESTS() {
+  return ::testing::UnitTest::GetInstance()->Run();
+}
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/header-only-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/header-only-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..570f09a563a760004337d54b39f50697fc127d74
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/header-only-test.cc
@@ -0,0 +1,11 @@
+// Header-only configuration test
+
+#include "fmt/core.h"
+#include "fmt/ostream.h"
+#include "gtest/gtest.h"
+
+#ifndef FMT_HEADER_ONLY
+#  error "Not in the header-only mode."
+#endif
+
+TEST(header_only_test, format) { EXPECT_EQ(fmt::format("foo"), "foo"); }
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/mock-allocator.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/mock-allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..dc4942f1758dfb5af3aa65d7c0c3cdcec9ff7009
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/mock-allocator.h
@@ -0,0 +1,64 @@
+// Formatting library for C++ - mock allocator
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_MOCK_ALLOCATOR_H_
+#define FMT_MOCK_ALLOCATOR_H_
+
+#include <assert.h>  // assert
+#include <stddef.h>  // size_t
+
+#include <memory>  // std::allocator_traits
+
+#include "gmock/gmock.h"
+
+template <typename T> class mock_allocator {
+ public:
+  mock_allocator() {}
+  mock_allocator(const mock_allocator&) {}
+  using value_type = T;
+  MOCK_METHOD(T*, allocate, (size_t));
+  MOCK_METHOD(void, deallocate, (T*, size_t));
+};
+
+template <typename Allocator> class allocator_ref {
+ private:
+  Allocator* alloc_;
+
+  void move(allocator_ref& other) {
+    alloc_ = other.alloc_;
+    other.alloc_ = nullptr;
+  }
+
+ public:
+  using value_type = typename Allocator::value_type;
+
+  explicit allocator_ref(Allocator* alloc = nullptr) : alloc_(alloc) {}
+
+  allocator_ref(const allocator_ref& other) : alloc_(other.alloc_) {}
+  allocator_ref(allocator_ref&& other) { move(other); }
+
+  allocator_ref& operator=(allocator_ref&& other) {
+    assert(this != &other);
+    move(other);
+    return *this;
+  }
+
+  allocator_ref& operator=(const allocator_ref& other) {
+    alloc_ = other.alloc_;
+    return *this;
+  }
+
+ public:
+  Allocator* get() const { return alloc_; }
+
+  value_type* allocate(size_t n) {
+    return std::allocator_traits<Allocator>::allocate(*alloc_, n);
+  }
+  void deallocate(value_type* p, size_t n) { alloc_->deallocate(p, n); }
+};
+
+#endif  // FMT_MOCK_ALLOCATOR_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/module-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/module-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bd9624f9a14efb78f933e633193a5f152cf99294
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/module-test.cc
@@ -0,0 +1,520 @@
+// Formatting library for C++ - module tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+//
+// Copyright (c) 2021 - present, Daniela Engert
+// All Rights Reserved
+// {fmt} module.
+
+#ifdef _MSC_FULL_VER
+// hide some implementation bugs in msvc
+// that are not essential to users of the module.
+#  define FMT_HIDE_MODULE_BUGS
+#endif
+
+#include <bit>
+#include <chrono>
+#include <exception>
+#include <iterator>
+#include <locale>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <string_view>
+#include <system_error>
+
+#if (__has_include(<fcntl.h>) || defined(__APPLE__) || \
+     defined(__linux__)) &&                              \
+    (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+#  include <fcntl.h>
+#  define FMT_USE_FCNTL 1
+#else
+#  define FMT_USE_FCNTL 0
+#endif
+#if defined(_WIN32) && !defined(__MINGW32__)
+#  define FMT_POSIX(call) _##call
+#else
+#  define FMT_POSIX(call) call
+#endif
+
+import fmt;
+
+// check for macros leaking from BMI
+static bool macro_leaked =
+#if defined(FMT_CORE_H_) || defined(FMT_FORMAT_H_)
+    true;
+#else
+    false;
+#endif
+
+#define FMT_OS_H_  // don't pull in os.h, neither directly nor indirectly
+#include "gtest-extra.h"
+
+// an implicitly exported namespace must be visible [module.interface]/2.2
+TEST(module_test, namespace) {
+  using namespace fmt;
+  using namespace fmt::literals;
+  ASSERT_TRUE(true);
+}
+
+namespace detail {
+bool oops_detail_namespace_is_visible;
+}
+
+namespace fmt {
+bool namespace_detail_invisible() {
+#if defined(FMT_HIDE_MODULE_BUGS) && defined(_MSC_FULL_VER) && \
+    _MSC_FULL_VER <= 193700000
+  // bug in msvc up to at least 17.7:
+
+  // the namespace is visible even when it is neither
+  // implicitly nor explicitly exported
+  return true;
+#else
+  using namespace detail;
+  // this fails to compile if fmt::detail is visible
+  return !oops_detail_namespace_is_visible;
+#endif
+}
+}  // namespace fmt
+
+// the non-exported namespace 'detail' must be invisible [module.interface]/2
+TEST(module_test, detail_namespace) {
+  EXPECT_TRUE(fmt::namespace_detail_invisible());
+}
+
+// macros must not be imported from a *named* module  [cpp.import]/5.1
+TEST(module_test, macros) {
+#if defined(FMT_HIDE_MODULE_BUGS) && defined(_MSC_FULL_VER) && \
+    _MSC_FULL_VER <= 192930130
+  // bug in msvc up to 16.11-pre2:
+  // include-guard macros leak from BMI
+  // and even worse: they cannot be #undef-ined
+  macro_leaked = false;
+#endif
+  EXPECT_FALSE(macro_leaked);
+}
+
+// The following is less about functional testing (that's done elsewhere)
+// but rather visibility of all client-facing overloads, reachability of
+// non-exported entities, name lookup and overload resolution within
+// template instantitions.
+// Exercise all exported entities of the API at least once.
+// Instantiate as many code paths as possible.
+
+TEST(module_test, to_string) {
+  EXPECT_EQ("42", fmt::to_string(42));
+  EXPECT_EQ("42", fmt::to_string(42.0));
+
+  EXPECT_EQ(L"42", fmt::to_wstring(42));
+  EXPECT_EQ(L"42", fmt::to_wstring(42.0));
+}
+
+TEST(module_test, format) {
+  EXPECT_EQ("42", fmt::format("{:}", 42));
+  EXPECT_EQ("-42", fmt::format("{0}", -42.0));
+
+  EXPECT_EQ(L"42", fmt::format(L"{:}", 42));
+  EXPECT_EQ(L"-42", fmt::format(L"{0}", -42.0));
+}
+
+TEST(module_test, format_to) {
+  std::string s;
+  fmt::format_to(std::back_inserter(s), "{}", 42);
+  EXPECT_EQ("42", s);
+
+  char buffer[4] = {0};
+  fmt::format_to(buffer, "{}", 42);
+  EXPECT_EQ("42", std::string_view(buffer));
+
+  fmt::memory_buffer mb;
+  fmt::format_to(std::back_inserter(mb), "{}", 42);
+  EXPECT_EQ("42", std::string_view(buffer));
+
+  std::wstring w;
+  fmt::format_to(std::back_inserter(w), L"{}", 42);
+  EXPECT_EQ(L"42", w);
+
+  wchar_t wbuffer[4] = {0};
+  fmt::format_to(wbuffer, L"{}", 42);
+  EXPECT_EQ(L"42", std::wstring_view(wbuffer));
+
+  fmt::wmemory_buffer wb;
+  fmt::format_to(std::back_inserter(wb), L"{}", 42);
+  EXPECT_EQ(L"42", std::wstring_view(wbuffer));
+}
+
+TEST(module_test, formatted_size) {
+  EXPECT_EQ(2u, fmt::formatted_size("{}", 42));
+  EXPECT_EQ(2u, fmt::formatted_size(L"{}", 42));
+}
+
+TEST(module_test, format_to_n) {
+  std::string s;
+  auto result = fmt::format_to_n(std::back_inserter(s), 1, "{}", 42);
+  EXPECT_EQ(2u, result.size);
+  char buffer[4] = {0};
+  fmt::format_to_n(buffer, 3, "{}", 12345);
+
+  std::wstring w;
+  auto wresult = fmt::format_to_n(std::back_inserter(w), 1, L"{}", 42);
+  EXPECT_EQ(2u, wresult.size);
+  wchar_t wbuffer[4] = {0};
+  fmt::format_to_n(wbuffer, 3, L"{}", 12345);
+}
+
+TEST(module_test, format_args) {
+  auto no_args = fmt::format_args();
+  EXPECT_FALSE(no_args.get(1));
+
+  fmt::basic_format_args args = fmt::make_format_args(42);
+  EXPECT_TRUE(args.max_size() > 0);
+  auto arg0 = args.get(0);
+  EXPECT_TRUE(arg0);
+  decltype(arg0) arg_none;
+  EXPECT_FALSE(arg_none);
+  EXPECT_TRUE(arg0.type() != arg_none.type());
+}
+
+TEST(module_test, wformat_args) {
+  auto no_args = fmt::wformat_args();
+  EXPECT_FALSE(no_args.get(1));
+  fmt::basic_format_args args = fmt::make_wformat_args(42);
+  EXPECT_TRUE(args.get(0));
+}
+
+TEST(module_test, dynamic_format_args) {
+  fmt::dynamic_format_arg_store<fmt::format_context> dyn_store;
+  dyn_store.push_back(fmt::arg("a42", 42));
+  fmt::basic_format_args args = dyn_store;
+  EXPECT_FALSE(args.get(3));
+  EXPECT_TRUE(args.get(fmt::string_view("a42")));
+
+  fmt::dynamic_format_arg_store<fmt::wformat_context> wdyn_store;
+  wdyn_store.push_back(fmt::arg(L"a42", 42));
+  fmt::basic_format_args wargs = wdyn_store;
+  EXPECT_FALSE(wargs.get(3));
+  EXPECT_TRUE(wargs.get(fmt::wstring_view(L"a42")));
+}
+
+TEST(module_test, vformat) {
+  EXPECT_EQ("42", fmt::vformat("{}", fmt::make_format_args(42)));
+  EXPECT_EQ(L"42",
+            fmt::vformat(fmt::wstring_view(L"{}"), fmt::make_wformat_args(42)));
+}
+
+TEST(module_test, vformat_to) {
+  auto store = fmt::make_format_args(42);
+  std::string s;
+  fmt::vformat_to(std::back_inserter(s), "{}", store);
+  EXPECT_EQ("42", s);
+
+  char buffer[4] = {0};
+  fmt::vformat_to(buffer, "{:}", store);
+  EXPECT_EQ("42", std::string_view(buffer));
+
+  auto wstore = fmt::make_wformat_args(42);
+  std::wstring w;
+  fmt::vformat_to(std::back_inserter(w), L"{}", wstore);
+  EXPECT_EQ(L"42", w);
+
+  wchar_t wbuffer[4] = {0};
+  fmt::vformat_to(wbuffer, L"{:}", wstore);
+  EXPECT_EQ(L"42", std::wstring_view(wbuffer));
+}
+
+TEST(module_test, vformat_to_n) {
+  auto store = fmt::make_format_args(12345);
+  std::string s;
+  auto result = fmt::vformat_to_n(std::back_inserter(s), 1, "{}", store);
+  char buffer[4] = {0};
+  fmt::vformat_to_n(buffer, 3, "{:}", store);
+
+  auto wstore = fmt::make_wformat_args(12345);
+  std::wstring w;
+  auto wresult = fmt::vformat_to_n(std::back_inserter(w), 1,
+                                   fmt::wstring_view(L"{}"), wstore);
+  wchar_t wbuffer[4] = {0};
+  fmt::vformat_to_n(wbuffer, 3, fmt::wstring_view(L"{:}"), wstore);
+}
+
+std::string as_string(std::wstring_view text) {
+  return {reinterpret_cast<const char*>(text.data()),
+          text.size() * sizeof(text[0])};
+}
+
+TEST(module_test, print) {
+  EXPECT_WRITE(stdout, fmt::print("{}µ", 42), "42µ");
+  EXPECT_WRITE(stderr, fmt::print(stderr, "{}µ", 4.2), "4.2µ");
+  EXPECT_WRITE(stdout, fmt::print(L"{}µ", 42), as_string(L"42µ"));
+  EXPECT_WRITE(stderr, fmt::print(stderr, L"{}µ", 4.2), as_string(L"4.2µ"));
+}
+
+TEST(module_test, vprint) {
+  EXPECT_WRITE(stdout, fmt::vprint("{:}µ", fmt::make_format_args(42)), "42µ");
+  EXPECT_WRITE(stderr, fmt::vprint(stderr, "{}", fmt::make_format_args(4.2)),
+               "4.2");
+  EXPECT_WRITE(stdout, fmt::vprint(L"{:}µ", fmt::make_wformat_args(42)),
+               as_string(L"42µ"));
+  EXPECT_WRITE(stderr, fmt::vprint(stderr, L"{}", fmt::make_wformat_args(42)),
+               as_string(L"42"));
+}
+
+TEST(module_test, named_args) {
+  EXPECT_EQ("42", fmt::format("{answer}", fmt::arg("answer", 42)));
+  EXPECT_EQ(L"42", fmt::format(L"{answer}", fmt::arg(L"answer", 42)));
+}
+
+TEST(module_test, literals) {
+  using namespace fmt::literals;
+  EXPECT_EQ("42", fmt::format("{answer}", "answer"_a = 42));
+  EXPECT_EQ(L"42", fmt::format(L"{answer}", L"answer"_a = 42));
+}
+
+TEST(module_test, locale) {
+  auto store = fmt::make_format_args(4.2);
+  const auto classic = std::locale::classic();
+  EXPECT_EQ("4.2", fmt::format(classic, "{:L}", 4.2));
+  EXPECT_EQ("4.2", fmt::vformat(classic, "{:L}", store));
+  std::string s;
+  fmt::vformat_to(std::back_inserter(s), classic, "{:L}", store);
+  EXPECT_EQ("4.2", s);
+  EXPECT_EQ("4.2", fmt::format("{:L}", 4.2));
+
+  auto wstore = fmt::make_wformat_args(4.2);
+  EXPECT_EQ(L"4.2", fmt::format(classic, L"{:L}", 4.2));
+  EXPECT_EQ(L"4.2", fmt::vformat(classic, L"{:L}", wstore));
+  std::wstring w;
+  fmt::vformat_to(std::back_inserter(w), classic, L"{:L}", wstore);
+  EXPECT_EQ(L"4.2", w);
+  EXPECT_EQ(L"4.2", fmt::format(L"{:L}", 4.2));
+}
+
+TEST(module_test, string_view) {
+  fmt::string_view nsv("fmt");
+  EXPECT_EQ("fmt", nsv);
+  EXPECT_TRUE(fmt::string_view("fmt") == nsv);
+
+  fmt::wstring_view wsv(L"fmt");
+  EXPECT_EQ(L"fmt", wsv);
+  EXPECT_TRUE(fmt::wstring_view(L"fmt") == wsv);
+}
+
+TEST(module_test, memory_buffer) {
+  fmt::basic_memory_buffer<char, fmt::inline_buffer_size> buffer;
+  fmt::format_to(std::back_inserter(buffer), "{}", "42");
+  EXPECT_EQ("42", to_string(buffer));
+  fmt::memory_buffer nbuffer(std::move(buffer));
+  EXPECT_EQ("42", to_string(nbuffer));
+  buffer = std::move(nbuffer);
+  EXPECT_EQ("42", to_string(buffer));
+  nbuffer.clear();
+  EXPECT_EQ(0u, to_string(nbuffer).size());
+
+  fmt::wmemory_buffer wbuffer;
+  EXPECT_EQ(0u, to_string(wbuffer).size());
+}
+
+TEST(module_test, is_char) {
+  EXPECT_TRUE(fmt::is_char<char>());
+  EXPECT_TRUE(fmt::is_char<wchar_t>());
+  EXPECT_TRUE(fmt::is_char<char8_t>());
+  EXPECT_TRUE(fmt::is_char<char16_t>());
+  EXPECT_TRUE(fmt::is_char<char32_t>());
+  EXPECT_FALSE(fmt::is_char<signed char>());
+}
+
+TEST(module_test, ptr) {
+  uintptr_t answer = 42;
+  auto p = std::bit_cast<int*>(answer);
+  EXPECT_EQ("0x2a", fmt::to_string(fmt::ptr(p)));
+  std::unique_ptr<int> up(p);
+  EXPECT_EQ("0x2a", fmt::to_string(fmt::ptr(up)));
+  up.release();
+  auto sp = std::make_shared<int>(0);
+  p = sp.get();
+  EXPECT_EQ(fmt::to_string(fmt::ptr(p)), fmt::to_string(fmt::ptr(sp)));
+}
+
+TEST(module_test, errors) {
+  auto store = fmt::make_format_args(42);
+  EXPECT_THROW(throw fmt::format_error("oops"), std::exception);
+  EXPECT_THROW(throw fmt::vsystem_error(0, "{}", store), std::system_error);
+  EXPECT_THROW(throw fmt::system_error(0, "{}", 42), std::system_error);
+
+  fmt::memory_buffer buffer;
+  fmt::format_system_error(buffer, 0, "oops");
+  auto oops = to_string(buffer);
+  EXPECT_TRUE(oops.size() > 0);
+  EXPECT_WRITE(stderr, fmt::report_system_error(0, "oops"), oops + '\n');
+
+#ifdef _WIN32
+  EXPECT_THROW(throw fmt::vwindows_error(0, "{}", store), std::system_error);
+  EXPECT_THROW(throw fmt::windows_error(0, "{}", 42), std::system_error);
+  output_redirect redirect(stderr);
+  fmt::report_windows_error(0, "oops");
+  EXPECT_TRUE(redirect.restore_and_read().size() > 0);
+#endif
+}
+
+TEST(module_test, error_code) {
+  EXPECT_EQ("generic:42",
+            fmt::format("{0}", std::error_code(42, std::generic_category())));
+  EXPECT_EQ("system:42",
+            fmt::format("{0}", std::error_code(42, fmt::system_category())));
+  EXPECT_EQ(L"generic:42",
+            fmt::format(L"{0}", std::error_code(42, std::generic_category())));
+}
+
+TEST(module_test, format_int) {
+  fmt::format_int sanswer(42);
+  EXPECT_EQ("42", fmt::string_view(sanswer.data(), sanswer.size()));
+  fmt::format_int uanswer(42u);
+  EXPECT_EQ("42", fmt::string_view(uanswer.data(), uanswer.size()));
+}
+
+struct test_formatter : fmt::formatter<char> {
+  bool check() { return true; }
+};
+
+TEST(module_test, formatter) { EXPECT_TRUE(test_formatter{}.check()); }
+
+TEST(module_test, join) {
+  int arr[3] = {1, 2, 3};
+  std::vector<double> vec{1.0, 2.0, 3.0};
+  std::initializer_list<int> il{1, 2, 3};
+  auto sep = fmt::string_view(", ");
+  EXPECT_EQ("1, 2, 3", to_string(fmt::join(arr + 0, arr + 3, sep)));
+  EXPECT_EQ("1, 2, 3", to_string(fmt::join(arr, sep)));
+  EXPECT_EQ("1, 2, 3", to_string(fmt::join(vec.begin(), vec.end(), sep)));
+  EXPECT_EQ("1, 2, 3", to_string(fmt::join(vec, sep)));
+  EXPECT_EQ("1, 2, 3", to_string(fmt::join(il, sep)));
+
+  auto wsep = fmt::wstring_view(L", ");
+  EXPECT_EQ(L"1, 2, 3", fmt::format(L"{}", fmt::join(arr + 0, arr + 3, wsep)));
+  EXPECT_EQ(L"1, 2, 3", fmt::format(L"{}", fmt::join(arr, wsep)));
+  EXPECT_EQ(L"1, 2, 3", fmt::format(L"{}", fmt::join(il, wsep)));
+}
+
+TEST(module_test, time) {
+  auto time_now = std::time(nullptr);
+  EXPECT_TRUE(fmt::localtime(time_now).tm_year > 120);
+  EXPECT_TRUE(fmt::gmtime(time_now).tm_year > 120);
+  auto chrono_now = std::chrono::system_clock::now();
+  EXPECT_TRUE(fmt::gmtime(chrono_now).tm_year > 120);
+}
+
+TEST(module_test, time_point) {
+  auto now = std::chrono::system_clock::now();
+  std::string_view past("2021-05-20 10:30:15");
+  EXPECT_TRUE(past < fmt::format("{:%Y-%m-%d %H:%M:%S}", now));
+  std::wstring_view wpast(L"2021-05-20 10:30:15");
+  EXPECT_TRUE(wpast < fmt::format(L"{:%Y-%m-%d %H:%M:%S}", now));
+}
+
+TEST(module_test, time_duration) {
+  using us = std::chrono::duration<double, std::micro>;
+  EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds{42}));
+  EXPECT_EQ("4.2µs", fmt::format("{:3.1}", us{4.234}));
+  EXPECT_EQ("4.2µs", fmt::format(std::locale::classic(), "{:L}", us{4.2}));
+
+  EXPECT_EQ(L"42s", fmt::format(L"{}", std::chrono::seconds{42}));
+  EXPECT_EQ(L"4.2µs", fmt::format(L"{:3.1}", us{4.234}));
+  EXPECT_EQ(L"4.2µs", fmt::format(std::locale::classic(), L"{:L}", us{4.2}));
+}
+
+TEST(module_test, weekday) {
+  EXPECT_EQ("Mon", fmt::format(std::locale::classic(), "{}", fmt::weekday(1)));
+}
+
+TEST(module_test, printf) {
+  EXPECT_WRITE(stdout, fmt::printf("%f", 42.123456), "42.123456");
+  EXPECT_WRITE(stdout, fmt::printf("%d", 42), "42");
+  EXPECT_WRITE(stdout, fmt::printf(L"%f", 42.123456), as_string(L"42.123456"));
+  EXPECT_WRITE(stdout, fmt::printf(L"%d", 42), as_string(L"42"));
+}
+
+TEST(module_test, fprintf) {
+  EXPECT_WRITE(stderr, fmt::fprintf(stderr, "%d", 42), "42");
+  EXPECT_WRITE(stderr, fmt::fprintf(stderr, L"%d", 42), as_string(L"42"));
+}
+
+TEST(module_test, sprintf) {
+  EXPECT_EQ("42", fmt::sprintf("%d", 42));
+  EXPECT_EQ(L"42", fmt::sprintf(L"%d", 42));
+}
+
+TEST(module_test, vprintf) {
+  EXPECT_WRITE(stdout, fmt::vprintf("%d", fmt::make_printf_args(42)), "42");
+  EXPECT_WRITE(stdout, fmt::vprintf(L"%d", fmt::make_wprintf_args(42)),
+               as_string(L"42"));
+}
+
+TEST(module_test, vfprintf) {
+  auto args = fmt::make_printf_args(42);
+  EXPECT_WRITE(stderr, fmt::vfprintf(stderr, "%d", args), "42");
+  auto wargs = fmt::make_wprintf_args(42);
+  EXPECT_WRITE(stderr, fmt::vfprintf(stderr, L"%d", wargs), as_string(L"42"));
+}
+
+TEST(module_test, vsprintf) {
+  EXPECT_EQ("42", fmt::vsprintf("%d", fmt::make_printf_args(42)));
+  EXPECT_EQ(L"42", fmt::vsprintf(L"%d", fmt::make_wprintf_args(42)));
+}
+
+TEST(module_test, color) {
+  auto fg_check = fg(fmt::rgb(255, 200, 30));
+  auto bg_check = bg(fmt::color::dark_slate_gray) | fmt::emphasis::italic;
+  auto emphasis_check = fmt::emphasis::underline | fmt::emphasis::bold;
+  EXPECT_EQ("\x1B[30m42\x1B[0m",
+            fmt::format(fg(fmt::terminal_color::black), "{}", 42));
+  EXPECT_EQ(L"\x1B[30m42\x1B[0m",
+            fmt::format(fg(fmt::terminal_color::black), L"{}", 42));
+}
+
+TEST(module_test, cstring_view) {
+  auto s = "fmt";
+  EXPECT_EQ(s, fmt::cstring_view(s).c_str());
+  auto w = L"fmt";
+  EXPECT_EQ(w, fmt::wcstring_view(w).c_str());
+}
+
+TEST(module_test, buffered_file) {
+  EXPECT_TRUE(fmt::buffered_file{}.get() == nullptr);
+}
+
+TEST(module_test, output_file) {
+#ifdef __clang__
+  fmt::println("\033[0;33m[=disabled=] {}\033[0;0m",
+               "Clang 16.0 emits multiple copies of vtables");
+#else
+  fmt::ostream out = fmt::output_file("module-test", fmt::buffer_size = 1);
+  out.close();
+#endif
+}
+
+struct custom_context {
+  using char_type = char;
+  using parse_context_type = fmt::format_parse_context;
+};
+
+TEST(module_test, custom_context) {
+  fmt::basic_format_arg<custom_context> custom_arg;
+  EXPECT_TRUE(!custom_arg);
+}
+
+TEST(module_test, compile_format_string) {
+  using namespace fmt::literals;
+#ifdef __clang__
+  fmt::println("\033[0;33m[=disabled=] {}\033[0;0m",
+               "Clang 16.0 fails to import user-defined literals");
+#else
+  EXPECT_EQ("42", fmt::format("{0:x}"_cf, 0x42));
+  EXPECT_EQ(L"42", fmt::format(L"{:}"_cf, 42));
+  EXPECT_EQ("4.2", fmt::format("{arg:3.1f}"_cf, "arg"_a = 4.2));
+  EXPECT_EQ(L" 42", fmt::format(L"{arg:>3}"_cf, L"arg"_a = L"42"));
+#endif
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/noexception-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/noexception-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bf3472fd101307c2c715c32119a716d3e7a90911
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/noexception-test.cc
@@ -0,0 +1,18 @@
+// Formatting library for C++ - Noexception tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/args.h"
+#include "fmt/chrono.h"
+#include "fmt/color.h"
+#include "fmt/compile.h"
+#include "fmt/core.h"
+#include "fmt/format.h"
+#include "fmt/os.h"
+#include "fmt/ostream.h"
+#include "fmt/printf.h"
+#include "fmt/ranges.h"
+#include "fmt/xchar.h"
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/os-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/os-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1e6c7c4b39aa5c1e9b0c17353ebf28bc2adf6c49
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/os-test.cc
@@ -0,0 +1,506 @@
+// Formatting library for C++ - tests of the OS-specific functionality
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/os.h"
+
+#include <cstdlib>  // std::exit
+#include <cstring>
+#include <memory>
+
+#include "gtest-extra.h"
+#include "util.h"
+
+using fmt::buffered_file;
+using testing::HasSubstr;
+using wstring_view = fmt::basic_string_view<wchar_t>;
+
+#ifdef _WIN32
+
+#  include <windows.h>
+
+TEST(os_test, format_windows_error) {
+  LPWSTR message = nullptr;
+  auto result = FormatMessageW(
+      FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+          FORMAT_MESSAGE_IGNORE_INSERTS,
+      nullptr, ERROR_FILE_EXISTS, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+      reinterpret_cast<LPWSTR>(&message), 0, nullptr);
+  auto utf8_message =
+      fmt::detail::to_utf8<wchar_t>(wstring_view(message, result - 2));
+  LocalFree(message);
+  fmt::memory_buffer actual_message;
+  fmt::detail::format_windows_error(actual_message, ERROR_FILE_EXISTS, "test");
+  EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
+            fmt::to_string(actual_message));
+  actual_message.resize(0);
+}
+
+TEST(os_test, format_long_windows_error) {
+  LPWSTR message = nullptr;
+  // this error code is not available on all Windows platforms and
+  // Windows SDKs, so do not fail the test if the error string cannot
+  // be retrieved.
+  int provisioning_not_allowed = 0x80284013L;  // TBS_E_PROVISIONING_NOT_ALLOWED
+  auto result = FormatMessageW(
+      FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+          FORMAT_MESSAGE_IGNORE_INSERTS,
+      nullptr, static_cast<DWORD>(provisioning_not_allowed),
+      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+      reinterpret_cast<LPWSTR>(&message), 0, nullptr);
+  if (result == 0) {
+    LocalFree(message);
+    return;
+  }
+  auto utf8_message =
+      fmt::detail::to_utf8<wchar_t>(wstring_view(message, result - 2));
+  LocalFree(message);
+  fmt::memory_buffer actual_message;
+  fmt::detail::format_windows_error(actual_message, provisioning_not_allowed,
+                                    "test");
+  EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
+            fmt::to_string(actual_message));
+}
+
+TEST(os_test, windows_error) {
+  auto error = std::system_error(std::error_code());
+  try {
+    throw fmt::windows_error(ERROR_FILE_EXISTS, "test {}", "error");
+  } catch (const std::system_error& e) {
+    error = e;
+  }
+  fmt::memory_buffer message;
+  fmt::detail::format_windows_error(message, ERROR_FILE_EXISTS, "test error");
+  EXPECT_THAT(error.what(), HasSubstr(to_string(message)));
+  EXPECT_EQ(ERROR_FILE_EXISTS, error.code().value());
+}
+
+TEST(os_test, report_windows_error) {
+  fmt::memory_buffer out;
+  fmt::detail::format_windows_error(out, ERROR_FILE_EXISTS, "test error");
+  out.push_back('\n');
+  EXPECT_WRITE(stderr,
+               fmt::report_windows_error(ERROR_FILE_EXISTS, "test error"),
+               fmt::to_string(out));
+}
+
+#  if FMT_USE_FCNTL && !defined(__MINGW32__)
+TEST(file_test, open_windows_file) {
+  using fmt::file;
+  file out = file::open_windows_file(L"test-file",
+                                     file::WRONLY | file::CREATE | file::TRUNC);
+  out.write("x", 1);
+  file in = file::open_windows_file(L"test-file", file::RDONLY);
+  EXPECT_READ(in, "x");
+}
+#  endif  // FMT_USE_FCNTL && !defined(__MINGW32__)
+
+#endif  // _WIN32
+
+#if FMT_USE_FCNTL
+
+using fmt::file;
+
+bool isclosed(int fd) {
+  char buffer;
+  auto result = std::streamsize();
+  SUPPRESS_ASSERT(result = FMT_POSIX(read(fd, &buffer, 1)));
+  return result == -1 && errno == EBADF;
+}
+
+// Opens a file for reading.
+file open_file() {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  write_end.write(file_content, std::strlen(file_content));
+  write_end.close();
+  return read_end;
+}
+
+// Attempts to write a string to a file.
+void write(file& f, fmt::string_view s) {
+  size_t num_chars_left = s.size();
+  const char* ptr = s.data();
+  do {
+    size_t count = f.write(ptr, num_chars_left);
+    ptr += count;
+    // We can't write more than size_t bytes since num_chars_left
+    // has type size_t.
+    num_chars_left -= count;
+  } while (num_chars_left != 0);
+}
+
+TEST(buffered_file_test, default_ctor) {
+  auto f = buffered_file();
+  EXPECT_TRUE(f.get() == nullptr);
+}
+
+TEST(buffered_file_test, move_ctor) {
+  buffered_file bf = open_buffered_file();
+  FILE* fp = bf.get();
+  EXPECT_TRUE(fp != nullptr);
+  buffered_file bf2(std::move(bf));
+  EXPECT_EQ(fp, bf2.get());
+  EXPECT_TRUE(bf.get() == nullptr);
+}
+
+TEST(buffered_file_test, move_assignment) {
+  buffered_file bf = open_buffered_file();
+  FILE* fp = bf.get();
+  EXPECT_TRUE(fp != nullptr);
+  buffered_file bf2;
+  bf2 = std::move(bf);
+  EXPECT_EQ(fp, bf2.get());
+  EXPECT_TRUE(bf.get() == nullptr);
+}
+
+TEST(buffered_file_test, move_assignment_closes_file) {
+  buffered_file bf = open_buffered_file();
+  buffered_file bf2 = open_buffered_file();
+  int old_fd = bf2.descriptor();
+  bf2 = std::move(bf);
+  EXPECT_TRUE(isclosed(old_fd));
+}
+
+TEST(buffered_file_test, move_from_temporary_in_ctor) {
+  FILE* fp = nullptr;
+  buffered_file f = open_buffered_file(&fp);
+  EXPECT_EQ(fp, f.get());
+}
+
+TEST(buffered_file_test, move_from_temporary_in_assignment) {
+  FILE* fp = nullptr;
+  auto f = buffered_file();
+  f = open_buffered_file(&fp);
+  EXPECT_EQ(fp, f.get());
+}
+
+TEST(buffered_file_test, move_from_temporary_in_assignment_closes_file) {
+  buffered_file f = open_buffered_file();
+  int old_fd = f.descriptor();
+  f = open_buffered_file();
+  EXPECT_TRUE(isclosed(old_fd));
+}
+
+TEST(buffered_file_test, close_file_in_dtor) {
+  int fd = 0;
+  {
+    buffered_file f = open_buffered_file();
+    fd = f.descriptor();
+  }
+  EXPECT_TRUE(isclosed(fd));
+}
+
+TEST(buffered_file_test, close_error_in_dtor) {
+  auto f =
+      std::unique_ptr<buffered_file>(new buffered_file(open_buffered_file()));
+  EXPECT_WRITE(
+      stderr,
+      {
+        // The close function must be called inside EXPECT_WRITE,
+        // otherwise the system may recycle closed file descriptor when
+        // redirecting the output in EXPECT_STDERR and the second close
+        // will break output redirection.
+        FMT_POSIX(close(f->descriptor()));
+        SUPPRESS_ASSERT(f.reset(nullptr));
+      },
+      system_error_message(EBADF, "cannot close file") + "\n");
+}
+
+TEST(buffered_file_test, close) {
+  buffered_file f = open_buffered_file();
+  int fd = f.descriptor();
+  f.close();
+  EXPECT_TRUE(f.get() == nullptr);
+  EXPECT_TRUE(isclosed(fd));
+}
+
+TEST(buffered_file_test, close_error) {
+  buffered_file f = open_buffered_file();
+  FMT_POSIX(close(f.descriptor()));
+  EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file");
+  EXPECT_TRUE(f.get() == nullptr);
+}
+
+TEST(buffered_file_test, descriptor) {
+  auto f = open_buffered_file();
+  EXPECT_TRUE(f.descriptor() != -1);
+  file copy = file::dup(f.descriptor());
+  EXPECT_READ(copy, file_content);
+}
+
+TEST(ostream_test, move) {
+  fmt::ostream out = fmt::output_file("test-file");
+  fmt::ostream moved(std::move(out));
+  moved.print("hello");
+}
+
+TEST(ostream_test, move_while_holding_data) {
+  {
+    fmt::ostream out = fmt::output_file("test-file");
+    out.print("Hello, ");
+    fmt::ostream moved(std::move(out));
+    moved.print("world!\n");
+  }
+  {
+    file in("test-file", file::RDONLY);
+    EXPECT_READ(in, "Hello, world!\n");
+  }
+}
+
+TEST(ostream_test, print) {
+  fmt::ostream out = fmt::output_file("test-file");
+  out.print("The answer is {}.\n",
+            fmt::join(std::initializer_list<int>{42}, ", "));
+  out.close();
+  file in("test-file", file::RDONLY);
+  EXPECT_READ(in, "The answer is 42.\n");
+}
+
+TEST(ostream_test, buffer_boundary) {
+  auto str = std::string(4096, 'x');
+  fmt::ostream out = fmt::output_file("test-file");
+  out.print("{}", str);
+  out.print("{}", str);
+  out.close();
+  file in("test-file", file::RDONLY);
+  EXPECT_READ(in, str + str);
+}
+
+TEST(ostream_test, buffer_size) {
+  fmt::ostream out = fmt::output_file("test-file", fmt::buffer_size = 1);
+  out.print("{}", "foo");
+  out.close();
+  file in("test-file", file::RDONLY);
+  EXPECT_READ(in, "foo");
+}
+
+TEST(ostream_test, truncate) {
+  {
+    fmt::ostream out = fmt::output_file("test-file");
+    out.print("0123456789");
+  }
+  {
+    fmt::ostream out = fmt::output_file("test-file");
+    out.print("foo");
+  }
+  file in("test-file", file::RDONLY);
+  EXPECT_EQ("foo", read(in, 4));
+}
+
+TEST(ostream_test, flush) {
+  auto out = fmt::output_file("test-file");
+  out.print("x");
+  out.flush();
+  auto in = fmt::file("test-file", file::RDONLY);
+  EXPECT_READ(in, "x");
+}
+
+TEST(file_test, default_ctor) {
+  file f;
+  EXPECT_EQ(-1, f.descriptor());
+}
+
+TEST(file_test, open_buffered_file_in_ctor) {
+  FILE* fp = safe_fopen("test-file", "w");
+  std::fputs(file_content, fp);
+  std::fclose(fp);
+  file f("test-file", file::RDONLY);
+  // Check if the file is open by reading one character from it.
+  char buffer;
+  bool isopen = FMT_POSIX(read(f.descriptor(), &buffer, 1)) == 1;
+  ASSERT_TRUE(isopen);
+}
+
+TEST(file_test, open_buffered_file_error) {
+  EXPECT_SYSTEM_ERROR(file("nonexistent", file::RDONLY), ENOENT,
+                      "cannot open file nonexistent");
+}
+
+TEST(file_test, move_ctor) {
+  file f = open_file();
+  int fd = f.descriptor();
+  EXPECT_NE(-1, fd);
+  file f2(std::move(f));
+  EXPECT_EQ(fd, f2.descriptor());
+  EXPECT_EQ(-1, f.descriptor());
+}
+
+TEST(file_test, move_assignment) {
+  file f = open_file();
+  int fd = f.descriptor();
+  EXPECT_NE(-1, fd);
+  file f2;
+  f2 = std::move(f);
+  EXPECT_EQ(fd, f2.descriptor());
+  EXPECT_EQ(-1, f.descriptor());
+}
+
+TEST(file_test, move_assignment_closes_file) {
+  file f = open_file();
+  file f2 = open_file();
+  int old_fd = f2.descriptor();
+  f2 = std::move(f);
+  EXPECT_TRUE(isclosed(old_fd));
+}
+
+file open_buffered_file(int& fd) {
+  file f = open_file();
+  fd = f.descriptor();
+  return f;
+}
+
+TEST(file_test, move_from_temporary_in_ctor) {
+  int fd = 0xdead;
+  file f(open_buffered_file(fd));
+  EXPECT_EQ(fd, f.descriptor());
+}
+
+TEST(file_test, move_from_temporary_in_assignment) {
+  int fd = 0xdead;
+  file f;
+  f = open_buffered_file(fd);
+  EXPECT_EQ(fd, f.descriptor());
+}
+
+TEST(file_test, move_from_temporary_in_assignment_closes_file) {
+  int fd = 0xdead;
+  file f = open_file();
+  int old_fd = f.descriptor();
+  f = open_buffered_file(fd);
+  EXPECT_TRUE(isclosed(old_fd));
+}
+
+TEST(file_test, close_file_in_dtor) {
+  int fd = 0;
+  {
+    file f = open_file();
+    fd = f.descriptor();
+  }
+  EXPECT_TRUE(isclosed(fd));
+}
+
+TEST(file_test, close_error_in_dtor) {
+  std::unique_ptr<file> f(new file(open_file()));
+  EXPECT_WRITE(
+      stderr,
+      {
+        // The close function must be called inside EXPECT_WRITE,
+        // otherwise the system may recycle closed file descriptor when
+        // redirecting the output in EXPECT_STDERR and the second close
+        // will break output redirection.
+        FMT_POSIX(close(f->descriptor()));
+        SUPPRESS_ASSERT(f.reset(nullptr));
+      },
+      system_error_message(EBADF, "cannot close file") + "\n");
+}
+
+TEST(file_test, close) {
+  file f = open_file();
+  int fd = f.descriptor();
+  f.close();
+  EXPECT_EQ(-1, f.descriptor());
+  EXPECT_TRUE(isclosed(fd));
+}
+
+TEST(file_test, close_error) {
+  file f = open_file();
+  FMT_POSIX(close(f.descriptor()));
+  EXPECT_SYSTEM_ERROR_NOASSERT(f.close(), EBADF, "cannot close file");
+  EXPECT_EQ(-1, f.descriptor());
+}
+
+TEST(file_test, read) {
+  file f = open_file();
+  EXPECT_READ(f, file_content);
+}
+
+TEST(file_test, read_error) {
+  file f("test-file", file::WRONLY);
+  char buf;
+  // We intentionally read from a file opened in the write-only mode to
+  // cause error.
+  EXPECT_SYSTEM_ERROR(f.read(&buf, 1), EBADF, "cannot read from file");
+}
+
+TEST(file_test, write) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  write(write_end, "test");
+  write_end.close();
+  EXPECT_READ(read_end, "test");
+}
+
+TEST(file_test, write_error) {
+  file f("test-file", file::RDONLY);
+  // We intentionally write to a file opened in the read-only mode to
+  // cause error.
+  EXPECT_SYSTEM_ERROR(f.write(" ", 1), EBADF, "cannot write to file");
+}
+
+TEST(file_test, dup) {
+  file f = open_file();
+  file copy = file::dup(f.descriptor());
+  EXPECT_NE(f.descriptor(), copy.descriptor());
+  EXPECT_EQ(file_content, read(copy, std::strlen(file_content)));
+}
+
+#  ifndef __COVERITY__
+TEST(file_test, dup_error) {
+  int value = -1;
+  EXPECT_SYSTEM_ERROR_NOASSERT(file::dup(value), EBADF,
+                               "cannot duplicate file descriptor -1");
+}
+#  endif
+
+TEST(file_test, dup2) {
+  file f = open_file();
+  file copy = open_file();
+  f.dup2(copy.descriptor());
+  EXPECT_NE(f.descriptor(), copy.descriptor());
+  EXPECT_READ(copy, file_content);
+}
+
+TEST(file_test, dup2_error) {
+  file f = open_file();
+  EXPECT_SYSTEM_ERROR_NOASSERT(
+      f.dup2(-1), EBADF,
+      fmt::format("cannot duplicate file descriptor {} to -1", f.descriptor()));
+}
+
+TEST(file_test, dup2_noexcept) {
+  file f = open_file();
+  file copy = open_file();
+  std::error_code ec;
+  f.dup2(copy.descriptor(), ec);
+  EXPECT_EQ(ec.value(), 0);
+  EXPECT_NE(f.descriptor(), copy.descriptor());
+  EXPECT_READ(copy, file_content);
+}
+
+TEST(file_test, dup2_noexcept_error) {
+  file f = open_file();
+  std::error_code ec;
+  SUPPRESS_ASSERT(f.dup2(-1, ec));
+  EXPECT_EQ(EBADF, ec.value());
+}
+
+TEST(file_test, pipe) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  EXPECT_NE(-1, read_end.descriptor());
+  EXPECT_NE(-1, write_end.descriptor());
+  write(write_end, "test");
+  EXPECT_READ(read_end, "test");
+}
+
+TEST(file_test, fdopen) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  int read_fd = read_end.descriptor();
+  EXPECT_EQ(read_fd, FMT_POSIX(fileno(read_end.fdopen("r").get())));
+}
+#endif  // FMT_USE_FCNTL
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/ostream-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/ostream-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..98ee0757b2e4b12412684f3a28cc2d153863e222
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/ostream-test.cc
@@ -0,0 +1,308 @@
+// Formatting library for C++ - std::ostream support tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <fstream>
+
+#include "fmt/format.h"
+
+using fmt::runtime;
+
+struct test {};
+
+// Test that there is no issues with specializations when fmt/ostream.h is
+// included after fmt/format.h.
+namespace fmt {
+template <> struct formatter<test> : formatter<int> {
+  auto format(const test&, format_context& ctx) const -> decltype(ctx.out()) {
+    return formatter<int>::format(42, ctx);
+  }
+};
+}  // namespace fmt
+
+#include <sstream>
+
+#include "fmt/compile.h"
+#include "fmt/ostream.h"
+#include "fmt/ranges.h"
+#include "gmock/gmock.h"
+#include "gtest-extra.h"
+#include "util.h"
+
+auto operator<<(std::ostream& os, const date& d) -> std::ostream& {
+  os << d.year() << '-' << d.month() << '-' << d.day();
+  return os;
+}
+
+auto operator<<(std::wostream& os, const date& d) -> std::wostream& {
+  os << d.year() << L'-' << d.month() << L'-' << d.day();
+  return os;
+}
+
+// Make sure that overloaded comma operators do no harm to is_streamable.
+struct type_with_comma_op {};
+template <typename T> void operator,(type_with_comma_op, const T&);
+template <typename T> type_with_comma_op operator<<(T&, const date&);
+
+enum streamable_enum {};
+
+auto operator<<(std::ostream& os, streamable_enum) -> std::ostream& {
+  return os << "streamable_enum";
+}
+
+enum unstreamable_enum {};
+auto format_as(unstreamable_enum e) -> int { return e; }
+
+struct empty_test {};
+auto operator<<(std::ostream& os, empty_test) -> std::ostream& {
+  return os << "";
+}
+
+namespace fmt {
+template <> struct formatter<test_string> : ostream_formatter {};
+template <> struct formatter<date> : ostream_formatter {};
+template <> struct formatter<streamable_enum> : ostream_formatter {};
+template <> struct formatter<empty_test> : ostream_formatter {};
+}  // namespace fmt
+
+TEST(ostream_test, enum) {
+  EXPECT_EQ("streamable_enum", fmt::format("{}", streamable_enum()));
+  EXPECT_EQ("0", fmt::format("{}", unstreamable_enum()));
+}
+
+TEST(ostream_test, format) {
+  EXPECT_EQ("a string", fmt::format("{0}", test_string("a string")));
+  EXPECT_EQ("The date is 2012-12-9",
+            fmt::format("The date is {0}", date(2012, 12, 9)));
+}
+
+TEST(ostream_test, format_specs) {
+  using fmt::format_error;
+  EXPECT_EQ("def  ", fmt::format("{0:<5}", test_string("def")));
+  EXPECT_EQ("  def", fmt::format("{0:>5}", test_string("def")));
+  EXPECT_EQ(" def ", fmt::format("{0:^5}", test_string("def")));
+  EXPECT_EQ("def**", fmt::format("{0:*<5}", test_string("def")));
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:+}"), test_string()),
+                   format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:-}"), test_string()),
+                   format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0: }"), test_string()),
+                   format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:#}"), test_string()),
+                   format_error, "invalid format specifier");
+  EXPECT_THROW_MSG((void)fmt::format(runtime("{0:05}"), test_string()),
+                   format_error, "format specifier requires numeric argument");
+  EXPECT_EQ("test         ", fmt::format("{0:13}", test_string("test")));
+  EXPECT_EQ("test         ", fmt::format("{0:{1}}", test_string("test"), 13));
+  EXPECT_EQ("te", fmt::format("{0:.2}", test_string("test")));
+  EXPECT_EQ("te", fmt::format("{0:.{1}}", test_string("test"), 2));
+}
+
+TEST(ostream_test, empty_custom_output) {
+  EXPECT_EQ("", fmt::format("{}", empty_test()));
+}
+
+TEST(ostream_test, print) {
+  {
+    std::ostringstream os;
+    fmt::print(os, "Don't {}!", "panic");
+    EXPECT_EQ("Don't panic!", os.str());
+  }
+
+  {
+    std::ostringstream os;
+    fmt::println(os, "Don't {}!", "panic");
+    EXPECT_EQ("Don't panic!\n", os.str());
+  }
+}
+
+TEST(ostream_test, write_to_ostream) {
+  std::ostringstream os;
+  fmt::memory_buffer buffer;
+  const char* foo = "foo";
+  buffer.append(foo, foo + std::strlen(foo));
+  fmt::detail::write_buffer(os, buffer);
+  EXPECT_EQ("foo", os.str());
+}
+
+TEST(ostream_test, write_to_ostream_max_size) {
+  auto max_size = fmt::detail::max_value<size_t>();
+  auto max_streamsize = fmt::detail::max_value<std::streamsize>();
+  if (max_size <= fmt::detail::to_unsigned(max_streamsize)) return;
+
+  struct test_buffer final : fmt::detail::buffer<char> {
+    explicit test_buffer(size_t size)
+        : fmt::detail::buffer<char>(nullptr, size, size) {}
+    void grow(size_t) override {}
+  } buffer(max_size);
+
+  struct mock_streambuf : std::streambuf {
+    MOCK_METHOD(std::streamsize, xsputn, (const void*, std::streamsize));
+    auto xsputn(const char* s, std::streamsize n) -> std::streamsize override {
+      const void* v = s;
+      return xsputn(v, n);
+    }
+  } streambuf;
+
+  struct test_ostream : std::ostream {
+    explicit test_ostream(mock_streambuf& output_buffer)
+        : std::ostream(&output_buffer) {}
+  } os(streambuf);
+
+  testing::InSequence sequence;
+  const char* data = nullptr;
+  using ustreamsize = std::make_unsigned<std::streamsize>::type;
+  ustreamsize size = max_size;
+  do {
+    auto n = std::min(size, fmt::detail::to_unsigned(max_streamsize));
+    EXPECT_CALL(streambuf, xsputn(data, static_cast<std::streamsize>(n)))
+        .WillOnce(testing::Return(max_streamsize));
+    data += n;
+    size -= n;
+  } while (size != 0);
+  fmt::detail::write_buffer(os, buffer);
+}
+
+TEST(ostream_test, join) {
+  int v[3] = {1, 2, 3};
+  EXPECT_EQ("1, 2, 3", fmt::format("{}", fmt::join(v, v + 3, ", ")));
+}
+
+TEST(ostream_test, join_fallback_formatter) {
+  auto strs = std::vector<test_string>{test_string("foo"), test_string("bar")};
+  EXPECT_EQ("foo, bar", fmt::format("{}", fmt::join(strs, ", ")));
+}
+
+#if FMT_USE_CONSTEXPR
+TEST(ostream_test, constexpr_string) {
+  EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), std::string("42")));
+  EXPECT_EQ("a string",
+            fmt::format(FMT_STRING("{0}"), test_string("a string")));
+}
+#endif
+
+namespace fmt_test {
+struct abc {};
+
+template <typename Output> auto operator<<(Output& out, abc) -> Output& {
+  return out << "abc";
+}
+}  // namespace fmt_test
+
+template <typename T> struct test_template {};
+
+template <typename T>
+auto operator<<(std::ostream& os, test_template<T>) -> std::ostream& {
+  return os << 1;
+}
+
+namespace fmt {
+template <typename T> struct formatter<test_template<T>> : formatter<int> {
+  auto format(test_template<T>, format_context& ctx) -> decltype(ctx.out()) {
+    return formatter<int>::format(2, ctx);
+  }
+};
+
+template <> struct formatter<fmt_test::abc> : ostream_formatter {};
+}  // namespace fmt
+
+TEST(ostream_test, template) {
+  EXPECT_EQ("2", fmt::format("{}", test_template<int>()));
+}
+
+TEST(ostream_test, format_to_n) {
+  char buffer[4];
+  buffer[3] = 'x';
+  auto result = fmt::format_to_n(buffer, 3, "{}", fmt_test::abc());
+  EXPECT_EQ(3u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ("abcx", fmt::string_view(buffer, 4));
+  result = fmt::format_to_n(buffer, 3, "x{}y", fmt_test::abc());
+  EXPECT_EQ(5u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ("xabx", fmt::string_view(buffer, 4));
+}
+
+struct copyfmt_test {};
+
+std::ostream& operator<<(std::ostream& os, copyfmt_test) {
+  std::ios ios(nullptr);
+  ios.copyfmt(os);
+  return os << "foo";
+}
+
+namespace fmt {
+template <> struct formatter<copyfmt_test> : ostream_formatter {};
+}  // namespace fmt
+
+TEST(ostream_test, copyfmt) {
+  EXPECT_EQ("foo", fmt::format("{}", copyfmt_test()));
+}
+
+TEST(ostream_test, to_string) {
+  EXPECT_EQ("abc", fmt::to_string(fmt_test::abc()));
+}
+
+TEST(ostream_test, range) {
+  auto strs = std::vector<test_string>{test_string("foo"), test_string("bar")};
+  EXPECT_EQ("[foo, bar]", fmt::format("{}", strs));
+}
+
+struct abstract {
+  virtual ~abstract() = default;
+  virtual void f() = 0;
+  friend auto operator<<(std::ostream& os, const abstract&) -> std::ostream& {
+    return os;
+  }
+};
+
+namespace fmt {
+template <> struct formatter<abstract> : ostream_formatter {};
+}  // namespace fmt
+
+void format_abstract_compiles(const abstract& a) {
+  fmt::format(FMT_COMPILE("{}"), a);
+}
+
+TEST(ostream_test, is_formattable) {
+  EXPECT_TRUE(fmt::is_formattable<std::string>());
+  EXPECT_TRUE(fmt::is_formattable<fmt::detail::std_string_view<char>>());
+}
+
+struct streamable_and_unformattable {};
+
+auto operator<<(std::ostream& os, streamable_and_unformattable)
+    -> std::ostream& {
+  return os << "foo";
+}
+
+TEST(ostream_test, streamed) {
+  EXPECT_FALSE(fmt::is_formattable<streamable_and_unformattable>());
+  EXPECT_EQ(fmt::format("{}", fmt::streamed(streamable_and_unformattable())),
+            "foo");
+}
+
+TEST(ostream_test, closed_ofstream) {
+  std::ofstream ofs;
+  fmt::print(ofs, "discard");
+}
+
+struct unlocalized {};
+
+auto operator<<(std::ostream& os, unlocalized)
+    -> std::ostream& {
+  return os << 12345;
+}
+
+namespace fmt {
+template <> struct formatter<unlocalized> : ostream_formatter {};
+}  // namespace fmt
+
+TEST(ostream_test, unlocalized) {
+  auto loc = get_locale("en_US.UTF-8");
+  std::locale::global(loc);
+  EXPECT_EQ(fmt::format(loc, "{}", unlocalized()), "12345");
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/posix-mock-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/posix-mock-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..32078bf8a5966018966d8a053ebf2c3021e62029
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/posix-mock-test.cc
@@ -0,0 +1,453 @@
+// Tests of the C++ interface to POSIX functions that require mocks
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+// Disable bogus MSVC warnings.
+#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
+#  define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "posix-mock.h"
+
+#include <errno.h>
+#include <fcntl.h>
+
+#include <climits>
+#include <memory>
+
+#include "../src/os.cc"
+
+#ifdef _WIN32
+#  include <io.h>
+#  undef max
+#endif
+
+#include "gmock/gmock.h"
+#include "gtest-extra.h"
+#include "util.h"
+
+using fmt::buffered_file;
+
+using testing::_;
+using testing::Return;
+using testing::StrEq;
+
+template <typename Mock> struct scoped_mock : testing::StrictMock<Mock> {
+  scoped_mock() { Mock::instance = this; }
+  ~scoped_mock() { Mock::instance = nullptr; }
+};
+
+namespace {
+int open_count;
+int close_count;
+int dup_count;
+int dup2_count;
+int fdopen_count;
+int read_count;
+int write_count;
+int pipe_count;
+int fopen_count;
+int fclose_count;
+int fileno_count;
+size_t read_nbyte;
+size_t write_nbyte;
+bool sysconf_error;
+
+enum { none, max_size, error } fstat_sim;
+}  // namespace
+
+#define EMULATE_EINTR(func, error_result) \
+  if (func##_count != 0) {                \
+    if (func##_count++ != 3) {            \
+      errno = EINTR;                      \
+      return error_result;                \
+    }                                     \
+  }
+
+#ifndef _MSC_VER
+int test::open(const char* path, int oflag, int mode) {
+  EMULATE_EINTR(open, -1);
+  return ::open(path, oflag, mode);
+}
+#endif
+
+#ifndef _WIN32
+
+long test::sysconf(int name) {
+  long result = ::sysconf(name);
+  if (!sysconf_error) return result;
+  // Simulate an error.
+  errno = EINVAL;
+  return -1;
+}
+
+static off_t max_file_size() { return std::numeric_limits<off_t>::max(); }
+
+int test::fstat(int fd, struct stat* buf) {
+  int result = ::fstat(fd, buf);
+  if (fstat_sim == max_size) buf->st_size = max_file_size();
+  return result;
+}
+
+#else
+
+static LONGLONG max_file_size() { return std::numeric_limits<LONGLONG>::max(); }
+
+DWORD test::GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) {
+  if (fstat_sim == error) {
+    SetLastError(ERROR_ACCESS_DENIED);
+    return INVALID_FILE_SIZE;
+  }
+  if (fstat_sim == max_size) {
+    DWORD max = std::numeric_limits<DWORD>::max();
+    *lpFileSizeHigh = max >> 1;
+    return max;
+  }
+  return ::GetFileSize(hFile, lpFileSizeHigh);
+}
+
+#endif
+
+int test::close(int fildes) {
+  // Close the file first because close shouldn't be retried.
+  int result = ::FMT_POSIX(close(fildes));
+  EMULATE_EINTR(close, -1);
+  return result;
+}
+
+int test::dup(int fildes) {
+  EMULATE_EINTR(dup, -1);
+  return ::FMT_POSIX(dup(fildes));
+}
+
+int test::dup2(int fildes, int fildes2) {
+  EMULATE_EINTR(dup2, -1);
+  return ::FMT_POSIX(dup2(fildes, fildes2));
+}
+
+FILE* test::fdopen(int fildes, const char* mode) {
+  EMULATE_EINTR(fdopen, nullptr);
+  return ::FMT_POSIX(fdopen(fildes, mode));
+}
+
+test::ssize_t test::read(int fildes, void* buf, test::size_t nbyte) {
+  read_nbyte = nbyte;
+  EMULATE_EINTR(read, -1);
+  return ::FMT_POSIX(read(fildes, buf, nbyte));
+}
+
+test::ssize_t test::write(int fildes, const void* buf, test::size_t nbyte) {
+  write_nbyte = nbyte;
+  EMULATE_EINTR(write, -1);
+  return ::FMT_POSIX(write(fildes, buf, nbyte));
+}
+
+#ifndef _WIN32
+int test::pipe(int fildes[2]) {
+  EMULATE_EINTR(pipe, -1);
+  return ::pipe(fildes);
+}
+#else
+int test::pipe(int* pfds, unsigned psize, int textmode) {
+  EMULATE_EINTR(pipe, -1);
+  return _pipe(pfds, psize, textmode);
+}
+#endif
+
+FILE* test::fopen(const char* filename, const char* mode) {
+  EMULATE_EINTR(fopen, nullptr);
+  return ::fopen(filename, mode);
+}
+
+int test::fclose(FILE* stream) {
+  EMULATE_EINTR(fclose, EOF);
+  return ::fclose(stream);
+}
+
+int(test::fileno)(FILE* stream) {
+  EMULATE_EINTR(fileno, -1);
+#ifdef fileno
+  return FMT_POSIX(fileno(stream));
+#else
+  return ::FMT_POSIX(fileno(stream));
+#endif
+}
+
+#ifndef _WIN32
+#  define EXPECT_RETRY(statement, func, message) \
+    func##_count = 1;                            \
+    statement;                                   \
+    EXPECT_EQ(4, func##_count);                  \
+    func##_count = 0;
+#  define EXPECT_EQ_POSIX(expected, actual) EXPECT_EQ(expected, actual)
+#else
+#  define EXPECT_RETRY(statement, func, message)    \
+    func##_count = 1;                               \
+    EXPECT_SYSTEM_ERROR(statement, EINTR, message); \
+    func##_count = 0;
+#  define EXPECT_EQ_POSIX(expected, actual)
+#endif
+
+#if FMT_USE_FCNTL
+void write_file(fmt::cstring_view filename, fmt::string_view content) {
+  fmt::buffered_file f(filename, "w");
+  f.print("{}", content);
+}
+
+using fmt::file;
+
+TEST(os_test, getpagesize) {
+#  ifdef _WIN32
+  SYSTEM_INFO si = {};
+  GetSystemInfo(&si);
+  EXPECT_EQ(si.dwPageSize, fmt::getpagesize());
+#  else
+  EXPECT_EQ(sysconf(_SC_PAGESIZE), fmt::getpagesize());
+  sysconf_error = true;
+  EXPECT_SYSTEM_ERROR(fmt::getpagesize(), EINVAL,
+                      "cannot get memory page size");
+  sysconf_error = false;
+#  endif
+}
+
+TEST(file_test, open_retry) {
+#  ifndef _WIN32
+  write_file("temp", "there must be something here");
+  std::unique_ptr<file> f{nullptr};
+  EXPECT_RETRY(f.reset(new file("temp", file::RDONLY)), open,
+               "cannot open file temp");
+  char c = 0;
+  f->read(&c, 1);
+#  endif
+}
+
+TEST(file_test, close_no_retry_in_dtor) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  std::unique_ptr<file> f(new file(std::move(read_end)));
+  int saved_close_count = 0;
+  EXPECT_WRITE(
+      stderr,
+      {
+        close_count = 1;
+        f.reset(nullptr);
+        saved_close_count = close_count;
+        close_count = 0;
+      },
+      system_error_message(EINTR, "cannot close file") + "\n");
+  EXPECT_EQ(2, saved_close_count);
+}
+
+TEST(file_test, close_no_retry) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  close_count = 1;
+  EXPECT_SYSTEM_ERROR(read_end.close(), EINTR, "cannot close file");
+  EXPECT_EQ(2, close_count);
+  close_count = 0;
+}
+
+TEST(file_test, size) {
+  std::string content = "top secret, destroy before reading";
+  write_file("temp", content);
+  file f("temp", file::RDONLY);
+  EXPECT_GE(f.size(), 0);
+  EXPECT_EQ(content.size(), static_cast<unsigned long long>(f.size()));
+#  ifdef _WIN32
+  auto error_code = std::error_code();
+  fstat_sim = error;
+  try {
+    f.size();
+  } catch (const std::system_error& e) {
+    error_code = e.code();
+  }
+  fstat_sim = none;
+  EXPECT_EQ(error_code,
+            std::error_code(ERROR_ACCESS_DENIED, fmt::system_category()));
+#  else
+  f.close();
+  EXPECT_SYSTEM_ERROR(f.size(), EBADF, "cannot get file attributes");
+#  endif
+}
+
+TEST(file_test, max_size) {
+  write_file("temp", "");
+  file f("temp", file::RDONLY);
+  fstat_sim = max_size;
+  EXPECT_GE(f.size(), 0);
+  EXPECT_EQ(max_file_size(), f.size());
+  fstat_sim = none;
+}
+
+TEST(file_test, read_retry) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  enum { SIZE = 4 };
+  write_end.write("test", SIZE);
+  write_end.close();
+  char buffer[SIZE];
+  size_t count = 0;
+  EXPECT_RETRY(count = read_end.read(buffer, SIZE), read,
+               "cannot read from file");
+  EXPECT_EQ_POSIX(static_cast<std::streamsize>(SIZE), count);
+}
+
+TEST(file_test, write_retry) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  enum { SIZE = 4 };
+  size_t count = 0;
+  EXPECT_RETRY(count = write_end.write("test", SIZE), write,
+               "cannot write to file");
+  write_end.close();
+#  ifndef _WIN32
+  EXPECT_EQ(static_cast<std::streamsize>(SIZE), count);
+  char buffer[SIZE + 1];
+  read_end.read(buffer, SIZE);
+  buffer[SIZE] = '\0';
+  EXPECT_STREQ("test", buffer);
+#  endif
+}
+
+#  ifdef _WIN32
+TEST(file_test, convert_read_count) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  char c;
+  size_t size = UINT_MAX;
+  if (sizeof(unsigned) != sizeof(size_t)) ++size;
+  read_count = 1;
+  read_nbyte = 0;
+  EXPECT_THROW(read_end.read(&c, size), std::system_error);
+  read_count = 0;
+  EXPECT_EQ(UINT_MAX, read_nbyte);
+}
+
+TEST(file_test, convert_write_count) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  char c;
+  size_t size = UINT_MAX;
+  if (sizeof(unsigned) != sizeof(size_t)) ++size;
+  write_count = 1;
+  write_nbyte = 0;
+  EXPECT_THROW(write_end.write(&c, size), std::system_error);
+  write_count = 0;
+  EXPECT_EQ(UINT_MAX, write_nbyte);
+}
+#  endif
+
+TEST(file_test, dup_no_retry) {
+  int stdout_fd = FMT_POSIX(fileno(stdout));
+  dup_count = 1;
+  EXPECT_SYSTEM_ERROR(
+      file::dup(stdout_fd), EINTR,
+      fmt::format("cannot duplicate file descriptor {}", stdout_fd));
+  dup_count = 0;
+}
+
+TEST(file_test, dup2_retry) {
+  int stdout_fd = FMT_POSIX(fileno(stdout));
+  file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd);
+  EXPECT_RETRY(f1.dup2(f2.descriptor()), dup2,
+               fmt::format("cannot duplicate file descriptor {} to {}",
+                           f1.descriptor(), f2.descriptor()));
+}
+
+TEST(file_test, dup2_no_except_retry) {
+  int stdout_fd = FMT_POSIX(fileno(stdout));
+  file f1 = file::dup(stdout_fd), f2 = file::dup(stdout_fd);
+  std::error_code ec;
+  dup2_count = 1;
+  f1.dup2(f2.descriptor(), ec);
+#  ifndef _WIN32
+  EXPECT_EQ(4, dup2_count);
+#  else
+  EXPECT_EQ(EINTR, ec.value());
+#  endif
+  dup2_count = 0;
+}
+
+TEST(file_test, pipe_no_retry) {
+  file read_end, write_end;
+  pipe_count = 1;
+  EXPECT_SYSTEM_ERROR(file::pipe(read_end, write_end), EINTR,
+                      "cannot create pipe");
+  pipe_count = 0;
+}
+
+TEST(file_test, fdopen_no_retry) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  fdopen_count = 1;
+  EXPECT_SYSTEM_ERROR(read_end.fdopen("r"), EINTR,
+                      "cannot associate stream with file descriptor");
+  fdopen_count = 0;
+}
+
+TEST(buffered_file_test, open_retry) {
+  write_file("temp", "there must be something here");
+  std::unique_ptr<buffered_file> f{nullptr};
+  EXPECT_RETRY(f.reset(new buffered_file("temp", "r")), fopen,
+               "cannot open file temp");
+#  ifndef _WIN32
+  char c = 0;
+  if (fread(&c, 1, 1, f->get()) < 1)
+    throw fmt::system_error(errno, "fread failed");
+#  endif
+}
+
+TEST(buffered_file_test, close_no_retry_in_dtor) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  std::unique_ptr<buffered_file> f(new buffered_file(read_end.fdopen("r")));
+  int saved_fclose_count = 0;
+  EXPECT_WRITE(
+      stderr,
+      {
+        fclose_count = 1;
+        f.reset(nullptr);
+        saved_fclose_count = fclose_count;
+        fclose_count = 0;
+      },
+      system_error_message(EINTR, "cannot close file") + "\n");
+  EXPECT_EQ(2, saved_fclose_count);
+}
+
+TEST(buffered_file_test, close_no_retry) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  buffered_file f = read_end.fdopen("r");
+  fclose_count = 1;
+  EXPECT_SYSTEM_ERROR(f.close(), EINTR, "cannot close file");
+  EXPECT_EQ(2, fclose_count);
+  fclose_count = 0;
+}
+
+TEST(buffered_file_test, fileno_no_retry) {
+  file read_end, write_end;
+  file::pipe(read_end, write_end);
+  buffered_file f = read_end.fdopen("r");
+  fileno_count = 1;
+  EXPECT_SYSTEM_ERROR((f.descriptor)(), EINTR, "cannot get file descriptor");
+  EXPECT_EQ(2, fileno_count);
+  fileno_count = 0;
+}
+#endif  // FMT_USE_FCNTL
+
+struct test_mock {
+  static test_mock* instance;
+} * test_mock::instance;
+
+TEST(scoped_mock, scope) {
+  {
+    scoped_mock<test_mock> mock;
+    EXPECT_EQ(&mock, test_mock::instance);
+    test_mock& copy = mock;
+    static_cast<void>(copy);
+  }
+  EXPECT_EQ(nullptr, test_mock::instance);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/posix-mock.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/posix-mock.h
new file mode 100644
index 0000000000000000000000000000000000000000..545808717d50bbc6f1649232851dc58d1522f6b1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/posix-mock.h
@@ -0,0 +1,75 @@
+// Formatting library for C++ - mocks of POSIX functions
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_POSIX_TEST_H
+#define FMT_POSIX_TEST_H
+
+#include <errno.h>
+#include <locale.h>
+#include <stdio.h>
+#ifdef __APPLE__
+#  include <xlocale.h>
+#endif
+
+#ifdef _WIN32
+#  include <windows.h>
+#else
+#  include <sys/param.h>  // for FreeBSD version
+#  include <sys/types.h>  // for ssize_t
+#endif
+
+#ifndef _MSC_VER
+struct stat;
+#endif
+
+namespace test {
+
+#ifndef _MSC_VER
+// Size type for read and write.
+using size_t = size_t;
+using ssize_t = ssize_t;
+int open(const char* path, int oflag, int mode);
+int fstat(int fd, struct stat* buf);
+#else
+using size_t = unsigned;
+using ssize_t = int;
+#endif
+
+#ifndef _WIN32
+long sysconf(int name);
+#else
+DWORD GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh);
+#endif
+
+int close(int fildes);
+
+int dup(int fildes);
+int dup2(int fildes, int fildes2);
+
+FILE* fdopen(int fildes, const char* mode);
+
+ssize_t read(int fildes, void* buf, size_t nbyte);
+ssize_t write(int fildes, const void* buf, size_t nbyte);
+
+#ifndef _WIN32
+int pipe(int fildes[2]);
+#else
+int pipe(int* pfds, unsigned psize, int textmode);
+#endif
+
+FILE* fopen(const char* filename, const char* mode);
+int fclose(FILE* stream);
+int(fileno)(FILE* stream);
+
+#if defined(FMT_LOCALE) && !defined(_WIN32)
+locale_t newlocale(int category_mask, const char* locale, locale_t base);
+#endif
+}  // namespace test
+
+#define FMT_SYSTEM(call) test::call
+
+#endif  // FMT_POSIX_TEST_H
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/printf-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/printf-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7e09ecca7d9b1dfd15ca02fefa0d2f2c1141ce72
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/printf-test.cc
@@ -0,0 +1,560 @@
+// Formatting library for C++ - printf tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/printf.h"
+
+#include <cctype>
+#include <climits>
+#include <cstring>
+
+#include "fmt/xchar.h"
+#include "gtest-extra.h"
+#include "util.h"
+
+using fmt::format;
+using fmt::format_error;
+using fmt::detail::max_value;
+
+const unsigned big_num = INT_MAX + 1u;
+
+// Makes format string argument positional.
+static std::string make_positional(fmt::string_view format) {
+  std::string s(format.data(), format.size());
+  s.replace(s.find('%'), 1, "%1$");
+  return s;
+}
+
+static std::wstring make_positional(fmt::basic_string_view<wchar_t> format) {
+  std::wstring s(format.data(), format.size());
+  s.replace(s.find(L'%'), 1, L"%1$");
+  return s;
+}
+
+// A wrapper around fmt::sprintf to workaround bogus warnings about invalid
+// format strings in MSVC.
+template <typename... Args>
+std::string test_sprintf(fmt::string_view format, const Args&... args) {
+  return fmt::sprintf(format, args...);
+}
+template <typename... Args>
+std::wstring test_sprintf(fmt::basic_string_view<wchar_t> format,
+                          const Args&... args) {
+  return fmt::sprintf(format, args...);
+}
+
+#define EXPECT_PRINTF(expected_output, format, arg)     \
+  EXPECT_EQ(expected_output, test_sprintf(format, arg)) \
+      << "format: " << format;                          \
+  EXPECT_EQ(expected_output, fmt::sprintf(make_positional(format), arg))
+
+TEST(printf_test, no_args) {
+  EXPECT_EQ("test", test_sprintf("test"));
+  EXPECT_EQ(L"test", fmt::sprintf(L"test"));
+}
+
+TEST(printf_test, escape) {
+  EXPECT_EQ("%", test_sprintf("%%"));
+  EXPECT_EQ("before %", test_sprintf("before %%"));
+  EXPECT_EQ("% after", test_sprintf("%% after"));
+  EXPECT_EQ("before % after", test_sprintf("before %% after"));
+  EXPECT_EQ("%s", test_sprintf("%%s"));
+  EXPECT_EQ(L"%", fmt::sprintf(L"%%"));
+  EXPECT_EQ(L"before %", fmt::sprintf(L"before %%"));
+  EXPECT_EQ(L"% after", fmt::sprintf(L"%% after"));
+  EXPECT_EQ(L"before % after", fmt::sprintf(L"before %% after"));
+  EXPECT_EQ(L"%s", fmt::sprintf(L"%%s"));
+}
+
+TEST(printf_test, positional_args) {
+  EXPECT_EQ("42", test_sprintf("%1$d", 42));
+  EXPECT_EQ("before 42", test_sprintf("before %1$d", 42));
+  EXPECT_EQ("42 after", test_sprintf("%1$d after", 42));
+  EXPECT_EQ("before 42 after", test_sprintf("before %1$d after", 42));
+  EXPECT_EQ("answer = 42", test_sprintf("%1$s = %2$d", "answer", 42));
+  EXPECT_EQ("42 is the answer", test_sprintf("%2$d is the %1$s", "answer", 42));
+  EXPECT_EQ("abracadabra", test_sprintf("%1$s%2$s%1$s", "abra", "cad"));
+}
+
+TEST(printf_test, automatic_arg_indexing) {
+  EXPECT_EQ("abc", test_sprintf("%c%c%c", 'a', 'b', 'c'));
+}
+
+TEST(printf_test, number_is_too_big_in_arg_index) {
+  EXPECT_THROW_MSG(test_sprintf(format("%{}$", big_num)), format_error,
+                   "argument not found");
+  EXPECT_THROW_MSG(test_sprintf(format("%{}$d", big_num)), format_error,
+                   "argument not found");
+}
+
+TEST(printf_test, switch_arg_indexing) {
+  EXPECT_THROW_MSG(test_sprintf("%1$d%", 1, 2), format_error,
+                   "cannot switch from manual to automatic argument indexing");
+  EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", big_num), 1, 2),
+                   format_error, "number is too big");
+  EXPECT_THROW_MSG(test_sprintf("%1$d%d", 1, 2), format_error,
+                   "cannot switch from manual to automatic argument indexing");
+
+  EXPECT_THROW_MSG(test_sprintf("%d%1$", 1, 2), format_error,
+                   "cannot switch from automatic to manual argument indexing");
+  EXPECT_THROW_MSG(test_sprintf(format("%d%{}$d", big_num), 1, 2), format_error,
+                   "cannot switch from automatic to manual argument indexing");
+  EXPECT_THROW_MSG(test_sprintf("%d%1$d", 1, 2), format_error,
+                   "cannot switch from automatic to manual argument indexing");
+
+  // Indexing errors override width errors.
+  EXPECT_THROW_MSG(test_sprintf(format("%d%1${}d", big_num), 1, 2),
+                   format_error, "number is too big");
+  EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", big_num), 1, 2),
+                   format_error, "number is too big");
+}
+
+TEST(printf_test, invalid_arg_index) {
+  EXPECT_THROW_MSG(test_sprintf("%0$d", 42), format_error,
+                   "argument not found");
+  EXPECT_THROW_MSG(test_sprintf("%2$d", 42), format_error,
+                   "argument not found");
+  EXPECT_THROW_MSG(test_sprintf(format("%{}$d", INT_MAX), 42), format_error,
+                   "argument not found");
+
+  EXPECT_THROW_MSG(test_sprintf("%2$", 42), format_error, "argument not found");
+  EXPECT_THROW_MSG(test_sprintf(format("%{}$d", big_num), 42), format_error,
+                   "argument not found");
+}
+
+TEST(printf_test, default_align_right) {
+  EXPECT_PRINTF("   42", "%5d", 42);
+  EXPECT_PRINTF("  abc", "%5s", "abc");
+}
+
+TEST(printf_test, zero_flag) {
+  EXPECT_PRINTF("00042", "%05d", 42);
+  EXPECT_PRINTF("-0042", "%05d", -42);
+
+  EXPECT_PRINTF("00042", "%05d", 42);
+  EXPECT_PRINTF("-0042", "%05d", -42);
+  EXPECT_PRINTF("-004.2", "%06g", -4.2);
+
+  EXPECT_PRINTF("+00042", "%00+6d", 42);
+
+  EXPECT_PRINTF("   42", "%05.d", 42);
+  EXPECT_PRINTF(" 0042", "%05.4d", 42);
+
+  // '0' flag is ignored for non-numeric types.
+  EXPECT_PRINTF("    x", "%05c", 'x');
+}
+
+TEST(printf_test, plus_flag) {
+  EXPECT_PRINTF("+42", "%+d", 42);
+  EXPECT_PRINTF("-42", "%+d", -42);
+  EXPECT_PRINTF("+0042", "%+05d", 42);
+  EXPECT_PRINTF("+0042", "%0++5d", 42);
+
+  // '+' flag is ignored for non-numeric types.
+  EXPECT_PRINTF("x", "%+c", 'x');
+
+  // '+' flag wins over space flag
+  EXPECT_PRINTF("+42", "%+ d", 42);
+  EXPECT_PRINTF("-42", "%+ d", -42);
+  EXPECT_PRINTF("+42", "% +d", 42);
+  EXPECT_PRINTF("-42", "% +d", -42);
+  EXPECT_PRINTF("+0042", "% +05d", 42);
+  EXPECT_PRINTF("+0042", "%0+ 5d", 42);
+
+  // '+' flag and space flag are both ignored for non-numeric types.
+  EXPECT_PRINTF("x", "%+ c", 'x');
+  EXPECT_PRINTF("x", "% +c", 'x');
+}
+
+TEST(printf_test, minus_flag) {
+  EXPECT_PRINTF("abc  ", "%-5s", "abc");
+  EXPECT_PRINTF("abc  ", "%0--5s", "abc");
+
+  EXPECT_PRINTF("7    ", "%-5d", 7);
+  EXPECT_PRINTF("97   ", "%-5hhi", 'a');
+  EXPECT_PRINTF("a    ", "%-5c", 'a');
+
+  // '0' flag is ignored if '-' flag is given
+  EXPECT_PRINTF("7    ", "%-05d", 7);
+  EXPECT_PRINTF("7    ", "%0-5d", 7);
+  EXPECT_PRINTF("a    ", "%-05c", 'a');
+  EXPECT_PRINTF("a    ", "%0-5c", 'a');
+  EXPECT_PRINTF("97   ", "%-05hhi", 'a');
+  EXPECT_PRINTF("97   ", "%0-5hhi", 'a');
+
+  // '-' and space flag don't interfere
+  EXPECT_PRINTF(" 42", "%- d", 42);
+}
+
+TEST(printf_test, space_flag) {
+  EXPECT_PRINTF(" 42", "% d", 42);
+  EXPECT_PRINTF("-42", "% d", -42);
+  EXPECT_PRINTF(" 0042", "% 05d", 42);
+  EXPECT_PRINTF(" 0042", "%0  5d", 42);
+
+  // ' ' flag is ignored for non-numeric types.
+  EXPECT_PRINTF("x", "% c", 'x');
+}
+
+TEST(printf_test, hash_flag) {
+  EXPECT_PRINTF("042", "%#o", 042);
+  EXPECT_PRINTF(fmt::format("0{:o}", static_cast<unsigned>(-042)), "%#o", -042);
+  EXPECT_PRINTF("0", "%#o", 0);
+
+  EXPECT_PRINTF("0x42", "%#x", 0x42);
+  EXPECT_PRINTF("0X42", "%#X", 0x42);
+  EXPECT_PRINTF(fmt::format("0x{:x}", static_cast<unsigned>(-0x42)), "%#x",
+                -0x42);
+  EXPECT_PRINTF("0", "%#x", 0);
+
+  EXPECT_PRINTF("0x0042", "%#06x", 0x42);
+  EXPECT_PRINTF("0x0042", "%0##6x", 0x42);
+
+  EXPECT_PRINTF("-42.000000", "%#f", -42.0);
+  EXPECT_PRINTF("-42.000000", "%#F", -42.0);
+
+  char buffer[256];
+  safe_sprintf(buffer, "%#e", -42.0);
+  EXPECT_PRINTF(buffer, "%#e", -42.0);
+  safe_sprintf(buffer, "%#E", -42.0);
+  EXPECT_PRINTF(buffer, "%#E", -42.0);
+
+  EXPECT_PRINTF("-42.0000", "%#g", -42.0);
+  EXPECT_PRINTF("-42.0000", "%#G", -42.0);
+
+  EXPECT_PRINTF("0x1.p+4", "%#a", 16.0);
+  EXPECT_PRINTF("0X1.P+4", "%#A", 16.0);
+
+  // '#' flag is ignored for non-numeric types.
+  EXPECT_PRINTF("x", "%#c", 'x');
+}
+
+TEST(printf_test, width) {
+  EXPECT_PRINTF("  abc", "%5s", "abc");
+
+  // Width cannot be specified twice.
+  EXPECT_THROW_MSG(test_sprintf("%5-5d", 42), format_error,
+                   "invalid format specifier");
+
+  EXPECT_THROW_MSG(test_sprintf(format("%{}d", big_num), 42), format_error,
+                   "number is too big");
+  EXPECT_THROW_MSG(test_sprintf(format("%1${}d", big_num), 42), format_error,
+                   "number is too big");
+}
+
+TEST(printf_test, dynamic_width) {
+  EXPECT_EQ("   42", test_sprintf("%*d", 5, 42));
+  EXPECT_EQ("42   ", test_sprintf("%*d", -5, 42));
+  EXPECT_THROW_MSG(test_sprintf("%*d", 5.0, 42), format_error,
+                   "width is not integer");
+  EXPECT_THROW_MSG(test_sprintf("%*d"), format_error, "argument not found");
+  EXPECT_THROW_MSG(test_sprintf("%*d", big_num, 42), format_error,
+                   "number is too big");
+}
+
+TEST(printf_test, int_precision) {
+  EXPECT_PRINTF("00042", "%.5d", 42);
+  EXPECT_PRINTF("-00042", "%.5d", -42);
+  EXPECT_PRINTF("00042", "%.5x", 0x42);
+  EXPECT_PRINTF("0x00042", "%#.5x", 0x42);
+  EXPECT_PRINTF("00042", "%.5o", 042);
+  EXPECT_PRINTF("00042", "%#.5o", 042);
+
+  EXPECT_PRINTF("  00042", "%7.5d", 42);
+  EXPECT_PRINTF("  00042", "%7.5x", 0x42);
+  EXPECT_PRINTF("   0x00042", "%#10.5x", 0x42);
+  EXPECT_PRINTF("  00042", "%7.5o", 042);
+  EXPECT_PRINTF("     00042", "%#10.5o", 042);
+
+  EXPECT_PRINTF("00042  ", "%-7.5d", 42);
+  EXPECT_PRINTF("00042  ", "%-7.5x", 0x42);
+  EXPECT_PRINTF("0x00042   ", "%-#10.5x", 0x42);
+  EXPECT_PRINTF("00042  ", "%-7.5o", 042);
+  EXPECT_PRINTF("00042     ", "%-#10.5o", 042);
+}
+
+TEST(printf_test, float_precision) {
+  char buffer[256];
+  safe_sprintf(buffer, "%.3e", 1234.5678);
+  EXPECT_PRINTF(buffer, "%.3e", 1234.5678);
+  EXPECT_PRINTF("1234.568", "%.3f", 1234.5678);
+  EXPECT_PRINTF("1.23e+03", "%.3g", 1234.5678);
+  safe_sprintf(buffer, "%.3a", 1234.5678);
+  EXPECT_PRINTF(buffer, "%.3a", 1234.5678);
+}
+
+TEST(printf_test, string_precision) {
+  char test[] = {'H', 'e', 'l', 'l', 'o'};
+  EXPECT_EQ(fmt::sprintf("%.4s", test), "Hell");
+}
+
+TEST(printf_test, ignore_precision_for_non_numeric_arg) {
+  EXPECT_PRINTF("abc", "%.5s", "abc");
+}
+
+TEST(printf_test, dynamic_precision) {
+  EXPECT_EQ("00042", test_sprintf("%.*d", 5, 42));
+  EXPECT_EQ("42", test_sprintf("%.*d", -5, 42));
+  EXPECT_THROW_MSG(test_sprintf("%.*d", 5.0, 42), format_error,
+                   "precision is not integer");
+  EXPECT_THROW_MSG(test_sprintf("%.*d"), format_error, "argument not found");
+  EXPECT_THROW_MSG(test_sprintf("%.*d", big_num, 42), format_error,
+                   "number is too big");
+  if (sizeof(long long) != sizeof(int)) {
+    long long prec = static_cast<long long>(INT_MIN) - 1;
+    EXPECT_THROW_MSG(test_sprintf("%.*d", prec, 42), format_error,
+                     "number is too big");
+  }
+}
+
+template <typename T> struct make_signed { using type = T; };
+
+#define SPECIALIZE_MAKE_SIGNED(T, S) \
+  template <> struct make_signed<T> { using type = S; }
+
+SPECIALIZE_MAKE_SIGNED(char, signed char);
+SPECIALIZE_MAKE_SIGNED(unsigned char, signed char);
+SPECIALIZE_MAKE_SIGNED(unsigned short, short);
+SPECIALIZE_MAKE_SIGNED(unsigned, int);
+SPECIALIZE_MAKE_SIGNED(unsigned long, long);
+SPECIALIZE_MAKE_SIGNED(unsigned long long, long long);
+
+// Test length format specifier ``length_spec``.
+template <typename T, typename U>
+void test_length(const char* length_spec, U value) {
+  long long signed_value = 0;
+  unsigned long long unsigned_value = 0;
+  // Apply integer promotion to the argument.
+  unsigned long long max = max_value<U>();
+  using fmt::detail::const_check;
+  if (const_check(max <= static_cast<unsigned>(max_value<int>()))) {
+    signed_value = static_cast<int>(value);
+    unsigned_value = static_cast<unsigned long long>(value);
+  } else if (const_check(max <= max_value<unsigned>())) {
+    signed_value = static_cast<unsigned>(value);
+    unsigned_value = static_cast<unsigned long long>(value);
+  }
+  if (sizeof(U) <= sizeof(int) && sizeof(int) < sizeof(T)) {
+    signed_value = static_cast<long long>(value);
+    unsigned_value = static_cast<unsigned long long>(
+        static_cast<typename std::make_unsigned<unsigned>::type>(value));
+  } else {
+    signed_value = static_cast<typename make_signed<T>::type>(value);
+    unsigned_value = static_cast<typename std::make_unsigned<T>::type>(value);
+  }
+  std::ostringstream os;
+  os << signed_value;
+  EXPECT_PRINTF(os.str(), fmt::format("%{}d", length_spec), value);
+  EXPECT_PRINTF(os.str(), fmt::format("%{}i", length_spec), value);
+  os.str("");
+  os << unsigned_value;
+  EXPECT_PRINTF(os.str(), fmt::format("%{}u", length_spec), value);
+  os.str("");
+  os << std::oct << unsigned_value;
+  EXPECT_PRINTF(os.str(), fmt::format("%{}o", length_spec), value);
+  os.str("");
+  os << std::hex << unsigned_value;
+  EXPECT_PRINTF(os.str(), fmt::format("%{}x", length_spec), value);
+  os.str("");
+  os << std::hex << std::uppercase << unsigned_value;
+  EXPECT_PRINTF(os.str(), fmt::format("%{}X", length_spec), value);
+}
+
+template <typename T> void test_length(const char* length_spec) {
+  T min = std::numeric_limits<T>::min(), max = max_value<T>();
+  test_length<T>(length_spec, 42);
+  test_length<T>(length_spec, -42);
+  test_length<T>(length_spec, min);
+  test_length<T>(length_spec, max);
+  long long long_long_min = std::numeric_limits<long long>::min();
+  if (static_cast<long long>(min) > long_long_min)
+    test_length<T>(length_spec, static_cast<long long>(min) - 1);
+  unsigned long long long_long_max = max_value<long long>();
+  if (static_cast<unsigned long long>(max) < long_long_max)
+    test_length<T>(length_spec, static_cast<long long>(max) + 1);
+  test_length<T>(length_spec, std::numeric_limits<short>::min());
+  test_length<T>(length_spec, max_value<unsigned short>());
+  test_length<T>(length_spec, std::numeric_limits<int>::min());
+  test_length<T>(length_spec, max_value<int>());
+  test_length<T>(length_spec, std::numeric_limits<unsigned>::min());
+  test_length<T>(length_spec, max_value<unsigned>());
+  test_length<T>(length_spec, std::numeric_limits<long long>::min());
+  test_length<T>(length_spec, max_value<long long>());
+  test_length<T>(length_spec, std::numeric_limits<unsigned long long>::min());
+  test_length<T>(length_spec, max_value<unsigned long long>());
+}
+
+TEST(printf_test, length) {
+  test_length<char>("hh");
+  test_length<signed char>("hh");
+  test_length<unsigned char>("hh");
+  test_length<short>("h");
+  test_length<unsigned short>("h");
+  test_length<long>("l");
+  test_length<unsigned long>("l");
+  test_length<long long>("ll");
+  test_length<unsigned long long>("ll");
+  test_length<intmax_t>("j");
+  test_length<size_t>("z");
+  test_length<std::ptrdiff_t>("t");
+  long double max = max_value<long double>();
+  EXPECT_PRINTF(fmt::format("{:.6}", max), "%g", max);
+  EXPECT_PRINTF(fmt::format("{:.6}", max), "%Lg", max);
+}
+
+TEST(printf_test, bool) { EXPECT_PRINTF("1", "%d", true); }
+
+TEST(printf_test, int) {
+  EXPECT_PRINTF("-42", "%d", -42);
+  EXPECT_PRINTF("-42", "%i", -42);
+  unsigned u = 0 - 42u;
+  EXPECT_PRINTF(fmt::format("{}", u), "%u", -42);
+  EXPECT_PRINTF(fmt::format("{:o}", u), "%o", -42);
+  EXPECT_PRINTF(fmt::format("{:x}", u), "%x", -42);
+  EXPECT_PRINTF(fmt::format("{:X}", u), "%X", -42);
+}
+
+TEST(printf_test, long_long) {
+  // fmt::printf allows passing long long arguments to %d without length
+  // specifiers.
+  long long max = max_value<long long>();
+  EXPECT_PRINTF(fmt::format("{}", max), "%d", max);
+}
+
+TEST(printf_test, float) {
+  EXPECT_PRINTF("392.650000", "%f", 392.65);
+  EXPECT_PRINTF("392.65", "%.2f", 392.65);
+  EXPECT_PRINTF("392.6", "%.1f", 392.65);
+  EXPECT_PRINTF("393", "%.f", 392.65);
+  EXPECT_PRINTF("392.650000", "%F", 392.65);
+  char buffer[256];
+  safe_sprintf(buffer, "%e", 392.65);
+  EXPECT_PRINTF(buffer, "%e", 392.65);
+  safe_sprintf(buffer, "%E", 392.65);
+  EXPECT_PRINTF(buffer, "%E", 392.65);
+  EXPECT_PRINTF("392.65", "%g", 392.65);
+  EXPECT_PRINTF("392.65", "%G", 392.65);
+  EXPECT_PRINTF("392", "%g", 392.0);
+  EXPECT_PRINTF("392", "%G", 392.0);
+  EXPECT_PRINTF("4.56e-07", "%g", 0.000000456);
+  safe_sprintf(buffer, "%a", -392.65);
+  EXPECT_EQ(buffer, format("{:a}", -392.65));
+  safe_sprintf(buffer, "%A", -392.65);
+  EXPECT_EQ(buffer, format("{:A}", -392.65));
+}
+
+TEST(printf_test, inf) {
+  double inf = std::numeric_limits<double>::infinity();
+  for (const char* type = "fega"; *type; ++type) {
+    EXPECT_PRINTF("inf", fmt::format("%{}", *type), inf);
+    char upper = static_cast<char>(std::toupper(*type));
+    EXPECT_PRINTF("INF", fmt::format("%{}", upper), inf);
+  }
+}
+
+TEST(printf_test, char) {
+  EXPECT_PRINTF("x", "%c", 'x');
+  int max = max_value<int>();
+  EXPECT_PRINTF(fmt::format("{}", static_cast<char>(max)), "%c", max);
+  // EXPECT_PRINTF("x", "%lc", L'x');
+  EXPECT_PRINTF(L"x", L"%c", L'x');
+  EXPECT_PRINTF(fmt::format(L"{}", static_cast<wchar_t>(max)), L"%c", max);
+}
+
+TEST(printf_test, string) {
+  EXPECT_PRINTF("abc", "%s", "abc");
+  const char* null_str = nullptr;
+  EXPECT_PRINTF("(null)", "%s", null_str);
+  EXPECT_PRINTF("    (null)", "%10s", null_str);
+  EXPECT_PRINTF(L"abc", L"%s", L"abc");
+  const wchar_t* null_wstr = nullptr;
+  EXPECT_PRINTF(L"(null)", L"%s", null_wstr);
+  EXPECT_PRINTF(L"    (null)", L"%10s", null_wstr);
+}
+
+TEST(printf_test, pointer) {
+  int n;
+  void* p = &n;
+  EXPECT_PRINTF(fmt::format("{}", p), "%p", p);
+  p = nullptr;
+  EXPECT_PRINTF("(nil)", "%p", p);
+  EXPECT_PRINTF("     (nil)", "%10p", p);
+  const char* s = "test";
+  EXPECT_PRINTF(fmt::format("{:p}", s), "%p", s);
+  const char* null_str = nullptr;
+  EXPECT_PRINTF("(nil)", "%p", null_str);
+
+  p = &n;
+  EXPECT_PRINTF(fmt::format(L"{}", p), L"%p", p);
+  p = nullptr;
+  EXPECT_PRINTF(L"(nil)", L"%p", p);
+  EXPECT_PRINTF(L"     (nil)", L"%10p", p);
+  const wchar_t* w = L"test";
+  EXPECT_PRINTF(fmt::format(L"{:p}", w), L"%p", w);
+  const wchar_t* null_wstr = nullptr;
+  EXPECT_PRINTF(L"(nil)", L"%p", null_wstr);
+}
+
+enum test_enum { answer = 42 };
+auto format_as(test_enum e) -> int { return e; }
+
+TEST(printf_test, enum) {
+  EXPECT_PRINTF("42", "%d", answer);
+  volatile test_enum volatile_enum = answer;
+  EXPECT_PRINTF("42", "%d", volatile_enum);
+}
+
+#if FMT_USE_FCNTL
+TEST(printf_test, examples) {
+  const char* weekday = "Thursday";
+  const char* month = "August";
+  int day = 21;
+  EXPECT_WRITE(stdout, fmt::printf("%1$s, %3$d %2$s", weekday, month, day),
+               "Thursday, 21 August");
+}
+
+TEST(printf_test, printf_error) {
+  fmt::file read_end, write_end;
+  fmt::file::pipe(read_end, write_end);
+  int result = fmt::fprintf(read_end.fdopen("r").get(), "test");
+  EXPECT_LT(result, 0);
+}
+#endif
+
+TEST(printf_test, wide_string) {
+  EXPECT_EQ(L"abc", fmt::sprintf(L"%s", L"abc"));
+}
+
+TEST(printf_test, vprintf) {
+  int n = 42;
+  auto store = fmt::format_arg_store<fmt::printf_context, int>(n);
+  auto args = fmt::basic_format_args<fmt::printf_context>(store);
+  EXPECT_EQ(fmt::vsprintf(fmt::string_view("%d"), args), "42");
+  EXPECT_WRITE(stdout, fmt::vfprintf(stdout, fmt::string_view("%d"), args),
+               "42");
+}
+
+template <typename... Args>
+void check_format_string_regression(fmt::string_view s, const Args&... args) {
+  fmt::sprintf(s, args...);
+}
+
+TEST(printf_test, check_format_string_regression) {
+  check_format_string_regression("%c%s", 'x', "");
+}
+
+TEST(printf_test, fixed_large_exponent) {
+  EXPECT_EQ("1000000000000000000000", fmt::sprintf("%.*f", -13, 1e21));
+}
+
+TEST(printf_test, make_printf_args) {
+  EXPECT_EQ("[42] something happened",
+            fmt::vsprintf(fmt::string_view("[%d] %s happened"),
+                          {fmt::make_printf_args(42, "something")}));
+  EXPECT_EQ(L"[42] something happened",
+            fmt::vsprintf(fmt::basic_string_view<wchar_t>(L"[%d] %s happened"),
+                          {fmt::make_wprintf_args(42, L"something")}));
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/ranges-odr-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/ranges-odr-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..031354d3c2ed0870041468c25f518a1758f48ee9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/ranges-odr-test.cc
@@ -0,0 +1,17 @@
+// Formatting library for C++ - the core API
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <vector>
+
+#include "fmt/ranges.h"
+#include "gtest/gtest.h"
+
+// call fmt::format from another translation unit to test ODR
+TEST(ranges_odr_test, format_vector) {
+  auto v = std::vector<int>{1, 2, 3, 5, 7, 11};
+  EXPECT_EQ(fmt::format("{}", v), "[1, 2, 3, 5, 7, 11]");
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/ranges-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/ranges-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8ab66b33871af9b60b69fdb0e829f410e9f8b998
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/ranges-test.cc
@@ -0,0 +1,560 @@
+// Formatting library for C++ - ranges tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/ranges.h"
+
+#include <list>
+#include <map>
+#include <numeric>
+#include <queue>
+#include <stack>
+#include <string>
+#include <utility>
+#include <vector>
+
+#if FMT_HAS_INCLUDE(<ranges>)
+#  include <ranges>
+#endif
+
+#include "gtest/gtest.h"
+
+#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 601
+#  define FMT_RANGES_TEST_ENABLE_C_STYLE_ARRAY
+#endif
+
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION > 1910
+#  define FMT_RANGES_TEST_ENABLE_JOIN
+#  define FMT_RANGES_TEST_ENABLE_FORMAT_STRUCT
+#endif
+
+#ifdef FMT_RANGES_TEST_ENABLE_C_STYLE_ARRAY
+TEST(ranges_test, format_array) {
+  int arr[] = {1, 2, 3, 5, 7, 11};
+  EXPECT_EQ(fmt::format("{}", arr), "[1, 2, 3, 5, 7, 11]");
+}
+
+TEST(ranges_test, format_2d_array) {
+  int arr[][2] = {{1, 2}, {3, 5}, {7, 11}};
+  EXPECT_EQ(fmt::format("{}", arr), "[[1, 2], [3, 5], [7, 11]]");
+}
+
+TEST(ranges_test, format_array_of_literals) {
+  const char* arr[] = {"1234", "abcd"};
+  EXPECT_EQ(fmt::format("{}", arr), "[\"1234\", \"abcd\"]");
+  EXPECT_EQ(fmt::format("{:n}", arr), "\"1234\", \"abcd\"");
+  EXPECT_EQ(fmt::format("{:n:}", arr), "1234, abcd");
+}
+#endif  // FMT_RANGES_TEST_ENABLE_C_STYLE_ARRAY
+
+TEST(ranges_test, format_vector) {
+  auto v = std::vector<int>{1, 2, 3, 5, 7, 11};
+  EXPECT_EQ(fmt::format("{}", v), "[1, 2, 3, 5, 7, 11]");
+  EXPECT_EQ(fmt::format("{::#x}", v), "[0x1, 0x2, 0x3, 0x5, 0x7, 0xb]");
+  EXPECT_EQ(fmt::format("{:n:#x}", v), "0x1, 0x2, 0x3, 0x5, 0x7, 0xb");
+
+  auto vc = std::vector<char>{'a', 'b', 'c'};
+  auto vvc = std::vector<std::vector<char>>{vc, vc};
+  EXPECT_EQ(fmt::format("{}", vc), "['a', 'b', 'c']");
+  EXPECT_EQ(fmt::format("{}", vvc), "[['a', 'b', 'c'], ['a', 'b', 'c']]");
+  EXPECT_EQ(fmt::format("{:n}", vvc), "['a', 'b', 'c'], ['a', 'b', 'c']");
+  EXPECT_EQ(fmt::format("{:n:n}", vvc), "'a', 'b', 'c', 'a', 'b', 'c'");
+  EXPECT_EQ(fmt::format("{:n:n:}", vvc), "a, b, c, a, b, c");
+}
+
+TEST(ranges_test, format_nested_vector) {
+  auto v = std::vector<std::vector<int>>{{1, 2}, {3, 5}, {7, 11}};
+  EXPECT_EQ(fmt::format("{}", v), "[[1, 2], [3, 5], [7, 11]]");
+  EXPECT_EQ(fmt::format("{:::#x}", v), "[[0x1, 0x2], [0x3, 0x5], [0x7, 0xb]]");
+  EXPECT_EQ(fmt::format("{:n:n:#x}", v), "0x1, 0x2, 0x3, 0x5, 0x7, 0xb");
+}
+
+TEST(ranges_test, to_string_vector) {
+  auto v = std::vector<std::string>{"a", "b", "c"};
+  EXPECT_EQ(fmt::to_string(v), "[\"a\", \"b\", \"c\"]");
+}
+
+TEST(ranges_test, format_map) {
+  auto m = std::map<std::string, int>{{"one", 1}, {"two", 2}};
+  EXPECT_EQ(fmt::format("{}", m), "{\"one\": 1, \"two\": 2}");
+  EXPECT_EQ(fmt::format("{:n}", m), "\"one\": 1, \"two\": 2");
+}
+
+TEST(ranges_test, format_set) {
+  EXPECT_EQ(fmt::format("{}", std::set<std::string>{"one", "two"}),
+            "{\"one\", \"two\"}");
+}
+
+// Models std::flat_set close enough to test if no ambiguous lookup of a
+// formatter happens due to the flat_set type matching is_set and
+// is_container_adaptor_like.
+template <typename T> class flat_set {
+ public:
+  using key_type = T;
+  using container_type = std::vector<T>;
+
+  using iterator = typename std::vector<T>::iterator;
+  using const_iterator = typename std::vector<T>::const_iterator;
+
+  template <typename... Ts>
+  explicit flat_set(Ts&&... args) : c{std::forward<Ts>(args)...} {}
+
+  auto begin() -> iterator { return c.begin(); }
+  auto end() -> iterator { return c.end(); }
+
+  auto begin() const -> const_iterator { return c.begin(); }
+  auto end() const -> const_iterator { return c.end(); }
+
+ private:
+  std::vector<T> c;
+};
+
+TEST(ranges_test, format_flat_set) {
+  EXPECT_EQ(fmt::format("{}", flat_set<std::string>{"one", "two"}),
+            "{\"one\", \"two\"}");
+}
+
+namespace adl {
+struct box {
+  int value;
+};
+
+auto begin(const box& b) -> const int* { return &b.value; }
+auto end(const box& b) -> const int* { return &b.value + 1; }
+}  // namespace adl
+
+TEST(ranges_test, format_adl_begin_end) {
+  auto b = adl::box{42};
+  EXPECT_EQ(fmt::format("{}", b), "[42]");
+}
+
+TEST(ranges_test, format_pair) {
+  auto p = std::pair<int, float>(42, 1.5f);
+  EXPECT_EQ(fmt::format("{}", p), "(42, 1.5)");
+}
+
+struct unformattable {};
+
+TEST(ranges_test, format_tuple) {
+  auto t =
+      std::tuple<int, float, std::string, char>(42, 1.5f, "this is tuple", 'i');
+  EXPECT_EQ(fmt::format("{}", t), "(42, 1.5, \"this is tuple\", 'i')");
+
+  EXPECT_EQ(fmt::format("{}", std::tuple<>()), "()");
+
+  EXPECT_TRUE((fmt::is_formattable<std::tuple<>>::value));
+  EXPECT_FALSE((fmt::is_formattable<unformattable>::value));
+  EXPECT_FALSE((fmt::is_formattable<std::tuple<unformattable>>::value));
+  EXPECT_FALSE((fmt::is_formattable<std::tuple<unformattable, int>>::value));
+  EXPECT_FALSE((fmt::is_formattable<std::tuple<int, unformattable>>::value));
+  EXPECT_FALSE(
+      (fmt::is_formattable<std::tuple<unformattable, unformattable>>::value));
+  EXPECT_TRUE((fmt::is_formattable<std::tuple<int, float>>::value));
+}
+
+struct not_default_formattable {};
+struct bad_format {};
+
+FMT_BEGIN_NAMESPACE
+template <> struct formatter<not_default_formattable> {
+  auto parse(format_parse_context&) -> const char* { throw bad_format(); }
+  auto format(not_default_formattable, format_context& ctx)
+      -> format_context::iterator {
+    return ctx.out();
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(ranges_test, tuple_parse_calls_element_parse) {
+  auto f = fmt::formatter<std::tuple<not_default_formattable>>();
+  auto ctx = fmt::format_parse_context("");
+  EXPECT_THROW(f.parse(ctx), bad_format);
+}
+
+#ifdef FMT_RANGES_TEST_ENABLE_FORMAT_STRUCT
+struct tuple_like {
+  int i;
+  std::string str;
+
+  template <size_t N>
+  auto get() const noexcept -> fmt::enable_if_t<N == 0, int> {
+    return i;
+  }
+  template <size_t N>
+  auto get() const noexcept -> fmt::enable_if_t<N == 1, fmt::string_view> {
+    return str;
+  }
+};
+
+template <size_t N>
+auto get(const tuple_like& t) noexcept -> decltype(t.get<N>()) {
+  return t.get<N>();
+}
+
+namespace std {
+template <>
+struct tuple_size<tuple_like> : std::integral_constant<size_t, 2> {};
+
+template <size_t N> struct tuple_element<N, tuple_like> {
+  using type = decltype(std::declval<tuple_like>().get<N>());
+};
+}  // namespace std
+
+TEST(ranges_test, format_struct) {
+  auto t = tuple_like{42, "foo"};
+  EXPECT_EQ(fmt::format("{}", t), "(42, \"foo\")");
+}
+#endif  // FMT_RANGES_TEST_ENABLE_FORMAT_STRUCT
+
+TEST(ranges_test, format_to) {
+  char buf[10];
+  auto end = fmt::format_to(buf, "{}", std::vector<int>{1, 2, 3});
+  *end = '\0';
+  EXPECT_STREQ(buf, "[1, 2, 3]");
+}
+
+template <typename Char> struct path_like {
+  auto begin() const -> const path_like*;
+  auto end() const -> const path_like*;
+
+  operator std::basic_string<Char>() const;
+};
+
+TEST(ranges_test, disabled_range_formatting_of_path) {
+  // Range formatting of path is disabled because of infinite recursion
+  // (path element is itself a path).
+  EXPECT_EQ((fmt::range_format_kind<path_like<char>, char>::value),
+            fmt::range_format::disabled);
+  EXPECT_EQ((fmt::range_format_kind<path_like<wchar_t>, char>::value),
+            fmt::range_format::disabled);
+}
+
+// A range that provides non-const only begin()/end() to test fmt::join
+// handles that.
+//
+// Some ranges (e.g. those produced by range-v3's views::filter()) can cache
+// information during iteration so they only provide non-const begin()/end().
+template <typename T> class non_const_only_range {
+ private:
+  std::vector<T> vec;
+
+ public:
+  using const_iterator = typename ::std::vector<T>::const_iterator;
+
+  template <typename... Args>
+  explicit non_const_only_range(Args&&... args)
+      : vec(std::forward<Args>(args)...) {}
+
+  auto begin() -> const_iterator { return vec.begin(); }
+  auto end() -> const_iterator { return vec.end(); }
+};
+
+template <typename T> class noncopyable_range {
+ private:
+  std::vector<T> vec;
+
+ public:
+  using iterator = typename ::std::vector<T>::iterator;
+
+  template <typename... Args>
+  explicit noncopyable_range(Args&&... args)
+      : vec(std::forward<Args>(args)...) {}
+
+  noncopyable_range(noncopyable_range const&) = delete;
+  noncopyable_range(noncopyable_range&) = delete;
+
+  auto begin() -> iterator { return vec.begin(); }
+  auto end() -> iterator { return vec.end(); }
+};
+
+TEST(ranges_test, range) {
+  auto&& w = noncopyable_range<int>(3u, 0);
+  EXPECT_EQ(fmt::format("{}", w), "[0, 0, 0]");
+  EXPECT_EQ(fmt::format("{}", noncopyable_range<int>(3u, 0)), "[0, 0, 0]");
+
+  auto x = non_const_only_range<int>(3u, 0);
+  EXPECT_EQ(fmt::format("{}", x), "[0, 0, 0]");
+  EXPECT_EQ(fmt::format("{}", non_const_only_range<int>(3u, 0)), "[0, 0, 0]");
+
+  auto y = std::vector<int>(3u, 0);
+  EXPECT_EQ(fmt::format("{}", y), "[0, 0, 0]");
+  EXPECT_EQ(fmt::format("{}", std::vector<int>(3u, 0)), "[0, 0, 0]");
+
+  const auto z = std::vector<int>(3u, 0);
+  EXPECT_EQ(fmt::format("{}", z), "[0, 0, 0]");
+}
+
+enum test_enum { foo };
+auto format_as(test_enum e) -> int { return e; }
+
+TEST(ranges_test, enum_range) {
+  auto v = std::vector<test_enum>{test_enum::foo};
+  EXPECT_EQ(fmt::format("{}", v), "[0]");
+}
+
+#if !FMT_MSC_VERSION
+TEST(ranges_test, unformattable_range) {
+  EXPECT_FALSE((fmt::has_formatter<std::vector<unformattable>,
+                                   fmt::format_context>::value));
+}
+#endif
+
+#ifdef FMT_RANGES_TEST_ENABLE_JOIN
+TEST(ranges_test, join_tuple) {
+  // Value tuple args.
+  auto t1 = std::tuple<char, int, float>('a', 1, 2.0f);
+  EXPECT_EQ(fmt::format("({})", fmt::join(t1, ", ")), "(a, 1, 2)");
+
+  // Testing lvalue tuple args.
+  int x = 4;
+  auto t2 = std::tuple<char, int&>('b', x);
+  EXPECT_EQ(fmt::format("{}", fmt::join(t2, " + ")), "b + 4");
+
+  // Empty tuple.
+  auto t3 = std::tuple<>();
+  EXPECT_EQ(fmt::format("{}", fmt::join(t3, "|")), "");
+
+  // Single element tuple.
+  auto t4 = std::tuple<float>(4.0f);
+  EXPECT_EQ(fmt::format("{}", fmt::join(t4, "/")), "4");
+
+#  if FMT_TUPLE_JOIN_SPECIFIERS
+  // Specs applied to each element.
+  auto t5 = std::tuple<int, int, long>(-3, 100, 1);
+  EXPECT_EQ(fmt::format("{:+03}", fmt::join(t5, ", ")), "-03, +100, +01");
+
+  auto t6 = std::tuple<float, double, long double>(3, 3.14, 3.1415);
+  EXPECT_EQ(fmt::format("{:5.5f}", fmt::join(t6, ", ")),
+            "3.00000, 3.14000, 3.14150");
+
+  // Testing lvalue tuple args.
+  int y = -1;
+  auto t7 = std::tuple<int, int&, const int&>(3, y, y);
+  EXPECT_EQ(fmt::format("{:03}", fmt::join(t7, ", ")), "003, -01, -01");
+#  endif
+}
+
+TEST(ranges_test, join_initializer_list) {
+  EXPECT_EQ(fmt::format("{}", fmt::join({1, 2, 3}, ", ")), "1, 2, 3");
+  EXPECT_EQ(fmt::format("{}", fmt::join({"fmt", "rocks", "!"}, " ")),
+            "fmt rocks !");
+}
+
+struct zstring_sentinel {};
+
+bool operator==(const char* p, zstring_sentinel) { return *p == '\0'; }
+bool operator!=(const char* p, zstring_sentinel) { return *p != '\0'; }
+
+struct zstring {
+  const char* p;
+  auto begin() const -> const char* { return p; }
+  auto end() const -> zstring_sentinel { return {}; }
+};
+
+#  ifdef __cpp_lib_ranges
+struct cpp20_only_range {
+  struct iterator {
+    int val = 0;
+
+    using value_type = int;
+    using difference_type = std::ptrdiff_t;
+    using iterator_concept = std::input_iterator_tag;
+
+    iterator() = default;
+    iterator(int i) : val(i) {}
+    auto operator*() const -> int { return val; }
+    auto operator++() -> iterator& {
+      ++val;
+      return *this;
+    }
+    void operator++(int) { ++*this; }
+    auto operator==(const iterator& rhs) const -> bool {
+      return val == rhs.val;
+    }
+  };
+
+  int lo;
+  int hi;
+
+  auto begin() const -> iterator { return iterator(lo); }
+  auto end() const -> iterator { return iterator(hi); }
+};
+
+static_assert(std::input_iterator<cpp20_only_range::iterator>);
+#  endif
+
+TEST(ranges_test, join_sentinel) {
+  auto hello = zstring{"hello"};
+  EXPECT_EQ(fmt::format("{}", hello), "['h', 'e', 'l', 'l', 'o']");
+  EXPECT_EQ(fmt::format("{::}", hello), "[h, e, l, l, o]");
+  EXPECT_EQ(fmt::format("{}", fmt::join(hello, "_")), "h_e_l_l_o");
+}
+
+TEST(ranges_test, join_range) {
+  auto&& w = noncopyable_range<int>(3u, 0);
+  EXPECT_EQ(fmt::format("{}", fmt::join(w, ",")), "0,0,0");
+  EXPECT_EQ(fmt::format("{}", fmt::join(noncopyable_range<int>(3u, 0), ",")),
+            "0,0,0");
+
+  auto x = non_const_only_range<int>(3u, 0);
+  EXPECT_EQ(fmt::format("{}", fmt::join(x, ",")), "0,0,0");
+  EXPECT_EQ(fmt::format("{}", fmt::join(non_const_only_range<int>(3u, 0), ",")),
+            "0,0,0");
+
+  auto y = std::vector<int>(3u, 0);
+  EXPECT_EQ(fmt::format("{}", fmt::join(y, ",")), "0,0,0");
+  EXPECT_EQ(fmt::format("{}", fmt::join(std::vector<int>(3u, 0), ",")),
+            "0,0,0");
+
+  const auto z = std::vector<int>(3u, 0);
+  EXPECT_EQ(fmt::format("{}", fmt::join(z, ",")), "0,0,0");
+
+#  ifdef __cpp_lib_ranges
+  EXPECT_EQ(fmt::format("{}", cpp20_only_range{.lo = 0, .hi = 5}),
+            "[0, 1, 2, 3, 4]");
+  EXPECT_EQ(
+      fmt::format("{}", fmt::join(cpp20_only_range{.lo = 0, .hi = 5}, ",")),
+      "0,1,2,3,4");
+#  endif
+}
+#endif  // FMT_RANGES_TEST_ENABLE_JOIN
+
+#if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 202302L
+TEST(ranges_test, nested_ranges) {
+  auto l = std::list{1, 2, 3};
+  auto r = std::views::iota(0, 3) | std::views::transform([&l](auto i) {
+             return std::views::take(std::ranges::subrange(l), i);
+           }) |
+           std::views::transform(std::views::reverse);
+  EXPECT_EQ(fmt::format("{}", r), "[[], [1], [2, 1]]");
+}
+#endif
+
+TEST(ranges_test, is_printable) {
+  using fmt::detail::is_printable;
+  EXPECT_TRUE(is_printable(0x0323));
+  EXPECT_FALSE(is_printable(0x0378));
+  EXPECT_FALSE(is_printable(0x110000));
+}
+
+TEST(ranges_test, escape) {
+  using vec = std::vector<std::string>;
+  EXPECT_EQ(fmt::format("{}", vec{"\n\r\t\"\\"}), "[\"\\n\\r\\t\\\"\\\\\"]");
+  EXPECT_EQ(fmt::format("{}", vec{"\x07"}), "[\"\\x07\"]");
+  EXPECT_EQ(fmt::format("{}", vec{"\x7f"}), "[\"\\x7f\"]");
+  EXPECT_EQ(fmt::format("{}", vec{"n\xcc\x83"}), "[\"n\xcc\x83\"]");
+
+  if (fmt::detail::is_utf8()) {
+    EXPECT_EQ(fmt::format("{}", vec{"\xcd\xb8"}), "[\"\\u0378\"]");
+    // Unassigned Unicode code points.
+    EXPECT_EQ(fmt::format("{}", vec{"\xf0\xaa\x9b\x9e"}), "[\"\\U0002a6de\"]");
+    // Broken utf-8.
+    EXPECT_EQ(fmt::format("{}", vec{"\xf4\x8f\xbf\xc0"}),
+              "[\"\\xf4\\x8f\\xbf\\xc0\"]");
+    EXPECT_EQ(fmt::format("{}", vec{"\xf0\x28"}), "[\"\\xf0(\"]");
+    EXPECT_EQ(fmt::format("{}", vec{"\xe1\x28"}), "[\"\\xe1(\"]");
+    EXPECT_EQ(fmt::format("{}", vec{std::string("\xf0\x28\0\0anything", 12)}),
+              "[\"\\xf0(\\x00\\x00anything\"]");
+
+    // Correct utf-8.
+    EXPECT_EQ(fmt::format("{}", vec{"🦄"}), "[\"🦄\"]");
+  }
+
+  EXPECT_EQ(fmt::format("{}", std::vector<std::vector<char>>{{'x'}}),
+            "[['x']]");
+  EXPECT_EQ(fmt::format("{}", std::tuple<std::vector<char>>{{'x'}}), "(['x'])");
+}
+
+template <typename R> struct fmt_ref_view {
+  R* r;
+
+  auto begin() const -> decltype(r->begin()) { return r->begin(); }
+  auto end() const -> decltype(r->end()) { return r->end(); }
+};
+
+TEST(ranges_test, range_of_range_of_mixed_const) {
+  auto v = std::vector<std::vector<int>>{{1, 2, 3}, {4, 5}};
+  EXPECT_EQ(fmt::format("{}", v), "[[1, 2, 3], [4, 5]]");
+
+  auto r = fmt_ref_view<decltype(v)>{&v};
+  EXPECT_EQ(fmt::format("{}", r), "[[1, 2, 3], [4, 5]]");
+}
+
+TEST(ranges_test, vector_char) {
+  EXPECT_EQ(fmt::format("{}", std::vector<char>{'a', 'b'}), "['a', 'b']");
+}
+
+TEST(ranges_test, container_adaptor) {
+  {
+    using fmt::detail::is_container_adaptor_like;
+    using T = std::nullptr_t;
+    static_assert(is_container_adaptor_like<std::stack<T>>::value, "");
+    static_assert(is_container_adaptor_like<std::queue<T>>::value, "");
+    static_assert(is_container_adaptor_like<std::priority_queue<T>>::value, "");
+    static_assert(!is_container_adaptor_like<std::vector<T>>::value, "");
+  }
+
+  {
+    auto s = std::stack<int>();
+    s.push(1);
+    s.push(2);
+    EXPECT_EQ(fmt::format("{}", s), "[1, 2]");
+    EXPECT_EQ(fmt::format("{}", const_cast<const decltype(s)&>(s)), "[1, 2]");
+  }
+
+  {
+    auto q = std::queue<int>();
+    q.push(1);
+    q.push(2);
+    EXPECT_EQ(fmt::format("{}", q), "[1, 2]");
+  }
+
+  {
+    auto q = std::priority_queue<int>();
+    q.push(3);
+    q.push(1);
+    q.push(2);
+    q.push(4);
+    EXPECT_EQ(fmt::format("{}", q), "[4, 3, 2, 1]");
+  }
+
+  {
+    auto s = std::stack<char, std::string>();
+    s.push('a');
+    s.push('b');
+    // See https://cplusplus.github.io/LWG/issue3881.
+    EXPECT_EQ(fmt::format("{}", s), "['a', 'b']");
+  }
+
+  {
+    struct my_container_adaptor {
+      using value_type = int;
+      using container_type = std::vector<value_type>;
+      void push(const value_type& v) { c.push_back(v); }
+
+     protected:
+      container_type c;
+    };
+
+    auto m = my_container_adaptor();
+    m.push(1);
+    m.push(2);
+    EXPECT_EQ(fmt::format("{}", m), "[1, 2]");
+  }
+}
+
+struct tieable {
+  int a = 3;
+  double b = 0.42;
+};
+
+auto format_as(const tieable& t) -> std::tuple<int, double> {
+  return std::tie(t.a, t.b);
+}
+
+TEST(ranges_test, format_as_tie) {
+  EXPECT_EQ(fmt::format("{}", tieable()), "(3, 0.42)");
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/scan-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/scan-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f0ede192fb03e25a1f4564dc013c97b628a58622
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/scan-test.cc
@@ -0,0 +1,188 @@
+// Formatting library for C++ - scanning API test
+//
+// Copyright (c) 2019 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "scan.h"
+
+#include <time.h>
+
+#include <climits>
+#include <thread>
+
+#include "fmt/os.h"
+#include "gmock/gmock.h"
+#include "gtest-extra.h"
+
+TEST(scan_test, read_text) {
+  fmt::string_view s = "foo";
+  auto end = fmt::scan(s, "foo");
+  EXPECT_EQ(end, s.end());
+  EXPECT_THROW_MSG(fmt::scan("fob", "foo"), fmt::format_error, "invalid input");
+}
+
+TEST(scan_test, read_int) {
+  int n = 0;
+  fmt::scan("42", "{}", n);
+  EXPECT_EQ(n, 42);
+  fmt::scan("-42", "{}", n);
+  EXPECT_EQ(n, -42);
+  fmt::scan("42", "{:}", n);
+  EXPECT_EQ(n, 42);
+  EXPECT_THROW_MSG(fmt::scan(std::to_string(INT_MAX + 1u), "{}", n),
+                   fmt::format_error, "number is too big");
+}
+
+TEST(scan_test, read_longlong) {
+  long long n = 0;
+  fmt::scan("42", "{}", n);
+  EXPECT_EQ(n, 42);
+  fmt::scan("-42", "{}", n);
+  EXPECT_EQ(n, -42);
+}
+
+TEST(scan_test, read_uint) {
+  unsigned n = 0;
+  fmt::scan("42", "{}", n);
+  EXPECT_EQ(n, 42);
+  EXPECT_THROW_MSG(fmt::scan("-42", "{}", n), fmt::format_error,
+                   "invalid input");
+}
+
+TEST(scan_test, read_ulonglong) {
+  unsigned long long n = 0;
+  fmt::scan("42", "{}", n);
+  EXPECT_EQ(n, 42);
+  EXPECT_THROW_MSG(fmt::scan("-42", "{}", n), fmt::format_error,
+                   "invalid input");
+}
+
+TEST(scan_test, read_hex) {
+  unsigned n = 0;
+  fmt::scan("2a", "{:x}", n);
+  EXPECT_EQ(n, 42);
+  auto num_digits = std::numeric_limits<unsigned>::digits / 4;
+  EXPECT_THROW_MSG(fmt::scan(fmt::format("1{:0{}}", 0, num_digits), "{:x}", n),
+                   fmt::format_error, "number is too big");
+}
+
+TEST(scan_test, read_string) {
+  std::string s;
+  fmt::scan("foo", "{}", s);
+  EXPECT_EQ(s, "foo");
+}
+
+TEST(scan_test, read_string_view) {
+  fmt::string_view s;
+  fmt::scan("foo", "{}", s);
+  EXPECT_EQ(s, "foo");
+}
+
+TEST(scan_test, separator) {
+  int n1 = 0, n2 = 0;
+  fmt::scan("10 20", "{} {}", n1, n2);
+  EXPECT_EQ(n1, 10);
+  EXPECT_EQ(n2, 20);
+}
+
+struct num {
+  int value;
+};
+
+namespace fmt {
+template <> struct scanner<num> {
+  bool hex = false;
+
+  auto parse(scan_parse_context& ctx) -> scan_parse_context::iterator {
+    auto it = ctx.begin(), end = ctx.end();
+    if (it != end && *it == 'x') hex = true;
+    if (it != end && *it != '}') throw_format_error("invalid format");
+    return it;
+  }
+
+  template <class ScanContext>
+  auto scan(num& n, ScanContext& ctx) const -> typename ScanContext::iterator {
+    // TODO: handle specifier
+    return fmt::scan(ctx, "{}", n.value);
+  }
+};
+}  // namespace fmt
+
+TEST(scan_test, read_custom) {
+  auto input = "42";
+  auto n = num();
+  fmt::scan(input, "{:}", n);
+  EXPECT_EQ(n.value, 42);
+}
+
+TEST(scan_test, invalid_format) {
+  EXPECT_THROW_MSG(fmt::scan("", "{}"), fmt::format_error,
+                   "argument index out of range");
+  EXPECT_THROW_MSG(fmt::scan("", "{"), fmt::format_error,
+                   "invalid format string");
+}
+
+TEST(scan_test, example) {
+  std::string key;
+  int value = 0;
+  fmt::scan("answer = 42", "{} = {}", key, value);
+  EXPECT_EQ(key, "answer");
+  EXPECT_EQ(value, 42);
+}
+
+TEST(scan_test, end_of_input) {
+  int value = 0;
+  fmt::scan("", "{}", value);
+}
+
+#if FMT_USE_FCNTL
+TEST(scan_test, file) {
+  fmt::file read_end, write_end;
+  fmt::file::pipe(read_end, write_end);
+
+  fmt::string_view input = "10 20";
+  write_end.write(input.data(), input.size());
+  write_end.close();
+
+  int n1 = 0, n2 = 0;
+  fmt::buffered_file f = read_end.fdopen("r");
+  fmt::scan(f.get(), "{} {}", n1, n2);
+  EXPECT_EQ(n1, 10);
+  EXPECT_EQ(n2, 20);
+}
+
+TEST(scan_test, lock) {
+  fmt::file read_end, write_end;
+  fmt::file::pipe(read_end, write_end);
+
+  std::thread producer([&]() {
+    fmt::string_view input = "42 ";
+    for (int i = 0; i < 1000; ++i) write_end.write(input.data(), input.size());
+    write_end.close();
+  });
+
+  std::atomic<int> count(0);
+  fmt::buffered_file f = read_end.fdopen("r");
+  auto fun = [&]() {
+    int value = 0;
+    while (fmt::scan(f.get(), "{}", value)) {
+      if (value != 42) {
+        read_end.close();
+        EXPECT_EQ(value, 42);
+        break;
+      }
+      ++count;
+    }
+  };
+  std::thread consumer1(fun);
+  std::thread consumer2(fun);
+  
+  producer.join();
+  consumer1.join();
+  consumer2.join();
+  EXPECT_EQ(count, 1000);
+
+}
+#endif  // FMT_USE_FCNTL
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/scan.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/scan.h
new file mode 100644
index 0000000000000000000000000000000000000000..a68c77c3b4ac3a5f29e94e4d87feffcd88879ba7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/scan.h
@@ -0,0 +1,666 @@
+// Formatting library for C++ - scanning API proof of concept
+//
+// Copyright (c) 2019 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <array>
+#include <cassert>
+#include <climits>
+
+#include "fmt/format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+inline auto is_whitespace(char c) -> bool { return c == ' ' || c == '\n'; }
+
+// If c is a hex digit returns its numeric value, othewise -1.
+inline auto to_hex_digit(char c) -> int {
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+  if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+  return -1;
+}
+
+struct maybe_contiguous_range {
+  const char* begin;
+  const char* end;
+
+  explicit operator bool() const { return begin != nullptr; }
+};
+
+class scan_buffer {
+ private:
+  const char* ptr_;
+  const char* end_;
+  bool contiguous_;
+
+ protected:
+  scan_buffer(const char* ptr, const char* end, bool contiguous)
+      : ptr_(ptr), end_(end), contiguous_(contiguous) {}
+  ~scan_buffer() = default;
+
+  void set(string_view buf) {
+    ptr_ = buf.begin();
+    end_ = buf.end();
+  }
+
+  auto ptr() const -> const char* { return ptr_; }
+
+ public:
+  scan_buffer(const scan_buffer&) = delete;
+  void operator=(const scan_buffer&) = delete;
+
+  // Fills the buffer with more input if available.
+  virtual void consume() = 0;
+
+  class sentinel {};
+
+  class iterator {
+   private:
+    const char** ptr_;
+    scan_buffer* buf_;  // This could be merged with ptr_.
+    char value_;
+
+    static auto get_sentinel() -> const char** {
+      static const char* ptr = nullptr;
+      return &ptr;
+    }
+
+    friend class scan_buffer;
+
+    friend auto operator==(iterator lhs, sentinel) -> bool {
+      return *lhs.ptr_ == nullptr;
+    }
+    friend auto operator!=(iterator lhs, sentinel) -> bool {
+      return *lhs.ptr_ != nullptr;
+    }
+
+    iterator(scan_buffer* buf) : buf_(buf) {
+      if (buf->ptr_ == buf->end_) {
+        ptr_ = get_sentinel();
+        return;
+      }
+      ptr_ = &buf->ptr_;
+      value_ = *buf->ptr_;
+    }
+
+    friend scan_buffer& get_buffer(iterator it) { return *it.buf_; }
+
+   public:
+    iterator() : ptr_(get_sentinel()), buf_(nullptr) {}
+
+    auto operator++() -> iterator& {
+      if (!buf_->try_consume()) ptr_ = get_sentinel();
+      value_ = *buf_->ptr_;
+      return *this;
+    }
+    auto operator++(int) -> iterator {
+      iterator copy = *this;
+      ++*this;
+      return copy;
+    }
+    auto operator*() const -> char { return value_; }
+
+    auto base() const -> const char* { return buf_->ptr_; }
+
+    friend auto to_contiguous(iterator it) -> maybe_contiguous_range;
+    friend auto advance(iterator it, size_t n) -> iterator;
+  };
+
+  friend auto to_contiguous(iterator it) -> maybe_contiguous_range {
+    if (it.buf_->is_contiguous()) return {it.buf_->ptr_, it.buf_->end_};
+    return {nullptr, nullptr};
+  }
+  friend auto advance(iterator it, size_t n) -> iterator {
+    FMT_ASSERT(it.buf_->is_contiguous(), "");
+    const char*& ptr = it.buf_->ptr_;
+    ptr += n;
+    it.value_ = *ptr;
+    if (ptr == it.buf_->end_) it.ptr_ = iterator::get_sentinel();
+    return it;
+  }
+
+  auto begin() -> iterator { return this; }
+  auto end() -> sentinel { return {}; }
+
+  auto is_contiguous() const -> bool { return contiguous_; }
+
+  // Tries consuming a single code unit. Returns true iff there is more input.
+  auto try_consume() -> bool {
+    FMT_ASSERT(ptr_ != end_, "");
+    ++ptr_;
+    if (ptr_ != end_) return true;
+    consume();
+    return ptr_ != end_;
+  }
+};
+
+using scan_iterator = scan_buffer::iterator;
+using scan_sentinel = scan_buffer::sentinel;
+
+class string_scan_buffer : public scan_buffer {
+ private:
+  void consume() override {}
+
+ public:
+  explicit string_scan_buffer(string_view s)
+      : scan_buffer(s.begin(), s.end(), true) {}
+};
+
+#ifdef _WIN32
+void flockfile(FILE* f) { _lock_file(f); }
+void funlockfile(FILE* f) { _unlock_file(f); }
+int getc_unlocked(FILE* f) { return _fgetc_nolock(f); }
+#endif
+
+// A FILE wrapper. F is FILE defined as a template parameter to make
+// system-specific API detection work.
+template <typename F> class file_base {
+ protected:
+  F* file_;
+
+ public:
+  file_base(F* file) : file_(file) {}
+  operator F*() const { return file_; }
+
+  // Reads a code unit from the stream.
+  auto get() -> int {
+    int result = getc_unlocked(file_);
+    if (result == EOF && ferror(file_) != 0)
+      FMT_THROW(system_error(errno, FMT_STRING("getc failed")));
+    return result;
+  }
+
+  // Puts the code unit back into the stream buffer.
+  void unget(char c) {
+    if (ungetc(c, file_) == EOF)
+      FMT_THROW(system_error(errno, FMT_STRING("ungetc failed")));
+  }
+};
+
+// A FILE wrapper for glibc.
+template <typename F> class glibc_file : public file_base<F> {
+ public:
+  using file_base<F>::file_base;
+
+  // Returns the file's read buffer as a string_view.
+  auto buffer() const -> string_view {
+    return {this->file_->_IO_read_ptr,
+            to_unsigned(this->file_->_IO_read_end - this->file_->_IO_read_ptr)};
+  }
+};
+
+// A FILE wrapper for Apple's libc.
+template <typename F> class apple_file : public file_base<F> {
+ public:
+  using file_base<F>::file_base;
+
+  auto buffer() const -> string_view {
+    return {reinterpret_cast<char*>(this->file_->_p),
+            to_unsigned(this->file_->_r)};
+  }
+};
+
+// A fallback FILE wrapper.
+template <typename F> class fallback_file : public file_base<F> {
+ private:
+  char next_;  // The next unconsumed character in the buffer.
+  bool has_next_ = false;
+
+ public:
+  using file_base<F>::file_base;
+
+  auto buffer() const -> string_view { return {&next_, has_next_ ? 1u : 0u}; }
+
+  auto get() -> int {
+    has_next_ = false;
+    return file_base<F>::get();
+  }
+
+  void unget(char c) {
+    file_base<F>::unget(c);
+    next_ = c;
+    has_next_ = true;
+  }
+};
+
+class file_scan_buffer : public scan_buffer {
+ private:
+  template <typename F, FMT_ENABLE_IF(sizeof(F::_IO_read_ptr) != 0)>
+  static auto get_file(F* f, int) -> glibc_file<F> {
+    return f;
+  }
+  template <typename F, FMT_ENABLE_IF(sizeof(F::_p) != 0)>
+  static auto get_file(F* f, int) -> apple_file<F> {
+    return f;
+  }
+  static auto get_file(FILE* f, ...) -> fallback_file<FILE> { return f; }
+
+  decltype(get_file(static_cast<FILE*>(nullptr), 0)) file_;
+
+  // Fills the buffer if it is empty.
+  void fill() {
+    string_view buf = file_.buffer();
+    if (buf.size() == 0) {
+      int c = file_.get();
+      // Put the character back since we are only filling the buffer.
+      if (c != EOF) file_.unget(static_cast<char>(c));
+      buf = file_.buffer();
+    }
+    set(buf);
+  }
+
+  void consume() override {
+    // Consume the current buffer content.
+    size_t n = to_unsigned(ptr() - file_.buffer().begin());
+    for (size_t i = 0; i != n; ++i) file_.get();
+    fill();
+  }
+
+ public:
+  explicit file_scan_buffer(FILE* f)
+      : scan_buffer(nullptr, nullptr, false), file_(f) {
+    flockfile(f);
+    fill();
+  }
+  ~file_scan_buffer() { funlockfile(file_); }
+};
+}  // namespace detail
+
+template <typename T, typename Char = char> struct scanner {
+  // A deleted default constructor indicates a disabled scanner.
+  scanner() = delete;
+};
+
+class scan_parse_context {
+ private:
+  string_view format_;
+
+ public:
+  using iterator = string_view::iterator;
+
+  explicit FMT_CONSTEXPR scan_parse_context(string_view format)
+      : format_(format) {}
+
+  FMT_CONSTEXPR auto begin() const -> iterator { return format_.begin(); }
+  FMT_CONSTEXPR auto end() const -> iterator { return format_.end(); }
+
+  void advance_to(iterator it) {
+    format_.remove_prefix(detail::to_unsigned(it - begin()));
+  }
+};
+
+namespace detail {
+enum class scan_type {
+  none_type,
+  int_type,
+  uint_type,
+  long_long_type,
+  ulong_long_type,
+  string_type,
+  string_view_type,
+  custom_type
+};
+
+template <typename Context> struct custom_scan_arg {
+  void* value;
+  void (*scan)(void* arg, scan_parse_context& parse_ctx, Context& ctx);
+};
+}  // namespace detail
+
+// A scan argument. Context is a template parameter for the compiled API where
+// output can be unbuffered.
+template <typename Context> class basic_scan_arg {
+ private:
+  using scan_type = detail::scan_type;
+  scan_type type_;
+  union {
+    int* int_value_;
+    unsigned* uint_value_;
+    long long* long_long_value_;
+    unsigned long long* ulong_long_value_;
+    std::string* string_;
+    string_view* string_view_;
+    detail::custom_scan_arg<Context> custom_;
+    // TODO: more types
+  };
+
+  template <typename T>
+  static void scan_custom_arg(void* arg, scan_parse_context& parse_ctx,
+                              Context& ctx) {
+    auto s = scanner<T>();
+    parse_ctx.advance_to(s.parse(parse_ctx));
+    ctx.advance_to(s.scan(*static_cast<T*>(arg), ctx));
+  }
+
+ public:
+  FMT_CONSTEXPR basic_scan_arg()
+      : type_(scan_type::none_type), int_value_(nullptr) {}
+  FMT_CONSTEXPR basic_scan_arg(int& value)
+      : type_(scan_type::int_type), int_value_(&value) {}
+  FMT_CONSTEXPR basic_scan_arg(unsigned& value)
+      : type_(scan_type::uint_type), uint_value_(&value) {}
+  FMT_CONSTEXPR basic_scan_arg(long long& value)
+      : type_(scan_type::long_long_type), long_long_value_(&value) {}
+  FMT_CONSTEXPR basic_scan_arg(unsigned long long& value)
+      : type_(scan_type::ulong_long_type), ulong_long_value_(&value) {}
+  FMT_CONSTEXPR basic_scan_arg(std::string& value)
+      : type_(scan_type::string_type), string_(&value) {}
+  FMT_CONSTEXPR basic_scan_arg(string_view& value)
+      : type_(scan_type::string_view_type), string_view_(&value) {}
+  template <typename T>
+  FMT_CONSTEXPR basic_scan_arg(T& value) : type_(scan_type::custom_type) {
+    custom_.value = &value;
+    custom_.scan = scan_custom_arg<T>;
+  }
+
+  constexpr explicit operator bool() const noexcept {
+    return type_ != scan_type::none_type;
+  }
+
+  auto type() const -> detail::scan_type { return type_; }
+
+  template <typename Visitor>
+  auto visit(Visitor&& vis) -> decltype(vis(monostate())) {
+    switch (type_) {
+    case scan_type::none_type:
+      break;
+    case scan_type::int_type:
+      return vis(*int_value_);
+    case scan_type::uint_type:
+      return vis(*uint_value_);
+    case scan_type::long_long_type:
+      return vis(*long_long_value_);
+    case scan_type::ulong_long_type:
+      return vis(*ulong_long_value_);
+    case scan_type::string_type:
+      return vis(*string_);
+    case scan_type::string_view_type:
+      return vis(*string_view_);
+    case scan_type::custom_type:
+      break;
+    }
+    return vis(monostate());
+  }
+
+  auto scan_custom(const char* parse_begin, scan_parse_context& parse_ctx,
+                   Context& ctx) const -> bool {
+    if (type_ != scan_type::custom_type) return false;
+    parse_ctx.advance_to(parse_begin);
+    custom_.scan(custom_.value, parse_ctx, ctx);
+    return true;
+  }
+};
+
+class scan_context;
+using scan_arg = basic_scan_arg<scan_context>;
+
+struct scan_args {
+  int size;
+  const scan_arg* data;
+
+  template <size_t N>
+  FMT_CONSTEXPR scan_args(const std::array<scan_arg, N>& store)
+      : size(N), data(store.data()) {
+    static_assert(N < INT_MAX, "too many arguments");
+  }
+};
+
+class scan_context {
+ private:
+  detail::scan_buffer& buf_;
+  scan_args args_;
+
+ public:
+  using iterator = detail::scan_iterator;
+  using sentinel = detail::scan_sentinel;
+
+  explicit FMT_CONSTEXPR scan_context(detail::scan_buffer& buf, scan_args args)
+      : buf_(buf), args_(args) {}
+
+  FMT_CONSTEXPR auto arg(int id) const -> scan_arg {
+    return id < args_.size ? args_.data[id] : scan_arg();
+  }
+
+  auto begin() const -> iterator { return buf_.begin(); }
+  auto end() const -> sentinel { return {}; }
+
+  void advance_to(iterator) { buf_.consume(); }
+};
+
+namespace detail {
+
+const char* parse_scan_specs(const char* begin, const char* end,
+                             format_specs<>& specs, scan_type) {
+  while (begin != end) {
+    switch (to_ascii(*begin)) {
+    // TODO: parse more scan format specifiers
+    case 'x':
+      specs.type = presentation_type::hex_lower;
+      ++begin;
+      break;
+    case '}':
+      return begin;
+    }
+  }
+  return begin;
+}
+
+template <typename T, FMT_ENABLE_IF(std::is_unsigned<T>::value)>
+auto read(scan_iterator it, T& value)
+    -> scan_iterator {
+  if (it == scan_sentinel()) return it;
+  char c = *it;
+  if (c < '0' || c > '9') throw_format_error("invalid input");
+
+  int num_digits = 0;
+  T n = 0, prev = 0;
+  char prev_digit = c;
+  do {
+    prev = n;
+    n = n * 10 + static_cast<unsigned>(c - '0');
+    prev_digit = c;
+    c = *++it;
+    ++num_digits;
+    if (c < '0' || c > '9') break;
+  } while (it != scan_sentinel());
+
+  // Check overflow.
+  if (num_digits <= std::numeric_limits<int>::digits10) {
+    value = n;
+    return it;
+  }
+  unsigned max = to_unsigned((std::numeric_limits<int>::max)());
+  if (num_digits == std::numeric_limits<int>::digits10 + 1 &&
+      prev * 10ull + unsigned(prev_digit - '0') <= max) {
+    value = n;
+  } else {
+    throw_format_error("number is too big");
+  }
+  return it;
+}
+
+template <typename T, FMT_ENABLE_IF(std::is_unsigned<T>::value)>
+auto read_hex(scan_iterator it, T& value)
+    -> scan_iterator {
+  if (it == scan_sentinel()) return it;
+  int digit = to_hex_digit(*it);
+  if (digit < 0) throw_format_error("invalid input");
+
+  int num_digits = 0;
+  T n = 0;
+  do {
+    n = (n << 4) + static_cast<unsigned>(digit);
+    ++num_digits;
+    digit = to_hex_digit(*++it);
+    if (digit < 0) break;
+  } while (it != scan_sentinel());
+
+  // Check overflow.
+  if (num_digits <= (std::numeric_limits<T>::digits >> 2))
+    value = n;
+  else
+    throw_format_error("number is too big");
+  return it;
+}
+
+template <typename T, FMT_ENABLE_IF(std::is_unsigned<T>::value)>
+auto read(scan_iterator it, T& value, const format_specs<>& specs)
+    -> scan_iterator {
+  if (specs.type == presentation_type::hex_lower)
+    return read_hex(it, value);
+  return read(it, value);
+}
+
+template <typename T, FMT_ENABLE_IF(std::is_signed<T>::value)>
+auto read(scan_iterator it, T& value, const format_specs<>& = {})
+    -> scan_iterator {
+  bool negative = it != scan_sentinel() && *it == '-';
+  if (negative) {
+    ++it;
+    if (it == scan_sentinel()) throw_format_error("invalid input");
+  }
+  using unsigned_type = typename std::make_unsigned<T>::type;
+  unsigned_type abs_value = 0;
+  it = read(it, abs_value);
+  auto n = static_cast<T>(abs_value);
+  value = negative ? -n : n;
+  return it;
+}
+
+auto read(scan_iterator it, std::string& value, const format_specs<>& = {})
+    -> scan_iterator {
+  while (it != scan_sentinel() && *it != ' ') value.push_back(*it++);
+  return it;
+}
+
+auto read(scan_iterator it, string_view& value, const format_specs<>& = {})
+    -> scan_iterator {
+  auto range = to_contiguous(it);
+  // This could also be checked at compile time in scan.
+  if (!range) throw_format_error("string_view requires contiguous input");
+  auto p = range.begin;
+  while (p != range.end && *p != ' ') ++p;
+  size_t size = to_unsigned(p - range.begin);
+  value = {range.begin, size};
+  return advance(it, size);
+}
+
+auto read(scan_iterator it, monostate, const format_specs<>& = {})
+    -> scan_iterator {
+  return it;
+}
+
+// An argument scanner that uses the default format, e.g. decimal for integers.
+struct default_arg_scanner {
+  scan_iterator it;
+
+  template <typename T> FMT_INLINE auto operator()(T&& value) -> scan_iterator {
+    return read(it, value);
+  }
+};
+
+// An argument scanner with format specifiers.
+struct arg_scanner {
+  scan_iterator it;
+  const format_specs<>& specs;
+
+  template <typename T> auto operator()(T&& value) -> scan_iterator {
+    return read(it, value, specs);
+  }
+};
+
+struct scan_handler : error_handler {
+ private:
+  scan_parse_context parse_ctx_;
+  scan_context scan_ctx_;
+  int next_arg_id_;
+
+  using sentinel = scan_buffer::sentinel;
+
+ public:
+  FMT_CONSTEXPR scan_handler(string_view format, scan_buffer& buf,
+                             scan_args args)
+      : parse_ctx_(format), scan_ctx_(buf, args), next_arg_id_(0) {}
+
+  auto pos() const -> scan_buffer::iterator { return scan_ctx_.begin(); }
+
+  void on_text(const char* begin, const char* end) {
+    if (begin == end) return;
+    auto it = scan_ctx_.begin();
+    for (; begin != end; ++begin, ++it) {
+      if (it == sentinel() || *begin != *it) on_error("invalid input");
+    }
+    scan_ctx_.advance_to(it);
+  }
+
+  FMT_CONSTEXPR auto on_arg_id() -> int { return on_arg_id(next_arg_id_++); }
+  FMT_CONSTEXPR auto on_arg_id(int id) -> int {
+    if (!scan_ctx_.arg(id)) on_error("argument index out of range");
+    return id;
+  }
+  FMT_CONSTEXPR auto on_arg_id(string_view id) -> int {
+    if (id.data()) on_error("invalid format");
+    return 0;
+  }
+
+  void on_replacement_field(int arg_id, const char*) {
+    scan_arg arg = scan_ctx_.arg(arg_id);
+    auto it = scan_ctx_.begin();
+    while (it != sentinel() && is_whitespace(*it)) ++it;
+    scan_ctx_.advance_to(arg.visit(default_arg_scanner{it}));
+  }
+
+  auto on_format_specs(int arg_id, const char* begin, const char* end) -> const
+      char* {
+    scan_arg arg = scan_ctx_.arg(arg_id);
+    if (arg.scan_custom(begin, parse_ctx_, scan_ctx_))
+      return parse_ctx_.begin();
+    auto specs = format_specs<>();
+    begin = parse_scan_specs(begin, end, specs, arg.type());
+    if (begin == end || *begin != '}') on_error("missing '}' in format string");
+    scan_ctx_.advance_to(arg.visit(arg_scanner{scan_ctx_.begin(), specs}));
+    return begin;
+  }
+
+  void on_error(const char* message) { error_handler::on_error(message); }
+};
+}  // namespace detail
+
+template <typename... T>
+auto make_scan_args(T&... args) -> std::array<scan_arg, sizeof...(T)> {
+  return {{args...}};
+}
+
+void vscan(detail::scan_buffer& buf, string_view fmt, scan_args args) {
+  auto h = detail::scan_handler(fmt, buf, args);
+  detail::parse_format_string<false>(fmt, h);
+}
+
+template <typename... T>
+auto scan(string_view input, string_view fmt, T&... args)
+    -> string_view::iterator {
+  auto&& buf = detail::string_scan_buffer(input);
+  vscan(buf, fmt, make_scan_args(args...));
+  return input.begin() + (buf.begin().base() - input.data());
+}
+
+template <typename InputRange, typename... T,
+          FMT_ENABLE_IF(!std::is_convertible<InputRange, string_view>::value)>
+auto scan(InputRange&& input, string_view fmt, T&... args)
+    -> decltype(std::begin(input)) {
+  auto it = std::begin(input);
+  vscan(get_buffer(it), fmt, make_scan_args(args...));
+  return it;
+}
+
+template <typename... T> bool scan(std::FILE* f, string_view fmt, T&... args) {
+  auto&& buf = detail::file_scan_buffer(f);
+  vscan(buf, fmt, make_scan_args(args...));
+  return buf.begin() != buf.end();
+}
+
+FMT_END_NAMESPACE
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/static-export-test/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/static-export-test/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..492194f9fe5ebce9347e7c2291d90eeb2ff69fa3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/static-export-test/CMakeLists.txt
@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.8...3.25)
+
+project(fmt-link CXX)
+
+set(BUILD_SHARED_LIBS OFF)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN TRUE)
+set(CMAKE_CXX_VISIBILITY_PRESET "hidden")
+
+# Broken LTO on GCC 4
+if (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5)
+  set(BROKEN_LTO ON)
+endif ()
+
+if (NOT BROKEN_LTO AND CMAKE_VERSION VERSION_GREATER "3.8")
+  # CMake 3.9+
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT HAVE_IPO)
+  if (HAVE_IPO)
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+  endif ()
+endif ()
+
+add_subdirectory(../.. fmt)
+set_property(TARGET fmt PROPERTY POSITION_INDEPENDENT_CODE ON)
+
+add_library(library-test SHARED library.cc)
+target_link_libraries(library-test PRIVATE fmt::fmt)
+
+add_executable(exe-test main.cc)
+target_link_libraries(exe-test PRIVATE library-test)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/static-export-test/library.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/static-export-test/library.cc
new file mode 100644
index 0000000000000000000000000000000000000000..fe4801ba58a4f2fdd0c0386c814ac607f007d5fb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/static-export-test/library.cc
@@ -0,0 +1,5 @@
+#include <fmt/compile.h>
+
+__attribute__((visibility("default"))) std::string foo() {
+  return fmt::format(FMT_COMPILE("foo bar {}"), 4242);
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/static-export-test/main.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/static-export-test/main.cc
new file mode 100644
index 0000000000000000000000000000000000000000..38f7999ed3dd1876ac2ff6292089cd2fbadac7c3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/static-export-test/main.cc
@@ -0,0 +1,6 @@
+#include <iostream>
+#include <string>
+
+extern std::string foo();
+
+int main() { std::cout << foo() << std::endl; }
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/std-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/std-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..de3feaa051b909bd99b58e05efe14adad88a7aac
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/std-test.cc
@@ -0,0 +1,306 @@
+// Formatting library for C++ - tests of formatters for standard library types
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/std.h"
+
+#include <bitset>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "fmt/os.h"  // fmt::system_category
+#include "fmt/ranges.h"
+#include "gtest-extra.h"  // StartsWith
+
+#ifdef __cpp_lib_filesystem
+TEST(std_test, path) {
+  using std::filesystem::path;
+  EXPECT_EQ(fmt::format("{}", path("/usr/bin")), "/usr/bin");
+  EXPECT_EQ(fmt::format("{:?}", path("/usr/bin")), "\"/usr/bin\"");
+  EXPECT_EQ(fmt::format("{:8}", path("foo")), "foo     ");
+
+  EXPECT_EQ(fmt::format("{}", path("foo\"bar")), "foo\"bar");
+  EXPECT_EQ(fmt::format("{:?}", path("foo\"bar")), "\"foo\\\"bar\"");
+
+  EXPECT_EQ(fmt::format("{:g}", path("/usr/bin")), "/usr/bin");
+#  ifdef _WIN32
+  EXPECT_EQ(fmt::format("{}", path("C:\\foo")), "C:\\foo");
+  EXPECT_EQ(fmt::format("{:g}", path("C:\\foo")), "C:/foo");
+
+  EXPECT_EQ(fmt::format("{}", path(L"\x0428\x0447\x0443\x0447\x044B\x043D\x0448"
+                                   L"\x0447\x044B\x043D\x0430")),
+            "Шчучыншчына");
+  EXPECT_EQ(fmt::format("{}", path(L"\xd800")), "�");
+  EXPECT_EQ(fmt::format("{:?}", path(L"\xd800")), "\"\\ud800\"");
+#  endif
+}
+
+// Test ambiguity problem described in #2954.
+TEST(ranges_std_test, format_vector_path) {
+  auto p = std::filesystem::path("foo/bar.txt");
+  auto c = std::vector<std::string>{"abc", "def"};
+  EXPECT_EQ(fmt::format("path={}, range={}", p, c),
+            "path=foo/bar.txt, range=[\"abc\", \"def\"]");
+}
+
+// Test that path is not escaped twice in the debug mode.
+TEST(ranges_std_test, format_quote_path) {
+  auto vec =
+      std::vector<std::filesystem::path>{"path1/file1.txt", "path2/file2.txt"};
+  EXPECT_EQ(fmt::format("{}", vec),
+            "[\"path1/file1.txt\", \"path2/file2.txt\"]");
+#  ifdef __cpp_lib_optional
+  auto o = std::optional<std::filesystem::path>("path/file.txt");
+  EXPECT_EQ(fmt::format("{}", o), "optional(\"path/file.txt\")");
+  EXPECT_EQ(fmt::format("{:?}", o), "optional(\"path/file.txt\")");
+#  endif
+}
+#endif
+
+TEST(std_test, thread_id) {
+  EXPECT_FALSE(fmt::format("{}", std::this_thread::get_id()).empty());
+}
+
+#ifdef __cpp_lib_source_location
+TEST(std_test, source_location) {
+  std::source_location loc = std::source_location::current();
+  EXPECT_EQ(fmt::format("{}", loc),
+            fmt::format("{}:{}:{}: {}", loc.file_name(), loc.line(),
+                        loc.column(), loc.function_name()));
+}
+#endif
+
+TEST(std_test, optional) {
+#ifdef __cpp_lib_optional
+  EXPECT_EQ(fmt::format("{}", std::optional<int>{}), "none");
+  EXPECT_EQ(fmt::format("{}", std::pair{1, "second"}), "(1, \"second\")");
+  EXPECT_EQ(fmt::format("{}", std::vector{std::optional{1}, std::optional{2},
+                                          std::optional{3}}),
+            "[optional(1), optional(2), optional(3)]");
+  EXPECT_EQ(
+      fmt::format("{}", std::optional<std::optional<const char*>>{{"nested"}}),
+      "optional(optional(\"nested\"))");
+  EXPECT_EQ(
+      fmt::format("{:<{}}", std::optional{std::string{"left aligned"}}, 30),
+      "optional(\"left aligned\"                )");
+  EXPECT_EQ(
+      fmt::format("{::d}", std::optional{std::vector{'h', 'e', 'l', 'l', 'o'}}),
+      "optional([104, 101, 108, 108, 111])");
+  EXPECT_EQ(fmt::format("{}", std::optional{std::string{"string"}}),
+            "optional(\"string\")");
+  EXPECT_EQ(fmt::format("{}", std::optional{'C'}), "optional(\'C\')");
+  EXPECT_EQ(fmt::format("{:.{}f}", std::optional{3.14}, 1), "optional(3.1)");
+
+  struct unformattable {};
+  EXPECT_FALSE((fmt::is_formattable<unformattable>::value));
+  EXPECT_FALSE((fmt::is_formattable<std::optional<unformattable>>::value));
+  EXPECT_TRUE((fmt::is_formattable<std::optional<int>>::value));
+#endif
+}
+
+namespace my_nso {
+enum class my_number {
+  one,
+  two,
+};
+auto format_as(my_number number) -> fmt::string_view {
+  return number == my_number::one ? "first" : "second";
+}
+
+class my_class {
+ public:
+  int av;
+
+ private:
+  friend auto format_as(const my_class& elm) -> std::string {
+    return fmt::to_string(elm.av);
+  }
+};
+}  // namespace my_nso
+TEST(std_test, optional_format_as) {
+#ifdef __cpp_lib_optional
+  EXPECT_EQ(fmt::format("{}", std::optional<my_nso::my_number>{}), "none");
+  EXPECT_EQ(fmt::format("{}", std::optional{my_nso::my_number::one}),
+            "optional(\"first\")");
+  EXPECT_EQ(fmt::format("{}", std::optional<my_nso::my_class>{}), "none");
+  EXPECT_EQ(fmt::format("{}", std::optional{my_nso::my_class{7}}),
+            "optional(\"7\")");
+#endif
+}
+
+struct throws_on_move {
+  throws_on_move() = default;
+
+  [[noreturn]] throws_on_move(throws_on_move&&) {
+    throw std::runtime_error("Thrown by throws_on_move");
+  }
+
+  throws_on_move(const throws_on_move&) = default;
+};
+
+namespace fmt {
+template <> struct formatter<throws_on_move> : formatter<string_view> {
+  auto format(const throws_on_move&, format_context& ctx) const
+      -> decltype(ctx.out()) {
+    string_view str("<throws_on_move>");
+    return formatter<string_view>::format(str, ctx);
+  }
+};
+}  // namespace fmt
+
+TEST(std_test, variant) {
+#ifdef __cpp_lib_variant
+  EXPECT_EQ(fmt::format("{}", std::monostate{}), "monostate");
+  using V0 = std::variant<int, float, std::string, char>;
+  V0 v0(42);
+  V0 v1(1.5f);
+  V0 v2("hello");
+  V0 v3('i');
+  EXPECT_EQ(fmt::format("{}", v0), "variant(42)");
+  EXPECT_EQ(fmt::format("{}", v1), "variant(1.5)");
+  EXPECT_EQ(fmt::format("{}", v2), "variant(\"hello\")");
+  EXPECT_EQ(fmt::format("{}", v3), "variant('i')");
+
+  struct unformattable {};
+  EXPECT_FALSE((fmt::is_formattable<unformattable>::value));
+  EXPECT_FALSE((fmt::is_formattable<std::variant<unformattable>>::value));
+  EXPECT_FALSE((fmt::is_formattable<std::variant<unformattable, int>>::value));
+  EXPECT_FALSE((fmt::is_formattable<std::variant<int, unformattable>>::value));
+  EXPECT_FALSE(
+      (fmt::is_formattable<std::variant<unformattable, unformattable>>::value));
+  EXPECT_TRUE((fmt::is_formattable<std::variant<int, float>>::value));
+
+  using V1 = std::variant<std::monostate, std::string, std::string>;
+  V1 v4{};
+  V1 v5{std::in_place_index<1>, "yes, this is variant"};
+
+  EXPECT_EQ(fmt::format("{}", v4), "variant(monostate)");
+  EXPECT_EQ(fmt::format("{}", v5), "variant(\"yes, this is variant\")");
+
+  volatile int i = 42;  // Test compile error before GCC 11 described in #3068.
+  EXPECT_EQ(fmt::format("{}", i), "42");
+
+  std::variant<std::monostate, throws_on_move> v6;
+
+  try {
+    throws_on_move thrower;
+    v6.emplace<throws_on_move>(std::move(thrower));
+  } catch (const std::runtime_error&) {
+  }
+  // v6 is now valueless by exception
+
+  EXPECT_EQ(fmt::format("{}", v6), "variant(valueless by exception)");
+
+#endif
+}
+
+TEST(std_test, error_code) {
+  EXPECT_EQ("generic:42",
+            fmt::format(FMT_STRING("{0}"),
+                        std::error_code(42, std::generic_category())));
+  EXPECT_EQ("system:42",
+            fmt::format(FMT_STRING("{0}"),
+                        std::error_code(42, fmt::system_category())));
+  EXPECT_EQ("system:-42",
+            fmt::format(FMT_STRING("{0}"),
+                        std::error_code(-42, fmt::system_category())));
+}
+
+template <typename Catch> void exception_test() {
+  try {
+    throw std::runtime_error("Test Exception");
+  } catch (const Catch& ex) {
+    EXPECT_EQ("Test Exception", fmt::format("{}", ex));
+    EXPECT_EQ("std::runtime_error: Test Exception", fmt::format("{:t}", ex));
+  }
+}
+
+namespace my_ns1 {
+namespace my_ns2 {
+struct my_exception : public std::exception {
+ private:
+  std::string msg;
+
+ public:
+  my_exception(const std::string& s) : msg(s) {}
+  const char* what() const noexcept override;
+};
+const char* my_exception::what() const noexcept { return msg.c_str(); }
+}  // namespace my_ns2
+}  // namespace my_ns1
+
+TEST(std_test, exception) {
+  using testing::StartsWith;
+  exception_test<std::exception>();
+  exception_test<std::runtime_error>();
+
+  try {
+    using namespace my_ns1::my_ns2;
+    throw my_exception("My Exception");
+  } catch (const std::exception& ex) {
+    EXPECT_EQ("my_ns1::my_ns2::my_exception: My Exception",
+              fmt::format("{:t}", ex));
+    EXPECT_EQ("My Exception", fmt::format("{:}", ex));
+  }
+
+  try {
+    throw std::system_error(std::error_code(), "message");
+  } catch (const std::system_error& ex) {
+    EXPECT_THAT(fmt::format("{:t}", ex), StartsWith("std::system_error: "));
+  }
+
+#ifdef __cpp_lib_filesystem
+  // Tests that the inline namespace is stripped out, e.g.
+  // std::filesystem::__cxx11::* -> std::filesystem::*.
+  try {
+    throw std::filesystem::filesystem_error("message", std::error_code());
+  } catch (const std::filesystem::filesystem_error& ex) {
+    EXPECT_THAT(fmt::format("{:t}", ex),
+                StartsWith("std::filesystem::filesystem_error: "));
+  }
+#endif
+}
+
+TEST(std_test, format_bit_reference) {
+  std::bitset<2> bs(1);
+  EXPECT_EQ(fmt::format("{} {}", bs[0], bs[1]), "true false");
+  std::vector<bool> v = {true, false};
+  EXPECT_EQ(fmt::format("{} {}", v[0], v[1]), "true false");
+}
+
+TEST(std_test, format_const_bit_reference) {
+  const std::bitset<2> bs(1);
+  EXPECT_EQ(fmt::format("{} {}", bs[0], bs[1]), "true false");
+  const std::vector<bool> v = {true, false};
+  EXPECT_EQ(fmt::format("{} {}", v[0], v[1]), "true false");
+}
+
+TEST(std_test, format_bitset) {
+  auto bs = std::bitset<6>(42);
+  EXPECT_EQ(fmt::format("{}", bs), "101010");
+  EXPECT_EQ(fmt::format("{:0>8}", bs), "00101010");
+  EXPECT_EQ(fmt::format("{:-^12}", bs), "---101010---");
+}
+
+TEST(std_test, format_atomic) {
+  std::atomic<bool> b(false);
+  EXPECT_EQ(fmt::format("{}", b), "false");
+
+  const std::atomic<bool> cb(true);
+  EXPECT_EQ(fmt::format("{}", cb), "true");
+}
+
+#ifdef __cpp_lib_atomic_flag_test
+TEST(std_test, format_atomic_flag) {
+  std::atomic_flag f = ATOMIC_FLAG_INIT;
+  (void)f.test_and_set();
+  EXPECT_EQ(fmt::format("{}", f), "true");
+
+  const std::atomic_flag cf = ATOMIC_FLAG_INIT;
+  EXPECT_EQ(fmt::format("{}", cf), "false");
+}
+#endif  // __cpp_lib_atomic_flag_test
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/test-assert.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/test-assert.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab7b2bf732f1901ab314874471e84879c217c4c1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/test-assert.h
@@ -0,0 +1,39 @@
+// Formatting library for C++ - test version of FMT_ASSERT
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_TEST_ASSERT_H_
+#define FMT_TEST_ASSERT_H_
+
+#include <stdexcept>
+
+void throw_assertion_failure(const char* message);
+#define FMT_ASSERT(condition, message) \
+  if (!(condition)) throw_assertion_failure(message);
+
+#include "gtest/gtest.h"
+
+class assertion_failure : public std::logic_error {
+ public:
+  explicit assertion_failure(const char* message) : std::logic_error(message) {}
+
+ private:
+  virtual void avoid_weak_vtable();
+};
+
+void assertion_failure::avoid_weak_vtable() {}
+
+// We use a separate function (rather than throw directly from FMT_ASSERT) to
+// avoid GCC's -Wterminate warning when FMT_ASSERT is used in a destructor.
+inline void throw_assertion_failure(const char* message) {
+  throw assertion_failure(message);
+}
+
+// Expects an assertion failure.
+#define EXPECT_ASSERT(stmt, message) \
+  FMT_TEST_THROW_(stmt, assertion_failure, message, GTEST_NONFATAL_FAILURE_)
+
+#endif  // FMT_TEST_ASSERT_H_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/test-main.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/test-main.cc
new file mode 100644
index 0000000000000000000000000000000000000000..39d2789d33c3fd555022cfaf7fe045a9072f85a7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/test-main.cc
@@ -0,0 +1,43 @@
+// Formatting library for C++ - test main function.
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <cstdlib>
+
+#include "gtest/gtest.h"
+
+#ifdef _WIN32
+#  include <windows.h>
+#endif
+
+#ifdef _MSC_VER
+#  include <crtdbg.h>
+#endif
+
+int main(int argc, char** argv) {
+#ifdef _WIN32
+  // Don't display any error dialogs. This also suppresses message boxes
+  // on assertion failures in MinGW where _set_error_mode/CrtSetReportMode
+  // doesn't help.
+  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
+               SEM_NOOPENFILEERRORBOX);
+#endif
+#ifdef _MSC_VER
+  // Disable message boxes on assertion failures.
+  _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+  _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
+  _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+  _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
+#endif
+  try {
+    testing::InitGoogleTest(&argc, argv);
+    testing::FLAGS_gtest_death_test_style = "threadsafe";
+    return RUN_ALL_TESTS();
+  } catch (...) {
+    // Catch all exceptions to make Coverity happy.
+  }
+  return EXIT_FAILURE;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/unicode-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/unicode-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e9ea5e5e079da87c8218f51cbeec4f71c53a2b6b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/unicode-test.cc
@@ -0,0 +1,48 @@
+// Formatting library for C++ - Unicode tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <iomanip>
+#include <locale>
+#include <vector>
+
+#include "fmt/chrono.h"
+#include "gmock/gmock.h"
+#include "util.h"  // get_locale
+
+using testing::Contains;
+
+TEST(unicode_test, is_utf8) { EXPECT_TRUE(fmt::detail::is_utf8()); }
+
+TEST(unicode_test, legacy_locale) {
+  auto loc = get_locale("be_BY.CP1251", "Belarusian_Belarus.1251");
+  if (loc == std::locale::classic()) return;
+
+  auto s = std::string();
+  try {
+    s = fmt::format(loc, "Дзень тыдня: {:L}", fmt::weekday(1));
+  } catch (const fmt::format_error& e) {
+    // Formatting can fail due to an unsupported encoding.
+    fmt::print("Format error: {}\n", e.what());
+    return;
+  }
+
+#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 500
+  auto&& os = std::ostringstream();
+  os.imbue(loc);
+  auto tm = std::tm();
+  tm.tm_wday = 1;
+  os << std::put_time(&tm, "%a");
+  auto wd = os.str();
+  if (wd == "??") {
+    EXPECT_EQ(s, "Дзень тыдня: ??");
+    fmt::print("std::locale gives ?? as a weekday.\n");
+    return;
+  }
+#endif
+  EXPECT_THAT((std::vector<std::string>{"Дзень тыдня: пн", "Дзень тыдня: Пан"}),
+              Contains(s));
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/util.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/util.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d3f2dc7375f1ce1405e9ca439c27c5a25fe6425c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/util.cc
@@ -0,0 +1,50 @@
+// Formatting library for C++ - test utilities
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "util.h"
+
+#include <cstring>
+
+const char* const file_content = "Don't panic!";
+
+fmt::buffered_file open_buffered_file(FILE** fp) {
+#if FMT_USE_FCNTL
+  fmt::file read_end, write_end;
+  fmt::file::pipe(read_end, write_end);
+  write_end.write(file_content, std::strlen(file_content));
+  write_end.close();
+  fmt::buffered_file f = read_end.fdopen("r");
+  if (fp) *fp = f.get();
+#else
+  fmt::buffered_file f("test-file", "w");
+  fputs(file_content, f.get());
+  if (fp) *fp = f.get();
+#endif
+  return f;
+}
+
+std::locale do_get_locale(const char* name) {
+  try {
+    return std::locale(name);
+  } catch (const std::runtime_error&) {
+  }
+  return std::locale::classic();
+}
+
+std::locale get_locale(const char* name, const char* alt_name) {
+  auto loc = do_get_locale(name);
+  if (loc == std::locale::classic() && alt_name)
+    loc = do_get_locale(alt_name);
+#ifdef __OpenBSD__
+    // Locales are not working in OpenBSD:
+    // https://github.com/fmtlib/fmt/issues/3670.
+    loc = std::locale::classic();
+#endif
+  if (loc == std::locale::classic())
+    fmt::print(stderr, "{} locale is missing.\n", name);
+  return loc;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/util.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/util.h
new file mode 100644
index 0000000000000000000000000000000000000000..803cdeea9632ab63ae7e552c9bb84f4d2e80a992
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/util.h
@@ -0,0 +1,83 @@
+// Formatting library for C++ - test utilities
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include <cstdarg>
+#include <cstdio>
+#include <locale>
+#include <string>
+
+#include "fmt/os.h"
+
+#ifdef _MSC_VER
+#  define FMT_VSNPRINTF vsprintf_s
+#else
+#  define FMT_VSNPRINTF vsnprintf
+#endif
+
+template <size_t SIZE>
+void safe_sprintf(char (&buffer)[SIZE], const char* format, ...) {
+  std::va_list args;
+  va_start(args, format);
+  FMT_VSNPRINTF(buffer, SIZE, format, args);
+  va_end(args);
+}
+
+extern const char* const file_content;
+
+// Opens a buffered file for reading.
+auto open_buffered_file(FILE** fp = nullptr) -> fmt::buffered_file;
+
+inline auto safe_fopen(const char* filename, const char* mode) -> FILE* {
+#if defined(_WIN32) && !defined(__MINGW32__)
+  // Fix MSVC warning about "unsafe" fopen.
+  FILE* f = nullptr;
+  errno = fopen_s(&f, filename, mode);
+  return f;
+#else
+  return std::fopen(filename, mode);
+#endif
+}
+
+template <typename Char> class basic_test_string {
+ private:
+  std::basic_string<Char> value_;
+
+  static const Char empty[];
+
+ public:
+  explicit basic_test_string(const Char* value = empty) : value_(value) {}
+
+  auto value() const -> const std::basic_string<Char>& { return value_; }
+};
+
+template <typename Char> const Char basic_test_string<Char>::empty[] = {0};
+
+using test_string = basic_test_string<char>;
+using test_wstring = basic_test_string<wchar_t>;
+
+template <typename Char>
+auto operator<<(std::basic_ostream<Char>& os, const basic_test_string<Char>& s)
+    -> std::basic_ostream<Char>& {
+  os << s.value();
+  return os;
+}
+
+class date {
+  int year_, month_, day_;
+
+ public:
+  date(int year, int month, int day) : year_(year), month_(month), day_(day) {}
+
+  auto year() const -> int { return year_; }
+  auto month() const -> int { return month_; }
+  auto day() const -> int { return day_; }
+};
+
+// Returns a locale with the given name if available or classic locale
+// otherwise.
+auto get_locale(const char* name, const char* alt_name = nullptr)
+    -> std::locale;
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/xchar-test.cc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/xchar-test.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7f33fb27aa0a8dec0efeb3b8182f4f7dbd728a4c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/test/xchar-test.cc
@@ -0,0 +1,629 @@
+// Formatting library for C++ - formatting library tests
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/xchar.h"
+
+#include <algorithm>
+#include <complex>
+#include <cwchar>
+#include <vector>
+
+#include "fmt/chrono.h"
+#include "fmt/color.h"
+#include "fmt/ostream.h"
+#include "fmt/ranges.h"
+#include "fmt/std.h"
+#include "gtest-extra.h"  // Contains
+#include "util.h"         // get_locale
+
+using fmt::detail::max_value;
+using testing::Contains;
+
+#if defined(__MINGW32__) && !defined(_UCRT)
+// Only C89 conversion specifiers when using MSVCRT instead of UCRT
+#  define FMT_HAS_C99_STRFTIME 0
+#else
+#  define FMT_HAS_C99_STRFTIME 1
+#endif
+
+struct non_string {};
+
+template <typename T> class is_string_test : public testing::Test {};
+
+using string_char_types = testing::Types<char, wchar_t, char16_t, char32_t>;
+TYPED_TEST_SUITE(is_string_test, string_char_types);
+
+template <typename Char>
+struct derived_from_string_view : fmt::basic_string_view<Char> {};
+
+TYPED_TEST(is_string_test, is_string) {
+  EXPECT_TRUE(fmt::detail::is_string<TypeParam*>::value);
+  EXPECT_TRUE(fmt::detail::is_string<const TypeParam*>::value);
+  EXPECT_TRUE(fmt::detail::is_string<TypeParam[2]>::value);
+  EXPECT_TRUE(fmt::detail::is_string<const TypeParam[2]>::value);
+  EXPECT_TRUE(fmt::detail::is_string<std::basic_string<TypeParam>>::value);
+  EXPECT_TRUE(fmt::detail::is_string<fmt::basic_string_view<TypeParam>>::value);
+  EXPECT_TRUE(
+      fmt::detail::is_string<derived_from_string_view<TypeParam>>::value);
+  using fmt_string_view = fmt::detail::std_string_view<TypeParam>;
+  EXPECT_TRUE(std::is_empty<fmt_string_view>::value !=
+              fmt::detail::is_string<fmt_string_view>::value);
+  EXPECT_FALSE(fmt::detail::is_string<non_string>::value);
+}
+
+// std::is_constructible is broken in MSVC until version 2015.
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1900
+struct explicitly_convertible_to_wstring_view {
+  explicit operator fmt::wstring_view() const { return L"foo"; }
+};
+
+TEST(xchar_test, format_explicitly_convertible_to_wstring_view) {
+  // Types explicitly convertible to wstring_view are not formattable by
+  // default because it may introduce ODR violations.
+  static_assert(
+      !fmt::is_formattable<explicitly_convertible_to_wstring_view>::value, "");
+}
+#endif
+
+TEST(xchar_test, format) {
+  EXPECT_EQ(L"42", fmt::format(L"{}", 42));
+  EXPECT_EQ(L"4.2", fmt::format(L"{}", 4.2));
+  EXPECT_EQ(L"abc", fmt::format(L"{}", L"abc"));
+  EXPECT_EQ(L"z", fmt::format(L"{}", L'z'));
+  EXPECT_THROW(fmt::format(fmt::runtime(L"{:*\x343E}"), 42), fmt::format_error);
+  EXPECT_EQ(L"true", fmt::format(L"{}", true));
+  EXPECT_EQ(L"a", fmt::format(L"{0}", 'a'));
+  EXPECT_EQ(L"a", fmt::format(L"{0}", L'a'));
+  EXPECT_EQ(L"Cyrillic letter \x42e",
+            fmt::format(L"Cyrillic letter {}", L'\x42e'));
+  EXPECT_EQ(L"abc1", fmt::format(L"{}c{}", L"ab", 1));
+}
+
+TEST(xchar_test, is_formattable) {
+  static_assert(!fmt::is_formattable<const wchar_t*>::value, "");
+}
+
+TEST(xchar_test, compile_time_string) {
+  EXPECT_EQ(fmt::format(fmt::wformat_string<int>(L"{}"), 42), L"42");
+#if defined(FMT_USE_STRING_VIEW) && FMT_CPLUSPLUS >= 201703L
+  EXPECT_EQ(fmt::format(FMT_STRING(std::wstring_view(L"{}")), 42), L"42");
+#endif
+}
+
+#if FMT_CPLUSPLUS > 201103L
+struct custom_char {
+  int value;
+  custom_char() = default;
+
+  template <typename T>
+  constexpr custom_char(T val) : value(static_cast<int>(val)) {}
+
+  constexpr operator char() const {
+    return value <= 0xff ? static_cast<char>(value) : '\0';
+  }
+  constexpr bool operator<(custom_char c) const { return value < c.value; }
+};
+
+namespace std {
+
+template <> struct char_traits<custom_char> {
+  using char_type = custom_char;
+  using int_type = int;
+  using off_type = streamoff;
+  using pos_type = streampos;
+  using state_type = mbstate_t;
+
+  static constexpr void assign(char_type& r, const char_type& a) { r = a; }
+  static constexpr bool eq(char_type a, char_type b) { return a == b; }
+  static constexpr bool lt(char_type a, char_type b) { return a < b; }
+  static FMT_CONSTEXPR int compare(const char_type* s1, const char_type* s2,
+                                   size_t count) {
+    for (; count; count--, s1++, s2++) {
+      if (lt(*s1, *s2)) return -1;
+      if (lt(*s2, *s1)) return 1;
+    }
+    return 0;
+  }
+  static FMT_CONSTEXPR size_t length(const char_type* s) {
+    size_t count = 0;
+    while (!eq(*s++, custom_char(0))) count++;
+    return count;
+  }
+  static const char_type* find(const char_type*, size_t, const char_type&);
+  static FMT_CONSTEXPR char_type* move(char_type* dest, const char_type* src,
+                                       size_t count) {
+    if (count == 0) return dest;
+    char_type* ret = dest;
+    if (src < dest) {
+      dest += count;
+      src += count;
+      for (; count; count--) assign(*--dest, *--src);
+    } else if (src > dest)
+      copy(dest, src, count);
+    return ret;
+  }
+  static FMT_CONSTEXPR char_type* copy(char_type* dest, const char_type* src,
+                                       size_t count) {
+    char_type* ret = dest;
+    for (; count; count--) assign(*dest++, *src++);
+    return ret;
+  }
+  static FMT_CONSTEXPR char_type* assign(char_type* dest, std::size_t count,
+                                         char_type a) {
+    char_type* ret = dest;
+    for (; count; count--) assign(*dest++, a);
+    return ret;
+  }
+  static int_type not_eof(int_type);
+  static char_type to_char_type(int_type);
+  static int_type to_int_type(char_type);
+  static bool eq_int_type(int_type, int_type);
+  static int_type eof();
+};
+
+}  // namespace std
+
+auto to_ascii(custom_char c) -> char { return c; }
+
+FMT_BEGIN_NAMESPACE
+template <> struct is_char<custom_char> : std::true_type {};
+FMT_END_NAMESPACE
+
+TEST(xchar_test, format_custom_char) {
+  const custom_char format[] = {'{', '}', 0};
+  auto result = fmt::format(format, custom_char('x'));
+  EXPECT_EQ(result.size(), 1);
+  EXPECT_EQ(result[0], custom_char('x'));
+}
+#endif
+
+// Convert a char8_t string to std::string. Otherwise GTest will insist on
+// inserting `char8_t` NTBS into a `char` stream which is disabled by P1423.
+template <typename S> std::string from_u8str(const S& str) {
+  return std::string(str.begin(), str.end());
+}
+
+TEST(xchar_test, format_to) {
+  auto buf = std::vector<wchar_t>();
+  fmt::format_to(std::back_inserter(buf), L"{}{}", 42, L'\0');
+  EXPECT_STREQ(buf.data(), L"42");
+}
+
+TEST(xchar_test, vformat_to) {
+  auto args = fmt::make_wformat_args(42);
+  auto w = std::wstring();
+  fmt::vformat_to(std::back_inserter(w), L"{}", args);
+  EXPECT_EQ(L"42", w);
+}
+
+namespace test {
+struct struct_as_wstring_view {};
+auto format_as(struct_as_wstring_view) -> fmt::wstring_view { return L"foo"; }
+}  // namespace test
+
+TEST(xchar_test, format_as) {
+  EXPECT_EQ(fmt::format(L"{}", test::struct_as_wstring_view()), L"foo");
+}
+
+TEST(format_test, wide_format_to_n) {
+  wchar_t buffer[4];
+  buffer[3] = L'x';
+  auto result = fmt::format_to_n(buffer, 3, L"{}", 12345);
+  EXPECT_EQ(5u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ(L"123x", fmt::wstring_view(buffer, 4));
+  buffer[0] = L'x';
+  buffer[1] = L'x';
+  buffer[2] = L'x';
+  result = fmt::format_to_n(buffer, 3, L"{}", L'A');
+  EXPECT_EQ(1u, result.size);
+  EXPECT_EQ(buffer + 1, result.out);
+  EXPECT_EQ(L"Axxx", fmt::wstring_view(buffer, 4));
+  result = fmt::format_to_n(buffer, 3, L"{}{} ", L'B', L'C');
+  EXPECT_EQ(3u, result.size);
+  EXPECT_EQ(buffer + 3, result.out);
+  EXPECT_EQ(L"BC x", fmt::wstring_view(buffer, 4));
+}
+
+#if FMT_USE_USER_DEFINED_LITERALS
+TEST(xchar_test, named_arg_udl) {
+  using namespace fmt::literals;
+  auto udl_a =
+      fmt::format(L"{first}{second}{first}{third}", L"first"_a = L"abra",
+                  L"second"_a = L"cad", L"third"_a = 99);
+  EXPECT_EQ(
+      fmt::format(L"{first}{second}{first}{third}", fmt::arg(L"first", L"abra"),
+                  fmt::arg(L"second", L"cad"), fmt::arg(L"third", 99)),
+      udl_a);
+}
+#endif  // FMT_USE_USER_DEFINED_LITERALS
+
+TEST(xchar_test, print) {
+  // Check that the wide print overload compiles.
+  if (fmt::detail::const_check(false)) {
+    fmt::print(L"test");
+    fmt::println(L"test");
+  }
+}
+
+TEST(xchar_test, join) {
+  int v[3] = {1, 2, 3};
+  EXPECT_EQ(fmt::format(L"({})", fmt::join(v, v + 3, L", ")), L"(1, 2, 3)");
+  auto t = std::tuple<wchar_t, int, float>('a', 1, 2.0f);
+  EXPECT_EQ(fmt::format(L"({})", fmt::join(t, L", ")), L"(a, 1, 2)");
+}
+
+enum streamable_enum {};
+
+std::wostream& operator<<(std::wostream& os, streamable_enum) {
+  return os << L"streamable_enum";
+}
+
+namespace fmt {
+template <>
+struct formatter<streamable_enum, wchar_t> : basic_ostream_formatter<wchar_t> {
+};
+}  // namespace fmt
+
+enum unstreamable_enum {};
+auto format_as(unstreamable_enum e) -> int { return e; }
+
+TEST(xchar_test, enum) {
+  EXPECT_EQ(L"streamable_enum", fmt::format(L"{}", streamable_enum()));
+  EXPECT_EQ(L"0", fmt::format(L"{}", unstreamable_enum()));
+}
+
+struct streamable_and_unformattable {};
+
+auto operator<<(std::wostream& os, streamable_and_unformattable)
+    -> std::wostream& {
+  return os << L"foo";
+}
+
+TEST(xchar_test, streamed) {
+  EXPECT_FALSE(fmt::is_formattable<streamable_and_unformattable>());
+  EXPECT_EQ(fmt::format(L"{}", fmt::streamed(streamable_and_unformattable())),
+            L"foo");
+}
+
+TEST(xchar_test, sign_not_truncated) {
+  wchar_t format_str[] = {
+      L'{', L':',
+      '+' | static_cast<wchar_t>(1 << fmt::detail::num_bits<char>()), L'}', 0};
+  EXPECT_THROW(fmt::format(fmt::runtime(format_str), 42), fmt::format_error);
+}
+
+TEST(xchar_test, chrono) {
+  auto tm = std::tm();
+  tm.tm_year = 116;
+  tm.tm_mon = 3;
+  tm.tm_mday = 25;
+  tm.tm_hour = 11;
+  tm.tm_min = 22;
+  tm.tm_sec = 33;
+  EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm),
+            "The date is 2016-04-25 11:22:33.");
+  EXPECT_EQ(L"42s", fmt::format(L"{}", std::chrono::seconds(42)));
+  EXPECT_EQ(fmt::format(L"{:%F}", tm), L"2016-04-25");
+  EXPECT_EQ(fmt::format(L"{:%T}", tm), L"11:22:33");
+}
+
+std::wstring system_wcsftime(const std::wstring& format, const std::tm* timeptr,
+                             std::locale* locptr = nullptr) {
+  auto loc = locptr ? *locptr : std::locale::classic();
+  auto& facet = std::use_facet<std::time_put<wchar_t>>(loc);
+  std::wostringstream os;
+  os.imbue(loc);
+  facet.put(os, os, L' ', timeptr, format.c_str(),
+            format.c_str() + format.size());
+#ifdef _WIN32
+  // Workaround a bug in older versions of Universal CRT.
+  auto str = os.str();
+  if (str == L"-0000") str = L"+0000";
+  return str;
+#else
+  return os.str();
+#endif
+}
+
+TEST(chrono_test_wchar, time_point) {
+  auto t1 = std::chrono::time_point_cast<std::chrono::seconds>(
+      std::chrono::system_clock::now());
+
+  std::vector<std::wstring> spec_list = {
+      L"%%",  L"%n",  L"%t",  L"%Y",  L"%EY", L"%y",  L"%Oy", L"%Ey", L"%C",
+      L"%EC", L"%G",  L"%g",  L"%b",  L"%h",  L"%B",  L"%m",  L"%Om", L"%U",
+      L"%OU", L"%W",  L"%OW", L"%V",  L"%OV", L"%j",  L"%d",  L"%Od", L"%e",
+      L"%Oe", L"%a",  L"%A",  L"%w",  L"%Ow", L"%u",  L"%Ou", L"%H",  L"%OH",
+      L"%I",  L"%OI", L"%M",  L"%OM", L"%S",  L"%OS", L"%x",  L"%Ex", L"%X",
+      L"%EX", L"%D",  L"%F",  L"%R",  L"%T",  L"%p"};
+#ifndef _WIN32
+  // Disabled on Windows, because these formats is not consistent among
+  // platforms.
+  spec_list.insert(spec_list.end(), {L"%c", L"%Ec", L"%r"});
+#elif !FMT_HAS_C99_STRFTIME
+  // Only C89 conversion specifiers when using MSVCRT instead of UCRT
+  spec_list = {L"%%", L"%Y", L"%y", L"%b", L"%B", L"%m", L"%U",
+               L"%W", L"%j", L"%d", L"%a", L"%A", L"%w", L"%H",
+               L"%I", L"%M", L"%S", L"%x", L"%X", L"%p"};
+#endif
+  spec_list.push_back(L"%Y-%m-%d %H:%M:%S");
+
+  for (const auto& spec : spec_list) {
+    auto t = std::chrono::system_clock::to_time_t(t1);
+    auto tm = *std::gmtime(&t);
+
+    auto sys_output = system_wcsftime(spec, &tm);
+
+    auto fmt_spec = fmt::format(L"{{:{}}}", spec);
+    EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), t1));
+    EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), tm));
+  }
+
+  // Timezone formatters tests makes sense for localtime.
+#if FMT_HAS_C99_STRFTIME
+  spec_list = {L"%z", L"%Z"};
+#else
+  spec_list = {L"%Z"};
+#endif
+  for (const auto& spec : spec_list) {
+    auto t = std::chrono::system_clock::to_time_t(t1);
+    auto tm = *std::localtime(&t);
+
+    auto sys_output = system_wcsftime(spec, &tm);
+
+    auto fmt_spec = fmt::format(L"{{:{}}}", spec);
+    EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), tm));
+
+    if (spec == L"%z") {
+      sys_output.insert(sys_output.end() - 2, 1, L':');
+      EXPECT_EQ(sys_output, fmt::format(L"{:%Ez}", tm));
+      EXPECT_EQ(sys_output, fmt::format(L"{:%Oz}", tm));
+    }
+  }
+
+  // Separate tests for UTC, since std::time_put can use local time and ignoring
+  // the timezone in std::tm (if it presents on platform).
+  if (fmt::detail::has_member_data_tm_zone<std::tm>::value) {
+    auto t = std::chrono::system_clock::to_time_t(t1);
+    auto tm = *std::gmtime(&t);
+
+    std::vector<std::wstring> tz_names = {L"GMT", L"UTC"};
+    EXPECT_THAT(tz_names, Contains(fmt::format(L"{:%Z}", t1)));
+    EXPECT_THAT(tz_names, Contains(fmt::format(L"{:%Z}", tm)));
+  }
+
+  if (fmt::detail::has_member_data_tm_gmtoff<std::tm>::value) {
+    auto t = std::chrono::system_clock::to_time_t(t1);
+    auto tm = *std::gmtime(&t);
+
+    EXPECT_EQ(L"+0000", fmt::format(L"{:%z}", t1));
+    EXPECT_EQ(L"+0000", fmt::format(L"{:%z}", tm));
+
+    EXPECT_EQ(L"+00:00", fmt::format(L"{:%Ez}", t1));
+    EXPECT_EQ(L"+00:00", fmt::format(L"{:%Ez}", tm));
+
+    EXPECT_EQ(L"+00:00", fmt::format(L"{:%Oz}", t1));
+    EXPECT_EQ(L"+00:00", fmt::format(L"{:%Oz}", tm));
+  }
+}
+
+TEST(xchar_test, color) {
+  EXPECT_EQ(fmt::format(fg(fmt::rgb(255, 20, 30)), L"rgb(255,20,30) wide"),
+            L"\x1b[38;2;255;020;030mrgb(255,20,30) wide\x1b[0m");
+}
+
+TEST(xchar_test, ostream) {
+#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 409
+  {
+    std::wostringstream wos;
+    fmt::print(wos, L"Don't {}!", L"panic");
+    EXPECT_EQ(wos.str(), L"Don't panic!");
+  }
+
+  {
+    std::wostringstream wos;
+    fmt::println(wos, L"Don't {}!", L"panic");
+    EXPECT_EQ(wos.str(), L"Don't panic!\n");
+  }
+#endif
+}
+
+TEST(xchar_test, format_map) {
+  auto m = std::map<std::wstring, int>{{L"one", 1}, {L"t\"wo", 2}};
+  EXPECT_EQ(fmt::format(L"{}", m), L"{\"one\": 1, \"t\\\"wo\": 2}");
+}
+
+TEST(xchar_test, escape_string) {
+  using vec = std::vector<std::wstring>;
+  EXPECT_EQ(fmt::format(L"{}", vec{L"\n\r\t\"\\"}), L"[\"\\n\\r\\t\\\"\\\\\"]");
+  EXPECT_EQ(fmt::format(L"{}", vec{L"понедельник"}), L"[\"понедельник\"]");
+}
+
+TEST(xchar_test, to_wstring) { EXPECT_EQ(L"42", fmt::to_wstring(42)); }
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+
+template <typename Char> struct numpunct : std::numpunct<Char> {
+ protected:
+  Char do_decimal_point() const override { return '?'; }
+  std::string do_grouping() const override { return "\03"; }
+  Char do_thousands_sep() const override { return '~'; }
+};
+
+template <typename Char> struct no_grouping : std::numpunct<Char> {
+ protected:
+  Char do_decimal_point() const override { return '.'; }
+  std::string do_grouping() const override { return ""; }
+  Char do_thousands_sep() const override { return ','; }
+};
+
+template <typename Char> struct special_grouping : std::numpunct<Char> {
+ protected:
+  Char do_decimal_point() const override { return '.'; }
+  std::string do_grouping() const override { return "\03\02"; }
+  Char do_thousands_sep() const override { return ','; }
+};
+
+template <typename Char> struct small_grouping : std::numpunct<Char> {
+ protected:
+  Char do_decimal_point() const override { return '.'; }
+  std::string do_grouping() const override { return "\01"; }
+  Char do_thousands_sep() const override { return ','; }
+};
+
+TEST(locale_test, localized_double) {
+  auto loc = std::locale(std::locale(), new numpunct<char>());
+  EXPECT_EQ(fmt::format(loc, "{:L}", 1.23), "1?23");
+  EXPECT_EQ(fmt::format(loc, "{:Lf}", 1.23), "1?230000");
+  EXPECT_EQ(fmt::format(loc, "{:L}", 1234.5), "1~234?5");
+  EXPECT_EQ(fmt::format(loc, "{:L}", 12000.0), "12~000");
+  EXPECT_EQ(fmt::format(loc, "{:8L}", 1230.0), "   1~230");
+  EXPECT_EQ(fmt::format(loc, "{:15.6Lf}", 0.1), "       0?100000");
+  EXPECT_EQ(fmt::format(loc, "{:15.6Lf}", 1.0), "       1?000000");
+  EXPECT_EQ(fmt::format(loc, "{:15.6Lf}", 1e3), "   1~000?000000");
+}
+
+TEST(locale_test, format) {
+  auto loc = std::locale(std::locale(), new numpunct<char>());
+  EXPECT_EQ("1234567", fmt::format(std::locale(), "{:L}", 1234567));
+  EXPECT_EQ("1~234~567", fmt::format(loc, "{:L}", 1234567));
+  EXPECT_EQ("-1~234~567", fmt::format(loc, "{:L}", -1234567));
+  EXPECT_EQ("-256", fmt::format(loc, "{:L}", -256));
+  auto n = 1234567;
+  EXPECT_EQ("1~234~567", fmt::vformat(loc, "{:L}", fmt::make_format_args(n)));
+  auto s = std::string();
+  fmt::format_to(std::back_inserter(s), loc, "{:L}", 1234567);
+  EXPECT_EQ("1~234~567", s);
+
+  auto no_grouping_loc = std::locale(std::locale(), new no_grouping<char>());
+  EXPECT_EQ("1234567", fmt::format(no_grouping_loc, "{:L}", 1234567));
+
+  auto special_grouping_loc =
+      std::locale(std::locale(), new special_grouping<char>());
+  EXPECT_EQ("1,23,45,678", fmt::format(special_grouping_loc, "{:L}", 12345678));
+  EXPECT_EQ("12,345", fmt::format(special_grouping_loc, "{:L}", 12345));
+
+  auto small_grouping_loc =
+      std::locale(std::locale(), new small_grouping<char>());
+  EXPECT_EQ("4,2,9,4,9,6,7,2,9,5",
+            fmt::format(small_grouping_loc, "{:L}", max_value<uint32_t>()));
+}
+
+TEST(locale_test, format_detault_align) {
+  auto loc = std::locale({}, new special_grouping<char>());
+  EXPECT_EQ("  12,345", fmt::format(loc, "{:8L}", 12345));
+}
+
+TEST(locale_test, format_plus) {
+  auto loc = std::locale({}, new special_grouping<char>());
+  EXPECT_EQ("+100", fmt::format(loc, "{:+L}", 100));
+}
+
+TEST(locale_test, wformat) {
+  auto loc = std::locale(std::locale(), new numpunct<wchar_t>());
+  EXPECT_EQ(L"1234567", fmt::format(std::locale(), L"{:L}", 1234567));
+  EXPECT_EQ(L"1~234~567", fmt::format(loc, L"{:L}", 1234567));
+  int n = 1234567;
+  EXPECT_EQ(L"1~234~567",
+            fmt::vformat(loc, L"{:L}", fmt::make_wformat_args(n)));
+  EXPECT_EQ(L"1234567", fmt::format(std::locale("C"), L"{:L}", 1234567));
+
+  auto no_grouping_loc = std::locale(std::locale(), new no_grouping<wchar_t>());
+  EXPECT_EQ(L"1234567", fmt::format(no_grouping_loc, L"{:L}", 1234567));
+
+  auto special_grouping_loc =
+      std::locale(std::locale(), new special_grouping<wchar_t>());
+  EXPECT_EQ(L"1,23,45,678",
+            fmt::format(special_grouping_loc, L"{:L}", 12345678));
+
+  auto small_grouping_loc =
+      std::locale(std::locale(), new small_grouping<wchar_t>());
+  EXPECT_EQ(L"4,2,9,4,9,6,7,2,9,5",
+            fmt::format(small_grouping_loc, L"{:L}", max_value<uint32_t>()));
+}
+
+TEST(locale_test, int_formatter) {
+  auto loc = std::locale(std::locale(), new special_grouping<char>());
+  auto f = fmt::formatter<int>();
+  auto parse_ctx = fmt::format_parse_context("L");
+  f.parse(parse_ctx);
+  auto buf = fmt::memory_buffer();
+  fmt::basic_format_context<fmt::appender, char> format_ctx(
+      fmt::appender(buf), {}, fmt::detail::locale_ref(loc));
+  f.format(12345, format_ctx);
+  EXPECT_EQ(fmt::to_string(buf), "12,345");
+}
+
+FMT_BEGIN_NAMESPACE
+template <class charT> struct formatter<std::complex<double>, charT> {
+ private:
+  detail::dynamic_format_specs<char> specs_;
+
+ public:
+  FMT_CONSTEXPR typename basic_format_parse_context<charT>::iterator parse(
+      basic_format_parse_context<charT>& ctx) {
+    auto end = parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
+                                  detail::type::float_type);
+    detail::parse_float_type_spec(specs_);
+    return end;
+  }
+
+  template <class FormatContext>
+  typename FormatContext::iterator format(const std::complex<double>& c,
+                                          FormatContext& ctx) {
+    detail::handle_dynamic_spec<detail::precision_checker>(
+        specs_.precision, specs_.precision_ref, ctx);
+    auto specs = std::string();
+    if (specs_.precision > 0) specs = fmt::format(".{}", specs_.precision);
+    if (specs_.type == presentation_type::fixed_lower) specs += 'f';
+    auto real = fmt::format(ctx.locale().template get<std::locale>(),
+                            fmt::runtime("{:" + specs + "}"), c.real());
+    auto imag = fmt::format(ctx.locale().template get<std::locale>(),
+                            fmt::runtime("{:" + specs + "}"), c.imag());
+    auto fill_align_width = std::string();
+    if (specs_.width > 0) fill_align_width = fmt::format(">{}", specs_.width);
+    return fmt::format_to(ctx.out(), runtime("{:" + fill_align_width + "}"),
+                          c.real() != 0 ? fmt::format("({}+{}i)", real, imag)
+                                        : fmt::format("{}i", imag));
+  }
+};
+FMT_END_NAMESPACE
+
+TEST(locale_test, complex) {
+  std::string s = fmt::format("{}", std::complex<double>(1, 2));
+  EXPECT_EQ(s, "(1+2i)");
+  EXPECT_EQ(fmt::format("{:.2f}", std::complex<double>(1, 2)), "(1.00+2.00i)");
+  EXPECT_EQ(fmt::format("{:8}", std::complex<double>(1, 2)), "  (1+2i)");
+}
+
+TEST(locale_test, chrono_weekday) {
+  auto loc = get_locale("es_ES.UTF-8", "Spanish_Spain.1252");
+  auto loc_old = std::locale::global(loc);
+  auto sat = fmt::weekday(6);
+  EXPECT_EQ(fmt::format(L"{}", sat), L"Sat");
+  if (loc != std::locale::classic()) {
+    // L'\xE1' is 'á'.
+    auto saturdays = std::vector<std::wstring>{L"s\xE1""b", L"s\xE1."};
+    EXPECT_THAT(saturdays, Contains(fmt::format(loc, L"{:L}", sat)));
+  }
+  std::locale::global(loc_old);
+}
+
+TEST(locale_test, sign) {
+  EXPECT_EQ(fmt::format(std::locale(), L"{:L}", -50), L"-50");
+}
+
+TEST(std_test_xchar, optional) {
+#  ifdef __cpp_lib_optional
+  EXPECT_EQ(fmt::format(L"{}", std::optional{L'C'}), L"optional(\'C\')");
+  EXPECT_EQ(fmt::format(L"{}", std::optional{std::wstring{L"wide string"}}),
+            L"optional(\"wide string\")");
+#  endif
+}
+
+#endif  // FMT_STATIC_THOUSANDS_SEPARATOR
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeCache.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeCache.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2567ccc1276530491467d65ff3442c603d01e681
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeCache.txt
@@ -0,0 +1,117 @@
+# This is the CMakeCache file.
+# For build in directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild
+# It was generated by CMake: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+# You can edit this file to change values found and used by cmake.
+# If you do not want to change any of the values, simply exit the editor.
+# If you do want to change a value, simply edit, save, and exit the editor.
+# The syntax for the file is as follows:
+# KEY:TYPE=VALUE
+# KEY is the name of a variable in the cache.
+# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
+# VALUE is the current value for the KEY.
+
+########################
+# EXTERNAL cache entries
+########################
+
+//Enable/Disable color output during build.
+CMAKE_COLOR_MAKEFILE:BOOL=ON
+
+//Enable/Disable output of compile commands during generation.
+CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=
+
+//Value Computed by CMake.
+CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/pkgRedirects
+
+//Install path prefix, prepended onto install directories.
+CMAKE_INSTALL_PREFIX:PATH=/usr/local
+
+//No help, variable specified on the command line.
+CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/gmake
+
+//Value Computed by CMake
+CMAKE_PROJECT_DESCRIPTION:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_HOMEPAGE_URL:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_NAME:STATIC=fmt-populate
+
+//If set, runtime paths are not added when installing shared libraries,
+// but are added when building.
+CMAKE_SKIP_INSTALL_RPATH:BOOL=NO
+
+//If set, runtime paths are not added when using shared libraries.
+CMAKE_SKIP_RPATH:BOOL=NO
+
+//If this value is on, makefiles will be generated without the
+// .SILENT directive, and all commands will be echoed to the console
+// during the make.  This is useful for debugging only. With Visual
+// Studio IDE projects all commands are done without /nologo.
+CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE
+
+//Value Computed by CMake
+fmt-populate_BINARY_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild
+
+//Value Computed by CMake
+fmt-populate_IS_TOP_LEVEL:STATIC=ON
+
+//Value Computed by CMake
+fmt-populate_SOURCE_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild
+
+
+########################
+# INTERNAL cache entries
+########################
+
+//This is the directory where this CMakeCache.txt was created
+CMAKE_CACHEFILE_DIR:INTERNAL=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild
+//Major version of cmake used to create the current loaded cache
+CMAKE_CACHE_MAJOR_VERSION:INTERNAL=4
+//Minor version of cmake used to create the current loaded cache
+CMAKE_CACHE_MINOR_VERSION:INTERNAL=0
+//Patch version of cmake used to create the current loaded cache
+CMAKE_CACHE_PATCH_VERSION:INTERNAL=3
+//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
+CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
+//Path to CMake executable.
+CMAKE_COMMAND:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+//Path to cpack program executable.
+CMAKE_CPACK_COMMAND:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cpack
+//Path to ctest program executable.
+CMAKE_CTEST_COMMAND:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/ctest
+//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS
+CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1
+//Name of external makefile project generator.
+CMAKE_EXTRA_GENERATOR:INTERNAL=
+//Name of generator.
+CMAKE_GENERATOR:INTERNAL=Unix Makefiles
+//Generator instance identifier.
+CMAKE_GENERATOR_INSTANCE:INTERNAL=
+//Name of generator platform.
+CMAKE_GENERATOR_PLATFORM:INTERNAL=
+//Name of generator toolset.
+CMAKE_GENERATOR_TOOLSET:INTERNAL=
+//Source directory with the top level CMakeLists.txt file for this
+// project
+CMAKE_HOME_DIRECTORY:INTERNAL=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild
+//Install .so files without execute permission.
+CMAKE_INSTALL_SO_NO_EXE:INTERNAL=0
+//Name of CMakeLists files to read
+CMAKE_LIST_FILE_NAME:INTERNAL=CMakeLists.txt
+//number of local generators
+CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1
+//Platform information initialized
+CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1
+//Path to CMake installation.
+CMAKE_ROOT:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0
+//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH
+CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SKIP_RPATH
+CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1
+//uname command
+CMAKE_UNAME:INTERNAL=/usr/bin/uname
+//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE
+CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/4.0.3/CMakeSystem.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/4.0.3/CMakeSystem.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..6ac4680931858770a602d316fb4a5f01540d588e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/4.0.3/CMakeSystem.cmake
@@ -0,0 +1,15 @@
+set(CMAKE_HOST_SYSTEM "Linux-4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_HOST_SYSTEM_NAME "Linux")
+set(CMAKE_HOST_SYSTEM_VERSION "4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
+
+
+
+set(CMAKE_SYSTEM "Linux-4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_SYSTEM_VERSION "4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_SYSTEM_PROCESSOR "x86_64")
+
+set(CMAKE_CROSSCOMPILING "FALSE")
+
+set(CMAKE_SYSTEM_LOADED 1)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/CMakeConfigureLog.yaml b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/CMakeConfigureLog.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..c5d89b2e6dd4fffd370ace469a89217b70d793f1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/CMakeConfigureLog.yaml
@@ -0,0 +1,11 @@
+
+---
+events:
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineSystem.cmake:205 (message)"
+      - "CMakeLists.txt:16 (project)"
+    message: |
+      The system is: Linux - 4.18.0-553.75.1.el8_10.x86_64 - x86_64
+...
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..cf2d629eb960eb78e64224285dd53b5280d4f7f0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/CMakeRuleHashes.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/CMakeRuleHashes.txt
new file mode 100644
index 0000000000000000000000000000000000000000..18f15c9a8f1592cc536152f278eeee19cde71c69
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/CMakeRuleHashes.txt
@@ -0,0 +1,11 @@
+# Hashes of file build rules.
+7bffb502aac01cfbc9487bc3fb35383b CMakeFiles/fmt-populate
+ae82112393028c08da1d7fc7b652fb6a CMakeFiles/fmt-populate-complete
+0bfa8e6aeeac096dd43a729595380f4c fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-build
+882da29c721def9db1d542fb96034734 fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-configure
+18291163d4ede2f8d5e75b639ce482d9 fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-download
+ee1710f0df895278bf192687e819cf50 fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-install
+c145baa20e5a389401fe3cd5015e47b7 fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-mkdir
+b8397f0831469c4ab445805a27a8cd62 fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch
+16d02804bfb23167ef387fe95766e42f fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-test
+6aa7371b4f74a23dc7e2ff0e19dfcdc9 fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/InstallScripts.json b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/InstallScripts.json
new file mode 100644
index 0000000000000000000000000000000000000000..8d39125a294b866c6b58c9f179aa8d45c061a19d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/InstallScripts.json
@@ -0,0 +1,7 @@
+{
+	"InstallScripts" : 
+	[
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/cmake_install.cmake"
+	],
+	"Parallel" : false
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/Makefile.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/Makefile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..be64ae6291cbfde2ea7e347f6214eb5b798345d1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/Makefile.cmake
@@ -0,0 +1,52 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# The generator used is:
+set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles")
+
+# The top level Makefile was generated from the following files:
+set(CMAKE_MAKEFILE_DEPENDS
+  "CMakeCache.txt"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeGenericSystem.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeInitializeConfigs.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeSystemSpecificInformation.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeSystemSpecificInitialize.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/PatchInfo.txt.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/RepositoryInfo.txt.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/UpdateInfo.txt.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/cfgcmd.txt.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/gitclone.cmake.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/gitupdate.cmake.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/mkdirs.cmake.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/shared_internal_commands.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linux-Initialize.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linux.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/UnixPaths.cmake"
+  "CMakeFiles/4.0.3/CMakeSystem.cmake"
+  "CMakeLists.txt"
+  "fmt-populate-prefix/tmp/fmt-populate-mkdirs.cmake"
+  )
+
+# The corresponding makefile is:
+set(CMAKE_MAKEFILE_OUTPUTS
+  "Makefile"
+  "CMakeFiles/cmake.check_cache"
+  )
+
+# Byproducts of CMake generate step:
+set(CMAKE_MAKEFILE_PRODUCTS
+  "fmt-populate-prefix/tmp/fmt-populate-mkdirs.cmake"
+  "fmt-populate-prefix/tmp/fmt-populate-gitclone.cmake"
+  "fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitinfo.txt"
+  "fmt-populate-prefix/tmp/fmt-populate-gitupdate.cmake"
+  "fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update-info.txt"
+  "fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch-info.txt"
+  "fmt-populate-prefix/tmp/fmt-populate-cfgcmd.txt"
+  "CMakeFiles/CMakeDirectoryInformation.cmake"
+  )
+
+# Dependency information for all targets:
+set(CMAKE_DEPEND_INFO_FILES
+  "CMakeFiles/fmt-populate.dir/DependInfo.cmake"
+  )
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/Makefile2 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/Makefile2
new file mode 100644
index 0000000000000000000000000000000000000000..85ddfe2d35f36ef72f54795cea49562e6d00071e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/Makefile2
@@ -0,0 +1,122 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild
+
+#=============================================================================
+# Directory level rules for the build root directory
+
+# The main recursive "all" target.
+all: CMakeFiles/fmt-populate.dir/all
+.PHONY : all
+
+# The main recursive "codegen" target.
+codegen: CMakeFiles/fmt-populate.dir/codegen
+.PHONY : codegen
+
+# The main recursive "preinstall" target.
+preinstall:
+.PHONY : preinstall
+
+# The main recursive "clean" target.
+clean: CMakeFiles/fmt-populate.dir/clean
+.PHONY : clean
+
+#=============================================================================
+# Target rules for target CMakeFiles/fmt-populate.dir
+
+# All Build rule for target.
+CMakeFiles/fmt-populate.dir/all:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/fmt-populate.dir/build.make CMakeFiles/fmt-populate.dir/depend
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/fmt-populate.dir/build.make CMakeFiles/fmt-populate.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9 "Built target fmt-populate"
+.PHONY : CMakeFiles/fmt-populate.dir/all
+
+# Build rule for subdir invocation for target.
+CMakeFiles/fmt-populate.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles 9
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/fmt-populate.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles 0
+.PHONY : CMakeFiles/fmt-populate.dir/rule
+
+# Convenience name for target.
+fmt-populate: CMakeFiles/fmt-populate.dir/rule
+.PHONY : fmt-populate
+
+# codegen rule for target.
+CMakeFiles/fmt-populate.dir/codegen:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/fmt-populate.dir/build.make CMakeFiles/fmt-populate.dir/codegen
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9 "Finished codegen for target fmt-populate"
+.PHONY : CMakeFiles/fmt-populate.dir/codegen
+
+# clean rule for target.
+CMakeFiles/fmt-populate.dir/clean:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/fmt-populate.dir/build.make CMakeFiles/fmt-populate.dir/clean
+.PHONY : CMakeFiles/fmt-populate.dir/clean
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/TargetDirectories.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/TargetDirectories.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8ba4ea2e7939052799918910061c70cb4f27d519
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/TargetDirectories.txt
@@ -0,0 +1,3 @@
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/rebuild_cache.dir
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/cmake.check_cache b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/cmake.check_cache
new file mode 100644
index 0000000000000000000000000000000000000000..3dccd731726d7faa8b29d8d7dba3b981a53ca497
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/cmake.check_cache
@@ -0,0 +1 @@
+# This file is generated by cmake for dependency checking of the CMakeCache.txt file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate-complete b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate-complete
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/DependInfo.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/DependInfo.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..29b95a515e51db792a1019bc6c3419b6d78ec34c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/DependInfo.cmake
@@ -0,0 +1,22 @@
+
+# Consider dependencies only in project.
+set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
+
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  )
+
+# The set of dependency files which are needed:
+set(CMAKE_DEPENDS_DEPENDENCY_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/Labels.json b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/Labels.json
new file mode 100644
index 0000000000000000000000000000000000000000..a4aed64af6e8e1c72164af46cc8b3a2264cafbd7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/Labels.json
@@ -0,0 +1,46 @@
+{
+	"sources" : 
+	[
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate-complete.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-build.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-configure.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-download.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-install.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-mkdir.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-test.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update.rule"
+		}
+	],
+	"target" : 
+	{
+		"labels" : 
+		[
+			"fmt-populate"
+		],
+		"name" : "fmt-populate"
+	}
+}
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/Labels.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/Labels.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7196da00b43d80c9b9888464c39f5a3b2a0f4b21
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/Labels.txt
@@ -0,0 +1,14 @@
+# Target labels
+ fmt-populate
+# Source files and their labels
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate-complete.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-build.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-configure.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-download.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-install.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-mkdir.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-test.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update.rule
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/build.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/build.make
new file mode 100644
index 0000000000000000000000000000000000000000..708875aa6470467e42eac4928cc99bf502d9b174
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/build.make
@@ -0,0 +1,162 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild
+
+# Utility rule file for fmt-populate.
+
+# Include any custom commands dependencies for this target.
+include CMakeFiles/fmt-populate.dir/compiler_depend.make
+
+# Include the progress variables for this target.
+include CMakeFiles/fmt-populate.dir/progress.make
+
+CMakeFiles/fmt-populate: CMakeFiles/fmt-populate-complete
+
+CMakeFiles/fmt-populate-complete: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-install
+CMakeFiles/fmt-populate-complete: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-mkdir
+CMakeFiles/fmt-populate-complete: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-download
+CMakeFiles/fmt-populate-complete: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update
+CMakeFiles/fmt-populate-complete: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch
+CMakeFiles/fmt-populate-complete: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-configure
+CMakeFiles/fmt-populate-complete: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-build
+CMakeFiles/fmt-populate-complete: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-install
+CMakeFiles/fmt-populate-complete: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-test
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Completed 'fmt-populate'"
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E make_directory /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate-complete
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-done
+
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update:
+.PHONY : fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update
+
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-build: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-configure
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "No build step for 'fmt-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-build
+
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-configure: fmt-populate-prefix/tmp/fmt-populate-cfgcmd.txt
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-configure: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "No configure step for 'fmt-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-configure
+
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-download: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitinfo.txt
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-download: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-mkdir
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Performing download step (git clone) for 'fmt-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE -P /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-gitclone.cmake
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-download
+
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-install: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "No install step for 'fmt-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-install
+
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-mkdir:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_6) "Creating directories for 'fmt-populate'"
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -Dcfgdir= -P /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-mkdirs.cmake
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-mkdir
+
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch-info.txt
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_7) "No patch step for 'fmt-populate'"
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch
+
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update:
+.PHONY : fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update
+
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-test: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-install
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_8) "No test step for 'fmt-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-test
+
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update: fmt-populate-prefix/tmp/fmt-populate-gitupdate.cmake
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update-info.txt
+fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-download
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_9) "Performing update step for 'fmt-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -Dcan_fetch=YES -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE -P /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-gitupdate.cmake
+
+CMakeFiles/fmt-populate.dir/codegen:
+.PHONY : CMakeFiles/fmt-populate.dir/codegen
+
+fmt-populate: CMakeFiles/fmt-populate
+fmt-populate: CMakeFiles/fmt-populate-complete
+fmt-populate: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-build
+fmt-populate: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-configure
+fmt-populate: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-download
+fmt-populate: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-install
+fmt-populate: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-mkdir
+fmt-populate: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch
+fmt-populate: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-test
+fmt-populate: fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update
+fmt-populate: CMakeFiles/fmt-populate.dir/build.make
+.PHONY : fmt-populate
+
+# Rule to build all files generated by this target.
+CMakeFiles/fmt-populate.dir/build: fmt-populate
+.PHONY : CMakeFiles/fmt-populate.dir/build
+
+CMakeFiles/fmt-populate.dir/clean:
+	$(CMAKE_COMMAND) -P CMakeFiles/fmt-populate.dir/cmake_clean.cmake
+.PHONY : CMakeFiles/fmt-populate.dir/clean
+
+CMakeFiles/fmt-populate.dir/depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/DependInfo.cmake "--color=$(COLOR)"
+.PHONY : CMakeFiles/fmt-populate.dir/depend
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/cmake_clean.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/cmake_clean.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..4869102f4e7284230ba143cc845b138c9ac920ec
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/cmake_clean.cmake
@@ -0,0 +1,17 @@
+file(REMOVE_RECURSE
+  "CMakeFiles/fmt-populate"
+  "CMakeFiles/fmt-populate-complete"
+  "fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-build"
+  "fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-configure"
+  "fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-download"
+  "fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-install"
+  "fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-mkdir"
+  "fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch"
+  "fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-test"
+  "fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang )
+  include(CMakeFiles/fmt-populate.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/compiler_depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/compiler_depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..f984cb3bf805de9c7dc0c525d88e8613566d2510
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/compiler_depend.make
@@ -0,0 +1,2 @@
+# Empty custom commands generated dependencies file for fmt-populate.
+# This may be replaced when dependencies are built.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/compiler_depend.ts b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/compiler_depend.ts
new file mode 100644
index 0000000000000000000000000000000000000000..13e69351c2e48a0aaead82721968641beb5ebb34
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/compiler_depend.ts
@@ -0,0 +1,2 @@
+# CMAKE generated file: DO NOT EDIT!
+# Timestamp file for custom commands dependencies management for fmt-populate.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/progress.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/progress.make
new file mode 100644
index 0000000000000000000000000000000000000000..d4f6ce35d26a4136a4edb4873325a1cadb14ccfe
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/fmt-populate.dir/progress.make
@@ -0,0 +1,10 @@
+CMAKE_PROGRESS_1 = 1
+CMAKE_PROGRESS_2 = 2
+CMAKE_PROGRESS_3 = 3
+CMAKE_PROGRESS_4 = 4
+CMAKE_PROGRESS_5 = 5
+CMAKE_PROGRESS_6 = 6
+CMAKE_PROGRESS_7 = 7
+CMAKE_PROGRESS_8 = 8
+CMAKE_PROGRESS_9 = 9
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..ec635144f60048986bc560c5576355344005e6e7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+9
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..22c4e310d48f69944006e2806cebf4a2a0fb3557
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeLists.txt
@@ -0,0 +1,42 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION 4.0.3)
+
+# Reject any attempt to use a toolchain file. We must not use one because
+# we could be downloading it here. If the CMAKE_TOOLCHAIN_FILE environment
+# variable is set, the cache variable will have been initialized from it.
+unset(CMAKE_TOOLCHAIN_FILE CACHE)
+unset(ENV{CMAKE_TOOLCHAIN_FILE})
+
+# We name the project and the target for the ExternalProject_Add() call
+# to something that will highlight to the user what we are working on if
+# something goes wrong and an error message is produced.
+
+project(fmt-populate NONE)
+
+
+# Pass through things we've already detected in the main project to avoid
+# paying the cost of redetecting them again in ExternalProject_Add()
+set(GIT_EXECUTABLE [==[/usr/bin/git]==])
+set(GIT_VERSION_STRING [==[2.51.0]==])
+set_property(GLOBAL PROPERTY _CMAKE_FindGit_GIT_EXECUTABLE_VERSION
+  [==[/usr/bin/git;2.51.0]==]
+)
+
+
+include(ExternalProject)
+ExternalProject_Add(fmt-populate
+                     "UPDATE_DISCONNECTED" "False" "GIT_REPOSITORY" "https://github.com/fmtlib/fmt.git" "EXTERNALPROJECT_INTERNAL_ARGUMENT_SEPARATOR" "GIT_TAG" "10.2.1"
+                    SOURCE_DIR          "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+                    BINARY_DIR          "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build"
+                    CONFIGURE_COMMAND   ""
+                    BUILD_COMMAND       ""
+                    INSTALL_COMMAND     ""
+                    TEST_COMMAND        ""
+                    USES_TERMINAL_DOWNLOAD  YES
+                    USES_TERMINAL_UPDATE    YES
+                    USES_TERMINAL_PATCH     YES
+)
+
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..57582d11975fc9c5aee340a370b9318c948e9ecc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/Makefile
@@ -0,0 +1,162 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# The main all target
+all: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild//CMakeFiles/progress.marks
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles 0
+.PHONY : all
+
+# The main codegen target
+codegen: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild//CMakeFiles/progress.marks
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 codegen
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/CMakeFiles 0
+.PHONY : codegen
+
+# The main clean target
+clean:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+#=============================================================================
+# Target rules for targets named fmt-populate
+
+# Build rule for target.
+fmt-populate: cmake_check_build_system
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 fmt-populate
+.PHONY : fmt-populate
+
+# fast build rule for target.
+fmt-populate/fast:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/fmt-populate.dir/build.make CMakeFiles/fmt-populate.dir/build
+.PHONY : fmt-populate/fast
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... codegen"
+	@echo "... edit_cache"
+	@echo "... rebuild_cache"
+	@echo "... fmt-populate"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..39a4fd0426beeca80c28be3e47a154685c9e90cc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/cmake_install.cmake
@@ -0,0 +1,61 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/usr/local")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
+if(CMAKE_INSTALL_COMPONENT)
+  if(CMAKE_INSTALL_COMPONENT MATCHES "^[a-zA-Z0-9_.+-]+$")
+    set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt")
+  else()
+    string(MD5 CMAKE_INST_COMP_HASH "${CMAKE_INSTALL_COMPONENT}")
+    set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INST_COMP_HASH}.txt")
+    unset(CMAKE_INST_COMP_HASH)
+  endif()
+else()
+  set(CMAKE_INSTALL_MANIFEST "install_manifest.txt")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/${CMAKE_INSTALL_MANIFEST}"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-build b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-build
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-configure b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-configure
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-done b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-done
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-download b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-download
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitclone-lastrun.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitclone-lastrun.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1e450d8467138b9b2538d4d826fe400598752ad0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitclone-lastrun.txt
@@ -0,0 +1,15 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The download step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+method=git
+command=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake;-DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE;-P;/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-gitclone.cmake
+source_dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src
+work_dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps
+repository=https://github.com/fmtlib/fmt.git
+remote=origin
+init_submodules=TRUE
+recurse_submodules=--recursive
+submodules=
+CMP0097=NEW
+      
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitinfo.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitinfo.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1e450d8467138b9b2538d4d826fe400598752ad0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitinfo.txt
@@ -0,0 +1,15 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The download step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+method=git
+command=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake;-DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE;-P;/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-gitclone.cmake
+source_dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src
+work_dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps
+repository=https://github.com/fmtlib/fmt.git
+remote=origin
+init_submodules=TRUE
+recurse_submodules=--recursive
+submodules=
+CMP0097=NEW
+      
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-install b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-install
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-mkdir b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-mkdir
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch-info.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch-info.txt
new file mode 100644
index 0000000000000000000000000000000000000000..53e1e1e6854ba141183d4dc9c77325b48e4b99da
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-patch-info.txt
@@ -0,0 +1,6 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The update step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+command=
+work_dir=
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-test b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-test
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update-info.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update-info.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b15130beb08bf62705b9a7616ebfd4fa6f60f6df
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-update-info.txt
@@ -0,0 +1,7 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The patch step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+command (connected)=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake;-Dcan_fetch=YES;-DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE;-P;/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-gitupdate.cmake
+command (disconnected)=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake;-Dcan_fetch=NO;-DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE;-P;/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-gitupdate.cmake
+work_dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-cfgcmd.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-cfgcmd.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6a6ed5fd2a2f3671b44653100d811d1afbc218c1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-cfgcmd.txt
@@ -0,0 +1 @@
+cmd=''
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-gitclone.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-gitclone.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..51f0cdac9f0a53b481515b09b911b3870585c9b8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-gitclone.cmake
@@ -0,0 +1,87 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+if(EXISTS "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitclone-lastrun.txt" AND EXISTS "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitinfo.txt" AND
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitclone-lastrun.txt" IS_NEWER_THAN "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitinfo.txt")
+  message(VERBOSE
+    "Avoiding repeated git clone, stamp file is up to date: "
+    "'/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitclone-lastrun.txt'"
+  )
+  return()
+endif()
+
+# Even at VERBOSE level, we don't want to see the commands executed, but
+# enabling them to be shown for DEBUG may be useful to help diagnose problems.
+cmake_language(GET_MESSAGE_LOG_LEVEL active_log_level)
+if(active_log_level MATCHES "DEBUG|TRACE")
+  set(maybe_show_command COMMAND_ECHO STDOUT)
+else()
+  set(maybe_show_command "")
+endif()
+
+execute_process(
+  COMMAND ${CMAKE_COMMAND} -E rm -rf "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+  RESULT_VARIABLE error_code
+  ${maybe_show_command}
+)
+if(error_code)
+  message(FATAL_ERROR "Failed to remove directory: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src'")
+endif()
+
+# try the clone 3 times in case there is an odd git clone issue
+set(error_code 1)
+set(number_of_tries 0)
+while(error_code AND number_of_tries LESS 3)
+  execute_process(
+    COMMAND "/usr/bin/git"
+            clone --no-checkout --config "advice.detachedHead=false" "https://github.com/fmtlib/fmt.git" "fmt-src"
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps"
+    RESULT_VARIABLE error_code
+    ${maybe_show_command}
+  )
+  math(EXPR number_of_tries "${number_of_tries} + 1")
+endwhile()
+if(number_of_tries GREATER 1)
+  message(NOTICE "Had to git clone more than once: ${number_of_tries} times.")
+endif()
+if(error_code)
+  message(FATAL_ERROR "Failed to clone repository: 'https://github.com/fmtlib/fmt.git'")
+endif()
+
+execute_process(
+  COMMAND "/usr/bin/git"
+          checkout "10.2.1" --
+  WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+  RESULT_VARIABLE error_code
+  ${maybe_show_command}
+)
+if(error_code)
+  message(FATAL_ERROR "Failed to checkout tag: '10.2.1'")
+endif()
+
+set(init_submodules TRUE)
+if(init_submodules)
+  execute_process(
+    COMMAND "/usr/bin/git" 
+            submodule update --recursive --init 
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+    RESULT_VARIABLE error_code
+    ${maybe_show_command}
+  )
+endif()
+if(error_code)
+  message(FATAL_ERROR "Failed to update submodules in: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src'")
+endif()
+
+# Complete success, update the script-last-run stamp file:
+#
+execute_process(
+  COMMAND ${CMAKE_COMMAND} -E copy "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitinfo.txt" "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitclone-lastrun.txt"
+  RESULT_VARIABLE error_code
+  ${maybe_show_command}
+)
+if(error_code)
+  message(FATAL_ERROR "Failed to copy script-last-run stamp file: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/fmt-populate-gitclone-lastrun.txt'")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-gitupdate.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-gitupdate.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ed630ea91385d296b052988397bb8076f491d288
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-gitupdate.cmake
@@ -0,0 +1,317 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+# Even at VERBOSE level, we don't want to see the commands executed, but
+# enabling them to be shown for DEBUG may be useful to help diagnose problems.
+cmake_language(GET_MESSAGE_LOG_LEVEL active_log_level)
+if(active_log_level MATCHES "DEBUG|TRACE")
+  set(maybe_show_command COMMAND_ECHO STDOUT)
+else()
+  set(maybe_show_command "")
+endif()
+
+function(do_fetch)
+  message(VERBOSE "Fetching latest from the remote origin")
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git fetch --tags --force "origin"
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+    COMMAND_ERROR_IS_FATAL LAST
+    ${maybe_show_command}
+  )
+endfunction()
+
+function(get_hash_for_ref ref out_var err_var)
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git rev-parse "${ref}^0"
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+    RESULT_VARIABLE error_code
+    OUTPUT_VARIABLE ref_hash
+    ERROR_VARIABLE error_msg
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  if(error_code)
+    set(${out_var} "" PARENT_SCOPE)
+  else()
+    set(${out_var} "${ref_hash}" PARENT_SCOPE)
+  endif()
+  set(${err_var} "${error_msg}" PARENT_SCOPE)
+endfunction()
+
+get_hash_for_ref(HEAD head_sha error_msg)
+if(head_sha STREQUAL "")
+  message(FATAL_ERROR "Failed to get the hash for HEAD:\n${error_msg}")
+endif()
+
+if("${can_fetch}" STREQUAL "")
+  set(can_fetch "YES")
+endif()
+
+execute_process(
+  COMMAND "/usr/bin/git" --git-dir=.git show-ref "10.2.1"
+  WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+  OUTPUT_VARIABLE show_ref_output
+)
+if(show_ref_output MATCHES "^[a-z0-9]+[ \\t]+refs/remotes/")
+  # Given a full remote/branch-name and we know about it already. Since
+  # branches can move around, we should always fetch, if permitted.
+  if(can_fetch)
+    do_fetch()
+  endif()
+  set(checkout_name "10.2.1")
+
+elseif(show_ref_output MATCHES "^[a-z0-9]+[ \\t]+refs/tags/")
+  # Given a tag name that we already know about. We don't know if the tag we
+  # have matches the remote though (tags can move), so we should fetch. As a
+  # special case to preserve backward compatibility, if we are already at the
+  # same commit as the tag we hold locally, don't do a fetch and assume the tag
+  # hasn't moved on the remote.
+  # FIXME: We should provide an option to always fetch for this case
+  get_hash_for_ref("10.2.1" tag_sha error_msg)
+  if(tag_sha STREQUAL head_sha)
+    message(VERBOSE "Already at requested tag: 10.2.1")
+    return()
+  endif()
+
+  if(can_fetch)
+    do_fetch()
+  endif()
+  set(checkout_name "10.2.1")
+
+elseif(show_ref_output MATCHES "^[a-z0-9]+[ \\t]+refs/heads/")
+  # Given a branch name without any remote and we already have a branch by that
+  # name. We might already have that branch checked out or it might be a
+  # different branch. It isn't fully safe to use a bare branch name without the
+  # remote, so do a fetch (if allowed) and replace the ref with one that
+  # includes the remote.
+  if(can_fetch)
+    do_fetch()
+  endif()
+  set(checkout_name "origin/10.2.1")
+
+else()
+  get_hash_for_ref("10.2.1" tag_sha error_msg)
+  if(tag_sha STREQUAL head_sha)
+    # Have the right commit checked out already
+    message(VERBOSE "Already at requested ref: ${tag_sha}")
+    return()
+
+  elseif(tag_sha STREQUAL "")
+    # We don't know about this ref yet, so we have no choice but to fetch.
+    if(NOT can_fetch)
+      message(FATAL_ERROR
+        "Requested git ref \"10.2.1\" is not present locally, and not "
+        "allowed to contact remote due to UPDATE_DISCONNECTED setting."
+      )
+    endif()
+
+    # We deliberately swallow any error message at the default log level
+    # because it can be confusing for users to see a failed git command.
+    # That failure is being handled here, so it isn't an error.
+    if(NOT error_msg STREQUAL "")
+      message(DEBUG "${error_msg}")
+    endif()
+    do_fetch()
+    set(checkout_name "10.2.1")
+
+  else()
+    # We have the commit, so we know we were asked to find a commit hash
+    # (otherwise it would have been handled further above), but we don't
+    # have that commit checked out yet. We don't need to fetch from the remote.
+    set(checkout_name "10.2.1")
+    if(NOT error_msg STREQUAL "")
+      message(WARNING "${error_msg}")
+    endif()
+
+  endif()
+endif()
+
+set(git_update_strategy "REBASE")
+if(git_update_strategy STREQUAL "")
+  # Backward compatibility requires REBASE as the default behavior
+  set(git_update_strategy REBASE)
+endif()
+
+if(git_update_strategy MATCHES "^REBASE(_CHECKOUT)?$")
+  # Asked to potentially try to rebase first, maybe with fallback to checkout.
+  # We can't if we aren't already on a branch and we shouldn't if that local
+  # branch isn't tracking the one we want to checkout.
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git symbolic-ref -q HEAD
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+    OUTPUT_VARIABLE current_branch
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    # Don't test for an error. If this isn't a branch, we get a non-zero error
+    # code but empty output.
+  )
+
+  if(current_branch STREQUAL "")
+    # Not on a branch, checkout is the only sensible option since any rebase
+    # would always fail (and backward compatibility requires us to checkout in
+    # this situation)
+    set(git_update_strategy CHECKOUT)
+
+  else()
+    execute_process(
+      COMMAND "/usr/bin/git" --git-dir=.git for-each-ref "--format=%(upstream:short)" "${current_branch}"
+      WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+      OUTPUT_VARIABLE upstream_branch
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      COMMAND_ERROR_IS_FATAL ANY  # There is no error if no upstream is set
+    )
+    if(NOT upstream_branch STREQUAL checkout_name)
+      # Not safe to rebase when asked to checkout a different branch to the one
+      # we are tracking. If we did rebase, we could end up with arbitrary
+      # commits added to the ref we were asked to checkout if the current local
+      # branch happens to be able to rebase onto the target branch. There would
+      # be no error message and the user wouldn't know this was occurring.
+      set(git_update_strategy CHECKOUT)
+    endif()
+
+  endif()
+elseif(NOT git_update_strategy STREQUAL "CHECKOUT")
+  message(FATAL_ERROR "Unsupported git update strategy: ${git_update_strategy}")
+endif()
+
+
+# Check if stash is needed
+execute_process(
+  COMMAND "/usr/bin/git" --git-dir=.git status --porcelain
+  WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+  RESULT_VARIABLE error_code
+  OUTPUT_VARIABLE repo_status
+)
+if(error_code)
+  message(FATAL_ERROR "Failed to get the status")
+endif()
+string(LENGTH "${repo_status}" need_stash)
+
+# If not in clean state, stash changes in order to be able to perform a
+# rebase or checkout without losing those changes permanently
+if(need_stash)
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git stash save --quiet;--include-untracked
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+    COMMAND_ERROR_IS_FATAL ANY
+    ${maybe_show_command}
+  )
+endif()
+
+if(git_update_strategy STREQUAL "CHECKOUT")
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git checkout "${checkout_name}"
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+    COMMAND_ERROR_IS_FATAL ANY
+    ${maybe_show_command}
+  )
+else()
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git rebase "${checkout_name}"
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+    RESULT_VARIABLE error_code
+    OUTPUT_VARIABLE rebase_output
+    ERROR_VARIABLE  rebase_output
+  )
+  if(error_code)
+    # Rebase failed, undo the rebase attempt before continuing
+    execute_process(
+      COMMAND "/usr/bin/git" --git-dir=.git rebase --abort
+      WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+      ${maybe_show_command}
+    )
+
+    if(NOT git_update_strategy STREQUAL "REBASE_CHECKOUT")
+      # Not allowed to do a checkout as a fallback, so cannot proceed
+      if(need_stash)
+        execute_process(
+          COMMAND "/usr/bin/git" --git-dir=.git stash pop --index --quiet
+          WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+          ${maybe_show_command}
+          )
+      endif()
+      message(FATAL_ERROR "\nFailed to rebase in: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src'."
+                          "\nOutput from the attempted rebase follows:"
+                          "\n${rebase_output}"
+                          "\n\nYou will have to resolve the conflicts manually")
+    endif()
+
+    # Fall back to checkout. We create an annotated tag so that the user
+    # can manually inspect the situation and revert if required.
+    # We can't log the failed rebase output because MSVC sees it and
+    # intervenes, causing the build to fail even though it completes.
+    # Write it to a file instead.
+    string(TIMESTAMP tag_timestamp "%Y%m%dT%H%M%S" UTC)
+    set(tag_name _cmake_ExternalProject_moved_from_here_${tag_timestamp}Z)
+    set(error_log_file ${CMAKE_CURRENT_LIST_DIR}/rebase_error_${tag_timestamp}Z.log)
+    file(WRITE ${error_log_file} "${rebase_output}")
+    message(WARNING "Rebase failed, output has been saved to ${error_log_file}"
+                    "\nFalling back to checkout, previous commit tagged as ${tag_name}")
+    execute_process(
+      COMMAND "/usr/bin/git" --git-dir=.git tag -a
+              -m "ExternalProject attempting to move from here to ${checkout_name}"
+              ${tag_name}
+      WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+      COMMAND_ERROR_IS_FATAL ANY
+      ${maybe_show_command}
+    )
+
+    execute_process(
+      COMMAND "/usr/bin/git" --git-dir=.git checkout "${checkout_name}"
+      WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+      COMMAND_ERROR_IS_FATAL ANY
+      ${maybe_show_command}
+    )
+  endif()
+endif()
+
+if(need_stash)
+  # Put back the stashed changes
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git stash pop --index --quiet
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+    RESULT_VARIABLE error_code
+    ${maybe_show_command}
+    )
+  if(error_code)
+    # Stash pop --index failed: Try again dropping the index
+    execute_process(
+      COMMAND "/usr/bin/git" --git-dir=.git reset --hard --quiet
+      WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+      ${maybe_show_command}
+    )
+    execute_process(
+      COMMAND "/usr/bin/git" --git-dir=.git stash pop --quiet
+      WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+      RESULT_VARIABLE error_code
+      ${maybe_show_command}
+    )
+    if(error_code)
+      # Stash pop failed: Restore previous state.
+      execute_process(
+        COMMAND "/usr/bin/git" --git-dir=.git reset --hard --quiet ${head_sha}
+        WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+        ${maybe_show_command}
+      )
+      execute_process(
+        COMMAND "/usr/bin/git" --git-dir=.git stash pop --index --quiet
+        WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+        ${maybe_show_command}
+      )
+      message(FATAL_ERROR "\nFailed to unstash changes in: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src'."
+                          "\nYou will have to resolve the conflicts manually")
+    endif()
+  endif()
+endif()
+
+set(init_submodules "TRUE")
+if(init_submodules)
+  execute_process(
+    COMMAND "/usr/bin/git"
+            --git-dir=.git 
+            submodule update --recursive --init 
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src"
+    COMMAND_ERROR_IS_FATAL ANY
+    ${maybe_show_command}
+  )
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-mkdirs.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-mkdirs.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..f56fd28d0d9db5e00b330c1a312fd199bf7ce29f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp/fmt-populate-mkdirs.cmake
@@ -0,0 +1,27 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+# If CMAKE_DISABLE_SOURCE_CHANGES is set to true and the source directory is an
+# existing directory in our source tree, calling file(MAKE_DIRECTORY) on it
+# would cause a fatal error, even though it would be a no-op.
+if(NOT EXISTS "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src")
+  file(MAKE_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src")
+endif()
+file(MAKE_DIRECTORY
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/tmp"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp"
+)
+
+set(configSubDirs )
+foreach(subDir IN LISTS configSubDirs)
+    file(MAKE_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp/${subDir}")
+endforeach()
+if(cfgdir)
+  file(MAKE_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-subbuild/fmt-populate-prefix/src/fmt-populate-stamp${cfgdir}") # cfgdir has leading slash
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/.gitignore b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..8eb55dd3170d75c9ecff26c51db0f78ae69119bf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/.gitignore
@@ -0,0 +1 @@
+gguf-tools
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/LICENSE b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..fb7ff0ce4a7626a4e76edffcb7b20fbc59ba9b19
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Georgi Gerganov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..b1f9127b6e7dea54df73545c225232f80d387646
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/Makefile
@@ -0,0 +1,9 @@
+all: gguf-tools
+
+gguf-tools: gguf-tools.c gguflib.c gguflib.h sds.c sds.h sdsalloc.h fp16.h bf16.h
+	$(CC) gguf-tools.c gguflib.c sds.c fp16.c \
+		-march=native -ffast-math \
+		-g -ggdb -Wall -W -pedantic -O3 -o gguf-tools
+
+clean:
+	rm -rf gguf-tools
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/README.md b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4fbd71fd9a6867cfa82f888f4c9aa18eb97c8503
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/README.md
@@ -0,0 +1,99 @@
+# GGUF tools
+
+This is a work in progress library to manipulate GGUF files.
+While the library aims to be useful, one of the main goals is to provide
+an accessible code base that as a side effect documents the GGUF
+files used by the awesome [llama.cpp](https://github.com/ggerganov/llama.cpp) project: GGUF files are becoming increasingly more used and central in
+the _local_ machine learning scene, so to have multiple implementations
+of parsers and files generators may be useful.
+
+The program **gguf-tools** uses the library to implement both useful and
+useless stuff, to show the library usage in the real world. For now
+the utility implements the following subcommands:
+
+### gguf-tools show file.gguf
+
+shows detailed info about the GGUF file. This will include all the key-value pairs, including arrays, and detailed tensors informations. Tensor offsets will be relative to the start *of the file* (so they are actually absolute offsets), not the start of the data section like in the GGUF format.
+
+Example output:
+
+```
+./gguf-tools show models/phi-2.Q8_0.gguf | head -20        :main*: ??
+models/phi-2.Q8_0.gguf (ver 3): 20 key-value pairs, 325 tensors
+general.architecture: [string] phi2
+general.name: [string] Phi2
+phi2.context_length: [uint32] 2048
+phi2.embedding_length: [uint32] 2560
+phi2.feed_forward_length: [uint32] 10240
+phi2.block_count: [uint32] 32
+phi2.attention.head_count: [uint32] 32
+phi2.attention.head_count_kv: [uint32] 32
+phi2.attention.layer_norm_epsilon: [float32] 0.000010
+phi2.rope.dimension_count: [uint32] 32
+general.file_type: [uint32] 7
+tokenizer.ggml.add_bos_token: [bool] false
+tokenizer.ggml.model: [string] gpt2
+tokenizer.ggml.tokens: [array] [!, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, :, ;, <, =, >, ... 51170 more items of 51200]
+
+... many more key-value pairs ...
+
+q8_0 tensor token_embd.weight @1806176, 131072000 weights, dims [2560,51200], 139264000 bytes
+f32 tensor blk.0.attn_norm.bias @141070176, 2560 weights, dims [2560], 10240 bytes
+f32 tensor blk.0.attn_norm.weight @141080416, 2560 weights, dims [2560], 10240 bytes
+f32 tensor blk.0.attn_qkv.bias @141090656, 7680 weights, dims [7680], 30720 bytes
+q8_0 tensor blk.0.attn_qkv.weight @141121376, 19660800 weights, dims [2560,7680], 20889600 bytes
+f32 tensor blk.0.attn_output.bias @162010976, 2560 weights, dims [2560], 10240 bytes
+q8_0 tensor blk.0.attn_output.weight @162021216, 6553600 weights, dims [2560,2560], 6963200 bytes
+f32 tensor blk.0.ffn_up.bias @168984416, 10240 weights, dims [10240], 40960 bytes
+
+... many more tensors ...
+```
+
+### gguf-tools compare file1.gguf file2.gguf
+
+This tool is useful to understand if two LLMs (or other models distributed as GGUF files) are related, for instance if one is the finetune of another, or if both are fine-tuned from the same parent model.
+
+For each matching tensor (same name and parameters count), the command computes the average weights difference (in percentage, so that a random distribution in the interval -N, +N would be on average 100% different than another random distribution in the same interval). This is useful to see if a model is a finetune of another model, how much it was finetuned, which layers were frozen while finetuning and so forth. Note that because of quantization, even tensors that are functionally equivalent may have some small average difference.
+
+Example output:
+
+```
+./gguf-tools compare mistral-7b-instruct-v0.2.Q8_0.gguf \
+                     solar-10.7b-instruct-v1.0-uncensored.Q8_0.gguf
+[token_embd.weight]: avg weights difference: 44.539944%
+[blk.0.attn_q.weight]: avg weights difference: 48.717736%
+[blk.0.attn_k.weight]: avg weights difference: 56.201885%
+[blk.0.attn_v.weight]: avg weights difference: 47.087249%
+[blk.0.attn_output.weight]: avg weights difference: 47.663048%
+[blk.0.ffn_gate.weight]: avg weights difference: 37.508761%
+[blk.0.ffn_up.weight]: avg weights difference: 39.061584%
+[blk.0.ffn_down.weight]: avg weights difference: 39.632648%
+...
+```
+
+### gguf-tools inspect-tensor file.gguf tensor.name [count]
+
+Show all (if count is not specified, otherwise only the first _count_) weights values of the specified tensor. This is useful for low level stuff, like checking if quantization is working as expected, see the introduced error, model fingerprinting and so forth.
+
+### gguf-tools split-mixtral 65230776370407150546470161412165 mixtral.gguf out.gguf
+
+Extracts a 7B model `out.gguf` from Mixtral 7B MoE using the specified MoE ID for each layer (there are 32 digits in the sequence 652...).
+
+Note that split-mixtral is quite useless as models obtained in this way will not perform any useful work. This is just an experiment and a non trivial task to show how to use the library. Likely it will be removed soon, once I have more interesting and useful examples to show, like models merging.
+
+## gufflib API
+
+For now the only documentation is the implementation itself: see the
+gguf-tools.c for usage information. This may change later, but for now
+the library is under active development.
+
+The code is well commented, and the API so far is extremely simple to understand and use.
+
+## Limitations
+
+Many quantization formats are missing.
+
+## Specification documents
+
+* [Official GGUF specification](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md), where the file layout and meta-data is described.
+* [Quantization formats](https://github.com/ggerganov/ggml/blob/master/src/ggml-quants.h) used in quantized GGUF models.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/bf16.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/bf16.h
new file mode 100644
index 0000000000000000000000000000000000000000..3c160f40f4b96113b35e36357d83436cf8b936f0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/bf16.h
@@ -0,0 +1,70 @@
+#ifndef BF16_h
+#define BF16_h
+#include <stdint.h>
+
+/**
+ * Converts brain16 to float32.
+ *
+ * The bfloat16 floating point format has the following structure:
+ *
+ *       ┌sign
+ *       │
+ *       │   ┌exponent
+ *       │   │
+ *       │   │      ┌mantissa
+ *       │   │      │
+ *       │┌──┴───┐┌─┴───┐
+ *     0b0000000000000000 brain16
+ *
+ * Since bf16 has the same number of exponent bits as a 32bit float,
+ * encoding and decoding numbers becomes relatively straightforward.
+ *
+ *       ┌sign
+ *       │
+ *       │   ┌exponent
+ *       │   │
+ *       │   │      ┌mantissa
+ *       │   │      │
+ *       │┌──┴───┐┌─┴───────────────────┐
+ *     0b00000000000000000000000000000000 IEEE binary32
+ *
+ * For comparison, the standard fp16 format has fewer exponent bits.
+ *
+ *       ┌sign
+ *       │
+ *       │  ┌exponent
+ *       │  │
+ *       │  │    ┌mantissa
+ *       │  │    │
+ *       │┌─┴─┐┌─┴──────┐
+ *     0b0000000000000000 IEEE binary16
+ *
+ * @see IEEE 754-2008
+ */
+static inline float from_brain(uint16_t h) {
+    union {
+        float f;
+        uint32_t i;
+    } u;
+    u.i = (uint32_t)h << 16;
+    return u.f;
+}
+
+/**
+ * Converts float32 to brain16.
+ */
+static inline uint16_t to_brain(float s) {
+    uint16_t h;
+    union {
+        float f;
+        uint32_t i;
+    } u;
+    u.f = s;
+    if ((u.i & 0x7fffffff) > 0x7f800000) { /* nan */
+        h = (u.i >> 16) | 64; /* force to quiet */
+        return h;
+    }
+    return (u.i + (0x7fff + ((u.i >> 16) & 1))) >> 16;
+}
+
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.c b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.c
new file mode 100644
index 0000000000000000000000000000000000000000..fa90605ea8cfc2187d3bff44e245293277533299
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.c
@@ -0,0 +1,90 @@
+/* Conversion from floats to FP16 and the other way around.
+ * This is useful as in GGUF files we have both FP16 tensors
+ * and quantized blocks where half-precisions floats are used
+ * to store the scaling factor (delta) and other parameters.
+ *
+ * This code comes originally from:
+ * https://github.com/Maratyszcza/FP16/blob/master/include/fp16/fp16.h
+ *
+ * The original code is MIT licensed. */
+
+#include <stdint.h>
+#include <math.h>
+
+static inline float fp32_from_bits(uint32_t w) {
+    union {
+        uint32_t as_bits;
+        float as_value;
+    } fp32;
+    fp32.as_bits = w;
+    return fp32.as_value;
+}
+
+static inline uint32_t fp32_to_bits(float f) {
+    union {
+        float as_value;
+        uint32_t as_bits;
+    } fp32;
+    fp32.as_value = f;
+    return fp32.as_bits;
+}
+
+float from_half(uint16_t h) {
+    const uint32_t w = (uint32_t) h << 16;
+    const uint32_t sign = w & UINT32_C(0x80000000);
+    const uint32_t two_w = w + w;
+
+    const uint32_t exp_offset = UINT32_C(0xE0) << 23;
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) || defined(__GNUC__) && !defined(__STRICT_ANSI__)
+    const float exp_scale = 0x1.0p-112f;
+#else
+    const float exp_scale = fp32_from_bits(UINT32_C(0x7800000));
+#endif
+    const float normalized_value = fp32_from_bits((two_w >> 4) + exp_offset) * exp_scale;
+
+    const uint32_t magic_mask = UINT32_C(126) << 23;
+    const float magic_bias = 0.5f;
+    const float denormalized_value = fp32_from_bits((two_w >> 17) | magic_mask) - magic_bias;
+
+    const uint32_t denormalized_cutoff = UINT32_C(1) << 27;
+    const uint32_t result = sign |
+        (two_w < denormalized_cutoff ? fp32_to_bits(denormalized_value) : fp32_to_bits(normalized_value));
+    return fp32_from_bits(result);
+}
+
+uint16_t to_half(float f) {
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) || defined(__GNUC__) && !defined(__STRICT_ANSI__)
+    const float scale_to_inf = 0x1.0p+112f;
+    const float scale_to_zero = 0x1.0p-110f;
+#else
+    const float scale_to_inf = fp32_from_bits(UINT32_C(0x77800000));
+    const float scale_to_zero = fp32_from_bits(UINT32_C(0x08800000));
+#endif
+    float base = (fabsf(f) * scale_to_inf) * scale_to_zero;
+
+    const uint32_t w = fp32_to_bits(f);
+    const uint32_t shl1_w = w + w;
+    const uint32_t sign = w & UINT32_C(0x80000000);
+    uint32_t bias = shl1_w & UINT32_C(0xFF000000);
+    if (bias < UINT32_C(0x71000000)) {
+        bias = UINT32_C(0x71000000);
+    }
+
+    base = fp32_from_bits((bias >> 1) + UINT32_C(0x07800000)) + base;
+    const uint32_t bits = fp32_to_bits(base);
+    const uint32_t exp_bits = (bits >> 13) & UINT32_C(0x00007C00);
+    const uint32_t mantissa_bits = bits & UINT32_C(0x00000FFF);
+    const uint32_t nonsign = exp_bits + mantissa_bits;
+    return (sign >> 16) | (shl1_w > UINT32_C(0xFF000000) ? UINT16_C(0x7E00) : nonsign);
+}
+
+#ifdef TEST_MAIN
+#include <stdio.h>
+int main(void) {
+    float f = 1.2345;
+    uint16_t half = to_half(f);
+    float f2 = from_half(half);
+    printf("%f %f\n", f, f2);
+    return 0;
+}
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.h
new file mode 100644
index 0000000000000000000000000000000000000000..10d2d82f8b2068977583d5772279effcb5437825
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.h
@@ -0,0 +1,7 @@
+/* See fp16.c. */
+
+#ifndef FP16_h
+#define FP16_h
+float from_half(uint16_t h);
+uint16_t to_half(float f);
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguf-tools.c b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguf-tools.c
new file mode 100644
index 0000000000000000000000000000000000000000..ce54d0fbd9fa9d8220fabe354b6518de645b9980
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguf-tools.c
@@ -0,0 +1,578 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <assert.h>
+#include <errno.h>
+#include <math.h>
+#include <inttypes.h>
+
+#include "gguflib.h"
+#include "sds.h"
+#include "fp16.h"
+
+/* Global options that can could be used for all the subcommands. */
+struct {
+    int verbose;        // --verbose option
+    int diffable;       // --diffable option
+} Opt = {0};
+
+/* ========================== Utility functions  ============================ */
+
+/* Glob-style pattern matching. Return 1 on match, 0 otherwise. */
+int strmatch(const char *pattern, int patternLen,
+             const char *string, int stringLen, int nocase)
+{
+    while(patternLen && stringLen) {
+        switch(pattern[0]) {
+        case '*':
+            while (patternLen && pattern[1] == '*') {
+                pattern++;
+                patternLen--;
+            }
+            if (patternLen == 1)
+                return 1; /* match */
+            while(stringLen) {
+                if (strmatch(pattern+1, patternLen-1,
+                             string, stringLen, nocase))
+                    return 1; /* match */
+                string++;
+                stringLen--;
+            }
+            return 0; /* no match */
+            break;
+        case '?':
+            string++;
+            stringLen--;
+            break;
+        case '[':
+        {
+            int not, match;
+
+            pattern++;
+            patternLen--;
+            not = pattern[0] == '^';
+            if (not) {
+                pattern++;
+                patternLen--;
+            }
+            match = 0;
+            while(1) {
+                if (pattern[0] == '\\' && patternLen >= 2) {
+                    pattern++;
+                    patternLen--;
+                    if (pattern[0] == string[0])
+                        match = 1;
+                } else if (pattern[0] == ']') {
+                    break;
+                } else if (patternLen == 0) {
+                    pattern--;
+                    patternLen++;
+                    break;
+                } else if (patternLen >= 3 && pattern[1] == '-') {
+                    int start = pattern[0];
+                    int end = pattern[2];
+                    int c = string[0];
+                    if (start > end) {
+                        int t = start;
+                        start = end;
+                        end = t;
+                    }
+                    if (nocase) {
+                        start = tolower(start);
+                        end = tolower(end);
+                        c = tolower(c);
+                    }
+                    pattern += 2;
+                    patternLen -= 2;
+                    if (c >= start && c <= end)
+                        match = 1;
+                } else {
+                    if (!nocase) {
+                        if (pattern[0] == string[0])
+                            match = 1;
+                    } else {
+                        if (tolower((int)pattern[0]) == tolower((int)string[0]))
+                            match = 1;
+                    }
+                }
+                pattern++;
+                patternLen--;
+            }
+            if (not)
+                match = !match;
+            if (!match)
+                return 0; /* no match */
+            string++;
+            stringLen--;
+            break;
+        }
+        case '\\':
+            if (patternLen >= 2) {
+                pattern++;
+                patternLen--;
+            }
+            /* fall through */
+        default:
+            if (!nocase) {
+                if (pattern[0] != string[0])
+                    return 0; /* no match */
+            } else {
+                if (tolower((int)pattern[0]) != tolower((int)string[0]))
+                    return 0; /* no match */
+            }
+            string++;
+            stringLen--;
+            break;
+        }
+        pattern++;
+        patternLen--;
+        if (stringLen == 0) {
+            while(*pattern == '*') {
+                pattern++;
+                patternLen--;
+            }
+            break;
+        }
+    }
+    if (patternLen == 0 && stringLen == 0)
+        return 1;
+    return 0;
+}
+
+/* ========================== 'show' subcommand ============================= */
+
+void gguf_tools_show(const char *filename) {
+    gguf_ctx *ctx = gguf_open(filename);
+    if (ctx == NULL) {
+        perror(filename);
+        exit(1);
+    }
+
+    /* Show general information about the neural network. */
+    printf("%s (ver %d): %llu key-value pairs, %llu tensors\n",
+        filename,
+        (int)ctx->header->version,
+        (unsigned long long)ctx->header->metadata_kv_count,
+        (unsigned long long)ctx->header->tensor_count);
+
+    /* Show all the key-value pairs. */
+    gguf_key key;
+    while (gguf_get_key(ctx,&key)) {
+        printf("%.*s: [%s] ", (int)key.namelen, key.name, gguf_get_value_type_name(key.type));
+        gguf_print_value(ctx,key.type,key.val,Opt.verbose);
+        printf("\n");
+    }
+
+    /* Show all the tensors. */
+    gguf_tensor tensor;
+    uint64_t params = 0;
+    while (gguf_get_tensor(ctx,&tensor)) {
+        printf("%s tensor %.*s",
+            gguf_get_tensor_type_name(tensor.type),
+            (int)tensor.namelen,
+            tensor.name);
+        if (!Opt.diffable)
+            printf(" @%" PRIu64, tensor.offset);
+        printf(", %" PRIu64 " weights, dims ", tensor.num_weights);
+        for (uint32_t j = 0; j < tensor.ndim; j++) {
+            printf("%s%" PRIu64 "",(j == 0) ? "[" : ",", tensor.dim[j]);
+        }
+        printf("]");
+        if (!Opt.diffable)
+            printf(", %" PRIu64 " bytes", tensor.bsize);
+        printf("\n");
+
+        params += tensor.num_weights;
+    }
+    printf("gguf-tools.info.parameters: %.02fB\n",
+        (double)params/1000000000);
+    return;
+}
+
+/* ======================= 'split-mixtral' subcommand ======================= */
+
+/* Read a Mixtral MoE model and creates a new non-MoE GGUF file based
+ * on the weights of the experts with IDs in the array of 'experts_id'.
+ * The array must contain 32 integers, one for each layer. */
+void gguf_tools_split_mixtral(int *experts_id, const char *mixtral_filename, const char *output_filename) {
+    gguf_ctx *mixtral = gguf_open(mixtral_filename);
+    if (mixtral == NULL) {
+        perror(mixtral_filename);
+        exit(1);
+    }
+
+    gguf_ctx *output = gguf_create(output_filename, GGUF_NONE);
+    if (output == NULL) {
+        perror(output_filename);
+        exit(1);
+    }
+
+    /* To start, copy all the key value items, excluding the one
+     * related to the experts. */
+    gguf_key key;
+    while (gguf_get_key(mixtral,&key)) {
+        char keybuf[1024];
+        snprintf(keybuf,sizeof(keybuf),"%.*s",(int)key.namelen, key.name);
+
+        int skip = strstr(keybuf,"llama.expert_") != NULL;
+
+        if (!skip)
+            printf("Copying %s\n", keybuf);
+        uint64_t value_start_offset = mixtral->off;
+        void *value = mixtral->data+mixtral->off;
+        // Just consume the value without doing anything with it.
+        gguf_do_with_value(mixtral,key.type,key.val,NULL,0,0,NULL);
+        uint64_t value_len = mixtral->off - value_start_offset;
+
+        // Now append the value to the output model.
+        if (!skip)
+            gguf_append_kv(output,key.name,key.namelen,key.type,value,value_len);
+    }
+
+    /* Now it's time to copy the tensors. We need to copy all the shared
+     * tensors (between the different experts), but only a set of
+     * expert-specific tensors corresponding to the expert ID the user
+     * wants to extract. */
+    struct tensor_to_copy {
+        sds dest_name;          // Tensor name in the output file.
+        gguf_tensor orig_info;  // Original tensor info.
+        uint64_t dest_offset;   // Destination offset in output file.
+        uint64_t size;          // Tensor total bytes.
+    };
+
+    uint32_t num_tensors = 0;
+    uint32_t max_tensors = 2048;
+
+    struct tensor_to_copy *tensors =
+        malloc(sizeof(struct tensor_to_copy)*max_tensors);
+    if (tensors == NULL) {
+        perror("Allocating tensors info array");
+        exit(1);
+    }
+
+    /* Scan Mixtral tensors looking for the ones we need to copy
+     * in the output model. */
+    gguf_tensor tensor_info;
+    while (gguf_get_tensor(mixtral,&tensor_info)) {
+        assert(num_tensors < max_tensors);
+
+        char tn[1024]; // Tensor name as null terminated string.
+        snprintf(tn,sizeof(tn),"%.*s",(int)tensor_info.namelen, tensor_info.name);
+
+        /* The tensor is a feed-forward tensor? We want to copy only
+         * the ones of our expert ID. */
+        if (strstr(tn,".ffn_") != NULL && strstr(tn,".ffn_norm") == NULL) {
+            /* Extract which block this FFN belongs. */
+            int block;
+            assert(memcmp(tn,"blk.",4) == 0); // Must start with blk.<block>
+            char *p = strchr(tn+4,'.');
+            assert(p != NULL);
+            *p = 0;
+            block = atoi(tn+4);
+            *p = '.';
+            assert(block >= 0 && block < 32);
+
+            /* Now that we have the block, we can select the corresponding
+             * expert ID we want to use for this block. */
+            int expert_id = experts_id[block];
+
+            char match[32];
+            snprintf(match,sizeof(match),".%d.weight",expert_id);
+            char *match_ptr = strstr(tn,match);
+            if (match_ptr == NULL) {
+                printf("Skipping tensor %s\n", tn);
+                continue; // Skip this tensor.
+            }
+
+            /* We need to remove the .<id>. from the name. */
+            size_t taillen = strlen(match_ptr);
+            memmove(match_ptr,match_ptr+2,taillen+1);
+        }
+
+        /* Create the entry for this tensor. Later we will scan all our
+         * entries and append data to our output tensor. */
+        tensors[num_tensors].dest_name = sdsnew(tn);
+        if (tensors[num_tensors].dest_name == NULL) {
+            perror("Allocating test tensor name");
+            exit(1);
+        }
+        tensors[num_tensors].orig_info = tensor_info;
+        tensors[num_tensors].size = tensor_info.bsize;
+        num_tensors++;
+    }
+
+    /* Now we need to set the offset for our destination tensors. As
+     * we calculate the offsets, we can emit the tensors information
+     * section as well. */
+    uint64_t tensor_off = 0; // Tensor offsets are relative to data section,
+                             // so we start at offset 0.
+    for (uint32_t j = 0; j < num_tensors; j++) {
+        /* Align offset. */
+        tensor_off += gguf_get_alignment_padding(mixtral->alignment,tensor_off);
+        tensors[j].dest_offset = tensor_off;
+        if (gguf_append_tensor_info(output,tensors[j].dest_name,strlen(tensors[j].dest_name),tensors[j].orig_info.ndim,tensors[j].orig_info.dim,tensors[j].orig_info.type,tensor_off) == 0)
+        {
+            perror("Failed to append tensor info");
+            exit(1);
+        }
+        tensor_off += tensors[j].orig_info.bsize;
+    }
+    printf("Output file: after writing tensors info, file size is: %" PRIu64 "\n", output->size);
+
+    /* Finally, append the tensors weights. */
+    for (uint32_t j = 0; j < num_tensors; j++) {
+        printf("Writing tensor %s (weights from %.*s)\n", tensors[j].dest_name,
+            (int)tensors[j].orig_info.namelen, tensors[j].orig_info.name);
+        if (gguf_append_tensor_data(output,tensors[j].orig_info.weights_data,
+            tensors[j].orig_info.bsize) == 0)
+        {
+            perror("Failed to append tensor data");
+            exit(1);
+        }
+    }
+    exit(0);
+}
+
+/* ====================== 'inspect-weights' subcommand ====================== */
+
+void gguf_tools_inspect_weights(const char *filename, const char *tname, uint64_t count) {
+    gguf_ctx *ctx = gguf_open(filename);
+    if (ctx == NULL) {
+        perror(filename);
+        exit(1);
+    }
+
+    /* Skip all the key-value pairs. */
+    gguf_skip_key_values_section(ctx);
+
+    /* Look for the tensor with the specified name. */
+    size_t tnamelen = strlen(tname);
+    gguf_tensor tensor;
+    while (gguf_get_tensor(ctx,&tensor)) {
+        if (tensor.namelen != tnamelen ||
+            memcmp(tensor.name,tname,tnamelen)) continue;
+        break; // Matching tensor found!
+    }
+
+    if (tensor.name == NULL) {
+        fprintf(stderr, "A tensor with the specified name was not found\n");
+        exit(1);
+    }
+
+    float *weights = gguf_tensor_to_float(&tensor);
+    if (weights == NULL) {
+        if (errno == EINVAL) {
+            fprintf(stderr,"Unsupported tensor type: %s\n",
+                gguf_get_tensor_type_name(tensor.type));
+        } else {
+            fprintf(stderr,"Out of memory\n");
+        }
+        exit(1);
+    }
+
+    uint64_t strides[GGUF_TENSOR_MAX_DIM] = {0};
+    strides[tensor.ndim-1] = 1;
+    for (int j = tensor.ndim - 2; j >= 0; j--) {
+        strides[j] = tensor.dim[tensor.ndim - 2 - j] * strides[j + 1];
+    }
+
+    const int ident = 4;
+    uint64_t j = 0;
+    int broke = 1;
+    while (j < tensor.num_weights) {
+        int last = j + 1 == tensor.num_weights;
+        for (int k = 0; k < (int) tensor.ndim - 1; k++) {
+            if (j % strides[k] == 0) {
+                printf("%*s\n", k * ident, "[");
+            }
+        }
+        if (broke) {
+            printf("%*s", tensor.ndim * ident, "");
+        }
+        printf("%f%s", weights[j], last ? "" : ", ");
+        broke = 0;
+        j++;
+        for (int k = (int) tensor.ndim - 2; k >= 0; k--) {
+            if (j % strides[k] == 0) {
+                if (!broke) {
+                    broke = 1;
+                    printf("\n");
+                }
+                printf("%*s%s\n", k * ident, "]", last ? "" : ",");
+            }
+        }
+        if (!broke && j % 4 == 0) {
+            broke = 1;
+            printf("\n");
+        }
+        if (j == count) break;
+    }
+    if (!broke) printf("\n");
+    free(weights);
+    return;
+}
+
+/* ========================== 'compare' subcommand ========================== */
+
+/* Given two tensors of the same length, return the average difference
+ * of their weights, in percentage.
+ *
+ * The difference is calculated like that: the average of the absolute values
+ * of all the weights in the two vectors is calculated. Then, for each set
+ * of corresponding weights, we calculate the difference, and the percentage
+ * according to the average value (100%). The function returns the average
+ * of the percentage of difference between all the pairs.
+ *
+ * Returns 1 on success, 0 if one or both the provided tensors can't be
+ * dequantized. */
+int tensors_avg_diff(gguf_tensor *t1, gguf_tensor *t2, double *diff) {
+    float *weights1 = gguf_tensor_to_float(t1);
+    float *weights2 = gguf_tensor_to_float(t2);
+    if (weights1 == NULL || weights2 == NULL) {
+        free(weights1);
+        free(weights2);
+        return 0;
+    }
+
+    /* Compute the average magnitude of the weights. */
+    double tot_mag = 0;
+    for (uint64_t j = 0; j < t1->num_weights; j++) {
+        tot_mag += fabs(weights1[j]);
+        tot_mag += fabs(weights2[j]);
+    }
+    double avg_mag = tot_mag/(t1->num_weights*2);
+
+    /* Compute the average % difference of the weights. */
+    double tot_diff = 0;
+    for (uint64_t j = 0; j < t1->num_weights; j++)
+        tot_diff += fabs(weights1[j]-weights2[j]);
+    double avg_diff = tot_diff / t1->num_weights;
+
+    /* Multiply by 75 to normalize the difference of a
+     * random variable between -N and +N to 0 - 100% */
+    *diff = avg_diff / avg_mag * 75;
+
+    free(weights1);
+    free(weights2);
+    return 1;
+}
+
+void gguf_tools_compare(const char *file1, const char *file2) {
+    gguf_ctx *ctx1 = gguf_open(file1);
+    if (ctx1 == NULL) {
+        perror(file1);
+        exit(1);
+    }
+
+    gguf_ctx *ctx2 = gguf_open(file2);
+    if (ctx2 == NULL) {
+        perror(file2);
+        exit(1);
+    }
+
+    /* Skip all the key-value pairs. */
+    gguf_skip_key_values_section(ctx1);
+
+    /* For each tensor of the first net... */
+    gguf_tensor tensor1, tensor2;
+    while (gguf_get_tensor(ctx1,&tensor1)) {
+        gguf_skip_key_values_section(ctx2);
+        while (gguf_get_tensor(ctx2,&tensor2)) {
+            /* Search for a tensor with the same name. */
+            if (tensor2.namelen == tensor1.namelen &&
+                memcmp(tensor2.name,tensor1.name,tensor1.namelen) == 0)
+            {
+                printf("[%.*s]: ", (int)tensor1.namelen, tensor1.name);
+                fflush(stdout);
+                if (tensor1.num_weights != tensor2.num_weights) {
+                    printf("size mismatch\n");
+                } else {
+                    double diff;
+                    if (tensors_avg_diff(&tensor1, &tensor2, &diff)) {
+                        printf("avg weights difference: %f%%\n", diff);
+                    } else {
+                        printf("dequantization function missing...\n");
+                    }
+                }
+            }
+        }
+        gguf_rewind(ctx2);
+    }
+}
+
+/* ======================= Main and CLI options parsing ===================== */
+
+void gguf_tools_usage(const char *progname) {
+    printf("Usage: %s <subcommand> [arguments...] [options...]\n"
+"Subcommands:\n"
+"  show <filename> -- show GGUF model keys and tensors.\n"
+"  inspect-tensor <filename> <tensor-name> [count] -- show tensor weights.\n"
+"  compare <file1> <file2> -- avg weights diff for matching tensor names.\n"
+"  split-mixtral <ids...> mixtral.gguf out.gguf -- extract expert.\n"
+"Options:\n"
+"  --verbose       :With 'show', print full arrays (e.g. token lists)\n"
+"  --diffable      :Don't show tensor file offsets and sizes\n"
+"Example:\n"
+"  split-mixtral 65230776370407150546470161412165 mixtral.gguf out.gguf\n"
+           , progname);
+    exit(1);
+}
+
+int main(int argc, char **argv) {
+    if (argc < 3) gguf_tools_usage(argv[0]);
+
+    /* Parse options before getting into subcommands parsing. */
+    for (int j = 1; j < argc; j++) {
+        /* Every time we find a an option, we try to parse it
+         * and set the used argv[] entires to NULL. Later we remove
+         * the NULL entries. In this way '--options' can be anywhere,
+         * making the tool simpler to use. */
+        if (!strcmp(argv[j],"--verbose")) {
+            argv[j] = NULL;
+            argc--;
+            Opt.verbose = 1;
+        }
+        if (!strcmp(argv[j],"--diffable")) {
+            argv[j] = NULL;
+            argc--;
+            Opt.diffable = 1;
+        }
+    }
+
+    /* Strip empty elements. */
+    for (int j = 1; j < argc; j++) {
+        if (argv[j] == NULL) {
+            memmove(argv+j, argv+j+1, sizeof(char*) * (argc-j));
+        }
+    }
+
+    if (!strcmp(argv[1],"show") && argc == 3) {
+        gguf_tools_show(argv[2]);
+    } else if (!strcmp(argv[1],"compare") && argc == 4) {
+        gguf_tools_compare(argv[2],argv[3]);
+    } else if (!strcmp(argv[1],"inspect-tensor") && (argc == 4 || argc == 5)) {
+        gguf_tools_inspect_weights(argv[2],argv[3],
+                                   argc == 5 ? atoi(argv[4]) : 0);
+    } else if (!strcmp(argv[1],"split-mixtral") && argc == 5) {
+        int experts[32];
+        size_t elen = strlen(argv[2]);
+        for (size_t j = 0; j < 32; j++) {
+            if (j < elen) {
+                experts[j] = argv[2][j] - '0';
+                if (experts[j] < 0 || experts[j] > 7) {
+                    fprintf(stderr,"Invalid expert ID: %d\n", experts[j]);
+                    exit(1);
+                }
+            } else {
+                /* If there aren't 32 digits in the input, use the last
+                 * one repeated up to the last layer. */
+                experts[j] = j > 1 ? experts[j-1] : 0;
+            }
+        }
+        gguf_tools_split_mixtral(experts,argv[3],argv[4]);
+    } else {
+        gguf_tools_usage(argv[0]);
+    }
+    return 0;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.c b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.c
new file mode 100644
index 0000000000000000000000000000000000000000..aa68527cf1c9fa61b93e8bb3e776e2a644de0112
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.c
@@ -0,0 +1,1017 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+#include <assert.h>
+#include <inttypes.h>
+
+#include "gguflib.h"
+#include "fp16.h"
+#include "bf16.h"
+
+/* ============================ Low level functions ========================= */
+
+/* GGUF value ID to name lookup table. */
+const char *gguf_value_name[] = {
+    "uint8", "int8", "uint16", "int16", "uint32", "int32",
+    "float32", "bool", "string", "array", "uint64", "int64",
+    "float64"
+};
+
+/* GGUF tensor type to features lookup table. */
+struct gguf_tensor_type_features {
+    char *name;
+    uint32_t items_per_block;
+    uint32_t bytes_per_block;
+} gguf_tensor_type_features[] = {
+    {"f32", 1, 4},
+    {"f16", 1, 2},
+    {"q4_0", 32, 18},
+    {"q4_1", 32, 20},
+    {"q4_2 deprecated", 0, 0},
+    {"q4_3 deprecated", 0, 0},
+    {"q5_0", 32, 22},
+    {"q5_1", 32, 24},
+    {"q8_0", 32, 34},
+    {"q8_1", 32, 40},
+    {"q2_k", 256, 82},
+    {"q3_k", 256, 110},
+    {"q4_k", 256, 144},
+    {"q5_k", 256, 176},
+    {"q6_k", 256, 210},
+    {"q8_k", 256, 292},
+    {"iq2_xxs", 256, 66},
+    {"iq2_xs", 256, 74},
+    {"iq3_xxs", 256, 98},
+    {"iq1_s", 256, 110},
+    {"iq4_nl", 256, 50},
+    {"iq3_s", 256, 110},
+    {"iq2_s", 256, 82},
+    {"iq4_xs", 256, 136},
+    {"i8", 1, 1},
+    {"i16", 1, 2},
+    {"i32", 1, 4},
+    {"i64", 1, 8},
+    {"f64", 1, 8},
+    {"iq1_m", 256, 56},
+    {"bf16", 1, 2},
+};
+
+/* Return the value type name given the type ID. */
+const char *gguf_get_value_type_name(uint32_t type) {
+    if (type >= sizeof(gguf_value_name)/sizeof(char*)) return "unknown";
+    return gguf_value_name[type];
+}
+
+/* Return the tensor type name given the type ID. */
+const char *gguf_get_tensor_type_name(uint32_t type) {
+    if (type >= sizeof(gguf_tensor_type_features)/sizeof(gguf_tensor_type_features[0])) return "unknown";
+    return gguf_tensor_type_features[type].name;
+}
+
+/* Return the tensor type features, or NULL if the type ID is out of range. */
+struct gguf_tensor_type_features *gguf_get_tensor_type_features(uint32_t type) {
+    if (type >= sizeof(gguf_tensor_type_features)/sizeof(gguf_tensor_type_features[0])) return NULL;
+    return &gguf_tensor_type_features[type];
+}
+
+/* Return the length of the value pointed by 'val' of type 'type'.
+ * For the array type the length can't be inferred without consuming
+ * it, so 0 is returned. */
+uint64_t gguf_value_len(uint32_t type, union gguf_value *val) {
+    uint64_t valuelen = 0;
+    switch(type) {
+    case GGUF_VALUE_TYPE_BOOL:
+    case GGUF_VALUE_TYPE_UINT8:
+    case GGUF_VALUE_TYPE_INT8:
+        valuelen = 1; break;
+    case GGUF_VALUE_TYPE_UINT16:
+    case GGUF_VALUE_TYPE_INT16:
+        valuelen = 2; break;
+    case GGUF_VALUE_TYPE_UINT32:
+    case GGUF_VALUE_TYPE_INT32:
+    case GGUF_VALUE_TYPE_FLOAT32:
+        valuelen = 4; break;
+    case GGUF_VALUE_TYPE_UINT64:
+    case GGUF_VALUE_TYPE_INT64:
+    case GGUF_VALUE_TYPE_FLOAT64:
+        valuelen = 8; break;
+    case GGUF_VALUE_TYPE_STRING:
+        valuelen = 8+val->string.len; break;
+    }
+    return valuelen;
+}
+
+/* =============================== GGUF file API ============================ */
+
+/* Open a GGUF file and return a parsing context. */
+gguf_ctx *gguf_open(const char *filename) {
+    int fd = open(filename,O_RDWR|O_APPEND);
+    if (fd == -1) return NULL;
+
+    /* Mapping successful. We can create our context object. */
+    gguf_ctx *ctx = calloc(1, sizeof(*ctx));
+    if (!ctx) return NULL;
+    ctx->fd = fd;
+    ctx->alignment = 32; // Default alignment of GGUF files.
+    ctx->data_off = 0;   // Set later.
+    if (gguf_remap(ctx) == 0) {
+        gguf_close(ctx);
+        return NULL;
+    }
+    gguf_rewind(ctx);
+    return ctx;
+}
+
+/* Set the context to read the first key-value entry in the GGUF
+ * file and then all the rest. Is used when creating a new context
+ * and also when you want to restart scanning the key-value
+ * items in the file. */
+void gguf_rewind(gguf_ctx *ctx) {
+    ctx->off = sizeof(struct gguf_header);
+    ctx->left_kv = ctx->header->metadata_kv_count;
+    ctx->left_tensors = ctx->header->tensor_count;
+}
+
+/* map or re-map the GGUF file inside the context pointers to
+ * header and data, also calculating the file length. This is
+ * used when creating a context, but also after the user write
+ * to the file extending it, and requires to view again the
+ * whole updated file.
+ *
+ * Return 1 on success, 0 on error. */
+int gguf_remap(gguf_ctx *ctx) {
+    struct stat sb;
+
+    /* Unmap if the file was already memory mapped. */
+    if (ctx->data) munmap(ctx->data,ctx->size);
+
+    /* Get the size of the file to map, then map it. */
+    if (fstat(ctx->fd,&sb) == -1) return 0;
+
+    void *mapped = mmap(0,sb.st_size,PROT_READ|PROT_WRITE,MAP_SHARED,ctx->fd,0);
+    if (mapped == MAP_FAILED) return 0;
+
+    /* Minimal sanity check... */
+    if (sb.st_size < (signed)sizeof(struct gguf_header) ||
+        memcmp(mapped,"GGUF",4) != 0)
+    {
+        errno = EINVAL;
+        return 0;
+    }
+    ctx->data = mapped;
+    ctx->header = mapped;
+    ctx->size = sb.st_size;
+    return 1;
+}
+
+/* Cleanup needed after gguf_open() and gguf_create(), to terminate the context
+ * and cleanup resources. */
+void gguf_close(gguf_ctx *ctx) {
+    if (ctx == NULL) return;
+    if (ctx->data) munmap(ctx->data,ctx->size);
+    close(ctx->fd);
+    free(ctx);
+}
+
+/* Parse the next key. Returns key information into 'key'.
+ * The function return value is 1 is a key was returned, or 0
+ * if there are no longer keys to process in this GGUF file. */
+int gguf_get_key(gguf_ctx *ctx, gguf_key *key) {
+    if (ctx->left_kv == 0) return 0;
+    ctx->left_kv--;
+    struct gguf_string *str = (struct gguf_string*) (ctx->data+ctx->off);
+    key->namelen = str->len;
+    key->name = str->string;
+    uint32_t *type = (uint32_t*) (ctx->data+ctx->off+8+str->len);
+    key->type = *type;
+    ctx->off += 8+str->len+4; // Skip prefixed len + string + type.
+    key->val = (void*)(ctx->data+ctx->off);
+
+    /* Update the context with the alignment data, if needed. */
+    const char *alignment_key = "general.alignment";
+    if (key->type == GGUF_VALUE_TYPE_UINT32 &&
+        key->namelen == strlen(alignment_key) &&
+        memcmp(alignment_key, key->name, key->namelen) == 0)
+    {
+        ctx->alignment = key->val->uint32;
+    }
+    return 1;
+}
+
+/* Skip all the key values pairs in the GGUF files to get to the
+ * tensors information segment. */
+void gguf_skip_key_values_section(gguf_ctx *ctx) {
+    gguf_key key;
+    while (gguf_get_key(ctx,&key))
+        gguf_do_with_value(ctx,key.type,key.val,NULL,0,0,NULL);
+}
+
+/* Given an offset or a length, returns the padding needed to align it
+ * to ctx->alignment. */
+uint64_t gguf_get_alignment_padding(uint64_t alignment, uint64_t offset) {
+    return (alignment - (offset % alignment)) % alignment;
+}
+
+/* Set the data section offset. This function must be called exactly when
+ * all the key-values are consumed, in the context of the first call of
+ * gguf_get_tensor(): this way we will be able to return tensor offsets
+ * as absolute positions and pointers to the mmapped file. */
+void gguf_set_data_offset(gguf_ctx *ctx) {
+    assert(ctx->left_kv == 0 && ctx->left_tensors == ctx->header->tensor_count);
+
+    uint64_t offset = ctx->off;
+    for (uint32_t j = 0; j < ctx->left_tensors; j++) {
+        struct gguf_string *str = (struct gguf_string*) (ctx->data+offset);
+        offset += 8+str->len;   // Skip prefixed len + string
+        uint32_t *num_dim = (uint32_t*)(ctx->data+offset);
+        offset += 4;            // Skip num dimentions.
+        offset += 8*(*num_dim); // Skip dimensions.
+        offset += 4;            // Skip tensor type.
+        offset += 8;            // Skip tensor offset.
+    }
+    uint64_t padding = gguf_get_alignment_padding(ctx->alignment,offset);
+    ctx->data_off = offset + padding;
+}
+
+/* Parse the next tensor info data. Returns information into 'tensor'.
+ * The function return value is 1 if a tensor was returned, or 0
+ * if there are no longer tensors to process in this GGUF file or if
+ * there are still key-value pairs to process before getting into the
+ * tensors section.
+ *
+ * The first time this function is called, as a side effect it will
+ * set ctx->data_off to return tensors with absolute offsets.
+ * 
+ * When 0 is returned, the tensor name is set to NULL, so that after
+ * a while() loop scanning tensors for a given condition, the caller
+ * can easily understand if the search terminated because the loop
+ * was exit or because all the entries were consumed. */
+int gguf_get_tensor(gguf_ctx *ctx, gguf_tensor *tensor) {
+    if (ctx->left_tensors == 0 || ctx->left_kv != 0) {
+        tensor->name = NULL;
+        return 0;
+    }
+
+    /* We want to return tensor data with offsets relative to the start
+     * of the file, so that the user of the API is able to access tensors
+     * as it iterates over them. To do so, we need to perform a full
+     * scan if this is the first tensor info we are reading. */
+    if (ctx->data_off == 0) gguf_set_data_offset(ctx);
+
+    ctx->left_tensors--;
+    struct gguf_string *str = (struct gguf_string*) (ctx->data+ctx->off);
+    ctx->off += 8+str->len; // Skip prefixed len + string.
+    tensor->namelen = str->len;
+    tensor->name = str->string;
+    uint32_t *num_dim = (uint32_t*) (ctx->data+ctx->off);
+    ctx->off += 4;  // Skip number of dimensions.
+    tensor->ndim = *num_dim;
+    assert(tensor->ndim <= GGUF_TENSOR_MAX_DIM);
+
+    /* Read the dimentions: all the unused dimensions are set to 1. */
+    tensor->num_weights = 1;
+    for (uint32_t j = 0; j < tensor->ndim; j++) {
+        if (j < tensor->ndim) {
+            uint64_t *dim = (uint64_t*) (ctx->data+ctx->off);
+            ctx->off += 8; // Skip dimension size.
+            tensor->dim[j] = *dim;
+            tensor->num_weights *= *dim;
+        } else {
+            tensor->dim[j] = 1;
+        }
+    }
+    uint32_t *type = (uint32_t*) (ctx->data+ctx->off);
+    if (*type >= GGUF_TYPE_COUNT) return 0;
+    ctx->off += 4;  // Skip tensor type.
+    tensor->type = *type;
+
+    uint64_t *offset = (uint64_t*) (ctx->data+ctx->off);
+    ctx->off += 8;  // Skip tensor offset.
+
+    tensor->offset = ctx->data_off + *offset;
+    tensor->weights_data = ctx->data + tensor->offset;
+
+    /* To accurately calculate the bytes used by this tensor on the GGUF
+     * file, we need to take into account that quantization methods store
+     * tensors as block of N weights. So first of all we need to understand
+     * the number of padding weights (since the last block may have just
+     * fewer weights stored inside, but still requires to be stored to its full
+     * length). Then we can do the math to see how many blocks we need, and
+     * multiply by the block size to obtain the final total size. */
+    struct gguf_tensor_type_features *tf;
+    tf = gguf_get_tensor_type_features(tensor->type);
+    uint64_t weights_padding = gguf_get_alignment_padding(tf->items_per_block,tensor->num_weights);
+    tensor->bsize = ((tensor->num_weights+weights_padding) / tf->items_per_block) * tf->bytes_per_block;
+    return 1;
+}
+
+/* This function can be called after gguf_get_key(), since the context
+ * offset will be in the position of a value.
+ *
+ * The function will process the value, including nested values (in the
+ * case of an array value), and for each value will call the specified
+ * callback. As a side effect of calling this function, the context offset
+ * is advanced to consume the value.
+ *
+ * If the callback is set to NULL, no callback will be called,
+ * but the value will be consumed, so that it will be possible
+ * to call gguf_get_key() or gguf_get_tensor() to continue reading
+ * the file.
+ *
+ * When the callback is called, it gets the argument 'privdata' and 'in_array'
+ * as passed to this function. This is useful if the callback needs
+ * to take state (for pretty printing or alike) and to know if the
+ * elements it is processing belong to an array.
+ *
+ * The value of 'in_array' is the 1-based index of the element being
+ * processed.
+ *
+ * In the case of arrays, callbacks are also called with the special
+ * type ARRAY_START / ARRAY_END at the start/end of the array
+ * processing. */
+void gguf_do_with_value(gguf_ctx *ctx, uint32_t type, union gguf_value *val,
+                        void *privdata, uint64_t in_array, uint64_t array_len,
+                        void(*callback)(void *privdata, uint32_t type,
+                                     union gguf_value *val, uint64_t in_array,
+                                     uint64_t array_len))
+{
+    if (type == GGUF_VALUE_TYPE_ARRAY) {
+        uint32_t etype; // Elements type.
+        uint64_t len;   // Number of elements.
+        etype = val->array.type;
+        len = val->array.len;
+        //exit(1);
+        ctx->off += 4+8; // Skip elements type / array length.
+        if (callback)
+            callback(privdata,GGUF_VALUE_TYPE_ARRAY_START,val,in_array,len);
+        for (uint64_t j = 0; j < len; j++) {
+            val = (union gguf_value*)(ctx->data+ctx->off);
+            gguf_do_with_value(ctx,etype,val,privdata,j+1,len,callback);
+            /* As a side effect of calling gguf_do_with_value() ctx->off
+             * will be update, so 'val' will be set to the next element. */
+        }
+        if (callback)
+            callback(privdata,GGUF_VALUE_TYPE_ARRAY_END,NULL,in_array,len);
+    } else {
+        if (callback)
+            callback(privdata,type,val,in_array,array_len);
+        ctx->off += gguf_value_len(type,val);
+    }
+}
+
+struct gguf_print_options {
+    uint64_t max_array_items;       // Don't print more than N items.
+};
+
+/* Print a GGUF value. 'privdata' is used to pass guff_print_options and
+ * may be NULL if no options are provided.
+ *
+ * The function is designed to be used as a callback of gguf_do_with_value(). */
+void gguf_print_value_callback(void *privdata, uint32_t type, union gguf_value *val, uint64_t in_array, uint64_t array_len) {
+    struct gguf_print_options *po = privdata;
+    if (po && po->max_array_items && in_array > po->max_array_items) {
+        if (in_array-1 == po->max_array_items)
+            printf("... %" PRIu64 " more items of %" PRIu64 "",
+                   array_len-in_array+1, array_len);
+        return;
+    }
+
+    switch (type) {
+        case GGUF_VALUE_TYPE_ARRAY_START:
+            printf("["); break;
+        case GGUF_VALUE_TYPE_ARRAY_END:
+            printf("]"); break;
+        case GGUF_VALUE_TYPE_UINT8:
+            printf("%u", val->uint8); break;
+        case GGUF_VALUE_TYPE_INT8:
+            printf("%d", val->int8); break;
+        case GGUF_VALUE_TYPE_UINT16:
+            printf("%u", val->uint16); break;
+        case GGUF_VALUE_TYPE_INT16:
+            printf("%d", val->int16); break;
+        case GGUF_VALUE_TYPE_UINT32:
+            printf("%u", val->uint32); break;
+        case GGUF_VALUE_TYPE_INT32:
+            printf("%d", val->int32); break;
+        case GGUF_VALUE_TYPE_FLOAT32:
+            printf("%f", val->float32); break;
+        case GGUF_VALUE_TYPE_BOOL:
+            if (val->boolval == 0 || val->boolval == 1)
+                printf("%s", val->boolval ? "true" : "false");
+            else
+                printf("Invalid boolean value %d", val->boolval);
+            break;
+        case GGUF_VALUE_TYPE_STRING:
+            printf("%.*s", (int)val->string.len, val->string.string); break;
+        case GGUF_VALUE_TYPE_UINT64:
+            printf("%" PRIu64 "", val->uint64); break;
+        case GGUF_VALUE_TYPE_INT64:
+            printf("%" PRId64 "", val->int64); break;
+        case GGUF_VALUE_TYPE_FLOAT64:
+            printf("%lf", val->float64); break;
+        default:
+            printf("Unknown type\n");
+            break;
+    }
+    if (in_array && in_array != array_len) printf(", ");
+}
+
+/* Print the current value, including arrays. As a side effect
+ * the value will be consumed from the context, that will now point
+ * to the next item in the GGUF file.
+ *
+ * If 'full' is true, in the case of arrays, the whole array is printed,
+ * otherwise just the first few elements. */
+void gguf_print_value(gguf_ctx *ctx, uint32_t type, union gguf_value *val, int full) {
+    struct gguf_print_options po;
+    po.max_array_items = full ? 0 : 30;
+    gguf_do_with_value(ctx,type,val,&po,0,0,gguf_print_value_callback);
+}
+
+/* ============================= GGUF writing API  ========================== */
+
+/* Create an empty GGUF file with no key-value pairs nor tensors.
+ * The file can be extended by using the APIs to add tensors and
+ * keys.
+ *
+ * On success the context with the file already loaded is returned,
+ * otherwise NULL is returned. */
+gguf_ctx *gguf_create(const char *filename, int flags) {
+    struct gguf_header hdr;
+    memcpy(&hdr.magic,"GGUF",4);
+    hdr.version = 3;
+    hdr.tensor_count = 0;
+    hdr.metadata_kv_count = 0;
+
+    FILE *fp = fopen(filename, flags & GGUF_OVERWRITE ? "w" : "wx");
+    if (fp == NULL) return NULL;
+    if (fwrite(&hdr,1,sizeof(hdr),fp) != sizeof(hdr)) {
+        fclose(fp);
+        return NULL;
+    }
+    fclose(fp);
+
+    return gguf_open(filename);
+}
+
+/* Low level API to append some key-value data to the GGUF file identified
+ * by the context 'ctx'. It's up to the caller to provide a well-formatted
+ * value of the specified type in 'val'. The len is the raw bytes length of
+ * the specified value. Higher level APIs use this one to create fields with
+ * different numerical values, strings, ...
+ *
+ * On success the function returns 1. Otherwise 0.
+ * The function fails and returns 0 with errno set to EINVAL if the
+ * tensors count in the header is non-zero: we can't append key-value
+ * data after the first tensor was emitted. */
+int gguf_append_kv(gguf_ctx *ctx, const char *keyname, uint64_t keylen, uint32_t type, void *val, uint64_t len) {
+    if (ctx->header->tensor_count != 0) {
+        errno = EINVAL;
+        return 0;
+    }
+    if (write(ctx->fd,&keylen,sizeof(keylen)) != sizeof(keylen)) return 0;
+    if (write(ctx->fd,keyname,keylen) != (ssize_t)keylen) return 0;
+    if (write(ctx->fd,&type,sizeof(type)) != sizeof(type)) return 0;
+    if (write(ctx->fd,val,len) != (ssize_t)len) return 0;
+    if (gguf_remap(ctx) == 0) return 0;
+    ctx->header->metadata_kv_count++;
+    return 1;
+}
+
+/* Append tensor metadata (but not the actual tensor weights data) to the
+ * GGUF file identified by 'ctx'. */
+int gguf_append_tensor_info(gguf_ctx *ctx, const char *tensorname, uint64_t namelen, uint32_t num_dim, uint64_t *dim, uint32_t type, uint64_t offset)
+{
+    if (write(ctx->fd,&namelen,sizeof(namelen)) != sizeof(namelen)) return 0;
+    if (write(ctx->fd,tensorname,namelen) != (ssize_t)namelen) return 0;
+    if (write(ctx->fd,&num_dim,sizeof(num_dim)) != sizeof(num_dim)) return 0;
+    for (uint32_t j = 0; j < num_dim; j++) {
+        if (write(ctx->fd,&dim[j],sizeof(uint64_t)) != sizeof(uint64_t))
+            return 0;
+    }
+    if (write(ctx->fd,&type,sizeof(type)) != sizeof(type)) return 0;
+    if (write(ctx->fd,&offset,sizeof(offset)) != sizeof(offset)) return 0;
+    if (gguf_remap(ctx) == 0) return 0;
+    ctx->header->tensor_count++;
+    return 1;
+}
+
+/* Append tensor data enforcing the GGUF file aligment.
+ * The function will take care to add the padding required to start writing
+ * the tensor at an alignment multiple. */
+int gguf_append_tensor_data(gguf_ctx *ctx, void *tensor, uint64_t tensor_size) {
+    char padding_data[1024] = {0};
+    assert(sizeof(padding_data) >= ctx->alignment);
+
+    uint64_t padding = gguf_get_alignment_padding(ctx->alignment,ctx->size);
+    if (write(ctx->fd,padding_data,padding) != (ssize_t)padding) return 0;
+    if (write(ctx->fd,tensor,tensor_size) != (ssize_t)tensor_size) return 0;
+    if (gguf_remap(ctx) == 0) return 0;
+    return 1;
+}
+
+/* ============================ GGUF dequantization ========================= */
+
+/* This callback is used by dequantization functions to store dequantized
+ * weights in a different format than f32. By default all the dequantization
+ * functions will store f32 floats just just f[j] = weight, but if
+ * a store callback is passed, the function will be used. */
+typedef void (*store_float_callback)(void *dst, uint64_t idx, float f);
+
+/* Callback used to store F16 when dequantizing. */
+void gguf_store_f16_callback(void *dst, uint64_t idx, float f) {
+    uint16_t *f16 = dst;
+    f16[idx] = to_half(f);
+}
+
+/* Callback used to store BF16 when dequantizing. */
+void gguf_store_bf16_callback(void *dst, uint64_t idx, float f) {
+    uint16_t *f16 = dst;
+    f16[idx] = to_brain(f);
+}
+
+/* Q8_0 blocks dequantization to floats.
+ * 'dst' is supposed to have enough space for 'count' weights. */
+void gguf_q8_0_to_float(void *weights_data, void *dst, uint64_t count, store_float_callback store_callback) {
+    float *f = dst;
+    struct gguf_tensor_type_features *tf =
+        gguf_get_tensor_type_features(GGUF_TYPE_Q8_0);
+
+    /* Very simple layout: |16 bit scale|32 x 8bit weights|
+     * Each weight is scale * quantized_weight[0..31] */
+    int8_t *block = weights_data;
+    uint64_t i = 0; // i-th weight to dequantize.
+    while(i < count) {
+        /* For each block get the scale and convert all the
+         * weights in the block. */
+        float scale = from_half(*((uint16_t*)block));
+        for (uint32_t j = 0; j < tf->items_per_block; j++) {
+            float weight = block[j+2] * scale; // j+2 to skip the scale bytes.
+            if (store_callback)
+                store_callback(dst,i,weight);
+            else
+                f[i] = weight;
+            if (++i == count) break;
+        }
+        block += tf->bytes_per_block; // Go to the next block.
+    }
+}
+
+/* Q4_K blocks dequantization to floats.
+ * 'y' is supposed to have enough space for 'count' weights. */
+void gguf_q4_k_to_float(void *weights_data, void *dst, uint64_t count, store_float_callback store_callback) {
+    float *f = dst;
+    uint8_t *block = weights_data;
+    uint64_t i = 0; // i-th weight to dequantize.
+    while(i < count) {
+        /* Q4_K super-blocks have 256 total weights, split in 8 sub-block.
+         * Each 8 sub-blocks have a different set of scales/mins, so
+         * there are 16 total values for scales/mins, but the scales/mins
+         * are also quantized (6 bits each) using two different scales:
+         * scale_of_scales and scale_of_mins, that are two FP16 values
+         * at the start of the super block, so:
+         *
+         * |FP16 s_of_scales | +
+         * |FP16 s_of_mins   | +
+         * |16 6 bit integers d,m pairs, one per sub-block of 32 ele | +
+         * |256 x 4bit weights|
+         *
+         * Each quantized weight 'q' is restored as:
+         *
+         *      w = q * scale - min;
+         */
+        float scales_scale = from_half(*((uint16_t*)block));
+        float mins_scale  = from_half(*((uint16_t*)(block+2)));
+        block += 4;
+
+        /* Extract the 16 x 6 bit values scales-mins pairs. The
+         * encoding of those values is odd because of performance
+         * reasons:
+         *
+         *  dddddddd dddddddd dddddddd dddddddd mmmmmmmm mmmmmmmm
+         *  44000000|55111111|66222222|77333333|44000000|55111111
+         *
+         *  mmmmmmmm mmmmmmmm mmmmdddd mmmmdddd mmmmdddd mmmmdddd
+         *  66222222|77333333|44444444|55555555|66666666|77777777
+         *
+         * In the above diagram you can see the 12 bytes and the
+         * scales/mins 6 bits encodings. */
+
+        /* Scale scales/mins. */
+        float scales[8], mins[8];
+        for (int j = 0; j < 8; j++) {
+            uint8_t d,m;
+            if (j < 4) {
+                d = block[j] & 63;
+                m = block[j+4] & 63;
+            } else {
+                d = (block[j+4] & 0xF) | ((block[j-4] >> 6) << 4);
+                m = (block[j+4] >> 4) | ((block[j-0] >> 6) << 4);
+            }
+            scales[j] = d * scales_scale;
+            mins[j] = m * mins_scale;
+        }
+        block += 12; // Seek 4-bit weights start.
+
+        /* Finally we can extract the 256 weights.
+         * We process two blocks per time, because each
+         * 32 bytes have 64 weights stored like this:
+         * First 32 weights of the first block are the higher 4
+         * bits of each byte. Second 32 weights of the second
+         * block are lower 4 bits of each byte. */
+        for (uint32_t b = 0; b < 8; b += 2) {
+            float scale = scales[b];
+            float min = mins[b];
+            /* First set: higher bits. */
+            for (uint32_t j = 0; j < 32; j++) {
+                uint8_t w = block[j] & 0xf;
+                float weight = w * scale - min;
+                if (store_callback)
+                    store_callback(dst,i,weight);
+                else
+                    f[i] = weight;
+                if (++i == count) return;
+            }
+            /* Second set: lower bits. */
+            for (uint32_t j = 0; j < 32; j++) {
+                uint8_t w = block[j] >> 4;
+                float weight = w * scale - min;
+                if (store_callback)
+                    store_callback(dst,i,weight);
+                else
+                    f[i] = weight;
+                if (++i == count) return;
+            }
+            block += 32; // Skip the two processed blocks.
+        }
+    }
+}
+
+/* Q6_K blocks dequantization to floats.
+ * 'y' is supposed to have enough space for 'count' weights. */
+void gguf_q6_k_to_float(void *weights_data, void *dst, uint64_t count, store_float_callback store_callback) {
+    float *f = dst;
+    uint8_t *block = weights_data;
+    uint64_t i = 0; // i-th weight to dequantize.
+    while(i < count) {
+        /* Q6_K super-blocks have 256 total weights, split in 16 sub-block
+         * of 16 elements. There are no mins, just scales. Each sub-block
+         * have a block-specific scale quantized at 8 bits via a single
+         * 16-bit main scale-of-scales.
+         *
+         * |128 bytes of lower 4 bits of quants| +
+         * |64 bytes of lower 2 bits of quants| +
+         * |16 bytes of 8-bit block scales | +
+         * |A single FP16 value: the scale of the scales above |
+         *
+         * Let's call "L" the lower 4 bits array (128 bytes)
+         * and "H" the higher 2 bits array (64 bytes)
+         *
+         * Values are logically encoded in two 128 weights clusters
+         * where the first cluster is the first 64 bytes of "L" and
+         * the first 32 bytes of "H".
+         *
+         * Higher bits of the i-th weight from 0 to 63 are stored in the
+         * lower 4 bits of L[i], while higher bits of the i-th weight
+         * from 64 to 127 are stored in the higher bits of L[i-64]:
+         *
+         * L = |64640000|65650101|66660202|...
+         *
+         * So this actually is: w_low = (L[i%64] >> i/64*4) & 15
+         *
+         * H = |96643200|97653301|98663402|...
+         *
+         * Higher bits of the i-th weight are arranged like that:
+         *
+         * From 0 to 31,  bits 0,1 of H[i]
+         * From 32 to 63, bits 3,2 of H[i-32]
+         * From 64 to 95, bits 5,4 of H[i-64]
+         * From 96 to 127, bits 7,6 of H[i-96]
+         *
+         * So this actually is: w_high = ((H[i%32] >> i/32*2) & 3) << 2
+         * The same is true with the next 128 weights cluster, but
+         * everything is relative to the second half of H and L.
+         *
+         * Finally, there is to extract the scale from the
+         * 16 blocks scales array. Scales are just sequential,
+         * so the i-th weight uses the scale[i/16].
+         *
+         * Important: In Q6_K the 6-bit quants are wisely stored
+         * as unsigned integers + 32, so that there is no need to
+         * do sign bit extension in order to convert the 6-bit value
+         * into 8 bit value. Instead the values from -32 to 31 are
+         * remapped in the 0-63 range (just adding 32).
+         */
+        float super_scale = from_half(*((uint16_t*)(block+128+64+16)));
+        uint8_t *L = block;
+        uint8_t *H = block+128;
+        int8_t *scales = (int8_t*)block+128+64;
+        for (int cluster = 0; cluster < 2; cluster++) {
+            for (uint64_t j = 0; j < 128; j++) {
+                float weight =
+                      (super_scale * scales[j/16]) *
+                       ((int8_t)
+                        ((((L[j%64] >> (j/64*4)) & 0xF) |
+                         (((H[j%32] >> (j/32*2)) & 3) << 4)))-32);
+                if (store_callback)
+                    store_callback(dst,i,weight);
+                else
+                    f[i] = weight;
+                if (++i == count) return;
+            }
+            L += 64;
+            H += 32;
+            scales += 8;
+        }
+        block += 128+64+16+2; // Go to the next block.
+    }
+}
+
+/* Q2_K blocks dequantization to floats.
+ * 'y' is supposed to have enough space for 'count' weights. */
+void gguf_q2_k_to_float(void *weights_data, void *dst, uint64_t count, store_float_callback store_callback) {
+    float *f = dst;
+    uint8_t *block = weights_data;
+    uint64_t i = 0; // i-th weight to dequantize.
+    while(i < count) {
+        /* Q2_K superblocks of 256 weights:
+         * | 16 bytes of 16 scales, 16 mins quantized at 4 bits       | +
+         * | 64 bytes of 2-bit 256 quants (16 elements x 16 blocks)  | +
+         * | 2 bytes F16 scale of scales                              | +
+         * | 2 bytes F16 scale of mins                                |
+         *
+         * Weights are organized as follows:
+         *
+         *                               |76543210| (bit number)
+         * 16 bytes scales/mins are just |min scal| x 16, from block
+         * 0 to 15, sequentially.
+         *
+         * 64 bytes of 2 bits quants are stored like that:
+         * Weights from 0 to 31: bits 1,0 of bytes 0-31 (block 0, 1)
+         * Weights from 32 to 63: bits 3,2 of bytes 0-31 (block 2, 3)
+         * Weights from 64 to 95: bits 5,4 of bytes 0-31 (block 4, 5)
+         * Weights from 96 to 127: bits 7,6 of bytes 0-31 (block 6, 7)
+         *
+         * The same happens for the next 8 blocks, stored in the remaining
+         * 32 bytes.
+         *
+         * The final weight is computed as: w = q2 * block_scale - block_min.
+         *
+         * Since in this code we want to be simple more than fast (at least
+         * for now), the i-th weight can be found (considering we have
+         * two clusters of 128 weights each):
+         *
+         * cluster = i/128 # Cluster 0 or 1
+         * byte = i % 32
+         * shift = i / 32 * 2
+         * w[i] = (quants[byte + (cluster*32)] >> shift) & 3
+         */
+        float scale_of_scales = from_half(*((uint16_t*)(block+16+64)));
+        float scale_of_mins = from_half(*((uint16_t*)(block+16+64+2)));
+
+        float scale = 0, min = 0;
+        int bn = 0; // Block number
+        for (uint64_t cluster = 0; cluster < 2; cluster++) {
+            for (uint64_t j = 0; j < 128; j++) {
+                /* Use new scale/min for each 16 weights sub-block. */
+                if (j % 16 == 0) {
+                    scale = scale_of_scales * (block[bn] & 0xf);
+                    min = scale_of_mins * (block[bn] >> 4);
+                    bn++;
+                }
+                uint8_t q = (block[16+j%32+cluster*32] >> (j/32*2)) & 3;
+                float weight = q * scale - min;
+                if (store_callback)
+                    store_callback(dst,i,weight);
+                else
+                    f[i] = weight;
+                if (++i == count) return;
+            }
+        }
+        block += 16+64+4;
+    }
+}
+
+/* Q4_0 blocks dequantization to floats.
+ * 'dst' is supposed to have enough space for 'count' weights. */
+void gguf_q4_0_to_float(void *weights_data, void *dst, uint64_t count, store_float_callback store_callback) {
+    float *f = dst;
+    struct gguf_tensor_type_features *tf =
+        gguf_get_tensor_type_features(GGUF_TYPE_Q4_0);
+
+    /* Very simple layout: |16 bit scale|32 x 4bit weights|
+     * Each weight is scale * (quantized_weight[0..31] - 8) */
+    uint8_t *block = weights_data;
+    uint64_t i = 0; // i-th weight to dequantize.
+    while(i < count) {
+        /* For each block get the scale and convert all the
+         * weights in the block. */
+        float scale = from_half(*((uint16_t*)block));
+        /* First 16 weights are in the lower bits */
+        for (uint32_t j = 0; j < 16; j++) {
+            uint8_t value = block[j+2]; // j+2 to skip the scale bytes.
+            value &= 0xf;  // lower bits
+            float weight = ((int8_t) value - 8) * scale;
+            if (store_callback)
+                store_callback(dst,i,weight);
+            else
+                f[i] = weight;
+            if (++i == count) break;
+        }
+        /* Last 16 weights are in the higher bits */
+        for (uint32_t j = 0; j < 16; j++) {
+            uint8_t value = block[j+2]; // j+2 to skip the scale bytes.
+            value >>= 4;  // higher bits
+            float weight = ((int8_t) value - 8) * scale;
+            if (store_callback)
+                store_callback(dst,i,weight);
+            else
+                f[i] = weight;
+            if (++i == count) break;
+        }
+        block += tf->bytes_per_block; // Go to the next block.
+    }
+}
+
+/* Q4_1 blocks dequantization to floats.
+ * 'dst' is supposed to have enough space for 'count' weights. */
+void gguf_q4_1_to_float(void *weights_data, void *dst, uint64_t count, store_float_callback store_callback) {
+    float *f = dst;
+    struct gguf_tensor_type_features *tf =
+        gguf_get_tensor_type_features(GGUF_TYPE_Q4_1);
+
+    /* Very simple layout: |16 bit scale|16 bit bias|32 x 4bit weights|
+     * Each weight is scale * quantized_weight[0..31] + bias */
+    uint8_t *block = weights_data;
+    uint64_t i = 0; // i-th weight to dequantize.
+    while(i < count) {
+        /* For each block get the scale and convert all the
+         * weights in the block. */
+        float scale = from_half(*((uint16_t*)block));
+        float bias = from_half(*((uint16_t*)block+1));
+        /* First 16 weights are in the lower bits */
+        for (uint32_t j = 0; j < 16; j++) {
+            uint8_t value = block[j+4]; // j+2 to skip the scale and bias bytes.
+            value &= 0xf;  // lower bits
+            float weight = value * scale + bias;
+            if (store_callback)
+                store_callback(dst,i,weight);
+            else
+                f[i] = weight;
+            if (++i == count) break;
+        }
+        /* Last 16 weights are in the higher bits */
+        for (uint32_t j = 0; j < 16; j++) {
+            uint8_t value = block[j+4]; // j+2 to skip the scale and bias bytes.
+            value >>= 4;  // higher bits
+            float weight = value * scale + bias;
+            if (store_callback)
+                store_callback(dst,i,weight);
+            else
+                f[i] = weight;
+            if (++i == count) break;
+        }
+        block += tf->bytes_per_block; // Go to the next block.
+    }
+}
+
+/* FP16 blocks dequantization to floats.
+ * 'y' is supposed to have enough space for 'count' weights. */
+static void gguf_f16_to_float(void *weights_data, void *dst, uint64_t count,
+                              store_float_callback store_callback) {
+    float *f = dst;
+    uint64_t i = 0; // i-th weight to dequantize.
+    uint16_t *w16 = weights_data;
+    while(i < count) {
+        float weight = from_half(w16[i]);
+        if (store_callback)
+            store_callback(dst,i,weight);
+        else
+            f[i] = weight;
+        i++;
+    }
+}
+
+/* BF16 blocks dequantization to floats.
+ * 'y' is supposed to have enough space for 'count' weights. */
+static void gguf_bf16_to_float(void *weights_data, void *dst, uint64_t count,
+                               store_float_callback store_callback) {
+    float *f = dst;
+    uint64_t i = 0; // i-th weight to dequantize.
+    uint16_t *w16 = weights_data;
+    while(i < count) {
+        float weight = from_brain(w16[i]);
+        if (store_callback)
+            store_callback(dst,i,weight);
+        else
+            f[i] = weight;
+        i++;
+    }
+}
+
+/* Convert the specified tensor (quantized or not) into an array of
+ * floats. The array is allocated with malloc(). If the tensor is already
+ * in FP32 floats format, it is just memcpy()-ed to the destination array.
+ *
+ * On OOM, NULL is returned. If the tensor format is not yet supported,
+ * NULL is returned as well, but errno is set to EINVAL. */
+float *gguf_tensor_to_float(gguf_tensor *tensor) {
+    float *f = malloc(tensor->num_weights*sizeof(float));
+    if (!f) return NULL;
+    if (tensor->type == GGUF_TYPE_F32) {
+        memcpy(f, tensor->weights_data, tensor->num_weights*sizeof(float));
+    } else if (tensor->type == GGUF_TYPE_F16) {
+        gguf_f16_to_float(tensor->weights_data, f, tensor->num_weights, NULL);
+    } else if (tensor->type == GGUF_TYPE_BF16) {
+        gguf_bf16_to_float(tensor->weights_data, f, tensor->num_weights, NULL);
+    } else if (tensor->type == GGUF_TYPE_Q8_0) {
+        gguf_q8_0_to_float(tensor->weights_data, f, tensor->num_weights, NULL);
+    } else if (tensor->type == GGUF_TYPE_Q4_K) {
+        gguf_q4_k_to_float(tensor->weights_data, f, tensor->num_weights, NULL);
+    } else if (tensor->type == GGUF_TYPE_Q6_K) {
+        gguf_q6_k_to_float(tensor->weights_data, f, tensor->num_weights, NULL);
+    } else if (tensor->type == GGUF_TYPE_Q2_K) {
+        gguf_q2_k_to_float(tensor->weights_data, f, tensor->num_weights, NULL);
+    } else if (tensor->type == GGUF_TYPE_Q4_0) {
+        gguf_q4_0_to_float(tensor->weights_data, f, tensor->num_weights, NULL);
+    } else if (tensor->type == GGUF_TYPE_Q4_1) {
+        gguf_q4_1_to_float(tensor->weights_data, f, tensor->num_weights, NULL);
+    } else {
+        free(f);
+        errno = EINVAL;
+        return NULL;
+    }
+    return f;
+}
+
+/* Same as gguf_tensor_to_float() but the result will be an f16 tensor, that is
+ * an array of int16_t values. */
+int16_t *gguf_tensor_to_f16(gguf_tensor *tensor) {
+    int16_t *f16 = malloc(tensor->num_weights*sizeof(int16_t));
+    if (!f16) return NULL;
+    if (tensor->type == GGUF_TYPE_F32) {
+        float *f = (float*)tensor->weights_data;
+        for (uint64_t j = 0; j < tensor->num_weights; j++)
+            f16[j] = to_half(f[j]);
+    } else if (tensor->type == GGUF_TYPE_F16) {
+        memcpy(f16, tensor->weights_data, tensor->num_weights*sizeof(int16_t));
+    } else if (tensor->type == GGUF_TYPE_BF16) {
+        gguf_bf16_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_f16_callback);
+    } else if (tensor->type == GGUF_TYPE_Q8_0) {
+        gguf_q8_0_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_f16_callback);
+    } else if (tensor->type == GGUF_TYPE_Q4_K) {
+        gguf_q4_k_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_f16_callback);
+    } else if (tensor->type == GGUF_TYPE_Q6_K) {
+        gguf_q6_k_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_f16_callback);
+    } else if (tensor->type == GGUF_TYPE_Q2_K) {
+        gguf_q2_k_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_f16_callback);
+    } else if (tensor->type == GGUF_TYPE_Q4_0) {
+        gguf_q4_0_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_f16_callback);
+    } else if (tensor->type == GGUF_TYPE_Q4_1) {
+        gguf_q4_1_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_f16_callback);
+    } else {
+        free(f16);
+        errno = EINVAL;
+        return NULL;
+    }
+    return f16;
+}
+
+/* Same as gguf_tensor_to_float() but the result will be an bf16 tensor, that is
+ * an array of int16_t values. */
+int16_t *gguf_tensor_to_bf16(gguf_tensor *tensor) {
+    int16_t *f16 = malloc(tensor->num_weights*sizeof(int16_t));
+    if (!f16) return NULL;
+    if (tensor->type == GGUF_TYPE_F32) {
+        float *f = (float*)tensor->weights_data;
+        for (uint64_t j = 0; j < tensor->num_weights; j++)
+            f16[j] = to_half(f[j]);
+    } else if (tensor->type == GGUF_TYPE_F16) {
+        gguf_f16_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_bf16_callback);
+    } else if (tensor->type == GGUF_TYPE_BF16) {
+        memcpy(f16, tensor->weights_data, tensor->num_weights*sizeof(int16_t));
+    } else if (tensor->type == GGUF_TYPE_Q8_0) {
+        gguf_q8_0_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_bf16_callback);
+    } else if (tensor->type == GGUF_TYPE_Q4_K) {
+        gguf_q4_k_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_bf16_callback);
+    } else if (tensor->type == GGUF_TYPE_Q6_K) {
+        gguf_q6_k_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_bf16_callback);
+    } else if (tensor->type == GGUF_TYPE_Q2_K) {
+        gguf_q2_k_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_bf16_callback);
+    } else if (tensor->type == GGUF_TYPE_Q4_0) {
+        gguf_q4_0_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_bf16_callback);
+    } else if (tensor->type == GGUF_TYPE_Q4_1) {
+        gguf_q4_1_to_float(tensor->weights_data, f16, tensor->num_weights, gguf_store_bf16_callback);
+    } else {
+        free(f16);
+        errno = EINVAL;
+        return NULL;
+    }
+    return f16;
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.h
new file mode 100644
index 0000000000000000000000000000000000000000..4cb973a00a2674063340fda06c850a9c0fee5d68
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.h
@@ -0,0 +1,201 @@
+/* Copyright (C) 2024 Salvatore Sanfilippo <antirez@gmail.com>
+ * See LICENSE for licensing info.
+ *
+ * GGUF enums / structures are partially adapted
+ * the official GGUF implementation at from https://github.com/ggerganov/ggml/
+ */
+
+#ifndef GGUFLIB_H
+#define GGUFLIB_H
+
+#include <stdint.h>
+
+/* ============================ Enums and structures ======================== */
+
+/* Flags that can be used in different functions with the same meaning. */
+#define GGUF_NONE           0           // No flags.
+#define GGUF_OVERWRITE      (1<<0)      // Overwrite the destination object.
+
+enum gguf_tensor_type {
+    GGUF_TYPE_F32  = 0,
+    GGUF_TYPE_F16  = 1,
+    GGUF_TYPE_Q4_0 = 2,
+    GGUF_TYPE_Q4_1 = 3,
+    // GGUF_TYPE_Q4_2 = 4, support has been removed
+    // GGUF_TYPE_Q4_3 (5) support has been removed
+    GGUF_TYPE_Q5_0 = 6,
+    GGUF_TYPE_Q5_1 = 7,
+    GGUF_TYPE_Q8_0 = 8,
+    GGUF_TYPE_Q8_1 = 9,
+    GGUF_TYPE_Q2_K = 10,
+    GGUF_TYPE_Q3_K = 11,
+    GGUF_TYPE_Q4_K = 12,
+    GGUF_TYPE_Q5_K = 13,
+    GGUF_TYPE_Q6_K = 14,
+    GGUF_TYPE_Q8_K = 15,
+    GGUF_TYPE_IQ2_XXS = 16,
+    GGUF_TYPE_IQ2_XS = 17,
+    GGUF_TYPE_IQ3_XXS = 18,
+    GGUF_TYPE_IQ1_S = 19,
+    GGUF_TYPE_IQ4_NL = 20,
+    GGUF_TYPE_IQ3_S = 21,
+    GGUF_TYPE_IQ2_S = 22,
+    GGUF_TYPE_IQ4_XS = 23,
+    GGUF_TYPE_I8 = 24,
+    GGUF_TYPE_I16 = 25,
+    GGUF_TYPE_I32 = 26,
+    GGUF_TYPE_I64 = 27,
+    GGUF_TYPE_F64 = 28,
+    GGUF_TYPE_IQ1_M = 29,
+    GGUF_TYPE_BF16 = 30,
+    GGUF_TYPE_COUNT,
+};
+
+enum gguf_value_type {
+    // The value is a 8-bit unsigned integer.
+    GGUF_VALUE_TYPE_UINT8 = 0,
+    // The value is a 8-bit signed integer.
+    GGUF_VALUE_TYPE_INT8 = 1,
+    // The value is a 16-bit unsigned little-endian integer.
+    GGUF_VALUE_TYPE_UINT16 = 2,
+    // The value is a 16-bit signed little-endian integer.
+    GGUF_VALUE_TYPE_INT16 = 3,
+    // The value is a 32-bit unsigned little-endian integer.
+    GGUF_VALUE_TYPE_UINT32 = 4,
+    // The value is a 32-bit signed little-endian integer.
+    GGUF_VALUE_TYPE_INT32 = 5,
+    // The value is a 32-bit IEEE754 floating point number.
+    GGUF_VALUE_TYPE_FLOAT32 = 6,
+    // The value is a boolean.
+    // 1-byte value where 0 is false and 1 is true.
+    // Anything else is invalid, and should be treated as either the model
+    // being invalid or the reader being buggy.
+    GGUF_VALUE_TYPE_BOOL = 7,
+    // The value is a UTF-8 non-null-terminated string, with length prepended.
+    GGUF_VALUE_TYPE_STRING = 8,
+    // The value is an array of other values, with the length and type
+    // prepended. Arrays can be nested, and the length of the array is the
+    // number of elements in the array, not the number of bytes.
+    GGUF_VALUE_TYPE_ARRAY = 9,
+    // The value is a 64-bit unsigned little-endian integer.
+    GGUF_VALUE_TYPE_UINT64 = 10,
+    // The value is a 64-bit signed little-endian integer.
+    GGUF_VALUE_TYPE_INT64 = 11,
+    // The value is a 64-bit IEEE754 floating point number.
+    GGUF_VALUE_TYPE_FLOAT64 = 12,
+    // Special values used by the callbacks of gguf_do_with_value().
+    GGUF_VALUE_TYPE_ARRAY_START = 100,
+    GGUF_VALUE_TYPE_ARRAY_END = 101
+};
+
+// A string in GGUF.
+struct gguf_string {
+    // The length of the string, in bytes.
+    uint64_t len;
+    // The string as a UTF-8 non-null-terminated string.
+    char string[];
+};
+
+// Union of possible values.
+union gguf_value {
+    uint8_t uint8;
+    int8_t int8;
+    uint16_t uint16;
+    int16_t int16;
+    uint32_t uint32;
+    int32_t int32;
+    float float32;
+    uint64_t uint64;
+    int64_t int64;
+    double float64;
+    uint8_t boolval;
+    struct gguf_string string;
+    struct {
+        // Any value type is valid, including arrays.
+        uint32_t type;
+        // Number of elements, not bytes
+        uint64_t len;
+        // The array of values follow...
+    } __attribute__((packed)) array;
+};
+
+// Header
+struct gguf_header {
+    // Magic number to announce that this is a GGUF file.
+    // Must be `GGUF` at the byte level: `0x47` `0x47` `0x55` `0x46`.
+    uint32_t magic;
+    // The version of the format implemented.
+    // Must be `3` for version described in this spec.
+    uint32_t version;
+    // The number of tensors in the file.
+    // This is explicit, instead of being included in the metadata, to ensure
+    // it is always present for loading the tensors.
+    uint64_t tensor_count;
+    // The number of metadata key-value pairs.
+    uint64_t metadata_kv_count;
+};
+
+/* Key representation in this library API. */
+typedef struct {
+    const char *name;
+    size_t namelen;
+    uint32_t type;
+    union gguf_value *val;
+} gguf_key;
+
+/* Tensor representation in this library API. */
+#define GGUF_TENSOR_MAX_DIM 8           // Future-proof: actual limit is 4.
+typedef struct {
+    const char *name;
+    size_t namelen;
+    uint32_t type;                      // Tensor type (enum gguf_tensor_type).
+    uint32_t ndim;                      // Number of dimensions of the tensor.
+    uint64_t dim[GGUF_TENSOR_MAX_DIM];  // Dimensions (Eg. [512, 1024, 1, 1]).
+    uint64_t offset;                    // Offset from start of file.
+    uint64_t bsize;                     // Total size in bytes.
+    uint64_t num_weights;               // Total number of parameters.
+    uint8_t *weights_data;              // Pointer to the mmaped file.
+} gguf_tensor;
+
+/* The context you get after opening a GGUF file with gguf_init(). */
+typedef struct {
+    int fd;
+    uint8_t *data;  // Memory mapped data.
+    uint64_t size;  // Total file size.
+    struct gguf_header *header;     // GUFF file header info.
+    uint64_t left_kv;               // Number of key-value pairs yet to read.
+    uint64_t left_tensors;          // Number of tensors yet to read.
+    uint64_t off;                   // Offset of the next item to parse.
+    uint64_t data_off;              // Offset of tensor data section. This
+                                    // is only set when all the kv/tensor header
+                                    // entries are processed. Initially 0.
+    uint64_t alignment;             // File data alignment. Default: 32 bytes.
+} gguf_ctx;
+
+/* =============================== Prototypes =============================== */
+
+gguf_ctx *gguf_open(const char *filename);
+gguf_ctx *gguf_create(const char *filename, int flags);
+int gguf_remap(gguf_ctx *ctx);
+void gguf_rewind(gguf_ctx *ctx);
+void gguf_close(gguf_ctx *ctx);
+int gguf_get_key(gguf_ctx *ctx, gguf_key *key);
+int gguf_get_tensor(gguf_ctx *ctx, gguf_tensor *tensor);
+const char *gguf_get_value_type_name(uint32_t type);
+const char *gguf_get_tensor_type_name(uint32_t type);
+void gguf_do_with_value(gguf_ctx *ctx, uint32_t type, union gguf_value *val,
+                        void *privdata, uint64_t in_array, uint64_t array_len,
+                        void(*callback)(void *privdata, uint32_t type,
+                                     union gguf_value *val, uint64_t in_array,
+                                     uint64_t array_len));
+void gguf_print_value(gguf_ctx *ctx, uint32_t type, union gguf_value *val, int full);
+int gguf_append_kv(gguf_ctx *ctx, const char *keyname, uint64_t keylen, uint32_t type, void *val, uint64_t len);
+int gguf_append_tensor_info(gguf_ctx *ctx, const char *tensorname, uint64_t namelen, uint32_t num_dim, uint64_t *dim, uint32_t type, uint64_t offset);
+int gguf_append_tensor_data(gguf_ctx *ctx, void *tensor, uint64_t tensor_size);
+uint64_t gguf_get_alignment_padding(uint64_t alignment, uint64_t offset);
+void gguf_skip_key_values_section(gguf_ctx *ctx);
+float *gguf_tensor_to_float(gguf_tensor *tensor);
+int16_t *gguf_tensor_to_f16(gguf_tensor *tensor);
+int16_t *gguf_tensor_to_bf16(gguf_tensor *tensor);
+
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/sds.c b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/sds.c
new file mode 100644
index 0000000000000000000000000000000000000000..118971621ae88127857454ee621bf574b11884a8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/sds.c
@@ -0,0 +1,1300 @@
+/* SDSLib 2.0 -- A C dynamic strings library
+ *
+ * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2015, Oran Agra
+ * Copyright (c) 2015, Redis Labs, Inc
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+#include <limits.h>
+#include "sds.h"
+#include "sdsalloc.h"
+
+const char *SDS_NOINIT = "SDS_NOINIT";
+
+static inline int sdsHdrSize(char type) {
+    switch(type&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            return sizeof(struct sdshdr5);
+        case SDS_TYPE_8:
+            return sizeof(struct sdshdr8);
+        case SDS_TYPE_16:
+            return sizeof(struct sdshdr16);
+        case SDS_TYPE_32:
+            return sizeof(struct sdshdr32);
+        case SDS_TYPE_64:
+            return sizeof(struct sdshdr64);
+    }
+    return 0;
+}
+
+static inline char sdsReqType(size_t string_size) {
+    if (string_size < 1<<5)
+        return SDS_TYPE_5;
+    if (string_size < 1<<8)
+        return SDS_TYPE_8;
+    if (string_size < 1<<16)
+        return SDS_TYPE_16;
+#if (LONG_MAX == LLONG_MAX)
+    if (string_size < 1ll<<32)
+        return SDS_TYPE_32;
+    return SDS_TYPE_64;
+#else
+    return SDS_TYPE_32;
+#endif
+}
+
+/* Create a new sds string with the content specified by the 'init' pointer
+ * and 'initlen'.
+ * If NULL is used for 'init' the string is initialized with zero bytes.
+ * If SDS_NOINIT is used, the buffer is left uninitialized;
+ *
+ * The string is always null-termined (all the sds strings are, always) so
+ * even if you create an sds string with:
+ *
+ * mystring = sdsnewlen("abc",3);
+ *
+ * You can print the string with printf() as there is an implicit \0 at the
+ * end of the string. However the string is binary safe and can contain
+ * \0 characters in the middle, as the length is stored in the sds header. */
+sds sdsnewlen(const void *init, size_t initlen) {
+    void *sh;
+    sds s;
+    char type = sdsReqType(initlen);
+    /* Empty strings are usually created in order to append. Use type 8
+     * since type 5 is not good at this. */
+    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
+    int hdrlen = sdsHdrSize(type);
+    unsigned char *fp; /* flags pointer. */
+
+    sh = s_malloc(hdrlen+initlen+1);
+    if (sh == NULL) return NULL;
+    if (init==SDS_NOINIT)
+        init = NULL;
+    else if (!init)
+        memset(sh, 0, hdrlen+initlen+1);
+    s = (char*)sh+hdrlen;
+    fp = ((unsigned char*)s)-1;
+    switch(type) {
+        case SDS_TYPE_5: {
+            *fp = type | (initlen << SDS_TYPE_BITS);
+            break;
+        }
+        case SDS_TYPE_8: {
+            SDS_HDR_VAR(8,s);
+            sh->len = initlen;
+            sh->alloc = initlen;
+            *fp = type;
+            break;
+        }
+        case SDS_TYPE_16: {
+            SDS_HDR_VAR(16,s);
+            sh->len = initlen;
+            sh->alloc = initlen;
+            *fp = type;
+            break;
+        }
+        case SDS_TYPE_32: {
+            SDS_HDR_VAR(32,s);
+            sh->len = initlen;
+            sh->alloc = initlen;
+            *fp = type;
+            break;
+        }
+        case SDS_TYPE_64: {
+            SDS_HDR_VAR(64,s);
+            sh->len = initlen;
+            sh->alloc = initlen;
+            *fp = type;
+            break;
+        }
+    }
+    if (initlen && init)
+        memcpy(s, init, initlen);
+    s[initlen] = '\0';
+    return s;
+}
+
+/* Create an empty (zero length) sds string. Even in this case the string
+ * always has an implicit null term. */
+sds sdsempty(void) {
+    return sdsnewlen("",0);
+}
+
+/* Create a new sds string starting from a null terminated C string. */
+sds sdsnew(const char *init) {
+    size_t initlen = (init == NULL) ? 0 : strlen(init);
+    return sdsnewlen(init, initlen);
+}
+
+/* Duplicate an sds string. */
+sds sdsdup(const sds s) {
+    return sdsnewlen(s, sdslen(s));
+}
+
+/* Free an sds string. No operation is performed if 's' is NULL. */
+void sdsfree(sds s) {
+    if (s == NULL) return;
+    s_free((char*)s-sdsHdrSize(s[-1]));
+}
+
+/* Set the sds string length to the length as obtained with strlen(), so
+ * considering as content only up to the first null term character.
+ *
+ * This function is useful when the sds string is hacked manually in some
+ * way, like in the following example:
+ *
+ * s = sdsnew("foobar");
+ * s[2] = '\0';
+ * sdsupdatelen(s);
+ * printf("%d\n", sdslen(s));
+ *
+ * The output will be "2", but if we comment out the call to sdsupdatelen()
+ * the output will be "6" as the string was modified but the logical length
+ * remains 6 bytes. */
+void sdsupdatelen(sds s) {
+    size_t reallen = strlen(s);
+    sdssetlen(s, reallen);
+}
+
+/* Modify an sds string in-place to make it empty (zero length).
+ * However all the existing buffer is not discarded but set as free space
+ * so that next append operations will not require allocations up to the
+ * number of bytes previously available. */
+void sdsclear(sds s) {
+    sdssetlen(s, 0);
+    s[0] = '\0';
+}
+
+/* Enlarge the free space at the end of the sds string so that the caller
+ * is sure that after calling this function can overwrite up to addlen
+ * bytes after the end of the string, plus one more byte for nul term.
+ *
+ * Note: this does not change the *length* of the sds string as returned
+ * by sdslen(), but only the free buffer space we have. */
+sds sdsMakeRoomFor(sds s, size_t addlen) {
+    void *sh, *newsh;
+    size_t avail = sdsavail(s);
+    size_t len, newlen;
+    char type, oldtype = s[-1] & SDS_TYPE_MASK;
+    int hdrlen;
+
+    /* Return ASAP if there is enough space left. */
+    if (avail >= addlen) return s;
+
+    len = sdslen(s);
+    sh = (char*)s-sdsHdrSize(oldtype);
+    newlen = (len+addlen);
+    if (newlen < SDS_MAX_PREALLOC)
+        newlen *= 2;
+    else
+        newlen += SDS_MAX_PREALLOC;
+
+    type = sdsReqType(newlen);
+
+    /* Don't use type 5: the user is appending to the string and type 5 is
+     * not able to remember empty space, so sdsMakeRoomFor() must be called
+     * at every appending operation. */
+    if (type == SDS_TYPE_5) type = SDS_TYPE_8;
+
+    hdrlen = sdsHdrSize(type);
+    if (oldtype==type) {
+        newsh = s_realloc(sh, hdrlen+newlen+1);
+        if (newsh == NULL) return NULL;
+        s = (char*)newsh+hdrlen;
+    } else {
+        /* Since the header size changes, need to move the string forward,
+         * and can't use realloc */
+        newsh = s_malloc(hdrlen+newlen+1);
+        if (newsh == NULL) return NULL;
+        memcpy((char*)newsh+hdrlen, s, len+1);
+        s_free(sh);
+        s = (char*)newsh+hdrlen;
+        s[-1] = type;
+        sdssetlen(s, len);
+    }
+    sdssetalloc(s, newlen);
+    return s;
+}
+
+/* Reallocate the sds string so that it has no free space at the end. The
+ * contained string remains not altered, but next concatenation operations
+ * will require a reallocation.
+ *
+ * After the call, the passed sds string is no longer valid and all the
+ * references must be substituted with the new pointer returned by the call. */
+sds sdsRemoveFreeSpace(sds s) {
+    void *sh, *newsh;
+    char type, oldtype = s[-1] & SDS_TYPE_MASK;
+    int hdrlen, oldhdrlen = sdsHdrSize(oldtype);
+    size_t len = sdslen(s);
+    size_t avail = sdsavail(s);
+    sh = (char*)s-oldhdrlen;
+
+    /* Return ASAP if there is no space left. */
+    if (avail == 0) return s;
+
+    /* Check what would be the minimum SDS header that is just good enough to
+     * fit this string. */
+    type = sdsReqType(len);
+    hdrlen = sdsHdrSize(type);
+
+    /* If the type is the same, or at least a large enough type is still
+     * required, we just realloc(), letting the allocator to do the copy
+     * only if really needed. Otherwise if the change is huge, we manually
+     * reallocate the string to use the different header type. */
+    if (oldtype==type || type > SDS_TYPE_8) {
+        newsh = s_realloc(sh, oldhdrlen+len+1);
+        if (newsh == NULL) return NULL;
+        s = (char*)newsh+oldhdrlen;
+    } else {
+        newsh = s_malloc(hdrlen+len+1);
+        if (newsh == NULL) return NULL;
+        memcpy((char*)newsh+hdrlen, s, len+1);
+        s_free(sh);
+        s = (char*)newsh+hdrlen;
+        s[-1] = type;
+        sdssetlen(s, len);
+    }
+    sdssetalloc(s, len);
+    return s;
+}
+
+/* Return the total size of the allocation of the specified sds string,
+ * including:
+ * 1) The sds header before the pointer.
+ * 2) The string.
+ * 3) The free buffer at the end if any.
+ * 4) The implicit null term.
+ */
+size_t sdsAllocSize(sds s) {
+    size_t alloc = sdsalloc(s);
+    return sdsHdrSize(s[-1])+alloc+1;
+}
+
+/* Return the pointer of the actual SDS allocation (normally SDS strings
+ * are referenced by the start of the string buffer). */
+void *sdsAllocPtr(sds s) {
+    return (void*) (s-sdsHdrSize(s[-1]));
+}
+
+/* Increment the sds length and decrements the left free space at the
+ * end of the string according to 'incr'. Also set the null term
+ * in the new end of the string.
+ *
+ * This function is used in order to fix the string length after the
+ * user calls sdsMakeRoomFor(), writes something after the end of
+ * the current string, and finally needs to set the new length.
+ *
+ * Note: it is possible to use a negative increment in order to
+ * right-trim the string.
+ *
+ * Usage example:
+ *
+ * Using sdsIncrLen() and sdsMakeRoomFor() it is possible to mount the
+ * following schema, to cat bytes coming from the kernel to the end of an
+ * sds string without copying into an intermediate buffer:
+ *
+ * oldlen = sdslen(s);
+ * s = sdsMakeRoomFor(s, BUFFER_SIZE);
+ * nread = read(fd, s+oldlen, BUFFER_SIZE);
+ * ... check for nread <= 0 and handle it ...
+ * sdsIncrLen(s, nread);
+ */
+void sdsIncrLen(sds s, ssize_t incr) {
+    unsigned char flags = s[-1];
+    size_t len;
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5: {
+            unsigned char *fp = ((unsigned char*)s)-1;
+            unsigned char oldlen = SDS_TYPE_5_LEN(flags);
+            assert((incr > 0 && oldlen+incr < 32) || (incr < 0 && oldlen >= (unsigned int)(-incr)));
+            *fp = SDS_TYPE_5 | ((oldlen+incr) << SDS_TYPE_BITS);
+            len = oldlen+incr;
+            break;
+        }
+        case SDS_TYPE_8: {
+            SDS_HDR_VAR(8,s);
+            assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
+            len = (sh->len += incr);
+            break;
+        }
+        case SDS_TYPE_16: {
+            SDS_HDR_VAR(16,s);
+            assert((incr >= 0 && sh->alloc-sh->len >= incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
+            len = (sh->len += incr);
+            break;
+        }
+        case SDS_TYPE_32: {
+            SDS_HDR_VAR(32,s);
+            assert((incr >= 0 && sh->alloc-sh->len >= (unsigned int)incr) || (incr < 0 && sh->len >= (unsigned int)(-incr)));
+            len = (sh->len += incr);
+            break;
+        }
+        case SDS_TYPE_64: {
+            SDS_HDR_VAR(64,s);
+            assert((incr >= 0 && sh->alloc-sh->len >= (uint64_t)incr) || (incr < 0 && sh->len >= (uint64_t)(-incr)));
+            len = (sh->len += incr);
+            break;
+        }
+        default: len = 0; /* Just to avoid compilation warnings. */
+    }
+    s[len] = '\0';
+}
+
+/* Grow the sds to have the specified length. Bytes that were not part of
+ * the original length of the sds will be set to zero.
+ *
+ * if the specified length is smaller than the current length, no operation
+ * is performed. */
+sds sdsgrowzero(sds s, size_t len) {
+    size_t curlen = sdslen(s);
+
+    if (len <= curlen) return s;
+    s = sdsMakeRoomFor(s,len-curlen);
+    if (s == NULL) return NULL;
+
+    /* Make sure added region doesn't contain garbage */
+    memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */
+    sdssetlen(s, len);
+    return s;
+}
+
+/* Append the specified binary-safe string pointed by 't' of 'len' bytes to the
+ * end of the specified sds string 's'.
+ *
+ * After the call, the passed sds string is no longer valid and all the
+ * references must be substituted with the new pointer returned by the call. */
+sds sdscatlen(sds s, const void *t, size_t len) {
+    size_t curlen = sdslen(s);
+
+    s = sdsMakeRoomFor(s,len);
+    if (s == NULL) return NULL;
+    memcpy(s+curlen, t, len);
+    sdssetlen(s, curlen+len);
+    s[curlen+len] = '\0';
+    return s;
+}
+
+/* Append the specified null termianted C string to the sds string 's'.
+ *
+ * After the call, the passed sds string is no longer valid and all the
+ * references must be substituted with the new pointer returned by the call. */
+sds sdscat(sds s, const char *t) {
+    return sdscatlen(s, t, strlen(t));
+}
+
+/* Append the specified sds 't' to the existing sds 's'.
+ *
+ * After the call, the modified sds string is no longer valid and all the
+ * references must be substituted with the new pointer returned by the call. */
+sds sdscatsds(sds s, const sds t) {
+    return sdscatlen(s, t, sdslen(t));
+}
+
+/* Destructively modify the sds string 's' to hold the specified binary
+ * safe string pointed by 't' of length 'len' bytes. */
+sds sdscpylen(sds s, const char *t, size_t len) {
+    if (sdsalloc(s) < len) {
+        s = sdsMakeRoomFor(s,len-sdslen(s));
+        if (s == NULL) return NULL;
+    }
+    memcpy(s, t, len);
+    s[len] = '\0';
+    sdssetlen(s, len);
+    return s;
+}
+
+/* Like sdscpylen() but 't' must be a null-termined string so that the length
+ * of the string is obtained with strlen(). */
+sds sdscpy(sds s, const char *t) {
+    return sdscpylen(s, t, strlen(t));
+}
+
+/* Helper for sdscatlonglong() doing the actual number -> string
+ * conversion. 's' must point to a string with room for at least
+ * SDS_LLSTR_SIZE bytes.
+ *
+ * The function returns the length of the null-terminated string
+ * representation stored at 's'. */
+#define SDS_LLSTR_SIZE 21
+int sdsll2str(char *s, long long value) {
+    char *p, aux;
+    unsigned long long v;
+    size_t l;
+
+    /* Generate the string representation, this method produces
+     * an reversed string. */
+    v = (value < 0) ? -value : value;
+    p = s;
+    do {
+        *p++ = '0'+(v%10);
+        v /= 10;
+    } while(v);
+    if (value < 0) *p++ = '-';
+
+    /* Compute length and add null term. */
+    l = p-s;
+    *p = '\0';
+
+    /* Reverse the string. */
+    p--;
+    while(s < p) {
+        aux = *s;
+        *s = *p;
+        *p = aux;
+        s++;
+        p--;
+    }
+    return l;
+}
+
+/* Identical sdsll2str(), but for unsigned long long type. */
+int sdsull2str(char *s, unsigned long long v) {
+    char *p, aux;
+    size_t l;
+
+    /* Generate the string representation, this method produces
+     * an reversed string. */
+    p = s;
+    do {
+        *p++ = '0'+(v%10);
+        v /= 10;
+    } while(v);
+
+    /* Compute length and add null term. */
+    l = p-s;
+    *p = '\0';
+
+    /* Reverse the string. */
+    p--;
+    while(s < p) {
+        aux = *s;
+        *s = *p;
+        *p = aux;
+        s++;
+        p--;
+    }
+    return l;
+}
+
+/* Create an sds string from a long long value. It is much faster than:
+ *
+ * sdscatprintf(sdsempty(),"%lld\n", value);
+ */
+sds sdsfromlonglong(long long value) {
+    char buf[SDS_LLSTR_SIZE];
+    int len = sdsll2str(buf,value);
+
+    return sdsnewlen(buf,len);
+}
+
+/* Like sdscatprintf() but gets va_list instead of being variadic. */
+sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
+    va_list cpy;
+    char staticbuf[1024], *buf = staticbuf, *t;
+    size_t buflen = strlen(fmt)*2;
+
+    /* We try to start using a static buffer for speed.
+     * If not possible we revert to heap allocation. */
+    if (buflen > sizeof(staticbuf)) {
+        buf = s_malloc(buflen);
+        if (buf == NULL) return NULL;
+    } else {
+        buflen = sizeof(staticbuf);
+    }
+
+    /* Try with buffers two times bigger every time we fail to
+     * fit the string in the current buffer size. */
+    while(1) {
+        buf[buflen-2] = '\0';
+        va_copy(cpy,ap);
+        vsnprintf(buf, buflen, fmt, cpy);
+        va_end(cpy);
+        if (buf[buflen-2] != '\0') {
+            if (buf != staticbuf) s_free(buf);
+            buflen *= 2;
+            buf = s_malloc(buflen);
+            if (buf == NULL) return NULL;
+            continue;
+        }
+        break;
+    }
+
+    /* Finally concat the obtained string to the SDS string and return it. */
+    t = sdscat(s, buf);
+    if (buf != staticbuf) s_free(buf);
+    return t;
+}
+
+/* Append to the sds string 's' a string obtained using printf-alike format
+ * specifier.
+ *
+ * After the call, the modified sds string is no longer valid and all the
+ * references must be substituted with the new pointer returned by the call.
+ *
+ * Example:
+ *
+ * s = sdsnew("Sum is: ");
+ * s = sdscatprintf(s,"%d+%d = %d",a,b,a+b).
+ *
+ * Often you need to create a string from scratch with the printf-alike
+ * format. When this is the need, just use sdsempty() as the target string:
+ *
+ * s = sdscatprintf(sdsempty(), "... your format ...", args);
+ */
+sds sdscatprintf(sds s, const char *fmt, ...) {
+    va_list ap;
+    char *t;
+    va_start(ap, fmt);
+    t = sdscatvprintf(s,fmt,ap);
+    va_end(ap);
+    return t;
+}
+
+/* This function is similar to sdscatprintf, but much faster as it does
+ * not rely on sprintf() family functions implemented by the libc that
+ * are often very slow. Moreover directly handling the sds string as
+ * new data is concatenated provides a performance improvement.
+ *
+ * However this function only handles an incompatible subset of printf-alike
+ * format specifiers:
+ *
+ * %s - C String
+ * %S - SDS string
+ * %i - signed int
+ * %I - 64 bit signed integer (long long, int64_t)
+ * %u - unsigned int
+ * %U - 64 bit unsigned integer (unsigned long long, uint64_t)
+ * %% - Verbatim "%" character.
+ */
+sds sdscatfmt(sds s, char const *fmt, ...) {
+    size_t initlen = sdslen(s);
+    const char *f = fmt;
+    long i;
+    va_list ap;
+
+    /* To avoid continuous reallocations, let's start with a buffer that
+     * can hold at least two times the format string itself. It's not the
+     * best heuristic but seems to work in practice. */
+    s = sdsMakeRoomFor(s, initlen + strlen(fmt)*2);
+    va_start(ap,fmt);
+    f = fmt;    /* Next format specifier byte to process. */
+    i = initlen; /* Position of the next byte to write to dest str. */
+    while(*f) {
+        char next, *str;
+        size_t l;
+        long long num;
+        unsigned long long unum;
+
+        /* Make sure there is always space for at least 1 char. */
+        if (sdsavail(s)==0) {
+            s = sdsMakeRoomFor(s,1);
+        }
+
+        switch(*f) {
+        case '%':
+            next = *(f+1);
+            f++;
+            switch(next) {
+            case 's':
+            case 'S':
+                str = va_arg(ap,char*);
+                l = (next == 's') ? strlen(str) : sdslen(str);
+                if (sdsavail(s) < l) {
+                    s = sdsMakeRoomFor(s,l);
+                }
+                memcpy(s+i,str,l);
+                sdsinclen(s,l);
+                i += l;
+                break;
+            case 'i':
+            case 'I':
+                if (next == 'i')
+                    num = va_arg(ap,int);
+                else
+                    num = va_arg(ap,long long);
+                {
+                    char buf[SDS_LLSTR_SIZE];
+                    l = sdsll2str(buf,num);
+                    if (sdsavail(s) < l) {
+                        s = sdsMakeRoomFor(s,l);
+                    }
+                    memcpy(s+i,buf,l);
+                    sdsinclen(s,l);
+                    i += l;
+                }
+                break;
+            case 'u':
+            case 'U':
+                if (next == 'u')
+                    unum = va_arg(ap,unsigned int);
+                else
+                    unum = va_arg(ap,unsigned long long);
+                {
+                    char buf[SDS_LLSTR_SIZE];
+                    l = sdsull2str(buf,unum);
+                    if (sdsavail(s) < l) {
+                        s = sdsMakeRoomFor(s,l);
+                    }
+                    memcpy(s+i,buf,l);
+                    sdsinclen(s,l);
+                    i += l;
+                }
+                break;
+            default: /* Handle %% and generally %<unknown>. */
+                s[i++] = next;
+                sdsinclen(s,1);
+                break;
+            }
+            break;
+        default:
+            s[i++] = *f;
+            sdsinclen(s,1);
+            break;
+        }
+        f++;
+    }
+    va_end(ap);
+
+    /* Add null-term */
+    s[i] = '\0';
+    return s;
+}
+
+/* Remove the part of the string from left and from right composed just of
+ * contiguous characters found in 'cset', that is a null terminted C string.
+ *
+ * After the call, the modified sds string is no longer valid and all the
+ * references must be substituted with the new pointer returned by the call.
+ *
+ * Example:
+ *
+ * s = sdsnew("AA...AA.a.aa.aHelloWorld     :::");
+ * s = sdstrim(s,"Aa. :");
+ * printf("%s\n", s);
+ *
+ * Output will be just "HelloWorld".
+ */
+sds sdstrim(sds s, const char *cset) {
+    char *start, *end, *sp, *ep;
+    size_t len;
+
+    sp = start = s;
+    ep = end = s+sdslen(s)-1;
+    while(sp <= end && strchr(cset, *sp)) sp++;
+    while(ep > sp && strchr(cset, *ep)) ep--;
+    len = (sp > ep) ? 0 : ((ep-sp)+1);
+    if (s != sp) memmove(s, sp, len);
+    s[len] = '\0';
+    sdssetlen(s,len);
+    return s;
+}
+
+/* Turn the string into a smaller (or equal) string containing only the
+ * substring specified by the 'start' and 'end' indexes.
+ *
+ * start and end can be negative, where -1 means the last character of the
+ * string, -2 the penultimate character, and so forth.
+ *
+ * The interval is inclusive, so the start and end characters will be part
+ * of the resulting string.
+ *
+ * The string is modified in-place.
+ *
+ * Example:
+ *
+ * s = sdsnew("Hello World");
+ * sdsrange(s,1,-1); => "ello World"
+ */
+void sdsrange(sds s, ssize_t start, ssize_t end) {
+    size_t newlen, len = sdslen(s);
+
+    if (len == 0) return;
+    if (start < 0) {
+        start = len+start;
+        if (start < 0) start = 0;
+    }
+    if (end < 0) {
+        end = len+end;
+        if (end < 0) end = 0;
+    }
+    newlen = (start > end) ? 0 : (end-start)+1;
+    if (newlen != 0) {
+        if (start >= (ssize_t)len) {
+            newlen = 0;
+        } else if (end >= (ssize_t)len) {
+            end = len-1;
+            newlen = (start > end) ? 0 : (end-start)+1;
+        }
+    } else {
+        start = 0;
+    }
+    if (start && newlen) memmove(s, s+start, newlen);
+    s[newlen] = 0;
+    sdssetlen(s,newlen);
+}
+
+/* Apply tolower() to every character of the sds string 's'. */
+void sdstolower(sds s) {
+    size_t len = sdslen(s), j;
+
+    for (j = 0; j < len; j++) s[j] = tolower(s[j]);
+}
+
+/* Apply toupper() to every character of the sds string 's'. */
+void sdstoupper(sds s) {
+    size_t len = sdslen(s), j;
+
+    for (j = 0; j < len; j++) s[j] = toupper(s[j]);
+}
+
+/* Compare two sds strings s1 and s2 with memcmp().
+ *
+ * Return value:
+ *
+ *     positive if s1 > s2.
+ *     negative if s1 < s2.
+ *     0 if s1 and s2 are exactly the same binary string.
+ *
+ * If two strings share exactly the same prefix, but one of the two has
+ * additional characters, the longer string is considered to be greater than
+ * the smaller one. */
+int sdscmp(const sds s1, const sds s2) {
+    size_t l1, l2, minlen;
+    int cmp;
+
+    l1 = sdslen(s1);
+    l2 = sdslen(s2);
+    minlen = (l1 < l2) ? l1 : l2;
+    cmp = memcmp(s1,s2,minlen);
+    if (cmp == 0) return l1>l2? 1: (l1<l2? -1: 0);
+    return cmp;
+}
+
+/* Split 's' with separator in 'sep'. An array
+ * of sds strings is returned. *count will be set
+ * by reference to the number of tokens returned.
+ *
+ * On out of memory, zero length string, zero length
+ * separator, NULL is returned.
+ *
+ * Note that 'sep' is able to split a string using
+ * a multi-character separator. For example
+ * sdssplit("foo_-_bar","_-_"); will return two
+ * elements "foo" and "bar".
+ *
+ * This version of the function is binary-safe but
+ * requires length arguments. sdssplit() is just the
+ * same function but for zero-terminated strings.
+ */
+sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count) {
+    int elements = 0, slots = 5;
+    long start = 0, j;
+    sds *tokens;
+
+    if (seplen < 1 || len < 0) return NULL;
+
+    tokens = s_malloc(sizeof(sds)*slots);
+    if (tokens == NULL) return NULL;
+
+    if (len == 0) {
+        *count = 0;
+        return tokens;
+    }
+    for (j = 0; j < (len-(seplen-1)); j++) {
+        /* make sure there is room for the next element and the final one */
+        if (slots < elements+2) {
+            sds *newtokens;
+
+            slots *= 2;
+            newtokens = s_realloc(tokens,sizeof(sds)*slots);
+            if (newtokens == NULL) goto cleanup;
+            tokens = newtokens;
+        }
+        /* search the separator */
+        if ((seplen == 1 && *(s+j) == sep[0]) || (memcmp(s+j,sep,seplen) == 0)) {
+            tokens[elements] = sdsnewlen(s+start,j-start);
+            if (tokens[elements] == NULL) goto cleanup;
+            elements++;
+            start = j+seplen;
+            j = j+seplen-1; /* skip the separator */
+        }
+    }
+    /* Add the final element. We are sure there is room in the tokens array. */
+    tokens[elements] = sdsnewlen(s+start,len-start);
+    if (tokens[elements] == NULL) goto cleanup;
+    elements++;
+    *count = elements;
+    return tokens;
+
+cleanup:
+    {
+        int i;
+        for (i = 0; i < elements; i++) sdsfree(tokens[i]);
+        s_free(tokens);
+        *count = 0;
+        return NULL;
+    }
+}
+
+/* Free the result returned by sdssplitlen(), or do nothing if 'tokens' is NULL. */
+void sdsfreesplitres(sds *tokens, int count) {
+    if (!tokens) return;
+    while(count--)
+        sdsfree(tokens[count]);
+    s_free(tokens);
+}
+
+/* Append to the sds string "s" an escaped string representation where
+ * all the non-printable characters (tested with isprint()) are turned into
+ * escapes in the form "\n\r\a...." or "\x<hex-number>".
+ *
+ * After the call, the modified sds string is no longer valid and all the
+ * references must be substituted with the new pointer returned by the call. */
+sds sdscatrepr(sds s, const char *p, size_t len) {
+    s = sdscatlen(s,"\"",1);
+    while(len--) {
+        switch(*p) {
+        case '\\':
+        case '"':
+            s = sdscatprintf(s,"\\%c",*p);
+            break;
+        case '\n': s = sdscatlen(s,"\\n",2); break;
+        case '\r': s = sdscatlen(s,"\\r",2); break;
+        case '\t': s = sdscatlen(s,"\\t",2); break;
+        case '\a': s = sdscatlen(s,"\\a",2); break;
+        case '\b': s = sdscatlen(s,"\\b",2); break;
+        default:
+            if (isprint(*p))
+                s = sdscatprintf(s,"%c",*p);
+            else
+                s = sdscatprintf(s,"\\x%02x",(unsigned char)*p);
+            break;
+        }
+        p++;
+    }
+    return sdscatlen(s,"\"",1);
+}
+
+/* Helper function for sdssplitargs() that returns non zero if 'c'
+ * is a valid hex digit. */
+int is_hex_digit(char c) {
+    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
+           (c >= 'A' && c <= 'F');
+}
+
+/* Helper function for sdssplitargs() that converts a hex digit into an
+ * integer from 0 to 15 */
+int hex_digit_to_int(char c) {
+    switch(c) {
+    case '0': return 0;
+    case '1': return 1;
+    case '2': return 2;
+    case '3': return 3;
+    case '4': return 4;
+    case '5': return 5;
+    case '6': return 6;
+    case '7': return 7;
+    case '8': return 8;
+    case '9': return 9;
+    case 'a': case 'A': return 10;
+    case 'b': case 'B': return 11;
+    case 'c': case 'C': return 12;
+    case 'd': case 'D': return 13;
+    case 'e': case 'E': return 14;
+    case 'f': case 'F': return 15;
+    default: return 0;
+    }
+}
+
+/* Split a line into arguments, where every argument can be in the
+ * following programming-language REPL-alike form:
+ *
+ * foo bar "newline are supported\n" and "\xff\x00otherstuff"
+ *
+ * The number of arguments is stored into *argc, and an array
+ * of sds is returned.
+ *
+ * The caller should free the resulting array of sds strings with
+ * sdsfreesplitres().
+ *
+ * Note that sdscatrepr() is able to convert back a string into
+ * a quoted string in the same format sdssplitargs() is able to parse.
+ *
+ * The function returns the allocated tokens on success, even when the
+ * input string is empty, or NULL if the input contains unbalanced
+ * quotes or closed quotes followed by non space characters
+ * as in: "foo"bar or "foo'
+ */
+sds *sdssplitargs(const char *line, int *argc) {
+    const char *p = line;
+    char *current = NULL;
+    char **vector = NULL;
+
+    *argc = 0;
+    while(1) {
+        /* skip blanks */
+        while(*p && isspace(*p)) p++;
+        if (*p) {
+            /* get a token */
+            int inq=0;  /* set to 1 if we are in "quotes" */
+            int insq=0; /* set to 1 if we are in 'single quotes' */
+            int done=0;
+
+            if (current == NULL) current = sdsempty();
+            while(!done) {
+                if (inq) {
+                    if (*p == '\\' && *(p+1) == 'x' &&
+                                             is_hex_digit(*(p+2)) &&
+                                             is_hex_digit(*(p+3)))
+                    {
+                        unsigned char byte;
+
+                        byte = (hex_digit_to_int(*(p+2))*16)+
+                                hex_digit_to_int(*(p+3));
+                        current = sdscatlen(current,(char*)&byte,1);
+                        p += 3;
+                    } else if (*p == '\\' && *(p+1)) {
+                        char c;
+
+                        p++;
+                        switch(*p) {
+                        case 'n': c = '\n'; break;
+                        case 'r': c = '\r'; break;
+                        case 't': c = '\t'; break;
+                        case 'b': c = '\b'; break;
+                        case 'a': c = '\a'; break;
+                        default: c = *p; break;
+                        }
+                        current = sdscatlen(current,&c,1);
+                    } else if (*p == '"') {
+                        /* closing quote must be followed by a space or
+                         * nothing at all. */
+                        if (*(p+1) && !isspace(*(p+1))) goto err;
+                        done=1;
+                    } else if (!*p) {
+                        /* unterminated quotes */
+                        goto err;
+                    } else {
+                        current = sdscatlen(current,p,1);
+                    }
+                } else if (insq) {
+                    if (*p == '\\' && *(p+1) == '\'') {
+                        p++;
+                        current = sdscatlen(current,"'",1);
+                    } else if (*p == '\'') {
+                        /* closing quote must be followed by a space or
+                         * nothing at all. */
+                        if (*(p+1) && !isspace(*(p+1))) goto err;
+                        done=1;
+                    } else if (!*p) {
+                        /* unterminated quotes */
+                        goto err;
+                    } else {
+                        current = sdscatlen(current,p,1);
+                    }
+                } else {
+                    switch(*p) {
+                    case ' ':
+                    case '\n':
+                    case '\r':
+                    case '\t':
+                    case '\0':
+                        done=1;
+                        break;
+                    case '"':
+                        inq=1;
+                        break;
+                    case '\'':
+                        insq=1;
+                        break;
+                    default:
+                        current = sdscatlen(current,p,1);
+                        break;
+                    }
+                }
+                if (*p) p++;
+            }
+            /* add the token to the vector */
+            vector = s_realloc(vector,((*argc)+1)*sizeof(char*));
+            vector[*argc] = current;
+            (*argc)++;
+            current = NULL;
+        } else {
+            /* Even on empty input string return something not NULL. */
+            if (vector == NULL) vector = s_malloc(sizeof(void*));
+            return vector;
+        }
+    }
+
+err:
+    while((*argc)--)
+        sdsfree(vector[*argc]);
+    s_free(vector);
+    if (current) sdsfree(current);
+    *argc = 0;
+    return NULL;
+}
+
+/* Modify the string substituting all the occurrences of the set of
+ * characters specified in the 'from' string to the corresponding character
+ * in the 'to' array.
+ *
+ * For instance: sdsmapchars(mystring, "ho", "01", 2)
+ * will have the effect of turning the string "hello" into "0ell1".
+ *
+ * The function returns the sds string pointer, that is always the same
+ * as the input pointer since no resize is needed. */
+sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) {
+    size_t j, i, l = sdslen(s);
+
+    for (j = 0; j < l; j++) {
+        for (i = 0; i < setlen; i++) {
+            if (s[j] == from[i]) {
+                s[j] = to[i];
+                break;
+            }
+        }
+    }
+    return s;
+}
+
+/* Join an array of C strings using the specified separator (also a C string).
+ * Returns the result as an sds string. */
+sds sdsjoin(char **argv, int argc, char *sep) {
+    sds join = sdsempty();
+    int j;
+
+    for (j = 0; j < argc; j++) {
+        join = sdscat(join, argv[j]);
+        if (j != argc-1) join = sdscat(join,sep);
+    }
+    return join;
+}
+
+/* Like sdsjoin, but joins an array of SDS strings. */
+sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen) {
+    sds join = sdsempty();
+    int j;
+
+    for (j = 0; j < argc; j++) {
+        join = sdscatsds(join, argv[j]);
+        if (j != argc-1) join = sdscatlen(join,sep,seplen);
+    }
+    return join;
+}
+
+/* Wrappers to the allocators used by SDS. Note that SDS will actually
+ * just use the macros defined into sdsalloc.h in order to avoid to pay
+ * the overhead of function calls. Here we define these wrappers only for
+ * the programs SDS is linked to, if they want to touch the SDS internals
+ * even if they use a different allocator. */
+void *sds_malloc(size_t size) { return s_malloc(size); }
+void *sds_realloc(void *ptr, size_t size) { return s_realloc(ptr,size); }
+void sds_free(void *ptr) { s_free(ptr); }
+
+#if defined(SDS_TEST_MAIN)
+#include <stdio.h>
+#include "testhelp.h"
+#include "limits.h"
+
+#define UNUSED(x) (void)(x)
+int sdsTest(void) {
+    {
+        sds x = sdsnew("foo"), y;
+
+        test_cond("Create a string and obtain the length",
+            sdslen(x) == 3 && memcmp(x,"foo\0",4) == 0)
+
+        sdsfree(x);
+        x = sdsnewlen("foo",2);
+        test_cond("Create a string with specified length",
+            sdslen(x) == 2 && memcmp(x,"fo\0",3) == 0)
+
+        x = sdscat(x,"bar");
+        test_cond("Strings concatenation",
+            sdslen(x) == 5 && memcmp(x,"fobar\0",6) == 0);
+
+        x = sdscpy(x,"a");
+        test_cond("sdscpy() against an originally longer string",
+            sdslen(x) == 1 && memcmp(x,"a\0",2) == 0)
+
+        x = sdscpy(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk");
+        test_cond("sdscpy() against an originally shorter string",
+            sdslen(x) == 33 &&
+            memcmp(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk\0",33) == 0)
+
+        sdsfree(x);
+        x = sdscatprintf(sdsempty(),"%d",123);
+        test_cond("sdscatprintf() seems working in the base case",
+            sdslen(x) == 3 && memcmp(x,"123\0",4) == 0)
+
+        sdsfree(x);
+        x = sdsnew("--");
+        x = sdscatfmt(x, "Hello %s World %I,%I--", "Hi!", LLONG_MIN,LLONG_MAX);
+        test_cond("sdscatfmt() seems working in the base case",
+            sdslen(x) == 60 &&
+            memcmp(x,"--Hello Hi! World -9223372036854775808,"
+                     "9223372036854775807--",60) == 0)
+        printf("[%s]\n",x);
+
+        sdsfree(x);
+        x = sdsnew("--");
+        x = sdscatfmt(x, "%u,%U--", UINT_MAX, ULLONG_MAX);
+        test_cond("sdscatfmt() seems working with unsigned numbers",
+            sdslen(x) == 35 &&
+            memcmp(x,"--4294967295,18446744073709551615--",35) == 0)
+
+        sdsfree(x);
+        x = sdsnew(" x ");
+        sdstrim(x," x");
+        test_cond("sdstrim() works when all chars match",
+            sdslen(x) == 0)
+
+        sdsfree(x);
+        x = sdsnew(" x ");
+        sdstrim(x," ");
+        test_cond("sdstrim() works when a single char remains",
+            sdslen(x) == 1 && x[0] == 'x')
+
+        sdsfree(x);
+        x = sdsnew("xxciaoyyy");
+        sdstrim(x,"xy");
+        test_cond("sdstrim() correctly trims characters",
+            sdslen(x) == 4 && memcmp(x,"ciao\0",5) == 0)
+
+        y = sdsdup(x);
+        sdsrange(y,1,1);
+        test_cond("sdsrange(...,1,1)",
+            sdslen(y) == 1 && memcmp(y,"i\0",2) == 0)
+
+        sdsfree(y);
+        y = sdsdup(x);
+        sdsrange(y,1,-1);
+        test_cond("sdsrange(...,1,-1)",
+            sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0)
+
+        sdsfree(y);
+        y = sdsdup(x);
+        sdsrange(y,-2,-1);
+        test_cond("sdsrange(...,-2,-1)",
+            sdslen(y) == 2 && memcmp(y,"ao\0",3) == 0)
+
+        sdsfree(y);
+        y = sdsdup(x);
+        sdsrange(y,2,1);
+        test_cond("sdsrange(...,2,1)",
+            sdslen(y) == 0 && memcmp(y,"\0",1) == 0)
+
+        sdsfree(y);
+        y = sdsdup(x);
+        sdsrange(y,1,100);
+        test_cond("sdsrange(...,1,100)",
+            sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0)
+
+        sdsfree(y);
+        y = sdsdup(x);
+        sdsrange(y,100,100);
+        test_cond("sdsrange(...,100,100)",
+            sdslen(y) == 0 && memcmp(y,"\0",1) == 0)
+
+        sdsfree(y);
+        sdsfree(x);
+        x = sdsnew("foo");
+        y = sdsnew("foa");
+        test_cond("sdscmp(foo,foa)", sdscmp(x,y) > 0)
+
+        sdsfree(y);
+        sdsfree(x);
+        x = sdsnew("bar");
+        y = sdsnew("bar");
+        test_cond("sdscmp(bar,bar)", sdscmp(x,y) == 0)
+
+        sdsfree(y);
+        sdsfree(x);
+        x = sdsnew("aar");
+        y = sdsnew("bar");
+        test_cond("sdscmp(bar,bar)", sdscmp(x,y) < 0)
+
+        sdsfree(y);
+        sdsfree(x);
+        x = sdsnewlen("\a\n\0foo\r",7);
+        y = sdscatrepr(sdsempty(),x,sdslen(x));
+        test_cond("sdscatrepr(...data...)",
+            memcmp(y,"\"\\a\\n\\x00foo\\r\"",15) == 0)
+
+        {
+            unsigned int oldfree;
+            char *p;
+            int step = 10, j, i;
+
+            sdsfree(x);
+            sdsfree(y);
+            x = sdsnew("0");
+            test_cond("sdsnew() free/len buffers", sdslen(x) == 1 && sdsavail(x) == 0);
+
+            /* Run the test a few times in order to hit the first two
+             * SDS header types. */
+            for (i = 0; i < 10; i++) {
+                int oldlen = sdslen(x);
+                x = sdsMakeRoomFor(x,step);
+                int type = x[-1]&SDS_TYPE_MASK;
+
+                test_cond("sdsMakeRoomFor() len", sdslen(x) == oldlen);
+                if (type != SDS_TYPE_5) {
+                    test_cond("sdsMakeRoomFor() free", sdsavail(x) >= step);
+                    oldfree = sdsavail(x);
+                }
+                p = x+oldlen;
+                for (j = 0; j < step; j++) {
+                    p[j] = 'A'+j;
+                }
+                sdsIncrLen(x,step);
+            }
+            test_cond("sdsMakeRoomFor() content",
+                memcmp("0ABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJABCDEFGHIJ",x,101) == 0);
+            test_cond("sdsMakeRoomFor() final length",sdslen(x)==101);
+
+            sdsfree(x);
+        }
+    }
+    test_report()
+    return 0;
+}
+#endif
+
+#ifdef SDS_TEST_MAIN
+int main(void) {
+    return sdsTest();
+}
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/sds.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/sds.h
new file mode 100644
index 0000000000000000000000000000000000000000..adcc12c0a7646d2c88a796ad5591931017140999
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/sds.h
@@ -0,0 +1,274 @@
+/* SDSLib 2.0 -- A C dynamic strings library
+ *
+ * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2015, Oran Agra
+ * Copyright (c) 2015, Redis Labs, Inc
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __SDS_H
+#define __SDS_H
+
+#define SDS_MAX_PREALLOC (1024*1024)
+extern const char *SDS_NOINIT;
+
+#include <sys/types.h>
+#include <stdarg.h>
+#include <stdint.h>
+
+typedef char *sds;
+
+/* Note: sdshdr5 is never used, we just access the flags byte directly.
+ * However is here to document the layout of type 5 SDS strings. */
+struct __attribute__ ((__packed__)) sdshdr5 {
+    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
+    char buf[];
+};
+struct __attribute__ ((__packed__)) sdshdr8 {
+    uint8_t len; /* used */
+    uint8_t alloc; /* excluding the header and null terminator */
+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
+    char buf[];
+};
+struct __attribute__ ((__packed__)) sdshdr16 {
+    uint16_t len; /* used */
+    uint16_t alloc; /* excluding the header and null terminator */
+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
+    char buf[];
+};
+struct __attribute__ ((__packed__)) sdshdr32 {
+    uint32_t len; /* used */
+    uint32_t alloc; /* excluding the header and null terminator */
+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
+    char buf[];
+};
+struct __attribute__ ((__packed__)) sdshdr64 {
+    uint64_t len; /* used */
+    uint64_t alloc; /* excluding the header and null terminator */
+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
+    char buf[];
+};
+
+#define SDS_TYPE_5  0
+#define SDS_TYPE_8  1
+#define SDS_TYPE_16 2
+#define SDS_TYPE_32 3
+#define SDS_TYPE_64 4
+#define SDS_TYPE_MASK 7
+#define SDS_TYPE_BITS 3
+#define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));
+#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
+#define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)
+
+static inline size_t sdslen(const sds s) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            return SDS_TYPE_5_LEN(flags);
+        case SDS_TYPE_8:
+            return SDS_HDR(8,s)->len;
+        case SDS_TYPE_16:
+            return SDS_HDR(16,s)->len;
+        case SDS_TYPE_32:
+            return SDS_HDR(32,s)->len;
+        case SDS_TYPE_64:
+            return SDS_HDR(64,s)->len;
+    }
+    return 0;
+}
+
+static inline size_t sdsavail(const sds s) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5: {
+            return 0;
+        }
+        case SDS_TYPE_8: {
+            SDS_HDR_VAR(8,s);
+            return sh->alloc - sh->len;
+        }
+        case SDS_TYPE_16: {
+            SDS_HDR_VAR(16,s);
+            return sh->alloc - sh->len;
+        }
+        case SDS_TYPE_32: {
+            SDS_HDR_VAR(32,s);
+            return sh->alloc - sh->len;
+        }
+        case SDS_TYPE_64: {
+            SDS_HDR_VAR(64,s);
+            return sh->alloc - sh->len;
+        }
+    }
+    return 0;
+}
+
+static inline void sdssetlen(sds s, size_t newlen) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            {
+                unsigned char *fp = ((unsigned char*)s)-1;
+                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
+            }
+            break;
+        case SDS_TYPE_8:
+            SDS_HDR(8,s)->len = newlen;
+            break;
+        case SDS_TYPE_16:
+            SDS_HDR(16,s)->len = newlen;
+            break;
+        case SDS_TYPE_32:
+            SDS_HDR(32,s)->len = newlen;
+            break;
+        case SDS_TYPE_64:
+            SDS_HDR(64,s)->len = newlen;
+            break;
+    }
+}
+
+static inline void sdsinclen(sds s, size_t inc) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            {
+                unsigned char *fp = ((unsigned char*)s)-1;
+                unsigned char newlen = SDS_TYPE_5_LEN(flags)+inc;
+                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
+            }
+            break;
+        case SDS_TYPE_8:
+            SDS_HDR(8,s)->len += inc;
+            break;
+        case SDS_TYPE_16:
+            SDS_HDR(16,s)->len += inc;
+            break;
+        case SDS_TYPE_32:
+            SDS_HDR(32,s)->len += inc;
+            break;
+        case SDS_TYPE_64:
+            SDS_HDR(64,s)->len += inc;
+            break;
+    }
+}
+
+/* sdsalloc() = sdsavail() + sdslen() */
+static inline size_t sdsalloc(const sds s) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            return SDS_TYPE_5_LEN(flags);
+        case SDS_TYPE_8:
+            return SDS_HDR(8,s)->alloc;
+        case SDS_TYPE_16:
+            return SDS_HDR(16,s)->alloc;
+        case SDS_TYPE_32:
+            return SDS_HDR(32,s)->alloc;
+        case SDS_TYPE_64:
+            return SDS_HDR(64,s)->alloc;
+    }
+    return 0;
+}
+
+static inline void sdssetalloc(sds s, size_t newlen) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            /* Nothing to do, this type has no total allocation info. */
+            break;
+        case SDS_TYPE_8:
+            SDS_HDR(8,s)->alloc = newlen;
+            break;
+        case SDS_TYPE_16:
+            SDS_HDR(16,s)->alloc = newlen;
+            break;
+        case SDS_TYPE_32:
+            SDS_HDR(32,s)->alloc = newlen;
+            break;
+        case SDS_TYPE_64:
+            SDS_HDR(64,s)->alloc = newlen;
+            break;
+    }
+}
+
+sds sdsnewlen(const void *init, size_t initlen);
+sds sdsnew(const char *init);
+sds sdsempty(void);
+sds sdsdup(const sds s);
+void sdsfree(sds s);
+sds sdsgrowzero(sds s, size_t len);
+sds sdscatlen(sds s, const void *t, size_t len);
+sds sdscat(sds s, const char *t);
+sds sdscatsds(sds s, const sds t);
+sds sdscpylen(sds s, const char *t, size_t len);
+sds sdscpy(sds s, const char *t);
+
+sds sdscatvprintf(sds s, const char *fmt, va_list ap);
+#ifdef __GNUC__
+sds sdscatprintf(sds s, const char *fmt, ...)
+    __attribute__((format(printf, 2, 3)));
+#else
+sds sdscatprintf(sds s, const char *fmt, ...);
+#endif
+
+sds sdscatfmt(sds s, char const *fmt, ...);
+sds sdstrim(sds s, const char *cset);
+void sdsrange(sds s, ssize_t start, ssize_t end);
+void sdsupdatelen(sds s);
+void sdsclear(sds s);
+int sdscmp(const sds s1, const sds s2);
+sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count);
+void sdsfreesplitres(sds *tokens, int count);
+void sdstolower(sds s);
+void sdstoupper(sds s);
+sds sdsfromlonglong(long long value);
+sds sdscatrepr(sds s, const char *p, size_t len);
+sds *sdssplitargs(const char *line, int *argc);
+sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen);
+sds sdsjoin(char **argv, int argc, char *sep);
+sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen);
+
+/* Low level functions exposed to the user API */
+sds sdsMakeRoomFor(sds s, size_t addlen);
+void sdsIncrLen(sds s, ssize_t incr);
+sds sdsRemoveFreeSpace(sds s);
+size_t sdsAllocSize(sds s);
+void *sdsAllocPtr(sds s);
+
+/* Export the allocator used by SDS to the program using SDS.
+ * Sometimes the program SDS is linked to, may use a different set of
+ * allocators, but may want to allocate or free things that SDS will
+ * respectively free or allocate. */
+void *sds_malloc(size_t size);
+void *sds_realloc(void *ptr, size_t size);
+void sds_free(void *ptr);
+
+#ifdef REDIS_TEST
+int sdsTest(int argc, char *argv[]);
+#endif
+
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/sdsalloc.h b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/sdsalloc.h
new file mode 100644
index 0000000000000000000000000000000000000000..0448c89a0639ec0df97a2f1265d2a4f6460abe15
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/sdsalloc.h
@@ -0,0 +1,46 @@
+/* SDSLib 2.0 -- A C dynamic strings library
+ *
+ * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2015, Redis Labs, Inc
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* SDS allocator selection.
+ *
+ * This file is used in order to change the SDS allocator at compile time.
+ * Just define the following defines to what you want to use. Also add
+ * the include of your alternate allocator if needed (not needed in order
+ * to use the default libc allocator). */
+
+#ifndef __SDS_ALLOC_H__
+#define __SDS_ALLOC_H__
+
+#define s_malloc malloc
+#define s_realloc realloc
+#define s_free free
+
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeCache.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeCache.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b134604a9393c331f1b826888ba8f7138c45c2f5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeCache.txt
@@ -0,0 +1,117 @@
+# This is the CMakeCache file.
+# For build in directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild
+# It was generated by CMake: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+# You can edit this file to change values found and used by cmake.
+# If you do not want to change any of the values, simply exit the editor.
+# If you do want to change a value, simply edit, save, and exit the editor.
+# The syntax for the file is as follows:
+# KEY:TYPE=VALUE
+# KEY is the name of a variable in the cache.
+# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
+# VALUE is the current value for the KEY.
+
+########################
+# EXTERNAL cache entries
+########################
+
+//Enable/Disable color output during build.
+CMAKE_COLOR_MAKEFILE:BOOL=ON
+
+//Enable/Disable output of compile commands during generation.
+CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=
+
+//Value Computed by CMake.
+CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/pkgRedirects
+
+//Install path prefix, prepended onto install directories.
+CMAKE_INSTALL_PREFIX:PATH=/usr/local
+
+//No help, variable specified on the command line.
+CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/gmake
+
+//Value Computed by CMake
+CMAKE_PROJECT_DESCRIPTION:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_HOMEPAGE_URL:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_NAME:STATIC=gguflib-populate
+
+//If set, runtime paths are not added when installing shared libraries,
+// but are added when building.
+CMAKE_SKIP_INSTALL_RPATH:BOOL=NO
+
+//If set, runtime paths are not added when using shared libraries.
+CMAKE_SKIP_RPATH:BOOL=NO
+
+//If this value is on, makefiles will be generated without the
+// .SILENT directive, and all commands will be echoed to the console
+// during the make.  This is useful for debugging only. With Visual
+// Studio IDE projects all commands are done without /nologo.
+CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE
+
+//Value Computed by CMake
+gguflib-populate_BINARY_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild
+
+//Value Computed by CMake
+gguflib-populate_IS_TOP_LEVEL:STATIC=ON
+
+//Value Computed by CMake
+gguflib-populate_SOURCE_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild
+
+
+########################
+# INTERNAL cache entries
+########################
+
+//This is the directory where this CMakeCache.txt was created
+CMAKE_CACHEFILE_DIR:INTERNAL=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild
+//Major version of cmake used to create the current loaded cache
+CMAKE_CACHE_MAJOR_VERSION:INTERNAL=4
+//Minor version of cmake used to create the current loaded cache
+CMAKE_CACHE_MINOR_VERSION:INTERNAL=0
+//Patch version of cmake used to create the current loaded cache
+CMAKE_CACHE_PATCH_VERSION:INTERNAL=3
+//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
+CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
+//Path to CMake executable.
+CMAKE_COMMAND:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+//Path to cpack program executable.
+CMAKE_CPACK_COMMAND:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cpack
+//Path to ctest program executable.
+CMAKE_CTEST_COMMAND:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/ctest
+//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS
+CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1
+//Name of external makefile project generator.
+CMAKE_EXTRA_GENERATOR:INTERNAL=
+//Name of generator.
+CMAKE_GENERATOR:INTERNAL=Unix Makefiles
+//Generator instance identifier.
+CMAKE_GENERATOR_INSTANCE:INTERNAL=
+//Name of generator platform.
+CMAKE_GENERATOR_PLATFORM:INTERNAL=
+//Name of generator toolset.
+CMAKE_GENERATOR_TOOLSET:INTERNAL=
+//Source directory with the top level CMakeLists.txt file for this
+// project
+CMAKE_HOME_DIRECTORY:INTERNAL=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild
+//Install .so files without execute permission.
+CMAKE_INSTALL_SO_NO_EXE:INTERNAL=0
+//Name of CMakeLists files to read
+CMAKE_LIST_FILE_NAME:INTERNAL=CMakeLists.txt
+//number of local generators
+CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1
+//Platform information initialized
+CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1
+//Path to CMake installation.
+CMAKE_ROOT:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0
+//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH
+CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SKIP_RPATH
+CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1
+//uname command
+CMAKE_UNAME:INTERNAL=/usr/bin/uname
+//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE
+CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/4.0.3/CMakeSystem.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/4.0.3/CMakeSystem.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..6ac4680931858770a602d316fb4a5f01540d588e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/4.0.3/CMakeSystem.cmake
@@ -0,0 +1,15 @@
+set(CMAKE_HOST_SYSTEM "Linux-4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_HOST_SYSTEM_NAME "Linux")
+set(CMAKE_HOST_SYSTEM_VERSION "4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
+
+
+
+set(CMAKE_SYSTEM "Linux-4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_SYSTEM_VERSION "4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_SYSTEM_PROCESSOR "x86_64")
+
+set(CMAKE_CROSSCOMPILING "FALSE")
+
+set(CMAKE_SYSTEM_LOADED 1)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/CMakeConfigureLog.yaml b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/CMakeConfigureLog.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..c5d89b2e6dd4fffd370ace469a89217b70d793f1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/CMakeConfigureLog.yaml
@@ -0,0 +1,11 @@
+
+---
+events:
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineSystem.cmake:205 (message)"
+      - "CMakeLists.txt:16 (project)"
+    message: |
+      The system is: Linux - 4.18.0-553.75.1.el8_10.x86_64 - x86_64
+...
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..aacc0f2bdb42adeae7355abeb963aba08f62ab5c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/CMakeRuleHashes.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/CMakeRuleHashes.txt
new file mode 100644
index 0000000000000000000000000000000000000000..90c0555935cdd5a7e0c7305638811db6a0ec5a91
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/CMakeRuleHashes.txt
@@ -0,0 +1,11 @@
+# Hashes of file build rules.
+5dfcd54356bdb1467194a34356d84978 CMakeFiles/gguflib-populate
+910cbfb4fc741594db24d21b033fb53a CMakeFiles/gguflib-populate-complete
+62fb8e4c91f8468dd32c92c37927c0bd gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-build
+a0e1cc005c53ebbbd52fb7d26de350fe gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-configure
+29d4f16b463fbabfe127d56fe68a2a52 gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-download
+fd6d126a107196e648ac22be559b6c5c gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-install
+e98560d9b1174ce6c56ff5717d11dbab gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-mkdir
+75625eeea4a4dbec2e4912edc4693853 gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch
+a821ed9647ce8f7e646a1f3b5af04895 gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-test
+8792a3304e6372861591d4a19c1afbd2 gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/InstallScripts.json b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/InstallScripts.json
new file mode 100644
index 0000000000000000000000000000000000000000..10ab3e4cc2c1c8221ee150fb0ad60eef8df88feb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/InstallScripts.json
@@ -0,0 +1,7 @@
+{
+	"InstallScripts" : 
+	[
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/cmake_install.cmake"
+	],
+	"Parallel" : false
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/Makefile.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/Makefile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..0e2a066c57795bb10eed65b679537a2961c78a30
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/Makefile.cmake
@@ -0,0 +1,52 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# The generator used is:
+set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles")
+
+# The top level Makefile was generated from the following files:
+set(CMAKE_MAKEFILE_DEPENDS
+  "CMakeCache.txt"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeGenericSystem.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeInitializeConfigs.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeSystemSpecificInformation.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeSystemSpecificInitialize.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/PatchInfo.txt.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/RepositoryInfo.txt.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/UpdateInfo.txt.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/cfgcmd.txt.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/gitclone.cmake.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/gitupdate.cmake.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/mkdirs.cmake.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/shared_internal_commands.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linux-Initialize.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linux.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/UnixPaths.cmake"
+  "CMakeFiles/4.0.3/CMakeSystem.cmake"
+  "CMakeLists.txt"
+  "gguflib-populate-prefix/tmp/gguflib-populate-mkdirs.cmake"
+  )
+
+# The corresponding makefile is:
+set(CMAKE_MAKEFILE_OUTPUTS
+  "Makefile"
+  "CMakeFiles/cmake.check_cache"
+  )
+
+# Byproducts of CMake generate step:
+set(CMAKE_MAKEFILE_PRODUCTS
+  "gguflib-populate-prefix/tmp/gguflib-populate-mkdirs.cmake"
+  "gguflib-populate-prefix/tmp/gguflib-populate-gitclone.cmake"
+  "gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitinfo.txt"
+  "gguflib-populate-prefix/tmp/gguflib-populate-gitupdate.cmake"
+  "gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update-info.txt"
+  "gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch-info.txt"
+  "gguflib-populate-prefix/tmp/gguflib-populate-cfgcmd.txt"
+  "CMakeFiles/CMakeDirectoryInformation.cmake"
+  )
+
+# Dependency information for all targets:
+set(CMAKE_DEPEND_INFO_FILES
+  "CMakeFiles/gguflib-populate.dir/DependInfo.cmake"
+  )
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/Makefile2 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/Makefile2
new file mode 100644
index 0000000000000000000000000000000000000000..6475b56764963fc6e7fbd7dc16d733d9a7858da2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/Makefile2
@@ -0,0 +1,122 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild
+
+#=============================================================================
+# Directory level rules for the build root directory
+
+# The main recursive "all" target.
+all: CMakeFiles/gguflib-populate.dir/all
+.PHONY : all
+
+# The main recursive "codegen" target.
+codegen: CMakeFiles/gguflib-populate.dir/codegen
+.PHONY : codegen
+
+# The main recursive "preinstall" target.
+preinstall:
+.PHONY : preinstall
+
+# The main recursive "clean" target.
+clean: CMakeFiles/gguflib-populate.dir/clean
+.PHONY : clean
+
+#=============================================================================
+# Target rules for target CMakeFiles/gguflib-populate.dir
+
+# All Build rule for target.
+CMakeFiles/gguflib-populate.dir/all:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/gguflib-populate.dir/build.make CMakeFiles/gguflib-populate.dir/depend
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/gguflib-populate.dir/build.make CMakeFiles/gguflib-populate.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9 "Built target gguflib-populate"
+.PHONY : CMakeFiles/gguflib-populate.dir/all
+
+# Build rule for subdir invocation for target.
+CMakeFiles/gguflib-populate.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles 9
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/gguflib-populate.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles 0
+.PHONY : CMakeFiles/gguflib-populate.dir/rule
+
+# Convenience name for target.
+gguflib-populate: CMakeFiles/gguflib-populate.dir/rule
+.PHONY : gguflib-populate
+
+# codegen rule for target.
+CMakeFiles/gguflib-populate.dir/codegen:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/gguflib-populate.dir/build.make CMakeFiles/gguflib-populate.dir/codegen
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9 "Finished codegen for target gguflib-populate"
+.PHONY : CMakeFiles/gguflib-populate.dir/codegen
+
+# clean rule for target.
+CMakeFiles/gguflib-populate.dir/clean:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/gguflib-populate.dir/build.make CMakeFiles/gguflib-populate.dir/clean
+.PHONY : CMakeFiles/gguflib-populate.dir/clean
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/TargetDirectories.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/TargetDirectories.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f0c3cca0494eb2da0b035a5f48a3d3a6431ab9a0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/TargetDirectories.txt
@@ -0,0 +1,3 @@
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/rebuild_cache.dir
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/cmake.check_cache b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/cmake.check_cache
new file mode 100644
index 0000000000000000000000000000000000000000..3dccd731726d7faa8b29d8d7dba3b981a53ca497
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/cmake.check_cache
@@ -0,0 +1 @@
+# This file is generated by cmake for dependency checking of the CMakeCache.txt file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate-complete b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate-complete
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/DependInfo.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/DependInfo.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..29b95a515e51db792a1019bc6c3419b6d78ec34c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/DependInfo.cmake
@@ -0,0 +1,22 @@
+
+# Consider dependencies only in project.
+set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
+
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  )
+
+# The set of dependency files which are needed:
+set(CMAKE_DEPENDS_DEPENDENCY_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/Labels.json b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/Labels.json
new file mode 100644
index 0000000000000000000000000000000000000000..1819afed8abd00e153bdba896f0bea23efa8749b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/Labels.json
@@ -0,0 +1,46 @@
+{
+	"sources" : 
+	[
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate-complete.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-build.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-configure.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-download.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-install.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-mkdir.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-test.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update.rule"
+		}
+	],
+	"target" : 
+	{
+		"labels" : 
+		[
+			"gguflib-populate"
+		],
+		"name" : "gguflib-populate"
+	}
+}
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/Labels.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/Labels.txt
new file mode 100644
index 0000000000000000000000000000000000000000..59ffeaa8cf814e9b2794500272bfcb598ef7f77b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/Labels.txt
@@ -0,0 +1,14 @@
+# Target labels
+ gguflib-populate
+# Source files and their labels
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate-complete.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-build.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-configure.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-download.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-install.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-mkdir.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-test.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update.rule
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/build.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/build.make
new file mode 100644
index 0000000000000000000000000000000000000000..810df7d14bc3b22b4f929c303549864e14a15f93
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/build.make
@@ -0,0 +1,162 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild
+
+# Utility rule file for gguflib-populate.
+
+# Include any custom commands dependencies for this target.
+include CMakeFiles/gguflib-populate.dir/compiler_depend.make
+
+# Include the progress variables for this target.
+include CMakeFiles/gguflib-populate.dir/progress.make
+
+CMakeFiles/gguflib-populate: CMakeFiles/gguflib-populate-complete
+
+CMakeFiles/gguflib-populate-complete: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-install
+CMakeFiles/gguflib-populate-complete: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-mkdir
+CMakeFiles/gguflib-populate-complete: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-download
+CMakeFiles/gguflib-populate-complete: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update
+CMakeFiles/gguflib-populate-complete: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch
+CMakeFiles/gguflib-populate-complete: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-configure
+CMakeFiles/gguflib-populate-complete: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-build
+CMakeFiles/gguflib-populate-complete: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-install
+CMakeFiles/gguflib-populate-complete: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-test
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Completed 'gguflib-populate'"
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E make_directory /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate-complete
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-done
+
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update:
+.PHONY : gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update
+
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-build: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-configure
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "No build step for 'gguflib-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-build
+
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-configure: gguflib-populate-prefix/tmp/gguflib-populate-cfgcmd.txt
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-configure: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "No configure step for 'gguflib-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-configure
+
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-download: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitinfo.txt
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-download: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-mkdir
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Performing download step (git clone) for 'gguflib-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE -P /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-gitclone.cmake
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-download
+
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-install: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "No install step for 'gguflib-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-install
+
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-mkdir:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_6) "Creating directories for 'gguflib-populate'"
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -Dcfgdir= -P /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-mkdirs.cmake
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-mkdir
+
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch-info.txt
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_7) "No patch step for 'gguflib-populate'"
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch
+
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update:
+.PHONY : gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update
+
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-test: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-install
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_8) "No test step for 'gguflib-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-test
+
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update: gguflib-populate-prefix/tmp/gguflib-populate-gitupdate.cmake
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update-info.txt
+gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-download
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_9) "Performing update step for 'gguflib-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -Dcan_fetch=YES -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE -P /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-gitupdate.cmake
+
+CMakeFiles/gguflib-populate.dir/codegen:
+.PHONY : CMakeFiles/gguflib-populate.dir/codegen
+
+gguflib-populate: CMakeFiles/gguflib-populate
+gguflib-populate: CMakeFiles/gguflib-populate-complete
+gguflib-populate: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-build
+gguflib-populate: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-configure
+gguflib-populate: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-download
+gguflib-populate: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-install
+gguflib-populate: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-mkdir
+gguflib-populate: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch
+gguflib-populate: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-test
+gguflib-populate: gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update
+gguflib-populate: CMakeFiles/gguflib-populate.dir/build.make
+.PHONY : gguflib-populate
+
+# Rule to build all files generated by this target.
+CMakeFiles/gguflib-populate.dir/build: gguflib-populate
+.PHONY : CMakeFiles/gguflib-populate.dir/build
+
+CMakeFiles/gguflib-populate.dir/clean:
+	$(CMAKE_COMMAND) -P CMakeFiles/gguflib-populate.dir/cmake_clean.cmake
+.PHONY : CMakeFiles/gguflib-populate.dir/clean
+
+CMakeFiles/gguflib-populate.dir/depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/DependInfo.cmake "--color=$(COLOR)"
+.PHONY : CMakeFiles/gguflib-populate.dir/depend
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/cmake_clean.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/cmake_clean.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ed657c2ccc9eb6f91359ffa08578bd9573833cb8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/cmake_clean.cmake
@@ -0,0 +1,17 @@
+file(REMOVE_RECURSE
+  "CMakeFiles/gguflib-populate"
+  "CMakeFiles/gguflib-populate-complete"
+  "gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-build"
+  "gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-configure"
+  "gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-download"
+  "gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-install"
+  "gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-mkdir"
+  "gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch"
+  "gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-test"
+  "gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang )
+  include(CMakeFiles/gguflib-populate.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/compiler_depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/compiler_depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..e967d3ad400aa6a1a0f44b19a6bf1bed4c1aefff
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/compiler_depend.make
@@ -0,0 +1,2 @@
+# Empty custom commands generated dependencies file for gguflib-populate.
+# This may be replaced when dependencies are built.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/compiler_depend.ts b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/compiler_depend.ts
new file mode 100644
index 0000000000000000000000000000000000000000..caf91a9ed0b1098e9f97d9b78873754e25279498
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/compiler_depend.ts
@@ -0,0 +1,2 @@
+# CMAKE generated file: DO NOT EDIT!
+# Timestamp file for custom commands dependencies management for gguflib-populate.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/progress.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/progress.make
new file mode 100644
index 0000000000000000000000000000000000000000..d4f6ce35d26a4136a4edb4873325a1cadb14ccfe
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/gguflib-populate.dir/progress.make
@@ -0,0 +1,10 @@
+CMAKE_PROGRESS_1 = 1
+CMAKE_PROGRESS_2 = 2
+CMAKE_PROGRESS_3 = 3
+CMAKE_PROGRESS_4 = 4
+CMAKE_PROGRESS_5 = 5
+CMAKE_PROGRESS_6 = 6
+CMAKE_PROGRESS_7 = 7
+CMAKE_PROGRESS_8 = 8
+CMAKE_PROGRESS_9 = 9
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..ec635144f60048986bc560c5576355344005e6e7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+9
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2bc9c87c1db349bf676814b882d41498ca3db73d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeLists.txt
@@ -0,0 +1,42 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION 4.0.3)
+
+# Reject any attempt to use a toolchain file. We must not use one because
+# we could be downloading it here. If the CMAKE_TOOLCHAIN_FILE environment
+# variable is set, the cache variable will have been initialized from it.
+unset(CMAKE_TOOLCHAIN_FILE CACHE)
+unset(ENV{CMAKE_TOOLCHAIN_FILE})
+
+# We name the project and the target for the ExternalProject_Add() call
+# to something that will highlight to the user what we are working on if
+# something goes wrong and an error message is produced.
+
+project(gguflib-populate NONE)
+
+
+# Pass through things we've already detected in the main project to avoid
+# paying the cost of redetecting them again in ExternalProject_Add()
+set(GIT_EXECUTABLE [==[/usr/bin/git]==])
+set(GIT_VERSION_STRING [==[2.51.0]==])
+set_property(GLOBAL PROPERTY _CMAKE_FindGit_GIT_EXECUTABLE_VERSION
+  [==[/usr/bin/git;2.51.0]==]
+)
+
+
+include(ExternalProject)
+ExternalProject_Add(gguflib-populate
+                     "UPDATE_DISCONNECTED" "False" "GIT_REPOSITORY" "https://github.com/antirez/gguf-tools/" "EXTERNALPROJECT_INTERNAL_ARGUMENT_SEPARATOR" "GIT_TAG" "8fa6eb65236618e28fd7710a0fba565f7faa1848"
+                    SOURCE_DIR          "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+                    BINARY_DIR          "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-build"
+                    CONFIGURE_COMMAND   ""
+                    BUILD_COMMAND       ""
+                    INSTALL_COMMAND     ""
+                    TEST_COMMAND        ""
+                    USES_TERMINAL_DOWNLOAD  YES
+                    USES_TERMINAL_UPDATE    YES
+                    USES_TERMINAL_PATCH     YES
+)
+
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..fc48619e8d07322eed3b93675be93d16962374d5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/Makefile
@@ -0,0 +1,162 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# The main all target
+all: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild//CMakeFiles/progress.marks
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles 0
+.PHONY : all
+
+# The main codegen target
+codegen: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild//CMakeFiles/progress.marks
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 codegen
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/CMakeFiles 0
+.PHONY : codegen
+
+# The main clean target
+clean:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+#=============================================================================
+# Target rules for targets named gguflib-populate
+
+# Build rule for target.
+gguflib-populate: cmake_check_build_system
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 gguflib-populate
+.PHONY : gguflib-populate
+
+# fast build rule for target.
+gguflib-populate/fast:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/gguflib-populate.dir/build.make CMakeFiles/gguflib-populate.dir/build
+.PHONY : gguflib-populate/fast
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... codegen"
+	@echo "... edit_cache"
+	@echo "... rebuild_cache"
+	@echo "... gguflib-populate"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..8a4e438c759e523a7b68961f4b5072921b4835fc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/cmake_install.cmake
@@ -0,0 +1,61 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/usr/local")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
+if(CMAKE_INSTALL_COMPONENT)
+  if(CMAKE_INSTALL_COMPONENT MATCHES "^[a-zA-Z0-9_.+-]+$")
+    set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt")
+  else()
+    string(MD5 CMAKE_INST_COMP_HASH "${CMAKE_INSTALL_COMPONENT}")
+    set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INST_COMP_HASH}.txt")
+    unset(CMAKE_INST_COMP_HASH)
+  endif()
+else()
+  set(CMAKE_INSTALL_MANIFEST "install_manifest.txt")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/${CMAKE_INSTALL_MANIFEST}"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-build b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-build
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-configure b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-configure
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-done b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-done
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-download b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-download
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitclone-lastrun.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitclone-lastrun.txt
new file mode 100644
index 0000000000000000000000000000000000000000..522eb1e748deaecd1931feb57f64d88da2dd3d80
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitclone-lastrun.txt
@@ -0,0 +1,15 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The download step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+method=git
+command=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake;-DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE;-P;/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-gitclone.cmake
+source_dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src
+work_dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps
+repository=https://github.com/antirez/gguf-tools/
+remote=origin
+init_submodules=TRUE
+recurse_submodules=--recursive
+submodules=
+CMP0097=NEW
+      
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitinfo.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitinfo.txt
new file mode 100644
index 0000000000000000000000000000000000000000..522eb1e748deaecd1931feb57f64d88da2dd3d80
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitinfo.txt
@@ -0,0 +1,15 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The download step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+method=git
+command=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake;-DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE;-P;/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-gitclone.cmake
+source_dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src
+work_dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps
+repository=https://github.com/antirez/gguf-tools/
+remote=origin
+init_submodules=TRUE
+recurse_submodules=--recursive
+submodules=
+CMP0097=NEW
+      
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-install b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-install
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-mkdir b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-mkdir
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch-info.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch-info.txt
new file mode 100644
index 0000000000000000000000000000000000000000..53e1e1e6854ba141183d4dc9c77325b48e4b99da
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-patch-info.txt
@@ -0,0 +1,6 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The update step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+command=
+work_dir=
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-test b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-test
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update-info.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update-info.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9a7681a54d90da87a1e20ee18760f178d77c8ce1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-update-info.txt
@@ -0,0 +1,7 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The patch step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+command (connected)=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake;-Dcan_fetch=YES;-DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE;-P;/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-gitupdate.cmake
+command (disconnected)=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake;-Dcan_fetch=NO;-DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE;-P;/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-gitupdate.cmake
+work_dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-cfgcmd.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-cfgcmd.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6a6ed5fd2a2f3671b44653100d811d1afbc218c1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-cfgcmd.txt
@@ -0,0 +1 @@
+cmd=''
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-gitclone.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-gitclone.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d15aa341f8011fb1e73bad15b11a99a044d5962a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-gitclone.cmake
@@ -0,0 +1,87 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+if(EXISTS "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitclone-lastrun.txt" AND EXISTS "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitinfo.txt" AND
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitclone-lastrun.txt" IS_NEWER_THAN "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitinfo.txt")
+  message(VERBOSE
+    "Avoiding repeated git clone, stamp file is up to date: "
+    "'/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitclone-lastrun.txt'"
+  )
+  return()
+endif()
+
+# Even at VERBOSE level, we don't want to see the commands executed, but
+# enabling them to be shown for DEBUG may be useful to help diagnose problems.
+cmake_language(GET_MESSAGE_LOG_LEVEL active_log_level)
+if(active_log_level MATCHES "DEBUG|TRACE")
+  set(maybe_show_command COMMAND_ECHO STDOUT)
+else()
+  set(maybe_show_command "")
+endif()
+
+execute_process(
+  COMMAND ${CMAKE_COMMAND} -E rm -rf "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+  RESULT_VARIABLE error_code
+  ${maybe_show_command}
+)
+if(error_code)
+  message(FATAL_ERROR "Failed to remove directory: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src'")
+endif()
+
+# try the clone 3 times in case there is an odd git clone issue
+set(error_code 1)
+set(number_of_tries 0)
+while(error_code AND number_of_tries LESS 3)
+  execute_process(
+    COMMAND "/usr/bin/git"
+            clone --no-checkout --config "advice.detachedHead=false" "https://github.com/antirez/gguf-tools/" "gguflib-src"
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps"
+    RESULT_VARIABLE error_code
+    ${maybe_show_command}
+  )
+  math(EXPR number_of_tries "${number_of_tries} + 1")
+endwhile()
+if(number_of_tries GREATER 1)
+  message(NOTICE "Had to git clone more than once: ${number_of_tries} times.")
+endif()
+if(error_code)
+  message(FATAL_ERROR "Failed to clone repository: 'https://github.com/antirez/gguf-tools/'")
+endif()
+
+execute_process(
+  COMMAND "/usr/bin/git"
+          checkout "8fa6eb65236618e28fd7710a0fba565f7faa1848" --
+  WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+  RESULT_VARIABLE error_code
+  ${maybe_show_command}
+)
+if(error_code)
+  message(FATAL_ERROR "Failed to checkout tag: '8fa6eb65236618e28fd7710a0fba565f7faa1848'")
+endif()
+
+set(init_submodules TRUE)
+if(init_submodules)
+  execute_process(
+    COMMAND "/usr/bin/git" 
+            submodule update --recursive --init 
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+    RESULT_VARIABLE error_code
+    ${maybe_show_command}
+  )
+endif()
+if(error_code)
+  message(FATAL_ERROR "Failed to update submodules in: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src'")
+endif()
+
+# Complete success, update the script-last-run stamp file:
+#
+execute_process(
+  COMMAND ${CMAKE_COMMAND} -E copy "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitinfo.txt" "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitclone-lastrun.txt"
+  RESULT_VARIABLE error_code
+  ${maybe_show_command}
+)
+if(error_code)
+  message(FATAL_ERROR "Failed to copy script-last-run stamp file: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/gguflib-populate-gitclone-lastrun.txt'")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-gitupdate.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-gitupdate.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..91440e0d19a0100a455aae3ba0ee7cd9b7029bf2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-gitupdate.cmake
@@ -0,0 +1,317 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+# Even at VERBOSE level, we don't want to see the commands executed, but
+# enabling them to be shown for DEBUG may be useful to help diagnose problems.
+cmake_language(GET_MESSAGE_LOG_LEVEL active_log_level)
+if(active_log_level MATCHES "DEBUG|TRACE")
+  set(maybe_show_command COMMAND_ECHO STDOUT)
+else()
+  set(maybe_show_command "")
+endif()
+
+function(do_fetch)
+  message(VERBOSE "Fetching latest from the remote origin")
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git fetch --tags --force "origin"
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+    COMMAND_ERROR_IS_FATAL LAST
+    ${maybe_show_command}
+  )
+endfunction()
+
+function(get_hash_for_ref ref out_var err_var)
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git rev-parse "${ref}^0"
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+    RESULT_VARIABLE error_code
+    OUTPUT_VARIABLE ref_hash
+    ERROR_VARIABLE error_msg
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+  if(error_code)
+    set(${out_var} "" PARENT_SCOPE)
+  else()
+    set(${out_var} "${ref_hash}" PARENT_SCOPE)
+  endif()
+  set(${err_var} "${error_msg}" PARENT_SCOPE)
+endfunction()
+
+get_hash_for_ref(HEAD head_sha error_msg)
+if(head_sha STREQUAL "")
+  message(FATAL_ERROR "Failed to get the hash for HEAD:\n${error_msg}")
+endif()
+
+if("${can_fetch}" STREQUAL "")
+  set(can_fetch "YES")
+endif()
+
+execute_process(
+  COMMAND "/usr/bin/git" --git-dir=.git show-ref "8fa6eb65236618e28fd7710a0fba565f7faa1848"
+  WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+  OUTPUT_VARIABLE show_ref_output
+)
+if(show_ref_output MATCHES "^[a-z0-9]+[ \\t]+refs/remotes/")
+  # Given a full remote/branch-name and we know about it already. Since
+  # branches can move around, we should always fetch, if permitted.
+  if(can_fetch)
+    do_fetch()
+  endif()
+  set(checkout_name "8fa6eb65236618e28fd7710a0fba565f7faa1848")
+
+elseif(show_ref_output MATCHES "^[a-z0-9]+[ \\t]+refs/tags/")
+  # Given a tag name that we already know about. We don't know if the tag we
+  # have matches the remote though (tags can move), so we should fetch. As a
+  # special case to preserve backward compatibility, if we are already at the
+  # same commit as the tag we hold locally, don't do a fetch and assume the tag
+  # hasn't moved on the remote.
+  # FIXME: We should provide an option to always fetch for this case
+  get_hash_for_ref("8fa6eb65236618e28fd7710a0fba565f7faa1848" tag_sha error_msg)
+  if(tag_sha STREQUAL head_sha)
+    message(VERBOSE "Already at requested tag: 8fa6eb65236618e28fd7710a0fba565f7faa1848")
+    return()
+  endif()
+
+  if(can_fetch)
+    do_fetch()
+  endif()
+  set(checkout_name "8fa6eb65236618e28fd7710a0fba565f7faa1848")
+
+elseif(show_ref_output MATCHES "^[a-z0-9]+[ \\t]+refs/heads/")
+  # Given a branch name without any remote and we already have a branch by that
+  # name. We might already have that branch checked out or it might be a
+  # different branch. It isn't fully safe to use a bare branch name without the
+  # remote, so do a fetch (if allowed) and replace the ref with one that
+  # includes the remote.
+  if(can_fetch)
+    do_fetch()
+  endif()
+  set(checkout_name "origin/8fa6eb65236618e28fd7710a0fba565f7faa1848")
+
+else()
+  get_hash_for_ref("8fa6eb65236618e28fd7710a0fba565f7faa1848" tag_sha error_msg)
+  if(tag_sha STREQUAL head_sha)
+    # Have the right commit checked out already
+    message(VERBOSE "Already at requested ref: ${tag_sha}")
+    return()
+
+  elseif(tag_sha STREQUAL "")
+    # We don't know about this ref yet, so we have no choice but to fetch.
+    if(NOT can_fetch)
+      message(FATAL_ERROR
+        "Requested git ref \"8fa6eb65236618e28fd7710a0fba565f7faa1848\" is not present locally, and not "
+        "allowed to contact remote due to UPDATE_DISCONNECTED setting."
+      )
+    endif()
+
+    # We deliberately swallow any error message at the default log level
+    # because it can be confusing for users to see a failed git command.
+    # That failure is being handled here, so it isn't an error.
+    if(NOT error_msg STREQUAL "")
+      message(DEBUG "${error_msg}")
+    endif()
+    do_fetch()
+    set(checkout_name "8fa6eb65236618e28fd7710a0fba565f7faa1848")
+
+  else()
+    # We have the commit, so we know we were asked to find a commit hash
+    # (otherwise it would have been handled further above), but we don't
+    # have that commit checked out yet. We don't need to fetch from the remote.
+    set(checkout_name "8fa6eb65236618e28fd7710a0fba565f7faa1848")
+    if(NOT error_msg STREQUAL "")
+      message(WARNING "${error_msg}")
+    endif()
+
+  endif()
+endif()
+
+set(git_update_strategy "REBASE")
+if(git_update_strategy STREQUAL "")
+  # Backward compatibility requires REBASE as the default behavior
+  set(git_update_strategy REBASE)
+endif()
+
+if(git_update_strategy MATCHES "^REBASE(_CHECKOUT)?$")
+  # Asked to potentially try to rebase first, maybe with fallback to checkout.
+  # We can't if we aren't already on a branch and we shouldn't if that local
+  # branch isn't tracking the one we want to checkout.
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git symbolic-ref -q HEAD
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+    OUTPUT_VARIABLE current_branch
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    # Don't test for an error. If this isn't a branch, we get a non-zero error
+    # code but empty output.
+  )
+
+  if(current_branch STREQUAL "")
+    # Not on a branch, checkout is the only sensible option since any rebase
+    # would always fail (and backward compatibility requires us to checkout in
+    # this situation)
+    set(git_update_strategy CHECKOUT)
+
+  else()
+    execute_process(
+      COMMAND "/usr/bin/git" --git-dir=.git for-each-ref "--format=%(upstream:short)" "${current_branch}"
+      WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+      OUTPUT_VARIABLE upstream_branch
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      COMMAND_ERROR_IS_FATAL ANY  # There is no error if no upstream is set
+    )
+    if(NOT upstream_branch STREQUAL checkout_name)
+      # Not safe to rebase when asked to checkout a different branch to the one
+      # we are tracking. If we did rebase, we could end up with arbitrary
+      # commits added to the ref we were asked to checkout if the current local
+      # branch happens to be able to rebase onto the target branch. There would
+      # be no error message and the user wouldn't know this was occurring.
+      set(git_update_strategy CHECKOUT)
+    endif()
+
+  endif()
+elseif(NOT git_update_strategy STREQUAL "CHECKOUT")
+  message(FATAL_ERROR "Unsupported git update strategy: ${git_update_strategy}")
+endif()
+
+
+# Check if stash is needed
+execute_process(
+  COMMAND "/usr/bin/git" --git-dir=.git status --porcelain
+  WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+  RESULT_VARIABLE error_code
+  OUTPUT_VARIABLE repo_status
+)
+if(error_code)
+  message(FATAL_ERROR "Failed to get the status")
+endif()
+string(LENGTH "${repo_status}" need_stash)
+
+# If not in clean state, stash changes in order to be able to perform a
+# rebase or checkout without losing those changes permanently
+if(need_stash)
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git stash save --quiet;--include-untracked
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+    COMMAND_ERROR_IS_FATAL ANY
+    ${maybe_show_command}
+  )
+endif()
+
+if(git_update_strategy STREQUAL "CHECKOUT")
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git checkout "${checkout_name}"
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+    COMMAND_ERROR_IS_FATAL ANY
+    ${maybe_show_command}
+  )
+else()
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git rebase "${checkout_name}"
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+    RESULT_VARIABLE error_code
+    OUTPUT_VARIABLE rebase_output
+    ERROR_VARIABLE  rebase_output
+  )
+  if(error_code)
+    # Rebase failed, undo the rebase attempt before continuing
+    execute_process(
+      COMMAND "/usr/bin/git" --git-dir=.git rebase --abort
+      WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+      ${maybe_show_command}
+    )
+
+    if(NOT git_update_strategy STREQUAL "REBASE_CHECKOUT")
+      # Not allowed to do a checkout as a fallback, so cannot proceed
+      if(need_stash)
+        execute_process(
+          COMMAND "/usr/bin/git" --git-dir=.git stash pop --index --quiet
+          WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+          ${maybe_show_command}
+          )
+      endif()
+      message(FATAL_ERROR "\nFailed to rebase in: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src'."
+                          "\nOutput from the attempted rebase follows:"
+                          "\n${rebase_output}"
+                          "\n\nYou will have to resolve the conflicts manually")
+    endif()
+
+    # Fall back to checkout. We create an annotated tag so that the user
+    # can manually inspect the situation and revert if required.
+    # We can't log the failed rebase output because MSVC sees it and
+    # intervenes, causing the build to fail even though it completes.
+    # Write it to a file instead.
+    string(TIMESTAMP tag_timestamp "%Y%m%dT%H%M%S" UTC)
+    set(tag_name _cmake_ExternalProject_moved_from_here_${tag_timestamp}Z)
+    set(error_log_file ${CMAKE_CURRENT_LIST_DIR}/rebase_error_${tag_timestamp}Z.log)
+    file(WRITE ${error_log_file} "${rebase_output}")
+    message(WARNING "Rebase failed, output has been saved to ${error_log_file}"
+                    "\nFalling back to checkout, previous commit tagged as ${tag_name}")
+    execute_process(
+      COMMAND "/usr/bin/git" --git-dir=.git tag -a
+              -m "ExternalProject attempting to move from here to ${checkout_name}"
+              ${tag_name}
+      WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+      COMMAND_ERROR_IS_FATAL ANY
+      ${maybe_show_command}
+    )
+
+    execute_process(
+      COMMAND "/usr/bin/git" --git-dir=.git checkout "${checkout_name}"
+      WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+      COMMAND_ERROR_IS_FATAL ANY
+      ${maybe_show_command}
+    )
+  endif()
+endif()
+
+if(need_stash)
+  # Put back the stashed changes
+  execute_process(
+    COMMAND "/usr/bin/git" --git-dir=.git stash pop --index --quiet
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+    RESULT_VARIABLE error_code
+    ${maybe_show_command}
+    )
+  if(error_code)
+    # Stash pop --index failed: Try again dropping the index
+    execute_process(
+      COMMAND "/usr/bin/git" --git-dir=.git reset --hard --quiet
+      WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+      ${maybe_show_command}
+    )
+    execute_process(
+      COMMAND "/usr/bin/git" --git-dir=.git stash pop --quiet
+      WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+      RESULT_VARIABLE error_code
+      ${maybe_show_command}
+    )
+    if(error_code)
+      # Stash pop failed: Restore previous state.
+      execute_process(
+        COMMAND "/usr/bin/git" --git-dir=.git reset --hard --quiet ${head_sha}
+        WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+        ${maybe_show_command}
+      )
+      execute_process(
+        COMMAND "/usr/bin/git" --git-dir=.git stash pop --index --quiet
+        WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+        ${maybe_show_command}
+      )
+      message(FATAL_ERROR "\nFailed to unstash changes in: '/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src'."
+                          "\nYou will have to resolve the conflicts manually")
+    endif()
+  endif()
+endif()
+
+set(init_submodules "TRUE")
+if(init_submodules)
+  execute_process(
+    COMMAND "/usr/bin/git"
+            --git-dir=.git 
+            submodule update --recursive --init 
+    WORKING_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src"
+    COMMAND_ERROR_IS_FATAL ANY
+    ${maybe_show_command}
+  )
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-mkdirs.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-mkdirs.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..5860e3b599282c06037f7fa559e7bd6108945ec6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp/gguflib-populate-mkdirs.cmake
@@ -0,0 +1,27 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+# If CMAKE_DISABLE_SOURCE_CHANGES is set to true and the source directory is an
+# existing directory in our source tree, calling file(MAKE_DIRECTORY) on it
+# would cause a fatal error, even though it would be a no-op.
+if(NOT EXISTS "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src")
+  file(MAKE_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src")
+endif()
+file(MAKE_DIRECTORY
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-build"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/tmp"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp"
+)
+
+set(configSubDirs )
+foreach(subDir IN LISTS configSubDirs)
+    file(MAKE_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp/${subDir}")
+endforeach()
+if(cfgdir)
+  file(MAKE_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-subbuild/gguflib-populate-prefix/src/gguflib-populate-stamp${cfgdir}") # cfgdir has leading slash
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb9de92640e91b3d38364ee7a569cd8b862951
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+0
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..28656465cc0afe58497d6041ffc3af6ab12df1c4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/Makefile
@@ -0,0 +1,189 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\" \"headers\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build//CMakeFiles/progress.marks
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 _deps/json-build/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 _deps/json-build/clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 _deps/json-build/preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 _deps/json-build/preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..9756ec573e440097fb3d69967523874aad57a137
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/cmake_install.cmake
@@ -0,0 +1,50 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/nlohmann_json.pc b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/nlohmann_json.pc
new file mode 100644
index 0000000000000000000000000000000000000000..e723684a266adc63cf61f1c115befe214480f6a8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/nlohmann_json.pc
@@ -0,0 +1,4 @@
+Name: nlohmann_json
+Description: JSON for Modern C++
+Version: 3.11.3
+Cflags: -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/include
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/nlohmann_jsonConfig.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/nlohmann_jsonConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..27b0a864a89356e466d57f57b6a6cd76be2be801
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/nlohmann_jsonConfig.cmake
@@ -0,0 +1,15 @@
+include(FindPackageHandleStandardArgs)
+set(${CMAKE_FIND_PACKAGE_NAME}_CONFIG ${CMAKE_CURRENT_LIST_FILE})
+find_package_handle_standard_args(nlohmann_json CONFIG_MODE)
+
+if(NOT TARGET nlohmann_json::nlohmann_json)
+    include("${CMAKE_CURRENT_LIST_DIR}/nlohmann_jsonTargets.cmake")
+    if((NOT TARGET nlohmann_json) AND
+       (NOT nlohmann_json_FIND_VERSION OR
+        nlohmann_json_FIND_VERSION VERSION_LESS 3.2.0))
+        add_library(nlohmann_json INTERFACE IMPORTED)
+        set_target_properties(nlohmann_json PROPERTIES
+            INTERFACE_LINK_LIBRARIES nlohmann_json::nlohmann_json
+        )
+    endif()
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/nlohmann_jsonConfigVersion.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/nlohmann_jsonConfigVersion.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..771c9c87a3b6fa4526b26dcb41e391470bca8b7d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/nlohmann_jsonConfigVersion.cmake
@@ -0,0 +1,20 @@
+# This is essentially cmake's BasicConfigVersion-SameMajorVersion.cmake.in but
+# without the 32/64-bit check.  Since json is a header-only library, it doesn't
+# matter if it was built on a different platform than what it is used on (see
+# https://github.com/nlohmann/json/issues/1697).
+set(PACKAGE_VERSION "3.11.3")
+
+if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+
+  if(PACKAGE_FIND_VERSION_MAJOR STREQUAL "3")
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  endif()
+
+  if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7a49dc47eac718212a52bcfc6c582d56743f8b96
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/CMakeLists.txt
@@ -0,0 +1,209 @@
+cmake_minimum_required(VERSION 3.1...3.14)
+
+##
+## PROJECT
+## name and version
+##
+project(nlohmann_json VERSION 3.11.3 LANGUAGES CXX)
+
+##
+## MAIN_PROJECT CHECK
+## determine if nlohmann_json is built as a subproject (using add_subdirectory) or if it is the main project
+##
+set(MAIN_PROJECT OFF)
+if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    set(MAIN_PROJECT ON)
+endif()
+
+##
+## INCLUDE
+##
+##
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
+include(ExternalProject)
+
+##
+## OPTIONS
+##
+
+if (POLICY CMP0077)
+    # Allow CMake 3.13+ to override options when using FetchContent / add_subdirectory.
+    cmake_policy(SET CMP0077 NEW)
+endif ()
+
+# VERSION_GREATER_EQUAL is not available in CMake 3.1
+if(${MAIN_PROJECT} AND (${CMAKE_VERSION} VERSION_EQUAL 3.13 OR ${CMAKE_VERSION} VERSION_GREATER 3.13))
+    set(JSON_BuildTests_INIT ON)
+else()
+    set(JSON_BuildTests_INIT OFF)
+endif()
+option(JSON_BuildTests                     "Build the unit tests when BUILD_TESTING is enabled." ${JSON_BuildTests_INIT})
+option(JSON_CI                             "Enable CI build targets." OFF)
+option(JSON_Diagnostics                    "Use extended diagnostic messages." OFF)
+option(JSON_GlobalUDLs                     "Place use-defined string literals in the global namespace." ON)
+option(JSON_ImplicitConversions            "Enable implicit conversions." ON)
+option(JSON_DisableEnumSerialization       "Disable default integer enum serialization." OFF)
+option(JSON_LegacyDiscardedValueComparison "Enable legacy discarded value comparison." OFF)
+option(JSON_Install                        "Install CMake targets during install step." ${MAIN_PROJECT})
+option(JSON_MultipleHeaders                "Use non-amalgamated version of the library." ON)
+option(JSON_SystemInclude                  "Include as system headers (skip for clang-tidy)." OFF)
+
+if (JSON_CI)
+    include(ci)
+endif ()
+
+##
+## CONFIGURATION
+##
+include(GNUInstallDirs)
+
+set(NLOHMANN_JSON_TARGET_NAME               ${PROJECT_NAME})
+set(NLOHMANN_JSON_CONFIG_INSTALL_DIR        "${CMAKE_INSTALL_DATADIR}/cmake/${PROJECT_NAME}" CACHE INTERNAL "")
+set(NLOHMANN_JSON_INCLUDE_INSTALL_DIR       "${CMAKE_INSTALL_INCLUDEDIR}")
+set(NLOHMANN_JSON_TARGETS_EXPORT_NAME       "${PROJECT_NAME}Targets")
+set(NLOHMANN_JSON_CMAKE_CONFIG_TEMPLATE     "cmake/config.cmake.in")
+set(NLOHMANN_JSON_CMAKE_CONFIG_DIR          "${CMAKE_CURRENT_BINARY_DIR}")
+set(NLOHMANN_JSON_CMAKE_VERSION_CONFIG_FILE "${NLOHMANN_JSON_CMAKE_CONFIG_DIR}/${PROJECT_NAME}ConfigVersion.cmake")
+set(NLOHMANN_JSON_CMAKE_PROJECT_CONFIG_FILE "${NLOHMANN_JSON_CMAKE_CONFIG_DIR}/${PROJECT_NAME}Config.cmake")
+set(NLOHMANN_JSON_CMAKE_PROJECT_TARGETS_FILE "${NLOHMANN_JSON_CMAKE_CONFIG_DIR}/${PROJECT_NAME}Targets.cmake")
+set(NLOHMANN_JSON_PKGCONFIG_INSTALL_DIR     "${CMAKE_INSTALL_DATADIR}/pkgconfig")
+
+if (JSON_MultipleHeaders)
+    set(NLOHMANN_JSON_INCLUDE_BUILD_DIR "${PROJECT_SOURCE_DIR}/include/")
+    message(STATUS "Using the multi-header code from ${NLOHMANN_JSON_INCLUDE_BUILD_DIR}")
+else()
+    set(NLOHMANN_JSON_INCLUDE_BUILD_DIR "${PROJECT_SOURCE_DIR}/single_include/")
+    message(STATUS "Using the single-header code from ${NLOHMANN_JSON_INCLUDE_BUILD_DIR}")
+endif()
+
+if (NOT JSON_ImplicitConversions)
+    message(STATUS "Implicit conversions are disabled")
+endif()
+
+if (JSON_DisableEnumSerialization)
+    message(STATUS "Enum integer serialization is disabled")
+endif()
+
+if (JSON_LegacyDiscardedValueComparison)
+    message(STATUS "Legacy discarded value comparison enabled")
+endif()
+
+if (JSON_Diagnostics)
+    message(STATUS "Diagnostics enabled")
+endif()
+
+if (JSON_SystemInclude)
+    set(NLOHMANN_JSON_SYSTEM_INCLUDE "SYSTEM")
+endif()
+
+##
+## TARGET
+## create target and add include path
+##
+add_library(${NLOHMANN_JSON_TARGET_NAME} INTERFACE)
+add_library(${PROJECT_NAME}::${NLOHMANN_JSON_TARGET_NAME} ALIAS ${NLOHMANN_JSON_TARGET_NAME})
+if (${CMAKE_VERSION} VERSION_LESS "3.8.0")
+    target_compile_features(${NLOHMANN_JSON_TARGET_NAME} INTERFACE cxx_range_for)
+else()
+    target_compile_features(${NLOHMANN_JSON_TARGET_NAME} INTERFACE cxx_std_11)
+endif()
+
+target_compile_definitions(
+    ${NLOHMANN_JSON_TARGET_NAME}
+    INTERFACE
+    $<$<NOT:$<BOOL:${JSON_GlobalUDLs}>>:JSON_USE_GLOBAL_UDLS=0>
+    $<$<NOT:$<BOOL:${JSON_ImplicitConversions}>>:JSON_USE_IMPLICIT_CONVERSIONS=0>
+    $<$<BOOL:${JSON_DisableEnumSerialization}>:JSON_DISABLE_ENUM_SERIALIZATION=1>
+    $<$<BOOL:${JSON_Diagnostics}>:JSON_DIAGNOSTICS=1>
+    $<$<BOOL:${JSON_LegacyDiscardedValueComparison}>:JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1>
+)
+
+target_include_directories(
+    ${NLOHMANN_JSON_TARGET_NAME}
+    ${NLOHMANN_JSON_SYSTEM_INCLUDE} INTERFACE
+    $<BUILD_INTERFACE:${NLOHMANN_JSON_INCLUDE_BUILD_DIR}>
+    $<INSTALL_INTERFACE:${NLOHMANN_JSON_INCLUDE_INSTALL_DIR}>
+)
+
+## add debug view definition file for msvc (natvis)
+if (MSVC)
+    set(NLOHMANN_ADD_NATVIS TRUE)
+    set(NLOHMANN_NATVIS_FILE "nlohmann_json.natvis")
+    target_sources(
+        ${NLOHMANN_JSON_TARGET_NAME}
+        INTERFACE
+            $<INSTALL_INTERFACE:${NLOHMANN_NATVIS_FILE}>
+            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/${NLOHMANN_NATVIS_FILE}>
+    )
+endif()
+
+# Install a pkg-config file, so other tools can find this.
+CONFIGURE_FILE(
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkg-config.pc.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"
+)
+
+##
+## TESTS
+## create and configure the unit test target
+##
+if (JSON_BuildTests)
+    include(CTest)
+    enable_testing()
+    add_subdirectory(tests)
+endif()
+
+##
+## INSTALL
+## install header files, generate and install cmake config files for find_package()
+##
+include(CMakePackageConfigHelpers)
+# use a custom package version config file instead of
+# write_basic_package_version_file to ensure that it's architecture-independent
+# https://github.com/nlohmann/json/issues/1697
+configure_file(
+    "cmake/nlohmann_jsonConfigVersion.cmake.in"
+    ${NLOHMANN_JSON_CMAKE_VERSION_CONFIG_FILE}
+    @ONLY
+)
+configure_file(
+    ${NLOHMANN_JSON_CMAKE_CONFIG_TEMPLATE}
+    ${NLOHMANN_JSON_CMAKE_PROJECT_CONFIG_FILE}
+    @ONLY
+)
+
+if(JSON_Install)
+    install(
+        DIRECTORY ${NLOHMANN_JSON_INCLUDE_BUILD_DIR}
+        DESTINATION ${NLOHMANN_JSON_INCLUDE_INSTALL_DIR}
+    )
+    install(
+        FILES ${NLOHMANN_JSON_CMAKE_PROJECT_CONFIG_FILE} ${NLOHMANN_JSON_CMAKE_VERSION_CONFIG_FILE}
+        DESTINATION ${NLOHMANN_JSON_CONFIG_INSTALL_DIR}
+    )
+    if (NLOHMANN_ADD_NATVIS)
+        install(
+            FILES ${NLOHMANN_NATVIS_FILE}
+            DESTINATION .
+    )
+    endif()
+    export(
+        TARGETS ${NLOHMANN_JSON_TARGET_NAME}
+        NAMESPACE ${PROJECT_NAME}::
+        FILE ${NLOHMANN_JSON_CMAKE_PROJECT_TARGETS_FILE}
+    )
+    install(
+        TARGETS ${NLOHMANN_JSON_TARGET_NAME}
+        EXPORT ${NLOHMANN_JSON_TARGETS_EXPORT_NAME}
+        INCLUDES DESTINATION ${NLOHMANN_JSON_INCLUDE_INSTALL_DIR}
+    )
+    install(
+        EXPORT ${NLOHMANN_JSON_TARGETS_EXPORT_NAME}
+        NAMESPACE ${PROJECT_NAME}::
+        DESTINATION ${NLOHMANN_JSON_CONFIG_INSTALL_DIR}
+    )
+    install(
+        FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"
+        DESTINATION ${NLOHMANN_JSON_PKGCONFIG_INSTALL_DIR}
+    )
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/LICENSE.MIT b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/LICENSE.MIT
new file mode 100644
index 0000000000000000000000000000000000000000..1c1f7a690d815db3a79ea3d4c9138a497e2e7702
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/LICENSE.MIT
@@ -0,0 +1,21 @@
+MIT License 
+
+Copyright (c) 2013-2022 Niels Lohmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/cmake/config.cmake.in b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/cmake/config.cmake.in
new file mode 100644
index 0000000000000000000000000000000000000000..9a17a7d7b2d5502f7d829b2f679d88fd0c9fa932
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/cmake/config.cmake.in
@@ -0,0 +1,15 @@
+include(FindPackageHandleStandardArgs)
+set(${CMAKE_FIND_PACKAGE_NAME}_CONFIG ${CMAKE_CURRENT_LIST_FILE})
+find_package_handle_standard_args(@PROJECT_NAME@ CONFIG_MODE)
+
+if(NOT TARGET @PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@)
+    include("${CMAKE_CURRENT_LIST_DIR}/@NLOHMANN_JSON_TARGETS_EXPORT_NAME@.cmake")
+    if((NOT TARGET @NLOHMANN_JSON_TARGET_NAME@) AND
+       (NOT @PROJECT_NAME@_FIND_VERSION OR
+        @PROJECT_NAME@_FIND_VERSION VERSION_LESS 3.2.0))
+        add_library(@NLOHMANN_JSON_TARGET_NAME@ INTERFACE IMPORTED)
+        set_target_properties(@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
+            INTERFACE_LINK_LIBRARIES @PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@
+        )
+    endif()
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/cmake/nlohmann_jsonConfigVersion.cmake.in b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/cmake/nlohmann_jsonConfigVersion.cmake.in
new file mode 100644
index 0000000000000000000000000000000000000000..10910859734e88f236ae92cb99a50458cc7f73c7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/cmake/nlohmann_jsonConfigVersion.cmake.in
@@ -0,0 +1,20 @@
+# This is essentially cmake's BasicConfigVersion-SameMajorVersion.cmake.in but
+# without the 32/64-bit check.  Since json is a header-only library, it doesn't
+# matter if it was built on a different platform than what it is used on (see
+# https://github.com/nlohmann/json/issues/1697).
+set(PACKAGE_VERSION "@PROJECT_VERSION@")
+
+if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+
+  if(PACKAGE_FIND_VERSION_MAJOR STREQUAL "@PROJECT_VERSION_MAJOR@")
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  endif()
+
+  if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/cmake/pkg-config.pc.in b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/cmake/pkg-config.pc.in
new file mode 100644
index 0000000000000000000000000000000000000000..d36317f09aad122bdd9b7777e409e2fd42500925
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/cmake/pkg-config.pc.in
@@ -0,0 +1,4 @@
+Name: ${PROJECT_NAME}
+Description: JSON for Modern C++
+Version: ${PROJECT_VERSION}
+Cflags: -I${CMAKE_INSTALL_FULL_INCLUDEDIR}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/adl_serializer.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/adl_serializer.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..56a606c0f6a1bc39cfb5a88d62df343a7f36bd41
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/adl_serializer.hpp
@@ -0,0 +1,55 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <utility>
+
+#include <nlohmann/detail/abi_macros.hpp>
+#include <nlohmann/detail/conversions/from_json.hpp>
+#include <nlohmann/detail/conversions/to_json.hpp>
+#include <nlohmann/detail/meta/identity_tag.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @sa https://json.nlohmann.me/api/adl_serializer/
+template<typename ValueType, typename>
+struct adl_serializer
+{
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
+        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
+    {
+        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
+    }
+
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j) noexcept(
+    noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
+    {
+        return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
+    }
+
+    /// @brief convert any value type to a JSON value
+    /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
+        noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
+    -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
+    {
+        ::nlohmann::to_json(j, std::forward<TargetType>(val));
+    }
+};
+
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/byte_container_with_subtype.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/byte_container_with_subtype.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..91382cd682d10c804743dd90afb499f4864a2920
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/byte_container_with_subtype.hpp
@@ -0,0 +1,103 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstdint> // uint8_t, uint64_t
+#include <tuple> // tie
+#include <utility> // move
+
+#include <nlohmann/detail/abi_macros.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @brief an internal type for a backed binary type
+/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/
+template<typename BinaryType>
+class byte_container_with_subtype : public BinaryType
+{
+  public:
+    using container_type = BinaryType;
+    using subtype_type = std::uint64_t;
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype() noexcept(noexcept(container_type()))
+        : container_type()
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    bool operator==(const byte_container_with_subtype& rhs) const
+    {
+        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
+               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
+    }
+
+    bool operator!=(const byte_container_with_subtype& rhs) const
+    {
+        return !(rhs == *this);
+    }
+
+    /// @brief sets the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/
+    void set_subtype(subtype_type subtype_) noexcept
+    {
+        m_subtype = subtype_;
+        m_has_subtype = true;
+    }
+
+    /// @brief return the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/
+    constexpr subtype_type subtype() const noexcept
+    {
+        return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
+    }
+
+    /// @brief return whether the value has a subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/
+    constexpr bool has_subtype() const noexcept
+    {
+        return m_has_subtype;
+    }
+
+    /// @brief clears the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/
+    void clear_subtype() noexcept
+    {
+        m_subtype = 0;
+        m_has_subtype = false;
+    }
+
+  private:
+    subtype_type m_subtype = 0;
+    bool m_has_subtype = false;
+};
+
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/abi_macros.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/abi_macros.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f48b9eb1d5f0ec15fb47072084a4452f5c39fdde
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/abi_macros.hpp
@@ -0,0 +1,100 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+// This file contains all macro definitions affecting or depending on the ABI
+
+#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
+    #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
+        #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3
+            #warning "Already included a different version of the library!"
+        #endif
+    #endif
+#endif
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3   // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_MINOR 11  // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_PATCH 3   // NOLINT(modernize-macro-to-enum)
+
+#ifndef JSON_DIAGNOSTICS
+    #define JSON_DIAGNOSTICS 0
+#endif
+
+#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
+#endif
+
+#if JSON_DIAGNOSTICS
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
+#else
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
+#endif
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
+#else
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
+    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
+#endif
+
+// Construct the namespace ABI tags component
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)
+
+#define NLOHMANN_JSON_ABI_TAGS                                       \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
+            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
+
+// Construct the namespace version component
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
+    _v ## major ## _ ## minor ## _ ## patch
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
+
+#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
+#define NLOHMANN_JSON_NAMESPACE_VERSION
+#else
+#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
+                                           NLOHMANN_JSON_VERSION_MINOR, \
+                                           NLOHMANN_JSON_VERSION_PATCH)
+#endif
+
+// Combine namespace components
+#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
+#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
+    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
+
+#ifndef NLOHMANN_JSON_NAMESPACE
+#define NLOHMANN_JSON_NAMESPACE               \
+    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
+            NLOHMANN_JSON_ABI_TAGS,           \
+            NLOHMANN_JSON_NAMESPACE_VERSION)
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
+#define NLOHMANN_JSON_NAMESPACE_BEGIN                \
+    namespace nlohmann                               \
+    {                                                \
+    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
+                NLOHMANN_JSON_ABI_TAGS,              \
+                NLOHMANN_JSON_NAMESPACE_VERSION)     \
+    {
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_END
+#define NLOHMANN_JSON_NAMESPACE_END                                     \
+    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
+    }  // namespace nlohmann
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/conversions/from_json.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/conversions/from_json.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..aa2f0cbf4cdef243d339ff08883622b769289aad
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/conversions/from_json.hpp
@@ -0,0 +1,497 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <algorithm> // transform
+#include <array> // array
+#include <forward_list> // forward_list
+#include <iterator> // inserter, front_inserter, end
+#include <map> // map
+#include <string> // string
+#include <tuple> // tuple, make_tuple
+#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
+#include <unordered_map> // unordered_map
+#include <utility> // pair, declval
+#include <valarray> // valarray
+
+#include <nlohmann/detail/exceptions.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/meta/cpp_future.hpp>
+#include <nlohmann/detail/meta/identity_tag.hpp>
+#include <nlohmann/detail/meta/std_fs.hpp>
+#include <nlohmann/detail/meta/type_traits.hpp>
+#include <nlohmann/detail/string_concat.hpp>
+#include <nlohmann/detail/value_t.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be null, but is ", j.type_name()), &j));
+    }
+    n = nullptr;
+}
+
+// overloads for basic_json template parameters
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
+                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+                         int > = 0 >
+void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+
+        case value_t::null:
+        case value_t::object:
+        case value_t::array:
+        case value_t::string:
+        case value_t::boolean:
+        case value_t::binary:
+        case value_t::discarded:
+        default:
+            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
+    }
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
+    }
+    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template <
+    typename BasicJsonType, typename StringType,
+    enable_if_t <
+        std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value
+        && is_detected_exact<typename BasicJsonType::string_t::value_type, value_type_t, StringType>::value
+        && !std::is_same<typename BasicJsonType::string_t, StringType>::value
+        && !is_json_ref<StringType>::value, int > = 0 >
+inline void from_json(const BasicJsonType& j, StringType& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+#if !JSON_DISABLE_ENUM_SERIALIZATION
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, EnumType& e)
+{
+    typename std::underlying_type<EnumType>::type val;
+    get_arithmetic_value(j, val);
+    e = static_cast<EnumType>(val);
+}
+#endif  // JSON_DISABLE_ENUM_SERIALIZATION
+
+// forward_list doesn't have an insert method
+template<typename BasicJsonType, typename T, typename Allocator,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    l.clear();
+    std::transform(j.rbegin(), j.rend(),
+                   std::front_inserter(l), [](const BasicJsonType & i)
+    {
+        return i.template get<T>();
+    });
+}
+
+// valarray doesn't have an insert method
+template<typename BasicJsonType, typename T,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    l.resize(j.size());
+    std::transform(j.begin(), j.end(), std::begin(l),
+                   [](const BasicJsonType & elem)
+    {
+        return elem.template get<T>();
+    });
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType>
+inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
+{
+    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
+                          priority_tag<2> /*unused*/)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType,
+         enable_if_t<
+             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
+             int> = 0>
+auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
+-> decltype(
+    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
+    j.template get<typename ConstructibleArrayType::value_type>(),
+    void())
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    ret.reserve(j.size());
+    std::transform(j.begin(), j.end(),
+                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType,
+         enable_if_t<
+             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
+             int> = 0>
+inline void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
+                                 priority_tag<0> /*unused*/)
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    std::transform(
+        j.begin(), j.end(), std::inserter(ret, end(ret)),
+        [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template < typename BasicJsonType, typename ConstructibleArrayType,
+           enable_if_t <
+               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
+               !is_basic_json<ConstructibleArrayType>::value,
+               int > = 0 >
+auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
+-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
+j.template get<typename ConstructibleArrayType::value_type>(),
+void())
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    from_json_array_impl(j, arr, priority_tag<3> {});
+}
+
+template < typename BasicJsonType, typename T, std::size_t... Idx >
+std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
+        identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
+{
+    return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
+}
+
+template < typename BasicJsonType, typename T, std::size_t N >
+auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
+-> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be binary, but is ", j.type_name()), &j));
+    }
+
+    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
+}
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be object, but is ", j.type_name()), &j));
+    }
+
+    ConstructibleObjectType ret;
+    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
+    using value_type = typename ConstructibleObjectType::value_type;
+    std::transform(
+        inner_object->begin(), inner_object->end(),
+        std::inserter(ret, ret.begin()),
+        [](typename BasicJsonType::object_t::value_type const & p)
+    {
+        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
+    });
+    obj = std::move(ret);
+}
+
+// overload for arithmetic types, not chosen for basic_json template arguments
+// (BooleanType, etc..); note: Is it really necessary to provide explicit
+// overloads for boolean_t etc. in case of a custom BooleanType which is not
+// an arithmetic type?
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t <
+               std::is_arithmetic<ArithmeticType>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+               int > = 0 >
+inline void from_json(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+        case value_t::boolean:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
+            break;
+        }
+
+        case value_t::null:
+        case value_t::object:
+        case value_t::array:
+        case value_t::string:
+        case value_t::binary:
+        case value_t::discarded:
+        default:
+            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
+    }
+}
+
+template<typename BasicJsonType, typename... Args, std::size_t... Idx>
+std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
+{
+    return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
+}
+
+template < typename BasicJsonType, class A1, class A2 >
+std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
+{
+    return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
+            std::forward<BasicJsonType>(j).at(1).template get<A2>()};
+}
+
+template<typename BasicJsonType, typename A1, typename A2>
+inline void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
+{
+    p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
+}
+
+template<typename BasicJsonType, typename... Args>
+std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
+{
+    return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+}
+
+template<typename BasicJsonType, typename... Args>
+inline void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
+{
+    t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+}
+
+template<typename BasicJsonType, typename TupleRelated>
+auto from_json(BasicJsonType&& j, TupleRelated&& t)
+-> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+inline void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+inline void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, std_fs::path& p)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+    p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+#endif
+
+struct from_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(const BasicJsonType& j, T&& val) const
+    noexcept(noexcept(from_json(j, std::forward<T>(val))))
+    -> decltype(from_json(j, std::forward<T>(val)))
+    {
+        return from_json(j, std::forward<T>(val));
+    }
+};
+
+}  // namespace detail
+
+#ifndef JSON_HAS_CPP_17
+/// namespace to hold default `from_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+{
+#endif
+JSON_INLINE_VARIABLE constexpr const auto& from_json = // NOLINT(misc-definitions-in-headers)
+    detail::static_const<detail::from_json_fn>::value;
+#ifndef JSON_HAS_CPP_17
+}  // namespace
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/conversions/to_chars.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/conversions/to_chars.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e10741c9232ca95cb723becccbd334e2c9ea42da
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/conversions/to_chars.hpp
@@ -0,0 +1,1118 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2009 Florian Loitsch <https://florian.loitsch.com/>
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <array> // array
+#include <cmath>   // signbit, isfinite
+#include <cstdint> // intN_t, uintN_t
+#include <cstring> // memcpy, memmove
+#include <limits> // numeric_limits
+#include <type_traits> // conditional
+
+#include <nlohmann/detail/macro_scope.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief implements the Grisu2 algorithm for binary to decimal floating-point
+conversion.
+
+This implementation is a slightly modified version of the reference
+implementation which may be obtained from
+http://florian.loitsch.com/publications (bench.tar.gz).
+
+The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
+
+For a detailed description of the algorithm see:
+
+[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
+    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
+    Language Design and Implementation, PLDI 2010
+[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
+    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
+    Design and Implementation, PLDI 1996
+*/
+namespace dtoa_impl
+{
+
+template<typename Target, typename Source>
+Target reinterpret_bits(const Source source)
+{
+    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
+
+    Target target;
+    std::memcpy(&target, &source, sizeof(Source));
+    return target;
+}
+
+struct diyfp // f * 2^e
+{
+    static constexpr int kPrecision = 64; // = q
+
+    std::uint64_t f = 0;
+    int e = 0;
+
+    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
+
+    /*!
+    @brief returns x - y
+    @pre x.e == y.e and x.f >= y.f
+    */
+    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
+    {
+        JSON_ASSERT(x.e == y.e);
+        JSON_ASSERT(x.f >= y.f);
+
+        return {x.f - y.f, x.e};
+    }
+
+    /*!
+    @brief returns x * y
+    @note The result is rounded. (Only the upper q bits are returned.)
+    */
+    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
+    {
+        static_assert(kPrecision == 64, "internal error");
+
+        // Computes:
+        //  f = round((x.f * y.f) / 2^q)
+        //  e = x.e + y.e + q
+
+        // Emulate the 64-bit * 64-bit multiplication:
+        //
+        // p = u * v
+        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
+        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
+        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
+        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
+        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
+        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
+        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
+        //
+        // (Since Q might be larger than 2^32 - 1)
+        //
+        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
+        //
+        // (Q_hi + H does not overflow a 64-bit int)
+        //
+        //   = p_lo + 2^64 p_hi
+
+        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
+        const std::uint64_t u_hi = x.f >> 32u;
+        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
+        const std::uint64_t v_hi = y.f >> 32u;
+
+        const std::uint64_t p0 = u_lo * v_lo;
+        const std::uint64_t p1 = u_lo * v_hi;
+        const std::uint64_t p2 = u_hi * v_lo;
+        const std::uint64_t p3 = u_hi * v_hi;
+
+        const std::uint64_t p0_hi = p0 >> 32u;
+        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
+        const std::uint64_t p1_hi = p1 >> 32u;
+        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
+        const std::uint64_t p2_hi = p2 >> 32u;
+
+        std::uint64_t Q = p0_hi + p1_lo + p2_lo;
+
+        // The full product might now be computed as
+        //
+        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
+        // p_lo = p0_lo + (Q << 32)
+        //
+        // But in this particular case here, the full p_lo is not required.
+        // Effectively we only need to add the highest bit in p_lo to p_hi (and
+        // Q_hi + 1 does not overflow).
+
+        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
+
+        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
+
+        return {h, x.e + y.e + 64};
+    }
+
+    /*!
+    @brief normalize x such that the significand is >= 2^(q-1)
+    @pre x.f != 0
+    */
+    static diyfp normalize(diyfp x) noexcept
+    {
+        JSON_ASSERT(x.f != 0);
+
+        while ((x.f >> 63u) == 0)
+        {
+            x.f <<= 1u;
+            x.e--;
+        }
+
+        return x;
+    }
+
+    /*!
+    @brief normalize x such that the result has the exponent E
+    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
+    */
+    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
+    {
+        const int delta = x.e - target_exponent;
+
+        JSON_ASSERT(delta >= 0);
+        JSON_ASSERT(((x.f << delta) >> delta) == x.f);
+
+        return {x.f << delta, target_exponent};
+    }
+};
+
+struct boundaries
+{
+    diyfp w;
+    diyfp minus;
+    diyfp plus;
+};
+
+/*!
+Compute the (normalized) diyfp representing the input number 'value' and its
+boundaries.
+
+@pre value must be finite and positive
+*/
+template<typename FloatType>
+boundaries compute_boundaries(FloatType value)
+{
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // Convert the IEEE representation into a diyfp.
+    //
+    // If v is denormal:
+    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
+    // If v is normalized:
+    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
+
+    static_assert(std::numeric_limits<FloatType>::is_iec559,
+                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
+
+    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
+    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
+    constexpr int      kMinExp    = 1 - kBias;
+    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
+
+    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
+
+    const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
+    const std::uint64_t E = bits >> (kPrecision - 1);
+    const std::uint64_t F = bits & (kHiddenBit - 1);
+
+    const bool is_denormal = E == 0;
+    const diyfp v = is_denormal
+                    ? diyfp(F, kMinExp)
+                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
+
+    // Compute the boundaries m- and m+ of the floating-point value
+    // v = f * 2^e.
+    //
+    // Determine v- and v+, the floating-point predecessor and successor if v,
+    // respectively.
+    //
+    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
+    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
+    //
+    //      v+ = v + 2^e
+    //
+    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
+    // between m- and m+ round to v, regardless of how the input rounding
+    // algorithm breaks ties.
+    //
+    //      ---+-------------+-------------+-------------+-------------+---  (A)
+    //         v-            m-            v             m+            v+
+    //
+    //      -----------------+------+------+-------------+-------------+---  (B)
+    //                       v-     m-     v             m+            v+
+
+    const bool lower_boundary_is_closer = F == 0 && E > 1;
+    const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
+    const diyfp m_minus = lower_boundary_is_closer
+                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)
+                          : diyfp(2 * v.f - 1, v.e - 1); // (A)
+
+    // Determine the normalized w+ = m+.
+    const diyfp w_plus = diyfp::normalize(m_plus);
+
+    // Determine w- = m- such that e_(w-) = e_(w+).
+    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
+
+    return {diyfp::normalize(v), w_minus, w_plus};
+}
+
+// Given normalized diyfp w, Grisu needs to find a (normalized) cached
+// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
+// within a certain range [alpha, gamma] (Definition 3.2 from [1])
+//
+//      alpha <= e = e_c + e_w + q <= gamma
+//
+// or
+//
+//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
+//                          <= f_c * f_w * 2^gamma
+//
+// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
+//
+//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
+//
+// or
+//
+//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
+//
+// The choice of (alpha,gamma) determines the size of the table and the form of
+// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
+// in practice:
+//
+// The idea is to cut the number c * w = f * 2^e into two parts, which can be
+// processed independently: An integral part p1, and a fractional part p2:
+//
+//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
+//              = (f div 2^-e) + (f mod 2^-e) * 2^e
+//              = p1 + p2 * 2^e
+//
+// The conversion of p1 into decimal form requires a series of divisions and
+// modulos by (a power of) 10. These operations are faster for 32-bit than for
+// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
+// achieved by choosing
+//
+//      -e >= 32   or   e <= -32 := gamma
+//
+// In order to convert the fractional part
+//
+//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
+//
+// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
+// d[-i] are extracted in order:
+//
+//      (10 * p2) div 2^-e = d[-1]
+//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
+//
+// The multiplication by 10 must not overflow. It is sufficient to choose
+//
+//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
+//
+// Since p2 = f mod 2^-e < 2^-e,
+//
+//      -e <= 60   or   e >= -60 := alpha
+
+constexpr int kAlpha = -60;
+constexpr int kGamma = -32;
+
+struct cached_power // c = f * 2^e ~= 10^k
+{
+    std::uint64_t f;
+    int e;
+    int k;
+};
+
+/*!
+For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
+power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
+satisfies (Definition 3.2 from [1])
+
+     alpha <= e_c + e + q <= gamma.
+*/
+inline cached_power get_cached_power_for_binary_exponent(int e)
+{
+    // Now
+    //
+    //      alpha <= e_c + e + q <= gamma                                    (1)
+    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
+    //
+    // and since the c's are normalized, 2^(q-1) <= f_c,
+    //
+    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
+    //      ==> 2^(alpha - e - 1) <= c
+    //
+    // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
+    //
+    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
+    //        = ceil( (alpha - e - 1) * log_10(2) )
+    //
+    // From the paper:
+    // "In theory the result of the procedure could be wrong since c is rounded,
+    //  and the computation itself is approximated [...]. In practice, however,
+    //  this simple function is sufficient."
+    //
+    // For IEEE double precision floating-point numbers converted into
+    // normalized diyfp's w = f * 2^e, with q = 64,
+    //
+    //      e >= -1022      (min IEEE exponent)
+    //           -52        (p - 1)
+    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
+    //           -11        (normalize the diyfp)
+    //         = -1137
+    //
+    // and
+    //
+    //      e <= +1023      (max IEEE exponent)
+    //           -52        (p - 1)
+    //           -11        (normalize the diyfp)
+    //         = 960
+    //
+    // This binary exponent range [-1137,960] results in a decimal exponent
+    // range [-307,324]. One does not need to store a cached power for each
+    // k in this range. For each such k it suffices to find a cached power
+    // such that the exponent of the product lies in [alpha,gamma].
+    // This implies that the difference of the decimal exponents of adjacent
+    // table entries must be less than or equal to
+    //
+    //      floor( (gamma - alpha) * log_10(2) ) = 8.
+    //
+    // (A smaller distance gamma-alpha would require a larger table.)
+
+    // NB:
+    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
+
+    constexpr int kCachedPowersMinDecExp = -300;
+    constexpr int kCachedPowersDecStep = 8;
+
+    static constexpr std::array<cached_power, 79> kCachedPowers =
+    {
+        {
+            { 0xAB70FE17C79AC6CA, -1060, -300 },
+            { 0xFF77B1FCBEBCDC4F, -1034, -292 },
+            { 0xBE5691EF416BD60C, -1007, -284 },
+            { 0x8DD01FAD907FFC3C,  -980, -276 },
+            { 0xD3515C2831559A83,  -954, -268 },
+            { 0x9D71AC8FADA6C9B5,  -927, -260 },
+            { 0xEA9C227723EE8BCB,  -901, -252 },
+            { 0xAECC49914078536D,  -874, -244 },
+            { 0x823C12795DB6CE57,  -847, -236 },
+            { 0xC21094364DFB5637,  -821, -228 },
+            { 0x9096EA6F3848984F,  -794, -220 },
+            { 0xD77485CB25823AC7,  -768, -212 },
+            { 0xA086CFCD97BF97F4,  -741, -204 },
+            { 0xEF340A98172AACE5,  -715, -196 },
+            { 0xB23867FB2A35B28E,  -688, -188 },
+            { 0x84C8D4DFD2C63F3B,  -661, -180 },
+            { 0xC5DD44271AD3CDBA,  -635, -172 },
+            { 0x936B9FCEBB25C996,  -608, -164 },
+            { 0xDBAC6C247D62A584,  -582, -156 },
+            { 0xA3AB66580D5FDAF6,  -555, -148 },
+            { 0xF3E2F893DEC3F126,  -529, -140 },
+            { 0xB5B5ADA8AAFF80B8,  -502, -132 },
+            { 0x87625F056C7C4A8B,  -475, -124 },
+            { 0xC9BCFF6034C13053,  -449, -116 },
+            { 0x964E858C91BA2655,  -422, -108 },
+            { 0xDFF9772470297EBD,  -396, -100 },
+            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
+            { 0xF8A95FCF88747D94,  -343,  -84 },
+            { 0xB94470938FA89BCF,  -316,  -76 },
+            { 0x8A08F0F8BF0F156B,  -289,  -68 },
+            { 0xCDB02555653131B6,  -263,  -60 },
+            { 0x993FE2C6D07B7FAC,  -236,  -52 },
+            { 0xE45C10C42A2B3B06,  -210,  -44 },
+            { 0xAA242499697392D3,  -183,  -36 },
+            { 0xFD87B5F28300CA0E,  -157,  -28 },
+            { 0xBCE5086492111AEB,  -130,  -20 },
+            { 0x8CBCCC096F5088CC,  -103,  -12 },
+            { 0xD1B71758E219652C,   -77,   -4 },
+            { 0x9C40000000000000,   -50,    4 },
+            { 0xE8D4A51000000000,   -24,   12 },
+            { 0xAD78EBC5AC620000,     3,   20 },
+            { 0x813F3978F8940984,    30,   28 },
+            { 0xC097CE7BC90715B3,    56,   36 },
+            { 0x8F7E32CE7BEA5C70,    83,   44 },
+            { 0xD5D238A4ABE98068,   109,   52 },
+            { 0x9F4F2726179A2245,   136,   60 },
+            { 0xED63A231D4C4FB27,   162,   68 },
+            { 0xB0DE65388CC8ADA8,   189,   76 },
+            { 0x83C7088E1AAB65DB,   216,   84 },
+            { 0xC45D1DF942711D9A,   242,   92 },
+            { 0x924D692CA61BE758,   269,  100 },
+            { 0xDA01EE641A708DEA,   295,  108 },
+            { 0xA26DA3999AEF774A,   322,  116 },
+            { 0xF209787BB47D6B85,   348,  124 },
+            { 0xB454E4A179DD1877,   375,  132 },
+            { 0x865B86925B9BC5C2,   402,  140 },
+            { 0xC83553C5C8965D3D,   428,  148 },
+            { 0x952AB45CFA97A0B3,   455,  156 },
+            { 0xDE469FBD99A05FE3,   481,  164 },
+            { 0xA59BC234DB398C25,   508,  172 },
+            { 0xF6C69A72A3989F5C,   534,  180 },
+            { 0xB7DCBF5354E9BECE,   561,  188 },
+            { 0x88FCF317F22241E2,   588,  196 },
+            { 0xCC20CE9BD35C78A5,   614,  204 },
+            { 0x98165AF37B2153DF,   641,  212 },
+            { 0xE2A0B5DC971F303A,   667,  220 },
+            { 0xA8D9D1535CE3B396,   694,  228 },
+            { 0xFB9B7CD9A4A7443C,   720,  236 },
+            { 0xBB764C4CA7A44410,   747,  244 },
+            { 0x8BAB8EEFB6409C1A,   774,  252 },
+            { 0xD01FEF10A657842C,   800,  260 },
+            { 0x9B10A4E5E9913129,   827,  268 },
+            { 0xE7109BFBA19C0C9D,   853,  276 },
+            { 0xAC2820D9623BF429,   880,  284 },
+            { 0x80444B5E7AA7CF85,   907,  292 },
+            { 0xBF21E44003ACDD2D,   933,  300 },
+            { 0x8E679C2F5E44FF8F,   960,  308 },
+            { 0xD433179D9C8CB841,   986,  316 },
+            { 0x9E19DB92B4E31BA9,  1013,  324 },
+        }
+    };
+
+    // This computation gives exactly the same results for k as
+    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
+    // for |e| <= 1500, but doesn't require floating-point operations.
+    // NB: log_10(2) ~= 78913 / 2^18
+    JSON_ASSERT(e >= -1500);
+    JSON_ASSERT(e <=  1500);
+    const int f = kAlpha - e - 1;
+    const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
+
+    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
+    JSON_ASSERT(index >= 0);
+    JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
+
+    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
+    JSON_ASSERT(kAlpha <= cached.e + e + 64);
+    JSON_ASSERT(kGamma >= cached.e + e + 64);
+
+    return cached;
+}
+
+/*!
+For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
+For n == 0, returns 1 and sets pow10 := 1.
+*/
+inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
+{
+    // LCOV_EXCL_START
+    if (n >= 1000000000)
+    {
+        pow10 = 1000000000;
+        return 10;
+    }
+    // LCOV_EXCL_STOP
+    if (n >= 100000000)
+    {
+        pow10 = 100000000;
+        return  9;
+    }
+    if (n >= 10000000)
+    {
+        pow10 = 10000000;
+        return  8;
+    }
+    if (n >= 1000000)
+    {
+        pow10 = 1000000;
+        return  7;
+    }
+    if (n >= 100000)
+    {
+        pow10 = 100000;
+        return  6;
+    }
+    if (n >= 10000)
+    {
+        pow10 = 10000;
+        return  5;
+    }
+    if (n >= 1000)
+    {
+        pow10 = 1000;
+        return  4;
+    }
+    if (n >= 100)
+    {
+        pow10 = 100;
+        return  3;
+    }
+    if (n >= 10)
+    {
+        pow10 = 10;
+        return  2;
+    }
+
+    pow10 = 1;
+    return 1;
+}
+
+inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
+                         std::uint64_t rest, std::uint64_t ten_k)
+{
+    JSON_ASSERT(len >= 1);
+    JSON_ASSERT(dist <= delta);
+    JSON_ASSERT(rest <= delta);
+    JSON_ASSERT(ten_k > 0);
+
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    //                                  ten_k
+    //                                <------>
+    //                                       <---- rest ---->
+    // --------------[------------------+----+--------------]--------------
+    //                                  w    V
+    //                                       = buf * 10^k
+    //
+    // ten_k represents a unit-in-the-last-place in the decimal representation
+    // stored in buf.
+    // Decrement buf by ten_k while this takes buf closer to w.
+
+    // The tests are written in this order to avoid overflow in unsigned
+    // integer arithmetic.
+
+    while (rest < dist
+            && delta - rest >= ten_k
+            && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
+    {
+        JSON_ASSERT(buf[len - 1] != '0');
+        buf[len - 1]--;
+        rest += ten_k;
+    }
+}
+
+/*!
+Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
+M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
+*/
+inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
+                             diyfp M_minus, diyfp w, diyfp M_plus)
+{
+    static_assert(kAlpha >= -60, "internal error");
+    static_assert(kGamma <= -32, "internal error");
+
+    // Generates the digits (and the exponent) of a decimal floating-point
+    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
+    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
+    //
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    // Grisu2 generates the digits of M+ from left to right and stops as soon as
+    // V is in [M-,M+].
+
+    JSON_ASSERT(M_plus.e >= kAlpha);
+    JSON_ASSERT(M_plus.e <= kGamma);
+
+    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
+    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
+
+    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
+    //
+    //      M+ = f * 2^e
+    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
+    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
+    //         = p1 + p2 * 2^e
+
+    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
+
+    auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
+    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
+
+    // 1)
+    //
+    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
+
+    JSON_ASSERT(p1 > 0);
+
+    std::uint32_t pow10{};
+    const int k = find_largest_pow10(p1, pow10);
+
+    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
+    //
+    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
+    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
+    //
+    //      M+ = p1                                             + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
+    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
+    //
+    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
+    //
+    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
+    //
+    // but stop as soon as
+    //
+    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
+
+    int n = k;
+    while (n > 0)
+    {
+        // Invariants:
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        //
+        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
+        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
+        //
+        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
+        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
+        //
+        p1 = r;
+        n--;
+        //
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
+        //      pow10 = 10^n
+        //
+
+        // Now check if enough digits have been generated.
+        // Compute
+        //
+        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
+        //
+        // Note:
+        // Since rest and delta share the same exponent e, it suffices to
+        // compare the significands.
+        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
+        if (rest <= delta)
+        {
+            // V = buffer * 10^n, with M- <= V <= M+.
+
+            decimal_exponent += n;
+
+            // We may now just stop. But instead look if the buffer could be
+            // decremented to bring V closer to w.
+            //
+            // pow10 = 10^n is now 1 ulp in the decimal representation V.
+            // The rounding procedure works with diyfp's with an implicit
+            // exponent of e.
+            //
+            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
+            //
+            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
+            grisu2_round(buffer, length, dist, delta, rest, ten_n);
+
+            return;
+        }
+
+        pow10 /= 10;
+        //
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        // Invariants restored.
+    }
+
+    // 2)
+    //
+    // The digits of the integral part have been generated:
+    //
+    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
+    //         = buffer            + p2 * 2^e
+    //
+    // Now generate the digits of the fractional part p2 * 2^e.
+    //
+    // Note:
+    // No decimal point is generated: the exponent is adjusted instead.
+    //
+    // p2 actually represents the fraction
+    //
+    //      p2 * 2^e
+    //          = p2 / 2^-e
+    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
+    //
+    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
+    //
+    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
+    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
+    //
+    // using
+    //
+    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
+    //                = (                   d) * 2^-e + (                   r)
+    //
+    // or
+    //      10^m * p2 * 2^e = d + r * 2^e
+    //
+    // i.e.
+    //
+    //      M+ = buffer + p2 * 2^e
+    //         = buffer + 10^-m * (d + r * 2^e)
+    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
+    //
+    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
+
+    JSON_ASSERT(p2 > delta);
+
+    int m = 0;
+    for (;;)
+    {
+        // Invariant:
+        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
+        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
+        //
+        JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
+        p2 *= 10;
+        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
+        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
+        //
+        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
+        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        p2 = r;
+        m++;
+        //
+        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
+        // Invariant restored.
+
+        // Check if enough digits have been generated.
+        //
+        //      10^-m * p2 * 2^e <= delta * 2^e
+        //              p2 * 2^e <= 10^m * delta * 2^e
+        //                    p2 <= 10^m * delta
+        delta *= 10;
+        dist  *= 10;
+        if (p2 <= delta)
+        {
+            break;
+        }
+    }
+
+    // V = buffer * 10^-m, with M- <= V <= M+.
+
+    decimal_exponent -= m;
+
+    // 1 ulp in the decimal representation is now 10^-m.
+    // Since delta and dist are now scaled by 10^m, we need to do the
+    // same with ulp in order to keep the units in sync.
+    //
+    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
+    //
+    const std::uint64_t ten_m = one.f;
+    grisu2_round(buffer, length, dist, delta, p2, ten_m);
+
+    // By construction this algorithm generates the shortest possible decimal
+    // number (Loitsch, Theorem 6.2) which rounds back to w.
+    // For an input number of precision p, at least
+    //
+    //      N = 1 + ceil(p * log_10(2))
+    //
+    // decimal digits are sufficient to identify all binary floating-point
+    // numbers (Matula, "In-and-Out conversions").
+    // This implies that the algorithm does not produce more than N decimal
+    // digits.
+    //
+    //      N = 17 for p = 53 (IEEE double precision)
+    //      N = 9  for p = 24 (IEEE single precision)
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline void grisu2(char* buf, int& len, int& decimal_exponent,
+                   diyfp m_minus, diyfp v, diyfp m_plus)
+{
+    JSON_ASSERT(m_plus.e == m_minus.e);
+    JSON_ASSERT(m_plus.e == v.e);
+
+    //  --------(-----------------------+-----------------------)--------    (A)
+    //          m-                      v                       m+
+    //
+    //  --------------------(-----------+-----------------------)--------    (B)
+    //                      m-          v                       m+
+    //
+    // First scale v (and m- and m+) such that the exponent is in the range
+    // [alpha, gamma].
+
+    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
+
+    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
+
+    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
+    const diyfp w       = diyfp::mul(v,       c_minus_k);
+    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
+    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
+
+    //  ----(---+---)---------------(---+---)---------------(---+---)----
+    //          w-                      w                       w+
+    //          = c*m-                  = c*v                   = c*m+
+    //
+    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
+    // w+ are now off by a small amount.
+    // In fact:
+    //
+    //      w - v * 10^k < 1 ulp
+    //
+    // To account for this inaccuracy, add resp. subtract 1 ulp.
+    //
+    //  --------+---[---------------(---+---)---------------]---+--------
+    //          w-  M-                  w                   M+  w+
+    //
+    // Now any number in [M-, M+] (bounds included) will round to w when input,
+    // regardless of how the input rounding algorithm breaks ties.
+    //
+    // And digit_gen generates the shortest possible such number in [M-, M+].
+    // Note that this does not mean that Grisu2 always generates the shortest
+    // possible number in the interval (m-, m+).
+    const diyfp M_minus(w_minus.f + 1, w_minus.e);
+    const diyfp M_plus (w_plus.f  - 1, w_plus.e );
+
+    decimal_exponent = -cached.k; // = -(-k) = k
+
+    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1)
+void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
+{
+    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
+                  "internal error: not enough precision");
+
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
+    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
+    // decimal representations are not exactly "short".
+    //
+    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
+    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
+    // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
+    // does.
+    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
+    // representation using the corresponding std::from_chars function recovers value exactly". That
+    // indicates that single precision floating-point numbers should be recovered using
+    // 'std::strtof'.
+    //
+    // NB: If the neighbors are computed for single-precision numbers, there is a single float
+    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
+    //     value is off by 1 ulp.
+#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
+    const boundaries w = compute_boundaries(static_cast<double>(value));
+#else
+    const boundaries w = compute_boundaries(value);
+#endif
+
+    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
+}
+
+/*!
+@brief appends a decimal representation of e to buf
+@return a pointer to the element following the exponent.
+@pre -1000 < e < 1000
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* append_exponent(char* buf, int e)
+{
+    JSON_ASSERT(e > -1000);
+    JSON_ASSERT(e <  1000);
+
+    if (e < 0)
+    {
+        e = -e;
+        *buf++ = '-';
+    }
+    else
+    {
+        *buf++ = '+';
+    }
+
+    auto k = static_cast<std::uint32_t>(e);
+    if (k < 10)
+    {
+        // Always print at least two digits in the exponent.
+        // This is for compatibility with printf("%g").
+        *buf++ = '0';
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else if (k < 100)
+    {
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else
+    {
+        *buf++ = static_cast<char>('0' + k / 100);
+        k %= 100;
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+
+    return buf;
+}
+
+/*!
+@brief prettify v = buf * 10^decimal_exponent
+
+If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
+notation. Otherwise it will be printed in exponential notation.
+
+@pre min_exp < 0
+@pre max_exp > 0
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* format_buffer(char* buf, int len, int decimal_exponent,
+                           int min_exp, int max_exp)
+{
+    JSON_ASSERT(min_exp < 0);
+    JSON_ASSERT(max_exp > 0);
+
+    const int k = len;
+    const int n = len + decimal_exponent;
+
+    // v = buf * 10^(n-k)
+    // k is the length of the buffer (number of decimal digits)
+    // n is the position of the decimal point relative to the start of the buffer.
+
+    if (k <= n && n <= max_exp)
+    {
+        // digits[000]
+        // len <= max_exp + 2
+
+        std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
+        // Make it look like a floating-point number (#362, #378)
+        buf[n + 0] = '.';
+        buf[n + 1] = '0';
+        return buf + (static_cast<size_t>(n) + 2);
+    }
+
+    if (0 < n && n <= max_exp)
+    {
+        // dig.its
+        // len <= max_digits10 + 1
+
+        JSON_ASSERT(k > n);
+
+        std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
+        buf[n] = '.';
+        return buf + (static_cast<size_t>(k) + 1U);
+    }
+
+    if (min_exp < n && n <= 0)
+    {
+        // 0.[000]digits
+        // len <= 2 + (-min_exp - 1) + max_digits10
+
+        std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
+        buf[0] = '0';
+        buf[1] = '.';
+        std::memset(buf + 2, '0', static_cast<size_t>(-n));
+        return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
+    }
+
+    if (k == 1)
+    {
+        // dE+123
+        // len <= 1 + 5
+
+        buf += 1;
+    }
+    else
+    {
+        // d.igitsE+123
+        // len <= max_digits10 + 1 + 5
+
+        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
+        buf[1] = '.';
+        buf += 1 + static_cast<size_t>(k);
+    }
+
+    *buf++ = 'e';
+    return append_exponent(buf, n - 1);
+}
+
+}  // namespace dtoa_impl
+
+/*!
+@brief generates a decimal representation of the floating-point number value in [first, last).
+
+The format of the resulting decimal representation is similar to printf's %g
+format. Returns an iterator pointing past-the-end of the decimal representation.
+
+@note The input number must be finite, i.e. NaN's and Inf's are not supported.
+@note The buffer must be large enough.
+@note The result is NOT null-terminated.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1, 2)
+JSON_HEDLEY_RETURNS_NON_NULL
+char* to_chars(char* first, const char* last, FloatType value)
+{
+    static_cast<void>(last); // maybe unused - fix warning
+    JSON_ASSERT(std::isfinite(value));
+
+    // Use signbit(value) instead of (value < 0) since signbit works for -0.
+    if (std::signbit(value))
+    {
+        value = -value;
+        *first++ = '-';
+    }
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+    if (value == 0) // +-0
+    {
+        *first++ = '0';
+        // Make it look like a floating-point number (#362, #378)
+        *first++ = '.';
+        *first++ = '0';
+        return first;
+    }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
+
+    // Compute v = buffer * 10^decimal_exponent.
+    // The decimal digits are stored in the buffer, which needs to be interpreted
+    // as an unsigned decimal integer.
+    // len is the length of the buffer, i.e. the number of decimal digits.
+    int len = 0;
+    int decimal_exponent = 0;
+    dtoa_impl::grisu2(first, len, decimal_exponent, value);
+
+    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
+
+    // Format the buffer like printf("%.*g", prec, value)
+    constexpr int kMinExp = -4;
+    // Use digits10 here to increase compatibility with version 2.
+    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
+
+    JSON_ASSERT(last - first >= kMaxExp + 2);
+    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
+
+    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/conversions/to_json.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/conversions/to_json.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e39b7797dd2cf73f018adc241471f94a164c999b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/conversions/to_json.hpp
@@ -0,0 +1,446 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <algorithm> // copy
+#include <iterator> // begin, end
+#include <string> // string
+#include <tuple> // tuple, get
+#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
+#include <utility> // move, forward, declval, pair
+#include <valarray> // valarray
+#include <vector> // vector
+
+#include <nlohmann/detail/iterators/iteration_proxy.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/meta/cpp_future.hpp>
+#include <nlohmann/detail/meta/std_fs.hpp>
+#include <nlohmann/detail/meta/type_traits.hpp>
+#include <nlohmann/detail/value_t.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+//////////////////
+// constructors //
+//////////////////
+
+/*
+ * Note all external_constructor<>::construct functions need to call
+ * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an
+ * allocated value (e.g., a string). See bug issue
+ * https://github.com/nlohmann/json/issues/2865 for more information.
+ */
+
+template<value_t> struct external_constructor;
+
+template<>
+struct external_constructor<value_t::boolean>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::boolean;
+        j.m_data.m_value = b;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::string>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value = s;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value = std::move(s);
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleStringType,
+               enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleStringType& str)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::binary>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::binary;
+        j.m_data.m_value = typename BasicJsonType::binary_t(b);
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::binary;
+        j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_float>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_float;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_unsigned>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_unsigned;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_integer>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_integer;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::array>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = arr;
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = std::move(arr);
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleArrayType,
+               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->reserve(arr.size());
+        for (const bool x : arr)
+        {
+            j.m_data.m_value.array->push_back(x);
+            j.set_parent(j.m_data.m_value.array->back());
+        }
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename T,
+             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->resize(arr.size());
+        if (arr.size() > 0)
+        {
+            std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin());
+        }
+        j.set_parents();
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::object>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value = obj;
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value = std::move(obj);
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleObjectType,
+               enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
+        j.set_parents();
+        j.assert_invariant();
+    }
+};
+
+/////////////
+// to_json //
+/////////////
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
+inline void to_json(BasicJsonType& j, T b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, b);
+}
+
+template < typename BasicJsonType, typename BoolRef,
+           enable_if_t <
+               ((std::is_same<std::vector<bool>::reference, BoolRef>::value
+                 && !std::is_same <std::vector<bool>::reference, typename BasicJsonType::boolean_t&>::value)
+                || (std::is_same<std::vector<bool>::const_reference, BoolRef>::value
+                    && !std::is_same <detail::uncvref_t<std::vector<bool>::const_reference>,
+                                      typename BasicJsonType::boolean_t >::value))
+               && std::is_convertible<const BoolRef&, typename BasicJsonType::boolean_t>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const BoolRef& b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, static_cast<typename BasicJsonType::boolean_t>(b));
+}
+
+template<typename BasicJsonType, typename CompatibleString,
+         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const CompatibleString& s)
+{
+    external_constructor<value_t::string>::construct(j, s);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+{
+    external_constructor<value_t::string>::construct(j, std::move(s));
+}
+
+template<typename BasicJsonType, typename FloatType,
+         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, FloatType val) noexcept
+{
+    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
+{
+    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberIntegerType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
+{
+    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
+}
+
+#if !JSON_DISABLE_ENUM_SERIALIZATION
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, EnumType e) noexcept
+{
+    using underlying_type = typename std::underlying_type<EnumType>::type;
+    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
+}
+#endif  // JSON_DISABLE_ENUM_SERIALIZATION
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const std::vector<bool>& e)
+{
+    external_constructor<value_t::array>::construct(j, e);
+}
+
+template < typename BasicJsonType, typename CompatibleArrayType,
+           enable_if_t < is_compatible_array_type<BasicJsonType,
+                         CompatibleArrayType>::value&&
+                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
+                         !is_basic_json<CompatibleArrayType>::value,
+                         int > = 0 >
+inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
+{
+    external_constructor<value_t::binary>::construct(j, bin);
+}
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template < typename BasicJsonType, typename CompatibleObjectType,
+           enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
+{
+    external_constructor<value_t::object>::construct(j, obj);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+{
+    external_constructor<value_t::object>::construct(j, std::move(obj));
+}
+
+template <
+    typename BasicJsonType, typename T, std::size_t N,
+    enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
+                  const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+                  int > = 0 >
+inline void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
+{
+    j = { p.first, p.second };
+}
+
+// for https://github.com/nlohmann/json/pull/1134
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const T& b)
+{
+    j = { {b.key(), b.value()} };
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    j = { std::get<Idx>(t)... };
+}
+
+template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
+inline void to_json(BasicJsonType& j, const T& t)
+{
+    to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
+}
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const std_fs::path& p)
+{
+    j = p.string();
+}
+#endif
+
+struct to_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
+    -> decltype(to_json(j, std::forward<T>(val)), void())
+    {
+        return to_json(j, std::forward<T>(val));
+    }
+};
+}  // namespace detail
+
+#ifndef JSON_HAS_CPP_17
+/// namespace to hold default `to_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+{
+#endif
+JSON_INLINE_VARIABLE constexpr const auto& to_json = // NOLINT(misc-definitions-in-headers)
+    detail::static_const<detail::to_json_fn>::value;
+#ifndef JSON_HAS_CPP_17
+}  // namespace
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/exceptions.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/exceptions.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..5974d7be2b474fdc3d39ce4d06cb1e183a7057c2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/exceptions.hpp
@@ -0,0 +1,257 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstddef> // nullptr_t
+#include <exception> // exception
+#if JSON_DIAGNOSTICS
+    #include <numeric> // accumulate
+#endif
+#include <stdexcept> // runtime_error
+#include <string> // to_string
+#include <vector> // vector
+
+#include <nlohmann/detail/value_t.hpp>
+#include <nlohmann/detail/string_escape.hpp>
+#include <nlohmann/detail/input/position_t.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/meta/cpp_future.hpp>
+#include <nlohmann/detail/meta/type_traits.hpp>
+#include <nlohmann/detail/string_concat.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+////////////////
+// exceptions //
+////////////////
+
+/// @brief general exception of the @ref basic_json class
+/// @sa https://json.nlohmann.me/api/basic_json/exception/
+class exception : public std::exception
+{
+  public:
+    /// returns the explanatory string
+    const char* what() const noexcept override
+    {
+        return m.what();
+    }
+
+    /// the id of the exception
+    const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
+
+  protected:
+    JSON_HEDLEY_NON_NULL(3)
+    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
+
+    static std::string name(const std::string& ename, int id_)
+    {
+        return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
+    }
+
+    static std::string diagnostics(std::nullptr_t /*leaf_element*/)
+    {
+        return "";
+    }
+
+    template<typename BasicJsonType>
+    static std::string diagnostics(const BasicJsonType* leaf_element)
+    {
+#if JSON_DIAGNOSTICS
+        std::vector<std::string> tokens;
+        for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent)
+        {
+            switch (current->m_parent->type())
+            {
+                case value_t::array:
+                {
+                    for (std::size_t i = 0; i < current->m_parent->m_data.m_value.array->size(); ++i)
+                    {
+                        if (&current->m_parent->m_data.m_value.array->operator[](i) == current)
+                        {
+                            tokens.emplace_back(std::to_string(i));
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                case value_t::object:
+                {
+                    for (const auto& element : *current->m_parent->m_data.m_value.object)
+                    {
+                        if (&element.second == current)
+                        {
+                            tokens.emplace_back(element.first.c_str());
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                case value_t::null: // LCOV_EXCL_LINE
+                case value_t::string: // LCOV_EXCL_LINE
+                case value_t::boolean: // LCOV_EXCL_LINE
+                case value_t::number_integer: // LCOV_EXCL_LINE
+                case value_t::number_unsigned: // LCOV_EXCL_LINE
+                case value_t::number_float: // LCOV_EXCL_LINE
+                case value_t::binary: // LCOV_EXCL_LINE
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:   // LCOV_EXCL_LINE
+                    break; // LCOV_EXCL_LINE
+            }
+        }
+
+        if (tokens.empty())
+        {
+            return "";
+        }
+
+        auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
+                                   [](const std::string & a, const std::string & b)
+        {
+            return concat(a, '/', detail::escape(b));
+        });
+        return concat('(', str, ") ");
+#else
+        static_cast<void>(leaf_element);
+        return "";
+#endif
+    }
+
+  private:
+    /// an exception object as storage for error messages
+    std::runtime_error m;
+};
+
+/// @brief exception indicating a parse error
+/// @sa https://json.nlohmann.me/api/basic_json/parse_error/
+class parse_error : public exception
+{
+  public:
+    /*!
+    @brief create a parse error exception
+    @param[in] id_       the id of the exception
+    @param[in] pos       the position where the error occurred (or with
+                         chars_read_total=0 if the position cannot be
+                         determined)
+    @param[in] what_arg  the explanatory string
+    @return parse_error object
+    */
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("parse_error", id_), "parse error",
+                                     position_string(pos), ": ", exception::diagnostics(context), what_arg);
+        return {id_, pos.chars_read_total, w.c_str()};
+    }
+
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("parse_error", id_), "parse error",
+                                     (byte_ != 0 ? (concat(" at byte ", std::to_string(byte_))) : ""),
+                                     ": ", exception::diagnostics(context), what_arg);
+        return {id_, byte_, w.c_str()};
+    }
+
+    /*!
+    @brief byte index of the parse error
+
+    The byte index of the last read character in the input file.
+
+    @note For an input with n bytes, 1 is the index of the first character and
+          n+1 is the index of the terminating null byte or the end of file.
+          This also holds true when reading a byte vector (CBOR or MessagePack).
+    */
+    const std::size_t byte;
+
+  private:
+    parse_error(int id_, std::size_t byte_, const char* what_arg)
+        : exception(id_, what_arg), byte(byte_) {}
+
+    static std::string position_string(const position_t& pos)
+    {
+        return concat(" at line ", std::to_string(pos.lines_read + 1),
+                      ", column ", std::to_string(pos.chars_read_current_line));
+    }
+};
+
+/// @brief exception indicating errors with iterators
+/// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/
+class invalid_iterator : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    invalid_iterator(int id_, const char* what_arg)
+        : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating executing a member function with a wrong type
+/// @sa https://json.nlohmann.me/api/basic_json/type_error/
+class type_error : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating access out of the defined range
+/// @sa https://json.nlohmann.me/api/basic_json/out_of_range/
+class out_of_range : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating other library errors
+/// @sa https://json.nlohmann.me/api/basic_json/other_error/
+class other_error : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static other_error create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/hash.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/hash.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..4464e8e67bb0e768fb8dcfad1983a838701e4bda
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/hash.hpp
@@ -0,0 +1,129 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstdint> // uint8_t
+#include <cstddef> // size_t
+#include <functional> // hash
+
+#include <nlohmann/detail/abi_macros.hpp>
+#include <nlohmann/detail/value_t.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// boost::hash_combine
+inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
+{
+    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
+    return seed;
+}
+
+/*!
+@brief hash a JSON value
+
+The hash function tries to rely on std::hash where possible. Furthermore, the
+type of the JSON value is taken into account to have different hash values for
+null, 0, 0U, and false, etc.
+
+@tparam BasicJsonType basic_json specialization
+@param j JSON value to hash
+@return hash value of j
+*/
+template<typename BasicJsonType>
+std::size_t hash(const BasicJsonType& j)
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+    const auto type = static_cast<std::size_t>(j.type());
+    switch (j.type())
+    {
+        case BasicJsonType::value_t::null:
+        case BasicJsonType::value_t::discarded:
+        {
+            return combine(type, 0);
+        }
+
+        case BasicJsonType::value_t::object:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j.items())
+            {
+                const auto h = std::hash<string_t> {}(element.key());
+                seed = combine(seed, h);
+                seed = combine(seed, hash(element.value()));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::array:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j)
+            {
+                seed = combine(seed, hash(element));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::string:
+        {
+            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::boolean:
+        {
+            const auto h = std::hash<bool> {}(j.template get<bool>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_integer:
+        {
+            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_unsigned:
+        {
+            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_float:
+        {
+            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::binary:
+        {
+            auto seed = combine(type, j.get_binary().size());
+            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
+            seed = combine(seed, h);
+            seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
+            for (const auto byte : j.get_binary())
+            {
+                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
+            }
+            return seed;
+        }
+
+        default:                   // LCOV_EXCL_LINE
+            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            return 0;              // LCOV_EXCL_LINE
+    }
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/binary_reader.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/binary_reader.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a6e100e7611e46f93e91326acd7710c15ba10edc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/binary_reader.hpp
@@ -0,0 +1,3009 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <algorithm> // generate_n
+#include <array> // array
+#include <cmath> // ldexp
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstdio> // snprintf
+#include <cstring> // memcpy
+#include <iterator> // back_inserter
+#include <limits> // numeric_limits
+#include <string> // char_traits, string
+#include <utility> // make_pair, move
+#include <vector> // vector
+
+#include <nlohmann/detail/exceptions.hpp>
+#include <nlohmann/detail/input/input_adapters.hpp>
+#include <nlohmann/detail/input/json_sax.hpp>
+#include <nlohmann/detail/input/lexer.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/meta/is_sax.hpp>
+#include <nlohmann/detail/meta/type_traits.hpp>
+#include <nlohmann/detail/string_concat.hpp>
+#include <nlohmann/detail/value_t.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// how to treat CBOR tags
+enum class cbor_tag_handler_t
+{
+    error,   ///< throw a parse_error exception in case of a tag
+    ignore,  ///< ignore tags
+    store    ///< store tags as binary type
+};
+
+/*!
+@brief determine system byte order
+
+@return true if and only if system's byte order is little endian
+
+@note from https://stackoverflow.com/a/1001328/266378
+*/
+static inline bool little_endianness(int num = 1) noexcept
+{
+    return *reinterpret_cast<char*>(&num) == 1;
+}
+
+///////////////////
+// binary reader //
+///////////////////
+
+/*!
+@brief deserialization of CBOR, MessagePack, and UBJSON values
+*/
+template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
+class binary_reader
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using json_sax_t = SAX;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename char_traits<char_type>::int_type;
+
+  public:
+    /*!
+    @brief create a binary reader
+
+    @param[in] adapter  input adapter to read from
+    */
+    explicit binary_reader(InputAdapterType&& adapter, const input_format_t format = input_format_t::json) noexcept : ia(std::move(adapter)), input_format(format)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+    }
+
+    // make class move-only
+    binary_reader(const binary_reader&) = delete;
+    binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    binary_reader& operator=(const binary_reader&) = delete;
+    binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~binary_reader() = default;
+
+    /*!
+    @param[in] format  the binary format to parse
+    @param[in] sax_    a SAX event processor
+    @param[in] strict  whether to expect the input to be consumed completed
+    @param[in] tag_handler  how to treat CBOR tags
+
+    @return whether parsing was successful
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool sax_parse(const input_format_t format,
+                   json_sax_t* sax_,
+                   const bool strict = true,
+                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        sax = sax_;
+        bool result = false;
+
+        switch (format)
+        {
+            case input_format_t::bson:
+                result = parse_bson_internal();
+                break;
+
+            case input_format_t::cbor:
+                result = parse_cbor_internal(true, tag_handler);
+                break;
+
+            case input_format_t::msgpack:
+                result = parse_msgpack_internal();
+                break;
+
+            case input_format_t::ubjson:
+            case input_format_t::bjdata:
+                result = parse_ubjson_internal();
+                break;
+
+            case input_format_t::json: // LCOV_EXCL_LINE
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+        // strict mode: next byte must be EOF
+        if (result && strict)
+        {
+            if (input_format == input_format_t::ubjson || input_format == input_format_t::bjdata)
+            {
+                get_ignore_noop();
+            }
+            else
+            {
+                get();
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(current != char_traits<char_type>::eof()))
+            {
+                return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read,
+                                        exception_message(input_format, concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr));
+            }
+        }
+
+        return result;
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @brief Reads in a BSON-object and passes it to the SAX-parser.
+    @return whether a valid BSON-value was passed to the SAX parser
+    */
+    bool parse_bson_internal()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
+        {
+            return false;
+        }
+
+        return sax->end_object();
+    }
+
+    /*!
+    @brief Parses a C-style string from the BSON input.
+    @param[in,out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @return `true` if the \x00-byte indicating the end of the string was
+             encountered before the EOF; false` indicates an unexpected EOF.
+    */
+    bool get_bson_cstr(string_t& result)
+    {
+        auto out = std::back_inserter(result);
+        while (true)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
+            {
+                return false;
+            }
+            if (current == 0x00)
+            {
+                return true;
+            }
+            *out++ = static_cast<typename string_t::value_type>(current);
+        }
+    }
+
+    /*!
+    @brief Parses a zero-terminated string of length @a len from the BSON
+           input.
+    @param[in] len  The length (including the zero-byte at the end) of the
+                    string to be read.
+    @param[in,out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 1
+    @return `true` if the string was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_string(const NumberType len, string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 1))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr));
+        }
+
+        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != char_traits<char_type>::eof();
+    }
+
+    /*!
+    @brief Parses a byte array input of length @a len from the BSON input.
+    @param[in] len  The length of the byte array to be read.
+    @param[in,out] result  A reference to the binary variable where the read
+                            array is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 0
+    @return `true` if the byte array was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_binary(const NumberType len, binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 0))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr));
+        }
+
+        // All BSON binary values have a subtype
+        std::uint8_t subtype{};
+        get_number<std::uint8_t>(input_format_t::bson, subtype);
+        result.set_subtype(subtype);
+
+        return get_binary(input_format_t::bson, len, result);
+    }
+
+    /*!
+    @brief Read a BSON document element of the given @a element_type.
+    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
+    @param[in] element_type_parse_position The position in the input stream,
+               where the `element_type` was read.
+    @warning Not all BSON element types are supported yet. An unsupported
+             @a element_type will give rise to a parse_error.114:
+             Unsupported BSON record type 0x...
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_internal(const char_int_type element_type,
+                                     const std::size_t element_type_parse_position)
+    {
+        switch (element_type)
+        {
+            case 0x01: // double
+            {
+                double number{};
+                return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0x02: // string
+            {
+                std::int32_t len{};
+                string_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
+            }
+
+            case 0x03: // object
+            {
+                return parse_bson_internal();
+            }
+
+            case 0x04: // array
+            {
+                return parse_bson_array();
+            }
+
+            case 0x05: // binary
+            {
+                std::int32_t len{};
+                binary_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
+            }
+
+            case 0x08: // boolean
+            {
+                return sax->boolean(get() != 0);
+            }
+
+            case 0x0A: // null
+            {
+                return sax->null();
+            }
+
+            case 0x10: // int32
+            {
+                std::int32_t value{};
+                return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            case 0x12: // int64
+            {
+                std::int64_t value{};
+                return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            default: // anything else not supported (yet)
+            {
+                std::array<char, 3> cr{{}};
+                static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                const std::string cr_str{cr.data()};
+                return sax->parse_error(element_type_parse_position, cr_str,
+                                        parse_error::create(114, element_type_parse_position, concat("Unsupported BSON record type 0x", cr_str), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief Read a BSON element list (as specified in the BSON-spec)
+
+    The same binary layout is used for objects and arrays, hence it must be
+    indicated with the argument @a is_array which one is expected
+    (true --> array, false --> object).
+
+    @param[in] is_array Determines if the element list being read is to be
+                        treated as an object (@a is_array == false), or as an
+                        array (@a is_array == true).
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_list(const bool is_array)
+    {
+        string_t key;
+
+        while (auto element_type = get())
+        {
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
+            {
+                return false;
+            }
+
+            const std::size_t element_type_parse_position = chars_read;
+            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
+            {
+                return false;
+            }
+
+            if (!is_array && !sax->key(key))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
+            {
+                return false;
+            }
+
+            // get_bson_cstr only appends
+            key.clear();
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief Reads an array from the BSON input and passes it to the SAX-parser.
+    @return whether a valid BSON-array was passed to the SAX parser
+    */
+    bool parse_bson_array()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
+        {
+            return false;
+        }
+
+        return sax->end_array();
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true) or whether the last read character should
+                         be considered instead (false)
+    @param[in] tag_handler how CBOR tags should be treated
+
+    @return whether a valid CBOR value was passed to the SAX parser
+    */
+    bool parse_cbor_internal(const bool get_char,
+                             const cbor_tag_handler_t tag_handler)
+    {
+        switch (get_char ? get() : current)
+        {
+            // EOF
+            case char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::cbor, "value");
+
+            // Integer 0x00..0x17 (0..23)
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            case 0x18: // Unsigned integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x19: // Unsigned integer (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            // Negative integer -1-0x00..-1-0x17 (-1..-24)
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
+
+            case 0x38: // Negative integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
+                        - static_cast<number_integer_t>(number));
+            }
+
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            case 0x5F: // Binary data (indefinite length)
+            {
+                binary_t b;
+                return get_cbor_binary(b) && sax->binary(b);
+            }
+
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                string_t s;
+                return get_cbor_string(s) && sax->string(s);
+            }
+
+            // array (0x00..0x17 data items follow)
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+                return get_cbor_array(
+                           conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0x98: // array (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x99: // array (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9A: // array (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9B: // array (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9F: // array (indefinite length)
+                return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);
+
+            // map (0x00..0x17 pairs of data items follow)
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+                return get_cbor_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0xB8: // map (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xB9: // map (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBA: // map (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBB: // map (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBF: // map (indefinite length)
+                return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);
+
+            case 0xC6: // tagged item
+            case 0xC7:
+            case 0xC8:
+            case 0xC9:
+            case 0xCA:
+            case 0xCB:
+            case 0xCC:
+            case 0xCD:
+            case 0xCE:
+            case 0xCF:
+            case 0xD0:
+            case 0xD1:
+            case 0xD2:
+            case 0xD3:
+            case 0xD4:
+            case 0xD8: // tagged item (1 bytes follow)
+            case 0xD9: // tagged item (2 bytes follow)
+            case 0xDA: // tagged item (4 bytes follow)
+            case 0xDB: // tagged item (8 bytes follow)
+            {
+                switch (tag_handler)
+                {
+                    case cbor_tag_handler_t::error:
+                    {
+                        auto last_token = get_token_string();
+                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                                exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
+                    }
+
+                    case cbor_tag_handler_t::ignore:
+                    {
+                        // ignore binary subtype
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            default:
+                                break;
+                        }
+                        return parse_cbor_internal(true, tag_handler);
+                    }
+
+                    case cbor_tag_handler_t::store:
+                    {
+                        binary_t b;
+                        // use binary subtype and store in binary container
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            default:
+                                return parse_cbor_internal(true, tag_handler);
+                        }
+                        get();
+                        return get_cbor_binary(b) && sax->binary(b);
+                    }
+
+                    default:                 // LCOV_EXCL_LINE
+                        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+                        return false;        // LCOV_EXCL_LINE
+                }
+            }
+
+            case 0xF4: // false
+                return sax->boolean(false);
+
+            case 0xF5: // true
+                return sax->boolean(true);
+
+            case 0xF6: // null
+                return sax->null();
+
+            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
+            {
+                const auto byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+                const auto byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
+            {
+                float number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
+            {
+                double number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            default: // anything else (0xFF is handled inside the other types)
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+    Additionally, CBOR's strings with indefinite lengths are supported.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_cbor_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            {
+                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    string_t chunk;
+                    if (!get_cbor_string(chunk))
+                    {
+                        return false;
+                    }
+                    result.append(chunk);
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::cbor, concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into the byte array.
+    Additionally, CBOR's byte arrays with indefinite lengths are supported.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_cbor_binary(binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            {
+                return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5F: // Binary data (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    binary_t chunk;
+                    if (!get_cbor_binary(chunk))
+                    {
+                        return false;
+                    }
+                    result.insert(result.end(), chunk.begin(), chunk.end());
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::cbor, concat("expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x", last_token), "binary"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array or static_cast<std::size_t>(-1) for an
+                    array of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether array creation completed
+    */
+    bool get_cbor_array(const std::size_t len,
+                        const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        if (len != static_cast<std::size_t>(-1))
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object or static_cast<std::size_t>(-1) for an
+                    object of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether object creation completed
+    */
+    bool get_cbor_object(const std::size_t len,
+                         const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        if (len != 0)
+        {
+            string_t key;
+            if (len != static_cast<std::size_t>(-1))
+            {
+                for (std::size_t i = 0; i < len; ++i)
+                {
+                    get();
+                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                while (get() != 0xFF)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    /*!
+    @return whether a valid MessagePack value was passed to the SAX parser
+    */
+    bool parse_msgpack_internal()
+    {
+        switch (get())
+        {
+            // EOF
+            case char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::msgpack, "value");
+
+            // positive fixint
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+            case 0x18:
+            case 0x19:
+            case 0x1A:
+            case 0x1B:
+            case 0x1C:
+            case 0x1D:
+            case 0x1E:
+            case 0x1F:
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+            case 0x38:
+            case 0x39:
+            case 0x3A:
+            case 0x3B:
+            case 0x3C:
+            case 0x3D:
+            case 0x3E:
+            case 0x3F:
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58:
+            case 0x59:
+            case 0x5A:
+            case 0x5B:
+            case 0x5C:
+            case 0x5D:
+            case 0x5E:
+            case 0x5F:
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78:
+            case 0x79:
+            case 0x7A:
+            case 0x7B:
+            case 0x7C:
+            case 0x7D:
+            case 0x7E:
+            case 0x7F:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            // fixmap
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+                return get_msgpack_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixarray
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+            case 0x98:
+            case 0x99:
+            case 0x9A:
+            case 0x9B:
+            case 0x9C:
+            case 0x9D:
+            case 0x9E:
+            case 0x9F:
+                return get_msgpack_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            case 0xD9: // str 8
+            case 0xDA: // str 16
+            case 0xDB: // str 32
+            {
+                string_t s;
+                return get_msgpack_string(s) && sax->string(s);
+            }
+
+            case 0xC0: // nil
+                return sax->null();
+
+            case 0xC2: // false
+                return sax->boolean(false);
+
+            case 0xC3: // true
+                return sax->boolean(true);
+
+            case 0xC4: // bin 8
+            case 0xC5: // bin 16
+            case 0xC6: // bin 32
+            case 0xC7: // ext 8
+            case 0xC8: // ext 16
+            case 0xC9: // ext 32
+            case 0xD4: // fixext 1
+            case 0xD5: // fixext 2
+            case 0xD6: // fixext 4
+            case 0xD7: // fixext 8
+            case 0xD8: // fixext 16
+            {
+                binary_t b;
+                return get_msgpack_binary(b) && sax->binary(b);
+            }
+
+            case 0xCA: // float 32
+            {
+                float number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCB: // float 64
+            {
+                double number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCC: // uint 8
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCD: // uint 16
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCE: // uint 32
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCF: // uint 64
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xD0: // int 8
+            {
+                std::int8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD1: // int 16
+            {
+                std::int16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD2: // int 32
+            {
+                std::int32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD3: // int 64
+            {
+                std::int64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xDC: // array 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDD: // array 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(conditional_static_cast<std::size_t>(len));
+            }
+
+            case 0xDE: // map 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xDF: // map 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(conditional_static_cast<std::size_t>(len));
+            }
+
+            // negative fixint
+            case 0xE0:
+            case 0xE1:
+            case 0xE2:
+            case 0xE3:
+            case 0xE4:
+            case 0xE5:
+            case 0xE6:
+            case 0xE7:
+            case 0xE8:
+            case 0xE9:
+            case 0xEA:
+            case 0xEB:
+            case 0xEC:
+            case 0xED:
+            case 0xEE:
+            case 0xEF:
+            case 0xF0:
+            case 0xF1:
+            case 0xF2:
+            case 0xF3:
+            case 0xF4:
+            case 0xF5:
+            case 0xF6:
+            case 0xF7:
+            case 0xF8:
+            case 0xF9:
+            case 0xFA:
+            case 0xFB:
+            case 0xFC:
+            case 0xFD:
+            case 0xFE:
+            case 0xFF:
+                return sax->number_integer(static_cast<std::int8_t>(current));
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format_t::msgpack, concat("invalid byte: 0x", last_token), "value"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_msgpack_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            {
+                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0xD9: // str 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDA: // str 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDB: // str 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::msgpack, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into a byte array.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_msgpack_binary(binary_t& result)
+    {
+        // helper function to set the subtype
+        auto assign_and_return_true = [&result](std::int8_t subtype)
+        {
+            result.set_subtype(static_cast<std::uint8_t>(subtype));
+            return true;
+        };
+
+        switch (current)
+        {
+            case 0xC4: // bin 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC5: // bin 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC6: // bin 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC7: // ext 8
+            {
+                std::uint8_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC8: // ext 16
+            {
+                std::uint16_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC9: // ext 32
+            {
+                std::uint32_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD4: // fixext 1
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 1, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD5: // fixext 2
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 2, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD6: // fixext 4
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 4, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD7: // fixext 8
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 8, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD8: // fixext 16
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 16, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            default:           // LCOV_EXCL_LINE
+                return false;  // LCOV_EXCL_LINE
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array
+    @return whether array creation completed
+    */
+    bool get_msgpack_array(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object
+    @return whether object creation completed
+    */
+    bool get_msgpack_object(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+            key.clear();
+        }
+
+        return sax->end_object();
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether a valid UBJSON value was passed to the SAX parser
+    */
+    bool parse_ubjson_internal(const bool get_char = true)
+    {
+        return get_ubjson_value(get_char ? get_ignore_noop() : current);
+    }
+
+    /*!
+    @brief reads a UBJSON string
+
+    This function is either called after reading the 'S' byte explicitly
+    indicating a string, or in case of an object key where the 'S' byte can be
+    left out.
+
+    @param[out] result   created string
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether string creation completed
+    */
+    bool get_ubjson_string(string_t& result, const bool get_char = true)
+    {
+        if (get_char)
+        {
+            get();  // TODO(niels): may we ignore N here?
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            case 'U':
+            {
+                std::uint8_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'i':
+            {
+                std::int8_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'I':
+            {
+                std::int16_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'l':
+            {
+                std::int32_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'L':
+            {
+                std::int64_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            default:
+                break;
+        }
+        auto last_token = get_token_string();
+        std::string message;
+
+        if (input_format != input_format_t::bjdata)
+        {
+            message = "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token;
+        }
+        else
+        {
+            message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token;
+        }
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr));
+    }
+
+    /*!
+    @param[out] dim  an integer vector storing the ND array dimensions
+    @return whether reading ND array size vector is successful
+    */
+    bool get_ubjson_ndarray_size(std::vector<size_t>& dim)
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        size_t dimlen = 0;
+        bool no_ndarray = true;
+
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type, no_ndarray)))
+        {
+            return false;
+        }
+
+        if (size_and_type.first != npos)
+        {
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, size_and_type.second)))
+                        {
+                            return false;
+                        }
+                        dim.push_back(dimlen);
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray)))
+                    {
+                        return false;
+                    }
+                    dim.push_back(dimlen);
+                }
+            }
+        }
+        else
+        {
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, current)))
+                {
+                    return false;
+                }
+                dim.push_back(dimlen);
+                get_ignore_noop();
+            }
+        }
+        return true;
+    }
+
+    /*!
+    @param[out] result  determined size
+    @param[in,out] is_ndarray  for input, `true` means already inside an ndarray vector
+                               or ndarray dimension is not allowed; `false` means ndarray
+                               is allowed; for output, `true` means an ndarray is found;
+                               is_ndarray can only return `true` when its initial value
+                               is `false`
+    @param[in] prefix  type marker if already read, otherwise set to 0
+
+    @return whether size determination completed
+    */
+    bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0)
+    {
+        if (prefix == 0)
+        {
+            prefix = get_ignore_noop();
+        }
+
+        switch (prefix)
+        {
+            case 'U':
+            {
+                std::uint8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
+                return true;
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                if (!value_in_range_of<std::size_t>(number))
+                {
+                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
+                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = conditional_static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (!value_in_range_of<std::size_t>(number))
+                {
+                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
+                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
+                }
+                result = detail::conditional_static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case '[':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                if (is_ndarray) // ndarray dimensional vector can only contain integers, and can not embed another array
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message(input_format, "ndarray dimensional vector is not allowed", "size"), nullptr));
+                }
+                std::vector<size_t> dim;
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim)))
+                {
+                    return false;
+                }
+                if (dim.size() == 1 || (dim.size() == 2 && dim.at(0) == 1)) // return normal array size if 1D row vector
+                {
+                    result = dim.at(dim.size() - 1);
+                    return true;
+                }
+                if (!dim.empty())  // if ndarray, convert to an object in JData annotated array format
+                {
+                    for (auto i : dim) // test if any dimension in an ndarray is 0, if so, return a 1D empty container
+                    {
+                        if ( i == 0 )
+                        {
+                            result = 0;
+                            return true;
+                        }
+                    }
+
+                    string_t key = "_ArraySize_";
+                    if (JSON_HEDLEY_UNLIKELY(!sax->start_object(3) || !sax->key(key) || !sax->start_array(dim.size())))
+                    {
+                        return false;
+                    }
+                    result = 1;
+                    for (auto i : dim)
+                    {
+                        result *= i;
+                        if (result == 0 || result == npos) // because dim elements shall not have zeros, result = 0 means overflow happened; it also can't be npos as it is used to initialize size in get_ubjson_size_type()
+                        {
+                            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(static_cast<number_unsigned_t>(i))))
+                        {
+                            return false;
+                        }
+                    }
+                    is_ndarray = true;
+                    return sax->end_array();
+                }
+                result = 0;
+                return true;
+            }
+
+            default:
+                break;
+        }
+        auto last_token = get_token_string();
+        std::string message;
+
+        if (input_format != input_format_t::bjdata)
+        {
+            message = "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token;
+        }
+        else
+        {
+            message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token;
+        }
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr));
+    }
+
+    /*!
+    @brief determine the type and size for a container
+
+    In the optimized UBJSON format, a type and a size can be provided to allow
+    for a more compact representation.
+
+    @param[out] result  pair of the size and the type
+    @param[in] inside_ndarray  whether the parser is parsing an ND array dimensional vector
+
+    @return whether pair creation completed
+    */
+    bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result, bool inside_ndarray = false)
+    {
+        result.first = npos; // size
+        result.second = 0; // type
+        bool is_ndarray = false;
+
+        get_ignore_noop();
+
+        if (current == '$')
+        {
+            result.second = get();  // must not ignore 'N', because 'N' maybe the type
+            if (input_format == input_format_t::bjdata
+                    && JSON_HEDLEY_UNLIKELY(std::binary_search(bjd_optimized_type_markers.begin(), bjd_optimized_type_markers.end(), result.second)))
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr));
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type")))
+            {
+                return false;
+            }
+
+            get_ignore_noop();
+            if (JSON_HEDLEY_UNLIKELY(current != '#'))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
+                {
+                    return false;
+                }
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr));
+            }
+
+            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
+            if (input_format == input_format_t::bjdata && is_ndarray)
+            {
+                if (inside_ndarray)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
+                                            exception_message(input_format, "ndarray can not be recursive", "size"), nullptr));
+                }
+                result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON and BJData markers should be ASCII letters
+            }
+            return is_error;
+        }
+
+        if (current == '#')
+        {
+            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
+            if (input_format == input_format_t::bjdata && is_ndarray)
+            {
+                return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
+                                        exception_message(input_format, "ndarray requires both type and size", "size"), nullptr));
+            }
+            return is_error;
+        }
+
+        return true;
+    }
+
+    /*!
+    @param prefix  the previously read or set type prefix
+    @return whether value creation completed
+    */
+    bool get_ubjson_value(const char_int_type prefix)
+    {
+        switch (prefix)
+        {
+            case char_traits<char_type>::eof():  // EOF
+                return unexpect_eof(input_format, "value");
+
+            case 'T':  // true
+                return sax->boolean(true);
+            case 'F':  // false
+                return sax->boolean(false);
+
+            case 'Z':  // null
+                return sax->null();
+
+            case 'U':
+            {
+                std::uint8_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'h':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                const auto byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+                {
+                    return false;
+                }
+                const auto byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte2 << 8u) + byte1);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 'd':
+            {
+                float number{};
+                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'D':
+            {
+                double number{};
+                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'H':
+            {
+                return get_ubjson_high_precision_number();
+            }
+
+            case 'C':  // char
+            {
+                get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char")))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(current > 127))
+                {
+                    auto last_token = get_token_string();
+                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                            exception_message(input_format, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr));
+                }
+                string_t s(1, static_cast<typename string_t::value_type>(current));
+                return sax->string(s);
+            }
+
+            case 'S':  // string
+            {
+                string_t s;
+                return get_ubjson_string(s) && sax->string(s);
+            }
+
+            case '[':  // array
+                return get_ubjson_array();
+
+            case '{':  // object
+                return get_ubjson_object();
+
+            default: // anything else
+                break;
+        }
+        auto last_token = get_token_string();
+        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format, "invalid byte: 0x" + last_token, "value"), nullptr));
+    }
+
+    /*!
+    @return whether array creation completed
+    */
+    bool get_ubjson_array()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        // if bit-8 of size_and_type.second is set to 1, encode bjdata ndarray as an object in JData annotated array format (https://github.com/NeuroJSON/jdata):
+        // {"_ArrayType_" : "typeid", "_ArraySize_" : [n1, n2, ...], "_ArrayData_" : [v1, v2, ...]}
+
+        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
+        {
+            size_and_type.second &= ~(static_cast<char_int_type>(1) << 8);  // use bit 8 to indicate ndarray, here we remove the bit to restore the type marker
+            auto it = std::lower_bound(bjd_types_map.begin(), bjd_types_map.end(), size_and_type.second, [](const bjd_type & p, char_int_type t)
+            {
+                return p.first < t;
+            });
+            string_t key = "_ArrayType_";
+            if (JSON_HEDLEY_UNLIKELY(it == bjd_types_map.end() || it->first != size_and_type.second))
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, "invalid byte: 0x" + last_token, "type"), nullptr));
+            }
+
+            string_t type = it->second; // sax->string() takes a reference
+            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->string(type)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second == 'C')
+            {
+                size_and_type.second = 'U';
+            }
+
+            key = "_ArrayData_";
+            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->start_array(size_and_type.first) ))
+            {
+                return false;
+            }
+
+            for (std::size_t i = 0; i < size_and_type.first; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                {
+                    return false;
+                }
+            }
+
+            return (sax->end_array() && sax->end_object());
+        }
+
+        if (size_and_type.first != npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+            {
+                return false;
+            }
+
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @return whether object creation completed
+    */
+    bool get_ubjson_object()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        // do not accept ND-array size in objects in BJData
+        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format, "BJData object does not support ND-array size in optimized format", "object"), nullptr));
+        }
+
+        string_t key;
+        if (size_and_type.first != npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+            {
+                return false;
+            }
+
+            while (current != '}')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    // Note, no reader for UBJSON binary types is implemented because they do
+    // not exist
+
+    bool get_ubjson_high_precision_number()
+    {
+        // get size of following number string
+        std::size_t size{};
+        bool no_ndarray = true;
+        auto res = get_ubjson_size_value(size, no_ndarray);
+        if (JSON_HEDLEY_UNLIKELY(!res))
+        {
+            return res;
+        }
+
+        // get number string
+        std::vector<char> number_vector;
+        for (std::size_t i = 0; i < size; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+            {
+                return false;
+            }
+            number_vector.push_back(static_cast<char>(current));
+        }
+
+        // parse number string
+        using ia_type = decltype(detail::input_adapter(number_vector));
+        auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);
+        const auto result_number = number_lexer.scan();
+        const auto number_string = number_lexer.get_token_string();
+        const auto result_remainder = number_lexer.scan();
+
+        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
+
+        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
+        {
+            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
+                                    exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
+        }
+
+        switch (result_number)
+        {
+            case token_type::value_integer:
+                return sax->number_integer(number_lexer.get_number_integer());
+            case token_type::value_unsigned:
+                return sax->number_unsigned(number_lexer.get_number_unsigned());
+            case token_type::value_float:
+                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
+            case token_type::uninitialized:
+            case token_type::literal_true:
+            case token_type::literal_false:
+            case token_type::literal_null:
+            case token_type::value_string:
+            case token_type::begin_array:
+            case token_type::begin_object:
+            case token_type::end_array:
+            case token_type::end_object:
+            case token_type::name_separator:
+            case token_type::value_separator:
+            case token_type::parse_error:
+            case token_type::end_of_input:
+            case token_type::literal_or_value:
+            default:
+                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
+                                        exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
+        }
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*!
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a -'ve valued
+    `char_traits<char_type>::eof()` in that case.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++chars_read;
+        return current = ia.get_character();
+    }
+
+    /*!
+    @return character read from the input after ignoring all 'N' entries
+    */
+    char_int_type get_ignore_noop()
+    {
+        do
+        {
+            get();
+        }
+        while (current == 'N');
+
+        return current;
+    }
+
+    /*
+    @brief read a number from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format   the current format (for diagnostics)
+    @param[out] result  number of type @a NumberType
+
+    @return whether conversion completed
+
+    @note This function needs to respect the system's endianness, because
+          bytes in CBOR, MessagePack, and UBJSON are stored in network order
+          (big endian) and therefore need reordering on little endian systems.
+          On the other hand, BSON and BJData use little endian and should reorder
+          on big endian systems.
+    */
+    template<typename NumberType, bool InputIsLittleEndian = false>
+    bool get_number(const input_format_t format, NumberType& result)
+    {
+        // step 1: read input into array with system's byte order
+        std::array<std::uint8_t, sizeof(NumberType)> vec{};
+        for (std::size_t i = 0; i < sizeof(NumberType); ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
+            {
+                return false;
+            }
+
+            // reverse byte order prior to conversion if necessary
+            if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata))
+            {
+                vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
+            }
+            else
+            {
+                vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
+            }
+        }
+
+        // step 2: convert array into number of type T and return
+        std::memcpy(&result, vec.data(), sizeof(NumberType));
+        return true;
+    }
+
+    /*!
+    @brief create a string by reading characters from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of characters to read
+    @param[out] result string created by reading @a len bytes
+
+    @return whether string creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of string memory.
+    */
+    template<typename NumberType>
+    bool get_string(const input_format_t format,
+                    const NumberType len,
+                    string_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<typename string_t::value_type>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @brief create a byte array by reading bytes from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of bytes to read
+    @param[out] result byte array created by reading @a len bytes
+
+    @return whether byte array creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of memory.
+    */
+    template<typename NumberType>
+    bool get_binary(const input_format_t format,
+                    const NumberType len,
+                    binary_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<std::uint8_t>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @param[in] format   the current format (for diagnostics)
+    @param[in] context  further context information (for diagnostics)
+    @return whether the last read character is not EOF
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool unexpect_eof(const input_format_t format, const char* context) const
+    {
+        if (JSON_HEDLEY_UNLIKELY(current == char_traits<char_type>::eof()))
+        {
+            return sax->parse_error(chars_read, "<end of file>",
+                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr));
+        }
+        return true;
+    }
+
+    /*!
+    @return a string representation of the last read byte
+    */
+    std::string get_token_string() const
+    {
+        std::array<char, 3> cr{{}};
+        static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        return std::string{cr.data()};
+    }
+
+    /*!
+    @param[in] format   the current format
+    @param[in] detail   a detailed error message
+    @param[in] context  further context information
+    @return a message string to use in the parse_error exceptions
+    */
+    std::string exception_message(const input_format_t format,
+                                  const std::string& detail,
+                                  const std::string& context) const
+    {
+        std::string error_msg = "syntax error while parsing ";
+
+        switch (format)
+        {
+            case input_format_t::cbor:
+                error_msg += "CBOR";
+                break;
+
+            case input_format_t::msgpack:
+                error_msg += "MessagePack";
+                break;
+
+            case input_format_t::ubjson:
+                error_msg += "UBJSON";
+                break;
+
+            case input_format_t::bson:
+                error_msg += "BSON";
+                break;
+
+            case input_format_t::bjdata:
+                error_msg += "BJData";
+                break;
+
+            case input_format_t::json: // LCOV_EXCL_LINE
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+        return concat(error_msg, ' ', context, ": ", detail);
+    }
+
+  private:
+    static JSON_INLINE_VARIABLE constexpr std::size_t npos = static_cast<std::size_t>(-1);
+
+    /// input adapter
+    InputAdapterType ia;
+
+    /// the current character
+    char_int_type current = char_traits<char_type>::eof();
+
+    /// the number of characters read
+    std::size_t chars_read = 0;
+
+    /// whether we can assume little endianness
+    const bool is_little_endian = little_endianness();
+
+    /// input format
+    const input_format_t input_format = input_format_t::json;
+
+    /// the SAX parser
+    json_sax_t* sax = nullptr;
+
+    // excluded markers in bjdata optimized type
+#define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ \
+    make_array<char_int_type>('F', 'H', 'N', 'S', 'T', 'Z', '[', '{')
+
+#define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ \
+    make_array<bjd_type>(                      \
+    bjd_type{'C', "char"},                     \
+    bjd_type{'D', "double"},                   \
+    bjd_type{'I', "int16"},                    \
+    bjd_type{'L', "int64"},                    \
+    bjd_type{'M', "uint64"},                   \
+    bjd_type{'U', "uint8"},                    \
+    bjd_type{'d', "single"},                   \
+    bjd_type{'i', "int8"},                     \
+    bjd_type{'l', "int32"},                    \
+    bjd_type{'m', "uint32"},                   \
+    bjd_type{'u', "uint16"})
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // lookup tables
+    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
+    const decltype(JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_) bjd_optimized_type_markers =
+        JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_;
+
+    using bjd_type = std::pair<char_int_type, string_t>;
+    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
+    const decltype(JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_) bjd_types_map =
+        JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_;
+
+#undef JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_
+#undef JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_
+};
+
+#ifndef JSON_HAS_CPP_17
+    template<typename BasicJsonType, typename InputAdapterType, typename SAX>
+    constexpr std::size_t binary_reader<BasicJsonType, InputAdapterType, SAX>::npos;
+#endif
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/input_adapters.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/input_adapters.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..33fca3e4b932c8182762b10bb38baa68da63cb9d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/input_adapters.hpp
@@ -0,0 +1,492 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstring> // strlen
+#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
+#include <memory> // shared_ptr, make_shared, addressof
+#include <numeric> // accumulate
+#include <string> // string, char_traits
+#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
+#include <utility> // pair, declval
+
+#ifndef JSON_NO_IO
+    #include <cstdio>   // FILE *
+    #include <istream>  // istream
+#endif                  // JSON_NO_IO
+
+#include <nlohmann/detail/iterators/iterator_traits.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/meta/type_traits.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// the supported input formats
+enum class input_format_t { json, cbor, msgpack, ubjson, bson, bjdata };
+
+////////////////////
+// input adapters //
+////////////////////
+
+#ifndef JSON_NO_IO
+/*!
+Input adapter for stdio file access. This adapter read only 1 byte and do not use any
+ buffer. This adapter is a very low level adapter.
+*/
+class file_input_adapter
+{
+  public:
+    using char_type = char;
+
+    JSON_HEDLEY_NON_NULL(2)
+    explicit file_input_adapter(std::FILE* f) noexcept
+        : m_file(f)
+    {
+        JSON_ASSERT(m_file != nullptr);
+    }
+
+    // make class move-only
+    file_input_adapter(const file_input_adapter&) = delete;
+    file_input_adapter(file_input_adapter&&) noexcept = default;
+    file_input_adapter& operator=(const file_input_adapter&) = delete;
+    file_input_adapter& operator=(file_input_adapter&&) = delete;
+    ~file_input_adapter() = default;
+
+    std::char_traits<char>::int_type get_character() noexcept
+    {
+        return std::fgetc(m_file);
+    }
+
+  private:
+    /// the file pointer to read from
+    std::FILE* m_file;
+};
+
+/*!
+Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
+beginning of input. Does not support changing the underlying std::streambuf
+in mid-input. Maintains underlying std::istream and std::streambuf to support
+subsequent use of standard std::istream operations to process any input
+characters following those used in parsing the JSON input.  Clears the
+std::istream flags; any input errors (e.g., EOF) will be detected by the first
+subsequent call for input from the std::istream.
+*/
+class input_stream_adapter
+{
+  public:
+    using char_type = char;
+
+    ~input_stream_adapter()
+    {
+        // clear stream flags; we use underlying streambuf I/O, do not
+        // maintain ifstream flags, except eof
+        if (is != nullptr)
+        {
+            is->clear(is->rdstate() & std::ios::eofbit);
+        }
+    }
+
+    explicit input_stream_adapter(std::istream& i)
+        : is(&i), sb(i.rdbuf())
+    {}
+
+    // delete because of pointer members
+    input_stream_adapter(const input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&&) = delete;
+
+    input_stream_adapter(input_stream_adapter&& rhs) noexcept
+        : is(rhs.is), sb(rhs.sb)
+    {
+        rhs.is = nullptr;
+        rhs.sb = nullptr;
+    }
+
+    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
+    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
+    // end up as the same value, e.g. 0xFFFFFFFF.
+    std::char_traits<char>::int_type get_character()
+    {
+        auto res = sb->sbumpc();
+        // set eof manually, as we don't use the istream interface.
+        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
+        {
+            is->clear(is->rdstate() | std::ios::eofbit);
+        }
+        return res;
+    }
+
+  private:
+    /// the associated input stream
+    std::istream* is = nullptr;
+    std::streambuf* sb = nullptr;
+};
+#endif  // JSON_NO_IO
+
+// General-purpose iterator-based adapter. It might not be as fast as
+// theoretically possible for some containers, but it is extremely versatile.
+template<typename IteratorType>
+class iterator_input_adapter
+{
+  public:
+    using char_type = typename std::iterator_traits<IteratorType>::value_type;
+
+    iterator_input_adapter(IteratorType first, IteratorType last)
+        : current(std::move(first)), end(std::move(last))
+    {}
+
+    typename char_traits<char_type>::int_type get_character()
+    {
+        if (JSON_HEDLEY_LIKELY(current != end))
+        {
+            auto result = char_traits<char_type>::to_int_type(*current);
+            std::advance(current, 1);
+            return result;
+        }
+
+        return char_traits<char_type>::eof();
+    }
+
+  private:
+    IteratorType current;
+    IteratorType end;
+
+    template<typename BaseInputAdapter, size_t T>
+    friend struct wide_string_input_helper;
+
+    bool empty() const
+    {
+        return current == end;
+    }
+};
+
+template<typename BaseInputAdapter, size_t T>
+struct wide_string_input_helper;
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 4>
+{
+    // UTF-32
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-32 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (wc <= 0xFFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else if (wc <= 0x10FFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 4;
+            }
+            else
+            {
+                // unknown character
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+        }
+    }
+};
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 2>
+{
+    // UTF-16
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-16 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (0xD800 > wc || wc >= 0xE000)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else
+            {
+                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
+                {
+                    const auto wc2 = static_cast<unsigned int>(input.get_character());
+                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
+                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
+                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
+                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
+                    utf8_bytes_filled = 4;
+                }
+                else
+                {
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                    utf8_bytes_filled = 1;
+                }
+            }
+        }
+    }
+};
+
+// Wraps another input adapter to convert wide character types into individual bytes.
+template<typename BaseInputAdapter, typename WideCharType>
+class wide_string_input_adapter
+{
+  public:
+    using char_type = char;
+
+    wide_string_input_adapter(BaseInputAdapter base)
+        : base_adapter(base) {}
+
+    typename std::char_traits<char>::int_type get_character() noexcept
+    {
+        // check if buffer needs to be filled
+        if (utf8_bytes_index == utf8_bytes_filled)
+        {
+            fill_buffer<sizeof(WideCharType)>();
+
+            JSON_ASSERT(utf8_bytes_filled > 0);
+            JSON_ASSERT(utf8_bytes_index == 0);
+        }
+
+        // use buffer
+        JSON_ASSERT(utf8_bytes_filled > 0);
+        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
+        return utf8_bytes[utf8_bytes_index++];
+    }
+
+  private:
+    BaseInputAdapter base_adapter;
+
+    template<size_t T>
+    void fill_buffer()
+    {
+        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
+    }
+
+    /// a buffer for UTF-8 bytes
+    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
+
+    /// index to the utf8_codes array for the next valid byte
+    std::size_t utf8_bytes_index = 0;
+    /// number of valid bytes in the utf8_codes array
+    std::size_t utf8_bytes_filled = 0;
+};
+
+template<typename IteratorType, typename Enable = void>
+struct iterator_input_adapter_factory
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using adapter_type = iterator_input_adapter<iterator_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(std::move(first), std::move(last));
+    }
+};
+
+template<typename T>
+struct is_iterator_of_multibyte
+{
+    using value_type = typename std::iterator_traits<T>::value_type;
+    enum
+    {
+        value = sizeof(value_type) > 1
+    };
+};
+
+template<typename IteratorType>
+struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using base_adapter_type = iterator_input_adapter<iterator_type>;
+    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(base_adapter_type(std::move(first), std::move(last)));
+    }
+};
+
+// General purpose iterator-based input
+template<typename IteratorType>
+typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
+{
+    using factory_type = iterator_input_adapter_factory<IteratorType>;
+    return factory_type::create(first, last);
+}
+
+// Convenience shorthand from container to iterator
+// Enables ADL on begin(container) and end(container)
+// Encloses the using declarations in namespace for not to leak them to outside scope
+
+namespace container_input_adapter_factory_impl
+{
+
+using std::begin;
+using std::end;
+
+template<typename ContainerType, typename Enable = void>
+struct container_input_adapter_factory {};
+
+template<typename ContainerType>
+struct container_input_adapter_factory< ContainerType,
+       void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
+       {
+           using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
+
+           static adapter_type create(const ContainerType& container)
+{
+    return input_adapter(begin(container), end(container));
+}
+       };
+
+}  // namespace container_input_adapter_factory_impl
+
+template<typename ContainerType>
+typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
+{
+    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
+}
+
+#ifndef JSON_NO_IO
+// Special cases with fast paths
+inline file_input_adapter input_adapter(std::FILE* file)
+{
+    return file_input_adapter(file);
+}
+
+inline input_stream_adapter input_adapter(std::istream& stream)
+{
+    return input_stream_adapter(stream);
+}
+
+inline input_stream_adapter input_adapter(std::istream&& stream)
+{
+    return input_stream_adapter(stream);
+}
+#endif  // JSON_NO_IO
+
+using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
+
+// Null-delimited strings, and the like.
+template < typename CharT,
+           typename std::enable_if <
+               std::is_pointer<CharT>::value&&
+               !std::is_array<CharT>::value&&
+               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+               sizeof(typename std::remove_pointer<CharT>::type) == 1,
+               int >::type = 0 >
+contiguous_bytes_input_adapter input_adapter(CharT b)
+{
+    auto length = std::strlen(reinterpret_cast<const char*>(b));
+    const auto* ptr = reinterpret_cast<const char*>(b);
+    return input_adapter(ptr, ptr + length);
+}
+
+template<typename T, std::size_t N>
+auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+{
+    return input_adapter(array, array + N);
+}
+
+// This class only handles inputs of input_buffer_adapter type.
+// It's required so that expressions like {ptr, len} can be implicitly cast
+// to the correct adapter.
+class span_input_adapter
+{
+  public:
+    template < typename CharT,
+               typename std::enable_if <
+                   std::is_pointer<CharT>::value&&
+                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+                   sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                   int >::type = 0 >
+    span_input_adapter(CharT b, std::size_t l)
+        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
+
+    template<class IteratorType,
+             typename std::enable_if<
+                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
+                 int>::type = 0>
+    span_input_adapter(IteratorType first, IteratorType last)
+        : ia(input_adapter(first, last)) {}
+
+    contiguous_bytes_input_adapter&& get()
+    {
+        return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
+    }
+
+  private:
+    contiguous_bytes_input_adapter ia;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/json_sax.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/json_sax.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c772521cd843779fceff8f96928f15e88975e95a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/json_sax.hpp
@@ -0,0 +1,727 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstddef>
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+#include <nlohmann/detail/exceptions.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/string_concat.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/*!
+@brief SAX interface
+
+This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
+Each function is called in different situations while the input is parsed. The
+boolean return value informs the parser whether to continue processing the
+input.
+*/
+template<typename BasicJsonType>
+struct json_sax
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @brief a null value was read
+    @return whether parsing should proceed
+    */
+    virtual bool null() = 0;
+
+    /*!
+    @brief a boolean value was read
+    @param[in] val  boolean value
+    @return whether parsing should proceed
+    */
+    virtual bool boolean(bool val) = 0;
+
+    /*!
+    @brief an integer number was read
+    @param[in] val  integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_integer(number_integer_t val) = 0;
+
+    /*!
+    @brief an unsigned integer number was read
+    @param[in] val  unsigned integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_unsigned(number_unsigned_t val) = 0;
+
+    /*!
+    @brief a floating-point number was read
+    @param[in] val  floating-point value
+    @param[in] s    raw token value
+    @return whether parsing should proceed
+    */
+    virtual bool number_float(number_float_t val, const string_t& s) = 0;
+
+    /*!
+    @brief a string value was read
+    @param[in] val  string value
+    @return whether parsing should proceed
+    @note It is safe to move the passed string value.
+    */
+    virtual bool string(string_t& val) = 0;
+
+    /*!
+    @brief a binary value was read
+    @param[in] val  binary value
+    @return whether parsing should proceed
+    @note It is safe to move the passed binary value.
+    */
+    virtual bool binary(binary_t& val) = 0;
+
+    /*!
+    @brief the beginning of an object was read
+    @param[in] elements  number of object elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_object(std::size_t elements) = 0;
+
+    /*!
+    @brief an object key was read
+    @param[in] val  object key
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool key(string_t& val) = 0;
+
+    /*!
+    @brief the end of an object was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_object() = 0;
+
+    /*!
+    @brief the beginning of an array was read
+    @param[in] elements  number of array elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_array(std::size_t elements) = 0;
+
+    /*!
+    @brief the end of an array was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_array() = 0;
+
+    /*!
+    @brief a parse error occurred
+    @param[in] position    the position in the input where the error occurs
+    @param[in] last_token  the last read token
+    @param[in] ex          an exception object describing the error
+    @return whether parsing should proceed (must return false)
+    */
+    virtual bool parse_error(std::size_t position,
+                             const std::string& last_token,
+                             const detail::exception& ex) = 0;
+
+    json_sax() = default;
+    json_sax(const json_sax&) = default;
+    json_sax(json_sax&&) noexcept = default;
+    json_sax& operator=(const json_sax&) = default;
+    json_sax& operator=(json_sax&&) noexcept = default;
+    virtual ~json_sax() = default;
+};
+
+namespace detail
+{
+/*!
+@brief SAX implementation to create a JSON value from SAX events
+
+This class implements the @ref json_sax interface and processes the SAX events
+to create a JSON value which makes it basically a DOM parser. The structure or
+hierarchy of the JSON value is managed by the stack `ref_stack` which contains
+a pointer to the respective array or object for each recursion depth.
+
+After successful parsing, the value that is passed by reference to the
+constructor contains the parsed value.
+
+@tparam BasicJsonType  the JSON type
+*/
+template<typename BasicJsonType>
+class json_sax_dom_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @param[in,out] r  reference to a JSON value that is manipulated while
+                       parsing
+    @param[in] allow_exceptions_  whether parse errors yield exceptions
+    */
+    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
+        : root(r), allow_exceptions(allow_exceptions_)
+    {}
+
+    // make class move-only
+    json_sax_dom_parser(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~json_sax_dom_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
+
+        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_object());
+
+        // add null at given key and store the reference for later
+        object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val));
+        return true;
+    }
+
+    bool end_object()
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_object());
+
+        ref_stack.back()->set_parents();
+        ref_stack.pop_back();
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
+
+        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_array());
+
+        ref_stack.back()->set_parents();
+        ref_stack.pop_back();
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+    */
+    template<typename Value>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    BasicJsonType* handle_value(Value&& v)
+    {
+        if (ref_stack.empty())
+        {
+            root = BasicJsonType(std::forward<Value>(v));
+            return &root;
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->emplace_back(std::forward<Value>(v));
+            return &(ref_stack.back()->m_data.m_value.array->back());
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_object());
+        JSON_ASSERT(object_element);
+        *object_element = BasicJsonType(std::forward<Value>(v));
+        return object_element;
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+
+template<typename BasicJsonType>
+class json_sax_dom_callback_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using parser_callback_t = typename BasicJsonType::parser_callback_t;
+    using parse_event_t = typename BasicJsonType::parse_event_t;
+
+    json_sax_dom_callback_parser(BasicJsonType& r,
+                                 const parser_callback_t cb,
+                                 const bool allow_exceptions_ = true)
+        : root(r), callback(cb), allow_exceptions(allow_exceptions_)
+    {
+        keep_stack.push_back(true);
+    }
+
+    // make class move-only
+    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~json_sax_dom_callback_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        // check callback for object start
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::object, true);
+        ref_stack.push_back(val.second);
+
+        // check object limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        BasicJsonType k = BasicJsonType(val);
+
+        // check callback for key
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
+        key_keep_stack.push_back(keep);
+
+        // add discarded value at given key and store the reference for later
+        if (keep && ref_stack.back())
+        {
+            object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
+        }
+
+        return true;
+    }
+
+    bool end_object()
+    {
+        if (ref_stack.back())
+        {
+            if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
+            {
+                // discard object
+                *ref_stack.back() = discarded;
+            }
+            else
+            {
+                ref_stack.back()->set_parents();
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
+        {
+            // remove discarded value
+            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
+            {
+                if (it->is_discarded())
+                {
+                    ref_stack.back()->erase(it);
+                    break;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::array, true);
+        ref_stack.push_back(val.second);
+
+        // check array limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        bool keep = true;
+
+        if (ref_stack.back())
+        {
+            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
+            if (keep)
+            {
+                ref_stack.back()->set_parents();
+            }
+            else
+            {
+                // discard array
+                *ref_stack.back() = discarded;
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        // remove discarded value
+        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->pop_back();
+        }
+
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @param[in] v  value to add to the JSON value we build during parsing
+    @param[in] skip_callback  whether we should skip calling the callback
+               function; this is required after start_array() and
+               start_object() SAX events, because otherwise we would call the
+               callback function with an empty array or object, respectively.
+
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+
+    @return pair of boolean (whether value should be kept) and pointer (to the
+            passed value in the ref_stack hierarchy; nullptr if not kept)
+    */
+    template<typename Value>
+    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
+    {
+        JSON_ASSERT(!keep_stack.empty());
+
+        // do not handle this value if we know it would be added to a discarded
+        // container
+        if (!keep_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // create value
+        auto value = BasicJsonType(std::forward<Value>(v));
+
+        // check callback
+        const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
+
+        // do not handle this value if we just learnt it shall be discarded
+        if (!keep)
+        {
+            return {false, nullptr};
+        }
+
+        if (ref_stack.empty())
+        {
+            root = std::move(value);
+            return {true, & root};
+        }
+
+        // skip this value if we already decided to skip the parent
+        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
+        if (!ref_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // we now only expect arrays and objects
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        // array
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
+            return {true, & (ref_stack.back()->m_data.m_value.array->back())};
+        }
+
+        // object
+        JSON_ASSERT(ref_stack.back()->is_object());
+        // check if we should store an element for the current key
+        JSON_ASSERT(!key_keep_stack.empty());
+        const bool store_element = key_keep_stack.back();
+        key_keep_stack.pop_back();
+
+        if (!store_element)
+        {
+            return {false, nullptr};
+        }
+
+        JSON_ASSERT(object_element);
+        *object_element = std::move(value);
+        return {true, object_element};
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// stack to manage which values to keep
+    std::vector<bool> keep_stack {};
+    /// stack to manage which object keys to keep
+    std::vector<bool> key_keep_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+    /// a discarded value for the callback
+    BasicJsonType discarded = BasicJsonType::value_t::discarded;
+};
+
+template<typename BasicJsonType>
+class json_sax_acceptor
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    bool null()
+    {
+        return true;
+    }
+
+    bool boolean(bool /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_integer(number_integer_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool string(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool binary(binary_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
+    {
+        return true;
+    }
+
+    bool key(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool end_object()
+    {
+        return true;
+    }
+
+    bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
+    {
+        return true;
+    }
+
+    bool end_array()
+    {
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
+    {
+        return false;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/lexer.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/lexer.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..4b3bf77d624751b22c16ef93b1d7806414ec20c7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/lexer.hpp
@@ -0,0 +1,1633 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <array> // array
+#include <clocale> // localeconv
+#include <cstddef> // size_t
+#include <cstdio> // snprintf
+#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
+#include <initializer_list> // initializer_list
+#include <string> // char_traits, string
+#include <utility> // move
+#include <vector> // vector
+
+#include <nlohmann/detail/input/input_adapters.hpp>
+#include <nlohmann/detail/input/position_t.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/meta/type_traits.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////
+// lexer //
+///////////
+
+template<typename BasicJsonType>
+class lexer_base
+{
+  public:
+    /// token types for the parser
+    enum class token_type
+    {
+        uninitialized,    ///< indicating the scanner is uninitialized
+        literal_true,     ///< the `true` literal
+        literal_false,    ///< the `false` literal
+        literal_null,     ///< the `null` literal
+        value_string,     ///< a string -- use get_string() for actual value
+        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
+        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
+        value_float,      ///< an floating point number -- use get_number_float() for actual value
+        begin_array,      ///< the character for array begin `[`
+        begin_object,     ///< the character for object begin `{`
+        end_array,        ///< the character for array end `]`
+        end_object,       ///< the character for object end `}`
+        name_separator,   ///< the name separator `:`
+        value_separator,  ///< the value separator `,`
+        parse_error,      ///< indicating a parse error
+        end_of_input,     ///< indicating the end of the input buffer
+        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
+    };
+
+    /// return name of values of type token_type (only used for errors)
+    JSON_HEDLEY_RETURNS_NON_NULL
+    JSON_HEDLEY_CONST
+    static const char* token_type_name(const token_type t) noexcept
+    {
+        switch (t)
+        {
+            case token_type::uninitialized:
+                return "<uninitialized>";
+            case token_type::literal_true:
+                return "true literal";
+            case token_type::literal_false:
+                return "false literal";
+            case token_type::literal_null:
+                return "null literal";
+            case token_type::value_string:
+                return "string literal";
+            case token_type::value_unsigned:
+            case token_type::value_integer:
+            case token_type::value_float:
+                return "number literal";
+            case token_type::begin_array:
+                return "'['";
+            case token_type::begin_object:
+                return "'{'";
+            case token_type::end_array:
+                return "']'";
+            case token_type::end_object:
+                return "'}'";
+            case token_type::name_separator:
+                return "':'";
+            case token_type::value_separator:
+                return "','";
+            case token_type::parse_error:
+                return "<parse error>";
+            case token_type::end_of_input:
+                return "end of input";
+            case token_type::literal_or_value:
+                return "'[', '{', or a literal";
+            // LCOV_EXCL_START
+            default: // catch non-enum values
+                return "unknown token";
+                // LCOV_EXCL_STOP
+        }
+    }
+};
+/*!
+@brief lexical analysis
+
+This class organizes the lexical analysis during JSON deserialization.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class lexer : public lexer_base<BasicJsonType>
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename char_traits<char_type>::int_type;
+
+  public:
+    using token_type = typename lexer_base<BasicJsonType>::token_type;
+
+    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
+        : ia(std::move(adapter))
+        , ignore_comments(ignore_comments_)
+        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
+    {}
+
+    // delete because of pointer members
+    lexer(const lexer&) = delete;
+    lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    lexer& operator=(lexer&) = delete;
+    lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~lexer() = default;
+
+  private:
+    /////////////////////
+    // locales
+    /////////////////////
+
+    /// return the locale-dependent decimal point
+    JSON_HEDLEY_PURE
+    static char get_decimal_point() noexcept
+    {
+        const auto* loc = localeconv();
+        JSON_ASSERT(loc != nullptr);
+        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
+    }
+
+    /////////////////////
+    // scan functions
+    /////////////////////
+
+    /*!
+    @brief get codepoint from 4 hex characters following `\u`
+
+    For input "\u c1 c2 c3 c4" the codepoint is:
+      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
+    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
+
+    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
+    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
+    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
+    between the ASCII value of the character and the desired integer value.
+
+    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
+            non-hex character)
+    */
+    int get_codepoint()
+    {
+        // this function only makes sense after reading `\u`
+        JSON_ASSERT(current == 'u');
+        int codepoint = 0;
+
+        const auto factors = { 12u, 8u, 4u, 0u };
+        for (const auto factor : factors)
+        {
+            get();
+
+            if (current >= '0' && current <= '9')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
+            }
+            else if (current >= 'A' && current <= 'F')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
+            }
+            else if (current >= 'a' && current <= 'f')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
+        return codepoint;
+    }
+
+    /*!
+    @brief check if the next byte(s) are inside a given range
+
+    Adds the current byte and, for each passed range, reads a new byte and
+    checks if it is inside the range. If a violation was detected, set up an
+    error message and return false. Otherwise, return true.
+
+    @param[in] ranges  list of integers; interpreted as list of pairs of
+                       inclusive lower and upper bound, respectively
+
+    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
+         1, 2, or 3 pairs. This precondition is enforced by an assertion.
+
+    @return true if and only if no range violation was detected
+    */
+    bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
+    {
+        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
+        add(current);
+
+        for (auto range = ranges.begin(); range != ranges.end(); ++range)
+        {
+            get();
+            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
+            {
+                add(current);
+            }
+            else
+            {
+                error_message = "invalid string: ill-formed UTF-8 byte";
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief scan a string literal
+
+    This function scans a string according to Sect. 7 of RFC 8259. While
+    scanning, bytes are escaped and copied into buffer token_buffer. Then the
+    function returns successfully, token_buffer is *not* null-terminated (as it
+    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
+    string.
+
+    @return token_type::value_string if string could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note In case of errors, variable error_message contains a textual
+          description.
+    */
+    token_type scan_string()
+    {
+        // reset token_buffer (ignore opening quote)
+        reset();
+
+        // we entered the function by reading an open quote
+        JSON_ASSERT(current == '\"');
+
+        while (true)
+        {
+            // get next character
+            switch (get())
+            {
+                // end of file while parsing string
+                case char_traits<char_type>::eof():
+                {
+                    error_message = "invalid string: missing closing quote";
+                    return token_type::parse_error;
+                }
+
+                // closing quote
+                case '\"':
+                {
+                    return token_type::value_string;
+                }
+
+                // escapes
+                case '\\':
+                {
+                    switch (get())
+                    {
+                        // quotation mark
+                        case '\"':
+                            add('\"');
+                            break;
+                        // reverse solidus
+                        case '\\':
+                            add('\\');
+                            break;
+                        // solidus
+                        case '/':
+                            add('/');
+                            break;
+                        // backspace
+                        case 'b':
+                            add('\b');
+                            break;
+                        // form feed
+                        case 'f':
+                            add('\f');
+                            break;
+                        // line feed
+                        case 'n':
+                            add('\n');
+                            break;
+                        // carriage return
+                        case 'r':
+                            add('\r');
+                            break;
+                        // tab
+                        case 't':
+                            add('\t');
+                            break;
+
+                        // unicode escapes
+                        case 'u':
+                        {
+                            const int codepoint1 = get_codepoint();
+                            int codepoint = codepoint1; // start with codepoint1
+
+                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
+                            {
+                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                return token_type::parse_error;
+                            }
+
+                            // check if code point is a high surrogate
+                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
+                            {
+                                // expect next \uxxxx entry
+                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
+                                {
+                                    const int codepoint2 = get_codepoint();
+
+                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
+                                    {
+                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                        return token_type::parse_error;
+                                    }
+
+                                    // check if codepoint2 is a low surrogate
+                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
+                                    {
+                                        // overwrite codepoint
+                                        codepoint = static_cast<int>(
+                                                        // high surrogate occupies the most significant 22 bits
+                                                        (static_cast<unsigned int>(codepoint1) << 10u)
+                                                        // low surrogate occupies the least significant 15 bits
+                                                        + static_cast<unsigned int>(codepoint2)
+                                                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
+                                                        // in the result, so we have to subtract with:
+                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                                                        - 0x35FDC00u);
+                                    }
+                                    else
+                                    {
+                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                        return token_type::parse_error;
+                                    }
+                                }
+                                else
+                                {
+                                    error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+                            else
+                            {
+                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
+                                {
+                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+
+                            // result of the above calculation yields a proper codepoint
+                            JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
+
+                            // translate codepoint into bytes
+                            if (codepoint < 0x80)
+                            {
+                                // 1-byte characters: 0xxxxxxx (ASCII)
+                                add(static_cast<char_int_type>(codepoint));
+                            }
+                            else if (codepoint <= 0x7FF)
+                            {
+                                // 2-byte characters: 110xxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else if (codepoint <= 0xFFFF)
+                            {
+                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else
+                            {
+                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+
+                            break;
+                        }
+
+                        // other characters after escape
+                        default:
+                            error_message = "invalid string: forbidden character after backslash";
+                            return token_type::parse_error;
+                    }
+
+                    break;
+                }
+
+                // invalid control characters
+                case 0x00:
+                {
+                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
+                    return token_type::parse_error;
+                }
+
+                case 0x01:
+                {
+                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
+                    return token_type::parse_error;
+                }
+
+                case 0x02:
+                {
+                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
+                    return token_type::parse_error;
+                }
+
+                case 0x03:
+                {
+                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
+                    return token_type::parse_error;
+                }
+
+                case 0x04:
+                {
+                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
+                    return token_type::parse_error;
+                }
+
+                case 0x05:
+                {
+                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
+                    return token_type::parse_error;
+                }
+
+                case 0x06:
+                {
+                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
+                    return token_type::parse_error;
+                }
+
+                case 0x07:
+                {
+                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
+                    return token_type::parse_error;
+                }
+
+                case 0x08:
+                {
+                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
+                    return token_type::parse_error;
+                }
+
+                case 0x09:
+                {
+                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
+                    return token_type::parse_error;
+                }
+
+                case 0x0A:
+                {
+                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
+                    return token_type::parse_error;
+                }
+
+                case 0x0B:
+                {
+                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
+                    return token_type::parse_error;
+                }
+
+                case 0x0C:
+                {
+                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
+                    return token_type::parse_error;
+                }
+
+                case 0x0D:
+                {
+                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
+                    return token_type::parse_error;
+                }
+
+                case 0x0E:
+                {
+                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
+                    return token_type::parse_error;
+                }
+
+                case 0x0F:
+                {
+                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
+                    return token_type::parse_error;
+                }
+
+                case 0x10:
+                {
+                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
+                    return token_type::parse_error;
+                }
+
+                case 0x11:
+                {
+                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
+                    return token_type::parse_error;
+                }
+
+                case 0x12:
+                {
+                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
+                    return token_type::parse_error;
+                }
+
+                case 0x13:
+                {
+                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
+                    return token_type::parse_error;
+                }
+
+                case 0x14:
+                {
+                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
+                    return token_type::parse_error;
+                }
+
+                case 0x15:
+                {
+                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
+                    return token_type::parse_error;
+                }
+
+                case 0x16:
+                {
+                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
+                    return token_type::parse_error;
+                }
+
+                case 0x17:
+                {
+                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
+                    return token_type::parse_error;
+                }
+
+                case 0x18:
+                {
+                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
+                    return token_type::parse_error;
+                }
+
+                case 0x19:
+                {
+                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
+                    return token_type::parse_error;
+                }
+
+                case 0x1A:
+                {
+                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
+                    return token_type::parse_error;
+                }
+
+                case 0x1B:
+                {
+                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
+                    return token_type::parse_error;
+                }
+
+                case 0x1C:
+                {
+                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
+                    return token_type::parse_error;
+                }
+
+                case 0x1D:
+                {
+                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
+                    return token_type::parse_error;
+                }
+
+                case 0x1E:
+                {
+                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
+                    return token_type::parse_error;
+                }
+
+                case 0x1F:
+                {
+                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
+                    return token_type::parse_error;
+                }
+
+                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
+                case 0x20:
+                case 0x21:
+                case 0x23:
+                case 0x24:
+                case 0x25:
+                case 0x26:
+                case 0x27:
+                case 0x28:
+                case 0x29:
+                case 0x2A:
+                case 0x2B:
+                case 0x2C:
+                case 0x2D:
+                case 0x2E:
+                case 0x2F:
+                case 0x30:
+                case 0x31:
+                case 0x32:
+                case 0x33:
+                case 0x34:
+                case 0x35:
+                case 0x36:
+                case 0x37:
+                case 0x38:
+                case 0x39:
+                case 0x3A:
+                case 0x3B:
+                case 0x3C:
+                case 0x3D:
+                case 0x3E:
+                case 0x3F:
+                case 0x40:
+                case 0x41:
+                case 0x42:
+                case 0x43:
+                case 0x44:
+                case 0x45:
+                case 0x46:
+                case 0x47:
+                case 0x48:
+                case 0x49:
+                case 0x4A:
+                case 0x4B:
+                case 0x4C:
+                case 0x4D:
+                case 0x4E:
+                case 0x4F:
+                case 0x50:
+                case 0x51:
+                case 0x52:
+                case 0x53:
+                case 0x54:
+                case 0x55:
+                case 0x56:
+                case 0x57:
+                case 0x58:
+                case 0x59:
+                case 0x5A:
+                case 0x5B:
+                case 0x5D:
+                case 0x5E:
+                case 0x5F:
+                case 0x60:
+                case 0x61:
+                case 0x62:
+                case 0x63:
+                case 0x64:
+                case 0x65:
+                case 0x66:
+                case 0x67:
+                case 0x68:
+                case 0x69:
+                case 0x6A:
+                case 0x6B:
+                case 0x6C:
+                case 0x6D:
+                case 0x6E:
+                case 0x6F:
+                case 0x70:
+                case 0x71:
+                case 0x72:
+                case 0x73:
+                case 0x74:
+                case 0x75:
+                case 0x76:
+                case 0x77:
+                case 0x78:
+                case 0x79:
+                case 0x7A:
+                case 0x7B:
+                case 0x7C:
+                case 0x7D:
+                case 0x7E:
+                case 0x7F:
+                {
+                    add(current);
+                    break;
+                }
+
+                // U+0080..U+07FF: bytes C2..DF 80..BF
+                case 0xC2:
+                case 0xC3:
+                case 0xC4:
+                case 0xC5:
+                case 0xC6:
+                case 0xC7:
+                case 0xC8:
+                case 0xC9:
+                case 0xCA:
+                case 0xCB:
+                case 0xCC:
+                case 0xCD:
+                case 0xCE:
+                case 0xCF:
+                case 0xD0:
+                case 0xD1:
+                case 0xD2:
+                case 0xD3:
+                case 0xD4:
+                case 0xD5:
+                case 0xD6:
+                case 0xD7:
+                case 0xD8:
+                case 0xD9:
+                case 0xDA:
+                case 0xDB:
+                case 0xDC:
+                case 0xDD:
+                case 0xDE:
+                case 0xDF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
+                case 0xE0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
+                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
+                case 0xE1:
+                case 0xE2:
+                case 0xE3:
+                case 0xE4:
+                case 0xE5:
+                case 0xE6:
+                case 0xE7:
+                case 0xE8:
+                case 0xE9:
+                case 0xEA:
+                case 0xEB:
+                case 0xEC:
+                case 0xEE:
+                case 0xEF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
+                case 0xED:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
+                case 0xF0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
+                case 0xF1:
+                case 0xF2:
+                case 0xF3:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
+                case 0xF4:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // remaining bytes (80..C1 and F5..FF) are ill-formed
+                default:
+                {
+                    error_message = "invalid string: ill-formed UTF-8 byte";
+                    return token_type::parse_error;
+                }
+            }
+        }
+    }
+
+    /*!
+     * @brief scan a comment
+     * @return whether comment could be scanned successfully
+     */
+    bool scan_comment()
+    {
+        switch (get())
+        {
+            // single-line comments skip input until a newline or EOF is read
+            case '/':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case '\n':
+                        case '\r':
+                        case char_traits<char_type>::eof():
+                        case '\0':
+                            return true;
+
+                        default:
+                            break;
+                    }
+                }
+            }
+
+            // multi-line comments skip input until */ is read
+            case '*':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case char_traits<char_type>::eof():
+                        case '\0':
+                        {
+                            error_message = "invalid comment; missing closing '*/'";
+                            return false;
+                        }
+
+                        case '*':
+                        {
+                            switch (get())
+                            {
+                                case '/':
+                                    return true;
+
+                                default:
+                                {
+                                    unget();
+                                    continue;
+                                }
+                            }
+                        }
+
+                        default:
+                            continue;
+                    }
+                }
+            }
+
+            // unexpected character after reading '/'
+            default:
+            {
+                error_message = "invalid comment; expecting '/' or '*' after '/'";
+                return false;
+            }
+        }
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(float& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtof(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtod(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(long double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtold(str, endptr);
+    }
+
+    /*!
+    @brief scan a number literal
+
+    This function scans a string according to Sect. 6 of RFC 8259.
+
+    The function is realized with a deterministic finite state machine derived
+    from the grammar described in RFC 8259. Starting in state "init", the
+    input is read and used to determined the next state. Only state "done"
+    accepts the number. State "error" is a trap state to model errors. In the
+    table below, "anything" means any character but the ones listed before.
+
+    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
+    ---------|----------|----------|----------|---------|---------|----------|-----------
+    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
+    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
+    zero     | done     | done     | exponent | done    | done    | decimal1 | done
+    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
+    decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]
+    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
+    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
+    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
+    any2     | any2     | any2     | done     | done    | done    | done     | done
+
+    The state machine is realized with one label per state (prefixed with
+    "scan_number_") and `goto` statements between them. The state machine
+    contains cycles, but any cycle can be left when EOF is read. Therefore,
+    the function is guaranteed to terminate.
+
+    During scanning, the read bytes are stored in token_buffer. This string is
+    then converted to a signed integer, an unsigned integer, or a
+    floating-point number.
+
+    @return token_type::value_unsigned, token_type::value_integer, or
+            token_type::value_float if number could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note The scanner is independent of the current locale. Internally, the
+          locale's decimal point is used instead of `.` to work with the
+          locale-dependent converters.
+    */
+    token_type scan_number()  // lgtm [cpp/use-of-goto]
+    {
+        // reset token_buffer to store the number's bytes
+        reset();
+
+        // the type of the parsed number; initially set to unsigned; will be
+        // changed if minus sign, decimal point or exponent is read
+        token_type number_type = token_type::value_unsigned;
+
+        // state (init): we just found out we need to scan a number
+        switch (current)
+        {
+            case '-':
+            {
+                add(current);
+                goto scan_number_minus;
+            }
+
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            // all other characters are rejected outside scan_number()
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+scan_number_minus:
+        // state: we just parsed a leading minus sign
+        number_type = token_type::value_integer;
+        switch (get())
+        {
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '-'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_zero:
+        // state: we just parse a zero (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_any1:
+        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_decimal1:
+        // state: we just parsed a decimal point
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '.'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_decimal2:
+        // we just parsed at least one number after a decimal point
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_exponent:
+        // we just parsed an exponent
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '+':
+            case '-':
+            {
+                add(current);
+                goto scan_number_sign;
+            }
+
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message =
+                    "invalid number; expected '+', '-', or digit after exponent";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_sign:
+        // we just parsed an exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after exponent sign";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_any2:
+        // we just parsed a number after the exponent or exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_done:
+        // unget the character after the number (we only read it to know that
+        // we are done scanning a number)
+        unget();
+
+        char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        errno = 0;
+
+        // try to parse integers first and fall back to floats
+        if (number_type == token_type::value_unsigned)
+        {
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_unsigned = static_cast<number_unsigned_t>(x);
+                if (value_unsigned == x)
+                {
+                    return token_type::value_unsigned;
+                }
+            }
+        }
+        else if (number_type == token_type::value_integer)
+        {
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_integer = static_cast<number_integer_t>(x);
+                if (value_integer == x)
+                {
+                    return token_type::value_integer;
+                }
+            }
+        }
+
+        // this code is reached if we parse a floating-point number or if an
+        // integer conversion above failed
+        strtof(value_float, token_buffer.data(), &endptr);
+
+        // we checked the number format before
+        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+        return token_type::value_float;
+    }
+
+    /*!
+    @param[in] literal_text  the literal text to expect
+    @param[in] length        the length of the passed literal text
+    @param[in] return_type   the token type to return on success
+    */
+    JSON_HEDLEY_NON_NULL(2)
+    token_type scan_literal(const char_type* literal_text, const std::size_t length,
+                            token_type return_type)
+    {
+        JSON_ASSERT(char_traits<char_type>::to_char_type(current) == literal_text[0]);
+        for (std::size_t i = 1; i < length; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(char_traits<char_type>::to_char_type(get()) != literal_text[i]))
+            {
+                error_message = "invalid literal";
+                return token_type::parse_error;
+            }
+        }
+        return return_type;
+    }
+
+    /////////////////////
+    // input management
+    /////////////////////
+
+    /// reset token_buffer; current character is beginning of token
+    void reset() noexcept
+    {
+        token_buffer.clear();
+        token_string.clear();
+        token_string.push_back(char_traits<char_type>::to_char_type(current));
+    }
+
+    /*
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a
+    `char_traits<char>::eof()` in that case.  Stores the scanned characters
+    for use in error messages.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++position.chars_read_total;
+        ++position.chars_read_current_line;
+
+        if (next_unget)
+        {
+            // just reset the next_unget variable and work with current
+            next_unget = false;
+        }
+        else
+        {
+            current = ia.get_character();
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
+        {
+            token_string.push_back(char_traits<char_type>::to_char_type(current));
+        }
+
+        if (current == '\n')
+        {
+            ++position.lines_read;
+            position.chars_read_current_line = 0;
+        }
+
+        return current;
+    }
+
+    /*!
+    @brief unget current character (read it again on next get)
+
+    We implement unget by setting variable next_unget to true. The input is not
+    changed - we just simulate ungetting by modifying chars_read_total,
+    chars_read_current_line, and token_string. The next call to get() will
+    behave as if the unget character is read again.
+    */
+    void unget()
+    {
+        next_unget = true;
+
+        --position.chars_read_total;
+
+        // in case we "unget" a newline, we have to also decrement the lines_read
+        if (position.chars_read_current_line == 0)
+        {
+            if (position.lines_read > 0)
+            {
+                --position.lines_read;
+            }
+        }
+        else
+        {
+            --position.chars_read_current_line;
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
+        {
+            JSON_ASSERT(!token_string.empty());
+            token_string.pop_back();
+        }
+    }
+
+    /// add a character to token_buffer
+    void add(char_int_type c)
+    {
+        token_buffer.push_back(static_cast<typename string_t::value_type>(c));
+    }
+
+  public:
+    /////////////////////
+    // value getters
+    /////////////////////
+
+    /// return integer value
+    constexpr number_integer_t get_number_integer() const noexcept
+    {
+        return value_integer;
+    }
+
+    /// return unsigned integer value
+    constexpr number_unsigned_t get_number_unsigned() const noexcept
+    {
+        return value_unsigned;
+    }
+
+    /// return floating-point value
+    constexpr number_float_t get_number_float() const noexcept
+    {
+        return value_float;
+    }
+
+    /// return current string value (implicitly resets the token; useful only once)
+    string_t& get_string()
+    {
+        return token_buffer;
+    }
+
+    /////////////////////
+    // diagnostics
+    /////////////////////
+
+    /// return position of last read token
+    constexpr position_t get_position() const noexcept
+    {
+        return position;
+    }
+
+    /// return the last read token (for errors only).  Will never contain EOF
+    /// (an arbitrary value that is not a valid char value, often -1), because
+    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
+    std::string get_token_string() const
+    {
+        // escape control characters
+        std::string result;
+        for (const auto c : token_string)
+        {
+            if (static_cast<unsigned char>(c) <= '\x1F')
+            {
+                // escape control characters
+                std::array<char, 9> cs{{}};
+                static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                result += cs.data();
+            }
+            else
+            {
+                // add character as is
+                result.push_back(static_cast<std::string::value_type>(c));
+            }
+        }
+
+        return result;
+    }
+
+    /// return syntax error message
+    JSON_HEDLEY_RETURNS_NON_NULL
+    constexpr const char* get_error_message() const noexcept
+    {
+        return error_message;
+    }
+
+    /////////////////////
+    // actual scanner
+    /////////////////////
+
+    /*!
+    @brief skip the UTF-8 byte order mark
+    @return true iff there is no BOM or the correct BOM has been skipped
+    */
+    bool skip_bom()
+    {
+        if (get() == 0xEF)
+        {
+            // check if we completely parse the BOM
+            return get() == 0xBB && get() == 0xBF;
+        }
+
+        // the first character is not the beginning of the BOM; unget it to
+        // process is later
+        unget();
+        return true;
+    }
+
+    void skip_whitespace()
+    {
+        do
+        {
+            get();
+        }
+        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
+    }
+
+    token_type scan()
+    {
+        // initially, skip the BOM
+        if (position.chars_read_total == 0 && !skip_bom())
+        {
+            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
+            return token_type::parse_error;
+        }
+
+        // read next character and ignore whitespace
+        skip_whitespace();
+
+        // ignore comments
+        while (ignore_comments && current == '/')
+        {
+            if (!scan_comment())
+            {
+                return token_type::parse_error;
+            }
+
+            // skip following whitespace
+            skip_whitespace();
+        }
+
+        switch (current)
+        {
+            // structural characters
+            case '[':
+                return token_type::begin_array;
+            case ']':
+                return token_type::end_array;
+            case '{':
+                return token_type::begin_object;
+            case '}':
+                return token_type::end_object;
+            case ':':
+                return token_type::name_separator;
+            case ',':
+                return token_type::value_separator;
+
+            // literals
+            case 't':
+            {
+                std::array<char_type, 4> true_literal = {{static_cast<char_type>('t'), static_cast<char_type>('r'), static_cast<char_type>('u'), static_cast<char_type>('e')}};
+                return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
+            }
+            case 'f':
+            {
+                std::array<char_type, 5> false_literal = {{static_cast<char_type>('f'), static_cast<char_type>('a'), static_cast<char_type>('l'), static_cast<char_type>('s'), static_cast<char_type>('e')}};
+                return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
+            }
+            case 'n':
+            {
+                std::array<char_type, 4> null_literal = {{static_cast<char_type>('n'), static_cast<char_type>('u'), static_cast<char_type>('l'), static_cast<char_type>('l')}};
+                return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
+            }
+
+            // string
+            case '\"':
+                return scan_string();
+
+            // number
+            case '-':
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                return scan_number();
+
+            // end of input (the null byte is needed when parsing from
+            // string literals)
+            case '\0':
+            case char_traits<char_type>::eof():
+                return token_type::end_of_input;
+
+            // error
+            default:
+                error_message = "invalid literal";
+                return token_type::parse_error;
+        }
+    }
+
+  private:
+    /// input adapter
+    InputAdapterType ia;
+
+    /// whether comments should be ignored (true) or signaled as errors (false)
+    const bool ignore_comments = false;
+
+    /// the current character
+    char_int_type current = char_traits<char_type>::eof();
+
+    /// whether the next get() call should just return current
+    bool next_unget = false;
+
+    /// the start position of the current token
+    position_t position {};
+
+    /// raw input token string (for error messages)
+    std::vector<char_type> token_string {};
+
+    /// buffer for variable-length tokens (numbers, strings)
+    string_t token_buffer {};
+
+    /// a description of occurred lexer errors
+    const char* error_message = "";
+
+    // number values
+    number_integer_t value_integer = 0;
+    number_unsigned_t value_unsigned = 0;
+    number_float_t value_float = 0;
+
+    /// the decimal point
+    const char_int_type decimal_point_char = '.';
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/parser.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/parser.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..bdf85ba29267bd39fb0d17dc7bea3b1d7e750ef4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/parser.hpp
@@ -0,0 +1,519 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cmath> // isfinite
+#include <cstdint> // uint8_t
+#include <functional> // function
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+#include <nlohmann/detail/exceptions.hpp>
+#include <nlohmann/detail/input/input_adapters.hpp>
+#include <nlohmann/detail/input/json_sax.hpp>
+#include <nlohmann/detail/input/lexer.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/meta/is_sax.hpp>
+#include <nlohmann/detail/string_concat.hpp>
+#include <nlohmann/detail/value_t.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+////////////
+// parser //
+////////////
+
+enum class parse_event_t : std::uint8_t
+{
+    /// the parser read `{` and started to process a JSON object
+    object_start,
+    /// the parser read `}` and finished processing a JSON object
+    object_end,
+    /// the parser read `[` and started to process a JSON array
+    array_start,
+    /// the parser read `]` and finished processing a JSON array
+    array_end,
+    /// the parser read a key of a value in an object
+    key,
+    /// the parser finished reading a JSON value
+    value
+};
+
+template<typename BasicJsonType>
+using parser_callback_t =
+    std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;
+
+/*!
+@brief syntax analysis
+
+This class implements a recursive descent parser.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class parser
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
+    using token_type = typename lexer_t::token_type;
+
+  public:
+    /// a parser reading from an input adapter
+    explicit parser(InputAdapterType&& adapter,
+                    const parser_callback_t<BasicJsonType> cb = nullptr,
+                    const bool allow_exceptions_ = true,
+                    const bool skip_comments = false)
+        : callback(cb)
+        , m_lexer(std::move(adapter), skip_comments)
+        , allow_exceptions(allow_exceptions_)
+    {
+        // read first token
+        get_token();
+    }
+
+    /*!
+    @brief public parser interface
+
+    @param[in] strict      whether to expect the last token to be EOF
+    @param[in,out] result  parsed JSON value
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+    */
+    void parse(const bool strict, BasicJsonType& result)
+    {
+        if (callback)
+        {
+            json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
+            sax_parse_internal(&sdp);
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value"), nullptr));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+
+            // set top-level value to null if it was discarded by the callback
+            // function
+            if (result.is_discarded())
+            {
+                result = nullptr;
+            }
+        }
+        else
+        {
+            json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
+            sax_parse_internal(&sdp);
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+        }
+
+        result.assert_invariant();
+    }
+
+    /*!
+    @brief public accept interface
+
+    @param[in] strict  whether to expect the last token to be EOF
+    @return whether the input is a proper JSON text
+    */
+    bool accept(const bool strict = true)
+    {
+        json_sax_acceptor<BasicJsonType> sax_acceptor;
+        return sax_parse(&sax_acceptor, strict);
+    }
+
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse(SAX* sax, const bool strict = true)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+        const bool result = sax_parse_internal(sax);
+
+        // strict mode: next byte must be EOF
+        if (result && strict && (get_token() != token_type::end_of_input))
+        {
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
+        }
+
+        return result;
+    }
+
+  private:
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse_internal(SAX* sax)
+    {
+        // stack to remember the hierarchy of structured values we are parsing
+        // true = array; false = object
+        std::vector<bool> states;
+        // value to avoid a goto (see comment where set to true)
+        bool skip_to_state_evaluation = false;
+
+        while (true)
+        {
+            if (!skip_to_state_evaluation)
+            {
+                // invariant: get_token() was called before each iteration
+                switch (last_token)
+                {
+                    case token_type::begin_object:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing } -> we are done
+                        if (get_token() == token_type::end_object)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // parse key
+                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        // parse separator (:)
+                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
+                        }
+
+                        // remember we are now inside an object
+                        states.push_back(false);
+
+                        // parse values
+                        get_token();
+                        continue;
+                    }
+
+                    case token_type::begin_array:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing ] -> we are done
+                        if (get_token() == token_type::end_array)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // remember we are now inside an array
+                        states.push_back(true);
+
+                        // parse values (no need to call get_token)
+                        continue;
+                    }
+
+                    case token_type::value_float:
+                    {
+                        const auto res = m_lexer.get_number_float();
+
+                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
+                        }
+
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        break;
+                    }
+
+                    case token_type::literal_false:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_null:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_true:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_integer:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_string:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_unsigned:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::parse_error:
+                    {
+                        // using "uninitialized" to avoid "expected" message
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr));
+                    }
+                    case token_type::end_of_input:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
+                        }
+
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
+                    }
+                    case token_type::uninitialized:
+                    case token_type::end_array:
+                    case token_type::end_object:
+                    case token_type::name_separator:
+                    case token_type::value_separator:
+                    case token_type::literal_or_value:
+                    default: // the last token was unexpected
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
+                    }
+                }
+            }
+            else
+            {
+                skip_to_state_evaluation = false;
+            }
+
+            // we reached this line after we successfully parsed a value
+            if (states.empty())
+            {
+                // empty stack: we reached the end of the hierarchy: done
+                return true;
+            }
+
+            if (states.back())  // array
+            {
+                // comma -> next value
+                if (get_token() == token_type::value_separator)
+                {
+                    // parse a new value
+                    get_token();
+                    continue;
+                }
+
+                // closing ]
+                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                    {
+                        return false;
+                    }
+
+                    // We are done with this array. Before we can parse a
+                    // new value, we need to evaluate the new state first.
+                    // By setting skip_to_state_evaluation to false, we
+                    // are effectively jumping to the beginning of this if.
+                    JSON_ASSERT(!states.empty());
+                    states.pop_back();
+                    skip_to_state_evaluation = true;
+                    continue;
+                }
+
+                return sax->parse_error(m_lexer.get_position(),
+                                        m_lexer.get_token_string(),
+                                        parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr));
+            }
+
+            // states.back() is false -> object
+
+            // comma -> next value
+            if (get_token() == token_type::value_separator)
+            {
+                // parse key
+                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
+                {
+                    return sax->parse_error(m_lexer.get_position(),
+                                            m_lexer.get_token_string(),
+                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
+                }
+
+                if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                {
+                    return false;
+                }
+
+                // parse separator (:)
+                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                {
+                    return sax->parse_error(m_lexer.get_position(),
+                                            m_lexer.get_token_string(),
+                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
+                }
+
+                // parse values
+                get_token();
+                continue;
+            }
+
+            // closing }
+            if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                {
+                    return false;
+                }
+
+                // We are done with this object. Before we can parse a
+                // new value, we need to evaluate the new state first.
+                // By setting skip_to_state_evaluation to false, we
+                // are effectively jumping to the beginning of this if.
+                JSON_ASSERT(!states.empty());
+                states.pop_back();
+                skip_to_state_evaluation = true;
+                continue;
+            }
+
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr));
+        }
+    }
+
+    /// get next token from lexer
+    token_type get_token()
+    {
+        return last_token = m_lexer.scan();
+    }
+
+    std::string exception_message(const token_type expected, const std::string& context)
+    {
+        std::string error_msg = "syntax error ";
+
+        if (!context.empty())
+        {
+            error_msg += concat("while parsing ", context, ' ');
+        }
+
+        error_msg += "- ";
+
+        if (last_token == token_type::parse_error)
+        {
+            error_msg += concat(m_lexer.get_error_message(), "; last read: '",
+                                m_lexer.get_token_string(), '\'');
+        }
+        else
+        {
+            error_msg += concat("unexpected ", lexer_t::token_type_name(last_token));
+        }
+
+        if (expected != token_type::uninitialized)
+        {
+            error_msg += concat("; expected ", lexer_t::token_type_name(expected));
+        }
+
+        return error_msg;
+    }
+
+  private:
+    /// callback function
+    const parser_callback_t<BasicJsonType> callback = nullptr;
+    /// the type of the last read token
+    token_type last_token = token_type::uninitialized;
+    /// the lexer
+    lexer_t m_lexer;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/position_t.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/position_t.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..8ac7c78cfd3377796254f35bd6bf8f3e5272c555
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/input/position_t.hpp
@@ -0,0 +1,37 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstddef> // size_t
+
+#include <nlohmann/detail/abi_macros.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// struct to capture the start position of the current token
+struct position_t
+{
+    /// the total number of characters read
+    std::size_t chars_read_total = 0;
+    /// the number of characters read in the current line
+    std::size_t chars_read_current_line = 0;
+    /// the number of lines read
+    std::size_t lines_read = 0;
+
+    /// conversion to size_t to preserve SAX interface
+    constexpr operator size_t() const
+    {
+        return chars_read_total;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/internal_iterator.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/internal_iterator.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..2991ee6930c8963df0cc853702e3e041fb09baf5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/internal_iterator.hpp
@@ -0,0 +1,35 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <nlohmann/detail/abi_macros.hpp>
+#include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief an iterator value
+
+@note This structure could easily be a union, but MSVC currently does not allow
+unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
+*/
+template<typename BasicJsonType> struct internal_iterator
+{
+    /// iterator for JSON objects
+    typename BasicJsonType::object_t::iterator object_iterator {};
+    /// iterator for JSON arrays
+    typename BasicJsonType::array_t::iterator array_iterator {};
+    /// generic iterator for all other types
+    primitive_iterator_t primitive_iterator {};
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/iter_impl.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/iter_impl.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..44470913477d06949401a2469157bff448ea4e8e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/iter_impl.hpp
@@ -0,0 +1,751 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
+#include <type_traits> // conditional, is_const, remove_const
+
+#include <nlohmann/detail/exceptions.hpp>
+#include <nlohmann/detail/iterators/internal_iterator.hpp>
+#include <nlohmann/detail/iterators/primitive_iterator.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/meta/cpp_future.hpp>
+#include <nlohmann/detail/meta/type_traits.hpp>
+#include <nlohmann/detail/value_t.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// forward declare, to be able to friend it later on
+template<typename IteratorType> class iteration_proxy;
+template<typename IteratorType> class iteration_proxy_value;
+
+/*!
+@brief a template for a bidirectional iterator for the @ref basic_json class
+This class implements a both iterators (iterator and const_iterator) for the
+@ref basic_json class.
+@note An iterator is called *initialized* when a pointer to a JSON value has
+      been set (e.g., by a constructor or a copy assignment). If the iterator is
+      default-constructed, it is *uninitialized* and most methods are undefined.
+      **The library uses assertions to detect calls on uninitialized iterators.**
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
+       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
+*/
+template<typename BasicJsonType>
+class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+{
+    /// the iterator with BasicJsonType of different const-ness
+    using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
+    /// allow basic_json to access private members
+    friend other_iter_impl;
+    friend BasicJsonType;
+    friend iteration_proxy<iter_impl>;
+    friend iteration_proxy_value<iter_impl>;
+
+    using object_t = typename BasicJsonType::object_t;
+    using array_t = typename BasicJsonType::array_t;
+    // make sure BasicJsonType is basic_json or const basic_json
+    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
+                  "iter_impl only accepts (const) basic_json");
+    // superficial check for the LegacyBidirectionalIterator named requirement
+    static_assert(std::is_base_of<std::bidirectional_iterator_tag, std::bidirectional_iterator_tag>::value
+                  &&  std::is_base_of<std::bidirectional_iterator_tag, typename std::iterator_traits<typename array_t::iterator>::iterator_category>::value,
+                  "basic_json iterator assumes array and object type iterators satisfy the LegacyBidirectionalIterator named requirement.");
+
+  public:
+    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
+    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
+    /// A user-defined iterator should provide publicly accessible typedefs named
+    /// iterator_category, value_type, difference_type, pointer, and reference.
+    /// Note that value_type is required to be non-const, even for constant iterators.
+    using iterator_category = std::bidirectional_iterator_tag;
+
+    /// the type of the values when the iterator is dereferenced
+    using value_type = typename BasicJsonType::value_type;
+    /// a type to represent differences between iterators
+    using difference_type = typename BasicJsonType::difference_type;
+    /// defines a pointer to the type iterated over (value_type)
+    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
+          typename BasicJsonType::const_pointer,
+          typename BasicJsonType::pointer>::type;
+    /// defines a reference to the type iterated over (value_type)
+    using reference =
+        typename std::conditional<std::is_const<BasicJsonType>::value,
+        typename BasicJsonType::const_reference,
+        typename BasicJsonType::reference>::type;
+
+    iter_impl() = default;
+    ~iter_impl() = default;
+    iter_impl(iter_impl&&) noexcept = default;
+    iter_impl& operator=(iter_impl&&) noexcept = default;
+
+    /*!
+    @brief constructor for a given JSON instance
+    @param[in] object  pointer to a JSON object for this iterator
+    @pre object != nullptr
+    @post The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    explicit iter_impl(pointer object) noexcept : m_object(object)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = typename object_t::iterator();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = typename array_t::iterator();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator = primitive_iterator_t();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @note The conventional copy constructor and copy assignment are implicitly
+          defined. Combined with the following converting constructor and
+          assignment, they support: (1) copy from iterator to iterator, (2)
+          copy from const iterator to const iterator, and (3) conversion from
+          iterator to const iterator. However conversion from const iterator
+          to iterator is not defined.
+    */
+
+    /*!
+    @brief const copy constructor
+    @param[in] other const iterator to copy from
+    @note This copy constructor had to be defined explicitly to circumvent a bug
+          occurring on msvc v19.0 compiler (VS 2015) debug build. For more
+          information refer to: https://github.com/nlohmann/json/issues/1608
+    */
+    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
+    {
+        if (&other != this)
+        {
+            m_object = other.m_object;
+            m_it = other.m_it;
+        }
+        return *this;
+    }
+
+    /*!
+    @brief converting constructor
+    @param[in] other  non-const iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other  non-const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
+    {
+        m_object = other.m_object;
+        m_it = other.m_it;
+        return *this;
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief set the iterator to the first value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_begin() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_data.m_value.object->begin();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_data.m_value.array->begin();
+                break;
+            }
+
+            case value_t::null:
+            {
+                // set to end so begin()==end() is true: null is empty
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator.set_begin();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @brief set the iterator past the last value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_end() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_data.m_value.object->end();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_data.m_value.array->end();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+        }
+    }
+
+  public:
+    /*!
+    @brief return a reference to the value pointed to by the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator*() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
+                return m_it.object_iterator->second;
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
+                return *m_it.array_iterator;
+            }
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief dereference the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    pointer operator->() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
+                return &(m_it.object_iterator->second);
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
+                return &*m_it.array_iterator;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief post-increment (it++)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        ++(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-increment (++it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator++()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, 1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, 1);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                ++m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief post-decrement (it--)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator--(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        --(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-decrement (--it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator--()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, -1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, -1);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                --m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief comparison: equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
+    bool operator==(const IterImpl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                return (m_it.object_iterator == other.m_it.object_iterator);
+
+            case value_t::array:
+                return (m_it.array_iterator == other.m_it.array_iterator);
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief comparison: not equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
+    bool operator!=(const IterImpl& other) const
+    {
+        return !operator==(other);
+    }
+
+    /*!
+    @brief comparison: smaller
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", m_object));
+
+            case value_t::array:
+                return (m_it.array_iterator < other.m_it.array_iterator);
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<=(const iter_impl& other) const
+    {
+        return !other.operator < (*this);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>(const iter_impl& other) const
+    {
+        return !operator<=(other);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>=(const iter_impl& other) const
+    {
+        return !operator<(other);
+    }
+
+    /*!
+    @brief add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator+=(difference_type i)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, i);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator += i;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator-=(difference_type i)
+    {
+        return operator+=(-i);
+    }
+
+    /*!
+    @brief add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator+(difference_type i) const
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief addition of distance and iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    friend iter_impl operator+(difference_type i, const iter_impl& it)
+    {
+        auto result = it;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator-(difference_type i) const
+    {
+        auto result = *this;
+        result -= i;
+        return result;
+    }
+
+    /*!
+    @brief return difference
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    difference_type operator-(const iter_impl& other) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
+
+            case value_t::array:
+                return m_it.array_iterator - other.m_it.array_iterator;
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return m_it.primitive_iterator - other.m_it.primitive_iterator;
+        }
+    }
+
+    /*!
+    @brief access to successor
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator[](difference_type n) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", m_object));
+
+            case value_t::array:
+                return *std::next(m_it.array_iterator, n);
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief return the key of an object iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    const typename object_t::key_type& key() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
+        {
+            return m_it.object_iterator->first;
+        }
+
+        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
+    }
+
+    /*!
+    @brief return the value of an iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference value() const
+    {
+        return operator*();
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// associated JSON instance
+    pointer m_object = nullptr;
+    /// the actual iterator of the associated instance
+    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/iteration_proxy.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/iteration_proxy.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..76293de22701c7662053a5e0a16addd4693a2bc1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/iteration_proxy.hpp
@@ -0,0 +1,242 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstddef> // size_t
+#include <iterator> // input_iterator_tag
+#include <string> // string, to_string
+#include <tuple> // tuple_size, get, tuple_element
+#include <utility> // move
+
+#if JSON_HAS_RANGES
+    #include <ranges> // enable_borrowed_range
+#endif
+
+#include <nlohmann/detail/abi_macros.hpp>
+#include <nlohmann/detail/meta/type_traits.hpp>
+#include <nlohmann/detail/value_t.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename string_type>
+void int_to_string( string_type& target, std::size_t value )
+{
+    // For ADL
+    using std::to_string;
+    target = to_string(value);
+}
+template<typename IteratorType> class iteration_proxy_value
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    using value_type = iteration_proxy_value;
+    using pointer = value_type *;
+    using reference = value_type &;
+    using iterator_category = std::input_iterator_tag;
+    using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
+
+  private:
+    /// the iterator
+    IteratorType anchor{};
+    /// an index for arrays (used to create key names)
+    std::size_t array_index = 0;
+    /// last stringified array index
+    mutable std::size_t array_index_last = 0;
+    /// a string representation of the array index
+    mutable string_type array_index_str = "0";
+    /// an empty string (to return a reference for primitive values)
+    string_type empty_str{};
+
+  public:
+    explicit iteration_proxy_value() = default;
+    explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
+    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
+             && std::is_nothrow_default_constructible<string_type>::value)
+        : anchor(std::move(it))
+        , array_index(array_index_)
+    {}
+
+    iteration_proxy_value(iteration_proxy_value const&) = default;
+    iteration_proxy_value& operator=(iteration_proxy_value const&) = default;
+    // older GCCs are a bit fussy and require explicit noexcept specifiers on defaulted functions
+    iteration_proxy_value(iteration_proxy_value&&)
+    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
+             && std::is_nothrow_move_constructible<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
+    iteration_proxy_value& operator=(iteration_proxy_value&&)
+    noexcept(std::is_nothrow_move_assignable<IteratorType>::value
+             && std::is_nothrow_move_assignable<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
+    ~iteration_proxy_value() = default;
+
+    /// dereference operator (needed for range-based for)
+    const iteration_proxy_value& operator*() const
+    {
+        return *this;
+    }
+
+    /// increment operator (needed for range-based for)
+    iteration_proxy_value& operator++()
+    {
+        ++anchor;
+        ++array_index;
+
+        return *this;
+    }
+
+    iteration_proxy_value operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto tmp = iteration_proxy_value(anchor, array_index);
+        ++anchor;
+        ++array_index;
+        return tmp;
+    }
+
+    /// equality operator (needed for InputIterator)
+    bool operator==(const iteration_proxy_value& o) const
+    {
+        return anchor == o.anchor;
+    }
+
+    /// inequality operator (needed for range-based for)
+    bool operator!=(const iteration_proxy_value& o) const
+    {
+        return anchor != o.anchor;
+    }
+
+    /// return key of the iterator
+    const string_type& key() const
+    {
+        JSON_ASSERT(anchor.m_object != nullptr);
+
+        switch (anchor.m_object->type())
+        {
+            // use integer array index as key
+            case value_t::array:
+            {
+                if (array_index != array_index_last)
+                {
+                    int_to_string( array_index_str, array_index );
+                    array_index_last = array_index;
+                }
+                return array_index_str;
+            }
+
+            // use key from the object
+            case value_t::object:
+                return anchor.key();
+
+            // use an empty key for all primitive types
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return empty_str;
+        }
+    }
+
+    /// return value of the iterator
+    typename IteratorType::reference value() const
+    {
+        return anchor.value();
+    }
+};
+
+/// proxy class for the items() function
+template<typename IteratorType> class iteration_proxy
+{
+  private:
+    /// the container to iterate
+    typename IteratorType::pointer container = nullptr;
+
+  public:
+    explicit iteration_proxy() = default;
+
+    /// construct iteration proxy from a container
+    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
+        : container(&cont) {}
+
+    iteration_proxy(iteration_proxy const&) = default;
+    iteration_proxy& operator=(iteration_proxy const&) = default;
+    iteration_proxy(iteration_proxy&&) noexcept = default;
+    iteration_proxy& operator=(iteration_proxy&&) noexcept = default;
+    ~iteration_proxy() = default;
+
+    /// return iterator begin (needed for range-based for)
+    iteration_proxy_value<IteratorType> begin() const noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container->begin());
+    }
+
+    /// return iterator end (needed for range-based for)
+    iteration_proxy_value<IteratorType> end() const noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container->end());
+    }
+};
+
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
+{
+    return i.key();
+}
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
+{
+    return i.value();
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// The Addition to the STD Namespace is required to add
+// Structured Bindings Support to the iteration_proxy_value class
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+namespace std
+{
+
+#if defined(__clang__)
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+template<typename IteratorType>
+class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
+            : public std::integral_constant<std::size_t, 2> {};
+
+template<std::size_t N, typename IteratorType>
+class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >> // NOLINT(cert-dcl58-cpp)
+{
+  public:
+    using type = decltype(
+                     get<N>(std::declval <
+                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
+};
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+}  // namespace std
+
+#if JSON_HAS_RANGES
+    template <typename IteratorType>
+    inline constexpr bool ::std::ranges::enable_borrowed_range<::nlohmann::detail::iteration_proxy<IteratorType>> = true;
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/iterator_traits.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/iterator_traits.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..84cc27a85ea5c20491d4af837c98d3e42f6cc6c6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/iterator_traits.hpp
@@ -0,0 +1,61 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <iterator> // random_access_iterator_tag
+
+#include <nlohmann/detail/abi_macros.hpp>
+#include <nlohmann/detail/meta/void_t.hpp>
+#include <nlohmann/detail/meta/cpp_future.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename It, typename = void>
+struct iterator_types {};
+
+template<typename It>
+struct iterator_types <
+    It,
+    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
+    typename It::reference, typename It::iterator_category >>
+{
+    using difference_type = typename It::difference_type;
+    using value_type = typename It::value_type;
+    using pointer = typename It::pointer;
+    using reference = typename It::reference;
+    using iterator_category = typename It::iterator_category;
+};
+
+// This is required as some compilers implement std::iterator_traits in a way that
+// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
+template<typename T, typename = void>
+struct iterator_traits
+{
+};
+
+template<typename T>
+struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
+            : iterator_types<T>
+{
+};
+
+template<typename T>
+struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
+{
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = T;
+    using difference_type = ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/json_reverse_iterator.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/json_reverse_iterator.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..006d5499ad59c1e1d167d9941bd17793d92b05e8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/json_reverse_iterator.hpp
@@ -0,0 +1,130 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstddef> // ptrdiff_t
+#include <iterator> // reverse_iterator
+#include <utility> // declval
+
+#include <nlohmann/detail/abi_macros.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+//////////////////////
+// reverse_iterator //
+//////////////////////
+
+/*!
+@brief a template for a reverse iterator class
+
+@tparam Base the base iterator type to reverse. Valid types are @ref
+iterator (to create @ref reverse_iterator) and @ref const_iterator (to
+create @ref const_reverse_iterator).
+
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
+  It is possible to write to the pointed-to element (only if @a Base is
+  @ref iterator).
+
+@since version 1.0.0
+*/
+template<typename Base>
+class json_reverse_iterator : public std::reverse_iterator<Base>
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    /// shortcut to the reverse iterator adapter
+    using base_iterator = std::reverse_iterator<Base>;
+    /// the reference type for the pointed-to element
+    using reference = typename Base::reference;
+
+    /// create reverse iterator from iterator
+    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
+        : base_iterator(it) {}
+
+    /// create reverse iterator from base class
+    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
+
+    /// post-increment (it++)
+    json_reverse_iterator operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
+    }
+
+    /// pre-increment (++it)
+    json_reverse_iterator& operator++()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
+    }
+
+    /// post-decrement (it--)
+    json_reverse_iterator operator--(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
+    }
+
+    /// pre-decrement (--it)
+    json_reverse_iterator& operator--()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
+    }
+
+    /// add to iterator
+    json_reverse_iterator& operator+=(difference_type i)
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
+    }
+
+    /// add to iterator
+    json_reverse_iterator operator+(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
+    }
+
+    /// subtract from iterator
+    json_reverse_iterator operator-(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
+    }
+
+    /// return difference
+    difference_type operator-(const json_reverse_iterator& other) const
+    {
+        return base_iterator(*this) - base_iterator(other);
+    }
+
+    /// access to successor
+    reference operator[](difference_type n) const
+    {
+        return *(this->operator+(n));
+    }
+
+    /// return the key of an object iterator
+    auto key() const -> decltype(std::declval<Base>().key())
+    {
+        auto it = --this->base();
+        return it.key();
+    }
+
+    /// return the value of an iterator
+    reference value() const
+    {
+        auto it = --this->base();
+        return it.operator * ();
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/primitive_iterator.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/primitive_iterator.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..0b6e8499e6050baf20cf72f41081f851dc76b04d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/iterators/primitive_iterator.hpp
@@ -0,0 +1,132 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstddef> // ptrdiff_t
+#include <limits>  // numeric_limits
+
+#include <nlohmann/detail/macro_scope.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*
+@brief an iterator for primitive JSON types
+
+This class models an iterator for primitive JSON types (boolean, number,
+string). It's only purpose is to allow the iterator/const_iterator classes
+to "iterate" over primitive values. Internally, the iterator is modeled by
+a `difference_type` variable. Value begin_value (`0`) models the begin,
+end_value (`1`) models past the end.
+*/
+class primitive_iterator_t
+{
+  private:
+    using difference_type = std::ptrdiff_t;
+    static constexpr difference_type begin_value = 0;
+    static constexpr difference_type end_value = begin_value + 1;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// iterator as signed integer type
+    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
+
+  public:
+    constexpr difference_type get_value() const noexcept
+    {
+        return m_it;
+    }
+
+    /// set iterator to a defined beginning
+    void set_begin() noexcept
+    {
+        m_it = begin_value;
+    }
+
+    /// set iterator to a defined past the end
+    void set_end() noexcept
+    {
+        m_it = end_value;
+    }
+
+    /// return whether the iterator can be dereferenced
+    constexpr bool is_begin() const noexcept
+    {
+        return m_it == begin_value;
+    }
+
+    /// return whether the iterator is at end
+    constexpr bool is_end() const noexcept
+    {
+        return m_it == end_value;
+    }
+
+    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it == rhs.m_it;
+    }
+
+    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it < rhs.m_it;
+    }
+
+    primitive_iterator_t operator+(difference_type n) noexcept
+    {
+        auto result = *this;
+        result += n;
+        return result;
+    }
+
+    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it - rhs.m_it;
+    }
+
+    primitive_iterator_t& operator++() noexcept
+    {
+        ++m_it;
+        return *this;
+    }
+
+    primitive_iterator_t operator++(int)& noexcept // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        ++m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator--() noexcept
+    {
+        --m_it;
+        return *this;
+    }
+
+    primitive_iterator_t operator--(int)& noexcept // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        --m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator+=(difference_type n) noexcept
+    {
+        m_it += n;
+        return *this;
+    }
+
+    primitive_iterator_t& operator-=(difference_type n) noexcept
+    {
+        m_it -= n;
+        return *this;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/json_custom_base_class.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/json_custom_base_class.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..d1e29162a37baf3e8a489f0594d3f0fa6902d9c9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/json_custom_base_class.hpp
@@ -0,0 +1,39 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <type_traits> // conditional, is_same
+
+#include <nlohmann/detail/abi_macros.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief Default base class of the @ref basic_json class.
+
+So that the correct implementations of the copy / move ctors / assign operators
+of @ref basic_json do not require complex case distinctions
+(no base class / custom base class used as customization point),
+@ref basic_json always has a base class.
+By default, this class is used because it is empty and thus has no effect
+on the behavior of @ref basic_json.
+*/
+struct json_default_base {};
+
+template<class T>
+using json_base_class = typename std::conditional <
+                        std::is_same<T, void>::value,
+                        json_default_base,
+                        T
+                        >::type;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/json_pointer.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/json_pointer.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..4fdcd9ad28244b25f37e88393ceccf74dd1891e1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/json_pointer.hpp
@@ -0,0 +1,988 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <algorithm> // all_of
+#include <cctype> // isdigit
+#include <cerrno> // errno, ERANGE
+#include <cstdlib> // strtoull
+#ifndef JSON_NO_IO
+    #include <iosfwd> // ostream
+#endif  // JSON_NO_IO
+#include <limits> // max
+#include <numeric> // accumulate
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+#include <nlohmann/detail/exceptions.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/string_concat.hpp>
+#include <nlohmann/detail/string_escape.hpp>
+#include <nlohmann/detail/value_t.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+/// @sa https://json.nlohmann.me/api/json_pointer/
+template<typename RefStringType>
+class json_pointer
+{
+    // allow basic_json to access private members
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    friend class basic_json;
+
+    template<typename>
+    friend class json_pointer;
+
+    template<typename T>
+    struct string_t_helper
+    {
+        using type = T;
+    };
+
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    struct string_t_helper<NLOHMANN_BASIC_JSON_TPL>
+    {
+        using type = StringType;
+    };
+
+  public:
+    // for backwards compatibility accept BasicJsonType
+    using string_t = typename string_t_helper<RefStringType>::type;
+
+    /// @brief create JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/
+    explicit json_pointer(const string_t& s = "")
+        : reference_tokens(split(s))
+    {}
+
+    /// @brief return a string representation of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
+    string_t to_string() const
+    {
+        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
+                               string_t{},
+                               [](const string_t& a, const string_t& b)
+        {
+            return detail::concat(a, '/', detail::escape(b));
+        });
+    }
+
+    /// @brief return a string representation of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
+    operator string_t() const
+    {
+        return to_string();
+    }
+
+#ifndef JSON_NO_IO
+    /// @brief write string representation of the JSON pointer to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr)
+    {
+        o << ptr.to_string();
+        return o;
+    }
+#endif
+
+    /// @brief append another JSON pointer at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(const json_pointer& ptr)
+    {
+        reference_tokens.insert(reference_tokens.end(),
+                                ptr.reference_tokens.begin(),
+                                ptr.reference_tokens.end());
+        return *this;
+    }
+
+    /// @brief append an unescaped reference token at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(string_t token)
+    {
+        push_back(std::move(token));
+        return *this;
+    }
+
+    /// @brief append an array index at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(std::size_t array_idx)
+    {
+        return *this /= std::to_string(array_idx);
+    }
+
+    /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs,
+                                  const json_pointer& rhs)
+    {
+        return json_pointer(lhs) /= rhs;
+    }
+
+    /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs, string_t token) // NOLINT(performance-unnecessary-value-param)
+    {
+        return json_pointer(lhs) /= std::move(token);
+    }
+
+    /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
+    {
+        return json_pointer(lhs) /= array_idx;
+    }
+
+    /// @brief returns the parent of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/
+    json_pointer parent_pointer() const
+    {
+        if (empty())
+        {
+            return *this;
+        }
+
+        json_pointer res = *this;
+        res.pop_back();
+        return res;
+    }
+
+    /// @brief remove last reference token
+    /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/
+    void pop_back()
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        reference_tokens.pop_back();
+    }
+
+    /// @brief return last reference token
+    /// @sa https://json.nlohmann.me/api/json_pointer/back/
+    const string_t& back() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        return reference_tokens.back();
+    }
+
+    /// @brief append an unescaped token at the end of the reference pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
+    void push_back(const string_t& token)
+    {
+        reference_tokens.push_back(token);
+    }
+
+    /// @brief append an unescaped token at the end of the reference pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
+    void push_back(string_t&& token)
+    {
+        reference_tokens.push_back(std::move(token));
+    }
+
+    /// @brief return whether pointer points to the root document
+    /// @sa https://json.nlohmann.me/api/json_pointer/empty/
+    bool empty() const noexcept
+    {
+        return reference_tokens.empty();
+    }
+
+  private:
+    /*!
+    @param[in] s  reference token to be converted into an array index
+
+    @return integer representation of @a s
+
+    @throw parse_error.106  if an array index begins with '0'
+    @throw parse_error.109  if an array index begins not with a digit
+    @throw out_of_range.404 if string @a s could not be converted to an integer
+    @throw out_of_range.410 if an array index exceeds size_type
+    */
+    template<typename BasicJsonType>
+    static typename BasicJsonType::size_type array_index(const string_t& s)
+    {
+        using size_type = typename BasicJsonType::size_type;
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
+        {
+            JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr));
+        }
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
+        {
+            JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr));
+        }
+
+        const char* p = s.c_str();
+        char* p_end = nullptr;
+        errno = 0; // strtoull doesn't reset errno
+        const unsigned long long res = std::strtoull(p, &p_end, 10); // NOLINT(runtime/int)
+        if (p == p_end // invalid input or empty string
+                || errno == ERANGE // out of range
+                || JSON_HEDLEY_UNLIKELY(static_cast<std::size_t>(p_end - p) != s.size())) // incomplete read
+        {
+            JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr));
+        }
+
+        // only triggered on special platforms (like 32bit), see also
+        // https://github.com/nlohmann/json/pull/2203
+        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))  // NOLINT(runtime/int)
+        {
+            JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr));   // LCOV_EXCL_LINE
+        }
+
+        return static_cast<size_type>(res);
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    json_pointer top() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        json_pointer result = *this;
+        result.reference_tokens = {reference_tokens[0]};
+        return result;
+    }
+
+  private:
+    /*!
+    @brief create and return a reference to the pointed to value
+
+    @complexity Linear in the number of reference tokens.
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.313 if value cannot be unflattened
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_and_create(BasicJsonType& j) const
+    {
+        auto* result = &j;
+
+        // in case no reference tokens exist, return a reference to the JSON value
+        // j which will be overwritten by a primitive value
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (result->type())
+            {
+                case detail::value_t::null:
+                {
+                    if (reference_token == "0")
+                    {
+                        // start a new array if reference token is 0
+                        result = &result->operator[](0);
+                    }
+                    else
+                    {
+                        // start a new object otherwise
+                        result = &result->operator[](reference_token);
+                    }
+                    break;
+                }
+
+                case detail::value_t::object:
+                {
+                    // create an entry in the object
+                    result = &result->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    // create an entry in the array
+                    result = &result->operator[](array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                /*
+                The following code is only reached if there exists a reference
+                token _and_ the current value is primitive. In this case, we have
+                an error situation, because primitive values may only occur as
+                single value; that is, with an empty list of reference tokens.
+                */
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));
+            }
+        }
+
+        return *result;
+    }
+
+    /*!
+    @brief return a reference to the pointed to value
+
+    @note This version does not throw if a value is not present, but tries to
+          create nested values instead. For instance, calling this function
+          with pointer `"/this/that"` on a null value is equivalent to calling
+          `operator[]("this").operator[]("that")` on that value, effectively
+          changing the null value to an object.
+
+    @param[in] ptr  a JSON value
+
+    @return reference to the JSON value pointed to by the JSON pointer
+
+    @complexity Linear in the length of the JSON pointer.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            // convert null values to arrays or objects before continuing
+            if (ptr->is_null())
+            {
+                // check if reference token is a number
+                const bool nums =
+                    std::all_of(reference_token.begin(), reference_token.end(),
+                                [](const unsigned char x)
+                {
+                    return std::isdigit(x);
+                });
+
+                // change value to array for numbers or "-" or to object otherwise
+                *ptr = (nums || reference_token == "-")
+                       ? detail::value_t::array
+                       : detail::value_t::object;
+            }
+
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // explicitly treat "-" as index beyond the end
+                        ptr = &ptr->operator[](ptr->m_data.m_value.array->size());
+                    }
+                    else
+                    {
+                        // convert array index to number; unchecked access
+                        ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
+                    }
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_checked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
+                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
+                                ") is out of range"), ptr));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @brief return a const reference to the pointed to value
+
+    @param[in] ptr  a JSON value
+
+    @return const reference to the JSON value pointed to by the JSON
+    pointer
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" cannot be used for const access
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr));
+                    }
+
+                    // use unchecked array access
+                    ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
+                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
+                                ") is out of range"), ptr));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    */
+    template<typename BasicJsonType>
+    bool contains(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    if (!ptr->contains(reference_token))
+                    {
+                        // we did not find the key in the object
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
+                    {
+                        // invalid char
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
+                        {
+                            // first char should be between '1' and '9'
+                            return false;
+                        }
+                        for (std::size_t i = 1; i < reference_token.size(); i++)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
+                            {
+                                // other char should be between '0' and '9'
+                                return false;
+                            }
+                        }
+                    }
+
+                    const auto idx = array_index<BasicJsonType>(reference_token);
+                    if (idx >= ptr->size())
+                    {
+                        // index out of range
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](idx);
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                {
+                    // we do not expect primitive values if there is still a
+                    // reference token to process
+                    return false;
+                }
+            }
+        }
+
+        // no reference token left means we found a primitive value
+        return true;
+    }
+
+    /*!
+    @brief split the string input to reference tokens
+
+    @note This function is only called by the json_pointer constructor.
+          All exceptions below are documented there.
+
+    @throw parse_error.107  if the pointer is not empty or begins with '/'
+    @throw parse_error.108  if character '~' is not followed by '0' or '1'
+    */
+    static std::vector<string_t> split(const string_t& reference_string)
+    {
+        std::vector<string_t> result;
+
+        // special case: empty reference string -> no reference tokens
+        if (reference_string.empty())
+        {
+            return result;
+        }
+
+        // check if nonempty reference string begins with slash
+        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
+        {
+            JSON_THROW(detail::parse_error::create(107, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr));
+        }
+
+        // extract the reference tokens:
+        // - slash: position of the last read slash (or end of string)
+        // - start: position after the previous slash
+        for (
+            // search for the first slash after the first character
+            std::size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == 0 (if slash == string_t::npos)
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == string_t::npos)
+            start = (slash == string_t::npos) ? 0 : slash + 1,
+            // find next slash
+            slash = reference_string.find_first_of('/', start))
+        {
+            // use the text between the beginning of the reference token
+            // (start) and the last slash (slash).
+            auto reference_token = reference_string.substr(start, slash - start);
+
+            // check reference tokens are properly escaped
+            for (std::size_t pos = reference_token.find_first_of('~');
+                    pos != string_t::npos;
+                    pos = reference_token.find_first_of('~', pos + 1))
+            {
+                JSON_ASSERT(reference_token[pos] == '~');
+
+                // ~ must be followed by 0 or 1
+                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
+                                         (reference_token[pos + 1] != '0' &&
+                                          reference_token[pos + 1] != '1')))
+                {
+                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", nullptr));
+                }
+            }
+
+            // finally, store the reference token
+            detail::unescape(reference_token);
+            result.push_back(reference_token);
+        }
+
+        return result;
+    }
+
+  private:
+    /*!
+    @param[in] reference_string  the reference string to the current value
+    @param[in] value             the value to consider
+    @param[in,out] result        the result object to insert values to
+
+    @note Empty objects or arrays are flattened to `null`.
+    */
+    template<typename BasicJsonType>
+    static void flatten(const string_t& reference_string,
+                        const BasicJsonType& value,
+                        BasicJsonType& result)
+    {
+        switch (value.type())
+        {
+            case detail::value_t::array:
+            {
+                if (value.m_data.m_value.array->empty())
+                {
+                    // flatten empty array as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate array and use index as reference string
+                    for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i)
+                    {
+                        flatten(detail::concat(reference_string, '/', std::to_string(i)),
+                                value.m_data.m_value.array->operator[](i), result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::object:
+            {
+                if (value.m_data.m_value.object->empty())
+                {
+                    // flatten empty object as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate object and use keys as reference string
+                    for (const auto& element : *value.m_data.m_value.object)
+                    {
+                        flatten(detail::concat(reference_string, '/', detail::escape(element.first)), element.second, result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::null:
+            case detail::value_t::string:
+            case detail::value_t::boolean:
+            case detail::value_t::number_integer:
+            case detail::value_t::number_unsigned:
+            case detail::value_t::number_float:
+            case detail::value_t::binary:
+            case detail::value_t::discarded:
+            default:
+            {
+                // add primitive value with its reference string
+                result[reference_string] = value;
+                break;
+            }
+        }
+    }
+
+    /*!
+    @param[in] value  flattened JSON
+
+    @return unflattened JSON
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+    @throw type_error.313  if value cannot be unflattened
+    */
+    template<typename BasicJsonType>
+    static BasicJsonType
+    unflatten(const BasicJsonType& value)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
+        {
+            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", &value));
+        }
+
+        BasicJsonType result;
+
+        // iterate the JSON object values
+        for (const auto& element : *value.m_data.m_value.object)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
+            {
+                JSON_THROW(detail::type_error::create(315, "values in object must be primitive", &element.second));
+            }
+
+            // assign value to reference pointed to by JSON pointer; Note that if
+            // the JSON pointer is "" (i.e., points to the whole value), function
+            // get_and_create returns a reference to result itself. An assignment
+            // will then create a primitive value.
+            json_pointer(element.first).get_and_create(result) = element.second;
+        }
+
+        return result;
+    }
+
+    // can't use conversion operator because of ambiguity
+    json_pointer<string_t> convert() const&
+    {
+        json_pointer<string_t> result;
+        result.reference_tokens = reference_tokens;
+        return result;
+    }
+
+    json_pointer<string_t> convert()&&
+    {
+        json_pointer<string_t> result;
+        result.reference_tokens = std::move(reference_tokens);
+        return result;
+    }
+
+  public:
+#if JSON_HAS_THREE_WAY_COMPARISON
+    /// @brief compares two JSON pointers for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeRhs>
+    bool operator==(const json_pointer<RefStringTypeRhs>& rhs) const noexcept
+    {
+        return reference_tokens == rhs.reference_tokens;
+    }
+
+    /// @brief compares JSON pointer and string for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
+    bool operator==(const string_t& rhs) const
+    {
+        return *this == json_pointer(rhs);
+    }
+
+    /// @brief 3-way compares two JSON pointers
+    template<typename RefStringTypeRhs>
+    std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept // *NOPAD*
+    {
+        return  reference_tokens <=> rhs.reference_tokens; // *NOPAD*
+    }
+#else
+    /// @brief compares two JSON pointers for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+
+    /// @brief compares JSON pointer and string for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeLhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                           const StringType& rhs);
+
+    /// @brief compares string and JSON pointer for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeRhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const StringType& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs);
+
+    /// @brief compares two JSON pointers for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+
+    /// @brief compares JSON pointer and string for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeLhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                           const StringType& rhs);
+
+    /// @brief compares string and JSON pointer for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeRhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const StringType& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs);
+
+    /// @brief compares two JSON pointer for less-than
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
+                          const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+#endif
+
+  private:
+    /// the reference tokens
+    std::vector<string_t> reference_tokens;
+};
+
+#if !JSON_HAS_THREE_WAY_COMPARISON
+// functions cannot be defined inside class due to ODR violations
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return lhs.reference_tokens == rhs.reference_tokens;
+}
+
+template<typename RefStringTypeLhs,
+         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
+inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                       const StringType& rhs)
+{
+    return lhs == json_pointer<RefStringTypeLhs>(rhs);
+}
+
+template<typename RefStringTypeRhs,
+         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
+inline bool operator==(const StringType& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs)
+{
+    return json_pointer<RefStringTypeRhs>(lhs) == rhs;
+}
+
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeLhs,
+         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
+inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                       const StringType& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeRhs,
+         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
+inline bool operator!=(const StringType& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
+                      const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return lhs.reference_tokens < rhs.reference_tokens;
+}
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/json_ref.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/json_ref.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b8bb6a76b06717e3337b732f61373a3a0cb5d18b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/json_ref.hpp
@@ -0,0 +1,78 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <initializer_list>
+#include <utility>
+
+#include <nlohmann/detail/abi_macros.hpp>
+#include <nlohmann/detail/meta/type_traits.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename BasicJsonType>
+class json_ref
+{
+  public:
+    using value_type = BasicJsonType;
+
+    json_ref(value_type&& value)
+        : owned_value(std::move(value))
+    {}
+
+    json_ref(const value_type& value)
+        : value_ref(&value)
+    {}
+
+    json_ref(std::initializer_list<json_ref> init)
+        : owned_value(init)
+    {}
+
+    template <
+        class... Args,
+        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
+    json_ref(Args && ... args)
+        : owned_value(std::forward<Args>(args)...)
+    {}
+
+    // class should be movable only
+    json_ref(json_ref&&) noexcept = default;
+    json_ref(const json_ref&) = delete;
+    json_ref& operator=(const json_ref&) = delete;
+    json_ref& operator=(json_ref&&) = delete;
+    ~json_ref() = default;
+
+    value_type moved_or_copied() const
+    {
+        if (value_ref == nullptr)
+        {
+            return std::move(owned_value);
+        }
+        return *value_ref;
+    }
+
+    value_type const& operator*() const
+    {
+        return value_ref ? *value_ref : owned_value;
+    }
+
+    value_type const* operator->() const
+    {
+        return &** this;
+    }
+
+  private:
+    mutable value_type owned_value = nullptr;
+    value_type const* value_ref = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/macro_scope.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/macro_scope.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..97127a646279904b9727712504af17239932fa73
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/macro_scope.hpp
@@ -0,0 +1,482 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <utility> // declval, pair
+#include <nlohmann/detail/meta/detected.hpp>
+#include <nlohmann/thirdparty/hedley/hedley.hpp>
+
+// This file contains all internal macro definitions (except those affecting ABI)
+// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
+
+#include <nlohmann/detail/abi_macros.hpp>
+
+// exclude unsupported compilers
+#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
+    #if defined(__clang__)
+        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
+            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
+        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
+            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #endif
+#endif
+
+// C++ language standard detection
+// if the user manually specified the used c++ version this is skipped
+#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
+    #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
+        #define JSON_HAS_CPP_20
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+        #define JSON_HAS_CPP_14
+    #endif
+    // the cpp 11 flag is always specified because it is the minimal required version
+    #define JSON_HAS_CPP_11
+#endif
+
+#ifdef __has_include
+    #if __has_include(<version>)
+        #include <version>
+    #endif
+#endif
+
+#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
+    #ifdef JSON_HAS_CPP_17
+        #if defined(__cpp_lib_filesystem)
+            #define JSON_HAS_FILESYSTEM 1
+        #elif defined(__cpp_lib_experimental_filesystem)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #elif !defined(__has_include)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #elif __has_include(<filesystem>)
+            #define JSON_HAS_FILESYSTEM 1
+        #elif __has_include(<experimental/filesystem>)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #endif
+
+        // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
+        #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(__clang_major__) && __clang_major__ < 7
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(_MSC_VER) && _MSC_VER < 1914
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before iOS 13
+        #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before macOS Catalina
+        #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+    #endif
+#endif
+
+#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+    #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
+#endif
+
+#ifndef JSON_HAS_FILESYSTEM
+    #define JSON_HAS_FILESYSTEM 0
+#endif
+
+#ifndef JSON_HAS_THREE_WAY_COMPARISON
+    #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \
+        && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L
+        #define JSON_HAS_THREE_WAY_COMPARISON 1
+    #else
+        #define JSON_HAS_THREE_WAY_COMPARISON 0
+    #endif
+#endif
+
+#ifndef JSON_HAS_RANGES
+    // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error
+    #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427
+        #define JSON_HAS_RANGES 0
+    #elif defined(__cpp_lib_ranges)
+        #define JSON_HAS_RANGES 1
+    #else
+        #define JSON_HAS_RANGES 0
+    #endif
+#endif
+
+#ifndef JSON_HAS_STATIC_RTTI
+    #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0
+        #define JSON_HAS_STATIC_RTTI 1
+    #else
+        #define JSON_HAS_STATIC_RTTI 0
+    #endif
+#endif
+
+#ifdef JSON_HAS_CPP_17
+    #define JSON_INLINE_VARIABLE inline
+#else
+    #define JSON_INLINE_VARIABLE
+#endif
+
+#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address)
+    #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#else
+    #define JSON_NO_UNIQUE_ADDRESS
+#endif
+
+// disable documentation warnings on clang
+#if defined(__clang__)
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wdocumentation"
+    #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
+#endif
+
+// allow disabling exceptions
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
+    #define JSON_THROW(exception) throw exception
+    #define JSON_TRY try
+    #define JSON_CATCH(exception) catch(exception)
+    #define JSON_INTERNAL_CATCH(exception) catch(exception)
+#else
+    #include <cstdlib>
+    #define JSON_THROW(exception) std::abort()
+    #define JSON_TRY if(true)
+    #define JSON_CATCH(exception) if(false)
+    #define JSON_INTERNAL_CATCH(exception) if(false)
+#endif
+
+// override exception macros
+#if defined(JSON_THROW_USER)
+    #undef JSON_THROW
+    #define JSON_THROW JSON_THROW_USER
+#endif
+#if defined(JSON_TRY_USER)
+    #undef JSON_TRY
+    #define JSON_TRY JSON_TRY_USER
+#endif
+#if defined(JSON_CATCH_USER)
+    #undef JSON_CATCH
+    #define JSON_CATCH JSON_CATCH_USER
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
+#endif
+#if defined(JSON_INTERNAL_CATCH_USER)
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
+#endif
+
+// allow overriding assert
+#if !defined(JSON_ASSERT)
+    #include <cassert> // assert
+    #define JSON_ASSERT(x) assert(x)
+#endif
+
+// allow to access some private functions (needed by the test suite)
+#if defined(JSON_TESTS_PRIVATE)
+    #define JSON_PRIVATE_UNLESS_TESTED public
+#else
+    #define JSON_PRIVATE_UNLESS_TESTED private
+#endif
+
+/*!
+@brief macro to briefly define a mapping between an enum and JSON
+@def NLOHMANN_JSON_SERIALIZE_ENUM
+@since version 3.4.0
+*/
+#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
+    template<typename BasicJsonType>                                                            \
+    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
+        {                                                                                       \
+            return ej_pair.first == e;                                                          \
+        });                                                                                     \
+        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
+    }                                                                                           \
+    template<typename BasicJsonType>                                                            \
+    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+        {                                                                                       \
+            return ej_pair.second == j;                                                         \
+        });                                                                                     \
+        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
+    }
+
+// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
+// may be removed in the future once the class is split.
+
+#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
+    template<template<typename, typename, typename...> class ObjectType,   \
+             template<typename, typename...> class ArrayType,              \
+             class StringType, class BooleanType, class NumberIntegerType, \
+             class NumberUnsignedType, class NumberFloatType,              \
+             template<typename> class AllocatorType,                       \
+             template<typename, typename = void> class JSONSerializer,     \
+             class BinaryType,                                             \
+             class CustomBaseClass>
+
+#define NLOHMANN_BASIC_JSON_TPL                                            \
+    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
+    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
+    AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>
+
+// Macros to simplify conversion from/to types
+
+#define NLOHMANN_JSON_EXPAND( x ) x
+#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
+#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
+        NLOHMANN_JSON_PASTE64, \
+        NLOHMANN_JSON_PASTE63, \
+        NLOHMANN_JSON_PASTE62, \
+        NLOHMANN_JSON_PASTE61, \
+        NLOHMANN_JSON_PASTE60, \
+        NLOHMANN_JSON_PASTE59, \
+        NLOHMANN_JSON_PASTE58, \
+        NLOHMANN_JSON_PASTE57, \
+        NLOHMANN_JSON_PASTE56, \
+        NLOHMANN_JSON_PASTE55, \
+        NLOHMANN_JSON_PASTE54, \
+        NLOHMANN_JSON_PASTE53, \
+        NLOHMANN_JSON_PASTE52, \
+        NLOHMANN_JSON_PASTE51, \
+        NLOHMANN_JSON_PASTE50, \
+        NLOHMANN_JSON_PASTE49, \
+        NLOHMANN_JSON_PASTE48, \
+        NLOHMANN_JSON_PASTE47, \
+        NLOHMANN_JSON_PASTE46, \
+        NLOHMANN_JSON_PASTE45, \
+        NLOHMANN_JSON_PASTE44, \
+        NLOHMANN_JSON_PASTE43, \
+        NLOHMANN_JSON_PASTE42, \
+        NLOHMANN_JSON_PASTE41, \
+        NLOHMANN_JSON_PASTE40, \
+        NLOHMANN_JSON_PASTE39, \
+        NLOHMANN_JSON_PASTE38, \
+        NLOHMANN_JSON_PASTE37, \
+        NLOHMANN_JSON_PASTE36, \
+        NLOHMANN_JSON_PASTE35, \
+        NLOHMANN_JSON_PASTE34, \
+        NLOHMANN_JSON_PASTE33, \
+        NLOHMANN_JSON_PASTE32, \
+        NLOHMANN_JSON_PASTE31, \
+        NLOHMANN_JSON_PASTE30, \
+        NLOHMANN_JSON_PASTE29, \
+        NLOHMANN_JSON_PASTE28, \
+        NLOHMANN_JSON_PASTE27, \
+        NLOHMANN_JSON_PASTE26, \
+        NLOHMANN_JSON_PASTE25, \
+        NLOHMANN_JSON_PASTE24, \
+        NLOHMANN_JSON_PASTE23, \
+        NLOHMANN_JSON_PASTE22, \
+        NLOHMANN_JSON_PASTE21, \
+        NLOHMANN_JSON_PASTE20, \
+        NLOHMANN_JSON_PASTE19, \
+        NLOHMANN_JSON_PASTE18, \
+        NLOHMANN_JSON_PASTE17, \
+        NLOHMANN_JSON_PASTE16, \
+        NLOHMANN_JSON_PASTE15, \
+        NLOHMANN_JSON_PASTE14, \
+        NLOHMANN_JSON_PASTE13, \
+        NLOHMANN_JSON_PASTE12, \
+        NLOHMANN_JSON_PASTE11, \
+        NLOHMANN_JSON_PASTE10, \
+        NLOHMANN_JSON_PASTE9, \
+        NLOHMANN_JSON_PASTE8, \
+        NLOHMANN_JSON_PASTE7, \
+        NLOHMANN_JSON_PASTE6, \
+        NLOHMANN_JSON_PASTE5, \
+        NLOHMANN_JSON_PASTE4, \
+        NLOHMANN_JSON_PASTE3, \
+        NLOHMANN_JSON_PASTE2, \
+        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
+#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
+#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
+#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
+#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
+#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
+#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
+#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
+#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
+#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
+#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
+#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
+#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
+#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
+#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
+#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
+#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
+#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
+#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
+#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
+#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
+#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
+#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
+#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
+#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
+#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
+#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
+#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
+#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
+#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
+#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
+#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
+#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
+#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
+#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
+#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
+#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
+#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
+#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
+#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
+#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
+#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
+#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
+#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
+#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
+#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
+#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
+#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
+#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
+#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
+#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
+#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
+#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
+#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
+#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
+#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
+#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
+#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
+#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
+#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
+#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
+#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
+
+#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
+#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
+#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1);
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
+@since version 3.9.0
+*/
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
+@since version 3.9.0
+*/
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+// inspired from https://stackoverflow.com/a/26745591
+// allows to call any std function as if (e.g. with begin):
+// using std::begin; begin(x);
+//
+// it allows using the detected idiom to retrieve the return type
+// of such an expression
+#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)                                 \
+    namespace detail {                                                            \
+    using std::std_name;                                                          \
+    \
+    template<typename... T>                                                       \
+    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
+    }                                                                             \
+    \
+    namespace detail2 {                                                           \
+    struct std_name##_tag                                                         \
+    {                                                                             \
+    };                                                                            \
+    \
+    template<typename... T>                                                       \
+    std_name##_tag std_name(T&&...);                                              \
+    \
+    template<typename... T>                                                       \
+    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
+    \
+    template<typename... T>                                                       \
+    struct would_call_std_##std_name                                              \
+    {                                                                             \
+        static constexpr auto const value = ::nlohmann::detail::                  \
+                                            is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
+    };                                                                            \
+    } /* namespace detail2 */ \
+    \
+    template<typename... T>                                                       \
+    struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...>   \
+    {                                                                             \
+    }
+
+#ifndef JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_USE_IMPLICIT_CONVERSIONS 1
+#endif
+
+#if JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_EXPLICIT
+#else
+    #define JSON_EXPLICIT explicit
+#endif
+
+#ifndef JSON_DISABLE_ENUM_SERIALIZATION
+    #define JSON_DISABLE_ENUM_SERIALIZATION 0
+#endif
+
+#ifndef JSON_USE_GLOBAL_UDLS
+    #define JSON_USE_GLOBAL_UDLS 1
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/macro_unscope.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/macro_unscope.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c6620d1e2c100bc5e6041ce97a8d6ec3d240fc44
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/macro_unscope.hpp
@@ -0,0 +1,45 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+// restore clang diagnostic settings
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+// clean up
+#undef JSON_ASSERT
+#undef JSON_INTERNAL_CATCH
+#undef JSON_THROW
+#undef JSON_PRIVATE_UNLESS_TESTED
+#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
+#undef NLOHMANN_BASIC_JSON_TPL
+#undef JSON_EXPLICIT
+#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
+#undef JSON_INLINE_VARIABLE
+#undef JSON_NO_UNIQUE_ADDRESS
+#undef JSON_DISABLE_ENUM_SERIALIZATION
+#undef JSON_USE_GLOBAL_UDLS
+
+#ifndef JSON_TEST_KEEP_MACROS
+    #undef JSON_CATCH
+    #undef JSON_TRY
+    #undef JSON_HAS_CPP_11
+    #undef JSON_HAS_CPP_14
+    #undef JSON_HAS_CPP_17
+    #undef JSON_HAS_CPP_20
+    #undef JSON_HAS_FILESYSTEM
+    #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+    #undef JSON_HAS_THREE_WAY_COMPARISON
+    #undef JSON_HAS_RANGES
+    #undef JSON_HAS_STATIC_RTTI
+    #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+#endif
+
+#include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/call_std/begin.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/call_std/begin.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..364cc89d8793149b3330b18c436b9623eca7a019
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/call_std/begin.hpp
@@ -0,0 +1,17 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <nlohmann/detail/macro_scope.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);
+
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/call_std/end.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/call_std/end.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..463f07061b1d2471e3106d44c70d0561b134ee3b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/call_std/end.hpp
@@ -0,0 +1,17 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <nlohmann/detail/macro_scope.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);
+
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/cpp_future.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/cpp_future.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..412b5aa74b4bf50b7268dde9b4c72dc723c60615
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/cpp_future.hpp
@@ -0,0 +1,171 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-FileCopyrightText: 2018 The Abseil Authors
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
+#include <utility> // index_sequence, make_index_sequence, index_sequence_for
+
+#include <nlohmann/detail/macro_scope.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename T>
+using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+#ifdef JSON_HAS_CPP_14
+
+// the following utilities are natively available in C++14
+using std::enable_if_t;
+using std::index_sequence;
+using std::make_index_sequence;
+using std::index_sequence_for;
+
+#else
+
+// alias templates to reduce boilerplate
+template<bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
+// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.
+
+//// START OF CODE FROM GOOGLE ABSEIL
+
+// integer_sequence
+//
+// Class template representing a compile-time integer sequence. An instantiation
+// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
+// type through its template arguments (which is a common need when
+// working with C++11 variadic templates). `absl::integer_sequence` is designed
+// to be a drop-in replacement for C++14's `std::integer_sequence`.
+//
+// Example:
+//
+//   template< class T, T... Ints >
+//   void user_function(integer_sequence<T, Ints...>);
+//
+//   int main()
+//   {
+//     // user_function's `T` will be deduced to `int` and `Ints...`
+//     // will be deduced to `0, 1, 2, 3, 4`.
+//     user_function(make_integer_sequence<int, 5>());
+//   }
+template <typename T, T... Ints>
+struct integer_sequence
+{
+    using value_type = T;
+    static constexpr std::size_t size() noexcept
+    {
+        return sizeof...(Ints);
+    }
+};
+
+// index_sequence
+//
+// A helper template for an `integer_sequence` of `size_t`,
+// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
+// `std::index_sequence`.
+template <size_t... Ints>
+using index_sequence = integer_sequence<size_t, Ints...>;
+
+namespace utility_internal
+{
+
+template <typename Seq, size_t SeqSize, size_t Rem>
+struct Extend;
+
+// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
+{
+    using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
+};
+
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
+{
+    using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
+};
+
+// Recursion helper for 'make_integer_sequence<T, N>'.
+// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
+template <typename T, size_t N>
+struct Gen
+{
+    using type =
+        typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
+};
+
+template <typename T>
+struct Gen<T, 0>
+{
+    using type = integer_sequence<T>;
+};
+
+}  // namespace utility_internal
+
+// Compile-time sequences of integers
+
+// make_integer_sequence
+//
+// This template alias is equivalent to
+// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
+// replacement for C++14's `std::make_integer_sequence`.
+template <typename T, T N>
+using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
+
+// make_index_sequence
+//
+// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
+// and is designed to be a drop-in replacement for C++14's
+// `std::make_index_sequence`.
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
+
+// index_sequence_for
+//
+// Converts a typename pack into an index sequence of the same length, and
+// is designed to be a drop-in replacement for C++14's
+// `std::index_sequence_for()`
+template <typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+//// END OF CODE FROM GOOGLE ABSEIL
+
+#endif
+
+// dispatch utility (taken from ranges-v3)
+template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
+template<> struct priority_tag<0> {};
+
+// taken from ranges-v3
+template<typename T>
+struct static_const
+{
+    static JSON_INLINE_VARIABLE constexpr T value{};
+};
+
+#ifndef JSON_HAS_CPP_17
+    template<typename T>
+    constexpr T static_const<T>::value;
+#endif
+
+template<typename T, typename... Args>
+inline constexpr std::array<T, sizeof...(Args)> make_array(Args&& ... args)
+{
+    return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}};
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/detected.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/detected.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..1db9bf9ca322b156aebc957dd24a577e7ede29ca
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/detected.hpp
@@ -0,0 +1,70 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <type_traits>
+
+#include <nlohmann/detail/meta/void_t.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// https://en.cppreference.com/w/cpp/experimental/is_detected
+struct nonesuch
+{
+    nonesuch() = delete;
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const&) = delete;
+    nonesuch(nonesuch const&&) = delete;
+    void operator=(nonesuch const&) = delete;
+    void operator=(nonesuch&&) = delete;
+};
+
+template<class Default,
+         class AlwaysVoid,
+         template<class...> class Op,
+         class... Args>
+struct detector
+{
+    using value_t = std::false_type;
+    using type = Default;
+};
+
+template<class Default, template<class...> class Op, class... Args>
+struct detector<Default, void_t<Op<Args...>>, Op, Args...>
+{
+    using value_t = std::true_type;
+    using type = Op<Args...>;
+};
+
+template<template<class...> class Op, class... Args>
+using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
+
+template<template<class...> class Op, class... Args>
+struct is_detected_lazy : is_detected<Op, Args...> { };
+
+template<template<class...> class Op, class... Args>
+using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or = detector<Default, void, Op, Args...>;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+template<class Expected, template<class...> class Op, class... Args>
+using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
+
+template<class To, template<class...> class Op, class... Args>
+using is_detected_convertible =
+    std::is_convertible<detected_t<Op, Args...>, To>;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/identity_tag.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/identity_tag.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..269deffb26f34aa407a98288ef8e6d6dfccc4ee6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/identity_tag.hpp
@@ -0,0 +1,21 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <nlohmann/detail/abi_macros.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// dispatching helper struct
+template <class T> struct identity_tag {};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/is_sax.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/is_sax.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..4e02bc1480eea61e4664cc73d2623c9bce593ecc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/is_sax.hpp
@@ -0,0 +1,159 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstdint> // size_t
+#include <utility> // declval
+#include <string> // string
+
+#include <nlohmann/detail/abi_macros.hpp>
+#include <nlohmann/detail/meta/detected.hpp>
+#include <nlohmann/detail/meta/type_traits.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename T>
+using null_function_t = decltype(std::declval<T&>().null());
+
+template<typename T>
+using boolean_function_t =
+    decltype(std::declval<T&>().boolean(std::declval<bool>()));
+
+template<typename T, typename Integer>
+using number_integer_function_t =
+    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
+
+template<typename T, typename Unsigned>
+using number_unsigned_function_t =
+    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
+
+template<typename T, typename Float, typename String>
+using number_float_function_t = decltype(std::declval<T&>().number_float(
+                                    std::declval<Float>(), std::declval<const String&>()));
+
+template<typename T, typename String>
+using string_function_t =
+    decltype(std::declval<T&>().string(std::declval<String&>()));
+
+template<typename T, typename Binary>
+using binary_function_t =
+    decltype(std::declval<T&>().binary(std::declval<Binary&>()));
+
+template<typename T>
+using start_object_function_t =
+    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
+
+template<typename T, typename String>
+using key_function_t =
+    decltype(std::declval<T&>().key(std::declval<String&>()));
+
+template<typename T>
+using end_object_function_t = decltype(std::declval<T&>().end_object());
+
+template<typename T>
+using start_array_function_t =
+    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
+
+template<typename T>
+using end_array_function_t = decltype(std::declval<T&>().end_array());
+
+template<typename T, typename Exception>
+using parse_error_function_t = decltype(std::declval<T&>().parse_error(
+        std::declval<std::size_t>(), std::declval<const std::string&>(),
+        std::declval<const Exception&>()));
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static constexpr bool value =
+        is_detected_exact<bool, null_function_t, SAX>::value &&
+        is_detected_exact<bool, boolean_function_t, SAX>::value &&
+        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
+        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
+        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
+        is_detected_exact<bool, start_object_function_t, SAX>::value &&
+        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, end_object_function_t, SAX>::value &&
+        is_detected_exact<bool, start_array_function_t, SAX>::value &&
+        is_detected_exact<bool, end_array_function_t, SAX>::value &&
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
+};
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax_static_asserts
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
+                  "Missing/invalid function: bool null()");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(
+        is_detected_exact<bool, number_integer_function_t, SAX,
+        number_integer_t>::value,
+        "Missing/invalid function: bool number_integer(number_integer_t)");
+    static_assert(
+        is_detected_exact<bool, number_unsigned_function_t, SAX,
+        number_unsigned_t>::value,
+        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
+    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
+                  number_float_t, string_t>::value,
+                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
+    static_assert(
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
+        "Missing/invalid function: bool string(string_t&)");
+    static_assert(
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
+        "Missing/invalid function: bool binary(binary_t&)");
+    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_object(std::size_t)");
+    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
+                  "Missing/invalid function: bool key(string_t&)");
+    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_object()");
+    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_array(std::size_t)");
+    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_array()");
+    static_assert(
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
+        "Missing/invalid function: bool parse_error(std::size_t, const "
+        "std::string&, const exception&)");
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/std_fs.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/std_fs.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..fd180396492c3eef79887a742a9c2336b1046989
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/std_fs.hpp
@@ -0,0 +1,29 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <nlohmann/detail/macro_scope.hpp>
+
+#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
+#include <experimental/filesystem>
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace std_fs = std::experimental::filesystem;
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+#elif JSON_HAS_FILESYSTEM
+#include <filesystem>
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace std_fs = std::filesystem;
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+#endif
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/type_traits.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/type_traits.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e1b000dcc22587c702efd4bffbb1774447174e4e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/type_traits.hpp
@@ -0,0 +1,795 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <limits> // numeric_limits
+#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
+#include <utility> // declval
+#include <tuple> // tuple
+#include <string> // char_traits
+
+#include <nlohmann/detail/iterators/iterator_traits.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/meta/call_std/begin.hpp>
+#include <nlohmann/detail/meta/call_std/end.hpp>
+#include <nlohmann/detail/meta/cpp_future.hpp>
+#include <nlohmann/detail/meta/detected.hpp>
+#include <nlohmann/json_fwd.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+/*!
+@brief detail namespace with internal helper functions
+
+This namespace collects functions that should not be exposed,
+implementations of some @ref basic_json methods, and meta-programming helpers.
+
+@since version 2.1.0
+*/
+namespace detail
+{
+
+/////////////
+// helpers //
+/////////////
+
+// Note to maintainers:
+//
+// Every trait in this file expects a non CV-qualified type.
+// The only exceptions are in the 'aliases for detected' section
+// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
+//
+// In this case, T has to be properly CV-qualified to constraint the function arguments
+// (e.g. to_json(BasicJsonType&, const T&))
+
+template<typename> struct is_basic_json : std::false_type {};
+
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
+
+// used by exceptions create() member functions
+// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t
+// false_type otherwise
+template<typename BasicJsonContext>
+struct is_basic_json_context :
+    std::integral_constant < bool,
+    is_basic_json<typename std::remove_cv<typename std::remove_pointer<BasicJsonContext>::type>::type>::value
+    || std::is_same<BasicJsonContext, std::nullptr_t>::value >
+{};
+
+//////////////////////
+// json_ref helpers //
+//////////////////////
+
+template<typename>
+class json_ref;
+
+template<typename>
+struct is_json_ref : std::false_type {};
+
+template<typename T>
+struct is_json_ref<json_ref<T>> : std::true_type {};
+
+//////////////////////////
+// aliases for detected //
+//////////////////////////
+
+template<typename T>
+using mapped_type_t = typename T::mapped_type;
+
+template<typename T>
+using key_type_t = typename T::key_type;
+
+template<typename T>
+using value_type_t = typename T::value_type;
+
+template<typename T>
+using difference_type_t = typename T::difference_type;
+
+template<typename T>
+using pointer_t = typename T::pointer;
+
+template<typename T>
+using reference_t = typename T::reference;
+
+template<typename T>
+using iterator_category_t = typename T::iterator_category;
+
+template<typename T, typename... Args>
+using to_json_function = decltype(T::to_json(std::declval<Args>()...));
+
+template<typename T, typename... Args>
+using from_json_function = decltype(T::from_json(std::declval<Args>()...));
+
+template<typename T, typename U>
+using get_template_function = decltype(std::declval<T>().template get<U>());
+
+// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
+template<typename BasicJsonType, typename T, typename = void>
+struct has_from_json : std::false_type {};
+
+// trait checking if j.get<T> is valid
+// use this trait instead of std::is_constructible or std::is_convertible,
+// both rely on, or make use of implicit conversions, and thus fail when T
+// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
+template <typename BasicJsonType, typename T>
+struct is_getable
+{
+    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
+};
+
+template<typename BasicJsonType, typename T>
+struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, from_json_function, serializer,
+        const BasicJsonType&, T&>::value;
+};
+
+// This trait checks if JSONSerializer<T>::from_json(json const&) exists
+// this overload is used for non-default-constructible user-defined-types
+template<typename BasicJsonType, typename T, typename = void>
+struct has_non_default_from_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<T, from_json_function, serializer,
+        const BasicJsonType&>::value;
+};
+
+// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
+// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
+template<typename BasicJsonType, typename T, typename = void>
+struct has_to_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
+        T>::value;
+};
+
+template<typename T>
+using detect_key_compare = typename T::key_compare;
+
+template<typename T>
+struct has_key_compare : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {};
+
+// obtains the actual object key comparator
+template<typename BasicJsonType>
+struct actual_object_comparator
+{
+    using object_t = typename BasicJsonType::object_t;
+    using object_comparator_t = typename BasicJsonType::default_object_comparator_t;
+    using type = typename std::conditional < has_key_compare<object_t>::value,
+          typename object_t::key_compare, object_comparator_t>::type;
+};
+
+template<typename BasicJsonType>
+using actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type;
+
+/////////////////
+// char_traits //
+/////////////////
+
+// Primary template of char_traits calls std char_traits
+template<typename T>
+struct char_traits : std::char_traits<T>
+{};
+
+// Explicitly define char traits for unsigned char since it is not standard
+template<>
+struct char_traits<unsigned char> : std::char_traits<char>
+{
+    using char_type = unsigned char;
+    using int_type = uint64_t;
+
+    // Redefine to_int_type function
+    static int_type to_int_type(char_type c) noexcept
+    {
+        return static_cast<int_type>(c);
+    }
+
+    static char_type to_char_type(int_type i) noexcept
+    {
+        return static_cast<char_type>(i);
+    }
+
+    static constexpr int_type eof() noexcept
+    {
+        return static_cast<int_type>(EOF);
+    }
+};
+
+// Explicitly define char traits for signed char since it is not standard
+template<>
+struct char_traits<signed char> : std::char_traits<char>
+{
+    using char_type = signed char;
+    using int_type = uint64_t;
+
+    // Redefine to_int_type function
+    static int_type to_int_type(char_type c) noexcept
+    {
+        return static_cast<int_type>(c);
+    }
+
+    static char_type to_char_type(int_type i) noexcept
+    {
+        return static_cast<char_type>(i);
+    }
+
+    static constexpr int_type eof() noexcept
+    {
+        return static_cast<int_type>(EOF);
+    }
+};
+
+///////////////////
+// is_ functions //
+///////////////////
+
+// https://en.cppreference.com/w/cpp/types/conjunction
+template<class...> struct conjunction : std::true_type { };
+template<class B> struct conjunction<B> : B { };
+template<class B, class... Bn>
+struct conjunction<B, Bn...>
+: std::conditional<static_cast<bool>(B::value), conjunction<Bn...>, B>::type {};
+
+// https://en.cppreference.com/w/cpp/types/negation
+template<class B> struct negation : std::integral_constant < bool, !B::value > { };
+
+// Reimplementation of is_constructible and is_default_constructible, due to them being broken for
+// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
+// This causes compile errors in e.g. clang 3.5 or gcc 4.9.
+template <typename T>
+struct is_default_constructible : std::is_default_constructible<T> {};
+
+template <typename T1, typename T2>
+struct is_default_constructible<std::pair<T1, T2>>
+            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+
+template <typename T1, typename T2>
+struct is_default_constructible<const std::pair<T1, T2>>
+            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+
+template <typename... Ts>
+struct is_default_constructible<std::tuple<Ts...>>
+            : conjunction<is_default_constructible<Ts>...> {};
+
+template <typename... Ts>
+struct is_default_constructible<const std::tuple<Ts...>>
+            : conjunction<is_default_constructible<Ts>...> {};
+
+template <typename T, typename... Args>
+struct is_constructible : std::is_constructible<T, Args...> {};
+
+template <typename T1, typename T2>
+struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
+
+template <typename T1, typename T2>
+struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
+
+template <typename... Ts>
+struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
+
+template <typename... Ts>
+struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
+
+template<typename T, typename = void>
+struct is_iterator_traits : std::false_type {};
+
+template<typename T>
+struct is_iterator_traits<iterator_traits<T>>
+{
+  private:
+    using traits = iterator_traits<T>;
+
+  public:
+    static constexpr auto value =
+        is_detected<value_type_t, traits>::value &&
+        is_detected<difference_type_t, traits>::value &&
+        is_detected<pointer_t, traits>::value &&
+        is_detected<iterator_category_t, traits>::value &&
+        is_detected<reference_t, traits>::value;
+};
+
+template<typename T>
+struct is_range
+{
+  private:
+    using t_ref = typename std::add_lvalue_reference<T>::type;
+
+    using iterator = detected_t<result_of_begin, t_ref>;
+    using sentinel = detected_t<result_of_end, t_ref>;
+
+    // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator
+    // and https://en.cppreference.com/w/cpp/iterator/sentinel_for
+    // but reimplementing these would be too much work, as a lot of other concepts are used underneath
+    static constexpr auto is_iterator_begin =
+        is_iterator_traits<iterator_traits<iterator>>::value;
+
+  public:
+    static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
+};
+
+template<typename R>
+using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
+
+template<typename T>
+using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
+
+// The following implementation of is_complete_type is taken from
+// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
+// and is written by Xiang Fan who agreed to using it in this library.
+
+template<typename T, typename = void>
+struct is_complete_type : std::false_type {};
+
+template<typename T>
+struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType,
+         typename = void>
+struct is_compatible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type_impl <
+    BasicJsonType, CompatibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
+    is_detected<key_type_t, CompatibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    // macOS's is_constructible does not play well with nonesuch...
+    static constexpr bool value =
+        is_constructible<typename object_t::key_type,
+        typename CompatibleObjectType::key_type>::value &&
+        is_constructible<typename object_t::mapped_type,
+        typename CompatibleObjectType::mapped_type>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type
+    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         typename = void>
+struct is_constructible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type_impl <
+    BasicJsonType, ConstructibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
+    is_detected<key_type_t, ConstructibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    static constexpr bool value =
+        (is_default_constructible<ConstructibleObjectType>::value &&
+         (std::is_move_assignable<ConstructibleObjectType>::value ||
+          std::is_copy_assignable<ConstructibleObjectType>::value) &&
+         (is_constructible<typename ConstructibleObjectType::key_type,
+          typename object_t::key_type>::value &&
+          std::is_same <
+          typename object_t::mapped_type,
+          typename ConstructibleObjectType::mapped_type >::value)) ||
+        (has_from_json<BasicJsonType,
+         typename ConstructibleObjectType::mapped_type>::value ||
+         has_non_default_from_json <
+         BasicJsonType,
+         typename ConstructibleObjectType::mapped_type >::value);
+};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type
+    : is_constructible_object_type_impl<BasicJsonType,
+      ConstructibleObjectType> {};
+
+template<typename BasicJsonType, typename CompatibleStringType>
+struct is_compatible_string_type
+{
+    static constexpr auto value =
+        is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type
+{
+    // launder type through decltype() to fix compilation failure on ICPC
+#ifdef __INTEL_COMPILER
+    using laundered_type = decltype(std::declval<ConstructibleStringType>());
+#else
+    using laundered_type = ConstructibleStringType;
+#endif
+
+    static constexpr auto value =
+        conjunction <
+        is_constructible<laundered_type, typename BasicJsonType::string_t>,
+        is_detected_exact<typename BasicJsonType::string_t::value_type,
+        value_type_t, laundered_type >>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
+struct is_compatible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type_impl <
+    BasicJsonType, CompatibleArrayType,
+    enable_if_t <
+    is_detected<iterator_t, CompatibleArrayType>::value&&
+    is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&
+// special case for types like std::filesystem::path whose iterator's value_type are themselves
+// c.f. https://github.com/nlohmann/json/pull/3073
+    !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
+{
+    static constexpr bool value =
+        is_constructible<BasicJsonType,
+        range_value_t<CompatibleArrayType>>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type
+    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
+struct is_constructible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t<std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value >>
+            : std::true_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t < !std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value&&
+    !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+    is_default_constructible<ConstructibleArrayType>::value&&
+(std::is_move_assignable<ConstructibleArrayType>::value ||
+ std::is_copy_assignable<ConstructibleArrayType>::value)&&
+is_detected<iterator_t, ConstructibleArrayType>::value&&
+is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
+is_detected<range_value_t, ConstructibleArrayType>::value&&
+// special case for types like std::filesystem::path whose iterator's value_type are themselves
+// c.f. https://github.com/nlohmann/json/pull/3073
+!std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
+        is_complete_type <
+        detected_t<range_value_t, ConstructibleArrayType >>::value >>
+{
+    using value_type = range_value_t<ConstructibleArrayType>;
+
+    static constexpr bool value =
+        std::is_same<value_type,
+        typename BasicJsonType::array_t::value_type>::value ||
+        has_from_json<BasicJsonType,
+        value_type>::value ||
+        has_non_default_from_json <
+        BasicJsonType,
+        value_type >::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type
+    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType,
+         typename = void>
+struct is_compatible_integer_type_impl : std::false_type {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type_impl <
+    RealIntegerType, CompatibleNumberIntegerType,
+    enable_if_t < std::is_integral<RealIntegerType>::value&&
+    std::is_integral<CompatibleNumberIntegerType>::value&&
+    !std::is_same<bool, CompatibleNumberIntegerType>::value >>
+{
+    // is there an assert somewhere on overflows?
+    using RealLimits = std::numeric_limits<RealIntegerType>;
+    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
+
+    static constexpr auto value =
+        is_constructible<RealIntegerType,
+        CompatibleNumberIntegerType>::value &&
+        CompatibleLimits::is_integer &&
+        RealLimits::is_signed == CompatibleLimits::is_signed;
+};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type
+    : is_compatible_integer_type_impl<RealIntegerType,
+      CompatibleNumberIntegerType> {};
+
+template<typename BasicJsonType, typename CompatibleType, typename = void>
+struct is_compatible_type_impl: std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type_impl <
+    BasicJsonType, CompatibleType,
+    enable_if_t<is_complete_type<CompatibleType>::value >>
+{
+    static constexpr bool value =
+        has_to_json<BasicJsonType, CompatibleType>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type
+    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
+
+template<typename T1, typename T2>
+struct is_constructible_tuple : std::false_type {};
+
+template<typename T1, typename... Args>
+struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
+
+template<typename BasicJsonType, typename T>
+struct is_json_iterator_of : std::false_type {};
+
+template<typename BasicJsonType>
+struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::iterator> : std::true_type {};
+
+template<typename BasicJsonType>
+struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::const_iterator> : std::true_type
+{};
+
+// checks if a given type T is a template specialization of Primary
+template<template <typename...> class Primary, typename T>
+struct is_specialization_of : std::false_type {};
+
+template<template <typename...> class Primary, typename... Args>
+struct is_specialization_of<Primary, Primary<Args...>> : std::true_type {};
+
+template<typename T>
+using is_json_pointer = is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>;
+
+// checks if A and B are comparable using Compare functor
+template<typename Compare, typename A, typename B, typename = void>
+struct is_comparable : std::false_type {};
+
+template<typename Compare, typename A, typename B>
+struct is_comparable<Compare, A, B, void_t<
+decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>())),
+decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>()))
+>> : std::true_type {};
+
+template<typename T>
+using detect_is_transparent = typename T::is_transparent;
+
+// type trait to check if KeyType can be used as object key (without a BasicJsonType)
+// see is_usable_as_basic_json_key_type below
+template<typename Comparator, typename ObjectKeyType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
+         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
+using is_usable_as_key_type = typename std::conditional <
+                              is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value
+                              && !(ExcludeObjectKeyType && std::is_same<KeyType,
+                                   ObjectKeyType>::value)
+                              && (!RequireTransparentComparator
+                                  || is_detected <detect_is_transparent, Comparator>::value)
+                              && !is_json_pointer<KeyType>::value,
+                              std::true_type,
+                              std::false_type >::type;
+
+// type trait to check if KeyType can be used as object key
+// true if:
+//   - KeyType is comparable with BasicJsonType::object_t::key_type
+//   - if ExcludeObjectKeyType is true, KeyType is not BasicJsonType::object_t::key_type
+//   - the comparator is transparent or RequireTransparentComparator is false
+//   - KeyType is not a JSON iterator or json_pointer
+template<typename BasicJsonType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
+         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
+using is_usable_as_basic_json_key_type = typename std::conditional <
+        is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
+        typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
+        RequireTransparentComparator, ExcludeObjectKeyType>::value
+        && !is_json_iterator_of<BasicJsonType, KeyType>::value,
+        std::true_type,
+        std::false_type >::type;
+
+template<typename ObjectType, typename KeyType>
+using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()));
+
+// type trait to check if object_t has an erase() member functions accepting KeyType
+template<typename BasicJsonType, typename KeyType>
+using has_erase_with_key_type = typename std::conditional <
+                                is_detected <
+                                detect_erase_with_key_type,
+                                typename BasicJsonType::object_t, KeyType >::value,
+                                std::true_type,
+                                std::false_type >::type;
+
+// a naive helper to check if a type is an ordered_map (exploits the fact that
+// ordered_map inherits capacity() from std::vector)
+template <typename T>
+struct is_ordered_map
+{
+    using one = char;
+
+    struct two
+    {
+        char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+    };
+
+    template <typename C> static one test( decltype(&C::capacity) ) ;
+    template <typename C> static two test(...);
+
+    enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+};
+
+// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
+template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
+T conditional_static_cast(U value)
+{
+    return static_cast<T>(value);
+}
+
+template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
+T conditional_static_cast(U value)
+{
+    return value;
+}
+
+template<typename... Types>
+using all_integral = conjunction<std::is_integral<Types>...>;
+
+template<typename... Types>
+using all_signed = conjunction<std::is_signed<Types>...>;
+
+template<typename... Types>
+using all_unsigned = conjunction<std::is_unsigned<Types>...>;
+
+// there's a disjunction trait in another PR; replace when merged
+template<typename... Types>
+using same_sign = std::integral_constant < bool,
+      all_signed<Types...>::value || all_unsigned<Types...>::value >;
+
+template<typename OfType, typename T>
+using never_out_of_range = std::integral_constant < bool,
+      (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType)))
+      || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) >;
+
+template<typename OfType, typename T,
+         bool OfTypeSigned = std::is_signed<OfType>::value,
+         bool TSigned = std::is_signed<T>::value>
+struct value_in_range_of_impl2;
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, false, false>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, true, false>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, false, true>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return val >= 0 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, true, true>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) >= static_cast<CommonType>((std::numeric_limits<OfType>::min)())
+               && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T,
+         bool NeverOutOfRange = never_out_of_range<OfType, T>::value,
+         typename = detail::enable_if_t<all_integral<OfType, T>::value>>
+struct value_in_range_of_impl1;
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl1<OfType, T, false>
+{
+    static constexpr bool test(T val)
+    {
+        return value_in_range_of_impl2<OfType, T>::test(val);
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl1<OfType, T, true>
+{
+    static constexpr bool test(T /*val*/)
+    {
+        return true;
+    }
+};
+
+template<typename OfType, typename T>
+inline constexpr bool value_in_range_of(T val)
+{
+    return value_in_range_of_impl1<OfType, T>::test(val);
+}
+
+template<bool Value>
+using bool_constant = std::integral_constant<bool, Value>;
+
+///////////////////////////////////////////////////////////////////////////////
+// is_c_string
+///////////////////////////////////////////////////////////////////////////////
+
+namespace impl
+{
+
+template<typename T>
+inline constexpr bool is_c_string()
+{
+    using TUnExt = typename std::remove_extent<T>::type;
+    using TUnCVExt = typename std::remove_cv<TUnExt>::type;
+    using TUnPtr = typename std::remove_pointer<T>::type;
+    using TUnCVPtr = typename std::remove_cv<TUnPtr>::type;
+    return
+        (std::is_array<T>::value && std::is_same<TUnCVExt, char>::value)
+        || (std::is_pointer<T>::value && std::is_same<TUnCVPtr, char>::value);
+}
+
+}  // namespace impl
+
+// checks whether T is a [cv] char */[cv] char[] C string
+template<typename T>
+struct is_c_string : bool_constant<impl::is_c_string<T>()> {};
+
+template<typename T>
+using is_c_string_uncvref = is_c_string<uncvref_t<T>>;
+
+///////////////////////////////////////////////////////////////////////////////
+// is_transparent
+///////////////////////////////////////////////////////////////////////////////
+
+namespace impl
+{
+
+template<typename T>
+inline constexpr bool is_transparent()
+{
+    return is_detected<detect_is_transparent, T>::value;
+}
+
+}  // namespace impl
+
+// checks whether T has a member named is_transparent
+template<typename T>
+struct is_transparent : bool_constant<impl::is_transparent<T>()> {};
+
+///////////////////////////////////////////////////////////////////////////////
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/void_t.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/void_t.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..99615c7c5aba3d75daff97025ad7c1c0d6333b8b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/meta/void_t.hpp
@@ -0,0 +1,24 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <nlohmann/detail/abi_macros.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename ...Ts> struct make_void
+{
+    using type = void;
+};
+template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/output/binary_writer.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/output/binary_writer.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f475d57be800f9747f0ce91d61c57ad496930ae0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/output/binary_writer.hpp
@@ -0,0 +1,1838 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <algorithm> // reverse
+#include <array> // array
+#include <map> // map
+#include <cmath> // isnan, isinf
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstring> // memcpy
+#include <limits> // numeric_limits
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+#include <nlohmann/detail/input/binary_reader.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/output/output_adapters.hpp>
+#include <nlohmann/detail/string_concat.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////////////
+// binary writer //
+///////////////////
+
+/*!
+@brief serialization to CBOR and MessagePack values
+*/
+template<typename BasicJsonType, typename CharType>
+class binary_writer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+  public:
+    /*!
+    @brief create a binary writer
+
+    @param[in] adapter  output adapter to write to
+    */
+    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
+    {
+        JSON_ASSERT(oa);
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+            {
+                write_bson_object(*j.m_data.m_value.object);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::array:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                JSON_THROW(type_error::create(317, concat("to serialize to BSON, top-level type must be object, but is ", j.type_name()), &j));
+            }
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_cbor(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                oa->write_character(to_char_type(0xF6));
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                oa->write_character(j.m_data.m_value.boolean
+                                    ? to_char_type(0xF5)
+                                    : to_char_type(0xF4));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers. Therefore, we used the
+                    // code from the value_t::number_unsigned case here.
+                    if (j.m_data.m_value.number_integer <= 0x17)
+                    {
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x18));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x19));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x1A));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x1B));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    // The conversions below encode the sign in the first
+                    // byte, and the value is converted to a positive number.
+                    const auto positive_number = -1 - j.m_data.m_value.number_integer;
+                    if (j.m_data.m_value.number_integer >= -24)
+                    {
+                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x38));
+                        write_number(static_cast<std::uint8_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x39));
+                        write_number(static_cast<std::uint16_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x3A));
+                        write_number(static_cast<std::uint32_t>(positive_number));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x3B));
+                        write_number(static_cast<std::uint64_t>(positive_number));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x18));
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x19));
+                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x1A));
+                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_unsigned));
+                }
+                else
+                {
+                    oa->write_character(to_char_type(0x1B));
+                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                if (std::isnan(j.m_data.m_value.number_float))
+                {
+                    // NaN is 0xf97e00 in CBOR
+                    oa->write_character(to_char_type(0xF9));
+                    oa->write_character(to_char_type(0x7E));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else if (std::isinf(j.m_data.m_value.number_float))
+                {
+                    // Infinity is 0xf97c00, -Infinity is 0xf9fc00
+                    oa->write_character(to_char_type(0xf9));
+                    oa->write_character(j.m_data.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else
+                {
+                    write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::cbor);
+                }
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_data.m_value.string->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x60 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x78));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x79));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_data.m_value.array->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x80 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x98));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x99));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_cbor(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (j.m_data.m_value.binary->has_subtype())
+                {
+                    if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xd8));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xd9));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xda));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xdb));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                }
+
+                // step 1: write control byte and the binary array size
+                const auto N = j.m_data.m_value.binary->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x40 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x58));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x59));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_data.m_value.object->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0xA0 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB8));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB9));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBA));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBB));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_cbor(el.first);
+                    write_cbor(el.second);
+                }
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_msgpack(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null: // nil
+            {
+                oa->write_character(to_char_type(0xC0));
+                break;
+            }
+
+            case value_t::boolean: // true and false
+            {
+                oa->write_character(j.m_data.m_value.boolean
+                                    ? to_char_type(0xC3)
+                                    : to_char_type(0xC2));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers. Therefore, we used
+                    // the code from the value_t::number_unsigned case here.
+                    if (j.m_data.m_value.number_unsigned < 128)
+                    {
+                        // positive fixnum
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        // uint 8
+                        oa->write_character(to_char_type(0xCC));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        // uint 16
+                        oa->write_character(to_char_type(0xCD));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        // uint 32
+                        oa->write_character(to_char_type(0xCE));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        // uint 64
+                        oa->write_character(to_char_type(0xCF));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    if (j.m_data.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                    {
+                        // int 8
+                        oa->write_character(to_char_type(0xD0));
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                    {
+                        // int 16
+                        oa->write_character(to_char_type(0xD1));
+                        write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                    {
+                        // int 32
+                        oa->write_character(to_char_type(0xD2));
+                        write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                    {
+                        // int 64
+                        oa->write_character(to_char_type(0xD3));
+                        write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned < 128)
+                {
+                    // positive fixnum
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // uint 8
+                    oa->write_character(to_char_type(0xCC));
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // uint 16
+                    oa->write_character(to_char_type(0xCD));
+                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // uint 32
+                    oa->write_character(to_char_type(0xCE));
+                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    // uint 64
+                    oa->write_character(to_char_type(0xCF));
+                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::msgpack);
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_data.m_value.string->size();
+                if (N <= 31)
+                {
+                    // fixstr
+                    write_number(static_cast<std::uint8_t>(0xA0 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // str 8
+                    oa->write_character(to_char_type(0xD9));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // str 16
+                    oa->write_character(to_char_type(0xDA));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // str 32
+                    oa->write_character(to_char_type(0xDB));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_data.m_value.array->size();
+                if (N <= 15)
+                {
+                    // fixarray
+                    write_number(static_cast<std::uint8_t>(0x90 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // array 16
+                    oa->write_character(to_char_type(0xDC));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // array 32
+                    oa->write_character(to_char_type(0xDD));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_msgpack(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                // step 0: determine if the binary type has a set subtype to
+                // determine whether or not to use the ext or fixext types
+                const bool use_ext = j.m_data.m_value.binary->has_subtype();
+
+                // step 1: write control byte and the byte string length
+                const auto N = j.m_data.m_value.binary->size();
+                if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    std::uint8_t output_type{};
+                    bool fixed = true;
+                    if (use_ext)
+                    {
+                        switch (N)
+                        {
+                            case 1:
+                                output_type = 0xD4; // fixext 1
+                                break;
+                            case 2:
+                                output_type = 0xD5; // fixext 2
+                                break;
+                            case 4:
+                                output_type = 0xD6; // fixext 4
+                                break;
+                            case 8:
+                                output_type = 0xD7; // fixext 8
+                                break;
+                            case 16:
+                                output_type = 0xD8; // fixext 16
+                                break;
+                            default:
+                                output_type = 0xC7; // ext 8
+                                fixed = false;
+                                break;
+                        }
+
+                    }
+                    else
+                    {
+                        output_type = 0xC4; // bin 8
+                        fixed = false;
+                    }
+
+                    oa->write_character(to_char_type(output_type));
+                    if (!fixed)
+                    {
+                        write_number(static_cast<std::uint8_t>(N));
+                    }
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    const std::uint8_t output_type = use_ext
+                                                     ? 0xC8 // ext 16
+                                                     : 0xC5; // bin 16
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    const std::uint8_t output_type = use_ext
+                                                     ? 0xC9 // ext 32
+                                                     : 0xC6; // bin 32
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 1.5: if this is an ext type, write the subtype
+                if (use_ext)
+                {
+                    write_number(static_cast<std::int8_t>(j.m_data.m_value.binary->subtype()));
+                }
+
+                // step 2: write the byte string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_data.m_value.object->size();
+                if (N <= 15)
+                {
+                    // fixmap
+                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // map 16
+                    oa->write_character(to_char_type(0xDE));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // map 32
+                    oa->write_character(to_char_type(0xDF));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_msgpack(el.first);
+                    write_msgpack(el.second);
+                }
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @param[in] use_count   whether to use '#' prefixes (optimized format)
+    @param[in] use_type    whether to use '$' prefixes (optimized format)
+    @param[in] add_prefix  whether prefixes need to be used for this value
+    @param[in] use_bjdata  whether write in BJData format, default is false
+    */
+    void write_ubjson(const BasicJsonType& j, const bool use_count,
+                      const bool use_type, const bool add_prefix = true,
+                      const bool use_bjdata = false)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('Z'));
+                }
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(j.m_data.m_value.boolean
+                                        ? to_char_type('T')
+                                        : to_char_type('F'));
+                }
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_integer, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_unsigned, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_float, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::string:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('S'));
+                }
+                write_number_with_ubjson_prefix(j.m_data.m_value.string->size(), true, use_bjdata);
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_data.m_value.array->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
+                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
+                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v, use_bjdata) == first_prefix;
+                    });
+
+                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
+
+                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.array->size(), true, use_bjdata);
+                }
+
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_ubjson(el, use_count, use_type, prefix_required, use_bjdata);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                if (use_type && !j.m_data.m_value.binary->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    oa->write_character(to_char_type('$'));
+                    oa->write_character('U');
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.binary->size(), true, use_bjdata);
+                }
+
+                if (use_type)
+                {
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                        j.m_data.m_value.binary->size());
+                }
+                else
+                {
+                    for (size_t i = 0; i < j.m_data.m_value.binary->size(); ++i)
+                    {
+                        oa->write_character(to_char_type('U'));
+                        oa->write_character(j.m_data.m_value.binary->data()[i]);
+                    }
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                if (use_bjdata && j.m_data.m_value.object->size() == 3 && j.m_data.m_value.object->find("_ArrayType_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArraySize_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArrayData_") != j.m_data.m_value.object->end())
+                {
+                    if (!write_bjdata_ndarray(*j.m_data.m_value.object, use_count, use_type))  // decode bjdata ndarray in the JData format (https://github.com/NeuroJSON/jdata)
+                    {
+                        break;
+                    }
+                }
+
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('{'));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_data.m_value.object->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
+                    const bool same_prefix = std::all_of(j.begin(), j.end(),
+                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v, use_bjdata) == first_prefix;
+                    });
+
+                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
+
+                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.object->size(), true, use_bjdata);
+                }
+
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata);
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(el.first.c_str()),
+                        el.first.size());
+                    write_ubjson(el.second, use_count, use_type, prefix_required, use_bjdata);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type('}'));
+                }
+
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @return The size of a BSON document entry header, including the id marker
+            and the entry name size (and its null-terminator).
+    */
+    static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
+    {
+        const auto it = name.find(static_cast<typename string_t::value_type>(0));
+        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
+        {
+            JSON_THROW(out_of_range::create(409, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j));
+            static_cast<void>(j);
+        }
+
+        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
+    }
+
+    /*!
+    @brief Writes the given @a element_type and @a name to the output adapter
+    */
+    void write_bson_entry_header(const string_t& name,
+                                 const std::uint8_t element_type)
+    {
+        oa->write_character(to_char_type(element_type)); // boolean
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(name.c_str()),
+            name.size() + 1u);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and boolean value @a value
+    */
+    void write_bson_boolean(const string_t& name,
+                            const bool value)
+    {
+        write_bson_entry_header(name, 0x08);
+        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and double value @a value
+    */
+    void write_bson_double(const string_t& name,
+                           const double value)
+    {
+        write_bson_entry_header(name, 0x01);
+        write_number<double>(value, true);
+    }
+
+    /*!
+    @return The size of the BSON-encoded string in @a value
+    */
+    static std::size_t calc_bson_string_size(const string_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and string value @a value
+    */
+    void write_bson_string(const string_t& name,
+                           const string_t& value)
+    {
+        write_bson_entry_header(name, 0x02);
+
+        write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul), true);
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(value.c_str()),
+            value.size() + 1);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and null value
+    */
+    void write_bson_null(const string_t& name)
+    {
+        write_bson_entry_header(name, 0x0A);
+    }
+
+    /*!
+    @return The size of the BSON-encoded integer @a value
+    */
+    static std::size_t calc_bson_integer_size(const std::int64_t value)
+    {
+        return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and integer @a value
+    */
+    void write_bson_integer(const string_t& name,
+                            const std::int64_t value)
+    {
+        if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            write_bson_entry_header(name, 0x10); // int32
+            write_number<std::int32_t>(static_cast<std::int32_t>(value), true);
+        }
+        else
+        {
+            write_bson_entry_header(name, 0x12); // int64
+            write_number<std::int64_t>(static_cast<std::int64_t>(value), true);
+        }
+    }
+
+    /*!
+    @return The size of the BSON-encoded unsigned integer in @a j
+    */
+    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
+    {
+        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and unsigned @a value
+    */
+    void write_bson_unsigned(const string_t& name,
+                             const BasicJsonType& j)
+    {
+        if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x10 /* int32 */);
+            write_number<std::int32_t>(static_cast<std::int32_t>(j.m_data.m_value.number_unsigned), true);
+        }
+        else if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x12 /* int64 */);
+            write_number<std::int64_t>(static_cast<std::int64_t>(j.m_data.m_value.number_unsigned), true);
+        }
+        else
+        {
+            JSON_THROW(out_of_range::create(407, concat("integer number ", std::to_string(j.m_data.m_value.number_unsigned), " cannot be represented by BSON as it does not fit int64"), &j));
+        }
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and object @a value
+    */
+    void write_bson_object_entry(const string_t& name,
+                                 const typename BasicJsonType::object_t& value)
+    {
+        write_bson_entry_header(name, 0x03); // object
+        write_bson_object(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded array @a value
+    */
+    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
+    {
+        std::size_t array_index = 0ul;
+
+        const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
+        {
+            return result + calc_bson_element_size(std::to_string(array_index++), el);
+        });
+
+        return sizeof(std::int32_t) + embedded_document_size + 1ul;
+    }
+
+    /*!
+    @return The size of the BSON-encoded binary array @a value
+    */
+    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and array @a value
+    */
+    void write_bson_array(const string_t& name,
+                          const typename BasicJsonType::array_t& value)
+    {
+        write_bson_entry_header(name, 0x04); // array
+        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_array_size(value)), true);
+
+        std::size_t array_index = 0ul;
+
+        for (const auto& el : value)
+        {
+            write_bson_element(std::to_string(array_index++), el);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and binary value @a value
+    */
+    void write_bson_binary(const string_t& name,
+                           const binary_t& value)
+    {
+        write_bson_entry_header(name, 0x05);
+
+        write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true);
+        write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
+
+        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
+    }
+
+    /*!
+    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
+    @return The calculated size for the BSON document entry for @a j with the given @a name.
+    */
+    static std::size_t calc_bson_element_size(const string_t& name,
+            const BasicJsonType& j)
+    {
+        const auto header_size = calc_bson_entry_header_size(name, j);
+        switch (j.type())
+        {
+            case value_t::object:
+                return header_size + calc_bson_object_size(*j.m_data.m_value.object);
+
+            case value_t::array:
+                return header_size + calc_bson_array_size(*j.m_data.m_value.array);
+
+            case value_t::binary:
+                return header_size + calc_bson_binary_size(*j.m_data.m_value.binary);
+
+            case value_t::boolean:
+                return header_size + 1ul;
+
+            case value_t::number_float:
+                return header_size + 8ul;
+
+            case value_t::number_integer:
+                return header_size + calc_bson_integer_size(j.m_data.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return header_size + calc_bson_unsigned_size(j.m_data.m_value.number_unsigned);
+
+            case value_t::string:
+                return header_size + calc_bson_string_size(*j.m_data.m_value.string);
+
+            case value_t::null:
+                return header_size + 0ul;
+
+            // LCOV_EXCL_START
+            case value_t::discarded:
+            default:
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+                return 0ul;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Serializes the JSON value @a j to BSON and associates it with the
+           key @a name.
+    @param name The name to associate with the JSON entity @a j within the
+                current BSON document
+    */
+    void write_bson_element(const string_t& name,
+                            const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+                return write_bson_object_entry(name, *j.m_data.m_value.object);
+
+            case value_t::array:
+                return write_bson_array(name, *j.m_data.m_value.array);
+
+            case value_t::binary:
+                return write_bson_binary(name, *j.m_data.m_value.binary);
+
+            case value_t::boolean:
+                return write_bson_boolean(name, j.m_data.m_value.boolean);
+
+            case value_t::number_float:
+                return write_bson_double(name, j.m_data.m_value.number_float);
+
+            case value_t::number_integer:
+                return write_bson_integer(name, j.m_data.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return write_bson_unsigned(name, j);
+
+            case value_t::string:
+                return write_bson_string(name, *j.m_data.m_value.string);
+
+            case value_t::null:
+                return write_bson_null(name);
+
+            // LCOV_EXCL_START
+            case value_t::discarded:
+            default:
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+                return;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Calculates the size of the BSON serialization of the given
+           JSON-object @a j.
+    @param[in] value  JSON value to serialize
+    @pre       value.type() == value_t::object
+    */
+    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
+    {
+        const std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
+                                          [](size_t result, const typename BasicJsonType::object_t::value_type & el)
+        {
+            return result += calc_bson_element_size(el.first, el.second);
+        });
+
+        return sizeof(std::int32_t) + document_size + 1ul;
+    }
+
+    /*!
+    @param[in] value  JSON value to serialize
+    @pre       value.type() == value_t::object
+    */
+    void write_bson_object(const typename BasicJsonType::object_t& value)
+    {
+        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_object_size(value)), true);
+
+        for (const auto& el : value)
+        {
+            write_bson_element(el.first, el.second);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xFA);  // Single-Precision Float
+    }
+
+    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xFB);  // Double-Precision Float
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xCA);  // float 32
+    }
+
+    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xCB);  // float 64
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    // UBJSON: write number (floating point)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_floating_point<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if (add_prefix)
+        {
+            oa->write_character(get_ubjson_float_prefix(n));
+        }
+        write_number(n, use_bjdata);
+    }
+
+    // UBJSON: write number (unsigned integer)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_unsigned<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if (n <= (std::numeric_limits<std::uint8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
+            }
+            write_number(static_cast<std::uint16_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
+            }
+            write_number(static_cast<std::uint32_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= (std::numeric_limits<uint64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('M'));  // uint64 - bjdata only
+            }
+            write_number(static_cast<std::uint64_t>(n), use_bjdata);
+        }
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+    }
+
+    // UBJSON: write number (signed integer)
+    template < typename NumberType, typename std::enable_if <
+                   std::is_signed<NumberType>::value&&
+                   !std::is_floating_point<NumberType>::value, int >::type = 0 >
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::int8_t>(n), use_bjdata);
+        }
+        else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::max)())))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
+            }
+            write_number(static_cast<uint16_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::max)())))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
+            }
+            write_number(static_cast<uint32_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n), use_bjdata);
+        }
+        // LCOV_EXCL_START
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+        // LCOV_EXCL_STOP
+    }
+
+    /*!
+    @brief determine the type prefix of container values
+    */
+    CharType ubjson_prefix(const BasicJsonType& j, const bool use_bjdata) const noexcept
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+                return 'Z';
+
+            case value_t::boolean:
+                return j.m_data.m_value.boolean ? 'T' : 'F';
+
+            case value_t::number_integer:
+            {
+                if ((std::numeric_limits<std::int8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                {
+                    return 'i';
+                }
+                if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    return 'U';
+                }
+                if ((std::numeric_limits<std::int16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                {
+                    return 'I';
+                }
+                if (use_bjdata && ((std::numeric_limits<std::uint16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)()))
+                {
+                    return 'u';
+                }
+                if ((std::numeric_limits<std::int32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                {
+                    return 'l';
+                }
+                if (use_bjdata && ((std::numeric_limits<std::uint32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)()))
+                {
+                    return 'm';
+                }
+                if ((std::numeric_limits<std::int64_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                {
+                    return 'L';
+                }
+                // anything else is treated as high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+                {
+                    return 'i';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
+                {
+                    return 'U';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+                {
+                    return 'I';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint16_t>::max)()))
+                {
+                    return 'u';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+                {
+                    return 'l';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)()))
+                {
+                    return 'm';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+                {
+                    return 'L';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    return 'M';
+                }
+                // anything else is treated as high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_float:
+                return get_ubjson_float_prefix(j.m_data.m_value.number_float);
+
+            case value_t::string:
+                return 'S';
+
+            case value_t::array: // fallthrough
+            case value_t::binary:
+                return '[';
+
+            case value_t::object:
+                return '{';
+
+            case value_t::discarded:
+            default:  // discarded values
+                return 'N';
+        }
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
+    {
+        return 'd';  // float 32
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
+    {
+        return 'D';  // float 64
+    }
+
+    /*!
+    @return false if the object is successfully converted to a bjdata ndarray, true if the type or size is invalid
+    */
+    bool write_bjdata_ndarray(const typename BasicJsonType::object_t& value, const bool use_count, const bool use_type)
+    {
+        std::map<string_t, CharType> bjdtype = {{"uint8", 'U'},  {"int8", 'i'},  {"uint16", 'u'}, {"int16", 'I'},
+            {"uint32", 'm'}, {"int32", 'l'}, {"uint64", 'M'}, {"int64", 'L'}, {"single", 'd'}, {"double", 'D'}, {"char", 'C'}
+        };
+
+        string_t key = "_ArrayType_";
+        auto it = bjdtype.find(static_cast<string_t>(value.at(key)));
+        if (it == bjdtype.end())
+        {
+            return true;
+        }
+        CharType dtype = it->second;
+
+        key = "_ArraySize_";
+        std::size_t len = (value.at(key).empty() ? 0 : 1);
+        for (const auto& el : value.at(key))
+        {
+            len *= static_cast<std::size_t>(el.m_data.m_value.number_unsigned);
+        }
+
+        key = "_ArrayData_";
+        if (value.at(key).size() != len)
+        {
+            return true;
+        }
+
+        oa->write_character('[');
+        oa->write_character('$');
+        oa->write_character(dtype);
+        oa->write_character('#');
+
+        key = "_ArraySize_";
+        write_ubjson(value.at(key), use_count, use_type, true,  true);
+
+        key = "_ArrayData_";
+        if (dtype == 'U' || dtype == 'C')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint8_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'i')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int8_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'u')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint16_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'I')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int16_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'm')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint32_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'l')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int32_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'M')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint64_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'L')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int64_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'd')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<float>(el.m_data.m_value.number_float), true);
+            }
+        }
+        else if (dtype == 'D')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<double>(el.m_data.m_value.number_float), true);
+            }
+        }
+        return false;
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*
+    @brief write a number to output input
+    @param[in] n number of type @a NumberType
+    @param[in] OutputIsLittleEndian Set to true if output data is
+                                 required to be little endian
+    @tparam NumberType the type of the number
+
+    @note This function needs to respect the system's endianness, because bytes
+          in CBOR, MessagePack, and UBJSON are stored in network order (big
+          endian) and therefore need reordering on little endian systems.
+          On the other hand, BSON and BJData use little endian and should reorder
+          on big endian systems.
+    */
+    template<typename NumberType>
+    void write_number(const NumberType n, const bool OutputIsLittleEndian = false)
+    {
+        // step 1: write number to array of length NumberType
+        std::array<CharType, sizeof(NumberType)> vec{};
+        std::memcpy(vec.data(), &n, sizeof(NumberType));
+
+        // step 2: write array to output (with possible reordering)
+        if (is_little_endian != OutputIsLittleEndian)
+        {
+            // reverse byte order prior to conversion if necessary
+            std::reverse(vec.begin(), vec.end());
+        }
+
+        oa->write_characters(vec.data(), sizeof(NumberType));
+    }
+
+    void write_compact_float(const number_float_t n, detail::input_format_t format)
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
+                static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
+                static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(static_cast<float>(n))
+                                : get_msgpack_float_prefix(static_cast<float>(n)));
+            write_number(static_cast<float>(n));
+        }
+        else
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(n)
+                                : get_msgpack_float_prefix(n));
+            write_number(n);
+        }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+  public:
+    // The following to_char_type functions are implement the conversion
+    // between uint8_t and CharType. In case CharType is not unsigned,
+    // such a conversion is required to allow values greater than 128.
+    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return *reinterpret_cast<char*>(&x);
+    }
+
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
+    static CharType to_char_type(std::uint8_t x) noexcept
+    {
+        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
+        static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
+        CharType result;
+        std::memcpy(&result, &x, sizeof(x));
+        return result;
+    }
+
+    template<typename C = CharType,
+             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return x;
+    }
+
+    template < typename InputCharType, typename C = CharType,
+               enable_if_t <
+                   std::is_signed<C>::value &&
+                   std::is_signed<char>::value &&
+                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
+                   > * = nullptr >
+    static constexpr CharType to_char_type(InputCharType x) noexcept
+    {
+        return x;
+    }
+
+  private:
+    /// whether we can assume little endianness
+    const bool is_little_endian = little_endianness();
+
+    /// the output
+    output_adapter_t<CharType> oa = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/output/output_adapters.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/output/output_adapters.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..626f7c0c85e35ec51a90baa3bdd12cd8df7ba957
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/output/output_adapters.hpp
@@ -0,0 +1,147 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <algorithm> // copy
+#include <cstddef> // size_t
+#include <iterator> // back_inserter
+#include <memory> // shared_ptr, make_shared
+#include <string> // basic_string
+#include <vector> // vector
+
+#ifndef JSON_NO_IO
+    #include <ios>      // streamsize
+    #include <ostream>  // basic_ostream
+#endif  // JSON_NO_IO
+
+#include <nlohmann/detail/macro_scope.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// abstract output adapter interface
+template<typename CharType> struct output_adapter_protocol
+{
+    virtual void write_character(CharType c) = 0;
+    virtual void write_characters(const CharType* s, std::size_t length) = 0;
+    virtual ~output_adapter_protocol() = default;
+
+    output_adapter_protocol() = default;
+    output_adapter_protocol(const output_adapter_protocol&) = default;
+    output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
+    output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
+    output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
+};
+
+/// a type to simplify interfaces
+template<typename CharType>
+using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
+
+/// output adapter for byte vectors
+template<typename CharType, typename AllocatorType = std::allocator<CharType>>
+class output_vector_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
+        : v(vec)
+    {}
+
+    void write_character(CharType c) override
+    {
+        v.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        v.insert(v.end(), s, s + length);
+    }
+
+  private:
+    std::vector<CharType, AllocatorType>& v;
+};
+
+#ifndef JSON_NO_IO
+/// output adapter for output streams
+template<typename CharType>
+class output_stream_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
+        : stream(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        stream.put(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        stream.write(s, static_cast<std::streamsize>(length));
+    }
+
+  private:
+    std::basic_ostream<CharType>& stream;
+};
+#endif  // JSON_NO_IO
+
+/// output adapter for basic_string
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_string_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_string_adapter(StringType& s) noexcept
+        : str(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        str.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        str.append(s, length);
+    }
+
+  private:
+    StringType& str;
+};
+
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_adapter
+{
+  public:
+    template<typename AllocatorType = std::allocator<CharType>>
+    output_adapter(std::vector<CharType, AllocatorType>& vec)
+        : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
+
+#ifndef JSON_NO_IO
+    output_adapter(std::basic_ostream<CharType>& s)
+        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
+#endif  // JSON_NO_IO
+
+    output_adapter(StringType& s)
+        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
+
+    operator output_adapter_t<CharType>()
+    {
+        return oa;
+    }
+
+  private:
+    output_adapter_t<CharType> oa = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/output/serializer.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/output/serializer.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..ed20b0d9e183b940d689d712d9e4b2de0b72017e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/output/serializer.hpp
@@ -0,0 +1,988 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2008-2009 Björn Hoehrmann <bjoern@hoehrmann.de>
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <algorithm> // reverse, remove, fill, find, none_of
+#include <array> // array
+#include <clocale> // localeconv, lconv
+#include <cmath> // labs, isfinite, isnan, signbit
+#include <cstddef> // size_t, ptrdiff_t
+#include <cstdint> // uint8_t
+#include <cstdio> // snprintf
+#include <limits> // numeric_limits
+#include <string> // string, char_traits
+#include <iomanip> // setfill, setw
+#include <type_traits> // is_same
+#include <utility> // move
+
+#include <nlohmann/detail/conversions/to_chars.hpp>
+#include <nlohmann/detail/exceptions.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/meta/cpp_future.hpp>
+#include <nlohmann/detail/output/binary_writer.hpp>
+#include <nlohmann/detail/output/output_adapters.hpp>
+#include <nlohmann/detail/string_concat.hpp>
+#include <nlohmann/detail/value_t.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////////////
+// serialization //
+///////////////////
+
+/// how to treat decoding errors
+enum class error_handler_t
+{
+    strict,  ///< throw a type_error exception in case of invalid UTF-8
+    replace, ///< replace invalid UTF-8 sequences with U+FFFD
+    ignore   ///< ignore invalid UTF-8 sequences
+};
+
+template<typename BasicJsonType>
+class serializer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using binary_char_t = typename BasicJsonType::binary_t::value_type;
+    static constexpr std::uint8_t UTF8_ACCEPT = 0;
+    static constexpr std::uint8_t UTF8_REJECT = 1;
+
+  public:
+    /*!
+    @param[in] s  output stream to serialize to
+    @param[in] ichar  indentation character to use
+    @param[in] error_handler_  how to react on decoding errors
+    */
+    serializer(output_adapter_t<char> s, const char ichar,
+               error_handler_t error_handler_ = error_handler_t::strict)
+        : o(std::move(s))
+        , loc(std::localeconv())
+        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
+        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
+        , indent_char(ichar)
+        , indent_string(512, indent_char)
+        , error_handler(error_handler_)
+    {}
+
+    // delete because of pointer members
+    serializer(const serializer&) = delete;
+    serializer& operator=(const serializer&) = delete;
+    serializer(serializer&&) = delete;
+    serializer& operator=(serializer&&) = delete;
+    ~serializer() = default;
+
+    /*!
+    @brief internal implementation of the serialization function
+
+    This function is called by the public member function dump and organizes
+    the serialization internally. The indentation level is propagated as
+    additional parameter. In case of arrays and objects, the function is
+    called recursively.
+
+    - strings and object keys are escaped using `escape_string()`
+    - integer numbers are converted implicitly via `operator<<`
+    - floating-point numbers are converted to a string using `"%g"` format
+    - binary values are serialized as objects containing the subtype and the
+      byte array
+
+    @param[in] val               value to serialize
+    @param[in] pretty_print      whether the output shall be pretty-printed
+    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
+    in the output are escaped with `\uXXXX` sequences, and the result consists
+    of ASCII characters only.
+    @param[in] indent_step       the indent level
+    @param[in] current_indent    the current indent level (only used internally)
+    */
+    void dump(const BasicJsonType& val,
+              const bool pretty_print,
+              const bool ensure_ascii,
+              const unsigned int indent_step,
+              const unsigned int current_indent = 0)
+    {
+        switch (val.m_data.m_type)
+        {
+            case value_t::object:
+            {
+                if (val.m_data.m_value.object->empty())
+                {
+                    o->write_characters("{}", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    auto i = val.m_data.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\": ", 3);
+                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\": ", 3);
+                    dump(i->second, true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_character('{');
+
+                    // first n-1 elements
+                    auto i = val.m_data.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\":", 2);
+                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\":", 2);
+                    dump(i->second, false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character('}');
+                }
+
+                return;
+            }
+
+            case value_t::array:
+            {
+                if (val.m_data.m_value.array->empty())
+                {
+                    o->write_characters("[]", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("[\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    for (auto i = val.m_data.m_value.array->cbegin();
+                            i != val.m_data.m_value.array->cend() - 1; ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        dump(*i, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_data.m_value.array->empty());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    dump(val.m_data.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character(']');
+                }
+                else
+                {
+                    o->write_character('[');
+
+                    // first n-1 elements
+                    for (auto i = val.m_data.m_value.array->cbegin();
+                            i != val.m_data.m_value.array->cend() - 1; ++i)
+                    {
+                        dump(*i, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_data.m_value.array->empty());
+                    dump(val.m_data.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character(']');
+                }
+
+                return;
+            }
+
+            case value_t::string:
+            {
+                o->write_character('\"');
+                dump_escaped(*val.m_data.m_value.string, ensure_ascii);
+                o->write_character('\"');
+                return;
+            }
+
+            case value_t::binary:
+            {
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"bytes\": [", 10);
+
+                    if (!val.m_data.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_data.m_value.binary->cbegin();
+                                i != val.m_data.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_characters(", ", 2);
+                        }
+                        dump_integer(val.m_data.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\n", 3);
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"subtype\": ", 11);
+                    if (val.m_data.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_data.m_value.binary->subtype());
+                    }
+                    else
+                    {
+                        o->write_characters("null", 4);
+                    }
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_characters("{\"bytes\":[", 10);
+
+                    if (!val.m_data.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_data.m_value.binary->cbegin();
+                                i != val.m_data.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_character(',');
+                        }
+                        dump_integer(val.m_data.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\"subtype\":", 12);
+                    if (val.m_data.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_data.m_value.binary->subtype());
+                        o->write_character('}');
+                    }
+                    else
+                    {
+                        o->write_characters("null}", 5);
+                    }
+                }
+                return;
+            }
+
+            case value_t::boolean:
+            {
+                if (val.m_data.m_value.boolean)
+                {
+                    o->write_characters("true", 4);
+                }
+                else
+                {
+                    o->write_characters("false", 5);
+                }
+                return;
+            }
+
+            case value_t::number_integer:
+            {
+                dump_integer(val.m_data.m_value.number_integer);
+                return;
+            }
+
+            case value_t::number_unsigned:
+            {
+                dump_integer(val.m_data.m_value.number_unsigned);
+                return;
+            }
+
+            case value_t::number_float:
+            {
+                dump_float(val.m_data.m_value.number_float);
+                return;
+            }
+
+            case value_t::discarded:
+            {
+                o->write_characters("<discarded>", 11);
+                return;
+            }
+
+            case value_t::null:
+            {
+                o->write_characters("null", 4);
+                return;
+            }
+
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief dump escaped string
+
+    Escape a string by replacing certain special characters by a sequence of an
+    escape character (backslash) and another character and other control
+    characters by a sequence of "\u" followed by a four-digit hex
+    representation. The escaped string is written to output stream @a o.
+
+    @param[in] s  the string to escape
+    @param[in] ensure_ascii  whether to escape non-ASCII characters with
+                             \uXXXX sequences
+
+    @complexity Linear in the length of string @a s.
+    */
+    void dump_escaped(const string_t& s, const bool ensure_ascii)
+    {
+        std::uint32_t codepoint{};
+        std::uint8_t state = UTF8_ACCEPT;
+        std::size_t bytes = 0;  // number of bytes written to string_buffer
+
+        // number of bytes written at the point of the last valid byte
+        std::size_t bytes_after_last_accept = 0;
+        std::size_t undumped_chars = 0;
+
+        for (std::size_t i = 0; i < s.size(); ++i)
+        {
+            const auto byte = static_cast<std::uint8_t>(s[i]);
+
+            switch (decode(state, codepoint, byte))
+            {
+                case UTF8_ACCEPT:  // decode found a new code point
+                {
+                    switch (codepoint)
+                    {
+                        case 0x08: // backspace
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'b';
+                            break;
+                        }
+
+                        case 0x09: // horizontal tab
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 't';
+                            break;
+                        }
+
+                        case 0x0A: // newline
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'n';
+                            break;
+                        }
+
+                        case 0x0C: // formfeed
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'f';
+                            break;
+                        }
+
+                        case 0x0D: // carriage return
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'r';
+                            break;
+                        }
+
+                        case 0x22: // quotation mark
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\"';
+                            break;
+                        }
+
+                        case 0x5C: // reverse solidus
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\\';
+                            break;
+                        }
+
+                        default:
+                        {
+                            // escape control characters (0x00..0x1F) or, if
+                            // ensure_ascii parameter is used, non-ASCII characters
+                            if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
+                            {
+                                if (codepoint <= 0xFFFF)
+                                {
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                                      static_cast<std::uint16_t>(codepoint)));
+                                    bytes += 6;
+                                }
+                                else
+                                {
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
+                                    bytes += 12;
+                                }
+                            }
+                            else
+                            {
+                                // copy byte to buffer (all previous bytes
+                                // been copied have in default case above)
+                                string_buffer[bytes++] = s[i];
+                            }
+                            break;
+                        }
+                    }
+
+                    // write buffer and reset index; there must be 13 bytes
+                    // left, as this is the maximal number of bytes to be
+                    // written ("\uxxxx\uxxxx\0") for one code point
+                    if (string_buffer.size() - bytes < 13)
+                    {
+                        o->write_characters(string_buffer.data(), bytes);
+                        bytes = 0;
+                    }
+
+                    // remember the byte position of this accept
+                    bytes_after_last_accept = bytes;
+                    undumped_chars = 0;
+                    break;
+                }
+
+                case UTF8_REJECT:  // decode found invalid UTF-8 byte
+                {
+                    switch (error_handler)
+                    {
+                        case error_handler_t::strict:
+                        {
+                            JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", hex_bytes(byte | 0)), nullptr));
+                        }
+
+                        case error_handler_t::ignore:
+                        case error_handler_t::replace:
+                        {
+                            // in case we saw this character the first time, we
+                            // would like to read it again, because the byte
+                            // may be OK for itself, but just not OK for the
+                            // previous sequence
+                            if (undumped_chars > 0)
+                            {
+                                --i;
+                            }
+
+                            // reset length buffer to the last accepted index;
+                            // thus removing/ignoring the invalid characters
+                            bytes = bytes_after_last_accept;
+
+                            if (error_handler == error_handler_t::replace)
+                            {
+                                // add a replacement character
+                                if (ensure_ascii)
+                                {
+                                    string_buffer[bytes++] = '\\';
+                                    string_buffer[bytes++] = 'u';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'd';
+                                }
+                                else
+                                {
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
+                                }
+
+                                // write buffer and reset index; there must be 13 bytes
+                                // left, as this is the maximal number of bytes to be
+                                // written ("\uxxxx\uxxxx\0") for one code point
+                                if (string_buffer.size() - bytes < 13)
+                                {
+                                    o->write_characters(string_buffer.data(), bytes);
+                                    bytes = 0;
+                                }
+
+                                bytes_after_last_accept = bytes;
+                            }
+
+                            undumped_chars = 0;
+
+                            // continue processing the string
+                            state = UTF8_ACCEPT;
+                            break;
+                        }
+
+                        default:            // LCOV_EXCL_LINE
+                            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+
+                default:  // decode found yet incomplete multi-byte code point
+                {
+                    if (!ensure_ascii)
+                    {
+                        // code point will not be escaped - copy byte to buffer
+                        string_buffer[bytes++] = s[i];
+                    }
+                    ++undumped_chars;
+                    break;
+                }
+            }
+        }
+
+        // we finished processing the string
+        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
+        {
+            // write buffer
+            if (bytes > 0)
+            {
+                o->write_characters(string_buffer.data(), bytes);
+            }
+        }
+        else
+        {
+            // we finish reading, but do not accept: string was incomplete
+            switch (error_handler)
+            {
+                case error_handler_t::strict:
+                {
+                    JSON_THROW(type_error::create(316, concat("incomplete UTF-8 string; last byte: 0x", hex_bytes(static_cast<std::uint8_t>(s.back() | 0))), nullptr));
+                }
+
+                case error_handler_t::ignore:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    break;
+                }
+
+                case error_handler_t::replace:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    // add a replacement character
+                    if (ensure_ascii)
+                    {
+                        o->write_characters("\\ufffd", 6);
+                    }
+                    else
+                    {
+                        o->write_characters("\xEF\xBF\xBD", 3);
+                    }
+                    break;
+                }
+
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            }
+        }
+    }
+
+  private:
+    /*!
+    @brief count digits
+
+    Count the number of decimal (base 10) digits for an input unsigned integer.
+
+    @param[in] x  unsigned integer number to count its digits
+    @return    number of decimal digits
+    */
+    inline unsigned int count_digits(number_unsigned_t x) noexcept
+    {
+        unsigned int n_digits = 1;
+        for (;;)
+        {
+            if (x < 10)
+            {
+                return n_digits;
+            }
+            if (x < 100)
+            {
+                return n_digits + 1;
+            }
+            if (x < 1000)
+            {
+                return n_digits + 2;
+            }
+            if (x < 10000)
+            {
+                return n_digits + 3;
+            }
+            x = x / 10000u;
+            n_digits += 4;
+        }
+    }
+
+    /*!
+     * @brief convert a byte to a uppercase hex representation
+     * @param[in] byte byte to represent
+     * @return representation ("00".."FF")
+     */
+    static std::string hex_bytes(std::uint8_t byte)
+    {
+        std::string result = "FF";
+        constexpr const char* nibble_to_hex = "0123456789ABCDEF";
+        result[0] = nibble_to_hex[byte / 16];
+        result[1] = nibble_to_hex[byte % 16];
+        return result;
+    }
+
+    // templates to avoid warnings about useless casts
+    template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
+    bool is_negative_number(NumberType x)
+    {
+        return x < 0;
+    }
+
+    template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >
+    bool is_negative_number(NumberType /*unused*/)
+    {
+        return false;
+    }
+
+    /*!
+    @brief dump an integer
+
+    Dump a given integer to output stream @a o. Works internally with
+    @a number_buffer.
+
+    @param[in] x  integer number (signed or unsigned) to dump
+    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
+    */
+    template < typename NumberType, detail::enable_if_t <
+                   std::is_integral<NumberType>::value ||
+                   std::is_same<NumberType, number_unsigned_t>::value ||
+                   std::is_same<NumberType, number_integer_t>::value ||
+                   std::is_same<NumberType, binary_char_t>::value,
+                   int > = 0 >
+    void dump_integer(NumberType x)
+    {
+        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
+        {
+            {
+                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
+                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
+                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
+                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
+                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
+                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
+                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
+                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
+                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
+                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
+            }
+        };
+
+        // special case for "0"
+        if (x == 0)
+        {
+            o->write_character('0');
+            return;
+        }
+
+        // use a pointer to fill the buffer
+        auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+
+        number_unsigned_t abs_value;
+
+        unsigned int n_chars{};
+
+        if (is_negative_number(x))
+        {
+            *buffer_ptr = '-';
+            abs_value = remove_sign(static_cast<number_integer_t>(x));
+
+            // account one more byte for the minus sign
+            n_chars = 1 + count_digits(abs_value);
+        }
+        else
+        {
+            abs_value = static_cast<number_unsigned_t>(x);
+            n_chars = count_digits(abs_value);
+        }
+
+        // spare 1 byte for '\0'
+        JSON_ASSERT(n_chars < number_buffer.size() - 1);
+
+        // jump to the end to generate the string from backward,
+        // so we later avoid reversing the result
+        buffer_ptr += n_chars;
+
+        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
+        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
+        while (abs_value >= 100)
+        {
+            const auto digits_index = static_cast<unsigned>((abs_value % 100));
+            abs_value /= 100;
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+
+        if (abs_value >= 10)
+        {
+            const auto digits_index = static_cast<unsigned>(abs_value);
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+        else
+        {
+            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
+        }
+
+        o->write_characters(number_buffer.data(), n_chars);
+    }
+
+    /*!
+    @brief dump a floating-point number
+
+    Dump a given floating-point number to output stream @a o. Works internally
+    with @a number_buffer.
+
+    @param[in] x  floating-point number to dump
+    */
+    void dump_float(number_float_t x)
+    {
+        // NaN / inf
+        if (!std::isfinite(x))
+        {
+            o->write_characters("null", 4);
+            return;
+        }
+
+        // If number_float_t is an IEEE-754 single or double precision number,
+        // use the Grisu2 algorithm to produce short numbers which are
+        // guaranteed to round-trip, using strtof and strtod, resp.
+        //
+        // NB: The test below works if <long double> == <double>.
+        static constexpr bool is_ieee_single_or_double
+            = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
+              (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
+
+        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
+    }
+
+    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
+    {
+        auto* begin = number_buffer.data();
+        auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
+
+        o->write_characters(begin, static_cast<size_t>(end - begin));
+    }
+
+    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
+    {
+        // get number of digits for a float -> text -> float round-trip
+        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
+
+        // the actual conversion
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
+
+        // negative value indicates an error
+        JSON_ASSERT(len > 0);
+        // check if buffer was large enough
+        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
+
+        // erase thousands separator
+        if (thousands_sep != '\0')
+        {
+            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081
+            const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
+            std::fill(end, number_buffer.end(), '\0');
+            JSON_ASSERT((end - number_buffer.begin()) <= len);
+            len = (end - number_buffer.begin());
+        }
+
+        // convert decimal point to '.'
+        if (decimal_point != '\0' && decimal_point != '.')
+        {
+            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081
+            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
+            if (dec_pos != number_buffer.end())
+            {
+                *dec_pos = '.';
+            }
+        }
+
+        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
+
+        // determine if we need to append ".0"
+        const bool value_is_int_like =
+            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
+                         [](char c)
+        {
+            return c == '.' || c == 'e';
+        });
+
+        if (value_is_int_like)
+        {
+            o->write_characters(".0", 2);
+        }
+    }
+
+    /*!
+    @brief check whether a string is UTF-8 encoded
+
+    The function checks each byte of a string whether it is UTF-8 encoded. The
+    result of the check is stored in the @a state parameter. The function must
+    be called initially with state 0 (accept). State 1 means the string must
+    be rejected, because the current byte is not allowed. If the string is
+    completely processed, but the state is non-zero, the string ended
+    prematurely; that is, the last byte indicated more bytes should have
+    followed.
+
+    @param[in,out] state  the state of the decoding
+    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
+    @param[in] byte       next byte to decode
+    @return               new state
+
+    @note The function has been edited: a std::array is used.
+
+    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+    */
+    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
+    {
+        static const std::array<std::uint8_t, 400> utf8d =
+        {
+            {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
+                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
+                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
+                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
+                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
+                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
+                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
+                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
+                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
+            }
+        };
+
+        JSON_ASSERT(byte < utf8d.size());
+        const std::uint8_t type = utf8d[byte];
+
+        codep = (state != UTF8_ACCEPT)
+                ? (byte & 0x3fu) | (codep << 6u)
+                : (0xFFu >> type) & (byte);
+
+        const std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
+        JSON_ASSERT(index < utf8d.size());
+        state = utf8d[index];
+        return state;
+    }
+
+    /*
+     * Overload to make the compiler happy while it is instantiating
+     * dump_integer for number_unsigned_t.
+     * Must never be called.
+     */
+    number_unsigned_t remove_sign(number_unsigned_t x)
+    {
+        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        return x; // LCOV_EXCL_LINE
+    }
+
+    /*
+     * Helper function for dump_integer
+     *
+     * This function takes a negative signed integer and returns its absolute
+     * value as unsigned integer. The plus/minus shuffling is necessary as we can
+     * not directly remove the sign of an arbitrary signed integer as the
+     * absolute values of INT_MIN and INT_MAX are usually not the same. See
+     * #1708 for details.
+     */
+    inline number_unsigned_t remove_sign(number_integer_t x) noexcept
+    {
+        JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
+        return static_cast<number_unsigned_t>(-(x + 1)) + 1;
+    }
+
+  private:
+    /// the output of the serializer
+    output_adapter_t<char> o = nullptr;
+
+    /// a (hopefully) large enough character buffer
+    std::array<char, 64> number_buffer{{}};
+
+    /// the locale
+    const std::lconv* loc = nullptr;
+    /// the locale's thousand separator character
+    const char thousands_sep = '\0';
+    /// the locale's decimal point character
+    const char decimal_point = '\0';
+
+    /// string buffer
+    std::array<char, 512> string_buffer{{}};
+
+    /// the indentation character
+    const char indent_char;
+    /// the indentation string
+    string_t indent_string;
+
+    /// error_handler how to react on decoding errors
+    const error_handler_t error_handler;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/string_concat.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/string_concat.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f49e8d215ee250b9b6d68de0a91b93222d1fa845
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/string_concat.hpp
@@ -0,0 +1,146 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cstring> // strlen
+#include <string> // string
+#include <utility> // forward
+
+#include <nlohmann/detail/meta/cpp_future.hpp>
+#include <nlohmann/detail/meta/detected.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+inline std::size_t concat_length()
+{
+    return 0;
+}
+
+template<typename... Args>
+inline std::size_t concat_length(const char* cstr, const Args& ... rest);
+
+template<typename StringType, typename... Args>
+inline std::size_t concat_length(const StringType& str, const Args& ... rest);
+
+template<typename... Args>
+inline std::size_t concat_length(const char /*c*/, const Args& ... rest)
+{
+    return 1 + concat_length(rest...);
+}
+
+template<typename... Args>
+inline std::size_t concat_length(const char* cstr, const Args& ... rest)
+{
+    // cppcheck-suppress ignoredReturnValue
+    return ::strlen(cstr) + concat_length(rest...);
+}
+
+template<typename StringType, typename... Args>
+inline std::size_t concat_length(const StringType& str, const Args& ... rest)
+{
+    return str.size() + concat_length(rest...);
+}
+
+template<typename OutStringType>
+inline void concat_into(OutStringType& /*out*/)
+{}
+
+template<typename StringType, typename Arg>
+using string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg && > ()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append = is_detected<string_can_append, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg && > ());
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_op = is_detected<string_can_append_op, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_iter = is_detected<string_can_append_iter, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_data = is_detected<string_can_append_data, StringType, Arg>;
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && detect_string_can_append_op<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest);
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && !detect_string_can_append_iter<OutStringType, Arg>::value
+                         && detect_string_can_append_data<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
+
+template<typename OutStringType, typename Arg, typename... Args,
+         enable_if_t<detect_string_can_append<OutStringType, Arg>::value, int> = 0>
+inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest)
+{
+    out.append(std::forward<Arg>(arg));
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && detect_string_can_append_op<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, Arg&& arg, Args&& ... rest)
+{
+    out += std::forward<Arg>(arg);
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
+{
+    out.append(arg.begin(), arg.end());
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && !detect_string_can_append_iter<OutStringType, Arg>::value
+                         && detect_string_can_append_data<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
+{
+    out.append(arg.data(), arg.size());
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template<typename OutStringType = std::string, typename... Args>
+inline OutStringType concat(Args && ... args)
+{
+    OutStringType str;
+    str.reserve(concat_length(args...));
+    concat_into(str, std::forward<Args>(args)...);
+    return str;
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/string_escape.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/string_escape.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..7f1b5c562bc3978a3ce974ca5f60d5d332cc157b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/string_escape.hpp
@@ -0,0 +1,72 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <nlohmann/detail/abi_macros.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief replace all occurrences of a substring by another string
+
+@param[in,out] s  the string to manipulate; changed so that all
+               occurrences of @a f are replaced with @a t
+@param[in]     f  the substring to replace with @a t
+@param[in]     t  the string to replace @a f
+
+@pre The search string @a f must not be empty. **This precondition is
+enforced with an assertion.**
+
+@since version 2.0.0
+*/
+template<typename StringType>
+inline void replace_substring(StringType& s, const StringType& f,
+                              const StringType& t)
+{
+    JSON_ASSERT(!f.empty());
+    for (auto pos = s.find(f);                // find first occurrence of f
+            pos != StringType::npos;          // make sure f was found
+            s.replace(pos, f.size(), t),      // replace with t, and
+            pos = s.find(f, pos + t.size()))  // find next occurrence of f
+    {}
+}
+
+/*!
+ * @brief string escaping as described in RFC 6901 (Sect. 4)
+ * @param[in] s string to escape
+ * @return    escaped string
+ *
+ * Note the order of escaping "~" to "~0" and "/" to "~1" is important.
+ */
+template<typename StringType>
+inline StringType escape(StringType s)
+{
+    replace_substring(s, StringType{"~"}, StringType{"~0"});
+    replace_substring(s, StringType{"/"}, StringType{"~1"});
+    return s;
+}
+
+/*!
+ * @brief string unescaping as described in RFC 6901 (Sect. 4)
+ * @param[in] s string to unescape
+ * @return    unescaped string
+ *
+ * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
+ */
+template<typename StringType>
+static void unescape(StringType& s)
+{
+    replace_substring(s, StringType{"~1"}, StringType{"/"});
+    replace_substring(s, StringType{"~0"}, StringType{"~"});
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/value_t.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/value_t.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..07688fe8c682e03e49ce8355db744549815fea11
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/detail/value_t.hpp
@@ -0,0 +1,118 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t
+#include <string> // string
+
+#include <nlohmann/detail/macro_scope.hpp>
+#if JSON_HAS_THREE_WAY_COMPARISON
+    #include <compare> // partial_ordering
+#endif
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////////////////////
+// JSON type enumeration //
+///////////////////////////
+
+/*!
+@brief the JSON type enumeration
+
+This enumeration collects the different JSON types. It is internally used to
+distinguish the stored values, and the functions @ref basic_json::is_null(),
+@ref basic_json::is_object(), @ref basic_json::is_array(),
+@ref basic_json::is_string(), @ref basic_json::is_boolean(),
+@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
+@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
+@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
+@ref basic_json::is_structured() rely on it.
+
+@note There are three enumeration entries (number_integer, number_unsigned, and
+number_float), because the library distinguishes these three types for numbers:
+@ref basic_json::number_unsigned_t is used for unsigned integers,
+@ref basic_json::number_integer_t is used for signed integers, and
+@ref basic_json::number_float_t is used for floating-point numbers or to
+approximate integers which do not fit in the limits of their respective type.
+
+@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
+value with the default value for a given type
+
+@since version 1.0.0
+*/
+enum class value_t : std::uint8_t
+{
+    null,             ///< null value
+    object,           ///< object (unordered set of name/value pairs)
+    array,            ///< array (ordered collection of values)
+    string,           ///< string value
+    boolean,          ///< boolean value
+    number_integer,   ///< number value (signed integer)
+    number_unsigned,  ///< number value (unsigned integer)
+    number_float,     ///< number value (floating-point)
+    binary,           ///< binary array (ordered collection of bytes)
+    discarded         ///< discarded by the parser callback function
+};
+
+/*!
+@brief comparison operator for JSON types
+
+Returns an ordering that is similar to Python:
+- order: null < boolean < number < object < array < string < binary
+- furthermore, each type is not smaller than itself
+- discarded values are not comparable
+- binary is represented as a b"" string in python and directly comparable to a
+  string; however, making a binary array directly comparable with a string would
+  be surprising behavior in a JSON file.
+
+@since version 1.0.0
+*/
+#if JSON_HAS_THREE_WAY_COMPARISON
+    inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*
+#else
+    inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+#endif
+{
+    static constexpr std::array<std::uint8_t, 9> order = {{
+            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
+            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
+            6 /* binary */
+        }
+    };
+
+    const auto l_index = static_cast<std::size_t>(lhs);
+    const auto r_index = static_cast<std::size_t>(rhs);
+#if JSON_HAS_THREE_WAY_COMPARISON
+    if (l_index < order.size() && r_index < order.size())
+    {
+        return order[l_index] <=> order[r_index]; // *NOPAD*
+    }
+    return std::partial_ordering::unordered;
+#else
+    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
+#endif
+}
+
+// GCC selects the built-in operator< over an operator rewritten from
+// a user-defined spaceship operator
+// Clang, MSVC, and ICC select the rewritten candidate
+// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200)
+#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__)
+inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+{
+    return std::is_lt(lhs <=> rhs); // *NOPAD*
+}
+#endif
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/json.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/json.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..95d6bf1dd9d8bae1c87db8fb647c734e9c71f327
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/json.hpp
@@ -0,0 +1,5258 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+/****************************************************************************\
+ * Note on documentation: The source files contain links to the online      *
+ * documentation of the public API at https://json.nlohmann.me. This URL    *
+ * contains the most recent documentation and should also be applicable to  *
+ * previous versions; documentation for deprecated functions is not         *
+ * removed, but marked deprecated. See "Generate documentation" section in  *
+ * file docs/README.md.                                                     *
+\****************************************************************************/
+
+#ifndef INCLUDE_NLOHMANN_JSON_HPP_
+#define INCLUDE_NLOHMANN_JSON_HPP_
+
+#include <algorithm> // all_of, find, for_each
+#include <cstddef> // nullptr_t, ptrdiff_t, size_t
+#include <functional> // hash, less
+#include <initializer_list> // initializer_list
+#ifndef JSON_NO_IO
+    #include <iosfwd> // istream, ostream
+#endif  // JSON_NO_IO
+#include <iterator> // random_access_iterator_tag
+#include <memory> // unique_ptr
+#include <string> // string, stoi, to_string
+#include <utility> // declval, forward, move, pair, swap
+#include <vector> // vector
+
+#include <nlohmann/adl_serializer.hpp>
+#include <nlohmann/byte_container_with_subtype.hpp>
+#include <nlohmann/detail/conversions/from_json.hpp>
+#include <nlohmann/detail/conversions/to_json.hpp>
+#include <nlohmann/detail/exceptions.hpp>
+#include <nlohmann/detail/hash.hpp>
+#include <nlohmann/detail/input/binary_reader.hpp>
+#include <nlohmann/detail/input/input_adapters.hpp>
+#include <nlohmann/detail/input/lexer.hpp>
+#include <nlohmann/detail/input/parser.hpp>
+#include <nlohmann/detail/iterators/internal_iterator.hpp>
+#include <nlohmann/detail/iterators/iter_impl.hpp>
+#include <nlohmann/detail/iterators/iteration_proxy.hpp>
+#include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
+#include <nlohmann/detail/iterators/primitive_iterator.hpp>
+#include <nlohmann/detail/json_custom_base_class.hpp>
+#include <nlohmann/detail/json_pointer.hpp>
+#include <nlohmann/detail/json_ref.hpp>
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/string_concat.hpp>
+#include <nlohmann/detail/string_escape.hpp>
+#include <nlohmann/detail/meta/cpp_future.hpp>
+#include <nlohmann/detail/meta/type_traits.hpp>
+#include <nlohmann/detail/output/binary_writer.hpp>
+#include <nlohmann/detail/output/output_adapters.hpp>
+#include <nlohmann/detail/output/serializer.hpp>
+#include <nlohmann/detail/value_t.hpp>
+#include <nlohmann/json_fwd.hpp>
+#include <nlohmann/ordered_map.hpp>
+
+#if defined(JSON_HAS_CPP_17)
+    #if JSON_HAS_STATIC_RTTI
+        #include <any>
+    #endif
+    #include <string_view>
+#endif
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/*!
+@brief a class to store JSON values
+
+@internal
+@invariant The member variables @a m_value and @a m_type have the following
+relationship:
+- If `m_type == value_t::object`, then `m_value.object != nullptr`.
+- If `m_type == value_t::array`, then `m_value.array != nullptr`.
+- If `m_type == value_t::string`, then `m_value.string != nullptr`.
+The invariants are checked by member function assert_invariant().
+
+@note ObjectType trick from https://stackoverflow.com/a/9860911
+@endinternal
+
+@since version 1.0.0
+
+@nosubgrouping
+*/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+    : public ::nlohmann::detail::json_base_class<CustomBaseClass>
+{
+  private:
+    template<detail::value_t> friend struct detail::external_constructor;
+
+    template<typename>
+    friend class ::nlohmann::json_pointer;
+    // can be restored when json_pointer backwards compatibility is removed
+    // friend ::nlohmann::json_pointer<StringType>;
+
+    template<typename BasicJsonType, typename InputType>
+    friend class ::nlohmann::detail::parser;
+    friend ::nlohmann::detail::serializer<basic_json>;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::iter_impl;
+    template<typename BasicJsonType, typename CharType>
+    friend class ::nlohmann::detail::binary_writer;
+    template<typename BasicJsonType, typename InputType, typename SAX>
+    friend class ::nlohmann::detail::binary_reader;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_parser;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
+    friend class ::nlohmann::detail::exception;
+
+    /// workaround type for MSVC
+    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
+    using json_base_class_t = ::nlohmann::detail::json_base_class<CustomBaseClass>;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // convenience aliases for types residing in namespace detail;
+    using lexer = ::nlohmann::detail::lexer_base<basic_json>;
+
+    template<typename InputAdapterType>
+    static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
+        InputAdapterType adapter,
+        detail::parser_callback_t<basic_json>cb = nullptr,
+        const bool allow_exceptions = true,
+        const bool ignore_comments = false
+    )
+    {
+        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
+                std::move(cb), allow_exceptions, ignore_comments);
+    }
+
+  private:
+    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
+    template<typename BasicJsonType>
+    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
+    template<typename BasicJsonType>
+    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
+    template<typename Iterator>
+    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
+    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
+
+    template<typename CharType>
+    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
+
+    template<typename InputType>
+    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
+    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    using serializer = ::nlohmann::detail::serializer<basic_json>;
+
+  public:
+    using value_t = detail::value_t;
+    /// JSON Pointer, see @ref nlohmann::json_pointer
+    using json_pointer = ::nlohmann::json_pointer<StringType>;
+    template<typename T, typename SFINAE>
+    using json_serializer = JSONSerializer<T, SFINAE>;
+    /// how to treat decoding errors
+    using error_handler_t = detail::error_handler_t;
+    /// how to treat CBOR tags
+    using cbor_tag_handler_t = detail::cbor_tag_handler_t;
+    /// helper type for initializer lists of basic_json values
+    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
+
+    using input_format_t = detail::input_format_t;
+    /// SAX interface type, see @ref nlohmann::json_sax
+    using json_sax_t = json_sax<basic_json>;
+
+    ////////////////
+    // exceptions //
+    ////////////////
+
+    /// @name exceptions
+    /// Classes to implement user-defined exceptions.
+    /// @{
+
+    using exception = detail::exception;
+    using parse_error = detail::parse_error;
+    using invalid_iterator = detail::invalid_iterator;
+    using type_error = detail::type_error;
+    using out_of_range = detail::out_of_range;
+    using other_error = detail::other_error;
+
+    /// @}
+
+    /////////////////////
+    // container types //
+    /////////////////////
+
+    /// @name container types
+    /// The canonic container types to use @ref basic_json like any other STL
+    /// container.
+    /// @{
+
+    /// the type of elements in a basic_json container
+    using value_type = basic_json;
+
+    /// the type of an element reference
+    using reference = value_type&;
+    /// the type of an element const reference
+    using const_reference = const value_type&;
+
+    /// a type to represent differences between iterators
+    using difference_type = std::ptrdiff_t;
+    /// a type to represent container sizes
+    using size_type = std::size_t;
+
+    /// the allocator type
+    using allocator_type = AllocatorType<basic_json>;
+
+    /// the type of an element pointer
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    /// the type of an element const pointer
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+
+    /// an iterator for a basic_json container
+    using iterator = iter_impl<basic_json>;
+    /// a const iterator for a basic_json container
+    using const_iterator = iter_impl<const basic_json>;
+    /// a reverse iterator for a basic_json container
+    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
+    /// a const reverse iterator for a basic_json container
+    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
+
+    /// @}
+
+    /// @brief returns the allocator associated with the container
+    /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
+    static allocator_type get_allocator()
+    {
+        return allocator_type();
+    }
+
+    /// @brief returns version information on the library
+    /// @sa https://json.nlohmann.me/api/basic_json/meta/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json meta()
+    {
+        basic_json result;
+
+        result["copyright"] = "(C) 2013-2023 Niels Lohmann";
+        result["name"] = "JSON for Modern C++";
+        result["url"] = "https://github.com/nlohmann/json";
+        result["version"]["string"] =
+            detail::concat(std::to_string(NLOHMANN_JSON_VERSION_MAJOR), '.',
+                           std::to_string(NLOHMANN_JSON_VERSION_MINOR), '.',
+                           std::to_string(NLOHMANN_JSON_VERSION_PATCH));
+        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
+        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
+        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
+
+#ifdef _WIN32
+        result["platform"] = "win32";
+#elif defined __linux__
+        result["platform"] = "linux";
+#elif defined __APPLE__
+        result["platform"] = "apple";
+#elif defined __unix__
+        result["platform"] = "unix";
+#else
+        result["platform"] = "unknown";
+#endif
+
+#if defined(__ICC) || defined(__INTEL_COMPILER)
+        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
+#elif defined(__clang__)
+        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
+#elif defined(__GNUC__) || defined(__GNUG__)
+        result["compiler"] = {{"family", "gcc"}, {"version", detail::concat(
+                    std::to_string(__GNUC__), '.',
+                    std::to_string(__GNUC_MINOR__), '.',
+                    std::to_string(__GNUC_PATCHLEVEL__))
+            }
+        };
+#elif defined(__HP_cc) || defined(__HP_aCC)
+        result["compiler"] = "hp"
+#elif defined(__IBMCPP__)
+        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
+#elif defined(_MSC_VER)
+        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
+#elif defined(__PGI)
+        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
+#elif defined(__SUNPRO_CC)
+        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
+#else
+        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
+#endif
+
+#if defined(_MSVC_LANG)
+        result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
+#elif defined(__cplusplus)
+        result["compiler"]["c++"] = std::to_string(__cplusplus);
+#else
+        result["compiler"]["c++"] = "unknown";
+#endif
+        return result;
+    }
+
+    ///////////////////////////
+    // JSON value data types //
+    ///////////////////////////
+
+    /// @name JSON value data types
+    /// The data types to store a JSON value. These types are derived from
+    /// the template arguments passed to class @ref basic_json.
+    /// @{
+
+    /// @brief default object key comparator type
+    /// The actual object key comparator type (@ref object_comparator_t) may be
+    /// different.
+    /// @sa https://json.nlohmann.me/api/basic_json/default_object_comparator_t/
+#if defined(JSON_HAS_CPP_14)
+    // use of transparent comparator avoids unnecessary repeated construction of temporaries
+    // in functions involving lookup by key with types other than object_t::key_type (aka. StringType)
+    using default_object_comparator_t = std::less<>;
+#else
+    using default_object_comparator_t = std::less<StringType>;
+#endif
+
+    /// @brief a type for an object
+    /// @sa https://json.nlohmann.me/api/basic_json/object_t/
+    using object_t = ObjectType<StringType,
+          basic_json,
+          default_object_comparator_t,
+          AllocatorType<std::pair<const StringType,
+          basic_json>>>;
+
+    /// @brief a type for an array
+    /// @sa https://json.nlohmann.me/api/basic_json/array_t/
+    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
+
+    /// @brief a type for a string
+    /// @sa https://json.nlohmann.me/api/basic_json/string_t/
+    using string_t = StringType;
+
+    /// @brief a type for a boolean
+    /// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
+    using boolean_t = BooleanType;
+
+    /// @brief a type for a number (integer)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
+    using number_integer_t = NumberIntegerType;
+
+    /// @brief a type for a number (unsigned)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
+    using number_unsigned_t = NumberUnsignedType;
+
+    /// @brief a type for a number (floating-point)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
+    using number_float_t = NumberFloatType;
+
+    /// @brief a type for a packed binary type
+    /// @sa https://json.nlohmann.me/api/basic_json/binary_t/
+    using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
+
+    /// @brief object key comparator type
+    /// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
+    using object_comparator_t = detail::actual_object_comparator_t<basic_json>;
+
+    /// @}
+
+  private:
+
+    /// helper for exception-safe object creation
+    template<typename T, typename... Args>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    static T* create(Args&& ... args)
+    {
+        AllocatorType<T> alloc;
+        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
+
+        auto deleter = [&](T * obj)
+        {
+            AllocatorTraits::deallocate(alloc, obj, 1);
+        };
+        std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
+        AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
+        JSON_ASSERT(obj != nullptr);
+        return obj.release();
+    }
+
+    ////////////////////////
+    // JSON value storage //
+    ////////////////////////
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief a JSON value
+
+    The actual storage for a JSON value of the @ref basic_json class. This
+    union combines the different storage types for the JSON value types
+    defined in @ref value_t.
+
+    JSON type | value_t type    | used type
+    --------- | --------------- | ------------------------
+    object    | object          | pointer to @ref object_t
+    array     | array           | pointer to @ref array_t
+    string    | string          | pointer to @ref string_t
+    boolean   | boolean         | @ref boolean_t
+    number    | number_integer  | @ref number_integer_t
+    number    | number_unsigned | @ref number_unsigned_t
+    number    | number_float    | @ref number_float_t
+    binary    | binary          | pointer to @ref binary_t
+    null      | null            | *no value is stored*
+
+    @note Variable-length types (objects, arrays, and strings) are stored as
+    pointers. The size of the union should not exceed 64 bits if the default
+    value types are used.
+
+    @since version 1.0.0
+    */
+    union json_value
+    {
+        /// object (stored with pointer to save storage)
+        object_t* object;
+        /// array (stored with pointer to save storage)
+        array_t* array;
+        /// string (stored with pointer to save storage)
+        string_t* string;
+        /// binary (stored with pointer to save storage)
+        binary_t* binary;
+        /// boolean
+        boolean_t boolean;
+        /// number (integer)
+        number_integer_t number_integer;
+        /// number (unsigned integer)
+        number_unsigned_t number_unsigned;
+        /// number (floating-point)
+        number_float_t number_float;
+
+        /// default constructor (for null values)
+        json_value() = default;
+        /// constructor for booleans
+        json_value(boolean_t v) noexcept : boolean(v) {}
+        /// constructor for numbers (integer)
+        json_value(number_integer_t v) noexcept : number_integer(v) {}
+        /// constructor for numbers (unsigned)
+        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
+        /// constructor for numbers (floating-point)
+        json_value(number_float_t v) noexcept : number_float(v) {}
+        /// constructor for empty values of a given type
+        json_value(value_t t)
+        {
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    object = create<object_t>();
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    array = create<array_t>();
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    string = create<string_t>("");
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    binary = create<binary_t>();
+                    break;
+                }
+
+                case value_t::boolean:
+                {
+                    boolean = static_cast<boolean_t>(false);
+                    break;
+                }
+
+                case value_t::number_integer:
+                {
+                    number_integer = static_cast<number_integer_t>(0);
+                    break;
+                }
+
+                case value_t::number_unsigned:
+                {
+                    number_unsigned = static_cast<number_unsigned_t>(0);
+                    break;
+                }
+
+                case value_t::number_float:
+                {
+                    number_float = static_cast<number_float_t>(0.0);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    break;
+                }
+
+                case value_t::discarded:
+                default:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
+                    {
+                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.11.3", nullptr)); // LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+            }
+        }
+
+        /// constructor for strings
+        json_value(const string_t& value) : string(create<string_t>(value)) {}
+
+        /// constructor for rvalue strings
+        json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
+
+        /// constructor for objects
+        json_value(const object_t& value) : object(create<object_t>(value)) {}
+
+        /// constructor for rvalue objects
+        json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
+
+        /// constructor for arrays
+        json_value(const array_t& value) : array(create<array_t>(value)) {}
+
+        /// constructor for rvalue arrays
+        json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
+
+        /// constructor for binary arrays
+        json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
+
+        /// constructor for rvalue binary arrays
+        json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
+
+        /// constructor for binary arrays (internal type)
+        json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
+
+        /// constructor for rvalue binary arrays (internal type)
+        json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
+
+        void destroy(value_t t)
+        {
+            if (
+                (t == value_t::object && object == nullptr) ||
+                (t == value_t::array && array == nullptr) ||
+                (t == value_t::string && string == nullptr) ||
+                (t == value_t::binary && binary == nullptr)
+            )
+            {
+                //not initialized (e.g. due to exception in the ctor)
+                return;
+            }
+            if (t == value_t::array || t == value_t::object)
+            {
+                // flatten the current json_value to a heap-allocated stack
+                std::vector<basic_json> stack;
+
+                // move the top-level items to stack
+                if (t == value_t::array)
+                {
+                    stack.reserve(array->size());
+                    std::move(array->begin(), array->end(), std::back_inserter(stack));
+                }
+                else
+                {
+                    stack.reserve(object->size());
+                    for (auto&& it : *object)
+                    {
+                        stack.push_back(std::move(it.second));
+                    }
+                }
+
+                while (!stack.empty())
+                {
+                    // move the last item to local variable to be processed
+                    basic_json current_item(std::move(stack.back()));
+                    stack.pop_back();
+
+                    // if current_item is array/object, move
+                    // its children to the stack to be processed later
+                    if (current_item.is_array())
+                    {
+                        std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
+
+                        current_item.m_data.m_value.array->clear();
+                    }
+                    else if (current_item.is_object())
+                    {
+                        for (auto&& it : *current_item.m_data.m_value.object)
+                        {
+                            stack.push_back(std::move(it.second));
+                        }
+
+                        current_item.m_data.m_value.object->clear();
+                    }
+
+                    // it's now safe that current_item get destructed
+                    // since it doesn't have any children
+                }
+            }
+
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    AllocatorType<object_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    AllocatorType<array_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
+                    break;
+                }
+
+                case value_t::null:
+                case value_t::boolean:
+                case value_t::number_integer:
+                case value_t::number_unsigned:
+                case value_t::number_float:
+                case value_t::discarded:
+                default:
+                {
+                    break;
+                }
+            }
+        }
+    };
+
+  private:
+    /*!
+    @brief checks the class invariants
+
+    This function asserts the class invariants. It needs to be called at the
+    end of every constructor to make sure that created objects respect the
+    invariant. Furthermore, it has to be called each time the type of a JSON
+    value is changed, because the invariant expresses a relationship between
+    @a m_type and @a m_value.
+
+    Furthermore, the parent relation is checked for arrays and objects: If
+    @a check_parents true and the value is an array or object, then the
+    container's elements must have the current value as parent.
+
+    @param[in] check_parents  whether the parent relation should be checked.
+               The value is true by default and should only be set to false
+               during destruction of objects when the invariant does not
+               need to hold.
+    */
+    void assert_invariant(bool check_parents = true) const noexcept
+    {
+        JSON_ASSERT(m_data.m_type != value_t::object || m_data.m_value.object != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::array || m_data.m_value.array != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::string || m_data.m_value.string != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::binary || m_data.m_value.binary != nullptr);
+
+#if JSON_DIAGNOSTICS
+        JSON_TRY
+        {
+            // cppcheck-suppress assertWithSideEffect
+            JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
+            {
+                return j.m_parent == this;
+            }));
+        }
+        JSON_CATCH(...) {} // LCOV_EXCL_LINE
+#endif
+        static_cast<void>(check_parents);
+    }
+
+    void set_parents()
+    {
+#if JSON_DIAGNOSTICS
+        switch (m_data.m_type)
+        {
+            case value_t::array:
+            {
+                for (auto& element : *m_data.m_value.array)
+                {
+                    element.m_parent = this;
+                }
+                break;
+            }
+
+            case value_t::object:
+            {
+                for (auto& element : *m_data.m_value.object)
+                {
+                    element.second.m_parent = this;
+                }
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                break;
+        }
+#endif
+    }
+
+    iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
+    {
+#if JSON_DIAGNOSTICS
+        for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)
+        {
+            (it + i)->m_parent = this;
+        }
+#else
+        static_cast<void>(count_set_parents);
+#endif
+        return it;
+    }
+
+    reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))
+    {
+#if JSON_DIAGNOSTICS
+        if (old_capacity != static_cast<std::size_t>(-1))
+        {
+            // see https://github.com/nlohmann/json/issues/2838
+            JSON_ASSERT(type() == value_t::array);
+            if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
+            {
+                // capacity has changed: update all parents
+                set_parents();
+                return j;
+            }
+        }
+
+        // ordered_json uses a vector internally, so pointers could have
+        // been invalidated; see https://github.com/nlohmann/json/issues/2962
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning(push )
+#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
+#endif
+        if (detail::is_ordered_map<object_t>::value)
+        {
+            set_parents();
+            return j;
+        }
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning( pop )
+#endif
+
+        j.m_parent = this;
+#else
+        static_cast<void>(j);
+        static_cast<void>(old_capacity);
+#endif
+        return j;
+    }
+
+  public:
+    //////////////////////////
+    // JSON parser callback //
+    //////////////////////////
+
+    /// @brief parser event types
+    /// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
+    using parse_event_t = detail::parse_event_t;
+
+    /// @brief per-element parser callback type
+    /// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
+    using parser_callback_t = detail::parser_callback_t<basic_json>;
+
+    //////////////////
+    // constructors //
+    //////////////////
+
+    /// @name constructors and destructors
+    /// Constructors of class @ref basic_json, copy/move constructor, copy
+    /// assignment, static functions creating objects, and the destructor.
+    /// @{
+
+    /// @brief create an empty value with a given type
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(const value_t v)
+        : m_data(v)
+    {
+        assert_invariant();
+    }
+
+    /// @brief create a null object
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-exception-escape)
+        : basic_json(value_t::null)
+    {
+        assert_invariant();
+    }
+
+    /// @brief create a JSON value from compatible types
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename CompatibleType,
+               typename U = detail::uncvref_t<CompatibleType>,
+               detail::enable_if_t <
+                   !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
+    basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
+                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
+                                           std::forward<CompatibleType>(val))))
+    {
+        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief create a JSON value from an existing one
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
+    basic_json(const BasicJsonType& val)
+    {
+        using other_boolean_t = typename BasicJsonType::boolean_t;
+        using other_number_float_t = typename BasicJsonType::number_float_t;
+        using other_number_integer_t = typename BasicJsonType::number_integer_t;
+        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+        using other_string_t = typename BasicJsonType::string_t;
+        using other_object_t = typename BasicJsonType::object_t;
+        using other_array_t = typename BasicJsonType::array_t;
+        using other_binary_t = typename BasicJsonType::binary_t;
+
+        switch (val.type())
+        {
+            case value_t::boolean:
+                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
+                break;
+            case value_t::number_float:
+                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
+                break;
+            case value_t::number_integer:
+                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
+                break;
+            case value_t::number_unsigned:
+                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
+                break;
+            case value_t::string:
+                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
+                break;
+            case value_t::object:
+                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
+                break;
+            case value_t::array:
+                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
+                break;
+            case value_t::binary:
+                JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
+                break;
+            case value_t::null:
+                *this = nullptr;
+                break;
+            case value_t::discarded:
+                m_data.m_type = value_t::discarded;
+                break;
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+        JSON_ASSERT(m_data.m_type == val.type());
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief create a container (array or object) from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(initializer_list_t init,
+               bool type_deduction = true,
+               value_t manual_type = value_t::array)
+    {
+        // check if each element is an array with two elements whose first
+        // element is a string
+        bool is_an_object = std::all_of(init.begin(), init.end(),
+                                        [](const detail::json_ref<basic_json>& element_ref)
+        {
+            // The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
+            // (many string types can be constructed from 0 via its null-pointer guise, so we get a
+            // broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
+            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
+        });
+
+        // adjust type if type deduction is not wanted
+        if (!type_deduction)
+        {
+            // if array is wanted, do not create an object though possible
+            if (manual_type == value_t::array)
+            {
+                is_an_object = false;
+            }
+
+            // if object is wanted but impossible, throw an exception
+            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
+            {
+                JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
+            }
+        }
+
+        if (is_an_object)
+        {
+            // the initializer list is a list of pairs -> create object
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+
+            for (auto& element_ref : init)
+            {
+                auto element = element_ref.moved_or_copied();
+                m_data.m_value.object->emplace(
+                    std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
+                    std::move((*element.m_data.m_value.array)[1]));
+            }
+        }
+        else
+        {
+            // the initializer list describes an array -> create array
+            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>(init.begin(), init.end());
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief explicitly create a binary array (without subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = init;
+        return res;
+    }
+
+    /// @brief explicitly create a binary array (with subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(init, subtype);
+        return res;
+    }
+
+    /// @brief explicitly create a binary array
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = std::move(init);
+        return res;
+    }
+
+    /// @brief explicitly create a binary array (with subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(std::move(init), subtype);
+        return res;
+    }
+
+    /// @brief explicitly create an array from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/array/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json array(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::array);
+    }
+
+    /// @brief explicitly create an object from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/object/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json object(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::object);
+    }
+
+    /// @brief construct an array with count copies of given value
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(size_type cnt, const basic_json& val):
+        m_data{cnt, val}
+    {
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief construct a JSON container given an iterator range
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < class InputIT, typename std::enable_if <
+                   std::is_same<InputIT, typename basic_json_t::iterator>::value ||
+                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
+    basic_json(InputIT first, InputIT last)
+    {
+        JSON_ASSERT(first.m_object != nullptr);
+        JSON_ASSERT(last.m_object != nullptr);
+
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", nullptr));
+        }
+
+        // copy type from first iterator
+        m_data.m_type = first.m_object->m_data.m_type;
+
+        // check if iterator range is complete for primitive values
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
+                                         || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", first.m_object));
+                }
+                break;
+            }
+
+            case value_t::null:
+            case value_t::object:
+            case value_t::array:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                break;
+        }
+
+        switch (m_data.m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_data.m_value.number_integer = first.m_object->m_data.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value.number_unsigned = first.m_object->m_data.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value.number_float = first.m_object->m_data.m_value.number_float;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value.boolean = first.m_object->m_data.m_value.boolean;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value = *first.m_object->m_data.m_value.string;
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_data.m_value.object = create<object_t>(first.m_it.object_iterator,
+                                        last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value.array = create<array_t>(first.m_it.array_iterator,
+                                                       last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value = *first.m_object->m_data.m_value.binary;
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(invalid_iterator::create(206, detail::concat("cannot construct with iterators from ", first.m_object->type_name()), first.m_object));
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    ///////////////////////////////////////
+    // other constructors and destructor //
+    ///////////////////////////////////////
+
+    template<typename JsonRef,
+             detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
+                                 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
+    basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
+
+    /// @brief copy constructor
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(const basic_json& other)
+        : json_base_class_t(other)
+    {
+        m_data.m_type = other.m_data.m_type;
+        // check of passed value is valid
+        other.assert_invariant();
+
+        switch (m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_data.m_value = *other.m_data.m_value.object;
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value = *other.m_data.m_value.array;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value = *other.m_data.m_value.string;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value = other.m_data.m_value.boolean;
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                m_data.m_value = other.m_data.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value = other.m_data.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value = other.m_data.m_value.number_float;
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value = *other.m_data.m_value.binary;
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                break;
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief move constructor
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(basic_json&& other) noexcept
+        : json_base_class_t(std::forward<json_base_class_t>(other)),
+          m_data(std::move(other.m_data))
+    {
+        // check that passed value is valid
+        other.assert_invariant(false);
+
+        // invalidate payload
+        other.m_data.m_type = value_t::null;
+        other.m_data.m_value = {};
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief copy assignment
+    /// @sa https://json.nlohmann.me/api/basic_json/operator=/
+    basic_json& operator=(basic_json other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value&&
+        std::is_nothrow_move_assignable<json_base_class_t>::value
+    )
+    {
+        // check that passed value is valid
+        other.assert_invariant();
+
+        using std::swap;
+        swap(m_data.m_type, other.m_data.m_type);
+        swap(m_data.m_value, other.m_data.m_value);
+        json_base_class_t::operator=(std::move(other));
+
+        set_parents();
+        assert_invariant();
+        return *this;
+    }
+
+    /// @brief destructor
+    /// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
+    ~basic_json() noexcept
+    {
+        assert_invariant(false);
+    }
+
+    /// @}
+
+  public:
+    ///////////////////////
+    // object inspection //
+    ///////////////////////
+
+    /// @name object inspection
+    /// Functions to inspect the type of a JSON value.
+    /// @{
+
+    /// @brief serialization
+    /// @sa https://json.nlohmann.me/api/basic_json/dump/
+    string_t dump(const int indent = -1,
+                  const char indent_char = ' ',
+                  const bool ensure_ascii = false,
+                  const error_handler_t error_handler = error_handler_t::strict) const
+    {
+        string_t result;
+        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
+
+        if (indent >= 0)
+        {
+            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
+        }
+        else
+        {
+            s.dump(*this, false, ensure_ascii, 0);
+        }
+
+        return result;
+    }
+
+    /// @brief return the type of the JSON value (explicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/type/
+    constexpr value_t type() const noexcept
+    {
+        return m_data.m_type;
+    }
+
+    /// @brief return whether type is primitive
+    /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
+    constexpr bool is_primitive() const noexcept
+    {
+        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
+    }
+
+    /// @brief return whether type is structured
+    /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
+    constexpr bool is_structured() const noexcept
+    {
+        return is_array() || is_object();
+    }
+
+    /// @brief return whether value is null
+    /// @sa https://json.nlohmann.me/api/basic_json/is_null/
+    constexpr bool is_null() const noexcept
+    {
+        return m_data.m_type == value_t::null;
+    }
+
+    /// @brief return whether value is a boolean
+    /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
+    constexpr bool is_boolean() const noexcept
+    {
+        return m_data.m_type == value_t::boolean;
+    }
+
+    /// @brief return whether value is a number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number/
+    constexpr bool is_number() const noexcept
+    {
+        return is_number_integer() || is_number_float();
+    }
+
+    /// @brief return whether value is an integer number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
+    constexpr bool is_number_integer() const noexcept
+    {
+        return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
+    }
+
+    /// @brief return whether value is an unsigned integer number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
+    constexpr bool is_number_unsigned() const noexcept
+    {
+        return m_data.m_type == value_t::number_unsigned;
+    }
+
+    /// @brief return whether value is a floating-point number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
+    constexpr bool is_number_float() const noexcept
+    {
+        return m_data.m_type == value_t::number_float;
+    }
+
+    /// @brief return whether value is an object
+    /// @sa https://json.nlohmann.me/api/basic_json/is_object/
+    constexpr bool is_object() const noexcept
+    {
+        return m_data.m_type == value_t::object;
+    }
+
+    /// @brief return whether value is an array
+    /// @sa https://json.nlohmann.me/api/basic_json/is_array/
+    constexpr bool is_array() const noexcept
+    {
+        return m_data.m_type == value_t::array;
+    }
+
+    /// @brief return whether value is a string
+    /// @sa https://json.nlohmann.me/api/basic_json/is_string/
+    constexpr bool is_string() const noexcept
+    {
+        return m_data.m_type == value_t::string;
+    }
+
+    /// @brief return whether value is a binary array
+    /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
+    constexpr bool is_binary() const noexcept
+    {
+        return m_data.m_type == value_t::binary;
+    }
+
+    /// @brief return whether value is discarded
+    /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
+    constexpr bool is_discarded() const noexcept
+    {
+        return m_data.m_type == value_t::discarded;
+    }
+
+    /// @brief return the type of the JSON value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
+    constexpr operator value_t() const noexcept
+    {
+        return m_data.m_type;
+    }
+
+    /// @}
+
+  private:
+    //////////////////
+    // value access //
+    //////////////////
+
+    /// get a boolean (explicit)
+    boolean_t get_impl(boolean_t* /*unused*/) const
+    {
+        if (JSON_HEDLEY_LIKELY(is_boolean()))
+        {
+            return m_data.m_value.boolean;
+        }
+
+        JSON_THROW(type_error::create(302, detail::concat("type must be boolean, but is ", type_name()), this));
+    }
+
+    /// get a pointer to the value (object)
+    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
+    {
+        return is_object() ? m_data.m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (object)
+    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
+    {
+        return is_object() ? m_data.m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
+    {
+        return is_array() ? m_data.m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
+    {
+        return is_array() ? m_data.m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
+    {
+        return is_string() ? m_data.m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
+    {
+        return is_string() ? m_data.m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
+    {
+        return is_boolean() ? &m_data.m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
+    {
+        return is_boolean() ? &m_data.m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
+    {
+        return is_number_integer() ? &m_data.m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
+    {
+        return is_number_integer() ? &m_data.m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
+    {
+        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
+    {
+        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
+    {
+        return is_number_float() ? &m_data.m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
+    {
+        return is_number_float() ? &m_data.m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
+    {
+        return is_binary() ? m_data.m_value.binary : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
+    {
+        return is_binary() ? m_data.m_value.binary : nullptr;
+    }
+
+    /*!
+    @brief helper function to implement get_ref()
+
+    This function helps to implement get_ref() without code duplication for
+    const and non-const overloads
+
+    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
+
+    @throw type_error.303 if ReferenceType does not match underlying value
+    type of the current JSON
+    */
+    template<typename ReferenceType, typename ThisType>
+    static ReferenceType get_ref_impl(ThisType& obj)
+    {
+        // delegate the call to get_ptr<>()
+        auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
+
+        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
+        {
+            return *ptr;
+        }
+
+        JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
+    }
+
+  public:
+    /// @name value access
+    /// Direct access to the stored value of a JSON value.
+    /// @{
+
+    /// @brief get a pointer value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>()
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /// @brief get a pointer value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
+    template < typename PointerType, typename std::enable_if <
+                   std::is_pointer<PointerType>::value&&
+                   std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
+    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>() const
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+  private:
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType ret;
+    JSONSerializer<ValueType>::from_json(*this, ret);
+    return ret;
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+    - @ref json_serializer<ValueType> does not have a `from_json()` method of
+      the form `ValueType from_json(const basic_json&)`
+
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get__ValueType_const}
+
+    @since version 2.1.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   detail::is_default_constructible<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
+    {
+        auto ret = ValueType();
+        JSONSerializer<ValueType>::from_json(*this, ret);
+        return ret;
+    }
+
+    /*!
+    @brief get a value (explicit); special case
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    return JSONSerializer<ValueType>::from_json(*this);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json and
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `ValueType from_json(const basic_json&)`
+
+    @note If @ref json_serializer<ValueType> has both overloads of
+    `from_json()`, this one is chosen.
+
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @since version 2.1.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
+    {
+        return JSONSerializer<ValueType>::from_json(*this);
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads converts the current @ref basic_json in a different
+    @ref basic_json type
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this, converted into @a BasicJsonType
+
+    @complexity Depending on the implementation of the called `from_json()`
+                method.
+
+    @since version 3.2.0
+    */
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value,
+                   int > = 0 >
+    BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads avoids a lot of template boilerplate, it can be seen as the
+    identity method
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this
+
+    @complexity Constant.
+
+    @since version 2.1.0
+    */
+    template<typename BasicJsonType,
+             detail::enable_if_t<
+                 std::is_same<BasicJsonType, basic_json_t>::value,
+                 int> = 0>
+    basic_json get_impl(detail::priority_tag<3> /*unused*/) const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+    @copydoc get()
+    */
+    template<typename PointerType,
+             detail::enable_if_t<
+                 std::is_pointer<PointerType>::value,
+                 int> = 0>
+    constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
+    -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+  public:
+    /*!
+    @brief get a (pointer) value (explicit)
+
+    Performs explicit type conversion between the JSON value and a compatible value if required.
+
+    - If the requested type is a pointer to the internally stored JSON value that pointer is returned.
+    No copies are made.
+
+    - If the requested type is the current @ref basic_json, or a different @ref basic_json convertible
+    from the current @ref basic_json.
+
+    - Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`
+    method.
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @tparam ValueType if necessary
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required
+
+    @since version 2.1.0
+    */
+    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
+#if defined(JSON_HAS_CPP_14)
+    constexpr
+#endif
+    auto get() const noexcept(
+    noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
+    -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
+    {
+        // we cannot static_assert on ValueTypeCV being non-const, because
+        // there is support for get<const basic_json_t>(), which is why we
+        // still need the uncvref
+        static_assert(!std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        return get_impl<ValueType>(detail::priority_tag<4> {});
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+
+    Explicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning The pointer becomes invalid if the underlying JSON object
+    changes.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get__PointerType}
+
+    @sa see @ref get_ptr() for explicit pointer-member access
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /// @brief get a value (explicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_to/
+    template < typename ValueType,
+               detail::enable_if_t <
+                   !detail::is_basic_json<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType & get_to(ValueType& v) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<ValueType>::from_json(*this, v);
+        return v;
+    }
+
+    // specialization to allow calling get_to with a basic_json value
+    // see https://github.com/nlohmann/json/issues/2175
+    template<typename ValueType,
+             detail::enable_if_t <
+                 detail::is_basic_json<ValueType>::value,
+                 int> = 0>
+    ValueType & get_to(ValueType& v) const
+    {
+        v = *this;
+        return v;
+    }
+
+    template <
+        typename T, std::size_t N,
+        typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+        detail::enable_if_t <
+            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
+    Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+    noexcept(noexcept(JSONSerializer<Array>::from_json(
+                          std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<Array>::from_json(*this, v);
+        return v;
+    }
+
+    /// @brief get a reference value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
+    template<typename ReferenceType, typename std::enable_if<
+                 std::is_reference<ReferenceType>::value, int>::type = 0>
+    ReferenceType get_ref()
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /// @brief get a reference value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
+    template < typename ReferenceType, typename std::enable_if <
+                   std::is_reference<ReferenceType>::value&&
+                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
+    ReferenceType get_ref() const
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a value (implicit)
+
+    Implicit type conversion between the JSON value and a compatible value.
+    The call is realized by calling @ref get() const.
+
+    @tparam ValueType non-pointer type compatible to the JSON value, for
+    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+    `std::vector` types for JSON arrays. The character type of @ref string_t
+    as well as an initializer list of this type is excluded to avoid
+    ambiguities as these types implicitly convert to `std::string`.
+
+    @return copy of the JSON value, converted to type @a ValueType
+
+    @throw type_error.302 in case passed type @a ValueType is incompatible
+    to the JSON value type (e.g., the JSON value is of type boolean, but a
+    string is requested); see example below
+
+    @complexity Linear in the size of the JSON value.
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,operator__ValueType}
+
+    @since version 1.0.0
+    */
+    template < typename ValueType, typename std::enable_if <
+                   detail::conjunction <
+                       detail::negation<std::is_pointer<ValueType>>,
+                       detail::negation<std::is_same<ValueType, std::nullptr_t>>,
+                       detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
+                                        detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
+                                        detail::negation<detail::is_basic_json<ValueType>>,
+                                        detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
+#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
+                                                detail::negation<std::is_same<ValueType, std::string_view>>,
+#endif
+#if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
+                                                detail::negation<std::is_same<ValueType, std::any>>,
+#endif
+                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
+                                                >::value, int >::type = 0 >
+                                        JSON_EXPLICIT operator ValueType() const
+    {
+        // delegate the call to get<>() const
+        return get<ValueType>();
+    }
+
+    /// @brief get a binary value
+    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
+    binary_t& get_binary()
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
+        }
+
+        return *get_ptr<binary_t*>();
+    }
+
+    /// @brief get a binary value
+    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
+    const binary_t& get_binary() const
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
+        }
+
+        return *get_ptr<const binary_t*>();
+    }
+
+    /// @}
+
+    ////////////////////
+    // element access //
+    ////////////////////
+
+    /// @name element access
+    /// Access to the JSON value.
+    /// @{
+
+    /// @brief access specified array element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(size_type idx)
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return set_parent(m_data.m_value.array->at(idx));
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+    }
+
+    /// @brief access specified array element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(size_type idx) const
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_data.m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(const typename object_t::key_type& key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(key);
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
+        }
+        return set_parent(it->second);
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    reference at(KeyType && key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
+        }
+        return set_parent(it->second);
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(const typename object_t::key_type& key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(key);
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
+        }
+        return it->second;
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    const_reference at(KeyType && key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
+        }
+        return it->second;
+    }
+
+    /// @brief access specified array element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](size_type idx)
+    {
+        // implicitly convert null value to an empty array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // fill up array with null values if given idx is outside range
+            if (idx >= m_data.m_value.array->size())
+            {
+#if JSON_DIAGNOSTICS
+                // remember array size & capacity before resizing
+                const auto old_size = m_data.m_value.array->size();
+                const auto old_capacity = m_data.m_value.array->capacity();
+#endif
+                m_data.m_value.array->resize(idx + 1);
+
+#if JSON_DIAGNOSTICS
+                if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
+                {
+                    // capacity has changed: update all parents
+                    set_parents();
+                }
+                else
+                {
+                    // set parent for values added above
+                    set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
+                }
+#endif
+                assert_invariant();
+            }
+
+            return m_data.m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
+    }
+
+    /// @brief access specified array element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](size_type idx) const
+    {
+        // const operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            return m_data.m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](typename object_t::key_type key)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
+            return set_parent(result.first->second);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](const typename object_t::key_type& key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto it = m_data.m_value.object->find(key);
+            JSON_ASSERT(it != m_data.m_value.object->end());
+            return it->second;
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    // these two functions resolve a (const) char * ambiguity affecting Clang and MSVC
+    // (they seemingly cannot be constrained to resolve the ambiguity)
+    template<typename T>
+    reference operator[](T* key)
+    {
+        return operator[](typename object_t::key_type(key));
+    }
+
+    template<typename T>
+    const_reference operator[](T* key) const
+    {
+        return operator[](typename object_t::key_type(key));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    reference operator[](KeyType && key)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto result = m_data.m_value.object->emplace(std::forward<KeyType>(key), nullptr);
+            return set_parent(result.first->second);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    const_reference operator[](KeyType && key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+            JSON_ASSERT(it != m_data.m_value.object->end());
+            return it->second;
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+  private:
+    template<typename KeyType>
+    using is_comparable_with_object_key = detail::is_comparable <
+        object_comparator_t, const typename object_t::key_type&, KeyType >;
+
+    template<typename ValueType>
+    using value_return_type = std::conditional <
+        detail::is_c_string_uncvref<ValueType>::value,
+        string_t, typename std::decay<ValueType>::type >;
+
+  public:
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, detail::enable_if_t <
+                   !detail::is_transparent<object_comparator_t>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(key);
+            if (it != end())
+            {
+                return it->template get<ValueType>();
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   !detail::is_transparent<object_comparator_t>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(const typename object_t::key_type& key, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(key);
+            if (it != end())
+            {
+                return it->template get<ReturnType>();
+            }
+
+            return std::forward<ValueType>(default_value);
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class KeyType, detail::enable_if_t <
+                   detail::is_transparent<object_comparator_t>::value
+                   && !detail::is_json_pointer<KeyType>::value
+                   && is_comparable_with_object_key<KeyType>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(KeyType && key, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(std::forward<KeyType>(key));
+            if (it != end())
+            {
+                return it->template get<ValueType>();
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class KeyType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_transparent<object_comparator_t>::value
+                   && !detail::is_json_pointer<KeyType>::value
+                   && is_comparable_with_object_key<KeyType>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(KeyType && key, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(std::forward<KeyType>(key));
+            if (it != end())
+            {
+                return it->template get<ReturnType>();
+            }
+
+            return std::forward<ValueType>(default_value);
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, detail::enable_if_t <
+                   detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if pointer resolves a value, return it or use default value
+            JSON_TRY
+            {
+                return ptr.get_checked(this).template get<ValueType>();
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return default_value;
+            }
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(const json_pointer& ptr, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if pointer resolves a value, return it or use default value
+            JSON_TRY
+            {
+                return ptr.get_checked(this).template get<ReturnType>();
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return std::forward<ValueType>(default_value);
+            }
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    template < class ValueType, class BasicJsonType, detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const
+    {
+        return value(ptr.convert(), default_value);
+    }
+
+    template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const
+    {
+        return value(ptr.convert(), std::forward<ValueType>(default_value));
+    }
+
+    /// @brief access the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/front/
+    reference front()
+    {
+        return *begin();
+    }
+
+    /// @brief access the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/front/
+    const_reference front() const
+    {
+        return *cbegin();
+    }
+
+    /// @brief access the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/back/
+    reference back()
+    {
+        auto tmp = end();
+        --tmp;
+        return *tmp;
+    }
+
+    /// @brief access the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/back/
+    const_reference back() const
+    {
+        auto tmp = cend();
+        --tmp;
+        return *tmp;
+    }
+
+    /// @brief remove element given an iterator
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template < class IteratorType, detail::enable_if_t <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
+    IteratorType erase(IteratorType pos)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        IteratorType result = end();
+
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
+                {
+                    JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
+                    m_data.m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
+                    m_data.m_value.binary = nullptr;
+                }
+
+                m_data.m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return result;
+    }
+
+    /// @brief remove elements given an iterator range
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template < class IteratorType, detail::enable_if_t <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
+    IteratorType erase(IteratorType first, IteratorType last)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", this));
+        }
+
+        IteratorType result = end();
+
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
+                                       || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", this));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
+                    m_data.m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
+                    m_data.m_value.binary = nullptr;
+                }
+
+                m_data.m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_data.m_value.object->erase(first.m_it.object_iterator,
+                                              last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_data.m_value.array->erase(first.m_it.array_iterator,
+                                             last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return result;
+    }
+
+  private:
+    template < typename KeyType, detail::enable_if_t <
+                   detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    size_type erase_internal(KeyType && key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return m_data.m_value.object->erase(std::forward<KeyType>(key));
+    }
+
+    template < typename KeyType, detail::enable_if_t <
+                   !detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    size_type erase_internal(KeyType && key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        const auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it != m_data.m_value.object->end())
+        {
+            m_data.m_value.object->erase(it);
+            return 1;
+        }
+        return 0;
+    }
+
+  public:
+
+    /// @brief remove element from a JSON object given a key
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    size_type erase(const typename object_t::key_type& key)
+    {
+        // the indirection via erase_internal() is added to avoid making this
+        // function a template and thus de-rank it during overload resolution
+        return erase_internal(key);
+    }
+
+    /// @brief remove element from a JSON object given a key
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    size_type erase(KeyType && key)
+    {
+        return erase_internal(std::forward<KeyType>(key));
+    }
+
+    /// @brief remove element from a JSON array given an index
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    void erase(const size_type idx)
+    {
+        // this erase only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
+            {
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            }
+
+            m_data.m_value.array->erase(m_data.m_value.array->begin() + static_cast<difference_type>(idx));
+        }
+        else
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+    }
+
+    /// @}
+
+    ////////////
+    // lookup //
+    ////////////
+
+    /// @name lookup
+    /// @{
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    iterator find(const typename object_t::key_type& key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(key);
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    const_iterator find(const typename object_t::key_type& key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(key);
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    iterator find(KeyType && key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    const_iterator find(KeyType && key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
+        }
+
+        return result;
+    }
+
+    /// @brief returns the number of occurrences of a key in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/count/
+    size_type count(const typename object_t::key_type& key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_data.m_value.object->count(key) : 0;
+    }
+
+    /// @brief returns the number of occurrences of a key in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/count/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    size_type count(KeyType && key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_data.m_value.object->count(std::forward<KeyType>(key)) : 0;
+    }
+
+    /// @brief check the existence of an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    bool contains(const typename object_t::key_type& key) const
+    {
+        return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
+    }
+
+    /// @brief check the existence of an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    bool contains(KeyType && key) const
+    {
+        return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
+    }
+
+    /// @brief check the existence of an element in a JSON object given a JSON pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    bool contains(const json_pointer& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    /// @}
+
+    ///////////////
+    // iterators //
+    ///////////////
+
+    /// @name iterators
+    /// @{
+
+    /// @brief returns an iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/begin/
+    iterator begin() noexcept
+    {
+        iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /// @brief returns an iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/begin/
+    const_iterator begin() const noexcept
+    {
+        return cbegin();
+    }
+
+    /// @brief returns a const iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/cbegin/
+    const_iterator cbegin() const noexcept
+    {
+        const_iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/end/
+    iterator end() noexcept
+    {
+        iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/end/
+    const_iterator end() const noexcept
+    {
+        return cend();
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/cend/
+    const_iterator cend() const noexcept
+    {
+        const_iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /// @brief returns an iterator to the reverse-beginning
+    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
+    reverse_iterator rbegin() noexcept
+    {
+        return reverse_iterator(end());
+    }
+
+    /// @brief returns an iterator to the reverse-beginning
+    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return crbegin();
+    }
+
+    /// @brief returns an iterator to the reverse-end
+    /// @sa https://json.nlohmann.me/api/basic_json/rend/
+    reverse_iterator rend() noexcept
+    {
+        return reverse_iterator(begin());
+    }
+
+    /// @brief returns an iterator to the reverse-end
+    /// @sa https://json.nlohmann.me/api/basic_json/rend/
+    const_reverse_iterator rend() const noexcept
+    {
+        return crend();
+    }
+
+    /// @brief returns a const reverse iterator to the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/crbegin/
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return const_reverse_iterator(cend());
+    }
+
+    /// @brief returns a const reverse iterator to one before the first
+    /// @sa https://json.nlohmann.me/api/basic_json/crend/
+    const_reverse_iterator crend() const noexcept
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
+  public:
+    /// @brief wrapper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use @ref items() instead;
+    ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /// @brief wrapper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
+    ///         version 4.0.0 of the library. Please use @ref items() instead;
+    ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /// @brief helper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    iteration_proxy<iterator> items() noexcept
+    {
+        return iteration_proxy<iterator>(*this);
+    }
+
+    /// @brief helper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    iteration_proxy<const_iterator> items() const noexcept
+    {
+        return iteration_proxy<const_iterator>(*this);
+    }
+
+    /// @}
+
+    //////////////
+    // capacity //
+    //////////////
+
+    /// @name capacity
+    /// @{
+
+    /// @brief checks whether the container is empty.
+    /// @sa https://json.nlohmann.me/api/basic_json/empty/
+    bool empty() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return true;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::empty()
+                return m_data.m_value.array->empty();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::empty()
+                return m_data.m_value.object->empty();
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types are nonempty
+                return false;
+            }
+        }
+    }
+
+    /// @brief returns the number of elements
+    /// @sa https://json.nlohmann.me/api/basic_json/size/
+    size_type size() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return 0;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::size()
+                return m_data.m_value.array->size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::size()
+                return m_data.m_value.object->size();
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types have size 1
+                return 1;
+            }
+        }
+    }
+
+    /// @brief returns the maximum possible number of elements
+    /// @sa https://json.nlohmann.me/api/basic_json/max_size/
+    size_type max_size() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::array:
+            {
+                // delegate call to array_t::max_size()
+                return m_data.m_value.array->max_size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::max_size()
+                return m_data.m_value.object->max_size();
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types have max_size() == size()
+                return size();
+            }
+        }
+    }
+
+    /// @}
+
+    ///////////////
+    // modifiers //
+    ///////////////
+
+    /// @name modifiers
+    /// @{
+
+    /// @brief clears the contents
+    /// @sa https://json.nlohmann.me/api/basic_json/clear/
+    void clear() noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_data.m_value.number_integer = 0;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value.number_unsigned = 0;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value.number_float = 0.0;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value.boolean = false;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value.string->clear();
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value.binary->clear();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value.array->clear();
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_data.m_value.object->clear();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(basic_json&& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (move semantics)
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->push_back(std::move(val));
+        set_parent(m_data.m_value.array->back(), old_capacity);
+        // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(basic_json&& val)
+    {
+        push_back(std::move(val));
+        return *this;
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(const basic_json& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->push_back(val);
+        set_parent(m_data.m_value.array->back(), old_capacity);
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(const basic_json& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(const typename object_t::value_type& val)
+    {
+        // push_back only works for null objects or objects
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to object
+        auto res = m_data.m_value.object->insert(val);
+        set_parent(res.first->second);
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(const typename object_t::value_type& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(initializer_list_t init)
+    {
+        if (is_object() && init.size() == 2 && (*init.begin())->is_string())
+        {
+            basic_json&& key = init.begin()->moved_or_copied();
+            push_back(typename object_t::value_type(
+                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
+        }
+        else
+        {
+            push_back(basic_json(init));
+        }
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(initializer_list_t init)
+    {
+        push_back(init);
+        return *this;
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
+    template<class... Args>
+    reference emplace_back(Args&& ... args)
+    {
+        // emplace_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
+        return set_parent(m_data.m_value.array->back(), old_capacity);
+    }
+
+    /// @brief add an object to an object if key does not exist
+    /// @sa https://json.nlohmann.me/api/basic_json/emplace/
+    template<class... Args>
+    std::pair<iterator, bool> emplace(Args&& ... args)
+    {
+        // emplace only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace() with ", type_name()), this));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+        auto res = m_data.m_value.object->emplace(std::forward<Args>(args)...);
+        set_parent(res.first->second);
+
+        // create result iterator and set iterator to the result of emplace
+        auto it = begin();
+        it.m_it.object_iterator = res.first;
+
+        // return pair of iterator and boolean
+        return {it, res.second};
+    }
+
+    /// Helper for insertion of an iterator
+    /// @note: This uses std::distance to support GCC 4.8,
+    ///        see https://github.com/nlohmann/json/pull/1257
+    template<typename... Args>
+    iterator insert_iterator(const_iterator pos, Args&& ... args)
+    {
+        iterator result(this);
+        JSON_ASSERT(m_data.m_value.array != nullptr);
+
+        auto insert_pos = std::distance(m_data.m_value.array->begin(), pos.m_it.array_iterator);
+        m_data.m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
+        result.m_it.array_iterator = m_data.m_value.array->begin() + insert_pos;
+
+        // This could have been written as:
+        // result.m_it.array_iterator = m_data.m_value.array->insert(pos.m_it.array_iterator, cnt, val);
+        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
+
+        set_parents();
+        return result;
+    }
+
+    /// @brief inserts element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, val);
+        }
+
+        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+    }
+
+    /// @brief inserts element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, basic_json&& val)
+    {
+        return insert(pos, val);
+    }
+
+    /// @brief inserts copies of element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, cnt, val);
+        }
+
+        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+    }
+
+    /// @brief inserts range of elements into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, const_iterator first, const_iterator last)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
+        {
+            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", this));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
+    }
+
+    /// @brief inserts elements from initializer list into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, initializer_list_t ilist)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, ilist.begin(), ilist.end());
+    }
+
+    /// @brief inserts range of elements into object
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    void insert(const_iterator first, const_iterator last)
+    {
+        // insert only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", this));
+        }
+
+        m_data.m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
+    }
+
+    /// @brief updates a JSON object from another object, overwriting existing keys
+    /// @sa https://json.nlohmann.me/api/basic_json/update/
+    void update(const_reference j, bool merge_objects = false)
+    {
+        update(j.begin(), j.end(), merge_objects);
+    }
+
+    /// @brief updates a JSON object from another object, overwriting existing keys
+    /// @sa https://json.nlohmann.me/api/basic_json/update/
+    void update(const_iterator first, const_iterator last, bool merge_objects = false)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", type_name()), this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
+        }
+
+        for (auto it = first; it != last; ++it)
+        {
+            if (merge_objects && it.value().is_object())
+            {
+                auto it2 = m_data.m_value.object->find(it.key());
+                if (it2 != m_data.m_value.object->end())
+                {
+                    it2->second.update(it.value(), true);
+                    continue;
+                }
+            }
+            m_data.m_value.object->operator[](it.key()) = it.value();
+#if JSON_DIAGNOSTICS
+            m_data.m_value.object->operator[](it.key()).m_parent = this;
+#endif
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(reference other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        std::swap(m_data.m_type, other.m_data.m_type);
+        std::swap(m_data.m_value, other.m_data.m_value);
+
+        set_parents();
+        other.set_parents();
+        assert_invariant();
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    friend void swap(reference left, reference right) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        left.swap(right);
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(array_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.array), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(array_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(object_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.object), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(object_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(string_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_string()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.string), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(string_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(binary_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t::container_type&) with ", type_name()), this));
+        }
+    }
+
+    /// @}
+
+    //////////////////////////////////////////
+    // lexicographical comparison operators //
+    //////////////////////////////////////////
+
+    /// @name lexicographical comparison operators
+    /// @{
+
+    // note parentheses around operands are necessary; see
+    // https://github.com/nlohmann/json/issues/1530
+#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result)                       \
+    const auto lhs_type = lhs.type();                                                                    \
+    const auto rhs_type = rhs.type();                                                                    \
+    \
+    if (lhs_type == rhs_type) /* NOLINT(readability/braces) */                                           \
+    {                                                                                                    \
+        switch (lhs_type)                                                                                \
+        {                                                                                                \
+            case value_t::array:                                                                         \
+                return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array);                                     \
+                \
+            case value_t::object:                                                                        \
+                return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object);                                   \
+                \
+            case value_t::null:                                                                          \
+                return (null_result);                                                                    \
+                \
+            case value_t::string:                                                                        \
+                return (*lhs.m_data.m_value.string) op (*rhs.m_data.m_value.string);                                   \
+                \
+            case value_t::boolean:                                                                       \
+                return (lhs.m_data.m_value.boolean) op (rhs.m_data.m_value.boolean);                                   \
+                \
+            case value_t::number_integer:                                                                \
+                return (lhs.m_data.m_value.number_integer) op (rhs.m_data.m_value.number_integer);                     \
+                \
+            case value_t::number_unsigned:                                                               \
+                return (lhs.m_data.m_value.number_unsigned) op (rhs.m_data.m_value.number_unsigned);                   \
+                \
+            case value_t::number_float:                                                                  \
+                return (lhs.m_data.m_value.number_float) op (rhs.m_data.m_value.number_float);                         \
+                \
+            case value_t::binary:                                                                        \
+                return (*lhs.m_data.m_value.binary) op (*rhs.m_data.m_value.binary);                                   \
+                \
+            case value_t::discarded:                                                                     \
+            default:                                                                                     \
+                return (unordered_result);                                                               \
+        }                                                                                                \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)                   \
+    {                                                                                                    \
+        return static_cast<number_float_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float;      \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)                   \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_integer);      \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)                  \
+    {                                                                                                    \
+        return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float;     \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)                  \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_unsigned);     \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)                \
+    {                                                                                                    \
+        return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_integer; \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)                \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>(rhs.m_data.m_value.number_unsigned); \
+    }                                                                                                    \
+    else if(compares_unordered(lhs, rhs))\
+    {\
+        return (unordered_result);\
+    }\
+    \
+    return (default_result);
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // returns true if:
+    // - any operand is NaN and the other operand is of number type
+    // - any operand is discarded
+    // in legacy mode, discarded values are considered ordered if
+    // an operation is computed as an odd number of inverses of others
+    static bool compares_unordered(const_reference lhs, const_reference rhs, bool inverse = false) noexcept
+    {
+        if ((lhs.is_number_float() && std::isnan(lhs.m_data.m_value.number_float) && rhs.is_number())
+                || (rhs.is_number_float() && std::isnan(rhs.m_data.m_value.number_float) && lhs.is_number()))
+        {
+            return true;
+        }
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+        return (lhs.is_discarded() || rhs.is_discarded()) && !inverse;
+#else
+        static_cast<void>(inverse);
+        return lhs.is_discarded() || rhs.is_discarded();
+#endif
+    }
+
+  private:
+    bool compares_unordered(const_reference rhs, bool inverse = false) const noexcept
+    {
+        return compares_unordered(*this, rhs, inverse);
+    }
+
+  public:
+#if JSON_HAS_THREE_WAY_COMPARISON
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    bool operator==(const_reference rhs) const noexcept
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        const_reference lhs = *this;
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator==(ScalarType rhs) const noexcept
+    {
+        return *this == basic_json(rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    bool operator!=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !operator==(rhs);
+    }
+
+    /// @brief comparison: 3-way
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
+    std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD*
+    {
+        const_reference lhs = *this;
+        // default_result is used if we cannot compare values. In that case,
+        // we compare types.
+        JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*
+                                std::partial_ordering::equivalent,
+                                std::partial_ordering::unordered,
+                                lhs_type <=> rhs_type) // *NOPAD*
+    }
+
+    /// @brief comparison: 3-way
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    std::partial_ordering operator<=>(ScalarType rhs) const noexcept // *NOPAD*
+    {
+        return *this <=> basic_json(rhs); // *NOPAD*
+    }
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    // all operators that are computed as an odd number of inverses of others
+    // need to be overloaded to emulate the legacy comparison behavior
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
+    bool operator<=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !(rhs < *this);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator<=(ScalarType rhs) const noexcept
+    {
+        return *this <= basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
+    bool operator>=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !(*this < rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator>=(ScalarType rhs) const noexcept
+    {
+        return *this >= basic_json(rhs);
+    }
+#endif
+#else
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs == basic_json(rhs);
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) == rhs;
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(lhs == rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs != basic_json(rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) != rhs;
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
+    {
+        // default_result is used if we cannot compare values. In that case,
+        // we compare types. Note we have to call the operator explicitly,
+        // because MSVC has problems otherwise.
+        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type))
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs < basic_json(rhs);
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) < rhs;
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(rhs < lhs);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs <= basic_json(rhs);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) <= rhs;
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
+    {
+        // double inverse
+        if (compares_unordered(lhs, rhs))
+        {
+            return false;
+        }
+        return !(lhs <= rhs);
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs > basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) > rhs;
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(lhs < rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs >= basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) >= rhs;
+    }
+#endif
+
+#undef JSON_IMPLEMENT_OPERATOR
+
+    /// @}
+
+    ///////////////////
+    // serialization //
+    ///////////////////
+
+    /// @name serialization
+    /// @{
+#ifndef JSON_NO_IO
+    /// @brief serialize to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
+    {
+        // read width member and use it as indentation parameter if nonzero
+        const bool pretty_print = o.width() > 0;
+        const auto indentation = pretty_print ? o.width() : 0;
+
+        // reset width to 0 for subsequent calls to this stream
+        o.width(0);
+
+        // do the actual serialization
+        serializer s(detail::output_adapter<char>(o), o.fill());
+        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
+        return o;
+    }
+
+    /// @brief serialize to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    /// @deprecated This function is deprecated since 3.0.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             operator<<(std::ostream&, const basic_json&) instead; that is,
+    ///             replace calls like `j >> o;` with `o << j;`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
+    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
+    {
+        return o << j;
+    }
+#endif  // JSON_NO_IO
+    /// @}
+
+    /////////////////////
+    // deserialization //
+    /////////////////////
+
+    /// @name deserialization
+    /// @{
+
+    /// @brief deserialize from a compatible input
+    /// @sa https://json.nlohmann.me/api/basic_json/parse/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(InputType&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    /// @brief deserialize from a pair of character iterators
+    /// @sa https://json.nlohmann.me/api/basic_json/parse/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(IteratorType first,
+                            IteratorType last,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
+    static basic_json parse(detail::span_input_adapter&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    /// @brief check if the input is valid JSON
+    /// @sa https://json.nlohmann.me/api/basic_json/accept/
+    template<typename InputType>
+    static bool accept(InputType&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    /// @brief check if the input is valid JSON
+    /// @sa https://json.nlohmann.me/api/basic_json/accept/
+    template<typename IteratorType>
+    static bool accept(IteratorType first, IteratorType last,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
+    static bool accept(detail::span_input_adapter&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(i.get(), nullptr, false, ignore_comments).accept(true);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    template <typename InputType, typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(InputType&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    template<class IteratorType, class SAX>
+    JSON_HEDLEY_NON_NULL(3)
+    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    /// @deprecated This function is deprecated since 3.8.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             sax_parse(ptr, ptr + len) instead.
+    template <typename SAX>
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = i.get();
+        return format == input_format_t::json
+               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+#ifndef JSON_NO_IO
+    /// @brief deserialize from stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
+    /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             operator>>(std::istream&, basic_json&) instead; that is,
+    ///             replace calls like `j << i;` with `i >> j;`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
+    friend std::istream& operator<<(basic_json& j, std::istream& i)
+    {
+        return operator>>(i, j);
+    }
+
+    /// @brief deserialize from stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
+    friend std::istream& operator>>(std::istream& i, basic_json& j)
+    {
+        parser(detail::input_adapter(i)).parse(false, j);
+        return i;
+    }
+#endif  // JSON_NO_IO
+    /// @}
+
+    ///////////////////////////
+    // convenience functions //
+    ///////////////////////////
+
+    /// @brief return the type as string
+    /// @sa https://json.nlohmann.me/api/basic_json/type_name/
+    JSON_HEDLEY_RETURNS_NON_NULL
+    const char* type_name() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+                return "null";
+            case value_t::object:
+                return "object";
+            case value_t::array:
+                return "array";
+            case value_t::string:
+                return "string";
+            case value_t::boolean:
+                return "boolean";
+            case value_t::binary:
+                return "binary";
+            case value_t::discarded:
+                return "discarded";
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            default:
+                return "number";
+        }
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    //////////////////////
+    // member variables //
+    //////////////////////
+
+    struct data
+    {
+        /// the type of the current element
+        value_t m_type = value_t::null;
+
+        /// the value of the current element
+        json_value m_value = {};
+
+        data(const value_t v)
+            : m_type(v), m_value(v)
+        {
+        }
+
+        data(size_type cnt, const basic_json& val)
+            : m_type(value_t::array)
+        {
+            m_value.array = create<array_t>(cnt, val);
+        }
+
+        data() noexcept = default;
+        data(data&&) noexcept = default;
+        data(const data&) noexcept = delete;
+        data& operator=(data&&) noexcept = delete;
+        data& operator=(const data&) noexcept = delete;
+
+        ~data() noexcept
+        {
+            m_value.destroy(m_type);
+        }
+    };
+
+    data m_data = {};
+
+#if JSON_DIAGNOSTICS
+    /// a pointer to a parent value (for debugging purposes)
+    basic_json* m_parent = nullptr;
+#endif
+
+    //////////////////////////////////////////
+    // binary serialization/deserialization //
+    //////////////////////////////////////////
+
+    /// @name binary serialization/deserialization support
+    /// @{
+
+  public:
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static std::vector<std::uint8_t> to_cbor(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_cbor(j, result);
+        return result;
+    }
+
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_cbor(j);
+    }
+
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_cbor(j);
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_msgpack(j, result);
+        return result;
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_msgpack(j);
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_msgpack(j);
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
+            const bool use_size = false,
+            const bool use_type = false)
+    {
+        std::vector<std::uint8_t> result;
+        to_ubjson(j, result, use_size, use_type);
+        return result;
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
+            const bool use_size = false,
+            const bool use_type = false)
+    {
+        std::vector<std::uint8_t> result;
+        to_bjdata(j, result, use_size, use_type);
+        return result;
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true, true);
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type, true, true);
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static std::vector<std::uint8_t> to_bson(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_bson(j, result);
+        return result;
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_bson(j);
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_bson(j);
+    }
+
+    /// @brief create a JSON value from an input in CBOR format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in CBOR format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in MessagePack format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(InputType&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in MessagePack format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(IteratorType first, IteratorType last,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(const T* ptr, std::size_t len,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(detail::span_input_adapter&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in UBJSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(InputType&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in UBJSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(IteratorType first, IteratorType last,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(const T* ptr, std::size_t len,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(detail::span_input_adapter&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BJData format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bjdata(InputType&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BJData format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bjdata(IteratorType first, IteratorType last,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        return from_bson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+    /// @}
+
+    //////////////////////////
+    // JSON Pointer support //
+    //////////////////////////
+
+    /// @name JSON Pointer functions
+    /// @{
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](const json_pointer& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](const json_pointer& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(const json_pointer& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(const json_pointer& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    /// @brief return flattened JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/flatten/
+    basic_json flatten() const
+    {
+        basic_json result(value_t::object);
+        json_pointer::flatten("", *this, result);
+        return result;
+    }
+
+    /// @brief unflatten a previously flattened JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/unflatten/
+    basic_json unflatten() const
+    {
+        return json_pointer::unflatten(*this);
+    }
+
+    /// @}
+
+    //////////////////////////
+    // JSON Patch functions //
+    //////////////////////////
+
+    /// @name JSON Patch functions
+    /// @{
+
+    /// @brief applies a JSON patch in-place without copying the object
+    /// @sa https://json.nlohmann.me/api/basic_json/patch/
+    void patch_inplace(const basic_json& json_patch)
+    {
+        basic_json& result = *this;
+        // the valid JSON Patch operations
+        enum class patch_operations {add, remove, replace, move, copy, test, invalid};
+
+        const auto get_op = [](const std::string & op)
+        {
+            if (op == "add")
+            {
+                return patch_operations::add;
+            }
+            if (op == "remove")
+            {
+                return patch_operations::remove;
+            }
+            if (op == "replace")
+            {
+                return patch_operations::replace;
+            }
+            if (op == "move")
+            {
+                return patch_operations::move;
+            }
+            if (op == "copy")
+            {
+                return patch_operations::copy;
+            }
+            if (op == "test")
+            {
+                return patch_operations::test;
+            }
+
+            return patch_operations::invalid;
+        };
+
+        // wrapper for "add" operation; add value at ptr
+        const auto operation_add = [&result](json_pointer & ptr, basic_json val)
+        {
+            // adding to the root of the target document means replacing it
+            if (ptr.empty())
+            {
+                result = val;
+                return;
+            }
+
+            // make sure the top element of the pointer exists
+            json_pointer const top_pointer = ptr.top();
+            if (top_pointer != ptr)
+            {
+                result.at(top_pointer);
+            }
+
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            // parent must exist when performing patch add per RFC6902 specs
+            basic_json& parent = result.at(ptr);
+
+            switch (parent.m_data.m_type)
+            {
+                case value_t::null:
+                case value_t::object:
+                {
+                    // use operator[] to add value
+                    parent[last_path] = val;
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    if (last_path == "-")
+                    {
+                        // special case: append to back
+                        parent.push_back(val);
+                    }
+                    else
+                    {
+                        const auto idx = json_pointer::template array_index<basic_json_t>(last_path);
+                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
+                        {
+                            // avoid undefined behavior
+                            JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent));
+                        }
+
+                        // default case: insert add offset
+                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
+                    }
+                    break;
+                }
+
+                // if there exists a parent it cannot be primitive
+                case value_t::string: // LCOV_EXCL_LINE
+                case value_t::boolean: // LCOV_EXCL_LINE
+                case value_t::number_integer: // LCOV_EXCL_LINE
+                case value_t::number_unsigned: // LCOV_EXCL_LINE
+                case value_t::number_float: // LCOV_EXCL_LINE
+                case value_t::binary: // LCOV_EXCL_LINE
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            }
+        };
+
+        // wrapper for "remove" operation; remove value at ptr
+        const auto operation_remove = [this, & result](json_pointer & ptr)
+        {
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            basic_json& parent = result.at(ptr);
+
+            // remove child
+            if (parent.is_object())
+            {
+                // perform range check
+                auto it = parent.find(last_path);
+                if (JSON_HEDLEY_LIKELY(it != parent.end()))
+                {
+                    parent.erase(it);
+                }
+                else
+                {
+                    JSON_THROW(out_of_range::create(403, detail::concat("key '", last_path, "' not found"), this));
+                }
+            }
+            else if (parent.is_array())
+            {
+                // note erase performs range check
+                parent.erase(json_pointer::template array_index<basic_json_t>(last_path));
+            }
+        };
+
+        // type check: top level value must be an array
+        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
+        {
+            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &json_patch));
+        }
+
+        // iterate and apply the operations
+        for (const auto& val : json_patch)
+        {
+            // wrapper to get a value for an operation
+            const auto get_value = [&val](const std::string & op,
+                                          const std::string & member,
+                                          bool string_type) -> basic_json &
+            {
+                // find value
+                auto it = val.m_data.m_value.object->find(member);
+
+                // context-sensitive error message
+                const auto error_msg = (op == "op") ? "operation" : detail::concat("operation '", op, '\'');
+
+                // check if desired value is present
+                if (JSON_HEDLEY_UNLIKELY(it == val.m_data.m_value.object->end()))
+                {
+                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
+                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have member '", member, "'"), &val));
+                }
+
+                // check if result is of type string
+                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
+                {
+                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
+                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have string member '", member, "'"), &val));
+                }
+
+                // no error: return value
+                return it->second;
+            };
+
+            // type check: every element of the array must be an object
+            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
+            {
+                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &val));
+            }
+
+            // collect mandatory members
+            const auto op = get_value("op", "op", true).template get<std::string>();
+            const auto path = get_value(op, "path", true).template get<std::string>();
+            json_pointer ptr(path);
+
+            switch (get_op(op))
+            {
+                case patch_operations::add:
+                {
+                    operation_add(ptr, get_value("add", "value", false));
+                    break;
+                }
+
+                case patch_operations::remove:
+                {
+                    operation_remove(ptr);
+                    break;
+                }
+
+                case patch_operations::replace:
+                {
+                    // the "path" location must exist - use at()
+                    result.at(ptr) = get_value("replace", "value", false);
+                    break;
+                }
+
+                case patch_operations::move:
+                {
+                    const auto from_path = get_value("move", "from", true).template get<std::string>();
+                    json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json const v = result.at(from_ptr);
+
+                    // The move operation is functionally identical to a
+                    // "remove" operation on the "from" location, followed
+                    // immediately by an "add" operation at the target
+                    // location with the value that was just removed.
+                    operation_remove(from_ptr);
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::copy:
+                {
+                    const auto from_path = get_value("copy", "from", true).template get<std::string>();
+                    const json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json const v = result.at(from_ptr);
+
+                    // The copy is functionally identical to an "add"
+                    // operation at the target location using the value
+                    // specified in the "from" member.
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::test:
+                {
+                    bool success = false;
+                    JSON_TRY
+                    {
+                        // check if "value" matches the one at "path"
+                        // the "path" location must exist - use at()
+                        success = (result.at(ptr) == get_value("test", "value", false));
+                    }
+                    JSON_INTERNAL_CATCH (out_of_range&)
+                    {
+                        // ignore out of range errors: success remains false
+                    }
+
+                    // throw an exception if test fails
+                    if (JSON_HEDLEY_UNLIKELY(!success))
+                    {
+                        JSON_THROW(other_error::create(501, detail::concat("unsuccessful: ", val.dump()), &val));
+                    }
+
+                    break;
+                }
+
+                case patch_operations::invalid:
+                default:
+                {
+                    // op must be "add", "remove", "replace", "move", "copy", or
+                    // "test"
+                    JSON_THROW(parse_error::create(105, 0, detail::concat("operation value '", op, "' is invalid"), &val));
+                }
+            }
+        }
+    }
+
+    /// @brief applies a JSON patch to a copy of the current object
+    /// @sa https://json.nlohmann.me/api/basic_json/patch/
+    basic_json patch(const basic_json& json_patch) const
+    {
+        basic_json result = *this;
+        result.patch_inplace(json_patch);
+        return result;
+    }
+
+    /// @brief creates a diff as a JSON patch
+    /// @sa https://json.nlohmann.me/api/basic_json/diff/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json diff(const basic_json& source, const basic_json& target,
+                           const std::string& path = "")
+    {
+        // the patch
+        basic_json result(value_t::array);
+
+        // if the values are the same, return empty patch
+        if (source == target)
+        {
+            return result;
+        }
+
+        if (source.type() != target.type())
+        {
+            // different types: replace value
+            result.push_back(
+            {
+                {"op", "replace"}, {"path", path}, {"value", target}
+            });
+            return result;
+        }
+
+        switch (source.type())
+        {
+            case value_t::array:
+            {
+                // first pass: traverse common elements
+                std::size_t i = 0;
+                while (i < source.size() && i < target.size())
+                {
+                    // recursive call to compare array values at index i
+                    auto temp_diff = diff(source[i], target[i], detail::concat(path, '/', std::to_string(i)));
+                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    ++i;
+                }
+
+                // We now reached the end of at least one array
+                // in a second pass, traverse the remaining elements
+
+                // remove my remaining elements
+                const auto end_index = static_cast<difference_type>(result.size());
+                while (i < source.size())
+                {
+                    // add operations in reverse order to avoid invalid
+                    // indices
+                    result.insert(result.begin() + end_index, object(
+                    {
+                        {"op", "remove"},
+                        {"path", detail::concat(path, '/', std::to_string(i))}
+                    }));
+                    ++i;
+                }
+
+                // add other remaining elements
+                while (i < target.size())
+                {
+                    result.push_back(
+                    {
+                        {"op", "add"},
+                        {"path", detail::concat(path, "/-")},
+                        {"value", target[i]}
+                    });
+                    ++i;
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // first pass: traverse this object's elements
+                for (auto it = source.cbegin(); it != source.cend(); ++it)
+                {
+                    // escape the key name to be used in a JSON patch
+                    const auto path_key = detail::concat(path, '/', detail::escape(it.key()));
+
+                    if (target.find(it.key()) != target.end())
+                    {
+                        // recursive call to compare object values at key it
+                        auto temp_diff = diff(it.value(), target[it.key()], path_key);
+                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    }
+                    else
+                    {
+                        // found a key that is not in o -> remove it
+                        result.push_back(object(
+                        {
+                            {"op", "remove"}, {"path", path_key}
+                        }));
+                    }
+                }
+
+                // second pass: traverse other object's elements
+                for (auto it = target.cbegin(); it != target.cend(); ++it)
+                {
+                    if (source.find(it.key()) == source.end())
+                    {
+                        // found a key that is not in this -> add it
+                        const auto path_key = detail::concat(path, '/', detail::escape(it.key()));
+                        result.push_back(
+                        {
+                            {"op", "add"}, {"path", path_key},
+                            {"value", it.value()}
+                        });
+                    }
+                }
+
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // both primitive type: replace value
+                result.push_back(
+                {
+                    {"op", "replace"}, {"path", path}, {"value", target}
+                });
+                break;
+            }
+        }
+
+        return result;
+    }
+    /// @}
+
+    ////////////////////////////////
+    // JSON Merge Patch functions //
+    ////////////////////////////////
+
+    /// @name JSON Merge Patch functions
+    /// @{
+
+    /// @brief applies a JSON Merge Patch
+    /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
+    void merge_patch(const basic_json& apply_patch)
+    {
+        if (apply_patch.is_object())
+        {
+            if (!is_object())
+            {
+                *this = object();
+            }
+            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
+            {
+                if (it.value().is_null())
+                {
+                    erase(it.key());
+                }
+                else
+                {
+                    operator[](it.key()).merge_patch(it.value());
+                }
+            }
+        }
+        else
+        {
+            *this = apply_patch;
+        }
+    }
+
+    /// @}
+};
+
+/// @brief user-defined to_string function for JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/to_string/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
+{
+    return j.dump();
+}
+
+inline namespace literals
+{
+inline namespace json_literals
+{
+
+/// @brief user-defined string literal for JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
+JSON_HEDLEY_NON_NULL(1)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json operator ""_json(const char* s, std::size_t n)
+#else
+    inline nlohmann::json operator "" _json(const char* s, std::size_t n)
+#endif
+{
+    return nlohmann::json::parse(s, s + n);
+}
+
+/// @brief user-defined string literal for JSON pointer
+/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
+JSON_HEDLEY_NON_NULL(1)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json::json_pointer operator ""_json_pointer(const char* s, std::size_t n)
+#else
+    inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
+#endif
+{
+    return nlohmann::json::json_pointer(std::string(s, n));
+}
+
+}  // namespace json_literals
+}  // namespace literals
+NLOHMANN_JSON_NAMESPACE_END
+
+///////////////////////
+// nonmember support //
+///////////////////////
+
+namespace std // NOLINT(cert-dcl58-cpp)
+{
+
+/// @brief hash value for JSON objects
+/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp)
+{
+    std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
+    {
+        return nlohmann::detail::hash(j);
+    }
+};
+
+// specialization for std::less<value_t>
+template<>
+struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
+{
+    /*!
+    @brief compare two value_t enum values
+    @since version 3.0.0
+    */
+    bool operator()(::nlohmann::detail::value_t lhs,
+                    ::nlohmann::detail::value_t rhs) const noexcept
+    {
+#if JSON_HAS_THREE_WAY_COMPARISON
+        return std::is_lt(lhs <=> rhs); // *NOPAD*
+#else
+        return ::nlohmann::detail::operator<(lhs, rhs);
+#endif
+    }
+};
+
+// C++20 prohibit function specialization in the std namespace.
+#ifndef JSON_HAS_CPP_20
+
+/// @brief exchanges the values of two JSON objects
+/// @sa https://json.nlohmann.me/api/basic_json/std_swap/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp)
+    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
+{
+    j1.swap(j2);
+}
+
+#endif
+
+}  // namespace std
+
+#if JSON_USE_GLOBAL_UDLS
+    #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+        using nlohmann::literals::json_literals::operator ""_json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator ""_json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #else
+        using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #endif
+#endif
+
+#include <nlohmann/detail/macro_unscope.hpp>
+
+#endif  // INCLUDE_NLOHMANN_JSON_HPP_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/json_fwd.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/json_fwd.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..32bde590f8cc445820fb02b3cd100ca1f736e5af
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/json_fwd.hpp
@@ -0,0 +1,75 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
+#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+#include <cstdint> // int64_t, uint64_t
+#include <map> // map
+#include <memory> // allocator
+#include <string> // string
+#include <vector> // vector
+
+#include <nlohmann/detail/abi_macros.hpp>
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/*!
+@brief default JSONSerializer template argument
+
+This serializer ignores the template arguments and uses ADL
+([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
+for serialization.
+*/
+template<typename T = void, typename SFINAE = void>
+struct adl_serializer;
+
+/// a class to store JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/
+template<template<typename U, typename V, typename... Args> class ObjectType =
+         std::map,
+         template<typename U, typename... Args> class ArrayType = std::vector,
+         class StringType = std::string, class BooleanType = bool,
+         class NumberIntegerType = std::int64_t,
+         class NumberUnsignedType = std::uint64_t,
+         class NumberFloatType = double,
+         template<typename U> class AllocatorType = std::allocator,
+         template<typename T, typename SFINAE = void> class JSONSerializer =
+         adl_serializer,
+         class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
+         class CustomBaseClass = void>
+class basic_json;
+
+/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+/// @sa https://json.nlohmann.me/api/json_pointer/
+template<typename RefStringType>
+class json_pointer;
+
+/*!
+@brief default specialization
+@sa https://json.nlohmann.me/api/json/
+*/
+using json = basic_json<>;
+
+/// @brief a minimal map-like container that preserves insertion order
+/// @sa https://json.nlohmann.me/api/ordered_map/
+template<class Key, class T, class IgnoredLess, class Allocator>
+struct ordered_map;
+
+/// @brief specialization that maintains the insertion order of object keys
+/// @sa https://json.nlohmann.me/api/ordered_json/
+using ordered_json = basic_json<nlohmann::ordered_map>;
+
+NLOHMANN_JSON_NAMESPACE_END
+
+#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/ordered_map.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/ordered_map.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..39e4a50a149683fe3bc74a9e123b37e58be31162
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/ordered_map.hpp
@@ -0,0 +1,359 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <functional> // equal_to, less
+#include <initializer_list> // initializer_list
+#include <iterator> // input_iterator_tag, iterator_traits
+#include <memory> // allocator
+#include <stdexcept> // for out_of_range
+#include <type_traits> // enable_if, is_convertible
+#include <utility> // pair
+#include <vector> // vector
+
+#include <nlohmann/detail/macro_scope.hpp>
+#include <nlohmann/detail/meta/type_traits.hpp>
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// ordered_map: a minimal map-like container that preserves insertion order
+/// for use within nlohmann::basic_json<ordered_map>
+template <class Key, class T, class IgnoredLess = std::less<Key>,
+          class Allocator = std::allocator<std::pair<const Key, T>>>
+                  struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
+{
+    using key_type = Key;
+    using mapped_type = T;
+    using Container = std::vector<std::pair<const Key, T>, Allocator>;
+    using iterator = typename Container::iterator;
+    using const_iterator = typename Container::const_iterator;
+    using size_type = typename Container::size_type;
+    using value_type = typename Container::value_type;
+#ifdef JSON_HAS_CPP_14
+    using key_compare = std::equal_to<>;
+#else
+    using key_compare = std::equal_to<Key>;
+#endif
+
+    // Explicit constructors instead of `using Container::Container`
+    // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
+    ordered_map() noexcept(noexcept(Container())) : Container{} {}
+    explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container(alloc))) : Container{alloc} {}
+    template <class It>
+    ordered_map(It first, It last, const Allocator& alloc = Allocator())
+        : Container{first, last, alloc} {}
+    ordered_map(std::initializer_list<value_type> init, const Allocator& alloc = Allocator() )
+        : Container{init, alloc} {}
+
+    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return {it, false};
+            }
+        }
+        Container::emplace_back(key, std::forward<T>(t));
+        return {std::prev(this->end()), true};
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    std::pair<iterator, bool> emplace(KeyType && key, T && t)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return {it, false};
+            }
+        }
+        Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
+        return {std::prev(this->end()), true};
+    }
+
+    T& operator[](const key_type& key)
+    {
+        return emplace(key, T{}).first->second;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    T & operator[](KeyType && key)
+    {
+        return emplace(std::forward<KeyType>(key), T{}).first->second;
+    }
+
+    const T& operator[](const key_type& key) const
+    {
+        return at(key);
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    const T & operator[](KeyType && key) const
+    {
+        return at(std::forward<KeyType>(key));
+    }
+
+    T& at(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    T & at(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    const T& at(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    const T & at(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    size_type erase(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator erase(iterator pos)
+    {
+        return erase(pos, std::next(pos));
+    }
+
+    iterator erase(iterator first, iterator last)
+    {
+        if (first == last)
+        {
+            return first;
+        }
+
+        const auto elements_affected = std::distance(first, last);
+        const auto offset = std::distance(Container::begin(), first);
+
+        // This is the start situation. We need to delete elements_affected
+        // elements (3 in this example: e, f, g), and need to return an
+        // iterator past the last deleted element (h in this example).
+        // Note that offset is the distance from the start of the vector
+        // to first. We will need this later.
+
+        // [ a, b, c, d, e, f, g, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // Since we cannot move const Keys, we re-construct them in place.
+        // We start at first and re-construct (viz. copy) the elements from
+        // the back of the vector. Example for first iteration:
+
+        //               ,--------.
+        //               v        |   destroy e and re-construct with h
+        // [ a, b, c, d, e, f, g, h, i, j ]
+        //               ^        ^
+        //               it       it + elements_affected
+
+        for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
+        {
+            it->~value_type(); // destroy but keep allocation
+            new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
+        }
+
+        // [ a, b, c, d, h, i, j, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // remove the unneeded elements at the end of the vector
+        Container::resize(this->size() - static_cast<size_type>(elements_affected));
+
+        // [ a, b, c, d, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // first is now pointing past the last deleted element, but we cannot
+        // use this iterator, because it may have been invalidated by the
+        // resize call. Instead, we can return begin() + offset.
+        return Container::begin() + offset;
+    }
+
+    size_type count(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    size_type count(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator find(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    const_iterator find(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    std::pair<iterator, bool> insert( value_type&& value )
+    {
+        return emplace(value.first, std::move(value.second));
+    }
+
+    std::pair<iterator, bool> insert( const value_type& value )
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, value.first))
+            {
+                return {it, false};
+            }
+        }
+        Container::push_back(value);
+        return {--this->end(), true};
+    }
+
+    template<typename InputIt>
+    using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
+            std::input_iterator_tag>::value>::type;
+
+    template<typename InputIt, typename = require_input_iter<InputIt>>
+    void insert(InputIt first, InputIt last)
+    {
+        for (auto it = first; it != last; ++it)
+        {
+            insert(*it);
+        }
+    }
+
+private:
+    JSON_NO_UNIQUE_ADDRESS key_compare m_compare = key_compare();
+};
+
+NLOHMANN_JSON_NAMESPACE_END
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/thirdparty/hedley/hedley.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/thirdparty/hedley/hedley.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..a1dc64f60063dd29778f5357207b89562263fc70
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/thirdparty/hedley/hedley.hpp
@@ -0,0 +1,2045 @@
+#pragma once
+
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson <evan@nemerson.com>
+// SPDX-License-Identifier: MIT
+
+/* Hedley - https://nemequ.github.io/hedley
+ * Created by Evan Nemerson <evan@nemerson.com>
+ */
+
+#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
+#if defined(JSON_HEDLEY_VERSION)
+    #undef JSON_HEDLEY_VERSION
+#endif
+#define JSON_HEDLEY_VERSION 15
+
+#if defined(JSON_HEDLEY_STRINGIFY_EX)
+    #undef JSON_HEDLEY_STRINGIFY_EX
+#endif
+#define JSON_HEDLEY_STRINGIFY_EX(x) #x
+
+#if defined(JSON_HEDLEY_STRINGIFY)
+    #undef JSON_HEDLEY_STRINGIFY
+#endif
+#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
+
+#if defined(JSON_HEDLEY_CONCAT_EX)
+    #undef JSON_HEDLEY_CONCAT_EX
+#endif
+#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
+
+#if defined(JSON_HEDLEY_CONCAT)
+    #undef JSON_HEDLEY_CONCAT
+#endif
+#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
+
+#if defined(JSON_HEDLEY_CONCAT3_EX)
+    #undef JSON_HEDLEY_CONCAT3_EX
+#endif
+#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
+
+#if defined(JSON_HEDLEY_CONCAT3)
+    #undef JSON_HEDLEY_CONCAT3
+#endif
+#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
+
+#if defined(JSON_HEDLEY_VERSION_ENCODE)
+    #undef JSON_HEDLEY_VERSION_ENCODE
+#endif
+#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
+    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
+
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #undef JSON_HEDLEY_GNUC_VERSION
+#endif
+#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#elif defined(__GNUC__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION)
+    #undef JSON_HEDLEY_MSVC_VERSION
+#endif
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
+#elif defined(_MSC_FULL_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
+#elif defined(_MSC_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#endif
+#if !defined(JSON_HEDLEY_MSVC_VERSION)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
+#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
+#else
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #undef JSON_HEDLEY_INTEL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
+#elif defined(__INTEL_COMPILER) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
+    #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #undef JSON_HEDLEY_PGI_VERSION
+#endif
+#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
+    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
+    #undef JSON_HEDLEY_PGI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #undef JSON_HEDLEY_SUNPRO_VERSION
+#endif
+#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
+#elif defined(__SUNPRO_C)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
+#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
+#elif defined(__SUNPRO_CC)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
+    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#endif
+#if defined(__EMSCRIPTEN__)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #undef JSON_HEDLEY_ARM_VERSION
+#endif
+#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
+#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
+    #undef JSON_HEDLEY_ARM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #undef JSON_HEDLEY_IBM_VERSION
+#endif
+#if defined(__ibmxl__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
+#elif defined(__xlC__) && defined(__xlC_ver__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
+#elif defined(__xlC__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
+    #undef JSON_HEDLEY_IBM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #undef JSON_HEDLEY_TI_VERSION
+#endif
+#if \
+    defined(__TI_COMPILER_VERSION__) && \
+    ( \
+      defined(__TMS470__) || defined(__TI_ARM__) || \
+      defined(__MSP430__) || \
+      defined(__TMS320C2000__) \
+    )
+#if (__TI_COMPILER_VERSION__ >= 16000000)
+    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
+    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #undef JSON_HEDLEY_TI_CL430_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
+    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
+    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
+    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
+    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #undef JSON_HEDLEY_CRAY_VERSION
+#endif
+#if defined(_CRAYC)
+    #if defined(_RELEASE_PATCHLEVEL)
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
+    #else
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
+    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #undef JSON_HEDLEY_IAR_VERSION
+#endif
+#if defined(__IAR_SYSTEMS_ICC__)
+    #if __VER__ > 1000
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
+    #else
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
+    #undef JSON_HEDLEY_IAR_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #undef JSON_HEDLEY_TINYC_VERSION
+#endif
+#if defined(__TINYC__)
+    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
+    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #undef JSON_HEDLEY_DMC_VERSION
+#endif
+#if defined(__DMC__)
+    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
+    #undef JSON_HEDLEY_DMC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #undef JSON_HEDLEY_COMPCERT_VERSION
+#endif
+#if defined(__COMPCERT_VERSION__)
+    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
+    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #undef JSON_HEDLEY_PELLES_VERSION
+#endif
+#if defined(__POCC__)
+    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
+    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #undef JSON_HEDLEY_MCST_LCC_VERSION
+#endif
+#if defined(__LCC__) && defined(__LCC_MINOR__)
+    #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
+#endif
+
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #undef JSON_HEDLEY_GCC_VERSION
+#endif
+#if \
+    defined(JSON_HEDLEY_GNUC_VERSION) && \
+    !defined(__clang__) && \
+    !defined(JSON_HEDLEY_INTEL_VERSION) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_ARM_VERSION) && \
+    !defined(JSON_HEDLEY_CRAY_VERSION) && \
+    !defined(JSON_HEDLEY_TI_VERSION) && \
+    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
+    !defined(__COMPCERT__) && \
+    !defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_ATTRIBUTE
+#endif
+#if \
+  defined(__has_attribute) && \
+  ( \
+    (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
+  )
+#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
+#else
+#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#endif
+#if \
+    defined(__has_cpp_attribute) && \
+    defined(__cplusplus) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#endif
+#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#elif \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_IAR_VERSION) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
+    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_BUILTIN)
+    #undef JSON_HEDLEY_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_FEATURE)
+    #undef JSON_HEDLEY_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GCC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_EXTENSION)
+    #undef JSON_HEDLEY_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_WARNING)
+    #undef JSON_HEDLEY_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
+    #undef JSON_HEDLEY_GNUC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
+    #undef JSON_HEDLEY_GCC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
+    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
+#else
+    #define JSON_HEDLEY_PRAGMA(value)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
+    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#endif
+#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
+    #undef JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
+    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
+#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
+    #define JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+
+/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
+#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
+#      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      else
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      endif
+#    else
+#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    endif
+#  endif
+#endif
+#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
+#endif
+
+#if defined(JSON_HEDLEY_CONST_CAST)
+    #undef JSON_HEDLEY_CONST_CAST
+#endif
+#if defined(__cplusplus)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
+#elif \
+  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_REINTERPRET_CAST)
+    #undef JSON_HEDLEY_REINTERPRET_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_CAST)
+    #undef JSON_HEDLEY_STATIC_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_CPP_CAST)
+    #undef JSON_HEDLEY_CPP_CAST
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
+    ((T) (expr)) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("diag_suppress=Pe137") \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
+#  endif
+#else
+#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#endif
+
+#if defined(JSON_HEDLEY_DEPRECATED)
+    #undef JSON_HEDLEY_DEPRECATED
+#endif
+#if defined(JSON_HEDLEY_DEPRECATED_FOR)
+    #undef JSON_HEDLEY_DEPRECATED_FOR
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
+#elif \
+    (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
+#elif defined(__cplusplus) && (__cplusplus >= 201402L)
+    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
+#else
+    #define JSON_HEDLEY_DEPRECATED(since)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
+#endif
+
+#if defined(JSON_HEDLEY_UNAVAILABLE)
+    #undef JSON_HEDLEY_UNAVAILABLE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
+#else
+    #define JSON_HEDLEY_UNAVAILABLE(available_since)
+#endif
+
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#endif
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
+#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+#elif defined(_Check_return_) /* SAL */
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
+#else
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
+#endif
+
+#if defined(JSON_HEDLEY_SENTINEL)
+    #undef JSON_HEDLEY_SENTINEL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
+#else
+    #define JSON_HEDLEY_SENTINEL(position)
+#endif
+
+#if defined(JSON_HEDLEY_NO_RETURN)
+    #undef JSON_HEDLEY_NO_RETURN
+#endif
+#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NO_RETURN __noreturn
+#elif \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+    #define JSON_HEDLEY_NO_RETURN _Noreturn
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#else
+    #define JSON_HEDLEY_NO_RETURN
+#endif
+
+#if defined(JSON_HEDLEY_NO_ESCAPE)
+    #undef JSON_HEDLEY_NO_ESCAPE
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
+    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
+#else
+    #define JSON_HEDLEY_NO_ESCAPE
+#endif
+
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #undef JSON_HEDLEY_UNREACHABLE
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
+    #undef JSON_HEDLEY_UNREACHABLE_RETURN
+#endif
+#if defined(JSON_HEDLEY_ASSUME)
+    #undef JSON_HEDLEY_ASSUME
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
+#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
+    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
+#elif \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+    #if defined(__cplusplus)
+        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
+    #endif
+#endif
+#if \
+    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
+#elif defined(JSON_HEDLEY_ASSUME)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+#if !defined(JSON_HEDLEY_ASSUME)
+    #if defined(JSON_HEDLEY_UNREACHABLE)
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
+    #endif
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #if  \
+        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
+    #else
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
+    #endif
+#else
+    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
+#endif
+#if !defined(JSON_HEDLEY_UNREACHABLE)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+
+JSON_HEDLEY_DIAGNOSTIC_PUSH
+#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
+    #pragma clang diagnostic ignored "-Wpedantic"
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
+    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#endif
+#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
+    #if defined(__clang__)
+        #pragma clang diagnostic ignored "-Wvariadic-macros"
+    #elif defined(JSON_HEDLEY_GCC_VERSION)
+        #pragma GCC diagnostic ignored "-Wvariadic-macros"
+    #endif
+#endif
+#if defined(JSON_HEDLEY_NON_NULL)
+    #undef JSON_HEDLEY_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
+#else
+    #define JSON_HEDLEY_NON_NULL(...)
+#endif
+JSON_HEDLEY_DIAGNOSTIC_POP
+
+#if defined(JSON_HEDLEY_PRINTF_FORMAT)
+    #undef JSON_HEDLEY_PRINTF_FORMAT
+#endif
+#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
+#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
+#else
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
+#endif
+
+#if defined(JSON_HEDLEY_CONSTEXPR)
+    #undef JSON_HEDLEY_CONSTEXPR
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
+    #endif
+#endif
+#if !defined(JSON_HEDLEY_CONSTEXPR)
+    #define JSON_HEDLEY_CONSTEXPR
+#endif
+
+#if defined(JSON_HEDLEY_PREDICT)
+    #undef JSON_HEDLEY_PREDICT
+#endif
+#if defined(JSON_HEDLEY_LIKELY)
+    #undef JSON_HEDLEY_LIKELY
+#endif
+#if defined(JSON_HEDLEY_UNLIKELY)
+    #undef JSON_HEDLEY_UNLIKELY
+#endif
+#if defined(JSON_HEDLEY_UNPREDICTABLE)
+    #undef JSON_HEDLEY_UNPREDICTABLE
+#endif
+#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
+#endif
+#if \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
+#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
+#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
+#elif \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
+  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
+    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
+#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
+#else
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
+#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
+#endif
+#if !defined(JSON_HEDLEY_UNPREDICTABLE)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
+#endif
+
+#if defined(JSON_HEDLEY_MALLOC)
+    #undef JSON_HEDLEY_MALLOC
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_MALLOC __declspec(restrict)
+#else
+    #define JSON_HEDLEY_MALLOC
+#endif
+
+#if defined(JSON_HEDLEY_PURE)
+    #undef JSON_HEDLEY_PURE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PURE __attribute__((__pure__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
+    )
+#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
+#else
+#  define JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_CONST)
+    #undef JSON_HEDLEY_CONST
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_CONST __attribute__((__const__))
+#elif \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
+#else
+    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_RESTRICT)
+    #undef JSON_HEDLEY_RESTRICT
+#endif
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT restrict
+#elif \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_RESTRICT __restrict
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT _Restrict
+#else
+    #define JSON_HEDLEY_RESTRICT
+#endif
+
+#if defined(JSON_HEDLEY_INLINE)
+    #undef JSON_HEDLEY_INLINE
+#endif
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    (defined(__cplusplus) && (__cplusplus >= 199711L))
+    #define JSON_HEDLEY_INLINE inline
+#elif \
+    defined(JSON_HEDLEY_GCC_VERSION) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
+    #define JSON_HEDLEY_INLINE __inline__
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_INLINE __inline
+#else
+    #define JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_ALWAYS_INLINE)
+    #undef JSON_HEDLEY_ALWAYS_INLINE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
+    )
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
+#else
+#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_NEVER_INLINE)
+    #undef JSON_HEDLEY_NEVER_INLINE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#else
+    #define JSON_HEDLEY_NEVER_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_PRIVATE)
+    #undef JSON_HEDLEY_PRIVATE
+#endif
+#if defined(JSON_HEDLEY_PUBLIC)
+    #undef JSON_HEDLEY_PUBLIC
+#endif
+#if defined(JSON_HEDLEY_IMPORT)
+    #undef JSON_HEDLEY_IMPORT
+#endif
+#if defined(_WIN32) || defined(__CYGWIN__)
+#  define JSON_HEDLEY_PRIVATE
+#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
+#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
+#else
+#  if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    ( \
+      defined(__TI_EABI__) && \
+      ( \
+        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
+      ) \
+    ) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
+#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
+#  else
+#    define JSON_HEDLEY_PRIVATE
+#    define JSON_HEDLEY_PUBLIC
+#  endif
+#  define JSON_HEDLEY_IMPORT    extern
+#endif
+
+#if defined(JSON_HEDLEY_NO_THROW)
+    #undef JSON_HEDLEY_NO_THROW
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
+#else
+    #define JSON_HEDLEY_NO_THROW
+#endif
+
+#if defined(JSON_HEDLEY_FALL_THROUGH)
+    #undef JSON_HEDLEY_FALL_THROUGH
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
+#elif defined(__fallthrough) /* SAL */
+    #define JSON_HEDLEY_FALL_THROUGH __fallthrough
+#else
+    #define JSON_HEDLEY_FALL_THROUGH
+#endif
+
+#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
+    #undef JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
+#elif defined(_Ret_notnull_) /* SAL */
+    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
+#else
+    #define JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+
+#if defined(JSON_HEDLEY_ARRAY_PARAM)
+    #undef JSON_HEDLEY_ARRAY_PARAM
+#endif
+#if \
+    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
+    !defined(__STDC_NO_VLA__) && \
+    !defined(__cplusplus) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
+#else
+    #define JSON_HEDLEY_ARRAY_PARAM(name)
+#endif
+
+#if defined(JSON_HEDLEY_IS_CONSTANT)
+    #undef JSON_HEDLEY_IS_CONSTANT
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
+    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#endif
+/* JSON_HEDLEY_IS_CONSTEXPR_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #undef JSON_HEDLEY_IS_CONSTEXPR_
+#endif
+#if \
+    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
+#endif
+#if !defined(__cplusplus)
+#  if \
+       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
+#endif
+#  elif \
+       ( \
+          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
+          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
+          !defined(JSON_HEDLEY_PGI_VERSION) && \
+          !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
+#endif
+#  elif \
+       defined(JSON_HEDLEY_GCC_VERSION) || \
+       defined(JSON_HEDLEY_INTEL_VERSION) || \
+       defined(JSON_HEDLEY_TINYC_VERSION) || \
+       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
+       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
+       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
+       defined(__clang__)
+#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
+        sizeof(void) != \
+        sizeof(*( \
+                  1 ? \
+                  ((void*) ((expr) * 0L) ) : \
+((struct { char v[sizeof(void) * 2]; } *) 1) \
+                ) \
+              ) \
+                                            )
+#  endif
+#endif
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
+#else
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
+    #undef JSON_HEDLEY_BEGIN_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_END_C_DECLS)
+    #undef JSON_HEDLEY_END_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_C_DECL)
+    #undef JSON_HEDLEY_C_DECL
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
+    #define JSON_HEDLEY_END_C_DECLS }
+    #define JSON_HEDLEY_C_DECL extern "C"
+#else
+    #define JSON_HEDLEY_BEGIN_C_DECLS
+    #define JSON_HEDLEY_END_C_DECLS
+    #define JSON_HEDLEY_C_DECL
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_ASSERT)
+    #undef JSON_HEDLEY_STATIC_ASSERT
+#endif
+#if \
+  !defined(__cplusplus) && ( \
+      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
+      (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
+      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+      defined(_Static_assert) \
+    )
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
+#elif \
+  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
+#else
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
+#endif
+
+#if defined(JSON_HEDLEY_NULL)
+    #undef JSON_HEDLEY_NULL
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
+    #elif defined(NULL)
+        #define JSON_HEDLEY_NULL NULL
+    #else
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
+    #endif
+#elif defined(NULL)
+    #define JSON_HEDLEY_NULL NULL
+#else
+    #define JSON_HEDLEY_NULL ((void*) 0)
+#endif
+
+#if defined(JSON_HEDLEY_MESSAGE)
+    #undef JSON_HEDLEY_MESSAGE
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_MESSAGE(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(message msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
+#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_WARNING)
+    #undef JSON_HEDLEY_WARNING
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_WARNING(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(clang warning msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_REQUIRE)
+    #undef JSON_HEDLEY_REQUIRE
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_MSG)
+    #undef JSON_HEDLEY_REQUIRE_MSG
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
+#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
+#    define JSON_HEDLEY_REQUIRE(expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), msg, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
+#  endif
+#else
+#  define JSON_HEDLEY_REQUIRE(expr)
+#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS)
+    #undef JSON_HEDLEY_FLAGS
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
+    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
+#else
+    #define JSON_HEDLEY_FLAGS
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS_CAST)
+    #undef JSON_HEDLEY_FLAGS_CAST
+#endif
+#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        _Pragma("warning(disable:188)") \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
+#endif
+
+#if defined(JSON_HEDLEY_EMPTY_BASES)
+    #undef JSON_HEDLEY_EMPTY_BASES
+#endif
+#if \
+    (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
+#else
+    #define JSON_HEDLEY_EMPTY_BASES
+#endif
+
+/* Remaining macros are deprecated. */
+
+#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
+#else
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
+    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#endif
+#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
+    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
+    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#endif
+#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
+    #undef JSON_HEDLEY_CLANG_HAS_WARNING
+#endif
+#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
+
+#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/thirdparty/hedley/hedley_undef.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/thirdparty/hedley/hedley_undef.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c0aee2bb309b086730590066b021fa80284991cb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/include/nlohmann/thirdparty/hedley/hedley_undef.hpp
@@ -0,0 +1,158 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#undef JSON_HEDLEY_ALWAYS_INLINE
+#undef JSON_HEDLEY_ARM_VERSION
+#undef JSON_HEDLEY_ARM_VERSION_CHECK
+#undef JSON_HEDLEY_ARRAY_PARAM
+#undef JSON_HEDLEY_ASSUME
+#undef JSON_HEDLEY_BEGIN_C_DECLS
+#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#undef JSON_HEDLEY_CLANG_HAS_WARNING
+#undef JSON_HEDLEY_COMPCERT_VERSION
+#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#undef JSON_HEDLEY_CONCAT
+#undef JSON_HEDLEY_CONCAT3
+#undef JSON_HEDLEY_CONCAT3_EX
+#undef JSON_HEDLEY_CONCAT_EX
+#undef JSON_HEDLEY_CONST
+#undef JSON_HEDLEY_CONSTEXPR
+#undef JSON_HEDLEY_CONST_CAST
+#undef JSON_HEDLEY_CPP_CAST
+#undef JSON_HEDLEY_CRAY_VERSION
+#undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#undef JSON_HEDLEY_C_DECL
+#undef JSON_HEDLEY_DEPRECATED
+#undef JSON_HEDLEY_DEPRECATED_FOR
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#undef JSON_HEDLEY_DIAGNOSTIC_POP
+#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#undef JSON_HEDLEY_DMC_VERSION
+#undef JSON_HEDLEY_DMC_VERSION_CHECK
+#undef JSON_HEDLEY_EMPTY_BASES
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#undef JSON_HEDLEY_END_C_DECLS
+#undef JSON_HEDLEY_FLAGS
+#undef JSON_HEDLEY_FLAGS_CAST
+#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#undef JSON_HEDLEY_GCC_HAS_FEATURE
+#undef JSON_HEDLEY_GCC_HAS_WARNING
+#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#undef JSON_HEDLEY_GCC_VERSION
+#undef JSON_HEDLEY_GCC_VERSION_CHECK
+#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#undef JSON_HEDLEY_GNUC_HAS_WARNING
+#undef JSON_HEDLEY_GNUC_VERSION
+#undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#undef JSON_HEDLEY_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_BUILTIN
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_EXTENSION
+#undef JSON_HEDLEY_HAS_FEATURE
+#undef JSON_HEDLEY_HAS_WARNING
+#undef JSON_HEDLEY_IAR_VERSION
+#undef JSON_HEDLEY_IAR_VERSION_CHECK
+#undef JSON_HEDLEY_IBM_VERSION
+#undef JSON_HEDLEY_IBM_VERSION_CHECK
+#undef JSON_HEDLEY_IMPORT
+#undef JSON_HEDLEY_INLINE
+#undef JSON_HEDLEY_INTEL_CL_VERSION
+#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#undef JSON_HEDLEY_INTEL_VERSION
+#undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#undef JSON_HEDLEY_IS_CONSTANT
+#undef JSON_HEDLEY_IS_CONSTEXPR_
+#undef JSON_HEDLEY_LIKELY
+#undef JSON_HEDLEY_MALLOC
+#undef JSON_HEDLEY_MCST_LCC_VERSION
+#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
+#undef JSON_HEDLEY_MESSAGE
+#undef JSON_HEDLEY_MSVC_VERSION
+#undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#undef JSON_HEDLEY_NEVER_INLINE
+#undef JSON_HEDLEY_NON_NULL
+#undef JSON_HEDLEY_NO_ESCAPE
+#undef JSON_HEDLEY_NO_RETURN
+#undef JSON_HEDLEY_NO_THROW
+#undef JSON_HEDLEY_NULL
+#undef JSON_HEDLEY_PELLES_VERSION
+#undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#undef JSON_HEDLEY_PGI_VERSION
+#undef JSON_HEDLEY_PGI_VERSION_CHECK
+#undef JSON_HEDLEY_PREDICT
+#undef JSON_HEDLEY_PRINTF_FORMAT
+#undef JSON_HEDLEY_PRIVATE
+#undef JSON_HEDLEY_PUBLIC
+#undef JSON_HEDLEY_PURE
+#undef JSON_HEDLEY_REINTERPRET_CAST
+#undef JSON_HEDLEY_REQUIRE
+#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#undef JSON_HEDLEY_REQUIRE_MSG
+#undef JSON_HEDLEY_RESTRICT
+#undef JSON_HEDLEY_RETURNS_NON_NULL
+#undef JSON_HEDLEY_SENTINEL
+#undef JSON_HEDLEY_STATIC_ASSERT
+#undef JSON_HEDLEY_STATIC_CAST
+#undef JSON_HEDLEY_STRINGIFY
+#undef JSON_HEDLEY_STRINGIFY_EX
+#undef JSON_HEDLEY_SUNPRO_VERSION
+#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#undef JSON_HEDLEY_TINYC_VERSION
+#undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#undef JSON_HEDLEY_TI_ARMCL_VERSION
+#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL2000_VERSION
+#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL430_VERSION
+#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL6X_VERSION
+#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL7X_VERSION
+#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CLPRU_VERSION
+#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#undef JSON_HEDLEY_TI_VERSION
+#undef JSON_HEDLEY_TI_VERSION_CHECK
+#undef JSON_HEDLEY_UNAVAILABLE
+#undef JSON_HEDLEY_UNLIKELY
+#undef JSON_HEDLEY_UNPREDICTABLE
+#undef JSON_HEDLEY_UNREACHABLE
+#undef JSON_HEDLEY_UNREACHABLE_RETURN
+#undef JSON_HEDLEY_VERSION
+#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#undef JSON_HEDLEY_VERSION_ENCODE
+#undef JSON_HEDLEY_WARNING
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#undef JSON_HEDLEY_FALL_THROUGH
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/nlohmann_json.natvis b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/nlohmann_json.natvis
new file mode 100644
index 0000000000000000000000000000000000000000..a831ea04be6f5c14e763c64742f3c5a10d6f2f34
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/nlohmann_json.natvis
@@ -0,0 +1,278 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- * * * * * * * * AUTO-GENERATED FILE  * * * * * * * * -->
+<!-- Edit ./tools/generate_natvis/nlohmann_json.natvis.j2 -->
+<!-- * * * * * * * * AUTO-GENERATED FILE  * * * * * * * * -->
+
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+    <!-- Namespace nlohmann -->
+    <Type Name="nlohmann::basic_json&lt;*&gt;">
+        <DisplayString Condition="m_type == nlohmann::detail::value_t::null">null</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::detail::value_t::object">{*(m_value.object)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::detail::value_t::array">{*(m_value.array)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::detail::value_t::string">{*(m_value.string)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::detail::value_t::boolean">{m_value.boolean}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::detail::value_t::number_integer">{m_value.number_integer}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::detail::value_t::number_unsigned">{m_value.number_unsigned}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::detail::value_t::number_float">{m_value.number_float}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::detail::value_t::discarded">discarded</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="m_type == nlohmann::detail::value_t::object">
+                *(m_value.object),view(simple)
+            </ExpandedItem>
+            <ExpandedItem Condition="m_type == nlohmann::detail::value_t::array">
+                *(m_value.array),view(simple)
+            </ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Skip the pair first/second members in the treeview while traversing a map.
+         Only works in VS 2015 Update 2 and beyond using the new visualization -->
+    <Type Name="std::pair&lt;*, nlohmann::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
+        <DisplayString>{second}</DisplayString>
+        <Expand>
+            <ExpandedItem>second</ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Namespace nlohmann::json_abi -->
+    <Type Name="nlohmann::json_abi::basic_json&lt;*&gt;">
+        <DisplayString Condition="m_type == nlohmann::json_abi::detail::value_t::null">null</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi::detail::value_t::object">{*(m_value.object)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi::detail::value_t::array">{*(m_value.array)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi::detail::value_t::string">{*(m_value.string)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi::detail::value_t::boolean">{m_value.boolean}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi::detail::value_t::number_integer">{m_value.number_integer}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi::detail::value_t::number_unsigned">{m_value.number_unsigned}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi::detail::value_t::number_float">{m_value.number_float}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi::detail::value_t::discarded">discarded</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi::detail::value_t::object">
+                *(m_value.object),view(simple)
+            </ExpandedItem>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi::detail::value_t::array">
+                *(m_value.array),view(simple)
+            </ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Skip the pair first/second members in the treeview while traversing a map.
+         Only works in VS 2015 Update 2 and beyond using the new visualization -->
+    <Type Name="std::pair&lt;*, nlohmann::json_abi::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
+        <DisplayString>{second}</DisplayString>
+        <Expand>
+            <ExpandedItem>second</ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Namespace nlohmann::json_abi_v3_11_2 -->
+    <Type Name="nlohmann::json_abi_v3_11_2::basic_json&lt;*&gt;">
+        <DisplayString Condition="m_type == nlohmann::json_abi_v3_11_2::detail::value_t::null">null</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_v3_11_2::detail::value_t::object">{*(m_value.object)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_v3_11_2::detail::value_t::array">{*(m_value.array)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_v3_11_2::detail::value_t::string">{*(m_value.string)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_v3_11_2::detail::value_t::boolean">{m_value.boolean}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_v3_11_2::detail::value_t::number_integer">{m_value.number_integer}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_v3_11_2::detail::value_t::number_unsigned">{m_value.number_unsigned}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_v3_11_2::detail::value_t::number_float">{m_value.number_float}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_v3_11_2::detail::value_t::discarded">discarded</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_v3_11_2::detail::value_t::object">
+                *(m_value.object),view(simple)
+            </ExpandedItem>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_v3_11_2::detail::value_t::array">
+                *(m_value.array),view(simple)
+            </ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Skip the pair first/second members in the treeview while traversing a map.
+         Only works in VS 2015 Update 2 and beyond using the new visualization -->
+    <Type Name="std::pair&lt;*, nlohmann::json_abi_v3_11_2::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
+        <DisplayString>{second}</DisplayString>
+        <Expand>
+            <ExpandedItem>second</ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Namespace nlohmann::json_abi_diag -->
+    <Type Name="nlohmann::json_abi_diag::basic_json&lt;*&gt;">
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag::detail::value_t::null">null</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag::detail::value_t::object">{*(m_value.object)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag::detail::value_t::array">{*(m_value.array)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag::detail::value_t::string">{*(m_value.string)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag::detail::value_t::boolean">{m_value.boolean}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag::detail::value_t::number_integer">{m_value.number_integer}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag::detail::value_t::number_unsigned">{m_value.number_unsigned}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag::detail::value_t::number_float">{m_value.number_float}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag::detail::value_t::discarded">discarded</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_diag::detail::value_t::object">
+                *(m_value.object),view(simple)
+            </ExpandedItem>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_diag::detail::value_t::array">
+                *(m_value.array),view(simple)
+            </ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Skip the pair first/second members in the treeview while traversing a map.
+         Only works in VS 2015 Update 2 and beyond using the new visualization -->
+    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
+        <DisplayString>{second}</DisplayString>
+        <Expand>
+            <ExpandedItem>second</ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Namespace nlohmann::json_abi_diag_v3_11_2 -->
+    <Type Name="nlohmann::json_abi_diag_v3_11_2::basic_json&lt;*&gt;">
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_v3_11_2::detail::value_t::null">null</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_v3_11_2::detail::value_t::object">{*(m_value.object)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_v3_11_2::detail::value_t::array">{*(m_value.array)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_v3_11_2::detail::value_t::string">{*(m_value.string)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_v3_11_2::detail::value_t::boolean">{m_value.boolean}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_v3_11_2::detail::value_t::number_integer">{m_value.number_integer}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_v3_11_2::detail::value_t::number_unsigned">{m_value.number_unsigned}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_v3_11_2::detail::value_t::number_float">{m_value.number_float}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_v3_11_2::detail::value_t::discarded">discarded</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_diag_v3_11_2::detail::value_t::object">
+                *(m_value.object),view(simple)
+            </ExpandedItem>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_diag_v3_11_2::detail::value_t::array">
+                *(m_value.array),view(simple)
+            </ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Skip the pair first/second members in the treeview while traversing a map.
+         Only works in VS 2015 Update 2 and beyond using the new visualization -->
+    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_v3_11_2::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
+        <DisplayString>{second}</DisplayString>
+        <Expand>
+            <ExpandedItem>second</ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Namespace nlohmann::json_abi_ldvcmp -->
+    <Type Name="nlohmann::json_abi_ldvcmp::basic_json&lt;*&gt;">
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp::detail::value_t::null">null</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp::detail::value_t::object">{*(m_value.object)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp::detail::value_t::array">{*(m_value.array)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp::detail::value_t::string">{*(m_value.string)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp::detail::value_t::boolean">{m_value.boolean}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp::detail::value_t::number_integer">{m_value.number_integer}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp::detail::value_t::number_unsigned">{m_value.number_unsigned}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp::detail::value_t::number_float">{m_value.number_float}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp::detail::value_t::discarded">discarded</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_ldvcmp::detail::value_t::object">
+                *(m_value.object),view(simple)
+            </ExpandedItem>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_ldvcmp::detail::value_t::array">
+                *(m_value.array),view(simple)
+            </ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Skip the pair first/second members in the treeview while traversing a map.
+         Only works in VS 2015 Update 2 and beyond using the new visualization -->
+    <Type Name="std::pair&lt;*, nlohmann::json_abi_ldvcmp::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
+        <DisplayString>{second}</DisplayString>
+        <Expand>
+            <ExpandedItem>second</ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Namespace nlohmann::json_abi_ldvcmp_v3_11_2 -->
+    <Type Name="nlohmann::json_abi_ldvcmp_v3_11_2::basic_json&lt;*&gt;">
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp_v3_11_2::detail::value_t::null">null</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp_v3_11_2::detail::value_t::object">{*(m_value.object)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp_v3_11_2::detail::value_t::array">{*(m_value.array)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp_v3_11_2::detail::value_t::string">{*(m_value.string)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp_v3_11_2::detail::value_t::boolean">{m_value.boolean}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp_v3_11_2::detail::value_t::number_integer">{m_value.number_integer}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp_v3_11_2::detail::value_t::number_unsigned">{m_value.number_unsigned}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp_v3_11_2::detail::value_t::number_float">{m_value.number_float}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_ldvcmp_v3_11_2::detail::value_t::discarded">discarded</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_ldvcmp_v3_11_2::detail::value_t::object">
+                *(m_value.object),view(simple)
+            </ExpandedItem>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_ldvcmp_v3_11_2::detail::value_t::array">
+                *(m_value.array),view(simple)
+            </ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Skip the pair first/second members in the treeview while traversing a map.
+         Only works in VS 2015 Update 2 and beyond using the new visualization -->
+    <Type Name="std::pair&lt;*, nlohmann::json_abi_ldvcmp_v3_11_2::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
+        <DisplayString>{second}</DisplayString>
+        <Expand>
+            <ExpandedItem>second</ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Namespace nlohmann::json_abi_diag_ldvcmp -->
+    <Type Name="nlohmann::json_abi_diag_ldvcmp::basic_json&lt;*&gt;">
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp::detail::value_t::null">null</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp::detail::value_t::object">{*(m_value.object)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp::detail::value_t::array">{*(m_value.array)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp::detail::value_t::string">{*(m_value.string)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp::detail::value_t::boolean">{m_value.boolean}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp::detail::value_t::number_integer">{m_value.number_integer}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp::detail::value_t::number_unsigned">{m_value.number_unsigned}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp::detail::value_t::number_float">{m_value.number_float}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp::detail::value_t::discarded">discarded</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_diag_ldvcmp::detail::value_t::object">
+                *(m_value.object),view(simple)
+            </ExpandedItem>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_diag_ldvcmp::detail::value_t::array">
+                *(m_value.array),view(simple)
+            </ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Skip the pair first/second members in the treeview while traversing a map.
+         Only works in VS 2015 Update 2 and beyond using the new visualization -->
+    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_ldvcmp::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
+        <DisplayString>{second}</DisplayString>
+        <Expand>
+            <ExpandedItem>second</ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Namespace nlohmann::json_abi_diag_ldvcmp_v3_11_2 -->
+    <Type Name="nlohmann::json_abi_diag_ldvcmp_v3_11_2::basic_json&lt;*&gt;">
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp_v3_11_2::detail::value_t::null">null</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp_v3_11_2::detail::value_t::object">{*(m_value.object)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp_v3_11_2::detail::value_t::array">{*(m_value.array)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp_v3_11_2::detail::value_t::string">{*(m_value.string)}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp_v3_11_2::detail::value_t::boolean">{m_value.boolean}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp_v3_11_2::detail::value_t::number_integer">{m_value.number_integer}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp_v3_11_2::detail::value_t::number_unsigned">{m_value.number_unsigned}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp_v3_11_2::detail::value_t::number_float">{m_value.number_float}</DisplayString>
+        <DisplayString Condition="m_type == nlohmann::json_abi_diag_ldvcmp_v3_11_2::detail::value_t::discarded">discarded</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_diag_ldvcmp_v3_11_2::detail::value_t::object">
+                *(m_value.object),view(simple)
+            </ExpandedItem>
+            <ExpandedItem Condition="m_type == nlohmann::json_abi_diag_ldvcmp_v3_11_2::detail::value_t::array">
+                *(m_value.array),view(simple)
+            </ExpandedItem>
+        </Expand>
+    </Type>
+
+    <!-- Skip the pair first/second members in the treeview while traversing a map.
+         Only works in VS 2015 Update 2 and beyond using the new visualization -->
+    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_ldvcmp_v3_11_2::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
+        <DisplayString>{second}</DisplayString>
+        <Expand>
+            <ExpandedItem>second</ExpandedItem>
+        </Expand>
+    </Type>
+
+</AutoVisualizer>
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann/json.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann/json.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..8b72ea6539f40e4e3f7762d17e30c67f2a8308ed
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann/json.hpp
@@ -0,0 +1,24765 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+/****************************************************************************\
+ * Note on documentation: The source files contain links to the online      *
+ * documentation of the public API at https://json.nlohmann.me. This URL    *
+ * contains the most recent documentation and should also be applicable to  *
+ * previous versions; documentation for deprecated functions is not         *
+ * removed, but marked deprecated. See "Generate documentation" section in  *
+ * file docs/README.md.                                                     *
+\****************************************************************************/
+
+#ifndef INCLUDE_NLOHMANN_JSON_HPP_
+#define INCLUDE_NLOHMANN_JSON_HPP_
+
+#include <algorithm> // all_of, find, for_each
+#include <cstddef> // nullptr_t, ptrdiff_t, size_t
+#include <functional> // hash, less
+#include <initializer_list> // initializer_list
+#ifndef JSON_NO_IO
+    #include <iosfwd> // istream, ostream
+#endif  // JSON_NO_IO
+#include <iterator> // random_access_iterator_tag
+#include <memory> // unique_ptr
+#include <string> // string, stoi, to_string
+#include <utility> // declval, forward, move, pair, swap
+#include <vector> // vector
+
+// #include <nlohmann/adl_serializer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <utility>
+
+// #include <nlohmann/detail/abi_macros.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// This file contains all macro definitions affecting or depending on the ABI
+
+#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
+    #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
+        #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3
+            #warning "Already included a different version of the library!"
+        #endif
+    #endif
+#endif
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3   // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_MINOR 11  // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_PATCH 3   // NOLINT(modernize-macro-to-enum)
+
+#ifndef JSON_DIAGNOSTICS
+    #define JSON_DIAGNOSTICS 0
+#endif
+
+#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
+#endif
+
+#if JSON_DIAGNOSTICS
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
+#else
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
+#endif
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
+#else
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
+    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
+#endif
+
+// Construct the namespace ABI tags component
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)
+
+#define NLOHMANN_JSON_ABI_TAGS                                       \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
+            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
+
+// Construct the namespace version component
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
+    _v ## major ## _ ## minor ## _ ## patch
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
+
+#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
+#define NLOHMANN_JSON_NAMESPACE_VERSION
+#else
+#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
+                                           NLOHMANN_JSON_VERSION_MINOR, \
+                                           NLOHMANN_JSON_VERSION_PATCH)
+#endif
+
+// Combine namespace components
+#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
+#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
+    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
+
+#ifndef NLOHMANN_JSON_NAMESPACE
+#define NLOHMANN_JSON_NAMESPACE               \
+    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
+            NLOHMANN_JSON_ABI_TAGS,           \
+            NLOHMANN_JSON_NAMESPACE_VERSION)
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
+#define NLOHMANN_JSON_NAMESPACE_BEGIN                \
+    namespace nlohmann                               \
+    {                                                \
+    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
+                NLOHMANN_JSON_ABI_TAGS,              \
+                NLOHMANN_JSON_NAMESPACE_VERSION)     \
+    {
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_END
+#define NLOHMANN_JSON_NAMESPACE_END                                     \
+    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
+    }  // namespace nlohmann
+#endif
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // transform
+#include <array> // array
+#include <forward_list> // forward_list
+#include <iterator> // inserter, front_inserter, end
+#include <map> // map
+#include <string> // string
+#include <tuple> // tuple, make_tuple
+#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
+#include <unordered_map> // unordered_map
+#include <utility> // pair, declval
+#include <valarray> // valarray
+
+// #include <nlohmann/detail/exceptions.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // nullptr_t
+#include <exception> // exception
+#if JSON_DIAGNOSTICS
+    #include <numeric> // accumulate
+#endif
+#include <stdexcept> // runtime_error
+#include <string> // to_string
+#include <vector> // vector
+
+// #include <nlohmann/detail/value_t.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t
+#include <string> // string
+
+// #include <nlohmann/detail/macro_scope.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <utility> // declval, pair
+// #include <nlohmann/detail/meta/detected.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <type_traits>
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename ...Ts> struct make_void
+{
+    using type = void;
+};
+template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// https://en.cppreference.com/w/cpp/experimental/is_detected
+struct nonesuch
+{
+    nonesuch() = delete;
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const&) = delete;
+    nonesuch(nonesuch const&&) = delete;
+    void operator=(nonesuch const&) = delete;
+    void operator=(nonesuch&&) = delete;
+};
+
+template<class Default,
+         class AlwaysVoid,
+         template<class...> class Op,
+         class... Args>
+struct detector
+{
+    using value_t = std::false_type;
+    using type = Default;
+};
+
+template<class Default, template<class...> class Op, class... Args>
+struct detector<Default, void_t<Op<Args...>>, Op, Args...>
+{
+    using value_t = std::true_type;
+    using type = Op<Args...>;
+};
+
+template<template<class...> class Op, class... Args>
+using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
+
+template<template<class...> class Op, class... Args>
+struct is_detected_lazy : is_detected<Op, Args...> { };
+
+template<template<class...> class Op, class... Args>
+using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or = detector<Default, void, Op, Args...>;
+
+template<class Default, template<class...> class Op, class... Args>
+using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+template<class Expected, template<class...> class Op, class... Args>
+using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
+
+template<class To, template<class...> class Op, class... Args>
+using is_detected_convertible =
+    std::is_convertible<detected_t<Op, Args...>, To>;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/thirdparty/hedley/hedley.hpp>
+
+
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson <evan@nemerson.com>
+// SPDX-License-Identifier: MIT
+
+/* Hedley - https://nemequ.github.io/hedley
+ * Created by Evan Nemerson <evan@nemerson.com>
+ */
+
+#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)
+#if defined(JSON_HEDLEY_VERSION)
+    #undef JSON_HEDLEY_VERSION
+#endif
+#define JSON_HEDLEY_VERSION 15
+
+#if defined(JSON_HEDLEY_STRINGIFY_EX)
+    #undef JSON_HEDLEY_STRINGIFY_EX
+#endif
+#define JSON_HEDLEY_STRINGIFY_EX(x) #x
+
+#if defined(JSON_HEDLEY_STRINGIFY)
+    #undef JSON_HEDLEY_STRINGIFY
+#endif
+#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
+
+#if defined(JSON_HEDLEY_CONCAT_EX)
+    #undef JSON_HEDLEY_CONCAT_EX
+#endif
+#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
+
+#if defined(JSON_HEDLEY_CONCAT)
+    #undef JSON_HEDLEY_CONCAT
+#endif
+#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
+
+#if defined(JSON_HEDLEY_CONCAT3_EX)
+    #undef JSON_HEDLEY_CONCAT3_EX
+#endif
+#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
+
+#if defined(JSON_HEDLEY_CONCAT3)
+    #undef JSON_HEDLEY_CONCAT3
+#endif
+#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
+
+#if defined(JSON_HEDLEY_VERSION_ENCODE)
+    #undef JSON_HEDLEY_VERSION_ENCODE
+#endif
+#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
+    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
+
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #undef JSON_HEDLEY_GNUC_VERSION
+#endif
+#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#elif defined(__GNUC__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION)
+    #undef JSON_HEDLEY_MSVC_VERSION
+#endif
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
+#elif defined(_MSC_FULL_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
+#elif defined(_MSC_VER) && !defined(__ICL)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#endif
+#if !defined(JSON_HEDLEY_MSVC_VERSION)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
+#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
+#else
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #undef JSON_HEDLEY_INTEL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
+#elif defined(__INTEL_COMPILER) && !defined(__ICL)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)
+    #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_CL_VERSION)
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #undef JSON_HEDLEY_PGI_VERSION
+#endif
+#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
+    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
+    #undef JSON_HEDLEY_PGI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #undef JSON_HEDLEY_SUNPRO_VERSION
+#endif
+#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
+#elif defined(__SUNPRO_C)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
+#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
+#elif defined(__SUNPRO_CC)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
+    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#endif
+#if defined(__EMSCRIPTEN__)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #undef JSON_HEDLEY_ARM_VERSION
+#endif
+#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
+#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
+    #undef JSON_HEDLEY_ARM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #undef JSON_HEDLEY_IBM_VERSION
+#endif
+#if defined(__ibmxl__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
+#elif defined(__xlC__) && defined(__xlC_ver__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
+#elif defined(__xlC__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
+    #undef JSON_HEDLEY_IBM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #undef JSON_HEDLEY_TI_VERSION
+#endif
+#if \
+    defined(__TI_COMPILER_VERSION__) && \
+    ( \
+      defined(__TMS470__) || defined(__TI_ARM__) || \
+      defined(__MSP430__) || \
+      defined(__TMS320C2000__) \
+    )
+#if (__TI_COMPILER_VERSION__ >= 16000000)
+    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
+    #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL2000_VERSION)
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #undef JSON_HEDLEY_TI_CL430_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
+    #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL430_VERSION)
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
+    #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
+    #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL6X_VERSION)
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
+    #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CL7X_VERSION)
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #undef JSON_HEDLEY_CRAY_VERSION
+#endif
+#if defined(_CRAYC)
+    #if defined(_RELEASE_PATCHLEVEL)
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
+    #else
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
+    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #undef JSON_HEDLEY_IAR_VERSION
+#endif
+#if defined(__IAR_SYSTEMS_ICC__)
+    #if __VER__ > 1000
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
+    #else
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
+    #undef JSON_HEDLEY_IAR_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #undef JSON_HEDLEY_TINYC_VERSION
+#endif
+#if defined(__TINYC__)
+    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
+    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #undef JSON_HEDLEY_DMC_VERSION
+#endif
+#if defined(__DMC__)
+    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
+    #undef JSON_HEDLEY_DMC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #undef JSON_HEDLEY_COMPCERT_VERSION
+#endif
+#if defined(__COMPCERT_VERSION__)
+    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
+    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #undef JSON_HEDLEY_PELLES_VERSION
+#endif
+#if defined(__POCC__)
+    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
+    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #undef JSON_HEDLEY_MCST_LCC_VERSION
+#endif
+#if defined(__LCC__) && defined(__LCC_MINOR__)
+    #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)
+#endif
+
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #undef JSON_HEDLEY_GCC_VERSION
+#endif
+#if \
+    defined(JSON_HEDLEY_GNUC_VERSION) && \
+    !defined(__clang__) && \
+    !defined(JSON_HEDLEY_INTEL_VERSION) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_ARM_VERSION) && \
+    !defined(JSON_HEDLEY_CRAY_VERSION) && \
+    !defined(JSON_HEDLEY_TI_VERSION) && \
+    !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
+    !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
+    !defined(__COMPCERT__) && \
+    !defined(JSON_HEDLEY_MCST_LCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_ATTRIBUTE
+#endif
+#if \
+  defined(__has_attribute) && \
+  ( \
+    (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \
+  )
+#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
+#else
+#  define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#endif
+#if \
+    defined(__has_cpp_attribute) && \
+    defined(__cplusplus) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#endif
+#if !defined(__cplusplus) || !defined(__has_cpp_attribute)
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#elif \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_IAR_VERSION) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
+    (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_BUILTIN)
+    #undef JSON_HEDLEY_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_FEATURE)
+    #undef JSON_HEDLEY_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GCC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_EXTENSION)
+    #undef JSON_HEDLEY_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_WARNING)
+    #undef JSON_HEDLEY_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
+    #undef JSON_HEDLEY_GNUC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
+    #undef JSON_HEDLEY_GCC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
+    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
+#else
+    #define JSON_HEDLEY_PRAGMA(value)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
+    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#endif
+#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
+    #undef JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
+    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
+#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
+    #define JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+
+/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
+#    if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
+#      if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions")
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      else
+#        define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#      endif
+#    else
+#      define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
+    xpr \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    endif
+#  endif
+#endif
+#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
+#endif
+
+#if defined(JSON_HEDLEY_CONST_CAST)
+    #undef JSON_HEDLEY_CONST_CAST
+#endif
+#if defined(__cplusplus)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
+#elif \
+  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_REINTERPRET_CAST)
+    #undef JSON_HEDLEY_REINTERPRET_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_CAST)
+    #undef JSON_HEDLEY_STATIC_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_CPP_CAST)
+    #undef JSON_HEDLEY_CPP_CAST
+#endif
+#if defined(__cplusplus)
+#  if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
+    ((T) (expr)) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
+#    define JSON_HEDLEY_CPP_CAST(T, expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("diag_suppress=Pe137") \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
+#  endif
+#else
+#  define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
+#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
+#elif \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunused-function")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))
+#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#endif
+
+#if defined(JSON_HEDLEY_DEPRECATED)
+    #undef JSON_HEDLEY_DEPRECATED
+#endif
+#if defined(JSON_HEDLEY_DEPRECATED_FOR)
+    #undef JSON_HEDLEY_DEPRECATED_FOR
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
+#elif \
+    (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
+#elif defined(__cplusplus) && (__cplusplus >= 201402L)
+    #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
+#else
+    #define JSON_HEDLEY_DEPRECATED(since)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
+#endif
+
+#if defined(JSON_HEDLEY_UNAVAILABLE)
+    #undef JSON_HEDLEY_UNAVAILABLE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
+#else
+    #define JSON_HEDLEY_UNAVAILABLE(available_since)
+#endif
+
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#endif
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
+#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
+#elif defined(_Check_return_) /* SAL */
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
+#else
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
+#endif
+
+#if defined(JSON_HEDLEY_SENTINEL)
+    #undef JSON_HEDLEY_SENTINEL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
+#else
+    #define JSON_HEDLEY_SENTINEL(position)
+#endif
+
+#if defined(JSON_HEDLEY_NO_RETURN)
+    #undef JSON_HEDLEY_NO_RETURN
+#endif
+#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NO_RETURN __noreturn
+#elif \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+    #define JSON_HEDLEY_NO_RETURN _Noreturn
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+    #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#else
+    #define JSON_HEDLEY_NO_RETURN
+#endif
+
+#if defined(JSON_HEDLEY_NO_ESCAPE)
+    #undef JSON_HEDLEY_NO_ESCAPE
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
+    #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
+#else
+    #define JSON_HEDLEY_NO_ESCAPE
+#endif
+
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #undef JSON_HEDLEY_UNREACHABLE
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
+    #undef JSON_HEDLEY_UNREACHABLE_RETURN
+#endif
+#if defined(JSON_HEDLEY_ASSUME)
+    #undef JSON_HEDLEY_ASSUME
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
+#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
+    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
+#elif \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+    #if defined(__cplusplus)
+        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
+    #endif
+#endif
+#if \
+    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
+#elif defined(JSON_HEDLEY_ASSUME)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+#if !defined(JSON_HEDLEY_ASSUME)
+    #if defined(JSON_HEDLEY_UNREACHABLE)
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
+    #endif
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #if  \
+        JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
+    #else
+        #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
+    #endif
+#else
+    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
+#endif
+#if !defined(JSON_HEDLEY_UNREACHABLE)
+    #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
+#endif
+
+JSON_HEDLEY_DIAGNOSTIC_PUSH
+#if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
+    #pragma clang diagnostic ignored "-Wpedantic"
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
+    #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
+#endif
+#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
+    #if defined(__clang__)
+        #pragma clang diagnostic ignored "-Wvariadic-macros"
+    #elif defined(JSON_HEDLEY_GCC_VERSION)
+        #pragma GCC diagnostic ignored "-Wvariadic-macros"
+    #endif
+#endif
+#if defined(JSON_HEDLEY_NON_NULL)
+    #undef JSON_HEDLEY_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
+#else
+    #define JSON_HEDLEY_NON_NULL(...)
+#endif
+JSON_HEDLEY_DIAGNOSTIC_POP
+
+#if defined(JSON_HEDLEY_PRINTF_FORMAT)
+    #undef JSON_HEDLEY_PRINTF_FORMAT
+#endif
+#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
+#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
+#else
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
+#endif
+
+#if defined(JSON_HEDLEY_CONSTEXPR)
+    #undef JSON_HEDLEY_CONSTEXPR
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
+    #endif
+#endif
+#if !defined(JSON_HEDLEY_CONSTEXPR)
+    #define JSON_HEDLEY_CONSTEXPR
+#endif
+
+#if defined(JSON_HEDLEY_PREDICT)
+    #undef JSON_HEDLEY_PREDICT
+#endif
+#if defined(JSON_HEDLEY_LIKELY)
+    #undef JSON_HEDLEY_LIKELY
+#endif
+#if defined(JSON_HEDLEY_UNLIKELY)
+    #undef JSON_HEDLEY_UNLIKELY
+#endif
+#if defined(JSON_HEDLEY_UNPREDICTABLE)
+    #undef JSON_HEDLEY_UNPREDICTABLE
+#endif
+#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
+#endif
+#if \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(  (expr), (value), (probability))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability)   __builtin_expect_with_probability(!!(expr),    1   , (probability))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability)  __builtin_expect_with_probability(!!(expr),    0   , (probability))
+#  define JSON_HEDLEY_LIKELY(expr)                      __builtin_expect                 (!!(expr),    1                  )
+#  define JSON_HEDLEY_UNLIKELY(expr)                    __builtin_expect                 (!!(expr),    0                  )
+#elif \
+  (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
+  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
+    (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
+    (__extension__ ({ \
+        double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
+#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
+#else
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
+#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
+#endif
+#if !defined(JSON_HEDLEY_UNPREDICTABLE)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
+#endif
+
+#if defined(JSON_HEDLEY_MALLOC)
+    #undef JSON_HEDLEY_MALLOC
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_MALLOC __declspec(restrict)
+#else
+    #define JSON_HEDLEY_MALLOC
+#endif
+
+#if defined(JSON_HEDLEY_PURE)
+    #undef JSON_HEDLEY_PURE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#  define JSON_HEDLEY_PURE __attribute__((__pure__))
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+#  define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
+    )
+#  define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
+#else
+#  define JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_CONST)
+    #undef JSON_HEDLEY_CONST
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_CONST __attribute__((__const__))
+#elif \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
+    #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
+#else
+    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_RESTRICT)
+    #undef JSON_HEDLEY_RESTRICT
+#endif
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT restrict
+#elif \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_RESTRICT __restrict
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT _Restrict
+#else
+    #define JSON_HEDLEY_RESTRICT
+#endif
+
+#if defined(JSON_HEDLEY_INLINE)
+    #undef JSON_HEDLEY_INLINE
+#endif
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    (defined(__cplusplus) && (__cplusplus >= 199711L))
+    #define JSON_HEDLEY_INLINE inline
+#elif \
+    defined(JSON_HEDLEY_GCC_VERSION) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
+    #define JSON_HEDLEY_INLINE __inline__
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_INLINE __inline
+#else
+    #define JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_ALWAYS_INLINE)
+    #undef JSON_HEDLEY_ALWAYS_INLINE
+#endif
+#if \
+  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+  JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+  JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE __forceinline
+#elif defined(__cplusplus) && \
+    ( \
+      JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+      JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+      JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+      JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+      JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+      JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
+    )
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
+#else
+#  define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_NEVER_INLINE)
+    #undef JSON_HEDLEY_NEVER_INLINE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
+    (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
+    (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
+    (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
+    (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
+    JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
+    JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
+#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#else
+    #define JSON_HEDLEY_NEVER_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_PRIVATE)
+    #undef JSON_HEDLEY_PRIVATE
+#endif
+#if defined(JSON_HEDLEY_PUBLIC)
+    #undef JSON_HEDLEY_PUBLIC
+#endif
+#if defined(JSON_HEDLEY_IMPORT)
+    #undef JSON_HEDLEY_IMPORT
+#endif
+#if defined(_WIN32) || defined(__CYGWIN__)
+#  define JSON_HEDLEY_PRIVATE
+#  define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
+#  define JSON_HEDLEY_IMPORT   __declspec(dllimport)
+#else
+#  if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    ( \
+      defined(__TI_EABI__) && \
+      ( \
+        (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+        JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
+      ) \
+    ) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+#    define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
+#    define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
+#  else
+#    define JSON_HEDLEY_PRIVATE
+#    define JSON_HEDLEY_PUBLIC
+#  endif
+#  define JSON_HEDLEY_IMPORT    extern
+#endif
+
+#if defined(JSON_HEDLEY_NO_THROW)
+    #undef JSON_HEDLEY_NO_THROW
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
+#else
+    #define JSON_HEDLEY_NO_THROW
+#endif
+
+#if defined(JSON_HEDLEY_FALL_THROUGH)
+    #undef JSON_HEDLEY_FALL_THROUGH
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
+#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
+    #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
+#elif defined(__fallthrough) /* SAL */
+    #define JSON_HEDLEY_FALL_THROUGH __fallthrough
+#else
+    #define JSON_HEDLEY_FALL_THROUGH
+#endif
+
+#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
+    #undef JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
+#elif defined(_Ret_notnull_) /* SAL */
+    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
+#else
+    #define JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+
+#if defined(JSON_HEDLEY_ARRAY_PARAM)
+    #undef JSON_HEDLEY_ARRAY_PARAM
+#endif
+#if \
+    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
+    !defined(__STDC_NO_VLA__) && \
+    !defined(__cplusplus) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
+#else
+    #define JSON_HEDLEY_ARRAY_PARAM(name)
+#endif
+
+#if defined(JSON_HEDLEY_IS_CONSTANT)
+    #undef JSON_HEDLEY_IS_CONSTANT
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
+    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#endif
+/* JSON_HEDLEY_IS_CONSTEXPR_ is for
+   HEDLEY INTERNAL USE ONLY.  API subject to change without notice. */
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #undef JSON_HEDLEY_IS_CONSTEXPR_
+#endif
+#if \
+    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+    JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)
+    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
+#endif
+#if !defined(__cplusplus)
+#  if \
+       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
+#endif
+#  elif \
+       ( \
+          defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
+          !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
+          !defined(JSON_HEDLEY_PGI_VERSION) && \
+          !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
+#endif
+#  elif \
+       defined(JSON_HEDLEY_GCC_VERSION) || \
+       defined(JSON_HEDLEY_INTEL_VERSION) || \
+       defined(JSON_HEDLEY_TINYC_VERSION) || \
+       defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
+       JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
+       defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
+       defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
+       defined(__clang__)
+#    define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
+        sizeof(void) != \
+        sizeof(*( \
+                  1 ? \
+                  ((void*) ((expr) * 0L) ) : \
+((struct { char v[sizeof(void) * 2]; } *) 1) \
+                ) \
+              ) \
+                                            )
+#  endif
+#endif
+#if defined(JSON_HEDLEY_IS_CONSTEXPR_)
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
+#else
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
+    #undef JSON_HEDLEY_BEGIN_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_END_C_DECLS)
+    #undef JSON_HEDLEY_END_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_C_DECL)
+    #undef JSON_HEDLEY_C_DECL
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
+    #define JSON_HEDLEY_END_C_DECLS }
+    #define JSON_HEDLEY_C_DECL extern "C"
+#else
+    #define JSON_HEDLEY_BEGIN_C_DECLS
+    #define JSON_HEDLEY_END_C_DECLS
+    #define JSON_HEDLEY_C_DECL
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_ASSERT)
+    #undef JSON_HEDLEY_STATIC_ASSERT
+#endif
+#if \
+  !defined(__cplusplus) && ( \
+      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
+      (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \
+      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
+      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+      defined(_Static_assert) \
+    )
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
+#elif \
+  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
+#else
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
+#endif
+
+#if defined(JSON_HEDLEY_NULL)
+    #undef JSON_HEDLEY_NULL
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
+    #elif defined(NULL)
+        #define JSON_HEDLEY_NULL NULL
+    #else
+        #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
+    #endif
+#elif defined(NULL)
+    #define JSON_HEDLEY_NULL NULL
+#else
+    #define JSON_HEDLEY_NULL ((void*) 0)
+#endif
+
+#if defined(JSON_HEDLEY_MESSAGE)
+    #undef JSON_HEDLEY_MESSAGE
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_MESSAGE(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(message msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
+#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_WARNING)
+    #undef JSON_HEDLEY_WARNING
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_WARNING(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(clang warning msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
+#elif \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \
+  JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_REQUIRE)
+    #undef JSON_HEDLEY_REQUIRE
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_MSG)
+    #undef JSON_HEDLEY_REQUIRE_MSG
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
+#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
+#    define JSON_HEDLEY_REQUIRE(expr) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), #expr, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((diagnose_if(!(expr), msg, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
+#    define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
+#  endif
+#else
+#  define JSON_HEDLEY_REQUIRE(expr)
+#  define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS)
+    #undef JSON_HEDLEY_FLAGS
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion"))
+    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
+#else
+    #define JSON_HEDLEY_FLAGS
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS_CAST)
+    #undef JSON_HEDLEY_FLAGS_CAST
+#endif
+#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        _Pragma("warning(disable:188)") \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
+#endif
+
+#if defined(JSON_HEDLEY_EMPTY_BASES)
+    #undef JSON_HEDLEY_EMPTY_BASES
+#endif
+#if \
+    (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \
+    JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)
+    #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
+#else
+    #define JSON_HEDLEY_EMPTY_BASES
+#endif
+
+/* Remaining macros are deprecated. */
+
+#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
+#else
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
+    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#endif
+#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
+    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
+    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#endif
+#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
+    #undef JSON_HEDLEY_CLANG_HAS_WARNING
+#endif
+#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
+
+#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
+
+
+// This file contains all internal macro definitions (except those affecting ABI)
+// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+// exclude unsupported compilers
+#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
+    #if defined(__clang__)
+        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
+            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
+        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
+            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #endif
+#endif
+
+// C++ language standard detection
+// if the user manually specified the used c++ version this is skipped
+#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)
+    #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
+        #define JSON_HAS_CPP_20
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+        #define JSON_HAS_CPP_17
+        #define JSON_HAS_CPP_14
+    #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+        #define JSON_HAS_CPP_14
+    #endif
+    // the cpp 11 flag is always specified because it is the minimal required version
+    #define JSON_HAS_CPP_11
+#endif
+
+#ifdef __has_include
+    #if __has_include(<version>)
+        #include <version>
+    #endif
+#endif
+
+#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)
+    #ifdef JSON_HAS_CPP_17
+        #if defined(__cpp_lib_filesystem)
+            #define JSON_HAS_FILESYSTEM 1
+        #elif defined(__cpp_lib_experimental_filesystem)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #elif !defined(__has_include)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #elif __has_include(<filesystem>)
+            #define JSON_HAS_FILESYSTEM 1
+        #elif __has_include(<experimental/filesystem>)
+            #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1
+        #endif
+
+        // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/
+        #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(__clang_major__) && __clang_major__ < 7
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support
+        #if defined(_MSC_VER) && _MSC_VER < 1914
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before iOS 13
+        #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+
+        // no filesystem support before macOS Catalina
+        #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
+            #undef JSON_HAS_FILESYSTEM
+            #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+        #endif
+    #endif
+#endif
+
+#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+    #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0
+#endif
+
+#ifndef JSON_HAS_FILESYSTEM
+    #define JSON_HAS_FILESYSTEM 0
+#endif
+
+#ifndef JSON_HAS_THREE_WAY_COMPARISON
+    #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \
+        && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L
+        #define JSON_HAS_THREE_WAY_COMPARISON 1
+    #else
+        #define JSON_HAS_THREE_WAY_COMPARISON 0
+    #endif
+#endif
+
+#ifndef JSON_HAS_RANGES
+    // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error
+    #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427
+        #define JSON_HAS_RANGES 0
+    #elif defined(__cpp_lib_ranges)
+        #define JSON_HAS_RANGES 1
+    #else
+        #define JSON_HAS_RANGES 0
+    #endif
+#endif
+
+#ifndef JSON_HAS_STATIC_RTTI
+    #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0
+        #define JSON_HAS_STATIC_RTTI 1
+    #else
+        #define JSON_HAS_STATIC_RTTI 0
+    #endif
+#endif
+
+#ifdef JSON_HAS_CPP_17
+    #define JSON_INLINE_VARIABLE inline
+#else
+    #define JSON_INLINE_VARIABLE
+#endif
+
+#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address)
+    #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#else
+    #define JSON_NO_UNIQUE_ADDRESS
+#endif
+
+// disable documentation warnings on clang
+#if defined(__clang__)
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wdocumentation"
+    #pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
+#endif
+
+// allow disabling exceptions
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
+    #define JSON_THROW(exception) throw exception
+    #define JSON_TRY try
+    #define JSON_CATCH(exception) catch(exception)
+    #define JSON_INTERNAL_CATCH(exception) catch(exception)
+#else
+    #include <cstdlib>
+    #define JSON_THROW(exception) std::abort()
+    #define JSON_TRY if(true)
+    #define JSON_CATCH(exception) if(false)
+    #define JSON_INTERNAL_CATCH(exception) if(false)
+#endif
+
+// override exception macros
+#if defined(JSON_THROW_USER)
+    #undef JSON_THROW
+    #define JSON_THROW JSON_THROW_USER
+#endif
+#if defined(JSON_TRY_USER)
+    #undef JSON_TRY
+    #define JSON_TRY JSON_TRY_USER
+#endif
+#if defined(JSON_CATCH_USER)
+    #undef JSON_CATCH
+    #define JSON_CATCH JSON_CATCH_USER
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
+#endif
+#if defined(JSON_INTERNAL_CATCH_USER)
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
+#endif
+
+// allow overriding assert
+#if !defined(JSON_ASSERT)
+    #include <cassert> // assert
+    #define JSON_ASSERT(x) assert(x)
+#endif
+
+// allow to access some private functions (needed by the test suite)
+#if defined(JSON_TESTS_PRIVATE)
+    #define JSON_PRIVATE_UNLESS_TESTED public
+#else
+    #define JSON_PRIVATE_UNLESS_TESTED private
+#endif
+
+/*!
+@brief macro to briefly define a mapping between an enum and JSON
+@def NLOHMANN_JSON_SERIALIZE_ENUM
+@since version 3.4.0
+*/
+#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                            \
+    template<typename BasicJsonType>                                                            \
+    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                   \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool  \
+        {                                                                                       \
+            return ej_pair.first == e;                                                          \
+        });                                                                                     \
+        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                 \
+    }                                                                                           \
+    template<typename BasicJsonType>                                                            \
+    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                 \
+    {                                                                                           \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");          \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                     \
+        auto it = std::find_if(std::begin(m), std::end(m),                                      \
+                               [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+        {                                                                                       \
+            return ej_pair.second == j;                                                         \
+        });                                                                                     \
+        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                  \
+    }
+
+// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
+// may be removed in the future once the class is split.
+
+#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
+    template<template<typename, typename, typename...> class ObjectType,   \
+             template<typename, typename...> class ArrayType,              \
+             class StringType, class BooleanType, class NumberIntegerType, \
+             class NumberUnsignedType, class NumberFloatType,              \
+             template<typename> class AllocatorType,                       \
+             template<typename, typename = void> class JSONSerializer,     \
+             class BinaryType,                                             \
+             class CustomBaseClass>
+
+#define NLOHMANN_BASIC_JSON_TPL                                            \
+    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
+    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
+    AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>
+
+// Macros to simplify conversion from/to types
+
+#define NLOHMANN_JSON_EXPAND( x ) x
+#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
+#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
+        NLOHMANN_JSON_PASTE64, \
+        NLOHMANN_JSON_PASTE63, \
+        NLOHMANN_JSON_PASTE62, \
+        NLOHMANN_JSON_PASTE61, \
+        NLOHMANN_JSON_PASTE60, \
+        NLOHMANN_JSON_PASTE59, \
+        NLOHMANN_JSON_PASTE58, \
+        NLOHMANN_JSON_PASTE57, \
+        NLOHMANN_JSON_PASTE56, \
+        NLOHMANN_JSON_PASTE55, \
+        NLOHMANN_JSON_PASTE54, \
+        NLOHMANN_JSON_PASTE53, \
+        NLOHMANN_JSON_PASTE52, \
+        NLOHMANN_JSON_PASTE51, \
+        NLOHMANN_JSON_PASTE50, \
+        NLOHMANN_JSON_PASTE49, \
+        NLOHMANN_JSON_PASTE48, \
+        NLOHMANN_JSON_PASTE47, \
+        NLOHMANN_JSON_PASTE46, \
+        NLOHMANN_JSON_PASTE45, \
+        NLOHMANN_JSON_PASTE44, \
+        NLOHMANN_JSON_PASTE43, \
+        NLOHMANN_JSON_PASTE42, \
+        NLOHMANN_JSON_PASTE41, \
+        NLOHMANN_JSON_PASTE40, \
+        NLOHMANN_JSON_PASTE39, \
+        NLOHMANN_JSON_PASTE38, \
+        NLOHMANN_JSON_PASTE37, \
+        NLOHMANN_JSON_PASTE36, \
+        NLOHMANN_JSON_PASTE35, \
+        NLOHMANN_JSON_PASTE34, \
+        NLOHMANN_JSON_PASTE33, \
+        NLOHMANN_JSON_PASTE32, \
+        NLOHMANN_JSON_PASTE31, \
+        NLOHMANN_JSON_PASTE30, \
+        NLOHMANN_JSON_PASTE29, \
+        NLOHMANN_JSON_PASTE28, \
+        NLOHMANN_JSON_PASTE27, \
+        NLOHMANN_JSON_PASTE26, \
+        NLOHMANN_JSON_PASTE25, \
+        NLOHMANN_JSON_PASTE24, \
+        NLOHMANN_JSON_PASTE23, \
+        NLOHMANN_JSON_PASTE22, \
+        NLOHMANN_JSON_PASTE21, \
+        NLOHMANN_JSON_PASTE20, \
+        NLOHMANN_JSON_PASTE19, \
+        NLOHMANN_JSON_PASTE18, \
+        NLOHMANN_JSON_PASTE17, \
+        NLOHMANN_JSON_PASTE16, \
+        NLOHMANN_JSON_PASTE15, \
+        NLOHMANN_JSON_PASTE14, \
+        NLOHMANN_JSON_PASTE13, \
+        NLOHMANN_JSON_PASTE12, \
+        NLOHMANN_JSON_PASTE11, \
+        NLOHMANN_JSON_PASTE10, \
+        NLOHMANN_JSON_PASTE9, \
+        NLOHMANN_JSON_PASTE8, \
+        NLOHMANN_JSON_PASTE7, \
+        NLOHMANN_JSON_PASTE6, \
+        NLOHMANN_JSON_PASTE5, \
+        NLOHMANN_JSON_PASTE4, \
+        NLOHMANN_JSON_PASTE3, \
+        NLOHMANN_JSON_PASTE2, \
+        NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
+#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
+#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
+#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
+#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
+#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
+#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
+#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
+#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
+#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
+#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
+#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
+#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
+#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
+#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
+#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
+#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
+#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
+#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
+#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
+#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
+#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
+#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
+#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
+#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
+#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
+#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
+#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
+#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
+#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
+#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
+#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
+#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
+#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
+#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
+#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
+#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
+#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
+#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
+#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
+#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
+#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
+#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
+#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
+#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
+#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
+#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
+#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
+#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
+#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
+#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
+#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
+#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
+#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
+#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
+#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
+#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
+#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
+#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
+#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
+#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
+#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
+
+#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
+#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
+#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1);
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_INTRUSIVE
+@since version 3.9.0
+*/
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+    friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+/*!
+@brief macro
+@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
+@since version 3.9.0
+*/
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) }
+
+#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...)  \
+    inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
+    inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }
+
+// inspired from https://stackoverflow.com/a/26745591
+// allows to call any std function as if (e.g. with begin):
+// using std::begin; begin(x);
+//
+// it allows using the detected idiom to retrieve the return type
+// of such an expression
+#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name)                                 \
+    namespace detail {                                                            \
+    using std::std_name;                                                          \
+    \
+    template<typename... T>                                                       \
+    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
+    }                                                                             \
+    \
+    namespace detail2 {                                                           \
+    struct std_name##_tag                                                         \
+    {                                                                             \
+    };                                                                            \
+    \
+    template<typename... T>                                                       \
+    std_name##_tag std_name(T&&...);                                              \
+    \
+    template<typename... T>                                                       \
+    using result_of_##std_name = decltype(std_name(std::declval<T>()...));        \
+    \
+    template<typename... T>                                                       \
+    struct would_call_std_##std_name                                              \
+    {                                                                             \
+        static constexpr auto const value = ::nlohmann::detail::                  \
+                                            is_detected_exact<std_name##_tag, result_of_##std_name, T...>::value; \
+    };                                                                            \
+    } /* namespace detail2 */ \
+    \
+    template<typename... T>                                                       \
+    struct would_call_std_##std_name : detail2::would_call_std_##std_name<T...>   \
+    {                                                                             \
+    }
+
+#ifndef JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_USE_IMPLICIT_CONVERSIONS 1
+#endif
+
+#if JSON_USE_IMPLICIT_CONVERSIONS
+    #define JSON_EXPLICIT
+#else
+    #define JSON_EXPLICIT explicit
+#endif
+
+#ifndef JSON_DISABLE_ENUM_SERIALIZATION
+    #define JSON_DISABLE_ENUM_SERIALIZATION 0
+#endif
+
+#ifndef JSON_USE_GLOBAL_UDLS
+    #define JSON_USE_GLOBAL_UDLS 1
+#endif
+
+#if JSON_HAS_THREE_WAY_COMPARISON
+    #include <compare> // partial_ordering
+#endif
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////////////////////
+// JSON type enumeration //
+///////////////////////////
+
+/*!
+@brief the JSON type enumeration
+
+This enumeration collects the different JSON types. It is internally used to
+distinguish the stored values, and the functions @ref basic_json::is_null(),
+@ref basic_json::is_object(), @ref basic_json::is_array(),
+@ref basic_json::is_string(), @ref basic_json::is_boolean(),
+@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
+@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
+@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
+@ref basic_json::is_structured() rely on it.
+
+@note There are three enumeration entries (number_integer, number_unsigned, and
+number_float), because the library distinguishes these three types for numbers:
+@ref basic_json::number_unsigned_t is used for unsigned integers,
+@ref basic_json::number_integer_t is used for signed integers, and
+@ref basic_json::number_float_t is used for floating-point numbers or to
+approximate integers which do not fit in the limits of their respective type.
+
+@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON
+value with the default value for a given type
+
+@since version 1.0.0
+*/
+enum class value_t : std::uint8_t
+{
+    null,             ///< null value
+    object,           ///< object (unordered set of name/value pairs)
+    array,            ///< array (ordered collection of values)
+    string,           ///< string value
+    boolean,          ///< boolean value
+    number_integer,   ///< number value (signed integer)
+    number_unsigned,  ///< number value (unsigned integer)
+    number_float,     ///< number value (floating-point)
+    binary,           ///< binary array (ordered collection of bytes)
+    discarded         ///< discarded by the parser callback function
+};
+
+/*!
+@brief comparison operator for JSON types
+
+Returns an ordering that is similar to Python:
+- order: null < boolean < number < object < array < string < binary
+- furthermore, each type is not smaller than itself
+- discarded values are not comparable
+- binary is represented as a b"" string in python and directly comparable to a
+  string; however, making a binary array directly comparable with a string would
+  be surprising behavior in a JSON file.
+
+@since version 1.0.0
+*/
+#if JSON_HAS_THREE_WAY_COMPARISON
+    inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*
+#else
+    inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+#endif
+{
+    static constexpr std::array<std::uint8_t, 9> order = {{
+            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
+            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
+            6 /* binary */
+        }
+    };
+
+    const auto l_index = static_cast<std::size_t>(lhs);
+    const auto r_index = static_cast<std::size_t>(rhs);
+#if JSON_HAS_THREE_WAY_COMPARISON
+    if (l_index < order.size() && r_index < order.size())
+    {
+        return order[l_index] <=> order[r_index]; // *NOPAD*
+    }
+    return std::partial_ordering::unordered;
+#else
+    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
+#endif
+}
+
+// GCC selects the built-in operator< over an operator rewritten from
+// a user-defined spaceship operator
+// Clang, MSVC, and ICC select the rewritten candidate
+// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200)
+#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__)
+inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+{
+    return std::is_lt(lhs <=> rhs); // *NOPAD*
+}
+#endif
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/string_escape.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief replace all occurrences of a substring by another string
+
+@param[in,out] s  the string to manipulate; changed so that all
+               occurrences of @a f are replaced with @a t
+@param[in]     f  the substring to replace with @a t
+@param[in]     t  the string to replace @a f
+
+@pre The search string @a f must not be empty. **This precondition is
+enforced with an assertion.**
+
+@since version 2.0.0
+*/
+template<typename StringType>
+inline void replace_substring(StringType& s, const StringType& f,
+                              const StringType& t)
+{
+    JSON_ASSERT(!f.empty());
+    for (auto pos = s.find(f);                // find first occurrence of f
+            pos != StringType::npos;          // make sure f was found
+            s.replace(pos, f.size(), t),      // replace with t, and
+            pos = s.find(f, pos + t.size()))  // find next occurrence of f
+    {}
+}
+
+/*!
+ * @brief string escaping as described in RFC 6901 (Sect. 4)
+ * @param[in] s string to escape
+ * @return    escaped string
+ *
+ * Note the order of escaping "~" to "~0" and "/" to "~1" is important.
+ */
+template<typename StringType>
+inline StringType escape(StringType s)
+{
+    replace_substring(s, StringType{"~"}, StringType{"~0"});
+    replace_substring(s, StringType{"/"}, StringType{"~1"});
+    return s;
+}
+
+/*!
+ * @brief string unescaping as described in RFC 6901 (Sect. 4)
+ * @param[in] s string to unescape
+ * @return    unescaped string
+ *
+ * Note the order of escaping "~1" to "/" and "~0" to "~" is important.
+ */
+template<typename StringType>
+static void unescape(StringType& s)
+{
+    replace_substring(s, StringType{"~1"}, StringType{"/"});
+    replace_substring(s, StringType{"~0"}, StringType{"~"});
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/position_t.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // size_t
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// struct to capture the start position of the current token
+struct position_t
+{
+    /// the total number of characters read
+    std::size_t chars_read_total = 0;
+    /// the number of characters read in the current line
+    std::size_t chars_read_current_line = 0;
+    /// the number of lines read
+    std::size_t lines_read = 0;
+
+    /// conversion to size_t to preserve SAX interface
+    constexpr operator size_t() const
+    {
+        return chars_read_total;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-FileCopyrightText: 2018 The Abseil Authors
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
+#include <utility> // index_sequence, make_index_sequence, index_sequence_for
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename T>
+using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+#ifdef JSON_HAS_CPP_14
+
+// the following utilities are natively available in C++14
+using std::enable_if_t;
+using std::index_sequence;
+using std::make_index_sequence;
+using std::index_sequence_for;
+
+#else
+
+// alias templates to reduce boilerplate
+template<bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h
+// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.
+
+//// START OF CODE FROM GOOGLE ABSEIL
+
+// integer_sequence
+//
+// Class template representing a compile-time integer sequence. An instantiation
+// of `integer_sequence<T, Ints...>` has a sequence of integers encoded in its
+// type through its template arguments (which is a common need when
+// working with C++11 variadic templates). `absl::integer_sequence` is designed
+// to be a drop-in replacement for C++14's `std::integer_sequence`.
+//
+// Example:
+//
+//   template< class T, T... Ints >
+//   void user_function(integer_sequence<T, Ints...>);
+//
+//   int main()
+//   {
+//     // user_function's `T` will be deduced to `int` and `Ints...`
+//     // will be deduced to `0, 1, 2, 3, 4`.
+//     user_function(make_integer_sequence<int, 5>());
+//   }
+template <typename T, T... Ints>
+struct integer_sequence
+{
+    using value_type = T;
+    static constexpr std::size_t size() noexcept
+    {
+        return sizeof...(Ints);
+    }
+};
+
+// index_sequence
+//
+// A helper template for an `integer_sequence` of `size_t`,
+// `absl::index_sequence` is designed to be a drop-in replacement for C++14's
+// `std::index_sequence`.
+template <size_t... Ints>
+using index_sequence = integer_sequence<size_t, Ints...>;
+
+namespace utility_internal
+{
+
+template <typename Seq, size_t SeqSize, size_t Rem>
+struct Extend;
+
+// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 0>
+{
+    using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;
+};
+
+template <typename T, T... Ints, size_t SeqSize>
+struct Extend<integer_sequence<T, Ints...>, SeqSize, 1>
+{
+    using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;
+};
+
+// Recursion helper for 'make_integer_sequence<T, N>'.
+// 'Gen<T, N>::type' is an alias for 'integer_sequence<T, 0, 1, ... N-1>'.
+template <typename T, size_t N>
+struct Gen
+{
+    using type =
+        typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;
+};
+
+template <typename T>
+struct Gen<T, 0>
+{
+    using type = integer_sequence<T>;
+};
+
+}  // namespace utility_internal
+
+// Compile-time sequences of integers
+
+// make_integer_sequence
+//
+// This template alias is equivalent to
+// `integer_sequence<int, 0, 1, ..., N-1>`, and is designed to be a drop-in
+// replacement for C++14's `std::make_integer_sequence`.
+template <typename T, T N>
+using make_integer_sequence = typename utility_internal::Gen<T, N>::type;
+
+// make_index_sequence
+//
+// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,
+// and is designed to be a drop-in replacement for C++14's
+// `std::make_index_sequence`.
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
+
+// index_sequence_for
+//
+// Converts a typename pack into an index sequence of the same length, and
+// is designed to be a drop-in replacement for C++14's
+// `std::index_sequence_for()`
+template <typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+//// END OF CODE FROM GOOGLE ABSEIL
+
+#endif
+
+// dispatch utility (taken from ranges-v3)
+template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
+template<> struct priority_tag<0> {};
+
+// taken from ranges-v3
+template<typename T>
+struct static_const
+{
+    static JSON_INLINE_VARIABLE constexpr T value{};
+};
+
+#ifndef JSON_HAS_CPP_17
+    template<typename T>
+    constexpr T static_const<T>::value;
+#endif
+
+template<typename T, typename... Args>
+inline constexpr std::array<T, sizeof...(Args)> make_array(Args&& ... args)
+{
+    return std::array<T, sizeof...(Args)> {{static_cast<T>(std::forward<Args>(args))...}};
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <limits> // numeric_limits
+#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
+#include <utility> // declval
+#include <tuple> // tuple
+#include <string> // char_traits
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <iterator> // random_access_iterator_tag
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename It, typename = void>
+struct iterator_types {};
+
+template<typename It>
+struct iterator_types <
+    It,
+    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
+    typename It::reference, typename It::iterator_category >>
+{
+    using difference_type = typename It::difference_type;
+    using value_type = typename It::value_type;
+    using pointer = typename It::pointer;
+    using reference = typename It::reference;
+    using iterator_category = typename It::iterator_category;
+};
+
+// This is required as some compilers implement std::iterator_traits in a way that
+// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
+template<typename T, typename = void>
+struct iterator_traits
+{
+};
+
+template<typename T>
+struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
+            : iterator_types<T>
+{
+};
+
+template<typename T>
+struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
+{
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = T;
+    using difference_type = ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/call_std/begin.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/call_std/end.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/json_fwd.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
+    #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+    #include <cstdint> // int64_t, uint64_t
+    #include <map> // map
+    #include <memory> // allocator
+    #include <string> // string
+    #include <vector> // vector
+
+    // #include <nlohmann/detail/abi_macros.hpp>
+
+
+    /*!
+    @brief namespace for Niels Lohmann
+    @see https://github.com/nlohmann
+    @since version 1.0.0
+    */
+    NLOHMANN_JSON_NAMESPACE_BEGIN
+
+    /*!
+    @brief default JSONSerializer template argument
+
+    This serializer ignores the template arguments and uses ADL
+    ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
+    for serialization.
+    */
+    template<typename T = void, typename SFINAE = void>
+    struct adl_serializer;
+
+    /// a class to store JSON values
+    /// @sa https://json.nlohmann.me/api/basic_json/
+    template<template<typename U, typename V, typename... Args> class ObjectType =
+    std::map,
+    template<typename U, typename... Args> class ArrayType = std::vector,
+    class StringType = std::string, class BooleanType = bool,
+    class NumberIntegerType = std::int64_t,
+    class NumberUnsignedType = std::uint64_t,
+    class NumberFloatType = double,
+    template<typename U> class AllocatorType = std::allocator,
+    template<typename T, typename SFINAE = void> class JSONSerializer =
+    adl_serializer,
+    class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
+    class CustomBaseClass = void>
+    class basic_json;
+
+    /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+    /// @sa https://json.nlohmann.me/api/json_pointer/
+    template<typename RefStringType>
+    class json_pointer;
+
+    /*!
+    @brief default specialization
+    @sa https://json.nlohmann.me/api/json/
+    */
+    using json = basic_json<>;
+
+    /// @brief a minimal map-like container that preserves insertion order
+    /// @sa https://json.nlohmann.me/api/ordered_map/
+    template<class Key, class T, class IgnoredLess, class Allocator>
+    struct ordered_map;
+
+    /// @brief specialization that maintains the insertion order of object keys
+    /// @sa https://json.nlohmann.me/api/ordered_json/
+    using ordered_json = basic_json<nlohmann::ordered_map>;
+
+    NLOHMANN_JSON_NAMESPACE_END
+
+#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+/*!
+@brief detail namespace with internal helper functions
+
+This namespace collects functions that should not be exposed,
+implementations of some @ref basic_json methods, and meta-programming helpers.
+
+@since version 2.1.0
+*/
+namespace detail
+{
+
+/////////////
+// helpers //
+/////////////
+
+// Note to maintainers:
+//
+// Every trait in this file expects a non CV-qualified type.
+// The only exceptions are in the 'aliases for detected' section
+// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
+//
+// In this case, T has to be properly CV-qualified to constraint the function arguments
+// (e.g. to_json(BasicJsonType&, const T&))
+
+template<typename> struct is_basic_json : std::false_type {};
+
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
+
+// used by exceptions create() member functions
+// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t
+// false_type otherwise
+template<typename BasicJsonContext>
+struct is_basic_json_context :
+    std::integral_constant < bool,
+    is_basic_json<typename std::remove_cv<typename std::remove_pointer<BasicJsonContext>::type>::type>::value
+    || std::is_same<BasicJsonContext, std::nullptr_t>::value >
+{};
+
+//////////////////////
+// json_ref helpers //
+//////////////////////
+
+template<typename>
+class json_ref;
+
+template<typename>
+struct is_json_ref : std::false_type {};
+
+template<typename T>
+struct is_json_ref<json_ref<T>> : std::true_type {};
+
+//////////////////////////
+// aliases for detected //
+//////////////////////////
+
+template<typename T>
+using mapped_type_t = typename T::mapped_type;
+
+template<typename T>
+using key_type_t = typename T::key_type;
+
+template<typename T>
+using value_type_t = typename T::value_type;
+
+template<typename T>
+using difference_type_t = typename T::difference_type;
+
+template<typename T>
+using pointer_t = typename T::pointer;
+
+template<typename T>
+using reference_t = typename T::reference;
+
+template<typename T>
+using iterator_category_t = typename T::iterator_category;
+
+template<typename T, typename... Args>
+using to_json_function = decltype(T::to_json(std::declval<Args>()...));
+
+template<typename T, typename... Args>
+using from_json_function = decltype(T::from_json(std::declval<Args>()...));
+
+template<typename T, typename U>
+using get_template_function = decltype(std::declval<T>().template get<U>());
+
+// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
+template<typename BasicJsonType, typename T, typename = void>
+struct has_from_json : std::false_type {};
+
+// trait checking if j.get<T> is valid
+// use this trait instead of std::is_constructible or std::is_convertible,
+// both rely on, or make use of implicit conversions, and thus fail when T
+// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
+template <typename BasicJsonType, typename T>
+struct is_getable
+{
+    static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
+};
+
+template<typename BasicJsonType, typename T>
+struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, from_json_function, serializer,
+        const BasicJsonType&, T&>::value;
+};
+
+// This trait checks if JSONSerializer<T>::from_json(json const&) exists
+// this overload is used for non-default-constructible user-defined-types
+template<typename BasicJsonType, typename T, typename = void>
+struct has_non_default_from_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<T, from_json_function, serializer,
+        const BasicJsonType&>::value;
+};
+
+// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
+// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
+template<typename BasicJsonType, typename T, typename = void>
+struct has_to_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
+        T>::value;
+};
+
+template<typename T>
+using detect_key_compare = typename T::key_compare;
+
+template<typename T>
+struct has_key_compare : std::integral_constant<bool, is_detected<detect_key_compare, T>::value> {};
+
+// obtains the actual object key comparator
+template<typename BasicJsonType>
+struct actual_object_comparator
+{
+    using object_t = typename BasicJsonType::object_t;
+    using object_comparator_t = typename BasicJsonType::default_object_comparator_t;
+    using type = typename std::conditional < has_key_compare<object_t>::value,
+          typename object_t::key_compare, object_comparator_t>::type;
+};
+
+template<typename BasicJsonType>
+using actual_object_comparator_t = typename actual_object_comparator<BasicJsonType>::type;
+
+/////////////////
+// char_traits //
+/////////////////
+
+// Primary template of char_traits calls std char_traits
+template<typename T>
+struct char_traits : std::char_traits<T>
+{};
+
+// Explicitly define char traits for unsigned char since it is not standard
+template<>
+struct char_traits<unsigned char> : std::char_traits<char>
+{
+    using char_type = unsigned char;
+    using int_type = uint64_t;
+
+    // Redefine to_int_type function
+    static int_type to_int_type(char_type c) noexcept
+    {
+        return static_cast<int_type>(c);
+    }
+
+    static char_type to_char_type(int_type i) noexcept
+    {
+        return static_cast<char_type>(i);
+    }
+
+    static constexpr int_type eof() noexcept
+    {
+        return static_cast<int_type>(EOF);
+    }
+};
+
+// Explicitly define char traits for signed char since it is not standard
+template<>
+struct char_traits<signed char> : std::char_traits<char>
+{
+    using char_type = signed char;
+    using int_type = uint64_t;
+
+    // Redefine to_int_type function
+    static int_type to_int_type(char_type c) noexcept
+    {
+        return static_cast<int_type>(c);
+    }
+
+    static char_type to_char_type(int_type i) noexcept
+    {
+        return static_cast<char_type>(i);
+    }
+
+    static constexpr int_type eof() noexcept
+    {
+        return static_cast<int_type>(EOF);
+    }
+};
+
+///////////////////
+// is_ functions //
+///////////////////
+
+// https://en.cppreference.com/w/cpp/types/conjunction
+template<class...> struct conjunction : std::true_type { };
+template<class B> struct conjunction<B> : B { };
+template<class B, class... Bn>
+struct conjunction<B, Bn...>
+: std::conditional<static_cast<bool>(B::value), conjunction<Bn...>, B>::type {};
+
+// https://en.cppreference.com/w/cpp/types/negation
+template<class B> struct negation : std::integral_constant < bool, !B::value > { };
+
+// Reimplementation of is_constructible and is_default_constructible, due to them being broken for
+// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).
+// This causes compile errors in e.g. clang 3.5 or gcc 4.9.
+template <typename T>
+struct is_default_constructible : std::is_default_constructible<T> {};
+
+template <typename T1, typename T2>
+struct is_default_constructible<std::pair<T1, T2>>
+            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+
+template <typename T1, typename T2>
+struct is_default_constructible<const std::pair<T1, T2>>
+            : conjunction<is_default_constructible<T1>, is_default_constructible<T2>> {};
+
+template <typename... Ts>
+struct is_default_constructible<std::tuple<Ts...>>
+            : conjunction<is_default_constructible<Ts>...> {};
+
+template <typename... Ts>
+struct is_default_constructible<const std::tuple<Ts...>>
+            : conjunction<is_default_constructible<Ts>...> {};
+
+template <typename T, typename... Args>
+struct is_constructible : std::is_constructible<T, Args...> {};
+
+template <typename T1, typename T2>
+struct is_constructible<std::pair<T1, T2>> : is_default_constructible<std::pair<T1, T2>> {};
+
+template <typename T1, typename T2>
+struct is_constructible<const std::pair<T1, T2>> : is_default_constructible<const std::pair<T1, T2>> {};
+
+template <typename... Ts>
+struct is_constructible<std::tuple<Ts...>> : is_default_constructible<std::tuple<Ts...>> {};
+
+template <typename... Ts>
+struct is_constructible<const std::tuple<Ts...>> : is_default_constructible<const std::tuple<Ts...>> {};
+
+template<typename T, typename = void>
+struct is_iterator_traits : std::false_type {};
+
+template<typename T>
+struct is_iterator_traits<iterator_traits<T>>
+{
+  private:
+    using traits = iterator_traits<T>;
+
+  public:
+    static constexpr auto value =
+        is_detected<value_type_t, traits>::value &&
+        is_detected<difference_type_t, traits>::value &&
+        is_detected<pointer_t, traits>::value &&
+        is_detected<iterator_category_t, traits>::value &&
+        is_detected<reference_t, traits>::value;
+};
+
+template<typename T>
+struct is_range
+{
+  private:
+    using t_ref = typename std::add_lvalue_reference<T>::type;
+
+    using iterator = detected_t<result_of_begin, t_ref>;
+    using sentinel = detected_t<result_of_end, t_ref>;
+
+    // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator
+    // and https://en.cppreference.com/w/cpp/iterator/sentinel_for
+    // but reimplementing these would be too much work, as a lot of other concepts are used underneath
+    static constexpr auto is_iterator_begin =
+        is_iterator_traits<iterator_traits<iterator>>::value;
+
+  public:
+    static constexpr bool value = !std::is_same<iterator, nonesuch>::value && !std::is_same<sentinel, nonesuch>::value && is_iterator_begin;
+};
+
+template<typename R>
+using iterator_t = enable_if_t<is_range<R>::value, result_of_begin<decltype(std::declval<R&>())>>;
+
+template<typename T>
+using range_value_t = value_type_t<iterator_traits<iterator_t<T>>>;
+
+// The following implementation of is_complete_type is taken from
+// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/
+// and is written by Xiang Fan who agreed to using it in this library.
+
+template<typename T, typename = void>
+struct is_complete_type : std::false_type {};
+
+template<typename T>
+struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType,
+         typename = void>
+struct is_compatible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type_impl <
+    BasicJsonType, CompatibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
+    is_detected<key_type_t, CompatibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    // macOS's is_constructible does not play well with nonesuch...
+    static constexpr bool value =
+        is_constructible<typename object_t::key_type,
+        typename CompatibleObjectType::key_type>::value &&
+        is_constructible<typename object_t::mapped_type,
+        typename CompatibleObjectType::mapped_type>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type
+    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         typename = void>
+struct is_constructible_object_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type_impl <
+    BasicJsonType, ConstructibleObjectType,
+    enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
+    is_detected<key_type_t, ConstructibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    static constexpr bool value =
+        (is_default_constructible<ConstructibleObjectType>::value &&
+         (std::is_move_assignable<ConstructibleObjectType>::value ||
+          std::is_copy_assignable<ConstructibleObjectType>::value) &&
+         (is_constructible<typename ConstructibleObjectType::key_type,
+          typename object_t::key_type>::value &&
+          std::is_same <
+          typename object_t::mapped_type,
+          typename ConstructibleObjectType::mapped_type >::value)) ||
+        (has_from_json<BasicJsonType,
+         typename ConstructibleObjectType::mapped_type>::value ||
+         has_non_default_from_json <
+         BasicJsonType,
+         typename ConstructibleObjectType::mapped_type >::value);
+};
+
+template<typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type
+    : is_constructible_object_type_impl<BasicJsonType,
+      ConstructibleObjectType> {};
+
+template<typename BasicJsonType, typename CompatibleStringType>
+struct is_compatible_string_type
+{
+    static constexpr auto value =
+        is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type
+{
+    // launder type through decltype() to fix compilation failure on ICPC
+#ifdef __INTEL_COMPILER
+    using laundered_type = decltype(std::declval<ConstructibleStringType>());
+#else
+    using laundered_type = ConstructibleStringType;
+#endif
+
+    static constexpr auto value =
+        conjunction <
+        is_constructible<laundered_type, typename BasicJsonType::string_t>,
+        is_detected_exact<typename BasicJsonType::string_t::value_type,
+        value_type_t, laundered_type >>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
+struct is_compatible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type_impl <
+    BasicJsonType, CompatibleArrayType,
+    enable_if_t <
+    is_detected<iterator_t, CompatibleArrayType>::value&&
+    is_iterator_traits<iterator_traits<detected_t<iterator_t, CompatibleArrayType>>>::value&&
+// special case for types like std::filesystem::path whose iterator's value_type are themselves
+// c.f. https://github.com/nlohmann/json/pull/3073
+    !std::is_same<CompatibleArrayType, detected_t<range_value_t, CompatibleArrayType>>::value >>
+{
+    static constexpr bool value =
+        is_constructible<BasicJsonType,
+        range_value_t<CompatibleArrayType>>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type
+    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
+struct is_constructible_array_type_impl : std::false_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t<std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value >>
+            : std::true_type {};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t < !std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value&&
+    !is_compatible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+    is_default_constructible<ConstructibleArrayType>::value&&
+(std::is_move_assignable<ConstructibleArrayType>::value ||
+ std::is_copy_assignable<ConstructibleArrayType>::value)&&
+is_detected<iterator_t, ConstructibleArrayType>::value&&
+is_iterator_traits<iterator_traits<detected_t<iterator_t, ConstructibleArrayType>>>::value&&
+is_detected<range_value_t, ConstructibleArrayType>::value&&
+// special case for types like std::filesystem::path whose iterator's value_type are themselves
+// c.f. https://github.com/nlohmann/json/pull/3073
+!std::is_same<ConstructibleArrayType, detected_t<range_value_t, ConstructibleArrayType>>::value&&
+        is_complete_type <
+        detected_t<range_value_t, ConstructibleArrayType >>::value >>
+{
+    using value_type = range_value_t<ConstructibleArrayType>;
+
+    static constexpr bool value =
+        std::is_same<value_type,
+        typename BasicJsonType::array_t::value_type>::value ||
+        has_from_json<BasicJsonType,
+        value_type>::value ||
+        has_non_default_from_json <
+        BasicJsonType,
+        value_type >::value;
+};
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type
+    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType,
+         typename = void>
+struct is_compatible_integer_type_impl : std::false_type {};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type_impl <
+    RealIntegerType, CompatibleNumberIntegerType,
+    enable_if_t < std::is_integral<RealIntegerType>::value&&
+    std::is_integral<CompatibleNumberIntegerType>::value&&
+    !std::is_same<bool, CompatibleNumberIntegerType>::value >>
+{
+    // is there an assert somewhere on overflows?
+    using RealLimits = std::numeric_limits<RealIntegerType>;
+    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
+
+    static constexpr auto value =
+        is_constructible<RealIntegerType,
+        CompatibleNumberIntegerType>::value &&
+        CompatibleLimits::is_integer &&
+        RealLimits::is_signed == CompatibleLimits::is_signed;
+};
+
+template<typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type
+    : is_compatible_integer_type_impl<RealIntegerType,
+      CompatibleNumberIntegerType> {};
+
+template<typename BasicJsonType, typename CompatibleType, typename = void>
+struct is_compatible_type_impl: std::false_type {};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type_impl <
+    BasicJsonType, CompatibleType,
+    enable_if_t<is_complete_type<CompatibleType>::value >>
+{
+    static constexpr bool value =
+        has_to_json<BasicJsonType, CompatibleType>::value;
+};
+
+template<typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type
+    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
+
+template<typename T1, typename T2>
+struct is_constructible_tuple : std::false_type {};
+
+template<typename T1, typename... Args>
+struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<is_constructible<T1, Args>...> {};
+
+template<typename BasicJsonType, typename T>
+struct is_json_iterator_of : std::false_type {};
+
+template<typename BasicJsonType>
+struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::iterator> : std::true_type {};
+
+template<typename BasicJsonType>
+struct is_json_iterator_of<BasicJsonType, typename BasicJsonType::const_iterator> : std::true_type
+{};
+
+// checks if a given type T is a template specialization of Primary
+template<template <typename...> class Primary, typename T>
+struct is_specialization_of : std::false_type {};
+
+template<template <typename...> class Primary, typename... Args>
+struct is_specialization_of<Primary, Primary<Args...>> : std::true_type {};
+
+template<typename T>
+using is_json_pointer = is_specialization_of<::nlohmann::json_pointer, uncvref_t<T>>;
+
+// checks if A and B are comparable using Compare functor
+template<typename Compare, typename A, typename B, typename = void>
+struct is_comparable : std::false_type {};
+
+template<typename Compare, typename A, typename B>
+struct is_comparable<Compare, A, B, void_t<
+decltype(std::declval<Compare>()(std::declval<A>(), std::declval<B>())),
+decltype(std::declval<Compare>()(std::declval<B>(), std::declval<A>()))
+>> : std::true_type {};
+
+template<typename T>
+using detect_is_transparent = typename T::is_transparent;
+
+// type trait to check if KeyType can be used as object key (without a BasicJsonType)
+// see is_usable_as_basic_json_key_type below
+template<typename Comparator, typename ObjectKeyType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
+         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
+using is_usable_as_key_type = typename std::conditional <
+                              is_comparable<Comparator, ObjectKeyType, KeyTypeCVRef>::value
+                              && !(ExcludeObjectKeyType && std::is_same<KeyType,
+                                   ObjectKeyType>::value)
+                              && (!RequireTransparentComparator
+                                  || is_detected <detect_is_transparent, Comparator>::value)
+                              && !is_json_pointer<KeyType>::value,
+                              std::true_type,
+                              std::false_type >::type;
+
+// type trait to check if KeyType can be used as object key
+// true if:
+//   - KeyType is comparable with BasicJsonType::object_t::key_type
+//   - if ExcludeObjectKeyType is true, KeyType is not BasicJsonType::object_t::key_type
+//   - the comparator is transparent or RequireTransparentComparator is false
+//   - KeyType is not a JSON iterator or json_pointer
+template<typename BasicJsonType, typename KeyTypeCVRef, bool RequireTransparentComparator = true,
+         bool ExcludeObjectKeyType = RequireTransparentComparator, typename KeyType = uncvref_t<KeyTypeCVRef>>
+using is_usable_as_basic_json_key_type = typename std::conditional <
+        is_usable_as_key_type<typename BasicJsonType::object_comparator_t,
+        typename BasicJsonType::object_t::key_type, KeyTypeCVRef,
+        RequireTransparentComparator, ExcludeObjectKeyType>::value
+        && !is_json_iterator_of<BasicJsonType, KeyType>::value,
+        std::true_type,
+        std::false_type >::type;
+
+template<typename ObjectType, typename KeyType>
+using detect_erase_with_key_type = decltype(std::declval<ObjectType&>().erase(std::declval<KeyType>()));
+
+// type trait to check if object_t has an erase() member functions accepting KeyType
+template<typename BasicJsonType, typename KeyType>
+using has_erase_with_key_type = typename std::conditional <
+                                is_detected <
+                                detect_erase_with_key_type,
+                                typename BasicJsonType::object_t, KeyType >::value,
+                                std::true_type,
+                                std::false_type >::type;
+
+// a naive helper to check if a type is an ordered_map (exploits the fact that
+// ordered_map inherits capacity() from std::vector)
+template <typename T>
+struct is_ordered_map
+{
+    using one = char;
+
+    struct two
+    {
+        char x[2]; // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+    };
+
+    template <typename C> static one test( decltype(&C::capacity) ) ;
+    template <typename C> static two test(...);
+
+    enum { value = sizeof(test<T>(nullptr)) == sizeof(char) }; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+};
+
+// to avoid useless casts (see https://github.com/nlohmann/json/issues/2893#issuecomment-889152324)
+template < typename T, typename U, enable_if_t < !std::is_same<T, U>::value, int > = 0 >
+T conditional_static_cast(U value)
+{
+    return static_cast<T>(value);
+}
+
+template<typename T, typename U, enable_if_t<std::is_same<T, U>::value, int> = 0>
+T conditional_static_cast(U value)
+{
+    return value;
+}
+
+template<typename... Types>
+using all_integral = conjunction<std::is_integral<Types>...>;
+
+template<typename... Types>
+using all_signed = conjunction<std::is_signed<Types>...>;
+
+template<typename... Types>
+using all_unsigned = conjunction<std::is_unsigned<Types>...>;
+
+// there's a disjunction trait in another PR; replace when merged
+template<typename... Types>
+using same_sign = std::integral_constant < bool,
+      all_signed<Types...>::value || all_unsigned<Types...>::value >;
+
+template<typename OfType, typename T>
+using never_out_of_range = std::integral_constant < bool,
+      (std::is_signed<OfType>::value && (sizeof(T) < sizeof(OfType)))
+      || (same_sign<OfType, T>::value && sizeof(OfType) == sizeof(T)) >;
+
+template<typename OfType, typename T,
+         bool OfTypeSigned = std::is_signed<OfType>::value,
+         bool TSigned = std::is_signed<T>::value>
+struct value_in_range_of_impl2;
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, false, false>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, true, false>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, false, true>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return val >= 0 && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl2<OfType, T, true, true>
+{
+    static constexpr bool test(T val)
+    {
+        using CommonType = typename std::common_type<OfType, T>::type;
+        return static_cast<CommonType>(val) >= static_cast<CommonType>((std::numeric_limits<OfType>::min)())
+               && static_cast<CommonType>(val) <= static_cast<CommonType>((std::numeric_limits<OfType>::max)());
+    }
+};
+
+template<typename OfType, typename T,
+         bool NeverOutOfRange = never_out_of_range<OfType, T>::value,
+         typename = detail::enable_if_t<all_integral<OfType, T>::value>>
+struct value_in_range_of_impl1;
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl1<OfType, T, false>
+{
+    static constexpr bool test(T val)
+    {
+        return value_in_range_of_impl2<OfType, T>::test(val);
+    }
+};
+
+template<typename OfType, typename T>
+struct value_in_range_of_impl1<OfType, T, true>
+{
+    static constexpr bool test(T /*val*/)
+    {
+        return true;
+    }
+};
+
+template<typename OfType, typename T>
+inline constexpr bool value_in_range_of(T val)
+{
+    return value_in_range_of_impl1<OfType, T>::test(val);
+}
+
+template<bool Value>
+using bool_constant = std::integral_constant<bool, Value>;
+
+///////////////////////////////////////////////////////////////////////////////
+// is_c_string
+///////////////////////////////////////////////////////////////////////////////
+
+namespace impl
+{
+
+template<typename T>
+inline constexpr bool is_c_string()
+{
+    using TUnExt = typename std::remove_extent<T>::type;
+    using TUnCVExt = typename std::remove_cv<TUnExt>::type;
+    using TUnPtr = typename std::remove_pointer<T>::type;
+    using TUnCVPtr = typename std::remove_cv<TUnPtr>::type;
+    return
+        (std::is_array<T>::value && std::is_same<TUnCVExt, char>::value)
+        || (std::is_pointer<T>::value && std::is_same<TUnCVPtr, char>::value);
+}
+
+}  // namespace impl
+
+// checks whether T is a [cv] char */[cv] char[] C string
+template<typename T>
+struct is_c_string : bool_constant<impl::is_c_string<T>()> {};
+
+template<typename T>
+using is_c_string_uncvref = is_c_string<uncvref_t<T>>;
+
+///////////////////////////////////////////////////////////////////////////////
+// is_transparent
+///////////////////////////////////////////////////////////////////////////////
+
+namespace impl
+{
+
+template<typename T>
+inline constexpr bool is_transparent()
+{
+    return is_detected<detect_is_transparent, T>::value;
+}
+
+}  // namespace impl
+
+// checks whether T has a member named is_transparent
+template<typename T>
+struct is_transparent : bool_constant<impl::is_transparent<T>()> {};
+
+///////////////////////////////////////////////////////////////////////////////
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/string_concat.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstring> // strlen
+#include <string> // string
+#include <utility> // forward
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+inline std::size_t concat_length()
+{
+    return 0;
+}
+
+template<typename... Args>
+inline std::size_t concat_length(const char* cstr, const Args& ... rest);
+
+template<typename StringType, typename... Args>
+inline std::size_t concat_length(const StringType& str, const Args& ... rest);
+
+template<typename... Args>
+inline std::size_t concat_length(const char /*c*/, const Args& ... rest)
+{
+    return 1 + concat_length(rest...);
+}
+
+template<typename... Args>
+inline std::size_t concat_length(const char* cstr, const Args& ... rest)
+{
+    // cppcheck-suppress ignoredReturnValue
+    return ::strlen(cstr) + concat_length(rest...);
+}
+
+template<typename StringType, typename... Args>
+inline std::size_t concat_length(const StringType& str, const Args& ... rest)
+{
+    return str.size() + concat_length(rest...);
+}
+
+template<typename OutStringType>
+inline void concat_into(OutStringType& /*out*/)
+{}
+
+template<typename StringType, typename Arg>
+using string_can_append = decltype(std::declval<StringType&>().append(std::declval < Arg && > ()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append = is_detected<string_can_append, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_op = decltype(std::declval<StringType&>() += std::declval < Arg && > ());
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_op = is_detected<string_can_append_op, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_iter = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().begin(), std::declval<const Arg&>().end()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_iter = is_detected<string_can_append_iter, StringType, Arg>;
+
+template<typename StringType, typename Arg>
+using string_can_append_data = decltype(std::declval<StringType&>().append(std::declval<const Arg&>().data(), std::declval<const Arg&>().size()));
+
+template<typename StringType, typename Arg>
+using detect_string_can_append_data = is_detected<string_can_append_data, StringType, Arg>;
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && detect_string_can_append_op<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest);
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && !detect_string_can_append_iter<OutStringType, Arg>::value
+                         && detect_string_can_append_data<OutStringType, Arg>::value, int > = 0 >
+inline void concat_into(OutStringType& out, const Arg& arg, Args && ... rest);
+
+template<typename OutStringType, typename Arg, typename... Args,
+         enable_if_t<detect_string_can_append<OutStringType, Arg>::value, int> = 0>
+inline void concat_into(OutStringType& out, Arg && arg, Args && ... rest)
+{
+    out.append(std::forward<Arg>(arg));
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && detect_string_can_append_op<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, Arg&& arg, Args&& ... rest)
+{
+    out += std::forward<Arg>(arg);
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && detect_string_can_append_iter<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
+{
+    out.append(arg.begin(), arg.end());
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template < typename OutStringType, typename Arg, typename... Args,
+           enable_if_t < !detect_string_can_append<OutStringType, Arg>::value
+                         && !detect_string_can_append_op<OutStringType, Arg>::value
+                         && !detect_string_can_append_iter<OutStringType, Arg>::value
+                         && detect_string_can_append_data<OutStringType, Arg>::value, int > >
+inline void concat_into(OutStringType& out, const Arg& arg, Args&& ... rest)
+{
+    out.append(arg.data(), arg.size());
+    concat_into(out, std::forward<Args>(rest)...);
+}
+
+template<typename OutStringType = std::string, typename... Args>
+inline OutStringType concat(Args && ... args)
+{
+    OutStringType str;
+    str.reserve(concat_length(args...));
+    concat_into(str, std::forward<Args>(args)...);
+    return str;
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+////////////////
+// exceptions //
+////////////////
+
+/// @brief general exception of the @ref basic_json class
+/// @sa https://json.nlohmann.me/api/basic_json/exception/
+class exception : public std::exception
+{
+  public:
+    /// returns the explanatory string
+    const char* what() const noexcept override
+    {
+        return m.what();
+    }
+
+    /// the id of the exception
+    const int id; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
+
+  protected:
+    JSON_HEDLEY_NON_NULL(3)
+    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {} // NOLINT(bugprone-throw-keyword-missing)
+
+    static std::string name(const std::string& ename, int id_)
+    {
+        return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
+    }
+
+    static std::string diagnostics(std::nullptr_t /*leaf_element*/)
+    {
+        return "";
+    }
+
+    template<typename BasicJsonType>
+    static std::string diagnostics(const BasicJsonType* leaf_element)
+    {
+#if JSON_DIAGNOSTICS
+        std::vector<std::string> tokens;
+        for (const auto* current = leaf_element; current != nullptr && current->m_parent != nullptr; current = current->m_parent)
+        {
+            switch (current->m_parent->type())
+            {
+                case value_t::array:
+                {
+                    for (std::size_t i = 0; i < current->m_parent->m_data.m_value.array->size(); ++i)
+                    {
+                        if (&current->m_parent->m_data.m_value.array->operator[](i) == current)
+                        {
+                            tokens.emplace_back(std::to_string(i));
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                case value_t::object:
+                {
+                    for (const auto& element : *current->m_parent->m_data.m_value.object)
+                    {
+                        if (&element.second == current)
+                        {
+                            tokens.emplace_back(element.first.c_str());
+                            break;
+                        }
+                    }
+                    break;
+                }
+
+                case value_t::null: // LCOV_EXCL_LINE
+                case value_t::string: // LCOV_EXCL_LINE
+                case value_t::boolean: // LCOV_EXCL_LINE
+                case value_t::number_integer: // LCOV_EXCL_LINE
+                case value_t::number_unsigned: // LCOV_EXCL_LINE
+                case value_t::number_float: // LCOV_EXCL_LINE
+                case value_t::binary: // LCOV_EXCL_LINE
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:   // LCOV_EXCL_LINE
+                    break; // LCOV_EXCL_LINE
+            }
+        }
+
+        if (tokens.empty())
+        {
+            return "";
+        }
+
+        auto str = std::accumulate(tokens.rbegin(), tokens.rend(), std::string{},
+                                   [](const std::string & a, const std::string & b)
+        {
+            return concat(a, '/', detail::escape(b));
+        });
+        return concat('(', str, ") ");
+#else
+        static_cast<void>(leaf_element);
+        return "";
+#endif
+    }
+
+  private:
+    /// an exception object as storage for error messages
+    std::runtime_error m;
+};
+
+/// @brief exception indicating a parse error
+/// @sa https://json.nlohmann.me/api/basic_json/parse_error/
+class parse_error : public exception
+{
+  public:
+    /*!
+    @brief create a parse error exception
+    @param[in] id_       the id of the exception
+    @param[in] pos       the position where the error occurred (or with
+                         chars_read_total=0 if the position cannot be
+                         determined)
+    @param[in] what_arg  the explanatory string
+    @return parse_error object
+    */
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("parse_error", id_), "parse error",
+                                     position_string(pos), ": ", exception::diagnostics(context), what_arg);
+        return {id_, pos.chars_read_total, w.c_str()};
+    }
+
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("parse_error", id_), "parse error",
+                                     (byte_ != 0 ? (concat(" at byte ", std::to_string(byte_))) : ""),
+                                     ": ", exception::diagnostics(context), what_arg);
+        return {id_, byte_, w.c_str()};
+    }
+
+    /*!
+    @brief byte index of the parse error
+
+    The byte index of the last read character in the input file.
+
+    @note For an input with n bytes, 1 is the index of the first character and
+          n+1 is the index of the terminating null byte or the end of file.
+          This also holds true when reading a byte vector (CBOR or MessagePack).
+    */
+    const std::size_t byte;
+
+  private:
+    parse_error(int id_, std::size_t byte_, const char* what_arg)
+        : exception(id_, what_arg), byte(byte_) {}
+
+    static std::string position_string(const position_t& pos)
+    {
+        return concat(" at line ", std::to_string(pos.lines_read + 1),
+                      ", column ", std::to_string(pos.chars_read_current_line));
+    }
+};
+
+/// @brief exception indicating errors with iterators
+/// @sa https://json.nlohmann.me/api/basic_json/invalid_iterator/
+class invalid_iterator : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static invalid_iterator create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("invalid_iterator", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    invalid_iterator(int id_, const char* what_arg)
+        : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating executing a member function with a wrong type
+/// @sa https://json.nlohmann.me/api/basic_json/type_error/
+class type_error : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating access out of the defined range
+/// @sa https://json.nlohmann.me/api/basic_json/out_of_range/
+class out_of_range : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/// @brief exception indicating other library errors
+/// @sa https://json.nlohmann.me/api/basic_json/other_error/
+class other_error : public exception
+{
+  public:
+    template<typename BasicJsonContext, enable_if_t<is_basic_json_context<BasicJsonContext>::value, int> = 0>
+    static other_error create(int id_, const std::string& what_arg, BasicJsonContext context)
+    {
+        const std::string w = concat(exception::name("other_error", id_), exception::diagnostics(context), what_arg);
+        return {id_, w.c_str()};
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/identity_tag.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// dispatching helper struct
+template <class T> struct identity_tag {};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/std_fs.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+#if JSON_HAS_EXPERIMENTAL_FILESYSTEM
+#include <experimental/filesystem>
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace std_fs = std::experimental::filesystem;
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+#elif JSON_HAS_FILESYSTEM
+#include <filesystem>
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+namespace std_fs = std::filesystem;
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+#endif
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be null, but is ", j.type_name()), &j));
+    }
+    n = nullptr;
+}
+
+// overloads for basic_json template parameters
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
+                         !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+                         int > = 0 >
+void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+
+        case value_t::null:
+        case value_t::object:
+        case value_t::array:
+        case value_t::string:
+        case value_t::boolean:
+        case value_t::binary:
+        case value_t::discarded:
+        default:
+            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
+    }
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
+    }
+    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template <
+    typename BasicJsonType, typename StringType,
+    enable_if_t <
+        std::is_assignable<StringType&, const typename BasicJsonType::string_t>::value
+        && is_detected_exact<typename BasicJsonType::string_t::value_type, value_type_t, StringType>::value
+        && !std::is_same<typename BasicJsonType::string_t, StringType>::value
+        && !is_json_ref<StringType>::value, int > = 0 >
+inline void from_json(const BasicJsonType& j, StringType& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+#if !JSON_DISABLE_ENUM_SERIALIZATION
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, EnumType& e)
+{
+    typename std::underlying_type<EnumType>::type val;
+    get_arithmetic_value(j, val);
+    e = static_cast<EnumType>(val);
+}
+#endif  // JSON_DISABLE_ENUM_SERIALIZATION
+
+// forward_list doesn't have an insert method
+template<typename BasicJsonType, typename T, typename Allocator,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    l.clear();
+    std::transform(j.rbegin(), j.rend(),
+                   std::front_inserter(l), [](const BasicJsonType & i)
+    {
+        return i.template get<T>();
+    });
+}
+
+// valarray doesn't have an insert method
+template<typename BasicJsonType, typename T,
+         enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, std::valarray<T>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    l.resize(j.size());
+    std::transform(j.begin(), j.end(), std::begin(l),
+                   [](const BasicJsonType & elem)
+    {
+        return elem.template get<T>();
+    });
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json(const BasicJsonType& j, T (&arr)[N])  // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType>
+inline void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
+{
+    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
+}
+
+template<typename BasicJsonType, typename T, std::size_t N>
+auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
+                          priority_tag<2> /*unused*/)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType,
+         enable_if_t<
+             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
+             int> = 0>
+auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
+-> decltype(
+    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
+    j.template get<typename ConstructibleArrayType::value_type>(),
+    void())
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    ret.reserve(j.size());
+    std::transform(j.begin(), j.end(),
+                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType,
+         enable_if_t<
+             std::is_assignable<ConstructibleArrayType&, ConstructibleArrayType>::value,
+             int> = 0>
+inline void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
+                                 priority_tag<0> /*unused*/)
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    std::transform(
+        j.begin(), j.end(), std::inserter(ret, end(ret)),
+        [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template < typename BasicJsonType, typename ConstructibleArrayType,
+           enable_if_t <
+               is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
+               !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
+               !is_basic_json<ConstructibleArrayType>::value,
+               int > = 0 >
+auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
+-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
+j.template get<typename ConstructibleArrayType::value_type>(),
+void())
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    from_json_array_impl(j, arr, priority_tag<3> {});
+}
+
+template < typename BasicJsonType, typename T, std::size_t... Idx >
+std::array<T, sizeof...(Idx)> from_json_inplace_array_impl(BasicJsonType&& j,
+        identity_tag<std::array<T, sizeof...(Idx)>> /*unused*/, index_sequence<Idx...> /*unused*/)
+{
+    return { { std::forward<BasicJsonType>(j).at(Idx).template get<T>()... } };
+}
+
+template < typename BasicJsonType, typename T, std::size_t N >
+auto from_json(BasicJsonType&& j, identity_tag<std::array<T, N>> tag)
+-> decltype(from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {}))
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    return from_json_inplace_array_impl(std::forward<BasicJsonType>(j), tag, make_index_sequence<N> {});
+}
+
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be binary, but is ", j.type_name()), &j));
+    }
+
+    bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
+}
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
+inline void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be object, but is ", j.type_name()), &j));
+    }
+
+    ConstructibleObjectType ret;
+    const auto* inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
+    using value_type = typename ConstructibleObjectType::value_type;
+    std::transform(
+        inner_object->begin(), inner_object->end(),
+        std::inserter(ret, ret.begin()),
+        [](typename BasicJsonType::object_t::value_type const & p)
+    {
+        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
+    });
+    obj = std::move(ret);
+}
+
+// overload for arithmetic types, not chosen for basic_json template arguments
+// (BooleanType, etc..); note: Is it really necessary to provide explicit
+// overloads for boolean_t etc. in case of a custom BooleanType which is not
+// an arithmetic type?
+template < typename BasicJsonType, typename ArithmeticType,
+           enable_if_t <
+               std::is_arithmetic<ArithmeticType>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
+               !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+               int > = 0 >
+inline void from_json(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+        case value_t::boolean:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
+            break;
+        }
+
+        case value_t::null:
+        case value_t::object:
+        case value_t::array:
+        case value_t::string:
+        case value_t::binary:
+        case value_t::discarded:
+        default:
+            JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
+    }
+}
+
+template<typename BasicJsonType, typename... Args, std::size_t... Idx>
+std::tuple<Args...> from_json_tuple_impl_base(BasicJsonType&& j, index_sequence<Idx...> /*unused*/)
+{
+    return std::make_tuple(std::forward<BasicJsonType>(j).at(Idx).template get<Args>()...);
+}
+
+template < typename BasicJsonType, class A1, class A2 >
+std::pair<A1, A2> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::pair<A1, A2>> /*unused*/, priority_tag<0> /*unused*/)
+{
+    return {std::forward<BasicJsonType>(j).at(0).template get<A1>(),
+            std::forward<BasicJsonType>(j).at(1).template get<A2>()};
+}
+
+template<typename BasicJsonType, typename A1, typename A2>
+inline void from_json_tuple_impl(BasicJsonType&& j, std::pair<A1, A2>& p, priority_tag<1> /*unused*/)
+{
+    p = from_json_tuple_impl(std::forward<BasicJsonType>(j), identity_tag<std::pair<A1, A2>> {}, priority_tag<0> {});
+}
+
+template<typename BasicJsonType, typename... Args>
+std::tuple<Args...> from_json_tuple_impl(BasicJsonType&& j, identity_tag<std::tuple<Args...>> /*unused*/, priority_tag<2> /*unused*/)
+{
+    return from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+}
+
+template<typename BasicJsonType, typename... Args>
+inline void from_json_tuple_impl(BasicJsonType&& j, std::tuple<Args...>& t, priority_tag<3> /*unused*/)
+{
+    t = from_json_tuple_impl_base<BasicJsonType, Args...>(std::forward<BasicJsonType>(j), index_sequence_for<Args...> {});
+}
+
+template<typename BasicJsonType, typename TupleRelated>
+auto from_json(BasicJsonType&& j, TupleRelated&& t)
+-> decltype(from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {}))
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+
+    return from_json_tuple_impl(std::forward<BasicJsonType>(j), std::forward<TupleRelated>(t), priority_tag<3> {});
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+inline void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+           typename = enable_if_t < !std::is_constructible <
+                                        typename BasicJsonType::string_t, Key >::value >>
+inline void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be array, but is ", j.type_name()), &j));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, concat("type must be array, but is ", p.type_name()), &j));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+template<typename BasicJsonType>
+inline void from_json(const BasicJsonType& j, std_fs::path& p)
+{
+    if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
+    }
+    p = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+#endif
+
+struct from_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(const BasicJsonType& j, T&& val) const
+    noexcept(noexcept(from_json(j, std::forward<T>(val))))
+    -> decltype(from_json(j, std::forward<T>(val)))
+    {
+        return from_json(j, std::forward<T>(val));
+    }
+};
+
+}  // namespace detail
+
+#ifndef JSON_HAS_CPP_17
+/// namespace to hold default `from_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+{
+#endif
+JSON_INLINE_VARIABLE constexpr const auto& from_json = // NOLINT(misc-definitions-in-headers)
+    detail::static_const<detail::from_json_fn>::value;
+#ifndef JSON_HAS_CPP_17
+}  // namespace
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // copy
+#include <iterator> // begin, end
+#include <string> // string
+#include <tuple> // tuple, get
+#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
+#include <utility> // move, forward, declval, pair
+#include <valarray> // valarray
+#include <vector> // vector
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // size_t
+#include <iterator> // input_iterator_tag
+#include <string> // string, to_string
+#include <tuple> // tuple_size, get, tuple_element
+#include <utility> // move
+
+#if JSON_HAS_RANGES
+    #include <ranges> // enable_borrowed_range
+#endif
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename string_type>
+void int_to_string( string_type& target, std::size_t value )
+{
+    // For ADL
+    using std::to_string;
+    target = to_string(value);
+}
+template<typename IteratorType> class iteration_proxy_value
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    using value_type = iteration_proxy_value;
+    using pointer = value_type *;
+    using reference = value_type &;
+    using iterator_category = std::input_iterator_tag;
+    using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
+
+  private:
+    /// the iterator
+    IteratorType anchor{};
+    /// an index for arrays (used to create key names)
+    std::size_t array_index = 0;
+    /// last stringified array index
+    mutable std::size_t array_index_last = 0;
+    /// a string representation of the array index
+    mutable string_type array_index_str = "0";
+    /// an empty string (to return a reference for primitive values)
+    string_type empty_str{};
+
+  public:
+    explicit iteration_proxy_value() = default;
+    explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
+    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
+             && std::is_nothrow_default_constructible<string_type>::value)
+        : anchor(std::move(it))
+        , array_index(array_index_)
+    {}
+
+    iteration_proxy_value(iteration_proxy_value const&) = default;
+    iteration_proxy_value& operator=(iteration_proxy_value const&) = default;
+    // older GCCs are a bit fussy and require explicit noexcept specifiers on defaulted functions
+    iteration_proxy_value(iteration_proxy_value&&)
+    noexcept(std::is_nothrow_move_constructible<IteratorType>::value
+             && std::is_nothrow_move_constructible<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
+    iteration_proxy_value& operator=(iteration_proxy_value&&)
+    noexcept(std::is_nothrow_move_assignable<IteratorType>::value
+             && std::is_nothrow_move_assignable<string_type>::value) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor,cppcoreguidelines-noexcept-move-operations)
+    ~iteration_proxy_value() = default;
+
+    /// dereference operator (needed for range-based for)
+    const iteration_proxy_value& operator*() const
+    {
+        return *this;
+    }
+
+    /// increment operator (needed for range-based for)
+    iteration_proxy_value& operator++()
+    {
+        ++anchor;
+        ++array_index;
+
+        return *this;
+    }
+
+    iteration_proxy_value operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto tmp = iteration_proxy_value(anchor, array_index);
+        ++anchor;
+        ++array_index;
+        return tmp;
+    }
+
+    /// equality operator (needed for InputIterator)
+    bool operator==(const iteration_proxy_value& o) const
+    {
+        return anchor == o.anchor;
+    }
+
+    /// inequality operator (needed for range-based for)
+    bool operator!=(const iteration_proxy_value& o) const
+    {
+        return anchor != o.anchor;
+    }
+
+    /// return key of the iterator
+    const string_type& key() const
+    {
+        JSON_ASSERT(anchor.m_object != nullptr);
+
+        switch (anchor.m_object->type())
+        {
+            // use integer array index as key
+            case value_t::array:
+            {
+                if (array_index != array_index_last)
+                {
+                    int_to_string( array_index_str, array_index );
+                    array_index_last = array_index;
+                }
+                return array_index_str;
+            }
+
+            // use key from the object
+            case value_t::object:
+                return anchor.key();
+
+            // use an empty key for all primitive types
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return empty_str;
+        }
+    }
+
+    /// return value of the iterator
+    typename IteratorType::reference value() const
+    {
+        return anchor.value();
+    }
+};
+
+/// proxy class for the items() function
+template<typename IteratorType> class iteration_proxy
+{
+  private:
+    /// the container to iterate
+    typename IteratorType::pointer container = nullptr;
+
+  public:
+    explicit iteration_proxy() = default;
+
+    /// construct iteration proxy from a container
+    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
+        : container(&cont) {}
+
+    iteration_proxy(iteration_proxy const&) = default;
+    iteration_proxy& operator=(iteration_proxy const&) = default;
+    iteration_proxy(iteration_proxy&&) noexcept = default;
+    iteration_proxy& operator=(iteration_proxy&&) noexcept = default;
+    ~iteration_proxy() = default;
+
+    /// return iterator begin (needed for range-based for)
+    iteration_proxy_value<IteratorType> begin() const noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container->begin());
+    }
+
+    /// return iterator end (needed for range-based for)
+    iteration_proxy_value<IteratorType> end() const noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container->end());
+    }
+};
+
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
+{
+    return i.key();
+}
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
+{
+    return i.value();
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// The Addition to the STD Namespace is required to add
+// Structured Bindings Support to the iteration_proxy_value class
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+namespace std
+{
+
+#if defined(__clang__)
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+template<typename IteratorType>
+class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>> // NOLINT(cert-dcl58-cpp)
+            : public std::integral_constant<std::size_t, 2> {};
+
+template<std::size_t N, typename IteratorType>
+class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >> // NOLINT(cert-dcl58-cpp)
+{
+  public:
+    using type = decltype(
+                     get<N>(std::declval <
+                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
+};
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+}  // namespace std
+
+#if JSON_HAS_RANGES
+    template <typename IteratorType>
+    inline constexpr bool ::std::ranges::enable_borrowed_range<::nlohmann::detail::iteration_proxy<IteratorType>> = true;
+#endif
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/std_fs.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+//////////////////
+// constructors //
+//////////////////
+
+/*
+ * Note all external_constructor<>::construct functions need to call
+ * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an
+ * allocated value (e.g., a string). See bug issue
+ * https://github.com/nlohmann/json/issues/2865 for more information.
+ */
+
+template<value_t> struct external_constructor;
+
+template<>
+struct external_constructor<value_t::boolean>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::boolean;
+        j.m_data.m_value = b;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::string>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value = s;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value = std::move(s);
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleStringType,
+               enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleStringType& str)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::binary>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::binary;
+        j.m_data.m_value = typename BasicJsonType::binary_t(b);
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::binary;
+        j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_float>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_float;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_unsigned>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_unsigned;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_integer>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_integer;
+        j.m_data.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::array>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = arr;
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = std::move(arr);
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleArrayType,
+               enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
+                             int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->reserve(arr.size());
+        for (const bool x : arr)
+        {
+            j.m_data.m_value.array->push_back(x);
+            j.set_parent(j.m_data.m_value.array->back());
+        }
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename T,
+             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->resize(arr.size());
+        if (arr.size() > 0)
+        {
+            std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin());
+        }
+        j.set_parents();
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::object>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value = obj;
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+    {
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value = std::move(obj);
+        j.set_parents();
+        j.assert_invariant();
+    }
+
+    template < typename BasicJsonType, typename CompatibleObjectType,
+               enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
+    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
+        j.set_parents();
+        j.assert_invariant();
+    }
+};
+
+/////////////
+// to_json //
+/////////////
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
+inline void to_json(BasicJsonType& j, T b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, b);
+}
+
+template < typename BasicJsonType, typename BoolRef,
+           enable_if_t <
+               ((std::is_same<std::vector<bool>::reference, BoolRef>::value
+                 && !std::is_same <std::vector<bool>::reference, typename BasicJsonType::boolean_t&>::value)
+                || (std::is_same<std::vector<bool>::const_reference, BoolRef>::value
+                    && !std::is_same <detail::uncvref_t<std::vector<bool>::const_reference>,
+                                      typename BasicJsonType::boolean_t >::value))
+               && std::is_convertible<const BoolRef&, typename BasicJsonType::boolean_t>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const BoolRef& b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, static_cast<typename BasicJsonType::boolean_t>(b));
+}
+
+template<typename BasicJsonType, typename CompatibleString,
+         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const CompatibleString& s)
+{
+    external_constructor<value_t::string>::construct(j, s);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+{
+    external_constructor<value_t::string>::construct(j, std::move(s));
+}
+
+template<typename BasicJsonType, typename FloatType,
+         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, FloatType val) noexcept
+{
+    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
+{
+    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberIntegerType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
+{
+    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
+}
+
+#if !JSON_DISABLE_ENUM_SERIALIZATION
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, EnumType e) noexcept
+{
+    using underlying_type = typename std::underlying_type<EnumType>::type;
+    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
+}
+#endif  // JSON_DISABLE_ENUM_SERIALIZATION
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const std::vector<bool>& e)
+{
+    external_constructor<value_t::array>::construct(j, e);
+}
+
+template < typename BasicJsonType, typename CompatibleArrayType,
+           enable_if_t < is_compatible_array_type<BasicJsonType,
+                         CompatibleArrayType>::value&&
+                         !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
+                         !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
+                         !is_basic_json<CompatibleArrayType>::value,
+                         int > = 0 >
+inline void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
+{
+    external_constructor<value_t::binary>::construct(j, bin);
+}
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const std::valarray<T>& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template < typename BasicJsonType, typename CompatibleObjectType,
+           enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
+{
+    external_constructor<value_t::object>::construct(j, obj);
+}
+
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+{
+    external_constructor<value_t::object>::construct(j, std::move(obj));
+}
+
+template <
+    typename BasicJsonType, typename T, std::size_t N,
+    enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
+                  const T(&)[N]>::value, // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+                  int > = 0 >
+inline void to_json(BasicJsonType& j, const T(&arr)[N]) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
+inline void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
+{
+    j = { p.first, p.second };
+}
+
+// for https://github.com/nlohmann/json/pull/1134
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
+inline void to_json(BasicJsonType& j, const T& b)
+{
+    j = { {b.key(), b.value()} };
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    j = { std::get<Idx>(t)... };
+}
+
+template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
+inline void to_json(BasicJsonType& j, const T& t)
+{
+    to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
+}
+
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+template<typename BasicJsonType>
+inline void to_json(BasicJsonType& j, const std_fs::path& p)
+{
+    j = p.string();
+}
+#endif
+
+struct to_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
+    -> decltype(to_json(j, std::forward<T>(val)), void())
+    {
+        return to_json(j, std::forward<T>(val));
+    }
+};
+}  // namespace detail
+
+#ifndef JSON_HAS_CPP_17
+/// namespace to hold default `to_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace // NOLINT(cert-dcl59-cpp,fuchsia-header-anon-namespaces,google-build-namespaces)
+{
+#endif
+JSON_INLINE_VARIABLE constexpr const auto& to_json = // NOLINT(misc-definitions-in-headers)
+    detail::static_const<detail::to_json_fn>::value;
+#ifndef JSON_HAS_CPP_17
+}  // namespace
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/identity_tag.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @sa https://json.nlohmann.me/api/adl_serializer/
+template<typename ValueType, typename>
+struct adl_serializer
+{
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
+        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
+    {
+        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
+    }
+
+    /// @brief convert a JSON value to any value type
+    /// @sa https://json.nlohmann.me/api/adl_serializer/from_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto from_json(BasicJsonType && j) noexcept(
+    noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {})))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {}))
+    {
+        return ::nlohmann::from_json(std::forward<BasicJsonType>(j), detail::identity_tag<TargetType> {});
+    }
+
+    /// @brief convert any value type to a JSON value
+    /// @sa https://json.nlohmann.me/api/adl_serializer/to_json/
+    template<typename BasicJsonType, typename TargetType = ValueType>
+    static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
+        noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
+    -> decltype(::nlohmann::to_json(j, std::forward<TargetType>(val)), void())
+    {
+        ::nlohmann::to_json(j, std::forward<TargetType>(val));
+    }
+};
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/byte_container_with_subtype.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstdint> // uint8_t, uint64_t
+#include <tuple> // tie
+#include <utility> // move
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @brief an internal type for a backed binary type
+/// @sa https://json.nlohmann.me/api/byte_container_with_subtype/
+template<typename BinaryType>
+class byte_container_with_subtype : public BinaryType
+{
+  public:
+    using container_type = BinaryType;
+    using subtype_type = std::uint64_t;
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype() noexcept(noexcept(container_type()))
+        : container_type()
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(const container_type& b, subtype_type subtype_) noexcept(noexcept(container_type(b)))
+        : container_type(b)
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/byte_container_with_subtype/
+    byte_container_with_subtype(container_type&& b, subtype_type subtype_) noexcept(noexcept(container_type(std::move(b))))
+        : container_type(std::move(b))
+        , m_subtype(subtype_)
+        , m_has_subtype(true)
+    {}
+
+    bool operator==(const byte_container_with_subtype& rhs) const
+    {
+        return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
+               std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
+    }
+
+    bool operator!=(const byte_container_with_subtype& rhs) const
+    {
+        return !(rhs == *this);
+    }
+
+    /// @brief sets the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/set_subtype/
+    void set_subtype(subtype_type subtype_) noexcept
+    {
+        m_subtype = subtype_;
+        m_has_subtype = true;
+    }
+
+    /// @brief return the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/subtype/
+    constexpr subtype_type subtype() const noexcept
+    {
+        return m_has_subtype ? m_subtype : static_cast<subtype_type>(-1);
+    }
+
+    /// @brief return whether the value has a subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/has_subtype/
+    constexpr bool has_subtype() const noexcept
+    {
+        return m_has_subtype;
+    }
+
+    /// @brief clears the binary subtype
+    /// @sa https://json.nlohmann.me/api/byte_container_with_subtype/clear_subtype/
+    void clear_subtype() noexcept
+    {
+        m_subtype = 0;
+        m_has_subtype = false;
+    }
+
+  private:
+    subtype_type m_subtype = 0;
+    bool m_has_subtype = false;
+};
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/hash.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstdint> // uint8_t
+#include <cstddef> // size_t
+#include <functional> // hash
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// boost::hash_combine
+inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
+{
+    seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
+    return seed;
+}
+
+/*!
+@brief hash a JSON value
+
+The hash function tries to rely on std::hash where possible. Furthermore, the
+type of the JSON value is taken into account to have different hash values for
+null, 0, 0U, and false, etc.
+
+@tparam BasicJsonType basic_json specialization
+@param j JSON value to hash
+@return hash value of j
+*/
+template<typename BasicJsonType>
+std::size_t hash(const BasicJsonType& j)
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+    const auto type = static_cast<std::size_t>(j.type());
+    switch (j.type())
+    {
+        case BasicJsonType::value_t::null:
+        case BasicJsonType::value_t::discarded:
+        {
+            return combine(type, 0);
+        }
+
+        case BasicJsonType::value_t::object:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j.items())
+            {
+                const auto h = std::hash<string_t> {}(element.key());
+                seed = combine(seed, h);
+                seed = combine(seed, hash(element.value()));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::array:
+        {
+            auto seed = combine(type, j.size());
+            for (const auto& element : j)
+            {
+                seed = combine(seed, hash(element));
+            }
+            return seed;
+        }
+
+        case BasicJsonType::value_t::string:
+        {
+            const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::boolean:
+        {
+            const auto h = std::hash<bool> {}(j.template get<bool>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_integer:
+        {
+            const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_unsigned:
+        {
+            const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::number_float:
+        {
+            const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
+            return combine(type, h);
+        }
+
+        case BasicJsonType::value_t::binary:
+        {
+            auto seed = combine(type, j.get_binary().size());
+            const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
+            seed = combine(seed, h);
+            seed = combine(seed, static_cast<std::size_t>(j.get_binary().subtype()));
+            for (const auto byte : j.get_binary())
+            {
+                seed = combine(seed, std::hash<std::uint8_t> {}(byte));
+            }
+            return seed;
+        }
+
+        default:                   // LCOV_EXCL_LINE
+            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            return 0;              // LCOV_EXCL_LINE
+    }
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // generate_n
+#include <array> // array
+#include <cmath> // ldexp
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstdio> // snprintf
+#include <cstring> // memcpy
+#include <iterator> // back_inserter
+#include <limits> // numeric_limits
+#include <string> // char_traits, string
+#include <utility> // make_pair, move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cstddef> // size_t
+#include <cstring> // strlen
+#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
+#include <memory> // shared_ptr, make_shared, addressof
+#include <numeric> // accumulate
+#include <string> // string, char_traits
+#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
+#include <utility> // pair, declval
+
+#ifndef JSON_NO_IO
+    #include <cstdio>   // FILE *
+    #include <istream>  // istream
+#endif                  // JSON_NO_IO
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// the supported input formats
+enum class input_format_t { json, cbor, msgpack, ubjson, bson, bjdata };
+
+////////////////////
+// input adapters //
+////////////////////
+
+#ifndef JSON_NO_IO
+/*!
+Input adapter for stdio file access. This adapter read only 1 byte and do not use any
+ buffer. This adapter is a very low level adapter.
+*/
+class file_input_adapter
+{
+  public:
+    using char_type = char;
+
+    JSON_HEDLEY_NON_NULL(2)
+    explicit file_input_adapter(std::FILE* f) noexcept
+        : m_file(f)
+    {
+        JSON_ASSERT(m_file != nullptr);
+    }
+
+    // make class move-only
+    file_input_adapter(const file_input_adapter&) = delete;
+    file_input_adapter(file_input_adapter&&) noexcept = default;
+    file_input_adapter& operator=(const file_input_adapter&) = delete;
+    file_input_adapter& operator=(file_input_adapter&&) = delete;
+    ~file_input_adapter() = default;
+
+    std::char_traits<char>::int_type get_character() noexcept
+    {
+        return std::fgetc(m_file);
+    }
+
+  private:
+    /// the file pointer to read from
+    std::FILE* m_file;
+};
+
+/*!
+Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
+beginning of input. Does not support changing the underlying std::streambuf
+in mid-input. Maintains underlying std::istream and std::streambuf to support
+subsequent use of standard std::istream operations to process any input
+characters following those used in parsing the JSON input.  Clears the
+std::istream flags; any input errors (e.g., EOF) will be detected by the first
+subsequent call for input from the std::istream.
+*/
+class input_stream_adapter
+{
+  public:
+    using char_type = char;
+
+    ~input_stream_adapter()
+    {
+        // clear stream flags; we use underlying streambuf I/O, do not
+        // maintain ifstream flags, except eof
+        if (is != nullptr)
+        {
+            is->clear(is->rdstate() & std::ios::eofbit);
+        }
+    }
+
+    explicit input_stream_adapter(std::istream& i)
+        : is(&i), sb(i.rdbuf())
+    {}
+
+    // delete because of pointer members
+    input_stream_adapter(const input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&&) = delete;
+
+    input_stream_adapter(input_stream_adapter&& rhs) noexcept
+        : is(rhs.is), sb(rhs.sb)
+    {
+        rhs.is = nullptr;
+        rhs.sb = nullptr;
+    }
+
+    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
+    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
+    // end up as the same value, e.g. 0xFFFFFFFF.
+    std::char_traits<char>::int_type get_character()
+    {
+        auto res = sb->sbumpc();
+        // set eof manually, as we don't use the istream interface.
+        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
+        {
+            is->clear(is->rdstate() | std::ios::eofbit);
+        }
+        return res;
+    }
+
+  private:
+    /// the associated input stream
+    std::istream* is = nullptr;
+    std::streambuf* sb = nullptr;
+};
+#endif  // JSON_NO_IO
+
+// General-purpose iterator-based adapter. It might not be as fast as
+// theoretically possible for some containers, but it is extremely versatile.
+template<typename IteratorType>
+class iterator_input_adapter
+{
+  public:
+    using char_type = typename std::iterator_traits<IteratorType>::value_type;
+
+    iterator_input_adapter(IteratorType first, IteratorType last)
+        : current(std::move(first)), end(std::move(last))
+    {}
+
+    typename char_traits<char_type>::int_type get_character()
+    {
+        if (JSON_HEDLEY_LIKELY(current != end))
+        {
+            auto result = char_traits<char_type>::to_int_type(*current);
+            std::advance(current, 1);
+            return result;
+        }
+
+        return char_traits<char_type>::eof();
+    }
+
+  private:
+    IteratorType current;
+    IteratorType end;
+
+    template<typename BaseInputAdapter, size_t T>
+    friend struct wide_string_input_helper;
+
+    bool empty() const
+    {
+        return current == end;
+    }
+};
+
+template<typename BaseInputAdapter, size_t T>
+struct wide_string_input_helper;
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 4>
+{
+    // UTF-32
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-32 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (wc <= 0xFFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else if (wc <= 0x10FFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 4;
+            }
+            else
+            {
+                // unknown character
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+        }
+    }
+};
+
+template<typename BaseInputAdapter>
+struct wide_string_input_helper<BaseInputAdapter, 2>
+{
+    // UTF-16
+    static void fill_buffer(BaseInputAdapter& input,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (JSON_HEDLEY_UNLIKELY(input.empty()))
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = input.get_character();
+
+            // UTF-16 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (0xD800 > wc || wc >= 0xE000)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else
+            {
+                if (JSON_HEDLEY_UNLIKELY(!input.empty()))
+                {
+                    const auto wc2 = static_cast<unsigned int>(input.get_character());
+                    const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
+                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
+                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
+                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
+                    utf8_bytes_filled = 4;
+                }
+                else
+                {
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                    utf8_bytes_filled = 1;
+                }
+            }
+        }
+    }
+};
+
+// Wraps another input adapter to convert wide character types into individual bytes.
+template<typename BaseInputAdapter, typename WideCharType>
+class wide_string_input_adapter
+{
+  public:
+    using char_type = char;
+
+    wide_string_input_adapter(BaseInputAdapter base)
+        : base_adapter(base) {}
+
+    typename std::char_traits<char>::int_type get_character() noexcept
+    {
+        // check if buffer needs to be filled
+        if (utf8_bytes_index == utf8_bytes_filled)
+        {
+            fill_buffer<sizeof(WideCharType)>();
+
+            JSON_ASSERT(utf8_bytes_filled > 0);
+            JSON_ASSERT(utf8_bytes_index == 0);
+        }
+
+        // use buffer
+        JSON_ASSERT(utf8_bytes_filled > 0);
+        JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
+        return utf8_bytes[utf8_bytes_index++];
+    }
+
+  private:
+    BaseInputAdapter base_adapter;
+
+    template<size_t T>
+    void fill_buffer()
+    {
+        wide_string_input_helper<BaseInputAdapter, T>::fill_buffer(base_adapter, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
+    }
+
+    /// a buffer for UTF-8 bytes
+    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
+
+    /// index to the utf8_codes array for the next valid byte
+    std::size_t utf8_bytes_index = 0;
+    /// number of valid bytes in the utf8_codes array
+    std::size_t utf8_bytes_filled = 0;
+};
+
+template<typename IteratorType, typename Enable = void>
+struct iterator_input_adapter_factory
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using adapter_type = iterator_input_adapter<iterator_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(std::move(first), std::move(last));
+    }
+};
+
+template<typename T>
+struct is_iterator_of_multibyte
+{
+    using value_type = typename std::iterator_traits<T>::value_type;
+    enum
+    {
+        value = sizeof(value_type) > 1
+    };
+};
+
+template<typename IteratorType>
+struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
+{
+    using iterator_type = IteratorType;
+    using char_type = typename std::iterator_traits<iterator_type>::value_type;
+    using base_adapter_type = iterator_input_adapter<iterator_type>;
+    using adapter_type = wide_string_input_adapter<base_adapter_type, char_type>;
+
+    static adapter_type create(IteratorType first, IteratorType last)
+    {
+        return adapter_type(base_adapter_type(std::move(first), std::move(last)));
+    }
+};
+
+// General purpose iterator-based input
+template<typename IteratorType>
+typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
+{
+    using factory_type = iterator_input_adapter_factory<IteratorType>;
+    return factory_type::create(first, last);
+}
+
+// Convenience shorthand from container to iterator
+// Enables ADL on begin(container) and end(container)
+// Encloses the using declarations in namespace for not to leak them to outside scope
+
+namespace container_input_adapter_factory_impl
+{
+
+using std::begin;
+using std::end;
+
+template<typename ContainerType, typename Enable = void>
+struct container_input_adapter_factory {};
+
+template<typename ContainerType>
+struct container_input_adapter_factory< ContainerType,
+       void_t<decltype(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>()))>>
+       {
+           using adapter_type = decltype(input_adapter(begin(std::declval<ContainerType>()), end(std::declval<ContainerType>())));
+
+           static adapter_type create(const ContainerType& container)
+{
+    return input_adapter(begin(container), end(container));
+}
+       };
+
+}  // namespace container_input_adapter_factory_impl
+
+template<typename ContainerType>
+typename container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::adapter_type input_adapter(const ContainerType& container)
+{
+    return container_input_adapter_factory_impl::container_input_adapter_factory<ContainerType>::create(container);
+}
+
+#ifndef JSON_NO_IO
+// Special cases with fast paths
+inline file_input_adapter input_adapter(std::FILE* file)
+{
+    return file_input_adapter(file);
+}
+
+inline input_stream_adapter input_adapter(std::istream& stream)
+{
+    return input_stream_adapter(stream);
+}
+
+inline input_stream_adapter input_adapter(std::istream&& stream)
+{
+    return input_stream_adapter(stream);
+}
+#endif  // JSON_NO_IO
+
+using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
+
+// Null-delimited strings, and the like.
+template < typename CharT,
+           typename std::enable_if <
+               std::is_pointer<CharT>::value&&
+               !std::is_array<CharT>::value&&
+               std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+               sizeof(typename std::remove_pointer<CharT>::type) == 1,
+               int >::type = 0 >
+contiguous_bytes_input_adapter input_adapter(CharT b)
+{
+    auto length = std::strlen(reinterpret_cast<const char*>(b));
+    const auto* ptr = reinterpret_cast<const char*>(b);
+    return input_adapter(ptr, ptr + length);
+}
+
+template<typename T, std::size_t N>
+auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+{
+    return input_adapter(array, array + N);
+}
+
+// This class only handles inputs of input_buffer_adapter type.
+// It's required so that expressions like {ptr, len} can be implicitly cast
+// to the correct adapter.
+class span_input_adapter
+{
+  public:
+    template < typename CharT,
+               typename std::enable_if <
+                   std::is_pointer<CharT>::value&&
+                   std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
+                   sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                   int >::type = 0 >
+    span_input_adapter(CharT b, std::size_t l)
+        : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
+
+    template<class IteratorType,
+             typename std::enable_if<
+                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
+                 int>::type = 0>
+    span_input_adapter(IteratorType first, IteratorType last)
+        : ia(input_adapter(first, last)) {}
+
+    contiguous_bytes_input_adapter&& get()
+    {
+        return std::move(ia); // NOLINT(hicpp-move-const-arg,performance-move-const-arg)
+    }
+
+  private:
+    contiguous_bytes_input_adapter ia;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef>
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/*!
+@brief SAX interface
+
+This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
+Each function is called in different situations while the input is parsed. The
+boolean return value informs the parser whether to continue processing the
+input.
+*/
+template<typename BasicJsonType>
+struct json_sax
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @brief a null value was read
+    @return whether parsing should proceed
+    */
+    virtual bool null() = 0;
+
+    /*!
+    @brief a boolean value was read
+    @param[in] val  boolean value
+    @return whether parsing should proceed
+    */
+    virtual bool boolean(bool val) = 0;
+
+    /*!
+    @brief an integer number was read
+    @param[in] val  integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_integer(number_integer_t val) = 0;
+
+    /*!
+    @brief an unsigned integer number was read
+    @param[in] val  unsigned integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_unsigned(number_unsigned_t val) = 0;
+
+    /*!
+    @brief a floating-point number was read
+    @param[in] val  floating-point value
+    @param[in] s    raw token value
+    @return whether parsing should proceed
+    */
+    virtual bool number_float(number_float_t val, const string_t& s) = 0;
+
+    /*!
+    @brief a string value was read
+    @param[in] val  string value
+    @return whether parsing should proceed
+    @note It is safe to move the passed string value.
+    */
+    virtual bool string(string_t& val) = 0;
+
+    /*!
+    @brief a binary value was read
+    @param[in] val  binary value
+    @return whether parsing should proceed
+    @note It is safe to move the passed binary value.
+    */
+    virtual bool binary(binary_t& val) = 0;
+
+    /*!
+    @brief the beginning of an object was read
+    @param[in] elements  number of object elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_object(std::size_t elements) = 0;
+
+    /*!
+    @brief an object key was read
+    @param[in] val  object key
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool key(string_t& val) = 0;
+
+    /*!
+    @brief the end of an object was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_object() = 0;
+
+    /*!
+    @brief the beginning of an array was read
+    @param[in] elements  number of array elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_array(std::size_t elements) = 0;
+
+    /*!
+    @brief the end of an array was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_array() = 0;
+
+    /*!
+    @brief a parse error occurred
+    @param[in] position    the position in the input where the error occurs
+    @param[in] last_token  the last read token
+    @param[in] ex          an exception object describing the error
+    @return whether parsing should proceed (must return false)
+    */
+    virtual bool parse_error(std::size_t position,
+                             const std::string& last_token,
+                             const detail::exception& ex) = 0;
+
+    json_sax() = default;
+    json_sax(const json_sax&) = default;
+    json_sax(json_sax&&) noexcept = default;
+    json_sax& operator=(const json_sax&) = default;
+    json_sax& operator=(json_sax&&) noexcept = default;
+    virtual ~json_sax() = default;
+};
+
+namespace detail
+{
+/*!
+@brief SAX implementation to create a JSON value from SAX events
+
+This class implements the @ref json_sax interface and processes the SAX events
+to create a JSON value which makes it basically a DOM parser. The structure or
+hierarchy of the JSON value is managed by the stack `ref_stack` which contains
+a pointer to the respective array or object for each recursion depth.
+
+After successful parsing, the value that is passed by reference to the
+constructor contains the parsed value.
+
+@tparam BasicJsonType  the JSON type
+*/
+template<typename BasicJsonType>
+class json_sax_dom_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    /*!
+    @param[in,out] r  reference to a JSON value that is manipulated while
+                       parsing
+    @param[in] allow_exceptions_  whether parse errors yield exceptions
+    */
+    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
+        : root(r), allow_exceptions(allow_exceptions_)
+    {}
+
+    // make class move-only
+    json_sax_dom_parser(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~json_sax_dom_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
+
+        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_object());
+
+        // add null at given key and store the reference for later
+        object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val));
+        return true;
+    }
+
+    bool end_object()
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_object());
+
+        ref_stack.back()->set_parents();
+        ref_stack.pop_back();
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
+
+        if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(ref_stack.back()->is_array());
+
+        ref_stack.back()->set_parents();
+        ref_stack.pop_back();
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+    */
+    template<typename Value>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    BasicJsonType* handle_value(Value&& v)
+    {
+        if (ref_stack.empty())
+        {
+            root = BasicJsonType(std::forward<Value>(v));
+            return &root;
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->emplace_back(std::forward<Value>(v));
+            return &(ref_stack.back()->m_data.m_value.array->back());
+        }
+
+        JSON_ASSERT(ref_stack.back()->is_object());
+        JSON_ASSERT(object_element);
+        *object_element = BasicJsonType(std::forward<Value>(v));
+        return object_element;
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+
+template<typename BasicJsonType>
+class json_sax_dom_callback_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using parser_callback_t = typename BasicJsonType::parser_callback_t;
+    using parse_event_t = typename BasicJsonType::parse_event_t;
+
+    json_sax_dom_callback_parser(BasicJsonType& r,
+                                 const parser_callback_t cb,
+                                 const bool allow_exceptions_ = true)
+        : root(r), callback(cb), allow_exceptions(allow_exceptions_)
+    {
+        keep_stack.push_back(true);
+    }
+
+    // make class move-only
+    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~json_sax_dom_callback_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool binary(binary_t& val)
+    {
+        handle_value(std::move(val));
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        // check callback for object start
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::object, true);
+        ref_stack.push_back(val.second);
+
+        // check object limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        BasicJsonType k = BasicJsonType(val);
+
+        // check callback for key
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
+        key_keep_stack.push_back(keep);
+
+        // add discarded value at given key and store the reference for later
+        if (keep && ref_stack.back())
+        {
+            object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
+        }
+
+        return true;
+    }
+
+    bool end_object()
+    {
+        if (ref_stack.back())
+        {
+            if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
+            {
+                // discard object
+                *ref_stack.back() = discarded;
+            }
+            else
+            {
+                ref_stack.back()->set_parents();
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
+        {
+            // remove discarded value
+            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
+            {
+                if (it->is_discarded())
+                {
+                    ref_stack.back()->erase(it);
+                    break;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::array, true);
+        ref_stack.push_back(val.second);
+
+        // check array limit
+        if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        bool keep = true;
+
+        if (ref_stack.back())
+        {
+            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
+            if (keep)
+            {
+                ref_stack.back()->set_parents();
+            }
+            else
+            {
+                // discard array
+                *ref_stack.back() = discarded;
+            }
+        }
+
+        JSON_ASSERT(!ref_stack.empty());
+        JSON_ASSERT(!keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        // remove discarded value
+        if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->pop_back();
+        }
+
+        return true;
+    }
+
+    template<class Exception>
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const Exception& ex)
+    {
+        errored = true;
+        static_cast<void>(ex);
+        if (allow_exceptions)
+        {
+            JSON_THROW(ex);
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @param[in] v  value to add to the JSON value we build during parsing
+    @param[in] skip_callback  whether we should skip calling the callback
+               function; this is required after start_array() and
+               start_object() SAX events, because otherwise we would call the
+               callback function with an empty array or object, respectively.
+
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+
+    @return pair of boolean (whether value should be kept) and pointer (to the
+            passed value in the ref_stack hierarchy; nullptr if not kept)
+    */
+    template<typename Value>
+    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
+    {
+        JSON_ASSERT(!keep_stack.empty());
+
+        // do not handle this value if we know it would be added to a discarded
+        // container
+        if (!keep_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // create value
+        auto value = BasicJsonType(std::forward<Value>(v));
+
+        // check callback
+        const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
+
+        // do not handle this value if we just learnt it shall be discarded
+        if (!keep)
+        {
+            return {false, nullptr};
+        }
+
+        if (ref_stack.empty())
+        {
+            root = std::move(value);
+            return {true, & root};
+        }
+
+        // skip this value if we already decided to skip the parent
+        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
+        if (!ref_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // we now only expect arrays and objects
+        JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
+
+        // array
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
+            return {true, & (ref_stack.back()->m_data.m_value.array->back())};
+        }
+
+        // object
+        JSON_ASSERT(ref_stack.back()->is_object());
+        // check if we should store an element for the current key
+        JSON_ASSERT(!key_keep_stack.empty());
+        const bool store_element = key_keep_stack.back();
+        key_keep_stack.pop_back();
+
+        if (!store_element)
+        {
+            return {false, nullptr};
+        }
+
+        JSON_ASSERT(object_element);
+        *object_element = std::move(value);
+        return {true, object_element};
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// stack to manage which values to keep
+    std::vector<bool> keep_stack {};
+    /// stack to manage which object keys to keep
+    std::vector<bool> key_keep_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+    /// a discarded value for the callback
+    BasicJsonType discarded = BasicJsonType::value_t::discarded;
+};
+
+template<typename BasicJsonType>
+class json_sax_acceptor
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+
+    bool null()
+    {
+        return true;
+    }
+
+    bool boolean(bool /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_integer(number_integer_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool string(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool binary(binary_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool start_object(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
+    {
+        return true;
+    }
+
+    bool key(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool end_object()
+    {
+        return true;
+    }
+
+    bool start_array(std::size_t /*unused*/ = static_cast<std::size_t>(-1))
+    {
+        return true;
+    }
+
+    bool end_array()
+    {
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
+    {
+        return false;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/lexer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <clocale> // localeconv
+#include <cstddef> // size_t
+#include <cstdio> // snprintf
+#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
+#include <initializer_list> // initializer_list
+#include <string> // char_traits, string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////
+// lexer //
+///////////
+
+template<typename BasicJsonType>
+class lexer_base
+{
+  public:
+    /// token types for the parser
+    enum class token_type
+    {
+        uninitialized,    ///< indicating the scanner is uninitialized
+        literal_true,     ///< the `true` literal
+        literal_false,    ///< the `false` literal
+        literal_null,     ///< the `null` literal
+        value_string,     ///< a string -- use get_string() for actual value
+        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
+        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
+        value_float,      ///< an floating point number -- use get_number_float() for actual value
+        begin_array,      ///< the character for array begin `[`
+        begin_object,     ///< the character for object begin `{`
+        end_array,        ///< the character for array end `]`
+        end_object,       ///< the character for object end `}`
+        name_separator,   ///< the name separator `:`
+        value_separator,  ///< the value separator `,`
+        parse_error,      ///< indicating a parse error
+        end_of_input,     ///< indicating the end of the input buffer
+        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
+    };
+
+    /// return name of values of type token_type (only used for errors)
+    JSON_HEDLEY_RETURNS_NON_NULL
+    JSON_HEDLEY_CONST
+    static const char* token_type_name(const token_type t) noexcept
+    {
+        switch (t)
+        {
+            case token_type::uninitialized:
+                return "<uninitialized>";
+            case token_type::literal_true:
+                return "true literal";
+            case token_type::literal_false:
+                return "false literal";
+            case token_type::literal_null:
+                return "null literal";
+            case token_type::value_string:
+                return "string literal";
+            case token_type::value_unsigned:
+            case token_type::value_integer:
+            case token_type::value_float:
+                return "number literal";
+            case token_type::begin_array:
+                return "'['";
+            case token_type::begin_object:
+                return "'{'";
+            case token_type::end_array:
+                return "']'";
+            case token_type::end_object:
+                return "'}'";
+            case token_type::name_separator:
+                return "':'";
+            case token_type::value_separator:
+                return "','";
+            case token_type::parse_error:
+                return "<parse error>";
+            case token_type::end_of_input:
+                return "end of input";
+            case token_type::literal_or_value:
+                return "'[', '{', or a literal";
+            // LCOV_EXCL_START
+            default: // catch non-enum values
+                return "unknown token";
+                // LCOV_EXCL_STOP
+        }
+    }
+};
+/*!
+@brief lexical analysis
+
+This class organizes the lexical analysis during JSON deserialization.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class lexer : public lexer_base<BasicJsonType>
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename char_traits<char_type>::int_type;
+
+  public:
+    using token_type = typename lexer_base<BasicJsonType>::token_type;
+
+    explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
+        : ia(std::move(adapter))
+        , ignore_comments(ignore_comments_)
+        , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
+    {}
+
+    // delete because of pointer members
+    lexer(const lexer&) = delete;
+    lexer(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    lexer& operator=(lexer&) = delete;
+    lexer& operator=(lexer&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~lexer() = default;
+
+  private:
+    /////////////////////
+    // locales
+    /////////////////////
+
+    /// return the locale-dependent decimal point
+    JSON_HEDLEY_PURE
+    static char get_decimal_point() noexcept
+    {
+        const auto* loc = localeconv();
+        JSON_ASSERT(loc != nullptr);
+        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
+    }
+
+    /////////////////////
+    // scan functions
+    /////////////////////
+
+    /*!
+    @brief get codepoint from 4 hex characters following `\u`
+
+    For input "\u c1 c2 c3 c4" the codepoint is:
+      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
+    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
+
+    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
+    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
+    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
+    between the ASCII value of the character and the desired integer value.
+
+    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
+            non-hex character)
+    */
+    int get_codepoint()
+    {
+        // this function only makes sense after reading `\u`
+        JSON_ASSERT(current == 'u');
+        int codepoint = 0;
+
+        const auto factors = { 12u, 8u, 4u, 0u };
+        for (const auto factor : factors)
+        {
+            get();
+
+            if (current >= '0' && current <= '9')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
+            }
+            else if (current >= 'A' && current <= 'F')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
+            }
+            else if (current >= 'a' && current <= 'f')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
+        return codepoint;
+    }
+
+    /*!
+    @brief check if the next byte(s) are inside a given range
+
+    Adds the current byte and, for each passed range, reads a new byte and
+    checks if it is inside the range. If a violation was detected, set up an
+    error message and return false. Otherwise, return true.
+
+    @param[in] ranges  list of integers; interpreted as list of pairs of
+                       inclusive lower and upper bound, respectively
+
+    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
+         1, 2, or 3 pairs. This precondition is enforced by an assertion.
+
+    @return true if and only if no range violation was detected
+    */
+    bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
+    {
+        JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
+        add(current);
+
+        for (auto range = ranges.begin(); range != ranges.end(); ++range)
+        {
+            get();
+            if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range))) // NOLINT(bugprone-inc-dec-in-conditions)
+            {
+                add(current);
+            }
+            else
+            {
+                error_message = "invalid string: ill-formed UTF-8 byte";
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief scan a string literal
+
+    This function scans a string according to Sect. 7 of RFC 8259. While
+    scanning, bytes are escaped and copied into buffer token_buffer. Then the
+    function returns successfully, token_buffer is *not* null-terminated (as it
+    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
+    string.
+
+    @return token_type::value_string if string could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note In case of errors, variable error_message contains a textual
+          description.
+    */
+    token_type scan_string()
+    {
+        // reset token_buffer (ignore opening quote)
+        reset();
+
+        // we entered the function by reading an open quote
+        JSON_ASSERT(current == '\"');
+
+        while (true)
+        {
+            // get next character
+            switch (get())
+            {
+                // end of file while parsing string
+                case char_traits<char_type>::eof():
+                {
+                    error_message = "invalid string: missing closing quote";
+                    return token_type::parse_error;
+                }
+
+                // closing quote
+                case '\"':
+                {
+                    return token_type::value_string;
+                }
+
+                // escapes
+                case '\\':
+                {
+                    switch (get())
+                    {
+                        // quotation mark
+                        case '\"':
+                            add('\"');
+                            break;
+                        // reverse solidus
+                        case '\\':
+                            add('\\');
+                            break;
+                        // solidus
+                        case '/':
+                            add('/');
+                            break;
+                        // backspace
+                        case 'b':
+                            add('\b');
+                            break;
+                        // form feed
+                        case 'f':
+                            add('\f');
+                            break;
+                        // line feed
+                        case 'n':
+                            add('\n');
+                            break;
+                        // carriage return
+                        case 'r':
+                            add('\r');
+                            break;
+                        // tab
+                        case 't':
+                            add('\t');
+                            break;
+
+                        // unicode escapes
+                        case 'u':
+                        {
+                            const int codepoint1 = get_codepoint();
+                            int codepoint = codepoint1; // start with codepoint1
+
+                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
+                            {
+                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                return token_type::parse_error;
+                            }
+
+                            // check if code point is a high surrogate
+                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
+                            {
+                                // expect next \uxxxx entry
+                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
+                                {
+                                    const int codepoint2 = get_codepoint();
+
+                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
+                                    {
+                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                        return token_type::parse_error;
+                                    }
+
+                                    // check if codepoint2 is a low surrogate
+                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
+                                    {
+                                        // overwrite codepoint
+                                        codepoint = static_cast<int>(
+                                                        // high surrogate occupies the most significant 22 bits
+                                                        (static_cast<unsigned int>(codepoint1) << 10u)
+                                                        // low surrogate occupies the least significant 15 bits
+                                                        + static_cast<unsigned int>(codepoint2)
+                                                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
+                                                        // in the result, so we have to subtract with:
+                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                                                        - 0x35FDC00u);
+                                    }
+                                    else
+                                    {
+                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                        return token_type::parse_error;
+                                    }
+                                }
+                                else
+                                {
+                                    error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+                            else
+                            {
+                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
+                                {
+                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+
+                            // result of the above calculation yields a proper codepoint
+                            JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
+
+                            // translate codepoint into bytes
+                            if (codepoint < 0x80)
+                            {
+                                // 1-byte characters: 0xxxxxxx (ASCII)
+                                add(static_cast<char_int_type>(codepoint));
+                            }
+                            else if (codepoint <= 0x7FF)
+                            {
+                                // 2-byte characters: 110xxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else if (codepoint <= 0xFFFF)
+                            {
+                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else
+                            {
+                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+
+                            break;
+                        }
+
+                        // other characters after escape
+                        default:
+                            error_message = "invalid string: forbidden character after backslash";
+                            return token_type::parse_error;
+                    }
+
+                    break;
+                }
+
+                // invalid control characters
+                case 0x00:
+                {
+                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
+                    return token_type::parse_error;
+                }
+
+                case 0x01:
+                {
+                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
+                    return token_type::parse_error;
+                }
+
+                case 0x02:
+                {
+                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
+                    return token_type::parse_error;
+                }
+
+                case 0x03:
+                {
+                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
+                    return token_type::parse_error;
+                }
+
+                case 0x04:
+                {
+                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
+                    return token_type::parse_error;
+                }
+
+                case 0x05:
+                {
+                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
+                    return token_type::parse_error;
+                }
+
+                case 0x06:
+                {
+                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
+                    return token_type::parse_error;
+                }
+
+                case 0x07:
+                {
+                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
+                    return token_type::parse_error;
+                }
+
+                case 0x08:
+                {
+                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
+                    return token_type::parse_error;
+                }
+
+                case 0x09:
+                {
+                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
+                    return token_type::parse_error;
+                }
+
+                case 0x0A:
+                {
+                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
+                    return token_type::parse_error;
+                }
+
+                case 0x0B:
+                {
+                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
+                    return token_type::parse_error;
+                }
+
+                case 0x0C:
+                {
+                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
+                    return token_type::parse_error;
+                }
+
+                case 0x0D:
+                {
+                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
+                    return token_type::parse_error;
+                }
+
+                case 0x0E:
+                {
+                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
+                    return token_type::parse_error;
+                }
+
+                case 0x0F:
+                {
+                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
+                    return token_type::parse_error;
+                }
+
+                case 0x10:
+                {
+                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
+                    return token_type::parse_error;
+                }
+
+                case 0x11:
+                {
+                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
+                    return token_type::parse_error;
+                }
+
+                case 0x12:
+                {
+                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
+                    return token_type::parse_error;
+                }
+
+                case 0x13:
+                {
+                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
+                    return token_type::parse_error;
+                }
+
+                case 0x14:
+                {
+                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
+                    return token_type::parse_error;
+                }
+
+                case 0x15:
+                {
+                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
+                    return token_type::parse_error;
+                }
+
+                case 0x16:
+                {
+                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
+                    return token_type::parse_error;
+                }
+
+                case 0x17:
+                {
+                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
+                    return token_type::parse_error;
+                }
+
+                case 0x18:
+                {
+                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
+                    return token_type::parse_error;
+                }
+
+                case 0x19:
+                {
+                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
+                    return token_type::parse_error;
+                }
+
+                case 0x1A:
+                {
+                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
+                    return token_type::parse_error;
+                }
+
+                case 0x1B:
+                {
+                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
+                    return token_type::parse_error;
+                }
+
+                case 0x1C:
+                {
+                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
+                    return token_type::parse_error;
+                }
+
+                case 0x1D:
+                {
+                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
+                    return token_type::parse_error;
+                }
+
+                case 0x1E:
+                {
+                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
+                    return token_type::parse_error;
+                }
+
+                case 0x1F:
+                {
+                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
+                    return token_type::parse_error;
+                }
+
+                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
+                case 0x20:
+                case 0x21:
+                case 0x23:
+                case 0x24:
+                case 0x25:
+                case 0x26:
+                case 0x27:
+                case 0x28:
+                case 0x29:
+                case 0x2A:
+                case 0x2B:
+                case 0x2C:
+                case 0x2D:
+                case 0x2E:
+                case 0x2F:
+                case 0x30:
+                case 0x31:
+                case 0x32:
+                case 0x33:
+                case 0x34:
+                case 0x35:
+                case 0x36:
+                case 0x37:
+                case 0x38:
+                case 0x39:
+                case 0x3A:
+                case 0x3B:
+                case 0x3C:
+                case 0x3D:
+                case 0x3E:
+                case 0x3F:
+                case 0x40:
+                case 0x41:
+                case 0x42:
+                case 0x43:
+                case 0x44:
+                case 0x45:
+                case 0x46:
+                case 0x47:
+                case 0x48:
+                case 0x49:
+                case 0x4A:
+                case 0x4B:
+                case 0x4C:
+                case 0x4D:
+                case 0x4E:
+                case 0x4F:
+                case 0x50:
+                case 0x51:
+                case 0x52:
+                case 0x53:
+                case 0x54:
+                case 0x55:
+                case 0x56:
+                case 0x57:
+                case 0x58:
+                case 0x59:
+                case 0x5A:
+                case 0x5B:
+                case 0x5D:
+                case 0x5E:
+                case 0x5F:
+                case 0x60:
+                case 0x61:
+                case 0x62:
+                case 0x63:
+                case 0x64:
+                case 0x65:
+                case 0x66:
+                case 0x67:
+                case 0x68:
+                case 0x69:
+                case 0x6A:
+                case 0x6B:
+                case 0x6C:
+                case 0x6D:
+                case 0x6E:
+                case 0x6F:
+                case 0x70:
+                case 0x71:
+                case 0x72:
+                case 0x73:
+                case 0x74:
+                case 0x75:
+                case 0x76:
+                case 0x77:
+                case 0x78:
+                case 0x79:
+                case 0x7A:
+                case 0x7B:
+                case 0x7C:
+                case 0x7D:
+                case 0x7E:
+                case 0x7F:
+                {
+                    add(current);
+                    break;
+                }
+
+                // U+0080..U+07FF: bytes C2..DF 80..BF
+                case 0xC2:
+                case 0xC3:
+                case 0xC4:
+                case 0xC5:
+                case 0xC6:
+                case 0xC7:
+                case 0xC8:
+                case 0xC9:
+                case 0xCA:
+                case 0xCB:
+                case 0xCC:
+                case 0xCD:
+                case 0xCE:
+                case 0xCF:
+                case 0xD0:
+                case 0xD1:
+                case 0xD2:
+                case 0xD3:
+                case 0xD4:
+                case 0xD5:
+                case 0xD6:
+                case 0xD7:
+                case 0xD8:
+                case 0xD9:
+                case 0xDA:
+                case 0xDB:
+                case 0xDC:
+                case 0xDD:
+                case 0xDE:
+                case 0xDF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
+                case 0xE0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
+                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
+                case 0xE1:
+                case 0xE2:
+                case 0xE3:
+                case 0xE4:
+                case 0xE5:
+                case 0xE6:
+                case 0xE7:
+                case 0xE8:
+                case 0xE9:
+                case 0xEA:
+                case 0xEB:
+                case 0xEC:
+                case 0xEE:
+                case 0xEF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
+                case 0xED:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
+                case 0xF0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
+                case 0xF1:
+                case 0xF2:
+                case 0xF3:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
+                case 0xF4:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // remaining bytes (80..C1 and F5..FF) are ill-formed
+                default:
+                {
+                    error_message = "invalid string: ill-formed UTF-8 byte";
+                    return token_type::parse_error;
+                }
+            }
+        }
+    }
+
+    /*!
+     * @brief scan a comment
+     * @return whether comment could be scanned successfully
+     */
+    bool scan_comment()
+    {
+        switch (get())
+        {
+            // single-line comments skip input until a newline or EOF is read
+            case '/':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case '\n':
+                        case '\r':
+                        case char_traits<char_type>::eof():
+                        case '\0':
+                            return true;
+
+                        default:
+                            break;
+                    }
+                }
+            }
+
+            // multi-line comments skip input until */ is read
+            case '*':
+            {
+                while (true)
+                {
+                    switch (get())
+                    {
+                        case char_traits<char_type>::eof():
+                        case '\0':
+                        {
+                            error_message = "invalid comment; missing closing '*/'";
+                            return false;
+                        }
+
+                        case '*':
+                        {
+                            switch (get())
+                            {
+                                case '/':
+                                    return true;
+
+                                default:
+                                {
+                                    unget();
+                                    continue;
+                                }
+                            }
+                        }
+
+                        default:
+                            continue;
+                    }
+                }
+            }
+
+            // unexpected character after reading '/'
+            default:
+            {
+                error_message = "invalid comment; expecting '/' or '*' after '/'";
+                return false;
+            }
+        }
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(float& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtof(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtod(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(long double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtold(str, endptr);
+    }
+
+    /*!
+    @brief scan a number literal
+
+    This function scans a string according to Sect. 6 of RFC 8259.
+
+    The function is realized with a deterministic finite state machine derived
+    from the grammar described in RFC 8259. Starting in state "init", the
+    input is read and used to determined the next state. Only state "done"
+    accepts the number. State "error" is a trap state to model errors. In the
+    table below, "anything" means any character but the ones listed before.
+
+    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
+    ---------|----------|----------|----------|---------|---------|----------|-----------
+    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
+    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
+    zero     | done     | done     | exponent | done    | done    | decimal1 | done
+    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
+    decimal1 | decimal2 | decimal2 | [error]  | [error] | [error] | [error]  | [error]
+    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
+    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
+    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
+    any2     | any2     | any2     | done     | done    | done    | done     | done
+
+    The state machine is realized with one label per state (prefixed with
+    "scan_number_") and `goto` statements between them. The state machine
+    contains cycles, but any cycle can be left when EOF is read. Therefore,
+    the function is guaranteed to terminate.
+
+    During scanning, the read bytes are stored in token_buffer. This string is
+    then converted to a signed integer, an unsigned integer, or a
+    floating-point number.
+
+    @return token_type::value_unsigned, token_type::value_integer, or
+            token_type::value_float if number could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note The scanner is independent of the current locale. Internally, the
+          locale's decimal point is used instead of `.` to work with the
+          locale-dependent converters.
+    */
+    token_type scan_number()  // lgtm [cpp/use-of-goto]
+    {
+        // reset token_buffer to store the number's bytes
+        reset();
+
+        // the type of the parsed number; initially set to unsigned; will be
+        // changed if minus sign, decimal point or exponent is read
+        token_type number_type = token_type::value_unsigned;
+
+        // state (init): we just found out we need to scan a number
+        switch (current)
+        {
+            case '-':
+            {
+                add(current);
+                goto scan_number_minus;
+            }
+
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            // all other characters are rejected outside scan_number()
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+scan_number_minus:
+        // state: we just parsed a leading minus sign
+        number_type = token_type::value_integer;
+        switch (get())
+        {
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '-'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_zero:
+        // state: we just parse a zero (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_any1:
+        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_decimal1:
+        // state: we just parsed a decimal point
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '.'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_decimal2:
+        // we just parsed at least one number after a decimal point
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_exponent:
+        // we just parsed an exponent
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '+':
+            case '-':
+            {
+                add(current);
+                goto scan_number_sign;
+            }
+
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message =
+                    "invalid number; expected '+', '-', or digit after exponent";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_sign:
+        // we just parsed an exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after exponent sign";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_any2:
+        // we just parsed a number after the exponent or exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_done:
+        // unget the character after the number (we only read it to know that
+        // we are done scanning a number)
+        unget();
+
+        char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        errno = 0;
+
+        // try to parse integers first and fall back to floats
+        if (number_type == token_type::value_unsigned)
+        {
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_unsigned = static_cast<number_unsigned_t>(x);
+                if (value_unsigned == x)
+                {
+                    return token_type::value_unsigned;
+                }
+            }
+        }
+        else if (number_type == token_type::value_integer)
+        {
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_integer = static_cast<number_integer_t>(x);
+                if (value_integer == x)
+                {
+                    return token_type::value_integer;
+                }
+            }
+        }
+
+        // this code is reached if we parse a floating-point number or if an
+        // integer conversion above failed
+        strtof(value_float, token_buffer.data(), &endptr);
+
+        // we checked the number format before
+        JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
+
+        return token_type::value_float;
+    }
+
+    /*!
+    @param[in] literal_text  the literal text to expect
+    @param[in] length        the length of the passed literal text
+    @param[in] return_type   the token type to return on success
+    */
+    JSON_HEDLEY_NON_NULL(2)
+    token_type scan_literal(const char_type* literal_text, const std::size_t length,
+                            token_type return_type)
+    {
+        JSON_ASSERT(char_traits<char_type>::to_char_type(current) == literal_text[0]);
+        for (std::size_t i = 1; i < length; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(char_traits<char_type>::to_char_type(get()) != literal_text[i]))
+            {
+                error_message = "invalid literal";
+                return token_type::parse_error;
+            }
+        }
+        return return_type;
+    }
+
+    /////////////////////
+    // input management
+    /////////////////////
+
+    /// reset token_buffer; current character is beginning of token
+    void reset() noexcept
+    {
+        token_buffer.clear();
+        token_string.clear();
+        token_string.push_back(char_traits<char_type>::to_char_type(current));
+    }
+
+    /*
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a
+    `char_traits<char>::eof()` in that case.  Stores the scanned characters
+    for use in error messages.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++position.chars_read_total;
+        ++position.chars_read_current_line;
+
+        if (next_unget)
+        {
+            // just reset the next_unget variable and work with current
+            next_unget = false;
+        }
+        else
+        {
+            current = ia.get_character();
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
+        {
+            token_string.push_back(char_traits<char_type>::to_char_type(current));
+        }
+
+        if (current == '\n')
+        {
+            ++position.lines_read;
+            position.chars_read_current_line = 0;
+        }
+
+        return current;
+    }
+
+    /*!
+    @brief unget current character (read it again on next get)
+
+    We implement unget by setting variable next_unget to true. The input is not
+    changed - we just simulate ungetting by modifying chars_read_total,
+    chars_read_current_line, and token_string. The next call to get() will
+    behave as if the unget character is read again.
+    */
+    void unget()
+    {
+        next_unget = true;
+
+        --position.chars_read_total;
+
+        // in case we "unget" a newline, we have to also decrement the lines_read
+        if (position.chars_read_current_line == 0)
+        {
+            if (position.lines_read > 0)
+            {
+                --position.lines_read;
+            }
+        }
+        else
+        {
+            --position.chars_read_current_line;
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
+        {
+            JSON_ASSERT(!token_string.empty());
+            token_string.pop_back();
+        }
+    }
+
+    /// add a character to token_buffer
+    void add(char_int_type c)
+    {
+        token_buffer.push_back(static_cast<typename string_t::value_type>(c));
+    }
+
+  public:
+    /////////////////////
+    // value getters
+    /////////////////////
+
+    /// return integer value
+    constexpr number_integer_t get_number_integer() const noexcept
+    {
+        return value_integer;
+    }
+
+    /// return unsigned integer value
+    constexpr number_unsigned_t get_number_unsigned() const noexcept
+    {
+        return value_unsigned;
+    }
+
+    /// return floating-point value
+    constexpr number_float_t get_number_float() const noexcept
+    {
+        return value_float;
+    }
+
+    /// return current string value (implicitly resets the token; useful only once)
+    string_t& get_string()
+    {
+        return token_buffer;
+    }
+
+    /////////////////////
+    // diagnostics
+    /////////////////////
+
+    /// return position of last read token
+    constexpr position_t get_position() const noexcept
+    {
+        return position;
+    }
+
+    /// return the last read token (for errors only).  Will never contain EOF
+    /// (an arbitrary value that is not a valid char value, often -1), because
+    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
+    std::string get_token_string() const
+    {
+        // escape control characters
+        std::string result;
+        for (const auto c : token_string)
+        {
+            if (static_cast<unsigned char>(c) <= '\x1F')
+            {
+                // escape control characters
+                std::array<char, 9> cs{{}};
+                static_cast<void>((std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                result += cs.data();
+            }
+            else
+            {
+                // add character as is
+                result.push_back(static_cast<std::string::value_type>(c));
+            }
+        }
+
+        return result;
+    }
+
+    /// return syntax error message
+    JSON_HEDLEY_RETURNS_NON_NULL
+    constexpr const char* get_error_message() const noexcept
+    {
+        return error_message;
+    }
+
+    /////////////////////
+    // actual scanner
+    /////////////////////
+
+    /*!
+    @brief skip the UTF-8 byte order mark
+    @return true iff there is no BOM or the correct BOM has been skipped
+    */
+    bool skip_bom()
+    {
+        if (get() == 0xEF)
+        {
+            // check if we completely parse the BOM
+            return get() == 0xBB && get() == 0xBF;
+        }
+
+        // the first character is not the beginning of the BOM; unget it to
+        // process is later
+        unget();
+        return true;
+    }
+
+    void skip_whitespace()
+    {
+        do
+        {
+            get();
+        }
+        while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
+    }
+
+    token_type scan()
+    {
+        // initially, skip the BOM
+        if (position.chars_read_total == 0 && !skip_bom())
+        {
+            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
+            return token_type::parse_error;
+        }
+
+        // read next character and ignore whitespace
+        skip_whitespace();
+
+        // ignore comments
+        while (ignore_comments && current == '/')
+        {
+            if (!scan_comment())
+            {
+                return token_type::parse_error;
+            }
+
+            // skip following whitespace
+            skip_whitespace();
+        }
+
+        switch (current)
+        {
+            // structural characters
+            case '[':
+                return token_type::begin_array;
+            case ']':
+                return token_type::end_array;
+            case '{':
+                return token_type::begin_object;
+            case '}':
+                return token_type::end_object;
+            case ':':
+                return token_type::name_separator;
+            case ',':
+                return token_type::value_separator;
+
+            // literals
+            case 't':
+            {
+                std::array<char_type, 4> true_literal = {{static_cast<char_type>('t'), static_cast<char_type>('r'), static_cast<char_type>('u'), static_cast<char_type>('e')}};
+                return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
+            }
+            case 'f':
+            {
+                std::array<char_type, 5> false_literal = {{static_cast<char_type>('f'), static_cast<char_type>('a'), static_cast<char_type>('l'), static_cast<char_type>('s'), static_cast<char_type>('e')}};
+                return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
+            }
+            case 'n':
+            {
+                std::array<char_type, 4> null_literal = {{static_cast<char_type>('n'), static_cast<char_type>('u'), static_cast<char_type>('l'), static_cast<char_type>('l')}};
+                return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
+            }
+
+            // string
+            case '\"':
+                return scan_string();
+
+            // number
+            case '-':
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                return scan_number();
+
+            // end of input (the null byte is needed when parsing from
+            // string literals)
+            case '\0':
+            case char_traits<char_type>::eof():
+                return token_type::end_of_input;
+
+            // error
+            default:
+                error_message = "invalid literal";
+                return token_type::parse_error;
+        }
+    }
+
+  private:
+    /// input adapter
+    InputAdapterType ia;
+
+    /// whether comments should be ignored (true) or signaled as errors (false)
+    const bool ignore_comments = false;
+
+    /// the current character
+    char_int_type current = char_traits<char_type>::eof();
+
+    /// whether the next get() call should just return current
+    bool next_unget = false;
+
+    /// the start position of the current token
+    position_t position {};
+
+    /// raw input token string (for error messages)
+    std::vector<char_type> token_string {};
+
+    /// buffer for variable-length tokens (numbers, strings)
+    string_t token_buffer {};
+
+    /// a description of occurred lexer errors
+    const char* error_message = "";
+
+    // number values
+    number_integer_t value_integer = 0;
+    number_unsigned_t value_unsigned = 0;
+    number_float_t value_float = 0;
+
+    /// the decimal point
+    const char_int_type decimal_point_char = '.';
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstdint> // size_t
+#include <utility> // declval
+#include <string> // string
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename T>
+using null_function_t = decltype(std::declval<T&>().null());
+
+template<typename T>
+using boolean_function_t =
+    decltype(std::declval<T&>().boolean(std::declval<bool>()));
+
+template<typename T, typename Integer>
+using number_integer_function_t =
+    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
+
+template<typename T, typename Unsigned>
+using number_unsigned_function_t =
+    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
+
+template<typename T, typename Float, typename String>
+using number_float_function_t = decltype(std::declval<T&>().number_float(
+                                    std::declval<Float>(), std::declval<const String&>()));
+
+template<typename T, typename String>
+using string_function_t =
+    decltype(std::declval<T&>().string(std::declval<String&>()));
+
+template<typename T, typename Binary>
+using binary_function_t =
+    decltype(std::declval<T&>().binary(std::declval<Binary&>()));
+
+template<typename T>
+using start_object_function_t =
+    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
+
+template<typename T, typename String>
+using key_function_t =
+    decltype(std::declval<T&>().key(std::declval<String&>()));
+
+template<typename T>
+using end_object_function_t = decltype(std::declval<T&>().end_object());
+
+template<typename T>
+using start_array_function_t =
+    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
+
+template<typename T>
+using end_array_function_t = decltype(std::declval<T&>().end_array());
+
+template<typename T, typename Exception>
+using parse_error_function_t = decltype(std::declval<T&>().parse_error(
+        std::declval<std::size_t>(), std::declval<const std::string&>(),
+        std::declval<const Exception&>()));
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static constexpr bool value =
+        is_detected_exact<bool, null_function_t, SAX>::value &&
+        is_detected_exact<bool, boolean_function_t, SAX>::value &&
+        is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
+        is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
+        is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
+        is_detected_exact<bool, start_object_function_t, SAX>::value &&
+        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, end_object_function_t, SAX>::value &&
+        is_detected_exact<bool, start_array_function_t, SAX>::value &&
+        is_detected_exact<bool, end_array_function_t, SAX>::value &&
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
+};
+
+template<typename SAX, typename BasicJsonType>
+struct is_sax_static_asserts
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
+                  "Missing/invalid function: bool null()");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(
+        is_detected_exact<bool, number_integer_function_t, SAX,
+        number_integer_t>::value,
+        "Missing/invalid function: bool number_integer(number_integer_t)");
+    static_assert(
+        is_detected_exact<bool, number_unsigned_function_t, SAX,
+        number_unsigned_t>::value,
+        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
+    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
+                  number_float_t, string_t>::value,
+                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
+    static_assert(
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
+        "Missing/invalid function: bool string(string_t&)");
+    static_assert(
+        is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
+        "Missing/invalid function: bool binary(binary_t&)");
+    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_object(std::size_t)");
+    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
+                  "Missing/invalid function: bool key(string_t&)");
+    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_object()");
+    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_array(std::size_t)");
+    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_array()");
+    static_assert(
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
+        "Missing/invalid function: bool parse_error(std::size_t, const "
+        "std::string&, const exception&)");
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// how to treat CBOR tags
+enum class cbor_tag_handler_t
+{
+    error,   ///< throw a parse_error exception in case of a tag
+    ignore,  ///< ignore tags
+    store    ///< store tags as binary type
+};
+
+/*!
+@brief determine system byte order
+
+@return true if and only if system's byte order is little endian
+
+@note from https://stackoverflow.com/a/1001328/266378
+*/
+static inline bool little_endianness(int num = 1) noexcept
+{
+    return *reinterpret_cast<char*>(&num) == 1;
+}
+
+///////////////////
+// binary reader //
+///////////////////
+
+/*!
+@brief deserialization of CBOR, MessagePack, and UBJSON values
+*/
+template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
+class binary_reader
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using json_sax_t = SAX;
+    using char_type = typename InputAdapterType::char_type;
+    using char_int_type = typename char_traits<char_type>::int_type;
+
+  public:
+    /*!
+    @brief create a binary reader
+
+    @param[in] adapter  input adapter to read from
+    */
+    explicit binary_reader(InputAdapterType&& adapter, const input_format_t format = input_format_t::json) noexcept : ia(std::move(adapter)), input_format(format)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+    }
+
+    // make class move-only
+    binary_reader(const binary_reader&) = delete;
+    binary_reader(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    binary_reader& operator=(const binary_reader&) = delete;
+    binary_reader& operator=(binary_reader&&) = default; // NOLINT(hicpp-noexcept-move,performance-noexcept-move-constructor)
+    ~binary_reader() = default;
+
+    /*!
+    @param[in] format  the binary format to parse
+    @param[in] sax_    a SAX event processor
+    @param[in] strict  whether to expect the input to be consumed completed
+    @param[in] tag_handler  how to treat CBOR tags
+
+    @return whether parsing was successful
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool sax_parse(const input_format_t format,
+                   json_sax_t* sax_,
+                   const bool strict = true,
+                   const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        sax = sax_;
+        bool result = false;
+
+        switch (format)
+        {
+            case input_format_t::bson:
+                result = parse_bson_internal();
+                break;
+
+            case input_format_t::cbor:
+                result = parse_cbor_internal(true, tag_handler);
+                break;
+
+            case input_format_t::msgpack:
+                result = parse_msgpack_internal();
+                break;
+
+            case input_format_t::ubjson:
+            case input_format_t::bjdata:
+                result = parse_ubjson_internal();
+                break;
+
+            case input_format_t::json: // LCOV_EXCL_LINE
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+        // strict mode: next byte must be EOF
+        if (result && strict)
+        {
+            if (input_format == input_format_t::ubjson || input_format == input_format_t::bjdata)
+            {
+                get_ignore_noop();
+            }
+            else
+            {
+                get();
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(current != char_traits<char_type>::eof()))
+            {
+                return sax->parse_error(chars_read, get_token_string(), parse_error::create(110, chars_read,
+                                        exception_message(input_format, concat("expected end of input; last byte: 0x", get_token_string()), "value"), nullptr));
+            }
+        }
+
+        return result;
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @brief Reads in a BSON-object and passes it to the SAX-parser.
+    @return whether a valid BSON-value was passed to the SAX parser
+    */
+    bool parse_bson_internal()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
+        {
+            return false;
+        }
+
+        return sax->end_object();
+    }
+
+    /*!
+    @brief Parses a C-style string from the BSON input.
+    @param[in,out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @return `true` if the \x00-byte indicating the end of the string was
+             encountered before the EOF; false` indicates an unexpected EOF.
+    */
+    bool get_bson_cstr(string_t& result)
+    {
+        auto out = std::back_inserter(result);
+        while (true)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
+            {
+                return false;
+            }
+            if (current == 0x00)
+            {
+                return true;
+            }
+            *out++ = static_cast<typename string_t::value_type>(current);
+        }
+    }
+
+    /*!
+    @brief Parses a zero-terminated string of length @a len from the BSON
+           input.
+    @param[in] len  The length (including the zero-byte at the end) of the
+                    string to be read.
+    @param[in,out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 1
+    @return `true` if the string was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_string(const NumberType len, string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 1))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format_t::bson, concat("string length must be at least 1, is ", std::to_string(len)), "string"), nullptr));
+        }
+
+        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != char_traits<char_type>::eof();
+    }
+
+    /*!
+    @brief Parses a byte array input of length @a len from the BSON input.
+    @param[in] len  The length of the byte array to be read.
+    @param[in,out] result  A reference to the binary variable where the read
+                            array is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 0
+    @return `true` if the byte array was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_binary(const NumberType len, binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 0))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format_t::bson, concat("byte array length cannot be negative, is ", std::to_string(len)), "binary"), nullptr));
+        }
+
+        // All BSON binary values have a subtype
+        std::uint8_t subtype{};
+        get_number<std::uint8_t>(input_format_t::bson, subtype);
+        result.set_subtype(subtype);
+
+        return get_binary(input_format_t::bson, len, result);
+    }
+
+    /*!
+    @brief Read a BSON document element of the given @a element_type.
+    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
+    @param[in] element_type_parse_position The position in the input stream,
+               where the `element_type` was read.
+    @warning Not all BSON element types are supported yet. An unsupported
+             @a element_type will give rise to a parse_error.114:
+             Unsupported BSON record type 0x...
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_internal(const char_int_type element_type,
+                                     const std::size_t element_type_parse_position)
+    {
+        switch (element_type)
+        {
+            case 0x01: // double
+            {
+                double number{};
+                return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0x02: // string
+            {
+                std::int32_t len{};
+                string_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
+            }
+
+            case 0x03: // object
+            {
+                return parse_bson_internal();
+            }
+
+            case 0x04: // array
+            {
+                return parse_bson_array();
+            }
+
+            case 0x05: // binary
+            {
+                std::int32_t len{};
+                binary_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
+            }
+
+            case 0x08: // boolean
+            {
+                return sax->boolean(get() != 0);
+            }
+
+            case 0x0A: // null
+            {
+                return sax->null();
+            }
+
+            case 0x10: // int32
+            {
+                std::int32_t value{};
+                return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            case 0x12: // int64
+            {
+                std::int64_t value{};
+                return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
+            }
+
+            default: // anything else not supported (yet)
+            {
+                std::array<char, 3> cr{{}};
+                static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                const std::string cr_str{cr.data()};
+                return sax->parse_error(element_type_parse_position, cr_str,
+                                        parse_error::create(114, element_type_parse_position, concat("Unsupported BSON record type 0x", cr_str), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief Read a BSON element list (as specified in the BSON-spec)
+
+    The same binary layout is used for objects and arrays, hence it must be
+    indicated with the argument @a is_array which one is expected
+    (true --> array, false --> object).
+
+    @param[in] is_array Determines if the element list being read is to be
+                        treated as an object (@a is_array == false), or as an
+                        array (@a is_array == true).
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_list(const bool is_array)
+    {
+        string_t key;
+
+        while (auto element_type = get())
+        {
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
+            {
+                return false;
+            }
+
+            const std::size_t element_type_parse_position = chars_read;
+            if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
+            {
+                return false;
+            }
+
+            if (!is_array && !sax->key(key))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
+            {
+                return false;
+            }
+
+            // get_bson_cstr only appends
+            key.clear();
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief Reads an array from the BSON input and passes it to the SAX-parser.
+    @return whether a valid BSON-array was passed to the SAX parser
+    */
+    bool parse_bson_array()
+    {
+        std::int32_t document_size{};
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
+        {
+            return false;
+        }
+
+        return sax->end_array();
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true) or whether the last read character should
+                         be considered instead (false)
+    @param[in] tag_handler how CBOR tags should be treated
+
+    @return whether a valid CBOR value was passed to the SAX parser
+    */
+    bool parse_cbor_internal(const bool get_char,
+                             const cbor_tag_handler_t tag_handler)
+    {
+        switch (get_char ? get() : current)
+        {
+            // EOF
+            case char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::cbor, "value");
+
+            // Integer 0x00..0x17 (0..23)
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            case 0x18: // Unsigned integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x19: // Unsigned integer (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
+            }
+
+            // Negative integer -1-0x00..-1-0x17 (-1..-24)
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
+
+            case 0x38: // Negative integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
+                        - static_cast<number_integer_t>(number));
+            }
+
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            case 0x5F: // Binary data (indefinite length)
+            {
+                binary_t b;
+                return get_cbor_binary(b) && sax->binary(b);
+            }
+
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                string_t s;
+                return get_cbor_string(s) && sax->string(s);
+            }
+
+            // array (0x00..0x17 data items follow)
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+                return get_cbor_array(
+                           conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0x98: // array (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x99: // array (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9A: // array (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9B: // array (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_array(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0x9F: // array (indefinite length)
+                return get_cbor_array(static_cast<std::size_t>(-1), tag_handler);
+
+            // map (0x00..0x17 pairs of data items follow)
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+                return get_cbor_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
+
+            case 0xB8: // map (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xB9: // map (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBA: // map (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBB: // map (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_cbor_object(conditional_static_cast<std::size_t>(len), tag_handler);
+            }
+
+            case 0xBF: // map (indefinite length)
+                return get_cbor_object(static_cast<std::size_t>(-1), tag_handler);
+
+            case 0xC6: // tagged item
+            case 0xC7:
+            case 0xC8:
+            case 0xC9:
+            case 0xCA:
+            case 0xCB:
+            case 0xCC:
+            case 0xCD:
+            case 0xCE:
+            case 0xCF:
+            case 0xD0:
+            case 0xD1:
+            case 0xD2:
+            case 0xD3:
+            case 0xD4:
+            case 0xD8: // tagged item (1 bytes follow)
+            case 0xD9: // tagged item (2 bytes follow)
+            case 0xDA: // tagged item (4 bytes follow)
+            case 0xDB: // tagged item (8 bytes follow)
+            {
+                switch (tag_handler)
+                {
+                    case cbor_tag_handler_t::error:
+                    {
+                        auto last_token = get_token_string();
+                        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                                exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
+                    }
+
+                    case cbor_tag_handler_t::ignore:
+                    {
+                        // ignore binary subtype
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t subtype_to_ignore{};
+                                get_number(input_format_t::cbor, subtype_to_ignore);
+                                break;
+                            }
+                            default:
+                                break;
+                        }
+                        return parse_cbor_internal(true, tag_handler);
+                    }
+
+                    case cbor_tag_handler_t::store:
+                    {
+                        binary_t b;
+                        // use binary subtype and store in binary container
+                        switch (current)
+                        {
+                            case 0xD8:
+                            {
+                                std::uint8_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xD9:
+                            {
+                                std::uint16_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xDA:
+                            {
+                                std::uint32_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            case 0xDB:
+                            {
+                                std::uint64_t subtype{};
+                                get_number(input_format_t::cbor, subtype);
+                                b.set_subtype(detail::conditional_static_cast<typename binary_t::subtype_type>(subtype));
+                                break;
+                            }
+                            default:
+                                return parse_cbor_internal(true, tag_handler);
+                        }
+                        get();
+                        return get_cbor_binary(b) && sax->binary(b);
+                    }
+
+                    default:                 // LCOV_EXCL_LINE
+                        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+                        return false;        // LCOV_EXCL_LINE
+                }
+            }
+
+            case 0xF4: // false
+                return sax->boolean(false);
+
+            case 0xF5: // true
+                return sax->boolean(true);
+
+            case 0xF6: // null
+                return sax->null();
+
+            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
+            {
+                const auto byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+                const auto byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
+            {
+                float number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
+            {
+                double number{};
+                return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            default: // anything else (0xFF is handled inside the other types)
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format_t::cbor, concat("invalid byte: 0x", last_token), "value"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+    Additionally, CBOR's strings with indefinite lengths are supported.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_cbor_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            {
+                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    string_t chunk;
+                    if (!get_cbor_string(chunk))
+                    {
+                        return false;
+                    }
+                    result.append(chunk);
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::cbor, concat("expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x", last_token), "string"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into the byte array.
+    Additionally, CBOR's byte arrays with indefinite lengths are supported.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_cbor_binary(binary_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // Binary data (0x00..0x17 bytes follow)
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            {
+                return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x58: // Binary data (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x59: // Binary data (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5A: // Binary data (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5B: // Binary data (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len{};
+                return get_number(input_format_t::cbor, len) &&
+                       get_binary(input_format_t::cbor, len, result);
+            }
+
+            case 0x5F: // Binary data (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    binary_t chunk;
+                    if (!get_cbor_binary(chunk))
+                    {
+                        return false;
+                    }
+                    result.insert(result.end(), chunk.begin(), chunk.end());
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::cbor, concat("expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x", last_token), "binary"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array or static_cast<std::size_t>(-1) for an
+                    array of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether array creation completed
+    */
+    bool get_cbor_array(const std::size_t len,
+                        const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        if (len != static_cast<std::size_t>(-1))
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
+                {
+                    return false;
+                }
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object or static_cast<std::size_t>(-1) for an
+                    object of indefinite size
+    @param[in] tag_handler how CBOR tags should be treated
+    @return whether object creation completed
+    */
+    bool get_cbor_object(const std::size_t len,
+                         const cbor_tag_handler_t tag_handler)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        if (len != 0)
+        {
+            string_t key;
+            if (len != static_cast<std::size_t>(-1))
+            {
+                for (std::size_t i = 0; i < len; ++i)
+                {
+                    get();
+                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                while (get() != 0xFF)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    /*!
+    @return whether a valid MessagePack value was passed to the SAX parser
+    */
+    bool parse_msgpack_internal()
+    {
+        switch (get())
+        {
+            // EOF
+            case char_traits<char_type>::eof():
+                return unexpect_eof(input_format_t::msgpack, "value");
+
+            // positive fixint
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+            case 0x18:
+            case 0x19:
+            case 0x1A:
+            case 0x1B:
+            case 0x1C:
+            case 0x1D:
+            case 0x1E:
+            case 0x1F:
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+            case 0x38:
+            case 0x39:
+            case 0x3A:
+            case 0x3B:
+            case 0x3C:
+            case 0x3D:
+            case 0x3E:
+            case 0x3F:
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58:
+            case 0x59:
+            case 0x5A:
+            case 0x5B:
+            case 0x5C:
+            case 0x5D:
+            case 0x5E:
+            case 0x5F:
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78:
+            case 0x79:
+            case 0x7A:
+            case 0x7B:
+            case 0x7C:
+            case 0x7D:
+            case 0x7E:
+            case 0x7F:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            // fixmap
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+                return get_msgpack_object(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixarray
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+            case 0x98:
+            case 0x99:
+            case 0x9A:
+            case 0x9B:
+            case 0x9C:
+            case 0x9D:
+            case 0x9E:
+            case 0x9F:
+                return get_msgpack_array(conditional_static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            case 0xD9: // str 8
+            case 0xDA: // str 16
+            case 0xDB: // str 32
+            {
+                string_t s;
+                return get_msgpack_string(s) && sax->string(s);
+            }
+
+            case 0xC0: // nil
+                return sax->null();
+
+            case 0xC2: // false
+                return sax->boolean(false);
+
+            case 0xC3: // true
+                return sax->boolean(true);
+
+            case 0xC4: // bin 8
+            case 0xC5: // bin 16
+            case 0xC6: // bin 32
+            case 0xC7: // ext 8
+            case 0xC8: // ext 16
+            case 0xC9: // ext 32
+            case 0xD4: // fixext 1
+            case 0xD5: // fixext 2
+            case 0xD6: // fixext 4
+            case 0xD7: // fixext 8
+            case 0xD8: // fixext 16
+            {
+                binary_t b;
+                return get_msgpack_binary(b) && sax->binary(b);
+            }
+
+            case 0xCA: // float 32
+            {
+                float number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCB: // float 64
+            {
+                double number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCC: // uint 8
+            {
+                std::uint8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCD: // uint 16
+            {
+                std::uint16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCE: // uint 32
+            {
+                std::uint32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xCF: // uint 64
+            {
+                std::uint64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
+            }
+
+            case 0xD0: // int 8
+            {
+                std::int8_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD1: // int 16
+            {
+                std::int16_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD2: // int 32
+            {
+                std::int32_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xD3: // int 64
+            {
+                std::int64_t number{};
+                return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
+            }
+
+            case 0xDC: // array 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDD: // array 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_array(conditional_static_cast<std::size_t>(len));
+            }
+
+            case 0xDE: // map 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xDF: // map 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_msgpack_object(conditional_static_cast<std::size_t>(len));
+            }
+
+            // negative fixint
+            case 0xE0:
+            case 0xE1:
+            case 0xE2:
+            case 0xE3:
+            case 0xE4:
+            case 0xE5:
+            case 0xE6:
+            case 0xE7:
+            case 0xE8:
+            case 0xE9:
+            case 0xEA:
+            case 0xEB:
+            case 0xEC:
+            case 0xED:
+            case 0xEE:
+            case 0xEF:
+            case 0xF0:
+            case 0xF1:
+            case 0xF2:
+            case 0xF3:
+            case 0xF4:
+            case 0xF5:
+            case 0xF6:
+            case 0xF7:
+            case 0xF8:
+            case 0xF9:
+            case 0xFA:
+            case 0xFB:
+            case 0xFC:
+            case 0xFD:
+            case 0xFE:
+            case 0xFF:
+                return sax->number_integer(static_cast<std::int8_t>(current));
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format_t::msgpack, concat("invalid byte: 0x", last_token), "value"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_msgpack_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            {
+                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0xD9: // str 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDA: // str 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDB: // str 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                        exception_message(input_format_t::msgpack, concat("expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x", last_token), "string"), nullptr));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack byte array
+
+    This function first reads starting bytes to determine the expected
+    byte array length and then copies this number of bytes into a byte array.
+
+    @param[out] result  created byte array
+
+    @return whether byte array creation completed
+    */
+    bool get_msgpack_binary(binary_t& result)
+    {
+        // helper function to set the subtype
+        auto assign_and_return_true = [&result](std::int8_t subtype)
+        {
+            result.set_subtype(static_cast<std::uint8_t>(subtype));
+            return true;
+        };
+
+        switch (current)
+        {
+            case 0xC4: // bin 8
+            {
+                std::uint8_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC5: // bin 16
+            {
+                std::uint16_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC6: // bin 32
+            {
+                std::uint32_t len{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_binary(input_format_t::msgpack, len, result);
+            }
+
+            case 0xC7: // ext 8
+            {
+                std::uint8_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC8: // ext 16
+            {
+                std::uint16_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xC9: // ext 32
+            {
+                std::uint32_t len{};
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, len) &&
+                       get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, len, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD4: // fixext 1
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 1, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD5: // fixext 2
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 2, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD6: // fixext 4
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 4, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD7: // fixext 8
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 8, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            case 0xD8: // fixext 16
+            {
+                std::int8_t subtype{};
+                return get_number(input_format_t::msgpack, subtype) &&
+                       get_binary(input_format_t::msgpack, 16, result) &&
+                       assign_and_return_true(subtype);
+            }
+
+            default:           // LCOV_EXCL_LINE
+                return false;  // LCOV_EXCL_LINE
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array
+    @return whether array creation completed
+    */
+    bool get_msgpack_array(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
+        {
+            return false;
+        }
+
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object
+    @return whether object creation completed
+    */
+    bool get_msgpack_object(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
+            {
+                return false;
+            }
+            key.clear();
+        }
+
+        return sax->end_object();
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether a valid UBJSON value was passed to the SAX parser
+    */
+    bool parse_ubjson_internal(const bool get_char = true)
+    {
+        return get_ubjson_value(get_char ? get_ignore_noop() : current);
+    }
+
+    /*!
+    @brief reads a UBJSON string
+
+    This function is either called after reading the 'S' byte explicitly
+    indicating a string, or in case of an object key where the 'S' byte can be
+    left out.
+
+    @param[out] result   created string
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether string creation completed
+    */
+    bool get_ubjson_string(string_t& result, const bool get_char = true)
+    {
+        if (get_char)
+        {
+            get();  // TODO(niels): may we ignore N here?
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            case 'U':
+            {
+                std::uint8_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'i':
+            {
+                std::int8_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'I':
+            {
+                std::int16_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'l':
+            {
+                std::int32_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'L':
+            {
+                std::int64_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t len{};
+                return get_number(input_format, len) && get_string(input_format, len, result);
+            }
+
+            default:
+                break;
+        }
+        auto last_token = get_token_string();
+        std::string message;
+
+        if (input_format != input_format_t::bjdata)
+        {
+            message = "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token;
+        }
+        else
+        {
+            message = "expected length type specification (U, i, u, I, m, l, M, L); last byte: 0x" + last_token;
+        }
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "string"), nullptr));
+    }
+
+    /*!
+    @param[out] dim  an integer vector storing the ND array dimensions
+    @return whether reading ND array size vector is successful
+    */
+    bool get_ubjson_ndarray_size(std::vector<size_t>& dim)
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        size_t dimlen = 0;
+        bool no_ndarray = true;
+
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type, no_ndarray)))
+        {
+            return false;
+        }
+
+        if (size_and_type.first != npos)
+        {
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, size_and_type.second)))
+                        {
+                            return false;
+                        }
+                        dim.push_back(dimlen);
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray)))
+                    {
+                        return false;
+                    }
+                    dim.push_back(dimlen);
+                }
+            }
+        }
+        else
+        {
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_value(dimlen, no_ndarray, current)))
+                {
+                    return false;
+                }
+                dim.push_back(dimlen);
+                get_ignore_noop();
+            }
+        }
+        return true;
+    }
+
+    /*!
+    @param[out] result  determined size
+    @param[in,out] is_ndarray  for input, `true` means already inside an ndarray vector
+                               or ndarray dimension is not allowed; `false` means ndarray
+                               is allowed; for output, `true` means an ndarray is found;
+                               is_ndarray can only return `true` when its initial value
+                               is `false`
+    @param[in] prefix  type marker if already read, otherwise set to 0
+
+    @return whether size determination completed
+    */
+    bool get_ubjson_size_value(std::size_t& result, bool& is_ndarray, char_int_type prefix = 0)
+    {
+        if (prefix == 0)
+        {
+            prefix = get_ignore_noop();
+        }
+
+        switch (prefix)
+        {
+            case 'U':
+            {
+                std::uint8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number); // NOLINT(bugprone-signed-char-misuse,cert-str34-c): number is not a char
+                return true;
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (number < 0)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read,
+                                            exception_message(input_format, "count in an optimized container must be positive", "size"), nullptr));
+                }
+                if (!value_in_range_of<std::size_t>(number))
+                {
+                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
+                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                result = conditional_static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t number{};
+                if (JSON_HEDLEY_UNLIKELY(!get_number(input_format, number)))
+                {
+                    return false;
+                }
+                if (!value_in_range_of<std::size_t>(number))
+                {
+                    return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408,
+                                            exception_message(input_format, "integer value overflow", "size"), nullptr));
+                }
+                result = detail::conditional_static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case '[':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                if (is_ndarray) // ndarray dimensional vector can only contain integers, and can not embed another array
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(113, chars_read, exception_message(input_format, "ndarray dimensional vector is not allowed", "size"), nullptr));
+                }
+                std::vector<size_t> dim;
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_ndarray_size(dim)))
+                {
+                    return false;
+                }
+                if (dim.size() == 1 || (dim.size() == 2 && dim.at(0) == 1)) // return normal array size if 1D row vector
+                {
+                    result = dim.at(dim.size() - 1);
+                    return true;
+                }
+                if (!dim.empty())  // if ndarray, convert to an object in JData annotated array format
+                {
+                    for (auto i : dim) // test if any dimension in an ndarray is 0, if so, return a 1D empty container
+                    {
+                        if ( i == 0 )
+                        {
+                            result = 0;
+                            return true;
+                        }
+                    }
+
+                    string_t key = "_ArraySize_";
+                    if (JSON_HEDLEY_UNLIKELY(!sax->start_object(3) || !sax->key(key) || !sax->start_array(dim.size())))
+                    {
+                        return false;
+                    }
+                    result = 1;
+                    for (auto i : dim)
+                    {
+                        result *= i;
+                        if (result == 0 || result == npos) // because dim elements shall not have zeros, result = 0 means overflow happened; it also can't be npos as it is used to initialize size in get_ubjson_size_type()
+                        {
+                            return sax->parse_error(chars_read, get_token_string(), out_of_range::create(408, exception_message(input_format, "excessive ndarray size caused overflow", "size"), nullptr));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(static_cast<number_unsigned_t>(i))))
+                        {
+                            return false;
+                        }
+                    }
+                    is_ndarray = true;
+                    return sax->end_array();
+                }
+                result = 0;
+                return true;
+            }
+
+            default:
+                break;
+        }
+        auto last_token = get_token_string();
+        std::string message;
+
+        if (input_format != input_format_t::bjdata)
+        {
+            message = "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token;
+        }
+        else
+        {
+            message = "expected length type specification (U, i, u, I, m, l, M, L) after '#'; last byte: 0x" + last_token;
+        }
+        return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format, message, "size"), nullptr));
+    }
+
+    /*!
+    @brief determine the type and size for a container
+
+    In the optimized UBJSON format, a type and a size can be provided to allow
+    for a more compact representation.
+
+    @param[out] result  pair of the size and the type
+    @param[in] inside_ndarray  whether the parser is parsing an ND array dimensional vector
+
+    @return whether pair creation completed
+    */
+    bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result, bool inside_ndarray = false)
+    {
+        result.first = npos; // size
+        result.second = 0; // type
+        bool is_ndarray = false;
+
+        get_ignore_noop();
+
+        if (current == '$')
+        {
+            result.second = get();  // must not ignore 'N', because 'N' maybe the type
+            if (input_format == input_format_t::bjdata
+                    && JSON_HEDLEY_UNLIKELY(std::binary_search(bjd_optimized_type_markers.begin(), bjd_optimized_type_markers.end(), result.second)))
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, concat("marker 0x", last_token, " is not a permitted optimized array type"), "type"), nullptr));
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "type")))
+            {
+                return false;
+            }
+
+            get_ignore_noop();
+            if (JSON_HEDLEY_UNLIKELY(current != '#'))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "value")))
+                {
+                    return false;
+                }
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, concat("expected '#' after type information; last byte: 0x", last_token), "size"), nullptr));
+            }
+
+            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
+            if (input_format == input_format_t::bjdata && is_ndarray)
+            {
+                if (inside_ndarray)
+                {
+                    return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
+                                            exception_message(input_format, "ndarray can not be recursive", "size"), nullptr));
+                }
+                result.second |= (1 << 8); // use bit 8 to indicate ndarray, all UBJSON and BJData markers should be ASCII letters
+            }
+            return is_error;
+        }
+
+        if (current == '#')
+        {
+            const bool is_error = get_ubjson_size_value(result.first, is_ndarray);
+            if (input_format == input_format_t::bjdata && is_ndarray)
+            {
+                return sax->parse_error(chars_read, get_token_string(), parse_error::create(112, chars_read,
+                                        exception_message(input_format, "ndarray requires both type and size", "size"), nullptr));
+            }
+            return is_error;
+        }
+
+        return true;
+    }
+
+    /*!
+    @param prefix  the previously read or set type prefix
+    @return whether value creation completed
+    */
+    bool get_ubjson_value(const char_int_type prefix)
+    {
+        switch (prefix)
+        {
+            case char_traits<char_type>::eof():  // EOF
+                return unexpect_eof(input_format, "value");
+
+            case 'T':  // true
+                return sax->boolean(true);
+            case 'F':  // false
+                return sax->boolean(false);
+
+            case 'Z':  // null
+                return sax->null();
+
+            case 'U':
+            {
+                std::uint8_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'i':
+            {
+                std::int8_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'I':
+            {
+                std::int16_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'l':
+            {
+                std::int32_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'L':
+            {
+                std::int64_t number{};
+                return get_number(input_format, number) && sax->number_integer(number);
+            }
+
+            case 'u':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint16_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'm':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint32_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'M':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                std::uint64_t number{};
+                return get_number(input_format, number) && sax->number_unsigned(number);
+            }
+
+            case 'h':
+            {
+                if (input_format != input_format_t::bjdata)
+                {
+                    break;
+                }
+                const auto byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+                {
+                    return false;
+                }
+                const auto byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte2 << 8u) + byte1);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    JSON_ASSERT(0 <= exp&& exp <= 32);
+                    JSON_ASSERT(mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 'd':
+            {
+                float number{};
+                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'D':
+            {
+                double number{};
+                return get_number(input_format, number) && sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'H':
+            {
+                return get_ubjson_high_precision_number();
+            }
+
+            case 'C':  // char
+            {
+                get();
+                if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "char")))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(current > 127))
+                {
+                    auto last_token = get_token_string();
+                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read,
+                                            exception_message(input_format, concat("byte after 'C' must be in range 0x00..0x7F; last byte: 0x", last_token), "char"), nullptr));
+                }
+                string_t s(1, static_cast<typename string_t::value_type>(current));
+                return sax->string(s);
+            }
+
+            case 'S':  // string
+            {
+                string_t s;
+                return get_ubjson_string(s) && sax->string(s);
+            }
+
+            case '[':  // array
+                return get_ubjson_array();
+
+            case '{':  // object
+                return get_ubjson_object();
+
+            default: // anything else
+                break;
+        }
+        auto last_token = get_token_string();
+        return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format, "invalid byte: 0x" + last_token, "value"), nullptr));
+    }
+
+    /*!
+    @return whether array creation completed
+    */
+    bool get_ubjson_array()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        // if bit-8 of size_and_type.second is set to 1, encode bjdata ndarray as an object in JData annotated array format (https://github.com/NeuroJSON/jdata):
+        // {"_ArrayType_" : "typeid", "_ArraySize_" : [n1, n2, ...], "_ArrayData_" : [v1, v2, ...]}
+
+        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
+        {
+            size_and_type.second &= ~(static_cast<char_int_type>(1) << 8);  // use bit 8 to indicate ndarray, here we remove the bit to restore the type marker
+            auto it = std::lower_bound(bjd_types_map.begin(), bjd_types_map.end(), size_and_type.second, [](const bjd_type & p, char_int_type t)
+            {
+                return p.first < t;
+            });
+            string_t key = "_ArrayType_";
+            if (JSON_HEDLEY_UNLIKELY(it == bjd_types_map.end() || it->first != size_and_type.second))
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                        exception_message(input_format, "invalid byte: 0x" + last_token, "type"), nullptr));
+            }
+
+            string_t type = it->second; // sax->string() takes a reference
+            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->string(type)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second == 'C')
+            {
+                size_and_type.second = 'U';
+            }
+
+            key = "_ArrayData_";
+            if (JSON_HEDLEY_UNLIKELY(!sax->key(key) || !sax->start_array(size_and_type.first) ))
+            {
+                return false;
+            }
+
+            for (std::size_t i = 0; i < size_and_type.first; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                {
+                    return false;
+                }
+            }
+
+            return (sax->end_array() && sax->end_object());
+        }
+
+        if (size_and_type.first != npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+            {
+                return false;
+            }
+
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @return whether object creation completed
+    */
+    bool get_ubjson_object()
+    {
+        std::pair<std::size_t, char_int_type> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        // do not accept ND-array size in objects in BJData
+        if (input_format == input_format_t::bjdata && size_and_type.first != npos && (size_and_type.second & (1 << 8)) != 0)
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read,
+                                    exception_message(input_format, "BJData object does not support ND-array size in optimized format", "object"), nullptr));
+        }
+
+        string_t key;
+        if (size_and_type.first != npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+            {
+                return false;
+            }
+
+            while (current != '}')
+            {
+                if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    // Note, no reader for UBJSON binary types is implemented because they do
+    // not exist
+
+    bool get_ubjson_high_precision_number()
+    {
+        // get size of following number string
+        std::size_t size{};
+        bool no_ndarray = true;
+        auto res = get_ubjson_size_value(size, no_ndarray);
+        if (JSON_HEDLEY_UNLIKELY(!res))
+        {
+            return res;
+        }
+
+        // get number string
+        std::vector<char> number_vector;
+        for (std::size_t i = 0; i < size; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format, "number")))
+            {
+                return false;
+            }
+            number_vector.push_back(static_cast<char>(current));
+        }
+
+        // parse number string
+        using ia_type = decltype(detail::input_adapter(number_vector));
+        auto number_lexer = detail::lexer<BasicJsonType, ia_type>(detail::input_adapter(number_vector), false);
+        const auto result_number = number_lexer.scan();
+        const auto number_string = number_lexer.get_token_string();
+        const auto result_remainder = number_lexer.scan();
+
+        using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
+
+        if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
+        {
+            return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
+                                    exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
+        }
+
+        switch (result_number)
+        {
+            case token_type::value_integer:
+                return sax->number_integer(number_lexer.get_number_integer());
+            case token_type::value_unsigned:
+                return sax->number_unsigned(number_lexer.get_number_unsigned());
+            case token_type::value_float:
+                return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
+            case token_type::uninitialized:
+            case token_type::literal_true:
+            case token_type::literal_false:
+            case token_type::literal_null:
+            case token_type::value_string:
+            case token_type::begin_array:
+            case token_type::begin_object:
+            case token_type::end_array:
+            case token_type::end_object:
+            case token_type::name_separator:
+            case token_type::value_separator:
+            case token_type::parse_error:
+            case token_type::end_of_input:
+            case token_type::literal_or_value:
+            default:
+                return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read,
+                                        exception_message(input_format, concat("invalid number text: ", number_lexer.get_token_string()), "high-precision number"), nullptr));
+        }
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*!
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a -'ve valued
+    `char_traits<char_type>::eof()` in that case.
+
+    @return character read from the input
+    */
+    char_int_type get()
+    {
+        ++chars_read;
+        return current = ia.get_character();
+    }
+
+    /*!
+    @return character read from the input after ignoring all 'N' entries
+    */
+    char_int_type get_ignore_noop()
+    {
+        do
+        {
+            get();
+        }
+        while (current == 'N');
+
+        return current;
+    }
+
+    /*
+    @brief read a number from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format   the current format (for diagnostics)
+    @param[out] result  number of type @a NumberType
+
+    @return whether conversion completed
+
+    @note This function needs to respect the system's endianness, because
+          bytes in CBOR, MessagePack, and UBJSON are stored in network order
+          (big endian) and therefore need reordering on little endian systems.
+          On the other hand, BSON and BJData use little endian and should reorder
+          on big endian systems.
+    */
+    template<typename NumberType, bool InputIsLittleEndian = false>
+    bool get_number(const input_format_t format, NumberType& result)
+    {
+        // step 1: read input into array with system's byte order
+        std::array<std::uint8_t, sizeof(NumberType)> vec{};
+        for (std::size_t i = 0; i < sizeof(NumberType); ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
+            {
+                return false;
+            }
+
+            // reverse byte order prior to conversion if necessary
+            if (is_little_endian != (InputIsLittleEndian || format == input_format_t::bjdata))
+            {
+                vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
+            }
+            else
+            {
+                vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
+            }
+        }
+
+        // step 2: convert array into number of type T and return
+        std::memcpy(&result, vec.data(), sizeof(NumberType));
+        return true;
+    }
+
+    /*!
+    @brief create a string by reading characters from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of characters to read
+    @param[out] result string created by reading @a len bytes
+
+    @return whether string creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of string memory.
+    */
+    template<typename NumberType>
+    bool get_string(const input_format_t format,
+                    const NumberType len,
+                    string_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<typename string_t::value_type>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @brief create a byte array by reading bytes from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of bytes to read
+    @param[out] result byte array created by reading @a len bytes
+
+    @return whether byte array creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of memory.
+    */
+    template<typename NumberType>
+    bool get_binary(const input_format_t format,
+                    const NumberType len,
+                    binary_t& result)
+    {
+        bool success = true;
+        for (NumberType i = 0; i < len; i++)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
+            {
+                success = false;
+                break;
+            }
+            result.push_back(static_cast<std::uint8_t>(current));
+        }
+        return success;
+    }
+
+    /*!
+    @param[in] format   the current format (for diagnostics)
+    @param[in] context  further context information (for diagnostics)
+    @return whether the last read character is not EOF
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool unexpect_eof(const input_format_t format, const char* context) const
+    {
+        if (JSON_HEDLEY_UNLIKELY(current == char_traits<char_type>::eof()))
+        {
+            return sax->parse_error(chars_read, "<end of file>",
+                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context), nullptr));
+        }
+        return true;
+    }
+
+    /*!
+    @return a string representation of the last read byte
+    */
+    std::string get_token_string() const
+    {
+        std::array<char, 3> cr{{}};
+        static_cast<void>((std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current))); // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        return std::string{cr.data()};
+    }
+
+    /*!
+    @param[in] format   the current format
+    @param[in] detail   a detailed error message
+    @param[in] context  further context information
+    @return a message string to use in the parse_error exceptions
+    */
+    std::string exception_message(const input_format_t format,
+                                  const std::string& detail,
+                                  const std::string& context) const
+    {
+        std::string error_msg = "syntax error while parsing ";
+
+        switch (format)
+        {
+            case input_format_t::cbor:
+                error_msg += "CBOR";
+                break;
+
+            case input_format_t::msgpack:
+                error_msg += "MessagePack";
+                break;
+
+            case input_format_t::ubjson:
+                error_msg += "UBJSON";
+                break;
+
+            case input_format_t::bson:
+                error_msg += "BSON";
+                break;
+
+            case input_format_t::bjdata:
+                error_msg += "BJData";
+                break;
+
+            case input_format_t::json: // LCOV_EXCL_LINE
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+
+        return concat(error_msg, ' ', context, ": ", detail);
+    }
+
+  private:
+    static JSON_INLINE_VARIABLE constexpr std::size_t npos = static_cast<std::size_t>(-1);
+
+    /// input adapter
+    InputAdapterType ia;
+
+    /// the current character
+    char_int_type current = char_traits<char_type>::eof();
+
+    /// the number of characters read
+    std::size_t chars_read = 0;
+
+    /// whether we can assume little endianness
+    const bool is_little_endian = little_endianness();
+
+    /// input format
+    const input_format_t input_format = input_format_t::json;
+
+    /// the SAX parser
+    json_sax_t* sax = nullptr;
+
+    // excluded markers in bjdata optimized type
+#define JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_ \
+    make_array<char_int_type>('F', 'H', 'N', 'S', 'T', 'Z', '[', '{')
+
+#define JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_ \
+    make_array<bjd_type>(                      \
+    bjd_type{'C', "char"},                     \
+    bjd_type{'D', "double"},                   \
+    bjd_type{'I', "int16"},                    \
+    bjd_type{'L', "int64"},                    \
+    bjd_type{'M', "uint64"},                   \
+    bjd_type{'U', "uint8"},                    \
+    bjd_type{'d', "single"},                   \
+    bjd_type{'i', "int8"},                     \
+    bjd_type{'l', "int32"},                    \
+    bjd_type{'m', "uint32"},                   \
+    bjd_type{'u', "uint16"})
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // lookup tables
+    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
+    const decltype(JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_) bjd_optimized_type_markers =
+        JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_;
+
+    using bjd_type = std::pair<char_int_type, string_t>;
+    // NOLINTNEXTLINE(cppcoreguidelines-non-private-member-variables-in-classes)
+    const decltype(JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_) bjd_types_map =
+        JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_;
+
+#undef JSON_BINARY_READER_MAKE_BJD_OPTIMIZED_TYPE_MARKERS_
+#undef JSON_BINARY_READER_MAKE_BJD_TYPES_MAP_
+};
+
+#ifndef JSON_HAS_CPP_17
+    template<typename BasicJsonType, typename InputAdapterType, typename SAX>
+    constexpr std::size_t binary_reader<BasicJsonType, InputAdapterType, SAX>::npos;
+#endif
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/input/parser.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cmath> // isfinite
+#include <cstdint> // uint8_t
+#include <functional> // function
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+////////////
+// parser //
+////////////
+
+enum class parse_event_t : std::uint8_t
+{
+    /// the parser read `{` and started to process a JSON object
+    object_start,
+    /// the parser read `}` and finished processing a JSON object
+    object_end,
+    /// the parser read `[` and started to process a JSON array
+    array_start,
+    /// the parser read `]` and finished processing a JSON array
+    array_end,
+    /// the parser read a key of a value in an object
+    key,
+    /// the parser finished reading a JSON value
+    value
+};
+
+template<typename BasicJsonType>
+using parser_callback_t =
+    std::function<bool(int /*depth*/, parse_event_t /*event*/, BasicJsonType& /*parsed*/)>;
+
+/*!
+@brief syntax analysis
+
+This class implements a recursive descent parser.
+*/
+template<typename BasicJsonType, typename InputAdapterType>
+class parser
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using lexer_t = lexer<BasicJsonType, InputAdapterType>;
+    using token_type = typename lexer_t::token_type;
+
+  public:
+    /// a parser reading from an input adapter
+    explicit parser(InputAdapterType&& adapter,
+                    const parser_callback_t<BasicJsonType> cb = nullptr,
+                    const bool allow_exceptions_ = true,
+                    const bool skip_comments = false)
+        : callback(cb)
+        , m_lexer(std::move(adapter), skip_comments)
+        , allow_exceptions(allow_exceptions_)
+    {
+        // read first token
+        get_token();
+    }
+
+    /*!
+    @brief public parser interface
+
+    @param[in] strict      whether to expect the last token to be EOF
+    @param[in,out] result  parsed JSON value
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+    */
+    void parse(const bool strict, BasicJsonType& result)
+    {
+        if (callback)
+        {
+            json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
+            sax_parse_internal(&sdp);
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value"), nullptr));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+
+            // set top-level value to null if it was discarded by the callback
+            // function
+            if (result.is_discarded())
+            {
+                result = nullptr;
+            }
+        }
+        else
+        {
+            json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
+            sax_parse_internal(&sdp);
+
+            // in strict mode, input must be completely read
+            if (strict && (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+        }
+
+        result.assert_invariant();
+    }
+
+    /*!
+    @brief public accept interface
+
+    @param[in] strict  whether to expect the last token to be EOF
+    @return whether the input is a proper JSON text
+    */
+    bool accept(const bool strict = true)
+    {
+        json_sax_acceptor<BasicJsonType> sax_acceptor;
+        return sax_parse(&sax_acceptor, strict);
+    }
+
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse(SAX* sax, const bool strict = true)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+        const bool result = sax_parse_internal(sax);
+
+        // strict mode: next byte must be EOF
+        if (result && strict && (get_token() != token_type::end_of_input))
+        {
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
+        }
+
+        return result;
+    }
+
+  private:
+    template<typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse_internal(SAX* sax)
+    {
+        // stack to remember the hierarchy of structured values we are parsing
+        // true = array; false = object
+        std::vector<bool> states;
+        // value to avoid a goto (see comment where set to true)
+        bool skip_to_state_evaluation = false;
+
+        while (true)
+        {
+            if (!skip_to_state_evaluation)
+            {
+                // invariant: get_token() was called before each iteration
+                switch (last_token)
+                {
+                    case token_type::begin_object:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_object(static_cast<std::size_t>(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing } -> we are done
+                        if (get_token() == token_type::end_object)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // parse key
+                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        // parse separator (:)
+                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
+                        }
+
+                        // remember we are now inside an object
+                        states.push_back(false);
+
+                        // parse values
+                        get_token();
+                        continue;
+                    }
+
+                    case token_type::begin_array:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->start_array(static_cast<std::size_t>(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing ] -> we are done
+                        if (get_token() == token_type::end_array)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // remember we are now inside an array
+                        states.push_back(true);
+
+                        // parse values (no need to call get_token)
+                        continue;
+                    }
+
+                    case token_type::value_float:
+                    {
+                        const auto res = m_lexer.get_number_float();
+
+                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
+                        }
+
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        break;
+                    }
+
+                    case token_type::literal_false:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_null:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_true:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_integer:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_string:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_unsigned:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::parse_error:
+                    {
+                        // using "uninitialized" to avoid "expected" message
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr));
+                    }
+                    case token_type::end_of_input:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
+                        }
+
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
+                    }
+                    case token_type::uninitialized:
+                    case token_type::end_array:
+                    case token_type::end_object:
+                    case token_type::name_separator:
+                    case token_type::value_separator:
+                    case token_type::literal_or_value:
+                    default: // the last token was unexpected
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
+                    }
+                }
+            }
+            else
+            {
+                skip_to_state_evaluation = false;
+            }
+
+            // we reached this line after we successfully parsed a value
+            if (states.empty())
+            {
+                // empty stack: we reached the end of the hierarchy: done
+                return true;
+            }
+
+            if (states.back())  // array
+            {
+                // comma -> next value
+                if (get_token() == token_type::value_separator)
+                {
+                    // parse a new value
+                    get_token();
+                    continue;
+                }
+
+                // closing ]
+                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
+                {
+                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                    {
+                        return false;
+                    }
+
+                    // We are done with this array. Before we can parse a
+                    // new value, we need to evaluate the new state first.
+                    // By setting skip_to_state_evaluation to false, we
+                    // are effectively jumping to the beginning of this if.
+                    JSON_ASSERT(!states.empty());
+                    states.pop_back();
+                    skip_to_state_evaluation = true;
+                    continue;
+                }
+
+                return sax->parse_error(m_lexer.get_position(),
+                                        m_lexer.get_token_string(),
+                                        parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr));
+            }
+
+            // states.back() is false -> object
+
+            // comma -> next value
+            if (get_token() == token_type::value_separator)
+            {
+                // parse key
+                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
+                {
+                    return sax->parse_error(m_lexer.get_position(),
+                                            m_lexer.get_token_string(),
+                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
+                }
+
+                if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+                {
+                    return false;
+                }
+
+                // parse separator (:)
+                if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                {
+                    return sax->parse_error(m_lexer.get_position(),
+                                            m_lexer.get_token_string(),
+                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
+                }
+
+                // parse values
+                get_token();
+                continue;
+            }
+
+            // closing }
+            if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
+            {
+                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                {
+                    return false;
+                }
+
+                // We are done with this object. Before we can parse a
+                // new value, we need to evaluate the new state first.
+                // By setting skip_to_state_evaluation to false, we
+                // are effectively jumping to the beginning of this if.
+                JSON_ASSERT(!states.empty());
+                states.pop_back();
+                skip_to_state_evaluation = true;
+                continue;
+            }
+
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr));
+        }
+    }
+
+    /// get next token from lexer
+    token_type get_token()
+    {
+        return last_token = m_lexer.scan();
+    }
+
+    std::string exception_message(const token_type expected, const std::string& context)
+    {
+        std::string error_msg = "syntax error ";
+
+        if (!context.empty())
+        {
+            error_msg += concat("while parsing ", context, ' ');
+        }
+
+        error_msg += "- ";
+
+        if (last_token == token_type::parse_error)
+        {
+            error_msg += concat(m_lexer.get_error_message(), "; last read: '",
+                                m_lexer.get_token_string(), '\'');
+        }
+        else
+        {
+            error_msg += concat("unexpected ", lexer_t::token_type_name(last_token));
+        }
+
+        if (expected != token_type::uninitialized)
+        {
+            error_msg += concat("; expected ", lexer_t::token_type_name(expected));
+        }
+
+        return error_msg;
+    }
+
+  private:
+    /// callback function
+    const parser_callback_t<BasicJsonType> callback = nullptr;
+    /// the type of the last read token
+    token_type last_token = token_type::uninitialized;
+    /// the lexer
+    lexer_t m_lexer;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // ptrdiff_t
+#include <limits>  // numeric_limits
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*
+@brief an iterator for primitive JSON types
+
+This class models an iterator for primitive JSON types (boolean, number,
+string). It's only purpose is to allow the iterator/const_iterator classes
+to "iterate" over primitive values. Internally, the iterator is modeled by
+a `difference_type` variable. Value begin_value (`0`) models the begin,
+end_value (`1`) models past the end.
+*/
+class primitive_iterator_t
+{
+  private:
+    using difference_type = std::ptrdiff_t;
+    static constexpr difference_type begin_value = 0;
+    static constexpr difference_type end_value = begin_value + 1;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// iterator as signed integer type
+    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
+
+  public:
+    constexpr difference_type get_value() const noexcept
+    {
+        return m_it;
+    }
+
+    /// set iterator to a defined beginning
+    void set_begin() noexcept
+    {
+        m_it = begin_value;
+    }
+
+    /// set iterator to a defined past the end
+    void set_end() noexcept
+    {
+        m_it = end_value;
+    }
+
+    /// return whether the iterator can be dereferenced
+    constexpr bool is_begin() const noexcept
+    {
+        return m_it == begin_value;
+    }
+
+    /// return whether the iterator is at end
+    constexpr bool is_end() const noexcept
+    {
+        return m_it == end_value;
+    }
+
+    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it == rhs.m_it;
+    }
+
+    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it < rhs.m_it;
+    }
+
+    primitive_iterator_t operator+(difference_type n) noexcept
+    {
+        auto result = *this;
+        result += n;
+        return result;
+    }
+
+    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it - rhs.m_it;
+    }
+
+    primitive_iterator_t& operator++() noexcept
+    {
+        ++m_it;
+        return *this;
+    }
+
+    primitive_iterator_t operator++(int)& noexcept // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        ++m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator--() noexcept
+    {
+        --m_it;
+        return *this;
+    }
+
+    primitive_iterator_t operator--(int)& noexcept // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        --m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator+=(difference_type n) noexcept
+    {
+        m_it += n;
+        return *this;
+    }
+
+    primitive_iterator_t& operator-=(difference_type n) noexcept
+    {
+        m_it -= n;
+        return *this;
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief an iterator value
+
+@note This structure could easily be a union, but MSVC currently does not allow
+unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
+*/
+template<typename BasicJsonType> struct internal_iterator
+{
+    /// iterator for JSON objects
+    typename BasicJsonType::object_t::iterator object_iterator {};
+    /// iterator for JSON arrays
+    typename BasicJsonType::array_t::iterator array_iterator {};
+    /// generic iterator for all other types
+    primitive_iterator_t primitive_iterator {};
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/iter_impl.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
+#include <type_traits> // conditional, is_const, remove_const
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+// forward declare, to be able to friend it later on
+template<typename IteratorType> class iteration_proxy;
+template<typename IteratorType> class iteration_proxy_value;
+
+/*!
+@brief a template for a bidirectional iterator for the @ref basic_json class
+This class implements a both iterators (iterator and const_iterator) for the
+@ref basic_json class.
+@note An iterator is called *initialized* when a pointer to a JSON value has
+      been set (e.g., by a constructor or a copy assignment). If the iterator is
+      default-constructed, it is *uninitialized* and most methods are undefined.
+      **The library uses assertions to detect calls on uninitialized iterators.**
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
+       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
+*/
+template<typename BasicJsonType>
+class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+{
+    /// the iterator with BasicJsonType of different const-ness
+    using other_iter_impl = iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
+    /// allow basic_json to access private members
+    friend other_iter_impl;
+    friend BasicJsonType;
+    friend iteration_proxy<iter_impl>;
+    friend iteration_proxy_value<iter_impl>;
+
+    using object_t = typename BasicJsonType::object_t;
+    using array_t = typename BasicJsonType::array_t;
+    // make sure BasicJsonType is basic_json or const basic_json
+    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
+                  "iter_impl only accepts (const) basic_json");
+    // superficial check for the LegacyBidirectionalIterator named requirement
+    static_assert(std::is_base_of<std::bidirectional_iterator_tag, std::bidirectional_iterator_tag>::value
+                  &&  std::is_base_of<std::bidirectional_iterator_tag, typename std::iterator_traits<typename array_t::iterator>::iterator_category>::value,
+                  "basic_json iterator assumes array and object type iterators satisfy the LegacyBidirectionalIterator named requirement.");
+
+  public:
+    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
+    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
+    /// A user-defined iterator should provide publicly accessible typedefs named
+    /// iterator_category, value_type, difference_type, pointer, and reference.
+    /// Note that value_type is required to be non-const, even for constant iterators.
+    using iterator_category = std::bidirectional_iterator_tag;
+
+    /// the type of the values when the iterator is dereferenced
+    using value_type = typename BasicJsonType::value_type;
+    /// a type to represent differences between iterators
+    using difference_type = typename BasicJsonType::difference_type;
+    /// defines a pointer to the type iterated over (value_type)
+    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
+          typename BasicJsonType::const_pointer,
+          typename BasicJsonType::pointer>::type;
+    /// defines a reference to the type iterated over (value_type)
+    using reference =
+        typename std::conditional<std::is_const<BasicJsonType>::value,
+        typename BasicJsonType::const_reference,
+        typename BasicJsonType::reference>::type;
+
+    iter_impl() = default;
+    ~iter_impl() = default;
+    iter_impl(iter_impl&&) noexcept = default;
+    iter_impl& operator=(iter_impl&&) noexcept = default;
+
+    /*!
+    @brief constructor for a given JSON instance
+    @param[in] object  pointer to a JSON object for this iterator
+    @pre object != nullptr
+    @post The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    explicit iter_impl(pointer object) noexcept : m_object(object)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = typename object_t::iterator();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = typename array_t::iterator();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator = primitive_iterator_t();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @note The conventional copy constructor and copy assignment are implicitly
+          defined. Combined with the following converting constructor and
+          assignment, they support: (1) copy from iterator to iterator, (2)
+          copy from const iterator to const iterator, and (3) conversion from
+          iterator to const iterator. However conversion from const iterator
+          to iterator is not defined.
+    */
+
+    /*!
+    @brief const copy constructor
+    @param[in] other const iterator to copy from
+    @note This copy constructor had to be defined explicitly to circumvent a bug
+          occurring on msvc v19.0 compiler (VS 2015) debug build. For more
+          information refer to: https://github.com/nlohmann/json/issues/1608
+    */
+    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
+    {
+        if (&other != this)
+        {
+            m_object = other.m_object;
+            m_it = other.m_it;
+        }
+        return *this;
+    }
+
+    /*!
+    @brief converting constructor
+    @param[in] other  non-const iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other  non-const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept // NOLINT(cert-oop54-cpp)
+    {
+        m_object = other.m_object;
+        m_it = other.m_it;
+        return *this;
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief set the iterator to the first value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_begin() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_data.m_value.object->begin();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_data.m_value.array->begin();
+                break;
+            }
+
+            case value_t::null:
+            {
+                // set to end so begin()==end() is true: null is empty
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator.set_begin();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @brief set the iterator past the last value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_end() noexcept
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_data.m_value.object->end();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_data.m_value.array->end();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+        }
+    }
+
+  public:
+    /*!
+    @brief return a reference to the value pointed to by the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator*() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
+                return m_it.object_iterator->second;
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
+                return *m_it.array_iterator;
+            }
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief dereference the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    pointer operator->() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
+                return &(m_it.object_iterator->second);
+            }
+
+            case value_t::array:
+            {
+                JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
+                return &*m_it.array_iterator;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief post-increment (it++)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        ++(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-increment (++it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator++()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, 1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, 1);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                ++m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief post-decrement (it--)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator--(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        auto result = *this;
+        --(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-decrement (--it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator--()
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, -1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, -1);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                --m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief comparison: equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
+    bool operator==(const IterImpl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                return (m_it.object_iterator == other.m_it.object_iterator);
+
+            case value_t::array:
+                return (m_it.array_iterator == other.m_it.array_iterator);
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief comparison: not equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    template < typename IterImpl, detail::enable_if_t < (std::is_same<IterImpl, iter_impl>::value || std::is_same<IterImpl, other_iter_impl>::value), std::nullptr_t > = nullptr >
+    bool operator!=(const IterImpl& other) const
+    {
+        return !operator==(other);
+    }
+
+    /*!
+    @brief comparison: smaller
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers", m_object));
+        }
+
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators", m_object));
+
+            case value_t::array:
+                return (m_it.array_iterator < other.m_it.array_iterator);
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<=(const iter_impl& other) const
+    {
+        return !other.operator < (*this);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>(const iter_impl& other) const
+    {
+        return !operator<=(other);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>=(const iter_impl& other) const
+    {
+        return !operator<(other);
+    }
+
+    /*!
+    @brief add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator+=(difference_type i)
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, i);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                m_it.primitive_iterator += i;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator-=(difference_type i)
+    {
+        return operator+=(-i);
+    }
+
+    /*!
+    @brief add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator+(difference_type i) const
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief addition of distance and iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    friend iter_impl operator+(difference_type i, const iter_impl& it)
+    {
+        auto result = it;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator-(difference_type i) const
+    {
+        auto result = *this;
+        result -= i;
+        return result;
+    }
+
+    /*!
+    @brief return difference
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    difference_type operator-(const iter_impl& other) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators", m_object));
+
+            case value_t::array:
+                return m_it.array_iterator - other.m_it.array_iterator;
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                return m_it.primitive_iterator - other.m_it.primitive_iterator;
+        }
+    }
+
+    /*!
+    @brief access to successor
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator[](difference_type n) const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        switch (m_object->m_data.m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators", m_object));
+
+            case value_t::array:
+                return *std::next(m_it.array_iterator, n);
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
+            }
+        }
+    }
+
+    /*!
+    @brief return the key of an object iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    const typename object_t::key_type& key() const
+    {
+        JSON_ASSERT(m_object != nullptr);
+
+        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
+        {
+            return m_it.object_iterator->first;
+        }
+
+        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators", m_object));
+    }
+
+    /*!
+    @brief return the value of an iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference value() const
+    {
+        return operator*();
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /// associated JSON instance
+    pointer m_object = nullptr;
+    /// the actual iterator of the associated instance
+    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <cstddef> // ptrdiff_t
+#include <iterator> // reverse_iterator
+#include <utility> // declval
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+//////////////////////
+// reverse_iterator //
+//////////////////////
+
+/*!
+@brief a template for a reverse iterator class
+
+@tparam Base the base iterator type to reverse. Valid types are @ref
+iterator (to create @ref reverse_iterator) and @ref const_iterator (to
+create @ref const_reverse_iterator).
+
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
+  It is possible to write to the pointed-to element (only if @a Base is
+  @ref iterator).
+
+@since version 1.0.0
+*/
+template<typename Base>
+class json_reverse_iterator : public std::reverse_iterator<Base>
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    /// shortcut to the reverse iterator adapter
+    using base_iterator = std::reverse_iterator<Base>;
+    /// the reference type for the pointed-to element
+    using reference = typename Base::reference;
+
+    /// create reverse iterator from iterator
+    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
+        : base_iterator(it) {}
+
+    /// create reverse iterator from base class
+    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
+
+    /// post-increment (it++)
+    json_reverse_iterator operator++(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
+    }
+
+    /// pre-increment (++it)
+    json_reverse_iterator& operator++()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
+    }
+
+    /// post-decrement (it--)
+    json_reverse_iterator operator--(int)& // NOLINT(cert-dcl21-cpp)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
+    }
+
+    /// pre-decrement (--it)
+    json_reverse_iterator& operator--()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
+    }
+
+    /// add to iterator
+    json_reverse_iterator& operator+=(difference_type i)
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
+    }
+
+    /// add to iterator
+    json_reverse_iterator operator+(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
+    }
+
+    /// subtract from iterator
+    json_reverse_iterator operator-(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
+    }
+
+    /// return difference
+    difference_type operator-(const json_reverse_iterator& other) const
+    {
+        return base_iterator(*this) - base_iterator(other);
+    }
+
+    /// access to successor
+    reference operator[](difference_type n) const
+    {
+        return *(this->operator+(n));
+    }
+
+    /// return the key of an object iterator
+    auto key() const -> decltype(std::declval<Base>().key())
+    {
+        auto it = --this->base();
+        return it.key();
+    }
+
+    /// return the value of an iterator
+    reference value() const
+    {
+        auto it = --this->base();
+        return it.operator * ();
+    }
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/json_custom_base_class.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <type_traits> // conditional, is_same
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief Default base class of the @ref basic_json class.
+
+So that the correct implementations of the copy / move ctors / assign operators
+of @ref basic_json do not require complex case distinctions
+(no base class / custom base class used as customization point),
+@ref basic_json always has a base class.
+By default, this class is used because it is empty and thus has no effect
+on the behavior of @ref basic_json.
+*/
+struct json_default_base {};
+
+template<class T>
+using json_base_class = typename std::conditional <
+                        std::is_same<T, void>::value,
+                        json_default_base,
+                        T
+                        >::type;
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/json_pointer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // all_of
+#include <cctype> // isdigit
+#include <cerrno> // errno, ERANGE
+#include <cstdlib> // strtoull
+#ifndef JSON_NO_IO
+    #include <iosfwd> // ostream
+#endif  // JSON_NO_IO
+#include <limits> // max
+#include <numeric> // accumulate
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/string_escape.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+/// @sa https://json.nlohmann.me/api/json_pointer/
+template<typename RefStringType>
+class json_pointer
+{
+    // allow basic_json to access private members
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    friend class basic_json;
+
+    template<typename>
+    friend class json_pointer;
+
+    template<typename T>
+    struct string_t_helper
+    {
+        using type = T;
+    };
+
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    struct string_t_helper<NLOHMANN_BASIC_JSON_TPL>
+    {
+        using type = StringType;
+    };
+
+  public:
+    // for backwards compatibility accept BasicJsonType
+    using string_t = typename string_t_helper<RefStringType>::type;
+
+    /// @brief create JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/json_pointer/
+    explicit json_pointer(const string_t& s = "")
+        : reference_tokens(split(s))
+    {}
+
+    /// @brief return a string representation of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
+    string_t to_string() const
+    {
+        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
+                               string_t{},
+                               [](const string_t& a, const string_t& b)
+        {
+            return detail::concat(a, '/', detail::escape(b));
+        });
+    }
+
+    /// @brief return a string representation of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
+    operator string_t() const
+    {
+        return to_string();
+    }
+
+#ifndef JSON_NO_IO
+    /// @brief write string representation of the JSON pointer to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    friend std::ostream& operator<<(std::ostream& o, const json_pointer& ptr)
+    {
+        o << ptr.to_string();
+        return o;
+    }
+#endif
+
+    /// @brief append another JSON pointer at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(const json_pointer& ptr)
+    {
+        reference_tokens.insert(reference_tokens.end(),
+                                ptr.reference_tokens.begin(),
+                                ptr.reference_tokens.end());
+        return *this;
+    }
+
+    /// @brief append an unescaped reference token at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(string_t token)
+    {
+        push_back(std::move(token));
+        return *this;
+    }
+
+    /// @brief append an array index at the end of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slasheq/
+    json_pointer& operator/=(std::size_t array_idx)
+    {
+        return *this /= std::to_string(array_idx);
+    }
+
+    /// @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs,
+                                  const json_pointer& rhs)
+    {
+        return json_pointer(lhs) /= rhs;
+    }
+
+    /// @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs, string_t token) // NOLINT(performance-unnecessary-value-param)
+    {
+        return json_pointer(lhs) /= std::move(token);
+    }
+
+    /// @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_slash/
+    friend json_pointer operator/(const json_pointer& lhs, std::size_t array_idx)
+    {
+        return json_pointer(lhs) /= array_idx;
+    }
+
+    /// @brief returns the parent of this JSON pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/parent_pointer/
+    json_pointer parent_pointer() const
+    {
+        if (empty())
+        {
+            return *this;
+        }
+
+        json_pointer res = *this;
+        res.pop_back();
+        return res;
+    }
+
+    /// @brief remove last reference token
+    /// @sa https://json.nlohmann.me/api/json_pointer/pop_back/
+    void pop_back()
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        reference_tokens.pop_back();
+    }
+
+    /// @brief return last reference token
+    /// @sa https://json.nlohmann.me/api/json_pointer/back/
+    const string_t& back() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        return reference_tokens.back();
+    }
+
+    /// @brief append an unescaped token at the end of the reference pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
+    void push_back(const string_t& token)
+    {
+        reference_tokens.push_back(token);
+    }
+
+    /// @brief append an unescaped token at the end of the reference pointer
+    /// @sa https://json.nlohmann.me/api/json_pointer/push_back/
+    void push_back(string_t&& token)
+    {
+        reference_tokens.push_back(std::move(token));
+    }
+
+    /// @brief return whether pointer points to the root document
+    /// @sa https://json.nlohmann.me/api/json_pointer/empty/
+    bool empty() const noexcept
+    {
+        return reference_tokens.empty();
+    }
+
+  private:
+    /*!
+    @param[in] s  reference token to be converted into an array index
+
+    @return integer representation of @a s
+
+    @throw parse_error.106  if an array index begins with '0'
+    @throw parse_error.109  if an array index begins not with a digit
+    @throw out_of_range.404 if string @a s could not be converted to an integer
+    @throw out_of_range.410 if an array index exceeds size_type
+    */
+    template<typename BasicJsonType>
+    static typename BasicJsonType::size_type array_index(const string_t& s)
+    {
+        using size_type = typename BasicJsonType::size_type;
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
+        {
+            JSON_THROW(detail::parse_error::create(106, 0, detail::concat("array index '", s, "' must not begin with '0'"), nullptr));
+        }
+
+        // error condition (cf. RFC 6901, Sect. 4)
+        if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
+        {
+            JSON_THROW(detail::parse_error::create(109, 0, detail::concat("array index '", s, "' is not a number"), nullptr));
+        }
+
+        const char* p = s.c_str();
+        char* p_end = nullptr;
+        errno = 0; // strtoull doesn't reset errno
+        const unsigned long long res = std::strtoull(p, &p_end, 10); // NOLINT(runtime/int)
+        if (p == p_end // invalid input or empty string
+                || errno == ERANGE // out of range
+                || JSON_HEDLEY_UNLIKELY(static_cast<std::size_t>(p_end - p) != s.size())) // incomplete read
+        {
+            JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", s, "'"), nullptr));
+        }
+
+        // only triggered on special platforms (like 32bit), see also
+        // https://github.com/nlohmann/json/pull/2203
+        if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))  // NOLINT(runtime/int)
+        {
+            JSON_THROW(detail::out_of_range::create(410, detail::concat("array index ", s, " exceeds size_type"), nullptr));   // LCOV_EXCL_LINE
+        }
+
+        return static_cast<size_type>(res);
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    json_pointer top() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent", nullptr));
+        }
+
+        json_pointer result = *this;
+        result.reference_tokens = {reference_tokens[0]};
+        return result;
+    }
+
+  private:
+    /*!
+    @brief create and return a reference to the pointed to value
+
+    @complexity Linear in the number of reference tokens.
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.313 if value cannot be unflattened
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_and_create(BasicJsonType& j) const
+    {
+        auto* result = &j;
+
+        // in case no reference tokens exist, return a reference to the JSON value
+        // j which will be overwritten by a primitive value
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (result->type())
+            {
+                case detail::value_t::null:
+                {
+                    if (reference_token == "0")
+                    {
+                        // start a new array if reference token is 0
+                        result = &result->operator[](0);
+                    }
+                    else
+                    {
+                        // start a new object otherwise
+                        result = &result->operator[](reference_token);
+                    }
+                    break;
+                }
+
+                case detail::value_t::object:
+                {
+                    // create an entry in the object
+                    result = &result->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    // create an entry in the array
+                    result = &result->operator[](array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                /*
+                The following code is only reached if there exists a reference
+                token _and_ the current value is primitive. In this case, we have
+                an error situation, because primitive values may only occur as
+                single value; that is, with an empty list of reference tokens.
+                */
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten", &j));
+            }
+        }
+
+        return *result;
+    }
+
+    /*!
+    @brief return a reference to the pointed to value
+
+    @note This version does not throw if a value is not present, but tries to
+          create nested values instead. For instance, calling this function
+          with pointer `"/this/that"` on a null value is equivalent to calling
+          `operator[]("this").operator[]("that")` on that value, effectively
+          changing the null value to an object.
+
+    @param[in] ptr  a JSON value
+
+    @return reference to the JSON value pointed to by the JSON pointer
+
+    @complexity Linear in the length of the JSON pointer.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            // convert null values to arrays or objects before continuing
+            if (ptr->is_null())
+            {
+                // check if reference token is a number
+                const bool nums =
+                    std::all_of(reference_token.begin(), reference_token.end(),
+                                [](const unsigned char x)
+                {
+                    return std::isdigit(x);
+                });
+
+                // change value to array for numbers or "-" or to object otherwise
+                *ptr = (nums || reference_token == "-")
+                       ? detail::value_t::array
+                       : detail::value_t::object;
+            }
+
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (reference_token == "-")
+                    {
+                        // explicitly treat "-" as index beyond the end
+                        ptr = &ptr->operator[](ptr->m_data.m_value.array->size());
+                    }
+                    else
+                    {
+                        // convert array index to number; unchecked access
+                        ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
+                    }
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    BasicJsonType& get_checked(BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
+                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
+                                ") is out of range"), ptr));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @brief return a const reference to the pointed to value
+
+    @param[in] ptr  a JSON value
+
+    @return const reference to the JSON value pointed to by the JSON
+    pointer
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" cannot be used for const access
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat("array index '-' (", std::to_string(ptr->m_data.m_value.array->size()), ") is out of range"), ptr));
+                    }
+
+                    // use unchecked array access
+                    ptr = &ptr->operator[](array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    template<typename BasicJsonType>
+    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402, detail::concat(
+                                "array index '-' (", std::to_string(ptr->m_data.m_value.array->size()),
+                                ") is out of range"), ptr));
+                    }
+
+                    // note: at performs range check
+                    ptr = &ptr->at(array_index<BasicJsonType>(reference_token));
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, detail::concat("unresolved reference token '", reference_token, "'"), ptr));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    */
+    template<typename BasicJsonType>
+    bool contains(const BasicJsonType* ptr) const
+    {
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    if (!ptr->contains(reference_token))
+                    {
+                        // we did not find the key in the object
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
+                    {
+                        // invalid char
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
+                        {
+                            // first char should be between '1' and '9'
+                            return false;
+                        }
+                        for (std::size_t i = 1; i < reference_token.size(); i++)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
+                            {
+                                // other char should be between '0' and '9'
+                                return false;
+                            }
+                        }
+                    }
+
+                    const auto idx = array_index<BasicJsonType>(reference_token);
+                    if (idx >= ptr->size())
+                    {
+                        // index out of range
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](idx);
+                    break;
+                }
+
+                case detail::value_t::null:
+                case detail::value_t::string:
+                case detail::value_t::boolean:
+                case detail::value_t::number_integer:
+                case detail::value_t::number_unsigned:
+                case detail::value_t::number_float:
+                case detail::value_t::binary:
+                case detail::value_t::discarded:
+                default:
+                {
+                    // we do not expect primitive values if there is still a
+                    // reference token to process
+                    return false;
+                }
+            }
+        }
+
+        // no reference token left means we found a primitive value
+        return true;
+    }
+
+    /*!
+    @brief split the string input to reference tokens
+
+    @note This function is only called by the json_pointer constructor.
+          All exceptions below are documented there.
+
+    @throw parse_error.107  if the pointer is not empty or begins with '/'
+    @throw parse_error.108  if character '~' is not followed by '0' or '1'
+    */
+    static std::vector<string_t> split(const string_t& reference_string)
+    {
+        std::vector<string_t> result;
+
+        // special case: empty reference string -> no reference tokens
+        if (reference_string.empty())
+        {
+            return result;
+        }
+
+        // check if nonempty reference string begins with slash
+        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
+        {
+            JSON_THROW(detail::parse_error::create(107, 1, detail::concat("JSON pointer must be empty or begin with '/' - was: '", reference_string, "'"), nullptr));
+        }
+
+        // extract the reference tokens:
+        // - slash: position of the last read slash (or end of string)
+        // - start: position after the previous slash
+        for (
+            // search for the first slash after the first character
+            std::size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == 0 (if slash == string_t::npos)
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == string_t::npos)
+            start = (slash == string_t::npos) ? 0 : slash + 1,
+            // find next slash
+            slash = reference_string.find_first_of('/', start))
+        {
+            // use the text between the beginning of the reference token
+            // (start) and the last slash (slash).
+            auto reference_token = reference_string.substr(start, slash - start);
+
+            // check reference tokens are properly escaped
+            for (std::size_t pos = reference_token.find_first_of('~');
+                    pos != string_t::npos;
+                    pos = reference_token.find_first_of('~', pos + 1))
+            {
+                JSON_ASSERT(reference_token[pos] == '~');
+
+                // ~ must be followed by 0 or 1
+                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
+                                         (reference_token[pos + 1] != '0' &&
+                                          reference_token[pos + 1] != '1')))
+                {
+                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'", nullptr));
+                }
+            }
+
+            // finally, store the reference token
+            detail::unescape(reference_token);
+            result.push_back(reference_token);
+        }
+
+        return result;
+    }
+
+  private:
+    /*!
+    @param[in] reference_string  the reference string to the current value
+    @param[in] value             the value to consider
+    @param[in,out] result        the result object to insert values to
+
+    @note Empty objects or arrays are flattened to `null`.
+    */
+    template<typename BasicJsonType>
+    static void flatten(const string_t& reference_string,
+                        const BasicJsonType& value,
+                        BasicJsonType& result)
+    {
+        switch (value.type())
+        {
+            case detail::value_t::array:
+            {
+                if (value.m_data.m_value.array->empty())
+                {
+                    // flatten empty array as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate array and use index as reference string
+                    for (std::size_t i = 0; i < value.m_data.m_value.array->size(); ++i)
+                    {
+                        flatten(detail::concat(reference_string, '/', std::to_string(i)),
+                                value.m_data.m_value.array->operator[](i), result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::object:
+            {
+                if (value.m_data.m_value.object->empty())
+                {
+                    // flatten empty object as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate object and use keys as reference string
+                    for (const auto& element : *value.m_data.m_value.object)
+                    {
+                        flatten(detail::concat(reference_string, '/', detail::escape(element.first)), element.second, result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::null:
+            case detail::value_t::string:
+            case detail::value_t::boolean:
+            case detail::value_t::number_integer:
+            case detail::value_t::number_unsigned:
+            case detail::value_t::number_float:
+            case detail::value_t::binary:
+            case detail::value_t::discarded:
+            default:
+            {
+                // add primitive value with its reference string
+                result[reference_string] = value;
+                break;
+            }
+        }
+    }
+
+    /*!
+    @param[in] value  flattened JSON
+
+    @return unflattened JSON
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+    @throw type_error.313  if value cannot be unflattened
+    */
+    template<typename BasicJsonType>
+    static BasicJsonType
+    unflatten(const BasicJsonType& value)
+    {
+        if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
+        {
+            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened", &value));
+        }
+
+        BasicJsonType result;
+
+        // iterate the JSON object values
+        for (const auto& element : *value.m_data.m_value.object)
+        {
+            if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
+            {
+                JSON_THROW(detail::type_error::create(315, "values in object must be primitive", &element.second));
+            }
+
+            // assign value to reference pointed to by JSON pointer; Note that if
+            // the JSON pointer is "" (i.e., points to the whole value), function
+            // get_and_create returns a reference to result itself. An assignment
+            // will then create a primitive value.
+            json_pointer(element.first).get_and_create(result) = element.second;
+        }
+
+        return result;
+    }
+
+    // can't use conversion operator because of ambiguity
+    json_pointer<string_t> convert() const&
+    {
+        json_pointer<string_t> result;
+        result.reference_tokens = reference_tokens;
+        return result;
+    }
+
+    json_pointer<string_t> convert()&&
+    {
+        json_pointer<string_t> result;
+        result.reference_tokens = std::move(reference_tokens);
+        return result;
+    }
+
+  public:
+#if JSON_HAS_THREE_WAY_COMPARISON
+    /// @brief compares two JSON pointers for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeRhs>
+    bool operator==(const json_pointer<RefStringTypeRhs>& rhs) const noexcept
+    {
+        return reference_tokens == rhs.reference_tokens;
+    }
+
+    /// @brief compares JSON pointer and string for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
+    bool operator==(const string_t& rhs) const
+    {
+        return *this == json_pointer(rhs);
+    }
+
+    /// @brief 3-way compares two JSON pointers
+    template<typename RefStringTypeRhs>
+    std::strong_ordering operator<=>(const json_pointer<RefStringTypeRhs>& rhs) const noexcept // *NOPAD*
+    {
+        return  reference_tokens <=> rhs.reference_tokens; // *NOPAD*
+    }
+#else
+    /// @brief compares two JSON pointers for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+
+    /// @brief compares JSON pointer and string for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeLhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                           const StringType& rhs);
+
+    /// @brief compares string and JSON pointer for equality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
+    template<typename RefStringTypeRhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator==(const StringType& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs);
+
+    /// @brief compares two JSON pointers for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+
+    /// @brief compares JSON pointer and string for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeLhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                           const StringType& rhs);
+
+    /// @brief compares string and JSON pointer for inequality
+    /// @sa https://json.nlohmann.me/api/json_pointer/operator_ne/
+    template<typename RefStringTypeRhs, typename StringType>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator!=(const StringType& lhs,
+                           const json_pointer<RefStringTypeRhs>& rhs);
+
+    /// @brief compares two JSON pointer for less-than
+    template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+    // NOLINTNEXTLINE(readability-redundant-declaration)
+    friend bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
+                          const json_pointer<RefStringTypeRhs>& rhs) noexcept;
+#endif
+
+  private:
+    /// the reference tokens
+    std::vector<string_t> reference_tokens;
+};
+
+#if !JSON_HAS_THREE_WAY_COMPARISON
+// functions cannot be defined inside class due to ODR violations
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return lhs.reference_tokens == rhs.reference_tokens;
+}
+
+template<typename RefStringTypeLhs,
+         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
+inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
+                       const StringType& rhs)
+{
+    return lhs == json_pointer<RefStringTypeLhs>(rhs);
+}
+
+template<typename RefStringTypeRhs,
+         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
+inline bool operator==(const StringType& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs)
+{
+    return json_pointer<RefStringTypeRhs>(lhs) == rhs;
+}
+
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeLhs,
+         typename StringType = typename json_pointer<RefStringTypeLhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
+inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
+                       const StringType& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeRhs,
+         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
+JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
+inline bool operator!=(const StringType& lhs,
+                       const json_pointer<RefStringTypeRhs>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<typename RefStringTypeLhs, typename RefStringTypeRhs>
+inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
+                      const json_pointer<RefStringTypeRhs>& rhs) noexcept
+{
+    return lhs.reference_tokens < rhs.reference_tokens;
+}
+#endif
+
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/json_ref.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <initializer_list>
+#include <utility>
+
+// #include <nlohmann/detail/abi_macros.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+template<typename BasicJsonType>
+class json_ref
+{
+  public:
+    using value_type = BasicJsonType;
+
+    json_ref(value_type&& value)
+        : owned_value(std::move(value))
+    {}
+
+    json_ref(const value_type& value)
+        : value_ref(&value)
+    {}
+
+    json_ref(std::initializer_list<json_ref> init)
+        : owned_value(init)
+    {}
+
+    template <
+        class... Args,
+        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
+    json_ref(Args && ... args)
+        : owned_value(std::forward<Args>(args)...)
+    {}
+
+    // class should be movable only
+    json_ref(json_ref&&) noexcept = default;
+    json_ref(const json_ref&) = delete;
+    json_ref& operator=(const json_ref&) = delete;
+    json_ref& operator=(json_ref&&) = delete;
+    ~json_ref() = default;
+
+    value_type moved_or_copied() const
+    {
+        if (value_ref == nullptr)
+        {
+            return std::move(owned_value);
+        }
+        return *value_ref;
+    }
+
+    value_type const& operator*() const
+    {
+        return value_ref ? *value_ref : owned_value;
+    }
+
+    value_type const* operator->() const
+    {
+        return &** this;
+    }
+
+  private:
+    mutable value_type owned_value = nullptr;
+    value_type const* value_ref = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/string_escape.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // reverse
+#include <array> // array
+#include <map> // map
+#include <cmath> // isnan, isinf
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstring> // memcpy
+#include <limits> // numeric_limits
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // copy
+#include <cstddef> // size_t
+#include <iterator> // back_inserter
+#include <memory> // shared_ptr, make_shared
+#include <string> // basic_string
+#include <vector> // vector
+
+#ifndef JSON_NO_IO
+    #include <ios>      // streamsize
+    #include <ostream>  // basic_ostream
+#endif  // JSON_NO_IO
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/// abstract output adapter interface
+template<typename CharType> struct output_adapter_protocol
+{
+    virtual void write_character(CharType c) = 0;
+    virtual void write_characters(const CharType* s, std::size_t length) = 0;
+    virtual ~output_adapter_protocol() = default;
+
+    output_adapter_protocol() = default;
+    output_adapter_protocol(const output_adapter_protocol&) = default;
+    output_adapter_protocol(output_adapter_protocol&&) noexcept = default;
+    output_adapter_protocol& operator=(const output_adapter_protocol&) = default;
+    output_adapter_protocol& operator=(output_adapter_protocol&&) noexcept = default;
+};
+
+/// a type to simplify interfaces
+template<typename CharType>
+using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
+
+/// output adapter for byte vectors
+template<typename CharType, typename AllocatorType = std::allocator<CharType>>
+class output_vector_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
+        : v(vec)
+    {}
+
+    void write_character(CharType c) override
+    {
+        v.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        v.insert(v.end(), s, s + length);
+    }
+
+  private:
+    std::vector<CharType, AllocatorType>& v;
+};
+
+#ifndef JSON_NO_IO
+/// output adapter for output streams
+template<typename CharType>
+class output_stream_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
+        : stream(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        stream.put(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        stream.write(s, static_cast<std::streamsize>(length));
+    }
+
+  private:
+    std::basic_ostream<CharType>& stream;
+};
+#endif  // JSON_NO_IO
+
+/// output adapter for basic_string
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_string_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_string_adapter(StringType& s) noexcept
+        : str(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        str.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        str.append(s, length);
+    }
+
+  private:
+    StringType& str;
+};
+
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_adapter
+{
+  public:
+    template<typename AllocatorType = std::allocator<CharType>>
+    output_adapter(std::vector<CharType, AllocatorType>& vec)
+        : oa(std::make_shared<output_vector_adapter<CharType, AllocatorType>>(vec)) {}
+
+#ifndef JSON_NO_IO
+    output_adapter(std::basic_ostream<CharType>& s)
+        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
+#endif  // JSON_NO_IO
+
+    output_adapter(StringType& s)
+        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
+
+    operator output_adapter_t<CharType>()
+    {
+        return oa;
+    }
+
+  private:
+    output_adapter_t<CharType> oa = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////////////
+// binary writer //
+///////////////////
+
+/*!
+@brief serialization to CBOR and MessagePack values
+*/
+template<typename BasicJsonType, typename CharType>
+class binary_writer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using binary_t = typename BasicJsonType::binary_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+
+  public:
+    /*!
+    @brief create a binary writer
+
+    @param[in] adapter  output adapter to write to
+    */
+    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(std::move(adapter))
+    {
+        JSON_ASSERT(oa);
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+            {
+                write_bson_object(*j.m_data.m_value.object);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::array:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                JSON_THROW(type_error::create(317, concat("to serialize to BSON, top-level type must be object, but is ", j.type_name()), &j));
+            }
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_cbor(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                oa->write_character(to_char_type(0xF6));
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                oa->write_character(j.m_data.m_value.boolean
+                                    ? to_char_type(0xF5)
+                                    : to_char_type(0xF4));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers. Therefore, we used the
+                    // code from the value_t::number_unsigned case here.
+                    if (j.m_data.m_value.number_integer <= 0x17)
+                    {
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x18));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x19));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x1A));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x1B));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    // The conversions below encode the sign in the first
+                    // byte, and the value is converted to a positive number.
+                    const auto positive_number = -1 - j.m_data.m_value.number_integer;
+                    if (j.m_data.m_value.number_integer >= -24)
+                    {
+                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x38));
+                        write_number(static_cast<std::uint8_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x39));
+                        write_number(static_cast<std::uint16_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x3A));
+                        write_number(static_cast<std::uint32_t>(positive_number));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x3B));
+                        write_number(static_cast<std::uint64_t>(positive_number));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x18));
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x19));
+                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_unsigned));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x1A));
+                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_unsigned));
+                }
+                else
+                {
+                    oa->write_character(to_char_type(0x1B));
+                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_unsigned));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                if (std::isnan(j.m_data.m_value.number_float))
+                {
+                    // NaN is 0xf97e00 in CBOR
+                    oa->write_character(to_char_type(0xF9));
+                    oa->write_character(to_char_type(0x7E));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else if (std::isinf(j.m_data.m_value.number_float))
+                {
+                    // Infinity is 0xf97c00, -Infinity is 0xf9fc00
+                    oa->write_character(to_char_type(0xf9));
+                    oa->write_character(j.m_data.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
+                    oa->write_character(to_char_type(0x00));
+                }
+                else
+                {
+                    write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::cbor);
+                }
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_data.m_value.string->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x60 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x78));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x79));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_data.m_value.array->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x80 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x98));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x99));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_cbor(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (j.m_data.m_value.binary->has_subtype())
+                {
+                    if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xd8));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xd9));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xda));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                    else if (j.m_data.m_value.binary->subtype() <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        write_number(static_cast<std::uint8_t>(0xdb));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.binary->subtype()));
+                    }
+                }
+
+                // step 1: write control byte and the binary array size
+                const auto N = j.m_data.m_value.binary->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x40 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x58));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x59));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x5B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_data.m_value.object->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0xA0 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB8));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB9));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBA));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBB));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_cbor(el.first);
+                    write_cbor(el.second);
+                }
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_msgpack(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null: // nil
+            {
+                oa->write_character(to_char_type(0xC0));
+                break;
+            }
+
+            case value_t::boolean: // true and false
+            {
+                oa->write_character(j.m_data.m_value.boolean
+                                    ? to_char_type(0xC3)
+                                    : to_char_type(0xC2));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_data.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers. Therefore, we used
+                    // the code from the value_t::number_unsigned case here.
+                    if (j.m_data.m_value.number_unsigned < 128)
+                    {
+                        // positive fixnum
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        // uint 8
+                        oa->write_character(to_char_type(0xCC));
+                        write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        // uint 16
+                        oa->write_character(to_char_type(0xCD));
+                        write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        // uint 32
+                        oa->write_character(to_char_type(0xCE));
+                        write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        // uint 64
+                        oa->write_character(to_char_type(0xCF));
+                        write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    if (j.m_data.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                    {
+                        // int 8
+                        oa->write_character(to_char_type(0xD0));
+                        write_number(static_cast<std::int8_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                    {
+                        // int 16
+                        oa->write_character(to_char_type(0xD1));
+                        write_number(static_cast<std::int16_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                    {
+                        // int 32
+                        oa->write_character(to_char_type(0xD2));
+                        write_number(static_cast<std::int32_t>(j.m_data.m_value.number_integer));
+                    }
+                    else if (j.m_data.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
+                             j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                    {
+                        // int 64
+                        oa->write_character(to_char_type(0xD3));
+                        write_number(static_cast<std::int64_t>(j.m_data.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned < 128)
+                {
+                    // positive fixnum
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // uint 8
+                    oa->write_character(to_char_type(0xCC));
+                    write_number(static_cast<std::uint8_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // uint 16
+                    oa->write_character(to_char_type(0xCD));
+                    write_number(static_cast<std::uint16_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // uint 32
+                    oa->write_character(to_char_type(0xCE));
+                    write_number(static_cast<std::uint32_t>(j.m_data.m_value.number_integer));
+                }
+                else if (j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    // uint 64
+                    oa->write_character(to_char_type(0xCF));
+                    write_number(static_cast<std::uint64_t>(j.m_data.m_value.number_integer));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_compact_float(j.m_data.m_value.number_float, detail::input_format_t::msgpack);
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_data.m_value.string->size();
+                if (N <= 31)
+                {
+                    // fixstr
+                    write_number(static_cast<std::uint8_t>(0xA0 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // str 8
+                    oa->write_character(to_char_type(0xD9));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // str 16
+                    oa->write_character(to_char_type(0xDA));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // str 32
+                    oa->write_character(to_char_type(0xDB));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_data.m_value.array->size();
+                if (N <= 15)
+                {
+                    // fixarray
+                    write_number(static_cast<std::uint8_t>(0x90 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // array 16
+                    oa->write_character(to_char_type(0xDC));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // array 32
+                    oa->write_character(to_char_type(0xDD));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_msgpack(el);
+                }
+                break;
+            }
+
+            case value_t::binary:
+            {
+                // step 0: determine if the binary type has a set subtype to
+                // determine whether or not to use the ext or fixext types
+                const bool use_ext = j.m_data.m_value.binary->has_subtype();
+
+                // step 1: write control byte and the byte string length
+                const auto N = j.m_data.m_value.binary->size();
+                if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    std::uint8_t output_type{};
+                    bool fixed = true;
+                    if (use_ext)
+                    {
+                        switch (N)
+                        {
+                            case 1:
+                                output_type = 0xD4; // fixext 1
+                                break;
+                            case 2:
+                                output_type = 0xD5; // fixext 2
+                                break;
+                            case 4:
+                                output_type = 0xD6; // fixext 4
+                                break;
+                            case 8:
+                                output_type = 0xD7; // fixext 8
+                                break;
+                            case 16:
+                                output_type = 0xD8; // fixext 16
+                                break;
+                            default:
+                                output_type = 0xC7; // ext 8
+                                fixed = false;
+                                break;
+                        }
+
+                    }
+                    else
+                    {
+                        output_type = 0xC4; // bin 8
+                        fixed = false;
+                    }
+
+                    oa->write_character(to_char_type(output_type));
+                    if (!fixed)
+                    {
+                        write_number(static_cast<std::uint8_t>(N));
+                    }
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    const std::uint8_t output_type = use_ext
+                                                     ? 0xC8 // ext 16
+                                                     : 0xC5; // bin 16
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    const std::uint8_t output_type = use_ext
+                                                     ? 0xC9 // ext 32
+                                                     : 0xC6; // bin 32
+
+                    oa->write_character(to_char_type(output_type));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 1.5: if this is an ext type, write the subtype
+                if (use_ext)
+                {
+                    write_number(static_cast<std::int8_t>(j.m_data.m_value.binary->subtype()));
+                }
+
+                // step 2: write the byte string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                    N);
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_data.m_value.object->size();
+                if (N <= 15)
+                {
+                    // fixmap
+                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // map 16
+                    oa->write_character(to_char_type(0xDE));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // map 32
+                    oa->write_character(to_char_type(0xDF));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_msgpack(el.first);
+                    write_msgpack(el.second);
+                }
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @param[in] use_count   whether to use '#' prefixes (optimized format)
+    @param[in] use_type    whether to use '$' prefixes (optimized format)
+    @param[in] add_prefix  whether prefixes need to be used for this value
+    @param[in] use_bjdata  whether write in BJData format, default is false
+    */
+    void write_ubjson(const BasicJsonType& j, const bool use_count,
+                      const bool use_type, const bool add_prefix = true,
+                      const bool use_bjdata = false)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('Z'));
+                }
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(j.m_data.m_value.boolean
+                                        ? to_char_type('T')
+                                        : to_char_type('F'));
+                }
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_integer, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_unsigned, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_number_with_ubjson_prefix(j.m_data.m_value.number_float, add_prefix, use_bjdata);
+                break;
+            }
+
+            case value_t::string:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('S'));
+                }
+                write_number_with_ubjson_prefix(j.m_data.m_value.string->size(), true, use_bjdata);
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_data.m_value.string->c_str()),
+                    j.m_data.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_data.m_value.array->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
+                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
+                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v, use_bjdata) == first_prefix;
+                    });
+
+                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
+
+                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.array->size(), true, use_bjdata);
+                }
+
+                for (const auto& el : *j.m_data.m_value.array)
+                {
+                    write_ubjson(el, use_count, use_type, prefix_required, use_bjdata);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::binary:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                if (use_type && !j.m_data.m_value.binary->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    oa->write_character(to_char_type('$'));
+                    oa->write_character('U');
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.binary->size(), true, use_bjdata);
+                }
+
+                if (use_type)
+                {
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(j.m_data.m_value.binary->data()),
+                        j.m_data.m_value.binary->size());
+                }
+                else
+                {
+                    for (size_t i = 0; i < j.m_data.m_value.binary->size(); ++i)
+                    {
+                        oa->write_character(to_char_type('U'));
+                        oa->write_character(j.m_data.m_value.binary->data()[i]);
+                    }
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                if (use_bjdata && j.m_data.m_value.object->size() == 3 && j.m_data.m_value.object->find("_ArrayType_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArraySize_") != j.m_data.m_value.object->end() && j.m_data.m_value.object->find("_ArrayData_") != j.m_data.m_value.object->end())
+                {
+                    if (!write_bjdata_ndarray(*j.m_data.m_value.object, use_count, use_type))  // decode bjdata ndarray in the JData format (https://github.com/NeuroJSON/jdata)
+                    {
+                        break;
+                    }
+                }
+
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('{'));
+                }
+
+                bool prefix_required = true;
+                if (use_type && !j.m_data.m_value.object->empty())
+                {
+                    JSON_ASSERT(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front(), use_bjdata);
+                    const bool same_prefix = std::all_of(j.begin(), j.end(),
+                                                         [this, first_prefix, use_bjdata](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v, use_bjdata) == first_prefix;
+                    });
+
+                    std::vector<CharType> bjdx = {'[', '{', 'S', 'H', 'T', 'F', 'N', 'Z'}; // excluded markers in bjdata optimized type
+
+                    if (same_prefix && !(use_bjdata && std::find(bjdx.begin(), bjdx.end(), first_prefix) != bjdx.end()))
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_data.m_value.object->size(), true, use_bjdata);
+                }
+
+                for (const auto& el : *j.m_data.m_value.object)
+                {
+                    write_number_with_ubjson_prefix(el.first.size(), true, use_bjdata);
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(el.first.c_str()),
+                        el.first.size());
+                    write_ubjson(el.second, use_count, use_type, prefix_required, use_bjdata);
+                }
+
+                if (!use_count)
+                {
+                    oa->write_character(to_char_type('}'));
+                }
+
+                break;
+            }
+
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @return The size of a BSON document entry header, including the id marker
+            and the entry name size (and its null-terminator).
+    */
+    static std::size_t calc_bson_entry_header_size(const string_t& name, const BasicJsonType& j)
+    {
+        const auto it = name.find(static_cast<typename string_t::value_type>(0));
+        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
+        {
+            JSON_THROW(out_of_range::create(409, concat("BSON key cannot contain code point U+0000 (at byte ", std::to_string(it), ")"), &j));
+            static_cast<void>(j);
+        }
+
+        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
+    }
+
+    /*!
+    @brief Writes the given @a element_type and @a name to the output adapter
+    */
+    void write_bson_entry_header(const string_t& name,
+                                 const std::uint8_t element_type)
+    {
+        oa->write_character(to_char_type(element_type)); // boolean
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(name.c_str()),
+            name.size() + 1u);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and boolean value @a value
+    */
+    void write_bson_boolean(const string_t& name,
+                            const bool value)
+    {
+        write_bson_entry_header(name, 0x08);
+        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and double value @a value
+    */
+    void write_bson_double(const string_t& name,
+                           const double value)
+    {
+        write_bson_entry_header(name, 0x01);
+        write_number<double>(value, true);
+    }
+
+    /*!
+    @return The size of the BSON-encoded string in @a value
+    */
+    static std::size_t calc_bson_string_size(const string_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and string value @a value
+    */
+    void write_bson_string(const string_t& name,
+                           const string_t& value)
+    {
+        write_bson_entry_header(name, 0x02);
+
+        write_number<std::int32_t>(static_cast<std::int32_t>(value.size() + 1ul), true);
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(value.c_str()),
+            value.size() + 1);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and null value
+    */
+    void write_bson_null(const string_t& name)
+    {
+        write_bson_entry_header(name, 0x0A);
+    }
+
+    /*!
+    @return The size of the BSON-encoded integer @a value
+    */
+    static std::size_t calc_bson_integer_size(const std::int64_t value)
+    {
+        return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and integer @a value
+    */
+    void write_bson_integer(const string_t& name,
+                            const std::int64_t value)
+    {
+        if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            write_bson_entry_header(name, 0x10); // int32
+            write_number<std::int32_t>(static_cast<std::int32_t>(value), true);
+        }
+        else
+        {
+            write_bson_entry_header(name, 0x12); // int64
+            write_number<std::int64_t>(static_cast<std::int64_t>(value), true);
+        }
+    }
+
+    /*!
+    @return The size of the BSON-encoded unsigned integer in @a j
+    */
+    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
+    {
+        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and unsigned @a value
+    */
+    void write_bson_unsigned(const string_t& name,
+                             const BasicJsonType& j)
+    {
+        if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x10 /* int32 */);
+            write_number<std::int32_t>(static_cast<std::int32_t>(j.m_data.m_value.number_unsigned), true);
+        }
+        else if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x12 /* int64 */);
+            write_number<std::int64_t>(static_cast<std::int64_t>(j.m_data.m_value.number_unsigned), true);
+        }
+        else
+        {
+            JSON_THROW(out_of_range::create(407, concat("integer number ", std::to_string(j.m_data.m_value.number_unsigned), " cannot be represented by BSON as it does not fit int64"), &j));
+        }
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and object @a value
+    */
+    void write_bson_object_entry(const string_t& name,
+                                 const typename BasicJsonType::object_t& value)
+    {
+        write_bson_entry_header(name, 0x03); // object
+        write_bson_object(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded array @a value
+    */
+    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
+    {
+        std::size_t array_index = 0ul;
+
+        const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), static_cast<std::size_t>(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
+        {
+            return result + calc_bson_element_size(std::to_string(array_index++), el);
+        });
+
+        return sizeof(std::int32_t) + embedded_document_size + 1ul;
+    }
+
+    /*!
+    @return The size of the BSON-encoded binary array @a value
+    */
+    static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and array @a value
+    */
+    void write_bson_array(const string_t& name,
+                          const typename BasicJsonType::array_t& value)
+    {
+        write_bson_entry_header(name, 0x04); // array
+        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_array_size(value)), true);
+
+        std::size_t array_index = 0ul;
+
+        for (const auto& el : value)
+        {
+            write_bson_element(std::to_string(array_index++), el);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and binary value @a value
+    */
+    void write_bson_binary(const string_t& name,
+                           const binary_t& value)
+    {
+        write_bson_entry_header(name, 0x05);
+
+        write_number<std::int32_t>(static_cast<std::int32_t>(value.size()), true);
+        write_number(value.has_subtype() ? static_cast<std::uint8_t>(value.subtype()) : static_cast<std::uint8_t>(0x00));
+
+        oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
+    }
+
+    /*!
+    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
+    @return The calculated size for the BSON document entry for @a j with the given @a name.
+    */
+    static std::size_t calc_bson_element_size(const string_t& name,
+            const BasicJsonType& j)
+    {
+        const auto header_size = calc_bson_entry_header_size(name, j);
+        switch (j.type())
+        {
+            case value_t::object:
+                return header_size + calc_bson_object_size(*j.m_data.m_value.object);
+
+            case value_t::array:
+                return header_size + calc_bson_array_size(*j.m_data.m_value.array);
+
+            case value_t::binary:
+                return header_size + calc_bson_binary_size(*j.m_data.m_value.binary);
+
+            case value_t::boolean:
+                return header_size + 1ul;
+
+            case value_t::number_float:
+                return header_size + 8ul;
+
+            case value_t::number_integer:
+                return header_size + calc_bson_integer_size(j.m_data.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return header_size + calc_bson_unsigned_size(j.m_data.m_value.number_unsigned);
+
+            case value_t::string:
+                return header_size + calc_bson_string_size(*j.m_data.m_value.string);
+
+            case value_t::null:
+                return header_size + 0ul;
+
+            // LCOV_EXCL_START
+            case value_t::discarded:
+            default:
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+                return 0ul;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Serializes the JSON value @a j to BSON and associates it with the
+           key @a name.
+    @param name The name to associate with the JSON entity @a j within the
+                current BSON document
+    */
+    void write_bson_element(const string_t& name,
+                            const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+                return write_bson_object_entry(name, *j.m_data.m_value.object);
+
+            case value_t::array:
+                return write_bson_array(name, *j.m_data.m_value.array);
+
+            case value_t::binary:
+                return write_bson_binary(name, *j.m_data.m_value.binary);
+
+            case value_t::boolean:
+                return write_bson_boolean(name, j.m_data.m_value.boolean);
+
+            case value_t::number_float:
+                return write_bson_double(name, j.m_data.m_value.number_float);
+
+            case value_t::number_integer:
+                return write_bson_integer(name, j.m_data.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return write_bson_unsigned(name, j);
+
+            case value_t::string:
+                return write_bson_string(name, *j.m_data.m_value.string);
+
+            case value_t::null:
+                return write_bson_null(name);
+
+            // LCOV_EXCL_START
+            case value_t::discarded:
+            default:
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
+                return;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Calculates the size of the BSON serialization of the given
+           JSON-object @a j.
+    @param[in] value  JSON value to serialize
+    @pre       value.type() == value_t::object
+    */
+    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
+    {
+        const std::size_t document_size = std::accumulate(value.begin(), value.end(), static_cast<std::size_t>(0),
+                                          [](size_t result, const typename BasicJsonType::object_t::value_type & el)
+        {
+            return result += calc_bson_element_size(el.first, el.second);
+        });
+
+        return sizeof(std::int32_t) + document_size + 1ul;
+    }
+
+    /*!
+    @param[in] value  JSON value to serialize
+    @pre       value.type() == value_t::object
+    */
+    void write_bson_object(const typename BasicJsonType::object_t& value)
+    {
+        write_number<std::int32_t>(static_cast<std::int32_t>(calc_bson_object_size(value)), true);
+
+        for (const auto& el : value)
+        {
+            write_bson_element(el.first, el.second);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xFA);  // Single-Precision Float
+    }
+
+    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xFB);  // Double-Precision Float
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xCA);  // float 32
+    }
+
+    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xCB);  // float 64
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    // UBJSON: write number (floating point)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_floating_point<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if (add_prefix)
+        {
+            oa->write_character(get_ubjson_float_prefix(n));
+        }
+        write_number(n, use_bjdata);
+    }
+
+    // UBJSON: write number (unsigned integer)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_unsigned<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if (n <= (std::numeric_limits<std::uint8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
+            }
+            write_number(static_cast<std::uint16_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= static_cast<uint64_t>((std::numeric_limits<uint32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
+            }
+            write_number(static_cast<std::uint32_t>(n), use_bjdata);
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && n <= (std::numeric_limits<uint64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('M'));  // uint64 - bjdata only
+            }
+            write_number(static_cast<std::uint64_t>(n), use_bjdata);
+        }
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+    }
+
+    // UBJSON: write number (signed integer)
+    template < typename NumberType, typename std::enable_if <
+                   std::is_signed<NumberType>::value&&
+                   !std::is_floating_point<NumberType>::value, int >::type = 0 >
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix,
+                                         const bool use_bjdata)
+    {
+        if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::int8_t>(n), use_bjdata);
+        }
+        else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint16_t>::max)())))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('u'));  // uint16 - bjdata only
+            }
+            write_number(static_cast<uint16_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n), use_bjdata);
+        }
+        else if (use_bjdata && (static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint32_t>::max)())))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('m'));  // uint32 - bjdata only
+            }
+            write_number(static_cast<uint32_t>(n), use_bjdata);
+        }
+        else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n), use_bjdata);
+        }
+        // LCOV_EXCL_START
+        else
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('H'));  // high-precision number
+            }
+
+            const auto number = BasicJsonType(n).dump();
+            write_number_with_ubjson_prefix(number.size(), true, use_bjdata);
+            for (std::size_t i = 0; i < number.size(); ++i)
+            {
+                oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
+            }
+        }
+        // LCOV_EXCL_STOP
+    }
+
+    /*!
+    @brief determine the type prefix of container values
+    */
+    CharType ubjson_prefix(const BasicJsonType& j, const bool use_bjdata) const noexcept
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+                return 'Z';
+
+            case value_t::boolean:
+                return j.m_data.m_value.boolean ? 'T' : 'F';
+
+            case value_t::number_integer:
+            {
+                if ((std::numeric_limits<std::int8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                {
+                    return 'i';
+                }
+                if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    return 'U';
+                }
+                if ((std::numeric_limits<std::int16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                {
+                    return 'I';
+                }
+                if (use_bjdata && ((std::numeric_limits<std::uint16_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)()))
+                {
+                    return 'u';
+                }
+                if ((std::numeric_limits<std::int32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                {
+                    return 'l';
+                }
+                if (use_bjdata && ((std::numeric_limits<std::uint32_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)()))
+                {
+                    return 'm';
+                }
+                if ((std::numeric_limits<std::int64_t>::min)() <= j.m_data.m_value.number_integer && j.m_data.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                {
+                    return 'L';
+                }
+                // anything else is treated as high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+                {
+                    return 'i';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
+                {
+                    return 'U';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+                {
+                    return 'I';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint16_t>::max)()))
+                {
+                    return 'u';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+                {
+                    return 'l';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint32_t>::max)()))
+                {
+                    return 'm';
+                }
+                if (j.m_data.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+                {
+                    return 'L';
+                }
+                if (use_bjdata && j.m_data.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    return 'M';
+                }
+                // anything else is treated as high-precision number
+                return 'H'; // LCOV_EXCL_LINE
+            }
+
+            case value_t::number_float:
+                return get_ubjson_float_prefix(j.m_data.m_value.number_float);
+
+            case value_t::string:
+                return 'S';
+
+            case value_t::array: // fallthrough
+            case value_t::binary:
+                return '[';
+
+            case value_t::object:
+                return '{';
+
+            case value_t::discarded:
+            default:  // discarded values
+                return 'N';
+        }
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
+    {
+        return 'd';  // float 32
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
+    {
+        return 'D';  // float 64
+    }
+
+    /*!
+    @return false if the object is successfully converted to a bjdata ndarray, true if the type or size is invalid
+    */
+    bool write_bjdata_ndarray(const typename BasicJsonType::object_t& value, const bool use_count, const bool use_type)
+    {
+        std::map<string_t, CharType> bjdtype = {{"uint8", 'U'},  {"int8", 'i'},  {"uint16", 'u'}, {"int16", 'I'},
+            {"uint32", 'm'}, {"int32", 'l'}, {"uint64", 'M'}, {"int64", 'L'}, {"single", 'd'}, {"double", 'D'}, {"char", 'C'}
+        };
+
+        string_t key = "_ArrayType_";
+        auto it = bjdtype.find(static_cast<string_t>(value.at(key)));
+        if (it == bjdtype.end())
+        {
+            return true;
+        }
+        CharType dtype = it->second;
+
+        key = "_ArraySize_";
+        std::size_t len = (value.at(key).empty() ? 0 : 1);
+        for (const auto& el : value.at(key))
+        {
+            len *= static_cast<std::size_t>(el.m_data.m_value.number_unsigned);
+        }
+
+        key = "_ArrayData_";
+        if (value.at(key).size() != len)
+        {
+            return true;
+        }
+
+        oa->write_character('[');
+        oa->write_character('$');
+        oa->write_character(dtype);
+        oa->write_character('#');
+
+        key = "_ArraySize_";
+        write_ubjson(value.at(key), use_count, use_type, true,  true);
+
+        key = "_ArrayData_";
+        if (dtype == 'U' || dtype == 'C')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint8_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'i')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int8_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'u')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint16_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'I')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int16_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'm')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint32_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'l')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int32_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'M')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::uint64_t>(el.m_data.m_value.number_unsigned), true);
+            }
+        }
+        else if (dtype == 'L')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<std::int64_t>(el.m_data.m_value.number_integer), true);
+            }
+        }
+        else if (dtype == 'd')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<float>(el.m_data.m_value.number_float), true);
+            }
+        }
+        else if (dtype == 'D')
+        {
+            for (const auto& el : value.at(key))
+            {
+                write_number(static_cast<double>(el.m_data.m_value.number_float), true);
+            }
+        }
+        return false;
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*
+    @brief write a number to output input
+    @param[in] n number of type @a NumberType
+    @param[in] OutputIsLittleEndian Set to true if output data is
+                                 required to be little endian
+    @tparam NumberType the type of the number
+
+    @note This function needs to respect the system's endianness, because bytes
+          in CBOR, MessagePack, and UBJSON are stored in network order (big
+          endian) and therefore need reordering on little endian systems.
+          On the other hand, BSON and BJData use little endian and should reorder
+          on big endian systems.
+    */
+    template<typename NumberType>
+    void write_number(const NumberType n, const bool OutputIsLittleEndian = false)
+    {
+        // step 1: write number to array of length NumberType
+        std::array<CharType, sizeof(NumberType)> vec{};
+        std::memcpy(vec.data(), &n, sizeof(NumberType));
+
+        // step 2: write array to output (with possible reordering)
+        if (is_little_endian != OutputIsLittleEndian)
+        {
+            // reverse byte order prior to conversion if necessary
+            std::reverse(vec.begin(), vec.end());
+        }
+
+        oa->write_characters(vec.data(), sizeof(NumberType));
+    }
+
+    void write_compact_float(const number_float_t n, detail::input_format_t format)
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
+                static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
+                static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(static_cast<float>(n))
+                                : get_msgpack_float_prefix(static_cast<float>(n)));
+            write_number(static_cast<float>(n));
+        }
+        else
+        {
+            oa->write_character(format == detail::input_format_t::cbor
+                                ? get_cbor_float_prefix(n)
+                                : get_msgpack_float_prefix(n));
+            write_number(n);
+        }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+  public:
+    // The following to_char_type functions are implement the conversion
+    // between uint8_t and CharType. In case CharType is not unsigned,
+    // such a conversion is required to allow values greater than 128.
+    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return *reinterpret_cast<char*>(&x);
+    }
+
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
+    static CharType to_char_type(std::uint8_t x) noexcept
+    {
+        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
+        static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
+        CharType result;
+        std::memcpy(&result, &x, sizeof(x));
+        return result;
+    }
+
+    template<typename C = CharType,
+             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return x;
+    }
+
+    template < typename InputCharType, typename C = CharType,
+               enable_if_t <
+                   std::is_signed<C>::value &&
+                   std::is_signed<char>::value &&
+                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
+                   > * = nullptr >
+    static constexpr CharType to_char_type(InputCharType x) noexcept
+    {
+        return x;
+    }
+
+  private:
+    /// whether we can assume little endianness
+    const bool is_little_endian = little_endianness();
+
+    /// the output
+    output_adapter_t<CharType> oa = nullptr;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/output/serializer.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2008-2009 Björn Hoehrmann <bjoern@hoehrmann.de>
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <algorithm> // reverse, remove, fill, find, none_of
+#include <array> // array
+#include <clocale> // localeconv, lconv
+#include <cmath> // labs, isfinite, isnan, signbit
+#include <cstddef> // size_t, ptrdiff_t
+#include <cstdint> // uint8_t
+#include <cstdio> // snprintf
+#include <limits> // numeric_limits
+#include <string> // string, char_traits
+#include <iomanip> // setfill, setw
+#include <type_traits> // is_same
+#include <utility> // move
+
+// #include <nlohmann/detail/conversions/to_chars.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2009 Florian Loitsch <https://florian.loitsch.com/>
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <array> // array
+#include <cmath>   // signbit, isfinite
+#include <cstdint> // intN_t, uintN_t
+#include <cstring> // memcpy, memmove
+#include <limits> // numeric_limits
+#include <type_traits> // conditional
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+/*!
+@brief implements the Grisu2 algorithm for binary to decimal floating-point
+conversion.
+
+This implementation is a slightly modified version of the reference
+implementation which may be obtained from
+http://florian.loitsch.com/publications (bench.tar.gz).
+
+The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
+
+For a detailed description of the algorithm see:
+
+[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
+    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
+    Language Design and Implementation, PLDI 2010
+[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
+    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
+    Design and Implementation, PLDI 1996
+*/
+namespace dtoa_impl
+{
+
+template<typename Target, typename Source>
+Target reinterpret_bits(const Source source)
+{
+    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
+
+    Target target;
+    std::memcpy(&target, &source, sizeof(Source));
+    return target;
+}
+
+struct diyfp // f * 2^e
+{
+    static constexpr int kPrecision = 64; // = q
+
+    std::uint64_t f = 0;
+    int e = 0;
+
+    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
+
+    /*!
+    @brief returns x - y
+    @pre x.e == y.e and x.f >= y.f
+    */
+    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
+    {
+        JSON_ASSERT(x.e == y.e);
+        JSON_ASSERT(x.f >= y.f);
+
+        return {x.f - y.f, x.e};
+    }
+
+    /*!
+    @brief returns x * y
+    @note The result is rounded. (Only the upper q bits are returned.)
+    */
+    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
+    {
+        static_assert(kPrecision == 64, "internal error");
+
+        // Computes:
+        //  f = round((x.f * y.f) / 2^q)
+        //  e = x.e + y.e + q
+
+        // Emulate the 64-bit * 64-bit multiplication:
+        //
+        // p = u * v
+        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
+        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
+        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
+        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
+        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
+        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
+        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
+        //
+        // (Since Q might be larger than 2^32 - 1)
+        //
+        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
+        //
+        // (Q_hi + H does not overflow a 64-bit int)
+        //
+        //   = p_lo + 2^64 p_hi
+
+        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
+        const std::uint64_t u_hi = x.f >> 32u;
+        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
+        const std::uint64_t v_hi = y.f >> 32u;
+
+        const std::uint64_t p0 = u_lo * v_lo;
+        const std::uint64_t p1 = u_lo * v_hi;
+        const std::uint64_t p2 = u_hi * v_lo;
+        const std::uint64_t p3 = u_hi * v_hi;
+
+        const std::uint64_t p0_hi = p0 >> 32u;
+        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
+        const std::uint64_t p1_hi = p1 >> 32u;
+        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
+        const std::uint64_t p2_hi = p2 >> 32u;
+
+        std::uint64_t Q = p0_hi + p1_lo + p2_lo;
+
+        // The full product might now be computed as
+        //
+        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
+        // p_lo = p0_lo + (Q << 32)
+        //
+        // But in this particular case here, the full p_lo is not required.
+        // Effectively we only need to add the highest bit in p_lo to p_hi (and
+        // Q_hi + 1 does not overflow).
+
+        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
+
+        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
+
+        return {h, x.e + y.e + 64};
+    }
+
+    /*!
+    @brief normalize x such that the significand is >= 2^(q-1)
+    @pre x.f != 0
+    */
+    static diyfp normalize(diyfp x) noexcept
+    {
+        JSON_ASSERT(x.f != 0);
+
+        while ((x.f >> 63u) == 0)
+        {
+            x.f <<= 1u;
+            x.e--;
+        }
+
+        return x;
+    }
+
+    /*!
+    @brief normalize x such that the result has the exponent E
+    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
+    */
+    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
+    {
+        const int delta = x.e - target_exponent;
+
+        JSON_ASSERT(delta >= 0);
+        JSON_ASSERT(((x.f << delta) >> delta) == x.f);
+
+        return {x.f << delta, target_exponent};
+    }
+};
+
+struct boundaries
+{
+    diyfp w;
+    diyfp minus;
+    diyfp plus;
+};
+
+/*!
+Compute the (normalized) diyfp representing the input number 'value' and its
+boundaries.
+
+@pre value must be finite and positive
+*/
+template<typename FloatType>
+boundaries compute_boundaries(FloatType value)
+{
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // Convert the IEEE representation into a diyfp.
+    //
+    // If v is denormal:
+    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
+    // If v is normalized:
+    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
+
+    static_assert(std::numeric_limits<FloatType>::is_iec559,
+                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
+
+    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
+    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
+    constexpr int      kMinExp    = 1 - kBias;
+    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
+
+    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
+
+    const auto bits = static_cast<std::uint64_t>(reinterpret_bits<bits_type>(value));
+    const std::uint64_t E = bits >> (kPrecision - 1);
+    const std::uint64_t F = bits & (kHiddenBit - 1);
+
+    const bool is_denormal = E == 0;
+    const diyfp v = is_denormal
+                    ? diyfp(F, kMinExp)
+                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
+
+    // Compute the boundaries m- and m+ of the floating-point value
+    // v = f * 2^e.
+    //
+    // Determine v- and v+, the floating-point predecessor and successor if v,
+    // respectively.
+    //
+    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
+    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
+    //
+    //      v+ = v + 2^e
+    //
+    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
+    // between m- and m+ round to v, regardless of how the input rounding
+    // algorithm breaks ties.
+    //
+    //      ---+-------------+-------------+-------------+-------------+---  (A)
+    //         v-            m-            v             m+            v+
+    //
+    //      -----------------+------+------+-------------+-------------+---  (B)
+    //                       v-     m-     v             m+            v+
+
+    const bool lower_boundary_is_closer = F == 0 && E > 1;
+    const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
+    const diyfp m_minus = lower_boundary_is_closer
+                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)
+                          : diyfp(2 * v.f - 1, v.e - 1); // (A)
+
+    // Determine the normalized w+ = m+.
+    const diyfp w_plus = diyfp::normalize(m_plus);
+
+    // Determine w- = m- such that e_(w-) = e_(w+).
+    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
+
+    return {diyfp::normalize(v), w_minus, w_plus};
+}
+
+// Given normalized diyfp w, Grisu needs to find a (normalized) cached
+// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
+// within a certain range [alpha, gamma] (Definition 3.2 from [1])
+//
+//      alpha <= e = e_c + e_w + q <= gamma
+//
+// or
+//
+//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
+//                          <= f_c * f_w * 2^gamma
+//
+// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
+//
+//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
+//
+// or
+//
+//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
+//
+// The choice of (alpha,gamma) determines the size of the table and the form of
+// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
+// in practice:
+//
+// The idea is to cut the number c * w = f * 2^e into two parts, which can be
+// processed independently: An integral part p1, and a fractional part p2:
+//
+//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
+//              = (f div 2^-e) + (f mod 2^-e) * 2^e
+//              = p1 + p2 * 2^e
+//
+// The conversion of p1 into decimal form requires a series of divisions and
+// modulos by (a power of) 10. These operations are faster for 32-bit than for
+// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
+// achieved by choosing
+//
+//      -e >= 32   or   e <= -32 := gamma
+//
+// In order to convert the fractional part
+//
+//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
+//
+// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
+// d[-i] are extracted in order:
+//
+//      (10 * p2) div 2^-e = d[-1]
+//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
+//
+// The multiplication by 10 must not overflow. It is sufficient to choose
+//
+//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
+//
+// Since p2 = f mod 2^-e < 2^-e,
+//
+//      -e <= 60   or   e >= -60 := alpha
+
+constexpr int kAlpha = -60;
+constexpr int kGamma = -32;
+
+struct cached_power // c = f * 2^e ~= 10^k
+{
+    std::uint64_t f;
+    int e;
+    int k;
+};
+
+/*!
+For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
+power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
+satisfies (Definition 3.2 from [1])
+
+     alpha <= e_c + e + q <= gamma.
+*/
+inline cached_power get_cached_power_for_binary_exponent(int e)
+{
+    // Now
+    //
+    //      alpha <= e_c + e + q <= gamma                                    (1)
+    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
+    //
+    // and since the c's are normalized, 2^(q-1) <= f_c,
+    //
+    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
+    //      ==> 2^(alpha - e - 1) <= c
+    //
+    // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
+    //
+    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
+    //        = ceil( (alpha - e - 1) * log_10(2) )
+    //
+    // From the paper:
+    // "In theory the result of the procedure could be wrong since c is rounded,
+    //  and the computation itself is approximated [...]. In practice, however,
+    //  this simple function is sufficient."
+    //
+    // For IEEE double precision floating-point numbers converted into
+    // normalized diyfp's w = f * 2^e, with q = 64,
+    //
+    //      e >= -1022      (min IEEE exponent)
+    //           -52        (p - 1)
+    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
+    //           -11        (normalize the diyfp)
+    //         = -1137
+    //
+    // and
+    //
+    //      e <= +1023      (max IEEE exponent)
+    //           -52        (p - 1)
+    //           -11        (normalize the diyfp)
+    //         = 960
+    //
+    // This binary exponent range [-1137,960] results in a decimal exponent
+    // range [-307,324]. One does not need to store a cached power for each
+    // k in this range. For each such k it suffices to find a cached power
+    // such that the exponent of the product lies in [alpha,gamma].
+    // This implies that the difference of the decimal exponents of adjacent
+    // table entries must be less than or equal to
+    //
+    //      floor( (gamma - alpha) * log_10(2) ) = 8.
+    //
+    // (A smaller distance gamma-alpha would require a larger table.)
+
+    // NB:
+    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
+
+    constexpr int kCachedPowersMinDecExp = -300;
+    constexpr int kCachedPowersDecStep = 8;
+
+    static constexpr std::array<cached_power, 79> kCachedPowers =
+    {
+        {
+            { 0xAB70FE17C79AC6CA, -1060, -300 },
+            { 0xFF77B1FCBEBCDC4F, -1034, -292 },
+            { 0xBE5691EF416BD60C, -1007, -284 },
+            { 0x8DD01FAD907FFC3C,  -980, -276 },
+            { 0xD3515C2831559A83,  -954, -268 },
+            { 0x9D71AC8FADA6C9B5,  -927, -260 },
+            { 0xEA9C227723EE8BCB,  -901, -252 },
+            { 0xAECC49914078536D,  -874, -244 },
+            { 0x823C12795DB6CE57,  -847, -236 },
+            { 0xC21094364DFB5637,  -821, -228 },
+            { 0x9096EA6F3848984F,  -794, -220 },
+            { 0xD77485CB25823AC7,  -768, -212 },
+            { 0xA086CFCD97BF97F4,  -741, -204 },
+            { 0xEF340A98172AACE5,  -715, -196 },
+            { 0xB23867FB2A35B28E,  -688, -188 },
+            { 0x84C8D4DFD2C63F3B,  -661, -180 },
+            { 0xC5DD44271AD3CDBA,  -635, -172 },
+            { 0x936B9FCEBB25C996,  -608, -164 },
+            { 0xDBAC6C247D62A584,  -582, -156 },
+            { 0xA3AB66580D5FDAF6,  -555, -148 },
+            { 0xF3E2F893DEC3F126,  -529, -140 },
+            { 0xB5B5ADA8AAFF80B8,  -502, -132 },
+            { 0x87625F056C7C4A8B,  -475, -124 },
+            { 0xC9BCFF6034C13053,  -449, -116 },
+            { 0x964E858C91BA2655,  -422, -108 },
+            { 0xDFF9772470297EBD,  -396, -100 },
+            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
+            { 0xF8A95FCF88747D94,  -343,  -84 },
+            { 0xB94470938FA89BCF,  -316,  -76 },
+            { 0x8A08F0F8BF0F156B,  -289,  -68 },
+            { 0xCDB02555653131B6,  -263,  -60 },
+            { 0x993FE2C6D07B7FAC,  -236,  -52 },
+            { 0xE45C10C42A2B3B06,  -210,  -44 },
+            { 0xAA242499697392D3,  -183,  -36 },
+            { 0xFD87B5F28300CA0E,  -157,  -28 },
+            { 0xBCE5086492111AEB,  -130,  -20 },
+            { 0x8CBCCC096F5088CC,  -103,  -12 },
+            { 0xD1B71758E219652C,   -77,   -4 },
+            { 0x9C40000000000000,   -50,    4 },
+            { 0xE8D4A51000000000,   -24,   12 },
+            { 0xAD78EBC5AC620000,     3,   20 },
+            { 0x813F3978F8940984,    30,   28 },
+            { 0xC097CE7BC90715B3,    56,   36 },
+            { 0x8F7E32CE7BEA5C70,    83,   44 },
+            { 0xD5D238A4ABE98068,   109,   52 },
+            { 0x9F4F2726179A2245,   136,   60 },
+            { 0xED63A231D4C4FB27,   162,   68 },
+            { 0xB0DE65388CC8ADA8,   189,   76 },
+            { 0x83C7088E1AAB65DB,   216,   84 },
+            { 0xC45D1DF942711D9A,   242,   92 },
+            { 0x924D692CA61BE758,   269,  100 },
+            { 0xDA01EE641A708DEA,   295,  108 },
+            { 0xA26DA3999AEF774A,   322,  116 },
+            { 0xF209787BB47D6B85,   348,  124 },
+            { 0xB454E4A179DD1877,   375,  132 },
+            { 0x865B86925B9BC5C2,   402,  140 },
+            { 0xC83553C5C8965D3D,   428,  148 },
+            { 0x952AB45CFA97A0B3,   455,  156 },
+            { 0xDE469FBD99A05FE3,   481,  164 },
+            { 0xA59BC234DB398C25,   508,  172 },
+            { 0xF6C69A72A3989F5C,   534,  180 },
+            { 0xB7DCBF5354E9BECE,   561,  188 },
+            { 0x88FCF317F22241E2,   588,  196 },
+            { 0xCC20CE9BD35C78A5,   614,  204 },
+            { 0x98165AF37B2153DF,   641,  212 },
+            { 0xE2A0B5DC971F303A,   667,  220 },
+            { 0xA8D9D1535CE3B396,   694,  228 },
+            { 0xFB9B7CD9A4A7443C,   720,  236 },
+            { 0xBB764C4CA7A44410,   747,  244 },
+            { 0x8BAB8EEFB6409C1A,   774,  252 },
+            { 0xD01FEF10A657842C,   800,  260 },
+            { 0x9B10A4E5E9913129,   827,  268 },
+            { 0xE7109BFBA19C0C9D,   853,  276 },
+            { 0xAC2820D9623BF429,   880,  284 },
+            { 0x80444B5E7AA7CF85,   907,  292 },
+            { 0xBF21E44003ACDD2D,   933,  300 },
+            { 0x8E679C2F5E44FF8F,   960,  308 },
+            { 0xD433179D9C8CB841,   986,  316 },
+            { 0x9E19DB92B4E31BA9,  1013,  324 },
+        }
+    };
+
+    // This computation gives exactly the same results for k as
+    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
+    // for |e| <= 1500, but doesn't require floating-point operations.
+    // NB: log_10(2) ~= 78913 / 2^18
+    JSON_ASSERT(e >= -1500);
+    JSON_ASSERT(e <=  1500);
+    const int f = kAlpha - e - 1;
+    const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
+
+    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
+    JSON_ASSERT(index >= 0);
+    JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
+
+    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
+    JSON_ASSERT(kAlpha <= cached.e + e + 64);
+    JSON_ASSERT(kGamma >= cached.e + e + 64);
+
+    return cached;
+}
+
+/*!
+For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
+For n == 0, returns 1 and sets pow10 := 1.
+*/
+inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
+{
+    // LCOV_EXCL_START
+    if (n >= 1000000000)
+    {
+        pow10 = 1000000000;
+        return 10;
+    }
+    // LCOV_EXCL_STOP
+    if (n >= 100000000)
+    {
+        pow10 = 100000000;
+        return  9;
+    }
+    if (n >= 10000000)
+    {
+        pow10 = 10000000;
+        return  8;
+    }
+    if (n >= 1000000)
+    {
+        pow10 = 1000000;
+        return  7;
+    }
+    if (n >= 100000)
+    {
+        pow10 = 100000;
+        return  6;
+    }
+    if (n >= 10000)
+    {
+        pow10 = 10000;
+        return  5;
+    }
+    if (n >= 1000)
+    {
+        pow10 = 1000;
+        return  4;
+    }
+    if (n >= 100)
+    {
+        pow10 = 100;
+        return  3;
+    }
+    if (n >= 10)
+    {
+        pow10 = 10;
+        return  2;
+    }
+
+    pow10 = 1;
+    return 1;
+}
+
+inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
+                         std::uint64_t rest, std::uint64_t ten_k)
+{
+    JSON_ASSERT(len >= 1);
+    JSON_ASSERT(dist <= delta);
+    JSON_ASSERT(rest <= delta);
+    JSON_ASSERT(ten_k > 0);
+
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    //                                  ten_k
+    //                                <------>
+    //                                       <---- rest ---->
+    // --------------[------------------+----+--------------]--------------
+    //                                  w    V
+    //                                       = buf * 10^k
+    //
+    // ten_k represents a unit-in-the-last-place in the decimal representation
+    // stored in buf.
+    // Decrement buf by ten_k while this takes buf closer to w.
+
+    // The tests are written in this order to avoid overflow in unsigned
+    // integer arithmetic.
+
+    while (rest < dist
+            && delta - rest >= ten_k
+            && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
+    {
+        JSON_ASSERT(buf[len - 1] != '0');
+        buf[len - 1]--;
+        rest += ten_k;
+    }
+}
+
+/*!
+Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
+M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
+*/
+inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
+                             diyfp M_minus, diyfp w, diyfp M_plus)
+{
+    static_assert(kAlpha >= -60, "internal error");
+    static_assert(kGamma <= -32, "internal error");
+
+    // Generates the digits (and the exponent) of a decimal floating-point
+    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
+    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
+    //
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    // Grisu2 generates the digits of M+ from left to right and stops as soon as
+    // V is in [M-,M+].
+
+    JSON_ASSERT(M_plus.e >= kAlpha);
+    JSON_ASSERT(M_plus.e <= kGamma);
+
+    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
+    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
+
+    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
+    //
+    //      M+ = f * 2^e
+    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
+    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
+    //         = p1 + p2 * 2^e
+
+    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
+
+    auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
+    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
+
+    // 1)
+    //
+    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
+
+    JSON_ASSERT(p1 > 0);
+
+    std::uint32_t pow10{};
+    const int k = find_largest_pow10(p1, pow10);
+
+    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
+    //
+    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
+    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
+    //
+    //      M+ = p1                                             + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
+    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
+    //
+    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
+    //
+    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
+    //
+    // but stop as soon as
+    //
+    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
+
+    int n = k;
+    while (n > 0)
+    {
+        // Invariants:
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        //
+        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
+        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
+        //
+        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
+        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
+        //
+        p1 = r;
+        n--;
+        //
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
+        //      pow10 = 10^n
+        //
+
+        // Now check if enough digits have been generated.
+        // Compute
+        //
+        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
+        //
+        // Note:
+        // Since rest and delta share the same exponent e, it suffices to
+        // compare the significands.
+        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
+        if (rest <= delta)
+        {
+            // V = buffer * 10^n, with M- <= V <= M+.
+
+            decimal_exponent += n;
+
+            // We may now just stop. But instead look if the buffer could be
+            // decremented to bring V closer to w.
+            //
+            // pow10 = 10^n is now 1 ulp in the decimal representation V.
+            // The rounding procedure works with diyfp's with an implicit
+            // exponent of e.
+            //
+            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
+            //
+            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
+            grisu2_round(buffer, length, dist, delta, rest, ten_n);
+
+            return;
+        }
+
+        pow10 /= 10;
+        //
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        // Invariants restored.
+    }
+
+    // 2)
+    //
+    // The digits of the integral part have been generated:
+    //
+    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
+    //         = buffer            + p2 * 2^e
+    //
+    // Now generate the digits of the fractional part p2 * 2^e.
+    //
+    // Note:
+    // No decimal point is generated: the exponent is adjusted instead.
+    //
+    // p2 actually represents the fraction
+    //
+    //      p2 * 2^e
+    //          = p2 / 2^-e
+    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
+    //
+    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
+    //
+    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
+    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
+    //
+    // using
+    //
+    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
+    //                = (                   d) * 2^-e + (                   r)
+    //
+    // or
+    //      10^m * p2 * 2^e = d + r * 2^e
+    //
+    // i.e.
+    //
+    //      M+ = buffer + p2 * 2^e
+    //         = buffer + 10^-m * (d + r * 2^e)
+    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
+    //
+    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
+
+    JSON_ASSERT(p2 > delta);
+
+    int m = 0;
+    for (;;)
+    {
+        // Invariant:
+        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
+        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
+        //
+        JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
+        p2 *= 10;
+        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
+        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
+        //
+        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
+        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        JSON_ASSERT(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        p2 = r;
+        m++;
+        //
+        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
+        // Invariant restored.
+
+        // Check if enough digits have been generated.
+        //
+        //      10^-m * p2 * 2^e <= delta * 2^e
+        //              p2 * 2^e <= 10^m * delta * 2^e
+        //                    p2 <= 10^m * delta
+        delta *= 10;
+        dist  *= 10;
+        if (p2 <= delta)
+        {
+            break;
+        }
+    }
+
+    // V = buffer * 10^-m, with M- <= V <= M+.
+
+    decimal_exponent -= m;
+
+    // 1 ulp in the decimal representation is now 10^-m.
+    // Since delta and dist are now scaled by 10^m, we need to do the
+    // same with ulp in order to keep the units in sync.
+    //
+    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
+    //
+    const std::uint64_t ten_m = one.f;
+    grisu2_round(buffer, length, dist, delta, p2, ten_m);
+
+    // By construction this algorithm generates the shortest possible decimal
+    // number (Loitsch, Theorem 6.2) which rounds back to w.
+    // For an input number of precision p, at least
+    //
+    //      N = 1 + ceil(p * log_10(2))
+    //
+    // decimal digits are sufficient to identify all binary floating-point
+    // numbers (Matula, "In-and-Out conversions").
+    // This implies that the algorithm does not produce more than N decimal
+    // digits.
+    //
+    //      N = 17 for p = 53 (IEEE double precision)
+    //      N = 9  for p = 24 (IEEE single precision)
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline void grisu2(char* buf, int& len, int& decimal_exponent,
+                   diyfp m_minus, diyfp v, diyfp m_plus)
+{
+    JSON_ASSERT(m_plus.e == m_minus.e);
+    JSON_ASSERT(m_plus.e == v.e);
+
+    //  --------(-----------------------+-----------------------)--------    (A)
+    //          m-                      v                       m+
+    //
+    //  --------------------(-----------+-----------------------)--------    (B)
+    //                      m-          v                       m+
+    //
+    // First scale v (and m- and m+) such that the exponent is in the range
+    // [alpha, gamma].
+
+    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
+
+    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
+
+    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
+    const diyfp w       = diyfp::mul(v,       c_minus_k);
+    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
+    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
+
+    //  ----(---+---)---------------(---+---)---------------(---+---)----
+    //          w-                      w                       w+
+    //          = c*m-                  = c*v                   = c*m+
+    //
+    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
+    // w+ are now off by a small amount.
+    // In fact:
+    //
+    //      w - v * 10^k < 1 ulp
+    //
+    // To account for this inaccuracy, add resp. subtract 1 ulp.
+    //
+    //  --------+---[---------------(---+---)---------------]---+--------
+    //          w-  M-                  w                   M+  w+
+    //
+    // Now any number in [M-, M+] (bounds included) will round to w when input,
+    // regardless of how the input rounding algorithm breaks ties.
+    //
+    // And digit_gen generates the shortest possible such number in [M-, M+].
+    // Note that this does not mean that Grisu2 always generates the shortest
+    // possible number in the interval (m-, m+).
+    const diyfp M_minus(w_minus.f + 1, w_minus.e);
+    const diyfp M_plus (w_plus.f  - 1, w_plus.e );
+
+    decimal_exponent = -cached.k; // = -(-k) = k
+
+    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1)
+void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
+{
+    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
+                  "internal error: not enough precision");
+
+    JSON_ASSERT(std::isfinite(value));
+    JSON_ASSERT(value > 0);
+
+    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
+    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
+    // decimal representations are not exactly "short".
+    //
+    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
+    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
+    // and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
+    // does.
+    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
+    // representation using the corresponding std::from_chars function recovers value exactly". That
+    // indicates that single precision floating-point numbers should be recovered using
+    // 'std::strtof'.
+    //
+    // NB: If the neighbors are computed for single-precision numbers, there is a single float
+    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
+    //     value is off by 1 ulp.
+#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
+    const boundaries w = compute_boundaries(static_cast<double>(value));
+#else
+    const boundaries w = compute_boundaries(value);
+#endif
+
+    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
+}
+
+/*!
+@brief appends a decimal representation of e to buf
+@return a pointer to the element following the exponent.
+@pre -1000 < e < 1000
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* append_exponent(char* buf, int e)
+{
+    JSON_ASSERT(e > -1000);
+    JSON_ASSERT(e <  1000);
+
+    if (e < 0)
+    {
+        e = -e;
+        *buf++ = '-';
+    }
+    else
+    {
+        *buf++ = '+';
+    }
+
+    auto k = static_cast<std::uint32_t>(e);
+    if (k < 10)
+    {
+        // Always print at least two digits in the exponent.
+        // This is for compatibility with printf("%g").
+        *buf++ = '0';
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else if (k < 100)
+    {
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else
+    {
+        *buf++ = static_cast<char>('0' + k / 100);
+        k %= 100;
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+
+    return buf;
+}
+
+/*!
+@brief prettify v = buf * 10^decimal_exponent
+
+If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
+notation. Otherwise it will be printed in exponential notation.
+
+@pre min_exp < 0
+@pre max_exp > 0
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* format_buffer(char* buf, int len, int decimal_exponent,
+                           int min_exp, int max_exp)
+{
+    JSON_ASSERT(min_exp < 0);
+    JSON_ASSERT(max_exp > 0);
+
+    const int k = len;
+    const int n = len + decimal_exponent;
+
+    // v = buf * 10^(n-k)
+    // k is the length of the buffer (number of decimal digits)
+    // n is the position of the decimal point relative to the start of the buffer.
+
+    if (k <= n && n <= max_exp)
+    {
+        // digits[000]
+        // len <= max_exp + 2
+
+        std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
+        // Make it look like a floating-point number (#362, #378)
+        buf[n + 0] = '.';
+        buf[n + 1] = '0';
+        return buf + (static_cast<size_t>(n) + 2);
+    }
+
+    if (0 < n && n <= max_exp)
+    {
+        // dig.its
+        // len <= max_digits10 + 1
+
+        JSON_ASSERT(k > n);
+
+        std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
+        buf[n] = '.';
+        return buf + (static_cast<size_t>(k) + 1U);
+    }
+
+    if (min_exp < n && n <= 0)
+    {
+        // 0.[000]digits
+        // len <= 2 + (-min_exp - 1) + max_digits10
+
+        std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
+        buf[0] = '0';
+        buf[1] = '.';
+        std::memset(buf + 2, '0', static_cast<size_t>(-n));
+        return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
+    }
+
+    if (k == 1)
+    {
+        // dE+123
+        // len <= 1 + 5
+
+        buf += 1;
+    }
+    else
+    {
+        // d.igitsE+123
+        // len <= max_digits10 + 1 + 5
+
+        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
+        buf[1] = '.';
+        buf += 1 + static_cast<size_t>(k);
+    }
+
+    *buf++ = 'e';
+    return append_exponent(buf, n - 1);
+}
+
+}  // namespace dtoa_impl
+
+/*!
+@brief generates a decimal representation of the floating-point number value in [first, last).
+
+The format of the resulting decimal representation is similar to printf's %g
+format. Returns an iterator pointing past-the-end of the decimal representation.
+
+@note The input number must be finite, i.e. NaN's and Inf's are not supported.
+@note The buffer must be large enough.
+@note The result is NOT null-terminated.
+*/
+template<typename FloatType>
+JSON_HEDLEY_NON_NULL(1, 2)
+JSON_HEDLEY_RETURNS_NON_NULL
+char* to_chars(char* first, const char* last, FloatType value)
+{
+    static_cast<void>(last); // maybe unused - fix warning
+    JSON_ASSERT(std::isfinite(value));
+
+    // Use signbit(value) instead of (value < 0) since signbit works for -0.
+    if (std::signbit(value))
+    {
+        value = -value;
+        *first++ = '-';
+    }
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+    if (value == 0) // +-0
+    {
+        *first++ = '0';
+        // Make it look like a floating-point number (#362, #378)
+        *first++ = '.';
+        *first++ = '0';
+        return first;
+    }
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
+
+    // Compute v = buffer * 10^decimal_exponent.
+    // The decimal digits are stored in the buffer, which needs to be interpreted
+    // as an unsigned decimal integer.
+    // len is the length of the buffer, i.e. the number of decimal digits.
+    int len = 0;
+    int decimal_exponent = 0;
+    dtoa_impl::grisu2(first, len, decimal_exponent, value);
+
+    JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
+
+    // Format the buffer like printf("%.*g", prec, value)
+    constexpr int kMinExp = -4;
+    // Use digits10 here to increase compatibility with version 2.
+    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
+
+    JSON_ASSERT(last - first >= kMaxExp + 2);
+    JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
+    JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
+
+    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
+}
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/string_concat.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+namespace detail
+{
+
+///////////////////
+// serialization //
+///////////////////
+
+/// how to treat decoding errors
+enum class error_handler_t
+{
+    strict,  ///< throw a type_error exception in case of invalid UTF-8
+    replace, ///< replace invalid UTF-8 sequences with U+FFFD
+    ignore   ///< ignore invalid UTF-8 sequences
+};
+
+template<typename BasicJsonType>
+class serializer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using binary_char_t = typename BasicJsonType::binary_t::value_type;
+    static constexpr std::uint8_t UTF8_ACCEPT = 0;
+    static constexpr std::uint8_t UTF8_REJECT = 1;
+
+  public:
+    /*!
+    @param[in] s  output stream to serialize to
+    @param[in] ichar  indentation character to use
+    @param[in] error_handler_  how to react on decoding errors
+    */
+    serializer(output_adapter_t<char> s, const char ichar,
+               error_handler_t error_handler_ = error_handler_t::strict)
+        : o(std::move(s))
+        , loc(std::localeconv())
+        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
+        , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
+        , indent_char(ichar)
+        , indent_string(512, indent_char)
+        , error_handler(error_handler_)
+    {}
+
+    // delete because of pointer members
+    serializer(const serializer&) = delete;
+    serializer& operator=(const serializer&) = delete;
+    serializer(serializer&&) = delete;
+    serializer& operator=(serializer&&) = delete;
+    ~serializer() = default;
+
+    /*!
+    @brief internal implementation of the serialization function
+
+    This function is called by the public member function dump and organizes
+    the serialization internally. The indentation level is propagated as
+    additional parameter. In case of arrays and objects, the function is
+    called recursively.
+
+    - strings and object keys are escaped using `escape_string()`
+    - integer numbers are converted implicitly via `operator<<`
+    - floating-point numbers are converted to a string using `"%g"` format
+    - binary values are serialized as objects containing the subtype and the
+      byte array
+
+    @param[in] val               value to serialize
+    @param[in] pretty_print      whether the output shall be pretty-printed
+    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
+    in the output are escaped with `\uXXXX` sequences, and the result consists
+    of ASCII characters only.
+    @param[in] indent_step       the indent level
+    @param[in] current_indent    the current indent level (only used internally)
+    */
+    void dump(const BasicJsonType& val,
+              const bool pretty_print,
+              const bool ensure_ascii,
+              const unsigned int indent_step,
+              const unsigned int current_indent = 0)
+    {
+        switch (val.m_data.m_type)
+        {
+            case value_t::object:
+            {
+                if (val.m_data.m_value.object->empty())
+                {
+                    o->write_characters("{}", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    auto i = val.m_data.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\": ", 3);
+                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\": ", 3);
+                    dump(i->second, true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_character('{');
+
+                    // first n-1 elements
+                    auto i = val.m_data.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_data.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\":", 2);
+                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(i != val.m_data.m_value.object->cend());
+                    JSON_ASSERT(std::next(i) == val.m_data.m_value.object->cend());
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\":", 2);
+                    dump(i->second, false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character('}');
+                }
+
+                return;
+            }
+
+            case value_t::array:
+            {
+                if (val.m_data.m_value.array->empty())
+                {
+                    o->write_characters("[]", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("[\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    for (auto i = val.m_data.m_value.array->cbegin();
+                            i != val.m_data.m_value.array->cend() - 1; ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        dump(*i, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_data.m_value.array->empty());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    dump(val.m_data.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character(']');
+                }
+                else
+                {
+                    o->write_character('[');
+
+                    // first n-1 elements
+                    for (auto i = val.m_data.m_value.array->cbegin();
+                            i != val.m_data.m_value.array->cend() - 1; ++i)
+                    {
+                        dump(*i, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    JSON_ASSERT(!val.m_data.m_value.array->empty());
+                    dump(val.m_data.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character(']');
+                }
+
+                return;
+            }
+
+            case value_t::string:
+            {
+                o->write_character('\"');
+                dump_escaped(*val.m_data.m_value.string, ensure_ascii);
+                o->write_character('\"');
+                return;
+            }
+
+            case value_t::binary:
+            {
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"bytes\": [", 10);
+
+                    if (!val.m_data.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_data.m_value.binary->cbegin();
+                                i != val.m_data.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_characters(", ", 2);
+                        }
+                        dump_integer(val.m_data.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\n", 3);
+                    o->write_characters(indent_string.c_str(), new_indent);
+
+                    o->write_characters("\"subtype\": ", 11);
+                    if (val.m_data.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_data.m_value.binary->subtype());
+                    }
+                    else
+                    {
+                        o->write_characters("null", 4);
+                    }
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_characters("{\"bytes\":[", 10);
+
+                    if (!val.m_data.m_value.binary->empty())
+                    {
+                        for (auto i = val.m_data.m_value.binary->cbegin();
+                                i != val.m_data.m_value.binary->cend() - 1; ++i)
+                        {
+                            dump_integer(*i);
+                            o->write_character(',');
+                        }
+                        dump_integer(val.m_data.m_value.binary->back());
+                    }
+
+                    o->write_characters("],\"subtype\":", 12);
+                    if (val.m_data.m_value.binary->has_subtype())
+                    {
+                        dump_integer(val.m_data.m_value.binary->subtype());
+                        o->write_character('}');
+                    }
+                    else
+                    {
+                        o->write_characters("null}", 5);
+                    }
+                }
+                return;
+            }
+
+            case value_t::boolean:
+            {
+                if (val.m_data.m_value.boolean)
+                {
+                    o->write_characters("true", 4);
+                }
+                else
+                {
+                    o->write_characters("false", 5);
+                }
+                return;
+            }
+
+            case value_t::number_integer:
+            {
+                dump_integer(val.m_data.m_value.number_integer);
+                return;
+            }
+
+            case value_t::number_unsigned:
+            {
+                dump_integer(val.m_data.m_value.number_unsigned);
+                return;
+            }
+
+            case value_t::number_float:
+            {
+                dump_float(val.m_data.m_value.number_float);
+                return;
+            }
+
+            case value_t::discarded:
+            {
+                o->write_characters("<discarded>", 11);
+                return;
+            }
+
+            case value_t::null:
+            {
+                o->write_characters("null", 4);
+                return;
+            }
+
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief dump escaped string
+
+    Escape a string by replacing certain special characters by a sequence of an
+    escape character (backslash) and another character and other control
+    characters by a sequence of "\u" followed by a four-digit hex
+    representation. The escaped string is written to output stream @a o.
+
+    @param[in] s  the string to escape
+    @param[in] ensure_ascii  whether to escape non-ASCII characters with
+                             \uXXXX sequences
+
+    @complexity Linear in the length of string @a s.
+    */
+    void dump_escaped(const string_t& s, const bool ensure_ascii)
+    {
+        std::uint32_t codepoint{};
+        std::uint8_t state = UTF8_ACCEPT;
+        std::size_t bytes = 0;  // number of bytes written to string_buffer
+
+        // number of bytes written at the point of the last valid byte
+        std::size_t bytes_after_last_accept = 0;
+        std::size_t undumped_chars = 0;
+
+        for (std::size_t i = 0; i < s.size(); ++i)
+        {
+            const auto byte = static_cast<std::uint8_t>(s[i]);
+
+            switch (decode(state, codepoint, byte))
+            {
+                case UTF8_ACCEPT:  // decode found a new code point
+                {
+                    switch (codepoint)
+                    {
+                        case 0x08: // backspace
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'b';
+                            break;
+                        }
+
+                        case 0x09: // horizontal tab
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 't';
+                            break;
+                        }
+
+                        case 0x0A: // newline
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'n';
+                            break;
+                        }
+
+                        case 0x0C: // formfeed
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'f';
+                            break;
+                        }
+
+                        case 0x0D: // carriage return
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'r';
+                            break;
+                        }
+
+                        case 0x22: // quotation mark
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\"';
+                            break;
+                        }
+
+                        case 0x5C: // reverse solidus
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\\';
+                            break;
+                        }
+
+                        default:
+                        {
+                            // escape control characters (0x00..0x1F) or, if
+                            // ensure_ascii parameter is used, non-ASCII characters
+                            if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
+                            {
+                                if (codepoint <= 0xFFFF)
+                                {
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                                      static_cast<std::uint16_t>(codepoint)));
+                                    bytes += 6;
+                                }
+                                else
+                                {
+                                    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+                                    static_cast<void>((std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                                      static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+                                                                      static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu))));
+                                    bytes += 12;
+                                }
+                            }
+                            else
+                            {
+                                // copy byte to buffer (all previous bytes
+                                // been copied have in default case above)
+                                string_buffer[bytes++] = s[i];
+                            }
+                            break;
+                        }
+                    }
+
+                    // write buffer and reset index; there must be 13 bytes
+                    // left, as this is the maximal number of bytes to be
+                    // written ("\uxxxx\uxxxx\0") for one code point
+                    if (string_buffer.size() - bytes < 13)
+                    {
+                        o->write_characters(string_buffer.data(), bytes);
+                        bytes = 0;
+                    }
+
+                    // remember the byte position of this accept
+                    bytes_after_last_accept = bytes;
+                    undumped_chars = 0;
+                    break;
+                }
+
+                case UTF8_REJECT:  // decode found invalid UTF-8 byte
+                {
+                    switch (error_handler)
+                    {
+                        case error_handler_t::strict:
+                        {
+                            JSON_THROW(type_error::create(316, concat("invalid UTF-8 byte at index ", std::to_string(i), ": 0x", hex_bytes(byte | 0)), nullptr));
+                        }
+
+                        case error_handler_t::ignore:
+                        case error_handler_t::replace:
+                        {
+                            // in case we saw this character the first time, we
+                            // would like to read it again, because the byte
+                            // may be OK for itself, but just not OK for the
+                            // previous sequence
+                            if (undumped_chars > 0)
+                            {
+                                --i;
+                            }
+
+                            // reset length buffer to the last accepted index;
+                            // thus removing/ignoring the invalid characters
+                            bytes = bytes_after_last_accept;
+
+                            if (error_handler == error_handler_t::replace)
+                            {
+                                // add a replacement character
+                                if (ensure_ascii)
+                                {
+                                    string_buffer[bytes++] = '\\';
+                                    string_buffer[bytes++] = 'u';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'd';
+                                }
+                                else
+                                {
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
+                                }
+
+                                // write buffer and reset index; there must be 13 bytes
+                                // left, as this is the maximal number of bytes to be
+                                // written ("\uxxxx\uxxxx\0") for one code point
+                                if (string_buffer.size() - bytes < 13)
+                                {
+                                    o->write_characters(string_buffer.data(), bytes);
+                                    bytes = 0;
+                                }
+
+                                bytes_after_last_accept = bytes;
+                            }
+
+                            undumped_chars = 0;
+
+                            // continue processing the string
+                            state = UTF8_ACCEPT;
+                            break;
+                        }
+
+                        default:            // LCOV_EXCL_LINE
+                            JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+
+                default:  // decode found yet incomplete multi-byte code point
+                {
+                    if (!ensure_ascii)
+                    {
+                        // code point will not be escaped - copy byte to buffer
+                        string_buffer[bytes++] = s[i];
+                    }
+                    ++undumped_chars;
+                    break;
+                }
+            }
+        }
+
+        // we finished processing the string
+        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
+        {
+            // write buffer
+            if (bytes > 0)
+            {
+                o->write_characters(string_buffer.data(), bytes);
+            }
+        }
+        else
+        {
+            // we finish reading, but do not accept: string was incomplete
+            switch (error_handler)
+            {
+                case error_handler_t::strict:
+                {
+                    JSON_THROW(type_error::create(316, concat("incomplete UTF-8 string; last byte: 0x", hex_bytes(static_cast<std::uint8_t>(s.back() | 0))), nullptr));
+                }
+
+                case error_handler_t::ignore:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    break;
+                }
+
+                case error_handler_t::replace:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    // add a replacement character
+                    if (ensure_ascii)
+                    {
+                        o->write_characters("\\ufffd", 6);
+                    }
+                    else
+                    {
+                        o->write_characters("\xEF\xBF\xBD", 3);
+                    }
+                    break;
+                }
+
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            }
+        }
+    }
+
+  private:
+    /*!
+    @brief count digits
+
+    Count the number of decimal (base 10) digits for an input unsigned integer.
+
+    @param[in] x  unsigned integer number to count its digits
+    @return    number of decimal digits
+    */
+    inline unsigned int count_digits(number_unsigned_t x) noexcept
+    {
+        unsigned int n_digits = 1;
+        for (;;)
+        {
+            if (x < 10)
+            {
+                return n_digits;
+            }
+            if (x < 100)
+            {
+                return n_digits + 1;
+            }
+            if (x < 1000)
+            {
+                return n_digits + 2;
+            }
+            if (x < 10000)
+            {
+                return n_digits + 3;
+            }
+            x = x / 10000u;
+            n_digits += 4;
+        }
+    }
+
+    /*!
+     * @brief convert a byte to a uppercase hex representation
+     * @param[in] byte byte to represent
+     * @return representation ("00".."FF")
+     */
+    static std::string hex_bytes(std::uint8_t byte)
+    {
+        std::string result = "FF";
+        constexpr const char* nibble_to_hex = "0123456789ABCDEF";
+        result[0] = nibble_to_hex[byte / 16];
+        result[1] = nibble_to_hex[byte % 16];
+        return result;
+    }
+
+    // templates to avoid warnings about useless casts
+    template <typename NumberType, enable_if_t<std::is_signed<NumberType>::value, int> = 0>
+    bool is_negative_number(NumberType x)
+    {
+        return x < 0;
+    }
+
+    template < typename NumberType, enable_if_t <std::is_unsigned<NumberType>::value, int > = 0 >
+    bool is_negative_number(NumberType /*unused*/)
+    {
+        return false;
+    }
+
+    /*!
+    @brief dump an integer
+
+    Dump a given integer to output stream @a o. Works internally with
+    @a number_buffer.
+
+    @param[in] x  integer number (signed or unsigned) to dump
+    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
+    */
+    template < typename NumberType, detail::enable_if_t <
+                   std::is_integral<NumberType>::value ||
+                   std::is_same<NumberType, number_unsigned_t>::value ||
+                   std::is_same<NumberType, number_integer_t>::value ||
+                   std::is_same<NumberType, binary_char_t>::value,
+                   int > = 0 >
+    void dump_integer(NumberType x)
+    {
+        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
+        {
+            {
+                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
+                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
+                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
+                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
+                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
+                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
+                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
+                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
+                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
+                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
+            }
+        };
+
+        // special case for "0"
+        if (x == 0)
+        {
+            o->write_character('0');
+            return;
+        }
+
+        // use a pointer to fill the buffer
+        auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+
+        number_unsigned_t abs_value;
+
+        unsigned int n_chars{};
+
+        if (is_negative_number(x))
+        {
+            *buffer_ptr = '-';
+            abs_value = remove_sign(static_cast<number_integer_t>(x));
+
+            // account one more byte for the minus sign
+            n_chars = 1 + count_digits(abs_value);
+        }
+        else
+        {
+            abs_value = static_cast<number_unsigned_t>(x);
+            n_chars = count_digits(abs_value);
+        }
+
+        // spare 1 byte for '\0'
+        JSON_ASSERT(n_chars < number_buffer.size() - 1);
+
+        // jump to the end to generate the string from backward,
+        // so we later avoid reversing the result
+        buffer_ptr += n_chars;
+
+        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
+        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
+        while (abs_value >= 100)
+        {
+            const auto digits_index = static_cast<unsigned>((abs_value % 100));
+            abs_value /= 100;
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+
+        if (abs_value >= 10)
+        {
+            const auto digits_index = static_cast<unsigned>(abs_value);
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+        else
+        {
+            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
+        }
+
+        o->write_characters(number_buffer.data(), n_chars);
+    }
+
+    /*!
+    @brief dump a floating-point number
+
+    Dump a given floating-point number to output stream @a o. Works internally
+    with @a number_buffer.
+
+    @param[in] x  floating-point number to dump
+    */
+    void dump_float(number_float_t x)
+    {
+        // NaN / inf
+        if (!std::isfinite(x))
+        {
+            o->write_characters("null", 4);
+            return;
+        }
+
+        // If number_float_t is an IEEE-754 single or double precision number,
+        // use the Grisu2 algorithm to produce short numbers which are
+        // guaranteed to round-trip, using strtof and strtod, resp.
+        //
+        // NB: The test below works if <long double> == <double>.
+        static constexpr bool is_ieee_single_or_double
+            = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
+              (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
+
+        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
+    }
+
+    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
+    {
+        auto* begin = number_buffer.data();
+        auto* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
+
+        o->write_characters(begin, static_cast<size_t>(end - begin));
+    }
+
+    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
+    {
+        // get number of digits for a float -> text -> float round-trip
+        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
+
+        // the actual conversion
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
+
+        // negative value indicates an error
+        JSON_ASSERT(len > 0);
+        // check if buffer was large enough
+        JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
+
+        // erase thousands separator
+        if (thousands_sep != '\0')
+        {
+            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::remove returns an iterator, see https://github.com/nlohmann/json/issues/3081
+            const auto end = std::remove(number_buffer.begin(), number_buffer.begin() + len, thousands_sep);
+            std::fill(end, number_buffer.end(), '\0');
+            JSON_ASSERT((end - number_buffer.begin()) <= len);
+            len = (end - number_buffer.begin());
+        }
+
+        // convert decimal point to '.'
+        if (decimal_point != '\0' && decimal_point != '.')
+        {
+            // NOLINTNEXTLINE(readability-qualified-auto,llvm-qualified-auto): std::find returns an iterator, see https://github.com/nlohmann/json/issues/3081
+            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
+            if (dec_pos != number_buffer.end())
+            {
+                *dec_pos = '.';
+            }
+        }
+
+        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
+
+        // determine if we need to append ".0"
+        const bool value_is_int_like =
+            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
+                         [](char c)
+        {
+            return c == '.' || c == 'e';
+        });
+
+        if (value_is_int_like)
+        {
+            o->write_characters(".0", 2);
+        }
+    }
+
+    /*!
+    @brief check whether a string is UTF-8 encoded
+
+    The function checks each byte of a string whether it is UTF-8 encoded. The
+    result of the check is stored in the @a state parameter. The function must
+    be called initially with state 0 (accept). State 1 means the string must
+    be rejected, because the current byte is not allowed. If the string is
+    completely processed, but the state is non-zero, the string ended
+    prematurely; that is, the last byte indicated more bytes should have
+    followed.
+
+    @param[in,out] state  the state of the decoding
+    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
+    @param[in] byte       next byte to decode
+    @return               new state
+
+    @note The function has been edited: a std::array is used.
+
+    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+    */
+    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
+    {
+        static const std::array<std::uint8_t, 400> utf8d =
+        {
+            {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
+                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
+                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
+                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
+                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
+                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
+                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
+                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
+                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
+            }
+        };
+
+        JSON_ASSERT(byte < utf8d.size());
+        const std::uint8_t type = utf8d[byte];
+
+        codep = (state != UTF8_ACCEPT)
+                ? (byte & 0x3fu) | (codep << 6u)
+                : (0xFFu >> type) & (byte);
+
+        const std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
+        JSON_ASSERT(index < utf8d.size());
+        state = utf8d[index];
+        return state;
+    }
+
+    /*
+     * Overload to make the compiler happy while it is instantiating
+     * dump_integer for number_unsigned_t.
+     * Must never be called.
+     */
+    number_unsigned_t remove_sign(number_unsigned_t x)
+    {
+        JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        return x; // LCOV_EXCL_LINE
+    }
+
+    /*
+     * Helper function for dump_integer
+     *
+     * This function takes a negative signed integer and returns its absolute
+     * value as unsigned integer. The plus/minus shuffling is necessary as we can
+     * not directly remove the sign of an arbitrary signed integer as the
+     * absolute values of INT_MIN and INT_MAX are usually not the same. See
+     * #1708 for details.
+     */
+    inline number_unsigned_t remove_sign(number_integer_t x) noexcept
+    {
+        JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)()); // NOLINT(misc-redundant-expression)
+        return static_cast<number_unsigned_t>(-(x + 1)) + 1;
+    }
+
+  private:
+    /// the output of the serializer
+    output_adapter_t<char> o = nullptr;
+
+    /// a (hopefully) large enough character buffer
+    std::array<char, 64> number_buffer{{}};
+
+    /// the locale
+    const std::lconv* loc = nullptr;
+    /// the locale's thousand separator character
+    const char thousands_sep = '\0';
+    /// the locale's decimal point character
+    const char decimal_point = '\0';
+
+    /// string buffer
+    std::array<char, 512> string_buffer{{}};
+
+    /// the indentation character
+    const char indent_char;
+    /// the indentation string
+    string_t indent_string;
+
+    /// error_handler how to react on decoding errors
+    const error_handler_t error_handler;
+};
+
+}  // namespace detail
+NLOHMANN_JSON_NAMESPACE_END
+
+// #include <nlohmann/detail/value_t.hpp>
+
+// #include <nlohmann/json_fwd.hpp>
+
+// #include <nlohmann/ordered_map.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#include <functional> // equal_to, less
+#include <initializer_list> // initializer_list
+#include <iterator> // input_iterator_tag, iterator_traits
+#include <memory> // allocator
+#include <stdexcept> // for out_of_range
+#include <type_traits> // enable_if, is_convertible
+#include <utility> // pair
+#include <vector> // vector
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/// ordered_map: a minimal map-like container that preserves insertion order
+/// for use within nlohmann::basic_json<ordered_map>
+template <class Key, class T, class IgnoredLess = std::less<Key>,
+          class Allocator = std::allocator<std::pair<const Key, T>>>
+                  struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
+{
+    using key_type = Key;
+    using mapped_type = T;
+    using Container = std::vector<std::pair<const Key, T>, Allocator>;
+    using iterator = typename Container::iterator;
+    using const_iterator = typename Container::const_iterator;
+    using size_type = typename Container::size_type;
+    using value_type = typename Container::value_type;
+#ifdef JSON_HAS_CPP_14
+    using key_compare = std::equal_to<>;
+#else
+    using key_compare = std::equal_to<Key>;
+#endif
+
+    // Explicit constructors instead of `using Container::Container`
+    // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
+    ordered_map() noexcept(noexcept(Container())) : Container{} {}
+    explicit ordered_map(const Allocator& alloc) noexcept(noexcept(Container(alloc))) : Container{alloc} {}
+    template <class It>
+    ordered_map(It first, It last, const Allocator& alloc = Allocator())
+        : Container{first, last, alloc} {}
+    ordered_map(std::initializer_list<value_type> init, const Allocator& alloc = Allocator() )
+        : Container{init, alloc} {}
+
+    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return {it, false};
+            }
+        }
+        Container::emplace_back(key, std::forward<T>(t));
+        return {std::prev(this->end()), true};
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    std::pair<iterator, bool> emplace(KeyType && key, T && t)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return {it, false};
+            }
+        }
+        Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
+        return {std::prev(this->end()), true};
+    }
+
+    T& operator[](const key_type& key)
+    {
+        return emplace(key, T{}).first->second;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    T & operator[](KeyType && key)
+    {
+        return emplace(std::forward<KeyType>(key), T{}).first->second;
+    }
+
+    const T& operator[](const key_type& key) const
+    {
+        return at(key);
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    const T & operator[](KeyType && key) const
+    {
+        return at(std::forward<KeyType>(key));
+    }
+
+    T& at(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    T & at(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    const T& at(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    const T & at(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it->second;
+            }
+        }
+
+        JSON_THROW(std::out_of_range("key not found"));
+    }
+
+    size_type erase(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                // Since we cannot move const Keys, re-construct them in place
+                for (auto next = it; ++next != this->end(); ++it)
+                {
+                    it->~value_type(); // Destroy but keep allocation
+                    new (&*it) value_type{std::move(*next)};
+                }
+                Container::pop_back();
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator erase(iterator pos)
+    {
+        return erase(pos, std::next(pos));
+    }
+
+    iterator erase(iterator first, iterator last)
+    {
+        if (first == last)
+        {
+            return first;
+        }
+
+        const auto elements_affected = std::distance(first, last);
+        const auto offset = std::distance(Container::begin(), first);
+
+        // This is the start situation. We need to delete elements_affected
+        // elements (3 in this example: e, f, g), and need to return an
+        // iterator past the last deleted element (h in this example).
+        // Note that offset is the distance from the start of the vector
+        // to first. We will need this later.
+
+        // [ a, b, c, d, e, f, g, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // Since we cannot move const Keys, we re-construct them in place.
+        // We start at first and re-construct (viz. copy) the elements from
+        // the back of the vector. Example for first iteration:
+
+        //               ,--------.
+        //               v        |   destroy e and re-construct with h
+        // [ a, b, c, d, e, f, g, h, i, j ]
+        //               ^        ^
+        //               it       it + elements_affected
+
+        for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
+        {
+            it->~value_type(); // destroy but keep allocation
+            new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
+        }
+
+        // [ a, b, c, d, h, i, j, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // remove the unneeded elements at the end of the vector
+        Container::resize(this->size() - static_cast<size_type>(elements_affected));
+
+        // [ a, b, c, d, h, i, j ]
+        //               ^        ^
+        //             first    last
+
+        // first is now pointing past the last deleted element, but we cannot
+        // use this iterator, because it may have been invalidated by the
+        // resize call. Instead, we can return begin() + offset.
+        return Container::begin() + offset;
+    }
+
+    size_type count(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    size_type count(KeyType && key) const // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    iterator find(const key_type& key)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
+    iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    const_iterator find(const key_type& key) const
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, key))
+            {
+                return it;
+            }
+        }
+        return Container::end();
+    }
+
+    std::pair<iterator, bool> insert( value_type&& value )
+    {
+        return emplace(value.first, std::move(value.second));
+    }
+
+    std::pair<iterator, bool> insert( const value_type& value )
+    {
+        for (auto it = this->begin(); it != this->end(); ++it)
+        {
+            if (m_compare(it->first, value.first))
+            {
+                return {it, false};
+            }
+        }
+        Container::push_back(value);
+        return {--this->end(), true};
+    }
+
+    template<typename InputIt>
+    using require_input_iter = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIt>::iterator_category,
+            std::input_iterator_tag>::value>::type;
+
+    template<typename InputIt, typename = require_input_iter<InputIt>>
+    void insert(InputIt first, InputIt last)
+    {
+        for (auto it = first; it != last; ++it)
+        {
+            insert(*it);
+        }
+    }
+
+private:
+    JSON_NO_UNIQUE_ADDRESS key_compare m_compare = key_compare();
+};
+
+NLOHMANN_JSON_NAMESPACE_END
+
+
+#if defined(JSON_HAS_CPP_17)
+    #if JSON_HAS_STATIC_RTTI
+        #include <any>
+    #endif
+    #include <string_view>
+#endif
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/*!
+@brief a class to store JSON values
+
+@internal
+@invariant The member variables @a m_value and @a m_type have the following
+relationship:
+- If `m_type == value_t::object`, then `m_value.object != nullptr`.
+- If `m_type == value_t::array`, then `m_value.array != nullptr`.
+- If `m_type == value_t::string`, then `m_value.string != nullptr`.
+The invariants are checked by member function assert_invariant().
+
+@note ObjectType trick from https://stackoverflow.com/a/9860911
+@endinternal
+
+@since version 1.0.0
+
+@nosubgrouping
+*/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-special-member-functions)
+    : public ::nlohmann::detail::json_base_class<CustomBaseClass>
+{
+  private:
+    template<detail::value_t> friend struct detail::external_constructor;
+
+    template<typename>
+    friend class ::nlohmann::json_pointer;
+    // can be restored when json_pointer backwards compatibility is removed
+    // friend ::nlohmann::json_pointer<StringType>;
+
+    template<typename BasicJsonType, typename InputType>
+    friend class ::nlohmann::detail::parser;
+    friend ::nlohmann::detail::serializer<basic_json>;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::iter_impl;
+    template<typename BasicJsonType, typename CharType>
+    friend class ::nlohmann::detail::binary_writer;
+    template<typename BasicJsonType, typename InputType, typename SAX>
+    friend class ::nlohmann::detail::binary_reader;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_parser;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
+    friend class ::nlohmann::detail::exception;
+
+    /// workaround type for MSVC
+    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
+    using json_base_class_t = ::nlohmann::detail::json_base_class<CustomBaseClass>;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // convenience aliases for types residing in namespace detail;
+    using lexer = ::nlohmann::detail::lexer_base<basic_json>;
+
+    template<typename InputAdapterType>
+    static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
+        InputAdapterType adapter,
+        detail::parser_callback_t<basic_json>cb = nullptr,
+        const bool allow_exceptions = true,
+        const bool ignore_comments = false
+                                 )
+    {
+        return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
+                std::move(cb), allow_exceptions, ignore_comments);
+    }
+
+  private:
+    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
+    template<typename BasicJsonType>
+    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
+    template<typename BasicJsonType>
+    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
+    template<typename Iterator>
+    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
+    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
+
+    template<typename CharType>
+    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
+
+    template<typename InputType>
+    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
+    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    using serializer = ::nlohmann::detail::serializer<basic_json>;
+
+  public:
+    using value_t = detail::value_t;
+    /// JSON Pointer, see @ref nlohmann::json_pointer
+    using json_pointer = ::nlohmann::json_pointer<StringType>;
+    template<typename T, typename SFINAE>
+    using json_serializer = JSONSerializer<T, SFINAE>;
+    /// how to treat decoding errors
+    using error_handler_t = detail::error_handler_t;
+    /// how to treat CBOR tags
+    using cbor_tag_handler_t = detail::cbor_tag_handler_t;
+    /// helper type for initializer lists of basic_json values
+    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
+
+    using input_format_t = detail::input_format_t;
+    /// SAX interface type, see @ref nlohmann::json_sax
+    using json_sax_t = json_sax<basic_json>;
+
+    ////////////////
+    // exceptions //
+    ////////////////
+
+    /// @name exceptions
+    /// Classes to implement user-defined exceptions.
+    /// @{
+
+    using exception = detail::exception;
+    using parse_error = detail::parse_error;
+    using invalid_iterator = detail::invalid_iterator;
+    using type_error = detail::type_error;
+    using out_of_range = detail::out_of_range;
+    using other_error = detail::other_error;
+
+    /// @}
+
+    /////////////////////
+    // container types //
+    /////////////////////
+
+    /// @name container types
+    /// The canonic container types to use @ref basic_json like any other STL
+    /// container.
+    /// @{
+
+    /// the type of elements in a basic_json container
+    using value_type = basic_json;
+
+    /// the type of an element reference
+    using reference = value_type&;
+    /// the type of an element const reference
+    using const_reference = const value_type&;
+
+    /// a type to represent differences between iterators
+    using difference_type = std::ptrdiff_t;
+    /// a type to represent container sizes
+    using size_type = std::size_t;
+
+    /// the allocator type
+    using allocator_type = AllocatorType<basic_json>;
+
+    /// the type of an element pointer
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    /// the type of an element const pointer
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+
+    /// an iterator for a basic_json container
+    using iterator = iter_impl<basic_json>;
+    /// a const iterator for a basic_json container
+    using const_iterator = iter_impl<const basic_json>;
+    /// a reverse iterator for a basic_json container
+    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
+    /// a const reverse iterator for a basic_json container
+    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
+
+    /// @}
+
+    /// @brief returns the allocator associated with the container
+    /// @sa https://json.nlohmann.me/api/basic_json/get_allocator/
+    static allocator_type get_allocator()
+    {
+        return allocator_type();
+    }
+
+    /// @brief returns version information on the library
+    /// @sa https://json.nlohmann.me/api/basic_json/meta/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json meta()
+    {
+        basic_json result;
+
+        result["copyright"] = "(C) 2013-2023 Niels Lohmann";
+        result["name"] = "JSON for Modern C++";
+        result["url"] = "https://github.com/nlohmann/json";
+        result["version"]["string"] =
+            detail::concat(std::to_string(NLOHMANN_JSON_VERSION_MAJOR), '.',
+                           std::to_string(NLOHMANN_JSON_VERSION_MINOR), '.',
+                           std::to_string(NLOHMANN_JSON_VERSION_PATCH));
+        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
+        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
+        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
+
+#ifdef _WIN32
+        result["platform"] = "win32";
+#elif defined __linux__
+        result["platform"] = "linux";
+#elif defined __APPLE__
+        result["platform"] = "apple";
+#elif defined __unix__
+        result["platform"] = "unix";
+#else
+        result["platform"] = "unknown";
+#endif
+
+#if defined(__ICC) || defined(__INTEL_COMPILER)
+        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
+#elif defined(__clang__)
+        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
+#elif defined(__GNUC__) || defined(__GNUG__)
+        result["compiler"] = {{"family", "gcc"}, {"version", detail::concat(
+                    std::to_string(__GNUC__), '.',
+                    std::to_string(__GNUC_MINOR__), '.',
+                    std::to_string(__GNUC_PATCHLEVEL__))
+            }
+        };
+#elif defined(__HP_cc) || defined(__HP_aCC)
+        result["compiler"] = "hp"
+#elif defined(__IBMCPP__)
+        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
+#elif defined(_MSC_VER)
+        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
+#elif defined(__PGI)
+        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
+#elif defined(__SUNPRO_CC)
+        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
+#else
+        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
+#endif
+
+#if defined(_MSVC_LANG)
+        result["compiler"]["c++"] = std::to_string(_MSVC_LANG);
+#elif defined(__cplusplus)
+        result["compiler"]["c++"] = std::to_string(__cplusplus);
+#else
+        result["compiler"]["c++"] = "unknown";
+#endif
+        return result;
+    }
+
+    ///////////////////////////
+    // JSON value data types //
+    ///////////////////////////
+
+    /// @name JSON value data types
+    /// The data types to store a JSON value. These types are derived from
+    /// the template arguments passed to class @ref basic_json.
+    /// @{
+
+    /// @brief default object key comparator type
+    /// The actual object key comparator type (@ref object_comparator_t) may be
+    /// different.
+    /// @sa https://json.nlohmann.me/api/basic_json/default_object_comparator_t/
+#if defined(JSON_HAS_CPP_14)
+    // use of transparent comparator avoids unnecessary repeated construction of temporaries
+    // in functions involving lookup by key with types other than object_t::key_type (aka. StringType)
+    using default_object_comparator_t = std::less<>;
+#else
+    using default_object_comparator_t = std::less<StringType>;
+#endif
+
+    /// @brief a type for an object
+    /// @sa https://json.nlohmann.me/api/basic_json/object_t/
+    using object_t = ObjectType<StringType,
+          basic_json,
+          default_object_comparator_t,
+          AllocatorType<std::pair<const StringType,
+          basic_json>>>;
+
+    /// @brief a type for an array
+    /// @sa https://json.nlohmann.me/api/basic_json/array_t/
+    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
+
+    /// @brief a type for a string
+    /// @sa https://json.nlohmann.me/api/basic_json/string_t/
+    using string_t = StringType;
+
+    /// @brief a type for a boolean
+    /// @sa https://json.nlohmann.me/api/basic_json/boolean_t/
+    using boolean_t = BooleanType;
+
+    /// @brief a type for a number (integer)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_integer_t/
+    using number_integer_t = NumberIntegerType;
+
+    /// @brief a type for a number (unsigned)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_unsigned_t/
+    using number_unsigned_t = NumberUnsignedType;
+
+    /// @brief a type for a number (floating-point)
+    /// @sa https://json.nlohmann.me/api/basic_json/number_float_t/
+    using number_float_t = NumberFloatType;
+
+    /// @brief a type for a packed binary type
+    /// @sa https://json.nlohmann.me/api/basic_json/binary_t/
+    using binary_t = nlohmann::byte_container_with_subtype<BinaryType>;
+
+    /// @brief object key comparator type
+    /// @sa https://json.nlohmann.me/api/basic_json/object_comparator_t/
+    using object_comparator_t = detail::actual_object_comparator_t<basic_json>;
+
+    /// @}
+
+  private:
+
+    /// helper for exception-safe object creation
+    template<typename T, typename... Args>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    static T* create(Args&& ... args)
+    {
+        AllocatorType<T> alloc;
+        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
+
+        auto deleter = [&](T * obj)
+        {
+            AllocatorTraits::deallocate(alloc, obj, 1);
+        };
+        std::unique_ptr<T, decltype(deleter)> obj(AllocatorTraits::allocate(alloc, 1), deleter);
+        AllocatorTraits::construct(alloc, obj.get(), std::forward<Args>(args)...);
+        JSON_ASSERT(obj != nullptr);
+        return obj.release();
+    }
+
+    ////////////////////////
+    // JSON value storage //
+    ////////////////////////
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    /*!
+    @brief a JSON value
+
+    The actual storage for a JSON value of the @ref basic_json class. This
+    union combines the different storage types for the JSON value types
+    defined in @ref value_t.
+
+    JSON type | value_t type    | used type
+    --------- | --------------- | ------------------------
+    object    | object          | pointer to @ref object_t
+    array     | array           | pointer to @ref array_t
+    string    | string          | pointer to @ref string_t
+    boolean   | boolean         | @ref boolean_t
+    number    | number_integer  | @ref number_integer_t
+    number    | number_unsigned | @ref number_unsigned_t
+    number    | number_float    | @ref number_float_t
+    binary    | binary          | pointer to @ref binary_t
+    null      | null            | *no value is stored*
+
+    @note Variable-length types (objects, arrays, and strings) are stored as
+    pointers. The size of the union should not exceed 64 bits if the default
+    value types are used.
+
+    @since version 1.0.0
+    */
+    union json_value
+    {
+        /// object (stored with pointer to save storage)
+        object_t* object;
+        /// array (stored with pointer to save storage)
+        array_t* array;
+        /// string (stored with pointer to save storage)
+        string_t* string;
+        /// binary (stored with pointer to save storage)
+        binary_t* binary;
+        /// boolean
+        boolean_t boolean;
+        /// number (integer)
+        number_integer_t number_integer;
+        /// number (unsigned integer)
+        number_unsigned_t number_unsigned;
+        /// number (floating-point)
+        number_float_t number_float;
+
+        /// default constructor (for null values)
+        json_value() = default;
+        /// constructor for booleans
+        json_value(boolean_t v) noexcept : boolean(v) {}
+        /// constructor for numbers (integer)
+        json_value(number_integer_t v) noexcept : number_integer(v) {}
+        /// constructor for numbers (unsigned)
+        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
+        /// constructor for numbers (floating-point)
+        json_value(number_float_t v) noexcept : number_float(v) {}
+        /// constructor for empty values of a given type
+        json_value(value_t t)
+        {
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    object = create<object_t>();
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    array = create<array_t>();
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    string = create<string_t>("");
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    binary = create<binary_t>();
+                    break;
+                }
+
+                case value_t::boolean:
+                {
+                    boolean = static_cast<boolean_t>(false);
+                    break;
+                }
+
+                case value_t::number_integer:
+                {
+                    number_integer = static_cast<number_integer_t>(0);
+                    break;
+                }
+
+                case value_t::number_unsigned:
+                {
+                    number_unsigned = static_cast<number_unsigned_t>(0);
+                    break;
+                }
+
+                case value_t::number_float:
+                {
+                    number_float = static_cast<number_float_t>(0.0);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    break;
+                }
+
+                case value_t::discarded:
+                default:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
+                    {
+                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.11.3", nullptr)); // LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+            }
+        }
+
+        /// constructor for strings
+        json_value(const string_t& value) : string(create<string_t>(value)) {}
+
+        /// constructor for rvalue strings
+        json_value(string_t&& value) : string(create<string_t>(std::move(value))) {}
+
+        /// constructor for objects
+        json_value(const object_t& value) : object(create<object_t>(value)) {}
+
+        /// constructor for rvalue objects
+        json_value(object_t&& value) : object(create<object_t>(std::move(value))) {}
+
+        /// constructor for arrays
+        json_value(const array_t& value) : array(create<array_t>(value)) {}
+
+        /// constructor for rvalue arrays
+        json_value(array_t&& value) : array(create<array_t>(std::move(value))) {}
+
+        /// constructor for binary arrays
+        json_value(const typename binary_t::container_type& value) : binary(create<binary_t>(value)) {}
+
+        /// constructor for rvalue binary arrays
+        json_value(typename binary_t::container_type&& value) : binary(create<binary_t>(std::move(value))) {}
+
+        /// constructor for binary arrays (internal type)
+        json_value(const binary_t& value) : binary(create<binary_t>(value)) {}
+
+        /// constructor for rvalue binary arrays (internal type)
+        json_value(binary_t&& value) : binary(create<binary_t>(std::move(value))) {}
+
+        void destroy(value_t t)
+        {
+            if (
+                (t == value_t::object && object == nullptr) ||
+                (t == value_t::array && array == nullptr) ||
+                (t == value_t::string && string == nullptr) ||
+                (t == value_t::binary && binary == nullptr)
+            )
+            {
+                //not initialized (e.g. due to exception in the ctor)
+                return;
+            }
+            if (t == value_t::array || t == value_t::object)
+            {
+                // flatten the current json_value to a heap-allocated stack
+                std::vector<basic_json> stack;
+
+                // move the top-level items to stack
+                if (t == value_t::array)
+                {
+                    stack.reserve(array->size());
+                    std::move(array->begin(), array->end(), std::back_inserter(stack));
+                }
+                else
+                {
+                    stack.reserve(object->size());
+                    for (auto&& it : *object)
+                    {
+                        stack.push_back(std::move(it.second));
+                    }
+                }
+
+                while (!stack.empty())
+                {
+                    // move the last item to local variable to be processed
+                    basic_json current_item(std::move(stack.back()));
+                    stack.pop_back();
+
+                    // if current_item is array/object, move
+                    // its children to the stack to be processed later
+                    if (current_item.is_array())
+                    {
+                        std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
+
+                        current_item.m_data.m_value.array->clear();
+                    }
+                    else if (current_item.is_object())
+                    {
+                        for (auto&& it : *current_item.m_data.m_value.object)
+                        {
+                            stack.push_back(std::move(it.second));
+                        }
+
+                        current_item.m_data.m_value.object->clear();
+                    }
+
+                    // it's now safe that current_item get destructed
+                    // since it doesn't have any children
+                }
+            }
+
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    AllocatorType<object_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    AllocatorType<array_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
+                    break;
+                }
+
+                case value_t::binary:
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
+                    break;
+                }
+
+                case value_t::null:
+                case value_t::boolean:
+                case value_t::number_integer:
+                case value_t::number_unsigned:
+                case value_t::number_float:
+                case value_t::discarded:
+                default:
+                {
+                    break;
+                }
+            }
+        }
+    };
+
+  private:
+    /*!
+    @brief checks the class invariants
+
+    This function asserts the class invariants. It needs to be called at the
+    end of every constructor to make sure that created objects respect the
+    invariant. Furthermore, it has to be called each time the type of a JSON
+    value is changed, because the invariant expresses a relationship between
+    @a m_type and @a m_value.
+
+    Furthermore, the parent relation is checked for arrays and objects: If
+    @a check_parents true and the value is an array or object, then the
+    container's elements must have the current value as parent.
+
+    @param[in] check_parents  whether the parent relation should be checked.
+               The value is true by default and should only be set to false
+               during destruction of objects when the invariant does not
+               need to hold.
+    */
+    void assert_invariant(bool check_parents = true) const noexcept
+    {
+        JSON_ASSERT(m_data.m_type != value_t::object || m_data.m_value.object != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::array || m_data.m_value.array != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::string || m_data.m_value.string != nullptr);
+        JSON_ASSERT(m_data.m_type != value_t::binary || m_data.m_value.binary != nullptr);
+
+#if JSON_DIAGNOSTICS
+        JSON_TRY
+        {
+            // cppcheck-suppress assertWithSideEffect
+            JSON_ASSERT(!check_parents || !is_structured() || std::all_of(begin(), end(), [this](const basic_json & j)
+            {
+                return j.m_parent == this;
+            }));
+        }
+        JSON_CATCH(...) {} // LCOV_EXCL_LINE
+#endif
+        static_cast<void>(check_parents);
+    }
+
+    void set_parents()
+    {
+#if JSON_DIAGNOSTICS
+        switch (m_data.m_type)
+        {
+            case value_t::array:
+            {
+                for (auto& element : *m_data.m_value.array)
+                {
+                    element.m_parent = this;
+                }
+                break;
+            }
+
+            case value_t::object:
+            {
+                for (auto& element : *m_data.m_value.object)
+                {
+                    element.second.m_parent = this;
+                }
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                break;
+        }
+#endif
+    }
+
+    iterator set_parents(iterator it, typename iterator::difference_type count_set_parents)
+    {
+#if JSON_DIAGNOSTICS
+        for (typename iterator::difference_type i = 0; i < count_set_parents; ++i)
+        {
+            (it + i)->m_parent = this;
+        }
+#else
+        static_cast<void>(count_set_parents);
+#endif
+        return it;
+    }
+
+    reference set_parent(reference j, std::size_t old_capacity = static_cast<std::size_t>(-1))
+    {
+#if JSON_DIAGNOSTICS
+        if (old_capacity != static_cast<std::size_t>(-1))
+        {
+            // see https://github.com/nlohmann/json/issues/2838
+            JSON_ASSERT(type() == value_t::array);
+            if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
+            {
+                // capacity has changed: update all parents
+                set_parents();
+                return j;
+            }
+        }
+
+        // ordered_json uses a vector internally, so pointers could have
+        // been invalidated; see https://github.com/nlohmann/json/issues/2962
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning(push )
+#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
+#endif
+        if (detail::is_ordered_map<object_t>::value)
+        {
+            set_parents();
+            return j;
+        }
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning( pop )
+#endif
+
+        j.m_parent = this;
+#else
+        static_cast<void>(j);
+        static_cast<void>(old_capacity);
+#endif
+        return j;
+    }
+
+  public:
+    //////////////////////////
+    // JSON parser callback //
+    //////////////////////////
+
+    /// @brief parser event types
+    /// @sa https://json.nlohmann.me/api/basic_json/parse_event_t/
+    using parse_event_t = detail::parse_event_t;
+
+    /// @brief per-element parser callback type
+    /// @sa https://json.nlohmann.me/api/basic_json/parser_callback_t/
+    using parser_callback_t = detail::parser_callback_t<basic_json>;
+
+    //////////////////
+    // constructors //
+    //////////////////
+
+    /// @name constructors and destructors
+    /// Constructors of class @ref basic_json, copy/move constructor, copy
+    /// assignment, static functions creating objects, and the destructor.
+    /// @{
+
+    /// @brief create an empty value with a given type
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(const value_t v)
+        : m_data(v)
+    {
+        assert_invariant();
+    }
+
+    /// @brief create a null object
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(std::nullptr_t = nullptr) noexcept // NOLINT(bugprone-exception-escape)
+        : basic_json(value_t::null)
+    {
+        assert_invariant();
+    }
+
+    /// @brief create a JSON value from compatible types
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename CompatibleType,
+               typename U = detail::uncvref_t<CompatibleType>,
+               detail::enable_if_t <
+                   !detail::is_basic_json<U>::value && detail::is_compatible_type<basic_json_t, U>::value, int > = 0 >
+    basic_json(CompatibleType && val) noexcept(noexcept( // NOLINT(bugprone-forwarding-reference-overload,bugprone-exception-escape)
+                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
+                                           std::forward<CompatibleType>(val))))
+    {
+        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief create a JSON value from an existing one
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
+    basic_json(const BasicJsonType& val)
+    {
+        using other_boolean_t = typename BasicJsonType::boolean_t;
+        using other_number_float_t = typename BasicJsonType::number_float_t;
+        using other_number_integer_t = typename BasicJsonType::number_integer_t;
+        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+        using other_string_t = typename BasicJsonType::string_t;
+        using other_object_t = typename BasicJsonType::object_t;
+        using other_array_t = typename BasicJsonType::array_t;
+        using other_binary_t = typename BasicJsonType::binary_t;
+
+        switch (val.type())
+        {
+            case value_t::boolean:
+                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
+                break;
+            case value_t::number_float:
+                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
+                break;
+            case value_t::number_integer:
+                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
+                break;
+            case value_t::number_unsigned:
+                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
+                break;
+            case value_t::string:
+                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
+                break;
+            case value_t::object:
+                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
+                break;
+            case value_t::array:
+                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
+                break;
+            case value_t::binary:
+                JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
+                break;
+            case value_t::null:
+                *this = nullptr;
+                break;
+            case value_t::discarded:
+                m_data.m_type = value_t::discarded;
+                break;
+            default:            // LCOV_EXCL_LINE
+                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+        }
+        JSON_ASSERT(m_data.m_type == val.type());
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief create a container (array or object) from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(initializer_list_t init,
+               bool type_deduction = true,
+               value_t manual_type = value_t::array)
+    {
+        // check if each element is an array with two elements whose first
+        // element is a string
+        bool is_an_object = std::all_of(init.begin(), init.end(),
+                                        [](const detail::json_ref<basic_json>& element_ref)
+        {
+            // The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
+            // (many string types can be constructed from 0 via its null-pointer guise, so we get a
+            // broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
+            return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
+        });
+
+        // adjust type if type deduction is not wanted
+        if (!type_deduction)
+        {
+            // if array is wanted, do not create an object though possible
+            if (manual_type == value_t::array)
+            {
+                is_an_object = false;
+            }
+
+            // if object is wanted but impossible, throw an exception
+            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
+            {
+                JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
+            }
+        }
+
+        if (is_an_object)
+        {
+            // the initializer list is a list of pairs -> create object
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+
+            for (auto& element_ref : init)
+            {
+                auto element = element_ref.moved_or_copied();
+                m_data.m_value.object->emplace(
+                    std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
+                    std::move((*element.m_data.m_value.array)[1]));
+            }
+        }
+        else
+        {
+            // the initializer list describes an array -> create array
+            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>(init.begin(), init.end());
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief explicitly create a binary array (without subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = init;
+        return res;
+    }
+
+    /// @brief explicitly create a binary array (with subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(const typename binary_t::container_type& init, typename binary_t::subtype_type subtype)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(init, subtype);
+        return res;
+    }
+
+    /// @brief explicitly create a binary array
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = std::move(init);
+        return res;
+    }
+
+    /// @brief explicitly create a binary array (with subtype)
+    /// @sa https://json.nlohmann.me/api/basic_json/binary/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json binary(typename binary_t::container_type&& init, typename binary_t::subtype_type subtype)
+    {
+        auto res = basic_json();
+        res.m_data.m_type = value_t::binary;
+        res.m_data.m_value = binary_t(std::move(init), subtype);
+        return res;
+    }
+
+    /// @brief explicitly create an array from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/array/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json array(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::array);
+    }
+
+    /// @brief explicitly create an object from an initializer list
+    /// @sa https://json.nlohmann.me/api/basic_json/object/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json object(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::object);
+    }
+
+    /// @brief construct an array with count copies of given value
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(size_type cnt, const basic_json& val):
+        m_data{cnt, val}
+    {
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief construct a JSON container given an iterator range
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    template < class InputIT, typename std::enable_if <
+                   std::is_same<InputIT, typename basic_json_t::iterator>::value ||
+                   std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
+    basic_json(InputIT first, InputIT last)
+    {
+        JSON_ASSERT(first.m_object != nullptr);
+        JSON_ASSERT(last.m_object != nullptr);
+
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible", nullptr));
+        }
+
+        // copy type from first iterator
+        m_data.m_type = first.m_object->m_data.m_type;
+
+        // check if iterator range is complete for primitive values
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
+                                         || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", first.m_object));
+                }
+                break;
+            }
+
+            case value_t::null:
+            case value_t::object:
+            case value_t::array:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+                break;
+        }
+
+        switch (m_data.m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_data.m_value.number_integer = first.m_object->m_data.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value.number_unsigned = first.m_object->m_data.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value.number_float = first.m_object->m_data.m_value.number_float;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value.boolean = first.m_object->m_data.m_value.boolean;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value = *first.m_object->m_data.m_value.string;
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_data.m_value.object = create<object_t>(first.m_it.object_iterator,
+                                        last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value.array = create<array_t>(first.m_it.array_iterator,
+                                                       last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value = *first.m_object->m_data.m_value.binary;
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(invalid_iterator::create(206, detail::concat("cannot construct with iterators from ", first.m_object->type_name()), first.m_object));
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    ///////////////////////////////////////
+    // other constructors and destructor //
+    ///////////////////////////////////////
+
+    template<typename JsonRef,
+             detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
+                                 std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
+    basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
+
+    /// @brief copy constructor
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(const basic_json& other)
+        : json_base_class_t(other)
+    {
+        m_data.m_type = other.m_data.m_type;
+        // check of passed value is valid
+        other.assert_invariant();
+
+        switch (m_data.m_type)
+        {
+            case value_t::object:
+            {
+                m_data.m_value = *other.m_data.m_value.object;
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value = *other.m_data.m_value.array;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value = *other.m_data.m_value.string;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value = other.m_data.m_value.boolean;
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                m_data.m_value = other.m_data.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value = other.m_data.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value = other.m_data.m_value.number_float;
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value = *other.m_data.m_value.binary;
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                break;
+        }
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief move constructor
+    /// @sa https://json.nlohmann.me/api/basic_json/basic_json/
+    basic_json(basic_json&& other) noexcept
+        : json_base_class_t(std::forward<json_base_class_t>(other)),
+          m_data(std::move(other.m_data))
+    {
+        // check that passed value is valid
+        other.assert_invariant(false);
+
+        // invalidate payload
+        other.m_data.m_type = value_t::null;
+        other.m_data.m_value = {};
+
+        set_parents();
+        assert_invariant();
+    }
+
+    /// @brief copy assignment
+    /// @sa https://json.nlohmann.me/api/basic_json/operator=/
+    basic_json& operator=(basic_json other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&&
+        std::is_nothrow_move_assignable<json_value>::value&&
+        std::is_nothrow_move_assignable<json_base_class_t>::value
+    )
+    {
+        // check that passed value is valid
+        other.assert_invariant();
+
+        using std::swap;
+        swap(m_data.m_type, other.m_data.m_type);
+        swap(m_data.m_value, other.m_data.m_value);
+        json_base_class_t::operator=(std::move(other));
+
+        set_parents();
+        assert_invariant();
+        return *this;
+    }
+
+    /// @brief destructor
+    /// @sa https://json.nlohmann.me/api/basic_json/~basic_json/
+    ~basic_json() noexcept
+    {
+        assert_invariant(false);
+    }
+
+    /// @}
+
+  public:
+    ///////////////////////
+    // object inspection //
+    ///////////////////////
+
+    /// @name object inspection
+    /// Functions to inspect the type of a JSON value.
+    /// @{
+
+    /// @brief serialization
+    /// @sa https://json.nlohmann.me/api/basic_json/dump/
+    string_t dump(const int indent = -1,
+                  const char indent_char = ' ',
+                  const bool ensure_ascii = false,
+                  const error_handler_t error_handler = error_handler_t::strict) const
+    {
+        string_t result;
+        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
+
+        if (indent >= 0)
+        {
+            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
+        }
+        else
+        {
+            s.dump(*this, false, ensure_ascii, 0);
+        }
+
+        return result;
+    }
+
+    /// @brief return the type of the JSON value (explicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/type/
+    constexpr value_t type() const noexcept
+    {
+        return m_data.m_type;
+    }
+
+    /// @brief return whether type is primitive
+    /// @sa https://json.nlohmann.me/api/basic_json/is_primitive/
+    constexpr bool is_primitive() const noexcept
+    {
+        return is_null() || is_string() || is_boolean() || is_number() || is_binary();
+    }
+
+    /// @brief return whether type is structured
+    /// @sa https://json.nlohmann.me/api/basic_json/is_structured/
+    constexpr bool is_structured() const noexcept
+    {
+        return is_array() || is_object();
+    }
+
+    /// @brief return whether value is null
+    /// @sa https://json.nlohmann.me/api/basic_json/is_null/
+    constexpr bool is_null() const noexcept
+    {
+        return m_data.m_type == value_t::null;
+    }
+
+    /// @brief return whether value is a boolean
+    /// @sa https://json.nlohmann.me/api/basic_json/is_boolean/
+    constexpr bool is_boolean() const noexcept
+    {
+        return m_data.m_type == value_t::boolean;
+    }
+
+    /// @brief return whether value is a number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number/
+    constexpr bool is_number() const noexcept
+    {
+        return is_number_integer() || is_number_float();
+    }
+
+    /// @brief return whether value is an integer number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_integer/
+    constexpr bool is_number_integer() const noexcept
+    {
+        return m_data.m_type == value_t::number_integer || m_data.m_type == value_t::number_unsigned;
+    }
+
+    /// @brief return whether value is an unsigned integer number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_unsigned/
+    constexpr bool is_number_unsigned() const noexcept
+    {
+        return m_data.m_type == value_t::number_unsigned;
+    }
+
+    /// @brief return whether value is a floating-point number
+    /// @sa https://json.nlohmann.me/api/basic_json/is_number_float/
+    constexpr bool is_number_float() const noexcept
+    {
+        return m_data.m_type == value_t::number_float;
+    }
+
+    /// @brief return whether value is an object
+    /// @sa https://json.nlohmann.me/api/basic_json/is_object/
+    constexpr bool is_object() const noexcept
+    {
+        return m_data.m_type == value_t::object;
+    }
+
+    /// @brief return whether value is an array
+    /// @sa https://json.nlohmann.me/api/basic_json/is_array/
+    constexpr bool is_array() const noexcept
+    {
+        return m_data.m_type == value_t::array;
+    }
+
+    /// @brief return whether value is a string
+    /// @sa https://json.nlohmann.me/api/basic_json/is_string/
+    constexpr bool is_string() const noexcept
+    {
+        return m_data.m_type == value_t::string;
+    }
+
+    /// @brief return whether value is a binary array
+    /// @sa https://json.nlohmann.me/api/basic_json/is_binary/
+    constexpr bool is_binary() const noexcept
+    {
+        return m_data.m_type == value_t::binary;
+    }
+
+    /// @brief return whether value is discarded
+    /// @sa https://json.nlohmann.me/api/basic_json/is_discarded/
+    constexpr bool is_discarded() const noexcept
+    {
+        return m_data.m_type == value_t::discarded;
+    }
+
+    /// @brief return the type of the JSON value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_value_t/
+    constexpr operator value_t() const noexcept
+    {
+        return m_data.m_type;
+    }
+
+    /// @}
+
+  private:
+    //////////////////
+    // value access //
+    //////////////////
+
+    /// get a boolean (explicit)
+    boolean_t get_impl(boolean_t* /*unused*/) const
+    {
+        if (JSON_HEDLEY_LIKELY(is_boolean()))
+        {
+            return m_data.m_value.boolean;
+        }
+
+        JSON_THROW(type_error::create(302, detail::concat("type must be boolean, but is ", type_name()), this));
+    }
+
+    /// get a pointer to the value (object)
+    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
+    {
+        return is_object() ? m_data.m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (object)
+    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
+    {
+        return is_object() ? m_data.m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
+    {
+        return is_array() ? m_data.m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
+    {
+        return is_array() ? m_data.m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
+    {
+        return is_string() ? m_data.m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
+    {
+        return is_string() ? m_data.m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
+    {
+        return is_boolean() ? &m_data.m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
+    {
+        return is_boolean() ? &m_data.m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
+    {
+        return is_number_integer() ? &m_data.m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
+    {
+        return is_number_integer() ? &m_data.m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
+    {
+        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
+    {
+        return is_number_unsigned() ? &m_data.m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
+    {
+        return is_number_float() ? &m_data.m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
+    {
+        return is_number_float() ? &m_data.m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
+    {
+        return is_binary() ? m_data.m_value.binary : nullptr;
+    }
+
+    /// get a pointer to the value (binary)
+    constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
+    {
+        return is_binary() ? m_data.m_value.binary : nullptr;
+    }
+
+    /*!
+    @brief helper function to implement get_ref()
+
+    This function helps to implement get_ref() without code duplication for
+    const and non-const overloads
+
+    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
+
+    @throw type_error.303 if ReferenceType does not match underlying value
+    type of the current JSON
+    */
+    template<typename ReferenceType, typename ThisType>
+    static ReferenceType get_ref_impl(ThisType& obj)
+    {
+        // delegate the call to get_ptr<>()
+        auto* ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
+
+        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
+        {
+            return *ptr;
+        }
+
+        JSON_THROW(type_error::create(303, detail::concat("incompatible ReferenceType for get_ref, actual type is ", obj.type_name()), &obj));
+    }
+
+  public:
+    /// @name value access
+    /// Direct access to the stored value of a JSON value.
+    /// @{
+
+    /// @brief get a pointer value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>()
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /// @brief get a pointer value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ptr/
+    template < typename PointerType, typename std::enable_if <
+                   std::is_pointer<PointerType>::value&&
+                   std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
+    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>() const
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+  private:
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType ret;
+    JSONSerializer<ValueType>::from_json(*this, ret);
+    return ret;
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+    - @ref json_serializer<ValueType> does not have a `from_json()` method of
+      the form `ValueType from_json(const basic_json&)`
+
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get__ValueType_const}
+
+    @since version 2.1.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   detail::is_default_constructible<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get_impl(detail::priority_tag<0> /*unused*/) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
+    {
+        auto ret = ValueType();
+        JSONSerializer<ValueType>::from_json(*this, ret);
+        return ret;
+    }
+
+    /*!
+    @brief get a value (explicit); special case
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    return JSONSerializer<ValueType>::from_json(*this);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json and
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `ValueType from_json(const basic_json&)`
+
+    @note If @ref json_serializer<ValueType> has both overloads of
+    `from_json()`, this one is chosen.
+
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @since version 2.1.0
+    */
+    template < typename ValueType,
+               detail::enable_if_t <
+                   detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType get_impl(detail::priority_tag<1> /*unused*/) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
+    {
+        return JSONSerializer<ValueType>::from_json(*this);
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads converts the current @ref basic_json in a different
+    @ref basic_json type
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this, converted into @a BasicJsonType
+
+    @complexity Depending on the implementation of the called `from_json()`
+                method.
+
+    @since version 3.2.0
+    */
+    template < typename BasicJsonType,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value,
+                   int > = 0 >
+    BasicJsonType get_impl(detail::priority_tag<2> /*unused*/) const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads avoids a lot of template boilerplate, it can be seen as the
+    identity method
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this
+
+    @complexity Constant.
+
+    @since version 2.1.0
+    */
+    template<typename BasicJsonType,
+             detail::enable_if_t<
+                 std::is_same<BasicJsonType, basic_json_t>::value,
+                 int> = 0>
+    basic_json get_impl(detail::priority_tag<3> /*unused*/) const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+    @copydoc get()
+    */
+    template<typename PointerType,
+             detail::enable_if_t<
+                 std::is_pointer<PointerType>::value,
+                 int> = 0>
+    constexpr auto get_impl(detail::priority_tag<4> /*unused*/) const noexcept
+    -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+  public:
+    /*!
+    @brief get a (pointer) value (explicit)
+
+    Performs explicit type conversion between the JSON value and a compatible value if required.
+
+    - If the requested type is a pointer to the internally stored JSON value that pointer is returned.
+    No copies are made.
+
+    - If the requested type is the current @ref basic_json, or a different @ref basic_json convertible
+    from the current @ref basic_json.
+
+    - Otherwise the value is converted by calling the @ref json_serializer<ValueType> `from_json()`
+    method.
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @tparam ValueType if necessary
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws if conversion is required
+
+    @since version 2.1.0
+    */
+    template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>>
+#if defined(JSON_HAS_CPP_14)
+    constexpr
+#endif
+    auto get() const noexcept(
+    noexcept(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {})))
+    -> decltype(std::declval<const basic_json_t&>().template get_impl<ValueType>(detail::priority_tag<4> {}))
+    {
+        // we cannot static_assert on ValueTypeCV being non-const, because
+        // there is support for get<const basic_json_t>(), which is why we
+        // still need the uncvref
+        static_assert(!std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        return get_impl<ValueType>(detail::priority_tag<4> {});
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+
+    Explicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning The pointer becomes invalid if the underlying JSON object
+    changes.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get__PointerType}
+
+    @sa see @ref get_ptr() for explicit pointer-member access
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /// @brief get a value (explicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_to/
+    template < typename ValueType,
+               detail::enable_if_t <
+                   !detail::is_basic_json<ValueType>::value&&
+                   detail::has_from_json<basic_json_t, ValueType>::value,
+                   int > = 0 >
+    ValueType & get_to(ValueType& v) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<ValueType>::from_json(*this, v);
+        return v;
+    }
+
+    // specialization to allow calling get_to with a basic_json value
+    // see https://github.com/nlohmann/json/issues/2175
+    template<typename ValueType,
+             detail::enable_if_t <
+                 detail::is_basic_json<ValueType>::value,
+                 int> = 0>
+    ValueType & get_to(ValueType& v) const
+    {
+        v = *this;
+        return v;
+    }
+
+    template <
+        typename T, std::size_t N,
+        typename Array = T (&)[N], // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+        detail::enable_if_t <
+            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
+    Array get_to(T (&v)[N]) const // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+    noexcept(noexcept(JSONSerializer<Array>::from_json(
+                          std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<Array>::from_json(*this, v);
+        return v;
+    }
+
+    /// @brief get a reference value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
+    template<typename ReferenceType, typename std::enable_if<
+                 std::is_reference<ReferenceType>::value, int>::type = 0>
+    ReferenceType get_ref()
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /// @brief get a reference value (implicit)
+    /// @sa https://json.nlohmann.me/api/basic_json/get_ref/
+    template < typename ReferenceType, typename std::enable_if <
+                   std::is_reference<ReferenceType>::value&&
+                   std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
+    ReferenceType get_ref() const
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a value (implicit)
+
+    Implicit type conversion between the JSON value and a compatible value.
+    The call is realized by calling @ref get() const.
+
+    @tparam ValueType non-pointer type compatible to the JSON value, for
+    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+    `std::vector` types for JSON arrays. The character type of @ref string_t
+    as well as an initializer list of this type is excluded to avoid
+    ambiguities as these types implicitly convert to `std::string`.
+
+    @return copy of the JSON value, converted to type @a ValueType
+
+    @throw type_error.302 in case passed type @a ValueType is incompatible
+    to the JSON value type (e.g., the JSON value is of type boolean, but a
+    string is requested); see example below
+
+    @complexity Linear in the size of the JSON value.
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,operator__ValueType}
+
+    @since version 1.0.0
+    */
+    template < typename ValueType, typename std::enable_if <
+                   detail::conjunction <
+                       detail::negation<std::is_pointer<ValueType>>,
+                       detail::negation<std::is_same<ValueType, std::nullptr_t>>,
+                       detail::negation<std::is_same<ValueType, detail::json_ref<basic_json>>>,
+                                        detail::negation<std::is_same<ValueType, typename string_t::value_type>>,
+                                        detail::negation<detail::is_basic_json<ValueType>>,
+                                        detail::negation<std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>>,
+#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
+                                                detail::negation<std::is_same<ValueType, std::string_view>>,
+#endif
+#if defined(JSON_HAS_CPP_17) && JSON_HAS_STATIC_RTTI
+                                                detail::negation<std::is_same<ValueType, std::any>>,
+#endif
+                                                detail::is_detected_lazy<detail::get_template_function, const basic_json_t&, ValueType>
+                                                >::value, int >::type = 0 >
+                                        JSON_EXPLICIT operator ValueType() const
+    {
+        // delegate the call to get<>() const
+        return get<ValueType>();
+    }
+
+    /// @brief get a binary value
+    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
+    binary_t& get_binary()
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
+        }
+
+        return *get_ptr<binary_t*>();
+    }
+
+    /// @brief get a binary value
+    /// @sa https://json.nlohmann.me/api/basic_json/get_binary/
+    const binary_t& get_binary() const
+    {
+        if (!is_binary())
+        {
+            JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
+        }
+
+        return *get_ptr<const binary_t*>();
+    }
+
+    /// @}
+
+    ////////////////////
+    // element access //
+    ////////////////////
+
+    /// @name element access
+    /// Access to the JSON value.
+    /// @{
+
+    /// @brief access specified array element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(size_type idx)
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return set_parent(m_data.m_value.array->at(idx));
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+    }
+
+    /// @brief access specified array element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(size_type idx) const
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_data.m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(const typename object_t::key_type& key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(key);
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
+        }
+        return set_parent(it->second);
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    reference at(KeyType && key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
+        }
+        return set_parent(it->second);
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(const typename object_t::key_type& key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(key);
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", key, "' not found"), this));
+        }
+        return it->second;
+    }
+
+    /// @brief access specified object element with bounds checking
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    const_reference at(KeyType && key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
+        }
+
+        auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it == m_data.m_value.object->end())
+        {
+            JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
+        }
+        return it->second;
+    }
+
+    /// @brief access specified array element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](size_type idx)
+    {
+        // implicitly convert null value to an empty array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value.array = create<array_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // fill up array with null values if given idx is outside range
+            if (idx >= m_data.m_value.array->size())
+            {
+#if JSON_DIAGNOSTICS
+                // remember array size & capacity before resizing
+                const auto old_size = m_data.m_value.array->size();
+                const auto old_capacity = m_data.m_value.array->capacity();
+#endif
+                m_data.m_value.array->resize(idx + 1);
+
+#if JSON_DIAGNOSTICS
+                if (JSON_HEDLEY_UNLIKELY(m_data.m_value.array->capacity() != old_capacity))
+                {
+                    // capacity has changed: update all parents
+                    set_parents();
+                }
+                else
+                {
+                    // set parent for values added above
+                    set_parents(begin() + static_cast<typename iterator::difference_type>(old_size), static_cast<typename iterator::difference_type>(idx + 1 - old_size));
+                }
+#endif
+                assert_invariant();
+            }
+
+            return m_data.m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
+    }
+
+    /// @brief access specified array element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](size_type idx) const
+    {
+        // const operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            return m_data.m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](typename object_t::key_type key)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
+            return set_parent(result.first->second);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](const typename object_t::key_type& key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto it = m_data.m_value.object->find(key);
+            JSON_ASSERT(it != m_data.m_value.object->end());
+            return it->second;
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    // these two functions resolve a (const) char * ambiguity affecting Clang and MSVC
+    // (they seemingly cannot be constrained to resolve the ambiguity)
+    template<typename T>
+    reference operator[](T* key)
+    {
+        return operator[](typename object_t::key_type(key));
+    }
+
+    template<typename T>
+    const_reference operator[](T* key) const
+    {
+        return operator[](typename object_t::key_type(key));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    reference operator[](KeyType && key)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto result = m_data.m_value.object->emplace(std::forward<KeyType>(key), nullptr);
+            return set_parent(result.first->second);
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+    /// @brief access specified object element
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    const_reference operator[](KeyType && key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+            JSON_ASSERT(it != m_data.m_value.object->end());
+            return it->second;
+        }
+
+        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
+    }
+
+  private:
+    template<typename KeyType>
+    using is_comparable_with_object_key = detail::is_comparable <
+        object_comparator_t, const typename object_t::key_type&, KeyType >;
+
+    template<typename ValueType>
+    using value_return_type = std::conditional <
+        detail::is_c_string_uncvref<ValueType>::value,
+        string_t, typename std::decay<ValueType>::type >;
+
+  public:
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, detail::enable_if_t <
+                   !detail::is_transparent<object_comparator_t>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(key);
+            if (it != end())
+            {
+                return it->template get<ValueType>();
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   !detail::is_transparent<object_comparator_t>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(const typename object_t::key_type& key, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(key);
+            if (it != end())
+            {
+                return it->template get<ReturnType>();
+            }
+
+            return std::forward<ValueType>(default_value);
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class KeyType, detail::enable_if_t <
+                   detail::is_transparent<object_comparator_t>::value
+                   && !detail::is_json_pointer<KeyType>::value
+                   && is_comparable_with_object_key<KeyType>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(KeyType && key, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(std::forward<KeyType>(key));
+            if (it != end())
+            {
+                return it->template get<ValueType>();
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class KeyType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_transparent<object_comparator_t>::value
+                   && !detail::is_json_pointer<KeyType>::value
+                   && is_comparable_with_object_key<KeyType>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(KeyType && key, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(std::forward<KeyType>(key));
+            if (it != end())
+            {
+                return it->template get<ReturnType>();
+            }
+
+            return std::forward<ValueType>(default_value);
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, detail::enable_if_t <
+                   detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if pointer resolves a value, return it or use default value
+            JSON_TRY
+            {
+                return ptr.get_checked(this).template get<ValueType>();
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return default_value;
+            }
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    /// @brief access specified object element via JSON Pointer with default value
+    /// @sa https://json.nlohmann.me/api/basic_json/value/
+    template < class ValueType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    ReturnType value(const json_pointer& ptr, ValueType && default_value) const
+    {
+        // value only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if pointer resolves a value, return it or use default value
+            JSON_TRY
+            {
+                return ptr.get_checked(this).template get<ReturnType>();
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return std::forward<ValueType>(default_value);
+            }
+        }
+
+        JSON_THROW(type_error::create(306, detail::concat("cannot use value() with ", type_name()), this));
+    }
+
+    template < class ValueType, class BasicJsonType, detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value
+                   && detail::is_getable<basic_json_t, ValueType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    ValueType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, const ValueType& default_value) const
+    {
+        return value(ptr.convert(), default_value);
+    }
+
+    template < class ValueType, class BasicJsonType, class ReturnType = typename value_return_type<ValueType>::type,
+               detail::enable_if_t <
+                   detail::is_basic_json<BasicJsonType>::value
+                   && detail::is_getable<basic_json_t, ReturnType>::value
+                   && !std::is_same<value_t, detail::uncvref_t<ValueType>>::value, int > = 0 >
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    ReturnType value(const ::nlohmann::json_pointer<BasicJsonType>& ptr, ValueType && default_value) const
+    {
+        return value(ptr.convert(), std::forward<ValueType>(default_value));
+    }
+
+    /// @brief access the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/front/
+    reference front()
+    {
+        return *begin();
+    }
+
+    /// @brief access the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/front/
+    const_reference front() const
+    {
+        return *cbegin();
+    }
+
+    /// @brief access the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/back/
+    reference back()
+    {
+        auto tmp = end();
+        --tmp;
+        return *tmp;
+    }
+
+    /// @brief access the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/back/
+    const_reference back() const
+    {
+        auto tmp = cend();
+        --tmp;
+        return *tmp;
+    }
+
+    /// @brief remove element given an iterator
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template < class IteratorType, detail::enable_if_t <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
+    IteratorType erase(IteratorType pos)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        IteratorType result = end();
+
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
+                {
+                    JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
+                    m_data.m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
+                    m_data.m_value.binary = nullptr;
+                }
+
+                m_data.m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return result;
+    }
+
+    /// @brief remove elements given an iterator range
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template < class IteratorType, detail::enable_if_t <
+                   std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
+                   std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int > = 0 >
+    IteratorType erase(IteratorType first, IteratorType last)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value", this));
+        }
+
+        IteratorType result = end();
+
+        switch (m_data.m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            case value_t::binary:
+            {
+                if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
+                                       || !last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range", this));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
+                    m_data.m_value.string = nullptr;
+                }
+                else if (is_binary())
+                {
+                    AllocatorType<binary_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
+                    m_data.m_value.binary = nullptr;
+                }
+
+                m_data.m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_data.m_value.object->erase(first.m_it.object_iterator,
+                                              last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_data.m_value.array->erase(first.m_it.array_iterator,
+                                             last.m_it.array_iterator);
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return result;
+    }
+
+  private:
+    template < typename KeyType, detail::enable_if_t <
+                   detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    size_type erase_internal(KeyType && key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        return m_data.m_value.object->erase(std::forward<KeyType>(key));
+    }
+
+    template < typename KeyType, detail::enable_if_t <
+                   !detail::has_erase_with_key_type<basic_json_t, KeyType>::value, int > = 0 >
+    size_type erase_internal(KeyType && key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+
+        const auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
+        if (it != m_data.m_value.object->end())
+        {
+            m_data.m_value.object->erase(it);
+            return 1;
+        }
+        return 0;
+    }
+
+  public:
+
+    /// @brief remove element from a JSON object given a key
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    size_type erase(const typename object_t::key_type& key)
+    {
+        // the indirection via erase_internal() is added to avoid making this
+        // function a template and thus de-rank it during overload resolution
+        return erase_internal(key);
+    }
+
+    /// @brief remove element from a JSON object given a key
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    size_type erase(KeyType && key)
+    {
+        return erase_internal(std::forward<KeyType>(key));
+    }
+
+    /// @brief remove element from a JSON array given an index
+    /// @sa https://json.nlohmann.me/api/basic_json/erase/
+    void erase(const size_type idx)
+    {
+        // this erase only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
+            {
+                JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), this));
+            }
+
+            m_data.m_value.array->erase(m_data.m_value.array->begin() + static_cast<difference_type>(idx));
+        }
+        else
+        {
+            JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
+        }
+    }
+
+    /// @}
+
+    ////////////
+    // lookup //
+    ////////////
+
+    /// @name lookup
+    /// @{
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    iterator find(const typename object_t::key_type& key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(key);
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    const_iterator find(const typename object_t::key_type& key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(key);
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    iterator find(KeyType && key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
+        }
+
+        return result;
+    }
+
+    /// @brief find an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/find/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    const_iterator find(KeyType && key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_data.m_value.object->find(std::forward<KeyType>(key));
+        }
+
+        return result;
+    }
+
+    /// @brief returns the number of occurrences of a key in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/count/
+    size_type count(const typename object_t::key_type& key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_data.m_value.object->count(key) : 0;
+    }
+
+    /// @brief returns the number of occurrences of a key in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/count/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    size_type count(KeyType && key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_data.m_value.object->count(std::forward<KeyType>(key)) : 0;
+    }
+
+    /// @brief check the existence of an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    bool contains(const typename object_t::key_type& key) const
+    {
+        return is_object() && m_data.m_value.object->find(key) != m_data.m_value.object->end();
+    }
+
+    /// @brief check the existence of an element in a JSON object
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    template<class KeyType, detail::enable_if_t<
+                 detail::is_usable_as_basic_json_key_type<basic_json_t, KeyType>::value, int> = 0>
+    bool contains(KeyType && key) const
+    {
+        return is_object() && m_data.m_value.object->find(std::forward<KeyType>(key)) != m_data.m_value.object->end();
+    }
+
+    /// @brief check the existence of an element in a JSON object given a JSON pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/contains/
+    bool contains(const json_pointer& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    bool contains(const typename ::nlohmann::json_pointer<BasicJsonType>& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    /// @}
+
+    ///////////////
+    // iterators //
+    ///////////////
+
+    /// @name iterators
+    /// @{
+
+    /// @brief returns an iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/begin/
+    iterator begin() noexcept
+    {
+        iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /// @brief returns an iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/begin/
+    const_iterator begin() const noexcept
+    {
+        return cbegin();
+    }
+
+    /// @brief returns a const iterator to the first element
+    /// @sa https://json.nlohmann.me/api/basic_json/cbegin/
+    const_iterator cbegin() const noexcept
+    {
+        const_iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/end/
+    iterator end() noexcept
+    {
+        iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/end/
+    const_iterator end() const noexcept
+    {
+        return cend();
+    }
+
+    /// @brief returns an iterator to one past the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/cend/
+    const_iterator cend() const noexcept
+    {
+        const_iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /// @brief returns an iterator to the reverse-beginning
+    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
+    reverse_iterator rbegin() noexcept
+    {
+        return reverse_iterator(end());
+    }
+
+    /// @brief returns an iterator to the reverse-beginning
+    /// @sa https://json.nlohmann.me/api/basic_json/rbegin/
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return crbegin();
+    }
+
+    /// @brief returns an iterator to the reverse-end
+    /// @sa https://json.nlohmann.me/api/basic_json/rend/
+    reverse_iterator rend() noexcept
+    {
+        return reverse_iterator(begin());
+    }
+
+    /// @brief returns an iterator to the reverse-end
+    /// @sa https://json.nlohmann.me/api/basic_json/rend/
+    const_reverse_iterator rend() const noexcept
+    {
+        return crend();
+    }
+
+    /// @brief returns a const reverse iterator to the last element
+    /// @sa https://json.nlohmann.me/api/basic_json/crbegin/
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return const_reverse_iterator(cend());
+    }
+
+    /// @brief returns a const reverse iterator to one before the first
+    /// @sa https://json.nlohmann.me/api/basic_json/crend/
+    const_reverse_iterator crend() const noexcept
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
+  public:
+    /// @brief wrapper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use @ref items() instead;
+    ///             that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /// @brief wrapper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    /// @deprecated This function is deprecated since 3.1.0 and will be removed in
+    ///         version 4.0.0 of the library. Please use @ref items() instead;
+    ///         that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
+    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /// @brief helper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    iteration_proxy<iterator> items() noexcept
+    {
+        return iteration_proxy<iterator>(*this);
+    }
+
+    /// @brief helper to access iterator member functions in range-based for
+    /// @sa https://json.nlohmann.me/api/basic_json/items/
+    iteration_proxy<const_iterator> items() const noexcept
+    {
+        return iteration_proxy<const_iterator>(*this);
+    }
+
+    /// @}
+
+    //////////////
+    // capacity //
+    //////////////
+
+    /// @name capacity
+    /// @{
+
+    /// @brief checks whether the container is empty.
+    /// @sa https://json.nlohmann.me/api/basic_json/empty/
+    bool empty() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return true;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::empty()
+                return m_data.m_value.array->empty();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::empty()
+                return m_data.m_value.object->empty();
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types are nonempty
+                return false;
+            }
+        }
+    }
+
+    /// @brief returns the number of elements
+    /// @sa https://json.nlohmann.me/api/basic_json/size/
+    size_type size() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return 0;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::size()
+                return m_data.m_value.array->size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::size()
+                return m_data.m_value.object->size();
+            }
+
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types have size 1
+                return 1;
+            }
+        }
+    }
+
+    /// @brief returns the maximum possible number of elements
+    /// @sa https://json.nlohmann.me/api/basic_json/max_size/
+    size_type max_size() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::array:
+            {
+                // delegate call to array_t::max_size()
+                return m_data.m_value.array->max_size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::max_size()
+                return m_data.m_value.object->max_size();
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // all other types have max_size() == size()
+                return size();
+            }
+        }
+    }
+
+    /// @}
+
+    ///////////////
+    // modifiers //
+    ///////////////
+
+    /// @name modifiers
+    /// @{
+
+    /// @brief clears the contents
+    /// @sa https://json.nlohmann.me/api/basic_json/clear/
+    void clear() noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_data.m_value.number_integer = 0;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value.number_unsigned = 0;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value.number_float = 0.0;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value.boolean = false;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value.string->clear();
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value.binary->clear();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value.array->clear();
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_data.m_value.object->clear();
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                break;
+        }
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(basic_json&& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (move semantics)
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->push_back(std::move(val));
+        set_parent(m_data.m_value.array->back(), old_capacity);
+        // if val is moved from, basic_json move constructor marks it null, so we do not call the destructor
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(basic_json&& val)
+    {
+        push_back(std::move(val));
+        return *this;
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(const basic_json& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->push_back(val);
+        set_parent(m_data.m_value.array->back(), old_capacity);
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(const basic_json& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(const typename object_t::value_type& val)
+    {
+        // push_back only works for null objects or objects
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(308, detail::concat("cannot use push_back() with ", type_name()), this));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to object
+        auto res = m_data.m_value.object->insert(val);
+        set_parent(res.first->second);
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(const typename object_t::value_type& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/push_back/
+    void push_back(initializer_list_t init)
+    {
+        if (is_object() && init.size() == 2 && (*init.begin())->is_string())
+        {
+            basic_json&& key = init.begin()->moved_or_copied();
+            push_back(typename object_t::value_type(
+                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
+        }
+        else
+        {
+            push_back(basic_json(init));
+        }
+    }
+
+    /// @brief add an object to an object
+    /// @sa https://json.nlohmann.me/api/basic_json/operator+=/
+    reference operator+=(initializer_list_t init)
+    {
+        push_back(init);
+        return *this;
+    }
+
+    /// @brief add an object to an array
+    /// @sa https://json.nlohmann.me/api/basic_json/emplace_back/
+    template<class... Args>
+    reference emplace_back(Args&& ... args)
+    {
+        // emplace_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
+        {
+            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_data.m_type = value_t::array;
+            m_data.m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+        const auto old_capacity = m_data.m_value.array->capacity();
+        m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
+        return set_parent(m_data.m_value.array->back(), old_capacity);
+    }
+
+    /// @brief add an object to an object if key does not exist
+    /// @sa https://json.nlohmann.me/api/basic_json/emplace/
+    template<class... Args>
+    std::pair<iterator, bool> emplace(Args&& ... args)
+    {
+        // emplace only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
+        {
+            JSON_THROW(type_error::create(311, detail::concat("cannot use emplace() with ", type_name()), this));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+        auto res = m_data.m_value.object->emplace(std::forward<Args>(args)...);
+        set_parent(res.first->second);
+
+        // create result iterator and set iterator to the result of emplace
+        auto it = begin();
+        it.m_it.object_iterator = res.first;
+
+        // return pair of iterator and boolean
+        return {it, res.second};
+    }
+
+    /// Helper for insertion of an iterator
+    /// @note: This uses std::distance to support GCC 4.8,
+    ///        see https://github.com/nlohmann/json/pull/1257
+    template<typename... Args>
+    iterator insert_iterator(const_iterator pos, Args&& ... args)
+    {
+        iterator result(this);
+        JSON_ASSERT(m_data.m_value.array != nullptr);
+
+        auto insert_pos = std::distance(m_data.m_value.array->begin(), pos.m_it.array_iterator);
+        m_data.m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
+        result.m_it.array_iterator = m_data.m_value.array->begin() + insert_pos;
+
+        // This could have been written as:
+        // result.m_it.array_iterator = m_data.m_value.array->insert(pos.m_it.array_iterator, cnt, val);
+        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
+
+        set_parents();
+        return result;
+    }
+
+    /// @brief inserts element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, val);
+        }
+
+        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+    }
+
+    /// @brief inserts element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, basic_json&& val)
+    {
+        return insert(pos, val);
+    }
+
+    /// @brief inserts copies of element into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, cnt, val);
+        }
+
+        JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+    }
+
+    /// @brief inserts range of elements into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, const_iterator first, const_iterator last)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
+        {
+            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", this));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
+    }
+
+    /// @brief inserts elements from initializer list into array
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    iterator insert(const_iterator pos, initializer_list_t ilist)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(!is_array()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, ilist.begin(), ilist.end());
+    }
+
+    /// @brief inserts range of elements into object
+    /// @sa https://json.nlohmann.me/api/basic_json/insert/
+    void insert(const_iterator first, const_iterator last)
+    {
+        // insert only works for objects
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects", this));
+        }
+
+        m_data.m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
+    }
+
+    /// @brief updates a JSON object from another object, overwriting existing keys
+    /// @sa https://json.nlohmann.me/api/basic_json/update/
+    void update(const_reference j, bool merge_objects = false)
+    {
+        update(j.begin(), j.end(), merge_objects);
+    }
+
+    /// @brief updates a JSON object from another object, overwriting existing keys
+    /// @sa https://json.nlohmann.me/api/basic_json/update/
+    void update(const_iterator first, const_iterator last, bool merge_objects = false)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_data.m_type = value_t::object;
+            m_data.m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!is_object()))
+        {
+            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", type_name()), this));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
+        {
+            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
+        }
+
+        for (auto it = first; it != last; ++it)
+        {
+            if (merge_objects && it.value().is_object())
+            {
+                auto it2 = m_data.m_value.object->find(it.key());
+                if (it2 != m_data.m_value.object->end())
+                {
+                    it2->second.update(it.value(), true);
+                    continue;
+                }
+            }
+            m_data.m_value.object->operator[](it.key()) = it.value();
+#if JSON_DIAGNOSTICS
+            m_data.m_value.object->operator[](it.key()).m_parent = this;
+#endif
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(reference other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        std::swap(m_data.m_type, other.m_data.m_type);
+        std::swap(m_data.m_value, other.m_data.m_value);
+
+        set_parents();
+        other.set_parents();
+        assert_invariant();
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    friend void swap(reference left, reference right) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value&&
+        std::is_nothrow_move_assignable<value_t>::value&&
+        std::is_nothrow_move_constructible<json_value>::value&& // NOLINT(cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        left.swap(right);
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(array_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.array), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(array_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(object_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.object), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(object_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(string_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_string()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.string), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(string_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(binary_t& other) // NOLINT(bugprone-exception-escape,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t&) with ", type_name()), this));
+        }
+    }
+
+    /// @brief exchanges the values
+    /// @sa https://json.nlohmann.me/api/basic_json/swap/
+    void swap(typename binary_t::container_type& other) // NOLINT(bugprone-exception-escape)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_binary()))
+        {
+            using std::swap;
+            swap(*(m_data.m_value.binary), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, detail::concat("cannot use swap(binary_t::container_type&) with ", type_name()), this));
+        }
+    }
+
+    /// @}
+
+    //////////////////////////////////////////
+    // lexicographical comparison operators //
+    //////////////////////////////////////////
+
+    /// @name lexicographical comparison operators
+    /// @{
+
+    // note parentheses around operands are necessary; see
+    // https://github.com/nlohmann/json/issues/1530
+#define JSON_IMPLEMENT_OPERATOR(op, null_result, unordered_result, default_result)                       \
+    const auto lhs_type = lhs.type();                                                                    \
+    const auto rhs_type = rhs.type();                                                                    \
+    \
+    if (lhs_type == rhs_type) /* NOLINT(readability/braces) */                                           \
+    {                                                                                                    \
+        switch (lhs_type)                                                                                \
+        {                                                                                                \
+            case value_t::array:                                                                         \
+                return (*lhs.m_data.m_value.array) op (*rhs.m_data.m_value.array);                                     \
+                \
+            case value_t::object:                                                                        \
+                return (*lhs.m_data.m_value.object) op (*rhs.m_data.m_value.object);                                   \
+                \
+            case value_t::null:                                                                          \
+                return (null_result);                                                                    \
+                \
+            case value_t::string:                                                                        \
+                return (*lhs.m_data.m_value.string) op (*rhs.m_data.m_value.string);                                   \
+                \
+            case value_t::boolean:                                                                       \
+                return (lhs.m_data.m_value.boolean) op (rhs.m_data.m_value.boolean);                                   \
+                \
+            case value_t::number_integer:                                                                \
+                return (lhs.m_data.m_value.number_integer) op (rhs.m_data.m_value.number_integer);                     \
+                \
+            case value_t::number_unsigned:                                                               \
+                return (lhs.m_data.m_value.number_unsigned) op (rhs.m_data.m_value.number_unsigned);                   \
+                \
+            case value_t::number_float:                                                                  \
+                return (lhs.m_data.m_value.number_float) op (rhs.m_data.m_value.number_float);                         \
+                \
+            case value_t::binary:                                                                        \
+                return (*lhs.m_data.m_value.binary) op (*rhs.m_data.m_value.binary);                                   \
+                \
+            case value_t::discarded:                                                                     \
+            default:                                                                                     \
+                return (unordered_result);                                                               \
+        }                                                                                                \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)                   \
+    {                                                                                                    \
+        return static_cast<number_float_t>(lhs.m_data.m_value.number_integer) op rhs.m_data.m_value.number_float;      \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)                   \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_integer);      \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)                  \
+    {                                                                                                    \
+        return static_cast<number_float_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_float;     \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)                  \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_float op static_cast<number_float_t>(rhs.m_data.m_value.number_unsigned);     \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)                \
+    {                                                                                                    \
+        return static_cast<number_integer_t>(lhs.m_data.m_value.number_unsigned) op rhs.m_data.m_value.number_integer; \
+    }                                                                                                    \
+    else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)                \
+    {                                                                                                    \
+        return lhs.m_data.m_value.number_integer op static_cast<number_integer_t>(rhs.m_data.m_value.number_unsigned); \
+    }                                                                                                    \
+    else if(compares_unordered(lhs, rhs))\
+    {\
+        return (unordered_result);\
+    }\
+    \
+    return (default_result);
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    // returns true if:
+    // - any operand is NaN and the other operand is of number type
+    // - any operand is discarded
+    // in legacy mode, discarded values are considered ordered if
+    // an operation is computed as an odd number of inverses of others
+    static bool compares_unordered(const_reference lhs, const_reference rhs, bool inverse = false) noexcept
+    {
+        if ((lhs.is_number_float() && std::isnan(lhs.m_data.m_value.number_float) && rhs.is_number())
+                || (rhs.is_number_float() && std::isnan(rhs.m_data.m_value.number_float) && lhs.is_number()))
+        {
+            return true;
+        }
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+        return (lhs.is_discarded() || rhs.is_discarded()) && !inverse;
+#else
+        static_cast<void>(inverse);
+        return lhs.is_discarded() || rhs.is_discarded();
+#endif
+    }
+
+  private:
+    bool compares_unordered(const_reference rhs, bool inverse = false) const noexcept
+    {
+        return compares_unordered(*this, rhs, inverse);
+    }
+
+  public:
+#if JSON_HAS_THREE_WAY_COMPARISON
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    bool operator==(const_reference rhs) const noexcept
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        const_reference lhs = *this;
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator==(ScalarType rhs) const noexcept
+    {
+        return *this == basic_json(rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    bool operator!=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !operator==(rhs);
+    }
+
+    /// @brief comparison: 3-way
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
+    std::partial_ordering operator<=>(const_reference rhs) const noexcept // *NOPAD*
+    {
+        const_reference lhs = *this;
+        // default_result is used if we cannot compare values. In that case,
+        // we compare types.
+        JSON_IMPLEMENT_OPERATOR(<=>, // *NOPAD*
+                                std::partial_ordering::equivalent,
+                                std::partial_ordering::unordered,
+                                lhs_type <=> rhs_type) // *NOPAD*
+    }
+
+    /// @brief comparison: 3-way
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_spaceship/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    std::partial_ordering operator<=>(ScalarType rhs) const noexcept // *NOPAD*
+    {
+        return *this <=> basic_json(rhs); // *NOPAD*
+    }
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    // all operators that are computed as an odd number of inverses of others
+    // need to be overloaded to emulate the legacy comparison behavior
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
+    bool operator<=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !(rhs < *this);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator<=(ScalarType rhs) const noexcept
+    {
+        return *this <= basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON)
+    bool operator>=(const_reference rhs) const noexcept
+    {
+        if (compares_unordered(rhs, true))
+        {
+            return false;
+        }
+        return !(*this < rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType>
+    requires std::is_scalar_v<ScalarType>
+    bool operator>=(ScalarType rhs) const noexcept
+    {
+        return *this >= basic_json(rhs);
+    }
+#endif
+#else
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
+    {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+        JSON_IMPLEMENT_OPERATOR( ==, true, false, false)
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs == basic_json(rhs);
+    }
+
+    /// @brief comparison: equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_eq/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) == rhs;
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(lhs == rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs != basic_json(rhs);
+    }
+
+    /// @brief comparison: not equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ne/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) != rhs;
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
+    {
+        // default_result is used if we cannot compare values. In that case,
+        // we compare types. Note we have to call the operator explicitly,
+        // because MSVC has problems otherwise.
+        JSON_IMPLEMENT_OPERATOR( <, false, false, operator<(lhs_type, rhs_type))
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs < basic_json(rhs);
+    }
+
+    /// @brief comparison: less than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_lt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) < rhs;
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(rhs < lhs);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs <= basic_json(rhs);
+    }
+
+    /// @brief comparison: less than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_le/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) <= rhs;
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
+    {
+        // double inverse
+        if (compares_unordered(lhs, rhs))
+        {
+            return false;
+        }
+        return !(lhs <= rhs);
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs > basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gt/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) > rhs;
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
+    {
+        if (compares_unordered(lhs, rhs, true))
+        {
+            return false;
+        }
+        return !(lhs < rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(const_reference lhs, ScalarType rhs) noexcept
+    {
+        return lhs >= basic_json(rhs);
+    }
+
+    /// @brief comparison: greater than or equal
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ge/
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) >= rhs;
+    }
+#endif
+
+#undef JSON_IMPLEMENT_OPERATOR
+
+    /// @}
+
+    ///////////////////
+    // serialization //
+    ///////////////////
+
+    /// @name serialization
+    /// @{
+#ifndef JSON_NO_IO
+    /// @brief serialize to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
+    {
+        // read width member and use it as indentation parameter if nonzero
+        const bool pretty_print = o.width() > 0;
+        const auto indentation = pretty_print ? o.width() : 0;
+
+        // reset width to 0 for subsequent calls to this stream
+        o.width(0);
+
+        // do the actual serialization
+        serializer s(detail::output_adapter<char>(o), o.fill());
+        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
+        return o;
+    }
+
+    /// @brief serialize to stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_ltlt/
+    /// @deprecated This function is deprecated since 3.0.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             operator<<(std::ostream&, const basic_json&) instead; that is,
+    ///             replace calls like `j >> o;` with `o << j;`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
+    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
+    {
+        return o << j;
+    }
+#endif  // JSON_NO_IO
+    /// @}
+
+    /////////////////////
+    // deserialization //
+    /////////////////////
+
+    /// @name deserialization
+    /// @{
+
+    /// @brief deserialize from a compatible input
+    /// @sa https://json.nlohmann.me/api/basic_json/parse/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(InputType&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    /// @brief deserialize from a pair of character iterators
+    /// @sa https://json.nlohmann.me/api/basic_json/parse/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(IteratorType first,
+                            IteratorType last,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
+    static basic_json parse(detail::span_input_adapter&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true,
+                            const bool ignore_comments = false)
+    {
+        basic_json result;
+        parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
+        return result;
+    }
+
+    /// @brief check if the input is valid JSON
+    /// @sa https://json.nlohmann.me/api/basic_json/accept/
+    template<typename InputType>
+    static bool accept(InputType&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    /// @brief check if the input is valid JSON
+    /// @sa https://json.nlohmann.me/api/basic_json/accept/
+    template<typename IteratorType>
+    static bool accept(IteratorType first, IteratorType last,
+                       const bool ignore_comments = false)
+    {
+        return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
+    static bool accept(detail::span_input_adapter&& i,
+                       const bool ignore_comments = false)
+    {
+        return parser(i.get(), nullptr, false, ignore_comments).accept(true);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    template <typename InputType, typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(InputType&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    template<class IteratorType, class SAX>
+    JSON_HEDLEY_NON_NULL(3)
+    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        return format == input_format_t::json
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+
+    /// @brief generate SAX events
+    /// @sa https://json.nlohmann.me/api/basic_json/sax_parse/
+    /// @deprecated This function is deprecated since 3.8.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             sax_parse(ptr, ptr + len) instead.
+    template <typename SAX>
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true,
+                          const bool ignore_comments = false)
+    {
+        auto ia = i.get();
+        return format == input_format_t::json
+               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+               ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
+               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(format, sax, strict);
+    }
+#ifndef JSON_NO_IO
+    /// @brief deserialize from stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
+    /// @deprecated This stream operator is deprecated since 3.0.0 and will be removed in
+    ///             version 4.0.0 of the library. Please use
+    ///             operator>>(std::istream&, basic_json&) instead; that is,
+    ///             replace calls like `j << i;` with `i >> j;`.
+    JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
+    friend std::istream& operator<<(basic_json& j, std::istream& i)
+    {
+        return operator>>(i, j);
+    }
+
+    /// @brief deserialize from stream
+    /// @sa https://json.nlohmann.me/api/basic_json/operator_gtgt/
+    friend std::istream& operator>>(std::istream& i, basic_json& j)
+    {
+        parser(detail::input_adapter(i)).parse(false, j);
+        return i;
+    }
+#endif  // JSON_NO_IO
+    /// @}
+
+    ///////////////////////////
+    // convenience functions //
+    ///////////////////////////
+
+    /// @brief return the type as string
+    /// @sa https://json.nlohmann.me/api/basic_json/type_name/
+    JSON_HEDLEY_RETURNS_NON_NULL
+    const char* type_name() const noexcept
+    {
+        switch (m_data.m_type)
+        {
+            case value_t::null:
+                return "null";
+            case value_t::object:
+                return "object";
+            case value_t::array:
+                return "array";
+            case value_t::string:
+                return "string";
+            case value_t::boolean:
+                return "boolean";
+            case value_t::binary:
+                return "binary";
+            case value_t::discarded:
+                return "discarded";
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            default:
+                return "number";
+        }
+    }
+
+  JSON_PRIVATE_UNLESS_TESTED:
+    //////////////////////
+    // member variables //
+    //////////////////////
+
+    struct data
+    {
+        /// the type of the current element
+        value_t m_type = value_t::null;
+
+        /// the value of the current element
+        json_value m_value = {};
+
+        data(const value_t v)
+            : m_type(v), m_value(v)
+        {
+        }
+
+        data(size_type cnt, const basic_json& val)
+            : m_type(value_t::array)
+        {
+            m_value.array = create<array_t>(cnt, val);
+        }
+
+        data() noexcept = default;
+        data(data&&) noexcept = default;
+        data(const data&) noexcept = delete;
+        data& operator=(data&&) noexcept = delete;
+        data& operator=(const data&) noexcept = delete;
+
+        ~data() noexcept
+        {
+            m_value.destroy(m_type);
+        }
+    };
+
+    data m_data = {};
+
+#if JSON_DIAGNOSTICS
+    /// a pointer to a parent value (for debugging purposes)
+    basic_json* m_parent = nullptr;
+#endif
+
+    //////////////////////////////////////////
+    // binary serialization/deserialization //
+    //////////////////////////////////////////
+
+    /// @name binary serialization/deserialization support
+    /// @{
+
+  public:
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static std::vector<std::uint8_t> to_cbor(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_cbor(j, result);
+        return result;
+    }
+
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_cbor(j);
+    }
+
+    /// @brief create a CBOR serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_cbor/
+    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_cbor(j);
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_msgpack(j, result);
+        return result;
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static void to_msgpack(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_msgpack(j);
+    }
+
+    /// @brief create a MessagePack serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_msgpack/
+    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_msgpack(j);
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
+            const bool use_size = false,
+            const bool use_type = false)
+    {
+        std::vector<std::uint8_t> result;
+        to_ubjson(j, result, use_size, use_type);
+        return result;
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static void to_ubjson(const basic_json& j, detail::output_adapter<std::uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    /// @brief create a UBJSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_ubjson/
+    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
+            const bool use_size = false,
+            const bool use_type = false)
+    {
+        std::vector<std::uint8_t> result;
+        to_bjdata(j, result, use_size, use_type);
+        return result;
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static void to_bjdata(const basic_json& j, detail::output_adapter<std::uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<std::uint8_t>(o).write_ubjson(j, use_size, use_type, true, true);
+    }
+
+    /// @brief create a BJData serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bjdata/
+    static void to_bjdata(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type, true, true);
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static std::vector<std::uint8_t> to_bson(const basic_json& j)
+    {
+        std::vector<std::uint8_t> result;
+        to_bson(j, result);
+        return result;
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o)
+    {
+        binary_writer<std::uint8_t>(o).write_bson(j);
+    }
+
+    /// @brief create a BSON serialization of a given JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/to_bson/
+    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_bson(j);
+    }
+
+    /// @brief create a JSON value from an input in CBOR format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in CBOR format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_cbor/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
+    static basic_json from_cbor(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true,
+                                const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::cbor).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in MessagePack format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(InputType&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in MessagePack format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_msgpack/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(IteratorType first, IteratorType last,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(const T* ptr, std::size_t len,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
+    static basic_json from_msgpack(detail::span_input_adapter&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::msgpack).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in UBJSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(InputType&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in UBJSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_ubjson/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(IteratorType first, IteratorType last,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(const T* ptr, std::size_t len,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
+    static basic_json from_ubjson(detail::span_input_adapter&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::ubjson).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BJData format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bjdata(InputType&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BJData format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bjdata/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bjdata(IteratorType first, IteratorType last,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bjdata).sax_parse(input_format_t::bjdata, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
+    template<typename InputType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(InputType&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::forward<InputType>(i));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /// @brief create a JSON value from an input in BSON format
+    /// @sa https://json.nlohmann.me/api/basic_json/from_bson/
+    template<typename IteratorType>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(IteratorType first, IteratorType last,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = detail::input_adapter(std::move(first), std::move(last));
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    template<typename T>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(const T* ptr, std::size_t len,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        return from_bson(ptr, ptr + len, strict, allow_exceptions);
+    }
+
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
+    static basic_json from_bson(detail::span_input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        auto ia = i.get();
+        // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
+        const bool res = binary_reader<decltype(ia)>(std::move(ia), input_format_t::bson).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+    /// @}
+
+    //////////////////////////
+    // JSON Pointer support //
+    //////////////////////////
+
+    /// @name JSON Pointer functions
+    /// @{
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    reference operator[](const json_pointer& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/operator%5B%5D/
+    const_reference operator[](const json_pointer& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    const_reference operator[](const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    reference at(const json_pointer& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    /// @brief access specified element via JSON Pointer
+    /// @sa https://json.nlohmann.me/api/basic_json/at/
+    const_reference at(const json_pointer& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    template<typename BasicJsonType, detail::enable_if_t<detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, basic_json::json_pointer or nlohmann::json_pointer<basic_json::string_t>) // NOLINT(readability/alt_tokens)
+    const_reference at(const ::nlohmann::json_pointer<BasicJsonType>& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    /// @brief return flattened JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/flatten/
+    basic_json flatten() const
+    {
+        basic_json result(value_t::object);
+        json_pointer::flatten("", *this, result);
+        return result;
+    }
+
+    /// @brief unflatten a previously flattened JSON value
+    /// @sa https://json.nlohmann.me/api/basic_json/unflatten/
+    basic_json unflatten() const
+    {
+        return json_pointer::unflatten(*this);
+    }
+
+    /// @}
+
+    //////////////////////////
+    // JSON Patch functions //
+    //////////////////////////
+
+    /// @name JSON Patch functions
+    /// @{
+
+    /// @brief applies a JSON patch in-place without copying the object
+    /// @sa https://json.nlohmann.me/api/basic_json/patch/
+    void patch_inplace(const basic_json& json_patch)
+    {
+        basic_json& result = *this;
+        // the valid JSON Patch operations
+        enum class patch_operations {add, remove, replace, move, copy, test, invalid};
+
+        const auto get_op = [](const std::string & op)
+        {
+            if (op == "add")
+            {
+                return patch_operations::add;
+            }
+            if (op == "remove")
+            {
+                return patch_operations::remove;
+            }
+            if (op == "replace")
+            {
+                return patch_operations::replace;
+            }
+            if (op == "move")
+            {
+                return patch_operations::move;
+            }
+            if (op == "copy")
+            {
+                return patch_operations::copy;
+            }
+            if (op == "test")
+            {
+                return patch_operations::test;
+            }
+
+            return patch_operations::invalid;
+        };
+
+        // wrapper for "add" operation; add value at ptr
+        const auto operation_add = [&result](json_pointer & ptr, basic_json val)
+        {
+            // adding to the root of the target document means replacing it
+            if (ptr.empty())
+            {
+                result = val;
+                return;
+            }
+
+            // make sure the top element of the pointer exists
+            json_pointer const top_pointer = ptr.top();
+            if (top_pointer != ptr)
+            {
+                result.at(top_pointer);
+            }
+
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            // parent must exist when performing patch add per RFC6902 specs
+            basic_json& parent = result.at(ptr);
+
+            switch (parent.m_data.m_type)
+            {
+                case value_t::null:
+                case value_t::object:
+                {
+                    // use operator[] to add value
+                    parent[last_path] = val;
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    if (last_path == "-")
+                    {
+                        // special case: append to back
+                        parent.push_back(val);
+                    }
+                    else
+                    {
+                        const auto idx = json_pointer::template array_index<basic_json_t>(last_path);
+                        if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
+                        {
+                            // avoid undefined behavior
+                            JSON_THROW(out_of_range::create(401, detail::concat("array index ", std::to_string(idx), " is out of range"), &parent));
+                        }
+
+                        // default case: insert add offset
+                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
+                    }
+                    break;
+                }
+
+                // if there exists a parent it cannot be primitive
+                case value_t::string: // LCOV_EXCL_LINE
+                case value_t::boolean: // LCOV_EXCL_LINE
+                case value_t::number_integer: // LCOV_EXCL_LINE
+                case value_t::number_unsigned: // LCOV_EXCL_LINE
+                case value_t::number_float: // LCOV_EXCL_LINE
+                case value_t::binary: // LCOV_EXCL_LINE
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:            // LCOV_EXCL_LINE
+                    JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
+            }
+        };
+
+        // wrapper for "remove" operation; remove value at ptr
+        const auto operation_remove = [this, & result](json_pointer & ptr)
+        {
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            basic_json& parent = result.at(ptr);
+
+            // remove child
+            if (parent.is_object())
+            {
+                // perform range check
+                auto it = parent.find(last_path);
+                if (JSON_HEDLEY_LIKELY(it != parent.end()))
+                {
+                    parent.erase(it);
+                }
+                else
+                {
+                    JSON_THROW(out_of_range::create(403, detail::concat("key '", last_path, "' not found"), this));
+                }
+            }
+            else if (parent.is_array())
+            {
+                // note erase performs range check
+                parent.erase(json_pointer::template array_index<basic_json_t>(last_path));
+            }
+        };
+
+        // type check: top level value must be an array
+        if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
+        {
+            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &json_patch));
+        }
+
+        // iterate and apply the operations
+        for (const auto& val : json_patch)
+        {
+            // wrapper to get a value for an operation
+            const auto get_value = [&val](const std::string & op,
+                                          const std::string & member,
+                                          bool string_type) -> basic_json &
+            {
+                // find value
+                auto it = val.m_data.m_value.object->find(member);
+
+                // context-sensitive error message
+                const auto error_msg = (op == "op") ? "operation" : detail::concat("operation '", op, '\'');
+
+                // check if desired value is present
+                if (JSON_HEDLEY_UNLIKELY(it == val.m_data.m_value.object->end()))
+                {
+                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
+                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have member '", member, "'"), &val));
+                }
+
+                // check if result is of type string
+                if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
+                {
+                    // NOLINTNEXTLINE(performance-inefficient-string-concatenation)
+                    JSON_THROW(parse_error::create(105, 0, detail::concat(error_msg, " must have string member '", member, "'"), &val));
+                }
+
+                // no error: return value
+                return it->second;
+            };
+
+            // type check: every element of the array must be an object
+            if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
+            {
+                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects", &val));
+            }
+
+            // collect mandatory members
+            const auto op = get_value("op", "op", true).template get<std::string>();
+            const auto path = get_value(op, "path", true).template get<std::string>();
+            json_pointer ptr(path);
+
+            switch (get_op(op))
+            {
+                case patch_operations::add:
+                {
+                    operation_add(ptr, get_value("add", "value", false));
+                    break;
+                }
+
+                case patch_operations::remove:
+                {
+                    operation_remove(ptr);
+                    break;
+                }
+
+                case patch_operations::replace:
+                {
+                    // the "path" location must exist - use at()
+                    result.at(ptr) = get_value("replace", "value", false);
+                    break;
+                }
+
+                case patch_operations::move:
+                {
+                    const auto from_path = get_value("move", "from", true).template get<std::string>();
+                    json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json const v = result.at(from_ptr);
+
+                    // The move operation is functionally identical to a
+                    // "remove" operation on the "from" location, followed
+                    // immediately by an "add" operation at the target
+                    // location with the value that was just removed.
+                    operation_remove(from_ptr);
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::copy:
+                {
+                    const auto from_path = get_value("copy", "from", true).template get<std::string>();
+                    const json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json const v = result.at(from_ptr);
+
+                    // The copy is functionally identical to an "add"
+                    // operation at the target location using the value
+                    // specified in the "from" member.
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::test:
+                {
+                    bool success = false;
+                    JSON_TRY
+                    {
+                        // check if "value" matches the one at "path"
+                        // the "path" location must exist - use at()
+                        success = (result.at(ptr) == get_value("test", "value", false));
+                    }
+                    JSON_INTERNAL_CATCH (out_of_range&)
+                    {
+                        // ignore out of range errors: success remains false
+                    }
+
+                    // throw an exception if test fails
+                    if (JSON_HEDLEY_UNLIKELY(!success))
+                    {
+                        JSON_THROW(other_error::create(501, detail::concat("unsuccessful: ", val.dump()), &val));
+                    }
+
+                    break;
+                }
+
+                case patch_operations::invalid:
+                default:
+                {
+                    // op must be "add", "remove", "replace", "move", "copy", or
+                    // "test"
+                    JSON_THROW(parse_error::create(105, 0, detail::concat("operation value '", op, "' is invalid"), &val));
+                }
+            }
+        }
+    }
+
+    /// @brief applies a JSON patch to a copy of the current object
+    /// @sa https://json.nlohmann.me/api/basic_json/patch/
+    basic_json patch(const basic_json& json_patch) const
+    {
+        basic_json result = *this;
+        result.patch_inplace(json_patch);
+        return result;
+    }
+
+    /// @brief creates a diff as a JSON patch
+    /// @sa https://json.nlohmann.me/api/basic_json/diff/
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json diff(const basic_json& source, const basic_json& target,
+                           const std::string& path = "")
+    {
+        // the patch
+        basic_json result(value_t::array);
+
+        // if the values are the same, return empty patch
+        if (source == target)
+        {
+            return result;
+        }
+
+        if (source.type() != target.type())
+        {
+            // different types: replace value
+            result.push_back(
+            {
+                {"op", "replace"}, {"path", path}, {"value", target}
+            });
+            return result;
+        }
+
+        switch (source.type())
+        {
+            case value_t::array:
+            {
+                // first pass: traverse common elements
+                std::size_t i = 0;
+                while (i < source.size() && i < target.size())
+                {
+                    // recursive call to compare array values at index i
+                    auto temp_diff = diff(source[i], target[i], detail::concat(path, '/', std::to_string(i)));
+                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    ++i;
+                }
+
+                // We now reached the end of at least one array
+                // in a second pass, traverse the remaining elements
+
+                // remove my remaining elements
+                const auto end_index = static_cast<difference_type>(result.size());
+                while (i < source.size())
+                {
+                    // add operations in reverse order to avoid invalid
+                    // indices
+                    result.insert(result.begin() + end_index, object(
+                    {
+                        {"op", "remove"},
+                        {"path", detail::concat(path, '/', std::to_string(i))}
+                    }));
+                    ++i;
+                }
+
+                // add other remaining elements
+                while (i < target.size())
+                {
+                    result.push_back(
+                    {
+                        {"op", "add"},
+                        {"path", detail::concat(path, "/-")},
+                        {"value", target[i]}
+                    });
+                    ++i;
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // first pass: traverse this object's elements
+                for (auto it = source.cbegin(); it != source.cend(); ++it)
+                {
+                    // escape the key name to be used in a JSON patch
+                    const auto path_key = detail::concat(path, '/', detail::escape(it.key()));
+
+                    if (target.find(it.key()) != target.end())
+                    {
+                        // recursive call to compare object values at key it
+                        auto temp_diff = diff(it.value(), target[it.key()], path_key);
+                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    }
+                    else
+                    {
+                        // found a key that is not in o -> remove it
+                        result.push_back(object(
+                        {
+                            {"op", "remove"}, {"path", path_key}
+                        }));
+                    }
+                }
+
+                // second pass: traverse other object's elements
+                for (auto it = target.cbegin(); it != target.cend(); ++it)
+                {
+                    if (source.find(it.key()) == source.end())
+                    {
+                        // found a key that is not in this -> add it
+                        const auto path_key = detail::concat(path, '/', detail::escape(it.key()));
+                        result.push_back(
+                        {
+                            {"op", "add"}, {"path", path_key},
+                            {"value", it.value()}
+                        });
+                    }
+                }
+
+                break;
+            }
+
+            case value_t::null:
+            case value_t::string:
+            case value_t::boolean:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::number_float:
+            case value_t::binary:
+            case value_t::discarded:
+            default:
+            {
+                // both primitive type: replace value
+                result.push_back(
+                {
+                    {"op", "replace"}, {"path", path}, {"value", target}
+                });
+                break;
+            }
+        }
+
+        return result;
+    }
+    /// @}
+
+    ////////////////////////////////
+    // JSON Merge Patch functions //
+    ////////////////////////////////
+
+    /// @name JSON Merge Patch functions
+    /// @{
+
+    /// @brief applies a JSON Merge Patch
+    /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
+    void merge_patch(const basic_json& apply_patch)
+    {
+        if (apply_patch.is_object())
+        {
+            if (!is_object())
+            {
+                *this = object();
+            }
+            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
+            {
+                if (it.value().is_null())
+                {
+                    erase(it.key());
+                }
+                else
+                {
+                    operator[](it.key()).merge_patch(it.value());
+                }
+            }
+        }
+        else
+        {
+            *this = apply_patch;
+        }
+    }
+
+    /// @}
+};
+
+/// @brief user-defined to_string function for JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/to_string/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
+{
+    return j.dump();
+}
+
+inline namespace literals
+{
+inline namespace json_literals
+{
+
+/// @brief user-defined string literal for JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json/
+JSON_HEDLEY_NON_NULL(1)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json operator ""_json(const char* s, std::size_t n)
+#else
+    inline nlohmann::json operator "" _json(const char* s, std::size_t n)
+#endif
+{
+    return nlohmann::json::parse(s, s + n);
+}
+
+/// @brief user-defined string literal for JSON pointer
+/// @sa https://json.nlohmann.me/api/basic_json/operator_literal_json_pointer/
+JSON_HEDLEY_NON_NULL(1)
+#if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    inline nlohmann::json::json_pointer operator ""_json_pointer(const char* s, std::size_t n)
+#else
+    inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
+#endif
+{
+    return nlohmann::json::json_pointer(std::string(s, n));
+}
+
+}  // namespace json_literals
+}  // namespace literals
+NLOHMANN_JSON_NAMESPACE_END
+
+///////////////////////
+// nonmember support //
+///////////////////////
+
+namespace std // NOLINT(cert-dcl58-cpp)
+{
+
+/// @brief hash value for JSON objects
+/// @sa https://json.nlohmann.me/api/basic_json/std_hash/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct hash<nlohmann::NLOHMANN_BASIC_JSON_TPL> // NOLINT(cert-dcl58-cpp)
+{
+    std::size_t operator()(const nlohmann::NLOHMANN_BASIC_JSON_TPL& j) const
+    {
+        return nlohmann::detail::hash(j);
+    }
+};
+
+// specialization for std::less<value_t>
+template<>
+struct less< ::nlohmann::detail::value_t> // do not remove the space after '<', see https://github.com/nlohmann/json/pull/679
+{
+    /*!
+    @brief compare two value_t enum values
+    @since version 3.0.0
+    */
+    bool operator()(::nlohmann::detail::value_t lhs,
+                    ::nlohmann::detail::value_t rhs) const noexcept
+    {
+#if JSON_HAS_THREE_WAY_COMPARISON
+        return std::is_lt(lhs <=> rhs); // *NOPAD*
+#else
+        return ::nlohmann::detail::operator<(lhs, rhs);
+#endif
+    }
+};
+
+// C++20 prohibit function specialization in the std namespace.
+#ifndef JSON_HAS_CPP_20
+
+/// @brief exchanges the values of two JSON objects
+/// @sa https://json.nlohmann.me/api/basic_json/std_swap/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+inline void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL& j1, nlohmann::NLOHMANN_BASIC_JSON_TPL& j2) noexcept(  // NOLINT(readability-inconsistent-declaration-parameter-name, cert-dcl58-cpp)
+    is_nothrow_move_constructible<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value&&                          // NOLINT(misc-redundant-expression,cppcoreguidelines-noexcept-swap,performance-noexcept-swap)
+    is_nothrow_move_assignable<nlohmann::NLOHMANN_BASIC_JSON_TPL>::value)
+{
+    j1.swap(j2);
+}
+
+#endif
+
+}  // namespace std
+
+#if JSON_USE_GLOBAL_UDLS
+    #if !defined(JSON_HEDLEY_GCC_VERSION) || JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+        using nlohmann::literals::json_literals::operator ""_json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator ""_json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #else
+        using nlohmann::literals::json_literals::operator "" _json; // NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+        using nlohmann::literals::json_literals::operator "" _json_pointer; //NOLINT(misc-unused-using-decls,google-global-names-in-headers)
+    #endif
+#endif
+
+// #include <nlohmann/detail/macro_unscope.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// restore clang diagnostic settings
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+
+// clean up
+#undef JSON_ASSERT
+#undef JSON_INTERNAL_CATCH
+#undef JSON_THROW
+#undef JSON_PRIVATE_UNLESS_TESTED
+#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
+#undef NLOHMANN_BASIC_JSON_TPL
+#undef JSON_EXPLICIT
+#undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
+#undef JSON_INLINE_VARIABLE
+#undef JSON_NO_UNIQUE_ADDRESS
+#undef JSON_DISABLE_ENUM_SERIALIZATION
+#undef JSON_USE_GLOBAL_UDLS
+
+#ifndef JSON_TEST_KEEP_MACROS
+    #undef JSON_CATCH
+    #undef JSON_TRY
+    #undef JSON_HAS_CPP_11
+    #undef JSON_HAS_CPP_14
+    #undef JSON_HAS_CPP_17
+    #undef JSON_HAS_CPP_20
+    #undef JSON_HAS_FILESYSTEM
+    #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM
+    #undef JSON_HAS_THREE_WAY_COMPARISON
+    #undef JSON_HAS_RANGES
+    #undef JSON_HAS_STATIC_RTTI
+    #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+#endif
+
+// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+#undef JSON_HEDLEY_ALWAYS_INLINE
+#undef JSON_HEDLEY_ARM_VERSION
+#undef JSON_HEDLEY_ARM_VERSION_CHECK
+#undef JSON_HEDLEY_ARRAY_PARAM
+#undef JSON_HEDLEY_ASSUME
+#undef JSON_HEDLEY_BEGIN_C_DECLS
+#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#undef JSON_HEDLEY_CLANG_HAS_WARNING
+#undef JSON_HEDLEY_COMPCERT_VERSION
+#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#undef JSON_HEDLEY_CONCAT
+#undef JSON_HEDLEY_CONCAT3
+#undef JSON_HEDLEY_CONCAT3_EX
+#undef JSON_HEDLEY_CONCAT_EX
+#undef JSON_HEDLEY_CONST
+#undef JSON_HEDLEY_CONSTEXPR
+#undef JSON_HEDLEY_CONST_CAST
+#undef JSON_HEDLEY_CPP_CAST
+#undef JSON_HEDLEY_CRAY_VERSION
+#undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#undef JSON_HEDLEY_C_DECL
+#undef JSON_HEDLEY_DEPRECATED
+#undef JSON_HEDLEY_DEPRECATED_FOR
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
+#undef JSON_HEDLEY_DIAGNOSTIC_POP
+#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#undef JSON_HEDLEY_DMC_VERSION
+#undef JSON_HEDLEY_DMC_VERSION_CHECK
+#undef JSON_HEDLEY_EMPTY_BASES
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#undef JSON_HEDLEY_END_C_DECLS
+#undef JSON_HEDLEY_FLAGS
+#undef JSON_HEDLEY_FLAGS_CAST
+#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#undef JSON_HEDLEY_GCC_HAS_FEATURE
+#undef JSON_HEDLEY_GCC_HAS_WARNING
+#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#undef JSON_HEDLEY_GCC_VERSION
+#undef JSON_HEDLEY_GCC_VERSION_CHECK
+#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#undef JSON_HEDLEY_GNUC_HAS_WARNING
+#undef JSON_HEDLEY_GNUC_VERSION
+#undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#undef JSON_HEDLEY_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_BUILTIN
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
+#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_EXTENSION
+#undef JSON_HEDLEY_HAS_FEATURE
+#undef JSON_HEDLEY_HAS_WARNING
+#undef JSON_HEDLEY_IAR_VERSION
+#undef JSON_HEDLEY_IAR_VERSION_CHECK
+#undef JSON_HEDLEY_IBM_VERSION
+#undef JSON_HEDLEY_IBM_VERSION_CHECK
+#undef JSON_HEDLEY_IMPORT
+#undef JSON_HEDLEY_INLINE
+#undef JSON_HEDLEY_INTEL_CL_VERSION
+#undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK
+#undef JSON_HEDLEY_INTEL_VERSION
+#undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#undef JSON_HEDLEY_IS_CONSTANT
+#undef JSON_HEDLEY_IS_CONSTEXPR_
+#undef JSON_HEDLEY_LIKELY
+#undef JSON_HEDLEY_MALLOC
+#undef JSON_HEDLEY_MCST_LCC_VERSION
+#undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK
+#undef JSON_HEDLEY_MESSAGE
+#undef JSON_HEDLEY_MSVC_VERSION
+#undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#undef JSON_HEDLEY_NEVER_INLINE
+#undef JSON_HEDLEY_NON_NULL
+#undef JSON_HEDLEY_NO_ESCAPE
+#undef JSON_HEDLEY_NO_RETURN
+#undef JSON_HEDLEY_NO_THROW
+#undef JSON_HEDLEY_NULL
+#undef JSON_HEDLEY_PELLES_VERSION
+#undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#undef JSON_HEDLEY_PGI_VERSION
+#undef JSON_HEDLEY_PGI_VERSION_CHECK
+#undef JSON_HEDLEY_PREDICT
+#undef JSON_HEDLEY_PRINTF_FORMAT
+#undef JSON_HEDLEY_PRIVATE
+#undef JSON_HEDLEY_PUBLIC
+#undef JSON_HEDLEY_PURE
+#undef JSON_HEDLEY_REINTERPRET_CAST
+#undef JSON_HEDLEY_REQUIRE
+#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#undef JSON_HEDLEY_REQUIRE_MSG
+#undef JSON_HEDLEY_RESTRICT
+#undef JSON_HEDLEY_RETURNS_NON_NULL
+#undef JSON_HEDLEY_SENTINEL
+#undef JSON_HEDLEY_STATIC_ASSERT
+#undef JSON_HEDLEY_STATIC_CAST
+#undef JSON_HEDLEY_STRINGIFY
+#undef JSON_HEDLEY_STRINGIFY_EX
+#undef JSON_HEDLEY_SUNPRO_VERSION
+#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#undef JSON_HEDLEY_TINYC_VERSION
+#undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#undef JSON_HEDLEY_TI_ARMCL_VERSION
+#undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL2000_VERSION
+#undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL430_VERSION
+#undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL6X_VERSION
+#undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CL7X_VERSION
+#undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
+#undef JSON_HEDLEY_TI_CLPRU_VERSION
+#undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
+#undef JSON_HEDLEY_TI_VERSION
+#undef JSON_HEDLEY_TI_VERSION_CHECK
+#undef JSON_HEDLEY_UNAVAILABLE
+#undef JSON_HEDLEY_UNLIKELY
+#undef JSON_HEDLEY_UNPREDICTABLE
+#undef JSON_HEDLEY_UNREACHABLE
+#undef JSON_HEDLEY_UNREACHABLE_RETURN
+#undef JSON_HEDLEY_VERSION
+#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#undef JSON_HEDLEY_VERSION_ENCODE
+#undef JSON_HEDLEY_WARNING
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
+#undef JSON_HEDLEY_FALL_THROUGH
+
+
+
+#endif  // INCLUDE_NLOHMANN_JSON_HPP_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann/json_fwd.hpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann/json_fwd.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..29a6036d79c59fea00ea7c25927c88765d349dac
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann/json_fwd.hpp
@@ -0,0 +1,176 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
+#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+#include <cstdint> // int64_t, uint64_t
+#include <map> // map
+#include <memory> // allocator
+#include <string> // string
+#include <vector> // vector
+
+// #include <nlohmann/detail/abi_macros.hpp>
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++
+// |  |  |__   |  |  | | | |  version 3.11.3
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+
+
+// This file contains all macro definitions affecting or depending on the ABI
+
+#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
+    #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
+        #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3
+            #warning "Already included a different version of the library!"
+        #endif
+    #endif
+#endif
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3   // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_MINOR 11  // NOLINT(modernize-macro-to-enum)
+#define NLOHMANN_JSON_VERSION_PATCH 3   // NOLINT(modernize-macro-to-enum)
+
+#ifndef JSON_DIAGNOSTICS
+    #define JSON_DIAGNOSTICS 0
+#endif
+
+#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
+#endif
+
+#if JSON_DIAGNOSTICS
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
+#else
+    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
+#endif
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
+#else
+    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
+    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
+#endif
+
+// Construct the namespace ABI tags component
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)
+
+#define NLOHMANN_JSON_ABI_TAGS                                       \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
+            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)
+
+// Construct the namespace version component
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
+    _v ## major ## _ ## minor ## _ ## patch
+#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
+
+#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
+#define NLOHMANN_JSON_NAMESPACE_VERSION
+#else
+#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \
+    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
+                                           NLOHMANN_JSON_VERSION_MINOR, \
+                                           NLOHMANN_JSON_VERSION_PATCH)
+#endif
+
+// Combine namespace components
+#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
+#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
+    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
+
+#ifndef NLOHMANN_JSON_NAMESPACE
+#define NLOHMANN_JSON_NAMESPACE               \
+    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
+            NLOHMANN_JSON_ABI_TAGS,           \
+            NLOHMANN_JSON_NAMESPACE_VERSION)
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
+#define NLOHMANN_JSON_NAMESPACE_BEGIN                \
+    namespace nlohmann                               \
+    {                                                \
+    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
+                NLOHMANN_JSON_ABI_TAGS,              \
+                NLOHMANN_JSON_NAMESPACE_VERSION)     \
+    {
+#endif
+
+#ifndef NLOHMANN_JSON_NAMESPACE_END
+#define NLOHMANN_JSON_NAMESPACE_END                                     \
+    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
+    }  // namespace nlohmann
+#endif
+
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+NLOHMANN_JSON_NAMESPACE_BEGIN
+
+/*!
+@brief default JSONSerializer template argument
+
+This serializer ignores the template arguments and uses ADL
+([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
+for serialization.
+*/
+template<typename T = void, typename SFINAE = void>
+struct adl_serializer;
+
+/// a class to store JSON values
+/// @sa https://json.nlohmann.me/api/basic_json/
+template<template<typename U, typename V, typename... Args> class ObjectType =
+         std::map,
+         template<typename U, typename... Args> class ArrayType = std::vector,
+         class StringType = std::string, class BooleanType = bool,
+         class NumberIntegerType = std::int64_t,
+         class NumberUnsignedType = std::uint64_t,
+         class NumberFloatType = double,
+         template<typename U> class AllocatorType = std::allocator,
+         template<typename T, typename SFINAE = void> class JSONSerializer =
+         adl_serializer,
+         class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
+         class CustomBaseClass = void>
+class basic_json;
+
+/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
+/// @sa https://json.nlohmann.me/api/json_pointer/
+template<typename RefStringType>
+class json_pointer;
+
+/*!
+@brief default specialization
+@sa https://json.nlohmann.me/api/json/
+*/
+using json = basic_json<>;
+
+/// @brief a minimal map-like container that preserves insertion order
+/// @sa https://json.nlohmann.me/api/ordered_map/
+template<class Key, class T, class IgnoredLess, class Allocator>
+struct ordered_map;
+
+/// @brief specialization that maintains the insertion order of object keys
+/// @sa https://json.nlohmann.me/api/ordered_json/
+using ordered_json = basic_json<nlohmann::ordered_map>;
+
+NLOHMANN_JSON_NAMESPACE_END
+
+#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeCache.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeCache.txt
new file mode 100644
index 0000000000000000000000000000000000000000..04fc58d956cab2dfa17fdc9536a665c4f7ea8395
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeCache.txt
@@ -0,0 +1,117 @@
+# This is the CMakeCache file.
+# For build in directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild
+# It was generated by CMake: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+# You can edit this file to change values found and used by cmake.
+# If you do not want to change any of the values, simply exit the editor.
+# If you do want to change a value, simply edit, save, and exit the editor.
+# The syntax for the file is as follows:
+# KEY:TYPE=VALUE
+# KEY is the name of a variable in the cache.
+# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
+# VALUE is the current value for the KEY.
+
+########################
+# EXTERNAL cache entries
+########################
+
+//Enable/Disable color output during build.
+CMAKE_COLOR_MAKEFILE:BOOL=ON
+
+//Enable/Disable output of compile commands during generation.
+CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=
+
+//Value Computed by CMake.
+CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/pkgRedirects
+
+//Install path prefix, prepended onto install directories.
+CMAKE_INSTALL_PREFIX:PATH=/usr/local
+
+//No help, variable specified on the command line.
+CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/gmake
+
+//Value Computed by CMake
+CMAKE_PROJECT_DESCRIPTION:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_HOMEPAGE_URL:STATIC=
+
+//Value Computed by CMake
+CMAKE_PROJECT_NAME:STATIC=json-populate
+
+//If set, runtime paths are not added when installing shared libraries,
+// but are added when building.
+CMAKE_SKIP_INSTALL_RPATH:BOOL=NO
+
+//If set, runtime paths are not added when using shared libraries.
+CMAKE_SKIP_RPATH:BOOL=NO
+
+//If this value is on, makefiles will be generated without the
+// .SILENT directive, and all commands will be echoed to the console
+// during the make.  This is useful for debugging only. With Visual
+// Studio IDE projects all commands are done without /nologo.
+CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE
+
+//Value Computed by CMake
+json-populate_BINARY_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild
+
+//Value Computed by CMake
+json-populate_IS_TOP_LEVEL:STATIC=ON
+
+//Value Computed by CMake
+json-populate_SOURCE_DIR:STATIC=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild
+
+
+########################
+# INTERNAL cache entries
+########################
+
+//This is the directory where this CMakeCache.txt was created
+CMAKE_CACHEFILE_DIR:INTERNAL=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild
+//Major version of cmake used to create the current loaded cache
+CMAKE_CACHE_MAJOR_VERSION:INTERNAL=4
+//Minor version of cmake used to create the current loaded cache
+CMAKE_CACHE_MINOR_VERSION:INTERNAL=0
+//Patch version of cmake used to create the current loaded cache
+CMAKE_CACHE_PATCH_VERSION:INTERNAL=3
+//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
+CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
+//Path to CMake executable.
+CMAKE_COMMAND:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+//Path to cpack program executable.
+CMAKE_CPACK_COMMAND:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cpack
+//Path to ctest program executable.
+CMAKE_CTEST_COMMAND:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/ctest
+//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS
+CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1
+//Name of external makefile project generator.
+CMAKE_EXTRA_GENERATOR:INTERNAL=
+//Name of generator.
+CMAKE_GENERATOR:INTERNAL=Unix Makefiles
+//Generator instance identifier.
+CMAKE_GENERATOR_INSTANCE:INTERNAL=
+//Name of generator platform.
+CMAKE_GENERATOR_PLATFORM:INTERNAL=
+//Name of generator toolset.
+CMAKE_GENERATOR_TOOLSET:INTERNAL=
+//Source directory with the top level CMakeLists.txt file for this
+// project
+CMAKE_HOME_DIRECTORY:INTERNAL=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild
+//Install .so files without execute permission.
+CMAKE_INSTALL_SO_NO_EXE:INTERNAL=0
+//Name of CMakeLists files to read
+CMAKE_LIST_FILE_NAME:INTERNAL=CMakeLists.txt
+//number of local generators
+CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1
+//Platform information initialized
+CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1
+//Path to CMake installation.
+CMAKE_ROOT:INTERNAL=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0
+//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH
+CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1
+//ADVANCED property for variable: CMAKE_SKIP_RPATH
+CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1
+//uname command
+CMAKE_UNAME:INTERNAL=/usr/bin/uname
+//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE
+CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/4.0.3/CMakeSystem.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/4.0.3/CMakeSystem.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..6ac4680931858770a602d316fb4a5f01540d588e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/4.0.3/CMakeSystem.cmake
@@ -0,0 +1,15 @@
+set(CMAKE_HOST_SYSTEM "Linux-4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_HOST_SYSTEM_NAME "Linux")
+set(CMAKE_HOST_SYSTEM_VERSION "4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
+
+
+
+set(CMAKE_SYSTEM "Linux-4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_SYSTEM_NAME "Linux")
+set(CMAKE_SYSTEM_VERSION "4.18.0-553.75.1.el8_10.x86_64")
+set(CMAKE_SYSTEM_PROCESSOR "x86_64")
+
+set(CMAKE_CROSSCOMPILING "FALSE")
+
+set(CMAKE_SYSTEM_LOADED 1)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/CMakeConfigureLog.yaml b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/CMakeConfigureLog.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..c5d89b2e6dd4fffd370ace469a89217b70d793f1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/CMakeConfigureLog.yaml
@@ -0,0 +1,11 @@
+
+---
+events:
+  -
+    kind: "message-v1"
+    backtrace:
+      - "/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeDetermineSystem.cmake:205 (message)"
+      - "CMakeLists.txt:16 (project)"
+    message: |
+      The system is: Linux - 4.18.0-553.75.1.el8_10.x86_64 - x86_64
+...
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..4e90ee120b0acfb97277215072976c9e9dbdebce
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/CMakeRuleHashes.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/CMakeRuleHashes.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6a3470404533cb432f9e805cb5eb06376072079f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/CMakeRuleHashes.txt
@@ -0,0 +1,11 @@
+# Hashes of file build rules.
+3a5cdecff3be73be4ca595ba96ef323e CMakeFiles/json-populate
+914c0dc5467e45a086c46bb45623d2d8 CMakeFiles/json-populate-complete
+b2f783a81608c56be8d09c39521880d4 json-populate-prefix/src/json-populate-stamp/json-populate-build
+e23f1a31c3e8349e94060f0c5e5efa78 json-populate-prefix/src/json-populate-stamp/json-populate-configure
+3568a36343f2dcd8d219c38c76d71e28 json-populate-prefix/src/json-populate-stamp/json-populate-download
+020a54eca79fe62ed2a83c069bc8618b json-populate-prefix/src/json-populate-stamp/json-populate-install
+2186169eb75731753aad184fc88beef2 json-populate-prefix/src/json-populate-stamp/json-populate-mkdir
+5c076995a17f2f10b81298662bc9803f json-populate-prefix/src/json-populate-stamp/json-populate-patch
+475257c09c4152efa612203d6b36921f json-populate-prefix/src/json-populate-stamp/json-populate-test
+65672be500b53b5195ffbb987cebe98c json-populate-prefix/src/json-populate-stamp/json-populate-update
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/InstallScripts.json b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/InstallScripts.json
new file mode 100644
index 0000000000000000000000000000000000000000..26e6a0dc355e7348da5009dfa4dfe5d224802fae
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/InstallScripts.json
@@ -0,0 +1,7 @@
+{
+	"InstallScripts" : 
+	[
+		"/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/cmake_install.cmake"
+	],
+	"Parallel" : false
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/Makefile.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/Makefile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..a7f2a3fac89ca1a88b69e7cedeedcfb37a14cf7d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/Makefile.cmake
@@ -0,0 +1,53 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# The generator used is:
+set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles")
+
+# The top level Makefile was generated from the following files:
+set(CMAKE_MAKEFILE_DEPENDS
+  "CMakeCache.txt"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeGenericSystem.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeInitializeConfigs.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeSystemSpecificInformation.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/CMakeSystemSpecificInitialize.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/PatchInfo.txt.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/RepositoryInfo.txt.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/UpdateInfo.txt.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/cfgcmd.txt.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/download.cmake.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/extractfile.cmake.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/mkdirs.cmake.in"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/ExternalProject/shared_internal_commands.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linux-Initialize.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/Linux.cmake"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/share/cmake-4.0/Modules/Platform/UnixPaths.cmake"
+  "CMakeFiles/4.0.3/CMakeSystem.cmake"
+  "CMakeLists.txt"
+  "json-populate-prefix/tmp/json-populate-mkdirs.cmake"
+  )
+
+# The corresponding makefile is:
+set(CMAKE_MAKEFILE_OUTPUTS
+  "Makefile"
+  "CMakeFiles/cmake.check_cache"
+  )
+
+# Byproducts of CMake generate step:
+set(CMAKE_MAKEFILE_PRODUCTS
+  "json-populate-prefix/tmp/json-populate-mkdirs.cmake"
+  "json-populate-prefix/src/json-populate-stamp/download-json-populate.cmake"
+  "json-populate-prefix/src/json-populate-stamp/verify-json-populate.cmake"
+  "json-populate-prefix/src/json-populate-stamp/extract-json-populate.cmake"
+  "json-populate-prefix/src/json-populate-stamp/json-populate-urlinfo.txt"
+  "json-populate-prefix/src/json-populate-stamp/json-populate-update-info.txt"
+  "json-populate-prefix/src/json-populate-stamp/json-populate-patch-info.txt"
+  "json-populate-prefix/tmp/json-populate-cfgcmd.txt"
+  "CMakeFiles/CMakeDirectoryInformation.cmake"
+  )
+
+# Dependency information for all targets:
+set(CMAKE_DEPEND_INFO_FILES
+  "CMakeFiles/json-populate.dir/DependInfo.cmake"
+  )
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/Makefile2 b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/Makefile2
new file mode 100644
index 0000000000000000000000000000000000000000..3eb46add5368d7de0355863ff3e7a58076fcdcbc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/Makefile2
@@ -0,0 +1,122 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild
+
+#=============================================================================
+# Directory level rules for the build root directory
+
+# The main recursive "all" target.
+all: CMakeFiles/json-populate.dir/all
+.PHONY : all
+
+# The main recursive "codegen" target.
+codegen: CMakeFiles/json-populate.dir/codegen
+.PHONY : codegen
+
+# The main recursive "preinstall" target.
+preinstall:
+.PHONY : preinstall
+
+# The main recursive "clean" target.
+clean: CMakeFiles/json-populate.dir/clean
+.PHONY : clean
+
+#=============================================================================
+# Target rules for target CMakeFiles/json-populate.dir
+
+# All Build rule for target.
+CMakeFiles/json-populate.dir/all:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/json-populate.dir/build.make CMakeFiles/json-populate.dir/depend
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/json-populate.dir/build.make CMakeFiles/json-populate.dir/build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9 "Built target json-populate"
+.PHONY : CMakeFiles/json-populate.dir/all
+
+# Build rule for subdir invocation for target.
+CMakeFiles/json-populate.dir/rule: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles 9
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/json-populate.dir/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles 0
+.PHONY : CMakeFiles/json-populate.dir/rule
+
+# Convenience name for target.
+json-populate: CMakeFiles/json-populate.dir/rule
+.PHONY : json-populate
+
+# codegen rule for target.
+CMakeFiles/json-populate.dir/codegen:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/json-populate.dir/build.make CMakeFiles/json-populate.dir/codegen
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9 "Finished codegen for target json-populate"
+.PHONY : CMakeFiles/json-populate.dir/codegen
+
+# clean rule for target.
+CMakeFiles/json-populate.dir/clean:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/json-populate.dir/build.make CMakeFiles/json-populate.dir/clean
+.PHONY : CMakeFiles/json-populate.dir/clean
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/TargetDirectories.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/TargetDirectories.txt
new file mode 100644
index 0000000000000000000000000000000000000000..12cc91690a14d173393455f5109c0f7539b6358f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/TargetDirectories.txt
@@ -0,0 +1,3 @@
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/edit_cache.dir
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/rebuild_cache.dir
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/cmake.check_cache b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/cmake.check_cache
new file mode 100644
index 0000000000000000000000000000000000000000..3dccd731726d7faa8b29d8d7dba3b981a53ca497
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/cmake.check_cache
@@ -0,0 +1 @@
+# This file is generated by cmake for dependency checking of the CMakeCache.txt file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate-complete b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate-complete
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/DependInfo.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/DependInfo.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..29b95a515e51db792a1019bc6c3419b6d78ec34c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/DependInfo.cmake
@@ -0,0 +1,22 @@
+
+# Consider dependencies only in project.
+set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
+
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  )
+
+# The set of dependency files which are needed:
+set(CMAKE_DEPENDS_DEPENDENCY_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/Labels.json b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/Labels.json
new file mode 100644
index 0000000000000000000000000000000000000000..3b9531b4870d00a561d966bfe0adccfc48f13f8a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/Labels.json
@@ -0,0 +1,46 @@
+{
+	"sources" : 
+	[
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate-complete.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-build.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-configure.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-download.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-install.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-mkdir.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-patch.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-test.rule"
+		},
+		{
+			"file" : "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-update.rule"
+		}
+	],
+	"target" : 
+	{
+		"labels" : 
+		[
+			"json-populate"
+		],
+		"name" : "json-populate"
+	}
+}
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/Labels.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/Labels.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5465b730466a7506f3d0d5a1961172d574f7bb66
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/Labels.txt
@@ -0,0 +1,14 @@
+# Target labels
+ json-populate
+# Source files and their labels
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate-complete.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-build.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-configure.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-download.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-install.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-mkdir.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-patch.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-test.rule
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-update.rule
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/build.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/build.make
new file mode 100644
index 0000000000000000000000000000000000000000..8d14248dbd7ebf8102628c0e499435dbc1716825
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/build.make
@@ -0,0 +1,159 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild
+
+# Utility rule file for json-populate.
+
+# Include any custom commands dependencies for this target.
+include CMakeFiles/json-populate.dir/compiler_depend.make
+
+# Include the progress variables for this target.
+include CMakeFiles/json-populate.dir/progress.make
+
+CMakeFiles/json-populate: CMakeFiles/json-populate-complete
+
+CMakeFiles/json-populate-complete: json-populate-prefix/src/json-populate-stamp/json-populate-install
+CMakeFiles/json-populate-complete: json-populate-prefix/src/json-populate-stamp/json-populate-mkdir
+CMakeFiles/json-populate-complete: json-populate-prefix/src/json-populate-stamp/json-populate-download
+CMakeFiles/json-populate-complete: json-populate-prefix/src/json-populate-stamp/json-populate-update
+CMakeFiles/json-populate-complete: json-populate-prefix/src/json-populate-stamp/json-populate-patch
+CMakeFiles/json-populate-complete: json-populate-prefix/src/json-populate-stamp/json-populate-configure
+CMakeFiles/json-populate-complete: json-populate-prefix/src/json-populate-stamp/json-populate-build
+CMakeFiles/json-populate-complete: json-populate-prefix/src/json-populate-stamp/json-populate-install
+CMakeFiles/json-populate-complete: json-populate-prefix/src/json-populate-stamp/json-populate-test
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Completed 'json-populate'"
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E make_directory /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate-complete
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-done
+
+json-populate-prefix/src/json-populate-stamp/json-populate-build: json-populate-prefix/src/json-populate-stamp/json-populate-configure
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "No build step for 'json-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-build
+
+json-populate-prefix/src/json-populate-stamp/json-populate-configure: json-populate-prefix/tmp/json-populate-cfgcmd.txt
+json-populate-prefix/src/json-populate-stamp/json-populate-configure: json-populate-prefix/src/json-populate-stamp/json-populate-patch
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "No configure step for 'json-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-configure
+
+json-populate-prefix/src/json-populate-stamp/json-populate-download: json-populate-prefix/src/json-populate-stamp/download-json-populate.cmake
+json-populate-prefix/src/json-populate-stamp/json-populate-download: json-populate-prefix/src/json-populate-stamp/json-populate-urlinfo.txt
+json-populate-prefix/src/json-populate-stamp/json-populate-download: json-populate-prefix/src/json-populate-stamp/json-populate-mkdir
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Performing download step (download, verify and extract) for 'json-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE -P /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/download-json-populate.cmake
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE -P /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/verify-json-populate.cmake
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE -P /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/extract-json-populate.cmake
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-download
+
+json-populate-prefix/src/json-populate-stamp/json-populate-install: json-populate-prefix/src/json-populate-stamp/json-populate-build
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "No install step for 'json-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-install
+
+json-populate-prefix/src/json-populate-stamp/json-populate-mkdir:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_6) "Creating directories for 'json-populate'"
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -Dcfgdir= -P /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/tmp/json-populate-mkdirs.cmake
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-mkdir
+
+json-populate-prefix/src/json-populate-stamp/json-populate-patch: json-populate-prefix/src/json-populate-stamp/json-populate-patch-info.txt
+json-populate-prefix/src/json-populate-stamp/json-populate-patch: json-populate-prefix/src/json-populate-stamp/json-populate-update
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_7) "No patch step for 'json-populate'"
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-patch
+
+json-populate-prefix/src/json-populate-stamp/json-populate-test: json-populate-prefix/src/json-populate-stamp/json-populate-install
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_8) "No test step for 'json-populate'"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build && /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-test
+
+json-populate-prefix/src/json-populate-stamp/json-populate-update: json-populate-prefix/src/json-populate-stamp/json-populate-update-info.txt
+json-populate-prefix/src/json-populate-stamp/json-populate-update: json-populate-prefix/src/json-populate-stamp/json-populate-download
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles --progress-num=$(CMAKE_PROGRESS_9) "No update step for 'json-populate'"
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo_append
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E touch /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-update
+
+CMakeFiles/json-populate.dir/codegen:
+.PHONY : CMakeFiles/json-populate.dir/codegen
+
+json-populate: CMakeFiles/json-populate
+json-populate: CMakeFiles/json-populate-complete
+json-populate: json-populate-prefix/src/json-populate-stamp/json-populate-build
+json-populate: json-populate-prefix/src/json-populate-stamp/json-populate-configure
+json-populate: json-populate-prefix/src/json-populate-stamp/json-populate-download
+json-populate: json-populate-prefix/src/json-populate-stamp/json-populate-install
+json-populate: json-populate-prefix/src/json-populate-stamp/json-populate-mkdir
+json-populate: json-populate-prefix/src/json-populate-stamp/json-populate-patch
+json-populate: json-populate-prefix/src/json-populate-stamp/json-populate-test
+json-populate: json-populate-prefix/src/json-populate-stamp/json-populate-update
+json-populate: CMakeFiles/json-populate.dir/build.make
+.PHONY : json-populate
+
+# Rule to build all files generated by this target.
+CMakeFiles/json-populate.dir/build: json-populate
+.PHONY : CMakeFiles/json-populate.dir/build
+
+CMakeFiles/json-populate.dir/clean:
+	$(CMAKE_COMMAND) -P CMakeFiles/json-populate.dir/cmake_clean.cmake
+.PHONY : CMakeFiles/json-populate.dir/clean
+
+CMakeFiles/json-populate.dir/depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/DependInfo.cmake "--color=$(COLOR)"
+.PHONY : CMakeFiles/json-populate.dir/depend
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/cmake_clean.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/cmake_clean.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ab5823b74eaf3a331a469afb3a5ed775e2b6452f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/cmake_clean.cmake
@@ -0,0 +1,17 @@
+file(REMOVE_RECURSE
+  "CMakeFiles/json-populate"
+  "CMakeFiles/json-populate-complete"
+  "json-populate-prefix/src/json-populate-stamp/json-populate-build"
+  "json-populate-prefix/src/json-populate-stamp/json-populate-configure"
+  "json-populate-prefix/src/json-populate-stamp/json-populate-download"
+  "json-populate-prefix/src/json-populate-stamp/json-populate-install"
+  "json-populate-prefix/src/json-populate-stamp/json-populate-mkdir"
+  "json-populate-prefix/src/json-populate-stamp/json-populate-patch"
+  "json-populate-prefix/src/json-populate-stamp/json-populate-test"
+  "json-populate-prefix/src/json-populate-stamp/json-populate-update"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang )
+  include(CMakeFiles/json-populate.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/compiler_depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/compiler_depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..5168a0f3cfef6574b05673d9987958aaded51270
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/compiler_depend.make
@@ -0,0 +1,2 @@
+# Empty custom commands generated dependencies file for json-populate.
+# This may be replaced when dependencies are built.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/compiler_depend.ts b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/compiler_depend.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e213017fd88cafadedce908951483ff42446222e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/compiler_depend.ts
@@ -0,0 +1,2 @@
+# CMAKE generated file: DO NOT EDIT!
+# Timestamp file for custom commands dependencies management for json-populate.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/progress.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/progress.make
new file mode 100644
index 0000000000000000000000000000000000000000..d4f6ce35d26a4136a4edb4873325a1cadb14ccfe
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/json-populate.dir/progress.make
@@ -0,0 +1,10 @@
+CMAKE_PROGRESS_1 = 1
+CMAKE_PROGRESS_2 = 2
+CMAKE_PROGRESS_3 = 3
+CMAKE_PROGRESS_4 = 4
+CMAKE_PROGRESS_5 = 5
+CMAKE_PROGRESS_6 = 6
+CMAKE_PROGRESS_7 = 7
+CMAKE_PROGRESS_8 = 8
+CMAKE_PROGRESS_9 = 9
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..ec635144f60048986bc560c5576355344005e6e7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+9
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeLists.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..224b609208f7a6b4e5e8ef7893cce2d1096d1f8e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeLists.txt
@@ -0,0 +1,34 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION 4.0.3)
+
+# Reject any attempt to use a toolchain file. We must not use one because
+# we could be downloading it here. If the CMAKE_TOOLCHAIN_FILE environment
+# variable is set, the cache variable will have been initialized from it.
+unset(CMAKE_TOOLCHAIN_FILE CACHE)
+unset(ENV{CMAKE_TOOLCHAIN_FILE})
+
+# We name the project and the target for the ExternalProject_Add() call
+# to something that will highlight to the user what we are working on if
+# something goes wrong and an error message is produced.
+
+project(json-populate NONE)
+
+
+
+include(ExternalProject)
+ExternalProject_Add(json-populate
+                     "UPDATE_DISCONNECTED" "False" "DOWNLOAD_EXTRACT_TIMESTAMP" "FALSE" "EXTERNALPROJECT_INTERNAL_ARGUMENT_SEPARATOR" "URL" "https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz"
+                    SOURCE_DIR          "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src"
+                    BINARY_DIR          "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build"
+                    CONFIGURE_COMMAND   ""
+                    BUILD_COMMAND       ""
+                    INSTALL_COMMAND     ""
+                    TEST_COMMAND        ""
+                    USES_TERMINAL_DOWNLOAD  YES
+                    USES_TERMINAL_UPDATE    YES
+                    USES_TERMINAL_PATCH     YES
+)
+
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..6f5d801bad555a349e548ed8cdc279ea9f7e9a05
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/Makefile
@@ -0,0 +1,162 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# The main all target
+all: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild//CMakeFiles/progress.marks
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles 0
+.PHONY : all
+
+# The main codegen target
+codegen: cmake_check_build_system
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild//CMakeFiles/progress.marks
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 codegen
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/CMakeFiles 0
+.PHONY : codegen
+
+# The main clean target
+clean:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+#=============================================================================
+# Target rules for targets named json-populate
+
+# Build rule for target.
+json-populate: cmake_check_build_system
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 json-populate
+.PHONY : json-populate
+
+# fast build rule for target.
+json-populate/fast:
+	$(MAKE) $(MAKESILENT) -f CMakeFiles/json-populate.dir/build.make CMakeFiles/json-populate.dir/build
+.PHONY : json-populate/fast
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... codegen"
+	@echo "... edit_cache"
+	@echo "... rebuild_cache"
+	@echo "... json-populate"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..cd6127379356c029fe09027b9f47771ab592bfbc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/cmake_install.cmake
@@ -0,0 +1,61 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/usr/local")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
+if(CMAKE_INSTALL_COMPONENT)
+  if(CMAKE_INSTALL_COMPONENT MATCHES "^[a-zA-Z0-9_.+-]+$")
+    set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt")
+  else()
+    string(MD5 CMAKE_INST_COMP_HASH "${CMAKE_INSTALL_COMPONENT}")
+    set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INST_COMP_HASH}.txt")
+    unset(CMAKE_INST_COMP_HASH)
+  endif()
+else()
+  set(CMAKE_INSTALL_MANIFEST "install_manifest.txt")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/${CMAKE_INSTALL_MANIFEST}"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/download-json-populate.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/download-json-populate.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..f75dd475f11ccbb5d82311c6f2f8a2a2b9ead53c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/download-json-populate.cmake
@@ -0,0 +1,166 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+function(check_file_hash has_hash hash_is_good)
+  if("${has_hash}" STREQUAL "")
+    message(FATAL_ERROR "has_hash Can't be empty")
+  endif()
+
+  if("${hash_is_good}" STREQUAL "")
+    message(FATAL_ERROR "hash_is_good Can't be empty")
+  endif()
+
+  if("" STREQUAL "")
+    # No check
+    set("${has_hash}" FALSE PARENT_SCOPE)
+    set("${hash_is_good}" FALSE PARENT_SCOPE)
+    return()
+  endif()
+
+  set("${has_hash}" TRUE PARENT_SCOPE)
+
+  message(VERBOSE "verifying file...
+       file='/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz'")
+
+  file("" "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz" actual_value)
+
+  if(NOT "${actual_value}" STREQUAL "")
+    set("${hash_is_good}" FALSE PARENT_SCOPE)
+    message(VERBOSE " hash of
+    /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz
+  does not match expected value
+    expected: ''
+      actual: '${actual_value}'")
+  else()
+    set("${hash_is_good}" TRUE PARENT_SCOPE)
+  endif()
+endfunction()
+
+function(sleep_before_download attempt)
+  if(attempt EQUAL 0)
+    return()
+  endif()
+
+  if(attempt EQUAL 1)
+    message(VERBOSE "Retrying...")
+    return()
+  endif()
+
+  set(sleep_seconds 0)
+
+  if(attempt EQUAL 2)
+    set(sleep_seconds 5)
+  elseif(attempt EQUAL 3)
+    set(sleep_seconds 5)
+  elseif(attempt EQUAL 4)
+    set(sleep_seconds 15)
+  elseif(attempt EQUAL 5)
+    set(sleep_seconds 60)
+  elseif(attempt EQUAL 6)
+    set(sleep_seconds 90)
+  elseif(attempt EQUAL 7)
+    set(sleep_seconds 300)
+  else()
+    set(sleep_seconds 1200)
+  endif()
+
+  message(VERBOSE "Retry after ${sleep_seconds} seconds (attempt #${attempt}) ...")
+
+  execute_process(COMMAND "${CMAKE_COMMAND}" -E sleep "${sleep_seconds}")
+endfunction()
+
+if(EXISTS "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz")
+  check_file_hash(has_hash hash_is_good)
+  if(has_hash)
+    if(hash_is_good)
+      message(VERBOSE "File already exists and hash match (skip download):
+  file='/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz'
+  =''"
+      )
+      return()
+    else()
+      message(VERBOSE "File already exists but hash mismatch. Removing...")
+      file(REMOVE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz")
+    endif()
+  else()
+    message(VERBOSE "File already exists but no hash specified (use URL_HASH):
+  file='/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz'
+Old file will be removed and new file downloaded from URL."
+    )
+    file(REMOVE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz")
+  endif()
+endif()
+
+set(retry_number 5)
+
+message(VERBOSE "Downloading...
+   dst='/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz'
+   timeout='none'
+   inactivity timeout='none'"
+)
+set(download_retry_codes 7 6 8 15 28 35)
+set(skip_url_list)
+set(status_code)
+foreach(i RANGE ${retry_number})
+  if(status_code IN_LIST download_retry_codes)
+    sleep_before_download(${i})
+  endif()
+  foreach(url IN ITEMS [====[https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz]====])
+    if(NOT url IN_LIST skip_url_list)
+      message(VERBOSE "Using src='${url}'")
+
+      
+      
+      
+      
+      
+
+      file(
+        DOWNLOAD
+        "${url}" "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz"
+        SHOW_PROGRESS
+        # no TIMEOUT
+        # no INACTIVITY_TIMEOUT
+        STATUS status
+        LOG log
+        
+        
+        )
+
+      list(GET status 0 status_code)
+      list(GET status 1 status_string)
+
+      if(status_code EQUAL 0)
+        check_file_hash(has_hash hash_is_good)
+        if(has_hash AND NOT hash_is_good)
+          message(VERBOSE "Hash mismatch, removing...")
+          file(REMOVE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz")
+        else()
+          message(VERBOSE "Downloading... done")
+          return()
+        endif()
+      else()
+        string(APPEND logFailedURLs "error: downloading '${url}' failed
+        status_code: ${status_code}
+        status_string: ${status_string}
+        log:
+        --- LOG BEGIN ---
+        ${log}
+        --- LOG END ---
+        "
+        )
+      if(NOT status_code IN_LIST download_retry_codes)
+        list(APPEND skip_url_list "${url}")
+        break()
+      endif()
+    endif()
+  endif()
+  endforeach()
+endforeach()
+
+message(FATAL_ERROR "Each download failed!
+  ${logFailedURLs}
+  "
+)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/extract-json-populate.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/extract-json-populate.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e8933e3cb1461624164307e121c37bf621059561
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/extract-json-populate.cmake
@@ -0,0 +1,65 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+# Make file names absolute:
+#
+get_filename_component(filename "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz" ABSOLUTE)
+get_filename_component(directory "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src" ABSOLUTE)
+
+message(VERBOSE "extracting...
+     src='${filename}'
+     dst='${directory}'"
+)
+
+if(NOT EXISTS "${filename}")
+  message(FATAL_ERROR "File to extract does not exist: '${filename}'")
+endif()
+
+# Prepare a space for extracting:
+#
+set(i 1234)
+while(EXISTS "${directory}/../ex-json-populate${i}")
+  math(EXPR i "${i} + 1")
+endwhile()
+set(ut_dir "${directory}/../ex-json-populate${i}")
+file(MAKE_DIRECTORY "${ut_dir}")
+
+# Extract it:
+#
+message(VERBOSE "extracting... [tar xfz]")
+execute_process(COMMAND ${CMAKE_COMMAND} -E tar xfz ${filename} --touch
+  WORKING_DIRECTORY ${ut_dir}
+  RESULT_VARIABLE rv
+)
+
+if(NOT rv EQUAL 0)
+  message(VERBOSE "extracting... [error clean up]")
+  file(REMOVE_RECURSE "${ut_dir}")
+  message(FATAL_ERROR "Extract of '${filename}' failed")
+endif()
+
+# Analyze what came out of the tar file:
+#
+message(VERBOSE "extracting... [analysis]")
+file(GLOB contents "${ut_dir}/*")
+list(REMOVE_ITEM contents "${ut_dir}/.DS_Store")
+list(LENGTH contents n)
+if(NOT n EQUAL 1 OR NOT IS_DIRECTORY "${contents}")
+  set(contents "${ut_dir}")
+endif()
+
+# Move "the one" directory to the final directory:
+#
+message(VERBOSE "extracting... [rename]")
+file(REMOVE_RECURSE ${directory})
+get_filename_component(contents ${contents} ABSOLUTE)
+file(RENAME ${contents} ${directory})
+
+# Clean up:
+#
+message(VERBOSE "extracting... [clean up]")
+file(REMOVE_RECURSE "${ut_dir}")
+
+message(VERBOSE "extracting... done")
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-build b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-build
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-configure b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-configure
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-done b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-done
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-download b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-download
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-install b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-install
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-mkdir b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-mkdir
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-patch b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-patch
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-patch-info.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-patch-info.txt
new file mode 100644
index 0000000000000000000000000000000000000000..53e1e1e6854ba141183d4dc9c77325b48e4b99da
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-patch-info.txt
@@ -0,0 +1,6 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The update step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+command=
+work_dir=
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-test b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-test
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-update b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-update
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-update-info.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-update-info.txt
new file mode 100644
index 0000000000000000000000000000000000000000..31617d15d10db1324dba7f1794b96ab45c63cad3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-update-info.txt
@@ -0,0 +1,7 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The patch step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+command (connected)=
+command (disconnected)=
+work_dir=
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-urlinfo.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-urlinfo.txt
new file mode 100644
index 0000000000000000000000000000000000000000..da3014fe63b8e906cd013bc3f1593b798ed5b082
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/json-populate-urlinfo.txt
@@ -0,0 +1,12 @@
+# This is a generated file and its contents are an internal implementation detail.
+# The download step will be re-executed if anything in this file changes.
+# No other meaning or use of this file is supported.
+
+method=url
+command=/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake;-DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE;-P;/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/download-json-populate.cmake;COMMAND;/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake;-DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE;-P;/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/verify-json-populate.cmake;COMMAND;/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake;-DCMAKE_MESSAGE_LOG_LEVEL=VERBOSE;-P;/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/extract-json-populate.cmake
+source_dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src
+work_dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps
+url(s)=https://github.com/nlohmann/json/releases/download/v3.11.3/json.tar.xz
+hash=
+      no_extract=
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/verify-json-populate.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/verify-json-populate.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz
new file mode 100644
index 0000000000000000000000000000000000000000..e431f368499bc14ea59058727dce7cb167fcc1ca
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json.tar.xz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d6c65aca6b1ed68e7a182f4757257b107ae403032760ed6ef121c9d55e81757d
+size 110988
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/tmp/json-populate-cfgcmd.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/tmp/json-populate-cfgcmd.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6a6ed5fd2a2f3671b44653100d811d1afbc218c1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/tmp/json-populate-cfgcmd.txt
@@ -0,0 +1 @@
+cmd=''
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/tmp/json-populate-mkdirs.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/tmp/json-populate-mkdirs.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..00b844e543a050539c9299a230d8de2d94b8b8d8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/tmp/json-populate-mkdirs.cmake
@@ -0,0 +1,27 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+cmake_minimum_required(VERSION ${CMAKE_VERSION}) # this file comes with cmake
+
+# If CMAKE_DISABLE_SOURCE_CHANGES is set to true and the source directory is an
+# existing directory in our source tree, calling file(MAKE_DIRECTORY) on it
+# would cause a fatal error, even though it would be a no-op.
+if(NOT EXISTS "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src")
+  file(MAKE_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src")
+endif()
+file(MAKE_DIRECTORY
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/tmp"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp"
+)
+
+set(configSubDirs )
+foreach(subDir IN LISTS configSubDirs)
+    file(MAKE_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp/${subDir}")
+endforeach()
+if(cfgdir)
+  file(MAKE_DIRECTORY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-subbuild/json-populate-prefix/src/json-populate-stamp${cfgdir}") # cfgdir has leading slash
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..fb953201cf9a67ab7a8e369781f62893859db919
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/cmake_install.cmake
@@ -0,0 +1,138 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  # Include the install script for the subdirectory.
+  include("/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-build/cmake_install.cmake")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  # Include the install script for the subdirectory.
+  include("/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/cmake_install.cmake")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  # Include the install script for the subdirectory.
+  include("/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/cmake_install.cmake")
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  if(EXISTS "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/libmlx.so" AND
+     NOT IS_SYMLINK "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/libmlx.so")
+    file(RPATH_CHECK
+         FILE "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/libmlx.so"
+         RPATH "")
+  endif()
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/lib64" TYPE SHARED_LIBRARY MESSAGE_NEVER FILES "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/libmlx.so")
+  if(EXISTS "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/libmlx.so" AND
+     NOT IS_SYMLINK "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/libmlx.so")
+    if(CMAKE_INSTALL_DO_STRIP)
+      execute_process(COMMAND "/usr/bin/strip" "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/lib64/libmlx.so")
+    endif()
+  endif()
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "headers" OR NOT CMAKE_INSTALL_COMPONENT)
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/include" TYPE DIRECTORY MESSAGE_NEVER FILES "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx" FILES_MATCHING REGEX "/[^/]*\\.h$" REGEX "/backend\\/metal\\/kernels\\.h$" EXCLUDE)
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  if(EXISTS "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/share/cmake/MLX/MLXTargets.cmake")
+    file(DIFFERENT _cmake_export_file_changed FILES
+         "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/share/cmake/MLX/MLXTargets.cmake"
+         "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Export/1e8da368a82b8fcebd3a63675e0335e4/MLXTargets.cmake")
+    if(_cmake_export_file_changed)
+      file(GLOB _cmake_old_config_files "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/share/cmake/MLX/MLXTargets-*.cmake")
+      if(_cmake_old_config_files)
+        string(REPLACE ";" ", " _cmake_old_config_files_text "${_cmake_old_config_files}")
+        message(STATUS "Old export file \"$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/share/cmake/MLX/MLXTargets.cmake\" will be replaced.  Removing files [${_cmake_old_config_files_text}].")
+        unset(_cmake_old_config_files_text)
+        file(REMOVE ${_cmake_old_config_files})
+      endif()
+      unset(_cmake_old_config_files)
+    endif()
+    unset(_cmake_export_file_changed)
+  endif()
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/share/cmake/MLX" TYPE FILE MESSAGE_NEVER FILES "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Export/1e8da368a82b8fcebd3a63675e0335e4/MLXTargets.cmake")
+  if(CMAKE_INSTALL_CONFIG_NAME MATCHES "^([Rr][Ee][Ll][Ee][Aa][Ss][Ee])$")
+    file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/share/cmake/MLX" TYPE FILE MESSAGE_NEVER FILES "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles/Export/1e8da368a82b8fcebd3a63675e0335e4/MLXTargets-release.cmake")
+  endif()
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/share/cmake/MLX" TYPE FILE MESSAGE_NEVER FILES
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/MLXConfig.cmake"
+    "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/MLXConfigVersion.cmake"
+    )
+endif()
+
+if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
+  file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/share/cmake/MLX" TYPE DIRECTORY MESSAGE_NEVER FILES "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/cmake/")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
+if(CMAKE_INSTALL_COMPONENT)
+  if(CMAKE_INSTALL_COMPONENT MATCHES "^[a-zA-Z0-9_.+-]+$")
+    set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt")
+  else()
+    string(MD5 CMAKE_INST_COMP_HASH "${CMAKE_INSTALL_COMPONENT}")
+    set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INST_COMP_HASH}.txt")
+    unset(CMAKE_INST_COMP_HASH)
+  endif()
+else()
+  set(CMAKE_INSTALL_MANIFEST "install_manifest.txt")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/${CMAKE_INSTALL_MANIFEST}"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/compile_commands.json b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/compile_commands.json
new file mode 100644
index 0000000000000000000000000000000000000000..591f0a531bf82f0d9ad196200a3c2c4dd60414d4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/compile_commands.json
@@ -0,0 +1,692 @@
+[
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/allocator.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/allocator.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/allocator.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/array.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/array.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/array.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/compile.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/compile.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/compile.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/device.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/device.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/device.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/dtype.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/dtype.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/dtype_utils.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/export.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/export.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/export.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/einsum.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/einsum.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/einsum.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/fast.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fast.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/fast.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/fft.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/fft.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/fft.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/ops.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/ops.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/ops.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/graph_utils.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/graph_utils.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/primitives.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/primitives.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/primitives.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/random.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/random.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/random.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/scheduler.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/scheduler.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/scheduler.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/transforms.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/transforms.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/transforms.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/utils.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/utils.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/utils.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/linalg.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/linalg.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/linalg.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/common/broadcasting.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/common/compiled.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/common/common.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/common/load.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/common/reduce.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/common/slicing.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/common/utils.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/available.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/arg_reduce.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/binary.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/conv.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/copy.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/distributed.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/eig.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/eigh.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/encoder.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/fft.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/hadamard.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/matmul.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/cblas.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/masked_mm.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/primitives.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/quantized.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/reduce.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/scan.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/select.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/softmax.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/logsumexp.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/sort.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/threefry.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/indexing.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/luf.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/qrf.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/svd.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/inverse.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/cholesky.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/unary.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/eval.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/compiled_preamble.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/compiled_preamble.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/compiled_preamble.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_fp16.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/gemms/simd_bf16.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/compiled.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cpu/jit_compiler.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/distributed/primitives.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/distributed/ops.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/distributed/distributed.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/distributed/mpi/mpi.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/distributed/ring/ring.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/distributed/nccl/no_nccl.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/io/load.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/load.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/io/load.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/io/safetensors.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/io/gguf.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/io/gguf_quants.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/metal/no_metal.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/cuda/no_cuda.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/no_gpu/allocator.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/no_gpu/event.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/no_gpu/fence.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/no_gpu/eval.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core",
+  "command": "/usr/bin/c++ -DFMT_HEADER_ONLY=1 -I/software/sse/manual/OpenBLAS/0.3.23/gcc-12.3.0/sequential/lp64/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/json-src/single_include/nlohmann -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp",
+  "output": "CMakeFiles/mlx.dir/mlx/backend/no_gpu/primitives.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx",
+  "command": "/usr/bin/c++ -DMLX_VERSION=\\\"0.29.2.dev20251007+0073096d\\\"  -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/mlx_version.dir/version.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.cpp",
+  "output": "mlx/CMakeFiles/mlx_version.dir/version.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io",
+  "command": "/usr/bin/cc   -O3 -DNDEBUG -fPIC -o CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.c",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.c",
+  "output": "mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io",
+  "command": "/usr/bin/cc   -O3 -DNDEBUG -fPIC -o CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.c",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.c",
+  "output": "mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build",
+  "command": "/usr/bin/c++ -DFMT_LIB_EXPORT -Dfmt_EXPORTS -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/fmt.dir/src/format.cc.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/format.cc",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/format.cc",
+  "output": "_deps/fmt-build/CMakeFiles/fmt.dir/src/format.cc.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-build",
+  "command": "/usr/bin/c++ -DFMT_LIB_EXPORT -Dfmt_EXPORTS -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/include -O3 -DNDEBUG -std=gnu++17 -fPIC -o CMakeFiles/fmt.dir/src/os.cc.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/os.cc",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/fmt-src/src/os.cc",
+  "output": "_deps/fmt-build/CMakeFiles/fmt.dir/src/os.cc.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_COMPACT_ASSERTIONS -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -O3 -DNDEBUG -std=gnu++17 -fPIC -fvisibility=hidden -ffunction-sections -fdata-sections -fno-strict-aliasing -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp",
+  "output": "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_COMPACT_ASSERTIONS -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -O3 -DNDEBUG -std=gnu++17 -fPIC -fvisibility=hidden -ffunction-sections -fdata-sections -fno-strict-aliasing -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp",
+  "output": "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_COMPACT_ASSERTIONS -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -O3 -DNDEBUG -std=gnu++17 -fPIC -fvisibility=hidden -ffunction-sections -fdata-sections -fno-strict-aliasing -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp",
+  "output": "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_COMPACT_ASSERTIONS -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -O3 -DNDEBUG -std=gnu++17 -fPIC -fvisibility=hidden -ffunction-sections -fdata-sections -fno-strict-aliasing -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp",
+  "output": "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_COMPACT_ASSERTIONS -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -O3 -DNDEBUG -std=gnu++17 -fPIC -fvisibility=hidden -ffunction-sections -fdata-sections -fno-strict-aliasing -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp",
+  "output": "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_COMPACT_ASSERTIONS -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -O3 -DNDEBUG -std=gnu++17 -fPIC -fvisibility=hidden -ffunction-sections -fdata-sections -fno-strict-aliasing -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp",
+  "output": "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_COMPACT_ASSERTIONS -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -O3 -DNDEBUG -std=gnu++17 -fPIC -fvisibility=hidden -ffunction-sections -fdata-sections -fno-strict-aliasing -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp",
+  "output": "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_COMPACT_ASSERTIONS -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -O3 -DNDEBUG -std=gnu++17 -fPIC -fvisibility=hidden -ffunction-sections -fdata-sections -fno-strict-aliasing -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp",
+  "output": "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_COMPACT_ASSERTIONS -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -O3 -DNDEBUG -std=gnu++17 -fPIC -fvisibility=hidden -ffunction-sections -fdata-sections -fno-strict-aliasing -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp",
+  "output": "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_COMPACT_ASSERTIONS -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -O3 -DNDEBUG -std=gnu++17 -fPIC -fvisibility=hidden -ffunction-sections -fdata-sections -fno-strict-aliasing -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp",
+  "output": "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/mlx.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx.cpp",
+  "output": "python/src/CMakeFiles/core.dir/mlx.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/array.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/array.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/array.cpp",
+  "output": "python/src/CMakeFiles/core.dir/array.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/convert.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/convert.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/convert.cpp",
+  "output": "python/src/CMakeFiles/core.dir/convert.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/device.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/device.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/device.cpp",
+  "output": "python/src/CMakeFiles/core.dir/device.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/distributed.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/distributed.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/distributed.cpp",
+  "output": "python/src/CMakeFiles/core.dir/distributed.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/export.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/export.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/export.cpp",
+  "output": "python/src/CMakeFiles/core.dir/export.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/fast.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fast.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fast.cpp",
+  "output": "python/src/CMakeFiles/core.dir/fast.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/fft.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fft.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fft.cpp",
+  "output": "python/src/CMakeFiles/core.dir/fft.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/indexing.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/indexing.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/indexing.cpp",
+  "output": "python/src/CMakeFiles/core.dir/indexing.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/load.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/load.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/load.cpp",
+  "output": "python/src/CMakeFiles/core.dir/load.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/metal.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/metal.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/metal.cpp",
+  "output": "python/src/CMakeFiles/core.dir/metal.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/cuda.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/cuda.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/cuda.cpp",
+  "output": "python/src/CMakeFiles/core.dir/cuda.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/memory.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/memory.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/memory.cpp",
+  "output": "python/src/CMakeFiles/core.dir/memory.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/mlx_func.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx_func.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx_func.cpp",
+  "output": "python/src/CMakeFiles/core.dir/mlx_func.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/ops.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/ops.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/ops.cpp",
+  "output": "python/src/CMakeFiles/core.dir/ops.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/stream.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/stream.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/stream.cpp",
+  "output": "python/src/CMakeFiles/core.dir/stream.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/transforms.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/transforms.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/transforms.cpp",
+  "output": "python/src/CMakeFiles/core.dir/transforms.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/random.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/random.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/random.cpp",
+  "output": "python/src/CMakeFiles/core.dir/random.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/linalg.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/linalg.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/linalg.cpp",
+  "output": "python/src/CMakeFiles/core.dir/linalg.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/constants.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/constants.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/constants.cpp",
+  "output": "python/src/CMakeFiles/core.dir/constants.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/trees.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/trees.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/trees.cpp",
+  "output": "python/src/CMakeFiles/core.dir/trees.cpp.o"
+},
+{
+  "directory": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src",
+  "command": "/usr/bin/c++ -DNB_DOMAIN=mlx -Dcore_EXPORTS -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections -o CMakeFiles/core.dir/utils.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/utils.cpp",
+  "file": "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/utils.cpp",
+  "output": "python/src/CMakeFiles/core.dir/utils.cpp.o"
+}
+]
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb9de92640e91b3d38364ee7a569cd8b862951
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/DependInfo.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/DependInfo.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..a5fee79a9850a4dcdbe1943b0b62e93896126f38
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/DependInfo.cmake
@@ -0,0 +1,23 @@
+
+# Consider dependencies only in project.
+set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
+
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  )
+
+# The set of dependency files which are needed:
+set(CMAKE_DEPENDS_DEPENDENCY_FILES
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.cpp" "mlx/CMakeFiles/mlx_version.dir/version.cpp.o" "gcc" "mlx/CMakeFiles/mlx_version.dir/version.cpp.o.d"
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/build.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/build.make
new file mode 100644
index 0000000000000000000000000000000000000000..1b954b4df953b07eb86202de4dd3a302abd81960
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/build.make
@@ -0,0 +1,104 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+# Include any dependencies generated for this target.
+include mlx/CMakeFiles/mlx_version.dir/depend.make
+# Include any dependencies generated by the compiler for this target.
+include mlx/CMakeFiles/mlx_version.dir/compiler_depend.make
+
+# Include the progress variables for this target.
+include mlx/CMakeFiles/mlx_version.dir/progress.make
+
+# Include the compile flags for this target's objects.
+include mlx/CMakeFiles/mlx_version.dir/flags.make
+
+mlx/CMakeFiles/mlx_version.dir/codegen:
+.PHONY : mlx/CMakeFiles/mlx_version.dir/codegen
+
+mlx/CMakeFiles/mlx_version.dir/version.cpp.o: mlx/CMakeFiles/mlx_version.dir/flags.make
+mlx/CMakeFiles/mlx_version.dir/version.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.cpp
+mlx/CMakeFiles/mlx_version.dir/version.cpp.o: mlx/CMakeFiles/mlx_version.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object mlx/CMakeFiles/mlx_version.dir/version.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT mlx/CMakeFiles/mlx_version.dir/version.cpp.o -MF CMakeFiles/mlx_version.dir/version.cpp.o.d -o CMakeFiles/mlx_version.dir/version.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.cpp
+
+mlx/CMakeFiles/mlx_version.dir/version.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mlx_version.dir/version.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.cpp > CMakeFiles/mlx_version.dir/version.cpp.i
+
+mlx/CMakeFiles/mlx_version.dir/version.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mlx_version.dir/version.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.cpp -o CMakeFiles/mlx_version.dir/version.cpp.s
+
+mlx_version: mlx/CMakeFiles/mlx_version.dir/version.cpp.o
+mlx_version: mlx/CMakeFiles/mlx_version.dir/build.make
+.PHONY : mlx_version
+
+# Rule to build all files generated by this target.
+mlx/CMakeFiles/mlx_version.dir/build: mlx_version
+.PHONY : mlx/CMakeFiles/mlx_version.dir/build
+
+mlx/CMakeFiles/mlx_version.dir/clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx && $(CMAKE_COMMAND) -P CMakeFiles/mlx_version.dir/cmake_clean.cmake
+.PHONY : mlx/CMakeFiles/mlx_version.dir/clean
+
+mlx/CMakeFiles/mlx_version.dir/depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/DependInfo.cmake "--color=$(COLOR)"
+.PHONY : mlx/CMakeFiles/mlx_version.dir/depend
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/cmake_clean.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/cmake_clean.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..029680d444a305120f09704d58684b8be1aae752
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/cmake_clean.cmake
@@ -0,0 +1,9 @@
+file(REMOVE_RECURSE
+  "CMakeFiles/mlx_version.dir/version.cpp.o"
+  "CMakeFiles/mlx_version.dir/version.cpp.o.d"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang CXX)
+  include(CMakeFiles/mlx_version.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/compiler_depend.internal b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/compiler_depend.internal
new file mode 100644
index 0000000000000000000000000000000000000000..beacc02a1cae6dcf3a51a34c2215f132b64ab2af
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/compiler_depend.internal
@@ -0,0 +1,7 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+mlx/CMakeFiles/mlx_version.dir/version.cpp.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.cpp
+ /usr/include/stdc-predef.h
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/compiler_depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/compiler_depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..15da0be37810e4ea24e4f644fe086e4652c261a4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/compiler_depend.make
@@ -0,0 +1,10 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+mlx/CMakeFiles/mlx_version.dir/version.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.cpp \
+  /usr/include/stdc-predef.h
+
+
+/usr/include/stdc-predef.h:
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.cpp:
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/compiler_depend.ts b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/compiler_depend.ts
new file mode 100644
index 0000000000000000000000000000000000000000..32b2132567a8b5d5aaa1e1b5f5429187fd51b745
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/compiler_depend.ts
@@ -0,0 +1,2 @@
+# CMAKE generated file: DO NOT EDIT!
+# Timestamp file for compiler generated dependencies management for mlx_version.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..93666f1bf2fcba7b41c462573aac776b9dc1cf1e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/depend.make
@@ -0,0 +1,2 @@
+# Empty dependencies file for mlx_version.
+# This may be replaced when dependencies are built.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/flags.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/flags.make
new file mode 100644
index 0000000000000000000000000000000000000000..96defffbed8a553187f01154b769c58776c192e5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/flags.make
@@ -0,0 +1,10 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# compile CXX with /usr/bin/c++
+CXX_DEFINES = -DMLX_VERSION=\"0.29.2.dev20251007+0073096d\"
+
+CXX_INCLUDES = 
+
+CXX_FLAGS = -O3 -DNDEBUG -std=gnu++17 -fPIC
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/progress.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/progress.make
new file mode 100644
index 0000000000000000000000000000000000000000..225de343d65c51fd774bbe0e1adee2d439eb81dc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/progress.make
@@ -0,0 +1,2 @@
+CMAKE_PROGRESS_1 = 
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/version.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/version.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..70b5865d0a92a2efd76a47f3abf406468e95a570
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/version.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/version.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/version.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..60e09a59261139c9731fac3eff4cba4b9911af4a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/mlx_version.dir/version.cpp.o.d
@@ -0,0 +1,3 @@
+mlx/CMakeFiles/mlx_version.dir/version.cpp.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/version.cpp \
+ /usr/include/stdc-predef.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..0cfbf08886fca9a91cb753ec8734c84fcbe52c9f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+2
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..c92648fc945a4dda7c2f27b84c70fd3c4224fabf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/Makefile
@@ -0,0 +1,231 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\" \"headers\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx//CMakeFiles/progress.marks
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+# Convenience name for target.
+mlx/CMakeFiles/mlx_version.dir/rule:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/CMakeFiles/mlx_version.dir/rule
+.PHONY : mlx/CMakeFiles/mlx_version.dir/rule
+
+# Convenience name for target.
+mlx_version: mlx/CMakeFiles/mlx_version.dir/rule
+.PHONY : mlx_version
+
+# fast build rule for target.
+mlx_version/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f mlx/CMakeFiles/mlx_version.dir/build.make mlx/CMakeFiles/mlx_version.dir/build
+.PHONY : mlx_version/fast
+
+version.o: version.cpp.o
+.PHONY : version.o
+
+# target to build an object file
+version.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f mlx/CMakeFiles/mlx_version.dir/build.make mlx/CMakeFiles/mlx_version.dir/version.cpp.o
+.PHONY : version.cpp.o
+
+version.i: version.cpp.i
+.PHONY : version.i
+
+# target to preprocess a source file
+version.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f mlx/CMakeFiles/mlx_version.dir/build.make mlx/CMakeFiles/mlx_version.dir/version.cpp.i
+.PHONY : version.cpp.i
+
+version.s: version.cpp.s
+.PHONY : version.s
+
+# target to generate assembly for a file
+version.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f mlx/CMakeFiles/mlx_version.dir/build.make mlx/CMakeFiles/mlx_version.dir/version.cpp.s
+.PHONY : version.cpp.s
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+	@echo "... mlx_version"
+	@echo "... version.o"
+	@echo "... version.i"
+	@echo "... version.s"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb9de92640e91b3d38364ee7a569cd8b862951
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+0
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..0c1c92f07ff930b791645dbbec3c56def9f9c20f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/Makefile
@@ -0,0 +1,189 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\" \"headers\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common//CMakeFiles/progress.marks
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/common/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/common/clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/common/preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/common/preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..bf9f78826567f835ddabf2007aa5047976b84b08
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/cmake_install.cmake
@@ -0,0 +1,50 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/common
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb9de92640e91b3d38364ee7a569cd8b862951
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/DependInfo.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/DependInfo.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..29b95a515e51db792a1019bc6c3419b6d78ec34c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/DependInfo.cmake
@@ -0,0 +1,22 @@
+
+# Consider dependencies only in project.
+set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
+
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  )
+
+# The set of dependency files which are needed:
+set(CMAKE_DEPENDS_DEPENDENCY_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build.make
new file mode 100644
index 0000000000000000000000000000000000000000..0a11bf68d4d00fe53df2e10767dd8d103b680c7a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build.make
@@ -0,0 +1,105 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+# Utility rule file for cpu_compiled_preamble.
+
+# Include any custom commands dependencies for this target.
+include mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/compiler_depend.make
+
+# Include the progress variables for this target.
+include mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/progress.make
+
+mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble: mlx/backend/cpu/compiled_preamble.cpp
+
+mlx/backend/cpu/compiled_preamble.cpp: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/make_compiled_preamble.sh
+mlx/backend/cpu/compiled_preamble.cpp: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled_preamble.h
+mlx/backend/cpu/compiled_preamble.cpp: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/half_types.h
+mlx/backend/cpu/compiled_preamble.cpp: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/fp16.h
+mlx/backend/cpu/compiled_preamble.cpp: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/bf16.h
+mlx/backend/cpu/compiled_preamble.cpp: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/types/complex.h
+mlx/backend/cpu/compiled_preamble.cpp: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
+mlx/backend/cpu/compiled_preamble.cpp: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
+mlx/backend/cpu/compiled_preamble.cpp: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
+mlx/backend/cpu/compiled_preamble.cpp: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
+mlx/backend/cpu/compiled_preamble.cpp: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/unary_ops.h
+mlx/backend/cpu/compiled_preamble.cpp: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Generating compiled_preamble.cpp"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu && bash /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu/make_compiled_preamble.sh /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/compiled_preamble.cpp /usr/bin/c++ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx x86_64
+
+mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/codegen:
+.PHONY : mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/codegen
+
+cpu_compiled_preamble: mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble
+cpu_compiled_preamble: mlx/backend/cpu/compiled_preamble.cpp
+cpu_compiled_preamble: mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build.make
+.PHONY : cpu_compiled_preamble
+
+# Rule to build all files generated by this target.
+mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build: cpu_compiled_preamble
+.PHONY : mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build
+
+mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu && $(CMAKE_COMMAND) -P CMakeFiles/cpu_compiled_preamble.dir/cmake_clean.cmake
+.PHONY : mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/clean
+
+mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/DependInfo.cmake "--color=$(COLOR)"
+.PHONY : mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/depend
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/cmake_clean.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/cmake_clean.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d57e60dd1e2d023bd43daf0a93b4b5453b283d26
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/cmake_clean.cmake
@@ -0,0 +1,9 @@
+file(REMOVE_RECURSE
+  "CMakeFiles/cpu_compiled_preamble"
+  "compiled_preamble.cpp"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang )
+  include(CMakeFiles/cpu_compiled_preamble.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/compiler_depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/compiler_depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..1b6d097d0fe19176e02f21f9cf7757d34972453d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/compiler_depend.make
@@ -0,0 +1,2 @@
+# Empty custom commands generated dependencies file for cpu_compiled_preamble.
+# This may be replaced when dependencies are built.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/compiler_depend.ts b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/compiler_depend.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f7de0a6da3d5110fcb5995f0130909f40a14ede9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/compiler_depend.ts
@@ -0,0 +1,2 @@
+# CMAKE generated file: DO NOT EDIT!
+# Timestamp file for custom commands dependencies management for cpu_compiled_preamble.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/progress.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/progress.make
new file mode 100644
index 0000000000000000000000000000000000000000..225de343d65c51fd774bbe0e1adee2d439eb81dc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/progress.make
@@ -0,0 +1,2 @@
+CMAKE_PROGRESS_1 = 
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+0
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..6a80aba245ef41bdbaf9e23d0b63bdfb7b583caa
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/Makefile
@@ -0,0 +1,204 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\" \"headers\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu//CMakeFiles/progress.marks
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/cpu/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/cpu/clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/cpu/preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/cpu/preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+# Convenience name for target.
+mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/rule:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/rule
+.PHONY : mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/rule
+
+# Convenience name for target.
+cpu_compiled_preamble: mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/rule
+.PHONY : cpu_compiled_preamble
+
+# fast build rule for target.
+cpu_compiled_preamble/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build.make mlx/backend/cpu/CMakeFiles/cpu_compiled_preamble.dir/build
+.PHONY : cpu_compiled_preamble/fast
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+	@echo "... cpu_compiled_preamble"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e475bf7dcfcc6c73c0dd4dcf2c1a83998815297c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/cmake_install.cmake
@@ -0,0 +1,50 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/cpu
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/compiled_preamble.cpp b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/compiled_preamble.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3d4998cee3370cbaf374fb9cecdedbaf656313a4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/compiled_preamble.cpp
@@ -0,0 +1,44876 @@
+const char* get_kernel_preamble() {
+return R"preamble(
+
+       
+       
+       
+       
+       
+namespace std
+{
+  typedef long unsigned int size_t;
+  typedef long int ptrdiff_t;
+  typedef decltype(nullptr) nullptr_t;
+}
+namespace std
+{
+  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+}
+namespace __gnu_cxx
+{
+  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace rel_ops
+  {
+    template <class _Tp>
+      inline bool
+      operator!=(const _Tp& __x, const _Tp& __y)
+      { return !(__x == __y); }
+    template <class _Tp>
+      inline bool
+      operator>(const _Tp& __x, const _Tp& __y)
+      { return __y < __x; }
+    template <class _Tp>
+      inline bool
+      operator<=(const _Tp& __x, const _Tp& __y)
+      { return !(__y < __x); }
+    template <class _Tp>
+      inline bool
+      operator>=(const _Tp& __x, const _Tp& __y)
+      { return !(__x < __y); }
+  }
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp>
+    inline constexpr _Tp*
+    __addressof(_Tp& __r) noexcept
+    { return __builtin_addressof(__r); }
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp, _Tp __v>
+    struct integral_constant
+    {
+      static constexpr _Tp value = __v;
+      typedef _Tp value_type;
+      typedef integral_constant<_Tp, __v> type;
+      constexpr operator value_type() const noexcept { return value; }
+      constexpr value_type operator()() const noexcept { return value; }
+    };
+  template<typename _Tp, _Tp __v>
+    constexpr _Tp integral_constant<_Tp, __v>::value;
+  typedef integral_constant<bool, true> true_type;
+  typedef integral_constant<bool, false> false_type;
+  template<bool __v>
+    using __bool_constant = integral_constant<bool, __v>;
+  template<bool __v>
+    using bool_constant = integral_constant<bool, __v>;
+  template<bool, typename, typename>
+    struct conditional;
+  template<typename...>
+    struct __or_;
+  template<>
+    struct __or_<>
+    : public false_type
+    { };
+  template<typename _B1>
+    struct __or_<_B1>
+    : public _B1
+    { };
+  template<typename _B1, typename _B2>
+    struct __or_<_B1, _B2>
+    : public conditional<_B1::value, _B1, _B2>::type
+    { };
+  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
+    struct __or_<_B1, _B2, _B3, _Bn...>
+    : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
+    { };
+  template<typename...>
+    struct __and_;
+  template<>
+    struct __and_<>
+    : public true_type
+    { };
+  template<typename _B1>
+    struct __and_<_B1>
+    : public _B1
+    { };
+  template<typename _B1, typename _B2>
+    struct __and_<_B1, _B2>
+    : public conditional<_B1::value, _B2, _B1>::type
+    { };
+  template<typename _B1, typename _B2, typename _B3, typename... _Bn>
+    struct __and_<_B1, _B2, _B3, _Bn...>
+    : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
+    { };
+  template<typename _Pp>
+    struct __not_
+    : public __bool_constant<!bool(_Pp::value)>
+    { };
+  template<typename... _Bn>
+    struct conjunction
+    : __and_<_Bn...>
+    { };
+  template<typename... _Bn>
+    struct disjunction
+    : __or_<_Bn...>
+    { };
+  template<typename _Pp>
+    struct negation
+    : __not_<_Pp>
+    { };
+  template<typename... _Bn>
+    inline constexpr bool conjunction_v = conjunction<_Bn...>::value;
+  template<typename... _Bn>
+    inline constexpr bool disjunction_v = disjunction<_Bn...>::value;
+  template<typename _Pp>
+    inline constexpr bool negation_v = negation<_Pp>::value;
+  template<typename _Tp>
+    struct __success_type
+    { typedef _Tp type; };
+  struct __failure_type
+  { };
+  template<typename>
+    struct remove_cv;
+  template<typename>
+    struct __is_void_helper
+    : public false_type { };
+  template<>
+    struct __is_void_helper<void>
+    : public true_type { };
+  template<typename _Tp>
+    struct is_void
+    : public __is_void_helper<typename remove_cv<_Tp>::type>::type
+    { };
+  template<typename>
+    struct __is_integral_helper
+    : public false_type { };
+  template<>
+    struct __is_integral_helper<bool>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<char>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<signed char>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<unsigned char>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<wchar_t>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<char16_t>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<char32_t>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<short>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<unsigned short>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<int>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<unsigned int>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<long>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<unsigned long>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<long long>
+    : public true_type { };
+  template<>
+    struct __is_integral_helper<unsigned long long>
+    : public true_type { };
+  template<typename _Tp>
+    struct is_integral
+    : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
+    { };
+  template<typename>
+    struct __is_floating_point_helper
+    : public false_type { };
+  template<>
+    struct __is_floating_point_helper<float>
+    : public true_type { };
+  template<>
+    struct __is_floating_point_helper<double>
+    : public true_type { };
+  template<>
+    struct __is_floating_point_helper<long double>
+    : public true_type { };
+  template<typename _Tp>
+    struct is_floating_point
+    : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
+    { };
+  template<typename>
+    struct is_array
+    : public false_type { };
+  template<typename _Tp, std::size_t _Size>
+    struct is_array<_Tp[_Size]>
+    : public true_type { };
+  template<typename _Tp>
+    struct is_array<_Tp[]>
+    : public true_type { };
+  template<typename>
+    struct __is_pointer_helper
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_pointer_helper<_Tp*>
+    : public true_type { };
+  template<typename _Tp>
+    struct is_pointer
+    : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
+    { };
+  template<typename>
+    struct is_lvalue_reference
+    : public false_type { };
+  template<typename _Tp>
+    struct is_lvalue_reference<_Tp&>
+    : public true_type { };
+  template<typename>
+    struct is_rvalue_reference
+    : public false_type { };
+  template<typename _Tp>
+    struct is_rvalue_reference<_Tp&&>
+    : public true_type { };
+  template<typename>
+    struct is_function;
+  template<typename>
+    struct __is_member_object_pointer_helper
+    : public false_type { };
+  template<typename _Tp, typename _Cp>
+    struct __is_member_object_pointer_helper<_Tp _Cp::*>
+    : public integral_constant<bool, !is_function<_Tp>::value> { };
+  template<typename _Tp>
+    struct is_member_object_pointer
+    : public __is_member_object_pointer_helper<
+    typename remove_cv<_Tp>::type>::type
+    { };
+  template<typename>
+    struct __is_member_function_pointer_helper
+    : public false_type { };
+  template<typename _Tp, typename _Cp>
+    struct __is_member_function_pointer_helper<_Tp _Cp::*>
+    : public integral_constant<bool, is_function<_Tp>::value> { };
+  template<typename _Tp>
+    struct is_member_function_pointer
+    : public __is_member_function_pointer_helper<
+    typename remove_cv<_Tp>::type>::type
+    { };
+  template<typename _Tp>
+    struct is_enum
+    : public integral_constant<bool, __is_enum(_Tp)>
+    { };
+  template<typename _Tp>
+    struct is_union
+    : public integral_constant<bool, __is_union(_Tp)>
+    { };
+  template<typename _Tp>
+    struct is_class
+    : public integral_constant<bool, __is_class(_Tp)>
+    { };
+  template<typename>
+    struct is_function
+    : public false_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes...) noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes...) & noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes...) && noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes......) noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes......) & noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes......) && noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes...) const noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes...) const & noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes...) const && noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes......) const noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes......) const & noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes......) const && noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes...) volatile noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes...) volatile & noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes...) volatile && noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes......) volatile noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes......) volatile & noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes......) volatile && noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes...) const volatile noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes...) const volatile & noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes...) const volatile && noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes......) const volatile noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes......) const volatile & noexcept (_NE)>
+    : public true_type { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct is_function<_Res(_ArgTypes......) const volatile && noexcept (_NE)>
+    : public true_type { };
+  template<typename>
+    struct __is_null_pointer_helper
+    : public false_type { };
+  template<>
+    struct __is_null_pointer_helper<std::nullptr_t>
+    : public true_type { };
+  template<typename _Tp>
+    struct is_null_pointer
+    : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
+    { };
+  template<typename _Tp>
+    struct __is_nullptr_t
+    : public is_null_pointer<_Tp>
+    { };
+  template<typename _Tp>
+    struct is_reference
+    : public __or_<is_lvalue_reference<_Tp>,
+                   is_rvalue_reference<_Tp>>::type
+    { };
+  template<typename _Tp>
+    struct is_arithmetic
+    : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
+    { };
+  template<typename _Tp>
+    struct is_fundamental
+    : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
+     is_null_pointer<_Tp>>::type
+    { };
+  template<typename _Tp>
+    struct is_object
+    : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
+                          is_void<_Tp>>>::type
+    { };
+  template<typename>
+    struct is_member_pointer;
+  template<typename _Tp>
+    struct is_scalar
+    : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
+                   is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
+    { };
+  template<typename _Tp>
+    struct is_compound
+    : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
+  template<typename _Tp>
+    struct __is_member_pointer_helper
+    : public false_type { };
+  template<typename _Tp, typename _Cp>
+    struct __is_member_pointer_helper<_Tp _Cp::*>
+    : public true_type { };
+  template<typename _Tp>
+    struct is_member_pointer
+    : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
+    { };
+  template<typename _Tp>
+    struct __is_referenceable
+    : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
+    { };
+  template<typename _Res, typename... _Args , bool _NE>
+    struct __is_referenceable<_Res(_Args...) noexcept (_NE)>
+    : public true_type
+    { };
+  template<typename _Res, typename... _Args , bool _NE>
+    struct __is_referenceable<_Res(_Args......) noexcept (_NE)>
+    : public true_type
+    { };
+  template<typename>
+    struct is_const
+    : public false_type { };
+  template<typename _Tp>
+    struct is_const<_Tp const>
+    : public true_type { };
+  template<typename>
+    struct is_volatile
+    : public false_type { };
+  template<typename _Tp>
+    struct is_volatile<_Tp volatile>
+    : public true_type { };
+  template<typename _Tp>
+    struct is_trivial
+    : public integral_constant<bool, __is_trivial(_Tp)>
+    { };
+  template<typename _Tp>
+    struct is_trivially_copyable
+    : public integral_constant<bool, __is_trivially_copyable(_Tp)>
+    { };
+  template<typename _Tp>
+    struct is_standard_layout
+    : public integral_constant<bool, __is_standard_layout(_Tp)>
+    { };
+  template<typename _Tp>
+    struct is_pod
+    : public integral_constant<bool, __is_pod(_Tp)>
+    { };
+  template<typename _Tp>
+    struct is_literal_type
+    : public integral_constant<bool, __is_literal_type(_Tp)>
+    { };
+  template<typename _Tp>
+    struct is_empty
+    : public integral_constant<bool, __is_empty(_Tp)>
+    { };
+  template<typename _Tp>
+    struct is_polymorphic
+    : public integral_constant<bool, __is_polymorphic(_Tp)>
+    { };
+  template<typename _Tp>
+    struct is_final
+    : public integral_constant<bool, __is_final(_Tp)>
+    { };
+  template<typename _Tp>
+    struct is_abstract
+    : public integral_constant<bool, __is_abstract(_Tp)>
+    { };
+  template<typename _Tp,
+    bool = is_arithmetic<_Tp>::value>
+    struct __is_signed_helper
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_signed_helper<_Tp, true>
+    : public integral_constant<bool, _Tp(-1) < _Tp(0)>
+    { };
+  template<typename _Tp>
+    struct is_signed
+    : public __is_signed_helper<_Tp>::type
+    { };
+  template<typename _Tp>
+    struct is_unsigned
+    : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>
+    { };
+  template<typename _Tp, typename _Up = _Tp&&>
+    _Up
+    __declval(int);
+  template<typename _Tp>
+    _Tp
+    __declval(long);
+  template<typename _Tp>
+    auto declval() noexcept -> decltype(__declval<_Tp>(0));
+  template<typename, unsigned = 0>
+    struct extent;
+  template<typename>
+    struct remove_all_extents;
+  template<typename _Tp>
+    struct __is_array_known_bounds
+    : public integral_constant<bool, (extent<_Tp>::value > 0)>
+    { };
+  template<typename _Tp>
+    struct __is_array_unknown_bounds
+    : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
+    { };
+  struct __do_is_destructible_impl
+  {
+    template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
+      static true_type __test(int);
+    template<typename>
+      static false_type __test(...);
+  };
+  template<typename _Tp>
+    struct __is_destructible_impl
+    : public __do_is_destructible_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+  template<typename _Tp,
+           bool = __or_<is_void<_Tp>,
+                        __is_array_unknown_bounds<_Tp>,
+                        is_function<_Tp>>::value,
+           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
+    struct __is_destructible_safe;
+  template<typename _Tp>
+    struct __is_destructible_safe<_Tp, false, false>
+    : public __is_destructible_impl<typename
+               remove_all_extents<_Tp>::type>::type
+    { };
+  template<typename _Tp>
+    struct __is_destructible_safe<_Tp, true, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_destructible_safe<_Tp, false, true>
+    : public true_type { };
+  template<typename _Tp>
+    struct is_destructible
+    : public __is_destructible_safe<_Tp>::type
+    { };
+  struct __do_is_nt_destructible_impl
+  {
+    template<typename _Tp>
+      static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())>
+        __test(int);
+    template<typename>
+      static false_type __test(...);
+  };
+  template<typename _Tp>
+    struct __is_nt_destructible_impl
+    : public __do_is_nt_destructible_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+  template<typename _Tp,
+           bool = __or_<is_void<_Tp>,
+                        __is_array_unknown_bounds<_Tp>,
+                        is_function<_Tp>>::value,
+           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
+    struct __is_nt_destructible_safe;
+  template<typename _Tp>
+    struct __is_nt_destructible_safe<_Tp, false, false>
+    : public __is_nt_destructible_impl<typename
+               remove_all_extents<_Tp>::type>::type
+    { };
+  template<typename _Tp>
+    struct __is_nt_destructible_safe<_Tp, true, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_nt_destructible_safe<_Tp, false, true>
+    : public true_type { };
+  template<typename _Tp>
+    struct is_nothrow_destructible
+    : public __is_nt_destructible_safe<_Tp>::type
+    { };
+  template<typename _Tp, typename... _Args>
+    struct is_constructible
+      : public __bool_constant<__is_constructible(_Tp, _Args...)>
+    { };
+  template<typename _Tp>
+    struct is_default_constructible
+    : public is_constructible<_Tp>::type
+    { };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_copy_constructible_impl;
+  template<typename _Tp>
+    struct __is_copy_constructible_impl<_Tp, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_copy_constructible_impl<_Tp, true>
+    : public is_constructible<_Tp, const _Tp&>
+    { };
+  template<typename _Tp>
+    struct is_copy_constructible
+    : public __is_copy_constructible_impl<_Tp>
+    { };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_move_constructible_impl;
+  template<typename _Tp>
+    struct __is_move_constructible_impl<_Tp, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_move_constructible_impl<_Tp, true>
+    : public is_constructible<_Tp, _Tp&&>
+    { };
+  template<typename _Tp>
+    struct is_move_constructible
+    : public __is_move_constructible_impl<_Tp>
+    { };
+  template<bool, typename _Tp, typename... _Args>
+    struct __is_nt_constructible_impl
+    : public false_type
+    { };
+  template<typename _Tp, typename... _Args>
+    struct __is_nt_constructible_impl<true, _Tp, _Args...>
+    : public __bool_constant<noexcept(_Tp(std::declval<_Args>()...))>
+    { };
+  template<typename _Tp, typename _Arg>
+    struct __is_nt_constructible_impl<true, _Tp, _Arg>
+    : public __bool_constant<noexcept(static_cast<_Tp>(std::declval<_Arg>()))>
+    { };
+  template<typename _Tp>
+    struct __is_nt_constructible_impl<true, _Tp>
+    : public __bool_constant<noexcept(_Tp())>
+    { };
+  template<typename _Tp, size_t _Num>
+    struct __is_nt_constructible_impl<true, _Tp[_Num]>
+    : public __bool_constant<noexcept(typename remove_all_extents<_Tp>::type())>
+    { };
+  template<typename _Tp, typename... _Args>
+    using __is_nothrow_constructible_impl
+      = __is_nt_constructible_impl<__is_constructible(_Tp, _Args...),
+       _Tp, _Args...>;
+  template<typename _Tp, typename... _Args>
+    struct is_nothrow_constructible
+    : public __is_nothrow_constructible_impl<_Tp, _Args...>::type
+    { };
+  template<typename _Tp>
+    struct is_nothrow_default_constructible
+    : public __is_nothrow_constructible_impl<_Tp>::type
+    { };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_nothrow_copy_constructible_impl;
+  template<typename _Tp>
+    struct __is_nothrow_copy_constructible_impl<_Tp, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_nothrow_copy_constructible_impl<_Tp, true>
+    : public is_nothrow_constructible<_Tp, const _Tp&>
+    { };
+  template<typename _Tp>
+    struct is_nothrow_copy_constructible
+    : public __is_nothrow_copy_constructible_impl<_Tp>
+    { };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_nothrow_move_constructible_impl;
+  template<typename _Tp>
+    struct __is_nothrow_move_constructible_impl<_Tp, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_nothrow_move_constructible_impl<_Tp, true>
+    : public is_nothrow_constructible<_Tp, _Tp&&>
+    { };
+  template<typename _Tp>
+    struct is_nothrow_move_constructible
+    : public __is_nothrow_move_constructible_impl<_Tp>
+    { };
+  template<typename _Tp, typename _Up>
+    struct is_assignable
+      : public __bool_constant<__is_assignable(_Tp, _Up)>
+    { };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_copy_assignable_impl;
+  template<typename _Tp>
+    struct __is_copy_assignable_impl<_Tp, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_copy_assignable_impl<_Tp, true>
+    : public is_assignable<_Tp&, const _Tp&>
+    { };
+  template<typename _Tp>
+    struct is_copy_assignable
+    : public __is_copy_assignable_impl<_Tp>
+    { };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_move_assignable_impl;
+  template<typename _Tp>
+    struct __is_move_assignable_impl<_Tp, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_move_assignable_impl<_Tp, true>
+    : public is_assignable<_Tp&, _Tp&&>
+    { };
+  template<typename _Tp>
+    struct is_move_assignable
+    : public __is_move_assignable_impl<_Tp>
+    { };
+  template<typename _Tp, typename _Up>
+    struct __is_nt_assignable_impl
+    : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
+    { };
+  template<typename _Tp, typename _Up>
+    struct is_nothrow_assignable
+    : public __and_<is_assignable<_Tp, _Up>,
+      __is_nt_assignable_impl<_Tp, _Up>>
+    { };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_nt_copy_assignable_impl;
+  template<typename _Tp>
+    struct __is_nt_copy_assignable_impl<_Tp, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_nt_copy_assignable_impl<_Tp, true>
+    : public is_nothrow_assignable<_Tp&, const _Tp&>
+    { };
+  template<typename _Tp>
+    struct is_nothrow_copy_assignable
+    : public __is_nt_copy_assignable_impl<_Tp>
+    { };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_nt_move_assignable_impl;
+  template<typename _Tp>
+    struct __is_nt_move_assignable_impl<_Tp, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_nt_move_assignable_impl<_Tp, true>
+    : public is_nothrow_assignable<_Tp&, _Tp&&>
+    { };
+  template<typename _Tp>
+    struct is_nothrow_move_assignable
+    : public __is_nt_move_assignable_impl<_Tp>
+    { };
+  template<typename _Tp, typename... _Args>
+    struct is_trivially_constructible
+    : public __and_<is_constructible<_Tp, _Args...>, __bool_constant<
+        __is_trivially_constructible(_Tp, _Args...)>>::type
+    { };
+  template<typename _Tp>
+    struct is_trivially_default_constructible
+    : public is_trivially_constructible<_Tp>::type
+    { };
+  struct __do_is_implicitly_default_constructible_impl
+  {
+    template <typename _Tp>
+    static void __helper(const _Tp&);
+    template <typename _Tp>
+    static true_type __test(const _Tp&,
+                            decltype(__helper<const _Tp&>({}))* = 0);
+    static false_type __test(...);
+  };
+  template<typename _Tp>
+    struct __is_implicitly_default_constructible_impl
+    : public __do_is_implicitly_default_constructible_impl
+    {
+      typedef decltype(__test(declval<_Tp>())) type;
+    };
+  template<typename _Tp>
+    struct __is_implicitly_default_constructible_safe
+    : public __is_implicitly_default_constructible_impl<_Tp>::type
+    { };
+  template <typename _Tp>
+    struct __is_implicitly_default_constructible
+    : public __and_<is_default_constructible<_Tp>,
+      __is_implicitly_default_constructible_safe<_Tp>>
+    { };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_trivially_copy_constructible_impl;
+  template<typename _Tp>
+    struct __is_trivially_copy_constructible_impl<_Tp, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_trivially_copy_constructible_impl<_Tp, true>
+    : public __and_<is_copy_constructible<_Tp>,
+      integral_constant<bool,
+   __is_trivially_constructible(_Tp, const _Tp&)>>
+    { };
+  template<typename _Tp>
+    struct is_trivially_copy_constructible
+    : public __is_trivially_copy_constructible_impl<_Tp>
+    { };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_trivially_move_constructible_impl;
+  template<typename _Tp>
+    struct __is_trivially_move_constructible_impl<_Tp, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_trivially_move_constructible_impl<_Tp, true>
+    : public __and_<is_move_constructible<_Tp>,
+      integral_constant<bool,
+   __is_trivially_constructible(_Tp, _Tp&&)>>
+    { };
+  template<typename _Tp>
+    struct is_trivially_move_constructible
+    : public __is_trivially_move_constructible_impl<_Tp>
+    { };
+  template<typename _Tp, typename _Up>
+    struct is_trivially_assignable
+    : public __bool_constant<__is_trivially_assignable(_Tp, _Up)>
+    { };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_trivially_copy_assignable_impl;
+  template<typename _Tp>
+    struct __is_trivially_copy_assignable_impl<_Tp, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_trivially_copy_assignable_impl<_Tp, true>
+    : public __and_<is_copy_assignable<_Tp>,
+      integral_constant<bool,
+   __is_trivially_assignable(_Tp&, const _Tp&)>>
+    { };
+  template<typename _Tp>
+    struct is_trivially_copy_assignable
+    : public __is_trivially_copy_assignable_impl<_Tp>
+    { };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_trivially_move_assignable_impl;
+  template<typename _Tp>
+    struct __is_trivially_move_assignable_impl<_Tp, false>
+    : public false_type { };
+  template<typename _Tp>
+    struct __is_trivially_move_assignable_impl<_Tp, true>
+    : public __and_<is_move_assignable<_Tp>,
+      integral_constant<bool,
+   __is_trivially_assignable(_Tp&, _Tp&&)>>
+    { };
+  template<typename _Tp>
+    struct is_trivially_move_assignable
+    : public __is_trivially_move_assignable_impl<_Tp>
+    { };
+  template<typename _Tp>
+    struct is_trivially_destructible
+    : public __and_<is_destructible<_Tp>, integral_constant<bool,
+         __has_trivial_destructor(_Tp)>>
+    { };
+  template<typename _Tp>
+    struct has_virtual_destructor
+    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
+    { };
+  template<typename _Tp>
+    struct alignment_of
+    : public integral_constant<std::size_t, alignof(_Tp)> { };
+  template<typename>
+    struct rank
+    : public integral_constant<std::size_t, 0> { };
+  template<typename _Tp, std::size_t _Size>
+    struct rank<_Tp[_Size]>
+    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+  template<typename _Tp>
+    struct rank<_Tp[]>
+    : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+  template<typename, unsigned _Uint>
+    struct extent
+    : public integral_constant<std::size_t, 0> { };
+  template<typename _Tp, unsigned _Uint, std::size_t _Size>
+    struct extent<_Tp[_Size], _Uint>
+    : public integral_constant<std::size_t,
+          _Uint == 0 ? _Size : extent<_Tp,
+          _Uint - 1>::value>
+    { };
+  template<typename _Tp, unsigned _Uint>
+    struct extent<_Tp[], _Uint>
+    : public integral_constant<std::size_t,
+          _Uint == 0 ? 0 : extent<_Tp,
+             _Uint - 1>::value>
+    { };
+  template<typename, typename>
+    struct is_same
+    : public false_type { };
+  template<typename _Tp>
+    struct is_same<_Tp, _Tp>
+    : public true_type { };
+  template<typename _Base, typename _Derived>
+    struct is_base_of
+    : public integral_constant<bool, __is_base_of(_Base, _Derived)>
+    { };
+  template<typename _From, typename _To,
+           bool = __or_<is_void<_From>, is_function<_To>,
+                        is_array<_To>>::value>
+    struct __is_convertible_helper
+    { typedef typename is_void<_To>::type type; };
+  template<typename _From, typename _To>
+    class __is_convertible_helper<_From, _To, false>
+    {
+       template<typename _To1>
+ static void __test_aux(_To1);
+      template<typename _From1, typename _To1,
+        typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
+ static true_type
+ __test(int);
+      template<typename, typename>
+ static false_type
+ __test(...);
+    public:
+      typedef decltype(__test<_From, _To>(0)) type;
+    };
+  template<typename _From, typename _To>
+    struct is_convertible
+    : public __is_convertible_helper<_From, _To>::type
+    { };
+  template<typename _Tp>
+    struct remove_const
+    { typedef _Tp type; };
+  template<typename _Tp>
+    struct remove_const<_Tp const>
+    { typedef _Tp type; };
+  template<typename _Tp>
+    struct remove_volatile
+    { typedef _Tp type; };
+  template<typename _Tp>
+    struct remove_volatile<_Tp volatile>
+    { typedef _Tp type; };
+  template<typename _Tp>
+    struct remove_cv
+    {
+      typedef typename
+      remove_const<typename remove_volatile<_Tp>::type>::type type;
+    };
+  template<typename _Tp>
+    struct add_const
+    { typedef _Tp const type; };
+  template<typename _Tp>
+    struct add_volatile
+    { typedef _Tp volatile type; };
+  template<typename _Tp>
+    struct add_cv
+    {
+      typedef typename
+      add_const<typename add_volatile<_Tp>::type>::type type;
+    };
+  template<typename _Tp>
+    using remove_const_t = typename remove_const<_Tp>::type;
+  template<typename _Tp>
+    using remove_volatile_t = typename remove_volatile<_Tp>::type;
+  template<typename _Tp>
+    using remove_cv_t = typename remove_cv<_Tp>::type;
+  template<typename _Tp>
+    using add_const_t = typename add_const<_Tp>::type;
+  template<typename _Tp>
+    using add_volatile_t = typename add_volatile<_Tp>::type;
+  template<typename _Tp>
+    using add_cv_t = typename add_cv<_Tp>::type;
+  template<typename _Tp>
+    struct remove_reference
+    { typedef _Tp type; };
+  template<typename _Tp>
+    struct remove_reference<_Tp&>
+    { typedef _Tp type; };
+  template<typename _Tp>
+    struct remove_reference<_Tp&&>
+    { typedef _Tp type; };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __add_lvalue_reference_helper
+    { typedef _Tp type; };
+  template<typename _Tp>
+    struct __add_lvalue_reference_helper<_Tp, true>
+    { typedef _Tp& type; };
+  template<typename _Tp>
+    struct add_lvalue_reference
+    : public __add_lvalue_reference_helper<_Tp>
+    { };
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __add_rvalue_reference_helper
+    { typedef _Tp type; };
+  template<typename _Tp>
+    struct __add_rvalue_reference_helper<_Tp, true>
+    { typedef _Tp&& type; };
+  template<typename _Tp>
+    struct add_rvalue_reference
+    : public __add_rvalue_reference_helper<_Tp>
+    { };
+  template<typename _Tp>
+    using remove_reference_t = typename remove_reference<_Tp>::type;
+  template<typename _Tp>
+    using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
+  template<typename _Tp>
+    using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
+  template<typename _Unqualified, bool _IsConst, bool _IsVol>
+    struct __cv_selector;
+  template<typename _Unqualified>
+    struct __cv_selector<_Unqualified, false, false>
+    { typedef _Unqualified __type; };
+  template<typename _Unqualified>
+    struct __cv_selector<_Unqualified, false, true>
+    { typedef volatile _Unqualified __type; };
+  template<typename _Unqualified>
+    struct __cv_selector<_Unqualified, true, false>
+    { typedef const _Unqualified __type; };
+  template<typename _Unqualified>
+    struct __cv_selector<_Unqualified, true, true>
+    { typedef const volatile _Unqualified __type; };
+  template<typename _Qualified, typename _Unqualified,
+    bool _IsConst = is_const<_Qualified>::value,
+    bool _IsVol = is_volatile<_Qualified>::value>
+    class __match_cv_qualifiers
+    {
+      typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
+    public:
+      typedef typename __match::__type __type;
+    };
+  template<typename _Tp>
+    struct __make_unsigned
+    { typedef _Tp __type; };
+  template<>
+    struct __make_unsigned<char>
+    { typedef unsigned char __type; };
+  template<>
+    struct __make_unsigned<signed char>
+    { typedef unsigned char __type; };
+  template<>
+    struct __make_unsigned<short>
+    { typedef unsigned short __type; };
+  template<>
+    struct __make_unsigned<int>
+    { typedef unsigned int __type; };
+  template<>
+    struct __make_unsigned<long>
+    { typedef unsigned long __type; };
+  template<>
+    struct __make_unsigned<long long>
+    { typedef unsigned long long __type; };
+  template<typename _Tp,
+    bool _IsInt = is_integral<_Tp>::value,
+    bool _IsEnum = is_enum<_Tp>::value>
+    class __make_unsigned_selector;
+  template<typename _Tp>
+    class __make_unsigned_selector<_Tp, true, false>
+    {
+      typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
+      typedef typename __unsignedt::__type __unsigned_type;
+      typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
+    public:
+      typedef typename __cv_unsigned::__type __type;
+    };
+  template<typename _Tp>
+    class __make_unsigned_selector<_Tp, false, true>
+    {
+      typedef unsigned char __smallest;
+      static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
+      static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
+      static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
+      static const bool __b3 = sizeof(_Tp) <= sizeof(unsigned long);
+      typedef conditional<__b3, unsigned long, unsigned long long> __cond3;
+      typedef typename __cond3::type __cond3_type;
+      typedef conditional<__b2, unsigned int, __cond3_type> __cond2;
+      typedef typename __cond2::type __cond2_type;
+      typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
+      typedef typename __cond1::type __cond1_type;
+      typedef typename conditional<__b0, __smallest, __cond1_type>::type
+ __unsigned_type;
+      typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
+    public:
+      typedef typename __cv_unsigned::__type __type;
+    };
+  template<typename _Tp>
+    struct make_unsigned
+    { typedef typename __make_unsigned_selector<_Tp>::__type type; };
+  template<>
+    struct make_unsigned<bool>;
+  template<typename _Tp>
+    struct __make_signed
+    { typedef _Tp __type; };
+  template<>
+    struct __make_signed<char>
+    { typedef signed char __type; };
+  template<>
+    struct __make_signed<unsigned char>
+    { typedef signed char __type; };
+  template<>
+    struct __make_signed<unsigned short>
+    { typedef signed short __type; };
+  template<>
+    struct __make_signed<unsigned int>
+    { typedef signed int __type; };
+  template<>
+    struct __make_signed<unsigned long>
+    { typedef signed long __type; };
+  template<>
+    struct __make_signed<unsigned long long>
+    { typedef signed long long __type; };
+  template<typename _Tp,
+    bool _IsInt = is_integral<_Tp>::value,
+    bool _IsEnum = is_enum<_Tp>::value>
+    class __make_signed_selector;
+  template<typename _Tp>
+    class __make_signed_selector<_Tp, true, false>
+    {
+      typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
+      typedef typename __signedt::__type __signed_type;
+      typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
+    public:
+      typedef typename __cv_signed::__type __type;
+    };
+  template<typename _Tp>
+    class __make_signed_selector<_Tp, false, true>
+    {
+      typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
+    public:
+      typedef typename __make_signed_selector<__unsigned_type>::__type __type;
+    };
+  template<typename _Tp>
+    struct make_signed
+    { typedef typename __make_signed_selector<_Tp>::__type type; };
+  template<>
+    struct make_signed<bool>;
+  template<typename _Tp>
+    using make_signed_t = typename make_signed<_Tp>::type;
+  template<typename _Tp>
+    using make_unsigned_t = typename make_unsigned<_Tp>::type;
+  template<typename _Tp>
+    struct remove_extent
+    { typedef _Tp type; };
+  template<typename _Tp, std::size_t _Size>
+    struct remove_extent<_Tp[_Size]>
+    { typedef _Tp type; };
+  template<typename _Tp>
+    struct remove_extent<_Tp[]>
+    { typedef _Tp type; };
+  template<typename _Tp>
+    struct remove_all_extents
+    { typedef _Tp type; };
+  template<typename _Tp, std::size_t _Size>
+    struct remove_all_extents<_Tp[_Size]>
+    { typedef typename remove_all_extents<_Tp>::type type; };
+  template<typename _Tp>
+    struct remove_all_extents<_Tp[]>
+    { typedef typename remove_all_extents<_Tp>::type type; };
+  template<typename _Tp>
+    using remove_extent_t = typename remove_extent<_Tp>::type;
+  template<typename _Tp>
+    using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
+  template<typename _Tp, typename>
+    struct __remove_pointer_helper
+    { typedef _Tp type; };
+  template<typename _Tp, typename _Up>
+    struct __remove_pointer_helper<_Tp, _Up*>
+    { typedef _Up type; };
+  template<typename _Tp>
+    struct remove_pointer
+    : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
+    { };
+  template<typename _Tp, bool = __or_<__is_referenceable<_Tp>,
+          is_void<_Tp>>::value>
+    struct __add_pointer_helper
+    { typedef _Tp type; };
+  template<typename _Tp>
+    struct __add_pointer_helper<_Tp, true>
+    { typedef typename remove_reference<_Tp>::type* type; };
+  template<typename _Tp>
+    struct add_pointer
+    : public __add_pointer_helper<_Tp>
+    { };
+  template<typename _Tp>
+    using remove_pointer_t = typename remove_pointer<_Tp>::type;
+  template<typename _Tp>
+    using add_pointer_t = typename add_pointer<_Tp>::type;
+  template<std::size_t _Len>
+    struct __aligned_storage_msa
+    {
+      union __type
+      {
+ unsigned char __data[_Len];
+ struct __attribute__((__aligned__)) { } __align;
+      };
+    };
+  template<std::size_t _Len, std::size_t _Align =
+    __alignof__(typename __aligned_storage_msa<_Len>::__type)>
+    struct aligned_storage
+    {
+      union type
+      {
+ unsigned char __data[_Len];
+ struct __attribute__((__aligned__((_Align)))) { } __align;
+      };
+    };
+  template <typename... _Types>
+    struct __strictest_alignment
+    {
+      static const size_t _S_alignment = 0;
+      static const size_t _S_size = 0;
+    };
+  template <typename _Tp, typename... _Types>
+    struct __strictest_alignment<_Tp, _Types...>
+    {
+      static const size_t _S_alignment =
+        alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
+ ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
+      static const size_t _S_size =
+        sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
+ ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
+    };
+  template <size_t _Len, typename... _Types>
+    struct aligned_union
+    {
+    private:
+      static_assert(sizeof...(_Types) != 0, "At least one type is required");
+      using __strictest = __strictest_alignment<_Types...>;
+      static const size_t _S_len = _Len > __strictest::_S_size
+ ? _Len : __strictest::_S_size;
+    public:
+      static const size_t alignment_value = __strictest::_S_alignment;
+      typedef typename aligned_storage<_S_len, alignment_value>::type type;
+    };
+  template <size_t _Len, typename... _Types>
+    const size_t aligned_union<_Len, _Types...>::alignment_value;
+  template<typename _Up,
+    bool _IsArray = is_array<_Up>::value,
+    bool _IsFunction = is_function<_Up>::value>
+    struct __decay_selector;
+  template<typename _Up>
+    struct __decay_selector<_Up, false, false>
+    { typedef typename remove_cv<_Up>::type __type; };
+  template<typename _Up>
+    struct __decay_selector<_Up, true, false>
+    { typedef typename remove_extent<_Up>::type* __type; };
+  template<typename _Up>
+    struct __decay_selector<_Up, false, true>
+    { typedef typename add_pointer<_Up>::type __type; };
+  template<typename _Tp>
+    class decay
+    {
+      typedef typename remove_reference<_Tp>::type __remove_type;
+    public:
+      typedef typename __decay_selector<__remove_type>::__type type;
+    };
+  template<typename _Tp>
+    class reference_wrapper;
+  template<typename _Tp>
+    struct __strip_reference_wrapper
+    {
+      typedef _Tp __type;
+    };
+  template<typename _Tp>
+    struct __strip_reference_wrapper<reference_wrapper<_Tp> >
+    {
+      typedef _Tp& __type;
+    };
+  template<typename _Tp>
+    struct __decay_and_strip
+    {
+      typedef typename __strip_reference_wrapper<
+ typename decay<_Tp>::type>::__type __type;
+    };
+  template<bool, typename _Tp = void>
+    struct enable_if
+    { };
+  template<typename _Tp>
+    struct enable_if<true, _Tp>
+    { typedef _Tp type; };
+  template<typename... _Cond>
+    using _Require = typename enable_if<__and_<_Cond...>::value>::type;
+  template<bool _Cond, typename _Iftrue, typename _Iffalse>
+    struct conditional
+    { typedef _Iftrue type; };
+  template<typename _Iftrue, typename _Iffalse>
+    struct conditional<false, _Iftrue, _Iffalse>
+    { typedef _Iffalse type; };
+  template<typename... _Tp>
+    struct common_type;
+  struct __do_common_type_impl
+  {
+    template<typename _Tp, typename _Up>
+      static __success_type<typename decay<decltype
+       (true ? std::declval<_Tp>()
+        : std::declval<_Up>())>::type> _S_test(int);
+    template<typename, typename>
+      static __failure_type _S_test(...);
+  };
+  template<typename _Tp, typename _Up>
+    struct __common_type_impl
+    : private __do_common_type_impl
+    {
+      typedef decltype(_S_test<_Tp, _Up>(0)) type;
+    };
+  struct __do_member_type_wrapper
+  {
+    template<typename _Tp>
+      static __success_type<typename _Tp::type> _S_test(int);
+    template<typename>
+      static __failure_type _S_test(...);
+  };
+  template<typename _Tp>
+    struct __member_type_wrapper
+    : private __do_member_type_wrapper
+    {
+      typedef decltype(_S_test<_Tp>(0)) type;
+    };
+  template<typename _CTp, typename... _Args>
+    struct __expanded_common_type_wrapper
+    {
+      typedef common_type<typename _CTp::type, _Args...> type;
+    };
+  template<typename... _Args>
+    struct __expanded_common_type_wrapper<__failure_type, _Args...>
+    { typedef __failure_type type; };
+  template<>
+    struct common_type<>
+    { };
+  template<typename _Tp>
+    struct common_type<_Tp>
+    : common_type<_Tp, _Tp>
+    { };
+  template<typename _Tp, typename _Up>
+    struct common_type<_Tp, _Up>
+    : public __common_type_impl<_Tp, _Up>::type
+    { };
+  template<typename _Tp, typename _Up, typename... _Vp>
+    struct common_type<_Tp, _Up, _Vp...>
+    : public __expanded_common_type_wrapper<typename __member_type_wrapper<
+               common_type<_Tp, _Up>>::type, _Vp...>::type
+    { };
+  template<typename _Tp>
+    struct underlying_type
+    {
+      typedef __underlying_type(_Tp) type;
+    };
+  template<typename _Tp>
+    struct __declval_protector
+    {
+      static const bool __stop = false;
+    };
+  template<typename _Tp>
+    auto declval() noexcept -> decltype(__declval<_Tp>(0))
+    {
+      static_assert(__declval_protector<_Tp>::__stop,
+      "declval() must not be used!");
+      return __declval<_Tp>(0);
+    }
+  template<>
+    struct __make_unsigned<wchar_t>
+    {
+      using __type
+ = typename __make_unsigned_selector<wchar_t, false, true>::__type;
+    };
+  template<>
+    struct __make_signed<wchar_t>
+    {
+      using __type
+ = typename __make_signed_selector<wchar_t, false, true>::__type;
+    };
+  template<>
+    struct __make_unsigned<char16_t>
+    {
+      using __type
+ = typename __make_unsigned_selector<char16_t, false, true>::__type;
+    };
+  template<>
+    struct __make_signed<char16_t>
+    {
+      using __type
+ = typename __make_signed_selector<char16_t, false, true>::__type;
+    };
+  template<>
+    struct __make_unsigned<char32_t>
+    {
+      using __type
+ = typename __make_unsigned_selector<char32_t, false, true>::__type;
+    };
+  template<>
+    struct __make_signed<char32_t>
+    {
+      using __type
+ = typename __make_signed_selector<char32_t, false, true>::__type;
+    };
+  template<typename _Signature>
+    class result_of;
+  struct __invoke_memfun_ref { };
+  struct __invoke_memfun_deref { };
+  struct __invoke_memobj_ref { };
+  struct __invoke_memobj_deref { };
+  struct __invoke_other { };
+  template<typename _Tp, typename _Tag>
+    struct __result_of_success : __success_type<_Tp>
+    { using __invoke_type = _Tag; };
+  struct __result_of_memfun_ref_impl
+  {
+    template<typename _Fp, typename _Tp1, typename... _Args>
+      static __result_of_success<decltype(
+      (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
+      ), __invoke_memfun_ref> _S_test(int);
+    template<typename...>
+      static __failure_type _S_test(...);
+  };
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_memfun_ref
+    : private __result_of_memfun_ref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
+    };
+  struct __result_of_memfun_deref_impl
+  {
+    template<typename _Fp, typename _Tp1, typename... _Args>
+      static __result_of_success<decltype(
+      ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
+      ), __invoke_memfun_deref> _S_test(int);
+    template<typename...>
+      static __failure_type _S_test(...);
+  };
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_memfun_deref
+    : private __result_of_memfun_deref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
+    };
+  struct __result_of_memobj_ref_impl
+  {
+    template<typename _Fp, typename _Tp1>
+      static __result_of_success<decltype(
+      std::declval<_Tp1>().*std::declval<_Fp>()
+      ), __invoke_memobj_ref> _S_test(int);
+    template<typename, typename>
+      static __failure_type _S_test(...);
+  };
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_memobj_ref
+    : private __result_of_memobj_ref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
+    };
+  struct __result_of_memobj_deref_impl
+  {
+    template<typename _Fp, typename _Tp1>
+      static __result_of_success<decltype(
+      (*std::declval<_Tp1>()).*std::declval<_Fp>()
+      ), __invoke_memobj_deref> _S_test(int);
+    template<typename, typename>
+      static __failure_type _S_test(...);
+  };
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_memobj_deref
+    : private __result_of_memobj_deref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
+    };
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_memobj;
+  template<typename _Res, typename _Class, typename _Arg>
+    struct __result_of_memobj<_Res _Class::*, _Arg>
+    {
+      typedef typename remove_cv<typename remove_reference<
+        _Arg>::type>::type _Argval;
+      typedef _Res _Class::* _MemPtr;
+      typedef typename conditional<__or_<is_same<_Argval, _Class>,
+        is_base_of<_Class, _Argval>>::value,
+        __result_of_memobj_ref<_MemPtr, _Arg>,
+        __result_of_memobj_deref<_MemPtr, _Arg>
+      >::type::type type;
+    };
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_memfun;
+  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
+    struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
+    {
+      typedef typename remove_cv<typename remove_reference<
+        _Arg>::type>::type _Argval;
+      typedef _Res _Class::* _MemPtr;
+      typedef typename conditional<__or_<is_same<_Argval, _Class>,
+        is_base_of<_Class, _Argval>>::value,
+        __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
+        __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
+      >::type::type type;
+    };
+  template<typename _Tp, typename _Up = typename decay<_Tp>::type>
+    struct __inv_unwrap
+    {
+      using type = _Tp;
+    };
+  template<typename _Tp, typename _Up>
+    struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
+    {
+      using type = _Up&;
+    };
+  template<bool, bool, typename _Functor, typename... _ArgTypes>
+    struct __result_of_impl
+    {
+      typedef __failure_type type;
+    };
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_impl<true, false, _MemPtr, _Arg>
+    : public __result_of_memobj<typename decay<_MemPtr>::type,
+    typename __inv_unwrap<_Arg>::type>
+    { };
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
+    : public __result_of_memfun<typename decay<_MemPtr>::type,
+    typename __inv_unwrap<_Arg>::type, _Args...>
+    { };
+  struct __result_of_other_impl
+  {
+    template<typename _Fn, typename... _Args>
+      static __result_of_success<decltype(
+      std::declval<_Fn>()(std::declval<_Args>()...)
+      ), __invoke_other> _S_test(int);
+    template<typename...>
+      static __failure_type _S_test(...);
+  };
+  template<typename _Functor, typename... _ArgTypes>
+    struct __result_of_impl<false, false, _Functor, _ArgTypes...>
+    : private __result_of_other_impl
+    {
+      typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
+    };
+  template<typename _Functor, typename... _ArgTypes>
+    struct __invoke_result
+    : public __result_of_impl<
+        is_member_object_pointer<
+          typename remove_reference<_Functor>::type
+        >::value,
+        is_member_function_pointer<
+          typename remove_reference<_Functor>::type
+        >::value,
+ _Functor, _ArgTypes...
+      >::type
+    { };
+  template<typename _Functor, typename... _ArgTypes>
+    struct result_of<_Functor(_ArgTypes...)>
+    : public __invoke_result<_Functor, _ArgTypes...>
+    { };
+  template<size_t _Len, size_t _Align =
+     __alignof__(typename __aligned_storage_msa<_Len>::__type)>
+    using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
+  template <size_t _Len, typename... _Types>
+    using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
+  template<typename _Tp>
+    using decay_t = typename decay<_Tp>::type;
+  template<bool _Cond, typename _Tp = void>
+    using enable_if_t = typename enable_if<_Cond, _Tp>::type;
+  template<bool _Cond, typename _Iftrue, typename _Iffalse>
+    using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
+  template<typename... _Tp>
+    using common_type_t = typename common_type<_Tp...>::type;
+  template<typename _Tp>
+    using underlying_type_t = typename underlying_type<_Tp>::type;
+  template<typename _Tp>
+    using result_of_t = typename result_of<_Tp>::type;
+  template<bool _Cond, typename _Tp = void>
+    using __enable_if_t = typename enable_if<_Cond, _Tp>::type;
+  template<typename...> using __void_t = void;
+  template<typename...> using void_t = void;
+  template<typename _Default, typename _AlwaysVoid,
+    template<typename...> class _Op, typename... _Args>
+    struct __detector
+    {
+      using value_t = false_type;
+      using type = _Default;
+    };
+  template<typename _Default, template<typename...> class _Op,
+     typename... _Args>
+    struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
+    {
+      using value_t = true_type;
+      using type = _Op<_Args...>;
+    };
+  template<typename _Default, template<typename...> class _Op,
+    typename... _Args>
+    using __detected_or = __detector<_Default, void, _Op, _Args...>;
+  template<typename _Default, template<typename...> class _Op,
+    typename... _Args>
+    using __detected_or_t
+      = typename __detected_or<_Default, _Op, _Args...>::type;
+  template <typename _Tp>
+    struct __is_swappable;
+  template <typename _Tp>
+    struct __is_nothrow_swappable;
+  template<typename... _Elements>
+    class tuple;
+  template<typename>
+    struct __is_tuple_like_impl : false_type
+    { };
+  template<typename... _Tps>
+    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
+    { };
+  template<typename _Tp>
+    struct __is_tuple_like
+    : public __is_tuple_like_impl<typename remove_cv<
+      typename remove_reference<_Tp>::type>::type>::type
+    { };
+  template<typename _Tp>
+    inline
+    typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
+         is_move_constructible<_Tp>,
+         is_move_assignable<_Tp>>::value>::type
+    swap(_Tp&, _Tp&)
+    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+             is_nothrow_move_assignable<_Tp>>::value);
+  template<typename _Tp, size_t _Nm>
+    inline
+    typename enable_if<__is_swappable<_Tp>::value>::type
+    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
+    noexcept(__is_nothrow_swappable<_Tp>::value);
+  namespace __swappable_details {
+    using std::swap;
+    struct __do_is_swappable_impl
+    {
+      template<typename _Tp, typename
+               = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
+        static true_type __test(int);
+      template<typename>
+        static false_type __test(...);
+    };
+    struct __do_is_nothrow_swappable_impl
+    {
+      template<typename _Tp>
+        static __bool_constant<
+          noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
+        > __test(int);
+      template<typename>
+        static false_type __test(...);
+    };
+  }
+  template<typename _Tp>
+    struct __is_swappable_impl
+    : public __swappable_details::__do_is_swappable_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+  template<typename _Tp>
+    struct __is_nothrow_swappable_impl
+    : public __swappable_details::__do_is_nothrow_swappable_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+  template<typename _Tp>
+    struct __is_swappable
+    : public __is_swappable_impl<_Tp>::type
+    { };
+  template<typename _Tp>
+    struct __is_nothrow_swappable
+    : public __is_nothrow_swappable_impl<_Tp>::type
+    { };
+  template<typename _Tp>
+    struct is_swappable
+    : public __is_swappable_impl<_Tp>::type
+    { };
+  template<typename _Tp>
+    struct is_nothrow_swappable
+    : public __is_nothrow_swappable_impl<_Tp>::type
+    { };
+  template<typename _Tp>
+    inline constexpr bool is_swappable_v =
+      is_swappable<_Tp>::value;
+  template<typename _Tp>
+    inline constexpr bool is_nothrow_swappable_v =
+      is_nothrow_swappable<_Tp>::value;
+  namespace __swappable_with_details {
+    using std::swap;
+    struct __do_is_swappable_with_impl
+    {
+      template<typename _Tp, typename _Up, typename
+               = decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
+               typename
+               = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))>
+        static true_type __test(int);
+      template<typename, typename>
+        static false_type __test(...);
+    };
+    struct __do_is_nothrow_swappable_with_impl
+    {
+      template<typename _Tp, typename _Up>
+        static __bool_constant<
+          noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
+          &&
+          noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()))
+        > __test(int);
+      template<typename, typename>
+        static false_type __test(...);
+    };
+  }
+  template<typename _Tp, typename _Up>
+    struct __is_swappable_with_impl
+    : public __swappable_with_details::__do_is_swappable_with_impl
+    {
+      typedef decltype(__test<_Tp, _Up>(0)) type;
+    };
+  template<typename _Tp>
+    struct __is_swappable_with_impl<_Tp&, _Tp&>
+    : public __swappable_details::__do_is_swappable_impl
+    {
+      typedef decltype(__test<_Tp&>(0)) type;
+    };
+  template<typename _Tp, typename _Up>
+    struct __is_nothrow_swappable_with_impl
+    : public __swappable_with_details::__do_is_nothrow_swappable_with_impl
+    {
+      typedef decltype(__test<_Tp, _Up>(0)) type;
+    };
+  template<typename _Tp>
+    struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
+    : public __swappable_details::__do_is_nothrow_swappable_impl
+    {
+      typedef decltype(__test<_Tp&>(0)) type;
+    };
+  template<typename _Tp, typename _Up>
+    struct is_swappable_with
+    : public __is_swappable_with_impl<_Tp, _Up>::type
+    { };
+  template<typename _Tp, typename _Up>
+    struct is_nothrow_swappable_with
+    : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
+    { };
+  template<typename _Tp, typename _Up>
+    inline constexpr bool is_swappable_with_v =
+      is_swappable_with<_Tp, _Up>::value;
+  template<typename _Tp, typename _Up>
+    inline constexpr bool is_nothrow_swappable_with_v =
+      is_nothrow_swappable_with<_Tp, _Up>::value;
+  template<typename _Result, typename _Ret, typename = void>
+    struct __is_invocable_impl : false_type { };
+  template<typename _Result, typename _Ret>
+    struct __is_invocable_impl<_Result, _Ret, __void_t<typename _Result::type>>
+    : __or_<is_void<_Ret>, is_convertible<typename _Result::type, _Ret>>::type
+    { };
+  template<typename _Fn, typename... _ArgTypes>
+    struct __is_invocable
+    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
+    { };
+  template<typename _Fn, typename _Tp, typename... _Args>
+    constexpr bool __call_is_nt(__invoke_memfun_ref)
+    {
+      using _Up = typename __inv_unwrap<_Tp>::type;
+      return noexcept((std::declval<_Up>().*std::declval<_Fn>())(
+     std::declval<_Args>()...));
+    }
+  template<typename _Fn, typename _Tp, typename... _Args>
+    constexpr bool __call_is_nt(__invoke_memfun_deref)
+    {
+      return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())(
+     std::declval<_Args>()...));
+    }
+  template<typename _Fn, typename _Tp>
+    constexpr bool __call_is_nt(__invoke_memobj_ref)
+    {
+      using _Up = typename __inv_unwrap<_Tp>::type;
+      return noexcept(std::declval<_Up>().*std::declval<_Fn>());
+    }
+  template<typename _Fn, typename _Tp>
+    constexpr bool __call_is_nt(__invoke_memobj_deref)
+    {
+      return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>());
+    }
+  template<typename _Fn, typename... _Args>
+    constexpr bool __call_is_nt(__invoke_other)
+    {
+      return noexcept(std::declval<_Fn>()(std::declval<_Args>()...));
+    }
+  template<typename _Result, typename _Fn, typename... _Args>
+    struct __call_is_nothrow
+    : __bool_constant<
+ std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{})
+      >
+    { };
+  template<typename _Fn, typename... _Args>
+    using __call_is_nothrow_
+      = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;
+  template<typename _Fn, typename... _Args>
+    struct __is_nothrow_invocable
+    : __and_<__is_invocable<_Fn, _Args...>,
+             __call_is_nothrow_<_Fn, _Args...>>::type
+    { };
+  struct __nonesuch {
+    __nonesuch() = delete;
+    ~__nonesuch() = delete;
+    __nonesuch(__nonesuch const&) = delete;
+    void operator=(__nonesuch const&) = delete;
+  };
+  template<typename _Functor, typename... _ArgTypes>
+    struct invoke_result
+    : public __invoke_result<_Functor, _ArgTypes...>
+    { };
+  template<typename _Fn, typename... _Args>
+    using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
+  template<typename _Fn, typename... _ArgTypes>
+    struct is_invocable
+    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
+    { };
+  template<typename _Ret, typename _Fn, typename... _ArgTypes>
+    struct is_invocable_r
+    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type
+    { };
+  template<typename _Fn, typename... _ArgTypes>
+    struct is_nothrow_invocable
+    : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>,
+             __call_is_nothrow_<_Fn, _ArgTypes...>>::type
+    { };
+  template<typename _Result, typename _Ret, typename = void>
+    struct __is_nt_invocable_impl : false_type { };
+  template<typename _Result, typename _Ret>
+    struct __is_nt_invocable_impl<_Result, _Ret,
+      __void_t<typename _Result::type>>
+    : __or_<is_void<_Ret>,
+     __and_<is_convertible<typename _Result::type, _Ret>,
+     is_nothrow_constructible<_Ret, typename _Result::type>>>
+    { };
+  template<typename _Ret, typename _Fn, typename... _ArgTypes>
+    struct is_nothrow_invocable_r
+    : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>,
+             __call_is_nothrow_<_Fn, _ArgTypes...>>::type
+    { };
+  template<typename _Fn, typename... _Args>
+    inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
+  template<typename _Fn, typename... _Args>
+    inline constexpr bool is_nothrow_invocable_v
+      = is_nothrow_invocable<_Fn, _Args...>::value;
+  template<typename _Fn, typename... _Args>
+    inline constexpr bool is_invocable_r_v
+      = is_invocable_r<_Fn, _Args...>::value;
+  template<typename _Fn, typename... _Args>
+    inline constexpr bool is_nothrow_invocable_r_v
+      = is_nothrow_invocable_r<_Fn, _Args...>::value;
+template <typename _Tp>
+  inline constexpr bool is_void_v = is_void<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_integral_v = is_integral<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_array_v = is_array<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_lvalue_reference_v =
+    is_lvalue_reference<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_rvalue_reference_v =
+    is_rvalue_reference<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_member_object_pointer_v =
+    is_member_object_pointer<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_member_function_pointer_v =
+    is_member_function_pointer<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_enum_v = is_enum<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_union_v = is_union<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_class_v = is_class<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_function_v = is_function<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_reference_v = is_reference<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_object_v = is_object<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_compound_v = is_compound<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_const_v = is_const<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_volatile_v = is_volatile<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivial_v = is_trivial<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_copyable_v =
+    is_trivially_copyable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_pod_v = is_pod<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_literal_type_v = is_literal_type<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_empty_v = is_empty<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_polymorphic_v = is_polymorphic<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_abstract_v = is_abstract<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_final_v = is_final<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_signed_v = is_signed<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;
+template <typename _Tp, typename... _Args>
+  inline constexpr bool is_constructible_v =
+    is_constructible<_Tp, _Args...>::value;
+template <typename _Tp>
+  inline constexpr bool is_default_constructible_v =
+    is_default_constructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_copy_constructible_v =
+    is_copy_constructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_move_constructible_v =
+    is_move_constructible<_Tp>::value;
+template <typename _Tp, typename _Up>
+  inline constexpr bool is_assignable_v = is_assignable<_Tp, _Up>::value;
+template <typename _Tp>
+  inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_destructible_v = is_destructible<_Tp>::value;
+template <typename _Tp, typename... _Args>
+  inline constexpr bool is_trivially_constructible_v =
+    is_trivially_constructible<_Tp, _Args...>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_default_constructible_v =
+    is_trivially_default_constructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_copy_constructible_v =
+    is_trivially_copy_constructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_move_constructible_v =
+    is_trivially_move_constructible<_Tp>::value;
+template <typename _Tp, typename _Up>
+  inline constexpr bool is_trivially_assignable_v =
+    is_trivially_assignable<_Tp, _Up>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_copy_assignable_v =
+    is_trivially_copy_assignable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_move_assignable_v =
+    is_trivially_move_assignable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_trivially_destructible_v =
+    is_trivially_destructible<_Tp>::value;
+template <typename _Tp, typename... _Args>
+  inline constexpr bool is_nothrow_constructible_v =
+    is_nothrow_constructible<_Tp, _Args...>::value;
+template <typename _Tp>
+  inline constexpr bool is_nothrow_default_constructible_v =
+    is_nothrow_default_constructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_nothrow_copy_constructible_v =
+    is_nothrow_copy_constructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_nothrow_move_constructible_v =
+    is_nothrow_move_constructible<_Tp>::value;
+template <typename _Tp, typename _Up>
+  inline constexpr bool is_nothrow_assignable_v =
+    is_nothrow_assignable<_Tp, _Up>::value;
+template <typename _Tp>
+  inline constexpr bool is_nothrow_copy_assignable_v =
+    is_nothrow_copy_assignable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_nothrow_move_assignable_v =
+    is_nothrow_move_assignable<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool is_nothrow_destructible_v =
+    is_nothrow_destructible<_Tp>::value;
+template <typename _Tp>
+  inline constexpr bool has_virtual_destructor_v =
+    has_virtual_destructor<_Tp>::value;
+template <typename _Tp>
+  inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value;
+template <typename _Tp>
+  inline constexpr size_t rank_v = rank<_Tp>::value;
+template <typename _Tp, unsigned _Idx = 0>
+  inline constexpr size_t extent_v = extent<_Tp, _Idx>::value;
+template <typename _Tp, typename _Up>
+  inline constexpr bool is_same_v = is_same<_Tp, _Up>::value;
+template <typename _Base, typename _Derived>
+  inline constexpr bool is_base_of_v = is_base_of<_Base, _Derived>::value;
+template <typename _From, typename _To>
+  inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value;
+  template<typename _Tp>
+    struct has_unique_object_representations
+    : bool_constant<__has_unique_object_representations(
+      remove_cv_t<remove_all_extents_t<_Tp>>
+      )>
+    { };
+  template<typename _Tp>
+    inline constexpr bool has_unique_object_representations_v
+      = has_unique_object_representations<_Tp>::value;
+  template<typename _Tp>
+    struct is_aggregate
+    : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> { };
+  template<typename _Tp>
+    inline constexpr bool is_aggregate_v = is_aggregate<_Tp>::value;
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp>
+    constexpr _Tp&&
+    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
+    { return static_cast<_Tp&&>(__t); }
+  template<typename _Tp>
+    constexpr _Tp&&
+    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
+    {
+      static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
+      " substituting _Tp is an lvalue reference type");
+      return static_cast<_Tp&&>(__t);
+    }
+  template<typename _Tp>
+    constexpr typename std::remove_reference<_Tp>::type&&
+    move(_Tp&& __t) noexcept
+    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
+  template<typename _Tp>
+    struct __move_if_noexcept_cond
+    : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
+                    is_copy_constructible<_Tp>>::type { };
+  template<typename _Tp>
+    constexpr typename
+    conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
+    move_if_noexcept(_Tp& __x) noexcept
+    { return std::move(__x); }
+  template<typename _Tp>
+    inline constexpr _Tp*
+    addressof(_Tp& __r) noexcept
+    { return std::__addressof(__r); }
+  template<typename _Tp>
+    const _Tp* addressof(const _Tp&&) = delete;
+  template <typename _Tp, typename _Up = _Tp>
+    inline _Tp
+    __exchange(_Tp& __obj, _Up&& __new_val)
+    {
+      _Tp __old_val = std::move(__obj);
+      __obj = std::forward<_Up>(__new_val);
+      return __old_val;
+    }
+  template<typename _Tp>
+    inline
+    typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
+         is_move_constructible<_Tp>,
+         is_move_assignable<_Tp>>::value>::type
+    swap(_Tp& __a, _Tp& __b)
+    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+             is_nothrow_move_assignable<_Tp>>::value)
+    {
+     
+      _Tp __tmp = std::move(__a);
+      __a = std::move(__b);
+      __b = std::move(__tmp);
+    }
+  template<typename _Tp, size_t _Nm>
+    inline
+    typename enable_if<__is_swappable<_Tp>::value>::type
+    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
+    noexcept(__is_nothrow_swappable<_Tp>::value)
+    {
+      for (size_t __n = 0; __n < _Nm; ++__n)
+ swap(__a[__n], __b[__n]);
+    }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
+  inline constexpr piecewise_construct_t piecewise_construct =
+    piecewise_construct_t();
+  template<typename...>
+    class tuple;
+  template<std::size_t...>
+    struct _Index_tuple;
+  template <bool, typename _T1, typename _T2>
+    struct _PCC
+    {
+      template <typename _U1, typename _U2>
+      static constexpr bool _ConstructiblePair()
+      {
+ return __and_<is_constructible<_T1, const _U1&>,
+        is_constructible<_T2, const _U2&>>::value;
+      }
+      template <typename _U1, typename _U2>
+      static constexpr bool _ImplicitlyConvertiblePair()
+      {
+ return __and_<is_convertible<const _U1&, _T1>,
+        is_convertible<const _U2&, _T2>>::value;
+      }
+      template <typename _U1, typename _U2>
+      static constexpr bool _MoveConstructiblePair()
+      {
+ return __and_<is_constructible<_T1, _U1&&>,
+        is_constructible<_T2, _U2&&>>::value;
+      }
+      template <typename _U1, typename _U2>
+      static constexpr bool _ImplicitlyMoveConvertiblePair()
+      {
+ return __and_<is_convertible<_U1&&, _T1>,
+        is_convertible<_U2&&, _T2>>::value;
+      }
+      template <bool __implicit, typename _U1, typename _U2>
+      static constexpr bool _CopyMovePair()
+      {
+ using __do_converts = __and_<is_convertible<const _U1&, _T1>,
+      is_convertible<_U2&&, _T2>>;
+ using __converts = typename conditional<__implicit,
+           __do_converts,
+           __not_<__do_converts>>::type;
+ return __and_<is_constructible<_T1, const _U1&>,
+        is_constructible<_T2, _U2&&>,
+        __converts
+        >::value;
+      }
+      template <bool __implicit, typename _U1, typename _U2>
+      static constexpr bool _MoveCopyPair()
+      {
+ using __do_converts = __and_<is_convertible<_U1&&, _T1>,
+      is_convertible<const _U2&, _T2>>;
+ using __converts = typename conditional<__implicit,
+           __do_converts,
+           __not_<__do_converts>>::type;
+ return __and_<is_constructible<_T1, _U1&&>,
+        is_constructible<_T2, const _U2&&>,
+        __converts
+        >::value;
+      }
+  };
+  template <typename _T1, typename _T2>
+    struct _PCC<false, _T1, _T2>
+    {
+      template <typename _U1, typename _U2>
+      static constexpr bool _ConstructiblePair()
+      {
+ return false;
+      }
+      template <typename _U1, typename _U2>
+      static constexpr bool _ImplicitlyConvertiblePair()
+      {
+ return false;
+      }
+      template <typename _U1, typename _U2>
+      static constexpr bool _MoveConstructiblePair()
+      {
+ return false;
+      }
+      template <typename _U1, typename _U2>
+      static constexpr bool _ImplicitlyMoveConvertiblePair()
+      {
+ return false;
+      }
+  };
+  struct __nonesuch_no_braces : std::__nonesuch {
+    explicit __nonesuch_no_braces(const __nonesuch&) = delete;
+  };
+  template<typename _U1, typename _U2> class __pair_base
+  {
+    template<typename _T1, typename _T2> friend struct pair;
+    __pair_base() = default;
+    ~__pair_base() = default;
+    __pair_base(const __pair_base&) = default;
+    __pair_base& operator=(const __pair_base&) = delete;
+  };
+  template<typename _T1, typename _T2>
+    struct pair
+    : private __pair_base<_T1, _T2>
+    {
+      typedef _T1 first_type;
+      typedef _T2 second_type;
+      _T1 first;
+      _T2 second;
+      template <typename _U1 = _T1,
+                typename _U2 = _T2,
+                typename enable_if<__and_<
+                                     __is_implicitly_default_constructible<_U1>,
+                                     __is_implicitly_default_constructible<_U2>>
+                                   ::value, bool>::type = true>
+      constexpr pair()
+      : first(), second() { }
+      template <typename _U1 = _T1,
+                typename _U2 = _T2,
+                typename enable_if<__and_<
+                       is_default_constructible<_U1>,
+                       is_default_constructible<_U2>,
+                       __not_<
+                         __and_<__is_implicitly_default_constructible<_U1>,
+                                __is_implicitly_default_constructible<_U2>>>>
+                                   ::value, bool>::type = false>
+      explicit constexpr pair()
+      : first(), second() { }
+      using _PCCP = _PCC<true, _T1, _T2>;
+      template<typename _U1 = _T1, typename _U2=_T2, typename
+        enable_if<_PCCP::template
+      _ConstructiblePair<_U1, _U2>()
+                  && _PCCP::template
+      _ImplicitlyConvertiblePair<_U1, _U2>(),
+                         bool>::type=true>
+      constexpr pair(const _T1& __a, const _T2& __b)
+      : first(__a), second(__b) { }
+       template<typename _U1 = _T1, typename _U2=_T2, typename
+  enable_if<_PCCP::template
+       _ConstructiblePair<_U1, _U2>()
+                   && !_PCCP::template
+       _ImplicitlyConvertiblePair<_U1, _U2>(),
+                         bool>::type=false>
+      explicit constexpr pair(const _T1& __a, const _T2& __b)
+      : first(__a), second(__b) { }
+      template <typename _U1, typename _U2>
+        using _PCCFP = _PCC<!is_same<_T1, _U1>::value
+       || !is_same<_T2, _U2>::value,
+       _T1, _T2>;
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCFP<_U1, _U2>::template
+      _ConstructiblePair<_U1, _U2>()
+                  && _PCCFP<_U1, _U2>::template
+      _ImplicitlyConvertiblePair<_U1, _U2>(),
+     bool>::type=true>
+        constexpr pair(const pair<_U1, _U2>& __p)
+        : first(__p.first), second(__p.second) { }
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCFP<_U1, _U2>::template
+      _ConstructiblePair<_U1, _U2>()
+    && !_PCCFP<_U1, _U2>::template
+      _ImplicitlyConvertiblePair<_U1, _U2>(),
+                         bool>::type=false>
+ explicit constexpr pair(const pair<_U1, _U2>& __p)
+ : first(__p.first), second(__p.second) { }
+      constexpr pair(const pair&) = default;
+      constexpr pair(pair&&) = default;
+      template<typename _U1, typename
+        enable_if<_PCCP::template
+      _MoveCopyPair<true, _U1, _T2>(),
+                         bool>::type=true>
+       constexpr pair(_U1&& __x, const _T2& __y)
+       : first(std::forward<_U1>(__x)), second(__y) { }
+      template<typename _U1, typename
+        enable_if<_PCCP::template
+      _MoveCopyPair<false, _U1, _T2>(),
+                         bool>::type=false>
+       explicit constexpr pair(_U1&& __x, const _T2& __y)
+       : first(std::forward<_U1>(__x)), second(__y) { }
+      template<typename _U2, typename
+        enable_if<_PCCP::template
+      _CopyMovePair<true, _T1, _U2>(),
+                         bool>::type=true>
+       constexpr pair(const _T1& __x, _U2&& __y)
+       : first(__x), second(std::forward<_U2>(__y)) { }
+      template<typename _U2, typename
+        enable_if<_PCCP::template
+      _CopyMovePair<false, _T1, _U2>(),
+                         bool>::type=false>
+       explicit pair(const _T1& __x, _U2&& __y)
+       : first(__x), second(std::forward<_U2>(__y)) { }
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCP::template
+      _MoveConstructiblePair<_U1, _U2>()
+     && _PCCP::template
+      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
+                         bool>::type=true>
+ constexpr pair(_U1&& __x, _U2&& __y)
+ : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCP::template
+      _MoveConstructiblePair<_U1, _U2>()
+     && !_PCCP::template
+      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
+                         bool>::type=false>
+ explicit constexpr pair(_U1&& __x, _U2&& __y)
+ : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCFP<_U1, _U2>::template
+      _MoveConstructiblePair<_U1, _U2>()
+     && _PCCFP<_U1, _U2>::template
+      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
+                         bool>::type=true>
+ constexpr pair(pair<_U1, _U2>&& __p)
+ : first(std::forward<_U1>(__p.first)),
+   second(std::forward<_U2>(__p.second)) { }
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCFP<_U1, _U2>::template
+      _MoveConstructiblePair<_U1, _U2>()
+     && !_PCCFP<_U1, _U2>::template
+      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
+                         bool>::type=false>
+ explicit constexpr pair(pair<_U1, _U2>&& __p)
+ : first(std::forward<_U1>(__p.first)),
+   second(std::forward<_U2>(__p.second)) { }
+      template<typename... _Args1, typename... _Args2>
+        pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
+      pair&
+      operator=(typename conditional<
+  __and_<is_copy_assignable<_T1>,
+         is_copy_assignable<_T2>>::value,
+  const pair&, const __nonesuch_no_braces&>::type __p)
+      {
+ first = __p.first;
+ second = __p.second;
+ return *this;
+      }
+      pair&
+      operator=(typename conditional<
+  __and_<is_move_assignable<_T1>,
+         is_move_assignable<_T2>>::value,
+  pair&&, __nonesuch_no_braces&&>::type __p)
+      noexcept(__and_<is_nothrow_move_assignable<_T1>,
+        is_nothrow_move_assignable<_T2>>::value)
+      {
+ first = std::forward<first_type>(__p.first);
+ second = std::forward<second_type>(__p.second);
+ return *this;
+      }
+      template<typename _U1, typename _U2>
+      typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
+    is_assignable<_T2&, const _U2&>>::value,
+    pair&>::type
+ operator=(const pair<_U1, _U2>& __p)
+ {
+   first = __p.first;
+   second = __p.second;
+   return *this;
+ }
+      template<typename _U1, typename _U2>
+      typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
+    is_assignable<_T2&, _U2&&>>::value,
+    pair&>::type
+ operator=(pair<_U1, _U2>&& __p)
+ {
+   first = std::forward<_U1>(__p.first);
+   second = std::forward<_U2>(__p.second);
+   return *this;
+ }
+      void
+      swap(pair& __p)
+      noexcept(__and_<__is_nothrow_swappable<_T1>,
+                      __is_nothrow_swappable<_T2>>::value)
+      {
+ using std::swap;
+ swap(first, __p.first);
+ swap(second, __p.second);
+      }
+    private:
+      template<typename... _Args1, std::size_t... _Indexes1,
+               typename... _Args2, std::size_t... _Indexes2>
+        pair(tuple<_Args1...>&, tuple<_Args2...>&,
+             _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
+    };
+  template<typename _T1, typename _T2> pair(_T1, _T2) -> pair<_T1, _T2>;
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __x.first == __y.first && __x.second == __y.second; }
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __x.first < __y.first
+      || (!(__y.first < __x.first) && __x.second < __y.second); }
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__x == __y); }
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __y < __x; }
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__y < __x); }
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__x < __y); }
+  template<typename _T1, typename _T2>
+    inline
+    typename enable_if<__and_<__is_swappable<_T1>,
+                              __is_swappable<_T2>>::value>::type
+    swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+  template<typename _T1, typename _T2>
+    typename enable_if<!__and_<__is_swappable<_T1>,
+          __is_swappable<_T2>>::value>::type
+    swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;
+  template<typename _T1, typename _T2>
+    constexpr pair<typename __decay_and_strip<_T1>::__type,
+                   typename __decay_and_strip<_T2>::__type>
+    make_pair(_T1&& __x, _T2&& __y)
+    {
+      typedef typename __decay_and_strip<_T1>::__type __ds_type1;
+      typedef typename __decay_and_strip<_T2>::__type __ds_type2;
+      typedef pair<__ds_type1, __ds_type2> __pair_type;
+      return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
+    }
+
+}
+       
+#pragma GCC visibility push(default)
+namespace std
+{
+  template<class _E>
+    class initializer_list
+    {
+    public:
+      typedef _E value_type;
+      typedef const _E& reference;
+      typedef const _E& const_reference;
+      typedef size_t size_type;
+      typedef const _E* iterator;
+      typedef const _E* const_iterator;
+    private:
+      iterator _M_array;
+      size_type _M_len;
+      constexpr initializer_list(const_iterator __a, size_type __l)
+      : _M_array(__a), _M_len(__l) { }
+    public:
+      constexpr initializer_list() noexcept
+      : _M_array(0), _M_len(0) { }
+      constexpr size_type
+      size() const noexcept { return _M_len; }
+      constexpr const_iterator
+      begin() const noexcept { return _M_array; }
+      constexpr const_iterator
+      end() const noexcept { return begin() + size(); }
+    };
+  template<class _Tp>
+    constexpr const _Tp*
+    begin(initializer_list<_Tp> __ils) noexcept
+    { return __ils.begin(); }
+  template<class _Tp>
+    constexpr const _Tp*
+    end(initializer_list<_Tp> __ils) noexcept
+    { return __ils.end(); }
+}
+#pragma GCC visibility pop
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp>
+    struct tuple_size;
+  template<typename _Tp,
+    typename _Up = typename remove_cv<_Tp>::type,
+    typename = typename enable_if<is_same<_Tp, _Up>::value>::type,
+    size_t = tuple_size<_Tp>::value>
+    using __enable_if_has_tuple_size = _Tp;
+  template<typename _Tp>
+    struct tuple_size<const __enable_if_has_tuple_size<_Tp>>
+    : public tuple_size<_Tp> { };
+  template<typename _Tp>
+    struct tuple_size<volatile __enable_if_has_tuple_size<_Tp>>
+    : public tuple_size<_Tp> { };
+  template<typename _Tp>
+    struct tuple_size<const volatile __enable_if_has_tuple_size<_Tp>>
+    : public tuple_size<_Tp> { };
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element;
+  template<std::size_t __i, typename _Tp>
+    using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, const _Tp>
+    {
+      typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
+    };
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, volatile _Tp>
+    {
+      typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
+    };
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, const volatile _Tp>
+    {
+      typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
+    };
+  template<std::size_t __i, typename _Tp>
+    using tuple_element_t = typename tuple_element<__i, _Tp>::type;
+  template<typename _T1, typename _T2>
+    struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
+    { };
+  template<class _Tp1, class _Tp2>
+    struct tuple_size<std::pair<_Tp1, _Tp2>>
+    : public integral_constant<std::size_t, 2> { };
+  template<class _Tp1, class _Tp2>
+    struct tuple_element<0, std::pair<_Tp1, _Tp2>>
+    { typedef _Tp1 type; };
+  template<class _Tp1, class _Tp2>
+    struct tuple_element<1, std::pair<_Tp1, _Tp2>>
+    { typedef _Tp2 type; };
+  template<std::size_t _Int>
+    struct __pair_get;
+  template<>
+    struct __pair_get<0>
+    {
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp1&
+        __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.first; }
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp1&&
+        __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<_Tp1>(__pair.first); }
+      template<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp1&
+        __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.first; }
+      template<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp1&&
+        __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<const _Tp1>(__pair.first); }
+    };
+  template<>
+    struct __pair_get<1>
+    {
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp2&
+        __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.second; }
+      template<typename _Tp1, typename _Tp2>
+        static constexpr _Tp2&&
+        __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<_Tp2>(__pair.second); }
+      template<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp2&
+        __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
+        { return __pair.second; }
+      template<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp2&&
+        __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<const _Tp2>(__pair.second); }
+    };
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
+    get(std::pair<_Tp1, _Tp2>& __in) noexcept
+    { return __pair_get<_Int>::__get(__in); }
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
+    get(std::pair<_Tp1, _Tp2>&& __in) noexcept
+    { return __pair_get<_Int>::__move_get(std::move(__in)); }
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
+    get(const std::pair<_Tp1, _Tp2>& __in) noexcept
+    { return __pair_get<_Int>::__const_get(__in); }
+  template<std::size_t _Int, class _Tp1, class _Tp2>
+    constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
+    get(const std::pair<_Tp1, _Tp2>&& __in) noexcept
+    { return __pair_get<_Int>::__const_move_get(std::move(__in)); }
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&
+    get(pair<_Tp, _Up>& __p) noexcept
+    { return __p.first; }
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&
+    get(const pair<_Tp, _Up>& __p) noexcept
+    { return __p.first; }
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&&
+    get(pair<_Tp, _Up>&& __p) noexcept
+    { return std::move(__p.first); }
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&&
+    get(const pair<_Tp, _Up>&& __p) noexcept
+    { return std::move(__p.first); }
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&
+    get(pair<_Up, _Tp>& __p) noexcept
+    { return __p.second; }
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&
+    get(const pair<_Up, _Tp>& __p) noexcept
+    { return __p.second; }
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&&
+    get(pair<_Up, _Tp>&& __p) noexcept
+    { return std::move(__p.second); }
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&&
+    get(const pair<_Up, _Tp>&& __p) noexcept
+    { return std::move(__p.second); }
+  template <typename _Tp, typename _Up = _Tp>
+    inline _Tp
+    exchange(_Tp& __obj, _Up&& __new_val)
+    { return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
+  template<size_t... _Indexes> struct _Index_tuple { };
+  template<size_t _Num>
+    struct _Build_index_tuple
+    {
+      using __type = _Index_tuple<__integer_pack(_Num)...>;
+    };
+  template<typename _Tp, _Tp... _Idx>
+    struct integer_sequence
+    {
+      typedef _Tp value_type;
+      static constexpr size_t size() noexcept { return sizeof...(_Idx); }
+    };
+  template<typename _Tp, _Tp _Num>
+    using make_integer_sequence
+      = integer_sequence<_Tp, __integer_pack(_Num)...>;
+  template<size_t... _Idx>
+    using index_sequence = integer_sequence<size_t, _Idx...>;
+  template<size_t _Num>
+    using make_index_sequence = make_integer_sequence<size_t, _Num>;
+  template<typename... _Types>
+    using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
+  struct in_place_t {
+    explicit in_place_t() = default;
+  };
+  inline constexpr in_place_t in_place{};
+  template<typename _Tp> struct in_place_type_t
+  {
+    explicit in_place_type_t() = default;
+  };
+  template<typename _Tp>
+    inline constexpr in_place_type_t<_Tp> in_place_type{};
+  template<size_t _Idx> struct in_place_index_t
+  {
+    explicit in_place_index_t() = default;
+  };
+  template<size_t _Idx>
+    inline constexpr in_place_index_t<_Idx> in_place_index{};
+  template<typename>
+    struct __is_in_place_type_impl : false_type
+    { };
+  template<typename _Tp>
+    struct __is_in_place_type_impl<in_place_type_t<_Tp>> : true_type
+    { };
+  template<typename _Tp>
+    struct __is_in_place_type
+      : public __is_in_place_type_impl<_Tp>
+    { };
+  template<typename _Tp>
+    constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; }
+  template<typename _Tp>
+    void as_const(const _Tp&&) = delete;
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  void
+  __throw_bad_exception(void) __attribute__((__noreturn__));
+  void
+  __throw_bad_alloc(void) __attribute__((__noreturn__));
+  void
+  __throw_bad_cast(void) __attribute__((__noreturn__));
+  void
+  __throw_bad_typeid(void) __attribute__((__noreturn__));
+  void
+  __throw_logic_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_domain_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_invalid_argument(const char*) __attribute__((__noreturn__));
+  void
+  __throw_length_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_out_of_range(const char*) __attribute__((__noreturn__));
+  void
+  __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__))
+    __attribute__((__format__(__gnu_printf__, 1, 2)));
+  void
+  __throw_runtime_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_range_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_overflow_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_underflow_error(const char*) __attribute__((__noreturn__));
+  void
+  __throw_ios_failure(const char*) __attribute__((__noreturn__));
+  void
+  __throw_system_error(int) __attribute__((__noreturn__));
+  void
+  __throw_future_error(int) __attribute__((__noreturn__));
+  void
+  __throw_bad_function_call() __attribute__((__noreturn__));
+
+}
+       
+extern "C++" {
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  struct __true_type { };
+  struct __false_type { };
+  template<bool>
+    struct __truth_type
+    { typedef __false_type __type; };
+  template<>
+    struct __truth_type<true>
+    { typedef __true_type __type; };
+  template<class _Sp, class _Tp>
+    struct __traitor
+    {
+      enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
+      typedef typename __truth_type<__value>::__type __type;
+    };
+  template<typename, typename>
+    struct __are_same
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<typename _Tp>
+    struct __are_same<_Tp, _Tp>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_void
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<>
+    struct __is_void<void>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_integer
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<>
+    struct __is_integer<bool>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<signed char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<unsigned char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<wchar_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<char16_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<char32_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<short>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<unsigned short>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<int>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<unsigned int>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<unsigned long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<long long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_integer<unsigned long long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_floating
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<>
+    struct __is_floating<float>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_floating<double>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_floating<long double>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_pointer
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<typename _Tp>
+    struct __is_pointer<_Tp*>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_arithmetic
+    : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
+    { };
+  template<typename _Tp>
+    struct __is_scalar
+    : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
+    { };
+  template<typename _Tp>
+    struct __is_char
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<>
+    struct __is_char<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_char<wchar_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_byte
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<>
+    struct __is_byte<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_byte<signed char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<>
+    struct __is_byte<unsigned char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  enum class byte : unsigned char;
+  template<>
+    struct __is_byte<byte>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Tp>
+    struct __is_move_iterator
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+  template<typename _Iterator>
+    inline _Iterator
+    __miter_base(_Iterator __it)
+    { return __it; }
+
+}
+}
+       
+extern "C++" {
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+  template<bool, typename>
+    struct __enable_if
+    { };
+  template<typename _Tp>
+    struct __enable_if<true, _Tp>
+    { typedef _Tp __type; };
+  template<bool _Cond, typename _Iftrue, typename _Iffalse>
+    struct __conditional_type
+    { typedef _Iftrue __type; };
+  template<typename _Iftrue, typename _Iffalse>
+    struct __conditional_type<false, _Iftrue, _Iffalse>
+    { typedef _Iffalse __type; };
+  template<typename _Tp>
+    struct __add_unsigned
+    {
+    private:
+      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
+    public:
+      typedef typename __if_type::__type __type;
+    };
+  template<>
+    struct __add_unsigned<char>
+    { typedef unsigned char __type; };
+  template<>
+    struct __add_unsigned<signed char>
+    { typedef unsigned char __type; };
+  template<>
+    struct __add_unsigned<short>
+    { typedef unsigned short __type; };
+  template<>
+    struct __add_unsigned<int>
+    { typedef unsigned int __type; };
+  template<>
+    struct __add_unsigned<long>
+    { typedef unsigned long __type; };
+  template<>
+    struct __add_unsigned<long long>
+    { typedef unsigned long long __type; };
+  template<>
+    struct __add_unsigned<bool>;
+  template<>
+    struct __add_unsigned<wchar_t>;
+  template<typename _Tp>
+    struct __remove_unsigned
+    {
+    private:
+      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
+    public:
+      typedef typename __if_type::__type __type;
+    };
+  template<>
+    struct __remove_unsigned<char>
+    { typedef signed char __type; };
+  template<>
+    struct __remove_unsigned<unsigned char>
+    { typedef signed char __type; };
+  template<>
+    struct __remove_unsigned<unsigned short>
+    { typedef short __type; };
+  template<>
+    struct __remove_unsigned<unsigned int>
+    { typedef int __type; };
+  template<>
+    struct __remove_unsigned<unsigned long>
+    { typedef long __type; };
+  template<>
+    struct __remove_unsigned<unsigned long long>
+    { typedef long long __type; };
+  template<>
+    struct __remove_unsigned<bool>;
+  template<>
+    struct __remove_unsigned<wchar_t>;
+  template<typename _Type>
+    inline bool
+    __is_null_pointer(_Type* __ptr)
+    { return __ptr == 0; }
+  template<typename _Type>
+    inline bool
+    __is_null_pointer(_Type)
+    { return false; }
+  inline bool
+  __is_null_pointer(std::nullptr_t)
+  { return true; }
+  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
+    struct __promote
+    { typedef double __type; };
+  template<typename _Tp>
+    struct __promote<_Tp, false>
+    { };
+  template<>
+    struct __promote<long double>
+    { typedef long double __type; };
+  template<>
+    struct __promote<double>
+    { typedef double __type; };
+  template<>
+    struct __promote<float>
+    { typedef float __type; };
+  template<typename _Tp, typename _Up,
+           typename _Tp2 = typename __promote<_Tp>::__type,
+           typename _Up2 = typename __promote<_Up>::__type>
+    struct __promote_2
+    {
+      typedef __typeof__(_Tp2() + _Up2()) __type;
+    };
+  template<typename _Tp, typename _Up, typename _Vp,
+           typename _Tp2 = typename __promote<_Tp>::__type,
+           typename _Up2 = typename __promote<_Up>::__type,
+           typename _Vp2 = typename __promote<_Vp>::__type>
+    struct __promote_3
+    {
+      typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
+    };
+  template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
+           typename _Tp2 = typename __promote<_Tp>::__type,
+           typename _Up2 = typename __promote<_Up>::__type,
+           typename _Vp2 = typename __promote<_Vp>::__type,
+           typename _Wp2 = typename __promote<_Wp>::__type>
+    struct __promote_4
+    {
+      typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
+    };
+
+}
+}
+       
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Value>
+    struct __numeric_traits_integer
+    {
+      static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
+      static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
+      static const bool __is_signed = ((_Value)(-1) < 0);
+      static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
+    };
+  template<typename _Value>
+    const _Value __numeric_traits_integer<_Value>::__min;
+  template<typename _Value>
+    const _Value __numeric_traits_integer<_Value>::__max;
+  template<typename _Value>
+    const bool __numeric_traits_integer<_Value>::__is_signed;
+  template<typename _Value>
+    const int __numeric_traits_integer<_Value>::__digits;
+  template<typename _Value>
+    struct __numeric_traits_floating
+    {
+      static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
+      static const bool __is_signed = true;
+      static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
+      static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
+    };
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__max_digits10;
+  template<typename _Value>
+    const bool __numeric_traits_floating<_Value>::__is_signed;
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__digits10;
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__max_exponent10;
+  template<typename _Value>
+    struct __numeric_traits
+    : public __conditional_type<std::__is_integer<_Value>::__value,
+    __numeric_traits_integer<_Value>,
+    __numeric_traits_floating<_Value> >::__type
+    { };
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  struct input_iterator_tag { };
+  struct output_iterator_tag { };
+  struct forward_iterator_tag : public input_iterator_tag { };
+  struct bidirectional_iterator_tag : public forward_iterator_tag { };
+  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
+  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
+           typename _Pointer = _Tp*, typename _Reference = _Tp&>
+    struct iterator
+    {
+      typedef _Category iterator_category;
+      typedef _Tp value_type;
+      typedef _Distance difference_type;
+      typedef _Pointer pointer;
+      typedef _Reference reference;
+    };
+  template<typename _Iterator, typename = __void_t<>>
+    struct __iterator_traits { };
+  template<typename _Iterator>
+    struct __iterator_traits<_Iterator,
+        __void_t<typename _Iterator::iterator_category,
+          typename _Iterator::value_type,
+          typename _Iterator::difference_type,
+          typename _Iterator::pointer,
+          typename _Iterator::reference>>
+    {
+      typedef typename _Iterator::iterator_category iterator_category;
+      typedef typename _Iterator::value_type value_type;
+      typedef typename _Iterator::difference_type difference_type;
+      typedef typename _Iterator::pointer pointer;
+      typedef typename _Iterator::reference reference;
+    };
+  template<typename _Iterator>
+    struct iterator_traits
+    : public __iterator_traits<_Iterator> { };
+  template<typename _Tp>
+    struct iterator_traits<_Tp*>
+    {
+      typedef random_access_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp* pointer;
+      typedef _Tp& reference;
+    };
+  template<typename _Tp>
+    struct iterator_traits<const _Tp*>
+    {
+      typedef random_access_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef ptrdiff_t difference_type;
+      typedef const _Tp* pointer;
+      typedef const _Tp& reference;
+    };
+  template<typename _Iter>
+    inline constexpr
+    typename iterator_traits<_Iter>::iterator_category
+    __iterator_category(const _Iter&)
+    { return typename iterator_traits<_Iter>::iterator_category(); }
+  template<typename _InIter>
+    using _RequireInputIter = typename
+      enable_if<is_convertible<typename
+  iterator_traits<_InIter>::iterator_category,
+          input_iterator_tag>::value>::type;
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template <typename> struct _List_iterator;
+  template <typename> struct _List_const_iterator;
+
+  template<typename _InputIterator>
+    inline constexpr
+    typename iterator_traits<_InputIterator>::difference_type
+    __distance(_InputIterator __first, _InputIterator __last,
+               input_iterator_tag)
+    {
+     
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
+      while (__first != __last)
+ {
+   ++__first;
+   ++__n;
+ }
+      return __n;
+    }
+  template<typename _RandomAccessIterator>
+    inline constexpr
+    typename iterator_traits<_RandomAccessIterator>::difference_type
+    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
+               random_access_iterator_tag)
+    {
+     
+      return __last - __first;
+    }
+  template<typename _Tp>
+    ptrdiff_t
+    __distance(std::_List_iterator<_Tp>,
+        std::_List_iterator<_Tp>,
+        input_iterator_tag);
+  template<typename _Tp>
+    ptrdiff_t
+    __distance(std::_List_const_iterator<_Tp>,
+        std::_List_const_iterator<_Tp>,
+        input_iterator_tag);
+  template<typename _InputIterator>
+    inline constexpr
+    typename iterator_traits<_InputIterator>::difference_type
+    distance(_InputIterator __first, _InputIterator __last)
+    {
+      return std::__distance(__first, __last,
+        std::__iterator_category(__first));
+    }
+  template<typename _InputIterator, typename _Distance>
+    inline constexpr void
+    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
+    {
+     
+      ;
+      while (__n--)
+ ++__i;
+    }
+  template<typename _BidirectionalIterator, typename _Distance>
+    inline constexpr void
+    __advance(_BidirectionalIterator& __i, _Distance __n,
+       bidirectional_iterator_tag)
+    {
+     
+      if (__n > 0)
+        while (__n--)
+   ++__i;
+      else
+        while (__n++)
+   --__i;
+    }
+  template<typename _RandomAccessIterator, typename _Distance>
+    inline constexpr void
+    __advance(_RandomAccessIterator& __i, _Distance __n,
+              random_access_iterator_tag)
+    {
+     
+      if (__builtin_constant_p(__n) && __n == 1)
+ ++__i;
+      else if (__builtin_constant_p(__n) && __n == -1)
+ --__i;
+      else
+ __i += __n;
+    }
+  template<typename _InputIterator, typename _Distance>
+    inline constexpr void
+    advance(_InputIterator& __i, _Distance __n)
+    {
+      typename iterator_traits<_InputIterator>::difference_type __d = __n;
+      std::__advance(__i, __d, std::__iterator_category(__i));
+    }
+  template<typename _InputIterator>
+    inline constexpr _InputIterator
+    next(_InputIterator __x, typename
+  iterator_traits<_InputIterator>::difference_type __n = 1)
+    {
+     
+      std::advance(__x, __n);
+      return __x;
+    }
+  template<typename _BidirectionalIterator>
+    inline constexpr _BidirectionalIterator
+    prev(_BidirectionalIterator __x, typename
+  iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
+    {
+     
+      std::advance(__x, -__n);
+      return __x;
+    }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  class __undefined;
+  template<typename _Tp>
+    struct __get_first_arg
+    { using type = __undefined; };
+  template<template<typename, typename...> class _Template, typename _Tp,
+           typename... _Types>
+    struct __get_first_arg<_Template<_Tp, _Types...>>
+    { using type = _Tp; };
+  template<typename _Tp>
+    using __get_first_arg_t = typename __get_first_arg<_Tp>::type;
+  template<typename _Tp, typename _Up>
+    struct __replace_first_arg
+    { };
+  template<template<typename, typename...> class _Template, typename _Up,
+           typename _Tp, typename... _Types>
+    struct __replace_first_arg<_Template<_Tp, _Types...>, _Up>
+    { using type = _Template<_Up, _Types...>; };
+  template<typename _Tp, typename _Up>
+    using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type;
+  template<typename _Tp>
+    using __make_not_void
+      = typename conditional<is_void<_Tp>::value, __undefined, _Tp>::type;
+  template<typename _Ptr>
+    struct pointer_traits
+    {
+    private:
+      template<typename _Tp>
+ using __element_type = typename _Tp::element_type;
+      template<typename _Tp>
+ using __difference_type = typename _Tp::difference_type;
+      template<typename _Tp, typename _Up, typename = void>
+ struct __rebind : __replace_first_arg<_Tp, _Up> { };
+      template<typename _Tp, typename _Up>
+ struct __rebind<_Tp, _Up, __void_t<typename _Tp::template rebind<_Up>>>
+ { using type = typename _Tp::template rebind<_Up>; };
+    public:
+      using pointer = _Ptr;
+      using element_type
+ = __detected_or_t<__get_first_arg_t<_Ptr>, __element_type, _Ptr>;
+      using difference_type
+ = __detected_or_t<ptrdiff_t, __difference_type, _Ptr>;
+      template<typename _Up>
+        using rebind = typename __rebind<_Ptr, _Up>::type;
+      static _Ptr
+      pointer_to(__make_not_void<element_type>& __e)
+      { return _Ptr::pointer_to(__e); }
+      static_assert(!is_same<element_type, __undefined>::value,
+   "pointer type defines element_type or is like SomePointer<T, Args>");
+    };
+  template<typename _Tp>
+    struct pointer_traits<_Tp*>
+    {
+      typedef _Tp* pointer;
+      typedef _Tp element_type;
+      typedef ptrdiff_t difference_type;
+      template<typename _Up>
+        using rebind = _Up*;
+      static pointer
+      pointer_to(__make_not_void<element_type>& __r) noexcept
+      { return std::addressof(__r); }
+    };
+  template<typename _Ptr, typename _Tp>
+    using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>;
+  template<typename _Tp>
+    constexpr _Tp*
+    __to_address(_Tp* __ptr) noexcept
+    {
+      static_assert(!std::is_function<_Tp>::value, "not a function pointer");
+      return __ptr;
+    }
+  template<typename _Ptr>
+    constexpr typename std::pointer_traits<_Ptr>::element_type*
+    __to_address(const _Ptr& __ptr)
+    { return std::__to_address(__ptr.operator->()); }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Iterator>
+    class reverse_iterator
+    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
+        typename iterator_traits<_Iterator>::value_type,
+        typename iterator_traits<_Iterator>::difference_type,
+        typename iterator_traits<_Iterator>::pointer,
+                      typename iterator_traits<_Iterator>::reference>
+    {
+    protected:
+      _Iterator current;
+      typedef iterator_traits<_Iterator> __traits_type;
+    public:
+      typedef _Iterator iterator_type;
+      typedef typename __traits_type::difference_type difference_type;
+      typedef typename __traits_type::pointer pointer;
+      typedef typename __traits_type::reference reference;
+      constexpr
+      reverse_iterator() : current() { }
+      explicit constexpr
+      reverse_iterator(iterator_type __x) : current(__x) { }
+      constexpr
+      reverse_iterator(const reverse_iterator& __x)
+      : current(__x.current) { }
+      template<typename _Iter>
+ constexpr
+        reverse_iterator(const reverse_iterator<_Iter>& __x)
+ : current(__x.base()) { }
+      constexpr iterator_type
+      base() const
+      { return current; }
+      constexpr reference
+      operator*() const
+      {
+ _Iterator __tmp = current;
+ return *--__tmp;
+      }
+      constexpr pointer
+      operator->() const
+      { return std::__addressof(operator*()); }
+      constexpr reverse_iterator&
+      operator++()
+      {
+ --current;
+ return *this;
+      }
+      constexpr reverse_iterator
+      operator++(int)
+      {
+ reverse_iterator __tmp = *this;
+ --current;
+ return __tmp;
+      }
+      constexpr reverse_iterator&
+      operator--()
+      {
+ ++current;
+ return *this;
+      }
+      constexpr reverse_iterator
+      operator--(int)
+      {
+ reverse_iterator __tmp = *this;
+ ++current;
+ return __tmp;
+      }
+      constexpr reverse_iterator
+      operator+(difference_type __n) const
+      { return reverse_iterator(current - __n); }
+      constexpr reverse_iterator&
+      operator+=(difference_type __n)
+      {
+ current -= __n;
+ return *this;
+      }
+      constexpr reverse_iterator
+      operator-(difference_type __n) const
+      { return reverse_iterator(current + __n); }
+      constexpr reverse_iterator&
+      operator-=(difference_type __n)
+      {
+ current += __n;
+ return *this;
+      }
+      constexpr reference
+      operator[](difference_type __n) const
+      { return *(*this + __n); }
+    };
+  template<typename _Iterator>
+    inline constexpr bool
+    operator==(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return __x.base() == __y.base(); }
+  template<typename _Iterator>
+    inline constexpr bool
+    operator<(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y.base() < __x.base(); }
+  template<typename _Iterator>
+    inline constexpr bool
+    operator!=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__x == __y); }
+  template<typename _Iterator>
+    inline constexpr bool
+    operator>(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y < __x; }
+  template<typename _Iterator>
+    inline constexpr bool
+    operator<=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__y < __x); }
+  template<typename _Iterator>
+    inline constexpr bool
+    operator>=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__x < __y); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator==(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return __x.base() == __y.base(); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator<(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+    { return __y.base() < __x.base(); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator!=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__x == __y); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator>(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+    { return __y < __x; }
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator<=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__y < __x); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator>=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__x < __y); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr auto
+    operator-(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+    -> decltype(__y.base() - __x.base())
+    { return __y.base() - __x.base(); }
+  template<typename _Iterator>
+    inline constexpr reverse_iterator<_Iterator>
+    operator+(typename reverse_iterator<_Iterator>::difference_type __n,
+       const reverse_iterator<_Iterator>& __x)
+    { return reverse_iterator<_Iterator>(__x.base() - __n); }
+  template<typename _Iterator>
+    inline constexpr reverse_iterator<_Iterator>
+    __make_reverse_iterator(_Iterator __i)
+    { return reverse_iterator<_Iterator>(__i); }
+  template<typename _Iterator>
+    inline constexpr reverse_iterator<_Iterator>
+    make_reverse_iterator(_Iterator __i)
+    { return reverse_iterator<_Iterator>(__i); }
+  template<typename _Iterator>
+    auto
+    __niter_base(reverse_iterator<_Iterator> __it)
+    -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
+    { return __make_reverse_iterator(__niter_base(__it.base())); }
+  template<typename _Iterator>
+    struct __is_move_iterator<reverse_iterator<_Iterator> >
+      : __is_move_iterator<_Iterator>
+    { };
+  template<typename _Iterator>
+    auto
+    __miter_base(reverse_iterator<_Iterator> __it)
+    -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
+    { return __make_reverse_iterator(__miter_base(__it.base())); }
+  template<typename _Container>
+    class back_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+    public:
+      typedef _Container container_type;
+      explicit
+      back_insert_iterator(_Container& __x)
+      : container(std::__addressof(__x)) { }
+      back_insert_iterator&
+      operator=(const typename _Container::value_type& __value)
+      {
+ container->push_back(__value);
+ return *this;
+      }
+      back_insert_iterator&
+      operator=(typename _Container::value_type&& __value)
+      {
+ container->push_back(std::move(__value));
+ return *this;
+      }
+      back_insert_iterator&
+      operator*()
+      { return *this; }
+      back_insert_iterator&
+      operator++()
+      { return *this; }
+      back_insert_iterator
+      operator++(int)
+      { return *this; }
+    };
+  template<typename _Container>
+    inline back_insert_iterator<_Container>
+    back_inserter(_Container& __x)
+    { return back_insert_iterator<_Container>(__x); }
+  template<typename _Container>
+    class front_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+    public:
+      typedef _Container container_type;
+      explicit front_insert_iterator(_Container& __x)
+      : container(std::__addressof(__x)) { }
+      front_insert_iterator&
+      operator=(const typename _Container::value_type& __value)
+      {
+ container->push_front(__value);
+ return *this;
+      }
+      front_insert_iterator&
+      operator=(typename _Container::value_type&& __value)
+      {
+ container->push_front(std::move(__value));
+ return *this;
+      }
+      front_insert_iterator&
+      operator*()
+      { return *this; }
+      front_insert_iterator&
+      operator++()
+      { return *this; }
+      front_insert_iterator
+      operator++(int)
+      { return *this; }
+    };
+  template<typename _Container>
+    inline front_insert_iterator<_Container>
+    front_inserter(_Container& __x)
+    { return front_insert_iterator<_Container>(__x); }
+  template<typename _Container>
+    class insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+      typename _Container::iterator iter;
+    public:
+      typedef _Container container_type;
+      insert_iterator(_Container& __x, typename _Container::iterator __i)
+      : container(std::__addressof(__x)), iter(__i) {}
+      insert_iterator&
+      operator=(const typename _Container::value_type& __value)
+      {
+ iter = container->insert(iter, __value);
+ ++iter;
+ return *this;
+      }
+      insert_iterator&
+      operator=(typename _Container::value_type&& __value)
+      {
+ iter = container->insert(iter, std::move(__value));
+ ++iter;
+ return *this;
+      }
+      insert_iterator&
+      operator*()
+      { return *this; }
+      insert_iterator&
+      operator++()
+      { return *this; }
+      insert_iterator&
+      operator++(int)
+      { return *this; }
+    };
+  template<typename _Container, typename _Iterator>
+    inline insert_iterator<_Container>
+    inserter(_Container& __x, _Iterator __i)
+    {
+      return insert_iterator<_Container>(__x,
+      typename _Container::iterator(__i));
+    }
+
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+  using std::iterator_traits;
+  using std::iterator;
+  template<typename _Iterator, typename _Container>
+    class __normal_iterator
+    {
+    protected:
+      _Iterator _M_current;
+      typedef iterator_traits<_Iterator> __traits_type;
+    public:
+      typedef _Iterator iterator_type;
+      typedef typename __traits_type::iterator_category iterator_category;
+      typedef typename __traits_type::value_type value_type;
+      typedef typename __traits_type::difference_type difference_type;
+      typedef typename __traits_type::reference reference;
+      typedef typename __traits_type::pointer pointer;
+      constexpr __normal_iterator() noexcept
+      : _M_current(_Iterator()) { }
+      explicit
+      __normal_iterator(const _Iterator& __i) noexcept
+      : _M_current(__i) { }
+      template<typename _Iter>
+        __normal_iterator(const __normal_iterator<_Iter,
+     typename __enable_if<
+              (std::__are_same<_Iter, typename _Container::pointer>::__value),
+        _Container>::__type>& __i) noexcept
+        : _M_current(__i.base()) { }
+      reference
+      operator*() const noexcept
+      { return *_M_current; }
+      pointer
+      operator->() const noexcept
+      { return _M_current; }
+      __normal_iterator&
+      operator++() noexcept
+      {
+ ++_M_current;
+ return *this;
+      }
+      __normal_iterator
+      operator++(int) noexcept
+      { return __normal_iterator(_M_current++); }
+      __normal_iterator&
+      operator--() noexcept
+      {
+ --_M_current;
+ return *this;
+      }
+      __normal_iterator
+      operator--(int) noexcept
+      { return __normal_iterator(_M_current--); }
+      reference
+      operator[](difference_type __n) const noexcept
+      { return _M_current[__n]; }
+      __normal_iterator&
+      operator+=(difference_type __n) noexcept
+      { _M_current += __n; return *this; }
+      __normal_iterator
+      operator+(difference_type __n) const noexcept
+      { return __normal_iterator(_M_current + __n); }
+      __normal_iterator&
+      operator-=(difference_type __n) noexcept
+      { _M_current -= __n; return *this; }
+      __normal_iterator
+      operator-(difference_type __n) const noexcept
+      { return __normal_iterator(_M_current - __n); }
+      const _Iterator&
+      base() const noexcept
+      { return _M_current; }
+    };
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() == __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() == __rhs.base(); }
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() != __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() != __rhs.base(); }
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
+       const __normal_iterator<_IteratorR, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() < __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
+       const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() < __rhs.base(); }
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
+       const __normal_iterator<_IteratorR, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() > __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
+       const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() > __rhs.base(); }
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() <= __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() <= __rhs.base(); }
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() >= __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() >= __rhs.base(); }
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline auto
+    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
+       const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
+    -> decltype(__lhs.base() - __rhs.base())
+    { return __lhs.base() - __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline typename __normal_iterator<_Iterator, _Container>::difference_type
+    operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
+       const __normal_iterator<_Iterator, _Container>& __rhs)
+    noexcept
+    { return __lhs.base() - __rhs.base(); }
+  template<typename _Iterator, typename _Container>
+    inline __normal_iterator<_Iterator, _Container>
+    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
+       __n, const __normal_iterator<_Iterator, _Container>& __i)
+    noexcept
+    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Iterator, typename _Container>
+    _Iterator
+    __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
+    { return __it.base(); }
+  template<typename _Iterator>
+    class move_iterator
+    {
+    protected:
+      _Iterator _M_current;
+      typedef iterator_traits<_Iterator> __traits_type;
+      typedef typename __traits_type::reference __base_ref;
+    public:
+      typedef _Iterator iterator_type;
+      typedef typename __traits_type::iterator_category iterator_category;
+      typedef typename __traits_type::value_type value_type;
+      typedef typename __traits_type::difference_type difference_type;
+      typedef _Iterator pointer;
+      typedef typename conditional<is_reference<__base_ref>::value,
+    typename remove_reference<__base_ref>::type&&,
+    __base_ref>::type reference;
+      constexpr
+      move_iterator()
+      : _M_current() { }
+      explicit constexpr
+      move_iterator(iterator_type __i)
+      : _M_current(__i) { }
+      template<typename _Iter>
+ constexpr
+ move_iterator(const move_iterator<_Iter>& __i)
+ : _M_current(__i.base()) { }
+      constexpr iterator_type
+      base() const
+      { return _M_current; }
+      constexpr reference
+      operator*() const
+      { return static_cast<reference>(*_M_current); }
+      constexpr pointer
+      operator->() const
+      { return _M_current; }
+      constexpr move_iterator&
+      operator++()
+      {
+ ++_M_current;
+ return *this;
+      }
+      constexpr move_iterator
+      operator++(int)
+      {
+ move_iterator __tmp = *this;
+ ++_M_current;
+ return __tmp;
+      }
+      constexpr move_iterator&
+      operator--()
+      {
+ --_M_current;
+ return *this;
+      }
+      constexpr move_iterator
+      operator--(int)
+      {
+ move_iterator __tmp = *this;
+ --_M_current;
+ return __tmp;
+      }
+      constexpr move_iterator
+      operator+(difference_type __n) const
+      { return move_iterator(_M_current + __n); }
+      constexpr move_iterator&
+      operator+=(difference_type __n)
+      {
+ _M_current += __n;
+ return *this;
+      }
+      constexpr move_iterator
+      operator-(difference_type __n) const
+      { return move_iterator(_M_current - __n); }
+      constexpr move_iterator&
+      operator-=(difference_type __n)
+      {
+ _M_current -= __n;
+ return *this;
+      }
+      constexpr reference
+      operator[](difference_type __n) const
+      { return std::move(_M_current[__n]); }
+    };
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator==(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+    { return __x.base() == __y.base(); }
+  template<typename _Iterator>
+    inline constexpr bool
+    operator==(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return __x.base() == __y.base(); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator!=(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+    { return !(__x == __y); }
+  template<typename _Iterator>
+    inline constexpr bool
+    operator!=(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return !(__x == __y); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator<(const move_iterator<_IteratorL>& __x,
+       const move_iterator<_IteratorR>& __y)
+    { return __x.base() < __y.base(); }
+  template<typename _Iterator>
+    inline constexpr bool
+    operator<(const move_iterator<_Iterator>& __x,
+       const move_iterator<_Iterator>& __y)
+    { return __x.base() < __y.base(); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator<=(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+    { return !(__y < __x); }
+  template<typename _Iterator>
+    inline constexpr bool
+    operator<=(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return !(__y < __x); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator>(const move_iterator<_IteratorL>& __x,
+       const move_iterator<_IteratorR>& __y)
+    { return __y < __x; }
+  template<typename _Iterator>
+    inline constexpr bool
+    operator>(const move_iterator<_Iterator>& __x,
+       const move_iterator<_Iterator>& __y)
+    { return __y < __x; }
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr bool
+    operator>=(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+    { return !(__x < __y); }
+  template<typename _Iterator>
+    inline constexpr bool
+    operator>=(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return !(__x < __y); }
+  template<typename _IteratorL, typename _IteratorR>
+    inline constexpr auto
+    operator-(const move_iterator<_IteratorL>& __x,
+       const move_iterator<_IteratorR>& __y)
+    -> decltype(__x.base() - __y.base())
+    { return __x.base() - __y.base(); }
+  template<typename _Iterator>
+    inline constexpr move_iterator<_Iterator>
+    operator+(typename move_iterator<_Iterator>::difference_type __n,
+       const move_iterator<_Iterator>& __x)
+    { return __x + __n; }
+  template<typename _Iterator>
+    inline constexpr move_iterator<_Iterator>
+    make_move_iterator(_Iterator __i)
+    { return move_iterator<_Iterator>(__i); }
+  template<typename _Iterator, typename _ReturnType
+    = typename conditional<__move_if_noexcept_cond
+      <typename iterator_traits<_Iterator>::value_type>::value,
+                _Iterator, move_iterator<_Iterator>>::type>
+    inline constexpr _ReturnType
+    __make_move_if_noexcept_iterator(_Iterator __i)
+    { return _ReturnType(__i); }
+  template<typename _Tp, typename _ReturnType
+    = typename conditional<__move_if_noexcept_cond<_Tp>::value,
+      const _Tp*, move_iterator<_Tp*>>::type>
+    inline constexpr _ReturnType
+    __make_move_if_noexcept_iterator(_Tp* __i)
+    { return _ReturnType(__i); }
+  template<typename _Iterator>
+    auto
+    __niter_base(move_iterator<_Iterator> __it)
+    -> decltype(make_move_iterator(__niter_base(__it.base())))
+    { return make_move_iterator(__niter_base(__it.base())); }
+  template<typename _Iterator>
+    struct __is_move_iterator<move_iterator<_Iterator> >
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+  template<typename _Iterator>
+    auto
+    __miter_base(move_iterator<_Iterator> __it)
+    -> decltype(__miter_base(__it.base()))
+    { return __miter_base(__it.base()); }
+  template<typename _InputIterator>
+    using __iter_key_t = remove_const_t<
+    typename iterator_traits<_InputIterator>::value_type::first_type>;
+  template<typename _InputIterator>
+    using __iter_val_t =
+    typename iterator_traits<_InputIterator>::value_type::second_type;
+  template<typename _T1, typename _T2>
+    struct pair;
+  template<typename _InputIterator>
+    using __iter_to_alloc_t =
+    pair<add_const_t<__iter_key_t<_InputIterator>>,
+  __iter_val_t<_InputIterator>>;
+
+}
+namespace std
+{
+  namespace __debug { }
+}
+namespace __gnu_debug
+{
+  using namespace std::__debug;
+}
+namespace __gnu_cxx
+{
+namespace __ops
+{
+  struct _Iter_less_iter
+  {
+    template<typename _Iterator1, typename _Iterator2>
+      constexpr
+      bool
+      operator()(_Iterator1 __it1, _Iterator2 __it2) const
+      { return *__it1 < *__it2; }
+  };
+  constexpr
+  inline _Iter_less_iter
+  __iter_less_iter()
+  { return _Iter_less_iter(); }
+  struct _Iter_less_val
+  {
+    constexpr _Iter_less_val() = default;
+    explicit
+    _Iter_less_val(_Iter_less_iter) { }
+    template<typename _Iterator, typename _Value>
+      bool
+      operator()(_Iterator __it, _Value& __val) const
+      { return *__it < __val; }
+  };
+  inline _Iter_less_val
+  __iter_less_val()
+  { return _Iter_less_val(); }
+  inline _Iter_less_val
+  __iter_comp_val(_Iter_less_iter)
+  { return _Iter_less_val(); }
+  struct _Val_less_iter
+  {
+    constexpr _Val_less_iter() = default;
+    explicit
+    _Val_less_iter(_Iter_less_iter) { }
+    template<typename _Value, typename _Iterator>
+      bool
+      operator()(_Value& __val, _Iterator __it) const
+      { return __val < *__it; }
+  };
+  inline _Val_less_iter
+  __val_less_iter()
+  { return _Val_less_iter(); }
+  inline _Val_less_iter
+  __val_comp_iter(_Iter_less_iter)
+  { return _Val_less_iter(); }
+  struct _Iter_equal_to_iter
+  {
+    template<typename _Iterator1, typename _Iterator2>
+      bool
+      operator()(_Iterator1 __it1, _Iterator2 __it2) const
+      { return *__it1 == *__it2; }
+  };
+  inline _Iter_equal_to_iter
+  __iter_equal_to_iter()
+  { return _Iter_equal_to_iter(); }
+  struct _Iter_equal_to_val
+  {
+    template<typename _Iterator, typename _Value>
+      bool
+      operator()(_Iterator __it, _Value& __val) const
+      { return *__it == __val; }
+  };
+  inline _Iter_equal_to_val
+  __iter_equal_to_val()
+  { return _Iter_equal_to_val(); }
+  inline _Iter_equal_to_val
+  __iter_comp_val(_Iter_equal_to_iter)
+  { return _Iter_equal_to_val(); }
+  template<typename _Compare>
+    struct _Iter_comp_iter
+    {
+      _Compare _M_comp;
+      explicit constexpr
+      _Iter_comp_iter(_Compare __comp)
+ : _M_comp(std::move(__comp))
+      { }
+      template<typename _Iterator1, typename _Iterator2>
+        constexpr
+        bool
+        operator()(_Iterator1 __it1, _Iterator2 __it2)
+        { return bool(_M_comp(*__it1, *__it2)); }
+    };
+  template<typename _Compare>
+    constexpr
+    inline _Iter_comp_iter<_Compare>
+    __iter_comp_iter(_Compare __comp)
+    { return _Iter_comp_iter<_Compare>(std::move(__comp)); }
+  template<typename _Compare>
+    struct _Iter_comp_val
+    {
+      _Compare _M_comp;
+      explicit
+      _Iter_comp_val(_Compare __comp)
+ : _M_comp(std::move(__comp))
+      { }
+      explicit
+      _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp)
+ : _M_comp(__comp._M_comp)
+      { }
+      explicit
+      _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
+ : _M_comp(std::move(__comp._M_comp))
+      { }
+      template<typename _Iterator, typename _Value>
+ bool
+ operator()(_Iterator __it, _Value& __val)
+ { return bool(_M_comp(*__it, __val)); }
+    };
+  template<typename _Compare>
+   inline _Iter_comp_val<_Compare>
+    __iter_comp_val(_Compare __comp)
+    { return _Iter_comp_val<_Compare>(std::move(__comp)); }
+  template<typename _Compare>
+    inline _Iter_comp_val<_Compare>
+    __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
+    { return _Iter_comp_val<_Compare>(std::move(__comp)); }
+  template<typename _Compare>
+    struct _Val_comp_iter
+    {
+      _Compare _M_comp;
+      explicit
+      _Val_comp_iter(_Compare __comp)
+ : _M_comp(std::move(__comp))
+      { }
+      explicit
+      _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp)
+ : _M_comp(__comp._M_comp)
+      { }
+      explicit
+      _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
+ : _M_comp(std::move(__comp._M_comp))
+      { }
+      template<typename _Value, typename _Iterator>
+ bool
+ operator()(_Value& __val, _Iterator __it)
+ { return bool(_M_comp(__val, *__it)); }
+    };
+  template<typename _Compare>
+    inline _Val_comp_iter<_Compare>
+    __val_comp_iter(_Compare __comp)
+    { return _Val_comp_iter<_Compare>(std::move(__comp)); }
+  template<typename _Compare>
+    inline _Val_comp_iter<_Compare>
+    __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
+    { return _Val_comp_iter<_Compare>(std::move(__comp)); }
+  template<typename _Value>
+    struct _Iter_equals_val
+    {
+      _Value& _M_value;
+      explicit
+      _Iter_equals_val(_Value& __value)
+ : _M_value(__value)
+      { }
+      template<typename _Iterator>
+ bool
+ operator()(_Iterator __it)
+ { return *__it == _M_value; }
+    };
+  template<typename _Value>
+    inline _Iter_equals_val<_Value>
+    __iter_equals_val(_Value& __val)
+    { return _Iter_equals_val<_Value>(__val); }
+  template<typename _Iterator1>
+    struct _Iter_equals_iter
+    {
+      _Iterator1 _M_it1;
+      explicit
+      _Iter_equals_iter(_Iterator1 __it1)
+ : _M_it1(__it1)
+      { }
+      template<typename _Iterator2>
+ bool
+ operator()(_Iterator2 __it2)
+ { return *__it2 == *_M_it1; }
+    };
+  template<typename _Iterator>
+    inline _Iter_equals_iter<_Iterator>
+    __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
+    { return _Iter_equals_iter<_Iterator>(__it); }
+  template<typename _Predicate>
+    struct _Iter_pred
+    {
+      _Predicate _M_pred;
+      explicit
+      _Iter_pred(_Predicate __pred)
+ : _M_pred(std::move(__pred))
+      { }
+      template<typename _Iterator>
+ bool
+ operator()(_Iterator __it)
+ { return bool(_M_pred(*__it)); }
+    };
+  template<typename _Predicate>
+    inline _Iter_pred<_Predicate>
+    __pred_iter(_Predicate __pred)
+    { return _Iter_pred<_Predicate>(std::move(__pred)); }
+  template<typename _Compare, typename _Value>
+    struct _Iter_comp_to_val
+    {
+      _Compare _M_comp;
+      _Value& _M_value;
+      _Iter_comp_to_val(_Compare __comp, _Value& __value)
+ : _M_comp(std::move(__comp)), _M_value(__value)
+      { }
+      template<typename _Iterator>
+ bool
+ operator()(_Iterator __it)
+ { return bool(_M_comp(*__it, _M_value)); }
+    };
+  template<typename _Compare, typename _Value>
+    _Iter_comp_to_val<_Compare, _Value>
+    __iter_comp_val(_Compare __comp, _Value &__val)
+    {
+      return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val);
+    }
+  template<typename _Compare, typename _Iterator1>
+    struct _Iter_comp_to_iter
+    {
+      _Compare _M_comp;
+      _Iterator1 _M_it1;
+      _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
+ : _M_comp(std::move(__comp)), _M_it1(__it1)
+      { }
+      template<typename _Iterator2>
+ bool
+ operator()(_Iterator2 __it2)
+ { return bool(_M_comp(*__it2, *_M_it1)); }
+    };
+  template<typename _Compare, typename _Iterator>
+    inline _Iter_comp_to_iter<_Compare, _Iterator>
+    __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
+    {
+      return _Iter_comp_to_iter<_Compare, _Iterator>(
+   std::move(__comp._M_comp), __it);
+    }
+  template<typename _Predicate>
+    struct _Iter_negate
+    {
+      _Predicate _M_pred;
+      explicit
+      _Iter_negate(_Predicate __pred)
+ : _M_pred(std::move(__pred))
+      { }
+      template<typename _Iterator>
+ bool
+ operator()(_Iterator __it)
+ { return !bool(_M_pred(*__it)); }
+    };
+  template<typename _Predicate>
+    inline _Iter_negate<_Predicate>
+    __negate(_Iter_pred<_Predicate> __pred)
+    { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); }
+}
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline void
+    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+    {
+     
+     
+      swap(*__a, *__b);
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    _ForwardIterator2
+    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+  _ForwardIterator2 __first2)
+    {
+     
+     
+      ;
+      for (; __first1 != __last1; ++__first1, (void)++__first2)
+ std::iter_swap(__first1, __first2);
+      return __first2;
+    }
+  template<typename _Tp>
+    constexpr
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b)
+    {
+     
+      if (__b < __a)
+ return __b;
+      return __a;
+    }
+  template<typename _Tp>
+    constexpr
+    inline const _Tp&
+    max(const _Tp& __a, const _Tp& __b)
+    {
+     
+      if (__a < __b)
+ return __b;
+      return __a;
+    }
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+      if (__comp(__b, __a))
+ return __b;
+      return __a;
+    }
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline const _Tp&
+    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+      if (__comp(__a, __b))
+ return __b;
+      return __a;
+    }
+  template<typename _Iterator>
+    inline _Iterator
+    __niter_base(_Iterator __it)
+    { return __it; }
+  template<bool, bool, typename>
+    struct __copy_move
+    {
+      template<typename _II, typename _OI>
+ static _OI
+ __copy_m(_II __first, _II __last, _OI __result)
+ {
+   for (; __first != __last; ++__result, (void)++__first)
+     *__result = *__first;
+   return __result;
+ }
+    };
+  template<typename _Category>
+    struct __copy_move<true, false, _Category>
+    {
+      template<typename _II, typename _OI>
+ static _OI
+ __copy_m(_II __first, _II __last, _OI __result)
+ {
+   for (; __first != __last; ++__result, (void)++__first)
+     *__result = std::move(*__first);
+   return __result;
+ }
+    };
+  template<>
+    struct __copy_move<false, false, random_access_iterator_tag>
+    {
+      template<typename _II, typename _OI>
+ static _OI
+ __copy_m(_II __first, _II __last, _OI __result)
+ {
+   typedef typename iterator_traits<_II>::difference_type _Distance;
+   for(_Distance __n = __last - __first; __n > 0; --__n)
+     {
+       *__result = *__first;
+       ++__first;
+       ++__result;
+     }
+   return __result;
+ }
+    };
+  template<>
+    struct __copy_move<true, false, random_access_iterator_tag>
+    {
+      template<typename _II, typename _OI>
+ static _OI
+ __copy_m(_II __first, _II __last, _OI __result)
+ {
+   typedef typename iterator_traits<_II>::difference_type _Distance;
+   for(_Distance __n = __last - __first; __n > 0; --__n)
+     {
+       *__result = std::move(*__first);
+       ++__first;
+       ++__result;
+     }
+   return __result;
+ }
+    };
+  template<bool _IsMove>
+    struct __copy_move<_IsMove, true, random_access_iterator_tag>
+    {
+      template<typename _Tp>
+ static _Tp*
+ __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
+ {
+   using __assignable = conditional<_IsMove,
+        is_move_assignable<_Tp>,
+        is_copy_assignable<_Tp>>;
+   static_assert( __assignable::type::value, "type is not assignable" );
+   const ptrdiff_t _Num = __last - __first;
+   if (_Num)
+     __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
+   return __result + _Num;
+ }
+    };
+  template<bool _IsMove, typename _II, typename _OI>
+    inline _OI
+    __copy_move_a(_II __first, _II __last, _OI __result)
+    {
+      typedef typename iterator_traits<_II>::value_type _ValueTypeI;
+      typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
+      typedef typename iterator_traits<_II>::iterator_category _Category;
+      const bool __simple = (__is_trivial(_ValueTypeI)
+        && __is_pointer<_II>::__value
+        && __is_pointer<_OI>::__value
+        && __are_same<_ValueTypeI, _ValueTypeO>::__value);
+      return std::__copy_move<_IsMove, __simple,
+         _Category>::__copy_m(__first, __last, __result);
+    }
+  template<typename _CharT>
+    struct char_traits;
+  template<typename _CharT, typename _Traits>
+    class istreambuf_iterator;
+  template<typename _CharT, typename _Traits>
+    class ostreambuf_iterator;
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
+    __copy_move_a2(_CharT*, _CharT*,
+     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
+    __copy_move_a2(const _CharT*, const _CharT*,
+     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        _CharT*>::__type
+    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
+     istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
+  template<bool _IsMove, typename _II, typename _OI>
+    inline _OI
+    __copy_move_a2(_II __first, _II __last, _OI __result)
+    {
+      return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
+          std::__niter_base(__last),
+          std::__niter_base(__result)));
+    }
+  template<typename _II, typename _OI>
+    inline _OI
+    copy(_II __first, _II __last, _OI __result)
+    {
+     
+     
+      ;
+      return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
+       (std::__miter_base(__first), std::__miter_base(__last),
+        __result));
+    }
+  template<typename _II, typename _OI>
+    inline _OI
+    move(_II __first, _II __last, _OI __result)
+    {
+     
+     
+      ;
+      return std::__copy_move_a2<true>(std::__miter_base(__first),
+           std::__miter_base(__last), __result);
+    }
+  template<bool, bool, typename>
+    struct __copy_move_backward
+    {
+      template<typename _BI1, typename _BI2>
+ static _BI2
+ __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+ {
+   while (__first != __last)
+     *--__result = *--__last;
+   return __result;
+ }
+    };
+  template<typename _Category>
+    struct __copy_move_backward<true, false, _Category>
+    {
+      template<typename _BI1, typename _BI2>
+ static _BI2
+ __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+ {
+   while (__first != __last)
+     *--__result = std::move(*--__last);
+   return __result;
+ }
+    };
+  template<>
+    struct __copy_move_backward<false, false, random_access_iterator_tag>
+    {
+      template<typename _BI1, typename _BI2>
+ static _BI2
+ __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+ {
+   typename iterator_traits<_BI1>::difference_type __n;
+   for (__n = __last - __first; __n > 0; --__n)
+     *--__result = *--__last;
+   return __result;
+ }
+    };
+  template<>
+    struct __copy_move_backward<true, false, random_access_iterator_tag>
+    {
+      template<typename _BI1, typename _BI2>
+ static _BI2
+ __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+ {
+   typename iterator_traits<_BI1>::difference_type __n;
+   for (__n = __last - __first; __n > 0; --__n)
+     *--__result = std::move(*--__last);
+   return __result;
+ }
+    };
+  template<bool _IsMove>
+    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
+    {
+      template<typename _Tp>
+ static _Tp*
+ __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
+ {
+   using __assignable = conditional<_IsMove,
+        is_move_assignable<_Tp>,
+        is_copy_assignable<_Tp>>;
+   static_assert( __assignable::type::value, "type is not assignable" );
+   const ptrdiff_t _Num = __last - __first;
+   if (_Num)
+     __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
+   return __result - _Num;
+ }
+    };
+  template<bool _IsMove, typename _BI1, typename _BI2>
+    inline _BI2
+    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
+      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
+      typedef typename iterator_traits<_BI1>::iterator_category _Category;
+      const bool __simple = (__is_trivial(_ValueType1)
+        && __is_pointer<_BI1>::__value
+        && __is_pointer<_BI2>::__value
+        && __are_same<_ValueType1, _ValueType2>::__value);
+      return std::__copy_move_backward<_IsMove, __simple,
+           _Category>::__copy_move_b(__first,
+         __last,
+         __result);
+    }
+  template<bool _IsMove, typename _BI1, typename _BI2>
+    inline _BI2
+    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      return _BI2(std::__copy_move_backward_a<_IsMove>
+    (std::__niter_base(__first), std::__niter_base(__last),
+     std::__niter_base(__result)));
+    }
+  template<typename _BI1, typename _BI2>
+    inline _BI2
+    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+     
+     
+     
+      ;
+      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
+       (std::__miter_base(__first), std::__miter_base(__last),
+        __result));
+    }
+  template<typename _BI1, typename _BI2>
+    inline _BI2
+    move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+     
+     
+     
+      ;
+      return std::__copy_move_backward_a2<true>(std::__miter_base(__first),
+      std::__miter_base(__last),
+      __result);
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
+    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
+       const _Tp& __value)
+    {
+      for (; __first != __last; ++__first)
+ *__first = __value;
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
+    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __value)
+    {
+      const _Tp __tmp = __value;
+      for (; __first != __last; ++__first)
+ *__first = __tmp;
+    }
+  template<typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
+    __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
+    {
+      const _Tp __tmp = __c;
+      if (const size_t __len = __last - __first)
+ __builtin_memset(__first, static_cast<unsigned char>(__tmp), __len);
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
+    {
+     
+      ;
+      std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
+      __value);
+    }
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      for (__decltype(__n + 0) __niter = __n;
+    __niter > 0; --__niter, (void) ++__first)
+ *__first = __value;
+      return __first;
+    }
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      const _Tp __tmp = __value;
+      for (__decltype(__n + 0) __niter = __n;
+    __niter > 0; --__niter, (void) ++__first)
+ *__first = __tmp;
+      return __first;
+    }
+  template<typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
+    __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
+    {
+      std::__fill_a(__first, __first + __n, __c);
+      return __first + __n;
+    }
+  template<typename _OI, typename _Size, typename _Tp>
+    inline _OI
+    fill_n(_OI __first, _Size __n, const _Tp& __value)
+    {
+     
+      return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
+    }
+  template<bool _BoolType>
+    struct __equal
+    {
+      template<typename _II1, typename _II2>
+ static bool
+ equal(_II1 __first1, _II1 __last1, _II2 __first2)
+ {
+   for (; __first1 != __last1; ++__first1, (void) ++__first2)
+     if (!(*__first1 == *__first2))
+       return false;
+   return true;
+ }
+    };
+  template<>
+    struct __equal<true>
+    {
+      template<typename _Tp>
+ static bool
+ equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
+ {
+   if (const size_t __len = (__last1 - __first1))
+     return !__builtin_memcmp(__first1, __first2, sizeof(_Tp) * __len);
+   return true;
+ }
+    };
+  template<typename _II1, typename _II2>
+    inline bool
+    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+      const bool __simple = ((__is_integer<_ValueType1>::__value
+         || __is_pointer<_ValueType1>::__value)
+        && __is_pointer<_II1>::__value
+        && __is_pointer<_II2>::__value
+        && __are_same<_ValueType1, _ValueType2>::__value);
+      return std::__equal<__simple>::equal(__first1, __last1, __first2);
+    }
+  template<typename, typename>
+    struct __lc_rai
+    {
+      template<typename _II1, typename _II2>
+ static _II1
+ __newlast1(_II1, _II1 __last1, _II2, _II2)
+ { return __last1; }
+      template<typename _II>
+ static bool
+ __cnd2(_II __first, _II __last)
+ { return __first != __last; }
+    };
+  template<>
+    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
+    {
+      template<typename _RAI1, typename _RAI2>
+ static _RAI1
+ __newlast1(_RAI1 __first1, _RAI1 __last1,
+     _RAI2 __first2, _RAI2 __last2)
+ {
+   const typename iterator_traits<_RAI1>::difference_type
+     __diff1 = __last1 - __first1;
+   const typename iterator_traits<_RAI2>::difference_type
+     __diff2 = __last2 - __first2;
+   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
+ }
+      template<typename _RAI>
+ static bool
+ __cnd2(_RAI, _RAI)
+ { return true; }
+    };
+  template<typename _II1, typename _II2, typename _Compare>
+    bool
+    __lexicographical_compare_impl(_II1 __first1, _II1 __last1,
+       _II2 __first2, _II2 __last2,
+       _Compare __comp)
+    {
+      typedef typename iterator_traits<_II1>::iterator_category _Category1;
+      typedef typename iterator_traits<_II2>::iterator_category _Category2;
+      typedef std::__lc_rai<_Category1, _Category2> __rai_type;
+      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
+      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
+    ++__first1, (void)++__first2)
+ {
+   if (__comp(__first1, __first2))
+     return true;
+   if (__comp(__first2, __first1))
+     return false;
+ }
+      return __first1 == __last1 && __first2 != __last2;
+    }
+  template<bool _BoolType>
+    struct __lexicographical_compare
+    {
+      template<typename _II1, typename _II2>
+ static bool __lc(_II1, _II1, _II2, _II2);
+    };
+  template<bool _BoolType>
+    template<typename _II1, typename _II2>
+      bool
+      __lexicographical_compare<_BoolType>::
+      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
+      {
+ return std::__lexicographical_compare_impl(__first1, __last1,
+         __first2, __last2,
+     __gnu_cxx::__ops::__iter_less_iter());
+      }
+  template<>
+    struct __lexicographical_compare<true>
+    {
+      template<typename _Tp, typename _Up>
+ static bool
+ __lc(const _Tp* __first1, const _Tp* __last1,
+      const _Up* __first2, const _Up* __last2)
+ {
+   const size_t __len1 = __last1 - __first1;
+   const size_t __len2 = __last2 - __first2;
+   if (const size_t __len = std::min(__len1, __len2))
+     if (int __result = __builtin_memcmp(__first1, __first2, __len))
+       return __result < 0;
+   return __len1 < __len2;
+ }
+    };
+  template<typename _II1, typename _II2>
+    inline bool
+    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
+      _II2 __first2, _II2 __last2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+      const bool __simple =
+ (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
+  && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
+  && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
+  && __is_pointer<_II1>::__value
+  && __is_pointer<_II2>::__value);
+      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
+           __first2, __last2);
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+      _DistanceType __len = std::distance(__first, __last);
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp(__middle, __val))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else
+     __len = __half;
+ }
+      return __first;
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+     
+     
+      ;
+      return std::__lower_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_less_val());
+    }
+  inline constexpr int
+  __lg(int __n)
+  { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); }
+  inline constexpr unsigned
+  __lg(unsigned __n)
+  { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); }
+  inline constexpr long
+  __lg(long __n)
+  { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
+  inline constexpr unsigned long
+  __lg(unsigned long __n)
+  { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
+  inline constexpr long long
+  __lg(long long __n)
+  { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
+  inline constexpr unsigned long long
+  __lg(unsigned long long __n)
+  { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
+
+  template<typename _II1, typename _II2>
+    inline bool
+    equal(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+     
+     
+     
+      ;
+      return std::__equal_aux(std::__niter_base(__first1),
+         std::__niter_base(__last1),
+         std::__niter_base(__first2));
+    }
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    inline bool
+    equal(_IIter1 __first1, _IIter1 __last1,
+   _IIter2 __first2, _BinaryPredicate __binary_pred)
+    {
+     
+     
+      ;
+      for (; __first1 != __last1; ++__first1, (void)++__first2)
+ if (!bool(__binary_pred(*__first1, *__first2)))
+   return false;
+      return true;
+    }
+  template<typename _II1, typename _II2>
+    inline bool
+    __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
+    {
+      using _RATag = random_access_iterator_tag;
+      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
+      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
+      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
+      if (_RAIters())
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 != __d2)
+     return false;
+   return std::equal(__first1, __last1, __first2);
+ }
+      for (; __first1 != __last1 && __first2 != __last2;
+   ++__first1, (void)++__first2)
+ if (!(*__first1 == *__first2))
+   return false;
+      return __first1 == __last1 && __first2 == __last2;
+    }
+  template<typename _II1, typename _II2, typename _BinaryPredicate>
+    inline bool
+    __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2,
+      _BinaryPredicate __binary_pred)
+    {
+      using _RATag = random_access_iterator_tag;
+      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
+      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
+      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
+      if (_RAIters())
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 != __d2)
+     return false;
+   return std::equal(__first1, __last1, __first2,
+           __binary_pred);
+ }
+      for (; __first1 != __last1 && __first2 != __last2;
+   ++__first1, (void)++__first2)
+ if (!bool(__binary_pred(*__first1, *__first2)))
+   return false;
+      return __first1 == __last1 && __first2 == __last2;
+    }
+  template<typename _II1, typename _II2>
+    inline bool
+    equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
+    {
+     
+     
+     
+      ;
+      ;
+      return std::__equal4(__first1, __last1, __first2, __last2);
+    }
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    inline bool
+    equal(_IIter1 __first1, _IIter1 __last1,
+   _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
+    {
+     
+     
+      ;
+      ;
+      return std::__equal4(__first1, __last1, __first2, __last2,
+          __binary_pred);
+    }
+  template<typename _II1, typename _II2>
+    inline bool
+    lexicographical_compare(_II1 __first1, _II1 __last1,
+       _II2 __first2, _II2 __last2)
+    {
+     
+     
+     
+     
+      ;
+      ;
+      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
+      std::__niter_base(__last1),
+      std::__niter_base(__first2),
+      std::__niter_base(__last2));
+    }
+  template<typename _II1, typename _II2, typename _Compare>
+    inline bool
+    lexicographical_compare(_II1 __first1, _II1 __last1,
+       _II2 __first2, _II2 __last2, _Compare __comp)
+    {
+     
+     
+      ;
+      ;
+      return std::__lexicographical_compare_impl
+ (__first1, __last1, __first2, __last2,
+  __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    pair<_InputIterator1, _InputIterator2>
+    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _BinaryPredicate __binary_pred)
+    {
+      while (__first1 != __last1 && __binary_pred(__first1, __first2))
+ {
+   ++__first1;
+   ++__first2;
+ }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    }
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2)
+    {
+     
+     
+     
+      ;
+      return std::__mismatch(__first1, __last1, __first2,
+        __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
+    {
+     
+     
+      ;
+      return std::__mismatch(__first1, __last1, __first2,
+ __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    pair<_InputIterator1, _InputIterator2>
+    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _BinaryPredicate __binary_pred)
+    {
+      while (__first1 != __last1 && __first2 != __last2
+      && __binary_pred(__first1, __first2))
+ {
+   ++__first1;
+   ++__first2;
+ }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    }
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2)
+    {
+     
+     
+     
+      ;
+      ;
+      return std::__mismatch(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2,
+      _BinaryPredicate __binary_pred)
+    {
+     
+     
+      ;
+      ;
+      return std::__mismatch(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+
+
+}
+       
+typedef long unsigned int size_t;
+extern "C" {
+typedef _Complex float __cfloat128 __attribute__ ((__mode__ (__TC__)));
+typedef __float128 _Float128;
+typedef float _Float32;
+typedef double _Float64;
+typedef double _Float32x;
+typedef long double _Float64x;
+typedef struct
+  {
+    int quot;
+    int rem;
+  } div_t;
+typedef struct
+  {
+    long int quot;
+    long int rem;
+  } ldiv_t;
+__extension__ typedef struct
+  {
+    long long int quot;
+    long long int rem;
+  } lldiv_t;
+extern size_t __ctype_get_mb_cur_max (void) throw () ;
+extern double atof (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+extern int atoi (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+extern long int atol (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+__extension__ extern long long int atoll (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+extern double strtod (const char *__restrict __nptr,
+        char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern float strtof (const char *__restrict __nptr,
+       char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
+extern long double strtold (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern _Float32 strtof32 (const char *__restrict __nptr,
+     char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern _Float64 strtof64 (const char *__restrict __nptr,
+     char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern _Float128 strtof128 (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern _Float32x strtof32x (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern _Float64x strtof64x (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern long int strtol (const char *__restrict __nptr,
+   char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern unsigned long int strtoul (const char *__restrict __nptr,
+      char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+__extension__
+extern long long int strtoq (const char *__restrict __nptr,
+        char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+__extension__
+extern unsigned long long int strtouq (const char *__restrict __nptr,
+           char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+__extension__
+extern long long int strtoll (const char *__restrict __nptr,
+         char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+__extension__
+extern unsigned long long int strtoull (const char *__restrict __nptr,
+     char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int strfromd (char *__dest, size_t __size, const char *__format,
+       double __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int strfromf (char *__dest, size_t __size, const char *__format,
+       float __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int strfroml (char *__dest, size_t __size, const char *__format,
+       long double __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int strfromf32 (char *__dest, size_t __size, const char * __format,
+         _Float32 __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int strfromf64 (char *__dest, size_t __size, const char * __format,
+         _Float64 __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int strfromf128 (char *__dest, size_t __size, const char * __format,
+   _Float128 __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int strfromf32x (char *__dest, size_t __size, const char * __format,
+   _Float32x __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int strfromf64x (char *__dest, size_t __size, const char * __format,
+   _Float64x __f)
+     throw () __attribute__ ((__nonnull__ (3)));
+struct __locale_struct
+{
+  struct __locale_data *__locales[13];
+  const unsigned short int *__ctype_b;
+  const int *__ctype_tolower;
+  const int *__ctype_toupper;
+  const char *__names[13];
+};
+typedef struct __locale_struct *__locale_t;
+typedef __locale_t locale_t;
+extern long int strtol_l (const char *__restrict __nptr,
+     char **__restrict __endptr, int __base,
+     locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
+extern unsigned long int strtoul_l (const char *__restrict __nptr,
+        char **__restrict __endptr,
+        int __base, locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4)));
+__extension__
+extern long long int strtoll_l (const char *__restrict __nptr,
+    char **__restrict __endptr, int __base,
+    locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4)));
+__extension__
+extern unsigned long long int strtoull_l (const char *__restrict __nptr,
+       char **__restrict __endptr,
+       int __base, locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4)));
+extern double strtod_l (const char *__restrict __nptr,
+   char **__restrict __endptr, locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern float strtof_l (const char *__restrict __nptr,
+         char **__restrict __endptr, locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern long double strtold_l (const char *__restrict __nptr,
+         char **__restrict __endptr,
+         locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern _Float32 strtof32_l (const char *__restrict __nptr,
+       char **__restrict __endptr,
+       locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern _Float64 strtof64_l (const char *__restrict __nptr,
+       char **__restrict __endptr,
+       locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern _Float128 strtof128_l (const char *__restrict __nptr,
+         char **__restrict __endptr,
+         locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern _Float32x strtof32x_l (const char *__restrict __nptr,
+         char **__restrict __endptr,
+         locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern _Float64x strtof64x_l (const char *__restrict __nptr,
+         char **__restrict __endptr,
+         locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern char *l64a (long int __n) throw () ;
+extern long int a64l (const char *__s)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+extern "C" {
+typedef unsigned char __u_char;
+typedef unsigned short int __u_short;
+typedef unsigned int __u_int;
+typedef unsigned long int __u_long;
+typedef signed char __int8_t;
+typedef unsigned char __uint8_t;
+typedef signed short int __int16_t;
+typedef unsigned short int __uint16_t;
+typedef signed int __int32_t;
+typedef unsigned int __uint32_t;
+typedef signed long int __int64_t;
+typedef unsigned long int __uint64_t;
+typedef __int8_t __int_least8_t;
+typedef __uint8_t __uint_least8_t;
+typedef __int16_t __int_least16_t;
+typedef __uint16_t __uint_least16_t;
+typedef __int32_t __int_least32_t;
+typedef __uint32_t __uint_least32_t;
+typedef __int64_t __int_least64_t;
+typedef __uint64_t __uint_least64_t;
+typedef long int __quad_t;
+typedef unsigned long int __u_quad_t;
+typedef long int __intmax_t;
+typedef unsigned long int __uintmax_t;
+typedef unsigned long int __dev_t;
+typedef unsigned int __uid_t;
+typedef unsigned int __gid_t;
+typedef unsigned long int __ino_t;
+typedef unsigned long int __ino64_t;
+typedef unsigned int __mode_t;
+typedef unsigned long int __nlink_t;
+typedef long int __off_t;
+typedef long int __off64_t;
+typedef int __pid_t;
+typedef struct { int __val[2]; } __fsid_t;
+typedef long int __clock_t;
+typedef unsigned long int __rlim_t;
+typedef unsigned long int __rlim64_t;
+typedef unsigned int __id_t;
+typedef long int __time_t;
+typedef unsigned int __useconds_t;
+typedef long int __suseconds_t;
+typedef int __daddr_t;
+typedef int __key_t;
+typedef int __clockid_t;
+typedef void * __timer_t;
+typedef long int __blksize_t;
+typedef long int __blkcnt_t;
+typedef long int __blkcnt64_t;
+typedef unsigned long int __fsblkcnt_t;
+typedef unsigned long int __fsblkcnt64_t;
+typedef unsigned long int __fsfilcnt_t;
+typedef unsigned long int __fsfilcnt64_t;
+typedef long int __fsword_t;
+typedef long int __ssize_t;
+typedef long int __syscall_slong_t;
+typedef unsigned long int __syscall_ulong_t;
+typedef __off64_t __loff_t;
+typedef char *__caddr_t;
+typedef long int __intptr_t;
+typedef unsigned int __socklen_t;
+typedef int __sig_atomic_t;
+typedef __u_char u_char;
+typedef __u_short u_short;
+typedef __u_int u_int;
+typedef __u_long u_long;
+typedef __quad_t quad_t;
+typedef __u_quad_t u_quad_t;
+typedef __fsid_t fsid_t;
+typedef __loff_t loff_t;
+typedef __ino_t ino_t;
+typedef __ino64_t ino64_t;
+typedef __dev_t dev_t;
+typedef __gid_t gid_t;
+typedef __mode_t mode_t;
+typedef __nlink_t nlink_t;
+typedef __uid_t uid_t;
+typedef __off_t off_t;
+typedef __off64_t off64_t;
+typedef __pid_t pid_t;
+typedef __id_t id_t;
+typedef __ssize_t ssize_t;
+typedef __daddr_t daddr_t;
+typedef __caddr_t caddr_t;
+typedef __key_t key_t;
+typedef __clock_t clock_t;
+typedef __clockid_t clockid_t;
+typedef __time_t time_t;
+typedef __timer_t timer_t;
+typedef __useconds_t useconds_t;
+typedef __suseconds_t suseconds_t;
+typedef unsigned long int ulong;
+typedef unsigned short int ushort;
+typedef unsigned int uint;
+typedef __int8_t int8_t;
+typedef __int16_t int16_t;
+typedef __int32_t int32_t;
+typedef __int64_t int64_t;
+typedef __uint8_t u_int8_t;
+typedef __uint16_t u_int16_t;
+typedef __uint32_t u_int32_t;
+typedef __uint64_t u_int64_t;
+typedef int register_t __attribute__ ((__mode__ (__word__)));
+static __inline __uint16_t
+__bswap_16 (__uint16_t __bsx)
+{
+  return __builtin_bswap16 (__bsx);
+}
+static __inline __uint32_t
+__bswap_32 (__uint32_t __bsx)
+{
+  return __builtin_bswap32 (__bsx);
+}
+__extension__ static __inline __uint64_t
+__bswap_64 (__uint64_t __bsx)
+{
+  return __builtin_bswap64 (__bsx);
+}
+static __inline __uint16_t
+__uint16_identity (__uint16_t __x)
+{
+  return __x;
+}
+static __inline __uint32_t
+__uint32_identity (__uint32_t __x)
+{
+  return __x;
+}
+static __inline __uint64_t
+__uint64_identity (__uint64_t __x)
+{
+  return __x;
+}
+typedef struct
+{
+  unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
+} __sigset_t;
+typedef __sigset_t sigset_t;
+struct timeval
+{
+  __time_t tv_sec;
+  __suseconds_t tv_usec;
+};
+struct timespec
+{
+  __time_t tv_sec;
+  __syscall_slong_t tv_nsec;
+};
+typedef long int __fd_mask;
+typedef struct
+  {
+    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
+  } fd_set;
+typedef __fd_mask fd_mask;
+extern "C" {
+extern int select (int __nfds, fd_set *__restrict __readfds,
+     fd_set *__restrict __writefds,
+     fd_set *__restrict __exceptfds,
+     struct timeval *__restrict __timeout);
+extern int pselect (int __nfds, fd_set *__restrict __readfds,
+      fd_set *__restrict __writefds,
+      fd_set *__restrict __exceptfds,
+      const struct timespec *__restrict __timeout,
+      const __sigset_t *__restrict __sigmask);
+}
+typedef __blksize_t blksize_t;
+typedef __blkcnt_t blkcnt_t;
+typedef __fsblkcnt_t fsblkcnt_t;
+typedef __fsfilcnt_t fsfilcnt_t;
+typedef __blkcnt64_t blkcnt64_t;
+typedef __fsblkcnt64_t fsblkcnt64_t;
+typedef __fsfilcnt64_t fsfilcnt64_t;
+struct __pthread_rwlock_arch_t
+{
+  unsigned int __readers;
+  unsigned int __writers;
+  unsigned int __wrphase_futex;
+  unsigned int __writers_futex;
+  unsigned int __pad3;
+  unsigned int __pad4;
+  int __cur_writer;
+  int __shared;
+  signed char __rwelision;
+  unsigned char __pad1[7];
+  unsigned long int __pad2;
+  unsigned int __flags;
+};
+typedef struct __pthread_internal_list
+{
+  struct __pthread_internal_list *__prev;
+  struct __pthread_internal_list *__next;
+} __pthread_list_t;
+struct __pthread_mutex_s
+{
+  int __lock ;
+  unsigned int __count;
+  int __owner;
+  unsigned int __nusers;
+  int __kind;
+ 
+  short __spins; short __elision;
+  __pthread_list_t __list;
+ 
+};
+struct __pthread_cond_s
+{
+  __extension__ union
+  {
+    __extension__ unsigned long long int __wseq;
+    struct
+    {
+      unsigned int __low;
+      unsigned int __high;
+    } __wseq32;
+  };
+  __extension__ union
+  {
+    __extension__ unsigned long long int __g1_start;
+    struct
+    {
+      unsigned int __low;
+      unsigned int __high;
+    } __g1_start32;
+  };
+  unsigned int __glibc_unused___g_refs[2] ;
+  unsigned int __g_size[2];
+  unsigned int __g1_orig_size;
+  unsigned int __wrefs;
+  unsigned int __g_signals[2];
+};
+typedef unsigned long int pthread_t;
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_mutexattr_t;
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_condattr_t;
+typedef unsigned int pthread_key_t;
+typedef int pthread_once_t;
+union pthread_attr_t
+{
+  char __size[56];
+  long int __align;
+};
+typedef union pthread_attr_t pthread_attr_t;
+typedef union
+{
+  struct __pthread_mutex_s __data;
+  char __size[40];
+  long int __align;
+} pthread_mutex_t;
+typedef union
+{
+  struct __pthread_cond_s __data;
+  char __size[48];
+  __extension__ long long int __align;
+} pthread_cond_t;
+typedef union
+{
+  struct __pthread_rwlock_arch_t __data;
+  char __size[56];
+  long int __align;
+} pthread_rwlock_t;
+typedef union
+{
+  char __size[8];
+  long int __align;
+} pthread_rwlockattr_t;
+typedef volatile int pthread_spinlock_t;
+typedef union
+{
+  char __size[32];
+  long int __align;
+} pthread_barrier_t;
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_barrierattr_t;
+}
+extern long int random (void) throw ();
+extern void srandom (unsigned int __seed) throw ();
+extern char *initstate (unsigned int __seed, char *__statebuf,
+   size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
+extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
+struct random_data
+  {
+    int32_t *fptr;
+    int32_t *rptr;
+    int32_t *state;
+    int rand_type;
+    int rand_deg;
+    int rand_sep;
+    int32_t *end_ptr;
+  };
+extern int random_r (struct random_data *__restrict __buf,
+       int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int srandom_r (unsigned int __seed, struct random_data *__buf)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
+   size_t __statelen,
+   struct random_data *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (2, 4)));
+extern int setstate_r (char *__restrict __statebuf,
+         struct random_data *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int rand (void) throw ();
+extern void srand (unsigned int __seed) throw ();
+extern int rand_r (unsigned int *__seed) throw ();
+extern double drand48 (void) throw ();
+extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
+extern long int lrand48 (void) throw ();
+extern long int nrand48 (unsigned short int __xsubi[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+extern long int mrand48 (void) throw ();
+extern long int jrand48 (unsigned short int __xsubi[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+extern void srand48 (long int __seedval) throw ();
+extern unsigned short int *seed48 (unsigned short int __seed16v[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
+struct drand48_data
+  {
+    unsigned short int __x[3];
+    unsigned short int __old_x[3];
+    unsigned short int __c;
+    unsigned short int __init;
+    __extension__ unsigned long long int __a;
+  };
+extern int drand48_r (struct drand48_data *__restrict __buffer,
+        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int erand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int lrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int nrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int mrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int jrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int seed48_r (unsigned short int __seed16v[3],
+       struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int lcong48_r (unsigned short int __param[7],
+        struct drand48_data *__buffer)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
+extern void *calloc (size_t __nmemb, size_t __size)
+     throw () __attribute__ ((__malloc__)) ;
+extern void *realloc (void *__ptr, size_t __size)
+     throw () __attribute__ ((__warn_unused_result__));
+extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
+     throw () __attribute__ ((__warn_unused_result__));
+extern void free (void *__ptr) throw ();
+extern "C" {
+extern void *alloca (size_t __size) throw ();
+}
+extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
+extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+extern void *aligned_alloc (size_t __alignment, size_t __size)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
+extern void abort (void) throw () __attribute__ ((__noreturn__));
+extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
+extern "C++" int at_quick_exit (void (*__func) (void))
+     throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
+extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern void exit (int __status) throw () __attribute__ ((__noreturn__));
+extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
+extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
+extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
+extern char *secure_getenv (const char *__name)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
+extern int setenv (const char *__name, const char *__value, int __replace)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
+extern int clearenv (void) throw ();
+extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
+extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
+extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
+extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
+extern int mkstemps64 (char *__template, int __suffixlen)
+     __attribute__ ((__nonnull__ (1))) ;
+extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
+extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
+extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
+extern int mkostemps (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) ;
+extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) ;
+extern int system (const char *__command) ;
+extern char *canonicalize_file_name (const char *__name)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+extern char *realpath (const char *__restrict __name,
+         char *__restrict __resolved) throw () ;
+typedef int (*__compar_fn_t) (const void *, const void *);
+typedef __compar_fn_t comparison_fn_t;
+typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
+extern void *bsearch (const void *__key, const void *__base,
+        size_t __nmemb, size_t __size, __compar_fn_t __compar)
+     __attribute__ ((__nonnull__ (1, 2, 5))) ;
+extern void qsort (void *__base, size_t __nmemb, size_t __size,
+     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
+extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
+       __compar_d_fn_t __compar, void *__arg)
+  __attribute__ ((__nonnull__ (1, 4)));
+extern int abs (int __x) throw () __attribute__ ((__const__)) ;
+extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
+__extension__ extern long long int llabs (long long int __x)
+     throw () __attribute__ ((__const__)) ;
+extern div_t div (int __numer, int __denom)
+     throw () __attribute__ ((__const__)) ;
+extern ldiv_t ldiv (long int __numer, long int __denom)
+     throw () __attribute__ ((__const__)) ;
+__extension__ extern lldiv_t lldiv (long long int __numer,
+        long long int __denom)
+     throw () __attribute__ ((__const__)) ;
+extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *gcvt (double __value, int __ndigit, char *__buf)
+     throw () __attribute__ ((__nonnull__ (3))) ;
+extern char *qecvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     throw () __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *qfcvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     throw () __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *qgcvt (long double __value, int __ndigit, char *__buf)
+     throw () __attribute__ ((__nonnull__ (3))) ;
+extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int qecvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int qfcvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int mblen (const char *__s, size_t __n) throw ();
+extern int mbtowc (wchar_t *__restrict __pwc,
+     const char *__restrict __s, size_t __n) throw ();
+extern int wctomb (char *__s, wchar_t __wchar) throw ();
+extern size_t mbstowcs (wchar_t *__restrict __pwcs,
+   const char *__restrict __s, size_t __n) throw ();
+extern size_t wcstombs (char *__restrict __s,
+   const wchar_t *__restrict __pwcs, size_t __n)
+     throw ();
+extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
+extern int getsubopt (char **__restrict __optionp,
+        char *const *__restrict __tokens,
+        char **__restrict __valuep)
+     throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
+extern int posix_openpt (int __oflag) ;
+extern int grantpt (int __fd) throw ();
+extern int unlockpt (int __fd) throw ();
+extern char *ptsname (int __fd) throw () ;
+extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int getpt (void);
+extern int getloadavg (double __loadavg[], int __nelem)
+     throw () __attribute__ ((__nonnull__ (1)));
+}
+       
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  using ::abs;
+  inline long
+  abs(long __i) { return __builtin_labs(__i); }
+  inline long long
+  abs(long long __x) { return __builtin_llabs (__x); }
+  inline constexpr double
+  abs(double __x)
+  { return __builtin_fabs(__x); }
+  inline constexpr float
+  abs(float __x)
+  { return __builtin_fabsf(__x); }
+  inline constexpr long double
+  abs(long double __x)
+  { return __builtin_fabsl(__x); }
+
+}
+}
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  using ::div_t;
+  using ::ldiv_t;
+  using ::abort;
+  using ::aligned_alloc;
+  using ::atexit;
+  using ::at_quick_exit;
+  using ::atof;
+  using ::atoi;
+  using ::atol;
+  using ::bsearch;
+  using ::calloc;
+  using ::div;
+  using ::exit;
+  using ::free;
+  using ::getenv;
+  using ::labs;
+  using ::ldiv;
+  using ::malloc;
+  using ::mblen;
+  using ::mbstowcs;
+  using ::mbtowc;
+  using ::qsort;
+  using ::quick_exit;
+  using ::rand;
+  using ::realloc;
+  using ::srand;
+  using ::strtod;
+  using ::strtol;
+  using ::strtoul;
+  using ::system;
+  using ::wcstombs;
+  using ::wctomb;
+  inline ldiv_t
+  div(long __i, long __j) { return ldiv(__i, __j); }
+
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+  using ::lldiv_t;
+  using ::_Exit;
+  using ::llabs;
+  inline lldiv_t
+  div(long long __n, long long __d)
+  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
+  using ::lldiv;
+  using ::atoll;
+  using ::strtoll;
+  using ::strtoull;
+  using ::strtof;
+  using ::strtold;
+
+}
+namespace std
+{
+  using ::__gnu_cxx::lldiv_t;
+  using ::__gnu_cxx::_Exit;
+  using ::__gnu_cxx::llabs;
+  using ::__gnu_cxx::div;
+  using ::__gnu_cxx::lldiv;
+  using ::__gnu_cxx::atoll;
+  using ::__gnu_cxx::strtof;
+  using ::__gnu_cxx::strtoll;
+  using ::__gnu_cxx::strtoull;
+  using ::__gnu_cxx::strtold;
+}
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _IIter, typename _Predicate>
+    bool
+    all_of(_IIter, _IIter, _Predicate);
+  template<typename _IIter, typename _Predicate>
+    bool
+    any_of(_IIter, _IIter, _Predicate);
+  template<typename _FIter, typename _Tp>
+    bool
+    binary_search(_FIter, _FIter, const _Tp&);
+  template<typename _FIter, typename _Tp, typename _Compare>
+    bool
+    binary_search(_FIter, _FIter, const _Tp&, _Compare);
+  template<typename _Tp>
+    constexpr
+    const _Tp&
+    clamp(const _Tp&, const _Tp&, const _Tp&);
+  template<typename _Tp, typename _Compare>
+    constexpr
+    const _Tp&
+    clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);
+  template<typename _IIter, typename _OIter>
+    _OIter
+    copy(_IIter, _IIter, _OIter);
+  template<typename _BIter1, typename _BIter2>
+    _BIter2
+    copy_backward(_BIter1, _BIter1, _BIter2);
+  template<typename _IIter, typename _OIter, typename _Predicate>
+    _OIter
+    copy_if(_IIter, _IIter, _OIter, _Predicate);
+  template<typename _IIter, typename _Size, typename _OIter>
+    _OIter
+    copy_n(_IIter, _Size, _OIter);
+  template<typename _FIter, typename _Tp>
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&);
+  template<typename _FIter, typename _Tp, typename _Compare>
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&, _Compare);
+  template<typename _FIter, typename _Tp>
+    void
+    fill(_FIter, _FIter, const _Tp&);
+  template<typename _OIter, typename _Size, typename _Tp>
+    _OIter
+    fill_n(_OIter, _Size, const _Tp&);
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2);
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+  template<typename _IIter, typename _Predicate>
+    _IIter
+    find_if_not(_IIter, _IIter, _Predicate);
+  template<typename _IIter1, typename _IIter2>
+    bool
+    includes(_IIter1, _IIter1, _IIter2, _IIter2);
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+    bool
+    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+  template<typename _BIter>
+    void
+    inplace_merge(_BIter, _BIter, _BIter);
+  template<typename _BIter, typename _Compare>
+    void
+    inplace_merge(_BIter, _BIter, _BIter, _Compare);
+  template<typename _RAIter>
+    bool
+    is_heap(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    bool
+    is_heap(_RAIter, _RAIter, _Compare);
+  template<typename _RAIter>
+    _RAIter
+    is_heap_until(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    _RAIter
+    is_heap_until(_RAIter, _RAIter, _Compare);
+  template<typename _IIter, typename _Predicate>
+    bool
+    is_partitioned(_IIter, _IIter, _Predicate);
+  template<typename _FIter1, typename _FIter2>
+    bool
+    is_permutation(_FIter1, _FIter1, _FIter2);
+  template<typename _FIter1, typename _FIter2,
+    typename _BinaryPredicate>
+    bool
+    is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
+  template<typename _FIter>
+    bool
+    is_sorted(_FIter, _FIter);
+  template<typename _FIter, typename _Compare>
+    bool
+    is_sorted(_FIter, _FIter, _Compare);
+  template<typename _FIter>
+    _FIter
+    is_sorted_until(_FIter, _FIter);
+  template<typename _FIter, typename _Compare>
+    _FIter
+    is_sorted_until(_FIter, _FIter, _Compare);
+  template<typename _FIter1, typename _FIter2>
+    void
+    iter_swap(_FIter1, _FIter2);
+  template<typename _FIter, typename _Tp>
+    _FIter
+    lower_bound(_FIter, _FIter, const _Tp&);
+  template<typename _FIter, typename _Tp, typename _Compare>
+    _FIter
+    lower_bound(_FIter, _FIter, const _Tp&, _Compare);
+  template<typename _RAIter>
+    void
+    make_heap(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    make_heap(_RAIter, _RAIter, _Compare);
+  template<typename _Tp>
+    constexpr
+    const _Tp&
+    max(const _Tp&, const _Tp&);
+  template<typename _Tp, typename _Compare>
+    constexpr
+    const _Tp&
+    max(const _Tp&, const _Tp&, _Compare);
+  template<typename _Tp>
+    constexpr
+    const _Tp&
+    min(const _Tp&, const _Tp&);
+  template<typename _Tp, typename _Compare>
+    constexpr
+    const _Tp&
+    min(const _Tp&, const _Tp&, _Compare);
+  template<typename _Tp>
+    constexpr
+    pair<const _Tp&, const _Tp&>
+    minmax(const _Tp&, const _Tp&);
+  template<typename _Tp, typename _Compare>
+    constexpr
+    pair<const _Tp&, const _Tp&>
+    minmax(const _Tp&, const _Tp&, _Compare);
+  template<typename _FIter>
+    constexpr
+    pair<_FIter, _FIter>
+    minmax_element(_FIter, _FIter);
+  template<typename _FIter, typename _Compare>
+    constexpr
+    pair<_FIter, _FIter>
+    minmax_element(_FIter, _FIter, _Compare);
+  template<typename _Tp>
+    constexpr
+    _Tp
+    min(initializer_list<_Tp>);
+  template<typename _Tp, typename _Compare>
+    constexpr
+    _Tp
+    min(initializer_list<_Tp>, _Compare);
+  template<typename _Tp>
+    constexpr
+    _Tp
+    max(initializer_list<_Tp>);
+  template<typename _Tp, typename _Compare>
+    constexpr
+    _Tp
+    max(initializer_list<_Tp>, _Compare);
+  template<typename _Tp>
+    constexpr
+    pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp>);
+  template<typename _Tp, typename _Compare>
+    constexpr
+    pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp>, _Compare);
+  template<typename _BIter>
+    bool
+    next_permutation(_BIter, _BIter);
+  template<typename _BIter, typename _Compare>
+    bool
+    next_permutation(_BIter, _BIter, _Compare);
+  template<typename _IIter, typename _Predicate>
+    bool
+    none_of(_IIter, _IIter, _Predicate);
+  template<typename _IIter, typename _RAIter>
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
+  template<typename _IIter, typename _RAIter, typename _Compare>
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
+  template<typename _IIter, typename _OIter1,
+    typename _OIter2, typename _Predicate>
+    pair<_OIter1, _OIter2>
+    partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
+  template<typename _FIter, typename _Predicate>
+    _FIter
+    partition_point(_FIter, _FIter, _Predicate);
+  template<typename _RAIter>
+    void
+    pop_heap(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    pop_heap(_RAIter, _RAIter, _Compare);
+  template<typename _BIter>
+    bool
+    prev_permutation(_BIter, _BIter);
+  template<typename _BIter, typename _Compare>
+    bool
+    prev_permutation(_BIter, _BIter, _Compare);
+  template<typename _RAIter>
+    void
+    push_heap(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    push_heap(_RAIter, _RAIter, _Compare);
+  template<typename _FIter, typename _Tp>
+    _FIter
+    remove(_FIter, _FIter, const _Tp&);
+  template<typename _FIter, typename _Predicate>
+    _FIter
+    remove_if(_FIter, _FIter, _Predicate);
+  template<typename _IIter, typename _OIter, typename _Tp>
+    _OIter
+    remove_copy(_IIter, _IIter, _OIter, const _Tp&);
+  template<typename _IIter, typename _OIter, typename _Predicate>
+    _OIter
+    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
+  template<typename _IIter, typename _OIter, typename _Tp>
+    _OIter
+    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
+  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
+    _OIter
+    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
+  template<typename _BIter>
+    void
+    reverse(_BIter, _BIter);
+  template<typename _BIter, typename _OIter>
+    _OIter
+    reverse_copy(_BIter, _BIter, _OIter);
+  inline namespace _V2
+  {
+    template<typename _FIter>
+      _FIter
+      rotate(_FIter, _FIter, _FIter);
+  }
+  template<typename _FIter, typename _OIter>
+    _OIter
+    rotate_copy(_FIter, _FIter, _FIter, _OIter);
+  template<typename _RAIter, typename _UGenerator>
+    void
+    shuffle(_RAIter, _RAIter, _UGenerator&&);
+  template<typename _RAIter>
+    void
+    sort_heap(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    sort_heap(_RAIter, _RAIter, _Compare);
+  template<typename _BIter, typename _Predicate>
+    _BIter
+    stable_partition(_BIter, _BIter, _Predicate);
+  template<typename _FIter1, typename _FIter2>
+    _FIter2
+    swap_ranges(_FIter1, _FIter1, _FIter2);
+  template<typename _FIter>
+    _FIter
+    unique(_FIter, _FIter);
+  template<typename _FIter, typename _BinaryPredicate>
+    _FIter
+    unique(_FIter, _FIter, _BinaryPredicate);
+  template<typename _FIter, typename _Tp>
+    _FIter
+    upper_bound(_FIter, _FIter, const _Tp&);
+  template<typename _FIter, typename _Tp, typename _Compare>
+    _FIter
+    upper_bound(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _FIter>
+    _FIter
+    adjacent_find(_FIter, _FIter);
+  template<typename _FIter, typename _BinaryPredicate>
+    _FIter
+    adjacent_find(_FIter, _FIter, _BinaryPredicate);
+  template<typename _IIter, typename _Tp>
+    typename iterator_traits<_IIter>::difference_type
+    count(_IIter, _IIter, const _Tp&);
+  template<typename _IIter, typename _Predicate>
+    typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter, _IIter, _Predicate);
+  template<typename _IIter1, typename _IIter2>
+    bool
+    equal(_IIter1, _IIter1, _IIter2);
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    bool
+    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+  template<typename _IIter, typename _Tp>
+    _IIter
+    find(_IIter, _IIter, const _Tp&);
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+  template<typename _IIter, typename _Predicate>
+    _IIter
+    find_if(_IIter, _IIter, _Predicate);
+  template<typename _IIter, typename _Funct>
+    _Funct
+    for_each(_IIter, _IIter, _Funct);
+  template<typename _FIter, typename _Generator>
+    void
+    generate(_FIter, _FIter, _Generator);
+  template<typename _OIter, typename _Size, typename _Generator>
+    _OIter
+    generate_n(_OIter, _Size, _Generator);
+  template<typename _IIter1, typename _IIter2>
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+  template<typename _FIter>
+    constexpr
+    _FIter
+    max_element(_FIter, _FIter);
+  template<typename _FIter, typename _Compare>
+    constexpr
+    _FIter
+    max_element(_FIter, _FIter, _Compare);
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+  template<typename _FIter>
+    constexpr
+    _FIter
+    min_element(_FIter, _FIter);
+  template<typename _FIter, typename _Compare>
+    constexpr
+    _FIter
+    min_element(_FIter, _FIter, _Compare);
+  template<typename _IIter1, typename _IIter2>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2);
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+  template<typename _RAIter>
+    void
+    nth_element(_RAIter, _RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
+  template<typename _RAIter>
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
+  template<typename _BIter, typename _Predicate>
+    _BIter
+    partition(_BIter, _BIter, _Predicate);
+  template<typename _RAIter>
+    void
+    random_shuffle(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Generator>
+    void
+    random_shuffle(_RAIter, _RAIter,
+     _Generator&&);
+  template<typename _FIter, typename _Tp>
+    void
+    replace(_FIter, _FIter, const _Tp&, const _Tp&);
+  template<typename _FIter, typename _Predicate, typename _Tp>
+    void
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2);
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+  template<typename _FIter, typename _Size, typename _Tp>
+    _FIter
+    search_n(_FIter, _FIter, _Size, const _Tp&);
+  template<typename _FIter, typename _Size, typename _Tp,
+    typename _BinaryPredicate>
+    _FIter
+    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
+        _OIter, _Compare);
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+  template<typename _RAIter>
+    void
+    sort(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    sort(_RAIter, _RAIter, _Compare);
+  template<typename _RAIter>
+    void
+    stable_sort(_RAIter, _RAIter);
+  template<typename _RAIter, typename _Compare>
+    void
+    stable_sort(_RAIter, _RAIter, _Compare);
+  template<typename _IIter, typename _OIter, typename _UnaryOperation>
+    _OIter
+    transform(_IIter, _IIter, _OIter, _UnaryOperation);
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _BinaryOperation>
+    _OIter
+    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
+  template<typename _IIter, typename _OIter>
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter);
+  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
+
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Compare>
+    _Distance
+    __is_heap_until(_RandomAccessIterator __first, _Distance __n,
+      _Compare& __comp)
+    {
+      _Distance __parent = 0;
+      for (_Distance __child = 1; __child < __n; ++__child)
+ {
+   if (__comp(__first + __parent, __first + __child))
+     return __child;
+   if ((__child & 1) == 0)
+     ++__parent;
+ }
+      return __n;
+    }
+  template<typename _RandomAccessIterator, typename _Distance>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _Distance __n)
+    {
+      __gnu_cxx::__ops::_Iter_less_iter __comp;
+      return std::__is_heap_until(__first, __n, __comp) == __n;
+    }
+  template<typename _RandomAccessIterator, typename _Compare,
+    typename _Distance>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
+    {
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      return std::__is_heap_until(__first, __n, __cmp) == __n;
+    }
+  template<typename _RandomAccessIterator>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    { return std::__is_heap(__first, std::distance(__first, __last)); }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+      return std::__is_heap(__first, std::move(__comp),
+       std::distance(__first, __last));
+    }
+  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
+    typename _Compare>
+    void
+    __push_heap(_RandomAccessIterator __first,
+  _Distance __holeIndex, _Distance __topIndex, _Tp __value,
+  _Compare& __comp)
+    {
+      _Distance __parent = (__holeIndex - 1) / 2;
+      while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
+ {
+   *(__first + __holeIndex) = std::move(*(__first + __parent));
+   __holeIndex = __parent;
+   __parent = (__holeIndex - 1) / 2;
+ }
+      *(__first + __holeIndex) = std::move(__value);
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+     
+     
+      ;
+      ;
+      ;
+      __gnu_cxx::__ops::_Iter_less_val __comp;
+      _ValueType __value = std::move(*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+         _DistanceType(0), std::move(__value), __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+     
+      ;
+      ;
+      ;
+      __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
+ __cmp(std::move(__comp));
+      _ValueType __value = std::move(*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+         _DistanceType(0), std::move(__value), __cmp);
+    }
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Tp, typename _Compare>
+    void
+    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+    _Distance __len, _Tp __value, _Compare __comp)
+    {
+      const _Distance __topIndex = __holeIndex;
+      _Distance __secondChild = __holeIndex;
+      while (__secondChild < (__len - 1) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   if (__comp(__first + __secondChild,
+       __first + (__secondChild - 1)))
+     __secondChild--;
+   *(__first + __holeIndex) = std::move(*(__first + __secondChild));
+   __holeIndex = __secondChild;
+ }
+      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)));
+   __holeIndex = __secondChild - 1;
+ }
+      __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
+ __cmp(std::move(__comp));
+      std::__push_heap(__first, __holeIndex, __topIndex,
+         std::move(__value), __cmp);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+        _RandomAccessIterator __result, _Compare& __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+      _ValueType __value = std::move(*__result);
+      *__result = std::move(*__first);
+      std::__adjust_heap(__first, _DistanceType(0),
+    _DistanceType(__last - __first),
+    std::move(__value), __comp);
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+     
+     
+      ;
+      ;
+      ;
+      ;
+      if (__last - __first > 1)
+ {
+   --__last;
+   __gnu_cxx::__ops::_Iter_less_iter __comp;
+   std::__pop_heap(__first, __last, __last, __comp);
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    pop_heap(_RandomAccessIterator __first,
+      _RandomAccessIterator __last, _Compare __comp)
+    {
+     
+      ;
+      ;
+      ;
+      ;
+      if (__last - __first > 1)
+ {
+   typedef __decltype(__comp) _Cmp;
+   __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+   --__last;
+   std::__pop_heap(__first, __last, __last, __cmp);
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare& __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+      if (__last - __first < 2)
+ return;
+      const _DistanceType __len = __last - __first;
+      _DistanceType __parent = (__len - 2) / 2;
+      while (true)
+ {
+   _ValueType __value = std::move(*(__first + __parent));
+   std::__adjust_heap(__first, __parent, __len, std::move(__value),
+        __comp);
+   if (__parent == 0)
+     return;
+   __parent--;
+ }
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+     
+     
+      ;
+      ;
+      __gnu_cxx::__ops::_Iter_less_iter __comp;
+      std::__make_heap(__first, __last, __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+     
+      ;
+      ;
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      std::__make_heap(__first, __last, __cmp);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare& __comp)
+    {
+      while (__last - __first > 1)
+ {
+   --__last;
+   std::__pop_heap(__first, __last, __last, __comp);
+ }
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+     
+     
+      ;
+      ;
+      ;
+      __gnu_cxx::__ops::_Iter_less_iter __comp;
+      std::__sort_heap(__first, __last, __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+     
+      ;
+      ;
+      ;
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      std::__sort_heap(__first, __last, __cmp);
+    }
+  template<typename _RandomAccessIterator>
+    inline _RandomAccessIterator
+    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+     
+     
+      ;
+      ;
+      __gnu_cxx::__ops::_Iter_less_iter __comp;
+      return __first +
+ std::__is_heap_until(__first, std::distance(__first, __last), __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline _RandomAccessIterator
+    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    _Compare __comp)
+    {
+     
+      ;
+      ;
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      return __first
+ + std::__is_heap_until(__first, std::distance(__first, __last), __cmp);
+    }
+  template<typename _RandomAccessIterator>
+    inline bool
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    { return std::is_heap_until(__first, __last) == __last; }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline bool
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+     _Compare __comp)
+    {
+     
+      ;
+      ;
+      const auto __dist = std::distance(__first, __last);
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      return std::__is_heap_until(__first, __dist, __cmp) == __dist;
+    }
+
+}
+       
+       
+#pragma GCC visibility push(default)
+       
+#pragma GCC visibility push(default)
+extern "C++" {
+namespace std
+{
+  class exception
+  {
+  public:
+    exception() noexcept { }
+    virtual ~exception() noexcept;
+    virtual const char*
+    what() const noexcept;
+  };
+}
+}
+#pragma GCC visibility pop
+extern "C++" {
+namespace std
+{
+  class bad_exception : public exception
+  {
+  public:
+    bad_exception() noexcept { }
+    virtual ~bad_exception() noexcept;
+    virtual const char*
+    what() const noexcept;
+  };
+  typedef void (*terminate_handler) ();
+  typedef void (*unexpected_handler) ();
+  terminate_handler set_terminate(terminate_handler) noexcept;
+  terminate_handler get_terminate() noexcept;
+  void terminate() noexcept __attribute__ ((__noreturn__));
+  unexpected_handler set_unexpected(unexpected_handler) noexcept;
+  unexpected_handler get_unexpected() noexcept;
+  void unexpected() __attribute__ ((__noreturn__));
+  [[__deprecated__]]
+  bool uncaught_exception() noexcept __attribute__ ((__pure__));
+  int uncaught_exceptions() noexcept __attribute__ ((__pure__));
+}
+namespace __gnu_cxx
+{
+
+  void __verbose_terminate_handler();
+
+}
+}
+#pragma GCC visibility pop
+#pragma GCC visibility push(default)
+       
+#pragma GCC visibility push(default)
+typedef long int ptrdiff_t;
+typedef struct {
+  long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
+  long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
+} max_align_t;
+  typedef decltype(nullptr) nullptr_t;
+namespace std
+{
+  class type_info;
+}
+namespace __cxxabiv1
+{
+  struct __cxa_refcounted_exception;
+  extern "C"
+    {
+      void*
+      __cxa_allocate_exception(size_t) noexcept;
+      void
+      __cxa_free_exception(void*) noexcept;
+      __cxa_refcounted_exception*
+      __cxa_init_primary_exception(void *object, std::type_info *tinfo,
+                void ( *dest) (void *)) noexcept;
+    }
+}
+#pragma GCC visibility pop
+       
+       
+namespace std
+{
+
+  size_t
+  _Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
+  size_t
+  _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
+
+}
+#pragma GCC visibility push(default)
+extern "C++" {
+namespace __cxxabiv1
+{
+  class __class_type_info;
+}
+namespace std
+{
+  class type_info
+  {
+  public:
+    virtual ~type_info();
+    const char* name() const noexcept
+    { return __name[0] == '*' ? __name + 1 : __name; }
+    bool before(const type_info& __arg) const noexcept
+    { return (__name[0] == '*' && __arg.__name[0] == '*')
+ ? __name < __arg.__name
+ : __builtin_strcmp (__name, __arg.__name) < 0; }
+    bool operator==(const type_info& __arg) const noexcept
+    {
+      return ((__name == __arg.__name)
+       || (__name[0] != '*' &&
+    __builtin_strcmp (__name, __arg.__name) == 0));
+    }
+    bool operator!=(const type_info& __arg) const noexcept
+    { return !operator==(__arg); }
+    size_t hash_code() const noexcept
+    {
+      return _Hash_bytes(name(), __builtin_strlen(name()),
+    static_cast<size_t>(0xc70f6907UL));
+    }
+    virtual bool __is_pointer_p() const;
+    virtual bool __is_function_p() const;
+    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
+       unsigned __outer) const;
+    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
+        void **__obj_ptr) const;
+  protected:
+    const char *__name;
+    explicit type_info(const char *__n): __name(__n) { }
+  private:
+    type_info& operator=(const type_info&);
+    type_info(const type_info&);
+  };
+  class bad_cast : public exception
+  {
+  public:
+    bad_cast() noexcept { }
+    virtual ~bad_cast() noexcept;
+    virtual const char* what() const noexcept;
+  };
+  class bad_typeid : public exception
+  {
+  public:
+    bad_typeid () noexcept { }
+    virtual ~bad_typeid() noexcept;
+    virtual const char* what() const noexcept;
+  };
+}
+}
+#pragma GCC visibility pop
+extern "C++" {
+namespace std
+{
+  class type_info;
+  namespace __exception_ptr
+  {
+    class exception_ptr;
+  }
+  using __exception_ptr::exception_ptr;
+  exception_ptr current_exception() noexcept;
+  template<typename _Ex>
+  exception_ptr make_exception_ptr(_Ex) noexcept;
+  void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
+  namespace __exception_ptr
+  {
+    using std::rethrow_exception;
+    class exception_ptr
+    {
+      void* _M_exception_object;
+      explicit exception_ptr(void* __e) noexcept;
+      void _M_addref() noexcept;
+      void _M_release() noexcept;
+      void *_M_get() const noexcept __attribute__ ((__pure__));
+      friend exception_ptr std::current_exception() noexcept;
+      friend void std::rethrow_exception(exception_ptr);
+      template<typename _Ex>
+      friend exception_ptr std::make_exception_ptr(_Ex) noexcept;
+    public:
+      exception_ptr() noexcept;
+      exception_ptr(const exception_ptr&) noexcept;
+      exception_ptr(nullptr_t) noexcept
+      : _M_exception_object(0)
+      { }
+      exception_ptr(exception_ptr&& __o) noexcept
+      : _M_exception_object(__o._M_exception_object)
+      { __o._M_exception_object = 0; }
+      exception_ptr&
+      operator=(const exception_ptr&) noexcept;
+      exception_ptr&
+      operator=(exception_ptr&& __o) noexcept
+      {
+        exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
+        return *this;
+      }
+      ~exception_ptr() noexcept;
+      void
+      swap(exception_ptr&) noexcept;
+      explicit operator bool() const
+      { return _M_exception_object; }
+      friend bool
+      operator==(const exception_ptr&, const exception_ptr&)
+ noexcept __attribute__ ((__pure__));
+      const class std::type_info*
+      __cxa_exception_type() const noexcept
+ __attribute__ ((__pure__));
+    };
+    bool
+    operator==(const exception_ptr&, const exception_ptr&)
+      noexcept __attribute__ ((__pure__));
+    bool
+    operator!=(const exception_ptr&, const exception_ptr&)
+      noexcept __attribute__ ((__pure__));
+    inline void
+    swap(exception_ptr& __lhs, exception_ptr& __rhs)
+    { __lhs.swap(__rhs); }
+    template<typename _Ex>
+      inline void
+      __dest_thunk(void* __x)
+      { static_cast<_Ex*>(__x)->~_Ex(); }
+  }
+  template<typename _Ex>
+    exception_ptr
+    make_exception_ptr(_Ex __ex) noexcept
+    {
+      void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex));
+      (void) __cxxabiv1::__cxa_init_primary_exception(
+   __e, const_cast<std::type_info*>(&typeid(__ex)),
+   __exception_ptr::__dest_thunk<_Ex>);
+      try
+ {
+          ::new (__e) _Ex(__ex);
+          return exception_ptr(__e);
+ }
+      catch(...)
+ {
+   __cxxabiv1::__cxa_free_exception(__e);
+   return current_exception();
+ }
+    }
+}
+}
+#pragma GCC visibility pop
+#pragma GCC visibility push(default)
+extern "C++" {
+namespace std
+{
+  class nested_exception
+  {
+    exception_ptr _M_ptr;
+  public:
+    nested_exception() noexcept : _M_ptr(current_exception()) { }
+    nested_exception(const nested_exception&) noexcept = default;
+    nested_exception& operator=(const nested_exception&) noexcept = default;
+    virtual ~nested_exception() noexcept;
+    [[noreturn]]
+    void
+    rethrow_nested() const
+    {
+      if (_M_ptr)
+ rethrow_exception(_M_ptr);
+      std::terminate();
+    }
+    exception_ptr
+    nested_ptr() const noexcept
+    { return _M_ptr; }
+  };
+  template<typename _Except>
+    struct _Nested_exception : public _Except, public nested_exception
+    {
+      explicit _Nested_exception(const _Except& __ex)
+      : _Except(__ex)
+      { }
+      explicit _Nested_exception(_Except&& __ex)
+      : _Except(static_cast<_Except&&>(__ex))
+      { }
+    };
+  template<typename _Tp>
+    [[noreturn]]
+    inline void
+    __throw_with_nested_impl(_Tp&& __t, true_type)
+    {
+      using _Up = typename remove_reference<_Tp>::type;
+      throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
+    }
+  template<typename _Tp>
+    [[noreturn]]
+    inline void
+    __throw_with_nested_impl(_Tp&& __t, false_type)
+    { throw std::forward<_Tp>(__t); }
+  template<typename _Tp>
+    [[noreturn]]
+    inline void
+    throw_with_nested(_Tp&& __t)
+    {
+      using _Up = typename decay<_Tp>::type;
+      using _CopyConstructible
+ = __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
+      static_assert(_CopyConstructible::value,
+   "throw_with_nested argument must be CopyConstructible");
+      using __nest = __and_<is_class<_Up>, __bool_constant<!__is_final(_Up)>,
+       __not_<is_base_of<nested_exception, _Up>>>;
+      std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{});
+    }
+  template<typename _Tp>
+    using __rethrow_if_nested_cond = typename enable_if<
+      __and_<is_polymorphic<_Tp>,
+      __or_<__not_<is_base_of<nested_exception, _Tp>>,
+     is_convertible<_Tp*, nested_exception*>>>::value
+    >::type;
+  template<typename _Ex>
+    inline __rethrow_if_nested_cond<_Ex>
+    __rethrow_if_nested_impl(const _Ex* __ptr)
+    {
+      if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))
+ __ne_ptr->rethrow_nested();
+    }
+  inline void
+  __rethrow_if_nested_impl(const void*)
+  { }
+  template<typename _Ex>
+    inline void
+    rethrow_if_nested(const _Ex& __ex)
+    { std::__rethrow_if_nested_impl(std::__addressof(__ex)); }
+}
+}
+#pragma GCC visibility pop
+#pragma GCC visibility push(default)
+extern "C++" {
+namespace std
+{
+  class bad_alloc : public exception
+  {
+  public:
+    bad_alloc() throw() { }
+    virtual ~bad_alloc() throw();
+    virtual const char* what() const throw();
+  };
+  class bad_array_new_length : public bad_alloc
+  {
+  public:
+    bad_array_new_length() throw() { }
+    virtual ~bad_array_new_length() throw();
+    virtual const char* what() const throw();
+  };
+  enum class align_val_t: size_t {};
+  struct nothrow_t
+  {
+    explicit nothrow_t() = default;
+  };
+  extern const nothrow_t nothrow;
+  typedef void (*new_handler)();
+  new_handler set_new_handler(new_handler) throw();
+  new_handler get_new_handler() noexcept;
+}
+void* operator new(std::size_t)
+  __attribute__((__externally_visible__));
+void* operator new[](std::size_t)
+  __attribute__((__externally_visible__));
+void operator delete(void*) noexcept
+  __attribute__((__externally_visible__));
+void operator delete[](void*) noexcept
+  __attribute__((__externally_visible__));
+void operator delete(void*, std::size_t) noexcept
+  __attribute__((__externally_visible__));
+void operator delete[](void*, std::size_t) noexcept
+  __attribute__((__externally_visible__));
+void* operator new(std::size_t, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__));
+void* operator new[](std::size_t, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__));
+void operator delete(void*, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__));
+void operator delete[](void*, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__));
+void* operator new(std::size_t, std::align_val_t)
+  __attribute__((__externally_visible__));
+void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&)
+  noexcept __attribute__((__externally_visible__));
+void operator delete(void*, std::align_val_t)
+  noexcept __attribute__((__externally_visible__));
+void operator delete(void*, std::align_val_t, const std::nothrow_t&)
+  noexcept __attribute__((__externally_visible__));
+void* operator new[](std::size_t, std::align_val_t)
+  __attribute__((__externally_visible__));
+void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&)
+  noexcept __attribute__((__externally_visible__));
+void operator delete[](void*, std::align_val_t)
+  noexcept __attribute__((__externally_visible__));
+void operator delete[](void*, std::align_val_t, const std::nothrow_t&)
+  noexcept __attribute__((__externally_visible__));
+void operator delete(void*, std::size_t, std::align_val_t)
+  noexcept __attribute__((__externally_visible__));
+void operator delete[](void*, std::size_t, std::align_val_t)
+  noexcept __attribute__((__externally_visible__));
+inline void* operator new(std::size_t, void* __p) noexcept
+{ return __p; }
+inline void* operator new[](std::size_t, void* __p) noexcept
+{ return __p; }
+inline void operator delete (void*, void*) noexcept { }
+inline void operator delete[](void*, void*) noexcept { }
+}
+namespace std
+{
+  template<typename _Tp>
+    [[nodiscard]] constexpr _Tp*
+    launder(_Tp* __p) noexcept
+    { return __builtin_launder(__p); }
+  template<typename _Ret, typename... _Args , bool _NE>
+    void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete;
+  template<typename _Ret, typename... _Args , bool _NE>
+    void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete;
+  void launder(void*) = delete;
+  void launder(const void*) = delete;
+  void launder(volatile void*) = delete;
+  void launder(const volatile void*) = delete;
+}
+#pragma GCC visibility pop
+       
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename>
+    class allocator;
+  template<>
+    class allocator<void>;
+  template<typename, typename>
+    struct uses_allocator;
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  struct __allocator_traits_base
+  {
+    template<typename _Tp, typename _Up, typename = void>
+      struct __rebind : __replace_first_arg<_Tp, _Up> { };
+    template<typename _Tp, typename _Up>
+      struct __rebind<_Tp, _Up,
+        __void_t<typename _Tp::template rebind<_Up>::other>>
+      { using type = typename _Tp::template rebind<_Up>::other; };
+  protected:
+    template<typename _Tp>
+      using __pointer = typename _Tp::pointer;
+    template<typename _Tp>
+      using __c_pointer = typename _Tp::const_pointer;
+    template<typename _Tp>
+      using __v_pointer = typename _Tp::void_pointer;
+    template<typename _Tp>
+      using __cv_pointer = typename _Tp::const_void_pointer;
+    template<typename _Tp>
+      using __pocca = typename _Tp::propagate_on_container_copy_assignment;
+    template<typename _Tp>
+      using __pocma = typename _Tp::propagate_on_container_move_assignment;
+    template<typename _Tp>
+      using __pocs = typename _Tp::propagate_on_container_swap;
+    template<typename _Tp>
+      using __equal = typename _Tp::is_always_equal;
+  };
+  template<typename _Alloc, typename _Up>
+    using __alloc_rebind
+      = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;
+  template<typename _Alloc>
+    struct allocator_traits : __allocator_traits_base
+    {
+      typedef _Alloc allocator_type;
+      typedef typename _Alloc::value_type value_type;
+      using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;
+    private:
+      template<template<typename> class _Func, typename _Tp, typename = void>
+ struct _Ptr
+ {
+   using type = typename pointer_traits<pointer>::template rebind<_Tp>;
+ };
+      template<template<typename> class _Func, typename _Tp>
+ struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>>
+ {
+   using type = _Func<_Alloc>;
+ };
+      template<typename _A2, typename _PtrT, typename = void>
+ struct _Diff
+ { using type = typename pointer_traits<_PtrT>::difference_type; };
+      template<typename _A2, typename _PtrT>
+ struct _Diff<_A2, _PtrT, __void_t<typename _A2::difference_type>>
+ { using type = typename _A2::difference_type; };
+      template<typename _A2, typename _DiffT, typename = void>
+ struct _Size : make_unsigned<_DiffT> { };
+      template<typename _A2, typename _DiffT>
+ struct _Size<_A2, _DiffT, __void_t<typename _A2::size_type>>
+ { using type = typename _A2::size_type; };
+    public:
+      using const_pointer = typename _Ptr<__c_pointer, const value_type>::type;
+      using void_pointer = typename _Ptr<__v_pointer, void>::type;
+      using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type;
+      using difference_type = typename _Diff<_Alloc, pointer>::type;
+      using size_type = typename _Size<_Alloc, difference_type>::type;
+      using propagate_on_container_copy_assignment
+ = __detected_or_t<false_type, __pocca, _Alloc>;
+      using propagate_on_container_move_assignment
+ = __detected_or_t<false_type, __pocma, _Alloc>;
+      using propagate_on_container_swap
+ = __detected_or_t<false_type, __pocs, _Alloc>;
+      using is_always_equal
+ = __detected_or_t<typename is_empty<_Alloc>::type, __equal, _Alloc>;
+      template<typename _Tp>
+ using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
+      template<typename _Tp>
+ using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
+    private:
+      template<typename _Alloc2>
+ static auto
+ _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int)
+ -> decltype(__a.allocate(__n, __hint))
+ { return __a.allocate(__n, __hint); }
+      template<typename _Alloc2>
+ static pointer
+ _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
+ { return __a.allocate(__n); }
+      template<typename _Tp, typename... _Args>
+ struct __construct_helper
+ {
+   template<typename _Alloc2,
+     typename = decltype(std::declval<_Alloc2*>()->construct(
+    std::declval<_Tp*>(), std::declval<_Args>()...))>
+     static true_type __test(int);
+   template<typename>
+     static false_type __test(...);
+   using type = decltype(__test<_Alloc>(0));
+ };
+      template<typename _Tp, typename... _Args>
+ using __has_construct
+   = typename __construct_helper<_Tp, _Args...>::type;
+      template<typename _Tp, typename... _Args>
+ static _Require<__has_construct<_Tp, _Args...>>
+ _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
+ { __a.construct(__p, std::forward<_Args>(__args)...); }
+      template<typename _Tp, typename... _Args>
+ static
+ _Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
+          is_constructible<_Tp, _Args...>>>
+ _S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
+ { ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); }
+      template<typename _Alloc2, typename _Tp>
+ static auto
+ _S_destroy(_Alloc2& __a, _Tp* __p, int)
+ -> decltype(__a.destroy(__p))
+ { __a.destroy(__p); }
+      template<typename _Alloc2, typename _Tp>
+ static void
+ _S_destroy(_Alloc2&, _Tp* __p, ...)
+ { __p->~_Tp(); }
+      template<typename _Alloc2>
+ static auto
+ _S_max_size(_Alloc2& __a, int)
+ -> decltype(__a.max_size())
+ { return __a.max_size(); }
+      template<typename _Alloc2>
+ static size_type
+ _S_max_size(_Alloc2&, ...)
+ {
+   return __gnu_cxx::__numeric_traits<size_type>::__max
+     / sizeof(value_type);
+ }
+      template<typename _Alloc2>
+ static auto
+ _S_select(_Alloc2& __a, int)
+ -> decltype(__a.select_on_container_copy_construction())
+ { return __a.select_on_container_copy_construction(); }
+      template<typename _Alloc2>
+ static _Alloc2
+ _S_select(_Alloc2& __a, ...)
+ { return __a; }
+    public:
+      static pointer
+      allocate(_Alloc& __a, size_type __n)
+      { return __a.allocate(__n); }
+      static pointer
+      allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
+      { return _S_allocate(__a, __n, __hint, 0); }
+      static void
+      deallocate(_Alloc& __a, pointer __p, size_type __n)
+      { __a.deallocate(__p, __n); }
+      template<typename _Tp, typename... _Args>
+ static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
+ -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
+ { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
+      template<typename _Tp>
+ static void destroy(_Alloc& __a, _Tp* __p)
+ { _S_destroy(__a, __p, 0); }
+      static size_type max_size(const _Alloc& __a) noexcept
+      { return _S_max_size(__a, 0); }
+      static _Alloc
+      select_on_container_copy_construction(const _Alloc& __rhs)
+      { return _S_select(__rhs, 0); }
+    };
+  template<typename _Tp>
+    struct allocator_traits<allocator<_Tp>>
+    {
+      using allocator_type = allocator<_Tp>;
+      using value_type = _Tp;
+      using pointer = _Tp*;
+      using const_pointer = const _Tp*;
+      using void_pointer = void*;
+      using const_void_pointer = const void*;
+      using difference_type = std::ptrdiff_t;
+      using size_type = std::size_t;
+      using propagate_on_container_copy_assignment = false_type;
+      using propagate_on_container_move_assignment = true_type;
+      using propagate_on_container_swap = false_type;
+      using is_always_equal = true_type;
+      template<typename _Up>
+ using rebind_alloc = allocator<_Up>;
+      template<typename _Up>
+ using rebind_traits = allocator_traits<allocator<_Up>>;
+      static pointer
+      allocate(allocator_type& __a, size_type __n)
+      { return __a.allocate(__n); }
+      static pointer
+      allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
+      { return __a.allocate(__n, __hint); }
+      static void
+      deallocate(allocator_type& __a, pointer __p, size_type __n)
+      { __a.deallocate(__p, __n); }
+      template<typename _Up, typename... _Args>
+ static void
+ construct(allocator_type& __a, _Up* __p, _Args&&... __args)
+ { __a.construct(__p, std::forward<_Args>(__args)...); }
+      template<typename _Up>
+ static void
+ destroy(allocator_type& __a, _Up* __p)
+ { __a.destroy(__p); }
+      static size_type
+      max_size(const allocator_type& __a) noexcept
+      { return __a.max_size(); }
+      static allocator_type
+      select_on_container_copy_construction(const allocator_type& __rhs)
+      { return __rhs; }
+    };
+  template<typename _Alloc>
+    inline void
+    __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
+    { __one = __two; }
+  template<typename _Alloc>
+    inline void
+    __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
+    { }
+  template<typename _Alloc>
+    inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      typedef typename __traits::propagate_on_container_copy_assignment __pocca;
+      __do_alloc_on_copy(__one, __two, __pocca());
+    }
+  template<typename _Alloc>
+    inline _Alloc __alloc_on_copy(const _Alloc& __a)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      return __traits::select_on_container_copy_construction(__a);
+    }
+  template<typename _Alloc>
+    inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
+    { __one = std::move(__two); }
+  template<typename _Alloc>
+    inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
+    { }
+  template<typename _Alloc>
+    inline void __alloc_on_move(_Alloc& __one, _Alloc& __two)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      typedef typename __traits::propagate_on_container_move_assignment __pocma;
+      __do_alloc_on_move(__one, __two, __pocma());
+    }
+  template<typename _Alloc>
+    inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
+    {
+      using std::swap;
+      swap(__one, __two);
+    }
+  template<typename _Alloc>
+    inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
+    { }
+  template<typename _Alloc>
+    inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
+    {
+      typedef allocator_traits<_Alloc> __traits;
+      typedef typename __traits::propagate_on_container_swap __pocs;
+      __do_alloc_on_swap(__one, __two, __pocs());
+    }
+  template<typename _Alloc>
+    class __is_copy_insertable_impl
+    {
+      typedef allocator_traits<_Alloc> _Traits;
+      template<typename _Up, typename
+        = decltype(_Traits::construct(std::declval<_Alloc&>(),
+          std::declval<_Up*>(),
+          std::declval<const _Up&>()))>
+ static true_type
+ _M_select(int);
+      template<typename _Up>
+ static false_type
+ _M_select(...);
+    public:
+      typedef decltype(_M_select<typename _Alloc::value_type>(0)) type;
+    };
+  template<typename _Alloc>
+    struct __is_copy_insertable
+    : __is_copy_insertable_impl<_Alloc>::type
+    { };
+  template<typename _Tp>
+    struct __is_copy_insertable<allocator<_Tp>>
+    : is_copy_constructible<_Tp>
+    { };
+  template<typename _Alloc, typename = void>
+    struct __is_allocator : false_type { };
+  template<typename _Alloc>
+    struct __is_allocator<_Alloc,
+      __void_t<typename _Alloc::value_type,
+        decltype(std::declval<_Alloc&>().allocate(size_t{}))>>
+    : true_type { };
+  template<typename _Alloc>
+    using _RequireAllocator
+      = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type;
+
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+template<typename _Alloc, typename = typename _Alloc::value_type>
+  struct __alloc_traits
+  : std::allocator_traits<_Alloc>
+  {
+    typedef _Alloc allocator_type;
+    typedef std::allocator_traits<_Alloc> _Base_type;
+    typedef typename _Base_type::value_type value_type;
+    typedef typename _Base_type::pointer pointer;
+    typedef typename _Base_type::const_pointer const_pointer;
+    typedef typename _Base_type::size_type size_type;
+    typedef typename _Base_type::difference_type difference_type;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    using _Base_type::allocate;
+    using _Base_type::deallocate;
+    using _Base_type::construct;
+    using _Base_type::destroy;
+    using _Base_type::max_size;
+  private:
+    template<typename _Ptr>
+      using __is_custom_pointer
+ = std::__and_<std::is_same<pointer, _Ptr>,
+        std::__not_<std::is_pointer<_Ptr>>>;
+  public:
+    template<typename _Ptr, typename... _Args>
+      static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
+      construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
+      {
+ _Base_type::construct(__a, std::__to_address(__p),
+         std::forward<_Args>(__args)...);
+      }
+    template<typename _Ptr>
+      static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
+      destroy(_Alloc& __a, _Ptr __p)
+      { _Base_type::destroy(__a, std::__to_address(__p)); }
+    static _Alloc _S_select_on_copy(const _Alloc& __a)
+    { return _Base_type::select_on_container_copy_construction(__a); }
+    static void _S_on_swap(_Alloc& __a, _Alloc& __b)
+    { std::__alloc_on_swap(__a, __b); }
+    static constexpr bool _S_propagate_on_copy_assign()
+    { return _Base_type::propagate_on_container_copy_assignment::value; }
+    static constexpr bool _S_propagate_on_move_assign()
+    { return _Base_type::propagate_on_container_move_assignment::value; }
+    static constexpr bool _S_propagate_on_swap()
+    { return _Base_type::propagate_on_container_swap::value; }
+    static constexpr bool _S_always_equal()
+    { return _Base_type::is_always_equal::value; }
+    static constexpr bool _S_nothrow_move()
+    { return _S_propagate_on_move_assign() || _S_always_equal(); }
+    template<typename _Tp>
+      struct rebind
+      { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
+  };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _T1, typename... _Args>
+    inline void
+    _Construct(_T1* __p, _Args&&... __args)
+    { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
+  template<typename _T1>
+    inline void
+    _Construct_novalue(_T1* __p)
+    { ::new(static_cast<void*>(__p)) _T1; }
+  template<typename _Tp>
+    inline void
+    _Destroy(_Tp* __pointer)
+    { __pointer->~_Tp(); }
+  template<bool>
+    struct _Destroy_aux
+    {
+      template<typename _ForwardIterator>
+        static void
+        __destroy(_ForwardIterator __first, _ForwardIterator __last)
+ {
+   for (; __first != __last; ++__first)
+     std::_Destroy(std::__addressof(*__first));
+ }
+    };
+  template<>
+    struct _Destroy_aux<true>
+    {
+      template<typename _ForwardIterator>
+        static void
+        __destroy(_ForwardIterator, _ForwardIterator) { }
+    };
+  template<typename _ForwardIterator>
+    inline void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+                       _Value_type;
+      static_assert(is_destructible<_Value_type>::value,
+      "value type is destructible");
+      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
+ __destroy(__first, __last);
+    }
+  template<bool>
+    struct _Destroy_n_aux
+    {
+      template<typename _ForwardIterator, typename _Size>
+        static _ForwardIterator
+        __destroy_n(_ForwardIterator __first, _Size __count)
+ {
+   for (; __count > 0; (void)++__first, --__count)
+     std::_Destroy(std::__addressof(*__first));
+   return __first;
+ }
+    };
+  template<>
+    struct _Destroy_n_aux<true>
+    {
+      template<typename _ForwardIterator, typename _Size>
+        static _ForwardIterator
+        __destroy_n(_ForwardIterator __first, _Size __count)
+ {
+   std::advance(__first, __count);
+   return __first;
+ }
+    };
+  template<typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    _Destroy_n(_ForwardIterator __first, _Size __count)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+                       _Value_type;
+      static_assert(is_destructible<_Value_type>::value,
+      "value type is destructible");
+      return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>::
+ __destroy_n(__first, __count);
+    }
+  template<typename _ForwardIterator, typename _Allocator>
+    void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+      _Allocator& __alloc)
+    {
+      typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+      for (; __first != __last; ++__first)
+ __traits::destroy(__alloc, std::__addressof(*__first));
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+      allocator<_Tp>&)
+    {
+      _Destroy(__first, __last);
+    }
+  template <typename _Tp>
+    inline void
+    destroy_at(_Tp* __location)
+    {
+      std::_Destroy(__location);
+    }
+  template <typename _ForwardIterator>
+    inline void
+    destroy(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      std::_Destroy(__first, __last);
+    }
+  template <typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    destroy_n(_ForwardIterator __first, _Size __count)
+    {
+      return std::_Destroy_n(__first, __count);
+    }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp>
+    pair<_Tp*, ptrdiff_t>
+    get_temporary_buffer(ptrdiff_t __len) noexcept
+    {
+      const ptrdiff_t __max =
+ __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
+      if (__len > __max)
+ __len = __max;
+      while (__len > 0)
+ {
+   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
+       std::nothrow));
+   if (__tmp != 0)
+     return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
+   __len /= 2;
+ }
+      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
+    }
+  template<typename _Tp>
+    inline void
+    return_temporary_buffer(_Tp* __p)
+    { ::operator delete(__p, std::nothrow); }
+  template<typename _ForwardIterator, typename _Tp>
+    class _Temporary_buffer
+    {
+     
+    public:
+      typedef _Tp value_type;
+      typedef value_type* pointer;
+      typedef pointer iterator;
+      typedef ptrdiff_t size_type;
+    protected:
+      size_type _M_original_len;
+      size_type _M_len;
+      pointer _M_buffer;
+    public:
+      size_type
+      size() const
+      { return _M_len; }
+      size_type
+      requested_size() const
+      { return _M_original_len; }
+      iterator
+      begin()
+      { return _M_buffer; }
+      iterator
+      end()
+      { return _M_buffer + _M_len; }
+      _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
+      ~_Temporary_buffer()
+      {
+ std::_Destroy(_M_buffer, _M_buffer + _M_len);
+ std::return_temporary_buffer(_M_buffer);
+      }
+    private:
+      _Temporary_buffer(const _Temporary_buffer&);
+      void
+      operator=(const _Temporary_buffer&);
+    };
+  template<bool>
+    struct __uninitialized_construct_buf_dispatch
+    {
+      template<typename _Pointer, typename _ForwardIterator>
+        static void
+        __ucr(_Pointer __first, _Pointer __last,
+       _ForwardIterator __seed)
+        {
+   if(__first == __last)
+     return;
+   _Pointer __cur = __first;
+   try
+     {
+       std::_Construct(std::__addressof(*__first),
+         std::move(*__seed));
+       _Pointer __prev = __cur;
+       ++__cur;
+       for(; __cur != __last; ++__cur, ++__prev)
+  std::_Construct(std::__addressof(*__cur),
+    std::move(*__prev));
+       *__seed = std::move(*__prev);
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+  template<>
+    struct __uninitialized_construct_buf_dispatch<true>
+    {
+      template<typename _Pointer, typename _ForwardIterator>
+        static void
+        __ucr(_Pointer, _Pointer, _ForwardIterator) { }
+    };
+  template<typename _Pointer, typename _ForwardIterator>
+    inline void
+    __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
+      _ForwardIterator __seed)
+    {
+      typedef typename std::iterator_traits<_Pointer>::value_type
+ _ValueType;
+      std::__uninitialized_construct_buf_dispatch<
+        __has_trivial_constructor(_ValueType)>::
+   __ucr(__first, __last, __seed);
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    _Temporary_buffer<_ForwardIterator, _Tp>::
+    _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
+    : _M_original_len(std::distance(__first, __last)),
+      _M_len(0), _M_buffer(0)
+    {
+      try
+ {
+   std::pair<pointer, size_type> __p(std::get_temporary_buffer<
+         value_type>(_M_original_len));
+   _M_buffer = __p.first;
+   _M_len = __p.second;
+   if (_M_buffer)
+     std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len,
+            __first);
+ }
+      catch(...)
+ {
+   std::return_temporary_buffer(_M_buffer);
+   _M_buffer = 0;
+   _M_len = 0;
+   throw;
+ }
+    }
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  enum float_round_style
+  {
+    round_indeterminate = -1,
+    round_toward_zero = 0,
+    round_to_nearest = 1,
+    round_toward_infinity = 2,
+    round_toward_neg_infinity = 3
+  };
+  enum float_denorm_style
+  {
+    denorm_indeterminate = -1,
+    denorm_absent = 0,
+    denorm_present = 1
+  };
+  struct __numeric_limits_base
+  {
+    static constexpr bool is_specialized = false;
+    static constexpr int digits = 0;
+    static constexpr int digits10 = 0;
+    static constexpr int max_digits10 = 0;
+    static constexpr bool is_signed = false;
+    static constexpr bool is_integer = false;
+    static constexpr bool is_exact = false;
+    static constexpr int radix = 0;
+    static constexpr int min_exponent = 0;
+    static constexpr int min_exponent10 = 0;
+    static constexpr int max_exponent = 0;
+    static constexpr int max_exponent10 = 0;
+    static constexpr bool has_infinity = false;
+    static constexpr bool has_quiet_NaN = false;
+    static constexpr bool has_signaling_NaN = false;
+    static constexpr float_denorm_style has_denorm = denorm_absent;
+    static constexpr bool has_denorm_loss = false;
+    static constexpr bool is_iec559 = false;
+    static constexpr bool is_bounded = false;
+    static constexpr bool is_modulo = false;
+    static constexpr bool traps = false;
+    static constexpr bool tinyness_before = false;
+    static constexpr float_round_style round_style =
+          round_toward_zero;
+  };
+  template<typename _Tp>
+    struct numeric_limits : public __numeric_limits_base
+    {
+      static constexpr _Tp
+      min() noexcept { return _Tp(); }
+      static constexpr _Tp
+      max() noexcept { return _Tp(); }
+      static constexpr _Tp
+      lowest() noexcept { return _Tp(); }
+      static constexpr _Tp
+      epsilon() noexcept { return _Tp(); }
+      static constexpr _Tp
+      round_error() noexcept { return _Tp(); }
+      static constexpr _Tp
+      infinity() noexcept { return _Tp(); }
+      static constexpr _Tp
+      quiet_NaN() noexcept { return _Tp(); }
+      static constexpr _Tp
+      signaling_NaN() noexcept { return _Tp(); }
+      static constexpr _Tp
+      denorm_min() noexcept { return _Tp(); }
+    };
+  template<typename _Tp>
+    struct numeric_limits<const _Tp>
+    : public numeric_limits<_Tp> { };
+  template<typename _Tp>
+    struct numeric_limits<volatile _Tp>
+    : public numeric_limits<_Tp> { };
+  template<typename _Tp>
+    struct numeric_limits<const volatile _Tp>
+    : public numeric_limits<_Tp> { };
+  template<>
+    struct numeric_limits<bool>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr bool
+      min() noexcept { return false; }
+      static constexpr bool
+      max() noexcept { return true; }
+      static constexpr bool
+      lowest() noexcept { return min(); }
+      static constexpr int digits = 1;
+      static constexpr int digits10 = 0;
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr bool
+      epsilon() noexcept { return false; }
+      static constexpr bool
+      round_error() noexcept { return false; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr bool
+      infinity() noexcept { return false; }
+      static constexpr bool
+      quiet_NaN() noexcept { return false; }
+      static constexpr bool
+      signaling_NaN() noexcept { return false; }
+      static constexpr bool
+      denorm_min() noexcept { return false; }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<char>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr char
+      min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }
+      static constexpr char
+      max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
+      static constexpr char
+      lowest() noexcept { return min(); }
+      static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = ((char)(-1) < 0);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr char
+      epsilon() noexcept { return 0; }
+      static constexpr char
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr
+      char infinity() noexcept { return char(); }
+      static constexpr char
+      quiet_NaN() noexcept { return char(); }
+      static constexpr char
+      signaling_NaN() noexcept { return char(); }
+      static constexpr char
+      denorm_min() noexcept { return static_cast<char>(0); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<signed char>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr signed char
+      min() noexcept { return -0x7f - 1; }
+      static constexpr signed char
+      max() noexcept { return 0x7f; }
+      static constexpr signed char
+      lowest() noexcept { return min(); }
+      static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr signed char
+      epsilon() noexcept { return 0; }
+      static constexpr signed char
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr signed char
+      infinity() noexcept { return static_cast<signed char>(0); }
+      static constexpr signed char
+      quiet_NaN() noexcept { return static_cast<signed char>(0); }
+      static constexpr signed char
+      signaling_NaN() noexcept
+      { return static_cast<signed char>(0); }
+      static constexpr signed char
+      denorm_min() noexcept
+      { return static_cast<signed char>(0); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<unsigned char>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr unsigned char
+      min() noexcept { return 0; }
+      static constexpr unsigned char
+      max() noexcept { return 0x7f * 2U + 1; }
+      static constexpr unsigned char
+      lowest() noexcept { return min(); }
+      static constexpr int digits
+       = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr unsigned char
+      epsilon() noexcept { return 0; }
+      static constexpr unsigned char
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr unsigned char
+      infinity() noexcept
+      { return static_cast<unsigned char>(0); }
+      static constexpr unsigned char
+      quiet_NaN() noexcept
+      { return static_cast<unsigned char>(0); }
+      static constexpr unsigned char
+      signaling_NaN() noexcept
+      { return static_cast<unsigned char>(0); }
+      static constexpr unsigned char
+      denorm_min() noexcept
+      { return static_cast<unsigned char>(0); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<wchar_t>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr wchar_t
+      min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }
+      static constexpr wchar_t
+      max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
+      static constexpr wchar_t
+      lowest() noexcept { return min(); }
+      static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = ((wchar_t)(-1) < 0);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr wchar_t
+      epsilon() noexcept { return 0; }
+      static constexpr wchar_t
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr wchar_t
+      infinity() noexcept { return wchar_t(); }
+      static constexpr wchar_t
+      quiet_NaN() noexcept { return wchar_t(); }
+      static constexpr wchar_t
+      signaling_NaN() noexcept { return wchar_t(); }
+      static constexpr wchar_t
+      denorm_min() noexcept { return wchar_t(); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<char16_t>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr char16_t
+      min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }
+      static constexpr char16_t
+      max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }
+      static constexpr char16_t
+      lowest() noexcept { return min(); }
+      static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = ((char16_t)(-1) < 0);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr char16_t
+      epsilon() noexcept { return 0; }
+      static constexpr char16_t
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr char16_t
+      infinity() noexcept { return char16_t(); }
+      static constexpr char16_t
+      quiet_NaN() noexcept { return char16_t(); }
+      static constexpr char16_t
+      signaling_NaN() noexcept { return char16_t(); }
+      static constexpr char16_t
+      denorm_min() noexcept { return char16_t(); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<char32_t>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr char32_t
+      min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }
+      static constexpr char32_t
+      max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }
+      static constexpr char32_t
+      lowest() noexcept { return min(); }
+      static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = ((char32_t)(-1) < 0);
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr char32_t
+      epsilon() noexcept { return 0; }
+      static constexpr char32_t
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr char32_t
+      infinity() noexcept { return char32_t(); }
+      static constexpr char32_t
+      quiet_NaN() noexcept { return char32_t(); }
+      static constexpr char32_t
+      signaling_NaN() noexcept { return char32_t(); }
+      static constexpr char32_t
+      denorm_min() noexcept { return char32_t(); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = !is_signed;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<short>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr short
+      min() noexcept { return -0x7fff - 1; }
+      static constexpr short
+      max() noexcept { return 0x7fff; }
+      static constexpr short
+      lowest() noexcept { return min(); }
+      static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr short
+      epsilon() noexcept { return 0; }
+      static constexpr short
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr short
+      infinity() noexcept { return short(); }
+      static constexpr short
+      quiet_NaN() noexcept { return short(); }
+      static constexpr short
+      signaling_NaN() noexcept { return short(); }
+      static constexpr short
+      denorm_min() noexcept { return short(); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<unsigned short>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr unsigned short
+      min() noexcept { return 0; }
+      static constexpr unsigned short
+      max() noexcept { return 0x7fff * 2U + 1; }
+      static constexpr unsigned short
+      lowest() noexcept { return min(); }
+      static constexpr int digits
+       = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr unsigned short
+      epsilon() noexcept { return 0; }
+      static constexpr unsigned short
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr unsigned short
+      infinity() noexcept
+      { return static_cast<unsigned short>(0); }
+      static constexpr unsigned short
+      quiet_NaN() noexcept
+      { return static_cast<unsigned short>(0); }
+      static constexpr unsigned short
+      signaling_NaN() noexcept
+      { return static_cast<unsigned short>(0); }
+      static constexpr unsigned short
+      denorm_min() noexcept
+      { return static_cast<unsigned short>(0); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<int>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr int
+      min() noexcept { return -0x7fffffff - 1; }
+      static constexpr int
+      max() noexcept { return 0x7fffffff; }
+      static constexpr int
+      lowest() noexcept { return min(); }
+      static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr int
+      epsilon() noexcept { return 0; }
+      static constexpr int
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr int
+      infinity() noexcept { return static_cast<int>(0); }
+      static constexpr int
+      quiet_NaN() noexcept { return static_cast<int>(0); }
+      static constexpr int
+      signaling_NaN() noexcept { return static_cast<int>(0); }
+      static constexpr int
+      denorm_min() noexcept { return static_cast<int>(0); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<unsigned int>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr unsigned int
+      min() noexcept { return 0; }
+      static constexpr unsigned int
+      max() noexcept { return 0x7fffffff * 2U + 1; }
+      static constexpr unsigned int
+      lowest() noexcept { return min(); }
+      static constexpr int digits
+       = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr unsigned int
+      epsilon() noexcept { return 0; }
+      static constexpr unsigned int
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr unsigned int
+      infinity() noexcept { return static_cast<unsigned int>(0); }
+      static constexpr unsigned int
+      quiet_NaN() noexcept
+      { return static_cast<unsigned int>(0); }
+      static constexpr unsigned int
+      signaling_NaN() noexcept
+      { return static_cast<unsigned int>(0); }
+      static constexpr unsigned int
+      denorm_min() noexcept
+      { return static_cast<unsigned int>(0); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<long>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr long
+      min() noexcept { return -0x7fffffffffffffffL - 1; }
+      static constexpr long
+      max() noexcept { return 0x7fffffffffffffffL; }
+      static constexpr long
+      lowest() noexcept { return min(); }
+      static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
+      static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr long
+      epsilon() noexcept { return 0; }
+      static constexpr long
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr long
+      infinity() noexcept { return static_cast<long>(0); }
+      static constexpr long
+      quiet_NaN() noexcept { return static_cast<long>(0); }
+      static constexpr long
+      signaling_NaN() noexcept { return static_cast<long>(0); }
+      static constexpr long
+      denorm_min() noexcept { return static_cast<long>(0); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<unsigned long>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr unsigned long
+      min() noexcept { return 0; }
+      static constexpr unsigned long
+      max() noexcept { return 0x7fffffffffffffffL * 2UL + 1; }
+      static constexpr unsigned long
+      lowest() noexcept { return min(); }
+      static constexpr int digits
+       = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr unsigned long
+      epsilon() noexcept { return 0; }
+      static constexpr unsigned long
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr unsigned long
+      infinity() noexcept
+      { return static_cast<unsigned long>(0); }
+      static constexpr unsigned long
+      quiet_NaN() noexcept
+      { return static_cast<unsigned long>(0); }
+      static constexpr unsigned long
+      signaling_NaN() noexcept
+      { return static_cast<unsigned long>(0); }
+      static constexpr unsigned long
+      denorm_min() noexcept
+      { return static_cast<unsigned long>(0); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<long long>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr long long
+      min() noexcept { return -0x7fffffffffffffffLL - 1; }
+      static constexpr long long
+      max() noexcept { return 0x7fffffffffffffffLL; }
+      static constexpr long long
+      lowest() noexcept { return min(); }
+      static constexpr int digits
+       = (sizeof(long long) * 8 - ((long long)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr long long
+      epsilon() noexcept { return 0; }
+      static constexpr long long
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr long long
+      infinity() noexcept { return static_cast<long long>(0); }
+      static constexpr long long
+      quiet_NaN() noexcept { return static_cast<long long>(0); }
+      static constexpr long long
+      signaling_NaN() noexcept
+      { return static_cast<long long>(0); }
+      static constexpr long long
+      denorm_min() noexcept { return static_cast<long long>(0); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<unsigned long long>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr unsigned long long
+      min() noexcept { return 0; }
+      static constexpr unsigned long long
+      max() noexcept { return 0x7fffffffffffffffLL * 2ULL + 1; }
+      static constexpr unsigned long long
+      lowest() noexcept { return min(); }
+      static constexpr int digits
+       = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
+      static constexpr int digits10
+       = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
+      static constexpr int max_digits10 = 0;
+      static constexpr bool is_signed = false;
+      static constexpr bool is_integer = true;
+      static constexpr bool is_exact = true;
+      static constexpr int radix = 2;
+      static constexpr unsigned long long
+      epsilon() noexcept { return 0; }
+      static constexpr unsigned long long
+      round_error() noexcept { return 0; }
+      static constexpr int min_exponent = 0;
+      static constexpr int min_exponent10 = 0;
+      static constexpr int max_exponent = 0;
+      static constexpr int max_exponent10 = 0;
+      static constexpr bool has_infinity = false;
+      static constexpr bool has_quiet_NaN = false;
+      static constexpr bool has_signaling_NaN = false;
+      static constexpr float_denorm_style has_denorm
+       = denorm_absent;
+      static constexpr bool has_denorm_loss = false;
+      static constexpr unsigned long long
+      infinity() noexcept
+      { return static_cast<unsigned long long>(0); }
+      static constexpr unsigned long long
+      quiet_NaN() noexcept
+      { return static_cast<unsigned long long>(0); }
+      static constexpr unsigned long long
+      signaling_NaN() noexcept
+      { return static_cast<unsigned long long>(0); }
+      static constexpr unsigned long long
+      denorm_min() noexcept
+      { return static_cast<unsigned long long>(0); }
+      static constexpr bool is_iec559 = false;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = true;
+      static constexpr bool traps = true;
+      static constexpr bool tinyness_before = false;
+      static constexpr float_round_style round_style
+       = round_toward_zero;
+    };
+  template<>
+    struct numeric_limits<float>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr float
+      min() noexcept { return 1.17549435082228750796873653722224568e-38F; }
+      static constexpr float
+      max() noexcept { return 3.40282346638528859811704183484516925e+38F; }
+      static constexpr float
+      lowest() noexcept { return -3.40282346638528859811704183484516925e+38F; }
+      static constexpr int digits = 24;
+      static constexpr int digits10 = 6;
+      static constexpr int max_digits10
+  = (2 + (24) * 643L / 2136);
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = false;
+      static constexpr bool is_exact = false;
+      static constexpr int radix = 2;
+      static constexpr float
+      epsilon() noexcept { return 1.19209289550781250000000000000000000e-7F; }
+      static constexpr float
+      round_error() noexcept { return 0.5F; }
+      static constexpr int min_exponent = (-125);
+      static constexpr int min_exponent10 = (-37);
+      static constexpr int max_exponent = 128;
+      static constexpr int max_exponent10 = 38;
+      static constexpr bool has_infinity = 1;
+      static constexpr bool has_quiet_NaN = 1;
+      static constexpr bool has_signaling_NaN = has_quiet_NaN;
+      static constexpr float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static constexpr bool has_denorm_loss
+       = false;
+      static constexpr float
+      infinity() noexcept { return __builtin_huge_valf(); }
+      static constexpr float
+      quiet_NaN() noexcept { return __builtin_nanf(""); }
+      static constexpr float
+      signaling_NaN() noexcept { return __builtin_nansf(""); }
+      static constexpr float
+      denorm_min() noexcept { return 1.40129846432481707092372958328991613e-45F; }
+      static constexpr bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+      static constexpr bool traps = false;
+      static constexpr bool tinyness_before
+       = false;
+      static constexpr float_round_style round_style
+       = round_to_nearest;
+    };
+  template<>
+    struct numeric_limits<double>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr double
+      min() noexcept { return double(2.22507385850720138309023271733240406e-308L); }
+      static constexpr double
+      max() noexcept { return double(1.79769313486231570814527423731704357e+308L); }
+      static constexpr double
+      lowest() noexcept { return -double(1.79769313486231570814527423731704357e+308L); }
+      static constexpr int digits = 53;
+      static constexpr int digits10 = 15;
+      static constexpr int max_digits10
+  = (2 + (53) * 643L / 2136);
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = false;
+      static constexpr bool is_exact = false;
+      static constexpr int radix = 2;
+      static constexpr double
+      epsilon() noexcept { return double(2.22044604925031308084726333618164062e-16L); }
+      static constexpr double
+      round_error() noexcept { return 0.5; }
+      static constexpr int min_exponent = (-1021);
+      static constexpr int min_exponent10 = (-307);
+      static constexpr int max_exponent = 1024;
+      static constexpr int max_exponent10 = 308;
+      static constexpr bool has_infinity = 1;
+      static constexpr bool has_quiet_NaN = 1;
+      static constexpr bool has_signaling_NaN = has_quiet_NaN;
+      static constexpr float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static constexpr bool has_denorm_loss
+        = false;
+      static constexpr double
+      infinity() noexcept { return __builtin_huge_val(); }
+      static constexpr double
+      quiet_NaN() noexcept { return __builtin_nan(""); }
+      static constexpr double
+      signaling_NaN() noexcept { return __builtin_nans(""); }
+      static constexpr double
+      denorm_min() noexcept { return double(4.94065645841246544176568792868221372e-324L); }
+      static constexpr bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+      static constexpr bool traps = false;
+      static constexpr bool tinyness_before
+       = false;
+      static constexpr float_round_style round_style
+       = round_to_nearest;
+    };
+  template<>
+    struct numeric_limits<long double>
+    {
+      static constexpr bool is_specialized = true;
+      static constexpr long double
+      min() noexcept { return 3.36210314311209350626267781732175260e-4932L; }
+      static constexpr long double
+      max() noexcept { return 1.18973149535723176502126385303097021e+4932L; }
+      static constexpr long double
+      lowest() noexcept { return -1.18973149535723176502126385303097021e+4932L; }
+      static constexpr int digits = 64;
+      static constexpr int digits10 = 18;
+      static constexpr int max_digits10
+  = (2 + (64) * 643L / 2136);
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = false;
+      static constexpr bool is_exact = false;
+      static constexpr int radix = 2;
+      static constexpr long double
+      epsilon() noexcept { return 1.08420217248550443400745280086994171e-19L; }
+      static constexpr long double
+      round_error() noexcept { return 0.5L; }
+      static constexpr int min_exponent = (-16381);
+      static constexpr int min_exponent10 = (-4931);
+      static constexpr int max_exponent = 16384;
+      static constexpr int max_exponent10 = 4932;
+      static constexpr bool has_infinity = 1;
+      static constexpr bool has_quiet_NaN = 1;
+      static constexpr bool has_signaling_NaN = has_quiet_NaN;
+      static constexpr float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static constexpr bool has_denorm_loss
+ = false;
+      static constexpr long double
+      infinity() noexcept { return __builtin_huge_vall(); }
+      static constexpr long double
+      quiet_NaN() noexcept { return __builtin_nanl(""); }
+      static constexpr long double
+      signaling_NaN() noexcept { return __builtin_nansl(""); }
+      static constexpr long double
+      denorm_min() noexcept { return 3.64519953188247460252840593361941982e-4951L; }
+      static constexpr bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+      static constexpr bool traps = false;
+      static constexpr bool tinyness_before =
+      false;
+      static constexpr float_round_style round_style =
+            round_to_nearest;
+    };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+    template<typename _Tp>
+      inline bool
+      _Power_of_2(_Tp __x)
+      {
+ return ((__x - 1) & __x) == 0;
+      }
+  }
+  template<typename _IntType = int>
+    class uniform_int_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+      "template argument must be an integral type");
+    public:
+      typedef _IntType result_type;
+      struct param_type
+      {
+ typedef uniform_int_distribution<_IntType> distribution_type;
+ explicit
+ param_type(_IntType __a = 0,
+     _IntType __b = std::numeric_limits<_IntType>::max())
+ : _M_a(__a), _M_b(__b)
+ {
+   ;
+ }
+ result_type
+ a() const
+ { return _M_a; }
+ result_type
+ b() const
+ { return _M_b; }
+ friend bool
+ operator==(const param_type& __p1, const param_type& __p2)
+ { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+      private:
+ _IntType _M_a;
+ _IntType _M_b;
+      };
+    public:
+      explicit
+      uniform_int_distribution(_IntType __a = 0,
+      _IntType __b = std::numeric_limits<_IntType>::max())
+      : _M_param(__a, __b)
+      { }
+      explicit
+      uniform_int_distribution(const param_type& __p)
+      : _M_param(__p)
+      { }
+      void
+      reset() { }
+      result_type
+      a() const
+      { return _M_param.a(); }
+      result_type
+      b() const
+      { return _M_param.b(); }
+      param_type
+      param() const
+      { return _M_param; }
+      void
+      param(const param_type& __param)
+      { _M_param = __param; }
+      result_type
+      min() const
+      { return this->a(); }
+      result_type
+      max() const
+      { return this->b(); }
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng)
+        { return this->operator()(__urng, _M_param); }
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+      friend bool
+      operator==(const uniform_int_distribution& __d1,
+   const uniform_int_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+    private:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+      param_type _M_param;
+    };
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename uniform_int_distribution<_IntType>::result_type
+      uniform_int_distribution<_IntType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+   const param_type& __param)
+      {
+ typedef typename _UniformRandomNumberGenerator::result_type
+   _Gresult_type;
+ typedef typename std::make_unsigned<result_type>::type __utype;
+ typedef typename std::common_type<_Gresult_type, __utype>::type
+   __uctype;
+ const __uctype __urngmin = __urng.min();
+ const __uctype __urngmax = __urng.max();
+ const __uctype __urngrange = __urngmax - __urngmin;
+ const __uctype __urange
+   = __uctype(__param.b()) - __uctype(__param.a());
+ __uctype __ret;
+ if (__urngrange > __urange)
+   {
+     const __uctype __uerange = __urange + 1;
+     const __uctype __scaling = __urngrange / __uerange;
+     const __uctype __past = __uerange * __scaling;
+     do
+       __ret = __uctype(__urng()) - __urngmin;
+     while (__ret >= __past);
+     __ret /= __scaling;
+   }
+ else if (__urngrange < __urange)
+   {
+     __uctype __tmp;
+     do
+       {
+  const __uctype __uerngrange = __urngrange + 1;
+  __tmp = (__uerngrange * operator()
+    (__urng, param_type(0, __urange / __uerngrange)));
+  __ret = __tmp + (__uctype(__urng()) - __urngmin);
+       }
+     while (__ret > __urange || __ret < __tmp);
+   }
+ else
+   __ret = __uctype(__urng()) - __urngmin;
+ return __ret + __param.a();
+      }
+  template<typename _IntType>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      uniform_int_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __param)
+      {
+
+ typedef typename _UniformRandomNumberGenerator::result_type
+   _Gresult_type;
+ typedef typename std::make_unsigned<result_type>::type __utype;
+ typedef typename std::common_type<_Gresult_type, __utype>::type
+   __uctype;
+ const __uctype __urngmin = __urng.min();
+ const __uctype __urngmax = __urng.max();
+ const __uctype __urngrange = __urngmax - __urngmin;
+ const __uctype __urange
+   = __uctype(__param.b()) - __uctype(__param.a());
+ __uctype __ret;
+ if (__urngrange > __urange)
+   {
+     if (__detail::_Power_of_2(__urngrange + 1)
+  && __detail::_Power_of_2(__urange + 1))
+       {
+  while (__f != __t)
+    {
+      __ret = __uctype(__urng()) - __urngmin;
+      *__f++ = (__ret & __urange) + __param.a();
+    }
+       }
+     else
+       {
+  const __uctype __uerange = __urange + 1;
+  const __uctype __scaling = __urngrange / __uerange;
+  const __uctype __past = __uerange * __scaling;
+  while (__f != __t)
+    {
+      do
+        __ret = __uctype(__urng()) - __urngmin;
+      while (__ret >= __past);
+      *__f++ = __ret / __scaling + __param.a();
+    }
+       }
+   }
+ else if (__urngrange < __urange)
+   {
+     __uctype __tmp;
+     while (__f != __t)
+       {
+  do
+    {
+      const __uctype __uerngrange = __urngrange + 1;
+      __tmp = (__uerngrange * operator()
+        (__urng, param_type(0, __urange / __uerngrange)));
+      __ret = __tmp + (__uctype(__urng()) - __urngmin);
+    }
+  while (__ret > __urange || __ret < __tmp);
+  *__f++ = __ret;
+       }
+   }
+ else
+   while (__f != __t)
+     *__f++ = __uctype(__urng()) - __urngmin + __param.a();
+      }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Iterator, typename _Compare>
+    void
+    __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
+      _Iterator __c, _Compare __comp)
+    {
+      if (__comp(__a, __b))
+ {
+   if (__comp(__b, __c))
+     std::iter_swap(__result, __b);
+   else if (__comp(__a, __c))
+     std::iter_swap(__result, __c);
+   else
+     std::iter_swap(__result, __a);
+ }
+      else if (__comp(__a, __c))
+ std::iter_swap(__result, __a);
+      else if (__comp(__b, __c))
+ std::iter_swap(__result, __c);
+      else
+ std::iter_swap(__result, __b);
+    }
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    __find_if(_InputIterator __first, _InputIterator __last,
+       _Predicate __pred, input_iterator_tag)
+    {
+      while (__first != __last && !__pred(__first))
+ ++__first;
+      return __first;
+    }
+  template<typename _RandomAccessIterator, typename _Predicate>
+    _RandomAccessIterator
+    __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Predicate __pred, random_access_iterator_tag)
+    {
+      typename iterator_traits<_RandomAccessIterator>::difference_type
+ __trip_count = (__last - __first) >> 2;
+      for (; __trip_count > 0; --__trip_count)
+ {
+   if (__pred(__first))
+     return __first;
+   ++__first;
+   if (__pred(__first))
+     return __first;
+   ++__first;
+   if (__pred(__first))
+     return __first;
+   ++__first;
+   if (__pred(__first))
+     return __first;
+   ++__first;
+ }
+      switch (__last - __first)
+ {
+ case 3:
+   if (__pred(__first))
+     return __first;
+   ++__first;
+ case 2:
+   if (__pred(__first))
+     return __first;
+   ++__first;
+ case 1:
+   if (__pred(__first))
+     return __first;
+   ++__first;
+ case 0:
+ default:
+   return __last;
+ }
+    }
+  template<typename _Iterator, typename _Predicate>
+    inline _Iterator
+    __find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
+    {
+      return __find_if(__first, __last, __pred,
+         std::__iterator_category(__first));
+    }
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    __find_if_not(_InputIterator __first, _InputIterator __last,
+    _Predicate __pred)
+    {
+      return std::__find_if(__first, __last,
+       __gnu_cxx::__ops::__negate(__pred),
+       std::__iterator_category(__first));
+    }
+  template<typename _InputIterator, typename _Predicate, typename _Distance>
+    _InputIterator
+    __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
+    {
+      for (; __len; --__len, (void) ++__first)
+ if (!__pred(__first))
+   break;
+      return __first;
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    _ForwardIterator1
+    __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+      _BinaryPredicate __predicate)
+    {
+      if (__first1 == __last1 || __first2 == __last2)
+ return __first1;
+      _ForwardIterator2 __p1(__first2);
+      if (++__p1 == __last2)
+ return std::__find_if(__first1, __last1,
+  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
+      _ForwardIterator2 __p;
+      _ForwardIterator1 __current = __first1;
+      for (;;)
+ {
+   __first1 =
+     std::__find_if(__first1, __last1,
+  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
+   if (__first1 == __last1)
+     return __last1;
+   __p = __p1;
+   __current = __first1;
+   if (++__current == __last1)
+     return __last1;
+   while (__predicate(__current, __p))
+     {
+       if (++__p == __last2)
+  return __first1;
+       if (++__current == __last1)
+  return __last1;
+     }
+   ++__first1;
+ }
+      return __first1;
+    }
+  template<typename _ForwardIterator, typename _Integer,
+    typename _UnaryPredicate>
+    _ForwardIterator
+    __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
+     _Integer __count, _UnaryPredicate __unary_pred,
+     std::forward_iterator_tag)
+    {
+      __first = std::__find_if(__first, __last, __unary_pred);
+      while (__first != __last)
+ {
+   typename iterator_traits<_ForwardIterator>::difference_type
+     __n = __count;
+   _ForwardIterator __i = __first;
+   ++__i;
+   while (__i != __last && __n != 1 && __unary_pred(__i))
+     {
+       ++__i;
+       --__n;
+     }
+   if (__n == 1)
+     return __first;
+   if (__i == __last)
+     return __last;
+   __first = std::__find_if(++__i, __last, __unary_pred);
+ }
+      return __last;
+    }
+  template<typename _RandomAccessIter, typename _Integer,
+    typename _UnaryPredicate>
+    _RandomAccessIter
+    __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
+     _Integer __count, _UnaryPredicate __unary_pred,
+     std::random_access_iterator_tag)
+    {
+      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
+ _DistanceType;
+      _DistanceType __tailSize = __last - __first;
+      _DistanceType __remainder = __count;
+      while (__remainder <= __tailSize)
+ {
+   __first += __remainder;
+   __tailSize -= __remainder;
+   _RandomAccessIter __backTrack = __first;
+   while (__unary_pred(--__backTrack))
+     {
+       if (--__remainder == 0)
+  return (__first - __count);
+     }
+   __remainder = __count + 1 - (__first - __backTrack);
+ }
+      return __last;
+    }
+  template<typename _ForwardIterator, typename _Integer,
+    typename _UnaryPredicate>
+    _ForwardIterator
+    __search_n(_ForwardIterator __first, _ForwardIterator __last,
+        _Integer __count,
+        _UnaryPredicate __unary_pred)
+    {
+      if (__count <= 0)
+ return __first;
+      if (__count == 1)
+ return std::__find_if(__first, __last, __unary_pred);
+      return std::__search_n_aux(__first, __last, __count, __unary_pred,
+     std::__iterator_category(__first));
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    _ForwardIterator1
+    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+        forward_iterator_tag, forward_iterator_tag,
+        _BinaryPredicate __comp)
+    {
+      if (__first2 == __last2)
+ return __last1;
+      _ForwardIterator1 __result = __last1;
+      while (1)
+ {
+   _ForwardIterator1 __new_result
+     = std::__search(__first1, __last1, __first2, __last2, __comp);
+   if (__new_result == __last1)
+     return __result;
+   else
+     {
+       __result = __new_result;
+       __first1 = __new_result;
+       ++__first1;
+     }
+ }
+    }
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _BinaryPredicate>
+    _BidirectionalIterator1
+    __find_end(_BidirectionalIterator1 __first1,
+        _BidirectionalIterator1 __last1,
+        _BidirectionalIterator2 __first2,
+        _BidirectionalIterator2 __last2,
+        bidirectional_iterator_tag, bidirectional_iterator_tag,
+        _BinaryPredicate __comp)
+    {
+     
+     
+      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
+      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
+      _RevIterator1 __rlast1(__first1);
+      _RevIterator2 __rlast2(__first2);
+      _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
+           _RevIterator2(__last2), __rlast2,
+           __comp);
+      if (__rresult == __rlast1)
+ return __last1;
+      else
+ {
+   _BidirectionalIterator1 __result = __rresult.base();
+   std::advance(__result, -std::distance(__first2, __last2));
+   return __result;
+ }
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+     
+     
+     
+      ;
+      ;
+      return std::__find_end(__first1, __last1, __first2, __last2,
+        std::__iterator_category(__first1),
+        std::__iterator_category(__first2),
+        __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+      _BinaryPredicate __comp)
+    {
+     
+     
+     
+      ;
+      ;
+      return std::__find_end(__first1, __last1, __first2, __last2,
+        std::__iterator_category(__first1),
+        std::__iterator_category(__first2),
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return __last == std::find_if_not(__first, __last, __pred); }
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return __last == std::find_if(__first, __last, __pred); }
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return !std::none_of(__first, __last, __pred); }
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    find_if_not(_InputIterator __first, _InputIterator __last,
+  _Predicate __pred)
+    {
+     
+     
+      ;
+      return std::__find_if_not(__first, __last,
+    __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+  template<typename _InputIterator, typename _Predicate>
+    inline bool
+    is_partitioned(_InputIterator __first, _InputIterator __last,
+     _Predicate __pred)
+    {
+      __first = std::find_if_not(__first, __last, __pred);
+      if (__first == __last)
+ return true;
+      ++__first;
+      return std::none_of(__first, __last, __pred);
+    }
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    partition_point(_ForwardIterator __first, _ForwardIterator __last,
+      _Predicate __pred)
+    {
+     
+     
+      ;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+      _DistanceType __len = std::distance(__first, __last);
+      _DistanceType __half;
+      _ForwardIterator __middle;
+      while (__len > 0)
+ {
+   __half = __len >> 1;
+   __middle = __first;
+   std::advance(__middle, __half);
+   if (__pred(*__middle))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else
+     __len = __half;
+ }
+      return __first;
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+    _OutputIterator
+    __remove_copy_if(_InputIterator __first, _InputIterator __last,
+       _OutputIterator __result, _Predicate __pred)
+    {
+      for (; __first != __last; ++__first)
+ if (!__pred(__first))
+   {
+     *__result = *__first;
+     ++__result;
+   }
+      return __result;
+    }
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    inline _OutputIterator
+    remove_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result, const _Tp& __value)
+    {
+     
+     
+     
+      ;
+      return std::__remove_copy_if(__first, __last, __result,
+ __gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+    inline _OutputIterator
+    remove_copy_if(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _Predicate __pred)
+    {
+     
+     
+     
+      ;
+      return std::__remove_copy_if(__first, __last, __result,
+       __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+    _OutputIterator
+    copy_if(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _Predicate __pred)
+    {
+     
+     
+     
+      ;
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   {
+     *__result = *__first;
+     ++__result;
+   }
+      return __result;
+    }
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+    _OutputIterator
+    __copy_n(_InputIterator __first, _Size __n,
+      _OutputIterator __result, input_iterator_tag)
+    {
+      if (__n > 0)
+ {
+   while (true)
+     {
+       *__result = *__first;
+       ++__result;
+       if (--__n > 0)
+  ++__first;
+       else
+  break;
+     }
+ }
+      return __result;
+    }
+  template<typename _RandomAccessIterator, typename _Size,
+    typename _OutputIterator>
+    inline _OutputIterator
+    __copy_n(_RandomAccessIterator __first, _Size __n,
+      _OutputIterator __result, random_access_iterator_tag)
+    { return std::copy(__first, __first + __n, __result); }
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+    inline _OutputIterator
+    copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
+    {
+     
+     
+      return std::__copy_n(__first, __n, __result,
+      std::__iterator_category(__first));
+    }
+  template<typename _InputIterator, typename _OutputIterator1,
+    typename _OutputIterator2, typename _Predicate>
+    pair<_OutputIterator1, _OutputIterator2>
+    partition_copy(_InputIterator __first, _InputIterator __last,
+     _OutputIterator1 __out_true, _OutputIterator2 __out_false,
+     _Predicate __pred)
+    {
+     
+     
+     
+     
+      ;
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   {
+     *__out_true = *__first;
+     ++__out_true;
+   }
+ else
+   {
+     *__out_false = *__first;
+     ++__out_false;
+   }
+      return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
+    }
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    __remove_if(_ForwardIterator __first, _ForwardIterator __last,
+  _Predicate __pred)
+    {
+      __first = std::__find_if(__first, __last, __pred);
+      if (__first == __last)
+ return __first;
+      _ForwardIterator __result = __first;
+      ++__first;
+      for (; __first != __last; ++__first)
+ if (!__pred(__first))
+   {
+     *__result = std::move(*__first);
+     ++__result;
+   }
+      return __result;
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    remove(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __value)
+    {
+     
+     
+      ;
+      return std::__remove_if(__first, __last,
+  __gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    remove_if(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+     
+     
+      ;
+      return std::__remove_if(__first, __last,
+         __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    _ForwardIterator
+    __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
+      _BinaryPredicate __binary_pred)
+    {
+      if (__first == __last)
+ return __last;
+      _ForwardIterator __next = __first;
+      while (++__next != __last)
+ {
+   if (__binary_pred(__first, __next))
+     return __first;
+   __first = __next;
+ }
+      return __last;
+    }
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    _ForwardIterator
+    __unique(_ForwardIterator __first, _ForwardIterator __last,
+      _BinaryPredicate __binary_pred)
+    {
+      __first = std::__adjacent_find(__first, __last, __binary_pred);
+      if (__first == __last)
+ return __last;
+      _ForwardIterator __dest = __first;
+      ++__first;
+      while (++__first != __last)
+ if (!__binary_pred(__dest, __first))
+   *++__dest = std::move(*__first);
+      return ++__dest;
+    }
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last)
+    {
+     
+     
+      ;
+      return std::__unique(__first, __last,
+      __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    inline _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last,
+    _BinaryPredicate __binary_pred)
+    {
+     
+     
+      ;
+      return std::__unique(__first, __last,
+      __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+  template<typename _ForwardIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+    _OutputIterator
+    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
+    _OutputIterator __result, _BinaryPredicate __binary_pred,
+    forward_iterator_tag, output_iterator_tag)
+    {
+     
+      _ForwardIterator __next = __first;
+      *__result = *__first;
+      while (++__next != __last)
+ if (!__binary_pred(__first, __next))
+   {
+     __first = __next;
+     *++__result = *__first;
+   }
+      return ++__result;
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+    _OutputIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _OutputIterator __result, _BinaryPredicate __binary_pred,
+    input_iterator_tag, output_iterator_tag)
+    {
+     
+      typename iterator_traits<_InputIterator>::value_type __value = *__first;
+      __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
+ __rebound_pred
+ = __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
+      *__result = __value;
+      while (++__first != __last)
+ if (!__rebound_pred(__first, __value))
+   {
+     __value = *__first;
+     *++__result = __value;
+   }
+      return ++__result;
+    }
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _BinaryPredicate>
+    _ForwardIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _ForwardIterator __result, _BinaryPredicate __binary_pred,
+    input_iterator_tag, forward_iterator_tag)
+    {
+     
+      *__result = *__first;
+      while (++__first != __last)
+ if (!__binary_pred(__result, __first))
+   *++__result = *__first;
+      return ++__result;
+    }
+  template<typename _BidirectionalIterator>
+    void
+    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
+       bidirectional_iterator_tag)
+    {
+      while (true)
+ if (__first == __last || __first == --__last)
+   return;
+ else
+   {
+     std::iter_swap(__first, __last);
+     ++__first;
+   }
+    }
+  template<typename _RandomAccessIterator>
+    void
+    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       random_access_iterator_tag)
+    {
+      if (__first == __last)
+ return;
+      --__last;
+      while (__first < __last)
+ {
+   std::iter_swap(__first, __last);
+   ++__first;
+   --__last;
+ }
+    }
+  template<typename _BidirectionalIterator>
+    inline void
+    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
+    {
+     
+      ;
+      std::__reverse(__first, __last, std::__iterator_category(__first));
+    }
+  template<typename _BidirectionalIterator, typename _OutputIterator>
+    _OutputIterator
+    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
+   _OutputIterator __result)
+    {
+     
+     
+      ;
+      while (__first != __last)
+ {
+   --__last;
+   *__result = *__last;
+   ++__result;
+ }
+      return __result;
+    }
+  template<typename _EuclideanRingElement>
+    _EuclideanRingElement
+    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
+    {
+      while (__n != 0)
+ {
+   _EuclideanRingElement __t = __m % __n;
+   __m = __n;
+   __n = __t;
+ }
+      return __m;
+    }
+  inline namespace _V2
+  {
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    __rotate(_ForwardIterator __first,
+      _ForwardIterator __middle,
+      _ForwardIterator __last,
+      forward_iterator_tag)
+    {
+      if (__first == __middle)
+ return __last;
+      else if (__last == __middle)
+ return __first;
+      _ForwardIterator __first2 = __middle;
+      do
+ {
+   std::iter_swap(__first, __first2);
+   ++__first;
+   ++__first2;
+   if (__first == __middle)
+     __middle = __first2;
+ }
+      while (__first2 != __last);
+      _ForwardIterator __ret = __first;
+      __first2 = __middle;
+      while (__first2 != __last)
+ {
+   std::iter_swap(__first, __first2);
+   ++__first;
+   ++__first2;
+   if (__first == __middle)
+     __middle = __first2;
+   else if (__first2 == __last)
+     __first2 = __middle;
+ }
+      return __ret;
+    }
+  template<typename _BidirectionalIterator>
+    _BidirectionalIterator
+    __rotate(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+       bidirectional_iterator_tag)
+    {
+     
+      if (__first == __middle)
+ return __last;
+      else if (__last == __middle)
+ return __first;
+      std::__reverse(__first, __middle, bidirectional_iterator_tag());
+      std::__reverse(__middle, __last, bidirectional_iterator_tag());
+      while (__first != __middle && __middle != __last)
+ {
+   std::iter_swap(__first, --__last);
+   ++__first;
+ }
+      if (__first == __middle)
+ {
+   std::__reverse(__middle, __last, bidirectional_iterator_tag());
+   return __last;
+ }
+      else
+ {
+   std::__reverse(__first, __middle, bidirectional_iterator_tag());
+   return __first;
+ }
+    }
+  template<typename _RandomAccessIterator>
+    _RandomAccessIterator
+    __rotate(_RandomAccessIterator __first,
+      _RandomAccessIterator __middle,
+      _RandomAccessIterator __last,
+      random_access_iterator_tag)
+    {
+     
+      if (__first == __middle)
+ return __last;
+      else if (__last == __middle)
+ return __first;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      _Distance __n = __last - __first;
+      _Distance __k = __middle - __first;
+      if (__k == __n - __k)
+ {
+   std::swap_ranges(__first, __middle, __middle);
+   return __middle;
+ }
+      _RandomAccessIterator __p = __first;
+      _RandomAccessIterator __ret = __first + (__last - __middle);
+      for (;;)
+ {
+   if (__k < __n - __k)
+     {
+       if (__is_pod(_ValueType) && __k == 1)
+  {
+    _ValueType __t = std::move(*__p);
+    std::move(__p + 1, __p + __n, __p);
+    *(__p + __n - 1) = std::move(__t);
+    return __ret;
+  }
+       _RandomAccessIterator __q = __p + __k;
+       for (_Distance __i = 0; __i < __n - __k; ++ __i)
+  {
+    std::iter_swap(__p, __q);
+    ++__p;
+    ++__q;
+  }
+       __n %= __k;
+       if (__n == 0)
+  return __ret;
+       std::swap(__n, __k);
+       __k = __n - __k;
+     }
+   else
+     {
+       __k = __n - __k;
+       if (__is_pod(_ValueType) && __k == 1)
+  {
+    _ValueType __t = std::move(*(__p + __n - 1));
+    std::move_backward(__p, __p + __n - 1, __p + __n);
+    *__p = std::move(__t);
+    return __ret;
+  }
+       _RandomAccessIterator __q = __p + __n;
+       __p = __q - __k;
+       for (_Distance __i = 0; __i < __n - __k; ++ __i)
+  {
+    --__p;
+    --__q;
+    std::iter_swap(__p, __q);
+  }
+       __n %= __k;
+       if (__n == 0)
+  return __ret;
+       std::swap(__n, __k);
+     }
+ }
+    }
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    rotate(_ForwardIterator __first, _ForwardIterator __middle,
+    _ForwardIterator __last)
+    {
+     
+      ;
+      ;
+      return std::__rotate(__first, __middle, __last,
+      std::__iterator_category(__first));
+    }
+  }
+  template<typename _ForwardIterator, typename _OutputIterator>
+    inline _OutputIterator
+    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
+  _ForwardIterator __last, _OutputIterator __result)
+    {
+     
+     
+      ;
+      ;
+      return std::copy(__first, __middle,
+         std::copy(__middle, __last, __result));
+    }
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    __partition(_ForwardIterator __first, _ForwardIterator __last,
+  _Predicate __pred, forward_iterator_tag)
+    {
+      if (__first == __last)
+ return __first;
+      while (__pred(*__first))
+ if (++__first == __last)
+   return __first;
+      _ForwardIterator __next = __first;
+      while (++__next != __last)
+ if (__pred(*__next))
+   {
+     std::iter_swap(__first, __next);
+     ++__first;
+   }
+      return __first;
+    }
+  template<typename _BidirectionalIterator, typename _Predicate>
+    _BidirectionalIterator
+    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
+  _Predicate __pred, bidirectional_iterator_tag)
+    {
+      while (true)
+ {
+   while (true)
+     if (__first == __last)
+       return __first;
+     else if (__pred(*__first))
+       ++__first;
+     else
+       break;
+   --__last;
+   while (true)
+     if (__first == __last)
+       return __first;
+     else if (!bool(__pred(*__last)))
+       --__last;
+     else
+       break;
+   std::iter_swap(__first, __last);
+   ++__first;
+ }
+    }
+  template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
+    typename _Distance>
+    _ForwardIterator
+    __stable_partition_adaptive(_ForwardIterator __first,
+    _ForwardIterator __last,
+    _Predicate __pred, _Distance __len,
+    _Pointer __buffer,
+    _Distance __buffer_size)
+    {
+      if (__len == 1)
+ return __first;
+      if (__len <= __buffer_size)
+ {
+   _ForwardIterator __result1 = __first;
+   _Pointer __result2 = __buffer;
+   *__result2 = std::move(*__first);
+   ++__result2;
+   ++__first;
+   for (; __first != __last; ++__first)
+     if (__pred(__first))
+       {
+  *__result1 = std::move(*__first);
+  ++__result1;
+       }
+     else
+       {
+  *__result2 = std::move(*__first);
+  ++__result2;
+       }
+   std::move(__buffer, __result2, __result1);
+   return __result1;
+ }
+      _ForwardIterator __middle = __first;
+      std::advance(__middle, __len / 2);
+      _ForwardIterator __left_split =
+ std::__stable_partition_adaptive(__first, __middle, __pred,
+      __len / 2, __buffer,
+      __buffer_size);
+      _Distance __right_len = __len - __len / 2;
+      _ForwardIterator __right_split =
+ std::__find_if_not_n(__middle, __right_len, __pred);
+      if (__right_len)
+ __right_split =
+   std::__stable_partition_adaptive(__right_split, __last, __pred,
+        __right_len,
+        __buffer, __buffer_size);
+      std::rotate(__left_split, __middle, __right_split);
+      std::advance(__left_split, std::distance(__middle, __right_split));
+      return __left_split;
+    }
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    __stable_partition(_ForwardIterator __first, _ForwardIterator __last,
+         _Predicate __pred)
+    {
+      __first = std::__find_if_not(__first, __last, __pred);
+      if (__first == __last)
+ return __first;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+      _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last);
+      return
+ std::__stable_partition_adaptive(__first, __last, __pred,
+      _DistanceType(__buf.requested_size()),
+      __buf.begin(),
+      _DistanceType(__buf.size()));
+    }
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+     
+     
+      ;
+      return std::__stable_partition(__first, __last,
+         __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __heap_select(_RandomAccessIterator __first,
+    _RandomAccessIterator __middle,
+    _RandomAccessIterator __last, _Compare __comp)
+    {
+      std::__make_heap(__first, __middle, __comp);
+      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
+ if (__comp(__i, __first))
+   std::__pop_heap(__first, __middle, __i, __comp);
+    }
+  template<typename _InputIterator, typename _RandomAccessIterator,
+    typename _Compare>
+    _RandomAccessIterator
+    __partial_sort_copy(_InputIterator __first, _InputIterator __last,
+   _RandomAccessIterator __result_first,
+   _RandomAccessIterator __result_last,
+   _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _InputValueType;
+      typedef iterator_traits<_RandomAccessIterator> _RItTraits;
+      typedef typename _RItTraits::difference_type _DistanceType;
+      if (__result_first == __result_last)
+ return __result_last;
+      _RandomAccessIterator __result_real_last = __result_first;
+      while (__first != __last && __result_real_last != __result_last)
+ {
+   *__result_real_last = *__first;
+   ++__result_real_last;
+   ++__first;
+ }
+      std::__make_heap(__result_first, __result_real_last, __comp);
+      while (__first != __last)
+ {
+   if (__comp(__first, __result_first))
+     std::__adjust_heap(__result_first, _DistanceType(0),
+          _DistanceType(__result_real_last
+          - __result_first),
+          _InputValueType(*__first), __comp);
+   ++__first;
+ }
+      std::__sort_heap(__result_first, __result_real_last, __comp);
+      return __result_real_last;
+    }
+  template<typename _InputIterator, typename _RandomAccessIterator>
+    inline _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+        _RandomAccessIterator __result_first,
+        _RandomAccessIterator __result_last)
+    {
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      return std::__partial_sort_copy(__first, __last,
+          __result_first, __result_last,
+          __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _InputIterator, typename _RandomAccessIterator,
+    typename _Compare>
+    inline _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+        _RandomAccessIterator __result_first,
+        _RandomAccessIterator __result_last,
+        _Compare __comp)
+    {
+     
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      return std::__partial_sort_copy(__first, __last,
+          __result_first, __result_last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __unguarded_linear_insert(_RandomAccessIterator __last,
+         _Compare __comp)
+    {
+      typename iterator_traits<_RandomAccessIterator>::value_type
+ __val = std::move(*__last);
+      _RandomAccessIterator __next = __last;
+      --__next;
+      while (__comp(__val, __next))
+ {
+   *__last = std::move(*__next);
+   __last = __next;
+   --__next;
+ }
+      *__last = std::move(__val);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __insertion_sort(_RandomAccessIterator __first,
+       _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__first == __last) return;
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ {
+   if (__comp(__i, __first))
+     {
+       typename iterator_traits<_RandomAccessIterator>::value_type
+  __val = std::move(*__i);
+       std::move_backward(__first, __i, __i + 1);
+       *__first = std::move(__val);
+     }
+   else
+     std::__unguarded_linear_insert(__i,
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __unguarded_insertion_sort(_RandomAccessIterator __first,
+          _RandomAccessIterator __last, _Compare __comp)
+    {
+      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
+ std::__unguarded_linear_insert(__i,
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+  enum { _S_threshold = 16 };
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __final_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first > int(_S_threshold))
+ {
+   std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
+   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
+       __comp);
+ }
+      else
+ std::__insertion_sort(__first, __last, __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    _RandomAccessIterator
+    __unguarded_partition(_RandomAccessIterator __first,
+     _RandomAccessIterator __last,
+     _RandomAccessIterator __pivot, _Compare __comp)
+    {
+      while (true)
+ {
+   while (__comp(__first, __pivot))
+     ++__first;
+   --__last;
+   while (__comp(__pivot, __last))
+     --__last;
+   if (!(__first < __last))
+     return __first;
+   std::iter_swap(__first, __last);
+   ++__first;
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline _RandomAccessIterator
+    __unguarded_partition_pivot(_RandomAccessIterator __first,
+    _RandomAccessIterator __last, _Compare __comp)
+    {
+      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
+      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
+      __comp);
+      return std::__unguarded_partition(__first + 1, __last, __first, __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __partial_sort(_RandomAccessIterator __first,
+     _RandomAccessIterator __middle,
+     _RandomAccessIterator __last,
+     _Compare __comp)
+    {
+      std::__heap_select(__first, __middle, __last, __comp);
+      std::__sort_heap(__first, __middle, __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
+    void
+    __introsort_loop(_RandomAccessIterator __first,
+       _RandomAccessIterator __last,
+       _Size __depth_limit, _Compare __comp)
+    {
+      while (__last - __first > int(_S_threshold))
+ {
+   if (__depth_limit == 0)
+     {
+       std::__partial_sort(__first, __last, __last, __comp);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last, __comp);
+   std::__introsort_loop(__cut, __last, __depth_limit, __comp);
+   __last = __cut;
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    _Compare __comp)
+    {
+      if (__first != __last)
+ {
+   std::__introsort_loop(__first, __last,
+    std::__lg(__last - __first) * 2,
+    __comp);
+   std::__final_insertion_sort(__first, __last, __comp);
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
+    void
+    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+    _RandomAccessIterator __last, _Size __depth_limit,
+    _Compare __comp)
+    {
+      while (__last - __first > 3)
+ {
+   if (__depth_limit == 0)
+     {
+       std::__heap_select(__first, __nth + 1, __last, __comp);
+       std::iter_swap(__first, __nth);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last, __comp);
+   if (__cut <= __nth)
+     __first = __cut;
+   else
+     __last = __cut;
+ }
+      std::__insertion_sort(__first, __last, __comp);
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    inline _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+     
+     
+      ;
+      return std::__lower_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_comp_val(__comp));
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    __upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+      _DistanceType __len = std::distance(__first, __last);
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp(__val, __middle))
+     __len = __half;
+   else
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+ }
+      return __first;
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+     
+     
+      ;
+      return std::__upper_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__val_less_iter());
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    inline _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+     
+     
+      ;
+      return std::__upper_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+  template<typename _ForwardIterator, typename _Tp,
+    typename _CompareItTp, typename _CompareTpIt>
+    pair<_ForwardIterator, _ForwardIterator>
+    __equal_range(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val,
+    _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+      _DistanceType __len = std::distance(__first, __last);
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp_it_val(__middle, __val))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else if (__comp_val_it(__val, __middle))
+     __len = __half;
+   else
+     {
+       _ForwardIterator __left
+  = std::__lower_bound(__first, __middle, __val, __comp_it_val);
+       std::advance(__first, __len);
+       _ForwardIterator __right
+  = std::__upper_bound(++__middle, __first, __val, __comp_val_it);
+       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
+     }
+ }
+      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    inline pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+     
+     
+     
+      ;
+      ;
+      return std::__equal_range(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_less_val(),
+    __gnu_cxx::__ops::__val_less_iter());
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    inline pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+     
+     
+     
+      ;
+      ;
+      return std::__equal_range(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_comp_val(__comp),
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val)
+    {
+     
+     
+      ;
+      ;
+      _ForwardIterator __i
+ = std::__lower_bound(__first, __last, __val,
+        __gnu_cxx::__ops::__iter_less_val());
+      return __i != __last && !(__val < *__i);
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val, _Compare __comp)
+    {
+     
+     
+      ;
+      ;
+      _ForwardIterator __i
+ = std::__lower_bound(__first, __last, __val,
+        __gnu_cxx::__ops::__iter_comp_val(__comp));
+      return __i != __last && !bool(__comp(__val, *__i));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    void
+    __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first2, __first1))
+     {
+       *__result = std::move(*__first2);
+       ++__first2;
+     }
+   else
+     {
+       *__result = std::move(*__first1);
+       ++__first1;
+     }
+   ++__result;
+ }
+      if (__first1 != __last1)
+ std::move(__first1, __last1, __result);
+    }
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _BidirectionalIterator3, typename _Compare>
+    void
+    __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
+       _BidirectionalIterator1 __last1,
+       _BidirectionalIterator2 __first2,
+       _BidirectionalIterator2 __last2,
+       _BidirectionalIterator3 __result,
+       _Compare __comp)
+    {
+      if (__first1 == __last1)
+ {
+   std::move_backward(__first2, __last2, __result);
+   return;
+ }
+      else if (__first2 == __last2)
+ return;
+      --__last1;
+      --__last2;
+      while (true)
+ {
+   if (__comp(__last2, __last1))
+     {
+       *--__result = std::move(*__last1);
+       if (__first1 == __last1)
+  {
+    std::move_backward(__first2, ++__last2, __result);
+    return;
+  }
+       --__last1;
+     }
+   else
+     {
+       *--__result = std::move(*__last2);
+       if (__first2 == __last2)
+  return;
+       --__last2;
+     }
+ }
+    }
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _Distance>
+    _BidirectionalIterator1
+    __rotate_adaptive(_BidirectionalIterator1 __first,
+        _BidirectionalIterator1 __middle,
+        _BidirectionalIterator1 __last,
+        _Distance __len1, _Distance __len2,
+        _BidirectionalIterator2 __buffer,
+        _Distance __buffer_size)
+    {
+      _BidirectionalIterator2 __buffer_end;
+      if (__len1 > __len2 && __len2 <= __buffer_size)
+ {
+   if (__len2)
+     {
+       __buffer_end = std::move(__middle, __last, __buffer);
+       std::move_backward(__first, __middle, __last);
+       return std::move(__buffer, __buffer_end, __first);
+     }
+   else
+     return __first;
+ }
+      else if (__len1 <= __buffer_size)
+ {
+   if (__len1)
+     {
+       __buffer_end = std::move(__first, __middle, __buffer);
+       std::move(__middle, __last, __first);
+       return std::move_backward(__buffer, __buffer_end, __last);
+     }
+   else
+     return __last;
+ }
+      else
+ {
+   std::rotate(__first, __middle, __last);
+   std::advance(__first, std::distance(__middle, __last));
+   return __first;
+ }
+    }
+  template<typename _BidirectionalIterator, typename _Distance,
+    typename _Pointer, typename _Compare>
+    void
+    __merge_adaptive(_BidirectionalIterator __first,
+       _BidirectionalIterator __middle,
+       _BidirectionalIterator __last,
+       _Distance __len1, _Distance __len2,
+       _Pointer __buffer, _Distance __buffer_size,
+       _Compare __comp)
+    {
+      if (__len1 <= __len2 && __len1 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::move(__first, __middle, __buffer);
+   std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
+         __first, __comp);
+ }
+      else if (__len2 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::move(__middle, __last, __buffer);
+   std::__move_merge_adaptive_backward(__first, __middle, __buffer,
+           __buffer_end, __last, __comp);
+ }
+      else
+ {
+   _BidirectionalIterator __first_cut = __first;
+   _BidirectionalIterator __second_cut = __middle;
+   _Distance __len11 = 0;
+   _Distance __len22 = 0;
+   if (__len1 > __len2)
+     {
+       __len11 = __len1 / 2;
+       std::advance(__first_cut, __len11);
+       __second_cut
+  = std::__lower_bound(__middle, __last, *__first_cut,
+         __gnu_cxx::__ops::__iter_comp_val(__comp));
+       __len22 = std::distance(__middle, __second_cut);
+     }
+   else
+     {
+       __len22 = __len2 / 2;
+       std::advance(__second_cut, __len22);
+       __first_cut
+  = std::__upper_bound(__first, __middle, *__second_cut,
+         __gnu_cxx::__ops::__val_comp_iter(__comp));
+       __len11 = std::distance(__first, __first_cut);
+     }
+   _BidirectionalIterator __new_middle
+     = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
+         __len1 - __len11, __len22, __buffer,
+         __buffer_size);
+   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
+    __len22, __buffer, __buffer_size, __comp);
+   std::__merge_adaptive(__new_middle, __second_cut, __last,
+    __len1 - __len11,
+    __len2 - __len22, __buffer,
+    __buffer_size, __comp);
+ }
+    }
+  template<typename _BidirectionalIterator, typename _Distance,
+    typename _Compare>
+    void
+    __merge_without_buffer(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+      _Distance __len1, _Distance __len2,
+      _Compare __comp)
+    {
+      if (__len1 == 0 || __len2 == 0)
+ return;
+      if (__len1 + __len2 == 2)
+ {
+   if (__comp(__middle, __first))
+     std::iter_swap(__first, __middle);
+   return;
+ }
+      _BidirectionalIterator __first_cut = __first;
+      _BidirectionalIterator __second_cut = __middle;
+      _Distance __len11 = 0;
+      _Distance __len22 = 0;
+      if (__len1 > __len2)
+ {
+   __len11 = __len1 / 2;
+   std::advance(__first_cut, __len11);
+   __second_cut
+     = std::__lower_bound(__middle, __last, *__first_cut,
+     __gnu_cxx::__ops::__iter_comp_val(__comp));
+   __len22 = std::distance(__middle, __second_cut);
+ }
+      else
+ {
+   __len22 = __len2 / 2;
+   std::advance(__second_cut, __len22);
+   __first_cut
+     = std::__upper_bound(__first, __middle, *__second_cut,
+     __gnu_cxx::__ops::__val_comp_iter(__comp));
+   __len11 = std::distance(__first, __first_cut);
+ }
+      std::rotate(__first_cut, __middle, __second_cut);
+      _BidirectionalIterator __new_middle = __first_cut;
+      std::advance(__new_middle, std::distance(__middle, __second_cut));
+      std::__merge_without_buffer(__first, __first_cut, __new_middle,
+      __len11, __len22, __comp);
+      std::__merge_without_buffer(__new_middle, __second_cut, __last,
+      __len1 - __len11, __len2 - __len22, __comp);
+    }
+  template<typename _BidirectionalIterator, typename _Compare>
+    void
+    __inplace_merge(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+      _Compare __comp)
+    {
+      typedef typename iterator_traits<_BidirectionalIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
+   _DistanceType;
+      if (__first == __middle || __middle == __last)
+ return;
+      const _DistanceType __len1 = std::distance(__first, __middle);
+      const _DistanceType __len2 = std::distance(__middle, __last);
+      typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
+      _TmpBuf __buf(__first, __last);
+      if (__buf.begin() == 0)
+ std::__merge_without_buffer
+   (__first, __middle, __last, __len1, __len2, __comp);
+      else
+ std::__merge_adaptive
+   (__first, __middle, __last, __len1, __len2, __buf.begin(),
+    _DistanceType(__buf.size()), __comp);
+    }
+  template<typename _BidirectionalIterator>
+    inline void
+    inplace_merge(_BidirectionalIterator __first,
+    _BidirectionalIterator __middle,
+    _BidirectionalIterator __last)
+    {
+     
+     
+      ;
+      ;
+      ;
+      std::__inplace_merge(__first, __middle, __last,
+      __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _BidirectionalIterator, typename _Compare>
+    inline void
+    inplace_merge(_BidirectionalIterator __first,
+    _BidirectionalIterator __middle,
+    _BidirectionalIterator __last,
+    _Compare __comp)
+    {
+     
+     
+      ;
+      ;
+      ;
+      std::__inplace_merge(__first, __middle, __last,
+      __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __move_merge(_InputIterator __first1, _InputIterator __last1,
+   _InputIterator __first2, _InputIterator __last2,
+   _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first2, __first1))
+     {
+       *__result = std::move(*__first2);
+       ++__first2;
+     }
+   else
+     {
+       *__result = std::move(*__first1);
+       ++__first1;
+     }
+   ++__result;
+ }
+      return std::move(__first2, __last2, std::move(__first1, __last1, __result));
+    }
+  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
+    typename _Distance, typename _Compare>
+    void
+    __merge_sort_loop(_RandomAccessIterator1 __first,
+        _RandomAccessIterator1 __last,
+        _RandomAccessIterator2 __result, _Distance __step_size,
+        _Compare __comp)
+    {
+      const _Distance __two_step = 2 * __step_size;
+      while (__last - __first >= __two_step)
+ {
+   __result = std::__move_merge(__first, __first + __step_size,
+           __first + __step_size,
+           __first + __two_step,
+           __result, __comp);
+   __first += __two_step;
+ }
+      __step_size = std::min(_Distance(__last - __first), __step_size);
+      std::__move_merge(__first, __first + __step_size,
+   __first + __step_size, __last, __result, __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Compare>
+    void
+    __chunk_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+      _Distance __chunk_size, _Compare __comp)
+    {
+      while (__last - __first >= __chunk_size)
+ {
+   std::__insertion_sort(__first, __first + __chunk_size, __comp);
+   __first += __chunk_size;
+ }
+      std::__insertion_sort(__first, __last, __comp);
+    }
+  enum { _S_chunk_size = 7 };
+  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
+    void
+    __merge_sort_with_buffer(_RandomAccessIterator __first,
+        _RandomAccessIterator __last,
+        _Pointer __buffer, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _Distance;
+      const _Distance __len = __last - __first;
+      const _Pointer __buffer_last = __buffer + __len;
+      _Distance __step_size = _S_chunk_size;
+      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
+      while (__step_size < __len)
+ {
+   std::__merge_sort_loop(__first, __last, __buffer,
+     __step_size, __comp);
+   __step_size *= 2;
+   std::__merge_sort_loop(__buffer, __buffer_last, __first,
+     __step_size, __comp);
+   __step_size *= 2;
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Pointer,
+    typename _Distance, typename _Compare>
+    void
+    __stable_sort_adaptive(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+      _Pointer __buffer, _Distance __buffer_size,
+      _Compare __comp)
+    {
+      const _Distance __len = (__last - __first + 1) / 2;
+      const _RandomAccessIterator __middle = __first + __len;
+      if (__len > __buffer_size)
+ {
+   std::__stable_sort_adaptive(__first, __middle, __buffer,
+          __buffer_size, __comp);
+   std::__stable_sort_adaptive(__middle, __last, __buffer,
+          __buffer_size, __comp);
+ }
+      else
+ {
+   std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
+   std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
+ }
+      std::__merge_adaptive(__first, __middle, __last,
+       _Distance(__middle - __first),
+       _Distance(__last - __middle),
+       __buffer, __buffer_size,
+       __comp);
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __inplace_stable_sort(_RandomAccessIterator __first,
+     _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first < 15)
+ {
+   std::__insertion_sort(__first, __last, __comp);
+   return;
+ }
+      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
+      std::__inplace_stable_sort(__first, __middle, __comp);
+      std::__inplace_stable_sort(__middle, __last, __comp);
+      std::__merge_without_buffer(__first, __middle, __last,
+      __middle - __first,
+      __last - __middle,
+      __comp);
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _Compare>
+    bool
+    __includes(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first2, __first1))
+   return false;
+ else if (__comp(__first1, __first2))
+   ++__first1;
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return __first2 == __last2;
+    }
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2)
+    {
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      ;
+      return std::__includes(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _Compare>
+    inline bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2,
+      _Compare __comp)
+    {
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      ;
+      return std::__includes(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _BidirectionalIterator, typename _Compare>
+    bool
+    __next_permutation(_BidirectionalIterator __first,
+         _BidirectionalIterator __last, _Compare __comp)
+    {
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (__comp(__i, __ii))
+     {
+       _BidirectionalIterator __j = __last;
+       while (!__comp(__i, --__j))
+  {}
+       std::iter_swap(__i, __j);
+       std::__reverse(__ii, __last,
+        std::__iterator_category(__first));
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::__reverse(__first, __last,
+        std::__iterator_category(__first));
+       return false;
+     }
+ }
+    }
+  template<typename _BidirectionalIterator>
+    inline bool
+    next_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last)
+    {
+     
+     
+      ;
+      ;
+      return std::__next_permutation
+ (__first, __last, __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _BidirectionalIterator, typename _Compare>
+    inline bool
+    next_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last, _Compare __comp)
+    {
+     
+     
+      ;
+      ;
+      return std::__next_permutation
+ (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _BidirectionalIterator, typename _Compare>
+    bool
+    __prev_permutation(_BidirectionalIterator __first,
+         _BidirectionalIterator __last, _Compare __comp)
+    {
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (__comp(__ii, __i))
+     {
+       _BidirectionalIterator __j = __last;
+       while (!__comp(--__j, __i))
+  {}
+       std::iter_swap(__i, __j);
+       std::__reverse(__ii, __last,
+        std::__iterator_category(__first));
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::__reverse(__first, __last,
+        std::__iterator_category(__first));
+       return false;
+     }
+ }
+    }
+  template<typename _BidirectionalIterator>
+    inline bool
+    prev_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last)
+    {
+     
+     
+      ;
+      ;
+      return std::__prev_permutation(__first, __last,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _BidirectionalIterator, typename _Compare>
+    inline bool
+    prev_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last, _Compare __comp)
+    {
+     
+     
+      ;
+      ;
+      return std::__prev_permutation(__first, __last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate, typename _Tp>
+    _OutputIterator
+    __replace_copy_if(_InputIterator __first, _InputIterator __last,
+        _OutputIterator __result,
+        _Predicate __pred, const _Tp& __new_value)
+    {
+      for (; __first != __last; ++__first, (void)++__result)
+ if (__pred(__first))
+   *__result = __new_value;
+ else
+   *__result = *__first;
+      return __result;
+    }
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    inline _OutputIterator
+    replace_copy(_InputIterator __first, _InputIterator __last,
+   _OutputIterator __result,
+   const _Tp& __old_value, const _Tp& __new_value)
+    {
+     
+     
+     
+      ;
+      return std::__replace_copy_if(__first, __last, __result,
+   __gnu_cxx::__ops::__iter_equals_val(__old_value),
+           __new_value);
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate, typename _Tp>
+    inline _OutputIterator
+    replace_copy_if(_InputIterator __first, _InputIterator __last,
+      _OutputIterator __result,
+      _Predicate __pred, const _Tp& __new_value)
+    {
+     
+     
+     
+      ;
+      return std::__replace_copy_if(__first, __last, __result,
+    __gnu_cxx::__ops::__pred_iter(__pred),
+           __new_value);
+    }
+  template<typename _InputIterator, typename _Predicate>
+    typename iterator_traits<_InputIterator>::difference_type
+    __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    {
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
+      for (; __first != __last; ++__first)
+ if (__pred(__first))
+   ++__n;
+      return __n;
+    }
+  template<typename _ForwardIterator>
+    inline bool
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last)
+    { return std::is_sorted_until(__first, __last) == __last; }
+  template<typename _ForwardIterator, typename _Compare>
+    inline bool
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last,
+       _Compare __comp)
+    { return std::is_sorted_until(__first, __last, __comp) == __last; }
+  template<typename _ForwardIterator, typename _Compare>
+    _ForwardIterator
+    __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
+        _Compare __comp)
+    {
+      if (__first == __last)
+ return __last;
+      _ForwardIterator __next = __first;
+      for (++__next; __next != __last; __first = __next, (void)++__next)
+ if (__comp(__next, __first))
+   return __next;
+      return __next;
+    }
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
+    {
+     
+     
+      ;
+      ;
+      return std::__is_sorted_until(__first, __last,
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _ForwardIterator, typename _Compare>
+    inline _ForwardIterator
+    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
+      _Compare __comp)
+    {
+     
+     
+      ;
+      ;
+      return std::__is_sorted_until(__first, __last,
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _Tp>
+    constexpr
+    inline pair<const _Tp&, const _Tp&>
+    minmax(const _Tp& __a, const _Tp& __b)
+    {
+     
+      return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
+         : pair<const _Tp&, const _Tp&>(__a, __b);
+    }
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline pair<const _Tp&, const _Tp&>
+    minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+      return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
+         : pair<const _Tp&, const _Tp&>(__a, __b);
+    }
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    pair<_ForwardIterator, _ForwardIterator>
+    __minmax_element(_ForwardIterator __first, _ForwardIterator __last,
+       _Compare __comp)
+    {
+      _ForwardIterator __next = __first;
+      if (__first == __last
+   || ++__next == __last)
+ return std::make_pair(__first, __first);
+      _ForwardIterator __min{}, __max{};
+      if (__comp(__next, __first))
+ {
+   __min = __next;
+   __max = __first;
+ }
+      else
+ {
+   __min = __first;
+   __max = __next;
+ }
+      __first = __next;
+      ++__first;
+      while (__first != __last)
+ {
+   __next = __first;
+   if (++__next == __last)
+     {
+       if (__comp(__first, __min))
+  __min = __first;
+       else if (!__comp(__first, __max))
+  __max = __first;
+       break;
+     }
+   if (__comp(__next, __first))
+     {
+       if (__comp(__next, __min))
+  __min = __next;
+       if (!__comp(__first, __max))
+  __max = __first;
+     }
+   else
+     {
+       if (__comp(__first, __min))
+  __min = __first;
+       if (!__comp(__next, __max))
+  __max = __next;
+     }
+   __first = __next;
+   ++__first;
+ }
+      return std::make_pair(__min, __max);
+    }
+  template<typename _ForwardIterator>
+    constexpr
+    inline pair<_ForwardIterator, _ForwardIterator>
+    minmax_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+     
+     
+      ;
+      ;
+      return std::__minmax_element(__first, __last,
+       __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    inline pair<_ForwardIterator, _ForwardIterator>
+    minmax_element(_ForwardIterator __first, _ForwardIterator __last,
+     _Compare __comp)
+    {
+     
+     
+      ;
+      ;
+      return std::__minmax_element(__first, __last,
+       __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _Tp>
+    constexpr
+    inline _Tp
+    min(initializer_list<_Tp> __l)
+    { return *std::min_element(__l.begin(), __l.end()); }
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline _Tp
+    min(initializer_list<_Tp> __l, _Compare __comp)
+    { return *std::min_element(__l.begin(), __l.end(), __comp); }
+  template<typename _Tp>
+    constexpr
+    inline _Tp
+    max(initializer_list<_Tp> __l)
+    { return *std::max_element(__l.begin(), __l.end()); }
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline _Tp
+    max(initializer_list<_Tp> __l, _Compare __comp)
+    { return *std::max_element(__l.begin(), __l.end(), __comp); }
+  template<typename _Tp>
+    constexpr
+    inline pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp> __l)
+    {
+      pair<const _Tp*, const _Tp*> __p =
+ std::minmax_element(__l.begin(), __l.end());
+      return std::make_pair(*__p.first, *__p.second);
+    }
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp> __l, _Compare __comp)
+    {
+      pair<const _Tp*, const _Tp*> __p =
+ std::minmax_element(__l.begin(), __l.end(), __comp);
+      return std::make_pair(*__p.first, *__p.second);
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    bool
+    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+       _ForwardIterator2 __first2, _BinaryPredicate __pred)
+    {
+      for (; __first1 != __last1; ++__first1, (void)++__first2)
+ if (!__pred(__first1, __first2))
+   break;
+      if (__first1 == __last1)
+ return true;
+      _ForwardIterator2 __last2 = __first2;
+      std::advance(__last2, std::distance(__first1, __last1));
+      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
+ {
+   if (__scan != std::__find_if(__first1, __scan,
+     __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
+     continue;
+   auto __matches
+     = std::__count_if(__first2, __last2,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
+   if (0 == __matches ||
+       std::__count_if(__scan, __last1,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
+       != __matches)
+     return false;
+ }
+      return true;
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2)
+    {
+     
+     
+     
+      ;
+      return std::__is_permutation(__first1, __last1, __first2,
+       __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2, _BinaryPredicate __pred)
+    {
+     
+     
+     
+      ;
+      return std::__is_permutation(__first1, __last1, __first2,
+       __gnu_cxx::__ops::__iter_comp_iter(__pred));
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    bool
+    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+       _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+       _BinaryPredicate __pred)
+    {
+      using _Cat1
+ = typename iterator_traits<_ForwardIterator1>::iterator_category;
+      using _Cat2
+ = typename iterator_traits<_ForwardIterator2>::iterator_category;
+      using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
+      using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
+      constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
+      if (__ra_iters)
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 != __d2)
+     return false;
+ }
+      for (; __first1 != __last1 && __first2 != __last2;
+   ++__first1, (void)++__first2)
+ if (!__pred(__first1, __first2))
+   break;
+      if (__ra_iters)
+ {
+   if (__first1 == __last1)
+     return true;
+ }
+      else
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 == 0 && __d2 == 0)
+     return true;
+   if (__d1 != __d2)
+     return false;
+ }
+      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
+ {
+   if (__scan != std::__find_if(__first1, __scan,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
+     continue;
+   auto __matches = std::__count_if(__first2, __last2,
+  __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
+   if (0 == __matches
+       || std::__count_if(__scan, __last1,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
+       != __matches)
+     return false;
+ }
+      return true;
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+      ;
+      ;
+      return
+ std::__is_permutation(__first1, __last1, __first2, __last2,
+         __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+     _BinaryPredicate __pred)
+    {
+      ;
+      ;
+      return std::__is_permutation(__first1, __last1, __first2, __last2,
+       __gnu_cxx::__ops::__iter_comp_iter(__pred));
+    }
+  template<typename _Tp>
+    constexpr const _Tp&
+    clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi)
+    {
+      ;
+      return (__val < __lo) ? __lo : (__hi < __val) ? __hi : __val;
+    }
+  template<typename _Tp, typename _Compare>
+    constexpr const _Tp&
+    clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
+    {
+      ;
+      return __comp(__val, __lo) ? __lo : __comp(__hi, __val) ? __hi : __val;
+    }
+  template<typename _IntType, typename _UniformRandomBitGenerator>
+    pair<_IntType, _IntType>
+    __gen_two_uniform_ints(_IntType __b0, _IntType __b1,
+      _UniformRandomBitGenerator&& __g)
+    {
+      _IntType __x
+ = uniform_int_distribution<_IntType>{0, (__b0 * __b1) - 1}(__g);
+      return std::make_pair(__x / __b1, __x % __b1);
+    }
+  template<typename _RandomAccessIterator,
+    typename _UniformRandomNumberGenerator>
+    void
+    shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
+     _UniformRandomNumberGenerator&& __g)
+    {
+     
+      ;
+      if (__first == __last)
+ return;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+      typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
+      typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
+      typedef typename __distr_type::param_type __p_type;
+      typedef typename remove_reference<_UniformRandomNumberGenerator>::type
+ _Gen;
+      typedef typename common_type<typename _Gen::result_type, __ud_type>::type
+ __uc_type;
+      const __uc_type __urngrange = __g.max() - __g.min();
+      const __uc_type __urange = __uc_type(__last - __first);
+      if (__urngrange / __urange >= __urange)
+      {
+ _RandomAccessIterator __i = __first + 1;
+ if ((__urange % 2) == 0)
+ {
+   __distr_type __d{0, 1};
+   std::iter_swap(__i++, __first + __d(__g));
+ }
+ while (__i != __last)
+ {
+   const __uc_type __swap_range = __uc_type(__i - __first) + 1;
+   const pair<__uc_type, __uc_type> __pospos =
+     __gen_two_uniform_ints(__swap_range, __swap_range + 1, __g);
+   std::iter_swap(__i++, __first + __pospos.first);
+   std::iter_swap(__i++, __first + __pospos.second);
+ }
+ return;
+      }
+      __distr_type __d;
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
+    }
+
+  template<typename _InputIterator, typename _Function>
+    _Function
+    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
+    {
+     
+      ;
+      for (; __first != __last; ++__first)
+ __f(*__first);
+      return __f;
+    }
+  template<typename _InputIterator, typename _Tp>
+    inline _InputIterator
+    find(_InputIterator __first, _InputIterator __last,
+  const _Tp& __val)
+    {
+     
+     
+      ;
+      return std::__find_if(__first, __last,
+       __gnu_cxx::__ops::__iter_equals_val(__val));
+    }
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    find_if(_InputIterator __first, _InputIterator __last,
+     _Predicate __pred)
+    {
+     
+     
+      ;
+      return std::__find_if(__first, __last,
+       __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+  template<typename _InputIterator, typename _ForwardIterator>
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+    _ForwardIterator __first2, _ForwardIterator __last2)
+    {
+     
+     
+     
+      ;
+      ;
+      for (; __first1 != __last1; ++__first1)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+   if (*__first1 == *__iter)
+     return __first1;
+      return __last1;
+    }
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _BinaryPredicate>
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+    _ForwardIterator __first2, _ForwardIterator __last2,
+    _BinaryPredicate __comp)
+    {
+     
+     
+     
+      ;
+      ;
+      for (; __first1 != __last1; ++__first1)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+   if (__comp(*__first1, *__iter))
+     return __first1;
+      return __last1;
+    }
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
+    {
+     
+     
+      ;
+      return std::__adjacent_find(__first, __last,
+      __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
+    _BinaryPredicate __binary_pred)
+    {
+     
+     
+      ;
+      return std::__adjacent_find(__first, __last,
+   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+  template<typename _InputIterator, typename _Tp>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
+    {
+     
+     
+      ;
+      return std::__count_if(__first, __last,
+        __gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+  template<typename _InputIterator, typename _Predicate>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    {
+     
+     
+      ;
+      return std::__count_if(__first, __last,
+        __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+     
+     
+     
+      ;
+      ;
+      return std::__search(__first1, __last1, __first2, __last2,
+      __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    inline _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+    _BinaryPredicate __predicate)
+    {
+     
+     
+     
+      ;
+      ;
+      return std::__search(__first1, __last1, __first2, __last2,
+      __gnu_cxx::__ops::__iter_comp_iter(__predicate));
+    }
+  template<typename _ForwardIterator, typename _Integer, typename _Tp>
+    inline _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+      _Integer __count, const _Tp& __val)
+    {
+     
+     
+      ;
+      return std::__search_n(__first, __last, __count,
+        __gnu_cxx::__ops::__iter_equals_val(__val));
+    }
+  template<typename _ForwardIterator, typename _Integer, typename _Tp,
+    typename _BinaryPredicate>
+    inline _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+      _Integer __count, const _Tp& __val,
+      _BinaryPredicate __binary_pred)
+    {
+     
+     
+      ;
+      return std::__search_n(__first, __last, __count,
+  __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
+    }
+  template<typename _ForwardIterator, typename _Searcher>
+    inline _ForwardIterator
+    search(_ForwardIterator __first, _ForwardIterator __last,
+    const _Searcher& __searcher)
+    { return __searcher(__first, __last).first; }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _UnaryOperation>
+    _OutputIterator
+    transform(_InputIterator __first, _InputIterator __last,
+       _OutputIterator __result, _UnaryOperation __unary_op)
+    {
+     
+     
+      ;
+      for (; __first != __last; ++__first, (void)++__result)
+ *__result = __unary_op(*__first);
+      return __result;
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _BinaryOperation>
+    _OutputIterator
+    transform(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _OutputIterator __result,
+       _BinaryOperation __binary_op)
+    {
+     
+     
+     
+      ;
+      for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
+ *__result = __binary_op(*__first1, *__first2);
+      return __result;
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    void
+    replace(_ForwardIterator __first, _ForwardIterator __last,
+     const _Tp& __old_value, const _Tp& __new_value)
+    {
+     
+     
+     
+      ;
+      for (; __first != __last; ++__first)
+ if (*__first == __old_value)
+   *__first = __new_value;
+    }
+  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
+    void
+    replace_if(_ForwardIterator __first, _ForwardIterator __last,
+        _Predicate __pred, const _Tp& __new_value)
+    {
+     
+     
+     
+      ;
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   *__first = __new_value;
+    }
+  template<typename _ForwardIterator, typename _Generator>
+    void
+    generate(_ForwardIterator __first, _ForwardIterator __last,
+      _Generator __gen)
+    {
+     
+     
+      ;
+      for (; __first != __last; ++__first)
+ *__first = __gen();
+    }
+  template<typename _OutputIterator, typename _Size, typename _Generator>
+    _OutputIterator
+    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
+    {
+     
+      for (__decltype(__n + 0) __niter = __n;
+    __niter > 0; --__niter, (void) ++__first)
+ *__first = __gen();
+      return __first;
+    }
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result)
+    {
+     
+     
+     
+      ;
+      if (__first == __last)
+ return __result;
+      return std::__unique_copy(__first, __last, __result,
+    __gnu_cxx::__ops::__iter_equal_to_iter(),
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result,
+  _BinaryPredicate __binary_pred)
+    {
+     
+     
+      ;
+      if (__first == __last)
+ return __result;
+      return std::__unique_copy(__first, __last, __result,
+   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+     
+      ;
+      if (__first != __last)
+ for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+   {
+     _RandomAccessIterator __j = __first
+     + std::rand() % ((__i - __first) + 1);
+     if (__i != __j)
+       std::iter_swap(__i, __j);
+   }
+    }
+  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
+    void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
+     _RandomNumberGenerator&& __rand)
+    {
+     
+      ;
+      if (__first == __last)
+ return;
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ {
+   _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
+   if (__i != __j)
+     std::iter_swap(__i, __j);
+ }
+    }
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    partition(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+     
+     
+      ;
+      return std::__partition(__first, __last, __pred,
+         std::__iterator_category(__first));
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+   _RandomAccessIterator __middle,
+   _RandomAccessIterator __last)
+    {
+     
+     
+      ;
+      ;
+      ;
+      std::__partial_sort(__first, __middle, __last,
+     __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+   _RandomAccessIterator __middle,
+   _RandomAccessIterator __last,
+   _Compare __comp)
+    {
+     
+     
+      ;
+      ;
+      ;
+      std::__partial_sort(__first, __middle, __last,
+     __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+  _RandomAccessIterator __last)
+    {
+     
+     
+      ;
+      ;
+      ;
+      if (__first == __last || __nth == __last)
+ return;
+      std::__introselect(__first, __nth, __last,
+    std::__lg(__last - __first) * 2,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+  _RandomAccessIterator __last, _Compare __comp)
+    {
+     
+     
+      ;
+      ;
+      ;
+      if (__first == __last || __nth == __last)
+ return;
+      std::__introselect(__first, __nth, __last,
+    std::__lg(__last - __first) * 2,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+     
+     
+      ;
+      ;
+      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+     
+     
+      ;
+      ;
+      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    __merge(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first2, __first1))
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result)
+    {
+     
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      ;
+      return std::__merge(__first1, __last1,
+         __first2, __last2, __result,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result, _Compare __comp)
+    {
+     
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      ;
+      return std::__merge(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+      typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
+      _TmpBuf __buf(__first, __last);
+      if (__buf.begin() == 0)
+ std::__inplace_stable_sort(__first, __last, __comp);
+      else
+ std::__stable_sort_adaptive(__first, __last, __buf.begin(),
+        _DistanceType(__buf.size()), __comp);
+    }
+  template<typename _RandomAccessIterator>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+     
+     
+      ;
+      ;
+      std::__stable_sort(__first, __last,
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+     
+     
+      ;
+      ;
+      std::__stable_sort(__first, __last,
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+  _InputIterator2 __first2, _InputIterator2 __last2,
+  _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first1, __first2))
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   else if (__comp(__first2, __first1))
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+       ++__first2;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result)
+    {
+     
+     
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      ;
+      return std::__set_union(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+     
+     
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      ;
+      return std::__set_union(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+         _InputIterator2 __first2, _InputIterator2 __last2,
+         _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first1, __first2))
+   ++__first1;
+ else if (__comp(__first2, __first1))
+   ++__first2;
+ else
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__first2;
+     ++__result;
+   }
+      return __result;
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result)
+    {
+     
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      ;
+      return std::__set_intersection(__first1, __last1,
+         __first2, __last2, __result,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+     
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      ;
+      return std::__set_intersection(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first1, __first2))
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (__comp(__first2, __first1))
+   ++__first2;
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first1, __last1, __result);
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result)
+    {
+     
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      ;
+      return std::__set_difference(__first1, __last1,
+       __first2, __last2, __result,
+       __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+     
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      ;
+      return std::__set_difference(__first1, __last1,
+       __first2, __last2, __result,
+       __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __set_symmetric_difference(_InputIterator1 __first1,
+          _InputIterator1 __last1,
+          _InputIterator2 __first2,
+          _InputIterator2 __last2,
+          _OutputIterator __result,
+          _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first1, __first2))
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (__comp(__first2, __first1))
+   {
+     *__result = *__first2;
+     ++__first2;
+     ++__result;
+   }
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _OutputIterator __result)
+    {
+     
+     
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      ;
+      return std::__set_symmetric_difference(__first1, __last1,
+     __first2, __last2, __result,
+     __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _OutputIterator __result,
+        _Compare __comp)
+    {
+     
+     
+     
+     
+     
+     
+      ;
+      ;
+      ;
+      ;
+      return std::__set_symmetric_difference(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    _ForwardIterator
+    __min_element(_ForwardIterator __first, _ForwardIterator __last,
+    _Compare __comp)
+    {
+      if (__first == __last)
+ return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (__comp(__first, __result))
+   __result = __first;
+      return __result;
+    }
+  template<typename _ForwardIterator>
+    constexpr
+    _ForwardIterator
+    inline min_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+     
+     
+      ;
+      ;
+      return std::__min_element(__first, __last,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    inline _ForwardIterator
+    min_element(_ForwardIterator __first, _ForwardIterator __last,
+  _Compare __comp)
+    {
+     
+     
+      ;
+      ;
+      return std::__min_element(__first, __last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    _ForwardIterator
+    __max_element(_ForwardIterator __first, _ForwardIterator __last,
+    _Compare __comp)
+    {
+      if (__first == __last) return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (__comp(__result, __first))
+   __result = __first;
+      return __result;
+    }
+  template<typename _ForwardIterator>
+    constexpr
+    inline _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+     
+     
+      ;
+      ;
+      return std::__max_element(__first, __last,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    inline _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last,
+  _Compare __comp)
+    {
+     
+     
+      ;
+      ;
+      return std::__max_element(__first, __last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+  template<typename _InputIterator, typename _RandomAccessIterator,
+           typename _Size, typename _UniformRandomBitGenerator>
+    _RandomAccessIterator
+    __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
+      _RandomAccessIterator __out, random_access_iterator_tag,
+      _Size __n, _UniformRandomBitGenerator&& __g)
+    {
+      using __distrib_type = uniform_int_distribution<_Size>;
+      using __param_type = typename __distrib_type::param_type;
+      __distrib_type __d{};
+      _Size __sample_sz = 0;
+      while (__first != __last && __sample_sz != __n)
+ {
+   __out[__sample_sz++] = *__first;
+   ++__first;
+ }
+      for (auto __pop_sz = __sample_sz; __first != __last;
+   ++__first, (void) ++__pop_sz)
+ {
+   const auto __k = __d(__g, __param_type{0, __pop_sz});
+   if (__k < __n)
+     __out[__k] = *__first;
+ }
+      return __out + __sample_sz;
+    }
+  template<typename _ForwardIterator, typename _OutputIterator, typename _Cat,
+           typename _Size, typename _UniformRandomBitGenerator>
+    _OutputIterator
+    __sample(_ForwardIterator __first, _ForwardIterator __last,
+      forward_iterator_tag,
+      _OutputIterator __out, _Cat,
+      _Size __n, _UniformRandomBitGenerator&& __g)
+    {
+      using __distrib_type = uniform_int_distribution<_Size>;
+      using __param_type = typename __distrib_type::param_type;
+      using _USize = make_unsigned_t<_Size>;
+      using _Gen = remove_reference_t<_UniformRandomBitGenerator>;
+      using __uc_type = common_type_t<typename _Gen::result_type, _USize>;
+      if (__first == __last)
+ return __out;
+      __distrib_type __d{};
+      _Size __unsampled_sz = std::distance(__first, __last);
+      __n = std::min(__n, __unsampled_sz);
+      const __uc_type __urngrange = __g.max() - __g.min();
+      if (__urngrange / __uc_type(__unsampled_sz) >= __uc_type(__unsampled_sz))
+        {
+   while (__n != 0 && __unsampled_sz >= 2)
+     {
+       const pair<_Size, _Size> __p =
+  __gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g);
+       --__unsampled_sz;
+       if (__p.first < __n)
+  {
+    *__out++ = *__first;
+    --__n;
+  }
+       ++__first;
+       if (__n == 0) break;
+       --__unsampled_sz;
+       if (__p.second < __n)
+  {
+    *__out++ = *__first;
+    --__n;
+  }
+       ++__first;
+     }
+        }
+      for (; __n != 0; ++__first)
+ if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
+   {
+     *__out++ = *__first;
+     --__n;
+   }
+      return __out;
+    }
+  template<typename _PopulationIterator, typename _SampleIterator,
+           typename _Distance, typename _UniformRandomBitGenerator>
+    _SampleIterator
+    sample(_PopulationIterator __first, _PopulationIterator __last,
+    _SampleIterator __out, _Distance __n,
+    _UniformRandomBitGenerator&& __g)
+    {
+      using __pop_cat = typename
+ std::iterator_traits<_PopulationIterator>::iterator_category;
+      using __samp_cat = typename
+ std::iterator_traits<_SampleIterator>::iterator_category;
+      static_assert(
+   __or_<is_convertible<__pop_cat, forward_iterator_tag>,
+  is_convertible<__samp_cat, random_access_iterator_tag>>::value,
+   "output range must use a RandomAccessIterator when input range"
+   " does not meet the ForwardIterator requirements");
+      static_assert(is_integral<_Distance>::value,
+      "sample size must be an integer type");
+      typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
+      return std::
+ __sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
+   std::forward<_UniformRandomBitGenerator>(__g));
+    }
+
+
+}
+       
+extern "C" {
+typedef float float_t;
+typedef double double_t;
+enum
+  {
+    FP_INT_UPWARD =
+      0,
+    FP_INT_DOWNWARD =
+      1,
+    FP_INT_TOWARDZERO =
+      2,
+    FP_INT_TONEARESTFROMZERO =
+      3,
+    FP_INT_TONEAREST =
+      4,
+  };
+extern int __fpclassify (double __value) throw ()
+     __attribute__ ((__const__));
+extern int __signbit (double __value) throw ()
+     __attribute__ ((__const__));
+extern int __isinf (double __value) throw () __attribute__ ((__const__));
+extern int __finite (double __value) throw () __attribute__ ((__const__));
+extern int __isnan (double __value) throw () __attribute__ ((__const__));
+extern int __iseqsig (double __x, double __y) throw ();
+extern int __issignaling (double __value) throw ()
+     __attribute__ ((__const__));
+extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
+extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
+extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
+extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
+ extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
+ extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
+extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
+extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
+extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
+extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
+ extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();
+extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
+extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
+extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
+ extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
+extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
+extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
+ extern double log (double __x) throw (); extern double __log (double __x) throw ();
+extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
+extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
+extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
+extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
+extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
+extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
+extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
+ extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
+extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
+extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
+extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
+extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
+extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
+extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
+extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
+extern int finite (double __value) throw () __attribute__ ((__const__));
+extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
+extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
+extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
+extern double nan (const char *__tagb) throw (); extern double __nan (const char *__tagb) throw ();
+extern double j0 (double) throw (); extern double __j0 (double) throw ();
+extern double j1 (double) throw (); extern double __j1 (double) throw ();
+extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
+extern double y0 (double) throw (); extern double __y0 (double) throw ();
+extern double y1 (double) throw (); extern double __y1 (double) throw ();
+extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
+extern double erf (double) throw (); extern double __erf (double) throw ();
+extern double erfc (double) throw (); extern double __erfc (double) throw ();
+extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
+extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
+extern double gamma (double) throw (); extern double __gamma (double) throw ();
+extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
+extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
+extern double nextafter (double __x, double __y) throw (); extern double __nextafter (double __x, double __y) throw ();
+extern double nexttoward (double __x, long double __y) throw (); extern double __nexttoward (double __x, long double __y) throw ();
+extern double nextdown (double __x) throw (); extern double __nextdown (double __x) throw ();
+extern double nextup (double __x) throw (); extern double __nextup (double __x) throw ();
+extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
+extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
+extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
+extern long int llogb (double __x) throw (); extern long int __llogb (double __x) throw ();
+extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
+extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
+extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
+extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
+extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
+extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
+__extension__
+extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
+extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
+__extension__
+extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
+extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
+extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
+extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
+extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
+extern double roundeven (double __x) throw () __attribute__ ((__const__)); extern double __roundeven (double __x) throw () __attribute__ ((__const__));
+extern __intmax_t fromfp (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) throw ();
+extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) throw ();
+extern double fmaxmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) throw () __attribute__ ((__const__));
+extern double fminmag (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) throw () __attribute__ ((__const__));
+extern int totalorder (double __x, double __y) throw ()
+     __attribute__ ((__const__));
+extern int totalordermag (double __x, double __y) throw ()
+     __attribute__ ((__const__));
+extern int canonicalize (double *__cx, const double *__x) throw ();
+extern double getpayload (const double *__x) throw (); extern double __getpayload (const double *__x) throw ();
+extern int setpayload (double *__x, double __payload) throw ();
+extern int setpayloadsig (double *__x, double __payload) throw ();
+extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
+extern int __fpclassifyf (float __value) throw ()
+     __attribute__ ((__const__));
+extern int __signbitf (float __value) throw ()
+     __attribute__ ((__const__));
+extern int __isinff (float __value) throw () __attribute__ ((__const__));
+extern int __finitef (float __value) throw () __attribute__ ((__const__));
+extern int __isnanf (float __value) throw () __attribute__ ((__const__));
+extern int __iseqsigf (float __x, float __y) throw ();
+extern int __issignalingf (float __value) throw ()
+     __attribute__ ((__const__));
+extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
+extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
+extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
+extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
+ extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
+ extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
+extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
+extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
+extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
+extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
+ extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();
+extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
+extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
+extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
+ extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
+extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
+extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
+ extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
+extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
+extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
+extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
+extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
+extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
+extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
+extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
+ extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
+extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
+extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
+extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
+extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
+extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
+extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
+extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
+extern int isinff (float __value) throw () __attribute__ ((__const__));
+extern int finitef (float __value) throw () __attribute__ ((__const__));
+extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
+extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
+extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
+extern float nanf (const char *__tagb) throw (); extern float __nanf (const char *__tagb) throw ();
+extern int isnanf (float __value) throw () __attribute__ ((__const__));
+extern float j0f (float) throw (); extern float __j0f (float) throw ();
+extern float j1f (float) throw (); extern float __j1f (float) throw ();
+extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
+extern float y0f (float) throw (); extern float __y0f (float) throw ();
+extern float y1f (float) throw (); extern float __y1f (float) throw ();
+extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
+extern float erff (float) throw (); extern float __erff (float) throw ();
+extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
+extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
+extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
+extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
+extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
+extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
+extern float nextafterf (float __x, float __y) throw (); extern float __nextafterf (float __x, float __y) throw ();
+extern float nexttowardf (float __x, long double __y) throw (); extern float __nexttowardf (float __x, long double __y) throw ();
+extern float nextdownf (float __x) throw (); extern float __nextdownf (float __x) throw ();
+extern float nextupf (float __x) throw (); extern float __nextupf (float __x) throw ();
+extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
+extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
+extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
+extern long int llogbf (float __x) throw (); extern long int __llogbf (float __x) throw ();
+extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
+extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
+extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
+extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
+extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
+extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
+__extension__
+extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
+extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
+__extension__
+extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
+extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
+extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
+extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
+extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
+extern float roundevenf (float __x) throw () __attribute__ ((__const__)); extern float __roundevenf (float __x) throw () __attribute__ ((__const__));
+extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) throw ();
+extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) throw ();
+extern float fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) throw () __attribute__ ((__const__));
+extern float fminmagf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) throw () __attribute__ ((__const__));
+extern int totalorderf (float __x, float __y) throw ()
+     __attribute__ ((__const__));
+extern int totalordermagf (float __x, float __y) throw ()
+     __attribute__ ((__const__));
+extern int canonicalizef (float *__cx, const float *__x) throw ();
+extern float getpayloadf (const float *__x) throw (); extern float __getpayloadf (const float *__x) throw ();
+extern int setpayloadf (float *__x, float __payload) throw ();
+extern int setpayloadsigf (float *__x, float __payload) throw ();
+extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
+extern int __fpclassifyl (long double __value) throw ()
+     __attribute__ ((__const__));
+extern int __signbitl (long double __value) throw ()
+     __attribute__ ((__const__));
+extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
+extern int __finitel (long double __value) throw () __attribute__ ((__const__));
+extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
+extern int __iseqsigl (long double __x, long double __y) throw ();
+extern int __issignalingl (long double __value) throw ()
+     __attribute__ ((__const__));
+extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
+extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
+extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
+extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
+ extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
+ extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
+extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
+extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
+extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
+extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
+ extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();
+extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
+extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
+extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
+ extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
+extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
+extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
+ extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
+extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
+extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
+extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
+extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
+extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
+extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
+extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
+ extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
+extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
+extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
+extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
+extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
+extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
+extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
+extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
+extern int isinfl (long double __value) throw () __attribute__ ((__const__));
+extern int finitel (long double __value) throw () __attribute__ ((__const__));
+extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
+extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
+extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
+extern long double nanl (const char *__tagb) throw (); extern long double __nanl (const char *__tagb) throw ();
+extern int isnanl (long double __value) throw () __attribute__ ((__const__));
+extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
+extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
+extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
+extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
+extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
+extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
+extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
+extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
+extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
+extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
+extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
+extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
+extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
+extern long double nextafterl (long double __x, long double __y) throw (); extern long double __nextafterl (long double __x, long double __y) throw ();
+extern long double nexttowardl (long double __x, long double __y) throw (); extern long double __nexttowardl (long double __x, long double __y) throw ();
+extern long double nextdownl (long double __x) throw (); extern long double __nextdownl (long double __x) throw ();
+extern long double nextupl (long double __x) throw (); extern long double __nextupl (long double __x) throw ();
+extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
+extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
+extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
+extern long int llogbl (long double __x) throw (); extern long int __llogbl (long double __x) throw ();
+extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
+extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
+extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
+extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
+extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
+extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
+__extension__
+extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
+extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
+__extension__
+extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
+extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
+extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));
+extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));
+extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
+extern long double roundevenl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundevenl (long double __x) throw () __attribute__ ((__const__));
+extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) throw ();
+extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) throw ();
+extern long double fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) throw () __attribute__ ((__const__));
+extern long double fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) throw () __attribute__ ((__const__));
+extern int totalorderl (long double __x, long double __y) throw ()
+     __attribute__ ((__const__));
+extern int totalordermagl (long double __x, long double __y) throw ()
+     __attribute__ ((__const__));
+extern int canonicalizel (long double *__cx, const long double *__x) throw ();
+extern long double getpayloadl (const long double *__x) throw (); extern long double __getpayloadl (const long double *__x) throw ();
+extern int setpayloadl (long double *__x, long double __payload) throw ();
+extern int setpayloadsigl (long double *__x, long double __payload) throw ();
+extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
+extern _Float32 acosf32 (_Float32 __x) throw (); extern _Float32 __acosf32 (_Float32 __x) throw ();
+extern _Float32 asinf32 (_Float32 __x) throw (); extern _Float32 __asinf32 (_Float32 __x) throw ();
+extern _Float32 atanf32 (_Float32 __x) throw (); extern _Float32 __atanf32 (_Float32 __x) throw ();
+extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) throw (); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) throw ();
+ extern _Float32 cosf32 (_Float32 __x) throw (); extern _Float32 __cosf32 (_Float32 __x) throw ();
+ extern _Float32 sinf32 (_Float32 __x) throw (); extern _Float32 __sinf32 (_Float32 __x) throw ();
+extern _Float32 tanf32 (_Float32 __x) throw (); extern _Float32 __tanf32 (_Float32 __x) throw ();
+extern _Float32 coshf32 (_Float32 __x) throw (); extern _Float32 __coshf32 (_Float32 __x) throw ();
+extern _Float32 sinhf32 (_Float32 __x) throw (); extern _Float32 __sinhf32 (_Float32 __x) throw ();
+extern _Float32 tanhf32 (_Float32 __x) throw (); extern _Float32 __tanhf32 (_Float32 __x) throw ();
+ extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw (); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) throw ();
+extern _Float32 acoshf32 (_Float32 __x) throw (); extern _Float32 __acoshf32 (_Float32 __x) throw ();
+extern _Float32 asinhf32 (_Float32 __x) throw (); extern _Float32 __asinhf32 (_Float32 __x) throw ();
+extern _Float32 atanhf32 (_Float32 __x) throw (); extern _Float32 __atanhf32 (_Float32 __x) throw ();
+ extern _Float32 expf32 (_Float32 __x) throw (); extern _Float32 __expf32 (_Float32 __x) throw ();
+extern _Float32 frexpf32 (_Float32 __x, int *__exponent) throw (); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) throw ();
+extern _Float32 ldexpf32 (_Float32 __x, int __exponent) throw (); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) throw ();
+ extern _Float32 logf32 (_Float32 __x) throw (); extern _Float32 __logf32 (_Float32 __x) throw ();
+extern _Float32 log10f32 (_Float32 __x) throw (); extern _Float32 __log10f32 (_Float32 __x) throw ();
+extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) throw (); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+extern _Float32 exp10f32 (_Float32 __x) throw (); extern _Float32 __exp10f32 (_Float32 __x) throw ();
+extern _Float32 expm1f32 (_Float32 __x) throw (); extern _Float32 __expm1f32 (_Float32 __x) throw ();
+extern _Float32 log1pf32 (_Float32 __x) throw (); extern _Float32 __log1pf32 (_Float32 __x) throw ();
+extern _Float32 logbf32 (_Float32 __x) throw (); extern _Float32 __logbf32 (_Float32 __x) throw ();
+extern _Float32 exp2f32 (_Float32 __x) throw (); extern _Float32 __exp2f32 (_Float32 __x) throw ();
+extern _Float32 log2f32 (_Float32 __x) throw (); extern _Float32 __log2f32 (_Float32 __x) throw ();
+ extern _Float32 powf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) throw ();
+extern _Float32 sqrtf32 (_Float32 __x) throw (); extern _Float32 __sqrtf32 (_Float32 __x) throw ();
+extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) throw ();
+extern _Float32 cbrtf32 (_Float32 __x) throw (); extern _Float32 __cbrtf32 (_Float32 __x) throw ();
+extern _Float32 ceilf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) throw () __attribute__ ((__const__));
+extern _Float32 fabsf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) throw () __attribute__ ((__const__));
+extern _Float32 floorf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) throw () __attribute__ ((__const__));
+extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) throw ();
+extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
+extern _Float32 nanf32 (const char *__tagb) throw (); extern _Float32 __nanf32 (const char *__tagb) throw ();
+extern _Float32 j0f32 (_Float32) throw (); extern _Float32 __j0f32 (_Float32) throw ();
+extern _Float32 j1f32 (_Float32) throw (); extern _Float32 __j1f32 (_Float32) throw ();
+extern _Float32 jnf32 (int, _Float32) throw (); extern _Float32 __jnf32 (int, _Float32) throw ();
+extern _Float32 y0f32 (_Float32) throw (); extern _Float32 __y0f32 (_Float32) throw ();
+extern _Float32 y1f32 (_Float32) throw (); extern _Float32 __y1f32 (_Float32) throw ();
+extern _Float32 ynf32 (int, _Float32) throw (); extern _Float32 __ynf32 (int, _Float32) throw ();
+extern _Float32 erff32 (_Float32) throw (); extern _Float32 __erff32 (_Float32) throw ();
+extern _Float32 erfcf32 (_Float32) throw (); extern _Float32 __erfcf32 (_Float32) throw ();
+extern _Float32 lgammaf32 (_Float32) throw (); extern _Float32 __lgammaf32 (_Float32) throw ();
+extern _Float32 tgammaf32 (_Float32) throw (); extern _Float32 __tgammaf32 (_Float32) throw ();
+extern _Float32 lgammaf32_r (_Float32, int *__signgamp) throw (); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) throw ();
+extern _Float32 rintf32 (_Float32 __x) throw (); extern _Float32 __rintf32 (_Float32 __x) throw ();
+extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) throw ();
+extern _Float32 nextdownf32 (_Float32 __x) throw (); extern _Float32 __nextdownf32 (_Float32 __x) throw ();
+extern _Float32 nextupf32 (_Float32 __x) throw (); extern _Float32 __nextupf32 (_Float32 __x) throw ();
+extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) throw ();
+extern _Float32 scalbnf32 (_Float32 __x, int __n) throw (); extern _Float32 __scalbnf32 (_Float32 __x, int __n) throw ();
+extern int ilogbf32 (_Float32 __x) throw (); extern int __ilogbf32 (_Float32 __x) throw ();
+extern long int llogbf32 (_Float32 __x) throw (); extern long int __llogbf32 (_Float32 __x) throw ();
+extern _Float32 scalblnf32 (_Float32 __x, long int __n) throw (); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) throw ();
+extern _Float32 nearbyintf32 (_Float32 __x) throw (); extern _Float32 __nearbyintf32 (_Float32 __x) throw ();
+extern _Float32 roundf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) throw () __attribute__ ((__const__));
+extern _Float32 truncf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) throw () __attribute__ ((__const__));
+extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw (); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) throw ();
+extern long int lrintf32 (_Float32 __x) throw (); extern long int __lrintf32 (_Float32 __x) throw ();
+__extension__
+extern long long int llrintf32 (_Float32 __x) throw (); extern long long int __llrintf32 (_Float32 __x) throw ();
+extern long int lroundf32 (_Float32 __x) throw (); extern long int __lroundf32 (_Float32 __x) throw ();
+__extension__
+extern long long int llroundf32 (_Float32 __x) throw (); extern long long int __llroundf32 (_Float32 __x) throw ();
+extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) throw (); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) throw ();
+extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
+extern _Float32 fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
+extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw (); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) throw ();
+extern _Float32 roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) throw () __attribute__ ((__const__));
+extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) throw ();
+extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) throw ();
+extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
+extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) throw () __attribute__ ((__const__));
+extern int totalorderf32 (_Float32 __x, _Float32 __y) throw ()
+     __attribute__ ((__const__));
+extern int totalordermagf32 (_Float32 __x, _Float32 __y) throw ()
+     __attribute__ ((__const__));
+extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) throw ();
+extern _Float32 getpayloadf32 (const _Float32 *__x) throw (); extern _Float32 __getpayloadf32 (const _Float32 *__x) throw ();
+extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) throw ();
+extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) throw ();
+extern _Float64 acosf64 (_Float64 __x) throw (); extern _Float64 __acosf64 (_Float64 __x) throw ();
+extern _Float64 asinf64 (_Float64 __x) throw (); extern _Float64 __asinf64 (_Float64 __x) throw ();
+extern _Float64 atanf64 (_Float64 __x) throw (); extern _Float64 __atanf64 (_Float64 __x) throw ();
+extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) throw (); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) throw ();
+ extern _Float64 cosf64 (_Float64 __x) throw (); extern _Float64 __cosf64 (_Float64 __x) throw ();
+ extern _Float64 sinf64 (_Float64 __x) throw (); extern _Float64 __sinf64 (_Float64 __x) throw ();
+extern _Float64 tanf64 (_Float64 __x) throw (); extern _Float64 __tanf64 (_Float64 __x) throw ();
+extern _Float64 coshf64 (_Float64 __x) throw (); extern _Float64 __coshf64 (_Float64 __x) throw ();
+extern _Float64 sinhf64 (_Float64 __x) throw (); extern _Float64 __sinhf64 (_Float64 __x) throw ();
+extern _Float64 tanhf64 (_Float64 __x) throw (); extern _Float64 __tanhf64 (_Float64 __x) throw ();
+ extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw (); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) throw ();
+extern _Float64 acoshf64 (_Float64 __x) throw (); extern _Float64 __acoshf64 (_Float64 __x) throw ();
+extern _Float64 asinhf64 (_Float64 __x) throw (); extern _Float64 __asinhf64 (_Float64 __x) throw ();
+extern _Float64 atanhf64 (_Float64 __x) throw (); extern _Float64 __atanhf64 (_Float64 __x) throw ();
+ extern _Float64 expf64 (_Float64 __x) throw (); extern _Float64 __expf64 (_Float64 __x) throw ();
+extern _Float64 frexpf64 (_Float64 __x, int *__exponent) throw (); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) throw ();
+extern _Float64 ldexpf64 (_Float64 __x, int __exponent) throw (); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) throw ();
+ extern _Float64 logf64 (_Float64 __x) throw (); extern _Float64 __logf64 (_Float64 __x) throw ();
+extern _Float64 log10f64 (_Float64 __x) throw (); extern _Float64 __log10f64 (_Float64 __x) throw ();
+extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) throw (); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+extern _Float64 exp10f64 (_Float64 __x) throw (); extern _Float64 __exp10f64 (_Float64 __x) throw ();
+extern _Float64 expm1f64 (_Float64 __x) throw (); extern _Float64 __expm1f64 (_Float64 __x) throw ();
+extern _Float64 log1pf64 (_Float64 __x) throw (); extern _Float64 __log1pf64 (_Float64 __x) throw ();
+extern _Float64 logbf64 (_Float64 __x) throw (); extern _Float64 __logbf64 (_Float64 __x) throw ();
+extern _Float64 exp2f64 (_Float64 __x) throw (); extern _Float64 __exp2f64 (_Float64 __x) throw ();
+extern _Float64 log2f64 (_Float64 __x) throw (); extern _Float64 __log2f64 (_Float64 __x) throw ();
+ extern _Float64 powf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float64 sqrtf64 (_Float64 __x) throw (); extern _Float64 __sqrtf64 (_Float64 __x) throw ();
+extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float64 cbrtf64 (_Float64 __x) throw (); extern _Float64 __cbrtf64 (_Float64 __x) throw ();
+extern _Float64 ceilf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) throw () __attribute__ ((__const__));
+extern _Float64 fabsf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) throw () __attribute__ ((__const__));
+extern _Float64 floorf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) throw () __attribute__ ((__const__));
+extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
+extern _Float64 nanf64 (const char *__tagb) throw (); extern _Float64 __nanf64 (const char *__tagb) throw ();
+extern _Float64 j0f64 (_Float64) throw (); extern _Float64 __j0f64 (_Float64) throw ();
+extern _Float64 j1f64 (_Float64) throw (); extern _Float64 __j1f64 (_Float64) throw ();
+extern _Float64 jnf64 (int, _Float64) throw (); extern _Float64 __jnf64 (int, _Float64) throw ();
+extern _Float64 y0f64 (_Float64) throw (); extern _Float64 __y0f64 (_Float64) throw ();
+extern _Float64 y1f64 (_Float64) throw (); extern _Float64 __y1f64 (_Float64) throw ();
+extern _Float64 ynf64 (int, _Float64) throw (); extern _Float64 __ynf64 (int, _Float64) throw ();
+extern _Float64 erff64 (_Float64) throw (); extern _Float64 __erff64 (_Float64) throw ();
+extern _Float64 erfcf64 (_Float64) throw (); extern _Float64 __erfcf64 (_Float64) throw ();
+extern _Float64 lgammaf64 (_Float64) throw (); extern _Float64 __lgammaf64 (_Float64) throw ();
+extern _Float64 tgammaf64 (_Float64) throw (); extern _Float64 __tgammaf64 (_Float64) throw ();
+extern _Float64 lgammaf64_r (_Float64, int *__signgamp) throw (); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) throw ();
+extern _Float64 rintf64 (_Float64 __x) throw (); extern _Float64 __rintf64 (_Float64 __x) throw ();
+extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float64 nextdownf64 (_Float64 __x) throw (); extern _Float64 __nextdownf64 (_Float64 __x) throw ();
+extern _Float64 nextupf64 (_Float64 __x) throw (); extern _Float64 __nextupf64 (_Float64 __x) throw ();
+extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float64 scalbnf64 (_Float64 __x, int __n) throw (); extern _Float64 __scalbnf64 (_Float64 __x, int __n) throw ();
+extern int ilogbf64 (_Float64 __x) throw (); extern int __ilogbf64 (_Float64 __x) throw ();
+extern long int llogbf64 (_Float64 __x) throw (); extern long int __llogbf64 (_Float64 __x) throw ();
+extern _Float64 scalblnf64 (_Float64 __x, long int __n) throw (); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) throw ();
+extern _Float64 nearbyintf64 (_Float64 __x) throw (); extern _Float64 __nearbyintf64 (_Float64 __x) throw ();
+extern _Float64 roundf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) throw () __attribute__ ((__const__));
+extern _Float64 truncf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) throw () __attribute__ ((__const__));
+extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw (); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) throw ();
+extern long int lrintf64 (_Float64 __x) throw (); extern long int __lrintf64 (_Float64 __x) throw ();
+__extension__
+extern long long int llrintf64 (_Float64 __x) throw (); extern long long int __llrintf64 (_Float64 __x) throw ();
+extern long int lroundf64 (_Float64 __x) throw (); extern long int __lroundf64 (_Float64 __x) throw ();
+__extension__
+extern long long int llroundf64 (_Float64 __x) throw (); extern long long int __llroundf64 (_Float64 __x) throw ();
+extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) throw (); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
+extern _Float64 fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
+extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw (); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) throw ();
+extern _Float64 roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) throw () __attribute__ ((__const__));
+extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) throw ();
+extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) throw ();
+extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
+extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) throw () __attribute__ ((__const__));
+extern int totalorderf64 (_Float64 __x, _Float64 __y) throw ()
+     __attribute__ ((__const__));
+extern int totalordermagf64 (_Float64 __x, _Float64 __y) throw ()
+     __attribute__ ((__const__));
+extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) throw ();
+extern _Float64 getpayloadf64 (const _Float64 *__x) throw (); extern _Float64 __getpayloadf64 (const _Float64 *__x) throw ();
+extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) throw ();
+extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) throw ();
+extern int __fpclassifyf128 (_Float128 __value) throw ()
+     __attribute__ ((__const__));
+extern int __signbitf128 (_Float128 __value) throw ()
+     __attribute__ ((__const__));
+extern int __isinff128 (_Float128 __value) throw () __attribute__ ((__const__));
+extern int __finitef128 (_Float128 __value) throw () __attribute__ ((__const__));
+extern int __isnanf128 (_Float128 __value) throw () __attribute__ ((__const__));
+extern int __iseqsigf128 (_Float128 __x, _Float128 __y) throw ();
+extern int __issignalingf128 (_Float128 __value) throw ()
+     __attribute__ ((__const__));
+extern _Float128 acosf128 (_Float128 __x) throw (); extern _Float128 __acosf128 (_Float128 __x) throw ();
+extern _Float128 asinf128 (_Float128 __x) throw (); extern _Float128 __asinf128 (_Float128 __x) throw ();
+extern _Float128 atanf128 (_Float128 __x) throw (); extern _Float128 __atanf128 (_Float128 __x) throw ();
+extern _Float128 atan2f128 (_Float128 __y, _Float128 __x) throw (); extern _Float128 __atan2f128 (_Float128 __y, _Float128 __x) throw ();
+ extern _Float128 cosf128 (_Float128 __x) throw (); extern _Float128 __cosf128 (_Float128 __x) throw ();
+ extern _Float128 sinf128 (_Float128 __x) throw (); extern _Float128 __sinf128 (_Float128 __x) throw ();
+extern _Float128 tanf128 (_Float128 __x) throw (); extern _Float128 __tanf128 (_Float128 __x) throw ();
+extern _Float128 coshf128 (_Float128 __x) throw (); extern _Float128 __coshf128 (_Float128 __x) throw ();
+extern _Float128 sinhf128 (_Float128 __x) throw (); extern _Float128 __sinhf128 (_Float128 __x) throw ();
+extern _Float128 tanhf128 (_Float128 __x) throw (); extern _Float128 __tanhf128 (_Float128 __x) throw ();
+ extern void sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) throw (); extern void __sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) throw ();
+extern _Float128 acoshf128 (_Float128 __x) throw (); extern _Float128 __acoshf128 (_Float128 __x) throw ();
+extern _Float128 asinhf128 (_Float128 __x) throw (); extern _Float128 __asinhf128 (_Float128 __x) throw ();
+extern _Float128 atanhf128 (_Float128 __x) throw (); extern _Float128 __atanhf128 (_Float128 __x) throw ();
+ extern _Float128 expf128 (_Float128 __x) throw (); extern _Float128 __expf128 (_Float128 __x) throw ();
+extern _Float128 frexpf128 (_Float128 __x, int *__exponent) throw (); extern _Float128 __frexpf128 (_Float128 __x, int *__exponent) throw ();
+extern _Float128 ldexpf128 (_Float128 __x, int __exponent) throw (); extern _Float128 __ldexpf128 (_Float128 __x, int __exponent) throw ();
+ extern _Float128 logf128 (_Float128 __x) throw (); extern _Float128 __logf128 (_Float128 __x) throw ();
+extern _Float128 log10f128 (_Float128 __x) throw (); extern _Float128 __log10f128 (_Float128 __x) throw ();
+extern _Float128 modff128 (_Float128 __x, _Float128 *__iptr) throw (); extern _Float128 __modff128 (_Float128 __x, _Float128 *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+extern _Float128 exp10f128 (_Float128 __x) throw (); extern _Float128 __exp10f128 (_Float128 __x) throw ();
+extern _Float128 expm1f128 (_Float128 __x) throw (); extern _Float128 __expm1f128 (_Float128 __x) throw ();
+extern _Float128 log1pf128 (_Float128 __x) throw (); extern _Float128 __log1pf128 (_Float128 __x) throw ();
+extern _Float128 logbf128 (_Float128 __x) throw (); extern _Float128 __logbf128 (_Float128 __x) throw ();
+extern _Float128 exp2f128 (_Float128 __x) throw (); extern _Float128 __exp2f128 (_Float128 __x) throw ();
+extern _Float128 log2f128 (_Float128 __x) throw (); extern _Float128 __log2f128 (_Float128 __x) throw ();
+ extern _Float128 powf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __powf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float128 sqrtf128 (_Float128 __x) throw (); extern _Float128 __sqrtf128 (_Float128 __x) throw ();
+extern _Float128 hypotf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __hypotf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float128 cbrtf128 (_Float128 __x) throw (); extern _Float128 __cbrtf128 (_Float128 __x) throw ();
+extern _Float128 ceilf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __ceilf128 (_Float128 __x) throw () __attribute__ ((__const__));
+extern _Float128 fabsf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __fabsf128 (_Float128 __x) throw () __attribute__ ((__const__));
+extern _Float128 floorf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __floorf128 (_Float128 __x) throw () __attribute__ ((__const__));
+extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __copysignf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
+extern _Float128 nanf128 (const char *__tagb) throw (); extern _Float128 __nanf128 (const char *__tagb) throw ();
+extern _Float128 j0f128 (_Float128) throw (); extern _Float128 __j0f128 (_Float128) throw ();
+extern _Float128 j1f128 (_Float128) throw (); extern _Float128 __j1f128 (_Float128) throw ();
+extern _Float128 jnf128 (int, _Float128) throw (); extern _Float128 __jnf128 (int, _Float128) throw ();
+extern _Float128 y0f128 (_Float128) throw (); extern _Float128 __y0f128 (_Float128) throw ();
+extern _Float128 y1f128 (_Float128) throw (); extern _Float128 __y1f128 (_Float128) throw ();
+extern _Float128 ynf128 (int, _Float128) throw (); extern _Float128 __ynf128 (int, _Float128) throw ();
+extern _Float128 erff128 (_Float128) throw (); extern _Float128 __erff128 (_Float128) throw ();
+extern _Float128 erfcf128 (_Float128) throw (); extern _Float128 __erfcf128 (_Float128) throw ();
+extern _Float128 lgammaf128 (_Float128) throw (); extern _Float128 __lgammaf128 (_Float128) throw ();
+extern _Float128 tgammaf128 (_Float128) throw (); extern _Float128 __tgammaf128 (_Float128) throw ();
+extern _Float128 lgammaf128_r (_Float128, int *__signgamp) throw (); extern _Float128 __lgammaf128_r (_Float128, int *__signgamp) throw ();
+extern _Float128 rintf128 (_Float128 __x) throw (); extern _Float128 __rintf128 (_Float128 __x) throw ();
+extern _Float128 nextafterf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __nextafterf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float128 nextdownf128 (_Float128 __x) throw (); extern _Float128 __nextdownf128 (_Float128 __x) throw ();
+extern _Float128 nextupf128 (_Float128 __x) throw (); extern _Float128 __nextupf128 (_Float128 __x) throw ();
+extern _Float128 remainderf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __remainderf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float128 scalbnf128 (_Float128 __x, int __n) throw (); extern _Float128 __scalbnf128 (_Float128 __x, int __n) throw ();
+extern int ilogbf128 (_Float128 __x) throw (); extern int __ilogbf128 (_Float128 __x) throw ();
+extern long int llogbf128 (_Float128 __x) throw (); extern long int __llogbf128 (_Float128 __x) throw ();
+extern _Float128 scalblnf128 (_Float128 __x, long int __n) throw (); extern _Float128 __scalblnf128 (_Float128 __x, long int __n) throw ();
+extern _Float128 nearbyintf128 (_Float128 __x) throw (); extern _Float128 __nearbyintf128 (_Float128 __x) throw ();
+extern _Float128 roundf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __roundf128 (_Float128 __x) throw () __attribute__ ((__const__));
+extern _Float128 truncf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __truncf128 (_Float128 __x) throw () __attribute__ ((__const__));
+extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) throw (); extern _Float128 __remquof128 (_Float128 __x, _Float128 __y, int *__quo) throw ();
+extern long int lrintf128 (_Float128 __x) throw (); extern long int __lrintf128 (_Float128 __x) throw ();
+__extension__
+extern long long int llrintf128 (_Float128 __x) throw (); extern long long int __llrintf128 (_Float128 __x) throw ();
+extern long int lroundf128 (_Float128 __x) throw (); extern long int __lroundf128 (_Float128 __x) throw ();
+__extension__
+extern long long int llroundf128 (_Float128 __x) throw (); extern long long int __llroundf128 (_Float128 __x) throw ();
+extern _Float128 fdimf128 (_Float128 __x, _Float128 __y) throw (); extern _Float128 __fdimf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float128 fmaxf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fmaxf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
+extern _Float128 fminf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fminf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
+extern _Float128 fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) throw (); extern _Float128 __fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) throw ();
+extern _Float128 roundevenf128 (_Float128 __x) throw () __attribute__ ((__const__)); extern _Float128 __roundevenf128 (_Float128 __x) throw () __attribute__ ((__const__));
+extern __intmax_t fromfpf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf128 (_Float128 __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf128 (_Float128 __x, int __round, unsigned int __width) throw ();
+extern __intmax_t fromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) throw ();
+extern _Float128 fmaxmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fmaxmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
+extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__)); extern _Float128 __fminmagf128 (_Float128 __x, _Float128 __y) throw () __attribute__ ((__const__));
+extern int totalorderf128 (_Float128 __x, _Float128 __y) throw ()
+     __attribute__ ((__const__));
+extern int totalordermagf128 (_Float128 __x, _Float128 __y) throw ()
+     __attribute__ ((__const__));
+extern int canonicalizef128 (_Float128 *__cx, const _Float128 *__x) throw ();
+extern _Float128 getpayloadf128 (const _Float128 *__x) throw (); extern _Float128 __getpayloadf128 (const _Float128 *__x) throw ();
+extern int setpayloadf128 (_Float128 *__x, _Float128 __payload) throw ();
+extern int setpayloadsigf128 (_Float128 *__x, _Float128 __payload) throw ();
+extern _Float32x acosf32x (_Float32x __x) throw (); extern _Float32x __acosf32x (_Float32x __x) throw ();
+extern _Float32x asinf32x (_Float32x __x) throw (); extern _Float32x __asinf32x (_Float32x __x) throw ();
+extern _Float32x atanf32x (_Float32x __x) throw (); extern _Float32x __atanf32x (_Float32x __x) throw ();
+extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) throw (); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) throw ();
+ extern _Float32x cosf32x (_Float32x __x) throw (); extern _Float32x __cosf32x (_Float32x __x) throw ();
+ extern _Float32x sinf32x (_Float32x __x) throw (); extern _Float32x __sinf32x (_Float32x __x) throw ();
+extern _Float32x tanf32x (_Float32x __x) throw (); extern _Float32x __tanf32x (_Float32x __x) throw ();
+extern _Float32x coshf32x (_Float32x __x) throw (); extern _Float32x __coshf32x (_Float32x __x) throw ();
+extern _Float32x sinhf32x (_Float32x __x) throw (); extern _Float32x __sinhf32x (_Float32x __x) throw ();
+extern _Float32x tanhf32x (_Float32x __x) throw (); extern _Float32x __tanhf32x (_Float32x __x) throw ();
+ extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw (); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) throw ();
+extern _Float32x acoshf32x (_Float32x __x) throw (); extern _Float32x __acoshf32x (_Float32x __x) throw ();
+extern _Float32x asinhf32x (_Float32x __x) throw (); extern _Float32x __asinhf32x (_Float32x __x) throw ();
+extern _Float32x atanhf32x (_Float32x __x) throw (); extern _Float32x __atanhf32x (_Float32x __x) throw ();
+ extern _Float32x expf32x (_Float32x __x) throw (); extern _Float32x __expf32x (_Float32x __x) throw ();
+extern _Float32x frexpf32x (_Float32x __x, int *__exponent) throw (); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) throw ();
+extern _Float32x ldexpf32x (_Float32x __x, int __exponent) throw (); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) throw ();
+ extern _Float32x logf32x (_Float32x __x) throw (); extern _Float32x __logf32x (_Float32x __x) throw ();
+extern _Float32x log10f32x (_Float32x __x) throw (); extern _Float32x __log10f32x (_Float32x __x) throw ();
+extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) throw (); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+extern _Float32x exp10f32x (_Float32x __x) throw (); extern _Float32x __exp10f32x (_Float32x __x) throw ();
+extern _Float32x expm1f32x (_Float32x __x) throw (); extern _Float32x __expm1f32x (_Float32x __x) throw ();
+extern _Float32x log1pf32x (_Float32x __x) throw (); extern _Float32x __log1pf32x (_Float32x __x) throw ();
+extern _Float32x logbf32x (_Float32x __x) throw (); extern _Float32x __logbf32x (_Float32x __x) throw ();
+extern _Float32x exp2f32x (_Float32x __x) throw (); extern _Float32x __exp2f32x (_Float32x __x) throw ();
+extern _Float32x log2f32x (_Float32x __x) throw (); extern _Float32x __log2f32x (_Float32x __x) throw ();
+ extern _Float32x powf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) throw ();
+extern _Float32x sqrtf32x (_Float32x __x) throw (); extern _Float32x __sqrtf32x (_Float32x __x) throw ();
+extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) throw ();
+extern _Float32x cbrtf32x (_Float32x __x) throw (); extern _Float32x __cbrtf32x (_Float32x __x) throw ();
+extern _Float32x ceilf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) throw () __attribute__ ((__const__));
+extern _Float32x fabsf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) throw () __attribute__ ((__const__));
+extern _Float32x floorf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) throw () __attribute__ ((__const__));
+extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) throw ();
+extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
+extern _Float32x nanf32x (const char *__tagb) throw (); extern _Float32x __nanf32x (const char *__tagb) throw ();
+extern _Float32x j0f32x (_Float32x) throw (); extern _Float32x __j0f32x (_Float32x) throw ();
+extern _Float32x j1f32x (_Float32x) throw (); extern _Float32x __j1f32x (_Float32x) throw ();
+extern _Float32x jnf32x (int, _Float32x) throw (); extern _Float32x __jnf32x (int, _Float32x) throw ();
+extern _Float32x y0f32x (_Float32x) throw (); extern _Float32x __y0f32x (_Float32x) throw ();
+extern _Float32x y1f32x (_Float32x) throw (); extern _Float32x __y1f32x (_Float32x) throw ();
+extern _Float32x ynf32x (int, _Float32x) throw (); extern _Float32x __ynf32x (int, _Float32x) throw ();
+extern _Float32x erff32x (_Float32x) throw (); extern _Float32x __erff32x (_Float32x) throw ();
+extern _Float32x erfcf32x (_Float32x) throw (); extern _Float32x __erfcf32x (_Float32x) throw ();
+extern _Float32x lgammaf32x (_Float32x) throw (); extern _Float32x __lgammaf32x (_Float32x) throw ();
+extern _Float32x tgammaf32x (_Float32x) throw (); extern _Float32x __tgammaf32x (_Float32x) throw ();
+extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) throw (); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) throw ();
+extern _Float32x rintf32x (_Float32x __x) throw (); extern _Float32x __rintf32x (_Float32x __x) throw ();
+extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) throw ();
+extern _Float32x nextdownf32x (_Float32x __x) throw (); extern _Float32x __nextdownf32x (_Float32x __x) throw ();
+extern _Float32x nextupf32x (_Float32x __x) throw (); extern _Float32x __nextupf32x (_Float32x __x) throw ();
+extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) throw ();
+extern _Float32x scalbnf32x (_Float32x __x, int __n) throw (); extern _Float32x __scalbnf32x (_Float32x __x, int __n) throw ();
+extern int ilogbf32x (_Float32x __x) throw (); extern int __ilogbf32x (_Float32x __x) throw ();
+extern long int llogbf32x (_Float32x __x) throw (); extern long int __llogbf32x (_Float32x __x) throw ();
+extern _Float32x scalblnf32x (_Float32x __x, long int __n) throw (); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) throw ();
+extern _Float32x nearbyintf32x (_Float32x __x) throw (); extern _Float32x __nearbyintf32x (_Float32x __x) throw ();
+extern _Float32x roundf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) throw () __attribute__ ((__const__));
+extern _Float32x truncf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) throw () __attribute__ ((__const__));
+extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw (); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) throw ();
+extern long int lrintf32x (_Float32x __x) throw (); extern long int __lrintf32x (_Float32x __x) throw ();
+__extension__
+extern long long int llrintf32x (_Float32x __x) throw (); extern long long int __llrintf32x (_Float32x __x) throw ();
+extern long int lroundf32x (_Float32x __x) throw (); extern long int __lroundf32x (_Float32x __x) throw ();
+__extension__
+extern long long int llroundf32x (_Float32x __x) throw (); extern long long int __llroundf32x (_Float32x __x) throw ();
+extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) throw (); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) throw ();
+extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
+extern _Float32x fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
+extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw (); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) throw ();
+extern _Float32x roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) throw () __attribute__ ((__const__));
+extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) throw ();
+extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) throw ();
+extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
+extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) throw () __attribute__ ((__const__));
+extern int totalorderf32x (_Float32x __x, _Float32x __y) throw ()
+     __attribute__ ((__const__));
+extern int totalordermagf32x (_Float32x __x, _Float32x __y) throw ()
+     __attribute__ ((__const__));
+extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) throw ();
+extern _Float32x getpayloadf32x (const _Float32x *__x) throw (); extern _Float32x __getpayloadf32x (const _Float32x *__x) throw ();
+extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) throw ();
+extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) throw ();
+extern _Float64x acosf64x (_Float64x __x) throw (); extern _Float64x __acosf64x (_Float64x __x) throw ();
+extern _Float64x asinf64x (_Float64x __x) throw (); extern _Float64x __asinf64x (_Float64x __x) throw ();
+extern _Float64x atanf64x (_Float64x __x) throw (); extern _Float64x __atanf64x (_Float64x __x) throw ();
+extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) throw (); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) throw ();
+ extern _Float64x cosf64x (_Float64x __x) throw (); extern _Float64x __cosf64x (_Float64x __x) throw ();
+ extern _Float64x sinf64x (_Float64x __x) throw (); extern _Float64x __sinf64x (_Float64x __x) throw ();
+extern _Float64x tanf64x (_Float64x __x) throw (); extern _Float64x __tanf64x (_Float64x __x) throw ();
+extern _Float64x coshf64x (_Float64x __x) throw (); extern _Float64x __coshf64x (_Float64x __x) throw ();
+extern _Float64x sinhf64x (_Float64x __x) throw (); extern _Float64x __sinhf64x (_Float64x __x) throw ();
+extern _Float64x tanhf64x (_Float64x __x) throw (); extern _Float64x __tanhf64x (_Float64x __x) throw ();
+ extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw (); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) throw ();
+extern _Float64x acoshf64x (_Float64x __x) throw (); extern _Float64x __acoshf64x (_Float64x __x) throw ();
+extern _Float64x asinhf64x (_Float64x __x) throw (); extern _Float64x __asinhf64x (_Float64x __x) throw ();
+extern _Float64x atanhf64x (_Float64x __x) throw (); extern _Float64x __atanhf64x (_Float64x __x) throw ();
+ extern _Float64x expf64x (_Float64x __x) throw (); extern _Float64x __expf64x (_Float64x __x) throw ();
+extern _Float64x frexpf64x (_Float64x __x, int *__exponent) throw (); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) throw ();
+extern _Float64x ldexpf64x (_Float64x __x, int __exponent) throw (); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) throw ();
+ extern _Float64x logf64x (_Float64x __x) throw (); extern _Float64x __logf64x (_Float64x __x) throw ();
+extern _Float64x log10f64x (_Float64x __x) throw (); extern _Float64x __log10f64x (_Float64x __x) throw ();
+extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) throw (); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) throw () __attribute__ ((__nonnull__ (2)));
+extern _Float64x exp10f64x (_Float64x __x) throw (); extern _Float64x __exp10f64x (_Float64x __x) throw ();
+extern _Float64x expm1f64x (_Float64x __x) throw (); extern _Float64x __expm1f64x (_Float64x __x) throw ();
+extern _Float64x log1pf64x (_Float64x __x) throw (); extern _Float64x __log1pf64x (_Float64x __x) throw ();
+extern _Float64x logbf64x (_Float64x __x) throw (); extern _Float64x __logbf64x (_Float64x __x) throw ();
+extern _Float64x exp2f64x (_Float64x __x) throw (); extern _Float64x __exp2f64x (_Float64x __x) throw ();
+extern _Float64x log2f64x (_Float64x __x) throw (); extern _Float64x __log2f64x (_Float64x __x) throw ();
+ extern _Float64x powf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float64x sqrtf64x (_Float64x __x) throw (); extern _Float64x __sqrtf64x (_Float64x __x) throw ();
+extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float64x cbrtf64x (_Float64x __x) throw (); extern _Float64x __cbrtf64x (_Float64x __x) throw ();
+extern _Float64x ceilf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) throw () __attribute__ ((__const__));
+extern _Float64x fabsf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) throw () __attribute__ ((__const__));
+extern _Float64x floorf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) throw () __attribute__ ((__const__));
+extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
+extern _Float64x nanf64x (const char *__tagb) throw (); extern _Float64x __nanf64x (const char *__tagb) throw ();
+extern _Float64x j0f64x (_Float64x) throw (); extern _Float64x __j0f64x (_Float64x) throw ();
+extern _Float64x j1f64x (_Float64x) throw (); extern _Float64x __j1f64x (_Float64x) throw ();
+extern _Float64x jnf64x (int, _Float64x) throw (); extern _Float64x __jnf64x (int, _Float64x) throw ();
+extern _Float64x y0f64x (_Float64x) throw (); extern _Float64x __y0f64x (_Float64x) throw ();
+extern _Float64x y1f64x (_Float64x) throw (); extern _Float64x __y1f64x (_Float64x) throw ();
+extern _Float64x ynf64x (int, _Float64x) throw (); extern _Float64x __ynf64x (int, _Float64x) throw ();
+extern _Float64x erff64x (_Float64x) throw (); extern _Float64x __erff64x (_Float64x) throw ();
+extern _Float64x erfcf64x (_Float64x) throw (); extern _Float64x __erfcf64x (_Float64x) throw ();
+extern _Float64x lgammaf64x (_Float64x) throw (); extern _Float64x __lgammaf64x (_Float64x) throw ();
+extern _Float64x tgammaf64x (_Float64x) throw (); extern _Float64x __tgammaf64x (_Float64x) throw ();
+extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) throw (); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) throw ();
+extern _Float64x rintf64x (_Float64x __x) throw (); extern _Float64x __rintf64x (_Float64x __x) throw ();
+extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float64x nextdownf64x (_Float64x __x) throw (); extern _Float64x __nextdownf64x (_Float64x __x) throw ();
+extern _Float64x nextupf64x (_Float64x __x) throw (); extern _Float64x __nextupf64x (_Float64x __x) throw ();
+extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float64x scalbnf64x (_Float64x __x, int __n) throw (); extern _Float64x __scalbnf64x (_Float64x __x, int __n) throw ();
+extern int ilogbf64x (_Float64x __x) throw (); extern int __ilogbf64x (_Float64x __x) throw ();
+extern long int llogbf64x (_Float64x __x) throw (); extern long int __llogbf64x (_Float64x __x) throw ();
+extern _Float64x scalblnf64x (_Float64x __x, long int __n) throw (); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) throw ();
+extern _Float64x nearbyintf64x (_Float64x __x) throw (); extern _Float64x __nearbyintf64x (_Float64x __x) throw ();
+extern _Float64x roundf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) throw () __attribute__ ((__const__));
+extern _Float64x truncf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) throw () __attribute__ ((__const__));
+extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw (); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) throw ();
+extern long int lrintf64x (_Float64x __x) throw (); extern long int __lrintf64x (_Float64x __x) throw ();
+__extension__
+extern long long int llrintf64x (_Float64x __x) throw (); extern long long int __llrintf64x (_Float64x __x) throw ();
+extern long int lroundf64x (_Float64x __x) throw (); extern long int __lroundf64x (_Float64x __x) throw ();
+__extension__
+extern long long int llroundf64x (_Float64x __x) throw (); extern long long int __llroundf64x (_Float64x __x) throw ();
+extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) throw (); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
+extern _Float64x fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
+extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw (); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) throw ();
+extern _Float64x roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) throw () __attribute__ ((__const__));
+extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) throw ();
+extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw ();
+extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw (); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) throw ();
+extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
+extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) throw () __attribute__ ((__const__));
+extern int totalorderf64x (_Float64x __x, _Float64x __y) throw ()
+     __attribute__ ((__const__));
+extern int totalordermagf64x (_Float64x __x, _Float64x __y) throw ()
+     __attribute__ ((__const__));
+extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) throw ();
+extern _Float64x getpayloadf64x (const _Float64x *__x) throw (); extern _Float64x __getpayloadf64x (const _Float64x *__x) throw ();
+extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) throw ();
+extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) throw ();
+extern float fadd (double __x, double __y) throw ();
+extern float fdiv (double __x, double __y) throw ();
+extern float fmul (double __x, double __y) throw ();
+extern float fsub (double __x, double __y) throw ();
+extern float faddl (long double __x, long double __y) throw ();
+extern float fdivl (long double __x, long double __y) throw ();
+extern float fmull (long double __x, long double __y) throw ();
+extern float fsubl (long double __x, long double __y) throw ();
+extern double daddl (long double __x, long double __y) throw ();
+extern double ddivl (long double __x, long double __y) throw ();
+extern double dmull (long double __x, long double __y) throw ();
+extern double dsubl (long double __x, long double __y) throw ();
+extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) throw ();
+extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) throw ();
+extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) throw ();
+extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) throw ();
+extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float32 f32mulf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float32 f32subf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) throw ();
+extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float32x f32xaddf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) throw ();
+extern _Float64 f64addf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float64 f64mulf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float64 f64subf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) throw ();
+extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) throw ();
+extern int signgam;
+enum
+  {
+    FP_NAN =
+      0,
+    FP_INFINITE =
+      1,
+    FP_ZERO =
+      2,
+    FP_SUBNORMAL =
+      3,
+    FP_NORMAL =
+      4
+  };
+extern int __iscanonicall (long double __x)
+     throw () __attribute__ ((__const__));
+extern "C++" {
+inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); }
+inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); }
+inline int iscanonical (long double __val) { return __iscanonicall (__val); }
+inline int iscanonical (_Float128 __val) { return ((void) (__typeof (__val)) (__val), 1); }
+}
+extern "C++" {
+inline int issignaling (float __val) { return __issignalingf (__val); }
+inline int issignaling (double __val) { return __issignaling (__val); }
+inline int
+issignaling (long double __val)
+{
+  return __issignalingl (__val);
+}
+inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); }
+}
+extern "C++" {
+template <class __T> inline bool
+iszero (__T __val)
+{
+  return __val == 0;
+}
+}
+extern "C++" {
+template<typename> struct __iseqsig_type;
+template<> struct __iseqsig_type<float>
+{
+  static int __call (float __x, float __y) throw ()
+  {
+    return __iseqsigf (__x, __y);
+  }
+};
+template<> struct __iseqsig_type<double>
+{
+  static int __call (double __x, double __y) throw ()
+  {
+    return __iseqsig (__x, __y);
+  }
+};
+template<> struct __iseqsig_type<long double>
+{
+  static int __call (long double __x, long double __y) throw ()
+  {
+    return __iseqsigl (__x, __y);
+  }
+};
+template<> struct __iseqsig_type<_Float128>
+{
+  static int __call (_Float128 __x, _Float128 __y) throw ()
+  {
+    return __iseqsigf128 (__x, __y);
+  }
+};
+template<typename _T1, typename _T2>
+inline int
+iseqsig (_T1 __x, _T2 __y) throw ()
+{
+  typedef decltype (((__x) + (__y) + 0.0f)) _T3;
+  return __iseqsig_type<_T3>::__call (__x, __y);
+}
+}
+}
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  using ::acos;
+  inline constexpr float
+  acos(float __x)
+  { return __builtin_acosf(__x); }
+  inline constexpr long double
+  acos(long double __x)
+  { return __builtin_acosl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    acos(_Tp __x)
+    { return __builtin_acos(__x); }
+  using ::asin;
+  inline constexpr float
+  asin(float __x)
+  { return __builtin_asinf(__x); }
+  inline constexpr long double
+  asin(long double __x)
+  { return __builtin_asinl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    asin(_Tp __x)
+    { return __builtin_asin(__x); }
+  using ::atan;
+  inline constexpr float
+  atan(float __x)
+  { return __builtin_atanf(__x); }
+  inline constexpr long double
+  atan(long double __x)
+  { return __builtin_atanl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    atan(_Tp __x)
+    { return __builtin_atan(__x); }
+  using ::atan2;
+  inline constexpr float
+  atan2(float __y, float __x)
+  { return __builtin_atan2f(__y, __x); }
+  inline constexpr long double
+  atan2(long double __y, long double __x)
+  { return __builtin_atan2l(__y, __x); }
+  template<typename _Tp, typename _Up>
+    inline constexpr
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    atan2(_Tp __y, _Up __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return atan2(__type(__y), __type(__x));
+    }
+  using ::ceil;
+  inline constexpr float
+  ceil(float __x)
+  { return __builtin_ceilf(__x); }
+  inline constexpr long double
+  ceil(long double __x)
+  { return __builtin_ceill(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    ceil(_Tp __x)
+    { return __builtin_ceil(__x); }
+  using ::cos;
+  inline constexpr float
+  cos(float __x)
+  { return __builtin_cosf(__x); }
+  inline constexpr long double
+  cos(long double __x)
+  { return __builtin_cosl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    cos(_Tp __x)
+    { return __builtin_cos(__x); }
+  using ::cosh;
+  inline constexpr float
+  cosh(float __x)
+  { return __builtin_coshf(__x); }
+  inline constexpr long double
+  cosh(long double __x)
+  { return __builtin_coshl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    cosh(_Tp __x)
+    { return __builtin_cosh(__x); }
+  using ::exp;
+  inline constexpr float
+  exp(float __x)
+  { return __builtin_expf(__x); }
+  inline constexpr long double
+  exp(long double __x)
+  { return __builtin_expl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    exp(_Tp __x)
+    { return __builtin_exp(__x); }
+  using ::fabs;
+  inline constexpr float
+  fabs(float __x)
+  { return __builtin_fabsf(__x); }
+  inline constexpr long double
+  fabs(long double __x)
+  { return __builtin_fabsl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    fabs(_Tp __x)
+    { return __builtin_fabs(__x); }
+  using ::floor;
+  inline constexpr float
+  floor(float __x)
+  { return __builtin_floorf(__x); }
+  inline constexpr long double
+  floor(long double __x)
+  { return __builtin_floorl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    floor(_Tp __x)
+    { return __builtin_floor(__x); }
+  using ::fmod;
+  inline constexpr float
+  fmod(float __x, float __y)
+  { return __builtin_fmodf(__x, __y); }
+  inline constexpr long double
+  fmod(long double __x, long double __y)
+  { return __builtin_fmodl(__x, __y); }
+  template<typename _Tp, typename _Up>
+    inline constexpr
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmod(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmod(__type(__x), __type(__y));
+    }
+  using ::frexp;
+  inline float
+  frexp(float __x, int* __exp)
+  { return __builtin_frexpf(__x, __exp); }
+  inline long double
+  frexp(long double __x, int* __exp)
+  { return __builtin_frexpl(__x, __exp); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    frexp(_Tp __x, int* __exp)
+    { return __builtin_frexp(__x, __exp); }
+  using ::ldexp;
+  inline constexpr float
+  ldexp(float __x, int __exp)
+  { return __builtin_ldexpf(__x, __exp); }
+  inline constexpr long double
+  ldexp(long double __x, int __exp)
+  { return __builtin_ldexpl(__x, __exp); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    ldexp(_Tp __x, int __exp)
+    { return __builtin_ldexp(__x, __exp); }
+  using ::log;
+  inline constexpr float
+  log(float __x)
+  { return __builtin_logf(__x); }
+  inline constexpr long double
+  log(long double __x)
+  { return __builtin_logl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    log(_Tp __x)
+    { return __builtin_log(__x); }
+  using ::log10;
+  inline constexpr float
+  log10(float __x)
+  { return __builtin_log10f(__x); }
+  inline constexpr long double
+  log10(long double __x)
+  { return __builtin_log10l(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    log10(_Tp __x)
+    { return __builtin_log10(__x); }
+  using ::modf;
+  inline float
+  modf(float __x, float* __iptr)
+  { return __builtin_modff(__x, __iptr); }
+  inline long double
+  modf(long double __x, long double* __iptr)
+  { return __builtin_modfl(__x, __iptr); }
+  using ::pow;
+  inline constexpr float
+  pow(float __x, float __y)
+  { return __builtin_powf(__x, __y); }
+  inline constexpr long double
+  pow(long double __x, long double __y)
+  { return __builtin_powl(__x, __y); }
+  template<typename _Tp, typename _Up>
+    inline constexpr
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    pow(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return pow(__type(__x), __type(__y));
+    }
+  using ::sin;
+  inline constexpr float
+  sin(float __x)
+  { return __builtin_sinf(__x); }
+  inline constexpr long double
+  sin(long double __x)
+  { return __builtin_sinl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    sin(_Tp __x)
+    { return __builtin_sin(__x); }
+  using ::sinh;
+  inline constexpr float
+  sinh(float __x)
+  { return __builtin_sinhf(__x); }
+  inline constexpr long double
+  sinh(long double __x)
+  { return __builtin_sinhl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    sinh(_Tp __x)
+    { return __builtin_sinh(__x); }
+  using ::sqrt;
+  inline constexpr float
+  sqrt(float __x)
+  { return __builtin_sqrtf(__x); }
+  inline constexpr long double
+  sqrt(long double __x)
+  { return __builtin_sqrtl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    sqrt(_Tp __x)
+    { return __builtin_sqrt(__x); }
+  using ::tan;
+  inline constexpr float
+  tan(float __x)
+  { return __builtin_tanf(__x); }
+  inline constexpr long double
+  tan(long double __x)
+  { return __builtin_tanl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    tan(_Tp __x)
+    { return __builtin_tan(__x); }
+  using ::tanh;
+  inline constexpr float
+  tanh(float __x)
+  { return __builtin_tanhf(__x); }
+  inline constexpr long double
+  tanh(long double __x)
+  { return __builtin_tanhl(__x); }
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    tanh(_Tp __x)
+    { return __builtin_tanh(__x); }
+  constexpr int
+  fpclassify(float __x)
+  { return __builtin_fpclassify(0, 1, 4,
+    3, 2, __x); }
+  constexpr int
+  fpclassify(double __x)
+  { return __builtin_fpclassify(0, 1, 4,
+    3, 2, __x); }
+  constexpr int
+  fpclassify(long double __x)
+  { return __builtin_fpclassify(0, 1, 4,
+    3, 2, __x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              int>::__type
+    fpclassify(_Tp __x)
+    { return __x != 0 ? 4 : 2; }
+  constexpr bool
+  isfinite(float __x)
+  { return __builtin_isfinite(__x); }
+  constexpr bool
+  isfinite(double __x)
+  { return __builtin_isfinite(__x); }
+  constexpr bool
+  isfinite(long double __x)
+  { return __builtin_isfinite(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isfinite(_Tp __x)
+    { return true; }
+  constexpr bool
+  isinf(float __x)
+  { return __builtin_isinf(__x); }
+  constexpr bool
+  isinf(double __x)
+  { return __builtin_isinf(__x); }
+  constexpr bool
+  isinf(long double __x)
+  { return __builtin_isinf(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isinf(_Tp __x)
+    { return false; }
+  constexpr bool
+  isnan(float __x)
+  { return __builtin_isnan(__x); }
+  constexpr bool
+  isnan(double __x)
+  { return __builtin_isnan(__x); }
+  constexpr bool
+  isnan(long double __x)
+  { return __builtin_isnan(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isnan(_Tp __x)
+    { return false; }
+  constexpr bool
+  isnormal(float __x)
+  { return __builtin_isnormal(__x); }
+  constexpr bool
+  isnormal(double __x)
+  { return __builtin_isnormal(__x); }
+  constexpr bool
+  isnormal(long double __x)
+  { return __builtin_isnormal(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    isnormal(_Tp __x)
+    { return __x != 0 ? true : false; }
+  constexpr bool
+  signbit(float __x)
+  { return __builtin_signbit(__x); }
+  constexpr bool
+  signbit(double __x)
+  { return __builtin_signbit(__x); }
+  constexpr bool
+  signbit(long double __x)
+  { return __builtin_signbit(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    signbit(_Tp __x)
+    { return __x < 0 ? true : false; }
+  constexpr bool
+  isgreater(float __x, float __y)
+  { return __builtin_isgreater(__x, __y); }
+  constexpr bool
+  isgreater(double __x, double __y)
+  { return __builtin_isgreater(__x, __y); }
+  constexpr bool
+  isgreater(long double __x, long double __y)
+  { return __builtin_isgreater(__x, __y); }
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isgreater(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isgreater(__type(__x), __type(__y));
+    }
+  constexpr bool
+  isgreaterequal(float __x, float __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+  constexpr bool
+  isgreaterequal(double __x, double __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+  constexpr bool
+  isgreaterequal(long double __x, long double __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isgreaterequal(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isgreaterequal(__type(__x), __type(__y));
+    }
+  constexpr bool
+  isless(float __x, float __y)
+  { return __builtin_isless(__x, __y); }
+  constexpr bool
+  isless(double __x, double __y)
+  { return __builtin_isless(__x, __y); }
+  constexpr bool
+  isless(long double __x, long double __y)
+  { return __builtin_isless(__x, __y); }
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isless(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isless(__type(__x), __type(__y));
+    }
+  constexpr bool
+  islessequal(float __x, float __y)
+  { return __builtin_islessequal(__x, __y); }
+  constexpr bool
+  islessequal(double __x, double __y)
+  { return __builtin_islessequal(__x, __y); }
+  constexpr bool
+  islessequal(long double __x, long double __y)
+  { return __builtin_islessequal(__x, __y); }
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    islessequal(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_islessequal(__type(__x), __type(__y));
+    }
+  constexpr bool
+  islessgreater(float __x, float __y)
+  { return __builtin_islessgreater(__x, __y); }
+  constexpr bool
+  islessgreater(double __x, double __y)
+  { return __builtin_islessgreater(__x, __y); }
+  constexpr bool
+  islessgreater(long double __x, long double __y)
+  { return __builtin_islessgreater(__x, __y); }
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    islessgreater(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_islessgreater(__type(__x), __type(__y));
+    }
+  constexpr bool
+  isunordered(float __x, float __y)
+  { return __builtin_isunordered(__x, __y); }
+  constexpr bool
+  isunordered(double __x, double __y)
+  { return __builtin_isunordered(__x, __y); }
+  constexpr bool
+  isunordered(long double __x, long double __y)
+  { return __builtin_isunordered(__x, __y); }
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isunordered(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isunordered(__type(__x), __type(__y));
+    }
+  using ::double_t;
+  using ::float_t;
+  using ::acosh;
+  using ::acoshf;
+  using ::acoshl;
+  using ::asinh;
+  using ::asinhf;
+  using ::asinhl;
+  using ::atanh;
+  using ::atanhf;
+  using ::atanhl;
+  using ::cbrt;
+  using ::cbrtf;
+  using ::cbrtl;
+  using ::copysign;
+  using ::copysignf;
+  using ::copysignl;
+  using ::erf;
+  using ::erff;
+  using ::erfl;
+  using ::erfc;
+  using ::erfcf;
+  using ::erfcl;
+  using ::exp2;
+  using ::exp2f;
+  using ::exp2l;
+  using ::expm1;
+  using ::expm1f;
+  using ::expm1l;
+  using ::fdim;
+  using ::fdimf;
+  using ::fdiml;
+  using ::fma;
+  using ::fmaf;
+  using ::fmal;
+  using ::fmax;
+  using ::fmaxf;
+  using ::fmaxl;
+  using ::fmin;
+  using ::fminf;
+  using ::fminl;
+  using ::hypot;
+  using ::hypotf;
+  using ::hypotl;
+  using ::ilogb;
+  using ::ilogbf;
+  using ::ilogbl;
+  using ::lgamma;
+  using ::lgammaf;
+  using ::lgammal;
+  using ::llrint;
+  using ::llrintf;
+  using ::llrintl;
+  using ::llround;
+  using ::llroundf;
+  using ::llroundl;
+  using ::log1p;
+  using ::log1pf;
+  using ::log1pl;
+  using ::log2;
+  using ::log2f;
+  using ::log2l;
+  using ::logb;
+  using ::logbf;
+  using ::logbl;
+  using ::lrint;
+  using ::lrintf;
+  using ::lrintl;
+  using ::lround;
+  using ::lroundf;
+  using ::lroundl;
+  using ::nan;
+  using ::nanf;
+  using ::nanl;
+  using ::nearbyint;
+  using ::nearbyintf;
+  using ::nearbyintl;
+  using ::nextafter;
+  using ::nextafterf;
+  using ::nextafterl;
+  using ::nexttoward;
+  using ::nexttowardf;
+  using ::nexttowardl;
+  using ::remainder;
+  using ::remainderf;
+  using ::remainderl;
+  using ::remquo;
+  using ::remquof;
+  using ::remquol;
+  using ::rint;
+  using ::rintf;
+  using ::rintl;
+  using ::round;
+  using ::roundf;
+  using ::roundl;
+  using ::scalbln;
+  using ::scalblnf;
+  using ::scalblnl;
+  using ::scalbn;
+  using ::scalbnf;
+  using ::scalbnl;
+  using ::tgamma;
+  using ::tgammaf;
+  using ::tgammal;
+  using ::trunc;
+  using ::truncf;
+  using ::truncl;
+  constexpr float
+  acosh(float __x)
+  { return __builtin_acoshf(__x); }
+  constexpr long double
+  acosh(long double __x)
+  { return __builtin_acoshl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    acosh(_Tp __x)
+    { return __builtin_acosh(__x); }
+  constexpr float
+  asinh(float __x)
+  { return __builtin_asinhf(__x); }
+  constexpr long double
+  asinh(long double __x)
+  { return __builtin_asinhl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    asinh(_Tp __x)
+    { return __builtin_asinh(__x); }
+  constexpr float
+  atanh(float __x)
+  { return __builtin_atanhf(__x); }
+  constexpr long double
+  atanh(long double __x)
+  { return __builtin_atanhl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    atanh(_Tp __x)
+    { return __builtin_atanh(__x); }
+  constexpr float
+  cbrt(float __x)
+  { return __builtin_cbrtf(__x); }
+  constexpr long double
+  cbrt(long double __x)
+  { return __builtin_cbrtl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    cbrt(_Tp __x)
+    { return __builtin_cbrt(__x); }
+  constexpr float
+  copysign(float __x, float __y)
+  { return __builtin_copysignf(__x, __y); }
+  constexpr long double
+  copysign(long double __x, long double __y)
+  { return __builtin_copysignl(__x, __y); }
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    copysign(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return copysign(__type(__x), __type(__y));
+    }
+  constexpr float
+  erf(float __x)
+  { return __builtin_erff(__x); }
+  constexpr long double
+  erf(long double __x)
+  { return __builtin_erfl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    erf(_Tp __x)
+    { return __builtin_erf(__x); }
+  constexpr float
+  erfc(float __x)
+  { return __builtin_erfcf(__x); }
+  constexpr long double
+  erfc(long double __x)
+  { return __builtin_erfcl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    erfc(_Tp __x)
+    { return __builtin_erfc(__x); }
+  constexpr float
+  exp2(float __x)
+  { return __builtin_exp2f(__x); }
+  constexpr long double
+  exp2(long double __x)
+  { return __builtin_exp2l(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    exp2(_Tp __x)
+    { return __builtin_exp2(__x); }
+  constexpr float
+  expm1(float __x)
+  { return __builtin_expm1f(__x); }
+  constexpr long double
+  expm1(long double __x)
+  { return __builtin_expm1l(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    expm1(_Tp __x)
+    { return __builtin_expm1(__x); }
+  constexpr float
+  fdim(float __x, float __y)
+  { return __builtin_fdimf(__x, __y); }
+  constexpr long double
+  fdim(long double __x, long double __y)
+  { return __builtin_fdiml(__x, __y); }
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fdim(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fdim(__type(__x), __type(__y));
+    }
+  constexpr float
+  fma(float __x, float __y, float __z)
+  { return __builtin_fmaf(__x, __y, __z); }
+  constexpr long double
+  fma(long double __x, long double __y, long double __z)
+  { return __builtin_fmal(__x, __y, __z); }
+  template<typename _Tp, typename _Up, typename _Vp>
+    constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
+    fma(_Tp __x, _Up __y, _Vp __z)
+    {
+      typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
+      return fma(__type(__x), __type(__y), __type(__z));
+    }
+  constexpr float
+  fmax(float __x, float __y)
+  { return __builtin_fmaxf(__x, __y); }
+  constexpr long double
+  fmax(long double __x, long double __y)
+  { return __builtin_fmaxl(__x, __y); }
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmax(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmax(__type(__x), __type(__y));
+    }
+  constexpr float
+  fmin(float __x, float __y)
+  { return __builtin_fminf(__x, __y); }
+  constexpr long double
+  fmin(long double __x, long double __y)
+  { return __builtin_fminl(__x, __y); }
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    fmin(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return fmin(__type(__x), __type(__y));
+    }
+  constexpr float
+  hypot(float __x, float __y)
+  { return __builtin_hypotf(__x, __y); }
+  constexpr long double
+  hypot(long double __x, long double __y)
+  { return __builtin_hypotl(__x, __y); }
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    hypot(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return hypot(__type(__x), __type(__y));
+    }
+  constexpr int
+  ilogb(float __x)
+  { return __builtin_ilogbf(__x); }
+  constexpr int
+  ilogb(long double __x)
+  { return __builtin_ilogbl(__x); }
+  template<typename _Tp>
+    constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    int>::__type
+    ilogb(_Tp __x)
+    { return __builtin_ilogb(__x); }
+  constexpr float
+  lgamma(float __x)
+  { return __builtin_lgammaf(__x); }
+  constexpr long double
+  lgamma(long double __x)
+  { return __builtin_lgammal(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    lgamma(_Tp __x)
+    { return __builtin_lgamma(__x); }
+  constexpr long long
+  llrint(float __x)
+  { return __builtin_llrintf(__x); }
+  constexpr long long
+  llrint(long double __x)
+  { return __builtin_llrintl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              long long>::__type
+    llrint(_Tp __x)
+    { return __builtin_llrint(__x); }
+  constexpr long long
+  llround(float __x)
+  { return __builtin_llroundf(__x); }
+  constexpr long long
+  llround(long double __x)
+  { return __builtin_llroundl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              long long>::__type
+    llround(_Tp __x)
+    { return __builtin_llround(__x); }
+  constexpr float
+  log1p(float __x)
+  { return __builtin_log1pf(__x); }
+  constexpr long double
+  log1p(long double __x)
+  { return __builtin_log1pl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    log1p(_Tp __x)
+    { return __builtin_log1p(__x); }
+  constexpr float
+  log2(float __x)
+  { return __builtin_log2f(__x); }
+  constexpr long double
+  log2(long double __x)
+  { return __builtin_log2l(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    log2(_Tp __x)
+    { return __builtin_log2(__x); }
+  constexpr float
+  logb(float __x)
+  { return __builtin_logbf(__x); }
+  constexpr long double
+  logb(long double __x)
+  { return __builtin_logbl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    logb(_Tp __x)
+    { return __builtin_logb(__x); }
+  constexpr long
+  lrint(float __x)
+  { return __builtin_lrintf(__x); }
+  constexpr long
+  lrint(long double __x)
+  { return __builtin_lrintl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              long>::__type
+    lrint(_Tp __x)
+    { return __builtin_lrint(__x); }
+  constexpr long
+  lround(float __x)
+  { return __builtin_lroundf(__x); }
+  constexpr long
+  lround(long double __x)
+  { return __builtin_lroundl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              long>::__type
+    lround(_Tp __x)
+    { return __builtin_lround(__x); }
+  constexpr float
+  nearbyint(float __x)
+  { return __builtin_nearbyintf(__x); }
+  constexpr long double
+  nearbyint(long double __x)
+  { return __builtin_nearbyintl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    nearbyint(_Tp __x)
+    { return __builtin_nearbyint(__x); }
+  constexpr float
+  nextafter(float __x, float __y)
+  { return __builtin_nextafterf(__x, __y); }
+  constexpr long double
+  nextafter(long double __x, long double __y)
+  { return __builtin_nextafterl(__x, __y); }
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    nextafter(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return nextafter(__type(__x), __type(__y));
+    }
+  constexpr float
+  nexttoward(float __x, long double __y)
+  { return __builtin_nexttowardf(__x, __y); }
+  constexpr long double
+  nexttoward(long double __x, long double __y)
+  { return __builtin_nexttowardl(__x, __y); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    nexttoward(_Tp __x, long double __y)
+    { return __builtin_nexttoward(__x, __y); }
+  constexpr float
+  remainder(float __x, float __y)
+  { return __builtin_remainderf(__x, __y); }
+  constexpr long double
+  remainder(long double __x, long double __y)
+  { return __builtin_remainderl(__x, __y); }
+  template<typename _Tp, typename _Up>
+    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    remainder(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return remainder(__type(__x), __type(__y));
+    }
+  inline float
+  remquo(float __x, float __y, int* __pquo)
+  { return __builtin_remquof(__x, __y, __pquo); }
+  inline long double
+  remquo(long double __x, long double __y, int* __pquo)
+  { return __builtin_remquol(__x, __y, __pquo); }
+  template<typename _Tp, typename _Up>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    remquo(_Tp __x, _Up __y, int* __pquo)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return remquo(__type(__x), __type(__y), __pquo);
+    }
+  constexpr float
+  rint(float __x)
+  { return __builtin_rintf(__x); }
+  constexpr long double
+  rint(long double __x)
+  { return __builtin_rintl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    rint(_Tp __x)
+    { return __builtin_rint(__x); }
+  constexpr float
+  round(float __x)
+  { return __builtin_roundf(__x); }
+  constexpr long double
+  round(long double __x)
+  { return __builtin_roundl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    round(_Tp __x)
+    { return __builtin_round(__x); }
+  constexpr float
+  scalbln(float __x, long __ex)
+  { return __builtin_scalblnf(__x, __ex); }
+  constexpr long double
+  scalbln(long double __x, long __ex)
+  { return __builtin_scalblnl(__x, __ex); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    scalbln(_Tp __x, long __ex)
+    { return __builtin_scalbln(__x, __ex); }
+  constexpr float
+  scalbn(float __x, int __ex)
+  { return __builtin_scalbnf(__x, __ex); }
+  constexpr long double
+  scalbn(long double __x, int __ex)
+  { return __builtin_scalbnl(__x, __ex); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    scalbn(_Tp __x, int __ex)
+    { return __builtin_scalbn(__x, __ex); }
+  constexpr float
+  tgamma(float __x)
+  { return __builtin_tgammaf(__x); }
+  constexpr long double
+  tgamma(long double __x)
+  { return __builtin_tgammal(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    tgamma(_Tp __x)
+    { return __builtin_tgamma(__x); }
+  constexpr float
+  trunc(float __x)
+  { return __builtin_truncf(__x); }
+  constexpr long double
+  trunc(long double __x)
+  { return __builtin_truncl(__x); }
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              double>::__type
+    trunc(_Tp __x)
+    { return __builtin_trunc(__x); }
+  template<typename _Tp>
+    inline _Tp
+    __hypot3(_Tp __x, _Tp __y, _Tp __z)
+    {
+      __x = std::abs(__x);
+      __y = std::abs(__y);
+      __z = std::abs(__z);
+      if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
+ return __a * std::sqrt((__x / __a) * (__x / __a)
+          + (__y / __a) * (__y / __a)
+          + (__z / __a) * (__z / __a));
+      else
+ return {};
+    }
+  inline float
+  hypot(float __x, float __y, float __z)
+  { return std::__hypot3<float>(__x, __y, __z); }
+  inline double
+  hypot(double __x, double __y, double __z)
+  { return std::__hypot3<double>(__x, __y, __z); }
+  inline long double
+  hypot(long double __x, long double __y, long double __z)
+  { return std::__hypot3<long double>(__x, __y, __z); }
+  template<typename _Tp, typename _Up, typename _Vp>
+    typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
+    hypot(_Tp __x, _Up __y, _Vp __z)
+    {
+      using __type = typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type;
+      return std::__hypot3<__type>(__x, __y, __z);
+    }
+
+}
+#pragma GCC visibility push(default)
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+    template<typename _Tp>
+    struct __floating_point_constant
+    {
+      static const _Tp __value;
+    };
+    template<typename _Tp>
+      struct __numeric_constants
+      {
+        static _Tp __pi() throw()
+        { return static_cast<_Tp>(3.1415926535897932384626433832795029L); }
+        static _Tp __pi_2() throw()
+        { return static_cast<_Tp>(1.5707963267948966192313216916397514L); }
+        static _Tp __pi_3() throw()
+        { return static_cast<_Tp>(1.0471975511965977461542144610931676L); }
+        static _Tp __pi_4() throw()
+        { return static_cast<_Tp>(0.7853981633974483096156608458198757L); }
+        static _Tp __1_pi() throw()
+        { return static_cast<_Tp>(0.3183098861837906715377675267450287L); }
+        static _Tp __2_sqrtpi() throw()
+        { return static_cast<_Tp>(1.1283791670955125738961589031215452L); }
+        static _Tp __sqrt2() throw()
+        { return static_cast<_Tp>(1.4142135623730950488016887242096981L); }
+        static _Tp __sqrt3() throw()
+        { return static_cast<_Tp>(1.7320508075688772935274463415058723L); }
+        static _Tp __sqrtpio2() throw()
+        { return static_cast<_Tp>(1.2533141373155002512078826424055226L); }
+        static _Tp __sqrt1_2() throw()
+        { return static_cast<_Tp>(0.7071067811865475244008443621048490L); }
+        static _Tp __lnpi() throw()
+        { return static_cast<_Tp>(1.1447298858494001741434273513530587L); }
+        static _Tp __gamma_e() throw()
+        { return static_cast<_Tp>(0.5772156649015328606065120900824024L); }
+        static _Tp __euler() throw()
+        { return static_cast<_Tp>(2.7182818284590452353602874713526625L); }
+      };
+    template<typename _Tp>
+    inline bool __isnan(_Tp __x)
+    { return std::isnan(__x); }
+  }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+    template <typename _Tp>
+    _Tp
+    __bernoulli_series(unsigned int __n)
+    {
+      static const _Tp __num[28] = {
+        _Tp(1UL), -_Tp(1UL) / _Tp(2UL),
+        _Tp(1UL) / _Tp(6UL), _Tp(0UL),
+        -_Tp(1UL) / _Tp(30UL), _Tp(0UL),
+        _Tp(1UL) / _Tp(42UL), _Tp(0UL),
+        -_Tp(1UL) / _Tp(30UL), _Tp(0UL),
+        _Tp(5UL) / _Tp(66UL), _Tp(0UL),
+        -_Tp(691UL) / _Tp(2730UL), _Tp(0UL),
+        _Tp(7UL) / _Tp(6UL), _Tp(0UL),
+        -_Tp(3617UL) / _Tp(510UL), _Tp(0UL),
+        _Tp(43867UL) / _Tp(798UL), _Tp(0UL),
+        -_Tp(174611) / _Tp(330UL), _Tp(0UL),
+        _Tp(854513UL) / _Tp(138UL), _Tp(0UL),
+        -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL),
+        _Tp(8553103UL) / _Tp(6UL), _Tp(0UL)
+      };
+      if (__n == 0)
+        return _Tp(1);
+      if (__n == 1)
+        return -_Tp(1) / _Tp(2);
+      if (__n % 2 == 1)
+        return _Tp(0);
+      if (__n < 28)
+        return __num[__n];
+      _Tp __fact = _Tp(1);
+      if ((__n / 2) % 2 == 0)
+        __fact *= _Tp(-1);
+      for (unsigned int __k = 1; __k <= __n; ++__k)
+        __fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi());
+      __fact *= _Tp(2);
+      _Tp __sum = _Tp(0);
+      for (unsigned int __i = 1; __i < 1000; ++__i)
+        {
+          _Tp __term = std::pow(_Tp(__i), -_Tp(__n));
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term;
+        }
+      return __fact * __sum;
+    }
+    template<typename _Tp>
+    inline _Tp
+    __bernoulli(int __n)
+    { return __bernoulli_series<_Tp>(__n); }
+    template<typename _Tp>
+    _Tp
+    __log_gamma_bernoulli(_Tp __x)
+    {
+      _Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x
+               + _Tp(0.5L) * std::log(_Tp(2)
+               * __numeric_constants<_Tp>::__pi());
+      const _Tp __xx = __x * __x;
+      _Tp __help = _Tp(1) / __x;
+      for ( unsigned int __i = 1; __i < 20; ++__i )
+        {
+          const _Tp __2i = _Tp(2 * __i);
+          __help /= __2i * (__2i - _Tp(1)) * __xx;
+          __lg += __bernoulli<_Tp>(2 * __i) * __help;
+        }
+      return __lg;
+    }
+    template<typename _Tp>
+    _Tp
+    __log_gamma_lanczos(_Tp __x)
+    {
+      const _Tp __xm1 = __x - _Tp(1);
+      static const _Tp __lanczos_cheb_7[9] = {
+       _Tp( 0.99999999999980993227684700473478L),
+       _Tp( 676.520368121885098567009190444019L),
+       _Tp(-1259.13921672240287047156078755283L),
+       _Tp( 771.3234287776530788486528258894L),
+       _Tp(-176.61502916214059906584551354L),
+       _Tp( 12.507343278686904814458936853L),
+       _Tp(-0.13857109526572011689554707L),
+       _Tp( 9.984369578019570859563e-6L),
+       _Tp( 1.50563273514931155834e-7L)
+      };
+      static const _Tp __LOGROOT2PI
+          = _Tp(0.9189385332046727417803297364056176L);
+      _Tp __sum = __lanczos_cheb_7[0];
+      for(unsigned int __k = 1; __k < 9; ++__k)
+        __sum += __lanczos_cheb_7[__k] / (__xm1 + __k);
+      const _Tp __term1 = (__xm1 + _Tp(0.5L))
+                        * std::log((__xm1 + _Tp(7.5L))
+                       / __numeric_constants<_Tp>::__euler());
+      const _Tp __term2 = __LOGROOT2PI + std::log(__sum);
+      const _Tp __result = __term1 + (__term2 - _Tp(7));
+      return __result;
+    }
+    template<typename _Tp>
+    _Tp
+    __log_gamma(_Tp __x)
+    {
+      if (__x > _Tp(0.5L))
+        return __log_gamma_lanczos(__x);
+      else
+        {
+          const _Tp __sin_fact
+                 = std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x));
+          if (__sin_fact == _Tp(0))
+            std::__throw_domain_error(("Argument is nonpositive integer " "in __log_gamma"));
+          return __numeric_constants<_Tp>::__lnpi()
+                     - std::log(__sin_fact)
+                     - __log_gamma_lanczos(_Tp(1) - __x);
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __log_gamma_sign(_Tp __x)
+    {
+      if (__x > _Tp(0))
+        return _Tp(1);
+      else
+        {
+          const _Tp __sin_fact
+                  = std::sin(__numeric_constants<_Tp>::__pi() * __x);
+          if (__sin_fact > _Tp(0))
+            return (1);
+          else if (__sin_fact < _Tp(0))
+            return -_Tp(1);
+          else
+            return _Tp(0);
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __log_bincoef(unsigned int __n, unsigned int __k)
+    {
+      static const _Tp __max_bincoeff
+                      = std::numeric_limits<_Tp>::max_exponent10
+                      * std::log(_Tp(10)) - _Tp(1);
+      _Tp __coeff = ::std::lgamma(_Tp(1 + __n))
+                  - ::std::lgamma(_Tp(1 + __k))
+                  - ::std::lgamma(_Tp(1 + __n - __k));
+    }
+    template<typename _Tp>
+    _Tp
+    __bincoef(unsigned int __n, unsigned int __k)
+    {
+      static const _Tp __max_bincoeff
+                      = std::numeric_limits<_Tp>::max_exponent10
+                      * std::log(_Tp(10)) - _Tp(1);
+      const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k);
+      if (__log_coeff > __max_bincoeff)
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return std::exp(__log_coeff);
+    }
+    template<typename _Tp>
+    inline _Tp
+    __gamma(_Tp __x)
+    { return std::exp(__log_gamma(__x)); }
+    template<typename _Tp>
+    _Tp
+    __psi_series(_Tp __x)
+    {
+      _Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x;
+      const unsigned int __max_iter = 100000;
+      for (unsigned int __k = 1; __k < __max_iter; ++__k)
+        {
+          const _Tp __term = __x / (__k * (__k + __x));
+          __sum += __term;
+          if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
+            break;
+        }
+      return __sum;
+    }
+    template<typename _Tp>
+    _Tp
+    __psi_asymp(_Tp __x)
+    {
+      _Tp __sum = std::log(__x) - _Tp(0.5L) / __x;
+      const _Tp __xx = __x * __x;
+      _Tp __xp = __xx;
+      const unsigned int __max_iter = 100;
+      for (unsigned int __k = 1; __k < __max_iter; ++__k)
+        {
+          const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp);
+          __sum -= __term;
+          if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __xp *= __xx;
+        }
+      return __sum;
+    }
+    template<typename _Tp>
+    _Tp
+    __psi(_Tp __x)
+    {
+      const int __n = static_cast<int>(__x + 0.5L);
+      const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon();
+      if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps)
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x < _Tp(0))
+        {
+          const _Tp __pi = __numeric_constants<_Tp>::__pi();
+          return __psi(_Tp(1) - __x)
+               - __pi * std::cos(__pi * __x) / std::sin(__pi * __x);
+        }
+      else if (__x > _Tp(100))
+        return __psi_asymp(__x);
+      else
+        return __psi_series(__x);
+    }
+    template<typename _Tp>
+    _Tp
+    __psi(unsigned int __n, _Tp __x)
+    {
+      if (__x <= _Tp(0))
+        std::__throw_domain_error(("Argument out of range " "in __psi"));
+      else if (__n == 0)
+        return __psi(__x);
+      else
+        {
+          const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x);
+          const _Tp __ln_nfact = ::std::lgamma(_Tp(__n + 1));
+          _Tp __result = std::exp(__ln_nfact) * __hzeta;
+          if (__n % 2 == 1)
+            __result = -__result;
+          return __result;
+        }
+    }
+  }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+    template <typename _Tp>
+    void
+    __gamma_temme(_Tp __mu,
+                  _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi)
+    {
+      __gampl = _Tp(1) / ::std::tgamma(_Tp(1) + __mu);
+      __gammi = _Tp(1) / ::std::tgamma(_Tp(1) - __mu);
+      if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon())
+        __gam1 = -_Tp(__numeric_constants<_Tp>::__gamma_e());
+      else
+        __gam1 = (__gammi - __gampl) / (_Tp(2) * __mu);
+      __gam2 = (__gammi + __gampl) / (_Tp(2));
+      return;
+    }
+    template <typename _Tp>
+    void
+    __bessel_jn(_Tp __nu, _Tp __x,
+                _Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu)
+    {
+      if (__x == _Tp(0))
+        {
+          if (__nu == _Tp(0))
+            {
+              __Jnu = _Tp(1);
+              __Jpnu = _Tp(0);
+            }
+          else if (__nu == _Tp(1))
+            {
+              __Jnu = _Tp(0);
+              __Jpnu = _Tp(0.5L);
+            }
+          else
+            {
+              __Jnu = _Tp(0);
+              __Jpnu = _Tp(0);
+            }
+          __Nnu = -std::numeric_limits<_Tp>::infinity();
+          __Npnu = std::numeric_limits<_Tp>::infinity();
+          return;
+        }
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __fp_min = std::sqrt(std::numeric_limits<_Tp>::min());
+      const int __max_iter = 15000;
+      const _Tp __x_min = _Tp(2);
+      const int __nl = (__x < __x_min
+                    ? static_cast<int>(__nu + _Tp(0.5L))
+                    : std::max(0, static_cast<int>(__nu - __x + _Tp(1.5L))));
+      const _Tp __mu = __nu - __nl;
+      const _Tp __mu2 = __mu * __mu;
+      const _Tp __xi = _Tp(1) / __x;
+      const _Tp __xi2 = _Tp(2) * __xi;
+      _Tp __w = __xi2 / __numeric_constants<_Tp>::__pi();
+      int __isign = 1;
+      _Tp __h = __nu * __xi;
+      if (__h < __fp_min)
+        __h = __fp_min;
+      _Tp __b = __xi2 * __nu;
+      _Tp __d = _Tp(0);
+      _Tp __c = __h;
+      int __i;
+      for (__i = 1; __i <= __max_iter; ++__i)
+        {
+          __b += __xi2;
+          __d = __b - __d;
+          if (std::abs(__d) < __fp_min)
+            __d = __fp_min;
+          __c = __b - _Tp(1) / __c;
+          if (std::abs(__c) < __fp_min)
+            __c = __fp_min;
+          __d = _Tp(1) / __d;
+          const _Tp __del = __c * __d;
+          __h *= __del;
+          if (__d < _Tp(0))
+            __isign = -__isign;
+          if (std::abs(__del - _Tp(1)) < __eps)
+            break;
+        }
+      if (__i > __max_iter)
+        std::__throw_runtime_error(("Argument x too large in __bessel_jn; " "try asymptotic expansion."));
+      _Tp __Jnul = __isign * __fp_min;
+      _Tp __Jpnul = __h * __Jnul;
+      _Tp __Jnul1 = __Jnul;
+      _Tp __Jpnu1 = __Jpnul;
+      _Tp __fact = __nu * __xi;
+      for ( int __l = __nl; __l >= 1; --__l )
+        {
+          const _Tp __Jnutemp = __fact * __Jnul + __Jpnul;
+          __fact -= __xi;
+          __Jpnul = __fact * __Jnutemp - __Jnul;
+          __Jnul = __Jnutemp;
+        }
+      if (__Jnul == _Tp(0))
+        __Jnul = __eps;
+      _Tp __f= __Jpnul / __Jnul;
+      _Tp __Nmu, __Nnu1, __Npmu, __Jmu;
+      if (__x < __x_min)
+        {
+          const _Tp __x2 = __x / _Tp(2);
+          const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
+          _Tp __fact = (std::abs(__pimu) < __eps
+                      ? _Tp(1) : __pimu / std::sin(__pimu));
+          _Tp __d = -std::log(__x2);
+          _Tp __e = __mu * __d;
+          _Tp __fact2 = (std::abs(__e) < __eps
+                       ? _Tp(1) : std::sinh(__e) / __e);
+          _Tp __gam1, __gam2, __gampl, __gammi;
+          __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
+          _Tp __ff = (_Tp(2) / __numeric_constants<_Tp>::__pi())
+                   * __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
+          __e = std::exp(__e);
+          _Tp __p = __e / (__numeric_constants<_Tp>::__pi() * __gampl);
+          _Tp __q = _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * __gammi);
+          const _Tp __pimu2 = __pimu / _Tp(2);
+          _Tp __fact3 = (std::abs(__pimu2) < __eps
+                       ? _Tp(1) : std::sin(__pimu2) / __pimu2 );
+          _Tp __r = __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3 * __fact3;
+          _Tp __c = _Tp(1);
+          __d = -__x2 * __x2;
+          _Tp __sum = __ff + __r * __q;
+          _Tp __sum1 = __p;
+          for (__i = 1; __i <= __max_iter; ++__i)
+            {
+              __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
+              __c *= __d / _Tp(__i);
+              __p /= _Tp(__i) - __mu;
+              __q /= _Tp(__i) + __mu;
+              const _Tp __del = __c * (__ff + __r * __q);
+              __sum += __del;
+              const _Tp __del1 = __c * __p - __i * __del;
+              __sum1 += __del1;
+              if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) )
+                break;
+            }
+          if ( __i > __max_iter )
+            std::__throw_runtime_error(("Bessel y series failed to converge " "in __bessel_jn."));
+          __Nmu = -__sum;
+          __Nnu1 = -__sum1 * __xi2;
+          __Npmu = __mu * __xi * __Nmu - __Nnu1;
+          __Jmu = __w / (__Npmu - __f * __Nmu);
+        }
+      else
+        {
+          _Tp __a = _Tp(0.25L) - __mu2;
+          _Tp __q = _Tp(1);
+          _Tp __p = -__xi / _Tp(2);
+          _Tp __br = _Tp(2) * __x;
+          _Tp __bi = _Tp(2);
+          _Tp __fact = __a * __xi / (__p * __p + __q * __q);
+          _Tp __cr = __br + __q * __fact;
+          _Tp __ci = __bi + __p * __fact;
+          _Tp __den = __br * __br + __bi * __bi;
+          _Tp __dr = __br / __den;
+          _Tp __di = -__bi / __den;
+          _Tp __dlr = __cr * __dr - __ci * __di;
+          _Tp __dli = __cr * __di + __ci * __dr;
+          _Tp __temp = __p * __dlr - __q * __dli;
+          __q = __p * __dli + __q * __dlr;
+          __p = __temp;
+          int __i;
+          for (__i = 2; __i <= __max_iter; ++__i)
+            {
+              __a += _Tp(2 * (__i - 1));
+              __bi += _Tp(2);
+              __dr = __a * __dr + __br;
+              __di = __a * __di + __bi;
+              if (std::abs(__dr) + std::abs(__di) < __fp_min)
+                __dr = __fp_min;
+              __fact = __a / (__cr * __cr + __ci * __ci);
+              __cr = __br + __cr * __fact;
+              __ci = __bi - __ci * __fact;
+              if (std::abs(__cr) + std::abs(__ci) < __fp_min)
+                __cr = __fp_min;
+              __den = __dr * __dr + __di * __di;
+              __dr /= __den;
+              __di /= -__den;
+              __dlr = __cr * __dr - __ci * __di;
+              __dli = __cr * __di + __ci * __dr;
+              __temp = __p * __dlr - __q * __dli;
+              __q = __p * __dli + __q * __dlr;
+              __p = __temp;
+              if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps)
+                break;
+          }
+          if (__i > __max_iter)
+            std::__throw_runtime_error(("Lentz's method failed " "in __bessel_jn."));
+          const _Tp __gam = (__p - __f) / __q;
+          __Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q));
+          __Jmu = ::std::copysign(__Jmu, __Jnul);
+          __Nmu = __gam * __Jmu;
+          __Npmu = (__p + __q / __gam) * __Nmu;
+          __Nnu1 = __mu * __xi * __Nmu - __Npmu;
+      }
+      __fact = __Jmu / __Jnul;
+      __Jnu = __fact * __Jnul1;
+      __Jpnu = __fact * __Jpnu1;
+      for (__i = 1; __i <= __nl; ++__i)
+        {
+          const _Tp __Nnutemp = (__mu + __i) * __xi2 * __Nnu1 - __Nmu;
+          __Nmu = __Nnu1;
+          __Nnu1 = __Nnutemp;
+        }
+      __Nnu = __Nmu;
+      __Npnu = __nu * __xi * __Nmu - __Nnu1;
+      return;
+    }
+    template <typename _Tp>
+    void
+    __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu)
+    {
+      const _Tp __mu = _Tp(4) * __nu * __nu;
+      const _Tp __mum1 = __mu - _Tp(1);
+      const _Tp __mum9 = __mu - _Tp(9);
+      const _Tp __mum25 = __mu - _Tp(25);
+      const _Tp __mum49 = __mu - _Tp(49);
+      const _Tp __xx = _Tp(64) * __x * __x;
+      const _Tp __P = _Tp(1) - __mum1 * __mum9 / (_Tp(2) * __xx)
+                    * (_Tp(1) - __mum25 * __mum49 / (_Tp(12) * __xx));
+      const _Tp __Q = __mum1 / (_Tp(8) * __x)
+                    * (_Tp(1) - __mum9 * __mum25 / (_Tp(6) * __xx));
+      const _Tp __chi = __x - (__nu + _Tp(0.5L))
+                            * __numeric_constants<_Tp>::__pi_2();
+      const _Tp __c = std::cos(__chi);
+      const _Tp __s = std::sin(__chi);
+      const _Tp __coef = std::sqrt(_Tp(2)
+                             / (__numeric_constants<_Tp>::__pi() * __x));
+      __Jnu = __coef * (__c * __P - __s * __Q);
+      __Nnu = __coef * (__s * __P + __c * __Q);
+      return;
+    }
+    template <typename _Tp>
+    _Tp
+    __cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn,
+                           unsigned int __max_iter)
+    {
+      if (__x == _Tp(0))
+ return __nu == _Tp(0) ? _Tp(1) : _Tp(0);
+      const _Tp __x2 = __x / _Tp(2);
+      _Tp __fact = __nu * std::log(__x2);
+      __fact -= ::std::lgamma(__nu + _Tp(1));
+      __fact = std::exp(__fact);
+      const _Tp __xx4 = __sgn * __x2 * __x2;
+      _Tp __Jn = _Tp(1);
+      _Tp __term = _Tp(1);
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          __term *= __xx4 / (_Tp(__i) * (__nu + _Tp(__i)));
+          __Jn += __term;
+          if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon())
+            break;
+        }
+      return __fact * __Jn;
+    }
+    template<typename _Tp>
+    _Tp
+    __cyl_bessel_j(_Tp __nu, _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(("Bad argument " "in __cyl_bessel_j."));
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
+        return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200);
+      else if (__x > _Tp(1000))
+        {
+          _Tp __J_nu, __N_nu;
+          __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu);
+          return __J_nu;
+        }
+      else
+        {
+          _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
+          __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          return __J_nu;
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __cyl_neumann_n(_Tp __nu, _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(("Bad argument " "in __cyl_neumann_n."));
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x > _Tp(1000))
+        {
+          _Tp __J_nu, __N_nu;
+          __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu);
+          return __N_nu;
+        }
+      else
+        {
+          _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
+          __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          return __N_nu;
+        }
+    }
+    template <typename _Tp>
+    void
+    __sph_bessel_jn(unsigned int __n, _Tp __x,
+                    _Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n)
+    {
+      const _Tp __nu = _Tp(__n) + _Tp(0.5L);
+      _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
+      __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+      const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
+                         / std::sqrt(__x);
+      __j_n = __factor * __J_nu;
+      __n_n = __factor * __N_nu;
+      __jp_n = __factor * __Jp_nu - __j_n / (_Tp(2) * __x);
+      __np_n = __factor * __Np_nu - __n_n / (_Tp(2) * __x);
+      return;
+    }
+    template <typename _Tp>
+    _Tp
+    __sph_bessel(unsigned int __n, _Tp __x)
+    {
+      if (__x < _Tp(0))
+        std::__throw_domain_error(("Bad argument " "in __sph_bessel."));
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x == _Tp(0))
+        {
+          if (__n == 0)
+            return _Tp(1);
+          else
+            return _Tp(0);
+        }
+      else
+        {
+          _Tp __j_n, __n_n, __jp_n, __np_n;
+          __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n);
+          return __j_n;
+        }
+    }
+    template <typename _Tp>
+    _Tp
+    __sph_neumann(unsigned int __n, _Tp __x)
+    {
+      if (__x < _Tp(0))
+        std::__throw_domain_error(("Bad argument " "in __sph_neumann."));
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x == _Tp(0))
+        return -std::numeric_limits<_Tp>::infinity();
+      else
+        {
+          _Tp __j_n, __n_n, __jp_n, __np_n;
+          __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n);
+          return __n_n;
+        }
+    }
+  }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+    template<typename _Tp>
+    _Tp
+    __beta_gamma(_Tp __x, _Tp __y)
+    {
+      _Tp __bet;
+      if (__x > __y)
+        {
+          __bet = ::std::tgamma(__x)
+                / ::std::tgamma(__x + __y);
+          __bet *= ::std::tgamma(__y);
+        }
+      else
+        {
+          __bet = ::std::tgamma(__y)
+                / ::std::tgamma(__x + __y);
+          __bet *= ::std::tgamma(__x);
+        }
+      return __bet;
+    }
+    template<typename _Tp>
+    _Tp
+    __beta_lgamma(_Tp __x, _Tp __y)
+    {
+      _Tp __bet = ::std::lgamma(__x)
+                + ::std::lgamma(__y)
+                - ::std::lgamma(__x + __y);
+      __bet = std::exp(__bet);
+      return __bet;
+    }
+    template<typename _Tp>
+    _Tp
+    __beta_product(_Tp __x, _Tp __y)
+    {
+      _Tp __bet = (__x + __y) / (__x * __y);
+      unsigned int __max_iter = 1000000;
+      for (unsigned int __k = 1; __k < __max_iter; ++__k)
+        {
+          _Tp __term = (_Tp(1) + (__x + __y) / __k)
+                     / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k));
+          __bet *= __term;
+        }
+      return __bet;
+    }
+    template<typename _Tp>
+    inline _Tp
+    __beta(_Tp __x, _Tp __y)
+    {
+      if (__isnan(__x) || __isnan(__y))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __beta_lgamma(__x, __y);
+    }
+  }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+    template<typename _Tp>
+    _Tp
+    __ellint_rf(_Tp __x, _Tp __y, _Tp __z)
+    {
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = _Tp(5) * __min;
+      const _Tp __uplim = __max / _Tp(5);
+      if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
+        std::__throw_domain_error(("Argument less than zero " "in __ellint_rf."));
+      else if (__x + __y < __lolim || __x + __z < __lolim
+            || __y + __z < __lolim)
+        std::__throw_domain_error(("Argument too small in __ellint_rf"));
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(1) / _Tp(24);
+          const _Tp __c2 = _Tp(1) / _Tp(10);
+          const _Tp __c3 = _Tp(3) / _Tp(44);
+          const _Tp __c4 = _Tp(1) / _Tp(14);
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+          _Tp __zn = __z;
+          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+          const _Tp __errtol = std::pow(__eps, _Tp(1) / _Tp(6));
+          _Tp __mu;
+          _Tp __xndev, __yndev, __zndev;
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + __yn + __zn) / _Tp(3);
+              __xndev = 2 - (__mu + __xn) / __mu;
+              __yndev = 2 - (__mu + __yn) / __mu;
+              __zndev = 2 - (__mu + __zn) / __mu;
+              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
+              __epsilon = std::max(__epsilon, std::abs(__zndev));
+              if (__epsilon < __errtol)
+                break;
+              const _Tp __xnroot = std::sqrt(__xn);
+              const _Tp __ynroot = std::sqrt(__yn);
+              const _Tp __znroot = std::sqrt(__zn);
+              const _Tp __lambda = __xnroot * (__ynroot + __znroot)
+                                 + __ynroot * __znroot;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+              __zn = __c0 * (__zn + __lambda);
+            }
+          const _Tp __e2 = __xndev * __yndev - __zndev * __zndev;
+          const _Tp __e3 = __xndev * __yndev * __zndev;
+          const _Tp __s = _Tp(1) + (__c1 * __e2 - __c2 - __c3 * __e3) * __e2
+                   + __c4 * __e3;
+          return __s / std::sqrt(__mu);
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_1_series(_Tp __k)
+    {
+      const _Tp __kk = __k * __k;
+      _Tp __term = __kk / _Tp(4);
+      _Tp __sum = _Tp(1) + __term;
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 2; __i < __max_iter; ++__i)
+        {
+          __term *= (2 * __i - 1) * __kk / (2 * __i);
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term;
+        }
+      return __numeric_constants<_Tp>::__pi_2() * __sum;
+    }
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_1(_Tp __k)
+    {
+      if (__isnan(__k))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) >= _Tp(1))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1));
+    }
+    template<typename _Tp>
+    _Tp
+    __ellint_1(_Tp __k, _Tp __phi)
+    {
+      if (__isnan(__k) || __isnan(__phi))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(("Bad argument in __ellint_1."));
+      else
+        {
+          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+                                   + _Tp(0.5L));
+          const _Tp __phi_red = __phi
+                              - __n * __numeric_constants<_Tp>::__pi();
+          const _Tp __s = std::sin(__phi_red);
+          const _Tp __c = std::cos(__phi_red);
+          const _Tp __F = __s
+                        * __ellint_rf(__c * __c,
+                                _Tp(1) - __k * __k * __s * __s, _Tp(1));
+          if (__n == 0)
+            return __F;
+          else
+            return __F + _Tp(2) * __n * __comp_ellint_1(__k);
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_2_series(_Tp __k)
+    {
+      const _Tp __kk = __k * __k;
+      _Tp __term = __kk;
+      _Tp __sum = __term;
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 2; __i < __max_iter; ++__i)
+        {
+          const _Tp __i2m = 2 * __i - 1;
+          const _Tp __i2 = 2 * __i;
+          __term *= __i2m * __i2m * __kk / (__i2 * __i2);
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term / __i2m;
+        }
+      return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum);
+    }
+    template<typename _Tp>
+    _Tp
+    __ellint_rd(_Tp __x, _Tp __y, _Tp __z)
+    {
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = _Tp(2) / std::pow(__max, _Tp(2) / _Tp(3));
+      const _Tp __uplim = std::pow(_Tp(0.1L) * __errtol / __min, _Tp(2) / _Tp(3));
+      if (__x < _Tp(0) || __y < _Tp(0))
+        std::__throw_domain_error(("Argument less than zero " "in __ellint_rd."));
+      else if (__x + __y < __lolim || __z < __lolim)
+        std::__throw_domain_error(("Argument too small " "in __ellint_rd."));
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(3) / _Tp(14);
+          const _Tp __c2 = _Tp(1) / _Tp(6);
+          const _Tp __c3 = _Tp(9) / _Tp(22);
+          const _Tp __c4 = _Tp(3) / _Tp(26);
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+          _Tp __zn = __z;
+          _Tp __sigma = _Tp(0);
+          _Tp __power4 = _Tp(1);
+          _Tp __mu;
+          _Tp __xndev, __yndev, __zndev;
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + __yn + _Tp(3) * __zn) / _Tp(5);
+              __xndev = (__mu - __xn) / __mu;
+              __yndev = (__mu - __yn) / __mu;
+              __zndev = (__mu - __zn) / __mu;
+              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
+              __epsilon = std::max(__epsilon, std::abs(__zndev));
+              if (__epsilon < __errtol)
+                break;
+              _Tp __xnroot = std::sqrt(__xn);
+              _Tp __ynroot = std::sqrt(__yn);
+              _Tp __znroot = std::sqrt(__zn);
+              _Tp __lambda = __xnroot * (__ynroot + __znroot)
+                           + __ynroot * __znroot;
+              __sigma += __power4 / (__znroot * (__zn + __lambda));
+              __power4 *= __c0;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+              __zn = __c0 * (__zn + __lambda);
+            }
+          _Tp __eaa = __xndev * __yndev;
+          _Tp __eb = __zndev * __zndev;
+          _Tp __ec = __eaa - __eb;
+          _Tp __ed = __eaa - _Tp(6) * __eb;
+          _Tp __ef = __ed + __ec + __ec;
+          _Tp __s1 = __ed * (-__c1 + __c3 * __ed
+                                   / _Tp(3) - _Tp(3) * __c4 * __zndev * __ef
+                                   / _Tp(2));
+          _Tp __s2 = __zndev
+                   * (__c2 * __ef
+                    + __zndev * (-__c3 * __ec - __zndev * __c4 - __eaa));
+          return _Tp(3) * __sigma + __power4 * (_Tp(1) + __s1 + __s2)
+                                        / (__mu * std::sqrt(__mu));
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_2(_Tp __k)
+    {
+      if (__isnan(__k))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) == 1)
+        return _Tp(1);
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(("Bad argument in __comp_ellint_2."));
+      else
+        {
+          const _Tp __kk = __k * __k;
+          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
+               - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3);
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __ellint_2(_Tp __k, _Tp __phi)
+    {
+      if (__isnan(__k) || __isnan(__phi))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(("Bad argument in __ellint_2."));
+      else
+        {
+          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+                                   + _Tp(0.5L));
+          const _Tp __phi_red = __phi
+                              - __n * __numeric_constants<_Tp>::__pi();
+          const _Tp __kk = __k * __k;
+          const _Tp __s = std::sin(__phi_red);
+          const _Tp __ss = __s * __s;
+          const _Tp __sss = __ss * __s;
+          const _Tp __c = std::cos(__phi_red);
+          const _Tp __cc = __c * __c;
+          const _Tp __E = __s
+                        * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
+                        - __kk * __sss
+                        * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1))
+                        / _Tp(3);
+          if (__n == 0)
+            return __E;
+          else
+            return __E + _Tp(2) * __n * __comp_ellint_2(__k);
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __ellint_rc(_Tp __x, _Tp __y)
+    {
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = _Tp(5) * __min;
+      const _Tp __uplim = __max / _Tp(5);
+      if (__x < _Tp(0) || __y < _Tp(0) || __x + __y < __lolim)
+        std::__throw_domain_error(("Argument less than zero " "in __ellint_rc."));
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(1) / _Tp(7);
+          const _Tp __c2 = _Tp(9) / _Tp(22);
+          const _Tp __c3 = _Tp(3) / _Tp(10);
+          const _Tp __c4 = _Tp(3) / _Tp(8);
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+          const _Tp __errtol = std::pow(__eps / _Tp(30), _Tp(1) / _Tp(6));
+          _Tp __mu;
+          _Tp __sn;
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + _Tp(2) * __yn) / _Tp(3);
+              __sn = (__yn + __mu) / __mu - _Tp(2);
+              if (std::abs(__sn) < __errtol)
+                break;
+              const _Tp __lambda = _Tp(2) * std::sqrt(__xn) * std::sqrt(__yn)
+                             + __yn;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+            }
+          _Tp __s = __sn * __sn
+                  * (__c3 + __sn*(__c1 + __sn * (__c4 + __sn * __c2)));
+          return (_Tp(1) + __s) / std::sqrt(__mu);
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p)
+    {
+      const _Tp __min = std::numeric_limits<_Tp>::min();
+      const _Tp __max = std::numeric_limits<_Tp>::max();
+      const _Tp __lolim = std::pow(_Tp(5) * __min, _Tp(1)/_Tp(3));
+      const _Tp __uplim = _Tp(0.3L)
+                        * std::pow(_Tp(0.2L) * __max, _Tp(1)/_Tp(3));
+      if (__x < _Tp(0) || __y < _Tp(0) || __z < _Tp(0))
+        std::__throw_domain_error(("Argument less than zero " "in __ellint_rj."));
+      else if (__x + __y < __lolim || __x + __z < __lolim
+            || __y + __z < __lolim || __p < __lolim)
+        std::__throw_domain_error(("Argument too small " "in __ellint_rj"));
+      else
+        {
+          const _Tp __c0 = _Tp(1) / _Tp(4);
+          const _Tp __c1 = _Tp(3) / _Tp(14);
+          const _Tp __c2 = _Tp(1) / _Tp(3);
+          const _Tp __c3 = _Tp(3) / _Tp(22);
+          const _Tp __c4 = _Tp(3) / _Tp(26);
+          _Tp __xn = __x;
+          _Tp __yn = __y;
+          _Tp __zn = __z;
+          _Tp __pn = __p;
+          _Tp __sigma = _Tp(0);
+          _Tp __power4 = _Tp(1);
+          const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+          const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
+          _Tp __lambda, __mu;
+          _Tp __xndev, __yndev, __zndev, __pndev;
+          const unsigned int __max_iter = 100;
+          for (unsigned int __iter = 0; __iter < __max_iter; ++__iter)
+            {
+              __mu = (__xn + __yn + __zn + _Tp(2) * __pn) / _Tp(5);
+              __xndev = (__mu - __xn) / __mu;
+              __yndev = (__mu - __yn) / __mu;
+              __zndev = (__mu - __zn) / __mu;
+              __pndev = (__mu - __pn) / __mu;
+              _Tp __epsilon = std::max(std::abs(__xndev), std::abs(__yndev));
+              __epsilon = std::max(__epsilon, std::abs(__zndev));
+              __epsilon = std::max(__epsilon, std::abs(__pndev));
+              if (__epsilon < __errtol)
+                break;
+              const _Tp __xnroot = std::sqrt(__xn);
+              const _Tp __ynroot = std::sqrt(__yn);
+              const _Tp __znroot = std::sqrt(__zn);
+              const _Tp __lambda = __xnroot * (__ynroot + __znroot)
+                                 + __ynroot * __znroot;
+              const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot)
+                                + __xnroot * __ynroot * __znroot;
+              const _Tp __alpha2 = __alpha1 * __alpha1;
+              const _Tp __beta = __pn * (__pn + __lambda)
+                                      * (__pn + __lambda);
+              __sigma += __power4 * __ellint_rc(__alpha2, __beta);
+              __power4 *= __c0;
+              __xn = __c0 * (__xn + __lambda);
+              __yn = __c0 * (__yn + __lambda);
+              __zn = __c0 * (__zn + __lambda);
+              __pn = __c0 * (__pn + __lambda);
+            }
+          _Tp __eaa = __xndev * (__yndev + __zndev) + __yndev * __zndev;
+          _Tp __eb = __xndev * __yndev * __zndev;
+          _Tp __ec = __pndev * __pndev;
+          _Tp __e2 = __eaa - _Tp(3) * __ec;
+          _Tp __e3 = __eb + _Tp(2) * __pndev * (__eaa - __ec);
+          _Tp __s1 = _Tp(1) + __e2 * (-__c1 + _Tp(3) * __c3 * __e2 / _Tp(4)
+                            - _Tp(3) * __c4 * __e3 / _Tp(2));
+          _Tp __s2 = __eb * (__c2 / _Tp(2)
+                   + __pndev * (-__c3 - __c3 + __pndev * __c4));
+          _Tp __s3 = __pndev * __eaa * (__c2 - __pndev * __c3)
+                   - __c2 * __pndev * __ec;
+          return _Tp(3) * __sigma + __power4 * (__s1 + __s2 + __s3)
+                                             / (__mu * std::sqrt(__mu));
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __comp_ellint_3(_Tp __k, _Tp __nu)
+    {
+      if (__isnan(__k) || __isnan(__nu))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__nu == _Tp(1))
+        return std::numeric_limits<_Tp>::infinity();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(("Bad argument in __comp_ellint_3."));
+      else
+        {
+          const _Tp __kk = __k * __k;
+          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
+               + __nu
+               * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu)
+               / _Tp(3);
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __ellint_3(_Tp __k, _Tp __nu, _Tp __phi)
+    {
+      if (__isnan(__k) || __isnan(__nu) || __isnan(__phi))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (std::abs(__k) > _Tp(1))
+        std::__throw_domain_error(("Bad argument in __ellint_3."));
+      else
+        {
+          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
+                                   + _Tp(0.5L));
+          const _Tp __phi_red = __phi
+                              - __n * __numeric_constants<_Tp>::__pi();
+          const _Tp __kk = __k * __k;
+          const _Tp __s = std::sin(__phi_red);
+          const _Tp __ss = __s * __s;
+          const _Tp __sss = __ss * __s;
+          const _Tp __c = std::cos(__phi_red);
+          const _Tp __cc = __c * __c;
+          const _Tp __Pi = __s
+                         * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
+                         + __nu * __sss
+                         * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1),
+                                       _Tp(1) - __nu * __ss) / _Tp(3);
+          if (__n == 0)
+            return __Pi;
+          else
+            return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu);
+        }
+    }
+  }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+    template<typename _Tp> _Tp __expint_E1(_Tp);
+    template<typename _Tp>
+    _Tp
+    __expint_E1_series(_Tp __x)
+    {
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      _Tp __term = _Tp(1);
+      _Tp __esum = _Tp(0);
+      _Tp __osum = _Tp(0);
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          __term *= - __x / __i;
+          if (std::abs(__term) < __eps)
+            break;
+          if (__term >= _Tp(0))
+            __esum += __term / __i;
+          else
+            __osum += __term / __i;
+        }
+      return - __esum - __osum
+             - __numeric_constants<_Tp>::__gamma_e() - std::log(__x);
+    }
+    template<typename _Tp>
+    _Tp
+    __expint_E1_asymp(_Tp __x)
+    {
+      _Tp __term = _Tp(1);
+      _Tp __esum = _Tp(1);
+      _Tp __osum = _Tp(0);
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          _Tp __prev = __term;
+          __term *= - __i / __x;
+          if (std::abs(__term) > std::abs(__prev))
+            break;
+          if (__term >= _Tp(0))
+            __esum += __term;
+          else
+            __osum += __term;
+        }
+      return std::exp(- __x) * (__esum + __osum) / __x;
+    }
+    template<typename _Tp>
+    _Tp
+    __expint_En_series(unsigned int __n, _Tp __x)
+    {
+      const unsigned int __max_iter = 1000;
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const int __nm1 = __n - 1;
+      _Tp __ans = (__nm1 != 0
+                ? _Tp(1) / __nm1 : -std::log(__x)
+                                   - __numeric_constants<_Tp>::__gamma_e());
+      _Tp __fact = _Tp(1);
+      for (int __i = 1; __i <= __max_iter; ++__i)
+        {
+          __fact *= -__x / _Tp(__i);
+          _Tp __del;
+          if ( __i != __nm1 )
+            __del = -__fact / _Tp(__i - __nm1);
+          else
+            {
+              _Tp __psi = -__numeric_constants<_Tp>::gamma_e();
+              for (int __ii = 1; __ii <= __nm1; ++__ii)
+                __psi += _Tp(1) / _Tp(__ii);
+              __del = __fact * (__psi - std::log(__x));
+            }
+          __ans += __del;
+          if (std::abs(__del) < __eps * std::abs(__ans))
+            return __ans;
+        }
+      std::__throw_runtime_error(("Series summation failed " "in __expint_En_series."));
+    }
+    template<typename _Tp>
+    _Tp
+    __expint_En_cont_frac(unsigned int __n, _Tp __x)
+    {
+      const unsigned int __max_iter = 1000;
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __fp_min = std::numeric_limits<_Tp>::min();
+      const int __nm1 = __n - 1;
+      _Tp __b = __x + _Tp(__n);
+      _Tp __c = _Tp(1) / __fp_min;
+      _Tp __d = _Tp(1) / __b;
+      _Tp __h = __d;
+      for ( unsigned int __i = 1; __i <= __max_iter; ++__i )
+        {
+          _Tp __a = -_Tp(__i * (__nm1 + __i));
+          __b += _Tp(2);
+          __d = _Tp(1) / (__a * __d + __b);
+          __c = __b + __a / __c;
+          const _Tp __del = __c * __d;
+          __h *= __del;
+          if (std::abs(__del - _Tp(1)) < __eps)
+            {
+              const _Tp __ans = __h * std::exp(-__x);
+              return __ans;
+            }
+        }
+      std::__throw_runtime_error(("Continued fraction failed " "in __expint_En_cont_frac."));
+    }
+    template<typename _Tp>
+    _Tp
+    __expint_En_recursion(unsigned int __n, _Tp __x)
+    {
+      _Tp __En;
+      _Tp __E1 = __expint_E1(__x);
+      if (__x < _Tp(__n))
+        {
+          __En = __E1;
+          for (unsigned int __j = 2; __j < __n; ++__j)
+            __En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1);
+        }
+      else
+        {
+          __En = _Tp(1);
+          const int __N = __n + 20;
+          _Tp __save = _Tp(0);
+          for (int __j = __N; __j > 0; --__j)
+            {
+              __En = (std::exp(-__x) - __j * __En) / __x;
+              if (__j == __n)
+                __save = __En;
+            }
+            _Tp __norm = __En / __E1;
+            __En /= __norm;
+        }
+      return __En;
+    }
+    template<typename _Tp>
+    _Tp
+    __expint_Ei_series(_Tp __x)
+    {
+      _Tp __term = _Tp(1);
+      _Tp __sum = _Tp(0);
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          __term *= __x / __i;
+          __sum += __term / __i;
+          if (__term < std::numeric_limits<_Tp>::epsilon() * __sum)
+            break;
+        }
+      return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x);
+    }
+    template<typename _Tp>
+    _Tp
+    __expint_Ei_asymp(_Tp __x)
+    {
+      _Tp __term = _Tp(1);
+      _Tp __sum = _Tp(1);
+      const unsigned int __max_iter = 1000;
+      for (unsigned int __i = 1; __i < __max_iter; ++__i)
+        {
+          _Tp __prev = __term;
+          __term *= __i / __x;
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            break;
+          if (__term >= __prev)
+            break;
+          __sum += __term;
+        }
+      return std::exp(__x) * __sum / __x;
+    }
+    template<typename _Tp>
+    _Tp
+    __expint_Ei(_Tp __x)
+    {
+      if (__x < _Tp(0))
+        return -__expint_E1(-__x);
+      else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon()))
+        return __expint_Ei_series(__x);
+      else
+        return __expint_Ei_asymp(__x);
+    }
+    template<typename _Tp>
+    _Tp
+    __expint_E1(_Tp __x)
+    {
+      if (__x < _Tp(0))
+        return -__expint_Ei(-__x);
+      else if (__x < _Tp(1))
+        return __expint_E1_series(__x);
+      else if (__x < _Tp(100))
+        return __expint_En_cont_frac(1, __x);
+      else
+        return __expint_E1_asymp(__x);
+    }
+    template<typename _Tp>
+    _Tp
+    __expint_asymp(unsigned int __n, _Tp __x)
+    {
+      _Tp __term = _Tp(1);
+      _Tp __sum = _Tp(1);
+      for (unsigned int __i = 1; __i <= __n; ++__i)
+        {
+          _Tp __prev = __term;
+          __term *= -(__n - __i + 1) / __x;
+          if (std::abs(__term) > std::abs(__prev))
+            break;
+          __sum += __term;
+        }
+      return std::exp(-__x) * __sum / __x;
+    }
+    template<typename _Tp>
+    _Tp
+    __expint_large_n(unsigned int __n, _Tp __x)
+    {
+      const _Tp __xpn = __x + __n;
+      const _Tp __xpn2 = __xpn * __xpn;
+      _Tp __term = _Tp(1);
+      _Tp __sum = _Tp(1);
+      for (unsigned int __i = 1; __i <= __n; ++__i)
+        {
+          _Tp __prev = __term;
+          __term *= (__n - 2 * (__i - 1) * __x) / __xpn2;
+          if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __sum += __term;
+        }
+      return std::exp(-__x) * __sum / __xpn;
+    }
+    template<typename _Tp>
+    _Tp
+    __expint(unsigned int __n, _Tp __x)
+    {
+      if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__n <= 1 && __x == _Tp(0))
+        return std::numeric_limits<_Tp>::infinity();
+      else
+        {
+          _Tp __E0 = std::exp(__x) / __x;
+          if (__n == 0)
+            return __E0;
+          _Tp __E1 = __expint_E1(__x);
+          if (__n == 1)
+            return __E1;
+          if (__x == _Tp(0))
+            return _Tp(1) / static_cast<_Tp>(__n - 1);
+          _Tp __En = __expint_En_recursion(__n, __x);
+          return __En;
+        }
+    }
+    template<typename _Tp>
+    inline _Tp
+    __expint(_Tp __x)
+    {
+      if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __expint_Ei(__x);
+    }
+  }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+    template<typename _Tp>
+    _Tp
+    __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x)
+    {
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      _Tp __term = _Tp(1);
+      _Tp __Fac = _Tp(1);
+      const unsigned int __max_iter = 100000;
+      unsigned int __i;
+      for (__i = 0; __i < __max_iter; ++__i)
+        {
+          __term *= (__a + _Tp(__i)) * __x
+                  / ((__c + _Tp(__i)) * _Tp(1 + __i));
+          if (std::abs(__term) < __eps)
+            {
+              break;
+            }
+          __Fac += __term;
+        }
+      if (__i == __max_iter)
+        std::__throw_runtime_error(("Series failed to converge " "in __conf_hyperg_series."));
+      return __Fac;
+    }
+    template<typename _Tp>
+    _Tp
+    __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin)
+    {
+      const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
+      const int __nmax = 20000;
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __x = -__xin;
+      const _Tp __x3 = __x * __x * __x;
+      const _Tp __t0 = __a / __c;
+      const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c);
+      const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1)));
+      _Tp __F = _Tp(1);
+      _Tp __prec;
+      _Tp __Bnm3 = _Tp(1);
+      _Tp __Bnm2 = _Tp(1) + __t1 * __x;
+      _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);
+      _Tp __Anm3 = _Tp(1);
+      _Tp __Anm2 = __Bnm2 - __t0 * __x;
+      _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
+                 + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;
+      int __n = 3;
+      while(1)
+        {
+          _Tp __npam1 = _Tp(__n - 1) + __a;
+          _Tp __npcm1 = _Tp(__n - 1) + __c;
+          _Tp __npam2 = _Tp(__n - 2) + __a;
+          _Tp __npcm2 = _Tp(__n - 2) + __c;
+          _Tp __tnm1 = _Tp(2 * __n - 1);
+          _Tp __tnm3 = _Tp(2 * __n - 3);
+          _Tp __tnm5 = _Tp(2 * __n - 5);
+          _Tp __F1 = (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1);
+          _Tp __F2 = (_Tp(__n) + __a) * __npam1
+                   / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
+          _Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a)
+                   / (_Tp(8) * __tnm3 * __tnm3 * __tnm5
+                   * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
+          _Tp __E = -__npam1 * (_Tp(__n - 1) - __c)
+                   / (_Tp(2) * __tnm3 * __npcm2 * __npcm1);
+          _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
+                   + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
+          _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
+                   + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
+          _Tp __r = __An / __Bn;
+          __prec = std::abs((__F - __r) / __F);
+          __F = __r;
+          if (__prec < __eps || __n > __nmax)
+            break;
+          if (std::abs(__An) > __big || std::abs(__Bn) > __big)
+            {
+              __An /= __big;
+              __Bn /= __big;
+              __Anm1 /= __big;
+              __Bnm1 /= __big;
+              __Anm2 /= __big;
+              __Bnm2 /= __big;
+              __Anm3 /= __big;
+              __Bnm3 /= __big;
+            }
+          else if (std::abs(__An) < _Tp(1) / __big
+                || std::abs(__Bn) < _Tp(1) / __big)
+            {
+              __An *= __big;
+              __Bn *= __big;
+              __Anm1 *= __big;
+              __Bnm1 *= __big;
+              __Anm2 *= __big;
+              __Bnm2 *= __big;
+              __Anm3 *= __big;
+              __Bnm3 *= __big;
+            }
+          ++__n;
+          __Bnm3 = __Bnm2;
+          __Bnm2 = __Bnm1;
+          __Bnm1 = __Bn;
+          __Anm3 = __Anm2;
+          __Anm2 = __Anm1;
+          __Anm1 = __An;
+        }
+      if (__n >= __nmax)
+        std::__throw_runtime_error(("Iteration failed to converge " "in __conf_hyperg_luke."));
+      return __F;
+    }
+    template<typename _Tp>
+    _Tp
+    __conf_hyperg(_Tp __a, _Tp __c, _Tp __x)
+    {
+      const _Tp __c_nint = ::std::nearbyint(__c);
+      if (__isnan(__a) || __isnan(__c) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__c_nint == __c && __c_nint <= 0)
+        return std::numeric_limits<_Tp>::infinity();
+      else if (__a == _Tp(0))
+        return _Tp(1);
+      else if (__c == __a)
+        return std::exp(__x);
+      else if (__x < _Tp(0))
+        return __conf_hyperg_luke(__a, __c, __x);
+      else
+        return __conf_hyperg_series(__a, __c, __x);
+    }
+    template<typename _Tp>
+    _Tp
+    __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
+    {
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      _Tp __term = _Tp(1);
+      _Tp __Fabc = _Tp(1);
+      const unsigned int __max_iter = 100000;
+      unsigned int __i;
+      for (__i = 0; __i < __max_iter; ++__i)
+        {
+          __term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x
+                  / ((__c + _Tp(__i)) * _Tp(1 + __i));
+          if (std::abs(__term) < __eps)
+            {
+              break;
+            }
+          __Fabc += __term;
+        }
+      if (__i == __max_iter)
+        std::__throw_runtime_error(("Series failed to converge " "in __hyperg_series."));
+      return __Fabc;
+    }
+    template<typename _Tp>
+    _Tp
+    __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin)
+    {
+      const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
+      const int __nmax = 20000;
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __x = -__xin;
+      const _Tp __x3 = __x * __x * __x;
+      const _Tp __t0 = __a * __b / __c;
+      const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c);
+      const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2))
+                     / (_Tp(2) * (__c + _Tp(1)));
+      _Tp __F = _Tp(1);
+      _Tp __Bnm3 = _Tp(1);
+      _Tp __Bnm2 = _Tp(1) + __t1 * __x;
+      _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);
+      _Tp __Anm3 = _Tp(1);
+      _Tp __Anm2 = __Bnm2 - __t0 * __x;
+      _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
+                 + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;
+      int __n = 3;
+      while (1)
+        {
+          const _Tp __npam1 = _Tp(__n - 1) + __a;
+          const _Tp __npbm1 = _Tp(__n - 1) + __b;
+          const _Tp __npcm1 = _Tp(__n - 1) + __c;
+          const _Tp __npam2 = _Tp(__n - 2) + __a;
+          const _Tp __npbm2 = _Tp(__n - 2) + __b;
+          const _Tp __npcm2 = _Tp(__n - 2) + __c;
+          const _Tp __tnm1 = _Tp(2 * __n - 1);
+          const _Tp __tnm3 = _Tp(2 * __n - 3);
+          const _Tp __tnm5 = _Tp(2 * __n - 5);
+          const _Tp __n2 = __n * __n;
+          const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n
+                         + _Tp(2) - __a * __b - _Tp(2) * (__a + __b))
+                         / (_Tp(2) * __tnm3 * __npcm1);
+          const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n
+                         + _Tp(2) - __a * __b) * __npam1 * __npbm1
+                         / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
+          const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1
+                         * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b))
+                         / (_Tp(8) * __tnm3 * __tnm3 * __tnm5
+                         * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
+          const _Tp __E = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c)
+                         / (_Tp(2) * __tnm3 * __npcm2 * __npcm1);
+          _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
+                   + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
+          _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
+                   + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
+          const _Tp __r = __An / __Bn;
+          const _Tp __prec = std::abs((__F - __r) / __F);
+          __F = __r;
+          if (__prec < __eps || __n > __nmax)
+            break;
+          if (std::abs(__An) > __big || std::abs(__Bn) > __big)
+            {
+              __An /= __big;
+              __Bn /= __big;
+              __Anm1 /= __big;
+              __Bnm1 /= __big;
+              __Anm2 /= __big;
+              __Bnm2 /= __big;
+              __Anm3 /= __big;
+              __Bnm3 /= __big;
+            }
+          else if (std::abs(__An) < _Tp(1) / __big
+                || std::abs(__Bn) < _Tp(1) / __big)
+            {
+              __An *= __big;
+              __Bn *= __big;
+              __Anm1 *= __big;
+              __Bnm1 *= __big;
+              __Anm2 *= __big;
+              __Bnm2 *= __big;
+              __Anm3 *= __big;
+              __Bnm3 *= __big;
+            }
+          ++__n;
+          __Bnm3 = __Bnm2;
+          __Bnm2 = __Bnm1;
+          __Bnm1 = __Bn;
+          __Anm3 = __Anm2;
+          __Anm2 = __Anm1;
+          __Anm1 = __An;
+        }
+      if (__n >= __nmax)
+        std::__throw_runtime_error(("Iteration failed to converge " "in __hyperg_luke."));
+      return __F;
+    }
+    template<typename _Tp>
+    _Tp
+    __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
+    {
+      const _Tp __d = __c - __a - __b;
+      const int __intd = std::floor(__d + _Tp(0.5L));
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __toler = _Tp(1000) * __eps;
+      const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max());
+      const bool __d_integer = (std::abs(__d - __intd) < __toler);
+      if (__d_integer)
+        {
+          const _Tp __ln_omx = std::log(_Tp(1) - __x);
+          const _Tp __ad = std::abs(__d);
+          _Tp __F1, __F2;
+          _Tp __d1, __d2;
+          if (__d >= _Tp(0))
+            {
+              __d1 = __d;
+              __d2 = _Tp(0);
+            }
+          else
+            {
+              __d1 = _Tp(0);
+              __d2 = __d;
+            }
+          const _Tp __lng_c = __log_gamma(__c);
+          if (__ad < __eps)
+            {
+              __F1 = _Tp(0);
+            }
+          else
+            {
+              bool __ok_d1 = true;
+              _Tp __lng_ad, __lng_ad1, __lng_bd1;
+              try
+                {
+                  __lng_ad = __log_gamma(__ad);
+                  __lng_ad1 = __log_gamma(__a + __d1);
+                  __lng_bd1 = __log_gamma(__b + __d1);
+                }
+              catch(...)
+                {
+                  __ok_d1 = false;
+                }
+              if (__ok_d1)
+                {
+                  _Tp __sum1 = _Tp(1);
+                  _Tp __term = _Tp(1);
+                  _Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx
+                                - __lng_ad1 - __lng_bd1;
+                  for (int __i = 1; __i < __ad; ++__i)
+                    {
+                      const int __j = __i - 1;
+                      __term *= (__a + __d2 + __j) * (__b + __d2 + __j)
+                              / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x);
+                      __sum1 += __term;
+                    }
+                  if (__ln_pre1 > __log_max)
+                    std::__throw_runtime_error(("Overflow of gamma functions" " in __hyperg_luke."));
+                  else
+                    __F1 = std::exp(__ln_pre1) * __sum1;
+                }
+              else
+                {
+                  __F1 = _Tp(0);
+                }
+            }
+          bool __ok_d2 = true;
+          _Tp __lng_ad2, __lng_bd2;
+          try
+            {
+              __lng_ad2 = __log_gamma(__a + __d2);
+              __lng_bd2 = __log_gamma(__b + __d2);
+            }
+          catch(...)
+            {
+              __ok_d2 = false;
+            }
+          if (__ok_d2)
+            {
+              const int __maxiter = 2000;
+              const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e();
+              const _Tp __psi_1pd = __psi(_Tp(1) + __ad);
+              const _Tp __psi_apd1 = __psi(__a + __d1);
+              const _Tp __psi_bpd1 = __psi(__b + __d1);
+              _Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1
+                             - __psi_bpd1 - __ln_omx;
+              _Tp __fact = _Tp(1);
+              _Tp __sum2 = __psi_term;
+              _Tp __ln_pre2 = __lng_c + __d1 * __ln_omx
+                            - __lng_ad2 - __lng_bd2;
+              int __j;
+              for (__j = 1; __j < __maxiter; ++__j)
+                {
+                  const _Tp __term1 = _Tp(1) / _Tp(__j)
+                                    + _Tp(1) / (__ad + __j);
+                  const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1))
+                                    + _Tp(1) / (__b + __d1 + _Tp(__j - 1));
+                  __psi_term += __term1 - __term2;
+                  __fact *= (__a + __d1 + _Tp(__j - 1))
+                          * (__b + __d1 + _Tp(__j - 1))
+                          / ((__ad + __j) * __j) * (_Tp(1) - __x);
+                  const _Tp __delta = __fact * __psi_term;
+                  __sum2 += __delta;
+                  if (std::abs(__delta) < __eps * std::abs(__sum2))
+                    break;
+                }
+              if (__j == __maxiter)
+                std::__throw_runtime_error(("Sum F2 failed to converge " "in __hyperg_reflect"));
+              if (__sum2 == _Tp(0))
+                __F2 = _Tp(0);
+              else
+                __F2 = std::exp(__ln_pre2) * __sum2;
+            }
+          else
+            {
+              __F2 = _Tp(0);
+            }
+          const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1));
+          const _Tp __F = __F1 + __sgn_2 * __F2;
+          return __F;
+        }
+      else
+        {
+          bool __ok1 = true;
+          _Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0);
+          _Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0);
+          try
+            {
+              __sgn_g1ca = __log_gamma_sign(__c - __a);
+              __ln_g1ca = __log_gamma(__c - __a);
+              __sgn_g1cb = __log_gamma_sign(__c - __b);
+              __ln_g1cb = __log_gamma(__c - __b);
+            }
+          catch(...)
+            {
+              __ok1 = false;
+            }
+          bool __ok2 = true;
+          _Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0);
+          _Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0);
+          try
+            {
+              __sgn_g2a = __log_gamma_sign(__a);
+              __ln_g2a = __log_gamma(__a);
+              __sgn_g2b = __log_gamma_sign(__b);
+              __ln_g2b = __log_gamma(__b);
+            }
+          catch(...)
+            {
+              __ok2 = false;
+            }
+          const _Tp __sgn_gc = __log_gamma_sign(__c);
+          const _Tp __ln_gc = __log_gamma(__c);
+          const _Tp __sgn_gd = __log_gamma_sign(__d);
+          const _Tp __ln_gd = __log_gamma(__d);
+          const _Tp __sgn_gmd = __log_gamma_sign(-__d);
+          const _Tp __ln_gmd = __log_gamma(-__d);
+          const _Tp __sgn1 = __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1cb;
+          const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2b;
+          _Tp __pre1, __pre2;
+          if (__ok1 && __ok2)
+            {
+              _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb;
+              _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b
+                            + __d * std::log(_Tp(1) - __x);
+              if (__ln_pre1 < __log_max && __ln_pre2 < __log_max)
+                {
+                  __pre1 = std::exp(__ln_pre1);
+                  __pre2 = std::exp(__ln_pre2);
+                  __pre1 *= __sgn1;
+                  __pre2 *= __sgn2;
+                }
+              else
+                {
+                  std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect"));
+                }
+            }
+          else if (__ok1 && !__ok2)
+            {
+              _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb;
+              if (__ln_pre1 < __log_max)
+                {
+                  __pre1 = std::exp(__ln_pre1);
+                  __pre1 *= __sgn1;
+                  __pre2 = _Tp(0);
+                }
+              else
+                {
+                  std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect"));
+                }
+            }
+          else if (!__ok1 && __ok2)
+            {
+              _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b
+                            + __d * std::log(_Tp(1) - __x);
+              if (__ln_pre2 < __log_max)
+                {
+                  __pre1 = _Tp(0);
+                  __pre2 = std::exp(__ln_pre2);
+                  __pre2 *= __sgn2;
+                }
+              else
+                {
+                  std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect"));
+                }
+            }
+          else
+            {
+              __pre1 = _Tp(0);
+              __pre2 = _Tp(0);
+              std::__throw_runtime_error(("Underflow of gamma functions " "in __hyperg_reflect"));
+            }
+          const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d,
+                                           _Tp(1) - __x);
+          const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d,
+                                           _Tp(1) - __x);
+          const _Tp __F = __pre1 * __F1 + __pre2 * __F2;
+          return __F;
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
+    {
+      const _Tp __a_nint = ::std::nearbyint(__a);
+      const _Tp __b_nint = ::std::nearbyint(__b);
+      const _Tp __c_nint = ::std::nearbyint(__c);
+      const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon();
+      if (std::abs(__x) >= _Tp(1))
+        std::__throw_domain_error(("Argument outside unit circle " "in __hyperg."));
+      else if (__isnan(__a) || __isnan(__b)
+            || __isnan(__c) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__c_nint == __c && __c_nint <= _Tp(0))
+        return std::numeric_limits<_Tp>::infinity();
+      else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler)
+        return std::pow(_Tp(1) - __x, __c - __a - __b);
+      else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0)
+            && __x >= _Tp(0) && __x < _Tp(0.995L))
+        return __hyperg_series(__a, __b, __c, __x);
+      else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10))
+        {
+          if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler)
+            return __hyperg_series(__a_nint, __b, __c, __x);
+          else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler)
+            return __hyperg_series(__a, __b_nint, __c, __x);
+          else if (__x < -_Tp(0.25L))
+            return __hyperg_luke(__a, __b, __c, __x);
+          else if (__x < _Tp(0.5L))
+            return __hyperg_series(__a, __b, __c, __x);
+          else
+            if (std::abs(__c) > _Tp(10))
+              return __hyperg_series(__a, __b, __c, __x);
+            else
+              return __hyperg_reflect(__a, __b, __c, __x);
+        }
+      else
+        return __hyperg_luke(__a, __b, __c, __x);
+    }
+  }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+    template<typename _Tp>
+    _Tp
+    __poly_legendre_p(unsigned int __l, _Tp __x)
+    {
+      if ((__x < _Tp(-1)) || (__x > _Tp(+1)))
+        std::__throw_domain_error(("Argument out of range" " in __poly_legendre_p."));
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x == +_Tp(1))
+        return +_Tp(1);
+      else if (__x == -_Tp(1))
+        return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1));
+      else
+        {
+          _Tp __p_lm2 = _Tp(1);
+          if (__l == 0)
+            return __p_lm2;
+          _Tp __p_lm1 = __x;
+          if (__l == 1)
+            return __p_lm1;
+          _Tp __p_l = 0;
+          for (unsigned int __ll = 2; __ll <= __l; ++__ll)
+            {
+              __p_l = _Tp(2) * __x * __p_lm1 - __p_lm2
+                    - (__x * __p_lm1 - __p_lm2) / _Tp(__ll);
+              __p_lm2 = __p_lm1;
+              __p_lm1 = __p_l;
+            }
+          return __p_l;
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x)
+    {
+      if (__x < _Tp(-1) || __x > _Tp(+1))
+        std::__throw_domain_error(("Argument out of range" " in __assoc_legendre_p."));
+      else if (__m > __l)
+        std::__throw_domain_error(("Degree out of range" " in __assoc_legendre_p."));
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__m == 0)
+        return __poly_legendre_p(__l, __x);
+      else
+        {
+          _Tp __p_mm = _Tp(1);
+          if (__m > 0)
+            {
+              _Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x);
+              _Tp __fact = _Tp(1);
+              for (unsigned int __i = 1; __i <= __m; ++__i)
+                {
+                  __p_mm *= -__fact * __root;
+                  __fact += _Tp(2);
+                }
+            }
+          if (__l == __m)
+            return __p_mm;
+          _Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm;
+          if (__l == __m + 1)
+            return __p_mp1m;
+          _Tp __p_lm2m = __p_mm;
+          _Tp __P_lm1m = __p_mp1m;
+          _Tp __p_lm = _Tp(0);
+          for (unsigned int __j = __m + 2; __j <= __l; ++__j)
+            {
+              __p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m
+                      - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m);
+              __p_lm2m = __P_lm1m;
+              __P_lm1m = __p_lm;
+            }
+          return __p_lm;
+        }
+    }
+    template <typename _Tp>
+    _Tp
+    __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
+    {
+      if (__isnan(__theta))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      const _Tp __x = std::cos(__theta);
+      if (__l < __m)
+        {
+          std::__throw_domain_error(("Bad argument " "in __sph_legendre."));
+        }
+      else if (__m == 0)
+        {
+          _Tp __P = __poly_legendre_p(__l, __x);
+          _Tp __fact = std::sqrt(_Tp(2 * __l + 1)
+                     / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
+          __P *= __fact;
+          return __P;
+        }
+      else if (__x == _Tp(1) || __x == -_Tp(1))
+        {
+          return _Tp(0);
+        }
+      else
+        {
+          const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1));
+          const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3));
+          const _Tp __lncirc = ::std::log1p(-__x * __x);
+          const _Tp __lnpoch = ::std::lgamma(_Tp(__m + _Tp(0.5L)))
+                             - ::std::lgamma(_Tp(__m));
+          const _Tp __lnpre_val =
+                    -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi()
+                    + _Tp(0.5L) * (__lnpoch + __m * __lncirc);
+          _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m)
+                   / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
+          _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val);
+          _Tp __y_mp1m = __y_mp1m_factor * __y_mm;
+          if (__l == __m)
+            {
+              return __y_mm;
+            }
+          else if (__l == __m + 1)
+            {
+              return __y_mp1m;
+            }
+          else
+            {
+              _Tp __y_lm = _Tp(0);
+              for ( int __ll = __m + 2; __ll <= __l; ++__ll)
+                {
+                  const _Tp __rat1 = _Tp(__ll - __m) / _Tp(__ll + __m);
+                  const _Tp __rat2 = _Tp(__ll - __m - 1) / _Tp(__ll + __m - 1);
+                  const _Tp __fact1 = std::sqrt(__rat1 * _Tp(2 * __ll + 1)
+                                                       * _Tp(2 * __ll - 1));
+                  const _Tp __fact2 = std::sqrt(__rat1 * __rat2 * _Tp(2 * __ll + 1)
+                                                                / _Tp(2 * __ll - 3));
+                  __y_lm = (__x * __y_mp1m * __fact1
+                         - (__ll + __m - 1) * __y_mm * __fact2) / _Tp(__ll - __m);
+                  __y_mm = __y_mp1m;
+                  __y_mp1m = __y_lm;
+                }
+              return __y_lm;
+            }
+        }
+    }
+  }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+    template <typename _Tp>
+    void
+    __bessel_ik(_Tp __nu, _Tp __x,
+                _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu)
+    {
+      if (__x == _Tp(0))
+        {
+          if (__nu == _Tp(0))
+            {
+              __Inu = _Tp(1);
+              __Ipnu = _Tp(0);
+            }
+          else if (__nu == _Tp(1))
+            {
+              __Inu = _Tp(0);
+              __Ipnu = _Tp(0.5L);
+            }
+          else
+            {
+              __Inu = _Tp(0);
+              __Ipnu = _Tp(0);
+            }
+          __Knu = std::numeric_limits<_Tp>::infinity();
+          __Kpnu = -std::numeric_limits<_Tp>::infinity();
+          return;
+        }
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon();
+      const int __max_iter = 15000;
+      const _Tp __x_min = _Tp(2);
+      const int __nl = static_cast<int>(__nu + _Tp(0.5L));
+      const _Tp __mu = __nu - __nl;
+      const _Tp __mu2 = __mu * __mu;
+      const _Tp __xi = _Tp(1) / __x;
+      const _Tp __xi2 = _Tp(2) * __xi;
+      _Tp __h = __nu * __xi;
+      if ( __h < __fp_min )
+        __h = __fp_min;
+      _Tp __b = __xi2 * __nu;
+      _Tp __d = _Tp(0);
+      _Tp __c = __h;
+      int __i;
+      for ( __i = 1; __i <= __max_iter; ++__i )
+        {
+          __b += __xi2;
+          __d = _Tp(1) / (__b + __d);
+          __c = __b + _Tp(1) / __c;
+          const _Tp __del = __c * __d;
+          __h *= __del;
+          if (std::abs(__del - _Tp(1)) < __eps)
+            break;
+        }
+      if (__i > __max_iter)
+        std::__throw_runtime_error(("Argument x too large " "in __bessel_ik; " "try asymptotic expansion."));
+      _Tp __Inul = __fp_min;
+      _Tp __Ipnul = __h * __Inul;
+      _Tp __Inul1 = __Inul;
+      _Tp __Ipnu1 = __Ipnul;
+      _Tp __fact = __nu * __xi;
+      for (int __l = __nl; __l >= 1; --__l)
+        {
+          const _Tp __Inutemp = __fact * __Inul + __Ipnul;
+          __fact -= __xi;
+          __Ipnul = __fact * __Inutemp + __Inul;
+          __Inul = __Inutemp;
+        }
+      _Tp __f = __Ipnul / __Inul;
+      _Tp __Kmu, __Knu1;
+      if (__x < __x_min)
+        {
+          const _Tp __x2 = __x / _Tp(2);
+          const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
+          const _Tp __fact = (std::abs(__pimu) < __eps
+                            ? _Tp(1) : __pimu / std::sin(__pimu));
+          _Tp __d = -std::log(__x2);
+          _Tp __e = __mu * __d;
+          const _Tp __fact2 = (std::abs(__e) < __eps
+                            ? _Tp(1) : std::sinh(__e) / __e);
+          _Tp __gam1, __gam2, __gampl, __gammi;
+          __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
+          _Tp __ff = __fact
+                   * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
+          _Tp __sum = __ff;
+          __e = std::exp(__e);
+          _Tp __p = __e / (_Tp(2) * __gampl);
+          _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi);
+          _Tp __c = _Tp(1);
+          __d = __x2 * __x2;
+          _Tp __sum1 = __p;
+          int __i;
+          for (__i = 1; __i <= __max_iter; ++__i)
+            {
+              __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
+              __c *= __d / __i;
+              __p /= __i - __mu;
+              __q /= __i + __mu;
+              const _Tp __del = __c * __ff;
+              __sum += __del;
+              const _Tp __del1 = __c * (__p - __i * __ff);
+              __sum1 += __del1;
+              if (std::abs(__del) < __eps * std::abs(__sum))
+                break;
+            }
+          if (__i > __max_iter)
+            std::__throw_runtime_error(("Bessel k series failed to converge " "in __bessel_ik."));
+          __Kmu = __sum;
+          __Knu1 = __sum1 * __xi2;
+        }
+      else
+        {
+          _Tp __b = _Tp(2) * (_Tp(1) + __x);
+          _Tp __d = _Tp(1) / __b;
+          _Tp __delh = __d;
+          _Tp __h = __delh;
+          _Tp __q1 = _Tp(0);
+          _Tp __q2 = _Tp(1);
+          _Tp __a1 = _Tp(0.25L) - __mu2;
+          _Tp __q = __c = __a1;
+          _Tp __a = -__a1;
+          _Tp __s = _Tp(1) + __q * __delh;
+          int __i;
+          for (__i = 2; __i <= __max_iter; ++__i)
+            {
+              __a -= 2 * (__i - 1);
+              __c = -__a * __c / __i;
+              const _Tp __qnew = (__q1 - __b * __q2) / __a;
+              __q1 = __q2;
+              __q2 = __qnew;
+              __q += __c * __qnew;
+              __b += _Tp(2);
+              __d = _Tp(1) / (__b + __a * __d);
+              __delh = (__b * __d - _Tp(1)) * __delh;
+              __h += __delh;
+              const _Tp __dels = __q * __delh;
+              __s += __dels;
+              if ( std::abs(__dels / __s) < __eps )
+                break;
+            }
+          if (__i > __max_iter)
+            std::__throw_runtime_error(("Steed's method failed " "in __bessel_ik."));
+          __h = __a1 * __h;
+          __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x))
+                * std::exp(-__x) / __s;
+          __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi;
+        }
+      _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1;
+      _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu);
+      __Inu = __Inumu * __Inul1 / __Inul;
+      __Ipnu = __Inumu * __Ipnu1 / __Inul;
+      for ( __i = 1; __i <= __nl; ++__i )
+        {
+          const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu;
+          __Kmu = __Knu1;
+          __Knu1 = __Knutemp;
+        }
+      __Knu = __Kmu;
+      __Kpnu = __nu * __xi * __Kmu - __Knu1;
+      return;
+    }
+    template<typename _Tp>
+    _Tp
+    __cyl_bessel_i(_Tp __nu, _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i."));
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
+        return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200);
+      else
+        {
+          _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
+          __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          return __I_nu;
+        }
+    }
+    template<typename _Tp>
+    _Tp
+    __cyl_bessel_k(_Tp __nu, _Tp __x)
+    {
+      if (__nu < _Tp(0) || __x < _Tp(0))
+        std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k."));
+      else if (__isnan(__nu) || __isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        {
+          _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
+          __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          return __K_nu;
+        }
+    }
+    template <typename _Tp>
+    void
+    __sph_bessel_ik(unsigned int __n, _Tp __x,
+                    _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n)
+    {
+      const _Tp __nu = _Tp(__n) + _Tp(0.5L);
+      _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
+      __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+      const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
+                         / std::sqrt(__x);
+      __i_n = __factor * __I_nu;
+      __k_n = __factor * __K_nu;
+      __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x);
+      __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x);
+      return;
+    }
+    template <typename _Tp>
+    void
+    __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip)
+    {
+      const _Tp __absx = std::abs(__x);
+      const _Tp __rootx = std::sqrt(__absx);
+      const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3);
+      const _Tp _S_NaN = std::numeric_limits<_Tp>::quiet_NaN();
+      const _Tp _S_inf = std::numeric_limits<_Tp>::infinity();
+      if (__isnan(__x))
+        __Bip = __Aip = __Bi = __Ai = std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__z == _S_inf)
+        {
+   __Aip = __Ai = _Tp(0);
+   __Bip = __Bi = _S_inf;
+ }
+      else if (__z == -_S_inf)
+ __Bip = __Aip = __Bi = __Ai = _Tp(0);
+      else if (__x > _Tp(0))
+        {
+          _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
+          __bessel_ik(_Tp(1) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          __Ai = __rootx * __K_nu
+               / (__numeric_constants<_Tp>::__sqrt3()
+                * __numeric_constants<_Tp>::__pi());
+          __Bi = __rootx * (__K_nu / __numeric_constants<_Tp>::__pi()
+                 + _Tp(2) * __I_nu / __numeric_constants<_Tp>::__sqrt3());
+          __bessel_ik(_Tp(2) / _Tp(3), __z, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
+          __Aip = -__x * __K_nu
+                / (__numeric_constants<_Tp>::__sqrt3()
+                 * __numeric_constants<_Tp>::__pi());
+          __Bip = __x * (__K_nu / __numeric_constants<_Tp>::__pi()
+                      + _Tp(2) * __I_nu
+                      / __numeric_constants<_Tp>::__sqrt3());
+        }
+      else if (__x < _Tp(0))
+        {
+          _Tp __J_nu, __Jp_nu, __N_nu, __Np_nu;
+          __bessel_jn(_Tp(1) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          __Ai = __rootx * (__J_nu
+                    - __N_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
+          __Bi = -__rootx * (__N_nu
+                    + __J_nu / __numeric_constants<_Tp>::__sqrt3()) / _Tp(2);
+          __bessel_jn(_Tp(2) / _Tp(3), __z, __J_nu, __N_nu, __Jp_nu, __Np_nu);
+          __Aip = __absx * (__N_nu / __numeric_constants<_Tp>::__sqrt3()
+                          + __J_nu) / _Tp(2);
+          __Bip = __absx * (__J_nu / __numeric_constants<_Tp>::__sqrt3()
+                          - __N_nu) / _Tp(2);
+        }
+      else
+        {
+          __Ai = _Tp(0.35502805388781723926L);
+          __Bi = __Ai * __numeric_constants<_Tp>::__sqrt3();
+          __Aip = -_Tp(0.25881940379280679840L);
+          __Bip = -__Aip * __numeric_constants<_Tp>::__sqrt3();
+        }
+      return;
+    }
+  }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+    template<typename _Tp>
+    _Tp
+    __poly_hermite_recursion(unsigned int __n, _Tp __x)
+    {
+      _Tp __H_0 = 1;
+      if (__n == 0)
+        return __H_0;
+      _Tp __H_1 = 2 * __x;
+      if (__n == 1)
+        return __H_1;
+      _Tp __H_n, __H_nm1, __H_nm2;
+      unsigned int __i;
+      for (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i)
+        {
+          __H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2);
+          __H_nm2 = __H_nm1;
+          __H_nm1 = __H_n;
+        }
+      return __H_n;
+    }
+    template<typename _Tp>
+    inline _Tp
+    __poly_hermite(unsigned int __n, _Tp __x)
+    {
+      if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else
+        return __poly_hermite_recursion(__n, __x);
+    }
+  }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x)
+    {
+      const _Tp __a = -_Tp(__n);
+      const _Tp __b = _Tp(__alpha1) + _Tp(1);
+      const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a;
+      const _Tp __cos2th = __x / __eta;
+      const _Tp __sin2th = _Tp(1) - __cos2th;
+      const _Tp __th = std::acos(std::sqrt(__cos2th));
+      const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2()
+                        * __numeric_constants<_Tp>::__pi_2()
+                        * __eta * __eta * __cos2th * __sin2th;
+      const _Tp __lg_b = ::std::lgamma(_Tp(__n) + __b);
+      const _Tp __lnfact = ::std::lgamma(_Tp(__n + 1));
+      _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b)
+                      * std::log(_Tp(0.25L) * __x * __eta);
+      _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h);
+      _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x
+                      + __pre_term1 - __pre_term2;
+      _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi());
+      _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta
+                              * (_Tp(2) * __th
+                               - std::sin(_Tp(2) * __th))
+                               + __numeric_constants<_Tp>::__pi_4());
+      _Tp __ser = __ser_term1 + __ser_term2;
+      return std::exp(__lnpre) * __ser;
+    }
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x)
+    {
+      const _Tp __b = _Tp(__alpha1) + _Tp(1);
+      const _Tp __mx = -__x;
+      const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1)
+                         : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1)));
+      _Tp __tc = _Tp(1);
+      const _Tp __ax = std::abs(__x);
+      for (unsigned int __k = 1; __k <= __n; ++__k)
+        __tc *= (__ax / __k);
+      _Tp __term = __tc * __tc_sgn;
+      _Tp __sum = __term;
+      for (int __k = int(__n) - 1; __k >= 0; --__k)
+        {
+          __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k))
+                  * _Tp(__k + 1) / __mx;
+          __sum += __term;
+        }
+      return __sum;
+    }
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x)
+    {
+      _Tp __l_0 = _Tp(1);
+      if (__n == 0)
+        return __l_0;
+      _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1);
+      if (__n == 1)
+        return __l_1;
+      _Tp __l_n2 = __l_0;
+      _Tp __l_n1 = __l_1;
+      _Tp __l_n = _Tp(0);
+      for (unsigned int __nn = 2; __nn <= __n; ++__nn)
+        {
+            __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x)
+                  * __l_n1 / _Tp(__nn)
+                  - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn);
+            __l_n2 = __l_n1;
+            __l_n1 = __l_n;
+        }
+      return __l_n;
+    }
+    template<typename _Tpa, typename _Tp>
+    _Tp
+    __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x)
+    {
+      if (__x < _Tp(0))
+        std::__throw_domain_error(("Negative argument " "in __poly_laguerre."));
+      else if (__isnan(__x))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__n == 0)
+        return _Tp(1);
+      else if (__n == 1)
+        return _Tp(1) + _Tp(__alpha1) - __x;
+      else if (__x == _Tp(0))
+        {
+          _Tp __prod = _Tp(__alpha1) + _Tp(1);
+          for (unsigned int __k = 2; __k <= __n; ++__k)
+            __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k);
+          return __prod;
+        }
+      else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1)
+            && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n))
+        return __poly_laguerre_large_n(__n, __alpha1, __x);
+      else if (_Tp(__alpha1) >= _Tp(0)
+           || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1)))
+        return __poly_laguerre_recursion(__n, __alpha1, __x);
+      else
+        return __poly_laguerre_hyperg(__n, __alpha1, __x);
+    }
+    template<typename _Tp>
+    inline _Tp
+    __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
+    { return __poly_laguerre<unsigned int, _Tp>(__n, __m, __x); }
+    template<typename _Tp>
+    inline _Tp
+    __laguerre(unsigned int __n, _Tp __x)
+    { return __poly_laguerre<unsigned int, _Tp>(__n, 0, __x); }
+  }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  namespace __detail
+  {
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_sum(_Tp __s)
+    {
+      if (__s < _Tp(1))
+        std::__throw_domain_error(("Bad argument in zeta sum."));
+      const unsigned int max_iter = 10000;
+      _Tp __zeta = _Tp(0);
+      for (unsigned int __k = 1; __k < max_iter; ++__k)
+        {
+          _Tp __term = std::pow(static_cast<_Tp>(__k), -__s);
+          if (__term < std::numeric_limits<_Tp>::epsilon())
+            {
+              break;
+            }
+          __zeta += __term;
+        }
+      return __zeta;
+    }
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_alt(_Tp __s)
+    {
+      _Tp __sgn = _Tp(1);
+      _Tp __zeta = _Tp(0);
+      for (unsigned int __i = 1; __i < 10000000; ++__i)
+        {
+          _Tp __term = __sgn / std::pow(__i, __s);
+          if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
+            break;
+          __zeta += __term;
+          __sgn *= _Tp(-1);
+        }
+      __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);
+      return __zeta;
+    }
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_glob(_Tp __s)
+    {
+      _Tp __zeta = _Tp(0);
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
+                               * std::log(_Tp(10)) - _Tp(1);
+      if (__s < _Tp(0))
+        {
+          if (::std::fmod(__s,_Tp(2)) == _Tp(0))
+            return _Tp(0);
+          else
+            {
+              _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s);
+              __zeta *= std::pow(_Tp(2)
+                     * __numeric_constants<_Tp>::__pi(), __s)
+                     * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
+                     * std::exp(::std::lgamma(_Tp(1) - __s))
+                     / __numeric_constants<_Tp>::__pi();
+              return __zeta;
+            }
+        }
+      _Tp __num = _Tp(0.5L);
+      const unsigned int __maxit = 10000;
+      for (unsigned int __i = 0; __i < __maxit; ++__i)
+        {
+          bool __punt = false;
+          _Tp __sgn = _Tp(1);
+          _Tp __term = _Tp(0);
+          for (unsigned int __j = 0; __j <= __i; ++__j)
+            {
+              _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i))
+                              - ::std::lgamma(_Tp(1 + __j))
+                              - ::std::lgamma(_Tp(1 + __i - __j));
+              if (__bincoeff > __max_bincoeff)
+                {
+                  __punt = true;
+                  break;
+                }
+              __bincoeff = std::exp(__bincoeff);
+              __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s);
+              __sgn *= _Tp(-1);
+            }
+          if (__punt)
+            break;
+          __term *= __num;
+          __zeta += __term;
+          if (std::abs(__term/__zeta) < __eps)
+            break;
+          __num *= _Tp(0.5L);
+        }
+      __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);
+      return __zeta;
+    }
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta_product(_Tp __s)
+    {
+      static const _Tp __prime[] = {
+        _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19),
+        _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47),
+        _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79),
+        _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109)
+      };
+      static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp);
+      _Tp __zeta = _Tp(1);
+      for (unsigned int __i = 0; __i < __num_primes; ++__i)
+        {
+          const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s);
+          __zeta *= __fact;
+          if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon())
+            break;
+        }
+      __zeta = _Tp(1) / __zeta;
+      return __zeta;
+    }
+    template<typename _Tp>
+    _Tp
+    __riemann_zeta(_Tp __s)
+    {
+      if (__isnan(__s))
+        return std::numeric_limits<_Tp>::quiet_NaN();
+      else if (__s == _Tp(1))
+        return std::numeric_limits<_Tp>::infinity();
+      else if (__s < -_Tp(19))
+        {
+          _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s);
+          __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s)
+                 * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
+                 * std::exp(::std::lgamma(_Tp(1) - __s))
+                 / __numeric_constants<_Tp>::__pi();
+          return __zeta;
+        }
+      else if (__s < _Tp(20))
+        {
+          bool __glob = true;
+          if (__glob)
+            return __riemann_zeta_glob(__s);
+          else
+            {
+              if (__s > _Tp(1))
+                return __riemann_zeta_sum(__s);
+              else
+                {
+                  _Tp __zeta = std::pow(_Tp(2)
+                                * __numeric_constants<_Tp>::__pi(), __s)
+                         * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)
+                             * ::std::tgamma(_Tp(1) - __s)
+                             * __riemann_zeta_sum(_Tp(1) - __s);
+                  return __zeta;
+                }
+            }
+        }
+      else
+        return __riemann_zeta_product(__s);
+    }
+    template<typename _Tp>
+    _Tp
+    __hurwitz_zeta_glob(_Tp __a, _Tp __s)
+    {
+      _Tp __zeta = _Tp(0);
+      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
+      const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
+                               * std::log(_Tp(10)) - _Tp(1);
+      const unsigned int __maxit = 10000;
+      for (unsigned int __i = 0; __i < __maxit; ++__i)
+        {
+          bool __punt = false;
+          _Tp __sgn = _Tp(1);
+          _Tp __term = _Tp(0);
+          for (unsigned int __j = 0; __j <= __i; ++__j)
+            {
+              _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i))
+                              - ::std::lgamma(_Tp(1 + __j))
+                              - ::std::lgamma(_Tp(1 + __i - __j));
+              if (__bincoeff > __max_bincoeff)
+                {
+                  __punt = true;
+                  break;
+                }
+              __bincoeff = std::exp(__bincoeff);
+              __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s);
+              __sgn *= _Tp(-1);
+            }
+          if (__punt)
+            break;
+          __term /= _Tp(__i + 1);
+          if (std::abs(__term / __zeta) < __eps)
+            break;
+          __zeta += __term;
+        }
+      __zeta /= __s - _Tp(1);
+      return __zeta;
+    }
+    template<typename _Tp>
+    inline _Tp
+    __hurwitz_zeta(_Tp __a, _Tp __s)
+    { return __hurwitz_zeta_glob(__a, __s); }
+  }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  inline float
+  assoc_laguerref(unsigned int __n, unsigned int __m, float __x)
+  { return __detail::__assoc_laguerre<float>(__n, __m, __x); }
+  inline long double
+  assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x)
+  { return __detail::__assoc_laguerre<long double>(__n, __m, __x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__assoc_laguerre<__type>(__n, __m, __x);
+    }
+  inline float
+  assoc_legendref(unsigned int __l, unsigned int __m, float __x)
+  { return __detail::__assoc_legendre_p<float>(__l, __m, __x); }
+  inline long double
+  assoc_legendrel(unsigned int __l, unsigned int __m, long double __x)
+  { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
+    }
+  inline float
+  betaf(float __a, float __b)
+  { return __detail::__beta<float>(__a, __b); }
+  inline long double
+  betal(long double __a, long double __b)
+  { return __detail::__beta<long double>(__a, __b); }
+  template<typename _Tpa, typename _Tpb>
+    inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type
+    beta(_Tpa __a, _Tpb __b)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type;
+      return __detail::__beta<__type>(__a, __b);
+    }
+  inline float
+  comp_ellint_1f(float __k)
+  { return __detail::__comp_ellint_1<float>(__k); }
+  inline long double
+  comp_ellint_1l(long double __k)
+  { return __detail::__comp_ellint_1<long double>(__k); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    comp_ellint_1(_Tp __k)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__comp_ellint_1<__type>(__k);
+    }
+  inline float
+  comp_ellint_2f(float __k)
+  { return __detail::__comp_ellint_2<float>(__k); }
+  inline long double
+  comp_ellint_2l(long double __k)
+  { return __detail::__comp_ellint_2<long double>(__k); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    comp_ellint_2(_Tp __k)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__comp_ellint_2<__type>(__k);
+    }
+  inline float
+  comp_ellint_3f(float __k, float __nu)
+  { return __detail::__comp_ellint_3<float>(__k, __nu); }
+  inline long double
+  comp_ellint_3l(long double __k, long double __nu)
+  { return __detail::__comp_ellint_3<long double>(__k, __nu); }
+  template<typename _Tp, typename _Tpn>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
+    comp_ellint_3(_Tp __k, _Tpn __nu)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
+      return __detail::__comp_ellint_3<__type>(__k, __nu);
+    }
+  inline float
+  cyl_bessel_if(float __nu, float __x)
+  { return __detail::__cyl_bessel_i<float>(__nu, __x); }
+  inline long double
+  cyl_bessel_il(long double __nu, long double __x)
+  { return __detail::__cyl_bessel_i<long double>(__nu, __x); }
+  template<typename _Tpnu, typename _Tp>
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
+    cyl_bessel_i(_Tpnu __nu, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
+      return __detail::__cyl_bessel_i<__type>(__nu, __x);
+    }
+  inline float
+  cyl_bessel_jf(float __nu, float __x)
+  { return __detail::__cyl_bessel_j<float>(__nu, __x); }
+  inline long double
+  cyl_bessel_jl(long double __nu, long double __x)
+  { return __detail::__cyl_bessel_j<long double>(__nu, __x); }
+  template<typename _Tpnu, typename _Tp>
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
+    cyl_bessel_j(_Tpnu __nu, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
+      return __detail::__cyl_bessel_j<__type>(__nu, __x);
+    }
+  inline float
+  cyl_bessel_kf(float __nu, float __x)
+  { return __detail::__cyl_bessel_k<float>(__nu, __x); }
+  inline long double
+  cyl_bessel_kl(long double __nu, long double __x)
+  { return __detail::__cyl_bessel_k<long double>(__nu, __x); }
+  template<typename _Tpnu, typename _Tp>
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
+    cyl_bessel_k(_Tpnu __nu, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
+      return __detail::__cyl_bessel_k<__type>(__nu, __x);
+    }
+  inline float
+  cyl_neumannf(float __nu, float __x)
+  { return __detail::__cyl_neumann_n<float>(__nu, __x); }
+  inline long double
+  cyl_neumannl(long double __nu, long double __x)
+  { return __detail::__cyl_neumann_n<long double>(__nu, __x); }
+  template<typename _Tpnu, typename _Tp>
+    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
+    cyl_neumann(_Tpnu __nu, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
+      return __detail::__cyl_neumann_n<__type>(__nu, __x);
+    }
+  inline float
+  ellint_1f(float __k, float __phi)
+  { return __detail::__ellint_1<float>(__k, __phi); }
+  inline long double
+  ellint_1l(long double __k, long double __phi)
+  { return __detail::__ellint_1<long double>(__k, __phi); }
+  template<typename _Tp, typename _Tpp>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
+    ellint_1(_Tp __k, _Tpp __phi)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
+      return __detail::__ellint_1<__type>(__k, __phi);
+    }
+  inline float
+  ellint_2f(float __k, float __phi)
+  { return __detail::__ellint_2<float>(__k, __phi); }
+  inline long double
+  ellint_2l(long double __k, long double __phi)
+  { return __detail::__ellint_2<long double>(__k, __phi); }
+  template<typename _Tp, typename _Tpp>
+    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
+    ellint_2(_Tp __k, _Tpp __phi)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
+      return __detail::__ellint_2<__type>(__k, __phi);
+    }
+  inline float
+  ellint_3f(float __k, float __nu, float __phi)
+  { return __detail::__ellint_3<float>(__k, __nu, __phi); }
+  inline long double
+  ellint_3l(long double __k, long double __nu, long double __phi)
+  { return __detail::__ellint_3<long double>(__k, __nu, __phi); }
+  template<typename _Tp, typename _Tpn, typename _Tpp>
+    inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
+    ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
+    {
+      typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
+      return __detail::__ellint_3<__type>(__k, __nu, __phi);
+    }
+  inline float
+  expintf(float __x)
+  { return __detail::__expint<float>(__x); }
+  inline long double
+  expintl(long double __x)
+  { return __detail::__expint<long double>(__x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    expint(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__expint<__type>(__x);
+    }
+  inline float
+  hermitef(unsigned int __n, float __x)
+  { return __detail::__poly_hermite<float>(__n, __x); }
+  inline long double
+  hermitel(unsigned int __n, long double __x)
+  { return __detail::__poly_hermite<long double>(__n, __x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    hermite(unsigned int __n, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__poly_hermite<__type>(__n, __x);
+    }
+  inline float
+  laguerref(unsigned int __n, float __x)
+  { return __detail::__laguerre<float>(__n, __x); }
+  inline long double
+  laguerrel(unsigned int __n, long double __x)
+  { return __detail::__laguerre<long double>(__n, __x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    laguerre(unsigned int __n, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__laguerre<__type>(__n, __x);
+    }
+  inline float
+  legendref(unsigned int __l, float __x)
+  { return __detail::__poly_legendre_p<float>(__l, __x); }
+  inline long double
+  legendrel(unsigned int __l, long double __x)
+  { return __detail::__poly_legendre_p<long double>(__l, __x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    legendre(unsigned int __l, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__poly_legendre_p<__type>(__l, __x);
+    }
+  inline float
+  riemann_zetaf(float __s)
+  { return __detail::__riemann_zeta<float>(__s); }
+  inline long double
+  riemann_zetal(long double __s)
+  { return __detail::__riemann_zeta<long double>(__s); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    riemann_zeta(_Tp __s)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__riemann_zeta<__type>(__s);
+    }
+  inline float
+  sph_besself(unsigned int __n, float __x)
+  { return __detail::__sph_bessel<float>(__n, __x); }
+  inline long double
+  sph_bessell(unsigned int __n, long double __x)
+  { return __detail::__sph_bessel<long double>(__n, __x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    sph_bessel(unsigned int __n, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__sph_bessel<__type>(__n, __x);
+    }
+  inline float
+  sph_legendref(unsigned int __l, unsigned int __m, float __theta)
+  { return __detail::__sph_legendre<float>(__l, __m, __theta); }
+  inline long double
+  sph_legendrel(unsigned int __l, unsigned int __m, long double __theta)
+  { return __detail::__sph_legendre<long double>(__l, __m, __theta); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__sph_legendre<__type>(__l, __m, __theta);
+    }
+  inline float
+  sph_neumannf(unsigned int __n, float __x)
+  { return __detail::__sph_neumann<float>(__n, __x); }
+  inline long double
+  sph_neumannl(unsigned int __n, long double __x)
+  { return __detail::__sph_neumann<long double>(__n, __x); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    sph_neumann(unsigned int __n, _Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __detail::__sph_neumann<__type>(__n, __x);
+    }
+
+}
+#pragma GCC visibility pop
+}
+       
+typedef __uint8_t uint8_t;
+typedef __uint16_t uint16_t;
+typedef __uint32_t uint32_t;
+typedef __uint64_t uint64_t;
+typedef __int_least8_t int_least8_t;
+typedef __int_least16_t int_least16_t;
+typedef __int_least32_t int_least32_t;
+typedef __int_least64_t int_least64_t;
+typedef __uint_least8_t uint_least8_t;
+typedef __uint_least16_t uint_least16_t;
+typedef __uint_least32_t uint_least32_t;
+typedef __uint_least64_t uint_least64_t;
+typedef signed char int_fast8_t;
+typedef long int int_fast16_t;
+typedef long int int_fast32_t;
+typedef long int int_fast64_t;
+typedef unsigned char uint_fast8_t;
+typedef unsigned long int uint_fast16_t;
+typedef unsigned long int uint_fast32_t;
+typedef unsigned long int uint_fast64_t;
+typedef long int intptr_t;
+typedef unsigned long int uintptr_t;
+typedef __intmax_t intmax_t;
+typedef __uintmax_t uintmax_t;
+namespace std
+{
+  using ::int8_t;
+  using ::int16_t;
+  using ::int32_t;
+  using ::int64_t;
+  using ::int_fast8_t;
+  using ::int_fast16_t;
+  using ::int_fast32_t;
+  using ::int_fast64_t;
+  using ::int_least8_t;
+  using ::int_least16_t;
+  using ::int_least32_t;
+  using ::int_least64_t;
+  using ::intmax_t;
+  using ::intptr_t;
+  using ::uint8_t;
+  using ::uint16_t;
+  using ::uint32_t;
+  using ::uint64_t;
+  using ::uint_fast8_t;
+  using ::uint_fast16_t;
+  using ::uint_fast32_t;
+  using ::uint_fast64_t;
+  using ::uint_least8_t;
+  using ::uint_least16_t;
+  using ::uint_least32_t;
+  using ::uint_least64_t;
+  using ::uintmax_t;
+  using ::uintptr_t;
+}
+       
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+  using std::size_t;
+  using std::ptrdiff_t;
+  template<typename _Tp>
+    class new_allocator
+    {
+    public:
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp* pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp& reference;
+      typedef const _Tp& const_reference;
+      typedef _Tp value_type;
+      template<typename _Tp1>
+ struct rebind
+ { typedef new_allocator<_Tp1> other; };
+      typedef std::true_type propagate_on_container_move_assignment;
+      new_allocator() noexcept { }
+      new_allocator(const new_allocator&) noexcept { }
+      template<typename _Tp1>
+ new_allocator(const new_allocator<_Tp1>&) noexcept { }
+      ~new_allocator() noexcept { }
+      pointer
+      address(reference __x) const noexcept
+      { return std::__addressof(__x); }
+      const_pointer
+      address(const_reference __x) const noexcept
+      { return std::__addressof(__x); }
+      pointer
+      allocate(size_type __n, const void* = static_cast<const void*>(0))
+      {
+ if (__n > this->max_size())
+   std::__throw_bad_alloc();
+ if (alignof(_Tp) > 16)
+   {
+     std::align_val_t __al = std::align_val_t(alignof(_Tp));
+     return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al));
+   }
+ return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
+      }
+      void
+      deallocate(pointer __p, size_type)
+      {
+ if (alignof(_Tp) > 16)
+   {
+     ::operator delete(__p, std::align_val_t(alignof(_Tp)));
+     return;
+   }
+ ::operator delete(__p);
+      }
+      size_type
+      max_size() const noexcept
+      { return size_t(-1) / sizeof(_Tp); }
+      template<typename _Up, typename... _Args>
+ void
+ construct(_Up* __p, _Args&&... __args)
+ { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+      template<typename _Up>
+ void
+ destroy(_Up* __p) { __p->~_Up(); }
+    };
+  template<typename _Tp>
+    inline bool
+    operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
+    { return true; }
+  template<typename _Tp>
+    inline bool
+    operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
+    { return false; }
+
+}
+namespace std
+{
+  template<typename _Tp>
+    using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<>
+    class allocator<void>
+    {
+    public:
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef void* pointer;
+      typedef const void* const_pointer;
+      typedef void value_type;
+      template<typename _Tp1>
+ struct rebind
+ { typedef allocator<_Tp1> other; };
+      typedef true_type propagate_on_container_move_assignment;
+      typedef true_type is_always_equal;
+      template<typename _Up, typename... _Args>
+ void
+ construct(_Up* __p, _Args&&... __args)
+ { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+      template<typename _Up>
+ void
+ destroy(_Up* __p) { __p->~_Up(); }
+    };
+  template<typename _Tp>
+    class allocator : public __allocator_base<_Tp>
+    {
+   public:
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp* pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp& reference;
+      typedef const _Tp& const_reference;
+      typedef _Tp value_type;
+      template<typename _Tp1>
+ struct rebind
+ { typedef allocator<_Tp1> other; };
+      typedef true_type propagate_on_container_move_assignment;
+      typedef true_type is_always_equal;
+      allocator() throw() { }
+      allocator(const allocator& __a) throw()
+      : __allocator_base<_Tp>(__a) { }
+      template<typename _Tp1>
+ allocator(const allocator<_Tp1>&) throw() { }
+      ~allocator() throw() { }
+    };
+  template<typename _T1, typename _T2>
+    inline bool
+    operator==(const allocator<_T1>&, const allocator<_T2>&)
+    noexcept
+    { return true; }
+  template<typename _Tp>
+    inline bool
+    operator==(const allocator<_Tp>&, const allocator<_Tp>&)
+    noexcept
+    { return true; }
+  template<typename _T1, typename _T2>
+    inline bool
+    operator!=(const allocator<_T1>&, const allocator<_T2>&)
+    noexcept
+    { return false; }
+  template<typename _Tp>
+    inline bool
+    operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
+    noexcept
+    { return false; }
+  template<typename _Tp>
+    class allocator<const _Tp>
+    {
+    public:
+      typedef _Tp value_type;
+      template<typename _Up> allocator(const allocator<_Up>&) { }
+    };
+  template<typename _Tp>
+    class allocator<volatile _Tp>
+    {
+    public:
+      typedef _Tp value_type;
+      template<typename _Up> allocator(const allocator<_Up>&) { }
+    };
+  template<typename _Tp>
+    class allocator<const volatile _Tp>
+    {
+    public:
+      typedef _Tp value_type;
+      template<typename _Up> allocator(const allocator<_Up>&) { }
+    };
+  extern template class allocator<char>;
+  extern template class allocator<wchar_t>;
+  template<typename _Alloc, bool = __is_empty(_Alloc)>
+    struct __alloc_swap
+    { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } };
+  template<typename _Alloc>
+    struct __alloc_swap<_Alloc, false>
+    {
+      static void
+      _S_do_it(_Alloc& __one, _Alloc& __two) noexcept
+      {
+ if (__one != __two)
+   swap(__one, __two);
+      }
+    };
+  template<typename _Alloc, bool = __is_empty(_Alloc)>
+    struct __alloc_neq
+    {
+      static bool
+      _S_do_it(const _Alloc&, const _Alloc&)
+      { return false; }
+    };
+  template<typename _Alloc>
+    struct __alloc_neq<_Alloc, false>
+    {
+      static bool
+      _S_do_it(const _Alloc& __one, const _Alloc& __two)
+      { return __one != __two; }
+    };
+  template<typename _Tp, bool
+    = __or_<is_copy_constructible<typename _Tp::value_type>,
+            is_nothrow_move_constructible<typename _Tp::value_type>>::value>
+    struct __shrink_to_fit_aux
+    { static bool _S_do_it(_Tp&) noexcept { return false; } };
+  template<typename _Tp>
+    struct __shrink_to_fit_aux<_Tp, true>
+    {
+      static bool
+      _S_do_it(_Tp& __c) noexcept
+      {
+ try
+   {
+     _Tp(__make_move_if_noexcept_iterator(__c.begin()),
+  __make_move_if_noexcept_iterator(__c.end()),
+  __c.get_allocator()).swap(__c);
+     return true;
+   }
+ catch(...)
+   { return false; }
+      }
+    };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<bool _TrivialValueTypes>
+    struct __uninitialized_copy
+    {
+      template<typename _InputIterator, typename _ForwardIterator>
+        static _ForwardIterator
+        __uninit_copy(_InputIterator __first, _InputIterator __last,
+        _ForwardIterator __result)
+        {
+   _ForwardIterator __cur = __result;
+   try
+     {
+       for (; __first != __last; ++__first, (void)++__cur)
+  std::_Construct(std::__addressof(*__cur), *__first);
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__result, __cur);
+       throw;
+     }
+ }
+    };
+  template<>
+    struct __uninitialized_copy<true>
+    {
+      template<typename _InputIterator, typename _ForwardIterator>
+        static _ForwardIterator
+        __uninit_copy(_InputIterator __first, _InputIterator __last,
+        _ForwardIterator __result)
+        { return std::copy(__first, __last, __result); }
+    };
+  template<typename _InputIterator, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_copy(_InputIterator __first, _InputIterator __last,
+         _ForwardIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType2;
+      typedef typename iterator_traits<_InputIterator>::reference _RefType1;
+      typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;
+      const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
+      return std::__uninitialized_copy<__is_trivial(_ValueType1)
+           && __is_trivial(_ValueType2)
+           && __assignable>::
+ __uninit_copy(__first, __last, __result);
+    }
+  template<bool _TrivialValueType>
+    struct __uninitialized_fill
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
+        const _Tp& __x)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __cur != __last; ++__cur)
+  std::_Construct(std::__addressof(*__cur), __x);
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+  template<>
+    struct __uninitialized_fill<true>
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
+        const _Tp& __x)
+        { std::fill(__first, __last, __x); }
+    };
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
+         const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+      std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>::
+ __uninit_fill(__first, __last, __x);
+    }
+  template<bool _TrivialValueType>
+    struct __uninitialized_fill_n
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static _ForwardIterator
+        __uninit_fill_n(_ForwardIterator __first, _Size __n,
+   const _Tp& __x)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __n > 0; --__n, (void) ++__cur)
+  std::_Construct(std::__addressof(*__cur), __x);
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+  template<>
+    struct __uninitialized_fill_n<true>
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static _ForwardIterator
+        __uninit_fill_n(_ForwardIterator __first, _Size __n,
+   const _Tp& __x)
+        { return std::fill_n(__first, __n, __x); }
+    };
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline _ForwardIterator
+    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+      return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>::
+ __uninit_fill_n(__first, __n, __x);
+    }
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _Allocator>
+    _ForwardIterator
+    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __result;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __first != __last; ++__first, (void)++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur), *__first);
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __cur, __alloc);
+   throw;
+ }
+    }
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, allocator<_Tp>&)
+    { return std::uninitialized_copy(__first, __last, __result); }
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, _Allocator& __alloc)
+    {
+      return std::__uninitialized_copy_a(std::make_move_iterator(__first),
+      std::make_move_iterator(__last),
+      __result, __alloc);
+    }
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_if_noexcept_a(_InputIterator __first,
+           _InputIterator __last,
+           _ForwardIterator __result,
+           _Allocator& __alloc)
+    {
+      return std::__uninitialized_copy_a
+ (std::__make_move_if_noexcept_iterator(__first),
+  std::__make_move_if_noexcept_iterator(__last), __result, __alloc);
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Allocator>
+    void
+    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __x, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __cur != __last; ++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur), __x);
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _Tp2>
+    inline void
+    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __x, allocator<_Tp2>&)
+    { std::uninitialized_fill(__first, __last, __x); }
+  template<typename _ForwardIterator, typename _Size, typename _Tp,
+    typename _Allocator>
+    _ForwardIterator
+    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
+        const _Tp& __x, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __n > 0; --__n, (void) ++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur), __x);
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+  template<typename _ForwardIterator, typename _Size, typename _Tp,
+    typename _Tp2>
+    inline _ForwardIterator
+    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
+        const _Tp& __x, allocator<_Tp2>&)
+    { return std::uninitialized_fill_n(__first, __n, __x); }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_copy_move(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _ForwardIterator __result,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
+          __result,
+          __alloc);
+      try
+ {
+   return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_copy(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _ForwardIterator __result,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
+          __result,
+          __alloc);
+      try
+ {
+   return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+  template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
+         const _Tp& __x, _InputIterator __first,
+         _InputIterator __last, _Allocator& __alloc)
+    {
+      std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
+      try
+ {
+   return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
+    typename _Allocator>
+    inline void
+    __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
+         _ForwardIterator __first2,
+         _ForwardIterator __last2, const _Tp& __x,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
+           __first2,
+           __alloc);
+      try
+ {
+   std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__first2, __mid2, __alloc);
+   throw;
+ }
+    }
+  template<bool _TrivialValueType>
+    struct __uninitialized_default_1
+    {
+      template<typename _ForwardIterator>
+        static void
+        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __cur != __last; ++__cur)
+  std::_Construct(std::__addressof(*__cur));
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+  template<>
+    struct __uninitialized_default_1<true>
+    {
+      template<typename _ForwardIterator>
+        static void
+        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
+        {
+   typedef typename iterator_traits<_ForwardIterator>::value_type
+     _ValueType;
+   std::fill(__first, __last, _ValueType());
+ }
+    };
+  template<bool _TrivialValueType>
+    struct __uninitialized_default_n_1
+    {
+      template<typename _ForwardIterator, typename _Size>
+        static _ForwardIterator
+        __uninit_default_n(_ForwardIterator __first, _Size __n)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __n > 0; --__n, (void) ++__cur)
+  std::_Construct(std::__addressof(*__cur));
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+  template<>
+    struct __uninitialized_default_n_1<true>
+    {
+      template<typename _ForwardIterator, typename _Size>
+        static _ForwardIterator
+        __uninit_default_n(_ForwardIterator __first, _Size __n)
+        {
+   typedef typename iterator_traits<_ForwardIterator>::value_type
+     _ValueType;
+   return std::fill_n(__first, __n, _ValueType());
+ }
+    };
+  template<typename _ForwardIterator>
+    inline void
+    __uninitialized_default(_ForwardIterator __first,
+       _ForwardIterator __last)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+      std::__uninitialized_default_1<__is_trivial(_ValueType)
+         && __assignable>::
+ __uninit_default(__first, __last);
+    }
+  template<typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    __uninitialized_default_n(_ForwardIterator __first, _Size __n)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+      return __uninitialized_default_n_1<__is_trivial(_ValueType)
+           && __assignable>::
+ __uninit_default_n(__first, __n);
+    }
+  template<typename _ForwardIterator, typename _Allocator>
+    void
+    __uninitialized_default_a(_ForwardIterator __first,
+         _ForwardIterator __last,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __cur != __last; ++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur));
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    __uninitialized_default_a(_ForwardIterator __first,
+         _ForwardIterator __last,
+         allocator<_Tp>&)
+    { std::__uninitialized_default(__first, __last); }
+  template<typename _ForwardIterator, typename _Size, typename _Allocator>
+    _ForwardIterator
+    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
+    _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
+   for (; __n > 0; --__n, (void) ++__cur)
+     __traits::construct(__alloc, std::__addressof(*__cur));
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline _ForwardIterator
+    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
+    allocator<_Tp>&)
+    { return std::__uninitialized_default_n(__first, __n); }
+  template<bool _TrivialValueType>
+    struct __uninitialized_default_novalue_1
+    {
+      template<typename _ForwardIterator>
+ static void
+ __uninit_default_novalue(_ForwardIterator __first,
+     _ForwardIterator __last)
+ {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __cur != __last; ++__cur)
+  std::_Construct_novalue(std::__addressof(*__cur));
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+  template<>
+    struct __uninitialized_default_novalue_1<true>
+    {
+      template<typename _ForwardIterator>
+        static void
+        __uninit_default_novalue(_ForwardIterator __first,
+     _ForwardIterator __last)
+ {
+ }
+    };
+  template<bool _TrivialValueType>
+    struct __uninitialized_default_novalue_n_1
+    {
+      template<typename _ForwardIterator, typename _Size>
+ static _ForwardIterator
+ __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
+ {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __n > 0; --__n, (void) ++__cur)
+  std::_Construct_novalue(std::__addressof(*__cur));
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+  template<>
+    struct __uninitialized_default_novalue_n_1<true>
+    {
+      template<typename _ForwardIterator, typename _Size>
+ static _ForwardIterator
+ __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
+ { return std::next(__first, __n); }
+    };
+  template<typename _ForwardIterator>
+    inline void
+    __uninitialized_default_novalue(_ForwardIterator __first,
+        _ForwardIterator __last)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      std::__uninitialized_default_novalue_1<
+ is_trivially_default_constructible<_ValueType>::value>::
+ __uninit_default_novalue(__first, __last);
+    }
+  template<typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      return __uninitialized_default_novalue_n_1<
+ is_trivially_default_constructible<_ValueType>::value>::
+ __uninit_default_novalue_n(__first, __n);
+    }
+  template<typename _InputIterator, typename _Size,
+    typename _ForwardIterator>
+    _ForwardIterator
+    __uninitialized_copy_n(_InputIterator __first, _Size __n,
+      _ForwardIterator __result, input_iterator_tag)
+    {
+      _ForwardIterator __cur = __result;
+      try
+ {
+   for (; __n > 0; --__n, (void) ++__first, ++__cur)
+     std::_Construct(std::__addressof(*__cur), *__first);
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __cur);
+   throw;
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Size,
+    typename _ForwardIterator>
+    inline _ForwardIterator
+    __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
+      _ForwardIterator __result,
+      random_access_iterator_tag)
+    { return std::uninitialized_copy(__first, __first + __n, __result); }
+  template<typename _InputIterator, typename _Size,
+    typename _ForwardIterator>
+    pair<_InputIterator, _ForwardIterator>
+    __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,
+      _ForwardIterator __result, input_iterator_tag)
+    {
+      _ForwardIterator __cur = __result;
+      try
+ {
+   for (; __n > 0; --__n, (void) ++__first, ++__cur)
+     std::_Construct(std::__addressof(*__cur), *__first);
+   return {__first, __cur};
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __cur);
+   throw;
+ }
+    }
+  template<typename _RandomAccessIterator, typename _Size,
+    typename _ForwardIterator>
+    inline pair<_RandomAccessIterator, _ForwardIterator>
+    __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n,
+      _ForwardIterator __result,
+      random_access_iterator_tag)
+    {
+      auto __second_res = uninitialized_copy(__first, __first + __n, __result);
+      auto __first_res = std::next(__first, __n);
+      return {__first_res, __second_res};
+    }
+  template<typename _InputIterator, typename _Size, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_copy_n(_InputIterator __first, _Size __n,
+    _ForwardIterator __result)
+    { return std::__uninitialized_copy_n(__first, __n, __result,
+      std::__iterator_category(__first)); }
+  template<typename _InputIterator, typename _Size, typename _ForwardIterator>
+    inline pair<_InputIterator, _ForwardIterator>
+    __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,
+         _ForwardIterator __result)
+    {
+      return
+ std::__uninitialized_copy_n_pair(__first, __n, __result,
+      std::__iterator_category(__first));
+    }
+  template <typename _ForwardIterator>
+    inline void
+    uninitialized_default_construct(_ForwardIterator __first,
+        _ForwardIterator __last)
+    {
+      __uninitialized_default_novalue(__first, __last);
+    }
+  template <typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    uninitialized_default_construct_n(_ForwardIterator __first, _Size __count)
+    {
+      return __uninitialized_default_novalue_n(__first, __count);
+    }
+  template <typename _ForwardIterator>
+    inline void
+    uninitialized_value_construct(_ForwardIterator __first,
+      _ForwardIterator __last)
+    {
+      return __uninitialized_default(__first, __last);
+    }
+  template <typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    uninitialized_value_construct_n(_ForwardIterator __first, _Size __count)
+    {
+      return __uninitialized_default_n(__first, __count);
+    }
+  template <typename _InputIterator, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_move(_InputIterator __first, _InputIterator __last,
+         _ForwardIterator __result)
+    {
+      return std::uninitialized_copy
+ (std::make_move_iterator(__first),
+  std::make_move_iterator(__last), __result);
+    }
+  template <typename _InputIterator, typename _Size, typename _ForwardIterator>
+    inline pair<_InputIterator, _ForwardIterator>
+    uninitialized_move_n(_InputIterator __first, _Size __count,
+    _ForwardIterator __result)
+    {
+      auto __res = std::__uninitialized_copy_n_pair
+ (std::make_move_iterator(__first),
+  __count, __result);
+      return {__res.first.base(), __res.second};
+    }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Tp, typename _Alloc>
+    struct _Vector_base
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_Tp>::other _Tp_alloc_type;
+      typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
+        pointer;
+      struct _Vector_impl
+      : public _Tp_alloc_type
+      {
+ pointer _M_start;
+ pointer _M_finish;
+ pointer _M_end_of_storage;
+ _Vector_impl()
+ : _Tp_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+ _Vector_impl(_Tp_alloc_type const& __a) noexcept
+ : _Tp_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+ _Vector_impl(_Tp_alloc_type&& __a) noexcept
+ : _Tp_alloc_type(std::move(__a)),
+   _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+ void _M_swap_data(_Vector_impl& __x) noexcept
+ {
+   std::swap(_M_start, __x._M_start);
+   std::swap(_M_finish, __x._M_finish);
+   std::swap(_M_end_of_storage, __x._M_end_of_storage);
+ }
+      };
+    public:
+      typedef _Alloc allocator_type;
+      _Tp_alloc_type&
+      _M_get_Tp_allocator() noexcept
+      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
+      const _Tp_alloc_type&
+      _M_get_Tp_allocator() const noexcept
+      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_get_Tp_allocator()); }
+      _Vector_base()
+      : _M_impl() { }
+      _Vector_base(const allocator_type& __a) noexcept
+      : _M_impl(__a) { }
+      _Vector_base(size_t __n)
+      : _M_impl()
+      { _M_create_storage(__n); }
+      _Vector_base(size_t __n, const allocator_type& __a)
+      : _M_impl(__a)
+      { _M_create_storage(__n); }
+      _Vector_base(_Tp_alloc_type&& __a) noexcept
+      : _M_impl(std::move(__a)) { }
+      _Vector_base(_Vector_base&& __x) noexcept
+      : _M_impl(std::move(__x._M_get_Tp_allocator()))
+      { this->_M_impl._M_swap_data(__x._M_impl); }
+      _Vector_base(_Vector_base&& __x, const allocator_type& __a)
+      : _M_impl(__a)
+      {
+ if (__x.get_allocator() == __a)
+   this->_M_impl._M_swap_data(__x._M_impl);
+ else
+   {
+     size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
+     _M_create_storage(__n);
+   }
+      }
+      ~_Vector_base() noexcept
+      {
+ _M_deallocate(_M_impl._M_start,
+        _M_impl._M_end_of_storage - _M_impl._M_start);
+      }
+    public:
+      _Vector_impl _M_impl;
+      pointer
+      _M_allocate(size_t __n)
+      {
+ typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
+ return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
+      }
+      void
+      _M_deallocate(pointer __p, size_t __n)
+      {
+ typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
+ if (__p)
+   _Tr::deallocate(_M_impl, __p, __n);
+      }
+    private:
+      void
+      _M_create_storage(size_t __n)
+      {
+ this->_M_impl._M_start = this->_M_allocate(__n);
+ this->_M_impl._M_finish = this->_M_impl._M_start;
+ this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+      }
+    };
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class vector : protected _Vector_base<_Tp, _Alloc>
+    {
+      static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,
+   "std::vector must have a non-const, non-volatile value_type");
+      static_assert(is_same<typename _Alloc::value_type, _Tp>::value,
+   "std::vector must have the same value_type as its allocator");
+      typedef _Vector_base<_Tp, _Alloc> _Base;
+      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
+    public:
+      typedef _Tp value_type;
+      typedef typename _Base::pointer pointer;
+      typedef typename _Alloc_traits::const_pointer const_pointer;
+      typedef typename _Alloc_traits::reference reference;
+      typedef typename _Alloc_traits::const_reference const_reference;
+      typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
+      const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Alloc allocator_type;
+    protected:
+      using _Base::_M_allocate;
+      using _Base::_M_deallocate;
+      using _Base::_M_impl;
+      using _Base::_M_get_Tp_allocator;
+    public:
+      vector()
+      noexcept(is_nothrow_default_constructible<_Alloc>::value)
+      : _Base() { }
+      explicit
+      vector(const allocator_type& __a) noexcept
+      : _Base(__a) { }
+      explicit
+      vector(size_type __n, const allocator_type& __a = allocator_type())
+      : _Base(__n, __a)
+      { _M_default_initialize(__n); }
+      vector(size_type __n, const value_type& __value,
+      const allocator_type& __a = allocator_type())
+      : _Base(__n, __a)
+      { _M_fill_initialize(__n, __value); }
+      vector(const vector& __x)
+      : _Base(__x.size(),
+ _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
+      {
+ this->_M_impl._M_finish =
+   std::__uninitialized_copy_a(__x.begin(), __x.end(),
+          this->_M_impl._M_start,
+          _M_get_Tp_allocator());
+      }
+      vector(vector&& __x) noexcept
+      : _Base(std::move(__x)) { }
+      vector(const vector& __x, const allocator_type& __a)
+      : _Base(__x.size(), __a)
+      {
+ this->_M_impl._M_finish =
+   std::__uninitialized_copy_a(__x.begin(), __x.end(),
+          this->_M_impl._M_start,
+          _M_get_Tp_allocator());
+      }
+      vector(vector&& __rv, const allocator_type& __m)
+      noexcept(_Alloc_traits::_S_always_equal())
+      : _Base(std::move(__rv), __m)
+      {
+ if (__rv.get_allocator() != __m)
+   {
+     this->_M_impl._M_finish =
+       std::__uninitialized_move_a(__rv.begin(), __rv.end(),
+       this->_M_impl._M_start,
+       _M_get_Tp_allocator());
+     __rv.clear();
+   }
+      }
+      vector(initializer_list<value_type> __l,
+      const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+ _M_range_initialize(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+      }
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ vector(_InputIterator __first, _InputIterator __last,
+        const allocator_type& __a = allocator_type())
+ : _Base(__a)
+ { _M_initialize_dispatch(__first, __last, __false_type()); }
+      ~vector() noexcept
+      {
+ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+        _M_get_Tp_allocator());
+ ;
+      }
+      vector&
+      operator=(const vector& __x);
+      vector&
+      operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+ constexpr bool __move_storage =
+   _Alloc_traits::_S_propagate_on_move_assign()
+   || _Alloc_traits::_S_always_equal();
+ _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
+ return *this;
+      }
+      vector&
+      operator=(initializer_list<value_type> __l)
+      {
+ this->_M_assign_aux(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+ return *this;
+      }
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ void
+ assign(_InputIterator __first, _InputIterator __last)
+ { _M_assign_dispatch(__first, __last, __false_type()); }
+      void
+      assign(initializer_list<value_type> __l)
+      {
+ this->_M_assign_aux(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+      }
+      using _Base::get_allocator;
+      iterator
+      begin() noexcept
+      { return iterator(this->_M_impl._M_start); }
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(this->_M_impl._M_start); }
+      iterator
+      end() noexcept
+      { return iterator(this->_M_impl._M_finish); }
+      const_iterator
+      end() const noexcept
+      { return const_iterator(this->_M_impl._M_finish); }
+      reverse_iterator
+      rbegin() noexcept
+      { return reverse_iterator(end()); }
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+      reverse_iterator
+      rend() noexcept
+      { return reverse_iterator(begin()); }
+      const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(begin()); }
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(this->_M_impl._M_start); }
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(this->_M_impl._M_finish); }
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+      size_type
+      size() const noexcept
+      { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
+      size_type
+      max_size() const noexcept
+      { return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
+      void
+      resize(size_type __new_size)
+      {
+ if (__new_size > size())
+   _M_default_append(__new_size - size());
+ else if (__new_size < size())
+   _M_erase_at_end(this->_M_impl._M_start + __new_size);
+      }
+      void
+      resize(size_type __new_size, const value_type& __x)
+      {
+ if (__new_size > size())
+   _M_fill_insert(end(), __new_size - size(), __x);
+ else if (__new_size < size())
+   _M_erase_at_end(this->_M_impl._M_start + __new_size);
+      }
+      void
+      shrink_to_fit()
+      { _M_shrink_to_fit(); }
+      size_type
+      capacity() const noexcept
+      { return size_type(this->_M_impl._M_end_of_storage
+    - this->_M_impl._M_start); }
+      bool
+      empty() const noexcept
+      { return begin() == end(); }
+      void
+      reserve(size_type __n);
+      reference
+      operator[](size_type __n) noexcept
+      {
+ ;
+ return *(this->_M_impl._M_start + __n);
+      }
+      const_reference
+      operator[](size_type __n) const noexcept
+      {
+ ;
+ return *(this->_M_impl._M_start + __n);
+      }
+    protected:
+      void
+      _M_range_check(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
+       __n, this->size());
+      }
+    public:
+      reference
+      at(size_type __n)
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+      const_reference
+      at(size_type __n) const
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+      reference
+      front() noexcept
+      {
+ ;
+ return *begin();
+      }
+      const_reference
+      front() const noexcept
+      {
+ ;
+ return *begin();
+      }
+      reference
+      back() noexcept
+      {
+ ;
+ return *(end() - 1);
+      }
+      const_reference
+      back() const noexcept
+      {
+ ;
+ return *(end() - 1);
+      }
+      _Tp*
+      data() noexcept
+      { return _M_data_ptr(this->_M_impl._M_start); }
+      const _Tp*
+      data() const noexcept
+      { return _M_data_ptr(this->_M_impl._M_start); }
+      void
+      push_back(const value_type& __x)
+      {
+ if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+   {
+     ;
+     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+         __x);
+     ++this->_M_impl._M_finish;
+     ;
+   }
+ else
+   _M_realloc_insert(end(), __x);
+      }
+      void
+      push_back(value_type&& __x)
+      { emplace_back(std::move(__x)); }
+      template<typename... _Args>
+ reference
+ emplace_back(_Args&&... __args);
+      void
+      pop_back() noexcept
+      {
+ ;
+ --this->_M_impl._M_finish;
+ _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
+ ;
+      }
+      template<typename... _Args>
+ iterator
+ emplace(const_iterator __position, _Args&&... __args)
+ { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); }
+      iterator
+      insert(const_iterator __position, const value_type& __x);
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return _M_insert_rval(__position, std::move(__x)); }
+      iterator
+      insert(const_iterator __position, initializer_list<value_type> __l)
+      {
+ auto __offset = __position - cbegin();
+ _M_range_insert(begin() + __offset, __l.begin(), __l.end(),
+   std::random_access_iterator_tag());
+ return begin() + __offset;
+      }
+      iterator
+      insert(const_iterator __position, size_type __n, const value_type& __x)
+      {
+ difference_type __offset = __position - cbegin();
+ _M_fill_insert(begin() + __offset, __n, __x);
+ return begin() + __offset;
+      }
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ iterator
+ insert(const_iterator __position, _InputIterator __first,
+        _InputIterator __last)
+ {
+   difference_type __offset = __position - cbegin();
+   _M_insert_dispatch(begin() + __offset,
+        __first, __last, __false_type());
+   return begin() + __offset;
+ }
+      iterator
+      erase(const_iterator __position)
+      { return _M_erase(begin() + (__position - cbegin())); }
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      {
+ const auto __beg = begin();
+ const auto __cbeg = cbegin();
+ return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg));
+      }
+      void
+      swap(vector& __x) noexcept
+      {
+ ;
+ this->_M_impl._M_swap_data(__x._M_impl);
+ _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
+      __x._M_get_Tp_allocator());
+      }
+      void
+      clear() noexcept
+      { _M_erase_at_end(this->_M_impl._M_start); }
+    protected:
+      template<typename _ForwardIterator>
+ pointer
+ _M_allocate_and_copy(size_type __n,
+        _ForwardIterator __first, _ForwardIterator __last)
+ {
+   pointer __result = this->_M_allocate(__n);
+   try
+     {
+       std::__uninitialized_copy_a(__first, __last, __result,
+       _M_get_Tp_allocator());
+       return __result;
+     }
+   catch(...)
+     {
+       _M_deallocate(__result, __n);
+       throw;
+     }
+ }
+      template<typename _Integer>
+ void
+ _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
+ {
+   this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
+   this->_M_impl._M_end_of_storage =
+     this->_M_impl._M_start + static_cast<size_type>(__n);
+   _M_fill_initialize(static_cast<size_type>(__n), __value);
+ }
+      template<typename _InputIterator>
+ void
+ _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+          __false_type)
+ {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_range_initialize(__first, __last, _IterCategory());
+ }
+      template<typename _InputIterator>
+ void
+ _M_range_initialize(_InputIterator __first, _InputIterator __last,
+       std::input_iterator_tag)
+ {
+   try {
+     for (; __first != __last; ++__first)
+       emplace_back(*__first);
+   } catch(...) {
+     clear();
+     throw;
+   }
+ }
+      template<typename _ForwardIterator>
+ void
+ _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+       std::forward_iterator_tag)
+ {
+   const size_type __n = std::distance(__first, __last);
+   this->_M_impl._M_start = this->_M_allocate(__n);
+   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+   this->_M_impl._M_finish =
+     std::__uninitialized_copy_a(__first, __last,
+     this->_M_impl._M_start,
+     _M_get_Tp_allocator());
+ }
+      void
+      _M_fill_initialize(size_type __n, const value_type& __value)
+      {
+ this->_M_impl._M_finish =
+   std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
+     _M_get_Tp_allocator());
+      }
+      void
+      _M_default_initialize(size_type __n)
+      {
+ this->_M_impl._M_finish =
+   std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
+        _M_get_Tp_allocator());
+      }
+      template<typename _Integer>
+ void
+ _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+ { _M_fill_assign(__n, __val); }
+      template<typename _InputIterator>
+ void
+ _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+      __false_type)
+ { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
+      template<typename _InputIterator>
+ void
+ _M_assign_aux(_InputIterator __first, _InputIterator __last,
+        std::input_iterator_tag);
+      template<typename _ForwardIterator>
+ void
+ _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+        std::forward_iterator_tag);
+      void
+      _M_fill_assign(size_type __n, const value_type& __val);
+      template<typename _Integer>
+ void
+ _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+      __true_type)
+ { _M_fill_insert(__pos, __n, __val); }
+      template<typename _InputIterator>
+ void
+ _M_insert_dispatch(iterator __pos, _InputIterator __first,
+      _InputIterator __last, __false_type)
+ {
+   _M_range_insert(__pos, __first, __last,
+     std::__iterator_category(__first));
+ }
+      template<typename _InputIterator>
+ void
+ _M_range_insert(iterator __pos, _InputIterator __first,
+   _InputIterator __last, std::input_iterator_tag);
+      template<typename _ForwardIterator>
+ void
+ _M_range_insert(iterator __pos, _ForwardIterator __first,
+   _ForwardIterator __last, std::forward_iterator_tag);
+      void
+      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
+      void
+      _M_default_append(size_type __n);
+      bool
+      _M_shrink_to_fit();
+      struct _Temporary_value
+      {
+ template<typename... _Args>
+   explicit
+   _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec)
+   {
+     _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(),
+         std::forward<_Args>(__args)...);
+   }
+ ~_Temporary_value()
+ { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); }
+ value_type&
+ _M_val() { return *_M_ptr(); }
+      private:
+ _Tp*
+ _M_ptr() { return reinterpret_cast<_Tp*>(&__buf); }
+ vector* _M_this;
+ typename aligned_storage<sizeof(_Tp), alignof(_Tp)>::type __buf;
+      };
+      template<typename _Arg>
+ void
+ _M_insert_aux(iterator __position, _Arg&& __arg);
+      template<typename... _Args>
+ void
+ _M_realloc_insert(iterator __position, _Args&&... __args);
+      iterator
+      _M_insert_rval(const_iterator __position, value_type&& __v);
+      template<typename... _Args>
+ iterator
+ _M_emplace_aux(const_iterator __position, _Args&&... __args);
+      iterator
+      _M_emplace_aux(const_iterator __position, value_type&& __v)
+      { return _M_insert_rval(__position, std::move(__v)); }
+      size_type
+      _M_check_len(size_type __n, const char* __s) const
+      {
+ if (max_size() - size() < __n)
+   __throw_length_error((__s));
+ const size_type __len = size() + std::max(size(), __n);
+ return (__len < size() || __len > max_size()) ? max_size() : __len;
+      }
+      void
+      _M_erase_at_end(pointer __pos) noexcept
+      {
+ if (size_type __n = this->_M_impl._M_finish - __pos)
+   {
+     std::_Destroy(__pos, this->_M_impl._M_finish,
+     _M_get_Tp_allocator());
+     this->_M_impl._M_finish = __pos;
+     ;
+   }
+      }
+      iterator
+      _M_erase(iterator __position);
+      iterator
+      _M_erase(iterator __first, iterator __last);
+    private:
+      void
+      _M_move_assign(vector&& __x, std::true_type) noexcept
+      {
+ vector __tmp(get_allocator());
+ this->_M_impl._M_swap_data(__tmp._M_impl);
+ this->_M_impl._M_swap_data(__x._M_impl);
+ std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
+      }
+      void
+      _M_move_assign(vector&& __x, std::false_type)
+      {
+ if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
+   _M_move_assign(std::move(__x), std::true_type());
+ else
+   {
+     this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
+    std::__make_move_if_noexcept_iterator(__x.end()));
+     __x.clear();
+   }
+      }
+      template<typename _Up>
+ _Up*
+ _M_data_ptr(_Up* __ptr) const noexcept
+ { return __ptr; }
+      template<typename _Ptr>
+ typename std::pointer_traits<_Ptr>::element_type*
+ _M_data_ptr(_Ptr __ptr) const
+ { return empty() ? nullptr : std::__to_address(__ptr); }
+    };
+  template<typename _InputIterator, typename _ValT
+      = typename iterator_traits<_InputIterator>::value_type,
+    typename _Allocator = allocator<_ValT>,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    vector(_InputIterator, _InputIterator, _Allocator = _Allocator())
+      -> vector<_ValT, _Allocator>;
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return (__x.size() == __y.size()
+       && std::equal(__x.begin(), __x.end(), __y.begin())); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end()); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Result, typename _Arg>
+    struct __hash_base
+    {
+      typedef _Result result_type [[__deprecated__]];
+      typedef _Arg argument_type [[__deprecated__]];
+    };
+  template<typename _Tp>
+    struct hash;
+  template<typename _Tp, typename = void>
+    struct __poison_hash
+    {
+      static constexpr bool __enable_hash_call = false;
+    private:
+      __poison_hash(__poison_hash&&);
+      ~__poison_hash();
+    };
+  template<typename _Tp>
+    struct __poison_hash<_Tp, __void_t<decltype(hash<_Tp>()(declval<_Tp>()))>>
+    {
+      static constexpr bool __enable_hash_call = true;
+    };
+  template<typename _Tp, bool = is_enum<_Tp>::value>
+    struct __hash_enum
+    {
+    private:
+      __hash_enum(__hash_enum&&);
+      ~__hash_enum();
+    };
+  template<typename _Tp>
+    struct __hash_enum<_Tp, true> : public __hash_base<size_t, _Tp>
+    {
+      size_t
+      operator()(_Tp __val) const noexcept
+      {
+       using __type = typename underlying_type<_Tp>::type;
+       return hash<__type>{}(static_cast<__type>(__val));
+      }
+    };
+  template<typename _Tp>
+    struct hash : __hash_enum<_Tp>
+    { };
+  template<typename _Tp>
+    struct hash<_Tp*> : public __hash_base<size_t, _Tp*>
+    {
+      size_t
+      operator()(_Tp* __p) const noexcept
+      { return reinterpret_cast<size_t>(__p); }
+    };
+  template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<signed char> : public __hash_base<size_t, signed char> { size_t operator()(signed char __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char> { size_t operator()(unsigned char __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<long long> : public __hash_base<size_t, long long> { size_t operator()(long long __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned short> { size_t operator()(unsigned short __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> { size_t operator()(unsigned int __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> { size_t operator()(unsigned long __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned long long> { size_t operator()(unsigned long long __val) const noexcept { return static_cast<size_t>(__val); } };
+  struct _Hash_impl
+  {
+    static size_t
+    hash(const void* __ptr, size_t __clength,
+  size_t __seed = static_cast<size_t>(0xc70f6907UL))
+    { return _Hash_bytes(__ptr, __clength, __seed); }
+    template<typename _Tp>
+      static size_t
+      hash(const _Tp& __val)
+      { return hash(&__val, sizeof(__val)); }
+    template<typename _Tp>
+      static size_t
+      __hash_combine(const _Tp& __val, size_t __hash)
+      { return hash(&__val, sizeof(__val), __hash); }
+  };
+  struct _Fnv_hash_impl
+  {
+    static size_t
+    hash(const void* __ptr, size_t __clength,
+  size_t __seed = static_cast<size_t>(2166136261UL))
+    { return _Fnv_hash_bytes(__ptr, __clength, __seed); }
+    template<typename _Tp>
+      static size_t
+      hash(const _Tp& __val)
+      { return hash(&__val, sizeof(__val)); }
+    template<typename _Tp>
+      static size_t
+      __hash_combine(const _Tp& __val, size_t __hash)
+      { return hash(&__val, sizeof(__val), __hash); }
+  };
+  template<>
+    struct hash<float> : public __hash_base<size_t, float>
+    {
+      size_t
+      operator()(float __val) const noexcept
+      {
+ return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
+      }
+    };
+  template<>
+    struct hash<double> : public __hash_base<size_t, double>
+    {
+      size_t
+      operator()(double __val) const noexcept
+      {
+ return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
+      }
+    };
+  template<>
+    struct hash<long double>
+    : public __hash_base<size_t, long double>
+    {
+      __attribute__ ((__pure__)) size_t
+      operator()(long double __val) const noexcept;
+    };
+  template<typename _Hash>
+    struct __is_fast_hash : public std::true_type
+    { };
+  template<>
+    struct __is_fast_hash<hash<long double>> : public std::false_type
+    { };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  typedef unsigned long _Bit_type;
+  enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
+  struct _Bit_reference
+  {
+    _Bit_type * _M_p;
+    _Bit_type _M_mask;
+    _Bit_reference(_Bit_type * __x, _Bit_type __y)
+    : _M_p(__x), _M_mask(__y) { }
+    _Bit_reference() noexcept : _M_p(0), _M_mask(0) { }
+    operator bool() const noexcept
+    { return !!(*_M_p & _M_mask); }
+    _Bit_reference&
+    operator=(bool __x) noexcept
+    {
+      if (__x)
+ *_M_p |= _M_mask;
+      else
+ *_M_p &= ~_M_mask;
+      return *this;
+    }
+    _Bit_reference&
+    operator=(const _Bit_reference& __x) noexcept
+    { return *this = bool(__x); }
+    bool
+    operator==(const _Bit_reference& __x) const
+    { return bool(*this) == bool(__x); }
+    bool
+    operator<(const _Bit_reference& __x) const
+    { return !bool(*this) && bool(__x); }
+    void
+    flip() noexcept
+    { *_M_p ^= _M_mask; }
+  };
+  inline void
+  swap(_Bit_reference __x, _Bit_reference __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+  inline void
+  swap(_Bit_reference __x, bool& __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+  inline void
+  swap(bool& __x, _Bit_reference __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+  struct _Bit_iterator_base
+  : public std::iterator<std::random_access_iterator_tag, bool>
+  {
+    _Bit_type * _M_p;
+    unsigned int _M_offset;
+    _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
+    : _M_p(__x), _M_offset(__y) { }
+    void
+    _M_bump_up()
+    {
+      if (_M_offset++ == int(_S_word_bit) - 1)
+ {
+   _M_offset = 0;
+   ++_M_p;
+ }
+    }
+    void
+    _M_bump_down()
+    {
+      if (_M_offset-- == 0)
+ {
+   _M_offset = int(_S_word_bit) - 1;
+   --_M_p;
+ }
+    }
+    void
+    _M_incr(ptrdiff_t __i)
+    {
+      difference_type __n = __i + _M_offset;
+      _M_p += __n / int(_S_word_bit);
+      __n = __n % int(_S_word_bit);
+      if (__n < 0)
+ {
+   __n += int(_S_word_bit);
+   --_M_p;
+ }
+      _M_offset = static_cast<unsigned int>(__n);
+    }
+    bool
+    operator==(const _Bit_iterator_base& __i) const
+    { return _M_p == __i._M_p && _M_offset == __i._M_offset; }
+    bool
+    operator<(const _Bit_iterator_base& __i) const
+    {
+      return _M_p < __i._M_p
+     || (_M_p == __i._M_p && _M_offset < __i._M_offset);
+    }
+    bool
+    operator!=(const _Bit_iterator_base& __i) const
+    { return !(*this == __i); }
+    bool
+    operator>(const _Bit_iterator_base& __i) const
+    { return __i < *this; }
+    bool
+    operator<=(const _Bit_iterator_base& __i) const
+    { return !(__i < *this); }
+    bool
+    operator>=(const _Bit_iterator_base& __i) const
+    { return !(*this < __i); }
+  };
+  inline ptrdiff_t
+  operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+  {
+    return (int(_S_word_bit) * (__x._M_p - __y._M_p)
+     + __x._M_offset - __y._M_offset);
+  }
+  struct _Bit_iterator : public _Bit_iterator_base
+  {
+    typedef _Bit_reference reference;
+    typedef _Bit_reference* pointer;
+    typedef _Bit_iterator iterator;
+    _Bit_iterator() : _Bit_iterator_base(0, 0) { }
+    _Bit_iterator(_Bit_type * __x, unsigned int __y)
+    : _Bit_iterator_base(__x, __y) { }
+    iterator
+    _M_const_cast() const
+    { return *this; }
+    reference
+    operator*() const
+    { return reference(_M_p, 1UL << _M_offset); }
+    iterator&
+    operator++()
+    {
+      _M_bump_up();
+      return *this;
+    }
+    iterator
+    operator++(int)
+    {
+      iterator __tmp = *this;
+      _M_bump_up();
+      return __tmp;
+    }
+    iterator&
+    operator--()
+    {
+      _M_bump_down();
+      return *this;
+    }
+    iterator
+    operator--(int)
+    {
+      iterator __tmp = *this;
+      _M_bump_down();
+      return __tmp;
+    }
+    iterator&
+    operator+=(difference_type __i)
+    {
+      _M_incr(__i);
+      return *this;
+    }
+    iterator&
+    operator-=(difference_type __i)
+    {
+      *this += -__i;
+      return *this;
+    }
+    iterator
+    operator+(difference_type __i) const
+    {
+      iterator __tmp = *this;
+      return __tmp += __i;
+    }
+    iterator
+    operator-(difference_type __i) const
+    {
+      iterator __tmp = *this;
+      return __tmp -= __i;
+    }
+    reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+  };
+  inline _Bit_iterator
+  operator+(ptrdiff_t __n, const _Bit_iterator& __x)
+  { return __x + __n; }
+  struct _Bit_const_iterator : public _Bit_iterator_base
+  {
+    typedef bool reference;
+    typedef bool const_reference;
+    typedef const bool* pointer;
+    typedef _Bit_const_iterator const_iterator;
+    _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
+    _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
+    : _Bit_iterator_base(__x, __y) { }
+    _Bit_const_iterator(const _Bit_iterator& __x)
+    : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
+    _Bit_iterator
+    _M_const_cast() const
+    { return _Bit_iterator(_M_p, _M_offset); }
+    const_reference
+    operator*() const
+    { return _Bit_reference(_M_p, 1UL << _M_offset); }
+    const_iterator&
+    operator++()
+    {
+      _M_bump_up();
+      return *this;
+    }
+    const_iterator
+    operator++(int)
+    {
+      const_iterator __tmp = *this;
+      _M_bump_up();
+      return __tmp;
+    }
+    const_iterator&
+    operator--()
+    {
+      _M_bump_down();
+      return *this;
+    }
+    const_iterator
+    operator--(int)
+    {
+      const_iterator __tmp = *this;
+      _M_bump_down();
+      return __tmp;
+    }
+    const_iterator&
+    operator+=(difference_type __i)
+    {
+      _M_incr(__i);
+      return *this;
+    }
+    const_iterator&
+    operator-=(difference_type __i)
+    {
+      *this += -__i;
+      return *this;
+    }
+    const_iterator
+    operator+(difference_type __i) const
+    {
+      const_iterator __tmp = *this;
+      return __tmp += __i;
+    }
+    const_iterator
+    operator-(difference_type __i) const
+    {
+      const_iterator __tmp = *this;
+      return __tmp -= __i;
+    }
+    const_reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+  };
+  inline _Bit_const_iterator
+  operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
+  { return __x + __n; }
+  inline void
+  __fill_bvector(_Bit_type * __v,
+   unsigned int __first, unsigned int __last, bool __x)
+  {
+    const _Bit_type __fmask = ~0ul << __first;
+    const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last);
+    const _Bit_type __mask = __fmask & __lmask;
+    if (__x)
+      *__v |= __mask;
+    else
+      *__v &= ~__mask;
+  }
+  inline void
+  fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
+  {
+    if (__first._M_p != __last._M_p)
+      {
+ _Bit_type* __first_p = __first._M_p;
+ if (__first._M_offset != 0)
+   __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x);
+ __builtin_memset(__first_p, __x ? ~0 : 0,
+    (__last._M_p - __first_p) * sizeof(_Bit_type));
+ if (__last._M_offset != 0)
+   __fill_bvector(__last._M_p, 0, __last._M_offset, __x);
+      }
+    else if (__first._M_offset != __last._M_offset)
+      __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x);
+  }
+  template<typename _Alloc>
+    struct _Bvector_base
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+        rebind<_Bit_type>::other _Bit_alloc_type;
+      typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type>
+ _Bit_alloc_traits;
+      typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
+      struct _Bvector_impl_data
+      {
+ _Bit_iterator _M_start;
+ _Bit_iterator _M_finish;
+ _Bit_pointer _M_end_of_storage;
+ _Bvector_impl_data() noexcept
+ : _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+ _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept
+ : _M_start(__x._M_start), _M_finish(__x._M_finish)
+ , _M_end_of_storage(__x._M_end_of_storage)
+ { __x._M_reset(); }
+ void
+ _M_move_data(_Bvector_impl_data&& __x) noexcept
+ {
+   this->_M_start = __x._M_start;
+   this->_M_finish = __x._M_finish;
+   this->_M_end_of_storage = __x._M_end_of_storage;
+   __x._M_reset();
+ }
+ void
+ _M_reset() noexcept
+ {
+   _M_start = _M_finish = _Bit_iterator();
+   _M_end_of_storage = _Bit_pointer();
+ }
+      };
+      struct _Bvector_impl
+ : public _Bit_alloc_type, public _Bvector_impl_data
+ {
+ public:
+   _Bvector_impl() noexcept(is_nothrow_default_constructible<_Bit_alloc_type>::value)
+   : _Bit_alloc_type()
+   { }
+   _Bvector_impl(const _Bit_alloc_type& __a) noexcept
+   : _Bit_alloc_type(__a)
+   { }
+ _Bvector_impl(_Bvector_impl&&) = default;
+ _Bit_type*
+ _M_end_addr() const noexcept
+ {
+   if (this->_M_end_of_storage)
+     return std::__addressof(this->_M_end_of_storage[-1]) + 1;
+   return 0;
+ }
+      };
+    public:
+      typedef _Alloc allocator_type;
+      _Bit_alloc_type&
+      _M_get_Bit_allocator() noexcept
+      { return this->_M_impl; }
+      const _Bit_alloc_type&
+      _M_get_Bit_allocator() const noexcept
+      { return this->_M_impl; }
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_get_Bit_allocator()); }
+      _Bvector_base() = default;
+      _Bvector_base(const allocator_type& __a)
+      : _M_impl(__a) { }
+      _Bvector_base(_Bvector_base&&) = default;
+      ~_Bvector_base()
+      { this->_M_deallocate(); }
+    protected:
+      _Bvector_impl _M_impl;
+      _Bit_pointer
+      _M_allocate(size_t __n)
+      { return _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); }
+      void
+      _M_deallocate()
+      {
+ if (_M_impl._M_start._M_p)
+   {
+     const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
+     _Bit_alloc_traits::deallocate(_M_impl,
+       _M_impl._M_end_of_storage - __n,
+       __n);
+     _M_impl._M_reset();
+   }
+      }
+      void
+      _M_move_data(_Bvector_base&& __x) noexcept
+      { _M_impl._M_move_data(std::move(__x._M_impl)); }
+      static size_t
+      _S_nword(size_t __n)
+      { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
+    };
+
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Alloc>
+    class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
+    {
+      typedef _Bvector_base<_Alloc> _Base;
+      typedef typename _Base::_Bit_pointer _Bit_pointer;
+      typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits;
+      friend struct std::hash<vector>;
+    public:
+      typedef bool value_type;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Bit_reference reference;
+      typedef bool const_reference;
+      typedef _Bit_reference* pointer;
+      typedef const bool* const_pointer;
+      typedef _Bit_iterator iterator;
+      typedef _Bit_const_iterator const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef _Alloc allocator_type;
+      allocator_type
+      get_allocator() const
+      { return _Base::get_allocator(); }
+    protected:
+      using _Base::_M_allocate;
+      using _Base::_M_deallocate;
+      using _Base::_S_nword;
+      using _Base::_M_get_Bit_allocator;
+    public:
+      vector() = default;
+      explicit
+      vector(const allocator_type& __a)
+      : _Base(__a) { }
+      explicit
+      vector(size_type __n, const allocator_type& __a = allocator_type())
+      : vector(__n, false, __a)
+      { }
+      vector(size_type __n, const bool& __value,
+      const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+ _M_initialize(__n);
+ _M_initialize_value(__value);
+      }
+      vector(const vector& __x)
+      : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
+      {
+ _M_initialize(__x.size());
+ _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
+      }
+      vector(vector&&) = default;
+      vector(vector&& __x, const allocator_type& __a)
+      noexcept(_Bit_alloc_traits::_S_always_equal())
+      : _Base(__a)
+      {
+ if (__x.get_allocator() == __a)
+   this->_M_move_data(std::move(__x));
+ else
+   {
+     _M_initialize(__x.size());
+     _M_copy_aligned(__x.begin(), __x.end(), begin());
+     __x.clear();
+   }
+      }
+      vector(const vector& __x, const allocator_type& __a)
+      : _Base(__a)
+      {
+ _M_initialize(__x.size());
+ _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
+      }
+      vector(initializer_list<bool> __l,
+      const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+ _M_initialize_range(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+      }
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ vector(_InputIterator __first, _InputIterator __last,
+        const allocator_type& __a = allocator_type())
+ : _Base(__a)
+ { _M_initialize_dispatch(__first, __last, __false_type()); }
+      ~vector() noexcept { }
+      vector&
+      operator=(const vector& __x)
+      {
+ if (&__x == this)
+   return *this;
+ if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
+   {
+     if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
+       {
+  this->_M_deallocate();
+  std::__alloc_on_copy(_M_get_Bit_allocator(),
+         __x._M_get_Bit_allocator());
+  _M_initialize(__x.size());
+       }
+     else
+       std::__alloc_on_copy(_M_get_Bit_allocator(),
+       __x._M_get_Bit_allocator());
+   }
+ if (__x.size() > capacity())
+   {
+     this->_M_deallocate();
+     _M_initialize(__x.size());
+   }
+ this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
+        begin());
+ return *this;
+      }
+      vector&
+      operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move())
+      {
+ if (_Bit_alloc_traits::_S_propagate_on_move_assign()
+     || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
+   {
+     this->_M_deallocate();
+     this->_M_move_data(std::move(__x));
+     std::__alloc_on_move(_M_get_Bit_allocator(),
+     __x._M_get_Bit_allocator());
+   }
+ else
+   {
+     if (__x.size() > capacity())
+       {
+  this->_M_deallocate();
+  _M_initialize(__x.size());
+       }
+     this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
+            begin());
+     __x.clear();
+   }
+ return *this;
+      }
+      vector&
+      operator=(initializer_list<bool> __l)
+      {
+ this->assign (__l.begin(), __l.end());
+ return *this;
+      }
+      void
+      assign(size_type __n, const bool& __x)
+      { _M_fill_assign(__n, __x); }
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ void
+ assign(_InputIterator __first, _InputIterator __last)
+ { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
+      void
+      assign(initializer_list<bool> __l)
+      { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); }
+      iterator
+      begin() noexcept
+      { return this->_M_impl._M_start; }
+      const_iterator
+      begin() const noexcept
+      { return this->_M_impl._M_start; }
+      iterator
+      end() noexcept
+      { return this->_M_impl._M_finish; }
+      const_iterator
+      end() const noexcept
+      { return this->_M_impl._M_finish; }
+      reverse_iterator
+      rbegin() noexcept
+      { return reverse_iterator(end()); }
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+      reverse_iterator
+      rend() noexcept
+      { return reverse_iterator(begin()); }
+      const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(begin()); }
+      const_iterator
+      cbegin() const noexcept
+      { return this->_M_impl._M_start; }
+      const_iterator
+      cend() const noexcept
+      { return this->_M_impl._M_finish; }
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+      size_type
+      size() const noexcept
+      { return size_type(end() - begin()); }
+      size_type
+      max_size() const noexcept
+      {
+ const size_type __isize =
+   __gnu_cxx::__numeric_traits<difference_type>::__max
+   - int(_S_word_bit) + 1;
+ const size_type __asize
+   = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
+ return (__asize <= __isize / int(_S_word_bit)
+  ? __asize * int(_S_word_bit) : __isize);
+      }
+      size_type
+      capacity() const noexcept
+      { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
+    - begin()); }
+      bool
+      empty() const noexcept
+      { return begin() == end(); }
+      reference
+      operator[](size_type __n)
+      {
+ return *iterator(this->_M_impl._M_start._M_p
+    + __n / int(_S_word_bit), __n % int(_S_word_bit));
+      }
+      const_reference
+      operator[](size_type __n) const
+      {
+ return *const_iterator(this->_M_impl._M_start._M_p
+        + __n / int(_S_word_bit), __n % int(_S_word_bit));
+      }
+    protected:
+      void
+      _M_range_check(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
+       __n, this->size());
+      }
+    public:
+      reference
+      at(size_type __n)
+      { _M_range_check(__n); return (*this)[__n]; }
+      const_reference
+      at(size_type __n) const
+      { _M_range_check(__n); return (*this)[__n]; }
+      void
+      reserve(size_type __n)
+      {
+ if (__n > max_size())
+   __throw_length_error(("vector::reserve"));
+ if (capacity() < __n)
+   _M_reallocate(__n);
+      }
+      reference
+      front()
+      { return *begin(); }
+      const_reference
+      front() const
+      { return *begin(); }
+      reference
+      back()
+      { return *(end() - 1); }
+      const_reference
+      back() const
+      { return *(end() - 1); }
+      void
+      data() noexcept { }
+      void
+      push_back(bool __x)
+      {
+ if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
+   *this->_M_impl._M_finish++ = __x;
+ else
+   _M_insert_aux(end(), __x);
+      }
+      void
+      swap(vector& __x) noexcept
+      {
+ std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
+ std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
+ std::swap(this->_M_impl._M_end_of_storage,
+    __x._M_impl._M_end_of_storage);
+ _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
+          __x._M_get_Bit_allocator());
+      }
+      static void
+      swap(reference __x, reference __y) noexcept
+      {
+ bool __tmp = __x;
+ __x = __y;
+ __y = __tmp;
+      }
+      iterator
+      insert(const_iterator __position, const bool& __x = bool())
+      {
+ const difference_type __n = __position - begin();
+ if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()
+     && __position == end())
+   *this->_M_impl._M_finish++ = __x;
+ else
+   _M_insert_aux(__position._M_const_cast(), __x);
+ return begin() + __n;
+      }
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ iterator
+ insert(const_iterator __position,
+        _InputIterator __first, _InputIterator __last)
+ {
+   difference_type __offset = __position - cbegin();
+   _M_insert_dispatch(__position._M_const_cast(),
+        __first, __last, __false_type());
+   return begin() + __offset;
+ }
+      iterator
+      insert(const_iterator __position, size_type __n, const bool& __x)
+      {
+ difference_type __offset = __position - cbegin();
+ _M_fill_insert(__position._M_const_cast(), __n, __x);
+ return begin() + __offset;
+      }
+      iterator
+      insert(const_iterator __p, initializer_list<bool> __l)
+      { return this->insert(__p, __l.begin(), __l.end()); }
+      void
+      pop_back()
+      { --this->_M_impl._M_finish; }
+      iterator
+      erase(const_iterator __position)
+      { return _M_erase(__position._M_const_cast()); }
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
+      void
+      resize(size_type __new_size, bool __x = bool())
+      {
+ if (__new_size < size())
+   _M_erase_at_end(begin() + difference_type(__new_size));
+ else
+   insert(end(), __new_size - size(), __x);
+      }
+      void
+      shrink_to_fit()
+      { _M_shrink_to_fit(); }
+      void
+      flip() noexcept
+      {
+ _Bit_type * const __end = this->_M_impl._M_end_addr();
+ for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
+   *__p = ~*__p;
+      }
+      void
+      clear() noexcept
+      { _M_erase_at_end(begin()); }
+      template<typename... _Args>
+ reference
+ emplace_back(_Args&&... __args)
+ {
+   push_back(bool(__args...));
+   return back();
+ }
+      template<typename... _Args>
+ iterator
+ emplace(const_iterator __pos, _Args&&... __args)
+ { return insert(__pos, bool(__args...)); }
+    protected:
+      iterator
+      _M_copy_aligned(const_iterator __first, const_iterator __last,
+        iterator __result)
+      {
+ _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
+ return std::copy(const_iterator(__last._M_p, 0), __last,
+    iterator(__q, 0));
+      }
+      void
+      _M_initialize(size_type __n)
+      {
+ if (__n)
+   {
+     _Bit_pointer __q = this->_M_allocate(__n);
+     this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
+     this->_M_impl._M_start = iterator(std::__addressof(*__q), 0);
+   }
+ else
+   {
+     this->_M_impl._M_end_of_storage = _Bit_pointer();
+     this->_M_impl._M_start = iterator(0, 0);
+   }
+ this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
+      }
+      void
+      _M_initialize_value(bool __x)
+      {
+ if (_Bit_type* __p = this->_M_impl._M_start._M_p)
+   __builtin_memset(__p, __x ? ~0 : 0,
+      (this->_M_impl._M_end_addr() - __p)
+      * sizeof(_Bit_type));
+      }
+      void
+      _M_reallocate(size_type __n);
+      bool
+      _M_shrink_to_fit();
+      template<typename _Integer>
+ void
+ _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+ {
+   _M_initialize(static_cast<size_type>(__n));
+   _M_initialize_value(__x);
+ }
+      template<typename _InputIterator>
+ void
+ _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+          __false_type)
+ { _M_initialize_range(__first, __last,
+         std::__iterator_category(__first)); }
+      template<typename _InputIterator>
+ void
+ _M_initialize_range(_InputIterator __first, _InputIterator __last,
+       std::input_iterator_tag)
+ {
+   for (; __first != __last; ++__first)
+     push_back(*__first);
+ }
+      template<typename _ForwardIterator>
+ void
+ _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
+       std::forward_iterator_tag)
+ {
+   const size_type __n = std::distance(__first, __last);
+   _M_initialize(__n);
+   std::copy(__first, __last, this->_M_impl._M_start);
+ }
+      void
+      _M_fill_assign(size_t __n, bool __x)
+      {
+ if (__n > size())
+   {
+     _M_initialize_value(__x);
+     insert(end(), __n - size(), __x);
+   }
+ else
+   {
+     _M_erase_at_end(begin() + __n);
+     _M_initialize_value(__x);
+   }
+      }
+      template<typename _InputIterator>
+ void
+ _M_assign_aux(_InputIterator __first, _InputIterator __last,
+        std::input_iterator_tag)
+ {
+   iterator __cur = begin();
+   for (; __first != __last && __cur != end(); ++__cur, ++__first)
+     *__cur = *__first;
+   if (__first == __last)
+     _M_erase_at_end(__cur);
+   else
+     insert(end(), __first, __last);
+ }
+      template<typename _ForwardIterator>
+ void
+ _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+        std::forward_iterator_tag)
+ {
+   const size_type __len = std::distance(__first, __last);
+   if (__len < size())
+     _M_erase_at_end(std::copy(__first, __last, begin()));
+   else
+     {
+       _ForwardIterator __mid = __first;
+       std::advance(__mid, size());
+       std::copy(__first, __mid, begin());
+       insert(end(), __mid, __last);
+     }
+ }
+      template<typename _Integer>
+ void
+ _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+      __true_type)
+ { _M_fill_insert(__pos, __n, __x); }
+      template<typename _InputIterator>
+ void
+ _M_insert_dispatch(iterator __pos,
+      _InputIterator __first, _InputIterator __last,
+      __false_type)
+ { _M_insert_range(__pos, __first, __last,
+     std::__iterator_category(__first)); }
+      void
+      _M_fill_insert(iterator __position, size_type __n, bool __x);
+      template<typename _InputIterator>
+ void
+ _M_insert_range(iterator __pos, _InputIterator __first,
+   _InputIterator __last, std::input_iterator_tag)
+ {
+   for (; __first != __last; ++__first)
+     {
+       __pos = insert(__pos, *__first);
+       ++__pos;
+     }
+ }
+      template<typename _ForwardIterator>
+ void
+ _M_insert_range(iterator __position, _ForwardIterator __first,
+   _ForwardIterator __last, std::forward_iterator_tag);
+      void
+      _M_insert_aux(iterator __position, bool __x);
+      size_type
+      _M_check_len(size_type __n, const char* __s) const
+      {
+ if (max_size() - size() < __n)
+   __throw_length_error((__s));
+ const size_type __len = size() + std::max(size(), __n);
+ return (__len < size() || __len > max_size()) ? max_size() : __len;
+      }
+      void
+      _M_erase_at_end(iterator __pos)
+      { this->_M_impl._M_finish = __pos; }
+      iterator
+      _M_erase(iterator __pos);
+      iterator
+      _M_erase(iterator __first, iterator __last);
+  };
+
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Alloc>
+    struct hash<std::vector<bool, _Alloc>>
+    : public __hash_base<size_t, std::vector<bool, _Alloc>>
+    {
+      size_t
+      operator()(const std::vector<bool, _Alloc>&) const noexcept;
+    };
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Container>
+    inline constexpr auto
+    begin(_Container& __cont) -> decltype(__cont.begin())
+    { return __cont.begin(); }
+  template<typename _Container>
+    inline constexpr auto
+    begin(const _Container& __cont) -> decltype(__cont.begin())
+    { return __cont.begin(); }
+  template<typename _Container>
+    inline constexpr auto
+    end(_Container& __cont) -> decltype(__cont.end())
+    { return __cont.end(); }
+  template<typename _Container>
+    inline constexpr auto
+    end(const _Container& __cont) -> decltype(__cont.end())
+    { return __cont.end(); }
+  template<typename _Tp, size_t _Nm>
+    inline constexpr _Tp*
+    begin(_Tp (&__arr)[_Nm])
+    { return __arr; }
+  template<typename _Tp, size_t _Nm>
+    inline constexpr _Tp*
+    end(_Tp (&__arr)[_Nm])
+    { return __arr + _Nm; }
+  template<typename _Tp> class valarray;
+  template<typename _Tp> _Tp* begin(valarray<_Tp>&);
+  template<typename _Tp> const _Tp* begin(const valarray<_Tp>&);
+  template<typename _Tp> _Tp* end(valarray<_Tp>&);
+  template<typename _Tp> const _Tp* end(const valarray<_Tp>&);
+  template<typename _Container>
+    inline constexpr auto
+    cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
+      -> decltype(std::begin(__cont))
+    { return std::begin(__cont); }
+  template<typename _Container>
+    inline constexpr auto
+    cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
+      -> decltype(std::end(__cont))
+    { return std::end(__cont); }
+  template<typename _Container>
+    inline constexpr auto
+    rbegin(_Container& __cont) -> decltype(__cont.rbegin())
+    { return __cont.rbegin(); }
+  template<typename _Container>
+    inline constexpr auto
+    rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
+    { return __cont.rbegin(); }
+  template<typename _Container>
+    inline constexpr auto
+    rend(_Container& __cont) -> decltype(__cont.rend())
+    { return __cont.rend(); }
+  template<typename _Container>
+    inline constexpr auto
+    rend(const _Container& __cont) -> decltype(__cont.rend())
+    { return __cont.rend(); }
+  template<typename _Tp, size_t _Nm>
+    inline constexpr reverse_iterator<_Tp*>
+    rbegin(_Tp (&__arr)[_Nm])
+    { return reverse_iterator<_Tp*>(__arr + _Nm); }
+  template<typename _Tp, size_t _Nm>
+    inline constexpr reverse_iterator<_Tp*>
+    rend(_Tp (&__arr)[_Nm])
+    { return reverse_iterator<_Tp*>(__arr); }
+  template<typename _Tp>
+    inline constexpr reverse_iterator<const _Tp*>
+    rbegin(initializer_list<_Tp> __il)
+    { return reverse_iterator<const _Tp*>(__il.end()); }
+  template<typename _Tp>
+    inline constexpr reverse_iterator<const _Tp*>
+    rend(initializer_list<_Tp> __il)
+    { return reverse_iterator<const _Tp*>(__il.begin()); }
+  template<typename _Container>
+    inline constexpr auto
+    crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
+    { return std::rbegin(__cont); }
+  template<typename _Container>
+    inline constexpr auto
+    crend(const _Container& __cont) -> decltype(std::rend(__cont))
+    { return std::rend(__cont); }
+  template <typename _Container>
+    constexpr auto
+    size(const _Container& __cont) noexcept(noexcept(__cont.size()))
+    -> decltype(__cont.size())
+    { return __cont.size(); }
+  template <typename _Tp, size_t _Nm>
+    constexpr size_t
+    size(const _Tp (& )[_Nm]) noexcept
+    { return _Nm; }
+  template <typename _Container>
+    [[nodiscard]] constexpr auto
+    empty(const _Container& __cont) noexcept(noexcept(__cont.empty()))
+    -> decltype(__cont.empty())
+    { return __cont.empty(); }
+  template <typename _Tp, size_t _Nm>
+    [[nodiscard]] constexpr bool
+    empty(const _Tp (& )[_Nm]) noexcept
+    { return false; }
+  template <typename _Tp>
+    [[nodiscard]] constexpr bool
+    empty(initializer_list<_Tp> __il) noexcept
+    { return __il.size() == 0;}
+  template <typename _Container>
+    constexpr auto
+    data(_Container& __cont) noexcept(noexcept(__cont.data()))
+    -> decltype(__cont.data())
+    { return __cont.data(); }
+  template <typename _Container>
+    constexpr auto
+    data(const _Container& __cont) noexcept(noexcept(__cont.data()))
+    -> decltype(__cont.data())
+    { return __cont.data(); }
+  template <typename _Tp, size_t _Nm>
+    constexpr _Tp*
+    data(_Tp (&__array)[_Nm]) noexcept
+    { return __array; }
+  template <typename _Tp>
+    constexpr const _Tp*
+    data(initializer_list<_Tp> __il) noexcept
+    { return __il.begin(); }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    reserve(size_type __n)
+    {
+      if (__n > this->max_size())
+ __throw_length_error(("vector::reserve"));
+      if (this->capacity() < __n)
+ {
+   const size_type __old_size = size();
+   pointer __tmp = _M_allocate_and_copy(__n,
+     std::__make_move_if_noexcept_iterator(this->_M_impl._M_start),
+     std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish));
+   ;
+   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+   _M_get_Tp_allocator());
+   _M_deallocate(this->_M_impl._M_start,
+   this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_start);
+   this->_M_impl._M_start = __tmp;
+   this->_M_impl._M_finish = __tmp + __old_size;
+   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+ }
+    }
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      typename vector<_Tp, _Alloc>::reference
+      vector<_Tp, _Alloc>::
+      emplace_back(_Args&&... __args)
+      {
+ if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+   {
+     ;
+     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+         std::forward<_Args>(__args)...);
+     ++this->_M_impl._M_finish;
+     ;
+   }
+ else
+   _M_realloc_insert(end(), std::forward<_Args>(__args)...);
+ return back();
+      }
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    insert(const_iterator __position, const value_type& __x)
+    {
+      const size_type __n = __position - begin();
+      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+ if (__position == end())
+   {
+     ;
+     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+         __x);
+     ++this->_M_impl._M_finish;
+     ;
+   }
+ else
+   {
+     const auto __pos = begin() + (__position - cbegin());
+     _Temporary_value __x_copy(this, __x);
+     _M_insert_aux(__pos, std::move(__x_copy._M_val()));
+   }
+      else
+ _M_realloc_insert(begin() + (__position - cbegin()), __x);
+      return iterator(this->_M_impl._M_start + __n);
+    }
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    _M_erase(iterator __position)
+    {
+      if (__position + 1 != end())
+ std::move(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
+      ;
+      return __position;
+    }
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    _M_erase(iterator __first, iterator __last)
+    {
+      if (__first != __last)
+ {
+   if (__last != end())
+     std::move(__last, end(), __first);
+   _M_erase_at_end(__first.base() + (end() - __last));
+ }
+      return __first;
+    }
+  template<typename _Tp, typename _Alloc>
+    vector<_Tp, _Alloc>&
+    vector<_Tp, _Alloc>::
+    operator=(const vector<_Tp, _Alloc>& __x)
+    {
+      if (&__x != this)
+ {
+   ;
+   if (_Alloc_traits::_S_propagate_on_copy_assign())
+     {
+       if (!_Alloc_traits::_S_always_equal()
+           && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
+         {
+    this->clear();
+    _M_deallocate(this->_M_impl._M_start,
+    this->_M_impl._M_end_of_storage
+    - this->_M_impl._M_start);
+    this->_M_impl._M_start = nullptr;
+    this->_M_impl._M_finish = nullptr;
+    this->_M_impl._M_end_of_storage = nullptr;
+  }
+       std::__alloc_on_copy(_M_get_Tp_allocator(),
+       __x._M_get_Tp_allocator());
+     }
+   const size_type __xlen = __x.size();
+   if (__xlen > capacity())
+     {
+       pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
+         __x.end());
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+       _M_deallocate(this->_M_impl._M_start,
+       this->_M_impl._M_end_of_storage
+       - this->_M_impl._M_start);
+       this->_M_impl._M_start = __tmp;
+       this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
+     }
+   else if (size() >= __xlen)
+     {
+       std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
+       end(), _M_get_Tp_allocator());
+     }
+   else
+     {
+       std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
+   this->_M_impl._M_start);
+       std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
+       __x._M_impl._M_finish,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+     }
+   this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
+ }
+      return *this;
+    }
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_fill_assign(size_t __n, const value_type& __val)
+    {
+      if (__n > capacity())
+ {
+   vector __tmp(__n, __val, _M_get_Tp_allocator());
+   __tmp._M_impl._M_swap_data(this->_M_impl);
+ }
+      else if (__n > size())
+ {
+   std::fill(begin(), end(), __val);
+   const size_type __add = __n - size();
+   ;
+   this->_M_impl._M_finish =
+     std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+       __add, __val, _M_get_Tp_allocator());
+   ;
+ }
+      else
+        _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
+    }
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+      std::input_iterator_tag)
+      {
+ pointer __cur(this->_M_impl._M_start);
+ for (; __first != __last && __cur != this->_M_impl._M_finish;
+      ++__cur, ++__first)
+   *__cur = *__first;
+ if (__first == __last)
+   _M_erase_at_end(__cur);
+ else
+   _M_range_insert(end(), __first, __last,
+     std::__iterator_category(__first));
+      }
+  template<typename _Tp, typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+      std::forward_iterator_tag)
+      {
+ const size_type __len = std::distance(__first, __last);
+ if (__len > capacity())
+   {
+     pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
+     ;
+     std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+     _M_get_Tp_allocator());
+     _M_deallocate(this->_M_impl._M_start,
+     this->_M_impl._M_end_of_storage
+     - this->_M_impl._M_start);
+     this->_M_impl._M_start = __tmp;
+     this->_M_impl._M_finish = this->_M_impl._M_start + __len;
+     this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
+   }
+ else if (size() >= __len)
+   _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
+ else
+   {
+     _ForwardIterator __mid = __first;
+     std::advance(__mid, size());
+     std::copy(__first, __mid, this->_M_impl._M_start);
+     const size_type __attribute__((__unused__)) __n = __len - size();
+     ;
+     this->_M_impl._M_finish =
+       std::__uninitialized_copy_a(__mid, __last,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+     ;
+   }
+      }
+  template<typename _Tp, typename _Alloc>
+    auto
+    vector<_Tp, _Alloc>::
+    _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator
+    {
+      const auto __n = __position - cbegin();
+      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+ if (__position == cend())
+   {
+     ;
+     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+         std::move(__v));
+     ++this->_M_impl._M_finish;
+     ;
+   }
+ else
+   _M_insert_aux(begin() + __n, std::move(__v));
+      else
+ _M_realloc_insert(begin() + __n, std::move(__v));
+      return iterator(this->_M_impl._M_start + __n);
+    }
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      auto
+      vector<_Tp, _Alloc>::
+      _M_emplace_aux(const_iterator __position, _Args&&... __args)
+      -> iterator
+      {
+ const auto __n = __position - cbegin();
+ if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+   if (__position == cend())
+     {
+       ;
+       _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+           std::forward<_Args>(__args)...);
+       ++this->_M_impl._M_finish;
+       ;
+     }
+   else
+     {
+       _Temporary_value __tmp(this, std::forward<_Args>(__args)...);
+       _M_insert_aux(begin() + __n, std::move(__tmp._M_val()));
+     }
+ else
+   _M_realloc_insert(begin() + __n, std::forward<_Args>(__args)...);
+ return iterator(this->_M_impl._M_start + __n);
+      }
+  template<typename _Tp, typename _Alloc>
+    template<typename _Arg>
+      void
+      vector<_Tp, _Alloc>::
+      _M_insert_aux(iterator __position, _Arg&& __arg)
+    {
+      ;
+      _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+          std::move(*(this->_M_impl._M_finish - 1)));
+      ++this->_M_impl._M_finish;
+      ;
+      std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1);
+      *__position = std::forward<_Arg>(__arg);
+    }
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      vector<_Tp, _Alloc>::
+      _M_realloc_insert(iterator __position, _Args&&... __args)
+    {
+      const size_type __len =
+ _M_check_len(size_type(1), "vector::_M_realloc_insert");
+      pointer __old_start = this->_M_impl._M_start;
+      pointer __old_finish = this->_M_impl._M_finish;
+      const size_type __elems_before = __position - begin();
+      pointer __new_start(this->_M_allocate(__len));
+      pointer __new_finish(__new_start);
+      try
+ {
+   _Alloc_traits::construct(this->_M_impl,
+       __new_start + __elems_before,
+       std::forward<_Args>(__args)...);
+   __new_finish = pointer();
+   __new_finish
+     = std::__uninitialized_move_if_noexcept_a
+     (__old_start, __position.base(),
+      __new_start, _M_get_Tp_allocator());
+   ++__new_finish;
+   __new_finish
+     = std::__uninitialized_move_if_noexcept_a
+     (__position.base(), __old_finish,
+      __new_finish, _M_get_Tp_allocator());
+ }
+      catch(...)
+ {
+   if (!__new_finish)
+     _Alloc_traits::destroy(this->_M_impl,
+       __new_start + __elems_before);
+   else
+     std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
+   _M_deallocate(__new_start, __len);
+   throw;
+ }
+      ;
+      std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
+      _M_deallocate(__old_start,
+      this->_M_impl._M_end_of_storage - __old_start);
+      this->_M_impl._M_start = __new_start;
+      this->_M_impl._M_finish = __new_finish;
+      this->_M_impl._M_end_of_storage = __new_start + __len;
+    }
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
+    {
+      if (__n != 0)
+ {
+   if (size_type(this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_finish) >= __n)
+     {
+       _Temporary_value __tmp(this, __x);
+       value_type& __x_copy = __tmp._M_val();
+       const size_type __elems_after = end() - __position;
+       pointer __old_finish(this->_M_impl._M_finish);
+       if (__elems_after > __n)
+  {
+    ;
+    std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
+           this->_M_impl._M_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish += __n;
+    ;
+    std::move_backward(__position.base(), __old_finish - __n, __old_finish);
+    std::fill(__position.base(), __position.base() + __n,
+       __x_copy);
+  }
+       else
+  {
+    ;
+    this->_M_impl._M_finish =
+      std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+        __n - __elems_after,
+        __x_copy,
+        _M_get_Tp_allocator());
+    ;
+    std::__uninitialized_move_a(__position.base(), __old_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish += __elems_after;
+    ;
+    std::fill(__position.base(), __old_finish, __x_copy);
+  }
+     }
+   else
+     {
+       const size_type __len =
+  _M_check_len(__n, "vector::_M_fill_insert");
+       const size_type __elems_before = __position - begin();
+       pointer __new_start(this->_M_allocate(__len));
+       pointer __new_finish(__new_start);
+       try
+  {
+    std::__uninitialized_fill_n_a(__new_start + __elems_before,
+      __n, __x,
+      _M_get_Tp_allocator());
+    __new_finish = pointer();
+    __new_finish
+      = std::__uninitialized_move_if_noexcept_a
+      (this->_M_impl._M_start, __position.base(),
+       __new_start, _M_get_Tp_allocator());
+    __new_finish += __n;
+    __new_finish
+      = std::__uninitialized_move_if_noexcept_a
+      (__position.base(), this->_M_impl._M_finish,
+       __new_finish, _M_get_Tp_allocator());
+  }
+       catch(...)
+  {
+    if (!__new_finish)
+      std::_Destroy(__new_start + __elems_before,
+      __new_start + __elems_before + __n,
+      _M_get_Tp_allocator());
+    else
+      std::_Destroy(__new_start, __new_finish,
+      _M_get_Tp_allocator());
+    _M_deallocate(__new_start, __len);
+    throw;
+  }
+       ;
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+       _M_deallocate(this->_M_impl._M_start,
+       this->_M_impl._M_end_of_storage
+       - this->_M_impl._M_start);
+       this->_M_impl._M_start = __new_start;
+       this->_M_impl._M_finish = __new_finish;
+       this->_M_impl._M_end_of_storage = __new_start + __len;
+     }
+ }
+    }
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_default_append(size_type __n)
+    {
+      if (__n != 0)
+ {
+   const size_type __size = size();
+   size_type __navail = size_type(this->_M_impl._M_end_of_storage
+      - this->_M_impl._M_finish);
+   if (__size > max_size() || __navail > max_size() - __size)
+     __builtin_unreachable();
+   if (__navail >= __n)
+     {
+       ;
+       this->_M_impl._M_finish =
+  std::__uninitialized_default_n_a(this->_M_impl._M_finish,
+       __n, _M_get_Tp_allocator());
+       ;
+     }
+   else
+     {
+       const size_type __len =
+  _M_check_len(__n, "vector::_M_default_append");
+       pointer __new_start(this->_M_allocate(__len));
+       pointer __destroy_from = pointer();
+       try
+  {
+    std::__uninitialized_default_n_a(__new_start + __size,
+         __n, _M_get_Tp_allocator());
+    __destroy_from = __new_start + __size;
+    std::__uninitialized_move_if_noexcept_a(
+        this->_M_impl._M_start, this->_M_impl._M_finish,
+        __new_start, _M_get_Tp_allocator());
+  }
+       catch(...)
+  {
+    if (__destroy_from)
+      std::_Destroy(__destroy_from, __destroy_from + __n,
+      _M_get_Tp_allocator());
+    _M_deallocate(__new_start, __len);
+    throw;
+  }
+       ;
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+       _M_deallocate(this->_M_impl._M_start,
+       this->_M_impl._M_end_of_storage
+       - this->_M_impl._M_start);
+       this->_M_impl._M_start = __new_start;
+       this->_M_impl._M_finish = __new_start + __size + __n;
+       this->_M_impl._M_end_of_storage = __new_start + __len;
+     }
+ }
+    }
+  template<typename _Tp, typename _Alloc>
+    bool
+    vector<_Tp, _Alloc>::
+    _M_shrink_to_fit()
+    {
+      if (capacity() == size())
+ return false;
+      ;
+      return std::__shrink_to_fit_aux<vector>::_S_do_it(*this);
+    }
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_range_insert(iterator __pos, _InputIterator __first,
+        _InputIterator __last, std::input_iterator_tag)
+      {
+ if (__pos == end())
+   {
+     for (; __first != __last; ++__first)
+       insert(end(), *__first);
+   }
+ else if (__first != __last)
+   {
+     vector __tmp(__first, __last, _M_get_Tp_allocator());
+     insert(__pos,
+     std::make_move_iterator(__tmp.begin()),
+     std::make_move_iterator(__tmp.end()));
+   }
+      }
+  template<typename _Tp, typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_range_insert(iterator __position, _ForwardIterator __first,
+        _ForwardIterator __last, std::forward_iterator_tag)
+      {
+ if (__first != __last)
+   {
+     const size_type __n = std::distance(__first, __last);
+     if (size_type(this->_M_impl._M_end_of_storage
+     - this->_M_impl._M_finish) >= __n)
+       {
+  const size_type __elems_after = end() - __position;
+  pointer __old_finish(this->_M_impl._M_finish);
+  if (__elems_after > __n)
+    {
+      ;
+      std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
+      this->_M_impl._M_finish,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __n;
+      ;
+      std::move_backward(__position.base(), __old_finish - __n, __old_finish);
+      std::copy(__first, __last, __position);
+    }
+  else
+    {
+      _ForwardIterator __mid = __first;
+      std::advance(__mid, __elems_after);
+      ;
+      std::__uninitialized_copy_a(__mid, __last,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __n - __elems_after;
+      ;
+      std::__uninitialized_move_a(__position.base(),
+      __old_finish,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __elems_after;
+      ;
+      std::copy(__first, __mid, __position);
+    }
+       }
+     else
+       {
+  const size_type __len =
+    _M_check_len(__n, "vector::_M_range_insert");
+  pointer __new_start(this->_M_allocate(__len));
+  pointer __new_finish(__new_start);
+  try
+    {
+      __new_finish
+        = std::__uninitialized_move_if_noexcept_a
+        (this->_M_impl._M_start, __position.base(),
+         __new_start, _M_get_Tp_allocator());
+      __new_finish
+        = std::__uninitialized_copy_a(__first, __last,
+          __new_finish,
+          _M_get_Tp_allocator());
+      __new_finish
+        = std::__uninitialized_move_if_noexcept_a
+        (__position.base(), this->_M_impl._M_finish,
+         __new_finish, _M_get_Tp_allocator());
+    }
+  catch(...)
+    {
+      std::_Destroy(__new_start, __new_finish,
+      _M_get_Tp_allocator());
+      _M_deallocate(__new_start, __len);
+      throw;
+    }
+  ;
+  std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+         _M_get_Tp_allocator());
+  _M_deallocate(this->_M_impl._M_start,
+         this->_M_impl._M_end_of_storage
+         - this->_M_impl._M_start);
+  this->_M_impl._M_start = __new_start;
+  this->_M_impl._M_finish = __new_finish;
+  this->_M_impl._M_end_of_storage = __new_start + __len;
+       }
+   }
+      }
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_reallocate(size_type __n)
+    {
+      _Bit_pointer __q = this->_M_allocate(__n);
+      iterator __start(std::__addressof(*__q), 0);
+      iterator __finish(_M_copy_aligned(begin(), end(), __start));
+      this->_M_deallocate();
+      this->_M_impl._M_start = __start;
+      this->_M_impl._M_finish = __finish;
+      this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
+    }
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_fill_insert(iterator __position, size_type __n, bool __x)
+    {
+      if (__n == 0)
+ return;
+      if (capacity() - size() >= __n)
+ {
+   std::copy_backward(__position, end(),
+        this->_M_impl._M_finish + difference_type(__n));
+   std::fill(__position, __position + difference_type(__n), __x);
+   this->_M_impl._M_finish += difference_type(__n);
+ }
+      else
+ {
+   const size_type __len =
+     _M_check_len(__n, "vector<bool>::_M_fill_insert");
+   _Bit_pointer __q = this->_M_allocate(__len);
+   iterator __start(std::__addressof(*__q), 0);
+   iterator __i = _M_copy_aligned(begin(), __position, __start);
+   std::fill(__i, __i + difference_type(__n), __x);
+   iterator __finish = std::copy(__position, end(),
+     __i + difference_type(__n));
+   this->_M_deallocate();
+   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
+   this->_M_impl._M_start = __start;
+   this->_M_impl._M_finish = __finish;
+ }
+    }
+  template<typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<bool, _Alloc>::
+      _M_insert_range(iterator __position, _ForwardIterator __first,
+        _ForwardIterator __last, std::forward_iterator_tag)
+      {
+ if (__first != __last)
+   {
+     size_type __n = std::distance(__first, __last);
+     if (capacity() - size() >= __n)
+       {
+  std::copy_backward(__position, end(),
+       this->_M_impl._M_finish
+       + difference_type(__n));
+  std::copy(__first, __last, __position);
+  this->_M_impl._M_finish += difference_type(__n);
+       }
+     else
+       {
+  const size_type __len =
+    _M_check_len(__n, "vector<bool>::_M_insert_range");
+  _Bit_pointer __q = this->_M_allocate(__len);
+  iterator __start(std::__addressof(*__q), 0);
+  iterator __i = _M_copy_aligned(begin(), __position, __start);
+  __i = std::copy(__first, __last, __i);
+  iterator __finish = std::copy(__position, end(), __i);
+  this->_M_deallocate();
+  this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
+  this->_M_impl._M_start = __start;
+  this->_M_impl._M_finish = __finish;
+       }
+   }
+      }
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_insert_aux(iterator __position, bool __x)
+    {
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
+ {
+   std::copy_backward(__position, this->_M_impl._M_finish,
+        this->_M_impl._M_finish + 1);
+   *__position = __x;
+   ++this->_M_impl._M_finish;
+ }
+      else
+ {
+   const size_type __len =
+     _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
+   _Bit_pointer __q = this->_M_allocate(__len);
+   iterator __start(std::__addressof(*__q), 0);
+   iterator __i = _M_copy_aligned(begin(), __position, __start);
+   *__i++ = __x;
+   iterator __finish = std::copy(__position, end(), __i);
+   this->_M_deallocate();
+   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
+   this->_M_impl._M_start = __start;
+   this->_M_impl._M_finish = __finish;
+ }
+    }
+  template<typename _Alloc>
+    typename vector<bool, _Alloc>::iterator
+    vector<bool, _Alloc>::
+    _M_erase(iterator __position)
+    {
+      if (__position + 1 != end())
+        std::copy(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      return __position;
+    }
+  template<typename _Alloc>
+    typename vector<bool, _Alloc>::iterator
+    vector<bool, _Alloc>::
+    _M_erase(iterator __first, iterator __last)
+    {
+      if (__first != __last)
+ _M_erase_at_end(std::copy(__last, end(), __first));
+      return __first;
+    }
+  template<typename _Alloc>
+    bool
+    vector<bool, _Alloc>::
+    _M_shrink_to_fit()
+    {
+      if (capacity() - size() < int(_S_word_bit))
+ return false;
+      try
+ {
+   _M_reallocate(size());
+   return true;
+ }
+      catch(...)
+ { return false; }
+    }
+
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Alloc>
+    size_t
+    hash<std::vector<bool, _Alloc>>::
+    operator()(const std::vector<bool, _Alloc>& __b) const noexcept
+    {
+      size_t __hash = 0;
+      using std::_S_word_bit;
+      using std::_Bit_type;
+      const size_t __words = __b.size() / _S_word_bit;
+      if (__words)
+ {
+   const size_t __clength = __words * sizeof(_Bit_type);
+   __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
+ }
+      const size_t __extrabits = __b.size() % _S_word_bit;
+      if (__extrabits)
+ {
+   _Bit_type __hiword = *__b._M_impl._M_finish._M_p;
+   __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);
+   const size_t __clength
+     = (__extrabits + 8 - 1) / 8;
+   if (__words)
+     __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
+   else
+     __hash = std::_Hash_impl::hash(&__hiword, __clength);
+ }
+      return __hash;
+    }
+
+}
+namespace mlx::core {
+namespace {
+union float_bits_fp16 {
+  float f;
+  uint32_t u;
+};
+}
+struct _MLX_Float16 {
+  uint16_t bits_;
+  _MLX_Float16() = default;
+  _MLX_Float16(_MLX_Float16 const&) = default;
+  _MLX_Float16& operator=(std::vector<bool>::reference x) {
+    bits_ = x;
+    return *this;
+  }
+  _MLX_Float16& operator=(const float& x) {
+    return (*this = _MLX_Float16(x));
+  }
+  _MLX_Float16(const float& x) : bits_(0) {
+    float_bits_fp16 in;
+    in.f = x;
+    uint32_t x_sign_32 = in.u & uint32_t(0x80000000);
+    uint16_t x_sign_16 = (x_sign_32 >> 16);
+    if (std::isnan(x)) {
+      bits_ = x_sign_16 | uint16_t(0x7D00);
+    } else {
+      float_bits_fp16 inf_scale, zero_scale, magic_bits;
+      uint32_t x_expo_32 = in.u & uint32_t(0x7f800000);
+      uint32_t max_expo_32 = uint32_t(0x38800000);
+      x_expo_32 = x_expo_32 < max_expo_32 ? max_expo_32 : x_expo_32;
+      x_expo_32 += uint32_t(15) << 23;
+      inf_scale.u = uint32_t(0x77800000);
+      zero_scale.u = uint32_t(0x08800000);
+      magic_bits.u = x_expo_32;
+      magic_bits.f += (std::abs(x) * inf_scale.f) * zero_scale.f;
+      uint32_t x_expo_16 = ((magic_bits.u >> 13) & uint32_t(0x7c00));
+      uint32_t x_mant_16 = magic_bits.u & uint32_t(0x0fff);
+      bits_ = (x_sign_16 | uint16_t(x_expo_16 + x_mant_16));
+    }
+  }
+  operator float() const {
+    float_bits_fp16 out;
+    uint32_t x_sign_32 = (bits_ << 16) & uint32_t(0x80000000);
+    uint32_t base = (bits_ << 16);
+    uint32_t two_base = base + base;
+    uint32_t denorm_max = 1u << 27;
+    if (two_base < denorm_max) {
+      out.u = uint32_t(126) << 23;
+      out.u |= (two_base >> 17);
+      out.f -= 0.5f;
+    } else {
+      out.u = uint32_t(0xE0) << 23;
+      out.u += (two_base >> 4);
+      float out_unscaled = out.f;
+      out.u = uint32_t(0x7800000);
+      out.f *= out_unscaled;
+    }
+    out.u |= x_sign_32;
+    return out.f;
+  }
+};
+inline _MLX_Float16 operator+(_MLX_Float16 lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline float operator+(_MLX_Float16 lhs, float rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline float operator+(float lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline double operator+(_MLX_Float16 lhs, double rhs) { return static_cast<double>(lhs) + static_cast<double>(rhs); } inline double operator+(double lhs, _MLX_Float16 rhs) { return static_cast<double>(lhs) + static_cast<double>(rhs); }; inline _MLX_Float16 operator+(_MLX_Float16 lhs, bool rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_Float16 operator+(bool lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline _MLX_Float16 operator+(_MLX_Float16 lhs, int32_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_Float16 operator+(int32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline _MLX_Float16 operator+(_MLX_Float16 lhs, uint32_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_Float16 operator+(uint32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline _MLX_Float16 operator+(_MLX_Float16 lhs, int64_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_Float16 operator+(int64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline _MLX_Float16 operator+(_MLX_Float16 lhs, uint64_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_Float16 operator+(uint64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); };;
+inline _MLX_Float16 operator-(_MLX_Float16 lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline float operator-(_MLX_Float16 lhs, float rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline float operator-(float lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline double operator-(_MLX_Float16 lhs, double rhs) { return static_cast<double>(lhs) - static_cast<double>(rhs); } inline double operator-(double lhs, _MLX_Float16 rhs) { return static_cast<double>(lhs) - static_cast<double>(rhs); }; inline _MLX_Float16 operator-(_MLX_Float16 lhs, bool rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_Float16 operator-(bool lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline _MLX_Float16 operator-(_MLX_Float16 lhs, int32_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_Float16 operator-(int32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline _MLX_Float16 operator-(_MLX_Float16 lhs, uint32_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_Float16 operator-(uint32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline _MLX_Float16 operator-(_MLX_Float16 lhs, int64_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_Float16 operator-(int64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline _MLX_Float16 operator-(_MLX_Float16 lhs, uint64_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_Float16 operator-(uint64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); };;
+inline _MLX_Float16 operator*(_MLX_Float16 lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline float operator*(_MLX_Float16 lhs, float rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline float operator*(float lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline double operator*(_MLX_Float16 lhs, double rhs) { return static_cast<double>(lhs) * static_cast<double>(rhs); } inline double operator*(double lhs, _MLX_Float16 rhs) { return static_cast<double>(lhs) * static_cast<double>(rhs); }; inline _MLX_Float16 operator*(_MLX_Float16 lhs, bool rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_Float16 operator*(bool lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline _MLX_Float16 operator*(_MLX_Float16 lhs, int32_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_Float16 operator*(int32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline _MLX_Float16 operator*(_MLX_Float16 lhs, uint32_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_Float16 operator*(uint32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline _MLX_Float16 operator*(_MLX_Float16 lhs, int64_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_Float16 operator*(int64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline _MLX_Float16 operator*(_MLX_Float16 lhs, uint64_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_Float16 operator*(uint64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); };;
+inline _MLX_Float16 operator/(_MLX_Float16 lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline float operator/(_MLX_Float16 lhs, float rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline float operator/(float lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline double operator/(_MLX_Float16 lhs, double rhs) { return static_cast<double>(lhs) / static_cast<double>(rhs); } inline double operator/(double lhs, _MLX_Float16 rhs) { return static_cast<double>(lhs) / static_cast<double>(rhs); }; inline _MLX_Float16 operator/(_MLX_Float16 lhs, bool rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_Float16 operator/(bool lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline _MLX_Float16 operator/(_MLX_Float16 lhs, int32_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_Float16 operator/(int32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline _MLX_Float16 operator/(_MLX_Float16 lhs, uint32_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_Float16 operator/(uint32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline _MLX_Float16 operator/(_MLX_Float16 lhs, int64_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_Float16 operator/(int64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline _MLX_Float16 operator/(_MLX_Float16 lhs, uint64_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_Float16 operator/(uint64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); };;
+inline bool operator>(_MLX_Float16 lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); }; inline bool operator>(_MLX_Float16 lhs, float rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); } inline bool operator>(float lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); }; inline bool operator>(_MLX_Float16 lhs, double rhs) { return static_cast<double>(lhs) > static_cast<double>(rhs); } inline bool operator>(double lhs, _MLX_Float16 rhs) { return static_cast<double>(lhs) > static_cast<double>(rhs); }; inline bool operator>(_MLX_Float16 lhs, int32_t rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); } inline bool operator>(int32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); }; inline bool operator>(_MLX_Float16 lhs, uint32_t rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); } inline bool operator>(uint32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); }; inline bool operator>(_MLX_Float16 lhs, int64_t rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); } inline bool operator>(int64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); }; inline bool operator>(_MLX_Float16 lhs, uint64_t rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); } inline bool operator>(uint64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); };;
+inline bool operator<(_MLX_Float16 lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); }; inline bool operator<(_MLX_Float16 lhs, float rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); } inline bool operator<(float lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); }; inline bool operator<(_MLX_Float16 lhs, double rhs) { return static_cast<double>(lhs) < static_cast<double>(rhs); } inline bool operator<(double lhs, _MLX_Float16 rhs) { return static_cast<double>(lhs) < static_cast<double>(rhs); }; inline bool operator<(_MLX_Float16 lhs, int32_t rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); } inline bool operator<(int32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); }; inline bool operator<(_MLX_Float16 lhs, uint32_t rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); } inline bool operator<(uint32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); }; inline bool operator<(_MLX_Float16 lhs, int64_t rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); } inline bool operator<(int64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); }; inline bool operator<(_MLX_Float16 lhs, uint64_t rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); } inline bool operator<(uint64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); };;
+inline bool operator>=(_MLX_Float16 lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); }; inline bool operator>=(_MLX_Float16 lhs, float rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); } inline bool operator>=(float lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); }; inline bool operator>=(_MLX_Float16 lhs, double rhs) { return static_cast<double>(lhs) >= static_cast<double>(rhs); } inline bool operator>=(double lhs, _MLX_Float16 rhs) { return static_cast<double>(lhs) >= static_cast<double>(rhs); }; inline bool operator>=(_MLX_Float16 lhs, int32_t rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); } inline bool operator>=(int32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); }; inline bool operator>=(_MLX_Float16 lhs, uint32_t rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); } inline bool operator>=(uint32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); }; inline bool operator>=(_MLX_Float16 lhs, int64_t rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); } inline bool operator>=(int64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); }; inline bool operator>=(_MLX_Float16 lhs, uint64_t rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); } inline bool operator>=(uint64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); };;
+inline bool operator<=(_MLX_Float16 lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); }; inline bool operator<=(_MLX_Float16 lhs, float rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); } inline bool operator<=(float lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); }; inline bool operator<=(_MLX_Float16 lhs, double rhs) { return static_cast<double>(lhs) <= static_cast<double>(rhs); } inline bool operator<=(double lhs, _MLX_Float16 rhs) { return static_cast<double>(lhs) <= static_cast<double>(rhs); }; inline bool operator<=(_MLX_Float16 lhs, int32_t rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); } inline bool operator<=(int32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); }; inline bool operator<=(_MLX_Float16 lhs, uint32_t rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); } inline bool operator<=(uint32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); }; inline bool operator<=(_MLX_Float16 lhs, int64_t rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); } inline bool operator<=(int64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); }; inline bool operator<=(_MLX_Float16 lhs, uint64_t rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); } inline bool operator<=(uint64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); };;
+inline bool operator==(_MLX_Float16 lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); }; inline bool operator==(_MLX_Float16 lhs, float rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); } inline bool operator==(float lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); }; inline bool operator==(_MLX_Float16 lhs, double rhs) { return static_cast<double>(lhs) == static_cast<double>(rhs); } inline bool operator==(double lhs, _MLX_Float16 rhs) { return static_cast<double>(lhs) == static_cast<double>(rhs); }; inline bool operator==(_MLX_Float16 lhs, int32_t rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); } inline bool operator==(int32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); }; inline bool operator==(_MLX_Float16 lhs, uint32_t rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); } inline bool operator==(uint32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); }; inline bool operator==(_MLX_Float16 lhs, int64_t rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); } inline bool operator==(int64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); }; inline bool operator==(_MLX_Float16 lhs, uint64_t rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); } inline bool operator==(uint64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); };;
+inline bool operator!=(_MLX_Float16 lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); }; inline bool operator!=(_MLX_Float16 lhs, float rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); } inline bool operator!=(float lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); }; inline bool operator!=(_MLX_Float16 lhs, double rhs) { return static_cast<double>(lhs) != static_cast<double>(rhs); } inline bool operator!=(double lhs, _MLX_Float16 rhs) { return static_cast<double>(lhs) != static_cast<double>(rhs); }; inline bool operator!=(_MLX_Float16 lhs, int32_t rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); } inline bool operator!=(int32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); }; inline bool operator!=(_MLX_Float16 lhs, uint32_t rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); } inline bool operator!=(uint32_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); }; inline bool operator!=(_MLX_Float16 lhs, int64_t rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); } inline bool operator!=(int64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); }; inline bool operator!=(_MLX_Float16 lhs, uint64_t rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); } inline bool operator!=(uint64_t lhs, _MLX_Float16 rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); };;
+inline _MLX_Float16 operator-(_MLX_Float16 lhs) {
+  return -static_cast<float>(lhs);
+}
+inline _MLX_Float16& operator+=(_MLX_Float16& lhs, const float& rhs) { lhs = lhs + rhs; return lhs; } inline float& operator+=(float& lhs, _MLX_Float16 rhs) { lhs = lhs + rhs; return lhs; };
+inline _MLX_Float16& operator-=(_MLX_Float16& lhs, const float& rhs) { lhs = lhs - rhs; return lhs; } inline float& operator-=(float& lhs, _MLX_Float16 rhs) { lhs = lhs - rhs; return lhs; };
+inline _MLX_Float16& operator*=(_MLX_Float16& lhs, const float& rhs) { lhs = lhs * rhs; return lhs; } inline float& operator*=(float& lhs, _MLX_Float16 rhs) { lhs = lhs * rhs; return lhs; };
+inline _MLX_Float16& operator/=(_MLX_Float16& lhs, const float& rhs) { lhs = lhs / rhs; return lhs; } inline float& operator/=(float& lhs, _MLX_Float16 rhs) { lhs = lhs / rhs; return lhs; };
+inline _MLX_Float16 operator|(_MLX_Float16 lhs, _MLX_Float16 rhs) { _MLX_Float16 out; out.bits_ = lhs.bits_ | rhs.bits_; return out; } inline _MLX_Float16 operator|(_MLX_Float16 lhs, uint16_t rhs) { _MLX_Float16 out; out.bits_ = lhs.bits_ | rhs; return out; } inline _MLX_Float16 operator|(uint16_t lhs, _MLX_Float16 rhs) { _MLX_Float16 out; out.bits_ = lhs | rhs.bits_; return out; };
+inline _MLX_Float16 operator&(_MLX_Float16 lhs, _MLX_Float16 rhs) { _MLX_Float16 out; out.bits_ = lhs.bits_ & rhs.bits_; return out; } inline _MLX_Float16 operator&(_MLX_Float16 lhs, uint16_t rhs) { _MLX_Float16 out; out.bits_ = lhs.bits_ & rhs; return out; } inline _MLX_Float16 operator&(uint16_t lhs, _MLX_Float16 rhs) { _MLX_Float16 out; out.bits_ = lhs & rhs.bits_; return out; };
+inline _MLX_Float16 operator^(_MLX_Float16 lhs, _MLX_Float16 rhs) { _MLX_Float16 out; out.bits_ = lhs.bits_ ^ rhs.bits_; return out; } inline _MLX_Float16 operator^(_MLX_Float16 lhs, uint16_t rhs) { _MLX_Float16 out; out.bits_ = lhs.bits_ ^ rhs; return out; } inline _MLX_Float16 operator^(uint16_t lhs, _MLX_Float16 rhs) { _MLX_Float16 out; out.bits_ = lhs ^ rhs.bits_; return out; };
+inline _MLX_Float16& operator|=(_MLX_Float16& lhs, _MLX_Float16 rhs) { lhs.bits_ = lhs.bits_ | rhs.bits_; return lhs; } inline _MLX_Float16& operator|=(_MLX_Float16& lhs, uint16_t rhs) { lhs.bits_ = lhs.bits_ | rhs; return lhs; };
+inline _MLX_Float16& operator&=(_MLX_Float16& lhs, _MLX_Float16 rhs) { lhs.bits_ = lhs.bits_ & rhs.bits_; return lhs; } inline _MLX_Float16& operator&=(_MLX_Float16& lhs, uint16_t rhs) { lhs.bits_ = lhs.bits_ & rhs; return lhs; };
+inline _MLX_Float16& operator^=(_MLX_Float16& lhs, _MLX_Float16 rhs) { lhs.bits_ = lhs.bits_ ^ rhs.bits_; return lhs; } inline _MLX_Float16& operator^=(_MLX_Float16& lhs, uint16_t rhs) { lhs.bits_ = lhs.bits_ ^ rhs; return lhs; };
+}
+namespace mlx::core {
+typedef struct _MLX_Float16 float16_t;
+}
+       
+       
+namespace mlx::core {
+namespace {
+union float_bits_bf16 {
+  float f;
+  uint32_t u;
+};
+}
+struct _MLX_BFloat16 {
+  uint16_t bits_;
+  _MLX_BFloat16() = default;
+  _MLX_BFloat16(_MLX_BFloat16 const&) = default;
+  _MLX_BFloat16& operator=(std::vector<bool>::reference x) {
+    bits_ = x;
+    return *this;
+  }
+  _MLX_BFloat16& operator=(const float& x) {
+    return (*this = _MLX_BFloat16(x));
+  }
+  _MLX_BFloat16(const float& x) {
+    if (std::isnan(x)) {
+      bits_ = 0x7FC0;
+    } else {
+      float_bits_bf16 in;
+      in.f = x;
+      in.u += (in.u >> 16 & 1) + uint32_t(0x7FFF);
+      bits_ = in.u >> 16;
+    }
+  }
+  operator float() const {
+    float_bits_bf16 out;
+    out.u = ((uint32_t)bits_) << 16;
+    return out.f;
+  }
+};
+inline _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline float operator+(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline float operator+(float lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline double operator+(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) + static_cast<double>(rhs); } inline double operator+(double lhs, _MLX_BFloat16 rhs) { return static_cast<double>(lhs) + static_cast<double>(rhs); }; inline _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, bool rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_BFloat16 operator+(bool lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_BFloat16 operator+(int32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, uint32_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_BFloat16 operator+(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, int64_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_BFloat16 operator+(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }; inline _MLX_BFloat16 operator+(_MLX_BFloat16 lhs, uint64_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline _MLX_BFloat16 operator+(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); };;
+inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline float operator-(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline float operator-(float lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline double operator-(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) - static_cast<double>(rhs); } inline double operator-(double lhs, _MLX_BFloat16 rhs) { return static_cast<double>(lhs) - static_cast<double>(rhs); }; inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, bool rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_BFloat16 operator-(bool lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_BFloat16 operator-(int32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, uint32_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_BFloat16 operator-(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, int64_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_BFloat16 operator-(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }; inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs, uint64_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline _MLX_BFloat16 operator-(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); };;
+inline _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline float operator*(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline float operator*(float lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline double operator*(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) * static_cast<double>(rhs); } inline double operator*(double lhs, _MLX_BFloat16 rhs) { return static_cast<double>(lhs) * static_cast<double>(rhs); }; inline _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, bool rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_BFloat16 operator*(bool lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_BFloat16 operator*(int32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, uint32_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_BFloat16 operator*(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, int64_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_BFloat16 operator*(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }; inline _MLX_BFloat16 operator*(_MLX_BFloat16 lhs, uint64_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline _MLX_BFloat16 operator*(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); };;
+inline _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline float operator/(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline float operator/(float lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline double operator/(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) / static_cast<double>(rhs); } inline double operator/(double lhs, _MLX_BFloat16 rhs) { return static_cast<double>(lhs) / static_cast<double>(rhs); }; inline _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, bool rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_BFloat16 operator/(bool lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_BFloat16 operator/(int32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, uint32_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_BFloat16 operator/(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, int64_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_BFloat16 operator/(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }; inline _MLX_BFloat16 operator/(_MLX_BFloat16 lhs, uint64_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline _MLX_BFloat16 operator/(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); };;
+inline bool operator>(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); }; inline bool operator>(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); } inline bool operator>(float lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); }; inline bool operator>(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) > static_cast<double>(rhs); } inline bool operator>(double lhs, _MLX_BFloat16 rhs) { return static_cast<double>(lhs) > static_cast<double>(rhs); }; inline bool operator>(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); } inline bool operator>(int32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); }; inline bool operator>(_MLX_BFloat16 lhs, uint32_t rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); } inline bool operator>(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); }; inline bool operator>(_MLX_BFloat16 lhs, int64_t rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); } inline bool operator>(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); }; inline bool operator>(_MLX_BFloat16 lhs, uint64_t rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); } inline bool operator>(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) > static_cast<float>(rhs); };;
+inline bool operator<(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); }; inline bool operator<(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); } inline bool operator<(float lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); }; inline bool operator<(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) < static_cast<double>(rhs); } inline bool operator<(double lhs, _MLX_BFloat16 rhs) { return static_cast<double>(lhs) < static_cast<double>(rhs); }; inline bool operator<(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); } inline bool operator<(int32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); }; inline bool operator<(_MLX_BFloat16 lhs, uint32_t rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); } inline bool operator<(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); }; inline bool operator<(_MLX_BFloat16 lhs, int64_t rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); } inline bool operator<(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); }; inline bool operator<(_MLX_BFloat16 lhs, uint64_t rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); } inline bool operator<(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) < static_cast<float>(rhs); };;
+inline bool operator>=(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); }; inline bool operator>=(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); } inline bool operator>=(float lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); }; inline bool operator>=(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) >= static_cast<double>(rhs); } inline bool operator>=(double lhs, _MLX_BFloat16 rhs) { return static_cast<double>(lhs) >= static_cast<double>(rhs); }; inline bool operator>=(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); } inline bool operator>=(int32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); }; inline bool operator>=(_MLX_BFloat16 lhs, uint32_t rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); } inline bool operator>=(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); }; inline bool operator>=(_MLX_BFloat16 lhs, int64_t rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); } inline bool operator>=(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); }; inline bool operator>=(_MLX_BFloat16 lhs, uint64_t rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); } inline bool operator>=(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) >= static_cast<float>(rhs); };;
+inline bool operator<=(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); }; inline bool operator<=(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); } inline bool operator<=(float lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); }; inline bool operator<=(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) <= static_cast<double>(rhs); } inline bool operator<=(double lhs, _MLX_BFloat16 rhs) { return static_cast<double>(lhs) <= static_cast<double>(rhs); }; inline bool operator<=(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); } inline bool operator<=(int32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); }; inline bool operator<=(_MLX_BFloat16 lhs, uint32_t rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); } inline bool operator<=(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); }; inline bool operator<=(_MLX_BFloat16 lhs, int64_t rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); } inline bool operator<=(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); }; inline bool operator<=(_MLX_BFloat16 lhs, uint64_t rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); } inline bool operator<=(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) <= static_cast<float>(rhs); };;
+inline bool operator==(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); }; inline bool operator==(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); } inline bool operator==(float lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); }; inline bool operator==(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) == static_cast<double>(rhs); } inline bool operator==(double lhs, _MLX_BFloat16 rhs) { return static_cast<double>(lhs) == static_cast<double>(rhs); }; inline bool operator==(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); } inline bool operator==(int32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); }; inline bool operator==(_MLX_BFloat16 lhs, uint32_t rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); } inline bool operator==(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); }; inline bool operator==(_MLX_BFloat16 lhs, int64_t rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); } inline bool operator==(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); }; inline bool operator==(_MLX_BFloat16 lhs, uint64_t rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); } inline bool operator==(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) == static_cast<float>(rhs); };;
+inline bool operator!=(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); }; inline bool operator!=(_MLX_BFloat16 lhs, float rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); } inline bool operator!=(float lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); }; inline bool operator!=(_MLX_BFloat16 lhs, double rhs) { return static_cast<double>(lhs) != static_cast<double>(rhs); } inline bool operator!=(double lhs, _MLX_BFloat16 rhs) { return static_cast<double>(lhs) != static_cast<double>(rhs); }; inline bool operator!=(_MLX_BFloat16 lhs, int32_t rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); } inline bool operator!=(int32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); }; inline bool operator!=(_MLX_BFloat16 lhs, uint32_t rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); } inline bool operator!=(uint32_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); }; inline bool operator!=(_MLX_BFloat16 lhs, int64_t rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); } inline bool operator!=(int64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); }; inline bool operator!=(_MLX_BFloat16 lhs, uint64_t rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); } inline bool operator!=(uint64_t lhs, _MLX_BFloat16 rhs) { return static_cast<float>(lhs) != static_cast<float>(rhs); };;
+inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs) {
+  return -static_cast<float>(lhs);
+}
+inline _MLX_BFloat16& operator+=(_MLX_BFloat16& lhs, const float& rhs) { lhs = lhs + rhs; return lhs; } inline float& operator+=(float& lhs, _MLX_BFloat16 rhs) { lhs = lhs + rhs; return lhs; };
+inline _MLX_BFloat16& operator-=(_MLX_BFloat16& lhs, const float& rhs) { lhs = lhs - rhs; return lhs; } inline float& operator-=(float& lhs, _MLX_BFloat16 rhs) { lhs = lhs - rhs; return lhs; };
+inline _MLX_BFloat16& operator*=(_MLX_BFloat16& lhs, const float& rhs) { lhs = lhs * rhs; return lhs; } inline float& operator*=(float& lhs, _MLX_BFloat16 rhs) { lhs = lhs * rhs; return lhs; };
+inline _MLX_BFloat16& operator/=(_MLX_BFloat16& lhs, const float& rhs) { lhs = lhs / rhs; return lhs; } inline float& operator/=(float& lhs, _MLX_BFloat16 rhs) { lhs = lhs / rhs; return lhs; };
+inline _MLX_BFloat16 operator|(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { _MLX_BFloat16 out; out.bits_ = lhs.bits_ | rhs.bits_; return out; } inline _MLX_BFloat16 operator|(_MLX_BFloat16 lhs, uint16_t rhs) { _MLX_BFloat16 out; out.bits_ = lhs.bits_ | rhs; return out; } inline _MLX_BFloat16 operator|(uint16_t lhs, _MLX_BFloat16 rhs) { _MLX_BFloat16 out; out.bits_ = lhs | rhs.bits_; return out; };
+inline _MLX_BFloat16 operator&(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { _MLX_BFloat16 out; out.bits_ = lhs.bits_ & rhs.bits_; return out; } inline _MLX_BFloat16 operator&(_MLX_BFloat16 lhs, uint16_t rhs) { _MLX_BFloat16 out; out.bits_ = lhs.bits_ & rhs; return out; } inline _MLX_BFloat16 operator&(uint16_t lhs, _MLX_BFloat16 rhs) { _MLX_BFloat16 out; out.bits_ = lhs & rhs.bits_; return out; };
+inline _MLX_BFloat16 operator^(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { _MLX_BFloat16 out; out.bits_ = lhs.bits_ ^ rhs.bits_; return out; } inline _MLX_BFloat16 operator^(_MLX_BFloat16 lhs, uint16_t rhs) { _MLX_BFloat16 out; out.bits_ = lhs.bits_ ^ rhs; return out; } inline _MLX_BFloat16 operator^(uint16_t lhs, _MLX_BFloat16 rhs) { _MLX_BFloat16 out; out.bits_ = lhs ^ rhs.bits_; return out; };
+inline _MLX_BFloat16& operator|=(_MLX_BFloat16& lhs, _MLX_BFloat16 rhs) { lhs.bits_ = lhs.bits_ | rhs.bits_; return lhs; } inline _MLX_BFloat16& operator|=(_MLX_BFloat16& lhs, uint16_t rhs) { lhs.bits_ = lhs.bits_ | rhs; return lhs; };
+inline _MLX_BFloat16& operator&=(_MLX_BFloat16& lhs, _MLX_BFloat16 rhs) { lhs.bits_ = lhs.bits_ & rhs.bits_; return lhs; } inline _MLX_BFloat16& operator&=(_MLX_BFloat16& lhs, uint16_t rhs) { lhs.bits_ = lhs.bits_ & rhs; return lhs; };
+inline _MLX_BFloat16& operator^=(_MLX_BFloat16& lhs, _MLX_BFloat16 rhs) { lhs.bits_ = lhs.bits_ ^ rhs.bits_; return lhs; } inline _MLX_BFloat16& operator^=(_MLX_BFloat16& lhs, uint16_t rhs) { lhs.bits_ = lhs.bits_ ^ rhs; return lhs; };
+}
+namespace mlx::core {
+typedef struct _MLX_BFloat16 bfloat16_t;
+}
+namespace mlx::core {
+inline float operator+(float16_t lhs, bfloat16_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); } inline float operator+(bfloat16_t lhs, float16_t rhs) { return static_cast<float>(lhs) + static_cast<float>(rhs); }
+inline float operator-(float16_t lhs, bfloat16_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); } inline float operator-(bfloat16_t lhs, float16_t rhs) { return static_cast<float>(lhs) - static_cast<float>(rhs); }
+inline float operator*(float16_t lhs, bfloat16_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); } inline float operator*(bfloat16_t lhs, float16_t rhs) { return static_cast<float>(lhs) * static_cast<float>(rhs); }
+inline float operator/(float16_t lhs, bfloat16_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); } inline float operator/(bfloat16_t lhs, float16_t rhs) { return static_cast<float>(lhs) / static_cast<float>(rhs); }
+}
+       
+       
+       
+       
+       
+       
+       
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<class _CharT>
+    struct char_traits;
+  template<> struct char_traits<char>;
+  template<> struct char_traits<wchar_t>;
+  template<> struct char_traits<char16_t>;
+  template<> struct char_traits<char32_t>;
+namespace __cxx11 {
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+           typename _Alloc = allocator<_CharT> >
+    class basic_string;
+  typedef basic_string<char> string;
+  typedef basic_string<wchar_t> wstring;
+  typedef basic_string<char16_t> u16string;
+  typedef basic_string<char32_t> u32string;
+}
+
+}
+       
+       
+typedef __builtin_va_list __gnuc_va_list;
+typedef unsigned int wint_t;
+typedef struct
+{
+  int __count;
+  union
+  {
+    unsigned int __wch;
+    char __wchb[4];
+  } __value;
+} __mbstate_t;
+typedef __mbstate_t mbstate_t;
+struct _IO_FILE;
+typedef struct _IO_FILE __FILE;
+struct _IO_FILE;
+typedef struct _IO_FILE FILE;
+extern "C" {
+struct tm;
+extern wchar_t *wcscpy (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern wchar_t *wcscat (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern wchar_t *wcsncat (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
+extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
+   size_t __n) throw ();
+extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
+    locale_t __loc) throw ();
+extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
+     size_t __n, locale_t __loc) throw ();
+extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
+extern size_t wcsxfrm (wchar_t *__restrict __s1,
+         const wchar_t *__restrict __s2, size_t __n) throw ();
+extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
+        locale_t __loc) throw ();
+extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
+    size_t __n, locale_t __loc) throw ();
+extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
+extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcschr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcschr") __attribute__ ((__pure__));
+extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
+extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
+     throw () __attribute__ ((__pure__));
+extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
+     throw () __attribute__ ((__pure__));
+extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
+     throw () __attribute__ ((__pure__));
+extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
+     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
+         const wchar_t *__accept)
+     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
+extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
+     throw () __asm ("wcsstr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
+        const wchar_t *__needle)
+     throw () __asm ("wcsstr") __attribute__ ((__pure__));
+extern wchar_t *wcstok (wchar_t *__restrict __s,
+   const wchar_t *__restrict __delim,
+   wchar_t **__restrict __ptr) throw ();
+extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
+extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
+     throw () __asm ("wcswcs") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
+        const wchar_t *__needle)
+     throw () __asm ("wcswcs") __attribute__ ((__pure__));
+extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
+     throw () __attribute__ ((__pure__));
+extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
+     throw () __asm ("wmemchr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
+         size_t __n)
+     throw () __asm ("wmemchr") __attribute__ ((__pure__));
+extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     throw () __attribute__ ((__pure__));
+extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
+    const wchar_t *__restrict __s2, size_t __n) throw ();
+extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     throw ();
+extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
+extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
+     const wchar_t *__restrict __s2, size_t __n)
+     throw ();
+extern wint_t btowc (int __c) throw ();
+extern int wctob (wint_t __c) throw ();
+extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
+extern size_t mbrtowc (wchar_t *__restrict __pwc,
+         const char *__restrict __s, size_t __n,
+         mbstate_t *__restrict __p) throw ();
+extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
+         mbstate_t *__restrict __ps) throw ();
+extern size_t __mbrlen (const char *__restrict __s, size_t __n,
+   mbstate_t *__restrict __ps) throw ();
+extern size_t mbrlen (const char *__restrict __s, size_t __n,
+        mbstate_t *__restrict __ps) throw ();
+extern size_t mbsrtowcs (wchar_t *__restrict __dst,
+    const char **__restrict __src, size_t __len,
+    mbstate_t *__restrict __ps) throw ();
+extern size_t wcsrtombs (char *__restrict __dst,
+    const wchar_t **__restrict __src, size_t __len,
+    mbstate_t *__restrict __ps) throw ();
+extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
+     const char **__restrict __src, size_t __nmc,
+     size_t __len, mbstate_t *__restrict __ps) throw ();
+extern size_t wcsnrtombs (char *__restrict __dst,
+     const wchar_t **__restrict __src,
+     size_t __nwc, size_t __len,
+     mbstate_t *__restrict __ps) throw ();
+extern int wcwidth (wchar_t __c) throw ();
+extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
+extern double wcstod (const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr) throw ();
+extern float wcstof (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+extern long double wcstold (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+extern _Float32 wcstof32 (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr) throw ();
+extern _Float64 wcstof64 (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr) throw ();
+extern _Float128 wcstof128 (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+extern _Float32x wcstof32x (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+extern _Float64x wcstof64x (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+extern long int wcstol (const wchar_t *__restrict __nptr,
+   wchar_t **__restrict __endptr, int __base) throw ();
+extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
+      wchar_t **__restrict __endptr, int __base)
+     throw ();
+__extension__
+extern long long int wcstoll (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr, int __base)
+     throw ();
+__extension__
+extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr,
+     int __base) throw ();
+__extension__
+extern long long int wcstoq (const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr, int __base)
+     throw ();
+__extension__
+extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
+           wchar_t **__restrict __endptr,
+           int __base) throw ();
+extern long int wcstol_l (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr, int __base,
+     locale_t __loc) throw ();
+extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr,
+        int __base, locale_t __loc) throw ();
+__extension__
+extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
+    wchar_t **__restrict __endptr,
+    int __base, locale_t __loc) throw ();
+__extension__
+extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr,
+       int __base, locale_t __loc)
+     throw ();
+extern double wcstod_l (const wchar_t *__restrict __nptr,
+   wchar_t **__restrict __endptr, locale_t __loc)
+     throw ();
+extern float wcstof_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr, locale_t __loc)
+     throw ();
+extern long double wcstold_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         locale_t __loc) throw ();
+extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr,
+       locale_t __loc) throw ();
+extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr,
+       locale_t __loc) throw ();
+extern _Float128 wcstof128_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         locale_t __loc) throw ();
+extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         locale_t __loc) throw ();
+extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         locale_t __loc) throw ();
+extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src) throw ();
+extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     throw ();
+extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
+extern int fwide (__FILE *__fp, int __mode) throw ();
+extern int fwprintf (__FILE *__restrict __stream,
+       const wchar_t *__restrict __format, ...)
+                                                           ;
+extern int wprintf (const wchar_t *__restrict __format, ...)
+                                                           ;
+extern int swprintf (wchar_t *__restrict __s, size_t __n,
+       const wchar_t *__restrict __format, ...)
+     throw () ;
+extern int vfwprintf (__FILE *__restrict __s,
+        const wchar_t *__restrict __format,
+        __gnuc_va_list __arg)
+                                                           ;
+extern int vwprintf (const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+                                                           ;
+extern int vswprintf (wchar_t *__restrict __s, size_t __n,
+        const wchar_t *__restrict __format,
+        __gnuc_va_list __arg)
+     throw () ;
+extern int fwscanf (__FILE *__restrict __stream,
+      const wchar_t *__restrict __format, ...)
+                                                          ;
+extern int wscanf (const wchar_t *__restrict __format, ...)
+                                                          ;
+extern int swscanf (const wchar_t *__restrict __s,
+      const wchar_t *__restrict __format, ...)
+     throw () ;
+extern int vfwscanf (__FILE *__restrict __s,
+       const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+                                                          ;
+extern int vwscanf (const wchar_t *__restrict __format,
+      __gnuc_va_list __arg)
+                                                          ;
+extern int vswscanf (const wchar_t *__restrict __s,
+       const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+     throw () ;
+extern wint_t fgetwc (__FILE *__stream);
+extern wint_t getwc (__FILE *__stream);
+extern wint_t getwchar (void);
+extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
+extern wint_t putwc (wchar_t __wc, __FILE *__stream);
+extern wint_t putwchar (wchar_t __wc);
+extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
+   __FILE *__restrict __stream);
+extern int fputws (const wchar_t *__restrict __ws,
+     __FILE *__restrict __stream);
+extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
+extern wint_t getwc_unlocked (__FILE *__stream);
+extern wint_t getwchar_unlocked (void);
+extern wint_t fgetwc_unlocked (__FILE *__stream);
+extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
+extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
+extern wint_t putwchar_unlocked (wchar_t __wc);
+extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
+     __FILE *__restrict __stream);
+extern int fputws_unlocked (const wchar_t *__restrict __ws,
+       __FILE *__restrict __stream);
+extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
+   const wchar_t *__restrict __format,
+   const struct tm *__restrict __tp) throw ();
+extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
+     const wchar_t *__restrict __format,
+     const struct tm *__restrict __tp,
+     locale_t __loc) throw ();
+}
+namespace std
+{
+  using ::mbstate_t;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  using ::wint_t;
+  using ::btowc;
+  using ::fgetwc;
+  using ::fgetws;
+  using ::fputwc;
+  using ::fputws;
+  using ::fwide;
+  using ::fwprintf;
+  using ::fwscanf;
+  using ::getwc;
+  using ::getwchar;
+  using ::mbrlen;
+  using ::mbrtowc;
+  using ::mbsinit;
+  using ::mbsrtowcs;
+  using ::putwc;
+  using ::putwchar;
+  using ::swprintf;
+  using ::swscanf;
+  using ::ungetwc;
+  using ::vfwprintf;
+  using ::vfwscanf;
+  using ::vswprintf;
+  using ::vswscanf;
+  using ::vwprintf;
+  using ::vwscanf;
+  using ::wcrtomb;
+  using ::wcscat;
+  using ::wcscmp;
+  using ::wcscoll;
+  using ::wcscpy;
+  using ::wcscspn;
+  using ::wcsftime;
+  using ::wcslen;
+  using ::wcsncat;
+  using ::wcsncmp;
+  using ::wcsncpy;
+  using ::wcsrtombs;
+  using ::wcsspn;
+  using ::wcstod;
+  using ::wcstof;
+  using ::wcstok;
+  using ::wcstol;
+  using ::wcstoul;
+  using ::wcsxfrm;
+  using ::wctob;
+  using ::wmemcmp;
+  using ::wmemcpy;
+  using ::wmemmove;
+  using ::wmemset;
+  using ::wprintf;
+  using ::wscanf;
+  using ::wcschr;
+  using ::wcspbrk;
+  using ::wcsrchr;
+  using ::wcsstr;
+  using ::wmemchr;
+
+}
+namespace __gnu_cxx
+{
+  using ::wcstold;
+  using ::wcstoll;
+  using ::wcstoull;
+}
+namespace std
+{
+  using ::__gnu_cxx::wcstold;
+  using ::__gnu_cxx::wcstoll;
+  using ::__gnu_cxx::wcstoull;
+}
+namespace std
+{
+  using std::wcstof;
+  using std::vfwscanf;
+  using std::vswscanf;
+  using std::vwscanf;
+  using std::wcstold;
+  using std::wcstoll;
+  using std::wcstoull;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  typedef long streamoff;
+  typedef ptrdiff_t streamsize;
+  template<typename _StateT>
+    class fpos
+    {
+    private:
+      streamoff _M_off;
+      _StateT _M_state;
+    public:
+      fpos()
+      : _M_off(0), _M_state() { }
+      fpos(streamoff __off)
+      : _M_off(__off), _M_state() { }
+      operator streamoff() const { return _M_off; }
+      void
+      state(_StateT __st)
+      { _M_state = __st; }
+      _StateT
+      state() const
+      { return _M_state; }
+      fpos&
+      operator+=(streamoff __off)
+      {
+ _M_off += __off;
+ return *this;
+      }
+      fpos&
+      operator-=(streamoff __off)
+      {
+ _M_off -= __off;
+ return *this;
+      }
+      fpos
+      operator+(streamoff __off) const
+      {
+ fpos __pos(*this);
+ __pos += __off;
+ return __pos;
+      }
+      fpos
+      operator-(streamoff __off) const
+      {
+ fpos __pos(*this);
+ __pos -= __off;
+ return __pos;
+      }
+      streamoff
+      operator-(const fpos& __other) const
+      { return _M_off - __other._M_off; }
+    };
+  template<typename _StateT>
+    inline bool
+    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
+    { return streamoff(__lhs) == streamoff(__rhs); }
+  template<typename _StateT>
+    inline bool
+    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
+    { return streamoff(__lhs) != streamoff(__rhs); }
+  typedef fpos<mbstate_t> streampos;
+  typedef fpos<mbstate_t> wstreampos;
+  typedef fpos<mbstate_t> u16streampos;
+  typedef fpos<mbstate_t> u32streampos;
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  class ios_base;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ios;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_streambuf;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_istream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ostream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_iostream;
+namespace __cxx11 {
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+     typename _Alloc = allocator<_CharT> >
+    class basic_stringbuf;
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_istringstream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_ostringstream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_stringstream;
+}
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_filebuf;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ifstream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ofstream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_fstream;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class istreambuf_iterator;
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class ostreambuf_iterator;
+  typedef basic_ios<char> ios;
+  typedef basic_streambuf<char> streambuf;
+  typedef basic_istream<char> istream;
+  typedef basic_ostream<char> ostream;
+  typedef basic_iostream<char> iostream;
+  typedef basic_stringbuf<char> stringbuf;
+  typedef basic_istringstream<char> istringstream;
+  typedef basic_ostringstream<char> ostringstream;
+  typedef basic_stringstream<char> stringstream;
+  typedef basic_filebuf<char> filebuf;
+  typedef basic_ifstream<char> ifstream;
+  typedef basic_ofstream<char> ofstream;
+  typedef basic_fstream<char> fstream;
+  typedef basic_ios<wchar_t> wios;
+  typedef basic_streambuf<wchar_t> wstreambuf;
+  typedef basic_istream<wchar_t> wistream;
+  typedef basic_ostream<wchar_t> wostream;
+  typedef basic_iostream<wchar_t> wiostream;
+  typedef basic_stringbuf<wchar_t> wstringbuf;
+  typedef basic_istringstream<wchar_t> wistringstream;
+  typedef basic_ostringstream<wchar_t> wostringstream;
+  typedef basic_stringstream<wchar_t> wstringstream;
+  typedef basic_filebuf<wchar_t> wfilebuf;
+  typedef basic_ifstream<wchar_t> wifstream;
+  typedef basic_ofstream<wchar_t> wofstream;
+  typedef basic_fstream<wchar_t> wfstream;
+
+}
+       
+       
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT>
+    struct _Char_types
+    {
+      typedef unsigned long int_type;
+      typedef std::streampos pos_type;
+      typedef std::streamoff off_type;
+      typedef std::mbstate_t state_type;
+    };
+  template<typename _CharT>
+    struct char_traits
+    {
+      typedef _CharT char_type;
+      typedef typename _Char_types<_CharT>::int_type int_type;
+      typedef typename _Char_types<_CharT>::pos_type pos_type;
+      typedef typename _Char_types<_CharT>::off_type off_type;
+      typedef typename _Char_types<_CharT>::state_type state_type;
+      static constexpr void
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+      static constexpr int
+      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
+      static constexpr std::size_t
+      length(const char_type* __s);
+      static constexpr const char_type*
+      find(const char_type* __s, std::size_t __n, const char_type& __a);
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, std::size_t __n);
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, std::size_t __n);
+      static char_type*
+      assign(char_type* __s, std::size_t __n, char_type __a);
+      static constexpr char_type
+      to_char_type(const int_type& __c)
+      { return static_cast<char_type>(__c); }
+      static constexpr int_type
+      to_int_type(const char_type& __c)
+      { return static_cast<int_type>(__c); }
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+      static constexpr int_type
+      eof()
+      { return static_cast<int_type>(-1); }
+      static constexpr int_type
+      not_eof(const int_type& __c)
+      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
+    };
+  template<typename _CharT>
+    constexpr int
+    char_traits<_CharT>::
+    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      for (std::size_t __i = 0; __i < __n; ++__i)
+ if (lt(__s1[__i], __s2[__i]))
+   return -1;
+ else if (lt(__s2[__i], __s1[__i]))
+   return 1;
+      return 0;
+    }
+  template<typename _CharT>
+    constexpr std::size_t
+    char_traits<_CharT>::
+    length(const char_type* __p)
+    {
+      std::size_t __i = 0;
+      while (!eq(__p[__i], char_type()))
+        ++__i;
+      return __i;
+    }
+  template<typename _CharT>
+    constexpr const typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    find(const char_type* __s, std::size_t __n, const char_type& __a)
+    {
+      for (std::size_t __i = 0; __i < __n; ++__i)
+        if (eq(__s[__i], __a))
+          return __s + __i;
+      return 0;
+    }
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    move(char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      if (__n == 0)
+ return __s1;
+      return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
+          __n * sizeof(char_type)));
+    }
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      std::copy(__s2, __s2 + __n, __s1);
+      return __s1;
+    }
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    assign(char_type* __s, std::size_t __n, char_type __a)
+    {
+      std::fill_n(__s, __n, __a);
+      return __s;
+    }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT>
+    static inline __attribute__((__always_inline__)) constexpr bool
+    __constant_string_p(const _CharT* __s)
+    {
+      while (__builtin_constant_p(*__s) && *__s)
+ __s++;
+      return __builtin_constant_p(*__s);
+    }
+  template<typename _CharT>
+    static inline __attribute__((__always_inline__)) constexpr bool
+    __constant_char_array_p(const _CharT* __a, size_t __n)
+    {
+      size_t __i = 0;
+      while (__i < __n && __builtin_constant_p(__a[__i]))
+ __i++;
+      return __i == __n;
+    }
+  template<class _CharT>
+    struct char_traits : public __gnu_cxx::char_traits<_CharT>
+    { };
+  template<>
+    struct char_traits<char>
+    {
+      typedef char char_type;
+      typedef int int_type;
+      typedef streampos pos_type;
+      typedef streamoff off_type;
+      typedef mbstate_t state_type;
+      static constexpr void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      {
+ return (static_cast<unsigned char>(__c1)
+  < static_cast<unsigned char>(__c2));
+      }
+      static constexpr int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__builtin_constant_p(__n)
+     && __constant_char_array_p(__s1, __n)
+     && __constant_char_array_p(__s2, __n))
+   {
+     for (size_t __i = 0; __i < __n; ++__i)
+       if (lt(__s1[__i], __s2[__i]))
+  return -1;
+       else if (lt(__s2[__i], __s1[__i]))
+  return 1;
+     return 0;
+   }
+ if (__n == 0)
+   return 0;
+ return __builtin_memcmp(__s1, __s2, __n);
+      }
+      static constexpr size_t
+      length(const char_type* __s)
+      {
+ if (__constant_string_p(__s))
+   return __gnu_cxx::char_traits<char_type>::length(__s);
+ return __builtin_strlen(__s);
+      }
+      static constexpr const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ if (__builtin_constant_p(__n)
+     && __builtin_constant_p(__a)
+     && __constant_char_array_p(__s, __n))
+   return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);
+ if (__n == 0)
+   return 0;
+ return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
+      }
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
+      }
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
+      }
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ if (__n == 0)
+   return __s;
+ return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
+      }
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return static_cast<char_type>(__c); }
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>(-1); }
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return (__c == eof()) ? 0 : __c; }
+  };
+  template<>
+    struct char_traits<wchar_t>
+    {
+      typedef wchar_t char_type;
+      typedef wint_t int_type;
+      typedef streamoff off_type;
+      typedef wstreampos pos_type;
+      typedef mbstate_t state_type;
+      static constexpr void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 < __c2; }
+      static constexpr int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__builtin_constant_p(__n)
+     && __constant_char_array_p(__s1, __n)
+     && __constant_char_array_p(__s2, __n))
+   return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);
+ if (__n == 0)
+   return 0;
+ else
+   return wmemcmp(__s1, __s2, __n);
+      }
+      static constexpr size_t
+      length(const char_type* __s)
+      {
+ if (__constant_string_p(__s))
+   return __gnu_cxx::char_traits<char_type>::length(__s);
+ else
+   return wcslen(__s);
+      }
+      static constexpr const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ if (__builtin_constant_p(__n)
+     && __builtin_constant_p(__a)
+     && __constant_char_array_p(__s, __n))
+   return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);
+ if (__n == 0)
+   return 0;
+ else
+   return wmemchr(__s, __a, __n);
+      }
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return wmemmove(__s1, __s2, __n);
+      }
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return wmemcpy(__s1, __s2, __n);
+      }
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ if (__n == 0)
+   return __s;
+ return wmemset(__s, __a, __n);
+      }
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return char_type(__c); }
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return int_type(__c); }
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>((0xffffffffu)); }
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+  };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<>
+    struct char_traits<char16_t>
+    {
+      typedef char16_t char_type;
+      typedef uint_least16_t int_type;
+      typedef streamoff off_type;
+      typedef u16streampos pos_type;
+      typedef mbstate_t state_type;
+      static constexpr void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 < __c2; }
+      static constexpr int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   if (lt(__s1[__i], __s2[__i]))
+     return -1;
+   else if (lt(__s2[__i], __s1[__i]))
+     return 1;
+ return 0;
+      }
+      static constexpr size_t
+      length(const char_type* __s)
+      {
+ size_t __i = 0;
+ while (!eq(__s[__i], char_type()))
+   ++__i;
+ return __i;
+      }
+      static constexpr const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   if (eq(__s[__i], __a))
+     return __s + __i;
+ return 0;
+      }
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return (static_cast<char_type*>
+  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
+      }
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return (static_cast<char_type*>
+  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
+      }
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   assign(__s[__i], __a);
+ return __s;
+      }
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return char_type(__c); }
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return __c == eof() ? int_type(0xfffd) : int_type(__c); }
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>(-1); }
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+    };
+  template<>
+    struct char_traits<char32_t>
+    {
+      typedef char32_t char_type;
+      typedef uint_least32_t int_type;
+      typedef streamoff off_type;
+      typedef u32streampos pos_type;
+      typedef mbstate_t state_type;
+      static constexpr void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 < __c2; }
+      static constexpr int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   if (lt(__s1[__i], __s2[__i]))
+     return -1;
+   else if (lt(__s2[__i], __s1[__i]))
+     return 1;
+ return 0;
+      }
+      static constexpr size_t
+      length(const char_type* __s)
+      {
+ size_t __i = 0;
+ while (!eq(__s[__i], char_type()))
+   ++__i;
+ return __i;
+      }
+      static constexpr const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   if (eq(__s[__i], __a))
+     return __s + __i;
+ return 0;
+      }
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return (static_cast<char_type*>
+  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
+      }
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return (static_cast<char_type*>
+  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
+      }
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ for (size_t __i = 0; __i < __n; ++__i)
+   assign(__s[__i], __a);
+ return __s;
+      }
+      static constexpr char_type
+      to_char_type(const int_type& __c) noexcept
+      { return char_type(__c); }
+      static constexpr int_type
+      to_int_type(const char_type& __c) noexcept
+      { return int_type(__c); }
+      static constexpr bool
+      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
+      { return __c1 == __c2; }
+      static constexpr int_type
+      eof() noexcept
+      { return static_cast<int_type>(-1); }
+      static constexpr int_type
+      not_eof(const int_type& __c) noexcept
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+    };
+
+}
+       
+       
+       
+extern "C" {
+struct lconv
+{
+  char *decimal_point;
+  char *thousands_sep;
+  char *grouping;
+  char *int_curr_symbol;
+  char *currency_symbol;
+  char *mon_decimal_point;
+  char *mon_thousands_sep;
+  char *mon_grouping;
+  char *positive_sign;
+  char *negative_sign;
+  char int_frac_digits;
+  char frac_digits;
+  char p_cs_precedes;
+  char p_sep_by_space;
+  char n_cs_precedes;
+  char n_sep_by_space;
+  char p_sign_posn;
+  char n_sign_posn;
+  char int_p_cs_precedes;
+  char int_p_sep_by_space;
+  char int_n_cs_precedes;
+  char int_n_sep_by_space;
+  char int_p_sign_posn;
+  char int_n_sign_posn;
+};
+extern char *setlocale (int __category, const char *__locale) throw ();
+extern struct lconv *localeconv (void) throw ();
+extern locale_t newlocale (int __category_mask, const char *__locale,
+      locale_t __base) throw ();
+extern locale_t duplocale (locale_t __dataset) throw ();
+extern void freelocale (locale_t __dataset) throw ();
+extern locale_t uselocale (locale_t __dataset) throw ();
+}
+namespace std
+{
+  using ::lconv;
+  using ::setlocale;
+  using ::localeconv;
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+  extern "C" __typeof(uselocale) __uselocale;
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  typedef __locale_t __c_locale;
+  inline int
+  __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
+     char* __out,
+     const int __size __attribute__ ((__unused__)),
+     const char* __fmt, ...)
+  {
+    __c_locale __old = __gnu_cxx::__uselocale(__cloc);
+    __builtin_va_list __args;
+    __builtin_va_start(__args, __fmt);
+    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
+    __builtin_va_end(__args);
+    __gnu_cxx::__uselocale(__old);
+    return __ret;
+  }
+
+}
+       
+extern "C" {
+enum
+{
+  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
+  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
+  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
+  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
+  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
+  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
+  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
+  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
+  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
+  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
+  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
+  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
+};
+extern const unsigned short int **__ctype_b_loc (void)
+     throw () __attribute__ ((__const__));
+extern const __int32_t **__ctype_tolower_loc (void)
+     throw () __attribute__ ((__const__));
+extern const __int32_t **__ctype_toupper_loc (void)
+     throw () __attribute__ ((__const__));
+extern int isalnum (int) throw ();
+extern int isalpha (int) throw ();
+extern int iscntrl (int) throw ();
+extern int isdigit (int) throw ();
+extern int islower (int) throw ();
+extern int isgraph (int) throw ();
+extern int isprint (int) throw ();
+extern int ispunct (int) throw ();
+extern int isspace (int) throw ();
+extern int isupper (int) throw ();
+extern int isxdigit (int) throw ();
+extern int tolower (int __c) throw ();
+extern int toupper (int __c) throw ();
+extern int isblank (int) throw ();
+extern int isctype (int __c, int __mask) throw ();
+extern int isascii (int __c) throw ();
+extern int toascii (int __c) throw ();
+extern int _toupper (int) throw ();
+extern int _tolower (int) throw ();
+extern int isalnum_l (int, locale_t) throw ();
+extern int isalpha_l (int, locale_t) throw ();
+extern int iscntrl_l (int, locale_t) throw ();
+extern int isdigit_l (int, locale_t) throw ();
+extern int islower_l (int, locale_t) throw ();
+extern int isgraph_l (int, locale_t) throw ();
+extern int isprint_l (int, locale_t) throw ();
+extern int ispunct_l (int, locale_t) throw ();
+extern int isspace_l (int, locale_t) throw ();
+extern int isupper_l (int, locale_t) throw ();
+extern int isxdigit_l (int, locale_t) throw ();
+extern int isblank_l (int, locale_t) throw ();
+extern int __tolower_l (int __c, locale_t __l) throw ();
+extern int tolower_l (int __c, locale_t __l) throw ();
+extern int __toupper_l (int __c, locale_t __l) throw ();
+extern int toupper_l (int __c, locale_t __l) throw ();
+}
+namespace std
+{
+  using ::isalnum;
+  using ::isalpha;
+  using ::iscntrl;
+  using ::isdigit;
+  using ::isgraph;
+  using ::islower;
+  using ::isprint;
+  using ::ispunct;
+  using ::isspace;
+  using ::isupper;
+  using ::isxdigit;
+  using ::tolower;
+  using ::toupper;
+}
+namespace std
+{
+  using ::isblank;
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  class locale;
+  template<typename _Facet>
+    bool
+    has_facet(const locale&) throw();
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale&);
+  template<typename _CharT>
+    bool
+    isspace(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isprint(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    iscntrl(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isupper(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    islower(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isalpha(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isdigit(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    ispunct(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isxdigit(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isalnum(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isgraph(_CharT, const locale&);
+  template<typename _CharT>
+    bool
+    isblank(_CharT, const locale&);
+  template<typename _CharT>
+    _CharT
+    toupper(_CharT, const locale&);
+  template<typename _CharT>
+    _CharT
+    tolower(_CharT, const locale&);
+  class ctype_base;
+  template<typename _CharT>
+    class ctype;
+  template<> class ctype<char>;
+  template<> class ctype<wchar_t>;
+  template<typename _CharT>
+    class ctype_byname;
+  class codecvt_base;
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt;
+  template<> class codecvt<char, char, mbstate_t>;
+  template<> class codecvt<wchar_t, char, mbstate_t>;
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt_byname;
+
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class num_get;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class num_put;
+
+namespace __cxx11 {
+  template<typename _CharT> class numpunct;
+  template<typename _CharT> class numpunct_byname;
+}
+namespace __cxx11 {
+  template<typename _CharT>
+    class collate;
+  template<typename _CharT>
+    class collate_byname;
+}
+  class time_base;
+namespace __cxx11 {
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class time_get;
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class time_get_byname;
+}
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put_byname;
+  class money_base;
+namespace __cxx11 {
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class money_get;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class money_put;
+}
+namespace __cxx11 {
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct;
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct_byname;
+}
+  class messages_base;
+namespace __cxx11 {
+  template<typename _CharT>
+    class messages;
+  template<typename _CharT>
+    class messages_byname;
+}
+
+}
+       
+       
+#pragma GCC visibility push(default)
+struct sched_param
+{
+  int sched_priority;
+};
+extern "C" {
+extern int clone (int (*__fn) (void *__arg), void *__child_stack,
+    int __flags, void *__arg, ...) throw ();
+extern int unshare (int __flags) throw ();
+extern int sched_getcpu (void) throw ();
+extern int setns (int __fd, int __nstype) throw ();
+}
+typedef unsigned long int __cpu_mask;
+typedef struct
+{
+  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
+} cpu_set_t;
+extern "C" {
+extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
+     throw ();
+extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
+extern void __sched_cpufree (cpu_set_t *__set) throw ();
+}
+extern "C" {
+extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
+     throw ();
+extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
+extern int sched_setscheduler (__pid_t __pid, int __policy,
+          const struct sched_param *__param) throw ();
+extern int sched_getscheduler (__pid_t __pid) throw ();
+extern int sched_yield (void) throw ();
+extern int sched_get_priority_max (int __algorithm) throw ();
+extern int sched_get_priority_min (int __algorithm) throw ();
+extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
+extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
+         const cpu_set_t *__cpuset) throw ();
+extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
+         cpu_set_t *__cpuset) throw ();
+}
+struct timex
+{
+  unsigned int modes;
+  __syscall_slong_t offset;
+  __syscall_slong_t freq;
+  __syscall_slong_t maxerror;
+  __syscall_slong_t esterror;
+  int status;
+  __syscall_slong_t constant;
+  __syscall_slong_t precision;
+  __syscall_slong_t tolerance;
+  struct timeval time;
+  __syscall_slong_t tick;
+  __syscall_slong_t ppsfreq;
+  __syscall_slong_t jitter;
+  int shift;
+  __syscall_slong_t stabil;
+  __syscall_slong_t jitcnt;
+  __syscall_slong_t calcnt;
+  __syscall_slong_t errcnt;
+  __syscall_slong_t stbcnt;
+  int tai;
+  int :32; int :32; int :32; int :32;
+  int :32; int :32; int :32; int :32;
+  int :32; int :32; int :32;
+};
+extern "C" {
+extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
+}
+struct tm
+{
+  int tm_sec;
+  int tm_min;
+  int tm_hour;
+  int tm_mday;
+  int tm_mon;
+  int tm_year;
+  int tm_wday;
+  int tm_yday;
+  int tm_isdst;
+  long int tm_gmtoff;
+  const char *tm_zone;
+};
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+struct sigevent;
+extern "C" {
+extern clock_t clock (void) throw ();
+extern time_t time (time_t *__timer) throw ();
+extern double difftime (time_t __time1, time_t __time0)
+     throw () __attribute__ ((__const__));
+extern time_t mktime (struct tm *__tp) throw ();
+extern size_t strftime (char *__restrict __s, size_t __maxsize,
+   const char *__restrict __format,
+   const struct tm *__restrict __tp) throw ();
+extern char *strptime (const char *__restrict __s,
+         const char *__restrict __fmt, struct tm *__tp)
+     throw ();
+extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
+     const char *__restrict __format,
+     const struct tm *__restrict __tp,
+     locale_t __loc) throw ();
+extern char *strptime_l (const char *__restrict __s,
+    const char *__restrict __fmt, struct tm *__tp,
+    locale_t __loc) throw ();
+extern struct tm *gmtime (const time_t *__timer) throw ();
+extern struct tm *localtime (const time_t *__timer) throw ();
+extern struct tm *gmtime_r (const time_t *__restrict __timer,
+       struct tm *__restrict __tp) throw ();
+extern struct tm *localtime_r (const time_t *__restrict __timer,
+          struct tm *__restrict __tp) throw ();
+extern char *asctime (const struct tm *__tp) throw ();
+extern char *ctime (const time_t *__timer) throw ();
+extern char *asctime_r (const struct tm *__restrict __tp,
+   char *__restrict __buf) throw ();
+extern char *ctime_r (const time_t *__restrict __timer,
+        char *__restrict __buf) throw ();
+extern char *__tzname[2];
+extern int __daylight;
+extern long int __timezone;
+extern char *tzname[2];
+extern void tzset (void) throw ();
+extern int daylight;
+extern long int timezone;
+extern int stime (const time_t *__when) throw ();
+extern time_t timegm (struct tm *__tp) throw ();
+extern time_t timelocal (struct tm *__tp) throw ();
+extern int dysize (int __year) throw () __attribute__ ((__const__));
+extern int nanosleep (const struct timespec *__requested_time,
+        struct timespec *__remaining);
+extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
+extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
+extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
+     throw ();
+extern int clock_nanosleep (clockid_t __clock_id, int __flags,
+       const struct timespec *__req,
+       struct timespec *__rem);
+extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
+extern int timer_create (clockid_t __clock_id,
+    struct sigevent *__restrict __evp,
+    timer_t *__restrict __timerid) throw ();
+extern int timer_delete (timer_t __timerid) throw ();
+extern int timer_settime (timer_t __timerid, int __flags,
+     const struct itimerspec *__restrict __value,
+     struct itimerspec *__restrict __ovalue) throw ();
+extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
+     throw ();
+extern int timer_getoverrun (timer_t __timerid) throw ();
+extern int timespec_get (struct timespec *__ts, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int getdate_err;
+extern struct tm *getdate (const char *__string);
+extern int getdate_r (const char *__restrict __string,
+        struct tm *__restrict __resbufp);
+}
+typedef long int __jmp_buf[8];
+enum
+{
+  PTHREAD_CREATE_JOINABLE,
+  PTHREAD_CREATE_DETACHED
+};
+enum
+{
+  PTHREAD_MUTEX_TIMED_NP,
+  PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_ADAPTIVE_NP
+  ,
+  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
+  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
+  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
+};
+enum
+{
+  PTHREAD_MUTEX_STALLED,
+  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
+  PTHREAD_MUTEX_ROBUST,
+  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
+};
+enum
+{
+  PTHREAD_PRIO_NONE,
+  PTHREAD_PRIO_INHERIT,
+  PTHREAD_PRIO_PROTECT
+};
+enum
+{
+  PTHREAD_RWLOCK_PREFER_READER_NP,
+  PTHREAD_RWLOCK_PREFER_WRITER_NP,
+  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
+  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
+};
+enum
+{
+  PTHREAD_INHERIT_SCHED,
+  PTHREAD_EXPLICIT_SCHED
+};
+enum
+{
+  PTHREAD_SCOPE_SYSTEM,
+  PTHREAD_SCOPE_PROCESS
+};
+enum
+{
+  PTHREAD_PROCESS_PRIVATE,
+  PTHREAD_PROCESS_SHARED
+};
+struct _pthread_cleanup_buffer
+{
+  void (*__routine) (void *);
+  void *__arg;
+  int __canceltype;
+  struct _pthread_cleanup_buffer *__prev;
+};
+enum
+{
+  PTHREAD_CANCEL_ENABLE,
+  PTHREAD_CANCEL_DISABLE
+};
+enum
+{
+  PTHREAD_CANCEL_DEFERRED,
+  PTHREAD_CANCEL_ASYNCHRONOUS
+};
+extern "C" {
+extern int pthread_create (pthread_t *__restrict __newthread,
+      const pthread_attr_t *__restrict __attr,
+      void *(*__start_routine) (void *),
+      void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
+extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
+extern int pthread_join (pthread_t __th, void **__thread_return);
+extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
+extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
+     const struct timespec *__abstime);
+extern int pthread_detach (pthread_t __th) throw ();
+extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
+extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
+  throw () __attribute__ ((__const__));
+extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_destroy (pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
+     int *__detachstate)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
+     int __detachstate)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
+          size_t *__guardsize)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
+          size_t __guardsize)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
+           struct sched_param *__restrict __param)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
+           const struct sched_param *__restrict
+           __param) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
+     __attr, int *__restrict __policy)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
+      __attr, int *__restrict __inherit)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
+      int __inherit)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
+      int *__restrict __scope)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
+          __attr, void **__restrict __stackaddr)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
+extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
+          void *__stackaddr)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
+extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
+          __attr, size_t *__restrict __stacksize)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
+          size_t __stacksize)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
+      void **__restrict __stackaddr,
+      size_t *__restrict __stacksize)
+     throw () __attribute__ ((__nonnull__ (1, 2, 3)));
+extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
+      size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     const cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern int pthread_getattr_default_np (pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
+      const struct sched_param *__param)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int pthread_getschedparam (pthread_t __target_thread,
+      int *__restrict __policy,
+      struct sched_param *__restrict __param)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
+     throw ();
+extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
+          size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int pthread_getconcurrency (void) throw ();
+extern int pthread_setconcurrency (int __level) throw ();
+extern int pthread_yield (void) throw ();
+extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
+       const cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
+       cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int pthread_once (pthread_once_t *__once_control,
+    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_setcancelstate (int __state, int *__oldstate);
+extern int pthread_setcanceltype (int __type, int *__oldtype);
+extern int pthread_cancel (pthread_t __th);
+extern void pthread_testcancel (void);
+typedef struct
+{
+  struct
+  {
+    __jmp_buf __cancel_jmp_buf;
+    int __mask_was_saved;
+  } __cancel_jmp_buf[1];
+  void *__pad[4];
+} __pthread_unwind_buf_t __attribute__ ((__aligned__));
+struct __pthread_cleanup_frame
+{
+  void (*__cancel_routine) (void *);
+  void *__cancel_arg;
+  int __do_it;
+  int __cancel_type;
+};
+class __pthread_cleanup_class
+{
+  void (*__cancel_routine) (void *);
+  void *__cancel_arg;
+  int __do_it;
+  int __cancel_type;
+ public:
+  __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
+    : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
+  ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
+  void __setdoit (int __newval) { __do_it = __newval; }
+  void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
+        &__cancel_type); }
+  void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
+};
+struct __jmp_buf_tag;
+extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
+extern int pthread_mutex_init (pthread_mutex_t *__mutex,
+          const pthread_mutexattr_t *__mutexattr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
+        const struct timespec *__restrict
+        __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
+      __restrict __mutex,
+      int *__restrict __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
+      int __prioceiling,
+      int *__restrict __old_ceiling)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
+      __restrict __attr,
+      int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
+      int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
+          __attr, int *__restrict __kind)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
+       __restrict __attr,
+       int *__restrict __protocol)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
+       int __protocol)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
+          __restrict __attr,
+          int *__restrict __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
+          int __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
+     int *__robustness)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
+        int *__robustness)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
+     int __robustness)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
+        int __robustness)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
+    const pthread_rwlockattr_t *__restrict
+    __attr) throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
+  throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
+           const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
+           const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
+       int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pref)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
+       int __pref) throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
+         const pthread_condattr_t *__restrict __cond_attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_cond_destroy (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_cond_signal (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_cond_broadcast (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
+         pthread_mutex_t *__restrict __mutex)
+     __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
+       pthread_mutex_t *__restrict __mutex,
+       const struct timespec *__restrict __abstime)
+     __attribute__ ((__nonnull__ (1, 2, 3)));
+extern int pthread_condattr_init (pthread_condattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_condattr_getpshared (const pthread_condattr_t *
+     __restrict __attr,
+     int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
+     int __pshared) throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_condattr_getclock (const pthread_condattr_t *
+          __restrict __attr,
+          __clockid_t *__restrict __clock_id)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
+          __clockid_t __clock_id)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_spin_lock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
+     const pthread_barrierattr_t *__restrict
+     __attr, unsigned int __count)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
+        __restrict __attr,
+        int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
+        int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_key_create (pthread_key_t *__key,
+          void (*__destr_function) (void *))
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int pthread_key_delete (pthread_key_t __key) throw ();
+extern void *pthread_getspecific (pthread_key_t __key) throw ();
+extern int pthread_setspecific (pthread_key_t __key,
+    const void *__pointer) throw () ;
+extern int pthread_getcpuclockid (pthread_t __thread_id,
+      __clockid_t *__clock_id)
+     throw () __attribute__ ((__nonnull__ (2)));
+extern int pthread_atfork (void (*__prepare) (void),
+      void (*__parent) (void),
+      void (*__child) (void)) throw ();
+}
+typedef pthread_t __gthread_t;
+typedef pthread_key_t __gthread_key_t;
+typedef pthread_once_t __gthread_once_t;
+typedef pthread_mutex_t __gthread_mutex_t;
+typedef pthread_mutex_t __gthread_recursive_mutex_t;
+typedef pthread_cond_t __gthread_cond_t;
+typedef struct timespec __gthread_time_t;
+static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
+static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
+static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
+static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
+static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
+static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
+static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
+static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
+static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
+static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
+static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
+static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
+static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
+static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
+static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
+static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
+static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init")));
+static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
+static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
+static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
+static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
+static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
+static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
+static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
+static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
+static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
+static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
+static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
+static inline int
+__gthread_active_p (void)
+{
+  static void *const __gthread_active_ptr
+    = __extension__ (void *) &__gthrw___pthread_key_create;
+  return __gthread_active_ptr != 0;
+}
+static inline int
+__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
+    void *__args)
+{
+  return __gthrw_pthread_create (__threadid, __null, __func, __args);
+}
+static inline int
+__gthread_join (__gthread_t __threadid, void **__value_ptr)
+{
+  return __gthrw_pthread_join (__threadid, __value_ptr);
+}
+static inline int
+__gthread_detach (__gthread_t __threadid)
+{
+  return __gthrw_pthread_detach (__threadid);
+}
+static inline int
+__gthread_equal (__gthread_t __t1, __gthread_t __t2)
+{
+  return __gthrw_pthread_equal (__t1, __t2);
+}
+static inline __gthread_t
+__gthread_self (void)
+{
+  return __gthrw_pthread_self ();
+}
+static inline int
+__gthread_yield (void)
+{
+  return __gthrw_sched_yield ();
+}
+static inline int
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_once (__once, __func);
+  else
+    return -1;
+}
+static inline int
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
+{
+  return __gthrw_pthread_key_create (__key, __dtor);
+}
+static inline int
+__gthread_key_delete (__gthread_key_t __key)
+{
+  return __gthrw_pthread_key_delete (__key);
+}
+static inline void *
+__gthread_getspecific (__gthread_key_t __key)
+{
+  return __gthrw_pthread_getspecific (__key);
+}
+static inline int
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
+{
+  return __gthrw_pthread_setspecific (__key, __ptr);
+}
+static inline void
+__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    __gthrw_pthread_mutex_init (__mutex, __null);
+}
+static inline int
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_destroy (__mutex);
+  else
+    return 0;
+}
+static inline int
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_lock (__mutex);
+  else
+    return 0;
+}
+static inline int
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_trylock (__mutex);
+  else
+    return 0;
+}
+static inline int
+__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
+      const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
+  else
+    return 0;
+}
+static inline int
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_unlock (__mutex);
+  else
+    return 0;
+}
+static inline int
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_lock (__mutex);
+}
+static inline int
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_trylock (__mutex);
+}
+static inline int
+__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
+         const __gthread_time_t *__abs_timeout)
+{
+  return __gthread_mutex_timedlock (__mutex, __abs_timeout);
+}
+static inline int
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_unlock (__mutex);
+}
+static inline int
+__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_destroy (__mutex);
+}
+static inline int
+__gthread_cond_broadcast (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_broadcast (__cond);
+}
+static inline int
+__gthread_cond_signal (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_signal (__cond);
+}
+static inline int
+__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
+{
+  return __gthrw_pthread_cond_wait (__cond, __mutex);
+}
+static inline int
+__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
+     const __gthread_time_t *__abs_timeout)
+{
+  return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
+}
+static inline int
+__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
+          __gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_cond_wait (__cond, __mutex);
+}
+static inline int
+__gthread_cond_destroy (__gthread_cond_t* __cond)
+{
+  return __gthrw_pthread_cond_destroy (__cond);
+}
+#pragma GCC visibility pop
+typedef int _Atomic_word;
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+  static inline _Atomic_word
+  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
+  { return __atomic_fetch_add(__mem, __val, 4); }
+  static inline void
+  __atomic_add(volatile _Atomic_word* __mem, int __val)
+  { __atomic_fetch_add(__mem, __val, 4); }
+  static inline _Atomic_word
+  __exchange_and_add_single(_Atomic_word* __mem, int __val)
+  {
+    _Atomic_word __result = *__mem;
+    *__mem += __val;
+    return __result;
+  }
+  static inline void
+  __atomic_add_single(_Atomic_word* __mem, int __val)
+  { *__mem += __val; }
+  static inline _Atomic_word
+  __attribute__ ((__unused__))
+  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+    if (__gthread_active_p())
+      return __exchange_and_add(__mem, __val);
+    else
+      return __exchange_and_add_single(__mem, __val);
+  }
+  static inline void
+  __attribute__ ((__unused__))
+  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+    if (__gthread_active_p())
+      __atomic_add(__mem, __val);
+    else
+      __atomic_add_single(__mem, __val);
+  }
+
+}
+       
+       
+       
+       
+#pragma GCC visibility push(default)
+namespace __cxxabiv1
+{
+  class __forced_unwind
+  {
+    virtual ~__forced_unwind() throw();
+    virtual void __pure_dummy() = 0;
+  };
+}
+#pragma GCC visibility pop
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
+      const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
+      if (__put != __n)
+ __out.setstate(__ios_base::badbit);
+    }
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+      const _CharT __c = __out.fill();
+      for (; __n > 0; --__n)
+ {
+   const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
+   if (_Traits::eq_int_type(__put, _Traits::eof()))
+     {
+       __out.setstate(__ios_base::badbit);
+       break;
+     }
+ }
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
+       const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+      typename __ostream_type::sentry __cerb(__out);
+      if (__cerb)
+ {
+   try
+     {
+       const streamsize __w = __out.width();
+       if (__w > __n)
+  {
+    const bool __left = ((__out.flags()
+     & __ios_base::adjustfield)
+           == __ios_base::left);
+    if (!__left)
+      __ostream_fill(__out, __w - __n);
+    if (__out.good())
+      __ostream_write(__out, __s, __n);
+    if (__left && __out.good())
+      __ostream_fill(__out, __w - __n);
+  }
+       else
+  __ostream_write(__out, __s, __n);
+       __out.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __out._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __out._M_setstate(__ios_base::badbit); }
+ }
+      return __out;
+    }
+  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
+  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
+          streamsize);
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Arg, typename _Result>
+    struct unary_function
+    {
+      typedef _Arg argument_type;
+      typedef _Result result_type;
+    };
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    struct binary_function
+    {
+      typedef _Arg1 first_argument_type;
+      typedef _Arg2 second_argument_type;
+      typedef _Result result_type;
+    };
+  struct __is_transparent;
+  template<typename _Tp = void>
+    struct plus;
+  template<typename _Tp = void>
+    struct minus;
+  template<typename _Tp = void>
+    struct multiplies;
+  template<typename _Tp = void>
+    struct divides;
+  template<typename _Tp = void>
+    struct modulus;
+  template<typename _Tp = void>
+    struct negate;
+  template<typename _Tp>
+    struct plus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x + __y; }
+    };
+  template<typename _Tp>
+    struct minus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x - __y; }
+    };
+  template<typename _Tp>
+    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x * __y; }
+    };
+  template<typename _Tp>
+    struct divides : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x / __y; }
+    };
+  template<typename _Tp>
+    struct modulus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x % __y; }
+    };
+  template<typename _Tp>
+    struct negate : public unary_function<_Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x) const
+      { return -__x; }
+    };
+  template<>
+    struct plus<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
+      typedef __is_transparent is_transparent;
+    };
+  template<>
+    struct minus<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
+      typedef __is_transparent is_transparent;
+    };
+  template<>
+    struct multiplies<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
+      typedef __is_transparent is_transparent;
+    };
+  template<>
+    struct divides<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
+      typedef __is_transparent is_transparent;
+    };
+  template<>
+    struct modulus<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
+      typedef __is_transparent is_transparent;
+    };
+  template<>
+    struct negate<void>
+    {
+      template <typename _Tp>
+ constexpr
+ auto
+ operator()(_Tp&& __t) const
+ noexcept(noexcept(-std::forward<_Tp>(__t)))
+ -> decltype(-std::forward<_Tp>(__t))
+ { return -std::forward<_Tp>(__t); }
+      typedef __is_transparent is_transparent;
+    };
+  template<typename _Tp = void>
+    struct equal_to;
+  template<typename _Tp = void>
+    struct not_equal_to;
+  template<typename _Tp = void>
+    struct greater;
+  template<typename _Tp = void>
+    struct less;
+  template<typename _Tp = void>
+    struct greater_equal;
+  template<typename _Tp = void>
+    struct less_equal;
+  template<typename _Tp>
+    struct equal_to : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x == __y; }
+    };
+  template<typename _Tp>
+    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x != __y; }
+    };
+  template<typename _Tp>
+    struct greater : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x > __y; }
+    };
+  template<typename _Tp>
+    struct less : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x < __y; }
+    };
+  template<typename _Tp>
+    struct greater_equal : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x >= __y; }
+    };
+  template<typename _Tp>
+    struct less_equal : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x <= __y; }
+    };
+  template<typename _Tp>
+    struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+    {
+      constexpr bool
+      operator()(_Tp* __x, _Tp* __y) const noexcept
+      {
+ if (__builtin_constant_p (__x > __y))
+   return __x > __y;
+ return (long unsigned int)__x > (long unsigned int)__y;
+      }
+    };
+  template<typename _Tp>
+    struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+    {
+      constexpr bool
+      operator()(_Tp* __x, _Tp* __y) const noexcept
+      {
+ if (__builtin_constant_p (__x < __y))
+   return __x < __y;
+ return (long unsigned int)__x < (long unsigned int)__y;
+      }
+    };
+  template<typename _Tp>
+    struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+    {
+      constexpr bool
+      operator()(_Tp* __x, _Tp* __y) const noexcept
+      {
+ if (__builtin_constant_p (__x >= __y))
+   return __x >= __y;
+ return (long unsigned int)__x >= (long unsigned int)__y;
+      }
+    };
+  template<typename _Tp>
+    struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+    {
+      constexpr bool
+      operator()(_Tp* __x, _Tp* __y) const noexcept
+      {
+ if (__builtin_constant_p (__x <= __y))
+   return __x <= __y;
+ return (long unsigned int)__x <= (long unsigned int)__y;
+      }
+    };
+  template<>
+    struct equal_to<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
+      typedef __is_transparent is_transparent;
+    };
+  template<>
+    struct not_equal_to<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
+      typedef __is_transparent is_transparent;
+    };
+  template<>
+    struct greater<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
+ {
+   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
+   __ptr_cmp<_Tp, _Up>{});
+ }
+      template<typename _Tp, typename _Up>
+ constexpr bool
+ operator()(_Tp* __t, _Up* __u) const noexcept
+ { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
+      typedef __is_transparent is_transparent;
+    private:
+      template <typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
+      template <typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
+ {
+   return greater<const volatile void*>{}(
+       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
+       static_cast<const volatile void*>(std::forward<_Up>(__u)));
+ }
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded2 : true_type { };
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded2<_Tp, _Up, __void_t<
+   decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>>
+ : false_type { };
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded<_Tp, _Up, __void_t<
+   decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>>
+ : false_type { };
+      template<typename _Tp, typename _Up>
+ using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
+       is_convertible<_Tp, const volatile void*>,
+       is_convertible<_Up, const volatile void*>>;
+    };
+  template<>
+    struct less<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
+ {
+   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
+   __ptr_cmp<_Tp, _Up>{});
+ }
+      template<typename _Tp, typename _Up>
+ constexpr bool
+ operator()(_Tp* __t, _Up* __u) const noexcept
+ { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
+      typedef __is_transparent is_transparent;
+    private:
+      template <typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
+      template <typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
+ {
+   return less<const volatile void*>{}(
+       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
+       static_cast<const volatile void*>(std::forward<_Up>(__u)));
+ }
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded2 : true_type { };
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded2<_Tp, _Up, __void_t<
+   decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>>
+ : false_type { };
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded<_Tp, _Up, __void_t<
+   decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>>
+ : false_type { };
+      template<typename _Tp, typename _Up>
+ using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
+       is_convertible<_Tp, const volatile void*>,
+       is_convertible<_Up, const volatile void*>>;
+    };
+  template<>
+    struct greater_equal<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
+ {
+   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
+   __ptr_cmp<_Tp, _Up>{});
+ }
+      template<typename _Tp, typename _Up>
+ constexpr bool
+ operator()(_Tp* __t, _Up* __u) const noexcept
+ { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
+      typedef __is_transparent is_transparent;
+    private:
+      template <typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
+      template <typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
+ {
+   return greater_equal<const volatile void*>{}(
+       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
+       static_cast<const volatile void*>(std::forward<_Up>(__u)));
+ }
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded2 : true_type { };
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded2<_Tp, _Up, __void_t<
+   decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>>
+ : false_type { };
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded<_Tp, _Up, __void_t<
+   decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>>
+ : false_type { };
+      template<typename _Tp, typename _Up>
+ using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
+       is_convertible<_Tp, const volatile void*>,
+       is_convertible<_Up, const volatile void*>>;
+    };
+  template<>
+    struct less_equal<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
+ {
+   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
+   __ptr_cmp<_Tp, _Up>{});
+ }
+      template<typename _Tp, typename _Up>
+ constexpr bool
+ operator()(_Tp* __t, _Up* __u) const noexcept
+ { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
+      typedef __is_transparent is_transparent;
+    private:
+      template <typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
+      template <typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
+ {
+   return less_equal<const volatile void*>{}(
+       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
+       static_cast<const volatile void*>(std::forward<_Up>(__u)));
+ }
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded2 : true_type { };
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded2<_Tp, _Up, __void_t<
+   decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>>
+ : false_type { };
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded<_Tp, _Up, __void_t<
+   decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>>
+ : false_type { };
+      template<typename _Tp, typename _Up>
+ using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
+       is_convertible<_Tp, const volatile void*>,
+       is_convertible<_Up, const volatile void*>>;
+    };
+  template<typename _Tp = void>
+    struct logical_and;
+  template<typename _Tp = void>
+    struct logical_or;
+  template<typename _Tp = void>
+    struct logical_not;
+  template<typename _Tp>
+    struct logical_and : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x && __y; }
+    };
+  template<typename _Tp>
+    struct logical_or : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x || __y; }
+    };
+  template<typename _Tp>
+    struct logical_not : public unary_function<_Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x) const
+      { return !__x; }
+    };
+  template<>
+    struct logical_and<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
+      typedef __is_transparent is_transparent;
+    };
+  template<>
+    struct logical_or<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
+      typedef __is_transparent is_transparent;
+    };
+  template<>
+    struct logical_not<void>
+    {
+      template <typename _Tp>
+ constexpr
+ auto
+ operator()(_Tp&& __t) const
+ noexcept(noexcept(!std::forward<_Tp>(__t)))
+ -> decltype(!std::forward<_Tp>(__t))
+ { return !std::forward<_Tp>(__t); }
+      typedef __is_transparent is_transparent;
+    };
+  template<typename _Tp = void>
+    struct bit_and;
+  template<typename _Tp = void>
+    struct bit_or;
+  template<typename _Tp = void>
+    struct bit_xor;
+  template<typename _Tp = void>
+    struct bit_not;
+  template<typename _Tp>
+    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x & __y; }
+    };
+  template<typename _Tp>
+    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x | __y; }
+    };
+  template<typename _Tp>
+    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x ^ __y; }
+    };
+  template<typename _Tp>
+    struct bit_not : public unary_function<_Tp, _Tp>
+    {
+    constexpr
+      _Tp
+      operator()(const _Tp& __x) const
+      { return ~__x; }
+    };
+  template <>
+    struct bit_and<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
+      typedef __is_transparent is_transparent;
+    };
+  template <>
+    struct bit_or<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
+      typedef __is_transparent is_transparent;
+    };
+  template <>
+    struct bit_xor<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
+      typedef __is_transparent is_transparent;
+    };
+  template <>
+    struct bit_not<void>
+    {
+      template <typename _Tp>
+ constexpr
+ auto
+ operator()(_Tp&& __t) const
+ noexcept(noexcept(~std::forward<_Tp>(__t)))
+ -> decltype(~std::forward<_Tp>(__t))
+ { return ~std::forward<_Tp>(__t); }
+      typedef __is_transparent is_transparent;
+    };
+  template<typename _Predicate>
+    class unary_negate
+    : public unary_function<typename _Predicate::argument_type, bool>
+    {
+    protected:
+      _Predicate _M_pred;
+    public:
+      constexpr
+      explicit
+      unary_negate(const _Predicate& __x) : _M_pred(__x) { }
+      constexpr
+      bool
+      operator()(const typename _Predicate::argument_type& __x) const
+      { return !_M_pred(__x); }
+    };
+  template<typename _Predicate>
+    constexpr
+    inline unary_negate<_Predicate>
+    not1(const _Predicate& __pred)
+    { return unary_negate<_Predicate>(__pred); }
+  template<typename _Predicate>
+    class binary_negate
+    : public binary_function<typename _Predicate::first_argument_type,
+        typename _Predicate::second_argument_type, bool>
+    {
+    protected:
+      _Predicate _M_pred;
+    public:
+      constexpr
+      explicit
+      binary_negate(const _Predicate& __x) : _M_pred(__x) { }
+      constexpr
+      bool
+      operator()(const typename _Predicate::first_argument_type& __x,
+   const typename _Predicate::second_argument_type& __y) const
+      { return !_M_pred(__x, __y); }
+    };
+  template<typename _Predicate>
+    constexpr
+    inline binary_negate<_Predicate>
+    not2(const _Predicate& __pred)
+    { return binary_negate<_Predicate>(__pred); }
+  template<typename _Arg, typename _Result>
+    class pointer_to_unary_function : public unary_function<_Arg, _Result>
+    {
+    protected:
+      _Result (*_M_ptr)(_Arg);
+    public:
+      pointer_to_unary_function() { }
+      explicit
+      pointer_to_unary_function(_Result (*__x)(_Arg))
+      : _M_ptr(__x) { }
+      _Result
+      operator()(_Arg __x) const
+      { return _M_ptr(__x); }
+    };
+  template<typename _Arg, typename _Result>
+    inline pointer_to_unary_function<_Arg, _Result>
+    ptr_fun(_Result (*__x)(_Arg))
+    { return pointer_to_unary_function<_Arg, _Result>(__x); }
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    class pointer_to_binary_function
+    : public binary_function<_Arg1, _Arg2, _Result>
+    {
+    protected:
+      _Result (*_M_ptr)(_Arg1, _Arg2);
+    public:
+      pointer_to_binary_function() { }
+      explicit
+      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
+      : _M_ptr(__x) { }
+      _Result
+      operator()(_Arg1 __x, _Arg2 __y) const
+      { return _M_ptr(__x, __y); }
+    };
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
+    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
+    { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
+  template<typename _Tp>
+    struct _Identity
+    : public unary_function<_Tp, _Tp>
+    {
+      _Tp&
+      operator()(_Tp& __x) const
+      { return __x; }
+      const _Tp&
+      operator()(const _Tp& __x) const
+      { return __x; }
+    };
+  template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { };
+  template<typename _Pair>
+    struct _Select1st
+    : public unary_function<_Pair, typename _Pair::first_type>
+    {
+      typename _Pair::first_type&
+      operator()(_Pair& __x) const
+      { return __x.first; }
+      const typename _Pair::first_type&
+      operator()(const _Pair& __x) const
+      { return __x.first; }
+      template<typename _Pair2>
+        typename _Pair2::first_type&
+        operator()(_Pair2& __x) const
+        { return __x.first; }
+      template<typename _Pair2>
+        const typename _Pair2::first_type&
+        operator()(const _Pair2& __x) const
+        { return __x.first; }
+    };
+  template<typename _Pair>
+    struct _Select2nd
+    : public unary_function<_Pair, typename _Pair::second_type>
+    {
+      typename _Pair::second_type&
+      operator()(_Pair& __x) const
+      { return __x.second; }
+      const typename _Pair::second_type&
+      operator()(const _Pair& __x) const
+      { return __x.second; }
+    };
+  template<typename _Ret, typename _Tp>
+    class mem_fun_t : public unary_function<_Tp*, _Ret>
+    {
+    public:
+      explicit
+      mem_fun_t(_Ret (_Tp::*__pf)())
+      : _M_f(__pf) { }
+      _Ret
+      operator()(_Tp* __p) const
+      { return (__p->*_M_f)(); }
+    private:
+      _Ret (_Tp::*_M_f)();
+    };
+  template<typename _Ret, typename _Tp>
+    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
+      : _M_f(__pf) { }
+      _Ret
+      operator()(const _Tp* __p) const
+      { return (__p->*_M_f)(); }
+    private:
+      _Ret (_Tp::*_M_f)() const;
+    };
+  template<typename _Ret, typename _Tp>
+    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
+    {
+    public:
+      explicit
+      mem_fun_ref_t(_Ret (_Tp::*__pf)())
+      : _M_f(__pf) { }
+      _Ret
+      operator()(_Tp& __r) const
+      { return (__r.*_M_f)(); }
+    private:
+      _Ret (_Tp::*_M_f)();
+  };
+  template<typename _Ret, typename _Tp>
+    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
+      : _M_f(__pf) { }
+      _Ret
+      operator()(const _Tp& __r) const
+      { return (__r.*_M_f)(); }
+    private:
+      _Ret (_Tp::*_M_f)() const;
+    };
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
+    {
+    public:
+      explicit
+      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
+      : _M_f(__pf) { }
+      _Ret
+      operator()(_Tp* __p, _Arg __x) const
+      { return (__p->*_M_f)(__x); }
+    private:
+      _Ret (_Tp::*_M_f)(_Arg);
+    };
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
+      : _M_f(__pf) { }
+      _Ret
+      operator()(const _Tp* __p, _Arg __x) const
+      { return (__p->*_M_f)(__x); }
+    private:
+      _Ret (_Tp::*_M_f)(_Arg) const;
+    };
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
+    {
+    public:
+      explicit
+      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
+      : _M_f(__pf) { }
+      _Ret
+      operator()(_Tp& __r, _Arg __x) const
+      { return (__r.*_M_f)(__x); }
+    private:
+      _Ret (_Tp::*_M_f)(_Arg);
+    };
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
+      : _M_f(__pf) { }
+      _Ret
+      operator()(const _Tp& __r, _Arg __x) const
+      { return (__r.*_M_f)(__x); }
+    private:
+      _Ret (_Tp::*_M_f)(_Arg) const;
+    };
+  template<typename _Ret, typename _Tp>
+    inline mem_fun_t<_Ret, _Tp>
+    mem_fun(_Ret (_Tp::*__f)())
+    { return mem_fun_t<_Ret, _Tp>(__f); }
+  template<typename _Ret, typename _Tp>
+    inline const_mem_fun_t<_Ret, _Tp>
+    mem_fun(_Ret (_Tp::*__f)() const)
+    { return const_mem_fun_t<_Ret, _Tp>(__f); }
+  template<typename _Ret, typename _Tp>
+    inline mem_fun_ref_t<_Ret, _Tp>
+    mem_fun_ref(_Ret (_Tp::*__f)())
+    { return mem_fun_ref_t<_Ret, _Tp>(__f); }
+  template<typename _Ret, typename _Tp>
+    inline const_mem_fun_ref_t<_Ret, _Tp>
+    mem_fun_ref(_Ret (_Tp::*__f)() const)
+    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+
+}
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Operation>
+    class binder1st
+    : public unary_function<typename _Operation::second_argument_type,
+       typename _Operation::result_type>
+    {
+    protected:
+      _Operation op;
+      typename _Operation::first_argument_type value;
+    public:
+      binder1st(const _Operation& __x,
+  const typename _Operation::first_argument_type& __y)
+      : op(__x), value(__y) { }
+      typename _Operation::result_type
+      operator()(const typename _Operation::second_argument_type& __x) const
+      { return op(value, __x); }
+      typename _Operation::result_type
+      operator()(typename _Operation::second_argument_type& __x) const
+      { return op(value, __x); }
+    } __attribute__ ((__deprecated__));
+  template<typename _Operation, typename _Tp>
+    inline binder1st<_Operation>
+    bind1st(const _Operation& __fn, const _Tp& __x)
+    {
+      typedef typename _Operation::first_argument_type _Arg1_type;
+      return binder1st<_Operation>(__fn, _Arg1_type(__x));
+    }
+  template<typename _Operation>
+    class binder2nd
+    : public unary_function<typename _Operation::first_argument_type,
+       typename _Operation::result_type>
+    {
+    protected:
+      _Operation op;
+      typename _Operation::second_argument_type value;
+    public:
+      binder2nd(const _Operation& __x,
+  const typename _Operation::second_argument_type& __y)
+      : op(__x), value(__y) { }
+      typename _Operation::result_type
+      operator()(const typename _Operation::first_argument_type& __x) const
+      { return op(__x, value); }
+      typename _Operation::result_type
+      operator()(typename _Operation::first_argument_type& __x) const
+      { return op(__x, value); }
+    } __attribute__ ((__deprecated__));
+  template<typename _Operation, typename _Tp>
+    inline binder2nd<_Operation>
+    bind2nd(const _Operation& __fn, const _Tp& __x)
+    {
+      typedef typename _Operation::second_argument_type _Arg2_type;
+      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
+    }
+
+}
+#pragma GCC diagnostic pop
+       
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT, typename _Traits = std::char_traits<_CharT>>
+    class basic_string_view
+    {
+    public:
+      using traits_type = _Traits;
+      using value_type = _CharT;
+      using pointer = const _CharT*;
+      using const_pointer = const _CharT*;
+      using reference = const _CharT&;
+      using const_reference = const _CharT&;
+      using const_iterator = const _CharT*;
+      using iterator = const_iterator;
+      using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+      using reverse_iterator = const_reverse_iterator;
+      using size_type = size_t;
+      using difference_type = ptrdiff_t;
+      static constexpr size_type npos = size_type(-1);
+      constexpr
+      basic_string_view() noexcept
+      : _M_len{0}, _M_str{nullptr}
+      { }
+      constexpr basic_string_view(const basic_string_view&) noexcept = default;
+      constexpr basic_string_view(const _CharT* __str) noexcept
+      : _M_len{__str == nullptr ? 0 : traits_type::length(__str)},
+ _M_str{__str}
+      { }
+      constexpr
+      basic_string_view(const _CharT* __str, size_type __len) noexcept
+      : _M_len{__len}, _M_str{__str}
+      { }
+      constexpr basic_string_view&
+      operator=(const basic_string_view&) noexcept = default;
+      constexpr const_iterator
+      begin() const noexcept
+      { return this->_M_str; }
+      constexpr const_iterator
+      end() const noexcept
+      { return this->_M_str + this->_M_len; }
+      constexpr const_iterator
+      cbegin() const noexcept
+      { return this->_M_str; }
+      constexpr const_iterator
+      cend() const noexcept
+      { return this->_M_str + this->_M_len; }
+      constexpr const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+      constexpr const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+      constexpr const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+      constexpr const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+      constexpr size_type
+      size() const noexcept
+      { return this->_M_len; }
+      constexpr size_type
+      length() const noexcept
+      { return _M_len; }
+      constexpr size_type
+      max_size() const noexcept
+      {
+ return (npos - sizeof(size_type) - sizeof(void*))
+  / sizeof(value_type) / 4;
+      }
+      [[nodiscard]] constexpr bool
+      empty() const noexcept
+      { return this->_M_len == 0; }
+      constexpr const _CharT&
+      operator[](size_type __pos) const noexcept
+      {
+ ;
+ return *(this->_M_str + __pos);
+      }
+      constexpr const _CharT&
+      at(size_type __pos) const
+      {
+ if (__pos >= _M_len)
+   __throw_out_of_range_fmt(("basic_string_view::at: __pos " "(which is %zu) >= this->size() " "(which is %zu)"), __pos, this->size());
+ return *(this->_M_str + __pos);
+      }
+      constexpr const _CharT&
+      front() const noexcept
+      {
+ ;
+ return *this->_M_str;
+      }
+      constexpr const _CharT&
+      back() const noexcept
+      {
+ ;
+ return *(this->_M_str + this->_M_len - 1);
+      }
+      constexpr const _CharT*
+      data() const noexcept
+      { return this->_M_str; }
+      constexpr void
+      remove_prefix(size_type __n) noexcept
+      {
+ ;
+ this->_M_str += __n;
+ this->_M_len -= __n;
+      }
+      constexpr void
+      remove_suffix(size_type __n) noexcept
+      { this->_M_len -= __n; }
+      constexpr void
+      swap(basic_string_view& __sv) noexcept
+      {
+ auto __tmp = *this;
+ *this = __sv;
+ __sv = __tmp;
+      }
+      size_type
+      copy(_CharT* __str, size_type __n, size_type __pos = 0) const
+      {
+ ;
+ __pos = _M_check(__pos, "basic_string_view::copy");
+ const size_type __rlen = std::min(__n, _M_len - __pos);
+ traits_type::copy(__str, data() + __pos, __rlen);
+ return __rlen;
+      }
+      constexpr basic_string_view
+      substr(size_type __pos = 0, size_type __n = npos) const noexcept(false)
+      {
+ __pos = _M_check(__pos, "basic_string_view::substr");
+ const size_type __rlen = std::min(__n, _M_len - __pos);
+ return basic_string_view{_M_str + __pos, __rlen};
+      }
+      constexpr int
+      compare(basic_string_view __str) const noexcept
+      {
+ const size_type __rlen = std::min(this->_M_len, __str._M_len);
+ int __ret = traits_type::compare(this->_M_str, __str._M_str, __rlen);
+ if (__ret == 0)
+   __ret = _S_compare(this->_M_len, __str._M_len);
+ return __ret;
+      }
+      constexpr int
+      compare(size_type __pos1, size_type __n1, basic_string_view __str) const
+      { return this->substr(__pos1, __n1).compare(__str); }
+      constexpr int
+      compare(size_type __pos1, size_type __n1,
+       basic_string_view __str, size_type __pos2, size_type __n2) const
+      {
+ return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2));
+      }
+      constexpr int
+      compare(const _CharT* __str) const noexcept
+      { return this->compare(basic_string_view{__str}); }
+      constexpr int
+      compare(size_type __pos1, size_type __n1, const _CharT* __str) const
+      { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); }
+      constexpr int
+      compare(size_type __pos1, size_type __n1,
+       const _CharT* __str, size_type __n2) const noexcept(false)
+      {
+ return this->substr(__pos1, __n1)
+     .compare(basic_string_view(__str, __n2));
+      }
+      constexpr size_type
+      find(basic_string_view __str, size_type __pos = 0) const noexcept
+      { return this->find(__str._M_str, __pos, __str._M_len); }
+      constexpr size_type
+      find(_CharT __c, size_type __pos = 0) const noexcept;
+      constexpr size_type
+      find(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
+      constexpr size_type
+      find(const _CharT* __str, size_type __pos = 0) const noexcept
+      { return this->find(__str, __pos, traits_type::length(__str)); }
+      constexpr size_type
+      rfind(basic_string_view __str, size_type __pos = npos) const noexcept
+      { return this->rfind(__str._M_str, __pos, __str._M_len); }
+      constexpr size_type
+      rfind(_CharT __c, size_type __pos = npos) const noexcept;
+      constexpr size_type
+      rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
+      constexpr size_type
+      rfind(const _CharT* __str, size_type __pos = npos) const noexcept
+      { return this->rfind(__str, __pos, traits_type::length(__str)); }
+      constexpr size_type
+      find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept
+      { return this->find_first_of(__str._M_str, __pos, __str._M_len); }
+      constexpr size_type
+      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
+      { return this->find(__c, __pos); }
+      constexpr size_type
+      find_first_of(const _CharT* __str, size_type __pos, size_type __n) const noexcept;
+      constexpr size_type
+      find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept
+      { return this->find_first_of(__str, __pos, traits_type::length(__str)); }
+      constexpr size_type
+      find_last_of(basic_string_view __str,
+     size_type __pos = npos) const noexcept
+      { return this->find_last_of(__str._M_str, __pos, __str._M_len); }
+      constexpr size_type
+      find_last_of(_CharT __c, size_type __pos=npos) const noexcept
+      { return this->rfind(__c, __pos); }
+      constexpr size_type
+      find_last_of(const _CharT* __str, size_type __pos,
+     size_type __n) const noexcept;
+      constexpr size_type
+      find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept
+      { return this->find_last_of(__str, __pos, traits_type::length(__str)); }
+      constexpr size_type
+      find_first_not_of(basic_string_view __str,
+   size_type __pos = 0) const noexcept
+      { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); }
+      constexpr size_type
+      find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept;
+      constexpr size_type
+      find_first_not_of(const _CharT* __str,
+   size_type __pos, size_type __n) const noexcept;
+      constexpr size_type
+      find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept
+      {
+ return this->find_first_not_of(__str, __pos,
+           traits_type::length(__str));
+      }
+      constexpr size_type
+      find_last_not_of(basic_string_view __str,
+         size_type __pos = npos) const noexcept
+      { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); }
+      constexpr size_type
+      find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept;
+      constexpr size_type
+      find_last_not_of(const _CharT* __str,
+         size_type __pos, size_type __n) const noexcept;
+      constexpr size_type
+      find_last_not_of(const _CharT* __str,
+         size_type __pos = npos) const noexcept
+      {
+ return this->find_last_not_of(__str, __pos,
+          traits_type::length(__str));
+      }
+      constexpr size_type
+      _M_check(size_type __pos, const char* __s) const noexcept(false)
+      {
+ if (__pos > this->size())
+   __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)"),
+       __s, __pos, this->size());
+ return __pos;
+      }
+      constexpr size_type
+      _M_limit(size_type __pos, size_type __off) const noexcept
+      {
+ const bool __testoff = __off < this->size() - __pos;
+ return __testoff ? __off : this->size() - __pos;
+      }
+    private:
+      static constexpr int
+      _S_compare(size_type __n1, size_type __n2) noexcept
+      {
+ const difference_type __diff = __n1 - __n2;
+ if (__diff > std::numeric_limits<int>::max())
+   return std::numeric_limits<int>::max();
+ if (__diff < std::numeric_limits<int>::min())
+   return std::numeric_limits<int>::min();
+ return static_cast<int>(__diff);
+      }
+      size_t _M_len;
+      const _CharT* _M_str;
+    };
+  namespace __detail
+  {
+    template<typename _Tp>
+      using __idt = common_type_t<_Tp>;
+  }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator==(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.size() == __y.size() && __x.compare(__y) == 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator==(basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.size() == __y.size() && __x.compare(__y) == 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator==(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.size() == __y.size() && __x.compare(__y) == 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator!=(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return !(__x == __y); }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator!=(basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return !(__x == __y); }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator!=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return !(__x == __y); }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator< (basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) < 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator< (basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.compare(__y) < 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator< (__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) < 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator> (basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) > 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator> (basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.compare(__y) > 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator> (__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) > 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator<=(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) <= 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator<=(basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.compare(__y) <= 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator<=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) <= 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator>=(basic_string_view<_CharT, _Traits> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) >= 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator>=(basic_string_view<_CharT, _Traits> __x,
+               __detail::__idt<basic_string_view<_CharT, _Traits>> __y) noexcept
+    { return __x.compare(__y) >= 0; }
+  template<typename _CharT, typename _Traits>
+    constexpr bool
+    operator>=(__detail::__idt<basic_string_view<_CharT, _Traits>> __x,
+               basic_string_view<_CharT, _Traits> __y) noexcept
+    { return __x.compare(__y) >= 0; }
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os,
+        basic_string_view<_CharT,_Traits> __str)
+    { return __ostream_insert(__os, __str.data(), __str.size()); }
+  using string_view = basic_string_view<char>;
+  using wstring_view = basic_string_view<wchar_t>;
+  using u16string_view = basic_string_view<char16_t>;
+  using u32string_view = basic_string_view<char32_t>;
+  template<typename _Tp>
+    struct hash;
+  template<>
+    struct hash<string_view>
+    : public __hash_base<size_t, string_view>
+    {
+      size_t
+      operator()(const string_view& __str) const noexcept
+      { return std::_Hash_impl::hash(__str.data(), __str.length()); }
+    };
+  template<>
+    struct __is_fast_hash<hash<string_view>> : std::false_type
+    { };
+  template<>
+    struct hash<wstring_view>
+    : public __hash_base<size_t, wstring>
+    {
+      size_t
+      operator()(const wstring_view& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(wchar_t)); }
+    };
+  template<>
+    struct __is_fast_hash<hash<wstring_view>> : std::false_type
+    { };
+  template<>
+    struct hash<u16string_view>
+    : public __hash_base<size_t, u16string_view>
+    {
+      size_t
+      operator()(const u16string_view& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char16_t)); }
+    };
+  template<>
+    struct __is_fast_hash<hash<u16string_view>> : std::false_type
+    { };
+  template<>
+    struct hash<u32string_view>
+    : public __hash_base<size_t, u32string_view>
+    {
+      size_t
+      operator()(const u32string_view& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char32_t)); }
+    };
+  template<>
+    struct __is_fast_hash<hash<u32string_view>> : std::false_type
+    { };
+  inline namespace literals
+  {
+  inline namespace string_view_literals
+  {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+    inline constexpr basic_string_view<char>
+    operator""sv(const char* __str, size_t __len) noexcept
+    { return basic_string_view<char>{__str, __len}; }
+    inline constexpr basic_string_view<wchar_t>
+    operator""sv(const wchar_t* __str, size_t __len) noexcept
+    { return basic_string_view<wchar_t>{__str, __len}; }
+    inline constexpr basic_string_view<char16_t>
+    operator""sv(const char16_t* __str, size_t __len) noexcept
+    { return basic_string_view<char16_t>{__str, __len}; }
+    inline constexpr basic_string_view<char32_t>
+    operator""sv(const char32_t* __str, size_t __len) noexcept
+    { return basic_string_view<char32_t>{__str, __len}; }
+#pragma GCC diagnostic pop
+  }
+  }
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find(const _CharT* __str, size_type __pos, size_type __n) const noexcept
+    {
+      ;
+      if (__n == 0)
+ return __pos <= this->_M_len ? __pos : npos;
+      if (__n <= this->_M_len)
+ {
+   for (; __pos <= this->_M_len - __n; ++__pos)
+     if (traits_type::eq(this->_M_str[__pos], __str[0])
+  && traits_type::compare(this->_M_str + __pos + 1,
+     __str + 1, __n - 1) == 0)
+       return __pos;
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __ret = npos;
+      if (__pos < this->_M_len)
+ {
+   const size_type __n = this->_M_len - __pos;
+   const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c);
+   if (__p)
+     __ret = __p - this->_M_str;
+ }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept
+    {
+      ;
+      if (__n <= this->_M_len)
+ {
+   __pos = std::min(size_type(this->_M_len - __n), __pos);
+   do
+     {
+       if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0)
+  return __pos;
+     }
+   while (__pos-- > 0);
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    rfind(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __size = this->_M_len;
+      if (__size > 0)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   for (++__size; __size-- > 0; )
+     if (traits_type::eq(this->_M_str[__size], __c))
+       return __size;
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_first_of(const _CharT* __str, size_type __pos,
+    size_type __n) const noexcept
+    {
+      ;
+      for (; __n && __pos < this->_M_len; ++__pos)
+ {
+   const _CharT* __p = traits_type::find(__str, __n,
+      this->_M_str[__pos]);
+   if (__p)
+     return __pos;
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_last_of(const _CharT* __str, size_type __pos,
+   size_type __n) const noexcept
+    {
+      ;
+      size_type __size = this->size();
+      if (__size && __n)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (traits_type::find(__str, __n, this->_M_str[__size]))
+  return __size;
+     }
+   while (__size-- != 0);
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_first_not_of(const _CharT* __str, size_type __pos,
+        size_type __n) const noexcept
+    {
+      ;
+      for (; __pos < this->_M_len; ++__pos)
+ if (!traits_type::find(__str, __n, this->_M_str[__pos]))
+   return __pos;
+      return npos;
+    }
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_first_not_of(_CharT __c, size_type __pos) const noexcept
+    {
+      for (; __pos < this->_M_len; ++__pos)
+ if (!traits_type::eq(this->_M_str[__pos], __c))
+   return __pos;
+      return npos;
+    }
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_last_not_of(const _CharT* __str, size_type __pos,
+       size_type __n) const noexcept
+    {
+      ;
+      size_type __size = this->_M_len;
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::find(__str, __n, this->_M_str[__size]))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits>
+    constexpr typename basic_string_view<_CharT, _Traits>::size_type
+    basic_string_view<_CharT, _Traits>::
+    find_last_not_of(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __size = this->_M_len;
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::eq(this->_M_str[__size], __c))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+namespace __cxx11 {
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_string
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_CharT>::other _Char_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
+    public:
+      typedef _Traits traits_type;
+      typedef typename _Traits::char_type value_type;
+      typedef _Char_alloc_type allocator_type;
+      typedef typename _Alloc_traits::size_type size_type;
+      typedef typename _Alloc_traits::difference_type difference_type;
+      typedef typename _Alloc_traits::reference reference;
+      typedef typename _Alloc_traits::const_reference const_reference;
+      typedef typename _Alloc_traits::pointer pointer;
+      typedef typename _Alloc_traits::const_pointer const_pointer;
+      typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
+       const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      static const size_type npos = static_cast<size_type>(-1);
+    private:
+      typedef const_iterator __const_iterator;
+      typedef basic_string_view<_CharT, _Traits> __sv_type;
+      template<typename _Tp, typename _Res>
+ using _If_sv = enable_if_t<
+   __and_<is_convertible<const _Tp&, __sv_type>,
+   __not_<is_convertible<const _Tp*, const basic_string*>>,
+   __not_<is_convertible<const _Tp&, const _CharT*>>>::value,
+   _Res>;
+      static __sv_type
+      _S_to_string_view(__sv_type __svt) noexcept
+      { return __svt; }
+      struct __sv_wrapper
+      {
+ explicit __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { }
+ __sv_type _M_sv;
+      };
+      struct _Alloc_hider : allocator_type
+      {
+ _Alloc_hider(pointer __dat, const _Alloc& __a)
+ : allocator_type(__a), _M_p(__dat) { }
+ _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc())
+ : allocator_type(std::move(__a)), _M_p(__dat) { }
+ pointer _M_p;
+      };
+      _Alloc_hider _M_dataplus;
+      size_type _M_string_length;
+      enum { _S_local_capacity = 15 / sizeof(_CharT) };
+      union
+      {
+ _CharT _M_local_buf[_S_local_capacity + 1];
+ size_type _M_allocated_capacity;
+      };
+      void
+      _M_data(pointer __p)
+      { _M_dataplus._M_p = __p; }
+      void
+      _M_length(size_type __length)
+      { _M_string_length = __length; }
+      pointer
+      _M_data() const
+      { return _M_dataplus._M_p; }
+      pointer
+      _M_local_data()
+      {
+ return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
+      }
+      const_pointer
+      _M_local_data() const
+      {
+ return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
+      }
+      void
+      _M_capacity(size_type __capacity)
+      { _M_allocated_capacity = __capacity; }
+      void
+      _M_set_length(size_type __n)
+      {
+ _M_length(__n);
+ traits_type::assign(_M_data()[__n], _CharT());
+      }
+      bool
+      _M_is_local() const
+      { return _M_data() == _M_local_data(); }
+      pointer
+      _M_create(size_type&, size_type);
+      void
+      _M_dispose()
+      {
+ if (!_M_is_local())
+   _M_destroy(_M_allocated_capacity);
+      }
+      void
+      _M_destroy(size_type __size) throw()
+      { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
+      template<typename _InIterator>
+        void
+        _M_construct_aux(_InIterator __beg, _InIterator __end,
+    std::__false_type)
+ {
+          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
+          _M_construct(__beg, __end, _Tag());
+ }
+      template<typename _Integer>
+        void
+        _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
+ { _M_construct_aux_2(static_cast<size_type>(__beg), __end); }
+      void
+      _M_construct_aux_2(size_type __req, _CharT __c)
+      { _M_construct(__req, __c); }
+      template<typename _InIterator>
+        void
+        _M_construct(_InIterator __beg, _InIterator __end)
+ {
+   typedef typename std::__is_integer<_InIterator>::__type _Integral;
+   _M_construct_aux(__beg, __end, _Integral());
+        }
+      template<typename _InIterator>
+        void
+        _M_construct(_InIterator __beg, _InIterator __end,
+       std::input_iterator_tag);
+      template<typename _FwdIterator>
+        void
+        _M_construct(_FwdIterator __beg, _FwdIterator __end,
+       std::forward_iterator_tag);
+      void
+      _M_construct(size_type __req, _CharT __c);
+      allocator_type&
+      _M_get_allocator()
+      { return _M_dataplus; }
+      const allocator_type&
+      _M_get_allocator() const
+      { return _M_dataplus; }
+    private:
+      size_type
+      _M_check(size_type __pos, const char* __s) const
+      {
+ if (__pos > this->size())
+   __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)"),
+       __s, __pos, this->size());
+ return __pos;
+      }
+      void
+      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
+      {
+ if (this->max_size() - (this->size() - __n1) < __n2)
+   __throw_length_error((__s));
+      }
+      size_type
+      _M_limit(size_type __pos, size_type __off) const noexcept
+      {
+ const bool __testoff = __off < this->size() - __pos;
+ return __testoff ? __off : this->size() - __pos;
+      }
+      bool
+      _M_disjunct(const _CharT* __s) const noexcept
+      {
+ return (less<const _CharT*>()(__s, _M_data())
+  || less<const _CharT*>()(_M_data() + this->size(), __s));
+      }
+      static void
+      _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, *__s);
+ else
+   traits_type::copy(__d, __s, __n);
+      }
+      static void
+      _S_move(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, *__s);
+ else
+   traits_type::move(__d, __s, __n);
+      }
+      static void
+      _S_assign(_CharT* __d, size_type __n, _CharT __c)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, __c);
+ else
+   traits_type::assign(__d, __n, __c);
+      }
+      template<class _Iterator>
+        static void
+        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
+        {
+   for (; __k1 != __k2; ++__k1, (void)++__p)
+     traits_type::assign(*__p, *__k1);
+ }
+      static void
+      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+      static void
+      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
+      noexcept
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+      static void
+      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept
+      { _S_copy(__p, __k1, __k2 - __k1); }
+      static void
+      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
+      noexcept
+      { _S_copy(__p, __k1, __k2 - __k1); }
+      static int
+      _S_compare(size_type __n1, size_type __n2) noexcept
+      {
+ const difference_type __d = difference_type(__n1 - __n2);
+ if (__d > __gnu_cxx::__numeric_traits<int>::__max)
+   return __gnu_cxx::__numeric_traits<int>::__max;
+ else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
+   return __gnu_cxx::__numeric_traits<int>::__min;
+ else
+   return int(__d);
+      }
+      void
+      _M_assign(const basic_string&);
+      void
+      _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
+  size_type __len2);
+      void
+      _M_erase(size_type __pos, size_type __n);
+    public:
+      basic_string()
+      noexcept(is_nothrow_default_constructible<_Alloc>::value)
+      : _M_dataplus(_M_local_data())
+      { _M_set_length(0); }
+      explicit
+      basic_string(const _Alloc& __a) noexcept
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_set_length(0); }
+      basic_string(const basic_string& __str)
+      : _M_dataplus(_M_local_data(),
+      _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
+      { _M_construct(__str._M_data(), __str._M_data() + __str.length()); }
+      basic_string(const basic_string& __str, size_type __pos,
+     const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      {
+ const _CharT* __start = __str._M_data()
+   + __str._M_check(__pos, "basic_string::basic_string");
+ _M_construct(__start, __start + __str._M_limit(__pos, npos));
+      }
+      basic_string(const basic_string& __str, size_type __pos,
+     size_type __n)
+      : _M_dataplus(_M_local_data())
+      {
+ const _CharT* __start = __str._M_data()
+   + __str._M_check(__pos, "basic_string::basic_string");
+ _M_construct(__start, __start + __str._M_limit(__pos, __n));
+      }
+      basic_string(const basic_string& __str, size_type __pos,
+     size_type __n, const _Alloc& __a)
+      : _M_dataplus(_M_local_data(), __a)
+      {
+ const _CharT* __start
+   = __str._M_data() + __str._M_check(__pos, "string::string");
+ _M_construct(__start, __start + __str._M_limit(__pos, __n));
+      }
+      basic_string(const _CharT* __s, size_type __n,
+     const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__s, __s + __n); }
+      template<typename = _RequireAllocator<_Alloc>>
+      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__s, __s ? __s + traits_type::length(__s) : __s+npos); }
+      template<typename = _RequireAllocator<_Alloc>>
+      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__n, __c); }
+      basic_string(basic_string&& __str) noexcept
+      : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
+      {
+ if (__str._M_is_local())
+   {
+     traits_type::copy(_M_local_buf, __str._M_local_buf,
+         _S_local_capacity + 1);
+   }
+ else
+   {
+     _M_data(__str._M_data());
+     _M_capacity(__str._M_allocated_capacity);
+   }
+ _M_length(__str.length());
+ __str._M_data(__str._M_local_data());
+ __str._M_set_length(0);
+      }
+      basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__l.begin(), __l.end()); }
+      basic_string(const basic_string& __str, const _Alloc& __a)
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__str.begin(), __str.end()); }
+      basic_string(basic_string&& __str, const _Alloc& __a)
+      noexcept(_Alloc_traits::_S_always_equal())
+      : _M_dataplus(_M_local_data(), __a)
+      {
+ if (__str._M_is_local())
+   {
+     traits_type::copy(_M_local_buf, __str._M_local_buf,
+         _S_local_capacity + 1);
+     _M_length(__str.length());
+     __str._M_set_length(0);
+   }
+ else if (_Alloc_traits::_S_always_equal()
+     || __str.get_allocator() == __a)
+   {
+     _M_data(__str._M_data());
+     _M_length(__str.length());
+     _M_capacity(__str._M_allocated_capacity);
+     __str._M_data(__str._M_local_buf);
+     __str._M_set_length(0);
+   }
+ else
+   _M_construct(__str.begin(), __str.end());
+      }
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        basic_string(_InputIterator __beg, _InputIterator __end,
+       const _Alloc& __a = _Alloc())
+ : _M_dataplus(_M_local_data(), __a)
+ { _M_construct(__beg, __end); }
+      template<typename _Tp, typename = _If_sv<_Tp, void>>
+ basic_string(const _Tp& __t, size_type __pos, size_type __n,
+       const _Alloc& __a = _Alloc())
+ : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { }
+      template<typename _Tp, typename = _If_sv<_Tp, void>>
+ explicit
+ basic_string(const _Tp& __t, const _Alloc& __a = _Alloc())
+ : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { }
+      explicit
+      basic_string(__sv_wrapper __svw, const _Alloc& __a)
+      : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }
+      ~basic_string()
+      { _M_dispose(); }
+      basic_string&
+      operator=(const basic_string& __str)
+      {
+ if (_Alloc_traits::_S_propagate_on_copy_assign())
+   {
+     if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
+  && _M_get_allocator() != __str._M_get_allocator())
+       {
+  if (__str.size() <= _S_local_capacity)
+    {
+      _M_destroy(_M_allocated_capacity);
+      _M_data(_M_local_data());
+      _M_set_length(0);
+    }
+  else
+    {
+      const auto __len = __str.size();
+      auto __alloc = __str._M_get_allocator();
+      auto __ptr = _Alloc_traits::allocate(__alloc, __len + 1);
+      _M_destroy(_M_allocated_capacity);
+      _M_data(__ptr);
+      _M_capacity(__len);
+      _M_set_length(__len);
+    }
+       }
+     std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
+   }
+ return this->assign(__str);
+      }
+      basic_string&
+      operator=(const _CharT* __s)
+      { return this->assign(__s); }
+      basic_string&
+      operator=(_CharT __c)
+      {
+ this->assign(1, __c);
+ return *this;
+      }
+      basic_string&
+      operator=(basic_string&& __str)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+ if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
+     && !_Alloc_traits::_S_always_equal()
+     && _M_get_allocator() != __str._M_get_allocator())
+   {
+     _M_destroy(_M_allocated_capacity);
+     _M_data(_M_local_data());
+     _M_set_length(0);
+   }
+ std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
+ if (__str._M_is_local())
+   {
+     if (__str.size())
+       this->_S_copy(_M_data(), __str._M_data(), __str.size());
+     _M_set_length(__str.size());
+   }
+ else if (_Alloc_traits::_S_propagate_on_move_assign()
+     || _Alloc_traits::_S_always_equal()
+     || _M_get_allocator() == __str._M_get_allocator())
+   {
+     pointer __data = nullptr;
+     size_type __capacity;
+     if (!_M_is_local())
+       {
+  if (_Alloc_traits::_S_always_equal())
+    {
+      __data = _M_data();
+      __capacity = _M_allocated_capacity;
+    }
+  else
+    _M_destroy(_M_allocated_capacity);
+       }
+     _M_data(__str._M_data());
+     _M_length(__str.length());
+     _M_capacity(__str._M_allocated_capacity);
+     if (__data)
+       {
+  __str._M_data(__data);
+  __str._M_capacity(__capacity);
+       }
+     else
+       __str._M_data(__str._M_local_buf);
+   }
+ else
+   assign(__str);
+ __str.clear();
+ return *this;
+      }
+      basic_string&
+      operator=(initializer_list<_CharT> __l)
+      {
+ this->assign(__l.begin(), __l.size());
+ return *this;
+      }
+     template<typename _Tp>
+       _If_sv<_Tp, basic_string&>
+       operator=(const _Tp& __svt)
+       { return this->assign(__svt); }
+      operator __sv_type() const noexcept
+      { return __sv_type(data(), size()); }
+      iterator
+      begin() noexcept
+      { return iterator(_M_data()); }
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(_M_data()); }
+      iterator
+      end() noexcept
+      { return iterator(_M_data() + this->size()); }
+      const_iterator
+      end() const noexcept
+      { return const_iterator(_M_data() + this->size()); }
+      reverse_iterator
+      rbegin() noexcept
+      { return reverse_iterator(this->end()); }
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+      reverse_iterator
+      rend() noexcept
+      { return reverse_iterator(this->begin()); }
+      const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(this->_M_data()); }
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(this->_M_data() + this->size()); }
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(this->end()); }
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(this->begin()); }
+    public:
+      size_type
+      size() const noexcept
+      { return _M_string_length; }
+      size_type
+      length() const noexcept
+      { return _M_string_length; }
+      size_type
+      max_size() const noexcept
+      { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
+      void
+      resize(size_type __n, _CharT __c);
+      void
+      resize(size_type __n)
+      { this->resize(__n, _CharT()); }
+      void
+      shrink_to_fit() noexcept
+      {
+ if (capacity() > size())
+   {
+     try
+       { reserve(0); }
+     catch(...)
+       { }
+   }
+      }
+      size_type
+      capacity() const noexcept
+      {
+ return _M_is_local() ? size_type(_S_local_capacity)
+                      : _M_allocated_capacity;
+      }
+      void
+      reserve(size_type __res_arg = 0);
+      void
+      clear() noexcept
+      { _M_set_length(0); }
+      bool
+      empty() const noexcept
+      { return this->size() == 0; }
+      const_reference
+      operator[] (size_type __pos) const noexcept
+      {
+ ;
+ return _M_data()[__pos];
+      }
+      reference
+      operator[](size_type __pos)
+      {
+ ;
+ ;
+ return _M_data()[__pos];
+      }
+      const_reference
+      at(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
+       __n, this->size());
+ return _M_data()[__n];
+      }
+      reference
+      at(size_type __n)
+      {
+ if (__n >= size())
+   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"),
+       __n, this->size());
+ return _M_data()[__n];
+      }
+      reference
+      front() noexcept
+      {
+ ;
+ return operator[](0);
+      }
+      const_reference
+      front() const noexcept
+      {
+ ;
+ return operator[](0);
+      }
+      reference
+      back() noexcept
+      {
+ ;
+ return operator[](this->size() - 1);
+      }
+      const_reference
+      back() const noexcept
+      {
+ ;
+ return operator[](this->size() - 1);
+      }
+      basic_string&
+      operator+=(const basic_string& __str)
+      { return this->append(__str); }
+      basic_string&
+      operator+=(const _CharT* __s)
+      { return this->append(__s); }
+      basic_string&
+      operator+=(_CharT __c)
+      {
+ this->push_back(__c);
+ return *this;
+      }
+      basic_string&
+      operator+=(initializer_list<_CharT> __l)
+      { return this->append(__l.begin(), __l.size()); }
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ operator+=(const _Tp& __svt)
+ { return this->append(__svt); }
+      basic_string&
+      append(const basic_string& __str)
+      { return _M_append(__str._M_data(), __str.size()); }
+      basic_string&
+      append(const basic_string& __str, size_type __pos, size_type __n = npos)
+      { return _M_append(__str._M_data()
+    + __str._M_check(__pos, "basic_string::append"),
+    __str._M_limit(__pos, __n)); }
+      basic_string&
+      append(const _CharT* __s, size_type __n)
+      {
+ ;
+ _M_check_length(size_type(0), __n, "basic_string::append");
+ return _M_append(__s, __n);
+      }
+      basic_string&
+      append(const _CharT* __s)
+      {
+ ;
+ const size_type __n = traits_type::length(__s);
+ _M_check_length(size_type(0), __n, "basic_string::append");
+ return _M_append(__s, __n);
+      }
+      basic_string&
+      append(size_type __n, _CharT __c)
+      { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
+      basic_string&
+      append(initializer_list<_CharT> __l)
+      { return this->append(__l.begin(), __l.size()); }
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        basic_string&
+        append(_InputIterator __first, _InputIterator __last)
+        { return this->replace(end(), end(), __first, __last); }
+      template<typename _Tp>
+        _If_sv<_Tp, basic_string&>
+        append(const _Tp& __svt)
+        {
+          __sv_type __sv = __svt;
+          return this->append(__sv.data(), __sv.size());
+        }
+      template<typename _Tp>
+        _If_sv<_Tp, basic_string&>
+ append(const _Tp& __svt, size_type __pos, size_type __n = npos)
+ {
+   __sv_type __sv = __svt;
+   return _M_append(__sv.data()
+      + __sv._M_check(__pos, "basic_string::append"),
+      __sv._M_limit(__pos, __n));
+ }
+      void
+      push_back(_CharT __c)
+      {
+ const size_type __size = this->size();
+ if (__size + 1 > this->capacity())
+   this->_M_mutate(__size, size_type(0), 0, size_type(1));
+ traits_type::assign(this->_M_data()[__size], __c);
+ this->_M_set_length(__size + 1);
+      }
+      basic_string&
+      assign(const basic_string& __str)
+      {
+ this->_M_assign(__str);
+ return *this;
+      }
+      basic_string&
+      assign(basic_string&& __str)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+ return *this = std::move(__str);
+      }
+      basic_string&
+      assign(const basic_string& __str, size_type __pos, size_type __n = npos)
+      { return _M_replace(size_type(0), this->size(), __str._M_data()
+     + __str._M_check(__pos, "basic_string::assign"),
+     __str._M_limit(__pos, __n)); }
+      basic_string&
+      assign(const _CharT* __s, size_type __n)
+      {
+ ;
+ return _M_replace(size_type(0), this->size(), __s, __n);
+      }
+      basic_string&
+      assign(const _CharT* __s)
+      {
+ ;
+ return _M_replace(size_type(0), this->size(), __s,
+     traits_type::length(__s));
+      }
+      basic_string&
+      assign(size_type __n, _CharT __c)
+      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        basic_string&
+        assign(_InputIterator __first, _InputIterator __last)
+        { return this->replace(begin(), end(), __first, __last); }
+      basic_string&
+      assign(initializer_list<_CharT> __l)
+      { return this->assign(__l.begin(), __l.size()); }
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ assign(const _Tp& __svt)
+ {
+   __sv_type __sv = __svt;
+   return this->assign(__sv.data(), __sv.size());
+ }
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ assign(const _Tp& __svt, size_type __pos, size_type __n = npos)
+ {
+   __sv_type __sv = __svt;
+   return _M_replace(size_type(0), this->size(), __sv.data()
+       + __sv._M_check(__pos, "basic_string::assign"),
+       __sv._M_limit(__pos, __n));
+ }
+      iterator
+      insert(const_iterator __p, size_type __n, _CharT __c)
+      {
+ ;
+ const size_type __pos = __p - begin();
+ this->replace(__p, __p, __n, __c);
+ return iterator(this->_M_data() + __pos);
+      }
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ iterator
+        insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
+        {
+   ;
+   const size_type __pos = __p - begin();
+   this->replace(__p, __p, __beg, __end);
+   return iterator(this->_M_data() + __pos);
+ }
+      void
+      insert(iterator __p, initializer_list<_CharT> __l)
+      {
+ ;
+ this->insert(__p - begin(), __l.begin(), __l.size());
+      }
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str)
+      { return this->replace(__pos1, size_type(0),
+        __str._M_data(), __str.size()); }
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str,
+      size_type __pos2, size_type __n = npos)
+      { return this->replace(__pos1, size_type(0), __str._M_data()
+        + __str._M_check(__pos2, "basic_string::insert"),
+        __str._M_limit(__pos2, __n)); }
+      basic_string&
+      insert(size_type __pos, const _CharT* __s, size_type __n)
+      { return this->replace(__pos, size_type(0), __s, __n); }
+      basic_string&
+      insert(size_type __pos, const _CharT* __s)
+      {
+ ;
+ return this->replace(__pos, size_type(0), __s,
+        traits_type::length(__s));
+      }
+      basic_string&
+      insert(size_type __pos, size_type __n, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
+         size_type(0), __n, __c); }
+      iterator
+      insert(__const_iterator __p, _CharT __c)
+      {
+ ;
+ const size_type __pos = __p - begin();
+ _M_replace_aux(__pos, size_type(0), size_type(1), __c);
+ return iterator(_M_data() + __pos);
+      }
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ insert(size_type __pos, const _Tp& __svt)
+ {
+   __sv_type __sv = __svt;
+   return this->insert(__pos, __sv.data(), __sv.size());
+ }
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ insert(size_type __pos1, const _Tp& __svt,
+        size_type __pos2, size_type __n = npos)
+ {
+   __sv_type __sv = __svt;
+   return this->replace(__pos1, size_type(0), __sv.data()
+          + __sv._M_check(__pos2, "basic_string::insert"),
+          __sv._M_limit(__pos2, __n));
+ }
+      basic_string&
+      erase(size_type __pos = 0, size_type __n = npos)
+      {
+ _M_check(__pos, "basic_string::erase");
+ if (__n == npos)
+   this->_M_set_length(__pos);
+ else if (__n != 0)
+   this->_M_erase(__pos, _M_limit(__pos, __n));
+ return *this;
+      }
+      iterator
+      erase(__const_iterator __position)
+      {
+ ;
+ const size_type __pos = __position - begin();
+ this->_M_erase(__pos, size_type(1));
+ return iterator(_M_data() + __pos);
+      }
+      iterator
+      erase(__const_iterator __first, __const_iterator __last)
+      {
+ ;
+        const size_type __pos = __first - begin();
+ if (__last == end())
+   this->_M_set_length(__pos);
+ else
+   this->_M_erase(__pos, __last - __first);
+ return iterator(this->_M_data() + __pos);
+      }
+      void
+      pop_back() noexcept
+      {
+ ;
+ _M_erase(size() - 1, 1);
+      }
+      basic_string&
+      replace(size_type __pos, size_type __n, const basic_string& __str)
+      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
+      basic_string&
+      replace(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2 = npos)
+      { return this->replace(__pos1, __n1, __str._M_data()
+        + __str._M_check(__pos2, "basic_string::replace"),
+        __str._M_limit(__pos2, __n2)); }
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s,
+       size_type __n2)
+      {
+ ;
+ return _M_replace(_M_check(__pos, "basic_string::replace"),
+     _M_limit(__pos, __n1), __s, __n2);
+      }
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s)
+      {
+ ;
+ return this->replace(__pos, __n1, __s, traits_type::length(__s));
+      }
+      basic_string&
+      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
+         _M_limit(__pos, __n1), __n2, __c); }
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const basic_string& __str)
+      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const _CharT* __s, size_type __n)
+      {
+ ;
+ return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
+      }
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
+      {
+ ;
+ return this->replace(__i1, __i2, __s, traits_type::length(__s));
+      }
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
+       _CharT __c)
+      {
+ ;
+ return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
+      }
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        basic_string&
+        replace(const_iterator __i1, const_iterator __i2,
+  _InputIterator __k1, _InputIterator __k2)
+        {
+   ;
+   ;
+   return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
+        std::__false_type());
+ }
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       _CharT* __k1, _CharT* __k2)
+      {
+ ;
+ ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1, __k2 - __k1);
+      }
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const _CharT* __k1, const _CharT* __k2)
+      {
+ ;
+ ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1, __k2 - __k1);
+      }
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       iterator __k1, iterator __k2)
+      {
+ ;
+ ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1.base(), __k2 - __k1);
+      }
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const_iterator __k1, const_iterator __k2)
+      {
+ ;
+ ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1.base(), __k2 - __k1);
+      }
+      basic_string& replace(const_iterator __i1, const_iterator __i2,
+       initializer_list<_CharT> __l)
+      { return this->replace(__i1, __i2, __l.begin(), __l.size()); }
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ replace(size_type __pos, size_type __n, const _Tp& __svt)
+ {
+   __sv_type __sv = __svt;
+   return this->replace(__pos, __n, __sv.data(), __sv.size());
+ }
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ replace(size_type __pos1, size_type __n1, const _Tp& __svt,
+  size_type __pos2, size_type __n2 = npos)
+ {
+   __sv_type __sv = __svt;
+   return this->replace(__pos1, __n1, __sv.data()
+          + __sv._M_check(__pos2, "basic_string::replace"),
+          __sv._M_limit(__pos2, __n2));
+ }
+      template<typename _Tp>
+ _If_sv<_Tp, basic_string&>
+ replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt)
+ {
+   __sv_type __sv = __svt;
+   return this->replace(__i1 - begin(), __i2 - __i1, __sv);
+ }
+    private:
+      template<class _Integer>
+ basic_string&
+ _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+       _Integer __n, _Integer __val, __true_type)
+        { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }
+      template<class _InputIterator>
+ basic_string&
+ _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+       _InputIterator __k1, _InputIterator __k2,
+       __false_type);
+      basic_string&
+      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+       _CharT __c);
+      basic_string&
+      _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
+   const size_type __len2);
+      basic_string&
+      _M_append(const _CharT* __s, size_type __n);
+    public:
+      size_type
+      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
+      void
+      swap(basic_string& __s) noexcept;
+      const _CharT*
+      c_str() const noexcept
+      { return _M_data(); }
+      const _CharT*
+      data() const noexcept
+      { return _M_data(); }
+      _CharT*
+      data() noexcept
+      { return _M_data(); }
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_get_allocator(); }
+      size_type
+      find(const _CharT* __s, size_type __pos, size_type __n) const
+      noexcept;
+      size_type
+      find(const basic_string& __str, size_type __pos = 0) const
+      noexcept
+      { return this->find(__str.data(), __pos, __str.size()); }
+      template<typename _Tp>
+ _If_sv<_Tp, size_type>
+ find(const _Tp& __svt, size_type __pos = 0) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return this->find(__sv.data(), __pos, __sv.size());
+ }
+      size_type
+      find(const _CharT* __s, size_type __pos = 0) const noexcept
+      {
+ ;
+ return this->find(__s, __pos, traits_type::length(__s));
+      }
+      size_type
+      find(_CharT __c, size_type __pos = 0) const noexcept;
+      size_type
+      rfind(const basic_string& __str, size_type __pos = npos) const
+      noexcept
+      { return this->rfind(__str.data(), __pos, __str.size()); }
+      template<typename _Tp>
+ _If_sv<_Tp, size_type>
+ rfind(const _Tp& __svt, size_type __pos = npos) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return this->rfind(__sv.data(), __pos, __sv.size());
+ }
+      size_type
+      rfind(const _CharT* __s, size_type __pos, size_type __n) const
+      noexcept;
+      size_type
+      rfind(const _CharT* __s, size_type __pos = npos) const
+      {
+ ;
+ return this->rfind(__s, __pos, traits_type::length(__s));
+      }
+      size_type
+      rfind(_CharT __c, size_type __pos = npos) const noexcept;
+      size_type
+      find_first_of(const basic_string& __str, size_type __pos = 0) const
+      noexcept
+      { return this->find_first_of(__str.data(), __pos, __str.size()); }
+      template<typename _Tp>
+ _If_sv<_Tp, size_type>
+ find_first_of(const _Tp& __svt, size_type __pos = 0) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return this->find_first_of(__sv.data(), __pos, __sv.size());
+ }
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
+      noexcept;
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos = 0) const
+      noexcept
+      {
+ ;
+ return this->find_first_of(__s, __pos, traits_type::length(__s));
+      }
+      size_type
+      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
+      { return this->find(__c, __pos); }
+      size_type
+      find_last_of(const basic_string& __str, size_type __pos = npos) const
+      noexcept
+      { return this->find_last_of(__str.data(), __pos, __str.size()); }
+      template<typename _Tp>
+ _If_sv<_Tp, size_type>
+ find_last_of(const _Tp& __svt, size_type __pos = npos) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return this->find_last_of(__sv.data(), __pos, __sv.size());
+ }
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
+      noexcept;
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos = npos) const
+      noexcept
+      {
+ ;
+ return this->find_last_of(__s, __pos, traits_type::length(__s));
+      }
+      size_type
+      find_last_of(_CharT __c, size_type __pos = npos) const noexcept
+      { return this->rfind(__c, __pos); }
+      size_type
+      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
+      noexcept
+      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
+      template<typename _Tp>
+ _If_sv<_Tp, size_type>
+ find_first_not_of(const _Tp& __svt, size_type __pos = 0) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return this->find_first_not_of(__sv.data(), __pos, __sv.size());
+ }
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos,
+   size_type __n) const noexcept;
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+      noexcept
+      {
+ ;
+ return this->find_first_not_of(__s, __pos, traits_type::length(__s));
+      }
+      size_type
+      find_first_not_of(_CharT __c, size_type __pos = 0) const
+      noexcept;
+      size_type
+      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
+      noexcept
+      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
+      template<typename _Tp>
+ _If_sv<_Tp, size_type>
+ find_last_not_of(const _Tp& __svt, size_type __pos = npos) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return this->find_last_not_of(__sv.data(), __pos, __sv.size());
+ }
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos,
+         size_type __n) const noexcept;
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
+      noexcept
+      {
+ ;
+ return this->find_last_not_of(__s, __pos, traits_type::length(__s));
+      }
+      size_type
+      find_last_not_of(_CharT __c, size_type __pos = npos) const
+      noexcept;
+      basic_string
+      substr(size_type __pos = 0, size_type __n = npos) const
+      { return basic_string(*this,
+       _M_check(__pos, "basic_string::substr"), __n); }
+      int
+      compare(const basic_string& __str) const
+      {
+ const size_type __size = this->size();
+ const size_type __osize = __str.size();
+ const size_type __len = std::min(__size, __osize);
+ int __r = traits_type::compare(_M_data(), __str.data(), __len);
+ if (!__r)
+   __r = _S_compare(__size, __osize);
+ return __r;
+      }
+      template<typename _Tp>
+ _If_sv<_Tp, int>
+ compare(const _Tp& __svt) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   const size_type __size = this->size();
+   const size_type __osize = __sv.size();
+   const size_type __len = std::min(__size, __osize);
+   int __r = traits_type::compare(_M_data(), __sv.data(), __len);
+   if (!__r)
+     __r = _S_compare(__size, __osize);
+   return __r;
+ }
+      template<typename _Tp>
+ _If_sv<_Tp, int>
+ compare(size_type __pos, size_type __n, const _Tp& __svt) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return __sv_type(*this).substr(__pos, __n).compare(__sv);
+ }
+      template<typename _Tp>
+ _If_sv<_Tp, int>
+ compare(size_type __pos1, size_type __n1, const _Tp& __svt,
+  size_type __pos2, size_type __n2 = npos) const
+ noexcept(is_same<_Tp, __sv_type>::value)
+ {
+   __sv_type __sv = __svt;
+   return __sv_type(*this)
+     .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
+ }
+      int
+      compare(size_type __pos, size_type __n, const basic_string& __str) const;
+      int
+      compare(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2 = npos) const;
+      int
+      compare(const _CharT* __s) const noexcept;
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s,
+       size_type __n2) const;
+      template<typename, typename, typename> friend class basic_stringbuf;
+    };
+}
+namespace __cxx11 {
+  template<typename _InputIterator, typename _CharT
+      = typename iterator_traits<_InputIterator>::value_type,
+    typename _Allocator = allocator<_CharT>,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
+      -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
+  template<typename _CharT, typename _Traits,
+    typename _Allocator = allocator<_CharT>,
+    typename = _RequireAllocator<_Allocator>>
+    basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
+      -> basic_string<_CharT, _Traits, _Allocator>;
+  template<typename _CharT, typename _Traits,
+    typename _Allocator = allocator<_CharT>,
+    typename = _RequireAllocator<_Allocator>>
+    basic_string(basic_string_view<_CharT, _Traits>,
+   typename basic_string<_CharT, _Traits, _Allocator>::size_type,
+   typename basic_string<_CharT, _Traits, _Allocator>::size_type,
+   const _Allocator& = _Allocator())
+      -> basic_string<_CharT, _Traits, _Allocator>;
+}
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(const _CharT* __lhs,
+       const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      __string_type __str(__lhs);
+      __str.append(__size_type(1), __rhs);
+      return __str;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return std::move(__lhs.append(__rhs)); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    { return std::move(__rhs.insert(0, __lhs)); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    {
+      const auto __size = __lhs.size() + __rhs.size();
+      const bool __cond = (__size > __lhs.capacity()
+      && __size <= __rhs.capacity());
+      return __cond ? std::move(__rhs.insert(0, __lhs))
+             : std::move(__lhs.append(__rhs));
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const _CharT* __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    { return std::move(__rhs.insert(0, __lhs)); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(_CharT __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    { return std::move(__rhs.insert(0, 1, __lhs)); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       const _CharT* __rhs)
+    { return std::move(__lhs.append(__rhs)); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       _CharT __rhs)
+    { return std::move(__lhs.append(1, __rhs)); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) == 0; }
+  template<typename _CharT>
+    inline
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
+    operator==(const basic_string<_CharT>& __lhs,
+        const basic_string<_CharT>& __rhs) noexcept
+    { return (__lhs.size() == __rhs.size()
+       && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
+          __lhs.size())); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) == 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return !(__lhs == __rhs); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return !(__lhs == __rhs); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) < 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) > 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) > 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) < 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) <= 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) >= 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { return __lhs.compare(__rhs) >= 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const _CharT* __lhs,
+      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) <= 0; }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline void
+    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
+  basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept(noexcept(__lhs.swap(__rhs)))
+    { __lhs.swap(__rhs); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is,
+        basic_string<_CharT, _Traits, _Alloc>& __str);
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __is, basic_string<char>& __str);
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os,
+        const basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+      return __ostream_insert(__os, __str.data(), __str.size());
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str)
+    { return std::getline(__is, __str, __is.widen('\n')); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>&& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
+    { return std::getline(__is, __str, __delim); }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>&& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str)
+    { return std::getline(__is, __str); }
+  template<>
+    basic_istream<char>&
+    getline(basic_istream<char>& __in, basic_string<char>& __str,
+     char __delim);
+  template<>
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
+     wchar_t __delim);
+
+}
+       
+       
+       
+       
+extern "C" {
+typedef struct _G_fpos_t
+{
+  __off_t __pos;
+  __mbstate_t __state;
+} __fpos_t;
+typedef struct _G_fpos64_t
+{
+  __off64_t __pos;
+  __mbstate_t __state;
+} __fpos64_t;
+struct _IO_FILE;
+struct _IO_marker;
+struct _IO_codecvt;
+struct _IO_wide_data;
+typedef void _IO_lock_t;
+struct _IO_FILE
+{
+  int _flags;
+  char *_IO_read_ptr;
+  char *_IO_read_end;
+  char *_IO_read_base;
+  char *_IO_write_base;
+  char *_IO_write_ptr;
+  char *_IO_write_end;
+  char *_IO_buf_base;
+  char *_IO_buf_end;
+  char *_IO_save_base;
+  char *_IO_backup_base;
+  char *_IO_save_end;
+  struct _IO_marker *_markers;
+  struct _IO_FILE *_chain;
+  int _fileno;
+  int _flags2;
+  __off_t _old_offset;
+  unsigned short _cur_column;
+  signed char _vtable_offset;
+  char _shortbuf[1];
+  _IO_lock_t *_lock;
+  __off64_t _offset;
+  struct _IO_codecvt *_codecvt;
+  struct _IO_wide_data *_wide_data;
+  struct _IO_FILE *_freeres_list;
+  void *_freeres_buf;
+  size_t __pad5;
+  int _mode;
+  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
+};
+typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf,
+                                          size_t __nbytes);
+typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf,
+                                           size_t __nbytes);
+typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w);
+typedef int cookie_close_function_t (void *__cookie);
+typedef struct _IO_cookie_io_functions_t
+{
+  cookie_read_function_t *read;
+  cookie_write_function_t *write;
+  cookie_seek_function_t *seek;
+  cookie_close_function_t *close;
+} cookie_io_functions_t;
+typedef __gnuc_va_list va_list;
+typedef __fpos_t fpos_t;
+typedef __fpos64_t fpos64_t;
+extern FILE *stdin;
+extern FILE *stdout;
+extern FILE *stderr;
+extern int remove (const char *__filename) throw ();
+extern int rename (const char *__old, const char *__new) throw ();
+extern int renameat (int __oldfd, const char *__old, int __newfd,
+       const char *__new) throw ();
+extern int renameat2 (int __oldfd, const char *__old, int __newfd,
+        const char *__new, unsigned int __flags) throw ();
+extern FILE *tmpfile (void) ;
+extern FILE *tmpfile64 (void) ;
+extern char *tmpnam (char *__s) throw () ;
+extern char *tmpnam_r (char *__s) throw () ;
+extern char *tempnam (const char *__dir, const char *__pfx)
+     throw () __attribute__ ((__malloc__)) ;
+extern int fclose (FILE *__stream);
+extern int fflush (FILE *__stream);
+extern int fflush_unlocked (FILE *__stream);
+extern int fcloseall (void);
+extern FILE *fopen (const char *__restrict __filename,
+      const char *__restrict __modes) ;
+extern FILE *freopen (const char *__restrict __filename,
+        const char *__restrict __modes,
+        FILE *__restrict __stream) ;
+extern FILE *fopen64 (const char *__restrict __filename,
+        const char *__restrict __modes) ;
+extern FILE *freopen64 (const char *__restrict __filename,
+   const char *__restrict __modes,
+   FILE *__restrict __stream) ;
+extern FILE *fdopen (int __fd, const char *__modes) throw () ;
+extern FILE *fopencookie (void *__restrict __magic_cookie,
+     const char *__restrict __modes,
+     cookie_io_functions_t __io_funcs) throw () ;
+extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
+  throw () ;
+extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
+extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
+extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
+      int __modes, size_t __n) throw ();
+extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
+         size_t __size) throw ();
+extern void setlinebuf (FILE *__stream) throw ();
+extern int fprintf (FILE *__restrict __stream,
+      const char *__restrict __format, ...);
+extern int printf (const char *__restrict __format, ...);
+extern int sprintf (char *__restrict __s,
+      const char *__restrict __format, ...) throw ();
+extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
+       __gnuc_va_list __arg);
+extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
+extern int vsprintf (char *__restrict __s, const char *__restrict __format,
+       __gnuc_va_list __arg) throw ();
+extern int snprintf (char *__restrict __s, size_t __maxlen,
+       const char *__restrict __format, ...)
+     throw () __attribute__ ((__format__ (__printf__, 3, 4)));
+extern int vsnprintf (char *__restrict __s, size_t __maxlen,
+        const char *__restrict __format, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 3, 0)));
+extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
+        __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
+extern int __asprintf (char **__restrict __ptr,
+         const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
+extern int asprintf (char **__restrict __ptr,
+       const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
+extern int vdprintf (int __fd, const char *__restrict __fmt,
+       __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__printf__, 2, 0)));
+extern int dprintf (int __fd, const char *__restrict __fmt, ...)
+     __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int fscanf (FILE *__restrict __stream,
+     const char *__restrict __format, ...) ;
+extern int scanf (const char *__restrict __format, ...) ;
+extern int sscanf (const char *__restrict __s,
+     const char *__restrict __format, ...) throw ();
+extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
+      __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
+extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
+extern int vsscanf (const char *__restrict __s,
+      const char *__restrict __format, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
+extern int fgetc (FILE *__stream);
+extern int getc (FILE *__stream);
+extern int getchar (void);
+extern int getc_unlocked (FILE *__stream);
+extern int getchar_unlocked (void);
+extern int fgetc_unlocked (FILE *__stream);
+extern int fputc (int __c, FILE *__stream);
+extern int putc (int __c, FILE *__stream);
+extern int putchar (int __c);
+extern int fputc_unlocked (int __c, FILE *__stream);
+extern int putc_unlocked (int __c, FILE *__stream);
+extern int putchar_unlocked (int __c);
+extern int getw (FILE *__stream);
+extern int putw (int __w, FILE *__stream);
+extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
+     ;
+extern char *fgets_unlocked (char *__restrict __s, int __n,
+        FILE *__restrict __stream) ;
+extern __ssize_t __getdelim (char **__restrict __lineptr,
+                             size_t *__restrict __n, int __delimiter,
+                             FILE *__restrict __stream) ;
+extern __ssize_t getdelim (char **__restrict __lineptr,
+                           size_t *__restrict __n, int __delimiter,
+                           FILE *__restrict __stream) ;
+extern __ssize_t getline (char **__restrict __lineptr,
+                          size_t *__restrict __n,
+                          FILE *__restrict __stream) ;
+extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
+extern int puts (const char *__s);
+extern int ungetc (int __c, FILE *__stream);
+extern size_t fread (void *__restrict __ptr, size_t __size,
+       size_t __n, FILE *__restrict __stream) ;
+extern size_t fwrite (const void *__restrict __ptr, size_t __size,
+        size_t __n, FILE *__restrict __s);
+extern int fputs_unlocked (const char *__restrict __s,
+      FILE *__restrict __stream);
+extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
+         size_t __n, FILE *__restrict __stream) ;
+extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
+          size_t __n, FILE *__restrict __stream);
+extern int fseek (FILE *__stream, long int __off, int __whence);
+extern long int ftell (FILE *__stream) ;
+extern void rewind (FILE *__stream);
+extern int fseeko (FILE *__stream, __off_t __off, int __whence);
+extern __off_t ftello (FILE *__stream) ;
+extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
+extern int fsetpos (FILE *__stream, const fpos_t *__pos);
+extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
+extern __off64_t ftello64 (FILE *__stream) ;
+extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
+extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
+extern void clearerr (FILE *__stream) throw ();
+extern int feof (FILE *__stream) throw () ;
+extern int ferror (FILE *__stream) throw () ;
+extern void clearerr_unlocked (FILE *__stream) throw ();
+extern int feof_unlocked (FILE *__stream) throw () ;
+extern int ferror_unlocked (FILE *__stream) throw () ;
+extern void perror (const char *__s);
+extern int sys_nerr;
+extern const char *const sys_errlist[];
+extern int _sys_nerr;
+extern const char *const _sys_errlist[];
+extern int fileno (FILE *__stream) throw () ;
+extern int fileno_unlocked (FILE *__stream) throw () ;
+extern FILE *popen (const char *__command, const char *__modes) ;
+extern int pclose (FILE *__stream);
+extern char *ctermid (char *__s) throw ();
+extern char *cuserid (char *__s);
+struct obstack;
+extern int obstack_printf (struct obstack *__restrict __obstack,
+      const char *__restrict __format, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int obstack_vprintf (struct obstack *__restrict __obstack,
+       const char *__restrict __format,
+       __gnuc_va_list __args)
+     throw () __attribute__ ((__format__ (__printf__, 2, 0)));
+extern void flockfile (FILE *__stream) throw ();
+extern int ftrylockfile (FILE *__stream) throw () ;
+extern void funlockfile (FILE *__stream) throw ();
+extern int __uflow (FILE *);
+extern int __overflow (FILE *, int);
+}
+namespace std
+{
+  using ::FILE;
+  using ::fpos_t;
+  using ::clearerr;
+  using ::fclose;
+  using ::feof;
+  using ::ferror;
+  using ::fflush;
+  using ::fgetc;
+  using ::fgetpos;
+  using ::fgets;
+  using ::fopen;
+  using ::fprintf;
+  using ::fputc;
+  using ::fputs;
+  using ::fread;
+  using ::freopen;
+  using ::fscanf;
+  using ::fseek;
+  using ::fsetpos;
+  using ::ftell;
+  using ::fwrite;
+  using ::getc;
+  using ::getchar;
+  using ::perror;
+  using ::printf;
+  using ::putc;
+  using ::putchar;
+  using ::puts;
+  using ::remove;
+  using ::rename;
+  using ::rewind;
+  using ::scanf;
+  using ::setbuf;
+  using ::setvbuf;
+  using ::sprintf;
+  using ::sscanf;
+  using ::tmpfile;
+  using ::tmpnam;
+  using ::ungetc;
+  using ::vfprintf;
+  using ::vprintf;
+  using ::vsprintf;
+}
+namespace __gnu_cxx
+{
+  using ::snprintf;
+  using ::vfscanf;
+  using ::vscanf;
+  using ::vsnprintf;
+  using ::vsscanf;
+}
+namespace std
+{
+  using ::__gnu_cxx::snprintf;
+  using ::__gnu_cxx::vfscanf;
+  using ::__gnu_cxx::vscanf;
+  using ::__gnu_cxx::vsnprintf;
+  using ::__gnu_cxx::vsscanf;
+}
+       
+extern "C" {
+extern int *__errno_location (void) throw () __attribute__ ((__const__));
+extern char *program_invocation_name;
+extern char *program_invocation_short_name;
+typedef int error_t;
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _TRet, typename _Ret = _TRet, typename _CharT,
+    typename... _Base>
+    _Ret
+    __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...),
+    const char* __name, const _CharT* __str, std::size_t* __idx,
+    _Base... __base)
+    {
+      _Ret __ret;
+      _CharT* __endptr;
+      struct _Save_errno {
+ _Save_errno() : _M_errno((*__errno_location ())) { (*__errno_location ()) = 0; }
+ ~_Save_errno() { if ((*__errno_location ()) == 0) (*__errno_location ()) = _M_errno; }
+ int _M_errno;
+      } const __save_errno;
+      struct _Range_chk {
+   static bool
+   _S_chk(_TRet, std::false_type) { return false; }
+   static bool
+   _S_chk(_TRet __val, std::true_type)
+   {
+     return __val < _TRet(__numeric_traits<int>::__min)
+       || __val > _TRet(__numeric_traits<int>::__max);
+   }
+      };
+      const _TRet __tmp = __convf(__str, &__endptr, __base...);
+      if (__endptr == __str)
+ std::__throw_invalid_argument(__name);
+      else if ((*__errno_location ()) == 34
+   || _Range_chk::_S_chk(__tmp, std::is_same<_Ret, int>{}))
+ std::__throw_out_of_range(__name);
+      else
+ __ret = __tmp;
+      if (__idx)
+ *__idx = __endptr - __str;
+      return __ret;
+    }
+  template<typename _String, typename _CharT = typename _String::value_type>
+    _String
+    __to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*,
+     __builtin_va_list), std::size_t __n,
+   const _CharT* __fmt, ...)
+    {
+      _CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+         * __n));
+      __builtin_va_list __args;
+      __builtin_va_start(__args, __fmt);
+      const int __len = __convf(__s, __n, __fmt, __args);
+      __builtin_va_end(__args);
+      return _String(__s, __s + __len);
+    }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+namespace __cxx11 {
+  inline int
+  stoi(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
+     __idx, __base); }
+  inline long
+  stol(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
+        __idx, __base); }
+  inline unsigned long
+  stoul(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
+        __idx, __base); }
+  inline long long
+  stoll(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
+        __idx, __base); }
+  inline unsigned long long
+  stoull(const string& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
+        __idx, __base); }
+  inline float
+  stof(const string& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
+  inline double
+  stod(const string& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
+  inline long double
+  stold(const string& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
+  inline string
+  to_string(int __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int),
+        "%d", __val); }
+  inline string
+  to_string(unsigned __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
+        4 * sizeof(unsigned),
+        "%u", __val); }
+  inline string
+  to_string(long __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long),
+        "%ld", __val); }
+  inline string
+  to_string(unsigned long __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
+        4 * sizeof(unsigned long),
+        "%lu", __val); }
+  inline string
+  to_string(long long __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
+        4 * sizeof(long long),
+        "%lld", __val); }
+  inline string
+  to_string(unsigned long long __val)
+  { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
+        4 * sizeof(unsigned long long),
+        "%llu", __val); }
+  inline string
+  to_string(float __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
+        "%f", __val);
+  }
+  inline string
+  to_string(double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
+        "%f", __val);
+  }
+  inline string
+  to_string(long double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
+        "%Lf", __val);
+  }
+  inline int
+  stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
+     __idx, __base); }
+  inline long
+  stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
+        __idx, __base); }
+  inline unsigned long
+  stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
+        __idx, __base); }
+  inline long long
+  stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
+        __idx, __base); }
+  inline unsigned long long
+  stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
+  { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
+        __idx, __base); }
+  inline float
+  stof(const wstring& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
+  inline double
+  stod(const wstring& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
+  inline long double
+  stold(const wstring& __str, size_t* __idx = 0)
+  { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
+  inline wstring
+  to_wstring(int __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
+         L"%d", __val); }
+  inline wstring
+  to_wstring(unsigned __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+         4 * sizeof(unsigned),
+         L"%u", __val); }
+  inline wstring
+  to_wstring(long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
+         L"%ld", __val); }
+  inline wstring
+  to_wstring(unsigned long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+         4 * sizeof(unsigned long),
+         L"%lu", __val); }
+  inline wstring
+  to_wstring(long long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+         4 * sizeof(long long),
+         L"%lld", __val); }
+  inline wstring
+  to_wstring(unsigned long long __val)
+  { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
+         4 * sizeof(unsigned long long),
+         L"%llu", __val); }
+  inline wstring
+  to_wstring(float __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
+         L"%f", __val);
+  }
+  inline wstring
+  to_wstring(double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
+         L"%f", __val);
+  }
+  inline wstring
+  to_wstring(long double __val)
+  {
+    const int __n =
+      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
+    return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
+         L"%Lf", __val);
+  }
+}
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<>
+    struct hash<string>
+    : public __hash_base<size_t, string>
+    {
+      size_t
+      operator()(const string& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(), __s.length()); }
+    };
+  template<>
+    struct __is_fast_hash<hash<string>> : std::false_type
+    { };
+  template<>
+    struct hash<wstring>
+    : public __hash_base<size_t, wstring>
+    {
+      size_t
+      operator()(const wstring& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(wchar_t)); }
+    };
+  template<>
+    struct __is_fast_hash<hash<wstring>> : std::false_type
+    { };
+  template<>
+    struct hash<u16string>
+    : public __hash_base<size_t, u16string>
+    {
+      size_t
+      operator()(const u16string& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char16_t)); }
+    };
+  template<>
+    struct __is_fast_hash<hash<u16string>> : std::false_type
+    { };
+  template<>
+    struct hash<u32string>
+    : public __hash_base<size_t, u32string>
+    {
+      size_t
+      operator()(const u32string& __s) const noexcept
+      { return std::_Hash_impl::hash(__s.data(),
+                                     __s.length() * sizeof(char32_t)); }
+    };
+  template<>
+    struct __is_fast_hash<hash<u32string>> : std::false_type
+    { };
+  inline namespace literals
+  {
+  inline namespace string_literals
+  {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<char>
+    operator""s(const char* __str, size_t __len)
+    { return basic_string<char>{__str, __len}; }
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<wchar_t>
+    operator""s(const wchar_t* __str, size_t __len)
+    { return basic_string<wchar_t>{__str, __len}; }
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<char16_t>
+    operator""s(const char16_t* __str, size_t __len)
+    { return basic_string<char16_t>{__str, __len}; }
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<char32_t>
+    operator""s(const char32_t* __str, size_t __len)
+    { return basic_string<char32_t>{__str, __len}; }
+#pragma GCC diagnostic pop
+  }
+  }
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::npos;
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    swap(basic_string& __s) noexcept
+    {
+      if (this == &__s)
+ return;
+      _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator());
+      if (_M_is_local())
+ if (__s._M_is_local())
+   {
+     if (length() && __s.length())
+       {
+  _CharT __tmp_data[_S_local_capacity + 1];
+  traits_type::copy(__tmp_data, __s._M_local_buf,
+      _S_local_capacity + 1);
+  traits_type::copy(__s._M_local_buf, _M_local_buf,
+      _S_local_capacity + 1);
+  traits_type::copy(_M_local_buf, __tmp_data,
+      _S_local_capacity + 1);
+       }
+     else if (__s.length())
+       {
+  traits_type::copy(_M_local_buf, __s._M_local_buf,
+      _S_local_capacity + 1);
+  _M_length(__s.length());
+  __s._M_set_length(0);
+  return;
+       }
+     else if (length())
+       {
+  traits_type::copy(__s._M_local_buf, _M_local_buf,
+      _S_local_capacity + 1);
+  __s._M_length(length());
+  _M_set_length(0);
+  return;
+       }
+   }
+ else
+   {
+     const size_type __tmp_capacity = __s._M_allocated_capacity;
+     traits_type::copy(__s._M_local_buf, _M_local_buf,
+         _S_local_capacity + 1);
+     _M_data(__s._M_data());
+     __s._M_data(__s._M_local_buf);
+     _M_capacity(__tmp_capacity);
+   }
+      else
+ {
+   const size_type __tmp_capacity = _M_allocated_capacity;
+   if (__s._M_is_local())
+     {
+       traits_type::copy(_M_local_buf, __s._M_local_buf,
+    _S_local_capacity + 1);
+       __s._M_data(_M_data());
+       _M_data(_M_local_buf);
+     }
+   else
+     {
+       pointer __tmp_ptr = _M_data();
+       _M_data(__s._M_data());
+       __s._M_data(__tmp_ptr);
+       _M_capacity(__s._M_allocated_capacity);
+     }
+   __s._M_capacity(__tmp_capacity);
+ }
+      const size_type __tmp_length = length();
+      _M_length(__s.length());
+      __s._M_length(__tmp_length);
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::pointer
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_create(size_type& __capacity, size_type __old_capacity)
+    {
+      if (__capacity > max_size())
+ std::__throw_length_error(("basic_string::_M_create"));
+      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
+ {
+   __capacity = 2 * __old_capacity;
+   if (__capacity > max_size())
+     __capacity = max_size();
+ }
+      return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1);
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      void
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_construct(_InIterator __beg, _InIterator __end,
+     std::input_iterator_tag)
+      {
+ size_type __len = 0;
+ size_type __capacity = size_type(_S_local_capacity);
+ while (__beg != __end && __len < __capacity)
+   {
+     _M_data()[__len++] = *__beg;
+     ++__beg;
+   }
+ try
+   {
+     while (__beg != __end)
+       {
+  if (__len == __capacity)
+    {
+      __capacity = __len + 1;
+      pointer __another = _M_create(__capacity, __len);
+      this->_S_copy(__another, _M_data(), __len);
+      _M_dispose();
+      _M_data(__another);
+      _M_capacity(__capacity);
+    }
+  _M_data()[__len++] = *__beg;
+  ++__beg;
+       }
+   }
+ catch(...)
+   {
+     _M_dispose();
+     throw;
+   }
+ _M_set_length(__len);
+      }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      void
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_construct(_InIterator __beg, _InIterator __end,
+     std::forward_iterator_tag)
+      {
+ if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
+   std::__throw_logic_error(("basic_string::" "_M_construct null not valid"));
+ size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));
+ if (__dnew > size_type(_S_local_capacity))
+   {
+     _M_data(_M_create(__dnew, size_type(0)));
+     _M_capacity(__dnew);
+   }
+ try
+   { this->_S_copy_chars(_M_data(), __beg, __end); }
+ catch(...)
+   {
+     _M_dispose();
+     throw;
+   }
+ _M_set_length(__dnew);
+      }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_construct(size_type __n, _CharT __c)
+    {
+      if (__n > size_type(_S_local_capacity))
+ {
+   _M_data(_M_create(__n, size_type(0)));
+   _M_capacity(__n);
+ }
+      if (__n)
+ this->_S_assign(_M_data(), __n, __c);
+      _M_set_length(__n);
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_assign(const basic_string& __str)
+    {
+      if (this != &__str)
+ {
+   const size_type __rsize = __str.length();
+   const size_type __capacity = capacity();
+   if (__rsize > __capacity)
+     {
+       size_type __new_capacity = __rsize;
+       pointer __tmp = _M_create(__new_capacity, __capacity);
+       _M_dispose();
+       _M_data(__tmp);
+       _M_capacity(__new_capacity);
+     }
+   if (__rsize)
+     this->_S_copy(_M_data(), __str._M_data(), __rsize);
+   _M_set_length(__rsize);
+ }
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    reserve(size_type __res)
+    {
+      if (__res < length())
+ __res = length();
+      const size_type __capacity = capacity();
+      if (__res != __capacity)
+ {
+   if (__res > __capacity
+       || __res > size_type(_S_local_capacity))
+     {
+       pointer __tmp = _M_create(__res, __capacity);
+       this->_S_copy(__tmp, _M_data(), length() + 1);
+       _M_dispose();
+       _M_data(__tmp);
+       _M_capacity(__res);
+     }
+   else if (!_M_is_local())
+     {
+       this->_S_copy(_M_local_data(), _M_data(), length() + 1);
+       _M_destroy(__capacity);
+       _M_data(_M_local_data());
+     }
+ }
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
+       size_type __len2)
+    {
+      const size_type __how_much = length() - __pos - __len1;
+      size_type __new_capacity = length() + __len2 - __len1;
+      pointer __r = _M_create(__new_capacity, capacity());
+      if (__pos)
+ this->_S_copy(__r, _M_data(), __pos);
+      if (__s && __len2)
+ this->_S_copy(__r + __pos, __s, __len2);
+      if (__how_much)
+ this->_S_copy(__r + __pos + __len2,
+        _M_data() + __pos + __len1, __how_much);
+      _M_dispose();
+      _M_data(__r);
+      _M_capacity(__new_capacity);
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_erase(size_type __pos, size_type __n)
+    {
+      const size_type __how_much = length() - __pos - __n;
+      if (__how_much && __n)
+ this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);
+      _M_set_length(length() - __n);
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    resize(size_type __n, _CharT __c)
+    {
+      const size_type __size = this->size();
+      if (__size < __n)
+ this->append(__n - __size, __c);
+      else if (__n < __size)
+ this->_M_set_length(__n);
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_append(const _CharT* __s, size_type __n)
+    {
+      const size_type __len = __n + this->size();
+      if (__len <= this->capacity())
+ {
+   if (__n)
+     this->_S_copy(this->_M_data() + this->size(), __s, __n);
+ }
+      else
+ this->_M_mutate(this->size(), size_type(0), __s, __n);
+      this->_M_set_length(__len);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InputIterator>
+      basic_string<_CharT, _Traits, _Alloc>&
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+     _InputIterator __k1, _InputIterator __k2,
+     std::__false_type)
+      {
+ const basic_string __s(__k1, __k2);
+ const size_type __n1 = __i2 - __i1;
+ return _M_replace(__i1 - begin(), __n1, __s._M_data(),
+     __s.size());
+      }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+     _CharT __c)
+    {
+      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
+      const size_type __old_size = this->size();
+      const size_type __new_size = __old_size + __n2 - __n1;
+      if (__new_size <= this->capacity())
+ {
+   pointer __p = this->_M_data() + __pos1;
+   const size_type __how_much = __old_size - __pos1 - __n1;
+   if (__how_much && __n1 != __n2)
+     this->_S_move(__p + __n2, __p + __n1, __how_much);
+ }
+      else
+ this->_M_mutate(__pos1, __n1, 0, __n2);
+      if (__n2)
+ this->_S_assign(this->_M_data() + __pos1, __n2, __c);
+      this->_M_set_length(__new_size);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
+        const size_type __len2)
+    {
+      _M_check_length(__len1, __len2, "basic_string::_M_replace");
+      const size_type __old_size = this->size();
+      const size_type __new_size = __old_size + __len2 - __len1;
+      if (__new_size <= this->capacity())
+ {
+   pointer __p = this->_M_data() + __pos;
+   const size_type __how_much = __old_size - __pos - __len1;
+   if (_M_disjunct(__s))
+     {
+       if (__how_much && __len1 != __len2)
+  this->_S_move(__p + __len2, __p + __len1, __how_much);
+       if (__len2)
+  this->_S_copy(__p, __s, __len2);
+     }
+   else
+     {
+       if (__len2 && __len2 <= __len1)
+  this->_S_move(__p, __s, __len2);
+       if (__how_much && __len1 != __len2)
+  this->_S_move(__p + __len2, __p + __len1, __how_much);
+       if (__len2 > __len1)
+  {
+    if (__s + __len2 <= __p + __len1)
+      this->_S_move(__p, __s, __len2);
+    else if (__s >= __p + __len1)
+      this->_S_copy(__p, __s + __len2 - __len1, __len2);
+    else
+      {
+        const size_type __nleft = (__p + __len1) - __s;
+        this->_S_move(__p, __s, __nleft);
+        this->_S_copy(__p + __nleft, __p + __len2,
+        __len2 - __nleft);
+      }
+  }
+     }
+ }
+      else
+ this->_M_mutate(__pos, __len1, __s, __len2);
+      this->_M_set_length(__new_size);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    copy(_CharT* __s, size_type __n, size_type __pos) const
+    {
+      _M_check(__pos, "basic_string::copy");
+      __n = _M_limit(__pos, __n);
+      ;
+      if (__n)
+ _S_copy(__s, _M_data() + __pos, __n);
+      return __n;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      ;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      const __size_type __len = _Traits::length(__lhs);
+      __string_type __str;
+      __str.reserve(__len + __rhs.size());
+      __str.append(__lhs, __len);
+      __str.append(__rhs);
+      return __str;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      __string_type __str;
+      const __size_type __len = __rhs.size();
+      __str.reserve(__len + 1);
+      __str.append(__size_type(1), __lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find(const _CharT* __s, size_type __pos, size_type __n) const
+    noexcept
+    {
+      ;
+      const size_type __size = this->size();
+      if (__n == 0)
+ return __pos <= __size ? __pos : npos;
+      if (__pos >= __size)
+ return npos;
+      const _CharT __elem0 = __s[0];
+      const _CharT* const __data = data();
+      const _CharT* __first = __data + __pos;
+      const _CharT* const __last = __data + __size;
+      size_type __len = __size - __pos;
+      while (__len >= __n)
+ {
+   __first = traits_type::find(__first, __len - __n + 1, __elem0);
+   if (!__first)
+     return npos;
+   if (traits_type::compare(__first, __s, __n) == 0)
+     return __first - __data;
+   __len = __last - ++__first;
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __ret = npos;
+      const size_type __size = this->size();
+      if (__pos < __size)
+ {
+   const _CharT* __data = _M_data();
+   const size_type __n = __size - __pos;
+   const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
+   if (__p)
+     __ret = __p - __data;
+ }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    rfind(const _CharT* __s, size_type __pos, size_type __n) const
+    noexcept
+    {
+      ;
+      const size_type __size = this->size();
+      if (__n <= __size)
+ {
+   __pos = std::min(size_type(__size - __n), __pos);
+   const _CharT* __data = _M_data();
+   do
+     {
+       if (traits_type::compare(__data + __pos, __s, __n) == 0)
+  return __pos;
+     }
+   while (__pos-- > 0);
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    rfind(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   for (++__size; __size-- > 0; )
+     if (traits_type::eq(_M_data()[__size], __c))
+       return __size;
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
+    noexcept
+    {
+      ;
+      for (; __n && __pos < this->size(); ++__pos)
+ {
+   const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
+   if (__p)
+     return __pos;
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
+    noexcept
+    {
+      ;
+      size_type __size = this->size();
+      if (__size && __n)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (traits_type::find(__s, __n, _M_data()[__size]))
+  return __size;
+     }
+   while (__size-- != 0);
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    noexcept
+    {
+      ;
+      for (; __pos < this->size(); ++__pos)
+ if (!traits_type::find(__s, __n, _M_data()[__pos]))
+   return __pos;
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_not_of(_CharT __c, size_type __pos) const noexcept
+    {
+      for (; __pos < this->size(); ++__pos)
+ if (!traits_type::eq(_M_data()[__pos], __c))
+   return __pos;
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    noexcept
+    {
+      ;
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::find(__s, __n, _M_data()[__size]))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_not_of(_CharT __c, size_type __pos) const noexcept
+    {
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::eq(_M_data()[__size], __c))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n, const basic_string& __str) const
+    {
+      _M_check(__pos, "basic_string::compare");
+      __n = _M_limit(__pos, __n);
+      const size_type __osize = __str.size();
+      const size_type __len = std::min(__n, __osize);
+      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
+      if (!__r)
+ __r = _S_compare(__n, __osize);
+      return __r;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(size_type __pos1, size_type __n1, const basic_string& __str,
+     size_type __pos2, size_type __n2) const
+    {
+      _M_check(__pos1, "basic_string::compare");
+      __str._M_check(__pos2, "basic_string::compare");
+      __n1 = _M_limit(__pos1, __n1);
+      __n2 = __str._M_limit(__pos2, __n2);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(_M_data() + __pos1,
+         __str.data() + __pos2, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __n2);
+      return __r;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(const _CharT* __s) const noexcept
+    {
+      ;
+      const size_type __size = this->size();
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__size, __osize);
+      int __r = traits_type::compare(_M_data(), __s, __len);
+      if (!__r)
+ __r = _S_compare(__size, __osize);
+      return __r;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string <_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s) const
+    {
+      ;
+      _M_check(__pos, "basic_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__n1, __osize);
+      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __osize);
+      return __r;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string <_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s,
+     size_type __n2) const
+    {
+      ;
+      _M_check(__pos, "basic_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __n2);
+      return __r;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in,
+        basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __istream_type::ios_base __ios_base;
+      typedef typename __istream_type::int_type __int_type;
+      typedef typename __string_type::size_type __size_type;
+      typedef ctype<_CharT> __ctype_type;
+      typedef typename __ctype_type::ctype_base __ctype_base;
+      __size_type __extracted = 0;
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   try
+     {
+       __str.erase();
+       _CharT __buf[128];
+       __size_type __len = 0;
+       const streamsize __w = __in.width();
+       const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
+                                : __str.max_size();
+       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+       const __int_type __eof = _Traits::eof();
+       __int_type __c = __in.rdbuf()->sgetc();
+       while (__extracted < __n
+       && !_Traits::eq_int_type(__c, __eof)
+       && !__ct.is(__ctype_base::space,
+     _Traits::to_char_type(__c)))
+  {
+    if (__len == sizeof(__buf) / sizeof(_CharT))
+      {
+        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
+        __len = 0;
+      }
+    __buf[__len++] = _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __in.rdbuf()->snextc();
+  }
+       __str.append(__buf, __len);
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= __ios_base::eofbit;
+       __in.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     {
+       __in._M_setstate(__ios_base::badbit);
+     }
+ }
+      if (!__extracted)
+ __err |= __ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __in,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __istream_type::ios_base __ios_base;
+      typedef typename __istream_type::int_type __int_type;
+      typedef typename __string_type::size_type __size_type;
+      __size_type __extracted = 0;
+      const __size_type __n = __str.max_size();
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, true);
+      if (__cerb)
+ {
+   try
+     {
+       __str.erase();
+       const __int_type __idelim = _Traits::to_int_type(__delim);
+       const __int_type __eof = _Traits::eof();
+       __int_type __c = __in.rdbuf()->sgetc();
+       while (__extracted < __n
+       && !_Traits::eq_int_type(__c, __eof)
+       && !_Traits::eq_int_type(__c, __idelim))
+  {
+    __str += _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __in.rdbuf()->snextc();
+  }
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= __ios_base::eofbit;
+       else if (_Traits::eq_int_type(__c, __idelim))
+  {
+    ++__extracted;
+    __in.rdbuf()->sbumpc();
+  }
+       else
+  __err |= __ios_base::failbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     {
+       __in._M_setstate(__ios_base::badbit);
+     }
+ }
+      if (!__extracted)
+ __err |= __ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+  extern template
+    basic_istream<char>&
+    operator>>(basic_istream<char>&, string&);
+  extern template
+    basic_ostream<char>&
+    operator<<(basic_ostream<char>&, const string&);
+  extern template
+    basic_istream<char>&
+    getline(basic_istream<char>&, string&, char);
+  extern template
+    basic_istream<char>&
+    getline(basic_istream<char>&, string&);
+  extern template
+    basic_istream<wchar_t>&
+    operator>>(basic_istream<wchar_t>&, wstring&);
+  extern template
+    basic_ostream<wchar_t>&
+    operator<<(basic_ostream<wchar_t>&, const wstring&);
+  extern template
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
+  extern template
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>&, wstring&);
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  class locale
+  {
+  public:
+    typedef int category;
+    class facet;
+    class id;
+    class _Impl;
+    friend class facet;
+    friend class _Impl;
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+    template<typename _Cache>
+      friend struct __use_cache;
+    static const category none = 0;
+    static const category ctype = 1L << 0;
+    static const category numeric = 1L << 1;
+    static const category collate = 1L << 2;
+    static const category time = 1L << 3;
+    static const category monetary = 1L << 4;
+    static const category messages = 1L << 5;
+    static const category all = (ctype | numeric | collate |
+        time | monetary | messages);
+    locale() throw();
+    locale(const locale& __other) throw();
+    explicit
+    locale(const char* __s);
+    locale(const locale& __base, const char* __s, category __cat);
+    explicit
+    locale(const std::string& __s) : locale(__s.c_str()) { }
+    locale(const locale& __base, const std::string& __s, category __cat)
+    : locale(__base, __s.c_str(), __cat) { }
+    locale(const locale& __base, const locale& __add, category __cat);
+    template<typename _Facet>
+      locale(const locale& __other, _Facet* __f);
+    ~locale() throw();
+    const locale&
+    operator=(const locale& __other) throw();
+    template<typename _Facet>
+      locale
+      combine(const locale& __other) const;
+    __attribute ((__abi_tag__ ("cxx11")))
+    string
+    name() const;
+    bool
+    operator==(const locale& __other) const throw();
+    bool
+    operator!=(const locale& __other) const throw()
+    { return !(this->operator==(__other)); }
+    template<typename _Char, typename _Traits, typename _Alloc>
+      bool
+      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
+   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
+    static locale
+    global(const locale& __loc);
+    static const locale&
+    classic();
+  private:
+    _Impl* _M_impl;
+    static _Impl* _S_classic;
+    static _Impl* _S_global;
+    static const char* const* const _S_categories;
+    enum { _S_categories_size = 6 + 6 };
+    static __gthread_once_t _S_once;
+    explicit
+    locale(_Impl*) throw();
+    static void
+    _S_initialize();
+    static void
+    _S_initialize_once() throw();
+    static category
+    _S_normalize_category(category);
+    void
+    _M_coalesce(const locale& __base, const locale& __add, category __cat);
+    static const id* const _S_twinned_facets[];
+  };
+  class locale::facet
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+    mutable _Atomic_word _M_refcount;
+    static __c_locale _S_c_locale;
+    static const char _S_c_name[2];
+    static __gthread_once_t _S_once;
+    static void
+    _S_initialize_once();
+  protected:
+    explicit
+    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
+    { }
+    virtual
+    ~facet();
+    static void
+    _S_create_c_locale(__c_locale& __cloc, const char* __s,
+         __c_locale __old = 0);
+    static __c_locale
+    _S_clone_c_locale(__c_locale& __cloc) throw();
+    static void
+    _S_destroy_c_locale(__c_locale& __cloc);
+    static __c_locale
+    _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
+    static __c_locale
+    _S_get_c_locale();
+    __attribute__ ((__const__)) static const char*
+    _S_get_c_name() throw();
+    facet(const facet&) = delete;
+    facet&
+    operator=(const facet&) = delete;
+  private:
+    void
+    _M_add_reference() const throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+    void
+    _M_remove_reference() const throw()
+    {
+      ;
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+ {
+          ;
+   try
+     { delete this; }
+   catch(...)
+     { }
+ }
+    }
+    const facet* _M_sso_shim(const id*) const;
+    const facet* _M_cow_shim(const id*) const;
+  protected:
+    class __shim;
+  };
+  class locale::id
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+    mutable size_t _M_index;
+    static _Atomic_word _S_refcount;
+    void
+    operator=(const id&);
+    id(const id&);
+  public:
+    id() { }
+    size_t
+    _M_id() const throw();
+  };
+  class locale::_Impl
+  {
+  public:
+    friend class locale;
+    friend class locale::facet;
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+    template<typename _Cache>
+      friend struct __use_cache;
+  private:
+    _Atomic_word _M_refcount;
+    const facet** _M_facets;
+    size_t _M_facets_size;
+    const facet** _M_caches;
+    char** _M_names;
+    static const locale::id* const _S_id_ctype[];
+    static const locale::id* const _S_id_numeric[];
+    static const locale::id* const _S_id_collate[];
+    static const locale::id* const _S_id_time[];
+    static const locale::id* const _S_id_monetary[];
+    static const locale::id* const _S_id_messages[];
+    static const locale::id* const* const _S_facet_categories[];
+    void
+    _M_add_reference() throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+    void
+    _M_remove_reference() throw()
+    {
+      ;
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+ {
+          ;
+   try
+     { delete this; }
+   catch(...)
+     { }
+ }
+    }
+    _Impl(const _Impl&, size_t);
+    _Impl(const char*, size_t);
+    _Impl(size_t) throw();
+   ~_Impl() throw();
+    _Impl(const _Impl&);
+    void
+    operator=(const _Impl&);
+    bool
+    _M_check_same_name()
+    {
+      bool __ret = true;
+      if (_M_names[1])
+ for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
+   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
+      return __ret;
+    }
+    void
+    _M_replace_categories(const _Impl*, category);
+    void
+    _M_replace_category(const _Impl*, const locale::id* const*);
+    void
+    _M_replace_facet(const _Impl*, const locale::id*);
+    void
+    _M_install_facet(const locale::id*, const facet*);
+    template<typename _Facet>
+      void
+      _M_init_facet(_Facet* __facet)
+      { _M_install_facet(&_Facet::id, __facet); }
+    template<typename _Facet>
+      void
+      _M_init_facet_unchecked(_Facet* __facet)
+      {
+ __facet->_M_add_reference();
+ _M_facets[_Facet::id._M_id()] = __facet;
+      }
+    void
+    _M_install_cache(const facet*, size_t);
+    void _M_init_extra(facet**);
+    void _M_init_extra(void*, void*, const char*, const char*);
+  };
+  template<typename _CharT>
+    class __cxx11:: collate : public locale::facet
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+    protected:
+      __c_locale _M_c_locale_collate;
+    public:
+      static locale::id id;
+      explicit
+      collate(size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
+      { }
+      explicit
+      collate(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
+      { }
+      int
+      compare(const _CharT* __lo1, const _CharT* __hi1,
+       const _CharT* __lo2, const _CharT* __hi2) const
+      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
+      string_type
+      transform(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_transform(__lo, __hi); }
+      long
+      hash(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_hash(__lo, __hi); }
+      int
+      _M_compare(const _CharT*, const _CharT*) const throw();
+      size_t
+      _M_transform(_CharT*, const _CharT*, size_t) const throw();
+  protected:
+      virtual
+      ~collate()
+      { _S_destroy_c_locale(_M_c_locale_collate); }
+      virtual int
+      do_compare(const _CharT* __lo1, const _CharT* __hi1,
+   const _CharT* __lo2, const _CharT* __hi2) const;
+      virtual string_type
+      do_transform(const _CharT* __lo, const _CharT* __hi) const;
+      virtual long
+      do_hash(const _CharT* __lo, const _CharT* __hi) const;
+    };
+  template<typename _CharT>
+    locale::id collate<_CharT>::id;
+  template<>
+    int
+    collate<char>::_M_compare(const char*, const char*) const throw();
+  template<>
+    size_t
+    collate<char>::_M_transform(char*, const char*, size_t) const throw();
+  template<>
+    int
+    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
+  template<>
+    size_t
+    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
+  template<typename _CharT>
+    class __cxx11:: collate_byname : public collate<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+      explicit
+      collate_byname(const char* __s, size_t __refs = 0)
+      : collate<_CharT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     this->_S_destroy_c_locale(this->_M_c_locale_collate);
+     this->_S_create_c_locale(this->_M_c_locale_collate, __s);
+   }
+      }
+      explicit
+      collate_byname(const string& __s, size_t __refs = 0)
+      : collate_byname(__s.c_str(), __refs) { }
+    protected:
+      virtual
+      ~collate_byname() { }
+    };
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Facet>
+    locale::
+    locale(const locale& __other, _Facet* __f)
+    {
+      _M_impl = new _Impl(*__other._M_impl, 1);
+      try
+ { _M_impl->_M_install_facet(&_Facet::id, __f); }
+      catch(...)
+ {
+   _M_impl->_M_remove_reference();
+   throw;
+ }
+      delete [] _M_impl->_M_names[0];
+      _M_impl->_M_names[0] = 0;
+    }
+  template<typename _Facet>
+    locale
+    locale::
+    combine(const locale& __other) const
+    {
+      _Impl* __tmp = new _Impl(*_M_impl, 1);
+      try
+ {
+   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
+ }
+      catch(...)
+ {
+   __tmp->_M_remove_reference();
+   throw;
+ }
+      return locale(__tmp);
+    }
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    bool
+    locale::
+    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
+        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
+    {
+      typedef std::collate<_CharT> __collate_type;
+      const __collate_type& __collate = use_facet<__collate_type>(*this);
+      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
+    __s2.data(), __s2.data() + __s2.length()) < 0);
+    }
+  template<typename _Facet>
+    bool
+    has_facet(const locale& __loc) throw()
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      return (__i < __loc._M_impl->_M_facets_size
+       && dynamic_cast<const _Facet*>(__facets[__i]));
+    }
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale& __loc)
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
+        __throw_bad_cast();
+      return dynamic_cast<const _Facet&>(*__facets[__i]);
+    }
+  template<typename _CharT>
+    int
+    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
+    { return 0; }
+  template<typename _CharT>
+    size_t
+    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
+    { return 0; }
+  template<typename _CharT>
+    int
+    collate<_CharT>::
+    do_compare(const _CharT* __lo1, const _CharT* __hi1,
+        const _CharT* __lo2, const _CharT* __hi2) const
+    {
+      const string_type __one(__lo1, __hi1);
+      const string_type __two(__lo2, __hi2);
+      const _CharT* __p = __one.c_str();
+      const _CharT* __pend = __one.data() + __one.length();
+      const _CharT* __q = __two.c_str();
+      const _CharT* __qend = __two.data() + __two.length();
+      for (;;)
+ {
+   const int __res = _M_compare(__p, __q);
+   if (__res)
+     return __res;
+   __p += char_traits<_CharT>::length(__p);
+   __q += char_traits<_CharT>::length(__q);
+   if (__p == __pend && __q == __qend)
+     return 0;
+   else if (__p == __pend)
+     return -1;
+   else if (__q == __qend)
+     return 1;
+   __p++;
+   __q++;
+ }
+    }
+  template<typename _CharT>
+    typename collate<_CharT>::string_type
+    collate<_CharT>::
+    do_transform(const _CharT* __lo, const _CharT* __hi) const
+    {
+      string_type __ret;
+      const string_type __str(__lo, __hi);
+      const _CharT* __p = __str.c_str();
+      const _CharT* __pend = __str.data() + __str.length();
+      size_t __len = (__hi - __lo) * 2;
+      _CharT* __c = new _CharT[__len];
+      try
+ {
+   for (;;)
+     {
+       size_t __res = _M_transform(__c, __p, __len);
+       if (__res >= __len)
+  {
+    __len = __res + 1;
+    delete [] __c, __c = 0;
+    __c = new _CharT[__len];
+    __res = _M_transform(__c, __p, __len);
+  }
+       __ret.append(__c, __res);
+       __p += char_traits<_CharT>::length(__p);
+       if (__p == __pend)
+  break;
+       __p++;
+       __ret.push_back(_CharT());
+     }
+ }
+      catch(...)
+ {
+   delete [] __c;
+   throw;
+ }
+      delete [] __c;
+      return __ret;
+    }
+  template<typename _CharT>
+    long
+    collate<_CharT>::
+    do_hash(const _CharT* __lo, const _CharT* __hi) const
+    {
+      unsigned long __val = 0;
+      for (; __lo < __hi; ++__lo)
+ __val =
+   *__lo + ((__val << 7)
+     | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
+    __digits - 7)));
+      return static_cast<long>(__val);
+    }
+  extern template class collate<char>;
+  extern template class collate_byname<char>;
+  extern template
+    const collate<char>&
+    use_facet<collate<char> >(const locale&);
+  extern template
+    bool
+    has_facet<collate<char> >(const locale&);
+  extern template class collate<wchar_t>;
+  extern template class collate_byname<wchar_t>;
+  extern template
+    const collate<wchar_t>&
+    use_facet<collate<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<collate<wchar_t> >(const locale&);
+
+}
+       
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  enum class errc
+    {
+      address_family_not_supported = 97,
+      address_in_use = 98,
+      address_not_available = 99,
+      already_connected = 106,
+      argument_list_too_long = 7,
+      argument_out_of_domain = 33,
+      bad_address = 14,
+      bad_file_descriptor = 9,
+      bad_message = 74,
+      broken_pipe = 32,
+      connection_aborted = 103,
+      connection_already_in_progress = 114,
+      connection_refused = 111,
+      connection_reset = 104,
+      cross_device_link = 18,
+      destination_address_required = 89,
+      device_or_resource_busy = 16,
+      directory_not_empty = 39,
+      executable_format_error = 8,
+      file_exists = 17,
+      file_too_large = 27,
+      filename_too_long = 36,
+      function_not_supported = 38,
+      host_unreachable = 113,
+      identifier_removed = 43,
+      illegal_byte_sequence = 84,
+      inappropriate_io_control_operation = 25,
+      interrupted = 4,
+      invalid_argument = 22,
+      invalid_seek = 29,
+      io_error = 5,
+      is_a_directory = 21,
+      message_size = 90,
+      network_down = 100,
+      network_reset = 102,
+      network_unreachable = 101,
+      no_buffer_space = 105,
+      no_child_process = 10,
+      no_link = 67,
+      no_lock_available = 37,
+      no_message_available = 61,
+      no_message = 42,
+      no_protocol_option = 92,
+      no_space_on_device = 28,
+      no_stream_resources = 63,
+      no_such_device_or_address = 6,
+      no_such_device = 19,
+      no_such_file_or_directory = 2,
+      no_such_process = 3,
+      not_a_directory = 20,
+      not_a_socket = 88,
+      not_a_stream = 60,
+      not_connected = 107,
+      not_enough_memory = 12,
+      not_supported = 95,
+      operation_canceled = 125,
+      operation_in_progress = 115,
+      operation_not_permitted = 1,
+      operation_not_supported = 95,
+      operation_would_block = 11,
+      owner_dead = 130,
+      permission_denied = 13,
+      protocol_error = 71,
+      protocol_not_supported = 93,
+      read_only_file_system = 30,
+      resource_deadlock_would_occur = 35,
+      resource_unavailable_try_again = 11,
+      result_out_of_range = 34,
+      state_not_recoverable = 131,
+      stream_timeout = 62,
+      text_file_busy = 26,
+      timed_out = 110,
+      too_many_files_open_in_system = 23,
+      too_many_files_open = 24,
+      too_many_links = 31,
+      too_many_symbolic_link_levels = 40,
+      value_too_large = 75,
+      wrong_protocol_type = 91
+    };
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  struct __cow_string
+  {
+    union {
+      const char* _M_p;
+      char _M_bytes[sizeof(const char*)];
+    };
+    __cow_string();
+    __cow_string(const std::string&);
+    __cow_string(const char*, size_t);
+    __cow_string(const __cow_string&) noexcept;
+    __cow_string& operator=(const __cow_string&) noexcept;
+    ~__cow_string();
+    __cow_string(__cow_string&&) noexcept;
+    __cow_string& operator=(__cow_string&&) noexcept;
+  };
+  typedef basic_string<char> __sso_string;
+  class logic_error : public exception
+  {
+    __cow_string _M_msg;
+  public:
+    explicit
+    logic_error(const string& __arg) ;
+    explicit
+    logic_error(const char*) ;
+    logic_error(const logic_error&) noexcept;
+    logic_error& operator=(const logic_error&) noexcept;
+    virtual ~logic_error() noexcept;
+    virtual const char*
+    what() const noexcept;
+  };
+  class domain_error : public logic_error
+  {
+  public:
+    explicit domain_error(const string& __arg) ;
+    explicit domain_error(const char*) ;
+    virtual ~domain_error() noexcept;
+  };
+  class invalid_argument : public logic_error
+  {
+  public:
+    explicit invalid_argument(const string& __arg) ;
+    explicit invalid_argument(const char*) ;
+    virtual ~invalid_argument() noexcept;
+  };
+  class length_error : public logic_error
+  {
+  public:
+    explicit length_error(const string& __arg) ;
+    explicit length_error(const char*) ;
+    virtual ~length_error() noexcept;
+  };
+  class out_of_range : public logic_error
+  {
+  public:
+    explicit out_of_range(const string& __arg) ;
+    explicit out_of_range(const char*) ;
+    virtual ~out_of_range() noexcept;
+  };
+  class runtime_error : public exception
+  {
+    __cow_string _M_msg;
+  public:
+    explicit
+    runtime_error(const string& __arg) ;
+    explicit
+    runtime_error(const char*) ;
+    runtime_error(const runtime_error&) noexcept;
+    runtime_error& operator=(const runtime_error&) noexcept;
+    virtual ~runtime_error() noexcept;
+    virtual const char*
+    what() const noexcept;
+  };
+  class range_error : public runtime_error
+  {
+  public:
+    explicit range_error(const string& __arg) ;
+    explicit range_error(const char*) ;
+    virtual ~range_error() noexcept;
+  };
+  class overflow_error : public runtime_error
+  {
+  public:
+    explicit overflow_error(const string& __arg) ;
+    explicit overflow_error(const char*) ;
+    virtual ~overflow_error() noexcept;
+  };
+  class underflow_error : public runtime_error
+  {
+  public:
+    explicit underflow_error(const string& __arg) ;
+    explicit underflow_error(const char*) ;
+    virtual ~underflow_error() noexcept;
+  };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  class error_code;
+  class error_condition;
+  class system_error;
+  template<typename _Tp>
+    struct is_error_code_enum : public false_type { };
+  template<typename _Tp>
+    struct is_error_condition_enum : public false_type { };
+  template<>
+    struct is_error_condition_enum<errc>
+    : public true_type { };
+  template <typename _Tp>
+    inline constexpr bool is_error_code_enum_v =
+      is_error_code_enum<_Tp>::value;
+  template <typename _Tp>
+    inline constexpr bool is_error_condition_enum_v =
+      is_error_condition_enum<_Tp>::value;
+  inline namespace _V2 {
+  class error_category
+  {
+  public:
+    constexpr error_category() noexcept = default;
+    virtual ~error_category();
+    error_category(const error_category&) = delete;
+    error_category& operator=(const error_category&) = delete;
+    virtual const char*
+    name() const noexcept = 0;
+  private:
+    __attribute ((__abi_tag__ ("cxx11")))
+    virtual __cow_string
+    _M_message(int) const;
+  public:
+    __attribute ((__abi_tag__ ("cxx11")))
+    virtual string
+    message(int) const = 0;
+  public:
+    virtual error_condition
+    default_error_condition(int __i) const noexcept;
+    virtual bool
+    equivalent(int __i, const error_condition& __cond) const noexcept;
+    virtual bool
+    equivalent(const error_code& __code, int __i) const noexcept;
+    bool
+    operator<(const error_category& __other) const noexcept
+    { return less<const error_category*>()(this, &__other); }
+    bool
+    operator==(const error_category& __other) const noexcept
+    { return this == &__other; }
+    bool
+    operator!=(const error_category& __other) const noexcept
+    { return this != &__other; }
+  };
+  __attribute__ ((__const__)) const error_category& system_category() noexcept;
+  __attribute__ ((__const__)) const error_category& generic_category() noexcept;
+  }
+  error_code make_error_code(errc) noexcept;
+  template<typename _Tp>
+    struct hash;
+  struct error_code
+  {
+    error_code() noexcept
+    : _M_value(0), _M_cat(&system_category()) { }
+    error_code(int __v, const error_category& __cat) noexcept
+    : _M_value(__v), _M_cat(&__cat) { }
+    template<typename _ErrorCodeEnum, typename = typename
+      enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type>
+      error_code(_ErrorCodeEnum __e) noexcept
+      { *this = make_error_code(__e); }
+    void
+    assign(int __v, const error_category& __cat) noexcept
+    {
+      _M_value = __v;
+      _M_cat = &__cat;
+    }
+    void
+    clear() noexcept
+    { assign(0, system_category()); }
+    template<typename _ErrorCodeEnum>
+      typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
+    error_code&>::type
+      operator=(_ErrorCodeEnum __e) noexcept
+      { return *this = make_error_code(__e); }
+    int
+    value() const noexcept { return _M_value; }
+    const error_category&
+    category() const noexcept { return *_M_cat; }
+    error_condition
+    default_error_condition() const noexcept;
+    __attribute ((__abi_tag__ ("cxx11")))
+    string
+    message() const
+    { return category().message(value()); }
+    explicit operator bool() const noexcept
+    { return _M_value != 0; }
+  private:
+    friend class hash<error_code>;
+    int _M_value;
+    const error_category* _M_cat;
+  };
+  inline error_code
+  make_error_code(errc __e) noexcept
+  { return error_code(static_cast<int>(__e), generic_category()); }
+  inline bool
+  operator<(const error_code& __lhs, const error_code& __rhs) noexcept
+  {
+    return (__lhs.category() < __rhs.category()
+     || (__lhs.category() == __rhs.category()
+  && __lhs.value() < __rhs.value()));
+  }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
+    { return (__os << __e.category().name() << ':' << __e.value()); }
+  error_condition make_error_condition(errc) noexcept;
+  struct error_condition
+  {
+    error_condition() noexcept
+    : _M_value(0), _M_cat(&generic_category()) { }
+    error_condition(int __v, const error_category& __cat) noexcept
+    : _M_value(__v), _M_cat(&__cat) { }
+    template<typename _ErrorConditionEnum, typename = typename
+  enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type>
+      error_condition(_ErrorConditionEnum __e) noexcept
+      { *this = make_error_condition(__e); }
+    void
+    assign(int __v, const error_category& __cat) noexcept
+    {
+      _M_value = __v;
+      _M_cat = &__cat;
+    }
+    template<typename _ErrorConditionEnum>
+      typename enable_if<is_error_condition_enum
+    <_ErrorConditionEnum>::value, error_condition&>::type
+      operator=(_ErrorConditionEnum __e) noexcept
+      { return *this = make_error_condition(__e); }
+    void
+    clear() noexcept
+    { assign(0, generic_category()); }
+    int
+    value() const noexcept { return _M_value; }
+    const error_category&
+    category() const noexcept { return *_M_cat; }
+    __attribute ((__abi_tag__ ("cxx11")))
+    string
+    message() const
+    { return category().message(value()); }
+    explicit operator bool() const noexcept
+    { return _M_value != 0; }
+  private:
+    int _M_value;
+    const error_category* _M_cat;
+  };
+  inline error_condition
+  make_error_condition(errc __e) noexcept
+  { return error_condition(static_cast<int>(__e), generic_category()); }
+  inline bool
+  operator<(const error_condition& __lhs,
+     const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category() < __rhs.category()
+     || (__lhs.category() == __rhs.category()
+  && __lhs.value() < __rhs.value()));
+  }
+  inline bool
+  operator==(const error_code& __lhs, const error_code& __rhs) noexcept
+  { return (__lhs.category() == __rhs.category()
+     && __lhs.value() == __rhs.value()); }
+  inline bool
+  operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category().equivalent(__lhs.value(), __rhs)
+     || __rhs.category().equivalent(__lhs, __rhs.value()));
+  }
+  inline bool
+  operator==(const error_condition& __lhs, const error_code& __rhs) noexcept
+  {
+    return (__rhs.category().equivalent(__rhs.value(), __lhs)
+     || __lhs.category().equivalent(__rhs, __lhs.value()));
+  }
+  inline bool
+  operator==(const error_condition& __lhs,
+      const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category() == __rhs.category()
+     && __lhs.value() == __rhs.value());
+  }
+  inline bool
+  operator!=(const error_code& __lhs, const error_code& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+  inline bool
+  operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+  inline bool
+  operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+  inline bool
+  operator!=(const error_condition& __lhs,
+      const error_condition& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+  class system_error : public std::runtime_error
+  {
+  private:
+    error_code _M_code;
+  public:
+    system_error(error_code __ec = error_code())
+    : runtime_error(__ec.message()), _M_code(__ec) { }
+    system_error(error_code __ec, const string& __what)
+    : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { }
+    system_error(error_code __ec, const char* __what)
+    : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }
+    system_error(int __v, const error_category& __ecat, const char* __what)
+    : system_error(error_code(__v, __ecat), __what) { }
+    system_error(int __v, const error_category& __ecat)
+    : runtime_error(error_code(__v, __ecat).message()),
+      _M_code(__v, __ecat) { }
+    system_error(int __v, const error_category& __ecat, const string& __what)
+    : runtime_error(__what + ": " + error_code(__v, __ecat).message()),
+      _M_code(__v, __ecat) { }
+    virtual ~system_error() noexcept;
+    const error_code&
+    code() const noexcept { return _M_code; }
+  };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<>
+    struct hash<error_code>
+    : public __hash_base<size_t, error_code>
+    {
+      size_t
+      operator()(const error_code& __e) const noexcept
+      {
+ const size_t __tmp = std::_Hash_impl::hash(__e._M_value);
+ return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp);
+      }
+    };
+  template<>
+    struct hash<error_condition>
+    : public __hash_base<size_t, error_condition>
+    {
+      size_t
+      operator()(const error_condition& __e) const noexcept
+      {
+ const size_t __tmp = std::_Hash_impl::hash(__e.value());
+ return std::_Hash_impl::__hash_combine(__e.category(), __tmp);
+      }
+    };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  enum _Ios_Fmtflags
+    {
+      _S_boolalpha = 1L << 0,
+      _S_dec = 1L << 1,
+      _S_fixed = 1L << 2,
+      _S_hex = 1L << 3,
+      _S_internal = 1L << 4,
+      _S_left = 1L << 5,
+      _S_oct = 1L << 6,
+      _S_right = 1L << 7,
+      _S_scientific = 1L << 8,
+      _S_showbase = 1L << 9,
+      _S_showpoint = 1L << 10,
+      _S_showpos = 1L << 11,
+      _S_skipws = 1L << 12,
+      _S_unitbuf = 1L << 13,
+      _S_uppercase = 1L << 14,
+      _S_adjustfield = _S_left | _S_right | _S_internal,
+      _S_basefield = _S_dec | _S_oct | _S_hex,
+      _S_floatfield = _S_scientific | _S_fixed,
+      _S_ios_fmtflags_end = 1L << 16,
+      _S_ios_fmtflags_max = 0x7fffffff,
+      _S_ios_fmtflags_min = ~0x7fffffff
+    };
+  inline constexpr _Ios_Fmtflags
+  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
+  inline constexpr _Ios_Fmtflags
+  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
+  inline constexpr _Ios_Fmtflags
+  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+  inline constexpr _Ios_Fmtflags
+  operator~(_Ios_Fmtflags __a)
+  { return _Ios_Fmtflags(~static_cast<int>(__a)); }
+  inline const _Ios_Fmtflags&
+  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a | __b; }
+  inline const _Ios_Fmtflags&
+  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a & __b; }
+  inline const _Ios_Fmtflags&
+  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a ^ __b; }
+  enum _Ios_Openmode
+    {
+      _S_app = 1L << 0,
+      _S_ate = 1L << 1,
+      _S_bin = 1L << 2,
+      _S_in = 1L << 3,
+      _S_out = 1L << 4,
+      _S_trunc = 1L << 5,
+      _S_ios_openmode_end = 1L << 16,
+      _S_ios_openmode_max = 0x7fffffff,
+      _S_ios_openmode_min = ~0x7fffffff
+    };
+  inline constexpr _Ios_Openmode
+  operator&(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
+  inline constexpr _Ios_Openmode
+  operator|(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
+  inline constexpr _Ios_Openmode
+  operator^(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+  inline constexpr _Ios_Openmode
+  operator~(_Ios_Openmode __a)
+  { return _Ios_Openmode(~static_cast<int>(__a)); }
+  inline const _Ios_Openmode&
+  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a | __b; }
+  inline const _Ios_Openmode&
+  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a & __b; }
+  inline const _Ios_Openmode&
+  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a ^ __b; }
+  enum _Ios_Iostate
+    {
+      _S_goodbit = 0,
+      _S_badbit = 1L << 0,
+      _S_eofbit = 1L << 1,
+      _S_failbit = 1L << 2,
+      _S_ios_iostate_end = 1L << 16,
+      _S_ios_iostate_max = 0x7fffffff,
+      _S_ios_iostate_min = ~0x7fffffff
+    };
+  inline constexpr _Ios_Iostate
+  operator&(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
+  inline constexpr _Ios_Iostate
+  operator|(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
+  inline constexpr _Ios_Iostate
+  operator^(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+  inline constexpr _Ios_Iostate
+  operator~(_Ios_Iostate __a)
+  { return _Ios_Iostate(~static_cast<int>(__a)); }
+  inline const _Ios_Iostate&
+  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a | __b; }
+  inline const _Ios_Iostate&
+  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a & __b; }
+  inline const _Ios_Iostate&
+  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a ^ __b; }
+  enum _Ios_Seekdir
+    {
+      _S_beg = 0,
+      _S_cur = 1,
+      _S_end = 2,
+      _S_ios_seekdir_end = 1L << 16
+    };
+  enum class io_errc { stream = 1 };
+  template <> struct is_error_code_enum<io_errc> : public true_type { };
+  const error_category& iostream_category() noexcept;
+  inline error_code
+  make_error_code(io_errc __e) noexcept
+  { return error_code(static_cast<int>(__e), iostream_category()); }
+  inline error_condition
+  make_error_condition(io_errc __e) noexcept
+  { return error_condition(static_cast<int>(__e), iostream_category()); }
+  class ios_base
+  {
+  public:
+    class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error
+    {
+    public:
+      explicit
+      failure(const string& __str);
+      explicit
+      failure(const string&, const error_code&);
+      explicit
+      failure(const char*, const error_code& = io_errc::stream);
+      virtual
+      ~failure() throw();
+      virtual const char*
+      what() const throw();
+    };
+    typedef _Ios_Fmtflags fmtflags;
+    static const fmtflags boolalpha = _S_boolalpha;
+    static const fmtflags dec = _S_dec;
+    static const fmtflags fixed = _S_fixed;
+    static const fmtflags hex = _S_hex;
+    static const fmtflags internal = _S_internal;
+    static const fmtflags left = _S_left;
+    static const fmtflags oct = _S_oct;
+    static const fmtflags right = _S_right;
+    static const fmtflags scientific = _S_scientific;
+    static const fmtflags showbase = _S_showbase;
+    static const fmtflags showpoint = _S_showpoint;
+    static const fmtflags showpos = _S_showpos;
+    static const fmtflags skipws = _S_skipws;
+    static const fmtflags unitbuf = _S_unitbuf;
+    static const fmtflags uppercase = _S_uppercase;
+    static const fmtflags adjustfield = _S_adjustfield;
+    static const fmtflags basefield = _S_basefield;
+    static const fmtflags floatfield = _S_floatfield;
+    typedef _Ios_Iostate iostate;
+    static const iostate badbit = _S_badbit;
+    static const iostate eofbit = _S_eofbit;
+    static const iostate failbit = _S_failbit;
+    static const iostate goodbit = _S_goodbit;
+    typedef _Ios_Openmode openmode;
+    static const openmode app = _S_app;
+    static const openmode ate = _S_ate;
+    static const openmode binary = _S_bin;
+    static const openmode in = _S_in;
+    static const openmode out = _S_out;
+    static const openmode trunc = _S_trunc;
+    typedef _Ios_Seekdir seekdir;
+    static const seekdir beg = _S_beg;
+    static const seekdir cur = _S_cur;
+    static const seekdir end = _S_end;
+    enum event
+    {
+      erase_event,
+      imbue_event,
+      copyfmt_event
+    };
+    typedef void (*event_callback) (event __e, ios_base& __b, int __i);
+    void
+    register_callback(event_callback __fn, int __index);
+  protected:
+    streamsize _M_precision;
+    streamsize _M_width;
+    fmtflags _M_flags;
+    iostate _M_exception;
+    iostate _M_streambuf_state;
+    struct _Callback_list
+    {
+      _Callback_list* _M_next;
+      ios_base::event_callback _M_fn;
+      int _M_index;
+      _Atomic_word _M_refcount;
+      _Callback_list(ios_base::event_callback __fn, int __index,
+       _Callback_list* __cb)
+      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
+      void
+      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+      int
+      _M_remove_reference()
+      {
+        ;
+        int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
+        if (__res == 0)
+          {
+            ;
+          }
+        return __res;
+      }
+    };
+     _Callback_list* _M_callbacks;
+    void
+    _M_call_callbacks(event __ev) throw();
+    void
+    _M_dispose_callbacks(void) throw();
+    struct _Words
+    {
+      void* _M_pword;
+      long _M_iword;
+      _Words() : _M_pword(0), _M_iword(0) { }
+    };
+    _Words _M_word_zero;
+    enum { _S_local_word_size = 8 };
+    _Words _M_local_word[_S_local_word_size];
+    int _M_word_size;
+    _Words* _M_word;
+    _Words&
+    _M_grow_words(int __index, bool __iword);
+    locale _M_ios_locale;
+    void
+    _M_init() throw();
+  public:
+    class Init
+    {
+      friend class ios_base;
+    public:
+      Init();
+      ~Init();
+    private:
+      static _Atomic_word _S_refcount;
+      static bool _S_synced_with_stdio;
+    };
+    fmtflags
+    flags() const
+    { return _M_flags; }
+    fmtflags
+    flags(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags = __fmtfl;
+      return __old;
+    }
+    fmtflags
+    setf(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags |= __fmtfl;
+      return __old;
+    }
+    fmtflags
+    setf(fmtflags __fmtfl, fmtflags __mask)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags &= ~__mask;
+      _M_flags |= (__fmtfl & __mask);
+      return __old;
+    }
+    void
+    unsetf(fmtflags __mask)
+    { _M_flags &= ~__mask; }
+    streamsize
+    precision() const
+    { return _M_precision; }
+    streamsize
+    precision(streamsize __prec)
+    {
+      streamsize __old = _M_precision;
+      _M_precision = __prec;
+      return __old;
+    }
+    streamsize
+    width() const
+    { return _M_width; }
+    streamsize
+    width(streamsize __wide)
+    {
+      streamsize __old = _M_width;
+      _M_width = __wide;
+      return __old;
+    }
+    static bool
+    sync_with_stdio(bool __sync = true);
+    locale
+    imbue(const locale& __loc) throw();
+    locale
+    getloc() const
+    { return _M_ios_locale; }
+    const locale&
+    _M_getloc() const
+    { return _M_ios_locale; }
+    static int
+    xalloc() throw();
+    long&
+    iword(int __ix)
+    {
+      _Words& __word = (__ix < _M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, true);
+      return __word._M_iword;
+    }
+    void*&
+    pword(int __ix)
+    {
+      _Words& __word = (__ix < _M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, false);
+      return __word._M_pword;
+    }
+    virtual ~ios_base();
+  protected:
+    ios_base() throw ();
+  public:
+    ios_base(const ios_base&) = delete;
+    ios_base&
+    operator=(const ios_base&) = delete;
+  protected:
+    void
+    _M_move(ios_base&) noexcept;
+    void
+    _M_swap(ios_base& __rhs) noexcept;
+  };
+  inline ios_base&
+  boolalpha(ios_base& __base)
+  {
+    __base.setf(ios_base::boolalpha);
+    return __base;
+  }
+  inline ios_base&
+  noboolalpha(ios_base& __base)
+  {
+    __base.unsetf(ios_base::boolalpha);
+    return __base;
+  }
+  inline ios_base&
+  showbase(ios_base& __base)
+  {
+    __base.setf(ios_base::showbase);
+    return __base;
+  }
+  inline ios_base&
+  noshowbase(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showbase);
+    return __base;
+  }
+  inline ios_base&
+  showpoint(ios_base& __base)
+  {
+    __base.setf(ios_base::showpoint);
+    return __base;
+  }
+  inline ios_base&
+  noshowpoint(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showpoint);
+    return __base;
+  }
+  inline ios_base&
+  showpos(ios_base& __base)
+  {
+    __base.setf(ios_base::showpos);
+    return __base;
+  }
+  inline ios_base&
+  noshowpos(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showpos);
+    return __base;
+  }
+  inline ios_base&
+  skipws(ios_base& __base)
+  {
+    __base.setf(ios_base::skipws);
+    return __base;
+  }
+  inline ios_base&
+  noskipws(ios_base& __base)
+  {
+    __base.unsetf(ios_base::skipws);
+    return __base;
+  }
+  inline ios_base&
+  uppercase(ios_base& __base)
+  {
+    __base.setf(ios_base::uppercase);
+    return __base;
+  }
+  inline ios_base&
+  nouppercase(ios_base& __base)
+  {
+    __base.unsetf(ios_base::uppercase);
+    return __base;
+  }
+  inline ios_base&
+  unitbuf(ios_base& __base)
+  {
+     __base.setf(ios_base::unitbuf);
+     return __base;
+  }
+  inline ios_base&
+  nounitbuf(ios_base& __base)
+  {
+     __base.unsetf(ios_base::unitbuf);
+     return __base;
+  }
+  inline ios_base&
+  internal(ios_base& __base)
+  {
+     __base.setf(ios_base::internal, ios_base::adjustfield);
+     return __base;
+  }
+  inline ios_base&
+  left(ios_base& __base)
+  {
+    __base.setf(ios_base::left, ios_base::adjustfield);
+    return __base;
+  }
+  inline ios_base&
+  right(ios_base& __base)
+  {
+    __base.setf(ios_base::right, ios_base::adjustfield);
+    return __base;
+  }
+  inline ios_base&
+  dec(ios_base& __base)
+  {
+    __base.setf(ios_base::dec, ios_base::basefield);
+    return __base;
+  }
+  inline ios_base&
+  hex(ios_base& __base)
+  {
+    __base.setf(ios_base::hex, ios_base::basefield);
+    return __base;
+  }
+  inline ios_base&
+  oct(ios_base& __base)
+  {
+    __base.setf(ios_base::oct, ios_base::basefield);
+    return __base;
+  }
+  inline ios_base&
+  fixed(ios_base& __base)
+  {
+    __base.setf(ios_base::fixed, ios_base::floatfield);
+    return __base;
+  }
+  inline ios_base&
+  scientific(ios_base& __base)
+  {
+    __base.setf(ios_base::scientific, ios_base::floatfield);
+    return __base;
+  }
+  inline ios_base&
+  hexfloat(ios_base& __base)
+  {
+    __base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
+    return __base;
+  }
+  inline ios_base&
+  defaultfloat(ios_base& __base)
+  {
+    __base.unsetf(ios_base::floatfield);
+    return __base;
+  }
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
+     basic_streambuf<_CharT, _Traits>*, bool&);
+  template<typename _CharT, typename _Traits>
+    class basic_streambuf
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+      friend class basic_ios<char_type, traits_type>;
+      friend class basic_istream<char_type, traits_type>;
+      friend class basic_ostream<char_type, traits_type>;
+      friend class istreambuf_iterator<char_type, traits_type>;
+      friend class ostreambuf_iterator<char_type, traits_type>;
+      friend streamsize
+      __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
+      template<bool _IsMove, typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            _CharT2*>::__type
+        __copy_move_a2(istreambuf_iterator<_CharT2>,
+         istreambuf_iterator<_CharT2>, _CharT2*);
+      template<typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+      istreambuf_iterator<_CharT2> >::__type
+        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      const _CharT2&);
+      template<typename _CharT2, typename _Distance>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            void>::__type
+        advance(istreambuf_iterator<_CharT2>&, _Distance);
+      template<typename _CharT2, typename _Traits2>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&,
+     basic_string<_CharT2, _Traits2, _Alloc>&);
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        getline(basic_istream<_CharT2, _Traits2>&,
+  basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
+    protected:
+      char_type* _M_in_beg;
+      char_type* _M_in_cur;
+      char_type* _M_in_end;
+      char_type* _M_out_beg;
+      char_type* _M_out_cur;
+      char_type* _M_out_end;
+      locale _M_buf_locale;
+  public:
+      virtual
+      ~basic_streambuf()
+      { }
+      locale
+      pubimbue(const locale& __loc)
+      {
+ locale __tmp(this->getloc());
+ this->imbue(__loc);
+ _M_buf_locale = __loc;
+ return __tmp;
+      }
+      locale
+      getloc() const
+      { return _M_buf_locale; }
+      basic_streambuf*
+      pubsetbuf(char_type* __s, streamsize __n)
+      { return this->setbuf(__s, __n); }
+      pos_type
+      pubseekoff(off_type __off, ios_base::seekdir __way,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekoff(__off, __way, __mode); }
+      pos_type
+      pubseekpos(pos_type __sp,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekpos(__sp, __mode); }
+      int
+      pubsync() { return this->sync(); }
+      streamsize
+      in_avail()
+      {
+ const streamsize __ret = this->egptr() - this->gptr();
+ return __ret ? __ret : this->showmanyc();
+      }
+      int_type
+      snextc()
+      {
+ int_type __ret = traits_type::eof();
+ if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
+             __ret), true))
+   __ret = this->sgetc();
+ return __ret;
+      }
+      int_type
+      sbumpc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ else
+   __ret = this->uflow();
+ return __ret;
+      }
+      int_type
+      sgetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   __ret = traits_type::to_int_type(*this->gptr());
+ else
+   __ret = this->underflow();
+ return __ret;
+      }
+      streamsize
+      sgetn(char_type* __s, streamsize __n)
+      { return this->xsgetn(__s, __n); }
+      int_type
+      sputbackc(char_type __c)
+      {
+ int_type __ret;
+ const bool __testpos = this->eback() < this->gptr();
+ if (__builtin_expect(!__testpos ||
+        !traits_type::eq(__c, this->gptr()[-1]), false))
+   __ret = this->pbackfail(traits_type::to_int_type(__c));
+ else
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ return __ret;
+      }
+      int_type
+      sungetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->eback() < this->gptr(), true))
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ else
+   __ret = this->pbackfail();
+ return __ret;
+      }
+      int_type
+      sputc(char_type __c)
+      {
+ int_type __ret;
+ if (__builtin_expect(this->pptr() < this->epptr(), true))
+   {
+     *this->pptr() = __c;
+     this->pbump(1);
+     __ret = traits_type::to_int_type(__c);
+   }
+ else
+   __ret = this->overflow(traits_type::to_int_type(__c));
+ return __ret;
+      }
+      streamsize
+      sputn(const char_type* __s, streamsize __n)
+      { return this->xsputn(__s, __n); }
+    protected:
+      basic_streambuf()
+      : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
+      _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
+      _M_buf_locale(locale())
+      { }
+      char_type*
+      eback() const { return _M_in_beg; }
+      char_type*
+      gptr() const { return _M_in_cur; }
+      char_type*
+      egptr() const { return _M_in_end; }
+      void
+      gbump(int __n) { _M_in_cur += __n; }
+      void
+      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
+      {
+ _M_in_beg = __gbeg;
+ _M_in_cur = __gnext;
+ _M_in_end = __gend;
+      }
+      char_type*
+      pbase() const { return _M_out_beg; }
+      char_type*
+      pptr() const { return _M_out_cur; }
+      char_type*
+      epptr() const { return _M_out_end; }
+      void
+      pbump(int __n) { _M_out_cur += __n; }
+      void
+      setp(char_type* __pbeg, char_type* __pend)
+      {
+ _M_out_beg = _M_out_cur = __pbeg;
+ _M_out_end = __pend;
+      }
+      virtual void
+      imbue(const locale& __loc __attribute__ ((__unused__)))
+      { }
+      virtual basic_streambuf<char_type,_Traits>*
+      setbuf(char_type*, streamsize)
+      { return this; }
+      virtual pos_type
+      seekoff(off_type, ios_base::seekdir,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+      virtual pos_type
+      seekpos(pos_type,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+      virtual int
+      sync() { return 0; }
+      virtual streamsize
+      showmanyc() { return 0; }
+      virtual streamsize
+      xsgetn(char_type* __s, streamsize __n);
+      virtual int_type
+      underflow()
+      { return traits_type::eof(); }
+      virtual int_type
+      uflow()
+      {
+ int_type __ret = traits_type::eof();
+ const bool __testeof = traits_type::eq_int_type(this->underflow(),
+       __ret);
+ if (!__testeof)
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ return __ret;
+      }
+      virtual int_type
+      pbackfail(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
+      { return traits_type::eof(); }
+      virtual streamsize
+      xsputn(const char_type* __s, streamsize __n);
+      virtual int_type
+      overflow(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
+      { return traits_type::eof(); }
+      void
+      __safe_gbump(streamsize __n) { _M_in_cur += __n; }
+      void
+      __safe_pbump(streamsize __n) { _M_out_cur += __n; }
+    protected:
+      basic_streambuf(const basic_streambuf&);
+      basic_streambuf&
+      operator=(const basic_streambuf&);
+      void
+      swap(basic_streambuf& __sb)
+      {
+ std::swap(_M_in_beg, __sb._M_in_beg);
+ std::swap(_M_in_cur, __sb._M_in_cur);
+ std::swap(_M_in_end, __sb._M_in_end);
+ std::swap(_M_out_beg, __sb._M_out_beg);
+ std::swap(_M_out_cur, __sb._M_out_cur);
+ std::swap(_M_out_end, __sb._M_out_end);
+ std::swap(_M_buf_locale, __sb._M_buf_locale);
+      }
+    };
+  template<typename _CharT, typename _Traits>
+    std::basic_streambuf<_CharT, _Traits>::
+    basic_streambuf(const basic_streambuf&) = default;
+  template<typename _CharT, typename _Traits>
+    std::basic_streambuf<_CharT, _Traits>&
+    std::basic_streambuf<_CharT, _Traits>::
+    operator=(const basic_streambuf&) = default;
+  template<>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<char>* __sbin,
+     basic_streambuf<char>* __sbout, bool& __ineof);
+  template<>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
+     basic_streambuf<wchar_t>* __sbout, bool& __ineof);
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsgetn(char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+ {
+   const streamsize __buf_len = this->egptr() - this->gptr();
+   if (__buf_len)
+     {
+       const streamsize __remaining = __n - __ret;
+       const streamsize __len = std::min(__buf_len, __remaining);
+       traits_type::copy(__s, this->gptr(), __len);
+       __ret += __len;
+       __s += __len;
+       this->__safe_gbump(__len);
+     }
+   if (__ret < __n)
+     {
+       const int_type __c = this->uflow();
+       if (!traits_type::eq_int_type(__c, traits_type::eof()))
+  {
+    traits_type::assign(*__s++, traits_type::to_char_type(__c));
+    ++__ret;
+  }
+       else
+  break;
+     }
+ }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsputn(const char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+ {
+   const streamsize __buf_len = this->epptr() - this->pptr();
+   if (__buf_len)
+     {
+       const streamsize __remaining = __n - __ret;
+       const streamsize __len = std::min(__buf_len, __remaining);
+       traits_type::copy(this->pptr(), __s, __len);
+       __ret += __len;
+       __s += __len;
+       this->__safe_pbump(__len);
+     }
+   if (__ret < __n)
+     {
+       int_type __c = this->overflow(traits_type::to_int_type(*__s));
+       if (!traits_type::eq_int_type(__c, traits_type::eof()))
+  {
+    ++__ret;
+    ++__s;
+  }
+       else
+  break;
+     }
+ }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
+     basic_streambuf<_CharT, _Traits>* __sbout,
+     bool& __ineof)
+    {
+      streamsize __ret = 0;
+      __ineof = true;
+      typename _Traits::int_type __c = __sbin->sgetc();
+      while (!_Traits::eq_int_type(__c, _Traits::eof()))
+ {
+   __c = __sbout->sputc(_Traits::to_char_type(__c));
+   if (_Traits::eq_int_type(__c, _Traits::eof()))
+     {
+       __ineof = false;
+       break;
+     }
+   ++__ret;
+   __c = __sbin->snextc();
+ }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits>
+    inline streamsize
+    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
+        basic_streambuf<_CharT, _Traits>* __sbout)
+    {
+      bool __ineof;
+      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
+    }
+  extern template class basic_streambuf<char>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<char>*,
+        basic_streambuf<char>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<char>*,
+     basic_streambuf<char>*, bool&);
+  extern template class basic_streambuf<wchar_t>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<wchar_t>*,
+        basic_streambuf<wchar_t>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<wchar_t>*,
+     basic_streambuf<wchar_t>*, bool&);
+
+}
+       
+       
+       
+typedef unsigned long int wctype_t;
+enum
+{
+  __ISwupper = 0,
+  __ISwlower = 1,
+  __ISwalpha = 2,
+  __ISwdigit = 3,
+  __ISwxdigit = 4,
+  __ISwspace = 5,
+  __ISwprint = 6,
+  __ISwgraph = 7,
+  __ISwblank = 8,
+  __ISwcntrl = 9,
+  __ISwpunct = 10,
+  __ISwalnum = 11,
+  _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
+  _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
+  _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
+  _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
+  _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
+  _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
+  _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
+  _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
+  _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
+  _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
+  _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
+  _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
+};
+extern "C" {
+extern int iswalnum (wint_t __wc) throw ();
+extern int iswalpha (wint_t __wc) throw ();
+extern int iswcntrl (wint_t __wc) throw ();
+extern int iswdigit (wint_t __wc) throw ();
+extern int iswgraph (wint_t __wc) throw ();
+extern int iswlower (wint_t __wc) throw ();
+extern int iswprint (wint_t __wc) throw ();
+extern int iswpunct (wint_t __wc) throw ();
+extern int iswspace (wint_t __wc) throw ();
+extern int iswupper (wint_t __wc) throw ();
+extern int iswxdigit (wint_t __wc) throw ();
+extern int iswblank (wint_t __wc) throw ();
+extern wctype_t wctype (const char *__property) throw ();
+extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
+extern wint_t towlower (wint_t __wc) throw ();
+extern wint_t towupper (wint_t __wc) throw ();
+}
+extern "C" {
+typedef const __int32_t *wctrans_t;
+extern wctrans_t wctrans (const char *__property) throw ();
+extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
+extern int iswalnum_l (wint_t __wc, locale_t __locale) throw ();
+extern int iswalpha_l (wint_t __wc, locale_t __locale) throw ();
+extern int iswcntrl_l (wint_t __wc, locale_t __locale) throw ();
+extern int iswdigit_l (wint_t __wc, locale_t __locale) throw ();
+extern int iswgraph_l (wint_t __wc, locale_t __locale) throw ();
+extern int iswlower_l (wint_t __wc, locale_t __locale) throw ();
+extern int iswprint_l (wint_t __wc, locale_t __locale) throw ();
+extern int iswpunct_l (wint_t __wc, locale_t __locale) throw ();
+extern int iswspace_l (wint_t __wc, locale_t __locale) throw ();
+extern int iswupper_l (wint_t __wc, locale_t __locale) throw ();
+extern int iswxdigit_l (wint_t __wc, locale_t __locale) throw ();
+extern int iswblank_l (wint_t __wc, locale_t __locale) throw ();
+extern wctype_t wctype_l (const char *__property, locale_t __locale)
+     throw ();
+extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale)
+     throw ();
+extern wint_t towlower_l (wint_t __wc, locale_t __locale) throw ();
+extern wint_t towupper_l (wint_t __wc, locale_t __locale) throw ();
+extern wctrans_t wctrans_l (const char *__property, locale_t __locale)
+     throw ();
+extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
+      locale_t __locale) throw ();
+}
+namespace std
+{
+  using ::wctrans_t;
+  using ::wctype_t;
+  using ::wint_t;
+  using ::iswalnum;
+  using ::iswalpha;
+  using ::iswblank;
+  using ::iswcntrl;
+  using ::iswctype;
+  using ::iswdigit;
+  using ::iswgraph;
+  using ::iswlower;
+  using ::iswprint;
+  using ::iswpunct;
+  using ::iswspace;
+  using ::iswupper;
+  using ::iswxdigit;
+  using ::towctrans;
+  using ::towlower;
+  using ::towupper;
+  using ::wctrans;
+  using ::wctype;
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  struct ctype_base
+  {
+    typedef const int* __to_type;
+    typedef unsigned short mask;
+    static const mask upper = _ISupper;
+    static const mask lower = _ISlower;
+    static const mask alpha = _ISalpha;
+    static const mask digit = _ISdigit;
+    static const mask xdigit = _ISxdigit;
+    static const mask space = _ISspace;
+    static const mask print = _ISprint;
+    static const mask graph = _ISalpha | _ISdigit | _ISpunct;
+    static const mask cntrl = _IScntrl;
+    static const mask punct = _ISpunct;
+    static const mask alnum = _ISalpha | _ISdigit;
+    static const mask blank = _ISblank;
+  };
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT, typename _Traits>
+    class istreambuf_iterator
+    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
+        _CharT*,
+        _CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename _Traits::int_type int_type;
+      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+      typedef basic_istream<_CharT, _Traits> istream_type;
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+        ostreambuf_iterator<_CharT2> >::__type
+ copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      ostreambuf_iterator<_CharT2>);
+      template<bool _IsMove, typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            _CharT2*>::__type
+ __copy_move_a2(istreambuf_iterator<_CharT2>,
+         istreambuf_iterator<_CharT2>, _CharT2*);
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+        istreambuf_iterator<_CharT2> >::__type
+ find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      const _CharT2&);
+      template<typename _CharT2, typename _Distance>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            void>::__type
+ advance(istreambuf_iterator<_CharT2>&, _Distance);
+    private:
+      mutable streambuf_type* _M_sbuf;
+      int_type _M_c;
+    public:
+      constexpr istreambuf_iterator() noexcept
+      : _M_sbuf(0), _M_c(traits_type::eof()) { }
+      istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
+      ~istreambuf_iterator() = default;
+      istreambuf_iterator(istream_type& __s) noexcept
+      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
+      istreambuf_iterator(streambuf_type* __s) noexcept
+      : _M_sbuf(__s), _M_c(traits_type::eof()) { }
+      char_type
+      operator*() const
+      {
+ int_type __c = _M_get();
+ return traits_type::to_char_type(__c);
+      }
+      istreambuf_iterator&
+      operator++()
+      {
+ ;
+ _M_sbuf->sbumpc();
+ _M_c = traits_type::eof();
+ return *this;
+      }
+      istreambuf_iterator
+      operator++(int)
+      {
+ ;
+ istreambuf_iterator __old = *this;
+ __old._M_c = _M_sbuf->sbumpc();
+ _M_c = traits_type::eof();
+ return __old;
+      }
+      bool
+      equal(const istreambuf_iterator& __b) const
+      { return _M_at_eof() == __b._M_at_eof(); }
+    private:
+      int_type
+      _M_get() const
+      {
+ int_type __ret = _M_c;
+ if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret = _M_sbuf->sgetc()))
+   _M_sbuf = 0;
+ return __ret;
+      }
+      bool
+      _M_at_eof() const
+      { return _S_is_eof(_M_get()); }
+      static bool
+      _S_is_eof(int_type __c)
+      {
+ const int_type __eof = traits_type::eof();
+ return traits_type::eq_int_type(__c, __eof);
+      }
+    };
+  template<typename _CharT, typename _Traits>
+    inline bool
+    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
+        const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return __a.equal(__b); }
+  template<typename _CharT, typename _Traits>
+    inline bool
+    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
+        const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return !__a.equal(__b); }
+  template<typename _CharT, typename _Traits>
+    class ostreambuf_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+      typedef basic_ostream<_CharT, _Traits> ostream_type;
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+        ostreambuf_iterator<_CharT2> >::__type
+ copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      ostreambuf_iterator<_CharT2>);
+    private:
+      streambuf_type* _M_sbuf;
+      bool _M_failed;
+    public:
+      ostreambuf_iterator(ostream_type& __s) noexcept
+      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
+      ostreambuf_iterator(streambuf_type* __s) noexcept
+      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
+      ostreambuf_iterator&
+      operator=(_CharT __c)
+      {
+ if (!_M_failed &&
+     _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
+   _M_failed = true;
+ return *this;
+      }
+      ostreambuf_iterator&
+      operator*()
+      { return *this; }
+      ostreambuf_iterator&
+      operator++(int)
+      { return *this; }
+      ostreambuf_iterator&
+      operator++()
+      { return *this; }
+      bool
+      failed() const noexcept
+      { return _M_failed; }
+      ostreambuf_iterator&
+      _M_put(const _CharT* __ws, streamsize __len)
+      {
+ if (__builtin_expect(!_M_failed, true)
+     && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
+    false))
+   _M_failed = true;
+ return *this;
+      }
+    };
+  template<typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        ostreambuf_iterator<_CharT> >::__type
+    copy(istreambuf_iterator<_CharT> __first,
+  istreambuf_iterator<_CharT> __last,
+  ostreambuf_iterator<_CharT> __result)
+    {
+      if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
+ {
+   bool __ineof;
+   __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
+   if (!__ineof)
+     __result._M_failed = true;
+ }
+      return __result;
+    }
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        ostreambuf_iterator<_CharT> >::__type
+    __copy_move_a2(_CharT* __first, _CharT* __last,
+     ostreambuf_iterator<_CharT> __result)
+    {
+      const streamsize __num = __last - __first;
+      if (__num > 0)
+ __result._M_put(__first, __num);
+      return __result;
+    }
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        ostreambuf_iterator<_CharT> >::__type
+    __copy_move_a2(const _CharT* __first, const _CharT* __last,
+     ostreambuf_iterator<_CharT> __result)
+    {
+      const streamsize __num = __last - __first;
+      if (__num > 0)
+ __result._M_put(__first, __num);
+      return __result;
+    }
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        _CharT*>::__type
+    __copy_move_a2(istreambuf_iterator<_CharT> __first,
+     istreambuf_iterator<_CharT> __last, _CharT* __result)
+    {
+      typedef istreambuf_iterator<_CharT> __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type traits_type;
+      typedef typename __is_iterator_type::streambuf_type streambuf_type;
+      typedef typename traits_type::int_type int_type;
+      if (__first._M_sbuf && !__last._M_sbuf)
+ {
+   streambuf_type* __sb = __first._M_sbuf;
+   int_type __c = __sb->sgetc();
+   while (!traits_type::eq_int_type(__c, traits_type::eof()))
+     {
+       const streamsize __n = __sb->egptr() - __sb->gptr();
+       if (__n > 1)
+  {
+    traits_type::copy(__result, __sb->gptr(), __n);
+    __sb->__safe_gbump(__n);
+    __result += __n;
+    __c = __sb->underflow();
+  }
+       else
+  {
+    *__result++ = traits_type::to_char_type(__c);
+    __c = __sb->snextc();
+  }
+     }
+ }
+      return __result;
+    }
+  template<typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+          istreambuf_iterator<_CharT> >::__type
+    find(istreambuf_iterator<_CharT> __first,
+  istreambuf_iterator<_CharT> __last, const _CharT& __val)
+    {
+      typedef istreambuf_iterator<_CharT> __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type traits_type;
+      typedef typename __is_iterator_type::streambuf_type streambuf_type;
+      typedef typename traits_type::int_type int_type;
+      const int_type __eof = traits_type::eof();
+      if (__first._M_sbuf && !__last._M_sbuf)
+ {
+   const int_type __ival = traits_type::to_int_type(__val);
+   streambuf_type* __sb = __first._M_sbuf;
+   int_type __c = __sb->sgetc();
+   while (!traits_type::eq_int_type(__c, __eof)
+   && !traits_type::eq_int_type(__c, __ival))
+     {
+       streamsize __n = __sb->egptr() - __sb->gptr();
+       if (__n > 1)
+  {
+    const _CharT* __p = traits_type::find(__sb->gptr(),
+       __n, __val);
+    if (__p)
+      __n = __p - __sb->gptr();
+    __sb->__safe_gbump(__n);
+    __c = __sb->sgetc();
+  }
+       else
+  __c = __sb->snextc();
+     }
+   __first._M_c = __eof;
+ }
+      return __first;
+    }
+  template<typename _CharT, typename _Distance>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        void>::__type
+    advance(istreambuf_iterator<_CharT>& __i, _Distance __n)
+    {
+      if (__n == 0)
+ return;
+      ;
+      ;
+      typedef istreambuf_iterator<_CharT> __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type traits_type;
+      typedef typename __is_iterator_type::streambuf_type streambuf_type;
+      typedef typename traits_type::int_type int_type;
+      const int_type __eof = traits_type::eof();
+      streambuf_type* __sb = __i._M_sbuf;
+      while (__n > 0)
+ {
+   streamsize __size = __sb->egptr() - __sb->gptr();
+   if (__size > __n)
+     {
+       __sb->__safe_gbump(__n);
+       break;
+     }
+   __sb->__safe_gbump(__size);
+   __n -= __size;
+   if (traits_type::eq_int_type(__sb->underflow(), __eof))
+     {
+       ;
+       break;
+     }
+ }
+      __i._M_c = __eof;
+    }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp>
+    void
+    __convert_to_v(const char*, _Tp&, ios_base::iostate&,
+     const __c_locale&) throw();
+  template<>
+    void
+    __convert_to_v(const char*, float&, ios_base::iostate&,
+     const __c_locale&) throw();
+  template<>
+    void
+    __convert_to_v(const char*, double&, ios_base::iostate&,
+     const __c_locale&) throw();
+  template<>
+    void
+    __convert_to_v(const char*, long double&, ios_base::iostate&,
+     const __c_locale&) throw();
+  template<typename _CharT, typename _Traits>
+    struct __pad
+    {
+      static void
+      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
+      const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
+    };
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+     const char* __gbeg, size_t __gsize,
+     const _CharT* __first, const _CharT* __last);
+  template<typename _CharT>
+    inline
+    ostreambuf_iterator<_CharT>
+    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
+    {
+      __s._M_put(__ws, __len);
+      return __s;
+    }
+  template<typename _CharT, typename _OutIter>
+    inline
+    _OutIter
+    __write(_OutIter __s, const _CharT* __ws, int __len)
+    {
+      for (int __j = 0; __j < __len; __j++, ++__s)
+ *__s = __ws[__j];
+      return __s;
+    }
+  template<typename _CharT>
+    class __ctype_abstract_base : public locale::facet, public ctype_base
+    {
+    public:
+      typedef _CharT char_type;
+      bool
+      is(mask __m, char_type __c) const
+      { return this->do_is(__m, __c); }
+      const char_type*
+      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
+      { return this->do_is(__lo, __hi, __vec); }
+      const char_type*
+      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_is(__m, __lo, __hi); }
+      const char_type*
+      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_not(__m, __lo, __hi); }
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+      char_type
+      widen(char __c) const
+      { return this->do_widen(__c); }
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      { return this->do_widen(__lo, __hi, __to); }
+      char
+      narrow(char_type __c, char __dfault) const
+      { return this->do_narrow(__c, __dfault); }
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+       char __dfault, char* __to) const
+      { return this->do_narrow(__lo, __hi, __dfault, __to); }
+    protected:
+      explicit
+      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
+      virtual
+      ~__ctype_abstract_base() { }
+      virtual bool
+      do_is(mask __m, char_type __c) const = 0;
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi,
+     mask* __vec) const = 0;
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo,
+   const char_type* __hi) const = 0;
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const = 0;
+      virtual char_type
+      do_toupper(char_type __c) const = 0;
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
+      virtual char_type
+      do_tolower(char_type __c) const = 0;
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
+      virtual char_type
+      do_widen(char __c) const = 0;
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
+      virtual char
+      do_narrow(char_type __c, char __dfault) const = 0;
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const = 0;
+    };
+  template<typename _CharT>
+    class ctype : public __ctype_abstract_base<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef typename __ctype_abstract_base<_CharT>::mask mask;
+      static locale::id id;
+      explicit
+      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
+   protected:
+      virtual
+      ~ctype();
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const;
+      virtual char_type
+      do_toupper(char_type __c) const;
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+      virtual char_type
+      do_tolower(char_type __c) const;
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+      virtual char_type
+      do_widen(char __c) const;
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
+      virtual char
+      do_narrow(char_type, char __dfault) const;
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const;
+    };
+  template<typename _CharT>
+    locale::id ctype<_CharT>::id;
+  template<>
+    class ctype<char> : public locale::facet, public ctype_base
+    {
+    public:
+      typedef char char_type;
+    protected:
+      __c_locale _M_c_locale_ctype;
+      bool _M_del;
+      __to_type _M_toupper;
+      __to_type _M_tolower;
+      const mask* _M_table;
+      mutable char _M_widen_ok;
+      mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
+      mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
+      mutable char _M_narrow_ok;
+    public:
+      static locale::id id;
+      static const size_t table_size = 1 + static_cast<unsigned char>(-1);
+      explicit
+      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
+      explicit
+      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
+     size_t __refs = 0);
+      inline bool
+      is(mask __m, char __c) const;
+      inline const char*
+      is(const char* __lo, const char* __hi, mask* __vec) const;
+      inline const char*
+      scan_is(mask __m, const char* __lo, const char* __hi) const;
+      inline const char*
+      scan_not(mask __m, const char* __lo, const char* __hi) const;
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+      char_type
+      widen(char __c) const
+      {
+ if (_M_widen_ok)
+   return _M_widen[static_cast<unsigned char>(__c)];
+ this->_M_widen_init();
+ return this->do_widen(__c);
+      }
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+ if (_M_widen_ok == 1)
+   {
+     if (__builtin_expect(__hi != __lo, true))
+       __builtin_memcpy(__to, __lo, __hi - __lo);
+     return __hi;
+   }
+ if (!_M_widen_ok)
+   _M_widen_init();
+ return this->do_widen(__lo, __hi, __to);
+      }
+      char
+      narrow(char_type __c, char __dfault) const
+      {
+ if (_M_narrow[static_cast<unsigned char>(__c)])
+   return _M_narrow[static_cast<unsigned char>(__c)];
+ const char __t = do_narrow(__c, __dfault);
+ if (__t != __dfault)
+   _M_narrow[static_cast<unsigned char>(__c)] = __t;
+ return __t;
+      }
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+      char __dfault, char* __to) const
+      {
+ if (__builtin_expect(_M_narrow_ok == 1, true))
+   {
+     if (__builtin_expect(__hi != __lo, true))
+       __builtin_memcpy(__to, __lo, __hi - __lo);
+     return __hi;
+   }
+ if (!_M_narrow_ok)
+   _M_narrow_init();
+ return this->do_narrow(__lo, __hi, __dfault, __to);
+      }
+      const mask*
+      table() const throw()
+      { return _M_table; }
+      static const mask*
+      classic_table() throw();
+    protected:
+      virtual
+      ~ctype();
+      virtual char_type
+      do_toupper(char_type __c) const;
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+      virtual char_type
+      do_tolower(char_type __c) const;
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+      virtual char_type
+      do_widen(char __c) const
+      { return __c; }
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+ if (__builtin_expect(__hi != __lo, true))
+   __builtin_memcpy(__to, __lo, __hi - __lo);
+ return __hi;
+      }
+      virtual char
+      do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const
+      { return __c; }
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault __attribute__((__unused__)), char* __to) const
+      {
+ if (__builtin_expect(__hi != __lo, true))
+   __builtin_memcpy(__to, __lo, __hi - __lo);
+ return __hi;
+      }
+    private:
+      void _M_narrow_init() const;
+      void _M_widen_init() const;
+    };
+  template<>
+    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
+    {
+    public:
+      typedef wchar_t char_type;
+      typedef wctype_t __wmask_type;
+    protected:
+      __c_locale _M_c_locale_ctype;
+      bool _M_narrow_ok;
+      char _M_narrow[128];
+      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
+      mask _M_bit[16];
+      __wmask_type _M_wmask[16];
+    public:
+      static locale::id id;
+      explicit
+      ctype(size_t __refs = 0);
+      explicit
+      ctype(__c_locale __cloc, size_t __refs = 0);
+    protected:
+      __wmask_type
+      _M_convert_to_wmask(const mask __m) const throw();
+      virtual
+      ~ctype();
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const;
+      virtual char_type
+      do_toupper(char_type __c) const;
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+      virtual char_type
+      do_tolower(char_type __c) const;
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+      virtual char_type
+      do_widen(char __c) const;
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const;
+      virtual char
+      do_narrow(char_type __c, char __dfault) const;
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const;
+      void
+      _M_initialize_ctype() throw();
+    };
+  template<typename _CharT>
+    class ctype_byname : public ctype<_CharT>
+    {
+    public:
+      typedef typename ctype<_CharT>::mask mask;
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+      explicit
+      ctype_byname(const string& __s, size_t __refs = 0)
+      : ctype_byname(__s.c_str(), __refs) { }
+    protected:
+      virtual
+      ~ctype_byname() { }
+    };
+  template<>
+    class ctype_byname<char> : public ctype<char>
+    {
+    public:
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+      explicit
+      ctype_byname(const string& __s, size_t __refs = 0);
+    protected:
+      virtual
+      ~ctype_byname();
+    };
+  template<>
+    class ctype_byname<wchar_t> : public ctype<wchar_t>
+    {
+    public:
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+      explicit
+      ctype_byname(const string& __s, size_t __refs = 0);
+    protected:
+      virtual
+      ~ctype_byname();
+    };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  bool
+  ctype<char>::
+  is(mask __m, char __c) const
+  { return _M_table[static_cast<unsigned char>(__c)] & __m; }
+  const char*
+  ctype<char>::
+  is(const char* __low, const char* __high, mask* __vec) const
+  {
+    while (__low < __high)
+      *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
+    return __high;
+  }
+  const char*
+  ctype<char>::
+  scan_is(mask __m, const char* __low, const char* __high) const
+  {
+    while (__low < __high
+    && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
+      ++__low;
+    return __low;
+  }
+  const char*
+  ctype<char>::
+  scan_not(mask __m, const char* __low, const char* __high) const
+  {
+    while (__low < __high
+    && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
+      ++__low;
+    return __low;
+  }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  class __num_base
+  {
+  public:
+    enum
+      {
+ _S_ominus,
+ _S_oplus,
+ _S_ox,
+ _S_oX,
+ _S_odigits,
+ _S_odigits_end = _S_odigits + 16,
+ _S_oudigits = _S_odigits_end,
+ _S_oudigits_end = _S_oudigits + 16,
+ _S_oe = _S_odigits + 14,
+ _S_oE = _S_oudigits + 14,
+ _S_oend = _S_oudigits_end
+      };
+    static const char* _S_atoms_out;
+    static const char* _S_atoms_in;
+    enum
+    {
+      _S_iminus,
+      _S_iplus,
+      _S_ix,
+      _S_iX,
+      _S_izero,
+      _S_ie = _S_izero + 14,
+      _S_iE = _S_izero + 20,
+      _S_iend = 26
+    };
+    static void
+    _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
+  };
+  template<typename _CharT>
+    struct __numpunct_cache : public locale::facet
+    {
+      const char* _M_grouping;
+      size_t _M_grouping_size;
+      bool _M_use_grouping;
+      const _CharT* _M_truename;
+      size_t _M_truename_size;
+      const _CharT* _M_falsename;
+      size_t _M_falsename_size;
+      _CharT _M_decimal_point;
+      _CharT _M_thousands_sep;
+      _CharT _M_atoms_out[__num_base::_S_oend];
+      _CharT _M_atoms_in[__num_base::_S_iend];
+      bool _M_allocated;
+      __numpunct_cache(size_t __refs = 0)
+      : facet(__refs), _M_grouping(0), _M_grouping_size(0),
+ _M_use_grouping(false),
+ _M_truename(0), _M_truename_size(0), _M_falsename(0),
+ _M_falsename_size(0), _M_decimal_point(_CharT()),
+ _M_thousands_sep(_CharT()), _M_allocated(false)
+ { }
+      ~__numpunct_cache();
+      void
+      _M_cache(const locale& __loc);
+    private:
+      __numpunct_cache&
+      operator=(const __numpunct_cache&);
+      explicit
+      __numpunct_cache(const __numpunct_cache&);
+    };
+  template<typename _CharT>
+    __numpunct_cache<_CharT>::~__numpunct_cache()
+    {
+      if (_M_allocated)
+ {
+   delete [] _M_grouping;
+   delete [] _M_truename;
+   delete [] _M_falsename;
+ }
+    }
+namespace __cxx11 {
+  template<typename _CharT>
+    class numpunct : public locale::facet
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+      typedef __numpunct_cache<_CharT> __cache_type;
+    protected:
+      __cache_type* _M_data;
+    public:
+      static locale::id id;
+      explicit
+      numpunct(size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_numpunct(); }
+      explicit
+      numpunct(__cache_type* __cache, size_t __refs = 0)
+      : facet(__refs), _M_data(__cache)
+      { _M_initialize_numpunct(); }
+      explicit
+      numpunct(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_numpunct(__cloc); }
+      char_type
+      decimal_point() const
+      { return this->do_decimal_point(); }
+      char_type
+      thousands_sep() const
+      { return this->do_thousands_sep(); }
+      string
+      grouping() const
+      { return this->do_grouping(); }
+      string_type
+      truename() const
+      { return this->do_truename(); }
+      string_type
+      falsename() const
+      { return this->do_falsename(); }
+    protected:
+      virtual
+      ~numpunct();
+      virtual char_type
+      do_decimal_point() const
+      { return _M_data->_M_decimal_point; }
+      virtual char_type
+      do_thousands_sep() const
+      { return _M_data->_M_thousands_sep; }
+      virtual string
+      do_grouping() const
+      { return _M_data->_M_grouping; }
+      virtual string_type
+      do_truename() const
+      { return _M_data->_M_truename; }
+      virtual string_type
+      do_falsename() const
+      { return _M_data->_M_falsename; }
+      void
+      _M_initialize_numpunct(__c_locale __cloc = 0);
+    };
+  template<typename _CharT>
+    locale::id numpunct<_CharT>::id;
+  template<>
+    numpunct<char>::~numpunct();
+  template<>
+    void
+    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
+  template<>
+    numpunct<wchar_t>::~numpunct();
+  template<>
+    void
+    numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
+  template<typename _CharT>
+    class numpunct_byname : public numpunct<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+      explicit
+      numpunct_byname(const char* __s, size_t __refs = 0)
+      : numpunct<_CharT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     __c_locale __tmp;
+     this->_S_create_c_locale(__tmp, __s);
+     this->_M_initialize_numpunct(__tmp);
+     this->_S_destroy_c_locale(__tmp);
+   }
+      }
+      explicit
+      numpunct_byname(const string& __s, size_t __refs = 0)
+      : numpunct_byname(__s.c_str(), __refs) { }
+    protected:
+      virtual
+      ~numpunct_byname() { }
+    };
+}
+
+  template<typename _CharT, typename _InIter>
+    class num_get : public locale::facet
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+      static locale::id id;
+      explicit
+      num_get(size_t __refs = 0) : facet(__refs) { }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, bool& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned short& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned int& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, float& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, void*& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+    protected:
+      virtual ~num_get() { }
+      __attribute ((__abi_tag__ ("cxx11")))
+      iter_type
+      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
+         string&) const;
+      template<typename _ValueT>
+ __attribute ((__abi_tag__ ("cxx11")))
+ iter_type
+ _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
+         _ValueT&) const;
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
+ _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
+ {
+   int __ret = -1;
+   if (__len <= 10)
+     {
+       if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
+  __ret = __c - _CharT2('0');
+     }
+   else
+     {
+       if (__c >= _CharT2('0') && __c <= _CharT2('9'))
+  __ret = __c - _CharT2('0');
+       else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
+  __ret = 10 + (__c - _CharT2('a'));
+       else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
+  __ret = 10 + (__c - _CharT2('A'));
+     }
+   return __ret;
+ }
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
+          int>::__type
+ _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
+ {
+   int __ret = -1;
+   const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
+   if (__q)
+     {
+       __ret = __q - __zero;
+       if (__ret > 15)
+  __ret -= 6;
+     }
+   return __ret;
+ }
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned short& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned int& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+      double&) const;
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+      long double&) const;
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
+    };
+  template<typename _CharT, typename _InIter>
+    locale::id num_get<_CharT, _InIter>::id;
+  template<typename _CharT, typename _OutIter>
+    class num_put : public locale::facet
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+      static locale::id id;
+      explicit
+      num_put(size_t __refs = 0) : facet(__refs) { }
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   unsigned long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   unsigned long long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   long double __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   const void* __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+    protected:
+      template<typename _ValueT>
+ iter_type
+ _M_insert_float(iter_type, ios_base& __io, char_type __fill,
+   char __mod, _ValueT __v) const;
+      void
+      _M_group_float(const char* __grouping, size_t __grouping_size,
+       char_type __sep, const char_type* __p, char_type* __new,
+       char_type* __cs, int& __len) const;
+      template<typename _ValueT>
+ iter_type
+ _M_insert_int(iter_type, ios_base& __io, char_type __fill,
+        _ValueT __v) const;
+      void
+      _M_group_int(const char* __grouping, size_t __grouping_size,
+     char_type __sep, ios_base& __io, char_type* __new,
+     char_type* __cs, int& __len) const;
+      void
+      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
+      char_type* __new, const char_type* __cs, int& __len) const;
+      virtual
+      ~num_put() { }
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      unsigned long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      unsigned long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, double) const;
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, long double) const;
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, const void*) const;
+    };
+  template <typename _CharT, typename _OutIter>
+    locale::id num_put<_CharT, _OutIter>::id;
+
+  template<typename _CharT>
+    inline bool
+    isspace(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
+  template<typename _CharT>
+    inline bool
+    isprint(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
+  template<typename _CharT>
+    inline bool
+    iscntrl(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
+  template<typename _CharT>
+    inline bool
+    isupper(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
+  template<typename _CharT>
+    inline bool
+    islower(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
+  template<typename _CharT>
+    inline bool
+    isalpha(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
+  template<typename _CharT>
+    inline bool
+    isdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
+  template<typename _CharT>
+    inline bool
+    ispunct(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
+  template<typename _CharT>
+    inline bool
+    isxdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
+  template<typename _CharT>
+    inline bool
+    isalnum(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
+  template<typename _CharT>
+    inline bool
+    isgraph(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
+  template<typename _CharT>
+    inline bool
+    isblank(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }
+  template<typename _CharT>
+    inline _CharT
+    toupper(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
+  template<typename _CharT>
+    inline _CharT
+    tolower(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Facet>
+    struct __use_cache
+    {
+      const _Facet*
+      operator() (const locale& __loc) const;
+    };
+  template<typename _CharT>
+    struct __use_cache<__numpunct_cache<_CharT> >
+    {
+      const __numpunct_cache<_CharT>*
+      operator() (const locale& __loc) const
+      {
+ const size_t __i = numpunct<_CharT>::id._M_id();
+ const locale::facet** __caches = __loc._M_impl->_M_caches;
+ if (!__caches[__i])
+   {
+     __numpunct_cache<_CharT>* __tmp = 0;
+     try
+       {
+  __tmp = new __numpunct_cache<_CharT>;
+  __tmp->_M_cache(__loc);
+       }
+     catch(...)
+       {
+  delete __tmp;
+  throw;
+       }
+     __loc._M_impl->_M_install_cache(__tmp, __i);
+   }
+ return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
+      }
+    };
+  template<typename _CharT>
+    void
+    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
+    {
+      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
+      char* __grouping = 0;
+      _CharT* __truename = 0;
+      _CharT* __falsename = 0;
+      try
+ {
+   const string& __g = __np.grouping();
+   _M_grouping_size = __g.size();
+   __grouping = new char[_M_grouping_size];
+   __g.copy(__grouping, _M_grouping_size);
+   _M_use_grouping = (_M_grouping_size
+        && static_cast<signed char>(__grouping[0]) > 0
+        && (__grouping[0]
+     != __gnu_cxx::__numeric_traits<char>::__max));
+   const basic_string<_CharT>& __tn = __np.truename();
+   _M_truename_size = __tn.size();
+   __truename = new _CharT[_M_truename_size];
+   __tn.copy(__truename, _M_truename_size);
+   const basic_string<_CharT>& __fn = __np.falsename();
+   _M_falsename_size = __fn.size();
+   __falsename = new _CharT[_M_falsename_size];
+   __fn.copy(__falsename, _M_falsename_size);
+   _M_decimal_point = __np.decimal_point();
+   _M_thousands_sep = __np.thousands_sep();
+   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
+   __ct.widen(__num_base::_S_atoms_out,
+       __num_base::_S_atoms_out
+       + __num_base::_S_oend, _M_atoms_out);
+   __ct.widen(__num_base::_S_atoms_in,
+       __num_base::_S_atoms_in
+       + __num_base::_S_iend, _M_atoms_in);
+   _M_grouping = __grouping;
+   _M_truename = __truename;
+   _M_falsename = __falsename;
+   _M_allocated = true;
+ }
+      catch(...)
+ {
+   delete [] __grouping;
+   delete [] __truename;
+   delete [] __falsename;
+   throw;
+ }
+    }
+  __attribute__ ((__pure__)) bool
+  __verify_grouping(const char* __grouping, size_t __grouping_size,
+      const string& __grouping_tmp) throw ();
+
+  template<typename _CharT, typename _InIter>
+    __attribute ((__abi_tag__ ("cxx11")))
+    _InIter
+    num_get<_CharT, _InIter>::
+    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
+       ios_base::iostate& __err, string& __xtrc) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      typedef __numpunct_cache<_CharT> __cache_type;
+      __use_cache<__cache_type> __uc;
+      const locale& __loc = __io._M_getloc();
+      const __cache_type* __lc = __uc(__loc);
+      const _CharT* __lit = __lc->_M_atoms_in;
+      char_type __c = char_type();
+      bool __testeof = __beg == __end;
+      if (!__testeof)
+ {
+   __c = *__beg;
+   const bool __plus = __c == __lit[__num_base::_S_iplus];
+   if ((__plus || __c == __lit[__num_base::_S_iminus])
+       && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       && !(__c == __lc->_M_decimal_point))
+     {
+       __xtrc += __plus ? '+' : '-';
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ }
+      bool __found_mantissa = false;
+      int __sep_pos = 0;
+      while (!__testeof)
+ {
+   if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       || __c == __lc->_M_decimal_point)
+     break;
+   else if (__c == __lit[__num_base::_S_izero])
+     {
+       if (!__found_mantissa)
+  {
+    __xtrc += '0';
+    __found_mantissa = true;
+  }
+       ++__sep_pos;
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+   else
+     break;
+ }
+      bool __found_dec = false;
+      bool __found_sci = false;
+      string __found_grouping;
+      if (__lc->_M_use_grouping)
+ __found_grouping.reserve(32);
+      const char_type* __lit_zero = __lit + __num_base::_S_izero;
+      if (!__lc->_M_allocated)
+ while (!__testeof)
+   {
+     const int __digit = _M_find(__lit_zero, 10, __c);
+     if (__digit != -1)
+       {
+  __xtrc += '0' + __digit;
+  __found_mantissa = true;
+       }
+     else if (__c == __lc->_M_decimal_point
+       && !__found_dec && !__found_sci)
+       {
+  __xtrc += '.';
+  __found_dec = true;
+       }
+     else if ((__c == __lit[__num_base::_S_ie]
+        || __c == __lit[__num_base::_S_iE])
+       && !__found_sci && __found_mantissa)
+       {
+  __xtrc += 'e';
+  __found_sci = true;
+  if (++__beg != __end)
+    {
+      __c = *__beg;
+      const bool __plus = __c == __lit[__num_base::_S_iplus];
+      if (__plus || __c == __lit[__num_base::_S_iminus])
+        __xtrc += __plus ? '+' : '-';
+      else
+        continue;
+    }
+  else
+    {
+      __testeof = true;
+      break;
+    }
+       }
+     else
+       break;
+     if (++__beg != __end)
+       __c = *__beg;
+     else
+       __testeof = true;
+   }
+      else
+ while (!__testeof)
+   {
+     if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       {
+  if (!__found_dec && !__found_sci)
+    {
+      if (__sep_pos)
+        {
+   __found_grouping += static_cast<char>(__sep_pos);
+   __sep_pos = 0;
+        }
+      else
+        {
+   __xtrc.clear();
+   break;
+        }
+    }
+  else
+    break;
+       }
+     else if (__c == __lc->_M_decimal_point)
+       {
+  if (!__found_dec && !__found_sci)
+    {
+      if (__found_grouping.size())
+        __found_grouping += static_cast<char>(__sep_pos);
+      __xtrc += '.';
+      __found_dec = true;
+    }
+  else
+    break;
+       }
+     else
+       {
+  const char_type* __q =
+    __traits_type::find(__lit_zero, 10, __c);
+  if (__q)
+    {
+      __xtrc += '0' + (__q - __lit_zero);
+      __found_mantissa = true;
+      ++__sep_pos;
+    }
+  else if ((__c == __lit[__num_base::_S_ie]
+     || __c == __lit[__num_base::_S_iE])
+    && !__found_sci && __found_mantissa)
+    {
+      if (__found_grouping.size() && !__found_dec)
+        __found_grouping += static_cast<char>(__sep_pos);
+      __xtrc += 'e';
+      __found_sci = true;
+      if (++__beg != __end)
+        {
+   __c = *__beg;
+   const bool __plus = __c == __lit[__num_base::_S_iplus];
+   if ((__plus || __c == __lit[__num_base::_S_iminus])
+       && !(__lc->_M_use_grouping
+     && __c == __lc->_M_thousands_sep)
+       && !(__c == __lc->_M_decimal_point))
+        __xtrc += __plus ? '+' : '-';
+   else
+     continue;
+        }
+      else
+        {
+   __testeof = true;
+   break;
+        }
+    }
+  else
+    break;
+       }
+     if (++__beg != __end)
+       __c = *__beg;
+     else
+       __testeof = true;
+   }
+      if (__found_grouping.size())
+        {
+   if (!__found_dec && !__found_sci)
+     __found_grouping += static_cast<char>(__sep_pos);
+          if (!std::__verify_grouping(__lc->_M_grouping,
+          __lc->_M_grouping_size,
+          __found_grouping))
+     __err = ios_base::failbit;
+        }
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    template<typename _ValueT>
+      __attribute ((__abi_tag__ ("cxx11")))
+      _InIter
+      num_get<_CharT, _InIter>::
+      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
+       ios_base::iostate& __err, _ValueT& __v) const
+      {
+        typedef char_traits<_CharT> __traits_type;
+ using __gnu_cxx::__add_unsigned;
+ typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const _CharT* __lit = __lc->_M_atoms_in;
+ char_type __c = char_type();
+ const ios_base::fmtflags __basefield = __io.flags()
+                                        & ios_base::basefield;
+ const bool __oct = __basefield == ios_base::oct;
+ int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
+ bool __testeof = __beg == __end;
+ bool __negative = false;
+ if (!__testeof)
+   {
+     __c = *__beg;
+     __negative = __c == __lit[__num_base::_S_iminus];
+     if ((__negative || __c == __lit[__num_base::_S_iplus])
+  && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  && !(__c == __lc->_M_decimal_point))
+       {
+  if (++__beg != __end)
+    __c = *__beg;
+  else
+    __testeof = true;
+       }
+   }
+ bool __found_zero = false;
+ int __sep_pos = 0;
+ while (!__testeof)
+   {
+     if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  || __c == __lc->_M_decimal_point)
+       break;
+     else if (__c == __lit[__num_base::_S_izero]
+       && (!__found_zero || __base == 10))
+       {
+  __found_zero = true;
+  ++__sep_pos;
+  if (__basefield == 0)
+    __base = 8;
+  if (__base == 8)
+    __sep_pos = 0;
+       }
+     else if (__found_zero
+       && (__c == __lit[__num_base::_S_ix]
+    || __c == __lit[__num_base::_S_iX]))
+       {
+  if (__basefield == 0)
+    __base = 16;
+  if (__base == 16)
+    {
+      __found_zero = false;
+      __sep_pos = 0;
+    }
+  else
+    break;
+       }
+     else
+       break;
+     if (++__beg != __end)
+       {
+  __c = *__beg;
+  if (!__found_zero)
+    break;
+       }
+     else
+       __testeof = true;
+   }
+ const size_t __len = (__base == 16 ? __num_base::_S_iend
+         - __num_base::_S_izero : __base);
+ typedef __gnu_cxx::__numeric_traits<_ValueT> __num_traits;
+ string __found_grouping;
+ if (__lc->_M_use_grouping)
+   __found_grouping.reserve(32);
+ bool __testfail = false;
+ bool __testoverflow = false;
+ const __unsigned_type __max =
+   (__negative && __num_traits::__is_signed)
+   ? -static_cast<__unsigned_type>(__num_traits::__min)
+   : __num_traits::__max;
+ const __unsigned_type __smax = __max / __base;
+ __unsigned_type __result = 0;
+ int __digit = 0;
+ const char_type* __lit_zero = __lit + __num_base::_S_izero;
+ if (!__lc->_M_allocated)
+   while (!__testeof)
+     {
+       __digit = _M_find(__lit_zero, __len, __c);
+       if (__digit == -1)
+  break;
+       if (__result > __smax)
+  __testoverflow = true;
+       else
+  {
+    __result *= __base;
+    __testoverflow |= __result > __max - __digit;
+    __result += __digit;
+    ++__sep_pos;
+  }
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ else
+   while (!__testeof)
+     {
+       if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  {
+    if (__sep_pos)
+      {
+        __found_grouping += static_cast<char>(__sep_pos);
+        __sep_pos = 0;
+      }
+    else
+      {
+        __testfail = true;
+        break;
+      }
+  }
+       else if (__c == __lc->_M_decimal_point)
+  break;
+       else
+  {
+    const char_type* __q =
+      __traits_type::find(__lit_zero, __len, __c);
+    if (!__q)
+      break;
+    __digit = __q - __lit_zero;
+    if (__digit > 15)
+      __digit -= 6;
+    if (__result > __smax)
+      __testoverflow = true;
+    else
+      {
+        __result *= __base;
+        __testoverflow |= __result > __max - __digit;
+        __result += __digit;
+        ++__sep_pos;
+      }
+  }
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ if (__found_grouping.size())
+   {
+     __found_grouping += static_cast<char>(__sep_pos);
+     if (!std::__verify_grouping(__lc->_M_grouping,
+     __lc->_M_grouping_size,
+     __found_grouping))
+       __err = ios_base::failbit;
+   }
+ if ((!__sep_pos && !__found_zero && !__found_grouping.size())
+     || __testfail)
+   {
+     __v = 0;
+     __err = ios_base::failbit;
+   }
+ else if (__testoverflow)
+   {
+     if (__negative && __num_traits::__is_signed)
+       __v = __num_traits::__min;
+     else
+       __v = __num_traits::__max;
+     __err = ios_base::failbit;
+   }
+ else
+   __v = __negative ? -__result : __result;
+ if (__testeof)
+   __err |= ios_base::eofbit;
+ return __beg;
+      }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, bool& __v) const
+    {
+      if (!(__io.flags() & ios_base::boolalpha))
+        {
+   long __l = -1;
+          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
+   if (__l == 0 || __l == 1)
+     __v = bool(__l);
+   else
+     {
+       __v = true;
+       __err = ios_base::failbit;
+       if (__beg == __end)
+  __err |= ios_base::eofbit;
+     }
+        }
+      else
+        {
+   typedef __numpunct_cache<_CharT> __cache_type;
+   __use_cache<__cache_type> __uc;
+   const locale& __loc = __io._M_getloc();
+   const __cache_type* __lc = __uc(__loc);
+   bool __testf = true;
+   bool __testt = true;
+   bool __donef = __lc->_M_falsename_size == 0;
+   bool __donet = __lc->_M_truename_size == 0;
+   bool __testeof = false;
+   size_t __n = 0;
+   while (!__donef || !__donet)
+     {
+       if (__beg == __end)
+  {
+    __testeof = true;
+    break;
+  }
+       const char_type __c = *__beg;
+       if (!__donef)
+  __testf = __c == __lc->_M_falsename[__n];
+       if (!__testf && __donet)
+  break;
+       if (!__donet)
+  __testt = __c == __lc->_M_truename[__n];
+       if (!__testt && __donef)
+  break;
+       if (!__testt && !__testf)
+  break;
+       ++__n;
+       ++__beg;
+       __donef = !__testf || __n >= __lc->_M_falsename_size;
+       __donet = !__testt || __n >= __lc->_M_truename_size;
+     }
+   if (__testf && __n == __lc->_M_falsename_size && __n)
+     {
+       __v = false;
+       if (__testt && __n == __lc->_M_truename_size)
+  __err = ios_base::failbit;
+       else
+  __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else if (__testt && __n == __lc->_M_truename_size && __n)
+     {
+       __v = true;
+       __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else
+     {
+       __v = false;
+       __err = ios_base::failbit;
+       if (__testeof)
+  __err |= ios_base::eofbit;
+     }
+ }
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, float& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, long double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, void*& __v) const
+    {
+      typedef ios_base::fmtflags fmtflags;
+      const fmtflags __fmt = __io.flags();
+      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
+      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
+          <= sizeof(unsigned long)),
+ unsigned long, unsigned long long>::__type _UIntPtrType;
+      _UIntPtrType __ul;
+      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
+      __io.flags(__fmt);
+      __v = reinterpret_cast<void*>(__ul);
+      return __beg;
+    }
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
+    _CharT* __new, const _CharT* __cs, int& __len) const
+    {
+      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
+        __cs, __w, __len);
+      __len = static_cast<int>(__w);
+    }
+
+  template<typename _CharT, typename _ValueT>
+    int
+    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
+    ios_base::fmtflags __flags, bool __dec)
+    {
+      _CharT* __buf = __bufend;
+      if (__builtin_expect(__dec, true))
+ {
+   do
+     {
+       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
+       __v /= 10;
+     }
+   while (__v != 0);
+ }
+      else if ((__flags & ios_base::basefield) == ios_base::oct)
+ {
+   do
+     {
+       *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
+       __v >>= 3;
+     }
+   while (__v != 0);
+ }
+      else
+ {
+   const bool __uppercase = __flags & ios_base::uppercase;
+   const int __case_offset = __uppercase ? __num_base::_S_oudigits
+                                         : __num_base::_S_odigits;
+   do
+     {
+       *--__buf = __lit[(__v & 0xf) + __case_offset];
+       __v >>= 4;
+     }
+   while (__v != 0);
+ }
+      return __bufend - __buf;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
+   ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
+    {
+      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
+     __grouping_size, __cs, __cs + __len);
+      __len = __p - __new;
+    }
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
+      _ValueT __v) const
+      {
+ using __gnu_cxx::__add_unsigned;
+ typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const _CharT* __lit = __lc->_M_atoms_out;
+ const ios_base::fmtflags __flags = __io.flags();
+ const int __ilen = 5 * sizeof(_ValueT);
+ _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+            * __ilen));
+ const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
+ const bool __dec = (__basefield != ios_base::oct
+       && __basefield != ios_base::hex);
+ const __unsigned_type __u = ((__v > 0 || !__dec)
+         ? __unsigned_type(__v)
+         : -__unsigned_type(__v));
+  int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
+ __cs += __ilen - __len;
+ if (__lc->_M_use_grouping)
+   {
+     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * (__len + 1)
+          * 2));
+     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
+    __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
+     __cs = __cs2 + 2;
+   }
+ if (__builtin_expect(__dec, true))
+   {
+     if (__v >= 0)
+       {
+  if (bool(__flags & ios_base::showpos)
+      && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+    *--__cs = __lit[__num_base::_S_oplus], ++__len;
+       }
+     else
+       *--__cs = __lit[__num_base::_S_ominus], ++__len;
+   }
+ else if (bool(__flags & ios_base::showbase) && __v)
+   {
+     if (__basefield == ios_base::oct)
+       *--__cs = __lit[__num_base::_S_odigits], ++__len;
+     else
+       {
+  const bool __uppercase = __flags & ios_base::uppercase;
+  *--__cs = __lit[__num_base::_S_ox + __uppercase];
+  *--__cs = __lit[__num_base::_S_odigits];
+  __len += 2;
+       }
+   }
+ const streamsize __w = __io.width();
+ if (__w > static_cast<streamsize>(__len))
+   {
+     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __w));
+     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
+     __cs = __cs3;
+   }
+ __io.width(0);
+ return std::__write(__s, __cs, __len);
+      }
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_float(const char* __grouping, size_t __grouping_size,
+     _CharT __sep, const _CharT* __p, _CharT* __new,
+     _CharT* __cs, int& __len) const
+    {
+      const int __declen = __p ? __p - __cs : __len;
+      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
+      __grouping_size,
+      __cs, __cs + __declen);
+      int __newlen = __p2 - __new;
+      if (__p)
+ {
+   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
+   __newlen += __len - __declen;
+ }
+      __len = __newlen;
+    }
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
+         _ValueT __v) const
+      {
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
+ const int __max_digits =
+   __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
+ int __len;
+ char __fbuf[16];
+ __num_base::_S_format_float(__io, __fbuf, __mod);
+ const bool __use_prec =
+   (__io.flags() & ios_base::floatfield) != ios_base::floatfield;
+ int __cs_size = __max_digits * 3;
+ char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+ if (__use_prec)
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     __fbuf, __prec, __v);
+ else
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     __fbuf, __v);
+ if (__len >= __cs_size)
+   {
+     __cs_size = __len + 1;
+     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+     if (__use_prec)
+       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+         __fbuf, __prec, __v);
+     else
+       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+         __fbuf, __v);
+   }
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+ _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+            * __len));
+ __ctype.widen(__cs, __cs + __len, __ws);
+ _CharT* __wp = 0;
+ const char* __p = char_traits<char>::find(__cs, __len, '.');
+ if (__p)
+   {
+     __wp = __ws + (__p - __cs);
+     *__wp = __lc->_M_decimal_point;
+   }
+ if (__lc->_M_use_grouping
+     && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
+          && __cs[1] >= '0' && __cs[2] >= '0')))
+   {
+     _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __len * 2));
+     streamsize __off = 0;
+     if (__cs[0] == '-' || __cs[0] == '+')
+       {
+  __off = 1;
+  __ws2[0] = __ws[0];
+  __len -= 1;
+       }
+     _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
+      __lc->_M_thousands_sep, __wp, __ws2 + __off,
+      __ws + __off, __len);
+     __len += __off;
+     __ws = __ws2;
+   }
+ const streamsize __w = __io.width();
+ if (__w > static_cast<streamsize>(__len))
+   {
+     _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __w));
+     _M_pad(__fill, __w, __io, __ws3, __ws, __len);
+     __ws = __ws3;
+   }
+ __io.width(0);
+ return std::__write(__s, __ws, __len);
+      }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      if ((__flags & ios_base::boolalpha) == 0)
+        {
+          const long __l = __v;
+          __s = _M_insert_int(__s, __io, __fill, __l);
+        }
+      else
+        {
+   typedef __numpunct_cache<_CharT> __cache_type;
+   __use_cache<__cache_type> __uc;
+   const locale& __loc = __io._M_getloc();
+   const __cache_type* __lc = __uc(__loc);
+   const _CharT* __name = __v ? __lc->_M_truename
+                              : __lc->_M_falsename;
+   int __len = __v ? __lc->_M_truename_size
+                   : __lc->_M_falsename_size;
+   const streamsize __w = __io.width();
+   if (__w > static_cast<streamsize>(__len))
+     {
+       const streamsize __plen = __w - __len;
+       _CharT* __ps
+  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+       * __plen));
+       char_traits<_CharT>::assign(__ps, __plen, __fill);
+       __io.width(0);
+       if ((__flags & ios_base::adjustfield) == ios_base::left)
+  {
+    __s = std::__write(__s, __name, __len);
+    __s = std::__write(__s, __ps, __plen);
+  }
+       else
+  {
+    __s = std::__write(__s, __ps, __plen);
+    __s = std::__write(__s, __name, __len);
+  }
+       return __s;
+     }
+   __io.width(0);
+   __s = std::__write(__s, __name, __len);
+ }
+      return __s;
+    }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+    { return _M_insert_float(__s, __io, __fill, char(), __v); }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+    long double __v) const
+    { return _M_insert_float(__s, __io, __fill, 'L', __v); }
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+           const void* __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      const ios_base::fmtflags __fmt = ~(ios_base::basefield
+      | ios_base::uppercase);
+      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
+      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
+          <= sizeof(unsigned long)),
+ unsigned long, unsigned long long>::__type _UIntPtrType;
+      __s = _M_insert_int(__s, __io, __fill,
+     reinterpret_cast<_UIntPtrType>(__v));
+      __io.flags(__flags);
+      return __s;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
+       _CharT* __news, const _CharT* __olds,
+       streamsize __newlen, streamsize __oldlen)
+    {
+      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
+      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
+      if (__adjust == ios_base::left)
+ {
+   _Traits::copy(__news, __olds, __oldlen);
+   _Traits::assign(__news + __oldlen, __plen, __fill);
+   return;
+ }
+      size_t __mod = 0;
+      if (__adjust == ios_base::internal)
+ {
+          const locale& __loc = __io._M_getloc();
+   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+   if (__ctype.widen('-') == __olds[0]
+       || __ctype.widen('+') == __olds[0])
+     {
+       __news[0] = __olds[0];
+       __mod = 1;
+       ++__news;
+     }
+   else if (__ctype.widen('0') == __olds[0]
+     && __oldlen > 1
+     && (__ctype.widen('x') == __olds[1]
+         || __ctype.widen('X') == __olds[1]))
+     {
+       __news[0] = __olds[0];
+       __news[1] = __olds[1];
+       __mod = 2;
+       __news += 2;
+     }
+ }
+      _Traits::assign(__news, __plen, __fill);
+      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
+    }
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+     const char* __gbeg, size_t __gsize,
+     const _CharT* __first, const _CharT* __last)
+    {
+      size_t __idx = 0;
+      size_t __ctr = 0;
+      while (__last - __first > __gbeg[__idx]
+      && static_cast<signed char>(__gbeg[__idx]) > 0
+      && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
+ {
+   __last -= __gbeg[__idx];
+   __idx < __gsize - 1 ? ++__idx : ++__ctr;
+ }
+      while (__first != __last)
+ *__s++ = *__first++;
+      while (__ctr--)
+ {
+   *__s++ = __sep;
+   for (char __i = __gbeg[__idx]; __i > 0; --__i)
+     *__s++ = *__first++;
+ }
+      while (__idx--)
+ {
+   *__s++ = __sep;
+   for (char __i = __gbeg[__idx]; __i > 0; --__i)
+     *__s++ = *__first++;
+ }
+      return __s;
+    }
+  extern template class __cxx11:: numpunct<char>;
+  extern template class __cxx11:: numpunct_byname<char>;
+  extern template class num_get<char>;
+  extern template class num_put<char>;
+  extern template class ctype_byname<char>;
+  extern template
+    const ctype<char>&
+    use_facet<ctype<char> >(const locale&);
+  extern template
+    const numpunct<char>&
+    use_facet<numpunct<char> >(const locale&);
+  extern template
+    const num_put<char>&
+    use_facet<num_put<char> >(const locale&);
+  extern template
+    const num_get<char>&
+    use_facet<num_get<char> >(const locale&);
+  extern template
+    bool
+    has_facet<ctype<char> >(const locale&);
+  extern template
+    bool
+    has_facet<numpunct<char> >(const locale&);
+  extern template
+    bool
+    has_facet<num_put<char> >(const locale&);
+  extern template
+    bool
+    has_facet<num_get<char> >(const locale&);
+  extern template class __cxx11:: numpunct<wchar_t>;
+  extern template class __cxx11:: numpunct_byname<wchar_t>;
+  extern template class num_get<wchar_t>;
+  extern template class num_put<wchar_t>;
+  extern template class ctype_byname<wchar_t>;
+  extern template
+    const ctype<wchar_t>&
+    use_facet<ctype<wchar_t> >(const locale&);
+  extern template
+    const numpunct<wchar_t>&
+    use_facet<numpunct<wchar_t> >(const locale&);
+  extern template
+    const num_put<wchar_t>&
+    use_facet<num_put<wchar_t> >(const locale&);
+  extern template
+    const num_get<wchar_t>&
+    use_facet<num_get<wchar_t> >(const locale&);
+ extern template
+    bool
+    has_facet<ctype<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<numpunct<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<num_put<wchar_t> >(const locale&);
+  extern template
+    bool
+    has_facet<num_get<wchar_t> >(const locale&);
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Facet>
+    inline const _Facet&
+    __check_facet(const _Facet* __f)
+    {
+      if (!__f)
+ __throw_bad_cast();
+      return *__f;
+    }
+  template<typename _CharT, typename _Traits>
+    class basic_ios : public ios_base
+    {
+    public:
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+      typedef ctype<_CharT> __ctype_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+           __num_put_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+           __num_get_type;
+    protected:
+      basic_ostream<_CharT, _Traits>* _M_tie;
+      mutable char_type _M_fill;
+      mutable bool _M_fill_init;
+      basic_streambuf<_CharT, _Traits>* _M_streambuf;
+      const __ctype_type* _M_ctype;
+      const __num_put_type* _M_num_put;
+      const __num_get_type* _M_num_get;
+    public:
+      explicit operator bool() const
+      { return !this->fail(); }
+      bool
+      operator!() const
+      { return this->fail(); }
+      iostate
+      rdstate() const
+      { return _M_streambuf_state; }
+      void
+      clear(iostate __state = goodbit);
+      void
+      setstate(iostate __state)
+      { this->clear(this->rdstate() | __state); }
+      void
+      _M_setstate(iostate __state)
+      {
+ _M_streambuf_state |= __state;
+ if (this->exceptions() & __state)
+   throw;
+      }
+      bool
+      good() const
+      { return this->rdstate() == 0; }
+      bool
+      eof() const
+      { return (this->rdstate() & eofbit) != 0; }
+      bool
+      fail() const
+      { return (this->rdstate() & (badbit | failbit)) != 0; }
+      bool
+      bad() const
+      { return (this->rdstate() & badbit) != 0; }
+      iostate
+      exceptions() const
+      { return _M_exception; }
+      void
+      exceptions(iostate __except)
+      {
+        _M_exception = __except;
+        this->clear(_M_streambuf_state);
+      }
+      explicit
+      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
+      : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
+ _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { this->init(__sb); }
+      virtual
+      ~basic_ios() { }
+      basic_ostream<_CharT, _Traits>*
+      tie() const
+      { return _M_tie; }
+      basic_ostream<_CharT, _Traits>*
+      tie(basic_ostream<_CharT, _Traits>* __tiestr)
+      {
+        basic_ostream<_CharT, _Traits>* __old = _M_tie;
+        _M_tie = __tiestr;
+        return __old;
+      }
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf() const
+      { return _M_streambuf; }
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
+      basic_ios&
+      copyfmt(const basic_ios& __rhs);
+      char_type
+      fill() const
+      {
+ if (!_M_fill_init)
+   {
+     _M_fill = this->widen(' ');
+     _M_fill_init = true;
+   }
+ return _M_fill;
+      }
+      char_type
+      fill(char_type __ch)
+      {
+ char_type __old = this->fill();
+ _M_fill = __ch;
+ return __old;
+      }
+      locale
+      imbue(const locale& __loc);
+      char
+      narrow(char_type __c, char __dfault) const
+      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
+      char_type
+      widen(char __c) const
+      { return __check_facet(_M_ctype).widen(__c); }
+    protected:
+      basic_ios()
+      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
+ _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { }
+      void
+      init(basic_streambuf<_CharT, _Traits>* __sb);
+      basic_ios(const basic_ios&) = delete;
+      basic_ios& operator=(const basic_ios&) = delete;
+      void
+      move(basic_ios& __rhs)
+      {
+ ios_base::_M_move(__rhs);
+ _M_cache_locale(_M_ios_locale);
+ this->tie(__rhs.tie(nullptr));
+ _M_fill = __rhs._M_fill;
+ _M_fill_init = __rhs._M_fill_init;
+ _M_streambuf = nullptr;
+      }
+      void
+      move(basic_ios&& __rhs)
+      { this->move(__rhs); }
+      void
+      swap(basic_ios& __rhs) noexcept
+      {
+ ios_base::_M_swap(__rhs);
+ _M_cache_locale(_M_ios_locale);
+ __rhs._M_cache_locale(__rhs._M_ios_locale);
+ std::swap(_M_tie, __rhs._M_tie);
+ std::swap(_M_fill, __rhs._M_fill);
+ std::swap(_M_fill_init, __rhs._M_fill_init);
+      }
+      void
+      set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
+      { _M_streambuf = __sb; }
+      void
+      _M_cache_locale(const locale& __loc);
+    };
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::clear(iostate __state)
+    {
+      if (this->rdbuf())
+ _M_streambuf_state = __state;
+      else
+   _M_streambuf_state = __state | badbit;
+      if (this->exceptions() & this->rdstate())
+ __throw_ios_failure(("basic_ios::clear"));
+    }
+  template<typename _CharT, typename _Traits>
+    basic_streambuf<_CharT, _Traits>*
+    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
+      _M_streambuf = __sb;
+      this->clear();
+      return __old;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ios<_CharT, _Traits>&
+    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
+    {
+      if (this != &__rhs)
+ {
+   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
+                      _M_local_word : new _Words[__rhs._M_word_size];
+   _Callback_list* __cb = __rhs._M_callbacks;
+   if (__cb)
+     __cb->_M_add_reference();
+   _M_call_callbacks(erase_event);
+   if (_M_word != _M_local_word)
+     {
+       delete [] _M_word;
+       _M_word = 0;
+     }
+   _M_dispose_callbacks();
+   _M_callbacks = __cb;
+   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
+     __words[__i] = __rhs._M_word[__i];
+   _M_word = __words;
+   _M_word_size = __rhs._M_word_size;
+   this->flags(__rhs.flags());
+   this->width(__rhs.width());
+   this->precision(__rhs.precision());
+   this->tie(__rhs.tie());
+   this->fill(__rhs.fill());
+   _M_ios_locale = __rhs.getloc();
+   _M_cache_locale(_M_ios_locale);
+   _M_call_callbacks(copyfmt_event);
+   this->exceptions(__rhs.exceptions());
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    locale
+    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
+    {
+      locale __old(this->getloc());
+      ios_base::imbue(__loc);
+      _M_cache_locale(__loc);
+      if (this->rdbuf() != 0)
+ this->rdbuf()->pubimbue(__loc);
+      return __old;
+    }
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+      ios_base::_M_init();
+      _M_cache_locale(_M_ios_locale);
+      _M_fill = _CharT();
+      _M_fill_init = false;
+      _M_tie = 0;
+      _M_exception = goodbit;
+      _M_streambuf = __sb;
+      _M_streambuf_state = __sb ? goodbit : badbit;
+    }
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
+    {
+      if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
+ _M_ctype = std::__addressof(use_facet<__ctype_type>(__loc));
+      else
+ _M_ctype = 0;
+      if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
+ _M_num_put = std::__addressof(use_facet<__num_put_type>(__loc));
+      else
+ _M_num_put = 0;
+      if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
+ _M_num_get = std::__addressof(use_facet<__num_get_type>(__loc));
+      else
+ _M_num_get = 0;
+    }
+  extern template class basic_ios<char>;
+  extern template class basic_ios<wchar_t>;
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT, typename _Traits>
+    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+             __num_put_type;
+      typedef ctype<_CharT> __ctype_type;
+      explicit
+      basic_ostream(__streambuf_type* __sb)
+      { this->init(__sb); }
+      virtual
+      ~basic_ostream() { }
+      class sentry;
+      friend class sentry;
+      __ostream_type&
+      operator<<(__ostream_type& (*__pf)(__ostream_type&))
+      {
+ return __pf(*this);
+      }
+      __ostream_type&
+      operator<<(__ios_type& (*__pf)(__ios_type&))
+      {
+ __pf(*this);
+ return *this;
+      }
+      __ostream_type&
+      operator<<(ios_base& (*__pf) (ios_base&))
+      {
+ __pf(*this);
+ return *this;
+      }
+      __ostream_type&
+      operator<<(long __n)
+      { return _M_insert(__n); }
+      __ostream_type&
+      operator<<(unsigned long __n)
+      { return _M_insert(__n); }
+      __ostream_type&
+      operator<<(bool __n)
+      { return _M_insert(__n); }
+      __ostream_type&
+      operator<<(short __n);
+      __ostream_type&
+      operator<<(unsigned short __n)
+      {
+ return _M_insert(static_cast<unsigned long>(__n));
+      }
+      __ostream_type&
+      operator<<(int __n);
+      __ostream_type&
+      operator<<(unsigned int __n)
+      {
+ return _M_insert(static_cast<unsigned long>(__n));
+      }
+      __ostream_type&
+      operator<<(long long __n)
+      { return _M_insert(__n); }
+      __ostream_type&
+      operator<<(unsigned long long __n)
+      { return _M_insert(__n); }
+      __ostream_type&
+      operator<<(double __f)
+      { return _M_insert(__f); }
+      __ostream_type&
+      operator<<(float __f)
+      {
+ return _M_insert(static_cast<double>(__f));
+      }
+      __ostream_type&
+      operator<<(long double __f)
+      { return _M_insert(__f); }
+      __ostream_type&
+      operator<<(const void* __p)
+      { return _M_insert(__p); }
+      __ostream_type&
+      operator<<(__streambuf_type* __sb);
+      __ostream_type&
+      put(char_type __c);
+      void
+      _M_write(const char_type* __s, streamsize __n)
+      {
+ const streamsize __put = this->rdbuf()->sputn(__s, __n);
+ if (__put != __n)
+   this->setstate(ios_base::badbit);
+      }
+      __ostream_type&
+      write(const char_type* __s, streamsize __n);
+      __ostream_type&
+      flush();
+      pos_type
+      tellp();
+      __ostream_type&
+      seekp(pos_type);
+       __ostream_type&
+      seekp(off_type, ios_base::seekdir);
+    protected:
+      basic_ostream()
+      { this->init(0); }
+      basic_ostream(basic_iostream<_CharT, _Traits>&) { }
+      basic_ostream(const basic_ostream&) = delete;
+      basic_ostream(basic_ostream&& __rhs)
+      : __ios_type()
+      { __ios_type::move(__rhs); }
+      basic_ostream& operator=(const basic_ostream&) = delete;
+      basic_ostream&
+      operator=(basic_ostream&& __rhs)
+      {
+ swap(__rhs);
+ return *this;
+      }
+      void
+      swap(basic_ostream& __rhs)
+      { __ios_type::swap(__rhs); }
+      template<typename _ValueT>
+ __ostream_type&
+ _M_insert(_ValueT __v);
+    };
+  template <typename _CharT, typename _Traits>
+    class basic_ostream<_CharT, _Traits>::sentry
+    {
+      bool _M_ok;
+      basic_ostream<_CharT, _Traits>& _M_os;
+    public:
+      explicit
+      sentry(basic_ostream<_CharT, _Traits>& __os);
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+      ~sentry()
+      {
+ if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
+   {
+     if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
+       _M_os.setstate(ios_base::badbit);
+   }
+      }
+#pragma GCC diagnostic pop
+      explicit
+      operator bool() const
+      { return _M_ok; }
+    };
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
+    { return __ostream_insert(__out, &__c, 1); }
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
+    { return (__out << __out.widen(__c)); }
+  template <class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, char __c)
+    { return __ostream_insert(__out, &__c, 1); }
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
+    { return (__out << static_cast<char>(__c)); }
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
+    { return (__out << static_cast<char>(__c)); }
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ __ostream_insert(__out, __s,
+    static_cast<streamsize>(_Traits::length(__s)));
+      return __out;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits> &
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ __ostream_insert(__out, __s,
+    static_cast<streamsize>(_Traits::length(__s)));
+      return __out;
+    }
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+  template<class _Traits>
+    inline basic_ostream<char, _Traits> &
+    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    endl(basic_ostream<_CharT, _Traits>& __os)
+    { return flush(__os.put(__os.widen('\n'))); }
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    ends(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.put(_CharT()); }
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    flush(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.flush(); }
+  template<typename _Ch, typename _Up>
+    basic_ostream<_Ch, _Up>&
+    __is_convertible_to_basic_ostream_test(basic_ostream<_Ch, _Up>*);
+  template<typename _Tp, typename = void>
+    struct __is_convertible_to_basic_ostream_impl
+    {
+      using __ostream_type = void;
+    };
+  template<typename _Tp>
+    using __do_is_convertible_to_basic_ostream_impl =
+    decltype(__is_convertible_to_basic_ostream_test
+      (declval<typename remove_reference<_Tp>::type*>()));
+  template<typename _Tp>
+    struct __is_convertible_to_basic_ostream_impl
+    <_Tp,
+     __void_t<__do_is_convertible_to_basic_ostream_impl<_Tp>>>
+    {
+      using __ostream_type =
+ __do_is_convertible_to_basic_ostream_impl<_Tp>;
+    };
+  template<typename _Tp>
+    struct __is_convertible_to_basic_ostream
+    : __is_convertible_to_basic_ostream_impl<_Tp>
+    {
+    public:
+      using type = __not_<is_void<
+        typename __is_convertible_to_basic_ostream_impl<_Tp>::__ostream_type>>;
+      constexpr static bool value = type::value;
+    };
+  template<typename _Ostream, typename _Tp, typename = void>
+    struct __is_insertable : false_type {};
+  template<typename _Ostream, typename _Tp>
+    struct __is_insertable<_Ostream, _Tp,
+      __void_t<decltype(declval<_Ostream&>()
+          << declval<const _Tp&>())>>
+        : true_type {};
+  template<typename _Ostream>
+    using __rvalue_ostream_type =
+      typename __is_convertible_to_basic_ostream<
+ _Ostream>::__ostream_type;
+  template<typename _Ostream, typename _Tp>
+    inline
+    typename enable_if<__and_<__not_<is_lvalue_reference<_Ostream>>,
+         __is_convertible_to_basic_ostream<_Ostream>,
+         __is_insertable<
+    __rvalue_ostream_type<_Ostream>,
+    const _Tp&>>::value,
+         __rvalue_ostream_type<_Ostream>>::type
+    operator<<(_Ostream&& __os, const _Tp& __x)
+    {
+      __rvalue_ostream_type<_Ostream> __ret_os = __os;
+      __ret_os << __x;
+      return __ret_os;
+    }
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>::sentry::
+    sentry(basic_ostream<_CharT, _Traits>& __os)
+    : _M_ok(false), _M_os(__os)
+    {
+      if (__os.tie() && __os.good())
+ __os.tie()->flush();
+      if (__os.good())
+ _M_ok = true;
+      else
+ __os.setstate(ios_base::failbit);
+    }
+  template<typename _CharT, typename _Traits>
+    template<typename _ValueT>
+      basic_ostream<_CharT, _Traits>&
+      basic_ostream<_CharT, _Traits>::
+      _M_insert(_ValueT __v)
+      {
+ sentry __cerb(*this);
+ if (__cerb)
+   {
+     ios_base::iostate __err = ios_base::goodbit;
+     try
+       {
+  const __num_put_type& __np = __check_facet(this->_M_num_put);
+  if (__np.put(*this, *this, this->fill(), __v).failed())
+    __err |= ios_base::badbit;
+       }
+     catch(__cxxabiv1::__forced_unwind&)
+       {
+  this->_M_setstate(ios_base::badbit);
+  throw;
+       }
+     catch(...)
+       { this->_M_setstate(ios_base::badbit); }
+     if (__err)
+       this->setstate(__err);
+   }
+ return *this;
+      }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(short __n)
+    {
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+ return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
+      else
+ return _M_insert(static_cast<long>(__n));
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(int __n)
+    {
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+ return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
+      else
+ return _M_insert(static_cast<long>(__n));
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(__streambuf_type* __sbin)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this);
+      if (__cerb && __sbin)
+ {
+   try
+     {
+       if (!__copy_streambufs(__sbin, this->rdbuf()))
+  __err |= ios_base::failbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::failbit); }
+ }
+      else if (!__sbin)
+ __err |= ios_base::badbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    put(char_type __c)
+    {
+      sentry __cerb(*this);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __put = this->rdbuf()->sputc(__c);
+       if (traits_type::eq_int_type(__put, traits_type::eof()))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    write(const _CharT* __s, streamsize __n)
+    {
+      sentry __cerb(*this);
+      if (__cerb)
+ {
+   try
+     { _M_write(__s, __n); }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    flush()
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
+     __err |= ios_base::badbit;
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    typename basic_ostream<_CharT, _Traits>::pos_type
+    basic_ostream<_CharT, _Traits>::
+    tellp()
+    {
+      pos_type __ret = pos_type(-1);
+      try
+ {
+   if (!this->fail())
+     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(pos_type __pos)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+            ios_base::out);
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(off_type __off, ios_base::seekdir __dir)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+            ios_base::out);
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ {
+   const size_t __clen = char_traits<char>::length(__s);
+   try
+     {
+       struct __ptr_guard
+       {
+  _CharT *__p;
+  __ptr_guard (_CharT *__ip): __p(__ip) { }
+  ~__ptr_guard() { delete[] __p; }
+  _CharT* __get() { return __p; }
+       } __pg (new _CharT[__clen]);
+       _CharT *__ws = __pg.__get();
+       for (size_t __i = 0; __i < __clen; ++__i)
+  __ws[__i] = __out.widen(__s[__i]);
+       __ostream_insert(__out, __ws, __clen);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __out._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __out._M_setstate(ios_base::badbit); }
+ }
+      return __out;
+    }
+  extern template class basic_ostream<char>;
+  extern template ostream& endl(ostream&);
+  extern template ostream& ends(ostream&);
+  extern template ostream& flush(ostream&);
+  extern template ostream& operator<<(ostream&, char);
+  extern template ostream& operator<<(ostream&, unsigned char);
+  extern template ostream& operator<<(ostream&, signed char);
+  extern template ostream& operator<<(ostream&, const char*);
+  extern template ostream& operator<<(ostream&, const unsigned char*);
+  extern template ostream& operator<<(ostream&, const signed char*);
+  extern template ostream& ostream::_M_insert(long);
+  extern template ostream& ostream::_M_insert(unsigned long);
+  extern template ostream& ostream::_M_insert(bool);
+  extern template ostream& ostream::_M_insert(long long);
+  extern template ostream& ostream::_M_insert(unsigned long long);
+  extern template ostream& ostream::_M_insert(double);
+  extern template ostream& ostream::_M_insert(long double);
+  extern template ostream& ostream::_M_insert(const void*);
+  extern template class basic_ostream<wchar_t>;
+  extern template wostream& endl(wostream&);
+  extern template wostream& ends(wostream&);
+  extern template wostream& flush(wostream&);
+  extern template wostream& operator<<(wostream&, wchar_t);
+  extern template wostream& operator<<(wostream&, char);
+  extern template wostream& operator<<(wostream&, const wchar_t*);
+  extern template wostream& operator<<(wostream&, const char*);
+  extern template wostream& wostream::_M_insert(long);
+  extern template wostream& wostream::_M_insert(unsigned long);
+  extern template wostream& wostream::_M_insert(bool);
+  extern template wostream& wostream::_M_insert(long long);
+  extern template wostream& wostream::_M_insert(unsigned long long);
+  extern template wostream& wostream::_M_insert(double);
+  extern template wostream& wostream::_M_insert(long double);
+  extern template wostream& wostream::_M_insert(const void*);
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT, typename _Traits>
+    class basic_istream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+        __num_get_type;
+      typedef ctype<_CharT> __ctype_type;
+    protected:
+      streamsize _M_gcount;
+    public:
+      explicit
+      basic_istream(__streambuf_type* __sb)
+      : _M_gcount(streamsize(0))
+      { this->init(__sb); }
+      virtual
+      ~basic_istream()
+      { _M_gcount = streamsize(0); }
+      class sentry;
+      friend class sentry;
+      __istream_type&
+      operator>>(__istream_type& (*__pf)(__istream_type&))
+      { return __pf(*this); }
+      __istream_type&
+      operator>>(__ios_type& (*__pf)(__ios_type&))
+      {
+ __pf(*this);
+ return *this;
+      }
+      __istream_type&
+      operator>>(ios_base& (*__pf)(ios_base&))
+      {
+ __pf(*this);
+ return *this;
+      }
+      __istream_type&
+      operator>>(bool& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(short& __n);
+      __istream_type&
+      operator>>(unsigned short& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(int& __n);
+      __istream_type&
+      operator>>(unsigned int& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(long& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(unsigned long& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(long long& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(unsigned long long& __n)
+      { return _M_extract(__n); }
+      __istream_type&
+      operator>>(float& __f)
+      { return _M_extract(__f); }
+      __istream_type&
+      operator>>(double& __f)
+      { return _M_extract(__f); }
+      __istream_type&
+      operator>>(long double& __f)
+      { return _M_extract(__f); }
+      __istream_type&
+      operator>>(void*& __p)
+      { return _M_extract(__p); }
+      __istream_type&
+      operator>>(__streambuf_type* __sb);
+      streamsize
+      gcount() const
+      { return _M_gcount; }
+      int_type
+      get();
+      __istream_type&
+      get(char_type& __c);
+      __istream_type&
+      get(char_type* __s, streamsize __n, char_type __delim);
+      __istream_type&
+      get(char_type* __s, streamsize __n)
+      { return this->get(__s, __n, this->widen('\n')); }
+      __istream_type&
+      get(__streambuf_type& __sb, char_type __delim);
+      __istream_type&
+      get(__streambuf_type& __sb)
+      { return this->get(__sb, this->widen('\n')); }
+      __istream_type&
+      getline(char_type* __s, streamsize __n, char_type __delim);
+      __istream_type&
+      getline(char_type* __s, streamsize __n)
+      { return this->getline(__s, __n, this->widen('\n')); }
+      __istream_type&
+      ignore(streamsize __n, int_type __delim);
+      __istream_type&
+      ignore(streamsize __n);
+      __istream_type&
+      ignore();
+      int_type
+      peek();
+      __istream_type&
+      read(char_type* __s, streamsize __n);
+      streamsize
+      readsome(char_type* __s, streamsize __n);
+      __istream_type&
+      putback(char_type __c);
+      __istream_type&
+      unget();
+      int
+      sync();
+      pos_type
+      tellg();
+      __istream_type&
+      seekg(pos_type);
+      __istream_type&
+      seekg(off_type, ios_base::seekdir);
+    protected:
+      basic_istream()
+      : _M_gcount(streamsize(0))
+      { this->init(0); }
+      basic_istream(const basic_istream&) = delete;
+      basic_istream(basic_istream&& __rhs)
+      : __ios_type(), _M_gcount(__rhs._M_gcount)
+      {
+ __ios_type::move(__rhs);
+ __rhs._M_gcount = 0;
+      }
+      basic_istream& operator=(const basic_istream&) = delete;
+      basic_istream&
+      operator=(basic_istream&& __rhs)
+      {
+ swap(__rhs);
+ return *this;
+      }
+      void
+      swap(basic_istream& __rhs)
+      {
+ __ios_type::swap(__rhs);
+ std::swap(_M_gcount, __rhs._M_gcount);
+      }
+      template<typename _ValueT>
+ __istream_type&
+ _M_extract(_ValueT& __v);
+    };
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    getline(char_type* __s, streamsize __n, char_type __delim);
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    ignore(streamsize __n);
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    ignore(streamsize __n, int_type __delim);
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    getline(char_type* __s, streamsize __n, char_type __delim);
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    ignore(streamsize __n);
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    ignore(streamsize __n, int_type __delim);
+  template<typename _CharT, typename _Traits>
+    class basic_istream<_CharT, _Traits>::sentry
+    {
+      bool _M_ok;
+    public:
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::__ctype_type __ctype_type;
+      typedef typename _Traits::int_type __int_type;
+      explicit
+      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
+      explicit
+      operator bool() const
+      { return _M_ok; }
+    };
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __in, char* __s);
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+  template<typename _CharT, typename _Traits>
+    class basic_iostream
+    : public basic_istream<_CharT, _Traits>,
+      public basic_ostream<_CharT, _Traits>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      explicit
+      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
+      : __istream_type(__sb), __ostream_type(__sb) { }
+      virtual
+      ~basic_iostream() { }
+    protected:
+      basic_iostream()
+      : __istream_type(), __ostream_type() { }
+      basic_iostream(const basic_iostream&) = delete;
+      basic_iostream(basic_iostream&& __rhs)
+      : __istream_type(std::move(__rhs)), __ostream_type(*this)
+      { }
+      basic_iostream& operator=(const basic_iostream&) = delete;
+      basic_iostream&
+      operator=(basic_iostream&& __rhs)
+      {
+ swap(__rhs);
+ return *this;
+      }
+      void
+      swap(basic_iostream& __rhs)
+      { __istream_type::swap(__rhs); }
+    };
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __is);
+  template<typename _Ch, typename _Up>
+    basic_istream<_Ch, _Up>&
+    __is_convertible_to_basic_istream_test(basic_istream<_Ch, _Up>*);
+  template<typename _Tp, typename = void>
+    struct __is_convertible_to_basic_istream_impl
+    {
+      using __istream_type = void;
+    };
+  template<typename _Tp>
+    using __do_is_convertible_to_basic_istream_impl =
+    decltype(__is_convertible_to_basic_istream_test
+      (declval<typename remove_reference<_Tp>::type*>()));
+  template<typename _Tp>
+    struct __is_convertible_to_basic_istream_impl
+    <_Tp,
+     __void_t<__do_is_convertible_to_basic_istream_impl<_Tp>>>
+    {
+      using __istream_type =
+ __do_is_convertible_to_basic_istream_impl<_Tp>;
+    };
+  template<typename _Tp>
+    struct __is_convertible_to_basic_istream
+    : __is_convertible_to_basic_istream_impl<_Tp>
+    {
+    public:
+      using type = __not_<is_void<
+        typename __is_convertible_to_basic_istream_impl<_Tp>::__istream_type>>;
+      constexpr static bool value = type::value;
+    };
+  template<typename _Istream, typename _Tp, typename = void>
+    struct __is_extractable : false_type {};
+  template<typename _Istream, typename _Tp>
+    struct __is_extractable<_Istream, _Tp,
+       __void_t<decltype(declval<_Istream&>()
+           >> declval<_Tp>())>>
+    : true_type {};
+  template<typename _Istream>
+    using __rvalue_istream_type =
+      typename __is_convertible_to_basic_istream<
+ _Istream>::__istream_type;
+  template<typename _Istream, typename _Tp>
+    inline
+    typename enable_if<__and_<__not_<is_lvalue_reference<_Istream>>,
+         __is_convertible_to_basic_istream<_Istream>,
+         __is_extractable<
+    __rvalue_istream_type<_Istream>,
+    _Tp&&>>::value,
+         __rvalue_istream_type<_Istream>>::type
+    operator>>(_Istream&& __is, _Tp&& __x)
+    {
+      __rvalue_istream_type<_Istream> __ret_is = __is;
+      __ret_is >> std::forward<_Tp>(__x);
+      return __ret_is;
+    }
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>::sentry::
+    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      if (__in.good())
+ try
+   {
+     if (__in.tie())
+       __in.tie()->flush();
+     if (!__noskip && bool(__in.flags() & ios_base::skipws))
+       {
+  const __int_type __eof = traits_type::eof();
+  __streambuf_type* __sb = __in.rdbuf();
+  __int_type __c = __sb->sgetc();
+  const __ctype_type& __ct = __check_facet(__in._M_ctype);
+  while (!traits_type::eq_int_type(__c, __eof)
+         && __ct.is(ctype_base::space,
+      traits_type::to_char_type(__c)))
+    __c = __sb->snextc();
+  if (traits_type::eq_int_type(__c, __eof))
+    __err |= ios_base::eofbit;
+       }
+   }
+ catch(__cxxabiv1::__forced_unwind&)
+   {
+     __in._M_setstate(ios_base::badbit);
+     throw;
+   }
+ catch(...)
+   { __in._M_setstate(ios_base::badbit); }
+      if (__in.good() && __err == ios_base::goodbit)
+ _M_ok = true;
+      else
+ {
+   __err |= ios_base::failbit;
+   __in.setstate(__err);
+ }
+    }
+  template<typename _CharT, typename _Traits>
+    template<typename _ValueT>
+      basic_istream<_CharT, _Traits>&
+      basic_istream<_CharT, _Traits>::
+      _M_extract(_ValueT& __v)
+      {
+ sentry __cerb(*this, false);
+ if (__cerb)
+   {
+     ios_base::iostate __err = ios_base::goodbit;
+     try
+       {
+  const __num_get_type& __ng = __check_facet(this->_M_num_get);
+  __ng.get(*this, 0, *this, __err, __v);
+       }
+     catch(__cxxabiv1::__forced_unwind&)
+       {
+  this->_M_setstate(ios_base::badbit);
+  throw;
+       }
+     catch(...)
+       { this->_M_setstate(ios_base::badbit); }
+     if (__err)
+       this->setstate(__err);
+   }
+ return *this;
+      }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(short& __n)
+    {
+      sentry __cerb(*this, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       long __l;
+       const __num_get_type& __ng = __check_facet(this->_M_num_get);
+       __ng.get(*this, 0, *this, __err, __l);
+       if (__l < __gnu_cxx::__numeric_traits<short>::__min)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<short>::__min;
+  }
+       else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<short>::__max;
+  }
+       else
+  __n = short(__l);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(int& __n)
+    {
+      sentry __cerb(*this, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       long __l;
+       const __num_get_type& __ng = __check_facet(this->_M_num_get);
+       __ng.get(*this, 0, *this, __err, __l);
+       if (__l < __gnu_cxx::__numeric_traits<int>::__min)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<int>::__min;
+  }
+       else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<int>::__max;
+  }
+       else
+  __n = int(__l);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(__streambuf_type* __sbout)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, false);
+      if (__cerb && __sbout)
+ {
+   try
+     {
+       bool __ineof;
+       if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
+  __err |= ios_base::failbit;
+       if (__ineof)
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::failbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::failbit); }
+ }
+      else if (!__sbout)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::int_type
+    basic_istream<_CharT, _Traits>::
+    get(void)
+    {
+      const int_type __eof = traits_type::eof();
+      int_type __c = __eof;
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       __c = this->rdbuf()->sbumpc();
+       if (!traits_type::eq_int_type(__c, __eof))
+  _M_gcount = 1;
+       else
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return __c;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(char_type& __c)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __cb = this->rdbuf()->sbumpc();
+       if (!traits_type::eq_int_type(__cb, traits_type::eof()))
+  {
+    _M_gcount = 1;
+    __c = traits_type::to_char_type(__cb);
+  }
+       else
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(char_type* __s, streamsize __n, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __idelim = traits_type::to_int_type(__delim);
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       int_type __c = __sb->sgetc();
+       while (_M_gcount + 1 < __n
+       && !traits_type::eq_int_type(__c, __eof)
+       && !traits_type::eq_int_type(__c, __idelim))
+  {
+    *__s++ = traits_type::to_char_type(__c);
+    ++_M_gcount;
+    __c = __sb->snextc();
+  }
+       if (traits_type::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (__n > 0)
+ *__s = char_type();
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(__streambuf_type& __sb, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __idelim = traits_type::to_int_type(__delim);
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __this_sb = this->rdbuf();
+       int_type __c = __this_sb->sgetc();
+       char_type __c2 = traits_type::to_char_type(__c);
+       while (!traits_type::eq_int_type(__c, __eof)
+       && !traits_type::eq_int_type(__c, __idelim)
+       && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
+  {
+    ++_M_gcount;
+    __c = __this_sb->snextc();
+    __c2 = traits_type::to_char_type(__c);
+  }
+       if (traits_type::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    getline(char_type* __s, streamsize __n, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+        {
+          try
+            {
+              const int_type __idelim = traits_type::to_int_type(__delim);
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+              while (_M_gcount + 1 < __n
+                     && !traits_type::eq_int_type(__c, __eof)
+                     && !traits_type::eq_int_type(__c, __idelim))
+                {
+                  *__s++ = traits_type::to_char_type(__c);
+                  __c = __sb->snextc();
+                  ++_M_gcount;
+                }
+              if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+              else
+                {
+                  if (traits_type::eq_int_type(__c, __idelim))
+                    {
+                      __sb->sbumpc();
+                      ++_M_gcount;
+                    }
+                  else
+                    __err |= ios_base::failbit;
+                }
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+        }
+      if (__n > 0)
+ *__s = char_type();
+      if (!_M_gcount)
+        __err |= ios_base::failbit;
+      if (__err)
+        this->setstate(__err);
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(void)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
+  __err |= ios_base::eofbit;
+       else
+  _M_gcount = 1;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb && __n > 0)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+       bool __large_ignore = false;
+       while (true)
+  {
+    while (_M_gcount < __n
+    && !traits_type::eq_int_type(__c, __eof))
+      {
+        ++_M_gcount;
+        __c = __sb->snextc();
+      }
+    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+        && !traits_type::eq_int_type(__c, __eof))
+      {
+        _M_gcount =
+   __gnu_cxx::__numeric_traits<streamsize>::__min;
+        __large_ignore = true;
+      }
+    else
+      break;
+  }
+       if (__large_ignore)
+  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+       if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(streamsize __n, int_type __delim)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb && __n > 0)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+       bool __large_ignore = false;
+       while (true)
+  {
+    while (_M_gcount < __n
+    && !traits_type::eq_int_type(__c, __eof)
+    && !traits_type::eq_int_type(__c, __delim))
+      {
+        ++_M_gcount;
+        __c = __sb->snextc();
+      }
+    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+        && !traits_type::eq_int_type(__c, __eof)
+        && !traits_type::eq_int_type(__c, __delim))
+      {
+        _M_gcount =
+   __gnu_cxx::__numeric_traits<streamsize>::__min;
+        __large_ignore = true;
+      }
+    else
+      break;
+  }
+       if (__large_ignore)
+  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+              if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+       else if (traits_type::eq_int_type(__c, __delim))
+  {
+    if (_M_gcount
+        < __gnu_cxx::__numeric_traits<streamsize>::__max)
+      ++_M_gcount;
+    __sb->sbumpc();
+  }
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::int_type
+    basic_istream<_CharT, _Traits>::
+    peek(void)
+    {
+      int_type __c = traits_type::eof();
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       __c = this->rdbuf()->sgetc();
+       if (traits_type::eq_int_type(__c, traits_type::eof()))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return __c;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    read(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       _M_gcount = this->rdbuf()->sgetn(__s, __n);
+       if (_M_gcount != __n)
+  __err |= (ios_base::eofbit | ios_base::failbit);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_istream<_CharT, _Traits>::
+    readsome(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const streamsize __num = this->rdbuf()->in_avail();
+       if (__num > 0)
+  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
+       else if (__num == -1)
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return _M_gcount;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    putback(char_type __c)
+    {
+      _M_gcount = 0;
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (!__sb
+    || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    unget(void)
+    {
+      _M_gcount = 0;
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (!__sb
+    || traits_type::eq_int_type(__sb->sungetc(), __eof))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    int
+    basic_istream<_CharT, _Traits>::
+    sync(void)
+    {
+      int __ret = -1;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       __streambuf_type* __sb = this->rdbuf();
+       if (__sb)
+  {
+    if (__sb->pubsync() == -1)
+      __err |= ios_base::badbit;
+    else
+      __ret = 0;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::pos_type
+    basic_istream<_CharT, _Traits>::
+    tellg(void)
+    {
+      pos_type __ret = pos_type(-1);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       if (!this->fail())
+  __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
+        ios_base::in);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      return __ret;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(pos_type __pos)
+    {
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       if (!this->fail())
+  {
+    const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+         ios_base::in);
+    if (__p == pos_type(off_type(-1)))
+      __err |= ios_base::failbit;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(off_type __off, ios_base::seekdir __dir)
+    {
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       if (!this->fail())
+  {
+    const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+         ios_base::in);
+    if (__p == pos_type(off_type(-1)))
+      __err |= ios_base::failbit;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::int_type __int_type;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const __int_type __cb = __in.rdbuf()->sbumpc();
+       if (!_Traits::eq_int_type(__cb, _Traits::eof()))
+  __c = _Traits::to_char_type(__cb);
+       else
+  __err |= (ios_base::eofbit | ios_base::failbit);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __in._M_setstate(ios_base::badbit); }
+   if (__err)
+     __in.setstate(__err);
+ }
+      return __in;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef typename _Traits::int_type int_type;
+      typedef _CharT char_type;
+      typedef ctype<_CharT> __ctype_type;
+      streamsize __extracted = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   try
+     {
+       streamsize __num = __in.width();
+       if (__num <= 0)
+  __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
+       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+       const int_type __eof = _Traits::eof();
+       __streambuf_type* __sb = __in.rdbuf();
+       int_type __c = __sb->sgetc();
+       while (__extracted < __num - 1
+       && !_Traits::eq_int_type(__c, __eof)
+       && !__ct.is(ctype_base::space,
+     _Traits::to_char_type(__c)))
+  {
+    *__s++ = _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __sb->snextc();
+  }
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+       *__s = char_type();
+       __in.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __in._M_setstate(ios_base::badbit); }
+ }
+      if (!__extracted)
+ __err |= ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __in)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef typename __istream_type::int_type __int_type;
+      typedef ctype<_CharT> __ctype_type;
+      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+      const __int_type __eof = _Traits::eof();
+      __streambuf_type* __sb = __in.rdbuf();
+      __int_type __c = __sb->sgetc();
+      while (!_Traits::eq_int_type(__c, __eof)
+      && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
+ __c = __sb->snextc();
+       if (_Traits::eq_int_type(__c, __eof))
+  __in.setstate(ios_base::eofbit);
+      return __in;
+    }
+  extern template class basic_istream<char>;
+  extern template istream& ws(istream&);
+  extern template istream& operator>>(istream&, char&);
+  extern template istream& operator>>(istream&, char*);
+  extern template istream& operator>>(istream&, unsigned char&);
+  extern template istream& operator>>(istream&, signed char&);
+  extern template istream& operator>>(istream&, unsigned char*);
+  extern template istream& operator>>(istream&, signed char*);
+  extern template istream& istream::_M_extract(unsigned short&);
+  extern template istream& istream::_M_extract(unsigned int&);
+  extern template istream& istream::_M_extract(long&);
+  extern template istream& istream::_M_extract(unsigned long&);
+  extern template istream& istream::_M_extract(bool&);
+  extern template istream& istream::_M_extract(long long&);
+  extern template istream& istream::_M_extract(unsigned long long&);
+  extern template istream& istream::_M_extract(float&);
+  extern template istream& istream::_M_extract(double&);
+  extern template istream& istream::_M_extract(long double&);
+  extern template istream& istream::_M_extract(void*&);
+  extern template class basic_iostream<char>;
+  extern template class basic_istream<wchar_t>;
+  extern template wistream& ws(wistream&);
+  extern template wistream& operator>>(wistream&, wchar_t&);
+  extern template wistream& operator>>(wistream&, wchar_t*);
+  extern template wistream& wistream::_M_extract(unsigned short&);
+  extern template wistream& wistream::_M_extract(unsigned int&);
+  extern template wistream& wistream::_M_extract(long&);
+  extern template wistream& wistream::_M_extract(unsigned long&);
+  extern template wistream& wistream::_M_extract(bool&);
+  extern template wistream& wistream::_M_extract(long long&);
+  extern template wistream& wistream::_M_extract(unsigned long long&);
+  extern template wistream& wistream::_M_extract(float&);
+  extern template wistream& wistream::_M_extract(double&);
+  extern template wistream& wistream::_M_extract(long double&);
+  extern template wistream& wistream::_M_extract(void*&);
+  extern template class basic_iostream<wchar_t>;
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+namespace __cxx11 {
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
+    {
+      struct __xfer_bufptrs;
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+      typedef basic_string<char_type, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+    protected:
+      ios_base::openmode _M_mode;
+      __string_type _M_string;
+    public:
+      explicit
+      basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __streambuf_type(), _M_mode(__mode), _M_string()
+      { }
+      explicit
+      basic_stringbuf(const __string_type& __str,
+        ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __streambuf_type(), _M_mode(),
+ _M_string(__str.data(), __str.size(), __str.get_allocator())
+      { _M_stringbuf_init(__mode); }
+      basic_stringbuf(const basic_stringbuf&) = delete;
+      basic_stringbuf(basic_stringbuf&& __rhs)
+      : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this))
+      { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); }
+      basic_stringbuf&
+      operator=(const basic_stringbuf&) = delete;
+      basic_stringbuf&
+      operator=(basic_stringbuf&& __rhs)
+      {
+ __xfer_bufptrs __st{__rhs, this};
+ const __streambuf_type& __base = __rhs;
+ __streambuf_type::operator=(__base);
+ this->pubimbue(__rhs.getloc());
+ _M_mode = __rhs._M_mode;
+ _M_string = std::move(__rhs._M_string);
+ __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0);
+ return *this;
+      }
+      void
+      swap(basic_stringbuf& __rhs)
+      {
+ __xfer_bufptrs __l_st{*this, std::__addressof(__rhs)};
+ __xfer_bufptrs __r_st{__rhs, this};
+ __streambuf_type& __base = __rhs;
+ __streambuf_type::swap(__base);
+ __rhs.pubimbue(this->pubimbue(__rhs.getloc()));
+ std::swap(_M_mode, __rhs._M_mode);
+ std::swap(_M_string, __rhs._M_string);
+      }
+      __string_type
+      str() const
+      {
+ __string_type __ret(_M_string.get_allocator());
+ if (this->pptr())
+   {
+     if (this->pptr() > this->egptr())
+       __ret.assign(this->pbase(), this->pptr());
+     else
+       __ret.assign(this->pbase(), this->egptr());
+   }
+ else
+   __ret = _M_string;
+ return __ret;
+      }
+      void
+      str(const __string_type& __s)
+      {
+ _M_string.assign(__s.data(), __s.size());
+ _M_stringbuf_init(_M_mode);
+      }
+    protected:
+      void
+      _M_stringbuf_init(ios_base::openmode __mode)
+      {
+ _M_mode = __mode;
+ __size_type __len = 0;
+ if (_M_mode & (ios_base::ate | ios_base::app))
+   __len = _M_string.size();
+ _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
+      }
+      virtual streamsize
+      showmanyc()
+      {
+ streamsize __ret = -1;
+ if (_M_mode & ios_base::in)
+   {
+     _M_update_egptr();
+     __ret = this->egptr() - this->gptr();
+   }
+ return __ret;
+      }
+      virtual int_type
+      underflow();
+      virtual int_type
+      pbackfail(int_type __c = traits_type::eof());
+      virtual int_type
+      overflow(int_type __c = traits_type::eof());
+      virtual __streambuf_type*
+      setbuf(char_type* __s, streamsize __n)
+      {
+ if (__s && __n >= 0)
+   {
+     _M_string.clear();
+     _M_sync(__s, __n, 0);
+   }
+ return this;
+      }
+      virtual pos_type
+      seekoff(off_type __off, ios_base::seekdir __way,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+      virtual pos_type
+      seekpos(pos_type __sp,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+      void
+      _M_sync(char_type* __base, __size_type __i, __size_type __o);
+      void
+      _M_update_egptr()
+      {
+ const bool __testin = _M_mode & ios_base::in;
+ if (this->pptr() && this->pptr() > this->egptr())
+   {
+     if (__testin)
+       this->setg(this->eback(), this->gptr(), this->pptr());
+     else
+       this->setg(this->pptr(), this->pptr(), this->pptr());
+   }
+      }
+      void
+      _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
+    private:
+      struct __xfer_bufptrs
+      {
+ __xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to)
+ : _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1}
+ {
+   const _CharT* const __str = __from._M_string.data();
+   const _CharT* __end = nullptr;
+   if (__from.eback())
+     {
+       _M_goff[0] = __from.eback() - __str;
+       _M_goff[1] = __from.gptr() - __str;
+       _M_goff[2] = __from.egptr() - __str;
+       __end = __from.egptr();
+     }
+   if (__from.pbase())
+     {
+       _M_poff[0] = __from.pbase() - __str;
+       _M_poff[1] = __from.pptr() - __from.pbase();
+       _M_poff[2] = __from.epptr() - __str;
+       if (__from.pptr() > __end)
+  __end = __from.pptr();
+     }
+   if (__end)
+     {
+       auto& __mut_from = const_cast<basic_stringbuf&>(__from);
+       __mut_from._M_string._M_length(__end - __str);
+     }
+ }
+ ~__xfer_bufptrs()
+ {
+   char_type* __str = const_cast<char_type*>(_M_to->_M_string.data());
+   if (_M_goff[0] != -1)
+     _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]);
+   if (_M_poff[0] != -1)
+     _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]);
+ }
+ basic_stringbuf* _M_to;
+ off_type _M_goff[3];
+ off_type _M_poff[3];
+      };
+      basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&)
+      : __streambuf_type(static_cast<const __streambuf_type&>(__rhs)),
+      _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string))
+      { }
+    };
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_istringstream : public basic_istream<_CharT, _Traits>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_istream<char_type, traits_type> __istream_type;
+    private:
+      __stringbuf_type _M_stringbuf;
+    public:
+      explicit
+      basic_istringstream(ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+      explicit
+      basic_istringstream(const __string_type& __str,
+     ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+      ~basic_istringstream()
+      { }
+      basic_istringstream(const basic_istringstream&) = delete;
+      basic_istringstream(basic_istringstream&& __rhs)
+      : __istream_type(std::move(__rhs)),
+      _M_stringbuf(std::move(__rhs._M_stringbuf))
+      { __istream_type::set_rdbuf(&_M_stringbuf); }
+      basic_istringstream&
+      operator=(const basic_istringstream&) = delete;
+      basic_istringstream&
+      operator=(basic_istringstream&& __rhs)
+      {
+ __istream_type::operator=(std::move(__rhs));
+ _M_stringbuf = std::move(__rhs._M_stringbuf);
+ return *this;
+      }
+      void
+      swap(basic_istringstream& __rhs)
+      {
+ __istream_type::swap(__rhs);
+ _M_stringbuf.swap(__rhs._M_stringbuf);
+      }
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_ostringstream : public basic_ostream<_CharT, _Traits>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_ostream<char_type, traits_type> __ostream_type;
+    private:
+      __stringbuf_type _M_stringbuf;
+    public:
+      explicit
+      basic_ostringstream(ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+      explicit
+      basic_ostringstream(const __string_type& __str,
+     ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+      ~basic_ostringstream()
+      { }
+      basic_ostringstream(const basic_ostringstream&) = delete;
+      basic_ostringstream(basic_ostringstream&& __rhs)
+      : __ostream_type(std::move(__rhs)),
+      _M_stringbuf(std::move(__rhs._M_stringbuf))
+      { __ostream_type::set_rdbuf(&_M_stringbuf); }
+      basic_ostringstream&
+      operator=(const basic_ostringstream&) = delete;
+      basic_ostringstream&
+      operator=(basic_ostringstream&& __rhs)
+      {
+ __ostream_type::operator=(std::move(__rhs));
+ _M_stringbuf = std::move(__rhs._M_stringbuf);
+ return *this;
+      }
+      void
+      swap(basic_ostringstream& __rhs)
+      {
+ __ostream_type::swap(__rhs);
+ _M_stringbuf.swap(__rhs._M_stringbuf);
+      }
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringstream : public basic_iostream<_CharT, _Traits>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_iostream<char_type, traits_type> __iostream_type;
+    private:
+      __stringbuf_type _M_stringbuf;
+    public:
+      explicit
+      basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
+      : __iostream_type(), _M_stringbuf(__m)
+      { this->init(&_M_stringbuf); }
+      explicit
+      basic_stringstream(const __string_type& __str,
+    ios_base::openmode __m = ios_base::out | ios_base::in)
+      : __iostream_type(), _M_stringbuf(__str, __m)
+      { this->init(&_M_stringbuf); }
+      ~basic_stringstream()
+      { }
+      basic_stringstream(const basic_stringstream&) = delete;
+      basic_stringstream(basic_stringstream&& __rhs)
+      : __iostream_type(std::move(__rhs)),
+      _M_stringbuf(std::move(__rhs._M_stringbuf))
+      { __iostream_type::set_rdbuf(&_M_stringbuf); }
+      basic_stringstream&
+      operator=(const basic_stringstream&) = delete;
+      basic_stringstream&
+      operator=(basic_stringstream&& __rhs)
+      {
+ __iostream_type::operator=(std::move(__rhs));
+ _M_stringbuf = std::move(__rhs._M_stringbuf);
+ return *this;
+      }
+      void
+      swap(basic_stringstream& __rhs)
+      {
+ __iostream_type::swap(__rhs);
+ _M_stringbuf.swap(__rhs._M_stringbuf);
+      }
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
+  basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
+  basic_istringstream<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
+  basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
+  basic_stringstream<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+}
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    pbackfail(int_type __c)
+    {
+      int_type __ret = traits_type::eof();
+      if (this->eback() < this->gptr())
+ {
+   const bool __testeof = traits_type::eq_int_type(__c, __ret);
+   if (!__testeof)
+     {
+       const bool __testeq = traits_type::eq(traits_type::
+          to_char_type(__c),
+          this->gptr()[-1]);
+       const bool __testout = this->_M_mode & ios_base::out;
+       if (__testeq || __testout)
+  {
+    this->gbump(-1);
+    if (!__testeq)
+      *this->gptr() = traits_type::to_char_type(__c);
+    __ret = __c;
+  }
+     }
+   else
+     {
+       this->gbump(-1);
+       __ret = traits_type::not_eof(__c);
+     }
+ }
+      return __ret;
+    }
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    overflow(int_type __c)
+    {
+      const bool __testout = this->_M_mode & ios_base::out;
+      if (__builtin_expect(!__testout, false))
+ return traits_type::eof();
+      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
+      if (__builtin_expect(__testeof, false))
+ return traits_type::not_eof(__c);
+      const __size_type __capacity = _M_string.capacity();
+      if ((this->epptr() - this->pbase()) < __capacity)
+ {
+   char_type* __base = const_cast<char_type*>(_M_string.data());
+   _M_pbump(__base, __base + __capacity, this->pptr() - this->pbase());
+   if (_M_mode & ios_base::in)
+     {
+       const __size_type __nget = this->gptr() - this->eback();
+       const __size_type __eget = this->egptr() - this->eback();
+       this->setg(__base, __base + __nget, __base + __eget + 1);
+     }
+   *this->pptr() = traits_type::to_char_type(__c);
+   this->pbump(1);
+   return __c;
+ }
+      const __size_type __max_size = _M_string.max_size();
+      const bool __testput = this->pptr() < this->epptr();
+      if (__builtin_expect(!__testput && __capacity == __max_size, false))
+ return traits_type::eof();
+      const char_type __conv = traits_type::to_char_type(__c);
+      if (!__testput)
+ {
+   const __size_type __opt_len = std::max(__size_type(2 * __capacity),
+       __size_type(512));
+   const __size_type __len = std::min(__opt_len, __max_size);
+   __string_type __tmp(_M_string.get_allocator());
+   __tmp.reserve(__len);
+   if (this->pbase())
+     __tmp.assign(this->pbase(), this->epptr() - this->pbase());
+   __tmp.push_back(__conv);
+   _M_string.swap(__tmp);
+   _M_sync(const_cast<char_type*>(_M_string.data()),
+    this->gptr() - this->eback(), this->pptr() - this->pbase());
+ }
+      else
+ *this->pptr() = __conv;
+      this->pbump(1);
+      return __c;
+    }
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    underflow()
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testin = this->_M_mode & ios_base::in;
+      if (__testin)
+ {
+   _M_update_egptr();
+   if (this->gptr() < this->egptr())
+     __ret = traits_type::to_int_type(*this->gptr());
+ }
+      return __ret;
+    }
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+      const bool __testboth = __testin && __testout && __way != ios_base::cur;
+      __testin &= !(__mode & ios_base::out);
+      __testout &= !(__mode & ios_base::in);
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !__off) && (__testin || __testout || __testboth))
+ {
+   _M_update_egptr();
+   off_type __newoffi = __off;
+   off_type __newoffo = __newoffi;
+   if (__way == ios_base::cur)
+     {
+       __newoffi += this->gptr() - __beg;
+       __newoffo += this->pptr() - __beg;
+     }
+   else if (__way == ios_base::end)
+     __newoffo = __newoffi += this->egptr() - __beg;
+   if ((__testin || __testboth)
+       && __newoffi >= 0
+       && this->egptr() - __beg >= __newoffi)
+     {
+       this->setg(this->eback(), this->eback() + __newoffi,
+    this->egptr());
+       __ret = pos_type(__newoffi);
+     }
+   if ((__testout || __testboth)
+       && __newoffo >= 0
+       && this->egptr() - __beg >= __newoffo)
+     {
+       _M_pbump(this->pbase(), this->epptr(), __newoffo);
+       __ret = pos_type(__newoffo);
+     }
+ }
+      return __ret;
+    }
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekpos(pos_type __sp, ios_base::openmode __mode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !off_type(__sp)) && (__testin || __testout))
+ {
+   _M_update_egptr();
+   const off_type __pos(__sp);
+   const bool __testpos = (0 <= __pos
+      && __pos <= this->egptr() - __beg);
+   if (__testpos)
+     {
+       if (__testin)
+  this->setg(this->eback(), this->eback() + __pos,
+      this->egptr());
+       if (__testout)
+  _M_pbump(this->pbase(), this->epptr(), __pos);
+       __ret = __sp;
+     }
+ }
+      return __ret;
+    }
+  template <class _CharT, class _Traits, class _Alloc>
+    void
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    _M_sync(char_type* __base, __size_type __i, __size_type __o)
+    {
+      const bool __testin = _M_mode & ios_base::in;
+      const bool __testout = _M_mode & ios_base::out;
+      char_type* __endg = __base + _M_string.size();
+      char_type* __endp = __base + _M_string.capacity();
+      if (__base != _M_string.data())
+ {
+   __endg += __i;
+   __i = 0;
+   __endp = __endg;
+ }
+      if (__testin)
+ this->setg(__base, __base + __i, __endg);
+      if (__testout)
+ {
+   _M_pbump(__base, __endp, __o);
+   if (!__testin)
+     this->setg(__endg, __endg, __endg);
+ }
+    }
+  template <class _CharT, class _Traits, class _Alloc>
+    void
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off)
+    {
+      this->setp(__pbeg, __pend);
+      while (__off > __gnu_cxx::__numeric_traits<int>::__max)
+ {
+   this->pbump(__gnu_cxx::__numeric_traits<int>::__max);
+   __off -= __gnu_cxx::__numeric_traits<int>::__max;
+ }
+      this->pbump(__off);
+    }
+  extern template class basic_stringbuf<char>;
+  extern template class basic_istringstream<char>;
+  extern template class basic_ostringstream<char>;
+  extern template class basic_stringstream<char>;
+  extern template class basic_stringbuf<wchar_t>;
+  extern template class basic_istringstream<wchar_t>;
+  extern template class basic_ostringstream<wchar_t>;
+  extern template class basic_stringstream<wchar_t>;
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp> class complex;
+  template<> class complex<float>;
+  template<> class complex<double>;
+  template<> class complex<long double>;
+  template<typename _Tp> _Tp abs(const complex<_Tp>&);
+  template<typename _Tp> _Tp arg(const complex<_Tp>&);
+  template<typename _Tp> _Tp norm(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
+  template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
+  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
+  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
+                                          const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
+  template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
+  template<typename _Tp>
+    struct complex
+    {
+      typedef _Tp value_type;
+      constexpr complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
+      : _M_real(__r), _M_imag(__i) { }
+      constexpr complex(const complex&) = default;
+      template<typename _Up>
+        constexpr complex(const complex<_Up>& __z)
+ : _M_real(__z.real()), _M_imag(__z.imag()) { }
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr _Tp
+      real() const { return _M_real; }
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr _Tp
+      imag() const { return _M_imag; }
+      void
+      real(_Tp __val) { _M_real = __val; }
+      void
+      imag(_Tp __val) { _M_imag = __val; }
+      complex<_Tp>& operator=(const _Tp&);
+      complex<_Tp>&
+      operator+=(const _Tp& __t)
+      {
+ _M_real += __t;
+ return *this;
+      }
+      complex<_Tp>&
+      operator-=(const _Tp& __t)
+      {
+ _M_real -= __t;
+ return *this;
+      }
+      complex<_Tp>& operator*=(const _Tp&);
+      complex<_Tp>& operator/=(const _Tp&);
+      complex& operator=(const complex&) = default;
+      template<typename _Up>
+        complex<_Tp>& operator=(const complex<_Up>&);
+      template<typename _Up>
+        complex<_Tp>& operator+=(const complex<_Up>&);
+      template<typename _Up>
+        complex<_Tp>& operator-=(const complex<_Up>&);
+      template<typename _Up>
+        complex<_Tp>& operator*=(const complex<_Up>&);
+      template<typename _Up>
+        complex<_Tp>& operator/=(const complex<_Up>&);
+      constexpr complex __rep() const
+      { return *this; }
+    private:
+      _Tp _M_real;
+      _Tp _M_imag;
+    };
+  template<typename _Tp>
+    complex<_Tp>&
+    complex<_Tp>::operator=(const _Tp& __t)
+    {
+     _M_real = __t;
+     _M_imag = _Tp();
+     return *this;
+    }
+  template<typename _Tp>
+    complex<_Tp>&
+    complex<_Tp>::operator*=(const _Tp& __t)
+    {
+      _M_real *= __t;
+      _M_imag *= __t;
+      return *this;
+    }
+  template<typename _Tp>
+    complex<_Tp>&
+    complex<_Tp>::operator/=(const _Tp& __t)
+    {
+      _M_real /= __t;
+      _M_imag /= __t;
+      return *this;
+    }
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator=(const complex<_Up>& __z)
+    {
+      _M_real = __z.real();
+      _M_imag = __z.imag();
+      return *this;
+    }
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator+=(const complex<_Up>& __z)
+    {
+      _M_real += __z.real();
+      _M_imag += __z.imag();
+      return *this;
+    }
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator-=(const complex<_Up>& __z)
+    {
+      _M_real -= __z.real();
+      _M_imag -= __z.imag();
+      return *this;
+    }
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator*=(const complex<_Up>& __z)
+    {
+      const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
+      _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
+      _M_real = __r;
+      return *this;
+    }
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator/=(const complex<_Up>& __z)
+    {
+      const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
+      const _Tp __n = std::norm(__z);
+      _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
+      _M_real = __r / __n;
+      return *this;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r += __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r += __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __y;
+      __r += __x;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r -= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r -= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r(__x, -__y.imag());
+      __r -= __y.real();
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r *= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator*(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r *= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator*(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __y;
+      __r *= __x;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r /= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator/(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r /= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator/(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r /= __y;
+      return __r;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const complex<_Tp>& __x)
+    { return __x; }
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const complex<_Tp>& __x)
+    { return complex<_Tp>(-__x.real(), -__x.imag()); }
+  template<typename _Tp>
+    inline constexpr bool
+    operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
+  template<typename _Tp>
+    inline constexpr bool
+    operator==(const complex<_Tp>& __x, const _Tp& __y)
+    { return __x.real() == __y && __x.imag() == _Tp(); }
+  template<typename _Tp>
+    inline constexpr bool
+    operator==(const _Tp& __x, const complex<_Tp>& __y)
+    { return __x == __y.real() && _Tp() == __y.imag(); }
+  template<typename _Tp>
+    inline constexpr bool
+    operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
+  template<typename _Tp>
+    inline constexpr bool
+    operator!=(const complex<_Tp>& __x, const _Tp& __y)
+    { return __x.real() != __y || __x.imag() != _Tp(); }
+  template<typename _Tp>
+    inline constexpr bool
+    operator!=(const _Tp& __x, const complex<_Tp>& __y)
+    { return __x != __y.real() || _Tp() != __y.imag(); }
+  template<typename _Tp, typename _CharT, class _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
+    {
+      bool __fail = true;
+      _CharT __ch;
+      if (__is >> __ch)
+ {
+   if (_Traits::eq(__ch, __is.widen('(')))
+     {
+       _Tp __u;
+       if (__is >> __u >> __ch)
+  {
+    const _CharT __rparen = __is.widen(')');
+    if (_Traits::eq(__ch, __rparen))
+      {
+        __x = __u;
+        __fail = false;
+      }
+    else if (_Traits::eq(__ch, __is.widen(',')))
+      {
+        _Tp __v;
+        if (__is >> __v >> __ch)
+   {
+     if (_Traits::eq(__ch, __rparen))
+       {
+         __x = complex<_Tp>(__u, __v);
+         __fail = false;
+       }
+     else
+       __is.putback(__ch);
+   }
+      }
+    else
+      __is.putback(__ch);
+  }
+     }
+   else
+     {
+       __is.putback(__ch);
+       _Tp __u;
+       if (__is >> __u)
+  {
+    __x = __u;
+    __fail = false;
+  }
+     }
+ }
+      if (__fail)
+ __is.setstate(ios_base::failbit);
+      return __is;
+    }
+  template<typename _Tp, typename _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
+    {
+      basic_ostringstream<_CharT, _Traits> __s;
+      __s.flags(__os.flags());
+      __s.imbue(__os.getloc());
+      __s.precision(__os.precision());
+      __s << '(' << __x.real() << ',' << __x.imag() << ')';
+      return __os << __s.str();
+    }
+  template<typename _Tp>
+    constexpr _Tp
+    real(const complex<_Tp>& __z)
+    { return __z.real(); }
+  template<typename _Tp>
+    constexpr _Tp
+    imag(const complex<_Tp>& __z)
+    { return __z.imag(); }
+  template<typename _Tp>
+    inline _Tp
+    __complex_abs(const complex<_Tp>& __z)
+    {
+      _Tp __x = __z.real();
+      _Tp __y = __z.imag();
+      const _Tp __s = std::max(abs(__x), abs(__y));
+      if (__s == _Tp())
+        return __s;
+      __x /= __s;
+      __y /= __s;
+      return __s * sqrt(__x * __x + __y * __y);
+    }
+  inline float
+  __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
+  inline double
+  __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
+  inline long double
+  __complex_abs(const __complex__ long double& __z)
+  { return __builtin_cabsl(__z); }
+  template<typename _Tp>
+    inline _Tp
+    abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
+  template<typename _Tp>
+    inline _Tp
+    __complex_arg(const complex<_Tp>& __z)
+    { return atan2(__z.imag(), __z.real()); }
+  inline float
+  __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
+  inline double
+  __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
+  inline long double
+  __complex_arg(const __complex__ long double& __z)
+  { return __builtin_cargl(__z); }
+  template<typename _Tp>
+    inline _Tp
+    arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
+  template<bool>
+    struct _Norm_helper
+    {
+      template<typename _Tp>
+        static inline _Tp _S_do_it(const complex<_Tp>& __z)
+        {
+          const _Tp __x = __z.real();
+          const _Tp __y = __z.imag();
+          return __x * __x + __y * __y;
+        }
+    };
+  template<>
+    struct _Norm_helper<true>
+    {
+      template<typename _Tp>
+        static inline _Tp _S_do_it(const complex<_Tp>& __z)
+        {
+          _Tp __res = std::abs(__z);
+          return __res * __res;
+        }
+    };
+  template<typename _Tp>
+    inline _Tp
+    norm(const complex<_Tp>& __z)
+    {
+      return _Norm_helper<__is_floating<_Tp>::__value
+ && !0>::_S_do_it(__z);
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    polar(const _Tp& __rho, const _Tp& __theta)
+    {
+      ;
+      return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta));
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    conj(const complex<_Tp>& __z)
+    { return complex<_Tp>(__z.real(), -__z.imag()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_cos(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
+    }
+  inline __complex__ float
+  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
+  inline __complex__ double
+  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
+  inline __complex__ long double
+  __complex_cos(const __complex__ long double& __z)
+  { return __builtin_ccosl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_cosh(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
+    }
+  inline __complex__ float
+  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
+  inline __complex__ double
+  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
+  inline __complex__ long double
+  __complex_cosh(const __complex__ long double& __z)
+  { return __builtin_ccoshl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_exp(const complex<_Tp>& __z)
+    { return std::polar<_Tp>(exp(__z.real()), __z.imag()); }
+  inline __complex__ float
+  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
+  inline __complex__ double
+  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
+  inline __complex__ long double
+  __complex_exp(const __complex__ long double& __z)
+  { return __builtin_cexpl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_log(const complex<_Tp>& __z)
+    { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
+  inline __complex__ float
+  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
+  inline __complex__ double
+  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
+  inline __complex__ long double
+  __complex_log(const __complex__ long double& __z)
+  { return __builtin_clogl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    log10(const complex<_Tp>& __z)
+    { return std::log(__z) / log(_Tp(10.0)); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_sin(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
+    }
+  inline __complex__ float
+  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
+  inline __complex__ double
+  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
+  inline __complex__ long double
+  __complex_sin(const __complex__ long double& __z)
+  { return __builtin_csinl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_sinh(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
+    }
+  inline __complex__ float
+  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
+  inline __complex__ double
+  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
+  inline __complex__ long double
+  __complex_sinh(const __complex__ long double& __z)
+  { return __builtin_csinhl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
+  template<typename _Tp>
+    complex<_Tp>
+    __complex_sqrt(const complex<_Tp>& __z)
+    {
+      _Tp __x = __z.real();
+      _Tp __y = __z.imag();
+      if (__x == _Tp())
+        {
+          _Tp __t = sqrt(abs(__y) / 2);
+          return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
+        }
+      else
+        {
+          _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
+          _Tp __u = __t / 2;
+          return __x > _Tp()
+            ? complex<_Tp>(__u, __y / __t)
+            : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
+        }
+    }
+  inline __complex__ float
+  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
+  inline __complex__ double
+  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
+  inline __complex__ long double
+  __complex_sqrt(const __complex__ long double& __z)
+  { return __builtin_csqrtl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_tan(const complex<_Tp>& __z)
+    { return std::sin(__z) / std::cos(__z); }
+  inline __complex__ float
+  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
+  inline __complex__ double
+  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
+  inline __complex__ long double
+  __complex_tan(const __complex__ long double& __z)
+  { return __builtin_ctanl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_tanh(const complex<_Tp>& __z)
+    { return std::sinh(__z) / std::cosh(__z); }
+  inline __complex__ float
+  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
+  inline __complex__ double
+  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
+  inline __complex__ long double
+  __complex_tanh(const __complex__ long double& __z)
+  { return __builtin_ctanhl(__z); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
+  template<typename _Tp>
+    complex<_Tp>
+    __complex_pow_unsigned(complex<_Tp> __x, unsigned __n)
+    {
+      complex<_Tp> __y = __n % 2 ? __x : complex<_Tp>(1);
+      while (__n >>= 1)
+        {
+          __x *= __x;
+          if (__n % 2)
+            __y *= __x;
+        }
+      return __y;
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    pow(const complex<_Tp>& __z, int __n)
+    {
+      return __n < 0
+ ? complex<_Tp>(1) / std::__complex_pow_unsigned(__z, -(unsigned)__n)
+        : std::__complex_pow_unsigned(__z, __n);
+    }
+  template<typename _Tp>
+    complex<_Tp>
+    pow(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      if (__x.imag() == _Tp() && __x.real() > _Tp())
+        return pow(__x.real(), __y);
+      complex<_Tp> __t = std::log(__x);
+      return std::polar<_Tp>(exp(__y * __t.real()), __y * __t.imag());
+    }
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
+  inline __complex__ float
+  __complex_pow(__complex__ float __x, __complex__ float __y)
+  { return __builtin_cpowf(__x, __y); }
+  inline __complex__ double
+  __complex_pow(__complex__ double __x, __complex__ double __y)
+  { return __builtin_cpow(__x, __y); }
+  inline __complex__ long double
+  __complex_pow(const __complex__ long double& __x,
+  const __complex__ long double& __y)
+  { return __builtin_cpowl(__x, __y); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __complex_pow(__x.__rep(), __y.__rep()); }
+  template<typename _Tp>
+    inline complex<_Tp>
+    pow(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      return __x > _Tp() ? std::polar<_Tp>(pow(__x, __y.real()),
+        __y.imag() * log(__x))
+                  : std::pow(complex<_Tp>(__x), __y);
+    }
+  template<>
+    struct complex<float>
+    {
+      typedef float value_type;
+      typedef __complex__ float _ComplexT;
+      constexpr complex(_ComplexT __z) : _M_value(__z) { }
+      constexpr complex(float __r = 0.0f, float __i = 0.0f)
+      : _M_value{ __r, __i } { }
+      explicit constexpr complex(const complex<double>&);
+      explicit constexpr complex(const complex<long double>&);
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr float
+      real() const { return __real__ _M_value; }
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr float
+      imag() const { return __imag__ _M_value; }
+      void
+      real(float __val) { __real__ _M_value = __val; }
+      void
+      imag(float __val) { __imag__ _M_value = __val; }
+      complex&
+      operator=(float __f)
+      {
+ _M_value = __f;
+ return *this;
+      }
+      complex&
+      operator+=(float __f)
+      {
+ _M_value += __f;
+ return *this;
+      }
+      complex&
+      operator-=(float __f)
+      {
+ _M_value -= __f;
+ return *this;
+      }
+      complex&
+      operator*=(float __f)
+      {
+ _M_value *= __f;
+ return *this;
+      }
+      complex&
+      operator/=(float __f)
+      {
+ _M_value /= __f;
+ return *this;
+      }
+      template<typename _Tp>
+        complex&
+        operator=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value = __z.real();
+   __imag__ _M_value = __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+        operator+=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value += __z.real();
+   __imag__ _M_value += __z.imag();
+   return *this;
+ }
+      template<class _Tp>
+        complex&
+        operator-=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value -= __z.real();
+   __imag__ _M_value -= __z.imag();
+   return *this;
+ }
+      template<class _Tp>
+        complex&
+        operator*=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value *= __t;
+   return *this;
+ }
+      template<class _Tp>
+        complex&
+        operator/=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value /= __t;
+   return *this;
+ }
+      constexpr _ComplexT __rep() const { return _M_value; }
+    private:
+      _ComplexT _M_value;
+    };
+  template<>
+    struct complex<double>
+    {
+      typedef double value_type;
+      typedef __complex__ double _ComplexT;
+      constexpr complex(_ComplexT __z) : _M_value(__z) { }
+      constexpr complex(double __r = 0.0, double __i = 0.0)
+      : _M_value{ __r, __i } { }
+      constexpr complex(const complex<float>& __z)
+      : _M_value(__z.__rep()) { }
+      explicit constexpr complex(const complex<long double>&);
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr double
+      real() const { return __real__ _M_value; }
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr double
+      imag() const { return __imag__ _M_value; }
+      void
+      real(double __val) { __real__ _M_value = __val; }
+      void
+      imag(double __val) { __imag__ _M_value = __val; }
+      complex&
+      operator=(double __d)
+      {
+ _M_value = __d;
+ return *this;
+      }
+      complex&
+      operator+=(double __d)
+      {
+ _M_value += __d;
+ return *this;
+      }
+      complex&
+      operator-=(double __d)
+      {
+ _M_value -= __d;
+ return *this;
+      }
+      complex&
+      operator*=(double __d)
+      {
+ _M_value *= __d;
+ return *this;
+      }
+      complex&
+      operator/=(double __d)
+      {
+ _M_value /= __d;
+ return *this;
+      }
+      template<typename _Tp>
+        complex&
+        operator=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value = __z.real();
+   __imag__ _M_value = __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+        operator+=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value += __z.real();
+   __imag__ _M_value += __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+        operator-=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value -= __z.real();
+   __imag__ _M_value -= __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+        operator*=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value *= __t;
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+        operator/=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value /= __t;
+   return *this;
+ }
+      constexpr _ComplexT __rep() const { return _M_value; }
+    private:
+      _ComplexT _M_value;
+    };
+  template<>
+    struct complex<long double>
+    {
+      typedef long double value_type;
+      typedef __complex__ long double _ComplexT;
+      constexpr complex(_ComplexT __z) : _M_value(__z) { }
+      constexpr complex(long double __r = 0.0L,
+     long double __i = 0.0L)
+      : _M_value{ __r, __i } { }
+      constexpr complex(const complex<float>& __z)
+      : _M_value(__z.__rep()) { }
+      constexpr complex(const complex<double>& __z)
+      : _M_value(__z.__rep()) { }
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr long double
+      real() const { return __real__ _M_value; }
+      __attribute ((__abi_tag__ ("cxx11")))
+      constexpr long double
+      imag() const { return __imag__ _M_value; }
+      void
+      real(long double __val) { __real__ _M_value = __val; }
+      void
+      imag(long double __val) { __imag__ _M_value = __val; }
+      complex&
+      operator=(long double __r)
+      {
+ _M_value = __r;
+ return *this;
+      }
+      complex&
+      operator+=(long double __r)
+      {
+ _M_value += __r;
+ return *this;
+      }
+      complex&
+      operator-=(long double __r)
+      {
+ _M_value -= __r;
+ return *this;
+      }
+      complex&
+      operator*=(long double __r)
+      {
+ _M_value *= __r;
+ return *this;
+      }
+      complex&
+      operator/=(long double __r)
+      {
+ _M_value /= __r;
+ return *this;
+      }
+      template<typename _Tp>
+        complex&
+        operator=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value = __z.real();
+   __imag__ _M_value = __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+ operator+=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value += __z.real();
+   __imag__ _M_value += __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+ operator-=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value -= __z.real();
+   __imag__ _M_value -= __z.imag();
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+ operator*=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value *= __t;
+   return *this;
+ }
+      template<typename _Tp>
+        complex&
+ operator/=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value /= __t;
+   return *this;
+ }
+      constexpr _ComplexT __rep() const { return _M_value; }
+    private:
+      _ComplexT _M_value;
+    };
+  inline constexpr
+  complex<float>::complex(const complex<double>& __z)
+  : _M_value(__z.__rep()) { }
+  inline constexpr
+  complex<float>::complex(const complex<long double>& __z)
+  : _M_value(__z.__rep()) { }
+  inline constexpr
+  complex<double>::complex(const complex<long double>& __z)
+  : _M_value(__z.__rep()) { }
+  extern template istream& operator>>(istream&, complex<float>&);
+  extern template ostream& operator<<(ostream&, const complex<float>&);
+  extern template istream& operator>>(istream&, complex<double>&);
+  extern template ostream& operator<<(ostream&, const complex<double>&);
+  extern template istream& operator>>(istream&, complex<long double>&);
+  extern template ostream& operator<<(ostream&, const complex<long double>&);
+  extern template wistream& operator>>(wistream&, complex<float>&);
+  extern template wostream& operator<<(wostream&, const complex<float>&);
+  extern template wistream& operator>>(wistream&, complex<double>&);
+  extern template wostream& operator<<(wostream&, const complex<double>&);
+  extern template wistream& operator>>(wistream&, complex<long double>&);
+  extern template wostream& operator<<(wostream&, const complex<long double>&);
+
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp, typename _Up>
+    struct __promote_2<std::complex<_Tp>, _Up>
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+  template<typename _Tp, typename _Up>
+    struct __promote_2<_Tp, std::complex<_Up> >
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+  template<typename _Tp, typename _Up>
+    struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
+  template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);
+  template<typename _Tp> _Tp fabs(const std::complex<_Tp>&);
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    __complex_acos(const std::complex<_Tp>& __z)
+    {
+      const std::complex<_Tp> __t = std::asin(__z);
+      const _Tp __pi_2 = 1.5707963267948966192313216916397514L;
+      return std::complex<_Tp>(__pi_2 - __t.real(), -__t.imag());
+    }
+  inline __complex__ float
+  __complex_acos(__complex__ float __z)
+  { return __builtin_cacosf(__z); }
+  inline __complex__ double
+  __complex_acos(__complex__ double __z)
+  { return __builtin_cacos(__z); }
+  inline __complex__ long double
+  __complex_acos(const __complex__ long double& __z)
+  { return __builtin_cacosl(__z); }
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acos(const std::complex<_Tp>& __z)
+    { return __complex_acos(__z.__rep()); }
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    __complex_asin(const std::complex<_Tp>& __z)
+    {
+      std::complex<_Tp> __t(-__z.imag(), __z.real());
+      __t = std::asinh(__t);
+      return std::complex<_Tp>(__t.imag(), -__t.real());
+    }
+  inline __complex__ float
+  __complex_asin(__complex__ float __z)
+  { return __builtin_casinf(__z); }
+  inline __complex__ double
+  __complex_asin(__complex__ double __z)
+  { return __builtin_casin(__z); }
+  inline __complex__ long double
+  __complex_asin(const __complex__ long double& __z)
+  { return __builtin_casinl(__z); }
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asin(const std::complex<_Tp>& __z)
+    { return __complex_asin(__z.__rep()); }
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_atan(const std::complex<_Tp>& __z)
+    {
+      const _Tp __r2 = __z.real() * __z.real();
+      const _Tp __x = _Tp(1.0) - __r2 - __z.imag() * __z.imag();
+      _Tp __num = __z.imag() + _Tp(1.0);
+      _Tp __den = __z.imag() - _Tp(1.0);
+      __num = __r2 + __num * __num;
+      __den = __r2 + __den * __den;
+      return std::complex<_Tp>(_Tp(0.5) * atan2(_Tp(2.0) * __z.real(), __x),
+          _Tp(0.25) * log(__num / __den));
+    }
+  inline __complex__ float
+  __complex_atan(__complex__ float __z)
+  { return __builtin_catanf(__z); }
+  inline __complex__ double
+  __complex_atan(__complex__ double __z)
+  { return __builtin_catan(__z); }
+  inline __complex__ long double
+  __complex_atan(const __complex__ long double& __z)
+  { return __builtin_catanl(__z); }
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atan(const std::complex<_Tp>& __z)
+    { return __complex_atan(__z.__rep()); }
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_acosh(const std::complex<_Tp>& __z)
+    {
+      return _Tp(2.0) * std::log(std::sqrt(_Tp(0.5) * (__z + _Tp(1.0)))
+     + std::sqrt(_Tp(0.5) * (__z - _Tp(1.0))));
+    }
+  inline __complex__ float
+  __complex_acosh(__complex__ float __z)
+  { return __builtin_cacoshf(__z); }
+  inline __complex__ double
+  __complex_acosh(__complex__ double __z)
+  { return __builtin_cacosh(__z); }
+  inline __complex__ long double
+  __complex_acosh(const __complex__ long double& __z)
+  { return __builtin_cacoshl(__z); }
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    acosh(const std::complex<_Tp>& __z)
+    { return __complex_acosh(__z.__rep()); }
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_asinh(const std::complex<_Tp>& __z)
+    {
+      std::complex<_Tp> __t((__z.real() - __z.imag())
+       * (__z.real() + __z.imag()) + _Tp(1.0),
+       _Tp(2.0) * __z.real() * __z.imag());
+      __t = std::sqrt(__t);
+      return std::log(__t + __z);
+    }
+  inline __complex__ float
+  __complex_asinh(__complex__ float __z)
+  { return __builtin_casinhf(__z); }
+  inline __complex__ double
+  __complex_asinh(__complex__ double __z)
+  { return __builtin_casinh(__z); }
+  inline __complex__ long double
+  __complex_asinh(const __complex__ long double& __z)
+  { return __builtin_casinhl(__z); }
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    asinh(const std::complex<_Tp>& __z)
+    { return __complex_asinh(__z.__rep()); }
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_atanh(const std::complex<_Tp>& __z)
+    {
+      const _Tp __i2 = __z.imag() * __z.imag();
+      const _Tp __x = _Tp(1.0) - __i2 - __z.real() * __z.real();
+      _Tp __num = _Tp(1.0) + __z.real();
+      _Tp __den = _Tp(1.0) - __z.real();
+      __num = __i2 + __num * __num;
+      __den = __i2 + __den * __den;
+      return std::complex<_Tp>(_Tp(0.25) * (log(__num) - log(__den)),
+          _Tp(0.5) * atan2(_Tp(2.0) * __z.imag(), __x));
+    }
+  inline __complex__ float
+  __complex_atanh(__complex__ float __z)
+  { return __builtin_catanhf(__z); }
+  inline __complex__ double
+  __complex_atanh(__complex__ double __z)
+  { return __builtin_catanh(__z); }
+  inline __complex__ long double
+  __complex_atanh(const __complex__ long double& __z)
+  { return __builtin_catanhl(__z); }
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    atanh(const std::complex<_Tp>& __z)
+    { return __complex_atanh(__z.__rep()); }
+  template<typename _Tp>
+    inline _Tp
+    fabs(const std::complex<_Tp>& __z)
+    { return std::abs(__z); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    arg(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return std::signbit(__x) ? __type(3.1415926535897932384626433832795029L)
+                        : __type();
+    }
+  template<typename _Tp>
+    constexpr inline typename __gnu_cxx::__promote<_Tp>::__type
+    imag(_Tp)
+    { return _Tp(); }
+  template<typename _Tp>
+    inline typename __gnu_cxx::__promote<_Tp>::__type
+    norm(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __type(__x) * __type(__x);
+    }
+  template<typename _Tp>
+    constexpr inline typename __gnu_cxx::__promote<_Tp>::__type
+    real(_Tp __x)
+    { return __x; }
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    pow(const std::complex<_Tp>& __x, const _Up& __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::pow(std::complex<__type>(__x), __type(__y));
+    }
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    pow(const _Tp& __x, const std::complex<_Up>& __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::pow(__type(__x), std::complex<__type>(__y));
+    }
+  template<typename _Tp, typename _Up>
+    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__type>
+    pow(const std::complex<_Tp>& __x, const std::complex<_Up>& __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return std::pow(std::complex<__type>(__x),
+        std::complex<__type>(__y));
+    }
+  template<typename _Tp> std::complex<_Tp> proj(const std::complex<_Tp>&);
+  template<typename _Tp>
+    std::complex<_Tp>
+    __complex_proj(const std::complex<_Tp>& __z)
+    {
+      const _Tp __den = (__z.real() * __z.real()
+    + __z.imag() * __z.imag() + _Tp(1.0));
+      return std::complex<_Tp>((_Tp(2.0) * __z.real()) / __den,
+          (_Tp(2.0) * __z.imag()) / __den);
+    }
+  inline __complex__ float
+  __complex_proj(__complex__ float __z)
+  { return __builtin_cprojf(__z); }
+  inline __complex__ double
+  __complex_proj(__complex__ double __z)
+  { return __builtin_cproj(__z); }
+  inline __complex__ long double
+  __complex_proj(const __complex__ long double& __z)
+  { return __builtin_cprojl(__z); }
+  template<typename _Tp>
+    inline std::complex<_Tp>
+    proj(const std::complex<_Tp>& __z)
+    { return __complex_proj(__z.__rep()); }
+  template<typename _Tp>
+    inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
+    proj(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return std::proj(std::complex<__type>(__x));
+    }
+  template<typename _Tp>
+    inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
+    conj(_Tp __x)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return std::complex<__type>(__x, -__type());
+    }
+inline namespace literals {
+inline namespace complex_literals {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+  constexpr std::complex<float>
+  operator""if(long double __num)
+  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
+  constexpr std::complex<float>
+  operator""if(unsigned long long __num)
+  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }
+  constexpr std::complex<double>
+  operator""i(long double __num)
+  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
+  constexpr std::complex<double>
+  operator""i(unsigned long long __num)
+  { return std::complex<double>{0.0, static_cast<double>(__num)}; }
+  constexpr std::complex<long double>
+  operator""il(long double __num)
+  { return std::complex<long double>{0.0L, __num}; }
+  constexpr std::complex<long double>
+  operator""il(unsigned long long __num)
+  { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }
+#pragma GCC diagnostic pop
+}
+}
+
+}
+namespace mlx::core {
+struct complex64_t;
+struct complex128_t;
+template <typename T>
+inline constexpr bool can_convert_to_complex128 =
+    !std::is_same_v<T, complex128_t> && std::is_convertible_v<T, double>;
+struct complex128_t : public std::complex<double> {
+  complex128_t() : std::complex<double>() {};
+  complex128_t(double v, double u) : std::complex<double>(v, u) {};
+  complex128_t(std::complex<double> v) : std::complex<double>(v) {};
+  template <
+      typename T,
+      typename = typename std::enable_if<can_convert_to_complex128<T>>::type>
+  complex128_t(T x) : std::complex<double>(x){};
+  operator float() const {
+    return real();
+  };
+};
+template <typename T>
+inline constexpr bool can_convert_to_complex64 =
+    !std::is_same_v<T, complex64_t> && std::is_convertible_v<T, float>;
+struct complex64_t : public std::complex<float> {
+  complex64_t() : std::complex<float>() {};
+  complex64_t(float v, float u) : std::complex<float>(v, u) {};
+  complex64_t(std::complex<float> v) : std::complex<float>(v) {};
+  template <
+      typename T,
+      typename = typename std::enable_if<can_convert_to_complex64<T>>::type>
+  complex64_t(T x) : std::complex<float>(x){};
+  operator float() const {
+    return real();
+  };
+};
+inline bool operator>=(const complex64_t& a, const complex64_t& b) {
+  return (a.real() > b.real()) ||
+      (a.real() == b.real() && a.imag() >= b.imag());
+}
+inline bool operator>(const complex64_t& a, const complex64_t& b) {
+  return (a.real() > b.real()) || (a.real() == b.real() && a.imag() > b.imag());
+}
+inline complex64_t operator%(complex64_t a, complex64_t b) {
+  auto real = a.real() - (b.real() * static_cast<int64_t>(a.real() / b.real()));
+  auto imag = a.imag() - (b.imag() * static_cast<int64_t>(a.imag() / b.imag()));
+  if (real != 0 && ((real < 0) != (b.real() < 0)))
+    real += b.real();
+  if (imag != 0 && ((imag < 0) != (b.imag() < 0)))
+    imag += b.imag();
+  return {real, imag};
+}
+inline bool operator<=(const complex64_t& a, const complex64_t& b) {
+  return operator>=(b, a);
+}
+inline bool operator<(const complex64_t& a, const complex64_t& b) {
+  return operator>(b, a);
+}
+inline complex64_t operator-(const complex64_t& v) {
+  return -static_cast<std::complex<float>>(v);
+}
+inline complex64_t operator+(const std::complex<float>& x, const complex64_t& y) { return x + static_cast<std::complex<float>>(y); } inline complex64_t operator+(const complex64_t& x, const std::complex<float>& y) { return static_cast<std::complex<float>>(x) + y; } inline complex64_t operator+(const complex64_t& x, const complex64_t& y) { return static_cast<std::complex<float>>(x) + static_cast<std::complex<float>>(y); } inline complex64_t operator+(bool x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x, bool y) { return x + static_cast<complex64_t>(y); } inline complex64_t operator+(uint32_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x, uint32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t operator+(uint64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x, uint64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t operator+(int32_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x, int32_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t operator+(int64_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x, int64_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t operator+(float16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x, float16_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t operator+(bfloat16_t x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x, bfloat16_t y) { return x + static_cast<complex64_t>(y); } inline complex64_t operator+(float x, const complex64_t& y) { return static_cast<complex64_t>(x) + y; } inline complex64_t operator+(const complex64_t& x, float y) { return x + static_cast<complex64_t>(y); }
+}
+       
+       
+       
+       
+       
+       
+       
+       
+       
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp, std::size_t _Nm>
+    struct __array_traits
+    {
+      typedef _Tp _Type[_Nm];
+      typedef __is_swappable<_Tp> _Is_swappable;
+      typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable;
+      static constexpr _Tp&
+      _S_ref(const _Type& __t, std::size_t __n) noexcept
+      { return const_cast<_Tp&>(__t[__n]); }
+      static constexpr _Tp*
+      _S_ptr(const _Type& __t) noexcept
+      { return const_cast<_Tp*>(__t); }
+    };
+ template<typename _Tp>
+   struct __array_traits<_Tp, 0>
+   {
+     struct _Type { };
+     typedef true_type _Is_swappable;
+     typedef true_type _Is_nothrow_swappable;
+     static constexpr _Tp&
+     _S_ref(const _Type&, std::size_t) noexcept
+     { return *static_cast<_Tp*>(nullptr); }
+     static constexpr _Tp*
+     _S_ptr(const _Type&) noexcept
+     { return nullptr; }
+   };
+  template<typename _Tp, std::size_t _Nm>
+    struct array
+    {
+      typedef _Tp value_type;
+      typedef value_type* pointer;
+      typedef const value_type* const_pointer;
+      typedef value_type& reference;
+      typedef const value_type& const_reference;
+      typedef value_type* iterator;
+      typedef const value_type* const_iterator;
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::__array_traits<_Tp, _Nm> _AT_Type;
+      typename _AT_Type::_Type _M_elems;
+      void
+      fill(const value_type& __u)
+      { std::fill_n(begin(), size(), __u); }
+      void
+      swap(array& __other)
+      noexcept(_AT_Type::_Is_nothrow_swappable::value)
+      { std::swap_ranges(begin(), end(), __other.begin()); }
+      constexpr iterator
+      begin() noexcept
+      { return iterator(data()); }
+      constexpr const_iterator
+      begin() const noexcept
+      { return const_iterator(data()); }
+      constexpr iterator
+      end() noexcept
+      { return iterator(data() + _Nm); }
+      constexpr const_iterator
+      end() const noexcept
+      { return const_iterator(data() + _Nm); }
+      constexpr reverse_iterator
+      rbegin() noexcept
+      { return reverse_iterator(end()); }
+      constexpr const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+      constexpr reverse_iterator
+      rend() noexcept
+      { return reverse_iterator(begin()); }
+      constexpr const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(begin()); }
+      constexpr const_iterator
+      cbegin() const noexcept
+      { return const_iterator(data()); }
+      constexpr const_iterator
+      cend() const noexcept
+      { return const_iterator(data() + _Nm); }
+      constexpr const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+      constexpr const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+      constexpr size_type
+      size() const noexcept { return _Nm; }
+      constexpr size_type
+      max_size() const noexcept { return _Nm; }
+      constexpr bool
+      empty() const noexcept { return size() == 0; }
+      constexpr reference
+      operator[](size_type __n) noexcept
+      { return _AT_Type::_S_ref(_M_elems, __n); }
+      constexpr const_reference
+      operator[](size_type __n) const noexcept
+      { return _AT_Type::_S_ref(_M_elems, __n); }
+      constexpr reference
+      at(size_type __n)
+      {
+ if (__n >= _Nm)
+   std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"),
+     __n, _Nm);
+ return _AT_Type::_S_ref(_M_elems, __n);
+      }
+      constexpr const_reference
+      at(size_type __n) const
+      {
+ return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
+   : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"),
+        __n, _Nm),
+      _AT_Type::_S_ref(_M_elems, 0));
+      }
+      constexpr reference
+      front() noexcept
+      { return *begin(); }
+      constexpr const_reference
+      front() const noexcept
+      { return _AT_Type::_S_ref(_M_elems, 0); }
+      constexpr reference
+      back() noexcept
+      { return _Nm ? *(end() - 1) : *end(); }
+      constexpr const_reference
+      back() const noexcept
+      {
+ return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
+             : _AT_Type::_S_ref(_M_elems, 0);
+      }
+      constexpr pointer
+      data() noexcept
+      { return _AT_Type::_S_ptr(_M_elems); }
+      constexpr const_pointer
+      data() const noexcept
+      { return _AT_Type::_S_ptr(_M_elems); }
+    };
+  template<typename _Tp, typename... _Up>
+    array(_Tp, _Up...)
+      -> array<enable_if_t<(is_same_v<_Tp, _Up> && ...), _Tp>,
+        1 + sizeof...(_Up)>;
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one == __two); }
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
+    {
+      return std::lexicographical_compare(__a.begin(), __a.end(),
+       __b.begin(), __b.end());
+    }
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return __two < __one; }
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one > __two); }
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one < __two); }
+  template<typename _Tp, std::size_t _Nm>
+    inline
+    typename enable_if<
+      std::__array_traits<_Tp, _Nm>::_Is_swappable::value
+    >::type
+    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
+    noexcept(noexcept(__one.swap(__two)))
+    { __one.swap(__two); }
+  template<typename _Tp, std::size_t _Nm>
+    typename enable_if<
+      !std::__array_traits<_Tp, _Nm>::_Is_swappable::value>::type
+    swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete;
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&
+    get(array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "array index is within bounds");
+      return std::__array_traits<_Tp, _Nm>::
+ _S_ref(__arr._M_elems, _Int);
+    }
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&&
+    get(array<_Tp, _Nm>&& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "array index is within bounds");
+      return std::move(std::get<_Int>(__arr));
+    }
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr const _Tp&
+    get(const array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "array index is within bounds");
+      return std::__array_traits<_Tp, _Nm>::
+ _S_ref(__arr._M_elems, _Int);
+    }
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr const _Tp&&
+    get(const array<_Tp, _Nm>&& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "array index is within bounds");
+      return std::move(std::get<_Int>(__arr));
+    }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp>
+    struct tuple_size;
+  template<typename _Tp, std::size_t _Nm>
+    struct tuple_size<std::array<_Tp, _Nm>>
+    : public integral_constant<std::size_t, _Nm> { };
+  template<std::size_t _Int, typename _Tp>
+    struct tuple_element;
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    struct tuple_element<_Int, std::array<_Tp, _Nm>>
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      typedef _Tp type;
+    };
+  template<typename _Tp, std::size_t _Nm>
+    struct __is_tuple_like_impl<std::array<_Tp, _Nm>> : true_type
+    { };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  struct __erased_type { };
+  template<typename _Alloc, typename _Tp>
+    using __is_erased_or_convertible
+      = __or_<is_same<_Tp, __erased_type>, is_convertible<_Alloc, _Tp>>;
+  struct allocator_arg_t { explicit allocator_arg_t() = default; };
+  inline constexpr allocator_arg_t allocator_arg =
+    allocator_arg_t();
+  template<typename _Tp, typename _Alloc, typename = __void_t<>>
+    struct __uses_allocator_helper
+    : false_type { };
+  template<typename _Tp, typename _Alloc>
+    struct __uses_allocator_helper<_Tp, _Alloc,
+       __void_t<typename _Tp::allocator_type>>
+    : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type
+    { };
+  template<typename _Tp, typename _Alloc>
+    struct uses_allocator
+    : __uses_allocator_helper<_Tp, _Alloc>::type
+    { };
+  struct __uses_alloc_base { };
+  struct __uses_alloc0 : __uses_alloc_base
+  {
+    struct _Sink { void operator=(const void*) { } } _M_a;
+  };
+  template<typename _Alloc>
+    struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };
+  template<typename _Alloc>
+    struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };
+  template<bool, typename _Tp, typename _Alloc, typename... _Args>
+    struct __uses_alloc;
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __uses_alloc<true, _Tp, _Alloc, _Args...>
+    : conditional<
+        is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value,
+        __uses_alloc1<_Alloc>,
+        __uses_alloc2<_Alloc>>::type
+    {
+      static_assert(__or_<
+   is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>,
+   is_constructible<_Tp, _Args..., const _Alloc&>>::value,
+   "construction with an allocator must be possible"
+   " if uses_allocator is true");
+    };
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __uses_alloc<false, _Tp, _Alloc, _Args...>
+    : __uses_alloc0 { };
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    using __uses_alloc_t =
+      __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>;
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    inline __uses_alloc_t<_Tp, _Alloc, _Args...>
+    __use_alloc(const _Alloc& __a)
+    {
+      __uses_alloc_t<_Tp, _Alloc, _Args...> __ret;
+      __ret._M_a = std::__addressof(__a);
+      return __ret;
+    }
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    void
+    __use_alloc(const _Alloc&&) = delete;
+  template <typename _Tp, typename _Alloc>
+    inline constexpr bool uses_allocator_v =
+      uses_allocator<_Tp, _Alloc>::value;
+  template<template<typename...> class _Predicate,
+    typename _Tp, typename _Alloc, typename... _Args>
+    struct __is_uses_allocator_predicate
+    : conditional<uses_allocator<_Tp, _Alloc>::value,
+      __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>,
+     _Predicate<_Tp, _Args..., _Alloc>>,
+      _Predicate<_Tp, _Args...>>::type { };
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __is_uses_allocator_constructible
+    : __is_uses_allocator_predicate<is_constructible, _Tp, _Alloc, _Args...>
+    { };
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    inline constexpr bool __is_uses_allocator_constructible_v =
+      __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __is_nothrow_uses_allocator_constructible
+    : __is_uses_allocator_predicate<is_nothrow_constructible,
+        _Tp, _Alloc, _Args...>
+    { };
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    inline constexpr bool
+    __is_nothrow_uses_allocator_constructible_v =
+      __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;
+  template<typename _Tp, typename... _Args>
+    void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr,
+      _Args&&... __args)
+    { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); }
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr,
+      _Args&&... __args)
+    {
+      ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a,
+          std::forward<_Args>(__args)...);
+    }
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr,
+      _Args&&... __args)
+    { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); }
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr,
+        _Args&&... __args)
+    {
+      __uses_allocator_construct_impl(__use_alloc<_Tp, _Alloc, _Args...>(__a),
+          __ptr, std::forward<_Args>(__args)...);
+    }
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp, typename _Up = typename __inv_unwrap<_Tp>::type>
+    constexpr _Up&&
+    __invfwd(typename remove_reference<_Tp>::type& __t) noexcept
+    { return static_cast<_Up&&>(__t); }
+  template<typename _Res, typename _Fn, typename... _Args>
+    constexpr _Res
+    __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
+    { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    constexpr _Res
+    __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t,
+    _Args&&... __args)
+    { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); }
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    constexpr _Res
+    __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t,
+    _Args&&... __args)
+    {
+      return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...);
+    }
+  template<typename _Res, typename _MemPtr, typename _Tp>
+    constexpr _Res
+    __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t)
+    { return __invfwd<_Tp>(__t).*__f; }
+  template<typename _Res, typename _MemPtr, typename _Tp>
+    constexpr _Res
+    __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t)
+    { return (*std::forward<_Tp>(__t)).*__f; }
+  template<typename _Callable, typename... _Args>
+    constexpr typename __invoke_result<_Callable, _Args...>::type
+    __invoke(_Callable&& __fn, _Args&&... __args)
+    noexcept(__is_nothrow_invocable<_Callable, _Args...>::value)
+    {
+      using __result = __invoke_result<_Callable, _Args...>;
+      using __type = typename __result::type;
+      using __tag = typename __result::__invoke_type;
+      return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
+     std::forward<_Args>(__args)...);
+    }
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename... _Elements>
+    class tuple;
+  template<typename _Tp>
+    struct __is_empty_non_tuple : is_empty<_Tp> { };
+  template<typename _El0, typename... _El>
+    struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
+  template<typename _Tp>
+    using __empty_not_final
+    = typename conditional<__is_final(_Tp), false_type,
+      __is_empty_non_tuple<_Tp>>::type;
+  template<std::size_t _Idx, typename _Head,
+    bool = __empty_not_final<_Head>::value>
+    struct _Head_base;
+  template<std::size_t _Idx, typename _Head>
+    struct _Head_base<_Idx, _Head, true>
+    : public _Head
+    {
+      constexpr _Head_base()
+      : _Head() { }
+      constexpr _Head_base(const _Head& __h)
+      : _Head(__h) { }
+      constexpr _Head_base(const _Head_base&) = default;
+      constexpr _Head_base(_Head_base&&) = default;
+      template<typename _UHead>
+        constexpr _Head_base(_UHead&& __h)
+ : _Head(std::forward<_UHead>(__h)) { }
+      _Head_base(allocator_arg_t, __uses_alloc0)
+      : _Head() { }
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
+ : _Head(allocator_arg, *__a._M_a) { }
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
+ : _Head(*__a._M_a) { }
+      template<typename _UHead>
+ _Head_base(__uses_alloc0, _UHead&& __uhead)
+ : _Head(std::forward<_UHead>(__uhead)) { }
+      template<typename _Alloc, typename _UHead>
+ _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
+ : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
+      template<typename _Alloc, typename _UHead>
+ _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
+ : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
+      static constexpr _Head&
+      _M_head(_Head_base& __b) noexcept { return __b; }
+      static constexpr const _Head&
+      _M_head(const _Head_base& __b) noexcept { return __b; }
+    };
+  template<std::size_t _Idx, typename _Head>
+    struct _Head_base<_Idx, _Head, false>
+    {
+      constexpr _Head_base()
+      : _M_head_impl() { }
+      constexpr _Head_base(const _Head& __h)
+      : _M_head_impl(__h) { }
+      constexpr _Head_base(const _Head_base&) = default;
+      constexpr _Head_base(_Head_base&&) = default;
+      template<typename _UHead>
+        constexpr _Head_base(_UHead&& __h)
+ : _M_head_impl(std::forward<_UHead>(__h)) { }
+      _Head_base(allocator_arg_t, __uses_alloc0)
+      : _M_head_impl() { }
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
+ : _M_head_impl(allocator_arg, *__a._M_a) { }
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
+ : _M_head_impl(*__a._M_a) { }
+      template<typename _UHead>
+ _Head_base(__uses_alloc0, _UHead&& __uhead)
+ : _M_head_impl(std::forward<_UHead>(__uhead)) { }
+      template<typename _Alloc, typename _UHead>
+ _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
+ : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
+ { }
+      template<typename _Alloc, typename _UHead>
+ _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
+ : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
+      static constexpr _Head&
+      _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
+      static constexpr const _Head&
+      _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
+      _Head _M_head_impl;
+    };
+  template<std::size_t _Idx, typename... _Elements>
+    struct _Tuple_impl;
+  template<std::size_t _Idx, typename _Head, typename... _Tail>
+    struct _Tuple_impl<_Idx, _Head, _Tail...>
+    : public _Tuple_impl<_Idx + 1, _Tail...>,
+      private _Head_base<_Idx, _Head>
+    {
+      template<std::size_t, typename...> friend class _Tuple_impl;
+      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
+      typedef _Head_base<_Idx, _Head> _Base;
+      static constexpr _Head&
+      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+      static constexpr const _Head&
+      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+      static constexpr _Inherited&
+      _M_tail(_Tuple_impl& __t) noexcept { return __t; }
+      static constexpr const _Inherited&
+      _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
+      constexpr _Tuple_impl()
+      : _Inherited(), _Base() { }
+      explicit
+      constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
+      : _Inherited(__tail...), _Base(__head) { }
+      template<typename _UHead, typename... _UTail, typename = typename
+               enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
+        explicit
+        constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
+ : _Inherited(std::forward<_UTail>(__tail)...),
+   _Base(std::forward<_UHead>(__head)) { }
+      constexpr _Tuple_impl(const _Tuple_impl&) = default;
+      constexpr
+      _Tuple_impl(_Tuple_impl&& __in)
+      noexcept(__and_<is_nothrow_move_constructible<_Head>,
+               is_nothrow_move_constructible<_Inherited>>::value)
+      : _Inherited(std::move(_M_tail(__in))),
+ _Base(std::forward<_Head>(_M_head(__in))) { }
+      template<typename... _UElements>
+        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
+ : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
+   _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
+      template<typename _UHead, typename... _UTails>
+        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+ : _Inherited(std::move
+       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+   _Base(std::forward<_UHead>
+  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
+ : _Inherited(__tag, __a),
+          _Base(__tag, __use_alloc<_Head>(__a)) { }
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+      const _Head& __head, const _Tail&... __tail)
+ : _Inherited(__tag, __a, __tail...),
+          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
+      template<typename _Alloc, typename _UHead, typename... _UTail,
+               typename = typename enable_if<sizeof...(_Tail)
+          == sizeof...(_UTail)>::type>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _UHead&& __head, _UTail&&... __tail)
+ : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
+          _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+         std::forward<_UHead>(__head)) { }
+      template<typename _Alloc>
+        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             const _Tuple_impl& __in)
+ : _Inherited(__tag, __a, _M_tail(__in)),
+          _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _Tuple_impl&& __in)
+ : _Inherited(__tag, __a, std::move(_M_tail(__in))),
+   _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+         std::forward<_Head>(_M_head(__in))) { }
+      template<typename _Alloc, typename _UHead, typename... _UTails>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+      const _Tuple_impl<_Idx, _UHead, _UTails...>& __in)
+ : _Inherited(__tag, __a,
+       _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
+   _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
+  _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)) { }
+      template<typename _Alloc, typename _UHead, typename... _UTails>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+ : _Inherited(__tag, __a, std::move
+       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+   _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+                std::forward<_UHead>
+  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
+      _Tuple_impl&
+      operator=(const _Tuple_impl& __in)
+      {
+ _M_head(*this) = _M_head(__in);
+ _M_tail(*this) = _M_tail(__in);
+ return *this;
+      }
+      _Tuple_impl&
+      operator=(_Tuple_impl&& __in)
+      noexcept(__and_<is_nothrow_move_assignable<_Head>,
+               is_nothrow_move_assignable<_Inherited>>::value)
+      {
+ _M_head(*this) = std::forward<_Head>(_M_head(__in));
+ _M_tail(*this) = std::move(_M_tail(__in));
+ return *this;
+      }
+      template<typename... _UElements>
+        _Tuple_impl&
+        operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
+        {
+   _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
+   _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
+   return *this;
+ }
+      template<typename _UHead, typename... _UTails>
+        _Tuple_impl&
+        operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+        {
+   _M_head(*this) = std::forward<_UHead>
+     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
+   _M_tail(*this) = std::move
+     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
+   return *this;
+ }
+    protected:
+      void
+      _M_swap(_Tuple_impl& __in)
+      noexcept(__is_nothrow_swappable<_Head>::value
+               && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
+      {
+ using std::swap;
+ swap(_M_head(*this), _M_head(__in));
+ _Inherited::_M_swap(_M_tail(__in));
+      }
+    };
+  template<std::size_t _Idx, typename _Head>
+    struct _Tuple_impl<_Idx, _Head>
+    : private _Head_base<_Idx, _Head>
+    {
+      template<std::size_t, typename...> friend class _Tuple_impl;
+      typedef _Head_base<_Idx, _Head> _Base;
+      static constexpr _Head&
+      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+      static constexpr const _Head&
+      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
+      constexpr _Tuple_impl()
+      : _Base() { }
+      explicit
+      constexpr _Tuple_impl(const _Head& __head)
+      : _Base(__head) { }
+      template<typename _UHead>
+        explicit
+        constexpr _Tuple_impl(_UHead&& __head)
+ : _Base(std::forward<_UHead>(__head)) { }
+      constexpr _Tuple_impl(const _Tuple_impl&) = default;
+      constexpr
+      _Tuple_impl(_Tuple_impl&& __in)
+      noexcept(is_nothrow_move_constructible<_Head>::value)
+      : _Base(std::forward<_Head>(_M_head(__in))) { }
+      template<typename _UHead>
+        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
+ : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
+      template<typename _UHead>
+        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
+ : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+ { }
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
+ : _Base(__tag, __use_alloc<_Head>(__a)) { }
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+      const _Head& __head)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
+      template<typename _Alloc, typename _UHead>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _UHead&& __head)
+ : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+         std::forward<_UHead>(__head)) { }
+      template<typename _Alloc>
+        _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             const _Tuple_impl& __in)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _Tuple_impl&& __in)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+         std::forward<_Head>(_M_head(__in))) { }
+      template<typename _Alloc, typename _UHead>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             const _Tuple_impl<_Idx, _UHead>& __in)
+ : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
+  _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
+      template<typename _Alloc, typename _UHead>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _Tuple_impl<_Idx, _UHead>&& __in)
+ : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+                std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+ { }
+      _Tuple_impl&
+      operator=(const _Tuple_impl& __in)
+      {
+ _M_head(*this) = _M_head(__in);
+ return *this;
+      }
+      _Tuple_impl&
+      operator=(_Tuple_impl&& __in)
+      noexcept(is_nothrow_move_assignable<_Head>::value)
+      {
+ _M_head(*this) = std::forward<_Head>(_M_head(__in));
+ return *this;
+      }
+      template<typename _UHead>
+        _Tuple_impl&
+        operator=(const _Tuple_impl<_Idx, _UHead>& __in)
+        {
+   _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
+   return *this;
+ }
+      template<typename _UHead>
+        _Tuple_impl&
+        operator=(_Tuple_impl<_Idx, _UHead>&& __in)
+        {
+   _M_head(*this)
+     = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
+   return *this;
+ }
+    protected:
+      void
+      _M_swap(_Tuple_impl& __in)
+      noexcept(__is_nothrow_swappable<_Head>::value)
+      {
+ using std::swap;
+ swap(_M_head(*this), _M_head(__in));
+      }
+    };
+  template<bool, typename... _Elements>
+  struct _TC
+  {
+    template<typename... _UElements>
+    static constexpr bool _ConstructibleTuple()
+    {
+      return __and_<is_constructible<_Elements, const _UElements&>...>::value;
+    }
+    template<typename... _UElements>
+    static constexpr bool _ImplicitlyConvertibleTuple()
+    {
+      return __and_<is_convertible<const _UElements&, _Elements>...>::value;
+    }
+    template<typename... _UElements>
+    static constexpr bool _MoveConstructibleTuple()
+    {
+      return __and_<is_constructible<_Elements, _UElements&&>...>::value;
+    }
+    template<typename... _UElements>
+    static constexpr bool _ImplicitlyMoveConvertibleTuple()
+    {
+      return __and_<is_convertible<_UElements&&, _Elements>...>::value;
+    }
+    template<typename _SrcTuple>
+    static constexpr bool _NonNestedTuple()
+    {
+      return __and_<__not_<is_same<tuple<_Elements...>,
+                                   typename remove_cv<
+                                     typename remove_reference<_SrcTuple>::type
+                                   >::type>>,
+                     __not_<is_convertible<_SrcTuple, _Elements...>>,
+                     __not_<is_constructible<_Elements..., _SrcTuple>>
+              >::value;
+    }
+    template<typename... _UElements>
+    static constexpr bool _NotSameTuple()
+    {
+      return __not_<is_same<tuple<_Elements...>,
+        typename remove_const<
+          typename remove_reference<_UElements...>::type
+          >::type>>::value;
+    }
+  };
+  template<typename... _Elements>
+  struct _TC<false, _Elements...>
+  {
+    template<typename... _UElements>
+    static constexpr bool _ConstructibleTuple()
+    {
+      return false;
+    }
+    template<typename... _UElements>
+    static constexpr bool _ImplicitlyConvertibleTuple()
+    {
+      return false;
+    }
+    template<typename... _UElements>
+    static constexpr bool _MoveConstructibleTuple()
+    {
+      return false;
+    }
+    template<typename... _UElements>
+    static constexpr bool _ImplicitlyMoveConvertibleTuple()
+    {
+      return false;
+    }
+    template<typename... _UElements>
+    static constexpr bool _NonNestedTuple()
+    {
+      return true;
+    }
+    template<typename... _UElements>
+    static constexpr bool _NotSameTuple()
+    {
+      return true;
+    }
+  };
+  template<typename... _Elements>
+    class tuple : public _Tuple_impl<0, _Elements...>
+    {
+      typedef _Tuple_impl<0, _Elements...> _Inherited;
+      template<typename _Dummy>
+      struct _TC2
+      {
+        static constexpr bool _DefaultConstructibleTuple()
+        {
+          return __and_<is_default_constructible<_Elements>...>::value;
+        }
+        static constexpr bool _ImplicitlyDefaultConstructibleTuple()
+        {
+          return __and_<__is_implicitly_default_constructible<_Elements>...>
+            ::value;
+        }
+      };
+    public:
+      template<typename _Dummy = void,
+               typename enable_if<_TC2<_Dummy>::
+                                    _ImplicitlyDefaultConstructibleTuple(),
+                                  bool>::type = true>
+      constexpr tuple()
+      : _Inherited() { }
+      template<typename _Dummy = void,
+               typename enable_if<_TC2<_Dummy>::
+                                    _DefaultConstructibleTuple()
+                                  &&
+                                  !_TC2<_Dummy>::
+                                    _ImplicitlyDefaultConstructibleTuple(),
+                                  bool>::type = false>
+      explicit constexpr tuple()
+      : _Inherited() { }
+      template<typename _Dummy> using _TCC =
+        _TC<is_same<_Dummy, void>::value,
+            _Elements...>;
+      template<typename _Dummy = void,
+               typename enable_if<
+                 _TCC<_Dummy>::template
+                   _ConstructibleTuple<_Elements...>()
+                 && _TCC<_Dummy>::template
+                   _ImplicitlyConvertibleTuple<_Elements...>()
+                 && (sizeof...(_Elements) >= 1),
+               bool>::type=true>
+        constexpr tuple(const _Elements&... __elements)
+      : _Inherited(__elements...) { }
+      template<typename _Dummy = void,
+               typename enable_if<
+                 _TCC<_Dummy>::template
+                   _ConstructibleTuple<_Elements...>()
+                 && !_TCC<_Dummy>::template
+                   _ImplicitlyConvertibleTuple<_Elements...>()
+                 && (sizeof...(_Elements) >= 1),
+               bool>::type=false>
+      explicit constexpr tuple(const _Elements&... __elements)
+      : _Inherited(__elements...) { }
+      template<typename... _UElements> using _TMC =
+                  _TC<(sizeof...(_Elements) == sizeof...(_UElements))
+        && (_TC<(sizeof...(_UElements)==1), _Elements...>::
+     template _NotSameTuple<_UElements...>()),
+                      _Elements...>;
+      template<typename... _UElements> using _TMCT =
+                  _TC<(sizeof...(_Elements) == sizeof...(_UElements))
+        && !is_same<tuple<_Elements...>,
+      tuple<_UElements...>>::value,
+                      _Elements...>;
+      template<typename... _UElements, typename
+        enable_if<
+    _TMC<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && _TMC<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
+                  && (sizeof...(_Elements) >= 1),
+        bool>::type=true>
+        constexpr tuple(_UElements&&... __elements)
+        : _Inherited(std::forward<_UElements>(__elements)...) { }
+      template<typename... _UElements, typename
+        enable_if<
+    _TMC<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && !_TMC<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
+                  && (sizeof...(_Elements) >= 1),
+        bool>::type=false>
+        explicit constexpr tuple(_UElements&&... __elements)
+ : _Inherited(std::forward<_UElements>(__elements)...) { }
+      constexpr tuple(const tuple&) = default;
+      constexpr tuple(tuple&&) = default;
+      template<typename _Dummy> using _TNTC =
+        _TC<is_same<_Dummy, void>::value && sizeof...(_Elements) == 1,
+            _Elements...>;
+      template<typename... _UElements, typename _Dummy = void, typename
+        enable_if<_TMCT<_UElements...>::template
+                    _ConstructibleTuple<_UElements...>()
+                  && _TMCT<_UElements...>::template
+                    _ImplicitlyConvertibleTuple<_UElements...>()
+                  && _TNTC<_Dummy>::template
+                    _NonNestedTuple<const tuple<_UElements...>&>(),
+        bool>::type=true>
+        constexpr tuple(const tuple<_UElements...>& __in)
+        : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+        { }
+      template<typename... _UElements, typename _Dummy = void, typename
+        enable_if<_TMCT<_UElements...>::template
+                    _ConstructibleTuple<_UElements...>()
+                  && !_TMCT<_UElements...>::template
+                    _ImplicitlyConvertibleTuple<_UElements...>()
+                  && _TNTC<_Dummy>::template
+                    _NonNestedTuple<const tuple<_UElements...>&>(),
+        bool>::type=false>
+        explicit constexpr tuple(const tuple<_UElements...>& __in)
+        : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+        { }
+      template<typename... _UElements, typename _Dummy = void, typename
+        enable_if<_TMCT<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && _TMCT<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
+                  && _TNTC<_Dummy>::template
+                    _NonNestedTuple<tuple<_UElements...>&&>(),
+        bool>::type=true>
+        constexpr tuple(tuple<_UElements...>&& __in)
+        : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
+      template<typename... _UElements, typename _Dummy = void, typename
+        enable_if<_TMCT<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && !_TMCT<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
+                  && _TNTC<_Dummy>::template
+                    _NonNestedTuple<tuple<_UElements...>&&>(),
+        bool>::type=false>
+        explicit constexpr tuple(tuple<_UElements...>&& __in)
+        : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
+      template<typename _Alloc>
+ tuple(allocator_arg_t __tag, const _Alloc& __a)
+ : _Inherited(__tag, __a) { }
+      template<typename _Alloc, typename _Dummy = void,
+               typename enable_if<
+                 _TCC<_Dummy>::template
+                   _ConstructibleTuple<_Elements...>()
+                 && _TCC<_Dummy>::template
+                   _ImplicitlyConvertibleTuple<_Elements...>(),
+               bool>::type=true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const _Elements&... __elements)
+ : _Inherited(__tag, __a, __elements...) { }
+      template<typename _Alloc, typename _Dummy = void,
+               typename enable_if<
+                 _TCC<_Dummy>::template
+                   _ConstructibleTuple<_Elements...>()
+                 && !_TCC<_Dummy>::template
+                   _ImplicitlyConvertibleTuple<_Elements...>(),
+               bool>::type=false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+                       const _Elements&... __elements)
+ : _Inherited(__tag, __a, __elements...) { }
+      template<typename _Alloc, typename... _UElements, typename
+        enable_if<_TMC<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && _TMC<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>(),
+        bool>::type=true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       _UElements&&... __elements)
+ : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
+        { }
+      template<typename _Alloc, typename... _UElements, typename
+        enable_if<_TMC<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && !_TMC<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>(),
+        bool>::type=false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+       _UElements&&... __elements)
+ : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
+        { }
+      template<typename _Alloc>
+ tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
+ : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
+      template<typename _Alloc>
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
+ : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
+      template<typename _Alloc, typename _Dummy = void,
+        typename... _UElements, typename
+        enable_if<_TMCT<_UElements...>::template
+                    _ConstructibleTuple<_UElements...>()
+                  && _TMCT<_UElements...>::template
+                    _ImplicitlyConvertibleTuple<_UElements...>()
+                  && _TNTC<_Dummy>::template
+                    _NonNestedTuple<tuple<_UElements...>&&>(),
+        bool>::type=true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const tuple<_UElements...>& __in)
+ : _Inherited(__tag, __a,
+              static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ { }
+      template<typename _Alloc, typename _Dummy = void,
+        typename... _UElements, typename
+        enable_if<_TMCT<_UElements...>::template
+                    _ConstructibleTuple<_UElements...>()
+                  && !_TMCT<_UElements...>::template
+                    _ImplicitlyConvertibleTuple<_UElements...>()
+                  && _TNTC<_Dummy>::template
+                    _NonNestedTuple<tuple<_UElements...>&&>(),
+        bool>::type=false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const tuple<_UElements...>& __in)
+ : _Inherited(__tag, __a,
+              static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ { }
+      template<typename _Alloc, typename _Dummy = void,
+        typename... _UElements, typename
+        enable_if<_TMCT<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && _TMCT<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
+                  && _TNTC<_Dummy>::template
+                    _NonNestedTuple<tuple<_UElements...>&&>(),
+        bool>::type=true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       tuple<_UElements...>&& __in)
+ : _Inherited(__tag, __a,
+              static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+ { }
+      template<typename _Alloc, typename _Dummy = void,
+        typename... _UElements, typename
+        enable_if<_TMCT<_UElements...>::template
+                    _MoveConstructibleTuple<_UElements...>()
+                  && !_TMCT<_UElements...>::template
+                    _ImplicitlyMoveConvertibleTuple<_UElements...>()
+                  && _TNTC<_Dummy>::template
+                    _NonNestedTuple<tuple<_UElements...>&&>(),
+        bool>::type=false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+       tuple<_UElements...>&& __in)
+ : _Inherited(__tag, __a,
+              static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+ { }
+      tuple&
+      operator=(const tuple& __in)
+      {
+ static_cast<_Inherited&>(*this) = __in;
+ return *this;
+      }
+      tuple&
+      operator=(tuple&& __in)
+      noexcept(is_nothrow_move_assignable<_Inherited>::value)
+      {
+ static_cast<_Inherited&>(*this) = std::move(__in);
+ return *this;
+      }
+      template<typename... _UElements>
+ typename
+        enable_if<sizeof...(_UElements)
+    == sizeof...(_Elements), tuple&>::type
+        operator=(const tuple<_UElements...>& __in)
+        {
+   static_cast<_Inherited&>(*this) = __in;
+   return *this;
+ }
+      template<typename... _UElements>
+ typename
+        enable_if<sizeof...(_UElements)
+    == sizeof...(_Elements), tuple&>::type
+        operator=(tuple<_UElements...>&& __in)
+        {
+   static_cast<_Inherited&>(*this) = std::move(__in);
+   return *this;
+ }
+      void
+      swap(tuple& __in)
+      noexcept(noexcept(__in._M_swap(__in)))
+      { _Inherited::_M_swap(__in); }
+    };
+  template<typename... _UTypes>
+    tuple(_UTypes...) -> tuple<_UTypes...>;
+  template<typename _T1, typename _T2>
+    tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>;
+  template<typename _Alloc, typename... _UTypes>
+    tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>;
+  template<typename _Alloc, typename _T1, typename _T2>
+    tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>;
+  template<typename _Alloc, typename... _UTypes>
+    tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>;
+  template<>
+    class tuple<>
+    {
+    public:
+      void swap(tuple&) noexcept { }
+      tuple() = default;
+      template<typename _Alloc>
+ tuple(allocator_arg_t, const _Alloc&) { }
+      template<typename _Alloc>
+ tuple(allocator_arg_t, const _Alloc&, const tuple&) { }
+    };
+  template<typename _T1, typename _T2>
+    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
+    {
+      typedef _Tuple_impl<0, _T1, _T2> _Inherited;
+    public:
+      template <typename _U1 = _T1,
+                typename _U2 = _T2,
+                typename enable_if<__and_<
+                                     __is_implicitly_default_constructible<_U1>,
+                                     __is_implicitly_default_constructible<_U2>>
+                                   ::value, bool>::type = true>
+      constexpr tuple()
+      : _Inherited() { }
+      template <typename _U1 = _T1,
+                typename _U2 = _T2,
+                typename enable_if<
+                  __and_<
+                    is_default_constructible<_U1>,
+                    is_default_constructible<_U2>,
+                    __not_<
+                      __and_<__is_implicitly_default_constructible<_U1>,
+                             __is_implicitly_default_constructible<_U2>>>>
+                  ::value, bool>::type = false>
+      explicit constexpr tuple()
+      : _Inherited() { }
+      template<typename _Dummy> using _TCC =
+        _TC<is_same<_Dummy, void>::value, _T1, _T2>;
+      template<typename _Dummy = void, typename
+               enable_if<_TCC<_Dummy>::template
+                           _ConstructibleTuple<_T1, _T2>()
+                         && _TCC<_Dummy>::template
+                           _ImplicitlyConvertibleTuple<_T1, _T2>(),
+ bool>::type = true>
+        constexpr tuple(const _T1& __a1, const _T2& __a2)
+        : _Inherited(__a1, __a2) { }
+      template<typename _Dummy = void, typename
+               enable_if<_TCC<_Dummy>::template
+                           _ConstructibleTuple<_T1, _T2>()
+                         && !_TCC<_Dummy>::template
+                           _ImplicitlyConvertibleTuple<_T1, _T2>(),
+ bool>::type = false>
+        explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
+        : _Inherited(__a1, __a2) { }
+      using _TMC = _TC<true, _T1, _T2>;
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>()
+           && !is_same<typename decay<_U1>::type,
+         allocator_arg_t>::value,
+ bool>::type = true>
+        constexpr tuple(_U1&& __a1, _U2&& __a2)
+ : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>()
+           && !is_same<typename decay<_U1>::type,
+         allocator_arg_t>::value,
+ bool>::type = false>
+        explicit constexpr tuple(_U1&& __a1, _U2&& __a2)
+ : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
+      constexpr tuple(const tuple&) = default;
+      constexpr tuple(tuple&&) = default;
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+        constexpr tuple(const tuple<_U1, _U2>& __in)
+ : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+        explicit constexpr tuple(const tuple<_U1, _U2>& __in)
+ : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+        constexpr tuple(tuple<_U1, _U2>&& __in)
+ : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+        explicit constexpr tuple(tuple<_U1, _U2>&& __in)
+ : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+        constexpr tuple(const pair<_U1, _U2>& __in)
+ : _Inherited(__in.first, __in.second) { }
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+        explicit constexpr tuple(const pair<_U1, _U2>& __in)
+ : _Inherited(__in.first, __in.second) { }
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+        constexpr tuple(pair<_U1, _U2>&& __in)
+ : _Inherited(std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+      template<typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+        explicit constexpr tuple(pair<_U1, _U2>&& __in)
+ : _Inherited(std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+      template<typename _Alloc>
+ tuple(allocator_arg_t __tag, const _Alloc& __a)
+ : _Inherited(__tag, __a) { }
+      template<typename _Alloc, typename _Dummy = void,
+               typename enable_if<
+                 _TCC<_Dummy>::template
+                   _ConstructibleTuple<_T1, _T2>()
+                 && _TCC<_Dummy>::template
+                   _ImplicitlyConvertibleTuple<_T1, _T2>(),
+               bool>::type=true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const _T1& __a1, const _T2& __a2)
+ : _Inherited(__tag, __a, __a1, __a2) { }
+      template<typename _Alloc, typename _Dummy = void,
+               typename enable_if<
+                 _TCC<_Dummy>::template
+                   _ConstructibleTuple<_T1, _T2>()
+                 && !_TCC<_Dummy>::template
+                   _ImplicitlyConvertibleTuple<_T1, _T2>(),
+               bool>::type=false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const _T1& __a1, const _T2& __a2)
+ : _Inherited(__tag, __a, __a1, __a2) { }
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
+ : _Inherited(__tag, __a, std::forward<_U1>(__a1),
+              std::forward<_U2>(__a2)) { }
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+                       _U1&& __a1, _U2&& __a2)
+ : _Inherited(__tag, __a, std::forward<_U1>(__a1),
+              std::forward<_U2>(__a2)) { }
+      template<typename _Alloc>
+ tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
+ : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
+      template<typename _Alloc>
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
+ : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const tuple<_U1, _U2>& __in)
+ : _Inherited(__tag, __a,
+              static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
+ { }
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const tuple<_U1, _U2>& __in)
+ : _Inherited(__tag, __a,
+              static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
+ { }
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
+ : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
+ { }
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+ explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+                       tuple<_U1, _U2>&& __in)
+ : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
+ { }
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+        tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const pair<_U1, _U2>& __in)
+ : _Inherited(__tag, __a, __in.first, __in.second) { }
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _ConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+        explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const pair<_U1, _U2>& __in)
+ : _Inherited(__tag, __a, __in.first, __in.second) { }
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && _TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = true>
+        tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
+ : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+      template<typename _Alloc, typename _U1, typename _U2, typename
+        enable_if<_TMC::template
+                    _MoveConstructibleTuple<_U1, _U2>()
+                  && !_TMC::template
+                    _ImplicitlyMoveConvertibleTuple<_U1, _U2>(),
+ bool>::type = false>
+        explicit tuple(allocator_arg_t __tag, const _Alloc& __a,
+                       pair<_U1, _U2>&& __in)
+ : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+      tuple&
+      operator=(const tuple& __in)
+      {
+ static_cast<_Inherited&>(*this) = __in;
+ return *this;
+      }
+      tuple&
+      operator=(tuple&& __in)
+      noexcept(is_nothrow_move_assignable<_Inherited>::value)
+      {
+ static_cast<_Inherited&>(*this) = std::move(__in);
+ return *this;
+      }
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(const tuple<_U1, _U2>& __in)
+        {
+   static_cast<_Inherited&>(*this) = __in;
+   return *this;
+ }
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(tuple<_U1, _U2>&& __in)
+        {
+   static_cast<_Inherited&>(*this) = std::move(__in);
+   return *this;
+ }
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(const pair<_U1, _U2>& __in)
+        {
+   this->_M_head(*this) = __in.first;
+   this->_M_tail(*this)._M_head(*this) = __in.second;
+   return *this;
+ }
+      template<typename _U1, typename _U2>
+        tuple&
+        operator=(pair<_U1, _U2>&& __in)
+        {
+   this->_M_head(*this) = std::forward<_U1>(__in.first);
+   this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
+   return *this;
+ }
+      void
+      swap(tuple& __in)
+      noexcept(noexcept(__in._M_swap(__in)))
+      { _Inherited::_M_swap(__in); }
+    };
+  template<typename... _Elements>
+    struct tuple_size<tuple<_Elements...>>
+    : public integral_constant<std::size_t, sizeof...(_Elements)> { };
+  template <typename _Tp>
+    inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
+  template<std::size_t __i, typename _Head, typename... _Tail>
+    struct tuple_element<__i, tuple<_Head, _Tail...> >
+    : tuple_element<__i - 1, tuple<_Tail...> > { };
+  template<typename _Head, typename... _Tail>
+    struct tuple_element<0, tuple<_Head, _Tail...> >
+    {
+      typedef _Head type;
+    };
+  template<size_t __i>
+    struct tuple_element<__i, tuple<>>
+    {
+      static_assert(__i < tuple_size<tuple<>>::value,
+   "tuple index is in range");
+    };
+  template<std::size_t __i, typename _Head, typename... _Tail>
+    constexpr _Head&
+    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+  template<std::size_t __i, typename _Head, typename... _Tail>
+    constexpr const _Head&
+    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+  template<std::size_t __i, typename... _Elements>
+    constexpr __tuple_element_t<__i, tuple<_Elements...>>&
+    get(tuple<_Elements...>& __t) noexcept
+    { return std::__get_helper<__i>(__t); }
+  template<std::size_t __i, typename... _Elements>
+    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
+    get(const tuple<_Elements...>& __t) noexcept
+    { return std::__get_helper<__i>(__t); }
+  template<std::size_t __i, typename... _Elements>
+    constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
+    get(tuple<_Elements...>&& __t) noexcept
+    {
+      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
+      return std::forward<__element_type&&>(std::get<__i>(__t));
+    }
+  template<std::size_t __i, typename... _Elements>
+    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
+    get(const tuple<_Elements...>&& __t) noexcept
+    {
+      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
+      return std::forward<const __element_type&&>(std::get<__i>(__t));
+    }
+  template<typename _Head, size_t __i, typename... _Tail>
+    constexpr _Head&
+    __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+  template<typename _Head, size_t __i, typename... _Tail>
+    constexpr const _Head&
+    __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+  template <typename _Tp, typename... _Types>
+    constexpr _Tp&
+    get(tuple<_Types...>& __t) noexcept
+    { return std::__get_helper2<_Tp>(__t); }
+  template <typename _Tp, typename... _Types>
+    constexpr _Tp&&
+    get(tuple<_Types...>&& __t) noexcept
+    { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
+  template <typename _Tp, typename... _Types>
+    constexpr const _Tp&
+    get(const tuple<_Types...>& __t) noexcept
+    { return std::__get_helper2<_Tp>(__t); }
+  template <typename _Tp, typename... _Types>
+    constexpr const _Tp&&
+    get(const tuple<_Types...>&& __t) noexcept
+    { return std::forward<const _Tp&&>(std::__get_helper2<_Tp>(__t)); }
+  template<typename _Tp, typename _Up, size_t __i, size_t __size>
+    struct __tuple_compare
+    {
+      static constexpr bool
+      __eq(const _Tp& __t, const _Up& __u)
+      {
+ return bool(std::get<__i>(__t) == std::get<__i>(__u))
+   && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
+      }
+      static constexpr bool
+      __less(const _Tp& __t, const _Up& __u)
+      {
+ return bool(std::get<__i>(__t) < std::get<__i>(__u))
+   || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
+       && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
+      }
+    };
+  template<typename _Tp, typename _Up, size_t __size>
+    struct __tuple_compare<_Tp, _Up, __size, __size>
+    {
+      static constexpr bool
+      __eq(const _Tp&, const _Up&) { return true; }
+      static constexpr bool
+      __less(const _Tp&, const _Up&) { return false; }
+    };
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator==(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    {
+      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
+   "tuple objects can only be compared if they have equal sizes.");
+      using __compare = __tuple_compare<tuple<_TElements...>,
+     tuple<_UElements...>,
+     0, sizeof...(_TElements)>;
+      return __compare::__eq(__t, __u);
+    }
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator<(const tuple<_TElements...>& __t,
+       const tuple<_UElements...>& __u)
+    {
+      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
+   "tuple objects can only be compared if they have equal sizes.");
+      using __compare = __tuple_compare<tuple<_TElements...>,
+     tuple<_UElements...>,
+     0, sizeof...(_TElements)>;
+      return __compare::__less(__t, __u);
+    }
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator!=(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    { return !(__t == __u); }
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator>(const tuple<_TElements...>& __t,
+       const tuple<_UElements...>& __u)
+    { return __u < __t; }
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator<=(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    { return !(__u < __t); }
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator>=(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    { return !(__t < __u); }
+  template<typename... _Elements>
+    constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
+    make_tuple(_Elements&&... __args)
+    {
+      typedef tuple<typename __decay_and_strip<_Elements>::__type...>
+ __result_type;
+      return __result_type(std::forward<_Elements>(__args)...);
+    }
+  template<typename... _Elements>
+    constexpr tuple<_Elements&&...>
+    forward_as_tuple(_Elements&&... __args) noexcept
+    { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
+  template<size_t, typename, typename, size_t>
+    struct __make_tuple_impl;
+  template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
+    struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
+    : __make_tuple_impl<_Idx + 1,
+   tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
+   _Tuple, _Nm>
+    { };
+  template<std::size_t _Nm, typename _Tuple, typename... _Tp>
+    struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
+    {
+      typedef tuple<_Tp...> __type;
+    };
+  template<typename _Tuple>
+    struct __do_make_tuple
+    : __make_tuple_impl<0, tuple<>, _Tuple, std::tuple_size<_Tuple>::value>
+    { };
+  template<typename _Tuple>
+    struct __make_tuple
+    : public __do_make_tuple<typename std::remove_cv
+            <typename std::remove_reference<_Tuple>::type>::type>
+    { };
+  template<typename...>
+    struct __combine_tuples;
+  template<>
+    struct __combine_tuples<>
+    {
+      typedef tuple<> __type;
+    };
+  template<typename... _Ts>
+    struct __combine_tuples<tuple<_Ts...>>
+    {
+      typedef tuple<_Ts...> __type;
+    };
+  template<typename... _T1s, typename... _T2s, typename... _Rem>
+    struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
+    {
+      typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
+     _Rem...>::__type __type;
+    };
+  template<typename... _Tpls>
+    struct __tuple_cat_result
+    {
+      typedef typename __combine_tuples
+        <typename __make_tuple<_Tpls>::__type...>::__type __type;
+    };
+  template<typename...>
+    struct __make_1st_indices;
+  template<>
+    struct __make_1st_indices<>
+    {
+      typedef std::_Index_tuple<> __type;
+    };
+  template<typename _Tp, typename... _Tpls>
+    struct __make_1st_indices<_Tp, _Tpls...>
+    {
+      typedef typename std::_Build_index_tuple<std::tuple_size<
+ typename std::remove_reference<_Tp>::type>::value>::__type __type;
+    };
+  template<typename _Ret, typename _Indices, typename... _Tpls>
+    struct __tuple_concater;
+  template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
+    struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
+    {
+      template<typename... _Us>
+        static constexpr _Ret
+        _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
+        {
+   typedef typename __make_1st_indices<_Tpls...>::__type __idx;
+   typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
+   return __next::_S_do(std::forward<_Tpls>(__tps)...,
+          std::forward<_Us>(__us)...,
+          std::get<_Is>(std::forward<_Tp>(__tp))...);
+ }
+    };
+  template<typename _Ret>
+    struct __tuple_concater<_Ret, std::_Index_tuple<>>
+    {
+      template<typename... _Us>
+ static constexpr _Ret
+ _S_do(_Us&&... __us)
+        {
+   return _Ret(std::forward<_Us>(__us)...);
+ }
+    };
+  template<typename... _Tpls, typename = typename
+           enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
+    constexpr auto
+    tuple_cat(_Tpls&&... __tpls)
+    -> typename __tuple_cat_result<_Tpls...>::__type
+    {
+      typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
+      typedef typename __make_1st_indices<_Tpls...>::__type __idx;
+      typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
+      return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
+    }
+  template<typename... _Elements>
+    constexpr tuple<_Elements&...>
+    tie(_Elements&... __args) noexcept
+    { return tuple<_Elements&...>(__args...); }
+  template<typename... _Elements>
+    inline
+    typename enable_if<__and_<__is_swappable<_Elements>...>::value
+      >::type
+    swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+  template<typename... _Elements>
+    typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
+    swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;
+  struct _Swallow_assign
+  {
+    template<class _Tp>
+      constexpr const _Swallow_assign&
+      operator=(const _Tp&) const
+      { return *this; }
+  };
+  inline constexpr _Swallow_assign ignore{};
+  template<typename... _Types, typename _Alloc>
+    struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
+  template<class _T1, class _T2>
+    template<typename... _Args1, typename... _Args2>
+      inline
+      pair<_T1, _T2>::
+      pair(piecewise_construct_t,
+    tuple<_Args1...> __first, tuple<_Args2...> __second)
+      : pair(__first, __second,
+      typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
+      typename _Build_index_tuple<sizeof...(_Args2)>::__type())
+      { }
+  template<class _T1, class _T2>
+    template<typename... _Args1, std::size_t... _Indexes1,
+             typename... _Args2, std::size_t... _Indexes2>
+      inline
+      pair<_T1, _T2>::
+      pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
+    _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
+      : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
+        second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
+      { }
+  template <typename _Fn, typename _Tuple, size_t... _Idx>
+    constexpr decltype(auto)
+    __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>)
+    {
+      return std::__invoke(std::forward<_Fn>(__f),
+      std::get<_Idx>(std::forward<_Tuple>(__t))...);
+    }
+  template <typename _Fn, typename _Tuple>
+    constexpr decltype(auto)
+    apply(_Fn&& __f, _Tuple&& __t)
+    {
+      using _Indices = make_index_sequence<tuple_size_v<decay_t<_Tuple>>>;
+      return std::__apply_impl(std::forward<_Fn>(__f),
+          std::forward<_Tuple>(__t),
+          _Indices{});
+    }
+  template <typename _Tp, typename _Tuple, size_t... _Idx>
+    constexpr _Tp
+    __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>)
+    { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); }
+  template <typename _Tp, typename _Tuple>
+    constexpr _Tp
+    make_from_tuple(_Tuple&& __t)
+    {
+      return __make_from_tuple_impl<_Tp>(
+        std::forward<_Tuple>(__t),
+ make_index_sequence<tuple_size_v<decay_t<_Tuple>>>{});
+    }
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Res, typename... _ArgTypes>
+    struct _Maybe_unary_or_binary_function { };
+  template<typename _Res, typename _T1>
+    struct _Maybe_unary_or_binary_function<_Res, _T1>
+    : std::unary_function<_T1, _Res> { };
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
+    : std::binary_function<_T1, _T2, _Res> { };
+  template<typename _Signature>
+    struct _Mem_fn_traits;
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Mem_fn_traits_base
+    {
+      using __result_type = _Res;
+      using __maybe_type
+ = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
+      using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
+    };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+  template<typename _Functor, typename = __void_t<>>
+    struct _Maybe_get_result_type
+    { };
+  template<typename _Functor>
+    struct _Maybe_get_result_type<_Functor,
+      __void_t<typename _Functor::result_type>>
+    { typedef typename _Functor::result_type result_type; };
+  template<typename _Functor>
+    struct _Weak_result_type_impl
+    : _Maybe_get_result_type<_Functor>
+    { };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)>
+    { typedef _Res result_type; };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)>
+    { typedef _Res result_type; };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)>
+    { typedef _Res result_type; };
+  template<typename _Res, typename... _ArgTypes , bool _NE>
+    struct
+    _Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)>
+    { typedef _Res result_type; };
+  template<typename _Functor,
+    bool = is_member_function_pointer<_Functor>::value>
+    struct _Weak_result_type_memfun
+    : _Weak_result_type_impl<_Functor>
+    { };
+  template<typename _MemFunPtr>
+    struct _Weak_result_type_memfun<_MemFunPtr, true>
+    {
+      using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
+    };
+  template<typename _Func, typename _Class>
+    struct _Weak_result_type_memfun<_Func _Class::*, false>
+    { };
+  template<typename _Functor>
+    struct _Weak_result_type
+    : _Weak_result_type_memfun<typename remove_cv<_Functor>::type>
+    { };
+  template<typename _Tp, typename = __void_t<>>
+    struct _Refwrap_base_arg1
+    { };
+  template<typename _Tp>
+    struct _Refwrap_base_arg1<_Tp,
+         __void_t<typename _Tp::argument_type>>
+    {
+      typedef typename _Tp::argument_type argument_type;
+    };
+  template<typename _Tp, typename = __void_t<>>
+    struct _Refwrap_base_arg2
+    { };
+  template<typename _Tp>
+    struct _Refwrap_base_arg2<_Tp,
+         __void_t<typename _Tp::first_argument_type,
+           typename _Tp::second_argument_type>>
+    {
+      typedef typename _Tp::first_argument_type first_argument_type;
+      typedef typename _Tp::second_argument_type second_argument_type;
+    };
+  template<typename _Tp>
+    struct _Reference_wrapper_base
+    : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp>
+    { };
+  template<typename _Res, typename _T1 , bool _NE>
+    struct _Reference_wrapper_base<_Res(_T1) noexcept (_NE)>
+    : unary_function<_T1, _Res>
+    { };
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) const>
+    : unary_function<_T1, _Res>
+    { };
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) volatile>
+    : unary_function<_T1, _Res>
+    { };
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) const volatile>
+    : unary_function<_T1, _Res>
+    { };
+  template<typename _Res, typename _T1, typename _T2 , bool _NE>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) noexcept (_NE)>
+    : binary_function<_T1, _T2, _Res>
+    { };
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) const>
+    : binary_function<_T1, _T2, _Res>
+    { };
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
+    : binary_function<_T1, _T2, _Res>
+    { };
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
+    : binary_function<_T1, _T2, _Res>
+    { };
+  template<typename _Res, typename _T1 , bool _NE>
+    struct _Reference_wrapper_base<_Res(*)(_T1) noexcept (_NE)>
+    : unary_function<_T1, _Res>
+    { };
+  template<typename _Res, typename _T1, typename _T2 , bool _NE>
+    struct _Reference_wrapper_base<_Res(*)(_T1, _T2) noexcept (_NE)>
+    : binary_function<_T1, _T2, _Res>
+    { };
+  template<typename _Tp, bool = is_member_function_pointer<_Tp>::value>
+    struct _Reference_wrapper_base_memfun
+    : _Reference_wrapper_base<_Tp>
+    { };
+  template<typename _MemFunPtr>
+    struct _Reference_wrapper_base_memfun<_MemFunPtr, true>
+    : _Mem_fn_traits<_MemFunPtr>::__maybe_type
+    {
+      using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
+    };
+  template<typename _Tp>
+    class reference_wrapper
+    : public _Reference_wrapper_base_memfun<typename remove_cv<_Tp>::type>
+    {
+      _Tp* _M_data;
+    public:
+      typedef _Tp type;
+      reference_wrapper(_Tp& __indata) noexcept
+      : _M_data(std::__addressof(__indata))
+      { }
+      reference_wrapper(_Tp&&) = delete;
+      reference_wrapper(const reference_wrapper&) = default;
+      reference_wrapper&
+      operator=(const reference_wrapper&) = default;
+      operator _Tp&() const noexcept
+      { return this->get(); }
+      _Tp&
+      get() const noexcept
+      { return *_M_data; }
+      template<typename... _Args>
+ typename result_of<_Tp&(_Args&&...)>::type
+ operator()(_Args&&... __args) const
+ {
+   return std::__invoke(get(), std::forward<_Args>(__args)...);
+ }
+    };
+  template<typename _Tp>
+    inline reference_wrapper<_Tp>
+    ref(_Tp& __t) noexcept
+    { return reference_wrapper<_Tp>(__t); }
+  template<typename _Tp>
+    inline reference_wrapper<const _Tp>
+    cref(const _Tp& __t) noexcept
+    { return reference_wrapper<const _Tp>(__t); }
+  template<typename _Tp>
+    void ref(const _Tp&&) = delete;
+  template<typename _Tp>
+    void cref(const _Tp&&) = delete;
+  template<typename _Tp>
+    inline reference_wrapper<_Tp>
+    ref(reference_wrapper<_Tp> __t) noexcept
+    { return __t; }
+  template<typename _Tp>
+    inline reference_wrapper<const _Tp>
+    cref(reference_wrapper<_Tp> __t) noexcept
+    { return { __t.get() }; }
+
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  class bad_function_call : public std::exception
+  {
+  public:
+    virtual ~bad_function_call() noexcept;
+    const char* what() const noexcept;
+  };
+  template<typename _Tp>
+    struct __is_location_invariant
+    : is_trivially_copyable<_Tp>::type
+    { };
+  class _Undefined_class;
+  union _Nocopy_types
+  {
+    void* _M_object;
+    const void* _M_const_object;
+    void (*_M_function_pointer)();
+    void (_Undefined_class::*_M_member_pointer)();
+  };
+  union [[gnu::may_alias]] _Any_data
+  {
+    void* _M_access() { return &_M_pod_data[0]; }
+    const void* _M_access() const { return &_M_pod_data[0]; }
+    template<typename _Tp>
+      _Tp&
+      _M_access()
+      { return *static_cast<_Tp*>(_M_access()); }
+    template<typename _Tp>
+      const _Tp&
+      _M_access() const
+      { return *static_cast<const _Tp*>(_M_access()); }
+    _Nocopy_types _M_unused;
+    char _M_pod_data[sizeof(_Nocopy_types)];
+  };
+  enum _Manager_operation
+  {
+    __get_type_info,
+    __get_functor_ptr,
+    __clone_functor,
+    __destroy_functor
+  };
+  template<typename _Tp>
+    struct _Simple_type_wrapper
+    {
+      _Simple_type_wrapper(_Tp __value) : __value(__value) { }
+      _Tp __value;
+    };
+  template<typename _Tp>
+    struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
+    : __is_location_invariant<_Tp>
+    { };
+  template<typename _Signature>
+    class function;
+  class _Function_base
+  {
+  public:
+    static const std::size_t _M_max_size = sizeof(_Nocopy_types);
+    static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
+    template<typename _Functor>
+      class _Base_manager
+      {
+      protected:
+ static const bool __stored_locally =
+ (__is_location_invariant<_Functor>::value
+  && sizeof(_Functor) <= _M_max_size
+  && __alignof__(_Functor) <= _M_max_align
+  && (_M_max_align % __alignof__(_Functor) == 0));
+ typedef integral_constant<bool, __stored_locally> _Local_storage;
+ static _Functor*
+ _M_get_pointer(const _Any_data& __source)
+ {
+   const _Functor* __ptr =
+     __stored_locally? std::__addressof(__source._M_access<_Functor>())
+                                 : __source._M_access<_Functor*>();
+   return const_cast<_Functor*>(__ptr);
+ }
+ static void
+ _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
+ {
+   ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
+ }
+ static void
+ _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
+ {
+   __dest._M_access<_Functor*>() =
+     new _Functor(*__source._M_access<_Functor*>());
+ }
+ static void
+ _M_destroy(_Any_data& __victim, true_type)
+ {
+   __victim._M_access<_Functor>().~_Functor();
+ }
+ static void
+ _M_destroy(_Any_data& __victim, false_type)
+ {
+   delete __victim._M_access<_Functor*>();
+ }
+      public:
+ static bool
+ _M_manager(_Any_data& __dest, const _Any_data& __source,
+     _Manager_operation __op)
+ {
+   switch (__op)
+     {
+     case __get_type_info:
+       __dest._M_access<const type_info*>() = &typeid(_Functor);
+       break;
+     case __get_functor_ptr:
+       __dest._M_access<_Functor*>() = _M_get_pointer(__source);
+       break;
+     case __clone_functor:
+       _M_clone(__dest, __source, _Local_storage());
+       break;
+     case __destroy_functor:
+       _M_destroy(__dest, _Local_storage());
+       break;
+     }
+   return false;
+ }
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f)
+ { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
+ template<typename _Signature>
+   static bool
+   _M_not_empty_function(const function<_Signature>& __f)
+   { return static_cast<bool>(__f); }
+ template<typename _Tp>
+   static bool
+   _M_not_empty_function(_Tp* __fp)
+   { return __fp != nullptr; }
+ template<typename _Class, typename _Tp>
+   static bool
+   _M_not_empty_function(_Tp _Class::* __mp)
+   { return __mp != nullptr; }
+ template<typename _Tp>
+   static bool
+   _M_not_empty_function(const _Tp&)
+   { return true; }
+      private:
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
+ { ::new (__functor._M_access()) _Functor(std::move(__f)); }
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
+ { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
+      };
+    _Function_base() : _M_manager(nullptr) { }
+    ~_Function_base()
+    {
+      if (_M_manager)
+ _M_manager(_M_functor, _M_functor, __destroy_functor);
+    }
+    bool _M_empty() const { return !_M_manager; }
+    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
+      _Manager_operation);
+    _Any_data _M_functor;
+    _Manager_type _M_manager;
+  };
+  template<typename _Signature, typename _Functor>
+    class _Function_handler;
+  template<typename _Res, typename _Functor, typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), _Functor>
+    : public _Function_base::_Base_manager<_Functor>
+    {
+      typedef _Function_base::_Base_manager<_Functor> _Base;
+    public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+      {
+ return (*_Base::_M_get_pointer(__functor))(
+     std::forward<_ArgTypes>(__args)...);
+      }
+    };
+  template<typename _Functor, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), _Functor>
+    : public _Function_base::_Base_manager<_Functor>
+    {
+      typedef _Function_base::_Base_manager<_Functor> _Base;
+     public:
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+      {
+ (*_Base::_M_get_pointer(__functor))(
+     std::forward<_ArgTypes>(__args)...);
+      }
+    };
+  template<typename _Class, typename _Member, typename _Res,
+    typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
+    : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
+    {
+      typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
+ _Base;
+     public:
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+      {
+ return std::__invoke(_Base::_M_get_pointer(__functor)->__value,
+        std::forward<_ArgTypes>(__args)...);
+      }
+    };
+  template<typename _Class, typename _Member, typename... _ArgTypes>
+    class _Function_handler<void(_ArgTypes...), _Member _Class::*>
+    : public _Function_base::_Base_manager<
+   _Simple_type_wrapper< _Member _Class::* > >
+    {
+      typedef _Member _Class::* _Functor;
+      typedef _Simple_type_wrapper<_Functor> _Wrapper;
+      typedef _Function_base::_Base_manager<_Wrapper> _Base;
+    public:
+      static bool
+      _M_manager(_Any_data& __dest, const _Any_data& __source,
+   _Manager_operation __op)
+      {
+ switch (__op)
+   {
+   case __get_type_info:
+     __dest._M_access<const type_info*>() = &typeid(_Functor);
+     break;
+   case __get_functor_ptr:
+     __dest._M_access<_Functor*>() =
+       &_Base::_M_get_pointer(__source)->__value;
+     break;
+   default:
+     _Base::_M_manager(__dest, __source, __op);
+   }
+ return false;
+      }
+      static void
+      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+      {
+ std::__invoke(_Base::_M_get_pointer(__functor)->__value,
+        std::forward<_ArgTypes>(__args)...);
+      }
+    };
+  template<typename _From, typename _To>
+    using __check_func_return_type
+      = __or_<is_void<_To>, is_same<_From, _To>, is_convertible<_From, _To>>;
+  template<typename _Res, typename... _ArgTypes>
+    class function<_Res(_ArgTypes...)>
+    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
+      private _Function_base
+    {
+      template<typename _Func,
+        typename _Res2 = typename result_of<_Func&(_ArgTypes...)>::type>
+ struct _Callable : __check_func_return_type<_Res2, _Res> { };
+      template<typename _Tp>
+ struct _Callable<function, _Tp> : false_type { };
+      template<typename _Cond, typename _Tp>
+ using _Requires = typename enable_if<_Cond::value, _Tp>::type;
+    public:
+      typedef _Res result_type;
+      function() noexcept
+      : _Function_base() { }
+      function(nullptr_t) noexcept
+      : _Function_base() { }
+      function(const function& __x);
+      function(function&& __x) noexcept : _Function_base()
+      {
+ __x.swap(*this);
+      }
+      template<typename _Functor,
+        typename = _Requires<__not_<is_same<_Functor, function>>, void>,
+        typename = _Requires<_Callable<_Functor>, void>>
+ function(_Functor);
+      function&
+      operator=(const function& __x)
+      {
+ function(__x).swap(*this);
+ return *this;
+      }
+      function&
+      operator=(function&& __x) noexcept
+      {
+ function(std::move(__x)).swap(*this);
+ return *this;
+      }
+      function&
+      operator=(nullptr_t) noexcept
+      {
+ if (_M_manager)
+   {
+     _M_manager(_M_functor, _M_functor, __destroy_functor);
+     _M_manager = nullptr;
+     _M_invoker = nullptr;
+   }
+ return *this;
+      }
+      template<typename _Functor>
+ _Requires<_Callable<typename decay<_Functor>::type>, function&>
+ operator=(_Functor&& __f)
+ {
+   function(std::forward<_Functor>(__f)).swap(*this);
+   return *this;
+ }
+      template<typename _Functor>
+ function&
+ operator=(reference_wrapper<_Functor> __f) noexcept
+ {
+   function(__f).swap(*this);
+   return *this;
+ }
+      void swap(function& __x) noexcept
+      {
+ std::swap(_M_functor, __x._M_functor);
+ std::swap(_M_manager, __x._M_manager);
+ std::swap(_M_invoker, __x._M_invoker);
+      }
+      explicit operator bool() const noexcept
+      { return !_M_empty(); }
+      _Res operator()(_ArgTypes... __args) const;
+      const type_info& target_type() const noexcept;
+      template<typename _Functor> _Functor* target() noexcept;
+      template<typename _Functor> const _Functor* target() const noexcept;
+    private:
+      using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
+      _Invoker_type _M_invoker;
+  };
+  template<typename>
+    struct __function_guide_helper
+    { };
+  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
+    struct __function_guide_helper<
+      _Res (_Tp::*) (_Args...) noexcept(_Nx)
+    >
+    { using type = _Res(_Args...); };
+  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
+    struct __function_guide_helper<
+      _Res (_Tp::*) (_Args...) & noexcept(_Nx)
+    >
+    { using type = _Res(_Args...); };
+  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
+    struct __function_guide_helper<
+      _Res (_Tp::*) (_Args...) const noexcept(_Nx)
+    >
+    { using type = _Res(_Args...); };
+  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
+    struct __function_guide_helper<
+      _Res (_Tp::*) (_Args...) const & noexcept(_Nx)
+    >
+    { using type = _Res(_Args...); };
+  template<typename _Res, typename... _ArgTypes>
+    function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>;
+  template<typename _Functor, typename _Signature = typename
+    __function_guide_helper<decltype(&_Functor::operator())>::type>
+    function(_Functor) -> function<_Signature>;
+  template<typename _Res, typename... _ArgTypes>
+    function<_Res(_ArgTypes...)>::
+    function(const function& __x)
+    : _Function_base()
+    {
+      if (static_cast<bool>(__x))
+ {
+   __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
+   _M_invoker = __x._M_invoker;
+   _M_manager = __x._M_manager;
+ }
+    }
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor, typename, typename>
+      function<_Res(_ArgTypes...)>::
+      function(_Functor __f)
+      : _Function_base()
+      {
+ typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler;
+ if (_My_handler::_M_not_empty_function(__f))
+   {
+     _My_handler::_M_init_functor(_M_functor, std::move(__f));
+     _M_invoker = &_My_handler::_M_invoke;
+     _M_manager = &_My_handler::_M_manager;
+   }
+      }
+  template<typename _Res, typename... _ArgTypes>
+    _Res
+    function<_Res(_ArgTypes...)>::
+    operator()(_ArgTypes... __args) const
+    {
+      if (_M_empty())
+ __throw_bad_function_call();
+      return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
+    }
+  template<typename _Res, typename... _ArgTypes>
+    const type_info&
+    function<_Res(_ArgTypes...)>::
+    target_type() const noexcept
+    {
+      if (_M_manager)
+ {
+   _Any_data __typeinfo_result;
+   _M_manager(__typeinfo_result, _M_functor, __get_type_info);
+   return *__typeinfo_result._M_access<const type_info*>();
+ }
+      else
+ return typeid(void);
+    }
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      _Functor*
+      function<_Res(_ArgTypes...)>::
+      target() noexcept
+      {
+ const function* __const_this = this;
+ const _Functor* __func = __const_this->template target<_Functor>();
+ return const_cast<_Functor*>(__func);
+      }
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      const _Functor*
+      function<_Res(_ArgTypes...)>::
+      target() const noexcept
+      {
+ if (typeid(_Functor) == target_type() && _M_manager)
+   {
+     _Any_data __ptr;
+     _M_manager(__ptr, _M_functor, __get_functor_ptr);
+     return __ptr._M_access<const _Functor*>();
+   }
+ else
+   return nullptr;
+      }
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
+    { return !static_cast<bool>(__f); }
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
+    { return !static_cast<bool>(__f); }
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
+    { return static_cast<bool>(__f); }
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
+    { return static_cast<bool>(__f); }
+  template<typename _Res, typename... _Args>
+    inline void
+    swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept
+    { __x.swap(__y); }
+
+}
+       
+       
+namespace __gnu_cxx
+{
+  template<typename _Tp>
+    struct __aligned_membuf
+    {
+      struct _Tp2 { _Tp _M_t; };
+      alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)];
+      __aligned_membuf() = default;
+      __aligned_membuf(std::nullptr_t) { }
+      void*
+      _M_addr() noexcept
+      { return static_cast<void*>(&_M_storage); }
+      const void*
+      _M_addr() const noexcept
+      { return static_cast<const void*>(&_M_storage); }
+      _Tp*
+      _M_ptr() noexcept
+      { return static_cast<_Tp*>(_M_addr()); }
+      const _Tp*
+      _M_ptr() const noexcept
+      { return static_cast<const _Tp*>(_M_addr()); }
+    };
+  template<typename _Tp>
+    struct __aligned_buffer
+    : std::aligned_storage<sizeof(_Tp), __alignof__(_Tp)>
+    {
+      typename
+ std::aligned_storage<sizeof(_Tp), __alignof__(_Tp)>::type _M_storage;
+      __aligned_buffer() = default;
+      __aligned_buffer(std::nullptr_t) { }
+      void*
+      _M_addr() noexcept
+      {
+        return static_cast<void*>(&_M_storage);
+      }
+      const void*
+      _M_addr() const noexcept
+      {
+        return static_cast<const void*>(&_M_storage);
+      }
+      _Tp*
+      _M_ptr() noexcept
+      { return static_cast<_Tp*>(_M_addr()); }
+      const _Tp*
+      _M_ptr() const noexcept
+      { return static_cast<const _Tp*>(_M_addr()); }
+    };
+}
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    class _Hashtable;
+namespace __detail
+{
+  template<typename _Key, typename _Value,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _Traits>
+    struct _Hashtable_base;
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last,
+    std::input_iterator_tag)
+    { return __first != __last ? 1 : 0; }
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last,
+    std::forward_iterator_tag)
+    { return std::distance(__first, __last); }
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last)
+    { return __distance_fw(__first, __last,
+      std::__iterator_category(__first)); }
+  struct _Identity
+  {
+    template<typename _Tp>
+      _Tp&&
+      operator()(_Tp&& __x) const
+      { return std::forward<_Tp>(__x); }
+  };
+  struct _Select1st
+  {
+    template<typename _Tp>
+      auto
+      operator()(_Tp&& __x) const
+      -> decltype(std::get<0>(std::forward<_Tp>(__x)))
+      { return std::get<0>(std::forward<_Tp>(__x)); }
+  };
+  template<typename _NodeAlloc>
+    struct _Hashtable_alloc;
+  template<typename _NodeAlloc>
+    struct _ReuseOrAllocNode
+    {
+    private:
+      using __node_alloc_type = _NodeAlloc;
+      using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>;
+      using __node_alloc_traits =
+ typename __hashtable_alloc::__node_alloc_traits;
+      using __node_type = typename __hashtable_alloc::__node_type;
+    public:
+      _ReuseOrAllocNode(__node_type* __nodes, __hashtable_alloc& __h)
+ : _M_nodes(__nodes), _M_h(__h) { }
+      _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete;
+      ~_ReuseOrAllocNode()
+      { _M_h._M_deallocate_nodes(_M_nodes); }
+      template<typename _Arg>
+ __node_type*
+ operator()(_Arg&& __arg) const
+ {
+   if (_M_nodes)
+     {
+       __node_type* __node = _M_nodes;
+       _M_nodes = _M_nodes->_M_next();
+       __node->_M_nxt = nullptr;
+       auto& __a = _M_h._M_node_allocator();
+       __node_alloc_traits::destroy(__a, __node->_M_valptr());
+       try
+  {
+    __node_alloc_traits::construct(__a, __node->_M_valptr(),
+       std::forward<_Arg>(__arg));
+  }
+       catch(...)
+  {
+    __node->~__node_type();
+    __node_alloc_traits::deallocate(__a, __node, 1);
+    throw;
+  }
+       return __node;
+     }
+   return _M_h._M_allocate_node(std::forward<_Arg>(__arg));
+ }
+    private:
+      mutable __node_type* _M_nodes;
+      __hashtable_alloc& _M_h;
+    };
+  template<typename _NodeAlloc>
+    struct _AllocNode
+    {
+    private:
+      using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>;
+      using __node_type = typename __hashtable_alloc::__node_type;
+    public:
+      _AllocNode(__hashtable_alloc& __h)
+ : _M_h(__h) { }
+      template<typename _Arg>
+ __node_type*
+ operator()(_Arg&& __arg) const
+ { return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); }
+    private:
+      __hashtable_alloc& _M_h;
+    };
+  template<bool _Cache_hash_code, bool _Constant_iterators, bool _Unique_keys>
+    struct _Hashtable_traits
+    {
+      using __hash_cached = __bool_constant<_Cache_hash_code>;
+      using __constant_iterators = __bool_constant<_Constant_iterators>;
+      using __unique_keys = __bool_constant<_Unique_keys>;
+    };
+  struct _Hash_node_base
+  {
+    _Hash_node_base* _M_nxt;
+    _Hash_node_base() noexcept : _M_nxt() { }
+    _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { }
+  };
+  template<typename _Value>
+    struct _Hash_node_value_base : _Hash_node_base
+    {
+      typedef _Value value_type;
+      __gnu_cxx::__aligned_buffer<_Value> _M_storage;
+      _Value*
+      _M_valptr() noexcept
+      { return _M_storage._M_ptr(); }
+      const _Value*
+      _M_valptr() const noexcept
+      { return _M_storage._M_ptr(); }
+      _Value&
+      _M_v() noexcept
+      { return *_M_valptr(); }
+      const _Value&
+      _M_v() const noexcept
+      { return *_M_valptr(); }
+    };
+  template<typename _Value, bool _Cache_hash_code>
+    struct _Hash_node;
+  template<typename _Value>
+    struct _Hash_node<_Value, true> : _Hash_node_value_base<_Value>
+    {
+      std::size_t _M_hash_code;
+      _Hash_node*
+      _M_next() const noexcept
+      { return static_cast<_Hash_node*>(this->_M_nxt); }
+    };
+  template<typename _Value>
+    struct _Hash_node<_Value, false> : _Hash_node_value_base<_Value>
+    {
+      _Hash_node*
+      _M_next() const noexcept
+      { return static_cast<_Hash_node*>(this->_M_nxt); }
+    };
+  template<typename _Value, bool _Cache_hash_code>
+    struct _Node_iterator_base
+    {
+      using __node_type = _Hash_node<_Value, _Cache_hash_code>;
+      __node_type* _M_cur;
+      _Node_iterator_base(__node_type* __p) noexcept
+      : _M_cur(__p) { }
+      void
+      _M_incr() noexcept
+      { _M_cur = _M_cur->_M_next(); }
+    };
+  template<typename _Value, bool _Cache_hash_code>
+    inline bool
+    operator==(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
+        const _Node_iterator_base<_Value, _Cache_hash_code >& __y)
+    noexcept
+    { return __x._M_cur == __y._M_cur; }
+  template<typename _Value, bool _Cache_hash_code>
+    inline bool
+    operator!=(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
+        const _Node_iterator_base<_Value, _Cache_hash_code>& __y)
+    noexcept
+    { return __x._M_cur != __y._M_cur; }
+  template<typename _Value, bool __constant_iterators, bool __cache>
+    struct _Node_iterator
+    : public _Node_iterator_base<_Value, __cache>
+    {
+    private:
+      using __base_type = _Node_iterator_base<_Value, __cache>;
+      using __node_type = typename __base_type::__node_type;
+    public:
+      typedef _Value value_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+      using pointer = typename std::conditional<__constant_iterators,
+      const _Value*, _Value*>::type;
+      using reference = typename std::conditional<__constant_iterators,
+        const _Value&, _Value&>::type;
+      _Node_iterator() noexcept
+      : __base_type(0) { }
+      explicit
+      _Node_iterator(__node_type* __p) noexcept
+      : __base_type(__p) { }
+      reference
+      operator*() const noexcept
+      { return this->_M_cur->_M_v(); }
+      pointer
+      operator->() const noexcept
+      { return this->_M_cur->_M_valptr(); }
+      _Node_iterator&
+      operator++() noexcept
+      {
+ this->_M_incr();
+ return *this;
+      }
+      _Node_iterator
+      operator++(int) noexcept
+      {
+ _Node_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+      }
+    };
+  template<typename _Value, bool __constant_iterators, bool __cache>
+    struct _Node_const_iterator
+    : public _Node_iterator_base<_Value, __cache>
+    {
+    private:
+      using __base_type = _Node_iterator_base<_Value, __cache>;
+      using __node_type = typename __base_type::__node_type;
+    public:
+      typedef _Value value_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+      typedef const _Value* pointer;
+      typedef const _Value& reference;
+      _Node_const_iterator() noexcept
+      : __base_type(0) { }
+      explicit
+      _Node_const_iterator(__node_type* __p) noexcept
+      : __base_type(__p) { }
+      _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators,
+      __cache>& __x) noexcept
+      : __base_type(__x._M_cur) { }
+      reference
+      operator*() const noexcept
+      { return this->_M_cur->_M_v(); }
+      pointer
+      operator->() const noexcept
+      { return this->_M_cur->_M_valptr(); }
+      _Node_const_iterator&
+      operator++() noexcept
+      {
+ this->_M_incr();
+ return *this;
+      }
+      _Node_const_iterator
+      operator++(int) noexcept
+      {
+ _Node_const_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+      }
+    };
+  struct _Mod_range_hashing
+  {
+    typedef std::size_t first_argument_type;
+    typedef std::size_t second_argument_type;
+    typedef std::size_t result_type;
+    result_type
+    operator()(first_argument_type __num,
+        second_argument_type __den) const noexcept
+    { return __num % __den; }
+  };
+  struct _Default_ranged_hash { };
+  struct _Prime_rehash_policy
+  {
+    using __has_load_factor = std::true_type;
+    _Prime_rehash_policy(float __z = 1.0) noexcept
+    : _M_max_load_factor(__z), _M_next_resize(0) { }
+    float
+    max_load_factor() const noexcept
+    { return _M_max_load_factor; }
+    std::size_t
+    _M_next_bkt(std::size_t __n) const;
+    std::size_t
+    _M_bkt_for_elements(std::size_t __n) const
+    { return __builtin_ceil(__n / (long double)_M_max_load_factor); }
+    std::pair<bool, std::size_t>
+    _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
+     std::size_t __n_ins) const;
+    typedef std::size_t _State;
+    _State
+    _M_state() const
+    { return _M_next_resize; }
+    void
+    _M_reset() noexcept
+    { _M_next_resize = 0; }
+    void
+    _M_reset(_State __state)
+    { _M_next_resize = __state; }
+    static const std::size_t _S_growth_factor = 2;
+    float _M_max_load_factor;
+    mutable std::size_t _M_next_resize;
+  };
+  struct _Mask_range_hashing
+  {
+    typedef std::size_t first_argument_type;
+    typedef std::size_t second_argument_type;
+    typedef std::size_t result_type;
+    result_type
+    operator()(first_argument_type __num,
+        second_argument_type __den) const noexcept
+    { return __num & (__den - 1); }
+  };
+  constexpr
+  inline std::size_t
+  __clp2(std::size_t __n) noexcept
+  {
+    std::uint_fast64_t __x = __n;
+    __x = __x - 1;
+    __x = __x | (__x >> 1);
+    __x = __x | (__x >> 2);
+    __x = __x | (__x >> 4);
+    __x = __x | (__x >> 8);
+    __x = __x | (__x >>16);
+    __x = __x | (__x >>32);
+    return __x + 1;
+  }
+  struct _Power2_rehash_policy
+  {
+    using __has_load_factor = std::true_type;
+    _Power2_rehash_policy(float __z = 1.0) noexcept
+    : _M_max_load_factor(__z), _M_next_resize(0) { }
+    float
+    max_load_factor() const noexcept
+    { return _M_max_load_factor; }
+    std::size_t
+    _M_next_bkt(std::size_t __n) noexcept
+    {
+      const auto __max_width = std::min<size_t>(sizeof(size_t), 8);
+      const auto __max_bkt = size_t(1) << (__max_width * 8 - 1);
+      std::size_t __res = __clp2(__n);
+      if (__res == __n)
+ __res <<= 1;
+      if (__res == 0)
+ __res = __max_bkt;
+      if (__res == __max_bkt)
+ _M_next_resize = std::size_t(-1);
+      else
+ _M_next_resize
+   = __builtin_ceil(__res * (long double)_M_max_load_factor);
+      return __res;
+    }
+    std::size_t
+    _M_bkt_for_elements(std::size_t __n) const noexcept
+    { return __builtin_ceil(__n / (long double)_M_max_load_factor); }
+    std::pair<bool, std::size_t>
+    _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
+     std::size_t __n_ins) noexcept
+    {
+      if (__n_elt + __n_ins >= _M_next_resize)
+ {
+   long double __min_bkts = (__n_elt + __n_ins)
+     / (long double)_M_max_load_factor;
+   if (__min_bkts >= __n_bkt)
+     return std::make_pair(true,
+       _M_next_bkt(std::max<std::size_t>(__builtin_floor(__min_bkts) + 1,
+      __n_bkt * _S_growth_factor)));
+   _M_next_resize
+     = __builtin_floor(__n_bkt * (long double)_M_max_load_factor);
+   return std::make_pair(false, 0);
+ }
+      else
+ return std::make_pair(false, 0);
+    }
+    typedef std::size_t _State;
+    _State
+    _M_state() const noexcept
+    { return _M_next_resize; }
+    void
+    _M_reset() noexcept
+    { _M_next_resize = 0; }
+    void
+    _M_reset(_State __state) noexcept
+    { _M_next_resize = __state; }
+    static const std::size_t _S_growth_factor = 2;
+    float _M_max_load_factor;
+    std::size_t _M_next_resize;
+  };
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits,
+    bool _Unique_keys = _Traits::__unique_keys::value>
+    struct _Map_base { };
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, false>
+    {
+      using mapped_type = typename std::tuple_element<1, _Pair>::type;
+    };
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
+    {
+    private:
+      using __hashtable_base = __detail::_Hashtable_base<_Key, _Pair,
+        _Select1st,
+       _Equal, _H1, _H2, _Hash,
+         _Traits>;
+      using __hashtable = _Hashtable<_Key, _Pair, _Alloc,
+         _Select1st, _Equal,
+         _H1, _H2, _Hash, _RehashPolicy, _Traits>;
+      using __hash_code = typename __hashtable_base::__hash_code;
+      using __node_type = typename __hashtable_base::__node_type;
+    public:
+      using key_type = typename __hashtable_base::key_type;
+      using iterator = typename __hashtable_base::iterator;
+      using mapped_type = typename std::tuple_element<1, _Pair>::type;
+      mapped_type&
+      operator[](const key_type& __k);
+      mapped_type&
+      operator[](key_type&& __k);
+      mapped_type&
+      at(const key_type& __k);
+      const mapped_type&
+      at(const key_type& __k) const;
+    };
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    auto
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    operator[](const key_type& __k)
+    -> mapped_type&
+    {
+      __hashtable* __h = static_cast<__hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __n = __h->_M_bucket_index(__k, __code);
+      __node_type* __p = __h->_M_find_node(__n, __k, __code);
+      if (!__p)
+ {
+   __p = __h->_M_allocate_node(std::piecewise_construct,
+          std::tuple<const key_type&>(__k),
+          std::tuple<>());
+   return __h->_M_insert_unique_node(__n, __code, __p)->second;
+ }
+      return __p->_M_v().second;
+    }
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    auto
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    operator[](key_type&& __k)
+    -> mapped_type&
+    {
+      __hashtable* __h = static_cast<__hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __n = __h->_M_bucket_index(__k, __code);
+      __node_type* __p = __h->_M_find_node(__n, __k, __code);
+      if (!__p)
+ {
+   __p = __h->_M_allocate_node(std::piecewise_construct,
+          std::forward_as_tuple(std::move(__k)),
+          std::tuple<>());
+   return __h->_M_insert_unique_node(__n, __code, __p)->second;
+ }
+      return __p->_M_v().second;
+    }
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    auto
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    at(const key_type& __k)
+    -> mapped_type&
+    {
+      __hashtable* __h = static_cast<__hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __n = __h->_M_bucket_index(__k, __code);
+      __node_type* __p = __h->_M_find_node(__n, __k, __code);
+      if (!__p)
+ __throw_out_of_range(("_Map_base::at"));
+      return __p->_M_v().second;
+    }
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    auto
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    at(const key_type& __k) const
+    -> const mapped_type&
+    {
+      const __hashtable* __h = static_cast<const __hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __n = __h->_M_bucket_index(__k, __code);
+      __node_type* __p = __h->_M_find_node(__n, __k, __code);
+      if (!__p)
+ __throw_out_of_range(("_Map_base::at"));
+      return __p->_M_v().second;
+    }
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Insert_base
+    {
+    protected:
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
+         _Equal, _H1, _H2, _Hash,
+         _RehashPolicy, _Traits>;
+      using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey,
+            _Equal, _H1, _H2, _Hash,
+            _Traits>;
+      using value_type = typename __hashtable_base::value_type;
+      using iterator = typename __hashtable_base::iterator;
+      using const_iterator = typename __hashtable_base::const_iterator;
+      using size_type = typename __hashtable_base::size_type;
+      using __unique_keys = typename __hashtable_base::__unique_keys;
+      using __ireturn_type = typename __hashtable_base::__ireturn_type;
+      using __node_type = _Hash_node<_Value, _Traits::__hash_cached::value>;
+      using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>;
+      using __node_gen_type = _AllocNode<__node_alloc_type>;
+      __hashtable&
+      _M_conjure_hashtable()
+      { return *(static_cast<__hashtable*>(this)); }
+      template<typename _InputIterator, typename _NodeGetter>
+ void
+ _M_insert_range(_InputIterator __first, _InputIterator __last,
+   const _NodeGetter&, true_type);
+      template<typename _InputIterator, typename _NodeGetter>
+ void
+ _M_insert_range(_InputIterator __first, _InputIterator __last,
+   const _NodeGetter&, false_type);
+    public:
+      __ireturn_type
+      insert(const value_type& __v)
+      {
+ __hashtable& __h = _M_conjure_hashtable();
+ __node_gen_type __node_gen(__h);
+ return __h._M_insert(__v, __node_gen, __unique_keys());
+      }
+      iterator
+      insert(const_iterator __hint, const value_type& __v)
+      {
+ __hashtable& __h = _M_conjure_hashtable();
+ __node_gen_type __node_gen(__h);
+ return __h._M_insert(__hint, __v, __node_gen, __unique_keys());
+      }
+      void
+      insert(initializer_list<value_type> __l)
+      { this->insert(__l.begin(), __l.end()); }
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ {
+   __hashtable& __h = _M_conjure_hashtable();
+   __node_gen_type __node_gen(__h);
+   return _M_insert_range(__first, __last, __node_gen, __unique_keys());
+ }
+    };
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    template<typename _InputIterator, typename _NodeGetter>
+      void
+      _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+      _RehashPolicy, _Traits>::
+      _M_insert_range(_InputIterator __first, _InputIterator __last,
+        const _NodeGetter& __node_gen, true_type)
+      {
+ size_type __n_elt = __detail::__distance_fw(__first, __last);
+ if (__n_elt == 0)
+   return;
+ __hashtable& __h = _M_conjure_hashtable();
+ for (; __first != __last; ++__first)
+   {
+     if (__h._M_insert(*__first, __node_gen, __unique_keys(),
+         __n_elt).second)
+       __n_elt = 1;
+     else if (__n_elt != 1)
+       --__n_elt;
+   }
+      }
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    template<typename _InputIterator, typename _NodeGetter>
+      void
+      _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+      _RehashPolicy, _Traits>::
+      _M_insert_range(_InputIterator __first, _InputIterator __last,
+        const _NodeGetter& __node_gen, false_type)
+      {
+ using __rehash_type = typename __hashtable::__rehash_type;
+ using __rehash_state = typename __hashtable::__rehash_state;
+ using pair_type = std::pair<bool, std::size_t>;
+ size_type __n_elt = __detail::__distance_fw(__first, __last);
+ if (__n_elt == 0)
+   return;
+ __hashtable& __h = _M_conjure_hashtable();
+ __rehash_type& __rehash = __h._M_rehash_policy;
+ const __rehash_state& __saved_state = __rehash._M_state();
+ pair_type __do_rehash = __rehash._M_need_rehash(__h._M_bucket_count,
+       __h._M_element_count,
+       __n_elt);
+ if (__do_rehash.first)
+   __h._M_rehash(__do_rehash.second, __saved_state);
+ for (; __first != __last; ++__first)
+   __h._M_insert(*__first, __node_gen, __unique_keys());
+      }
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits,
+    bool _Constant_iterators = _Traits::__constant_iterators::value>
+    struct _Insert;
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+     _RehashPolicy, _Traits, true>
+    : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+      _H1, _H2, _Hash, _RehashPolicy, _Traits>
+    {
+      using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
+     _Equal, _H1, _H2, _Hash,
+     _RehashPolicy, _Traits>;
+      using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey,
+            _Equal, _H1, _H2, _Hash,
+            _Traits>;
+      using value_type = typename __base_type::value_type;
+      using iterator = typename __base_type::iterator;
+      using const_iterator = typename __base_type::const_iterator;
+      using __unique_keys = typename __base_type::__unique_keys;
+      using __ireturn_type = typename __hashtable_base::__ireturn_type;
+      using __hashtable = typename __base_type::__hashtable;
+      using __node_gen_type = typename __base_type::__node_gen_type;
+      using __base_type::insert;
+      __ireturn_type
+      insert(value_type&& __v)
+      {
+ __hashtable& __h = this->_M_conjure_hashtable();
+ __node_gen_type __node_gen(__h);
+ return __h._M_insert(std::move(__v), __node_gen, __unique_keys());
+      }
+      iterator
+      insert(const_iterator __hint, value_type&& __v)
+      {
+ __hashtable& __h = this->_M_conjure_hashtable();
+ __node_gen_type __node_gen(__h);
+ return __h._M_insert(__hint, std::move(__v), __node_gen,
+        __unique_keys());
+      }
+    };
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+     _RehashPolicy, _Traits, false>
+    : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+      _H1, _H2, _Hash, _RehashPolicy, _Traits>
+    {
+      using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
+           _Equal, _H1, _H2, _Hash,
+           _RehashPolicy, _Traits>;
+      using value_type = typename __base_type::value_type;
+      using iterator = typename __base_type::iterator;
+      using const_iterator = typename __base_type::const_iterator;
+      using __unique_keys = typename __base_type::__unique_keys;
+      using __hashtable = typename __base_type::__hashtable;
+      using __ireturn_type = typename __base_type::__ireturn_type;
+      using __base_type::insert;
+      template<typename _Pair>
+ using __is_cons = std::is_constructible<value_type, _Pair&&>;
+      template<typename _Pair>
+ using _IFcons = std::enable_if<__is_cons<_Pair>::value>;
+      template<typename _Pair>
+ using _IFconsp = typename _IFcons<_Pair>::type;
+      template<typename _Pair, typename = _IFconsp<_Pair>>
+ __ireturn_type
+ insert(_Pair&& __v)
+ {
+   __hashtable& __h = this->_M_conjure_hashtable();
+   return __h._M_emplace(__unique_keys(), std::forward<_Pair>(__v));
+ }
+      template<typename _Pair, typename = _IFconsp<_Pair>>
+ iterator
+ insert(const_iterator __hint, _Pair&& __v)
+ {
+   __hashtable& __h = this->_M_conjure_hashtable();
+   return __h._M_emplace(__hint, __unique_keys(),
+    std::forward<_Pair>(__v));
+ }
+   };
+  template<typename _Policy>
+    using __has_load_factor = typename _Policy::__has_load_factor;
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits,
+    typename =
+      __detected_or_t<std::false_type, __has_load_factor, _RehashPolicy>>
+    struct _Rehash_base;
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits,
+        std::false_type>
+    {
+    };
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits,
+   std::true_type>
+    {
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
+         _Equal, _H1, _H2, _Hash,
+         _RehashPolicy, _Traits>;
+      float
+      max_load_factor() const noexcept
+      {
+ const __hashtable* __this = static_cast<const __hashtable*>(this);
+ return __this->__rehash_policy().max_load_factor();
+      }
+      void
+      max_load_factor(float __z)
+      {
+ __hashtable* __this = static_cast<__hashtable*>(this);
+ __this->__rehash_policy(_RehashPolicy(__z));
+      }
+      void
+      reserve(std::size_t __n)
+      {
+ __hashtable* __this = static_cast<__hashtable*>(this);
+ __this->rehash(__builtin_ceil(__n / max_load_factor()));
+      }
+    };
+  template<int _Nm, typename _Tp,
+    bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
+    struct _Hashtable_ebo_helper;
+  template<int _Nm, typename _Tp>
+    struct _Hashtable_ebo_helper<_Nm, _Tp, true>
+    : private _Tp
+    {
+      _Hashtable_ebo_helper() = default;
+      template<typename _OtherTp>
+ _Hashtable_ebo_helper(_OtherTp&& __tp)
+   : _Tp(std::forward<_OtherTp>(__tp))
+ { }
+      static const _Tp&
+      _S_cget(const _Hashtable_ebo_helper& __eboh)
+      { return static_cast<const _Tp&>(__eboh); }
+      static _Tp&
+      _S_get(_Hashtable_ebo_helper& __eboh)
+      { return static_cast<_Tp&>(__eboh); }
+    };
+  template<int _Nm, typename _Tp>
+    struct _Hashtable_ebo_helper<_Nm, _Tp, false>
+    {
+      _Hashtable_ebo_helper() = default;
+      template<typename _OtherTp>
+ _Hashtable_ebo_helper(_OtherTp&& __tp)
+   : _M_tp(std::forward<_OtherTp>(__tp))
+ { }
+      static const _Tp&
+      _S_cget(const _Hashtable_ebo_helper& __eboh)
+      { return __eboh._M_tp; }
+      static _Tp&
+      _S_get(_Hashtable_ebo_helper& __eboh)
+      { return __eboh._M_tp; }
+    private:
+      _Tp _M_tp;
+    };
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash,
+    bool __cache_hash_code>
+    struct _Local_iterator_base;
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash,
+    bool __cache_hash_code>
+    struct _Hash_code_base;
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, false>
+    : private _Hashtable_ebo_helper<0, _ExtractKey>,
+      private _Hashtable_ebo_helper<1, _Hash>
+    {
+    private:
+      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
+      using __ebo_hash = _Hashtable_ebo_helper<1, _Hash>;
+    protected:
+      typedef void* __hash_code;
+      typedef _Hash_node<_Value, false> __node_type;
+      _Hash_code_base() = default;
+      _Hash_code_base(const _ExtractKey& __ex, const _H1&, const _H2&,
+        const _Hash& __h)
+      : __ebo_extract_key(__ex), __ebo_hash(__h) { }
+      __hash_code
+      _M_hash_code(const _Key& __key) const
+      { return 0; }
+      std::size_t
+      _M_bucket_index(const _Key& __k, __hash_code, std::size_t __n) const
+      { return _M_ranged_hash()(__k, __n); }
+      std::size_t
+      _M_bucket_index(const __node_type* __p, std::size_t __n) const
+ noexcept( noexcept(declval<const _Hash&>()(declval<const _Key&>(),
+         (std::size_t)0)) )
+      { return _M_ranged_hash()(_M_extract()(__p->_M_v()), __n); }
+      void
+      _M_store_code(__node_type*, __hash_code) const
+      { }
+      void
+      _M_copy_code(__node_type*, const __node_type*) const
+      { }
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+ std::swap(_M_extract(), __x._M_extract());
+ std::swap(_M_ranged_hash(), __x._M_ranged_hash());
+      }
+      const _ExtractKey&
+      _M_extract() const { return __ebo_extract_key::_S_cget(*this); }
+      _ExtractKey&
+      _M_extract() { return __ebo_extract_key::_S_get(*this); }
+      const _Hash&
+      _M_ranged_hash() const { return __ebo_hash::_S_cget(*this); }
+      _Hash&
+      _M_ranged_hash() { return __ebo_hash::_S_get(*this); }
+    };
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, true>;
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
+      _Default_ranged_hash, false>
+    : private _Hashtable_ebo_helper<0, _ExtractKey>,
+      private _Hashtable_ebo_helper<1, _H1>,
+      private _Hashtable_ebo_helper<2, _H2>
+    {
+    private:
+      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
+      using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>;
+      using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>;
+      friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2,
+      _Default_ranged_hash, false>;
+    public:
+      typedef _H1 hasher;
+      hasher
+      hash_function() const
+      { return _M_h1(); }
+    protected:
+      typedef std::size_t __hash_code;
+      typedef _Hash_node<_Value, false> __node_type;
+      _Hash_code_base() = default;
+      _Hash_code_base(const _ExtractKey& __ex,
+        const _H1& __h1, const _H2& __h2,
+        const _Default_ranged_hash&)
+      : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { }
+      __hash_code
+      _M_hash_code(const _Key& __k) const
+      {
+ static_assert(__is_invocable<const _H1&, const _Key&>{},
+     "hash function must be invocable with an argument of key type");
+ return _M_h1()(__k);
+      }
+      std::size_t
+      _M_bucket_index(const _Key&, __hash_code __c, std::size_t __n) const
+      { return _M_h2()(__c, __n); }
+      std::size_t
+      _M_bucket_index(const __node_type* __p, std::size_t __n) const
+ noexcept( noexcept(declval<const _H1&>()(declval<const _Key&>()))
+    && noexcept(declval<const _H2&>()((__hash_code)0,
+          (std::size_t)0)) )
+      { return _M_h2()(_M_h1()(_M_extract()(__p->_M_v())), __n); }
+      void
+      _M_store_code(__node_type*, __hash_code) const
+      { }
+      void
+      _M_copy_code(__node_type*, const __node_type*) const
+      { }
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+ std::swap(_M_extract(), __x._M_extract());
+ std::swap(_M_h1(), __x._M_h1());
+ std::swap(_M_h2(), __x._M_h2());
+      }
+      const _ExtractKey&
+      _M_extract() const { return __ebo_extract_key::_S_cget(*this); }
+      _ExtractKey&
+      _M_extract() { return __ebo_extract_key::_S_get(*this); }
+      const _H1&
+      _M_h1() const { return __ebo_h1::_S_cget(*this); }
+      _H1&
+      _M_h1() { return __ebo_h1::_S_get(*this); }
+      const _H2&
+      _M_h2() const { return __ebo_h2::_S_cget(*this); }
+      _H2&
+      _M_h2() { return __ebo_h2::_S_get(*this); }
+    };
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
+      _Default_ranged_hash, true>
+    : private _Hashtable_ebo_helper<0, _ExtractKey>,
+      private _Hashtable_ebo_helper<1, _H1>,
+      private _Hashtable_ebo_helper<2, _H2>
+    {
+    private:
+      friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2,
+      _Default_ranged_hash, true>;
+      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
+      using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>;
+      using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>;
+    public:
+      typedef _H1 hasher;
+      hasher
+      hash_function() const
+      { return _M_h1(); }
+    protected:
+      typedef std::size_t __hash_code;
+      typedef _Hash_node<_Value, true> __node_type;
+      _Hash_code_base() = default;
+      _Hash_code_base(const _ExtractKey& __ex,
+        const _H1& __h1, const _H2& __h2,
+        const _Default_ranged_hash&)
+      : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { }
+      __hash_code
+      _M_hash_code(const _Key& __k) const
+      {
+ static_assert(__is_invocable<const _H1&, const _Key&>{},
+     "hash function must be invocable with an argument of key type");
+ return _M_h1()(__k);
+      }
+      std::size_t
+      _M_bucket_index(const _Key&, __hash_code __c,
+        std::size_t __n) const
+      { return _M_h2()(__c, __n); }
+      std::size_t
+      _M_bucket_index(const __node_type* __p, std::size_t __n) const
+ noexcept( noexcept(declval<const _H2&>()((__hash_code)0,
+       (std::size_t)0)) )
+      { return _M_h2()(__p->_M_hash_code, __n); }
+      void
+      _M_store_code(__node_type* __n, __hash_code __c) const
+      { __n->_M_hash_code = __c; }
+      void
+      _M_copy_code(__node_type* __to, const __node_type* __from) const
+      { __to->_M_hash_code = __from->_M_hash_code; }
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+ std::swap(_M_extract(), __x._M_extract());
+ std::swap(_M_h1(), __x._M_h1());
+ std::swap(_M_h2(), __x._M_h2());
+      }
+      const _ExtractKey&
+      _M_extract() const { return __ebo_extract_key::_S_cget(*this); }
+      _ExtractKey&
+      _M_extract() { return __ebo_extract_key::_S_get(*this); }
+      const _H1&
+      _M_h1() const { return __ebo_h1::_S_cget(*this); }
+      _H1&
+      _M_h1() { return __ebo_h1::_S_get(*this); }
+      const _H2&
+      _M_h2() const { return __ebo_h2::_S_cget(*this); }
+      _H2&
+      _M_h2() { return __ebo_h2::_S_get(*this); }
+    };
+  template <typename _Key, typename _Value, typename _ExtractKey,
+     typename _Equal, typename _HashCodeType,
+     bool __cache_hash_code>
+  struct _Equal_helper;
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _Equal, typename _HashCodeType>
+  struct _Equal_helper<_Key, _Value, _ExtractKey, _Equal, _HashCodeType, true>
+  {
+    static bool
+    _S_equals(const _Equal& __eq, const _ExtractKey& __extract,
+       const _Key& __k, _HashCodeType __c, _Hash_node<_Value, true>* __n)
+    { return __c == __n->_M_hash_code && __eq(__k, __extract(__n->_M_v())); }
+  };
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _Equal, typename _HashCodeType>
+  struct _Equal_helper<_Key, _Value, _ExtractKey, _Equal, _HashCodeType, false>
+  {
+    static bool
+    _S_equals(const _Equal& __eq, const _ExtractKey& __extract,
+       const _Key& __k, _HashCodeType, _Hash_node<_Value, false>* __n)
+    { return __eq(__k, __extract(__n->_M_v())); }
+  };
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
+    _H1, _H2, _Hash, true>
+    : private _Hashtable_ebo_helper<0, _H2>
+    {
+    protected:
+      using __base_type = _Hashtable_ebo_helper<0, _H2>;
+      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
+            _H1, _H2, _Hash, true>;
+      _Local_iterator_base() = default;
+      _Local_iterator_base(const __hash_code_base& __base,
+      _Hash_node<_Value, true>* __p,
+      std::size_t __bkt, std::size_t __bkt_count)
+      : __base_type(__base._M_h2()),
+ _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { }
+      void
+      _M_incr()
+      {
+ _M_cur = _M_cur->_M_next();
+ if (_M_cur)
+   {
+     std::size_t __bkt
+       = __base_type::_S_get(*this)(_M_cur->_M_hash_code,
+        _M_bucket_count);
+     if (__bkt != _M_bucket)
+       _M_cur = nullptr;
+   }
+      }
+      _Hash_node<_Value, true>* _M_cur;
+      std::size_t _M_bucket;
+      std::size_t _M_bucket_count;
+    public:
+      const void*
+      _M_curr() const { return _M_cur; }
+      std::size_t
+      _M_get_bucket() const { return _M_bucket; }
+    };
+  template<typename _Tp, bool _IsEmpty = std::is_empty<_Tp>::value>
+    struct _Hash_code_storage
+    {
+      __gnu_cxx::__aligned_buffer<_Tp> _M_storage;
+      _Tp*
+      _M_h() { return _M_storage._M_ptr(); }
+      const _Tp*
+      _M_h() const { return _M_storage._M_ptr(); }
+    };
+  template<typename _Tp>
+    struct _Hash_code_storage<_Tp, true>
+    {
+      static_assert( std::is_empty<_Tp>::value, "Type must be empty" );
+      _Tp*
+      _M_h() { return reinterpret_cast<_Tp*>(this); }
+      const _Tp*
+      _M_h() const { return reinterpret_cast<const _Tp*>(this); }
+    };
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    using __hash_code_for_local_iter
+      = _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey,
+        _H1, _H2, _Hash, false>>;
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
+    _H1, _H2, _Hash, false>
+    : __hash_code_for_local_iter<_Key, _Value, _ExtractKey, _H1, _H2, _Hash>
+    {
+    protected:
+      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
+            _H1, _H2, _Hash, false>;
+      _Local_iterator_base() : _M_bucket_count(-1) { }
+      _Local_iterator_base(const __hash_code_base& __base,
+      _Hash_node<_Value, false>* __p,
+      std::size_t __bkt, std::size_t __bkt_count)
+      : _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count)
+      { _M_init(__base); }
+      ~_Local_iterator_base()
+      {
+ if (_M_bucket_count != -1)
+   _M_destroy();
+      }
+      _Local_iterator_base(const _Local_iterator_base& __iter)
+      : _M_cur(__iter._M_cur), _M_bucket(__iter._M_bucket),
+        _M_bucket_count(__iter._M_bucket_count)
+      {
+ if (_M_bucket_count != -1)
+   _M_init(*__iter._M_h());
+      }
+      _Local_iterator_base&
+      operator=(const _Local_iterator_base& __iter)
+      {
+ if (_M_bucket_count != -1)
+   _M_destroy();
+ _M_cur = __iter._M_cur;
+ _M_bucket = __iter._M_bucket;
+ _M_bucket_count = __iter._M_bucket_count;
+ if (_M_bucket_count != -1)
+   _M_init(*__iter._M_h());
+ return *this;
+      }
+      void
+      _M_incr()
+      {
+ _M_cur = _M_cur->_M_next();
+ if (_M_cur)
+   {
+     std::size_t __bkt = this->_M_h()->_M_bucket_index(_M_cur,
+             _M_bucket_count);
+     if (__bkt != _M_bucket)
+       _M_cur = nullptr;
+   }
+      }
+      _Hash_node<_Value, false>* _M_cur;
+      std::size_t _M_bucket;
+      std::size_t _M_bucket_count;
+      void
+      _M_init(const __hash_code_base& __base)
+      { ::new(this->_M_h()) __hash_code_base(__base); }
+      void
+      _M_destroy() { this->_M_h()->~__hash_code_base(); }
+    public:
+      const void*
+      _M_curr() const { return _M_cur; }
+      std::size_t
+      _M_get_bucket() const { return _M_bucket; }
+    };
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash, bool __cache>
+    inline bool
+    operator==(const _Local_iterator_base<_Key, _Value, _ExtractKey,
+       _H1, _H2, _Hash, __cache>& __x,
+        const _Local_iterator_base<_Key, _Value, _ExtractKey,
+       _H1, _H2, _Hash, __cache>& __y)
+    { return __x._M_curr() == __y._M_curr(); }
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash, bool __cache>
+    inline bool
+    operator!=(const _Local_iterator_base<_Key, _Value, _ExtractKey,
+       _H1, _H2, _Hash, __cache>& __x,
+        const _Local_iterator_base<_Key, _Value, _ExtractKey,
+       _H1, _H2, _Hash, __cache>& __y)
+    { return __x._M_curr() != __y._M_curr(); }
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash,
+    bool __constant_iterators, bool __cache>
+    struct _Local_iterator
+    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
+      _H1, _H2, _Hash, __cache>
+    {
+    private:
+      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
+            _H1, _H2, _Hash, __cache>;
+      using __hash_code_base = typename __base_type::__hash_code_base;
+    public:
+      typedef _Value value_type;
+      typedef typename std::conditional<__constant_iterators,
+     const _Value*, _Value*>::type
+             pointer;
+      typedef typename std::conditional<__constant_iterators,
+     const _Value&, _Value&>::type
+             reference;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+      _Local_iterator() = default;
+      _Local_iterator(const __hash_code_base& __base,
+        _Hash_node<_Value, __cache>* __p,
+        std::size_t __bkt, std::size_t __bkt_count)
+ : __base_type(__base, __p, __bkt, __bkt_count)
+      { }
+      reference
+      operator*() const
+      { return this->_M_cur->_M_v(); }
+      pointer
+      operator->() const
+      { return this->_M_cur->_M_valptr(); }
+      _Local_iterator&
+      operator++()
+      {
+ this->_M_incr();
+ return *this;
+      }
+      _Local_iterator
+      operator++(int)
+      {
+ _Local_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+      }
+    };
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash,
+    bool __constant_iterators, bool __cache>
+    struct _Local_const_iterator
+    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
+      _H1, _H2, _Hash, __cache>
+    {
+    private:
+      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
+            _H1, _H2, _Hash, __cache>;
+      using __hash_code_base = typename __base_type::__hash_code_base;
+    public:
+      typedef _Value value_type;
+      typedef const _Value* pointer;
+      typedef const _Value& reference;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+      _Local_const_iterator() = default;
+      _Local_const_iterator(const __hash_code_base& __base,
+       _Hash_node<_Value, __cache>* __p,
+       std::size_t __bkt, std::size_t __bkt_count)
+ : __base_type(__base, __p, __bkt, __bkt_count)
+      { }
+      _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey,
+        _H1, _H2, _Hash,
+        __constant_iterators,
+        __cache>& __x)
+ : __base_type(__x)
+      { }
+      reference
+      operator*() const
+      { return this->_M_cur->_M_v(); }
+      pointer
+      operator->() const
+      { return this->_M_cur->_M_valptr(); }
+      _Local_const_iterator&
+      operator++()
+      {
+ this->_M_incr();
+ return *this;
+      }
+      _Local_const_iterator
+      operator++(int)
+      {
+ _Local_const_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+      }
+    };
+  template<typename _Key, typename _Value,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _Traits>
+  struct _Hashtable_base
+  : public _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash,
+      _Traits::__hash_cached::value>,
+    private _Hashtable_ebo_helper<0, _Equal>
+  {
+  public:
+    typedef _Key key_type;
+    typedef _Value value_type;
+    typedef _Equal key_equal;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    using __traits_type = _Traits;
+    using __hash_cached = typename __traits_type::__hash_cached;
+    using __constant_iterators = typename __traits_type::__constant_iterators;
+    using __unique_keys = typename __traits_type::__unique_keys;
+    using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
+          _H1, _H2, _Hash,
+          __hash_cached::value>;
+    using __hash_code = typename __hash_code_base::__hash_code;
+    using __node_type = typename __hash_code_base::__node_type;
+    using iterator = __detail::_Node_iterator<value_type,
+           __constant_iterators::value,
+           __hash_cached::value>;
+    using const_iterator = __detail::_Node_const_iterator<value_type,
+         __constant_iterators::value,
+         __hash_cached::value>;
+    using local_iterator = __detail::_Local_iterator<key_type, value_type,
+        _ExtractKey, _H1, _H2, _Hash,
+        __constant_iterators::value,
+           __hash_cached::value>;
+    using const_local_iterator = __detail::_Local_const_iterator<key_type,
+         value_type,
+     _ExtractKey, _H1, _H2, _Hash,
+     __constant_iterators::value,
+     __hash_cached::value>;
+    using __ireturn_type = typename std::conditional<__unique_keys::value,
+           std::pair<iterator, bool>,
+           iterator>::type;
+  private:
+    using _EqualEBO = _Hashtable_ebo_helper<0, _Equal>;
+    using _EqualHelper = _Equal_helper<_Key, _Value, _ExtractKey, _Equal,
+     __hash_code, __hash_cached::value>;
+  protected:
+    _Hashtable_base() = default;
+    _Hashtable_base(const _ExtractKey& __ex, const _H1& __h1, const _H2& __h2,
+      const _Hash& __hash, const _Equal& __eq)
+    : __hash_code_base(__ex, __h1, __h2, __hash), _EqualEBO(__eq)
+    { }
+    bool
+    _M_equals(const _Key& __k, __hash_code __c, __node_type* __n) const
+    {
+      static_assert(__is_invocable<const _Equal&, const _Key&, const _Key&>{},
+   "key equality predicate must be invocable with two arguments of "
+   "key type");
+      return _EqualHelper::_S_equals(_M_eq(), this->_M_extract(),
+         __k, __c, __n);
+    }
+    void
+    _M_swap(_Hashtable_base& __x)
+    {
+      __hash_code_base::_M_swap(__x);
+      std::swap(_M_eq(), __x._M_eq());
+    }
+    const _Equal&
+    _M_eq() const { return _EqualEBO::_S_cget(*this); }
+    _Equal&
+    _M_eq() { return _EqualEBO::_S_get(*this); }
+  };
+  struct _Equality_base
+  {
+  protected:
+    template<typename _Uiterator>
+      static bool
+      _S_is_permutation(_Uiterator, _Uiterator, _Uiterator);
+  };
+  template<typename _Uiterator>
+    bool
+    _Equality_base::
+    _S_is_permutation(_Uiterator __first1, _Uiterator __last1,
+        _Uiterator __first2)
+    {
+      for (; __first1 != __last1; ++__first1, ++__first2)
+ if (!(*__first1 == *__first2))
+   break;
+      if (__first1 == __last1)
+ return true;
+      _Uiterator __last2 = __first2;
+      std::advance(__last2, std::distance(__first1, __last1));
+      for (_Uiterator __it1 = __first1; __it1 != __last1; ++__it1)
+ {
+   _Uiterator __tmp = __first1;
+   while (__tmp != __it1 && !bool(*__tmp == *__it1))
+     ++__tmp;
+   if (__tmp != __it1)
+     continue;
+   std::ptrdiff_t __n2 = 0;
+   for (__tmp = __first2; __tmp != __last2; ++__tmp)
+     if (*__tmp == *__it1)
+       ++__n2;
+   if (!__n2)
+     return false;
+   std::ptrdiff_t __n1 = 0;
+   for (__tmp = __it1; __tmp != __last1; ++__tmp)
+     if (*__tmp == *__it1)
+       ++__n1;
+   if (__n1 != __n2)
+     return false;
+ }
+      return true;
+    }
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits,
+    bool _Unique_keys = _Traits::__unique_keys::value>
+    struct _Equality;
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
+    {
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+         _H1, _H2, _Hash, _RehashPolicy, _Traits>;
+      bool
+      _M_equal(const __hashtable&) const;
+    };
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    bool
+    _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    _M_equal(const __hashtable& __other) const
+    {
+      const __hashtable* __this = static_cast<const __hashtable*>(this);
+      if (__this->size() != __other.size())
+ return false;
+      for (auto __itx = __this->begin(); __itx != __this->end(); ++__itx)
+ {
+   const auto __ity = __other.find(_ExtractKey()(*__itx));
+   if (__ity == __other.end() || !bool(*__ity == *__itx))
+     return false;
+ }
+      return true;
+    }
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, false>
+    : public _Equality_base
+    {
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+         _H1, _H2, _Hash, _RehashPolicy, _Traits>;
+      bool
+      _M_equal(const __hashtable&) const;
+    };
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    bool
+    _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, false>::
+    _M_equal(const __hashtable& __other) const
+    {
+      const __hashtable* __this = static_cast<const __hashtable*>(this);
+      if (__this->size() != __other.size())
+ return false;
+      for (auto __itx = __this->begin(); __itx != __this->end();)
+ {
+   const auto __xrange = __this->equal_range(_ExtractKey()(*__itx));
+   const auto __yrange = __other.equal_range(_ExtractKey()(*__itx));
+   if (std::distance(__xrange.first, __xrange.second)
+       != std::distance(__yrange.first, __yrange.second))
+     return false;
+   if (!_S_is_permutation(__xrange.first, __xrange.second,
+     __yrange.first))
+     return false;
+   __itx = __xrange.second;
+ }
+      return true;
+    }
+  template<typename _NodeAlloc>
+    struct _Hashtable_alloc : private _Hashtable_ebo_helper<0, _NodeAlloc>
+    {
+    private:
+      using __ebo_node_alloc = _Hashtable_ebo_helper<0, _NodeAlloc>;
+    public:
+      using __node_type = typename _NodeAlloc::value_type;
+      using __node_alloc_type = _NodeAlloc;
+      using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>;
+      using __value_alloc_traits = typename __node_alloc_traits::template
+ rebind_traits<typename __node_type::value_type>;
+      using __node_base = __detail::_Hash_node_base;
+      using __bucket_type = __node_base*;
+      using __bucket_alloc_type =
+ __alloc_rebind<__node_alloc_type, __bucket_type>;
+      using __bucket_alloc_traits = std::allocator_traits<__bucket_alloc_type>;
+      _Hashtable_alloc() = default;
+      _Hashtable_alloc(const _Hashtable_alloc&) = default;
+      _Hashtable_alloc(_Hashtable_alloc&&) = default;
+      template<typename _Alloc>
+ _Hashtable_alloc(_Alloc&& __a)
+   : __ebo_node_alloc(std::forward<_Alloc>(__a))
+ { }
+      __node_alloc_type&
+      _M_node_allocator()
+      { return __ebo_node_alloc::_S_get(*this); }
+      const __node_alloc_type&
+      _M_node_allocator() const
+      { return __ebo_node_alloc::_S_cget(*this); }
+      template<typename... _Args>
+ __node_type*
+ _M_allocate_node(_Args&&... __args);
+      void
+      _M_deallocate_node(__node_type* __n);
+      void
+      _M_deallocate_nodes(__node_type* __n);
+      __bucket_type*
+      _M_allocate_buckets(std::size_t __n);
+      void
+      _M_deallocate_buckets(__bucket_type*, std::size_t __n);
+    };
+  template<typename _NodeAlloc>
+    template<typename... _Args>
+      typename _Hashtable_alloc<_NodeAlloc>::__node_type*
+      _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args)
+      {
+ auto __nptr = __node_alloc_traits::allocate(_M_node_allocator(), 1);
+ __node_type* __n = std::__to_address(__nptr);
+ try
+   {
+     ::new ((void*)__n) __node_type;
+     __node_alloc_traits::construct(_M_node_allocator(),
+        __n->_M_valptr(),
+        std::forward<_Args>(__args)...);
+     return __n;
+   }
+ catch(...)
+   {
+     __node_alloc_traits::deallocate(_M_node_allocator(), __nptr, 1);
+     throw;
+   }
+      }
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_type* __n)
+    {
+      typedef typename __node_alloc_traits::pointer _Ptr;
+      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n);
+      __node_alloc_traits::destroy(_M_node_allocator(), __n->_M_valptr());
+      __n->~__node_type();
+      __node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1);
+    }
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_type* __n)
+    {
+      while (__n)
+ {
+   __node_type* __tmp = __n;
+   __n = __n->_M_next();
+   _M_deallocate_node(__tmp);
+ }
+    }
+  template<typename _NodeAlloc>
+    typename _Hashtable_alloc<_NodeAlloc>::__bucket_type*
+    _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(std::size_t __n)
+    {
+      __bucket_alloc_type __alloc(_M_node_allocator());
+      auto __ptr = __bucket_alloc_traits::allocate(__alloc, __n);
+      __bucket_type* __p = std::__to_address(__ptr);
+      __builtin_memset(__p, 0, __n * sizeof(__bucket_type));
+      return __p;
+    }
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_buckets(__bucket_type* __bkts,
+       std::size_t __n)
+    {
+      typedef typename __bucket_alloc_traits::pointer _Ptr;
+      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts);
+      __bucket_alloc_type __alloc(_M_node_allocator());
+      __bucket_alloc_traits::deallocate(__alloc, __ptr, __n);
+    }
+}
+
+}
+       
+       
+       
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  struct _Enable_default_constructor_tag
+  {
+    explicit constexpr _Enable_default_constructor_tag() = default;
+  };
+template<bool _Switch, typename _Tag = void>
+  struct _Enable_default_constructor
+  {
+    constexpr _Enable_default_constructor() noexcept = default;
+    constexpr _Enable_default_constructor(_Enable_default_constructor const&)
+      noexcept = default;
+    constexpr _Enable_default_constructor(_Enable_default_constructor&&)
+      noexcept = default;
+    _Enable_default_constructor&
+    operator=(_Enable_default_constructor const&) noexcept = default;
+    _Enable_default_constructor&
+    operator=(_Enable_default_constructor&&) noexcept = default;
+    constexpr explicit
+    _Enable_default_constructor(_Enable_default_constructor_tag) { }
+  };
+template<bool _Switch, typename _Tag = void>
+  struct _Enable_destructor { };
+template<bool _Copy, bool _CopyAssignment,
+         bool _Move, bool _MoveAssignment,
+         typename _Tag = void>
+  struct _Enable_copy_move { };
+template<bool _Default, bool _Destructor,
+         bool _Copy, bool _CopyAssignment,
+         bool _Move, bool _MoveAssignment,
+         typename _Tag = void>
+  struct _Enable_special_members
+  : private _Enable_default_constructor<_Default, _Tag>,
+    private _Enable_destructor<_Destructor, _Tag>,
+    private _Enable_copy_move<_Copy, _CopyAssignment,
+                              _Move, _MoveAssignment,
+                              _Tag>
+  { };
+template<typename _Tag>
+  struct _Enable_default_constructor<false, _Tag>
+  {
+    constexpr _Enable_default_constructor() noexcept = delete;
+    constexpr _Enable_default_constructor(_Enable_default_constructor const&)
+      noexcept = default;
+    constexpr _Enable_default_constructor(_Enable_default_constructor&&)
+      noexcept = default;
+    _Enable_default_constructor&
+    operator=(_Enable_default_constructor const&) noexcept = default;
+    _Enable_default_constructor&
+    operator=(_Enable_default_constructor&&) noexcept = default;
+    constexpr explicit
+    _Enable_default_constructor(_Enable_default_constructor_tag) { }
+  };
+template<typename _Tag>
+  struct _Enable_destructor<false, _Tag>
+  { ~_Enable_destructor() noexcept = delete; };
+template<typename _Tag>
+  struct _Enable_copy_move<false, true, true, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<true, false, true, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<false, false, true, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<true, true, false, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<false, true, false, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<true, false, false, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<false, false, false, true, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = default;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<true, true, true, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<false, true, true, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<true, false, true, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<false, false, true, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<true, true, false, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<false, true, false, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = default;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<true, false, false, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+template<typename _Tag>
+  struct _Enable_copy_move<false, false, false, false, _Tag>
+  {
+    constexpr _Enable_copy_move() noexcept = default;
+    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
+    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move const&) noexcept = delete;
+    _Enable_copy_move&
+    operator=(_Enable_copy_move&&) noexcept = delete;
+  };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp>
+    class optional;
+  struct nullopt_t
+  {
+    enum class _Construct { _Token };
+    explicit constexpr nullopt_t(_Construct) { }
+  };
+  inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };
+  class bad_optional_access : public exception
+  {
+  public:
+    bad_optional_access() { }
+    virtual const char* what() const noexcept override
+    { return "bad optional access"; }
+    virtual ~bad_optional_access() noexcept = default;
+  };
+  void
+  __throw_bad_optional_access()
+  __attribute__((__noreturn__));
+  inline void
+  __throw_bad_optional_access()
+  { (throw (bad_optional_access())); }
+  template <typename _Tp,
+     bool =
+       is_trivially_destructible_v<_Tp>,
+     bool =
+       is_trivially_copy_assignable_v<_Tp>
+       && is_trivially_copy_constructible_v<_Tp>,
+     bool =
+       is_trivially_move_assignable_v<_Tp>
+       && is_trivially_move_constructible_v<_Tp>>
+    struct _Optional_payload
+    {
+      constexpr _Optional_payload() noexcept : _M_empty() { }
+      template <typename... _Args>
+ constexpr
+ _Optional_payload(in_place_t, _Args&&... __args)
+ : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { }
+      template<typename _Up, typename... _Args>
+ constexpr
+ _Optional_payload(std::initializer_list<_Up> __il,
+     _Args&&... __args)
+ : _M_payload(__il, std::forward<_Args>(__args)...),
+   _M_engaged(true)
+ { }
+      constexpr
+      _Optional_payload(bool __engaged, const _Optional_payload& __other)
+      : _Optional_payload(__other)
+      { }
+      constexpr
+      _Optional_payload(bool __engaged, _Optional_payload&& __other)
+      : _Optional_payload(std::move(__other))
+      { }
+      constexpr
+      _Optional_payload(const _Optional_payload& __other)
+      {
+ if (__other._M_engaged)
+   this->_M_construct(__other._M_payload);
+      }
+      constexpr
+      _Optional_payload(_Optional_payload&& __other)
+      {
+ if (__other._M_engaged)
+   this->_M_construct(std::move(__other._M_payload));
+      }
+      constexpr
+      _Optional_payload&
+      operator=(const _Optional_payload& __other)
+      {
+        if (this->_M_engaged && __other._M_engaged)
+          this->_M_get() = __other._M_get();
+        else
+   {
+     if (__other._M_engaged)
+       this->_M_construct(__other._M_get());
+     else
+       this->_M_reset();
+   }
+ return *this;
+      }
+      constexpr
+      _Optional_payload&
+      operator=(_Optional_payload&& __other)
+      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+        is_nothrow_move_assignable<_Tp>>())
+      {
+ if (this->_M_engaged && __other._M_engaged)
+   this->_M_get() = std::move(__other._M_get());
+ else
+   {
+     if (__other._M_engaged)
+       this->_M_construct(std::move(__other._M_get()));
+     else
+       this->_M_reset();
+   }
+ return *this;
+      }
+      using _Stored_type = remove_const_t<_Tp>;
+      struct _Empty_byte { };
+      union {
+          _Empty_byte _M_empty;
+          _Stored_type _M_payload;
+      };
+      bool _M_engaged = false;
+      ~_Optional_payload()
+      {
+        if (_M_engaged)
+          _M_payload.~_Stored_type();
+      }
+      template<typename... _Args>
+        void
+        _M_construct(_Args&&... __args)
+        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
+        {
+          ::new ((void *) std::__addressof(this->_M_payload))
+            _Stored_type(std::forward<_Args>(__args)...);
+          this->_M_engaged = true;
+        }
+      constexpr _Tp&
+      _M_get() noexcept
+      { return this->_M_payload; }
+      constexpr const _Tp&
+      _M_get() const noexcept
+      { return this->_M_payload; }
+      constexpr
+      void
+      _M_reset() noexcept
+      {
+ if (this->_M_engaged)
+   {
+     this->_M_engaged = false;
+     this->_M_payload.~_Stored_type();
+   }
+      }
+    };
+  template <typename _Tp>
+    struct _Optional_payload<_Tp, true, true, true>
+    {
+      constexpr _Optional_payload() noexcept
+      : _M_empty(), _M_engaged(false) { }
+      template<typename... _Args>
+ constexpr
+ _Optional_payload(in_place_t, _Args&&... __args)
+ : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true)
+ { }
+      template<typename _Up, typename... _Args>
+ constexpr
+ _Optional_payload(std::initializer_list<_Up> __il,
+     _Args&&... __args)
+ : _M_payload(__il, std::forward<_Args>(__args)...),
+   _M_engaged(true)
+ { }
+      constexpr
+      _Optional_payload(bool __engaged, const _Optional_payload& __other)
+      : _M_engaged(__engaged)
+      {
+ if (__engaged)
+   _M_construct(__other._M_get());
+      }
+      constexpr
+      _Optional_payload(bool __engaged, _Optional_payload&& __other)
+      : _M_engaged(__engaged)
+      {
+ if (__engaged)
+   _M_construct(std::move(__other._M_get()));
+      }
+      using _Stored_type = remove_const_t<_Tp>;
+      struct _Empty_byte { };
+      union {
+   _Empty_byte _M_empty;
+          _Stored_type _M_payload;
+      };
+      bool _M_engaged;
+      constexpr _Tp&
+      _M_get() noexcept
+      { return this->_M_payload; }
+      constexpr const _Tp&
+      _M_get() const noexcept
+      { return this->_M_payload; }
+    };
+  template <typename _Tp>
+    struct _Optional_payload<_Tp, true, false, true>
+    {
+      constexpr _Optional_payload() noexcept
+      : _M_empty(), _M_engaged(false) { }
+      template<typename... _Args>
+ constexpr
+ _Optional_payload(in_place_t, _Args&&... __args)
+ : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true)
+ { }
+      template<typename _Up, typename... _Args>
+ constexpr
+ _Optional_payload(std::initializer_list<_Up> __il,
+     _Args&&... __args)
+ : _M_payload(__il, std::forward<_Args>(__args)...),
+   _M_engaged(true)
+ { }
+      constexpr
+      _Optional_payload(bool __engaged, const _Optional_payload& __other)
+      : _M_engaged(__engaged)
+      {
+ if (__engaged)
+   _M_construct(__other._M_get());
+      }
+      constexpr
+      _Optional_payload(bool __engaged, _Optional_payload&& __other)
+      : _M_engaged(__engaged)
+      {
+ if (__engaged)
+   _M_construct(std::move(__other._M_get()));
+      }
+      _Optional_payload(const _Optional_payload&) = default;
+      _Optional_payload(_Optional_payload&&) = default;
+      constexpr
+      _Optional_payload&
+      operator=(const _Optional_payload& __other)
+      {
+        if (this->_M_engaged && __other._M_engaged)
+          this->_M_get() = __other._M_get();
+        else
+   {
+     if (__other._M_engaged)
+       this->_M_construct(__other._M_get());
+     else
+       this->_M_reset();
+   }
+ return *this;
+      }
+      _Optional_payload&
+      operator=(_Optional_payload&& __other) = default;
+      using _Stored_type = remove_const_t<_Tp>;
+      struct _Empty_byte { };
+      union {
+          _Empty_byte _M_empty;
+          _Stored_type _M_payload;
+      };
+      bool _M_engaged;
+      template<typename... _Args>
+        void
+        _M_construct(_Args&&... __args)
+        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
+        {
+          ::new ((void *) std::__addressof(this->_M_payload))
+            _Stored_type(std::forward<_Args>(__args)...);
+          this->_M_engaged = true;
+        }
+      constexpr _Tp&
+      _M_get() noexcept
+      { return this->_M_payload; }
+      constexpr const _Tp&
+      _M_get() const noexcept
+      { return this->_M_payload; }
+      constexpr
+      void
+      _M_reset() noexcept
+      {
+ if (this->_M_engaged)
+   {
+     this->_M_engaged = false;
+     this->_M_payload.~_Stored_type();
+   }
+      }
+    };
+  template <typename _Tp>
+    struct _Optional_payload<_Tp, true, true, false>
+    {
+      constexpr _Optional_payload() noexcept
+      : _M_empty(), _M_engaged(false) { }
+      template<typename... _Args>
+ constexpr
+ _Optional_payload(in_place_t, _Args&&... __args)
+ : _M_payload(std::forward<_Args>(__args)...),
+   _M_engaged(true)
+ { }
+      template<typename _Up, typename... _Args>
+ constexpr
+ _Optional_payload(std::initializer_list<_Up> __il,
+     _Args&&... __args)
+ : _M_payload(__il, std::forward<_Args>(__args)...),
+   _M_engaged(true)
+ { }
+      constexpr
+      _Optional_payload(bool __engaged, const _Optional_payload& __other)
+      : _M_engaged(__engaged)
+      {
+ if (__engaged)
+   _M_construct(__other._M_get());
+      }
+      constexpr
+      _Optional_payload(bool __engaged, _Optional_payload&& __other)
+      : _M_engaged(__engaged)
+      {
+ if (__engaged)
+   _M_construct(std::move(__other._M_get()));
+      }
+      _Optional_payload(const _Optional_payload&) = default;
+      _Optional_payload(_Optional_payload&&) = default;
+      _Optional_payload&
+      operator=(const _Optional_payload& __other) = default;
+      constexpr
+      _Optional_payload&
+      operator=(_Optional_payload&& __other)
+      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+        is_nothrow_move_assignable<_Tp>>())
+      {
+ if (this->_M_engaged && __other._M_engaged)
+   this->_M_get() = std::move(__other._M_get());
+ else
+   {
+     if (__other._M_engaged)
+       this->_M_construct(std::move(__other._M_get()));
+     else
+       this->_M_reset();
+   }
+ return *this;
+      }
+      using _Stored_type = remove_const_t<_Tp>;
+      struct _Empty_byte { };
+      union {
+          _Empty_byte _M_empty;
+          _Stored_type _M_payload;
+      };
+      bool _M_engaged;
+      template<typename... _Args>
+        void
+        _M_construct(_Args&&... __args)
+        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
+        {
+          ::new ((void *) std::__addressof(this->_M_payload))
+            _Stored_type(std::forward<_Args>(__args)...);
+          this->_M_engaged = true;
+        }
+      constexpr _Tp&
+      _M_get() noexcept
+      { return this->_M_payload; }
+      constexpr const _Tp&
+      _M_get() const noexcept
+      { return this->_M_payload; }
+      constexpr
+      void
+      _M_reset() noexcept
+      {
+ if (this->_M_engaged)
+   {
+     this->_M_engaged = false;
+     this->_M_payload.~_Stored_type();
+   }
+      }
+    };
+  template <typename _Tp>
+    struct _Optional_payload<_Tp, true, false, false>
+    {
+      constexpr _Optional_payload() noexcept
+      : _M_empty(), _M_engaged(false) {}
+      template<typename... _Args>
+ constexpr
+ _Optional_payload(in_place_t, _Args&&... __args)
+ : _M_payload(std::forward<_Args>(__args)...),
+   _M_engaged(true)
+ { }
+      template<typename _Up, typename... _Args>
+ constexpr
+ _Optional_payload(std::initializer_list<_Up> __il,
+     _Args&&... __args)
+ : _M_payload(__il, std::forward<_Args>(__args)...),
+   _M_engaged(true)
+ { }
+      constexpr
+      _Optional_payload(bool __engaged, const _Optional_payload& __other)
+      : _M_engaged(__engaged)
+      {
+ if (__engaged)
+   _M_construct(__other._M_get());
+      }
+      constexpr
+      _Optional_payload(bool __engaged, _Optional_payload&& __other)
+      : _M_engaged(__engaged)
+      {
+ if (__engaged)
+   _M_construct(std::move(__other._M_get()));
+      }
+      _Optional_payload(const _Optional_payload&) = default;
+      _Optional_payload(_Optional_payload&&) = default;
+      constexpr
+      _Optional_payload&
+      operator=(const _Optional_payload& __other)
+      {
+        if (this->_M_engaged && __other._M_engaged)
+          this->_M_get() = __other._M_get();
+        else
+   {
+     if (__other._M_engaged)
+       this->_M_construct(__other._M_get());
+     else
+       this->_M_reset();
+   }
+ return *this;
+      }
+      constexpr
+      _Optional_payload&
+      operator=(_Optional_payload&& __other)
+      noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+        is_nothrow_move_assignable<_Tp>>())
+      {
+ if (this->_M_engaged && __other._M_engaged)
+   this->_M_get() = std::move(__other._M_get());
+ else
+   {
+     if (__other._M_engaged)
+       this->_M_construct(std::move(__other._M_get()));
+     else
+       this->_M_reset();
+   }
+ return *this;
+      }
+      using _Stored_type = remove_const_t<_Tp>;
+      struct _Empty_byte { };
+      union {
+          _Empty_byte _M_empty;
+          _Stored_type _M_payload;
+      };
+      bool _M_engaged;
+      template<typename... _Args>
+        void
+        _M_construct(_Args&&... __args)
+        noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
+        {
+          ::new ((void *) std::__addressof(this->_M_payload))
+            _Stored_type(std::forward<_Args>(__args)...);
+          this->_M_engaged = true;
+        }
+      constexpr _Tp&
+      _M_get() noexcept
+      { return this->_M_payload; }
+      constexpr const _Tp&
+      _M_get() const noexcept
+      { return this->_M_payload; }
+      constexpr
+      void
+      _M_reset() noexcept
+      {
+ if (this->_M_engaged)
+   {
+     this->_M_engaged = false;
+     this->_M_payload.~_Stored_type();
+   }
+      }
+    };
+  template<typename _Tp, typename _Dp>
+    class _Optional_base_impl
+    {
+    protected:
+      using _Stored_type = remove_const_t<_Tp>;
+      template<typename... _Args>
+ void
+ _M_construct(_Args&&... __args)
+ noexcept(is_nothrow_constructible<_Stored_type, _Args...>())
+ {
+   ::new
+     (std::__addressof(static_cast<_Dp*>(this)->_M_payload._M_payload))
+     _Stored_type(std::forward<_Args>(__args)...);
+   static_cast<_Dp*>(this)->_M_payload._M_engaged = true;
+ }
+      void
+      _M_destruct() noexcept
+      {
+ static_cast<_Dp*>(this)->_M_payload._M_engaged = false;
+ static_cast<_Dp*>(this)->_M_payload._M_payload.~_Stored_type();
+      }
+      constexpr
+      void
+      _M_reset() noexcept
+      {
+ if (static_cast<_Dp*>(this)->_M_payload._M_engaged)
+   static_cast<_Dp*>(this)->_M_destruct();
+      }
+  };
+  template<typename _Tp,
+    bool = is_trivially_copy_constructible_v<_Tp>,
+    bool = is_trivially_move_constructible_v<_Tp>>
+    class _Optional_base
+      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
+    {
+      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
+    public:
+      constexpr _Optional_base() = default;
+      template<typename... _Args,
+        enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
+        : _M_payload(in_place,
+       std::forward<_Args>(__args)...) { }
+      template<typename _Up, typename... _Args,
+               enable_if_t<is_constructible_v<_Tp,
+           initializer_list<_Up>&,
+           _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t,
+                                          initializer_list<_Up> __il,
+                                          _Args&&... __args)
+        : _M_payload(in_place,
+       __il, std::forward<_Args>(__args)...)
+        { }
+      constexpr _Optional_base(const _Optional_base& __other)
+ : _M_payload(__other._M_payload._M_engaged,
+       __other._M_payload)
+      { }
+      constexpr _Optional_base(_Optional_base&& __other)
+      noexcept(is_nothrow_move_constructible<_Tp>())
+ : _M_payload(__other._M_payload._M_engaged,
+       std::move(__other._M_payload))
+      { }
+      _Optional_base& operator=(const _Optional_base&) = default;
+      _Optional_base& operator=(_Optional_base&&) = default;
+    protected:
+      constexpr bool _M_is_engaged() const noexcept
+      { return this->_M_payload._M_engaged; }
+      constexpr _Tp&
+ _M_get() noexcept
+      {
+ ;
+ return this->_M_payload._M_payload;
+      }
+      constexpr const _Tp&
+ _M_get() const noexcept
+      {
+ ;
+ return this->_M_payload._M_payload;
+      }
+    private:
+      _Optional_payload<_Tp> _M_payload;
+    };
+  template<typename _Tp>
+    class _Optional_base<_Tp, false, true>
+      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
+    {
+      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
+    public:
+      constexpr _Optional_base() = default;
+      template<typename... _Args,
+        enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
+        : _M_payload(in_place,
+       std::forward<_Args>(__args)...) { }
+      template<typename _Up, typename... _Args,
+               enable_if_t<is_constructible_v<_Tp,
+           initializer_list<_Up>&,
+           _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t,
+                                          initializer_list<_Up> __il,
+                                          _Args&&... __args)
+        : _M_payload(in_place,
+       __il, std::forward<_Args>(__args)...)
+        { }
+      constexpr _Optional_base(const _Optional_base& __other)
+ : _M_payload(__other._M_payload._M_engaged,
+       __other._M_payload)
+      { }
+      constexpr _Optional_base(_Optional_base&& __other) = default;
+      _Optional_base& operator=(const _Optional_base&) = default;
+      _Optional_base& operator=(_Optional_base&&) = default;
+    protected:
+      constexpr bool _M_is_engaged() const noexcept
+      { return this->_M_payload._M_engaged; }
+      constexpr _Tp&
+ _M_get() noexcept
+      {
+ ;
+ return this->_M_payload._M_payload;
+      }
+      constexpr const _Tp&
+ _M_get() const noexcept
+      {
+ ;
+ return this->_M_payload._M_payload;
+      }
+    private:
+      _Optional_payload<_Tp> _M_payload;
+    };
+  template<typename _Tp>
+    class _Optional_base<_Tp, true, false>
+      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
+    {
+      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
+    public:
+      constexpr _Optional_base() = default;
+      template<typename... _Args,
+        enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
+        : _M_payload(in_place,
+       std::forward<_Args>(__args)...) { }
+      template<typename _Up, typename... _Args,
+               enable_if_t<is_constructible_v<_Tp,
+           initializer_list<_Up>&,
+           _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t,
+                                          initializer_list<_Up> __il,
+                                          _Args&&... __args)
+        : _M_payload(in_place,
+       __il, std::forward<_Args>(__args)...)
+        { }
+      constexpr _Optional_base(const _Optional_base& __other) = default;
+      constexpr _Optional_base(_Optional_base&& __other)
+      noexcept(is_nothrow_move_constructible<_Tp>())
+ : _M_payload(__other._M_payload._M_engaged,
+       std::move(__other._M_payload))
+      { }
+      _Optional_base& operator=(const _Optional_base&) = default;
+      _Optional_base& operator=(_Optional_base&&) = default;
+    protected:
+      constexpr bool _M_is_engaged() const noexcept
+      { return this->_M_payload._M_engaged; }
+      constexpr _Tp&
+ _M_get() noexcept
+      {
+ ;
+ return this->_M_payload._M_payload;
+      }
+      constexpr const _Tp&
+ _M_get() const noexcept
+      {
+ ;
+ return this->_M_payload._M_payload;
+      }
+    private:
+      _Optional_payload<_Tp> _M_payload;
+    };
+  template<typename _Tp>
+    class _Optional_base<_Tp, true, true>
+      : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
+    {
+      friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
+    public:
+      constexpr _Optional_base() = default;
+      template<typename... _Args,
+        enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
+        : _M_payload(in_place,
+       std::forward<_Args>(__args)...) { }
+      template<typename _Up, typename... _Args,
+               enable_if_t<is_constructible_v<_Tp,
+           initializer_list<_Up>&,
+           _Args&&...>, bool> = false>
+        constexpr explicit _Optional_base(in_place_t,
+                                          initializer_list<_Up> __il,
+                                          _Args&&... __args)
+        : _M_payload(in_place,
+       __il, std::forward<_Args>(__args)...)
+        { }
+      constexpr _Optional_base(const _Optional_base& __other) = default;
+      constexpr _Optional_base(_Optional_base&& __other) = default;
+      _Optional_base& operator=(const _Optional_base&) = default;
+      _Optional_base& operator=(_Optional_base&&) = default;
+    protected:
+      constexpr bool _M_is_engaged() const noexcept
+      { return this->_M_payload._M_engaged; }
+      constexpr _Tp&
+ _M_get() noexcept
+      {
+ ;
+ return this->_M_payload._M_payload;
+      }
+      constexpr const _Tp&
+ _M_get() const noexcept
+      {
+ ;
+ return this->_M_payload._M_payload;
+      }
+    private:
+      _Optional_payload<_Tp> _M_payload;
+    };
+  template<typename _Tp>
+  class optional;
+  template<typename _Tp, typename _Up>
+    using __converts_from_optional =
+      __or_<is_constructible<_Tp, const optional<_Up>&>,
+     is_constructible<_Tp, optional<_Up>&>,
+     is_constructible<_Tp, const optional<_Up>&&>,
+     is_constructible<_Tp, optional<_Up>&&>,
+     is_convertible<const optional<_Up>&, _Tp>,
+     is_convertible<optional<_Up>&, _Tp>,
+     is_convertible<const optional<_Up>&&, _Tp>,
+     is_convertible<optional<_Up>&&, _Tp>>;
+  template<typename _Tp, typename _Up>
+    using __assigns_from_optional =
+      __or_<is_assignable<_Tp&, const optional<_Up>&>,
+     is_assignable<_Tp&, optional<_Up>&>,
+     is_assignable<_Tp&, const optional<_Up>&&>,
+     is_assignable<_Tp&, optional<_Up>&&>>;
+  template<typename _Tp>
+    class optional
+    : private _Optional_base<_Tp>,
+      private _Enable_copy_move<
+        is_copy_constructible<_Tp>::value,
+        __and_<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>::value,
+        is_move_constructible<_Tp>::value,
+        __and_<is_move_constructible<_Tp>, is_move_assignable<_Tp>>::value,
+        optional<_Tp>>
+    {
+      static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>);
+      static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>);
+      static_assert(!is_reference_v<_Tp>);
+    private:
+      using _Base = _Optional_base<_Tp>;
+    public:
+      using value_type = _Tp;
+      constexpr optional() = default;
+      constexpr optional(nullopt_t) noexcept { }
+      template <typename _Up = _Tp,
+                enable_if_t<__and_<
+         __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
+         __not_<is_same<in_place_t, decay_t<_Up>>>,
+         is_constructible<_Tp, _Up&&>,
+         is_convertible<_Up&&, _Tp>
+         >::value, bool> = true>
+      constexpr optional(_Up&& __t)
+        : _Base(std::in_place, std::forward<_Up>(__t)) { }
+      template <typename _Up = _Tp,
+                enable_if_t<__and_<
+         __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
+         __not_<is_same<in_place_t, decay_t<_Up>>>,
+         is_constructible<_Tp, _Up&&>,
+         __not_<is_convertible<_Up&&, _Tp>>
+         >::value, bool> = false>
+      explicit constexpr optional(_Up&& __t)
+        : _Base(std::in_place, std::forward<_Up>(__t)) { }
+      template <typename _Up,
+                enable_if_t<__and_<
+       __not_<is_same<_Tp, _Up>>,
+       is_constructible<_Tp, const _Up&>,
+       is_convertible<const _Up&, _Tp>,
+       __not_<__converts_from_optional<_Tp, _Up>>
+       >::value, bool> = true>
+      constexpr optional(const optional<_Up>& __t)
+      {
+ if (__t)
+   emplace(*__t);
+      }
+      template <typename _Up,
+                 enable_if_t<__and_<
+          __not_<is_same<_Tp, _Up>>,
+          is_constructible<_Tp, const _Up&>,
+          __not_<is_convertible<const _Up&, _Tp>>,
+          __not_<__converts_from_optional<_Tp, _Up>>
+          >::value, bool> = false>
+      explicit constexpr optional(const optional<_Up>& __t)
+      {
+ if (__t)
+   emplace(*__t);
+      }
+      template <typename _Up,
+                enable_if_t<__and_<
+         __not_<is_same<_Tp, _Up>>,
+         is_constructible<_Tp, _Up&&>,
+         is_convertible<_Up&&, _Tp>,
+         __not_<__converts_from_optional<_Tp, _Up>>
+         >::value, bool> = true>
+      constexpr optional(optional<_Up>&& __t)
+      {
+ if (__t)
+   emplace(std::move(*__t));
+      }
+      template <typename _Up,
+                enable_if_t<__and_<
+       __not_<is_same<_Tp, _Up>>,
+       is_constructible<_Tp, _Up&&>,
+       __not_<is_convertible<_Up&&, _Tp>>,
+       __not_<__converts_from_optional<_Tp, _Up>>
+       >::value, bool> = false>
+      explicit constexpr optional(optional<_Up>&& __t)
+      {
+ if (__t)
+   emplace(std::move(*__t));
+      }
+      template<typename... _Args,
+        enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
+      explicit constexpr optional(in_place_t, _Args&&... __args)
+        : _Base(std::in_place, std::forward<_Args>(__args)...) { }
+      template<typename _Up, typename... _Args,
+               enable_if_t<is_constructible_v<_Tp,
+           initializer_list<_Up>&,
+           _Args&&...>, bool> = false>
+      explicit constexpr optional(in_place_t,
+      initializer_list<_Up> __il,
+      _Args&&... __args)
+        : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }
+      optional&
+      operator=(nullopt_t) noexcept
+      {
+        this->_M_reset();
+        return *this;
+      }
+      template<typename _Up = _Tp>
+        enable_if_t<__and_<
+        __not_<is_same<optional<_Tp>, decay_t<_Up>>>,
+        is_constructible<_Tp, _Up>,
+        __not_<__and_<is_scalar<_Tp>,
+        is_same<_Tp, decay_t<_Up>>>>,
+        is_assignable<_Tp&, _Up>>::value,
+      optional&>
+        operator=(_Up&& __u)
+        {
+          if (this->_M_is_engaged())
+            this->_M_get() = std::forward<_Up>(__u);
+          else
+            this->_M_construct(std::forward<_Up>(__u));
+          return *this;
+        }
+      template<typename _Up>
+ enable_if_t<__and_<
+        __not_<is_same<_Tp, _Up>>,
+        is_constructible<_Tp, const _Up&>,
+        is_assignable<_Tp&, _Up>,
+        __not_<__converts_from_optional<_Tp, _Up>>,
+        __not_<__assigns_from_optional<_Tp, _Up>>
+        >::value,
+      optional&>
+        operator=(const optional<_Up>& __u)
+        {
+          if (__u)
+            {
+              if (this->_M_is_engaged())
+                this->_M_get() = *__u;
+              else
+                this->_M_construct(*__u);
+            }
+          else
+            {
+              this->_M_reset();
+            }
+          return *this;
+        }
+      template<typename _Up>
+ enable_if_t<__and_<
+        __not_<is_same<_Tp, _Up>>,
+        is_constructible<_Tp, _Up>,
+        is_assignable<_Tp&, _Up>,
+        __not_<__converts_from_optional<_Tp, _Up>>,
+        __not_<__assigns_from_optional<_Tp, _Up>>
+        >::value,
+      optional&>
+        operator=(optional<_Up>&& __u)
+        {
+          if (__u)
+            {
+              if (this->_M_is_engaged())
+                this->_M_get() = std::move(*__u);
+              else
+                this->_M_construct(std::move(*__u));
+            }
+          else
+            {
+              this->_M_reset();
+            }
+          return *this;
+        }
+      template<typename... _Args>
+ enable_if_t<is_constructible<_Tp, _Args&&...>::value, _Tp&>
+ emplace(_Args&&... __args)
+ {
+   this->_M_reset();
+   this->_M_construct(std::forward<_Args>(__args)...);
+   return this->_M_get();
+ }
+      template<typename _Up, typename... _Args>
+ enable_if_t<is_constructible<_Tp, initializer_list<_Up>&,
+         _Args&&...>::value, _Tp&>
+ emplace(initializer_list<_Up> __il, _Args&&... __args)
+ {
+   this->_M_reset();
+   this->_M_construct(__il, std::forward<_Args>(__args)...);
+   return this->_M_get();
+ }
+      void
+      swap(optional& __other)
+      noexcept(is_nothrow_move_constructible<_Tp>()
+               && is_nothrow_swappable_v<_Tp>)
+      {
+        using std::swap;
+        if (this->_M_is_engaged() && __other._M_is_engaged())
+          swap(this->_M_get(), __other._M_get());
+        else if (this->_M_is_engaged())
+   {
+     __other._M_construct(std::move(this->_M_get()));
+     this->_M_destruct();
+   }
+        else if (__other._M_is_engaged())
+   {
+     this->_M_construct(std::move(__other._M_get()));
+     __other._M_destruct();
+   }
+      }
+      constexpr const _Tp*
+      operator->() const
+      { return std::__addressof(this->_M_get()); }
+      constexpr
+      _Tp*
+      operator->()
+      { return std::__addressof(this->_M_get()); }
+      constexpr const _Tp&
+      operator*() const&
+      { return this->_M_get(); }
+      constexpr _Tp&
+      operator*()&
+      { return this->_M_get(); }
+      constexpr _Tp&&
+      operator*()&&
+      { return std::move(this->_M_get()); }
+      constexpr const _Tp&&
+      operator*() const&&
+      { return std::move(this->_M_get()); }
+      constexpr explicit operator bool() const noexcept
+      { return this->_M_is_engaged(); }
+      constexpr bool has_value() const noexcept
+      { return this->_M_is_engaged(); }
+      constexpr const _Tp&
+      value() const&
+      {
+ return this->_M_is_engaged()
+   ? this->_M_get()
+   : (__throw_bad_optional_access(),
+      this->_M_get());
+      }
+      constexpr _Tp&
+      value()&
+      {
+ return this->_M_is_engaged()
+   ? this->_M_get()
+   : (__throw_bad_optional_access(),
+      this->_M_get());
+      }
+      constexpr _Tp&&
+      value()&&
+      {
+ return this->_M_is_engaged()
+   ? std::move(this->_M_get())
+   : (__throw_bad_optional_access(),
+      std::move(this->_M_get()));
+      }
+      constexpr const _Tp&&
+      value() const&&
+      {
+ return this->_M_is_engaged()
+   ? std::move(this->_M_get())
+   : (__throw_bad_optional_access(),
+      std::move(this->_M_get()));
+      }
+      template<typename _Up>
+ constexpr _Tp
+ value_or(_Up&& __u) const&
+ {
+   static_assert(is_copy_constructible_v<_Tp>);
+   static_assert(is_convertible_v<_Up&&, _Tp>);
+   return this->_M_is_engaged()
+     ? this->_M_get()
+     : static_cast<_Tp>(std::forward<_Up>(__u));
+ }
+      template<typename _Up>
+ constexpr _Tp
+ value_or(_Up&& __u) &&
+ {
+   static_assert(is_move_constructible_v<_Tp>);
+   static_assert(is_convertible_v<_Up&&, _Tp>);
+   return this->_M_is_engaged()
+     ? std::move(this->_M_get())
+     : static_cast<_Tp>(std::forward<_Up>(__u));
+ }
+      void reset() noexcept { this->_M_reset(); }
+    };
+  template<typename _Tp>
+    using __optional_relop_t =
+    enable_if_t<is_convertible<_Tp, bool>::value, bool>;
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
+    {
+      return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
+      && (!__lhs || *__lhs == *__rhs);
+    }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
+    {
+      return static_cast<bool>(__lhs) != static_cast<bool>(__rhs)
+ || (static_cast<bool>(__lhs) && *__lhs != *__rhs);
+    }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
+    {
+      return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
+    }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
+    {
+      return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs);
+    }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
+    {
+      return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs);
+    }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
+    {
+      return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs);
+    }
+  template<typename _Tp>
+    constexpr bool
+    operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept
+    { return !__lhs; }
+  template<typename _Tp>
+    constexpr bool
+    operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept
+    { return !__rhs; }
+  template<typename _Tp>
+    constexpr bool
+    operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept
+    { return static_cast<bool>(__lhs); }
+  template<typename _Tp>
+    constexpr bool
+    operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept
+    { return static_cast<bool>(__rhs); }
+  template<typename _Tp>
+    constexpr bool
+    operator<(const optional<_Tp>& , nullopt_t) noexcept
+    { return false; }
+  template<typename _Tp>
+    constexpr bool
+    operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept
+    { return static_cast<bool>(__rhs); }
+  template<typename _Tp>
+    constexpr bool
+    operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept
+    { return static_cast<bool>(__lhs); }
+  template<typename _Tp>
+    constexpr bool
+    operator>(nullopt_t, const optional<_Tp>& ) noexcept
+    { return false; }
+  template<typename _Tp>
+    constexpr bool
+    operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept
+    { return !__lhs; }
+  template<typename _Tp>
+    constexpr bool
+    operator<=(nullopt_t, const optional<_Tp>& ) noexcept
+    { return true; }
+  template<typename _Tp>
+    constexpr bool
+    operator>=(const optional<_Tp>& , nullopt_t) noexcept
+    { return true; }
+  template<typename _Tp>
+    constexpr bool
+    operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept
+    { return !__rhs; }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator==(const optional<_Tp>& __lhs, const _Up& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
+    { return __lhs && *__lhs == __rhs; }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator==(const _Up& __lhs, const optional<_Tp>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Up>() == declval<_Tp>())>
+    { return __rhs && __lhs == *__rhs; }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator!=(const optional<_Tp>& __lhs, const _Up& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
+    { return !__lhs || *__lhs != __rhs; }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator!=(const _Up& __lhs, const optional<_Tp>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Up>() != declval<_Tp>())>
+    { return !__rhs || __lhs != *__rhs; }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator<(const optional<_Tp>& __lhs, const _Up& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
+    { return !__lhs || *__lhs < __rhs; }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator<(const _Up& __lhs, const optional<_Tp>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Up>() < declval<_Tp>())>
+    { return __rhs && __lhs < *__rhs; }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator>(const optional<_Tp>& __lhs, const _Up& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
+    { return __lhs && *__lhs > __rhs; }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator>(const _Up& __lhs, const optional<_Tp>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Up>() > declval<_Tp>())>
+    { return !__rhs || __lhs > *__rhs; }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator<=(const optional<_Tp>& __lhs, const _Up& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
+    { return !__lhs || *__lhs <= __rhs; }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator<=(const _Up& __lhs, const optional<_Tp>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Up>() <= declval<_Tp>())>
+    { return __rhs && __lhs <= *__rhs; }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator>=(const optional<_Tp>& __lhs, const _Up& __rhs)
+    -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
+    { return __lhs && *__lhs >= __rhs; }
+  template<typename _Tp, typename _Up>
+    constexpr auto
+    operator>=(const _Up& __lhs, const optional<_Tp>& __rhs)
+    -> __optional_relop_t<decltype(declval<_Up>() >= declval<_Tp>())>
+    { return !__rhs || __lhs >= *__rhs; }
+  template<typename _Tp>
+    inline enable_if_t<is_move_constructible_v<_Tp> && is_swappable_v<_Tp>>
+    swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs)
+    noexcept(noexcept(__lhs.swap(__rhs)))
+    { __lhs.swap(__rhs); }
+  template<typename _Tp>
+    enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)>
+    swap(optional<_Tp>&, optional<_Tp>&) = delete;
+  template<typename _Tp>
+    constexpr optional<decay_t<_Tp>>
+    make_optional(_Tp&& __t)
+    { return optional<decay_t<_Tp>> { std::forward<_Tp>(__t) }; }
+  template<typename _Tp, typename ..._Args>
+    constexpr optional<_Tp>
+    make_optional(_Args&&... __args)
+    { return optional<_Tp> { in_place, std::forward<_Args>(__args)... }; }
+  template<typename _Tp, typename _Up, typename ..._Args>
+    constexpr optional<_Tp>
+    make_optional(initializer_list<_Up> __il, _Args&&... __args)
+    { return optional<_Tp> { in_place, __il, std::forward<_Args>(__args)... }; }
+  template<typename _Tp, typename _Up = remove_const_t<_Tp>,
+           bool = __poison_hash<_Up>::__enable_hash_call>
+    struct __optional_hash_call_base
+    {
+      size_t
+      operator()(const optional<_Tp>& __t) const
+      noexcept(noexcept(hash<_Up>{}(*__t)))
+      {
+        constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333);
+        return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash;
+      }
+    };
+  template<typename _Tp, typename _Up>
+    struct __optional_hash_call_base<_Tp, _Up, false> {};
+  template<typename _Tp>
+    struct hash<optional<_Tp>>
+    : private __poison_hash<remove_const_t<_Tp>>,
+      public __optional_hash_call_base<_Tp>
+    {
+      using result_type [[__deprecated__]] = size_t;
+      using argument_type [[__deprecated__]] = optional<_Tp>;
+    };
+  template<typename _Tp>
+    struct __is_fast_hash<hash<optional<_Tp>>> : __is_fast_hash<hash<_Tp>>
+    { };
+  template <typename _Tp> optional(_Tp) -> optional<_Tp>;
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Val, typename _NodeAlloc>
+    class _Node_handle_common
+    {
+      using _AllocTraits = allocator_traits<_NodeAlloc>;
+    public:
+      using allocator_type = __alloc_rebind<_NodeAlloc, _Val>;
+      allocator_type
+      get_allocator() const noexcept
+      {
+ ;
+ return allocator_type(*_M_alloc);
+      }
+      explicit operator bool() const noexcept { return _M_ptr != nullptr; }
+      [[nodiscard]] bool empty() const noexcept { return _M_ptr == nullptr; }
+    protected:
+      constexpr _Node_handle_common() noexcept : _M_ptr(), _M_alloc() {}
+      ~_Node_handle_common() { _M_destroy(); }
+      _Node_handle_common(_Node_handle_common&& __nh) noexcept
+      : _M_ptr(__nh._M_ptr), _M_alloc(std::move(__nh._M_alloc))
+      {
+ __nh._M_ptr = nullptr;
+ __nh._M_alloc = nullopt;
+      }
+      _Node_handle_common&
+      operator=(_Node_handle_common&& __nh) noexcept
+      {
+ _M_destroy();
+ _M_ptr = __nh._M_ptr;
+ if constexpr (is_move_assignable_v<_NodeAlloc>)
+   {
+     if (_AllocTraits::propagate_on_container_move_assignment::value
+  || !this->_M_alloc)
+       this->_M_alloc = std::move(__nh._M_alloc);
+     else
+       {
+  ;
+       }
+   }
+ else
+   {
+     ;
+   }
+ __nh._M_ptr = nullptr;
+ __nh._M_alloc = nullopt;
+ return *this;
+      }
+      _Node_handle_common(typename _AllocTraits::pointer __ptr,
+     const _NodeAlloc& __alloc)
+      : _M_ptr(__ptr), _M_alloc(__alloc) { }
+      void
+      _M_swap(_Node_handle_common& __nh) noexcept
+      {
+ using std::swap;
+ swap(_M_ptr, __nh._M_ptr);
+ if (_AllocTraits::propagate_on_container_swap::value
+     || !_M_alloc || !__nh._M_alloc)
+   _M_alloc.swap(__nh._M_alloc);
+ else
+   {
+     ;
+   }
+      }
+    private:
+      void
+      _M_destroy() noexcept
+      {
+ if (_M_ptr != nullptr)
+   {
+     allocator_type __alloc(*_M_alloc);
+     allocator_traits<allocator_type>::destroy(__alloc,
+            _M_ptr->_M_valptr());
+     _AllocTraits::deallocate(*_M_alloc, _M_ptr, 1);
+   }
+      }
+    protected:
+      typename _AllocTraits::pointer _M_ptr;
+    private:
+      optional<_NodeAlloc> _M_alloc;
+      template<typename _Key2, typename _Value2, typename _KeyOfValue,
+        typename _Compare, typename _ValueAlloc>
+ friend class _Rb_tree;
+    };
+  template<typename _Key, typename _Value, typename _NodeAlloc>
+    class _Node_handle : public _Node_handle_common<_Value, _NodeAlloc>
+    {
+    public:
+      constexpr _Node_handle() noexcept = default;
+      ~_Node_handle() = default;
+      _Node_handle(_Node_handle&&) noexcept = default;
+      _Node_handle&
+      operator=(_Node_handle&&) noexcept = default;
+      using key_type = _Key;
+      using mapped_type = typename _Value::second_type;
+      key_type&
+      key() const noexcept
+      {
+ ;
+ return *_M_pkey;
+      }
+      mapped_type&
+      mapped() const noexcept
+      {
+ ;
+ return *_M_pmapped;
+      }
+      void
+      swap(_Node_handle& __nh) noexcept
+      {
+ this->_M_swap(__nh);
+ using std::swap;
+ swap(_M_pkey, __nh._M_pkey);
+ swap(_M_pmapped, __nh._M_pmapped);
+      }
+      friend void
+      swap(_Node_handle& __x, _Node_handle& __y)
+      noexcept(noexcept(__x.swap(__y)))
+      { __x.swap(__y); }
+    private:
+      using _AllocTraits = allocator_traits<_NodeAlloc>;
+      _Node_handle(typename _AllocTraits::pointer __ptr,
+     const _NodeAlloc& __alloc)
+      : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc)
+      {
+ if (__ptr)
+   {
+     auto& __key = const_cast<_Key&>(__ptr->_M_valptr()->first);
+     _M_pkey = _S_pointer_to(__key);
+     _M_pmapped = _S_pointer_to(__ptr->_M_valptr()->second);
+   }
+ else
+   {
+     _M_pkey = nullptr;
+     _M_pmapped = nullptr;
+   }
+      }
+      template<typename _Tp>
+ using __pointer
+   = __ptr_rebind<typename _AllocTraits::pointer,
+    remove_reference_t<_Tp>>;
+      __pointer<_Key> _M_pkey = nullptr;
+      __pointer<typename _Value::second_type> _M_pmapped = nullptr;
+      template<typename _Tp>
+ __pointer<_Tp>
+ _S_pointer_to(_Tp& __obj)
+ { return pointer_traits<__pointer<_Tp>>::pointer_to(__obj); }
+      const key_type&
+      _M_key() const noexcept { return key(); }
+      template<typename _Key2, typename _Value2, typename _KeyOfValue,
+        typename _Compare, typename _ValueAlloc>
+ friend class _Rb_tree;
+      template<typename _Key2, typename _Value2, typename _ValueAlloc,
+        typename _ExtractKey, typename _Equal,
+        typename _H1, typename _H2, typename _Hash,
+        typename _RehashPolicy, typename _Traits>
+ friend class _Hashtable;
+    };
+  template<typename _Value, typename _NodeAlloc>
+    class _Node_handle<_Value, _Value, _NodeAlloc>
+    : public _Node_handle_common<_Value, _NodeAlloc>
+    {
+    public:
+      constexpr _Node_handle() noexcept = default;
+      ~_Node_handle() = default;
+      _Node_handle(_Node_handle&&) noexcept = default;
+      _Node_handle&
+      operator=(_Node_handle&&) noexcept = default;
+      using value_type = _Value;
+      value_type&
+      value() const noexcept
+      {
+ ;
+ return *this->_M_ptr->_M_valptr();
+      }
+      void
+      swap(_Node_handle& __nh) noexcept
+      { this->_M_swap(__nh); }
+      friend void
+      swap(_Node_handle& __x, _Node_handle& __y)
+      noexcept(noexcept(__x.swap(__y)))
+      { __x.swap(__y); }
+    private:
+      using _AllocTraits = allocator_traits<_NodeAlloc>;
+      _Node_handle(typename _AllocTraits::pointer __ptr,
+     const _NodeAlloc& __alloc)
+      : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) { }
+      const value_type&
+      _M_key() const noexcept { return value(); }
+      template<typename _Key, typename _Val, typename _KeyOfValue,
+        typename _Compare, typename _Alloc>
+ friend class _Rb_tree;
+      template<typename _Key2, typename _Value2, typename _ValueAlloc,
+        typename _ExtractKey, typename _Equal,
+        typename _H1, typename _H2, typename _Hash,
+        typename _RehashPolicy, typename _Traits>
+ friend class _Hashtable;
+    };
+  template<typename _Iterator, typename _NodeHandle>
+    struct _Node_insert_return
+    {
+      _Iterator position = _Iterator();
+      bool inserted = false;
+      _NodeHandle node;
+    };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Tp, typename _Hash>
+    using __cache_default
+      = __not_<__and_<
+         __is_fast_hash<_Hash>,
+         __is_nothrow_invocable<const _Hash&, const _Tp&>>>;
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    class _Hashtable
+    : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal,
+           _H1, _H2, _Hash, _Traits>,
+      public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+     _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+          _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+     _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      private __detail::_Hashtable_alloc<
+ __alloc_rebind<_Alloc,
+         __detail::_Hash_node<_Value,
+         _Traits::__hash_cached::value>>>
+    {
+      static_assert(is_same<typename remove_cv<_Value>::type, _Value>::value,
+   "unordered container must have a non-const, non-volatile value_type");
+      static_assert(is_same<typename _Alloc::value_type, _Value>{},
+   "unordered container must have the same value_type as its allocator");
+      using __traits_type = _Traits;
+      using __hash_cached = typename __traits_type::__hash_cached;
+      using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>;
+      using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>;
+      using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>;
+      using __value_alloc_traits =
+ typename __hashtable_alloc::__value_alloc_traits;
+      using __node_alloc_traits =
+ typename __hashtable_alloc::__node_alloc_traits;
+      using __node_base = typename __hashtable_alloc::__node_base;
+      using __bucket_type = typename __hashtable_alloc::__bucket_type;
+    public:
+      typedef _Key key_type;
+      typedef _Value value_type;
+      typedef _Alloc allocator_type;
+      typedef _Equal key_equal;
+      typedef typename __value_alloc_traits::pointer pointer;
+      typedef typename __value_alloc_traits::const_pointer const_pointer;
+      typedef value_type& reference;
+      typedef const value_type& const_reference;
+    private:
+      using __rehash_type = _RehashPolicy;
+      using __rehash_state = typename __rehash_type::_State;
+      using __constant_iterators = typename __traits_type::__constant_iterators;
+      using __unique_keys = typename __traits_type::__unique_keys;
+      using __key_extract = typename std::conditional<
+          __constant_iterators::value,
+                 __detail::_Identity,
+          __detail::_Select1st>::type;
+      using __hashtable_base = __detail::
+          _Hashtable_base<_Key, _Value, _ExtractKey,
+           _Equal, _H1, _H2, _Hash, _Traits>;
+      using __hash_code_base = typename __hashtable_base::__hash_code_base;
+      using __hash_code = typename __hashtable_base::__hash_code;
+      using __ireturn_type = typename __hashtable_base::__ireturn_type;
+      using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey,
+          _Equal, _H1, _H2, _Hash,
+          _RehashPolicy, _Traits>;
+      using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc,
+         _ExtractKey, _Equal,
+         _H1, _H2, _Hash,
+         _RehashPolicy, _Traits>;
+      using __eq_base = __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey,
+         _Equal, _H1, _H2, _Hash,
+         _RehashPolicy, _Traits>;
+      using __reuse_or_alloc_node_type =
+ __detail::_ReuseOrAllocNode<__node_alloc_type>;
+      template<typename _Cond>
+ using __if_hash_cached = __or_<__not_<__hash_cached>, _Cond>;
+      template<typename _Cond>
+ using __if_hash_not_cached = __or_<__hash_cached, _Cond>;
+      struct __hash_code_base_access : __hash_code_base
+      { using __hash_code_base::_M_bucket_index; };
+      static_assert(noexcept(declval<const __hash_code_base_access&>()
+        ._M_bucket_index((const __node_type*)nullptr,
+           (std::size_t)0)),
+      "Cache the hash code or qualify your functors involved"
+      " in hash code and bucket index computation with noexcept");
+      static_assert(__if_hash_cached<is_default_constructible<_H2>>::value,
+      "Functor used to map hash code to bucket index"
+      " must be default constructible");
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+        typename _ExtractKeya, typename _Equala,
+        typename _H1a, typename _H2a, typename _Hasha,
+        typename _RehashPolicya, typename _Traitsa,
+        bool _Unique_keysa>
+ friend struct __detail::_Map_base;
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+        typename _ExtractKeya, typename _Equala,
+        typename _H1a, typename _H2a, typename _Hasha,
+        typename _RehashPolicya, typename _Traitsa>
+ friend struct __detail::_Insert_base;
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+        typename _ExtractKeya, typename _Equala,
+        typename _H1a, typename _H2a, typename _Hasha,
+        typename _RehashPolicya, typename _Traitsa,
+        bool _Constant_iteratorsa>
+ friend struct __detail::_Insert;
+    public:
+      using size_type = typename __hashtable_base::size_type;
+      using difference_type = typename __hashtable_base::difference_type;
+      using iterator = typename __hashtable_base::iterator;
+      using const_iterator = typename __hashtable_base::const_iterator;
+      using local_iterator = typename __hashtable_base::local_iterator;
+      using const_local_iterator = typename __hashtable_base::
+       const_local_iterator;
+      using node_type = _Node_handle<_Key, _Value, __node_alloc_type>;
+      using insert_return_type = _Node_insert_return<iterator, node_type>;
+    private:
+      __bucket_type* _M_buckets = &_M_single_bucket;
+      size_type _M_bucket_count = 1;
+      __node_base _M_before_begin;
+      size_type _M_element_count = 0;
+      _RehashPolicy _M_rehash_policy;
+      __bucket_type _M_single_bucket = nullptr;
+      bool
+      _M_uses_single_bucket(__bucket_type* __bkts) const
+      { return __builtin_expect(__bkts == &_M_single_bucket, false); }
+      bool
+      _M_uses_single_bucket() const
+      { return _M_uses_single_bucket(_M_buckets); }
+      __hashtable_alloc&
+      _M_base_alloc() { return *this; }
+      __bucket_type*
+      _M_allocate_buckets(size_type __n)
+      {
+ if (__builtin_expect(__n == 1, false))
+   {
+     _M_single_bucket = nullptr;
+     return &_M_single_bucket;
+   }
+ return __hashtable_alloc::_M_allocate_buckets(__n);
+      }
+      void
+      _M_deallocate_buckets(__bucket_type* __bkts, size_type __n)
+      {
+ if (_M_uses_single_bucket(__bkts))
+   return;
+ __hashtable_alloc::_M_deallocate_buckets(__bkts, __n);
+      }
+      void
+      _M_deallocate_buckets()
+      { _M_deallocate_buckets(_M_buckets, _M_bucket_count); }
+      __node_type*
+      _M_bucket_begin(size_type __bkt) const;
+      __node_type*
+      _M_begin() const
+      { return static_cast<__node_type*>(_M_before_begin._M_nxt); }
+      template<typename _NodeGenerator>
+ void
+ _M_assign(const _Hashtable&, const _NodeGenerator&);
+      void
+      _M_move_assign(_Hashtable&&, std::true_type);
+      void
+      _M_move_assign(_Hashtable&&, std::false_type);
+      void
+      _M_reset() noexcept;
+      _Hashtable(const _H1& __h1, const _H2& __h2, const _Hash& __h,
+   const _Equal& __eq, const _ExtractKey& __exk,
+   const allocator_type& __a)
+ : __hashtable_base(__exk, __h1, __h2, __h, __eq),
+   __hashtable_alloc(__node_alloc_type(__a))
+      { }
+    public:
+      _Hashtable() = default;
+      _Hashtable(size_type __bucket_hint,
+   const _H1&, const _H2&, const _Hash&,
+   const _Equal&, const _ExtractKey&,
+   const allocator_type&);
+      template<typename _InputIterator>
+ _Hashtable(_InputIterator __first, _InputIterator __last,
+     size_type __bucket_hint,
+     const _H1&, const _H2&, const _Hash&,
+     const _Equal&, const _ExtractKey&,
+     const allocator_type&);
+      _Hashtable(const _Hashtable&);
+      _Hashtable(_Hashtable&&) noexcept;
+      _Hashtable(const _Hashtable&, const allocator_type&);
+      _Hashtable(_Hashtable&&, const allocator_type&);
+      explicit
+      _Hashtable(const allocator_type& __a)
+ : __hashtable_alloc(__node_alloc_type(__a))
+      { }
+      explicit
+      _Hashtable(size_type __n,
+   const _H1& __hf = _H1(),
+   const key_equal& __eql = key_equal(),
+   const allocator_type& __a = allocator_type())
+      : _Hashtable(__n, __hf, _H2(), _Hash(), __eql,
+     __key_extract(), __a)
+      { }
+      template<typename _InputIterator>
+ _Hashtable(_InputIterator __f, _InputIterator __l,
+     size_type __n = 0,
+     const _H1& __hf = _H1(),
+     const key_equal& __eql = key_equal(),
+     const allocator_type& __a = allocator_type())
+ : _Hashtable(__f, __l, __n, __hf, _H2(), _Hash(), __eql,
+       __key_extract(), __a)
+ { }
+      _Hashtable(initializer_list<value_type> __l,
+   size_type __n = 0,
+   const _H1& __hf = _H1(),
+   const key_equal& __eql = key_equal(),
+   const allocator_type& __a = allocator_type())
+      : _Hashtable(__l.begin(), __l.end(), __n, __hf, _H2(), _Hash(), __eql,
+     __key_extract(), __a)
+      { }
+      _Hashtable&
+      operator=(const _Hashtable& __ht);
+      _Hashtable&
+      operator=(_Hashtable&& __ht)
+      noexcept(__node_alloc_traits::_S_nothrow_move()
+        && is_nothrow_move_assignable<_H1>::value
+        && is_nothrow_move_assignable<_Equal>::value)
+      {
+        constexpr bool __move_storage =
+   __node_alloc_traits::_S_propagate_on_move_assign()
+   || __node_alloc_traits::_S_always_equal();
+ _M_move_assign(std::move(__ht), __bool_constant<__move_storage>());
+ return *this;
+      }
+      _Hashtable&
+      operator=(initializer_list<value_type> __l)
+      {
+ __reuse_or_alloc_node_type __roan(_M_begin(), *this);
+ _M_before_begin._M_nxt = nullptr;
+ clear();
+ this->_M_insert_range(__l.begin(), __l.end(), __roan, __unique_keys());
+ return *this;
+      }
+      ~_Hashtable() noexcept;
+      void
+      swap(_Hashtable&)
+      noexcept(__and_<__is_nothrow_swappable<_H1>,
+                   __is_nothrow_swappable<_Equal>>::value);
+      iterator
+      begin() noexcept
+      { return iterator(_M_begin()); }
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(_M_begin()); }
+      iterator
+      end() noexcept
+      { return iterator(nullptr); }
+      const_iterator
+      end() const noexcept
+      { return const_iterator(nullptr); }
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_M_begin()); }
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(nullptr); }
+      size_type
+      size() const noexcept
+      { return _M_element_count; }
+      bool
+      empty() const noexcept
+      { return size() == 0; }
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(this->_M_node_allocator()); }
+      size_type
+      max_size() const noexcept
+      { return __node_alloc_traits::max_size(this->_M_node_allocator()); }
+      key_equal
+      key_eq() const
+      { return this->_M_eq(); }
+      size_type
+      bucket_count() const noexcept
+      { return _M_bucket_count; }
+      size_type
+      max_bucket_count() const noexcept
+      { return max_size(); }
+      size_type
+      bucket_size(size_type __n) const
+      { return std::distance(begin(__n), end(__n)); }
+      size_type
+      bucket(const key_type& __k) const
+      { return _M_bucket_index(__k, this->_M_hash_code(__k)); }
+      local_iterator
+      begin(size_type __n)
+      {
+ return local_iterator(*this, _M_bucket_begin(__n),
+         __n, _M_bucket_count);
+      }
+      local_iterator
+      end(size_type __n)
+      { return local_iterator(*this, nullptr, __n, _M_bucket_count); }
+      const_local_iterator
+      begin(size_type __n) const
+      {
+ return const_local_iterator(*this, _M_bucket_begin(__n),
+        __n, _M_bucket_count);
+      }
+      const_local_iterator
+      end(size_type __n) const
+      { return const_local_iterator(*this, nullptr, __n, _M_bucket_count); }
+      const_local_iterator
+      cbegin(size_type __n) const
+      {
+ return const_local_iterator(*this, _M_bucket_begin(__n),
+        __n, _M_bucket_count);
+      }
+      const_local_iterator
+      cend(size_type __n) const
+      { return const_local_iterator(*this, nullptr, __n, _M_bucket_count); }
+      float
+      load_factor() const noexcept
+      {
+ return static_cast<float>(size()) / static_cast<float>(bucket_count());
+      }
+      const _RehashPolicy&
+      __rehash_policy() const
+      { return _M_rehash_policy; }
+      void
+      __rehash_policy(const _RehashPolicy& __pol)
+      { _M_rehash_policy = __pol; }
+      iterator
+      find(const key_type& __k);
+      const_iterator
+      find(const key_type& __k) const;
+      size_type
+      count(const key_type& __k) const;
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __k);
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __k) const;
+    protected:
+      size_type
+      _M_bucket_index(__node_type* __n) const noexcept
+      { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); }
+      size_type
+      _M_bucket_index(const key_type& __k, __hash_code __c) const
+      { return __hash_code_base::_M_bucket_index(__k, __c, _M_bucket_count); }
+      __node_base*
+      _M_find_before_node(size_type, const key_type&, __hash_code) const;
+      __node_type*
+      _M_find_node(size_type __bkt, const key_type& __key,
+     __hash_code __c) const
+      {
+ __node_base* __before_n = _M_find_before_node(__bkt, __key, __c);
+ if (__before_n)
+   return static_cast<__node_type*>(__before_n->_M_nxt);
+ return nullptr;
+      }
+      void
+      _M_insert_bucket_begin(size_type, __node_type*);
+      void
+      _M_remove_bucket_begin(size_type __bkt, __node_type* __next_n,
+        size_type __next_bkt);
+      __node_base*
+      _M_get_previous_node(size_type __bkt, __node_base* __n);
+      iterator
+      _M_insert_unique_node(size_type __bkt, __hash_code __code,
+       __node_type* __n, size_type __n_elt = 1);
+      iterator
+      _M_insert_multi_node(__node_type* __hint,
+      __hash_code __code, __node_type* __n);
+      template<typename... _Args>
+ std::pair<iterator, bool>
+ _M_emplace(std::true_type, _Args&&... __args);
+      template<typename... _Args>
+ iterator
+ _M_emplace(std::false_type __uk, _Args&&... __args)
+ { return _M_emplace(cend(), __uk, std::forward<_Args>(__args)...); }
+      template<typename... _Args>
+ iterator
+ _M_emplace(const_iterator, std::true_type __uk, _Args&&... __args)
+ { return _M_emplace(__uk, std::forward<_Args>(__args)...).first; }
+      template<typename... _Args>
+ iterator
+ _M_emplace(const_iterator, std::false_type, _Args&&... __args);
+      template<typename _Arg, typename _NodeGenerator>
+ std::pair<iterator, bool>
+ _M_insert(_Arg&&, const _NodeGenerator&, true_type, size_type = 1);
+      template<typename _Arg, typename _NodeGenerator>
+ iterator
+ _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen,
+    false_type __uk)
+ {
+   return _M_insert(cend(), std::forward<_Arg>(__arg), __node_gen,
+      __uk);
+ }
+      template<typename _Arg, typename _NodeGenerator>
+ iterator
+ _M_insert(const_iterator, _Arg&& __arg,
+    const _NodeGenerator& __node_gen, true_type __uk)
+ {
+   return
+     _M_insert(std::forward<_Arg>(__arg), __node_gen, __uk).first;
+ }
+      template<typename _Arg, typename _NodeGenerator>
+ iterator
+ _M_insert(const_iterator, _Arg&&,
+    const _NodeGenerator&, false_type);
+      size_type
+      _M_erase(std::true_type, const key_type&);
+      size_type
+      _M_erase(std::false_type, const key_type&);
+      iterator
+      _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n);
+    public:
+      template<typename... _Args>
+ __ireturn_type
+ emplace(_Args&&... __args)
+ { return _M_emplace(__unique_keys(), std::forward<_Args>(__args)...); }
+      template<typename... _Args>
+ iterator
+ emplace_hint(const_iterator __hint, _Args&&... __args)
+ {
+   return _M_emplace(__hint, __unique_keys(),
+       std::forward<_Args>(__args)...);
+ }
+      iterator
+      erase(const_iterator);
+      iterator
+      erase(iterator __it)
+      { return erase(const_iterator(__it)); }
+      size_type
+      erase(const key_type& __k)
+      { return _M_erase(__unique_keys(), __k); }
+      iterator
+      erase(const_iterator, const_iterator);
+      void
+      clear() noexcept;
+      void rehash(size_type __n);
+      insert_return_type
+      _M_reinsert_node(node_type&& __nh)
+      {
+ insert_return_type __ret;
+ if (__nh.empty())
+   __ret.position = end();
+ else
+   {
+     ;
+     const key_type& __k = __nh._M_key();
+     __hash_code __code = this->_M_hash_code(__k);
+     size_type __bkt = _M_bucket_index(__k, __code);
+     if (__node_type* __n = _M_find_node(__bkt, __k, __code))
+       {
+  __ret.node = std::move(__nh);
+  __ret.position = iterator(__n);
+  __ret.inserted = false;
+       }
+     else
+       {
+  __ret.position
+    = _M_insert_unique_node(__bkt, __code, __nh._M_ptr);
+  __nh._M_ptr = nullptr;
+  __ret.inserted = true;
+       }
+   }
+ return __ret;
+      }
+      iterator
+      _M_reinsert_node_multi(const_iterator __hint, node_type&& __nh)
+      {
+ iterator __ret;
+ if (__nh.empty())
+   __ret = end();
+ else
+   {
+     ;
+     auto __code = this->_M_hash_code(__nh._M_key());
+     auto __node = std::exchange(__nh._M_ptr, nullptr);
+     __ret = _M_insert_multi_node(__hint._M_cur, __code, __node);
+   }
+ return __ret;
+      }
+      node_type
+      extract(const_iterator __pos)
+      {
+ __node_type* __n = __pos._M_cur;
+ size_t __bkt = _M_bucket_index(__n);
+ __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
+ if (__prev_n == _M_buckets[__bkt])
+   _M_remove_bucket_begin(__bkt, __n->_M_next(),
+      __n->_M_nxt ? _M_bucket_index(__n->_M_next()) : 0);
+ else if (__n->_M_nxt)
+   {
+     size_type __next_bkt = _M_bucket_index(__n->_M_next());
+     if (__next_bkt != __bkt)
+       _M_buckets[__next_bkt] = __prev_n;
+   }
+ __prev_n->_M_nxt = __n->_M_nxt;
+ __n->_M_nxt = nullptr;
+ --_M_element_count;
+ return { __n, this->_M_node_allocator() };
+      }
+      node_type
+      extract(const _Key& __k)
+      {
+ node_type __nh;
+ auto __pos = find(__k);
+ if (__pos != end())
+   __nh = extract(const_iterator(__pos));
+ return __nh;
+      }
+      template<typename _Compatible_Hashtable>
+ void
+ _M_merge_unique(_Compatible_Hashtable& __src) noexcept
+ {
+   static_assert(is_same_v<typename _Compatible_Hashtable::node_type,
+       node_type>, "Node types are compatible");
+   ;
+   auto __n_elt = __src.size();
+   for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
+     {
+       auto __pos = __i++;
+       const key_type& __k = this->_M_extract()(__pos._M_cur->_M_v());
+       __hash_code __code = this->_M_hash_code(__k);
+       size_type __bkt = _M_bucket_index(__k, __code);
+       if (_M_find_node(__bkt, __k, __code) == nullptr)
+  {
+    auto __nh = __src.extract(__pos);
+    _M_insert_unique_node(__bkt, __code, __nh._M_ptr, __n_elt);
+    __nh._M_ptr = nullptr;
+    __n_elt = 1;
+  }
+       else if (__n_elt != 1)
+  --__n_elt;
+     }
+ }
+      template<typename _Compatible_Hashtable>
+ void
+ _M_merge_multi(_Compatible_Hashtable& __src) noexcept
+ {
+   static_assert(is_same_v<typename _Compatible_Hashtable::node_type,
+       node_type>, "Node types are compatible");
+   ;
+   this->reserve(size() + __src.size());
+   for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
+     _M_reinsert_node_multi(cend(), __src.extract(__i++));
+ }
+    private:
+      void _M_rehash_aux(size_type __n, std::true_type);
+      void _M_rehash_aux(size_type __n, std::false_type);
+      void _M_rehash(size_type __n, const __rehash_state& __state);
+    };
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_bucket_begin(size_type __bkt) const
+    -> __node_type*
+    {
+      __node_base* __n = _M_buckets[__bkt];
+      return __n ? static_cast<__node_type*>(__n->_M_nxt) : nullptr;
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(size_type __bucket_hint,
+        const _H1& __h1, const _H2& __h2, const _Hash& __h,
+        const _Equal& __eq, const _ExtractKey& __exk,
+        const allocator_type& __a)
+      : _Hashtable(__h1, __h2, __h, __eq, __exk, __a)
+    {
+      auto __bkt = _M_rehash_policy._M_next_bkt(__bucket_hint);
+      if (__bkt > _M_bucket_count)
+ {
+   _M_buckets = _M_allocate_buckets(__bkt);
+   _M_bucket_count = __bkt;
+ }
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _InputIterator>
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _Hashtable(_InputIterator __f, _InputIterator __l,
+   size_type __bucket_hint,
+   const _H1& __h1, const _H2& __h2, const _Hash& __h,
+   const _Equal& __eq, const _ExtractKey& __exk,
+   const allocator_type& __a)
+ : _Hashtable(__h1, __h2, __h, __eq, __exk, __a)
+      {
+ auto __nb_elems = __detail::__distance_fw(__f, __l);
+ auto __bkt_count =
+   _M_rehash_policy._M_next_bkt(
+     std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems),
+       __bucket_hint));
+ if (__bkt_count > _M_bucket_count)
+   {
+     _M_buckets = _M_allocate_buckets(__bkt_count);
+     _M_bucket_count = __bkt_count;
+   }
+ for (; __f != __l; ++__f)
+   this->insert(*__f);
+      }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    operator=(const _Hashtable& __ht)
+    -> _Hashtable&
+    {
+      if (&__ht == this)
+ return *this;
+      if (__node_alloc_traits::_S_propagate_on_copy_assign())
+ {
+   auto& __this_alloc = this->_M_node_allocator();
+   auto& __that_alloc = __ht._M_node_allocator();
+   if (!__node_alloc_traits::_S_always_equal()
+       && __this_alloc != __that_alloc)
+     {
+       this->_M_deallocate_nodes(_M_begin());
+       _M_before_begin._M_nxt = nullptr;
+       _M_deallocate_buckets();
+       _M_buckets = nullptr;
+       std::__alloc_on_copy(__this_alloc, __that_alloc);
+       __hashtable_base::operator=(__ht);
+       _M_bucket_count = __ht._M_bucket_count;
+       _M_element_count = __ht._M_element_count;
+       _M_rehash_policy = __ht._M_rehash_policy;
+       try
+  {
+    _M_assign(__ht,
+       [this](const __node_type* __n)
+       { return this->_M_allocate_node(__n->_M_v()); });
+  }
+       catch(...)
+  {
+    _M_reset();
+    throw;
+  }
+       return *this;
+     }
+   std::__alloc_on_copy(__this_alloc, __that_alloc);
+ }
+      __bucket_type* __former_buckets = nullptr;
+      std::size_t __former_bucket_count = _M_bucket_count;
+      const __rehash_state& __former_state = _M_rehash_policy._M_state();
+      if (_M_bucket_count != __ht._M_bucket_count)
+ {
+   __former_buckets = _M_buckets;
+   _M_buckets = _M_allocate_buckets(__ht._M_bucket_count);
+   _M_bucket_count = __ht._M_bucket_count;
+ }
+      else
+ __builtin_memset(_M_buckets, 0,
+    _M_bucket_count * sizeof(__bucket_type));
+      try
+ {
+   __hashtable_base::operator=(__ht);
+   _M_element_count = __ht._M_element_count;
+   _M_rehash_policy = __ht._M_rehash_policy;
+   __reuse_or_alloc_node_type __roan(_M_begin(), *this);
+   _M_before_begin._M_nxt = nullptr;
+   _M_assign(__ht,
+      [&__roan](const __node_type* __n)
+      { return __roan(__n->_M_v()); });
+   if (__former_buckets)
+     _M_deallocate_buckets(__former_buckets, __former_bucket_count);
+ }
+      catch(...)
+ {
+   if (__former_buckets)
+     {
+       _M_deallocate_buckets();
+       _M_rehash_policy._M_reset(__former_state);
+       _M_buckets = __former_buckets;
+       _M_bucket_count = __former_bucket_count;
+     }
+   __builtin_memset(_M_buckets, 0,
+      _M_bucket_count * sizeof(__bucket_type));
+   throw;
+ }
+      return *this;
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _NodeGenerator>
+      void
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_assign(const _Hashtable& __ht, const _NodeGenerator& __node_gen)
+      {
+ __bucket_type* __buckets = nullptr;
+ if (!_M_buckets)
+   _M_buckets = __buckets = _M_allocate_buckets(_M_bucket_count);
+ try
+   {
+     if (!__ht._M_before_begin._M_nxt)
+       return;
+     __node_type* __ht_n = __ht._M_begin();
+     __node_type* __this_n = __node_gen(__ht_n);
+     this->_M_copy_code(__this_n, __ht_n);
+     _M_before_begin._M_nxt = __this_n;
+     _M_buckets[_M_bucket_index(__this_n)] = &_M_before_begin;
+     __node_base* __prev_n = __this_n;
+     for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next())
+       {
+  __this_n = __node_gen(__ht_n);
+  __prev_n->_M_nxt = __this_n;
+  this->_M_copy_code(__this_n, __ht_n);
+  size_type __bkt = _M_bucket_index(__this_n);
+  if (!_M_buckets[__bkt])
+    _M_buckets[__bkt] = __prev_n;
+  __prev_n = __this_n;
+       }
+   }
+ catch(...)
+   {
+     clear();
+     if (__buckets)
+       _M_deallocate_buckets();
+     throw;
+   }
+      }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_reset() noexcept
+    {
+      _M_rehash_policy._M_reset();
+      _M_bucket_count = 1;
+      _M_single_bucket = nullptr;
+      _M_buckets = &_M_single_bucket;
+      _M_before_begin._M_nxt = nullptr;
+      _M_element_count = 0;
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_move_assign(_Hashtable&& __ht, std::true_type)
+    {
+      this->_M_deallocate_nodes(_M_begin());
+      _M_deallocate_buckets();
+      __hashtable_base::operator=(std::move(__ht));
+      _M_rehash_policy = __ht._M_rehash_policy;
+      if (!__ht._M_uses_single_bucket())
+ _M_buckets = __ht._M_buckets;
+      else
+ {
+   _M_buckets = &_M_single_bucket;
+   _M_single_bucket = __ht._M_single_bucket;
+ }
+      _M_bucket_count = __ht._M_bucket_count;
+      _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;
+      _M_element_count = __ht._M_element_count;
+      std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator());
+      if (_M_begin())
+ _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+      __ht._M_reset();
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_move_assign(_Hashtable&& __ht, std::false_type)
+    {
+      if (__ht._M_node_allocator() == this->_M_node_allocator())
+ _M_move_assign(std::move(__ht), std::true_type());
+      else
+ {
+   __bucket_type* __former_buckets = nullptr;
+   size_type __former_bucket_count = _M_bucket_count;
+   const __rehash_state& __former_state = _M_rehash_policy._M_state();
+   if (_M_bucket_count != __ht._M_bucket_count)
+     {
+       __former_buckets = _M_buckets;
+       _M_buckets = _M_allocate_buckets(__ht._M_bucket_count);
+       _M_bucket_count = __ht._M_bucket_count;
+     }
+   else
+     __builtin_memset(_M_buckets, 0,
+        _M_bucket_count * sizeof(__bucket_type));
+   try
+     {
+       __hashtable_base::operator=(std::move(__ht));
+       _M_element_count = __ht._M_element_count;
+       _M_rehash_policy = __ht._M_rehash_policy;
+       __reuse_or_alloc_node_type __roan(_M_begin(), *this);
+       _M_before_begin._M_nxt = nullptr;
+       _M_assign(__ht,
+   [&__roan](__node_type* __n)
+   { return __roan(std::move_if_noexcept(__n->_M_v())); });
+       if (__former_buckets)
+  _M_deallocate_buckets(__former_buckets, __former_bucket_count);
+       __ht.clear();
+     }
+   catch(...)
+     {
+       if (__former_buckets)
+  {
+    _M_deallocate_buckets();
+    _M_rehash_policy._M_reset(__former_state);
+    _M_buckets = __former_buckets;
+    _M_bucket_count = __former_bucket_count;
+  }
+       __builtin_memset(_M_buckets, 0,
+          _M_bucket_count * sizeof(__bucket_type));
+       throw;
+     }
+ }
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(const _Hashtable& __ht)
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(
+ __node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())),
+      _M_buckets(nullptr),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      _M_assign(__ht,
+  [this](const __node_type* __n)
+  { return this->_M_allocate_node(__n->_M_v()); });
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(_Hashtable&& __ht) noexcept
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(std::move(__ht._M_base_alloc())),
+      _M_buckets(__ht._M_buckets),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_before_begin(__ht._M_before_begin._M_nxt),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      if (__ht._M_uses_single_bucket())
+ {
+   _M_buckets = &_M_single_bucket;
+   _M_single_bucket = __ht._M_single_bucket;
+ }
+      if (_M_begin())
+ _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+      __ht._M_reset();
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(const _Hashtable& __ht, const allocator_type& __a)
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(__node_alloc_type(__a)),
+      _M_buckets(),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      _M_assign(__ht,
+  [this](const __node_type* __n)
+  { return this->_M_allocate_node(__n->_M_v()); });
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(_Hashtable&& __ht, const allocator_type& __a)
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(__node_alloc_type(__a)),
+      _M_buckets(nullptr),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      if (__ht._M_node_allocator() == this->_M_node_allocator())
+ {
+   if (__ht._M_uses_single_bucket())
+     {
+       _M_buckets = &_M_single_bucket;
+       _M_single_bucket = __ht._M_single_bucket;
+     }
+   else
+     _M_buckets = __ht._M_buckets;
+   _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;
+   if (_M_begin())
+     _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+   __ht._M_reset();
+ }
+      else
+ {
+   _M_assign(__ht,
+      [this](__node_type* __n)
+      {
+        return this->_M_allocate_node(
+     std::move_if_noexcept(__n->_M_v()));
+      });
+   __ht.clear();
+ }
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    ~_Hashtable() noexcept
+    {
+      clear();
+      _M_deallocate_buckets();
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    swap(_Hashtable& __x)
+    noexcept(__and_<__is_nothrow_swappable<_H1>,
+                 __is_nothrow_swappable<_Equal>>::value)
+    {
+      this->_M_swap(__x);
+      std::__alloc_on_swap(this->_M_node_allocator(), __x._M_node_allocator());
+      std::swap(_M_rehash_policy, __x._M_rehash_policy);
+      if (this->_M_uses_single_bucket())
+ {
+   if (!__x._M_uses_single_bucket())
+     {
+       _M_buckets = __x._M_buckets;
+       __x._M_buckets = &__x._M_single_bucket;
+     }
+ }
+      else if (__x._M_uses_single_bucket())
+ {
+   __x._M_buckets = _M_buckets;
+   _M_buckets = &_M_single_bucket;
+ }
+      else
+ std::swap(_M_buckets, __x._M_buckets);
+      std::swap(_M_bucket_count, __x._M_bucket_count);
+      std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt);
+      std::swap(_M_element_count, __x._M_element_count);
+      std::swap(_M_single_bucket, __x._M_single_bucket);
+      if (_M_begin())
+ _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+      if (__x._M_begin())
+ __x._M_buckets[__x._M_bucket_index(__x._M_begin())]
+   = &__x._M_before_begin;
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    find(const key_type& __k)
+    -> iterator
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __n = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__n, __k, __code);
+      return __p ? iterator(__p) : end();
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    find(const key_type& __k) const
+    -> const_iterator
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __n = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__n, __k, __code);
+      return __p ? const_iterator(__p) : end();
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    count(const key_type& __k) const
+    -> size_type
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __n = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_bucket_begin(__n);
+      if (!__p)
+ return 0;
+      std::size_t __result = 0;
+      for (;; __p = __p->_M_next())
+ {
+   if (this->_M_equals(__k, __code, __p))
+     ++__result;
+   else if (__result)
+     break;
+   if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __n)
+     break;
+ }
+      return __result;
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    equal_range(const key_type& __k)
+    -> pair<iterator, iterator>
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __n = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__n, __k, __code);
+      if (__p)
+ {
+   __node_type* __p1 = __p->_M_next();
+   while (__p1 && _M_bucket_index(__p1) == __n
+   && this->_M_equals(__k, __code, __p1))
+     __p1 = __p1->_M_next();
+   return std::make_pair(iterator(__p), iterator(__p1));
+ }
+      else
+ return std::make_pair(end(), end());
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    equal_range(const key_type& __k) const
+    -> pair<const_iterator, const_iterator>
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __n = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__n, __k, __code);
+      if (__p)
+ {
+   __node_type* __p1 = __p->_M_next();
+   while (__p1 && _M_bucket_index(__p1) == __n
+   && this->_M_equals(__k, __code, __p1))
+     __p1 = __p1->_M_next();
+   return std::make_pair(const_iterator(__p), const_iterator(__p1));
+ }
+      else
+ return std::make_pair(end(), end());
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_find_before_node(size_type __n, const key_type& __k,
+   __hash_code __code) const
+    -> __node_base*
+    {
+      __node_base* __prev_p = _M_buckets[__n];
+      if (!__prev_p)
+ return nullptr;
+      for (__node_type* __p = static_cast<__node_type*>(__prev_p->_M_nxt);;
+    __p = __p->_M_next())
+ {
+   if (this->_M_equals(__k, __code, __p))
+     return __prev_p;
+   if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __n)
+     break;
+   __prev_p = __p;
+ }
+      return nullptr;
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_insert_bucket_begin(size_type __bkt, __node_type* __node)
+    {
+      if (_M_buckets[__bkt])
+ {
+   __node->_M_nxt = _M_buckets[__bkt]->_M_nxt;
+   _M_buckets[__bkt]->_M_nxt = __node;
+ }
+      else
+ {
+   __node->_M_nxt = _M_before_begin._M_nxt;
+   _M_before_begin._M_nxt = __node;
+   if (__node->_M_nxt)
+     _M_buckets[_M_bucket_index(__node->_M_next())] = __node;
+   _M_buckets[__bkt] = &_M_before_begin;
+ }
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_remove_bucket_begin(size_type __bkt, __node_type* __next,
+      size_type __next_bkt)
+    {
+      if (!__next || __next_bkt != __bkt)
+ {
+   if (__next)
+     _M_buckets[__next_bkt] = _M_buckets[__bkt];
+   if (&_M_before_begin == _M_buckets[__bkt])
+     _M_before_begin._M_nxt = __next;
+   _M_buckets[__bkt] = nullptr;
+ }
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_get_previous_node(size_type __bkt, __node_base* __n)
+    -> __node_base*
+    {
+      __node_base* __prev_n = _M_buckets[__bkt];
+      while (__prev_n->_M_nxt != __n)
+ __prev_n = __prev_n->_M_nxt;
+      return __prev_n;
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename... _Args>
+      auto
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_emplace(std::true_type, _Args&&... __args)
+      -> pair<iterator, bool>
+      {
+ __node_type* __node = this->_M_allocate_node(std::forward<_Args>(__args)...);
+ const key_type& __k = this->_M_extract()(__node->_M_v());
+ __hash_code __code;
+ try
+   {
+     __code = this->_M_hash_code(__k);
+   }
+ catch(...)
+   {
+     this->_M_deallocate_node(__node);
+     throw;
+   }
+ size_type __bkt = _M_bucket_index(__k, __code);
+ if (__node_type* __p = _M_find_node(__bkt, __k, __code))
+   {
+     this->_M_deallocate_node(__node);
+     return std::make_pair(iterator(__p), false);
+   }
+ return std::make_pair(_M_insert_unique_node(__bkt, __code, __node),
+         true);
+      }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename... _Args>
+      auto
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_emplace(const_iterator __hint, std::false_type, _Args&&... __args)
+      -> iterator
+      {
+ __node_type* __node =
+   this->_M_allocate_node(std::forward<_Args>(__args)...);
+ __hash_code __code;
+ try
+   {
+     __code = this->_M_hash_code(this->_M_extract()(__node->_M_v()));
+   }
+ catch(...)
+   {
+     this->_M_deallocate_node(__node);
+     throw;
+   }
+ return _M_insert_multi_node(__hint._M_cur, __code, __node);
+      }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_insert_unique_node(size_type __bkt, __hash_code __code,
+     __node_type* __node, size_type __n_elt)
+    -> iterator
+    {
+      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
+      std::pair<bool, std::size_t> __do_rehash
+ = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count,
+       __n_elt);
+      try
+ {
+   if (__do_rehash.first)
+     {
+       _M_rehash(__do_rehash.second, __saved_state);
+       __bkt = _M_bucket_index(this->_M_extract()(__node->_M_v()), __code);
+     }
+   this->_M_store_code(__node, __code);
+   _M_insert_bucket_begin(__bkt, __node);
+   ++_M_element_count;
+   return iterator(__node);
+ }
+      catch(...)
+ {
+   this->_M_deallocate_node(__node);
+   throw;
+ }
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_insert_multi_node(__node_type* __hint, __hash_code __code,
+    __node_type* __node)
+    -> iterator
+    {
+      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
+      std::pair<bool, std::size_t> __do_rehash
+ = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1);
+      try
+ {
+   if (__do_rehash.first)
+     _M_rehash(__do_rehash.second, __saved_state);
+   this->_M_store_code(__node, __code);
+   const key_type& __k = this->_M_extract()(__node->_M_v());
+   size_type __bkt = _M_bucket_index(__k, __code);
+   __node_base* __prev
+     = __builtin_expect(__hint != nullptr, false)
+       && this->_M_equals(__k, __code, __hint)
+  ? __hint
+  : _M_find_before_node(__bkt, __k, __code);
+   if (__prev)
+     {
+       __node->_M_nxt = __prev->_M_nxt;
+       __prev->_M_nxt = __node;
+       if (__builtin_expect(__prev == __hint, false))
+        if (__node->_M_nxt
+            && !this->_M_equals(__k, __code, __node->_M_next()))
+          {
+            size_type __next_bkt = _M_bucket_index(__node->_M_next());
+            if (__next_bkt != __bkt)
+              _M_buckets[__next_bkt] = __node;
+          }
+     }
+   else
+     _M_insert_bucket_begin(__bkt, __node);
+   ++_M_element_count;
+   return iterator(__node);
+ }
+      catch(...)
+ {
+   this->_M_deallocate_node(__node);
+   throw;
+ }
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _Arg, typename _NodeGenerator>
+      auto
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_insert(_Arg&& __v, const _NodeGenerator& __node_gen, true_type,
+  size_type __n_elt)
+      -> pair<iterator, bool>
+      {
+ const key_type& __k = this->_M_extract()(__v);
+ __hash_code __code = this->_M_hash_code(__k);
+ size_type __bkt = _M_bucket_index(__k, __code);
+ __node_type* __n = _M_find_node(__bkt, __k, __code);
+ if (__n)
+   return std::make_pair(iterator(__n), false);
+ __n = __node_gen(std::forward<_Arg>(__v));
+ return { _M_insert_unique_node(__bkt, __code, __n, __n_elt), true };
+      }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _Arg, typename _NodeGenerator>
+      auto
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_insert(const_iterator __hint, _Arg&& __v,
+  const _NodeGenerator& __node_gen, false_type)
+      -> iterator
+      {
+ __hash_code __code = this->_M_hash_code(this->_M_extract()(__v));
+ __node_type* __node = __node_gen(std::forward<_Arg>(__v));
+ return _M_insert_multi_node(__hint._M_cur, __code, __node);
+      }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    erase(const_iterator __it)
+    -> iterator
+    {
+      __node_type* __n = __it._M_cur;
+      std::size_t __bkt = _M_bucket_index(__n);
+      __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
+      return _M_erase(__bkt, __prev_n, __n);
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n)
+    -> iterator
+    {
+      if (__prev_n == _M_buckets[__bkt])
+ _M_remove_bucket_begin(__bkt, __n->_M_next(),
+    __n->_M_nxt ? _M_bucket_index(__n->_M_next()) : 0);
+      else if (__n->_M_nxt)
+ {
+   size_type __next_bkt = _M_bucket_index(__n->_M_next());
+   if (__next_bkt != __bkt)
+     _M_buckets[__next_bkt] = __prev_n;
+ }
+      __prev_n->_M_nxt = __n->_M_nxt;
+      iterator __result(__n->_M_next());
+      this->_M_deallocate_node(__n);
+      --_M_element_count;
+      return __result;
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_erase(std::true_type, const key_type& __k)
+    -> size_type
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+      __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code);
+      if (!__prev_n)
+ return 0;
+      __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
+      _M_erase(__bkt, __prev_n, __n);
+      return 1;
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_erase(std::false_type, const key_type& __k)
+    -> size_type
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+      __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code);
+      if (!__prev_n)
+ return 0;
+      __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
+      __node_type* __n_last = __n;
+      std::size_t __n_last_bkt = __bkt;
+      do
+ {
+   __n_last = __n_last->_M_next();
+   if (!__n_last)
+     break;
+   __n_last_bkt = _M_bucket_index(__n_last);
+ }
+      while (__n_last_bkt == __bkt && this->_M_equals(__k, __code, __n_last));
+      size_type __result = 0;
+      do
+ {
+   __node_type* __p = __n->_M_next();
+   this->_M_deallocate_node(__n);
+   __n = __p;
+   ++__result;
+   --_M_element_count;
+ }
+      while (__n != __n_last);
+      if (__prev_n == _M_buckets[__bkt])
+ _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt);
+      else if (__n_last && __n_last_bkt != __bkt)
+ _M_buckets[__n_last_bkt] = __prev_n;
+      __prev_n->_M_nxt = __n_last;
+      return __result;
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    erase(const_iterator __first, const_iterator __last)
+    -> iterator
+    {
+      __node_type* __n = __first._M_cur;
+      __node_type* __last_n = __last._M_cur;
+      if (__n == __last_n)
+ return iterator(__n);
+      std::size_t __bkt = _M_bucket_index(__n);
+      __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
+      bool __is_bucket_begin = __n == _M_bucket_begin(__bkt);
+      std::size_t __n_bkt = __bkt;
+      for (;;)
+ {
+   do
+     {
+       __node_type* __tmp = __n;
+       __n = __n->_M_next();
+       this->_M_deallocate_node(__tmp);
+       --_M_element_count;
+       if (!__n)
+  break;
+       __n_bkt = _M_bucket_index(__n);
+     }
+   while (__n != __last_n && __n_bkt == __bkt);
+   if (__is_bucket_begin)
+     _M_remove_bucket_begin(__bkt, __n, __n_bkt);
+   if (__n == __last_n)
+     break;
+   __is_bucket_begin = true;
+   __bkt = __n_bkt;
+ }
+      if (__n && (__n_bkt != __bkt || __is_bucket_begin))
+ _M_buckets[__n_bkt] = __prev_n;
+      __prev_n->_M_nxt = __n;
+      return iterator(__n);
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    clear() noexcept
+    {
+      this->_M_deallocate_nodes(_M_begin());
+      __builtin_memset(_M_buckets, 0, _M_bucket_count * sizeof(__bucket_type));
+      _M_element_count = 0;
+      _M_before_begin._M_nxt = nullptr;
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    rehash(size_type __n)
+    {
+      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
+      std::size_t __buckets
+ = std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1),
+     __n);
+      __buckets = _M_rehash_policy._M_next_bkt(__buckets);
+      if (__buckets != _M_bucket_count)
+ _M_rehash(__buckets, __saved_state);
+      else
+ _M_rehash_policy._M_reset(__saved_state);
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_rehash(size_type __n, const __rehash_state& __state)
+    {
+      try
+ {
+   _M_rehash_aux(__n, __unique_keys());
+ }
+      catch(...)
+ {
+   _M_rehash_policy._M_reset(__state);
+   throw;
+ }
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_rehash_aux(size_type __n, std::true_type)
+    {
+      __bucket_type* __new_buckets = _M_allocate_buckets(__n);
+      __node_type* __p = _M_begin();
+      _M_before_begin._M_nxt = nullptr;
+      std::size_t __bbegin_bkt = 0;
+      while (__p)
+ {
+   __node_type* __next = __p->_M_next();
+   std::size_t __bkt = __hash_code_base::_M_bucket_index(__p, __n);
+   if (!__new_buckets[__bkt])
+     {
+       __p->_M_nxt = _M_before_begin._M_nxt;
+       _M_before_begin._M_nxt = __p;
+       __new_buckets[__bkt] = &_M_before_begin;
+       if (__p->_M_nxt)
+  __new_buckets[__bbegin_bkt] = __p;
+       __bbegin_bkt = __bkt;
+     }
+   else
+     {
+       __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
+       __new_buckets[__bkt]->_M_nxt = __p;
+     }
+   __p = __next;
+ }
+      _M_deallocate_buckets();
+      _M_bucket_count = __n;
+      _M_buckets = __new_buckets;
+    }
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_rehash_aux(size_type __n, std::false_type)
+    {
+      __bucket_type* __new_buckets = _M_allocate_buckets(__n);
+      __node_type* __p = _M_begin();
+      _M_before_begin._M_nxt = nullptr;
+      std::size_t __bbegin_bkt = 0;
+      std::size_t __prev_bkt = 0;
+      __node_type* __prev_p = nullptr;
+      bool __check_bucket = false;
+      while (__p)
+ {
+   __node_type* __next = __p->_M_next();
+   std::size_t __bkt = __hash_code_base::_M_bucket_index(__p, __n);
+   if (__prev_p && __prev_bkt == __bkt)
+     {
+       __p->_M_nxt = __prev_p->_M_nxt;
+       __prev_p->_M_nxt = __p;
+       __check_bucket = true;
+     }
+   else
+     {
+       if (__check_bucket)
+  {
+    if (__prev_p->_M_nxt)
+      {
+        std::size_t __next_bkt
+   = __hash_code_base::_M_bucket_index(__prev_p->_M_next(),
+           __n);
+        if (__next_bkt != __prev_bkt)
+   __new_buckets[__next_bkt] = __prev_p;
+      }
+    __check_bucket = false;
+  }
+       if (!__new_buckets[__bkt])
+  {
+    __p->_M_nxt = _M_before_begin._M_nxt;
+    _M_before_begin._M_nxt = __p;
+    __new_buckets[__bkt] = &_M_before_begin;
+    if (__p->_M_nxt)
+      __new_buckets[__bbegin_bkt] = __p;
+    __bbegin_bkt = __bkt;
+  }
+       else
+  {
+    __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
+    __new_buckets[__bkt]->_M_nxt = __p;
+  }
+     }
+   __prev_p = __p;
+   __prev_bkt = __bkt;
+   __p = __next;
+ }
+      if (__check_bucket && __prev_p->_M_nxt)
+ {
+   std::size_t __next_bkt
+     = __hash_code_base::_M_bucket_index(__prev_p->_M_next(), __n);
+   if (__next_bkt != __prev_bkt)
+     __new_buckets[__next_bkt] = __prev_p;
+ }
+      _M_deallocate_buckets();
+      _M_bucket_count = __n;
+      _M_buckets = __new_buckets;
+    }
+  template<typename, typename, typename> class _Hash_merge_helper { };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<bool _Cache>
+    using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>;
+  template<typename _Key,
+    typename _Tp,
+    typename _Hash = hash<_Key>,
+    typename _Pred = std::equal_to<_Key>,
+    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+    typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>>
+    using __umap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
+                                        _Alloc, __detail::_Select1st,
+            _Pred, _Hash,
+            __detail::_Mod_range_hashing,
+            __detail::_Default_ranged_hash,
+            __detail::_Prime_rehash_policy, _Tr>;
+  template<bool _Cache>
+    using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>;
+  template<typename _Key,
+    typename _Tp,
+    typename _Hash = hash<_Key>,
+    typename _Pred = std::equal_to<_Key>,
+    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+    typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>>
+    using __ummap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
+      _Alloc, __detail::_Select1st,
+      _Pred, _Hash,
+      __detail::_Mod_range_hashing,
+      __detail::_Default_ranged_hash,
+      __detail::_Prime_rehash_policy, _Tr>;
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    class unordered_multimap;
+  template<typename _Key, typename _Tp,
+    typename _Hash = hash<_Key>,
+    typename _Pred = equal_to<_Key>,
+    typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
+    class unordered_map
+    {
+      typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
+      _Hashtable _M_h;
+    public:
+      typedef typename _Hashtable::key_type key_type;
+      typedef typename _Hashtable::value_type value_type;
+      typedef typename _Hashtable::mapped_type mapped_type;
+      typedef typename _Hashtable::hasher hasher;
+      typedef typename _Hashtable::key_equal key_equal;
+      typedef typename _Hashtable::allocator_type allocator_type;
+      typedef typename _Hashtable::pointer pointer;
+      typedef typename _Hashtable::const_pointer const_pointer;
+      typedef typename _Hashtable::reference reference;
+      typedef typename _Hashtable::const_reference const_reference;
+      typedef typename _Hashtable::iterator iterator;
+      typedef typename _Hashtable::const_iterator const_iterator;
+      typedef typename _Hashtable::local_iterator local_iterator;
+      typedef typename _Hashtable::const_local_iterator const_local_iterator;
+      typedef typename _Hashtable::size_type size_type;
+      typedef typename _Hashtable::difference_type difference_type;
+      using node_type = typename _Hashtable::node_type;
+      using insert_return_type = typename _Hashtable::insert_return_type;
+      unordered_map() = default;
+      explicit
+      unordered_map(size_type __n,
+      const hasher& __hf = hasher(),
+      const key_equal& __eql = key_equal(),
+      const allocator_type& __a = allocator_type())
+      : _M_h(__n, __hf, __eql, __a)
+      { }
+      template<typename _InputIterator>
+ unordered_map(_InputIterator __first, _InputIterator __last,
+        size_type __n = 0,
+        const hasher& __hf = hasher(),
+        const key_equal& __eql = key_equal(),
+        const allocator_type& __a = allocator_type())
+ : _M_h(__first, __last, __n, __hf, __eql, __a)
+ { }
+      unordered_map(const unordered_map&) = default;
+      unordered_map(unordered_map&&) = default;
+      explicit
+      unordered_map(const allocator_type& __a)
+ : _M_h(__a)
+      { }
+      unordered_map(const unordered_map& __umap,
+      const allocator_type& __a)
+      : _M_h(__umap._M_h, __a)
+      { }
+      unordered_map(unordered_map&& __umap,
+      const allocator_type& __a)
+      : _M_h(std::move(__umap._M_h), __a)
+      { }
+      unordered_map(initializer_list<value_type> __l,
+      size_type __n = 0,
+      const hasher& __hf = hasher(),
+      const key_equal& __eql = key_equal(),
+      const allocator_type& __a = allocator_type())
+      : _M_h(__l, __n, __hf, __eql, __a)
+      { }
+      unordered_map(size_type __n, const allocator_type& __a)
+      : unordered_map(__n, hasher(), key_equal(), __a)
+      { }
+      unordered_map(size_type __n, const hasher& __hf,
+      const allocator_type& __a)
+      : unordered_map(__n, __hf, key_equal(), __a)
+      { }
+      template<typename _InputIterator>
+ unordered_map(_InputIterator __first, _InputIterator __last,
+        size_type __n,
+        const allocator_type& __a)
+ : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
+ { }
+      template<typename _InputIterator>
+ unordered_map(_InputIterator __first, _InputIterator __last,
+        size_type __n, const hasher& __hf,
+        const allocator_type& __a)
+   : unordered_map(__first, __last, __n, __hf, key_equal(), __a)
+ { }
+      unordered_map(initializer_list<value_type> __l,
+      size_type __n,
+      const allocator_type& __a)
+      : unordered_map(__l, __n, hasher(), key_equal(), __a)
+      { }
+      unordered_map(initializer_list<value_type> __l,
+      size_type __n, const hasher& __hf,
+      const allocator_type& __a)
+      : unordered_map(__l, __n, __hf, key_equal(), __a)
+      { }
+      unordered_map&
+      operator=(const unordered_map&) = default;
+      unordered_map&
+      operator=(unordered_map&&) = default;
+      unordered_map&
+      operator=(initializer_list<value_type> __l)
+      {
+ _M_h = __l;
+ return *this;
+      }
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_h.get_allocator(); }
+      bool
+      empty() const noexcept
+      { return _M_h.empty(); }
+      size_type
+      size() const noexcept
+      { return _M_h.size(); }
+      size_type
+      max_size() const noexcept
+      { return _M_h.max_size(); }
+      iterator
+      begin() noexcept
+      { return _M_h.begin(); }
+      const_iterator
+      begin() const noexcept
+      { return _M_h.begin(); }
+      const_iterator
+      cbegin() const noexcept
+      { return _M_h.begin(); }
+      iterator
+      end() noexcept
+      { return _M_h.end(); }
+      const_iterator
+      end() const noexcept
+      { return _M_h.end(); }
+      const_iterator
+      cend() const noexcept
+      { return _M_h.end(); }
+      template<typename... _Args>
+ std::pair<iterator, bool>
+ emplace(_Args&&... __args)
+ { return _M_h.emplace(std::forward<_Args>(__args)...); }
+      template<typename... _Args>
+ iterator
+ emplace_hint(const_iterator __pos, _Args&&... __args)
+ { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
+      node_type
+      extract(const_iterator __pos)
+      {
+ ;
+ return _M_h.extract(__pos);
+      }
+      node_type
+      extract(const key_type& __key)
+      { return _M_h.extract(__key); }
+      insert_return_type
+      insert(node_type&& __nh)
+      { return _M_h._M_reinsert_node(std::move(__nh)); }
+      iterator
+      insert(const_iterator, node_type&& __nh)
+      { return _M_h._M_reinsert_node(std::move(__nh)).position; }
+      template <typename... _Args>
+        pair<iterator, bool>
+        try_emplace(const key_type& __k, _Args&&... __args)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            {
+              __i = emplace(std::piecewise_construct,
+                            std::forward_as_tuple(__k),
+                            std::forward_as_tuple(
+                              std::forward<_Args>(__args)...))
+                .first;
+              return {__i, true};
+            }
+          return {__i, false};
+        }
+      template <typename... _Args>
+        pair<iterator, bool>
+        try_emplace(key_type&& __k, _Args&&... __args)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            {
+              __i = emplace(std::piecewise_construct,
+                            std::forward_as_tuple(std::move(__k)),
+                            std::forward_as_tuple(
+                              std::forward<_Args>(__args)...))
+                .first;
+              return {__i, true};
+            }
+          return {__i, false};
+        }
+      template <typename... _Args>
+        iterator
+        try_emplace(const_iterator __hint, const key_type& __k,
+                    _Args&&... __args)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            __i = emplace_hint(__hint, std::piecewise_construct,
+                               std::forward_as_tuple(__k),
+                               std::forward_as_tuple(
+                                 std::forward<_Args>(__args)...));
+          return __i;
+        }
+      template <typename... _Args>
+        iterator
+        try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            __i = emplace_hint(__hint, std::piecewise_construct,
+                               std::forward_as_tuple(std::move(__k)),
+                               std::forward_as_tuple(
+                                 std::forward<_Args>(__args)...));
+          return __i;
+        }
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      { return _M_h.insert(__x); }
+      std::pair<iterator, bool>
+      insert(value_type&& __x)
+      { return _M_h.insert(std::move(__x)); }
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value,
+        pair<iterator, bool>>
+ insert(_Pair&& __x)
+        { return _M_h.emplace(std::forward<_Pair>(__x)); }
+      iterator
+      insert(const_iterator __hint, const value_type& __x)
+      { return _M_h.insert(__hint, __x); }
+      iterator
+      insert(const_iterator __hint, value_type&& __x)
+      { return _M_h.insert(__hint, std::move(__x)); }
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
+ insert(const_iterator __hint, _Pair&& __x)
+ { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); }
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_h.insert(__first, __last); }
+      void
+      insert(initializer_list<value_type> __l)
+      { _M_h.insert(__l); }
+      template <typename _Obj>
+        pair<iterator, bool>
+        insert_or_assign(const key_type& __k, _Obj&& __obj)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            {
+              __i = emplace(std::piecewise_construct,
+                            std::forward_as_tuple(__k),
+                            std::forward_as_tuple(std::forward<_Obj>(__obj)))
+                .first;
+              return {__i, true};
+            }
+          (*__i).second = std::forward<_Obj>(__obj);
+          return {__i, false};
+        }
+      template <typename _Obj>
+        pair<iterator, bool>
+        insert_or_assign(key_type&& __k, _Obj&& __obj)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            {
+              __i = emplace(std::piecewise_construct,
+                            std::forward_as_tuple(std::move(__k)),
+                            std::forward_as_tuple(std::forward<_Obj>(__obj)))
+                .first;
+              return {__i, true};
+            }
+          (*__i).second = std::forward<_Obj>(__obj);
+          return {__i, false};
+        }
+      template <typename _Obj>
+        iterator
+        insert_or_assign(const_iterator __hint, const key_type& __k,
+                         _Obj&& __obj)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            {
+              return emplace_hint(__hint, std::piecewise_construct,
+                                  std::forward_as_tuple(__k),
+                                  std::forward_as_tuple(
+                                    std::forward<_Obj>(__obj)));
+            }
+          (*__i).second = std::forward<_Obj>(__obj);
+          return __i;
+        }
+      template <typename _Obj>
+        iterator
+        insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj)
+        {
+          iterator __i = find(__k);
+          if (__i == end())
+            {
+              return emplace_hint(__hint, std::piecewise_construct,
+                                  std::forward_as_tuple(std::move(__k)),
+                                  std::forward_as_tuple(
+                                    std::forward<_Obj>(__obj)));
+            }
+          (*__i).second = std::forward<_Obj>(__obj);
+          return __i;
+        }
+      iterator
+      erase(const_iterator __position)
+      { return _M_h.erase(__position); }
+      iterator
+      erase(iterator __position)
+      { return _M_h.erase(__position); }
+      size_type
+      erase(const key_type& __x)
+      { return _M_h.erase(__x); }
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_h.erase(__first, __last); }
+      void
+      clear() noexcept
+      { _M_h.clear(); }
+      void
+      swap(unordered_map& __x)
+      noexcept( noexcept(_M_h.swap(__x._M_h)) )
+      { _M_h.swap(__x._M_h); }
+      template<typename, typename, typename>
+ friend class std::_Hash_merge_helper;
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source)
+ {
+   using _Merge_helper = _Hash_merge_helper<unordered_map, _H2, _P2>;
+   _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source));
+ }
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
+ { merge(__source); }
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source)
+ {
+   using _Merge_helper = _Hash_merge_helper<unordered_map, _H2, _P2>;
+   _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source));
+ }
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
+ { merge(__source); }
+      hasher
+      hash_function() const
+      { return _M_h.hash_function(); }
+      key_equal
+      key_eq() const
+      { return _M_h.key_eq(); }
+      iterator
+      find(const key_type& __x)
+      { return _M_h.find(__x); }
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_h.find(__x); }
+      size_type
+      count(const key_type& __x) const
+      { return _M_h.count(__x); }
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_h.equal_range(__x); }
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_h.equal_range(__x); }
+      mapped_type&
+      operator[](const key_type& __k)
+      { return _M_h[__k]; }
+      mapped_type&
+      operator[](key_type&& __k)
+      { return _M_h[std::move(__k)]; }
+      mapped_type&
+      at(const key_type& __k)
+      { return _M_h.at(__k); }
+      const mapped_type&
+      at(const key_type& __k) const
+      { return _M_h.at(__k); }
+      size_type
+      bucket_count() const noexcept
+      { return _M_h.bucket_count(); }
+      size_type
+      max_bucket_count() const noexcept
+      { return _M_h.max_bucket_count(); }
+      size_type
+      bucket_size(size_type __n) const
+      { return _M_h.bucket_size(__n); }
+      size_type
+      bucket(const key_type& __key) const
+      { return _M_h.bucket(__key); }
+      local_iterator
+      begin(size_type __n)
+      { return _M_h.begin(__n); }
+      const_local_iterator
+      begin(size_type __n) const
+      { return _M_h.begin(__n); }
+      const_local_iterator
+      cbegin(size_type __n) const
+      { return _M_h.cbegin(__n); }
+      local_iterator
+      end(size_type __n)
+      { return _M_h.end(__n); }
+      const_local_iterator
+      end(size_type __n) const
+      { return _M_h.end(__n); }
+      const_local_iterator
+      cend(size_type __n) const
+      { return _M_h.cend(__n); }
+      float
+      load_factor() const noexcept
+      { return _M_h.load_factor(); }
+      float
+      max_load_factor() const noexcept
+      { return _M_h.max_load_factor(); }
+      void
+      max_load_factor(float __z)
+      { _M_h.max_load_factor(__z); }
+      void
+      rehash(size_type __n)
+      { _M_h.rehash(__n); }
+      void
+      reserve(size_type __n)
+      { _M_h.reserve(__n); }
+      template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,
+        typename _Alloc1>
+        friend bool
+ operator==(const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&,
+     const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&);
+    };
+  template<typename _InputIterator,
+    typename _Hash = hash<__iter_key_t<_InputIterator>>,
+    typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
+    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(_InputIterator, _InputIterator,
+    typename unordered_map<int, int>::size_type = {},
+    _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+    -> unordered_map<__iter_key_t<_InputIterator>,
+       __iter_val_t<_InputIterator>,
+       _Hash, _Pred, _Allocator>;
+  template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
+    typename _Pred = equal_to<_Key>,
+    typename _Allocator = allocator<pair<const _Key, _Tp>>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(initializer_list<pair<_Key, _Tp>>,
+    typename unordered_map<int, int>::size_type = {},
+    _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
+    -> unordered_map<_Key, _Tp, _Hash, _Pred, _Allocator>;
+  template<typename _InputIterator, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(_InputIterator, _InputIterator,
+    typename unordered_map<int, int>::size_type, _Allocator)
+    -> unordered_map<__iter_key_t<_InputIterator>,
+       __iter_val_t<_InputIterator>,
+       hash<__iter_key_t<_InputIterator>>,
+       equal_to<__iter_key_t<_InputIterator>>,
+       _Allocator>;
+  template<typename _InputIterator, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(_InputIterator, _InputIterator, _Allocator)
+    -> unordered_map<__iter_key_t<_InputIterator>,
+       __iter_val_t<_InputIterator>,
+       hash<__iter_key_t<_InputIterator>>,
+       equal_to<__iter_key_t<_InputIterator>>,
+       _Allocator>;
+  template<typename _InputIterator, typename _Hash, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(_InputIterator, _InputIterator,
+    typename unordered_map<int, int>::size_type,
+    _Hash, _Allocator)
+    -> unordered_map<__iter_key_t<_InputIterator>,
+       __iter_val_t<_InputIterator>, _Hash,
+       equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+  template<typename _Key, typename _Tp, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(initializer_list<pair<_Key, _Tp>>,
+    typename unordered_map<int, int>::size_type,
+    _Allocator)
+    -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+  template<typename _Key, typename _Tp, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(initializer_list<pair<_Key, _Tp>>, _Allocator)
+    -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+  template<typename _Key, typename _Tp, typename _Hash, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_map(initializer_list<pair<_Key, _Tp>>,
+    typename unordered_map<int, int>::size_type,
+    _Hash, _Allocator)
+    -> unordered_map<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;
+  template<typename _Key, typename _Tp,
+    typename _Hash = hash<_Key>,
+    typename _Pred = equal_to<_Key>,
+    typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
+    class unordered_multimap
+    {
+      typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
+      _Hashtable _M_h;
+    public:
+      typedef typename _Hashtable::key_type key_type;
+      typedef typename _Hashtable::value_type value_type;
+      typedef typename _Hashtable::mapped_type mapped_type;
+      typedef typename _Hashtable::hasher hasher;
+      typedef typename _Hashtable::key_equal key_equal;
+      typedef typename _Hashtable::allocator_type allocator_type;
+      typedef typename _Hashtable::pointer pointer;
+      typedef typename _Hashtable::const_pointer const_pointer;
+      typedef typename _Hashtable::reference reference;
+      typedef typename _Hashtable::const_reference const_reference;
+      typedef typename _Hashtable::iterator iterator;
+      typedef typename _Hashtable::const_iterator const_iterator;
+      typedef typename _Hashtable::local_iterator local_iterator;
+      typedef typename _Hashtable::const_local_iterator const_local_iterator;
+      typedef typename _Hashtable::size_type size_type;
+      typedef typename _Hashtable::difference_type difference_type;
+      using node_type = typename _Hashtable::node_type;
+      unordered_multimap() = default;
+      explicit
+      unordered_multimap(size_type __n,
+    const hasher& __hf = hasher(),
+    const key_equal& __eql = key_equal(),
+    const allocator_type& __a = allocator_type())
+      : _M_h(__n, __hf, __eql, __a)
+      { }
+      template<typename _InputIterator>
+ unordered_multimap(_InputIterator __first, _InputIterator __last,
+      size_type __n = 0,
+      const hasher& __hf = hasher(),
+      const key_equal& __eql = key_equal(),
+      const allocator_type& __a = allocator_type())
+ : _M_h(__first, __last, __n, __hf, __eql, __a)
+ { }
+      unordered_multimap(const unordered_multimap&) = default;
+      unordered_multimap(unordered_multimap&&) = default;
+      explicit
+      unordered_multimap(const allocator_type& __a)
+      : _M_h(__a)
+      { }
+      unordered_multimap(const unordered_multimap& __ummap,
+    const allocator_type& __a)
+      : _M_h(__ummap._M_h, __a)
+      { }
+      unordered_multimap(unordered_multimap&& __ummap,
+    const allocator_type& __a)
+      : _M_h(std::move(__ummap._M_h), __a)
+      { }
+      unordered_multimap(initializer_list<value_type> __l,
+    size_type __n = 0,
+    const hasher& __hf = hasher(),
+    const key_equal& __eql = key_equal(),
+    const allocator_type& __a = allocator_type())
+      : _M_h(__l, __n, __hf, __eql, __a)
+      { }
+      unordered_multimap(size_type __n, const allocator_type& __a)
+      : unordered_multimap(__n, hasher(), key_equal(), __a)
+      { }
+      unordered_multimap(size_type __n, const hasher& __hf,
+    const allocator_type& __a)
+      : unordered_multimap(__n, __hf, key_equal(), __a)
+      { }
+      template<typename _InputIterator>
+ unordered_multimap(_InputIterator __first, _InputIterator __last,
+      size_type __n,
+      const allocator_type& __a)
+ : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a)
+ { }
+      template<typename _InputIterator>
+ unordered_multimap(_InputIterator __first, _InputIterator __last,
+      size_type __n, const hasher& __hf,
+      const allocator_type& __a)
+ : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)
+ { }
+      unordered_multimap(initializer_list<value_type> __l,
+    size_type __n,
+    const allocator_type& __a)
+      : unordered_multimap(__l, __n, hasher(), key_equal(), __a)
+      { }
+      unordered_multimap(initializer_list<value_type> __l,
+    size_type __n, const hasher& __hf,
+    const allocator_type& __a)
+      : unordered_multimap(__l, __n, __hf, key_equal(), __a)
+      { }
+      unordered_multimap&
+      operator=(const unordered_multimap&) = default;
+      unordered_multimap&
+      operator=(unordered_multimap&&) = default;
+      unordered_multimap&
+      operator=(initializer_list<value_type> __l)
+      {
+ _M_h = __l;
+ return *this;
+      }
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_h.get_allocator(); }
+      bool
+      empty() const noexcept
+      { return _M_h.empty(); }
+      size_type
+      size() const noexcept
+      { return _M_h.size(); }
+      size_type
+      max_size() const noexcept
+      { return _M_h.max_size(); }
+      iterator
+      begin() noexcept
+      { return _M_h.begin(); }
+      const_iterator
+      begin() const noexcept
+      { return _M_h.begin(); }
+      const_iterator
+      cbegin() const noexcept
+      { return _M_h.begin(); }
+      iterator
+      end() noexcept
+      { return _M_h.end(); }
+      const_iterator
+      end() const noexcept
+      { return _M_h.end(); }
+      const_iterator
+      cend() const noexcept
+      { return _M_h.end(); }
+      template<typename... _Args>
+ iterator
+ emplace(_Args&&... __args)
+ { return _M_h.emplace(std::forward<_Args>(__args)...); }
+      template<typename... _Args>
+ iterator
+ emplace_hint(const_iterator __pos, _Args&&... __args)
+ { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
+      iterator
+      insert(const value_type& __x)
+      { return _M_h.insert(__x); }
+      iterator
+      insert(value_type&& __x)
+      { return _M_h.insert(std::move(__x)); }
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
+ insert(_Pair&& __x)
+        { return _M_h.emplace(std::forward<_Pair>(__x)); }
+      iterator
+      insert(const_iterator __hint, const value_type& __x)
+      { return _M_h.insert(__hint, __x); }
+      iterator
+      insert(const_iterator __hint, value_type&& __x)
+      { return _M_h.insert(__hint, std::move(__x)); }
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
+ insert(const_iterator __hint, _Pair&& __x)
+        { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); }
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_h.insert(__first, __last); }
+      void
+      insert(initializer_list<value_type> __l)
+      { _M_h.insert(__l); }
+      node_type
+      extract(const_iterator __pos)
+      {
+ ;
+ return _M_h.extract(__pos);
+      }
+      node_type
+      extract(const key_type& __key)
+      { return _M_h.extract(__key); }
+      iterator
+      insert(node_type&& __nh)
+      { return _M_h._M_reinsert_node_multi(cend(), std::move(__nh)); }
+      iterator
+      insert(const_iterator __hint, node_type&& __nh)
+      { return _M_h._M_reinsert_node_multi(__hint, std::move(__nh)); }
+      iterator
+      erase(const_iterator __position)
+      { return _M_h.erase(__position); }
+      iterator
+      erase(iterator __position)
+      { return _M_h.erase(__position); }
+      size_type
+      erase(const key_type& __x)
+      { return _M_h.erase(__x); }
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_h.erase(__first, __last); }
+      void
+      clear() noexcept
+      { _M_h.clear(); }
+      void
+      swap(unordered_multimap& __x)
+      noexcept( noexcept(_M_h.swap(__x._M_h)) )
+      { _M_h.swap(__x._M_h); }
+      template<typename, typename, typename>
+ friend class std::_Hash_merge_helper;
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source)
+ {
+   using _Merge_helper
+     = _Hash_merge_helper<unordered_multimap, _H2, _P2>;
+   _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source));
+ }
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
+ { merge(__source); }
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source)
+ {
+   using _Merge_helper
+     = _Hash_merge_helper<unordered_multimap, _H2, _P2>;
+   _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source));
+ }
+      template<typename _H2, typename _P2>
+ void
+ merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
+ { merge(__source); }
+      hasher
+      hash_function() const
+      { return _M_h.hash_function(); }
+      key_equal
+      key_eq() const
+      { return _M_h.key_eq(); }
+      iterator
+      find(const key_type& __x)
+      { return _M_h.find(__x); }
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_h.find(__x); }
+      size_type
+      count(const key_type& __x) const
+      { return _M_h.count(__x); }
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_h.equal_range(__x); }
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_h.equal_range(__x); }
+      size_type
+      bucket_count() const noexcept
+      { return _M_h.bucket_count(); }
+      size_type
+      max_bucket_count() const noexcept
+      { return _M_h.max_bucket_count(); }
+      size_type
+      bucket_size(size_type __n) const
+      { return _M_h.bucket_size(__n); }
+      size_type
+      bucket(const key_type& __key) const
+      { return _M_h.bucket(__key); }
+      local_iterator
+      begin(size_type __n)
+      { return _M_h.begin(__n); }
+      const_local_iterator
+      begin(size_type __n) const
+      { return _M_h.begin(__n); }
+      const_local_iterator
+      cbegin(size_type __n) const
+      { return _M_h.cbegin(__n); }
+      local_iterator
+      end(size_type __n)
+      { return _M_h.end(__n); }
+      const_local_iterator
+      end(size_type __n) const
+      { return _M_h.end(__n); }
+      const_local_iterator
+      cend(size_type __n) const
+      { return _M_h.cend(__n); }
+      float
+      load_factor() const noexcept
+      { return _M_h.load_factor(); }
+      float
+      max_load_factor() const noexcept
+      { return _M_h.max_load_factor(); }
+      void
+      max_load_factor(float __z)
+      { _M_h.max_load_factor(__z); }
+      void
+      rehash(size_type __n)
+      { _M_h.rehash(__n); }
+      void
+      reserve(size_type __n)
+      { _M_h.reserve(__n); }
+      template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,
+        typename _Alloc1>
+        friend bool
+ operator==(const unordered_multimap<_Key1, _Tp1,
+         _Hash1, _Pred1, _Alloc1>&,
+     const unordered_multimap<_Key1, _Tp1,
+         _Hash1, _Pred1, _Alloc1>&);
+    };
+  template<typename _InputIterator,
+    typename _Hash = hash<__iter_key_t<_InputIterator>>,
+    typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
+    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(_InputIterator, _InputIterator,
+         unordered_multimap<int, int>::size_type = {},
+         _Hash = _Hash(), _Pred = _Pred(),
+         _Allocator = _Allocator())
+    -> unordered_multimap<__iter_key_t<_InputIterator>,
+     __iter_val_t<_InputIterator>, _Hash, _Pred,
+     _Allocator>;
+  template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
+    typename _Pred = equal_to<_Key>,
+    typename _Allocator = allocator<pair<const _Key, _Tp>>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(initializer_list<pair<_Key, _Tp>>,
+         unordered_multimap<int, int>::size_type = {},
+         _Hash = _Hash(), _Pred = _Pred(),
+         _Allocator = _Allocator())
+    -> unordered_multimap<_Key, _Tp, _Hash, _Pred, _Allocator>;
+  template<typename _InputIterator, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(_InputIterator, _InputIterator,
+         unordered_multimap<int, int>::size_type, _Allocator)
+    -> unordered_multimap<__iter_key_t<_InputIterator>,
+     __iter_val_t<_InputIterator>,
+     hash<__iter_key_t<_InputIterator>>,
+     equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+  template<typename _InputIterator, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(_InputIterator, _InputIterator, _Allocator)
+    -> unordered_multimap<__iter_key_t<_InputIterator>,
+     __iter_val_t<_InputIterator>,
+     hash<__iter_key_t<_InputIterator>>,
+     equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+  template<typename _InputIterator, typename _Hash, typename _Allocator,
+    typename = _RequireInputIter<_InputIterator>,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(_InputIterator, _InputIterator,
+         unordered_multimap<int, int>::size_type, _Hash,
+         _Allocator)
+    -> unordered_multimap<__iter_key_t<_InputIterator>,
+     __iter_val_t<_InputIterator>, _Hash,
+     equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
+  template<typename _Key, typename _Tp, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(initializer_list<pair<_Key, _Tp>>,
+         unordered_multimap<int, int>::size_type,
+         _Allocator)
+    -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+  template<typename _Key, typename _Tp, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
+    -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;
+  template<typename _Key, typename _Tp, typename _Hash, typename _Allocator,
+    typename = _RequireAllocator<_Allocator>>
+    unordered_multimap(initializer_list<pair<_Key, _Tp>>,
+         unordered_multimap<int, int>::size_type,
+         _Hash, _Allocator)
+    -> unordered_multimap<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+  unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+  unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+        const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_h._M_equal(__y._M_h); }
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+        const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+        const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_h._M_equal(__y._M_h); }
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+        const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  template<typename _Key, typename _Val, typename _Hash1, typename _Eq1,
+    typename _Alloc, typename _Hash2, typename _Eq2>
+    struct _Hash_merge_helper<
+      std::unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>,
+      _Hash2, _Eq2>
+    {
+    private:
+      template<typename... _Tp>
+ using unordered_map = std::unordered_map<_Tp...>;
+      template<typename... _Tp>
+ using unordered_multimap = std::unordered_multimap<_Tp...>;
+      friend unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>;
+      static auto&
+      _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
+      { return __map._M_h; }
+      static auto&
+      _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
+      { return __map._M_h; }
+    };
+  template<typename _Key, typename _Val, typename _Hash1, typename _Eq1,
+    typename _Alloc, typename _Hash2, typename _Eq2>
+    struct _Hash_merge_helper<
+      std::unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>,
+      _Hash2, _Eq2>
+    {
+    private:
+      template<typename... _Tp>
+ using unordered_map = std::unordered_map<_Tp...>;
+      template<typename... _Tp>
+ using unordered_multimap = std::unordered_multimap<_Tp...>;
+      friend unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>;
+      static auto&
+      _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
+      { return __map._M_h; }
+      static auto&
+      _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
+      { return __map._M_h; }
+    };
+
+}
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+  template<typename _Callable, typename... _Args>
+    inline invoke_result_t<_Callable, _Args...>
+    invoke(_Callable&& __fn, _Args&&... __args)
+    noexcept(is_nothrow_invocable_v<_Callable, _Args...>)
+    {
+      return std::__invoke(std::forward<_Callable>(__fn),
+      std::forward<_Args>(__args)...);
+    }
+  template<typename _MemFunPtr,
+    bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
+    class _Mem_fn_base
+    : public _Mem_fn_traits<_MemFunPtr>::__maybe_type
+    {
+      using _Traits = _Mem_fn_traits<_MemFunPtr>;
+      using _Arity = typename _Traits::__arity;
+      using _Varargs = typename _Traits::__vararg;
+      template<typename _Func, typename... _BoundArgs>
+ friend struct _Bind_check_arity;
+      _MemFunPtr _M_pmf;
+    public:
+      using result_type = typename _Traits::__result_type;
+      explicit constexpr
+      _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }
+      template<typename... _Args>
+ auto
+ operator()(_Args&&... __args) const
+ noexcept(noexcept(
+       std::__invoke(_M_pmf, std::forward<_Args>(__args)...)))
+ -> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...))
+ { return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); }
+    };
+  template<typename _MemObjPtr>
+    class _Mem_fn_base<_MemObjPtr, false>
+    {
+      using _Arity = integral_constant<size_t, 0>;
+      using _Varargs = false_type;
+      template<typename _Func, typename... _BoundArgs>
+ friend struct _Bind_check_arity;
+      _MemObjPtr _M_pm;
+    public:
+      explicit constexpr
+      _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }
+      template<typename _Tp>
+ auto
+ operator()(_Tp&& __obj) const
+ noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj))))
+ -> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))
+ { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); }
+    };
+  template<typename _MemberPointer>
+    struct _Mem_fn;
+  template<typename _Res, typename _Class>
+    struct _Mem_fn<_Res _Class::*>
+    : _Mem_fn_base<_Res _Class::*>
+    {
+      using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base;
+    };
+  template<typename _Tp, typename _Class>
+    inline _Mem_fn<_Tp _Class::*>
+    mem_fn(_Tp _Class::* __pm) noexcept
+    {
+      return _Mem_fn<_Tp _Class::*>(__pm);
+    }
+  template<typename _Tp>
+    struct is_bind_expression
+    : public false_type { };
+  template<typename _Tp>
+    struct is_placeholder
+    : public integral_constant<int, 0>
+    { };
+  template <typename _Tp> inline constexpr bool is_bind_expression_v
+    = is_bind_expression<_Tp>::value;
+  template <typename _Tp> inline constexpr int is_placeholder_v
+    = is_placeholder<_Tp>::value;
+  template<int _Num> struct _Placeholder { };
+  namespace placeholders
+  {
+    extern const _Placeholder<1> _1;
+    extern const _Placeholder<2> _2;
+    extern const _Placeholder<3> _3;
+    extern const _Placeholder<4> _4;
+    extern const _Placeholder<5> _5;
+    extern const _Placeholder<6> _6;
+    extern const _Placeholder<7> _7;
+    extern const _Placeholder<8> _8;
+    extern const _Placeholder<9> _9;
+    extern const _Placeholder<10> _10;
+    extern const _Placeholder<11> _11;
+    extern const _Placeholder<12> _12;
+    extern const _Placeholder<13> _13;
+    extern const _Placeholder<14> _14;
+    extern const _Placeholder<15> _15;
+    extern const _Placeholder<16> _16;
+    extern const _Placeholder<17> _17;
+    extern const _Placeholder<18> _18;
+    extern const _Placeholder<19> _19;
+    extern const _Placeholder<20> _20;
+    extern const _Placeholder<21> _21;
+    extern const _Placeholder<22> _22;
+    extern const _Placeholder<23> _23;
+    extern const _Placeholder<24> _24;
+    extern const _Placeholder<25> _25;
+    extern const _Placeholder<26> _26;
+    extern const _Placeholder<27> _27;
+    extern const _Placeholder<28> _28;
+    extern const _Placeholder<29> _29;
+  }
+  template<int _Num>
+    struct is_placeholder<_Placeholder<_Num> >
+    : public integral_constant<int, _Num>
+    { };
+  template<int _Num>
+    struct is_placeholder<const _Placeholder<_Num> >
+    : public integral_constant<int, _Num>
+    { };
+  template<std::size_t __i, typename _Tuple>
+    using _Safe_tuple_element_t
+      = typename enable_if<(__i < tuple_size<_Tuple>::value),
+      tuple_element<__i, _Tuple>>::type::type;
+  template<typename _Arg,
+    bool _IsBindExp = is_bind_expression<_Arg>::value,
+    bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
+    class _Mu;
+  template<typename _Tp>
+    class _Mu<reference_wrapper<_Tp>, false, false>
+    {
+    public:
+      template<typename _CVRef, typename _Tuple>
+ _Tp&
+ operator()(_CVRef& __arg, _Tuple&) const volatile
+ { return __arg.get(); }
+    };
+  template<typename _Arg>
+    class _Mu<_Arg, true, false>
+    {
+    public:
+      template<typename _CVArg, typename... _Args>
+ auto
+ operator()(_CVArg& __arg,
+     tuple<_Args...>& __tuple) const volatile
+ -> decltype(__arg(declval<_Args>()...))
+ {
+   typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
+     _Indexes;
+   return this->__call(__arg, __tuple, _Indexes());
+ }
+    private:
+      template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
+ auto
+ __call(_CVArg& __arg, tuple<_Args...>& __tuple,
+        const _Index_tuple<_Indexes...>&) const volatile
+ -> decltype(__arg(declval<_Args>()...))
+ {
+   return __arg(std::get<_Indexes>(std::move(__tuple))...);
+ }
+    };
+  template<typename _Arg>
+    class _Mu<_Arg, false, true>
+    {
+    public:
+      template<typename _Tuple>
+ _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&&
+ operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
+ {
+   return
+     ::std::get<(is_placeholder<_Arg>::value - 1)>(std::move(__tuple));
+ }
+    };
+  template<typename _Arg>
+    class _Mu<_Arg, false, false>
+    {
+    public:
+      template<typename _CVArg, typename _Tuple>
+ _CVArg&&
+ operator()(_CVArg&& __arg, _Tuple&) const volatile
+ { return std::forward<_CVArg>(__arg); }
+    };
+  template<std::size_t _Ind, typename... _Tp>
+    inline auto
+    __volget(volatile tuple<_Tp...>& __tuple)
+    -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
+    { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
+  template<std::size_t _Ind, typename... _Tp>
+    inline auto
+    __volget(const volatile tuple<_Tp...>& __tuple)
+    -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
+    { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
+  template<typename _Signature>
+    struct _Bind;
+   template<typename _Functor, typename... _Bound_args>
+    class _Bind<_Functor(_Bound_args...)>
+    : public _Weak_result_type<_Functor>
+    {
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
+ _Bound_indexes;
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
+ {
+   return std::__invoke(_M_f,
+       _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
+       );
+ }
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
+ {
+   return std::__invoke(_M_f,
+       _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
+       );
+ }
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call_v(tuple<_Args...>&& __args,
+   _Index_tuple<_Indexes...>) volatile
+ {
+   return std::__invoke(_M_f,
+       _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...
+       );
+ }
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call_c_v(tuple<_Args...>&& __args,
+     _Index_tuple<_Indexes...>) const volatile
+ {
+   return std::__invoke(_M_f,
+       _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...
+       );
+ }
+      template<typename _BoundArg, typename _CallArgs>
+ using _Mu_type = decltype(
+     _Mu<typename remove_cv<_BoundArg>::type>()(
+       std::declval<_BoundArg&>(), std::declval<_CallArgs&>()) );
+      template<typename _Fn, typename _CallArgs, typename... _BArgs>
+ using _Res_type_impl
+   = typename result_of< _Fn&(_Mu_type<_BArgs, _CallArgs>&&...) >::type;
+      template<typename _CallArgs>
+ using _Res_type = _Res_type_impl<_Functor, _CallArgs, _Bound_args...>;
+      template<typename _CallArgs>
+ using __dependent = typename
+   enable_if<bool(tuple_size<_CallArgs>::value+1), _Functor>::type;
+      template<typename _CallArgs, template<class> class __cv_quals>
+ using _Res_type_cv = _Res_type_impl<
+   typename __cv_quals<__dependent<_CallArgs>>::type,
+   _CallArgs,
+   typename __cv_quals<_Bound_args>::type...>;
+     public:
+      template<typename... _Args>
+ explicit _Bind(const _Functor& __f, _Args&&... __args)
+ : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+      template<typename... _Args>
+ explicit _Bind(_Functor&& __f, _Args&&... __args)
+ : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+      _Bind(const _Bind&) = default;
+      _Bind(_Bind&& __b)
+      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
+      { }
+      template<typename... _Args,
+        typename _Result = _Res_type<tuple<_Args...>>>
+ _Result
+ operator()(_Args&&... __args)
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+      template<typename... _Args,
+        typename _Result = _Res_type_cv<tuple<_Args...>, add_const>>
+ _Result
+ operator()(_Args&&... __args) const
+ {
+   return this->__call_c<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+      template<typename... _Args,
+        typename _Result = _Res_type_cv<tuple<_Args...>, add_volatile>>
+ [[deprecated("std::bind does not support volatile in C++17")]]
+ _Result
+ operator()(_Args&&... __args) volatile
+ {
+   return this->__call_v<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+      template<typename... _Args,
+        typename _Result = _Res_type_cv<tuple<_Args...>, add_cv>>
+ [[deprecated("std::bind does not support volatile in C++17")]]
+ _Result
+ operator()(_Args&&... __args) const volatile
+ {
+   return this->__call_c_v<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+    };
+  template<typename _Result, typename _Signature>
+    struct _Bind_result;
+  template<typename _Result, typename _Functor, typename... _Bound_args>
+    class _Bind_result<_Result, _Functor(_Bound_args...)>
+    {
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
+ _Bound_indexes;
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+      template<typename _Res>
+ using __enable_if_void
+   = typename enable_if<is_void<_Res>{}>::type;
+      template<typename _Res>
+ using __disable_if_void
+   = typename enable_if<!is_void<_Res>{}, _Result>::type;
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ __disable_if_void<_Res>
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
+ {
+   return std::__invoke(_M_f, _Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ __enable_if_void<_Res>
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
+ {
+   std::__invoke(_M_f, _Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ __disable_if_void<_Res>
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
+ {
+   return std::__invoke(_M_f, _Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ __enable_if_void<_Res>
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
+ {
+   std::__invoke(_M_f, _Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ __disable_if_void<_Res>
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile
+ {
+   return std::__invoke(_M_f, _Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ __enable_if_void<_Res>
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile
+ {
+   std::__invoke(_M_f, _Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ __disable_if_void<_Res>
+ __call(tuple<_Args...>&& __args,
+        _Index_tuple<_Indexes...>) const volatile
+ {
+   return std::__invoke(_M_f, _Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+ __enable_if_void<_Res>
+ __call(tuple<_Args...>&& __args,
+        _Index_tuple<_Indexes...>) const volatile
+ {
+   std::__invoke(_M_f, _Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+    public:
+      typedef _Result result_type;
+      template<typename... _Args>
+ explicit _Bind_result(const _Functor& __f, _Args&&... __args)
+ : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+      template<typename... _Args>
+ explicit _Bind_result(_Functor&& __f, _Args&&... __args)
+ : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+      _Bind_result(const _Bind_result&) = default;
+      _Bind_result(_Bind_result&& __b)
+      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
+      { }
+      template<typename... _Args>
+ result_type
+ operator()(_Args&&... __args)
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+      template<typename... _Args>
+ result_type
+ operator()(_Args&&... __args) const
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+      template<typename... _Args>
+ [[deprecated("std::bind does not support volatile in C++17")]]
+ result_type
+ operator()(_Args&&... __args) volatile
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+      template<typename... _Args>
+ [[deprecated("std::bind does not support volatile in C++17")]]
+ result_type
+ operator()(_Args&&... __args) const volatile
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+    };
+  template<typename _Signature>
+    struct is_bind_expression<_Bind<_Signature> >
+    : public true_type { };
+  template<typename _Signature>
+    struct is_bind_expression<const _Bind<_Signature> >
+    : public true_type { };
+  template<typename _Signature>
+    struct is_bind_expression<volatile _Bind<_Signature> >
+    : public true_type { };
+  template<typename _Signature>
+    struct is_bind_expression<const volatile _Bind<_Signature>>
+    : public true_type { };
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<_Bind_result<_Result, _Signature>>
+    : public true_type { };
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const _Bind_result<_Result, _Signature>>
+    : public true_type { };
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
+    : public true_type { };
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
+    : public true_type { };
+  template<typename _Func, typename... _BoundArgs>
+    struct _Bind_check_arity { };
+  template<typename _Ret, typename... _Args, typename... _BoundArgs>
+    struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...>
+    {
+      static_assert(sizeof...(_BoundArgs) == sizeof...(_Args),
+                   "Wrong number of arguments for function");
+    };
+  template<typename _Ret, typename... _Args, typename... _BoundArgs>
+    struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...>
+    {
+      static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args),
+                   "Wrong number of arguments for function");
+    };
+  template<typename _Tp, typename _Class, typename... _BoundArgs>
+    struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...>
+    {
+      using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity;
+      using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs;
+      static_assert(_Varargs::value
+      ? sizeof...(_BoundArgs) >= _Arity::value + 1
+      : sizeof...(_BoundArgs) == _Arity::value + 1,
+      "Wrong number of arguments for pointer-to-member");
+    };
+  template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
+    using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
+  template<bool _SocketLike, typename _Func, typename... _BoundArgs>
+    struct _Bind_helper
+    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
+    {
+      typedef typename decay<_Func>::type __func_type;
+      typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
+    };
+  template<typename _Func, typename... _BoundArgs>
+    struct _Bind_helper<true, _Func, _BoundArgs...>
+    { };
+  template<typename _Func, typename... _BoundArgs>
+    inline typename
+    _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
+    bind(_Func&& __f, _BoundArgs&&... __args)
+    {
+      typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
+      return typename __helper_type::type(std::forward<_Func>(__f),
+       std::forward<_BoundArgs>(__args)...);
+    }
+  template<typename _Result, typename _Func, typename... _BoundArgs>
+    struct _Bindres_helper
+    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
+    {
+      typedef typename decay<_Func>::type __functor_type;
+      typedef _Bind_result<_Result,
+      __functor_type(typename decay<_BoundArgs>::type...)>
+ type;
+    };
+  template<typename _Result, typename _Func, typename... _BoundArgs>
+    inline
+    typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
+    bind(_Func&& __f, _BoundArgs&&... __args)
+    {
+      typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
+      return typename __helper_type::type(std::forward<_Func>(__f),
+       std::forward<_BoundArgs>(__args)...);
+    }
+  template<typename _Fn>
+    class _Not_fn
+    {
+      template<typename _Fn2, typename... _Args>
+ using __inv_res_t = typename __invoke_result<_Fn2, _Args...>::type;
+      template<typename _Tp>
+ static decltype(!std::declval<_Tp>())
+ _S_not() noexcept(noexcept(!std::declval<_Tp>()));
+    public:
+      template<typename _Fn2>
+ _Not_fn(_Fn2&& __fn, int)
+ : _M_fn(std::forward<_Fn2>(__fn)) { }
+      _Not_fn(const _Not_fn& __fn) = default;
+      _Not_fn(_Not_fn&& __fn) = default;
+      ~_Not_fn() = default;
+      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn &, _Args...>>()) operator()(_Args&&... __args) & noexcept(__is_nothrow_invocable<_Fn &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &, _Args...>>())) { return !std::__invoke(std::forward< _Fn & >(_M_fn), std::forward<_Args>(__args)...); }
+      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn const &, _Args...>>()) operator()(_Args&&... __args) const & noexcept(__is_nothrow_invocable<_Fn const &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &, _Args...>>())) { return !std::__invoke(std::forward< _Fn const & >(_M_fn), std::forward<_Args>(__args)...); }
+      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn &&, _Args...>>()) operator()(_Args&&... __args) && noexcept(__is_nothrow_invocable<_Fn &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn && >(_M_fn), std::forward<_Args>(__args)...); }
+      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn const &&, _Args...>>()) operator()(_Args&&... __args) const && noexcept(__is_nothrow_invocable<_Fn const &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn const && >(_M_fn), std::forward<_Args>(__args)...); }
+    private:
+      _Fn _M_fn;
+    };
+  template<typename _Tp, typename _Pred>
+    struct __is_byte_like : false_type { };
+  template<typename _Tp>
+    struct __is_byte_like<_Tp, equal_to<_Tp>>
+    : __bool_constant<sizeof(_Tp) == 1 && is_integral<_Tp>::value> { };
+  template<typename _Tp>
+    struct __is_byte_like<_Tp, equal_to<void>>
+    : __bool_constant<sizeof(_Tp) == 1 && is_integral<_Tp>::value> { };
+  enum class byte : unsigned char;
+  template<>
+    struct __is_byte_like<byte, equal_to<byte>>
+    : true_type { };
+  template<>
+    struct __is_byte_like<byte, equal_to<void>>
+    : true_type { };
+  template<typename _Fn>
+    inline auto
+    not_fn(_Fn&& __fn)
+    noexcept(std::is_nothrow_constructible<std::decay_t<_Fn>, _Fn&&>::value)
+    {
+      return _Not_fn<std::decay_t<_Fn>>{std::forward<_Fn>(__fn), 0};
+    }
+  template<typename _ForwardIterator1, typename _BinaryPredicate = equal_to<>>
+    class default_searcher
+    {
+    public:
+      default_searcher(_ForwardIterator1 __pat_first,
+         _ForwardIterator1 __pat_last,
+         _BinaryPredicate __pred = _BinaryPredicate())
+      : _M_m(__pat_first, __pat_last, std::move(__pred))
+      { }
+      template<typename _ForwardIterator2>
+        pair<_ForwardIterator2, _ForwardIterator2>
+ operator()(_ForwardIterator2 __first, _ForwardIterator2 __last) const
+ {
+   _ForwardIterator2 __first_ret =
+     std::search(__first, __last, std::get<0>(_M_m), std::get<1>(_M_m),
+   std::get<2>(_M_m));
+   auto __ret = std::make_pair(__first_ret, __first_ret);
+   if (__ret.first != __last)
+     std::advance(__ret.second, std::distance(std::get<0>(_M_m),
+           std::get<1>(_M_m)));
+   return __ret;
+ }
+    private:
+      tuple<_ForwardIterator1, _ForwardIterator1, _BinaryPredicate> _M_m;
+    };
+  template<typename _Key, typename _Tp, typename _Hash, typename _Pred>
+    struct __boyer_moore_map_base
+    {
+      template<typename _RAIter>
+ __boyer_moore_map_base(_RAIter __pat, size_t __patlen,
+          _Hash&& __hf, _Pred&& __pred)
+ : _M_bad_char{ __patlen, std::move(__hf), std::move(__pred) }
+ {
+   if (__patlen > 0)
+     for (__diff_type __i = 0; __i < __patlen - 1; ++__i)
+       _M_bad_char[__pat[__i]] = __patlen - 1 - __i;
+ }
+      using __diff_type = _Tp;
+      __diff_type
+      _M_lookup(_Key __key, __diff_type __not_found) const
+      {
+ auto __iter = _M_bad_char.find(__key);
+ if (__iter == _M_bad_char.end())
+   return __not_found;
+ return __iter->second;
+      }
+      _Pred
+      _M_pred() const { return _M_bad_char.key_eq(); }
+      std::unordered_map<_Key, _Tp, _Hash, _Pred> _M_bad_char;
+    };
+  template<typename _Tp, size_t _Len, typename _Pred>
+    struct __boyer_moore_array_base
+    {
+      template<typename _RAIter, typename _Unused>
+ __boyer_moore_array_base(_RAIter __pat, size_t __patlen,
+     _Unused&&, _Pred&& __pred)
+ : _M_bad_char{ std::array<_Tp, _Len>{}, std::move(__pred) }
+ {
+   std::get<0>(_M_bad_char).fill(__patlen);
+   if (__patlen > 0)
+     for (__diff_type __i = 0; __i < __patlen - 1; ++__i)
+       {
+  auto __ch = __pat[__i];
+  using _UCh = make_unsigned_t<decltype(__ch)>;
+  auto __uch = static_cast<_UCh>(__ch);
+  std::get<0>(_M_bad_char)[__uch] = __patlen - 1 - __i;
+       }
+ }
+      using __diff_type = _Tp;
+      template<typename _Key>
+ __diff_type
+ _M_lookup(_Key __key, __diff_type __not_found) const
+ {
+   auto __ukey = static_cast<make_unsigned_t<_Key>>(__key);
+   if (__ukey >= _Len)
+     return __not_found;
+   return std::get<0>(_M_bad_char)[__ukey];
+ }
+      const _Pred&
+      _M_pred() const { return std::get<1>(_M_bad_char); }
+      tuple<std::array<_Tp, _Len>, _Pred> _M_bad_char;
+    };
+  template<typename _RAIter, typename _Hash, typename _Pred,
+           typename _Val = typename iterator_traits<_RAIter>::value_type,
+    typename _Diff = typename iterator_traits<_RAIter>::difference_type>
+    using __boyer_moore_base_t
+      = conditional_t<__is_byte_like<_Val, _Pred>::value,
+        __boyer_moore_array_base<_Diff, 256, _Pred>,
+        __boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>;
+  template<typename _RAIter, typename _Hash
+      = hash<typename iterator_traits<_RAIter>::value_type>,
+    typename _BinaryPredicate = equal_to<>>
+    class boyer_moore_searcher
+    : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>
+    {
+      using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>;
+      using typename _Base::__diff_type;
+    public:
+      boyer_moore_searcher(_RAIter __pat_first, _RAIter __pat_last,
+      _Hash __hf = _Hash(),
+      _BinaryPredicate __pred = _BinaryPredicate());
+      template<typename _RandomAccessIterator2>
+        pair<_RandomAccessIterator2, _RandomAccessIterator2>
+ operator()(_RandomAccessIterator2 __first,
+     _RandomAccessIterator2 __last) const;
+    private:
+      bool
+      _M_is_prefix(_RAIter __word, __diff_type __len,
+     __diff_type __pos)
+      {
+ const auto& __pred = this->_M_pred();
+ __diff_type __suffixlen = __len - __pos;
+ for (__diff_type __i = 0; __i < __suffixlen; ++__i)
+   if (!__pred(__word[__i], __word[__pos + __i]))
+     return false;
+ return true;
+      }
+      __diff_type
+      _M_suffix_length(_RAIter __word, __diff_type __len,
+         __diff_type __pos)
+      {
+ const auto& __pred = this->_M_pred();
+ __diff_type __i = 0;
+ while (__pred(__word[__pos - __i], __word[__len - 1 - __i])
+        && __i < __pos)
+   {
+     ++__i;
+   }
+ return __i;
+      }
+      template<typename _Tp>
+ __diff_type
+ _M_bad_char_shift(_Tp __c) const
+ { return this->_M_lookup(__c, _M_pat_end - _M_pat); }
+      _RAIter _M_pat;
+      _RAIter _M_pat_end;
+      std::vector<__diff_type> _M_good_suffix;
+    };
+  template<typename _RAIter, typename _Hash
+      = hash<typename iterator_traits<_RAIter>::value_type>,
+    typename _BinaryPredicate = equal_to<>>
+    class boyer_moore_horspool_searcher
+    : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>
+    {
+      using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>;
+      using typename _Base::__diff_type;
+    public:
+      boyer_moore_horspool_searcher(_RAIter __pat,
+        _RAIter __pat_end,
+        _Hash __hf = _Hash(),
+        _BinaryPredicate __pred
+        = _BinaryPredicate())
+      : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
+ _M_pat(__pat), _M_pat_end(__pat_end)
+      { }
+      template<typename _RandomAccessIterator2>
+        pair<_RandomAccessIterator2, _RandomAccessIterator2>
+ operator()(_RandomAccessIterator2 __first,
+     _RandomAccessIterator2 __last) const
+ {
+   const auto& __pred = this->_M_pred();
+   auto __patlen = _M_pat_end - _M_pat;
+   if (__patlen == 0)
+     return std::make_pair(__first, __first);
+   auto __len = __last - __first;
+   while (__len >= __patlen)
+     {
+       for (auto __scan = __patlen - 1;
+     __pred(__first[__scan], _M_pat[__scan]); --__scan)
+  if (__scan == 0)
+    return std::make_pair(__first, __first + __patlen);
+       auto __shift = _M_bad_char_shift(__first[__patlen - 1]);
+       __len -= __shift;
+       __first += __shift;
+     }
+   return std::make_pair(__last, __last);
+ }
+    private:
+      template<typename _Tp>
+ __diff_type
+ _M_bad_char_shift(_Tp __c) const
+ { return this->_M_lookup(__c, _M_pat_end - _M_pat); }
+      _RAIter _M_pat;
+      _RAIter _M_pat_end;
+    };
+  template<typename _RAIter, typename _Hash, typename _BinaryPredicate>
+    boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>::
+    boyer_moore_searcher(_RAIter __pat, _RAIter __pat_end,
+    _Hash __hf, _BinaryPredicate __pred)
+    : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
+      _M_pat(__pat), _M_pat_end(__pat_end), _M_good_suffix(__pat_end - __pat)
+    {
+      auto __patlen = __pat_end - __pat;
+      if (__patlen == 0)
+ return;
+      __diff_type __last_prefix = __patlen - 1;
+      for (__diff_type __p = __patlen - 1; __p >= 0; --__p)
+ {
+   if (_M_is_prefix(__pat, __patlen, __p + 1))
+     __last_prefix = __p + 1;
+   _M_good_suffix[__p] = __last_prefix + (__patlen - 1 - __p);
+ }
+      for (__diff_type __p = 0; __p < __patlen - 1; ++__p)
+ {
+   auto __slen = _M_suffix_length(__pat, __patlen, __p);
+   auto __pos = __patlen - 1 - __slen;
+   if (!__pred(__pat[__p - __slen], __pat[__pos]))
+     _M_good_suffix[__pos] = __patlen - 1 - __p + __slen;
+ }
+    }
+  template<typename _RAIter, typename _Hash, typename _BinaryPredicate>
+  template<typename _RandomAccessIterator2>
+    pair<_RandomAccessIterator2, _RandomAccessIterator2>
+    boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>::
+    operator()(_RandomAccessIterator2 __first,
+        _RandomAccessIterator2 __last) const
+    {
+      auto __patlen = _M_pat_end - _M_pat;
+      if (__patlen == 0)
+ return std::make_pair(__first, __first);
+      const auto& __pred = this->_M_pred();
+      __diff_type __i = __patlen - 1;
+      auto __stringlen = __last - __first;
+      while (__i < __stringlen)
+ {
+   __diff_type __j = __patlen - 1;
+   while (__j >= 0 && __pred(__first[__i], _M_pat[__j]))
+     {
+       --__i;
+       --__j;
+     }
+   if (__j < 0)
+     {
+       const auto __match = __first + __i + 1;
+       return std::make_pair(__match, __match + __patlen);
+     }
+   __i += std::max(_M_bad_char_shift(__first[__i]),
+     _M_good_suffix[__j]);
+ }
+      return std::make_pair(__last, __last);
+    }
+
+}
+namespace mlx::core::simd {
+template <typename T, int N>
+struct Simd;
+template <typename T>
+static constexpr int max_size = 1;
+template <typename T>
+struct Simd<T, 1> {
+  static constexpr int size = 1;
+  T value;
+  Simd() {}
+  template <typename U>
+  Simd(Simd<U, 1> v) : value(v.value) {}
+  template <typename U>
+  Simd(U v) : value(v) {}
+};
+template <typename T, int N>
+Simd<T, N> load(const T* x) {
+  return *(Simd<T, N>*)x;
+}
+template <typename T, int N>
+void store(T* dst, Simd<T, N> x) {
+  if constexpr (std::is_same_v<T, bool> && N > 1) {
+    x = x & 1;
+  }
+  *(Simd<T, N>*)dst = x;
+}
+template <typename, typename = void>
+constexpr bool is_complex = false;
+template <typename T>
+constexpr bool is_complex<T, std::void_t<decltype(std::declval<T>().real())>> =
+    true;
+template <typename T>
+Simd<T, 1> rint(Simd<T, 1> in) {
+  if constexpr (is_complex<T>) {
+    return Simd<T, 1>{
+        T{std::rint(in.value.real()), std::rint(in.value.imag())}};
+  } else {
+    return Simd<T, 1>{std::rint(in.value)};
+  }
+}
+template <typename T>
+Simd<T, 1> rsqrt(Simd<T, 1> in) {
+  return T(1.0) / sqrt(in);
+}
+template <typename T>
+Simd<T, 1> recip(Simd<T, 1> in) {
+  return T(1.0) / in;
+}
+template <typename T> Simd<T, 1> operator-(Simd<T, 1> in) { return std::negate{}(in.value); }
+template <typename T> Simd<T, 1> operator!(Simd<T, 1> in) { return std::logical_not{}(in.value); }
+template <typename T> Simd<T, 1> abs(Simd<T, 1> in) { return std::abs(in.value); }
+template <typename T> Simd<T, 1> acos(Simd<T, 1> in) { return std::acos(in.value); }
+template <typename T> Simd<T, 1> acosh(Simd<T, 1> in) { return std::acosh(in.value); }
+template <typename T> Simd<T, 1> asin(Simd<T, 1> in) { return std::asin(in.value); }
+template <typename T> Simd<T, 1> asinh(Simd<T, 1> in) { return std::asinh(in.value); }
+template <typename T> Simd<T, 1> atan(Simd<T, 1> in) { return std::atan(in.value); }
+template <typename T> Simd<T, 1> atanh(Simd<T, 1> in) { return std::atanh(in.value); }
+template <typename T> Simd<T, 1> ceil(Simd<T, 1> in) { return std::ceil(in.value); }
+template <typename T> Simd<T, 1> conj(Simd<T, 1> in) { return std::conj(in.value); }
+template <typename T> Simd<T, 1> cosh(Simd<T, 1> in) { return std::cosh(in.value); }
+template <typename T> Simd<T, 1> expm1(Simd<T, 1> in) { return std::expm1(in.value); }
+template <typename T> Simd<T, 1> floor(Simd<T, 1> in) { return std::floor(in.value); }
+template <typename T> Simd<T, 1> log(Simd<T, 1> in) { return std::log(in.value); }
+template <typename T> Simd<T, 1> log10(Simd<T, 1> in) { return std::log10(in.value); }
+template <typename T> Simd<T, 1> sinh(Simd<T, 1> in) { return std::sinh(in.value); }
+template <typename T> Simd<T, 1> sqrt(Simd<T, 1> in) { return std::sqrt(in.value); }
+template <typename T> Simd<T, 1> tan(Simd<T, 1> in) { return std::tan(in.value); }
+template <typename T> Simd<T, 1> tanh(Simd<T, 1> in) { return std::tanh(in.value); }
+template <typename T>
+Simd<T, 1> log1p(Simd<T, 1> in) {
+  if constexpr (is_complex<T>) {
+    auto x = in.value.real();
+    auto y = in.value.imag();
+    auto zabs = std::abs(in.value);
+    auto theta = std::atan2(y, x + 1);
+    if (zabs < 0.5) {
+      auto r = x * (2 + x) + y * y;
+      if (r == 0) {
+        return Simd<T, 1>{T{x, theta}};
+      }
+      return Simd<T, 1>{T{((typeof(x))(0.5)) * std::log1p(r), theta}};
+    } else {
+      auto z0 = std::hypot(x + 1, y);
+      return Simd<T, 1>{T{std::log(z0), theta}};
+    }
+  } else {
+    return Simd<T, 1>{std::log1p(in.value)};
+  }
+}
+template <typename T>
+Simd<T, 1> log2(Simd<T, 1> in) {
+  if constexpr (is_complex<T>) {
+    auto out = std::log(in.value);
+    auto scale = decltype(out.real())(0.69314718055994530942);
+    return Simd<T, 1>{T{out.real() / scale, out.imag() / scale}};
+  } else {
+    return Simd<T, 1>{std::log2(in.value)};
+  }
+}
+template <typename T>
+Simd<T, 1> operator~(Simd<T, 1> in) {
+  return ~in.value;
+}
+template <typename T>
+auto real(Simd<T, 1> in) -> Simd<decltype(std::real(in.value)), 1> {
+  return std::real(in.value);
+}
+template <typename T>
+auto imag(Simd<T, 1> in) -> Simd<decltype(std::imag(in.value)), 1> {
+  return std::imag(in.value);
+}
+template <typename T>
+Simd<bool, 1> isnan(Simd<T, 1> in) {
+  return std::isnan(in.value);
+}
+template <typename T1, typename T2> auto operator +(Simd<T1, 1> a, Simd<T2, 1> b) ->Simd<decltype(a.value + b.value), 1> { return a.value + b.value; } template <typename T1, typename T2> auto operator +(T1 a, Simd<T2, 1> b)->Simd<decltype(a + b.value), 1> { return a + b.value; } template <typename T1, typename T2> auto operator +(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value + b), 1> { return a.value + b; }
+template <typename T1, typename T2> auto operator -(Simd<T1, 1> a, Simd<T2, 1> b) ->Simd<decltype(a.value - b.value), 1> { return a.value - b.value; } template <typename T1, typename T2> auto operator -(T1 a, Simd<T2, 1> b)->Simd<decltype(a - b.value), 1> { return a - b.value; } template <typename T1, typename T2> auto operator -(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value - b), 1> { return a.value - b; }
+template <typename T1, typename T2> auto operator *(Simd<T1, 1> a, Simd<T2, 1> b) ->Simd<decltype(a.value * b.value), 1> { return a.value * b.value; } template <typename T1, typename T2> auto operator *(T1 a, Simd<T2, 1> b)->Simd<decltype(a * b.value), 1> { return a * b.value; } template <typename T1, typename T2> auto operator *(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value * b), 1> { return a.value * b; }
+template <typename T1, typename T2> auto operator /(Simd<T1, 1> a, Simd<T2, 1> b) ->Simd<decltype(a.value / b.value), 1> { return a.value / b.value; } template <typename T1, typename T2> auto operator /(T1 a, Simd<T2, 1> b)->Simd<decltype(a / b.value), 1> { return a / b.value; } template <typename T1, typename T2> auto operator /(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value / b), 1> { return a.value / b; }
+template <typename T1, typename T2> auto operator <<(Simd<T1, 1> a, Simd<T2, 1> b) ->Simd<decltype(a.value << b.value), 1> { return a.value << b.value; } template <typename T1, typename T2> auto operator <<(T1 a, Simd<T2, 1> b)->Simd<decltype(a << b.value), 1> { return a << b.value; } template <typename T1, typename T2> auto operator <<(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value << b), 1> { return a.value << b; }
+template <typename T1, typename T2> auto operator >>(Simd<T1, 1> a, Simd<T2, 1> b) ->Simd<decltype(a.value >> b.value), 1> { return a.value >> b.value; } template <typename T1, typename T2> auto operator >>(T1 a, Simd<T2, 1> b)->Simd<decltype(a >> b.value), 1> { return a >> b.value; } template <typename T1, typename T2> auto operator >>(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value >> b), 1> { return a.value >> b; }
+template <typename T1, typename T2> auto operator |(Simd<T1, 1> a, Simd<T2, 1> b) ->Simd<decltype(a.value | b.value), 1> { return a.value | b.value; } template <typename T1, typename T2> auto operator |(T1 a, Simd<T2, 1> b)->Simd<decltype(a | b.value), 1> { return a | b.value; } template <typename T1, typename T2> auto operator |(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value | b), 1> { return a.value | b; }
+template <typename T1, typename T2> auto operator ^(Simd<T1, 1> a, Simd<T2, 1> b) ->Simd<decltype(a.value ^ b.value), 1> { return a.value ^ b.value; } template <typename T1, typename T2> auto operator ^(T1 a, Simd<T2, 1> b)->Simd<decltype(a ^ b.value), 1> { return a ^ b.value; } template <typename T1, typename T2> auto operator ^(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value ^ b), 1> { return a.value ^ b; }
+template <typename T1, typename T2> auto operator &(Simd<T1, 1> a, Simd<T2, 1> b) ->Simd<decltype(a.value & b.value), 1> { return a.value & b.value; } template <typename T1, typename T2> auto operator &(T1 a, Simd<T2, 1> b)->Simd<decltype(a & b.value), 1> { return a & b.value; } template <typename T1, typename T2> auto operator &(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value & b), 1> { return a.value & b; }
+template <typename T1, typename T2> auto operator &&(Simd<T1, 1> a, Simd<T2, 1> b) ->Simd<decltype(a.value && b.value), 1> { return a.value && b.value; } template <typename T1, typename T2> auto operator &&(T1 a, Simd<T2, 1> b)->Simd<decltype(a && b.value), 1> { return a && b.value; } template <typename T1, typename T2> auto operator &&(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value && b), 1> { return a.value && b; }
+template <typename T1, typename T2> auto operator ||(Simd<T1, 1> a, Simd<T2, 1> b) ->Simd<decltype(a.value || b.value), 1> { return a.value || b.value; } template <typename T1, typename T2> auto operator ||(T1 a, Simd<T2, 1> b)->Simd<decltype(a || b.value), 1> { return a || b.value; } template <typename T1, typename T2> auto operator ||(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value || b), 1> { return a.value || b; }
+template <typename T>
+Simd<T, 1> remainder(Simd<T, 1> a_, Simd<T, 1> b_) {
+  T a = a_.value;
+  T b = b_.value;
+  T r;
+  if constexpr (std::is_integral_v<T>) {
+    r = a % b;
+  } else {
+    r = std::remainder(a, b);
+  }
+  if constexpr (std::is_signed_v<T>) {
+    if (r != 0 && (r < 0 != b < 0)) {
+      r += b;
+    }
+  }
+  return r;
+}
+template <typename T>
+Simd<T, 1> maximum(Simd<T, 1> a_, Simd<T, 1> b_) {
+  T a = a_.value;
+  T b = b_.value;
+  if constexpr (!std::is_integral_v<T>) {
+    if (std::isnan(a)) {
+      return a;
+    }
+  }
+  return (a > b) ? a : b;
+}
+template <typename T>
+Simd<T, 1> minimum(Simd<T, 1> a_, Simd<T, 1> b_) {
+  T a = a_.value;
+  T b = b_.value;
+  if constexpr (!std::is_integral_v<T>) {
+    if (std::isnan(a)) {
+      return a;
+    }
+  }
+  return (a < b) ? a : b;
+}
+template <typename T>
+Simd<T, 1> pow(Simd<T, 1> a, Simd<T, 1> b) {
+  T base = a.value;
+  T exp = b.value;
+  if constexpr (!std::is_integral_v<T>) {
+    return std::pow(base, exp);
+  } else {
+    T res = 1;
+    while (exp) {
+      if (exp & 1) {
+        res *= base;
+      }
+      exp >>= 1;
+      base *= base;
+    }
+    return res;
+  }
+}
+template <typename T>
+Simd<T, 1> atan2(Simd<T, 1> a, Simd<T, 1> b) {
+  return std::atan2(a.value, b.value);
+}
+template <typename T1, typename T2> Simd<bool, 1> operator >(Simd<T1, 1> a, Simd<T2, 1> b) { return a.value > b.value; } template <typename T1, typename T2> Simd<bool, 1> operator >(T1 a, Simd<T2, 1> b) { return a > b.value; } template <typename T1, typename T2> Simd<bool, 1> operator >(Simd<T1, 1> a, T2 b) { return a.value > b; }
+template <typename T1, typename T2> Simd<bool, 1> operator <(Simd<T1, 1> a, Simd<T2, 1> b) { return a.value < b.value; } template <typename T1, typename T2> Simd<bool, 1> operator <(T1 a, Simd<T2, 1> b) { return a < b.value; } template <typename T1, typename T2> Simd<bool, 1> operator <(Simd<T1, 1> a, T2 b) { return a.value < b; }
+template <typename T1, typename T2> Simd<bool, 1> operator >=(Simd<T1, 1> a, Simd<T2, 1> b) { return a.value >= b.value; } template <typename T1, typename T2> Simd<bool, 1> operator >=(T1 a, Simd<T2, 1> b) { return a >= b.value; } template <typename T1, typename T2> Simd<bool, 1> operator >=(Simd<T1, 1> a, T2 b) { return a.value >= b; }
+template <typename T1, typename T2> Simd<bool, 1> operator <=(Simd<T1, 1> a, Simd<T2, 1> b) { return a.value <= b.value; } template <typename T1, typename T2> Simd<bool, 1> operator <=(T1 a, Simd<T2, 1> b) { return a <= b.value; } template <typename T1, typename T2> Simd<bool, 1> operator <=(Simd<T1, 1> a, T2 b) { return a.value <= b; }
+template <typename T1, typename T2> Simd<bool, 1> operator ==(Simd<T1, 1> a, Simd<T2, 1> b) { return a.value == b.value; } template <typename T1, typename T2> Simd<bool, 1> operator ==(T1 a, Simd<T2, 1> b) { return a == b.value; } template <typename T1, typename T2> Simd<bool, 1> operator ==(Simd<T1, 1> a, T2 b) { return a.value == b; }
+template <typename T1, typename T2> Simd<bool, 1> operator !=(Simd<T1, 1> a, Simd<T2, 1> b) { return a.value != b.value; } template <typename T1, typename T2> Simd<bool, 1> operator !=(T1 a, Simd<T2, 1> b) { return a != b.value; } template <typename T1, typename T2> Simd<bool, 1> operator !=(Simd<T1, 1> a, T2 b) { return a.value != b; }
+template <typename MaskT, typename T>
+Simd<T, 1> select(Simd<MaskT, 1> mask, Simd<T, 1> x, Simd<T, 1> y) {
+  return mask.value ? x.value : y.value;
+}
+template <typename T>
+Simd<T, 1> clamp(Simd<T, 1> v, Simd<T, 1> min, Simd<T, 1> max) {
+  return std::clamp(v.value, min.value, max.value);
+}
+template <typename T, typename U>
+Simd<T, 1> fma(Simd<T, 1> x, Simd<T, 1> y, U z) {
+  return std::fma(x.value, y.value, Simd<T, 1>(z).value);
+}
+template <typename T> T max(Simd<T, 1> x) { return x.value; }
+template <typename T> T min(Simd<T, 1> x) { return x.value; }
+template <typename T> T sum(Simd<T, 1> x) { return x.value; }
+template <typename T> T prod(Simd<T, 1> x) { return x.value; }
+template <typename T> bool any(Simd<T, 1> x) { return x.value; }
+template <typename T> bool all(Simd<T, 1> x) { return x.value; }
+}
+namespace mlx::core::simd {
+constexpr float inf = std::numeric_limits<float>::infinity();
+template <typename T, int N>
+Simd<T, N> exp(Simd<T, N> in) {
+  if constexpr (is_complex<T>) {
+    return Simd<T, 1>{std::exp(in.value)};
+  } else {
+    Simd<float, N> x_init = in;
+    auto x = x_init * 1.442695f;
+    Simd<float, N> ipart, fpart;
+    ipart = floor(x + 0.5);
+    fpart = x - ipart;
+    x = 1.535336188319500e-4f;
+    x = fma(x, fpart, 1.339887440266574e-3f);
+    x = fma(x, fpart, 9.618437357674640e-3f);
+    x = fma(x, fpart, 5.550332471162809e-2f);
+    x = fma(x, fpart, 2.402264791363012e-1f);
+    x = fma(x, fpart, 6.931472028550421e-1f);
+    x = fma(x, fpart, 1.000000000000000f);
+    Simd<int, N> epart = (Simd<int, N>(ipart) + 127) << 23;
+    auto result = select(isnan(x_init), x_init, (*(Simd<float, N>*)&epart) * x);
+    result = select(x_init > 88.0f, Simd<float, N>(inf), result);
+    result = select(x_init < -88.0f, Simd<float, N>(0), result);
+    return Simd<T, N>(result);
+  }
+}
+template <bool Sine, typename T, int N>
+Simd<T, N> sincos(Simd<T, N> in) {
+  auto sign_mask_sin = in < 0;
+  in = abs(in);
+  Simd<float, N> x = in;
+  auto y = x * 1.27323954473516f;
+  Simd<uint32_t, N> emm2 = y;
+  emm2 = emm2 + 1;
+  emm2 = emm2 & ~1;
+  y = emm2;
+  auto poly_mask = (emm2 & 2) != 0;
+  x = fma(y, Simd<float, N>(-0.78515625f), x);
+  x = fma(y, Simd<float, N>(-2.4187564849853515625e-4f), x);
+  x = fma(y, Simd<float, N>(-3.77489497744594108e-8f), x);
+  sign_mask_sin = sign_mask_sin ^ ((emm2 & 4) != 0);
+  auto sign_mask_cos = ((emm2 - 2) & 4) != 0;
+  auto z = x * x;
+  auto y1 =
+      fma(z, Simd<float, N>(2.443315711809948e-5f), -1.388731625493765e-3f);
+  auto y2 = fma(z, Simd<float, N>(-1.9515295891e-4f), 8.3321608736e-3f);
+  y1 = fma(y1, z, 4.166664568298827e-2f);
+  y2 = fma(y2, z, -1.6666654611e-1f);
+  y1 = y1 * z;
+  y2 = y2 * z;
+  y1 = y1 * z;
+  y2 = fma(x, y2, x);
+  y1 = fma(z, Simd<float, N>(-0.5f), y1);
+  y1 = y1 + 1.0f;
+  if constexpr (Sine) {
+    auto ys = select(poly_mask, y1, y2);
+    return select(sign_mask_sin, -ys, ys);
+  } else {
+    auto yc = select(poly_mask, y2, y1);
+    return select(sign_mask_cos, yc, -yc);
+  }
+}
+template <typename T, int N>
+Simd<T, N> sin(Simd<T, N> x) {
+  if constexpr (is_complex<T>) {
+    return std::sin(x.value);
+  } else {
+    return sincos<true>(x);
+  }
+}
+template <typename T, int N>
+Simd<T, N> cos(Simd<T, N> x) {
+  if constexpr (is_complex<T>) {
+    return std::cos(x.value);
+  } else {
+    return sincos<false>(x);
+  }
+}
+template <typename T, int N>
+Simd<T, N> erf(Simd<T, N> x) {
+  Simd<float, N> v = x;
+  auto t = recip(fma(Simd<float, N>(0.3275911f), abs(v), 1.0f));
+  auto r = fma(Simd<float, N>(1.061405429f), t, -1.453152027f);
+  r = fma(r, t, 1.421413741f);
+  r = fma(r, t, -0.284496736f);
+  r = fma(r, t, 0.254829592f);
+  auto e = -exp(-v * v);
+  auto result = Simd<T, N>(fma(e * t, r, 1.0f));
+  return select(x > 0, result, -result);
+}
+template <typename T, int N>
+Simd<T, N> erfinv(Simd<T, N> a_) {
+  Simd<float, N> a = a_;
+  auto t = fma(a, 0.0f - a, 1.0f);
+  t = log(t);
+  auto lhs = [](auto t) {
+    Simd<float, N> p;
+    p = 3.03697567e-10f;
+    p = fma(p, t, 2.93243101e-8f);
+    p = fma(p, t, 1.22150334e-6f);
+    p = fma(p, t, 2.84108955e-5f);
+    p = fma(p, t, 3.93552968e-4f);
+    p = fma(p, t, 3.02698812e-3f);
+    p = fma(p, t, 4.83185798e-3f);
+    p = fma(p, t, -2.64646143e-1f);
+    return fma(p, t, 8.40016484e-1f);
+  };
+  auto rhs = [](auto t) {
+    Simd<float, N> p;
+    p = 5.43877832e-9f;
+    p = fma(p, t, 1.43285448e-7f);
+    p = fma(p, t, 1.22774793e-6f);
+    p = fma(p, t, 1.12963626e-7f);
+    p = fma(p, t, -5.61530760e-5f);
+    p = fma(p, t, -1.47697632e-4f);
+    p = fma(p, t, 2.31468678e-3f);
+    p = fma(p, t, 1.15392581e-2f);
+    p = fma(p, t, -2.32015476e-1f);
+    return fma(p, t, 8.86226892e-1f);
+  };
+  auto thresh = 6.125f;
+  if constexpr (N == 1) {
+    if ((abs(t) > thresh).value) {
+      return a * lhs(t);
+    } else {
+      return a * rhs(t);
+    }
+  } else {
+    return a * select(abs(t) > thresh, lhs(t), rhs(t));
+  }
+}
+}
+namespace mlx::core::detail {
+using namespace mlx::core::simd;
+struct Abs { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::abs(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct ArcCos { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::acos(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct ArcCosh { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::acosh(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct ArcSin { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::asin(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct ArcSinh { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::asinh(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct ArcTan { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::atan(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct ArcTanh { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::atanh(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct BitwiseInvert { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::operator~(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Ceil { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::ceil(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Conjugate { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::conj(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Cos { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::cos(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Cosh { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::cosh(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Erf { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::erf(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct ErfInv { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::erfinv(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Exp { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::exp(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Expm1 { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::expm1(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Floor { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::floor(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };;
+struct Log { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::log(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };;
+struct Log2 { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::log2(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };;
+struct Log10 { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::log10(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };;
+struct Log1p { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::log1p(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };;
+struct LogicalNot { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::operator!(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Negative { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::operator-(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Round { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::rint(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };;
+struct Sin { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::sin(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Sinh { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::sinh(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Sqrt { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::sqrt(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Rsqrt { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::rsqrt(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Tan { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::tan(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Tanh { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x) { return simd::tanh(x); } template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; } };
+struct Imag {
+  template <int N>
+  Simd<float, N> operator()(Simd<complex64_t, N> x) {
+    return simd::imag(x);
+  }
+  template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; }
+};
+struct Real {
+  template <int N>
+  Simd<float, N> operator()(Simd<complex64_t, N> x) {
+    return simd::real(x);
+  }
+  template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; }
+};
+struct Sigmoid {
+  template <int N, typename T>
+  Simd<T, N> operator()(Simd<T, N> x) {
+    return 1.0f / (1.0f + simd::exp(-x));
+  }
+  template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; }
+};
+struct Sign {
+  template <int N, typename T>
+  Simd<T, N> operator()(Simd<T, N> x) {
+    auto z = Simd<T, N>{0};
+    auto o = Simd<T, N>{1};
+    auto m = Simd<T, N>{-1};
+    if constexpr (std::is_unsigned_v<T>) {
+      return simd::select(x == z, z, o);
+    } else if constexpr (std::is_same_v<T, complex64_t>) {
+      return simd::select(x == z, x, Simd<T, N>(x / simd::abs(x)));
+    } else {
+      return simd::select(x < z, m, simd::select(x > z, o, z));
+    }
+  }
+  template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; }
+};
+struct Square {
+  template <int N, typename T>
+  Simd<T, N> operator()(Simd<T, N> x) {
+    return x * x;
+  }
+  template <typename T> T operator()(T x) { return (*this)(Simd<T, 1>(x)).value; }
+};
+}
+       
+namespace mlx::core::detail {
+using namespace mlx::core::simd;
+struct Add { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator+(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct ArcTan2 { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return atan2(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct Divide { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator/(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct Multiply { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator*(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct Subtract { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator-(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct LogicalAnd { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator&&(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct LogicalOr { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator||(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct BitwiseAnd { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator&(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct BitwiseOr { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator|(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct BitwiseXor { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator^(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct LeftShift { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator<<(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct RightShift { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator>>(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct Remainder { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return remainder(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct Maximum { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return maximum(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct Minimum { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return minimum(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct Power { template <int N, typename T> Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { return pow(x, y); } template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct Equal { template <int N, typename T> Simd<bool, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator==(x, y); } template <typename T> bool operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct Greater { template <int N, typename T> Simd<bool, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator>(x, y); } template <typename T> bool operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct GreaterEqual { template <int N, typename T> Simd<bool, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator>=(x, y); } template <typename T> bool operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct Less { template <int N, typename T> Simd<bool, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator<(x, y); } template <typename T> bool operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct LessEqual { template <int N, typename T> Simd<bool, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator<=(x, y); } template <typename T> bool operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct NotEqual { template <int N, typename T> Simd<bool, N> operator()(Simd<T, N> x, Simd<T, N> y) { return operator!=(x, y); } template <typename T> bool operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; } };
+struct NaNEqual {
+  template <int N, typename T>
+  Simd<bool, N> operator()(Simd<T, N> x, Simd<T, N> y) {
+    return x == y || (isnan(x) && isnan(y));
+  }
+  template <typename T>
+  bool operator()(T x, T y) {
+    return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value;
+  }
+};
+struct LogAddExp {
+  template <int N, typename T>
+  Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) {
+    auto maxval = maximum(x, y);
+    auto minval = minimum(x, y);
+    auto mask = minval == -inf || maxval == inf;
+    auto out = maxval + log1p(exp(minval - maxval));
+    return select(mask, Simd<T, N>(maxval), Simd<T, N>(out));
+  }
+  template <typename T> T operator()(T x, T y) { return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; }
+};
+struct Select {
+  template <typename T>
+  T operator()(bool condition, T x, T y) {
+    return (*this)(Simd<bool, 1>(condition), Simd<T, 1>(x), Simd<T, 1>(y))
+        .value;
+  }
+  template <int N, typename T>
+  Simd<T, N> operator()(Simd<bool, N> condition, Simd<T, N> x, Simd<T, N> y) {
+    return select(condition, x, y);
+  }
+};
+}
+const char* get_kernel_preamble();
+using namespace mlx::core;
+using namespace mlx::core::detail;
+)preamble";
+}
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb9de92640e91b3d38364ee7a569cd8b862951
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+0
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..fcc479b68f9753fe03bce59259f1bb056402d926
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/Makefile
@@ -0,0 +1,189 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\" \"headers\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu//CMakeFiles/progress.marks
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/no_gpu/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/no_gpu/clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/no_gpu/preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/backend/no_gpu/preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..700818ad404016953d260803d98a45017d83040d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/cmake_install.cmake
@@ -0,0 +1,50 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/backend/no_gpu
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e356b630934283a05e15886411707fe9465a2742
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/cmake_install.cmake
@@ -0,0 +1,75 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  # Include the install script for the subdirectory.
+  include("/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/common/cmake_install.cmake")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  # Include the install script for the subdirectory.
+  include("/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/cpu/cmake_install.cmake")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  # Include the install script for the subdirectory.
+  include("/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/cmake_install.cmake")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  # Include the install script for the subdirectory.
+  include("/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/cmake_install.cmake")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  # Include the install script for the subdirectory.
+  include("/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/backend/no_gpu/cmake_install.cmake")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb9de92640e91b3d38364ee7a569cd8b862951
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+0
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..6d01df4680fea9440ef2254f3f1e366e7650afff
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/Makefile
@@ -0,0 +1,189 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\" \"headers\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed//CMakeFiles/progress.marks
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..7c9cad01ab5bfea0e727b62ab28cb4ae702b3f21
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/cmake_install.cmake
@@ -0,0 +1,65 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  # Include the install script for the subdirectory.
+  include("/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/cmake_install.cmake")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  # Include the install script for the subdirectory.
+  include("/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/cmake_install.cmake")
+endif()
+
+if(NOT CMAKE_INSTALL_LOCAL_ONLY)
+  # Include the install script for the subdirectory.
+  include("/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/cmake_install.cmake")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb9de92640e91b3d38364ee7a569cd8b862951
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+0
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..896c6292efaf9709c862e522186bf05a0bf02afe
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/Makefile
@@ -0,0 +1,189 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\" \"headers\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi//CMakeFiles/progress.marks
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/mpi/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/mpi/clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/mpi/preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/mpi/preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..6f06ce34a806c45f5e344b08343623a0afa42ff8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/cmake_install.cmake
@@ -0,0 +1,50 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/mpi
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/mpi/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb9de92640e91b3d38364ee7a569cd8b862951
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+0
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..09c101e4d63650dbed468c364034f6f4359d7a16
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/Makefile
@@ -0,0 +1,189 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\" \"headers\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl//CMakeFiles/progress.marks
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/nccl/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/nccl/clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/nccl/preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/nccl/preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..f921406f215b3f5ce98b76b2ebe82bceaff3919f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/cmake_install.cmake
@@ -0,0 +1,50 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/nccl
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/nccl/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb9de92640e91b3d38364ee7a569cd8b862951
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..573541ac9702dd3969c9bc859d2b91ec1f7e6e56
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+0
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..8db4ee86a950d42f653e0d57d7441d9c59f28094
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/Makefile
@@ -0,0 +1,189 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\" \"headers\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring//CMakeFiles/progress.marks
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/ring/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/ring/clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/ring/preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/distributed/ring/preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..cb5e9edd553edd09f3af5ee6136be3dc2028f539
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/cmake_install.cmake
@@ -0,0 +1,50 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/distributed/ring
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/distributed/ring/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb9de92640e91b3d38364ee7a569cd8b862951
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/DependInfo.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/DependInfo.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..7a4fde0fe82ff3bfb114fec004a99f61c9e4746f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/DependInfo.cmake
@@ -0,0 +1,24 @@
+
+# Consider dependencies only in project.
+set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
+
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  )
+
+# The set of dependency files which are needed:
+set(CMAKE_DEPENDS_DEPENDENCY_FILES
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.c" "mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o" "gcc" "mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.c" "mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o" "gcc" "mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o.d"
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o
new file mode 100644
index 0000000000000000000000000000000000000000..93d3232272cf252997648d9e1de2577d14678258
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..55f4b45e7f54f23b528ab615b0e8d7673ee8af45
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o.d
@@ -0,0 +1,17 @@
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.c \
+ /usr/include/stdc-predef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/wordsize.h /usr/include/bits/long-double.h \
+ /usr/include/gnu/stubs.h /usr/include/gnu/stubs-64.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathinline.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o
new file mode 100644
index 0000000000000000000000000000000000000000..d084540e49a8b86607896e0a832971a6d708a433
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..ea4c43d51d1a7392f5ad2a3e5c61d1d93ae30e2e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o.d
@@ -0,0 +1,47 @@
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o: \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.c \
+ /usr/include/stdc-predef.h /usr/include/stdio.h \
+ /usr/include/bits/libc-header-start.h /usr/include/features.h \
+ /usr/include/sys/cdefs.h /usr/include/bits/wordsize.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__mbstate_t.h \
+ /usr/include/bits/types/__fpos64_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/stdlib.h \
+ /usr/include/bits/waitflags.h /usr/include/bits/waitstatus.h \
+ /usr/include/bits/floatn.h /usr/include/bits/floatn-common.h \
+ /usr/include/sys/types.h /usr/include/bits/types/clock_t.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/timer_t.h /usr/include/bits/stdint-intn.h \
+ /usr/include/endian.h /usr/include/bits/endian.h \
+ /usr/include/bits/byteswap.h /usr/include/bits/uintn-identity.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/struct_timespec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/alloca.h \
+ /usr/include/bits/stdlib-bsearch.h /usr/include/bits/stdlib-float.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/wchar.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/sys/mman.h \
+ /usr/include/bits/mman.h /usr/include/bits/mman-linux.h \
+ /usr/include/bits/mman-shared.h /usr/include/fcntl.h \
+ /usr/include/bits/fcntl.h /usr/include/bits/fcntl-linux.h \
+ /usr/include/bits/stat.h /usr/include/sys/stat.h /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/string.h \
+ /usr/include/bits/types/locale_t.h /usr/include/bits/types/__locale_t.h \
+ /usr/include/strings.h /usr/include/assert.h /usr/include/inttypes.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.h \
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/bf16.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/build.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/build.make
new file mode 100644
index 0000000000000000000000000000000000000000..e671c71cf4208f397b94b4500e5fc7f32c8117f7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/build.make
@@ -0,0 +1,130 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+# Include any dependencies generated for this target.
+include mlx/io/CMakeFiles/gguflib.dir/depend.make
+# Include any dependencies generated by the compiler for this target.
+include mlx/io/CMakeFiles/gguflib.dir/compiler_depend.make
+
+# Include the progress variables for this target.
+include mlx/io/CMakeFiles/gguflib.dir/progress.make
+
+# Include the compile flags for this target's objects.
+include mlx/io/CMakeFiles/gguflib.dir/flags.make
+
+mlx/io/CMakeFiles/gguflib.dir/codegen:
+.PHONY : mlx/io/CMakeFiles/gguflib.dir/codegen
+
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o: mlx/io/CMakeFiles/gguflib.dir/flags.make
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o: _deps/gguflib-src/fp16.c
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o: mlx/io/CMakeFiles/gguflib.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building C object mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io && /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -MD -MT mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o -MF CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o.d -o CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.c
+
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing C source to CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io && /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.c > CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.i
+
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling C source to assembly CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io && /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.c -o CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.s
+
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o: mlx/io/CMakeFiles/gguflib.dir/flags.make
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o: _deps/gguflib-src/gguflib.c
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o: mlx/io/CMakeFiles/gguflib.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building C object mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io && /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -MD -MT mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o -MF CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o.d -o CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.c
+
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing C source to CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io && /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.c > CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.i
+
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling C source to assembly CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io && /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.c -o CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.s
+
+# Object files for target gguflib
+gguflib_OBJECTS = \
+"CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o" \
+"CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o"
+
+# External object files for target gguflib
+gguflib_EXTERNAL_OBJECTS =
+
+mlx/io/libgguflib.a: mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o
+mlx/io/libgguflib.a: mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o
+mlx/io/libgguflib.a: mlx/io/CMakeFiles/gguflib.dir/build.make
+mlx/io/libgguflib.a: mlx/io/CMakeFiles/gguflib.dir/link.txt
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Linking C static library libgguflib.a"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io && $(CMAKE_COMMAND) -P CMakeFiles/gguflib.dir/cmake_clean_target.cmake
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/gguflib.dir/link.txt --verbose=$(VERBOSE)
+
+# Rule to build all files generated by this target.
+mlx/io/CMakeFiles/gguflib.dir/build: mlx/io/libgguflib.a
+.PHONY : mlx/io/CMakeFiles/gguflib.dir/build
+
+mlx/io/CMakeFiles/gguflib.dir/clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io && $(CMAKE_COMMAND) -P CMakeFiles/gguflib.dir/cmake_clean.cmake
+.PHONY : mlx/io/CMakeFiles/gguflib.dir/clean
+
+mlx/io/CMakeFiles/gguflib.dir/depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/DependInfo.cmake "--color=$(COLOR)"
+.PHONY : mlx/io/CMakeFiles/gguflib.dir/depend
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/cmake_clean.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/cmake_clean.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..70edf2ecca4067c475553c6bd29a6779629b33bf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/cmake_clean.cmake
@@ -0,0 +1,13 @@
+file(REMOVE_RECURSE
+  "CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o"
+  "CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o.d"
+  "CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o"
+  "CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o.d"
+  "libgguflib.a"
+  "libgguflib.pdb"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang C)
+  include(CMakeFiles/gguflib.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/cmake_clean_target.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/cmake_clean_target.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..59df74259b571921b6e87200724227cc29d83a91
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/cmake_clean_target.cmake
@@ -0,0 +1,3 @@
+file(REMOVE_RECURSE
+  "libgguflib.a"
+)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/compiler_depend.internal b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/compiler_depend.internal
new file mode 100644
index 0000000000000000000000000000000000000000..bf113ebd204bab763fccb32a8f2057d62aad370b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/compiler_depend.internal
@@ -0,0 +1,118 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.c
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/flt-eval-method.h
+ /usr/include/bits/fp-fast.h
+ /usr/include/bits/fp-logb.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/libm-simd-decl-stubs.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/math-vector.h
+ /usr/include/bits/mathcalls-helper-functions.h
+ /usr/include/bits/mathcalls.h
+ /usr/include/bits/mathinline.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/types.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/math.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/sys/cdefs.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.c
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/bf16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/fp16.h
+ /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/_deps/gguflib-src/gguflib.h
+ /usr/include/alloca.h
+ /usr/include/asm-generic/errno-base.h
+ /usr/include/asm-generic/errno.h
+ /usr/include/asm/errno.h
+ /usr/include/assert.h
+ /usr/include/bits/byteswap.h
+ /usr/include/bits/confname.h
+ /usr/include/bits/endian.h
+ /usr/include/bits/environments.h
+ /usr/include/bits/errno.h
+ /usr/include/bits/fcntl-linux.h
+ /usr/include/bits/fcntl.h
+ /usr/include/bits/floatn-common.h
+ /usr/include/bits/floatn.h
+ /usr/include/bits/getopt_core.h
+ /usr/include/bits/getopt_posix.h
+ /usr/include/bits/libc-header-start.h
+ /usr/include/bits/long-double.h
+ /usr/include/bits/mman-linux.h
+ /usr/include/bits/mman-shared.h
+ /usr/include/bits/mman.h
+ /usr/include/bits/posix_opt.h
+ /usr/include/bits/pthreadtypes-arch.h
+ /usr/include/bits/pthreadtypes.h
+ /usr/include/bits/select.h
+ /usr/include/bits/stat.h
+ /usr/include/bits/stdint-intn.h
+ /usr/include/bits/stdint-uintn.h
+ /usr/include/bits/stdio.h
+ /usr/include/bits/stdio_lim.h
+ /usr/include/bits/stdlib-bsearch.h
+ /usr/include/bits/stdlib-float.h
+ /usr/include/bits/sys_errlist.h
+ /usr/include/bits/thread-shared-types.h
+ /usr/include/bits/types.h
+ /usr/include/bits/types/FILE.h
+ /usr/include/bits/types/__FILE.h
+ /usr/include/bits/types/__fpos64_t.h
+ /usr/include/bits/types/__fpos_t.h
+ /usr/include/bits/types/__locale_t.h
+ /usr/include/bits/types/__mbstate_t.h
+ /usr/include/bits/types/__sigset_t.h
+ /usr/include/bits/types/clock_t.h
+ /usr/include/bits/types/clockid_t.h
+ /usr/include/bits/types/locale_t.h
+ /usr/include/bits/types/sigset_t.h
+ /usr/include/bits/types/struct_FILE.h
+ /usr/include/bits/types/struct_timespec.h
+ /usr/include/bits/types/struct_timeval.h
+ /usr/include/bits/types/time_t.h
+ /usr/include/bits/types/timer_t.h
+ /usr/include/bits/typesizes.h
+ /usr/include/bits/uintn-identity.h
+ /usr/include/bits/waitflags.h
+ /usr/include/bits/waitstatus.h
+ /usr/include/bits/wchar.h
+ /usr/include/bits/wordsize.h
+ /usr/include/endian.h
+ /usr/include/errno.h
+ /usr/include/fcntl.h
+ /usr/include/features.h
+ /usr/include/gnu/stubs-64.h
+ /usr/include/gnu/stubs.h
+ /usr/include/inttypes.h
+ /usr/include/linux/errno.h
+ /usr/include/stdc-predef.h
+ /usr/include/stdint.h
+ /usr/include/stdio.h
+ /usr/include/stdlib.h
+ /usr/include/string.h
+ /usr/include/strings.h
+ /usr/include/sys/cdefs.h
+ /usr/include/sys/mman.h
+ /usr/include/sys/select.h
+ /usr/include/sys/stat.h
+ /usr/include/sys/types.h
+ /usr/include/unistd.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/compiler_depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/compiler_depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..81241a54ece6e2519b2ccb29e4e30d2484b5784b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/compiler_depend.make
@@ -0,0 +1,304 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o: _deps/gguflib-src/fp16.c \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/flt-eval-method.h \
+  /usr/include/bits/fp-fast.h \
+  /usr/include/bits/fp-logb.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/libm-simd-decl-stubs.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/math-vector.h \
+  /usr/include/bits/mathcalls-helper-functions.h \
+  /usr/include/bits/mathcalls.h \
+  /usr/include/bits/mathinline.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/math.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/sys/cdefs.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o: _deps/gguflib-src/gguflib.c \
+  _deps/gguflib-src/bf16.h \
+  _deps/gguflib-src/fp16.h \
+  _deps/gguflib-src/gguflib.h \
+  /usr/include/alloca.h \
+  /usr/include/asm-generic/errno-base.h \
+  /usr/include/asm-generic/errno.h \
+  /usr/include/asm/errno.h \
+  /usr/include/assert.h \
+  /usr/include/bits/byteswap.h \
+  /usr/include/bits/confname.h \
+  /usr/include/bits/endian.h \
+  /usr/include/bits/environments.h \
+  /usr/include/bits/errno.h \
+  /usr/include/bits/fcntl-linux.h \
+  /usr/include/bits/fcntl.h \
+  /usr/include/bits/floatn-common.h \
+  /usr/include/bits/floatn.h \
+  /usr/include/bits/getopt_core.h \
+  /usr/include/bits/getopt_posix.h \
+  /usr/include/bits/libc-header-start.h \
+  /usr/include/bits/long-double.h \
+  /usr/include/bits/mman-linux.h \
+  /usr/include/bits/mman-shared.h \
+  /usr/include/bits/mman.h \
+  /usr/include/bits/posix_opt.h \
+  /usr/include/bits/pthreadtypes-arch.h \
+  /usr/include/bits/pthreadtypes.h \
+  /usr/include/bits/select.h \
+  /usr/include/bits/stat.h \
+  /usr/include/bits/stdint-intn.h \
+  /usr/include/bits/stdint-uintn.h \
+  /usr/include/bits/stdio.h \
+  /usr/include/bits/stdio_lim.h \
+  /usr/include/bits/stdlib-bsearch.h \
+  /usr/include/bits/stdlib-float.h \
+  /usr/include/bits/sys_errlist.h \
+  /usr/include/bits/thread-shared-types.h \
+  /usr/include/bits/types.h \
+  /usr/include/bits/types/FILE.h \
+  /usr/include/bits/types/__FILE.h \
+  /usr/include/bits/types/__fpos64_t.h \
+  /usr/include/bits/types/__fpos_t.h \
+  /usr/include/bits/types/__locale_t.h \
+  /usr/include/bits/types/__mbstate_t.h \
+  /usr/include/bits/types/__sigset_t.h \
+  /usr/include/bits/types/clock_t.h \
+  /usr/include/bits/types/clockid_t.h \
+  /usr/include/bits/types/locale_t.h \
+  /usr/include/bits/types/sigset_t.h \
+  /usr/include/bits/types/struct_FILE.h \
+  /usr/include/bits/types/struct_timespec.h \
+  /usr/include/bits/types/struct_timeval.h \
+  /usr/include/bits/types/time_t.h \
+  /usr/include/bits/types/timer_t.h \
+  /usr/include/bits/typesizes.h \
+  /usr/include/bits/uintn-identity.h \
+  /usr/include/bits/waitflags.h \
+  /usr/include/bits/waitstatus.h \
+  /usr/include/bits/wchar.h \
+  /usr/include/bits/wordsize.h \
+  /usr/include/endian.h \
+  /usr/include/errno.h \
+  /usr/include/fcntl.h \
+  /usr/include/features.h \
+  /usr/include/gnu/stubs-64.h \
+  /usr/include/gnu/stubs.h \
+  /usr/include/inttypes.h \
+  /usr/include/linux/errno.h \
+  /usr/include/stdc-predef.h \
+  /usr/include/stdint.h \
+  /usr/include/stdio.h \
+  /usr/include/stdlib.h \
+  /usr/include/string.h \
+  /usr/include/strings.h \
+  /usr/include/sys/cdefs.h \
+  /usr/include/sys/mman.h \
+  /usr/include/sys/select.h \
+  /usr/include/sys/stat.h \
+  /usr/include/sys/types.h \
+  /usr/include/unistd.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+  /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h
+
+
+/usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h:
+
+/usr/include/unistd.h:
+
+/usr/include/sys/stat.h:
+
+/usr/include/sys/mman.h:
+
+/usr/include/strings.h:
+
+/usr/include/string.h:
+
+/usr/include/linux/errno.h:
+
+/usr/include/fcntl.h:
+
+/usr/include/endian.h:
+
+/usr/include/alloca.h:
+
+/usr/include/asm-generic/errno-base.h:
+
+_deps/gguflib-src/bf16.h:
+
+/usr/include/bits/libm-simd-decl-stubs.h:
+
+/usr/include/stdc-predef.h:
+
+/usr/include/bits/stat.h:
+
+/usr/include/asm-generic/errno.h:
+
+/usr/include/bits/math-vector.h:
+
+/usr/include/bits/endian.h:
+
+/usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h:
+
+/usr/include/asm/errno.h:
+
+_deps/gguflib-src/gguflib.h:
+
+/usr/include/stdlib.h:
+
+/usr/include/bits/typesizes.h:
+
+/usr/include/stdio.h:
+
+_deps/gguflib-src/fp16.c:
+
+/usr/include/bits/types/struct_FILE.h:
+
+/usr/include/bits/getopt_posix.h:
+
+/usr/include/gnu/stubs-64.h:
+
+/usr/include/bits/select.h:
+
+/usr/include/bits/long-double.h:
+
+_deps/gguflib-src/fp16.h:
+
+/usr/include/bits/wchar.h:
+
+/usr/include/math.h:
+
+/usr/include/bits/fp-fast.h:
+
+/usr/include/bits/fcntl.h:
+
+_deps/gguflib-src/gguflib.c:
+
+/usr/include/bits/mathinline.h:
+
+/usr/include/bits/floatn.h:
+
+/usr/include/bits/floatn-common.h:
+
+/usr/include/sys/cdefs.h:
+
+/usr/include/inttypes.h:
+
+/usr/include/bits/types/sigset_t.h:
+
+/usr/include/gnu/stubs.h:
+
+/usr/include/bits/wordsize.h:
+
+/usr/include/bits/mathcalls-helper-functions.h:
+
+/usr/include/bits/libc-header-start.h:
+
+/usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h:
+
+/usr/include/bits/getopt_core.h:
+
+/usr/include/bits/types/time_t.h:
+
+/usr/include/bits/uintn-identity.h:
+
+/usr/include/bits/flt-eval-method.h:
+
+/usr/include/stdint.h:
+
+/usr/include/bits/mathcalls.h:
+
+/usr/include/bits/stdint-intn.h:
+
+/usr/include/bits/types/clock_t.h:
+
+/usr/include/bits/waitstatus.h:
+
+/usr/include/bits/types.h:
+
+/usr/include/bits/stdlib-bsearch.h:
+
+/usr/include/bits/confname.h:
+
+/usr/include/bits/stdint-uintn.h:
+
+/usr/include/bits/mman.h:
+
+/usr/include/bits/mman-shared.h:
+
+/usr/include/bits/fcntl-linux.h:
+
+/usr/include/bits/mman-linux.h:
+
+/usr/include/bits/environments.h:
+
+/usr/include/bits/pthreadtypes-arch.h:
+
+/usr/include/bits/fp-logb.h:
+
+/usr/include/bits/stdio.h:
+
+/usr/include/errno.h:
+
+/usr/include/bits/pthreadtypes.h:
+
+/usr/include/bits/sys_errlist.h:
+
+/usr/include/bits/stdio_lim.h:
+
+/usr/include/bits/types/FILE.h:
+
+/usr/include/bits/stdlib-float.h:
+
+/usr/include/bits/thread-shared-types.h:
+
+/usr/include/sys/types.h:
+
+/usr/include/features.h:
+
+/usr/include/bits/types/__fpos64_t.h:
+
+/usr/include/bits/types/__FILE.h:
+
+/usr/include/bits/errno.h:
+
+/usr/include/bits/types/__fpos_t.h:
+
+/usr/include/bits/types/__locale_t.h:
+
+/usr/include/bits/types/__sigset_t.h:
+
+/usr/include/bits/types/clockid_t.h:
+
+/usr/include/bits/posix_opt.h:
+
+/usr/include/bits/types/locale_t.h:
+
+/usr/include/bits/types/struct_timespec.h:
+
+/usr/include/assert.h:
+
+/usr/include/bits/byteswap.h:
+
+/usr/include/bits/types/__mbstate_t.h:
+
+/usr/include/bits/types/struct_timeval.h:
+
+/usr/include/bits/waitflags.h:
+
+/usr/include/sys/select.h:
+
+/usr/include/bits/types/timer_t.h:
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/compiler_depend.ts b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/compiler_depend.ts
new file mode 100644
index 0000000000000000000000000000000000000000..013384546e7882351ae4045bf11a23c7339a3776
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/compiler_depend.ts
@@ -0,0 +1,2 @@
+# CMAKE generated file: DO NOT EDIT!
+# Timestamp file for compiler generated dependencies management for gguflib.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..3fc406d2a494da69b117e34594e0c7ca0f77a007
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/depend.make
@@ -0,0 +1,2 @@
+# Empty dependencies file for gguflib.
+# This may be replaced when dependencies are built.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/flags.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/flags.make
new file mode 100644
index 0000000000000000000000000000000000000000..bd44775447552c0c9e344b65f5873c8fd3275096
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/flags.make
@@ -0,0 +1,10 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# compile C with /usr/bin/cc
+C_DEFINES = 
+
+C_INCLUDES = 
+
+C_FLAGS = -O3 -DNDEBUG -fPIC
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/link.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/link.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7d67c9d16bc11c9a7d366978268e2d8199cc7865
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/link.txt
@@ -0,0 +1,2 @@
+/usr/bin/ar qc libgguflib.a "CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o" "CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o"
+/usr/bin/ranlib libgguflib.a
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/progress.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/progress.make
new file mode 100644
index 0000000000000000000000000000000000000000..6df05a82f56b4fec1542bcd7898ac05fb4dcb77a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/gguflib.dir/progress.make
@@ -0,0 +1,4 @@
+CMAKE_PROGRESS_1 = 23
+CMAKE_PROGRESS_2 = 
+CMAKE_PROGRESS_3 = 24
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..0cfbf08886fca9a91cb753ec8734c84fcbe52c9f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+2
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..334575ef307b7dd61f9e90123f412c1662197caf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/Makefile
@@ -0,0 +1,258 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\" \"headers\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io//CMakeFiles/progress.marks
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/io/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/io/clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/io/preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/io/preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+# Convenience name for target.
+mlx/io/CMakeFiles/gguflib.dir/rule:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 mlx/io/CMakeFiles/gguflib.dir/rule
+.PHONY : mlx/io/CMakeFiles/gguflib.dir/rule
+
+# Convenience name for target.
+gguflib: mlx/io/CMakeFiles/gguflib.dir/rule
+.PHONY : gguflib
+
+# fast build rule for target.
+gguflib/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f mlx/io/CMakeFiles/gguflib.dir/build.make mlx/io/CMakeFiles/gguflib.dir/build
+.PHONY : gguflib/fast
+
+__/__/_deps/gguflib-src/fp16.o: __/__/_deps/gguflib-src/fp16.c.o
+.PHONY : __/__/_deps/gguflib-src/fp16.o
+
+# target to build an object file
+__/__/_deps/gguflib-src/fp16.c.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f mlx/io/CMakeFiles/gguflib.dir/build.make mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.o
+.PHONY : __/__/_deps/gguflib-src/fp16.c.o
+
+__/__/_deps/gguflib-src/fp16.i: __/__/_deps/gguflib-src/fp16.c.i
+.PHONY : __/__/_deps/gguflib-src/fp16.i
+
+# target to preprocess a source file
+__/__/_deps/gguflib-src/fp16.c.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f mlx/io/CMakeFiles/gguflib.dir/build.make mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.i
+.PHONY : __/__/_deps/gguflib-src/fp16.c.i
+
+__/__/_deps/gguflib-src/fp16.s: __/__/_deps/gguflib-src/fp16.c.s
+.PHONY : __/__/_deps/gguflib-src/fp16.s
+
+# target to generate assembly for a file
+__/__/_deps/gguflib-src/fp16.c.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f mlx/io/CMakeFiles/gguflib.dir/build.make mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/fp16.c.s
+.PHONY : __/__/_deps/gguflib-src/fp16.c.s
+
+__/__/_deps/gguflib-src/gguflib.o: __/__/_deps/gguflib-src/gguflib.c.o
+.PHONY : __/__/_deps/gguflib-src/gguflib.o
+
+# target to build an object file
+__/__/_deps/gguflib-src/gguflib.c.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f mlx/io/CMakeFiles/gguflib.dir/build.make mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.o
+.PHONY : __/__/_deps/gguflib-src/gguflib.c.o
+
+__/__/_deps/gguflib-src/gguflib.i: __/__/_deps/gguflib-src/gguflib.c.i
+.PHONY : __/__/_deps/gguflib-src/gguflib.i
+
+# target to preprocess a source file
+__/__/_deps/gguflib-src/gguflib.c.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f mlx/io/CMakeFiles/gguflib.dir/build.make mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.i
+.PHONY : __/__/_deps/gguflib-src/gguflib.c.i
+
+__/__/_deps/gguflib-src/gguflib.s: __/__/_deps/gguflib-src/gguflib.c.s
+.PHONY : __/__/_deps/gguflib-src/gguflib.s
+
+# target to generate assembly for a file
+__/__/_deps/gguflib-src/gguflib.c.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f mlx/io/CMakeFiles/gguflib.dir/build.make mlx/io/CMakeFiles/gguflib.dir/__/__/_deps/gguflib-src/gguflib.c.s
+.PHONY : __/__/_deps/gguflib-src/gguflib.c.s
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+	@echo "... gguflib"
+	@echo "... __/__/_deps/gguflib-src/fp16.o"
+	@echo "... __/__/_deps/gguflib-src/fp16.i"
+	@echo "... __/__/_deps/gguflib-src/fp16.s"
+	@echo "... __/__/_deps/gguflib-src/gguflib.o"
+	@echo "... __/__/_deps/gguflib-src/gguflib.i"
+	@echo "... __/__/_deps/gguflib-src/gguflib.s"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ec572a72393eeec8a2da39c422f63c9ccbcd8844
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/cmake_install.cmake
@@ -0,0 +1,50 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/mlx/io
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/libgguflib.a b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/libgguflib.a
new file mode 100644
index 0000000000000000000000000000000000000000..02ace1af6bec973b85807340e88f533792a68397
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/mlx/io/libgguflib.a differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/CMakeDirectoryInformation.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/CMakeDirectoryInformation.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..1aeb9de92640e91b3d38364ee7a569cd8b862951
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/CMakeDirectoryInformation.cmake
@@ -0,0 +1,16 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Relative path conversion top directories.
+set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx")
+set(CMAKE_RELATIVE_PATH_TOP_BINARY "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core")
+
+# Force unix paths in dependencies.
+set(CMAKE_FORCE_UNIX_PATHS 1)
+
+
+# The C and CXX include file regular expressions for this directory.
+set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
+set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
+set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
+set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/DependInfo.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/DependInfo.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..aa8556eed6384e13f18e101bb30eefa190a90bd6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/DependInfo.cmake
@@ -0,0 +1,44 @@
+
+# Consider dependencies only in project.
+set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
+
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  )
+
+# The set of dependency files which are needed:
+set(CMAKE_DEPENDS_DEPENDENCY_FILES
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/array.cpp" "python/src/CMakeFiles/core.dir/array.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/array.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/constants.cpp" "python/src/CMakeFiles/core.dir/constants.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/constants.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/convert.cpp" "python/src/CMakeFiles/core.dir/convert.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/convert.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/cuda.cpp" "python/src/CMakeFiles/core.dir/cuda.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/cuda.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/device.cpp" "python/src/CMakeFiles/core.dir/device.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/device.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/distributed.cpp" "python/src/CMakeFiles/core.dir/distributed.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/distributed.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/export.cpp" "python/src/CMakeFiles/core.dir/export.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/export.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fast.cpp" "python/src/CMakeFiles/core.dir/fast.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/fast.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fft.cpp" "python/src/CMakeFiles/core.dir/fft.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/fft.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/indexing.cpp" "python/src/CMakeFiles/core.dir/indexing.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/indexing.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/linalg.cpp" "python/src/CMakeFiles/core.dir/linalg.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/linalg.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/load.cpp" "python/src/CMakeFiles/core.dir/load.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/load.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/memory.cpp" "python/src/CMakeFiles/core.dir/memory.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/memory.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/metal.cpp" "python/src/CMakeFiles/core.dir/metal.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/metal.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx.cpp" "python/src/CMakeFiles/core.dir/mlx.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/mlx.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx_func.cpp" "python/src/CMakeFiles/core.dir/mlx_func.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/mlx_func.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/ops.cpp" "python/src/CMakeFiles/core.dir/ops.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/ops.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/random.cpp" "python/src/CMakeFiles/core.dir/random.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/random.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/stream.cpp" "python/src/CMakeFiles/core.dir/stream.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/stream.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/transforms.cpp" "python/src/CMakeFiles/core.dir/transforms.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/transforms.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/trees.cpp" "python/src/CMakeFiles/core.dir/trees.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/trees.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/utils.cpp" "python/src/CMakeFiles/core.dir/utils.cpp.o" "gcc" "python/src/CMakeFiles/core.dir/utils.cpp.o.d"
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/build.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/build.make
new file mode 100644
index 0000000000000000000000000000000000000000..667cd121a11a9ff506c1578d88856ebd7efc6174
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/build.make
@@ -0,0 +1,451 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+# Include any dependencies generated for this target.
+include python/src/CMakeFiles/core.dir/depend.make
+# Include any dependencies generated by the compiler for this target.
+include python/src/CMakeFiles/core.dir/compiler_depend.make
+
+# Include the progress variables for this target.
+include python/src/CMakeFiles/core.dir/progress.make
+
+# Include the compile flags for this target's objects.
+include python/src/CMakeFiles/core.dir/flags.make
+
+python/src/CMakeFiles/core.dir/codegen:
+.PHONY : python/src/CMakeFiles/core.dir/codegen
+
+python/src/CMakeFiles/core.dir/mlx.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/mlx.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx.cpp
+python/src/CMakeFiles/core.dir/mlx.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object python/src/CMakeFiles/core.dir/mlx.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/mlx.cpp.o -MF CMakeFiles/core.dir/mlx.cpp.o.d -o CMakeFiles/core.dir/mlx.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx.cpp
+
+python/src/CMakeFiles/core.dir/mlx.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/mlx.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx.cpp > CMakeFiles/core.dir/mlx.cpp.i
+
+python/src/CMakeFiles/core.dir/mlx.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/mlx.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx.cpp -o CMakeFiles/core.dir/mlx.cpp.s
+
+python/src/CMakeFiles/core.dir/array.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/array.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/array.cpp
+python/src/CMakeFiles/core.dir/array.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object python/src/CMakeFiles/core.dir/array.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/array.cpp.o -MF CMakeFiles/core.dir/array.cpp.o.d -o CMakeFiles/core.dir/array.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/array.cpp
+
+python/src/CMakeFiles/core.dir/array.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/array.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/array.cpp > CMakeFiles/core.dir/array.cpp.i
+
+python/src/CMakeFiles/core.dir/array.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/array.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/array.cpp -o CMakeFiles/core.dir/array.cpp.s
+
+python/src/CMakeFiles/core.dir/convert.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/convert.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/convert.cpp
+python/src/CMakeFiles/core.dir/convert.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object python/src/CMakeFiles/core.dir/convert.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/convert.cpp.o -MF CMakeFiles/core.dir/convert.cpp.o.d -o CMakeFiles/core.dir/convert.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/convert.cpp
+
+python/src/CMakeFiles/core.dir/convert.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/convert.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/convert.cpp > CMakeFiles/core.dir/convert.cpp.i
+
+python/src/CMakeFiles/core.dir/convert.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/convert.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/convert.cpp -o CMakeFiles/core.dir/convert.cpp.s
+
+python/src/CMakeFiles/core.dir/device.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/device.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/device.cpp
+python/src/CMakeFiles/core.dir/device.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Building CXX object python/src/CMakeFiles/core.dir/device.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/device.cpp.o -MF CMakeFiles/core.dir/device.cpp.o.d -o CMakeFiles/core.dir/device.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/device.cpp
+
+python/src/CMakeFiles/core.dir/device.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/device.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/device.cpp > CMakeFiles/core.dir/device.cpp.i
+
+python/src/CMakeFiles/core.dir/device.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/device.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/device.cpp -o CMakeFiles/core.dir/device.cpp.s
+
+python/src/CMakeFiles/core.dir/distributed.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/distributed.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/distributed.cpp
+python/src/CMakeFiles/core.dir/distributed.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "Building CXX object python/src/CMakeFiles/core.dir/distributed.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/distributed.cpp.o -MF CMakeFiles/core.dir/distributed.cpp.o.d -o CMakeFiles/core.dir/distributed.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/distributed.cpp
+
+python/src/CMakeFiles/core.dir/distributed.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/distributed.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/distributed.cpp > CMakeFiles/core.dir/distributed.cpp.i
+
+python/src/CMakeFiles/core.dir/distributed.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/distributed.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/distributed.cpp -o CMakeFiles/core.dir/distributed.cpp.s
+
+python/src/CMakeFiles/core.dir/export.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/export.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/export.cpp
+python/src/CMakeFiles/core.dir/export.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_6) "Building CXX object python/src/CMakeFiles/core.dir/export.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/export.cpp.o -MF CMakeFiles/core.dir/export.cpp.o.d -o CMakeFiles/core.dir/export.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/export.cpp
+
+python/src/CMakeFiles/core.dir/export.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/export.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/export.cpp > CMakeFiles/core.dir/export.cpp.i
+
+python/src/CMakeFiles/core.dir/export.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/export.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/export.cpp -o CMakeFiles/core.dir/export.cpp.s
+
+python/src/CMakeFiles/core.dir/fast.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/fast.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fast.cpp
+python/src/CMakeFiles/core.dir/fast.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_7) "Building CXX object python/src/CMakeFiles/core.dir/fast.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/fast.cpp.o -MF CMakeFiles/core.dir/fast.cpp.o.d -o CMakeFiles/core.dir/fast.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fast.cpp
+
+python/src/CMakeFiles/core.dir/fast.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/fast.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fast.cpp > CMakeFiles/core.dir/fast.cpp.i
+
+python/src/CMakeFiles/core.dir/fast.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/fast.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fast.cpp -o CMakeFiles/core.dir/fast.cpp.s
+
+python/src/CMakeFiles/core.dir/fft.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/fft.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fft.cpp
+python/src/CMakeFiles/core.dir/fft.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_8) "Building CXX object python/src/CMakeFiles/core.dir/fft.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/fft.cpp.o -MF CMakeFiles/core.dir/fft.cpp.o.d -o CMakeFiles/core.dir/fft.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fft.cpp
+
+python/src/CMakeFiles/core.dir/fft.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/fft.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fft.cpp > CMakeFiles/core.dir/fft.cpp.i
+
+python/src/CMakeFiles/core.dir/fft.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/fft.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/fft.cpp -o CMakeFiles/core.dir/fft.cpp.s
+
+python/src/CMakeFiles/core.dir/indexing.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/indexing.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/indexing.cpp
+python/src/CMakeFiles/core.dir/indexing.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_9) "Building CXX object python/src/CMakeFiles/core.dir/indexing.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/indexing.cpp.o -MF CMakeFiles/core.dir/indexing.cpp.o.d -o CMakeFiles/core.dir/indexing.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/indexing.cpp
+
+python/src/CMakeFiles/core.dir/indexing.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/indexing.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/indexing.cpp > CMakeFiles/core.dir/indexing.cpp.i
+
+python/src/CMakeFiles/core.dir/indexing.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/indexing.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/indexing.cpp -o CMakeFiles/core.dir/indexing.cpp.s
+
+python/src/CMakeFiles/core.dir/load.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/load.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/load.cpp
+python/src/CMakeFiles/core.dir/load.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_10) "Building CXX object python/src/CMakeFiles/core.dir/load.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/load.cpp.o -MF CMakeFiles/core.dir/load.cpp.o.d -o CMakeFiles/core.dir/load.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/load.cpp
+
+python/src/CMakeFiles/core.dir/load.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/load.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/load.cpp > CMakeFiles/core.dir/load.cpp.i
+
+python/src/CMakeFiles/core.dir/load.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/load.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/load.cpp -o CMakeFiles/core.dir/load.cpp.s
+
+python/src/CMakeFiles/core.dir/metal.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/metal.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/metal.cpp
+python/src/CMakeFiles/core.dir/metal.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_11) "Building CXX object python/src/CMakeFiles/core.dir/metal.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/metal.cpp.o -MF CMakeFiles/core.dir/metal.cpp.o.d -o CMakeFiles/core.dir/metal.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/metal.cpp
+
+python/src/CMakeFiles/core.dir/metal.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/metal.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/metal.cpp > CMakeFiles/core.dir/metal.cpp.i
+
+python/src/CMakeFiles/core.dir/metal.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/metal.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/metal.cpp -o CMakeFiles/core.dir/metal.cpp.s
+
+python/src/CMakeFiles/core.dir/cuda.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/cuda.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/cuda.cpp
+python/src/CMakeFiles/core.dir/cuda.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_12) "Building CXX object python/src/CMakeFiles/core.dir/cuda.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/cuda.cpp.o -MF CMakeFiles/core.dir/cuda.cpp.o.d -o CMakeFiles/core.dir/cuda.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/cuda.cpp
+
+python/src/CMakeFiles/core.dir/cuda.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/cuda.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/cuda.cpp > CMakeFiles/core.dir/cuda.cpp.i
+
+python/src/CMakeFiles/core.dir/cuda.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/cuda.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/cuda.cpp -o CMakeFiles/core.dir/cuda.cpp.s
+
+python/src/CMakeFiles/core.dir/memory.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/memory.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/memory.cpp
+python/src/CMakeFiles/core.dir/memory.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_13) "Building CXX object python/src/CMakeFiles/core.dir/memory.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/memory.cpp.o -MF CMakeFiles/core.dir/memory.cpp.o.d -o CMakeFiles/core.dir/memory.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/memory.cpp
+
+python/src/CMakeFiles/core.dir/memory.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/memory.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/memory.cpp > CMakeFiles/core.dir/memory.cpp.i
+
+python/src/CMakeFiles/core.dir/memory.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/memory.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/memory.cpp -o CMakeFiles/core.dir/memory.cpp.s
+
+python/src/CMakeFiles/core.dir/mlx_func.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/mlx_func.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx_func.cpp
+python/src/CMakeFiles/core.dir/mlx_func.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_14) "Building CXX object python/src/CMakeFiles/core.dir/mlx_func.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/mlx_func.cpp.o -MF CMakeFiles/core.dir/mlx_func.cpp.o.d -o CMakeFiles/core.dir/mlx_func.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx_func.cpp
+
+python/src/CMakeFiles/core.dir/mlx_func.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/mlx_func.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx_func.cpp > CMakeFiles/core.dir/mlx_func.cpp.i
+
+python/src/CMakeFiles/core.dir/mlx_func.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/mlx_func.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/mlx_func.cpp -o CMakeFiles/core.dir/mlx_func.cpp.s
+
+python/src/CMakeFiles/core.dir/ops.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/ops.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/ops.cpp
+python/src/CMakeFiles/core.dir/ops.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_15) "Building CXX object python/src/CMakeFiles/core.dir/ops.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/ops.cpp.o -MF CMakeFiles/core.dir/ops.cpp.o.d -o CMakeFiles/core.dir/ops.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/ops.cpp
+
+python/src/CMakeFiles/core.dir/ops.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/ops.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/ops.cpp > CMakeFiles/core.dir/ops.cpp.i
+
+python/src/CMakeFiles/core.dir/ops.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/ops.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/ops.cpp -o CMakeFiles/core.dir/ops.cpp.s
+
+python/src/CMakeFiles/core.dir/stream.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/stream.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/stream.cpp
+python/src/CMakeFiles/core.dir/stream.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_16) "Building CXX object python/src/CMakeFiles/core.dir/stream.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/stream.cpp.o -MF CMakeFiles/core.dir/stream.cpp.o.d -o CMakeFiles/core.dir/stream.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/stream.cpp
+
+python/src/CMakeFiles/core.dir/stream.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/stream.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/stream.cpp > CMakeFiles/core.dir/stream.cpp.i
+
+python/src/CMakeFiles/core.dir/stream.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/stream.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/stream.cpp -o CMakeFiles/core.dir/stream.cpp.s
+
+python/src/CMakeFiles/core.dir/transforms.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/transforms.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/transforms.cpp
+python/src/CMakeFiles/core.dir/transforms.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_17) "Building CXX object python/src/CMakeFiles/core.dir/transforms.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/transforms.cpp.o -MF CMakeFiles/core.dir/transforms.cpp.o.d -o CMakeFiles/core.dir/transforms.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/transforms.cpp
+
+python/src/CMakeFiles/core.dir/transforms.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/transforms.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/transforms.cpp > CMakeFiles/core.dir/transforms.cpp.i
+
+python/src/CMakeFiles/core.dir/transforms.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/transforms.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/transforms.cpp -o CMakeFiles/core.dir/transforms.cpp.s
+
+python/src/CMakeFiles/core.dir/random.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/random.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/random.cpp
+python/src/CMakeFiles/core.dir/random.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_18) "Building CXX object python/src/CMakeFiles/core.dir/random.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/random.cpp.o -MF CMakeFiles/core.dir/random.cpp.o.d -o CMakeFiles/core.dir/random.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/random.cpp
+
+python/src/CMakeFiles/core.dir/random.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/random.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/random.cpp > CMakeFiles/core.dir/random.cpp.i
+
+python/src/CMakeFiles/core.dir/random.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/random.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/random.cpp -o CMakeFiles/core.dir/random.cpp.s
+
+python/src/CMakeFiles/core.dir/linalg.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/linalg.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/linalg.cpp
+python/src/CMakeFiles/core.dir/linalg.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_19) "Building CXX object python/src/CMakeFiles/core.dir/linalg.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/linalg.cpp.o -MF CMakeFiles/core.dir/linalg.cpp.o.d -o CMakeFiles/core.dir/linalg.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/linalg.cpp
+
+python/src/CMakeFiles/core.dir/linalg.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/linalg.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/linalg.cpp > CMakeFiles/core.dir/linalg.cpp.i
+
+python/src/CMakeFiles/core.dir/linalg.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/linalg.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/linalg.cpp -o CMakeFiles/core.dir/linalg.cpp.s
+
+python/src/CMakeFiles/core.dir/constants.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/constants.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/constants.cpp
+python/src/CMakeFiles/core.dir/constants.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_20) "Building CXX object python/src/CMakeFiles/core.dir/constants.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/constants.cpp.o -MF CMakeFiles/core.dir/constants.cpp.o.d -o CMakeFiles/core.dir/constants.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/constants.cpp
+
+python/src/CMakeFiles/core.dir/constants.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/constants.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/constants.cpp > CMakeFiles/core.dir/constants.cpp.i
+
+python/src/CMakeFiles/core.dir/constants.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/constants.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/constants.cpp -o CMakeFiles/core.dir/constants.cpp.s
+
+python/src/CMakeFiles/core.dir/trees.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/trees.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/trees.cpp
+python/src/CMakeFiles/core.dir/trees.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_21) "Building CXX object python/src/CMakeFiles/core.dir/trees.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/trees.cpp.o -MF CMakeFiles/core.dir/trees.cpp.o.d -o CMakeFiles/core.dir/trees.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/trees.cpp
+
+python/src/CMakeFiles/core.dir/trees.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/trees.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/trees.cpp > CMakeFiles/core.dir/trees.cpp.i
+
+python/src/CMakeFiles/core.dir/trees.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/trees.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/trees.cpp -o CMakeFiles/core.dir/trees.cpp.s
+
+python/src/CMakeFiles/core.dir/utils.cpp.o: python/src/CMakeFiles/core.dir/flags.make
+python/src/CMakeFiles/core.dir/utils.cpp.o: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/utils.cpp
+python/src/CMakeFiles/core.dir/utils.cpp.o: python/src/CMakeFiles/core.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_22) "Building CXX object python/src/CMakeFiles/core.dir/utils.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/core.dir/utils.cpp.o -MF CMakeFiles/core.dir/utils.cpp.o.d -o CMakeFiles/core.dir/utils.cpp.o -c /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/utils.cpp
+
+python/src/CMakeFiles/core.dir/utils.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/core.dir/utils.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/utils.cpp > CMakeFiles/core.dir/utils.cpp.i
+
+python/src/CMakeFiles/core.dir/utils.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/core.dir/utils.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src/utils.cpp -o CMakeFiles/core.dir/utils.cpp.s
+
+# Object files for target core
+core_OBJECTS = \
+"CMakeFiles/core.dir/mlx.cpp.o" \
+"CMakeFiles/core.dir/array.cpp.o" \
+"CMakeFiles/core.dir/convert.cpp.o" \
+"CMakeFiles/core.dir/device.cpp.o" \
+"CMakeFiles/core.dir/distributed.cpp.o" \
+"CMakeFiles/core.dir/export.cpp.o" \
+"CMakeFiles/core.dir/fast.cpp.o" \
+"CMakeFiles/core.dir/fft.cpp.o" \
+"CMakeFiles/core.dir/indexing.cpp.o" \
+"CMakeFiles/core.dir/load.cpp.o" \
+"CMakeFiles/core.dir/metal.cpp.o" \
+"CMakeFiles/core.dir/cuda.cpp.o" \
+"CMakeFiles/core.dir/memory.cpp.o" \
+"CMakeFiles/core.dir/mlx_func.cpp.o" \
+"CMakeFiles/core.dir/ops.cpp.o" \
+"CMakeFiles/core.dir/stream.cpp.o" \
+"CMakeFiles/core.dir/transforms.cpp.o" \
+"CMakeFiles/core.dir/random.cpp.o" \
+"CMakeFiles/core.dir/linalg.cpp.o" \
+"CMakeFiles/core.dir/constants.cpp.o" \
+"CMakeFiles/core.dir/trees.cpp.o" \
+"CMakeFiles/core.dir/utils.cpp.o"
+
+# External object files for target core
+core_EXTERNAL_OBJECTS =
+
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/mlx.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/array.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/convert.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/device.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/distributed.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/export.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/fast.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/fft.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/indexing.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/load.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/metal.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/cuda.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/memory.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/mlx_func.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/ops.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/stream.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/transforms.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/random.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/linalg.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/constants.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/trees.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/utils.cpp.o
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/build.make
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/libnanobind-static.a
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: libmlx.so
+/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so: python/src/CMakeFiles/core.dir/link.txt
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_23) "Linking CXX shared module /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/core.dir/link.txt --verbose=$(VERBOSE)
+
+# Rule to build all files generated by this target.
+python/src/CMakeFiles/core.dir/build: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so
+.PHONY : python/src/CMakeFiles/core.dir/build
+
+python/src/CMakeFiles/core.dir/clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && $(CMAKE_COMMAND) -P CMakeFiles/core.dir/cmake_clean.cmake
+.PHONY : python/src/CMakeFiles/core.dir/clean
+
+python/src/CMakeFiles/core.dir/depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/DependInfo.cmake "--color=$(COLOR)"
+.PHONY : python/src/CMakeFiles/core.dir/depend
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/cmake_clean.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/cmake_clean.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..a308124416f8132cf52bbe46af9f5767b682f416
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/cmake_clean.cmake
@@ -0,0 +1,53 @@
+file(REMOVE_RECURSE
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so"
+  "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.pdb"
+  "CMakeFiles/core.dir/array.cpp.o"
+  "CMakeFiles/core.dir/array.cpp.o.d"
+  "CMakeFiles/core.dir/constants.cpp.o"
+  "CMakeFiles/core.dir/constants.cpp.o.d"
+  "CMakeFiles/core.dir/convert.cpp.o"
+  "CMakeFiles/core.dir/convert.cpp.o.d"
+  "CMakeFiles/core.dir/cuda.cpp.o"
+  "CMakeFiles/core.dir/cuda.cpp.o.d"
+  "CMakeFiles/core.dir/device.cpp.o"
+  "CMakeFiles/core.dir/device.cpp.o.d"
+  "CMakeFiles/core.dir/distributed.cpp.o"
+  "CMakeFiles/core.dir/distributed.cpp.o.d"
+  "CMakeFiles/core.dir/export.cpp.o"
+  "CMakeFiles/core.dir/export.cpp.o.d"
+  "CMakeFiles/core.dir/fast.cpp.o"
+  "CMakeFiles/core.dir/fast.cpp.o.d"
+  "CMakeFiles/core.dir/fft.cpp.o"
+  "CMakeFiles/core.dir/fft.cpp.o.d"
+  "CMakeFiles/core.dir/indexing.cpp.o"
+  "CMakeFiles/core.dir/indexing.cpp.o.d"
+  "CMakeFiles/core.dir/linalg.cpp.o"
+  "CMakeFiles/core.dir/linalg.cpp.o.d"
+  "CMakeFiles/core.dir/load.cpp.o"
+  "CMakeFiles/core.dir/load.cpp.o.d"
+  "CMakeFiles/core.dir/memory.cpp.o"
+  "CMakeFiles/core.dir/memory.cpp.o.d"
+  "CMakeFiles/core.dir/metal.cpp.o"
+  "CMakeFiles/core.dir/metal.cpp.o.d"
+  "CMakeFiles/core.dir/mlx.cpp.o"
+  "CMakeFiles/core.dir/mlx.cpp.o.d"
+  "CMakeFiles/core.dir/mlx_func.cpp.o"
+  "CMakeFiles/core.dir/mlx_func.cpp.o.d"
+  "CMakeFiles/core.dir/ops.cpp.o"
+  "CMakeFiles/core.dir/ops.cpp.o.d"
+  "CMakeFiles/core.dir/random.cpp.o"
+  "CMakeFiles/core.dir/random.cpp.o.d"
+  "CMakeFiles/core.dir/stream.cpp.o"
+  "CMakeFiles/core.dir/stream.cpp.o.d"
+  "CMakeFiles/core.dir/transforms.cpp.o"
+  "CMakeFiles/core.dir/transforms.cpp.o.d"
+  "CMakeFiles/core.dir/trees.cpp.o"
+  "CMakeFiles/core.dir/trees.cpp.o.d"
+  "CMakeFiles/core.dir/utils.cpp.o"
+  "CMakeFiles/core.dir/utils.cpp.o.d"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang CXX)
+  include(CMakeFiles/core.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/compiler_depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/compiler_depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..e0483068e84e4f704aa4209024084a240f7bf706
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/compiler_depend.make
@@ -0,0 +1,2 @@
+# Empty compiler generated dependencies file for core.
+# This may be replaced when dependencies are built.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/compiler_depend.ts b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/compiler_depend.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6d3a0200a5fe76d5f32c64f27458111e4d56eddd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/compiler_depend.ts
@@ -0,0 +1,2 @@
+# CMAKE generated file: DO NOT EDIT!
+# Timestamp file for compiler generated dependencies management for core.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..e89a2a3e96284c6c376d1e048309462cca2dd216
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/depend.make
@@ -0,0 +1,2 @@
+# Empty dependencies file for core.
+# This may be replaced when dependencies are built.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/flags.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/flags.make
new file mode 100644
index 0000000000000000000000000000000000000000..7757a95e269055ea3752e1026a69f6eb12af08ef
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/flags.make
@@ -0,0 +1,10 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# compile CXX with /usr/bin/c++
+CXX_DEFINES = -DNB_DOMAIN=mlx -Dcore_EXPORTS
+
+CXX_INCLUDES = -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include -I/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+CXX_FLAGS = -O3 -DNDEBUG -std=gnu++17 -flto -fno-fat-lto-objects -fPIC -fvisibility=hidden -fno-stack-protector -ffunction-sections -fdata-sections
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/link.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/link.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c1d19af7e4f6de1c1c5a005401f9ee338f984470
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/link.txt
@@ -0,0 +1 @@
+/usr/bin/c++ -fPIC -O3 -DNDEBUG -flto -fno-fat-lto-objects -Wl,-s "-Wl,-rpath,\$ORIGIN/lib" -Wl,--gc-sections -shared  -o /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx/core.cpython-310-x86_64-linux-gnu.so CMakeFiles/core.dir/mlx.cpp.o CMakeFiles/core.dir/array.cpp.o CMakeFiles/core.dir/convert.cpp.o CMakeFiles/core.dir/device.cpp.o CMakeFiles/core.dir/distributed.cpp.o CMakeFiles/core.dir/export.cpp.o CMakeFiles/core.dir/fast.cpp.o CMakeFiles/core.dir/fft.cpp.o CMakeFiles/core.dir/indexing.cpp.o CMakeFiles/core.dir/load.cpp.o CMakeFiles/core.dir/metal.cpp.o CMakeFiles/core.dir/cuda.cpp.o CMakeFiles/core.dir/memory.cpp.o CMakeFiles/core.dir/mlx_func.cpp.o CMakeFiles/core.dir/ops.cpp.o CMakeFiles/core.dir/stream.cpp.o CMakeFiles/core.dir/transforms.cpp.o CMakeFiles/core.dir/random.cpp.o CMakeFiles/core.dir/linalg.cpp.o CMakeFiles/core.dir/constants.cpp.o CMakeFiles/core.dir/trees.cpp.o CMakeFiles/core.dir/utils.cpp.o  -Wl,-rpath,/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core libnanobind-static.a ../../libmlx.so
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/progress.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/progress.make
new file mode 100644
index 0000000000000000000000000000000000000000..182103427dd4406c09ee20e590f53090adc2bc96
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/core.dir/progress.make
@@ -0,0 +1,24 @@
+CMAKE_PROGRESS_1 = 
+CMAKE_PROGRESS_2 = 1
+CMAKE_PROGRESS_3 = 2
+CMAKE_PROGRESS_4 = 3
+CMAKE_PROGRESS_5 = 4
+CMAKE_PROGRESS_6 = 
+CMAKE_PROGRESS_7 = 5
+CMAKE_PROGRESS_8 = 6
+CMAKE_PROGRESS_9 = 7
+CMAKE_PROGRESS_10 = 8
+CMAKE_PROGRESS_11 = 9
+CMAKE_PROGRESS_12 = 
+CMAKE_PROGRESS_13 = 10
+CMAKE_PROGRESS_14 = 11
+CMAKE_PROGRESS_15 = 12
+CMAKE_PROGRESS_16 = 13
+CMAKE_PROGRESS_17 = 14
+CMAKE_PROGRESS_18 = 
+CMAKE_PROGRESS_19 = 15
+CMAKE_PROGRESS_20 = 16
+CMAKE_PROGRESS_21 = 17
+CMAKE_PROGRESS_22 = 18
+CMAKE_PROGRESS_23 = 19
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/DependInfo.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/DependInfo.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..28616a513f36a130e42e50bb041d0e22c5ffb42d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/DependInfo.cmake
@@ -0,0 +1,32 @@
+
+# Consider dependencies only in project.
+set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
+
+# The set of languages for which implicit dependencies are needed:
+set(CMAKE_DEPENDS_LANGUAGES
+  )
+
+# The set of dependency files which are needed:
+set(CMAKE_DEPENDS_DEPENDENCY_FILES
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o" "gcc" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o" "gcc" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o" "gcc" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o" "gcc" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o" "gcc" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o" "gcc" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o" "gcc" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o" "gcc" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o" "gcc" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o.d"
+  "/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o" "gcc" "python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o.d"
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
+  )
+
+# Targets to which this target links which contain Fortran sources.
+set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
+  )
+
+# Fortran module output directory.
+set(CMAKE_Fortran_TARGET_MODULE_DIR "")
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/build.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/build.make
new file mode 100644
index 0000000000000000000000000000000000000000..91b18f4b38a561dc749628f2ea026587c6de8166
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/build.make
@@ -0,0 +1,258 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Delete rule output on recipe failure.
+.DELETE_ON_ERROR:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+# Include any dependencies generated for this target.
+include python/src/CMakeFiles/nanobind-static.dir/depend.make
+# Include any dependencies generated by the compiler for this target.
+include python/src/CMakeFiles/nanobind-static.dir/compiler_depend.make
+
+# Include the progress variables for this target.
+include python/src/CMakeFiles/nanobind-static.dir/progress.make
+
+# Include the compile flags for this target's objects.
+include python/src/CMakeFiles/nanobind-static.dir/flags.make
+
+python/src/CMakeFiles/nanobind-static.dir/codegen:
+.PHONY : python/src/CMakeFiles/nanobind-static.dir/codegen
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o: python/src/CMakeFiles/nanobind-static.dir/flags.make
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o: python/src/CMakeFiles/nanobind-static.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o -MF CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o.d -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp > CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.i
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.s
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o: python/src/CMakeFiles/nanobind-static.dir/flags.make
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o: python/src/CMakeFiles/nanobind-static.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o -MF CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o.d -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp > CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.i
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.s
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o: python/src/CMakeFiles/nanobind-static.dir/flags.make
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o: python/src/CMakeFiles/nanobind-static.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o -MF CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o.d -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp > CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.i
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.s
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o: python/src/CMakeFiles/nanobind-static.dir/flags.make
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o: python/src/CMakeFiles/nanobind-static.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Building CXX object python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o -MF CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o.d -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp > CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.i
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.s
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o: python/src/CMakeFiles/nanobind-static.dir/flags.make
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o: python/src/CMakeFiles/nanobind-static.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "Building CXX object python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o -MF CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o.d -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp > CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.i
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.s
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o: python/src/CMakeFiles/nanobind-static.dir/flags.make
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o: python/src/CMakeFiles/nanobind-static.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_6) "Building CXX object python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o -MF CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o.d -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp > CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.i
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.s
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o: python/src/CMakeFiles/nanobind-static.dir/flags.make
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o: python/src/CMakeFiles/nanobind-static.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_7) "Building CXX object python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o -MF CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o.d -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp > CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.i
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.s
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o: python/src/CMakeFiles/nanobind-static.dir/flags.make
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o: python/src/CMakeFiles/nanobind-static.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_8) "Building CXX object python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o -MF CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o.d -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp > CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.i
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.s
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o: python/src/CMakeFiles/nanobind-static.dir/flags.make
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o: python/src/CMakeFiles/nanobind-static.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_9) "Building CXX object python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o -MF CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o.d -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp > CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.i
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.s
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o: python/src/CMakeFiles/nanobind-static.dir/flags.make
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o: /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o: python/src/CMakeFiles/nanobind-static.dir/compiler_depend.ts
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_10) "Building CXX object python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o -MF CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o.d -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o -c /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.i: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.i"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp > CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.i
+
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.s: cmake_force
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.s"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp -o CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.s
+
+# Object files for target nanobind-static
+nanobind__static_OBJECTS = \
+"CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o" \
+"CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o" \
+"CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o" \
+"CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o" \
+"CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o" \
+"CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o" \
+"CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o" \
+"CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o" \
+"CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o" \
+"CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o"
+
+# External object files for target nanobind-static
+nanobind__static_EXTERNAL_OBJECTS =
+
+python/src/libnanobind-static.a: python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o
+python/src/libnanobind-static.a: python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o
+python/src/libnanobind-static.a: python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o
+python/src/libnanobind-static.a: python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o
+python/src/libnanobind-static.a: python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o
+python/src/libnanobind-static.a: python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o
+python/src/libnanobind-static.a: python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o
+python/src/libnanobind-static.a: python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o
+python/src/libnanobind-static.a: python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o
+python/src/libnanobind-static.a: python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o
+python/src/libnanobind-static.a: python/src/CMakeFiles/nanobind-static.dir/build.make
+python/src/libnanobind-static.a: python/src/CMakeFiles/nanobind-static.dir/link.txt
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles --progress-num=$(CMAKE_PROGRESS_11) "Linking CXX static library libnanobind-static.a"
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && $(CMAKE_COMMAND) -P CMakeFiles/nanobind-static.dir/cmake_clean_target.cmake
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/nanobind-static.dir/link.txt --verbose=$(VERBOSE)
+
+# Rule to build all files generated by this target.
+python/src/CMakeFiles/nanobind-static.dir/build: python/src/libnanobind-static.a
+.PHONY : python/src/CMakeFiles/nanobind-static.dir/build
+
+python/src/CMakeFiles/nanobind-static.dir/clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src && $(CMAKE_COMMAND) -P CMakeFiles/nanobind-static.dir/cmake_clean.cmake
+.PHONY : python/src/CMakeFiles/nanobind-static.dir/clean
+
+python/src/CMakeFiles/nanobind-static.dir/depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/DependInfo.cmake "--color=$(COLOR)"
+.PHONY : python/src/CMakeFiles/nanobind-static.dir/depend
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/cmake_clean.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/cmake_clean.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..9974890426ce0224d0799f055ee3d5f667c99dea
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/cmake_clean.cmake
@@ -0,0 +1,29 @@
+file(REMOVE_RECURSE
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o.d"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o.d"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o.d"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o.d"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o.d"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o.d"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o.d"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o.d"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o.d"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o"
+  "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o.d"
+  "libnanobind-static.a"
+  "libnanobind-static.pdb"
+)
+
+# Per-language clean rules from dependency scanning.
+foreach(lang CXX)
+  include(CMakeFiles/nanobind-static.dir/cmake_clean_${lang}.cmake OPTIONAL)
+endforeach()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/cmake_clean_target.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/cmake_clean_target.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e441be2603c0c94ce7622316bf4cfbd67d00d3d6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/cmake_clean_target.cmake
@@ -0,0 +1,3 @@
+file(REMOVE_RECURSE
+  "libnanobind-static.a"
+)
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/compiler_depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/compiler_depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..3a69b7d39fbb8d4588974d424c861bbbfb610c84
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/compiler_depend.make
@@ -0,0 +1,2 @@
+# Empty compiler generated dependencies file for nanobind-static.
+# This may be replaced when dependencies are built.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/compiler_depend.ts b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/compiler_depend.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7af6736dcd5b9b987f8457d2a61c557e4580c95a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/compiler_depend.ts
@@ -0,0 +1,2 @@
+# CMAKE generated file: DO NOT EDIT!
+# Timestamp file for compiler generated dependencies management for nanobind-static.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/depend.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/depend.make
new file mode 100644
index 0000000000000000000000000000000000000000..3cfea8a8a1e97ce2ed2ac73802b2fc5b9a22fee0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/depend.make
@@ -0,0 +1,2 @@
+# Empty dependencies file for nanobind-static.
+# This may be replaced when dependencies are built.
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/flags.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/flags.make
new file mode 100644
index 0000000000000000000000000000000000000000..f9181a69cb72748edd8d25143a4065967a4b9f17
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/flags.make
@@ -0,0 +1,10 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# compile CXX with /usr/bin/c++
+CXX_DEFINES = -DNB_COMPACT_ASSERTIONS
+
+CXX_INCLUDES = -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include -I/proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10 -I/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include
+
+CXX_FLAGS = -O3 -DNDEBUG -std=gnu++17 -fPIC -fvisibility=hidden -ffunction-sections -fdata-sections -fno-strict-aliasing
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/link.txt b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/link.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7a003defa3b1c430f5ae7e8de08104036d9f5702
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/link.txt
@@ -0,0 +1,2 @@
+/usr/bin/ar qc libnanobind-static.a "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o" "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o" "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o" "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o" "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o" "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o" "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o" "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o" "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o" "CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o"
+/usr/bin/ranlib libnanobind-static.a
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/progress.make b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/progress.make
new file mode 100644
index 0000000000000000000000000000000000000000..b531a45b105b76db2c0d379fe5879f19917a078a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/progress.make
@@ -0,0 +1,12 @@
+CMAKE_PROGRESS_1 = 91
+CMAKE_PROGRESS_2 = 92
+CMAKE_PROGRESS_3 = 93
+CMAKE_PROGRESS_4 = 94
+CMAKE_PROGRESS_5 = 95
+CMAKE_PROGRESS_6 = 
+CMAKE_PROGRESS_7 = 96
+CMAKE_PROGRESS_8 = 97
+CMAKE_PROGRESS_9 = 98
+CMAKE_PROGRESS_10 = 99
+CMAKE_PROGRESS_11 = 100
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..601819a1eae34bc3ebd64dfb53220e353e6c7c4e
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..d1a86a4abf9e59ef5dac543a1026a781bb36714c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o.d
@@ -0,0 +1,316 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..03fa3b8c661c42667dbbd2354dc87b99e003384e
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..a4d76eb547e23d4b9b0a9dae82a2bbbaa57761c7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o.d
@@ -0,0 +1,318 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /usr/include/c++/8/cstdarg \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/buffer.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..ecacc60ce4865256926b3b93f660165adc2bc98b
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..4de2cca3c32bb9ed55fa16dd76ff1b1d7b19fd7c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o.d
@@ -0,0 +1,317 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/trampoline.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..a2c425e5c4896038075c7da550d5836ad32831c6
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..695e1fd70118114da42948ccf74d012a56e896f9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o.d
@@ -0,0 +1,316 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..81e7cf5ffa49352d6455b979fe2c48f69d1a4888
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..fd7e472391409183ed622d55e08f618fc0445230
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o.d
@@ -0,0 +1,319 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/hash.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/buffer.h \
+ /usr/include/c++/8/cxxabi.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cxxabi_tweaks.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..2ee2c32f9c0fa5504d932598282070eb750673ea
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..8f0ece20378aff473921e6370e49ff9b03d8845c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o.d
@@ -0,0 +1,318 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/hash.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..e65e18a880c2ccb426d709c59d4703e01df60424
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..adaf80dfee95d2944ccfad5a81a6733b3e9c11ba
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o.d
@@ -0,0 +1,317 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/ndarray.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..dd1cb5bd8a95d1b1de6a52eb898856e97bcf14cf
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..8ba9c9c60143f52eafb4dbf02c623e8a645fed64
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o.d
@@ -0,0 +1,316 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..758ec1a4e28905762cc420ff7162fb7509283cf9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87aad9a03149f6a3108639ed48397ce556bd7e0826a7a30c4385bdbd8d066410
+size 133968
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..107d7daa0abdc3b9f83c9dc01509b0a1611673c9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o.d
@@ -0,0 +1,316 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..49e7879dad80293caab9b8b18739b01e6992f8be
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..21796df7589b4af19d82324e3e69113371a2a025
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o.d
@@ -0,0 +1,317 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/trampoline.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-nyl54h73/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..601819a1eae34bc3ebd64dfb53220e353e6c7c4e
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..6c1ee6edb82d04f22e0424ba9f41e2ed189cc48e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o.d
@@ -0,0 +1,316 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..03fa3b8c661c42667dbbd2354dc87b99e003384e
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..32053561c9524346bf34880a40891f90fb89576e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o.d
@@ -0,0 +1,318 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /usr/include/c++/8/cstdarg \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/buffer.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..ecacc60ce4865256926b3b93f660165adc2bc98b
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..6ebb69f8b9adfe452473a43f7dcb78733f35e468
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o.d
@@ -0,0 +1,317 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/trampoline.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..a2c425e5c4896038075c7da550d5836ad32831c6
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..437e406b73029cd42b6fc9e85a205aa7df9945ae
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o.d
@@ -0,0 +1,316 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..81e7cf5ffa49352d6455b979fe2c48f69d1a4888
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..3e61b14d2a14d5c3f914b39bc8af4941d0132887
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o.d
@@ -0,0 +1,319 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/hash.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/buffer.h \
+ /usr/include/c++/8/cxxabi.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cxxabi_tweaks.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..2ee2c32f9c0fa5504d932598282070eb750673ea
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..b4cbf426df42a69b144159718fdcf5307c46bf4c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o.d
@@ -0,0 +1,318 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/hash.h \
+ /usr/include/c++/8/thread /usr/include/c++/8/chrono \
+ /usr/include/c++/8/ctime /usr/include/c++/8/bits/parse_numbers.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..e65e18a880c2ccb426d709c59d4703e01df60424
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..00db59b6543cc1e5496585c159009537d2d10b71
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o.d
@@ -0,0 +1,317 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/ndarray.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /usr/include/c++/8/atomic /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..dd1cb5bd8a95d1b1de6a52eb898856e97bcf14cf
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..59db9845f159f6915a9884909e42755ab0c589c7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o.d
@@ -0,0 +1,316 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..758ec1a4e28905762cc420ff7162fb7509283cf9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87aad9a03149f6a3108639ed48397ce556bd7e0826a7a30c4385bdbd8d066410
+size 133968
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..77f838863e889fe6d9740fcd79206f407855e644
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o.d
@@ -0,0 +1,316 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o
new file mode 100644
index 0000000000000000000000000000000000000000..49e7879dad80293caab9b8b18739b01e6992f8be
Binary files /dev/null and b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o differ
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o.d b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o.d
new file mode 100644
index 0000000000000000000000000000000000000000..c4118cad0f52210bf2fa91597dd28ec7a9571b37
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o.d
@@ -0,0 +1,317 @@
+python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o: \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp \
+ /usr/include/stdc-predef.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/trampoline.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nanobind.h \
+ /usr/include/c++/8/cstddef \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++config.h \
+ /usr/include/bits/wordsize.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/os_defines.h \
+ /usr/include/features.h /usr/include/sys/cdefs.h \
+ /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \
+ /usr/include/gnu/stubs-64.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/cpu_defines.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stddef.h \
+ /usr/include/c++/8/cstdint \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdint.h \
+ /usr/include/stdint.h /usr/include/bits/libc-header-start.h \
+ /usr/include/bits/types.h /usr/include/bits/typesizes.h \
+ /usr/include/bits/wchar.h /usr/include/bits/stdint-intn.h \
+ /usr/include/bits/stdint-uintn.h /usr/include/c++/8/exception \
+ /usr/include/c++/8/bits/exception.h \
+ /usr/include/c++/8/bits/exception_ptr.h \
+ /usr/include/c++/8/bits/exception_defines.h \
+ /usr/include/c++/8/bits/cxxabi_init_exception.h \
+ /usr/include/c++/8/typeinfo /usr/include/c++/8/bits/hash_bytes.h \
+ /usr/include/c++/8/new /usr/include/c++/8/bits/nested_exception.h \
+ /usr/include/c++/8/bits/move.h /usr/include/c++/8/bits/concept_check.h \
+ /usr/include/c++/8/type_traits /usr/include/c++/8/stdexcept \
+ /usr/include/c++/8/string /usr/include/c++/8/bits/stringfwd.h \
+ /usr/include/c++/8/bits/memoryfwd.h \
+ /usr/include/c++/8/bits/char_traits.h \
+ /usr/include/c++/8/bits/stl_algobase.h \
+ /usr/include/c++/8/bits/functexcept.h \
+ /usr/include/c++/8/bits/cpp_type_traits.h \
+ /usr/include/c++/8/ext/type_traits.h \
+ /usr/include/c++/8/ext/numeric_traits.h \
+ /usr/include/c++/8/bits/stl_pair.h \
+ /usr/include/c++/8/bits/stl_iterator_base_types.h \
+ /usr/include/c++/8/bits/stl_iterator_base_funcs.h \
+ /usr/include/c++/8/debug/assertions.h \
+ /usr/include/c++/8/bits/stl_iterator.h \
+ /usr/include/c++/8/bits/ptr_traits.h /usr/include/c++/8/debug/debug.h \
+ /usr/include/c++/8/bits/predefined_ops.h \
+ /usr/include/c++/8/bits/postypes.h /usr/include/c++/8/cwchar \
+ /usr/include/wchar.h /usr/include/bits/floatn.h \
+ /usr/include/bits/floatn-common.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/stdarg.h \
+ /usr/include/bits/types/wint_t.h /usr/include/bits/types/mbstate_t.h \
+ /usr/include/bits/types/__mbstate_t.h /usr/include/bits/types/__FILE.h \
+ /usr/include/bits/types/FILE.h /usr/include/bits/types/locale_t.h \
+ /usr/include/bits/types/__locale_t.h /usr/include/c++/8/bits/allocator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++allocator.h \
+ /usr/include/c++/8/ext/new_allocator.h \
+ /usr/include/c++/8/bits/localefwd.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/c++locale.h \
+ /usr/include/c++/8/clocale /usr/include/locale.h \
+ /usr/include/bits/locale.h /usr/include/c++/8/iosfwd \
+ /usr/include/c++/8/cctype /usr/include/ctype.h /usr/include/endian.h \
+ /usr/include/bits/endian.h /usr/include/bits/byteswap.h \
+ /usr/include/bits/uintn-identity.h \
+ /usr/include/c++/8/bits/ostream_insert.h \
+ /usr/include/c++/8/bits/cxxabi_forced.h \
+ /usr/include/c++/8/bits/stl_function.h \
+ /usr/include/c++/8/backward/binders.h \
+ /usr/include/c++/8/bits/range_access.h \
+ /usr/include/c++/8/initializer_list \
+ /usr/include/c++/8/bits/basic_string.h \
+ /usr/include/c++/8/ext/atomicity.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/gthr-default.h \
+ /usr/include/pthread.h /usr/include/sched.h \
+ /usr/include/bits/types/time_t.h \
+ /usr/include/bits/types/struct_timespec.h /usr/include/bits/sched.h \
+ /usr/include/bits/types/struct_sched_param.h /usr/include/bits/cpu-set.h \
+ /usr/include/time.h /usr/include/bits/time.h /usr/include/bits/timex.h \
+ /usr/include/bits/types/struct_timeval.h \
+ /usr/include/bits/types/clock_t.h /usr/include/bits/types/struct_tm.h \
+ /usr/include/bits/types/clockid_t.h /usr/include/bits/types/timer_t.h \
+ /usr/include/bits/types/struct_itimerspec.h \
+ /usr/include/bits/pthreadtypes.h /usr/include/bits/thread-shared-types.h \
+ /usr/include/bits/pthreadtypes-arch.h /usr/include/bits/setjmp.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/atomic_word.h \
+ /usr/include/c++/8/ext/alloc_traits.h \
+ /usr/include/c++/8/bits/alloc_traits.h /usr/include/c++/8/string_view \
+ /usr/include/c++/8/limits /usr/include/c++/8/bits/functional_hash.h \
+ /usr/include/c++/8/bits/string_view.tcc \
+ /usr/include/c++/8/ext/string_conversions.h /usr/include/c++/8/cstdlib \
+ /usr/include/stdlib.h /usr/include/bits/waitflags.h \
+ /usr/include/bits/waitstatus.h /usr/include/sys/types.h \
+ /usr/include/sys/select.h /usr/include/bits/select.h \
+ /usr/include/bits/types/sigset_t.h /usr/include/bits/types/__sigset_t.h \
+ /usr/include/alloca.h /usr/include/bits/stdlib-bsearch.h \
+ /usr/include/bits/stdlib-float.h /usr/include/c++/8/bits/std_abs.h \
+ /usr/include/c++/8/cstdio /usr/include/stdio.h \
+ /usr/include/bits/types/__fpos_t.h /usr/include/bits/types/__fpos64_t.h \
+ /usr/include/bits/types/struct_FILE.h \
+ /usr/include/bits/types/cookie_io_functions_t.h \
+ /usr/include/bits/stdio_lim.h /usr/include/bits/sys_errlist.h \
+ /usr/include/bits/stdio.h /usr/include/c++/8/cerrno /usr/include/errno.h \
+ /usr/include/bits/errno.h /usr/include/linux/errno.h \
+ /usr/include/asm/errno.h /usr/include/asm-generic/errno.h \
+ /usr/include/asm-generic/errno-base.h /usr/include/bits/types/error_t.h \
+ /usr/include/c++/8/bits/basic_string.tcc /usr/include/c++/8/utility \
+ /usr/include/c++/8/bits/stl_relops.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/Python.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/patchlevel.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacconfig.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/limits.h \
+ /usr/lib/gcc/x86_64-redhat-linux/8/include/syslimits.h \
+ /usr/include/limits.h /usr/include/bits/posix1_lim.h \
+ /usr/include/bits/local_lim.h /usr/include/linux/limits.h \
+ /usr/include/bits/posix2_lim.h /usr/include/bits/xopen_lim.h \
+ /usr/include/bits/uio_lim.h /usr/include/string.h /usr/include/strings.h \
+ /usr/include/c++/8/stdlib.h /usr/include/unistd.h \
+ /usr/include/bits/posix_opt.h /usr/include/bits/environments.h \
+ /usr/include/bits/confname.h /usr/include/bits/getopt_posix.h \
+ /usr/include/bits/getopt_core.h /usr/include/assert.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyport.h \
+ /usr/include/inttypes.h /usr/include/c++/8/math.h \
+ /usr/include/c++/8/cmath /usr/include/math.h \
+ /usr/include/bits/math-vector.h /usr/include/bits/libm-simd-decl-stubs.h \
+ /usr/include/bits/flt-eval-method.h /usr/include/bits/fp-logb.h \
+ /usr/include/bits/fp-fast.h \
+ /usr/include/bits/mathcalls-helper-functions.h \
+ /usr/include/bits/mathcalls.h /usr/include/bits/mathcalls-narrow.h \
+ /usr/include/bits/iscanonical.h /usr/include/bits/mathinline.h \
+ /usr/include/c++/8/bits/specfun.h /usr/include/c++/8/tr1/gamma.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/bessel_function.tcc \
+ /usr/include/c++/8/tr1/special_function_util.h \
+ /usr/include/c++/8/tr1/beta_function.tcc \
+ /usr/include/c++/8/tr1/ell_integral.tcc \
+ /usr/include/c++/8/tr1/exp_integral.tcc \
+ /usr/include/c++/8/tr1/hypergeometric.tcc \
+ /usr/include/c++/8/tr1/legendre_function.tcc \
+ /usr/include/c++/8/tr1/modified_bessel_func.tcc \
+ /usr/include/c++/8/tr1/poly_hermite.tcc \
+ /usr/include/c++/8/tr1/poly_laguerre.tcc \
+ /usr/include/c++/8/tr1/riemann_zeta.tcc /usr/include/sys/time.h \
+ /usr/include/sys/stat.h /usr/include/bits/stat.h \
+ /usr/include/bits/statx.h /usr/include/linux/stat.h \
+ /usr/include/linux/types.h /usr/include/asm/types.h \
+ /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \
+ /usr/include/asm/bitsperlong.h /usr/include/asm-generic/bitsperlong.h \
+ /usr/include/linux/posix_types.h /usr/include/linux/stddef.h \
+ /usr/include/asm/posix_types.h /usr/include/asm/posix_types_64.h \
+ /usr/include/asm-generic/posix_types.h /usr/include/bits/statx-generic.h \
+ /usr/include/bits/types/struct_statx_timestamp.h \
+ /usr/include/bits/types/struct_statx.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/exports.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymacro.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymath.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pymem.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/object.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/objimpl.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/typeslots.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyhash.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pydebug.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytearrayobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/bytesobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/unicodeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/longintrepr.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/boolobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/floatobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/complexobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/rangeobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/memoryobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/tupleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/listobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/dictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/odictobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/enumobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/setobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/methodobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/moduleobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/funcobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/classobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pycapsule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/code.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyframe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/traceback.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sliceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cellobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/iterobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/initconfig.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pystate.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/abstract.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/descrobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/genericaliasobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/warnings.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/weakrefobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structseq.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/namespaceobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/picklebufobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pytime.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/codecs.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyerrors.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/context.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/modsupport.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/compile.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pythonrun.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pylifecycle.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/ceval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/sysmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/osmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/intrcheck.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/import.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/bltinmodule.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/eval.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyctype.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrtod.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pystrcmp.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/fileutils.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/pyfpe.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/tracemalloc.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/cpython/frameobject.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/pythread.h \
+ /proj/cvl/users/x_fahkh2/envs/matagent/include/python3.10/structmember.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_defs.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_enums.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_traits.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_tuple.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_lib.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_descr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_types.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_accessor.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_error.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_attr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_cast.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_misc.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_call.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_func.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/include/nanobind/nb_class.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_map.h \
+ /usr/include/c++/8/functional /usr/include/c++/8/tuple \
+ /usr/include/c++/8/array /usr/include/c++/8/bits/uses_allocator.h \
+ /usr/include/c++/8/bits/invoke.h /usr/include/c++/8/bits/refwrap.h \
+ /usr/include/c++/8/bits/std_function.h /usr/include/c++/8/unordered_map \
+ /usr/include/c++/8/ext/aligned_buffer.h \
+ /usr/include/c++/8/bits/hashtable.h \
+ /usr/include/c++/8/bits/hashtable_policy.h \
+ /usr/include/c++/8/bits/node_handle.h /usr/include/c++/8/optional \
+ /usr/include/c++/8/bits/enable_special_members.h \
+ /usr/include/c++/8/bits/unordered_map.h /usr/include/c++/8/vector \
+ /usr/include/c++/8/bits/stl_construct.h \
+ /usr/include/c++/8/bits/stl_uninitialized.h \
+ /usr/include/c++/8/bits/stl_vector.h \
+ /usr/include/c++/8/bits/stl_bvector.h /usr/include/c++/8/bits/vector.tcc \
+ /usr/include/c++/8/bits/stl_algo.h \
+ /usr/include/c++/8/bits/algorithmfwd.h \
+ /usr/include/c++/8/bits/stl_heap.h /usr/include/c++/8/bits/stl_tempbuf.h \
+ /usr/include/c++/8/bits/uniform_int_dist.h /usr/include/c++/8/memory \
+ /usr/include/c++/8/bits/stl_raw_storage_iter.h \
+ /usr/include/c++/8/ext/concurrence.h \
+ /usr/include/c++/8/bits/unique_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_base.h \
+ /usr/include/c++/8/bits/allocated_ptr.h \
+ /usr/include/c++/8/bits/shared_ptr_atomic.h \
+ /usr/include/c++/8/bits/atomic_base.h \
+ /usr/include/c++/8/bits/atomic_lockfree_defines.h \
+ /usr/include/c++/8/backward/auto_ptr.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_hash.h \
+ /usr/include/c++/8/algorithm /usr/include/c++/8/cassert \
+ /usr/include/c++/8/iterator /usr/include/c++/8/ostream \
+ /usr/include/c++/8/ios /usr/include/c++/8/bits/ios_base.h \
+ /usr/include/c++/8/bits/locale_classes.h \
+ /usr/include/c++/8/bits/locale_classes.tcc \
+ /usr/include/c++/8/system_error \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/error_constants.h \
+ /usr/include/c++/8/streambuf /usr/include/c++/8/bits/streambuf.tcc \
+ /usr/include/c++/8/bits/basic_ios.h \
+ /usr/include/c++/8/bits/locale_facets.h /usr/include/c++/8/cwctype \
+ /usr/include/wctype.h /usr/include/bits/wctype-wchar.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_base.h \
+ /usr/include/c++/8/bits/streambuf_iterator.h \
+ /usr/include/c++/8/x86_64-redhat-linux/bits/ctype_inline.h \
+ /usr/include/c++/8/bits/locale_facets.tcc \
+ /usr/include/c++/8/bits/basic_ios.tcc \
+ /usr/include/c++/8/bits/ostream.tcc /usr/include/c++/8/istream \
+ /usr/include/c++/8/bits/istream.tcc \
+ /usr/include/c++/8/bits/stream_iterator.h \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/ext/robin_map/include/tsl/robin_growth_policy.h \
+ /usr/include/c++/8/climits /usr/include/c++/8/ratio \
+ /usr/include/c++/8/cstring \
+ /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/hash.h
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/progress.marks b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/progress.marks
new file mode 100644
index 0000000000000000000000000000000000000000..c17e934b51c1f08a2b3056e4cd63fe62d111672d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/CMakeFiles/progress.marks
@@ -0,0 +1 @@
+97
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/Makefile b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..f476dad4a201f5996bd41f3aa65074b0a3f334b7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/Makefile
@@ -0,0 +1,1083 @@
+# CMAKE generated file: DO NOT EDIT!
+# Generated by "Unix Makefiles" Generator, CMake Version 4.0
+
+# Default target executed when no arguments are given to make.
+default_target: all
+.PHONY : default_target
+
+# Allow only one "make -f Makefile2" at a time, but pass parallelism.
+.NOTPARALLEL:
+
+#=============================================================================
+# Special targets provided by cmake.
+
+# Disable implicit rules so canonical targets will work.
+.SUFFIXES:
+
+# Disable VCS-based implicit rules.
+% : %,v
+
+# Disable VCS-based implicit rules.
+% : RCS/%
+
+# Disable VCS-based implicit rules.
+% : RCS/%,v
+
+# Disable VCS-based implicit rules.
+% : SCCS/s.%
+
+# Disable VCS-based implicit rules.
+% : s.%
+
+.SUFFIXES: .hpux_make_needs_suffix_list
+
+# Command-line flag to silence nested $(MAKE).
+$(VERBOSE)MAKESILENT = -s
+
+#Suppress display of executed commands.
+$(VERBOSE).SILENT:
+
+# A target that is always out of date.
+cmake_force:
+.PHONY : cmake_force
+
+#=============================================================================
+# Set environment variables for the build.
+
+# The shell in which to execute make rules.
+SHELL = /bin/sh
+
+# The CMake executable.
+CMAKE_COMMAND = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake
+
+# The command to remove a file.
+RM = /proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E rm -f
+
+# Escaping for special characters.
+EQUALS = =
+
+# The top-level source directory on which CMake was run.
+CMAKE_SOURCE_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx
+
+# The top-level build directory on which CMake was run.
+CMAKE_BINARY_DIR = /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core
+
+#=============================================================================
+# Targets provided globally by CMake.
+
+# Special rule for the target edit_cache
+edit_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "No interactive CMake dialog available..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -E echo No\ interactive\ CMake\ dialog\ available.
+.PHONY : edit_cache
+
+# Special rule for the target edit_cache
+edit_cache/fast: edit_cache
+.PHONY : edit_cache/fast
+
+# Special rule for the target rebuild_cache
+rebuild_cache:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
+.PHONY : rebuild_cache
+
+# Special rule for the target rebuild_cache
+rebuild_cache/fast: rebuild_cache
+.PHONY : rebuild_cache/fast
+
+# Special rule for the target list_install_components
+list_install_components:
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\" \"headers\""
+.PHONY : list_install_components
+
+# Special rule for the target list_install_components
+list_install_components/fast: list_install_components
+.PHONY : list_install_components/fast
+
+# Special rule for the target install
+install: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install
+
+# Special rule for the target install
+install/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -P cmake_install.cmake
+.PHONY : install/fast
+
+# Special rule for the target install/local
+install/local: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local
+
+# Special rule for the target install/local
+install/local/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
+.PHONY : install/local/fast
+
+# Special rule for the target install/strip
+install/strip: preinstall
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip
+
+# Special rule for the target install/strip
+install/strip/fast: preinstall/fast
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
+	/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/cmake/data/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
+.PHONY : install/strip/fast
+
+# The main all target
+all: cmake_check_build_system
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src//CMakeFiles/progress.marks
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 python/src/all
+	$(CMAKE_COMMAND) -E cmake_progress_start /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/CMakeFiles 0
+.PHONY : all
+
+# The main clean target
+clean:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 python/src/clean
+.PHONY : clean
+
+# The main clean target
+clean/fast: clean
+.PHONY : clean/fast
+
+# Prepare targets for installation.
+preinstall: all
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 python/src/preinstall
+.PHONY : preinstall
+
+# Prepare targets for installation.
+preinstall/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 python/src/preinstall
+.PHONY : preinstall/fast
+
+# clear depends
+depend:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
+.PHONY : depend
+
+# Convenience name for target.
+python/src/CMakeFiles/core.dir/rule:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 python/src/CMakeFiles/core.dir/rule
+.PHONY : python/src/CMakeFiles/core.dir/rule
+
+# Convenience name for target.
+core: python/src/CMakeFiles/core.dir/rule
+.PHONY : core
+
+# fast build rule for target.
+core/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/build
+.PHONY : core/fast
+
+# Convenience name for target.
+python/src/CMakeFiles/nanobind-static.dir/rule:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 python/src/CMakeFiles/nanobind-static.dir/rule
+.PHONY : python/src/CMakeFiles/nanobind-static.dir/rule
+
+# Convenience name for target.
+nanobind-static: python/src/CMakeFiles/nanobind-static.dir/rule
+.PHONY : nanobind-static
+
+# fast build rule for target.
+nanobind-static/fast:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/build
+.PHONY : nanobind-static/fast
+
+array.o: array.cpp.o
+.PHONY : array.o
+
+# target to build an object file
+array.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/array.cpp.o
+.PHONY : array.cpp.o
+
+array.i: array.cpp.i
+.PHONY : array.i
+
+# target to preprocess a source file
+array.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/array.cpp.i
+.PHONY : array.cpp.i
+
+array.s: array.cpp.s
+.PHONY : array.s
+
+# target to generate assembly for a file
+array.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/array.cpp.s
+.PHONY : array.cpp.s
+
+constants.o: constants.cpp.o
+.PHONY : constants.o
+
+# target to build an object file
+constants.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/constants.cpp.o
+.PHONY : constants.cpp.o
+
+constants.i: constants.cpp.i
+.PHONY : constants.i
+
+# target to preprocess a source file
+constants.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/constants.cpp.i
+.PHONY : constants.cpp.i
+
+constants.s: constants.cpp.s
+.PHONY : constants.s
+
+# target to generate assembly for a file
+constants.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/constants.cpp.s
+.PHONY : constants.cpp.s
+
+convert.o: convert.cpp.o
+.PHONY : convert.o
+
+# target to build an object file
+convert.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/convert.cpp.o
+.PHONY : convert.cpp.o
+
+convert.i: convert.cpp.i
+.PHONY : convert.i
+
+# target to preprocess a source file
+convert.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/convert.cpp.i
+.PHONY : convert.cpp.i
+
+convert.s: convert.cpp.s
+.PHONY : convert.s
+
+# target to generate assembly for a file
+convert.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/convert.cpp.s
+.PHONY : convert.cpp.s
+
+cuda.o: cuda.cpp.o
+.PHONY : cuda.o
+
+# target to build an object file
+cuda.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/cuda.cpp.o
+.PHONY : cuda.cpp.o
+
+cuda.i: cuda.cpp.i
+.PHONY : cuda.i
+
+# target to preprocess a source file
+cuda.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/cuda.cpp.i
+.PHONY : cuda.cpp.i
+
+cuda.s: cuda.cpp.s
+.PHONY : cuda.s
+
+# target to generate assembly for a file
+cuda.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/cuda.cpp.s
+.PHONY : cuda.cpp.s
+
+device.o: device.cpp.o
+.PHONY : device.o
+
+# target to build an object file
+device.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/device.cpp.o
+.PHONY : device.cpp.o
+
+device.i: device.cpp.i
+.PHONY : device.i
+
+# target to preprocess a source file
+device.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/device.cpp.i
+.PHONY : device.cpp.i
+
+device.s: device.cpp.s
+.PHONY : device.s
+
+# target to generate assembly for a file
+device.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/device.cpp.s
+.PHONY : device.cpp.s
+
+distributed.o: distributed.cpp.o
+.PHONY : distributed.o
+
+# target to build an object file
+distributed.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/distributed.cpp.o
+.PHONY : distributed.cpp.o
+
+distributed.i: distributed.cpp.i
+.PHONY : distributed.i
+
+# target to preprocess a source file
+distributed.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/distributed.cpp.i
+.PHONY : distributed.cpp.i
+
+distributed.s: distributed.cpp.s
+.PHONY : distributed.s
+
+# target to generate assembly for a file
+distributed.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/distributed.cpp.s
+.PHONY : distributed.cpp.s
+
+export.o: export.cpp.o
+.PHONY : export.o
+
+# target to build an object file
+export.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/export.cpp.o
+.PHONY : export.cpp.o
+
+export.i: export.cpp.i
+.PHONY : export.i
+
+# target to preprocess a source file
+export.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/export.cpp.i
+.PHONY : export.cpp.i
+
+export.s: export.cpp.s
+.PHONY : export.s
+
+# target to generate assembly for a file
+export.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/export.cpp.s
+.PHONY : export.cpp.s
+
+fast.o: fast.cpp.o
+.PHONY : fast.o
+
+# target to build an object file
+fast.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/fast.cpp.o
+.PHONY : fast.cpp.o
+
+fast.i: fast.cpp.i
+.PHONY : fast.i
+
+# target to preprocess a source file
+fast.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/fast.cpp.i
+.PHONY : fast.cpp.i
+
+fast.s: fast.cpp.s
+.PHONY : fast.s
+
+# target to generate assembly for a file
+fast.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/fast.cpp.s
+.PHONY : fast.cpp.s
+
+fft.o: fft.cpp.o
+.PHONY : fft.o
+
+# target to build an object file
+fft.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/fft.cpp.o
+.PHONY : fft.cpp.o
+
+fft.i: fft.cpp.i
+.PHONY : fft.i
+
+# target to preprocess a source file
+fft.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/fft.cpp.i
+.PHONY : fft.cpp.i
+
+fft.s: fft.cpp.s
+.PHONY : fft.s
+
+# target to generate assembly for a file
+fft.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/fft.cpp.s
+.PHONY : fft.cpp.s
+
+indexing.o: indexing.cpp.o
+.PHONY : indexing.o
+
+# target to build an object file
+indexing.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/indexing.cpp.o
+.PHONY : indexing.cpp.o
+
+indexing.i: indexing.cpp.i
+.PHONY : indexing.i
+
+# target to preprocess a source file
+indexing.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/indexing.cpp.i
+.PHONY : indexing.cpp.i
+
+indexing.s: indexing.cpp.s
+.PHONY : indexing.s
+
+# target to generate assembly for a file
+indexing.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/indexing.cpp.s
+.PHONY : indexing.cpp.s
+
+linalg.o: linalg.cpp.o
+.PHONY : linalg.o
+
+# target to build an object file
+linalg.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/linalg.cpp.o
+.PHONY : linalg.cpp.o
+
+linalg.i: linalg.cpp.i
+.PHONY : linalg.i
+
+# target to preprocess a source file
+linalg.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/linalg.cpp.i
+.PHONY : linalg.cpp.i
+
+linalg.s: linalg.cpp.s
+.PHONY : linalg.s
+
+# target to generate assembly for a file
+linalg.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/linalg.cpp.s
+.PHONY : linalg.cpp.s
+
+load.o: load.cpp.o
+.PHONY : load.o
+
+# target to build an object file
+load.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/load.cpp.o
+.PHONY : load.cpp.o
+
+load.i: load.cpp.i
+.PHONY : load.i
+
+# target to preprocess a source file
+load.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/load.cpp.i
+.PHONY : load.cpp.i
+
+load.s: load.cpp.s
+.PHONY : load.s
+
+# target to generate assembly for a file
+load.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/load.cpp.s
+.PHONY : load.cpp.s
+
+memory.o: memory.cpp.o
+.PHONY : memory.o
+
+# target to build an object file
+memory.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/memory.cpp.o
+.PHONY : memory.cpp.o
+
+memory.i: memory.cpp.i
+.PHONY : memory.i
+
+# target to preprocess a source file
+memory.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/memory.cpp.i
+.PHONY : memory.cpp.i
+
+memory.s: memory.cpp.s
+.PHONY : memory.s
+
+# target to generate assembly for a file
+memory.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/memory.cpp.s
+.PHONY : memory.cpp.s
+
+metal.o: metal.cpp.o
+.PHONY : metal.o
+
+# target to build an object file
+metal.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/metal.cpp.o
+.PHONY : metal.cpp.o
+
+metal.i: metal.cpp.i
+.PHONY : metal.i
+
+# target to preprocess a source file
+metal.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/metal.cpp.i
+.PHONY : metal.cpp.i
+
+metal.s: metal.cpp.s
+.PHONY : metal.s
+
+# target to generate assembly for a file
+metal.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/metal.cpp.s
+.PHONY : metal.cpp.s
+
+mlx.o: mlx.cpp.o
+.PHONY : mlx.o
+
+# target to build an object file
+mlx.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/mlx.cpp.o
+.PHONY : mlx.cpp.o
+
+mlx.i: mlx.cpp.i
+.PHONY : mlx.i
+
+# target to preprocess a source file
+mlx.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/mlx.cpp.i
+.PHONY : mlx.cpp.i
+
+mlx.s: mlx.cpp.s
+.PHONY : mlx.s
+
+# target to generate assembly for a file
+mlx.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/mlx.cpp.s
+.PHONY : mlx.cpp.s
+
+mlx_func.o: mlx_func.cpp.o
+.PHONY : mlx_func.o
+
+# target to build an object file
+mlx_func.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/mlx_func.cpp.o
+.PHONY : mlx_func.cpp.o
+
+mlx_func.i: mlx_func.cpp.i
+.PHONY : mlx_func.i
+
+# target to preprocess a source file
+mlx_func.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/mlx_func.cpp.i
+.PHONY : mlx_func.cpp.i
+
+mlx_func.s: mlx_func.cpp.s
+.PHONY : mlx_func.s
+
+# target to generate assembly for a file
+mlx_func.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/mlx_func.cpp.s
+.PHONY : mlx_func.cpp.s
+
+ops.o: ops.cpp.o
+.PHONY : ops.o
+
+# target to build an object file
+ops.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/ops.cpp.o
+.PHONY : ops.cpp.o
+
+ops.i: ops.cpp.i
+.PHONY : ops.i
+
+# target to preprocess a source file
+ops.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/ops.cpp.i
+.PHONY : ops.cpp.i
+
+ops.s: ops.cpp.s
+.PHONY : ops.s
+
+# target to generate assembly for a file
+ops.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/ops.cpp.s
+.PHONY : ops.cpp.s
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.o: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.o
+
+# target to build an object file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.o
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.i: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.i
+
+# target to preprocess a source file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.i
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.s: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.s
+
+# target to generate assembly for a file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.cpp.s
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.o: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.o
+
+# target to build an object file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.o
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.i: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.i
+
+# target to preprocess a source file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.i
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.s: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.s
+
+# target to generate assembly for a file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.cpp.s
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.o: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.o
+
+# target to build an object file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.o
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.i: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.i
+
+# target to preprocess a source file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.i
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.s: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.s
+
+# target to generate assembly for a file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.cpp.s
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.o: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.o
+
+# target to build an object file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.o
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.i: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.i
+
+# target to preprocess a source file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.i
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.s: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.s
+
+# target to generate assembly for a file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.cpp.s
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.o: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.o
+
+# target to build an object file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.o
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.i: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.i
+
+# target to preprocess a source file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.i
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.s: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.s
+
+# target to generate assembly for a file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.cpp.s
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.o: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.o
+
+# target to build an object file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.o
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.i: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.i
+
+# target to preprocess a source file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.i
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.s: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.s
+
+# target to generate assembly for a file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.cpp.s
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.o: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.o
+
+# target to build an object file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.o
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.i: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.i
+
+# target to preprocess a source file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.i
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.s: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.s
+
+# target to generate assembly for a file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.cpp.s
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.o: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.o
+
+# target to build an object file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.o
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.i: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.i
+
+# target to preprocess a source file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.i
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.s: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.s
+
+# target to generate assembly for a file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.cpp.s
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.o: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.o
+
+# target to build an object file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.o
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.i: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.i
+
+# target to preprocess a source file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.i
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.s: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.s
+
+# target to generate assembly for a file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.cpp.s
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.o: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.o
+
+# target to build an object file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.o
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.i: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.i
+
+# target to preprocess a source file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.i
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.i
+
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.s: proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.s
+
+# target to generate assembly for a file
+proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/nanobind-static.dir/build.make python/src/CMakeFiles/nanobind-static.dir/proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.s
+.PHONY : proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.cpp.s
+
+random.o: random.cpp.o
+.PHONY : random.o
+
+# target to build an object file
+random.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/random.cpp.o
+.PHONY : random.cpp.o
+
+random.i: random.cpp.i
+.PHONY : random.i
+
+# target to preprocess a source file
+random.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/random.cpp.i
+.PHONY : random.cpp.i
+
+random.s: random.cpp.s
+.PHONY : random.s
+
+# target to generate assembly for a file
+random.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/random.cpp.s
+.PHONY : random.cpp.s
+
+stream.o: stream.cpp.o
+.PHONY : stream.o
+
+# target to build an object file
+stream.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/stream.cpp.o
+.PHONY : stream.cpp.o
+
+stream.i: stream.cpp.i
+.PHONY : stream.i
+
+# target to preprocess a source file
+stream.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/stream.cpp.i
+.PHONY : stream.cpp.i
+
+stream.s: stream.cpp.s
+.PHONY : stream.s
+
+# target to generate assembly for a file
+stream.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/stream.cpp.s
+.PHONY : stream.cpp.s
+
+transforms.o: transforms.cpp.o
+.PHONY : transforms.o
+
+# target to build an object file
+transforms.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/transforms.cpp.o
+.PHONY : transforms.cpp.o
+
+transforms.i: transforms.cpp.i
+.PHONY : transforms.i
+
+# target to preprocess a source file
+transforms.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/transforms.cpp.i
+.PHONY : transforms.cpp.i
+
+transforms.s: transforms.cpp.s
+.PHONY : transforms.s
+
+# target to generate assembly for a file
+transforms.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/transforms.cpp.s
+.PHONY : transforms.cpp.s
+
+trees.o: trees.cpp.o
+.PHONY : trees.o
+
+# target to build an object file
+trees.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/trees.cpp.o
+.PHONY : trees.cpp.o
+
+trees.i: trees.cpp.i
+.PHONY : trees.i
+
+# target to preprocess a source file
+trees.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/trees.cpp.i
+.PHONY : trees.cpp.i
+
+trees.s: trees.cpp.s
+.PHONY : trees.s
+
+# target to generate assembly for a file
+trees.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/trees.cpp.s
+.PHONY : trees.cpp.s
+
+utils.o: utils.cpp.o
+.PHONY : utils.o
+
+# target to build an object file
+utils.cpp.o:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/utils.cpp.o
+.PHONY : utils.cpp.o
+
+utils.i: utils.cpp.i
+.PHONY : utils.i
+
+# target to preprocess a source file
+utils.cpp.i:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/utils.cpp.i
+.PHONY : utils.cpp.i
+
+utils.s: utils.cpp.s
+.PHONY : utils.s
+
+# target to generate assembly for a file
+utils.cpp.s:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(MAKE) $(MAKESILENT) -f python/src/CMakeFiles/core.dir/build.make python/src/CMakeFiles/core.dir/utils.cpp.s
+.PHONY : utils.cpp.s
+
+# Help Target
+help:
+	@echo "The following are some of the valid targets for this Makefile:"
+	@echo "... all (the default if no target is provided)"
+	@echo "... clean"
+	@echo "... depend"
+	@echo "... edit_cache"
+	@echo "... install"
+	@echo "... install/local"
+	@echo "... install/strip"
+	@echo "... list_install_components"
+	@echo "... rebuild_cache"
+	@echo "... core"
+	@echo "... nanobind-static"
+	@echo "... array.o"
+	@echo "... array.i"
+	@echo "... array.s"
+	@echo "... constants.o"
+	@echo "... constants.i"
+	@echo "... constants.s"
+	@echo "... convert.o"
+	@echo "... convert.i"
+	@echo "... convert.s"
+	@echo "... cuda.o"
+	@echo "... cuda.i"
+	@echo "... cuda.s"
+	@echo "... device.o"
+	@echo "... device.i"
+	@echo "... device.s"
+	@echo "... distributed.o"
+	@echo "... distributed.i"
+	@echo "... distributed.s"
+	@echo "... export.o"
+	@echo "... export.i"
+	@echo "... export.s"
+	@echo "... fast.o"
+	@echo "... fast.i"
+	@echo "... fast.s"
+	@echo "... fft.o"
+	@echo "... fft.i"
+	@echo "... fft.s"
+	@echo "... indexing.o"
+	@echo "... indexing.i"
+	@echo "... indexing.s"
+	@echo "... linalg.o"
+	@echo "... linalg.i"
+	@echo "... linalg.s"
+	@echo "... load.o"
+	@echo "... load.i"
+	@echo "... load.s"
+	@echo "... memory.o"
+	@echo "... memory.i"
+	@echo "... memory.s"
+	@echo "... metal.o"
+	@echo "... metal.i"
+	@echo "... metal.s"
+	@echo "... mlx.o"
+	@echo "... mlx.i"
+	@echo "... mlx.s"
+	@echo "... mlx_func.o"
+	@echo "... mlx_func.i"
+	@echo "... mlx_func.s"
+	@echo "... ops.o"
+	@echo "... ops.i"
+	@echo "... ops.s"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.o"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.i"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/common.s"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.o"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.i"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/error.s"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.o"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.i"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/implicit.s"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.o"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.i"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_enum.s"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.o"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.i"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_func.s"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.o"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.i"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_internals.s"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.o"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.i"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_ndarray.s"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.o"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.i"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_static_property.s"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.o"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.i"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/nb_type.s"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.o"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.i"
+	@echo "... proj/cvl/users/x_fahkh2/caches/pip-build-env-vont0ixn/overlay/lib/python3.10/site-packages/nanobind/src/trampoline.s"
+	@echo "... random.o"
+	@echo "... random.i"
+	@echo "... random.s"
+	@echo "... stream.o"
+	@echo "... stream.i"
+	@echo "... stream.s"
+	@echo "... transforms.o"
+	@echo "... transforms.i"
+	@echo "... transforms.s"
+	@echo "... trees.o"
+	@echo "... trees.i"
+	@echo "... trees.s"
+	@echo "... utils.o"
+	@echo "... utils.i"
+	@echo "... utils.s"
+.PHONY : help
+
+
+
+#=============================================================================
+# Special targets to cleanup operation of make.
+
+# Special rule to run CMake to check the build system integrity.
+# No rule that depends on this can have commands that come from listfiles
+# because they might be regenerated.
+cmake_check_build_system:
+	cd /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
+.PHONY : cmake_check_build_system
+
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/cmake_install.cmake b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/cmake_install.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..62acd9cb79c9ea7f3e0b21d745acb3c0756edd52
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/cmake_install.cmake
@@ -0,0 +1,50 @@
+# Install script for directory: /proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/python/src
+
+# Set the install prefix
+if(NOT DEFINED CMAKE_INSTALL_PREFIX)
+  set(CMAKE_INSTALL_PREFIX "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/lib.linux-x86_64-cpython-310/mlx")
+endif()
+string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
+
+# Set the install configuration name.
+if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
+  if(BUILD_TYPE)
+    string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
+           CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
+  else()
+    set(CMAKE_INSTALL_CONFIG_NAME "Release")
+  endif()
+  message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
+endif()
+
+# Set the component getting installed.
+if(NOT CMAKE_INSTALL_COMPONENT)
+  if(COMPONENT)
+    message(STATUS "Install component: \"${COMPONENT}\"")
+    set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
+  else()
+    set(CMAKE_INSTALL_COMPONENT)
+  endif()
+endif()
+
+# Install shared libraries without execute permission?
+if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
+  set(CMAKE_INSTALL_SO_NO_EXE "0")
+endif()
+
+# Is this installation the result of a crosscompile?
+if(NOT DEFINED CMAKE_CROSSCOMPILING)
+  set(CMAKE_CROSSCOMPILING "FALSE")
+endif()
+
+# Set path to fallback-tool for dependency-resolution.
+if(NOT DEFINED CMAKE_OBJDUMP)
+  set(CMAKE_OBJDUMP "/usr/bin/objdump")
+endif()
+
+string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
+       "${CMAKE_INSTALL_MANIFEST_FILES}")
+if(CMAKE_INSTALL_LOCAL_ONLY)
+  file(WRITE "/proj/cvl/users/x_fahkh2/coreml/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/install_local_manifest.txt"
+     "${CMAKE_INSTALL_MANIFEST_CONTENT}")
+endif()
diff --git a/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/libnanobind-static.a b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/libnanobind-static.a
new file mode 100644
index 0000000000000000000000000000000000000000..0fe10d7a5ac0a687fe7de92f0cbd79ff9eb94b7a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/build/temp.linux-x86_64-cpython-310/mlx.core/python/src/libnanobind-static.a
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b6285a6a75f33608071ecf3f6f10e35343fe02bbc554427ed893102294d05545
+size 520508
diff --git a/ml-stable-diffusion/mlx/cmake/FindNCCL.cmake b/ml-stable-diffusion/mlx/cmake/FindNCCL.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b3189324162509e4e127fd6ff3c035f70acb8dc6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/cmake/FindNCCL.cmake
@@ -0,0 +1,54 @@
+# FindNCCL.cmake This module finds the NVIDIA NCCL library and its include
+# directories.
+
+set(NCCL_ROOT_DIR
+    $ENV{NCCL_ROOT_DIR}
+    CACHE PATH "Folder contains NVIDIA NCCL")
+
+find_path(
+  NCCL_INCLUDE_DIRS
+  NAMES nccl.h
+  HINTS ${NCCL_INCLUDE_DIR} ${NCCL_ROOT_DIR} ${NCCL_ROOT_DIR}/include
+        ${CUDA_TOOLKIT_ROOT_DIR}/include)
+
+if($ENV{USE_STATIC_NCCL})
+  message(
+    STATUS "USE_STATIC_NCCL detected. Linking against static NCCL library")
+  set(NCCL_LIBNAME "libnccl_static.a")
+else()
+  set(NCCL_LIBNAME "nccl")
+endif()
+
+find_library(
+  NCCL_LIBRARIES
+  NAMES ${NCCL_LIBNAME}
+  HINTS ${NCCL_LIB_DIR}
+        ${NCCL_ROOT_DIR}
+        ${NCCL_ROOT_DIR}/lib
+        ${NCCL_ROOT_DIR}/lib/x86_64-linux-gnu
+        ${NCCL_ROOT_DIR}/lib64
+        ${CUDA_TOOLKIT_ROOT_DIR}/lib
+        ${CUDA_TOOLKIT_ROOT_DIR}/lib64)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(NCCL DEFAULT_MSG NCCL_INCLUDE_DIRS
+                                  NCCL_LIBRARIES)
+
+if(NCCL_FOUND)
+  set(NCCL_HEADER_FILE "${NCCL_INCLUDE_DIRS}/nccl.h")
+  message(
+    STATUS "Determining NCCL version from the header file: ${NCCL_HEADER_FILE}")
+  file(
+    STRINGS ${NCCL_HEADER_FILE} NCCL_MAJOR_VERSION_DEFINED
+    REGEX "^[ \t]*#define[ \t]+NCCL_MAJOR[ \t]+[0-9]+.*$"
+    LIMIT_COUNT 1)
+  if(NCCL_MAJOR_VERSION_DEFINED)
+    string(REGEX REPLACE "^[ \t]*#define[ \t]+NCCL_MAJOR[ \t]+" ""
+                         NCCL_MAJOR_VERSION ${NCCL_MAJOR_VERSION_DEFINED})
+    message(STATUS "NCCL_MAJOR_VERSION: ${NCCL_MAJOR_VERSION}")
+  endif()
+  message(
+    STATUS
+      "Found NCCL (include: ${NCCL_INCLUDE_DIRS}, library: ${NCCL_LIBRARIES})")
+  mark_as_advanced(NCCL_ROOT_DIR NCCL_INCLUDE_DIRS NCCL_LIBRARIES)
+endif()
diff --git a/ml-stable-diffusion/mlx/cmake/extension.cmake b/ml-stable-diffusion/mlx/cmake/extension.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..13db804a1c57eeae6243e13f481d4f0ceb9afead
--- /dev/null
+++ b/ml-stable-diffusion/mlx/cmake/extension.cmake
@@ -0,0 +1,50 @@
+include(CMakeParseArguments)
+
+# clang format off
+#
+# ##############################################################################
+# Build metal library
+#
+# Adds a custom target ${TARGET} to build ${OUTPUT_DIRECTORY}/{TITLE}.metallib
+# from list ${SOURCES}, including list ${INCLUDE_DIRS}, depends on list ${DEPS}
+#
+# Args: TARGET: Custom target to be added for the metal library TITLE: Name of
+# the .metallib OUTPUT_DIRECTORY: Where to place ${TITLE}.metallib SOURCES: List
+# of source files INCLUDE_DIRS: List of include dirs DEPS: List of dependency
+# files (like headers) DEBUG: Boolean, if true, enables debug compile options
+# for this specific library. If not provided, uses global MLX_METAL_DEBUG.
+#
+# clang format on
+
+macro(mlx_build_metallib)
+  # Parse args
+  set(oneValueArgs TARGET TITLE OUTPUT_DIRECTORY DEBUG)
+  set(multiValueArgs SOURCES INCLUDE_DIRS DEPS)
+  cmake_parse_arguments(MTLLIB "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+  # Set output
+  set(MTLLIB_BUILD_TARGET "${MTLLIB_OUTPUT_DIRECTORY}/${MTLLIB_TITLE}.metallib")
+
+  # Collect compile options
+  set(MTLLIB_COMPILE_OPTIONS -Wall -Wextra -fno-fast-math -Wno-c++17-extensions)
+  if(MLX_METAL_DEBUG OR MTLLIB_DEBUG)
+    set(MTLLIB_COMPILE_OPTIONS ${MTLLIB_COMPILE_OPTIONS} -gline-tables-only
+                               -frecord-sources)
+  endif()
+
+  # Prepare metallib build command
+  add_custom_command(
+    OUTPUT ${MTLLIB_BUILD_TARGET}
+    COMMAND
+      xcrun -sdk macosx metal
+      "$<LIST:TRANSFORM,${MTLLIB_INCLUDE_DIRS},PREPEND,-I>"
+      ${MTLLIB_COMPILE_OPTIONS} ${MTLLIB_SOURCES} -o ${MTLLIB_BUILD_TARGET}
+    DEPENDS ${MTLLIB_DEPS} ${MTLLIB_SOURCES}
+    COMMAND_EXPAND_LISTS
+    COMMENT "Building ${MTLLIB_TITLE}.metallib"
+    VERBATIM)
+
+  # Add metallib custom target
+  add_custom_target(${MTLLIB_TARGET} DEPENDS ${MTLLIB_BUILD_TARGET})
+
+endmacro(mlx_build_metallib)
diff --git a/ml-stable-diffusion/mlx/docs/.clang-format b/ml-stable-diffusion/mlx/docs/.clang-format
new file mode 100644
index 0000000000000000000000000000000000000000..47a38a93f2dbdd6d944f9dddc3465e3fb65aec29
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/.clang-format
@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: Never
diff --git a/ml-stable-diffusion/mlx/docs/.gitignore b/ml-stable-diffusion/mlx/docs/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..fa80a135e6a052eaaf552e328ba083a0c6e2e9f8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/.gitignore
@@ -0,0 +1,3 @@
+src/python/_autosummary*/
+src/python/nn/_autosummary*/
+src/python/optimizers/_autosummary*/
diff --git a/ml-stable-diffusion/mlx/docs/.nojekyll b/ml-stable-diffusion/mlx/docs/.nojekyll
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/ml-stable-diffusion/mlx/docs/Doxyfile b/ml-stable-diffusion/mlx/docs/Doxyfile
new file mode 100644
index 0000000000000000000000000000000000000000..e47712d44e9d456775c8eaa5aa05cfabc0f8c9e4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/Doxyfile
@@ -0,0 +1,50 @@
+################################################################################
+# Primary project setup.                                                       #
+################################################################################
+
+PROJECT_NAME           = "MLX"
+OUTPUT_DIRECTORY       = build
+XML_OUTPUT             = xml
+HTML_OUTPUT            = html
+STRIP_FROM_PATH        = ../
+INPUT                  = ../mlx
+FILE_PATTERNS          = *.h
+EXCLUDE_PATTERNS       = */private/*
+CREATE_SUBDIRS         = NO
+FULL_PATH_NAMES        = YES
+RECURSIVE              = YES
+GENERATE_HTML          = NO
+GENERATE_LATEX         = NO
+GENERATE_XML           = YES
+XML_PROGRAMLISTING     = YES
+
+################################################################################
+# Doxygen preprocessor / parser control.                                       #
+################################################################################
+
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = YES
+EXPAND_ONLY_PREDEF     = NO
+SKIP_FUNCTION_MACROS   = NO
+
+################################################################################
+# Compound extraction control.                                                 #
+################################################################################
+
+EXTRACT_ALL            = YES
+EXTRACT_PACKAGE        = YES
+EXTRACT_STATIC         = YES
+CASE_SENSE_NAMES       = NO
+
+################################################################################
+# Docstring control / customization.                                           #
+################################################################################
+
+JAVADOC_AUTOBRIEF      = YES
+
+################################################################################
+# Warning suppression.                                                         #
+################################################################################
+
+QUIET                  = YES
+WARN_IF_UNDOCUMENTED   = NO
diff --git a/ml-stable-diffusion/mlx/docs/Makefile b/ml-stable-diffusion/mlx/docs/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..e5888bc2f1f5984ac2bd3fbdb486cd16dc918431
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/Makefile
@@ -0,0 +1,18 @@
+# Minimal makefile for Sphinx documentation
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+SOURCEDIR     = src
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/ml-stable-diffusion/mlx/docs/README.md b/ml-stable-diffusion/mlx/docs/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..cfa8724172caee69a984bc6653b0cf7173f866bc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/README.md
@@ -0,0 +1,40 @@
+## Build the Docs
+
+### Setup (do once)
+
+Install Doxygen:
+
+```
+brew install doxygen
+```
+
+Install Python packages:
+
+```
+pip install -r requirements.txt
+```
+
+### Build
+
+Build the docs from `mlx/docs/`
+
+```
+doxygen && make html
+```
+
+View the docs by running a server in `mlx/docs/build/html/`:
+
+```
+python -m http.server <port>
+```
+
+and point your browser to `http://localhost:<port>`.
+
+### Push to GitHub Pages
+
+Check-out the `gh-pages` branch (`git switch gh-pages`) and build
+the docs. Then force add the `build/html` directory:
+
+`git add -f build/html`
+
+Commit and push the changes to the `gh-pages` branch.
diff --git a/ml-stable-diffusion/mlx/docs/index.html b/ml-stable-diffusion/mlx/docs/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..0707108937b1e335e54b4d12e59883e81d3872e0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/index.html
@@ -0,0 +1 @@
+<meta http-equiv="refresh" content="0; url=./build/html/index.html" />
diff --git a/ml-stable-diffusion/mlx/docs/requirements.txt b/ml-stable-diffusion/mlx/docs/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..06404fa750cfc153a9212bf907118256a79aa569
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/requirements.txt
@@ -0,0 +1,5 @@
+sphinx
+breathe
+sphinx-book-theme
+sphinx-copybutton
+mlx
diff --git a/ml-stable-diffusion/mlx/docs/src/_static/metal_debugger/capture.png b/ml-stable-diffusion/mlx/docs/src/_static/metal_debugger/capture.png
new file mode 100644
index 0000000000000000000000000000000000000000..651d5a62185833d285a42175e9195de334ed0e1d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/_static/metal_debugger/capture.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c8422a23353cd95cfcca5e91c7943b2281feb6eed4547a75713cf63056e96bf0
+size 1270056
diff --git a/ml-stable-diffusion/mlx/docs/src/_static/metal_debugger/schema.png b/ml-stable-diffusion/mlx/docs/src/_static/metal_debugger/schema.png
new file mode 100644
index 0000000000000000000000000000000000000000..03a868c03775b90afff8a49777c03ddffae86897
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/_static/metal_debugger/schema.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48b68d25f4058b9bd5547f6740353eea900c36cf6fb610a601c82137a605c35c
+size 763831
diff --git a/ml-stable-diffusion/mlx/docs/src/_static/mlx_logo.png b/ml-stable-diffusion/mlx/docs/src/_static/mlx_logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..be122bf7cd07560f1118eef458da8e472de6a8d2
Binary files /dev/null and b/ml-stable-diffusion/mlx/docs/src/_static/mlx_logo.png differ
diff --git a/ml-stable-diffusion/mlx/docs/src/_static/mlx_logo_dark.png b/ml-stable-diffusion/mlx/docs/src/_static/mlx_logo_dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..cda3c1f61326b05c26d7248e6a44816043d0c424
Binary files /dev/null and b/ml-stable-diffusion/mlx/docs/src/_static/mlx_logo_dark.png differ
diff --git a/ml-stable-diffusion/mlx/docs/src/_templates/module-base-class.rst b/ml-stable-diffusion/mlx/docs/src/_templates/module-base-class.rst
new file mode 100644
index 0000000000000000000000000000000000000000..08371fb01ed1a9f2c76992d2999f587bfce34f76
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/_templates/module-base-class.rst
@@ -0,0 +1,33 @@
+{{ fullname | escape | underline}}
+
+.. currentmodule:: {{ module }}
+
+.. add toctree option to make autodoc generate the pages
+
+.. autoclass:: {{ objname }}
+
+   {% block attributes %}
+   {% if attributes %}
+   .. rubric:: Attributes
+
+   .. autosummary::
+      :toctree: .
+   {% for item in attributes %}
+      ~{{ fullname }}.{{ item }}
+   {%- endfor %}
+   {% endif %}
+   {% endblock %}
+
+   {% block methods %}
+   {% if methods %}
+   .. rubric:: Methods
+
+   .. autosummary::
+      :toctree: .
+   {% for item in methods %}
+      {%- if item not in inherited_members and item != '__init__' %}
+      ~{{ fullname }}.{{ item }}
+      {%- endif -%}
+   {%- endfor %}
+   {% endif %}
+   {% endblock %}
diff --git a/ml-stable-diffusion/mlx/docs/src/_templates/nn-module-template.rst b/ml-stable-diffusion/mlx/docs/src/_templates/nn-module-template.rst
new file mode 100644
index 0000000000000000000000000000000000000000..9e8b5cc744d43d988a7e34a1ecda82ac00c1d39f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/_templates/nn-module-template.rst
@@ -0,0 +1,20 @@
+{{ fullname | escape | underline}}
+
+.. currentmodule:: {{ module }}
+
+.. autoclass:: {{ objname }}
+
+   {% block methods %}
+
+   {% if methods %}
+   .. rubric:: {{ _('Methods') }}
+
+   .. autosummary::
+   {% for item in methods %}
+      {%- if item not in inherited_members and item != "__init__" %}
+         ~{{ name }}.{{ item }}
+      {%- endif %}
+   {%- endfor %}
+   {% endif %}
+   {% endblock %}
+
diff --git a/ml-stable-diffusion/mlx/docs/src/_templates/optimizers-template.rst b/ml-stable-diffusion/mlx/docs/src/_templates/optimizers-template.rst
new file mode 100644
index 0000000000000000000000000000000000000000..80f049b4af74db488d53280f5dbbb89e9ee0f90a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/_templates/optimizers-template.rst
@@ -0,0 +1,20 @@
+{{ fullname | escape | underline}}
+
+.. currentmodule:: {{ module }}
+
+.. autoclass:: {{ objname }}
+
+   {% block methods %}
+
+   {% if methods %}
+   .. rubric:: {{ _('Methods') }}
+
+   .. autosummary::
+   {% for item in methods %}
+      {%- if item not in inherited_members %}
+         ~{{ name }}.{{ item }}
+      {%- endif %}
+   {%- endfor %}
+   {% endif %}
+   {% endblock %}
+
diff --git a/ml-stable-diffusion/mlx/docs/src/conf.py b/ml-stable-diffusion/mlx/docs/src/conf.py
new file mode 100644
index 0000000000000000000000000000000000000000..446d95cd20af45bfa0726354e470c1d7394748fd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/conf.py
@@ -0,0 +1,99 @@
+# Copyright © 2023 Apple Inc.
+
+# -*- coding: utf-8 -*-
+
+import os
+import subprocess
+
+import mlx.core as mx
+
+# -- Project information -----------------------------------------------------
+
+project = "MLX"
+copyright = "2023, Apple"
+author = "MLX Contributors"
+version = ".".join(mx.__version__.split(".")[:3])
+release = version
+
+# -- General configuration ---------------------------------------------------
+
+extensions = [
+    "sphinx_copybutton",
+    "sphinx.ext.autodoc",
+    "sphinx.ext.autosummary",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.napoleon",
+    "breathe",
+]
+
+python_use_unqualified_type_names = True
+autosummary_generate = True
+autosummary_filename_map = {"mlx.core.Stream": "stream_class"}
+
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3", None),
+    "numpy": ("https://numpy.org/doc/stable/", None),
+}
+
+breathe_projects = {"mlx": "../build/xml"}
+breathe_default_project = "mlx"
+
+templates_path = ["_templates"]
+html_static_path = ["_static"]
+source_suffix = ".rst"
+main_doc = "index"
+highlight_language = "python"
+pygments_style = "sphinx"
+add_module_names = False
+
+# -- Options for HTML output -------------------------------------------------
+
+html_theme = "sphinx_book_theme"
+
+html_theme_options = {
+    "show_toc_level": 2,
+    "repository_url": "https://github.com/ml-explore/mlx",
+    "use_repository_button": True,
+    "navigation_with_keys": False,
+    "logo": {
+        "image_light": "_static/mlx_logo.png",
+        "image_dark": "_static/mlx_logo_dark.png",
+    },
+}
+
+html_favicon = html_theme_options["logo"]["image_light"]
+
+# -- Options for HTMLHelp output ---------------------------------------------
+
+htmlhelp_basename = "mlx_doc"
+
+
+def setup(app):
+    from sphinx.util import inspect
+
+    wrapped_isfunc = inspect.isfunction
+
+    def isfunc(obj):
+        type_name = str(type(obj))
+        if "nanobind.nb_method" in type_name or "nanobind.nb_func" in type_name:
+            return True
+        return wrapped_isfunc(obj)
+
+    inspect.isfunction = isfunc
+
+
+# -- Options for LaTeX output ------------------------------------------------
+
+latex_documents = [(main_doc, "MLX.tex", "MLX Documentation", author, "manual")]
+latex_elements = {
+    "preamble": r"""
+    \usepackage{enumitem}
+    \setlistdepth{5}
+    \setlist[itemize,1]{label=$\bullet$}
+    \setlist[itemize,2]{label=$\bullet$}
+    \setlist[itemize,3]{label=$\bullet$}
+    \setlist[itemize,4]{label=$\bullet$}
+    \setlist[itemize,5]{label=$\bullet$}
+    \renewlist{itemize}{itemize}{5}
+""",
+}
diff --git a/ml-stable-diffusion/mlx/docs/src/cpp/ops.rst b/ml-stable-diffusion/mlx/docs/src/cpp/ops.rst
new file mode 100644
index 0000000000000000000000000000000000000000..009a10b1e07c654ffd2e71c11cac3692672d730b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/cpp/ops.rst
@@ -0,0 +1,7 @@
+.. _cpp_ops:
+
+Operations
+==========
+
+.. doxygengroup:: ops
+   :content-only:
diff --git a/ml-stable-diffusion/mlx/docs/src/dev/custom_metal_kernels.rst b/ml-stable-diffusion/mlx/docs/src/dev/custom_metal_kernels.rst
new file mode 100644
index 0000000000000000000000000000000000000000..4c4ce65aebe97b61eb0056c7b9ba410909e79460
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/dev/custom_metal_kernels.rst
@@ -0,0 +1,445 @@
+.. _custom_metal_kernels:
+
+Custom Metal Kernels
+====================
+
+MLX supports writing custom Metal kernels through the Python and C++ APIs.
+
+Simple Example
+--------------
+
+.. currentmodule:: mlx.core
+
+Let's write a custom kernel that computes ``exp`` elementwise:
+
+.. code-block:: python
+
+  source = """
+      uint elem = thread_position_in_grid.x;
+      T tmp = inp[elem];
+      out[elem] = metal::exp(tmp);
+  """
+
+  kernel = mx.fast.metal_kernel(
+      name="myexp",
+      input_names=["inp"],
+      output_names=["out"],
+      source=source,
+  )
+
+  def exp_elementwise(a: mx.array):
+      outputs = kernel(
+          inputs=[a],
+          template=[("T", mx.float32)],
+          grid=(a.size, 1, 1),
+          threadgroup=(256, 1, 1),
+          output_shapes=[a.shape],
+          output_dtypes=[a.dtype],
+      )
+      return outputs[0]
+
+  a = mx.random.normal(shape=(4, 16)).astype(mx.float16)
+  b = exp_elementwise(a)
+  assert mx.allclose(b, mx.exp(a))
+
+Every time you make a kernel, a new Metal library is created and possibly
+JIT compiled. To reduce the overhead from that, build the kernel once with
+:func:`fast.metal_kernel` and then use it many times.
+
+.. note::
+   Only pass the body of the Metal kernel in ``source``. The function
+   signature is generated automatically.
+
+The full function signature will be generated using:
+
+* The shapes/dtypes of ``inputs``
+    In the above, ``a`` is an ``mx.array`` of type ``mx.float16`` and we pass it with the key ``inp``
+    so we will add ``const device float16_t* inp`` to the signature.
+    ``inp_shape``, ``inp_strides`` and ``inp_ndim`` are also added for convenience if they are present
+    in ``source``.
+* The list of ``output_dtypes``
+    In the above, ``out`` is an ``mx.array`` of type ``mx.float16``
+    so we add ``device float16_t* out``.
+* Template parameters passed using ``template``
+    In the above, ``template=[("T", mx.float32)]`` adds a template of ``template <typename T>`` to the function
+    and instantiates the template with ``custom_kernel_myexp_float<float>``.
+    Template parameters can be ``mx.core.Dtype``, ``int`` or ``bool``.
+* Metal attributes used in ``source`` such as ``[[thread_position_in_grid]]``
+    These will be added as function arguments.
+    All the attributes defined in Table 5.8 of the `Metal Shading Language Specification <https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf>`_ are supported.
+
+Putting this all together, the generated function signature for ``myexp`` is as follows:
+
+.. code-block:: cpp
+
+  template <typename T>
+  [[kernel]] void custom_kernel_myexp_float(
+    const device float16_t* inp [[buffer(0)]],
+    device float16_t* out [[buffer(1)]],
+    uint3 thread_position_in_grid [[thread_position_in_grid]]) {
+
+          uint elem = thread_position_in_grid.x;
+          T tmp = inp[elem];
+          out[elem] = metal::exp(tmp);
+
+  }
+
+  template [[host_name("custom_kernel_myexp_float")]] [[kernel]] decltype(custom_kernel_myexp_float<float>) custom_kernel_myexp_float<float>;
+
+Note: ``grid`` and ``threadgroup`` are parameters to the Metal `dispatchThreads
+<https://developer.apple.com/documentation/metal/mtlcomputecommandencoder/2866532-dispatchthreads>`_
+function. This means we will launch ``mx.prod(grid)`` threads, subdivided into
+``threadgroup`` size threadgroups.  For optimal performance, each thread group
+dimension should be less than or equal to the corresponding grid dimension.
+
+Passing ``verbose=True`` to :func:`ast.metal_kernel.__call__` will print the
+generated code for debugging purposes.
+
+Using Shape/Strides
+-------------------
+
+:func:`fast.metal_kernel` supports an argument ``ensure_row_contiguous`` which
+is ``True`` by default. This will copy the array inputs if needed
+before the kernel is launched to ensure that the memory layout is row
+contiguous.  Generally this makes writing the kernel easier, since we don't
+have to worry about gaps or the ordering of the dims when indexing.
+
+If we want to avoid this copy, :func:`fast.metal_kernel` automatically passes
+``a_shape``, ``a_strides`` and ``a_ndim`` for each input array ``a`` if any are
+present in ``source``. We can then use MLX's built in indexing utils to fetch
+the right elements for each thread.
+
+Let's convert ``myexp`` above to support arbitrarily strided arrays without
+relying on a copy from ``ensure_row_contiguous``:
+
+.. code-block:: python
+   
+  source = """
+      uint elem = thread_position_in_grid.x;
+      // Utils from `mlx/backend/metal/kernels/utils.h` are automatically included
+      uint loc = elem_to_loc(elem, inp_shape, inp_strides, inp_ndim);
+      T tmp = inp[loc];
+      // Output arrays are always row contiguous
+      out[elem] = metal::exp(tmp);
+  """
+
+  kernel = mx.fast.metal_kernel(
+      name="myexp_strided",
+      input_names=["inp"],
+      output_names=["out"],
+      source=source,
+      ensure_row_contiguous=False,
+  )
+
+  def exp_elementwise(a: mx.array):
+      outputs = kernel(
+          inputs=[a],
+          template=[("T", mx.float32)],
+          grid=(a.size, 1, 1),
+          threadgroup=(256, 1, 1),
+          output_shapes=[a.shape],
+          output_dtypes=[a.dtype],
+      )
+      return outputs[0]
+
+  a = mx.random.normal(shape=(4, 16)).astype(mx.float16)
+  # make non-contiguous
+  a = a[::2]
+  b = exp_elementwise(a)
+  assert mx.allclose(b, mx.exp(a))
+
+Complex Example
+-----------------------------
+
+Let's implement a more complex example: ``grid_sample`` in ``"bilinear"`` mode.
+
+We'll start with the following MLX implementation using standard ops:
+
+.. code-block:: python
+
+  def grid_sample_ref(x, grid):
+      N, H_in, W_in, _ = x.shape
+      ix = ((grid[..., 0] + 1) * W_in - 1) / 2
+      iy = ((grid[..., 1] + 1) * H_in - 1) / 2
+
+      ix_nw = mx.floor(ix).astype(mx.int32)
+      iy_nw = mx.floor(iy).astype(mx.int32)
+
+      ix_ne = ix_nw + 1
+      iy_ne = iy_nw
+
+      ix_sw = ix_nw
+      iy_sw = iy_nw + 1
+
+      ix_se = ix_nw + 1
+      iy_se = iy_nw + 1
+
+      nw = (ix_se - ix)    * (iy_se - iy)
+      ne = (ix    - ix_sw) * (iy_sw - iy)
+      sw = (ix_ne - ix)    * (iy    - iy_ne)
+      se = (ix    - ix_nw) * (iy    - iy_nw)
+
+      I_nw = x[mx.arange(N)[:, None, None], iy_nw, ix_nw, :]
+      I_ne = x[mx.arange(N)[:, None, None], iy_ne, ix_ne, :]
+      I_sw = x[mx.arange(N)[:, None, None], iy_sw, ix_sw, :]
+      I_se = x[mx.arange(N)[:, None, None], iy_se, ix_se, :]
+
+      mask_nw = (iy_nw >= 0) & (iy_nw <= H_in - 1) & (ix_nw >= 0) & (ix_nw <= W_in - 1)
+      mask_ne = (iy_ne >= 0) & (iy_ne <= H_in - 1) & (ix_ne >= 0) & (ix_ne <= W_in - 1)
+      mask_sw = (iy_sw >= 0) & (iy_sw <= H_in - 1) & (ix_sw >= 0) & (ix_sw <= W_in - 1)
+      mask_se = (iy_se >= 0) & (iy_se <= H_in - 1) & (ix_se >= 0) & (ix_se <= W_in - 1)
+
+      I_nw *= mask_nw[..., None]
+      I_ne *= mask_ne[..., None]
+      I_sw *= mask_sw[..., None]
+      I_se *= mask_se[..., None]
+
+      output = nw[..., None] * I_nw + ne[..., None] * I_ne + sw[..., None] * I_sw + se[..., None] * I_se
+
+      return output
+
+Now let's use :func:`custom_function` together with :func:`fast.metal_kernel`
+to write a fast GPU kernel for both the forward and backward passes.
+
+First we'll implement the forward pass as a fused kernel:
+
+.. code-block:: python
+
+  source = """
+      uint elem = thread_position_in_grid.x;
+      int H = x_shape[1];
+      int W = x_shape[2];
+      int C = x_shape[3];
+      int gH = grid_shape[1];
+      int gW = grid_shape[2];
+
+      int w_stride = C;
+      int h_stride = W * w_stride;
+      int b_stride = H * h_stride;
+
+      uint grid_idx = elem / C * 2;
+      float ix = ((grid[grid_idx] + 1) * W - 1) / 2;
+      float iy = ((grid[grid_idx + 1] + 1) * H - 1) / 2;
+
+      int ix_nw = floor(ix);
+      int iy_nw = floor(iy);
+
+      int ix_ne = ix_nw + 1;
+      int iy_ne = iy_nw;
+
+      int ix_sw = ix_nw;
+      int iy_sw = iy_nw + 1;
+
+      int ix_se = ix_nw + 1;
+      int iy_se = iy_nw + 1;
+
+      T nw = (ix_se - ix)    * (iy_se - iy);
+      T ne = (ix    - ix_sw) * (iy_sw - iy);
+      T sw = (ix_ne - ix)    * (iy    - iy_ne);
+      T se = (ix    - ix_nw) * (iy    - iy_nw);
+
+      int batch_idx = elem / C / gH / gW * b_stride;
+      int channel_idx = elem % C;
+      int base_idx = batch_idx + channel_idx;
+
+      T I_nw = x[base_idx + iy_nw * h_stride + ix_nw * w_stride];
+      T I_ne = x[base_idx + iy_ne * h_stride + ix_ne * w_stride];
+      T I_sw = x[base_idx + iy_sw * h_stride + ix_sw * w_stride];
+      T I_se = x[base_idx + iy_se * h_stride + ix_se * w_stride];
+
+      I_nw = iy_nw >= 0 && iy_nw <= H - 1 && ix_nw >= 0 && ix_nw <= W - 1 ? I_nw : 0;
+      I_ne = iy_ne >= 0 && iy_ne <= H - 1 && ix_ne >= 0 && ix_ne <= W - 1 ? I_ne : 0;
+      I_sw = iy_sw >= 0 && iy_sw <= H - 1 && ix_sw >= 0 && ix_sw <= W - 1 ? I_sw : 0;
+      I_se = iy_se >= 0 && iy_se <= H - 1 && ix_se >= 0 && ix_se <= W - 1 ? I_se : 0;
+
+      out[elem] = nw * I_nw + ne * I_ne + sw * I_sw + se * I_se;
+  """
+
+  kernel = mx.fast.metal_kernel(
+      name="grid_sample",
+      input_names=["x", "grid"],
+      output_names=["out"],
+      source=source,
+  )
+
+  @mx.custom_function
+  def grid_sample(x, grid):
+
+      assert x.ndim == 4, "`x` must be 4D."
+      assert grid.ndim == 4, "`grid` must be 4D."
+
+      B, _, _, C = x.shape
+      _, gN, gM, D = grid.shape
+      out_shape = (B, gN, gM, C)
+
+      assert D == 2, "Last dim of `grid` must be size 2."
+
+      outputs = kernel(
+          inputs=[x, grid],
+          template=[("T", x.dtype)],
+          output_shapes=[out_shape],
+          output_dtypes=[x.dtype],
+          grid=(np.prod(out_shape), 1, 1),
+          threadgroup=(256, 1, 1),
+      )
+      return outputs[0]
+
+For a reasonably sized input such as:
+
+.. code-block:: python
+
+  x.shape = (8, 1024, 1024, 64)
+  grid.shape = (8, 256, 256, 2)
+
+On an M1 Max, we see a big performance improvement:
+
+``55.7ms -> 6.7ms => 8x speed up``
+
+Grid Sample VJP
+---------------
+
+Since we decorated ``grid_sample`` with :func:`custom_function`, we can now
+define its custom vjp transform so MLX can differentiate it.
+
+The backwards pass requires atomically updating ``x_grad``/``grid_grad`` and so
+requires a few extra :func:`fast.metal_kernel` features:
+
+* ``init_value=0``
+    Initialize all of the kernel's outputs to this value before it runs. This allows us to update only part of the output arrays with the kernel.
+
+* ``atomic_outputs=True``
+    Designate all of the kernel outputs as ``atomic`` in the function signature. 
+    This means we can use Metal's ``atomic`` features to simultaneously update the ``x_grad`` and ``grid_grad`` arrays from multiple threadgroups. 
+    See section 6.15 of the `Metal Shading Language Specification <https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf>`_ for more details.
+
+We can then implement the backwards pass as follows:
+
+.. code-block:: python
+
+  source = """
+      uint elem = thread_position_in_grid.x;
+      int H = x_shape[1];
+      int W = x_shape[2];
+      int C = x_shape[3];
+      // Pad C to the nearest larger simdgroup size multiple
+      int C_padded = ceildiv(C, threads_per_simdgroup) * threads_per_simdgroup;
+
+      int gH = grid_shape[1];
+      int gW = grid_shape[2];
+
+      int w_stride = C;
+      int h_stride = W * w_stride;
+      int b_stride = H * h_stride;
+
+      uint grid_idx = elem / C_padded * 2;
+      float ix = ((grid[grid_idx] + 1) * W - 1) / 2;
+      float iy = ((grid[grid_idx + 1] + 1) * H - 1) / 2;
+
+      int ix_nw = floor(ix);
+      int iy_nw = floor(iy);
+
+      int ix_ne = ix_nw + 1;
+      int iy_ne = iy_nw;
+
+      int ix_sw = ix_nw;
+      int iy_sw = iy_nw + 1;
+
+      int ix_se = ix_nw + 1;
+      int iy_se = iy_nw + 1;
+
+      T nw = (ix_se - ix)    * (iy_se - iy);
+      T ne = (ix    - ix_sw) * (iy_sw - iy);
+      T sw = (ix_ne - ix)    * (iy    - iy_ne);
+      T se = (ix    - ix_nw) * (iy    - iy_nw);
+
+      int batch_idx = elem / C_padded / gH / gW * b_stride;
+      int channel_idx = elem % C_padded;
+      int base_idx = batch_idx + channel_idx;
+
+      T gix = T(0);
+      T giy = T(0);
+      if (channel_idx < C) {
+          int cot_index = elem / C_padded * C + channel_idx;
+          T cot = cotangent[cot_index];
+          if (iy_nw >= 0 && iy_nw <= H - 1 && ix_nw >= 0 && ix_nw <= W - 1) {
+              int offset = base_idx + iy_nw * h_stride + ix_nw * w_stride;
+              atomic_fetch_add_explicit(&x_grad[offset], nw * cot, memory_order_relaxed);
+
+              T I_nw = x[offset];
+              gix -= I_nw * (iy_se - iy) * cot;
+              giy -= I_nw * (ix_se - ix) * cot;
+          }
+          if (iy_ne >= 0 && iy_ne <= H - 1 && ix_ne >= 0 && ix_ne <= W - 1) {
+              int offset = base_idx + iy_ne * h_stride + ix_ne * w_stride;
+              atomic_fetch_add_explicit(&x_grad[offset], ne * cot, memory_order_relaxed);
+
+              T I_ne = x[offset];
+              gix += I_ne * (iy_sw - iy) * cot;
+              giy -= I_ne * (ix - ix_sw) * cot;
+          }
+          if (iy_sw >= 0 && iy_sw <= H - 1 && ix_sw >= 0 && ix_sw <= W - 1) {
+              int offset = base_idx + iy_sw * h_stride + ix_sw * w_stride;
+              atomic_fetch_add_explicit(&x_grad[offset], sw * cot, memory_order_relaxed);
+
+              T I_sw = x[offset];
+              gix -= I_sw * (iy - iy_ne) * cot;
+              giy += I_sw * (ix_ne - ix) * cot;
+          }
+          if (iy_se >= 0 && iy_se <= H - 1 && ix_se >= 0 && ix_se <= W - 1) {
+              int offset = base_idx + iy_se * h_stride + ix_se * w_stride;
+              atomic_fetch_add_explicit(&x_grad[offset], se * cot, memory_order_relaxed);
+
+              T I_se = x[offset];
+              gix += I_se * (iy - iy_nw) * cot;
+              giy += I_se * (ix - ix_nw) * cot;
+          }
+      }
+
+      T gix_mult = W / 2;
+      T giy_mult = H / 2;
+
+      // Reduce across each simdgroup first.
+      // This is much faster than relying purely on atomics.
+      gix = simd_sum(gix);
+      giy = simd_sum(giy);
+
+      if (thread_index_in_simdgroup == 0) {
+          atomic_fetch_add_explicit(&grid_grad[grid_idx], gix * gix_mult, memory_order_relaxed);
+          atomic_fetch_add_explicit(&grid_grad[grid_idx + 1], giy * giy_mult, memory_order_relaxed);
+      }
+  """
+  kernel = mx.fast.metal_kernel(
+      name="grid_sample_grad",
+      input_names=["x", "grid", "cotangent"],
+      output_names=["x_grad", "grid_grad"],
+      source=source,
+      atomic_outputs=True,
+  )
+
+  @grid_sample.vjp
+  def grid_sample_vjp(primals, cotangent, _):
+      x, grid = primals
+      B, _, _, C = x.shape
+      _, gN, gM, D = grid.shape
+
+      assert D == 2, "Last dim of `grid` must be size 2."
+
+      # pad the output channels to simd group size
+      # so that our `simd_sum`s don't overlap.
+      simdgroup_size = 32
+      C_padded = (C + simdgroup_size - 1) // simdgroup_size * simdgroup_size
+      grid_size = B * gN * gM * C_padded
+      outputs = kernel(
+          inputs=[x, grid, cotangent],
+          template=[("T", x.dtype)],
+          output_shapes=[x.shape, grid.shape],
+          output_dtypes=[x.dtype, x.dtype],
+          grid=(grid_size, 1, 1),
+          threadgroup=(256, 1, 1),
+          init_value=0,
+      )
+      return outputs[0], outputs[1]
+
+There's an even larger speed up for the vjp:
+
+``676.4ms -> 16.7ms => 40x speed up``
diff --git a/ml-stable-diffusion/mlx/docs/src/dev/extensions.rst b/ml-stable-diffusion/mlx/docs/src/dev/extensions.rst
new file mode 100644
index 0000000000000000000000000000000000000000..8b5bd41e5fb3526ff4ba14d30fab0c8021500616
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/dev/extensions.rst
@@ -0,0 +1,811 @@
+Custom Extensions in MLX
+========================
+
+You can extend MLX with custom operations on the CPU or GPU. This guide
+explains how to do that with a simple example.
+
+Introducing the Example
+-----------------------
+
+Let's say you would like an operation that takes in two arrays, ``x`` and
+``y``, scales them both by coefficients ``alpha`` and ``beta`` respectively,
+and then adds them together to get the result ``z = alpha * x + beta * y``.
+You can do that in MLX directly:
+
+.. code-block:: python
+
+    import mlx.core as mx
+
+    def simple_axpby(x: mx.array, y: mx.array, alpha: float, beta: float) -> mx.array:
+        return alpha * x + beta * y
+
+This function performs that operation while leaving the implementation and
+function transformations to MLX.
+
+However, you may want to customize the underlying implementation, perhaps to
+make it faster. In this tutorial we will go through adding custom extensions.
+It will cover:
+
+* The structure of the MLX library.
+* Implementing a CPU operation.
+* Implementing a GPU operation using metal.
+* Adding the ``vjp`` and ``jvp`` function transformation.
+* Building a custom extension and binding it to python.
+
+Operations and Primitives
+-------------------------
+
+Operations in MLX build the computation graph. Primitives provide the rules for
+evaluating and transforming the graph. Let's start by discussing operations in
+more detail.
+
+Operations
+^^^^^^^^^^^
+
+Operations are the front-end functions that operate on arrays. They are defined
+in the C++ API (:ref:`cpp_ops`), and the Python API (:ref:`ops`) binds them.
+
+We would like an operation :meth:`axpby` that takes in two arrays, ``x`` and
+``y``, and two scalars, ``alpha`` and ``beta``. This is how to define it in
+C++:
+
+.. code-block:: C++
+
+    /**
+    *  Scale and sum two vectors element-wise
+    *  z = alpha * x + beta * y
+    *
+    *  Use NumPy-style broadcasting between x and y
+    *  Inputs are upcasted to floats if needed
+    **/
+    array axpby(
+        const array& x, // Input array x
+        const array& y, // Input array y
+        const float alpha, // Scaling factor for x
+        const float beta, // Scaling factor for y
+        StreamOrDevice s = {} // Stream on which to schedule the operation
+    );
+
+The simplest way to implement this is with existing operations:
+
+.. code-block:: C++
+
+    array axpby(
+        const array& x, // Input array x
+        const array& y, // Input array y
+        const float alpha, // Scaling factor for x
+        const float beta, // Scaling factor for y
+        StreamOrDevice s /* = {} */ // Stream on which to schedule the operation
+    ) {
+        // Scale x and y on the provided stream
+        auto ax = multiply(array(alpha), x, s);
+        auto by = multiply(array(beta), y, s);
+
+        // Add and return
+        return add(ax, by, s);
+    }
+
+The operations themselves do not contain the implementations that act on the
+data, nor do they contain the rules of transformations. Rather, they are an
+easy to use interface that use :class:`Primitive` building blocks.
+
+Primitives
+^^^^^^^^^^^
+
+A :class:`Primitive` is part of the computation graph of an :class:`array`. It
+defines how to create output arrays given input arrays. Further, a
+:class:`Primitive` has methods to run on the CPU or GPU and for function
+transformations such as ``vjp`` and ``jvp``.  Let's go back to our example to be
+more concrete:
+
+.. code-block:: C++
+
+    class Axpby : public Primitive {
+      public:
+        explicit Axpby(Stream stream, float alpha, float beta)
+            : Primitive(stream), alpha_(alpha), beta_(beta){};
+
+        /**
+        * A primitive must know how to evaluate itself on the CPU/GPU
+        * for the given inputs and populate the output array.
+        *
+        * To avoid unnecessary allocations, the evaluation function
+        * is responsible for allocating space for the array.
+        */
+        void eval_cpu(
+            const std::vector<array>& inputs,
+            std::vector<array>& outputs) override;
+        void eval_gpu(
+            const std::vector<array>& inputs,
+            std::vector<array>& outputs) override;
+
+        /** The Jacobian-vector product. */
+        std::vector<array> jvp(
+            const std::vector<array>& primals,
+            const std::vector<array>& tangents,
+            const std::vector<int>& argnums) override;
+
+        /** The vector-Jacobian product. */
+        std::vector<array> vjp(
+            const std::vector<array>& primals,
+            const std::vector<array>& cotangents,
+            const std::vector<int>& argnums,
+            const std::vector<array>& outputs) override;
+
+        /**
+        * The primitive must know how to vectorize itself across
+        * the given axes. The output is a pair containing the array
+        * representing the vectorized computation and the axis which
+        * corresponds to the output vectorized dimension.
+        */
+        std::pair<std::vector<array>, std::vector<int>> vmap(
+            const std::vector<array>& inputs,
+            const std::vector<int>& axes) override;
+
+        /** The name of primitive. */
+        const char* name() const override {
+          return "Axpby";
+        }
+
+        /** Equivalence check **/
+        bool is_equivalent(const Primitive& other) const override;
+
+      private:
+        float alpha_;
+        float beta_;
+    };
+
+The :class:`Axpby` class derives from the base :class:`Primitive` class. The
+:class:`Axpby` treats ``alpha`` and ``beta`` as parameters. It then provides
+implementations of how the output array is produced given the inputs through
+:meth:`Axpby::eval_cpu` and :meth:`Axpby::eval_gpu`. It also provides rules
+of transformations in :meth:`Axpby::jvp`, :meth:`Axpby::vjp`, and
+:meth:`Axpby::vmap`.
+
+Using the Primitive
+^^^^^^^^^^^^^^^^^^^
+
+Operations can use this :class:`Primitive` to add a new :class:`array` to the
+computation graph. An :class:`array` can be constructed by providing its data
+type, shape, the :class:`Primitive` that computes it, and the :class:`array`
+inputs that are passed to the primitive.
+
+Let's reimplement our operation now in terms of our :class:`Axpby` primitive.
+
+.. code-block:: C++
+
+    array axpby(
+        const array& x, // Input array x
+        const array& y, // Input array y
+        const float alpha, // Scaling factor for x
+        const float beta, // Scaling factor for y
+        StreamOrDevice s /* = {} */ // Stream on which to schedule the operation
+    ) {
+        // Promote dtypes between x and y as needed
+        auto promoted_dtype = promote_types(x.dtype(), y.dtype());
+
+        // Upcast to float32 for non-floating point inputs x and y
+        auto out_dtype = issubdtype(promoted_dtype, float32)
+            ? promoted_dtype
+            : promote_types(promoted_dtype, float32);
+
+        // Cast x and y up to the determined dtype (on the same stream s)
+        auto x_casted = astype(x, out_dtype, s);
+        auto y_casted = astype(y, out_dtype, s);
+
+        // Broadcast the shapes of x and y (on the same stream s)
+        auto broadcasted_inputs = broadcast_arrays({x_casted, y_casted}, s);
+        auto out_shape = broadcasted_inputs[0].shape();
+
+        // Construct the array as the output of the Axpby primitive
+        // with the broadcasted and upcasted arrays as inputs
+        return array(
+            /* const std::vector<int>& shape = */ out_shape,
+            /* Dtype dtype = */ out_dtype,
+            /* std::unique_ptr<Primitive> primitive = */
+            std::make_shared<Axpby>(to_stream(s), alpha, beta),
+            /* const std::vector<array>& inputs = */ broadcasted_inputs);
+    }
+
+
+This operation now handles the following:
+
+#. Upcast inputs and resolve the output data type.
+#. Broadcast the inputs and resolve the output shape.
+#. Construct the primitive :class:`Axpby` using the given stream, ``alpha``, and ``beta``.
+#. Construct the output :class:`array` using the primitive and the inputs.
+
+Implementing the Primitive
+--------------------------
+
+No computation happens when we call the operation alone. The operation only
+builds the computation graph. When we evaluate the output array, MLX schedules
+the execution of the computation graph, and calls :meth:`Axpby::eval_cpu` or
+:meth:`Axpby::eval_gpu` depending on the stream/device specified by the user.
+
+.. warning::
+    When :meth:`Primitive::eval_cpu` or :meth:`Primitive::eval_gpu` are called,
+    no memory has been allocated for the output array. It falls on the implementation
+    of these functions to allocate memory as needed.
+
+Implementing the CPU Back-end
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Let's start by implementing :meth:`Axpby::eval_cpu`.
+
+The method will go over each element of the output array, find the
+corresponding input elements of ``x`` and ``y`` and perform the operation
+point-wise. This is captured in the templated function :meth:`axpby_impl`.
+
+.. code-block:: C++
+
+  template <typename T>
+  void axpby_impl(
+      const mx::array& x,
+      const mx::array& y,
+      mx::array& out,
+      float alpha_,
+      float beta_,
+      mx::Stream stream) {
+    out.set_data(mx::allocator::malloc(out.nbytes()));
+
+    // Get the CPU command encoder and register input and output arrays
+    auto& encoder = mx::cpu::get_command_encoder(stream);
+    encoder.set_input_array(x);
+    encoder.set_input_array(y);
+    encoder.set_output_array(out);
+
+    // Launch the CPU kernel
+    encoder.dispatch([x_ptr = x.data<T>(),
+                      y_ptr = y.data<T>(),
+                      out_ptr = out.data<T>(),
+                      size = out.size(),
+                      shape = out.shape(),
+                      x_strides = x.strides(),
+                      y_strides = y.strides(),
+                      alpha_,
+                      beta_]() {
+
+      // Cast alpha and beta to the relevant types
+      T alpha = static_cast<T>(alpha_);
+      T beta = static_cast<T>(beta_);
+
+      // Do the element-wise operation for each output
+      for (size_t out_idx = 0; out_idx < size; out_idx++) {
+        // Map linear indices to offsets in x and y
+        auto x_offset = mx::elem_to_loc(out_idx, shape, x_strides);
+        auto y_offset = mx::elem_to_loc(out_idx, shape, y_strides);
+
+        // We allocate the output to be contiguous and regularly strided
+        // (defaults to row major) and hence it doesn't need additional mapping
+        out_ptr[out_idx] = alpha * x_ptr[x_offset] + beta * y_ptr[y_offset];
+      }
+    });
+  }
+
+Our implementation should work for all incoming floating point arrays.
+Accordingly, we add dispatches for ``float32``, ``float16``, ``bfloat16`` and
+``complex64``. We throw an error if we encounter an unexpected type.
+
+.. code-block:: C++
+
+    void Axpby::eval_cpu(
+        const std::vector<mx::array>& inputs,
+        std::vector<mx::array>& outputs) {
+      auto& x = inputs[0];
+      auto& y = inputs[1];
+      auto& out = outputs[0];
+
+      // Dispatch to the correct dtype
+      if (out.dtype() == mx::float32) {
+        return axpby_impl<float>(x, y, out, alpha_, beta_, stream());
+      } else if (out.dtype() == mx::float16) {
+        return axpby_impl<mx::float16_t>(x, y, out, alpha_, beta_, stream());
+      } else if (out.dtype() == mx::bfloat16) {
+        return axpby_impl<mx::bfloat16_t>(x, y, out, alpha_, beta_, stream());
+      } else if (out.dtype() == mx::complex64) {
+        return axpby_impl<mx::complex64_t>(x, y, out, alpha_, beta_, stream());
+      } else {
+        throw std::runtime_error(
+            "Axpby is only supported for floating point types.");
+      }
+    }
+
+Just this much is enough to run the operation :meth:`axpby` on a CPU stream! If
+you do not plan on running the operation on the GPU or using transforms on
+computation graphs that contain :class:`Axpby`, you can stop implementing the
+primitive here.
+
+Implementing the GPU Back-end
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Apple silicon devices address their GPUs using the Metal_ shading language, and
+GPU kernels in MLX are written using Metal.
+
+.. note::
+
+    Here are some helpful resources if you are new to Metal:
+
+    * A walkthrough of the metal compute pipeline: `Metal Example`_
+    * Documentation for metal shading language: `Metal Specification`_
+    * Using metal from C++: `Metal-cpp`_
+
+Let's keep the GPU kernel simple. We will launch exactly as many threads as
+there are elements in the output. Each thread will pick the element it needs
+from ``x`` and ``y``, do the point-wise operation, and update its assigned
+element in the output.
+
+.. code-block:: C++
+
+    template <typename T>
+    [[kernel]] void axpby_general(
+            device const T* x [[buffer(0)]],
+            device const T* y [[buffer(1)]],
+            device T* out [[buffer(2)]],
+            constant const float& alpha [[buffer(3)]],
+            constant const float& beta [[buffer(4)]],
+            constant const int* shape [[buffer(5)]],
+            constant const int64_t* x_strides [[buffer(6)]],
+            constant const int64_t* y_strides [[buffer(7)]],
+            constant const int& ndim [[buffer(8)]],
+            uint index [[thread_position_in_grid]]) {
+        // Convert linear indices to offsets in array
+        auto x_offset = elem_to_loc(index, shape, x_strides, ndim);
+        auto y_offset = elem_to_loc(index, shape, y_strides, ndim);
+
+        // Do the operation and update the output
+        out[index] =
+            static_cast<T>(alpha) * x[x_offset] + static_cast<T>(beta) * y[y_offset];
+    }
+
+We then need to instantiate this template for all floating point types and give
+each instantiation a unique host name so we can identify it.
+
+.. code-block:: C++
+
+    instantiate_kernel("axpby_general_float32", axpby_general, float)
+    instantiate_kernel("axpby_general_float16", axpby_general, float16_t)
+    instantiate_kernel("axpby_general_bfloat16", axpby_general, bfloat16_t)
+    instantiate_kernel("axpby_general_complex64", axpby_general, complex64_t)
+
+The logic to determine the kernel, set the inputs, resolve the grid dimensions,
+and dispatch to the GPU are contained in :meth:`Axpby::eval_gpu` as shown
+below.
+
+.. code-block:: C++
+
+    /** Evaluate primitive on GPU */
+    void Axpby::eval_gpu(
+      const std::vector<array>& inputs,
+      std::vector<array>& outputs) {
+        // Prepare inputs
+        assert(inputs.size() == 2);
+        auto& x = inputs[0];
+        auto& y = inputs[1];
+        auto& out = outputs[0];
+
+        // Each primitive carries the stream it should execute on
+        // and each stream carries its device identifiers
+        auto& s = stream();
+        // We get the needed metal device using the stream
+        auto& d = metal::device(s.device);
+
+        // Allocate output memory
+        out.set_data(allocator::malloc(out.nbytes()));
+
+        // Resolve name of kernel
+        std::stream kname;
+        kname = "axpby_general_" + type_to_name(out);
+
+        // Load the metal library
+        auto lib = d.get_library("mlx_ext", current_binary_dir());
+
+        // Make a kernel from this metal library
+        auto kernel = d.get_kernel(kname, lib);
+
+        // Prepare to encode kernel
+        auto& compute_encoder = d.get_command_encoder(s.index);
+        compute_encoder.set_compute_pipeline_state(kernel);
+
+        // Kernel parameters are registered with buffer indices corresponding to
+        // those in the kernel declaration at axpby.metal
+        int ndim = out.ndim();
+        size_t nelem = out.size();
+
+        // Encode input arrays to kernel
+        compute_encoder.set_input_array(x, 0);
+        compute_encoder.set_input_array(y, 1);
+
+        // Encode output arrays to kernel
+        compute_encoder.set_output_array(out, 2);
+
+        // Encode alpha and beta
+        compute_encoder.set_bytes(alpha_, 3);
+        compute_encoder.set_bytes(beta_, 4);
+
+        // Encode shape, strides and ndim
+        compute_encoder.set_vector_bytes(x.shape(), 5);
+        compute_encoder.set_vector_bytes(x.strides(), 6);
+        compute_encoder.set_bytes(y.strides(), 7);
+        compute_encoder.set_bytes(ndim, 8);
+
+        // We launch 1 thread for each input and make sure that the number of
+        // threads in any given threadgroup is not higher than the max allowed
+        size_t tgp_size = std::min(nelem, kernel->maxTotalThreadsPerThreadgroup());
+
+        // Fix the 3D size of each threadgroup (in terms of threads)
+        MTL::Size group_dims = MTL::Size(tgp_size, 1, 1);
+
+        // Fix the 3D size of the launch grid (in terms of threads)
+        MTL::Size grid_dims = MTL::Size(nelem, 1, 1);
+
+        // Launch the grid with the given number of threads divided among
+        // the given threadgroups
+        compute_encoder.dispatch_threads(grid_dims, group_dims);
+    }
+
+We can now call the :meth:`axpby` operation on both the CPU and the GPU!
+
+A few things to note about MLX and Metal before moving on. MLX keeps track of
+the active ``command_buffer`` and the ``MTLCommandBuffer`` to which it is
+associated. We rely on :meth:`d.get_command_encoder` to give us the active
+metal compute command encoder instead of building a new one and calling
+:meth:`compute_encoder->end_encoding` at the end. MLX adds kernels (compute
+pipelines) to the active command buffer until some specified limit is hit or
+the command buffer needs to be flushed for synchronization.
+
+Primitive Transforms
+^^^^^^^^^^^^^^^^^^^^^
+
+Next, let's add implementations for transformations in a :class:`Primitive`.
+These transformations can be built on top of other operations, including the
+one we just defined:
+
+.. code-block:: C++
+
+    /** The Jacobian-vector product. */
+    std::vector<array> Axpby::jvp(
+            const std::vector<array>& primals,
+            const std::vector<array>& tangents,
+            const std::vector<int>& argnums) {
+        // Forward mode diff that pushes along the tangents
+        // The jvp transform on the primitive can be built with ops
+        // that are scheduled on the same stream as the primitive
+
+        // If argnums = {0}, we only push along x in which case the
+        // jvp is just the tangent scaled by alpha
+        // Similarly, if argnums = {1}, the jvp is just the tangent
+        // scaled by beta
+        if (argnums.size() > 1) {
+            auto scale = argnums[0] == 0 ? alpha_ : beta_;
+            auto scale_arr = array(scale, tangents[0].dtype());
+            return {multiply(scale_arr, tangents[0], stream())};
+        }
+        // If argnums = {0, 1}, we take contributions from both
+        // which gives us jvp = tangent_x * alpha + tangent_y * beta
+        else {
+            return {axpby(tangents[0], tangents[1], alpha_, beta_, stream())};
+        }
+    }
+
+.. code-block:: C++
+
+    /** The vector-Jacobian product. */
+    std::vector<array> Axpby::vjp(
+            const std::vector<array>& primals,
+            const std::vector<array>& cotangents,
+            const std::vector<int>& argnums,
+            const std::vector<int>& /* unused */) {
+        // Reverse mode diff
+        std::vector<array> vjps;
+        for (auto arg : argnums) {
+            auto scale = arg == 0 ? alpha_ : beta_;
+            auto scale_arr = array(scale, cotangents[0].dtype());
+            vjps.push_back(multiply(scale_arr, cotangents[0], stream()));
+        }
+        return vjps;
+    }
+
+Note, a transformation does not need to be fully defined to start using
+the :class:`Primitive`.
+
+.. code-block:: C++
+
+    /** Vectorize primitive along given axis */
+    std::pair<std::vector<array>, std::vector<int>> Axpby::vmap(
+            const std::vector<array>& inputs,
+            const std::vector<int>& axes) {
+        throw std::runtime_error("[Axpby] vmap not implemented.");
+    }
+
+Building and Binding
+--------------------
+
+Let's look at the overall directory structure first.
+
+| extensions
+| ├── axpby
+| │   ├── axpby.cpp
+| │   ├── axpby.h
+| │   └── axpby.metal
+| ├── mlx_sample_extensions
+| │   └── __init__.py
+| ├── bindings.cpp
+| ├── CMakeLists.txt
+| └── setup.py
+
+* ``extensions/axpby/`` defines the C++ extension library
+* ``extensions/mlx_sample_extensions`` sets out the structure for the
+  associated Python package
+* ``extensions/bindings.cpp`` provides Python bindings for our operation
+* ``extensions/CMakeLists.txt`` holds CMake rules to build the library and
+  Python bindings
+* ``extensions/setup.py`` holds the ``setuptools`` rules to build and install
+  the Python package
+
+Binding to Python
+^^^^^^^^^^^^^^^^^^
+
+We use nanobind_ to build a Python API for the C++ library. Since bindings for
+components such as :class:`mlx.core.array`, :class:`mlx.core.stream`, etc. are
+already provided, adding our :meth:`axpby` is simple.
+
+.. code-block:: C++
+
+   NB_MODULE(_ext, m) {
+        m.doc() = "Sample extension for MLX";
+
+        m.def(
+            "axpby",
+            &axpby,
+            "x"_a,
+            "y"_a,
+            "alpha"_a,
+            "beta"_a,
+            nb::kw_only(),
+            "stream"_a = nb::none(),
+            R"(
+                Scale and sum two vectors element-wise
+                ``z = alpha * x + beta * y``
+
+                Follows numpy style broadcasting between ``x`` and ``y``
+                Inputs are upcasted to floats if needed
+
+                Args:
+                    x (array): Input array.
+                    y (array): Input array.
+                    alpha (float): Scaling factor for ``x``.
+                    beta (float): Scaling factor for ``y``.
+
+                Returns:
+                    array: ``alpha * x + beta * y``
+            )");
+    }
+
+Most of the complexity in the above example comes from additional bells and
+whistles such as the literal names and doc-strings.
+
+.. warning::
+
+    :mod:`mlx.core` must be imported before importing
+    :mod:`mlx_sample_extensions` as defined by the nanobind module above to
+    ensure that the casters for :mod:`mlx.core` components like
+    :class:`mlx.core.array` are available.
+
+.. _Building with CMake:
+
+Building with CMake
+^^^^^^^^^^^^^^^^^^^^
+
+Building the C++ extension library only requires that you ``find_package(MLX
+CONFIG)`` and then link it to your library.
+
+.. code-block:: cmake
+
+    # Add library
+    add_library(mlx_ext)
+
+    # Add sources
+    target_sources(
+        mlx_ext
+        PUBLIC
+        ${CMAKE_CURRENT_LIST_DIR}/axpby/axpby.cpp
+    )
+
+    # Add include headers
+    target_include_directories(
+        mlx_ext PUBLIC ${CMAKE_CURRENT_LIST_DIR}
+    )
+
+    # Link to mlx
+    target_link_libraries(mlx_ext PUBLIC mlx)
+
+We also need to build the attached Metal library. For convenience, we provide a
+:meth:`mlx_build_metallib` function that builds a ``.metallib`` target given
+sources, headers, destinations, etc. (defined in ``cmake/extension.cmake`` and
+automatically imported with MLX package).
+
+Here is what that looks like in practice:
+
+.. code-block:: cmake
+
+    # Build metallib
+    if(MLX_BUILD_METAL)
+
+    mlx_build_metallib(
+        TARGET mlx_ext_metallib
+        TITLE mlx_ext
+        SOURCES ${CMAKE_CURRENT_LIST_DIR}/axpby/axpby.metal
+        INCLUDE_DIRS ${PROJECT_SOURCE_DIR} ${MLX_INCLUDE_DIRS}
+        OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
+    )
+
+    add_dependencies(
+        mlx_ext
+        mlx_ext_metallib
+    )
+
+    endif()
+
+Finally, we build the nanobind_ bindings
+
+.. code-block:: cmake
+
+    nanobind_add_module(
+      _ext
+      NB_STATIC STABLE_ABI LTO NOMINSIZE
+      NB_DOMAIN mlx
+      ${CMAKE_CURRENT_LIST_DIR}/bindings.cpp
+    )
+    target_link_libraries(_ext PRIVATE mlx_ext)
+
+    if(BUILD_SHARED_LIBS)
+      target_link_options(_ext PRIVATE -Wl,-rpath,@loader_path)
+    endif()
+
+Building with ``setuptools``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Once we have set out the CMake build rules as described above, we can use the
+build utilities defined in :mod:`mlx.extension`:
+
+.. code-block:: python
+
+    from mlx import extension
+    from setuptools import setup
+
+    if __name__ == "__main__":
+        setup(
+            name="mlx_sample_extensions",
+            version="0.0.0",
+            description="Sample C++ and Metal extensions for MLX primitives.",
+            ext_modules=[extension.CMakeExtension("mlx_sample_extensions._ext")],
+            cmdclass={"build_ext": extension.CMakeBuild},
+            packages=["mlx_sample_extensions"],
+            package_data={"mlx_sample_extensions": ["*.so", "*.dylib", "*.metallib"]},
+            extras_require={"dev":[]},
+            zip_safe=False,
+            python_requires=">=3.8",
+        )
+
+.. note::
+    We treat ``extensions/mlx_sample_extensions`` as the package directory
+    even though it only contains a ``__init__.py`` to ensure the following:
+
+    * :mod:`mlx.core` must be imported before importing :mod:`_ext`
+    * The C++ extension library and the metal library are co-located with the python
+      bindings and copied together if the package is installed
+
+To build the package, first install the build dependencies with ``pip install
+-r requirements.txt``.  You can then build inplace for development using
+``python setup.py build_ext -j8 --inplace`` (in ``extensions/``)
+
+This results in the directory structure:
+
+| extensions
+| ├── mlx_sample_extensions
+| │   ├── __init__.py
+| │   ├── libmlx_ext.dylib # C++ extension library
+| │   ├── mlx_ext.metallib # Metal library
+| │   └── _ext.cpython-3x-darwin.so # Python Binding
+| ...
+
+When you try to install using the command ``python -m pip install .`` (in
+``extensions/``), the package will be installed with the same structure as
+``extensions/mlx_sample_extensions`` and the C++ and Metal library will be
+copied along with the Python binding since they are specified as
+``package_data``.
+
+Usage
+-----
+
+After installing the extension as described above, you should be able to simply
+import the Python package and play with it as you would any other MLX operation.
+
+Let's look at a simple script and its results:
+
+.. code-block:: python
+
+    import mlx.core as mx
+    from mlx_sample_extensions import axpby
+
+    a = mx.ones((3, 4))
+    b = mx.ones((3, 4))
+    c = axpby(a, b, 4.0, 2.0, stream=mx.cpu)
+
+    print(f"c shape: {c.shape}")
+    print(f"c dtype: {c.dtype}")
+    print(f"c is correct: {mx.all(c == 6.0).item()}")
+
+Output:
+
+.. code-block::
+
+    c shape: [3, 4]
+    c dtype: float32
+    c is correct: True
+
+Results
+^^^^^^^
+
+Let's run a quick benchmark and see how our new ``axpby`` operation compares
+with the naive :meth:`simple_axpby` we first defined.
+
+.. code-block:: python
+
+    import mlx.core as mx
+    from mlx_sample_extensions import axpby
+    import time
+
+    def simple_axpby(x: mx.array, y: mx.array, alpha: float, beta: float) -> mx.array:
+        return alpha * x + beta * y
+
+    M = 4096
+    N = 4096
+
+    x = mx.random.normal((M, N))
+    y = mx.random.normal((M, N))
+    alpha = 4.0
+    beta = 2.0
+
+    mx.eval(x, y)
+
+    def bench(f):
+        # Warm up
+        for i in range(5):
+            z = f(x, y, alpha, beta)
+            mx.eval(z)
+
+        # Timed run
+        s = time.time()
+        for i in range(100):
+            z = f(x, y, alpha, beta)
+            mx.eval(z)
+        e = time.time()
+        return 1000 * (e - s) / 100
+
+    simple_time = bench(simple_axpby)
+    custom_time = bench(axpby)
+
+    print(f"Simple axpby: {simple_time:.3f} ms | Custom axpby: {custom_time:.3f} ms")
+
+The results are ``Simple axpby: 1.559 ms | Custom axpby: 0.774 ms``. We see
+modest improvements right away!
+
+This operation is now good to be used to build other operations, in
+:class:`mlx.nn.Module` calls, and also as a part of graph transformations like
+:meth:`grad`.
+
+Scripts
+-------
+
+.. admonition:: Download the code
+
+   The full example code is available in `mlx <https://github.com/ml-explore/mlx/tree/main/examples/extensions/>`_.
+
+.. _Accelerate: https://developer.apple.com/documentation/accelerate/blas?language=objc
+.. _Metal: https://developer.apple.com/documentation/metal?language=objc
+.. _Metal-cpp: https://developer.apple.com/metal/cpp/
+.. _`Metal Specification`: https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf
+.. _`Metal Example`: https://developer.apple.com/documentation/metal/performing_calculations_on_a_gpu?language=objc
+.. _nanobind: https://nanobind.readthedocs.io/en/latest/
diff --git a/ml-stable-diffusion/mlx/docs/src/dev/metal_debugger.rst b/ml-stable-diffusion/mlx/docs/src/dev/metal_debugger.rst
new file mode 100644
index 0000000000000000000000000000000000000000..df4b988227c92733b38b44869a559de7616734d0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/dev/metal_debugger.rst
@@ -0,0 +1,68 @@
+Metal Debugger
+==============
+
+.. currentmodule:: mlx.core
+
+Profiling is a key step for performance optimization. You can build MLX with
+the ``MLX_METAL_DEBUG`` option to improve the Metal debugging and
+optimization workflow. The ``MLX_METAL_DEBUG`` debug option:
+
+* Records source during Metal compilation, for later inspection while
+  debugging.
+* Labels Metal objects such as command queues, improving capture readability.
+
+To build with debugging enabled in Python prepend
+``CMAKE_ARGS="-DMLX_METAL_DEBUG=ON"`` to the build call.
+
+The :func:`metal.start_capture` function initiates a capture of all MLX GPU
+work.
+
+.. note::
+
+   To capture a GPU trace you must run the application with
+   ``MTL_CAPTURE_ENABLED=1``.
+
+.. code-block:: python
+
+    import mlx.core as mx
+
+    a = mx.random.uniform(shape=(512, 512))
+    b = mx.random.uniform(shape=(512, 512))
+    mx.eval(a, b)
+
+    trace_file = "mlx_trace.gputrace"
+
+    # Make sure to run with MTL_CAPTURE_ENABLED=1 and
+    # that the path trace_file does not already exist.
+    mx.metal.start_capture(trace_file)
+
+    for _ in range(10):
+      mx.eval(mx.add(a, b))
+
+    mx.metal.stop_capture()
+
+You can open and replay the GPU trace in Xcode. The ``Dependencies`` view
+has a great overview of all operations. Checkout the `Metal debugger
+documentation`_ for more information.
+
+.. image:: ../_static/metal_debugger/capture.png
+    :class: dark-light
+
+Xcode Workflow
+--------------
+
+You can skip saving to a path by running within Xcode. First, generate an
+Xcode project using CMake.
+
+.. code-block::
+
+    mkdir build && cd build
+    cmake .. -DMLX_METAL_DEBUG=ON -G Xcode
+    open mlx.xcodeproj
+
+Select the ``metal_capture`` example schema and run.
+
+.. image:: ../_static/metal_debugger/schema.png
+    :class: dark-light
+
+.. _`Metal debugger documentation`: https://developer.apple.com/documentation/xcode/metal-debugger
diff --git a/ml-stable-diffusion/mlx/docs/src/dev/mlx_in_cpp.rst b/ml-stable-diffusion/mlx/docs/src/dev/mlx_in_cpp.rst
new file mode 100644
index 0000000000000000000000000000000000000000..af778b33bc367ae28adfabb5c2011016ea79a93a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/dev/mlx_in_cpp.rst
@@ -0,0 +1,121 @@
+.. _mlx_in_cpp:
+
+Using MLX in C++
+================
+
+You can use MLX in a C++ project with CMake.
+
+.. note::
+
+  This guide is based one the following `example using MLX in C++ 
+  <https://github.com/ml-explore/mlx/tree/main/examples/cmake_project>`_
+
+First install MLX:
+
+.. code-block:: bash
+
+  pip install -U mlx
+
+You can also install the MLX Python package from source or just the C++
+library. For more information see the :ref:`documentation on installing MLX
+<build_and_install>`.
+
+Next make an example program in ``example.cpp``: 
+
+.. code-block:: C++
+
+  #include <iostream>
+
+  #include "mlx/mlx.h"
+
+  namespace mx = mlx::core;
+
+  int main() {
+    auto x = mx::array({1, 2, 3});
+    auto y = mx::array({1, 2, 3});
+    std::cout << x + y << std::endl;
+    return 0;
+  }
+
+The next step is to setup a CMake file in ``CMakeLists.txt``:
+
+.. code-block:: cmake
+
+  cmake_minimum_required(VERSION 3.27)
+
+  project(example LANGUAGES CXX)
+
+  set(CMAKE_CXX_STANDARD 17)
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+
+Depending on how you installed MLX, you may need to tell CMake where to
+find it. 
+
+If you installed MLX with Python, then add the following to the CMake file:
+
+.. code-block:: cmake
+
+  find_package(
+    Python 3.9
+    COMPONENTS Interpreter Development.Module
+    REQUIRED)
+  execute_process(
+    COMMAND "${Python_EXECUTABLE}" -m mlx --cmake-dir
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    OUTPUT_VARIABLE MLX_ROOT)
+
+If you installed the MLX C++ package to a system path, then CMake should be
+able to find it. If you installed it to a non-standard location or CMake can't
+find MLX then set ``MLX_ROOT`` to the location where MLX is installed:
+
+.. code-block:: cmake
+
+  set(MLX_ROOT "/path/to/mlx/")
+
+Next, instruct CMake to find MLX:
+
+.. code-block:: cmake
+
+  find_package(MLX CONFIG REQUIRED)
+
+Finally, add the ``example.cpp`` program as an executable and link MLX.
+
+.. code-block:: cmake
+
+  add_executable(example example.cpp)
+  target_link_libraries(example PRIVATE mlx)
+
+You can build the example with:
+
+.. code-block:: bash
+
+  cmake -B build -DCMAKE_BUILD_TYPE=Release
+  cmake --build build
+
+And run it with:
+
+.. code-block:: bash
+
+  ./build/example
+
+Note ``find_package(MLX CONFIG REQUIRED)`` sets the following variables:
+
+.. list-table:: Package Variables
+   :widths: 20 20 
+   :header-rows: 1
+
+   * - Variable 
+     - Description 
+   * - MLX_FOUND
+     - ``True`` if MLX is found
+   * - MLX_INCLUDE_DIRS
+     - Include directory
+   * - MLX_LIBRARIES
+     - Libraries to link against
+   * - MLX_CXX_FLAGS
+     - Additional compiler flags
+   * - MLX_BUILD_ACCELERATE
+     - ``True`` if MLX was built with Accelerate 
+   * - MLX_BUILD_METAL
+     - ``True`` if MLX was built with Metal
diff --git a/ml-stable-diffusion/mlx/docs/src/examples/linear_regression.rst b/ml-stable-diffusion/mlx/docs/src/examples/linear_regression.rst
new file mode 100644
index 0000000000000000000000000000000000000000..19fc0d435039486d8e1002c9790af3f9ab05d464
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/examples/linear_regression.rst
@@ -0,0 +1,77 @@
+.. _linear_regression:
+
+Linear Regression
+-----------------
+
+Let's implement a basic linear regression model as a starting point to
+learn MLX. First import the core package and setup some problem metadata:
+
+.. code-block:: python
+
+  import mlx.core as mx
+
+  num_features = 100
+  num_examples = 1_000
+  num_iters = 10_000  # iterations of SGD
+  lr = 0.01  # learning rate for SGD
+
+
+We'll generate a synthetic dataset by:
+
+1. Sampling the design matrix ``X``.
+2. Sampling a ground truth parameter vector ``w_star``.
+3. Compute the dependent values ``y`` by adding Gaussian noise to ``X @ w_star``.
+
+.. code-block:: python
+
+  # True parameters
+  w_star = mx.random.normal((num_features,))
+
+  # Input examples (design matrix)
+  X = mx.random.normal((num_examples, num_features))
+
+  # Noisy labels
+  eps = 1e-2 * mx.random.normal((num_examples,))
+  y = X @ w_star + eps
+
+
+We will use SGD to find the optimal weights. To start, define the squared loss
+and get the gradient function of the loss with respect to the parameters.
+
+.. code-block:: python
+
+  def loss_fn(w):
+      return 0.5 * mx.mean(mx.square(X @ w - y))
+
+  grad_fn = mx.grad(loss_fn)
+
+Start the optimization by initializing the parameters ``w`` randomly. Then
+repeatedly update the parameters for ``num_iters`` iterations. 
+
+.. code-block:: python
+
+  w = 1e-2 * mx.random.normal((num_features,))
+
+  for _ in range(num_iters):
+      grad = grad_fn(w)
+      w = w - lr * grad
+      mx.eval(w)
+
+Finally, compute the loss of the learned parameters and verify that they are
+close to the ground truth parameters.
+
+.. code-block:: python
+
+  loss = loss_fn(w)
+  error_norm = mx.sum(mx.square(w - w_star)).item() ** 0.5
+
+  print(
+      f"Loss {loss.item():.5f}, |w-w*| = {error_norm:.5f}, "
+  )
+  # Should print something close to: Loss 0.00005, |w-w*| = 0.00364
+
+Complete `linear regression
+<https://github.com/ml-explore/mlx/tree/main/examples/python/linear_regression.py>`_
+and `logistic regression
+<https://github.com/ml-explore/mlx/tree/main/examples/python/logistic_regression.py>`_
+examples are available in the MLX GitHub repo.
diff --git a/ml-stable-diffusion/mlx/docs/src/examples/llama-inference.rst b/ml-stable-diffusion/mlx/docs/src/examples/llama-inference.rst
new file mode 100644
index 0000000000000000000000000000000000000000..7e06895e3580a207e2b6f8a2eb5d2d79e8b7b58d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/examples/llama-inference.rst
@@ -0,0 +1,382 @@
+LLM inference
+==============
+
+MLX enables efficient inference of large-ish transformers on Apple silicon
+without compromising on ease of use. In this example we will create an
+inference script for the Llama family of transformer models in which the model
+is defined in less than 200 lines of python.
+
+Implementing the model
+----------------------
+
+We will use the neural network building blocks defined in the :mod:`mlx.nn`
+module to concisely define the model architecture. 
+
+Attention layer
+^^^^^^^^^^^^^^^^
+
+We will start with the Llama attention layer which notably uses the RoPE
+positional encoding. [1]_ In addition, our attention layer will optionally use a
+key/value cache that will be concatenated with the provided keys and values to
+support efficient inference.
+
+Our implementation uses :class:`mlx.nn.Linear` for all the projections and
+:class:`mlx.nn.RoPE` for the positional encoding.
+
+.. code-block:: python
+
+    import mlx.core as mx
+    import mlx.nn as nn
+
+    class LlamaAttention(nn.Module):
+        def __init__(self, dims: int, num_heads: int):
+            super().__init__()
+
+            self.num_heads = num_heads
+
+            self.rope = nn.RoPE(dims // num_heads, traditional=True)
+            self.query_proj = nn.Linear(dims, dims, bias=False)
+            self.key_proj = nn.Linear(dims, dims, bias=False)
+            self.value_proj = nn.Linear(dims, dims, bias=False)
+            self.out_proj = nn.Linear(dims, dims, bias=False)
+
+        def __call__(self, queries, keys, values, mask=None, cache=None):
+            queries = self.query_proj(queries)
+            keys = self.key_proj(keys)
+            values = self.value_proj(values)
+
+            # Extract some shapes
+            num_heads = self.num_heads
+            B, L, D = queries.shape
+
+            # Prepare the queries, keys and values for the attention computation
+            queries = queries.reshape(B, L, num_heads, -1).transpose(0, 2, 1, 3)
+            keys = keys.reshape(B, L, num_heads, -1).transpose(0, 2, 1, 3)
+            values = values.reshape(B, L, num_heads, -1).transpose(0, 2, 1, 3)
+
+            # Add RoPE to the queries and keys and combine them with the cache
+            if cache is not None:
+                key_cache, value_cache = cache
+                queries = self.rope(queries, offset=key_cache.shape[2])
+                keys = self.rope(keys, offset=key_cache.shape[2])
+                keys = mx.concatenate([key_cache, keys], axis=2)
+                values = mx.concatenate([value_cache, values], axis=2)
+            else:
+                queries = self.rope(queries)
+                keys = self.rope(keys)
+
+            # Finally perform the attention computation
+            scale = math.sqrt(1 / queries.shape[-1])
+            scores = (queries * scale) @ keys.transpose(0, 1, 3, 2)
+            if mask is not None:
+                scores = scores + mask
+            scores = mx.softmax(scores, axis=-1)
+            values_hat = (scores @ values).transpose(0, 2, 1, 3).reshape(B, L, -1)
+
+            # Note that we return the keys and values to possibly be used as a cache
+            return self.out_proj(values_hat), (keys, values)
+
+Encoder layer
+^^^^^^^^^^^^^
+
+The other component of the Llama model is the encoder layer which uses RMS
+normalization [2]_ and SwiGLU. [3]_ For RMS normalization we will use
+:class:`mlx.nn.RMSNorm` that is already provided in :mod:`mlx.nn`.
+
+.. code-block:: python
+
+    class LlamaEncoderLayer(nn.Module):
+        def __init__(self, dims: int, mlp_dims: int, num_heads: int):
+            super().__init__()
+
+            self.attention = LlamaAttention(dims, num_heads)
+
+            self.norm1 = nn.RMSNorm(dims)
+            self.norm2 = nn.RMSNorm(dims)
+
+            self.linear1 = nn.Linear(dims, mlp_dims, bias=False)
+            self.linear2 = nn.Linear(dims, mlp_dims, bias=False)
+            self.linear3 = nn.Linear(mlp_dims, dims, bias=False)
+
+        def __call__(self, x, mask=None, cache=None):
+            y = self.norm1(x)
+            y, cache = self.attention(y, y, y, mask, cache)
+            x = x + y
+
+            y = self.norm2(x)
+            a = self.linear1(y)
+            b = self.linear2(y)
+            y = a * mx.sigmoid(a) * b
+            y = self.linear3(y)
+            x = x + y
+
+            return x, cache
+
+Full model
+^^^^^^^^^^
+
+To implement any Llama model we simply have to combine ``LlamaEncoderLayer``
+instances with an :class:`mlx.nn.Embedding` to embed the input tokens.
+
+.. code-block:: python
+
+    class Llama(nn.Module):
+        def __init__(
+            self, num_layers: int, vocab_size: int, dims: int, mlp_dims: int, num_heads: int
+        ):
+            super().__init__()
+
+            self.embedding = nn.Embedding(vocab_size, dims)
+            self.layers = [
+                LlamaEncoderLayer(dims, mlp_dims, num_heads) for _ in range(num_layers)
+            ]
+            self.norm = nn.RMSNorm(dims)
+            self.out_proj = nn.Linear(dims, vocab_size, bias=False)
+
+        def __call__(self, x):
+            mask = nn.MultiHeadAttention.create_additive_causal_mask(x.shape[1])
+            mask = mask.astype(self.embedding.weight.dtype)
+
+            x = self.embedding(x)
+            for l in self.layers:
+                x, _ = l(x, mask)
+            x = self.norm(x)
+            return self.out_proj(x)
+
+Note that in the implementation above we use a simple list to hold the encoder
+layers but using ``model.parameters()`` will still consider these layers.
+
+Generation
+^^^^^^^^^^^
+
+Our ``Llama`` module can be used for training but not inference as the
+``__call__`` method above processes one input, completely ignores the cache and
+performs no sampling whatsoever. In the rest of this subsection, we will
+implement the inference function as a python generator that processes the
+prompt and then autoregressively yields tokens one at a time.
+
+.. code-block:: python
+
+    class Llama(nn.Module):
+        ...
+
+        def generate(self, x, temp=1.0):
+            cache = []
+
+            # Make an additive causal mask. We will need that to process the prompt.
+            mask = nn.MultiHeadAttention.create_additive_causal_mask(x.shape[1])
+            mask = mask.astype(self.embedding.weight.dtype)
+
+            # First we process the prompt x the same way as in __call__ but
+            # save the caches in cache
+            x = self.embedding(x)
+            for l in self.layers:
+                x, c = l(x, mask=mask)
+                cache.append(c)  # <--- we store the per layer cache in a
+                                 #      simple python list
+            x = self.norm(x)
+            y = self.out_proj(x[:, -1])  # <--- we only care about the last logits
+                                         #      that generate the next token
+            y = mx.random.categorical(y * (1/temp))
+
+            # y now has size [1]
+            # Since MLX is lazily evaluated nothing is computed yet.
+            # Calling y.item() would force the computation to happen at
+            # this point but we can also choose not to do that and let the
+            # user choose when to start the computation.
+            yield y
+
+            # Now we parsed the prompt and generated the first token we
+            # need to feed it back into the model and loop to generate the
+            # rest.
+            while True:
+                # Unsqueezing the last dimension to add a sequence length
+                # dimension of 1
+                x = y[:, None]
+
+                x = self.embedding(x)
+                for i in range(len(cache)):
+                    # We are overwriting the arrays in the cache list. When
+                    # the computation will happen, MLX will be discarding the
+                    # old cache the moment it is not needed anymore.
+                    x, cache[i] = self.layers[i](x, mask=None, cache=cache[i])
+                x = self.norm(x)
+                y = self.out_proj(x[:, -1])
+                y = mx.random.categorical(y * (1/temp))
+
+                yield y
+
+Putting it all together
+^^^^^^^^^^^^^^^^^^^^^^^
+
+We now have everything we need to create a Llama model and sample tokens from
+it. In the following code, we randomly initialize a small Llama model, process
+6 tokens of prompt and generate 10 tokens.
+
+.. code-block:: python
+
+    model = Llama(num_layers=12, vocab_size=8192, dims=512, mlp_dims=1024, num_heads=8)
+
+    # Since MLX is lazily evaluated nothing has actually been materialized yet.
+    # We could have set the `dims` to 20_000 on a machine with 8GB of RAM and the
+    # code above would still run. Let's actually materialize the model.
+    mx.eval(model.parameters())
+
+    prompt = mx.array([[1, 10, 8, 32, 44, 7]])  # <-- Note the double brackets because we
+                                                #     have a batch dimension even
+                                                #     though it is 1 in this case
+
+    generated = [t for i, t in zip(range(10), model.generate(prompt, 0.8))]
+
+    # Since we haven't evaluated anything, nothing is computed yet. The list
+    # `generated` contains the arrays that hold the computation graph for the
+    # full processing of the prompt and the generation of 10 tokens.
+    #
+    # We can evaluate them one at a time, or all together. Concatenate them or
+    # print them. They would all result in very similar runtimes and give exactly
+    # the same results.
+    mx.eval(generated)
+
+Converting the weights
+----------------------
+
+This section assumes that you have access to the original Llama weights and the
+SentencePiece model that comes with them. We will write a small script to
+convert the PyTorch weights to MLX compatible ones and write them in a NPZ file
+that can be loaded directly by MLX.
+
+.. code-block:: python
+
+    import argparse
+    from itertools import starmap
+
+    import numpy as np
+    import torch
+
+    def map_torch_to_mlx(key, value):
+        if "tok_embedding" in key:
+            key = "embedding.weight"
+
+        elif "norm" in key:
+            key = key.replace("attention_norm", "norm1").replace("ffn_norm", "norm2")
+
+        elif "wq" in key or "wk" in key or "wv" in key or "wo" in key:
+            key = key.replace("wq", "query_proj")
+            key = key.replace("wk", "key_proj")
+            key = key.replace("wv", "value_proj")
+            key = key.replace("wo", "out_proj")
+
+        elif "w1" in key or "w2" in key or "w3" in key:
+            # The FFN is a separate submodule in PyTorch
+            key = key.replace("feed_forward.w1", "linear1")
+            key = key.replace("feed_forward.w3", "linear2")
+            key = key.replace("feed_forward.w2", "linear3")
+
+        elif "output" in key:
+            key = key.replace("output", "out_proj")
+
+        elif "rope" in key:
+            return None, None
+
+        return key, value.numpy()
+
+
+    if __name__ == "__main__":
+        parser = argparse.ArgumentParser(description="Convert Llama weights to MLX")
+        parser.add_argument("torch_weights")
+        parser.add_argument("output_file")
+        args = parser.parse_args()
+
+        state = torch.load(args.torch_weights)
+        np.savez(
+            args.output_file,
+            **{k: v for k, v in starmap(map_torch_to_mlx, state.items()) if k is not None}
+        )
+
+
+Weight loading and benchmarking
+-------------------------------
+
+After converting the weights to be compatible to our implementation, all that is
+left is to load them from disk and we can finally use the LLM to generate text.
+We can load numpy format files using the :func:`mlx.core.load` operation.
+
+To create a parameter dictionary from the key/value representation of NPZ files
+we will use the :func:`mlx.utils.tree_unflatten` helper method as follows:
+
+.. code-block:: python
+
+    from mlx.utils import tree_unflatten
+
+    model.update(tree_unflatten(list(mx.load(weight_file).items())))
+
+:meth:`mlx.utils.tree_unflatten` will take keys from the NPZ file that look
+like ``layers.2.attention.query_proj.weight`` and will transform them to
+
+.. code-block:: python
+
+   {"layers": [..., ..., {"attention": {"query_proj": {"weight": ...}}}]}
+
+which can then be used to update the model. Note that the method above incurs
+several unnecessary copies from disk to numpy and then from numpy to MLX. It
+will be replaced in the future with direct loading to MLX.
+
+You can download the full example code in `mlx-examples`_. Assuming, the
+existence of ``weights.pth`` and ``tokenizer.model`` in the current working
+directory we can play around with our inference script as follows (the timings
+are representative of an M1 Ultra and the 7B parameter Llama model):
+
+.. code-block:: bash
+
+    $ python convert.py weights.pth llama-7B.mlx.npz
+    $ python llama.py llama-7B.mlx.npz tokenizer.model 'Call me Ishmael. Some years ago never mind how long precisely'
+    [INFO] Loading model from disk: 5.247 s
+    Press enter to start generation
+    ------
+    , having little or no money in my purse, and nothing of greater consequence in my mind, I happened to be walking down Gower Street in the afternoon, in the heavy rain, and I saw a few steps off, a man in rags, who sat upon his bundle and looked hard into the wet as if he were going to cry. I watched him attentively for some time, and could not but observe that, though a numerous crowd was hurrying up and down,
+    ------
+    [INFO] Prompt processing: 0.437 s
+    [INFO] Full generation: 4.330 s
+
+We observe that 4.3 seconds are required to generate 100 tokens and 0.4 seconds
+of those are spent processing the prompt. This amounts to a little over **39 ms
+per token**.
+
+By running with a much bigger prompt we can see that the per token generation
+time as well as the prompt processing time remains almost constant.
+
+.. code-block:: bash
+
+    $ python llama.py llama-7B.mlx.npz tokenizer.model 'Call me Ishmael. Some years ago never mind how long precisely, having little or no money in my purse, and nothing of greater consequence in my mind, I happened to be walking down Gower Street in the afternoon, in the heavy rain, and I saw a few steps off, a man in rags, who sat upon his bundle and looked hard into the wet as if he were going to cry. I watched him attentively for some time, and could not but observe that, though a numerous crowd was hurrying up and down, nobody took the least notice of him. I stopped at last, at a little distance, as if I had been in doubt, and after looking on a few minutes, walked straight up to him. He slowly raised his eyes, and fixed them upon me for a moment, without speaking, and then resumed his place and posture as before. I stood looking at him for a while, feeling very much pain at heart, and then said to him, “What are you doing there?” Something like a smile passed over his face, as he said slowly, “I am waiting for someone; but it has been three quarters of an hour now, and he has not come.” “What is it you are waiting for?” said I. Still he made no immediate reply, but again put his face down upon his hands, and did not'
+    [INFO] Loading model from disk: 5.247 s
+    Press enter to start generation
+    ------
+    take his eyes from the ground. “What is it you are waiting for?” said I. “I am not accustomed to be thus questioned,” said he. “You look like a reasonable man—tell me, then, what are you waiting for?” “You would not understand,” he replied; “and how could you help me, if I were to tell you?” “I should not only understand, but would do all that I could,” said I. He did not
+    ------
+    [INFO] Prompt processing: 0.579 s
+    [INFO] Full generation: 4.690 s
+    $ python llama.py --num-tokens 500 llama-7B.mlx.npz tokenizer.model 'Call me Ishmael. Some years ago never mind how long precisely, having little or no money in my purse, and nothing of greater consequence in my mind, I happened to be walking down Gower Street in the afternoon, in the heavy rain, and I saw a few steps off, a man in rags, who sat upon his bundle and looked hard into the wet as if he were going to cry. I watched him attentively for some time, and could not but observe that, though a numerous crowd was hurrying up and down, nobody took the least notice of him. I stopped at last, at a little distance, as if I had been in doubt, and after looking on a few minutes, walked straight up to him. He slowly raised his eyes, and fixed them upon me for a moment, without speaking, and then resumed his place and posture as before. I stood looking at him for a while, feeling very much pain at heart, and then said to him, “What are you doing there?” Something like a smile passed over his face, as he said slowly, “I am waiting for someone; but it has been three quarters of an hour now, and he has not come.” “What is it you are waiting for?” said I. Still he made no immediate reply, but again put his face down upon his hands, and did not'
+    [INFO] Loading model from disk: 5.628 s
+    Press enter to start generation
+    ------
+    take his eyes from the ground. “What is it you are waiting for?” said I. “I am not accustomed to be thus questioned,” said he. “You look like a reasonable man—tell me, then, what are you waiting for?” “You would not understand,” he replied; “and how could you help me, if I were to tell you?” “I should not only understand, but would do all that I could,” said I. He did not reply, but still went on looking at the ground, and took hold of his bundle with a nervous trembling. I waited some time, and then resumed. “It is of no use to say you would not understand, if I were to tell you,” said he. “I have not told you why I am waiting for him,” said I. “And I am sure I should not understand,” replied he. “I will tell you then,” said I, “and, perhaps, you would not be surprised.” “No matter,” said he, “I shall be surprised anyhow; so tell me why you are waiting for him.” “He is my friend,” said I. “Yes,” said he, with a slight smile, “I know.” “He has been kind to me,” said I, “and I am waiting for him. I want to see him, and could have waited as I am now, for a much longer time.” “He will not soon come,” said he. “Unless he sees you here, he will not know of your having waited, and he will be very unlikely to come.” “No matter,” said I, “I shall wait for him.” “This is a strange thing,” said he, still with the same amused smile. “How did you know,” said I, “that he was coming? How should you be waiting?” “That is my secret,” said he. “And you expect him?” “Yes,” said I. “Are you disappointed then, if he does not come?” “No,” said I, “it is his secret, not mine.” “If he comes,” said he, “do you mean to go straight away?” “Yes,” said I, “I cannot be happy if I do not go straight away after him.” “Did you know this place before?” asked he. “Yes,” said I. “Is there any shop to buy food here?” “
+    ------
+    [INFO] Prompt processing: 0.633 s
+    [INFO] Full generation: 21.475 s
+
+Scripts
+-------
+
+.. admonition:: Download the code
+
+   The full example code is available in `mlx-examples`_.
+
+.. _mlx-examples: https://github.com/ml-explore/mlx-examples/tree/main/llms/llama
+
+.. [1] Su, J., Lu, Y., Pan, S., Murtadha, A., Wen, B. and Liu, Y., 2021.
+   Roformer: Enhanced transformer with rotary position embedding. arXiv
+   preprint arXiv:2104.09864.
+.. [2] Zhang, B. and Sennrich, R., 2019. Root mean square layer normalization.
+   Advances in Neural Information Processing Systems, 32.
+.. [3] Shazeer, N., 2020. Glu variants improve transformer. arXiv preprint
+   arXiv:2002.05202.
diff --git a/ml-stable-diffusion/mlx/docs/src/examples/mlp.rst b/ml-stable-diffusion/mlx/docs/src/examples/mlp.rst
new file mode 100644
index 0000000000000000000000000000000000000000..3214af504e030e827aa749b4366ca4d203645563
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/examples/mlp.rst
@@ -0,0 +1,134 @@
+.. _mlp:
+
+Multi-Layer Perceptron
+----------------------
+
+In this example we'll learn to use ``mlx.nn`` by implementing a simple
+multi-layer perceptron to classify MNIST.
+
+As a first step import the MLX packages we need:
+
+.. code-block:: python
+
+  import mlx.core as mx
+  import mlx.nn as nn
+  import mlx.optimizers as optim
+
+  import numpy as np
+
+
+The model is defined as the ``MLP`` class which inherits from
+:class:`mlx.nn.Module`. We follow the standard idiom to make a new module:
+
+1. Define an ``__init__`` where the parameters and/or submodules are setup. See
+   the :ref:`Module class docs<module_class>` for more information on how
+   :class:`mlx.nn.Module` registers parameters.
+2. Define a ``__call__`` where the computation is implemented.
+
+.. code-block:: python
+
+  class MLP(nn.Module):
+      def __init__(
+          self, num_layers: int, input_dim: int, hidden_dim: int, output_dim: int
+      ):
+          super().__init__()
+          layer_sizes = [input_dim] + [hidden_dim] * num_layers + [output_dim]
+          self.layers = [
+              nn.Linear(idim, odim)
+              for idim, odim in zip(layer_sizes[:-1], layer_sizes[1:])
+          ]
+
+      def __call__(self, x):
+          for l in self.layers[:-1]:
+              x = mx.maximum(l(x), 0.0)
+          return self.layers[-1](x)
+
+
+We define the loss function which takes the mean of the per-example cross
+entropy loss.  The ``mlx.nn.losses`` sub-package has implementations of some
+commonly used loss functions.
+
+.. code-block:: python
+
+  def loss_fn(model, X, y):
+      return mx.mean(nn.losses.cross_entropy(model(X), y))
+
+We also need a function to compute the accuracy of the model on the validation
+set:
+
+.. code-block:: python
+
+  def eval_fn(model, X, y):
+      return mx.mean(mx.argmax(model(X), axis=1) == y)
+
+Next, setup the problem parameters and load the data. To load the data, you need our
+`mnist data loader
+<https://github.com/ml-explore/mlx-examples/blob/main/mnist/mnist.py>`_, which
+we will import as ``mnist``.
+
+.. code-block:: python
+
+  num_layers = 2
+  hidden_dim = 32
+  num_classes = 10
+  batch_size = 256
+  num_epochs = 10
+  learning_rate = 1e-1
+
+  # Load the data
+  import mnist 
+  train_images, train_labels, test_images, test_labels = map(
+      mx.array, mnist.mnist()
+  )
+
+Since we're using SGD, we need an iterator which shuffles and constructs
+minibatches of examples in the training set:
+
+.. code-block:: python
+
+  def batch_iterate(batch_size, X, y):
+      perm = mx.array(np.random.permutation(y.size))
+      for s in range(0, y.size, batch_size):
+          ids = perm[s : s + batch_size]
+          yield X[ids], y[ids]
+
+
+Finally, we put it all together by instantiating the model, the
+:class:`mlx.optimizers.SGD` optimizer, and running the training loop:
+
+.. code-block:: python
+
+  # Load the model
+  model = MLP(num_layers, train_images.shape[-1], hidden_dim, num_classes)
+  mx.eval(model.parameters())
+
+  # Get a function which gives the loss and gradient of the
+  # loss with respect to the model's trainable parameters
+  loss_and_grad_fn = nn.value_and_grad(model, loss_fn)
+
+  # Instantiate the optimizer
+  optimizer = optim.SGD(learning_rate=learning_rate)
+
+  for e in range(num_epochs):
+      for X, y in batch_iterate(batch_size, train_images, train_labels):
+          loss, grads = loss_and_grad_fn(model, X, y)
+
+          # Update the optimizer state and model parameters
+          # in a single call
+          optimizer.update(model, grads)
+
+          # Force a graph evaluation
+          mx.eval(model.parameters(), optimizer.state)
+
+      accuracy = eval_fn(model, test_images, test_labels)
+      print(f"Epoch {e}: Test accuracy {accuracy.item():.3f}")
+
+
+.. note::
+  The :func:`mlx.nn.value_and_grad` function is a convenience function to get
+  the gradient of a loss with respect to the trainable parameters of a model.
+  This should not be confused with :func:`mlx.core.value_and_grad`.
+
+The model should train to a decent accuracy (about 95%) after just a few passes
+over the training set. The `full example <https://github.com/ml-explore/mlx-examples/tree/main/mnist>`_
+is available in the MLX GitHub repo.
diff --git a/ml-stable-diffusion/mlx/docs/src/index.rst b/ml-stable-diffusion/mlx/docs/src/index.rst
new file mode 100644
index 0000000000000000000000000000000000000000..76907dbe036d63daa32d1baf8bcda2cec99aac7d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/index.rst
@@ -0,0 +1,93 @@
+MLX
+===
+
+MLX is a NumPy-like array framework designed for efficient and flexible machine
+learning on Apple silicon, brought to you by Apple machine learning research.
+
+The Python API closely follows NumPy with a few exceptions. MLX also has a
+fully featured C++ API which closely follows the Python API.
+
+The main differences between MLX and NumPy are:
+
+ - **Composable function transformations**: MLX has composable function
+   transformations for automatic differentiation, automatic vectorization,
+   and computation graph optimization.
+ - **Lazy computation**: Computations in MLX are lazy. Arrays are only
+   materialized when needed.
+ - **Multi-device**: Operations can run on any of the supported devices (CPU,
+   GPU, ...)
+
+The design of MLX is inspired by frameworks like `PyTorch
+<https://pytorch.org/>`_, `Jax <https://github.com/google/jax>`_, and
+`ArrayFire <https://arrayfire.org/>`_. A notable difference from these
+frameworks and MLX is the *unified memory model*. Arrays in MLX live in shared
+memory. Operations on MLX arrays can be performed on any of the supported
+device types without performing data copies. Currently supported device types
+are the CPU and GPU.
+
+.. toctree::
+   :caption: Install
+   :maxdepth: 1
+
+   install
+
+.. toctree::
+   :caption: Usage 
+   :maxdepth: 1
+
+   usage/quick_start
+   usage/lazy_evaluation
+   usage/unified_memory
+   usage/indexing
+   usage/saving_and_loading
+   usage/function_transforms
+   usage/compile
+   usage/numpy
+   usage/distributed
+   usage/using_streams
+   usage/export
+
+.. toctree::
+   :caption: Examples
+   :maxdepth: 1
+
+   examples/linear_regression
+   examples/mlp
+   examples/llama-inference
+
+.. toctree::
+   :caption: Python API Reference
+   :maxdepth: 1
+
+   python/array
+   python/data_types
+   python/devices_and_streams
+   python/export
+   python/ops
+   python/random
+   python/transforms
+   python/fast
+   python/fft
+   python/linalg
+   python/metal
+   python/cuda
+   python/memory_management
+   python/nn
+   python/optimizers
+   python/distributed
+   python/tree_utils
+
+.. toctree::
+   :caption: C++ API Reference
+   :maxdepth: 1
+
+   cpp/ops
+
+.. toctree::
+   :caption: Further Reading
+   :maxdepth: 1
+
+   dev/extensions
+   dev/metal_debugger
+   dev/custom_metal_kernels
+   dev/mlx_in_cpp
diff --git a/ml-stable-diffusion/mlx/docs/src/install.rst b/ml-stable-diffusion/mlx/docs/src/install.rst
new file mode 100644
index 0000000000000000000000000000000000000000..da74709084af1d708a10ca6831bfa22c67581cd8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/install.rst
@@ -0,0 +1,345 @@
+.. _build_and_install:
+
+Build and Install
+=================
+
+Python Installation
+-------------------
+
+MLX is available on PyPI. All you have to do to use MLX with your own Apple
+silicon computer is
+
+.. code-block:: shell
+
+    pip install mlx
+
+To install from PyPI your system must meet the following requirements:
+
+- Using an M series chip (Apple silicon)
+- Using a native Python >= 3.9
+- macOS >= 13.5
+
+.. note::
+    MLX is only available on devices running macOS >= 13.5
+    It is highly recommended to use macOS 14 (Sonoma)
+
+CUDA
+^^^^
+
+MLX has a CUDA backend which you can install with:
+
+.. code-block:: shell
+
+    pip install mlx[cuda]
+
+To install the CUDA package from PyPi your system must meet the following
+requirements:
+
+- Nvidia architecture >= SM 7.0 (Volta)
+- Nvidia driver >= 550.54.14
+- CUDA toolkit >= 12.0
+- Linux distribution with glibc >= 2.35
+- Python >= 3.9
+
+
+CPU-only (Linux)
+^^^^^^^^^^^^^^^^
+
+For a CPU-only version of MLX that runs on Linux use:
+
+.. code-block:: shell
+
+    pip install mlx[cpu]
+
+To install the CPU-only package from PyPi your system must meet the following
+requirements:
+
+- Linux distribution with glibc >= 2.35
+- Python >= 3.9
+
+
+Troubleshooting
+^^^^^^^^^^^^^^^
+
+*My OS and Python versions are in the required range but pip still does not find
+a matching distribution.*
+
+Probably you are using a non-native Python. The output of
+
+.. code-block:: shell
+
+  python -c "import platform; print(platform.processor())"
+
+should be ``arm``. If it is ``i386`` (and you have M series machine) then you
+are using a non-native Python. Switch your Python to a native Python. A good
+way to do this is with `Conda <https://stackoverflow.com/q/65415996>`_.
+
+
+Build from source
+-----------------
+
+Build Requirements
+^^^^^^^^^^^^^^^^^^
+
+- A C++ compiler with C++17 support (e.g. Clang >= 5.0)
+- `cmake <https://cmake.org/>`_ -- version 3.25 or later, and ``make``
+- Xcode >= 15.0 and macOS SDK >= 14.0
+
+.. note::
+   Ensure your shell environment is native ``arm``, not ``x86`` via Rosetta. If
+   the output of ``uname -p`` is ``x86``, see the :ref:`troubleshooting section <build shell>` below.
+
+Python API
+^^^^^^^^^^
+
+.. _python install:
+
+To build and install the MLX python library from source, first, clone MLX from
+`its GitHub repo <https://github.com/ml-explore/mlx>`_:
+
+.. code-block:: shell
+
+   git clone git@github.com:ml-explore/mlx.git mlx && cd mlx
+
+Then simply build and install MLX using pip:
+
+.. code-block:: shell
+
+  pip install .
+
+For developing, install the package with development dependencies, and use an
+editable install:
+
+.. code-block:: shell
+
+  pip install -e ".[dev]"
+
+Once the development dependencies are installed, you can build faster with:
+
+.. code-block:: shell
+
+ python setup.py build_ext --inplace
+
+Run the tests with:
+
+.. code-block:: shell
+
+  python -m unittest discover python/tests
+
+Optional: Install stubs to enable auto completions and type checking from your
+IDE:
+
+.. code-block:: shell
+
+  python setup.py generate_stubs
+
+C++ API
+^^^^^^^
+
+.. _cpp install:
+
+Currently, MLX must be built and installed from source.
+
+Similarly to the python library, to build and install the MLX C++ library start
+by cloning MLX from `its GitHub repo
+<https://github.com/ml-explore/mlx>`_:
+
+.. code-block:: shell
+
+   git clone git@github.com:ml-explore/mlx.git mlx && cd mlx
+
+Create a build directory and run CMake and make:
+
+.. code-block:: shell
+
+   mkdir -p build && cd build
+   cmake .. && make -j
+
+Run tests with:
+
+.. code-block:: shell
+
+   make test
+
+Install with:
+
+.. code-block:: shell
+
+   make install
+
+Note that the built ``mlx.metallib`` file should be either at the same
+directory as the executable statically linked to ``libmlx.a`` or the
+preprocessor constant ``METAL_PATH`` should be defined at build time and it
+should point to the path to the built metal library.
+
+.. list-table:: Build Options
+   :widths: 25 8
+   :header-rows: 1
+
+   * - Option
+     - Default
+   * - MLX_BUILD_TESTS
+     - ON
+   * - MLX_BUILD_EXAMPLES
+     - OFF
+   * - MLX_BUILD_BENCHMARKS
+     - OFF
+   * - MLX_BUILD_METAL
+     - ON
+   * - MLX_BUILD_CPU
+     - ON
+   * - MLX_BUILD_PYTHON_BINDINGS
+     - OFF
+   * - MLX_METAL_DEBUG
+     - OFF
+   * - MLX_BUILD_SAFETENSORS
+     - ON
+   * - MLX_BUILD_GGUF
+     - ON
+   * - MLX_METAL_JIT
+     - OFF
+
+.. note::
+
+    If you have multiple Xcode installations and wish to use
+    a specific one while building, you can do so by adding the
+    following environment variable before building
+
+    .. code-block:: shell
+
+      export DEVELOPER_DIR="/path/to/Xcode.app/Contents/Developer/"
+
+    Further, you can use the following command to find out which
+    macOS SDK will be used
+
+    .. code-block:: shell
+
+      xcrun -sdk macosx --show-sdk-version
+
+
+Binary Size Minimization
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+To produce a smaller binary use the CMake flags ``CMAKE_BUILD_TYPE=MinSizeRel``
+and ``BUILD_SHARED_LIBS=ON``.
+
+The MLX CMake build has several additional options to make smaller binaries.
+For example, if you don't need the CPU backend or support for safetensors and
+GGUF, you can do:
+
+.. code-block:: shell
+
+  cmake .. \
+    -DCMAKE_BUILD_TYPE=MinSizeRel \
+    -DBUILD_SHARED_LIBS=ON \
+    -DMLX_BUILD_CPU=OFF \
+    -DMLX_BUILD_SAFETENSORS=OFF \
+    -DMLX_BUILD_GGUF=OFF \
+    -DMLX_METAL_JIT=ON
+
+THE ``MLX_METAL_JIT`` flag minimizes the size of the MLX Metal library which
+contains pre-built GPU kernels. This substantially reduces the size of the
+Metal library by run-time compiling kernels the first time they are used in MLX
+on a given machine. Note run-time compilation incurs a cold-start cost which can
+be anwywhere from a few hundred millisecond to a few seconds depending on the
+application. Once a kernel is compiled, it will be cached by the system. The
+Metal kernel cache persists across reboots.
+
+Linux
+^^^^^
+
+To build from source on Linux (CPU only), install the BLAS and LAPACK headers.
+For example on Ubuntu, run the following:
+
+.. code-block:: shell
+
+   apt-get update -y
+   apt-get install libblas-dev liblapack-dev liblapacke-dev -y
+
+From here follow the instructions to install either the :ref:`Python <python
+install>` or :ref:`C++ <cpp install>` APIs.
+
+CUDA
+^^^^
+
+To build from source on Linux with CUDA, install the BLAS and LAPACK headers
+and the CUDA toolkit. For example on Ubuntu, run the following:
+
+.. code-block:: shell
+
+   wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb
+   dpkg -i cuda-keyring_1.1-1_all.deb
+   apt-get update -y
+   apt-get -y install cuda-toolkit-12-9
+   apt-get install libblas-dev liblapack-dev liblapacke-dev libcudnn9-dev-cuda-12 -y
+
+
+When building either the Python or C++ APIs make sure to pass the cmake flag
+``MLX_BUILD_CUDA=ON``. For example, to build the Python API run:
+
+.. code-block:: shell
+
+  CMAKE_ARGS="-DMLX_BUILD_CUDA=ON" pip install -e ".[dev]"
+
+To build the C++ package run:
+
+.. code-block:: shell
+
+   mkdir -p build && cd build
+   cmake .. -DMLX_BUILD_CUDA=ON && make -j
+
+
+Troubleshooting
+^^^^^^^^^^^^^^^
+
+Metal not found
+~~~~~~~~~~~~~~~
+
+You see the following error when you try to build:
+
+.. code-block:: shell
+
+  error: unable to find utility "metal", not a developer tool or in PATH
+
+To fix this, first make sure you have Xcode installed:
+
+.. code-block:: shell
+
+  xcode-select --install
+
+Then set the active developer directory:
+
+.. code-block:: shell
+
+  sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer
+
+x86 Shell
+~~~~~~~~~
+
+.. _build shell:
+
+If the output of ``uname -p``  is ``x86`` then your shell is running as x86 via
+Rosetta instead of natively.
+
+To fix this, find the application in Finder (``/Applications`` for iTerm,
+``/Applications/Utilities`` for Terminal), right-click, and click “Get Info”.
+Uncheck “Open using Rosetta”, close the “Get Info” window, and restart your
+terminal.
+
+Verify the terminal is now running natively the following command:
+
+.. code-block:: shell
+
+  $ uname -p
+  arm
+
+Also check that cmake is using the correct architecture:
+
+.. code-block:: shell
+
+  $ cmake --system-information | grep CMAKE_HOST_SYSTEM_PROCESSOR
+  CMAKE_HOST_SYSTEM_PROCESSOR "arm64"
+
+If you see ``"x86_64"``, try re-installing ``cmake``. If you see ``"arm64"``
+but the build errors out with "Building for x86_64 on macOS is not supported."
+wipe your build cache with ``rm -rf build/`` and try again.
diff --git a/ml-stable-diffusion/mlx/docs/src/python/array.rst b/ml-stable-diffusion/mlx/docs/src/python/array.rst
new file mode 100644
index 0000000000000000000000000000000000000000..e68524d5a44abcba5e2c2d34cfb33be8c2ca97e7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/array.rst
@@ -0,0 +1,65 @@
+.. _array:
+
+Array
+=====
+
+.. currentmodule:: mlx.core
+
+.. autosummary:: 
+   :toctree: _autosummary 
+
+    array
+    array.astype
+    array.at
+    array.item
+    array.tolist
+    array.dtype
+    array.itemsize
+    array.nbytes
+    array.ndim
+    array.shape
+    array.size
+    array.real
+    array.imag
+    array.abs
+    array.all
+    array.any
+    array.argmax
+    array.argmin
+    array.conj
+    array.cos
+    array.cummax
+    array.cummin
+    array.cumprod
+    array.cumsum
+    array.diag
+    array.diagonal
+    array.exp
+    array.flatten
+    array.log
+    array.log10
+    array.log1p
+    array.log2
+    array.logcumsumexp
+    array.logsumexp
+    array.max
+    array.mean
+    array.min
+    array.moveaxis
+    array.prod
+    array.reciprocal
+    array.reshape
+    array.round
+    array.rsqrt
+    array.sin
+    array.split
+    array.sqrt
+    array.square
+    array.squeeze
+    array.std
+    array.sum
+    array.swapaxes
+    array.transpose
+    array.T
+    array.var
+    array.view
diff --git a/ml-stable-diffusion/mlx/docs/src/python/cuda.rst b/ml-stable-diffusion/mlx/docs/src/python/cuda.rst
new file mode 100644
index 0000000000000000000000000000000000000000..932d36b5ef9860a600f5698760bc6cd62d7313fe
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/cuda.rst
@@ -0,0 +1,9 @@
+CUDA
+=====
+
+.. currentmodule:: mlx.core.cuda
+
+.. autosummary::
+  :toctree: _autosummary
+
+  is_available
diff --git a/ml-stable-diffusion/mlx/docs/src/python/data_types.rst b/ml-stable-diffusion/mlx/docs/src/python/data_types.rst
new file mode 100644
index 0000000000000000000000000000000000000000..4c4a5910dc0a78604534b470b03cc7daf5e924a3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/data_types.rst
@@ -0,0 +1,78 @@
+.. _data_types:
+
+Data Types
+==========
+
+.. currentmodule:: mlx.core
+
+The default floating point type is ``float32`` and the default integer type is
+``int32``. The table below shows supported values for :obj:`Dtype`. 
+
+.. list-table:: Supported Data Types 
+   :widths: 5 3 20
+   :header-rows: 1
+
+   * - Type 
+     - Bytes
+     - Description
+   * - ``bool_``
+     - 1 
+     - Boolean (``True``, ``False``) data type
+   * - ``uint8``
+     - 1 
+     - 8-bit unsigned integer 
+   * - ``uint16``
+     - 2 
+     - 16-bit unsigned integer 
+   * - ``uint32``
+     - 4 
+     - 32-bit unsigned integer 
+   * - ``uint64``
+     - 8 
+     - 64-bit unsigned integer 
+   * - ``int8``
+     - 1 
+     - 8-bit signed integer 
+   * - ``int16``
+     - 2 
+     - 16-bit signed integer 
+   * - ``int32``
+     - 4 
+     - 32-bit signed integer 
+   * - ``int64``
+     - 8 
+     - 64-bit signed integer 
+   * - ``bfloat16``
+     - 2 
+     - 16-bit brain float (e8, m7)
+   * - ``float16``
+     - 2 
+     - 16-bit IEEE float (e5, m10)
+   * - ``float32``
+     - 4 
+     - 32-bit float
+   * - ``float64``
+     - 4 
+     - 64-bit double
+   * - ``complex64``
+     - 8 
+     - 64-bit complex float
+
+
+.. note::
+
+    Arrays with type ``float64`` only work with CPU operations. Using
+    ``float64`` arrays on the GPU will result in an exception.
+
+
+Data type are aranged in a hierarchy. See the :obj:`DtypeCategory` object
+documentation for more information. Use :func:`issubdtype` to determine if one
+``dtype`` (or category) is a subtype of another category.
+
+.. autosummary::
+   :toctree: _autosummary
+
+   Dtype
+   DtypeCategory
+   issubdtype
+   finfo
diff --git a/ml-stable-diffusion/mlx/docs/src/python/devices_and_streams.rst b/ml-stable-diffusion/mlx/docs/src/python/devices_and_streams.rst
new file mode 100644
index 0000000000000000000000000000000000000000..2a5adc05a6f8f3704969fdf969b25ecf4d6fcd51
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/devices_and_streams.rst
@@ -0,0 +1,19 @@
+.. _devices_and_streams:
+
+Devices and Streams
+===================
+
+.. currentmodule:: mlx.core
+
+.. autosummary::
+  :toctree: _autosummary
+
+   Device
+   Stream
+   default_device
+   set_default_device
+   default_stream
+   new_stream
+   set_default_stream
+   stream
+   synchronize
diff --git a/ml-stable-diffusion/mlx/docs/src/python/distributed.rst b/ml-stable-diffusion/mlx/docs/src/python/distributed.rst
new file mode 100644
index 0000000000000000000000000000000000000000..8b48d727e02d1b7b1279ee48b7bf0702045c5e45
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/distributed.rst
@@ -0,0 +1,22 @@
+.. _distributed:
+
+.. currentmodule:: mlx.core.distributed
+
+Distributed Communication
+==========================
+
+MLX provides a distributed communication package using MPI. The MPI library is
+loaded at runtime; if MPI is available then distributed communication is also
+made available.
+
+.. autosummary::
+   :toctree: _autosummary
+
+    Group
+    is_available
+    init
+    all_sum
+    all_gather
+    send
+    recv
+    recv_like
diff --git a/ml-stable-diffusion/mlx/docs/src/python/export.rst b/ml-stable-diffusion/mlx/docs/src/python/export.rst
new file mode 100644
index 0000000000000000000000000000000000000000..9a1599096a18ffff89754d0472ae561738544d4a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/export.rst
@@ -0,0 +1,14 @@
+.. _export:
+
+Export Functions
+================
+
+.. currentmodule:: mlx.core
+
+.. autosummary::
+  :toctree: _autosummary
+
+   export_function
+   import_function
+   exporter
+   export_to_dot
diff --git a/ml-stable-diffusion/mlx/docs/src/python/fast.rst b/ml-stable-diffusion/mlx/docs/src/python/fast.rst
new file mode 100644
index 0000000000000000000000000000000000000000..b250dcb1867b7d17771f120e5d3aa869f755e30e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/fast.rst
@@ -0,0 +1,16 @@
+.. _fast:
+
+Fast
+====
+
+.. currentmodule:: mlx.core.fast
+
+.. autosummary:: 
+  :toctree: _autosummary
+
+  rms_norm
+  layer_norm
+  rope
+  scaled_dot_product_attention
+  metal_kernel
+  cuda_kernel
diff --git a/ml-stable-diffusion/mlx/docs/src/python/fft.rst b/ml-stable-diffusion/mlx/docs/src/python/fft.rst
new file mode 100644
index 0000000000000000000000000000000000000000..36d9d78380beb9315e901b87fae0b96fb5c4715c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/fft.rst
@@ -0,0 +1,24 @@
+.. _fft:
+
+FFT
+===
+
+.. currentmodule:: mlx.core.fft
+
+.. autosummary:: 
+  :toctree: _autosummary
+
+  fft
+  ifft
+  fft2
+  ifft2
+  fftn
+  ifftn
+  rfft
+  irfft
+  rfft2
+  irfft2
+  rfftn
+  irfftn
+  fftshift
+  ifftshift
diff --git a/ml-stable-diffusion/mlx/docs/src/python/linalg.rst b/ml-stable-diffusion/mlx/docs/src/python/linalg.rst
new file mode 100644
index 0000000000000000000000000000000000000000..495380c46f2107677a37c63f2c60ba621ee9b6ac
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/linalg.rst
@@ -0,0 +1,27 @@
+.. _linalg:
+
+Linear Algebra
+==============
+
+.. currentmodule:: mlx.core.linalg
+
+.. autosummary::
+   :toctree: _autosummary
+
+    inv
+    tri_inv
+    norm
+    cholesky
+    cholesky_inv
+    cross
+    qr
+    svd
+    eigvals
+    eig
+    eigvalsh
+    eigh
+    lu
+    lu_factor
+    pinv
+    solve
+    solve_triangular
diff --git a/ml-stable-diffusion/mlx/docs/src/python/memory_management.rst b/ml-stable-diffusion/mlx/docs/src/python/memory_management.rst
new file mode 100644
index 0000000000000000000000000000000000000000..f708efbfd2a4e29e9c31877cf29b0ea9ea16ddf7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/memory_management.rst
@@ -0,0 +1,16 @@
+Memory Management
+=================
+
+.. currentmodule:: mlx.core
+
+.. autosummary::
+  :toctree: _autosummary
+
+  get_active_memory
+  get_peak_memory
+  reset_peak_memory
+  get_cache_memory
+  set_memory_limit
+  set_cache_limit
+  set_wired_limit
+  clear_cache
diff --git a/ml-stable-diffusion/mlx/docs/src/python/metal.rst b/ml-stable-diffusion/mlx/docs/src/python/metal.rst
new file mode 100644
index 0000000000000000000000000000000000000000..83a363c3ba8cb5410f0e857364f5e0f9b91b1ce7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/metal.rst
@@ -0,0 +1,12 @@
+Metal
+=====
+
+.. currentmodule:: mlx.core.metal
+
+.. autosummary::
+  :toctree: _autosummary
+
+  is_available
+  device_info
+  start_capture
+  stop_capture
diff --git a/ml-stable-diffusion/mlx/docs/src/python/nn.rst b/ml-stable-diffusion/mlx/docs/src/python/nn.rst
new file mode 100644
index 0000000000000000000000000000000000000000..5a7344d9f5b60140cb9e7899bdfc16f71f803d3f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/nn.rst
@@ -0,0 +1,185 @@
+.. _nn:
+
+.. currentmodule:: mlx.nn
+
+Neural Networks
+===============
+
+Writing arbitrarily complex neural networks in MLX can be done using only
+:class:`mlx.core.array` and :meth:`mlx.core.value_and_grad`. However, this requires the
+user to write again and again the same simple neural network operations as well
+as handle all the parameter state and initialization manually and explicitly.
+
+The module :mod:`mlx.nn` solves this problem by providing an intuitive way of
+composing neural network layers, initializing their parameters, freezing them
+for finetuning and more.
+
+Quick Start with Neural Networks
+---------------------------------
+
+.. code-block:: python
+
+    import mlx.core as mx
+    import mlx.nn as nn
+
+    class MLP(nn.Module):
+        def __init__(self, in_dims: int, out_dims: int):
+            super().__init__()
+
+            self.layers = [
+                nn.Linear(in_dims, 128),
+                nn.Linear(128, 128),
+                nn.Linear(128, out_dims),
+            ]
+
+        def __call__(self, x):
+            for i, l in enumerate(self.layers):
+                x = mx.maximum(x, 0) if i > 0 else x
+                x = l(x)
+            return x
+
+    # The model is created with all its parameters but nothing is initialized
+    # yet because MLX is lazily evaluated
+    mlp = MLP(2, 10)
+
+    # We can access its parameters by calling mlp.parameters()
+    params = mlp.parameters()
+    print(params["layers"][0]["weight"].shape)
+
+    # Printing a parameter will cause it to be evaluated and thus initialized
+    print(params["layers"][0])
+
+    # We can also force evaluate all parameters to initialize the model
+    mx.eval(mlp.parameters())
+
+    # A simple loss function.
+    # NOTE: It doesn't matter how it uses the mlp model. It currently captures
+    #       it from the local scope. It could be a positional argument or a
+    #       keyword argument.
+    def l2_loss(x, y):
+        y_hat = mlp(x)
+        return (y_hat - y).square().mean()
+
+    # Calling `nn.value_and_grad` instead of `mx.value_and_grad` returns the
+    # gradient with respect to `mlp.trainable_parameters()`
+    loss_and_grad = nn.value_and_grad(mlp, l2_loss)
+
+.. _module_class:
+
+The Module Class
+----------------
+
+The workhorse of any neural network library is the :class:`Module` class. In
+MLX the :class:`Module` class is a container of :class:`mlx.core.array` or
+:class:`Module` instances. Its main function is to provide a way to
+recursively **access** and **update** its parameters and those of its
+submodules.
+
+Parameters
+^^^^^^^^^^
+
+A parameter of a module is any public member of type :class:`mlx.core.array` (its
+name should not start with ``_``). It can be arbitrarily nested in other
+:class:`Module` instances or lists and dictionaries.
+
+:meth:`Module.parameters` can be used to extract a nested dictionary with all
+the parameters of a module and its submodules.
+
+A :class:`Module` can also keep track of "frozen" parameters. See the
+:meth:`Module.freeze` method for more details. :meth:`mlx.nn.value_and_grad`
+the gradients returned will be with respect to these trainable parameters.
+
+
+Updating the Parameters
+^^^^^^^^^^^^^^^^^^^^^^^
+
+MLX modules allow accessing and updating individual parameters. However, most
+times we need to update large subsets of a module's parameters. This action is
+performed by :meth:`Module.update`.
+
+
+Inspecting Modules
+^^^^^^^^^^^^^^^^^^
+
+The simplest way to see the model architecture is to print it. Following along with
+the above example, you can print the ``MLP`` with:
+
+.. code-block:: python
+
+  print(mlp)
+
+This will display:
+
+.. code-block:: shell
+
+  MLP(
+    (layers.0): Linear(input_dims=2, output_dims=128, bias=True)
+    (layers.1): Linear(input_dims=128, output_dims=128, bias=True)
+    (layers.2): Linear(input_dims=128, output_dims=10, bias=True)
+  )
+
+To get more detailed information on the arrays in a :class:`Module` you can use
+:func:`mlx.utils.tree_map` on the parameters. For example, to see the shapes of
+all the parameters in a :class:`Module` do:
+
+.. code-block:: python
+
+   from mlx.utils import tree_map
+   shapes = tree_map(lambda p: p.shape, mlp.parameters())
+
+As another example, you can count the number of parameters in a :class:`Module`
+with:
+
+.. code-block:: python
+
+   from mlx.utils import tree_flatten
+   num_params = sum(v.size for _, v in tree_flatten(mlp.parameters()))
+
+
+Value and Grad
+--------------
+
+Using a :class:`Module` does not preclude using MLX's high order function
+transformations (:meth:`mlx.core.value_and_grad`, :meth:`mlx.core.grad`, etc.). However,
+these function transformations assume pure functions, namely the parameters
+should be passed as an argument to the function being transformed.
+
+There is an easy pattern to achieve that with MLX modules
+
+.. code-block:: python
+
+    model = ...
+
+    def f(params, other_inputs):
+        model.update(params)  # <---- Necessary to make the model use the passed parameters
+        return model(other_inputs)
+
+    f(model.trainable_parameters(), mx.zeros((10,)))
+
+However, :meth:`mlx.nn.value_and_grad` provides precisely this pattern and only
+computes the gradients with respect to the trainable parameters of the model.
+
+In detail:
+
+- it wraps the passed function with a function that calls :meth:`Module.update`
+  to make sure the model is using the provided parameters.
+- it calls :meth:`mlx.core.value_and_grad` to transform the function into a function
+  that also computes the gradients with respect to the passed parameters.
+- it wraps the returned function with a function that passes the trainable
+  parameters as the first argument to the function returned by
+  :meth:`mlx.core.value_and_grad`
+
+.. autosummary::
+   :toctree: _autosummary
+
+   value_and_grad
+   quantize
+   average_gradients
+
+.. toctree::
+
+   nn/module
+   nn/layers
+   nn/functions
+   nn/losses
+   nn/init
diff --git a/ml-stable-diffusion/mlx/docs/src/python/nn/functions.rst b/ml-stable-diffusion/mlx/docs/src/python/nn/functions.rst
new file mode 100644
index 0000000000000000000000000000000000000000..d3c533d0cb02b7679dc378212e45573143f714c2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/nn/functions.rst
@@ -0,0 +1,40 @@
+.. _nn_functions:
+
+.. currentmodule:: mlx.nn
+
+Functions
+---------
+
+Layers without parameters (e.g. activation functions) are also provided as
+simple functions.
+
+.. autosummary::
+   :toctree: _autosummary_functions
+   :template: nn-module-template.rst
+
+   elu
+   celu
+   gelu
+   gelu_approx
+   gelu_fast_approx
+   glu
+   hard_shrink
+   hard_tanh
+   hardswish
+   leaky_relu
+   log_sigmoid
+   log_softmax
+   mish
+   prelu
+   relu
+   relu2
+   relu6
+   selu
+   sigmoid
+   silu
+   softmax
+   softmin
+   softplus
+   softshrink
+   step
+   tanh
diff --git a/ml-stable-diffusion/mlx/docs/src/python/nn/init.rst b/ml-stable-diffusion/mlx/docs/src/python/nn/init.rst
new file mode 100644
index 0000000000000000000000000000000000000000..610d767d43154bc36afdb374f29a975632fb0da5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/nn/init.rst
@@ -0,0 +1,45 @@
+.. _init:
+
+.. currentmodule:: mlx.nn.init
+
+Initializers
+------------
+
+The ``mlx.nn.init`` package contains commonly used initializers for neural
+network parameters. Initializers return a function which can be applied to any
+input :obj:`mlx.core.array` to produce an initialized output.
+
+For example:
+
+.. code:: python
+
+   import mlx.core as mx
+   import mlx.nn as nn
+
+   init_fn = nn.init.uniform()
+
+   # Produces a [2, 2] uniform matrix
+   param = init_fn(mx.zeros((2, 2)))
+
+To re-initialize all the parameter in an :obj:`mlx.nn.Module` from say a uniform 
+distribution, you can do:
+
+.. code:: python
+  
+   import mlx.nn as nn
+   model = nn.Sequential(nn.Linear(5, 10), nn.ReLU(), nn.Linear(10, 5))
+   init_fn = nn.init.uniform(low=-0.1, high=0.1)
+   model.apply(init_fn)
+   
+
+.. autosummary::
+   :toctree: _autosummary
+
+   constant
+   normal
+   uniform
+   identity
+   glorot_normal
+   glorot_uniform
+   he_normal
+   he_uniform
diff --git a/ml-stable-diffusion/mlx/docs/src/python/nn/layers.rst b/ml-stable-diffusion/mlx/docs/src/python/nn/layers.rst
new file mode 100644
index 0000000000000000000000000000000000000000..1469481477b436a7eaa158cfb845c2369533cbc6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/nn/layers.rst
@@ -0,0 +1,70 @@
+.. _layers:
+
+.. currentmodule:: mlx.nn
+
+Layers
+------
+
+.. autosummary::
+   :toctree: _autosummary
+   :template: nn-module-template.rst
+
+   ALiBi
+   AvgPool1d
+   AvgPool2d
+   AvgPool3d
+   BatchNorm
+   CELU
+   Conv1d
+   Conv2d
+   Conv3d
+   ConvTranspose1d
+   ConvTranspose2d
+   ConvTranspose3d
+   Dropout
+   Dropout2d
+   Dropout3d
+   Embedding
+   ELU
+   GELU
+   GLU
+   GroupNorm
+   GRU
+   HardShrink
+   HardTanh
+   Hardswish
+   InstanceNorm
+   LayerNorm
+   LeakyReLU
+   Linear
+   LogSigmoid
+   LogSoftmax
+   LSTM
+   MaxPool1d
+   MaxPool2d
+   MaxPool3d
+   Mish
+   MultiHeadAttention
+   PReLU
+   QuantizedEmbedding
+   QuantizedLinear
+   RMSNorm
+   ReLU
+   ReLU2
+   ReLU6
+   RNN
+   RoPE
+   SELU
+   Sequential
+   Sigmoid
+   SiLU
+   SinusoidalPositionalEncoding
+   Softmin
+   Softshrink
+   Softsign
+   Softmax
+   Softplus
+   Step
+   Tanh
+   Transformer
+   Upsample
diff --git a/ml-stable-diffusion/mlx/docs/src/python/nn/losses.rst b/ml-stable-diffusion/mlx/docs/src/python/nn/losses.rst
new file mode 100644
index 0000000000000000000000000000000000000000..6a2e128c5d1dcb020bf6ad65e8f741073cd90428
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/nn/losses.rst
@@ -0,0 +1,25 @@
+.. _losses:
+
+.. currentmodule:: mlx.nn.losses
+
+Loss Functions
+--------------
+
+.. autosummary::
+   :toctree: _autosummary_functions
+   :template: nn-module-template.rst
+
+   binary_cross_entropy
+   cosine_similarity_loss
+   cross_entropy
+   gaussian_nll_loss
+   hinge_loss
+   huber_loss
+   kl_div_loss
+   l1_loss
+   log_cosh_loss
+   margin_ranking_loss
+   mse_loss
+   nll_loss
+   smooth_l1_loss
+   triplet_loss
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/docs/src/python/nn/module.rst b/ml-stable-diffusion/mlx/docs/src/python/nn/module.rst
new file mode 100644
index 0000000000000000000000000000000000000000..c17f63eceab0b6b33ed3f659f8a9bba12b5473c2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/nn/module.rst
@@ -0,0 +1,38 @@
+Module
+======
+
+.. currentmodule:: mlx.nn
+
+.. autoclass:: Module
+
+   .. rubric:: Attributes
+
+   .. autosummary::
+      :toctree: _autosummary
+   
+      Module.training
+      Module.state
+   
+   .. rubric:: Methods
+
+   .. autosummary::
+      :toctree: _autosummary
+   
+      Module.apply
+      Module.apply_to_modules
+      Module.children
+      Module.eval
+      Module.filter_and_map
+      Module.freeze
+      Module.leaf_modules
+      Module.load_weights
+      Module.modules
+      Module.named_modules
+      Module.parameters
+      Module.save_weights
+      Module.set_dtype
+      Module.train
+      Module.trainable_parameters
+      Module.unfreeze
+      Module.update
+      Module.update_modules
diff --git a/ml-stable-diffusion/mlx/docs/src/python/ops.rst b/ml-stable-diffusion/mlx/docs/src/python/ops.rst
new file mode 100644
index 0000000000000000000000000000000000000000..55fc1f5347b28ef2e36daf1212cb6b2f8107ac74
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/ops.rst
@@ -0,0 +1,183 @@
+.. _ops:
+
+Operations
+==========
+
+.. currentmodule:: mlx.core
+
+.. autosummary::
+  :toctree: _autosummary
+
+   abs
+   add
+   addmm
+   all
+   allclose
+   any
+   arange
+   arccos
+   arccosh
+   arcsin
+   arcsinh
+   arctan
+   arctan2
+   arctanh
+   argmax
+   argmin
+   argpartition
+   argsort
+   array_equal
+   as_strided
+   atleast_1d
+   atleast_2d
+   atleast_3d
+   bitwise_and
+   bitwise_invert
+   bitwise_or
+   bitwise_xor
+   block_masked_mm
+   broadcast_arrays
+   broadcast_to
+   ceil
+   clip
+   concatenate
+   contiguous
+   conj
+   conjugate
+   convolve
+   conv1d
+   conv2d
+   conv3d
+   conv_transpose1d
+   conv_transpose2d
+   conv_transpose3d
+   conv_general
+   cos
+   cosh
+   cummax
+   cummin
+   cumprod
+   cumsum
+   degrees
+   dequantize
+   diag
+   diagonal
+   divide
+   divmod
+   einsum
+   einsum_path
+   equal
+   erf
+   erfinv
+   exp
+   expm1
+   expand_dims
+   eye
+   flatten
+   floor
+   floor_divide
+   full
+   gather_mm
+   gather_qmm
+   greater
+   greater_equal
+   hadamard_transform
+   identity
+   imag
+   inner
+   isfinite
+   isclose
+   isinf
+   isnan
+   isneginf
+   isposinf
+   issubdtype
+   kron
+   left_shift
+   less
+   less_equal
+   linspace
+   load
+   log
+   log2
+   log10
+   log1p
+   logaddexp
+   logcumsumexp
+   logical_not
+   logical_and
+   logical_or
+   logsumexp
+   matmul
+   max
+   maximum
+   mean
+   meshgrid
+   min
+   minimum
+   moveaxis
+   multiply
+   nan_to_num
+   negative
+   not_equal
+   ones
+   ones_like
+   outer
+   partition
+   pad
+   power
+   prod
+   put_along_axis
+   quantize
+   quantized_matmul
+   radians
+   real
+   reciprocal
+   remainder
+   repeat
+   reshape
+   right_shift
+   roll
+   round
+   rsqrt
+   save
+   savez
+   savez_compressed
+   save_gguf
+   save_safetensors
+   sigmoid
+   sign
+   sin
+   sinh
+   slice
+   slice_update
+   softmax
+   sort
+   split
+   sqrt
+   square
+   squeeze
+   stack
+   std
+   stop_gradient
+   subtract
+   sum
+   swapaxes
+   take
+   take_along_axis
+   tan
+   tanh
+   tensordot
+   tile
+   topk
+   trace
+   transpose
+   tri
+   tril
+   triu
+   unflatten
+   var
+   view
+   where
+   zeros
+   zeros_like
diff --git a/ml-stable-diffusion/mlx/docs/src/python/optimizers.rst b/ml-stable-diffusion/mlx/docs/src/python/optimizers.rst
new file mode 100644
index 0000000000000000000000000000000000000000..3320225aed0f5e5df592806700cefee440b33cc7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/optimizers.rst
@@ -0,0 +1,78 @@
+.. _optimizers:
+
+.. currentmodule:: mlx.optimizers
+
+Optimizers
+==========
+
+The optimizers in MLX can be used both with :mod:`mlx.nn` but also with pure
+:mod:`mlx.core` functions. A typical example involves calling
+:meth:`Optimizer.update` to update a model's parameters based on the loss
+gradients and subsequently calling :func:`mlx.core.eval` to evaluate both the
+model's parameters and the **optimizer state**.
+
+.. code-block:: python
+
+    # Create a model
+    model = MLP(num_layers, train_images.shape[-1], hidden_dim, num_classes)
+    mx.eval(model.parameters())
+
+    # Create the gradient function and the optimizer
+    loss_and_grad_fn = nn.value_and_grad(model, loss_fn)
+    optimizer = optim.SGD(learning_rate=learning_rate)
+
+    for e in range(num_epochs):
+        for X, y in batch_iterate(batch_size, train_images, train_labels):
+            loss, grads = loss_and_grad_fn(model, X, y)
+
+            # Update the model with the gradients. So far no computation has happened.
+            optimizer.update(model, grads)
+
+            # Compute the new parameters but also the optimizer state.
+            mx.eval(model.parameters(), optimizer.state)
+
+Saving and Loading
+------------------
+
+To serialize an optimizer, save its state. To load an optimizer, load and set
+the saved state. Here's a simple example:
+
+.. code-block:: python
+
+   import mlx.core as mx
+   from mlx.utils import tree_flatten, tree_unflatten
+   import mlx.optimizers as optim
+
+   optimizer = optim.Adam(learning_rate=1e-2)
+
+   # Perform some updates with the optimizer
+   model = {"w" : mx.zeros((5, 5))}
+   grads = {"w" : mx.ones((5, 5))}
+   optimizer.update(model, grads)
+
+   # Save the state
+   state = tree_flatten(optimizer.state, destination={})
+   mx.save_safetensors("optimizer.safetensors", state)
+
+   # Later on, for example when loading from a checkpoint,
+   # recreate the optimizer and load the state
+   optimizer = optim.Adam(learning_rate=1e-2)
+
+   state = tree_unflatten(mx.load("optimizer.safetensors"))
+   optimizer.state = state
+
+Note, not every optimizer configuation parameter is saved in the state. For
+example, for Adam the learning rate is saved but the ``betas`` and ``eps``
+parameters are not. A good rule of thumb is if the parameter can be scheduled
+then it will be included in the optimizer state.
+
+.. toctree::
+
+   optimizers/optimizer
+   optimizers/common_optimizers
+   optimizers/schedulers
+
+.. autosummary::
+   :toctree: _autosummary
+
+   clip_grad_norm
diff --git a/ml-stable-diffusion/mlx/docs/src/python/optimizers/common_optimizers.rst b/ml-stable-diffusion/mlx/docs/src/python/optimizers/common_optimizers.rst
new file mode 100644
index 0000000000000000000000000000000000000000..4975df541b40d22084a85fe0e064c42b71800fb9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/optimizers/common_optimizers.rst
@@ -0,0 +1,22 @@
+.. _common_optimizers:
+
+Common Optimizers
+=================
+
+.. currentmodule:: mlx.optimizers
+
+.. autosummary::
+   :toctree: _autosummary
+   :template: optimizers-template.rst
+
+   SGD
+   RMSprop
+   Adagrad
+   Adafactor
+   AdaDelta
+   Adam
+   AdamW
+   Adamax
+   Lion
+   MultiOptimizer
+   Muon
diff --git a/ml-stable-diffusion/mlx/docs/src/python/optimizers/optimizer.rst b/ml-stable-diffusion/mlx/docs/src/python/optimizers/optimizer.rst
new file mode 100644
index 0000000000000000000000000000000000000000..cf6034dee64b0745e0a20229ab8a50d25d02f73f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/optimizers/optimizer.rst
@@ -0,0 +1,23 @@
+Optimizer
+=========
+
+.. currentmodule:: mlx.optimizers
+
+.. autoclass:: Optimizer 
+
+
+   .. rubric:: Attributes
+
+   .. autosummary::
+      :toctree: _autosummary
+
+      Optimizer.state
+   
+   .. rubric:: Methods
+
+   .. autosummary::
+      :toctree: _autosummary
+   
+      Optimizer.apply_gradients
+      Optimizer.init
+      Optimizer.update
diff --git a/ml-stable-diffusion/mlx/docs/src/python/optimizers/schedulers.rst b/ml-stable-diffusion/mlx/docs/src/python/optimizers/schedulers.rst
new file mode 100644
index 0000000000000000000000000000000000000000..50855e1e73c40f8cadb6c214c8bc37efa243734d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/optimizers/schedulers.rst
@@ -0,0 +1,15 @@
+.. _schedulers:
+
+Schedulers
+==========
+
+.. currentmodule:: mlx.optimizers
+
+.. autosummary::
+   :toctree: _autosummary
+
+   cosine_decay    
+   exponential_decay    
+   join_schedules
+   linear_schedule
+   step_decay    
diff --git a/ml-stable-diffusion/mlx/docs/src/python/random.rst b/ml-stable-diffusion/mlx/docs/src/python/random.rst
new file mode 100644
index 0000000000000000000000000000000000000000..2489591080394994228efa8da48b1d57fff76f00
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/random.rst
@@ -0,0 +1,48 @@
+.. _random:
+
+Random
+======
+
+Random sampling functions in MLX use an implicit global PRNG state by default.
+However, all function take an optional ``key`` keyword argument for when more
+fine-grained control or explicit state management is needed.
+
+For example, you can generate random numbers with:
+
+.. code-block:: python
+
+  for _ in range(3):
+    print(mx.random.uniform())
+
+which will print a sequence of unique pseudo random numbers. Alternatively you
+can explicitly set the key:
+
+.. code-block:: python
+
+  key = mx.random.key(0)
+  for _ in range(3):
+    print(mx.random.uniform(key=key))
+
+which will yield the same pseudo random number at each iteration.
+
+Following `JAX's PRNG design <https://jax.readthedocs.io/en/latest/jep/263-prng.html>`_
+we use a splittable version of Threefry, which is a counter-based PRNG.
+
+.. currentmodule:: mlx.core.random
+
+.. autosummary:: 
+  :toctree: _autosummary
+
+   bernoulli
+   categorical
+   gumbel
+   key
+   normal
+   multivariate_normal
+   randint
+   seed
+   split
+   truncated_normal
+   uniform
+   laplace
+   permutation
diff --git a/ml-stable-diffusion/mlx/docs/src/python/transforms.rst b/ml-stable-diffusion/mlx/docs/src/python/transforms.rst
new file mode 100644
index 0000000000000000000000000000000000000000..23f86720b5082b964ddae49eb01ef5ff45e5aa0a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/transforms.rst
@@ -0,0 +1,21 @@
+.. _transforms:
+
+Transforms
+==========
+
+.. currentmodule:: mlx.core
+
+.. autosummary::
+  :toctree: _autosummary
+
+   eval
+   async_eval
+   compile
+   custom_function
+   disable_compile
+   enable_compile
+   grad
+   value_and_grad
+   jvp
+   vjp
+   vmap
diff --git a/ml-stable-diffusion/mlx/docs/src/python/tree_utils.rst b/ml-stable-diffusion/mlx/docs/src/python/tree_utils.rst
new file mode 100644
index 0000000000000000000000000000000000000000..6dc60b47d0600f2c1d1526689be5814090b704d9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/python/tree_utils.rst
@@ -0,0 +1,23 @@
+.. _utils:
+
+Tree Utils
+==========
+
+In MLX we consider a python tree to be an arbitrarily nested collection of
+dictionaries, lists and tuples without cycles. Functions in this module that
+return python trees will be using the default python ``dict``, ``list`` and
+``tuple`` but they can usually process objects that inherit from any of these.
+
+.. note::
+   Dictionaries should have keys that are valid python identifiers.
+
+.. currentmodule:: mlx.utils
+
+.. autosummary:: 
+  :toctree: _autosummary
+
+   tree_flatten
+   tree_unflatten
+   tree_map
+   tree_map_with_path
+   tree_reduce
diff --git a/ml-stable-diffusion/mlx/docs/src/usage/compile.rst b/ml-stable-diffusion/mlx/docs/src/usage/compile.rst
new file mode 100644
index 0000000000000000000000000000000000000000..b073bbc4c9f3971980fc4ad29f07b8e0a2fd660f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/usage/compile.rst
@@ -0,0 +1,497 @@
+.. _compile:
+
+Compilation
+===========
+
+.. currentmodule:: mlx.core
+
+MLX has a :func:`compile` function transformation which compiles computation
+graphs. Function compilation results in smaller graphs by merging common work
+and fusing certain operations. In many cases this can lead to big improvements
+in run-time and memory use.
+
+Getting started with :func:`compile` is simple, but there are some edge cases
+that are good to be aware of for more complex graphs and advanced usage.
+
+Basics of Compile
+-----------------
+
+Let's start with a simple example:
+
+.. code-block:: python
+
+  def fun(x, y):
+      return mx.exp(-x) + y
+
+  x = mx.array(1.0)
+  y = mx.array(2.0)
+
+  # Regular call, no compilation
+  # Prints: array(2.36788, dtype=float32)
+  print(fun(x, y))
+
+  # Compile the function
+  compiled_fun = mx.compile(fun)
+
+  # Prints: array(2.36788, dtype=float32)
+  print(compiled_fun(x, y))
+
+The output of both the regular function and the compiled function is the same
+up to numerical precision.
+
+The first time you call a compiled function, MLX will build the compute
+graph, optimize it, and generate and compile code. This can be relatively
+slow. However, MLX will cache compiled functions, so calling a compiled
+function multiple times will not initiate a new compilation. This means you
+should typically compile functions that you plan to use more than once.
+
+.. code-block:: python
+
+  def fun(x, y):
+      return mx.exp(-x) + y
+
+  x = mx.array(1.0)
+  y = mx.array(2.0)
+
+  compiled_fun = mx.compile(fun)
+
+  # Compiled here
+  compiled_fun(x, y)
+
+  # Not compiled again
+  compiled_fun(x, y)
+
+  # Not compiled again
+  mx.compile(fun)(x, y)
+
+There are some important cases to be aware of that can cause a function to
+be recompiled:
+
+* Changing the shape or number of dimensions
+* Changing the type of any of the inputs
+* Changing the number of inputs to the function
+
+In certain cases only some of the compilation stack will be rerun (for
+example when changing the shapes) and in other cases the full compilation
+stack will be rerun (for example when changing the types). In general you
+should avoid compiling functions too frequently.
+
+Another idiom to watch out for is compiling functions which get created and
+destroyed frequently. This can happen, for example, when compiling an anonymous
+function in a loop:
+
+.. code-block:: python
+
+  a = mx.array(1.0)
+  # Don't do this, compiles lambda at each iteration
+  for _ in range(5):
+      mx.compile(lambda x: mx.exp(mx.abs(x)))(a)
+
+Example Speedup
+---------------
+
+The :func:`mlx.nn.gelu` is a nonlinear activation function commonly used with
+Transformer-based models. The implementation involves several unary and binary
+element-wise operations:
+
+.. code-block:: python
+
+  def gelu(x):
+      return x * (1 + mx.erf(x / math.sqrt(2))) / 2
+
+If you use this function with small arrays, it will be overhead bound. If you
+use it with large arrays it will be memory bandwidth bound.  However, all of
+the operations in the ``gelu`` are fusible into a single kernel with
+:func:`compile`. This can speedup both cases considerably.
+
+Let's compare the runtime of the regular function versus the compiled
+function. We'll use the following timing helper which does a warm up and
+handles synchronization:
+
+.. code-block:: python
+
+  import time
+
+  def timeit(fun, x):
+      # warm up
+      for _ in range(10):
+          mx.eval(fun(x))
+
+      tic = time.perf_counter()
+      for _ in range(100):
+          mx.eval(fun(x))
+      toc = time.perf_counter()
+      tpi = 1e3 * (toc - tic) / 100
+      print(f"Time per iteration {tpi:.3f} (ms)")
+
+
+Now make an array, and benchmark both functions:
+
+.. code-block:: python
+
+  x = mx.random.uniform(shape=(32, 1000, 4096))
+  timeit(gelu, x)
+  timeit(mx.compile(gelu), x)
+
+On an M1 Max the times are 15.5 and 3.1 milliseconds. The compiled ``gelu`` is
+five times faster.
+
+Debugging
+---------
+
+When a compiled function is first called, it is traced with placeholder
+inputs. This means you can't evaluate arrays (for example to print their
+contents) inside compiled functions.
+
+.. code-block:: python
+
+  @mx.compile
+  def fun(x):
+      z = -x
+      print(z)  # Crash
+      return mx.exp(z)
+
+  fun(mx.array(5.0))
+
+For debugging, inspecting arrays can be helpful. One way to do that is to
+globally disable compilation using the :func:`disable_compile` function or
+``MLX_DISABLE_COMPILE`` flag. For example the following is okay even though
+``fun`` is compiled:
+
+.. code-block:: python
+
+  @mx.compile
+  def fun(x):
+      z = -x
+      print(z) # Okay
+      return mx.exp(z)
+
+  mx.disable_compile()
+  fun(mx.array(5.0))
+
+
+Pure Functions
+--------------
+
+Compiled functions are intended to be *pure*; that is they should not have side
+effects. For example:
+
+.. code-block:: python
+
+  state = []
+
+  @mx.compile
+  def fun(x, y):
+      z = x + y
+      state.append(z)
+      return mx.exp(z)
+
+  fun(mx.array(1.0), mx.array(2.0))
+  # Crash!
+  print(state)
+
+After the first call of ``fun``, the ``state`` list will hold a placeholder
+array. The placeholder does not have any data; it is only used to build the
+computation graph. Printing such an array results in a crash.
+
+You have two options to deal with this. The first option is to simply return
+``state`` as an output:
+
+.. code-block:: python
+
+   state = []
+
+   @mx.compile
+   def fun(x, y):
+      z = x + y
+      state.append(z)
+      return mx.exp(z), state
+
+    _, state = fun(mx.array(1.0), mx.array(2.0))
+    # Prints [array(3, dtype=float32)]
+    print(state)
+
+In some cases returning updated state can be pretty inconvenient. Hence,
+:func:`compile` has a parameter to capture implicit outputs:
+
+.. code-block:: python
+
+  from functools import partial
+
+  state = []
+
+  # Tell compile to capture state as an output
+  @partial(mx.compile, outputs=state)
+  def fun(x, y):
+      z = x + y
+      state.append(z)
+      return mx.exp(z)
+
+  fun(mx.array(1.0), mx.array(2.0))
+  # Prints [array(3, dtype=float32)]
+  print(state)
+
+This is particularly useful for compiling a function which includes an update
+to a container of arrays, as is commonly done when training the parameters of a
+:class:`mlx.nn.Module`.
+
+Compiled functions will also treat any inputs not in the parameter list as
+constants. For example:
+
+.. code-block:: python
+
+  state = [mx.array(1.0)]
+
+  @mx.compile
+  def fun(x):
+      return x + state[0]
+
+  # Prints array(2, dtype=float32)
+  print(fun(mx.array(1.0)))
+
+  # Update state
+  state[0] = mx.array(5.0)
+
+  # Still prints array(2, dtype=float32)
+  print(fun(mx.array(1.0)))
+
+In order to have the change of state reflected in the outputs of ``fun`` you
+again have two options. The first option is to simply pass ``state`` as input
+to the function. In some cases this can be pretty inconvenient. Hence,
+:func:`compile` also has a parameter to capture implicit inputs:
+
+.. code-block:: python
+
+  from functools import partial
+  state = [mx.array(1.0)]
+
+  # Tell compile to capture state as an input
+  @partial(mx.compile, inputs=state)
+  def fun(x):
+      return x + state[0]
+
+  # Prints array(2, dtype=float32)
+  print(fun(mx.array(1.0)))
+
+  # Update state
+  state[0] = mx.array(5.0)
+
+  # Prints array(6, dtype=float32)
+  print(fun(mx.array(1.0)))
+
+
+Compiling Training Graphs
+-------------------------
+
+This section will step through how to use :func:`compile` with a simple example
+of a common setup: training a model with :obj:`mlx.nn.Module` using an
+:obj:`mlx.optimizers.Optimizer` with state. We will show how to compile the
+full forward, backward, and update with :func:`compile`.
+
+To start, here is the simple example without any compilation:
+
+.. code-block:: python
+
+  import mlx.core as mx
+  import mlx.nn as nn
+  import mlx.optimizers as optim
+
+  # 4 examples with 10 features each
+  x = mx.random.uniform(shape=(4, 10))
+
+  # 0, 1 targets
+  y = mx.array([0, 1, 0, 1])
+
+  # Simple linear model
+  model = nn.Linear(10, 1)
+
+  # SGD with momentum
+  optimizer = optim.SGD(learning_rate=0.1, momentum=0.8)
+
+  def loss_fn(model, x, y):
+      logits = model(x).squeeze()
+      return nn.losses.binary_cross_entropy(logits, y)
+
+  loss_and_grad_fn = nn.value_and_grad(model, loss_fn)
+
+  # Perform 10 steps of gradient descent
+  for it in range(10):
+      loss, grads = loss_and_grad_fn(model, x, y)
+      optimizer.update(model, grads)
+      mx.eval(model.parameters(), optimizer.state)
+
+To compile the update we can put it all in a function and compile it with the
+appropriate input and output captures. Here's the same example but compiled:
+
+.. code-block:: python
+
+  import mlx.core as mx
+  import mlx.nn as nn
+  import mlx.optimizers as optim
+  from functools import partial
+
+  # 4 examples with 10 features each
+  x = mx.random.uniform(shape=(4, 10))
+
+  # 0, 1 targets
+  y = mx.array([0, 1, 0, 1])
+
+  # Simple linear model
+  model = nn.Linear(10, 1)
+
+  # SGD with momentum
+  optimizer = optim.SGD(learning_rate=0.1, momentum=0.8)
+
+  def loss_fn(model, x, y):
+      logits = model(x).squeeze()
+      return nn.losses.binary_cross_entropy(logits, y)
+
+  # The state that will be captured as input and output
+  state = [model.state, optimizer.state]
+
+  @partial(mx.compile, inputs=state, outputs=state)
+  def step(x, y):
+      loss_and_grad_fn = nn.value_and_grad(model, loss_fn)
+      loss, grads = loss_and_grad_fn(model, x, y)
+      optimizer.update(model, grads)
+      return loss
+
+  # Perform 10 steps of gradient descent
+  for it in range(10):
+      loss = step(x, y)
+      # Evaluate the model and optimizer state
+      mx.eval(state)
+      print(loss)
+
+
+.. note::
+
+  If you are using a module which performs random sampling such as
+  :func:`mlx.nn.Dropout`, make sure you also include ``mx.random.state`` in the
+  ``state`` captured by :func:`compile`, i.e. ``state = [model.state,
+  optimizer.state, mx.random.state]``.
+
+
+.. note::
+
+   For more examples of compiling full training graphs checkout the  `MLX
+   Examples <https://github.com/ml-explore/mlx-examples>`_ GitHub repo.
+
+Transformations with Compile
+----------------------------
+
+In MLX function transformations are composable. You can apply any function
+transformation to the output of any other function transformation. For more on
+this, see the documentation on :ref:`function transforms
+<function_transforms>`.
+
+Compiling transformed functions works just as expected:
+
+.. code-block:: python
+
+  grad_fn = mx.grad(mx.exp)
+
+  compiled_grad_fn = mx.compile(grad_fn)
+
+  # Prints: array(2.71828, dtype=float32)
+  print(grad_fn(mx.array(1.0)))
+
+  # Also prints: array(2.71828, dtype=float32)
+  print(compiled_grad_fn(mx.array(1.0)))
+
+.. note::
+
+   In order to compile as much as possible, a transformation of a compiled
+   function will not by default be compiled. To compile the transformed
+   function simply pass it through :func:`compile`.
+
+You can also compile functions which themselves call compiled functions. A
+good practice is to compile the outer most function to give :func:`compile`
+the most opportunity to optimize the computation graph:
+
+.. code-block:: python
+
+  @mx.compile
+  def inner(x):
+      return mx.exp(-mx.abs(x))
+
+  def outer(x):
+      inner(inner(x))
+
+  # Compiling the outer function is good to do as it will likely
+  # be faster even though the inner functions are compiled
+  fun = mx.compile(outer)
+
+
+
+.. _shapeless_compile:
+
+Shapeless Compilation
+---------------------
+
+When the shape of an input to a compiled function changes, the function is
+recompiled. You can compile a function once and run it on inputs with
+variable shapes by specifying ``shapeless=True`` to :func:`compile`. In this
+case changes to the shapes of the inputs do not cause the function to be
+recompiled.
+
+.. code-block:: python
+
+  def fun(x, y):
+      return mx.abs(x + y)
+
+  compiled_fun = mx.compile(fun, shapeless=True)
+
+  x = mx.array(1.0)
+  y = mx.array(-2.0)
+
+  # Firt call compiles the function
+  print(compiled_fun(x, y))
+
+  # Second call with different shapes
+  # does not recompile the function
+  x = mx.array([1.0, -6.0])
+  y = mx.array([-2.0, 3.0])
+  print(compiled_fun(x, y))
+
+
+Use shapeless compilations carefully. Since compilation is not triggered when
+shapes change, any graphs which are conditional on the input shapes will not
+work as expected. Shape-dependent computations are common and sometimes subtle
+to detect. For example:
+
+.. code-block:: python
+
+  def fun(x):
+      return x.reshape(x.shape[0] * x.shape[1], -1)
+
+  compiled_fun = mx.compile(fun, shapeless=True)
+
+  x = mx.random.uniform(shape=(2, 3, 4))
+
+  out = compiled_fun(x)
+
+  x = mx.random.uniform(shape=(5, 5, 3))
+
+  # Error, can't reshape (5, 5, 3) to (6, -1)
+  out = compiled_fun(x)
+
+The second call to the ``compiled_fun`` fails because of the call to
+:func:`reshape` which uses the static shape of ``x`` in the first call. We can
+fix this by using :func:`flatten` to avoid hardcoding the shape of ``x``:
+
+.. code-block:: python
+
+  def fun(x):
+      return x.flatten(0, 1)
+
+  compiled_fun = mx.compile(fun, shapeless=True)
+
+  x = mx.random.uniform(shape=(2, 3, 4))
+
+  out = compiled_fun(x)
+
+  x = mx.random.uniform(shape=(5, 5, 3))
+
+  # Ok
+  out = compiled_fun(x)
diff --git a/ml-stable-diffusion/mlx/docs/src/usage/distributed.rst b/ml-stable-diffusion/mlx/docs/src/usage/distributed.rst
new file mode 100644
index 0000000000000000000000000000000000000000..f1a1e4e9493cfe48b40538c21901f7ca2fb8baee
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/usage/distributed.rst
@@ -0,0 +1,344 @@
+.. _usage_distributed:
+
+Distributed Communication
+=========================
+
+.. currentmodule:: mlx.core.distributed
+
+MLX supports distributed communication operations that allow the computational cost
+of training or inference to be shared across many physical machines. At the
+moment we support two different communication backends:
+
+* `MPI <https://en.wikipedia.org/wiki/Message_Passing_Interface>`_ a
+  full-featured and mature distributed communications library
+* A **ring** backend of our own that uses native TCP sockets and should be
+  faster for thunderbolt connections.
+
+The list of all currently supported operations and their documentation can be
+seen in the :ref:`API docs<distributed>`.
+
+.. note::
+   Some operations may not be supported or not as fast as they should be.
+   We are adding more and tuning the ones we have as we are figuring out the
+   best way to do distributed computing on Macs using MLX.
+
+Getting Started
+---------------
+
+A distributed program in MLX is as simple as:
+
+.. code:: python
+
+    import mlx.core as mx
+
+    world = mx.distributed.init()
+    x = mx.distributed.all_sum(mx.ones(10))
+    print(world.rank(), x)
+
+The program above sums the array ``mx.ones(10)`` across all
+distributed processes. However, when this script is run with ``python`` only
+one process is launched and no distributed communication takes place. Namely,
+all operations in ``mx.distributed`` are noops when the distributed group has a
+size of one. This property allows us to avoid code that checks if we are in a
+distributed setting similar to the one below:
+
+.. code:: python
+
+    import mlx.core as mx
+
+    x = ...
+    world = mx.distributed.init()
+    # No need for the check we can simply do x = mx.distributed.all_sum(x)
+    if world.size() > 1:
+        x = mx.distributed.all_sum(x)
+
+Running Distributed Programs
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+MLX provides ``mlx.launch`` a helper script to launch distributed programs.
+Continuing with our initial example we can run it on localhost with 4 processes using
+
+.. code:: shell
+
+    $ mlx.launch -n 4 my_script.py
+    3 array([4, 4, 4, ..., 4, 4, 4], dtype=float32)
+    2 array([4, 4, 4, ..., 4, 4, 4], dtype=float32)
+    1 array([4, 4, 4, ..., 4, 4, 4], dtype=float32)
+    0 array([4, 4, 4, ..., 4, 4, 4], dtype=float32)
+
+We can also run it on some remote hosts by providing their IPs (provided that
+the script exists on all hosts and they are reachable by ssh)
+
+.. code:: shell
+
+    $ mlx.launch --hosts ip1,ip2,ip3,ip4 my_script.py
+    3 array([4, 4, 4, ..., 4, 4, 4], dtype=float32)
+    2 array([4, 4, 4, ..., 4, 4, 4], dtype=float32)
+    1 array([4, 4, 4, ..., 4, 4, 4], dtype=float32)
+    0 array([4, 4, 4, ..., 4, 4, 4], dtype=float32)
+
+Consult the dedicated :doc:`usage guide<launching_distributed>` for more
+information on using ``mlx.launch``.
+
+Selecting Backend
+^^^^^^^^^^^^^^^^^
+
+You can select the backend you want to use when calling :func:`init` by passing
+one of ``{'any', 'ring', 'mpi'}``. When passing ``any``, MLX will try to
+initialize the ``ring`` backend and if it fails the ``mpi`` backend. If they
+both fail then a singleton group is created.
+
+.. note::
+   After a distributed backend is successfully initialized :func:`init` will
+   return **the same backend** if called without arguments or with backend set to
+   ``any``.
+
+The following examples aim to clarify the backend initialization logic in MLX:
+
+.. code:: python
+
+    # Case 1: Initialize MPI regardless if it was possible to initialize the ring backend
+    world = mx.distributed.init(backend="mpi")
+    world2 = mx.distributed.init()  # subsequent calls return the MPI backend!
+
+    # Case 2: Initialize any backend
+    world = mx.distributed.init(backend="any")  # equivalent to no arguments
+    world2 = mx.distributed.init()  # same as above
+
+    # Case 3: Initialize both backends at the same time
+    world_mpi = mx.distributed.init(backend="mpi")
+    world_ring = mx.distributed.init(backend="ring")
+    world_any = mx.distributed.init()  # same as MPI because it was initialized first!
+
+Training Example
+----------------
+
+In this section we will adapt an MLX training loop to support data parallel
+distributed training. Namely, we will average the gradients across a set of
+hosts before applying them to the model.
+
+Our training loop looks like the following code snippet if we omit the model,
+dataset and optimizer initialization.
+
+.. code:: python
+
+    model = ...
+    optimizer = ...
+    dataset = ...
+
+    def step(model, x, y):
+        loss, grads = loss_grad_fn(model, x, y)
+        optimizer.update(model, grads)
+        return loss
+
+    for x, y in dataset:
+        loss = step(model, x, y)
+        mx.eval(loss, model.parameters())
+
+All we have to do to average the gradients across machines is perform an
+:func:`all_sum` and divide by the size of the :class:`Group`. Namely we
+have to :func:`mlx.utils.tree_map` the gradients with following function.
+
+.. code:: python
+
+    def all_avg(x):
+        return mx.distributed.all_sum(x) / mx.distributed.init().size()
+
+Putting everything together our training loop step looks as follows with
+everything else remaining the same.
+
+.. code:: python
+
+    from mlx.utils import tree_map
+
+    def all_reduce_grads(grads):
+        N = mx.distributed.init().size()
+        if N == 1:
+            return grads
+        return tree_map(
+            lambda x: mx.distributed.all_sum(x) / N,
+            grads
+        )
+
+    def step(model, x, y):
+        loss, grads = loss_grad_fn(model, x, y)
+        grads = all_reduce_grads(grads)  # <--- This line was added
+        optimizer.update(model, grads)
+        return loss
+
+Utilizing ``nn.average_gradients``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Although the code example above works correctly; it performs one communication
+per gradient. It is significantly more efficient to aggregate several gradients
+together and perform fewer communication steps.
+
+This is the purpose of :func:`mlx.nn.average_gradients`. The final code looks
+almost identical to the example above:
+
+.. code:: python
+
+    model = ...
+    optimizer = ...
+    dataset = ...
+
+    def step(model, x, y):
+        loss, grads = loss_grad_fn(model, x, y)
+        grads = mx.nn.average_gradients(grads)  # <---- This line was added
+        optimizer.update(model, grads)
+        return loss
+
+    for x, y in dataset:
+        loss = step(model, x, y)
+        mx.eval(loss, model.parameters())
+
+
+Getting Started with MPI
+------------------------
+
+MLX already comes with the ability to "talk" to MPI if it is installed on the
+machine. Launching distributed MLX programs that use MPI can be done with
+``mpirun`` as expected. However, in the following examples we will be using
+``mlx.launch --backend mpi`` which takes care of some nuisances such as setting
+absolute paths for the ``mpirun`` executable and the ``libmpi.dyld`` shared
+library.
+
+The simplest possible usage is the following which, assuming the minimal
+example in the beginning of this page, should result in:
+
+.. code:: shell
+
+    $ mlx.launch --backend mpi -n 2 test.py
+    1 array([2, 2, 2, ..., 2, 2, 2], dtype=float32)
+    0 array([2, 2, 2, ..., 2, 2, 2], dtype=float32)
+
+The above launches two processes on the same (local) machine and we can see
+both standard output streams. The processes send the array of 1s to each other
+and compute the sum which is printed. Launching with ``mlx.launch -n 4 ...`` would
+print 4 etc.
+
+Installing MPI
+^^^^^^^^^^^^^^
+
+MPI can be installed with Homebrew, using the Anaconda package manager or
+compiled from source. Most of our testing is done using ``openmpi`` installed
+with the Anaconda package manager as follows:
+
+.. code:: shell
+
+    $ conda install conda-forge::openmpi
+
+Installing with Homebrew may require specifying the location of ``libmpi.dyld``
+so that MLX can find it and load it at runtime. This can simply be achieved by
+passing the ``DYLD_LIBRARY_PATH`` environment variable to ``mpirun`` and it is
+done automatically by ``mlx.launch``.
+
+.. code:: shell
+
+    $ mpirun -np 2 -x DYLD_LIBRARY_PATH=/opt/homebrew/lib/ python test.py
+    $ # or simply
+    $ mlx.launch -n 2 test.py
+
+Setting up Remote Hosts
+^^^^^^^^^^^^^^^^^^^^^^^
+
+MPI can automatically connect to remote hosts and set up the communication over
+the network if the remote hosts can be accessed via ssh. A good checklist to
+debug connectivity issues is the following:
+
+* ``ssh hostname`` works from all machines to all machines without asking for
+  password or host confirmation
+* ``mpirun`` is accessible on all machines.
+* Ensure that the ``hostname`` used by MPI is the one that you have configured
+  in the ``.ssh/config`` files on all machines.
+
+Tuning MPI All Reduce
+^^^^^^^^^^^^^^^^^^^^^
+
+.. note::
+
+    For faster all reduce consider using the ring backend either with Thunderbolt
+    connections or over Ethernet.
+
+Configure MPI to use N tcp connections between each host to improve bandwidth
+by passing ``--mca btl_tcp_links N``.
+
+Force MPI to use the most performant network interface by setting ``--mca
+btl_tcp_if_include <iface>`` where ``<iface>`` should be the interface you want
+to use.
+
+Getting Started with Ring
+-------------------------
+
+The ring backend does not depend on any third party library so it is always
+available. It uses TCP sockets so the nodes need to be reachable via a network.
+As the name suggests the nodes are connected in a ring which means that rank 1
+can only communicate with rank 0 and rank 2, rank 2 only with rank 1 and rank 3
+and so on and so forth. As a result :func:`send` and :func:`recv` with
+arbitrary sender and receiver is not supported in the ring backend.
+
+Defining a Ring
+^^^^^^^^^^^^^^^
+
+The easiest way to define and use a ring is via a JSON hostfile and the
+``mlx.launch`` :doc:`helper script <launching_distributed>`. For each node one
+defines a hostname to ssh into to run commands on this node and one or more IPs
+that this node will listen to for connections.
+
+For example the hostfile below defines a 4 node ring. ``hostname1`` will be
+rank 0, ``hostname2`` rank 1 etc.
+
+.. code:: json
+
+    [
+        {"ssh": "hostname1", "ips": ["123.123.123.1"]},
+        {"ssh": "hostname2", "ips": ["123.123.123.2"]},
+        {"ssh": "hostname3", "ips": ["123.123.123.3"]},
+        {"ssh": "hostname4", "ips": ["123.123.123.4"]}
+    ]
+
+Running ``mlx.launch --hostfile ring-4.json my_script.py`` will ssh into each
+node, run the script which will listen for connections in each of the provided
+IPs. Specifically, ``hostname1`` will connect to ``123.123.123.2`` and accept a
+connection from ``123.123.123.4`` and so on and so forth.
+
+Thunderbolt Ring
+^^^^^^^^^^^^^^^^
+
+Although the ring backend can have benefits over MPI even for Ethernet, its
+main purpose is to use Thunderbolt rings for higher bandwidth communication.
+Setting up such thunderbolt rings can be done manually, but is a relatively
+tedious process. To simplify this, we provide the utility ``mlx.distributed_config``.
+
+To use ``mlx.distributed_config`` your computers need to be accessible by ssh via
+Ethernet or Wi-Fi. Subsequently, connect them via thunderbolt cables and then call the
+utility as follows:
+
+.. code:: shell
+
+   mlx.distributed_config --verbose --hosts host1,host2,host3,host4
+
+By default the script will attempt to discover the thunderbolt ring and provide
+you with the commands to configure each node as well as the ``hostfile.json``
+to use with ``mlx.launch``. If password-less ``sudo`` is available on the nodes
+then ``--auto-setup`` can be used to configure them automatically.
+
+To validate your connection without configuring anything
+``mlx.distributed_config`` can also plot the ring using DOT format.
+
+.. code:: shell
+
+   mlx.distributed_config --verbose --hosts host1,host2,host3,host4 --dot >ring.dot
+   dot -Tpng ring.dot >ring.png
+   open ring.png
+
+If you want to go through the process manually, the steps are as follows:
+
+* Disable the thunderbolt bridge interface
+* For the cable connecting rank ``i`` to rank ``i + 1`` find the interfaces
+  corresponding to that cable in nodes ``i`` and ``i + 1``.
+* Set up a unique subnetwork connecting the two nodes for the corresponding
+  interfaces. For instance if the cable corresponds to ``en2`` on node ``i``
+  and ``en2`` also on node ``i + 1`` then we may assign IPs ``192.168.0.1`` and
+  ``192.168.0.2`` respectively to the two nodes. For more details you can see
+  the commands prepared by the utility script.
diff --git a/ml-stable-diffusion/mlx/docs/src/usage/export.rst b/ml-stable-diffusion/mlx/docs/src/usage/export.rst
new file mode 100644
index 0000000000000000000000000000000000000000..e908b85fcb240926ca03101cee2ca439d5426368
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/usage/export.rst
@@ -0,0 +1,288 @@
+.. _export_usage:
+
+Exporting Functions
+===================
+
+.. currentmodule:: mlx.core
+
+MLX has an API to export and import functions to and from a file. This lets you
+run computations written in one MLX front-end (e.g. Python) in another MLX
+front-end (e.g. C++).
+
+This guide walks through the basics of the MLX export API with some examples.
+To see the full list of functions check-out the :ref:`API documentation
+<export>`.
+
+Basics of Exporting
+-------------------
+
+Let's start with a simple example:
+
+.. code-block:: python
+
+  def fun(x, y):
+    return x + y
+
+  x = mx.array(1.0)
+  y = mx.array(1.0)
+  mx.export_function("add.mlxfn", fun, x, y)
+
+To export a function, provide sample input arrays that the function
+can be called with. The data doesn't matter, but the shapes and types of the
+arrays do. In the above example we exported ``fun`` with two ``float32``
+scalar arrays. We can then import the function and run it:
+
+.. code-block:: python
+
+  add_fun = mx.import_function("add.mlxfn")
+
+  out, = add_fun(mx.array(1.0), mx.array(2.0))
+  # Prints: array(3, dtype=float32)
+  print(out)
+
+  out, = add_fun(mx.array(1.0), mx.array(3.0))
+  # Prints: array(4, dtype=float32)
+  print(out)
+
+  # Raises an exception
+  add_fun(mx.array(1), mx.array(3.0))
+
+  # Raises an exception
+  add_fun(mx.array([1.0, 2.0]), mx.array(3.0))
+
+Notice the third and fourth calls to ``add_fun`` raise exceptions because the
+shapes and types of the inputs are different than the shapes and types of the
+example inputs we exported the function with.
+
+Also notice that even though the original ``fun`` returns a single output
+array, the imported function always returns a tuple of one or more arrays.
+
+The inputs to :func:`export_function` and to an imported function can be
+specified as variable positional arguments or as a tuple of arrays:
+
+.. code-block:: python
+
+  def fun(x, y):
+    return x + y
+
+  x = mx.array(1.0)
+  y = mx.array(1.0)
+
+  # Both arguments to fun are positional
+  mx.export_function("add.mlxfn", fun, x, y)
+
+  # Same as above
+  mx.export_function("add.mlxfn", fun, (x, y))
+
+  imported_fun = mx.import_function("add.mlxfn")
+
+  # Ok
+  out, = imported_fun(x, y)
+
+  # Also ok
+  out, = imported_fun((x, y))
+
+You can pass example inputs to functions as positional or keyword arguments. If
+you use keyword arguments to export the function, then you have to use the same
+keyword arguments when calling the imported function.
+
+.. code-block:: python
+
+  def fun(x, y):
+    return x + y
+
+  # One argument to fun is positional, the other is a kwarg
+  mx.export_function("add.mlxfn", fun, x, y=y)
+
+  imported_fun = mx.import_function("add.mlxfn")
+
+  # Ok
+  out, = imported_fun(x, y=y)
+
+  # Also ok
+  out, = imported_fun((x,), {"y": y})
+
+  # Raises since the keyword argument is missing
+  out, = imported_fun(x, y)
+
+  # Raises since the keyword argument has the wrong key
+  out, = imported_fun(x, z=y)
+
+
+Exporting Modules
+-----------------
+
+An :obj:`mlx.nn.Module` can be exported with or without the parameters included
+in the exported function. Here's an example:
+
+.. code-block:: python
+
+   model = nn.Linear(4, 4)
+   mx.eval(model.parameters())
+
+   def call(x):
+      return model(x)
+
+   mx.export_function("model.mlxfn", call, mx.zeros(4))
+
+In the above example, the :obj:`mlx.nn.Linear` module is exported. Its
+parameters are also saved to the ``model.mlxfn`` file.
+
+.. note::
+
+   For enclosed arrays inside an exported function, be extra careful to ensure
+   they are evaluated. The computation graph that gets exported will include
+   the computation that produces enclosed inputs.
+
+   If the above example was missing ``mx.eval(model.parameters()``, the
+   exported function would include the random initialization of the
+   :obj:`mlx.nn.Module` parameters.
+
+If you only want to export the ``Module.__call__`` function without the
+parameters, pass them as inputs to the ``call`` wrapper:
+
+.. code-block:: python
+
+   model = nn.Linear(4, 4)
+   mx.eval(model.parameters())
+
+   def call(x, **params):
+     # Set the model's parameters to the input parameters
+     model.update(tree_unflatten(list(params.items())))
+     return model(x)
+
+   params = tree_flatten(model.parameters(), destination={})
+   mx.export_function("model.mlxfn", call, (mx.zeros(4),), params)
+
+
+Shapeless Exports
+-----------------
+
+Just like :func:`compile`, functions can also be exported for dynamically shaped
+inputs. Pass ``shapeless=True`` to :func:`export_function` or :func:`exporter`
+to export a function which can be used for inputs with variable shapes:
+
+.. code-block:: python
+
+  mx.export_function("fun.mlxfn", mx.abs, mx.array([0.0]), shapeless=True)
+  imported_abs = mx.import_function("fun.mlxfn")
+
+  # Ok
+  out, = imported_abs(mx.array([-1.0]))
+
+  # Also ok
+  out, = imported_abs(mx.array([-1.0, -2.0]))
+
+With ``shapeless=False`` (which is the default), the second call to
+``imported_abs`` would raise an exception with a shape mismatch.
+
+Shapeless exporting works the same as shapeless compilation and should be
+used carefully. See the :ref:`documentation on shapeless compilation
+<shapeless_compile>` for more information.
+
+Exporting Multiple Traces
+-------------------------
+
+In some cases, functions build different computation graphs for different
+input arguments. A simple way to manage this is to export to a new file with
+each set of inputs. This is a fine option in many cases. But it can be
+suboptimal if the exported functions have a large amount of duplicate constant
+data (for example the parameters of a :obj:`mlx.nn.Module`).
+
+The export API in MLX lets you export multiple traces of the same function to
+a single file by creating an exporting context manager with :func:`exporter`:
+
+.. code-block:: python
+
+  def fun(x, y=None):
+      constant = mx.array(3.0)
+      if y is not None:
+        x += y
+      return x + constant
+
+  with mx.exporter("fun.mlxfn", fun) as exporter:
+      exporter(mx.array(1.0))
+      exporter(mx.array(1.0), y=mx.array(0.0))
+
+  imported_function = mx.import_function("fun.mlxfn")
+
+  # Call the function with y=None
+  out, = imported_function(mx.array(1.0))
+  print(out)
+
+  # Call the function with y specified
+  out, = imported_function(mx.array(1.0), y=mx.array(1.0))
+  print(out)
+
+In the above example the function constant data, (i.e. ``constant``), is only
+saved once.
+
+Transformations with Imported Functions
+---------------------------------------
+
+Function transformations like :func:`grad`, :func:`vmap`, and :func:`compile` work
+on imported functions just like regular Python functions:
+
+.. code-block:: python
+
+  def fun(x):
+      return mx.sin(x)
+
+  x = mx.array(0.0)
+  mx.export_function("sine.mlxfn", fun, x)
+
+  imported_fun = mx.import_function("sine.mlxfn")
+
+  # Take the derivative of the imported function
+  dfdx = mx.grad(lambda x: imported_fun(x)[0])
+  # Prints: array(1, dtype=float32)
+  print(dfdx(x))
+
+  # Compile the imported function
+  mx.compile(imported_fun)
+  # Prints: array(0, dtype=float32)
+  print(compiled_fun(x)[0])
+
+
+Importing Functions in C++
+--------------------------
+
+Importing and running functions in C++ is basically the same as importing and
+running them in Python. First, follow the :ref:`instructions <mlx_in_cpp>` to
+setup a simple C++ project that uses MLX as a library.
+
+Next, export a simple function from Python:
+
+.. code-block:: python
+
+  def fun(x, y):
+      return mx.exp(x + y)
+
+  x = mx.array(1.0)
+  y = mx.array(1.0)
+  mx.export_function("fun.mlxfn", fun, x, y)
+
+
+Import and run the function in C++ with only a few lines of code:
+
+.. code-block:: c++
+
+  auto fun = mx::import_function("fun.mlxfn");
+
+  auto inputs = {mx::array(1.0), mx::array(1.0)};
+  auto outputs = fun(inputs);
+
+  // Prints: array(2, dtype=float32)
+  std::cout << outputs[0] << std::endl;
+
+Imported functions can be transformed in C++ just like in Python. Use
+``std::vector<mx::array>`` for positional arguments and ``std::map<std::string,
+mx::array>`` for keyword arguments when calling imported functions in C++.
+
+More Examples
+-------------
+
+Here are a few more complete examples exporting more complex functions from
+Python and importing and running them in C++:
+
+* `Inference and training a multi-layer perceptron <https://github.com/ml-explore/mlx/tree/main/examples/export>`_
diff --git a/ml-stable-diffusion/mlx/docs/src/usage/function_transforms.rst b/ml-stable-diffusion/mlx/docs/src/usage/function_transforms.rst
new file mode 100644
index 0000000000000000000000000000000000000000..045c36c93331926832237c83b57c8008e08f9bc0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/usage/function_transforms.rst
@@ -0,0 +1,191 @@
+.. _function_transforms:
+
+Function Transforms
+===================
+
+.. currentmodule:: mlx.core
+
+MLX uses composable function transformations for automatic differentiation,
+vectorization, and compute graph optimizations. To see the complete list of
+function transformations check-out the :ref:`API documentation <transforms>`.
+
+The key idea behind composable function transformations is that every
+transformation returns a function which can be further transformed.
+
+Here is a simple example:
+
+.. code-block:: shell
+
+   >>> dfdx = mx.grad(mx.sin)
+   >>> dfdx(mx.array(mx.pi))
+   array(-1, dtype=float32)
+   >>> mx.cos(mx.array(mx.pi))
+   array(-1, dtype=float32)
+
+
+The output of :func:`grad` on :func:`sin` is simply another function. In this
+case it is the gradient of the sine function which is exactly the cosine
+function. To get the second derivative you can do:
+
+.. code-block:: shell
+
+   >>> d2fdx2 = mx.grad(mx.grad(mx.sin))
+   >>> d2fdx2(mx.array(mx.pi / 2))
+   array(-1, dtype=float32)
+   >>> mx.sin(mx.array(mx.pi / 2))
+   array(1, dtype=float32)
+
+Using :func:`grad` on the output of :func:`grad` is always ok. You keep
+getting higher order derivatives.
+
+Any of the MLX function transformations can be composed in any order to any
+depth. See the following sections for more information on :ref:`automatic
+differentiation <auto diff>` and :ref:`automatic vectorization <vmap>`.
+For more information on :func:`compile` see the :ref:`compile documentation <compile>`.
+
+
+Automatic Differentiation
+-------------------------
+
+.. _auto diff:
+
+Automatic differentiation in MLX works on functions rather than on implicit
+graphs.
+
+.. note::
+
+   If you are coming to MLX from PyTorch, you no longer need functions like
+   ``backward``, ``zero_grad``, and ``detach``, or properties like
+   ``requires_grad``.
+
+The most basic example is taking the gradient of a scalar-valued function as we
+saw above. You can use the :func:`grad` and :func:`value_and_grad` function to
+compute gradients of more complex functions. By default these functions compute
+the gradient with respect to the first argument:
+
+.. code-block:: python
+
+   def loss_fn(w, x, y):
+      return mx.mean(mx.square(w * x - y))
+
+   w = mx.array(1.0)
+   x = mx.array([0.5, -0.5])
+   y = mx.array([1.5, -1.5])
+
+   # Computes the gradient of loss_fn with respect to w:
+   grad_fn = mx.grad(loss_fn)
+   dloss_dw = grad_fn(w, x, y)
+   # Prints array(-1, dtype=float32)
+   print(dloss_dw)
+
+   # To get the gradient with respect to x we can do:
+   grad_fn = mx.grad(loss_fn, argnums=1)
+   dloss_dx = grad_fn(w, x, y)
+   # Prints array([-1, 1], dtype=float32)
+   print(dloss_dx)
+
+
+One way to get the loss and gradient is to call ``loss_fn`` followed by
+``grad_fn``, but this can result in a lot of redundant work. Instead, you
+should use :func:`value_and_grad`. Continuing the above example:
+
+
+.. code-block:: python
+
+   # Computes the gradient of loss_fn with respect to w:
+   loss_and_grad_fn = mx.value_and_grad(loss_fn)
+   loss, dloss_dw = loss_and_grad_fn(w, x, y)
+
+   # Prints array(1, dtype=float32)
+   print(loss)
+
+   # Prints array(-1, dtype=float32)
+   print(dloss_dw)
+
+
+You can also take the gradient with respect to arbitrarily nested Python
+containers of arrays (specifically any of :obj:`list`, :obj:`tuple`, or
+:obj:`dict`).
+
+Suppose we wanted a weight and a bias parameter in the above example. A nice
+way to do that is the following:
+
+.. code-block:: python
+
+   def loss_fn(params, x, y):
+      w, b = params["weight"], params["bias"]
+      h = w * x + b
+      return mx.mean(mx.square(h - y))
+
+   params = {"weight": mx.array(1.0), "bias": mx.array(0.0)}
+   x = mx.array([0.5, -0.5])
+   y = mx.array([1.5, -1.5])
+
+   # Computes the gradient of loss_fn with respect to both the
+   # weight and bias:
+   grad_fn = mx.grad(loss_fn)
+   grads = grad_fn(params, x, y)
+
+   # Prints
+   # {'weight': array(-1, dtype=float32), 'bias': array(0, dtype=float32)}
+   print(grads)
+
+Notice the tree structure of the parameters is preserved in the gradients.
+
+In some cases you may want to stop gradients from propagating through a
+part of the function. You can use the :func:`stop_gradient` for that.
+
+
+Automatic Vectorization
+-----------------------
+
+.. _vmap:
+
+Use :func:`vmap` to automate vectorizing complex functions. Here we'll go
+through a basic and contrived example for the sake of clarity, but :func:`vmap`
+can be quite powerful for more complex functions which are difficult to optimize
+by hand.
+
+.. warning::
+
+   Some operations are not yet supported with :func:`vmap`. If you encounter an error
+   like: ``ValueError: Primitive's vmap not implemented.`` file an `issue
+   <https://github.com/ml-explore/mlx/issues>`_ and include your function.
+   We will prioritize including it.
+
+A naive way to add the elements from two sets of vectors is with a loop:
+
+.. code-block:: python
+
+  xs = mx.random.uniform(shape=(4096, 100))
+  ys = mx.random.uniform(shape=(100, 4096))
+
+  def naive_add(xs, ys):
+      return [xs[i] + ys[:, i] for i in range(xs.shape[0])]
+
+Instead you can use :func:`vmap` to automatically vectorize the addition:
+
+.. code-block:: python
+
+   # Vectorize over the second dimension of x and the
+   # first dimension of y
+   vmap_add = mx.vmap(lambda x, y: x + y, in_axes=(0, 1))
+
+The ``in_axes`` parameter can be used to specify which dimensions of the
+corresponding input to vectorize over. Similarly, use ``out_axes`` to specify
+where the vectorized axes should be in the outputs.
+
+Let's time these two different versions:
+
+.. code-block:: python
+
+  import timeit
+
+  print(timeit.timeit(lambda: mx.eval(naive_add(xs, ys)), number=100))
+  print(timeit.timeit(lambda: mx.eval(vmap_add(xs, ys)), number=100))
+
+On an M1 Max the naive version takes in total ``5.639`` seconds whereas the
+vectorized version takes only ``0.024`` seconds, more than 200 times faster.
+
+Of course, this operation is quite contrived. A better approach is to simply do
+``xs + ys.T``, but for more complex functions :func:`vmap` can be quite handy.
diff --git a/ml-stable-diffusion/mlx/docs/src/usage/indexing.rst b/ml-stable-diffusion/mlx/docs/src/usage/indexing.rst
new file mode 100644
index 0000000000000000000000000000000000000000..f454a3d5526f5646432bbd051911cbc533fac596
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/usage/indexing.rst
@@ -0,0 +1,145 @@
+.. _indexing:
+
+Indexing Arrays
+===============
+
+.. currentmodule:: mlx.core
+
+For the most part, indexing an MLX :obj:`array` works the same as indexing a
+NumPy :obj:`numpy.ndarray`. See the `NumPy documentation
+<https://numpy.org/doc/stable/user/basics.indexing.html>`_ for more details on
+how that works.
+
+For example, you can use regular integers and slices (:obj:`slice`) to index arrays:
+
+.. code-block:: shell
+
+  >>> arr = mx.arange(10)
+  >>> arr[3]
+  array(3, dtype=int32)
+  >>> arr[-2]  # negative indexing works
+  array(8, dtype=int32)
+  >>> arr[2:8:2] # start, stop, stride
+  array([2, 4, 6], dtype=int32)
+
+For multi-dimensional arrays, the ``...`` or :obj:`Ellipsis` syntax works as in NumPy:
+
+.. code-block:: shell
+
+  >>> arr = mx.arange(8).reshape(2, 2, 2)
+  >>> arr[:, :, 0]
+  array(3, dtype=int32)
+  array([[0, 2],
+         [4, 6]], dtype=int32
+  >>> arr[..., 0]
+  array([[0, 2],
+         [4, 6]], dtype=int32
+
+You can index with ``None`` to create a new axis:
+
+.. code-block:: shell
+
+  >>> arr = mx.arange(8)
+  >>> arr.shape
+  [8]
+  >>> arr[None].shape
+  [1, 8]
+
+
+You can also use an :obj:`array` to index another :obj:`array`:
+
+.. code-block:: shell
+
+  >>> arr = mx.arange(10)
+  >>> idx = mx.array([5, 7])
+  >>> arr[idx]
+  array([5, 7], dtype=int32)
+
+Mixing and matching integers, :obj:`slice`, ``...``, and :obj:`array` indices
+works just as in NumPy.
+
+Other functions which may be useful for indexing arrays are :func:`take` and
+:func:`take_along_axis`.
+
+Differences from NumPy
+----------------------
+
+.. Note::
+
+  MLX indexing is different from NumPy indexing in two important ways:
+
+  * Indexing does not perform bounds checking. Indexing out of bounds is
+    undefined behavior.
+  * Boolean mask based indexing is not yet supported.
+
+The reason for the lack of bounds checking is that exceptions cannot propagate
+from the GPU. Performing bounds checking for array indices before launching the
+kernel would be extremely inefficient.
+
+Indexing with boolean masks is something that MLX may support in the future. In
+general, MLX has limited support for operations for which output
+*shapes* are dependent on input *data*. Other examples of these types of
+operations which MLX does not yet support include :func:`numpy.nonzero` and the
+single input version of :func:`numpy.where`.
+
+In Place Updates
+----------------
+
+In place updates to indexed arrays are possible in MLX. For example:
+
+.. code-block:: shell
+
+  >>> a = mx.array([1, 2, 3])
+  >>> a[2] = 0
+  >>> a
+  array([1, 2, 0], dtype=int32)
+
+Just as in NumPy, in place updates will be reflected in all references to the
+same array:
+
+.. code-block:: shell
+
+  >>> a = mx.array([1, 2, 3])
+  >>> b = a
+  >>> b[2] = 0
+  >>> b
+  array([1, 2, 0], dtype=int32)
+  >>> a
+  array([1, 2, 0], dtype=int32)
+
+Note that unlike NumPy, slicing an array creates a copy, not a view. So
+mutating it does not mutate the original array:
+
+.. code-block:: shell
+
+  >>> a = mx.array([1, 2, 3])
+  >>> b = a[:]
+  >>> b[2] = 0
+  >>> b
+  array([1, 2, 0], dtype=int32)
+  >>> a
+  array([1, 2, 3], dtype=int32)
+
+Also unlike NumPy, updates to the same location are nondeterministic:
+
+.. code-block:: shell
+
+  >>> a = mx.array([1, 2, 3])
+  >>> a[[0, 0]] = mx.array([4, 5])
+
+The first element of ``a`` could be ``4`` or ``5``.
+
+Transformations of functions which use in-place updates are allowed and work as
+expected. For example:
+
+.. code-block:: python
+
+   def fun(x, idx):
+       x[idx] = 2.0
+       return x.sum()
+
+   dfdx = mx.grad(fun)(mx.array([1.0, 2.0, 3.0]), mx.array([1]))
+   print(dfdx)  # Prints: array([1, 0, 1], dtype=float32)
+
+In the above ``dfdx`` will have the correct gradient, namely zeros at ``idx``
+and ones elsewhere.
diff --git a/ml-stable-diffusion/mlx/docs/src/usage/launching_distributed.rst b/ml-stable-diffusion/mlx/docs/src/usage/launching_distributed.rst
new file mode 100644
index 0000000000000000000000000000000000000000..2e956a486cd43d1ab6a6dea8473831aacca257f3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/usage/launching_distributed.rst
@@ -0,0 +1,105 @@
+:orphan:
+
+.. _usage_launch_distributed:
+
+Launching Distributed Programs
+==============================
+
+.. currentmodule:: mlx.core.distributed
+
+Installing the MLX python package provides a helper script ``mlx.launch`` that
+can be used to run python scripts distributed on several nodes. It allows
+launching using either the MPI backend or the ring backend. See the
+:doc:`distributed docs <distributed>` for the different backends.
+
+Usage
+-----
+
+The minimal usage example of ``mlx.launch`` is simply
+
+.. code:: shell
+
+    mlx.launch --hosts ip1,ip2 my_script.py
+
+or for testing on localhost
+
+.. code:: shell
+
+    mlx.launch -n 2 my_script.py
+
+The ``mlx.launch`` command connects to the provided host and launches the input
+script on each host. It monitors each of the launched processes and terminates
+the rest if one of them fails unexpectedly or if ``mlx.launch`` is terminated.
+It also takes care of forwarding the output of each remote process to stdout
+and stderr respectively.
+
+Providing Hosts
+^^^^^^^^^^^^^^^^
+
+Hosts can be provided as command line arguments, like above, but the way that
+allows to fully define a list of hosts is via a JSON hostfile. The hostfile has
+a very simple schema. It is simply a list of objects that define each host via
+a hostname to ssh to and a list of IPs to utilize for the communication.
+
+.. code:: json
+
+    [
+        {"ssh": "hostname1", "ips": ["123.123.1.1", "123.123.2.1"]},
+        {"ssh": "hostname2", "ips": ["123.123.1.2", "123.123.2.2"]}
+    ]
+
+You can use ``mlx.distributed_config --over ethernet`` to create a hostfile
+with IPs corresponding to the ``en0`` interface.
+
+Setting up Remote Hosts
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+In order to be able to launch the script on each host we need to be able to
+connect via ssh. Moreover the input script and python binary need to be on each
+host and on the same path. A good checklist to debug errors is the following:
+
+* ``ssh hostname`` works without asking for password or host confirmation
+* the python binary is available on all hosts at the same path. You can use
+  ``mlx.launch --print-python`` to see what that path is.
+* the script you want to run is available on all hosts at the same path
+
+.. _mpi_specifics:
+
+MPI Specifics
+-------------
+
+One can use MPI by passing ``--backend mpi`` to ``mlx.launch``. In that case,
+``mlx.launch`` is a thin wrapper over ``mpirun``. Moreover,
+
+* The IPs in the hostfile are ignored
+* The ssh connectivity requirement is stronger as every node needs to be able
+  to connect to every other node
+* ``mpirun`` needs to be available on every node at the same path
+
+Finally, one can pass arguments to ``mpirun`` using ``--mpi-arg``. For instance
+to choose a specific interface for the byte-transfer-layer of MPI we can call
+``mlx.launch`` as follows:
+
+.. code:: shell
+
+    mlx.launch --backend mpi --mpi-arg '--mca btl_tcp_if_include en0' --hostfile hosts.json my_script.py
+
+
+.. _ring_specifics:
+
+Ring Specifics
+--------------
+
+The ring backend, which is also the default backend, can be explicitly selected
+with the argument ``--backend ring``. The ring backend has some specific
+requirements and arguments that are different to MPI:
+
+* The argument ``--hosts`` only accepts IPs and not hostnames. If we need to
+  ssh to a hostname that does not correspond to the IP we want to bind to we
+  have to provide a hostfile.
+* ``--starting-port`` defines the port to bind to on the remote hosts.
+  Specifically rank 0 for the first IP will use this port and each subsequent
+  IP or rank will add 1 to this port.
+* ``--connections-per-ip`` allows us to increase the number of connections
+  between neighboring nodes. This corresponds to ``--mca btl_tcp_links 2`` for
+  ``mpirun``.
diff --git a/ml-stable-diffusion/mlx/docs/src/usage/lazy_evaluation.rst b/ml-stable-diffusion/mlx/docs/src/usage/lazy_evaluation.rst
new file mode 100644
index 0000000000000000000000000000000000000000..8fd855efad91e2cda40a90cb1f363cc21254e20a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/usage/lazy_evaluation.rst
@@ -0,0 +1,144 @@
+.. _lazy eval:
+
+Lazy Evaluation
+===============
+
+.. currentmodule:: mlx.core
+
+Why Lazy Evaluation
+-------------------
+
+When you perform operations in MLX, no computation actually happens. Instead a
+compute graph is recorded. The actual computation only happens if an
+:func:`eval` is performed.
+
+MLX uses lazy evaluation because it has some nice features, some of which we
+describe below.
+
+Transforming Compute Graphs
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Lazy evaluation lets us record a compute graph without actually doing any
+computations. This is useful for function transformations like :func:`grad` and
+:func:`vmap` and graph optimizations.
+
+Currently, MLX does not compile and rerun compute graphs. They are all
+generated dynamically. However, lazy evaluation makes it much easier to
+integrate compilation for future performance enhancements.
+
+Only Compute What You Use
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+In MLX you do not need to worry as much about computing outputs that are never
+used. For example:
+
+.. code-block:: python
+
+  def fun(x):
+      a = fun1(x)
+      b = expensive_fun(a)
+      return a, b
+
+  y, _ = fun(x)
+
+Here, we never actually compute the output of ``expensive_fun``. Use this
+pattern with care though, as the graph of ``expensive_fun`` is still built, and
+that has some cost associated to it.
+
+Similarly, lazy evaluation can be beneficial for saving memory while keeping
+code simple. Say you have a very large model ``Model`` derived from
+:obj:`mlx.nn.Module`. You can instantiate this model with ``model = Model()``.
+Typically, this will initialize all of the weights as ``float32``, but the
+initialization does not actually compute anything until you perform an
+:func:`eval`. If you update the model with ``float16`` weights, your maximum
+consumed memory will be half that required if eager computation was used
+instead.
+
+This pattern is simple to do in MLX thanks to lazy computation:
+
+.. code-block:: python
+
+  model = Model() # no memory used yet
+  model.load_weights("weights_fp16.safetensors")
+
+When to Evaluate
+----------------
+
+A common question is when to use :func:`eval`. The trade-off is between
+letting graphs get too large and not batching enough useful work.
+
+For example:
+
+.. code-block:: python
+
+  for _ in range(100):
+       a = a + b
+       mx.eval(a)
+       b = b * 2
+       mx.eval(b)
+
+This is a bad idea because there is some fixed overhead with each graph
+evaluation. On the other hand, there is some slight overhead which grows with
+the compute graph size, so extremely large graphs (while computationally
+correct) can be costly.
+
+Luckily, a wide range of compute graph sizes work pretty well with MLX:
+anything from a few tens of operations to many thousands of operations per
+evaluation should be okay.
+
+Most numerical computations have an iterative outer loop (e.g. the iteration in
+stochastic gradient descent). A natural and usually efficient place to use
+:func:`eval` is at each iteration of this outer loop.
+
+Here is a concrete example:
+
+.. code-block:: python
+
+   for batch in dataset:
+
+       # Nothing has been evaluated yet
+       loss, grad = value_and_grad_fn(model, batch)
+
+       # Still nothing has been evaluated
+       optimizer.update(model, grad)
+
+       # Evaluate the loss and the new parameters which will
+       # run the full gradient computation and optimizer update
+       mx.eval(loss, model.parameters())
+
+
+An important behavior to be aware of is when the graph will be implicitly
+evaluated. Anytime you ``print`` an array, convert it to an
+:obj:`numpy.ndarray`, or otherwise access its memory via :obj:`memoryview`,
+the graph will be evaluated. Saving arrays via :func:`save` (or any other MLX
+saving functions) will also evaluate the array.
+
+
+Calling :func:`array.item` on a scalar array will also evaluate it. In the
+example above, printing the loss (``print(loss)``) or adding the loss scalar to
+a list (``losses.append(loss.item())``) would cause a graph evaluation. If
+these lines are before ``mx.eval(loss, model.parameters())`` then this
+will be a partial evaluation, computing only the forward pass.
+
+Also, calling :func:`eval` on an array or set of arrays multiple times is
+perfectly fine. This is effectively a no-op.
+
+.. warning::
+
+  Using scalar arrays for control-flow will cause an evaluation.
+
+Here is an example:
+
+.. code-block:: python
+
+   def fun(x):
+       h, y = first_layer(x)
+       if y > 0:  # An evaluation is done here!
+           z  = second_layer_a(h)
+       else:
+           z  = second_layer_b(h)
+       return z
+
+Using arrays for control flow should be done with care. The above example works
+and can even be used with gradient transformations. However, this can be very
+inefficient if evaluations are done too frequently.
diff --git a/ml-stable-diffusion/mlx/docs/src/usage/numpy.rst b/ml-stable-diffusion/mlx/docs/src/usage/numpy.rst
new file mode 100644
index 0000000000000000000000000000000000000000..09b36ddbd6f75ae1a53cf8242c4d3772c6bfb563
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/usage/numpy.rst
@@ -0,0 +1,124 @@
+.. _numpy:
+
+Conversion to NumPy and Other Frameworks
+========================================
+
+MLX array supports conversion between other frameworks with either:
+
+* The `Python Buffer Protocol <https://docs.python.org/3/c-api/buffer.html>`_.
+* `DLPack <https://dmlc.github.io/dlpack/latest/>`_.
+
+Let's convert an array to NumPy and back.
+
+.. code-block:: python
+
+  import mlx.core as mx
+  import numpy as np
+
+  a = mx.arange(3)
+  b = np.array(a) # copy of a
+  c = mx.array(b) # copy of b
+
+.. note::
+
+    Since NumPy does not support ``bfloat16`` arrays, you will need to convert
+    to ``float16`` or ``float32`` first: ``np.array(a.astype(mx.float32))``.
+    Otherwise, you will receive an error like: ``Item size 2 for PEP 3118
+    buffer format string does not match the dtype V item size 0.``
+
+By default, NumPy copies data to a new array. This can be prevented by creating
+an array view:
+
+.. code-block:: python
+
+  a = mx.arange(3)
+  a_view = np.array(a, copy=False)
+  print(a_view.flags.owndata) # False
+  a_view[0] = 1
+  print(a[0].item()) # 1
+
+.. note::
+
+    NumPy arrays with type ``float64`` will be default converted to MLX arrays
+    with type ``float32``.
+
+A NumPy array view is a normal NumPy array, except that it does not own its
+memory. This means writing to the view is reflected in the original array.
+
+While this is quite powerful to prevent copying arrays, it should be noted that
+external changes to the memory of arrays cannot be reflected in gradients.
+
+Let's demonstrate this in an example:
+
+.. code-block:: python
+
+  def f(x):
+      x_view = np.array(x, copy=False)
+      x_view[:] *= x_view # modify memory without telling mx
+      return x.sum()
+
+  x = mx.array([3.0])
+  y, df = mx.value_and_grad(f)(x)
+  print("f(x) = x² =", y.item()) # 9.0
+  print("f'(x) = 2x !=", df.item()) # 1.0
+
+
+The function ``f`` indirectly modifies the array ``x`` through a memory view.
+However, this modification is not reflected in the gradient, as seen in the
+last line outputting ``1.0``, representing the gradient of the sum operation
+alone.  The squaring of ``x`` occurs externally to MLX, meaning that no
+gradient is incorporated.  It's important to note that a similar issue arises
+during array conversion and copying.  For instance, a function defined as
+``mx.array(np.array(x)**2).sum()`` would also result in an incorrect gradient,
+even though no in-place operations on MLX memory are executed.
+
+PyTorch
+-------
+
+.. warning::
+
+   PyTorch Support for :obj:`memoryview` is experimental and can break for
+   multi-dimensional arrays. Casting to NumPy first is advised for now.
+
+PyTorch supports the buffer protocol, but it requires an explicit
+:obj:`memoryview`.
+
+.. code-block:: python
+
+  import mlx.core as mx
+  import torch
+
+  a = mx.arange(3)
+  b = torch.tensor(memoryview(a))
+  c = mx.array(b.numpy())
+
+Conversion from PyTorch tensors back to arrays must be done via intermediate
+NumPy arrays with ``numpy()``.
+
+JAX
+---
+JAX fully supports the buffer protocol.
+
+.. code-block:: python
+
+  import mlx.core as mx
+  import jax.numpy as jnp
+
+  a = mx.arange(3)
+  b = jnp.array(a)
+  c = mx.array(b)
+
+TensorFlow
+----------
+
+TensorFlow supports the buffer protocol, but it requires an explicit
+:obj:`memoryview`.
+
+.. code-block:: python
+
+  import mlx.core as mx
+  import tensorflow as tf
+
+  a = mx.arange(3)
+  b = tf.constant(memoryview(a))
+  c = mx.array(b)
diff --git a/ml-stable-diffusion/mlx/docs/src/usage/quick_start.rst b/ml-stable-diffusion/mlx/docs/src/usage/quick_start.rst
new file mode 100644
index 0000000000000000000000000000000000000000..bc1d92ad633b3ab0685d370b08a59dd6a09b6dc5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/usage/quick_start.rst
@@ -0,0 +1,67 @@
+Quick Start Guide
+=================
+
+
+Basics
+------
+
+.. currentmodule:: mlx.core
+
+Import ``mlx.core`` and make an :class:`array`:
+
+.. code-block:: python
+
+  >> import mlx.core as mx
+  >> a = mx.array([1, 2, 3, 4])
+  >> a.shape
+  [4]
+  >> a.dtype
+  int32
+  >> b = mx.array([1.0, 2.0, 3.0, 4.0])
+  >> b.dtype
+  float32
+
+Operations in MLX are lazy. The outputs of MLX operations are not computed
+until they are needed. To force an array to be evaluated use
+:func:`eval`.  Arrays will automatically be evaluated in a few cases. For
+example, inspecting a scalar with :meth:`array.item`, printing an array,
+or converting an array from :class:`array` to :class:`numpy.ndarray` all
+automatically evaluate the array.
+
+.. code-block:: python
+
+  >> c = a + b    # c not yet evaluated
+  >> mx.eval(c)  # evaluates c
+  >> c = a + b
+  >> print(c)     # Also evaluates c
+  array([2, 4, 6, 8], dtype=float32)
+  >> c = a + b
+  >> import numpy as np
+  >> np.array(c)   # Also evaluates c
+  array([2., 4., 6., 8.], dtype=float32)
+
+
+See the page on :ref:`Lazy Evaluation <lazy eval>` for more details.
+
+Function and Graph Transformations
+----------------------------------
+
+MLX has standard function transformations like :func:`grad` and :func:`vmap`.
+Transformations can be composed arbitrarily. For example
+``grad(vmap(grad(fn)))`` (or any other composition) is allowed.
+
+.. code-block:: python
+
+  >> x = mx.array(0.0)
+  >> mx.sin(x)
+  array(0, dtype=float32)
+  >> mx.grad(mx.sin)(x)
+  array(1, dtype=float32)
+  >> mx.grad(mx.grad(mx.sin))(x)
+  array(-0, dtype=float32)
+
+Other gradient transformations include :func:`vjp` for vector-Jacobian products
+and :func:`jvp` for Jacobian-vector products.
+
+Use :func:`value_and_grad` to efficiently compute both a function's output and
+gradient with respect to the function's input.
diff --git a/ml-stable-diffusion/mlx/docs/src/usage/saving_and_loading.rst b/ml-stable-diffusion/mlx/docs/src/usage/saving_and_loading.rst
new file mode 100644
index 0000000000000000000000000000000000000000..43f2a7999017ad6568f900f76f5414ae0a83dcf5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/usage/saving_and_loading.rst
@@ -0,0 +1,81 @@
+.. _saving_and_loading:
+
+Saving and Loading Arrays
+=========================
+
+.. currentmodule:: mlx.core
+
+MLX supports multiple array serialization formats.
+
+.. list-table:: Serialization Formats
+   :widths: 20 8 25 25
+   :header-rows: 1
+
+   * - Format
+     - Extension
+     - Function
+     - Notes
+   * - NumPy
+     - ``.npy``
+     - :func:`save`
+     - Single arrays only
+   * - NumPy archive
+     - ``.npz``
+     - :func:`savez` and :func:`savez_compressed`
+     - Multiple arrays
+   * - Safetensors
+     - ``.safetensors``
+     - :func:`save_safetensors`
+     - Multiple arrays
+   * - GGUF
+     - ``.gguf``
+     - :func:`save_gguf`
+     - Multiple arrays
+
+The :func:`load` function will load any of the supported serialization
+formats. It determines the format from the extensions. The output of
+:func:`load` depends on the format.
+
+Here's an example of saving a single array to a file:
+
+.. code-block:: shell
+
+   >>> a = mx.array([1.0])
+   >>> mx.save("array", a)
+
+The array ``a`` will be saved in the file ``array.npy`` (notice the extension
+is automatically added). Including the extension is optional; if it is missing
+it will be added. You can load the array with:
+
+.. code-block:: shell
+
+   >>> mx.load("array.npy")
+   array([1], dtype=float32)
+
+Here's an example of saving several arrays to a single file:
+
+.. code-block:: shell
+
+   >>> a = mx.array([1.0])
+   >>> b = mx.array([2.0])
+   >>> mx.savez("arrays", a, b=b)
+
+For compatibility with :func:`numpy.savez` the MLX :func:`savez` takes arrays
+as arguments. If the keywords are missing, then default names will be
+provided. This can be loaded with:
+
+.. code-block:: shell
+
+   >>> mx.load("arrays.npz")
+   {'b': array([2], dtype=float32), 'arr_0': array([1], dtype=float32)}
+
+In this case :func:`load` returns a dictionary of names to arrays.
+
+The functions :func:`save_safetensors` and :func:`save_gguf` are similar to
+:func:`savez`, but they take as input a :obj:`dict` of string names to arrays:
+
+.. code-block:: shell
+
+   >>> a = mx.array([1.0])
+   >>> b = mx.array([2.0])
+   >>> mx.save_safetensors("arrays", {"a": a, "b": b})
diff --git a/ml-stable-diffusion/mlx/docs/src/usage/unified_memory.rst b/ml-stable-diffusion/mlx/docs/src/usage/unified_memory.rst
new file mode 100644
index 0000000000000000000000000000000000000000..57f54bc23b41a3f207a82f89dec8d0f6c284b047
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/usage/unified_memory.rst
@@ -0,0 +1,78 @@
+.. _unified_memory:
+
+Unified Memory
+==============
+
+.. currentmodule:: mlx.core
+
+Apple silicon has a unified memory architecture. The CPU and GPU have direct
+access to the same memory pool. MLX is designed to take advantage of that.
+
+Concretely, when you make an array in MLX you don't have to specify its location:
+
+
+.. code-block:: python
+
+  a = mx.random.normal((100,))
+  b = mx.random.normal((100,))
+
+Both ``a`` and ``b`` live in unified memory.
+
+In MLX, rather than moving arrays to devices, you specify the device when you
+run the operation. Any device can perform any operation on ``a`` and ``b``
+without needing to move them from one memory location to another. For example:
+
+.. code-block:: python
+
+  mx.add(a, b, stream=mx.cpu)
+  mx.add(a, b, stream=mx.gpu)
+
+In the above, both the CPU and the GPU will perform the same add
+operation. The operations can (and likely will) be run in parallel since
+there are no dependencies between them. See :ref:`using_streams` for more
+information the semantics of streams in MLX.
+
+In the above ``add`` example, there are no dependencies between operations, so
+there is no possibility for race conditions. If there are dependencies, the
+MLX scheduler will automatically manage them. For example:
+
+.. code-block:: python
+
+  c = mx.add(a, b, stream=mx.cpu)
+  d = mx.add(a, c, stream=mx.gpu)
+
+In the above case, the second ``add`` runs on the GPU but it depends on the
+output of the first ``add`` which is running on the CPU. MLX will
+automatically insert a dependency between the two streams so that the second
+``add`` only starts executing after the first is complete and ``c`` is
+available.
+
+A Simple Example
+~~~~~~~~~~~~~~~~
+
+Here is a more interesting (albeit slightly contrived example) of how unified
+memory can be helpful. Suppose we have the following computation:
+
+.. code-block:: python
+
+  def fun(a, b, d1, d2):
+    x = mx.matmul(a, b, stream=d1)
+    for _ in range(500):
+        b = mx.exp(b, stream=d2)
+    return x, b
+
+which we want to run with the following arguments:
+
+.. code-block:: python
+
+  a = mx.random.uniform(shape=(4096, 512))
+  b = mx.random.uniform(shape=(512, 4))
+
+The first ``matmul`` operation is a good fit for the GPU since it's more
+compute dense. The second sequence of operations are a better fit for the CPU,
+since they are very small and would probably be overhead bound on the GPU.
+
+If we time the computation fully on the GPU, we get 2.8 milliseconds. But if we
+run the computation with ``d1=mx.gpu`` and ``d2=mx.cpu``, then the time is only
+about 1.4 milliseconds, about twice as fast. These times were measured on an M1
+Max.
diff --git a/ml-stable-diffusion/mlx/docs/src/usage/using_streams.rst b/ml-stable-diffusion/mlx/docs/src/usage/using_streams.rst
new file mode 100644
index 0000000000000000000000000000000000000000..058bc59dea6e99673a1bd0b4f5d62c7bc8e34097
--- /dev/null
+++ b/ml-stable-diffusion/mlx/docs/src/usage/using_streams.rst
@@ -0,0 +1,18 @@
+.. _using_streams:
+
+Using Streams
+=============
+
+.. currentmodule:: mlx.core
+
+Specifying the :obj:`Stream`
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+All operations (including random number generation) take an optional
+keyword argument ``stream``. The ``stream`` kwarg specifies which
+:obj:`Stream` the operation should run on. If the stream is unspecified then
+the operation is run on the default stream of the default device:
+``mx.default_stream(mx.default_device())``.  The ``stream`` kwarg can also
+be a :obj:`Device` (e.g. ``stream=my_device``) in which case the operation is
+run on the default stream of the provided device
+``mx.default_stream(my_device)``.
diff --git a/ml-stable-diffusion/mlx/examples/cmake_project/CMakeLists.txt b/ml-stable-diffusion/mlx/examples/cmake_project/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7a73ce1d9d14a566b6cfe9992d3b8903d22752fd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/cmake_project/CMakeLists.txt
@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.27)
+
+project(example LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Comment the following two commands only the MLX C++ library is installed and
+# set(MLX_ROOT "/path/to/mlx") directly if needed.
+find_package(
+  Python 3.9
+  COMPONENTS Interpreter Development.Module
+  REQUIRED)
+execute_process(
+  COMMAND "${Python_EXECUTABLE}" -m mlx --cmake-dir
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  OUTPUT_VARIABLE MLX_ROOT)
+
+find_package(MLX CONFIG REQUIRED)
+
+add_executable(example example.cpp)
+target_link_libraries(example PRIVATE mlx)
diff --git a/ml-stable-diffusion/mlx/examples/cmake_project/README.md b/ml-stable-diffusion/mlx/examples/cmake_project/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..657c58fe63f660e9fd4934d397473d160499a5ed
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/cmake_project/README.md
@@ -0,0 +1,26 @@
+## Build and Run 
+
+Install MLX with Python:
+
+```bash
+pip install mlx>=0.22
+```
+
+Build the C++ example:
+
+```bash
+cmake -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build
+```
+
+Run the C++ example:
+
+```
+./build/example
+```
+
+which should output:
+
+```
+array([2, 4, 6], dtype=int32)
+```
diff --git a/ml-stable-diffusion/mlx/examples/cmake_project/example.cpp b/ml-stable-diffusion/mlx/examples/cmake_project/example.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6e69f47c5f9aa185b97562a81713a9287fe31f48
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/cmake_project/example.cpp
@@ -0,0 +1,14 @@
+// Copyright © 2024 Apple Inc.
+
+#include <iostream>
+
+#include "mlx/mlx.h"
+
+namespace mx = mlx::core;
+
+int main() {
+  auto x = mx::array({1, 2, 3});
+  auto y = mx::array({1, 2, 3});
+  std::cout << x + y << std::endl;
+  return 0;
+}
diff --git a/ml-stable-diffusion/mlx/examples/cpp/CMakeLists.txt b/ml-stable-diffusion/mlx/examples/cpp/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1b3969c97e17d37c4237ed63b81842653307f273
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/cpp/CMakeLists.txt
@@ -0,0 +1,12 @@
+function(build_example SRCFILE)
+  get_filename_component(src_name ${SRCFILE} NAME_WE)
+  set(target "${src_name}")
+  add_executable(${target} ${SRCFILE})
+  target_link_libraries(${target} PRIVATE mlx)
+endfunction(build_example)
+
+build_example(tutorial.cpp)
+build_example(linear_regression.cpp)
+build_example(logistic_regression.cpp)
+build_example(metal_capture.cpp)
+build_example(distributed.cpp)
diff --git a/ml-stable-diffusion/mlx/examples/cpp/distributed.cpp b/ml-stable-diffusion/mlx/examples/cpp/distributed.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1cc69d9519f92a51ec76ddc8e98b221508daf882
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/cpp/distributed.cpp
@@ -0,0 +1,22 @@
+// Copyright © 2024 Apple Inc.
+
+#include <iostream>
+
+#include "mlx/mlx.h"
+
+namespace mx = mlx::core;
+
+int main() {
+  if (!mx::distributed::is_available()) {
+    std::cout << "No communication backend found" << std::endl;
+    return 1;
+  }
+
+  auto global_group = mx::distributed::init();
+  std::cout << global_group.rank() << " / " << global_group.size() << std::endl;
+
+  mx::array x = mx::ones({10});
+  mx::array out = mx::distributed::all_sum(x, global_group);
+
+  std::cout << out << std::endl;
+}
diff --git a/ml-stable-diffusion/mlx/examples/cpp/linear_regression.cpp b/ml-stable-diffusion/mlx/examples/cpp/linear_regression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ba3578d2f9d96cbc5e4d568711ec2e1b4fa2adcc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/cpp/linear_regression.cpp
@@ -0,0 +1,54 @@
+// Copyright © 2023 Apple Inc.
+
+#include <chrono>
+#include <cmath>
+#include <iostream>
+
+#include "mlx/mlx.h"
+#include "timer.h"
+
+/**
+ * An example of linear regression with MLX.
+ */
+namespace mx = mlx::core;
+
+int main() {
+  int num_features = 100;
+  int num_examples = 1'000;
+  int num_iters = 10'000;
+  float learning_rate = 0.01;
+
+  // True parameters
+  auto w_star = mx::random::normal({num_features});
+
+  // The input examples (design matrix)
+  auto X = mx::random::normal({num_examples, num_features});
+
+  // Noisy labels
+  auto eps = 1e-2 * mx::random::normal({num_examples});
+  auto y = mx::matmul(X, w_star) + eps;
+
+  // Initialize random parameters
+  mx::array w = 1e-2 * mx::random::normal({num_features});
+
+  auto loss_fn = [&](mx::array w) {
+    auto yhat = mx::matmul(X, w);
+    return (0.5f / num_examples) * mx::sum(mx::square(yhat - y));
+  };
+
+  auto grad_fn = mx::grad(loss_fn);
+
+  auto tic = timer::time();
+  for (int it = 0; it < num_iters; ++it) {
+    auto grads = grad_fn(w);
+    w = w - learning_rate * grads;
+    mx::eval(w);
+  }
+  auto toc = timer::time();
+
+  auto loss = loss_fn(w);
+  auto error_norm = std::sqrt(mx::sum(mx::square(w - w_star)).item<float>());
+  auto throughput = num_iters / timer::seconds(toc - tic);
+  std::cout << "Loss " << loss << ", |w - w*| = " << error_norm
+            << ", Throughput " << throughput << " (it/s)." << std::endl;
+}
diff --git a/ml-stable-diffusion/mlx/examples/cpp/logistic_regression.cpp b/ml-stable-diffusion/mlx/examples/cpp/logistic_regression.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1d373f5240747542adac161fac20ae1272a0acba
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/cpp/logistic_regression.cpp
@@ -0,0 +1,54 @@
+// Copyright © 2023 Apple Inc.
+
+#include <chrono>
+#include <cmath>
+#include <iostream>
+
+#include "mlx/mlx.h"
+#include "timer.h"
+
+/**
+ * An example of logistic regression with MLX.
+ */
+namespace mx = mlx::core;
+
+int main() {
+  int num_features = 100;
+  int num_examples = 1'000;
+  int num_iters = 10'000;
+  float learning_rate = 0.1;
+
+  // True parameters
+  auto w_star = mx::random::normal({num_features});
+
+  // The input examples
+  auto X = mx::random::normal({num_examples, num_features});
+
+  // Labels
+  auto y = mx::matmul(X, w_star) > 0;
+
+  // Initialize random parameters
+  mx::array w = 1e-2 * mx::random::normal({num_features});
+
+  auto loss_fn = [&](mx::array w) {
+    auto logits = mx::matmul(X, w);
+    auto scale = (1.0f / num_examples);
+    return scale * mx::sum(mx::logaddexp(mx::array(0.0f), logits) - y * logits);
+  };
+
+  auto grad_fn = mx::grad(loss_fn);
+
+  auto tic = timer::time();
+  for (int it = 0; it < num_iters; ++it) {
+    auto grads = grad_fn(w);
+    w = w - learning_rate * grads;
+    mx::eval(w);
+  }
+  auto toc = timer::time();
+
+  auto loss = loss_fn(w);
+  auto acc = mx::sum((mx::matmul(X, w) > 0) == y) / num_examples;
+  auto throughput = num_iters / timer::seconds(toc - tic);
+  std::cout << "Loss " << loss << ", Accuracy, " << acc << ", Throughput "
+            << throughput << " (it/s)." << std::endl;
+}
diff --git a/ml-stable-diffusion/mlx/examples/cpp/metal_capture.cpp b/ml-stable-diffusion/mlx/examples/cpp/metal_capture.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..17f830066264f786e8a9e49bf8deabeb2e57fbac
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/cpp/metal_capture.cpp
@@ -0,0 +1,31 @@
+// Copyright © 2024 Apple Inc.
+
+#include <cassert>
+#include <iostream>
+
+#include "mlx/mlx.h"
+
+namespace mx = mlx::core;
+
+int main() {
+  // To use Metal debugging and profiling:
+  // 1. Build with the MLX_METAL_DEBUG CMake option (i.e. -DMLX_METAL_DEBUG=ON).
+  // 2. Run with MTL_CAPTURE_ENABLED=1.
+  mx::metal::start_capture("mlx_trace.gputrace");
+
+  // Start at index two because the default GPU and CPU streams have indices
+  // zero and one, respectively. This naming matches the label assigned to each
+  // stream's command queue.
+  auto s2 = new_stream(mx::Device::gpu);
+  auto s3 = new_stream(mx::Device::gpu);
+
+  auto a = mx::arange(1.f, 10.f, 1.f, mx::float32, s2);
+  auto b = mx::arange(1.f, 10.f, 1.f, mx::float32, s3);
+  auto x = mx::add(a, a, s2);
+  auto y = mx::add(b, b, s3);
+
+  // The multiply will happen on the default stream.
+  std::cout << mx::multiply(x, y) << std::endl;
+
+  mx::metal::stop_capture();
+}
diff --git a/ml-stable-diffusion/mlx/examples/cpp/timer.h b/ml-stable-diffusion/mlx/examples/cpp/timer.h
new file mode 100644
index 0000000000000000000000000000000000000000..cea85ee829949762a7148c24e1a46ae8e4c1d9da
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/cpp/timer.h
@@ -0,0 +1,20 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <chrono>
+
+namespace timer {
+
+using namespace std::chrono;
+
+template <typename R, typename P>
+inline double seconds(duration<R, P> x) {
+  return duration_cast<nanoseconds>(x).count() / 1e9;
+}
+
+inline auto time() {
+  return high_resolution_clock::now();
+}
+
+} // namespace timer
diff --git a/ml-stable-diffusion/mlx/examples/cpp/tutorial.cpp b/ml-stable-diffusion/mlx/examples/cpp/tutorial.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ae2cd3cfbe42c203902f6eaeef5ec9a6ec126e22
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/cpp/tutorial.cpp
@@ -0,0 +1,99 @@
+// Copyright © 2023 Apple Inc.
+
+#include <cassert>
+#include <iostream>
+
+#include "mlx/mlx.h"
+
+namespace mx = mlx::core;
+
+void array_basics() {
+  // Make a scalar array:
+  mx::array x(1.0);
+
+  // Get the value out of it:
+  auto s = x.item<float>();
+  assert(s == 1.0);
+
+  // Scalars have a size of 1:
+  size_t size = x.size();
+  assert(size == 1);
+
+  // Scalars have 0 dimensions:
+  int ndim = x.ndim();
+  assert(ndim == 0);
+
+  // The shape should be an empty vector:
+  auto shape = x.shape();
+  assert(shape.empty());
+
+  // The datatype should be float32:
+  auto dtype = x.dtype();
+  assert(dtype == mx::float32);
+
+  // Specify the dtype when constructing the array:
+  x = mx::array(1, mx::int32);
+  assert(x.dtype() == mx::int32);
+  x.item<int>(); // OK
+  // x.item<float>();  // Undefined!
+
+  // Make a multidimensional array:
+  x = mx::array({1.0f, 2.0f, 3.0f, 4.0f}, {2, 2});
+  // mlx is row-major by default so the first row of this array
+  // is [1.0, 2.0] and the second row is [3.0, 4.0]
+
+  // Make an array of shape {2, 2} filled with ones:
+  auto y = mx::ones({2, 2});
+
+  // Pointwise add x and y:
+  auto z = mx::add(x, y);
+
+  // Same thing:
+  z = x + y;
+
+  // mlx is lazy by default. At this point `z` only
+  // has a shape and a type but no actual data:
+  assert(z.dtype() == mx::float32);
+  assert(z.shape(0) == 2);
+  assert(z.shape(1) == 2);
+
+  // To actually run the computation you must evaluate `z`.
+  // Under the hood, mlx records operations in a graph.
+  // The variable `z` is a node in the graph which points to its operation
+  // and inputs. When `eval` is called on an array (or arrays), the array and
+  // all of its dependencies are recursively evaluated to produce the result.
+  // Once an array is evaluated, it has data and is detached from its inputs.
+  mx::eval(z);
+
+  // Of course the array can still be an input to other operations. You can
+  // even call eval on the array again, this will just be a no-op:
+  mx::eval(z); // no-op
+
+  // Some functions or methods on arrays implicitly evaluate them. For example
+  // accessing a value in an array or printing the array implicitly evaluate it:
+  z = mx::ones({1});
+  z.item<float>(); // implicit evaluation
+
+  z = mx::ones({2, 2});
+  std::cout << z << std::endl; // implicit evaluation
+}
+
+void automatic_differentiation() {
+  auto fn = [](mx::array x) { return mx::square(x); };
+
+  // Computing the derivative function of a function
+  auto grad_fn = mx::grad(fn);
+  // Call grad_fn on the input to get the derivative
+  auto x = mx::array(1.5);
+  auto dfdx = grad_fn(x);
+  // dfdx is 2 * x
+
+  // Get the second derivative by composing grad with grad
+  auto d2fdx2 = mx::grad(mx::grad(fn))(x);
+  // d2fdx2 is 2
+}
+
+int main() {
+  array_basics();
+  automatic_differentiation();
+}
diff --git a/ml-stable-diffusion/mlx/examples/export/CMakeLists.txt b/ml-stable-diffusion/mlx/examples/export/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aefcdf59fb69a6836c82d9a4d5167bb0c6cd44d1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/export/CMakeLists.txt
@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.27)
+
+project(import_mlx LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+find_package(
+  Python 3.9
+  COMPONENTS Interpreter Development.Module
+  REQUIRED)
+execute_process(
+  COMMAND "${Python_EXECUTABLE}" -m mlx --cmake-dir
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  OUTPUT_VARIABLE MLX_ROOT)
+find_package(MLX CONFIG REQUIRED)
+
+add_executable(eval_mlp eval_mlp.cpp)
+target_link_libraries(eval_mlp PRIVATE mlx)
+
+add_executable(train_mlp train_mlp.cpp)
+target_link_libraries(train_mlp PRIVATE mlx)
diff --git a/ml-stable-diffusion/mlx/examples/export/README.md b/ml-stable-diffusion/mlx/examples/export/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4d9f77cdc197e217effb5a6488c2700b35257e79
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/export/README.md
@@ -0,0 +1,49 @@
+## Setup
+
+Install MLX:
+
+```bash
+pip install mlx>=0.22
+```
+
+Build the C++ examples:
+
+```bash
+cmake -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build
+```
+
+## Run
+
+### Eval MLP
+
+Run the Python script to export the eval function:
+
+```bash
+python eval_mlp.py
+```
+
+Then run the C++ program to import and run the function:
+
+```
+./build/eval_mlp
+```
+
+The Python and C++ programs should output the same result.
+
+### Train MLP
+
+Run the Python script to export the model initialization and training
+functions:
+
+```bash
+python train_mlp.py
+```
+
+Then run the C++ program to import and run the functions:
+
+```
+./build/train_mlp
+```
+
+The Python and C++ programs should output the same results.
diff --git a/ml-stable-diffusion/mlx/examples/export/eval_mlp.cpp b/ml-stable-diffusion/mlx/examples/export/eval_mlp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..336cdd272688828d417091efa682ecf23789452c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/export/eval_mlp.cpp
@@ -0,0 +1,25 @@
+// Copyright © 2024 Apple Inc.
+
+#include <mlx/mlx.h>
+#include <iostream>
+
+namespace mx = mlx::core;
+
+int main() {
+  int batch_size = 8;
+  int input_dim = 32;
+
+  // Make the input
+  mx::random::seed(42);
+  auto example_x = mx::random::uniform({batch_size, input_dim});
+
+  // Import the function
+  auto forward = mx::import_function("eval_mlp.mlxfn");
+
+  // Call the imported function
+  auto out = forward({example_x})[0];
+
+  std::cout << out << std::endl;
+
+  return 0;
+}
diff --git a/ml-stable-diffusion/mlx/examples/export/eval_mlp.py b/ml-stable-diffusion/mlx/examples/export/eval_mlp.py
new file mode 100644
index 0000000000000000000000000000000000000000..133ab691791ee4a88dab521e3d7f3ee413675a8f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/export/eval_mlp.py
@@ -0,0 +1,52 @@
+# Copyright © 2024 Apple Inc.
+
+import mlx.core as mx
+import mlx.nn as nn
+import mlx.utils
+
+
+class MLP(nn.Module):
+    """A simple MLP."""
+
+    def __init__(
+        self, num_layers: int, input_dim: int, hidden_dim: int, output_dim: int
+    ):
+        super().__init__()
+        layer_sizes = [input_dim] + [hidden_dim] * num_layers + [output_dim]
+        self.layers = [
+            nn.Linear(idim, odim)
+            for idim, odim in zip(layer_sizes[:-1], layer_sizes[1:])
+        ]
+
+    def __call__(self, x):
+        for l in self.layers[:-1]:
+            x = nn.relu(l(x))
+        return self.layers[-1](x)
+
+
+if __name__ == "__main__":
+
+    batch_size = 8
+    input_dim = 32
+    output_dim = 10
+
+    # Load the model
+    mx.random.seed(0)  # Seed for params
+    model = MLP(num_layers=5, input_dim=input_dim, hidden_dim=64, output_dim=output_dim)
+    mx.eval(model)
+
+    # Note, the model parameters are saved in the export function
+    def forward(x):
+        return model(x)
+
+    mx.random.seed(42)  # Seed for input
+    example_x = mx.random.uniform(shape=(batch_size, input_dim))
+
+    mx.export_function("eval_mlp.mlxfn", forward, example_x)
+
+    # Import in Python
+    imported_forward = mx.import_function("eval_mlp.mlxfn")
+    expected = forward(example_x)
+    (out,) = imported_forward(example_x)
+    assert mx.allclose(expected, out)
+    print(out)
diff --git a/ml-stable-diffusion/mlx/examples/export/train_mlp.cpp b/ml-stable-diffusion/mlx/examples/export/train_mlp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5950bebd37c698898ae1ef7f8cfe23a81b919c8f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/export/train_mlp.cpp
@@ -0,0 +1,35 @@
+// Copyright © 2024 Apple Inc.
+
+#include <mlx/mlx.h>
+#include <iostream>
+
+namespace mx = mlx::core;
+
+int main() {
+  int batch_size = 8;
+  int input_dim = 32;
+  int output_dim = 10;
+
+  auto state = mx::import_function("init_mlp.mlxfn")({});
+
+  // Make the input
+  mx::random::seed(42);
+  auto example_X = mx::random::normal({batch_size, input_dim});
+  auto example_y = mx::random::randint(0, output_dim, {batch_size});
+
+  // Import the function
+  auto step = mx::import_function("train_mlp.mlxfn");
+
+  // Call the imported function
+  for (int it = 0; it < 100; ++it) {
+    state.insert(state.end(), {example_X, example_y});
+    state = step(state);
+    eval(state);
+    auto loss = state.back();
+    state.pop_back();
+    if (it % 10 == 0) {
+      std::cout << "Loss " << loss.item<float>() << std::endl;
+    }
+  }
+  return 0;
+}
diff --git a/ml-stable-diffusion/mlx/examples/export/train_mlp.py b/ml-stable-diffusion/mlx/examples/export/train_mlp.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e19650a14c06f55c870c0b97a23e81505dbdc52
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/export/train_mlp.py
@@ -0,0 +1,76 @@
+# Copyright © 2024 Apple Inc.
+
+import mlx.core as mx
+import mlx.nn as nn
+import mlx.optimizers as optim
+import mlx.utils
+
+
+class MLP(nn.Module):
+    """A simple MLP."""
+
+    def __init__(
+        self, num_layers: int, input_dim: int, hidden_dim: int, output_dim: int
+    ):
+        super().__init__()
+        layer_sizes = [input_dim] + [hidden_dim] * num_layers + [output_dim]
+        self.layers = [
+            nn.Linear(idim, odim)
+            for idim, odim in zip(layer_sizes[:-1], layer_sizes[1:])
+        ]
+
+    def __call__(self, x):
+        for l in self.layers[:-1]:
+            x = nn.relu(l(x))
+        return self.layers[-1](x)
+
+
+if __name__ == "__main__":
+
+    batch_size = 8
+    input_dim = 32
+    output_dim = 10
+
+    def init():
+        # Seed for the parameter initialization
+        mx.random.seed(0)
+        model = MLP(
+            num_layers=3, input_dim=input_dim, hidden_dim=64, output_dim=output_dim
+        )
+        optimizer = optim.SGD(learning_rate=1e-1)
+        optimizer.init(model.parameters())
+        state = [model.parameters(), optimizer.state]
+        tree_structure, state = zip(*mlx.utils.tree_flatten(state))
+        return model, optimizer, tree_structure, state
+
+    # Export the model parameter initialization
+    model, optimizer, tree_structure, state = init()
+    mx.eval(state)
+    mx.export_function("init_mlp.mlxfn", lambda: init()[-1])
+
+    def loss_fn(params, X, y):
+        model.update(params)
+        return nn.losses.cross_entropy(model(X), y, reduction="mean")
+
+    def step(*inputs):
+        *state, X, y = inputs
+        params, opt_state = mlx.utils.tree_unflatten(list(zip(tree_structure, state)))
+        optimizer.state = opt_state
+        loss, grads = mx.value_and_grad(loss_fn)(params, X, y)
+        params = optimizer.apply_gradients(grads, params)
+        _, state = zip(*mlx.utils.tree_flatten([params, optimizer.state]))
+        return *state, loss
+
+    # Make some random data
+    mx.random.seed(42)
+    example_X = mx.random.normal(shape=(batch_size, input_dim))
+    example_y = mx.random.randint(low=0, high=output_dim, shape=(batch_size,))
+    mx.export_function("train_mlp.mlxfn", step, *state, example_X, example_y)
+
+    # Export one step of SGD
+    imported_step = mx.import_function("train_mlp.mlxfn")
+
+    for it in range(100):
+        *state, loss = imported_step(*state, example_X, example_y)
+        if it % 10 == 0:
+            print(f"Loss {loss.item():.6}")
diff --git a/ml-stable-diffusion/mlx/examples/extensions/CMakeLists.txt b/ml-stable-diffusion/mlx/examples/extensions/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0f70187209d5111b54b653040637f2731b626497
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/extensions/CMakeLists.txt
@@ -0,0 +1,78 @@
+cmake_minimum_required(VERSION 3.27)
+
+project(_ext LANGUAGES CXX)
+
+# ----------------------------- Setup -----------------------------
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+option(BUILD_SHARED_LIBS "Build extensions as a shared library" ON)
+
+# ----------------------------- Dependencies -----------------------------
+find_package(
+  Python 3.8
+  COMPONENTS Interpreter Development.Module
+  REQUIRED)
+execute_process(
+  COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  OUTPUT_VARIABLE nanobind_ROOT)
+find_package(nanobind CONFIG REQUIRED)
+
+execute_process(
+  COMMAND "${Python_EXECUTABLE}" -m mlx --cmake-dir
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  OUTPUT_VARIABLE MLX_ROOT)
+find_package(MLX CONFIG REQUIRED)
+
+# ----------------------------- Extensions -----------------------------
+
+# Add library
+add_library(mlx_ext)
+
+# Add sources
+target_sources(mlx_ext PUBLIC ${CMAKE_CURRENT_LIST_DIR}/axpby/axpby.cpp)
+
+# Add include headers
+target_include_directories(mlx_ext PUBLIC ${CMAKE_CURRENT_LIST_DIR})
+
+# Link to mlx
+target_link_libraries(mlx_ext PUBLIC mlx)
+
+# ----------------------------- Metal -----------------------------
+
+# Build metallib
+if(MLX_BUILD_METAL)
+  mlx_build_metallib(
+    TARGET
+    mlx_ext_metallib
+    TITLE
+    mlx_ext
+    SOURCES
+    ${CMAKE_CURRENT_LIST_DIR}/axpby/axpby.metal
+    INCLUDE_DIRS
+    ${PROJECT_SOURCE_DIR}
+    ${MLX_INCLUDE_DIRS}
+    OUTPUT_DIRECTORY
+    ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
+
+  add_dependencies(mlx_ext mlx_ext_metallib)
+
+endif()
+
+# ----------------------------- Python Bindings -----------------------------
+nanobind_add_module(
+  _ext
+  NB_STATIC
+  STABLE_ABI
+  LTO
+  NOMINSIZE
+  NB_DOMAIN
+  mlx
+  ${CMAKE_CURRENT_LIST_DIR}/bindings.cpp)
+target_link_libraries(_ext PRIVATE mlx_ext)
+
+if(BUILD_SHARED_LIBS)
+  target_link_options(_ext PRIVATE -Wl,-rpath,@loader_path)
+endif()
diff --git a/ml-stable-diffusion/mlx/examples/extensions/README.md b/ml-stable-diffusion/mlx/examples/extensions/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..610de99f42833a54837135a9845ee236f36f701b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/extensions/README.md
@@ -0,0 +1,24 @@
+
+## Build
+
+```
+pip install -e .
+```
+
+For faster builds during development, you can also pre-install the requirements:
+
+```
+pip install -r requirements.txt
+```
+
+And then run:
+
+```
+python setup.py build_ext -j8 --inplace
+```
+
+## Test
+
+```
+python test.py
+```
diff --git a/ml-stable-diffusion/mlx/examples/extensions/axpby/axpby.cpp b/ml-stable-diffusion/mlx/examples/extensions/axpby/axpby.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..31badbbda97e324cfcb3359fde94e005422a380b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/extensions/axpby/axpby.cpp
@@ -0,0 +1,306 @@
+// Copyright © 2023-2025 Apple Inc.
+
+#include <dlfcn.h>
+#include <iostream>
+#include <sstream>
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/utils.h"
+
+#include "axpby/axpby.h"
+
+#ifdef _METAL_
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/utils.h"
+#endif
+
+namespace my_ext {
+
+// A helper function to find the location of the current binary on disk.
+// The Metal library ("mlx_ext.mtllib"), should be in the same directory.
+std::string current_binary_dir() {
+  static std::string binary_dir = []() {
+    Dl_info info;
+    if (!dladdr(reinterpret_cast<void*>(&current_binary_dir), &info)) {
+      throw std::runtime_error("Unable to get current binary dir.");
+    }
+    return std::filesystem::path(info.dli_fname).parent_path().string();
+  }();
+  return binary_dir;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Operation Implementation
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Scale and sum two vectors element-wise
+ *  z = alpha * x + beta * y
+ *
+ *  Follow numpy style broadcasting between x and y
+ *  Inputs are upcasted to floats if needed
+ **/
+mx::array axpby(
+    const mx::array& x, // Input mx::array x
+    const mx::array& y, // Input mx::array y
+    const float alpha, // Scaling factor for x
+    const float beta, // Scaling factor for y
+    mx::StreamOrDevice s /* = {} */ // Stream on which to schedule the operation
+) {
+  // Promote dtypes between x and y as needed
+  auto promoted_dtype = promote_types(x.dtype(), y.dtype());
+
+  // Upcast to float32 for non-floating point inputs x and y
+  auto out_dtype = mx::issubdtype(promoted_dtype, mx::float32)
+      ? promoted_dtype
+      : promote_types(promoted_dtype, mx::float32);
+
+  // Cast x and y up to the determined dtype (on the same stream s)
+  auto x_casted = mx::astype(x, out_dtype, s);
+  auto y_casted = mx::astype(y, out_dtype, s);
+
+  // Broadcast the shapes of x and y (on the same stream s)
+  auto broadcasted_inputs = broadcast_arrays({x_casted, y_casted}, s);
+  auto out_shape = broadcasted_inputs[0].shape();
+
+  // Construct the array as the output of the Axpby primitive
+  // with the broadcasted and upcasted arrays as inputs
+  return mx::array(
+      /* const mx::Shape& shape = */ out_shape,
+      /* mx::Dtype dtype = */ out_dtype,
+      /* std::shared_ptr<mx::Primitive> primitive = */
+      std::make_shared<Axpby>(to_stream(s), alpha, beta),
+      /* const std::vector<mx::array>& inputs = */ broadcasted_inputs);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Primitive Common Backend Implementation
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+void axpby_impl(
+    const mx::array& x,
+    const mx::array& y,
+    mx::array& out,
+    float alpha_,
+    float beta_,
+    mx::Stream stream) {
+  out.set_data(mx::allocator::malloc(out.nbytes()));
+
+  // Get the CPU command encoder and register input and output arrays
+  auto& encoder = mx::cpu::get_command_encoder(stream);
+  encoder.set_input_array(x);
+  encoder.set_input_array(y);
+  encoder.set_output_array(out);
+
+  // Launch the CPU kernel
+  encoder.dispatch([x_ptr = x.data<T>(),
+                    y_ptr = y.data<T>(),
+                    out_ptr = out.data<T>(),
+                    size = out.size(),
+                    shape = out.shape(),
+                    x_strides = x.strides(),
+                    y_strides = y.strides(),
+                    alpha_,
+                    beta_]() {
+    // Cast alpha and beta to the relevant types
+    T alpha = static_cast<T>(alpha_);
+    T beta = static_cast<T>(beta_);
+
+    // Do the element-wise operation for each output
+    for (size_t out_idx = 0; out_idx < size; out_idx++) {
+      // Map linear indices to offsets in x and y
+      auto x_offset = mx::elem_to_loc(out_idx, shape, x_strides);
+      auto y_offset = mx::elem_to_loc(out_idx, shape, y_strides);
+
+      // We allocate the output to be contiguous and regularly strided
+      // (defaults to row major) and hence it doesn't need additional mapping
+      out_ptr[out_idx] = alpha * x_ptr[x_offset] + beta * y_ptr[y_offset];
+    }
+  });
+}
+
+void Axpby::eval_cpu(
+    const std::vector<mx::array>& inputs,
+    std::vector<mx::array>& outputs) {
+  auto& x = inputs[0];
+  auto& y = inputs[1];
+  auto& out = outputs[0];
+
+  // Dispatch to the correct dtype
+  if (out.dtype() == mx::float32) {
+    return axpby_impl<float>(x, y, out, alpha_, beta_, stream());
+  } else if (out.dtype() == mx::float16) {
+    return axpby_impl<mx::float16_t>(x, y, out, alpha_, beta_, stream());
+  } else if (out.dtype() == mx::bfloat16) {
+    return axpby_impl<mx::bfloat16_t>(x, y, out, alpha_, beta_, stream());
+  } else if (out.dtype() == mx::complex64) {
+    return axpby_impl<mx::complex64_t>(x, y, out, alpha_, beta_, stream());
+  } else {
+    throw std::runtime_error(
+        "Axpby is only supported for floating point types.");
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Primitive Metal Backend Implementation
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef _METAL_
+
+/** Evaluate primitive on GPU */
+void Axpby::eval_gpu(
+    const std::vector<mx::array>& inputs,
+    std::vector<mx::array>& outputs) {
+  // Prepare inputs
+  auto& x = inputs[0];
+  auto& y = inputs[1];
+  auto& out = outputs[0];
+
+  // Each primitive carries the stream it should execute on
+  // and each stream carries its device identifiers
+  auto& s = stream();
+  // We get the needed metal device using the stream
+  auto& d = mx::metal::device(s.device);
+
+  // Prepare to specialize based on contiguity
+  bool contiguous_kernel =
+      (x.flags().row_contiguous && y.flags().row_contiguous) ||
+      (x.flags().col_contiguous && y.flags().col_contiguous);
+
+  // Allocate output memory with strides based on specialization
+  if (contiguous_kernel) {
+    out.set_data(
+        mx::allocator::malloc(x.data_size() * out.itemsize()),
+        x.data_size(),
+        x.strides(),
+        x.flags());
+  } else {
+    out.set_data(mx::allocator::malloc(out.nbytes()));
+  }
+
+  // Resolve name of kernel (corresponds to axpby.metal)
+  std::string kname = "axpby_";
+  kname += (contiguous_kernel ? "contiguous_" : "general_");
+  kname += type_to_name(out);
+
+  // Load the metal library
+  auto lib = d.get_library("mlx_ext", current_binary_dir());
+
+  // Make a kernel from this metal library
+  auto kernel = d.get_kernel(kname, lib);
+
+  // Prepare to encode kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Kernel parameters are registered with buffer indices corresponding to
+  // those in the kernel declaration at axpby.metal
+  int ndim = out.ndim();
+  size_t nelem = out.size();
+
+  // Encode input arrays to kernel
+  compute_encoder.set_input_array(x, 0);
+  compute_encoder.set_input_array(y, 1);
+
+  // Encode output arrays to kernel
+  compute_encoder.set_output_array(out, 2);
+
+  // Encode alpha and beta
+  compute_encoder.set_bytes(alpha_, 3);
+  compute_encoder.set_bytes(beta_, 4);
+
+  // Encode shape, strides and ndim if needed
+  if (!contiguous_kernel) {
+    compute_encoder.set_vector_bytes(x.shape(), 5);
+    compute_encoder.set_vector_bytes(x.strides(), 6);
+    compute_encoder.set_vector_bytes(y.strides(), 7);
+    compute_encoder.set_bytes(ndim, 8);
+  }
+
+  // We launch 1 thread for each input and make sure that the number of
+  // threads in any given threadgroup is not higher than the max allowed
+  size_t tgp_size = std::min(nelem, kernel->maxTotalThreadsPerThreadgroup());
+
+  // Fix the 3D size of each threadgroup (in terms of threads)
+  MTL::Size group_dims = MTL::Size(tgp_size, 1, 1);
+
+  // Fix the 3D size of the launch grid (in terms of threads)
+  MTL::Size grid_dims = MTL::Size(nelem, 1, 1);
+
+  // Launch the grid with the given number of threads divided among
+  // the given threadgroups
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+#else // Metal is not available
+
+/** Fail evaluation on GPU */
+void Axpby::eval_gpu(
+    const std::vector<mx::array>& inputs,
+    std::vector<mx::array>& out) {
+  throw std::runtime_error("Axpby has no GPU implementation.");
+}
+
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Primitive Transforms
+///////////////////////////////////////////////////////////////////////////////
+
+/** The Jacobian-vector product. */
+std::vector<mx::array> Axpby::jvp(
+    const std::vector<mx::array>& primals,
+    const std::vector<mx::array>& tangents,
+    const std::vector<int>& argnums) {
+  // Forward mode diff that pushes along the tangents
+  // The jvp transform on the primitive can built with ops
+  // that are scheduled on the same stream as the primitive
+
+  // If argnums = {0}, we only push along x in which case the
+  // jvp is just the tangent scaled by alpha
+  // Similarly, if argnums = {1}, the jvp is just the tangent
+  // scaled by beta
+  if (argnums.size() > 1) {
+    auto scale = argnums[0] == 0 ? alpha_ : beta_;
+    auto scale_arr = mx::array(scale, tangents[0].dtype());
+    return {mx::multiply(scale_arr, tangents[0], stream())};
+  }
+  // If, argnums = {0, 1}, we take contributions from both
+  // which gives us jvp = tangent_x * alpha + tangent_y * beta
+  else {
+    return {axpby(tangents[0], tangents[1], alpha_, beta_, stream())};
+  }
+}
+
+/** The vector-Jacobian product. */
+std::vector<mx::array> Axpby::vjp(
+    const std::vector<mx::array>& primals,
+    const std::vector<mx::array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<mx::array>&) {
+  // Reverse mode diff
+  std::vector<mx::array> vjps;
+  for (auto arg : argnums) {
+    auto scale = arg == 0 ? alpha_ : beta_;
+    auto scale_arr = mx::array(scale, cotangents[0].dtype());
+    vjps.push_back(mx::multiply(scale_arr, cotangents[0], stream()));
+  }
+  return vjps;
+}
+
+/** Vectorize primitive along given axis */
+std::pair<std::vector<mx::array>, std::vector<int>> Axpby::vmap(
+    const std::vector<mx::array>& inputs,
+    const std::vector<int>& axes) {
+  throw std::runtime_error("Axpby has no vmap implementation.");
+}
+
+/** Equivalence check **/
+bool Axpby::is_equivalent(const Primitive& other) const {
+  const Axpby& r_other = static_cast<const Axpby&>(other);
+  return alpha_ == r_other.alpha_ && beta_ == r_other.beta_;
+}
+
+} // namespace my_ext
diff --git a/ml-stable-diffusion/mlx/examples/extensions/axpby/axpby.h b/ml-stable-diffusion/mlx/examples/extensions/axpby/axpby.h
new file mode 100644
index 0000000000000000000000000000000000000000..e6da491f8c157501527930eb311589574af24c80
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/extensions/axpby/axpby.h
@@ -0,0 +1,90 @@
+// Copyright © 2023-2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/ops.h"
+#include "mlx/primitives.h"
+
+namespace mx = mlx::core;
+
+namespace my_ext {
+
+///////////////////////////////////////////////////////////////////////////////
+// Operation
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Scale and sum two vectors element-wise
+ *  z = alpha * x + beta * y
+ *
+ *  Follow numpy style broadcasting between x and y
+ *  Inputs are upcasted to floats if needed
+ **/
+mx::array axpby(
+    const mx::array& x, // Input array x
+    const mx::array& y, // Input array y
+    const float alpha, // Scaling factor for x
+    const float beta, // Scaling factor for y
+    mx::StreamOrDevice s = {} // Stream on which to schedule the operation
+);
+
+///////////////////////////////////////////////////////////////////////////////
+// Primitive
+///////////////////////////////////////////////////////////////////////////////
+
+class Axpby : public mx::Primitive {
+ public:
+  explicit Axpby(mx::Stream stream, float alpha, float beta)
+      : mx::Primitive(stream), alpha_(alpha), beta_(beta) {};
+
+  /**
+   * A primitive must know how to evaluate itself on the CPU/GPU
+   * for the given inputs and populate the output array.
+   *
+   * To avoid unnecessary allocations, the evaluation function
+   * is responsible for allocating space for the array.
+   */
+  void eval_cpu(
+      const std::vector<mx::array>& inputs,
+      std::vector<mx::array>& outputs) override;
+  void eval_gpu(
+      const std::vector<mx::array>& inputs,
+      std::vector<mx::array>& outputs) override;
+
+  /** The Jacobian-vector product. */
+  std::vector<mx::array> jvp(
+      const std::vector<mx::array>& primals,
+      const std::vector<mx::array>& tangents,
+      const std::vector<int>& argnums) override;
+
+  /** The vector-Jacobian product. */
+  std::vector<mx::array> vjp(
+      const std::vector<mx::array>& primals,
+      const std::vector<mx::array>& cotangents,
+      const std::vector<int>& argnums,
+      const std::vector<mx::array>& outputs) override;
+
+  /**
+   * The primitive must know how to vectorize itself across
+   * the given axes. The output is a pair containing the array
+   * representing the vectorized computation and the axis which
+   * corresponds to the output vectorized dimension.
+   */
+  std::pair<std::vector<mx::array>, std::vector<int>> vmap(
+      const std::vector<mx::array>& inputs,
+      const std::vector<int>& axes) override;
+
+  /** The name of primitive. */
+  const char* name() const override {
+    return "Axpby";
+  }
+
+  /** Equivalence check **/
+  bool is_equivalent(const mx::Primitive& other) const override;
+
+ private:
+  float alpha_;
+  float beta_;
+};
+
+} // namespace my_ext
diff --git a/ml-stable-diffusion/mlx/examples/extensions/axpby/axpby.metal b/ml-stable-diffusion/mlx/examples/extensions/axpby/axpby.metal
new file mode 100644
index 0000000000000000000000000000000000000000..ce8c5452044952846866e219330d86444109a832
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/extensions/axpby/axpby.metal
@@ -0,0 +1,47 @@
+// Copyright © 2023-2025 Apple Inc.
+
+#include <metal_stdlib>
+
+#include "mlx/backend/metal/kernels/utils.h"
+
+template <typename T>
+[[kernel]] void axpby_general(
+    device const T* x [[buffer(0)]],
+    device const T* y [[buffer(1)]],
+    device T* out [[buffer(2)]],
+    constant const float& alpha [[buffer(3)]],
+    constant const float& beta [[buffer(4)]],
+    constant const int* shape [[buffer(5)]],
+    constant const int64_t* x_strides [[buffer(6)]],
+    constant const int64_t* y_strides [[buffer(7)]],
+    constant const int& ndim [[buffer(8)]],
+    uint index [[thread_position_in_grid]]) {
+  auto x_offset = elem_to_loc(index, shape, x_strides, ndim);
+  auto y_offset = elem_to_loc(index, shape, y_strides, ndim);
+  out[index] =
+      static_cast<T>(alpha) * x[x_offset] + static_cast<T>(beta) * y[y_offset];
+}
+
+template <typename T>
+[[kernel]] void axpby_contiguous(
+    device const T* x [[buffer(0)]],
+    device const T* y [[buffer(1)]],
+    device T* out [[buffer(2)]],
+    constant const float& alpha [[buffer(3)]],
+    constant const float& beta [[buffer(4)]],
+    uint index [[thread_position_in_grid]]) {
+  out[index] =
+      static_cast<T>(alpha) * x[index] + static_cast<T>(beta) * y[index];
+}
+
+// clang-format off
+#define instantiate_axpby(type_name, type)                             \
+  instantiate_kernel("axpby_general_" #type_name, axpby_general, type) \
+  instantiate_kernel(                                                  \
+          "axpby_contiguous_" #type_name, axpby_contiguous, type)
+
+instantiate_axpby(float32, float);
+instantiate_axpby(float16, half);
+instantiate_axpby(bfloat16, bfloat16_t);
+instantiate_axpby(complex64, complex64_t);
+// clang-format on
diff --git a/ml-stable-diffusion/mlx/examples/extensions/bindings.cpp b/ml-stable-diffusion/mlx/examples/extensions/bindings.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..91892fa90328a90f8acac0981d99886cf564bc42
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/extensions/bindings.cpp
@@ -0,0 +1,39 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/variant.h>
+
+#include "axpby/axpby.h"
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+NB_MODULE(_ext, m) {
+  m.doc() = "Sample extension for MLX";
+
+  m.def(
+      "axpby",
+      &my_ext::axpby,
+      "x"_a,
+      "y"_a,
+      "alpha"_a,
+      "beta"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      R"(
+        Scale and sum two vectors element-wise
+        ``z = alpha * x + beta * y``
+
+        Follows numpy style broadcasting between ``x`` and ``y``
+        Inputs are upcasted to floats if needed
+
+        Args:
+            x (array): Input array.
+            y (array): Input array.
+            alpha (float): Scaling factor for ``x``.
+            beta (float): Scaling factor for ``y``.
+
+        Returns:
+            array: ``alpha * x + beta * y``
+      )");
+}
diff --git a/ml-stable-diffusion/mlx/examples/extensions/mlx_sample_extensions/__init__.py b/ml-stable-diffusion/mlx/examples/extensions/mlx_sample_extensions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b56a54fd2c0f8435ff65c2d1a307a5704e920af6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/extensions/mlx_sample_extensions/__init__.py
@@ -0,0 +1,5 @@
+# Copyright © 2023 Apple Inc.
+
+import mlx.core as mx
+
+from ._ext import axpby
diff --git a/ml-stable-diffusion/mlx/examples/extensions/pyproject.toml b/ml-stable-diffusion/mlx/examples/extensions/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9f0f09752df6942637e8df471b637f57b65894b0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/extensions/pyproject.toml
@@ -0,0 +1,8 @@
+[build-system]
+requires = [
+  "setuptools>=42",
+  "cmake>=3.25",
+  "mlx>=0.18.0",
+  "nanobind==2.4.0",
+]
+build-backend = "setuptools.build_meta"
diff --git a/ml-stable-diffusion/mlx/examples/extensions/requirements.txt b/ml-stable-diffusion/mlx/examples/extensions/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a4591df8cc6fcbc39de392755d2895b5ae74833b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/extensions/requirements.txt
@@ -0,0 +1,4 @@
+setuptools>=42
+cmake>=3.25
+mlx>=0.21.0
+nanobind==2.4.0
diff --git a/ml-stable-diffusion/mlx/examples/extensions/setup.py b/ml-stable-diffusion/mlx/examples/extensions/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..8dd1186ab8b6fc3a452e54a4055e90fb3505d2eb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/extensions/setup.py
@@ -0,0 +1,18 @@
+# Copyright © 2023-2024 Apple Inc.
+
+from setuptools import setup
+
+from mlx import extension
+
+if __name__ == "__main__":
+    setup(
+        name="mlx_sample_extensions",
+        version="0.0.0",
+        description="Sample C++ and Metal extensions for MLX primitives.",
+        ext_modules=[extension.CMakeExtension("mlx_sample_extensions._ext")],
+        cmdclass={"build_ext": extension.CMakeBuild},
+        packages=["mlx_sample_extensions"],
+        package_data={"mlx_sample_extensions": ["*.so", "*.dylib", "*.metallib"]},
+        zip_safe=False,
+        python_requires=">=3.8",
+    )
diff --git a/ml-stable-diffusion/mlx/examples/extensions/test.py b/ml-stable-diffusion/mlx/examples/extensions/test.py
new file mode 100644
index 0000000000000000000000000000000000000000..4190fe99626e841e6f962ed1eb5e82a742024ff4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/extensions/test.py
@@ -0,0 +1,12 @@
+import mlx.core as mx
+from mlx_sample_extensions import axpby
+
+a = mx.ones((3, 4))
+b = mx.ones((3, 4))
+c_cpu = axpby(a, b, 4.0, 2.0, stream=mx.cpu)
+c_gpu = axpby(a, b, 4.0, 2.0, stream=mx.gpu)
+
+print(f"c shape: {c_cpu.shape}")
+print(f"c dtype: {c_cpu.dtype}")
+print(f"c_cpu correct: {mx.all(c_cpu == 6.0).item()}")
+print(f"c_gpu correct: {mx.all(c_gpu == 6.0).item()}")
diff --git a/ml-stable-diffusion/mlx/examples/python/linear_regression.py b/ml-stable-diffusion/mlx/examples/python/linear_regression.py
new file mode 100644
index 0000000000000000000000000000000000000000..c247d1701464cd89615fd9cee87de3d15e6f1a53
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/python/linear_regression.py
@@ -0,0 +1,46 @@
+# Copyright © 2023 Apple Inc.
+
+import time
+
+import mlx.core as mx
+
+num_features = 100
+num_examples = 1_000
+num_iters = 10_000
+lr = 0.01
+
+# True parameters
+w_star = mx.random.normal((num_features,))
+
+# Input examples (design matrix)
+X = mx.random.normal((num_examples, num_features))
+
+# Noisy labels
+eps = 1e-2 * mx.random.normal((num_examples,))
+y = X @ w_star + eps
+
+# Initialize random parameters
+w = 1e-2 * mx.random.normal((num_features,))
+
+
+def loss_fn(w):
+    return 0.5 * mx.mean(mx.square(X @ w - y))
+
+
+grad_fn = mx.grad(loss_fn)
+
+tic = time.time()
+for _ in range(num_iters):
+    grad = grad_fn(w)
+    w = w - lr * grad
+    mx.eval(w)
+toc = time.time()
+
+loss = loss_fn(w)
+error_norm = mx.sum(mx.square(w - w_star)).item() ** 0.5
+throughput = num_iters / (toc - tic)
+
+print(
+    f"Loss {loss.item():.5f}, L2 distance: |w-w*| = {error_norm:.5f}, "
+    f"Throughput {throughput:.5f} (it/s)"
+)
diff --git a/ml-stable-diffusion/mlx/examples/python/logistic_regression.py b/ml-stable-diffusion/mlx/examples/python/logistic_regression.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce6c1f53f43ec8f46965d660cf7cc79a3578a575
--- /dev/null
+++ b/ml-stable-diffusion/mlx/examples/python/logistic_regression.py
@@ -0,0 +1,49 @@
+# Copyright © 2023 Apple Inc.
+
+import time
+
+import mlx.core as mx
+
+num_features = 100
+num_examples = 1_000
+num_iters = 10_000
+lr = 0.1
+
+# True parameters
+w_star = mx.random.normal((num_features,))
+
+# Input examples
+X = mx.random.normal((num_examples, num_features))
+
+# Labels
+y = (X @ w_star) > 0
+
+
+# Initialize random parameters
+w = 1e-2 * mx.random.normal((num_features,))
+
+
+def loss_fn(w):
+    logits = X @ w
+    return mx.mean(mx.logaddexp(0.0, logits) - y * logits)
+
+
+grad_fn = mx.grad(loss_fn)
+
+tic = time.time()
+for _ in range(num_iters):
+    grad = grad_fn(w)
+    w = w - lr * grad
+    mx.eval(w)
+
+toc = time.time()
+
+loss = loss_fn(w)
+final_preds = (X @ w) > 0
+acc = mx.mean(final_preds == y)
+
+throughput = num_iters / (toc - tic)
+print(
+    f"Loss {loss.item():.5f}, Accuracy {acc.item():.5f} "
+    f"Throughput {throughput:.5f} (it/s)"
+)
diff --git a/ml-stable-diffusion/mlx/mlx.pc.in b/ml-stable-diffusion/mlx/mlx.pc.in
new file mode 100644
index 0000000000000000000000000000000000000000..c4e2515d71cde3fa636616c4cbc3b723ee66dac2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx.pc.in
@@ -0,0 +1,52 @@
+# Find MLX
+#
+# Defines the following variables:
+#
+#   MLX_FOUND            : True if MLX is found
+#   MLX_INCLUDE_DIRS     : Include directory
+#   MLX_LIBRARIES        : Libraries to link against
+#   MLX_CXX_FLAGS        : Additional compiler flags
+#   MLX_BUILD_ACCELERATE : True if MLX was built with accelerate 
+#   MLX_BUILD_METAL      : True if MLX was built with metal 
+
+@PACKAGE_INIT@
+
+include(@PACKAGE_MLX_CMAKE_INSTALL_MODULE_DIR@/MLXTargets.cmake)
+include(@PACKAGE_MLX_CMAKE_INSTALL_MODULE_DIR@/extension.cmake)
+
+set_and_check(MLX_LIBRARY_DIRS @PACKAGE_CMAKE_INSTALL_LIBDIR@)
+set_and_check(MLX_INCLUDE_DIRS @PACKAGE_CMAKE_INSTALL_INCLUDEDIR@)
+set(MLX_LIBRARIES mlx)
+
+find_library(MLX_LIBRARY mlx PATHS ${MLX_LIBRARY_DIRS})
+
+if (@MLX_BUILD_ACCELERATE@)
+    set(MLX_BUILD_ACCELERATE @MLX_BUILD_ACCELERATE@)
+    set(MLX_CXX_FLAGS ${MLX_CXX_FLAGS} -DACCELERATE_NEW_LAPACK)
+endif()
+
+if (@MLX_BUILD_METAL@)
+    set(MLX_BUILD_METAL @MLX_BUILD_METAL@)
+    set(MLX_CXX_FLAGS ${MLX_CXX_FLAGS} -D_METAL_)
+    set(MLX_INCLUDE_DIRS 
+        "${MLX_INCLUDE_DIRS};"
+        @PACKAGE_CMAKE_INSTALL_INCLUDEDIR@/metal_cpp
+    )
+    if(@MLX_METAL_VERSION@ GREATER_EQUAL 310)
+      set(MLX_INCLUDE_DIRS
+        "${MLX_INCLUDE_DIRS};"
+        @PACKAGE_CMAKE_INSTALL_INCLUDEDIR@/mlx/backend/metal/kernels/metal_3_1)
+    else()
+      set(MLX_INCLUDE_DIRS
+        "${MLX_INCLUDE_DIRS};"
+        @PACKAGE_CMAKE_INSTALL_INCLUDEDIR@/mlx/backend/metal/kernels/metal_3_0)
+    endif()
+endif()
+
+set_target_properties(mlx PROPERTIES
+    CXX_STANDARD 17
+    INTERFACE_COMPILE_OPTIONS "${MLX_CXX_FLAGS}"
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(MLX DEFAULT_MSG MLX_LIBRARY MLX_INCLUDE_DIRS)
diff --git a/ml-stable-diffusion/mlx/mlx/3rdparty/.clang-format b/ml-stable-diffusion/mlx/mlx/3rdparty/.clang-format
new file mode 100644
index 0000000000000000000000000000000000000000..47a38a93f2dbdd6d944f9dddc3465e3fb65aec29
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/3rdparty/.clang-format
@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: Never
diff --git a/ml-stable-diffusion/mlx/mlx/3rdparty/pocketfft.h b/ml-stable-diffusion/mlx/mlx/3rdparty/pocketfft.h
new file mode 100644
index 0000000000000000000000000000000000000000..03a45897a0f0cd664167380a4739f46fab68755d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/3rdparty/pocketfft.h
@@ -0,0 +1,3581 @@
+/*
+This file is part of pocketfft.
+
+Copyright (C) 2010-2022 Max-Planck-Society
+Copyright (C) 2019-2020 Peter Bell
+
+For the odd-sized DCT-IV transforms:
+  Copyright (C) 2003, 2007-14 Matteo Frigo
+  Copyright (C) 2003, 2007-14 Massachusetts Institute of Technology
+
+Authors: Martin Reinecke, Peter Bell
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+* Neither the name of the copyright holder nor the names of its contributors may
+  be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef POCKETFFT_HDRONLY_H
+#define POCKETFFT_HDRONLY_H
+
+#ifndef __cplusplus
+#error This file is C++ and requires a C++ compiler.
+#endif
+
+#if !(__cplusplus >= 201103L || _MSVC_LANG+0L >= 201103L)
+#error This file requires at least C++11 support.
+#endif
+
+#ifndef POCKETFFT_CACHE_SIZE
+#define POCKETFFT_CACHE_SIZE 0
+#endif
+
+#include <cmath>
+#include <cstdlib>
+#include <stdexcept>
+#include <memory>
+#include <vector>
+#include <complex>
+#include <algorithm>
+#if POCKETFFT_CACHE_SIZE!=0
+#include <array>
+#include <mutex>
+#endif
+
+#ifndef POCKETFFT_NO_MULTITHREADING
+#include <mutex>
+#include <condition_variable>
+#include <thread>
+#include <queue>
+#include <atomic>
+#include <functional>
+#include <new>
+
+#ifdef POCKETFFT_PTHREADS
+#  include <pthread.h>
+#endif
+#endif
+
+#if defined(__GNUC__)
+#define POCKETFFT_NOINLINE __attribute__((noinline))
+#define POCKETFFT_RESTRICT __restrict__
+#elif defined(_MSC_VER)
+#define POCKETFFT_NOINLINE __declspec(noinline)
+#define POCKETFFT_RESTRICT __restrict
+#else
+#define POCKETFFT_NOINLINE
+#define POCKETFFT_RESTRICT
+#endif
+
+namespace pocketfft {
+
+namespace detail {
+using std::size_t;
+using std::ptrdiff_t;
+
+// Always use std:: for <cmath> functions
+template <typename T> T cos(T) = delete;
+template <typename T> T sin(T) = delete;
+template <typename T> T sqrt(T) = delete;
+
+using shape_t = std::vector<size_t>;
+using stride_t = std::vector<ptrdiff_t>;
+
+constexpr bool FORWARD  = true,
+               BACKWARD = false;
+
+// only enable vector support for gcc>=5.0 and clang>=5.0
+#ifndef POCKETFFT_NO_VECTORS
+#define POCKETFFT_NO_VECTORS
+#if defined(__INTEL_COMPILER)
+// do nothing. This is necessary because this compiler also sets __GNUC__.
+#elif defined(__clang__)
+// AppleClang has their own version numbering
+#ifdef __apple_build_version__
+#  if (__clang_major__ > 9) || (__clang_major__ == 9 && __clang_minor__ >= 1)
+#     undef POCKETFFT_NO_VECTORS
+#  endif
+#elif __clang_major__ >= 5
+#  undef POCKETFFT_NO_VECTORS
+#endif
+#elif defined(__GNUC__)
+#if __GNUC__>=5
+#undef POCKETFFT_NO_VECTORS
+#endif
+#endif
+#endif
+
+template<typename T> struct VLEN { static constexpr size_t val=1; };
+
+#ifndef POCKETFFT_NO_VECTORS
+#if (defined(__AVX512F__))
+template<> struct VLEN<float> { static constexpr size_t val=16; };
+template<> struct VLEN<double> { static constexpr size_t val=8; };
+#elif (defined(__AVX__))
+template<> struct VLEN<float> { static constexpr size_t val=8; };
+template<> struct VLEN<double> { static constexpr size_t val=4; };
+#elif (defined(__SSE2__))
+template<> struct VLEN<float> { static constexpr size_t val=4; };
+template<> struct VLEN<double> { static constexpr size_t val=2; };
+#elif (defined(__VSX__))
+template<> struct VLEN<float> { static constexpr size_t val=4; };
+template<> struct VLEN<double> { static constexpr size_t val=2; };
+#elif (defined(__ARM_NEON__) || defined(__ARM_NEON))
+template<> struct VLEN<float> { static constexpr size_t val=4; };
+template<> struct VLEN<double> { static constexpr size_t val=2; };
+#else
+#define POCKETFFT_NO_VECTORS
+#endif
+#endif
+
+// the __MINGW32__ part in the conditional below works around the problem that
+// the standard C++ library on Windows does not provide aligned_alloc() even
+// though the MinGW compiler and MSVC may advertise C++17 compliance.
+#if (__cplusplus >= 201703L) && (!defined(__MINGW32__)) && (!defined(_MSC_VER))
+inline void *aligned_alloc(size_t align, size_t size)
+  {
+  // aligned_alloc() requires that the requested size is a multiple of "align"
+  void *ptr = ::aligned_alloc(align,(size+align-1)&(~(align-1)));
+  if (!ptr) throw std::bad_alloc();
+  return ptr;
+  }
+inline void aligned_dealloc(void *ptr)
+    { free(ptr); }
+#else // portable emulation
+inline void *aligned_alloc(size_t align, size_t size)
+  {
+  align = std::max(align, alignof(max_align_t));
+  void *ptr = malloc(size+align);
+  if (!ptr) throw std::bad_alloc();
+  void *res = reinterpret_cast<void *>
+    ((reinterpret_cast<uintptr_t>(ptr) & ~(uintptr_t(align-1))) + uintptr_t(align));
+  (reinterpret_cast<void**>(res))[-1] = ptr;
+  return res;
+  }
+inline void aligned_dealloc(void *ptr)
+  { if (ptr) free((reinterpret_cast<void**>(ptr))[-1]); }
+#endif
+
+template<typename T> class arr
+  {
+  private:
+    T *p;
+    size_t sz;
+
+#if defined(POCKETFFT_NO_VECTORS)
+    static T *ralloc(size_t num)
+      {
+      if (num==0) return nullptr;
+      void *res = malloc(num*sizeof(T));
+      if (!res) throw std::bad_alloc();
+      return reinterpret_cast<T *>(res);
+      }
+    static void dealloc(T *ptr)
+      { free(ptr); }
+#else
+    static T *ralloc(size_t num)
+      {
+      if (num==0) return nullptr;
+      void *ptr = aligned_alloc(64, num*sizeof(T));
+      return static_cast<T*>(ptr);
+      }
+    static void dealloc(T *ptr)
+      { aligned_dealloc(ptr); }
+#endif
+
+  public:
+    arr() : p(0), sz(0) {}
+    arr(size_t n) : p(ralloc(n)), sz(n) {}
+    arr(arr &&other)
+      : p(other.p), sz(other.sz)
+      { other.p=nullptr; other.sz=0; }
+    ~arr() { dealloc(p); }
+
+    void resize(size_t n)
+      {
+      if (n==sz) return;
+      dealloc(p);
+      p = ralloc(n);
+      sz = n;
+      }
+
+    T &operator[](size_t idx) { return p[idx]; }
+    const T &operator[](size_t idx) const { return p[idx]; }
+
+    T *data() { return p; }
+    const T *data() const { return p; }
+
+    size_t size() const { return sz; }
+  };
+
+template<typename T> struct cmplx {
+  T r, i;
+  cmplx() {}
+  cmplx(T r_, T i_) : r(r_), i(i_) {}
+  void Set(T r_, T i_) { r=r_; i=i_; }
+  void Set(T r_) { r=r_; i=T(0); }
+  cmplx &operator+= (const cmplx &other)
+    { r+=other.r; i+=other.i; return *this; }
+  template<typename T2>cmplx &operator*= (T2 other)
+    { r*=other; i*=other; return *this; }
+  template<typename T2>cmplx &operator*= (const cmplx<T2> &other)
+    {
+    T tmp = r*other.r - i*other.i;
+    i = r*other.i + i*other.r;
+    r = tmp;
+    return *this;
+    }
+  template<typename T2>cmplx &operator+= (const cmplx<T2> &other)
+    { r+=other.r; i+=other.i; return *this; }
+  template<typename T2>cmplx &operator-= (const cmplx<T2> &other)
+    { r-=other.r; i-=other.i; return *this; }
+  template<typename T2> auto operator* (const T2 &other) const
+    -> cmplx<decltype(r*other)>
+    { return {r*other, i*other}; }
+  template<typename T2> auto operator+ (const cmplx<T2> &other) const
+    -> cmplx<decltype(r+other.r)>
+    { return {r+other.r, i+other.i}; }
+  template<typename T2> auto operator- (const cmplx<T2> &other) const
+    -> cmplx<decltype(r+other.r)>
+    { return {r-other.r, i-other.i}; }
+  template<typename T2> auto operator* (const cmplx<T2> &other) const
+    -> cmplx<decltype(r+other.r)>
+    { return {r*other.r-i*other.i, r*other.i + i*other.r}; }
+  template<bool fwd, typename T2> auto special_mul (const cmplx<T2> &other) const
+    -> cmplx<decltype(r+other.r)>
+    {
+    using Tres = cmplx<decltype(r+other.r)>;
+    return fwd ? Tres(r*other.r+i*other.i, i*other.r-r*other.i)
+               : Tres(r*other.r-i*other.i, r*other.i+i*other.r);
+    }
+};
+template<typename T> inline void PM(T &a, T &b, T c, T d)
+  { a=c+d; b=c-d; }
+template<typename T> inline void PMINPLACE(T &a, T &b)
+  { T t = a; a+=b; b=t-b; }
+template<typename T> inline void MPINPLACE(T &a, T &b)
+  { T t = a; a-=b; b=t+b; }
+template<typename T> cmplx<T> conj(const cmplx<T> &a)
+  { return {a.r, -a.i}; }
+template<bool fwd, typename T, typename T2> void special_mul (const cmplx<T> &v1, const cmplx<T2> &v2, cmplx<T> &res)
+  {
+  res = fwd ? cmplx<T>(v1.r*v2.r+v1.i*v2.i, v1.i*v2.r-v1.r*v2.i)
+            : cmplx<T>(v1.r*v2.r-v1.i*v2.i, v1.r*v2.i+v1.i*v2.r);
+  }
+
+template<typename T> void ROT90(cmplx<T> &a)
+  { auto tmp_=a.r; a.r=-a.i; a.i=tmp_; }
+template<bool fwd, typename T> void ROTX90(cmplx<T> &a)
+  { auto tmp_= fwd ? -a.r : a.r; a.r = fwd ? a.i : -a.i; a.i=tmp_; }
+
+//
+// twiddle factor section
+//
+template<typename T> class sincos_2pibyn
+  {
+  private:
+    using Thigh = typename std::conditional<(sizeof(T)>sizeof(double)), T, double>::type;
+    size_t N, mask, shift;
+    arr<cmplx<Thigh>> v1, v2;
+
+    static cmplx<Thigh> calc(size_t x, size_t n, Thigh ang)
+      {
+      x<<=3;
+      if (x<4*n) // first half
+        {
+        if (x<2*n) // first quadrant
+          {
+          if (x<n) return cmplx<Thigh>(std::cos(Thigh(x)*ang), std::sin(Thigh(x)*ang));
+          return cmplx<Thigh>(std::sin(Thigh(2*n-x)*ang), std::cos(Thigh(2*n-x)*ang));
+          }
+        else // second quadrant
+          {
+          x-=2*n;
+          if (x<n) return cmplx<Thigh>(-std::sin(Thigh(x)*ang), std::cos(Thigh(x)*ang));
+          return cmplx<Thigh>(-std::cos(Thigh(2*n-x)*ang), std::sin(Thigh(2*n-x)*ang));
+          }
+        }
+      else
+        {
+        x=8*n-x;
+        if (x<2*n) // third quadrant
+          {
+          if (x<n) return cmplx<Thigh>(std::cos(Thigh(x)*ang), -std::sin(Thigh(x)*ang));
+          return cmplx<Thigh>(std::sin(Thigh(2*n-x)*ang), -std::cos(Thigh(2*n-x)*ang));
+          }
+        else // fourth quadrant
+          {
+          x-=2*n;
+          if (x<n) return cmplx<Thigh>(-std::sin(Thigh(x)*ang), -std::cos(Thigh(x)*ang));
+          return cmplx<Thigh>(-std::cos(Thigh(2*n-x)*ang), -std::sin(Thigh(2*n-x)*ang));
+          }
+        }
+      }
+
+  public:
+    POCKETFFT_NOINLINE sincos_2pibyn(size_t n)
+      : N(n)
+      {
+      constexpr auto pi = 3.141592653589793238462643383279502884197L;
+      Thigh ang = Thigh(0.25L*pi/n);
+      size_t nval = (n+2)/2;
+      shift = 1;
+      while((size_t(1)<<shift)*(size_t(1)<<shift) < nval) ++shift;
+      mask = (size_t(1)<<shift)-1;
+      v1.resize(mask+1);
+      v1[0].Set(Thigh(1), Thigh(0));
+      for (size_t i=1; i<v1.size(); ++i)
+        v1[i]=calc(i,n,ang);
+      v2.resize((nval+mask)/(mask+1));
+      v2[0].Set(Thigh(1), Thigh(0));
+      for (size_t i=1; i<v2.size(); ++i)
+        v2[i]=calc(i*(mask+1),n,ang);
+      }
+
+    cmplx<T> operator[](size_t idx) const
+      {
+      if (2*idx<=N)
+        {
+        auto x1=v1[idx&mask], x2=v2[idx>>shift];
+        return cmplx<T>(T(x1.r*x2.r-x1.i*x2.i), T(x1.r*x2.i+x1.i*x2.r));
+        }
+      idx = N-idx;
+      auto x1=v1[idx&mask], x2=v2[idx>>shift];
+      return cmplx<T>(T(x1.r*x2.r-x1.i*x2.i), -T(x1.r*x2.i+x1.i*x2.r));
+      }
+  };
+
+struct util // hack to avoid duplicate symbols
+  {
+  static POCKETFFT_NOINLINE size_t largest_prime_factor (size_t n)
+    {
+    size_t res=1;
+    while ((n&1)==0)
+      { res=2; n>>=1; }
+    for (size_t x=3; x*x<=n; x+=2)
+      while ((n%x)==0)
+        { res=x; n/=x; }
+    if (n>1) res=n;
+    return res;
+    }
+
+  static POCKETFFT_NOINLINE double cost_guess (size_t n)
+    {
+    constexpr double lfp=1.1; // penalty for non-hardcoded larger factors
+    size_t ni=n;
+    double result=0.;
+    while ((n&1)==0)
+      { result+=2; n>>=1; }
+    for (size_t x=3; x*x<=n; x+=2)
+      while ((n%x)==0)
+        {
+        result+= (x<=5) ? double(x) : lfp*double(x); // penalize larger prime factors
+        n/=x;
+        }
+    if (n>1) result+=(n<=5) ? double(n) : lfp*double(n);
+    return result*double(ni);
+    }
+
+  /* returns the smallest composite of 2, 3, 5, 7 and 11 which is >= n */
+  static POCKETFFT_NOINLINE size_t good_size_cmplx(size_t n)
+    {
+    if (n<=12) return n;
+
+    size_t bestfac=2*n;
+    for (size_t f11=1; f11<bestfac; f11*=11)
+      for (size_t f117=f11; f117<bestfac; f117*=7)
+        for (size_t f1175=f117; f1175<bestfac; f1175*=5)
+          {
+          size_t x=f1175;
+          while (x<n) x*=2;
+          for (;;)
+            {
+            if (x<n)
+              x*=3;
+            else if (x>n)
+              {
+              if (x<bestfac) bestfac=x;
+              if (x&1) break;
+              x>>=1;
+              }
+            else
+              return n;
+            }
+          }
+    return bestfac;
+    }
+
+  /* returns the smallest composite of 2, 3, 5 which is >= n */
+  static POCKETFFT_NOINLINE size_t good_size_real(size_t n)
+    {
+    if (n<=6) return n;
+
+    size_t bestfac=2*n;
+    for (size_t f5=1; f5<bestfac; f5*=5)
+      {
+      size_t x = f5;
+      while (x<n) x *= 2;
+      for (;;)
+        {
+        if (x<n)
+          x*=3;
+        else if (x>n)
+          {
+          if (x<bestfac) bestfac=x;
+          if (x&1) break;
+          x>>=1;
+          }
+        else
+          return n;
+        }
+      }
+    return bestfac;
+    }
+
+  static size_t prod(const shape_t &shape)
+    {
+    size_t res=1;
+    for (auto sz: shape)
+      res*=sz;
+    return res;
+    }
+
+  static POCKETFFT_NOINLINE void sanity_check(const shape_t &shape,
+    const stride_t &stride_in, const stride_t &stride_out, bool inplace)
+    {
+    auto ndim = shape.size();
+    if (ndim<1) throw std::runtime_error("ndim must be >= 1");
+    if ((stride_in.size()!=ndim) || (stride_out.size()!=ndim))
+      throw std::runtime_error("stride dimension mismatch");
+    if (inplace && (stride_in!=stride_out))
+      throw std::runtime_error("stride mismatch");
+    }
+
+  static POCKETFFT_NOINLINE void sanity_check(const shape_t &shape,
+    const stride_t &stride_in, const stride_t &stride_out, bool inplace,
+    const shape_t &axes)
+    {
+    sanity_check(shape, stride_in, stride_out, inplace);
+    auto ndim = shape.size();
+    shape_t tmp(ndim,0);
+    for (auto ax : axes)
+      {
+      if (ax>=ndim) throw std::invalid_argument("bad axis number");
+      if (++tmp[ax]>1) throw std::invalid_argument("axis specified repeatedly");
+      }
+    }
+
+  static POCKETFFT_NOINLINE void sanity_check(const shape_t &shape,
+    const stride_t &stride_in, const stride_t &stride_out, bool inplace,
+    size_t axis)
+    {
+    sanity_check(shape, stride_in, stride_out, inplace);
+    if (axis>=shape.size()) throw std::invalid_argument("bad axis number");
+    }
+
+#ifdef POCKETFFT_NO_MULTITHREADING
+  static size_t thread_count (size_t /*nthreads*/, const shape_t &/*shape*/,
+    size_t /*axis*/, size_t /*vlen*/)
+    { return 1; }
+#else
+  static size_t thread_count (size_t nthreads, const shape_t &shape,
+    size_t axis, size_t vlen)
+    {
+    if (nthreads==1) return 1;
+    size_t size = prod(shape);
+    size_t parallel = size / (shape[axis] * vlen);
+    if (shape[axis] < 1000)
+      parallel /= 4;
+    size_t max_threads = nthreads == 0 ?
+      std::thread::hardware_concurrency() : nthreads;
+    return std::max(size_t(1), std::min(parallel, max_threads));
+    }
+#endif
+  };
+
+namespace threading {
+
+#ifdef POCKETFFT_NO_MULTITHREADING
+
+constexpr inline size_t thread_id() { return 0; }
+constexpr inline size_t num_threads() { return 1; }
+
+template <typename Func>
+void thread_map(size_t /* nthreads */, Func f)
+  { f(); }
+
+#else
+
+inline size_t &thread_id()
+  {
+  static thread_local size_t thread_id_=0;
+  return thread_id_;
+  }
+inline size_t &num_threads()
+  {
+  static thread_local size_t num_threads_=1;
+  return num_threads_;
+  }
+static const size_t max_threads = std::max(1u, std::thread::hardware_concurrency());
+
+class latch
+  {
+    std::atomic<size_t> num_left_;
+    std::mutex mut_;
+    std::condition_variable completed_;
+    using lock_t = std::unique_lock<std::mutex>;
+
+  public:
+    latch(size_t n): num_left_(n) {}
+
+    void count_down()
+      {
+      lock_t lock(mut_);
+      if (--num_left_)
+        return;
+      completed_.notify_all();
+      }
+
+    void wait()
+      {
+      lock_t lock(mut_);
+      completed_.wait(lock, [this]{ return is_ready(); });
+      }
+    bool is_ready() { return num_left_ == 0; }
+  };
+
+template <typename T> class concurrent_queue
+  {
+    std::queue<T> q_;
+    std::mutex mut_;
+    std::atomic<size_t> size_;
+    using lock_t = std::lock_guard<std::mutex>;
+
+  public:
+
+    void push(T val)
+      {
+      lock_t lock(mut_);
+      ++size_;
+      q_.push(std::move(val));
+      }
+
+    bool try_pop(T &val)
+      {
+      if (size_ == 0) return false;
+      lock_t lock(mut_);
+      // Queue might have been emptied while we acquired the lock
+      if (q_.empty()) return false;
+
+      val = std::move(q_.front());
+      --size_;
+      q_.pop();
+      return true;
+      }
+
+    bool empty() const { return size_==0; }
+  };
+
+// C++ allocator with support for over-aligned types
+template <typename T> struct aligned_allocator
+  {
+  using value_type = T;
+  template <class U>
+  aligned_allocator(const aligned_allocator<U>&) {}
+  aligned_allocator() = default;
+
+  T *allocate(size_t n)
+    {
+    void* mem = aligned_alloc(alignof(T), n*sizeof(T));
+    return static_cast<T*>(mem);
+    }
+
+  void deallocate(T *p, size_t /*n*/)
+    { aligned_dealloc(p); }
+  };
+
+class thread_pool
+  {
+    // A reasonable guess, probably close enough for most hardware
+    static constexpr size_t cache_line_size = 64;
+    struct alignas(cache_line_size) worker
+      {
+      std::thread thread;
+      std::condition_variable work_ready;
+      std::mutex mut;
+      std::atomic_flag busy_flag = ATOMIC_FLAG_INIT;
+      std::function<void()> work;
+
+      void worker_main(
+        std::atomic<bool> &shutdown_flag,
+        std::atomic<size_t> &unscheduled_tasks,
+        concurrent_queue<std::function<void()>> &overflow_work)
+        {
+        using lock_t = std::unique_lock<std::mutex>;
+        bool expect_work = true;
+        while (!shutdown_flag || expect_work)
+          {
+          std::function<void()> local_work;
+          if (expect_work || unscheduled_tasks == 0)
+            {
+            lock_t lock(mut);
+            // Wait until there is work to be executed
+            work_ready.wait(lock, [&]{ return (work || shutdown_flag); });
+            local_work.swap(work);
+            expect_work = false;
+            }
+
+          bool marked_busy = false;
+          if (local_work)
+            {
+            marked_busy = true;
+            local_work();
+            }
+
+          if (!overflow_work.empty())
+            {
+            if (!marked_busy && busy_flag.test_and_set())
+              {
+              expect_work = true;
+              continue;
+              }
+            marked_busy = true;
+
+            while (overflow_work.try_pop(local_work))
+              {
+              --unscheduled_tasks;
+              local_work();
+              }
+            }
+
+          if (marked_busy) busy_flag.clear();
+          }
+        }
+      };
+
+    concurrent_queue<std::function<void()>> overflow_work_;
+    std::mutex mut_;
+    std::vector<worker, aligned_allocator<worker>> workers_;
+    std::atomic<bool> shutdown_;
+    std::atomic<size_t> unscheduled_tasks_;
+    using lock_t = std::lock_guard<std::mutex>;
+
+    void create_threads()
+      {
+      lock_t lock(mut_);
+      size_t nthreads=workers_.size();
+      for (size_t i=0; i<nthreads; ++i)
+        {
+        try
+          {
+          auto *worker = &workers_[i];
+          worker->busy_flag.clear();
+          worker->work = nullptr;
+          worker->thread = std::thread([worker, this]
+            {
+            worker->worker_main(shutdown_, unscheduled_tasks_, overflow_work_);
+            });
+          }
+        catch (...)
+          {
+          shutdown_locked();
+          throw;
+          }
+        }
+      }
+
+    void shutdown_locked()
+      {
+      shutdown_ = true;
+      for (auto &worker : workers_)
+        worker.work_ready.notify_all();
+
+      for (auto &worker : workers_)
+        if (worker.thread.joinable())
+          worker.thread.join();
+      }
+
+  public:
+    explicit thread_pool(size_t nthreads):
+      workers_(nthreads)
+      { create_threads(); }
+
+    thread_pool(): thread_pool(max_threads) {}
+
+    ~thread_pool() { shutdown(); }
+
+    void submit(std::function<void()> work)
+      {
+      lock_t lock(mut_);
+      if (shutdown_)
+        throw std::runtime_error("Work item submitted after shutdown");
+
+      ++unscheduled_tasks_;
+
+      // First check for any idle workers and wake those
+      for (auto &worker : workers_)
+        if (!worker.busy_flag.test_and_set())
+          {
+          --unscheduled_tasks_;
+          {
+          lock_t lock(worker.mut);
+          worker.work = std::move(work);
+          }
+          worker.work_ready.notify_one();
+          return;
+          }
+
+      // If no workers were idle, push onto the overflow queue for later
+      overflow_work_.push(std::move(work));
+      }
+
+    void shutdown()
+      {
+      lock_t lock(mut_);
+      shutdown_locked();
+      }
+
+    void restart()
+      {
+      shutdown_ = false;
+      create_threads();
+      }
+  };
+
+inline thread_pool & get_pool()
+  {
+  static thread_pool pool;
+#ifdef POCKETFFT_PTHREADS
+  static std::once_flag f;
+  std::call_once(f,
+    []{
+    pthread_atfork(
+      +[]{ get_pool().shutdown(); },  // prepare
+      +[]{ get_pool().restart(); },   // parent
+      +[]{ get_pool().restart(); }    // child
+      );
+    });
+#endif
+
+  return pool;
+  }
+
+/** Map a function f over nthreads */
+template <typename Func>
+void thread_map(size_t nthreads, Func f)
+  {
+  if (nthreads == 0)
+    nthreads = max_threads;
+
+  if (nthreads == 1)
+    { f(); return; }
+
+  auto & pool = get_pool();
+  latch counter(nthreads);
+  std::exception_ptr ex;
+  std::mutex ex_mut;
+  for (size_t i=0; i<nthreads; ++i)
+    {
+    pool.submit(
+      [&f, &counter, &ex, &ex_mut, i, nthreads] {
+      thread_id() = i;
+      num_threads() = nthreads;
+      try { f(); }
+      catch (...)
+        {
+        std::lock_guard<std::mutex> lock(ex_mut);
+        ex = std::current_exception();
+        }
+      counter.count_down();
+      });
+    }
+  counter.wait();
+  if (ex)
+    std::rethrow_exception(ex);
+  }
+
+#endif
+
+}
+
+//
+// complex FFTPACK transforms
+//
+
+template<typename T0> class cfftp
+  {
+  private:
+    struct fctdata
+      {
+      size_t fct;
+      cmplx<T0> *tw, *tws;
+      };
+
+    size_t length;
+    arr<cmplx<T0>> mem;
+    std::vector<fctdata> fact;
+
+    void add_factor(size_t factor)
+      { fact.push_back({factor, nullptr, nullptr}); }
+
+template<bool fwd, typename T> void pass2 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+2*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      CH(0,k,0) = CC(0,0,k)+CC(0,1,k);
+      CH(0,k,1) = CC(0,0,k)-CC(0,1,k);
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      CH(0,k,0) = CC(0,0,k)+CC(0,1,k);
+      CH(0,k,1) = CC(0,0,k)-CC(0,1,k);
+      for (size_t i=1; i<ido; ++i)
+        {
+        CH(i,k,0) = CC(i,0,k)+CC(i,1,k);
+        special_mul<fwd>(CC(i,0,k)-CC(i,1,k),WA(0,i),CH(i,k,1));
+        }
+      }
+  }
+
+#define POCKETFFT_PREP3(idx) \
+        T t0 = CC(idx,0,k), t1, t2; \
+        PM (t1,t2,CC(idx,1,k),CC(idx,2,k)); \
+        CH(idx,k,0)=t0+t1;
+#define POCKETFFT_PARTSTEP3a(u1,u2,twr,twi) \
+        { \
+        T ca=t0+t1*twr; \
+        T cb{-t2.i*twi, t2.r*twi}; \
+        PM(CH(0,k,u1),CH(0,k,u2),ca,cb) ;\
+        }
+#define POCKETFFT_PARTSTEP3b(u1,u2,twr,twi) \
+        { \
+        T ca=t0+t1*twr; \
+        T cb{-t2.i*twi, t2.r*twi}; \
+        special_mul<fwd>(ca+cb,WA(u1-1,i),CH(i,k,u1)); \
+        special_mul<fwd>(ca-cb,WA(u2-1,i),CH(i,k,u2)); \
+        }
+template<bool fwd, typename T> void pass3 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 tw1r=-0.5,
+               tw1i= (fwd ? -1: 1) * T0(0.8660254037844386467637231707529362L);
+
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+3*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      POCKETFFT_PREP3(0)
+      POCKETFFT_PARTSTEP3a(1,2,tw1r,tw1i)
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      {
+      POCKETFFT_PREP3(0)
+      POCKETFFT_PARTSTEP3a(1,2,tw1r,tw1i)
+      }
+      for (size_t i=1; i<ido; ++i)
+        {
+        POCKETFFT_PREP3(i)
+        POCKETFFT_PARTSTEP3b(1,2,tw1r,tw1i)
+        }
+      }
+  }
+
+#undef POCKETFFT_PARTSTEP3b
+#undef POCKETFFT_PARTSTEP3a
+#undef POCKETFFT_PREP3
+
+template<bool fwd, typename T> void pass4 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+4*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      T t1, t2, t3, t4;
+      PM(t2,t1,CC(0,0,k),CC(0,2,k));
+      PM(t3,t4,CC(0,1,k),CC(0,3,k));
+      ROTX90<fwd>(t4);
+      PM(CH(0,k,0),CH(0,k,2),t2,t3);
+      PM(CH(0,k,1),CH(0,k,3),t1,t4);
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      {
+      T t1, t2, t3, t4;
+      PM(t2,t1,CC(0,0,k),CC(0,2,k));
+      PM(t3,t4,CC(0,1,k),CC(0,3,k));
+      ROTX90<fwd>(t4);
+      PM(CH(0,k,0),CH(0,k,2),t2,t3);
+      PM(CH(0,k,1),CH(0,k,3),t1,t4);
+      }
+      for (size_t i=1; i<ido; ++i)
+        {
+        T t1, t2, t3, t4;
+        T cc0=CC(i,0,k), cc1=CC(i,1,k),cc2=CC(i,2,k),cc3=CC(i,3,k);
+        PM(t2,t1,cc0,cc2);
+        PM(t3,t4,cc1,cc3);
+        ROTX90<fwd>(t4);
+        CH(i,k,0) = t2+t3;
+        special_mul<fwd>(t1+t4,WA(0,i),CH(i,k,1));
+        special_mul<fwd>(t2-t3,WA(1,i),CH(i,k,2));
+        special_mul<fwd>(t1-t4,WA(2,i),CH(i,k,3));
+        }
+      }
+  }
+
+#define POCKETFFT_PREP5(idx) \
+        T t0 = CC(idx,0,k), t1, t2, t3, t4; \
+        PM (t1,t4,CC(idx,1,k),CC(idx,4,k)); \
+        PM (t2,t3,CC(idx,2,k),CC(idx,3,k)); \
+        CH(idx,k,0).r=t0.r+t1.r+t2.r; \
+        CH(idx,k,0).i=t0.i+t1.i+t2.i;
+
+#define POCKETFFT_PARTSTEP5a(u1,u2,twar,twbr,twai,twbi) \
+        { \
+        T ca,cb; \
+        ca.r=t0.r+twar*t1.r+twbr*t2.r; \
+        ca.i=t0.i+twar*t1.i+twbr*t2.i; \
+        cb.i=twai*t4.r twbi*t3.r; \
+        cb.r=-(twai*t4.i twbi*t3.i); \
+        PM(CH(0,k,u1),CH(0,k,u2),ca,cb); \
+        }
+
+#define POCKETFFT_PARTSTEP5b(u1,u2,twar,twbr,twai,twbi) \
+        { \
+        T ca,cb,da,db; \
+        ca.r=t0.r+twar*t1.r+twbr*t2.r; \
+        ca.i=t0.i+twar*t1.i+twbr*t2.i; \
+        cb.i=twai*t4.r twbi*t3.r; \
+        cb.r=-(twai*t4.i twbi*t3.i); \
+        special_mul<fwd>(ca+cb,WA(u1-1,i),CH(i,k,u1)); \
+        special_mul<fwd>(ca-cb,WA(u2-1,i),CH(i,k,u2)); \
+        }
+template<bool fwd, typename T> void pass5 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 tw1r= T0(0.3090169943749474241022934171828191L),
+               tw1i= (fwd ? -1: 1) * T0(0.9510565162951535721164393333793821L),
+               tw2r= T0(-0.8090169943749474241022934171828191L),
+               tw2i= (fwd ? -1: 1) * T0(0.5877852522924731291687059546390728L);
+
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+5*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      POCKETFFT_PREP5(0)
+      POCKETFFT_PARTSTEP5a(1,4,tw1r,tw2r,+tw1i,+tw2i)
+      POCKETFFT_PARTSTEP5a(2,3,tw2r,tw1r,+tw2i,-tw1i)
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      {
+      POCKETFFT_PREP5(0)
+      POCKETFFT_PARTSTEP5a(1,4,tw1r,tw2r,+tw1i,+tw2i)
+      POCKETFFT_PARTSTEP5a(2,3,tw2r,tw1r,+tw2i,-tw1i)
+      }
+      for (size_t i=1; i<ido; ++i)
+        {
+        POCKETFFT_PREP5(i)
+        POCKETFFT_PARTSTEP5b(1,4,tw1r,tw2r,+tw1i,+tw2i)
+        POCKETFFT_PARTSTEP5b(2,3,tw2r,tw1r,+tw2i,-tw1i)
+        }
+      }
+  }
+
+#undef POCKETFFT_PARTSTEP5b
+#undef POCKETFFT_PARTSTEP5a
+#undef POCKETFFT_PREP5
+
+#define POCKETFFT_PREP7(idx) \
+        T t1 = CC(idx,0,k), t2, t3, t4, t5, t6, t7; \
+        PM (t2,t7,CC(idx,1,k),CC(idx,6,k)); \
+        PM (t3,t6,CC(idx,2,k),CC(idx,5,k)); \
+        PM (t4,t5,CC(idx,3,k),CC(idx,4,k)); \
+        CH(idx,k,0).r=t1.r+t2.r+t3.r+t4.r; \
+        CH(idx,k,0).i=t1.i+t2.i+t3.i+t4.i;
+
+#define POCKETFFT_PARTSTEP7a0(u1,u2,x1,x2,x3,y1,y2,y3,out1,out2) \
+        { \
+        T ca,cb; \
+        ca.r=t1.r+x1*t2.r+x2*t3.r+x3*t4.r; \
+        ca.i=t1.i+x1*t2.i+x2*t3.i+x3*t4.i; \
+        cb.i=y1*t7.r y2*t6.r y3*t5.r; \
+        cb.r=-(y1*t7.i y2*t6.i y3*t5.i); \
+        PM(out1,out2,ca,cb); \
+        }
+#define POCKETFFT_PARTSTEP7a(u1,u2,x1,x2,x3,y1,y2,y3) \
+        POCKETFFT_PARTSTEP7a0(u1,u2,x1,x2,x3,y1,y2,y3,CH(0,k,u1),CH(0,k,u2))
+#define POCKETFFT_PARTSTEP7(u1,u2,x1,x2,x3,y1,y2,y3) \
+        { \
+        T da,db; \
+        POCKETFFT_PARTSTEP7a0(u1,u2,x1,x2,x3,y1,y2,y3,da,db) \
+        special_mul<fwd>(da,WA(u1-1,i),CH(i,k,u1)); \
+        special_mul<fwd>(db,WA(u2-1,i),CH(i,k,u2)); \
+        }
+
+template<bool fwd, typename T> void pass7(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 tw1r= T0(0.6234898018587335305250048840042398L),
+               tw1i= (fwd ? -1 : 1) * T0(0.7818314824680298087084445266740578L),
+               tw2r= T0(-0.2225209339563144042889025644967948L),
+               tw2i= (fwd ? -1 : 1) * T0(0.9749279121818236070181316829939312L),
+               tw3r= T0(-0.9009688679024191262361023195074451L),
+               tw3i= (fwd ? -1 : 1) * T0(0.433883739117558120475768332848359L);
+
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+7*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      POCKETFFT_PREP7(0)
+      POCKETFFT_PARTSTEP7a(1,6,tw1r,tw2r,tw3r,+tw1i,+tw2i,+tw3i)
+      POCKETFFT_PARTSTEP7a(2,5,tw2r,tw3r,tw1r,+tw2i,-tw3i,-tw1i)
+      POCKETFFT_PARTSTEP7a(3,4,tw3r,tw1r,tw2r,+tw3i,-tw1i,+tw2i)
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      {
+      POCKETFFT_PREP7(0)
+      POCKETFFT_PARTSTEP7a(1,6,tw1r,tw2r,tw3r,+tw1i,+tw2i,+tw3i)
+      POCKETFFT_PARTSTEP7a(2,5,tw2r,tw3r,tw1r,+tw2i,-tw3i,-tw1i)
+      POCKETFFT_PARTSTEP7a(3,4,tw3r,tw1r,tw2r,+tw3i,-tw1i,+tw2i)
+      }
+      for (size_t i=1; i<ido; ++i)
+        {
+        POCKETFFT_PREP7(i)
+        POCKETFFT_PARTSTEP7(1,6,tw1r,tw2r,tw3r,+tw1i,+tw2i,+tw3i)
+        POCKETFFT_PARTSTEP7(2,5,tw2r,tw3r,tw1r,+tw2i,-tw3i,-tw1i)
+        POCKETFFT_PARTSTEP7(3,4,tw3r,tw1r,tw2r,+tw3i,-tw1i,+tw2i)
+        }
+      }
+  }
+
+#undef POCKETFFT_PARTSTEP7
+#undef POCKETFFT_PARTSTEP7a0
+#undef POCKETFFT_PARTSTEP7a
+#undef POCKETFFT_PREP7
+
+template <bool fwd, typename T> void ROTX45(T &a) const
+  {
+  constexpr T0 hsqt2=T0(0.707106781186547524400844362104849L);
+  if (fwd)
+    { auto tmp_=a.r; a.r=hsqt2*(a.r+a.i); a.i=hsqt2*(a.i-tmp_); }
+  else
+    { auto tmp_=a.r; a.r=hsqt2*(a.r-a.i); a.i=hsqt2*(a.i+tmp_); }
+  }
+template <bool fwd, typename T> void ROTX135(T &a) const
+  {
+  constexpr T0 hsqt2=T0(0.707106781186547524400844362104849L);
+  if (fwd)
+    { auto tmp_=a.r; a.r=hsqt2*(a.i-a.r); a.i=hsqt2*(-tmp_-a.i); }
+  else
+    { auto tmp_=a.r; a.r=hsqt2*(-a.r-a.i); a.i=hsqt2*(tmp_-a.i); }
+  }
+
+template<bool fwd, typename T> void pass8 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+8*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      T a0, a1, a2, a3, a4, a5, a6, a7;
+      PM(a1,a5,CC(0,1,k),CC(0,5,k));
+      PM(a3,a7,CC(0,3,k),CC(0,7,k));
+      PMINPLACE(a1,a3);
+      ROTX90<fwd>(a3);
+
+      ROTX90<fwd>(a7);
+      PMINPLACE(a5,a7);
+      ROTX45<fwd>(a5);
+      ROTX135<fwd>(a7);
+
+      PM(a0,a4,CC(0,0,k),CC(0,4,k));
+      PM(a2,a6,CC(0,2,k),CC(0,6,k));
+      PM(CH(0,k,0),CH(0,k,4),a0+a2,a1);
+      PM(CH(0,k,2),CH(0,k,6),a0-a2,a3);
+      ROTX90<fwd>(a6);
+      PM(CH(0,k,1),CH(0,k,5),a4+a6,a5);
+      PM(CH(0,k,3),CH(0,k,7),a4-a6,a7);
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      {
+      T a0, a1, a2, a3, a4, a5, a6, a7;
+      PM(a1,a5,CC(0,1,k),CC(0,5,k));
+      PM(a3,a7,CC(0,3,k),CC(0,7,k));
+      PMINPLACE(a1,a3);
+      ROTX90<fwd>(a3);
+
+      ROTX90<fwd>(a7);
+      PMINPLACE(a5,a7);
+      ROTX45<fwd>(a5);
+      ROTX135<fwd>(a7);
+
+      PM(a0,a4,CC(0,0,k),CC(0,4,k));
+      PM(a2,a6,CC(0,2,k),CC(0,6,k));
+      PM(CH(0,k,0),CH(0,k,4),a0+a2,a1);
+      PM(CH(0,k,2),CH(0,k,6),a0-a2,a3);
+      ROTX90<fwd>(a6);
+      PM(CH(0,k,1),CH(0,k,5),a4+a6,a5);
+      PM(CH(0,k,3),CH(0,k,7),a4-a6,a7);
+      }
+      for (size_t i=1; i<ido; ++i)
+        {
+        T a0, a1, a2, a3, a4, a5, a6, a7;
+        PM(a1,a5,CC(i,1,k),CC(i,5,k));
+        PM(a3,a7,CC(i,3,k),CC(i,7,k));
+        ROTX90<fwd>(a7);
+        PMINPLACE(a1,a3);
+        ROTX90<fwd>(a3);
+        PMINPLACE(a5,a7);
+        ROTX45<fwd>(a5);
+        ROTX135<fwd>(a7);
+        PM(a0,a4,CC(i,0,k),CC(i,4,k));
+        PM(a2,a6,CC(i,2,k),CC(i,6,k));
+        PMINPLACE(a0,a2);
+        CH(i,k,0) = a0+a1;
+        special_mul<fwd>(a0-a1,WA(3,i),CH(i,k,4));
+        special_mul<fwd>(a2+a3,WA(1,i),CH(i,k,2));
+        special_mul<fwd>(a2-a3,WA(5,i),CH(i,k,6));
+        ROTX90<fwd>(a6);
+        PMINPLACE(a4,a6);
+        special_mul<fwd>(a4+a5,WA(0,i),CH(i,k,1));
+        special_mul<fwd>(a4-a5,WA(4,i),CH(i,k,5));
+        special_mul<fwd>(a6+a7,WA(2,i),CH(i,k,3));
+        special_mul<fwd>(a6-a7,WA(6,i),CH(i,k,7));
+        }
+      }
+   }
+
+
+#define POCKETFFT_PREP11(idx) \
+        T t1 = CC(idx,0,k), t2, t3, t4, t5, t6, t7, t8, t9, t10, t11; \
+        PM (t2,t11,CC(idx,1,k),CC(idx,10,k)); \
+        PM (t3,t10,CC(idx,2,k),CC(idx, 9,k)); \
+        PM (t4,t9 ,CC(idx,3,k),CC(idx, 8,k)); \
+        PM (t5,t8 ,CC(idx,4,k),CC(idx, 7,k)); \
+        PM (t6,t7 ,CC(idx,5,k),CC(idx, 6,k)); \
+        CH(idx,k,0).r=t1.r+t2.r+t3.r+t4.r+t5.r+t6.r; \
+        CH(idx,k,0).i=t1.i+t2.i+t3.i+t4.i+t5.i+t6.i;
+
+#define POCKETFFT_PARTSTEP11a0(u1,u2,x1,x2,x3,x4,x5,y1,y2,y3,y4,y5,out1,out2) \
+        { \
+        T ca = t1 + t2*x1 + t3*x2 + t4*x3 + t5*x4 +t6*x5, \
+          cb; \
+        cb.i=y1*t11.r y2*t10.r y3*t9.r y4*t8.r y5*t7.r; \
+        cb.r=-(y1*t11.i y2*t10.i y3*t9.i y4*t8.i y5*t7.i ); \
+        PM(out1,out2,ca,cb); \
+        }
+#define POCKETFFT_PARTSTEP11a(u1,u2,x1,x2,x3,x4,x5,y1,y2,y3,y4,y5) \
+        POCKETFFT_PARTSTEP11a0(u1,u2,x1,x2,x3,x4,x5,y1,y2,y3,y4,y5,CH(0,k,u1),CH(0,k,u2))
+#define POCKETFFT_PARTSTEP11(u1,u2,x1,x2,x3,x4,x5,y1,y2,y3,y4,y5) \
+        { \
+        T da,db; \
+        POCKETFFT_PARTSTEP11a0(u1,u2,x1,x2,x3,x4,x5,y1,y2,y3,y4,y5,da,db) \
+        special_mul<fwd>(da,WA(u1-1,i),CH(i,k,u1)); \
+        special_mul<fwd>(db,WA(u2-1,i),CH(i,k,u2)); \
+        }
+
+template<bool fwd, typename T> void pass11 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 tw1r= T0(0.8412535328311811688618116489193677L),
+               tw1i= (fwd ? -1 : 1) * T0(0.5406408174555975821076359543186917L),
+               tw2r= T0(0.4154150130018864255292741492296232L),
+               tw2i= (fwd ? -1 : 1) * T0(0.9096319953545183714117153830790285L),
+               tw3r= T0(-0.1423148382732851404437926686163697L),
+               tw3i= (fwd ? -1 : 1) * T0(0.9898214418809327323760920377767188L),
+               tw4r= T0(-0.6548607339452850640569250724662936L),
+               tw4i= (fwd ? -1 : 1) * T0(0.7557495743542582837740358439723444L),
+               tw5r= T0(-0.9594929736144973898903680570663277L),
+               tw5i= (fwd ? -1 : 1) * T0(0.2817325568414296977114179153466169L);
+
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+11*c)]; };
+  auto WA = [wa, ido](size_t x, size_t i)
+    { return wa[i-1+x*(ido-1)]; };
+
+  if (ido==1)
+    for (size_t k=0; k<l1; ++k)
+      {
+      POCKETFFT_PREP11(0)
+      POCKETFFT_PARTSTEP11a(1,10,tw1r,tw2r,tw3r,tw4r,tw5r,+tw1i,+tw2i,+tw3i,+tw4i,+tw5i)
+      POCKETFFT_PARTSTEP11a(2, 9,tw2r,tw4r,tw5r,tw3r,tw1r,+tw2i,+tw4i,-tw5i,-tw3i,-tw1i)
+      POCKETFFT_PARTSTEP11a(3, 8,tw3r,tw5r,tw2r,tw1r,tw4r,+tw3i,-tw5i,-tw2i,+tw1i,+tw4i)
+      POCKETFFT_PARTSTEP11a(4, 7,tw4r,tw3r,tw1r,tw5r,tw2r,+tw4i,-tw3i,+tw1i,+tw5i,-tw2i)
+      POCKETFFT_PARTSTEP11a(5, 6,tw5r,tw1r,tw4r,tw2r,tw3r,+tw5i,-tw1i,+tw4i,-tw2i,+tw3i)
+      }
+  else
+    for (size_t k=0; k<l1; ++k)
+      {
+      {
+      POCKETFFT_PREP11(0)
+      POCKETFFT_PARTSTEP11a(1,10,tw1r,tw2r,tw3r,tw4r,tw5r,+tw1i,+tw2i,+tw3i,+tw4i,+tw5i)
+      POCKETFFT_PARTSTEP11a(2, 9,tw2r,tw4r,tw5r,tw3r,tw1r,+tw2i,+tw4i,-tw5i,-tw3i,-tw1i)
+      POCKETFFT_PARTSTEP11a(3, 8,tw3r,tw5r,tw2r,tw1r,tw4r,+tw3i,-tw5i,-tw2i,+tw1i,+tw4i)
+      POCKETFFT_PARTSTEP11a(4, 7,tw4r,tw3r,tw1r,tw5r,tw2r,+tw4i,-tw3i,+tw1i,+tw5i,-tw2i)
+      POCKETFFT_PARTSTEP11a(5, 6,tw5r,tw1r,tw4r,tw2r,tw3r,+tw5i,-tw1i,+tw4i,-tw2i,+tw3i)
+      }
+      for (size_t i=1; i<ido; ++i)
+        {
+        POCKETFFT_PREP11(i)
+        POCKETFFT_PARTSTEP11(1,10,tw1r,tw2r,tw3r,tw4r,tw5r,+tw1i,+tw2i,+tw3i,+tw4i,+tw5i)
+        POCKETFFT_PARTSTEP11(2, 9,tw2r,tw4r,tw5r,tw3r,tw1r,+tw2i,+tw4i,-tw5i,-tw3i,-tw1i)
+        POCKETFFT_PARTSTEP11(3, 8,tw3r,tw5r,tw2r,tw1r,tw4r,+tw3i,-tw5i,-tw2i,+tw1i,+tw4i)
+        POCKETFFT_PARTSTEP11(4, 7,tw4r,tw3r,tw1r,tw5r,tw2r,+tw4i,-tw3i,+tw1i,+tw5i,-tw2i)
+        POCKETFFT_PARTSTEP11(5, 6,tw5r,tw1r,tw4r,tw2r,tw3r,+tw5i,-tw1i,+tw4i,-tw2i,+tw3i)
+        }
+      }
+  }
+
+#undef POCKETFFT_PARTSTEP11
+#undef POCKETFFT_PARTSTEP11a0
+#undef POCKETFFT_PARTSTEP11a
+#undef POCKETFFT_PREP11
+
+template<bool fwd, typename T> void passg (size_t ido, size_t ip,
+  size_t l1, T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const cmplx<T0> * POCKETFFT_RESTRICT wa,
+  const cmplx<T0> * POCKETFFT_RESTRICT csarr) const
+  {
+  const size_t cdim=ip;
+  size_t ipph = (ip+1)/2;
+  size_t idl1 = ido*l1;
+
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto CC = [cc,ido,cdim](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+cdim*c)]; };
+  auto CX = [cc, ido, l1](size_t a, size_t b, size_t c) -> T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto CX2 = [cc, idl1](size_t a, size_t b) -> T&
+    { return cc[a+idl1*b]; };
+  auto CH2 = [ch, idl1](size_t a, size_t b) -> const T&
+    { return ch[a+idl1*b]; };
+
+  arr<cmplx<T0>> wal(ip);
+  wal[0] = cmplx<T0>(1., 0.);
+  for (size_t i=1; i<ip; ++i)
+    wal[i]=cmplx<T0>(csarr[i].r,fwd ? -csarr[i].i : csarr[i].i);
+
+  for (size_t k=0; k<l1; ++k)
+    for (size_t i=0; i<ido; ++i)
+      CH(i,k,0) = CC(i,0,k);
+  for (size_t j=1, jc=ip-1; j<ipph; ++j, --jc)
+    for (size_t k=0; k<l1; ++k)
+      for (size_t i=0; i<ido; ++i)
+        PM(CH(i,k,j),CH(i,k,jc),CC(i,j,k),CC(i,jc,k));
+  for (size_t k=0; k<l1; ++k)
+    for (size_t i=0; i<ido; ++i)
+      {
+      T tmp = CH(i,k,0);
+      for (size_t j=1; j<ipph; ++j)
+        tmp+=CH(i,k,j);
+      CX(i,k,0) = tmp;
+      }
+  for (size_t l=1, lc=ip-1; l<ipph; ++l, --lc)
+    {
+    // j=0
+    for (size_t ik=0; ik<idl1; ++ik)
+      {
+      CX2(ik,l).r = CH2(ik,0).r+wal[l].r*CH2(ik,1).r+wal[2*l].r*CH2(ik,2).r;
+      CX2(ik,l).i = CH2(ik,0).i+wal[l].r*CH2(ik,1).i+wal[2*l].r*CH2(ik,2).i;
+      CX2(ik,lc).r=-wal[l].i*CH2(ik,ip-1).i-wal[2*l].i*CH2(ik,ip-2).i;
+      CX2(ik,lc).i=wal[l].i*CH2(ik,ip-1).r+wal[2*l].i*CH2(ik,ip-2).r;
+      }
+
+    size_t iwal=2*l;
+    size_t j=3, jc=ip-3;
+    for (; j<ipph-1; j+=2, jc-=2)
+      {
+      iwal+=l; if (iwal>ip) iwal-=ip;
+      cmplx<T0> xwal=wal[iwal];
+      iwal+=l; if (iwal>ip) iwal-=ip;
+      cmplx<T0> xwal2=wal[iwal];
+      for (size_t ik=0; ik<idl1; ++ik)
+        {
+        CX2(ik,l).r += CH2(ik,j).r*xwal.r+CH2(ik,j+1).r*xwal2.r;
+        CX2(ik,l).i += CH2(ik,j).i*xwal.r+CH2(ik,j+1).i*xwal2.r;
+        CX2(ik,lc).r -= CH2(ik,jc).i*xwal.i+CH2(ik,jc-1).i*xwal2.i;
+        CX2(ik,lc).i += CH2(ik,jc).r*xwal.i+CH2(ik,jc-1).r*xwal2.i;
+        }
+      }
+    for (; j<ipph; ++j, --jc)
+      {
+      iwal+=l; if (iwal>ip) iwal-=ip;
+      cmplx<T0> xwal=wal[iwal];
+      for (size_t ik=0; ik<idl1; ++ik)
+        {
+        CX2(ik,l).r += CH2(ik,j).r*xwal.r;
+        CX2(ik,l).i += CH2(ik,j).i*xwal.r;
+        CX2(ik,lc).r -= CH2(ik,jc).i*xwal.i;
+        CX2(ik,lc).i += CH2(ik,jc).r*xwal.i;
+        }
+      }
+    }
+
+  // shuffling and twiddling
+  if (ido==1)
+    for (size_t j=1, jc=ip-1; j<ipph; ++j, --jc)
+      for (size_t ik=0; ik<idl1; ++ik)
+        {
+        T t1=CX2(ik,j), t2=CX2(ik,jc);
+        PM(CX2(ik,j),CX2(ik,jc),t1,t2);
+        }
+  else
+    {
+    for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)
+      for (size_t k=0; k<l1; ++k)
+        {
+        T t1=CX(0,k,j), t2=CX(0,k,jc);
+        PM(CX(0,k,j),CX(0,k,jc),t1,t2);
+        for (size_t i=1; i<ido; ++i)
+          {
+          T x1, x2;
+          PM(x1,x2,CX(i,k,j),CX(i,k,jc));
+          size_t idij=(j-1)*(ido-1)+i-1;
+          special_mul<fwd>(x1,wa[idij],CX(i,k,j));
+          idij=(jc-1)*(ido-1)+i-1;
+          special_mul<fwd>(x2,wa[idij],CX(i,k,jc));
+          }
+        }
+    }
+  }
+
+template<bool fwd, typename T> void pass_all(T c[], T0 fct) const
+  {
+  if (length==1) { c[0]*=fct; return; }
+  size_t l1=1;
+  arr<T> ch(length);
+  T *p1=c, *p2=ch.data();
+
+  for(size_t k1=0; k1<fact.size(); k1++)
+    {
+    size_t ip=fact[k1].fct;
+    size_t l2=ip*l1;
+    size_t ido = length/l2;
+    if     (ip==4)
+      pass4<fwd> (ido, l1, p1, p2, fact[k1].tw);
+    else if(ip==8)
+      pass8<fwd>(ido, l1, p1, p2, fact[k1].tw);
+    else if(ip==2)
+      pass2<fwd>(ido, l1, p1, p2, fact[k1].tw);
+    else if(ip==3)
+      pass3<fwd> (ido, l1, p1, p2, fact[k1].tw);
+    else if(ip==5)
+      pass5<fwd> (ido, l1, p1, p2, fact[k1].tw);
+    else if(ip==7)
+      pass7<fwd> (ido, l1, p1, p2, fact[k1].tw);
+    else if(ip==11)
+      pass11<fwd> (ido, l1, p1, p2, fact[k1].tw);
+    else
+      {
+      passg<fwd>(ido, ip, l1, p1, p2, fact[k1].tw, fact[k1].tws);
+      std::swap(p1,p2);
+      }
+    std::swap(p1,p2);
+    l1=l2;
+    }
+  if (p1!=c)
+    {
+    if (fct!=1.)
+      for (size_t i=0; i<length; ++i)
+        c[i] = ch[i]*fct;
+    else
+      std::copy_n (p1, length, c);
+    }
+  else
+    if (fct!=1.)
+      for (size_t i=0; i<length; ++i)
+        c[i] *= fct;
+  }
+
+  public:
+    template<typename T> void exec(T c[], T0 fct, bool fwd) const
+      { fwd ? pass_all<true>(c, fct) : pass_all<false>(c, fct); }
+
+  private:
+    POCKETFFT_NOINLINE void factorize()
+      {
+      size_t len=length;
+      while ((len&7)==0)
+        { add_factor(8); len>>=3; }
+      while ((len&3)==0)
+        { add_factor(4); len>>=2; }
+      if ((len&1)==0)
+        {
+        len>>=1;
+        // factor 2 should be at the front of the factor list
+        add_factor(2);
+        std::swap(fact[0].fct, fact.back().fct);
+        }
+      for (size_t divisor=3; divisor*divisor<=len; divisor+=2)
+        while ((len%divisor)==0)
+          {
+          add_factor(divisor);
+          len/=divisor;
+          }
+      if (len>1) add_factor(len);
+      }
+
+    size_t twsize() const
+      {
+      size_t twsize=0, l1=1;
+      for (size_t k=0; k<fact.size(); ++k)
+        {
+        size_t ip=fact[k].fct, ido= length/(l1*ip);
+        twsize+=(ip-1)*(ido-1);
+        if (ip>11)
+          twsize+=ip;
+        l1*=ip;
+        }
+      return twsize;
+      }
+
+    void comp_twiddle()
+      {
+      sincos_2pibyn<T0> twiddle(length);
+      size_t l1=1;
+      size_t memofs=0;
+      for (size_t k=0; k<fact.size(); ++k)
+        {
+        size_t ip=fact[k].fct, ido=length/(l1*ip);
+        fact[k].tw=mem.data()+memofs;
+        memofs+=(ip-1)*(ido-1);
+        for (size_t j=1; j<ip; ++j)
+          for (size_t i=1; i<ido; ++i)
+            fact[k].tw[(j-1)*(ido-1)+i-1] = twiddle[j*l1*i];
+        if (ip>11)
+          {
+          fact[k].tws=mem.data()+memofs;
+          memofs+=ip;
+          for (size_t j=0; j<ip; ++j)
+            fact[k].tws[j] = twiddle[j*l1*ido];
+          }
+        l1*=ip;
+        }
+      }
+
+  public:
+    POCKETFFT_NOINLINE cfftp(size_t length_)
+      : length(length_)
+      {
+      if (length==0) throw std::runtime_error("zero-length FFT requested");
+      if (length==1) return;
+      factorize();
+      mem.resize(twsize());
+      comp_twiddle();
+      }
+  };
+
+//
+// real-valued FFTPACK transforms
+//
+
+template<typename T0> class rfftp
+  {
+  private:
+    struct fctdata
+      {
+      size_t fct;
+      T0 *tw, *tws;
+      };
+
+    size_t length;
+    arr<T0> mem;
+    std::vector<fctdata> fact;
+
+    void add_factor(size_t factor)
+      { fact.push_back({factor, nullptr, nullptr}); }
+
+/* (a+ib) = conj(c+id) * (e+if) */
+template<typename T1, typename T2, typename T3> inline void MULPM
+  (T1 &a, T1 &b, T2 c, T2 d, T3 e, T3 f) const
+  {  a=c*e+d*f; b=c*f-d*e; }
+
+template<typename T> void radf2 (size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido,l1](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto CH = [ch,ido](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+2*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    PM (CH(0,0,k),CH(ido-1,1,k),CC(0,k,0),CC(0,k,1));
+  if ((ido&1)==0)
+    for (size_t k=0; k<l1; k++)
+      {
+      CH(    0,1,k) = -CC(ido-1,k,1);
+      CH(ido-1,0,k) =  CC(ido-1,k,0);
+      }
+  if (ido<=2) return;
+  for (size_t k=0; k<l1; k++)
+    for (size_t i=2; i<ido; i+=2)
+      {
+      size_t ic=ido-i;
+      T tr2, ti2;
+      MULPM (tr2,ti2,WA(0,i-2),WA(0,i-1),CC(i-1,k,1),CC(i,k,1));
+      PM (CH(i-1,0,k),CH(ic-1,1,k),CC(i-1,k,0),tr2);
+      PM (CH(i  ,0,k),CH(ic  ,1,k),ti2,CC(i  ,k,0));
+      }
+  }
+
+// a2=a+b; b2=i*(b-a);
+#define POCKETFFT_REARRANGE(rx, ix, ry, iy) \
+  {\
+  auto t1=rx+ry, t2=ry-rx, t3=ix+iy, t4=ix-iy; \
+  rx=t1; ix=t3; ry=t4; iy=t2; \
+  }
+
+template<typename T> void radf3(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 taur=-0.5, taui=T0(0.8660254037844386467637231707529362L);
+
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido,l1](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto CH = [ch,ido](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+3*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    {
+    T cr2=CC(0,k,1)+CC(0,k,2);
+    CH(0,0,k) = CC(0,k,0)+cr2;
+    CH(0,2,k) = taui*(CC(0,k,2)-CC(0,k,1));
+    CH(ido-1,1,k) = CC(0,k,0)+taur*cr2;
+    }
+  if (ido==1) return;
+  for (size_t k=0; k<l1; k++)
+    for (size_t i=2; i<ido; i+=2)
+      {
+      size_t ic=ido-i;
+      T di2, di3, dr2, dr3;
+      MULPM (dr2,di2,WA(0,i-2),WA(0,i-1),CC(i-1,k,1),CC(i,k,1)); // d2=conj(WA0)*CC1
+      MULPM (dr3,di3,WA(1,i-2),WA(1,i-1),CC(i-1,k,2),CC(i,k,2)); // d3=conj(WA1)*CC2
+      POCKETFFT_REARRANGE(dr2, di2, dr3, di3);
+      CH(i-1,0,k) = CC(i-1,k,0)+dr2; // c add
+      CH(i  ,0,k) = CC(i  ,k,0)+di2;
+      T tr2 = CC(i-1,k,0)+taur*dr2; // c add
+      T ti2 = CC(i  ,k,0)+taur*di2;
+      T tr3 = taui*dr3;  // t3 = taui*i*(d3-d2)?
+      T ti3 = taui*di3;
+      PM(CH(i-1,2,k),CH(ic-1,1,k),tr2,tr3); // PM(i) = t2+t3
+      PM(CH(i  ,2,k),CH(ic  ,1,k),ti3,ti2); // PM(ic) = conj(t2-t3)
+      }
+  }
+
+template<typename T> void radf4(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 hsqt2=T0(0.707106781186547524400844362104849L);
+
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido,l1](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto CH = [ch,ido](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+4*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    {
+    T tr1,tr2;
+    PM (tr1,CH(0,2,k),CC(0,k,3),CC(0,k,1));
+    PM (tr2,CH(ido-1,1,k),CC(0,k,0),CC(0,k,2));
+    PM (CH(0,0,k),CH(ido-1,3,k),tr2,tr1);
+    }
+  if ((ido&1)==0)
+    for (size_t k=0; k<l1; k++)
+      {
+      T ti1=-hsqt2*(CC(ido-1,k,1)+CC(ido-1,k,3));
+      T tr1= hsqt2*(CC(ido-1,k,1)-CC(ido-1,k,3));
+      PM (CH(ido-1,0,k),CH(ido-1,2,k),CC(ido-1,k,0),tr1);
+      PM (CH(    0,3,k),CH(    0,1,k),ti1,CC(ido-1,k,2));
+      }
+  if (ido<=2) return;
+  for (size_t k=0; k<l1; k++)
+    for (size_t i=2; i<ido; i+=2)
+      {
+      size_t ic=ido-i;
+      T ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4;
+      MULPM(cr2,ci2,WA(0,i-2),WA(0,i-1),CC(i-1,k,1),CC(i,k,1));
+      MULPM(cr3,ci3,WA(1,i-2),WA(1,i-1),CC(i-1,k,2),CC(i,k,2));
+      MULPM(cr4,ci4,WA(2,i-2),WA(2,i-1),CC(i-1,k,3),CC(i,k,3));
+      PM(tr1,tr4,cr4,cr2);
+      PM(ti1,ti4,ci2,ci4);
+      PM(tr2,tr3,CC(i-1,k,0),cr3);
+      PM(ti2,ti3,CC(i  ,k,0),ci3);
+      PM(CH(i-1,0,k),CH(ic-1,3,k),tr2,tr1);
+      PM(CH(i  ,0,k),CH(ic  ,3,k),ti1,ti2);
+      PM(CH(i-1,2,k),CH(ic-1,1,k),tr3,ti4);
+      PM(CH(i  ,2,k),CH(ic  ,1,k),tr4,ti3);
+      }
+  }
+
+template<typename T> void radf5(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 tr11= T0(0.3090169943749474241022934171828191L),
+               ti11= T0(0.9510565162951535721164393333793821L),
+               tr12= T0(-0.8090169943749474241022934171828191L),
+               ti12= T0(0.5877852522924731291687059546390728L);
+
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido,l1](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto CH = [ch,ido](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+5*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    {
+    T cr2, cr3, ci4, ci5;
+    PM (cr2,ci5,CC(0,k,4),CC(0,k,1));
+    PM (cr3,ci4,CC(0,k,3),CC(0,k,2));
+    CH(0,0,k)=CC(0,k,0)+cr2+cr3;
+    CH(ido-1,1,k)=CC(0,k,0)+tr11*cr2+tr12*cr3;
+    CH(0,2,k)=ti11*ci5+ti12*ci4;
+    CH(ido-1,3,k)=CC(0,k,0)+tr12*cr2+tr11*cr3;
+    CH(0,4,k)=ti12*ci5-ti11*ci4;
+    }
+  if (ido==1) return;
+  for (size_t k=0; k<l1;++k)
+    for (size_t i=2, ic=ido-2; i<ido; i+=2, ic-=2)
+      {
+      T di2, di3, di4, di5, dr2, dr3, dr4, dr5;
+      MULPM (dr2,di2,WA(0,i-2),WA(0,i-1),CC(i-1,k,1),CC(i,k,1));
+      MULPM (dr3,di3,WA(1,i-2),WA(1,i-1),CC(i-1,k,2),CC(i,k,2));
+      MULPM (dr4,di4,WA(2,i-2),WA(2,i-1),CC(i-1,k,3),CC(i,k,3));
+      MULPM (dr5,di5,WA(3,i-2),WA(3,i-1),CC(i-1,k,4),CC(i,k,4));
+      POCKETFFT_REARRANGE(dr2, di2, dr5, di5);
+      POCKETFFT_REARRANGE(dr3, di3, dr4, di4);
+      CH(i-1,0,k)=CC(i-1,k,0)+dr2+dr3;
+      CH(i  ,0,k)=CC(i  ,k,0)+di2+di3;
+      T tr2=CC(i-1,k,0)+tr11*dr2+tr12*dr3;
+      T ti2=CC(i  ,k,0)+tr11*di2+tr12*di3;
+      T tr3=CC(i-1,k,0)+tr12*dr2+tr11*dr3;
+      T ti3=CC(i  ,k,0)+tr12*di2+tr11*di3;
+      T tr5 = ti11*dr5 + ti12*dr4;
+      T ti5 = ti11*di5 + ti12*di4;
+      T tr4 = ti12*dr5 - ti11*dr4;
+      T ti4 = ti12*di5 - ti11*di4;
+      PM(CH(i-1,2,k),CH(ic-1,1,k),tr2,tr5);
+      PM(CH(i  ,2,k),CH(ic  ,1,k),ti5,ti2);
+      PM(CH(i-1,4,k),CH(ic-1,3,k),tr3,tr4);
+      PM(CH(i  ,4,k),CH(ic  ,3,k),ti4,ti3);
+      }
+  }
+
+#undef POCKETFFT_REARRANGE
+
+template<typename T> void radfg(size_t ido, size_t ip, size_t l1,
+  T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa, const T0 * POCKETFFT_RESTRICT csarr) const
+  {
+  const size_t cdim=ip;
+  size_t ipph=(ip+1)/2;
+  size_t idl1 = ido*l1;
+
+  auto CC = [cc,ido,cdim](size_t a, size_t b, size_t c) -> T&
+    { return cc[a+ido*(b+cdim*c)]; };
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> const T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto C1 = [cc,ido,l1] (size_t a, size_t b, size_t c) -> T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto C2 = [cc,idl1] (size_t a, size_t b) -> T&
+    { return cc[a+idl1*b]; };
+  auto CH2 = [ch,idl1] (size_t a, size_t b) -> T&
+    { return ch[a+idl1*b]; };
+
+  if (ido>1)
+    {
+    for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)              // 114
+      {
+      size_t is=(j-1)*(ido-1),
+             is2=(jc-1)*(ido-1);
+      for (size_t k=0; k<l1; ++k)                            // 113
+        {
+        size_t idij=is;
+        size_t idij2=is2;
+        for (size_t i=1; i<=ido-2; i+=2)                      // 112
+          {
+          T t1=C1(i,k,j ), t2=C1(i+1,k,j ),
+            t3=C1(i,k,jc), t4=C1(i+1,k,jc);
+          T x1=wa[idij]*t1 + wa[idij+1]*t2,
+            x2=wa[idij]*t2 - wa[idij+1]*t1,
+            x3=wa[idij2]*t3 + wa[idij2+1]*t4,
+            x4=wa[idij2]*t4 - wa[idij2+1]*t3;
+          PM(C1(i,k,j),C1(i+1,k,jc),x3,x1);
+          PM(C1(i+1,k,j),C1(i,k,jc),x2,x4);
+          idij+=2;
+          idij2+=2;
+          }
+        }
+      }
+    }
+
+  for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)                // 123
+    for (size_t k=0; k<l1; ++k)                              // 122
+      MPINPLACE(C1(0,k,jc), C1(0,k,j));
+
+//everything in C
+//memset(ch,0,ip*l1*ido*sizeof(double));
+
+  for (size_t l=1,lc=ip-1; l<ipph; ++l,--lc)                 // 127
+    {
+    for (size_t ik=0; ik<idl1; ++ik)                         // 124
+      {
+      CH2(ik,l ) = C2(ik,0)+csarr[2*l]*C2(ik,1)+csarr[4*l]*C2(ik,2);
+      CH2(ik,lc) = csarr[2*l+1]*C2(ik,ip-1)+csarr[4*l+1]*C2(ik,ip-2);
+      }
+    size_t iang = 2*l;
+    size_t j=3, jc=ip-3;
+    for (; j<ipph-3; j+=4,jc-=4)              // 126
+      {
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar1=csarr[2*iang], ai1=csarr[2*iang+1];
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar2=csarr[2*iang], ai2=csarr[2*iang+1];
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar3=csarr[2*iang], ai3=csarr[2*iang+1];
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar4=csarr[2*iang], ai4=csarr[2*iang+1];
+      for (size_t ik=0; ik<idl1; ++ik)                       // 125
+        {
+        CH2(ik,l ) += ar1*C2(ik,j )+ar2*C2(ik,j +1)
+                     +ar3*C2(ik,j +2)+ar4*C2(ik,j +3);
+        CH2(ik,lc) += ai1*C2(ik,jc)+ai2*C2(ik,jc-1)
+                     +ai3*C2(ik,jc-2)+ai4*C2(ik,jc-3);
+        }
+      }
+    for (; j<ipph-1; j+=2,jc-=2)              // 126
+      {
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar1=csarr[2*iang], ai1=csarr[2*iang+1];
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar2=csarr[2*iang], ai2=csarr[2*iang+1];
+      for (size_t ik=0; ik<idl1; ++ik)                       // 125
+        {
+        CH2(ik,l ) += ar1*C2(ik,j )+ar2*C2(ik,j +1);
+        CH2(ik,lc) += ai1*C2(ik,jc)+ai2*C2(ik,jc-1);
+        }
+      }
+    for (; j<ipph; ++j,--jc)              // 126
+      {
+      iang+=l; if (iang>=ip) iang-=ip;
+      T0 ar=csarr[2*iang], ai=csarr[2*iang+1];
+      for (size_t ik=0; ik<idl1; ++ik)                       // 125
+        {
+        CH2(ik,l ) += ar*C2(ik,j );
+        CH2(ik,lc) += ai*C2(ik,jc);
+        }
+      }
+    }
+  for (size_t ik=0; ik<idl1; ++ik)                         // 101
+    CH2(ik,0) = C2(ik,0);
+  for (size_t j=1; j<ipph; ++j)                              // 129
+    for (size_t ik=0; ik<idl1; ++ik)                         // 128
+      CH2(ik,0) += C2(ik,j);
+
+// everything in CH at this point!
+//memset(cc,0,ip*l1*ido*sizeof(double));
+
+  for (size_t k=0; k<l1; ++k)                                // 131
+    for (size_t i=0; i<ido; ++i)                             // 130
+      CC(i,0,k) = CH(i,k,0);
+
+  for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)                // 137
+    {
+    size_t j2=2*j-1;
+    for (size_t k=0; k<l1; ++k)                              // 136
+      {
+      CC(ido-1,j2,k) = CH(0,k,j);
+      CC(0,j2+1,k) = CH(0,k,jc);
+      }
+    }
+
+  if (ido==1) return;
+
+  for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)                // 140
+    {
+    size_t j2=2*j-1;
+    for(size_t k=0; k<l1; ++k)                               // 139
+      for(size_t i=1, ic=ido-i-2; i<=ido-2; i+=2, ic-=2)      // 138
+        {
+        CC(i   ,j2+1,k) = CH(i  ,k,j )+CH(i  ,k,jc);
+        CC(ic  ,j2  ,k) = CH(i  ,k,j )-CH(i  ,k,jc);
+        CC(i+1 ,j2+1,k) = CH(i+1,k,j )+CH(i+1,k,jc);
+        CC(ic+1,j2  ,k) = CH(i+1,k,jc)-CH(i+1,k,j );
+        }
+    }
+  }
+
+template<typename T> void radb2(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+2*c)]; };
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    PM (CH(0,k,0),CH(0,k,1),CC(0,0,k),CC(ido-1,1,k));
+  if ((ido&1)==0)
+    for (size_t k=0; k<l1; k++)
+      {
+      CH(ido-1,k,0) = 2*CC(ido-1,0,k);
+      CH(ido-1,k,1) =-2*CC(0    ,1,k);
+      }
+  if (ido<=2) return;
+  for (size_t k=0; k<l1;++k)
+    for (size_t i=2; i<ido; i+=2)
+      {
+      size_t ic=ido-i;
+      T ti2, tr2;
+      PM (CH(i-1,k,0),tr2,CC(i-1,0,k),CC(ic-1,1,k));
+      PM (ti2,CH(i  ,k,0),CC(i  ,0,k),CC(ic  ,1,k));
+      MULPM (CH(i,k,1),CH(i-1,k,1),WA(0,i-2),WA(0,i-1),ti2,tr2);
+      }
+  }
+
+template<typename T> void radb3(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 taur=-0.5, taui=T0(0.8660254037844386467637231707529362L);
+
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+3*c)]; };
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    {
+    T tr2=2*CC(ido-1,1,k);
+    T cr2=CC(0,0,k)+taur*tr2;
+    CH(0,k,0)=CC(0,0,k)+tr2;
+    T ci3=2*taui*CC(0,2,k);
+    PM (CH(0,k,2),CH(0,k,1),cr2,ci3);
+    }
+  if (ido==1) return;
+  for (size_t k=0; k<l1; k++)
+    for (size_t i=2, ic=ido-2; i<ido; i+=2, ic-=2)
+      {
+      T tr2=CC(i-1,2,k)+CC(ic-1,1,k); // t2=CC(I) + conj(CC(ic))
+      T ti2=CC(i  ,2,k)-CC(ic  ,1,k);
+      T cr2=CC(i-1,0,k)+taur*tr2;     // c2=CC +taur*t2
+      T ci2=CC(i  ,0,k)+taur*ti2;
+      CH(i-1,k,0)=CC(i-1,0,k)+tr2;         // CH=CC+t2
+      CH(i  ,k,0)=CC(i  ,0,k)+ti2;
+      T cr3=taui*(CC(i-1,2,k)-CC(ic-1,1,k));// c3=taui*(CC(i)-conj(CC(ic)))
+      T ci3=taui*(CC(i  ,2,k)+CC(ic  ,1,k));
+      T di2, di3, dr2, dr3;
+      PM(dr3,dr2,cr2,ci3); // d2= (cr2-ci3, ci2+cr3) = c2+i*c3
+      PM(di2,di3,ci2,cr3); // d3= (cr2+ci3, ci2-cr3) = c2-i*c3
+      MULPM(CH(i,k,1),CH(i-1,k,1),WA(0,i-2),WA(0,i-1),di2,dr2); // ch = WA*d2
+      MULPM(CH(i,k,2),CH(i-1,k,2),WA(1,i-2),WA(1,i-1),di3,dr3);
+      }
+  }
+
+template<typename T> void radb4(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 sqrt2=T0(1.414213562373095048801688724209698L);
+
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+4*c)]; };
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    {
+    T tr1, tr2;
+    PM (tr2,tr1,CC(0,0,k),CC(ido-1,3,k));
+    T tr3=2*CC(ido-1,1,k);
+    T tr4=2*CC(0,2,k);
+    PM (CH(0,k,0),CH(0,k,2),tr2,tr3);
+    PM (CH(0,k,3),CH(0,k,1),tr1,tr4);
+    }
+  if ((ido&1)==0)
+    for (size_t k=0; k<l1; k++)
+      {
+      T tr1,tr2,ti1,ti2;
+      PM (ti1,ti2,CC(0    ,3,k),CC(0    ,1,k));
+      PM (tr2,tr1,CC(ido-1,0,k),CC(ido-1,2,k));
+      CH(ido-1,k,0)=tr2+tr2;
+      CH(ido-1,k,1)=sqrt2*(tr1-ti1);
+      CH(ido-1,k,2)=ti2+ti2;
+      CH(ido-1,k,3)=-sqrt2*(tr1+ti1);
+      }
+  if (ido<=2) return;
+  for (size_t k=0; k<l1;++k)
+    for (size_t i=2; i<ido; i+=2)
+      {
+      T ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4;
+      size_t ic=ido-i;
+      PM (tr2,tr1,CC(i-1,0,k),CC(ic-1,3,k));
+      PM (ti1,ti2,CC(i  ,0,k),CC(ic  ,3,k));
+      PM (tr4,ti3,CC(i  ,2,k),CC(ic  ,1,k));
+      PM (tr3,ti4,CC(i-1,2,k),CC(ic-1,1,k));
+      PM (CH(i-1,k,0),cr3,tr2,tr3);
+      PM (CH(i  ,k,0),ci3,ti2,ti3);
+      PM (cr4,cr2,tr1,tr4);
+      PM (ci2,ci4,ti1,ti4);
+      MULPM (CH(i,k,1),CH(i-1,k,1),WA(0,i-2),WA(0,i-1),ci2,cr2);
+      MULPM (CH(i,k,2),CH(i-1,k,2),WA(1,i-2),WA(1,i-1),ci3,cr3);
+      MULPM (CH(i,k,3),CH(i-1,k,3),WA(2,i-2),WA(2,i-1),ci4,cr4);
+      }
+  }
+
+template<typename T> void radb5(size_t ido, size_t l1,
+  const T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa) const
+  {
+  constexpr T0 tr11= T0(0.3090169943749474241022934171828191L),
+               ti11= T0(0.9510565162951535721164393333793821L),
+               tr12= T0(-0.8090169943749474241022934171828191L),
+               ti12= T0(0.5877852522924731291687059546390728L);
+
+  auto WA = [wa,ido](size_t x, size_t i) { return wa[i+x*(ido-1)]; };
+  auto CC = [cc,ido](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+5*c)]; };
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+
+  for (size_t k=0; k<l1; k++)
+    {
+    T ti5=CC(0,2,k)+CC(0,2,k);
+    T ti4=CC(0,4,k)+CC(0,4,k);
+    T tr2=CC(ido-1,1,k)+CC(ido-1,1,k);
+    T tr3=CC(ido-1,3,k)+CC(ido-1,3,k);
+    CH(0,k,0)=CC(0,0,k)+tr2+tr3;
+    T cr2=CC(0,0,k)+tr11*tr2+tr12*tr3;
+    T cr3=CC(0,0,k)+tr12*tr2+tr11*tr3;
+    T ci4, ci5;
+    MULPM(ci5,ci4,ti5,ti4,ti11,ti12);
+    PM(CH(0,k,4),CH(0,k,1),cr2,ci5);
+    PM(CH(0,k,3),CH(0,k,2),cr3,ci4);
+    }
+  if (ido==1) return;
+  for (size_t k=0; k<l1;++k)
+    for (size_t i=2, ic=ido-2; i<ido; i+=2, ic-=2)
+      {
+      T tr2, tr3, tr4, tr5, ti2, ti3, ti4, ti5;
+      PM(tr2,tr5,CC(i-1,2,k),CC(ic-1,1,k));
+      PM(ti5,ti2,CC(i  ,2,k),CC(ic  ,1,k));
+      PM(tr3,tr4,CC(i-1,4,k),CC(ic-1,3,k));
+      PM(ti4,ti3,CC(i  ,4,k),CC(ic  ,3,k));
+      CH(i-1,k,0)=CC(i-1,0,k)+tr2+tr3;
+      CH(i  ,k,0)=CC(i  ,0,k)+ti2+ti3;
+      T cr2=CC(i-1,0,k)+tr11*tr2+tr12*tr3;
+      T ci2=CC(i  ,0,k)+tr11*ti2+tr12*ti3;
+      T cr3=CC(i-1,0,k)+tr12*tr2+tr11*tr3;
+      T ci3=CC(i  ,0,k)+tr12*ti2+tr11*ti3;
+      T ci4, ci5, cr5, cr4;
+      MULPM(cr5,cr4,tr5,tr4,ti11,ti12);
+      MULPM(ci5,ci4,ti5,ti4,ti11,ti12);
+      T dr2, dr3, dr4, dr5, di2, di3, di4, di5;
+      PM(dr4,dr3,cr3,ci4);
+      PM(di3,di4,ci3,cr4);
+      PM(dr5,dr2,cr2,ci5);
+      PM(di2,di5,ci2,cr5);
+      MULPM(CH(i,k,1),CH(i-1,k,1),WA(0,i-2),WA(0,i-1),di2,dr2);
+      MULPM(CH(i,k,2),CH(i-1,k,2),WA(1,i-2),WA(1,i-1),di3,dr3);
+      MULPM(CH(i,k,3),CH(i-1,k,3),WA(2,i-2),WA(2,i-1),di4,dr4);
+      MULPM(CH(i,k,4),CH(i-1,k,4),WA(3,i-2),WA(3,i-1),di5,dr5);
+      }
+  }
+
+template<typename T> void radbg(size_t ido, size_t ip, size_t l1,
+  T * POCKETFFT_RESTRICT cc, T * POCKETFFT_RESTRICT ch,
+  const T0 * POCKETFFT_RESTRICT wa, const T0 * POCKETFFT_RESTRICT csarr) const
+  {
+  const size_t cdim=ip;
+  size_t ipph=(ip+1)/ 2;
+  size_t idl1 = ido*l1;
+
+  auto CC = [cc,ido,cdim](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+cdim*c)]; };
+  auto CH = [ch,ido,l1](size_t a, size_t b, size_t c) -> T&
+    { return ch[a+ido*(b+l1*c)]; };
+  auto C1 = [cc,ido,l1](size_t a, size_t b, size_t c) -> const T&
+    { return cc[a+ido*(b+l1*c)]; };
+  auto C2 = [cc,idl1](size_t a, size_t b) -> T&
+    { return cc[a+idl1*b]; };
+  auto CH2 = [ch,idl1](size_t a, size_t b) -> T&
+    { return ch[a+idl1*b]; };
+
+  for (size_t k=0; k<l1; ++k)        // 102
+    for (size_t i=0; i<ido; ++i)     // 101
+      CH(i,k,0) = CC(i,0,k);
+  for (size_t j=1, jc=ip-1; j<ipph; ++j, --jc)   // 108
+    {
+    size_t j2=2*j-1;
+    for (size_t k=0; k<l1; ++k)
+      {
+      CH(0,k,j ) = 2*CC(ido-1,j2,k);
+      CH(0,k,jc) = 2*CC(0,j2+1,k);
+      }
+    }
+
+  if (ido!=1)
+    {
+    for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)   // 111
+      {
+      size_t j2=2*j-1;
+      for (size_t k=0; k<l1; ++k)
+        for (size_t i=1, ic=ido-i-2; i<=ido-2; i+=2, ic-=2)      // 109
+          {
+          CH(i  ,k,j ) = CC(i  ,j2+1,k)+CC(ic  ,j2,k);
+          CH(i  ,k,jc) = CC(i  ,j2+1,k)-CC(ic  ,j2,k);
+          CH(i+1,k,j ) = CC(i+1,j2+1,k)-CC(ic+1,j2,k);
+          CH(i+1,k,jc) = CC(i+1,j2+1,k)+CC(ic+1,j2,k);
+          }
+      }
+    }
+  for (size_t l=1,lc=ip-1; l<ipph; ++l,--lc)
+    {
+    for (size_t ik=0; ik<idl1; ++ik)
+      {
+      C2(ik,l ) = CH2(ik,0)+csarr[2*l]*CH2(ik,1)+csarr[4*l]*CH2(ik,2);
+      C2(ik,lc) = csarr[2*l+1]*CH2(ik,ip-1)+csarr[4*l+1]*CH2(ik,ip-2);
+      }
+    size_t iang=2*l;
+    size_t j=3,jc=ip-3;
+    for(; j<ipph-3; j+=4,jc-=4)
+      {
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 ar1=csarr[2*iang], ai1=csarr[2*iang+1];
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 ar2=csarr[2*iang], ai2=csarr[2*iang+1];
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 ar3=csarr[2*iang], ai3=csarr[2*iang+1];
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 ar4=csarr[2*iang], ai4=csarr[2*iang+1];
+      for (size_t ik=0; ik<idl1; ++ik)
+        {
+        C2(ik,l ) += ar1*CH2(ik,j )+ar2*CH2(ik,j +1)
+                    +ar3*CH2(ik,j +2)+ar4*CH2(ik,j +3);
+        C2(ik,lc) += ai1*CH2(ik,jc)+ai2*CH2(ik,jc-1)
+                    +ai3*CH2(ik,jc-2)+ai4*CH2(ik,jc-3);
+        }
+      }
+    for(; j<ipph-1; j+=2,jc-=2)
+      {
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 ar1=csarr[2*iang], ai1=csarr[2*iang+1];
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 ar2=csarr[2*iang], ai2=csarr[2*iang+1];
+      for (size_t ik=0; ik<idl1; ++ik)
+        {
+        C2(ik,l ) += ar1*CH2(ik,j )+ar2*CH2(ik,j +1);
+        C2(ik,lc) += ai1*CH2(ik,jc)+ai2*CH2(ik,jc-1);
+        }
+      }
+    for(; j<ipph; ++j,--jc)
+      {
+      iang+=l; if(iang>ip) iang-=ip;
+      T0 war=csarr[2*iang], wai=csarr[2*iang+1];
+      for (size_t ik=0; ik<idl1; ++ik)
+        {
+        C2(ik,l ) += war*CH2(ik,j );
+        C2(ik,lc) += wai*CH2(ik,jc);
+        }
+      }
+    }
+  for (size_t j=1; j<ipph; ++j)
+    for (size_t ik=0; ik<idl1; ++ik)
+      CH2(ik,0) += CH2(ik,j);
+  for (size_t j=1, jc=ip-1; j<ipph; ++j,--jc)   // 124
+    for (size_t k=0; k<l1; ++k)
+      PM(CH(0,k,jc),CH(0,k,j),C1(0,k,j),C1(0,k,jc));
+
+  if (ido==1) return;
+
+  for (size_t j=1, jc=ip-1; j<ipph; ++j, --jc)  // 127
+    for (size_t k=0; k<l1; ++k)
+      for (size_t i=1; i<=ido-2; i+=2)
+        {
+        CH(i  ,k,j ) = C1(i  ,k,j)-C1(i+1,k,jc);
+        CH(i  ,k,jc) = C1(i  ,k,j)+C1(i+1,k,jc);
+        CH(i+1,k,j ) = C1(i+1,k,j)+C1(i  ,k,jc);
+        CH(i+1,k,jc) = C1(i+1,k,j)-C1(i  ,k,jc);
+        }
+
+// All in CH
+
+  for (size_t j=1; j<ip; ++j)
+    {
+    size_t is = (j-1)*(ido-1);
+    for (size_t k=0; k<l1; ++k)
+      {
+      size_t idij = is;
+      for (size_t i=1; i<=ido-2; i+=2)
+        {
+        T t1=CH(i,k,j), t2=CH(i+1,k,j);
+        CH(i  ,k,j) = wa[idij]*t1-wa[idij+1]*t2;
+        CH(i+1,k,j) = wa[idij]*t2+wa[idij+1]*t1;
+        idij+=2;
+        }
+      }
+    }
+  }
+
+    template<typename T> void copy_and_norm(T *c, T *p1, T0 fct) const
+      {
+      if (p1!=c)
+        {
+        if (fct!=1.)
+          for (size_t i=0; i<length; ++i)
+            c[i] = fct*p1[i];
+        else
+          std::copy_n (p1, length, c);
+        }
+      else
+        if (fct!=1.)
+          for (size_t i=0; i<length; ++i)
+            c[i] *= fct;
+      }
+
+  public:
+    template<typename T> void exec(T c[], T0 fct, bool r2hc) const
+      {
+      if (length==1) { c[0]*=fct; return; }
+      size_t nf=fact.size();
+      arr<T> ch(length);
+      T *p1=c, *p2=ch.data();
+
+      if (r2hc)
+        for(size_t k1=0, l1=length; k1<nf;++k1)
+          {
+          size_t k=nf-k1-1;
+          size_t ip=fact[k].fct;
+          size_t ido=length / l1;
+          l1 /= ip;
+          if(ip==4)
+            radf4(ido, l1, p1, p2, fact[k].tw);
+          else if(ip==2)
+            radf2(ido, l1, p1, p2, fact[k].tw);
+          else if(ip==3)
+            radf3(ido, l1, p1, p2, fact[k].tw);
+          else if(ip==5)
+            radf5(ido, l1, p1, p2, fact[k].tw);
+          else
+            { radfg(ido, ip, l1, p1, p2, fact[k].tw, fact[k].tws); std::swap (p1,p2); }
+          std::swap (p1,p2);
+          }
+      else
+        for(size_t k=0, l1=1; k<nf; k++)
+          {
+          size_t ip = fact[k].fct,
+                 ido= length/(ip*l1);
+          if(ip==4)
+            radb4(ido, l1, p1, p2, fact[k].tw);
+          else if(ip==2)
+            radb2(ido, l1, p1, p2, fact[k].tw);
+          else if(ip==3)
+            radb3(ido, l1, p1, p2, fact[k].tw);
+          else if(ip==5)
+            radb5(ido, l1, p1, p2, fact[k].tw);
+          else
+            radbg(ido, ip, l1, p1, p2, fact[k].tw, fact[k].tws);
+          std::swap (p1,p2);
+          l1*=ip;
+          }
+
+      copy_and_norm(c,p1,fct);
+      }
+
+  private:
+    void factorize()
+      {
+      size_t len=length;
+      while ((len%4)==0)
+        { add_factor(4); len>>=2; }
+      if ((len%2)==0)
+        {
+        len>>=1;
+        // factor 2 should be at the front of the factor list
+        add_factor(2);
+        std::swap(fact[0].fct, fact.back().fct);
+        }
+      for (size_t divisor=3; divisor*divisor<=len; divisor+=2)
+        while ((len%divisor)==0)
+          {
+          add_factor(divisor);
+          len/=divisor;
+          }
+      if (len>1) add_factor(len);
+      }
+
+    size_t twsize() const
+      {
+      size_t twsz=0, l1=1;
+      for (size_t k=0; k<fact.size(); ++k)
+        {
+        size_t ip=fact[k].fct, ido=length/(l1*ip);
+        twsz+=(ip-1)*(ido-1);
+        if (ip>5) twsz+=2*ip;
+        l1*=ip;
+        }
+      return twsz;
+      }
+
+    void comp_twiddle()
+      {
+      sincos_2pibyn<T0> twid(length);
+      size_t l1=1;
+      T0 *ptr=mem.data();
+      for (size_t k=0; k<fact.size(); ++k)
+        {
+        size_t ip=fact[k].fct, ido=length/(l1*ip);
+        if (k<fact.size()-1) // last factor doesn't need twiddles
+          {
+          fact[k].tw=ptr; ptr+=(ip-1)*(ido-1);
+          for (size_t j=1; j<ip; ++j)
+            for (size_t i=1; i<=(ido-1)/2; ++i)
+              {
+              fact[k].tw[(j-1)*(ido-1)+2*i-2] = twid[j*l1*i].r;
+              fact[k].tw[(j-1)*(ido-1)+2*i-1] = twid[j*l1*i].i;
+              }
+          }
+        if (ip>5) // special factors required by *g functions
+          {
+          fact[k].tws=ptr; ptr+=2*ip;
+          fact[k].tws[0] = 1.;
+          fact[k].tws[1] = 0.;
+          for (size_t i=2, ic=2*ip-2; i<=ic; i+=2, ic-=2)
+            {
+            fact[k].tws[i  ] = twid[i/2*(length/ip)].r;
+            fact[k].tws[i+1] = twid[i/2*(length/ip)].i;
+            fact[k].tws[ic]   = twid[i/2*(length/ip)].r;
+            fact[k].tws[ic+1] = -twid[i/2*(length/ip)].i;
+            }
+          }
+        l1*=ip;
+        }
+      }
+
+  public:
+    POCKETFFT_NOINLINE rfftp(size_t length_)
+      : length(length_)
+      {
+      if (length==0) throw std::runtime_error("zero-length FFT requested");
+      if (length==1) return;
+      factorize();
+      mem.resize(twsize());
+      comp_twiddle();
+      }
+};
+
+//
+// complex Bluestein transforms
+//
+
+template<typename T0> class fftblue
+  {
+  private:
+    size_t n, n2;
+    cfftp<T0> plan;
+    arr<cmplx<T0>> mem;
+    cmplx<T0> *bk, *bkf;
+
+    template<bool fwd, typename T> void fft(cmplx<T> c[], T0 fct) const
+      {
+      arr<cmplx<T>> akf(n2);
+
+      /* initialize a_k and FFT it */
+      for (size_t m=0; m<n; ++m)
+        special_mul<fwd>(c[m],bk[m],akf[m]);
+      auto zero = akf[0]*T0(0);
+      for (size_t m=n; m<n2; ++m)
+        akf[m]=zero;
+
+      plan.exec (akf.data(),1.,true);
+
+      /* do the convolution */
+      akf[0] = akf[0].template special_mul<!fwd>(bkf[0]);
+      for (size_t m=1; m<(n2+1)/2; ++m)
+        {
+        akf[m] = akf[m].template special_mul<!fwd>(bkf[m]);
+        akf[n2-m] = akf[n2-m].template special_mul<!fwd>(bkf[m]);
+        }
+      if ((n2&1)==0)
+        akf[n2/2] = akf[n2/2].template special_mul<!fwd>(bkf[n2/2]);
+
+      /* inverse FFT */
+      plan.exec (akf.data(),1.,false);
+
+      /* multiply by b_k */
+      for (size_t m=0; m<n; ++m)
+        c[m] = akf[m].template special_mul<fwd>(bk[m])*fct;
+      }
+
+  public:
+    POCKETFFT_NOINLINE fftblue(size_t length)
+      : n(length), n2(util::good_size_cmplx(n*2-1)), plan(n2), mem(n+n2/2+1),
+        bk(mem.data()), bkf(mem.data()+n)
+      {
+      /* initialize b_k */
+      sincos_2pibyn<T0> tmp(2*n);
+      bk[0].Set(1, 0);
+
+      size_t coeff=0;
+      for (size_t m=1; m<n; ++m)
+        {
+        coeff+=2*m-1;
+        if (coeff>=2*n) coeff-=2*n;
+        bk[m] = tmp[coeff];
+        }
+
+      /* initialize the zero-padded, Fourier transformed b_k. Add normalisation. */
+      arr<cmplx<T0>> tbkf(n2);
+      T0 xn2 = T0(1)/T0(n2);
+      tbkf[0] = bk[0]*xn2;
+      for (size_t m=1; m<n; ++m)
+        tbkf[m] = tbkf[n2-m] = bk[m]*xn2;
+      for (size_t m=n;m<=(n2-n);++m)
+        tbkf[m].Set(0.,0.);
+      plan.exec(tbkf.data(),1.,true);
+      for (size_t i=0; i<n2/2+1; ++i)
+        bkf[i] = tbkf[i];
+      }
+
+    template<typename T> void exec(cmplx<T> c[], T0 fct, bool fwd) const
+      { fwd ? fft<true>(c,fct) : fft<false>(c,fct); }
+
+    template<typename T> void exec_r(T c[], T0 fct, bool fwd)
+      {
+      arr<cmplx<T>> tmp(n);
+      if (fwd)
+        {
+        auto zero = T0(0)*c[0];
+        for (size_t m=0; m<n; ++m)
+          tmp[m].Set(c[m], zero);
+        fft<true>(tmp.data(),fct);
+        c[0] = tmp[0].r;
+        std::copy_n (&tmp[1].r, n-1, &c[1]);
+        }
+      else
+        {
+        tmp[0].Set(c[0],c[0]*0);
+        std::copy_n (c+1, n-1, &tmp[1].r);
+        if ((n&1)==0) tmp[n/2].i=T0(0)*c[0];
+        for (size_t m=1; 2*m<n; ++m)
+          tmp[n-m].Set(tmp[m].r, -tmp[m].i);
+        fft<false>(tmp.data(),fct);
+        for (size_t m=0; m<n; ++m)
+          c[m] = tmp[m].r;
+        }
+      }
+  };
+
+//
+// flexible (FFTPACK/Bluestein) complex 1D transform
+//
+
+template<typename T0> class pocketfft_c
+  {
+  private:
+    std::unique_ptr<cfftp<T0>> packplan;
+    std::unique_ptr<fftblue<T0>> blueplan;
+    size_t len;
+
+  public:
+    POCKETFFT_NOINLINE pocketfft_c(size_t length)
+      : len(length)
+      {
+      if (length==0) throw std::runtime_error("zero-length FFT requested");
+      size_t tmp = (length<50) ? 0 : util::largest_prime_factor(length);
+      if (tmp*tmp <= length)
+        {
+        packplan=std::unique_ptr<cfftp<T0>>(new cfftp<T0>(length));
+        return;
+        }
+      double comp1 = util::cost_guess(length);
+      double comp2 = 2*util::cost_guess(util::good_size_cmplx(2*length-1));
+      comp2*=1.5; /* fudge factor that appears to give good overall performance */
+      if (comp2<comp1) // use Bluestein
+        blueplan=std::unique_ptr<fftblue<T0>>(new fftblue<T0>(length));
+      else
+        packplan=std::unique_ptr<cfftp<T0>>(new cfftp<T0>(length));
+      }
+
+    template<typename T> POCKETFFT_NOINLINE void exec(cmplx<T> c[], T0 fct, bool fwd) const
+      { packplan ? packplan->exec(c,fct,fwd) : blueplan->exec(c,fct,fwd); }
+
+    size_t length() const { return len; }
+  };
+
+//
+// flexible (FFTPACK/Bluestein) real-valued 1D transform
+//
+
+template<typename T0> class pocketfft_r
+  {
+  private:
+    std::unique_ptr<rfftp<T0>> packplan;
+    std::unique_ptr<fftblue<T0>> blueplan;
+    size_t len;
+
+  public:
+    POCKETFFT_NOINLINE pocketfft_r(size_t length)
+      : len(length)
+      {
+      if (length==0) throw std::runtime_error("zero-length FFT requested");
+      size_t tmp = (length<50) ? 0 : util::largest_prime_factor(length);
+      if (tmp*tmp <= length)
+        {
+        packplan=std::unique_ptr<rfftp<T0>>(new rfftp<T0>(length));
+        return;
+        }
+      double comp1 = 0.5*util::cost_guess(length);
+      double comp2 = 2*util::cost_guess(util::good_size_cmplx(2*length-1));
+      comp2*=1.5; /* fudge factor that appears to give good overall performance */
+      if (comp2<comp1) // use Bluestein
+        blueplan=std::unique_ptr<fftblue<T0>>(new fftblue<T0>(length));
+      else
+        packplan=std::unique_ptr<rfftp<T0>>(new rfftp<T0>(length));
+      }
+
+    template<typename T> POCKETFFT_NOINLINE void exec(T c[], T0 fct, bool fwd) const
+      { packplan ? packplan->exec(c,fct,fwd) : blueplan->exec_r(c,fct,fwd); }
+
+    size_t length() const { return len; }
+  };
+
+
+//
+// sine/cosine transforms
+//
+
+template<typename T0> class T_dct1
+  {
+  private:
+    pocketfft_r<T0> fftplan;
+
+  public:
+    POCKETFFT_NOINLINE T_dct1(size_t length)
+      : fftplan(2*(length-1)) {}
+
+    template<typename T> POCKETFFT_NOINLINE void exec(T c[], T0 fct, bool ortho,
+      int /*type*/, bool /*cosine*/) const
+      {
+      constexpr T0 sqrt2=T0(1.414213562373095048801688724209698L);
+      size_t N=fftplan.length(), n=N/2+1;
+      if (ortho)
+        { c[0]*=sqrt2; c[n-1]*=sqrt2; }
+      arr<T> tmp(N);
+      tmp[0] = c[0];
+      for (size_t i=1; i<n; ++i)
+        tmp[i] = tmp[N-i] = c[i];
+      fftplan.exec(tmp.data(), fct, true);
+      c[0] = tmp[0];
+      for (size_t i=1; i<n; ++i)
+        c[i] = tmp[2*i-1];
+      if (ortho)
+        { c[0]*=sqrt2*T0(0.5); c[n-1]*=sqrt2*T0(0.5); }
+      }
+
+    size_t length() const { return fftplan.length()/2+1; }
+  };
+
+template<typename T0> class T_dst1
+  {
+  private:
+    pocketfft_r<T0> fftplan;
+
+  public:
+    POCKETFFT_NOINLINE T_dst1(size_t length)
+      : fftplan(2*(length+1)) {}
+
+    template<typename T> POCKETFFT_NOINLINE void exec(T c[], T0 fct,
+      bool /*ortho*/, int /*type*/, bool /*cosine*/) const
+      {
+      size_t N=fftplan.length(), n=N/2-1;
+      arr<T> tmp(N);
+      tmp[0] = tmp[n+1] = c[0]*0;
+      for (size_t i=0; i<n; ++i)
+        { tmp[i+1]=c[i]; tmp[N-1-i]=-c[i]; }
+      fftplan.exec(tmp.data(), fct, true);
+      for (size_t i=0; i<n; ++i)
+        c[i] = -tmp[2*i+2];
+      }
+
+    size_t length() const { return fftplan.length()/2-1; }
+  };
+
+template<typename T0> class T_dcst23
+  {
+  private:
+    pocketfft_r<T0> fftplan;
+    std::vector<T0> twiddle;
+
+  public:
+    POCKETFFT_NOINLINE T_dcst23(size_t length)
+      : fftplan(length), twiddle(length)
+      {
+      sincos_2pibyn<T0> tw(4*length);
+      for (size_t i=0; i<length; ++i)
+        twiddle[i] = tw[i+1].r;
+      }
+
+    template<typename T> POCKETFFT_NOINLINE void exec(T c[], T0 fct, bool ortho,
+      int type, bool cosine) const
+      {
+      constexpr T0 sqrt2=T0(1.414213562373095048801688724209698L);
+      size_t N=length();
+      size_t NS2 = (N+1)/2;
+      if (type==2)
+        {
+        if (!cosine)
+          for (size_t k=1; k<N; k+=2)
+            c[k] = -c[k];
+        c[0] *= 2;
+        if ((N&1)==0) c[N-1]*=2;
+        for (size_t k=1; k<N-1; k+=2)
+          MPINPLACE(c[k+1], c[k]);
+        fftplan.exec(c, fct, false);
+        for (size_t k=1, kc=N-1; k<NS2; ++k, --kc)
+          {
+          T t1 = twiddle[k-1]*c[kc]+twiddle[kc-1]*c[k];
+          T t2 = twiddle[k-1]*c[k]-twiddle[kc-1]*c[kc];
+          c[k] = T0(0.5)*(t1+t2); c[kc]=T0(0.5)*(t1-t2);
+          }
+        if ((N&1)==0)
+          c[NS2] *= twiddle[NS2-1];
+        if (!cosine)
+          for (size_t k=0, kc=N-1; k<kc; ++k, --kc)
+            std::swap(c[k], c[kc]);
+        if (ortho) c[0]*=sqrt2*T0(0.5);
+        }
+      else
+        {
+        if (ortho) c[0]*=sqrt2;
+        if (!cosine)
+          for (size_t k=0, kc=N-1; k<NS2; ++k, --kc)
+            std::swap(c[k], c[kc]);
+        for (size_t k=1, kc=N-1; k<NS2; ++k, --kc)
+          {
+          T t1=c[k]+c[kc], t2=c[k]-c[kc];
+          c[k] = twiddle[k-1]*t2+twiddle[kc-1]*t1;
+          c[kc]= twiddle[k-1]*t1-twiddle[kc-1]*t2;
+          }
+        if ((N&1)==0)
+          c[NS2] *= 2*twiddle[NS2-1];
+        fftplan.exec(c, fct, true);
+        for (size_t k=1; k<N-1; k+=2)
+          MPINPLACE(c[k], c[k+1]);
+        if (!cosine)
+          for (size_t k=1; k<N; k+=2)
+            c[k] = -c[k];
+        }
+      }
+
+    size_t length() const { return fftplan.length(); }
+  };
+
+template<typename T0> class T_dcst4
+  {
+  private:
+    size_t N;
+    std::unique_ptr<pocketfft_c<T0>> fft;
+    std::unique_ptr<pocketfft_r<T0>> rfft;
+    arr<cmplx<T0>> C2;
+
+  public:
+    POCKETFFT_NOINLINE T_dcst4(size_t length)
+      : N(length),
+        fft((N&1) ? nullptr : new pocketfft_c<T0>(N/2)),
+        rfft((N&1)? new pocketfft_r<T0>(N) : nullptr),
+        C2((N&1) ? 0 : N/2)
+      {
+      if ((N&1)==0)
+        {
+        sincos_2pibyn<T0> tw(16*N);
+        for (size_t i=0; i<N/2; ++i)
+          C2[i] = conj(tw[8*i+1]);
+        }
+      }
+
+    template<typename T> POCKETFFT_NOINLINE void exec(T c[], T0 fct,
+      bool /*ortho*/, int /*type*/, bool cosine) const
+      {
+      size_t n2 = N/2;
+      if (!cosine)
+        for (size_t k=0, kc=N-1; k<n2; ++k, --kc)
+          std::swap(c[k], c[kc]);
+      if (N&1)
+        {
+        // The following code is derived from the FFTW3 function apply_re11()
+        // and is released under the 3-clause BSD license with friendly
+        // permission of Matteo Frigo and Steven G. Johnson.
+
+        arr<T> y(N);
+        {
+        size_t i=0, m=n2;
+        for (; m<N; ++i, m+=4)
+          y[i] = c[m];
+        for (; m<2*N; ++i, m+=4)
+          y[i] = -c[2*N-m-1];
+        for (; m<3*N; ++i, m+=4)
+          y[i] = -c[m-2*N];
+        for (; m<4*N; ++i, m+=4)
+          y[i] = c[4*N-m-1];
+        for (; i<N; ++i, m+=4)
+          y[i] = c[m-4*N];
+        }
+        rfft->exec(y.data(), fct, true);
+        {
+        auto SGN = [](size_t i)
+           {
+           constexpr T0 sqrt2=T0(1.414213562373095048801688724209698L);
+           return (i&2) ? -sqrt2 : sqrt2;
+           };
+        c[n2] = y[0]*SGN(n2+1);
+        size_t i=0, i1=1, k=1;
+        for (; k<n2; ++i, ++i1, k+=2)
+          {
+          c[i    ] = y[2*k-1]*SGN(i1)     + y[2*k  ]*SGN(i);
+          c[N -i1] = y[2*k-1]*SGN(N -i)   - y[2*k  ]*SGN(N -i1);
+          c[n2-i1] = y[2*k+1]*SGN(n2-i)   - y[2*k+2]*SGN(n2-i1);
+          c[n2+i1] = y[2*k+1]*SGN(n2+i+2) + y[2*k+2]*SGN(n2+i1);
+          }
+        if (k == n2)
+          {
+          c[i   ] = y[2*k-1]*SGN(i+1) + y[2*k]*SGN(i);
+          c[N-i1] = y[2*k-1]*SGN(i+2) + y[2*k]*SGN(i1);
+          }
+        }
+
+        // FFTW-derived code ends here
+        }
+      else
+        {
+        // even length algorithm from
+        // https://www.appletonaudio.com/blog/2013/derivation-of-fast-dct-4-algorithm-based-on-dft/
+        arr<cmplx<T>> y(n2);
+        for(size_t i=0; i<n2; ++i)
+          {
+          y[i].Set(c[2*i],c[N-1-2*i]);
+          y[i] *= C2[i];
+          }
+        fft->exec(y.data(), fct, true);
+        for(size_t i=0, ic=n2-1; i<n2; ++i, --ic)
+          {
+          c[2*i  ] =  2*(y[i ].r*C2[i ].r-y[i ].i*C2[i ].i);
+          c[2*i+1] = -2*(y[ic].i*C2[ic].r+y[ic].r*C2[ic].i);
+          }
+        }
+      if (!cosine)
+        for (size_t k=1; k<N; k+=2)
+          c[k] = -c[k];
+      }
+
+    size_t length() const { return N; }
+  };
+
+
+//
+// multi-D infrastructure
+//
+
+template<typename T> std::shared_ptr<T> get_plan(size_t length)
+  {
+#if POCKETFFT_CACHE_SIZE==0
+  return std::make_shared<T>(length);
+#else
+  constexpr size_t nmax=POCKETFFT_CACHE_SIZE;
+  static std::array<std::shared_ptr<T>, nmax> cache;
+  static std::array<size_t, nmax> last_access{{0}};
+  static size_t access_counter = 0;
+  static std::mutex mut;
+
+  auto find_in_cache = [&]() -> std::shared_ptr<T>
+    {
+    for (size_t i=0; i<nmax; ++i)
+      if (cache[i] && (cache[i]->length()==length))
+        {
+        // no need to update if this is already the most recent entry
+        if (last_access[i]!=access_counter)
+          {
+          last_access[i] = ++access_counter;
+          // Guard against overflow
+          if (access_counter == 0)
+            last_access.fill(0);
+          }
+        return cache[i];
+        }
+
+    return nullptr;
+    };
+
+  {
+  std::lock_guard<std::mutex> lock(mut);
+  auto p = find_in_cache();
+  if (p) return p;
+  }
+  auto plan = std::make_shared<T>(length);
+  {
+  std::lock_guard<std::mutex> lock(mut);
+  auto p = find_in_cache();
+  if (p) return p;
+
+  size_t lru = 0;
+  for (size_t i=1; i<nmax; ++i)
+    if (last_access[i] < last_access[lru])
+      lru = i;
+
+  cache[lru] = plan;
+  last_access[lru] = ++access_counter;
+  }
+  return plan;
+#endif
+  }
+
+class arr_info
+  {
+  protected:
+    shape_t shp;
+    stride_t str;
+
+  public:
+    arr_info(const shape_t &shape_, const stride_t &stride_)
+      : shp(shape_), str(stride_) {}
+    size_t ndim() const { return shp.size(); }
+    size_t size() const { return util::prod(shp); }
+    const shape_t &shape() const { return shp; }
+    size_t shape(size_t i) const { return shp[i]; }
+    const stride_t &stride() const { return str; }
+    const ptrdiff_t &stride(size_t i) const { return str[i]; }
+  };
+
+template<typename T> class cndarr: public arr_info
+  {
+  protected:
+    const char *d;
+
+  public:
+    cndarr(const void *data_, const shape_t &shape_, const stride_t &stride_)
+      : arr_info(shape_, stride_),
+        d(reinterpret_cast<const char *>(data_)) {}
+    const T &operator[](ptrdiff_t ofs) const
+      { return *reinterpret_cast<const T *>(d+ofs); }
+  };
+
+template<typename T> class ndarr: public cndarr<T>
+  {
+  public:
+    ndarr(void *data_, const shape_t &shape_, const stride_t &stride_)
+      : cndarr<T>::cndarr(const_cast<const void *>(data_), shape_, stride_)
+      {}
+    T &operator[](ptrdiff_t ofs)
+      { return *reinterpret_cast<T *>(const_cast<char *>(cndarr<T>::d+ofs)); }
+  };
+
+template<size_t N> class multi_iter
+  {
+  private:
+    shape_t pos;
+    const arr_info &iarr, &oarr;
+    ptrdiff_t p_ii, p_i[N], str_i, p_oi, p_o[N], str_o;
+    size_t idim, rem;
+
+    void advance_i()
+      {
+      for (int i_=int(pos.size())-1; i_>=0; --i_)
+        {
+        auto i = size_t(i_);
+        if (i==idim) continue;
+        p_ii += iarr.stride(i);
+        p_oi += oarr.stride(i);
+        if (++pos[i] < iarr.shape(i))
+          return;
+        pos[i] = 0;
+        p_ii -= ptrdiff_t(iarr.shape(i))*iarr.stride(i);
+        p_oi -= ptrdiff_t(oarr.shape(i))*oarr.stride(i);
+        }
+      }
+
+  public:
+    multi_iter(const arr_info &iarr_, const arr_info &oarr_, size_t idim_)
+      : pos(iarr_.ndim(), 0), iarr(iarr_), oarr(oarr_), p_ii(0),
+        str_i(iarr.stride(idim_)), p_oi(0), str_o(oarr.stride(idim_)),
+        idim(idim_), rem(iarr.size()/iarr.shape(idim))
+      {
+      auto nshares = threading::num_threads();
+      if (nshares==1) return;
+      if (nshares==0) throw std::runtime_error("can't run with zero threads");
+      auto myshare = threading::thread_id();
+      if (myshare>=nshares) throw std::runtime_error("impossible share requested");
+      size_t nbase = rem/nshares;
+      size_t additional = rem%nshares;
+      size_t lo = myshare*nbase + ((myshare<additional) ? myshare : additional);
+      size_t hi = lo+nbase+(myshare<additional);
+      size_t todo = hi-lo;
+
+      size_t chunk = rem;
+      for (size_t i=0; i<pos.size(); ++i)
+        {
+        if (i==idim) continue;
+        chunk /= iarr.shape(i);
+        size_t n_advance = lo/chunk;
+        pos[i] += n_advance;
+        p_ii += ptrdiff_t(n_advance)*iarr.stride(i);
+        p_oi += ptrdiff_t(n_advance)*oarr.stride(i);
+        lo -= n_advance*chunk;
+        }
+      rem = todo;
+      }
+    void advance(size_t n)
+      {
+      if (rem<n) throw std::runtime_error("underrun");
+      for (size_t i=0; i<n; ++i)
+        {
+        p_i[i] = p_ii;
+        p_o[i] = p_oi;
+        advance_i();
+        }
+      rem -= n;
+      }
+    ptrdiff_t iofs(size_t i) const { return p_i[0] + ptrdiff_t(i)*str_i; }
+    ptrdiff_t iofs(size_t j, size_t i) const { return p_i[j] + ptrdiff_t(i)*str_i; }
+    ptrdiff_t oofs(size_t i) const { return p_o[0] + ptrdiff_t(i)*str_o; }
+    ptrdiff_t oofs(size_t j, size_t i) const { return p_o[j] + ptrdiff_t(i)*str_o; }
+    size_t length_in() const { return iarr.shape(idim); }
+    size_t length_out() const { return oarr.shape(idim); }
+    ptrdiff_t stride_in() const { return str_i; }
+    ptrdiff_t stride_out() const { return str_o; }
+    size_t remaining() const { return rem; }
+  };
+
+class simple_iter
+  {
+  private:
+    shape_t pos;
+    const arr_info &arr;
+    ptrdiff_t p;
+    size_t rem;
+
+  public:
+    simple_iter(const arr_info &arr_)
+      : pos(arr_.ndim(), 0), arr(arr_), p(0), rem(arr_.size()) {}
+    void advance()
+      {
+      --rem;
+      for (int i_=int(pos.size())-1; i_>=0; --i_)
+        {
+        auto i = size_t(i_);
+        p += arr.stride(i);
+        if (++pos[i] < arr.shape(i))
+          return;
+        pos[i] = 0;
+        p -= ptrdiff_t(arr.shape(i))*arr.stride(i);
+        }
+      }
+    ptrdiff_t ofs() const { return p; }
+    size_t remaining() const { return rem; }
+  };
+
+class rev_iter
+  {
+  private:
+    shape_t pos;
+    const arr_info &arr;
+    std::vector<char> rev_axis;
+    std::vector<char> rev_jump;
+    size_t last_axis, last_size;
+    shape_t shp;
+    ptrdiff_t p, rp;
+    size_t rem;
+
+  public:
+    rev_iter(const arr_info &arr_, const shape_t &axes)
+      : pos(arr_.ndim(), 0), arr(arr_), rev_axis(arr_.ndim(), 0),
+        rev_jump(arr_.ndim(), 1), p(0), rp(0)
+      {
+      for (auto ax: axes)
+        rev_axis[ax]=1;
+      last_axis = axes.back();
+      last_size = arr.shape(last_axis)/2 + 1;
+      shp = arr.shape();
+      shp[last_axis] = last_size;
+      rem=1;
+      for (auto i: shp)
+        rem *= i;
+      }
+    void advance()
+      {
+      --rem;
+      for (int i_=int(pos.size())-1; i_>=0; --i_)
+        {
+        auto i = size_t(i_);
+        p += arr.stride(i);
+        if (!rev_axis[i])
+          rp += arr.stride(i);
+        else
+          {
+          rp -= arr.stride(i);
+          if (rev_jump[i])
+            {
+            rp += ptrdiff_t(arr.shape(i))*arr.stride(i);
+            rev_jump[i] = 0;
+            }
+          }
+        if (++pos[i] < shp[i])
+          return;
+        pos[i] = 0;
+        p -= ptrdiff_t(shp[i])*arr.stride(i);
+        if (rev_axis[i])
+          {
+          rp -= ptrdiff_t(arr.shape(i)-shp[i])*arr.stride(i);
+          rev_jump[i] = 1;
+          }
+        else
+          rp -= ptrdiff_t(shp[i])*arr.stride(i);
+        }
+      }
+    ptrdiff_t ofs() const { return p; }
+    ptrdiff_t rev_ofs() const { return rp; }
+    size_t remaining() const { return rem; }
+  };
+
+template<typename T> struct VTYPE {};
+template <typename T> using vtype_t = typename VTYPE<T>::type;
+
+#ifndef POCKETFFT_NO_VECTORS
+template<> struct VTYPE<float>
+  {
+  using type = float __attribute__ ((vector_size (VLEN<float>::val*sizeof(float))));
+  };
+template<> struct VTYPE<double>
+  {
+  using type = double __attribute__ ((vector_size (VLEN<double>::val*sizeof(double))));
+  };
+template<> struct VTYPE<long double>
+  {
+  using type = long double __attribute__ ((vector_size (VLEN<long double>::val*sizeof(long double))));
+  };
+#endif
+
+template<typename T> arr<char> alloc_tmp(const shape_t &shape,
+  size_t axsize, size_t elemsize)
+  {
+  auto othersize = util::prod(shape)/axsize;
+  auto tmpsize = axsize*((othersize>=VLEN<T>::val) ? VLEN<T>::val : 1);
+  return arr<char>(tmpsize*elemsize);
+  }
+template<typename T> arr<char> alloc_tmp(const shape_t &shape,
+  const shape_t &axes, size_t elemsize)
+  {
+  size_t fullsize=util::prod(shape);
+  size_t tmpsize=0;
+  for (size_t i=0; i<axes.size(); ++i)
+    {
+    auto axsize = shape[axes[i]];
+    auto othersize = fullsize/axsize;
+    auto sz = axsize*((othersize>=VLEN<T>::val) ? VLEN<T>::val : 1);
+    if (sz>tmpsize) tmpsize=sz;
+    }
+  return arr<char>(tmpsize*elemsize);
+  }
+
+template <typename T, size_t vlen> void copy_input(const multi_iter<vlen> &it,
+  const cndarr<cmplx<T>> &src, cmplx<vtype_t<T>> *POCKETFFT_RESTRICT dst)
+  {
+  for (size_t i=0; i<it.length_in(); ++i)
+    for (size_t j=0; j<vlen; ++j)
+      {
+      dst[i].r[j] = src[it.iofs(j,i)].r;
+      dst[i].i[j] = src[it.iofs(j,i)].i;
+      }
+  }
+
+template <typename T, size_t vlen> void copy_input(const multi_iter<vlen> &it,
+  const cndarr<T> &src, vtype_t<T> *POCKETFFT_RESTRICT dst)
+  {
+  for (size_t i=0; i<it.length_in(); ++i)
+    for (size_t j=0; j<vlen; ++j)
+      dst[i][j] = src[it.iofs(j,i)];
+  }
+
+template <typename T, size_t vlen> void copy_input(const multi_iter<vlen> &it,
+  const cndarr<T> &src, T *POCKETFFT_RESTRICT dst)
+  {
+  if (dst == &src[it.iofs(0)]) return;  // in-place
+  for (size_t i=0; i<it.length_in(); ++i)
+    dst[i] = src[it.iofs(i)];
+  }
+
+template<typename T, size_t vlen> void copy_output(const multi_iter<vlen> &it,
+  const cmplx<vtype_t<T>> *POCKETFFT_RESTRICT src, ndarr<cmplx<T>> &dst)
+  {
+  for (size_t i=0; i<it.length_out(); ++i)
+    for (size_t j=0; j<vlen; ++j)
+      dst[it.oofs(j,i)].Set(src[i].r[j],src[i].i[j]);
+  }
+
+template<typename T, size_t vlen> void copy_output(const multi_iter<vlen> &it,
+  const vtype_t<T> *POCKETFFT_RESTRICT src, ndarr<T> &dst)
+  {
+  for (size_t i=0; i<it.length_out(); ++i)
+    for (size_t j=0; j<vlen; ++j)
+      dst[it.oofs(j,i)] = src[i][j];
+  }
+
+template<typename T, size_t vlen> void copy_output(const multi_iter<vlen> &it,
+  const T *POCKETFFT_RESTRICT src, ndarr<T> &dst)
+  {
+  if (src == &dst[it.oofs(0)]) return;  // in-place
+  for (size_t i=0; i<it.length_out(); ++i)
+    dst[it.oofs(i)] = src[i];
+  }
+
+template <typename T> struct add_vec { using type = vtype_t<T>; };
+template <typename T> struct add_vec<cmplx<T>>
+  { using type = cmplx<vtype_t<T>>; };
+template <typename T> using add_vec_t = typename add_vec<T>::type;
+
+template<typename Tplan, typename T, typename T0, typename Exec>
+POCKETFFT_NOINLINE void general_nd(const cndarr<T> &in, ndarr<T> &out,
+  const shape_t &axes, T0 fct, size_t nthreads, const Exec & exec,
+  const bool allow_inplace=true)
+  {
+  std::shared_ptr<Tplan> plan;
+
+  for (size_t iax=0; iax<axes.size(); ++iax)
+    {
+    size_t len=in.shape(axes[iax]);
+    if ((!plan) || (len!=plan->length()))
+      plan = get_plan<Tplan>(len);
+
+    threading::thread_map(
+      util::thread_count(nthreads, in.shape(), axes[iax], VLEN<T>::val),
+      [&] {
+        constexpr auto vlen = VLEN<T0>::val;
+        auto storage = alloc_tmp<T0>(in.shape(), len, sizeof(T));
+        const auto &tin(iax==0? in : out);
+        multi_iter<vlen> it(tin, out, axes[iax]);
+#ifndef POCKETFFT_NO_VECTORS
+        if (vlen>1)
+          while (it.remaining()>=vlen)
+            {
+            it.advance(vlen);
+            auto tdatav = reinterpret_cast<add_vec_t<T> *>(storage.data());
+            exec(it, tin, out, tdatav, *plan, fct);
+            }
+#endif
+        while (it.remaining()>0)
+          {
+          it.advance(1);
+          auto buf = allow_inplace && it.stride_out() == sizeof(T) ?
+            &out[it.oofs(0)] : reinterpret_cast<T *>(storage.data());
+          exec(it, tin, out, buf, *plan, fct);
+          }
+      });  // end of parallel region
+    fct = T0(1); // factor has been applied, use 1 for remaining axes
+    }
+  }
+
+struct ExecC2C
+  {
+  bool forward;
+
+  template <typename T0, typename T, size_t vlen> void operator () (
+    const multi_iter<vlen> &it, const cndarr<cmplx<T0>> &in,
+    ndarr<cmplx<T0>> &out, T * buf, const pocketfft_c<T0> &plan, T0 fct) const
+    {
+    copy_input(it, in, buf);
+    plan.exec(buf, fct, forward);
+    copy_output(it, buf, out);
+    }
+  };
+
+template <typename T, size_t vlen> void copy_hartley(const multi_iter<vlen> &it,
+  const vtype_t<T> *POCKETFFT_RESTRICT src, ndarr<T> &dst)
+  {
+  for (size_t j=0; j<vlen; ++j)
+    dst[it.oofs(j,0)] = src[0][j];
+  size_t i=1, i1=1, i2=it.length_out()-1;
+  for (i=1; i<it.length_out()-1; i+=2, ++i1, --i2)
+    for (size_t j=0; j<vlen; ++j)
+      {
+        dst[it.oofs(j,i1)] = src[i][j]+src[i+1][j];
+        dst[it.oofs(j,i2)] = src[i][j]-src[i+1][j];
+      }
+  if (i<it.length_out())
+    for (size_t j=0; j<vlen; ++j)
+      dst[it.oofs(j,i1)] = src[i][j];
+  }
+
+template <typename T, size_t vlen> void copy_hartley(const multi_iter<vlen> &it,
+  const T *POCKETFFT_RESTRICT src, ndarr<T> &dst)
+  {
+  dst[it.oofs(0)] = src[0];
+  size_t i=1, i1=1, i2=it.length_out()-1;
+  for (i=1; i<it.length_out()-1; i+=2, ++i1, --i2)
+    {
+    dst[it.oofs(i1)] = src[i]+src[i+1];
+    dst[it.oofs(i2)] = src[i]-src[i+1];
+    }
+  if (i<it.length_out())
+    dst[it.oofs(i1)] = src[i];
+  }
+
+struct ExecHartley
+  {
+  template <typename T0, typename T, size_t vlen> void operator () (
+    const multi_iter<vlen> &it, const cndarr<T0> &in, ndarr<T0> &out,
+    T * buf, const pocketfft_r<T0> &plan, T0 fct) const
+    {
+    copy_input(it, in, buf);
+    plan.exec(buf, fct, true);
+    copy_hartley(it, buf, out);
+    }
+  };
+
+struct ExecDcst
+  {
+  bool ortho;
+  int type;
+  bool cosine;
+
+  template <typename T0, typename T, typename Tplan, size_t vlen>
+  void operator () (const multi_iter<vlen> &it, const cndarr<T0> &in,
+    ndarr<T0> &out, T * buf, const Tplan &plan, T0 fct) const
+    {
+    copy_input(it, in, buf);
+    plan.exec(buf, fct, ortho, type, cosine);
+    copy_output(it, buf, out);
+    }
+  };
+
+template<typename T> POCKETFFT_NOINLINE void general_r2c(
+  const cndarr<T> &in, ndarr<cmplx<T>> &out, size_t axis, bool forward, T fct,
+  size_t nthreads)
+  {
+  auto plan = get_plan<pocketfft_r<T>>(in.shape(axis));
+  size_t len=in.shape(axis);
+  threading::thread_map(
+    util::thread_count(nthreads, in.shape(), axis, VLEN<T>::val),
+    [&] {
+    constexpr auto vlen = VLEN<T>::val;
+    auto storage = alloc_tmp<T>(in.shape(), len, sizeof(T));
+    multi_iter<vlen> it(in, out, axis);
+#ifndef POCKETFFT_NO_VECTORS
+    if (vlen>1)
+      while (it.remaining()>=vlen)
+        {
+        it.advance(vlen);
+        auto tdatav = reinterpret_cast<vtype_t<T> *>(storage.data());
+        copy_input(it, in, tdatav);
+        plan->exec(tdatav, fct, true);
+        for (size_t j=0; j<vlen; ++j)
+          out[it.oofs(j,0)].Set(tdatav[0][j]);
+        size_t i=1, ii=1;
+        if (forward)
+          for (; i<len-1; i+=2, ++ii)
+            for (size_t j=0; j<vlen; ++j)
+              out[it.oofs(j,ii)].Set(tdatav[i][j], tdatav[i+1][j]);
+        else
+          for (; i<len-1; i+=2, ++ii)
+            for (size_t j=0; j<vlen; ++j)
+              out[it.oofs(j,ii)].Set(tdatav[i][j], -tdatav[i+1][j]);
+        if (i<len)
+          for (size_t j=0; j<vlen; ++j)
+            out[it.oofs(j,ii)].Set(tdatav[i][j]);
+        }
+#endif
+    while (it.remaining()>0)
+      {
+      it.advance(1);
+      auto tdata = reinterpret_cast<T *>(storage.data());
+      copy_input(it, in, tdata);
+      plan->exec(tdata, fct, true);
+      out[it.oofs(0)].Set(tdata[0]);
+      size_t i=1, ii=1;
+      if (forward)
+        for (; i<len-1; i+=2, ++ii)
+          out[it.oofs(ii)].Set(tdata[i], tdata[i+1]);
+      else
+        for (; i<len-1; i+=2, ++ii)
+          out[it.oofs(ii)].Set(tdata[i], -tdata[i+1]);
+      if (i<len)
+        out[it.oofs(ii)].Set(tdata[i]);
+      }
+    });  // end of parallel region
+  }
+template<typename T> POCKETFFT_NOINLINE void general_c2r(
+  const cndarr<cmplx<T>> &in, ndarr<T> &out, size_t axis, bool forward, T fct,
+  size_t nthreads)
+  {
+  auto plan = get_plan<pocketfft_r<T>>(out.shape(axis));
+  size_t len=out.shape(axis);
+  threading::thread_map(
+    util::thread_count(nthreads, in.shape(), axis, VLEN<T>::val),
+    [&] {
+      constexpr auto vlen = VLEN<T>::val;
+      auto storage = alloc_tmp<T>(out.shape(), len, sizeof(T));
+      multi_iter<vlen> it(in, out, axis);
+#ifndef POCKETFFT_NO_VECTORS
+      if (vlen>1)
+        while (it.remaining()>=vlen)
+          {
+          it.advance(vlen);
+          auto tdatav = reinterpret_cast<vtype_t<T> *>(storage.data());
+          for (size_t j=0; j<vlen; ++j)
+            tdatav[0][j]=in[it.iofs(j,0)].r;
+          {
+          size_t i=1, ii=1;
+          if (forward)
+            for (; i<len-1; i+=2, ++ii)
+              for (size_t j=0; j<vlen; ++j)
+                {
+                tdatav[i  ][j] =  in[it.iofs(j,ii)].r;
+                tdatav[i+1][j] = -in[it.iofs(j,ii)].i;
+                }
+          else
+            for (; i<len-1; i+=2, ++ii)
+              for (size_t j=0; j<vlen; ++j)
+                {
+                tdatav[i  ][j] = in[it.iofs(j,ii)].r;
+                tdatav[i+1][j] = in[it.iofs(j,ii)].i;
+                }
+          if (i<len)
+            for (size_t j=0; j<vlen; ++j)
+              tdatav[i][j] = in[it.iofs(j,ii)].r;
+          }
+          plan->exec(tdatav, fct, false);
+          copy_output(it, tdatav, out);
+          }
+#endif
+      while (it.remaining()>0)
+        {
+        it.advance(1);
+        auto tdata = reinterpret_cast<T *>(storage.data());
+        tdata[0]=in[it.iofs(0)].r;
+        {
+        size_t i=1, ii=1;
+        if (forward)
+          for (; i<len-1; i+=2, ++ii)
+            {
+            tdata[i  ] =  in[it.iofs(ii)].r;
+            tdata[i+1] = -in[it.iofs(ii)].i;
+            }
+        else
+          for (; i<len-1; i+=2, ++ii)
+            {
+            tdata[i  ] = in[it.iofs(ii)].r;
+            tdata[i+1] = in[it.iofs(ii)].i;
+            }
+        if (i<len)
+          tdata[i] = in[it.iofs(ii)].r;
+        }
+        plan->exec(tdata, fct, false);
+        copy_output(it, tdata, out);
+        }
+    });  // end of parallel region
+  }
+
+struct ExecR2R
+  {
+  bool r2h, forward;
+
+  template <typename T0, typename T, size_t vlen> void operator () (
+    const multi_iter<vlen> &it, const cndarr<T0> &in, ndarr<T0> &out, T * buf,
+    const pocketfft_r<T0> &plan, T0 fct) const
+    {
+    copy_input(it, in, buf);
+    if ((!r2h) && forward)
+      for (size_t i=2; i<it.length_out(); i+=2)
+        buf[i] = -buf[i];
+    plan.exec(buf, fct, r2h);
+    if (r2h && (!forward))
+      for (size_t i=2; i<it.length_out(); i+=2)
+        buf[i] = -buf[i];
+    copy_output(it, buf, out);
+    }
+  };
+
+template<typename T> void c2c(const shape_t &shape, const stride_t &stride_in,
+  const stride_t &stride_out, const shape_t &axes, bool forward,
+  const std::complex<T> *data_in, std::complex<T> *data_out, T fct,
+  size_t nthreads=1)
+  {
+  if (util::prod(shape)==0) return;
+  util::sanity_check(shape, stride_in, stride_out, data_in==data_out, axes);
+  cndarr<cmplx<T>> ain(data_in, shape, stride_in);
+  ndarr<cmplx<T>> aout(data_out, shape, stride_out);
+  general_nd<pocketfft_c<T>>(ain, aout, axes, fct, nthreads, ExecC2C{forward});
+  }
+
+template<typename T> void dct(const shape_t &shape,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  int type, const T *data_in, T *data_out, T fct, bool ortho, size_t nthreads=1)
+  {
+  if ((type<1) || (type>4)) throw std::invalid_argument("invalid DCT type");
+  if (util::prod(shape)==0) return;
+  util::sanity_check(shape, stride_in, stride_out, data_in==data_out, axes);
+  cndarr<T> ain(data_in, shape, stride_in);
+  ndarr<T> aout(data_out, shape, stride_out);
+  const ExecDcst exec{ortho, type, true};
+  if (type==1)
+    general_nd<T_dct1<T>>(ain, aout, axes, fct, nthreads, exec);
+  else if (type==4)
+    general_nd<T_dcst4<T>>(ain, aout, axes, fct, nthreads, exec);
+  else
+    general_nd<T_dcst23<T>>(ain, aout, axes, fct, nthreads, exec);
+  }
+
+template<typename T> void dst(const shape_t &shape,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  int type, const T *data_in, T *data_out, T fct, bool ortho, size_t nthreads=1)
+  {
+  if ((type<1) || (type>4)) throw std::invalid_argument("invalid DST type");
+  if (util::prod(shape)==0) return;
+  util::sanity_check(shape, stride_in, stride_out, data_in==data_out, axes);
+  cndarr<T> ain(data_in, shape, stride_in);
+  ndarr<T> aout(data_out, shape, stride_out);
+  const ExecDcst exec{ortho, type, false};
+  if (type==1)
+    general_nd<T_dst1<T>>(ain, aout, axes, fct, nthreads, exec);
+  else if (type==4)
+    general_nd<T_dcst4<T>>(ain, aout, axes, fct, nthreads, exec);
+  else
+    general_nd<T_dcst23<T>>(ain, aout, axes, fct, nthreads, exec);
+  }
+
+template<typename T> void r2c(const shape_t &shape_in,
+  const stride_t &stride_in, const stride_t &stride_out, size_t axis,
+  bool forward, const T *data_in, std::complex<T> *data_out, T fct,
+  size_t nthreads=1)
+  {
+  if (util::prod(shape_in)==0) return;
+  util::sanity_check(shape_in, stride_in, stride_out, false, axis);
+  cndarr<T> ain(data_in, shape_in, stride_in);
+  shape_t shape_out(shape_in);
+  shape_out[axis] = shape_in[axis]/2 + 1;
+  ndarr<cmplx<T>> aout(data_out, shape_out, stride_out);
+  general_r2c(ain, aout, axis, forward, fct, nthreads);
+  }
+
+template<typename T> void r2c(const shape_t &shape_in,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  bool forward, const T *data_in, std::complex<T> *data_out, T fct,
+  size_t nthreads=1)
+  {
+  if (util::prod(shape_in)==0) return;
+  util::sanity_check(shape_in, stride_in, stride_out, false, axes);
+  r2c(shape_in, stride_in, stride_out, axes.back(), forward, data_in, data_out,
+    fct, nthreads);
+  if (axes.size()==1) return;
+
+  shape_t shape_out(shape_in);
+  shape_out[axes.back()] = shape_in[axes.back()]/2 + 1;
+  auto newaxes = shape_t{axes.begin(), --axes.end()};
+  c2c(shape_out, stride_out, stride_out, newaxes, forward, data_out, data_out,
+    T(1), nthreads);
+  }
+
+template<typename T> void c2r(const shape_t &shape_out,
+  const stride_t &stride_in, const stride_t &stride_out, size_t axis,
+  bool forward, const std::complex<T> *data_in, T *data_out, T fct,
+  size_t nthreads=1)
+  {
+  if (util::prod(shape_out)==0) return;
+  util::sanity_check(shape_out, stride_in, stride_out, false, axis);
+  shape_t shape_in(shape_out);
+  shape_in[axis] = shape_out[axis]/2 + 1;
+  cndarr<cmplx<T>> ain(data_in, shape_in, stride_in);
+  ndarr<T> aout(data_out, shape_out, stride_out);
+  general_c2r(ain, aout, axis, forward, fct, nthreads);
+  }
+
+template<typename T> void c2r(const shape_t &shape_out,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  bool forward, const std::complex<T> *data_in, T *data_out, T fct,
+  size_t nthreads=1)
+  {
+  if (util::prod(shape_out)==0) return;
+  if (axes.size()==1)
+    return c2r(shape_out, stride_in, stride_out, axes[0], forward,
+      data_in, data_out, fct, nthreads);
+  util::sanity_check(shape_out, stride_in, stride_out, false, axes);
+  auto shape_in = shape_out;
+  shape_in[axes.back()] = shape_out[axes.back()]/2 + 1;
+  auto nval = util::prod(shape_in);
+  stride_t stride_inter(shape_in.size());
+  stride_inter.back() = sizeof(cmplx<T>);
+  for (int i=int(shape_in.size())-2; i>=0; --i)
+    stride_inter[size_t(i)] =
+      stride_inter[size_t(i+1)]*ptrdiff_t(shape_in[size_t(i+1)]);
+  arr<std::complex<T>> tmp(nval);
+  auto newaxes = shape_t{axes.begin(), --axes.end()};
+  c2c(shape_in, stride_in, stride_inter, newaxes, forward, data_in, tmp.data(),
+    T(1), nthreads);
+  c2r(shape_out, stride_inter, stride_out, axes.back(), forward,
+    tmp.data(), data_out, fct, nthreads);
+  }
+
+template<typename T> void r2r_fftpack(const shape_t &shape,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  bool real2hermitian, bool forward, const T *data_in, T *data_out, T fct,
+  size_t nthreads=1)
+  {
+  if (util::prod(shape)==0) return;
+  util::sanity_check(shape, stride_in, stride_out, data_in==data_out, axes);
+  cndarr<T> ain(data_in, shape, stride_in);
+  ndarr<T> aout(data_out, shape, stride_out);
+  general_nd<pocketfft_r<T>>(ain, aout, axes, fct, nthreads,
+    ExecR2R{real2hermitian, forward});
+  }
+
+template<typename T> void r2r_separable_hartley(const shape_t &shape,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  const T *data_in, T *data_out, T fct, size_t nthreads=1)
+  {
+  if (util::prod(shape)==0) return;
+  util::sanity_check(shape, stride_in, stride_out, data_in==data_out, axes);
+  cndarr<T> ain(data_in, shape, stride_in);
+  ndarr<T> aout(data_out, shape, stride_out);
+  general_nd<pocketfft_r<T>>(ain, aout, axes, fct, nthreads, ExecHartley{},
+    false);
+  }
+
+template<typename T> void r2r_genuine_hartley(const shape_t &shape,
+  const stride_t &stride_in, const stride_t &stride_out, const shape_t &axes,
+  const T *data_in, T *data_out, T fct, size_t nthreads=1)
+  {
+  if (util::prod(shape)==0) return;
+  if (axes.size()==1)
+    return r2r_separable_hartley(shape, stride_in, stride_out, axes, data_in,
+      data_out, fct, nthreads);
+  util::sanity_check(shape, stride_in, stride_out, data_in==data_out, axes);
+  shape_t tshp(shape);
+  tshp[axes.back()] = tshp[axes.back()]/2+1;
+  arr<std::complex<T>> tdata(util::prod(tshp));
+  stride_t tstride(shape.size());
+  tstride.back()=sizeof(std::complex<T>);
+  for (size_t i=tstride.size()-1; i>0; --i)
+    tstride[i-1]=tstride[i]*ptrdiff_t(tshp[i]);
+  r2c(shape, stride_in, tstride, axes, true, data_in, tdata.data(), fct, nthreads);
+  cndarr<cmplx<T>> atmp(tdata.data(), tshp, tstride);
+  ndarr<T> aout(data_out, shape, stride_out);
+  simple_iter iin(atmp);
+  rev_iter iout(aout, axes);
+  while(iin.remaining()>0)
+    {
+    auto v = atmp[iin.ofs()];
+    aout[iout.ofs()] = v.r+v.i;
+    aout[iout.rev_ofs()] = v.r-v.i;
+    iin.advance(); iout.advance();
+    }
+  }
+
+} // namespace detail
+
+using detail::FORWARD;
+using detail::BACKWARD;
+using detail::shape_t;
+using detail::stride_t;
+using detail::c2c;
+using detail::c2r;
+using detail::r2c;
+using detail::r2r_fftpack;
+using detail::r2r_separable_hartley;
+using detail::r2r_genuine_hartley;
+using detail::dct;
+using detail::dst;
+
+} // namespace pocketfft
+
+#undef POCKETFFT_NOINLINE
+#undef POCKETFFT_RESTRICT
+
+#endif // POCKETFFT_HDRONLY_H
diff --git a/ml-stable-diffusion/mlx/mlx/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7aa6485338a498eeef18bd704f1c2df74e6f490d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/CMakeLists.txt
@@ -0,0 +1,67 @@
+target_sources(
+  mlx
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/allocator.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/array.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/compile.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/device.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/dtype.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/dtype_utils.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/export.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/einsum.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/fast.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/fft.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/ops.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/graph_utils.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/primitives.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/random.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/scheduler.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/transforms.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/utils.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/linalg.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/backend/metal/metal.h)
+
+# Define MLX_VERSION only in the version.cpp file.
+add_library(mlx_version OBJECT ${CMAKE_CURRENT_SOURCE_DIR}/version.cpp)
+target_compile_definitions(mlx_version PRIVATE MLX_VERSION="${MLX_VERSION}")
+target_link_libraries(mlx PRIVATE $<BUILD_INTERFACE:mlx_version>)
+
+if(MSVC)
+  # Disable some MSVC warnings to speed up compilation.
+  target_compile_options(mlx PUBLIC /wd4068 /wd4244 /wd4267 /wd4804)
+endif()
+
+if(WIN32)
+  # Export symbols by default to behave like macOS/linux.
+  set_target_properties(mlx PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
+endif()
+
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backend/common)
+
+if(MLX_BUILD_CPU)
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backend/cpu)
+else()
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backend/no_cpu)
+endif()
+
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/distributed)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/io)
+
+if(MLX_BUILD_METAL)
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backend/metal)
+else()
+  target_sources(mlx
+                 PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/backend/metal/no_metal.cpp)
+endif()
+
+if(MLX_BUILD_CUDA)
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backend/cuda)
+else()
+  target_sources(mlx
+                 PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/backend/cuda/no_cuda.cpp)
+endif()
+
+if(MLX_BUILD_METAL OR MLX_BUILD_CUDA)
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backend/gpu)
+else()
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/backend/no_gpu)
+endif()
diff --git a/ml-stable-diffusion/mlx/mlx/allocator.cpp b/ml-stable-diffusion/mlx/mlx/allocator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fbfca75511d4c02b24962093f43a620084f7600e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/allocator.cpp
@@ -0,0 +1,24 @@
+// Copyright © 2023 Apple Inc.
+
+#include <cstdlib>
+#include <sstream>
+
+#include "mlx/allocator.h"
+
+namespace mlx::core::allocator {
+
+Buffer malloc(size_t size) {
+  auto buffer = allocator().malloc(size);
+  if (size && !buffer.ptr()) {
+    std::ostringstream msg;
+    msg << "[malloc] Unable to allocate " << size << " bytes.";
+    throw std::runtime_error(msg.str());
+  }
+  return buffer;
+}
+
+void free(Buffer buffer) {
+  allocator().free(buffer);
+}
+
+} // namespace mlx::core::allocator
diff --git a/ml-stable-diffusion/mlx/mlx/allocator.h b/ml-stable-diffusion/mlx/mlx/allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..362f4f08a6ad72e6f17699a3addc8f18747fbaba
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/allocator.h
@@ -0,0 +1,52 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <cstdlib>
+
+namespace mlx::core::allocator {
+
+// Simple wrapper around buffer pointers
+// WARNING: Only Buffer objects constructed from and those that wrap
+//          raw pointers from mlx::allocator are supported.
+class Buffer {
+ private:
+  void* ptr_;
+
+ public:
+  Buffer(void* ptr) : ptr_(ptr) {};
+
+  // Get the raw data pointer from the buffer
+  void* raw_ptr();
+
+  // Get the buffer pointer from the buffer
+  const void* ptr() const {
+    return ptr_;
+  };
+  void* ptr() {
+    return ptr_;
+  };
+};
+
+Buffer malloc(size_t size);
+
+void free(Buffer buffer);
+
+class Allocator {
+  /** Abstract base class for a memory allocator. */
+ public:
+  virtual Buffer malloc(size_t size) = 0;
+  virtual void free(Buffer buffer) = 0;
+  virtual size_t size(Buffer buffer) const = 0;
+
+  Allocator() = default;
+  Allocator(const Allocator& other) = delete;
+  Allocator(Allocator&& other) = delete;
+  Allocator& operator=(const Allocator& other) = delete;
+  Allocator& operator=(Allocator&& other) = delete;
+  virtual ~Allocator() = default;
+};
+
+Allocator& allocator();
+
+} // namespace mlx::core::allocator
diff --git a/ml-stable-diffusion/mlx/mlx/array.cpp b/ml-stable-diffusion/mlx/mlx/array.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d8d12e0db42dd9f4fd9e0325ddd50207e9c4e7ce
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/array.cpp
@@ -0,0 +1,330 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <functional>
+#include <unordered_map>
+
+#include "mlx/array.h"
+#include "mlx/ops.h"
+#include "mlx/primitives.h"
+#include "mlx/transforms.h"
+#include "mlx/transforms_impl.h"
+
+namespace mlx::core {
+
+array::array(const std::complex<float>& val, Dtype dtype /* = complex64 */)
+    : array_desc_(std::make_shared<ArrayDesc>(Shape{}, dtype)) {
+  auto cval = static_cast<complex64_t>(val);
+  init(&cval);
+}
+
+array::array(
+    Shape shape,
+    Dtype dtype,
+    std::shared_ptr<Primitive> primitive,
+    std::vector<array> inputs)
+    : array_desc_(std::make_shared<ArrayDesc>(
+          std::move(shape),
+          dtype,
+          std::move(primitive),
+          std::move(inputs))) {
+  if (has_primitive() && this->primitive().stream().device == Device::gpu) {
+    for (auto& in : this->inputs()) {
+      if (in.dtype() == float64) {
+        throw std::invalid_argument("float64 is not supported on the GPU");
+      }
+    }
+    if (this->dtype() == float64) {
+      throw std::invalid_argument("float64 is not supported on the GPU");
+    }
+  }
+}
+
+std::vector<array> array::make_arrays(
+    std::vector<Shape> shapes,
+    const std::vector<Dtype>& dtypes,
+    const std::shared_ptr<Primitive>& primitive,
+    const std::vector<array>& inputs) {
+  std::vector<array> outputs;
+  for (size_t i = 0; i < shapes.size(); ++i) {
+    outputs.emplace_back(std::move(shapes[i]), dtypes[i], primitive, inputs);
+  }
+  // For each node in |outputs|, its siblings are the other nodes.
+  for (size_t i = 0; i < outputs.size(); ++i) {
+    auto siblings = outputs;
+    siblings.erase(siblings.begin() + i);
+    outputs[i].set_siblings(std::move(siblings), i);
+  }
+  return outputs;
+}
+
+array array::unsafe_weak_copy(const array& other) {
+  auto cpy = array(other.shape(), other.dtype(), nullptr, {});
+  cpy.set_data(
+      other.buffer(),
+      other.data_size(),
+      other.strides(),
+      other.flags(),
+      [](auto) {});
+  cpy.array_desc_->data_ptr = other.array_desc_->data_ptr;
+  return cpy;
+}
+
+array::array(std::initializer_list<float> data)
+    : array_desc_(std::make_shared<ArrayDesc>(
+          Shape{static_cast<ShapeElem>(data.size())},
+          float32)) {
+  init(data.begin());
+}
+
+array::array(std::initializer_list<int> data, Dtype dtype)
+    : array_desc_(std::make_shared<ArrayDesc>(
+          Shape{static_cast<ShapeElem>(data.size())},
+          dtype)) {
+  init(data.begin());
+}
+
+/* Build an array from a shared buffer */
+array::array(allocator::Buffer data, Shape shape, Dtype dtype, Deleter deleter)
+    : array_desc_(std::make_shared<ArrayDesc>(std::move(shape), dtype)) {
+  set_data(data, deleter);
+}
+
+void array::detach() {
+  array_desc_->primitive = nullptr;
+  for (auto& s : array_desc_->siblings) {
+    s.array_desc_->primitive = nullptr;
+  }
+  for (auto& s : array_desc_->siblings) {
+    s.array_desc_->inputs.clear();
+    s.array_desc_->siblings.clear();
+    s.array_desc_->position = 0;
+  }
+  array_desc_->inputs.clear();
+  array_desc_->siblings.clear();
+  array_desc_->position = 0;
+}
+
+bool array::is_available() const {
+  if (status() == Status::available) {
+    return true;
+  } else if (
+      status() == Status::evaluated &&
+      (!event().valid() || event().is_signaled())) {
+    set_status(Status::available);
+    return true;
+  }
+  return false;
+}
+
+void array::wait() {
+  if (!is_available()) {
+    if (event().valid()) {
+      event().wait();
+      detach_event();
+    }
+    set_status(Status::available);
+  }
+}
+
+void array::eval() {
+  // Ensure the array is ready to be read
+  if (status() == Status::unscheduled) {
+    mlx::core::eval({*this});
+  } else {
+    wait();
+  }
+}
+
+bool array::is_tracer() const {
+  return (array_desc_->is_tracer && detail::in_tracing()) ||
+      detail::retain_graph();
+}
+
+void array::set_data(allocator::Buffer buffer, Deleter d) {
+  array_desc_->data = std::make_shared<Data>(buffer, d);
+  array_desc_->data_ptr = buffer.raw_ptr();
+  array_desc_->data_size = size();
+  array_desc_->flags.contiguous = true;
+  array_desc_->flags.row_contiguous = true;
+  auto max_dim = std::max_element(shape().begin(), shape().end());
+  array_desc_->flags.col_contiguous = size() <= 1 || size() == *max_dim;
+}
+
+void array::set_data(
+    allocator::Buffer buffer,
+    size_t data_size,
+    Strides strides,
+    Flags flags,
+    Deleter d) {
+  array_desc_->data = std::make_shared<Data>(buffer, d);
+  array_desc_->data_ptr = buffer.raw_ptr();
+  array_desc_->data_size = data_size;
+  array_desc_->strides = std::move(strides);
+  array_desc_->flags = flags;
+}
+
+void array::copy_shared_buffer(
+    const array& other,
+    const Strides& strides,
+    Flags flags,
+    size_t data_size,
+    size_t offset /* = 0 */) {
+  array_desc_->data = other.array_desc_->data;
+  array_desc_->strides = strides;
+  array_desc_->flags = flags;
+  array_desc_->data_size = data_size;
+  auto char_offset = sizeof(char) * itemsize() * offset;
+  array_desc_->data_ptr = static_cast<void*>(
+      static_cast<char*>(other.array_desc_->data_ptr) + char_offset);
+}
+
+void array::copy_shared_buffer(const array& other) {
+  copy_shared_buffer(other, other.strides(), other.flags(), other.data_size());
+}
+
+array::~array() {
+  if (array_desc_ == nullptr) {
+    return;
+  }
+
+  // Detached/detaching
+  if (array_desc_->primitive == nullptr) {
+    return;
+  }
+
+  // Break circular reference for non-detached arrays with siblings
+  if (auto n = siblings().size(); n > 0) {
+    bool do_detach = true;
+    // If all siblings have siblings.size() references except
+    // the one we are currently destroying (which has siblings.size() + 1)
+    // then there are no more external references
+    do_detach &= (array_desc_.use_count() == (n + 1));
+    for (auto& s : siblings()) {
+      do_detach &= (s.array_desc_.use_count() == n);
+      if (!do_detach) {
+        break;
+      }
+    }
+    if (do_detach) {
+      for (auto& s : siblings()) {
+        for (auto& ss : s.siblings()) {
+          // Set to null here to avoid descending into array destructor
+          // for siblings
+          ss.array_desc_ = nullptr;
+        }
+        s.array_desc_->siblings.clear();
+      }
+    }
+  }
+}
+
+void array::ArrayDesc::init() {
+  strides.resize(shape.size());
+  size = 1;
+  for (int i = shape.size() - 1; i >= 0; --i) {
+    strides[i] = size;
+    size *= shape[i];
+  }
+  for (const auto& in : inputs) {
+    is_tracer |= in.is_tracer();
+  }
+}
+
+array::ArrayDesc::ArrayDesc(Shape shape, Dtype dtype)
+    : shape(std::move(shape)), dtype(dtype), status(Status::available) {
+  init();
+}
+
+array::ArrayDesc::ArrayDesc(
+    Shape shape,
+    Dtype dtype,
+    std::shared_ptr<Primitive> primitive,
+    std::vector<array> inputs)
+    : shape(std::move(shape)),
+      dtype(dtype),
+      status(Status::unscheduled),
+      primitive(std::move(primitive)),
+      inputs(std::move(inputs)) {
+  init();
+}
+
+array::ArrayDesc::~ArrayDesc() {
+  // When an array description is destroyed it will delete a bunch of arrays
+  // that may also destroy their corresponding descriptions and so on and so
+  // forth.
+  //
+  // This calls recursively the destructor and can result in stack overflow, we
+  // instead put them in a vector and destroy them one at a time resulting in a
+  // max stack depth of 2.
+  if (inputs.empty()) {
+    return;
+  }
+
+  std::vector<std::shared_ptr<ArrayDesc>> for_deletion;
+
+  auto append_deletable_inputs = [&for_deletion](ArrayDesc& ad) {
+    std::unordered_map<std::uintptr_t, array> input_map;
+    for (array& a : ad.inputs) {
+      if (a.array_desc_) {
+        input_map.insert({a.id(), a});
+        for (auto& s : a.siblings()) {
+          input_map.insert({s.id(), s});
+        }
+      }
+    }
+    ad.inputs.clear();
+    for (auto& [_, a] : input_map) {
+      bool is_deletable =
+          (a.array_desc_.use_count() <= a.siblings().size() + 1);
+      // An array with siblings is deletable only if all of its siblings
+      // are deletable
+      for (auto& s : a.siblings()) {
+        if (!is_deletable) {
+          break;
+        }
+        int is_input = (input_map.find(s.id()) != input_map.end());
+        is_deletable &=
+            s.array_desc_.use_count() <= a.siblings().size() + is_input;
+      }
+      if (is_deletable) {
+        for_deletion.push_back(std::move(a.array_desc_));
+      }
+    }
+  };
+
+  append_deletable_inputs(*this);
+
+  while (!for_deletion.empty()) {
+    // top is going to be deleted at the end of the block *after* the arrays
+    // with inputs have been moved into the vector
+    auto top = std::move(for_deletion.back());
+    for_deletion.pop_back();
+    append_deletable_inputs(*top);
+
+    // Clear out possible siblings to break circular references
+    for (auto& s : top->siblings) {
+      // Set to null here to avoid descending into top-level
+      // array destructor for siblings
+      s.array_desc_ = nullptr;
+    }
+    top->siblings.clear();
+  }
+}
+
+array::ArrayIterator::ArrayIterator(const array& arr, int idx)
+    : arr(arr), idx(idx) {
+  if (arr.ndim() == 0) {
+    throw std::invalid_argument("Cannot iterate over 0-d array.");
+  }
+}
+
+array::ArrayIterator::reference array::ArrayIterator::operator*() const {
+  auto start = Shape(arr.ndim(), 0);
+  auto end = arr.shape();
+  auto shape = arr.shape();
+  shape.erase(shape.begin());
+  start[0] = idx;
+  end[0] = idx + 1;
+  return reshape(slice(arr, start, end), shape);
+};
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/array.h b/ml-stable-diffusion/mlx/mlx/array.h
new file mode 100644
index 0000000000000000000000000000000000000000..4e9a5ae63ad5f036d73af7c54136fc510801a83b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/array.h
@@ -0,0 +1,622 @@
+// Copyright © 2023 Apple Inc.
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include "mlx/allocator.h"
+#include "mlx/dtype.h"
+#include "mlx/event.h"
+#include "mlx/small_vector.h"
+
+namespace mlx::core {
+
+// Forward declaration
+class Primitive;
+
+using Deleter = std::function<void(allocator::Buffer)>;
+using ShapeElem = int32_t;
+using Shape = SmallVector<ShapeElem>;
+using Strides = SmallVector<int64_t>;
+
+class array {
+  /* An array is really a node in a graph. It contains a shared ArrayDesc
+   * object */
+
+ public:
+  /** Construct a scalar array with zero dimensions. */
+  template <typename T>
+  explicit array(T val, Dtype dtype = TypeToDtype<T>());
+
+  /* Special case since std::complex can't be implicitly converted to other
+   * types. */
+  explicit array(const std::complex<float>& val, Dtype dtype = complex64);
+
+  template <typename It>
+  explicit array(
+      It data,
+      Shape shape,
+      Dtype dtype =
+          TypeToDtype<typename std::iterator_traits<It>::value_type>());
+
+  template <typename T>
+  explicit array(std::initializer_list<T> data, Dtype dtype = TypeToDtype<T>());
+
+  /* Special case so empty lists default to float32. */
+  explicit array(std::initializer_list<float> data);
+
+  /* Special case so array({}, type) is an empty array. */
+  explicit array(std::initializer_list<int> data, Dtype dtype);
+
+  template <typename T>
+  explicit array(
+      std::initializer_list<T> data,
+      Shape shape,
+      Dtype dtype = TypeToDtype<T>());
+
+  /* Build an array from a buffer */
+  explicit array(
+      allocator::Buffer data,
+      Shape shape,
+      Dtype dtype,
+      Deleter deleter = allocator::free);
+
+  /** Assignment to rvalue does not compile. */
+  array& operator=(const array& other) && = delete;
+  array& operator=(array&& other) && = delete;
+
+  /** Default copy and move constructors otherwise. */
+  array& operator=(array&& other) & = default;
+  array(const array& other) = default;
+  array(array&& other) = default;
+
+  array& operator=(const array& other) & {
+    if (this->id() != other.id()) {
+      this->array_desc_ = other.array_desc_;
+    }
+    return *this;
+  }
+
+  /** The size of the array's datatype in bytes. */
+  size_t itemsize() const {
+    return size_of(dtype());
+  }
+
+  /** The number of elements in the array. */
+  size_t size() const {
+    return array_desc_->size;
+  }
+
+  /** The number of bytes in the array. */
+  size_t nbytes() const {
+    return size() * itemsize();
+  }
+
+  /** The number of dimensions of the array. */
+  size_t ndim() const {
+    return array_desc_->shape.size();
+  }
+
+  /** The shape of the array as a vector of integers. */
+  const Shape& shape() const {
+    return array_desc_->shape;
+  }
+
+  /**
+   *  Get the size of the corresponding dimension.
+   *
+   *  This function supports negative indexing and provides
+   *  bounds checking. */
+  auto shape(int dim) const {
+    return shape().at(dim < 0 ? dim + ndim() : dim);
+  }
+
+  /** The strides of the array. */
+  const Strides& strides() const {
+    return array_desc_->strides;
+  }
+
+  /**
+   *  Get the stride of the corresponding dimension.
+   *
+   *  This function supports negative indexing and provides
+   *  bounds checking. */
+  auto strides(int dim) const {
+    return strides().at(dim < 0 ? dim + ndim() : dim);
+  }
+
+  /** Get the arrays data type. */
+  Dtype dtype() const {
+    return array_desc_->dtype;
+  }
+
+  /** Evaluate the array. */
+  void eval();
+
+  /** Get the value from a scalar array. */
+  template <typename T>
+  T item();
+
+  template <typename T>
+  T item() const;
+
+  struct ArrayIterator {
+    using iterator_category = std::random_access_iterator_tag;
+    using difference_type = size_t;
+    using value_type = const array;
+    using reference = value_type;
+
+    explicit ArrayIterator(const array& arr, int idx = 0);
+
+    reference operator*() const;
+
+    ArrayIterator& operator+(difference_type diff) {
+      idx += diff;
+      return *this;
+    }
+
+    ArrayIterator& operator++() {
+      idx++;
+      return *this;
+    }
+
+    friend bool operator==(const ArrayIterator& a, const ArrayIterator& b) {
+      return a.arr.id() == b.arr.id() && a.idx == b.idx;
+    }
+    friend bool operator!=(const ArrayIterator& a, const ArrayIterator& b) {
+      return !(a == b);
+    }
+
+   private:
+    const array& arr;
+    int idx;
+  };
+
+  ArrayIterator begin() const {
+    return ArrayIterator(*this);
+  }
+  ArrayIterator end() const {
+    return ArrayIterator(*this, shape(0));
+  }
+
+  /**
+   * The following methods should be used with caution.
+   * They are intended for use by the backend implementation and the
+   * API may change.
+   */
+
+  array(
+      Shape shape,
+      Dtype dtype,
+      std::shared_ptr<Primitive> primitive,
+      std::vector<array> inputs);
+
+  static std::vector<array> make_arrays(
+      std::vector<Shape> shapes,
+      const std::vector<Dtype>& dtypes,
+      const std::shared_ptr<Primitive>& primitive,
+      const std::vector<array>& inputs);
+
+  /**
+   * Get a new array that refers to the same data as the input but with a
+   * non-owning pointer to it. Note the array is detached from the graph and has
+   * no inputs, siblings or primitive.
+   */
+  static array unsafe_weak_copy(const array& other);
+
+  /** A unique identifier for an array. */
+  std::uintptr_t id() const {
+    return reinterpret_cast<std::uintptr_t>(array_desc_.get());
+  }
+
+  /** A unique identifier for an arrays primitive. */
+  std::uintptr_t primitive_id() const {
+    return reinterpret_cast<std::uintptr_t>(array_desc_->primitive.get());
+  }
+
+  struct Data {
+    allocator::Buffer buffer;
+    Deleter d;
+    Data(allocator::Buffer buffer, Deleter d = allocator::free)
+        : buffer(buffer), d(d) {}
+    // Not copyable
+    Data(const Data& d) = delete;
+    Data& operator=(const Data& d) = delete;
+    Data(Data&& o) : buffer(o.buffer), d(o.d) {
+      o.buffer = allocator::Buffer(nullptr);
+      o.d = [](allocator::Buffer) {};
+    }
+    ~Data() {
+      d(buffer);
+    }
+  };
+
+  struct Flags {
+    // True iff there are no gaps in the underlying data. Each item
+    // in the underlying data buffer belongs to at least one index.
+    //
+    // True iff:
+    // prod(shape[i] for i in range(ndim) if strides[i] > 0) == data_size()
+    bool contiguous : 1;
+
+    // True iff:
+    // strides[-1] == 1 and
+    // all(strides[i] == (shape[i+1]*strides[i+1]) or shape[i] == 1 for i in
+    // range(ndim - 1))
+    bool row_contiguous : 1;
+
+    // True iff:
+    // strides[0] == 1 and
+    // all(strides[i] == (shape[i-1]*strides[i-1]) or shape[i] == 1 for i in
+    // range(1, ndim))
+    bool col_contiguous : 1;
+  };
+
+  /** The array's primitive. */
+  Primitive& primitive() const {
+    return *(array_desc_->primitive);
+  }
+
+  /** A shared pointer to the array's primitive. */
+  std::shared_ptr<Primitive>& primitive_ptr() const {
+    return array_desc_->primitive;
+  }
+
+  /** Check if the array has an attached primitive or is a leaf node. */
+  bool has_primitive() const {
+    return array_desc_->primitive != nullptr;
+  }
+
+  /** The array's inputs. */
+  const std::vector<array>& inputs() const {
+    return array_desc_->inputs;
+  }
+
+  std::vector<array>& inputs() {
+    return array_desc_->inputs;
+  }
+
+  /** True indicates the arrays buffer is safe to reuse */
+  bool is_donatable() const {
+    return array_desc_.use_count() == 1 && (array_desc_->data.use_count() == 1);
+  }
+
+  /** The array's siblings. */
+  const std::vector<array>& siblings() const {
+    return array_desc_->siblings;
+  }
+
+  /** The array's siblings. */
+  std::vector<array>& siblings() {
+    return array_desc_->siblings;
+  }
+
+  void set_siblings(std::vector<array> siblings, uint16_t position) {
+    array_desc_->siblings = std::move(siblings);
+    array_desc_->position = position;
+  }
+
+  /** The outputs of the array's primitive (i.e. this array and
+   * its siblings) in the order the primitive expects. */
+  std::vector<array> outputs() const {
+    auto idx = array_desc_->position;
+    std::vector<array> outputs;
+    outputs.reserve(siblings().size() + 1);
+    outputs.insert(outputs.end(), siblings().begin(), siblings().begin() + idx);
+    outputs.push_back(*this);
+    outputs.insert(outputs.end(), siblings().begin() + idx, siblings().end());
+    return outputs;
+  }
+
+  /** Detach the array from the graph. */
+  void detach();
+
+  /** Get the Flags bit-field. */
+  const Flags& flags() const {
+    return array_desc_->flags;
+  }
+
+  /** The size (in elements) of the underlying buffer the array points to.
+   *
+   * This can be different than the actual size of the array if the array has
+   * been broadcast or irregularly strided.  If ``first`` is the offset into
+   * the data buffer of the first element of the array (i.e. the offset
+   * corresponding to ``arr[0, 0, ...]``) and last is the offset into the
+   * data buffer of the last element of the array (i.e. the offset
+   * corresponding to ``arr[-1, -1, ...]``) then ``data_size = last - first``.
+   * Note, ``data_size`` is in units of ``item_size`` (not bytes).
+   **/
+  size_t data_size() const {
+    return array_desc_->data_size;
+  }
+
+  allocator::Buffer& buffer() {
+    return array_desc_->data->buffer;
+  }
+  const allocator::Buffer& buffer() const {
+    return array_desc_->data->buffer;
+  }
+
+  size_t buffer_size() const {
+    return allocator::allocator().size(buffer());
+  }
+
+  // Return the shared pointer to the array::Data struct
+  const std::shared_ptr<Data>& data_shared_ptr() const {
+    return array_desc_->data;
+  }
+
+  // Return a raw pointer to the arrays data
+  template <typename T>
+  T* data() {
+    return static_cast<T*>(array_desc_->data_ptr);
+  }
+
+  template <typename T>
+  const T* data() const {
+    return static_cast<T*>(array_desc_->data_ptr);
+  }
+
+  enum Status {
+    // The output of a computation which has not been scheduled.
+    // For example, the status of `x` in `auto x = a + b`.
+    unscheduled,
+
+    // The array's `eval_*` function has been run, but the computation is not
+    // necessarily complete. The array will have memory allocated and if it is
+    // not a tracer then it will be detached from the graph.
+    evaluated,
+
+    // If the array is the output of a computation then the computation
+    // is complete. Constant arrays are always available (e.g. `array({1, 2,
+    // 3})`)
+    available
+  };
+
+  // Check if the array is safe to read.
+  bool is_available() const;
+
+  // Wait on the array to be available. After this `is_available` returns
+  // `true`.
+  void wait();
+
+  Status status() const {
+    return array_desc_->status;
+  }
+
+  void set_status(Status s) const {
+    array_desc_->status = s;
+  }
+
+  // Get the array's shared event
+  Event& event() const {
+    return array_desc_->event;
+  }
+
+  // Attach an event to a not yet evaluated array
+  void attach_event(Event e) const {
+    array_desc_->event = std::move(e);
+  }
+
+  void detach_event() const {
+    array_desc_->event = Event{};
+  }
+
+  // Mark the array as a tracer array (true) or not.
+  void set_tracer(bool is_tracer) {
+    array_desc_->is_tracer = is_tracer;
+  }
+  // Check if the array is a tracer array
+  bool is_tracer() const;
+
+  void set_data(allocator::Buffer buffer, Deleter d = allocator::free);
+
+  void set_data(
+      allocator::Buffer buffer,
+      size_t data_size,
+      Strides strides,
+      Flags flags,
+      Deleter d = allocator::free);
+
+  void copy_shared_buffer(
+      const array& other,
+      const Strides& strides,
+      Flags flags,
+      size_t data_size,
+      size_t offset = 0);
+
+  void copy_shared_buffer(const array& other);
+
+  void overwrite_descriptor(const array& other) {
+    array_desc_ = other.array_desc_;
+  }
+
+  ~array();
+
+ private:
+  // Initialize the arrays data
+  template <typename It>
+  void init(const It src);
+
+  struct ArrayDesc {
+    Shape shape;
+    Strides strides;
+    size_t size;
+    Dtype dtype;
+    std::shared_ptr<Primitive> primitive;
+
+    Status status;
+
+    // An event on the array used for synchronization
+    Event event;
+
+    // Indicates an array is being used in a graph transform
+    // and should not be detached from the graph
+    bool is_tracer{false};
+
+    // This is a shared pointer so that *different* arrays
+    // can share the underlying data buffer.
+    std::shared_ptr<Data> data;
+
+    // Properly offset data pointer
+    void* data_ptr{nullptr};
+
+    // The size in elements of the data buffer the array accesses
+    size_t data_size;
+
+    // Contains useful meta data about the array
+    Flags flags;
+
+    std::vector<array> inputs;
+    // An array to keep track of the siblings from a multi-output
+    // primitive.
+    std::vector<array> siblings;
+    // The arrays position in the output list
+    uint32_t position{0};
+
+    explicit ArrayDesc(Shape shape, Dtype dtype);
+
+    explicit ArrayDesc(
+        Shape shape,
+        Dtype dtype,
+        std::shared_ptr<Primitive> primitive,
+        std::vector<array> inputs);
+
+    ~ArrayDesc();
+
+   private:
+    // Initialize size, strides, and other metadata
+    void init();
+  };
+
+  // The ArrayDesc contains the details of the materialized array including the
+  // shape, strides, the data type. It also includes
+  // the primitive which knows how to compute the array's data from its inputs
+  // and the list of array's inputs for the primitive.
+  std::shared_ptr<ArrayDesc> array_desc_;
+};
+
+template <typename T>
+array::array(T val, Dtype dtype /* = TypeToDtype<T>() */)
+    : array_desc_(std::make_shared<ArrayDesc>(Shape{}, dtype)) {
+  init(&val);
+}
+
+template <typename It>
+array::array(
+  It data,
+  Shape shape,
+  Dtype dtype /* = TypeToDtype<typename std::iterator_traits<It>::value_type>() */) :
+    array_desc_(std::make_shared<ArrayDesc>(std::move(shape), dtype)) {
+  init(data);
+}
+
+template <typename T>
+array::array(
+    std::initializer_list<T> data,
+    Dtype dtype /* = TypeToDtype<T>() */)
+    : array_desc_(std::make_shared<ArrayDesc>(
+          Shape{static_cast<ShapeElem>(data.size())},
+          dtype)) {
+  init(data.begin());
+}
+
+template <typename T>
+array::array(
+    std::initializer_list<T> data,
+    Shape shape,
+    Dtype dtype /* = TypeToDtype<T>() */)
+    : array_desc_(std::make_shared<ArrayDesc>(std::move(shape), dtype)) {
+  if (data.size() != size()) {
+    throw std::invalid_argument(
+        "Data size and provided shape mismatch in array construction.");
+  }
+  init(data.begin());
+}
+
+template <typename T>
+T array::item() {
+  if (size() != 1) {
+    throw std::invalid_argument("item can only be called on arrays of size 1.");
+  }
+  eval();
+  return *data<T>();
+}
+
+template <typename T>
+T array::item() const {
+  if (size() != 1) {
+    throw std::invalid_argument("item can only be called on arrays of size 1.");
+  }
+  if (status() == Status::unscheduled) {
+    throw std::invalid_argument(
+        "item() const can only be called on evaled arrays");
+  }
+  const_cast<array*>(this)->eval();
+  return *data<T>();
+}
+
+template <typename It>
+void array::init(It src) {
+  set_data(allocator::malloc(size() * size_of(dtype())));
+  switch (dtype()) {
+    case bool_:
+      std::copy(src, src + size(), data<bool>());
+      break;
+    case uint8:
+      std::copy(src, src + size(), data<uint8_t>());
+      break;
+    case uint16:
+      std::copy(src, src + size(), data<uint16_t>());
+      break;
+    case uint32:
+      std::copy(src, src + size(), data<uint32_t>());
+      break;
+    case uint64:
+      std::copy(src, src + size(), data<uint64_t>());
+      break;
+    case int8:
+      std::copy(src, src + size(), data<int8_t>());
+      break;
+    case int16:
+      std::copy(src, src + size(), data<int16_t>());
+      break;
+    case int32:
+      std::copy(src, src + size(), data<int32_t>());
+      break;
+    case int64:
+      std::copy(src, src + size(), data<int64_t>());
+      break;
+    case float16:
+      std::copy(src, src + size(), data<float16_t>());
+      break;
+    case float32:
+      std::copy(src, src + size(), data<float>());
+      break;
+    case float64:
+      std::copy(src, src + size(), data<double>());
+      break;
+    case bfloat16:
+      std::copy(src, src + size(), data<bfloat16_t>());
+      break;
+    case complex64:
+      std::copy(src, src + size(), data<complex64_t>());
+      break;
+  }
+}
+
+/* Utilities for determining whether a template parameter is array. */
+template <typename T>
+inline constexpr bool is_array_v =
+    std::is_same_v<std::remove_cv_t<std::remove_reference_t<T>>, array>;
+
+template <typename... T>
+inline constexpr bool is_arrays_v = (is_array_v<T> && ...);
+
+template <typename... T>
+using enable_for_arrays_t = typename std::enable_if_t<is_arrays_v<T...>>;
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/backend/common/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6c4e25067b8f6a3740901fd1834d0deaf50d869b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/CMakeLists.txt
@@ -0,0 +1,9 @@
+target_sources(
+  mlx
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/broadcasting.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/compiled.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/common.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/load.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/reduce.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/slicing.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/utils.cpp)
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/binary.h b/ml-stable-diffusion/mlx/mlx/backend/common/binary.h
new file mode 100644
index 0000000000000000000000000000000000000000..ac6e1891dd9a7cf39c0685d42f567b92f8ea275e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/binary.h
@@ -0,0 +1,97 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/allocator.h"
+#include "mlx/array.h"
+#include "mlx/backend/common/utils.h"
+
+namespace mlx::core {
+
+enum class BinaryOpType {
+  ScalarScalar,
+  ScalarVector,
+  VectorScalar,
+  VectorVector,
+  General,
+};
+
+inline BinaryOpType get_binary_op_type(const array& a, const array& b) {
+  BinaryOpType bopt;
+  if (a.data_size() == 1 && b.data_size() == 1) {
+    bopt = BinaryOpType::ScalarScalar;
+  } else if (a.data_size() == 1 && b.flags().contiguous) {
+    bopt = BinaryOpType::ScalarVector;
+  } else if (b.data_size() == 1 && a.flags().contiguous) {
+    bopt = BinaryOpType::VectorScalar;
+  } else if (
+      (a.flags().row_contiguous && b.flags().row_contiguous) ||
+      (a.flags().col_contiguous && b.flags().col_contiguous)) {
+    bopt = BinaryOpType::VectorVector;
+  } else {
+    bopt = BinaryOpType::General;
+  }
+  return bopt;
+}
+
+inline void set_binary_op_output_data(
+    const array& a,
+    const array& b,
+    array& out,
+    BinaryOpType bopt) {
+  bool b_donatable = is_donatable(b, out);
+  bool a_donatable = is_donatable(a, out);
+  switch (bopt) {
+    case BinaryOpType::ScalarScalar:
+      out.set_data(
+          allocator::malloc(out.itemsize()), 1, a.strides(), a.flags());
+      break;
+    case BinaryOpType::ScalarVector:
+      if (b_donatable) {
+        out.copy_shared_buffer(b);
+      } else {
+        out.set_data(
+            allocator::malloc(b.data_size() * out.itemsize()),
+            b.data_size(),
+            b.strides(),
+            b.flags());
+      }
+      break;
+    case BinaryOpType::VectorScalar:
+      if (a_donatable) {
+        out.copy_shared_buffer(a);
+      } else {
+        out.set_data(
+            allocator::malloc(a.data_size() * out.itemsize()),
+            a.data_size(),
+            a.strides(),
+            a.flags());
+      }
+      break;
+    case BinaryOpType::VectorVector:
+      if (a_donatable) {
+        out.copy_shared_buffer(a);
+      } else if (b_donatable) {
+        out.copy_shared_buffer(b);
+      } else {
+        out.set_data(
+            allocator::malloc(a.data_size() * out.itemsize()),
+            a.data_size(),
+            a.strides(),
+            a.flags());
+      }
+      break;
+    case BinaryOpType::General:
+      if (a_donatable && a.flags().row_contiguous && a.size() == out.size()) {
+        out.copy_shared_buffer(a);
+      } else if (
+          b_donatable && b.flags().row_contiguous && b.size() == out.size()) {
+        out.copy_shared_buffer(b);
+      } else {
+        out.set_data(allocator::malloc(out.nbytes()));
+      }
+      break;
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp b/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..49bc75b8f7b38634d51c48b6b5cffaa0b1c7867a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.cpp
@@ -0,0 +1,24 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/backend/common/utils.h"
+
+namespace mlx::core {
+
+void broadcast(const array& in, array& out) {
+  if (out.size() == 0) {
+    out.set_data(nullptr);
+    return;
+  }
+  Strides strides(out.ndim(), 0);
+  int diff = out.ndim() - in.ndim();
+  for (int i = in.ndim() - 1; i >= 0; --i) {
+    strides[i + diff] = (in.shape()[i] == 1) ? 0 : in.strides()[i];
+  }
+  auto flags = in.flags();
+  if (out.size() > in.size()) {
+    flags.row_contiguous = flags.col_contiguous = false;
+  }
+  out.copy_shared_buffer(in, strides, flags, in.data_size());
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.h b/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.h
new file mode 100644
index 0000000000000000000000000000000000000000..29651e90963c864b5db61113b6abaa80eecf22a6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/broadcasting.h
@@ -0,0 +1,11 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+void broadcast(const array& in, array& out);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/buffer_cache.h b/ml-stable-diffusion/mlx/mlx/backend/common/buffer_cache.h
new file mode 100644
index 0000000000000000000000000000000000000000..92b20f222cb4e1b09b8c34f0eec318b1a6832e52
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/buffer_cache.h
@@ -0,0 +1,157 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include <cassert>
+#include <functional>
+#include <map>
+
+namespace mlx::core {
+
+template <typename T>
+class BufferCache {
+ public:
+  BufferCache(
+      size_t page_size,
+      std::function<size_t(T*)> get_size,
+      std::function<void(T*)> free)
+      : page_size_(page_size),
+        get_size_(std::move(get_size)),
+        free_(std::move(free)) {}
+
+  ~BufferCache() {
+    clear();
+  }
+
+  BufferCache(const BufferCache&) = delete;
+  BufferCache& operator=(const BufferCache&) = delete;
+
+  T* reuse_from_cache(size_t size) {
+    // Find the closest buffer in pool.
+    auto it = buffer_pool_.lower_bound(size);
+    if (it == buffer_pool_.end() ||
+        it->first >= std::min(2 * size, size + 2 * page_size_)) {
+      return nullptr;
+    }
+
+    // Collect from the cache.
+    T* buf = it->second->buf;
+    pool_size_ -= it->first;
+
+    // Remove from record.
+    remove_from_list(it->second);
+    buffer_pool_.erase(it);
+    return buf;
+  }
+
+  void recycle_to_cache(T* buf) {
+    assert(buf);
+    // Add to cache.
+    BufferHolder* bh = new BufferHolder(buf);
+    add_at_head(bh);
+    size_t size = get_size_(buf);
+    pool_size_ += size;
+    buffer_pool_.emplace(size, bh);
+  }
+
+  int release_cached_buffers(size_t min_bytes_to_free) {
+    if (min_bytes_to_free >= 0.9 * pool_size_) {
+      return clear();
+    } else {
+      int n_release = 0;
+      size_t total_bytes_freed = 0;
+
+      while (tail_ && (total_bytes_freed < min_bytes_to_free)) {
+        // Release buffer.
+        size_t size = get_size_(tail_->buf);
+        total_bytes_freed += size;
+        free_(tail_->buf);
+        n_release++;
+
+        // Remove from record.
+        auto its = buffer_pool_.equal_range(size);
+        auto it = std::find_if(its.first, its.second, [this](const auto& el) {
+          return el.second == tail_;
+        });
+        assert(it != buffer_pool_.end());
+        buffer_pool_.erase(it);
+        remove_from_list(tail_);
+      }
+
+      pool_size_ -= total_bytes_freed;
+      return n_release;
+    }
+  }
+
+  int clear() {
+    int n_release = 0;
+    for (auto& [size, holder] : buffer_pool_) {
+      free_(holder->buf);
+      n_release++;
+      delete holder;
+    }
+    buffer_pool_.clear();
+    pool_size_ = 0;
+    head_ = nullptr;
+    tail_ = nullptr;
+    return n_release;
+  }
+
+  size_t cache_size() const {
+    return pool_size_;
+  }
+
+  size_t page_size() const {
+    return page_size_;
+  }
+
+ private:
+  struct BufferHolder {
+   public:
+    explicit BufferHolder(T* buf_) : buf(buf_) {}
+
+    BufferHolder* prev{nullptr};
+    BufferHolder* next{nullptr};
+    T* buf;
+  };
+
+  void add_at_head(BufferHolder* to_add) {
+    if (!head_) {
+      head_ = to_add;
+      tail_ = to_add;
+    } else {
+      head_->prev = to_add;
+      to_add->next = head_;
+      head_ = to_add;
+    }
+  }
+
+  void remove_from_list(BufferHolder* to_remove) {
+    if (to_remove->prev && to_remove->next) { // if middle
+      to_remove->prev->next = to_remove->next;
+      to_remove->next->prev = to_remove->prev;
+    } else if (to_remove->prev && to_remove == tail_) { // if tail
+      tail_ = to_remove->prev;
+      tail_->next = nullptr;
+    } else if (to_remove == head_ && to_remove->next) { // if head
+      head_ = to_remove->next;
+      head_->prev = nullptr;
+    } else if (to_remove == head_ && to_remove == tail_) { // if only element
+      head_ = nullptr;
+      tail_ = nullptr;
+    }
+
+    delete to_remove;
+  }
+
+  std::multimap<size_t, BufferHolder*> buffer_pool_;
+  BufferHolder* head_{nullptr};
+  BufferHolder* tail_{nullptr};
+  size_t pool_size_{0};
+
+  const size_t page_size_;
+  std::function<size_t(T*)> get_size_;
+  std::function<void(T*)> free_;
+};
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp b/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2cda88a311fde2431f9fff8a61ee49a211fbdcdf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/common.cpp
@@ -0,0 +1,305 @@
+// Copyright © 2024 Apple Inc.
+#include <cassert>
+
+#include "mlx/backend/common/broadcasting.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+void AsStrided::eval(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+
+  auto& in = inputs[0];
+
+  if (!in.flags().row_contiguous) {
+    // Just ensuring that inputs[0] came from the ops which would ensure the
+    // input is row contiguous.
+    throw std::runtime_error(
+        "AsStrided must be used with row contiguous arrays only.");
+  }
+
+  // Compute the flags given the shape and strides
+  bool row_contiguous = true, col_contiguous = true;
+  size_t r = 1, c = 1;
+  for (int i = strides_.size() - 1, j = 0; i >= 0; i--, j++) {
+    row_contiguous &= (r == strides_[i]) || (shape_[i] == 1);
+    col_contiguous &= (c == strides_[j]) || (shape_[j] == 1);
+    r *= shape_[i];
+    c *= shape_[j];
+  }
+  auto flags = in.flags();
+  // TODO: Compute the contiguous flag in a better way cause now we are
+  //       unnecessarily strict.
+  flags.contiguous = row_contiguous || col_contiguous;
+  flags.row_contiguous = row_contiguous;
+  flags.col_contiguous = col_contiguous;
+
+  // There is no easy way to compute the actual data size so we use out.size().
+  // The contiguous flag will almost certainly not be set so no code should
+  // rely on data_size anyway.
+  size_t data_size = out.size();
+
+  return out.copy_shared_buffer(in, strides_, flags, data_size, offset_);
+}
+
+void Broadcast::eval(const std::vector<array>& inputs, array& out) {
+  broadcast(inputs[0], out);
+}
+
+void BroadcastAxes::eval(const std::vector<array>& inputs, array& out) {
+  broadcast(inputs[0], out);
+}
+
+void Copy::eval(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  out.copy_shared_buffer(inputs[0]);
+}
+
+void CustomTransforms::eval(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  assert(inputs.size() > outputs.size());
+  for (int i = 0, j = inputs.size() - outputs.size(); i < outputs.size();
+       i++, j++) {
+    outputs[i].copy_shared_buffer(inputs[j]);
+  }
+}
+
+void Depends::eval(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  assert(inputs.size() > outputs.size());
+  for (int i = 0; i < outputs.size(); i++) {
+    outputs[i].copy_shared_buffer(inputs[i]);
+  }
+}
+
+void ExpandDims::eval(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  auto strides = in.strides();
+  for (auto ax : axes_) {
+    strides.insert(strides.begin() + ax, 1);
+  }
+  out.copy_shared_buffer(in, strides, in.flags(), in.data_size());
+}
+
+void NumberOfElements::eval(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  double numel = 1;
+  for (auto ax : axes_) {
+    numel *= inputs[0].shape(ax);
+  }
+
+  if (inverted_) {
+    numel = 1.0 / numel;
+  }
+
+  switch (out.dtype()) {
+    case bool_:
+      *out.data<bool>() = static_cast<bool>(numel);
+      break;
+    case uint8:
+      *out.data<uint8_t>() = static_cast<uint8_t>(numel);
+      break;
+    case uint16:
+      *out.data<uint16_t>() = static_cast<uint16_t>(numel);
+      break;
+    case uint32:
+      *out.data<uint32_t>() = static_cast<uint32_t>(numel);
+      break;
+    case uint64:
+      *out.data<uint64_t>() = static_cast<uint64_t>(numel);
+      break;
+    case int8:
+      *out.data<int8_t>() = static_cast<int8_t>(numel);
+      break;
+    case int16:
+      *out.data<int16_t>() = static_cast<int16_t>(numel);
+      break;
+    case int32:
+      *out.data<int32_t>() = static_cast<int32_t>(numel);
+      break;
+    case int64:
+      *out.data<int64_t>() = static_cast<int64_t>(numel);
+      break;
+    case float16:
+      *out.data<float16_t>() = static_cast<float16_t>(numel);
+      break;
+    case float32:
+      *out.data<float>() = static_cast<float>(numel);
+      break;
+    case bfloat16:
+      *out.data<bfloat16_t>() = static_cast<bfloat16_t>(numel);
+      break;
+    case float64:
+      *out.data<double>() = static_cast<double>(numel);
+      break;
+    case complex64:
+      *out.data<complex64_t>() = static_cast<complex64_t>(numel);
+      break;
+  }
+}
+
+std::pair<bool, Strides> prepare_reshape(const array& in, const array& out) {
+  // Special case for empty arrays or row contiguous arrays
+  if (in.size() == 0 || in.flags().row_contiguous) {
+    return {false, out.strides()};
+  }
+
+  // Special case for scalars
+  if (in.ndim() == 0) {
+    return {false, Strides(out.ndim(), 0)};
+  }
+
+  // Firstly let's collapse all the contiguous dimensions of the input
+  auto [shape, strides] = collapse_contiguous_dims(in);
+
+  // If shapes fit exactly in the contiguous dims then no copy is necessary so
+  // let's check.
+  Strides out_strides;
+  bool copy_necessary = false;
+  int j = 0;
+  for (int i = 0; i < out.ndim(); i++) {
+    int N = out.shape(i);
+    if (j < shape.size() && shape[j] % N == 0) {
+      shape[j] /= N;
+      out_strides.push_back(shape[j] * strides[j]);
+      j += (shape[j] == 1);
+    } else if (N == 1) {
+      // i > 0 because otherwise j < shape.size() && shape[j] % 1 == 0
+      out_strides.push_back(out_strides.back());
+    } else {
+      copy_necessary = true;
+      break;
+    }
+  }
+
+  return {copy_necessary, out_strides};
+}
+
+void shared_buffer_reshape(
+    const array& in,
+    const Strides& out_strides,
+    array& out) {
+  auto flags = in.flags();
+  if (flags.row_contiguous) {
+    // For row contiguous reshapes:
+    // - Shallow copy the buffer
+    // - If reshaping into a vector (all singleton dimensions except one) it
+    //    becomes col contiguous again.
+    auto max_dim = std::max_element(out.shape().begin(), out.shape().end());
+    flags.col_contiguous = out.size() <= 1 || out.size() == *max_dim;
+  }
+  out.copy_shared_buffer(in, out_strides, flags, in.data_size());
+}
+
+void Split::eval(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  assert(inputs.size() == 1);
+
+  auto& in = inputs[0];
+
+  auto compute_new_flags = [](const auto& shape,
+                              const auto& strides,
+                              size_t in_data_size,
+                              auto flags) {
+    size_t data_size = 1;
+    size_t f_stride = 1;
+    size_t b_stride = 1;
+    flags.row_contiguous = true;
+    flags.col_contiguous = true;
+    for (int i = 0, ri = shape.size() - 1; ri >= 0; i++, ri--) {
+      flags.col_contiguous &= strides[i] == f_stride || shape[i] == 1;
+      flags.row_contiguous &= strides[ri] == b_stride || shape[ri] == 1;
+      f_stride *= shape[i];
+      b_stride *= shape[ri];
+      if (strides[i] > 0) {
+        data_size *= shape[i];
+      }
+    }
+
+    if (data_size == 1) {
+      // Broadcasted scalar array is contiguous.
+      flags.contiguous = true;
+    } else if (data_size == in_data_size) {
+      // Means we sliced a broadcasted dimension so leave the "no holes" flag
+      // alone.
+    } else {
+      // We sliced something. So either we are row or col contiguous or we
+      // punched a hole.
+      flags.contiguous &= flags.row_contiguous || flags.col_contiguous;
+    }
+
+    return std::pair<decltype(flags), size_t>{flags, data_size};
+  };
+
+  std::vector<int> indices(1, 0);
+  indices.insert(indices.end(), indices_.begin(), indices_.end());
+  for (int i = 0; i < indices.size(); i++) {
+    size_t offset = indices[i] * in.strides()[axis_];
+    auto [new_flags, data_size] = compute_new_flags(
+        outputs[i].shape(), in.strides(), in.data_size(), in.flags());
+    outputs[i].copy_shared_buffer(
+        in, in.strides(), new_flags, data_size, offset);
+  }
+}
+
+void Squeeze::eval(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  Strides strides;
+  for (int i = 0, j = 0; i < in.ndim(); ++i) {
+    if (j < axes_.size() && i == axes_[j]) {
+      j++;
+    } else {
+      strides.push_back(in.strides(i));
+    }
+  }
+  out.copy_shared_buffer(in, strides, in.flags(), in.data_size());
+}
+
+void StopGradient::eval(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  out.copy_shared_buffer(inputs[0]);
+}
+
+void Transpose::eval(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  Strides out_strides(out.ndim());
+  auto& in = inputs[0];
+  for (int ax = 0; ax < axes_.size(); ++ax) {
+    out_strides[ax] = in.strides()[axes_[ax]];
+  }
+
+  // Conditions for {row/col}_contiguous
+  // - array must be contiguous (no gaps)
+  // - underlying buffer size should have the same size as the array
+  // - cumulative product of shapes is equal to the strides (we can ignore axes
+  //   with size == 1)
+  //   - in the forward direction (column contiguous)
+  //   - in the reverse direction (row contiguous)
+  // - vectors are both row and col contiguous (hence if both row/col are
+  //   true, they stay true)
+  auto flags = in.flags();
+  if (flags.contiguous && in.data_size() == in.size()) {
+    int64_t f_stride = 1;
+    int64_t b_stride = 1;
+    flags.col_contiguous = true;
+    flags.row_contiguous = true;
+    for (int i = 0, ri = out.ndim() - 1; i < out.ndim(); ++i, --ri) {
+      flags.col_contiguous &= (out_strides[i] == f_stride || out.shape(i) == 1);
+      f_stride *= out.shape(i);
+      flags.row_contiguous &=
+          (out_strides[ri] == b_stride || out.shape(ri) == 1);
+      b_stride *= out.shape(ri);
+    }
+  }
+  out.copy_shared_buffer(in, out_strides, flags, in.data_size());
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp b/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..44e2a432bb0ec573f3eb386bb1b96c140a593087
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/compiled.cpp
@@ -0,0 +1,241 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/backend/common/compiled.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+void print_constant(std::ostream& os, const array& x) {
+  switch (x.dtype()) {
+    case float32:
+      return print_float_constant<float>(os, x);
+    case float16:
+      return print_float_constant<float16_t>(os, x);
+    case bfloat16:
+      return print_float_constant<bfloat16_t>(os, x);
+    case float64:
+      return print_float_constant<double>(os, x);
+    case complex64:
+      return print_complex_constant<complex64_t>(os, x);
+    case int8:
+      os << static_cast<int32_t>(x.item<int8_t>());
+      return;
+    case int16:
+      return print_int_constant<int16_t>(os, x);
+    case int32:
+      return print_int_constant<int32_t>(os, x);
+    case int64:
+      return print_int_constant<int64_t>(os, x);
+    case uint8:
+      os << static_cast<uint32_t>(x.item<uint8_t>());
+      return;
+    case uint16:
+      return print_int_constant<uint16_t>(os, x);
+    case uint32:
+      return print_int_constant<uint32_t>(os, x);
+    case uint64:
+      return print_int_constant<uint64_t>(os, x);
+    case bool_:
+      os << std::boolalpha << x.item<bool>();
+      return;
+    default:
+      throw std::runtime_error("Unsupported constant type");
+  }
+}
+
+std::string get_type_string(Dtype d) {
+  switch (d) {
+    case float32:
+      return "float";
+    case float16:
+      return "float16_t";
+    case bfloat16:
+      return "bfloat16_t";
+    case float64:
+      return "double";
+    case complex64:
+      return "complex64_t";
+    case bool_:
+      return "bool";
+    case int8:
+      return "int8_t";
+    case int16:
+      return "int16_t";
+    case int32:
+      return "int32_t";
+    case int64:
+      return "int64_t";
+    case uint8:
+      return "uint8_t";
+    case uint16:
+      return "uint16_t";
+    case uint32:
+      return "uint32_t";
+    case uint64:
+      return "uint64_t";
+    default: {
+      std::ostringstream msg;
+      msg << "Unsupported compilation type " << d;
+      throw std::runtime_error(msg.str());
+    }
+  }
+}
+
+bool compiled_check_contiguity(
+    const std::vector<array>& inputs,
+    const Shape& shape) {
+  bool contiguous = true;
+  bool all_contig = true;
+  bool all_row_contig = true;
+  bool all_col_contig = true;
+  int non_scalar_inputs = 0;
+  for (const auto& x : inputs) {
+    if (is_scalar(x)) {
+      continue;
+    }
+    non_scalar_inputs++;
+    bool shape_eq = x.shape() == shape;
+    all_contig &= (x.flags().contiguous && shape_eq);
+    all_row_contig &= (x.flags().row_contiguous && shape_eq);
+    all_col_contig &= (x.flags().col_contiguous && shape_eq);
+  }
+  if (non_scalar_inputs > 1 && !all_row_contig && !all_col_contig) {
+    contiguous = false;
+  } else if (non_scalar_inputs == 1 && !all_contig) {
+    contiguous = false;
+  } else if (non_scalar_inputs == 0 && !shape.empty()) {
+    contiguous = false;
+  }
+  return contiguous;
+}
+
+void compiled_allocate_outputs(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs,
+    const std::function<bool(size_t)>& is_constant,
+    bool contiguous) {
+  if (contiguous) {
+    int o = 0;
+    Strides strides;
+    size_t data_size;
+    array::Flags flags;
+    for (int i = 0; i < inputs.size() && o < outputs.size(); ++i) {
+      auto& in = inputs[i];
+      // Conditions for donation
+      // - Correct size
+      // - Not a scalar
+      // - Donatable
+      // - Not a constant
+      if (in.itemsize() == outputs[o].itemsize() && !is_scalar(in) &&
+          in.is_donatable() && is_constant(i)) {
+        outputs[o++].copy_shared_buffer(in);
+      }
+      // Get representative input flags to properly set non-donated outputs
+      if (strides.empty() && in.size() == outputs[0].size()) {
+        strides = in.strides();
+        flags = in.flags();
+        data_size = in.data_size();
+      }
+    }
+    for (; o < outputs.size(); ++o) {
+      outputs[o].set_data(
+          allocator::malloc(data_size * outputs[o].itemsize()),
+          data_size,
+          strides,
+          flags);
+    }
+  } else {
+    int o = 0;
+    for (int i = 0; i < inputs.size() && o < outputs.size(); ++i) {
+      auto& in = inputs[i];
+      // Conditions for donation
+      // - Row contiguous
+      // - Donatable
+      // - Correct size
+      // - Not a constant
+      if (in.flags().row_contiguous && in.size() == outputs[o].size() &&
+          in.itemsize() == outputs[o].itemsize() && in.is_donatable() &&
+          is_constant(i)) {
+        outputs[o].copy_shared_buffer(
+            in, outputs[o].strides(), in.flags(), in.data_size());
+        o++;
+      }
+    }
+    for (; o < outputs.size(); ++o) {
+      outputs[o].set_data(allocator::malloc(outputs[o].nbytes()));
+    }
+  }
+}
+
+std::tuple<bool, Shape, std::vector<Strides>> compiled_collapse_contiguous_dims(
+    const std::vector<array>& inputs,
+    const array& out,
+    const std::function<bool(size_t)>& is_constant) {
+  const Shape& shape = out.shape();
+  bool contiguous = compiled_check_contiguity(inputs, shape);
+  if (contiguous) {
+    return {true, shape, {}};
+  }
+
+  std::vector<Strides> strides_vec{out.strides()};
+  for (size_t i = 0; i < inputs.size(); ++i) {
+    // Skip constants.
+    if (is_constant(i)) {
+      continue;
+    }
+
+    // Skip scalar inputs.
+    const auto& x = inputs[i];
+    if (is_scalar(x)) {
+      continue;
+    }
+
+    // Broadcast the inputs to the output shape.
+    Strides xstrides;
+    size_t j = 0;
+    for (; j < shape.size() - x.ndim(); ++j) {
+      if (shape[j] == 1) {
+        xstrides.push_back(out.strides()[j]);
+      } else {
+        xstrides.push_back(0);
+      }
+    }
+    for (size_t i = 0; i < x.ndim(); ++i, ++j) {
+      if (x.shape(i) == 1) {
+        if (shape[j] == 1) {
+          xstrides.push_back(out.strides()[j]);
+        } else {
+          xstrides.push_back(0);
+        }
+      } else {
+        xstrides.push_back(x.strides()[i]);
+      }
+    }
+    strides_vec.push_back(std::move(xstrides));
+  }
+
+  auto tup = collapse_contiguous_dims(shape, strides_vec, INT32_MAX);
+  return {false, std::move(std::get<0>(tup)), std::move(std::get<1>(tup))};
+}
+
+bool compiled_use_large_index(
+    const std::vector<array>& inputs,
+    const std::vector<array>& outputs,
+    bool contiguous) {
+  if (contiguous) {
+    size_t max_size = 0;
+    for (const auto& in : inputs) {
+      max_size = std::max(max_size, in.data_size());
+    }
+    return max_size > UINT32_MAX;
+  } else {
+    size_t max_size = 0;
+    for (const auto& o : outputs) {
+      max_size = std::max(max_size, o.size());
+    }
+    return max_size > UINT32_MAX;
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/compiled.h b/ml-stable-diffusion/mlx/mlx/backend/common/compiled.h
new file mode 100644
index 0000000000000000000000000000000000000000..e92a6d0adcbac1fb67b22689fa379d77a7ac9cb2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/compiled.h
@@ -0,0 +1,75 @@
+// Copyright © 2023-2024 Apple Inc.
+#pragma once
+
+#include <functional>
+#include <iomanip>
+
+#include "mlx/array.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+inline bool is_static_cast(const Primitive& p) {
+  return (typeid(p) == typeid(Broadcast) || typeid(p) == typeid(AsType));
+}
+
+std::string get_type_string(Dtype d);
+
+template <typename T>
+void print_float_constant(std::ostream& os, const array& x) {
+  auto old_precision = os.precision();
+  if constexpr (std::is_same_v<T, double>) {
+    os << std::setprecision(std::numeric_limits<double>::digits10 + 1);
+  } else {
+    os << std::setprecision(std::numeric_limits<float>::digits10 + 1);
+  }
+  os << x.item<T>() << std::setprecision(old_precision);
+}
+
+template <typename T>
+void print_int_constant(std::ostream& os, const array& x) {
+  os << x.item<T>();
+}
+
+template <typename T>
+void print_complex_constant(std::ostream& os, const array& x) {
+  auto old_precision = os.precision();
+  T constant = x.item<T>();
+
+  os << get_type_string(x.dtype()) << "("
+     << std::setprecision(std::numeric_limits<float>::digits10 + 1)
+     << constant.real() << ", " << constant.imag() << ")"
+     << std::setprecision(old_precision);
+}
+
+void print_constant(std::ostream& os, const array& x);
+
+inline bool is_scalar(const array& x) {
+  return x.ndim() == 0;
+}
+
+// Check if we can use a contiguous operation given inputs and the output shape
+bool compiled_check_contiguity(
+    const std::vector<array>& inputs,
+    const Shape& shape);
+
+// Allocate space for the outputs possibly with input donation
+void compiled_allocate_outputs(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs,
+    const std::function<bool(size_t)>& is_constant,
+    bool contiguous);
+
+// Collapse contiguous dims ignoring scalars and constants.
+std::tuple<bool, Shape, std::vector<Strides>> compiled_collapse_contiguous_dims(
+    const std::vector<array>& inputs,
+    const array& out,
+    const std::function<bool(size_t)>& is_constant);
+
+// Return whether the kernel should use large index.
+bool compiled_use_large_index(
+    const std::vector<array>& inputs,
+    const std::vector<array>& outputs,
+    bool contiguous);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/copy.h b/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..c23d2e79aa89a01382bafa5c418825860dea10dc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/copy.h
@@ -0,0 +1,46 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/common/utils.h"
+
+namespace mlx::core {
+
+enum class CopyType {
+  // Copy a raw scalar input into the full contiguous output
+  Scalar,
+
+  // Copy the raw input buffer contiguously into a raw output buffer of the same
+  // size
+  Vector,
+
+  // Copy the full virtual input to the full contiguous output
+  General,
+
+  // Copy the full virtual input to the full virtual output. We assume the
+  // input and output have the same shape.
+  GeneralGeneral
+};
+
+inline bool set_copy_output_data(const array& in, array& out, CopyType ctype) {
+  if (ctype == CopyType::Vector) {
+    // If the input is donateable, we are doing a vector copy and the types
+    // have the same size, then the input buffer can hold the output.
+    if (is_donatable(in, out)) {
+      out.copy_shared_buffer(in);
+      return true;
+    } else {
+      out.set_data(
+          allocator::malloc(in.data_size() * out.itemsize()),
+          in.data_size(),
+          in.strides(),
+          in.flags());
+      return false;
+    }
+  } else {
+    out.set_data(allocator::malloc(out.nbytes()));
+    return false;
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/hadamard.h b/ml-stable-diffusion/mlx/mlx/backend/common/hadamard.h
new file mode 100644
index 0000000000000000000000000000000000000000..ba5c4e41e62ce90aa6ee9572c72098ecf228e106
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/hadamard.h
@@ -0,0 +1,109 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include <map>
+
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+// From http://neilsloane.com/hadamard/
+constexpr std::string_view h12 = R"(
++-++++++++++
+--+-+-+-+-+-
++++-++----++
++---+--+-++-
++++++-++----
++-+---+--+-+
+++--+++-++--
++--++---+--+
+++----+++-++
++--+-++---+-
+++++----+++-
++-+--+-++---
+)";
+
+constexpr std::string_view h20 = R"(
++----+----++--++-++-
+-+----+---+++---+-++
+--+----+---+++-+-+-+
+---+----+---+++++-+-
+----+----++--++-++-+
+-+++++-----+--+++--+
++-+++-+---+-+--+++--
+++-++--+---+-+--+++-
++++-+---+---+-+--+++
+++++-----++--+-+--++
+--++-+-++-+-----++++
+---++-+-++-+---+-+++
++---++-+-+--+--++-++
+++---++-+----+-+++-+
+-++---++-+----+++++-
+-+--+--++-+----+----
++-+-----++-+----+---
+-+-+-+---+--+----+--
+--+-+++------+----+-
++--+--++------+----+
+)";
+
+constexpr std::string_view h28 = R"(
++------++----++-+--+-+--++--
+-+-----+++-----+-+--+-+--++-
+--+-----+++---+-+-+----+--++
+---+-----+++---+-+-+-+--+--+
+----+-----+++---+-+-+++--+--
+-----+-----++++--+-+--++--+-
+------++----++-+--+-+--++--+
+--++++-+-------++--+++-+--+-
+---++++-+-----+-++--+-+-+--+
++---+++--+----++-++--+-+-+--
+++---++---+----++-++--+-+-+-
++++---+----+----++-++--+-+-+
+++++--------+-+--++-++--+-+-
+-++++--------+++--++--+--+-+
+-+-++-++--++--+--------++++-
++-+-++--+--++--+--------++++
+-+-+-++--+--++--+----+---+++
++-+-+-++--+--+---+---++---++
+++-+-+-++--+------+--+++---+
+-++-+-+-++--+------+-++++---
++-++-+---++--+------+-++++--
+-++--++-+-++-+++----++------
++-++--++-+-++-+++-----+-----
+++-++---+-+-++-+++-----+----
+-++-++-+-+-+-+--+++-----+---
+--++-++++-+-+----+++-----+--
++--++-+-++-+-+----+++-----+-
+++--++-+-++-+-+----++------+
+)";
+
+inline const std::map<int, std::string_view> hadamard_matrices() {
+  return {{12, h12}, {20, h20}, {28, h28}};
+}
+
+inline std::pair<int, int> decompose_hadamard(int n) {
+  // n = m*2^k
+  int m = 1;
+  if (!is_power_of_2(n)) {
+    auto h_matrices = hadamard_matrices();
+    for (auto [factor, _] : h_matrices) {
+      if (n % factor == 0) {
+        m = factor;
+        n /= factor;
+        break;
+      }
+    }
+    if (m == 1) {
+      throw std::invalid_argument(
+          "[hadamard] Only supports n = m*2^k where m in (1, 12, 20, 28).");
+    }
+  }
+  if (n > (1 << 26)) {
+    throw std::invalid_argument(
+        "[hadamard] Only supports n = m*2^k where k <= 26");
+  }
+  return {n, m};
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp b/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ce41963de75f9f8b4bd61713d76516a102aaa585
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/load.cpp
@@ -0,0 +1,57 @@
+// Copyright © 2023 Apple Inc.
+
+#include <algorithm>
+#include <utility>
+
+#include "mlx/primitives.h"
+#include "mlx/scheduler.h"
+
+namespace {
+
+template <const uint8_t scalar_size>
+void swap_endianness(uint8_t* data_bytes, size_t N) {
+  struct Elem {
+    uint8_t bytes[scalar_size];
+  };
+
+  Elem* data = reinterpret_cast<Elem*>(data_bytes);
+
+  for (size_t i = 0; i < N; i++) {
+    for (size_t j = 0; j < (scalar_size / 2); j++) {
+      std::swap(data[i].bytes[j], data[i].bytes[scalar_size - j - 1]);
+    }
+  }
+}
+
+} // namespace
+
+namespace mlx::core {
+
+void Load::eval_cpu(const std::vector<array>& inputs, array& out) {
+  out.set_data(allocator::malloc(out.nbytes()));
+  auto read_task = [out_ptr = out.data<char>(),
+                    size = out.size(),
+                    itemsize = out.itemsize(),
+                    offset = offset_,
+                    reader = reader_,
+                    swap_endianness_ = swap_endianness_]() mutable {
+    reader->read(out_ptr, size * itemsize, offset);
+    if (swap_endianness_) {
+      switch (itemsize) {
+        case 2:
+          swap_endianness<2>(reinterpret_cast<uint8_t*>(out_ptr), size);
+          break;
+        case 4:
+          swap_endianness<4>(reinterpret_cast<uint8_t*>(out_ptr), size);
+          break;
+        case 8:
+          swap_endianness<8>(reinterpret_cast<uint8_t*>(out_ptr), size);
+          break;
+      }
+    }
+  };
+  auto fut = io::thread_pool().enqueue(std::move(read_task)).share();
+  scheduler::enqueue(stream(), [fut = std::move(fut)]() { fut.wait(); });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/matmul.h b/ml-stable-diffusion/mlx/mlx/backend/common/matmul.h
new file mode 100644
index 0000000000000000000000000000000000000000..2faf256d1dd47254d49eb897e279de90c7a31c2b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/matmul.h
@@ -0,0 +1,67 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/utils.h"
+
+#include <sstream>
+
+namespace mlx::core {
+
+inline std::tuple<Shape, Strides, Strides> collapse_batches(
+    const array& a,
+    const array& b) {
+  if (a.ndim() == 2) {
+    return {{1}, {0}, {0}};
+  }
+
+  Shape A_bshape{a.shape().begin(), a.shape().end() - 2};
+  Strides A_bstride{a.strides().begin(), a.strides().end() - 2};
+  Strides B_bstride{b.strides().begin(), b.strides().end() - 2};
+
+  auto [batch_shape, batch_strides] =
+      collapse_contiguous_dims(A_bshape, std::vector{A_bstride, B_bstride});
+
+  auto a_batch_strides = batch_strides[0];
+  auto b_batch_strides = batch_strides[1];
+
+  if (batch_shape.empty()) {
+    batch_shape.push_back(1);
+    a_batch_strides.push_back(0);
+    b_batch_strides.push_back(0);
+  }
+
+  return std::make_tuple(batch_shape, a_batch_strides, b_batch_strides);
+}
+
+inline std::tuple<Shape, Strides, Strides, Strides>
+collapse_batches(const array& a, const array& b, const array& c) {
+  if (a.ndim() == 2) {
+    return {{1}, {0}, {0}, {0}};
+  }
+
+  Shape A_bshape{a.shape().begin(), a.shape().end() - 2};
+  Strides A_bstride{a.strides().begin(), a.strides().end() - 2};
+  Strides B_bstride{b.strides().begin(), b.strides().end() - 2};
+  Strides C_bstride{c.strides().begin(), c.strides().end() - 2};
+
+  auto [batch_shape, batch_strides] = collapse_contiguous_dims(
+      A_bshape, std::vector{A_bstride, B_bstride, C_bstride});
+
+  auto A_batch_stride = batch_strides[0];
+  auto B_batch_stride = batch_strides[1];
+  auto C_batch_stride = batch_strides[2];
+
+  if (batch_shape.empty()) {
+    batch_shape.push_back(1);
+    A_batch_stride.push_back(0);
+    B_batch_stride.push_back(0);
+    C_batch_stride.push_back(0);
+  }
+
+  return std::make_tuple(
+      batch_shape, A_batch_stride, B_batch_stride, C_batch_stride);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp b/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ceef464007c8f997c2847ee081c2dccb2dc39755
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/reduce.cpp
@@ -0,0 +1,154 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/backend/common/reduce.h"
+
+namespace mlx::core {
+
+std::pair<Shape, Strides> shapes_without_reduction_axes(
+    Shape shape,
+    Strides strides,
+    const std::vector<int>& axes) {
+  for (int i = axes.size() - 1; i >= 0; i--) {
+    int a = axes[i];
+    shape.erase(shape.begin() + a);
+    strides.erase(strides.begin() + a);
+  }
+
+  return std::make_pair(shape, strides);
+}
+
+std::pair<Shape, Strides> shapes_without_reduction_axes(
+    const array& x,
+    const std::vector<int>& axes) {
+  auto shape = x.shape();
+  auto strides = x.strides();
+  return shapes_without_reduction_axes(
+      std::move(shape), std::move(strides), axes);
+}
+
+ReductionPlan get_reduction_plan(const array& x, const std::vector<int>& axes) {
+  // The data is all there and we are reducing over everything
+  if (x.size() == x.data_size() && axes.size() == x.ndim() &&
+      x.flags().contiguous) {
+    return ContiguousAllReduce;
+  }
+
+  // Row contiguous input so the output is row contiguous
+  if (x.flags().row_contiguous) {
+    // Merge consecutive axes
+    Shape shape = {x.shape(axes[0])};
+    Strides strides = {x.strides()[axes[0]]};
+    for (int i = 1; i < axes.size(); i++) {
+      if (axes[i] - 1 == axes[i - 1] && x.shape(axes[i]) > 1) {
+        shape.back() *= x.shape(axes[i]);
+        strides.back() = x.strides()[axes[i]];
+      } else {
+        shape.push_back(x.shape(axes[i]));
+        strides.push_back(x.strides()[axes[i]]);
+      }
+    }
+
+    // Remove singleton axes from the plan
+    for (int i = shape.size() - 1; i >= 0; i--) {
+      if (shape[i] == 1) {
+        shape.erase(shape.begin() + i);
+        strides.erase(strides.begin() + i);
+      }
+    }
+
+    if (strides.back() == 1) {
+      return ReductionPlan(ContiguousReduce, shape, strides);
+    } else if (strides.back() > 1) {
+      return ReductionPlan(ContiguousStridedReduce, shape, strides);
+    }
+  }
+
+  // Let's check if we can optimize our access patterns
+  //
+  // 1. We have a reduction axis with stride 1. Simply call
+  //    GeneralContiguousReduce and be done with it.
+  // 2. We have transpositions and we are not reducing over the axis with
+  //    stride 1. However, we are reducing over an axis where everything is
+  //    contiguous in memory to the right of that axis. We can call strided
+  //    reduce and be done with it.
+  // 2. We have weird transpositions and expands. Copy the strides to the
+  //    output, then call strided reduce.
+
+  // Sort reduction axes by stride in order to merge them and figure out if we
+  // have a contiguous reduction.
+  std::vector<std::pair<int, int64_t>> reductions;
+  for (auto a : axes) {
+    if (x.shape(a) > 1) {
+      reductions.push_back(std::make_pair(x.shape(a), x.strides()[a]));
+    }
+  }
+  std::sort(reductions.begin(), reductions.end(), [](auto a, auto b) {
+    bool a_is_zero = a.second == 0;
+    bool b_is_zero = b.second == 0;
+    return (a_is_zero != b_is_zero) ? a.second < b.second : a.second > b.second;
+  });
+  // Extract the two smallest and try to merge them in case the contiguous
+  // reduction can be bigger than just the last axis.
+  for (int i = reductions.size() - 1; i >= 1; i--) {
+    auto a = reductions[i];
+    auto b = reductions[i - 1];
+
+    // b.stride = a.shape * a.stride then a and b are contiguous
+    if (b.second == a.first * a.second) {
+      reductions.erase(reductions.begin() + i);
+      reductions[i - 1] = std::make_pair(a.first * b.first, a.second);
+    }
+  }
+
+  Shape shape;
+  Strides strides;
+  for (auto r : reductions) {
+    shape.push_back(r.first);
+    strides.push_back(r.second);
+  }
+
+  // We can call the contiguous reduction op for every weird way the input is
+  // structured in the rest of the axes.
+  if (strides.back() == 1) {
+    return ReductionPlan(GeneralContiguousReduce, shape, strides);
+  }
+
+  // Delegate to the general strided reduction op if the axes after
+  // strides.back() are contiguous.
+  if (strides.back() > 1) {
+    int64_t size = 1;
+    bool have_expand = false;
+    for (int i = x.ndim() - 1; i >= 0; i--) {
+      if (axes.back() == i) {
+        continue;
+      }
+
+      auto stride_i = x.strides()[i];
+      auto shape_i = x.shape(i);
+      if (stride_i == 0) {
+        if (shape_i == 1) {
+          continue;
+        }
+
+        have_expand = true;
+        break;
+      }
+
+      if (stride_i != size && shape_i != 1) {
+        break;
+      }
+      size *= shape_i;
+    }
+    // In the case of an expanded dimension we are being conservative and
+    // require the smallest reduction stride to be smaller than the maximum row
+    // contiguous size. The reason is that we can't easily know if the reduced
+    // axis is before or after an expanded dimension.
+    if (size > strides.back() || (size == strides.back() && !have_expand)) {
+      return ReductionPlan(GeneralStridedReduce, shape, strides);
+    }
+  }
+
+  return ReductionPlan(GeneralReduce, shape, strides);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/reduce.h b/ml-stable-diffusion/mlx/mlx/backend/common/reduce.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b24f4f530dc9dc14ab641e05526b3059a933077
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/reduce.h
@@ -0,0 +1,59 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/common/utils.h"
+
+namespace mlx::core {
+
+enum ReductionOpType {
+  // Self-explanatory. Read everything and produce 1 output.
+  ContiguousAllReduce,
+
+  // The input is contiguous and the last axis is reduced
+  // N1xR1xN2xR2x...xNnxRn
+  ContiguousReduce,
+
+  // The input is contiguous and the last axis is not reduced
+  // R1xN1xR2xN2x...xRnxNn
+  ContiguousStridedReduce,
+
+  // The input is not contiguous but the last axis is and it is reduced so we
+  // need to figure out the offsets but we can call the contiguous reduce after
+  // that.
+  // N3xR1xN1xR4x...xRn
+  GeneralContiguousReduce,
+
+  // The input is not contiguous but the last reduction axis and the last axis
+  // are so we need to figure out the offset but we can call the strided reduce
+  // after that.
+  GeneralStridedReduce,
+
+  // The input is not contiguous after the reduction axis and it may contain
+  // 0-stride axes or transpositions. We could copy the strides and produce a
+  // transposed outcome or we can read the input out of order and write the
+  // output in order.
+  GeneralReduce
+};
+
+struct ReductionPlan {
+  ReductionOpType type;
+  Shape shape;
+  Strides strides;
+
+  ReductionPlan(ReductionOpType type_, Shape shape_, Strides strides_)
+      : type(type_), shape(std::move(shape_)), strides(std::move(strides_)) {}
+  ReductionPlan(ReductionOpType type_) : type(type_) {}
+};
+
+ReductionPlan get_reduction_plan(const array& x, const std::vector<int>& axes);
+
+std::pair<Shape, Strides> shapes_without_reduction_axes(
+    const array& x,
+    const std::vector<int>& axes);
+std::pair<Shape, Strides> shapes_without_reduction_axes(
+    Shape shape,
+    Strides strides,
+    const std::vector<int>& axes);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp b/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6f5736d637ea628dd71939dbd3cd0fa1d91d664f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/slicing.cpp
@@ -0,0 +1,68 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/backend/common/utils.h"
+
+namespace mlx::core {
+
+std::tuple<int64_t, Strides> prepare_slice(
+    const array& in,
+    const Shape& start_indices,
+    const Shape& strides) {
+  int64_t data_offset = 0;
+  Strides inp_strides(in.ndim(), 0);
+  for (int i = 0; i < in.ndim(); ++i) {
+    data_offset += start_indices[i] * in.strides()[i];
+    inp_strides[i] = in.strides()[i] * strides[i];
+  }
+  // Normalize the offset
+  if (data_offset < 0) {
+    data_offset += in.data_size();
+  }
+  return std::make_tuple(data_offset, inp_strides);
+}
+
+void shared_buffer_slice(
+    const array& in,
+    const Strides& out_strides,
+    size_t data_offset,
+    size_t data_size,
+    array& out) {
+  // Compute row/col contiguity
+  auto [no_bsx_size, is_row_contiguous, is_col_contiguous] =
+      check_contiguity(out.shape(), out_strides);
+
+  auto flags = in.flags();
+  flags.row_contiguous = is_row_contiguous;
+  flags.col_contiguous = is_col_contiguous;
+  flags.contiguous = (no_bsx_size == data_size);
+
+  out.copy_shared_buffer(in, out_strides, flags, data_size, data_offset);
+}
+
+void slice(
+    const array& in,
+    array& out,
+    const Shape& start_indices,
+    const Shape& strides) {
+  if (out.size() == 0) {
+    out.set_data(nullptr);
+    return;
+  }
+
+  // Calculate out strides, initial offset
+  auto [data_offset, inp_strides] = prepare_slice(in, start_indices, strides);
+  int64_t data_end = 1;
+  for (int i = 0; i < start_indices.size(); ++i) {
+    if (in.shape()[i] > 1) {
+      auto end_idx = start_indices[i] + out.shape()[i] * strides[i] - 1;
+      data_end += end_idx * in.strides()[i];
+    }
+  }
+  if (data_end < 0) {
+    data_end += in.data_size();
+  }
+  size_t data_size = (data_end - data_offset);
+  shared_buffer_slice(in, inp_strides, data_offset, data_size, out);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/slicing.h b/ml-stable-diffusion/mlx/mlx/backend/common/slicing.h
new file mode 100644
index 0000000000000000000000000000000000000000..b667d2619d3093cc234835cbe4ab2875c8a1ba12
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/slicing.h
@@ -0,0 +1,20 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+std::tuple<int64_t, Strides> prepare_slice(
+    const array& in,
+    const Shape& start_indices,
+    const Shape& strides);
+
+void slice(
+    const array& in,
+    array& out,
+    const Shape& start_indices,
+    const Shape& strides);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/ternary.h b/ml-stable-diffusion/mlx/mlx/backend/common/ternary.h
new file mode 100644
index 0000000000000000000000000000000000000000..233708ec3387fe65746b48ec78ff5257fa20c81c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/ternary.h
@@ -0,0 +1,85 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+#include "mlx/allocator.h"
+#include "mlx/array.h"
+#include "mlx/backend/common/utils.h"
+
+namespace mlx::core {
+
+// TODO: Add support for more combinations of input types.
+enum class TernaryOpType {
+  ScalarScalarScalar,
+  VectorVectorVector,
+  VectorVectorScalar,
+  VectorScalarVector,
+  General,
+};
+
+inline TernaryOpType
+get_ternary_op_type(const array& a, const array& b, const array& c) {
+  TernaryOpType topt;
+  if (a.data_size() == 1 && b.data_size() == 1 && c.data_size() == 1) {
+    topt = TernaryOpType::ScalarScalarScalar;
+  } else if (
+      (a.flags().row_contiguous && b.flags().row_contiguous &&
+       c.flags().row_contiguous) ||
+      (a.flags().col_contiguous && b.flags().col_contiguous &&
+       c.flags().col_contiguous)) {
+    topt = TernaryOpType::VectorVectorVector;
+  } else if (
+      b.data_size() == 1 && a.flags().row_contiguous &&
+      c.flags().row_contiguous) {
+    topt = TernaryOpType::VectorScalarVector;
+  } else if (
+      c.data_size() == 1 && a.flags().row_contiguous &&
+      b.flags().row_contiguous) {
+    topt = TernaryOpType::VectorVectorScalar;
+  } else {
+    topt = TernaryOpType::General;
+  }
+  return topt;
+}
+
+inline void set_ternary_op_output_data(
+    const array& a,
+    const array& b,
+    const array& c,
+    array& out,
+    TernaryOpType topt) {
+  auto maybe_donate = [&out](const array& x) {
+    if (is_donatable(x, out)) {
+      out.copy_shared_buffer(x);
+      return true;
+    }
+    return false;
+  };
+
+  switch (topt) {
+    case TernaryOpType::ScalarScalarScalar:
+      out.set_data(
+          allocator::malloc(out.itemsize()), 1, b.strides(), b.flags());
+      break;
+    case TernaryOpType::VectorVectorVector:
+      if (!(maybe_donate(a) || maybe_donate(b) || maybe_donate(c))) {
+        out.set_data(
+            allocator::malloc(out.itemsize() * b.data_size()),
+            b.data_size(),
+            b.strides(),
+            b.flags());
+      }
+      break;
+    case TernaryOpType::VectorVectorScalar:
+    case TernaryOpType::VectorScalarVector:
+    case TernaryOpType::General:
+      // Try to donate an input which is row_contiguous
+      if (!((a.flags().row_contiguous && maybe_donate(a)) ||
+            (b.flags().row_contiguous && maybe_donate(b)) ||
+            (c.flags().row_contiguous && maybe_donate(c)))) {
+        out.set_data(allocator::malloc(out.nbytes()));
+      }
+      break;
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/unary.h b/ml-stable-diffusion/mlx/mlx/backend/common/unary.h
new file mode 100644
index 0000000000000000000000000000000000000000..a27a1f45c37b8cffd08803544028c0c8442a884b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/unary.h
@@ -0,0 +1,26 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/allocator.h"
+#include "mlx/backend/common/utils.h"
+
+namespace mlx::core {
+
+inline void set_unary_output_data(const array& in, array& out) {
+  if (in.flags().contiguous) {
+    if (is_donatable(in, out)) {
+      out.copy_shared_buffer(in);
+    } else {
+      out.set_data(
+          allocator::malloc(in.data_size() * out.itemsize()),
+          in.data_size(),
+          in.strides(),
+          in.flags());
+    }
+  } else {
+    out.set_data(allocator::malloc(out.nbytes()));
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp b/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ae169e35e2c88555d2d1e101697654e47e3fcf3e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/utils.cpp
@@ -0,0 +1,231 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <dlfcn.h>
+
+#include "mlx/backend/common/utils.h"
+
+namespace mlx::core {
+
+std::filesystem::path current_binary_dir() {
+  static std::filesystem::path binary_dir = []() {
+    Dl_info info;
+    if (!dladdr(reinterpret_cast<void*>(&current_binary_dir), &info)) {
+      throw std::runtime_error("Unable to get current binary dir.");
+    }
+    return std::filesystem::path(info.dli_fname).parent_path();
+  }();
+  return binary_dir;
+}
+
+std::tuple<Shape, std::vector<Strides>> collapse_contiguous_dims(
+    const Shape& shape,
+    const std::vector<Strides>& strides,
+    int64_t size_cap) {
+  // Make a vector that has axes separated with -1. Collapse all axes between
+  // -1.
+  Shape to_collapse;
+  if (shape.size() > 0) {
+    if (shape[0] != 1) {
+      to_collapse.push_back(0);
+    }
+    size_t size = shape[0];
+    for (int i = 1; i < shape.size(); i++) {
+      bool contiguous = true;
+      size *= shape[i];
+      for (const auto& st : strides) {
+        if (st[i] * shape[i] != st[i - 1] || size > size_cap) {
+          contiguous = false;
+          size = shape[i];
+          break;
+        }
+      }
+      if (!contiguous) {
+        to_collapse.push_back(-1);
+      }
+      if (shape[i] != 1) {
+        to_collapse.push_back(i);
+      }
+    }
+    to_collapse.push_back(-1);
+  }
+
+  Shape out_shape;
+  std::vector<Strides> out_strides(strides.size());
+  for (int i = 0;;) {
+    while (i < to_collapse.size() && to_collapse[i] == -1) {
+      ++i;
+    };
+    if (i == to_collapse.size()) {
+      break;
+    }
+    int current_shape = shape[to_collapse[i]];
+    int k = i;
+    while (to_collapse[++k] != -1) {
+      current_shape *= shape[to_collapse[k]];
+    }
+    out_shape.push_back(current_shape);
+    for (int j = 0; j < strides.size(); j++) {
+      const auto& st = strides[j];
+      out_strides[j].push_back(st[to_collapse[k - 1]]);
+    }
+    i = k + 1;
+  }
+
+  if (!shape.empty() && out_shape.empty()) {
+    out_shape.push_back(1);
+    for (auto& out_stride : out_strides) {
+      out_stride.push_back(0);
+    }
+  }
+  return std::make_tuple(out_shape, out_strides);
+}
+
+std::pair<Shape, Strides> collapse_contiguous_dims(
+    const Shape& shape,
+    const Strides& strides,
+    int64_t size_cap) {
+  Shape collapsed_shape;
+  Strides collapsed_strides;
+
+  if (shape.size() > 0) {
+    collapsed_shape.push_back(shape[0]);
+    collapsed_strides.push_back(strides[0]);
+    for (int i = 1; i < shape.size(); i++) {
+      if (shape[i] == 1) {
+        continue;
+      } else if (
+          strides[i] * shape[i] != collapsed_strides.back() ||
+          collapsed_shape.back() * static_cast<int64_t>(shape[i]) > size_cap) {
+        collapsed_shape.push_back(shape[i]);
+        collapsed_strides.push_back(strides[i]);
+      } else {
+        collapsed_shape.back() *= shape[i];
+        collapsed_strides.back() = strides[i];
+      }
+    }
+  }
+
+  return std::make_pair(collapsed_shape, collapsed_strides);
+}
+
+std::pair<Shape, Strides> collapse_contiguous_dims(
+    const array& a,
+    int64_t size_cap /* = std::numeric_limits<int32_t>::max()*/) {
+  return collapse_contiguous_dims(a.shape(), a.strides(), size_cap);
+}
+
+Dims get_block_dims_common(int dim0, int dim1, int dim2, int pow2 /* = 10 */) {
+  int pows[3] = {0, 0, 0};
+  int sum = 0;
+  while (true) {
+    int presum = sum;
+    // Check all the pows
+    if (dim0 >= (1 << (pows[0] + 1))) {
+      pows[0]++;
+      sum++;
+    }
+    if (sum == 10) {
+      break;
+    }
+    if (dim1 >= (1 << (pows[1] + 1))) {
+      pows[1]++;
+      sum++;
+    }
+    if (sum == 10) {
+      break;
+    }
+    if (dim2 >= (1 << (pows[2] + 1))) {
+      pows[2]++;
+      sum++;
+    }
+    if (sum == presum || sum == pow2) {
+      break;
+    }
+  }
+  return std::make_tuple(1ul << pows[0], 1ul << pows[1], 1ul << pows[2]);
+}
+
+Dims get_2d_grid_dims_common(const Shape& shape, const Strides& strides) {
+  // Dims with strides of 0 are ignored as they
+  // correspond to broadcasted dimensions
+  size_t grid_x = 1;
+  size_t grid_y = 1;
+  for (int i = 0; i < shape.size(); ++i) {
+    if (strides[i] == 0) {
+      continue;
+    }
+    if (grid_x * shape[i] < UINT32_MAX) {
+      grid_x *= shape[i];
+    } else {
+      grid_y *= shape[i];
+    }
+  }
+  if (grid_y > UINT32_MAX || grid_x > UINT32_MAX) {
+    throw std::runtime_error("Unable to safely factor shape.");
+  }
+  if (grid_y > grid_x) {
+    std::swap(grid_x, grid_y);
+  }
+  return std::make_tuple(
+      static_cast<uint32_t>(grid_x), static_cast<uint32_t>(grid_y), 1);
+}
+
+Dims get_2d_grid_dims_common(
+    const Shape& shape,
+    const Strides& strides,
+    size_t divisor) {
+  // Compute the 2d grid dimensions such that the total size of the grid is
+  // divided by divisor.
+  size_t grid_x = 1;
+  size_t grid_y = 1;
+  for (int i = 0; i < shape.size(); ++i) {
+    if (strides[i] == 0) {
+      continue;
+    }
+
+    // No need to add this shape we can just remove it from the divisor.
+    if (divisor % shape[i] == 0) {
+      divisor /= shape[i];
+      continue;
+    }
+
+    if (grid_x * shape[i] < UINT32_MAX) {
+      grid_x *= shape[i];
+    } else {
+      grid_y *= shape[i];
+    }
+
+    if (divisor > 1) {
+      if (grid_x % divisor == 0) {
+        grid_x /= divisor;
+        divisor = 1;
+      } else if (grid_y % divisor == 0) {
+        grid_y /= divisor;
+        divisor = 1;
+      }
+    }
+  }
+  if (grid_y > UINT32_MAX || grid_x > UINT32_MAX) {
+    throw std::runtime_error("Unable to safely factor shape.");
+  }
+  if (grid_y > grid_x) {
+    std::swap(grid_x, grid_y);
+  }
+  if (divisor > 1) {
+    grid_x = ((grid_x + divisor - 1) / divisor) * divisor;
+  }
+  return std::make_tuple(
+      static_cast<uint32_t>(grid_x), static_cast<uint32_t>(grid_y), 1);
+}
+
+std::pair<Dims, Dims> get_grid_and_block_common(int dim0, int dim1, int dim2) {
+  auto [bx, by, bz] = get_block_dims_common(dim0, dim1, dim2);
+  auto gx = (dim0 + bx - 1) / bx;
+  auto gy = (dim1 + by - 1) / by;
+  auto gz = (dim2 + bz - 1) / bz;
+
+  return std::make_pair(
+      std::make_tuple(gx, gy, gz), std::make_tuple(bx, by, bz));
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/common/utils.h b/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b6902ff331cfb467b1d031aeb1a9d72a50b59ad
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/common/utils.h
@@ -0,0 +1,205 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <filesystem>
+#include <tuple>
+#include <vector>
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+// Return the directory that contains current shared library.
+std::filesystem::path current_binary_dir();
+
+inline int64_t
+elem_to_loc(int elem, const Shape& shape, const Strides& strides) {
+  int64_t loc = 0;
+  for (int i = shape.size() - 1; i >= 0; --i) {
+    auto q_and_r = ldiv(elem, shape[i]);
+    loc += q_and_r.rem * strides[i];
+    elem = q_and_r.quot;
+  }
+  return loc;
+}
+
+inline int64_t elem_to_loc(int elem, const array& a) {
+  if (a.flags().row_contiguous) {
+    return elem;
+  }
+  return elem_to_loc(elem, a.shape(), a.strides());
+}
+
+inline Strides make_contiguous_strides(const Shape& shape) {
+  Strides strides(shape.size(), 1);
+  for (int i = shape.size() - 1; i > 0; i--) {
+    strides[i - 1] = strides[i] * shape[i];
+  }
+  return strides;
+}
+
+// Collapse dims that are contiguous to possibly route to a better kernel
+// e.g. for x = transpose(array({0, 1, 2, 3, 4, 5, 6, 7}, {2, 2, 2}), {2, 0, 1})
+// should return {{2, 4}, {{1, 2}}}.
+//
+// When multiple arrays are passed they should all have the same shape. The
+// collapsed axes are also the same so one shape is returned.
+std::tuple<Shape, std::vector<Strides>> collapse_contiguous_dims(
+    const Shape& shape,
+    const std::vector<Strides>& strides,
+    int64_t size_cap = std::numeric_limits<int32_t>::max());
+
+inline std::tuple<Shape, std::vector<Strides>> collapse_contiguous_dims(
+    const std::vector<array>& xs,
+    size_t size_cap = std::numeric_limits<int32_t>::max()) {
+  std::vector<Strides> strides;
+  for (auto& x : xs) {
+    strides.emplace_back(x.strides());
+  }
+  return collapse_contiguous_dims(xs[0].shape(), strides, size_cap);
+}
+
+template <typename... Arrays, typename = enable_for_arrays_t<Arrays...>>
+inline auto collapse_contiguous_dims(Arrays&&... xs) {
+  return collapse_contiguous_dims(
+      std::vector<array>{std::forward<Arrays>(xs)...});
+}
+
+// The single array version of the above.
+std::pair<Shape, Strides> collapse_contiguous_dims(
+    const Shape& shape,
+    const Strides& strides,
+    int64_t size_cap = std::numeric_limits<int32_t>::max());
+std::pair<Shape, Strides> collapse_contiguous_dims(
+    const array& a,
+    int64_t size_cap = std::numeric_limits<int32_t>::max());
+
+// Compute the thread block dimensions which fit the given
+// input dimensions.
+// - The thread block dimensions will be powers of two
+// - The thread block size will be less than 2^pow2
+using Dims = std::tuple<uint32_t, uint32_t, uint32_t>;
+Dims get_block_dims_common(int dim0, int dim1, int dim2, int pow2 = 10);
+
+// Computes a 2D grid where each element is < UINT_MAX
+// Assumes:
+// - overall size (product of non-broadcasted dimensions) is < UINT_MAX^2
+// - shape and strides correspond to a contiguous (no holes) but
+//   possibly broadcasted array
+Dims get_2d_grid_dims_common(const Shape& shape, const Strides& strides);
+
+// Same as above but we do an implicit division with divisor.
+// Basically, equivalent to factorizing
+//    Prod(s \forall s in shape if strides[s] > 0) / divisor.
+Dims get_2d_grid_dims_common(
+    const Shape& shape,
+    const Strides& strides,
+    size_t divisor);
+
+// Get both the block and a grid of blocks that covers dim0, dim1 and dim2.
+std::pair<Dims, Dims> get_grid_and_block_common(int dim0, int dim1, int dim2);
+
+struct ContiguousIterator {
+  inline void step() {
+    int dims = shape_.size();
+    if (dims == 0) {
+      return;
+    }
+    int i = dims - 1;
+    while (pos_[i] == (shape_[i] - 1) && i > 0) {
+      pos_[i] = 0;
+      loc -= (shape_[i] - 1) * strides_[i];
+      i--;
+    }
+    pos_[i]++;
+    loc += strides_[i];
+  }
+
+  void seek(int64_t n) {
+    loc = 0;
+    for (int i = shape_.size() - 1; i >= 0; --i) {
+      auto q_and_r = ldiv(n, shape_[i]);
+      loc += q_and_r.rem * strides_[i];
+      pos_[i] = q_and_r.rem;
+      n = q_and_r.quot;
+    }
+  }
+
+  void reset() {
+    loc = 0;
+    std::fill(pos_.begin(), pos_.end(), 0);
+  }
+
+  ContiguousIterator() {};
+
+  explicit ContiguousIterator(const array& a)
+      : shape_(a.shape()), strides_(a.strides()) {
+    if (!shape_.empty()) {
+      std::tie(shape_, strides_) = collapse_contiguous_dims(shape_, strides_);
+      pos_ = Shape(shape_.size(), 0);
+    }
+  }
+
+  explicit ContiguousIterator(
+      const Shape& shape,
+      const Strides& strides,
+      int dims)
+      : shape_(shape.begin(), shape.begin() + dims),
+        strides_(strides.begin(), strides.begin() + dims) {
+    if (!shape_.empty()) {
+      std::tie(shape_, strides_) = collapse_contiguous_dims(shape_, strides_);
+      pos_ = Shape(shape_.size(), 0);
+    }
+  }
+
+  int64_t loc{0};
+
+ private:
+  Shape shape_;
+  Strides strides_;
+  Shape pos_;
+};
+
+inline auto check_contiguity(const Shape& shape, const Strides& strides) {
+  size_t no_broadcast_data_size = 1;
+  int64_t f_stride = 1;
+  int64_t b_stride = 1;
+  bool is_row_contiguous = true;
+  bool is_col_contiguous = true;
+
+  for (int i = 0, ri = shape.size() - 1; ri >= 0; i++, ri--) {
+    is_col_contiguous &= strides[i] == f_stride || shape[i] == 1;
+    is_row_contiguous &= strides[ri] == b_stride || shape[ri] == 1;
+    f_stride *= shape[i];
+    b_stride *= shape[ri];
+    if (strides[i] > 0) {
+      no_broadcast_data_size *= shape[i];
+    }
+  }
+
+  return std::make_tuple(
+      no_broadcast_data_size, is_row_contiguous, is_col_contiguous);
+}
+
+inline bool is_donatable(const array& in, const array& out) {
+  constexpr size_t donation_extra = 16384;
+
+  return in.is_donatable() && in.itemsize() == out.itemsize() &&
+      in.buffer_size() <= out.nbytes() + donation_extra;
+}
+
+std::pair<bool, Strides> prepare_reshape(const array& in, const array& out);
+
+void shared_buffer_reshape(
+    const array& in,
+    const Strides& out_strides,
+    array& out);
+
+template <typename T>
+inline SmallVector<T> remove_index(SmallVector<T> vec, size_t index) {
+  vec.erase(std::next(vec.begin(), index));
+  return vec;
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/backend/cpu/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9d322c4c49c16d7b442ccb6d0404e5ca51223168
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/CMakeLists.txt
@@ -0,0 +1,88 @@
+if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+  set(COMPILER ${CMAKE_C_COMPILER})
+  set(CLANG TRUE)
+else()
+  set(COMPILER ${CMAKE_CXX_COMPILER})
+endif()
+
+set(COMPILE_DEPS
+    ${PROJECT_SOURCE_DIR}/mlx/types/half_types.h
+    ${PROJECT_SOURCE_DIR}/mlx/types/fp16.h
+    ${PROJECT_SOURCE_DIR}/mlx/types/bf16.h
+    ${PROJECT_SOURCE_DIR}/mlx/types/complex.h
+    simd/simd.h
+    simd/base_simd.h
+    simd/math.h
+    simd/type.h
+    unary_ops.h
+    binary_ops.h)
+
+if(MSVC)
+  set(SHELL_EXT ps1)
+  set(SHELL_CMD powershell -ExecutionPolicy Bypass -File)
+else()
+  set(SHELL_EXT sh)
+  set(SHELL_CMD bash)
+endif()
+
+add_custom_command(
+  OUTPUT compiled_preamble.cpp
+  COMMAND
+    ${SHELL_CMD} ${CMAKE_CURRENT_SOURCE_DIR}/make_compiled_preamble.${SHELL_EXT}
+    ${CMAKE_CURRENT_BINARY_DIR}/compiled_preamble.cpp ${COMPILER}
+    ${PROJECT_SOURCE_DIR} ${CLANG} ${CMAKE_SYSTEM_PROCESSOR}
+  DEPENDS make_compiled_preamble.${SHELL_EXT} compiled_preamble.h
+          ${COMPILE_DEPS})
+
+add_custom_target(cpu_compiled_preamble DEPENDS compiled_preamble.cpp)
+
+add_dependencies(mlx cpu_compiled_preamble)
+
+target_sources(
+  mlx
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/available.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/arg_reduce.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/binary.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/conv.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/copy.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/distributed.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/eig.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/eigh.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/encoder.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/fft.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/hadamard.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/matmul.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/gemms/cblas.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/masked_mm.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/primitives.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/quantized.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/reduce.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/scan.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/select.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/softmax.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/logsumexp.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/sort.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/threefry.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/indexing.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/luf.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/qrf.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/svd.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/inverse.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/cholesky.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/unary.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/eval.cpp
+          ${CMAKE_CURRENT_BINARY_DIR}/compiled_preamble.cpp)
+
+if(MLX_BUILD_ACCELERATE)
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/gemms/bnns.cpp)
+else()
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/gemms/simd_fp16.cpp
+                             ${CMAKE_CURRENT_SOURCE_DIR}/gemms/simd_bf16.cpp)
+endif()
+
+if(IOS)
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../no_cpu/compiled.cpp)
+else()
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/compiled.cpp
+                             ${CMAKE_CURRENT_SOURCE_DIR}/jit_compiler.cpp)
+endif()
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/arange.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/arange.h
new file mode 100644
index 0000000000000000000000000000000000000000..9e9b03bd77e4c4039a8786f3a5cbf00b7a2353a7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/arange.h
@@ -0,0 +1,28 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+#include "mlx/backend/cpu/encoder.h"
+
+namespace mlx::core {
+
+namespace {
+
+template <typename T>
+void arange(T start, T next, array& out, size_t size, Stream stream) {
+  auto ptr = out.data<T>();
+  auto step_size = next - start;
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_output_array(out);
+  encoder.dispatch([ptr, start, step_size, size]() mutable {
+    for (int i = 0; i < size; ++i) {
+      ptr[i] = start;
+      start += step_size;
+    }
+  });
+}
+
+} // namespace
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..66468912d10762e6d7588c4a6d261371904b3ed2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/arg_reduce.cpp
@@ -0,0 +1,124 @@
+// Copyright © 2023 Apple Inc.
+
+#include <cassert>
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+namespace {
+
+template <typename InT, typename OpT>
+void arg_reduce(const array& in, array& out, const OpT& op, int axis) {
+  auto axis_size = in.shape()[axis];
+  auto axis_stride = in.strides()[axis];
+  Strides strides = remove_index(in.strides(), axis);
+  Shape shape = remove_index(in.shape(), axis);
+  auto in_ptr = in.data<InT>();
+  auto out_ptr = out.data<uint32_t>();
+
+  for (uint32_t i = 0; i < out.size(); ++i) {
+    auto loc = elem_to_loc(i, shape, strides);
+    auto local_in_ptr = in_ptr + loc;
+    uint32_t ind_v = 0;
+    InT v = (*local_in_ptr);
+    for (uint32_t j = 0; j < axis_size; ++j, local_in_ptr += axis_stride) {
+      op(j, (*local_in_ptr), &ind_v, &v);
+    }
+    out_ptr[i] = ind_v;
+  }
+}
+
+template <typename InT>
+void arg_reduce_dispatch(
+    const array& in,
+    array& out,
+    ArgReduce::ReduceType rtype,
+    int axis) {
+  switch (rtype) {
+    case ArgReduce::ArgMin: {
+      auto op = [](auto ind_x, auto x, auto ind_y, auto y) {
+        if (x < (*y)) {
+          (*y) = x;
+          (*ind_y) = ind_x;
+        }
+      };
+      arg_reduce<InT>(in, out, op, axis);
+      break;
+    }
+    case ArgReduce::ArgMax: {
+      auto op = [](auto ind_x, auto x, auto ind_y, auto y) {
+        if (x > (*y)) {
+          (*y) = x;
+          (*ind_y) = ind_x;
+        }
+      };
+      arg_reduce<InT>(in, out, op, axis);
+      break;
+    }
+  }
+}
+
+} // namespace
+
+void ArgReduce::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  out.set_data(allocator::malloc(out.nbytes()));
+  auto& encoder = cpu::get_command_encoder(stream());
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  encoder.dispatch([in = array::unsafe_weak_copy(in),
+                    out = array::unsafe_weak_copy(out),
+                    reduce_type_ = reduce_type_,
+                    axis_ = axis_]() mutable {
+    switch (in.dtype()) {
+      case bool_:
+        arg_reduce_dispatch<bool>(in, out, reduce_type_, axis_);
+        break;
+      case uint8:
+        arg_reduce_dispatch<uint8_t>(in, out, reduce_type_, axis_);
+        break;
+      case uint16:
+        arg_reduce_dispatch<uint16_t>(in, out, reduce_type_, axis_);
+        break;
+      case uint32:
+        arg_reduce_dispatch<uint32_t>(in, out, reduce_type_, axis_);
+        break;
+      case uint64:
+        arg_reduce_dispatch<uint64_t>(in, out, reduce_type_, axis_);
+        break;
+      case int8:
+        arg_reduce_dispatch<int8_t>(in, out, reduce_type_, axis_);
+        break;
+      case int16:
+        arg_reduce_dispatch<int16_t>(in, out, reduce_type_, axis_);
+        break;
+      case int32:
+        arg_reduce_dispatch<int32_t>(in, out, reduce_type_, axis_);
+        break;
+      case int64:
+        arg_reduce_dispatch<int64_t>(in, out, reduce_type_, axis_);
+        break;
+      case float16:
+        arg_reduce_dispatch<float16_t>(in, out, reduce_type_, axis_);
+        break;
+      case float32:
+        arg_reduce_dispatch<float>(in, out, reduce_type_, axis_);
+        break;
+      case bfloat16:
+        arg_reduce_dispatch<bfloat16_t>(in, out, reduce_type_, axis_);
+        break;
+      case float64:
+        arg_reduce_dispatch<double>(in, out, reduce_type_, axis_);
+        break;
+      case complex64:
+        arg_reduce_dispatch<complex64_t>(in, out, reduce_type_, axis_);
+        break;
+    }
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0449d49b9a0ff64cd35b0f7c99307196eb8d419a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/available.cpp
@@ -0,0 +1,11 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cpu/available.h"
+
+namespace mlx::core::cpu {
+
+bool is_available() {
+  return true;
+}
+
+} // namespace mlx::core::cpu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/available.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/available.h
new file mode 100644
index 0000000000000000000000000000000000000000..1df95def21ed742ce8a559f12103beb3e16404c7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/available.h
@@ -0,0 +1,9 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+namespace mlx::core::cpu {
+
+bool is_available();
+
+} // namespace mlx::core::cpu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..35aa2a3e0dd53c6cf3ac233d27ea6c3c5014ff0c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.cpp
@@ -0,0 +1,490 @@
+// Copyright © 2023 Apple Inc.
+
+#include <cassert>
+#include <cmath>
+#include <sstream>
+
+#include "mlx/allocator.h"
+#include "mlx/backend/cpu/binary.h"
+#include "mlx/backend/cpu/binary_ops.h"
+#include "mlx/backend/cpu/binary_two.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+namespace {
+
+template <typename Op>
+void binary(const array& a, const array& b, array& out, Op op, Stream stream) {
+  auto bopt = get_binary_op_type(a, b);
+  set_binary_op_output_data(a, b, out, bopt);
+
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_output_array(out);
+  encoder.dispatch([a = array::unsafe_weak_copy(a),
+                    b = array::unsafe_weak_copy(b),
+                    out = array::unsafe_weak_copy(out),
+                    bopt]() mutable {
+    switch (out.dtype()) {
+      case bool_:
+        binary_op<bool, Op>(a, b, out, bopt);
+        break;
+      case uint8:
+        binary_op<uint8_t, Op>(a, b, out, bopt);
+        break;
+      case uint16:
+        binary_op<uint16_t, Op>(a, b, out, bopt);
+        break;
+      case uint32:
+        binary_op<uint32_t, Op>(a, b, out, bopt);
+        break;
+      case uint64:
+        binary_op<uint64_t, Op>(a, b, out, bopt);
+        break;
+      case int8:
+        binary_op<int8_t, Op>(a, b, out, bopt);
+        break;
+      case int16:
+        binary_op<int16_t, Op>(a, b, out, bopt);
+        break;
+      case int32:
+        binary_op<int32_t, Op>(a, b, out, bopt);
+        break;
+      case int64:
+        binary_op<int64_t, Op>(a, b, out, bopt);
+        break;
+      case float16:
+        binary_op<float16_t, Op>(a, b, out, bopt);
+        break;
+      case float32:
+        binary_op<float, Op>(a, b, out, bopt);
+        break;
+      case float64:
+        binary_op<double, Op>(a, b, out, bopt);
+        break;
+      case bfloat16:
+        binary_op<bfloat16_t, Op>(a, b, out, bopt);
+        break;
+      case complex64:
+        binary_op<complex64_t, Op>(a, b, out, bopt);
+        break;
+    }
+  });
+}
+
+template <typename Op>
+void comparison_op(
+    const array& a,
+    const array& b,
+    array& out,
+    Op op,
+    Stream stream) {
+  auto bopt = get_binary_op_type(a, b);
+  set_binary_op_output_data(a, b, out, bopt);
+
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_output_array(out);
+  encoder.dispatch([a = array::unsafe_weak_copy(a),
+                    b = array::unsafe_weak_copy(b),
+                    out = array::unsafe_weak_copy(out),
+                    bopt]() mutable {
+    switch (a.dtype()) {
+      case bool_:
+        binary_op<bool, bool, Op>(a, b, out, bopt);
+        break;
+      case uint8:
+        binary_op<uint8_t, bool, Op>(a, b, out, bopt);
+        break;
+      case uint16:
+        binary_op<uint16_t, bool, Op>(a, b, out, bopt);
+        break;
+      case uint32:
+        binary_op<uint32_t, bool, Op>(a, b, out, bopt);
+        break;
+      case uint64:
+        binary_op<uint64_t, bool, Op>(a, b, out, bopt);
+        break;
+      case int8:
+        binary_op<int8_t, bool, Op>(a, b, out, bopt);
+        break;
+      case int16:
+        binary_op<int16_t, bool, Op>(a, b, out, bopt);
+        break;
+      case int32:
+        binary_op<int32_t, bool, Op>(a, b, out, bopt);
+        break;
+      case int64:
+        binary_op<int64_t, bool, Op>(a, b, out, bopt);
+        break;
+      case float16:
+        binary_op<float16_t, bool, Op>(a, b, out, bopt);
+        break;
+      case float32:
+        binary_op<float, bool, Op>(a, b, out, bopt);
+        break;
+      case float64:
+        binary_op<double, bool, Op>(a, b, out, bopt);
+        break;
+      case bfloat16:
+        binary_op<bfloat16_t, bool, Op>(a, b, out, bopt);
+        break;
+      case complex64:
+        binary_op<complex64_t, bool, Op>(a, b, out, bopt);
+        break;
+    }
+  });
+}
+
+template <typename Op>
+void binary_float(
+    const array& a,
+    const array& b,
+    array& out,
+    Op op,
+    Stream stream) {
+  auto bopt = get_binary_op_type(a, b);
+  set_binary_op_output_data(a, b, out, bopt);
+
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_output_array(out);
+  encoder.dispatch([a = array::unsafe_weak_copy(a),
+                    b = array::unsafe_weak_copy(b),
+                    out = array::unsafe_weak_copy(out),
+                    bopt]() mutable {
+    switch (out.dtype()) {
+      case float16:
+        binary_op<float16_t, Op>(a, b, out, bopt);
+        break;
+      case float32:
+        binary_op<float, Op>(a, b, out, bopt);
+        break;
+      case float64:
+        binary_op<double, Op>(a, b, out, bopt);
+        break;
+      case bfloat16:
+        binary_op<bfloat16_t, Op>(a, b, out, bopt);
+        break;
+      case complex64:
+        binary_op<complex64_t, Op>(a, b, out, bopt);
+        break;
+      default:
+        throw std::runtime_error(
+            "[binary_float] Only supports floating point types.");
+    }
+  });
+}
+
+template <typename Op>
+void binary_int(
+    const array& a,
+    const array& b,
+    array& out,
+    Op op,
+    Stream stream) {
+  auto bopt = get_binary_op_type(a, b);
+  set_binary_op_output_data(a, b, out, bopt);
+
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_output_array(out);
+  encoder.dispatch([a = array::unsafe_weak_copy(a),
+                    b = array::unsafe_weak_copy(b),
+                    out = array::unsafe_weak_copy(out),
+                    bopt]() mutable {
+    switch (out.dtype()) {
+      case bool_:
+        binary_op<bool, Op>(a, b, out, bopt);
+      case uint8:
+        binary_op<uint8_t, Op>(a, b, out, bopt);
+        break;
+      case uint16:
+        binary_op<uint16_t, Op>(a, b, out, bopt);
+        break;
+      case uint32:
+        binary_op<uint32_t, Op>(a, b, out, bopt);
+        break;
+      case uint64:
+        binary_op<uint64_t, Op>(a, b, out, bopt);
+        break;
+      case int8:
+        binary_op<int8_t, Op>(a, b, out, bopt);
+        break;
+      case int16:
+        binary_op<int16_t, Op>(a, b, out, bopt);
+        break;
+      case int32:
+        binary_op<int32_t, Op>(a, b, out, bopt);
+        break;
+      case int64:
+        binary_op<int64_t, Op>(a, b, out, bopt);
+        break;
+      default:
+        throw std::runtime_error("[binary_int] Type not supported");
+        break;
+    }
+  });
+}
+
+} // namespace
+
+void Add::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  binary(a, b, out, detail::Add(), stream());
+}
+
+void DivMod::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  auto bopt = get_binary_op_type(a, b);
+  auto& out_a = outputs[0];
+  auto& out_b = outputs[1];
+  set_binary_op_output_data(a, b, out_a, bopt);
+  set_binary_op_output_data(a, b, out_b, bopt);
+
+  auto& encoder = cpu::get_command_encoder(stream());
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_output_array(out_a);
+  encoder.set_output_array(out_b);
+
+  encoder.dispatch([a = array::unsafe_weak_copy(a),
+                    b = array::unsafe_weak_copy(b),
+                    out_a = array::unsafe_weak_copy(out_a),
+                    out_b = array::unsafe_weak_copy(out_b),
+                    bopt]() mutable {
+    auto integral_op = [](auto x, auto y) {
+      return std::make_pair(x / y, x % y);
+    };
+    auto float_op = [](auto x, auto y) {
+      return std::make_pair(std::trunc(x / y), std::fmod(x, y));
+    };
+
+    switch (out_a.dtype()) {
+      case bool_:
+        binary_op<bool>(a, b, out_a, out_b, integral_op, bopt);
+      case uint8:
+        binary_op<uint8_t>(a, b, out_a, out_b, integral_op, bopt);
+        break;
+      case uint16:
+        binary_op<uint16_t>(a, b, out_a, out_b, integral_op, bopt);
+        break;
+      case uint32:
+        binary_op<uint32_t>(a, b, out_a, out_b, integral_op, bopt);
+        break;
+      case uint64:
+        binary_op<uint64_t>(a, b, out_a, out_b, integral_op, bopt);
+        break;
+      case int8:
+        binary_op<int8_t>(a, b, out_a, out_b, integral_op, bopt);
+        break;
+      case int16:
+        binary_op<int16_t>(a, b, out_a, out_b, integral_op, bopt);
+        break;
+      case int32:
+        binary_op<int32_t>(a, b, out_a, out_b, integral_op, bopt);
+        break;
+      case int64:
+        binary_op<int64_t>(a, b, out_a, out_b, integral_op, bopt);
+        break;
+      case float16:
+        binary_op<float16_t>(a, b, out_a, out_b, float_op, bopt);
+        break;
+      case float32:
+        binary_op<float>(a, b, out_a, out_b, float_op, bopt);
+        break;
+      case float64:
+        binary_op<double>(a, b, out_a, out_b, float_op, bopt);
+        break;
+      case bfloat16:
+        binary_op<bfloat16_t>(a, b, out_a, out_b, float_op, bopt);
+        break;
+      case complex64:
+        // Should never get here
+        throw std::runtime_error("[DivMod] Complex type not supported");
+        break;
+    }
+  });
+}
+
+void Divide::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  binary(a, b, out, detail::Divide(), stream());
+}
+
+void Remainder::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  binary(a, b, out, detail::Remainder(), stream());
+}
+
+void Equal::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  if (equal_nan_) {
+    auto bopt = get_binary_op_type(a, b);
+    set_binary_op_output_data(a, b, out, bopt);
+
+    auto& encoder = cpu::get_command_encoder(stream());
+    encoder.set_input_array(a);
+    encoder.set_input_array(b);
+    encoder.set_output_array(out);
+    encoder.dispatch([a = array::unsafe_weak_copy(a),
+                      b = array::unsafe_weak_copy(b),
+                      out = array::unsafe_weak_copy(out),
+                      bopt]() mutable {
+      switch (a.dtype()) {
+        case float16:
+          binary_op<float16_t, bool, detail::NaNEqual>(a, b, out, bopt);
+          break;
+        case float32:
+          binary_op<float, bool, detail::NaNEqual>(a, b, out, bopt);
+          break;
+        case float64:
+          binary_op<double, bool, detail::NaNEqual>(a, b, out, bopt);
+          break;
+        case bfloat16:
+          binary_op<bfloat16_t, bool, detail::NaNEqual>(a, b, out, bopt);
+          break;
+        case complex64:
+          binary_op<complex64_t, bool, detail::NaNEqual>(a, b, out, bopt);
+          break;
+        default:
+          throw std::runtime_error(
+              "[NanEqual::eval_cpu] Only for floating point types.");
+      }
+    });
+  } else {
+    comparison_op(a, b, out, detail::Equal(), stream());
+  }
+}
+
+void Greater::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  comparison_op(inputs[0], inputs[1], out, detail::Greater(), stream());
+}
+
+void GreaterEqual::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  comparison_op(inputs[0], inputs[1], out, detail::GreaterEqual(), stream());
+}
+
+void Less::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  comparison_op(inputs[0], inputs[1], out, detail::Less(), stream());
+}
+
+void LessEqual::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  comparison_op(inputs[0], inputs[1], out, detail::LessEqual(), stream());
+}
+
+void LogAddExp::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  binary_float(a, b, out, detail::LogAddExp(), stream());
+}
+
+void LogicalAnd::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2); // LogicalAnd requires two input arrays
+  auto& in1 = inputs[0];
+  auto& in2 = inputs[1];
+  binary(in1, in2, out, detail::LogicalAnd(), stream());
+}
+
+void LogicalOr::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2); // LogicalOr requires two input arrays
+  auto& in1 = inputs[0];
+  auto& in2 = inputs[1];
+  binary(in1, in2, out, detail::LogicalOr(), stream());
+}
+
+void Maximum::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  binary(a, b, out, detail::Maximum(), stream());
+}
+
+void Minimum::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  binary(a, b, out, detail::Minimum(), stream());
+}
+
+void Multiply::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  binary(a, b, out, detail::Multiply(), stream());
+}
+
+void NotEqual::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  comparison_op(inputs[0], inputs[1], out, detail::NotEqual(), stream());
+}
+
+void Power::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  binary(a, b, out, detail::Power(), stream());
+}
+
+void Subtract::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  binary(a, b, out, detail::Subtract(), stream());
+}
+
+void BitwiseBinary::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  switch (op_) {
+    case BitwiseBinary::And:
+      binary_int(a, b, out, detail::BitwiseAnd(), stream());
+      break;
+    case BitwiseBinary::Or:
+      binary_int(a, b, out, detail::BitwiseOr(), stream());
+      break;
+    case BitwiseBinary::Xor:
+      binary_int(a, b, out, detail::BitwiseXor(), stream());
+      break;
+    case BitwiseBinary::LeftShift:
+      binary_int(a, b, out, detail::LeftShift(), stream());
+      break;
+    case BitwiseBinary::RightShift:
+      binary_int(a, b, out, detail::RightShift(), stream());
+      break;
+  }
+}
+
+void ArcTan2::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  const auto& a = inputs[0];
+  const auto& b = inputs[1];
+  binary_float(a, b, out, detail::ArcTan2(), stream());
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.h
new file mode 100644
index 0000000000000000000000000000000000000000..31966c0ea301c08db0460e381fbc8e0238e20938
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/binary.h
@@ -0,0 +1,293 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+#include <cassert>
+
+#include "mlx/array.h"
+#include "mlx/backend/common/binary.h"
+#include "mlx/backend/common/utils.h"
+
+#include "mlx/backend/cpu/simd/simd.h"
+
+namespace mlx::core {
+
+template <typename Op>
+struct VectorScalar {
+  template <typename T, typename U>
+  void operator()(const T* a, const T* b, U* dst, int size) {
+    T scalar = *b;
+    constexpr int N = simd::max_size<T>;
+    while (size >= N) {
+      simd::store(dst, Op{}(simd::load<T, N>(a), simd::Simd<T, N>(scalar)));
+      dst += N;
+      a += N;
+      size -= N;
+    }
+    while (size-- > 0) {
+      *dst = Op{}(*a, scalar);
+      dst++;
+      a++;
+    }
+  }
+};
+
+template <typename Op>
+struct ScalarVector {
+  template <typename T, typename U>
+  void operator()(const T* a, const T* b, U* dst, int size) {
+    T scalar = *a;
+    constexpr int N = simd::max_size<T>;
+    while (size >= N) {
+      simd::store(dst, Op{}(simd::Simd<T, N>(scalar), simd::load<T, N>(b)));
+      dst += N;
+      b += N;
+      size -= N;
+    }
+    while (size-- > 0) {
+      *dst = Op{}(scalar, *b);
+      dst++;
+      b++;
+    }
+  }
+};
+
+template <typename Op>
+struct VectorVector {
+  template <typename T, typename U>
+  void operator()(const T* a, const T* b, U* dst, int size) {
+    constexpr int N = simd::max_size<T>;
+    while (size >= N) {
+      simd::store(dst, Op{}(simd::load<T, N>(a), simd::load<T, N>(b)));
+      dst += N;
+      a += N;
+      b += N;
+      size -= N;
+    }
+    while (size-- > 0) {
+      *dst = Op{}(*a, *b);
+      dst++;
+      a++;
+      b++;
+    }
+  }
+};
+
+template <typename T, typename U, typename Op, int D, bool Strided>
+void binary_op_dims(
+    const T* a,
+    const T* b,
+    U* out,
+    const Shape& shape,
+    const Strides& a_strides,
+    const Strides& b_strides,
+    const Strides& out_strides,
+    int axis) {
+  auto stride_a = a_strides[axis];
+  auto stride_b = b_strides[axis];
+  auto stride_out = out_strides[axis];
+  auto N = shape[axis];
+
+  for (int i = 0; i < N; i++) {
+    if constexpr (D > 1) {
+      binary_op_dims<T, U, Op, D - 1, Strided>(
+          a, b, out, shape, a_strides, b_strides, out_strides, axis + 1);
+    } else {
+      if constexpr (Strided) {
+        Op{}(a, b, out, stride_out);
+      } else {
+        *out = Op{}(*a, *b);
+      }
+    }
+    out += stride_out;
+    a += stride_a;
+    b += stride_b;
+  }
+}
+
+template <typename T, typename U, bool Strided, typename Op>
+void binary_op_dispatch_dims(
+    const T* a,
+    const T* b,
+    U* out,
+    int dim,
+    int size,
+    const Shape& shape,
+    const Strides& a_strides,
+    const Strides& b_strides,
+    const Strides& out_strides) {
+  switch (dim) {
+    case 1:
+      binary_op_dims<T, U, Op, 1, Strided>(
+          a, b, out, shape, a_strides, b_strides, out_strides, 0);
+      return;
+    case 2:
+      binary_op_dims<T, U, Op, 2, Strided>(
+          a, b, out, shape, a_strides, b_strides, out_strides, 0);
+      return;
+    case 3:
+      binary_op_dims<T, U, Op, 3, Strided>(
+          a, b, out, shape, a_strides, b_strides, out_strides, 0);
+      return;
+  }
+
+  ContiguousIterator a_it(shape, a_strides, dim - 3);
+  ContiguousIterator b_it(shape, b_strides, dim - 3);
+  auto stride = out_strides[dim - 4];
+  for (int64_t elem = 0; elem < size; elem += stride) {
+    binary_op_dims<T, U, Op, 3, Strided>(
+        a + a_it.loc,
+        b + b_it.loc,
+        out + elem,
+        shape,
+        a_strides,
+        b_strides,
+        out_strides,
+        dim - 3);
+    a_it.step();
+    b_it.step();
+  }
+}
+
+template <typename T, typename U, typename Op>
+void binary_op(const array& a, const array& b, array& out, BinaryOpType bopt) {
+  // The full computation is scalar scalar so call the base op once
+  auto a_ptr = a.data<T>();
+  auto b_ptr = b.data<T>();
+
+  auto out_ptr = out.data<U>();
+  if (bopt == BinaryOpType::ScalarScalar) {
+    *out_ptr = Op{}(*a_ptr, *b_ptr);
+    return;
+  }
+
+  // The full computation is scalar vector so delegate to the op
+  if (bopt == BinaryOpType::ScalarVector) {
+    ScalarVector<Op>{}(a_ptr, b_ptr, out_ptr, b.data_size());
+    return;
+  }
+
+  // The full computation is vector scalar so delegate to the op
+  if (bopt == BinaryOpType::VectorScalar) {
+    VectorScalar<Op>{}(a_ptr, b_ptr, out_ptr, a.data_size());
+    return;
+  }
+
+  // The full computation is vector vector so delegate to the op
+  if (bopt == BinaryOpType::VectorVector) {
+    VectorVector<Op>{}(a_ptr, b_ptr, out_ptr, a.size());
+    return;
+  }
+
+  // General computation so let's try to optimize
+  auto [new_shape, new_strides] = collapse_contiguous_dims(
+      a.shape(), {a.strides(), b.strides(), out.strides()});
+  auto& a_strides = new_strides[0];
+  auto& b_strides = new_strides[1];
+  auto& strides = new_strides[2];
+
+  // Get the left-most dim such that the array is row contiguous after
+  auto leftmost_rc_dim = [&strides](const auto& arr_strides) {
+    int d = arr_strides.size() - 1;
+    for (; d >= 0 && arr_strides[d] == strides[d]; d--) {
+    }
+    return d + 1;
+  };
+  auto a_rc_dim = leftmost_rc_dim(a_strides);
+  auto b_rc_dim = leftmost_rc_dim(b_strides);
+
+  // Get the left-most dim such that the array is a broadcasted "scalar" after
+  auto leftmost_s_dim = [](const auto& arr_strides) {
+    int d = arr_strides.size() - 1;
+    for (; d >= 0 && arr_strides[d] == 0; d--) {
+    }
+    return d + 1;
+  };
+  auto a_s_dim = leftmost_s_dim(a_strides);
+  auto b_s_dim = leftmost_s_dim(b_strides);
+
+  auto ndim = new_shape.size();
+
+  // Case 1: LxM and FxM where L and F are broadcastable and M is row
+  // contiguous
+  int dim = ndim;
+  if (int d = std::max(a_rc_dim, b_rc_dim); d < ndim) {
+    bopt = BinaryOpType::VectorVector;
+    dim = d;
+    // Case 2: LxM and Fx1 where L and F are broadcastable and M is row
+    // contiguous
+  } else if (int d = std::max(a_rc_dim, b_s_dim); d < ndim) {
+    bopt = BinaryOpType::VectorScalar;
+    dim = d;
+    // Case 3: Lx1 and FxM where L and F are broadcastable and M is row
+    // contiguous
+  } else if (int d = std::max(a_s_dim, b_rc_dim); d < ndim) {
+    bopt = BinaryOpType::ScalarVector;
+    dim = d;
+  }
+
+  // Can be sure dim > 0 since otherwise we would have used one of the fully
+  // contiguous methods above. Except for the case that the flags do not
+  // correspond to the underlying contiguity.
+  if (dim == 0 || strides[dim - 1] < 16) {
+    bopt = BinaryOpType::General;
+    dim = ndim;
+  }
+
+  switch (bopt) {
+    case BinaryOpType::VectorVector:
+      binary_op_dispatch_dims<T, U, true, VectorVector<Op>>(
+          a_ptr,
+          b_ptr,
+          out_ptr,
+          dim,
+          a.size(),
+          new_shape,
+          a_strides,
+          b_strides,
+          strides);
+      break;
+    case BinaryOpType::VectorScalar:
+      binary_op_dispatch_dims<T, U, true, VectorScalar<Op>>(
+          a_ptr,
+          b_ptr,
+          out_ptr,
+          dim,
+          a.size(),
+          new_shape,
+          a_strides,
+          b_strides,
+          strides);
+      break;
+    case BinaryOpType::ScalarVector:
+      binary_op_dispatch_dims<T, U, true, ScalarVector<Op>>(
+          a_ptr,
+          b_ptr,
+          out_ptr,
+          dim,
+          a.size(),
+          new_shape,
+          a_strides,
+          b_strides,
+          strides);
+      break;
+    default:
+      binary_op_dispatch_dims<T, U, false, Op>(
+          a_ptr,
+          b_ptr,
+          out_ptr,
+          dim,
+          a.size(),
+          new_shape,
+          a_strides,
+          b_strides,
+          strides);
+      break;
+  }
+}
+
+template <typename T, typename Op>
+void binary_op(const array& a, const array& b, array& out, BinaryOpType bopt) {
+  binary_op<T, T, Op>(a, b, out, bopt);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..d50751ce3da828051a4936b2193f20e90b5c6089
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_ops.h
@@ -0,0 +1,98 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cpu/simd/simd.h"
+
+namespace mlx::core::detail {
+
+using namespace mlx::core::simd;
+
+#define BINARY_SINGLE()                                 \
+  template <typename T>                                 \
+  T operator()(T x, T y) {                              \
+    return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value; \
+  }
+
+#define DEFAULT_BINARY_OP(Op, op)                       \
+  struct Op {                                           \
+    template <int N, typename T>                        \
+    Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) { \
+      return op(x, y);                                  \
+    }                                                   \
+    BINARY_SINGLE()                                     \
+  };
+
+DEFAULT_BINARY_OP(Add, operator+)
+DEFAULT_BINARY_OP(ArcTan2, atan2)
+DEFAULT_BINARY_OP(Divide, operator/)
+DEFAULT_BINARY_OP(Multiply, operator*)
+DEFAULT_BINARY_OP(Subtract, operator-)
+DEFAULT_BINARY_OP(LogicalAnd, operator&&)
+DEFAULT_BINARY_OP(LogicalOr, operator||)
+DEFAULT_BINARY_OP(BitwiseAnd, operator&)
+DEFAULT_BINARY_OP(BitwiseOr, operator|)
+DEFAULT_BINARY_OP(BitwiseXor, operator^)
+DEFAULT_BINARY_OP(LeftShift, operator<<)
+DEFAULT_BINARY_OP(RightShift, operator>>)
+DEFAULT_BINARY_OP(Remainder, remainder)
+DEFAULT_BINARY_OP(Maximum, maximum)
+DEFAULT_BINARY_OP(Minimum, minimum)
+DEFAULT_BINARY_OP(Power, pow)
+
+#define DEFAULT_BOOL_OP(Op, op)                            \
+  struct Op {                                              \
+    template <int N, typename T>                           \
+    Simd<bool, N> operator()(Simd<T, N> x, Simd<T, N> y) { \
+      return op(x, y);                                     \
+    }                                                      \
+    template <typename T>                                  \
+    bool operator()(T x, T y) {                            \
+      return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value;  \
+    }                                                      \
+  };
+
+DEFAULT_BOOL_OP(Equal, operator==)
+DEFAULT_BOOL_OP(Greater, operator>)
+DEFAULT_BOOL_OP(GreaterEqual, operator>=)
+DEFAULT_BOOL_OP(Less, operator<)
+DEFAULT_BOOL_OP(LessEqual, operator<=)
+DEFAULT_BOOL_OP(NotEqual, operator!=)
+
+struct NaNEqual {
+  template <int N, typename T>
+  Simd<bool, N> operator()(Simd<T, N> x, Simd<T, N> y) {
+    return x == y || (isnan(x) && isnan(y));
+  }
+  template <typename T>
+  bool operator()(T x, T y) {
+    return (*this)(Simd<T, 1>(x), Simd<T, 1>(y)).value;
+  }
+};
+
+struct LogAddExp {
+  template <int N, typename T>
+  Simd<T, N> operator()(Simd<T, N> x, Simd<T, N> y) {
+    auto maxval = maximum(x, y);
+    auto minval = minimum(x, y);
+    auto mask = minval == -inf || maxval == inf;
+    auto out = maxval + log1p(exp(minval - maxval));
+    return select(mask, Simd<T, N>(maxval), Simd<T, N>(out));
+  }
+  BINARY_SINGLE()
+};
+
+struct Select {
+  template <typename T>
+  T operator()(bool condition, T x, T y) {
+    return (*this)(Simd<bool, 1>(condition), Simd<T, 1>(x), Simd<T, 1>(y))
+        .value;
+  }
+
+  template <int N, typename T>
+  Simd<T, N> operator()(Simd<bool, N> condition, Simd<T, N> x, Simd<T, N> y) {
+    return select(condition, x, y);
+  }
+};
+
+} // namespace mlx::core::detail
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_two.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_two.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa0ca7996e16950537176c6147b71c069284ef8c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/binary_two.h
@@ -0,0 +1,166 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/binary.h"
+
+namespace mlx::core {
+
+namespace {
+
+template <typename T, typename U, typename Op, int D>
+void binary_op_dims(
+    const T* a,
+    const T* b,
+    U* out_a,
+    U* out_b,
+    Op op,
+    const Shape& shape,
+    const Strides& a_strides,
+    const Strides& b_strides,
+    const Strides& out_strides,
+    int axis) {
+  auto stride_a = a_strides[axis];
+  auto stride_b = b_strides[axis];
+  auto stride_out = out_strides[axis];
+  auto N = shape[axis];
+
+  for (int i = 0; i < N; i++) {
+    if constexpr (D > 1) {
+      binary_op_dims<T, U, Op, D - 1>(
+          a,
+          b,
+          out_a,
+          out_b,
+          op,
+          shape,
+          a_strides,
+          b_strides,
+          out_strides,
+          axis + 1);
+    } else {
+      std::tie(*out_a, *out_b) = op(*a, *b);
+    }
+    a += stride_a;
+    b += stride_b;
+    out_a += stride_out;
+    out_b += stride_out;
+  }
+}
+
+template <typename T, typename U, typename Op>
+void binary_op_dispatch_dims(
+    const array& a,
+    const array& b,
+    array& out_a,
+    array& out_b,
+    Op op) {
+  auto [shape, strides] = collapse_contiguous_dims(
+      a.shape(), {a.strides(), b.strides(), out_a.strides()});
+  const T* a_ptr = a.data<T>();
+  const T* b_ptr = b.data<T>();
+  U* out_a_ptr = out_a.data<U>();
+  U* out_b_ptr = out_b.data<U>();
+
+  const auto& a_strides = strides[0];
+  const auto& b_strides = strides[1];
+  const auto& out_strides = strides[2];
+  int ndim = shape.size();
+  switch (ndim) {
+    case 1:
+      binary_op_dims<T, U, Op, 1>(
+          a_ptr,
+          b_ptr,
+          out_a_ptr,
+          out_b_ptr,
+          op,
+          shape,
+          a_strides,
+          b_strides,
+          out_strides,
+          0);
+      return;
+    case 2:
+      binary_op_dims<T, U, Op, 2>(
+          a_ptr,
+          b_ptr,
+          out_a_ptr,
+          out_b_ptr,
+          op,
+          shape,
+          a_strides,
+          b_strides,
+          out_strides,
+          0);
+      return;
+  }
+
+  ContiguousIterator a_it(shape, a_strides, ndim - 2);
+  ContiguousIterator b_it(shape, b_strides, ndim - 2);
+  auto stride = out_strides[ndim - 3];
+  for (size_t elem = 0; elem < a.size(); elem += stride) {
+    binary_op_dims<T, U, Op, 2>(
+        a_ptr + a_it.loc,
+        b_ptr + b_it.loc,
+        out_a_ptr + elem,
+        out_b_ptr + elem,
+        op,
+        shape,
+        a_strides,
+        b_strides,
+        out_strides,
+        ndim - 2);
+    a_it.step();
+    b_it.step();
+  }
+}
+
+template <typename T, typename U = T, typename Op>
+void binary_op(
+    const array& a,
+    const array& b,
+    array& out_a,
+    array& out_b,
+    Op op,
+    BinaryOpType bopt) {
+  // The full computation is scalar scalar so call the base op once
+  if (bopt == BinaryOpType::General) {
+    binary_op_dispatch_dims<T, U, Op>(a, b, out_a, out_b, op);
+    return;
+  }
+
+  auto a_ptr = a.data<T>();
+  auto b_ptr = b.data<T>();
+  auto out_a_ptr = out_a.data<U>();
+  auto out_b_ptr = out_b.data<U>();
+  if (bopt == BinaryOpType::ScalarScalar) {
+    std::tie(*out_a_ptr, *out_b_ptr) = op(*a_ptr, *b_ptr);
+  } else if (bopt == BinaryOpType::ScalarVector) {
+    for (size_t i = 0; i < b.data_size(); ++i) {
+      std::tie(*out_a_ptr, *out_b_ptr) = op(*a_ptr, *b_ptr);
+      out_a_ptr++;
+      out_b_ptr++;
+      b_ptr++;
+    }
+  } else if (bopt == BinaryOpType::VectorScalar) {
+    for (size_t i = 0; i < a.data_size(); ++i) {
+      std::tie(*out_a_ptr, *out_b_ptr) = op(*a_ptr, *b_ptr);
+      out_a_ptr++;
+      out_b_ptr++;
+      a_ptr++;
+    }
+  } else { // VectorVector
+    for (size_t i = 0; i < a.size(); ++i) {
+      std::tie(*out_a_ptr, *out_b_ptr) = op(*a_ptr, *b_ptr);
+      out_a_ptr++;
+      out_b_ptr++;
+      a_ptr++;
+      b_ptr++;
+    }
+  }
+}
+
+} // namespace
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3c5bbbc93d1b09a8487653ad86e337e2881cff7a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/cholesky.cpp
@@ -0,0 +1,85 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/allocator.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/lapack.h"
+#include "mlx/linalg.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+template <typename T>
+void cholesky_impl(const array& a, array& factor, bool upper, Stream stream) {
+  // Lapack uses the column-major convention. We take advantage of the fact that
+  // the matrix should be symmetric:
+  //   (A)ᵀ = A
+  // and that a column-major lower triangular matrix is a row-major upper
+  // triangular matrix, so uplo is the opposite of what we would expect from
+  // upper
+
+  // The decomposition is computed in place, so just copy the input to the
+  // output.
+  copy_cpu(
+      a,
+      factor,
+      a.flags().row_contiguous ? CopyType::Vector : CopyType::General,
+      stream);
+
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_output_array(factor);
+  encoder.dispatch([matrix = factor.data<T>(),
+                    upper,
+                    N = a.shape(-1),
+                    size = a.size()]() mutable {
+    char uplo = (upper) ? 'L' : 'U';
+    size_t num_matrices = size / (N * N);
+    for (int i = 0; i < num_matrices; i++) {
+      // Compute Cholesky factorization.
+      int info;
+      potrf<T>(
+          /* uplo = */ &uplo,
+          /* n = */ &N,
+          /* a = */ matrix,
+          /* lda = */ &N,
+          /* info = */ &info);
+
+      // TODO: We do nothing when the matrix is not positive semi-definite
+      // because throwing an error would result in a crash. If we figure out how
+      // to catch errors from the implementation we should throw.
+      if (info < 0) {
+        std::stringstream msg;
+        msg << "[Cholesky::eval_cpu] Cholesky decomposition failed with error code "
+            << info;
+        throw std::runtime_error(msg.str());
+      }
+
+      // Zero out the upper/lower triangle while advancing the pointer to the
+      // next matrix at the same time.
+      for (int row = 0; row < N; row++) {
+        if (upper) {
+          std::fill(matrix, matrix + row, 0);
+        } else {
+          std::fill(matrix + row + 1, matrix + N, 0);
+        }
+        matrix += N;
+      }
+    }
+  });
+}
+
+void Cholesky::eval_cpu(const std::vector<array>& inputs, array& output) {
+  switch (inputs[0].dtype()) {
+    case float32:
+      cholesky_impl<float>(inputs[0], output, upper_, stream());
+      break;
+    case float64:
+      cholesky_impl<double>(inputs[0], output, upper_, stream());
+      break;
+    default:
+      throw std::runtime_error(
+          "[Cholesky::eval_cpu] only supports float32 or float64.");
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..53d6c47e3e4aaa2e8a99fa4be95265ec1191c1be
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled.cpp
@@ -0,0 +1,355 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <dlfcn.h>
+#include <filesystem>
+#include <fstream>
+#include <list>
+#include <mutex>
+#include <shared_mutex>
+
+#include <fmt/format.h>
+
+#include "mlx/backend/common/compiled.h"
+#include "mlx/backend/cpu/compiled_preamble.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/jit_compiler.h"
+#include "mlx/device.h"
+#include "mlx/graph_utils.h"
+#include "mlx/version.h"
+
+namespace mlx::core {
+
+struct CompilerCache {
+  struct DLib {
+    DLib(const std::string& libname) {
+      lib = dlopen(libname.c_str(), RTLD_NOW);
+      if (!lib) {
+        std::ostringstream msg;
+        msg << "Could not load C++ shared library " << dlerror();
+        throw std::runtime_error(msg.str());
+      }
+    }
+
+    ~DLib() {
+      dlclose(lib);
+    }
+    void* lib;
+  };
+  // Statics to cache compiled libraries and functions
+  std::list<DLib> libs;
+  std::unordered_map<std::string, void*> kernels;
+  std::shared_mutex mtx;
+};
+
+static CompilerCache& cache() {
+  static CompilerCache cache_;
+  return cache_;
+};
+
+// GPU compile is always available if the GPU is available and since we are in
+// this file CPU compile is also available.
+namespace detail {
+bool compile_available_for_device(const Device& device) {
+  return true;
+}
+
+} // namespace detail
+
+// Return a pointer to a compiled function
+void* compile(
+    const std::string& kernel_name,
+    const std::function<std::string(void)>& source_builder) {
+  {
+    std::shared_lock lock(cache().mtx);
+    if (auto it = cache().kernels.find(kernel_name);
+        it != cache().kernels.end()) {
+      return it->second;
+    }
+  }
+
+  std::unique_lock lock(cache().mtx);
+  if (auto it = cache().kernels.find(kernel_name);
+      it != cache().kernels.end()) {
+    return it->second;
+  }
+  std::string source_code = source_builder();
+  std::string kernel_file_name;
+
+  // Deal with long kernel names. Maximum length for filename on macOS is 255
+  // characters, and on Windows the maximum length for whole path is 260. Clip
+  // file name with a little extra room and append a 16 character hash.
+#ifdef _WIN32
+  constexpr int max_file_name_length = 140;
+#else
+  constexpr int max_file_name_length = 245;
+#endif
+  if (kernel_name.size() > max_file_name_length) {
+    std::ostringstream file_name;
+    file_name
+        << std::string_view(kernel_name).substr(0, max_file_name_length - 16);
+    auto file_id =
+        std::hash<std::string>{}(kernel_name.substr(max_file_name_length - 16));
+    file_name << "_" << std::hex << std::setw(16) << file_id << std::dec;
+    kernel_file_name = file_name.str();
+  } else {
+    kernel_file_name = kernel_name;
+  }
+
+  auto output_dir =
+      std::filesystem::temp_directory_path() / "mlx" / version() / "cpu";
+  if (!std::filesystem::exists(output_dir)) {
+    std::filesystem::create_directories(output_dir);
+  }
+
+  std::string shared_lib_name = "lib" + kernel_file_name + ".so";
+  auto shared_lib_path = (output_dir / shared_lib_name).string();
+  bool lib_exists = false;
+  {
+    std::ifstream f(shared_lib_path.c_str());
+    lib_exists = f.good();
+  }
+
+  if (!lib_exists) {
+    // Open source file and write source code to it
+    std::string source_file_name = kernel_file_name + ".cpp";
+    auto source_file_path = (output_dir / source_file_name).string();
+
+    std::ofstream source_file(source_file_path);
+    source_file << source_code;
+    source_file.close();
+
+    try {
+      JitCompiler::exec(JitCompiler::build_command(
+          output_dir, source_file_name, shared_lib_name));
+    } catch (const std::exception& error) {
+      throw std::runtime_error(fmt::format(
+          "[Compile::eval_cpu] Failed to compile function {0}: {1}",
+          kernel_name,
+          error.what()));
+    }
+  }
+
+  // load library
+  cache().libs.emplace_back(shared_lib_path);
+
+  // Load function
+  void* fun = dlsym(cache().libs.back().lib, kernel_name.c_str());
+  if (!fun) {
+    std::ostringstream msg;
+    msg << "[Compile::eval_cpu] Failed to load compiled function "
+        << kernel_name << std::endl
+        << dlerror();
+    throw std::runtime_error(msg.str());
+  }
+  cache().kernels.insert({kernel_name, fun});
+  return fun;
+}
+
+inline void build_kernel(
+    std::ostream& os,
+    const std::string& kernel_name,
+    const std::vector<array>& inputs,
+    const std::vector<array>& outputs,
+    const std::vector<array>& tape,
+    const std::function<bool(size_t)>& is_constant,
+    bool contiguous,
+    int ndim) {
+  NodeNamer namer;
+
+#ifdef _MSC_VER
+  // Export the symbol
+  os << "__declspec(dllexport) ";
+#endif
+
+  // Start the kernel
+  os << "void " << kernel_name
+     << "(int* shape, int64_t** strides, void** args) {" << std::endl;
+
+  // Add the input arguments
+  int cnt = 0;
+  int strides_index = 1;
+  for (size_t i = 0; i < inputs.size(); ++i) {
+    // Skip constants from the input list
+    if (is_constant(i)) {
+      continue;
+    }
+
+    const auto& x = inputs[i];
+    auto& xname = namer.get_name(x);
+
+    auto tstr = get_type_string(x.dtype());
+    os << "  " << tstr << "* " << xname << " = (" << tstr << "*)args[" << cnt++
+       << "];" << std::endl;
+    // Scalars and contiguous need no strides
+    if (!is_scalar(x) && !contiguous) {
+      os << "  const int64_t* " << xname << "_strides = strides["
+         << strides_index++ << "];" << std::endl;
+    }
+  }
+
+  // Add the output arguments
+  for (auto& x : outputs) {
+    auto tstr = get_type_string(x.dtype());
+    os << "  " << tstr << "* " << namer.get_name(x) << " = (" << tstr
+       << "*)args[" << cnt++ << "];" << std::endl;
+  }
+  // Add output size
+  if (contiguous) {
+    os << "  const size_t size = (size_t)args[" << cnt++ << "];" << std::endl;
+  }
+
+  if (contiguous) {
+    os << "  for (size_t i = 0; i < size; ++i) {" << std::endl;
+  } else {
+    for (int d = 0; d < ndim; ++d) {
+      os << "  for (int i" << d << " = 0; i" << d << " < shape[" << d
+         << "]; ++i" << d << ") {" << std::endl;
+    }
+  }
+
+  // Read the inputs in tmps
+  for (size_t i = 0; i < inputs.size(); ++i) {
+    const auto& x = inputs[i];
+    auto& xname = namer.get_name(x);
+
+    if (is_constant(i)) {
+      os << "  " << get_type_string(x.dtype()) << " tmp_" << xname << " = ";
+      print_constant(os, x);
+      os << ";" << std::endl;
+    } else if (is_scalar(x)) {
+      os << "  " << get_type_string(x.dtype()) << " tmp_" << xname << " = "
+         << xname << "[0];" << std::endl;
+    } else if (contiguous) {
+      os << "  " << get_type_string(x.dtype()) << " tmp_" << xname << " = "
+         << xname << "[i];" << std::endl;
+    } else {
+      os << "  " << get_type_string(x.dtype()) << " tmp_" << xname << " = *"
+         << xname << ";" << std::endl;
+    }
+  }
+
+  // Actually write the computation
+  for (auto& x : tape) {
+    os << "  " << get_type_string(x.dtype()) << " tmp_" << namer.get_name(x)
+       << " = ";
+    if (is_static_cast(x.primitive())) {
+      os << "static_cast<" << get_type_string(x.dtype()) << ">(tmp_"
+         << namer.get_name(x.inputs()[0]) << ");" << std::endl;
+    } else {
+      os << x.primitive().name();
+      os << "()(";
+      for (int i = 0; i < x.inputs().size() - 1; i++) {
+        os << "tmp_" << namer.get_name(x.inputs()[i]) << ", ";
+      }
+      os << "tmp_" << namer.get_name(x.inputs().back()) << ");" << std::endl;
+    }
+  }
+
+  // Write the outputs from tmps
+  for (auto& x : outputs) {
+    if (contiguous) {
+      os << "  " << namer.get_name(x) << "[i] = tmp_" << namer.get_name(x)
+         << ";" << std::endl;
+    } else {
+      os << "  *" << namer.get_name(x) << "++ = tmp_" << namer.get_name(x)
+         << ";" << std::endl;
+    }
+  }
+
+  // Close loops
+  if (contiguous) {
+    os << "  }" << std::endl;
+  } else {
+    for (int d = ndim - 1; d >= 0; --d) {
+      // Update pointers
+      for (size_t i = 0; i < inputs.size(); ++i) {
+        const auto& x = inputs[i];
+        if (is_constant(i) || is_scalar(x)) {
+          continue;
+        }
+        auto& xname = namer.get_name(x);
+        os << "  " << xname << " += " << xname << "_strides[" << d << "];"
+           << std::endl;
+        if (d < ndim - 1) {
+          os << "  " << xname << " -= " << xname << "_strides[" << d + 1 << "]"
+             << " * shape[" << d + 1 << "];" << std::endl;
+        }
+      }
+      os << "  }" << std::endl;
+    }
+  }
+
+  // Finish the kernel
+  os << "}" << std::endl;
+}
+
+void Compiled::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  auto& encoder = cpu::get_command_encoder(stream());
+
+  // Collapse contiguous dims to route to a faster kernel if possible. Also
+  // handle all broadcasting.
+  auto [contiguous, shape, strides] =
+      compiled_collapse_contiguous_dims(inputs, outputs[0], is_constant_);
+
+  // Collect function input arguments.
+  std::vector<void*> args;
+  for (size_t i = 0; i < inputs.size(); ++i) {
+    if (is_constant_(i)) {
+      continue;
+    }
+    const auto& x = inputs[i];
+    encoder.set_input_array(x);
+    args.push_back((void*)x.data<void>());
+  }
+
+  // Get the kernel name from the lib
+  int ndim = shape.size();
+  auto kernel_name = kernel_lib_ + (contiguous ? "_contiguous" : "_strided_");
+  if (!contiguous) {
+    kernel_name += std::to_string(ndim);
+  }
+
+  // Get the function
+  auto fn_ptr = compile(kernel_name, [&, contiguous = contiguous]() {
+    std::ostringstream kernel;
+    kernel << get_kernel_preamble() << std::endl;
+    kernel << "extern \"C\"  {" << std::endl;
+    build_kernel(
+        kernel,
+        kernel_name,
+        inputs_,
+        outputs_,
+        tape_,
+        is_constant_,
+        contiguous,
+        ndim);
+    // Close extern "C"
+    kernel << "}" << std::endl;
+    return kernel.str();
+  });
+
+  compiled_allocate_outputs(inputs, outputs, is_constant_, contiguous);
+
+  for (auto& x : outputs) {
+    args.push_back(x.data<void>());
+    encoder.set_output_array(x);
+  }
+  if (contiguous) {
+    args.push_back((void*)outputs[0].data_size());
+  }
+  auto fun = reinterpret_cast<void (*)(int*, int64_t**, void**)>(fn_ptr);
+  encoder.dispatch([fun,
+                    args = std::move(args),
+                    strides = std::move(strides),
+                    shape = std::move(shape)]() mutable {
+    SmallVector<int64_t*> strides_ptrs;
+    for (auto& s : strides) {
+      strides_ptrs.push_back(s.data());
+    }
+    fun(shape.data(), strides_ptrs.data(), args.data());
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled_preamble.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled_preamble.h
new file mode 100644
index 0000000000000000000000000000000000000000..31ca1b46851b81b7ecbdbe7811f064ce984b2163
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/compiled_preamble.h
@@ -0,0 +1,12 @@
+// Copyright © 2023-24 Apple Inc.
+
+#pragma once
+
+// clang-format off
+#include "mlx/types/half_types.h"
+#include "mlx/types/complex.h"
+#include "mlx/backend/cpu/unary_ops.h"
+#include "mlx/backend/cpu/binary_ops.h"
+// clang-format on
+
+const char* get_kernel_preamble();
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5684f9709d810f979b2973c227356f3766a0202d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/conv.cpp
@@ -0,0 +1,1476 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <cassert>
+#include <numeric>
+
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/lapack.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+namespace {
+
+///////////////////////////////////////////////////////////////////////////////
+// Naive reference conv
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+void slow_conv_1D(
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding_lo,
+    const std::vector<int>& padding_hi,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    const std::vector<int>& in_dilation,
+    bool flip,
+    Stream stream) {
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(in);
+  encoder.set_input_array(wt);
+  encoder.set_output_array(out);
+
+  encoder.dispatch([start_wt_ptr = wt.data<T>(),
+                    in_ptr = in.data<T>(),
+                    out_ptr = out.data<T>(),
+
+                    N = in.shape(
+                        0), // Batch size, should be the same as out.shape(0)
+                    iH = 1 +
+                        in_dilation[0] * (in.shape(1) - 1), // Input spatial dim
+                    oH = out.shape(1), // Output spatial dim
+                    wH = wt.shape(1), // Weight spatial dim
+                    groups = in.shape(2) / wt.shape(2),
+                    O = wt.shape(0), // Out channels
+                    C_per_group = wt.shape(2),
+
+                    in_stride_N = in.strides()[0],
+                    in_stride_H = in.strides()[1],
+                    in_stride_C = in.strides()[2],
+
+                    wt_stride_O = wt.strides()[0],
+                    wt_stride_H = wt.strides()[1],
+                    wt_stride_C = wt.strides()[2],
+
+                    out_stride_N = out.strides()[0],
+                    out_stride_H = out.strides()[1],
+                    out_stride_O = out.strides()[2],
+
+                    flip,
+                    padding_lo = padding_lo[0],
+                    padding_hi = padding_hi[0],
+                    wt_stride = wt_strides[0],
+                    wt_dilation = wt_dilation[0],
+                    in_dilation = in_dilation[0]]() mutable {
+    auto O_per_group = O / groups;
+
+    for (int n = 0; n < N; ++n) {
+      for (int oh = 0; oh < oH; ++oh) {
+        for (int g = 0; g < groups; ++g) {
+          for (int o = g * O_per_group; o < (g + 1) * O_per_group; ++o) {
+            const T* filter_wt_ptr = start_wt_ptr + o * wt_stride_O;
+            float r = 0.;
+
+            for (int wh = 0; wh < wH; ++wh) {
+              const T* wt_ptr = filter_wt_ptr + wh * wt_stride_H;
+
+              int wh_flip = flip ? (wH - wh - 1) : wh;
+              int ih = oh * wt_stride - padding_lo + wh_flip * wt_dilation;
+
+              auto ih_div = std::div(ih, in_dilation);
+
+              if (ih >= 0 && ih < iH && ih_div.rem == 0) {
+                for (int c = g * C_per_group; c < (g + 1) * C_per_group; ++c) {
+                  r +=
+                      static_cast<float>(
+                          in_ptr[ih_div.quot * in_stride_H + c * in_stride_C]) *
+                      static_cast<float>(
+                          wt_ptr[(c % C_per_group) * wt_stride_C]);
+                } // c
+
+              } // ih check
+            } // wh
+
+            out_ptr[oh * out_stride_H + o * out_stride_O] = static_cast<T>(r);
+          } // o
+        } // g
+      } // oh
+
+      in_ptr += in_stride_N;
+      out_ptr += out_stride_N;
+    } // n
+  });
+}
+
+template <typename T>
+void slow_conv_2D(
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding_lo,
+    const std::vector<int>& padding_hi,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    const std::vector<int>& in_dilation,
+    bool flip,
+    Stream stream) {
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(in);
+  encoder.set_input_array(wt);
+  encoder.set_output_array(out);
+
+  encoder.dispatch(
+      [st_wt_ptr = wt.data<T>(),
+       st_in_ptr = in.data<T>(),
+       st_out_ptr = out.data<T>(),
+
+       N = in.shape(0), // Batch size, should be the same as out.shape(0)
+       iH = 1 + in_dilation[0] * (in.shape(1) - 1), // Input spatial dim
+       iW = 1 + in_dilation[1] * (in.shape(2) - 1), // Input spatial dim
+       C = in.shape(3), // In channels
+       oH = out.shape(1), // Output spatial dim
+       oW = out.shape(2), // Output spatial dim
+       O = wt.shape(0), // Out channels
+       wH = wt.shape(1), // Weight spatial dim
+       wW = wt.shape(2), // Weight spatial dim
+
+       groups = in.shape(3) / wt.shape(3),
+       C_per_group = wt.shape(3),
+
+       in_stride_N = in.strides()[0],
+       in_stride_H = in.strides()[1],
+       in_stride_W = in.strides()[2],
+       in_stride_C = in.strides()[3],
+
+       wt_stride_O = wt.strides()[0],
+       wt_stride_H = wt.strides()[1],
+       wt_stride_W = wt.strides()[2],
+       wt_stride_C = wt.strides()[3],
+
+       out_stride_N = out.strides()[0],
+       out_stride_H = out.strides()[1],
+       out_stride_W = out.strides()[2],
+       out_stride_O = out.strides()[3],
+
+       padding_lo,
+       padding_hi,
+       wt_strides,
+       wt_dilation,
+       in_dilation,
+       flip]() mutable {
+        bool is_idil_one = in_dilation[0] == 1 && in_dilation[1] == 1;
+
+        const int O_per_group = O / groups;
+        auto pt_conv_no_checks =
+            [&](const T* in_ptr, const T* wt_ptr, T* out_ptr, int oh, int ow) {
+              out_ptr += oh * out_stride_H + ow * out_stride_W;
+              int ih_base = oh * wt_strides[0] - padding_lo[0];
+              int iw_base = ow * wt_strides[1] - padding_lo[1];
+
+              for (int g = 0; g < groups; ++g) {
+                for (int o = g * O_per_group; o < (g + 1) * O_per_group; ++o) {
+                  float r = 0.;
+
+                  for (int wh = 0; wh < wH; ++wh) {
+                    for (int ww = 0; ww < wW; ++ww) {
+                      int wh_flip = flip ? wH - wh - 1 : wh;
+                      int ww_flip = flip ? wW - ww - 1 : ww;
+                      int ih = ih_base + wh_flip * wt_dilation[0];
+                      int iw = iw_base + ww_flip * wt_dilation[1];
+
+                      const T* wt_ptr_pt =
+                          wt_ptr + wh * wt_stride_H + ww * wt_stride_W;
+                      const T* in_ptr_pt =
+                          in_ptr + ih * in_stride_H + iw * in_stride_W;
+
+                      for (int c = g * C_per_group; c < (g + 1) * C_per_group;
+                           ++c) {
+                        r += static_cast<float>(in_ptr_pt[c * in_stride_C]) *
+                            static_cast<float>(
+                                 wt_ptr_pt[(c % C_per_group) * wt_stride_C]);
+                      } // c
+                    } // ww
+                  } // wh
+
+                  out_ptr[0] = static_cast<T>(r);
+                  out_ptr += out_stride_O;
+                  wt_ptr += wt_stride_O;
+                } // o
+              } // g
+            };
+
+        int jump_h = flip ? -wt_dilation[0] : wt_dilation[0];
+        int jump_w = flip ? -wt_dilation[1] : wt_dilation[1];
+
+        int init_h = (flip ? (wH - 1) * wt_dilation[0] : 0);
+        int init_w = (flip ? (wW - 1) * wt_dilation[1] : 0);
+
+        int f_wgt_jump_h =
+            std::lcm(in_dilation[0], wt_dilation[0]) / wt_dilation[0];
+        int f_wgt_jump_w =
+            std::lcm(in_dilation[1], wt_dilation[1]) / wt_dilation[1];
+
+        int f_out_jump_h =
+            std::lcm(in_dilation[0], wt_strides[0]) / wt_strides[0];
+        int f_out_jump_w =
+            std::lcm(in_dilation[1], wt_strides[1]) / wt_strides[1];
+
+        std::vector<int> base_h(f_out_jump_h);
+        std::vector<int> base_w(f_out_jump_w);
+
+        for (int i = 0; i < f_out_jump_h; ++i) {
+          int ih_loop = i * wt_strides[0] - padding_lo[0] + init_h;
+
+          int wh_base = 0;
+          while (wh_base < wH && ih_loop % in_dilation[0] != 0) {
+            wh_base++;
+            ih_loop += jump_h;
+          }
+
+          base_h[i] = wh_base;
+        }
+
+        for (int j = 0; j < f_out_jump_w; ++j) {
+          int iw_loop = j * wt_strides[1] - padding_lo[1] + init_w;
+
+          int ww_base = 0;
+          while (ww_base < wW && iw_loop % in_dilation[1] != 0) {
+            ww_base++;
+            iw_loop += jump_w;
+          }
+
+          base_w[j] = ww_base;
+        }
+
+        auto pt_conv_all_checks =
+            [&](const T* in_ptr, const T* wt_ptr, T* out_ptr, int oh, int ow) {
+              out_ptr += oh * out_stride_H + ow * out_stride_W;
+
+              int ih_base = oh * wt_strides[0] - padding_lo[0];
+              int iw_base = ow * wt_strides[1] - padding_lo[1];
+
+              int wh_base = base_h[oh % f_out_jump_h];
+              int ww_base = base_w[ow % f_out_jump_w];
+
+              for (int g = 0; g < groups; ++g) {
+                for (int o = g * O_per_group; o < (g + 1) * O_per_group; ++o) {
+                  float r = 0.;
+
+                  for (int wh = wh_base; wh < wH; wh += f_wgt_jump_h) {
+                    for (int ww = ww_base; ww < wW; ww += f_wgt_jump_w) {
+                      int wh_flip = flip ? wH - wh - 1 : wh;
+                      int ww_flip = flip ? wW - ww - 1 : ww;
+                      int ih = ih_base + wh_flip * wt_dilation[0];
+                      int iw = iw_base + ww_flip * wt_dilation[1];
+
+                      if (ih >= 0 && ih < iH && iw >= 0 && iw < iW) {
+                        const T* wt_ptr_pt =
+                            wt_ptr + wh * wt_stride_H + ww * wt_stride_W;
+
+                        int ih_dil = !is_idil_one ? (ih / in_dilation[0]) : ih;
+                        int iw_dil = !is_idil_one ? (iw / in_dilation[1]) : iw;
+
+                        const T* in_ptr_pt = in_ptr + ih_dil * in_stride_H +
+                            iw_dil * in_stride_W;
+
+                        for (int c = g * C_per_group; c < (g + 1) * C_per_group;
+                             ++c) {
+                          r += static_cast<float>(in_ptr_pt[c * in_stride_C]) *
+                              static_cast<float>(
+                                   wt_ptr_pt[(c % C_per_group) * wt_stride_C]);
+                        } // c
+
+                      } // ih, iw check
+                    } // ww
+                  } // wh
+
+                  out_ptr[0] = static_cast<T>(r);
+                  out_ptr += out_stride_O;
+                  wt_ptr += wt_stride_O;
+                } // o
+              } // g
+            };
+
+        int oH_border_0 = 0;
+        int oH_border_1 = is_idil_one
+            ? ((padding_lo[0] + wt_strides[0] - 1) / wt_strides[0])
+            : oH;
+        int oH_border_2 = std::max(
+            oH_border_1,
+            (iH + padding_lo[0] - wH * wt_dilation[0]) / wt_strides[0]);
+        int oH_border_3 = oH;
+
+        int oW_border_0 = 0;
+        int oW_border_1 = is_idil_one
+            ? ((padding_lo[1] + wt_strides[1] - 1) / wt_strides[1])
+            : oW;
+        int oW_border_2 = std::max(
+            oW_border_1,
+            (iW + padding_lo[1] - wW * wt_dilation[1]) / wt_strides[1]);
+        int oW_border_3 = oW;
+
+        for (int n = 0; n < N; ++n) {
+          // Case 1: oh might put us out of bounds
+          for (int oh = oH_border_0; oh < oH_border_1; ++oh) {
+            for (int ow = 0; ow < oW; ++ow) {
+              pt_conv_all_checks(st_in_ptr, st_wt_ptr, st_out_ptr, oh, ow);
+            } // ow
+          } // oh
+
+          // Case 2: oh in bounds
+          for (int oh = oH_border_1; oh < oH_border_2; ++oh) {
+            // Case a: ow might put us out of bounds
+            for (int ow = oW_border_0; ow < oW_border_1; ++ow) {
+              pt_conv_all_checks(st_in_ptr, st_wt_ptr, st_out_ptr, oh, ow);
+            } // ow
+
+            // Case b: ow in bounds
+            for (int ow = oW_border_1; ow < oW_border_2; ++ow) {
+              pt_conv_no_checks(st_in_ptr, st_wt_ptr, st_out_ptr, oh, ow);
+            } // ow
+
+            // Case c: ow might put us out of bounds
+            for (int ow = oW_border_2; ow < oW_border_3; ++ow) {
+              pt_conv_all_checks(st_in_ptr, st_wt_ptr, st_out_ptr, oh, ow);
+            } // ow
+
+          } // oh
+
+          // Case 3: oh might put us out of bounds
+          for (int oh = oH_border_2; oh < oH_border_3; ++oh) {
+            for (int ow = 0; ow < oW; ++ow) {
+              pt_conv_all_checks(st_in_ptr, st_wt_ptr, st_out_ptr, oh, ow);
+            } // ow
+          } // oh
+
+          st_in_ptr += in_stride_N;
+          st_out_ptr += out_stride_N;
+
+        } // n
+      });
+}
+
+template <typename T>
+void slow_conv_3D(
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding_lo,
+    const std::vector<int>& padding_hi,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    const std::vector<int>& in_dilation,
+    bool flip,
+    Stream stream) {
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(in);
+  encoder.set_input_array(wt);
+  encoder.set_output_array(out);
+
+  encoder.dispatch([st_wt_ptr = wt.data<T>(),
+                    st_in_ptr = in.data<T>(),
+                    st_out_ptr = out.data<T>(),
+
+                    N = in.shape(
+                        0), // Batch size, should be the same as out.shape(0)
+                    iD = 1 +
+                        in_dilation[0] * (in.shape(1) - 1), // Input spatial dim
+                    iH = 1 +
+                        in_dilation[1] * (in.shape(2) - 1), // Input spatial dim
+                    iW = 1 +
+                        in_dilation[2] * (in.shape(3) - 1), // Input spatial dim
+                    oD = out.shape(1), // Output spatial dim
+                    oH = out.shape(2), // Output spatial dim
+                    oW = out.shape(3), // Output spatial dim
+                    O = wt.shape(0), // Out channels
+                    C = wt.shape(4), // In channels
+                    wD = wt.shape(1), // Weight spatial dim
+                    wH = wt.shape(2), // Weight spatial dim
+                    wW = wt.shape(3), // Weight spatial dim
+
+                    in_stride_N = in.strides()[0],
+                    in_stride_D = in.strides()[1],
+                    in_stride_H = in.strides()[2],
+                    in_stride_W = in.strides()[3],
+                    in_stride_C = in.strides()[4],
+
+                    wt_stride_O = wt.strides()[0],
+                    wt_stride_D = wt.strides()[1],
+                    wt_stride_H = wt.strides()[2],
+                    wt_stride_W = wt.strides()[3],
+                    wt_stride_C = wt.strides()[4],
+
+                    out_stride_N = out.strides()[0],
+                    out_stride_D = out.strides()[1],
+                    out_stride_H = out.strides()[2],
+                    out_stride_W = out.strides()[3],
+                    out_stride_O = out.strides()[4],
+                    padding_lo,
+                    padding_hi,
+                    wt_strides,
+                    wt_dilation,
+                    in_dilation,
+                    flip]() mutable {
+    bool is_idil_one =
+        in_dilation[0] == 1 && in_dilation[1] == 1 && in_dilation[2] == 1;
+
+    auto pt_conv_no_checks = [&](const T* in_ptr,
+                                 const T* wt_ptr,
+                                 T* out_ptr,
+                                 int od,
+                                 int oh,
+                                 int ow) {
+      out_ptr += od * out_stride_D + oh * out_stride_H + ow * out_stride_W;
+      int id_base = od * wt_strides[0] - padding_lo[0];
+      int ih_base = oh * wt_strides[1] - padding_lo[1];
+      int iw_base = ow * wt_strides[2] - padding_lo[2];
+
+      for (int o = 0; o < O; ++o) {
+        float r = 0.;
+
+        for (int wd = 0; wd < wD; ++wd) {
+          for (int wh = 0; wh < wH; ++wh) {
+            for (int ww = 0; ww < wW; ++ww) {
+              int wd_flip = flip ? wD - wd - 1 : wd;
+              int wh_flip = flip ? wH - wh - 1 : wh;
+              int ww_flip = flip ? wW - ww - 1 : ww;
+              int id = id_base + wd_flip * wt_dilation[0];
+              int ih = ih_base + wh_flip * wt_dilation[1];
+              int iw = iw_base + ww_flip * wt_dilation[2];
+
+              const T* wt_ptr_pt = wt_ptr + wd * wt_stride_D +
+                  wh * wt_stride_H + ww * wt_stride_W;
+              const T* in_ptr_pt = in_ptr + id * in_stride_D +
+                  ih * in_stride_H + iw * in_stride_W;
+
+              for (int c = 0; c < C; ++c) {
+                r += static_cast<float>(in_ptr_pt[0]) *
+                    static_cast<float>(wt_ptr_pt[0]);
+                in_ptr_pt += in_stride_C;
+                wt_ptr_pt += wt_stride_C;
+              } // c
+
+            } // ww
+          } // wh
+        } // wd
+
+        out_ptr[0] = static_cast<T>(r);
+        out_ptr += out_stride_O;
+        wt_ptr += wt_stride_O;
+      } // o
+    };
+
+    int jump_d = flip ? -wt_dilation[0] : wt_dilation[0];
+    int jump_h = flip ? -wt_dilation[1] : wt_dilation[1];
+    int jump_w = flip ? -wt_dilation[2] : wt_dilation[2];
+
+    int init_d = (flip ? (wD - 1) * wt_dilation[0] : 0);
+    int init_h = (flip ? (wH - 1) * wt_dilation[1] : 0);
+    int init_w = (flip ? (wW - 1) * wt_dilation[2] : 0);
+
+    int f_wgt_jump_d =
+        std::lcm(in_dilation[0], wt_dilation[0]) / wt_dilation[0];
+    int f_wgt_jump_h =
+        std::lcm(in_dilation[1], wt_dilation[1]) / wt_dilation[1];
+    int f_wgt_jump_w =
+        std::lcm(in_dilation[2], wt_dilation[2]) / wt_dilation[2];
+
+    int f_out_jump_d = std::lcm(in_dilation[0], wt_strides[0]) / wt_strides[0];
+    int f_out_jump_h = std::lcm(in_dilation[1], wt_strides[1]) / wt_strides[1];
+    int f_out_jump_w = std::lcm(in_dilation[2], wt_strides[2]) / wt_strides[2];
+
+    std::vector<int> base_d(f_out_jump_d);
+    std::vector<int> base_h(f_out_jump_h);
+    std::vector<int> base_w(f_out_jump_w);
+
+    for (int i = 0; i < f_out_jump_d; ++i) {
+      int id_loop = i * wt_strides[0] - padding_lo[0] + init_d;
+
+      int wd_base = 0;
+      while (wd_base < wD && id_loop % in_dilation[0] != 0) {
+        wd_base++;
+        id_loop += jump_d;
+      }
+
+      base_d[i] = wd_base;
+    }
+
+    for (int i = 0; i < f_out_jump_h; ++i) {
+      int ih_loop = i * wt_strides[1] - padding_lo[1] + init_h;
+
+      int wh_base = 0;
+      while (wh_base < wH && ih_loop % in_dilation[1] != 0) {
+        wh_base++;
+        ih_loop += jump_h;
+      }
+
+      base_h[i] = wh_base;
+    }
+
+    for (int j = 0; j < f_out_jump_w; ++j) {
+      int iw_loop = j * wt_strides[2] - padding_lo[2] + init_w;
+
+      int ww_base = 0;
+      while (ww_base < wW && iw_loop % in_dilation[2] != 0) {
+        ww_base++;
+        iw_loop += jump_w;
+      }
+
+      base_w[j] = ww_base;
+    }
+
+    auto pt_conv_all_checks = [&](const T* in_ptr,
+                                  const T* wt_ptr,
+                                  T* out_ptr,
+                                  int od,
+                                  int oh,
+                                  int ow) {
+      out_ptr += od * out_stride_D + oh * out_stride_H + ow * out_stride_W;
+
+      int id_base = od * wt_strides[0] - padding_lo[0];
+      int ih_base = oh * wt_strides[1] - padding_lo[1];
+      int iw_base = ow * wt_strides[2] - padding_lo[2];
+
+      int wd_base = base_d[od % f_out_jump_d];
+      int wh_base = base_h[oh % f_out_jump_h];
+      int ww_base = base_w[ow % f_out_jump_w];
+
+      for (int o = 0; o < O; ++o) {
+        float r = 0.;
+
+        for (int wd = wd_base; wd < wD; wd += f_wgt_jump_d) {
+          for (int wh = wh_base; wh < wH; wh += f_wgt_jump_h) {
+            for (int ww = ww_base; ww < wW; ww += f_wgt_jump_w) {
+              int wd_flip = flip ? wD - wd - 1 : wd;
+              int wh_flip = flip ? wH - wh - 1 : wh;
+              int ww_flip = flip ? wW - ww - 1 : ww;
+              int id = id_base + wd_flip * wt_dilation[0];
+              int ih = ih_base + wh_flip * wt_dilation[1];
+              int iw = iw_base + ww_flip * wt_dilation[2];
+
+              if (id >= 0 && id < iD && ih >= 0 && ih < iH && iw >= 0 &&
+                  iw < iW) {
+                const T* wt_ptr_pt = wt_ptr + wd * wt_stride_D +
+                    wh * wt_stride_H + ww * wt_stride_W;
+
+                int id_dil = !is_idil_one ? (id / in_dilation[0]) : id;
+                int ih_dil = !is_idil_one ? (ih / in_dilation[1]) : ih;
+                int iw_dil = !is_idil_one ? (iw / in_dilation[2]) : iw;
+
+                const T* in_ptr_pt = in_ptr + id_dil * in_stride_D +
+                    ih_dil * in_stride_H + iw_dil * in_stride_W;
+
+                for (int c = 0; c < C; ++c) {
+                  r += static_cast<float>(in_ptr_pt[0]) *
+                      static_cast<float>(wt_ptr_pt[0]);
+                  in_ptr_pt += in_stride_C;
+                  wt_ptr_pt += wt_stride_C;
+                } // c
+
+              } // iD, ih, iw check
+            } // ww
+          } // wh
+        } // wd
+
+        out_ptr[0] = static_cast<T>(r);
+        out_ptr += out_stride_O;
+        wt_ptr += wt_stride_O;
+      } // o
+    };
+
+    int oD_border_0 = 0;
+    int oD_border_1 = is_idil_one
+        ? ((padding_lo[0] + wt_strides[0] - 1) / wt_strides[0])
+        : oD;
+    int oD_border_2 = std::max(
+        oD_border_1,
+        (iD + padding_lo[0] - wD * wt_dilation[0]) / wt_strides[0]);
+    int oD_border_3 = oD;
+
+    int oH_border_0 = 0;
+    int oH_border_1 = is_idil_one
+        ? ((padding_lo[1] + wt_strides[1] - 1) / wt_strides[1])
+        : oH;
+    int oH_border_2 = std::max(
+        oH_border_1,
+        (iH + padding_lo[1] - wH * wt_dilation[1]) / wt_strides[1]);
+    int oH_border_3 = oH;
+
+    int oW_border_0 = 0;
+    int oW_border_1 = is_idil_one
+        ? ((padding_lo[2] + wt_strides[2] - 1) / wt_strides[2])
+        : oW;
+    int oW_border_2 = std::max(
+        oW_border_1,
+        (iW + padding_lo[2] - wW * wt_dilation[2]) / wt_strides[2]);
+    int oW_border_3 = oW;
+
+    for (int n = 0; n < N; ++n) {
+      // Case 1: od might put us out of bounds
+      for (int od = oD_border_0; od < oD_border_1; ++od) {
+        for (int oh = 0; oh < oH; ++oh) {
+          for (int ow = 0; ow < oW; ++ow) {
+            pt_conv_all_checks(st_in_ptr, st_wt_ptr, st_out_ptr, od, oh, ow);
+          } // ow
+        } // oh
+      } // od
+
+      // Case 2: od in bounds
+      for (int od = oD_border_1; od < oD_border_2; ++od) {
+        // Case 2.1: oh might put us out of bounds
+        for (int oh = oH_border_0; oh < oH_border_1; ++oh) {
+          for (int ow = 0; ow < oW; ++ow) {
+            pt_conv_all_checks(st_in_ptr, st_wt_ptr, st_out_ptr, od, oh, ow);
+          } // ow
+        } // oh
+
+        // Case 2.2: oh in bounds
+        for (int oh = oH_border_1; oh < oH_border_2; ++oh) {
+          // Case 2.2.1: ow might put us out of bounds
+          for (int ow = oW_border_0; ow < oW_border_1; ++ow) {
+            pt_conv_all_checks(st_in_ptr, st_wt_ptr, st_out_ptr, od, oh, ow);
+          } // ow
+
+          // Case 2.2.2: ow in bounds
+          for (int ow = oW_border_1; ow < oW_border_2; ++ow) {
+            pt_conv_no_checks(st_in_ptr, st_wt_ptr, st_out_ptr, od, oh, ow);
+          } // ow
+
+          // Case 2.2.3: ow might put us out of bounds
+          for (int ow = oW_border_2; ow < oW_border_3; ++ow) {
+            pt_conv_all_checks(st_in_ptr, st_wt_ptr, st_out_ptr, od, oh, ow);
+          } // ow
+        } // oh
+
+        // Case 2.3: oh might put us out of bounds
+        for (int oh = oH_border_2; oh < oH_border_3; ++oh) {
+          for (int ow = 0; ow < oW; ++ow) {
+            pt_conv_all_checks(st_in_ptr, st_wt_ptr, st_out_ptr, od, oh, ow);
+          } // ow
+        } // oh
+      } // od
+
+      // Case 3: od might put us out of bounds
+      for (int od = oD_border_2; od < oD_border_3; ++od) {
+        for (int oh = 0; oh < oH; ++oh) {
+          for (int ow = 0; ow < oW; ++ow) {
+            pt_conv_all_checks(st_in_ptr, st_wt_ptr, st_out_ptr, od, oh, ow);
+          } // ow
+        } // oh
+      } // od
+
+      st_in_ptr += in_stride_N;
+      st_out_ptr += out_stride_N;
+
+    } // n
+  });
+}
+
+void dispatch_slow_conv_1D(
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding_lo,
+    const std::vector<int>& padding_hi,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    const std::vector<int>& in_dilation,
+    bool flip,
+    Stream stream) {
+  if (in.dtype() == float32) {
+    return slow_conv_1D<float>(
+        in,
+        wt,
+        out,
+        padding_lo,
+        padding_hi,
+        wt_strides,
+        wt_dilation,
+        in_dilation,
+        flip,
+        stream);
+  } else if (in.dtype() == float16) {
+    return slow_conv_1D<float16_t>(
+        in,
+        wt,
+        out,
+        padding_lo,
+        padding_hi,
+        wt_strides,
+        wt_dilation,
+        in_dilation,
+        flip,
+        stream);
+  } else if (in.dtype() == bfloat16) {
+    return slow_conv_1D<bfloat16_t>(
+        in,
+        wt,
+        out,
+        padding_lo,
+        padding_hi,
+        wt_strides,
+        wt_dilation,
+        in_dilation,
+        flip,
+        stream);
+  } else {
+    throw std::invalid_argument(
+        "[Convolution::eval] got unsupported data type.");
+  }
+}
+
+void dispatch_slow_conv_2D(
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding_lo,
+    const std::vector<int>& padding_hi,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    const std::vector<int>& in_dilation,
+    bool flip,
+    Stream stream) {
+  if (in.dtype() == float32) {
+    return slow_conv_2D<float>(
+        in,
+        wt,
+        out,
+        padding_lo,
+        padding_hi,
+        wt_strides,
+        wt_dilation,
+        in_dilation,
+        flip,
+        stream);
+  } else if (in.dtype() == float16) {
+    return slow_conv_2D<float16_t>(
+        in,
+        wt,
+        out,
+        padding_lo,
+        padding_hi,
+        wt_strides,
+        wt_dilation,
+        in_dilation,
+        flip,
+        stream);
+  } else if (in.dtype() == bfloat16) {
+    return slow_conv_2D<bfloat16_t>(
+        in,
+        wt,
+        out,
+        padding_lo,
+        padding_hi,
+        wt_strides,
+        wt_dilation,
+        in_dilation,
+        flip,
+        stream);
+  } else {
+    throw std::invalid_argument(
+        "[Convolution::eval] got unsupported data type.");
+  }
+}
+
+void dispatch_slow_conv_3D(
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding_lo,
+    const std::vector<int>& padding_hi,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    const std::vector<int>& in_dilation,
+    bool flip,
+    Stream stream) {
+  if (in.dtype() == float32) {
+    return slow_conv_3D<float>(
+        in,
+        wt,
+        out,
+        padding_lo,
+        padding_hi,
+        wt_strides,
+        wt_dilation,
+        in_dilation,
+        flip,
+        stream);
+  } else if (in.dtype() == float16) {
+    return slow_conv_3D<float16_t>(
+        in,
+        wt,
+        out,
+        padding_lo,
+        padding_hi,
+        wt_strides,
+        wt_dilation,
+        in_dilation,
+        flip,
+        stream);
+  } else if (in.dtype() == bfloat16) {
+    return slow_conv_3D<bfloat16_t>(
+        in,
+        wt,
+        out,
+        padding_lo,
+        padding_hi,
+        wt_strides,
+        wt_dilation,
+        in_dilation,
+        flip,
+        stream);
+  } else {
+    throw std::invalid_argument(
+        "[Convolution::eval] got unsupported data type.");
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Explicit gemm conv
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+void flip_spatial_dims_inplace(
+    T* x,
+    size_t in_channels,
+    size_t out_channels,
+    size_t spatial_size) {
+  for (size_t i = 0; i < out_channels; i++) {
+    T* top = x + i * spatial_size * in_channels;
+    T* bottom =
+        x + i * spatial_size * in_channels + (spatial_size - 1) * in_channels;
+    for (size_t j = 0; j < spatial_size / 2; j++) {
+      for (size_t k = 0; k < in_channels; k++) {
+        std::swap(top[k], bottom[k]);
+      }
+      top += in_channels;
+      bottom -= in_channels;
+    }
+  }
+}
+
+void explicit_gemm_conv_1D_cpu(
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding_lo,
+    const std::vector<int>& padding_hi,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    Stream stream) {
+  const int N = in.shape(0); // Batch size, should be the same as out.shape(0)
+  const int iH = in.shape(1); // Input spatial dim
+  const int C = in.shape(2); // Input channels
+  const int oH = out.shape(1); // Output spatial dim
+  const int O = wt.shape(0); // Out channels
+  const int wH = wt.shape(1); // Weight spatial dim
+
+  const int groups = C / wt.shape(2);
+  const int C_per_group = wt.shape(2);
+  const int O_per_group = O / groups;
+
+  auto conv_dtype = float32;
+  auto& encoder = cpu::get_command_encoder(stream);
+
+  // Pad input
+  Shape padded_shape = {N, iH + padding_lo[0] + padding_hi[0], C};
+  array in_padded(padded_shape, conv_dtype, nullptr, {});
+
+  // Fill with zeros
+  std::vector<array> temps;
+  temps.push_back(array(0, conv_dtype));
+  copy_cpu(temps.back(), in_padded, CopyType::Scalar, stream);
+
+  // Pick input slice from padded
+  size_t data_offset = padding_lo[0] * in_padded.strides()[1];
+  array in_padded_slice(in.shape(), in_padded.dtype(), nullptr, {});
+  in_padded_slice.copy_shared_buffer(
+      in_padded,
+      in_padded.strides(),
+      in_padded.flags(),
+      in_padded_slice.size(),
+      data_offset);
+  // Copy input values into the slice
+  copy_cpu_inplace(in, in_padded_slice, CopyType::GeneralGeneral, stream);
+  temps.push_back(in_padded_slice);
+
+  // Make strided view
+  Shape strided_shape = {N, oH, wH, C};
+
+  Strides strided_strides = {
+      in_padded.strides()[0],
+      in_padded.strides()[1] * wt_strides[0],
+      in_padded.strides()[1],
+      in_padded.strides()[2]};
+  auto flags = in_padded.flags();
+  if (groups > 1) {
+    // Transpose the last two dimensions for grouped convolutions
+    std::swap(strided_shape[2], strided_shape[3]);
+    std::swap(strided_strides[2], strided_strides[3]);
+  }
+
+  array in_strided_view(strided_shape, in_padded.dtype(), nullptr, {});
+  in_strided_view.copy_shared_buffer(
+      in_padded, strided_strides, flags, in_strided_view.size(), 0);
+
+  // Materialize strided view
+  Shape strided_reshape = {N * oH, wH * C};
+  array in_strided(strided_reshape, in_strided_view.dtype(), nullptr, {});
+  copy_cpu(in_strided_view, in_strided, CopyType::General, stream);
+  temps.push_back(in_strided);
+
+  // Check wt dtype and prepare
+  auto gemm_wt = wt;
+  auto gemm_out = out;
+
+  if (groups > 1) {
+    // Transpose the last two dimensions for grouped convolutions
+    array wt_transpose(
+        {wt.shape(0), wt.shape(2), wt.shape(1)}, wt.dtype(), nullptr, {});
+    wt_transpose.copy_shared_buffer(
+        wt,
+        {wt.strides(0), wt.strides(2), wt.strides(1)},
+        wt.flags(),
+        wt.size(),
+        0);
+    gemm_wt = array(wt_transpose.shape(), float32, nullptr, {});
+    copy_cpu(wt_transpose, gemm_wt, CopyType::General, stream);
+    temps.push_back(gemm_wt);
+  } else if (wt.dtype() != float32 || !wt.flags().row_contiguous) {
+    auto ctype =
+        wt.flags().row_contiguous ? CopyType::Vector : CopyType::General;
+    gemm_wt = array(wt.shape(), float32, nullptr, {});
+    copy_cpu(wt, gemm_wt, ctype, stream);
+    temps.push_back(gemm_wt);
+  }
+
+  if (out.dtype() != float32) {
+    gemm_out = array(out.shape(), float32, nullptr, {});
+    gemm_out.set_data(allocator::malloc(gemm_out.nbytes()));
+    temps.push_back(gemm_out);
+  }
+
+  encoder.set_input_array(in_strided);
+  encoder.set_input_array(gemm_wt);
+  encoder.set_output_array(gemm_out);
+
+  encoder.dispatch([in_strided_ptr = in_strided.data<float>(),
+                    gemm_wt_ptr = gemm_wt.data<float>(),
+                    gemm_out_ptr = gemm_out.data<float>(),
+                    groups,
+                    strided_reshape = strided_reshape[0],
+                    O,
+                    C,
+                    wH,
+                    O_per_group,
+                    C_per_group]() {
+    for (int g = 0; g < groups; ++g) {
+      // Perform gemm
+      cblas_sgemm(
+          CblasRowMajor,
+          CblasNoTrans, // no trans A
+          CblasTrans, // transB
+          strided_reshape, // M
+          O_per_group, // N
+          C_per_group * wH, // K
+          1.0f, // alpha
+          in_strided_ptr + g * C_per_group * wH, // A
+          wH * C, // lda
+          gemm_wt_ptr + g * O_per_group * C_per_group * wH, // B
+          wH * C_per_group, // ldb
+          0.0f, // beta
+          gemm_out_ptr + g * O_per_group, // C
+          O // ldc
+      );
+    }
+  });
+
+  // Copy results if needed
+  if (out.dtype() != float32) {
+    copy_cpu_inplace(gemm_out, out, CopyType::Vector, stream);
+  }
+  encoder.add_temporaries(std::move(temps));
+}
+
+void explicit_gemm_conv_2D_cpu(
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding_lo,
+    const std::vector<int>& padding_hi,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    Stream stream) {
+  const int N = in.shape(0); // Batch size, should be the same as out.shape(0)
+  const int iH = in.shape(1); // Input spatial dim
+  const int iW = in.shape(2); // Input spatial dim
+  const int oH = out.shape(1); // Output spatial dim
+  const int oW = out.shape(2); // Output spatial dim
+  const int O = wt.shape(0); // Out channels
+  const int C = wt.shape(3); // In channels
+  const int wH = wt.shape(1); // Weight spatial dim
+  const int wW = wt.shape(2); // Weight spatial dim
+
+  auto conv_dtype = out.dtype();
+  auto& encoder = cpu::get_command_encoder(stream);
+
+  // Pad input
+  Shape padded_shape = {
+      N,
+      iH + padding_lo[0] + padding_hi[0],
+      iW + padding_lo[1] + padding_hi[1],
+      C};
+  array in_padded(padded_shape, conv_dtype, nullptr, {});
+
+  // Fill with zeros
+  std::vector<array> temps;
+  temps.push_back(array(0, conv_dtype));
+  copy_cpu(temps.back(), in_padded, CopyType::Scalar, stream);
+
+  // Pick input slice from padded
+  size_t data_offset = padding_lo[0] * in_padded.strides()[1] +
+      padding_lo[1] * in_padded.strides()[2];
+  array in_padded_slice(in.shape(), in_padded.dtype(), nullptr, {});
+  in_padded_slice.copy_shared_buffer(
+      in_padded,
+      in_padded.strides(),
+      in_padded.flags(),
+      in_padded_slice.size(),
+      data_offset);
+  temps.push_back(in_padded_slice);
+
+  // Copy input values into the slice
+  copy_cpu_inplace(in, in_padded_slice, CopyType::GeneralGeneral, stream);
+
+  // Make strided view
+  Shape strided_shape = {N, oH, oW, wH, wW, C};
+
+  Strides strided_strides = {
+      in_padded.strides()[0],
+      in_padded.strides()[1] * wt_strides[0],
+      in_padded.strides()[2] * wt_strides[1],
+      in_padded.strides()[1],
+      in_padded.strides()[2],
+      in_padded.strides()[3]};
+  auto flags = in_padded.flags();
+
+  array in_strided_view(strided_shape, in_padded.dtype(), nullptr, {});
+  in_strided_view.copy_shared_buffer(
+      in_padded, strided_strides, flags, in_strided_view.size(), 0);
+
+  // Materialize strided view
+  Shape strided_reshape = {N * oH * oW, wH * wW * C};
+  array in_strided(strided_reshape, in_strided_view.dtype(), nullptr, {});
+  copy_cpu(in_strided_view, in_strided, CopyType::General, stream);
+  temps.push_back(in_strided);
+
+  // Check wt dtype and prepare
+  auto gemm_wt = wt;
+  auto gemm_out = out;
+
+  if (wt.dtype() != float32 || !wt.flags().row_contiguous) {
+    auto ctype =
+        wt.flags().row_contiguous ? CopyType::Vector : CopyType::General;
+    gemm_wt = array(wt.shape(), float32, nullptr, {});
+    copy_cpu(wt, gemm_wt, ctype, stream);
+    temps.push_back(gemm_wt);
+  }
+
+  if (out.dtype() != float32) {
+    gemm_out = array(out.shape(), float32, nullptr, {});
+    gemm_out.set_data(allocator::malloc(gemm_out.nbytes()));
+    temps.push_back(gemm_out);
+  }
+
+  encoder.set_input_array(in_strided);
+  encoder.set_input_array(gemm_wt);
+  encoder.set_output_array(gemm_out);
+
+  encoder.dispatch([in_strided_ptr = in_strided.data<float>(),
+                    gemm_wt_ptr = gemm_wt.data<float>(),
+                    gemm_out_ptr = gemm_out.data<float>(),
+                    strided_reshape = std::move(strided_reshape),
+                    O]() {
+    // Perform gemm
+    cblas_sgemm(
+        CblasRowMajor,
+        CblasNoTrans, // no trans A
+        CblasTrans, // transB
+        strided_reshape[0], // M
+        O, // N
+        strided_reshape[1], // K
+        1.0f, // alpha
+        in_strided_ptr,
+        strided_reshape[1], // lda
+        gemm_wt_ptr,
+        strided_reshape[1], // ldb
+        0.0f, // beta
+        gemm_out_ptr,
+        O // ldc
+    );
+  });
+
+  // Copy results if needed
+  if (out.dtype() != float32) {
+    copy_cpu_inplace(gemm_out, out, CopyType::Vector, stream);
+  }
+  encoder.add_temporaries(std::move(temps));
+}
+
+void explicit_gemm_conv_ND_cpu(
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding_lo,
+    const std::vector<int>& padding_hi,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    const bool flip,
+    Stream stream) {
+  const int N = in.shape(0); // Batch size, should be the same as out.shape(0)
+  const auto iDim =
+      Shape(in.shape().begin() + 1, in.shape().end() - 1); // Input spatial dim
+  const auto oDim = Shape(
+      out.shape().begin() + 1, out.shape().end() - 1); // Output spatial dim
+  const int O = wt.shape(0); // Out channels
+  const int C = wt.shape(-1); // In channels
+  const auto wDim =
+      Shape(wt.shape().begin() + 1, wt.shape().end() - 1); // Weight spatial dim
+
+  auto conv_dtype = float32;
+
+  auto& encoder = cpu::get_command_encoder(stream);
+
+  // Pad input
+  Shape padded_shape(in.shape().size());
+  padded_shape.front() = N;
+  for (size_t i = 0; i < iDim.size(); i++) {
+    padded_shape[i + 1] = iDim[i] + padding_lo[i] + padding_hi[i];
+  }
+  padded_shape.back() = C;
+  array in_padded(padded_shape, conv_dtype, nullptr, {});
+
+  // Fill with zeros
+  std::vector<array> temps = {array(0, conv_dtype)};
+  copy_cpu(temps.back(), in_padded, CopyType::Scalar, stream);
+
+  // Pick input slice from padded
+  size_t data_offset = 0;
+  for (size_t i = 0; i < padding_lo.size(); i++) {
+    data_offset += padding_lo[i] * in_padded.strides()[i + 1];
+  }
+
+  array in_padded_slice(in.shape(), in_padded.dtype(), nullptr, {});
+  in_padded_slice.copy_shared_buffer(
+      in_padded,
+      in_padded.strides(),
+      in_padded.flags(),
+      in_padded_slice.size(),
+      data_offset);
+
+  // Copy input values into the slice
+  copy_cpu_inplace(in, in_padded_slice, CopyType::GeneralGeneral, stream);
+  temps.push_back(in_padded_slice);
+
+  // Make strided view
+  Shape strided_shape(oDim.size() + wDim.size() + 2);
+  strided_shape.front() = N;
+  for (size_t i = 0; i < oDim.size(); i++) {
+    strided_shape[i + 1] = oDim[i];
+  }
+  for (size_t i = 0; i < wDim.size(); i++) {
+    strided_shape[i + 1 + oDim.size()] = wDim[i];
+  }
+  strided_shape.back() = C;
+
+  Strides strided_strides(in.shape().size() * 2 - 2);
+  strided_strides[0] = in_padded.strides()[0];
+  for (size_t i = 0; i < wt_strides.size(); i++) {
+    strided_strides[i + 1] = in_padded.strides()[i + 1] * wt_strides[i];
+  }
+  for (size_t i = 1; i < in_padded.strides().size(); i++) {
+    strided_strides[i + wt_strides.size()] = in_padded.strides()[i];
+  }
+
+  auto flags = in_padded.flags();
+
+  array in_strided_view(strided_shape, in_padded.dtype(), nullptr, {});
+  in_strided_view.copy_shared_buffer(
+      in_padded, strided_strides, flags, in_strided_view.size(), 0);
+
+  // Materialize strided view
+  Shape strided_reshape = {N, C};
+  for (const auto& o : oDim) {
+    strided_reshape[0] *= o;
+  }
+  for (const auto& w : wDim) {
+    strided_reshape[1] *= w;
+  }
+
+  array in_strided(strided_reshape, in_strided_view.dtype(), nullptr, {});
+  copy_cpu(in_strided_view, in_strided, CopyType::General, stream);
+  temps.push_back(in_strided);
+
+  // Check wt dtype and prepare
+  auto gemm_wt = wt;
+  auto gemm_out = out;
+
+  if (wt.dtype() != float32 || !wt.flags().row_contiguous) {
+    auto ctype =
+        wt.flags().row_contiguous ? CopyType::Vector : CopyType::General;
+    gemm_wt = array(wt.shape(), float32, nullptr, {});
+    copy_cpu(wt, gemm_wt, ctype, stream);
+    temps.push_back(gemm_wt);
+  }
+
+  if (flip) {
+    auto gemm_wt_ = array(gemm_wt.shape(), float32, nullptr, {});
+    copy_cpu(gemm_wt, gemm_wt_, CopyType::Vector, stream);
+    temps.push_back(gemm_wt_);
+
+    // Calculate the total size of the spatial dimensions
+    int spatial_size = 1;
+    for (int d = 1; d < gemm_wt.ndim() - 1; ++d) {
+      spatial_size *= gemm_wt.shape(d);
+    }
+    encoder.set_output_array(gemm_wt_);
+    encoder.dispatch([gemm_wt_ptr = gemm_wt_.data<float>(),
+                      out_channels = gemm_wt.shape(0),
+                      in_channels = gemm_wt.shape(-1),
+                      spatial_size]() {
+      flip_spatial_dims_inplace<float>(
+          gemm_wt_ptr, in_channels, out_channels, spatial_size);
+    });
+    gemm_wt = gemm_wt_;
+  }
+
+  if (out.dtype() != float32) {
+    gemm_out = array(out.shape(), float32, nullptr, {});
+    gemm_out.set_data(allocator::malloc(gemm_out.nbytes()));
+    temps.push_back(gemm_out);
+  }
+
+  encoder.set_input_array(in_strided);
+  encoder.set_input_array(gemm_wt);
+  encoder.set_output_array(gemm_out);
+
+  encoder.dispatch([in_strided_ptr = in_strided.data<float>(),
+                    gemm_wt_ptr = gemm_wt.data<float>(),
+                    gemm_out_ptr = gemm_out.data<float>(),
+                    strided_reshape = std::move(strided_reshape),
+                    O]() {
+    // Perform gemm
+    cblas_sgemm(
+        CblasRowMajor,
+        CblasNoTrans, // no trans A
+        CblasTrans, // transB
+        strided_reshape[0], // M
+        O, // N
+        strided_reshape[1], // K
+        1.0f, // alpha
+        in_strided_ptr,
+        strided_reshape[1], // lda
+        gemm_wt_ptr,
+        strided_reshape[1], // ldb
+        0.0f, // beta
+        gemm_out_ptr,
+        O // ldc
+    );
+  });
+
+  // Copy results if needed
+  if (out.dtype() != float32) {
+    copy_cpu_inplace(gemm_out, out, CopyType::Vector, stream);
+  }
+  encoder.add_temporaries(std::move(temps));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Conv routing
+///////////////////////////////////////////////////////////////////////////////
+
+void conv_1D_cpu(
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding_lo,
+    const std::vector<int>& padding_hi,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    const std::vector<int>& in_dilation,
+    bool flip,
+    Stream stream) {
+  const int groups = in.shape().back() / wt.shape().back();
+  if (wt_dilation[0] == 1 && in_dilation[0] == 1 && !flip) {
+    return explicit_gemm_conv_1D_cpu(
+        in, wt, out, padding_lo, padding_hi, wt_strides, wt_dilation, stream);
+  }
+  if (wt_dilation[0] == 1 && in_dilation[0] == 1 && groups == 1) {
+    return explicit_gemm_conv_ND_cpu(
+        in,
+        wt,
+        out,
+        padding_lo,
+        padding_hi,
+        wt_strides,
+        wt_dilation,
+        flip,
+        stream);
+  }
+
+  return dispatch_slow_conv_1D(
+      in,
+      wt,
+      out,
+      padding_lo,
+      padding_hi,
+      wt_strides,
+      wt_dilation,
+      in_dilation,
+      flip,
+      stream);
+}
+
+void conv_2D_cpu(
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding_lo,
+    const std::vector<int>& padding_hi,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    const std::vector<int>& in_dilation,
+    bool flip,
+    Stream stream) {
+  const int groups = in.shape().back() / wt.shape().back();
+  if (wt_dilation[0] == 1 && wt_dilation[1] == 1 && in_dilation[0] == 1 &&
+      in_dilation[1] == 1 && groups == 1) {
+    return explicit_gemm_conv_ND_cpu(
+        in,
+        wt,
+        out,
+        padding_lo,
+        padding_hi,
+        wt_strides,
+        wt_dilation,
+        flip,
+        stream);
+  }
+  return dispatch_slow_conv_2D(
+      in,
+      wt,
+      out,
+      padding_lo,
+      padding_hi,
+      wt_strides,
+      wt_dilation,
+      in_dilation,
+      flip,
+      stream);
+}
+
+void conv_3D_cpu(
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding_lo,
+    const std::vector<int>& padding_hi,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    const std::vector<int>& in_dilation,
+    bool flip,
+    Stream stream) {
+  const int groups = in.shape().back() / wt.shape().back();
+  if (wt_dilation[0] == 1 && wt_dilation[1] == 1 && wt_dilation[2] == 1 &&
+      in_dilation[0] == 1 && in_dilation[1] == 1 && in_dilation[2] == 1 &&
+      groups == 1) {
+    return explicit_gemm_conv_ND_cpu(
+        in,
+        wt,
+        out,
+        padding_lo,
+        padding_hi,
+        wt_strides,
+        wt_dilation,
+        flip,
+        stream);
+  }
+
+  return dispatch_slow_conv_3D(
+      in,
+      wt,
+      out,
+      padding_lo,
+      padding_hi,
+      wt_strides,
+      wt_dilation,
+      in_dilation,
+      flip,
+      stream);
+}
+
+} // namespace
+
+void Convolution::eval_cpu(const std::vector<array>& inputs, array& out) {
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& in = inputs[0];
+  auto& wt = inputs[1];
+
+  // 3D convolution
+  if (in.ndim() == (3 + 2)) {
+    return conv_3D_cpu(
+        in,
+        wt,
+        out,
+        padding_lo_,
+        padding_hi_,
+        kernel_strides_,
+        kernel_dilation_,
+        input_dilation_,
+        flip_,
+        stream());
+  }
+  // 2D convolution
+  else if (in.ndim() == (2 + 2)) {
+    return conv_2D_cpu(
+        in,
+        wt,
+        out,
+        padding_lo_,
+        padding_hi_,
+        kernel_strides_,
+        kernel_dilation_,
+        input_dilation_,
+        flip_,
+        stream());
+  }
+  // 1D convolution
+  else if (in.ndim() == (1 + 2)) {
+    return conv_1D_cpu(
+        in,
+        wt,
+        out,
+        padding_lo_,
+        padding_hi_,
+        kernel_strides_,
+        kernel_dilation_,
+        input_dilation_,
+        flip_,
+        stream());
+  }
+  // Throw error
+  else {
+    std::ostringstream msg;
+    msg << "[Convolution::eval] Convolution currently only supports"
+        << " 1D, 2D and 3D convolutions. Got inputs with " << in.ndim() - 2
+        << " spatial dimensions";
+    throw std::invalid_argument(msg.str());
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f9ff22677a35853a9d92f9bd53aa250d27f38227
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.cpp
@@ -0,0 +1,386 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <numeric>
+
+#include "mlx/allocator.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/simd/simd.h"
+
+namespace mlx::core {
+
+namespace {
+
+template <typename SrcT, typename DstT>
+void copy_single(const array& src, array& dst) {
+  auto src_ptr = src.data<SrcT>();
+  auto dst_ptr = dst.data<DstT>();
+  auto size = dst.size();
+  auto val = static_cast<DstT>(src_ptr[0]);
+  std::fill_n(dst_ptr, size, val);
+}
+
+template <typename SrcT, typename DstT>
+void copy_vector(const array& src, array& dst) {
+  auto src_ptr = src.data<SrcT>();
+  auto dst_ptr = dst.data<DstT>();
+  auto size = src.data_size();
+  std::copy(src_ptr, src_ptr + size, dst_ptr);
+}
+
+template <typename SrcT, typename DstT, int D>
+inline void copy_dims(
+    const SrcT* src,
+    DstT* dst,
+    const Shape& shape,
+    const Strides& i_strides,
+    const Strides& o_strides,
+    int axis) {
+  auto stride_src = i_strides[axis];
+  auto stride_dst = o_strides[axis];
+  auto N = shape[axis];
+
+  for (int i = 0; i < N; i++) {
+    if constexpr (D > 1) {
+      copy_dims<SrcT, DstT, D - 1>(
+          src, dst, shape, i_strides, o_strides, axis + 1);
+    } else {
+      *dst = static_cast<DstT>(*src);
+    }
+    src += stride_src;
+    dst += stride_dst;
+  }
+}
+
+template <typename SrcT, typename DstT>
+void copy_general_general(
+    const array& src,
+    array& dst,
+    const Shape& data_shape,
+    const Strides& i_strides,
+    const Strides& o_strides,
+    int64_t i_offset,
+    int64_t o_offset,
+    const std::optional<array>& dynamic_i_offset,
+    const std::optional<array>& dynamic_o_offset) {
+  auto src_ptr = src.data<SrcT>() + i_offset;
+  auto dst_ptr = dst.data<DstT>() + o_offset;
+  auto i_offset_ptr =
+      dynamic_i_offset ? dynamic_i_offset->data<int64_t>() : nullptr;
+  auto o_offset_ptr =
+      dynamic_o_offset ? dynamic_o_offset->data<int64_t>() : nullptr;
+  auto size = src.size();
+  if (data_shape.empty()) {
+    auto val = static_cast<DstT>(*src_ptr);
+    *dst_ptr = val;
+    return;
+  }
+  auto [shape, strides] =
+      collapse_contiguous_dims(data_shape, {i_strides, o_strides});
+
+  int ndim = shape.size();
+  if (ndim < 3) {
+    if (i_offset_ptr) {
+      src_ptr += i_offset_ptr[0];
+    }
+    if (o_offset_ptr) {
+      dst_ptr += o_offset_ptr[0];
+    }
+
+    if (ndim == 1) {
+      copy_dims<SrcT, DstT, 1>(
+          src_ptr, dst_ptr, shape, strides[0], strides[1], 0);
+    } else if (ndim == 2) {
+      copy_dims<SrcT, DstT, 2>(
+          src_ptr, dst_ptr, shape, strides[0], strides[1], 0);
+    } else if (ndim == 3) {
+      copy_dims<SrcT, DstT, 3>(
+          src_ptr, dst_ptr, shape, strides[0], strides[1], 0);
+    }
+    return;
+  }
+  if (i_offset_ptr) {
+    src_ptr += i_offset_ptr[0];
+  }
+  if (o_offset_ptr) {
+    dst_ptr += o_offset_ptr[0];
+  }
+
+  ContiguousIterator in(shape, strides[0], ndim - 3);
+  ContiguousIterator out(shape, strides[1], ndim - 3);
+  auto stride = std::accumulate(
+      shape.end() - 3, shape.end(), 1, std::multiplies<int64_t>());
+  for (int64_t elem = 0; elem < size; elem += stride) {
+    copy_dims<SrcT, DstT, 3>(
+        src_ptr + in.loc,
+        dst_ptr + out.loc,
+        shape,
+        strides[0],
+        strides[1],
+        ndim - 3);
+    in.step();
+    out.step();
+  }
+}
+
+template <typename SrcT, typename DstT>
+inline void copy_general_general(const array& src, array& dst) {
+  copy_general_general<SrcT, DstT>(
+      src,
+      dst,
+      src.shape(),
+      src.strides(),
+      dst.strides(),
+      0,
+      0,
+      std::nullopt,
+      std::nullopt);
+}
+
+template <typename SrcT, typename DstT>
+void copy_general(
+    const array& src,
+    array& dst,
+    const Shape& data_shape,
+    const Strides& i_strides,
+    const Strides&,
+    int64_t i_offset,
+    int64_t o_offset,
+    const std::optional<array>& dynamic_i_offset,
+    const std::optional<array>& dynamic_o_offset) {
+  copy_general_general<SrcT, DstT>(
+      src,
+      dst,
+      data_shape,
+      i_strides,
+      make_contiguous_strides(data_shape),
+      i_offset,
+      o_offset,
+      dynamic_i_offset,
+      dynamic_o_offset);
+}
+
+template <typename SrcT, typename DstT>
+inline void copy_general(const array& src, array& dst) {
+  copy_general_general<SrcT, DstT>(
+      src,
+      dst,
+      src.shape(),
+      src.strides(),
+      make_contiguous_strides(src.shape()),
+      0,
+      0,
+      std::nullopt,
+      std::nullopt);
+}
+
+template <typename SrcT, typename DstT, typename... Args>
+void copy(const array& src, array& dst, CopyType ctype, Args&&... args) {
+  switch (ctype) {
+    case CopyType::Scalar:
+      copy_single<SrcT, DstT>(src, dst);
+      return;
+    case CopyType::Vector:
+      copy_vector<SrcT, DstT>(src, dst);
+      return;
+    case CopyType::General:
+      copy_general<SrcT, DstT>(src, dst, std::forward<Args>(args)...);
+      return;
+    case CopyType::GeneralGeneral:
+      copy_general_general<SrcT, DstT>(src, dst, std::forward<Args>(args)...);
+      return;
+  }
+}
+
+template <typename SrcT, typename... Args>
+void copy(const array& src, array& dst, CopyType ctype, Args&&... args) {
+  switch (dst.dtype()) {
+    case bool_:
+      copy<SrcT, bool>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case uint8:
+      copy<SrcT, uint8_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case uint16:
+      copy<SrcT, uint16_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case uint32:
+      copy<SrcT, uint32_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case uint64:
+      copy<SrcT, uint64_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case int8:
+      copy<SrcT, int8_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case int16:
+      copy<SrcT, int16_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case int32:
+      copy<SrcT, int32_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case int64:
+      copy<SrcT, int64_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case float16:
+      copy<SrcT, float16_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case float32:
+      copy<SrcT, float>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case float64:
+      copy<SrcT, double>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case bfloat16:
+      copy<SrcT, bfloat16_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case complex64:
+      copy<SrcT, complex64_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+  }
+}
+
+template <typename... Args>
+inline void copy_inplace_dispatch(
+    const array& src,
+    array& dst,
+    CopyType ctype,
+    Args&&... args) {
+  switch (src.dtype()) {
+    case bool_:
+      copy<bool>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case uint8:
+      copy<uint8_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case uint16:
+      copy<uint16_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case uint32:
+      copy<uint32_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case uint64:
+      copy<uint64_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case int8:
+      copy<int8_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case int16:
+      copy<int16_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case int32:
+      copy<int32_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case int64:
+      copy<int64_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case float16:
+      copy<float16_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case float32:
+      copy<float>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case float64:
+      copy<double>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case bfloat16:
+      copy<bfloat16_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+    case complex64:
+      copy<complex64_t>(src, dst, ctype, std::forward<Args>(args)...);
+      break;
+  }
+}
+
+} // namespace
+
+void copy_cpu_inplace(
+    const array& src,
+    array& dst,
+    CopyType ctype,
+    Stream stream) {
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(src);
+  encoder.set_output_array(dst);
+  encoder.dispatch(
+      [src = array::unsafe_weak_copy(src),
+       dst = array::unsafe_weak_copy(dst),
+       ctype]() mutable { copy_inplace_dispatch(src, dst, ctype); });
+}
+
+void copy_cpu(const array& src, array& dst, CopyType ctype, Stream stream) {
+  bool donated = set_copy_output_data(src, dst, ctype);
+  if (donated && src.dtype() == dst.dtype()) {
+    // If the output has the same type as the input then there is nothing to
+    // copy, just use the buffer.
+    return;
+  }
+  if (ctype == CopyType::GeneralGeneral) {
+    ctype = CopyType::General;
+  }
+  copy_cpu_inplace(src, dst, ctype, stream);
+}
+
+void copy_cpu_inplace(
+    const array& src,
+    array& dst,
+    const Shape& data_shape,
+    const Strides& i_strides,
+    const Strides& o_strides,
+    int64_t i_offset,
+    int64_t o_offset,
+    CopyType ctype,
+    Stream stream,
+    const std::optional<array>& dynamic_i_offset, /* = std::nullopt */
+    const std::optional<array>& dynamic_o_offset /* = std::nullopt */) {
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(src);
+  encoder.set_output_array(dst);
+  auto weak_copy_if_set = [](auto x) -> std::optional<array> {
+    if (x) {
+      return array::unsafe_weak_copy(*x);
+    } else {
+      return std::nullopt;
+    }
+  };
+  encoder.dispatch(
+      [src = array::unsafe_weak_copy(src),
+       dst = array::unsafe_weak_copy(dst),
+       data_shape,
+       i_strides,
+       o_strides,
+       i_offset,
+       o_offset,
+       ctype,
+       dynamic_i_offset = weak_copy_if_set(dynamic_i_offset),
+       dynamic_o_offset = weak_copy_if_set(dynamic_o_offset)]() mutable {
+        switch (ctype) {
+          case CopyType::General:
+          case CopyType::GeneralGeneral:
+            copy_inplace_dispatch(
+                src,
+                dst,
+                ctype,
+                data_shape,
+                i_strides,
+                o_strides,
+                i_offset,
+                o_offset,
+                dynamic_i_offset,
+                dynamic_o_offset);
+            break;
+          case CopyType::Scalar:
+          case CopyType::Vector:
+            copy_inplace_dispatch(src, dst, ctype);
+        }
+      });
+}
+
+array contiguous_copy_cpu(const array& arr, Stream stream) {
+  array arr_copy(arr.shape(), arr.dtype(), nullptr, {});
+  copy_cpu(arr, arr_copy, CopyType::General, stream);
+  return arr_copy;
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..007291369a289ef6d58c8314ba95034de774a37a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/copy.h
@@ -0,0 +1,36 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <optional>
+
+#include "mlx/array.h"
+#include "mlx/backend/common/copy.h"
+#include "mlx/backend/common/utils.h"
+
+namespace mlx::core {
+
+void copy_cpu(const array& src, array& dst, CopyType ctype, Stream stream);
+void copy_cpu_inplace(
+    const array& src,
+    array& dst,
+    CopyType ctype,
+    Stream stream);
+
+void copy_cpu_inplace(
+    const array& src,
+    array& dst,
+    const Shape& data_shape,
+    const Strides& i_strides,
+    const Strides& o_strides,
+    int64_t i_offset,
+    int64_t o_offset,
+    CopyType ctype,
+    Stream stream,
+    const std::optional<array>& dynamic_i_offset = std::nullopt,
+    const std::optional<array>& dynamic_o_offset = std::nullopt);
+
+// Return a contiguous array with same shape that copies the data of |arr|.
+array contiguous_copy_cpu(const array& arr, Stream stream);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d641d581ba25354088e2c1a5720b4f88a883a31c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/distributed.cpp
@@ -0,0 +1,98 @@
+// Copyright © 2024 Apple Inc.
+
+#include <cassert>
+
+#include "mlx/allocator.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/distributed/primitives.h"
+
+namespace mlx::core::distributed {
+
+std::pair<array, bool> ensure_row_contiguous(const array& arr, Stream stream) {
+  if (arr.flags().row_contiguous) {
+    return {arr, false};
+  } else {
+    return {contiguous_copy_cpu(arr, stream), true};
+  }
+};
+
+void AllReduce::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  assert(inputs.size() == 1);
+  assert(outputs.size() == 1);
+
+  auto donate_or_copy = [s = stream()](const array& in, array& out) {
+    if (in.flags().row_contiguous) {
+      if (in.is_donatable()) {
+        out.copy_shared_buffer(in);
+      } else {
+        out.set_data(allocator::malloc(out.nbytes()));
+      }
+      return in;
+    } else {
+      array arr_copy = contiguous_copy_cpu(in, s);
+      out.copy_shared_buffer(arr_copy);
+      return arr_copy;
+    }
+  };
+
+  auto in = donate_or_copy(inputs[0], outputs[0]);
+  switch (reduce_type_) {
+    case Sum:
+      distributed::detail::all_sum(group(), in, outputs[0], stream());
+      break;
+    case Max:
+      distributed::detail::all_max(group(), in, outputs[0], stream());
+      break;
+    case Min:
+      distributed::detail::all_min(group(), in, outputs[0], stream());
+      break;
+    default:
+      throw std::runtime_error(
+          "Only all reduce sum, min and max are supported for now");
+  }
+}
+
+void AllGather::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  assert(inputs.size() == 1);
+  assert(outputs.size() == 1);
+
+  auto [in, copied] = ensure_row_contiguous(inputs[0], stream());
+  outputs[0].set_data(allocator::malloc(outputs[0].nbytes()));
+  distributed::detail::all_gather(group(), in, outputs[0], stream());
+  if (copied) {
+    auto& enc = cpu::get_command_encoder(stream());
+    enc.add_temporary(in);
+  }
+}
+
+void Send::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  assert(inputs.size() == 1);
+  assert(outputs.size() == 1);
+
+  auto [in, copied] = ensure_row_contiguous(inputs[0], stream());
+  distributed::detail::send(group(), in, dst_, stream());
+  outputs[0].copy_shared_buffer(inputs[0]);
+  if (copied) {
+    auto& enc = cpu::get_command_encoder(stream());
+    enc.add_temporary(in);
+  }
+}
+
+void Recv::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  assert(inputs.size() == 0);
+  assert(outputs.size() == 1);
+
+  outputs[0].set_data(allocator::malloc(outputs[0].nbytes()));
+  distributed::detail::recv(group(), outputs[0], src_, stream());
+}
+
+} // namespace mlx::core::distributed
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a0129514508e8f3cd40971f6ba9b1ef34d2dfaf5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/eig.cpp
@@ -0,0 +1,174 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/allocator.h"
+#include "mlx/array.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/lapack.h"
+#include "mlx/linalg.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+namespace {
+
+template <typename T>
+void eig_impl(
+    array& a,
+    array& vectors,
+    array& values,
+    bool compute_eigenvectors,
+    Stream stream) {
+  using OT = std::complex<T>;
+  auto a_ptr = a.data<T>();
+  auto eig_ptr = values.data<OT>();
+
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_output_array(values);
+  OT* vec_ptr = nullptr;
+  if (compute_eigenvectors) {
+    encoder.set_output_array(vectors);
+    vec_ptr = vectors.data<OT>();
+  }
+  encoder.dispatch([a_ptr,
+                    vec_ptr,
+                    eig_ptr,
+                    compute_eigenvectors,
+                    N = vectors.shape(-1),
+                    size = vectors.size()]() mutable {
+    // Work query
+    char jobr = 'N';
+    char jobl = compute_eigenvectors ? 'V' : 'N';
+    int n_vecs_r = 1;
+    int n_vecs_l = compute_eigenvectors ? N : 1;
+    int lwork = -1;
+    int info;
+    {
+      T work;
+      int iwork;
+      geev<T>(
+          &jobl,
+          &jobr,
+          &N,
+          nullptr,
+          &N,
+          nullptr,
+          nullptr,
+          nullptr,
+          &n_vecs_l,
+          nullptr,
+          &n_vecs_r,
+          &work,
+          &lwork,
+          &info);
+      lwork = static_cast<int>(work);
+    }
+
+    auto eig_tmp_data = array::Data{allocator::malloc(sizeof(T) * N * 2)};
+    auto vec_tmp_data =
+        array::Data{allocator::malloc(vec_ptr ? sizeof(T) * N * N * 2 : 0)};
+    auto eig_tmp = static_cast<T*>(eig_tmp_data.buffer.raw_ptr());
+    auto vec_tmp = static_cast<T*>(vec_tmp_data.buffer.raw_ptr());
+    auto work_buf = array::Data{allocator::malloc(sizeof(T) * lwork)};
+    for (size_t i = 0; i < size / (N * N); ++i) {
+      geev<T>(
+          &jobl,
+          &jobr,
+          &N,
+          a_ptr,
+          &N,
+          eig_tmp,
+          eig_tmp + N,
+          vec_tmp,
+          &n_vecs_l,
+          nullptr,
+          &n_vecs_r,
+          static_cast<T*>(work_buf.buffer.raw_ptr()),
+          &lwork,
+          &info);
+      for (int i = 0; i < N; ++i) {
+        eig_ptr[i] = {eig_tmp[i], eig_tmp[N + i]};
+      }
+      if (vec_ptr) {
+        for (int i = 0; i < N; ++i) {
+          if (eig_ptr[i].imag() != 0) {
+            // This vector and the next are a pair
+            for (int j = 0; j < N; ++j) {
+              vec_ptr[i * N + j] = {
+                  vec_tmp[i * N + j], -vec_tmp[(i + 1) * N + j]};
+              vec_ptr[(i + 1) * N + j] = {
+                  vec_tmp[i * N + j], vec_tmp[(i + 1) * N + j]};
+            }
+            i += 1;
+          } else {
+            for (int j = 0; j < N; ++j) {
+              vec_ptr[i * N + j] = {vec_tmp[i * N + j], 0};
+            }
+          }
+        }
+        vec_ptr += N * N;
+      }
+      a_ptr += N * N;
+      eig_ptr += N;
+      if (info != 0) {
+        std::stringstream msg;
+        msg << "[Eig::eval_cpu] Eigenvalue decomposition failed with error code "
+            << info;
+        throw std::runtime_error(msg.str());
+      }
+    }
+  });
+  encoder.add_temporary(a);
+}
+
+} // namespace
+
+void Eig::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  const auto& a = inputs[0];
+  auto& values = outputs[0];
+
+  auto vectors = compute_eigenvectors_
+      ? outputs[1]
+      : array(a.shape(), complex64, nullptr, {});
+
+  auto a_copy = array(a.shape(), a.dtype(), nullptr, {});
+  copy_cpu(
+      a,
+      a_copy,
+      a.flags().row_contiguous ? CopyType::Vector : CopyType::General,
+      stream());
+
+  values.set_data(allocator::malloc(values.nbytes()));
+
+  if (compute_eigenvectors_) {
+    // Set the strides and flags so the eigenvectors
+    // are in the columns of the output
+    auto flags = vectors.flags();
+    auto strides = vectors.strides();
+    auto ndim = a.ndim();
+    std::swap(strides[ndim - 1], strides[ndim - 2]);
+
+    if (a.size() > 1) {
+      flags.row_contiguous = false;
+      if (ndim > 2) {
+        flags.col_contiguous = false;
+      } else {
+        flags.col_contiguous = true;
+      }
+    }
+    vectors.set_data(
+        allocator::malloc(vectors.nbytes()), vectors.size(), strides, flags);
+  }
+  switch (a.dtype()) {
+    case float32:
+      eig_impl<float>(a_copy, vectors, values, compute_eigenvectors_, stream());
+      break;
+    default:
+      throw std::runtime_error("[Eig::eval_cpu] only supports float32.");
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d457c1fd9940dfc0b1c58b680cc34a03ee7f788c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/eigh.cpp
@@ -0,0 +1,241 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/allocator.h"
+#include "mlx/array.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/lapack.h"
+#include "mlx/linalg.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+namespace {
+
+template <typename T, class Enable = void>
+struct EighWork {};
+
+template <typename T>
+struct EighWork<
+    T,
+    typename std::enable_if<std::is_floating_point<T>::value>::type> {
+  using R = T;
+
+  char jobz;
+  char uplo;
+  int N;
+  int lwork;
+  int liwork;
+  int info;
+  std::vector<array::Data> buffers;
+
+  EighWork(char jobz_, char uplo_, int N_)
+      : jobz(jobz_), uplo(uplo_), N(N_), lwork(-1), liwork(-1) {
+    T work;
+    int iwork;
+    syevd<T>(
+        &jobz,
+        &uplo,
+        &N,
+        nullptr,
+        &N,
+        nullptr,
+        &work,
+        &lwork,
+        &iwork,
+        &liwork,
+        &info);
+    lwork = static_cast<int>(work);
+    liwork = iwork;
+    buffers.emplace_back(allocator::malloc(sizeof(T) * lwork));
+    buffers.emplace_back(allocator::malloc(sizeof(int) * liwork));
+  }
+
+  void run(T* vectors, T* values) {
+    syevd<T>(
+        &jobz,
+        &uplo,
+        &N,
+        vectors,
+        &N,
+        values,
+        static_cast<T*>(buffers[0].buffer.raw_ptr()),
+        &lwork,
+        static_cast<int*>(buffers[1].buffer.raw_ptr()),
+        &liwork,
+        &info);
+  }
+};
+
+template <>
+struct EighWork<std::complex<float>> {
+  using T = std::complex<float>;
+  using R = float;
+
+  char jobz;
+  char uplo;
+  int N;
+  int lwork;
+  int lrwork;
+  int liwork;
+  int info;
+  std::vector<array::Data> buffers;
+
+  EighWork(char jobz_, char uplo_, int N_)
+      : jobz(jobz_), uplo(uplo_), N(N_), lwork(-1), lrwork(-1), liwork(-1) {
+    T work;
+    R rwork;
+    int iwork;
+    heevd<T>(
+        &jobz,
+        &uplo,
+        &N,
+        nullptr,
+        &N,
+        nullptr,
+        &work,
+        &lwork,
+        &rwork,
+        &lrwork,
+        &iwork,
+        &liwork,
+        &info);
+    lwork = static_cast<int>(work.real());
+    lrwork = static_cast<int>(rwork);
+    liwork = iwork;
+    buffers.emplace_back(allocator::malloc(sizeof(T) * lwork));
+    buffers.emplace_back(allocator::malloc(sizeof(R) * lrwork));
+    buffers.emplace_back(allocator::malloc(sizeof(int) * liwork));
+  }
+
+  void run(T* vectors, R* values) {
+    heevd<T>(
+        &jobz,
+        &uplo,
+        &N,
+        vectors,
+        &N,
+        values,
+        static_cast<T*>(buffers[0].buffer.raw_ptr()),
+        &lwork,
+        static_cast<R*>(buffers[1].buffer.raw_ptr()),
+        &lrwork,
+        static_cast<int*>(buffers[2].buffer.raw_ptr()),
+        &liwork,
+        &info);
+    if (jobz == 'V') {
+      // We have pre-transposed the vectors but we also must conjugate them
+      // when they are complex.
+      //
+      // We could vectorize this but it is so fast in comparison to heevd that
+      // it doesn't really matter.
+      for (int i = 0; i < N; i++) {
+        for (int j = 0; j < N; j++) {
+          *vectors = std::conj(*vectors);
+          vectors++;
+        }
+      }
+    }
+  }
+};
+
+template <typename T>
+void eigh_impl(
+    array& vectors,
+    array& values,
+    const std::string& uplo,
+    bool compute_eigenvectors,
+    Stream stream) {
+  using R = typename EighWork<T>::R;
+
+  auto vec_ptr = vectors.data<T>();
+  auto eig_ptr = values.data<R>();
+  char jobz = compute_eigenvectors ? 'V' : 'N';
+
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_output_array(vectors);
+  encoder.set_output_array(values);
+  encoder.dispatch([vec_ptr,
+                    eig_ptr,
+                    jobz,
+                    uplo = uplo[0],
+                    N = vectors.shape(-1),
+                    size = vectors.size()]() mutable {
+    // Work query
+    EighWork<T> work(jobz, uplo, N);
+
+    // Work loop
+    for (size_t i = 0; i < size / (N * N); ++i) {
+      work.run(vec_ptr, eig_ptr);
+      vec_ptr += N * N;
+      eig_ptr += N;
+      if (work.info != 0) {
+        std::stringstream msg;
+        msg << "[Eigh::eval_cpu] Eigenvalue decomposition failed with error code "
+            << work.info;
+        throw std::runtime_error(msg.str());
+      }
+    }
+  });
+  if (!compute_eigenvectors) {
+    encoder.add_temporary(vectors);
+  }
+}
+
+} // namespace
+
+void Eigh::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  const auto& a = inputs[0];
+  auto& values = outputs[0];
+
+  auto vectors = compute_eigenvectors_
+      ? outputs[1]
+      : array(a.shape(), a.dtype(), nullptr, {});
+
+  values.set_data(allocator::malloc(values.nbytes()));
+
+  copy_cpu(
+      a,
+      vectors,
+      a.flags().row_contiguous ? CopyType::Vector : CopyType::General,
+      stream());
+
+  if (compute_eigenvectors_) {
+    // Set the strides and flags so the eigenvectors
+    // are in the columns of the output
+    auto flags = vectors.flags();
+    auto strides = vectors.strides();
+    auto ndim = a.ndim();
+    std::swap(strides[ndim - 1], strides[ndim - 2]);
+
+    if (a.size() > 1) {
+      flags.row_contiguous = false;
+      if (ndim > 2) {
+        flags.col_contiguous = false;
+      } else {
+        flags.col_contiguous = true;
+      }
+    }
+    vectors.copy_shared_buffer(vectors, strides, flags, vectors.data_size());
+  }
+  switch (a.dtype()) {
+    case float32:
+      eigh_impl<float>(vectors, values, uplo_, compute_eigenvectors_, stream());
+      break;
+    case float64:
+      eigh_impl<double>(
+          vectors, values, uplo_, compute_eigenvectors_, stream());
+      break;
+    case complex64:
+      eigh_impl<std::complex<float>>(
+          vectors, values, uplo_, compute_eigenvectors_, stream());
+      break;
+    default:
+      throw std::runtime_error(
+          "[Eigh::eval_cpu] only supports float32 or float64.");
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f3fedefc330b5aa22cb7eecf9deab81083c6dd15
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.cpp
@@ -0,0 +1,16 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cpu/encoder.h"
+
+namespace mlx::core::cpu {
+
+CommandEncoder& get_command_encoder(Stream stream) {
+  static std::unordered_map<int, CommandEncoder> encoder_map;
+  auto it = encoder_map.find(stream.index);
+  if (it == encoder_map.end()) {
+    it = encoder_map.emplace(stream.index, stream).first;
+  }
+  return it->second;
+}
+
+} // namespace mlx::core::cpu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
new file mode 100644
index 0000000000000000000000000000000000000000..b8e33ca81050e64b97407d4ee78851a5cd7c44cc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/encoder.h
@@ -0,0 +1,67 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include <unordered_map>
+
+#include "mlx/array.h"
+#include "mlx/scheduler.h"
+
+namespace mlx::core::cpu {
+
+// Number of dispatches per scheduler task
+constexpr int DISPATCHES_PER_TASK = 10;
+
+struct CommandEncoder {
+  CommandEncoder(Stream stream) : stream_(stream) {}
+
+  CommandEncoder(const CommandEncoder&) = delete;
+  CommandEncoder& operator=(const CommandEncoder&) = delete;
+  CommandEncoder(CommandEncoder&&) = delete;
+  CommandEncoder& operator=(CommandEncoder&&) = delete;
+
+  void set_input_array(const array& a) {}
+  void set_output_array(array& a) {}
+
+  // Hold onto a temporary until any already scheduled tasks which use it as
+  // an input are complete.
+  void add_temporary(array arr) {
+    temporaries_.push_back(std::move(arr));
+  }
+
+  void add_temporaries(std::vector<array> arrays) {
+    temporaries_.insert(
+        temporaries_.end(),
+        std::make_move_iterator(arrays.begin()),
+        std::make_move_iterator(arrays.end()));
+  }
+
+  std::vector<array>& temporaries() {
+    return temporaries_;
+  }
+
+  template <class F, class... Args>
+  void dispatch(F&& f, Args&&... args) {
+    num_ops_ = (num_ops_ + 1) % DISPATCHES_PER_TASK;
+    auto task = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
+    if (num_ops_ == 0) {
+      scheduler::notify_new_task(stream_);
+      auto task_wrap = [s = stream_, task = std::move(task)]() mutable {
+        task();
+        scheduler::notify_task_completion(s);
+      };
+      scheduler::enqueue(stream_, std::move(task_wrap));
+    } else {
+      scheduler::enqueue(stream_, std::move(task));
+    }
+  }
+
+ private:
+  Stream stream_;
+  std::vector<array> temporaries_;
+  int num_ops_{0};
+};
+
+CommandEncoder& get_command_encoder(Stream stream);
+
+} // namespace mlx::core::cpu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b23c8d56180a75dd506886bfb7c82704f7edc942
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.cpp
@@ -0,0 +1,40 @@
+// Copyright © 2025 Apple Inc.
+#include "mlx/backend/cpu/eval.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/primitives.h"
+#include "mlx/scheduler.h"
+#include "mlx/utils.h"
+
+namespace mlx::core::cpu {
+
+void eval(array& arr) {
+  auto s = arr.primitive().stream();
+
+  auto outputs = arr.outputs();
+  {
+    // If the array is a tracer hold a reference
+    // to its inputs so they don't get donated
+    std::vector<array> inputs;
+    if (arr.is_tracer()) {
+      inputs = arr.inputs();
+    }
+    arr.primitive().eval_cpu(arr.inputs(), outputs);
+  }
+
+  std::unordered_set<std::shared_ptr<array::Data>> buffers;
+  for (auto& in : arr.inputs()) {
+    buffers.insert(in.data_shared_ptr());
+  }
+  for (auto& s : arr.siblings()) {
+    buffers.insert(s.data_shared_ptr());
+  }
+  // Remove the output if it was donated to by an input
+  if (auto it = buffers.find(arr.data_shared_ptr()); it != buffers.end()) {
+    buffers.erase(it);
+  }
+  auto& encoder = cpu::get_command_encoder(s);
+  encoder.dispatch([buffers = std::move(buffers),
+                    temps = std::move(encoder.temporaries())]() {});
+}
+
+} // namespace mlx::core::cpu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.h
new file mode 100644
index 0000000000000000000000000000000000000000..20156d61baac4a94273b5b2793bd17009c7d2b25
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/eval.h
@@ -0,0 +1,12 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+#include "mlx/stream.h"
+
+namespace mlx::core::cpu {
+
+void eval(array& arr);
+
+} // namespace mlx::core::cpu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d9e5f80501de849627bdfe71f8468bf3f4d14300
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/fft.cpp
@@ -0,0 +1,120 @@
+// Copyright © 2023 Apple Inc.
+
+#include <numeric>
+
+#include "mlx/3rdparty/pocketfft.h"
+#include "mlx/allocator.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+void FFT::eval_cpu(const std::vector<array>& inputs, array& out) {
+  auto& in = inputs[0];
+  std::vector<std::ptrdiff_t> strides_in(
+      in.strides().begin(), in.strides().end());
+  for (auto& s : strides_in) {
+    s *= in.itemsize();
+  }
+  std::vector<std::ptrdiff_t> strides_out(
+      out.strides().begin(), out.strides().end());
+  for (auto& s : strides_out) {
+    s *= out.itemsize();
+  }
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  std::vector<size_t> shape;
+  if (out.dtype() == float32) {
+    shape.insert(shape.end(), out.shape().begin(), out.shape().end());
+  } else {
+    shape.insert(shape.end(), in.shape().begin(), in.shape().end());
+  }
+
+  float scale = 1.0f;
+  if (inverse_) {
+    size_t nelem = std::accumulate(
+        axes_.begin(), axes_.end(), 1, [&shape](auto x, auto y) {
+          return x * shape[y];
+        });
+    scale /= nelem;
+  }
+
+  auto& encoder = cpu::get_command_encoder(stream());
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+
+  if (in.dtype() == complex64 && out.dtype() == complex64) {
+    auto in_ptr =
+        reinterpret_cast<const std::complex<float>*>(in.data<complex64_t>());
+    auto out_ptr =
+        reinterpret_cast<std::complex<float>*>(out.data<complex64_t>());
+    encoder.dispatch([shape = std::move(shape),
+                      strides_in = std::move(strides_in),
+                      strides_out = std::move(strides_out),
+                      axes = axes_,
+                      inverse = inverse_,
+                      in_ptr,
+                      out_ptr,
+                      scale]() {
+      pocketfft::c2c(
+          shape,
+          strides_in,
+          strides_out,
+          axes,
+          !inverse,
+          in_ptr,
+          out_ptr,
+          scale);
+    });
+  } else if (in.dtype() == float32 && out.dtype() == complex64) {
+    auto in_ptr = in.data<float>();
+    auto out_ptr =
+        reinterpret_cast<std::complex<float>*>(out.data<complex64_t>());
+    encoder.dispatch([shape = std::move(shape),
+                      strides_in = std::move(strides_in),
+                      strides_out = std::move(strides_out),
+                      axes = axes_,
+                      inverse = inverse_,
+                      in_ptr,
+                      out_ptr,
+                      scale]() {
+      pocketfft::r2c(
+          shape,
+          strides_in,
+          strides_out,
+          axes,
+          !inverse,
+          in_ptr,
+          out_ptr,
+          scale);
+    });
+  } else if (in.dtype() == complex64 && out.dtype() == float32) {
+    auto in_ptr =
+        reinterpret_cast<const std::complex<float>*>(in.data<complex64_t>());
+    auto out_ptr = out.data<float>();
+    encoder.dispatch([shape = std::move(shape),
+                      strides_in = std::move(strides_in),
+                      strides_out = std::move(strides_out),
+                      axes = axes_,
+                      inverse = inverse_,
+                      in_ptr,
+                      out_ptr,
+                      scale]() {
+      pocketfft::c2r(
+          shape,
+          strides_in,
+          strides_out,
+          axes,
+          !inverse,
+          in_ptr,
+          out_ptr,
+          scale);
+    });
+  } else {
+    throw std::runtime_error(
+        "[FFT] Received unexpected input and output type combination.");
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h
new file mode 100644
index 0000000000000000000000000000000000000000..d665cb91ffe037f3ef07422abbfcdff5fb4c25bb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/gemm.h
@@ -0,0 +1,26 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+template <typename T>
+void matmul(
+    const T* a,
+    const T* b,
+    T* out,
+    bool a_transposed,
+    bool b_transposed,
+    size_t lda,
+    size_t ldb,
+    size_t ldc,
+    float alpha,
+    float beta,
+    size_t batch_size,
+    const Shape& a_shape,
+    const Strides& a_strides,
+    const Shape& b_shape,
+    const Strides& b_strides);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/bnns.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/bnns.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0ba7a9b8cf09006f75e1e8bcf7899158110e5830
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/bnns.cpp
@@ -0,0 +1,209 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <Accelerate/Accelerate.h>
+
+#include "mlx/array.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/gemm.h"
+#include "mlx/dtype.h"
+
+namespace mlx::core {
+
+template <typename T>
+constexpr BNNSDataType to_bnns_dtype();
+
+template <>
+constexpr BNNSDataType to_bnns_dtype<float>() {
+  return BNNSDataType(BNNSDataTypeFloatBit | 32);
+}
+template <>
+constexpr BNNSDataType to_bnns_dtype<float16_t>() {
+  return BNNSDataType(BNNSDataTypeFloatBit | 16);
+}
+
+template <>
+constexpr BNNSDataType to_bnns_dtype<bfloat16_t>() {
+  return BNNSDataTypeBFloat16;
+}
+
+template <typename T>
+void matmul_bnns(
+    const T* a,
+    const T* b,
+    T* out,
+    bool a_transposed,
+    bool b_transposed,
+    size_t lda,
+    size_t ldb,
+    size_t ldc,
+    float alpha,
+    float beta,
+    size_t batch_size,
+    const Shape& a_shape,
+    const Strides& a_strides,
+    const Shape& b_shape,
+    const Strides& b_strides) {
+  auto ndim = a_shape.size();
+  size_t M = a_shape[ndim - 2];
+  size_t N = b_shape[ndim - 1];
+  size_t K = a_shape[ndim - 1];
+
+  BNNSDataType bnns_dtype = to_bnns_dtype<T>();
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+  const BNNSLayerParametersBroadcastMatMul gemm_params{
+      /* float alpha = */ alpha,
+      /* float beta = */ beta,
+      /* bool transA = */ a_transposed,
+      /* bool transB = */ b_transposed,
+      /* bool quadratic = */ false,
+      /* bool a_is_weights = */ false,
+      /* bool b_is_weights = */ false,
+      /* BNNSNDArrayDescriptor iA_desc = */
+      BNNSNDArrayDescriptor{
+          /* BNNSNDArrayFlags flags = */ BNNSNDArrayFlagBackpropSet,
+          /* BNNSDataLayout layout = */ BNNSDataLayoutRowMajorMatrix,
+
+          /* size_t size[BNNS_MAX_TENSOR_DIMENSION] = */
+          {lda, (M * K) / lda, 0, 0, 0, 0, 0, 0},
+          /* size_t stride[BNNS_MAX_TENSOR_DIMENSION] = */
+          {1, lda, 0, 0, 0, 0, 0, 0},
+
+          /* void * _Nullable data = */ nullptr,
+          /* BNNSDataType data_type = */ bnns_dtype,
+
+          /* void * _Nullable table_data = */ nullptr,
+          /* BNNSDataType table_data_type = */ bnns_dtype,
+
+          /* float data_scale = */ 1.0,
+          /* float data_bias = */ 0.0,
+      },
+      /* BNNSNDArrayDescriptor iB_desc = */
+      BNNSNDArrayDescriptor{
+          /* BNNSNDArrayFlags flags = */ BNNSNDArrayFlagBackpropSet,
+          /* BNNSDataLayout layout = */ BNNSDataLayoutRowMajorMatrix,
+
+          /* size_t size[BNNS_MAX_TENSOR_DIMENSION] = */
+          {ldb, (K * N) / ldb, 0, 0, 0, 0, 0, 0},
+          /* size_t stride[BNNS_MAX_TENSOR_DIMENSION] = */
+          {1, ldb, 0, 0, 0, 0, 0, 0},
+
+          /* void * _Nullable data = */ nullptr,
+          /* BNNSDataType data_type = */ bnns_dtype,
+
+          /* void * _Nullable table_data = */ nullptr,
+          /* BNNSDataType table_data_type = */ bnns_dtype,
+
+          /* float data_scale = */ 1.0,
+          /* float data_bias = */ 0.0,
+      },
+      /* BNNSNDArrayDescriptor o_desc = */
+      BNNSNDArrayDescriptor{
+          /* BNNSNDArrayFlags flags = */ BNNSNDArrayFlagBackpropSet,
+          /* BNNSDataLayout layout = */ BNNSDataLayoutRowMajorMatrix,
+
+          /* size_t size[BNNS_MAX_TENSOR_DIMENSION] = */
+          {N, M, 0, 0, 0, 0, 0, 0},
+          /* size_t stride[BNNS_MAX_TENSOR_DIMENSION] = */
+          {1, N, 0, 0, 0, 0, 0, 0},
+
+          /* void * _Nullable data = */ nullptr,
+          /* BNNSDataType data_type = */ bnns_dtype,
+
+          /* void * _Nullable table_data = */ nullptr,
+          /* BNNSDataType table_data_type = */ bnns_dtype,
+
+          /* float data_scale = */ 1.0,
+          /* float data_bias = */ 0.0,
+      },
+  };
+
+  auto bnns_filter =
+      BNNSFilterCreateLayerBroadcastMatMul(&gemm_params, nullptr);
+
+  for (int i = 0; i < batch_size; ++i) {
+    BNNSFilterApplyTwoInput(
+        bnns_filter,
+        reinterpret_cast<const uint8_t*>(
+            a + elem_to_loc(M * K * i, a_shape, a_strides)),
+        reinterpret_cast<const uint8_t*>(
+            b + elem_to_loc(K * N * i, b_shape, b_strides)),
+        reinterpret_cast<uint8_t*>(out + M * N * i));
+  }
+
+  BNNSFilterDestroy(bnns_filter);
+#pragma GCC diagnostic pop
+}
+
+template <>
+void matmul<float16_t>(
+    const float16_t* a,
+    const float16_t* b,
+    float16_t* out,
+    bool a_transposed,
+    bool b_transposed,
+    size_t lda,
+    size_t ldb,
+    size_t ldc,
+    float alpha,
+    float beta,
+    size_t batch_size,
+    const Shape& a_shape,
+    const Strides& a_strides,
+    const Shape& b_shape,
+    const Strides& b_strides) {
+  matmul_bnns(
+      a,
+      b,
+      out,
+      a_transposed,
+      b_transposed,
+      lda,
+      ldb,
+      ldc,
+      alpha,
+      beta,
+      batch_size,
+      a_shape,
+      a_strides,
+      b_shape,
+      b_strides);
+}
+
+template <>
+void matmul<bfloat16_t>(
+    const bfloat16_t* a,
+    const bfloat16_t* b,
+    bfloat16_t* out,
+    bool a_transposed,
+    bool b_transposed,
+    size_t lda,
+    size_t ldb,
+    size_t ldc,
+    float alpha,
+    float beta,
+    size_t batch_size,
+    const Shape& a_shape,
+    const Strides& a_strides,
+    const Shape& b_shape,
+    const Strides& b_strides) {
+  matmul_bnns(
+      a,
+      b,
+      out,
+      a_transposed,
+      b_transposed,
+      lda,
+      ldb,
+      ldc,
+      alpha,
+      beta,
+      batch_size,
+      a_shape,
+      a_strides,
+      b_shape,
+      b_strides);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..765e9f539ac13f19b6bac9da635afc4d26faf195
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/cblas.cpp
@@ -0,0 +1,134 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/gemm.h"
+#include "mlx/backend/cpu/lapack.h"
+
+namespace mlx::core {
+
+template <>
+void matmul<float>(
+    const float* a,
+    const float* b,
+    float* out,
+    bool a_transposed,
+    bool b_transposed,
+    size_t lda,
+    size_t ldb,
+    size_t ldc,
+    float alpha,
+    float beta,
+    size_t batch_size,
+    const Shape& a_shape,
+    const Strides& a_strides,
+    const Shape& b_shape,
+    const Strides& b_strides) {
+  auto ndim = a_shape.size();
+  size_t M = a_shape[ndim - 2];
+  size_t N = b_shape[ndim - 1];
+  size_t K = a_shape[ndim - 1];
+
+  for (int i = 0; i < batch_size; ++i) {
+    cblas_sgemm(
+        CblasRowMajor,
+        a_transposed ? CblasTrans : CblasNoTrans, // transA
+        b_transposed ? CblasTrans : CblasNoTrans, // transB
+        M,
+        N,
+        K,
+        alpha,
+        a + elem_to_loc(M * K * i, a_shape, a_strides),
+        lda,
+        b + elem_to_loc(K * N * i, b_shape, b_strides),
+        ldb,
+        beta,
+        out + M * N * i,
+        ldc);
+  }
+}
+
+template <>
+void matmul<double>(
+    const double* a,
+    const double* b,
+    double* out,
+    bool a_transposed,
+    bool b_transposed,
+    size_t lda,
+    size_t ldb,
+    size_t ldc,
+    float alpha,
+    float beta,
+    size_t batch_size,
+    const Shape& a_shape,
+    const Strides& a_strides,
+    const Shape& b_shape,
+    const Strides& b_strides) {
+  auto ndim = a_shape.size();
+  size_t M = a_shape[ndim - 2];
+  size_t N = b_shape[ndim - 1];
+  size_t K = a_shape[ndim - 1];
+
+  for (int i = 0; i < batch_size; ++i) {
+    cblas_dgemm(
+        CblasRowMajor,
+        a_transposed ? CblasTrans : CblasNoTrans, // transA
+        b_transposed ? CblasTrans : CblasNoTrans, // transB
+        M,
+        N,
+        K,
+        alpha,
+        a + elem_to_loc(M * K * i, a_shape, a_strides),
+        lda,
+        b + elem_to_loc(K * N * i, b_shape, b_strides),
+        ldb,
+        beta,
+        out + M * N * i,
+        ldc);
+  }
+}
+
+template <>
+void matmul<complex64_t>(
+    const complex64_t* a,
+    const complex64_t* b,
+    complex64_t* out,
+    bool a_transposed,
+    bool b_transposed,
+    size_t lda,
+    size_t ldb,
+    size_t ldc,
+    float alpha,
+    float beta,
+    size_t batch_size,
+    const Shape& a_shape,
+    const Strides& a_strides,
+    const Shape& b_shape,
+    const Strides& b_strides) {
+  auto ndim = a_shape.size();
+  size_t M = a_shape[ndim - 2];
+  size_t N = b_shape[ndim - 1];
+  size_t K = a_shape[ndim - 1];
+  auto calpha = static_cast<complex64_t>(alpha);
+  auto cbeta = static_cast<complex64_t>(beta);
+
+  for (int i = 0; i < batch_size; ++i) {
+    cblas_cgemm(
+        CblasRowMajor,
+        a_transposed ? CblasTrans : CblasNoTrans, // transA
+        b_transposed ? CblasTrans : CblasNoTrans, // transB
+        M,
+        N,
+        K,
+        &calpha,
+        a + elem_to_loc(M * K * i, a_shape, a_strides),
+        lda,
+        b + elem_to_loc(K * N * i, b_shape, b_strides),
+        ldb,
+        &cbeta,
+        out + M * N * i,
+        ldc);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..58f5964b6ec91853db81cce1ae2b823942dcc554
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_bf16.cpp
@@ -0,0 +1,45 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/gemm.h"
+#include "mlx/backend/cpu/gemms/simd_gemm.h"
+
+namespace mlx::core {
+
+template <>
+void matmul<bfloat16_t>(
+    const bfloat16_t* a,
+    const bfloat16_t* b,
+    bfloat16_t* out,
+    bool a_transposed,
+    bool b_transposed,
+    size_t lda,
+    size_t ldb,
+    size_t ldc,
+    float alpha,
+    float beta,
+    size_t batch_size,
+    const Shape& a_shape,
+    const Strides& a_strides,
+    const Shape& b_shape,
+    const Strides& b_strides) {
+  auto ndim = a_shape.size();
+  size_t M = a_shape[ndim - 2];
+  size_t N = b_shape[ndim - 1];
+  size_t K = a_shape[ndim - 1];
+  for (int i = 0; i < batch_size; ++i) {
+    simd_gemm<bfloat16_t, float>(
+        a + elem_to_loc(M * K * i, a_shape, a_strides),
+        b + elem_to_loc(K * N * i, b_shape, b_strides),
+        out + M * N * i,
+        a_transposed,
+        b_transposed,
+        M,
+        N,
+        K,
+        alpha,
+        beta);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..93467da8683707c6cb23db37a1021b5e26dbf2f2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_fp16.cpp
@@ -0,0 +1,45 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/gemm.h"
+#include "mlx/backend/cpu/gemms/simd_gemm.h"
+
+namespace mlx::core {
+
+template <>
+void matmul<float16_t>(
+    const float16_t* a,
+    const float16_t* b,
+    float16_t* out,
+    bool a_transposed,
+    bool b_transposed,
+    size_t lda,
+    size_t ldb,
+    size_t ldc,
+    float alpha,
+    float beta,
+    size_t batch_size,
+    const Shape& a_shape,
+    const Strides& a_strides,
+    const Shape& b_shape,
+    const Strides& b_strides) {
+  auto ndim = a_shape.size();
+  size_t M = a_shape[ndim - 2];
+  size_t N = b_shape[ndim - 1];
+  size_t K = a_shape[ndim - 1];
+  for (int i = 0; i < batch_size; ++i) {
+    simd_gemm<float16_t, float>(
+        a + elem_to_loc(M * K * i, a_shape, a_strides),
+        b + elem_to_loc(K * N * i, b_shape, b_strides),
+        out + M * N * i,
+        a_transposed,
+        b_transposed,
+        M,
+        N,
+        K,
+        alpha,
+        beta);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_gemm.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_gemm.h
new file mode 100644
index 0000000000000000000000000000000000000000..a23c7dea33702e5c96f1a67c17d37acf5eaee01f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/gemms/simd_gemm.h
@@ -0,0 +1,139 @@
+// Copyright © 2025 Apple Inc.
+#pragma once
+
+#include "mlx/backend/cpu/simd/simd.h"
+
+namespace mlx::core {
+
+inline int ceildiv(int a, int b) {
+  return (a + b - 1) / b;
+}
+
+template <int block_size, typename T, typename AccT>
+void load_block(
+    const T* in,
+    AccT* out,
+    int M,
+    int N,
+    int i,
+    int j,
+    bool transpose) {
+  if (transpose) {
+    for (int ii = 0; ii < block_size && i * block_size + ii < M; ++ii) {
+      for (int jj = 0; jj < block_size && j * block_size + jj < N; ++jj) {
+        out[jj * block_size + ii] =
+            in[(i * block_size + ii) * N + j * block_size + jj];
+      }
+    }
+  } else {
+    for (int ii = 0; ii < block_size && i * block_size + ii < M; ++ii) {
+      for (int jj = 0; jj < block_size && j * block_size + jj < N; ++jj) {
+        out[ii * block_size + jj] =
+            in[(i * block_size + ii) * N + j * block_size + jj];
+      }
+    }
+  }
+}
+
+template <typename T, typename AccT>
+void simd_gemm(
+    const T* a,
+    const T* b,
+    T* c,
+    bool a_trans,
+    bool b_trans,
+    int M,
+    int N,
+    int K,
+    float alpha,
+    float beta) {
+  constexpr int block_size = 16;
+  constexpr int simd_size = simd::max_size<AccT>;
+  static_assert(
+      (block_size % simd_size) == 0,
+      "Block size must be divisible by SIMD size");
+
+  int last_k_block_size = K - block_size * (K / block_size);
+  int last_k_simd_block = (last_k_block_size / simd_size) * simd_size;
+  for (int i = 0; i < ceildiv(M, block_size); i++) {
+    for (int j = 0; j < ceildiv(N, block_size); j++) {
+      AccT c_block[block_size * block_size] = {0.0};
+      AccT a_block[block_size * block_size];
+      AccT b_block[block_size * block_size];
+
+      int k = 0;
+      for (; k < K / block_size; k++) {
+        // Load a and b blocks
+        if (a_trans) {
+          load_block<block_size>(a, a_block, K, M, k, i, true);
+        } else {
+          load_block<block_size>(a, a_block, M, K, i, k, false);
+        }
+        if (b_trans) {
+          load_block<block_size>(b, b_block, N, K, j, k, false);
+        } else {
+          load_block<block_size>(b, b_block, K, N, k, j, true);
+        }
+
+        // Multiply and accumulate
+        for (int ii = 0; ii < block_size && i * block_size + ii < M; ++ii) {
+          for (int jj = 0; jj < block_size && j * block_size + jj < N; ++jj) {
+            for (int kk = 0; kk < block_size; kk += simd_size) {
+              auto av =
+                  simd::load<AccT, simd_size>(a_block + ii * block_size + kk);
+              auto bv =
+                  simd::load<AccT, simd_size>(b_block + jj * block_size + kk);
+              c_block[ii * block_size + jj] += simd::sum(av * bv);
+            }
+          }
+        }
+      }
+      if (last_k_block_size) {
+        // Load a and b blocks
+        if (a_trans) {
+          load_block<block_size>(a, a_block, K, M, k, i, true);
+        } else {
+          load_block<block_size>(a, a_block, M, K, i, k, false);
+        }
+        if (b_trans) {
+          load_block<block_size>(b, b_block, N, K, j, k, false);
+        } else {
+          load_block<block_size>(b, b_block, K, N, k, j, true);
+        }
+
+        // Multiply and accumulate
+        for (int ii = 0; ii < block_size && i * block_size + ii < M; ++ii) {
+          for (int jj = 0; jj < block_size && j * block_size + jj < N; ++jj) {
+            int kk = 0;
+            for (; kk < last_k_simd_block; kk += simd_size) {
+              auto av =
+                  simd::load<AccT, simd_size>(a_block + ii * block_size + kk);
+              auto bv =
+                  simd::load<AccT, simd_size>(b_block + jj * block_size + kk);
+              c_block[ii * block_size + jj] += simd::sum(av * bv);
+            }
+            for (; kk < last_k_block_size; ++kk) {
+              c_block[ii * block_size + jj] +=
+                  a_block[ii * block_size + kk] * b_block[jj * block_size + kk];
+            }
+          }
+        }
+      }
+
+      // Store
+      for (int ii = 0; ii < block_size && i * block_size + ii < M; ++ii) {
+        for (int jj = 0; jj < block_size && j * block_size + jj < N; ++jj) {
+          auto c_idx = (i * block_size + ii) * N + j * block_size + jj;
+          if (beta != 0) {
+            c[c_idx] = static_cast<T>(
+                alpha * c_block[ii * block_size + jj] + beta * c[c_idx]);
+          } else {
+            c[c_idx] = static_cast<T>(alpha * c_block[ii * block_size + jj]);
+          }
+        }
+      }
+    }
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bf7e1dc261643028d0e9d501907b57d02aae4013
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/hadamard.cpp
@@ -0,0 +1,121 @@
+// Copyright © 2024 Apple Inc.
+
+#include <cassert>
+
+#include "mlx/backend/common/hadamard.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+// n = 2^k component
+template <typename T>
+void hadamard_n(T* out, int n, int m, float scale, size_t size) {
+  for (int b = 0; b < size / n; b++) {
+    size_t loc = b * n;
+    T* data_ptr = out + loc;
+    int h = 1;
+    int n_over_2 = n / 2;
+    while (h < n) {
+      for (int i = 0; i < n / 2; i++) {
+        int k = i & (h - 1);
+        int j = ((i - k) << 1) + k;
+        float x = *(data_ptr + j);
+        float y = *(data_ptr + j + h);
+        *(data_ptr + j) = x + y;
+        *(data_ptr + j + h) = x - y;
+        if (h == n_over_2) {
+          *(data_ptr + j) *= scale;
+          *(data_ptr + j + h) *= scale;
+        }
+      }
+      h <<= 1;
+    }
+  }
+}
+
+// m component
+template <typename T>
+void hadamard_m(T* out, int n, int m, float scale, size_t size) {
+  auto h_matrices = hadamard_matrices();
+  auto& matrix = h_matrices[m];
+  auto start = 1;
+  auto end = matrix.find('\n', start);
+  std::vector<bool> hmat_vec;
+  while (end != std::string_view::npos) {
+    auto row = matrix.substr(start, end - start);
+    for (int i = 0; i < row.length(); i++) {
+      hmat_vec.push_back(row[i] == '+');
+    }
+    start = end + 1;
+    end = matrix.find('\n', start);
+  }
+
+  for (int b = 0; b < size / m / n; b++) {
+    size_t loc = b * n * m;
+    T* data_ptr = out + loc;
+    for (int i = 0; i < n; i++) {
+      std::vector<float> out(m);
+      for (int j = 0; j < m; j++) {
+        for (int k = 0; k < m; k++) {
+          float x = *(data_ptr + i + k * n);
+          if (hmat_vec[k + j * m]) {
+            out[j] += x;
+          } else {
+            out[j] -= x;
+          }
+        }
+      }
+      for (int j = 0; j < m; j++) {
+        *(data_ptr + i + j * n) = out[j] * scale;
+      }
+    }
+  }
+}
+
+template <typename T>
+void hadamard(array& out, int n, int m, float scale, Stream stream) {
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_output_array(out);
+  auto out_ptr = out.data<T>();
+  encoder.dispatch([out_ptr, size = out.size(), n, m, scale]() {
+    float n_scale = m > 1 ? 1.0 : scale;
+    hadamard_n<T>(out_ptr, n, m, n_scale, size);
+    if (m > 1) {
+      hadamard_m<T>(out_ptr, n, m, scale, size);
+    }
+  });
+}
+
+void Hadamard::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+
+  // Copy input to output
+  if (in.flags().row_contiguous && in.is_donatable()) {
+    out.copy_shared_buffer(in);
+  } else {
+    copy_cpu(
+        in,
+        out,
+        in.flags().row_contiguous ? CopyType::Vector : CopyType::General,
+        stream());
+  }
+
+  int axis = out.ndim() - 1;
+  auto [n, m] = decompose_hadamard(out.shape(axis));
+
+  switch (in.dtype()) {
+    case float32:
+      return hadamard<float>(out, n, m, scale_, stream());
+    case float16:
+      return hadamard<float16_t>(out, n, m, scale_, stream());
+    case bfloat16:
+      return hadamard<bfloat16_t>(out, n, m, scale_, stream());
+    default:
+      throw std::invalid_argument("[hadamard] Unsupported type.");
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6daced6fae20f861e73d335c9b807df34fc6a385
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/indexing.cpp
@@ -0,0 +1,750 @@
+// Copyright © 2023 Apple Inc.
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+
+#include "mlx/allocator.h"
+#include "mlx/primitives.h"
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+
+namespace mlx::core {
+
+template <typename IdxT>
+inline size_t offset_neg_idx(IdxT idx, size_t size) {
+  return (idx < 0) ? idx + size : idx;
+}
+
+template <>
+inline size_t offset_neg_idx(uint32_t idx, size_t) {
+  return idx;
+}
+
+struct None {
+  template <typename T>
+  void operator()(T x, T* y) {
+    (*y) = x;
+  }
+};
+struct Sum {
+  template <typename T>
+  void operator()(T x, T* y) {
+    (*y) += x;
+  }
+};
+
+struct Prod {
+  template <typename T>
+  void operator()(T x, T* y) {
+    (*y) *= x;
+  }
+};
+
+struct Max {
+  template <typename T>
+  void operator()(T x, T* y) {
+    (*y) = (*y > x) ? *y : x;
+  }
+};
+
+struct Min {
+  template <typename T>
+  void operator()(T x, T* y) {
+    (*y) = (*y < x) ? *y : x;
+  }
+};
+
+template <typename T, typename IdxT>
+void gather(
+    const array& src,
+    const std::vector<array>& inds,
+    array& out,
+    const std::vector<int>& axes,
+    const Shape& slice_sizes) {
+  // If the array is row contiguous then we can do a contiguous copy given
+  // two conditions on the slice size:
+  // - Any number of leading ones in the slice sizes are allowed
+  // - All other slice sizes match the corresponding dimension except the
+  //   first non-singleton slice size
+  // If the array is col contiguous then the reverse is the case:
+  // - Any number of trailing ones in the slice sizes are allowed
+  // - All other slice sizes match the corresponding dimension except the
+  //   first non-singleton slice size from the end
+
+  bool can_copy = false;
+  if (src.flags().row_contiguous) {
+    can_copy = true;
+
+    // Ignore leading 1s
+    int i = 0;
+    for (; i < slice_sizes.size() && slice_sizes[i] == 1; ++i)
+      ;
+
+    // Check the remaining
+    i++;
+    for (; i < src.ndim() && can_copy; ++i) {
+      can_copy = (src.shape(i) == slice_sizes[i]);
+    }
+  } else if (src.flags().col_contiguous) {
+    can_copy = true;
+
+    // Ignore trailing 1s
+    int i = slice_sizes.size() - 1;
+    for (; i >= 0 && slice_sizes[i] == 1; --i)
+      ;
+
+    // Skip the next slice size and check the remaining
+    i--;
+    for (; i >= 0 && can_copy; --i) {
+      can_copy = (src.shape(i) == slice_sizes[i]);
+    }
+  }
+  size_t slice_size = 1;
+  for (auto s : slice_sizes) {
+    slice_size *= s;
+  }
+  size_t ind_size = slice_size == 0 ? 0 : out.size() / slice_size;
+  const T* src_ptr = src.data<T>();
+  T* dst_ptr = out.data<T>();
+
+  std::vector<ContiguousIterator> its(inds.begin(), inds.end());
+  ContiguousIterator src_it;
+  if (!can_copy && src.ndim() > 0) {
+    src_it = ContiguousIterator(slice_sizes, src.strides(), src.ndim());
+  }
+
+  size_t out_idx = 0;
+  for (int idx = 0; idx < ind_size; idx++) {
+    size_t src_idx = 0;
+    for (int ii = 0; ii < inds.size(); ++ii) {
+      auto ax = axes[ii];
+      auto idx_loc = its[ii].loc;
+      its[ii].step();
+      auto idx_val =
+          offset_neg_idx(inds[ii].data<IdxT>()[idx_loc], src.shape(ax));
+      src_idx += (idx_val * src.strides()[ax]);
+    }
+
+    if (slice_size == 1) {
+      dst_ptr[out_idx++] = src_ptr[src_idx];
+    } else if (can_copy) {
+      std::copy(
+          src_ptr + src_idx, src_ptr + src_idx + slice_size, dst_ptr + out_idx);
+      out_idx += slice_size;
+    } else {
+      for (int jj = 0; jj < slice_size; jj++) {
+        dst_ptr[out_idx++] = src_ptr[src_idx + src_it.loc];
+        src_it.step();
+      }
+      src_it.reset();
+    }
+  }
+}
+
+template <typename IdxT>
+void dispatch_gather(
+    const array& src,
+    const std::vector<array>& inds,
+    array& out,
+    const std::vector<int>& axes,
+    const Shape& size) {
+  switch (out.dtype()) {
+    case bool_:
+      gather<bool, IdxT>(src, inds, out, axes, size);
+      break;
+    case uint8:
+      gather<uint8_t, IdxT>(src, inds, out, axes, size);
+      break;
+    case uint16:
+      gather<uint16_t, IdxT>(src, inds, out, axes, size);
+      break;
+    case uint32:
+      gather<uint32_t, IdxT>(src, inds, out, axes, size);
+      break;
+    case uint64:
+      gather<uint64_t, IdxT>(src, inds, out, axes, size);
+      break;
+    case int8:
+      gather<int8_t, IdxT>(src, inds, out, axes, size);
+      break;
+    case int16:
+      gather<int16_t, IdxT>(src, inds, out, axes, size);
+      break;
+    case int32:
+      gather<int32_t, IdxT>(src, inds, out, axes, size);
+      break;
+    case int64:
+      gather<int64_t, IdxT>(src, inds, out, axes, size);
+      break;
+    case float16:
+      gather<float16_t, IdxT>(src, inds, out, axes, size);
+      break;
+    case float32:
+      gather<float, IdxT>(src, inds, out, axes, size);
+      break;
+    case float64:
+      gather<double, IdxT>(src, inds, out, axes, size);
+      break;
+    case bfloat16:
+      gather<bfloat16_t, IdxT>(src, inds, out, axes, size);
+      break;
+    case complex64:
+      gather<complex64_t, IdxT>(src, inds, out, axes, size);
+      break;
+  }
+}
+
+void Gather::eval_cpu(const std::vector<array>& inputs, array& out) {
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& src = inputs[0];
+  std::vector<array> inds;
+  for (auto it = inputs.begin() + 1; it < inputs.end(); ++it) {
+    inds.push_back(array::unsafe_weak_copy(*it));
+  }
+  auto& encoder = cpu::get_command_encoder(stream());
+  for (auto& in : inputs) {
+    encoder.set_input_array(in);
+  }
+  encoder.set_output_array(out);
+  encoder.dispatch([axes_ = axes_,
+                    slice_sizes_ = slice_sizes_,
+                    src = array::unsafe_weak_copy(src),
+                    inds = std::move(inds),
+                    out = array::unsafe_weak_copy(out)]() mutable {
+    if (inds.empty()) {
+      dispatch_gather<uint8_t>(src, inds, out, axes_, slice_sizes_);
+      return;
+    }
+
+    switch (inds[0].dtype()) {
+      case uint8:
+        dispatch_gather<uint8_t>(src, inds, out, axes_, slice_sizes_);
+        break;
+      case uint16:
+        dispatch_gather<uint16_t>(src, inds, out, axes_, slice_sizes_);
+        break;
+      case uint32:
+        dispatch_gather<uint32_t>(src, inds, out, axes_, slice_sizes_);
+        break;
+      case uint64:
+        dispatch_gather<uint64_t>(src, inds, out, axes_, slice_sizes_);
+        break;
+      case int8:
+        dispatch_gather<int8_t>(src, inds, out, axes_, slice_sizes_);
+        break;
+      case int16:
+        dispatch_gather<int16_t>(src, inds, out, axes_, slice_sizes_);
+        break;
+      case int32:
+        dispatch_gather<int32_t>(src, inds, out, axes_, slice_sizes_);
+        break;
+      case int64:
+        dispatch_gather<int64_t>(src, inds, out, axes_, slice_sizes_);
+        break;
+      default:
+        throw std::runtime_error(
+            "[Gather::eval_cpu] Cannot gather with indices type.");
+        break;
+    }
+  });
+}
+template <typename T, typename IdxT>
+void gather_axis(
+    const array& src,
+    const array& ind,
+    array& out,
+    const int axis) {
+  auto shape = remove_index(ind.shape(), axis);
+  ContiguousIterator ind_it(
+      shape, remove_index(ind.strides(), axis), src.ndim() - 1);
+  ContiguousIterator src_it(
+      shape, remove_index(src.strides(), axis), src.ndim() - 1);
+
+  auto ind_ptr = ind.data<IdxT>();
+  auto src_ptr = src.data<T>();
+  auto dst_ptr = out.data<T>();
+  auto ind_ax_stride = ind.strides(axis);
+  auto src_ax_stride = src.strides(axis);
+  auto dst_ax_stride = out.strides(axis);
+  auto ind_ax_size = ind.shape(axis);
+  auto src_ax_size = src.shape(axis);
+
+  size_t size_pre = 1;
+  size_t size_post = 1;
+  for (int i = 0; i < axis; ++i) {
+    size_pre *= ind.shape(i);
+  }
+  for (int i = axis + 1; i < ind.ndim(); ++i) {
+    size_post *= ind.shape(i);
+  }
+
+  size_t stride_pre = size_post * ind_ax_size;
+  for (size_t i = 0; i < size_pre; i++) {
+    for (size_t k = 0; k < size_post; k++) {
+      for (int j = 0; j < ind_ax_size; ++j) {
+        auto ind_val = offset_neg_idx(
+            ind_ptr[ind_it.loc + j * ind_ax_stride], src_ax_size);
+        dst_ptr[k + j * dst_ax_stride] =
+            src_ptr[src_it.loc + ind_val * src_ax_stride];
+      }
+      ind_it.step();
+      src_it.step();
+    }
+    dst_ptr += stride_pre;
+  }
+}
+
+template <typename IdxT>
+void dispatch_gather_axis(
+    const array& src,
+    const array& inds,
+    array& out,
+    const int axis) {
+  switch (out.dtype()) {
+    case bool_:
+      gather_axis<bool, IdxT>(src, inds, out, axis);
+      break;
+    case uint8:
+      gather_axis<uint8_t, IdxT>(src, inds, out, axis);
+      break;
+    case uint16:
+      gather_axis<uint16_t, IdxT>(src, inds, out, axis);
+      break;
+    case uint32:
+      gather_axis<uint32_t, IdxT>(src, inds, out, axis);
+      break;
+    case uint64:
+      gather_axis<uint64_t, IdxT>(src, inds, out, axis);
+      break;
+    case int8:
+      gather_axis<int8_t, IdxT>(src, inds, out, axis);
+      break;
+    case int16:
+      gather_axis<int16_t, IdxT>(src, inds, out, axis);
+      break;
+    case int32:
+      gather_axis<int32_t, IdxT>(src, inds, out, axis);
+      break;
+    case int64:
+      gather_axis<int64_t, IdxT>(src, inds, out, axis);
+      break;
+    case float16:
+      gather_axis<float16_t, IdxT>(src, inds, out, axis);
+      break;
+    case float32:
+      gather_axis<float, IdxT>(src, inds, out, axis);
+      break;
+    case float64:
+      gather_axis<double, IdxT>(src, inds, out, axis);
+      break;
+    case bfloat16:
+      gather_axis<bfloat16_t, IdxT>(src, inds, out, axis);
+      break;
+    case complex64:
+      gather_axis<complex64_t, IdxT>(src, inds, out, axis);
+      break;
+  }
+}
+
+void GatherAxis::eval_cpu(const std::vector<array>& inputs, array& out) {
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& src = inputs[0];
+  auto& inds = inputs[1];
+  auto& encoder = cpu::get_command_encoder(stream());
+  encoder.set_input_array(src);
+  encoder.set_input_array(inds);
+  encoder.set_output_array(out);
+  encoder.dispatch([axis_ = axis_,
+                    src = array::unsafe_weak_copy(src),
+                    inds = array::unsafe_weak_copy(inds),
+                    out = array::unsafe_weak_copy(out)]() mutable {
+    switch (inds.dtype()) {
+      case uint8:
+        dispatch_gather_axis<uint8_t>(src, inds, out, axis_);
+        break;
+      case uint16:
+        dispatch_gather_axis<uint16_t>(src, inds, out, axis_);
+        break;
+      case uint32:
+        dispatch_gather_axis<uint32_t>(src, inds, out, axis_);
+        break;
+      case uint64:
+        dispatch_gather_axis<uint64_t>(src, inds, out, axis_);
+        break;
+      case int8:
+        dispatch_gather_axis<int8_t>(src, inds, out, axis_);
+        break;
+      case int16:
+        dispatch_gather_axis<int16_t>(src, inds, out, axis_);
+        break;
+      case int32:
+        dispatch_gather_axis<int32_t>(src, inds, out, axis_);
+        break;
+      case int64:
+        dispatch_gather_axis<int64_t>(src, inds, out, axis_);
+        break;
+      default:
+        throw std::runtime_error(
+            "[GatherAxis::eval_cpu] Cannot gather with indices type.");
+        break;
+    }
+  });
+}
+
+template <typename InT, typename IdxT, typename OpT>
+void scatter(
+    const array& updates,
+    array& out,
+    const std::vector<array>& inds,
+    const std::vector<int>& axes) {
+  int nind = inds.size();
+  auto inds_ndim = updates.ndim() - out.ndim();
+  size_t n_updates = nind ? inds[0].size() : 1;
+
+  Shape update_shape(
+      updates.shape().begin() + inds_ndim, updates.shape().end());
+  size_t update_size = 1;
+  for (auto us : update_shape) {
+    update_size *= us;
+  }
+
+  std::vector<ContiguousIterator> its(inds.begin(), inds.end());
+  ContiguousIterator update_it(updates);
+  ContiguousIterator out_it(update_shape, out.strides(), out.ndim());
+
+  auto out_ptr = out.data<InT>();
+  auto upd_ptr = updates.data<InT>();
+  for (int i = 0; i < n_updates; ++i) {
+    size_t out_offset = 0;
+    for (int j = 0; j < inds.size(); ++j) {
+      auto ax = axes[j];
+      auto idx_loc = its[j].loc;
+      its[j].step();
+      auto idx_val =
+          offset_neg_idx(inds[j].data<IdxT>()[idx_loc], out.shape(ax));
+      out_offset += (idx_val * out.strides()[ax]);
+    }
+    update_it.seek(i * update_size);
+    for (int j = 0; j < update_size; ++j) {
+      OpT{}(upd_ptr[update_it.loc], out_ptr + out_offset + out_it.loc);
+      update_it.step();
+      out_it.step();
+    }
+    out_it.reset();
+    update_it.reset();
+  }
+}
+
+template <typename InT, typename IdxT>
+void dispatch_scatter_inds(
+    array& out,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    Scatter::ReduceType rtype) {
+  switch (rtype) {
+    case Scatter::None:
+      scatter<InT, IdxT, None>(updates, out, indices, axes);
+      break;
+    case Scatter::Sum:
+      scatter<InT, IdxT, Sum>(updates, out, indices, axes);
+      break;
+    case Scatter::Prod:
+      scatter<InT, IdxT, Prod>(updates, out, indices, axes);
+      break;
+    case Scatter::Max:
+      scatter<InT, IdxT, Max>(updates, out, indices, axes);
+      break;
+    case Scatter::Min:
+      scatter<InT, IdxT, Min>(updates, out, indices, axes);
+      break;
+  }
+}
+
+template <typename InT>
+void dispatch_scatter(
+    array& out,
+    const std::vector<array>& inds,
+    const array& updates,
+    const std::vector<int>& axes,
+    Scatter::ReduceType rtype) {
+  if (inds.empty()) {
+    dispatch_scatter_inds<InT, uint8_t>(out, inds, updates, axes, rtype);
+    return;
+  }
+
+  switch (inds[0].dtype()) {
+    case uint8:
+      dispatch_scatter_inds<InT, uint8_t>(out, inds, updates, axes, rtype);
+      break;
+    case uint16:
+      dispatch_scatter_inds<InT, uint16_t>(out, inds, updates, axes, rtype);
+      break;
+    case uint32:
+      dispatch_scatter_inds<InT, uint32_t>(out, inds, updates, axes, rtype);
+      break;
+    case uint64:
+      dispatch_scatter_inds<InT, uint64_t>(out, inds, updates, axes, rtype);
+      break;
+    case int8:
+      dispatch_scatter_inds<InT, int8_t>(out, inds, updates, axes, rtype);
+      break;
+    case int16:
+      dispatch_scatter_inds<InT, int16_t>(out, inds, updates, axes, rtype);
+      break;
+    case int32:
+      dispatch_scatter_inds<InT, int32_t>(out, inds, updates, axes, rtype);
+      break;
+    case int64:
+      dispatch_scatter_inds<InT, int64_t>(out, inds, updates, axes, rtype);
+      break;
+    default:
+      throw std::runtime_error(
+          "[Scatter::eval_cpu] Cannot scatter with indices type.");
+  }
+}
+
+void Scatter::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() >= 2);
+
+  auto& src = inputs[0];
+  auto& updates = inputs.back();
+
+  // Copy src into out (copy allocates memory for out)
+  auto ctype =
+      src.flags().row_contiguous ? CopyType::Vector : CopyType::General;
+  copy_cpu(src, out, ctype, stream());
+
+  auto& encoder = cpu::get_command_encoder(stream());
+  std::vector<array> inds;
+  for (auto it = inputs.begin() + 1; it < inputs.end() - 1; ++it) {
+    encoder.set_input_array(*it);
+    inds.push_back(array::unsafe_weak_copy(*it));
+  }
+  encoder.set_input_array(updates);
+  encoder.set_output_array(out);
+  encoder.dispatch([axes_ = axes_,
+                    reduce_type_ = reduce_type_,
+                    updates = array::unsafe_weak_copy(updates),
+                    inds = std::move(inds),
+                    out = array::unsafe_weak_copy(out)]() mutable {
+    switch (out.dtype()) {
+      case bool_:
+        dispatch_scatter<bool>(out, inds, updates, axes_, reduce_type_);
+        break;
+      case uint8:
+        dispatch_scatter<uint8_t>(out, inds, updates, axes_, reduce_type_);
+        break;
+      case uint16:
+        dispatch_scatter<uint16_t>(out, inds, updates, axes_, reduce_type_);
+        break;
+      case uint32:
+        dispatch_scatter<uint32_t>(out, inds, updates, axes_, reduce_type_);
+        break;
+      case uint64:
+        dispatch_scatter<uint64_t>(out, inds, updates, axes_, reduce_type_);
+        break;
+      case int8:
+        dispatch_scatter<int8_t>(out, inds, updates, axes_, reduce_type_);
+        break;
+      case int16:
+        dispatch_scatter<int16_t>(out, inds, updates, axes_, reduce_type_);
+        break;
+      case int32:
+        dispatch_scatter<int32_t>(out, inds, updates, axes_, reduce_type_);
+        break;
+      case int64:
+        dispatch_scatter<int64_t>(out, inds, updates, axes_, reduce_type_);
+        break;
+      case float16:
+        dispatch_scatter<float16_t>(out, inds, updates, axes_, reduce_type_);
+        break;
+      case float32:
+        dispatch_scatter<float>(out, inds, updates, axes_, reduce_type_);
+        break;
+      case float64:
+        dispatch_scatter<double>(out, inds, updates, axes_, reduce_type_);
+        break;
+      case bfloat16:
+        dispatch_scatter<bfloat16_t>(out, inds, updates, axes_, reduce_type_);
+        break;
+      case complex64:
+        dispatch_scatter<complex64_t>(out, inds, updates, axes_, reduce_type_);
+        break;
+    }
+  });
+}
+
+template <typename T, typename IdxT, typename OpT>
+void scatter_axis(array& out, const array idx, const array& upd, int axis) {
+  auto shape = remove_index(idx.shape(), axis);
+  ContiguousIterator idx_it(
+      shape, remove_index(idx.strides(), axis), upd.ndim() - 1);
+  ContiguousIterator upd_it(
+      shape, remove_index(upd.strides(), axis), upd.ndim() - 1);
+
+  auto idx_ptr = idx.data<IdxT>();
+  auto upd_ptr = upd.data<T>();
+  auto dst_ptr = out.data<T>();
+  auto idx_ax_stride = idx.strides(axis);
+  auto upd_ax_stride = upd.strides(axis);
+  auto dst_ax_stride = out.strides(axis);
+  auto idx_ax_size = idx.shape(axis);
+  auto dst_ax_size = out.shape(axis);
+
+  size_t size_pre = 1;
+  size_t size_post = 1;
+  for (int i = 0; i < axis; ++i) {
+    size_pre *= idx.shape(i);
+  }
+  for (int i = axis + 1; i < idx.ndim(); ++i) {
+    size_post *= idx.shape(i);
+  }
+  size_t stride_pre = size_post * dst_ax_size;
+  for (size_t i = 0; i < size_pre; i++) {
+    for (size_t k = 0; k < size_post; k++) {
+      for (int j = 0; j < idx_ax_size; ++j) {
+        auto ind_val = offset_neg_idx(
+            idx_ptr[idx_it.loc + j * idx_ax_stride], dst_ax_size);
+        OpT{}(
+            upd_ptr[upd_it.loc + j * upd_ax_stride],
+            dst_ptr + k + ind_val * dst_ax_stride);
+      }
+      idx_it.step();
+      upd_it.step();
+    }
+    dst_ptr += stride_pre;
+  }
+}
+
+template <typename InT, typename IdxT>
+void dispatch_scatter_axis_op(
+    array& out,
+    const array& idx,
+    const array& updates,
+    int axis,
+    ScatterAxis::ReduceType rtype) {
+  switch (rtype) {
+    case ScatterAxis::None:
+      scatter_axis<InT, IdxT, None>(out, idx, updates, axis);
+      break;
+    case ScatterAxis::Sum:
+      scatter_axis<InT, IdxT, Sum>(out, idx, updates, axis);
+      break;
+  }
+}
+
+template <typename InT>
+void dispatch_scatter_axis(
+    array& out,
+    const array& idx,
+    const array& updates,
+    int axis,
+    ScatterAxis::ReduceType rtype) {
+  switch (idx.dtype()) {
+    case uint8:
+      dispatch_scatter_axis_op<InT, uint8_t>(out, idx, updates, axis, rtype);
+      break;
+    case uint16:
+      dispatch_scatter_axis_op<InT, uint16_t>(out, idx, updates, axis, rtype);
+      break;
+    case uint32:
+      dispatch_scatter_axis_op<InT, uint32_t>(out, idx, updates, axis, rtype);
+      break;
+    case uint64:
+      dispatch_scatter_axis_op<InT, uint64_t>(out, idx, updates, axis, rtype);
+      break;
+    case int8:
+      dispatch_scatter_axis_op<InT, int8_t>(out, idx, updates, axis, rtype);
+      break;
+    case int16:
+      dispatch_scatter_axis_op<InT, int16_t>(out, idx, updates, axis, rtype);
+      break;
+    case int32:
+      dispatch_scatter_axis_op<InT, int32_t>(out, idx, updates, axis, rtype);
+      break;
+    case int64:
+      dispatch_scatter_axis_op<InT, int64_t>(out, idx, updates, axis, rtype);
+      break;
+    default:
+      throw std::runtime_error(
+          "[ScatterAxis::eval_cpu] Cannot scatter with indices type.");
+  }
+}
+
+void ScatterAxis::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() >= 2);
+
+  auto& src = inputs[0];
+  auto& idx = inputs[1];
+  auto& updates = inputs[2];
+
+  // Copy src into out (copy allocates memory for out)
+  auto ctype =
+      src.flags().row_contiguous ? CopyType::Vector : CopyType::General;
+  copy_cpu(src, out, ctype, stream());
+
+  auto& encoder = cpu::get_command_encoder(stream());
+  encoder.set_input_array(idx);
+  encoder.set_input_array(updates);
+  encoder.set_output_array(out);
+  encoder.dispatch([axis_ = axis_,
+                    reduce_type_ = reduce_type_,
+                    idx = array::unsafe_weak_copy(idx),
+                    updates = array::unsafe_weak_copy(updates),
+                    out = array::unsafe_weak_copy(out)]() mutable {
+    switch (out.dtype()) {
+      case bool_:
+        dispatch_scatter_axis<bool>(out, idx, updates, axis_, reduce_type_);
+        break;
+      case uint8:
+        dispatch_scatter_axis<uint8_t>(out, idx, updates, axis_, reduce_type_);
+        break;
+      case uint16:
+        dispatch_scatter_axis<uint16_t>(out, idx, updates, axis_, reduce_type_);
+        break;
+      case uint32:
+        dispatch_scatter_axis<uint32_t>(out, idx, updates, axis_, reduce_type_);
+        break;
+      case uint64:
+        dispatch_scatter_axis<uint64_t>(out, idx, updates, axis_, reduce_type_);
+        break;
+      case int8:
+        dispatch_scatter_axis<int8_t>(out, idx, updates, axis_, reduce_type_);
+        break;
+      case int16:
+        dispatch_scatter_axis<int16_t>(out, idx, updates, axis_, reduce_type_);
+        break;
+      case int32:
+        dispatch_scatter_axis<int32_t>(out, idx, updates, axis_, reduce_type_);
+        break;
+      case int64:
+        dispatch_scatter_axis<int64_t>(out, idx, updates, axis_, reduce_type_);
+        break;
+      case float16:
+        dispatch_scatter_axis<float16_t>(
+            out, idx, updates, axis_, reduce_type_);
+        break;
+      case float32:
+        dispatch_scatter_axis<float>(out, idx, updates, axis_, reduce_type_);
+        break;
+      case float64:
+        dispatch_scatter_axis<double>(out, idx, updates, axis_, reduce_type_);
+        break;
+      case bfloat16:
+        dispatch_scatter_axis<bfloat16_t>(
+            out, idx, updates, axis_, reduce_type_);
+        break;
+      case complex64:
+        dispatch_scatter_axis<complex64_t>(
+            out, idx, updates, axis_, reduce_type_);
+        break;
+    }
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ddc979daa63f9975bb6c4d72e74e407d8ebf5054
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/inverse.cpp
@@ -0,0 +1,160 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/allocator.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/lapack.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+template <typename T>
+void general_inv(T* inv, int N) {
+  int info;
+  auto ipiv = array::Data{allocator::malloc(sizeof(int) * N)};
+  // Compute LU factorization.
+  getrf<T>(
+      /* m = */ &N,
+      /* n = */ &N,
+      /* a = */ inv,
+      /* lda = */ &N,
+      /* ipiv = */ static_cast<int*>(ipiv.buffer.raw_ptr()),
+      /* info = */ &info);
+
+  if (info != 0) {
+    std::stringstream ss;
+    ss << "[Inverse::eval_cpu] LU factorization failed with error code "
+       << info;
+    throw std::runtime_error(ss.str());
+  }
+
+  static const int lwork_query = -1;
+  T workspace_size = 0;
+
+  // Compute workspace size.
+  getri<T>(
+      /* m = */ &N,
+      /* a = */ nullptr,
+      /* lda = */ &N,
+      /* ipiv = */ nullptr,
+      /* work = */ &workspace_size,
+      /* lwork = */ &lwork_query,
+      /* info = */ &info);
+
+  if (info != 0) {
+    std::stringstream ss;
+    ss << "[Inverse::eval_cpu] LU workspace calculation failed with error code "
+       << info;
+    throw std::runtime_error(ss.str());
+  }
+
+  const int lwork = workspace_size;
+  auto scratch = array::Data{allocator::malloc(sizeof(T) * lwork)};
+
+  // Compute inverse.
+  getri<T>(
+      /* m = */ &N,
+      /* a = */ inv,
+      /* lda = */ &N,
+      /* ipiv = */ static_cast<int*>(ipiv.buffer.raw_ptr()),
+      /* work = */ static_cast<T*>(scratch.buffer.raw_ptr()),
+      /* lwork = */ &lwork,
+      /* info = */ &info);
+
+  if (info != 0) {
+    std::stringstream ss;
+    ss << "[Inverse::eval_cpu] inversion failed with error code " << info;
+    throw std::runtime_error(ss.str());
+  }
+}
+
+template <typename T>
+void tri_inv(T* inv, int N, bool upper) {
+  const char uplo = upper ? 'L' : 'U';
+  const char diag = 'N';
+  int info;
+  trtri<T>(
+      /* uplo = */ &uplo,
+      /* diag = */ &diag,
+      /* N = */ &N,
+      /* a = */ inv,
+      /* lda = */ &N,
+      /* info = */ &info);
+
+  // zero out the other triangle
+  if (upper) {
+    for (int i = 0; i < N; i++) {
+      std::fill(inv, inv + i, 0.0f);
+      inv += N;
+    }
+  } else {
+    for (int i = 0; i < N; i++) {
+      std::fill(inv + i + 1, inv + N, 0.0f);
+      inv += N;
+    }
+  }
+
+  if (info != 0) {
+    std::stringstream ss;
+    ss << "[Inverse::eval_cpu] triangular inversion failed with error code "
+       << info;
+    throw std::runtime_error(ss.str());
+  }
+}
+
+template <typename T>
+void inverse_impl(
+    const array& a,
+    array& inv,
+    bool tri,
+    bool upper,
+    Stream stream) {
+  // Lapack uses the column-major convention. We take advantage of the following
+  // identity to avoid transposing (see
+  // https://math.stackexchange.com/a/340234):
+  //   (A⁻¹)ᵀ = (Aᵀ)⁻¹
+
+  // The inverse is computed in place, so just copy the input to the output.
+  copy_cpu(
+      a,
+      inv,
+      a.flags().row_contiguous ? CopyType::Vector : CopyType::General,
+      stream);
+
+  const int N = a.shape(-1);
+  const size_t num_matrices = a.size() / (N * N);
+
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_output_array(inv);
+
+  auto inv_ptr = inv.data<T>();
+  if (tri) {
+    encoder.dispatch([inv_ptr, N, num_matrices, upper]() {
+      for (int i = 0; i < num_matrices; i++) {
+        tri_inv<T>(inv_ptr + N * N * i, N, upper);
+      }
+    });
+  } else {
+    encoder.dispatch([inv_ptr, N, num_matrices]() {
+      for (int i = 0; i < num_matrices; i++) {
+        general_inv<T>(inv_ptr + N * N * i, N);
+      }
+    });
+  }
+}
+
+void Inverse::eval_cpu(const std::vector<array>& inputs, array& output) {
+  switch (inputs[0].dtype()) {
+    case float32:
+      inverse_impl<float>(inputs[0], output, tri_, upper_, stream());
+      break;
+    case float64:
+      inverse_impl<double>(inputs[0], output, tri_, upper_, stream());
+      break;
+    default:
+      throw std::runtime_error(
+          "[Inverse::eval_cpu] only supports float32 or float64.");
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..01bab52f3ae7772e6cd45ee1812c0e41d30ebde3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.cpp
@@ -0,0 +1,153 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/backend/cpu/jit_compiler.h"
+
+#include <algorithm>
+#include <sstream>
+#include <vector>
+
+#include <fmt/format.h>
+
+namespace mlx::core {
+
+#ifdef _MSC_VER
+
+namespace {
+
+// Split string into array.
+std::vector<std::string> str_split(const std::string& str, char delimiter) {
+  std::vector<std::string> tokens;
+  std::string token;
+  std::istringstream tokenStream(str);
+  while (std::getline(tokenStream, token, delimiter)) {
+    tokens.push_back(token);
+  }
+  return tokens;
+}
+
+// Get path information about MSVC.
+struct VisualStudioInfo {
+  VisualStudioInfo() {
+#ifdef _M_ARM64
+    arch = "arm64";
+#else
+    arch = "x64";
+#endif
+    // Get path of Visual Studio.
+    std::string vs_path = JitCompiler::exec(fmt::format(
+        "\"{0}\\Microsoft Visual Studio\\Installer\\vswhere.exe\""
+        " -property installationPath",
+        std::getenv("ProgramFiles(x86)")));
+    if (vs_path.empty()) {
+      throw std::runtime_error("Can not find Visual Studio.");
+    }
+    // Read the envs from vcvarsall.
+    std::string envs = JitCompiler::exec(fmt::format(
+        "\"{0}\\VC\\Auxiliary\\Build\\vcvarsall.bat\" {1} >NUL && set",
+        vs_path,
+        arch));
+    for (const std::string& line : str_split(envs, '\n')) {
+      // Each line is in the format "ENV_NAME=values".
+      auto pos = line.find_first_of('=');
+      if (pos == std::string::npos || pos == 0 || pos == line.size() - 1)
+        continue;
+      std::string name = line.substr(0, pos);
+      std::string value = line.substr(pos + 1);
+      if (name == "LIB") {
+        libpaths = str_split(value, ';');
+      } else if (name == "VCToolsInstallDir" || name == "VCTOOLSINSTALLDIR") {
+        cl_exe = fmt::format("{0}\\bin\\Host{1}\\{1}\\cl.exe", value, arch);
+      }
+    }
+  }
+  std::string arch;
+  std::string cl_exe;
+  std::vector<std::string> libpaths;
+};
+
+const VisualStudioInfo& GetVisualStudioInfo() {
+  static VisualStudioInfo info;
+  return info;
+}
+
+} // namespace
+
+#endif // _MSC_VER
+
+std::string JitCompiler::build_command(
+    const std::filesystem::path& dir,
+    const std::string& source_file_name,
+    const std::string& shared_lib_name) {
+#ifdef _MSC_VER
+  const VisualStudioInfo& info = GetVisualStudioInfo();
+  std::string libpaths;
+  for (const std::string& lib : info.libpaths) {
+    libpaths += fmt::format(" /libpath:\"{0}\"", lib);
+  }
+  return fmt::format(
+      "\""
+      "cd /D \"{0}\" && "
+      "\"{1}\" /LD /EHsc /MD /Ox /nologo /std:c++17 \"{2}\" "
+      "/link /out:\"{3}\" {4} 2>&1"
+      "\"",
+      dir.string(),
+      info.cl_exe,
+      source_file_name,
+      shared_lib_name,
+      libpaths);
+#else
+  return fmt::format(
+      "g++ -std=c++17 -O3 -Wall -fPIC -shared \"{0}\" -o \"{1}\" 2>&1",
+      (dir / source_file_name).string(),
+      (dir / shared_lib_name).string());
+#endif
+}
+
+std::string JitCompiler::exec(const std::string& cmd) {
+#ifdef _MSC_VER
+  FILE* pipe = _popen(cmd.c_str(), "r");
+#else
+  FILE* pipe = popen(cmd.c_str(), "r");
+#endif
+  if (!pipe) {
+    throw std::runtime_error("popen() failed.");
+  }
+  char buffer[128];
+  std::string ret;
+  while (fgets(buffer, sizeof(buffer), pipe)) {
+    ret += buffer;
+  }
+  // Trim trailing spaces.
+  ret.erase(
+      std::find_if(
+          ret.rbegin(),
+          ret.rend(),
+          [](unsigned char ch) { return !std::isspace(ch); })
+          .base(),
+      ret.end());
+
+#ifdef _MSC_VER
+  int status = _pclose(pipe);
+#else
+  int status = pclose(pipe);
+#endif
+  if (status == -1) {
+    throw std::runtime_error("pclose() failed.");
+  }
+#if defined(_WIN32) || defined(__FreeBSD__)
+  int code = status;
+#else
+  int code = WEXITSTATUS(status);
+#endif
+  if (code != 0) {
+    throw std::runtime_error(fmt::format(
+        "Failed to execute command with return code {0}: \"{1}\", "
+        "the output is: {2}",
+        code,
+        cmd,
+        ret));
+  }
+  return ret;
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.h
new file mode 100644
index 0000000000000000000000000000000000000000..3a9e988da741d6fb1d143f0f3b8aff0e598e696d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/jit_compiler.h
@@ -0,0 +1,20 @@
+// Copyright © 2024 Apple Inc.
+#pragma once
+
+#include <filesystem>
+
+namespace mlx::core {
+
+class JitCompiler {
+ public:
+  // Build a shell command that compiles a source code file to a shared library.
+  static std::string build_command(
+      const std::filesystem::path& dir,
+      const std::string& source_file_name,
+      const std::string& shared_lib_name);
+
+  // Run a command and get its output.
+  static std::string exec(const std::string& cmd);
+};
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce735f26ca71360f269515a625f16595b100617b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/lapack.h
@@ -0,0 +1,65 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <complex>
+#define LAPACK_COMPLEX_CUSTOM
+#define lapack_complex_float std::complex<float>
+#define lapack_complex_double std::complex<double>
+#define lapack_complex_float_real(z) ((z).real())
+#define lapack_complex_float_imag(z) ((z).imag())
+#define lapack_complex_double_real(z) ((z).real())
+#define lapack_complex_double_imag(z) ((z).imag())
+
+#ifdef MLX_USE_ACCELERATE
+#include <Accelerate/Accelerate.h>
+#else
+#include <cblas.h>
+#include <lapack.h>
+#endif
+
+#if defined(LAPACK_GLOBAL) || defined(LAPACK_NAME)
+
+// This is to work around a change in the function signatures of lapack >= 3.9.1
+// where functions taking char* also include a strlen argument, see a similar
+// change in OpenCV:
+// https://github.com/opencv/opencv/blob/1eb061f89de0fb85c4c75a2deeb0f61a961a63ad/cmake/OpenCVFindLAPACK.cmake#L57
+#define MLX_LAPACK_FUNC(f) LAPACK_##f
+
+#else
+
+#define MLX_LAPACK_FUNC(f) f##_
+
+#endif
+
+#define INSTANTIATE_LAPACK_REAL(FUNC)                        \
+  template <typename T, typename... Args>                    \
+  void FUNC(Args... args) {                                  \
+    if constexpr (std::is_same_v<T, float>) {                \
+      MLX_LAPACK_FUNC(s##FUNC)(std::forward<Args>(args)...); \
+    } else if constexpr (std::is_same_v<T, double>) {        \
+      MLX_LAPACK_FUNC(d##FUNC)(std::forward<Args>(args)...); \
+    }                                                        \
+  }
+
+INSTANTIATE_LAPACK_REAL(geqrf)
+INSTANTIATE_LAPACK_REAL(orgqr)
+INSTANTIATE_LAPACK_REAL(syevd)
+INSTANTIATE_LAPACK_REAL(geev)
+INSTANTIATE_LAPACK_REAL(potrf)
+INSTANTIATE_LAPACK_REAL(gesdd)
+INSTANTIATE_LAPACK_REAL(getrf)
+INSTANTIATE_LAPACK_REAL(getri)
+INSTANTIATE_LAPACK_REAL(trtri)
+
+#define INSTANTIATE_LAPACK_COMPLEX(FUNC)                            \
+  template <typename T, typename... Args>                           \
+  void FUNC(Args... args) {                                         \
+    if constexpr (std::is_same_v<T, std::complex<float>>) {         \
+      MLX_LAPACK_FUNC(c##FUNC)(std::forward<Args>(args)...);        \
+    } else if constexpr (std::is_same_v<T, std::complex<double>>) { \
+      MLX_LAPACK_FUNC(z##FUNC)(std::forward<Args>(args)...);        \
+    }                                                               \
+  }
+
+INSTANTIATE_LAPACK_COMPLEX(heevd)
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d061907f96aa3cb82f6a16ac7dc83a0462b0d451
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/logsumexp.cpp
@@ -0,0 +1,139 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <cassert>
+#include <cmath>
+
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/simd/simd.h"
+#include "mlx/primitives.h"
+#include "mlx/types/limits.h"
+
+namespace mlx::core {
+
+namespace {
+
+using namespace mlx::core::simd;
+
+template <typename T, typename AccT>
+void logsumexp(const array& in, array& out, Stream stream) {
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+
+  const T* in_ptr = in.data<T>();
+  T* out_ptr = out.data<T>();
+
+  int M = in.shape().back();
+  int L = in.data_size() / M;
+
+  encoder.dispatch([in_ptr, out_ptr, M, L]() mutable {
+    constexpr int N = std::min(max_size<AccT>, max_size<T>);
+
+    const T* current_in_ptr;
+
+    for (int i = 0; i < L; i++, in_ptr += M, out_ptr += 1) {
+      // Find the maximum
+      current_in_ptr = in_ptr;
+      Simd<AccT, N> vmaximum(-numeric_limits<AccT>::infinity());
+      size_t s = M;
+      while (s >= N) {
+        Simd<AccT, N> vals = load<T, N>(current_in_ptr);
+        vmaximum = maximum(vals, vmaximum);
+        current_in_ptr += N;
+        s -= N;
+      }
+
+      AccT maximum = max(vmaximum);
+      while (s-- > 0) {
+        maximum = std::max(maximum, static_cast<AccT>(*current_in_ptr));
+        current_in_ptr++;
+      }
+
+      // Compute the normalizer and the exponentials
+      Simd<AccT, N> vnormalizer(0.0);
+      current_in_ptr = in_ptr;
+      s = M;
+      while (s >= N) {
+        Simd<AccT, N> vexp = load<T, N>(current_in_ptr);
+        vexp = exp(vexp - maximum);
+        vnormalizer = vnormalizer + vexp;
+        current_in_ptr += N;
+        s -= N;
+      }
+      AccT normalizer = sum(vnormalizer);
+      while (s-- > 0) {
+        AccT _exp = std::exp(*current_in_ptr - maximum);
+        normalizer += _exp;
+        current_in_ptr++;
+      }
+      // Normalize
+      *out_ptr = std::isinf(maximum)
+          ? static_cast<T>(maximum)
+          : static_cast<T>(std::log(normalizer) + maximum);
+    }
+  });
+}
+
+} // namespace
+
+void LogSumExp::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+
+  // Make sure that the last dimension is contiguous
+  auto s = stream();
+  auto& encoder = cpu::get_command_encoder(s);
+  auto ensure_contiguous = [&s, &encoder](const array& x) {
+    if (x.flags().contiguous && x.strides()[x.ndim() - 1] == 1) {
+      return x;
+    } else {
+      array x_copy = contiguous_copy_cpu(x, s);
+      encoder.add_temporary(x_copy);
+      return x_copy;
+    }
+  };
+
+  auto in = ensure_contiguous(inputs[0]);
+  if (in.flags().row_contiguous) {
+    out.set_data(allocator::malloc(out.nbytes()));
+  } else {
+    auto n = in.shape(-1);
+    auto flags = in.flags();
+    auto strides = in.strides();
+    for (auto& s : strides) {
+      s /= n;
+    }
+    bool col_contig = strides[0] == 1;
+    for (int i = 1; col_contig && i < strides.size(); ++i) {
+      col_contig &=
+          (out.shape(i) == 1 || strides[i - 1] == out.shape(i) * strides[i]);
+    }
+    flags.col_contiguous = col_contig;
+    out.set_data(
+        allocator::malloc(in.nbytes() / n),
+        in.data_size() / n,
+        std::move(strides),
+        flags);
+  }
+
+  switch (in.dtype()) {
+    case float32:
+      logsumexp<float, float>(in, out, stream());
+      break;
+    case float16:
+      logsumexp<float16_t, float>(in, out, stream());
+      break;
+    case bfloat16:
+      logsumexp<bfloat16_t, float>(in, out, stream());
+      break;
+    case float64:
+      logsumexp<double, double>(in, out, stream());
+      break;
+    default:
+      throw std::runtime_error(
+          "[logsumexp] only supports floating point types");
+      break;
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5f1507e183f26b3864323fa59f907599835b0d19
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/luf.cpp
@@ -0,0 +1,120 @@
+// Copyright © 2024 Apple Inc.
+
+#include <cassert>
+
+#include "mlx/allocator.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/lapack.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+template <typename T>
+void luf_impl(
+    const array& a,
+    array& lu,
+    array& pivots,
+    array& row_indices,
+    Stream stream) {
+  int M = a.shape(-2);
+  int N = a.shape(-1);
+  int K = std::min(M, N);
+
+  // Copy a into lu and make it col contiguous
+  auto ndim = lu.ndim();
+  auto flags = lu.flags();
+  flags.col_contiguous = ndim == 2;
+  flags.row_contiguous = false;
+  flags.contiguous = true;
+  auto strides = lu.strides();
+  strides[ndim - 1] = M;
+  strides[ndim - 2] = 1;
+  lu.set_data(allocator::malloc(lu.nbytes()), lu.nbytes(), strides, flags);
+  copy_cpu_inplace(
+      a,
+      lu,
+      a.shape(),
+      a.strides(),
+      strides,
+      0,
+      0,
+      CopyType::GeneralGeneral,
+      stream);
+
+  auto a_ptr = lu.data<T>();
+  pivots.set_data(allocator::malloc(pivots.nbytes()));
+  row_indices.set_data(allocator::malloc(row_indices.nbytes()));
+  auto pivots_ptr = pivots.data<uint32_t>();
+  auto row_indices_ptr = row_indices.data<uint32_t>();
+  size_t num_matrices = a.size() / (M * N);
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_output_array(lu);
+  encoder.set_output_array(pivots);
+  encoder.set_output_array(row_indices);
+
+  encoder.dispatch(
+      [a_ptr, pivots_ptr, row_indices_ptr, num_matrices, M, N, K]() mutable {
+        int info;
+        for (size_t i = 0; i < num_matrices; ++i) {
+          // Compute LU factorization of A
+          getrf<T>(
+              /* m */ &M,
+              /* n */ &N,
+              /* a */ a_ptr,
+              /* lda */ &M,
+              /* ipiv */ reinterpret_cast<int*>(pivots_ptr),
+              /* info */ &info);
+
+          if (info != 0) {
+            std::stringstream ss;
+            ss << "[LUF::eval_cpu] sgetrf_ failed with code " << info
+               << ((info > 0) ? " because matrix is singular"
+                              : " because argument had an illegal value");
+            throw std::runtime_error(ss.str());
+          }
+
+          // Subtract 1 to get 0-based index
+          int j = 0;
+          for (; j < K; ++j) {
+            pivots_ptr[j]--;
+            row_indices_ptr[j] = j;
+          }
+          for (; j < M; ++j) {
+            row_indices_ptr[j] = j;
+          }
+          for (int j = K - 1; j >= 0; --j) {
+            auto piv = pivots_ptr[j];
+            auto t1 = row_indices_ptr[piv];
+            auto t2 = row_indices_ptr[j];
+            row_indices_ptr[j] = t1;
+            row_indices_ptr[piv] = t2;
+          }
+
+          // Advance pointers to the next matrix
+          a_ptr += M * N;
+          pivots_ptr += K;
+          row_indices_ptr += M;
+        }
+      });
+}
+
+void LUF::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  assert(inputs.size() == 1);
+  switch (inputs[0].dtype()) {
+    case float32:
+      luf_impl<float>(inputs[0], outputs[0], outputs[1], outputs[2], stream());
+      break;
+    case float64:
+      luf_impl<double>(inputs[0], outputs[0], outputs[1], outputs[2], stream());
+      break;
+    default:
+      throw std::runtime_error(
+          "[LUF::eval_cpu] only supports float32 or float64.");
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/make_compiled_preamble.ps1 b/ml-stable-diffusion/mlx/mlx/backend/cpu/make_compiled_preamble.ps1
new file mode 100644
index 0000000000000000000000000000000000000000..0cd2d1f1701725388bd43d9d3002eadcc26e41bb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/make_compiled_preamble.ps1
@@ -0,0 +1,38 @@
+# This script generates a C++ function that provides the CPU
+# code for use with kernel generation.
+#
+# Copyright © 2024 Apple Inc.
+
+$OUTPUT_FILE = $args[0]
+$CL = $args[1]
+$SRCDIR = $args[2]
+
+# Get command result as array.
+$CONTENT = & $CL /std:c++17 /EP "/I$SRCDIR" /Tp "$SRCDIR/mlx/backend/cpu/compiled_preamble.h"
+# Remove empty lines.
+# Otherwise there will be too much empty lines making the result unreadable.
+$CONTENT = $CONTENT | Where-Object { $_.Trim() -ne '' }
+# Concatenate to string.
+$CONTENT = $CONTENT -join "`n"
+
+# Append extra content.
+$CONTENT = @"
+$($CONTENT)
+using namespace mlx::core;
+using namespace mlx::core::detail;
+"@
+
+# Convert each char to ASCII code.
+# Unlike the unix script that outputs string literal directly, the output from
+# MSVC is way too large to be embedded as string and compilation will fail, so
+# we store it as static array instead.
+$CHARCODES = ([System.Text.Encoding]::ASCII.GetBytes($CONTENT) -join ', ') + ', 0'
+
+$OUTPUT = @"
+const char* get_kernel_preamble() {
+  static char preamble[] = { $CHARCODES };
+  return preamble;
+}
+"@
+
+Set-Content -Path $OUTPUT_FILE -Value $OUTPUT
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/make_compiled_preamble.sh b/ml-stable-diffusion/mlx/mlx/backend/cpu/make_compiled_preamble.sh
new file mode 100644
index 0000000000000000000000000000000000000000..88b4c4615e56f2fa37679a699dc0bd0e822444db
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/make_compiled_preamble.sh
@@ -0,0 +1,41 @@
+#!/bin/bash
+#
+# This script generates a C++ function that provides the CPU
+# code for use with kernel generation.
+#
+# Copyright © 2023-24 Apple Inc.
+
+
+OUTPUT_FILE=$1
+GCC=$2
+SRCDIR=$3
+CLANG=$4
+ARCH=$5
+
+if [ "$CLANG" = "TRUE" ]; then
+  read -r -d '' INCLUDES <<- EOM
+#include <cmath>
+#include <complex>
+#include <cstdint>
+#include <vector>
+#ifdef __ARM_FEATURE_FP16_SCALAR_ARITHMETIC
+#include <arm_fp16.h>
+#endif
+EOM
+CC_FLAGS="-arch ${ARCH} -nobuiltininc -nostdinc"
+else
+CC_FLAGS="-std=c++17"
+fi
+
+CONTENT=$($GCC $CC_FLAGS -I "$SRCDIR" -E -P "$SRCDIR/mlx/backend/cpu/compiled_preamble.h" 2>/dev/null)
+
+cat << EOF > "$OUTPUT_FILE"
+const char* get_kernel_preamble() {
+return R"preamble(
+$INCLUDES
+$CONTENT
+using namespace mlx::core;
+using namespace mlx::core::detail;
+)preamble";
+}
+EOF
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c3efb79cd715aa7f144cba8c77acf6ada94b25e4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/masked_mm.cpp
@@ -0,0 +1,609 @@
+// Copyright © 2024 Apple Inc.
+
+#include <cstring>
+
+#include "mlx/array.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/gemm.h"
+#include "mlx/backend/cpu/lapack.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+namespace {
+
+template <typename T, typename mask_t>
+inline void mask_matrix(
+    T* data,
+    const mask_t* mask,
+    int block_size,
+    const int X,
+    const int Y,
+    const int64_t X_data_str,
+    const int64_t Y_data_str,
+    const int64_t X_mask_str,
+    const int64_t Y_mask_str,
+    const size_t mask_offset) {
+  int tX = (X + block_size - 1) / block_size;
+  int tY = (Y + block_size - 1) / block_size;
+
+  for (int i = 0; i < tX; i++) {
+    for (int j = 0; j < tY; j++) {
+      mask_t do_mask = mask[mask_offset + i * X_mask_str + j * Y_mask_str];
+      if (do_mask != 1) {
+        int loc_x = i * block_size;
+        int loc_y = j * block_size;
+        T* data_block = data + loc_x * X_data_str + loc_y * Y_data_str;
+
+        int size_x = std::min(block_size, X - loc_x);
+        int size_y = std::min(block_size, Y - loc_y);
+        for (int ii = 0; ii < size_x; ii++) {
+          for (int jj = 0; jj < size_y; jj++) {
+            if constexpr (std::is_same_v<mask_t, bool>) {
+              data_block[ii * X_data_str + jj * Y_data_str] = T(0.);
+            } else {
+              data_block[ii * X_data_str + jj * Y_data_str] *= do_mask;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+template <typename T>
+inline void segmented_mm(
+    const T* a,
+    const T* b,
+    const uint32_t* segments,
+    T* out,
+    bool a_transposed,
+    bool b_transposed,
+    size_t lda,
+    size_t ldb,
+    const Shape& a_shape,
+    const Strides& a_strides,
+    const Shape& b_shape,
+    const Strides& b_strides,
+    size_t num_segments,
+    const Shape& segments_shape,
+    const Strides& segments_strides) {
+  int ndim = a_shape.size();
+  Shape a_copy = a_shape;
+  Shape b_copy = b_shape;
+  int32_t M = a_copy[ndim - 2];
+  int32_t N = b_copy[ndim - 1];
+  for (int i = 0; i < num_segments; i++) {
+    uint32_t k_start =
+        segments[elem_to_loc(2 * i, segments_shape, segments_strides)];
+    uint32_t k_end =
+        segments[elem_to_loc(2 * i + 1, segments_shape, segments_strides)];
+    if (k_end <= k_start) {
+      std::fill_n(out + i * M * N, M * N, T(0));
+      continue;
+    }
+    a_copy[ndim - 1] = k_end - k_start;
+    b_copy[ndim - 2] = k_end - k_start;
+    matmul<T>(
+        a + k_start * a_strides[ndim - 1],
+        b + k_start * b_strides[ndim - 2],
+        out + i * M * N,
+        a_transposed,
+        b_transposed,
+        lda,
+        ldb,
+        N,
+        1.0,
+        0.0,
+        1,
+        a_copy,
+        a_strides,
+        b_copy,
+        b_strides);
+  }
+}
+
+} // namespace
+
+void BlockMaskedMM::eval_cpu(const std::vector<array>& inputs, array& out) {
+  if (out.dtype() != float32) {
+    throw std::runtime_error(
+        "[BlockMaskedMM::eval] Currently only supports float32.");
+  }
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& a_pre = inputs[0];
+  auto& b_pre = inputs[1];
+
+  auto check_transpose =
+      [s = stream()](const array& arr, bool do_copy, bool expand_all = false) {
+        auto stx = arr.strides()[arr.ndim() - 2];
+        auto sty = arr.strides()[arr.ndim() - 1];
+        if (!expand_all && stx == arr.shape(-1) && sty == 1) {
+          if (do_copy) {
+            array arr_copy(arr.shape(), arr.dtype(), nullptr, {});
+            copy_cpu(arr, arr_copy, CopyType::Vector, s);
+            return std::make_tuple(false, stx, arr_copy, true);
+          }
+          return std::make_tuple(false, stx, arr, false);
+        } else if (!expand_all && stx == 1 && sty == arr.shape(-2)) {
+          if (do_copy) {
+            array arr_copy(arr.shape(), arr.dtype(), nullptr, {});
+            copy_cpu(arr, arr_copy, CopyType::Vector, s);
+            return std::make_tuple(true, sty, arr_copy, true);
+          }
+          return std::make_tuple(true, sty, arr, false);
+        } else {
+          int64_t stx = arr.shape(-1);
+          array arr_copy = contiguous_copy_cpu(arr, s);
+          return std::make_tuple(false, stx, arr_copy, true);
+        }
+      };
+
+  bool has_op_mask = inputs.size() > 3;
+  bool has_out_mask = inputs.size() == 3 || inputs.size() == 5;
+  auto [a_transposed, lda, a, a_copied] =
+      check_transpose(a_pre, has_op_mask, inputs.back().dtype() != bool_);
+  auto [b_transposed, ldb, b, b_copied] =
+      check_transpose(b_pre, has_op_mask, inputs.back().dtype() != bool_);
+
+  size_t M = a.shape(-2);
+  size_t N = b.shape(-1);
+  size_t K = a.shape(-1);
+
+  if (M == 0 || N == 0) {
+    return;
+  }
+
+  auto& encoder = cpu::get_command_encoder(stream());
+  if (K == 0) {
+    encoder.set_output_array(out);
+    encoder.dispatch([out_ptr = out.data<void>(), nbytes = out.nbytes()]() {
+      std::memset(out_ptr, 0, nbytes);
+    });
+    return;
+  }
+
+  auto mask_array = [](const void* mask,
+                       float* data,
+                       int block_size,
+                       int batch_idx,
+                       int X,
+                       int Y,
+                       size_t X_data_str,
+                       size_t Y_data_str,
+                       const Shape& mask_shape,
+                       const Strides& mask_strides,
+                       bool is_bool) {
+    auto ndim = mask_shape.size();
+    auto mask_offset = elem_to_loc(
+        mask_shape[ndim - 1] * mask_shape[ndim - 2] * batch_idx,
+        mask_shape,
+        mask_strides);
+
+    auto X_mask_str = mask_strides[ndim - 2];
+    auto Y_mask_str = mask_strides[ndim - 1];
+
+    if (is_bool) {
+      return mask_matrix(
+          data,
+          static_cast<const bool*>(mask),
+          block_size,
+          X,
+          Y,
+          X_data_str,
+          Y_data_str,
+          X_mask_str,
+          Y_mask_str,
+          mask_offset);
+    } else {
+      return mask_matrix(
+          data,
+          static_cast<const float*>(mask),
+          block_size,
+          X,
+          Y,
+          X_data_str,
+          Y_data_str,
+          X_mask_str,
+          Y_mask_str,
+          mask_offset);
+    }
+  };
+
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  const void* a_mask_ptr;
+  const void* b_mask_ptr;
+  const void* out_mask_ptr;
+  Shape a_mask_shape;
+  Shape b_mask_shape;
+  Shape out_mask_shape;
+  Strides a_mask_strides;
+  Strides b_mask_strides;
+  Strides out_mask_strides;
+  bool a_mask_bool;
+  bool b_mask_bool;
+  bool out_mask_bool;
+  if (has_op_mask) {
+    auto& a_mask = inputs[inputs.size() - 2];
+    auto& b_mask = inputs[inputs.size() - 1];
+    a_mask_ptr = a_mask.data<void>();
+    b_mask_ptr = b_mask.data<void>();
+    a_mask_shape = a_mask.shape();
+    b_mask_shape = b_mask.shape();
+    a_mask_strides = a_mask.strides();
+    b_mask_strides = b_mask.strides();
+    a_mask_bool = (a_mask.dtype() == bool_);
+    b_mask_bool = (b_mask.dtype() == bool_);
+    encoder.set_input_array(a_mask);
+    encoder.set_input_array(b_mask);
+  }
+  if (has_out_mask) {
+    auto& out_mask = inputs[2];
+    out_mask_ptr = out_mask.data<void>();
+    out_mask_bool = (out_mask.dtype() == bool_);
+    encoder.set_input_array(out_mask);
+    out_mask_shape = out_mask.shape();
+    out_mask_strides = out_mask.strides();
+  }
+  encoder.set_output_array(out);
+  auto a_ptr = a.data<float>();
+  auto b_ptr = b.data<float>();
+  auto out_ptr = out.data<float>();
+  size_t num_matrices = out.size() / (M * size_t(N));
+  auto ldc = out.shape(-1);
+
+  encoder.dispatch([a_ptr,
+                    b_ptr,
+                    out_ptr,
+                    a_mask_ptr,
+                    b_mask_ptr,
+                    out_mask_ptr,
+                    has_op_mask,
+                    has_out_mask,
+                    block_size = block_size_,
+                    num_matrices,
+                    M,
+                    N,
+                    K,
+                    a_transposed = a_transposed,
+                    b_transposed = b_transposed,
+                    lda = lda,
+                    ldb = ldb,
+                    ldc,
+                    a_shape = a.shape(),
+                    a_strides = a.strides(),
+                    b_shape = b.shape(),
+                    b_strides = b.strides(),
+                    a_mask_shape = std::move(a_mask_shape),
+                    b_mask_shape = std::move(b_mask_shape),
+                    out_mask_shape = std::move(out_mask_shape),
+                    a_mask_strides = std::move(a_mask_strides),
+                    b_mask_strides = std::move(b_mask_strides),
+                    out_mask_strides = std::move(out_mask_strides),
+                    mask_array,
+                    a_mask_bool,
+                    b_mask_bool,
+                    out_mask_bool]() {
+    for (int i = 0; i < num_matrices; ++i) {
+      // Adjust pointer
+      float* ai = a_ptr + elem_to_loc(M * K * i, a_shape, a_strides);
+      float* bi = b_ptr + elem_to_loc(K * N * i, b_shape, b_strides);
+      float* ci = out_ptr + M * N * i;
+
+      // Zero out blocks in a and b if needed
+      if (has_op_mask) {
+        mask_array(
+            a_mask_ptr,
+            ai,
+            block_size,
+            i,
+            M,
+            K,
+            a_transposed ? 1 : lda,
+            a_transposed ? lda : 1,
+            a_mask_shape,
+            a_mask_strides,
+            a_mask_bool);
+
+        mask_array(
+            b_mask_ptr,
+            bi,
+            block_size,
+            i,
+            K,
+            N,
+            b_transposed ? 1 : ldb,
+            b_transposed ? ldb : 1,
+            b_mask_shape,
+            b_mask_strides,
+            b_mask_bool);
+      }
+
+      // Do matmul
+      cblas_sgemm(
+          CblasRowMajor,
+          a_transposed ? CblasTrans : CblasNoTrans, // transA
+          b_transposed ? CblasTrans : CblasNoTrans, // transB
+          M,
+          N,
+          K,
+          1.0, // alpha
+          ai,
+          lda,
+          bi,
+          ldb,
+          0.0, // beta
+          ci,
+          ldc);
+
+      // Zero out blocks in out
+      if (has_out_mask) {
+        mask_array(
+            out_mask_ptr,
+            ci,
+            block_size,
+            i,
+            M,
+            N,
+            N,
+            1,
+            out_mask_shape,
+            out_mask_strides,
+            out_mask_bool);
+      }
+    }
+  });
+  if (a_copied) {
+    encoder.add_temporary(a);
+  }
+  if (b_copied) {
+    encoder.add_temporary(b);
+  }
+}
+
+void GatherMM::eval_cpu(const std::vector<array>& inputs, array& out) {
+  if (out.dtype() != float32) {
+    throw std::runtime_error(
+        "[GatherMM::eval] Currently only supports float32.");
+  }
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& a_pre = inputs[0];
+  auto& b_pre = inputs[1];
+
+  std::vector<array> temps;
+  auto check_transpose = [s = stream(), &temps](const array& arr) {
+    auto stx = arr.strides()[arr.ndim() - 2];
+    auto sty = arr.strides()[arr.ndim() - 1];
+    if (stx == arr.shape(-1) && sty == 1) {
+      return std::make_tuple(false, stx, arr);
+    } else if (stx == 1 && sty == arr.shape(-2)) {
+      return std::make_tuple(true, sty, arr);
+    } else {
+      temps.push_back(array(arr.shape(), arr.dtype(), nullptr, {}));
+      copy_cpu(arr, temps.back(), CopyType::General, s);
+      int64_t stx = arr.shape(-1);
+      return std::make_tuple(false, stx, temps.back());
+    }
+  };
+
+  auto [a_transposed, lda, a] = check_transpose(a_pre);
+  auto [b_transposed, ldb, b] = check_transpose(b_pre);
+
+  size_t M = a.shape(-2);
+  size_t N = b.shape(-1);
+  size_t K = a.shape(-1);
+
+  if (M == 0 || N == 0) {
+    return;
+  }
+
+  auto& encoder = cpu::get_command_encoder(stream());
+  if (K == 0) {
+    encoder.set_output_array(out);
+    encoder.dispatch([out_ptr = out.data<float>(), size = out.size()]() {
+      std::fill_n(out_ptr, size, 0);
+    });
+    return;
+  }
+
+  // Get batch dims
+  auto batch_size_out = out.size() / (M * N);
+  size_t matrix_stride_out = M * N;
+
+  auto get_batch_dims = [](const auto& v) {
+    return decltype(v){v.begin(), v.end() - 2};
+  };
+
+  auto& lhs_indices = inputs[2];
+  auto& rhs_indices = inputs[3];
+
+  auto batch_shape = get_batch_dims(out.shape());
+  int batch_ndim = batch_shape.size();
+
+  auto batch_shape_A = get_batch_dims(a.shape());
+  auto batch_strides_A = get_batch_dims(a.strides());
+  auto batch_shape_B = get_batch_dims(b.shape());
+  auto batch_strides_B = get_batch_dims(b.strides());
+
+  const uint32_t* lhs_indices_ptr = lhs_indices.data<uint32_t>();
+  const uint32_t* rhs_indices_ptr = rhs_indices.data<uint32_t>();
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_input_array(lhs_indices);
+  encoder.set_input_array(rhs_indices);
+  encoder.set_output_array(out);
+  auto ldc = out.shape(-1);
+
+  encoder.dispatch([a_ptr = a.data<float>(),
+                    b_ptr = b.data<float>(),
+                    out_ptr = out.data<float>(),
+                    M,
+                    N,
+                    K,
+                    lda = lda,
+                    ldb = ldb,
+                    a_transposed = a_transposed,
+                    b_transposed = b_transposed,
+                    ldc,
+                    lhs_indices_ptr,
+                    rhs_indices_ptr,
+                    lhs_indices_shape = lhs_indices.shape(),
+                    lhs_indices_strides = lhs_indices.strides(),
+                    rhs_indices_shape = rhs_indices.shape(),
+                    rhs_indices_strides = rhs_indices.strides(),
+                    batch_size_out,
+                    matrix_stride_out,
+                    batch_shape_A = std::move(batch_shape_A),
+                    batch_shape_B = std::move(batch_shape_B),
+                    batch_strides_A = std::move(batch_strides_A),
+                    batch_strides_B = std::move(batch_strides_B)]() {
+    for (int i = 0; i < batch_size_out; i++) {
+      // Get index
+      uint32_t indx_A = lhs_indices_ptr[elem_to_loc(
+          i, lhs_indices_shape, lhs_indices_strides)];
+      uint32_t indx_B = rhs_indices_ptr[elem_to_loc(
+          i, rhs_indices_shape, rhs_indices_strides)];
+
+      cblas_sgemm(
+          CblasRowMajor,
+          a_transposed ? CblasTrans : CblasNoTrans, // transA
+          b_transposed ? CblasTrans : CblasNoTrans, // transB
+          M,
+          N,
+          K,
+          1.0f, // alpha
+          a_ptr + elem_to_loc(indx_A, batch_shape_A, batch_strides_A),
+          lda,
+          b_ptr + elem_to_loc(indx_B, batch_shape_B, batch_strides_B),
+          ldb,
+          0.0f, // beta
+          out_ptr + matrix_stride_out * i,
+          ldc);
+    }
+  });
+  encoder.add_temporaries(std::move(temps));
+}
+
+void SegmentedMM::eval_cpu(const std::vector<array>& inputs, array& out) {
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& s = stream();
+  auto& encoder = cpu::get_command_encoder(stream());
+  auto check_transpose = [&s, &encoder](const array& x) {
+    auto stx = x.strides()[x.ndim() - 2];
+    auto sty = x.strides()[x.ndim() - 1];
+    if (stx == x.shape(-1) && sty == 1) {
+      return std::make_tuple(false, stx, x);
+    } else if (stx == 1 && sty == x.shape(-2)) {
+      return std::make_tuple(true, sty, x);
+    } else {
+      array xc(x.shape(), x.dtype(), nullptr, {});
+      copy_cpu(x, xc, CopyType::General, s);
+      encoder.add_temporary(xc);
+      int64_t stx = x.shape(-1);
+      return std::make_tuple(false, stx, xc);
+    }
+  };
+
+  auto [a_transposed, lda, a] = check_transpose(inputs[0]);
+  auto [b_transposed, ldb, b] = check_transpose(inputs[1]);
+  auto& segments = inputs[2];
+
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_input_array(segments);
+  encoder.set_output_array(out);
+  encoder.dispatch([a = array::unsafe_weak_copy(a),
+                    b = array::unsafe_weak_copy(b),
+                    segments = array::unsafe_weak_copy(segments),
+                    out_ptr = out.data<void>(),
+                    a_transposed = a_transposed,
+                    b_transposed = b_transposed,
+                    lda = lda,
+                    ldb = ldb]() {
+    switch (a.dtype()) {
+      case float64:
+        segmented_mm<double>(
+            a.data<double>(),
+            b.data<double>(),
+            segments.data<uint32_t>(),
+            static_cast<double*>(out_ptr),
+            a_transposed,
+            b_transposed,
+            lda,
+            ldb,
+            a.shape(),
+            a.strides(),
+            b.shape(),
+            b.strides(),
+            segments.size() / 2,
+            segments.shape(),
+            segments.strides());
+        break;
+      case float32:
+        segmented_mm<float>(
+            a.data<float>(),
+            b.data<float>(),
+            segments.data<uint32_t>(),
+            static_cast<float*>(out_ptr),
+            a_transposed,
+            b_transposed,
+            lda,
+            ldb,
+            a.shape(),
+            a.strides(),
+            b.shape(),
+            b.strides(),
+            segments.size() / 2,
+            segments.shape(),
+            segments.strides());
+        break;
+      case float16:
+        segmented_mm<float16_t>(
+            a.data<float16_t>(),
+            b.data<float16_t>(),
+            segments.data<uint32_t>(),
+            static_cast<float16_t*>(out_ptr),
+            a_transposed,
+            b_transposed,
+            lda,
+            ldb,
+            a.shape(),
+            a.strides(),
+            b.shape(),
+            b.strides(),
+            segments.size() / 2,
+            segments.shape(),
+            segments.strides());
+        break;
+      case bfloat16:
+        segmented_mm<bfloat16_t>(
+            a.data<bfloat16_t>(),
+            b.data<bfloat16_t>(),
+            segments.data<uint32_t>(),
+            static_cast<bfloat16_t*>(out_ptr),
+            a_transposed,
+            b_transposed,
+            lda,
+            ldb,
+            a.shape(),
+            a.strides(),
+            b.shape(),
+            b.strides(),
+            segments.size() / 2,
+            segments.shape(),
+            segments.strides());
+        break;
+      default:
+        throw std::invalid_argument(
+            "Segmented mm supports only real float types.");
+    }
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..029e94aabde114f4557fe0863f2052e86d1a887a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/matmul.cpp
@@ -0,0 +1,155 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <cstring>
+#include "mlx/array.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/gemm.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+template <typename T>
+void matmul_dispatch(
+    const array& a,
+    const array& b,
+    array& out,
+    bool a_transposed,
+    bool b_transposed,
+    size_t lda,
+    size_t ldb,
+    float alpha,
+    float beta,
+    Stream stream) {
+  const T* a_ptr = a.data<T>();
+  const T* b_ptr = b.data<T>();
+  T* out_ptr = out.data<T>();
+  size_t ldc = out.shape(-1);
+  size_t batch_size = a.size() / (a.shape(-2) * a.shape(-1));
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_output_array(out);
+  encoder.dispatch([a_ptr,
+                    b_ptr,
+                    out_ptr,
+                    a_transposed,
+                    b_transposed,
+                    lda,
+                    ldb,
+                    ldc,
+                    alpha,
+                    beta,
+                    batch_size,
+                    a_shape = a.shape(),
+                    a_strides = a.strides(),
+                    b_shape = b.shape(),
+                    b_strides = b.strides()]() {
+    matmul<T>(
+        a_ptr,
+        b_ptr,
+        out_ptr,
+        a_transposed,
+        b_transposed,
+        lda,
+        ldb,
+        ldc,
+        alpha,
+        beta,
+        batch_size,
+        a_shape,
+        a_strides,
+        b_shape,
+        b_strides);
+  });
+}
+
+void matmul_general(
+    const array& a_pre,
+    const array& b_pre,
+    array& out,
+    Stream stream,
+    float alpha = 1.0f,
+    float beta = 0.0f) {
+  std::vector<array> temps;
+  auto check_transpose = [stream, &temps](const array& arr) {
+    auto stx = arr.strides()[arr.ndim() - 2];
+    auto sty = arr.strides()[arr.ndim() - 1];
+    if (stx == arr.shape(-1) && sty == 1) {
+      return std::make_tuple(false, stx, arr);
+    } else if (stx == 1 && sty == arr.shape(-2)) {
+      return std::make_tuple(true, sty, arr);
+    } else {
+      temps.push_back(array(arr.shape(), arr.dtype(), nullptr, {}));
+      copy_cpu(arr, temps.back(), CopyType::General, stream);
+      stx = arr.shape(-1);
+      return std::make_tuple(false, stx, temps.back());
+    }
+  };
+
+  auto [a_transposed, lda, a] = check_transpose(a_pre);
+  auto [b_transposed, ldb, b] = check_transpose(b_pre);
+  size_t M = a.shape(-2);
+  size_t N = b.shape(-1);
+  size_t K = a.shape(-1);
+  if (M == 0 || N == 0) {
+    return;
+  }
+
+  if (out.dtype() == float32) {
+    matmul_dispatch<float>(
+        a, b, out, a_transposed, b_transposed, lda, ldb, alpha, beta, stream);
+  } else if (out.dtype() == float16) {
+    matmul_dispatch<float16_t>(
+        a, b, out, a_transposed, b_transposed, lda, ldb, alpha, beta, stream);
+  } else if (out.dtype() == bfloat16) {
+    matmul_dispatch<bfloat16_t>(
+        a, b, out, a_transposed, b_transposed, lda, ldb, alpha, beta, stream);
+  } else if (out.dtype() == float64) {
+    matmul_dispatch<double>(
+        a, b, out, a_transposed, b_transposed, lda, ldb, alpha, beta, stream);
+  } else if (out.dtype() == complex64) {
+    matmul_dispatch<complex64_t>(
+        a, b, out, a_transposed, b_transposed, lda, ldb, alpha, beta, stream);
+  } else {
+    throw std::runtime_error("[Matmul::eval_cpu] Invalid type.");
+  }
+  cpu::get_command_encoder(stream).add_temporaries(std::move(temps));
+}
+
+void Matmul::eval_cpu(const std::vector<array>& inputs, array& out) {
+  out.set_data(allocator::malloc(out.nbytes()));
+  if (inputs[0].shape(-1) == 0) {
+    auto& encoder = cpu::get_command_encoder(stream());
+    encoder.set_output_array(out);
+    encoder.dispatch([out_ptr = out.data<void>(), nbytes = out.nbytes()]() {
+      std::memset(out_ptr, 0, nbytes);
+    });
+    return;
+  }
+  matmul_general(inputs[0], inputs[1], out, stream());
+}
+
+void AddMM::eval_cpu(const std::vector<array>& inputs, array& out) {
+  if (out.dtype() != float32) {
+    throw std::runtime_error(
+        "[AddMM::eval_cpu] Currently only supports float32.");
+  }
+  if (out.size() == 0) {
+    out.set_data(allocator::malloc(out.nbytes()));
+    return;
+  }
+
+  // Fill output with C
+  auto& c = inputs[2];
+  CopyType ctype = c.data_size() == 1
+      ? CopyType::Scalar
+      : (c.flags().row_contiguous ? CopyType::Vector : CopyType::General);
+  copy_cpu(c, out, ctype, stream());
+  if (inputs[0].shape(-1) == 0) {
+    return;
+  }
+  matmul_general(inputs[0], inputs[1], out, stream(), alpha_, beta_);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f2cb12fdd5ad6803a5ad0538d404affc41e3883b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/primitives.cpp
@@ -0,0 +1,473 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <numeric>
+#include <sstream>
+
+#include "mlx/allocator.h"
+#include "mlx/backend/common/slicing.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/arange.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/threefry.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+void reshape(const array& in, array& out) {
+  auto [copy_necessary, out_strides] = prepare_reshape(in, out);
+  if (copy_necessary) {
+    out.set_data(allocator::malloc(out.nbytes()));
+    copy_cpu_inplace(in, out, CopyType::General, out.primitive().stream());
+  } else {
+    shared_buffer_reshape(in, out_strides, out);
+  }
+}
+
+static std::pair<array, bool> compute_dynamic_offset(
+    const array& indices,
+    const Strides& strides,
+    const std::vector<int>& axes,
+    Stream stream) {
+  array offset({1}, int64, nullptr, {});
+  bool donate = indices.is_donatable() &&
+      (indices.data_size() * indices.itemsize()) >= offset.itemsize();
+  if (donate) {
+    offset.copy_shared_buffer(indices);
+  } else {
+    offset.set_data(allocator::malloc(offset.itemsize()));
+  }
+
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(indices);
+  encoder.set_output_array(offset);
+  auto compute_offset =
+      [strides, axes, offset = offset.data<int64_t>()](const auto* indices) {
+        int64_t offset_ = 0;
+        for (int i = 0; i < axes.size(); ++i) {
+          offset_ += indices[i] * strides[axes[i]];
+        }
+        offset[0] = offset_;
+      };
+  switch (indices.dtype()) {
+    case int8:
+    case uint8:
+      encoder.dispatch(compute_offset, indices.data<uint8_t>());
+      break;
+    case int16:
+    case uint16:
+      encoder.dispatch(compute_offset, indices.data<uint16_t>());
+      break;
+    case int32:
+    case uint32:
+      encoder.dispatch(compute_offset, indices.data<uint32_t>());
+      break;
+    case int64:
+    case uint64:
+      encoder.dispatch(compute_offset, indices.data<uint64_t>());
+      break;
+    default:
+      throw std::runtime_error("Invalid indices type.");
+  }
+  return {offset, donate};
+}
+
+void AsStrided::eval_cpu(const std::vector<array>& inputs, array& out) {
+  eval(inputs, out);
+}
+void Broadcast::eval_cpu(const std::vector<array>& inputs, array& out) {
+  eval(inputs, out);
+}
+void BroadcastAxes::eval_cpu(const std::vector<array>& inputs, array& out) {
+  eval(inputs, out);
+}
+void Copy::eval_cpu(const std::vector<array>& inputs, array& out) {
+  eval(inputs, out);
+}
+void CustomTransforms::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  eval(inputs, outputs);
+}
+void Depends::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  eval(inputs, outputs);
+}
+void ExpandDims::eval_cpu(const std::vector<array>& inputs, array& out) {
+  eval(inputs, out);
+}
+void NumberOfElements::eval_cpu(const std::vector<array>& inputs, array& out) {
+  eval(inputs, out);
+}
+void Slice::eval_cpu(const std::vector<array>& inputs, array& out) {
+  slice(inputs[0], out, start_indices_, strides_);
+}
+void Split::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  eval(inputs, outputs);
+}
+void Squeeze::eval_cpu(const std::vector<array>& inputs, array& out) {
+  eval(inputs, out);
+}
+void StopGradient::eval_cpu(const std::vector<array>& inputs, array& out) {
+  eval(inputs, out);
+}
+void Transpose::eval_cpu(const std::vector<array>& inputs, array& out) {
+  eval(inputs, out);
+}
+
+void Arange::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 0);
+  out.set_data(allocator::malloc(out.nbytes()));
+  switch (out.dtype()) {
+    case bool_:
+      throw std::runtime_error("Bool type unsupported for arange.");
+      break;
+    case uint8:
+      arange<uint8_t>(start_, start_ + step_, out, out.size(), stream());
+      break;
+    case uint16:
+      arange<uint16_t>(start_, start_ + step_, out, out.size(), stream());
+      break;
+    case uint32:
+      arange<uint32_t>(start_, start_ + step_, out, out.size(), stream());
+      break;
+    case uint64:
+      arange<uint64_t>(start_, start_ + step_, out, out.size(), stream());
+      break;
+    case int8:
+      arange<int8_t>(start_, start_ + step_, out, out.size(), stream());
+      break;
+    case int16:
+      arange<int16_t>(start_, start_ + step_, out, out.size(), stream());
+      break;
+    case int32:
+      arange<int32_t>(start_, start_ + step_, out, out.size(), stream());
+      break;
+    case int64:
+      arange<int64_t>(start_, start_ + step_, out, out.size(), stream());
+      break;
+    case float16:
+      arange<float16_t>(start_, start_ + step_, out, out.size(), stream());
+      break;
+    case float32:
+      arange<float>(start_, start_ + step_, out, out.size(), stream());
+      break;
+    case float64:
+      arange<double>(start_, start_ + step_, out, out.size(), stream());
+      break;
+    case bfloat16:
+      arange<bfloat16_t>(start_, start_ + step_, out, out.size(), stream());
+      break;
+    case complex64:
+      arange<complex64_t>(start_, start_ + step_, out, out.size(), stream());
+      break;
+  }
+}
+
+void AsType::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  CopyType ctype = in.flags().contiguous ? CopyType::Vector : CopyType::General;
+  copy_cpu(in, out, ctype, stream());
+}
+
+void Concatenate::eval_cpu(const std::vector<array>& inputs, array& out) {
+  std::vector<int> sizes;
+  sizes.push_back(0);
+  for (auto& p : inputs) {
+    sizes.push_back(p.shape(axis_));
+  }
+  std::partial_sum(sizes.cbegin(), sizes.cend(), sizes.begin());
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto strides = out.strides();
+  auto flags = out.flags();
+  flags.row_contiguous = false;
+  flags.col_contiguous = false;
+  flags.contiguous = false;
+  for (int i = 0; i < inputs.size(); i++) {
+    array out_slice(inputs[i].shape(), out.dtype(), nullptr, {});
+    size_t data_offset = strides[axis_] * sizes[i];
+    out_slice.copy_shared_buffer(
+        out, strides, flags, out_slice.size(), data_offset);
+    copy_cpu_inplace(inputs[i], out_slice, CopyType::GeneralGeneral, stream());
+  }
+}
+
+void Contiguous::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  constexpr size_t extra_bytes = 16384;
+  if (in.buffer_size() <= out.nbytes() + extra_bytes &&
+      (in.flags().row_contiguous ||
+       (allow_col_major_ && in.flags().col_contiguous))) {
+    out.copy_shared_buffer(in);
+  } else {
+    copy_cpu(in, out, CopyType::General, stream());
+  }
+}
+
+void Flatten::eval_cpu(const std::vector<array>& inputs, array& out) {
+  reshape(inputs[0], out);
+}
+
+void Unflatten::eval_cpu(const std::vector<array>& inputs, array& out) {
+  reshape(inputs[0], out);
+}
+
+void Full::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  assert(in.dtype() == out.dtype());
+  CopyType ctype;
+  if (in.data_size() == 1) {
+    ctype = CopyType::Scalar;
+  } else if (in.flags().contiguous) {
+    ctype = CopyType::Vector;
+  } else {
+    ctype = CopyType::General;
+  }
+  copy_cpu(in, out, ctype, stream());
+}
+
+void Pad::eval_cpu(const std::vector<array>& inputs, array& out) {
+  // Inputs must be base input array and scalar val array
+  assert(inputs.size() == 2);
+  auto& in = inputs[0];
+  auto& val = inputs[1];
+
+  // Padding value must be a scalar
+  assert(val.size() == 1);
+
+  // Padding value, input and output must be of the same type
+  assert(val.dtype() == in.dtype() && in.dtype() == out.dtype());
+
+  // Fill output with val
+  copy_cpu(val, out, CopyType::Scalar, stream());
+
+  // Find offset for start of input values
+  size_t data_offset = 0;
+  for (int i = 0; i < axes_.size(); i++) {
+    auto ax = axes_[i] < 0 ? out.ndim() + axes_[i] : axes_[i];
+    data_offset += out.strides()[ax] * low_pad_size_[i];
+  }
+
+  // Extract slice from output where input will be pasted
+  array out_slice(in.shape(), out.dtype(), nullptr, {});
+  out_slice.copy_shared_buffer(
+      out, out.strides(), out.flags(), out_slice.size(), data_offset);
+
+  // Copy input values into the slice
+  copy_cpu_inplace(in, out_slice, CopyType::GeneralGeneral, stream());
+}
+
+void RandomBits::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  // keys has shape (N1, ..., NK, 2)
+  // out has shape (N1, ..., NK, M1, M2, ...)
+  auto& keys = inputs[0];
+  size_t num_keys = keys.size() / 2;
+
+  size_t elems_per_key = out.size() / num_keys;
+  size_t bytes_per_key = out.itemsize() * elems_per_key;
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto kptr = inputs[0].data<uint32_t>();
+  auto cptr = out.data<char>();
+  auto& encoder = cpu::get_command_encoder(stream());
+  encoder.set_input_array(inputs[0]);
+  encoder.set_output_array(out);
+  encoder.dispatch([kptr,
+                    cptr,
+                    bytes_per_key,
+                    num_keys,
+                    kshape = keys.shape(),
+                    kstrides = keys.strides()]() mutable {
+    size_t out_skip = (bytes_per_key + 4 - 1) / 4;
+    auto half_size = out_skip / 2;
+    bool even = out_skip % 2 == 0;
+    for (int i = 0; i < num_keys; ++i, cptr += bytes_per_key) {
+      auto ptr = reinterpret_cast<uint32_t*>(cptr);
+      // Get ith key
+      auto kidx = 2 * i;
+      auto k1_elem = elem_to_loc(kidx, kshape, kstrides);
+      auto k2_elem = elem_to_loc(kidx + 1, kshape, kstrides);
+      auto key = std::make_pair(kptr[k1_elem], kptr[k2_elem]);
+
+      std::pair<uintptr_t, uintptr_t> count{0, half_size + !even};
+      for (; count.first + 1 < half_size; count.first++, count.second++) {
+        std::tie(ptr[count.first], ptr[count.second]) =
+            random::threefry2x32_hash(key, count);
+      }
+      if (count.first < half_size) {
+        auto rb = random::threefry2x32_hash(key, count);
+        ptr[count.first++] = rb.first;
+        if (bytes_per_key % 4 > 0) {
+          std::copy(
+              reinterpret_cast<char*>(&rb.second),
+              reinterpret_cast<char*>(&rb.second) + bytes_per_key % 4,
+              cptr + 4 * count.second);
+        } else {
+          ptr[count.second] = rb.second;
+        }
+      }
+      if (!even) {
+        count.second = 0;
+        ptr[half_size] = random::threefry2x32_hash(key, count).first;
+      }
+    }
+  });
+}
+
+void Reshape::eval_cpu(const std::vector<array>& inputs, array& out) {
+  reshape(inputs[0], out);
+}
+
+void DynamicSlice::eval_cpu(const std::vector<array>& inputs, array& out) {
+  if (out.size() == 0) {
+    out.set_data(nullptr);
+    return;
+  }
+  auto& in = inputs[0];
+  out.set_data(allocator::malloc(out.nbytes()));
+  auto [in_offset, donated] =
+      compute_dynamic_offset(inputs[1], in.strides(), axes_, stream());
+  copy_cpu_inplace(
+      /* const array& src = */ in,
+      /* array& dst = */ out,
+      /* const Shape& data_shape = */ out.shape(),
+      /* const Strides& i_strides = */ in.strides(),
+      /* const Strides& o_strides = */ out.strides(),
+      /* int64_t i_offset = */ 0,
+      /* int64_t o_offset = */ 0,
+      /* CopyType ctype = */ CopyType::GeneralGeneral,
+      stream(),
+      /* const std::optional<array>& dynamic_i_offset = */ in_offset,
+      /* const std::optional<array>& dynamic_o_offset = */ std::nullopt);
+  if (!donated) {
+    cpu::get_command_encoder(stream()).add_temporary(std::move(in_offset));
+  }
+}
+
+void DynamicSliceUpdate::eval_cpu(
+    const std::vector<array>& inputs,
+    array& out) {
+  if (out.size() == 0) {
+    out.set_data(nullptr);
+    return;
+  }
+
+  auto& in = inputs[0];
+  auto& upd = inputs[1];
+
+  // Copy or move src to dst
+  auto ctype = in.flags().contiguous && in.size() == in.data_size()
+      ? CopyType::Vector
+      : CopyType::General;
+  copy_cpu(in, out, in.data_size() == 1 ? CopyType::Scalar : ctype, stream());
+
+  auto [out_offset, donated] =
+      compute_dynamic_offset(inputs[2], out.strides(), axes_, stream());
+  copy_cpu_inplace(
+      /* const array& src = */ upd,
+      /* array& dst = */ out,
+      /* const std::vector<int>& data_shape = */ upd.shape(),
+      /* const std::vector<stride_t>& i_strides = */ upd.strides(),
+      /* const std::vector<stride_t>& o_strides = */ out.strides(),
+      /* int64_t i_offset = */ 0,
+      /* int64_t o_offset = */ 0,
+      /* CopyType ctype = */ CopyType::GeneralGeneral,
+      stream(),
+      /* const std::optional<array>& dynamic_i_offset = */ std::nullopt,
+      /* const std::optional<array>& dynamic_o_offset = */ out_offset);
+  if (!donated) {
+    cpu::get_command_encoder(stream()).add_temporary(std::move(out_offset));
+  }
+}
+
+void SliceUpdate::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  if (out.size() == 0) {
+    out.set_data(nullptr);
+    return;
+  }
+
+  auto& in = inputs[0];
+  auto& upd = inputs[1];
+
+  if (upd.size() == 0) {
+    out.copy_shared_buffer(in);
+    return;
+  }
+
+  // Check if materialization is needed
+  auto ctype = in.flags().contiguous && in.size() == in.data_size()
+      ? CopyType::Vector
+      : CopyType::General;
+  copy_cpu(in, out, in.data_size() == 1 ? CopyType::Scalar : ctype, stream());
+
+  // Calculate out strides, initial offset and if copy needs to be made
+  auto [data_offset, out_strides] =
+      prepare_slice(out, start_indices_, strides_);
+
+  // Do copy
+  copy_cpu_inplace(
+      /* const array& src = */ upd,
+      /* array& dst = */ out,
+      /* const std::vector<int>& data_shape = */ upd.shape(),
+      /* const std::vector<stride_t>& i_strides = */ upd.strides(),
+      /* const std::vector<stride_t>& o_strides = */ out_strides,
+      /* int64_t i_offset = */ 0,
+      /* int64_t o_offset = */ data_offset,
+      /* CopyType ctype = */ CopyType::GeneralGeneral,
+      stream());
+}
+
+void View::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  auto ibytes = size_of(in.dtype());
+  auto obytes = size_of(out.dtype());
+  // Conditions for buffer copying (disjunction):
+  // - type size is the same
+  // - type size is smaller and the last axis is contiguous
+  // - the entire array is row contiguous
+  if (ibytes == obytes || (obytes < ibytes && in.strides().back() == 1) ||
+      in.flags().row_contiguous) {
+    auto strides = in.strides();
+    for (int i = 0; i < static_cast<int>(strides.size()) - 1; ++i) {
+      strides[i] *= ibytes;
+      strides[i] /= obytes;
+    }
+    out.copy_shared_buffer(
+        in, strides, in.flags(), in.data_size() * ibytes / obytes);
+  } else {
+    auto tmp = array(
+        in.shape(), in.dtype() == bool_ ? uint8 : in.dtype(), nullptr, {});
+    tmp.set_data(allocator::malloc(tmp.nbytes()));
+    if (in.dtype() == bool_) {
+      auto in_tmp = array(in.shape(), uint8, nullptr, {});
+      in_tmp.copy_shared_buffer(in);
+      copy_cpu_inplace(in_tmp, tmp, CopyType::General, stream());
+    } else {
+      copy_cpu_inplace(in, tmp, CopyType::General, stream());
+    }
+
+    auto flags = out.flags();
+    flags.contiguous = true;
+    flags.row_contiguous = true;
+    auto max_dim = std::max_element(out.shape().begin(), out.shape().end());
+    flags.col_contiguous = out.size() <= 1 || out.size() == *max_dim;
+    out.copy_shared_buffer(tmp, out.strides(), flags, out.size());
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..13c7e1132183ebdcd9858f972890ba6fa6318daa
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/qrf.cpp
@@ -0,0 +1,147 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/allocator.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/lapack.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+template <typename T>
+void qrf_impl(const array& a, array& q, array& r, Stream stream) {
+  const int M = a.shape(-2);
+  const int N = a.shape(-1);
+  const int lda = M;
+  size_t num_matrices = a.size() / (M * N);
+
+  // Copy A to inplace input and make it col-contiguous
+  array in(a.shape(), a.dtype(), nullptr, {});
+  auto flags = in.flags();
+
+  // Copy the input to be column contiguous
+  flags.col_contiguous = num_matrices == 1;
+  flags.row_contiguous = false;
+  auto strides = in.strides();
+  strides[in.ndim() - 2] = 1;
+  strides[in.ndim() - 1] = M;
+  in.set_data(allocator::malloc(in.nbytes()), in.nbytes(), strides, flags);
+  copy_cpu_inplace(a, in, CopyType::GeneralGeneral, stream);
+  auto& encoder = cpu::get_command_encoder(stream);
+  q.set_data(allocator::malloc(q.nbytes()));
+  r.set_data(allocator::malloc(r.nbytes()));
+
+  auto in_ptr = in.data<T>();
+  auto r_ptr = r.data<T>();
+  auto q_ptr = q.data<T>();
+
+  encoder.set_input_array(in);
+  encoder.set_output_array(q);
+  encoder.set_output_array(r);
+  encoder.dispatch([in_ptr, q_ptr, r_ptr, M, N, lda, num_matrices]() {
+    int num_reflectors = std::min(M, N);
+    auto tau = allocator::malloc(sizeof(T) * num_matrices * num_reflectors);
+
+    T optimal_work;
+    int lwork = -1;
+    int info;
+
+    // Compute workspace size
+    geqrf<T>(&M, &N, nullptr, &lda, nullptr, &optimal_work, &lwork, &info);
+
+    // Update workspace size
+    lwork = optimal_work;
+    auto work = allocator::malloc(sizeof(T) * lwork);
+
+    // Loop over matrices
+    for (int i = 0; i < num_matrices; ++i) {
+      // Solve
+      geqrf<T>(
+          &M,
+          &N,
+          in_ptr + M * N * i,
+          &lda,
+          static_cast<T*>(tau.raw_ptr()) + num_reflectors * i,
+          static_cast<T*>(work.raw_ptr()),
+          &lwork,
+          &info);
+    }
+    allocator::free(work);
+
+    for (int i = 0; i < num_matrices; ++i) {
+      /// num_reflectors x N
+      for (int j = 0; j < num_reflectors; ++j) {
+        for (int k = 0; k < j; ++k) {
+          r_ptr[i * N * num_reflectors + j * N + k] = 0;
+        }
+        for (int k = j; k < N; ++k) {
+          r_ptr[i * N * num_reflectors + j * N + k] =
+              in_ptr[i * N * M + j + k * M];
+        }
+      }
+    }
+
+    // Get work size
+    lwork = -1;
+    orgqr<T>(
+        &M,
+        &num_reflectors,
+        &num_reflectors,
+        nullptr,
+        &lda,
+        nullptr,
+        &optimal_work,
+        &lwork,
+        &info);
+    lwork = optimal_work;
+    work = allocator::malloc(sizeof(T) * lwork);
+
+    // Loop over matrices
+    for (int i = 0; i < num_matrices; ++i) {
+      // Compute Q
+      orgqr<T>(
+          &M,
+          &num_reflectors,
+          &num_reflectors,
+          in_ptr + M * N * i,
+          &lda,
+          static_cast<T*>(tau.raw_ptr()) + num_reflectors * i,
+          static_cast<T*>(work.raw_ptr()),
+          &lwork,
+          &info);
+    }
+
+    for (int i = 0; i < num_matrices; ++i) {
+      // M x num_reflectors
+      for (int j = 0; j < M; ++j) {
+        for (int k = 0; k < num_reflectors; ++k) {
+          q_ptr[i * M * num_reflectors + j * num_reflectors + k] =
+              in_ptr[i * N * M + j + k * M];
+        }
+      }
+    }
+
+    // Cleanup
+    allocator::free(work);
+    allocator::free(tau);
+  });
+  encoder.add_temporary(in);
+}
+
+void QRF::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  switch (inputs[0].dtype()) {
+    case float32:
+      qrf_impl<float>(inputs[0], outputs[0], outputs[1], stream());
+      break;
+    case float64:
+      qrf_impl<double>(inputs[0], outputs[0], outputs[1], stream());
+      break;
+    default:
+      throw std::runtime_error(
+          "[QRF::eval_cpu] only supports float32 or float64.");
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a475131f7bae0545cf359b51a4d36072707284b1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/quantized.cpp
@@ -0,0 +1,1107 @@
+// Copyright © 2023 Apple Inc.
+
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/simd/simd.h"
+#include "mlx/fast_primitives.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+namespace {
+
+const static float MXFP4_LUT[16] = {
+    +0.0f,
+    +0.5f,
+    +1.0f,
+    +1.5f,
+    +2.0f,
+    +3.0f,
+    +4.0f,
+    +6.0f,
+    -0.0f,
+    -0.5f,
+    -1.0f,
+    -1.5f,
+    -2.0f,
+    -3.0f,
+    -4.0f,
+    -6.0f};
+
+template <typename T>
+static inline T dequantize_scale(uint8_t s) {
+  using FOrI = union {
+    bfloat16_t f;
+    uint16_t i;
+  };
+  FOrI out;
+  out.i = (s == 0 ? 0x40 : (static_cast<uint16_t>(s) << 7));
+  return static_cast<T>(out.f);
+}
+
+inline constexpr short get_pack_factor(int bits, int wsize = 8) {
+  return (bits == 3 || bits == 5) ? 8 : (bits == 6 ? 4 : wsize / bits);
+}
+
+inline constexpr short get_bytes_per_pack(int bits, int wsize = 8) {
+  auto power_of_2_bits = (bits & (bits - 1)) == 0;
+  return power_of_2_bits ? (wsize / 8) : (bits == 5 ? 5 : 3);
+}
+
+template <typename T, int bits>
+void extract_bits(const uint8_t* w_in, T* w_out) {
+  static_assert(bits == 3 || bits == 5 || bits == 6);
+  if (bits == 3) {
+    w_out[0] = static_cast<T>(w_in[0] & 0x7);
+    w_out[1] = static_cast<T>((w_in[0] & 0x38) >> 3);
+    w_out[2] = static_cast<T>(((w_in[0] & 0xc0) >> 6) + ((w_in[1] & 0x1) << 2));
+    w_out[3] = static_cast<T>((w_in[1] & 0xe) >> 1);
+    w_out[4] = static_cast<T>((w_in[1] & 0x70) >> 4);
+    w_out[5] = static_cast<T>(((w_in[1] & 0x80) >> 7) + ((w_in[2] & 0x3) << 1));
+    w_out[6] = static_cast<T>((w_in[2] & 0x1c) >> 2);
+    w_out[7] = static_cast<T>((w_in[2] & 0xe0) >> 5);
+  } else if (bits == 5) {
+    w_out[0] = static_cast<T>(w_in[0] & 0x1f);
+    w_out[1] = static_cast<T>(((w_in[0] & 0xe0) >> 5) + ((w_in[1] & 0x3) << 3));
+    w_out[2] = static_cast<T>((w_in[1] & 0x7c) >> 2);
+    w_out[3] = static_cast<T>(((w_in[1] & 0x80) >> 7) + ((w_in[2] & 0xf) << 1));
+    w_out[4] = static_cast<T>(((w_in[2] & 0xf0) >> 4) + ((w_in[3] & 0x1) << 4));
+    w_out[5] = static_cast<T>((w_in[3] & 0x3e) >> 1);
+    w_out[6] = static_cast<T>(((w_in[3] & 0xc0) >> 6) + ((w_in[4] & 0x7) << 2));
+    w_out[7] = static_cast<T>((w_in[4] & 0xf8) >> 3);
+
+  } else if (bits == 6) {
+    w_out[0] = static_cast<T>(w_in[0] & 0x3f);
+    w_out[1] =
+        static_cast<T>(((w_in[0] >> 6) & 0x03) + ((w_in[1] & 0x0f) << 2));
+    w_out[2] =
+        static_cast<T>(((w_in[1] >> 4) & 0x0f) + ((w_in[2] & 0x03) << 4));
+    w_out[3] = static_cast<T>((w_in[2] >> 2) & 0x3f);
+  }
+}
+
+template <typename T, int bits, int group_size>
+void _qmm(
+    T* result,
+    const T* x,
+    const uint32_t* w,
+    const T* scales,
+    const T* biases,
+    int M,
+    int N,
+    int K) {
+  constexpr int bitmask = (1 << bits) - 1;
+  constexpr int pack_factor = get_pack_factor(bits, 8);
+  constexpr int bytes_per_pack = get_bytes_per_pack(bits);
+  constexpr int packs_in_group = group_size / pack_factor;
+
+  for (int m = 0; m < M; m++) {
+    const uint8_t* w_local = (const uint8_t*)w;
+    const T* scales_local = scales;
+    const T* biases_local = biases;
+
+    std::fill(result, result + N, 0);
+
+    for (int k = 0; k < K; k++) {
+      T* result_local = result;
+      T xi = *x++;
+
+      for (int n = 0; n < N; n += group_size) {
+        T scale = *scales_local++;
+        T bias = *biases_local++;
+        for (int ng = 0; ng < packs_in_group; ng++) {
+          if constexpr (bits == 3 || bits == 5 || bits == 6) {
+            T wl[pack_factor];
+            extract_bits<T, bits>(w_local, wl);
+#pragma clang loop unroll(full)
+            for (int p = 0; p < pack_factor; p++) {
+              (*result_local++) += xi * (scale * wl[p] + bias);
+            }
+            w_local += bytes_per_pack;
+
+          } else {
+            uint8_t wi = *w_local++;
+#pragma clang loop unroll(full)
+            for (int p = 0; p < pack_factor; p++) {
+              (*result_local++) +=
+                  xi * (scale * static_cast<T>(wi & bitmask) + bias);
+              if (bits != 8) {
+                wi >>= bits;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    result += N;
+  }
+}
+
+template <typename T, int bits, int group_size>
+void _qmm_t(
+    T* result,
+    const T* x,
+    const uint32_t* w,
+    const T* scales,
+    const T* biases,
+    int M,
+    int N,
+    int K) {
+  constexpr int bitmask = (1 << bits) - 1;
+
+  constexpr int pack_factor = get_pack_factor(bits, 8);
+  constexpr int bytes_per_pack = get_bytes_per_pack(bits);
+  constexpr int packs_in_group = group_size / pack_factor;
+
+  for (int m = 0; m < M; m++) {
+    const uint8_t* w_local = (const uint8_t*)w;
+    const T* scales_local = scales;
+    const T* biases_local = biases;
+
+    for (int n = 0; n < N; n++) {
+      const T* x_local = x;
+      T sum = 0;
+      for (int k = 0; k < K; k += group_size) {
+        T scale = *scales_local++;
+        T bias = *biases_local++;
+
+        for (int kw = 0; kw < packs_in_group; kw++) {
+          if constexpr (bits == 3 || bits == 5 || bits == 6) {
+            T wl[pack_factor];
+            extract_bits<T, bits>(w_local, wl);
+#pragma clang loop unroll(full)
+            for (int p = 0; p < pack_factor; p++) {
+              sum += x_local[p] * (scale * wl[p] + bias);
+            }
+            w_local += bytes_per_pack;
+            x_local += pack_factor;
+
+          } else {
+            uint8_t wi = *w_local++;
+#pragma clang loop unroll(full)
+            for (int p = 0; p < pack_factor; p++) {
+              sum +=
+                  (*x_local++) * (scale * static_cast<T>(wi & bitmask) + bias);
+              if (bits != 8) {
+                wi >>= bits;
+              }
+            }
+          }
+        }
+      }
+      *result = sum;
+      result++;
+    }
+
+    x += K;
+  }
+}
+
+template <int bits, int S>
+simd::Simd<uint32_t, S> extract_bits_simd(const uint32_t* w) {
+  constexpr int bitmask = (1 << bits) - 1;
+  simd::Simd<uint32_t, S> wi;
+  if constexpr (bits == 4 && S == 8) {
+    constexpr std::array<uint32_t, 8> shifts_ = {{0, 4, 8, 12, 16, 20, 24, 28}};
+    auto shifts(*(simd::Simd<uint32_t, S>*)&shifts_);
+    wi = simd::Simd<uint32_t, S>(*w);
+    wi = wi >> shifts;
+    wi = wi & bitmask;
+  } else if constexpr (bits == 8 && S == 8) {
+    constexpr std::array<uint32_t, 8> shifts_ = {{0, 8, 16, 24, 0, 8, 16, 24}};
+    auto shifts(*(simd::Simd<uint32_t, S>*)&shifts_);
+    auto l = simd::Simd<uint32_t, S / 2>(*w++);
+    auto r = simd::Simd<uint32_t, S / 2>(*w);
+    wi = simd::Simd<uint32_t, S>(l, r);
+    wi = wi >> shifts;
+    wi = wi & bitmask;
+  } else {
+    // Appease compiler.. but should never get here
+    throw std::runtime_error("Unsupported combination for simd qmm.");
+  }
+  return wi;
+}
+
+template <typename T, int bits, int group_size>
+void _qmm_t_simd(
+    T* result,
+    const T* x,
+    const uint32_t* w,
+    const T* scales,
+    const T* biases,
+    int M,
+    int N,
+    int K) {
+  constexpr int pack_factor = 32 / bits;
+  constexpr int packs_in_group = group_size / pack_factor;
+  constexpr int S = simd::max_size<T>;
+  static_assert(
+      S % pack_factor == 0, "SIMD size must be divisible by pack factor");
+  constexpr int packs_per_simd = S / pack_factor;
+
+  for (int m = 0; m < M; m++) {
+    const uint32_t* w_local = w;
+    const T* scales_local = scales;
+    const T* biases_local = biases;
+
+    for (int n = 0; n < N; n++) {
+      simd::Simd<float, S> acc(0);
+      auto x_local = x;
+      for (int k = 0; k < K; k += group_size) {
+        T scale = *scales_local++;
+        T bias = *biases_local++;
+
+        for (int kw = 0; kw < packs_in_group; kw += packs_per_simd) {
+          auto wf = simd::Simd<float, S>(extract_bits_simd<bits, S>(w_local));
+          w_local += packs_per_simd;
+          wf = wf * scale;
+          wf = wf + bias;
+          simd::Simd<float, S> x_simd = simd::load<T, S>(x_local);
+          acc = acc + x_simd * wf;
+          x_local += S;
+        }
+      }
+
+      *result = T(simd::sum(acc));
+      result++;
+    }
+    x += K;
+  }
+}
+
+template <typename T, int bits, int group_size>
+void _qmm_dispatch_transpose(
+    T* result,
+    const T* x,
+    const uint32_t* w,
+    const T* scales,
+    const T* biases,
+    int M,
+    int N,
+    int K,
+    bool transposed_w) {
+  if (transposed_w) {
+    // the simd size must be a multiple of the number of elements per word
+    if constexpr (32 % bits == 0 && simd::max_size<T> % (32 / bits) == 0) {
+      _qmm_t_simd<T, bits, group_size>(result, x, w, scales, biases, M, N, K);
+    } else {
+      _qmm_t<T, bits, group_size>(result, x, w, scales, biases, M, N, K);
+    }
+  } else {
+    _qmm<T, bits, group_size>(result, x, w, scales, biases, M, N, K);
+  }
+}
+
+template <typename T, int bits>
+void _qmm_dispatch_group(
+    T* result,
+    const T* x,
+    const uint32_t* w,
+    const T* scales,
+    const T* biases,
+    int M,
+    int N,
+    int K,
+    int group_size,
+    bool transposed_w) {
+  switch (group_size) {
+    case 32:
+      _qmm_dispatch_transpose<T, bits, 32>(
+          result, x, w, scales, biases, M, N, K, transposed_w);
+      break;
+    case 64:
+      _qmm_dispatch_transpose<T, bits, 64>(
+          result, x, w, scales, biases, M, N, K, transposed_w);
+      break;
+    case 128:
+      _qmm_dispatch_transpose<T, bits, 128>(
+          result, x, w, scales, biases, M, N, K, transposed_w);
+      break;
+    default:
+      throw std::invalid_argument(
+          "Quantization group size must be 32, 64 or 128.");
+  }
+}
+
+template <typename T>
+void _qmm_dispatch_typed(
+    T* result,
+    const T* x,
+    const uint32_t* w,
+    const T* scales,
+    const T* biases,
+    int M,
+    int N,
+    int K,
+    int group_size,
+    int bits,
+    bool transposed_w) {
+  switch (bits) {
+    case 2:
+      _qmm_dispatch_group<T, 2>(
+          result, x, w, scales, biases, M, N, K, group_size, transposed_w);
+      break;
+    case 3:
+      _qmm_dispatch_group<T, 3>(
+          result, x, w, scales, biases, M, N, K, group_size, transposed_w);
+      break;
+    case 4:
+      _qmm_dispatch_group<T, 4>(
+          result, x, w, scales, biases, M, N, K, group_size, transposed_w);
+      break;
+    case 5:
+      _qmm_dispatch_group<T, 5>(
+          result, x, w, scales, biases, M, N, K, group_size, transposed_w);
+      break;
+    case 6:
+      _qmm_dispatch_group<T, 6>(
+          result, x, w, scales, biases, M, N, K, group_size, transposed_w);
+      break;
+    case 8:
+      _qmm_dispatch_group<T, 8>(
+          result, x, w, scales, biases, M, N, K, group_size, transposed_w);
+      break;
+    default:
+      throw std::invalid_argument("Quantization bits must be 2, 3, 4, 6 or 8.");
+  }
+}
+
+template <typename T>
+void _qmm_dispatch_typed(
+    array& out,
+    const array& x,
+    const array& w,
+    const array& scales,
+    const array& biases,
+    int bits,
+    int group_size,
+    bool transposed_w) {
+  int K = x.shape(-1);
+  int M = x.ndim() > 1 ? x.shape(-2) : 1;
+  int N = out.shape(-1);
+  int w_els = w.ndim() > 2 ? w.shape(-1) * w.shape(-2) : 0;
+  int g_els = w.ndim() > 2 ? scales.shape(-1) * scales.shape(-2) : 0;
+  int batch_size = x.size() / (K * M);
+
+  auto out_ptr = out.data<T>();
+  auto x_ptr = x.data<T>();
+  auto w_ptr = w.data<uint32_t>();
+  auto scales_ptr = scales.data<T>();
+  auto biases_ptr = biases.data<T>();
+  for (int i = 0; i < batch_size; i++) {
+    _qmm_dispatch_typed<T>(
+        out_ptr + i * M * N,
+        x_ptr + elem_to_loc(i * M * K, x.shape(), x.strides()),
+        w_ptr + elem_to_loc(i * w_els, w.shape(), w.strides()),
+        scales_ptr + elem_to_loc(i * g_els, scales.shape(), scales.strides()),
+        biases_ptr + elem_to_loc(i * g_els, biases.shape(), biases.strides()),
+        M,
+        N,
+        K,
+        bits,
+        group_size,
+        transposed_w);
+  }
+}
+
+void _qmm_dispatch(
+    array& out,
+    const array& x,
+    const array& w,
+    const array& scales,
+    const array& biases,
+    int bits,
+    int group_size,
+    bool transposed_w) {
+  switch (x.dtype()) {
+    case float32:
+      _qmm_dispatch_typed<float>(
+          out, x, w, scales, biases, bits, group_size, transposed_w);
+      break;
+    case float16:
+      _qmm_dispatch_typed<float16_t>(
+          out, x, w, scales, biases, bits, group_size, transposed_w);
+      break;
+    case bfloat16:
+      _qmm_dispatch_typed<bfloat16_t>(
+          out, x, w, scales, biases, bits, group_size, transposed_w);
+      break;
+    default:
+      throw std::invalid_argument(
+          "[quantized_matmul] only floating types are supported");
+  }
+}
+
+template <typename T>
+void mxfp4_qmm(
+    T* result,
+    const T* x,
+    const uint32_t* w,
+    const uint8_t* scales,
+    int M,
+    int N,
+    int K) {
+  constexpr int group_size = 32;
+  constexpr int pack_factor = get_pack_factor(4, 8);
+  constexpr int bytes_per_pack = get_bytes_per_pack(4);
+  constexpr int packs_in_group = group_size / pack_factor;
+
+  for (int m = 0; m < M; m++) {
+    const uint8_t* w_local = (const uint8_t*)w;
+    const uint8_t* scales_local = scales;
+
+    std::fill(result, result + N, 0);
+
+    for (int k = 0; k < K; k++) {
+      T* result_local = result;
+      T xi = *x++;
+
+      for (int n = 0; n < N; n += group_size) {
+        T scale = dequantize_scale<T>(*scales_local++);
+        for (int ng = 0; ng < packs_in_group; ng++) {
+          uint8_t wi = *w_local++;
+#pragma clang loop unroll(full)
+          for (int p = 0; p < pack_factor; p++) {
+            (*result_local++) +=
+                xi * scale * static_cast<T>(MXFP4_LUT[wi & 0xf]);
+            wi >>= 4;
+          }
+        }
+      }
+    }
+
+    result += N;
+  }
+}
+
+template <typename T>
+void mxfp4_qmm_t(
+    T* result,
+    const T* x,
+    const uint32_t* w,
+    const uint8_t* scales,
+    int M,
+    int N,
+    int K) {
+  constexpr int group_size = 32;
+  constexpr int pack_factor = get_pack_factor(4, 8);
+  constexpr int bytes_per_pack = get_bytes_per_pack(4);
+  constexpr int packs_in_group = group_size / pack_factor;
+
+  for (int m = 0; m < M; m++) {
+    const uint8_t* w_local = (const uint8_t*)w;
+    const uint8_t* scales_local = scales;
+
+    for (int n = 0; n < N; n++) {
+      const T* x_local = x;
+      T sum = 0;
+      for (int k = 0; k < K; k += group_size) {
+        T scale = dequantize_scale<T>(*scales_local++);
+
+        T gsum = 0;
+        for (int kw = 0; kw < packs_in_group; kw++) {
+          uint8_t wi = *w_local++;
+#pragma clang loop unroll(full)
+          for (int p = 0; p < pack_factor; p++) {
+            gsum += (*x_local++) * static_cast<T>(MXFP4_LUT[wi & 0xf]);
+            wi >>= 4;
+          }
+        }
+        sum += scale * gsum;
+      }
+      *result = sum;
+      result++;
+    }
+
+    x += K;
+  }
+}
+
+template <int S>
+simd::Simd<float, S> mxfp4_extract_bits_simd(const uint32_t* w) {
+  if constexpr (S == 8) {
+    constexpr std::array<uint32_t, 8> shifts_ = {{0, 4, 8, 12, 16, 20, 24, 28}};
+    auto shifts(*(simd::Simd<uint32_t, S>*)&shifts_);
+    auto wi = simd::Simd<uint32_t, S>(*w);
+    wi = wi >> shifts;
+    wi = wi & 0xf;
+    simd::Simd<float, S> w_out;
+    for (int i = 0; i < S; ++i) {
+      w_out[i] = MXFP4_LUT[wi[i]];
+    }
+    return w_out;
+  } else {
+    // Appease compiler.. but should never get here
+    throw std::runtime_error("Unsupported combination for simd qmm.");
+  }
+}
+
+template <typename T>
+void mxfp4_qmm_t_simd(
+    T* result,
+    const T* x,
+    const uint32_t* w,
+    const uint8_t* scales,
+    int M,
+    int N,
+    int K) {
+  constexpr int group_size = 32;
+  constexpr int pack_factor = 32 / 4;
+  constexpr int packs_in_group = group_size / pack_factor;
+  constexpr int S = simd::max_size<T>;
+  static_assert(
+      S % pack_factor == 0, "SIMD size must be divisible by pack factor");
+  constexpr int packs_per_simd = S / pack_factor;
+
+  for (int m = 0; m < M; m++) {
+    const uint32_t* w_local = w;
+    const uint8_t* scales_local = scales;
+
+    for (int n = 0; n < N; n++) {
+      simd::Simd<float, S> acc(0);
+      auto x_local = x;
+      for (int k = 0; k < K; k += group_size) {
+        T scale = dequantize_scale<T>(*scales_local++);
+
+        simd::Simd<float, S> g_acc(0);
+        for (int kw = 0; kw < packs_in_group; kw += packs_per_simd) {
+          // Extract bits
+          auto wf = mxfp4_extract_bits_simd<S>(w_local);
+          w_local += packs_per_simd;
+          simd::Simd<float, S> x_simd = simd::load<T, S>(x_local);
+          g_acc = g_acc + x_simd * wf;
+          x_local += S;
+        }
+        acc = acc + scale * g_acc;
+      }
+
+      *result = T(simd::sum(acc));
+      result++;
+    }
+    x += K;
+  }
+}
+
+template <typename T>
+void mxfp4_qmm_dispatch_transpose(
+    T* result,
+    const T* x,
+    const uint32_t* w,
+    const uint8_t* scales,
+    int M,
+    int N,
+    int K,
+    bool transposed_w) {
+  if (transposed_w) {
+    // the simd size must be a multiple of the number of elements per word
+    if constexpr (simd::max_size<T> % 8 == 0) {
+      mxfp4_qmm_t_simd<T>(result, x, w, scales, M, N, K);
+    } else {
+      mxfp4_qmm_t<T>(result, x, w, scales, M, N, K);
+    }
+  } else {
+    mxfp4_qmm<T>(result, x, w, scales, M, N, K);
+  }
+}
+
+template <typename T>
+void mxfp4_qmm_dispatch_typed(
+    array& out,
+    const array& x,
+    const array& w,
+    const array& scales,
+    bool transposed_w) {
+  int K = x.shape(-1);
+  int M = x.ndim() > 1 ? x.shape(-2) : 1;
+  int N = out.shape(-1);
+  int w_els = w.ndim() > 2 ? w.shape(-1) * w.shape(-2) : 0;
+  int g_els = w.ndim() > 2 ? scales.shape(-1) * scales.shape(-2) : 0;
+  int batch_size = x.size() / (K * M);
+
+  auto out_ptr = out.data<T>();
+  auto x_ptr = x.data<T>();
+  auto w_ptr = w.data<uint32_t>();
+  auto scales_ptr = scales.data<uint8_t>();
+  for (int i = 0; i < batch_size; i++) {
+    mxfp4_qmm_dispatch_transpose<T>(
+        out_ptr + i * M * N,
+        x_ptr + elem_to_loc(i * M * K, x.shape(), x.strides()),
+        w_ptr + elem_to_loc(i * w_els, w.shape(), w.strides()),
+        scales_ptr + elem_to_loc(i * g_els, scales.shape(), scales.strides()),
+        M,
+        N,
+        K,
+        transposed_w);
+  }
+}
+
+void mxfp4_qmm_dispatch(
+    array& out,
+    const array& x,
+    const array& w,
+    const array& scales,
+    bool transposed_w) {
+  switch (x.dtype()) {
+    case bfloat16:
+      mxfp4_qmm_dispatch_typed<bfloat16_t>(out, x, w, scales, transposed_w);
+      break;
+    case float16:
+      mxfp4_qmm_dispatch_typed<float16_t>(out, x, w, scales, transposed_w);
+      break;
+    case float32:
+      mxfp4_qmm_dispatch_typed<float>(out, x, w, scales, transposed_w);
+      break;
+    default:
+      throw std::invalid_argument(
+          "[quantized_matmul] only floating types are supported");
+  }
+}
+
+template <typename T>
+void _bs_qmm_dispatch_typed(
+    array& out,
+    const array& x,
+    const array& w,
+    const array& scales,
+    const array& biases,
+    const array& lhs_indices,
+    const array& rhs_indices,
+    int bits,
+    int group_size,
+    bool transposed_w) {
+  int K = x.shape(-1);
+  int M = x.shape(-2);
+  int N = out.shape(-1);
+
+  int w_els = w.shape(-1) * w.shape(-2);
+  int g_els = scales.shape(-1) * scales.shape(-2);
+
+  auto out_ptr = out.data<T>();
+  auto x_ptr = x.data<T>();
+  auto w_ptr = w.data<uint32_t>();
+  auto scales_ptr = scales.data<T>();
+  auto biases_ptr = biases.data<T>();
+  auto lhs_indices_ptr = lhs_indices.data<uint32_t>();
+  auto rhs_indices_ptr = rhs_indices.data<uint32_t>();
+
+  for (int i = 0; i < lhs_indices.size(); i++) {
+    int x_idx = lhs_indices_ptr[elem_to_loc(
+        i, lhs_indices.shape(), lhs_indices.strides())];
+    int w_idx = rhs_indices_ptr[elem_to_loc(
+        i, rhs_indices.shape(), rhs_indices.strides())];
+    _qmm_dispatch_typed<T>(
+        out_ptr + i * M * N,
+        x_ptr + elem_to_loc(x_idx * M * K, x.shape(), x.strides()),
+        w_ptr + elem_to_loc(w_idx * w_els, w.shape(), w.strides()),
+        scales_ptr +
+            elem_to_loc(w_idx * g_els, scales.shape(), scales.strides()),
+        biases_ptr +
+            elem_to_loc(w_idx * g_els, biases.shape(), biases.strides()),
+        M,
+        N,
+        K,
+        bits,
+        group_size,
+        transposed_w);
+  }
+}
+
+void _bs_qmm_dispatch(
+    array& out,
+    const array& x,
+    const array& w,
+    const array& scales,
+    const array& biases,
+    const array& lhs_indices,
+    const array& rhs_indices,
+    int bits,
+    int group_size,
+    bool transposed_w) {
+  switch (x.dtype()) {
+    case float32:
+      _bs_qmm_dispatch_typed<float>(
+          out,
+          x,
+          w,
+          scales,
+          biases,
+          lhs_indices,
+          rhs_indices,
+          bits,
+          group_size,
+          transposed_w);
+      break;
+    case float16:
+      _bs_qmm_dispatch_typed<float16_t>(
+          out,
+          x,
+          w,
+          scales,
+          biases,
+          lhs_indices,
+          rhs_indices,
+          bits,
+          group_size,
+          transposed_w);
+      break;
+    case bfloat16:
+      _bs_qmm_dispatch_typed<bfloat16_t>(
+          out,
+          x,
+          w,
+          scales,
+          biases,
+          lhs_indices,
+          rhs_indices,
+          bits,
+          group_size,
+          transposed_w);
+      break;
+    default:
+      throw std::invalid_argument(
+          "[quantized_matmul] only floating types are supported");
+  }
+}
+
+template <typename T>
+void mxfp4_bs_qmm_dispatch_typed(
+    array& out,
+    const array& x,
+    const array& w,
+    const array& scales,
+    const array& lhs_indices,
+    const array& rhs_indices,
+    bool transposed_w) {
+  int K = x.shape(-1);
+  int M = x.shape(-2);
+  int N = out.shape(-1);
+
+  int w_els = w.shape(-1) * w.shape(-2);
+  int g_els = scales.shape(-1) * scales.shape(-2);
+
+  auto out_ptr = out.data<T>();
+  auto x_ptr = x.data<T>();
+  auto w_ptr = w.data<uint32_t>();
+  auto scales_ptr = scales.data<uint8_t>();
+  auto lhs_indices_ptr = lhs_indices.data<uint32_t>();
+  auto rhs_indices_ptr = rhs_indices.data<uint32_t>();
+
+  for (int i = 0; i < lhs_indices.size(); i++) {
+    int x_idx = lhs_indices_ptr[elem_to_loc(
+        i, lhs_indices.shape(), lhs_indices.strides())];
+    int w_idx = rhs_indices_ptr[elem_to_loc(
+        i, rhs_indices.shape(), rhs_indices.strides())];
+    mxfp4_qmm_dispatch_transpose<T>(
+        out_ptr + i * M * N,
+        x_ptr + elem_to_loc(x_idx * M * K, x.shape(), x.strides()),
+        w_ptr + elem_to_loc(w_idx * w_els, w.shape(), w.strides()),
+        scales_ptr +
+            elem_to_loc(w_idx * g_els, scales.shape(), scales.strides()),
+        M,
+        N,
+        K,
+        transposed_w);
+  }
+}
+
+void mxfp4_bs_qmm_dispatch(
+    array& out,
+    const array& x,
+    const array& w,
+    const array& scales,
+    const array& lhs_indices,
+    const array& rhs_indices,
+    bool transposed_w) {
+  switch (x.dtype()) {
+    case float32:
+      mxfp4_bs_qmm_dispatch_typed<float>(
+          out, x, w, scales, lhs_indices, rhs_indices, transposed_w);
+      break;
+    case float16:
+      mxfp4_bs_qmm_dispatch_typed<float16_t>(
+          out, x, w, scales, lhs_indices, rhs_indices, transposed_w);
+      break;
+    case bfloat16:
+      mxfp4_bs_qmm_dispatch_typed<bfloat16_t>(
+          out, x, w, scales, lhs_indices, rhs_indices, transposed_w);
+      break;
+    default:
+      throw std::invalid_argument(
+          "[quantized_matmul] only floating types are supported");
+  }
+}
+
+} // namespace
+
+void QuantizedMatmul::eval_cpu(const std::vector<array>& inputs, array& out) {
+  auto& x_pre = inputs[0];
+  auto& w_pre = inputs[1];
+  auto& scales_pre = inputs[2];
+
+  auto& encoder = cpu::get_command_encoder(stream());
+  auto ensure_row_contiguous = [s = stream(), &encoder](const array& arr) {
+    if (arr.flags().row_contiguous) {
+      return arr;
+    } else {
+      auto arr_cpy = array(arr.shape(), arr.dtype(), nullptr, {});
+      copy_cpu(arr, arr_cpy, CopyType::General, s);
+      encoder.add_temporary(arr_cpy);
+      return arr_cpy;
+    }
+  };
+
+  auto x = ensure_row_contiguous(x_pre);
+  auto w = ensure_row_contiguous(w_pre);
+  auto scales = ensure_row_contiguous(scales_pre);
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  encoder.set_input_array(x);
+  encoder.set_input_array(w);
+  encoder.set_input_array(scales);
+  encoder.set_output_array(out);
+  if (mode_ == QuantizationMode::Affine) {
+    auto biases = ensure_row_contiguous(inputs[3]);
+    encoder.set_input_array(biases);
+    encoder.dispatch([out = array::unsafe_weak_copy(out),
+                      x = array::unsafe_weak_copy(x),
+                      w = array::unsafe_weak_copy(w),
+                      scales = array::unsafe_weak_copy(scales),
+                      biases = array::unsafe_weak_copy(biases),
+                      group_size_ = group_size_,
+                      bits_ = bits_,
+                      transpose_ = transpose_]() mutable {
+      _qmm_dispatch(out, x, w, scales, biases, group_size_, bits_, transpose_);
+    });
+  } else {
+    encoder.dispatch([out = array::unsafe_weak_copy(out),
+                      x = array::unsafe_weak_copy(x),
+                      w = array::unsafe_weak_copy(w),
+                      scales = array::unsafe_weak_copy(scales),
+                      transpose_ = transpose_]() mutable {
+      mxfp4_qmm_dispatch(out, x, w, scales, transpose_);
+    });
+  }
+}
+
+void GatherQMM::eval_cpu(const std::vector<array>& inputs, array& out) {
+  auto& x_pre = inputs[0];
+  auto& w_pre = inputs[1];
+  auto& scales_pre = inputs[2];
+  auto& lhs_indices = inputs[inputs.size() - 2];
+  auto& rhs_indices = inputs[inputs.size() - 1];
+
+  auto& encoder = cpu::get_command_encoder(stream());
+  auto ensure_row_contiguous_last_dims = [s = stream(),
+                                          &encoder](const array& arr) {
+    auto stride_0 = arr.strides()[arr.ndim() - 2];
+    auto stride_1 = arr.strides()[arr.ndim() - 1];
+    if (stride_0 == arr.shape(-1) && stride_1 == 1) {
+      return arr;
+    } else {
+      auto arr_cpy = array(arr.shape(), arr.dtype(), nullptr, {});
+      copy_cpu(arr, arr_cpy, CopyType::General, s);
+      encoder.add_temporary(arr_cpy);
+      return arr_cpy;
+    }
+  };
+
+  auto x = ensure_row_contiguous_last_dims(x_pre);
+  auto w = ensure_row_contiguous_last_dims(w_pre);
+  auto scales = ensure_row_contiguous_last_dims(scales_pre);
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  encoder.set_input_array(x);
+  encoder.set_input_array(w);
+  encoder.set_input_array(scales);
+  encoder.set_input_array(lhs_indices);
+  encoder.set_input_array(rhs_indices);
+  encoder.set_output_array(out);
+  if (mode_ == QuantizationMode::Affine) {
+    auto biases = ensure_row_contiguous_last_dims(inputs[3]);
+    encoder.set_input_array(biases);
+    encoder.dispatch([out = array::unsafe_weak_copy(out),
+                      x = array::unsafe_weak_copy(x),
+                      w = array::unsafe_weak_copy(w),
+                      scales = array::unsafe_weak_copy(scales),
+                      biases = array::unsafe_weak_copy(biases),
+                      lhs_indices = array::unsafe_weak_copy(lhs_indices),
+                      rhs_indices = array::unsafe_weak_copy(rhs_indices),
+                      group_size_ = group_size_,
+                      bits_ = bits_,
+                      transpose_ = transpose_]() mutable {
+      _bs_qmm_dispatch(
+          out,
+          x,
+          w,
+          scales,
+          biases,
+          lhs_indices,
+          rhs_indices,
+          group_size_,
+          bits_,
+          transpose_);
+    });
+  } else {
+    encoder.dispatch([out = array::unsafe_weak_copy(out),
+                      x = array::unsafe_weak_copy(x),
+                      w = array::unsafe_weak_copy(w),
+                      scales = array::unsafe_weak_copy(scales),
+                      lhs_indices = array::unsafe_weak_copy(lhs_indices),
+                      rhs_indices = array::unsafe_weak_copy(rhs_indices),
+                      transpose_ = transpose_]() mutable {
+      mxfp4_bs_qmm_dispatch(
+          out, x, w, scales, lhs_indices, rhs_indices, transpose_);
+    });
+  }
+}
+
+template <typename T, typename U>
+void quantize(
+    const T* w,
+    U* out,
+    T* scales,
+    T* biases,
+    int bits,
+    int group_size,
+    size_t w_size) {
+  float n_bins = (1 << bits) - 1;
+  float eps = 1e-7;
+
+  bool power_of_2_bits = is_power_of_2(bits);
+  int el_per_int = get_pack_factor(bits, 32);
+  int bytes_per_pack = get_bytes_per_pack(bits);
+  int int_per_group = group_size * bytes_per_pack / el_per_int;
+  size_t n_groups = w_size / group_size;
+
+  for (size_t i = 0; i < n_groups; ++i) {
+    size_t w_idx = i * group_size;
+    float w_min = std::numeric_limits<float>::infinity();
+    float w_max = -w_min;
+    for (int j = 0; j < group_size; ++j) {
+      w_max = std::max(w_max, (float)w[w_idx + j]);
+      w_min = std::min(w_min, (float)w[w_idx + j]);
+    }
+    bool mask = std::abs(w_min) > std::abs(w_max);
+    float scale = std::max((w_max - w_min) / n_bins, eps);
+    scale = mask ? scale : -scale;
+
+    float edge = mask ? w_min : w_max;
+    float q0 = std::rint(edge / scale);
+    float bias = 0;
+    if (q0 != 0) {
+      scale = edge / q0;
+      bias = edge;
+    }
+    size_t out_idx = i * int_per_group;
+    for (int j = 0; j < int_per_group / bytes_per_pack; ++j) {
+      uint64_t out_el = 0;
+      for (int k = 0; k < el_per_int; ++k) {
+        float w_el = w[w_idx + j * el_per_int + k];
+        w_el = std::rint((w_el - bias) / scale);
+        w_el = std::min(std::max(w_el, 0.0f), n_bins);
+        out_el |= static_cast<uint64_t>(w_el) << (k * bits);
+      }
+      if (power_of_2_bits) {
+        out[out_idx + j] = out_el;
+      } else if (bits == 5) {
+        out[out_idx + bytes_per_pack * j] = out_el & 0xff;
+        out[out_idx + bytes_per_pack * j + 1] = (out_el & 0xff00) >> 8;
+        out[out_idx + bytes_per_pack * j + 2] = (out_el & 0xff0000) >> 16;
+        out[out_idx + bytes_per_pack * j + 3] = (out_el & 0xff000000) >> 24;
+        out[out_idx + bytes_per_pack * j + 4] = (out_el & 0xff00000000) >> 32;
+      } else {
+        out[out_idx + bytes_per_pack * j] = out_el & 0xff;
+        out[out_idx + bytes_per_pack * j + 1] = (out_el & 0xff00) >> 8;
+        out[out_idx + bytes_per_pack * j + 2] = (out_el & 0xff0000) >> 16;
+      }
+    }
+    scales[i] = static_cast<T>(scale);
+    biases[i] = static_cast<T>(bias);
+  }
+}
+
+template <typename T, typename U>
+void dispatch_quantize(
+    const array& w,
+    array& out,
+    array& scales,
+    array& biases,
+    int bits,
+    int group_size) {
+  auto w_ptr = w.data<T>();
+  auto out_ptr = out.data<U>();
+  auto scales_ptr = scales.data<T>();
+  auto biases_ptr = biases.data<T>();
+  quantize<T, U>(
+      w_ptr, out_ptr, scales_ptr, biases_ptr, bits, group_size, w.size());
+}
+
+void fast::Quantize::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  auto ensure_row_contiguous = [s = stream()](const array& arr) {
+    if (arr.flags().row_contiguous) {
+      return std::make_pair(arr, false);
+    } else {
+      return std::make_pair(contiguous_copy_cpu(arr, s), true);
+    }
+  };
+
+  auto [w, copied] = ensure_row_contiguous(inputs[0]);
+  auto& out = outputs[0];
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& scales = outputs[1];
+  auto& biases = outputs[2];
+  scales.set_data(allocator::malloc(scales.nbytes()));
+  biases.set_data(allocator::malloc(biases.nbytes()));
+  auto& encoder = cpu::get_command_encoder(stream());
+  if (copied) {
+    encoder.add_temporary(w);
+  }
+  encoder.set_input_array(w);
+  encoder.set_input_array(scales);
+  encoder.set_input_array(biases);
+  encoder.set_output_array(out);
+  encoder.dispatch([w = array::unsafe_weak_copy(w),
+                    out = array::unsafe_weak_copy(out),
+                    scales = array::unsafe_weak_copy(scales),
+                    biases = array::unsafe_weak_copy(biases),
+                    group_size_ = group_size_,
+                    bits_ = bits_]() mutable {
+    if (w.dtype() == float16) {
+      if (is_power_of_2(bits_)) {
+        dispatch_quantize<float16_t, uint32_t>(
+            w, out, scales, biases, bits_, group_size_);
+      } else {
+        dispatch_quantize<float16_t, uint8_t>(
+            w, out, scales, biases, bits_, group_size_);
+      }
+    } else if (w.dtype() == bfloat16) {
+      if (is_power_of_2(bits_)) {
+        dispatch_quantize<bfloat16_t, uint32_t>(
+            w, out, scales, biases, bits_, group_size_);
+      } else {
+        dispatch_quantize<bfloat16_t, uint8_t>(
+            w, out, scales, biases, bits_, group_size_);
+      }
+    } else if (w.dtype() == float32) {
+      if (is_power_of_2(bits_)) {
+        dispatch_quantize<float, uint32_t>(
+            w, out, scales, biases, bits_, group_size_);
+      } else {
+        dispatch_quantize<float, uint8_t>(
+            w, out, scales, biases, bits_, group_size_);
+      }
+    } else {
+      throw std::runtime_error(
+          "[fast::Quantize::eval_cpu] Only supports floating point inputs");
+    }
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..41764f4c8d6e2f7dd4dbc1c8235bf82d6c908101
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/reduce.cpp
@@ -0,0 +1,587 @@
+// Copyright © 2023 Apple Inc.
+
+#include <cassert>
+#include <functional>
+#include <limits>
+
+#include "mlx/backend/common/reduce.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/simd/simd.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+template <typename U>
+struct Limits {
+  static const U max;
+  static const U min;
+};
+
+#define instantiate_default_limit(type)                           \
+  template <>                                                     \
+  struct Limits<type> {                                           \
+    static constexpr type max = std::numeric_limits<type>::max(); \
+    static constexpr type min = std::numeric_limits<type>::min(); \
+  };
+
+instantiate_default_limit(uint8_t);
+instantiate_default_limit(uint16_t);
+instantiate_default_limit(uint32_t);
+instantiate_default_limit(uint64_t);
+instantiate_default_limit(int8_t);
+instantiate_default_limit(int16_t);
+instantiate_default_limit(int32_t);
+instantiate_default_limit(int64_t);
+
+#define instantiate_float_limit(type) \
+  template <>                         \
+  struct Limits<type> {               \
+    static const type max;            \
+    static const type min;            \
+  };
+
+instantiate_float_limit(float16_t);
+instantiate_float_limit(bfloat16_t);
+instantiate_float_limit(float);
+instantiate_float_limit(double);
+instantiate_float_limit(complex64_t);
+
+template <>
+struct Limits<bool> {
+  static constexpr bool max = true;
+  static constexpr bool min = false;
+};
+
+const float Limits<float>::max = std::numeric_limits<float>::infinity();
+const float Limits<float>::min = -std::numeric_limits<float>::infinity();
+const bfloat16_t Limits<bfloat16_t>::max =
+    std::numeric_limits<float>::infinity();
+const bfloat16_t Limits<bfloat16_t>::min =
+    -std::numeric_limits<float>::infinity();
+const float16_t Limits<float16_t>::max = std::numeric_limits<float>::infinity();
+const float16_t Limits<float16_t>::min =
+    -std::numeric_limits<float>::infinity();
+const double Limits<double>::max = std::numeric_limits<double>::infinity();
+const double Limits<double>::min = -std::numeric_limits<double>::infinity();
+const complex64_t Limits<complex64_t>::max =
+    std::numeric_limits<float>::infinity();
+const complex64_t Limits<complex64_t>::min =
+    -std::numeric_limits<float>::infinity();
+
+template <typename T, typename U, typename Op>
+void strided_reduce(
+    const T* x,
+    U* accumulator,
+    int size,
+    size_t stride,
+    Op op) {
+  constexpr int N = std::min(simd::max_size<T>, simd::max_size<U>);
+  for (int i = 0; i < size; i++) {
+    U* moving_accumulator = accumulator;
+    auto s = stride;
+    while (s >= N) {
+      auto acc = simd::load<U, N>(moving_accumulator);
+      auto v = simd::Simd<U, N>(simd::load<T, N>(x));
+      simd::store<U, N>(moving_accumulator, op(acc, v));
+      moving_accumulator += N;
+      x += N;
+      s -= N;
+    }
+    while (s-- > 0) {
+      *moving_accumulator = op(*moving_accumulator, *x);
+      moving_accumulator++;
+      x++;
+    }
+  }
+};
+
+template <typename T, typename U, typename Op>
+void contiguous_reduce(const T* x, U* accumulator, int size, Op op, U init) {
+  constexpr int N = std::min(simd::max_size<T>, simd::max_size<U>);
+  simd::Simd<U, N> accumulator_v(init);
+  while (size >= N) {
+    accumulator_v = op(accumulator_v, simd::Simd<U, N>(simd::load<T, N>(x)));
+    x += N;
+    size -= N;
+  }
+  *accumulator = op(*accumulator, op(accumulator_v));
+  while (size-- > 0) {
+    *accumulator = op(*accumulator, *x);
+    x++;
+  }
+}
+
+// Helper for the ndimensional strided loop
+void nd_loop(
+    std::function<void(int)> callback,
+    const Shape& shape,
+    const Strides& strides) {
+  std::function<void(int, int)> loop_inner;
+  loop_inner = [&](int dim, int offset) {
+    if (dim < shape.size() - 1) {
+      auto size = shape[dim];
+      auto stride = strides[dim];
+      for (int i = 0; i < size; i++) {
+        loop_inner(dim + 1, offset + i * stride);
+      }
+    } else {
+      auto size = shape[dim];
+      auto stride = strides[dim];
+      for (int i = 0; i < size; i++) {
+        callback(offset + i * stride);
+      }
+    }
+  };
+  loop_inner(0, 0);
+}
+
+template <typename T, typename U, typename Op>
+void reduction_op(
+    const array& x,
+    array& out,
+    const std::vector<int>& axes,
+    U init) {
+  ReductionPlan plan = get_reduction_plan(x, axes);
+
+  auto in_ptr = x.data<T>();
+  auto out_ptr = out.data<U>();
+  if (plan.type == ContiguousAllReduce) {
+    *out_ptr = init;
+    contiguous_reduce(in_ptr, out_ptr, x.size(), Op{}, init);
+    return;
+  }
+
+  if (plan.type == ContiguousReduce && plan.shape.size() == 1) {
+    int reduction_size = plan.shape[0];
+    for (int i = 0; i < out.size(); i++, out_ptr++, in_ptr += reduction_size) {
+      *out_ptr = init;
+      contiguous_reduce(in_ptr, out_ptr, reduction_size, Op{}, init);
+    }
+    return;
+  }
+
+  if (plan.type == GeneralContiguousReduce || plan.type == ContiguousReduce) {
+    int reduction_size = plan.shape.back();
+    plan.shape.pop_back();
+    plan.strides.pop_back();
+    // Unrolling the following loop (and implementing it in order for
+    // ContiguousReduce) should hold extra performance boost.
+    auto [shape, strides] = shapes_without_reduction_axes(x, axes);
+    if (plan.shape.size() == 0) {
+      for (int i = 0; i < out.size(); i++, out_ptr++) {
+        int offset = elem_to_loc(i, shape, strides);
+        *out_ptr = init;
+        contiguous_reduce(in_ptr + offset, out_ptr, reduction_size, Op{}, init);
+      }
+    } else {
+      for (int i = 0; i < out.size(); i++, out_ptr++) {
+        int offset = elem_to_loc(i, shape, strides);
+        *out_ptr = init;
+        nd_loop(
+            [&](int extra_offset) {
+              contiguous_reduce(
+                  in_ptr + offset + extra_offset,
+                  out_ptr,
+                  reduction_size,
+                  Op{},
+                  init);
+            },
+            plan.shape,
+            plan.strides);
+      }
+    }
+    return;
+  }
+
+  if (plan.type == ContiguousStridedReduce && plan.shape.size() == 1) {
+    int reduction_size = plan.shape.back();
+    size_t reduction_stride = plan.strides.back();
+    plan.shape.pop_back();
+    plan.strides.pop_back();
+    for (int i = 0; i < out.size(); i += reduction_stride) {
+      std::fill_n(out_ptr, reduction_stride, init);
+      strided_reduce(in_ptr, out_ptr, reduction_size, reduction_stride, Op{});
+      in_ptr += reduction_stride * reduction_size;
+      out_ptr += reduction_stride;
+    }
+    return;
+  }
+
+  if (plan.type == GeneralStridedReduce ||
+      plan.type == ContiguousStridedReduce) {
+    int reduction_size = plan.shape.back();
+    size_t reduction_stride = plan.strides.back();
+    plan.shape.pop_back();
+    plan.strides.pop_back();
+    auto [shape, strides] = shapes_without_reduction_axes(x, axes);
+
+    if (plan.shape.size() == 0) {
+      for (int i = 0; i < out.size(); i += reduction_stride) {
+        int offset = elem_to_loc(i, shape, strides);
+        std::fill_n(out_ptr, reduction_stride, init);
+        strided_reduce(
+            in_ptr + offset, out_ptr, reduction_size, reduction_stride, Op{});
+        out_ptr += reduction_stride;
+      }
+    } else {
+      for (int i = 0; i < out.size(); i += reduction_stride) {
+        int offset = elem_to_loc(i, shape, strides);
+        std::fill_n(out_ptr, reduction_stride, init);
+        nd_loop(
+            [&](int extra_offset) {
+              strided_reduce(
+                  in_ptr + offset + extra_offset,
+                  out_ptr,
+                  reduction_size,
+                  reduction_stride,
+                  Op{});
+            },
+            plan.shape,
+            plan.strides);
+        out_ptr += reduction_stride;
+      }
+    }
+    return;
+  }
+
+  if (plan.type == GeneralReduce) {
+    auto [shape, strides] = shapes_without_reduction_axes(x, axes);
+
+    for (int i = 0; i < out.size(); i++, out_ptr++) {
+      int offset = elem_to_loc(i, shape, strides);
+      U val = init;
+      nd_loop(
+          [&](int extra_offset) {
+            val = Op{}(val, *(in_ptr + offset + extra_offset));
+          },
+          plan.shape,
+          plan.strides);
+      *out_ptr = val;
+    }
+  }
+}
+
+struct AndReduce {
+  template <typename T>
+  bool operator()(bool x, T y) {
+    return x & (y != 0);
+  }
+
+  bool operator()(bool x, bool y) {
+    return x & y;
+  }
+
+  template <int N, typename T>
+  simd::Simd<bool, N> operator()(simd::Simd<bool, N> y, simd::Simd<T, N> x) {
+    return x & (y != 0);
+  };
+
+  template <int N>
+  simd::Simd<bool, N> operator()(simd::Simd<bool, N> y, simd::Simd<bool, N> x) {
+    return x & y;
+  };
+
+  template <int N, typename T>
+  bool operator()(simd::Simd<T, N> x) {
+    return simd::all(x);
+  };
+};
+
+struct OrReduce {
+  template <typename T>
+  bool operator()(bool x, T y) {
+    return x | (y != 0);
+  }
+
+  bool operator()(bool x, bool y) {
+    return x | y;
+  }
+
+  template <int N, typename T>
+  simd::Simd<bool, N> operator()(simd::Simd<bool, N> y, simd::Simd<T, N> x) {
+    return x | (y != 0);
+  };
+
+  template <int N>
+  simd::Simd<bool, N> operator()(simd::Simd<bool, N> y, simd::Simd<bool, N> x) {
+    return x | y;
+  };
+
+  template <int N, typename T>
+  bool operator()(simd::Simd<T, N> x) {
+    return simd::any(x);
+  };
+};
+
+struct MaxReduce {
+  template <typename T>
+  T operator()(T y, T x) {
+    return (*this)(simd::Simd<T, 1>(x), simd::Simd<T, 1>(y)).value;
+  };
+
+  template <int N, typename T>
+  simd::Simd<T, N> operator()(simd::Simd<T, N> y, simd::Simd<T, N> x) {
+    return simd::maximum(x, y);
+  };
+
+  template <int N, typename T>
+  std::enable_if_t<std::is_integral_v<T>, T> operator()(simd::Simd<T, N> x) {
+    return simd::max(x);
+  };
+
+  template <int N, typename T>
+  std::enable_if_t<!std::is_integral_v<T>, T> operator()(simd::Simd<T, N> x) {
+    if (simd::any(x != x)) {
+      return static_cast<T>(NAN);
+    }
+    return simd::max(x);
+  };
+};
+
+struct MinReduce {
+  template <typename T>
+  T operator()(T y, T x) {
+    return (*this)(simd::Simd<T, 1>(x), simd::Simd<T, 1>(y)).value;
+  };
+
+  template <int N, typename T>
+  simd::Simd<T, N> operator()(simd::Simd<T, N> y, simd::Simd<T, N> x) {
+    return simd::minimum(x, y);
+  };
+
+  template <int N, typename T>
+  std::enable_if_t<std::is_integral_v<T>, T> operator()(simd::Simd<T, N> x) {
+    return simd::min(x);
+  };
+
+  template <int N, typename T>
+  std::enable_if_t<!std::is_integral_v<T>, T> operator()(simd::Simd<T, N> x) {
+    if (simd::any(x != x)) {
+      return static_cast<T>(NAN);
+    }
+    return simd::min(x);
+  };
+};
+
+struct SumReduce {
+  template <typename T, typename U>
+  U operator()(U y, T x) {
+    return x + y;
+  };
+
+  template <int N, typename T, typename U>
+  simd::Simd<U, N> operator()(simd::Simd<U, N> y, simd::Simd<T, N> x) {
+    return y + x;
+  };
+
+  template <int N, typename T>
+  T operator()(simd::Simd<T, N> x) {
+    return simd::sum(x);
+  };
+};
+
+struct ProdReduce {
+  template <typename T, typename U>
+  U operator()(U y, T x) {
+    return x * y;
+  };
+
+  template <int N, typename T, typename U>
+  simd::Simd<U, N> operator()(simd::Simd<U, N> y, simd::Simd<T, N> x) {
+    return x * y;
+  };
+
+  template <int N, typename T>
+  T operator()(simd::Simd<T, N> x) {
+    return simd::prod(x);
+  };
+};
+
+template <typename InT>
+void reduce_dispatch_and_or(
+    const array& in,
+    array& out,
+    Reduce::ReduceType rtype,
+    const std::vector<int>& axes) {
+  if (rtype == Reduce::And) {
+    reduction_op<InT, bool, AndReduce>(in, out, axes, true);
+  } else {
+    reduction_op<InT, bool, OrReduce>(in, out, axes, false);
+  }
+}
+
+template <typename InT>
+void reduce_dispatch_sum_prod(
+    const array& in,
+    array& out,
+    Reduce::ReduceType rtype,
+    const std::vector<int>& axes) {
+  if (rtype == Reduce::Sum) {
+    if constexpr (std::is_integral_v<InT> && sizeof(InT) <= 4) {
+      reduction_op<InT, int32_t, SumReduce>(in, out, axes, 0);
+    } else {
+      reduction_op<InT, InT, SumReduce>(in, out, axes, 0);
+    }
+  } else {
+    if constexpr (std::is_integral_v<InT> && sizeof(InT) <= 4) {
+      reduction_op<InT, int32_t, ProdReduce>(in, out, axes, 1);
+    } else {
+      reduction_op<InT, InT, ProdReduce>(in, out, axes, 1);
+    }
+  }
+}
+
+template <typename InT>
+void reduce_dispatch_min_max(
+    const array& in,
+    array& out,
+    Reduce::ReduceType rtype,
+    const std::vector<int>& axes) {
+  if (rtype == Reduce::Max) {
+    auto init = Limits<InT>::min;
+    reduction_op<InT, InT, MaxReduce>(in, out, axes, init);
+  } else {
+    auto init = Limits<InT>::max;
+    reduction_op<InT, InT, MinReduce>(in, out, axes, init);
+  }
+}
+
+void Reduce::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  out.set_data(allocator::malloc(out.nbytes()));
+  auto& encoder = cpu::get_command_encoder(stream());
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  encoder.dispatch([in = array::unsafe_weak_copy(in),
+                    out = array::unsafe_weak_copy(out),
+                    reduce_type_ = reduce_type_,
+                    axes_ = axes_]() mutable {
+    switch (reduce_type_) {
+      case Reduce::And:
+      case Reduce::Or: {
+        switch (in.dtype()) {
+          case bool_:
+          case uint8:
+          case int8:
+            reduce_dispatch_and_or<int8_t>(in, out, reduce_type_, axes_);
+            break;
+          case int16:
+          case uint16:
+          case float16:
+          case bfloat16:
+            reduce_dispatch_and_or<int16_t>(in, out, reduce_type_, axes_);
+            break;
+          case uint32:
+          case int32:
+          case float32:
+            reduce_dispatch_and_or<int32_t>(in, out, reduce_type_, axes_);
+            break;
+          case uint64:
+          case int64:
+          case float64:
+          case complex64:
+            reduce_dispatch_and_or<int64_t>(in, out, reduce_type_, axes_);
+            break;
+        }
+        break;
+      }
+      case Reduce::Sum:
+      case Reduce::Prod: {
+        switch (in.dtype()) {
+          case bool_:
+          case uint8:
+            reduce_dispatch_sum_prod<uint8_t>(in, out, reduce_type_, axes_);
+            break;
+          case uint16:
+            reduce_dispatch_sum_prod<uint16_t>(in, out, reduce_type_, axes_);
+            break;
+          case uint32:
+            reduce_dispatch_sum_prod<uint32_t>(in, out, reduce_type_, axes_);
+            break;
+          case uint64:
+            reduce_dispatch_sum_prod<uint64_t>(in, out, reduce_type_, axes_);
+            break;
+          case int8:
+            reduce_dispatch_sum_prod<int8_t>(in, out, reduce_type_, axes_);
+            break;
+          case int16:
+            reduce_dispatch_sum_prod<int16_t>(in, out, reduce_type_, axes_);
+            break;
+          case int32:
+            reduce_dispatch_sum_prod<int32_t>(in, out, reduce_type_, axes_);
+            break;
+          case int64:
+            reduce_dispatch_sum_prod<int64_t>(in, out, reduce_type_, axes_);
+            break;
+          case float16:
+            reduce_dispatch_sum_prod<float16_t>(in, out, reduce_type_, axes_);
+            break;
+          case bfloat16:
+            reduce_dispatch_sum_prod<bfloat16_t>(in, out, reduce_type_, axes_);
+            break;
+          case float32:
+            reduce_dispatch_sum_prod<float>(in, out, reduce_type_, axes_);
+            break;
+          case float64:
+            reduce_dispatch_sum_prod<double>(in, out, reduce_type_, axes_);
+            break;
+          case complex64:
+            reduce_dispatch_sum_prod<complex64_t>(in, out, reduce_type_, axes_);
+            break;
+        }
+        break;
+      }
+      case Reduce::Max:
+      case Reduce::Min: {
+        switch (in.dtype()) {
+          case bool_:
+            reduce_dispatch_min_max<bool>(in, out, reduce_type_, axes_);
+            break;
+          case uint8:
+            reduce_dispatch_min_max<uint8_t>(in, out, reduce_type_, axes_);
+            break;
+          case uint16:
+            reduce_dispatch_min_max<uint16_t>(in, out, reduce_type_, axes_);
+            break;
+          case uint32:
+            reduce_dispatch_min_max<uint32_t>(in, out, reduce_type_, axes_);
+            break;
+          case uint64:
+            reduce_dispatch_min_max<uint64_t>(in, out, reduce_type_, axes_);
+            break;
+          case int8:
+            reduce_dispatch_min_max<int8_t>(in, out, reduce_type_, axes_);
+            break;
+          case int16:
+            reduce_dispatch_min_max<int16_t>(in, out, reduce_type_, axes_);
+            break;
+          case int32:
+            reduce_dispatch_min_max<int32_t>(in, out, reduce_type_, axes_);
+            break;
+          case int64:
+            reduce_dispatch_min_max<int64_t>(in, out, reduce_type_, axes_);
+            break;
+          case float16:
+            reduce_dispatch_min_max<float16_t>(in, out, reduce_type_, axes_);
+            break;
+          case float32:
+            reduce_dispatch_min_max<float>(in, out, reduce_type_, axes_);
+            break;
+          case float64:
+            reduce_dispatch_min_max<double>(in, out, reduce_type_, axes_);
+            break;
+          case bfloat16:
+            reduce_dispatch_min_max<bfloat16_t>(in, out, reduce_type_, axes_);
+            break;
+          case complex64:
+            reduce_dispatch_min_max<complex64_t>(in, out, reduce_type_, axes_);
+            break;
+        }
+        break;
+      }
+    }
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4dc2f50ead6df0cd5d33be17eefedc214ec7b373
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/scan.cpp
@@ -0,0 +1,338 @@
+// Copyright © 2023 Apple Inc.
+
+#include <cassert>
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/binary_ops.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/simd/simd.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+namespace {
+
+template <typename T, typename U, typename Op>
+void contiguous_scan(
+    const T* input,
+    U* output,
+    int count,
+    int stride,
+    bool reverse,
+    bool inclusive,
+    const Op& op,
+    U init) {
+  if (!reverse) {
+    if (inclusive) {
+      for (int i = 0; i < count; i++) {
+        *output = *input;
+        for (int j = 1; j < stride; j++) {
+          input++;
+          output++;
+          *output = op(*(output - 1), *input);
+        }
+        output++;
+        input++;
+      }
+    } else {
+      for (int i = 0; i < count; i++) {
+        *output = init;
+        for (int j = 1; j < stride; j++) {
+          *(output + 1) = op(*output, *input);
+          input++;
+          output++;
+        }
+        output++;
+        input++;
+      }
+    }
+  } else {
+    if (inclusive) {
+      for (int i = 0; i < count; i++) {
+        output += stride - 1;
+        input += stride - 1;
+        *output = *input;
+        for (int j = 1; j < stride; j++) {
+          input--;
+          output--;
+          *output = op(*(output + 1), *input);
+        }
+        output += stride;
+        input += stride;
+      }
+    } else {
+      for (int i = 0; i < count; i++) {
+        output += stride - 1;
+        input += stride - 1;
+        *output = init;
+        for (int j = 1; j < stride; j++) {
+          *(output - 1) = op(*output, *input);
+          input--;
+          output--;
+        }
+        output += stride;
+        input += stride;
+      }
+    }
+  }
+};
+
+template <typename T, typename U, typename Op>
+void strided_scan(
+    const T* input,
+    U* output,
+    int count,
+    int size,
+    int stride,
+    bool reverse,
+    bool inclusive,
+    const Op& op,
+    U init) {
+  // TODO: Vectorize the following naive implementation
+  if (!reverse) {
+    if (inclusive) {
+      for (int i = 0; i < count; i++) {
+        std::copy(input, input + stride, output);
+        output += stride;
+        input += stride;
+        for (int j = 1; j < size; j++) {
+          for (int k = 0; k < stride; k++) {
+            *output = op(*(output - stride), *input);
+            output++;
+            input++;
+          }
+        }
+      }
+    } else {
+      for (int i = 0; i < count; i++) {
+        std::fill(output, output + stride, init);
+        output += stride;
+        input += stride;
+        for (int j = 1; j < size; j++) {
+          for (int k = 0; k < stride; k++) {
+            *output = op(*(output - stride), *(input - stride));
+            output++;
+            input++;
+          }
+        }
+      }
+    }
+  } else {
+    if (inclusive) {
+      for (int i = 0; i < count; i++) {
+        output += (size - 1) * stride;
+        input += (size - 1) * stride;
+        std::copy(input, input + stride, output);
+        for (int j = 1; j < size; j++) {
+          for (int k = 0; k < stride; k++) {
+            output--;
+            input--;
+            *output = op(*(output + stride), *input);
+          }
+        }
+        output += size * stride;
+        input += size * stride;
+      }
+    } else {
+      for (int i = 0; i < count; i++) {
+        output += (size - 1) * stride;
+        input += (size - 1) * stride;
+        std::fill(output, output + stride, init);
+        for (int j = 1; j < size; j++) {
+          for (int k = 0; k < stride; k++) {
+            output--;
+            input--;
+            *output = op(*(output + stride), *(input + stride));
+          }
+        }
+        output += size * stride;
+        input += size * stride;
+      }
+    }
+  }
+};
+
+template <typename T, typename U, typename Op>
+void scan_op(
+    const array& in,
+    array& out,
+    int axis,
+    bool reverse,
+    bool inclusive,
+    const Op& op,
+    U init) {
+  if (in.flags().row_contiguous) {
+    if (in.strides()[axis] == 1) {
+      contiguous_scan(
+          in.data<T>(),
+          out.data<U>(),
+          in.size() / in.shape(axis),
+          in.shape(axis),
+          reverse,
+          inclusive,
+          op,
+          init);
+    } else {
+      strided_scan(
+          in.data<T>(),
+          out.data<U>(),
+          in.size() / in.shape(axis) / in.strides()[axis],
+          in.shape(axis),
+          in.strides()[axis],
+          reverse,
+          inclusive,
+          op,
+          init);
+    }
+  } else {
+    throw std::runtime_error("Scan op supports only contiguous inputs");
+  }
+}
+
+template <typename T, typename U>
+void scan_dispatch(
+    Scan::ReduceType rtype,
+    const array& in,
+    array& out,
+    int axis,
+    bool reverse,
+    bool inclusive) {
+  switch (rtype) {
+    case Scan::Sum: {
+      auto op = [](U y, T x) { return y + x; };
+      auto init = static_cast<U>(0);
+      scan_op<T, U>(in, out, axis, reverse, inclusive, op, init);
+      break;
+    }
+    case Scan::Prod: {
+      auto op = [](U y, T x) { return y * x; };
+      auto init = static_cast<U>(1);
+      scan_op<T, U>(in, out, axis, reverse, inclusive, op, init);
+      break;
+    }
+    case Scan::Min: {
+      auto op = [](U y, T x) { return x < y ? x : y; };
+      auto init = (issubdtype(in.dtype(), floating))
+          ? static_cast<U>(std::numeric_limits<float>::infinity())
+          : std::numeric_limits<U>::max();
+      scan_op<T, U>(in, out, axis, reverse, inclusive, op, init);
+      break;
+    }
+    case Scan::Max: {
+      auto op = [](U y, T x) { return x < y ? y : x; };
+      auto init = (issubdtype(in.dtype(), floating))
+          ? static_cast<U>(-std::numeric_limits<float>::infinity())
+          : std::numeric_limits<U>::min();
+      scan_op<T, U>(in, out, axis, reverse, inclusive, op, init);
+      break;
+    }
+    case Scan::LogAddExp: {
+      auto op = [](U a, T b) {
+        return detail::LogAddExp{}(a, static_cast<U>(b));
+      };
+      auto init = (issubdtype(in.dtype(), floating))
+          ? static_cast<U>(-std::numeric_limits<float>::infinity())
+          : std::numeric_limits<U>::min();
+      scan_op<T, U>(in, out, axis, reverse, inclusive, op, init);
+      break;
+    }
+  }
+}
+
+} // namespace
+
+void Scan::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+
+  auto& encoder = cpu::get_command_encoder(stream());
+
+  // Ensure contiguity
+  auto in = inputs[0];
+  if (!in.flags().row_contiguous) {
+    in = contiguous_copy_cpu(in, stream());
+    encoder.add_temporary(in);
+  }
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  encoder.dispatch([in = array::unsafe_weak_copy(in),
+                    out = array::unsafe_weak_copy(out),
+                    axis_ = axis_,
+                    reduce_type_ = reduce_type_,
+                    reverse_ = reverse_,
+                    inclusive_ = inclusive_]() mutable {
+    switch (in.dtype()) {
+      case bool_: {
+        // We could do a full dtype x dtype switch but this is the only case
+        // where we accumulate in a different type, for now.
+        //
+        // TODO: If we add the option to accumulate floats in higher precision
+        //       floats perhaps we should add the full all-to-all dispatch.
+        if (reduce_type_ == Scan::Sum && out.dtype() == int32) {
+          scan_dispatch<bool, int32_t>(
+              reduce_type_, in, out, axis_, reverse_, inclusive_);
+        } else {
+          scan_dispatch<bool, bool>(
+              reduce_type_, in, out, axis_, reverse_, inclusive_);
+        }
+        break;
+      }
+      case uint8:
+        scan_dispatch<uint8_t, uint8_t>(
+            reduce_type_, in, out, axis_, reverse_, inclusive_);
+        break;
+      case uint16:
+        scan_dispatch<uint16_t, uint16_t>(
+            reduce_type_, in, out, axis_, reverse_, inclusive_);
+        break;
+      case uint32:
+        scan_dispatch<uint32_t, uint32_t>(
+            reduce_type_, in, out, axis_, reverse_, inclusive_);
+        break;
+      case uint64:
+        scan_dispatch<uint64_t, uint64_t>(
+            reduce_type_, in, out, axis_, reverse_, inclusive_);
+        break;
+      case int8:
+        scan_dispatch<int8_t, int8_t>(
+            reduce_type_, in, out, axis_, reverse_, inclusive_);
+        break;
+      case int16:
+        scan_dispatch<int16_t, int16_t>(
+            reduce_type_, in, out, axis_, reverse_, inclusive_);
+        break;
+      case int32:
+        scan_dispatch<int32_t, int32_t>(
+            reduce_type_, in, out, axis_, reverse_, inclusive_);
+        break;
+      case int64:
+        scan_dispatch<int64_t, int64_t>(
+            reduce_type_, in, out, axis_, reverse_, inclusive_);
+        break;
+      case float16:
+        scan_dispatch<float16_t, float16_t>(
+            reduce_type_, in, out, axis_, reverse_, inclusive_);
+        break;
+      case float32:
+        scan_dispatch<float, float>(
+            reduce_type_, in, out, axis_, reverse_, inclusive_);
+        break;
+      case float64:
+        scan_dispatch<double, double>(
+            reduce_type_, in, out, axis_, reverse_, inclusive_);
+        break;
+      case bfloat16:
+        scan_dispatch<bfloat16_t, bfloat16_t>(
+            reduce_type_, in, out, axis_, reverse_, inclusive_);
+        break;
+      case complex64:
+        scan_dispatch<complex64_t, complex64_t>(
+            reduce_type_, in, out, axis_, reverse_, inclusive_);
+        break;
+    }
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bf6a9b82590e56e7f010c822444000678ee8542a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/select.cpp
@@ -0,0 +1,95 @@
+// Copyright © 2023 Apple Inc.
+
+#include <cassert>
+
+#include "mlx/backend/cpu/binary_ops.h"
+#include "mlx/backend/cpu/ternary.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+namespace {
+
+template <typename Op>
+void select_op(
+    const array& a,
+    const array& b,
+    const array& c,
+    array& out,
+    Op op,
+    Stream stream) {
+  TernaryOpType topt = get_ternary_op_type(a, b, c);
+  set_ternary_op_output_data(a, b, c, out, topt);
+
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_input_array(c);
+  encoder.set_output_array(out);
+  encoder.dispatch([a = array::unsafe_weak_copy(a),
+                    b = array::unsafe_weak_copy(b),
+                    c = array::unsafe_weak_copy(c),
+                    out = array::unsafe_weak_copy(out),
+                    op,
+                    topt]() mutable {
+    switch (out.dtype()) {
+      case bool_:
+        ternary_op<bool, bool, bool, bool>(a, b, c, out, op, topt);
+        break;
+      case uint8:
+        ternary_op<bool, uint8_t, uint8_t, uint8_t>(a, b, c, out, op, topt);
+        break;
+      case uint16:
+        ternary_op<bool, uint16_t, uint16_t, uint16_t>(a, b, c, out, op, topt);
+        break;
+      case uint32:
+        ternary_op<bool, uint32_t, uint32_t, uint32_t>(a, b, c, out, op, topt);
+        break;
+      case uint64:
+        ternary_op<bool, uint64_t, uint64_t, uint64_t>(a, b, c, out, op, topt);
+        break;
+      case int8:
+        ternary_op<bool, int8_t, int8_t, int8_t>(a, b, c, out, op, topt);
+        break;
+      case int16:
+        ternary_op<bool, int16_t, int16_t, int16_t>(a, b, c, out, op, topt);
+        break;
+      case int32:
+        ternary_op<bool, int32_t, int32_t, int32_t>(a, b, c, out, op, topt);
+        break;
+      case int64:
+        ternary_op<bool, int64_t, int64_t, int64_t>(a, b, c, out, op, topt);
+        break;
+      case float16:
+        ternary_op<bool, float16_t, float16_t, float16_t>(
+            a, b, c, out, op, topt);
+        break;
+      case float32:
+        ternary_op<bool, float, float, float>(a, b, c, out, op, topt);
+        break;
+      case float64:
+        ternary_op<bool, double, double, double>(a, b, c, out, op, topt);
+        break;
+      case bfloat16:
+        ternary_op<bool, bfloat16_t, bfloat16_t, bfloat16_t>(
+            a, b, c, out, op, topt);
+        break;
+      case complex64:
+        ternary_op<bool, complex64_t, complex64_t, complex64_t>(
+            a, b, c, out, op, topt);
+        break;
+    }
+  });
+}
+
+} // namespace
+
+void Select::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 3);
+  const auto& condition = inputs[0];
+  const auto& a = inputs[1];
+  const auto& b = inputs[2];
+  select_op(condition, a, b, out, detail::Select(), stream());
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/accelerate_fp16_simd.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/accelerate_fp16_simd.h
new file mode 100644
index 0000000000000000000000000000000000000000..950544895d27245a584959d5857e4234df857093
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/accelerate_fp16_simd.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "mlx/backend/cpu/simd/base_simd.h"
+
+#if MLX_SIMD_LIBRARY_VERSION < 6
+#include "mlx/backend/cpu/simd/neon_fp16_simd.h"
+#endif
+
+namespace mlx::core::simd {
+
+#if MLX_SIMD_LIBRARY_VERSION >= 6
+constexpr int N = 8;
+template <int N>
+struct ScalarT<float16_t, N> {
+  using v = _Float16;
+};
+#endif
+
+template <>
+inline constexpr int max_size<float16_t> = N;
+
+#define SIMD_FP16_DEFAULT_UNARY(op)                    \
+  template <>                                          \
+  inline Simd<float16_t, N> op(Simd<float16_t, N> v) { \
+    Simd<float, N> in = v;                             \
+    return op(in);                                     \
+  }
+
+SIMD_FP16_DEFAULT_UNARY(acos)
+SIMD_FP16_DEFAULT_UNARY(acosh)
+SIMD_FP16_DEFAULT_UNARY(asin)
+SIMD_FP16_DEFAULT_UNARY(asinh)
+SIMD_FP16_DEFAULT_UNARY(atan)
+SIMD_FP16_DEFAULT_UNARY(atanh)
+SIMD_FP16_DEFAULT_UNARY(cosh)
+SIMD_FP16_DEFAULT_UNARY(expm1)
+SIMD_FP16_DEFAULT_UNARY(log)
+SIMD_FP16_DEFAULT_UNARY(log2)
+SIMD_FP16_DEFAULT_UNARY(log10)
+SIMD_FP16_DEFAULT_UNARY(log1p)
+SIMD_FP16_DEFAULT_UNARY(sinh)
+SIMD_FP16_DEFAULT_UNARY(tan)
+SIMD_FP16_DEFAULT_UNARY(tanh)
+
+#define SIMD_FP16_DEFAULT_BINARY(op)                                         \
+  template <>                                                                \
+  inline Simd<float16_t, N> op(Simd<float16_t, N> x, Simd<float16_t, N> y) { \
+    Simd<float, N> a = x;                                                    \
+    Simd<float, N> b = y;                                                    \
+    return op(a, b);                                                         \
+  }
+SIMD_FP16_DEFAULT_BINARY(atan2)
+SIMD_FP16_DEFAULT_BINARY(remainder)
+SIMD_FP16_DEFAULT_BINARY(pow)
+
+} // namespace mlx::core::simd
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/accelerate_simd.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/accelerate_simd.h
new file mode 100644
index 0000000000000000000000000000000000000000..9148310553dd5fa669f6216c0994dcdca1cbc763
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/accelerate_simd.h
@@ -0,0 +1,313 @@
+#pragma once
+
+#include <simd/math.h>
+#include <simd/vector.h>
+
+#include <stdint.h>
+#include <cmath>
+#include <complex>
+
+#include "mlx/backend/cpu/simd/base_simd.h"
+
+// There seems to be a bug in simd/base_simd.h
+// __XROS_2_0 is not defined, the expression evaluates
+// to true instead of false setting the SIMD library
+// higher than it should be even on macOS < 15
+#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 150000 ||  \
+    __IPHONE_OS_VERSION_MIN_REQUIRED >= 180000 || \
+    __WATCH_OS_VERSION_MIN_REQUIRED >= 110000 ||  \
+    __WATCH_OS_VERSION_MIN_REQUIRED >= 110000 ||  \
+    __TV_OS_VERSION_MIN_REQUIRED >= 180000
+#define MLX_SIMD_LIBRARY_VERSION 6
+#else
+#define MLX_SIMD_LIBRARY_VERSION 5
+#endif
+
+namespace mlx::core::simd {
+
+// Apple simd namespace
+namespace asd = ::simd;
+
+// This indirection is needed to remap certain types to ones that accelerate
+// SIMD can handle
+template <typename T, int N>
+struct ScalarT {
+  using v = T;
+};
+template <int N>
+struct ScalarT<bool, N> {
+  using v = char;
+};
+template <int N>
+struct ScalarT<int8_t, N> {
+  using v = char;
+};
+template <int N>
+struct ScalarT<uint64_t, N> {
+  using v = unsigned long;
+};
+template <int N>
+struct ScalarT<int64_t, N> {
+  using v = long;
+};
+
+template <typename T, int N>
+struct Simd {
+  static constexpr int size = N;
+  using scalar_t = typename ScalarT<T, N>::v;
+
+  Simd<T, N>() {}
+
+  template <typename U>
+  Simd<T, N>(Simd<U, N> other) : value(asd::convert<scalar_t>(other.value)) {}
+
+  template <typename U>
+  Simd<T, N>(U v) : value(v){};
+
+  Simd<T, N>(Simd<T, N / 2> x, Simd<T, N / 2> y) {
+    value = asd::make<typename asd::Vector<scalar_t, N>::packed_t>(
+        x.value, y.value);
+  };
+
+  T operator[](int idx) const {
+    return reinterpret_cast<const T*>(&value)[idx];
+  }
+
+  T& operator[](int idx) {
+    return reinterpret_cast<T*>(&value)[idx];
+  }
+
+  typename asd::Vector<scalar_t, N>::packed_t value;
+};
+
+// Values chosen based on benchmarks on M3 Max
+// TODO: consider choosing these more optimally
+template <>
+inline constexpr int max_size<int8_t> = 16;
+template <>
+inline constexpr int max_size<int16_t> = 16;
+template <>
+inline constexpr int max_size<int> = 8;
+template <>
+inline constexpr int max_size<int64_t> = 4;
+template <>
+inline constexpr int max_size<uint8_t> = 16;
+template <>
+inline constexpr int max_size<uint16_t> = 16;
+template <>
+inline constexpr int max_size<uint32_t> = 8;
+template <>
+inline constexpr int max_size<uint64_t> = 4;
+template <>
+inline constexpr int max_size<float> = 8;
+template <>
+inline constexpr int max_size<double> = 4;
+
+#define SIMD_DEFAULT_UNARY(name, op) \
+  template <typename T, int N>       \
+  Simd<T, N> name(Simd<T, N> v) {    \
+    return op(v.value);              \
+  }
+
+SIMD_DEFAULT_UNARY(abs, asd::abs)
+SIMD_DEFAULT_UNARY(floor, asd::floor)
+SIMD_DEFAULT_UNARY(acos, asd::acos)
+SIMD_DEFAULT_UNARY(acosh, asd::acosh)
+SIMD_DEFAULT_UNARY(asin, asd::asin)
+SIMD_DEFAULT_UNARY(asinh, asd::asinh)
+SIMD_DEFAULT_UNARY(atan, asd::atan)
+SIMD_DEFAULT_UNARY(atanh, asd::atanh)
+SIMD_DEFAULT_UNARY(ceil, asd::ceil)
+SIMD_DEFAULT_UNARY(cosh, asd::cosh)
+SIMD_DEFAULT_UNARY(expm1, asd::expm1)
+SIMD_DEFAULT_UNARY(log, asd::log)
+SIMD_DEFAULT_UNARY(log2, asd::log2)
+SIMD_DEFAULT_UNARY(log10, asd::log10)
+SIMD_DEFAULT_UNARY(log1p, asd::log1p)
+SIMD_DEFAULT_UNARY(rint, asd::rint)
+SIMD_DEFAULT_UNARY(sinh, asd::sinh)
+SIMD_DEFAULT_UNARY(sqrt, asd::sqrt)
+SIMD_DEFAULT_UNARY(rsqrt, asd::rsqrt)
+SIMD_DEFAULT_UNARY(recip, asd::recip)
+SIMD_DEFAULT_UNARY(tan, asd::tan)
+SIMD_DEFAULT_UNARY(tanh, asd::tanh)
+
+template <typename T, int N>
+Simd<T, N> operator-(Simd<T, N> v) {
+  return -v.value;
+}
+
+template <typename T, int N>
+Simd<T, N> operator~(Simd<T, N> v) {
+  return ~v.value;
+}
+
+template <typename T, int N>
+Simd<bool, N> isnan(Simd<T, N> v) {
+  return asd::convert<char>(v.value != v.value);
+}
+
+// No simd_boolN in accelerate, use int8_t instead
+template <typename T, int N>
+Simd<bool, N> operator!(Simd<T, N> v) {
+  return asd::convert<char>(!v.value);
+}
+
+#define SIMD_DEFAULT_BINARY(OP)                                              \
+  template <typename T, typename U, int N>                                   \
+  Simd<T, N> operator OP(Simd<T, N> x, U y) {                                \
+    return asd::convert<typename Simd<T, N>::scalar_t>(x.value OP y);        \
+  }                                                                          \
+  template <typename T1, typename T2, int N>                                 \
+  Simd<T2, N> operator OP(T1 x, Simd<T2, N> y) {                             \
+    return asd::convert<typename Simd<T2, N>::scalar_t>(x OP y.value);       \
+  }                                                                          \
+  template <typename T1, typename T2, int N>                                 \
+  Simd<T1, N> operator OP(Simd<T1, N> x, Simd<T2, N> y) {                    \
+    return asd::convert<typename Simd<T1, N>::scalar_t>(x.value OP y.value); \
+  }
+
+SIMD_DEFAULT_BINARY(+)
+SIMD_DEFAULT_BINARY(-)
+SIMD_DEFAULT_BINARY(/)
+SIMD_DEFAULT_BINARY(*)
+SIMD_DEFAULT_BINARY(<<)
+SIMD_DEFAULT_BINARY(>>)
+SIMD_DEFAULT_BINARY(|)
+SIMD_DEFAULT_BINARY(^)
+SIMD_DEFAULT_BINARY(&)
+SIMD_DEFAULT_BINARY(&&)
+SIMD_DEFAULT_BINARY(||)
+
+#define SIMD_DEFAULT_COMPARISONS(OP)                        \
+  template <int N, typename T, typename U>                  \
+  Simd<bool, N> operator OP(Simd<T, N> a, U b) {            \
+    return asd::convert<char>(a.value OP b);                \
+  }                                                         \
+  template <int N, typename T, typename U>                  \
+  Simd<bool, N> operator OP(T a, Simd<U, N> b) {            \
+    return asd::convert<char>(a OP b.value);                \
+  }                                                         \
+  template <int N, typename T1, typename T2>                \
+  Simd<bool, N> operator OP(Simd<T1, N> a, Simd<T2, N> b) { \
+    return asd::convert<char>(a.value OP b.value);          \
+  }
+
+SIMD_DEFAULT_COMPARISONS(>)
+SIMD_DEFAULT_COMPARISONS(<)
+SIMD_DEFAULT_COMPARISONS(>=)
+SIMD_DEFAULT_COMPARISONS(<=)
+SIMD_DEFAULT_COMPARISONS(==)
+SIMD_DEFAULT_COMPARISONS(!=)
+
+template <typename T, int N>
+Simd<T, N> atan2(Simd<T, N> a, Simd<T, N> b) {
+  return asd::atan2(a.value, b.value);
+}
+
+template <typename T, int N>
+Simd<T, N> maximum(Simd<T, N> a, Simd<T, N> b) {
+  // TODO add isnan
+  return asd::max(a.value, b.value);
+}
+
+template <typename T, int N>
+Simd<T, N> minimum(Simd<T, N> a, Simd<T, N> b) {
+  // TODO add isnan
+  return asd::min(a.value, b.value);
+}
+
+template <typename T, int N>
+Simd<T, N> remainder(Simd<T, N> a, Simd<T, N> b) {
+  Simd<T, N> r;
+  if constexpr (!std::is_integral_v<T>) {
+    r = asd::remainder(a.value, b.value);
+  } else {
+    r = a - b * (a / b);
+  }
+  if constexpr (std::is_signed_v<T>) {
+    auto mask = r != 0 && (r < 0 != b < 0);
+    r = select(mask, r + b, r);
+  }
+  return r;
+}
+
+template <typename MaskT, typename T1, typename T2, int N>
+Simd<T1, N> select(Simd<MaskT, N> mask, Simd<T1, N> x, Simd<T2, N> y) {
+  static_assert(std::is_same_v<MaskT, bool>);
+  if constexpr (sizeof(T1) == 1) {
+    return asd::bitselect(y.value, x.value, asd::convert<char>(mask.value));
+  } else if constexpr (sizeof(T1) == 2) {
+    return asd::bitselect(y.value, x.value, asd::convert<short>(mask.value));
+  } else if constexpr (sizeof(T1) == 4) {
+    return asd::bitselect(y.value, x.value, asd::convert<int>(mask.value));
+  } else {
+    return asd::bitselect(y.value, x.value, asd::convert<long>(mask.value));
+  }
+}
+
+template <typename T, int N>
+Simd<T, N> pow(Simd<T, N> base, Simd<T, N> exp) {
+  if constexpr (!std::is_integral_v<T>) {
+    return asd::pow(base.value, exp.value);
+  } else {
+    Simd<T, N> res = 1;
+    // Raising an integer to a negative power is undefined
+    if (any(exp < 0)) {
+      return 0;
+    }
+    while (any(exp > 0)) {
+      res = select((exp & 1) != 0, res * base, res);
+      base = select(exp > 0, base * base, base);
+      exp = exp >> 1;
+    }
+    return res;
+  }
+}
+
+template <typename T, int N>
+Simd<T, N> clamp(Simd<T, N> v, Simd<T, N> min, Simd<T, N> max) {
+  return asd::clamp(v.value, min.value, max.value);
+}
+
+template <typename T, typename U, int N>
+Simd<T, N> fma(Simd<T, N> x, Simd<T, N> y, U z) {
+  return asd::muladd(x.value, y.value, Simd<T, N>(z).value);
+}
+
+// Reductions
+
+template <typename T, int N>
+bool all(Simd<T, N> x) {
+  return asd::all(x.value);
+}
+template <typename T, int N>
+bool any(Simd<T, N> x) {
+  return asd::any(x.value);
+}
+template <typename T, int N>
+T sum(Simd<T, N> x) {
+  return asd::reduce_add(x.value);
+}
+template <typename T, int N>
+T max(Simd<T, N> x) {
+  return asd::reduce_max(x.value);
+}
+template <typename T, int N>
+T min(Simd<T, N> x) {
+  return asd::reduce_min(x.value);
+}
+
+template <typename T, int N>
+T prod(Simd<T, N> x) {
+  auto ptr = (T*)&x;
+  auto lhs = load<T, N / 2>(ptr);
+  auto rhs = load<T, N / 2>(ptr + N / 2);
+  return prod(lhs * rhs);
+}
+
+} // namespace mlx::core::simd
+
+#if __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
+#include "mlx/backend/cpu/simd/accelerate_fp16_simd.h"
+#endif
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
new file mode 100644
index 0000000000000000000000000000000000000000..17cd35b9ad6d13889f375d2a1bbe57d10fd92678
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/base_simd.h
@@ -0,0 +1,290 @@
+#pragma once
+
+#include <stdint.h>
+#include <algorithm>
+#include <cmath>
+#include <complex>
+#include <functional>
+
+namespace mlx::core::simd {
+template <typename T, int N>
+struct Simd;
+
+template <typename T>
+static constexpr int max_size = 1;
+
+template <typename T>
+struct Simd<T, 1> {
+  static constexpr int size = 1;
+  T value;
+  Simd() {}
+  template <typename U>
+  Simd(Simd<U, 1> v) : value(v.value) {}
+  template <typename U>
+  Simd(U v) : value(v) {}
+};
+
+template <typename T, int N>
+Simd<T, N> load(const T* x) {
+  return *(Simd<T, N>*)x;
+}
+
+template <typename T, int N>
+void store(T* dst, Simd<T, N> x) {
+  // Maintain invariant that bool is either 0 or 1 as
+  // simd comparison ops set all bits in the result to 1
+  if constexpr (std::is_same_v<T, bool> && N > 1) {
+    x = x & 1;
+  }
+  *(Simd<T, N>*)dst = x;
+}
+
+template <typename, typename = void>
+constexpr bool is_complex = false;
+
+template <typename T>
+constexpr bool is_complex<T, std::void_t<decltype(std::declval<T>().real())>> =
+    true;
+
+template <typename T>
+Simd<T, 1> rint(Simd<T, 1> in) {
+  if constexpr (is_complex<T>) {
+    return Simd<T, 1>{
+        T{std::rint(in.value.real()), std::rint(in.value.imag())}};
+  } else {
+    return Simd<T, 1>{std::rint(in.value)};
+  }
+}
+
+template <typename T>
+Simd<T, 1> rsqrt(Simd<T, 1> in) {
+  return T(1.0) / sqrt(in);
+}
+
+template <typename T>
+Simd<T, 1> recip(Simd<T, 1> in) {
+  return T(1.0) / in;
+}
+
+#define DEFAULT_UNARY(name, op)    \
+  template <typename T>            \
+  Simd<T, 1> name(Simd<T, 1> in) { \
+    return op(in.value);           \
+  }
+
+DEFAULT_UNARY(operator-, std::negate{})
+DEFAULT_UNARY(operator!, std::logical_not{})
+DEFAULT_UNARY(abs, std::abs)
+DEFAULT_UNARY(acos, std::acos)
+DEFAULT_UNARY(acosh, std::acosh)
+DEFAULT_UNARY(asin, std::asin)
+DEFAULT_UNARY(asinh, std::asinh)
+DEFAULT_UNARY(atan, std::atan)
+DEFAULT_UNARY(atanh, std::atanh)
+DEFAULT_UNARY(ceil, std::ceil)
+DEFAULT_UNARY(conj, std::conj)
+DEFAULT_UNARY(cosh, std::cosh)
+DEFAULT_UNARY(expm1, std::expm1)
+DEFAULT_UNARY(floor, std::floor)
+DEFAULT_UNARY(log, std::log)
+DEFAULT_UNARY(log10, std::log10)
+DEFAULT_UNARY(sinh, std::sinh)
+DEFAULT_UNARY(sqrt, std::sqrt)
+DEFAULT_UNARY(tan, std::tan)
+DEFAULT_UNARY(tanh, std::tanh)
+
+template <typename T>
+Simd<T, 1> log1p(Simd<T, 1> in) {
+  if constexpr (is_complex<T>) {
+    auto x = in.value.real();
+    auto y = in.value.imag();
+    auto zabs = std::abs(in.value);
+    auto theta = std::atan2(y, x + 1);
+    if (zabs < 0.5) {
+      auto r = x * (2 + x) + y * y;
+      if (r == 0) { // handle underflow
+        return Simd<T, 1>{T{x, theta}};
+      }
+      return Simd<T, 1>{T{((typeof(x))(0.5)) * std::log1p(r), theta}};
+    } else {
+      auto z0 = std::hypot(x + 1, y);
+      return Simd<T, 1>{T{std::log(z0), theta}};
+    }
+  } else {
+    return Simd<T, 1>{std::log1p(in.value)};
+  }
+}
+
+template <typename T>
+Simd<T, 1> log2(Simd<T, 1> in) {
+  if constexpr (is_complex<T>) {
+    auto out = std::log(in.value);
+    auto scale = decltype(out.real())(M_LN2);
+    return Simd<T, 1>{T{out.real() / scale, out.imag() / scale}};
+  } else {
+    return Simd<T, 1>{std::log2(in.value)};
+  }
+}
+
+template <typename T>
+Simd<T, 1> operator~(Simd<T, 1> in) {
+  return ~in.value;
+}
+
+template <typename T>
+auto real(Simd<T, 1> in) -> Simd<decltype(std::real(in.value)), 1> {
+  return std::real(in.value);
+}
+template <typename T>
+auto imag(Simd<T, 1> in) -> Simd<decltype(std::imag(in.value)), 1> {
+  return std::imag(in.value);
+}
+template <typename T>
+Simd<bool, 1> isnan(Simd<T, 1> in) {
+  return std::isnan(in.value);
+}
+
+#define DEFAULT_BINARY(OP)                                                 \
+  template <typename T1, typename T2>                                      \
+  auto operator OP(Simd<T1, 1> a, Simd<T2, 1> b)                           \
+      ->Simd<decltype(a.value OP b.value), 1> {                            \
+    return a.value OP b.value;                                             \
+  }                                                                        \
+  template <typename T1, typename T2>                                      \
+  auto operator OP(T1 a, Simd<T2, 1> b)->Simd<decltype(a OP b.value), 1> { \
+    return a OP b.value;                                                   \
+  }                                                                        \
+  template <typename T1, typename T2>                                      \
+  auto operator OP(Simd<T1, 1> a, T2 b)->Simd<decltype(a.value OP b), 1> { \
+    return a.value OP b;                                                   \
+  }
+
+DEFAULT_BINARY(+)
+DEFAULT_BINARY(-)
+DEFAULT_BINARY(*)
+DEFAULT_BINARY(/)
+DEFAULT_BINARY(<<)
+DEFAULT_BINARY(>>)
+DEFAULT_BINARY(|)
+DEFAULT_BINARY(^)
+DEFAULT_BINARY(&)
+DEFAULT_BINARY(&&)
+DEFAULT_BINARY(||)
+
+template <typename T>
+Simd<T, 1> remainder(Simd<T, 1> a_, Simd<T, 1> b_) {
+  T a = a_.value;
+  T b = b_.value;
+  T r;
+  if constexpr (std::is_integral_v<T>) {
+    r = a % b;
+  } else {
+    r = std::remainder(a, b);
+  }
+  if constexpr (std::is_signed_v<T>) {
+    if (r != 0 && (r < 0 != b < 0)) {
+      r += b;
+    }
+  }
+  return r;
+}
+
+template <typename T>
+Simd<T, 1> maximum(Simd<T, 1> a_, Simd<T, 1> b_) {
+  T a = a_.value;
+  T b = b_.value;
+  if constexpr (!std::is_integral_v<T>) {
+    if (std::isnan(a)) {
+      return a;
+    }
+  }
+  return (a > b) ? a : b;
+}
+
+template <typename T>
+Simd<T, 1> minimum(Simd<T, 1> a_, Simd<T, 1> b_) {
+  T a = a_.value;
+  T b = b_.value;
+  if constexpr (!std::is_integral_v<T>) {
+    if (std::isnan(a)) {
+      return a;
+    }
+  }
+  return (a < b) ? a : b;
+}
+
+template <typename T>
+Simd<T, 1> pow(Simd<T, 1> a, Simd<T, 1> b) {
+  T base = a.value;
+  T exp = b.value;
+  if constexpr (!std::is_integral_v<T>) {
+    return std::pow(base, exp);
+  } else {
+    T res = 1;
+    while (exp) {
+      if (exp & 1) {
+        res *= base;
+      }
+      exp >>= 1;
+      base *= base;
+    }
+    return res;
+  }
+}
+
+template <typename T>
+Simd<T, 1> atan2(Simd<T, 1> a, Simd<T, 1> b) {
+  return std::atan2(a.value, b.value);
+}
+
+#define DEFAULT_COMPARISONS(OP)                             \
+  template <typename T1, typename T2>                       \
+  Simd<bool, 1> operator OP(Simd<T1, 1> a, Simd<T2, 1> b) { \
+    return a.value OP b.value;                              \
+  }                                                         \
+  template <typename T1, typename T2>                       \
+  Simd<bool, 1> operator OP(T1 a, Simd<T2, 1> b) {          \
+    return a OP b.value;                                    \
+  }                                                         \
+  template <typename T1, typename T2>                       \
+  Simd<bool, 1> operator OP(Simd<T1, 1> a, T2 b) {          \
+    return a.value OP b;                                    \
+  }
+
+DEFAULT_COMPARISONS(>)
+DEFAULT_COMPARISONS(<)
+DEFAULT_COMPARISONS(>=)
+DEFAULT_COMPARISONS(<=)
+DEFAULT_COMPARISONS(==)
+DEFAULT_COMPARISONS(!=)
+
+template <typename MaskT, typename T>
+Simd<T, 1> select(Simd<MaskT, 1> mask, Simd<T, 1> x, Simd<T, 1> y) {
+  return mask.value ? x.value : y.value;
+}
+
+template <typename T>
+Simd<T, 1> clamp(Simd<T, 1> v, Simd<T, 1> min, Simd<T, 1> max) {
+  return std::clamp(v.value, min.value, max.value);
+}
+
+template <typename T, typename U>
+Simd<T, 1> fma(Simd<T, 1> x, Simd<T, 1> y, U z) {
+  return std::fma(x.value, y.value, Simd<T, 1>(z).value);
+}
+
+// Reductions
+#define DEFAULT_REDUCTION(name, type) \
+  template <typename T>               \
+  type name(Simd<T, 1> x) {           \
+    return x.value;                   \
+  }
+
+DEFAULT_REDUCTION(max, T)
+DEFAULT_REDUCTION(min, T)
+DEFAULT_REDUCTION(sum, T)
+DEFAULT_REDUCTION(prod, T)
+DEFAULT_REDUCTION(any, bool)
+DEFAULT_REDUCTION(all, bool)
+
+} // namespace mlx::core::simd
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
new file mode 100644
index 0000000000000000000000000000000000000000..f9fc8317a58d8f8ca9d76aec986de9bdf183a941
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/math.h
@@ -0,0 +1,193 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cpu/simd/type.h"
+
+namespace mlx::core::simd {
+
+constexpr float inf = std::numeric_limits<float>::infinity();
+
+/**
+ * Compute exp(x) in an optimizer friendly way as follows:
+ *
+ * First change the problem to computing 2**y where y = x / ln(2).
+ *
+ * Now we will compute 2**y as 2**y1 * 2**y2 where y1 is the integer part
+ * `ipart` and y2 is fractional part. For the integer part we perform bit
+ * shifting and for the fractional part we use a polynomial approximation.
+ *
+ * The algorithm and constants of the polynomial taken from
+ * https://github.com/akohlmey/fastermath/blob/master/src/exp.c which took them
+ * from Cephes math library.
+ *
+ * Note: The implementation below is a general fast exp. There could be faster
+ *       implementations for numbers strictly < 0.
+ */
+template <typename T, int N>
+Simd<T, N> exp(Simd<T, N> in) {
+  if constexpr (is_complex<T>) {
+    return Simd<T, 1>{std::exp(in.value)};
+  } else {
+    Simd<float, N> x_init = in;
+    auto x = x_init * 1.442695f; // multiply with log_2(e)
+    Simd<float, N> ipart, fpart;
+    ipart = floor(x + 0.5);
+    fpart = x - ipart;
+
+    x = 1.535336188319500e-4f;
+    x = fma(x, fpart, 1.339887440266574e-3f);
+    x = fma(x, fpart, 9.618437357674640e-3f);
+    x = fma(x, fpart, 5.550332471162809e-2f);
+    x = fma(x, fpart, 2.402264791363012e-1f);
+    x = fma(x, fpart, 6.931472028550421e-1f);
+    x = fma(x, fpart, 1.000000000000000f);
+
+    // generate 2**ipart in the floating point representation using integer
+    // bitshifting
+    Simd<int, N> epart = (Simd<int, N>(ipart) + 127) << 23;
+
+    // Deal with NaN and Inf
+    auto result = select(isnan(x_init), x_init, (*(Simd<float, N>*)&epart) * x);
+    result = select(x_init > 88.0f, Simd<float, N>(inf), result);
+    result = select(x_init < -88.0f, Simd<float, N>(0), result);
+    return Simd<T, N>(result);
+  }
+}
+
+/* Implementation from:
+ * https://github.com/JishinMaster/simd_utils/blob/3c1433a86fb38edcc9b02039f3c9a65b16640976/neon_mathfun.h#L357
+ * which originally came from the Cephes math library.
+ */
+template <bool Sine, typename T, int N>
+Simd<T, N> sincos(Simd<T, N> in) {
+  auto sign_mask_sin = in < 0;
+  in = abs(in);
+  Simd<float, N> x = in;
+
+  // scale by 4/Pi
+  auto y = x * 1.27323954473516f;
+
+  // store the integer part of y in mm0
+  Simd<uint32_t, N> emm2 = y;
+
+  // j=(j+1) & (~1) (see the cephes sources)
+  emm2 = emm2 + 1;
+  emm2 = emm2 & ~1;
+
+  y = emm2;
+
+  // Get the polynom selection mask. There is one polynom for 0 <= x <= Pi/4
+  // and another one for Pi/4<x<=Pi/2. Both branches will be computed.
+  auto poly_mask = (emm2 & 2) != 0;
+
+  // The magic pass: "Extended precision modular arithmetic"
+  // x = ((x - y * DP1) - y * DP2) - y * DP3
+  x = fma(y, Simd<float, N>(-0.78515625f), x);
+  x = fma(y, Simd<float, N>(-2.4187564849853515625e-4f), x);
+  x = fma(y, Simd<float, N>(-3.77489497744594108e-8f), x);
+
+  sign_mask_sin = sign_mask_sin ^ ((emm2 & 4) != 0);
+  auto sign_mask_cos = ((emm2 - 2) & 4) != 0;
+
+  // Evaluate the first polynom  (0 <= x <= Pi/4) in y1,
+  // and the second polynom      (Pi/4 <= x <= 0) in y2
+  auto z = x * x;
+
+  auto y1 =
+      fma(z, Simd<float, N>(2.443315711809948e-5f), -1.388731625493765e-3f);
+  auto y2 = fma(z, Simd<float, N>(-1.9515295891e-4f), 8.3321608736e-3f);
+  y1 = fma(y1, z, 4.166664568298827e-2f);
+  y2 = fma(y2, z, -1.6666654611e-1f);
+  y1 = y1 * z;
+  y2 = y2 * z;
+  y1 = y1 * z;
+  y2 = fma(x, y2, x);
+  y1 = fma(z, Simd<float, N>(-0.5f), y1);
+  y1 = y1 + 1.0f;
+
+  if constexpr (Sine) {
+    auto ys = select(poly_mask, y1, y2);
+    return select(sign_mask_sin, -ys, ys);
+  } else {
+    auto yc = select(poly_mask, y2, y1);
+    return select(sign_mask_cos, yc, -yc);
+  }
+}
+
+template <typename T, int N>
+Simd<T, N> sin(Simd<T, N> x) {
+  if constexpr (is_complex<T>) {
+    return std::sin(x.value);
+  } else {
+    return sincos<true>(x);
+  }
+}
+
+template <typename T, int N>
+Simd<T, N> cos(Simd<T, N> x) {
+  if constexpr (is_complex<T>) {
+    return std::cos(x.value);
+  } else {
+    return sincos<false>(x);
+  }
+}
+
+template <typename T, int N>
+Simd<T, N> erf(Simd<T, N> x) {
+  // https://github.com/pytorch/pytorch/blob/abf28982a8cb43342e7669d859de9543fd804cc9/aten/src/ATen/cpu/vec/vec256/vec256_float.h#L175
+  Simd<float, N> v = x;
+  auto t = recip(fma(Simd<float, N>(0.3275911f), abs(v), 1.0f));
+  auto r = fma(Simd<float, N>(1.061405429f), t, -1.453152027f);
+  r = fma(r, t, 1.421413741f);
+  r = fma(r, t, -0.284496736f);
+  r = fma(r, t, 0.254829592f);
+  auto e = -exp(-v * v);
+  auto result = Simd<T, N>(fma(e * t, r, 1.0f));
+  return select(x > 0, result, -result);
+}
+
+template <typename T, int N>
+Simd<T, N> erfinv(Simd<T, N> a_) {
+  Simd<float, N> a = a_;
+  auto t = fma(a, 0.0f - a, 1.0f);
+  t = log(t);
+  auto lhs = [](auto t) {
+    Simd<float, N> p;
+    p = 3.03697567e-10f; //  0x1.4deb44p-32
+    p = fma(p, t, 2.93243101e-8f); //  0x1.f7c9aep-26
+    p = fma(p, t, 1.22150334e-6f); //  0x1.47e512p-20
+    p = fma(p, t, 2.84108955e-5f); //  0x1.dca7dep-16
+    p = fma(p, t, 3.93552968e-4f); //  0x1.9cab92p-12
+    p = fma(p, t, 3.02698812e-3f); //  0x1.8cc0dep-9
+    p = fma(p, t, 4.83185798e-3f); //  0x1.3ca920p-8
+    p = fma(p, t, -2.64646143e-1f); // -0x1.0eff66p-2
+    return fma(p, t, 8.40016484e-1f); //  0x1.ae16a4p-1
+  };
+  auto rhs = [](auto t) {
+    Simd<float, N> p;
+    p = 5.43877832e-9f; //  0x1.75c000p-28
+    p = fma(p, t, 1.43285448e-7f); //  0x1.33b402p-23
+    p = fma(p, t, 1.22774793e-6f); //  0x1.499232p-20
+    p = fma(p, t, 1.12963626e-7f); //  0x1.e52cd2p-24
+    p = fma(p, t, -5.61530760e-5f); // -0x1.d70bd0p-15
+    p = fma(p, t, -1.47697632e-4f); // -0x1.35be90p-13
+    p = fma(p, t, 2.31468678e-3f); //  0x1.2f6400p-9
+    p = fma(p, t, 1.15392581e-2f); //  0x1.7a1e50p-7
+    p = fma(p, t, -2.32015476e-1f); // -0x1.db2aeep-3
+    return fma(p, t, 8.86226892e-1f); //  0x1.c5bf88p-1
+  };
+  auto thresh = 6.125f;
+  // Compute both branches and select if N > 1
+  if constexpr (N == 1) {
+    if ((abs(t) > thresh).value) { // maximum ulp error = 2.35793
+      return a * lhs(t);
+    } else { // maximum ulp error = 2.35002
+      return a * rhs(t);
+    }
+  } else {
+    return a * select(abs(t) > thresh, lhs(t), rhs(t));
+  }
+}
+
+} // namespace mlx::core::simd
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/neon_fp16_simd.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/neon_fp16_simd.h
new file mode 100644
index 0000000000000000000000000000000000000000..5d32042cc9646d797001707a9486cb3a5025dd63
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/neon_fp16_simd.h
@@ -0,0 +1,212 @@
+#pragma once
+
+#include <arm_neon.h>
+
+#include "mlx/backend/cpu/simd/base_simd.h"
+
+namespace mlx::core::simd {
+
+constexpr int N = 8;
+
+template <>
+struct Simd<float16_t, N> {
+  static constexpr int size = N;
+  using scalar_t = float16_t;
+
+  Simd<float16_t, N>() {}
+
+  template <typename U>
+  Simd<float16_t, N>(U v) : value(vdupq_n_f16(v)){};
+
+  Simd<float16_t, N>(float16x8_t v) : value(v){};
+
+  Simd<float16_t, N>(Simd<float, N> other) {
+    auto f32x4_a = *(float32x4_t*)(&other);
+    auto f32x4_b = *((float32x4_t*)(&other) + 1);
+    value = vcvt_high_f16_f32(vcvt_f16_f32(f32x4_a), f32x4_b);
+  };
+
+  Simd<float16_t, N>(Simd<uint16_t, N> other) {
+    value = vcvtq_f16_u16(*(uint16x8_t*)(&other.value));
+  };
+
+  operator Simd<int16_t, N>() {
+    auto v = vcvtq_s16_f16(value);
+    return load<int16_t, N>((int16_t*)&v);
+  };
+
+  operator Simd<float, N>() {
+    float32x4x2_t v;
+    v.val[0] = vcvt_f32_f16(*(float16x4_t*)(&value));
+    v.val[1] = vcvt_high_f32_f16(value);
+    return load<float, N>((float*)&v);
+  }
+  float16_t operator[](int idx) const {
+    return reinterpret_cast<const float16_t*>(&value)[idx];
+  }
+
+  float16_t& operator[](int idx) {
+    return reinterpret_cast<float16_t*>(&value)[idx];
+  }
+
+  float16x8_t value;
+};
+
+#define DEFINE_NEON_UNARY_OP(name, op)                   \
+  inline Simd<float16_t, N> name(Simd<float16_t, N> a) { \
+    return Simd<float16_t, N>{op(a.value)};              \
+  }
+
+DEFINE_NEON_UNARY_OP(abs, vabsq_f16)
+DEFINE_NEON_UNARY_OP(ceil, vrndpq_f16)
+DEFINE_NEON_UNARY_OP(floor, vrndmq_f16)
+DEFINE_NEON_UNARY_OP(sqrt, vsqrtq_f16)
+DEFINE_NEON_UNARY_OP(rsqrt, vrsqrteq_f16)
+DEFINE_NEON_UNARY_OP(recip, vrecpeq_f16)
+DEFINE_NEON_UNARY_OP(rint, vrndnq_f16)
+
+#define DEFINE_NEON_BINARY_OP(name, op)                                        \
+  inline Simd<float16_t, N> name(Simd<float16_t, N> a, Simd<float16_t, N> b) { \
+    return op(a.value, b.value);                                               \
+  }                                                                            \
+  template <typename T>                                                        \
+  Simd<float16_t, N> name(Simd<float16_t, N> a, T b) {                         \
+    return op(a.value, Simd<float16_t, N>(b).value);                           \
+  }                                                                            \
+  template <typename T>                                                        \
+  Simd<float16_t, N> name(T a, Simd<float16_t, N> b) {                         \
+    return op(Simd<float16_t, N>(a).value, b.value);                           \
+  }
+
+inline Simd<float16_t, N> operator!(Simd<float16_t, N> v) {
+  auto out = vceqzq_f16(v.value);
+  return Simd<uint16_t, N>(*(uint16_t*)&out);
+}
+
+inline Simd<float16_t, N> operator-(Simd<float16_t, N> v) {
+  return vnegq_f16(v.value);
+}
+
+DEFINE_NEON_BINARY_OP(maximum, vmaxq_f16)
+DEFINE_NEON_BINARY_OP(minimum, vminq_f16)
+DEFINE_NEON_BINARY_OP(operator+, vaddq_f16)
+DEFINE_NEON_BINARY_OP(operator-, vsubq_f16)
+DEFINE_NEON_BINARY_OP(operator*, vmulq_f16)
+DEFINE_NEON_BINARY_OP(operator/, vdivq_f16)
+
+#define DEFINE_NEON_COMPARISON(Op, op)                   \
+  template <typename T>                                  \
+  Simd<bool, N> operator Op(Simd<float16_t, N> a, T b) { \
+    auto out = op(a.value, Simd<float16_t, N>(b).value); \
+    return Simd<uint16_t, N>(*(uint16_t*)(&out));        \
+  }                                                      \
+  template <typename T>                                  \
+  Simd<bool, N> operator Op(T a, Simd<float16_t, N> b) { \
+    auto out = op(Simd<float16_t, N>(a).value, b.value); \
+    return Simd<uint16_t, N>(*(uint16_t*)(&out));        \
+  }                                                      \
+  inline Simd<bool, N> operator Op(                      \
+      Simd<float16_t, N> a, Simd<float16_t, N> b) {      \
+    auto out = op(a.value, b.value);                     \
+    return Simd<uint16_t, N>(*(uint16_t*)(&out));        \
+  }
+
+DEFINE_NEON_COMPARISON(==, vceqq_f16)
+DEFINE_NEON_COMPARISON(>=, vcgeq_f16)
+DEFINE_NEON_COMPARISON(<=, vcleq_f16)
+DEFINE_NEON_COMPARISON(>, vcgtq_f16)
+DEFINE_NEON_COMPARISON(<, vcltq_f16)
+
+template <typename T>
+Simd<bool, N> operator!=(Simd<float16_t, N> a, T b) {
+  return !(a == b);
+}
+template <typename T>
+Simd<bool, N> operator!=(T a, Simd<float16_t, N> b) {
+  return !(a == b);
+}
+inline Simd<bool, N> operator!=(Simd<float16_t, N> a, Simd<float16_t, N> b) {
+  return !(a == b);
+}
+
+inline Simd<float16_t, N> operator||(
+    Simd<float16_t, N> a,
+    Simd<float16_t, N> b) {
+  return Simd<uint16_t, N>((a != 0) || (b != 0));
+}
+template <typename T>
+Simd<float16_t, N> operator||(Simd<float16_t, N> a, T b) {
+  return Simd<uint16_t, N>((a != 0) || (b != 0));
+}
+template <typename T>
+Simd<float16_t, N> operator||(T a, Simd<float16_t, N> b) {
+  return Simd<uint16_t, N>((a != 0) || (b != 0));
+}
+inline Simd<float16_t, N> operator&&(
+    Simd<float16_t, N> a,
+    Simd<float16_t, N> b) {
+  return Simd<uint16_t, N>((a != 0) && (b != 0));
+}
+template <typename T>
+Simd<float16_t, N> operator&&(Simd<float16_t, N> a, T b) {
+  return Simd<uint16_t, N>((a != 0) && (b != 0));
+}
+template <typename T>
+Simd<float16_t, N> operator&&(T a, Simd<float16_t, N> b) {
+  return Simd<uint16_t, N>((a != 0) && (b != 0));
+}
+
+template <>
+inline Simd<bool, N> isnan(Simd<float16_t, N> v) {
+  return v != v;
+}
+
+template <>
+inline Simd<float16_t, N>
+clamp(Simd<float16_t, N> v, Simd<float16_t, N> min, Simd<float16_t, N> max) {
+  return minimum(maximum(v, min), max);
+}
+
+template <typename T>
+Simd<float16_t, N> fma(Simd<float16_t, N> x, Simd<float16_t, N> y, T z) {
+  return vfmaq_f16(x.value, y.value, Simd<float16_t, N>(z).value);
+}
+
+template <typename MaskT>
+Simd<float16_t, N>
+select(Simd<MaskT, N> mask, Simd<float16_t, N> x, Simd<float16_t, N> y) {
+  return vbslq_f16(Simd<uint16_t, N>(mask).value, x.value, y.value);
+}
+
+// Reductions
+inline float16_t max(Simd<float16_t, N> x) {
+  float16x4_t y;
+  y = vpmax_f16(vget_low_f16(x.value), vget_high_f16(x.value));
+  y = vpmax_f16(y, y);
+  y = vpmax_f16(y, y);
+  return vget_lane_f16(y, 0);
+}
+inline float16_t min(Simd<float16_t, N> x) {
+  float16x4_t y;
+  y = vpmin_f16(vget_low_f16(x.value), vget_high_f16(x.value));
+  y = vpmin_f16(y, y);
+  y = vpmin_f16(y, y);
+  return vget_lane_f16(y, 0);
+}
+inline float16_t sum(Simd<float16_t, N> x) {
+  float16x4_t y;
+  y = vpadd_f16(vget_low_f16(x.value), vget_high_f16(x.value));
+  y = vpadd_f16(y, y);
+  y = vpadd_f16(y, y);
+  return vget_lane_f16(y, 0);
+}
+inline float16_t prod(Simd<float16_t, N> x) {
+  auto hx = vmul_f16(vget_low_f16(x.value), vget_high_f16(x.value));
+  auto out = hx[0];
+  hx[0] *= hx[1];
+  hx[0] *= hx[2];
+  hx[0] *= hx[3];
+  return hx[0];
+}
+
+} // namespace mlx::core::simd
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
new file mode 100644
index 0000000000000000000000000000000000000000..8700f24c096a4131ff4d3654b74ff1764e3b34cc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/simd.h
@@ -0,0 +1,4 @@
+#pragma once
+
+#include "mlx/backend/cpu/simd/math.h"
+#include "mlx/backend/cpu/simd/type.h"
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
new file mode 100644
index 0000000000000000000000000000000000000000..c24da22b29aa741f81b86e0949fa1e3ad54158cb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/simd/type.h
@@ -0,0 +1,7 @@
+#pragma once
+
+#include "mlx/backend/cpu/simd/base_simd.h"
+
+#ifdef MLX_USE_ACCELERATE
+#include "mlx/backend/cpu/simd/accelerate_simd.h"
+#endif
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/slicing.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/slicing.h
new file mode 100644
index 0000000000000000000000000000000000000000..eda37320d0af0c7ddd3b961deda110780b8ed336
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/slicing.h
@@ -0,0 +1,21 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+std::tuple<int64_t, Strides> prepare_slice(
+    const array& in,
+    const Shape& start_indices,
+    const Shape& strides);
+
+void shared_buffer_slice(
+    const array& in,
+    const Strides& out_strides,
+    size_t data_offset,
+    size_t data_size,
+    array& out);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4c2941e965a836d2d7bf46d01893853ba274447f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/softmax.cpp
@@ -0,0 +1,170 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <cassert>
+#include <cmath>
+
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/simd/simd.h"
+#include "mlx/primitives.h"
+#include "mlx/types/limits.h"
+
+namespace mlx::core {
+
+namespace {
+
+using namespace mlx::core::simd;
+
+template <typename T, typename AccT>
+void softmax(const array& in, array& out, Stream stream) {
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+
+  const T* in_ptr = in.data<T>();
+  T* out_ptr = out.data<T>();
+
+  int M = in.shape().back();
+  int L = in.data_size() / M;
+
+  encoder.dispatch([in_ptr, out_ptr, M, L]() mutable {
+    constexpr bool same_t = std::is_same_v<T, AccT>;
+    constexpr int N = std::min(max_size<AccT>, max_size<T>);
+
+    const T* current_in_ptr;
+    T* current_out_ptr;
+
+    for (int i = 0; i < L; i++, in_ptr += M, out_ptr += M) {
+      // Find the maximum
+      current_in_ptr = in_ptr;
+      Simd<AccT, N> vmaximum(-numeric_limits<AccT>::infinity());
+      size_t s = M;
+      while (s >= N) {
+        Simd<AccT, N> vals = load<T, N>(current_in_ptr);
+        vmaximum = maximum(vals, vmaximum);
+        current_in_ptr += N;
+        s -= N;
+      }
+
+      AccT maximum = max(vmaximum);
+      while (s-- > 0) {
+        maximum = std::max(maximum, static_cast<AccT>(*current_in_ptr));
+        current_in_ptr++;
+      }
+
+      // Compute the normalizer and the exponentials
+      Simd<AccT, N> vnormalizer(0.0);
+      current_out_ptr = out_ptr;
+      current_in_ptr = in_ptr;
+      s = M;
+      while (s >= N) {
+        Simd<AccT, N> vexp = load<T, N>(current_in_ptr);
+        vexp = exp(vexp - maximum);
+        if constexpr (same_t) {
+          store(current_out_ptr, vexp);
+        }
+        vnormalizer = vnormalizer + vexp;
+        current_in_ptr += N;
+        current_out_ptr += N;
+        s -= N;
+      }
+      AccT normalizer = sum(vnormalizer);
+      while (s-- > 0) {
+        AccT _exp = std::exp(*current_in_ptr - maximum);
+        if constexpr (same_t) {
+          *current_out_ptr = _exp;
+        }
+        normalizer += _exp;
+        current_in_ptr++;
+        current_out_ptr++;
+      }
+      normalizer = 1 / normalizer;
+
+      // Normalize
+      current_out_ptr = out_ptr;
+      current_in_ptr = in_ptr;
+      s = M;
+      while (s >= N) {
+        if constexpr (same_t) {
+          store(
+              current_out_ptr,
+              Simd<T, N>(load<T, N>(current_out_ptr) * normalizer));
+        } else {
+          Simd<AccT, N> vexp = load<T, N>(current_in_ptr);
+          vexp = exp(vexp - maximum) * normalizer;
+          store(current_out_ptr, Simd<T, N>(vexp));
+          current_in_ptr += N;
+        }
+        current_out_ptr += N;
+        s -= N;
+      }
+      while (s-- > 0) {
+        if constexpr (same_t) {
+          *current_out_ptr *= normalizer;
+        } else {
+          AccT _exp = std::exp(*current_in_ptr - maximum);
+          *current_out_ptr = static_cast<T>(_exp * normalizer);
+          current_in_ptr++;
+        }
+        current_out_ptr++;
+      }
+    }
+  });
+}
+
+} // namespace
+
+void Softmax::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+
+  // Make sure that the last dimension is contiguous
+  auto set_output = [s = stream(), &out](const array& x) {
+    if (x.flags().contiguous && x.strides()[x.ndim() - 1] == 1) {
+      if (x.is_donatable()) {
+        out.copy_shared_buffer(x);
+      } else {
+        out.set_data(
+            allocator::malloc(x.data_size() * x.itemsize()),
+            x.data_size(),
+            x.strides(),
+            x.flags());
+      }
+      return x;
+    } else {
+      array x_copy = contiguous_copy_cpu(x, s);
+      out.copy_shared_buffer(x_copy);
+      return x_copy;
+    }
+  };
+
+  auto in = set_output(inputs[0]);
+
+  switch (in.dtype()) {
+    case float32:
+      softmax<float, float>(in, out, stream());
+      break;
+    case float16:
+      if (precise_) {
+        softmax<float16_t, float>(in, out, stream());
+      } else {
+        softmax<float16_t, float16_t>(in, out, stream());
+      }
+      break;
+    case bfloat16:
+      if (precise_) {
+        softmax<bfloat16_t, float>(in, out, stream());
+      } else {
+        softmax<bfloat16_t, bfloat16_t>(in, out, stream());
+      }
+      break;
+    case float64:
+      softmax<double, double>(in, out, stream());
+      break;
+    default:
+      throw std::runtime_error(
+          "[softmax] Only defined for floating point types.");
+      break;
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0b8471d32c77320f305432dab1350948cd4d193a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/sort.cpp
@@ -0,0 +1,451 @@
+// Copyright © 2023 Apple Inc.
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <numeric>
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+namespace {
+
+template <typename T>
+struct StridedIterator {
+  using iterator_category = std::random_access_iterator_tag;
+  using difference_type = int32_t;
+  using value_type = T;
+  using reference = value_type&;
+  using pointer = value_type*;
+
+  // Constructors
+  StridedIterator() = default;
+
+  explicit StridedIterator(T* ptr, int64_t stride, difference_type offset = 0)
+      : ptr_(ptr + offset * stride), stride_(stride) {}
+
+  explicit StridedIterator(array& arr, int axis, difference_type offset = 0)
+      : StridedIterator(arr.data<T>(), arr.strides()[axis], offset) {}
+
+  // Accessors
+  reference operator*() const {
+    return ptr_[0];
+  }
+
+  reference operator[](difference_type idx) const {
+    return ptr_[idx * stride_];
+  }
+
+  // Comparisons
+  bool operator==(const StridedIterator& other) const {
+    return ptr_ == other.ptr_ && stride_ == other.stride_;
+  }
+
+  bool operator!=(const StridedIterator& other) const {
+    return ptr_ != other.ptr_;
+  }
+
+  bool operator<(const StridedIterator& other) const {
+    return ptr_ < other.ptr_;
+  }
+
+  bool operator>(const StridedIterator& other) const {
+    return ptr_ > other.ptr_;
+  }
+
+  bool operator<=(const StridedIterator& other) const {
+    return ptr_ <= other.ptr_;
+  }
+
+  bool operator>=(const StridedIterator& other) const {
+    return ptr_ >= other.ptr_;
+  }
+
+  difference_type operator-(const StridedIterator& other) const {
+    return (ptr_ - other.ptr_) / stride_;
+  }
+
+  // Moving
+  StridedIterator& operator++() {
+    ptr_ += stride_;
+    return *this;
+  }
+
+  StridedIterator& operator--() {
+    ptr_ -= stride_;
+    return *this;
+  }
+
+  StridedIterator& operator+=(difference_type diff) {
+    ptr_ += diff * stride_;
+    return *this;
+  }
+
+  StridedIterator& operator-=(difference_type diff) {
+    ptr_ -= diff * stride_;
+    return *this;
+  }
+
+  StridedIterator operator+(difference_type diff) {
+    return StridedIterator(ptr_, stride_, diff);
+  }
+
+  StridedIterator operator-(difference_type diff) {
+    return StridedIterator(ptr_, stride_, -diff);
+  }
+
+ private:
+  int64_t stride_;
+  T* ptr_;
+};
+
+template <typename T>
+void sort(array& out, int axis) {
+  // Get axis, shape and stride info
+  axis = axis < 0 ? axis + out.ndim() : axis;
+  size_t in_size = out.size();
+  size_t n_rows = in_size / out.shape(axis);
+
+  auto remaining_shape = out.shape();
+  remaining_shape.erase(remaining_shape.begin() + axis);
+
+  auto remaining_strides = out.strides();
+  remaining_strides.erase(remaining_strides.begin() + axis);
+
+  auto axis_stride = out.strides()[axis];
+  auto axis_size = out.shape(axis);
+
+  // Perform sorting in place
+  ContiguousIterator src_it(
+      remaining_shape, remaining_strides, remaining_shape.size());
+  auto out_ptr = out.data<T>();
+  for (int i = 0; i < n_rows; i++) {
+    T* data_ptr = out_ptr + src_it.loc;
+
+    StridedIterator st(data_ptr, axis_stride, 0);
+    StridedIterator ed(data_ptr, axis_stride, axis_size);
+
+    std::stable_sort(st, ed);
+    src_it.step();
+  }
+}
+
+template <typename T, typename IdxT = uint32_t>
+void argsort(const array& in, array& out, int axis) {
+  // Get axis, shape and stride info
+  axis = axis < 0 ? axis + in.ndim() : axis;
+  size_t n_rows = in.size() / in.shape(axis);
+
+  auto in_remaining_shape = in.shape();
+  in_remaining_shape.erase(in_remaining_shape.begin() + axis);
+
+  auto in_remaining_strides = in.strides();
+  in_remaining_strides.erase(in_remaining_strides.begin() + axis);
+
+  auto out_remaining_shape = out.shape();
+  out_remaining_shape.erase(out_remaining_shape.begin() + axis);
+
+  auto out_remaining_strides = out.strides();
+  out_remaining_strides.erase(out_remaining_strides.begin() + axis);
+
+  auto in_stride = in.strides()[axis];
+  auto out_stride = out.strides()[axis];
+  auto axis_size = in.shape(axis);
+
+  // Perform sorting
+  ContiguousIterator in_it(
+      in_remaining_shape, in_remaining_strides, in_remaining_shape.size());
+  ContiguousIterator out_it(
+      out_remaining_shape, out_remaining_strides, out_remaining_shape.size());
+  auto in_ptr = in.data<T>();
+  auto out_ptr = out.data<IdxT>();
+  for (int i = 0; i < n_rows; i++) {
+    const T* data_ptr = in_ptr + in_it.loc;
+    IdxT* idx_ptr = out_ptr + out_it.loc;
+
+    in_it.step();
+    out_it.step();
+
+    StridedIterator st_(idx_ptr, out_stride, 0);
+    StridedIterator ed_(idx_ptr, out_stride, axis_size);
+
+    // Initialize with iota
+    std::iota(st_, ed_, IdxT(0));
+
+    // Sort according to vals
+    StridedIterator st(idx_ptr, out_stride, 0);
+    StridedIterator ed(idx_ptr, out_stride, axis_size);
+
+    std::stable_sort(st, ed, [data_ptr, in_stride](IdxT a, IdxT b) {
+      auto v1 = data_ptr[a * in_stride];
+      auto v2 = data_ptr[b * in_stride];
+      return v1 < v2 || (v1 == v2 && a < b);
+    });
+  }
+}
+
+template <typename T>
+void partition(array& out, int axis, int kth) {
+  // Get axis, shape and stride info
+  axis = axis < 0 ? axis + out.ndim() : axis;
+  size_t in_size = out.size();
+  size_t n_rows = in_size / out.shape(axis);
+
+  auto remaining_shape = out.shape();
+  remaining_shape.erase(remaining_shape.begin() + axis);
+
+  auto remaining_strides = out.strides();
+  remaining_strides.erase(remaining_strides.begin() + axis);
+
+  auto axis_stride = out.strides()[axis];
+  int axis_size = out.shape(axis);
+
+  kth = kth < 0 ? kth + axis_size : kth;
+
+  // Perform partition in place
+  ContiguousIterator src_it(
+      remaining_shape, remaining_strides, remaining_shape.size());
+  auto out_ptr = out.data<T>();
+  for (int i = 0; i < n_rows; i++) {
+    T* data_ptr = out_ptr + src_it.loc;
+    src_it.step();
+
+    StridedIterator st(data_ptr, axis_stride, 0);
+    StridedIterator md(data_ptr, axis_stride, kth);
+    StridedIterator ed(data_ptr, axis_stride, axis_size);
+
+    std::nth_element(st, md, ed);
+  }
+}
+
+template <typename T, typename IdxT = uint32_t>
+void argpartition(const array& in, array& out, int axis, int kth) {
+  // Get axis, shape and stride info
+  axis = axis < 0 ? axis + in.ndim() : axis;
+  size_t n_rows = in.size() / in.shape(axis);
+
+  auto in_remaining_shape = in.shape();
+  in_remaining_shape.erase(in_remaining_shape.begin() + axis);
+
+  auto in_remaining_strides = in.strides();
+  in_remaining_strides.erase(in_remaining_strides.begin() + axis);
+
+  auto out_remaining_shape = out.shape();
+  out_remaining_shape.erase(out_remaining_shape.begin() + axis);
+
+  auto out_remaining_strides = out.strides();
+  out_remaining_strides.erase(out_remaining_strides.begin() + axis);
+
+  auto in_stride = in.strides()[axis];
+  auto out_stride = out.strides()[axis];
+  auto axis_size = in.shape(axis);
+
+  kth = kth < 0 ? kth + axis_size : kth;
+
+  // Perform partition
+  ContiguousIterator in_it(
+      in_remaining_shape, in_remaining_strides, in_remaining_shape.size());
+  ContiguousIterator out_it(
+      out_remaining_shape, out_remaining_strides, out_remaining_shape.size());
+
+  auto in_ptr = in.data<T>();
+  auto out_ptr = out.data<IdxT>();
+
+  for (int i = 0; i < n_rows; i++) {
+    const T* data_ptr = in_ptr + in_it.loc;
+    IdxT* idx_ptr = out_ptr + out_it.loc;
+    in_it.step();
+    out_it.step();
+
+    StridedIterator st_(idx_ptr, out_stride, 0);
+    StridedIterator ed_(idx_ptr, out_stride, axis_size);
+
+    // Initialize with iota
+    std::iota(st_, ed_, IdxT(0));
+
+    // Sort according to vals
+    StridedIterator st(idx_ptr, out_stride, 0);
+    StridedIterator md(idx_ptr, out_stride, kth);
+    StridedIterator ed(idx_ptr, out_stride, axis_size);
+
+    std::nth_element(st, md, ed, [data_ptr, in_stride](IdxT a, IdxT b) {
+      auto v1 = data_ptr[a * in_stride];
+      auto v2 = data_ptr[b * in_stride];
+      return v1 < v2 || (v1 == v2 && a < b);
+    });
+  }
+}
+
+} // namespace
+
+void ArgSort::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+
+  // Allocate output
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& encoder = cpu::get_command_encoder(stream());
+  encoder.set_input_array(in);
+  encoder.set_input_array(out);
+  encoder.dispatch([in = array::unsafe_weak_copy(in),
+                    out = array::unsafe_weak_copy(out),
+                    axis_ = axis_]() mutable {
+    switch (in.dtype()) {
+      case bool_:
+        return argsort<bool>(in, out, axis_);
+      case uint8:
+        return argsort<uint8_t>(in, out, axis_);
+      case uint16:
+        return argsort<uint16_t>(in, out, axis_);
+      case uint32:
+        return argsort<uint32_t>(in, out, axis_);
+      case uint64:
+        return argsort<uint64_t>(in, out, axis_);
+      case int8:
+        return argsort<int8_t>(in, out, axis_);
+      case int16:
+        return argsort<int16_t>(in, out, axis_);
+      case int32:
+        return argsort<int32_t>(in, out, axis_);
+      case int64:
+        return argsort<int64_t>(in, out, axis_);
+      case float32:
+        return argsort<float>(in, out, axis_);
+      case float64:
+        return argsort<double>(in, out, axis_);
+      case float16:
+        return argsort<float16_t>(in, out, axis_);
+      case bfloat16:
+        return argsort<bfloat16_t>(in, out, axis_);
+      case complex64:
+        return argsort<complex64_t>(in, out, axis_);
+    }
+  });
+}
+
+void Sort::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+
+  int axis = axis_;
+  if (axis < 0) {
+    axis += in.ndim();
+  }
+
+  // Copy input to output
+  CopyType ctype = (in.flags().contiguous && in.strides()[axis] != 0)
+      ? CopyType::Vector
+      : CopyType::General;
+  copy_cpu(in, out, ctype, stream());
+
+  auto& encoder = cpu::get_command_encoder(stream());
+  encoder.set_output_array(out);
+  encoder.dispatch([out = array::unsafe_weak_copy(out), axis]() mutable {
+    dispatch_all_types(out.dtype(), [&](auto type_tag) {
+      sort<MLX_GET_TYPE(type_tag)>(out, axis);
+    });
+  });
+}
+
+void ArgPartition::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+
+  // Allocate output
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& encoder = cpu::get_command_encoder(stream());
+  encoder.set_input_array(in);
+  encoder.set_input_array(out);
+  encoder.dispatch([in = array::unsafe_weak_copy(in),
+                    out = array::unsafe_weak_copy(out),
+                    axis_ = axis_,
+                    kth_ = kth_]() mutable {
+    switch (in.dtype()) {
+      case bool_:
+        return argpartition<bool>(in, out, axis_, kth_);
+      case uint8:
+        return argpartition<uint8_t>(in, out, axis_, kth_);
+      case uint16:
+        return argpartition<uint16_t>(in, out, axis_, kth_);
+      case uint32:
+        return argpartition<uint32_t>(in, out, axis_, kth_);
+      case uint64:
+        return argpartition<uint64_t>(in, out, axis_, kth_);
+      case int8:
+        return argpartition<int8_t>(in, out, axis_, kth_);
+      case int16:
+        return argpartition<int16_t>(in, out, axis_, kth_);
+      case int32:
+        return argpartition<int32_t>(in, out, axis_, kth_);
+      case int64:
+        return argpartition<int64_t>(in, out, axis_, kth_);
+      case float32:
+        return argpartition<float>(in, out, axis_, kth_);
+      case float64:
+        return argpartition<double>(in, out, axis_, kth_);
+      case float16:
+        return argpartition<float16_t>(in, out, axis_, kth_);
+      case bfloat16:
+        return argpartition<bfloat16_t>(in, out, axis_, kth_);
+      case complex64:
+        return argpartition<complex64_t>(in, out, axis_, kth_);
+    }
+  });
+}
+
+void Partition::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+
+  // Copy input to output
+  CopyType ctype = (in.flags().contiguous && in.strides()[axis_] != 0)
+      ? CopyType::Vector
+      : CopyType::General;
+  copy_cpu(in, out, ctype, stream());
+
+  auto& encoder = cpu::get_command_encoder(stream());
+  encoder.set_output_array(out);
+  encoder.dispatch([out = array::unsafe_weak_copy(out),
+                    axis_ = axis_,
+                    kth_ = kth_]() mutable {
+    switch (out.dtype()) {
+      case bool_:
+        return partition<bool>(out, axis_, kth_);
+      case uint8:
+        return partition<uint8_t>(out, axis_, kth_);
+      case uint16:
+        return partition<uint16_t>(out, axis_, kth_);
+      case uint32:
+        return partition<uint32_t>(out, axis_, kth_);
+      case uint64:
+        return partition<uint64_t>(out, axis_, kth_);
+      case int8:
+        return partition<int8_t>(out, axis_, kth_);
+      case int16:
+        return partition<int16_t>(out, axis_, kth_);
+      case int32:
+        return partition<int32_t>(out, axis_, kth_);
+      case int64:
+        return partition<int64_t>(out, axis_, kth_);
+      case float32:
+        return partition<float>(out, axis_, kth_);
+      case float64:
+        return partition<double>(out, axis_, kth_);
+      case float16:
+        return partition<float16_t>(out, axis_, kth_);
+      case bfloat16:
+        return partition<bfloat16_t>(out, axis_, kth_);
+      case complex64:
+        return partition<complex64_t>(out, axis_, kth_);
+    }
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6e57eb40111ba4afc73b90f0b9dc91fbefa0cc5b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/svd.cpp
@@ -0,0 +1,179 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/allocator.h"
+#include "mlx/backend/cpu/copy.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/lapack.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+template <typename T>
+void svd_impl(
+    const array& a,
+    std::vector<array>& outputs,
+    bool compute_uv,
+    Stream stream) {
+  // Lapack uses the column-major convention. To avoid having to transpose
+  // the input and then transpose the outputs, we swap the indices/sizes of the
+  // matrices and take advantage of the following identity (see
+  // https://math.stackexchange.com/a/30077)
+  //    A = UΣVᵀ
+  //    Aᵀ = VΣUᵀ
+  // As a result some of the indices/sizes are swapped as noted above.
+
+  // Rows and cols of the original matrix in row-major order.
+  const int M = a.shape(-2);
+  const int N = a.shape(-1);
+  const int K = std::min(M, N);
+
+  size_t num_matrices = a.size() / (M * N);
+
+  // lapack clobbers the input, so we have to make a copy.
+  array in(a.shape(), a.dtype(), nullptr, {});
+  copy_cpu(
+      a,
+      in,
+      a.flags().row_contiguous ? CopyType::Vector : CopyType::General,
+      stream);
+
+  // Allocate outputs.
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  auto in_ptr = in.data<T>();
+  T* u_ptr;
+  T* s_ptr;
+  T* vt_ptr;
+
+  if (compute_uv) {
+    array& u = outputs[0];
+    array& s = outputs[1];
+    array& vt = outputs[2];
+
+    u.set_data(allocator::malloc(u.nbytes()));
+    s.set_data(allocator::malloc(s.nbytes()));
+    vt.set_data(allocator::malloc(vt.nbytes()));
+
+    encoder.set_output_array(u);
+    encoder.set_output_array(s);
+    encoder.set_output_array(vt);
+
+    s_ptr = s.data<T>();
+    u_ptr = u.data<T>();
+    vt_ptr = vt.data<T>();
+  } else {
+    array& s = outputs[0];
+
+    s.set_data(allocator::malloc(s.nbytes()));
+
+    encoder.set_output_array(s);
+
+    s_ptr = s.data<T>();
+    u_ptr = nullptr;
+    vt_ptr = nullptr;
+  }
+
+  encoder.dispatch([in_ptr, u_ptr, s_ptr, vt_ptr, M, N, K, num_matrices]() {
+    // A of shape M x N. The leading dimension is N since lapack receives Aᵀ.
+    const int lda = N;
+    // U of shape M x M. (N x N in lapack).
+    const int ldu = N;
+    // Vᵀ of shape N x N. (M x M in lapack).
+    const int ldvt = M;
+
+    auto jobz = (u_ptr) ? "A" : "N";
+
+    // Will contain the number of singular values after the call has returned.
+    int ns = 0;
+    T workspace_dimension = 0;
+
+    // Will contain the indices of eigenvectors that failed to converge (not
+    // used here but required by lapack).
+    auto iwork = array::Data{allocator::malloc(sizeof(int) * 8 * K)};
+
+    static const int lwork_query = -1;
+
+    int info;
+
+    // Compute workspace size.
+    gesdd<T>(
+        /* jobz = */ jobz,
+        // M and N are swapped since lapack expects column-major.
+        /* m = */ &N,
+        /* n = */ &M,
+        /* a = */ nullptr,
+        /* lda = */ &lda,
+        /* s = */ nullptr,
+        /* u = */ nullptr,
+        /* ldu = */ &ldu,
+        /* vt = */ nullptr,
+        /* ldvt = */ &ldvt,
+        /* work = */ &workspace_dimension,
+        /* lwork = */ &lwork_query,
+        /* iwork = */ static_cast<int*>(iwork.buffer.raw_ptr()),
+        /* info = */ &info);
+
+    if (info != 0) {
+      std::stringstream ss;
+      ss << "[SVD::eval_cpu] workspace calculation failed with code " << info;
+      throw std::runtime_error(ss.str());
+    }
+
+    const int lwork = workspace_dimension;
+    auto scratch = array::Data{allocator::malloc(sizeof(T) * lwork)};
+
+    // Loop over matrices.
+    for (int i = 0; i < num_matrices; i++) {
+      gesdd<T>(
+          /* jobz = */ jobz,
+          // M and N are swapped since lapack expects column-major.
+          /* m = */ &N,
+          /* n = */ &M,
+          /* a = */ in_ptr + M * N * i,
+          /* lda = */ &lda,
+          /* s = */ s_ptr + K * i,
+          // According to the identity above, lapack will write Vᵀᵀ as U.
+          /* u = */ vt_ptr ? vt_ptr + N * N * i : nullptr,
+          /* ldu = */ &ldu,
+          // According to the identity above, lapack will write Uᵀ as Vᵀ.
+          /* vt = */ u_ptr ? u_ptr + M * M * i : nullptr,
+          /* ldvt = */ &ldvt,
+          /* work = */ static_cast<T*>(scratch.buffer.raw_ptr()),
+          /* lwork = */ &lwork,
+          /* iwork = */ static_cast<int*>(iwork.buffer.raw_ptr()),
+          /* info = */ &info);
+
+      if (info != 0) {
+        std::stringstream ss;
+        ss << "svd_impl: sgesvdx_ failed with code " << info;
+        throw std::runtime_error(ss.str());
+      }
+    }
+  });
+  encoder.add_temporary(in);
+}
+
+template <typename T>
+void compute_svd(
+    const array& a,
+    bool compute_uv,
+    std::vector<array>& outputs,
+    Stream stream) {}
+
+void SVD::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  switch (inputs[0].dtype()) {
+    case float32:
+      svd_impl<float>(inputs[0], outputs, compute_uv_, stream());
+      break;
+    case float64:
+      svd_impl<double>(inputs[0], outputs, compute_uv_, stream());
+      break;
+    default:
+      throw std::runtime_error(
+          "[SVD::eval_cpu] only supports float32 or float64.");
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/ternary.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/ternary.h
new file mode 100644
index 0000000000000000000000000000000000000000..a27a7f2a9fc1ed1250373387d7ac3463f68bed8d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/ternary.h
@@ -0,0 +1,154 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+#include "mlx/array.h"
+#include "mlx/backend/common/ternary.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cpu/encoder.h"
+
+namespace mlx::core {
+
+template <typename T1, typename T2, typename T3, typename U, typename Op, int D>
+void ternary_op_dims(
+    const T1* a,
+    const T2* b,
+    const T3* c,
+    U* out,
+    Op op,
+    const Shape& shape,
+    const Strides& a_strides,
+    const Strides& b_strides,
+    const Strides& c_strides,
+    const Strides& out_strides,
+    int axis) {
+  auto stride_a = a_strides[axis];
+  auto stride_b = b_strides[axis];
+  auto stride_c = c_strides[axis];
+  auto stride_out = out_strides[axis];
+  auto N = shape[axis];
+
+  for (int i = 0; i < N; i++) {
+    if constexpr (D > 1) {
+      ternary_op_dims<T1, T2, T3, U, Op, D - 1>(
+          a,
+          b,
+          c,
+          out,
+          op,
+          shape,
+          a_strides,
+          b_strides,
+          c_strides,
+          out_strides,
+          axis + 1);
+    } else {
+      *out = op(*a, *b, *c);
+    }
+    a += stride_a;
+    b += stride_b;
+    c += stride_c;
+    out += stride_out;
+  }
+}
+
+template <typename T1, typename T2, typename T3, typename U, typename Op>
+void ternary_op_dispatch_dims(
+    const T1* a_ptr,
+    const T2* b_ptr,
+    const T3* c_ptr,
+    U* out_ptr,
+    Op op,
+    size_t size,
+    Shape& shape,
+    std::vector<Strides>& strides) {
+  const auto& a_strides = strides[0];
+  const auto& b_strides = strides[1];
+  const auto& c_strides = strides[2];
+  const auto& out_strides = strides[3];
+  int ndim = shape.size();
+  switch (ndim) {
+    case 1:
+      ternary_op_dims<T1, T2, T3, U, Op, 1>(
+          a_ptr,
+          b_ptr,
+          c_ptr,
+          out_ptr,
+          op,
+          shape,
+          a_strides,
+          b_strides,
+          c_strides,
+          out_strides,
+          0);
+      return;
+    case 2:
+      ternary_op_dims<T1, T2, T3, U, Op, 2>(
+          a_ptr,
+          b_ptr,
+          c_ptr,
+          out_ptr,
+          op,
+          shape,
+          a_strides,
+          b_strides,
+          c_strides,
+          out_strides,
+          0);
+      return;
+  }
+
+  ContiguousIterator a_it(shape, a_strides, ndim - 2);
+  ContiguousIterator b_it(shape, b_strides, ndim - 2);
+  ContiguousIterator c_it(shape, c_strides, ndim - 2);
+  auto stride = out_strides[ndim - 3];
+  for (size_t elem = 0; elem < size; elem += stride) {
+    ternary_op_dims<T1, T2, T3, U, Op, 2>(
+        a_ptr + a_it.loc,
+        b_ptr + b_it.loc,
+        c_ptr + c_it.loc,
+        out_ptr + elem,
+        op,
+        shape,
+        a_strides,
+        b_strides,
+        c_strides,
+        out_strides,
+        ndim - 2);
+    a_it.step();
+    b_it.step();
+    c_it.step();
+  }
+}
+
+template <typename T1, typename T2, typename T3, typename U, typename Op>
+void ternary_op(
+    const array& a,
+    const array& b,
+    const array& c,
+    array& out,
+    Op op,
+    TernaryOpType topt) {
+  const T1* a_ptr = a.data<T1>();
+  const T2* b_ptr = b.data<T2>();
+  const T3* c_ptr = c.data<T3>();
+  U* out_ptr = out.data<U>();
+
+  if (topt == TernaryOpType::ScalarScalarScalar) {
+    *out_ptr = op(*a_ptr, *b_ptr, *c_ptr);
+  } else if (topt == TernaryOpType::VectorVectorVector) {
+    for (size_t i = 0; i < out.size(); ++i) {
+      *out_ptr = op(*a_ptr, *b_ptr, *c_ptr);
+      a_ptr++;
+      b_ptr++;
+      c_ptr++;
+      out_ptr++;
+    }
+  } else {
+    auto [shape, strides] = collapse_contiguous_dims(
+        a.shape(), {a.strides(), b.strides(), c.strides(), out.strides()});
+    ternary_op_dispatch_dims<T1, T2, T3, U>(
+        a_ptr, b_ptr, c_ptr, out_ptr, op, out.size(), shape, strides);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8056b842c03760b2dd71c6309c63b70423b4ef72
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.cpp
@@ -0,0 +1,31 @@
+// Copyright © 2023 Apple Inc.
+
+#include "mlx/backend/cpu/threefry.h"
+
+namespace mlx::core::random {
+
+std::pair<uint32_t, uint32_t> threefry2x32_hash(
+    const std::pair<uint32_t, uint32_t>& key,
+    std::pair<uint32_t, uint32_t> count) {
+  constexpr static uint32_t rotations[2][4] = {
+      {13, 15, 26, 6}, {17, 29, 16, 24}};
+
+  uint32_t ks[3] = {key.first, key.second, key.first ^ key.second ^ 0x1BD11BDA};
+
+  count.first += ks[0];
+  count.second += ks[1];
+
+  for (int i = 0; i < 5; ++i) {
+    for (auto r : rotations[i % 2]) {
+      count.first += count.second;
+      count.second = (count.second << r) | (count.second >> (32 - r));
+      count.second ^= count.first;
+    }
+    count.first += ks[(i + 1) % 3];
+    count.second += ks[(i + 2) % 3] + i + 1;
+  }
+
+  return count;
+}
+
+} // namespace mlx::core::random
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.h
new file mode 100644
index 0000000000000000000000000000000000000000..0fc485fcbdc880ccd289ff0bb6de1bb202f7014c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/threefry.h
@@ -0,0 +1,21 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <cstdint>
+#include <utility>
+
+namespace mlx::core::random {
+
+/** Applies the Threefry 2x32 hash function.
+ * This code is based on the Jax counter-based and splittable PRNG
+ * https://github.com/google/jax/blob/main/docs/jep/263-prng.md
+ *
+ * Original Threefry reference:
+ * http://www.thesalmons.org/john/random123/papers/random123sc11.pdf
+ */
+std::pair<uint32_t, uint32_t> threefry2x32_hash(
+    const std::pair<uint32_t, uint32_t>& key,
+    std::pair<uint32_t, uint32_t> count);
+
+} // namespace mlx::core::random
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp b/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eafe98866f7396284184692f69af31e9efe574e8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.cpp
@@ -0,0 +1,238 @@
+// Copyright © 2024 Apple Inc.
+
+// Required for using M_LN2 in MSVC.
+#define _USE_MATH_DEFINES
+
+#include <cassert>
+
+#include "mlx/backend/cpu/unary.h"
+#include "mlx/backend/cpu/unary_ops.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+void Abs::eval_cpu(const std::vector<array>& inputs, array& out) {
+  auto& in = inputs[0];
+  if (issubdtype(in.dtype(), unsignedinteger) || in.dtype() == bool_) {
+    // No-op for unsigned types
+    out.copy_shared_buffer(in);
+  } else {
+    unary_signed(in, out, detail::Abs(), stream());
+  }
+}
+
+void ArcCos::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::ArcCos(), stream());
+}
+
+void ArcCosh::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::ArcCosh(), stream());
+}
+
+void ArcSin::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::ArcSin(), stream());
+}
+
+void ArcSinh::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::ArcSinh(), stream());
+}
+
+void ArcTan::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::ArcTan(), stream());
+}
+
+void ArcTanh::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::ArcTanh(), stream());
+}
+
+void BitwiseInvert::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_int(in, out, detail::BitwiseInvert(), stream());
+}
+
+void Ceil::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  if (issubdtype(in.dtype(), inexact)) {
+    unary_fp(in, out, detail::Ceil(), stream());
+  } else {
+    // No-op integer types
+    out.copy_shared_buffer(in);
+  }
+}
+
+void Conjugate::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  unary_complex(inputs[0], out, detail::Conjugate(), stream());
+}
+
+void Cos::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::Cos(), stream());
+}
+
+void Cosh::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::Cosh(), stream());
+}
+
+void Erf::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_real_fp(in, out, detail::Erf(), stream());
+}
+
+void ErfInv::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_real_fp(in, out, detail::ErfInv(), stream());
+}
+
+void Exp::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::Exp(), stream());
+}
+
+void Expm1::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::Expm1(), stream());
+}
+
+void Floor::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  if (issubdtype(in.dtype(), inexact)) {
+    unary_fp(in, out, detail::Floor(), stream());
+  } else {
+    // No-op integer types
+    out.copy_shared_buffer(in);
+  }
+}
+
+void Imag::eval_cpu(const std::vector<array>& inputs, array& out) {
+  unary_complex_to_float(inputs[0], out, detail::Imag(), stream());
+}
+
+void Log::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  switch (base_) {
+    case Base::e:
+      unary_fp(in, out, detail::Log(), stream());
+      break;
+    case Base::two:
+      unary_fp(in, out, detail::Log2(), stream());
+      break;
+    case Base::ten:
+      unary_fp(in, out, detail::Log10(), stream());
+      break;
+  }
+}
+
+void Log1p::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::Log1p(), stream());
+}
+
+void LogicalNot::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  unary(in, out, detail::LogicalNot(), stream());
+}
+
+void Negative::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  unary(in, out, detail::Negative(), stream());
+}
+
+void Real::eval_cpu(const std::vector<array>& inputs, array& out) {
+  unary_complex_to_float(inputs[0], out, detail::Real(), stream());
+}
+
+void Round::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  if (issubdtype(in.dtype(), inexact)) {
+    unary_fp(in, out, detail::Round(), stream());
+  } else {
+    // No-op integer types
+    out.copy_shared_buffer(in);
+  }
+}
+
+void Sigmoid::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::Sigmoid(), stream());
+}
+
+void Sign::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  if (in.dtype() == bool_) {
+    out.copy_shared_buffer(in);
+  } else {
+    unary(in, out, detail::Sign(), stream());
+  }
+}
+
+void Sin::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::Sin(), stream());
+}
+
+void Sinh::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::Sinh(), stream());
+}
+
+void Square::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  unary(in, out, detail::Square(), stream());
+}
+
+void Sqrt::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  if (recip_) {
+    unary_fp(in, out, detail::Rsqrt(), stream());
+  } else {
+    unary_fp(in, out, detail::Sqrt(), stream());
+  }
+}
+
+void Tan::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::Tan(), stream());
+}
+
+void Tanh::eval_cpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  unary_fp(in, out, detail::Tanh(), stream());
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.h
new file mode 100644
index 0000000000000000000000000000000000000000..14c1dd479a3d5c02215cd352f38f018c4424a8ca
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/unary.h
@@ -0,0 +1,281 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/common/unary.h"
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/backend/cpu/simd/simd.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+template <typename T, typename U = T, typename Op>
+void unary_op(const T* a, U* out, size_t shape, size_t stride) {
+  for (size_t i = 0; i < shape; i += 1) {
+    out[i] = Op{}(*a);
+    a += stride;
+  }
+}
+
+template <typename T, typename U = T, typename Op>
+void unary_op(const array& a, array& out, Op) {
+  const T* src = a.data<T>();
+  U* dst = out.data<U>();
+  auto ndim = a.ndim();
+  if (a.flags().contiguous) {
+    auto size = a.data_size();
+    constexpr int N = simd::max_size<T>;
+    while (size >= N) {
+      simd::store(dst, Op{}(simd::load<T, N>(src)));
+      size -= N;
+      src += N;
+      dst += N;
+    }
+    while (size > 0) {
+      *dst = Op{}(*src);
+      size--;
+      dst++;
+      src++;
+    }
+  } else {
+    size_t shape = ndim > 0 ? a.shape().back() : 1;
+    size_t stride = ndim > 0 ? a.strides().back() : 1;
+    if (ndim <= 1) {
+      unary_op<T, U, Op>(src, dst, shape, stride);
+      return;
+    }
+    auto it = ContiguousIterator(a.shape(), a.strides(), ndim - 1);
+    for (size_t elem = 0; elem < a.size(); elem += shape) {
+      unary_op<T, U, Op>(src + it.loc, dst + elem, shape, stride);
+      it.step();
+    }
+  }
+}
+
+template <typename Op>
+void unary(const array& a, array& out, Op op, Stream stream) {
+  set_unary_output_data(a, out);
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_output_array(out);
+  encoder.dispatch([a = array::unsafe_weak_copy(a),
+                    out = array::unsafe_weak_copy(out),
+                    op = op]() mutable {
+    switch (out.dtype()) {
+      case bool_:
+        unary_op<bool>(a, out, op);
+        break;
+      case uint8:
+        unary_op<uint8_t>(a, out, op);
+        break;
+      case uint16:
+        unary_op<uint16_t>(a, out, op);
+        break;
+      case uint32:
+        unary_op<uint32_t>(a, out, op);
+        break;
+      case uint64:
+        unary_op<uint64_t>(a, out, op);
+        break;
+      case int8:
+        unary_op<int8_t>(a, out, op);
+        break;
+      case int16:
+        unary_op<int16_t>(a, out, op);
+        break;
+      case int32:
+        unary_op<int32_t>(a, out, op);
+        break;
+      case int64:
+        unary_op<int64_t>(a, out, op);
+        break;
+      case float16:
+        unary_op<float16_t>(a, out, op);
+        break;
+      case float32:
+        unary_op<float>(a, out, op);
+        break;
+      case float64:
+        unary_op<double>(a, out, op);
+        break;
+      case bfloat16:
+        unary_op<bfloat16_t>(a, out, op);
+        break;
+      case complex64:
+        unary_op<complex64_t>(a, out, op);
+        break;
+    }
+  });
+}
+
+template <typename Op>
+void unary_real_fp(const array& a, array& out, Op op, Stream stream) {
+  set_unary_output_data(a, out);
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_output_array(out);
+  encoder.dispatch([a = array::unsafe_weak_copy(a),
+                    out = array::unsafe_weak_copy(out),
+                    op = op]() mutable {
+    switch (out.dtype()) {
+      case bfloat16:
+        unary_op<bfloat16_t>(a, out, op);
+        break;
+      case float16:
+        unary_op<float16_t>(a, out, op);
+        break;
+      case float32:
+        unary_op<float>(a, out, op);
+        break;
+      case float64:
+        unary_op<double>(a, out, op);
+        break;
+      default:
+        std::ostringstream err;
+        err << "[unary_real] Does not support " << out.dtype();
+        throw std::runtime_error(err.str());
+    }
+  });
+}
+template <typename Op>
+void unary_fp(const array& a, array& out, Op op, Stream stream) {
+  set_unary_output_data(a, out);
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_output_array(out);
+  encoder.dispatch([a = array::unsafe_weak_copy(a),
+                    out = array::unsafe_weak_copy(out),
+                    op = op]() mutable {
+    switch (out.dtype()) {
+      case bfloat16:
+        unary_op<bfloat16_t>(a, out, op);
+        break;
+      case float16:
+        unary_op<float16_t>(a, out, op);
+        break;
+      case float32:
+        unary_op<float>(a, out, op);
+        break;
+      case float64:
+        unary_op<double>(a, out, op);
+        break;
+      case complex64:
+        unary_op<complex64_t>(a, out, op);
+        break;
+      default:
+        std::ostringstream err;
+        err << "[unary_fp] Does not support " << out.dtype();
+        throw std::runtime_error(err.str());
+    }
+  });
+}
+
+template <typename Op>
+void unary_signed(const array& a, array& out, Op op, Stream stream) {
+  set_unary_output_data(a, out);
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_output_array(out);
+  encoder.dispatch([a = array::unsafe_weak_copy(a),
+                    out = array::unsafe_weak_copy(out),
+                    op = op]() mutable {
+    switch (out.dtype()) {
+      case int8:
+        unary_op<int8_t>(a, out, op);
+        break;
+      case int16:
+        unary_op<int16_t>(a, out, op);
+        break;
+      case int32:
+        unary_op<int32_t>(a, out, op);
+        break;
+      case int64:
+        unary_op<int64_t>(a, out, op);
+        break;
+      case float16:
+        unary_op<float16_t>(a, out, op);
+        break;
+      case float32:
+        unary_op<float>(a, out, op);
+        break;
+      case float64:
+        unary_op<double>(a, out, op);
+        break;
+      case bfloat16:
+        unary_op<bfloat16_t>(a, out, op);
+        break;
+      case complex64:
+        unary_op<complex64_t>(a, out, op);
+        break;
+      default:
+        throw std::runtime_error("[Abs] Called on unsigned type");
+    }
+  });
+}
+
+template <typename Op>
+void unary_complex(const array& a, array& out, Op op, Stream stream) {
+  set_unary_output_data(a, out);
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_output_array(out);
+  encoder.dispatch([a = array::unsafe_weak_copy(a),
+                    out = array::unsafe_weak_copy(out),
+                    op = op]() mutable { unary_op<complex64_t>(a, out, op); });
+}
+
+template <typename Op>
+void unary_complex_to_float(const array& a, array& out, Op op, Stream stream) {
+  set_unary_output_data(a, out);
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_output_array(out);
+  encoder.dispatch(
+      [a = array::unsafe_weak_copy(a),
+       out = array::unsafe_weak_copy(out),
+       op = op]() mutable { unary_op<complex64_t, float>(a, out, op); });
+}
+
+template <typename Op>
+void unary_int(const array& a, array& out, Op op, Stream stream) {
+  set_unary_output_data(a, out);
+  auto& encoder = cpu::get_command_encoder(stream);
+  encoder.set_input_array(a);
+  encoder.set_output_array(out);
+  encoder.dispatch([a = array::unsafe_weak_copy(a),
+                    out = array::unsafe_weak_copy(out),
+                    op = op]() mutable {
+    switch (out.dtype()) {
+      case uint8:
+        unary_op<uint8_t>(a, out, op);
+        break;
+      case uint16:
+        unary_op<uint16_t>(a, out, op);
+        break;
+      case uint32:
+        unary_op<uint32_t>(a, out, op);
+        break;
+      case uint64:
+        unary_op<uint64_t>(a, out, op);
+        break;
+      case int8:
+        unary_op<int8_t>(a, out, op);
+        break;
+      case int16:
+        unary_op<int16_t>(a, out, op);
+        break;
+      case int32:
+        unary_op<int32_t>(a, out, op);
+        break;
+      case int64:
+        unary_op<int64_t>(a, out, op);
+        break;
+      default:
+        std::ostringstream err;
+        err << "[unary_int] Does not support " << out.dtype();
+        throw std::runtime_error(err.str());
+    }
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cpu/unary_ops.h b/ml-stable-diffusion/mlx/mlx/backend/cpu/unary_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..633230658cdbfb32d18d48be30feb3cf60d91e78
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cpu/unary_ops.h
@@ -0,0 +1,110 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include <stdint.h>
+#include <cmath>
+#include <complex>
+
+#include "mlx/backend/cpu/simd/simd.h"
+
+namespace mlx::core::detail {
+
+using namespace mlx::core::simd;
+
+#define SINGLE()                         \
+  template <typename T>                  \
+  T operator()(T x) {                    \
+    return (*this)(Simd<T, 1>(x)).value; \
+  }
+
+#define DEFAULT_OP(Op, op)                \
+  struct Op {                             \
+    template <int N, typename T>          \
+    Simd<T, N> operator()(Simd<T, N> x) { \
+      return simd::op(x);                 \
+    }                                     \
+    SINGLE()                              \
+  };
+
+DEFAULT_OP(Abs, abs)
+DEFAULT_OP(ArcCos, acos)
+DEFAULT_OP(ArcCosh, acosh)
+DEFAULT_OP(ArcSin, asin)
+DEFAULT_OP(ArcSinh, asinh)
+DEFAULT_OP(ArcTan, atan)
+DEFAULT_OP(ArcTanh, atanh)
+DEFAULT_OP(BitwiseInvert, operator~)
+DEFAULT_OP(Ceil, ceil)
+DEFAULT_OP(Conjugate, conj)
+DEFAULT_OP(Cos, cos)
+DEFAULT_OP(Cosh, cosh)
+DEFAULT_OP(Erf, erf)
+DEFAULT_OP(ErfInv, erfinv)
+DEFAULT_OP(Exp, exp)
+DEFAULT_OP(Expm1, expm1)
+DEFAULT_OP(Floor, floor);
+DEFAULT_OP(Log, log);
+DEFAULT_OP(Log2, log2);
+DEFAULT_OP(Log10, log10);
+DEFAULT_OP(Log1p, log1p);
+DEFAULT_OP(LogicalNot, operator!)
+DEFAULT_OP(Negative, operator-)
+DEFAULT_OP(Round, rint);
+DEFAULT_OP(Sin, sin)
+DEFAULT_OP(Sinh, sinh)
+DEFAULT_OP(Sqrt, sqrt)
+DEFAULT_OP(Rsqrt, rsqrt)
+DEFAULT_OP(Tan, tan)
+DEFAULT_OP(Tanh, tanh)
+
+struct Imag {
+  template <int N>
+  Simd<float, N> operator()(Simd<complex64_t, N> x) {
+    return simd::imag(x);
+  }
+  SINGLE()
+};
+
+struct Real {
+  template <int N>
+  Simd<float, N> operator()(Simd<complex64_t, N> x) {
+    return simd::real(x);
+  }
+  SINGLE()
+};
+
+struct Sigmoid {
+  template <int N, typename T>
+  Simd<T, N> operator()(Simd<T, N> x) {
+    return 1.0f / (1.0f + simd::exp(-x));
+  }
+  SINGLE()
+};
+
+struct Sign {
+  template <int N, typename T>
+  Simd<T, N> operator()(Simd<T, N> x) {
+    auto z = Simd<T, N>{0};
+    auto o = Simd<T, N>{1};
+    auto m = Simd<T, N>{-1};
+    if constexpr (std::is_unsigned_v<T>) {
+      return simd::select(x == z, z, o);
+    } else if constexpr (std::is_same_v<T, complex64_t>) {
+      return simd::select(x == z, x, Simd<T, N>(x / simd::abs(x)));
+    } else {
+      return simd::select(x < z, m, simd::select(x > z, o, z));
+    }
+  }
+  SINGLE()
+};
+
+struct Square {
+  template <int N, typename T>
+  Simd<T, N> operator()(Simd<T, N> x) {
+    return x * x;
+  }
+  SINGLE()
+};
+
+} // namespace mlx::core::detail
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/backend/cuda/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8c38853841a8400d0bb26ecf7d5320724f445e06
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/CMakeLists.txt
@@ -0,0 +1,176 @@
+# Filename rules in cuda backend:
+#
+# * Use .cu/.cuh if code contains device code, and .cpp/.h if not.
+# * Device-only code should be put in device/ subdir.
+# * Files in device/ subdir should not include files outside.
+target_sources(
+  mlx
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/allocator.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/arange.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/arg_reduce.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/binary_two.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/compiled.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/copy.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/copy/copy_contiguous.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/copy/copy_general.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/copy/copy_general_dynamic.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/copy/copy_general_input.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/conv.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/conv/gemm_conv.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/conv/gemm_grouped_conv.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/cuda.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/cudnn_utils.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/custom_kernel.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/device.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/distributed.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/eval.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/event.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/fence.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/gemms/gemv.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/gemms/cublas_gemm.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/jit_module.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/indexing.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/kernel_utils.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/matmul.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/layer_norm.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/logsumexp.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/primitives.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/random.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/reduce.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/reduce/all_reduce.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/reduce/col_reduce.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/reduce/init_reduce.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/reduce/row_reduce.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/rms_norm.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/rope.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/scaled_dot_product_attention.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/scan.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/slicing.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/softmax.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/sort.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/ternary.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/utils.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/quantized/affine_quantize.cu
+          ${CMAKE_CURRENT_SOURCE_DIR}/quantized/quantized.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/worker.cpp)
+
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/binary)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/unary)
+
+if(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 12.9.0)
+  target_sources(
+    mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/gemms/cublas_gemm_batched_12_9.cu)
+else()
+  target_sources(
+    mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/gemms/cublas_gemm_batched_12_0.cpp)
+endif()
+
+target_compile_definitions(mlx PRIVATE MLX_USE_CUDA)
+
+# Embed kernel sources in binary for JIT compilation.
+file(
+  GLOB MLX_JIT_SOURCES
+  RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+  "${CMAKE_CURRENT_SOURCE_DIR}/device/*.h"
+  "${CMAKE_CURRENT_SOURCE_DIR}/device/*.cuh")
+string(JOIN ":" MLX_JIT_SOURCES_ARG ${MLX_JIT_SOURCES})
+add_custom_command(
+  OUTPUT gen/cuda_jit_sources.h
+  COMMAND
+    ${CMAKE_COMMAND} -DMLX_SOURCE_ROOT=${CMAKE_CURRENT_SOURCE_DIR}
+    -DMLX_JIT_SOURCES=${MLX_JIT_SOURCES_ARG} -P
+    "${CMAKE_CURRENT_SOURCE_DIR}/bin2h.cmake"
+  DEPENDS bin2h.cmake ${MLX_JIT_SOURCES})
+add_custom_target(cuda_jit_sources DEPENDS gen/cuda_jit_sources.h)
+add_dependencies(mlx cuda_jit_sources)
+target_include_directories(mlx PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/gen")
+
+# Enable defining device lambda functions.
+target_compile_options(mlx
+                       PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>")
+
+# Enable calling host constexpr functions from device. This is needed because
+# the constexpr version of isnan is host only.
+target_compile_options(
+  mlx PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:--expt-relaxed-constexpr>")
+
+# CUDA 12.8 emits warning #20280-D for copy kernels which is a false positive.
+# Explicitly pass this flag to suppress the warning, it is safe to set it to
+# true but the warning wouldn't be suppressed.
+if(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 12.8.0)
+  target_compile_options(
+    mlx
+    PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:--static-global-template-stub=false>")
+endif()
+
+# Suppress warning when building for compute capability 7 used by V100.
+target_compile_options(
+  mlx PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:--Wno-deprecated-gpu-targets>")
+
+# Use stronger binaries compression. This feature was introduced in CUDA 12.8
+# and requires drivers released after CUDA 12.4.
+if(CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 12.8.0)
+  target_compile_options(
+    mlx PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:--compress-mode=size>")
+endif()
+
+# Compute capability >= 7.0 is required for synchronization between CPU/GPU with
+# managed memory.
+if(NOT DEFINED MLX_CUDA_ARCHITECTURES)
+  set(MLX_CUDA_ARCHITECTURES "native")
+endif()
+message(STATUS "CUDA architectures: ${MLX_CUDA_ARCHITECTURES}")
+set_target_properties(mlx PROPERTIES CUDA_ARCHITECTURES
+                                     "${MLX_CUDA_ARCHITECTURES}")
+
+# Use fixed version of CCCL.
+FetchContent_Declare(
+  cccl
+  URL "https://github.com/NVIDIA/cccl/releases/download/v2.8.1/cccl-v2.8.1.zip")
+FetchContent_MakeAvailable(cccl)
+target_include_directories(mlx BEFORE PRIVATE "${cccl_SOURCE_DIR}/include")
+
+# Use fixed version of NVTX.
+FetchContent_Declare(
+  nvtx3
+  GIT_REPOSITORY https://github.com/NVIDIA/NVTX.git
+  GIT_TAG v3.1.1
+  GIT_SHALLOW TRUE
+  SOURCE_SUBDIR c EXCLUDE_FROM_ALL)
+FetchContent_MakeAvailable(nvtx3)
+target_link_libraries(mlx PUBLIC $<BUILD_INTERFACE:nvtx3-cpp>)
+
+# Make cuda runtime APIs available in non-cuda files.
+find_package(CUDAToolkit REQUIRED)
+target_include_directories(mlx PRIVATE ${CUDAToolkit_INCLUDE_DIRS})
+
+# Use cublasLt.
+target_link_libraries(mlx PRIVATE CUDA::cublasLt)
+
+# Use NVRTC and driver APIs.
+target_link_libraries(mlx PRIVATE CUDA::nvrtc CUDA::cuda_driver)
+
+# Use the frontend APIs of cuDNN.
+FetchContent_Declare(
+  cudnn
+  GIT_REPOSITORY https://github.com/NVIDIA/cudnn-frontend.git
+  GIT_TAG v1.14.0
+  GIT_SHALLOW TRUE
+  EXCLUDE_FROM_ALL)
+set(CUDNN_FRONTEND_SKIP_JSON_LIB ON)
+set(CUDNN_FRONTEND_BUILD_SAMPLES OFF)
+set(CUDNN_FRONTEND_BUILD_TESTS OFF)
+set(CUDNN_FRONTEND_BUILD_PYTHON_BINDINGS OFF)
+FetchContent_MakeAvailable(cudnn)
+target_link_libraries(mlx PRIVATE cudnn_frontend)
+# Link with the actual cuDNN libraries.
+include(${cudnn_frontend_SOURCE_DIR}/cmake/cuDNN.cmake)
+target_link_libraries(mlx PRIVATE CUDNN::cudnn_all)
+
+# Suppress nvcc warnings on MLX headers.
+target_compile_options(mlx PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:-Xcudafe
+                                   --diag_suppress=997>)
+
+# Install CCCL headers for JIT.
+install(DIRECTORY ${cccl_SOURCE_DIR}/include/cuda
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/cccl)
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/allocator.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/allocator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..329906a13f1ed5b6cd087f1d7d0a428a40a62872
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/allocator.cpp
@@ -0,0 +1,265 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/allocator.h"
+#include "mlx/backend/cuda/utils.h"
+#include "mlx/utils.h"
+
+#include <cuda_runtime.h>
+#include <fmt/format.h>
+#include <unistd.h>
+
+#include <cassert>
+
+namespace mlx::core {
+
+namespace cu {
+
+constexpr int page_size = 16384;
+
+// Any allocations smaller than this will try to use the small pool
+constexpr int small_block_size = 8;
+
+// The small pool size in bytes. This should be a multiple of the host page
+// size and small_block_size.
+constexpr int small_pool_size = 4 * page_size;
+
+SmallSizePool::SmallSizePool() {
+  auto num_blocks = small_pool_size / small_block_size;
+  buffer_ = new Block[num_blocks];
+
+  next_free_ = buffer_;
+
+  CHECK_CUDA_ERROR(cudaMallocManaged(&data_, small_pool_size));
+#if CUDART_VERSION >= 13000
+  cudaMemLocation loc;
+  loc.type = cudaMemLocationTypeDevice;
+  loc.id = 0;
+#else
+  int loc = 0;
+#endif // CUDART_VERSION >= 13000
+  CHECK_CUDA_ERROR(
+      cudaMemAdvise(data_, small_pool_size, cudaMemAdviseSetReadMostly, loc));
+
+  auto curr = next_free_;
+  for (size_t i = 1; i < num_blocks; ++i) {
+    curr->next = buffer_ + i;
+    curr = curr->next;
+  }
+  curr->next = nullptr;
+}
+
+SmallSizePool::~SmallSizePool() {
+  CHECK_CUDA_ERROR(cudaFree(data_));
+  delete[] buffer_;
+}
+
+CudaBuffer* SmallSizePool::malloc() {
+  if (next_free_ == nullptr) {
+    return nullptr;
+  }
+  Block* b = next_free_;
+  uint64_t i = next_free_ - buffer_;
+  next_free_ = next_free_->next;
+  b->buf.data = static_cast<char*>(data_) + i * small_block_size;
+  b->buf.size = small_block_size;
+  return &b->buf;
+}
+
+void SmallSizePool::free(CudaBuffer* buf) {
+  auto b = reinterpret_cast<Block*>(buf);
+  b->next = next_free_;
+  next_free_ = b;
+}
+
+bool SmallSizePool::in_pool(CudaBuffer* buf) {
+  constexpr int num_blocks = (small_pool_size / small_block_size);
+  auto b = reinterpret_cast<Block*>(buf);
+  int64_t block_num = b - buffer_;
+  return block_num >= 0 && block_num < num_blocks;
+}
+
+CudaAllocator::CudaAllocator()
+    : buffer_cache_(
+          page_size,
+          [](CudaBuffer* buf) { return buf->size; },
+          [this](CudaBuffer* buf) { cuda_free(buf); }) {
+  // TODO: Set memory limit for multi-device.
+  size_t free, total;
+  CHECK_CUDA_ERROR(cudaMemGetInfo(&free, &total));
+  memory_limit_ = total * 0.95;
+  max_pool_size_ = memory_limit_;
+}
+
+Buffer CudaAllocator::malloc(size_t size) {
+  // Find available buffer from cache.
+  auto orig_size = size;
+  std::unique_lock lock(mutex_);
+  if (size <= small_block_size) {
+    size = 8;
+  } else if (size < page_size) {
+    size = next_power_of_2(size);
+  } else {
+    size = page_size * ((size + page_size - 1) / page_size);
+  }
+
+  CudaBuffer* buf = buffer_cache_.reuse_from_cache(size);
+  if (!buf) {
+    // If we have a lot of memory pressure try to reclaim memory from the cache.
+    int64_t mem_to_free =
+        get_active_memory() + get_cache_memory() + size - memory_limit_;
+    if (mem_to_free > 0) {
+      buffer_cache_.release_cached_buffers(mem_to_free);
+    }
+
+    // Try the scalar pool first
+    if (size <= small_block_size) {
+      buf = scalar_pool_.malloc();
+    }
+    lock.unlock();
+    if (!buf) {
+      buf = new CudaBuffer{nullptr, size};
+      cudaError_t err = cudaMallocManaged(&buf->data, size);
+      if (err != cudaSuccess && err != cudaErrorMemoryAllocation) {
+        throw std::runtime_error(fmt::format(
+            "cudaMallocManaged failed: {}.", cudaGetErrorString(err)));
+      }
+    }
+    lock.lock();
+  }
+  active_memory_ += size;
+  peak_memory_ = std::max(active_memory_, peak_memory_);
+
+  // Maintain the cache below the requested limit.
+  if (get_cache_memory() > max_pool_size_) {
+    buffer_cache_.release_cached_buffers(get_cache_memory() - max_pool_size_);
+  }
+  return Buffer{buf};
+}
+
+void CudaAllocator::free(Buffer buffer) {
+  auto* buf = static_cast<CudaBuffer*>(buffer.ptr());
+  if (!buf) {
+    return;
+  }
+
+  std::unique_lock lock(mutex_);
+  active_memory_ -= buf->size;
+  if (get_cache_memory() < max_pool_size_) {
+    buffer_cache_.recycle_to_cache(buf);
+  } else {
+    cuda_free(buf);
+  }
+}
+
+size_t CudaAllocator::size(Buffer buffer) const {
+  auto* buf = static_cast<CudaBuffer*>(buffer.ptr());
+  if (!buf) {
+    return 0;
+  }
+  return buf->size;
+}
+
+// This must be called with mutex_ aquired
+void CudaAllocator::cuda_free(CudaBuffer* buf) {
+  if (scalar_pool_.in_pool(buf)) {
+    scalar_pool_.free(buf);
+  } else {
+    cudaFree(buf->data);
+    delete buf;
+  }
+}
+
+size_t CudaAllocator::get_active_memory() const {
+  return active_memory_;
+}
+
+size_t CudaAllocator::get_peak_memory() const {
+  return peak_memory_;
+}
+
+void CudaAllocator::reset_peak_memory() {
+  std::lock_guard lock(mutex_);
+  peak_memory_ = 0;
+}
+
+size_t CudaAllocator::get_memory_limit() {
+  return memory_limit_;
+}
+
+size_t CudaAllocator::set_memory_limit(size_t limit) {
+  std::lock_guard lock(mutex_);
+  std::swap(limit, memory_limit_);
+  return limit;
+}
+
+size_t CudaAllocator::get_cache_memory() const {
+  return buffer_cache_.cache_size();
+}
+
+size_t CudaAllocator::set_cache_limit(size_t limit) {
+  std::lock_guard lk(mutex_);
+  std::swap(limit, max_pool_size_);
+  return limit;
+}
+
+void CudaAllocator::clear_cache() {
+  std::lock_guard lk(mutex_);
+  buffer_cache_.clear();
+}
+
+CudaAllocator& allocator() {
+  // By creating the |allocator_| on heap, the destructor of CudaAllocator
+  // will not be called on exit and buffers in the cache will be leaked. This
+  // can save some time at program exit.
+  static CudaAllocator* allocator_ = new CudaAllocator;
+  return *allocator_;
+}
+
+} // namespace cu
+
+namespace allocator {
+
+Allocator& allocator() {
+  return cu::allocator();
+}
+
+void* Buffer::raw_ptr() {
+  if (!ptr_) {
+    return nullptr;
+  }
+  return static_cast<cu::CudaBuffer*>(ptr_)->data;
+}
+
+} // namespace allocator
+
+size_t get_active_memory() {
+  return cu::allocator().get_active_memory();
+}
+size_t get_peak_memory() {
+  return cu::allocator().get_peak_memory();
+}
+void reset_peak_memory() {
+  return cu::allocator().reset_peak_memory();
+}
+size_t set_memory_limit(size_t limit) {
+  return cu::allocator().set_memory_limit(limit);
+}
+size_t get_memory_limit() {
+  return cu::allocator().get_memory_limit();
+}
+size_t get_cache_memory() {
+  return cu::allocator().get_cache_memory();
+}
+size_t set_cache_limit(size_t limit) {
+  return cu::allocator().set_cache_limit(limit);
+}
+void clear_cache() {
+  cu::allocator().clear_cache();
+}
+
+// Not supported in CUDA.
+size_t set_wired_limit(size_t) {
+  return 0;
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/allocator.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..81b3dde59379657779530260eb4804113196eaab
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/allocator.h
@@ -0,0 +1,77 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/allocator.h"
+#include "mlx/backend/common/buffer_cache.h"
+
+#include <mutex>
+#include <set>
+#include <utility>
+
+namespace mlx::core::cu {
+
+using allocator::Buffer;
+
+// Stores cuda-managed unified memory.
+struct CudaBuffer {
+  void* data;
+  size_t size;
+};
+
+class SmallSizePool {
+ private:
+  union Block {
+    Block* next;
+    CudaBuffer buf;
+  };
+
+  Block* buffer_{nullptr};
+  void* data_{nullptr};
+  Block* next_free_{nullptr};
+
+ public:
+  SmallSizePool();
+  ~SmallSizePool();
+
+  SmallSizePool(const SmallSizePool&) = delete;
+  SmallSizePool& operator=(const SmallSizePool&) = delete;
+
+  CudaBuffer* malloc();
+  void free(CudaBuffer* buf);
+  bool in_pool(CudaBuffer* buf);
+};
+
+class CudaAllocator : public allocator::Allocator {
+ public:
+  Buffer malloc(size_t size) override;
+  void free(Buffer buffer) override;
+  size_t size(Buffer buffer) const override;
+
+  size_t get_active_memory() const;
+  size_t get_peak_memory() const;
+  void reset_peak_memory();
+  size_t get_memory_limit();
+  size_t set_memory_limit(size_t limit);
+  size_t get_cache_memory() const;
+  size_t set_cache_limit(size_t limit);
+  void clear_cache();
+
+ private:
+  void cuda_free(CudaBuffer* buf);
+
+  CudaAllocator();
+  friend CudaAllocator& allocator();
+
+  std::mutex mutex_;
+  size_t memory_limit_;
+  size_t max_pool_size_;
+  BufferCache<CudaBuffer> buffer_cache_;
+  size_t active_memory_{0};
+  size_t peak_memory_{0};
+  SmallSizePool scalar_pool_;
+};
+
+CudaAllocator& allocator();
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/arange.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/arange.cu
new file mode 100644
index 0000000000000000000000000000000000000000..a28a245dbc3efd32d26b68e82987c39749bb151c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/arange.cu
@@ -0,0 +1,69 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/device/fp16_math.cuh"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+#include <cooperative_groups.h>
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename T, typename IdxT, int N_WRITES>
+__global__ void arange(T* out, IdxT size, T start, T step) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_WRITES > size) {
+    for (IdxT i = index * N_WRITES; i < size; ++i) {
+      out[i] = start + i * step;
+    }
+  } else {
+    AlignedVector<T, N_WRITES> out_vec;
+#pragma unroll
+    for (int i = 0; i < N_WRITES; ++i) {
+      out_vec[i] = start + (index * N_WRITES + i) * step;
+    }
+
+    store_vector<N_WRITES>(out, index, out_vec);
+  }
+}
+
+} // namespace cu
+
+void Arange::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Arange::eval_gpu");
+  if (out.size() == 0) {
+    return;
+  }
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& encoder = cu::get_command_encoder(stream());
+  encoder.set_output_array(out);
+
+  dispatch_int_float_types(out.dtype(), "Arange", [&](auto type_tag) {
+    using CTYPE = MLX_GET_TYPE(type_tag);
+    using OutType = cuda_type_t<CTYPE>;
+    constexpr int N_WRITES = 16 / sizeof(OutType);
+    dispatch_bool(out.data_size() > INT32_MAX, [&](auto large) {
+      using IdxT = std::conditional_t<large(), int64_t, int32_t>;
+      auto [num_blocks, block_dims] = get_launch_args(out, large(), N_WRITES);
+      encoder.add_kernel_node(
+          cu::arange<OutType, IdxT, N_WRITES>,
+          num_blocks,
+          block_dims,
+          0,
+          out.data<OutType>(),
+          out.data_size(),
+          static_cast<CTYPE>(start_),
+          static_cast<CTYPE>(start_ + step_) - static_cast<CTYPE>(start_));
+    });
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/arg_reduce.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/arg_reduce.cu
new file mode 100644
index 0000000000000000000000000000000000000000..21cd677a89193e7b43fd9de15eb816fee5f5c9e2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/arg_reduce.cu
@@ -0,0 +1,188 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/device/fp16_math.cuh"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+#include <cooperative_groups.h>
+#include <nvtx3/nvtx3.hpp>
+#include <cub/block/block_load.cuh>
+#include <cub/block/block_reduce.cuh>
+
+#include <cassert>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename T>
+struct IndexValPair {
+  uint32_t index;
+  T val;
+};
+
+template <typename T>
+struct ArgMin {
+  constexpr __device__ T init() {
+    return Limits<T>::max();
+  }
+
+  __device__ IndexValPair<T> operator()(
+      const IndexValPair<T>& best,
+      const IndexValPair<T>& current) {
+    if (best.val > current.val ||
+        (best.val == current.val && best.index > current.index)) {
+      return current;
+    } else {
+      return best;
+    }
+  }
+
+  template <int N>
+  __device__ IndexValPair<T> reduce_many(
+      IndexValPair<T> best,
+      const AlignedVector<T, N>& vals,
+      uint32_t offset) {
+#pragma unroll
+    for (int i = 0; i < N; i++) {
+      if (vals[i] < best.val) {
+        best.val = vals[i];
+        best.index = offset + i;
+      }
+    }
+    return best;
+  }
+};
+
+template <typename T>
+struct ArgMax {
+  constexpr __device__ T init() {
+    return Limits<T>::min();
+  }
+
+  __device__ IndexValPair<T> operator()(
+      const IndexValPair<T>& best,
+      const IndexValPair<T>& current) {
+    if (best.val < current.val ||
+        (best.val == current.val && best.index > current.index)) {
+      return current;
+    } else {
+      return best;
+    }
+  }
+
+  template <int N>
+  __device__ IndexValPair<T> reduce_many(
+      IndexValPair<T> best,
+      const AlignedVector<T, N>& vals,
+      uint32_t offset) {
+#pragma unroll
+    for (int i = 0; i < N; i++) {
+      if (vals[i] > best.val) {
+        best.val = vals[i];
+        best.index = offset + i;
+      }
+    }
+    return best;
+  }
+};
+
+template <typename T, typename Op, int BLOCK_DIM, int N_READS = 4>
+__global__ void arg_reduce_general(
+    const T* in,
+    uint32_t* out,
+    size_t size,
+    const __grid_constant__ Shape shape,
+    const __grid_constant__ Strides in_strides,
+    const __grid_constant__ Strides out_strides,
+    int32_t ndim,
+    int64_t axis_stride,
+    int32_t axis_size) {
+  auto block = cg::this_thread_block();
+
+  int64_t index = cg::this_grid().block_rank();
+  if (index >= size) {
+    return;
+  }
+
+  int64_t in_idx = elem_to_loc(index, shape.data(), in_strides.data(), ndim);
+  int64_t out_idx = elem_to_loc(index, shape.data(), out_strides.data(), ndim);
+  in += in_idx;
+
+  Op op;
+  T init = op.init();
+  IndexValPair<T> best{0, init};
+
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); ++r) {
+    auto tid = r * BLOCK_DIM + block.thread_index().x;
+    auto vals = load_vector<N_READS>(in, tid, axis_size, axis_stride, init);
+    best = op.reduce_many(best, vals, tid * N_READS);
+  }
+
+  typedef cub::BlockReduce<IndexValPair<T>, BLOCK_DIM> BlockReduceT;
+  __shared__ typename BlockReduceT::TempStorage temp;
+
+  best = BlockReduceT(temp).Reduce(best, op);
+
+  if (block.thread_rank() == 0) {
+    out[out_idx] = best.index;
+  }
+}
+
+} // namespace cu
+
+void ArgReduce::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("ArgReduce::eval_gpu");
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  out.set_data(allocator::malloc(out.nbytes()));
+  auto& s = stream();
+
+  // Prepare the shapes, strides and axis arguments.
+  Shape shape = remove_index(in.shape(), axis_);
+  Strides in_strides = remove_index(in.strides(), axis_);
+  Strides out_strides = out.ndim() == in.ndim()
+      ? remove_index(out.strides(), axis_)
+      : out.strides();
+  int64_t axis_stride = in.strides()[axis_];
+  int32_t axis_size = in.shape()[axis_];
+  int32_t ndim = shape.size();
+
+  // ArgReduce.
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  dispatch_real_types(in.dtype(), "ArgReduce", [&](auto type_tag) {
+    using T = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+    constexpr uint32_t N_READS = 4;
+    dispatch_block_dim(cuda::ceil_div(axis_size, N_READS), [&](auto block_dim) {
+      dim3 num_blocks = get_2d_grid_dims(out.shape(), out.strides());
+      auto kernel =
+          cu::arg_reduce_general<T, cu::ArgMax<T>, block_dim(), N_READS>;
+      if (reduce_type_ == ArgReduce::ArgMin) {
+        kernel = cu::arg_reduce_general<T, cu::ArgMin<T>, block_dim(), N_READS>;
+      }
+      encoder.add_kernel_node(
+          kernel,
+          num_blocks,
+          block_dim(),
+          0,
+          in.data<T>(),
+          out.data<uint32_t>(),
+          out.size(),
+          const_param(shape),
+          const_param(in_strides),
+          const_param(out_strides),
+          ndim,
+          axis_stride,
+          axis_size);
+    });
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/bin2h.cmake b/ml-stable-diffusion/mlx/mlx/backend/cuda/bin2h.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b791d3d1a63ac651a9ab8c8012c82ce830867244
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/bin2h.cmake
@@ -0,0 +1,150 @@
+# Based on: https://github.com/sivachandran/cmake-bin2h
+#
+# Copyright 2020 Sivachandran Paramasivam
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+include(CMakeParseArguments)
+
+# Function to wrap a given string into multiple lines at the given column
+# position.
+#
+# Parameters:
+#
+# * VARIABLE - The name of the CMake variable holding the string.
+# * AT_COLUMN - The column position at which string will be wrapped.
+function(WRAP_STRING)
+  set(oneValueArgs VARIABLE AT_COLUMN)
+  cmake_parse_arguments(WRAP_STRING "${options}" "${oneValueArgs}" "" ${ARGN})
+
+  string(LENGTH ${${WRAP_STRING_VARIABLE}} stringLength)
+  math(EXPR offset "0")
+
+  while(stringLength GREATER 0)
+    if(stringLength GREATER ${WRAP_STRING_AT_COLUMN})
+      math(EXPR length "${WRAP_STRING_AT_COLUMN}")
+    else()
+      math(EXPR length "${stringLength}")
+    endif()
+
+    string(SUBSTRING ${${WRAP_STRING_VARIABLE}} ${offset} ${length} line)
+    set(lines "${lines}\n ${line}")
+
+    math(EXPR stringLength "${stringLength} - ${length}")
+    math(EXPR offset "${offset} + ${length}")
+  endwhile()
+
+  set(${WRAP_STRING_VARIABLE}
+      "${lines}"
+      PARENT_SCOPE)
+endfunction()
+
+# Function to embed contents of a file as byte array in C/C++ header file(.h).
+# The header file will contain a byte array and integer variable holding the
+# size of the array.
+#
+# Parameters:
+#
+# * SOURCE_FILES - The paths of source files whose contents will be embedded in
+#   the header file.
+# * VARIABLE_NAME - The name of the variable for the byte array. The string
+#   "_SIZE" will be append to this name and will be used a variable name for
+#   size variable.
+# * HEADER_FILE - The path of header file.
+# * APPEND - If specified appends to the header file instead of overwriting it
+# * HEADER_NAMESPACE - The namespace, where the array should be located in.
+# * NULL_TERMINATE - If specified a null byte(zero) will be append to the byte
+#   array.
+#
+# Usage:
+#
+# bin2h(SOURCE_FILE "Logo.png" HEADER_FILE "Logo.h" VARIABLE_NAME "LOGO_PNG")
+function(BIN2H)
+  set(options APPEND NULL_TERMINATE)
+  set(oneValueArgs VARIABLE_NAME HEADER_FILE HEADER_NAMESPACE)
+  set(multiValueArgs SOURCE_FILES)
+  cmake_parse_arguments(BIN2H "${options}" "${oneValueArgs}"
+                        "${multiValueArgs}" ${ARGN})
+
+  set(arrayDefinition "")
+  foreach(SOURCE_FILE IN LISTS BIN2H_SOURCE_FILES)
+    # get filename without extension
+    get_filename_component(FILE_NAME_WE ${SOURCE_FILE} NAME_WE)
+    # convert the filename to a valid C identifier
+    string(MAKE_C_IDENTIFIER "${FILE_NAME_WE}" VALID_FILE_NAME)
+
+    # reads source file contents as hex string
+    file(READ ${SOURCE_FILE} hexString HEX)
+
+    # append null
+    if(BIN2H_NULL_TERMINATE)
+      string(APPEND hexString "00")
+    endif()
+
+    # wraps the hex string into multiple lines
+    wrap_string(VARIABLE hexString AT_COLUMN 24)
+
+    # strip the © in source code
+    string(REGEX REPLACE "c2a9" "2020" arrayValues ${hexString})
+
+    string(REGEX REPLACE "([0-9a-f][0-9a-f])" " 0x\\1," arrayValues
+                         ${arrayValues})
+
+    # make a full variable name for the array
+    set(FULL_VARIABLE_NAME "${BIN2H_VARIABLE_NAME}_${VALID_FILE_NAME}")
+
+    # declares byte array and the length variables
+    string(APPEND arrayDefinition
+           "constexpr char ${FULL_VARIABLE_NAME}[] = {${arrayValues}\n};\n\n")
+  endforeach()
+
+  # add namespace wrapper if defined
+  if(DEFINED BIN2H_HEADER_NAMESPACE)
+    set(namespaceStart "namespace ${BIN2H_HEADER_NAMESPACE} {")
+    set(namespaceEnd "} // namespace ${BIN2H_HEADER_NAMESPACE}")
+    set(declarations "${namespaceStart}\n\n${arrayDefinition}${namespaceEnd}\n")
+  endif()
+
+  set(arrayIncludes "#pragma once")
+  string(PREPEND declarations "${arrayIncludes}\n\n")
+
+  if(BIN2H_APPEND)
+    file(APPEND ${BIN2H_HEADER_FILE} "${declarations}")
+  else()
+    file(WRITE ${BIN2H_HEADER_FILE} "${declarations}")
+  endif()
+endfunction()
+
+# ----------------------------- CLI args -----------------------------
+
+string(REPLACE ":" ";" MLX_JIT_SOURCES_LIST ${MLX_JIT_SOURCES})
+foreach(source ${MLX_JIT_SOURCES_LIST})
+  list(APPEND MLX_JIT_SOURCES_ABS "${MLX_SOURCE_ROOT}/${source}")
+endforeach()
+
+bin2h(
+  SOURCE_FILES
+  ${MLX_JIT_SOURCES_ABS}
+  NULL_TERMINATE
+  VARIABLE_NAME
+  "jit_source"
+  HEADER_NAMESPACE
+  "mlx::core"
+  HEADER_FILE
+  "${CMAKE_CURRENT_BINARY_DIR}/gen/cuda_jit_sources.h")
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..bda289de701a07c09ec6b067d9b4998d2209da97
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/CMakeLists.txt
@@ -0,0 +1,21 @@
+target_sources(
+  mlx
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/add.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/arctan2.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/bitwise_binary.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/divide.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/equal.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/greater.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/greater_equal.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/less.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/less_equal.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/logical_and.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/logical_or.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/log_add_exp.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/minimum.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/maximum.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/multiply.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/power.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/remainder.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/not_equal.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/subtract.cu)
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/add.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/add.cu
new file mode 100644
index 0000000000000000000000000000000000000000..87dfd7e701b225e0b6168a0c359765bc607afa83
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/add.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(Add)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/arctan2.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/arctan2.cu
new file mode 100644
index 0000000000000000000000000000000000000000..2fd7e392280662780eafea6322a9ccc374aa44a8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/arctan2.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(ArcTan2)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/binary.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/binary.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..20bb199ec460f68cfa57f1fa3da19bc8782e5805
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/binary.cuh
@@ -0,0 +1,379 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/binary.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/device/binary_ops.cuh"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+#include <cooperative_groups.h>
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void binary_ss(const In* a, const In* b, Out* out, IdxT size) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_READS > size) {
+    for (int i = index * N_READS; i < size; ++i) {
+      out[i] = Op{}(a[0], b[0]);
+    }
+  } else {
+    AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      out_vec[i] = Op{}(a[0], b[0]);
+    }
+
+    store_vector<N_READS>(out, index, out_vec);
+  }
+}
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void binary_sv(const In* a, const In* b, Out* out, IdxT size) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_READS > size) {
+    for (IdxT i = index * N_READS; i < size; ++i) {
+      out[i] = Op{}(a[0], b[i]);
+    }
+  } else {
+    auto b_vec = load_vector<N_READS>(b, index);
+
+    AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      out_vec[i] = Op{}(a[0], b_vec[i]);
+    }
+
+    store_vector<N_READS>(out, index, out_vec);
+  }
+}
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void binary_vs(const In* a, const In* b, Out* out, IdxT size) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_READS > size) {
+    for (IdxT i = index * N_READS; i < size; ++i) {
+      out[i] = Op{}(a[i], b[0]);
+    }
+  } else {
+    auto a_vec = load_vector<N_READS>(a, index);
+
+    AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      out_vec[i] = Op{}(a_vec[i], b[0]);
+    }
+
+    store_vector<N_READS>(out, index, out_vec);
+  }
+}
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void binary_vv(const In* a, const In* b, Out* out, IdxT size) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_READS > size) {
+    for (IdxT i = index * N_READS; i < size; ++i) {
+      out[i] = Op{}(a[i], b[i]);
+    }
+  } else {
+    auto a_vec = load_vector<N_READS>(a, index);
+    auto b_vec = load_vector<N_READS>(b, index);
+
+    AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      out_vec[i] = Op{}(a_vec[i], b_vec[i]);
+    }
+
+    store_vector<N_READS>(out, index, out_vec);
+  }
+}
+
+template <
+    typename Op,
+    typename In,
+    typename Out,
+    typename IdxT,
+    int NDIM,
+    int N_READS>
+__global__ void binary_g_nd(
+    const In* a,
+    const In* b,
+    Out* out,
+    IdxT size_rest,
+    const __grid_constant__ cuda::std::array<int32_t, NDIM> shape,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> a_strides,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> b_strides) {
+  auto block = cg::this_thread_block();
+  auto grid = cg::this_grid();
+  IdxT index_rest =
+      grid.block_index().y * block.dim_threads().y + block.thread_index().y;
+  if (index_rest >= size_rest) {
+    return;
+  }
+
+  auto shape_x = shape[NDIM - 1];
+  auto a_stride_x = a_strides[NDIM - 1];
+  auto b_stride_x = b_strides[NDIM - 1];
+  IdxT index_x =
+      grid.block_index().x * block.dim_threads().x + block.thread_index().x;
+  auto [a_idx, b_idx] = elem_to_loc_nd<NDIM>(
+      index_rest * shape_x, shape.data(), a_strides.data(), b_strides.data());
+  auto a_vec =
+      load_vector<N_READS>(a + a_idx, index_x, shape_x, a_stride_x, In(0));
+  auto b_vec =
+      load_vector<N_READS>(b + b_idx, index_x, shape_x, b_stride_x, In(0));
+
+  AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+  for (int i = 0; i < N_READS; ++i) {
+    out_vec[i] = Op{}(a_vec[i], b_vec[i]);
+  }
+  store_vector(out + shape_x * index_rest, index_x, out_vec, shape_x);
+}
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void binary_g(
+    const In* a,
+    const In* b,
+    Out* out,
+    IdxT size_rest,
+    const __grid_constant__ Shape shape,
+    const __grid_constant__ Strides a_strides,
+    const __grid_constant__ Strides b_strides,
+    int ndim) {
+  auto block = cg::this_thread_block();
+  auto grid = cg::this_grid();
+  IdxT index_rest =
+      grid.block_index().y * block.dim_threads().y + block.thread_index().y;
+  if (index_rest >= size_rest) {
+    return;
+  }
+
+  auto shape_x = shape[ndim - 1];
+  auto a_stride_x = a_strides[ndim - 1];
+  auto b_stride_x = b_strides[ndim - 1];
+  IdxT index_x =
+      grid.block_index().x * block.dim_threads().x + block.thread_index().x;
+  auto [a_idx, b_idx] = elem_to_loc(
+      index_rest * shape_x,
+      shape.data(),
+      a_strides.data(),
+      b_strides.data(),
+      ndim);
+  auto a_vec =
+      load_vector<N_READS>(a + a_idx, index_x, shape_x, a_stride_x, In(0));
+  auto b_vec =
+      load_vector<N_READS>(b + b_idx, index_x, shape_x, b_stride_x, In(0));
+
+  AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+  for (int i = 0; i < N_READS; ++i) {
+    out_vec[i] = Op{}(a_vec[i], b_vec[i]);
+  }
+  store_vector(out + shape_x * index_rest, index_x, out_vec, shape_x);
+}
+
+template <typename Op, typename In, typename Out>
+constexpr bool supports_binary_op() {
+  if (std::is_same_v<Op, Add> || std::is_same_v<Op, Divide> ||
+      std::is_same_v<Op, Maximum> || std::is_same_v<Op, Minimum> ||
+      std::is_same_v<Op, Multiply> || std::is_same_v<Op, Subtract> ||
+      std::is_same_v<Op, Power> || std::is_same_v<Op, Remainder>) {
+    return std::is_same_v<In, Out>;
+  }
+  if (std::is_same_v<Op, Equal> || std::is_same_v<Op, Greater> ||
+      std::is_same_v<Op, GreaterEqual> || std::is_same_v<Op, Less> ||
+      std::is_same_v<Op, LessEqual> || std::is_same_v<Op, NotEqual>) {
+    return std::is_same_v<Out, bool>;
+  }
+  if (std::is_same_v<Op, LogicalAnd> || std::is_same_v<Op, LogicalOr>) {
+    return std::is_same_v<Out, bool> && std::is_same_v<In, bool>;
+  }
+  if (std::is_same_v<Op, NaNEqual>) {
+    return std::is_same_v<Out, bool> && is_inexact_v<In>;
+  }
+  if (std::is_same_v<Op, LogAddExp>) {
+    return std::is_same_v<In, Out> && is_inexact_v<In>;
+  }
+  if (std::is_same_v<Op, ArcTan2>) {
+    return std::is_same_v<In, Out> && is_floating_v<In>;
+  }
+  if (std::is_same_v<Op, BitwiseAnd> || std::is_same_v<Op, BitwiseOr> ||
+      std::is_same_v<Op, BitwiseXor>) {
+    return std::is_same_v<In, Out> && std::is_integral_v<In>;
+  }
+  if (std::is_same_v<Op, LeftShift> || std::is_same_v<Op, RightShift>) {
+    return std::is_same_v<In, Out> && std::is_integral_v<In> &&
+        !std::is_same_v<In, bool>;
+  }
+  return false;
+}
+
+} // namespace cu
+
+template <typename Op>
+void binary_op_gpu_inplace(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s) {
+  assert(inputs.size() > 1);
+  const auto& a = inputs[0];
+  const auto& b = inputs[1];
+  if (out.size() == 0) {
+    return;
+  }
+
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_output_array(out);
+  dispatch_all_types(a.dtype(), [&](auto in_type_tag) {
+    dispatch_all_types(out.dtype(), [&](auto out_type_tag) {
+      using CTYPE_IN = MLX_GET_TYPE(in_type_tag);
+      using CTYPE_OUT = MLX_GET_TYPE(out_type_tag);
+      if constexpr (cu::supports_binary_op<Op, CTYPE_IN, CTYPE_OUT>()) {
+        using InType = cuda_type_t<CTYPE_IN>;
+        using OutType = cuda_type_t<CTYPE_OUT>;
+        auto bopt = get_binary_op_type(a, b);
+        if (bopt == BinaryOpType::General) {
+          dispatch_bool(
+              a.data_size() > INT32_MAX || b.data_size() > INT32_MAX ||
+                  out.data_size() > INT32_MAX,
+              [&](auto large) {
+                using IdxT = std::conditional_t<large(), int64_t, int32_t>;
+                Shape shape;
+                std::vector<Strides> strides;
+                std::tie(shape, strides) = collapse_contiguous_dims(a, b, out);
+                auto& a_strides = strides[0];
+                auto& b_strides = strides[1];
+                int ndim = shape.size();
+                int work_per_thread = 1;
+                auto dim0 = ndim > 0 ? shape.back() : 1;
+                auto rest = out.size() / dim0;
+                if (dim0 >= 4) {
+                  work_per_thread = 4;
+                }
+                dim0 = (dim0 + work_per_thread - 1) / work_per_thread;
+                auto block_dims = get_block_dims(dim0, rest, 1);
+                uint32_t num_blocks_x = cuda::ceil_div(dim0, block_dims.x);
+                uint32_t num_blocks_y = cuda::ceil_div(rest, block_dims.y);
+                if (ndim <= 3) {
+                  dispatch_1_2_3(ndim, [&](auto dims_constant) {
+                    auto kernel = cu::binary_g_nd<
+                        Op,
+                        InType,
+                        OutType,
+                        IdxT,
+                        dims_constant(),
+                        1>;
+                    if (work_per_thread == 4) {
+                      kernel = cu::binary_g_nd<
+                          Op,
+                          InType,
+                          OutType,
+                          IdxT,
+                          dims_constant(),
+                          4>;
+                    }
+                    encoder.add_kernel_node(
+                        kernel,
+                        {num_blocks_x, num_blocks_y},
+                        block_dims,
+                        0,
+                        a.data<InType>(),
+                        b.data<InType>(),
+                        out.data<OutType>(),
+                        rest,
+                        const_param<dims_constant()>(shape),
+                        const_param<dims_constant()>(a_strides),
+                        const_param<dims_constant()>(b_strides));
+                  });
+                } else {
+                  auto kernel = cu::binary_g<Op, InType, OutType, IdxT, 1>;
+                  if (work_per_thread == 4) {
+                    kernel = cu::binary_g<Op, InType, OutType, IdxT, 4>;
+                  }
+                  encoder.add_kernel_node(
+                      kernel,
+                      {num_blocks_x, num_blocks_y},
+                      block_dims,
+                      0,
+                      a.data<InType>(),
+                      b.data<InType>(),
+                      out.data<OutType>(),
+                      rest,
+                      const_param(shape),
+                      const_param(a_strides),
+                      const_param(b_strides),
+                      ndim);
+                }
+              });
+        } else {
+          dispatch_bool(out.data_size() > UINT32_MAX, [&](auto large) {
+            using IdxT = std::conditional_t<large(), int64_t, uint32_t>;
+            constexpr int N_READS = 16 / sizeof(InType);
+            auto kernel = cu::binary_ss<Op, InType, OutType, IdxT, N_READS>;
+            if (bopt == BinaryOpType::ScalarVector) {
+              kernel = cu::binary_sv<Op, InType, OutType, IdxT, N_READS>;
+            } else if (bopt == BinaryOpType::VectorScalar) {
+              kernel = cu::binary_vs<Op, InType, OutType, IdxT, N_READS>;
+            } else if (bopt == BinaryOpType::VectorVector) {
+              kernel = cu::binary_vv<Op, InType, OutType, IdxT, N_READS>;
+            }
+            auto [num_blocks, block_dims] = get_launch_args(
+                out.data_size(), out.shape(), out.strides(), large(), N_READS);
+            encoder.add_kernel_node(
+                kernel,
+                num_blocks,
+                block_dims,
+                0,
+                a.data<InType>(),
+                b.data<InType>(),
+                out.data<OutType>(),
+                out.data_size());
+          });
+        }
+      } else {
+        throw std::runtime_error(fmt::format(
+            "Can not do binary op {} on inputs of {} with result of {}.",
+            op,
+            dtype_to_string(a.dtype()),
+            dtype_to_string(out.dtype())));
+      }
+    });
+  });
+}
+
+template <typename Op>
+void binary_op_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s) {
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  auto bopt = get_binary_op_type(a, b);
+  set_binary_op_output_data(a, b, out, bopt);
+  binary_op_gpu_inplace<Op>(inputs, out, op, s);
+}
+
+#define BINARY_GPU(func)                                              \
+  void func::eval_gpu(const std::vector<array>& inputs, array& out) { \
+    nvtx3::scoped_range r(#func "::eval_gpu");                        \
+    auto& s = out.primitive().stream();                               \
+    binary_op_gpu<cu::func>(inputs, out, name(), s);                  \
+  }
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/bitwise_binary.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/bitwise_binary.cu
new file mode 100644
index 0000000000000000000000000000000000000000..8025a3bd1c5d43addf9890bb945ce3e856183e5a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/bitwise_binary.cu
@@ -0,0 +1,27 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+void BitwiseBinary::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("BitwiseBinary::eval_gpu");
+  auto& s = out.primitive().stream();
+  switch (op_) {
+    case BitwiseBinary::And:
+      binary_op_gpu<cu::BitwiseAnd>(inputs, out, name(), s);
+      break;
+    case BitwiseBinary::Or:
+      binary_op_gpu<cu::BitwiseOr>(inputs, out, name(), s);
+      break;
+    case BitwiseBinary::Xor:
+      binary_op_gpu<cu::BitwiseXor>(inputs, out, name(), s);
+      break;
+    case BitwiseBinary::LeftShift:
+      binary_op_gpu<cu::LeftShift>(inputs, out, name(), s);
+      break;
+    case BitwiseBinary::RightShift:
+      binary_op_gpu<cu::RightShift>(inputs, out, name(), s);
+      break;
+  }
+}
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/divide.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/divide.cu
new file mode 100644
index 0000000000000000000000000000000000000000..fcf3dc77e9d44f4cd84ba36a9bba2bd2e9921b61
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/divide.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(Divide)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/equal.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/equal.cu
new file mode 100644
index 0000000000000000000000000000000000000000..559b3e8edf0a9fea68e5f8a7844f9c165e0110c0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/equal.cu
@@ -0,0 +1,15 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+void Equal::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Equal::eval_gpu");
+  auto& s = out.primitive().stream();
+  if (equal_nan_) {
+    binary_op_gpu<cu::NaNEqual>(inputs, out, name(), s);
+  } else {
+    binary_op_gpu<cu::Equal>(inputs, out, name(), s);
+  }
+}
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/greater.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/greater.cu
new file mode 100644
index 0000000000000000000000000000000000000000..c9820206b70dd9a8a312d477d5d6493fbbaadf45
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/greater.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(Greater)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/greater_equal.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/greater_equal.cu
new file mode 100644
index 0000000000000000000000000000000000000000..4666fb4a994bedb03a2e4ca2ab743b12e38ce55b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/greater_equal.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(GreaterEqual)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/less.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/less.cu
new file mode 100644
index 0000000000000000000000000000000000000000..a2053fa8b56024592b6509744df3d5efede10461
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/less.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(Less)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/less_equal.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/less_equal.cu
new file mode 100644
index 0000000000000000000000000000000000000000..7f9bc5161419c1401464c69c7a8eaee03f33a5b4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/less_equal.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(LessEqual)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/log_add_exp.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/log_add_exp.cu
new file mode 100644
index 0000000000000000000000000000000000000000..17614f862045440687e533e6a299374a47384db4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/log_add_exp.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(LogAddExp)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/logical_and.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/logical_and.cu
new file mode 100644
index 0000000000000000000000000000000000000000..6bbeb1a4c9b71012c67c1b444984f589ebd8faf2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/logical_and.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(LogicalAnd)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/logical_or.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/logical_or.cu
new file mode 100644
index 0000000000000000000000000000000000000000..63afdb98caed66d137a085f87f15776e03ac9487
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/logical_or.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(LogicalOr)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/maximum.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/maximum.cu
new file mode 100644
index 0000000000000000000000000000000000000000..4f6cb6e0bde9e2b049f62779b9fc403c070c7df5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/maximum.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(Maximum)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/minimum.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/minimum.cu
new file mode 100644
index 0000000000000000000000000000000000000000..ec4c1abb01d1f3157fa0e4af9730fb5a65487c3d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/minimum.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(Minimum)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/multiply.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/multiply.cu
new file mode 100644
index 0000000000000000000000000000000000000000..bfc15fcaa9c1d3bf2bffabb54c44c088d9776c88
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/multiply.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(Multiply)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/not_equal.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/not_equal.cu
new file mode 100644
index 0000000000000000000000000000000000000000..49f05c90a216d9013f7200b1ee0e8cbdb1063f59
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/not_equal.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(NotEqual)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/power.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/power.cu
new file mode 100644
index 0000000000000000000000000000000000000000..cacdc75c48632612e25d015922a739b9f077008e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/power.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(Power)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/remainder.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/remainder.cu
new file mode 100644
index 0000000000000000000000000000000000000000..a55006ba0ae031cbab4b4180d2c3964ce7d8b00c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/remainder.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(Remainder)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/subtract.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/subtract.cu
new file mode 100644
index 0000000000000000000000000000000000000000..37f3874ccb11d89feeb7b2079bd726c6d3464cb9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary/subtract.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/binary/binary.cuh"
+
+namespace mlx::core {
+BINARY_GPU(Subtract)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/binary_two.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary_two.cu
new file mode 100644
index 0000000000000000000000000000000000000000..cd0fe2c46e3dc67a44c0f109bd74a74e71dec3ed
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/binary_two.cu
@@ -0,0 +1,409 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/binary.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/device/binary_ops.cuh"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+#include <cooperative_groups.h>
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void
+binary_two_ss(const In* a, const In* b, Out* out_a, Out* out_b, IdxT size) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_READS > size) {
+    for (IdxT i = index * N_READS; i < size; ++i) {
+      auto out = Op{}(a[0], b[0]);
+      out_a[i] = out[0];
+      out_b[i] = out[1];
+    }
+  } else {
+    AlignedVector<Out, N_READS> out_a_vec;
+    AlignedVector<Out, N_READS> out_b_vec;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      auto out = Op{}(a[0], b[0]);
+      out_a_vec[i] = out[0];
+      out_b_vec[i] = out[1];
+    }
+
+    store_vector<N_READS>(out_a, index, out_a_vec);
+    store_vector<N_READS>(out_b, index, out_b_vec);
+  }
+}
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void
+binary_two_sv(const In* a, const In* b, Out* out_a, Out* out_b, IdxT size) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_READS > size) {
+    for (IdxT i = index * N_READS; i < size; ++i) {
+      auto out = Op{}(a[0], b[i]);
+      out_a[i] = out[0];
+      out_b[i] = out[1];
+    }
+  } else {
+    auto b_vec = load_vector<N_READS>(b, index);
+
+    AlignedVector<Out, N_READS> out_a_vec;
+    AlignedVector<Out, N_READS> out_b_vec;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      auto out = Op{}(a[0], b_vec[i]);
+      out_a_vec[i] = out[0];
+      out_b_vec[i] = out[1];
+    }
+
+    store_vector<N_READS>(out_a, index, out_a_vec);
+    store_vector<N_READS>(out_b, index, out_b_vec);
+  }
+}
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void
+binary_two_vs(const In* a, const In* b, Out* out_a, Out* out_b, IdxT size) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_READS > size) {
+    for (IdxT i = index * N_READS; i < size; ++i) {
+      auto out = Op{}(a[i], b[0]);
+      out_a[i] = out[0];
+      out_b[i] = out[1];
+    }
+  } else {
+    auto a_vec = load_vector<N_READS>(a, index);
+
+    AlignedVector<Out, N_READS> out_a_vec;
+    AlignedVector<Out, N_READS> out_b_vec;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      auto out = Op{}(a_vec[i], b[0]);
+      out_a_vec[i] = out[0];
+      out_b_vec[i] = out[1];
+    }
+
+    store_vector<N_READS>(out_a, index, out_a_vec);
+    store_vector<N_READS>(out_b, index, out_b_vec);
+  }
+}
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void
+binary_two_vv(const In* a, const In* b, Out* out_a, Out* out_b, IdxT size) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_READS > size) {
+    for (IdxT i = index * N_READS; i < size; ++i) {
+      auto out = Op{}(a[i], b[i]);
+      out_a[i] = out[0];
+      out_b[i] = out[1];
+    }
+  } else {
+    auto a_vec = load_vector<N_READS>(a, index);
+    auto b_vec = load_vector<N_READS>(b, index);
+
+    AlignedVector<Out, N_READS> out_a_vec;
+    AlignedVector<Out, N_READS> out_b_vec;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      auto out = Op{}(a_vec[i], b_vec[i]);
+      out_a_vec[i] = out[0];
+      out_b_vec[i] = out[1];
+    }
+
+    store_vector<N_READS>(out_a, index, out_a_vec);
+    store_vector<N_READS>(out_b, index, out_b_vec);
+  }
+}
+
+template <
+    typename Op,
+    typename In,
+    typename Out,
+    typename IdxT,
+    int NDIM,
+    int N_READS>
+__global__ void binary_two_g_nd(
+    const In* a,
+    const In* b,
+    Out* out_a,
+    Out* out_b,
+    IdxT size_rest,
+    const __grid_constant__ cuda::std::array<int32_t, NDIM> shape,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> a_strides,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> b_strides) {
+  auto block = cg::this_thread_block();
+  auto grid = cg::this_grid();
+  IdxT index_rest =
+      grid.block_index().y * block.dim_threads().y + block.thread_index().y;
+  if (index_rest >= size_rest) {
+    return;
+  }
+
+  auto shape_x = shape[NDIM - 1];
+  auto a_stride_x = a_strides[NDIM - 1];
+  auto b_stride_x = b_strides[NDIM - 1];
+  IdxT index_x =
+      grid.block_index().x * block.dim_threads().x + block.thread_index().x;
+  auto [a_idx, b_idx] = elem_to_loc_nd<NDIM>(
+      index_rest * shape_x, shape.data(), a_strides.data(), b_strides.data());
+  auto a_vec =
+      load_vector<N_READS>(a + a_idx, index_x, shape_x, a_stride_x, In(0));
+  auto b_vec =
+      load_vector<N_READS>(b + b_idx, index_x, shape_x, b_stride_x, In(0));
+
+  AlignedVector<Out, N_READS> out_vec_a;
+  AlignedVector<Out, N_READS> out_vec_b;
+#pragma unroll
+  for (int i = 0; i < N_READS; ++i) {
+    auto out = Op{}(a_vec[i], b_vec[i]);
+    out_vec_a[i] = out[0];
+    out_vec_b[i] = out[1];
+  }
+  store_vector(out_a + shape_x * index_rest, index_x, out_vec_a, shape_x);
+  store_vector(out_b + shape_x * index_rest, index_x, out_vec_b, shape_x);
+}
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void binary_two_g(
+    const In* a,
+    const In* b,
+    Out* out_a,
+    Out* out_b,
+    IdxT size_rest,
+    const __grid_constant__ Shape shape,
+    const __grid_constant__ Strides a_strides,
+    const __grid_constant__ Strides b_strides,
+    int ndim) {
+  auto block = cg::this_thread_block();
+  auto grid = cg::this_grid();
+  IdxT index_rest =
+      grid.block_index().y * block.dim_threads().y + block.thread_index().y;
+  if (index_rest >= size_rest) {
+    return;
+  }
+
+  auto shape_x = shape[ndim - 1];
+  auto a_stride_x = a_strides[ndim - 1];
+  auto b_stride_x = b_strides[ndim - 1];
+  IdxT index_x =
+      grid.block_index().x * block.dim_threads().x + block.thread_index().x;
+  auto [a_idx, b_idx] = elem_to_loc(
+      index_rest * shape_x,
+      shape.data(),
+      a_strides.data(),
+      b_strides.data(),
+      ndim);
+  auto a_vec =
+      load_vector<N_READS>(a + a_idx, index_x, shape_x, a_stride_x, In(0));
+  auto b_vec =
+      load_vector<N_READS>(b + b_idx, index_x, shape_x, b_stride_x, In(0));
+
+  AlignedVector<Out, N_READS> out_vec_a;
+  AlignedVector<Out, N_READS> out_vec_b;
+#pragma unroll
+  for (int i = 0; i < N_READS; ++i) {
+    auto out = Op{}(a_vec[i], b_vec[i]);
+    out_vec_a[i] = out[0];
+    out_vec_b[i] = out[1];
+  }
+  store_vector(out_a + shape_x * index_rest, index_x, out_vec_a, shape_x);
+  store_vector(out_b + shape_x * index_rest, index_x, out_vec_b, shape_x);
+}
+
+template <typename Op, typename In, typename Out>
+constexpr bool supports_binary_two_op() {
+  if (std::is_same_v<Op, DivMod>) {
+    return std::is_same_v<In, Out> &&
+        (std::is_integral_v<Out> || is_floating_v<Out>);
+  }
+  return false;
+}
+
+} // namespace cu
+
+template <typename Op>
+void binary_two_op_gpu_inplace(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs,
+    const char* op,
+    const Stream& s) {
+  assert(inputs.size() > 1);
+  const auto& a = inputs[0];
+  const auto& b = inputs[1];
+  auto& out_a = outputs[0];
+  auto& out_b = outputs[1];
+  auto bopt = get_binary_op_type(a, b);
+  set_binary_op_output_data(a, b, out_a, bopt);
+  set_binary_op_output_data(a, b, out_b, bopt);
+
+  if (out_a.size() == 0) {
+    return;
+  }
+
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_output_array(out_a);
+  encoder.set_output_array(out_b);
+  dispatch_all_types(a.dtype(), [&](auto in_type_tag) {
+    dispatch_all_types(out_a.dtype(), [&](auto out_type_tag) {
+      using CTYPE_IN = MLX_GET_TYPE(in_type_tag);
+      using CTYPE_OUT = MLX_GET_TYPE(out_type_tag);
+      if constexpr (cu::supports_binary_two_op<Op, CTYPE_IN, CTYPE_OUT>()) {
+        using InType = cuda_type_t<CTYPE_IN>;
+        using OutType = cuda_type_t<CTYPE_OUT>;
+
+        auto bopt = get_binary_op_type(a, b);
+        if (bopt == BinaryOpType::General) {
+          dispatch_bool(
+              a.data_size() > INT32_MAX || b.data_size() > INT32_MAX ||
+                  out_a.data_size() > INT32_MAX,
+              [&](auto large) {
+                using IdxT = std::conditional_t<large(), int64_t, int32_t>;
+                Shape shape;
+                std::vector<Strides> strides;
+                std::tie(shape, strides) =
+                    collapse_contiguous_dims(a, b, out_a);
+                auto& a_strides = strides[0];
+                auto& b_strides = strides[1];
+                int ndim = shape.size();
+                int work_per_thread = 1;
+                auto dim0 = ndim > 0 ? shape.back() : 1;
+                auto rest = out_a.size() / dim0;
+                if (dim0 >= 4) {
+                  work_per_thread = 4;
+                }
+                dim0 = (dim0 + work_per_thread - 1) / work_per_thread;
+                auto block_dims = get_block_dims(dim0, rest, 1);
+                uint32_t num_blocks_x = cuda::ceil_div(dim0, block_dims.x);
+                uint32_t num_blocks_y = cuda::ceil_div(rest, block_dims.y);
+
+                if (ndim <= 3) {
+                  dispatch_1_2_3(ndim, [&](auto dims_constant) {
+                    auto kernel = cu::binary_two_g_nd<
+                        Op,
+                        InType,
+                        OutType,
+                        IdxT,
+                        dims_constant(),
+                        1>;
+                    if (work_per_thread == 4) {
+                      kernel = cu::binary_two_g_nd<
+                          Op,
+                          InType,
+                          OutType,
+                          IdxT,
+                          dims_constant(),
+                          4>;
+                    }
+                    encoder.add_kernel_node(
+                        kernel,
+                        {num_blocks_x, num_blocks_y},
+                        block_dims,
+                        0,
+                        a.data<InType>(),
+                        b.data<InType>(),
+                        out_a.data<OutType>(),
+                        out_b.data<OutType>(),
+                        rest,
+                        const_param<dims_constant()>(shape),
+                        const_param<dims_constant()>(a_strides),
+                        const_param<dims_constant()>(b_strides));
+                  });
+                } else {
+                  auto kernel = cu::binary_two_g<Op, InType, OutType, IdxT, 1>;
+                  if (work_per_thread == 4) {
+                    kernel = cu::binary_two_g<Op, InType, OutType, IdxT, 4>;
+                  }
+                  encoder.add_kernel_node(
+                      kernel,
+                      {num_blocks_x, num_blocks_y},
+                      block_dims,
+                      0,
+                      a.data<InType>(),
+                      b.data<InType>(),
+                      out_a.data<OutType>(),
+                      out_b.data<OutType>(),
+                      rest,
+                      const_param(shape),
+                      const_param(a_strides),
+                      const_param(b_strides),
+                      ndim);
+                }
+              });
+        } else {
+          dispatch_bool(out_a.data_size() > UINT32_MAX, [&](auto large) {
+            using IdxT = std::conditional_t<large(), int64_t, uint32_t>;
+            constexpr int N_READS = 16 / sizeof(InType);
+            auto kernel = cu::binary_two_ss<Op, InType, OutType, IdxT, N_READS>;
+            if (bopt == BinaryOpType::ScalarVector) {
+              kernel = cu::binary_two_sv<Op, InType, OutType, IdxT, N_READS>;
+            } else if (bopt == BinaryOpType::VectorScalar) {
+              kernel = cu::binary_two_vs<Op, InType, OutType, IdxT, N_READS>;
+            } else if (bopt == BinaryOpType::VectorVector) {
+              kernel = cu::binary_two_vv<Op, InType, OutType, IdxT, N_READS>;
+            }
+            auto [num_blocks, block_dims] = get_launch_args(
+                out_a.data_size(),
+                out_a.shape(),
+                out_a.strides(),
+                large(),
+                N_READS);
+            encoder.add_kernel_node(
+                kernel,
+                num_blocks,
+                block_dims,
+                0,
+                a.data<InType>(),
+                b.data<InType>(),
+                out_a.data<OutType>(),
+                out_b.data<OutType>(),
+                out_a.data_size());
+          });
+        }
+      } else {
+        throw std::runtime_error(fmt::format(
+            "Can not do binary op {} on inputs of {} with result of {}.",
+            op,
+            dtype_to_string(a.dtype()),
+            dtype_to_string(out_a.dtype())));
+      }
+    });
+  });
+}
+
+template <typename Op>
+void binary_two_op_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs,
+    const char* op,
+    const Stream& s) {
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  auto bopt = get_binary_op_type(a, b);
+  set_binary_op_output_data(a, b, outputs[0], bopt);
+  set_binary_op_output_data(a, b, outputs[1], bopt);
+  binary_two_op_gpu_inplace<Op>(inputs, outputs, op, s);
+}
+
+void DivMod::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  nvtx3::scoped_range r("DivMod::eval_gpu");
+  auto& s = outputs[0].primitive().stream();
+  binary_two_op_gpu<cu::DivMod>(inputs, outputs, name(), s);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/compiled.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/compiled.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..302ca2f999ee10d96330b143c948165fba61b03c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/compiled.cpp
@@ -0,0 +1,341 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/compiled.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/jit_module.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/graph_utils.h"
+#include "mlx/primitives.h"
+
+#include <fmt/format.h>
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core {
+
+namespace cu {
+
+struct FusedKernelBuilder {
+  std::string os;
+  const std::string& kernel_name;
+  const std::vector<array>& inputs;
+  const std::vector<array>& outputs;
+  const std::vector<array>& tape;
+  const std::function<bool(size_t)>& is_constant;
+
+  void build(const char* name, bool contiguous) {
+    NodeNamer namer;
+
+    // Function parameters.
+    std::vector<std::string> params;
+    for (size_t i = 0; i < inputs.size(); ++i) {
+      if (is_constant(i)) {
+        continue;
+      }
+      const auto& x = inputs[i];
+      const std::string& xname = namer.get_name(x);
+      params.push_back(
+          fmt::format("const {}* {}", dtype_to_cuda_type(x.dtype()), xname));
+      if (!is_scalar(x) && !contiguous) {
+        params.push_back(fmt::format(
+            "const __grid_constant__ cuda::std::array<int64_t, NDIM> {}_strides",
+            xname));
+      }
+    }
+    for (const auto& x : outputs) {
+      params.push_back(fmt::format(
+          "{}* {}", dtype_to_cuda_type(x.dtype()), namer.get_name(x)));
+    }
+    if (!contiguous) {
+      params.push_back(
+          "const __grid_constant__ cuda::std::array<int32_t, NDIM> shape");
+    }
+    params.push_back("IdxT size");
+
+    // Build function signature.
+    if (contiguous) {
+      os += "template <typename IdxT = uint32_t, int work_per_thread = 1>\n";
+    } else {
+      os +=
+          "template <int NDIM, typename IdxT = uint32_t, int work_per_thread = 1>\n";
+    }
+    os += fmt::format("__global__ void {}(\n", kernel_name + name);
+    for (size_t i = 0; i < params.size(); ++i) {
+      os += "    ";
+      os += params[i];
+      if (i != params.size() - 1) {
+        os += ",\n";
+      }
+    }
+    os += ") {\n";
+
+    // Index. For non contiguous kernels we create a separate index
+    // variable per variable otherwise everyone uses `index`.
+    os +=
+        "  IdxT index = cg::this_grid().thread_rank() * work_per_thread;\n"
+        "  if (index >= size) {\n"
+        "    return;\n"
+        "  }\n";
+    if (!contiguous) {
+      for (size_t i = 0; i < inputs.size(); ++i) {
+        const auto& x = inputs[i];
+        const std::string& xname = namer.get_name(x);
+        if (is_scalar(x) || is_constant(i)) {
+          continue;
+        }
+        os += "  IdxT " + xname + "_idx = 0;\n";
+      }
+      os += "  {\n";
+      os += "    IdxT loc = index;\n";
+      os +=
+          "    #pragma unroll\n"
+          "    for (int i = NDIM - 1; i >= 0; i--) {\n";
+      for (size_t i = 0; i < inputs.size(); ++i) {
+        const auto& x = inputs[i];
+        const std::string& xname = namer.get_name(x);
+        if (is_scalar(x) || is_constant(i)) {
+          continue;
+        }
+        os += "      " + xname + "_idx += (loc \% shape[i]) * IdxT(" + xname +
+            "_strides[i]);\n";
+      }
+      os +=
+          "      loc /= shape[i];\n"
+          "    }\n"
+          "  }\n";
+    }
+
+    // Vectorized read loop
+    if (contiguous) {
+      for (size_t i = 0; i < inputs.size(); ++i) {
+        const auto& x = inputs[i];
+        if (is_scalar(x) || is_constant(i)) {
+          continue;
+        }
+        const std::string& xname = namer.get_name(x);
+        std::string type = dtype_to_cuda_type(x.dtype());
+        os += fmt::format(
+            "  auto vec_{0} = load_vector<work_per_thread, {1}>({0} + index, 0, size - index, 0);\n",
+            xname,
+            type);
+      }
+    }
+
+    // Create some space for the outputs
+    for (const auto& x : outputs) {
+      const std::string& xname = namer.get_name(x);
+      std::string type = dtype_to_cuda_type(x.dtype());
+      os += fmt::format(
+          "  AlignedVector<{}, work_per_thread> vec_{};\n", type, xname);
+    }
+
+    // Work loop
+    if (!contiguous) {
+      os +=
+          "\n"
+          "  for (int i = 0; i < work_per_thread && index < size; i++) {\n";
+    } else {
+      os +=
+          "\n"
+          "  #pragma unroll\n"
+          "  for (int i = 0; i < work_per_thread; i++) {\n";
+    }
+
+    // Read inputs.
+    for (size_t i = 0; i < inputs.size(); ++i) {
+      const auto& x = inputs[i];
+      const std::string& xname = namer.get_name(x);
+      std::string type = dtype_to_cuda_type(x.dtype());
+      std::string value;
+      if (is_constant(i)) {
+        std::ostringstream ss;
+        print_constant(ss, x);
+        value = fmt::format("static_cast<{}>({})", type, ss.str());
+      } else if (is_scalar(x)) {
+        value = fmt::format("{}[0]", xname);
+      } else if (contiguous) {
+        value = fmt::format("vec_{}[i]", xname);
+      } else {
+        value = fmt::format("{}[{}_idx]", xname, xname);
+      }
+      os += fmt::format("    {} tmp_{} = {};\n", type, xname, value);
+    }
+
+    // Write tape.
+    for (const auto& x : tape) {
+      const std::string& xname = namer.get_name(x);
+      std::string type = dtype_to_cuda_type(x.dtype());
+      std::string value;
+      if (is_static_cast(x.primitive())) {
+        value = fmt::format(
+            "static_cast<{}>(tmp_{})", type, namer.get_name(x.inputs()[0]));
+      } else {
+        value = x.primitive().name();
+        value += "{}(";
+        for (size_t i = 0; i < x.inputs().size() - 1; ++i) {
+          value += fmt::format("tmp_{}, ", namer.get_name(x.inputs()[i]));
+        }
+        value += fmt::format("tmp_{})", namer.get_name(x.inputs().back()));
+      }
+      os += fmt::format("    {} tmp_{} = {};\n", type, xname, value);
+    }
+
+    // Write output.
+    for (const auto& x : outputs) {
+      os += fmt::format("    vec_{0}[i] = tmp_{0};\n", namer.get_name(x));
+    }
+
+    // End of work loop
+    if (!contiguous) {
+      os += "\n";
+      for (size_t i = 0; i < inputs.size(); ++i) {
+        const auto& x = inputs[i];
+        const std::string& xname = namer.get_name(x);
+        if (is_scalar(x) || is_constant(i)) {
+          continue;
+        }
+        os += fmt::format("    {0}_idx += {0}_strides[NDIM - 1];\n", xname);
+      }
+    }
+    os += "  }\n";
+
+    // Store the output to global memory
+    for (const auto& x : outputs) {
+      os += fmt::format(
+          "  store_vector({0} + index, 0, vec_{0}, size - index);\n",
+          namer.get_name(x));
+    }
+
+    os += "}\n";
+  }
+};
+
+} // namespace cu
+
+constexpr const char* g_jit_includes = R"(
+#include "mlx/backend/cuda/device/binary_ops.cuh"
+#include "mlx/backend/cuda/device/ternary_ops.cuh"
+#include "mlx/backend/cuda/device/unary_ops.cuh"
+#include "mlx/backend/cuda/device/utils.cuh"
+
+#include <cooperative_groups.h>
+
+#define inf cuda::std::numeric_limits<float>::infinity()
+)";
+
+void Compiled::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  nvtx3::scoped_range r("Compiled::eval_gpu");
+  auto& s = stream();
+
+  // Determine the work per thread for the vectorized reads/writes. We take it
+  // as 16 over the max itemsize for the outputs. Another heuristic could be
+  // over the max itemsize of all arrays.
+  int max_size = 1;
+  for (const auto& x : outputs) {
+    max_size = (max_size > x.itemsize()) ? max_size : x.itemsize();
+  }
+  int work_per_thread = 16 / max_size;
+
+  cu::JitModule& mod = cu::get_jit_module(s.device, lib_name(), [&]() {
+    // Build source code.
+    cu::FusedKernelBuilder builder{
+        g_jit_includes, lib_name(), inputs_, outputs_, tape_, is_constant_};
+    builder.os +=
+        "namespace mlx::core::cu {\n\n"
+        "namespace cg = cooperative_groups;\n\n";
+    builder.build("_contiguous", true);
+    builder.os += "\n";
+    builder.build("_strided", false);
+    builder.os += "\n} // namespace mlx::core::cu\n";
+    // Build kernel names.
+    std::vector<std::string> kernel_names;
+    kernel_names.push_back(fmt::format(
+        "mlx::core::cu::{}_contiguous<uint32_t, {}>",
+        lib_name(),
+        work_per_thread));
+    kernel_names.push_back(fmt::format(
+        "mlx::core::cu::{}_contiguous<int64_t, {}>",
+        lib_name(),
+        work_per_thread));
+    for (auto wpt : std::array<int, 2>{1, work_per_thread}) {
+      for (int i = 1; i <= MAX_NDIM; ++i) {
+        kernel_names.push_back(fmt::format(
+            "mlx::core::cu::{}_strided<{}, uint32_t, {}>", lib_name(), i, wpt));
+        kernel_names.push_back(fmt::format(
+            "mlx::core::cu::{}_strided<{}, int64_t, {}>", lib_name(), i, wpt));
+      }
+    }
+
+    return std::make_tuple(
+        false, std::move(builder.os), std::move(kernel_names));
+  });
+
+  // Collapse contiguous dims to route to a faster kernel if possible. Also
+  // handle all broadcasting.
+  auto [contiguous, shape, strides_vec] =
+      compiled_collapse_contiguous_dims(inputs, outputs[0], is_constant_);
+
+  // Whether to use large index.
+  bool large = compiled_use_large_index(inputs, outputs, contiguous);
+
+  cu::KernelArgs args;
+  // Put inputs.
+  int strides_index = 1;
+  for (size_t i = 0; i < inputs.size(); ++i) {
+    if (is_constant_(i)) {
+      continue;
+    }
+    const auto& x = inputs[i];
+    args.append(x);
+    if (!contiguous && !is_scalar(x)) {
+      args.append_ptr(strides_vec[strides_index++].data());
+    }
+  }
+
+  // Put outputs.
+  compiled_allocate_outputs(inputs, outputs, is_constant_, contiguous);
+  for (auto& x : outputs) {
+    args.append(x);
+  }
+
+  // Put shape and size.
+  if (!contiguous) {
+    args.append_ptr(shape.data());
+  }
+  if (large) {
+    args.append<int64_t>(outputs[0].data_size());
+  } else {
+    args.append<uint32_t>(outputs[0].data_size());
+  }
+
+  // Choose work per thread
+  if (!contiguous && shape.back() % work_per_thread != 0) {
+    work_per_thread = 1;
+  }
+
+  // Launch kernel.
+  const char* index_type = large ? "int64_t" : "uint32_t";
+  std::string kernel_name = fmt::format("mlx::core::cu::{}", lib_name());
+  if (contiguous) {
+    kernel_name +=
+        fmt::format("_contiguous<{}, {}>", index_type, work_per_thread);
+  } else {
+    kernel_name += fmt::format(
+        "_strided<{}, {}, {}>", shape.size(), index_type, work_per_thread);
+  }
+  auto& encoder = cu::get_command_encoder(s);
+  for (const auto& in : inputs) {
+    encoder.set_input_array(in);
+  }
+  for (const auto& out : outputs) {
+    encoder.set_output_array(out);
+  }
+
+  auto [kernel, max_block_dims] = mod.get_kernel_and_dims(kernel_name);
+  auto [num_blocks, block_dims] =
+      get_launch_args(outputs[0], large, work_per_thread, max_block_dims);
+  encoder.add_kernel_node(kernel, num_blocks, block_dims, 0, args.args());
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/conv.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/conv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a5bc8e41a533a499fc275c41ca3b3bd65d4144c7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/conv.cpp
@@ -0,0 +1,418 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/conv/conv.h"
+#include "mlx/backend/cuda/cudnn_utils.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/lru_cache.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/primitives.h"
+
+#include <nvtx3/nvtx3.hpp>
+
+#include <cassert>
+
+namespace mlx::core {
+
+namespace {
+
+// Alias for better readability.
+#define CONV_FORWARD CUDNN_BACKEND_OPERATION_CONVOLUTION_FORWARD_DESCRIPTOR
+#define CONV_BACKWARD_INPUT \
+  CUDNN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_DATA_DESCRIPTOR
+#define CONV_BACKWARD_WEIGHT \
+  CUDNN_BACKEND_OPERATION_CONVOLUTION_BACKWARD_FILTER_DESCRIPTOR
+
+// Custom placeholder representing fallback kernel.
+#define CONV_FALLBACK static_cast<cudnnBackendDescriptorType_t>(-1)
+
+struct ConvCacheKey {
+  int device_id;
+  cudnnDataType_t cudnn_dtype;
+  std::array<int, MAX_NDIM> input_shape;
+  std::array<int, MAX_NDIM> weight_shape;
+  std::array<int, MAX_NDIM> stride;
+  std::array<int, MAX_NDIM> padding_lo;
+  std::array<int, MAX_NDIM> padding_hi;
+  std::array<int, MAX_NDIM> dilation;
+  int groups;
+  bool flip;
+  uint8_t input_alignment;
+  uint8_t weight_alignment;
+  uint8_t output_alignment;
+};
+
+auto& conv_cache() {
+  static LRUBytesKeyCache<
+      ConvCacheKey,
+      std::pair<
+          cudnnBackendDescriptorType_t,
+          std::optional<cudnn_frontend::ExecutionPlan>>>
+      cache("MLX_CUDA_CONV_CACHE_SIZE", /* default_capacity */ 128);
+  return cache;
+}
+
+auto get_conv_op_settings(
+    cudnnBackendDescriptorType_t backend_type,
+    array& x,
+    array& w,
+    array& y,
+    const std::vector<int>& kernel_strides,
+    const std::vector<int>& padding_lo_,
+    const std::vector<int>& padding_hi_,
+    const std::vector<int>& kernel_dilation,
+    const std::vector<int>& input_dilation) {
+  auto padding_lo = convert_vector<int64_t>(padding_lo_);
+  auto padding_hi = convert_vector<int64_t>(padding_hi_);
+
+  if (backend_type == CONV_BACKWARD_INPUT) {
+    for (int i = 0; i < padding_lo.size(); ++i) {
+      int wt_size = 1 + kernel_dilation[i] * (w.shape(1 + i) - 1);
+      padding_lo[i] = wt_size - padding_lo[i] - 1;
+      int in_size = 1 + kernel_strides[i] * (x.shape(1 + i) - 1);
+      int out_size = 1 + input_dilation[i] * (y.shape(1 + i) - 1);
+      padding_hi[i] = out_size - in_size + padding_hi[i];
+    }
+    return std::make_tuple(
+        convert_vector<int64_t>(input_dilation),
+        std::move(padding_lo),
+        std::move(padding_hi),
+        convert_vector<int64_t>(kernel_dilation));
+
+  } else if (backend_type == CONV_BACKWARD_WEIGHT) {
+    padding_hi = padding_lo;
+    return std::make_tuple(
+        convert_vector<int64_t>(kernel_dilation),
+        std::move(padding_lo),
+        std::move(padding_hi),
+        convert_vector<int64_t>(kernel_strides));
+
+  } else {
+    return std::make_tuple(
+        convert_vector<int64_t>(kernel_strides),
+        std::move(padding_lo),
+        std::move(padding_hi),
+        convert_vector<int64_t>(kernel_dilation));
+  }
+}
+
+std::optional<cudnn_frontend::OperationGraph> build_conv_op_graph(
+    cu::CommandEncoder& encoder,
+    cudnnBackendDescriptorType_t backend_type,
+    Dtype dtype,
+    array& x,
+    array& w,
+    array& y,
+    const SmallVector<int64_t>& stride,
+    const SmallVector<int64_t>& padding_lo,
+    const SmallVector<int64_t>& padding_hi,
+    const SmallVector<int64_t>& dilation) {
+  try {
+    auto compute_dtype = (dtype == float16 || dtype == bfloat16)
+        ? CUDNN_DATA_FLOAT
+        : dtype_to_cudnn_type(dtype);
+    auto conv_desc = cudnn_frontend::ConvDescBuilder()
+                         .setDataType(compute_dtype)
+                         .setMathMode(CUDNN_CROSS_CORRELATION)
+                         .setNDims(stride.size())
+                         .setStrides(stride.size(), stride.data())
+                         .setPrePadding(padding_lo.size(), padding_lo.data())
+                         .setPostPadding(padding_hi.size(), padding_hi.data())
+                         .setDilation(dilation.size(), dilation.data())
+                         .build();
+
+    auto op = cudnn_frontend::OperationBuilder(backend_type)
+                  .setxDesc(build_cudnn_tensor_nchw('x', x))
+                  .setwDesc(build_cudnn_tensor_nchw('w', w))
+                  .setyDesc(build_cudnn_tensor_nchw('y', y))
+                  .setcDesc(conv_desc)
+                  .build();
+
+    std::array<cudnn_frontend::Operation const*, 1> ops = {&op};
+    return cudnn_frontend::OperationGraphBuilder()
+        .setHandle(encoder.device().cudnn_handle())
+        .setOperationGraph(ops.size(), ops.data())
+        .build();
+  } catch (cudnn_frontend::cudnnException& error) {
+    if (error.getCudnnStatus() != CUDNN_STATUS_BAD_PARAM) {
+      throw;
+    }
+    return std::nullopt;
+  }
+}
+
+// Transpose from (C_out, H, W, C_in / groups) to (C_in, H, W, C_out / groups).
+array group_transpose(
+    const array& x,
+    int groups,
+    int group_dim,
+    int axis1,
+    int axis2,
+    Stream s) {
+  if (groups == 1) {
+    return swapaxes_in_eval(x, axis1, axis2);
+  }
+  int ndim = x.ndim();
+  if (group_dim < 0) {
+    group_dim += ndim;
+  }
+  if (axis1 < 0) {
+    axis1 += ndim;
+  }
+  if (axis2 < 0) {
+    axis2 += ndim;
+  }
+  if (group_dim <= axis1) {
+    axis1 += 1;
+  }
+  if (group_dim <= axis2) {
+    axis2 += 1;
+  }
+  auto shape = x.shape();
+  shape.insert(shape.begin() + group_dim, groups);
+  shape[group_dim + 1] = shape[group_dim + 1] / groups;
+  array x_trans = reshape_in_eval(x, std::move(shape), s);
+  x_trans = swapaxes_in_eval(x_trans, axis1, axis2);
+  x_trans = flatten_in_eval(x_trans, group_dim, group_dim + 1, s);
+  return x_trans;
+}
+
+// Do necessary transposes and copies to prepare the inputs and outputs for
+// building the cuDNN conv op. It is safe to be called multiple times in one
+// eval_gpu, with cost of possible redundant copies.
+std::tuple<array, array, array> prepare_args(
+    cu::CommandEncoder& encoder,
+    cudnnBackendDescriptorType_t backend_type,
+    array in,
+    array wt,
+    array out,
+    int groups,
+    Stream s) {
+  // Transpose the args depending on the backend type.
+  // TODO: Handle groups.
+  if (backend_type == CONV_BACKWARD_INPUT) {
+    wt = group_transpose(wt, groups, 0, 0, -1, s);
+  } else if (backend_type == CONV_BACKWARD_WEIGHT) {
+    in = group_transpose(in, groups, -1, 0, -1, s);
+    wt = swapaxes_in_eval(wt, 0, -1);
+    // Create a contiguous array that shares the data with |out|, but with dim
+    // C_in and C_out swapped.
+    Shape shape(out.shape());
+    std::swap(shape.front(), shape.back());
+    Strides strides(shape.size(), 1);
+    for (int i = shape.size() - 2; i >= 0; --i) {
+      strides[i] = shape[i + 1] * strides[i + 1];
+    }
+    array intermediate(std::move(shape), out.dtype(), nullptr, {});
+    intermediate.copy_shared_buffer(
+        out, std::move(strides), {true, true, false}, out.data_size());
+    out = intermediate;
+  }
+
+  // cuDNN requires contiguous input.
+  if (!in.flags().row_contiguous) {
+    in = contiguous_copy_gpu(in, s);
+    encoder.add_temporary(in);
+  }
+  if (!wt.flags().row_contiguous) {
+    wt = contiguous_copy_gpu(wt, s);
+    encoder.add_temporary(wt);
+  }
+
+  return {std::move(in), std::move(wt), std::move(out)};
+}
+
+// Get the x/w/y args from the in/wt/out args depending on backend type.
+inline std::tuple<array&, array&, array&> dispatch_args(
+    cudnnBackendDescriptorType_t backend_type,
+    array& in,
+    array& wt,
+    array& out) {
+  switch (backend_type) {
+    case CONV_BACKWARD_INPUT:
+      return {out, wt, in};
+    case CONV_BACKWARD_WEIGHT:
+      return {in, out, wt};
+    default:
+      return {in, wt, out};
+  }
+}
+
+// Register inputs and outputs before actually running conv op. Can only be
+// called once per eval_gpu.
+void register_args(
+    cu::CommandEncoder& encoder,
+    cudnnBackendDescriptorType_t backend_type,
+    array& in,
+    array& wt,
+    array& intermediate_out,
+    array& final_out) {
+  encoder.set_input_array(in);
+  encoder.set_input_array(wt);
+  encoder.set_output_array(final_out);
+
+  if (backend_type == CONV_BACKWARD_WEIGHT) {
+    // Turn |out| into a strided array, which will have C_in and C_out swapped
+    // in vjp and the final |grad_weight| will then be contiguous.
+    Strides strides = intermediate_out.strides();
+    std::swap(strides.front(), strides.back());
+    final_out.copy_shared_buffer(
+        intermediate_out,
+        std::move(strides),
+        {false, false, false},
+        intermediate_out.data_size());
+  }
+}
+
+} // namespace
+
+void Convolution::eval_gpu(const std::vector<array>& inputs, array& out_) {
+  nvtx3::scoped_range r("Convolution::eval_gpu");
+  if (out_.size() == 0) {
+    return;
+  }
+
+  assert(inputs.size() == 2);
+  array in = inputs[0];
+  array wt = inputs[1];
+  array out = out_;
+  out.set_data(allocator::malloc(out.nbytes()));
+  Dtype dtype = out.dtype();
+
+  auto& s = stream();
+  auto& encoder = cu::get_command_encoder(s);
+
+  // Search cache.
+  ConvCacheKey cache_key{
+      encoder.device().cuda_device(),
+      dtype_to_cudnn_type(dtype),
+      vector_key(in.shape()),
+      vector_key(wt.shape()),
+      vector_key(kernel_strides_),
+      vector_key(padding_lo_),
+      vector_key(padding_hi_),
+      vector_key(kernel_dilation_),
+      groups_,
+      flip_,
+      get_alignment(in),
+      get_alignment(wt),
+      get_alignment(out)};
+  if (auto it = conv_cache().find(cache_key); it != conv_cache().end()) {
+    auto& [backend_type, plan] = it->second;
+    if (plan) {
+      // Run cached plan.
+      std::tie(in, wt, out) =
+          prepare_args(encoder, backend_type, in, wt, out, groups_, s);
+      register_args(encoder, backend_type, in, wt, out, out_);
+      auto [x, w, y] = dispatch_args(backend_type, in, wt, out);
+      if (!encode_cudnn_plan(encoder, *plan, {'x', 'w', 'y'}, x, w, y)) {
+        throw std::runtime_error("[conv] Cached plan failed to execute.");
+      }
+    } else {
+      // Run fallback kernel.
+      gemm_conv(
+          encoder,
+          in,
+          wt,
+          out,
+          kernel_strides_,
+          padding_lo_,
+          kernel_dilation_,
+          input_dilation_,
+          groups_,
+          flip_,
+          s);
+    }
+    return;
+  }
+
+  // There is no reliable way to deduce the proper cuDNN backend for the
+  // convolution, so we make a best guess and then try.
+  SmallVector<cudnnBackendDescriptorType_t, 2> try_backends;
+  if (flip_) {
+    // When weight is flipped, we assume it is backward input convolution.
+    try_backends.push_back(CONV_BACKWARD_INPUT);
+  } else {
+    // Otherwise it could be backward weight convolution or forward convolution,
+    // mathematically there is no difference so we have to use heuristics.
+    // Empirically backward convolutions have large kernel dimensions, and
+    // usually have |in| and |wt| transposed.
+    if (!in.flags().row_contiguous && !wt.flags().row_contiguous &&
+        wt.shape(2) > out.shape(2)) {
+      try_backends = {CONV_BACKWARD_WEIGHT, CONV_FORWARD};
+    } else {
+      try_backends = {CONV_FORWARD, CONV_BACKWARD_WEIGHT};
+    }
+  }
+
+  // Try to build op graph.
+  cudnnBackendDescriptorType_t backend_type;
+  std::optional<cudnn_frontend::OperationGraph> op_graph;
+  for (auto try_backend : try_backends) {
+    auto [in_copy, wt_copy, out_copy] =
+        prepare_args(encoder, try_backend, in, wt, out, groups_, s);
+    auto [x, w, y] = dispatch_args(try_backend, in_copy, wt_copy, out_copy);
+    auto [stride, padding_lo, padding_hi, dilation] = get_conv_op_settings(
+        try_backend,
+        x,
+        w,
+        y,
+        kernel_strides_,
+        padding_lo_,
+        padding_hi_,
+        kernel_dilation_,
+        input_dilation_);
+    op_graph = build_conv_op_graph(
+        encoder,
+        try_backend,
+        dtype,
+        x,
+        w,
+        y,
+        stride,
+        padding_lo,
+        padding_hi,
+        dilation);
+    if (op_graph) {
+      backend_type = try_backend;
+      in = std::move(in_copy);
+      wt = std::move(wt_copy);
+      out = std::move(out_copy);
+      break;
+    }
+  }
+
+  if (op_graph) {
+    // Setup inputs and outputs.
+    register_args(encoder, backend_type, in, wt, out, out_);
+
+    // Find a plan for the graph and execute it.
+    auto plan = find_cudnn_plan_from_op_graph(
+        encoder.device().cudnn_handle(), backend_type, dtype, *op_graph);
+    if (!plan) {
+      throw std::runtime_error("[conv] Unable to find an execution plan.");
+    }
+    auto [x, w, y] = dispatch_args(backend_type, in, wt, out);
+    if (encode_cudnn_plan(encoder, *plan, {'x', 'w', 'y'}, x, w, y)) {
+      conv_cache().emplace(
+          cache_key, std::make_pair(backend_type, std::move(*plan)));
+      return;
+    }
+  }
+
+  // Use fallback kernel for settings not supported by cuDNN.
+  gemm_conv(
+      encoder,
+      in,
+      wt,
+      out,
+      kernel_strides_,
+      padding_lo_,
+      kernel_dilation_,
+      input_dilation_,
+      groups_,
+      flip_,
+      s);
+  conv_cache().emplace(cache_key, std::make_pair(CONV_FALLBACK, std::nullopt));
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/conv/conv.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/conv/conv.h
new file mode 100644
index 0000000000000000000000000000000000000000..62dc9343e859f9b826dbbffa33d40d6c1cb6d8e3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/conv/conv.h
@@ -0,0 +1,126 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/gpu/copy.h"
+
+namespace mlx::core {
+
+template <int NDIM>
+struct ConvParams {
+  int N; // Batch size
+  int C; // In channels
+  int O; // Out channels
+  int strides[NDIM];
+  int padding[NDIM];
+  int kernel_dilation[NDIM];
+  int input_dilation[NDIM];
+  int groups;
+  bool flip;
+  int in_spatial_dims[NDIM];
+  int wt_spatial_dims[NDIM];
+  int out_spatial_dims[NDIM];
+  int64_t in_strides[NDIM + 2];
+
+  ConvParams(
+      const array& in,
+      const array& wt,
+      const array& out,
+      const std::vector<int>& strides,
+      const std::vector<int>& padding,
+      const std::vector<int>& kernel_dilation,
+      const std::vector<int>& input_dilation,
+      int groups,
+      bool flip)
+      : N(in.shape(0)),
+        C(in.shape(-1)),
+        O(wt.shape(0)),
+        groups(groups),
+        flip(flip) {
+    std::copy_n(strides.begin(), NDIM, this->strides);
+    std::copy_n(padding.begin(), NDIM, this->padding);
+    std::copy_n(kernel_dilation.begin(), NDIM, this->kernel_dilation);
+    std::copy_n(input_dilation.begin(), NDIM, this->input_dilation);
+    std::copy_n(in.shape().begin() + 1, NDIM, this->in_spatial_dims);
+    std::copy_n(wt.shape().begin() + 1, NDIM, this->wt_spatial_dims);
+    std::copy_n(out.shape().begin() + 1, NDIM, this->out_spatial_dims);
+    std::copy_n(in.strides().begin(), NDIM + 2, this->in_strides);
+  }
+};
+
+void gemm_grouped_conv(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    const array& wt,
+    array& out,
+    const std::vector<int>& strides,
+    const std::vector<int>& padding,
+    const std::vector<int>& kernel_dilation,
+    const std::vector<int>& input_dilation,
+    int groups,
+    bool flip,
+    Stream s);
+
+void gemm_conv(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    const array& wt,
+    array& out,
+    const std::vector<int>& strides,
+    const std::vector<int>& padding,
+    const std::vector<int>& kernel_dilation,
+    const std::vector<int>& input_dilation,
+    bool flip,
+    Stream s);
+
+inline void gemm_conv(
+    cu::CommandEncoder& encoder,
+    array in,
+    array wt,
+    array& out,
+    const std::vector<int>& strides,
+    const std::vector<int>& padding,
+    const std::vector<int>& kernel_dilation,
+    const std::vector<int>& input_dilation,
+    int groups,
+    bool flip,
+    Stream s) {
+  if (!in.flags().row_contiguous) {
+    in = contiguous_copy_gpu(in, s);
+    encoder.add_temporary(in);
+  }
+  if (!wt.flags().row_contiguous) {
+    wt = contiguous_copy_gpu(wt, s);
+    encoder.add_temporary(wt);
+  }
+
+  if (groups == 1) {
+    gemm_conv(
+        encoder,
+        in,
+        wt,
+        out,
+        strides,
+        padding,
+        kernel_dilation,
+        input_dilation,
+        flip,
+        s);
+  } else {
+    gemm_grouped_conv(
+        encoder,
+        in,
+        wt,
+        out,
+        strides,
+        padding,
+        kernel_dilation,
+        input_dilation,
+        groups,
+        flip,
+        s);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/conv/gemm_conv.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/conv/gemm_conv.cu
new file mode 100644
index 0000000000000000000000000000000000000000..11a78a7ab48345e79528dbc8d49bc59c014d6c5f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/conv/gemm_conv.cu
@@ -0,0 +1,217 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/conv/conv.h"
+#include "mlx/backend/cuda/gemms/cublas_gemm.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/dtype_utils.h"
+
+#include <cooperative_groups.h>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename T, int NDIM>
+__global__ void naive_unfold_nd(
+    const T* in,
+    T* out,
+    int filter_size,
+    int out_pixels,
+    const __grid_constant__ ConvParams<NDIM> params) {
+  auto block = cg::this_thread_block();
+  auto tid = block.group_index();
+  auto lid = block.thread_index();
+
+  int index_batch = tid.z / out_pixels; // [0, N)
+  int index_out_spatial = tid.z % out_pixels; // [0, H_out * W_out)
+  int index_wt_spatial =
+      tid.x * block.dim_threads().x + lid.x; // [0, H_wt * W_wt)
+
+  if (index_wt_spatial >= filter_size / params.C) {
+    return;
+  }
+
+  in += tid.y; // [0, C)
+  out += tid.z * filter_size + index_wt_spatial * params.C + tid.y;
+
+  bool valid = index_batch < params.N;
+
+  // Get the coordinates in input.
+  int index_in[NDIM] = {};
+#pragma unroll
+  for (int i = NDIM - 1; i >= 0; --i) {
+    int index_out = index_out_spatial % params.out_spatial_dims[i];
+    int index_wt = index_wt_spatial % params.wt_spatial_dims[i];
+
+    if (params.flip) {
+      index_wt = params.wt_spatial_dims[i] - index_wt - 1;
+    }
+
+    int index = index_out * params.strides[i] - params.padding[i] +
+        index_wt * params.kernel_dilation[i];
+    int index_max =
+        1 + params.input_dilation[i] * (params.in_spatial_dims[i] - 1);
+
+    valid &= (index >= 0) && (index < index_max) &&
+        (index % params.input_dilation[i] == 0);
+
+    index_in[i] = index / params.input_dilation[i];
+
+    index_out_spatial /= params.out_spatial_dims[i];
+    index_wt_spatial /= params.wt_spatial_dims[i];
+  }
+
+  if (valid) {
+    int in_offset = index_batch * params.in_strides[0];
+#pragma unroll
+    for (int i = 0; i < NDIM; ++i) {
+      in_offset += index_in[i] * params.in_strides[i + 1];
+    }
+    *out = in[in_offset];
+  } else {
+    *out = T{0};
+  }
+}
+
+} // namespace cu
+
+template <int NDIM>
+array unfold_inputs_nd(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    int mat_M,
+    int mat_K,
+    int mat_N,
+    ConvParams<NDIM>& params) {
+  array unfolded({mat_M, mat_K}, in.dtype(), nullptr, {});
+  unfolded.set_data(allocator::malloc(unfolded.nbytes()));
+  encoder.add_temporary(unfolded);
+
+  int filter_size = params.C;
+#pragma unroll
+  for (int i = 0; i < NDIM; ++i) {
+    filter_size *= params.wt_spatial_dims[i];
+  }
+
+  int out_pixels = 1;
+#pragma unroll
+  for (int i = 0; i < NDIM; ++i) {
+    out_pixels *= params.out_spatial_dims[i];
+  }
+
+  int wt_spatial_size = mat_K / params.C;
+  dim3 block_dims;
+  block_dims.x = std::min(std::max(wt_spatial_size, 32), 1024);
+  dim3 num_blocks;
+  num_blocks.x = cuda::ceil_div(wt_spatial_size, block_dims.x);
+  num_blocks.y = params.C;
+  num_blocks.z = mat_M;
+
+  encoder.set_input_array(in);
+  encoder.set_output_array(unfolded);
+  dispatch_float_types(in.dtype(), "unfold", [&](auto type_tag) {
+    using DataType = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+    encoder.add_kernel_node(
+        cu::naive_unfold_nd<DataType, NDIM>,
+        num_blocks,
+        block_dims,
+        0,
+        in.data<DataType>(),
+        unfolded.data<DataType>(),
+        filter_size,
+        out_pixels,
+        params);
+  });
+
+  return unfolded;
+}
+
+template <int NDIM>
+void gemm_conv_nd(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    const array& wt,
+    array& out,
+    ConvParams<NDIM>& params,
+    Stream s) {
+  // Get gemm shapes.
+  int mat_M = out.size() / params.O; // N * H_out * W_out
+  int mat_K = wt.size() / params.O; // C * H_wt * W_wt
+  int mat_N = params.O; // O
+
+  // Unfold input to (N * H_out * W_out, C * H_wt * W_wt) for gemm.
+  array in_unfolded =
+      unfold_inputs_nd<NDIM>(encoder, in, mat_M, mat_K, mat_N, params);
+
+  // Reshape weight to (C * H_wt * W_wt, O) for gemm.
+  array wt_reshaped({mat_K, mat_N}, wt.dtype(), nullptr, {});
+  wt_reshaped.copy_shared_buffer(
+      wt,
+      {1, mat_K},
+      {false, false, /* col_contiguous */ true},
+      wt.data_size());
+
+  // Single batch.
+  Shape batch_shape{1};
+  Strides a_batch_strides{0};
+  Strides b_batch_strides{0};
+
+  // Run matmul.
+  CublasGemm gemm(
+      encoder.device(),
+      in.dtype(),
+      false, // a_transposed
+      mat_M, // a_rows
+      mat_K, // a_cols
+      mat_K, // lda
+      true, // b_transposed
+      mat_K, // b_rows
+      mat_N, // b_cols
+      mat_K, // ldb
+      batch_shape.back(),
+      a_batch_strides.back(),
+      b_batch_strides.back());
+  gemm.run(
+      encoder,
+      out,
+      in_unfolded,
+      wt_reshaped,
+      batch_shape,
+      a_batch_strides,
+      b_batch_strides);
+}
+
+void gemm_conv(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    const array& wt,
+    array& out,
+    const std::vector<int>& strides,
+    const std::vector<int>& padding,
+    const std::vector<int>& kernel_dilation,
+    const std::vector<int>& input_dilation,
+    bool flip,
+    Stream s) {
+  int conv_ndim = in.ndim() - 2;
+  if (conv_ndim < 1 || conv_ndim > 3) {
+    throw std::runtime_error(
+        fmt::format("[conv] Unsupported gemm_conv for {}D conv.", conv_ndim));
+  }
+  dispatch_1_2_3(conv_ndim, [&](auto ndim_constant) {
+    ConvParams<ndim_constant()> params(
+        in,
+        wt,
+        out,
+        strides,
+        padding,
+        kernel_dilation,
+        input_dilation,
+        1, // groups
+        flip);
+    gemm_conv_nd<ndim_constant()>(encoder, in, wt, out, params, s);
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/conv/gemm_grouped_conv.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/conv/gemm_grouped_conv.cu
new file mode 100644
index 0000000000000000000000000000000000000000..7ceb58166c67abc419ec0a17c856c3b3c7134ce3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/conv/gemm_grouped_conv.cu
@@ -0,0 +1,231 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/conv/conv.h"
+#include "mlx/backend/cuda/gemms/cublas_gemm.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/dtype_utils.h"
+
+#include <cooperative_groups.h>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename T, int NDIM>
+__global__ void naive_grouped_unfold_transpose_nd(
+    const T* in,
+    T* out,
+    int filter_size,
+    int out_pixels,
+    const __grid_constant__ ConvParams<NDIM> params) {
+  auto block = cg::this_thread_block();
+  auto tid = block.group_index();
+  auto lid = block.thread_index();
+
+  int index_batch = tid.z / out_pixels; // [0, N)
+  int index_out_spatial = tid.z % out_pixels; // [0, H_out * W_out)
+  int index_wt_spatial =
+      tid.x * block.dim_threads().x + lid.x; // [0, H_wt * W_wt)
+
+  if (index_wt_spatial >= filter_size / params.C) {
+    return;
+  }
+
+  in += tid.y; // [0, C)
+  out += tid.z * filter_size + tid.y * (filter_size / params.C);
+
+  bool valid = index_batch < params.N;
+
+  // Get the coordinates in input.
+  int index_in[NDIM] = {};
+  int wt_stride = 1;
+#pragma unroll
+  for (int i = NDIM - 1; i >= 0; --i) {
+    int index_out = index_out_spatial % params.out_spatial_dims[i];
+    int index_wt = index_wt_spatial % params.wt_spatial_dims[i];
+    out += index_wt * wt_stride;
+
+    if (params.flip) {
+      index_wt = params.wt_spatial_dims[i] - index_wt - 1;
+    }
+
+    int index = index_out * params.strides[i] - params.padding[i] +
+        index_wt * params.kernel_dilation[i];
+    int index_max =
+        1 + params.input_dilation[i] * (params.in_spatial_dims[i] - 1);
+
+    valid &= (index >= 0) && (index < index_max) &&
+        (index % params.input_dilation[i] == 0);
+
+    index_in[i] = index / params.input_dilation[i];
+
+    index_out_spatial /= params.out_spatial_dims[i];
+    index_wt_spatial /= params.wt_spatial_dims[i];
+    wt_stride *= params.wt_spatial_dims[i];
+  }
+
+  if (valid) {
+    int in_offset = index_batch * params.in_strides[0];
+#pragma unroll
+    for (int i = 0; i < NDIM; ++i) {
+      in_offset += index_in[i] * params.in_strides[i + 1];
+    }
+    *out = in[in_offset];
+  } else {
+    *out = T{0};
+  }
+}
+
+} // namespace cu
+
+template <int NDIM>
+array grouped_unfold_transpose_inputs_nd(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    int mat_M,
+    int mat_K,
+    int mat_N,
+    ConvParams<NDIM>& params) {
+  array unfolded({mat_M, mat_K * params.groups}, in.dtype(), nullptr, {});
+  unfolded.set_data(allocator::malloc(unfolded.nbytes()));
+  encoder.add_temporary(unfolded);
+
+  int filter_size = params.C;
+#pragma unroll
+  for (int i = 0; i < NDIM; ++i) {
+    filter_size *= params.wt_spatial_dims[i];
+  }
+
+  int out_pixels = 1;
+#pragma unroll
+  for (int i = 0; i < NDIM; ++i) {
+    out_pixels *= params.out_spatial_dims[i];
+  }
+
+  int wt_spatial_size = (mat_K * params.groups) / params.C;
+  dim3 block_dims;
+  block_dims.x = std::min(std::max(wt_spatial_size, 32), 1024);
+  dim3 num_blocks;
+  num_blocks.x = cuda::ceil_div(wt_spatial_size, block_dims.x);
+  num_blocks.y = params.C;
+  num_blocks.z = mat_M;
+
+  encoder.set_input_array(in);
+  encoder.set_output_array(unfolded);
+  dispatch_float_types(in.dtype(), "unfold", [&](auto type_tag) {
+    using DataType = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+    encoder.add_kernel_node(
+        cu::naive_grouped_unfold_transpose_nd<DataType, NDIM>,
+        num_blocks,
+        block_dims,
+        0,
+        in.data<DataType>(),
+        unfolded.data<DataType>(),
+        filter_size,
+        out_pixels,
+        params);
+  });
+
+  return unfolded;
+}
+
+template <int NDIM>
+void gemm_grouped_conv_nd(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    const array& wt,
+    array& out,
+    ConvParams<NDIM>& params,
+    Stream s) {
+  // Get gemm shapes.
+  int C_per_group = params.C / params.groups;
+  int O_per_group = params.O / params.groups;
+  int mat_M = out.size() / params.O; // N * H_out * W_out
+  int mat_K = wt.size() / params.O; // C_per_group * H_wt * W_wt
+  int mat_N = O_per_group; // O_per_group
+
+  // Unfold input to (N * H_out * W_out, C * H_wt * W_wt) for gemm.
+  array in_unfolded = grouped_unfold_transpose_inputs_nd<NDIM>(
+      encoder, in, mat_M, mat_K, mat_N, params);
+
+  // Reshape weight to (O, C_per_group, H_wt * W_wt) for gemm.
+  int wt_spatial_size = (wt.size() / wt.shape(0)) / wt.shape(-1);
+  array wt_view(
+      {params.O, C_per_group, wt_spatial_size}, wt.dtype(), nullptr, {});
+  wt_view.copy_shared_buffer(
+      wt, {wt.strides(0), 1, C_per_group}, wt.flags(), wt.size());
+  array wt_reshaped = contiguous_copy_gpu(wt_view, s);
+
+  // Batch with size of groups.
+  Shape batch_shape{params.groups};
+  Strides a_batch_strides{mat_K};
+  Strides b_batch_strides{mat_N * mat_K};
+
+  // Run matmul.
+  CublasGemm gemm(
+      encoder.device(),
+      in.dtype(),
+      false, // a_transposed
+      mat_M, // a_rows
+      mat_K, // a_cols
+      mat_K * params.groups, // lda
+      true, // b_transposed
+      mat_K, // b_rows
+      mat_N, // b_cols
+      mat_K, // ldb
+      batch_shape.back(),
+      a_batch_strides.back(),
+      b_batch_strides.back());
+  gemm.set_out(
+      out.dtype(),
+      false, // out_transposed
+      mat_M, // out_rows
+      mat_N, // out_cols
+      mat_N * params.groups, // out_ld
+      params.groups, // batch_count
+      mat_N); // batch_stride
+  gemm.run(
+      encoder,
+      out,
+      in_unfolded,
+      wt_reshaped,
+      batch_shape,
+      a_batch_strides,
+      b_batch_strides);
+}
+
+void gemm_grouped_conv(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    const array& wt,
+    array& out,
+    const std::vector<int>& strides,
+    const std::vector<int>& padding,
+    const std::vector<int>& kernel_dilation,
+    const std::vector<int>& input_dilation,
+    int groups,
+    bool flip,
+    Stream s) {
+  int conv_ndim = in.ndim() - 2;
+  if (conv_ndim < 1 || conv_ndim > 3) {
+    throw std::runtime_error(
+        fmt::format("[conv] Unsupported gemm_conv for {}D conv.", conv_ndim));
+  }
+  dispatch_1_2_3(conv_ndim, [&](auto ndim_constant) {
+    ConvParams<ndim_constant()> params(
+        in,
+        wt,
+        out,
+        strides,
+        padding,
+        kernel_dilation,
+        input_dilation,
+        groups,
+        flip);
+    gemm_grouped_conv_nd<ndim_constant()>(encoder, in, wt, out, params, s);
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/copy.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/copy.cu
new file mode 100644
index 0000000000000000000000000000000000000000..158d3de6ee8f61cc2cf723d337b310466f927257
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/copy.cu
@@ -0,0 +1,97 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cuda/copy/copy.cuh"
+
+namespace mlx::core {
+
+void copy_gpu_inplace(
+    const array& in,
+    array& out,
+    const Shape& shape,
+    const Strides& strides_in,
+    const Strides& strides_out,
+    int64_t offset_in,
+    int64_t offset_out,
+    CopyType ctype,
+    const Stream& s,
+    std::optional<array> dynamic_offset_in,
+    std::optional<array> dynamic_offset_out) {
+  if (out.size() == 0) {
+    return;
+  }
+
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  if (ctype == CopyType::Scalar || ctype == CopyType::Vector) {
+    copy_contiguous(encoder, ctype, in, out, offset_in, offset_out);
+    return;
+  }
+
+  if (ctype == CopyType::General || ctype == CopyType::GeneralGeneral) {
+    auto [shape_collapsed, strides_vec] = collapse_contiguous_dims(
+        shape, std::vector{strides_in, strides_out}, INT32_MAX);
+    if (ctype == CopyType::General) {
+      copy_general_input(
+          encoder,
+          ctype,
+          in,
+          out,
+          offset_in,
+          offset_out,
+          shape_collapsed,
+          strides_vec[0]);
+    } else {
+      if (dynamic_offset_in || dynamic_offset_out) {
+        if (!dynamic_offset_in) {
+          dynamic_offset_in = array(0, int64);
+          encoder.add_temporary(*dynamic_offset_in);
+        }
+        if (!dynamic_offset_out) {
+          dynamic_offset_out = array(0, int64);
+          encoder.add_temporary(*dynamic_offset_out);
+        }
+        encoder.set_input_array(*dynamic_offset_in);
+        encoder.set_input_array(*dynamic_offset_out);
+        copy_general_dynamic(
+            encoder,
+            ctype,
+            in,
+            out,
+            offset_in,
+            offset_out,
+            shape_collapsed,
+            strides_vec[0],
+            strides_vec[1],
+            *dynamic_offset_in,
+            *dynamic_offset_out);
+      } else {
+        copy_general(
+            encoder,
+            ctype,
+            in,
+            out,
+            offset_in,
+            offset_out,
+            shape_collapsed,
+            strides_vec[0],
+            strides_vec[1]);
+      }
+    }
+    return;
+  }
+}
+
+void fill_gpu(const array& in, array& out, const Stream& s) {
+  if (out.size() == 0) {
+    return;
+  }
+  out.set_data(allocator::malloc(out.nbytes()));
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  copy_contiguous(encoder, CopyType::Scalar, in, out, 0, 0);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..e80fdec8c95baae8ad36eef0750a1c5baa4e0a42
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy.cuh
@@ -0,0 +1,55 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/device/cast_op.cuh"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/dtype_utils.h"
+
+namespace mlx::core {
+
+void copy_contiguous(
+    cu::CommandEncoder& encoder,
+    CopyType ctype,
+    const array& in,
+    array& out,
+    int64_t offset_in,
+    int64_t offset_out);
+
+void copy_general(
+    cu::CommandEncoder& encoder,
+    CopyType ctype,
+    const array& in,
+    array& out,
+    int64_t offset_in,
+    int64_t offset_out,
+    const Shape& shape,
+    const Strides& strides_in,
+    const Strides& strides_out);
+
+void copy_general_dynamic(
+    cu::CommandEncoder& encoder,
+    CopyType ctype,
+    const array& in,
+    array& out,
+    int64_t offset_in,
+    int64_t offset_out,
+    const Shape& shape,
+    const Strides& strides_in,
+    const Strides& strides_out,
+    const array& dynamic_offset_in,
+    const array& dynamic_offset_out);
+
+void copy_general_input(
+    cu::CommandEncoder& encoder,
+    CopyType ctype,
+    const array& in,
+    array& out,
+    int64_t offset_in,
+    int64_t offset_out,
+    const Shape& shape,
+    const Strides& strides_in);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy_contiguous.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy_contiguous.cu
new file mode 100644
index 0000000000000000000000000000000000000000..9c2aa9838b877452653417042762f14531744300
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy_contiguous.cu
@@ -0,0 +1,88 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/copy/copy.cuh"
+
+#include <cooperative_groups.h>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename In, typename Out, typename IdxT, int N_READS>
+__global__ void copy_s(const In* in, Out* out, IdxT size) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_READS > size) {
+    for (IdxT i = index * N_READS; i < size; ++i) {
+      out[i] = cast_to<Out>(in[0]);
+    }
+  } else {
+    AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      out_vec[i] = cast_to<Out>(in[0]);
+    }
+
+    store_vector<N_READS>(out, index, out_vec);
+  }
+}
+
+template <typename In, typename Out, typename IdxT, int N_READS>
+__global__ void copy_v(const In* in, Out* out, IdxT size) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_READS > size) {
+    for (IdxT i = index * N_READS; i < size; ++i) {
+      out[i] = cast_to<Out>(in[i]);
+    }
+  } else {
+    auto in_vec = load_vector<N_READS>(in, index);
+
+    AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      out_vec[i] = cast_to<Out>(in_vec[i]);
+    }
+
+    store_vector<N_READS>(out, index, out_vec);
+  }
+}
+
+} // namespace cu
+
+void copy_contiguous(
+    cu::CommandEncoder& encoder,
+    CopyType ctype,
+    const array& in,
+    array& out,
+    int64_t in_offset,
+    int64_t out_offset) {
+  dispatch_all_types(in.dtype(), [&](auto in_type_tag) {
+    dispatch_all_types(out.dtype(), [&](auto out_type_tag) {
+      dispatch_bool(out.data_size() > UINT32_MAX, [&](auto large) {
+        using InType = cuda_type_t<MLX_GET_TYPE(in_type_tag)>;
+        using OutType = cuda_type_t<MLX_GET_TYPE(out_type_tag)>;
+        using IdxT = std::conditional_t<large(), int64_t, uint32_t>;
+        constexpr int N_READS = 16 / sizeof(InType);
+        auto kernel = cu::copy_s<InType, OutType, IdxT, N_READS>;
+        if (ctype == CopyType::Vector) {
+          kernel = cu::copy_v<InType, OutType, IdxT, N_READS>;
+        }
+        auto [num_blocks, block_dims] = get_launch_args(
+            out.data_size(), out.shape(), out.strides(), large(), N_READS);
+        encoder.add_kernel_node(
+            kernel,
+            num_blocks,
+            block_dims,
+            0,
+            in.data<InType>() + in_offset,
+            out.data<OutType>() + out_offset,
+            out.data_size());
+      });
+    });
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy_general.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy_general.cu
new file mode 100644
index 0000000000000000000000000000000000000000..6ac42751a3cb6c341ea3ce7516405a4ef4d5400b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy_general.cu
@@ -0,0 +1,171 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/copy/copy.cuh"
+
+#include <cooperative_groups.h>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename In, typename Out, typename IdxT, int NDIM, int N_READS>
+__global__ void copy_gg_nd(
+    const In* in,
+    Out* out,
+    IdxT size_rest,
+    const __grid_constant__ cuda::std::array<int32_t, NDIM> shape,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> strides_in,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> strides_out) {
+  auto block = cg::this_thread_block();
+  auto grid = cg::this_grid();
+  IdxT index_rest =
+      grid.block_index().y * block.dim_threads().y + block.thread_index().y;
+  if (index_rest >= size_rest) {
+    return;
+  }
+
+  auto shape_x = shape[NDIM - 1];
+  auto in_stride_x = strides_in[NDIM - 1];
+  auto out_stride_x = strides_out[NDIM - 1];
+  IdxT index_x =
+      grid.block_index().x * block.dim_threads().x + block.thread_index().x;
+  auto [idx_in, idx_out] = elem_to_loc_nd<NDIM>(
+      index_rest * shape_x,
+      shape.data(),
+      strides_in.data(),
+      strides_out.data());
+
+  auto in_vec =
+      load_vector<N_READS>(in + idx_in, index_x, shape_x, in_stride_x, In(0));
+  AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+  for (int i = 0; i < N_READS; ++i) {
+    out_vec[i] = CastOp<In, Out>{}(in_vec[i]);
+  }
+  store_vector(out + idx_out, index_x, out_vec, shape_x, out_stride_x);
+}
+
+template <typename In, typename Out, typename IdxT, int N_READS>
+__global__ void copy_gg(
+    const In* in,
+    Out* out,
+    IdxT size_rest,
+    const __grid_constant__ Shape shape,
+    const __grid_constant__ Strides strides_in,
+    const __grid_constant__ Strides strides_out,
+    int ndim) {
+  auto block = cg::this_thread_block();
+  auto grid = cg::this_grid();
+  IdxT index_rest =
+      grid.block_index().y * block.dim_threads().y + block.thread_index().y;
+  if (index_rest >= size_rest) {
+    return;
+  }
+
+  auto shape_x = shape[ndim - 1];
+  auto in_stride_x = strides_in[ndim - 1];
+  auto out_stride_x = strides_out[ndim - 1];
+  IdxT index_x =
+      grid.block_index().x * block.dim_threads().x + block.thread_index().x;
+  auto [idx_in, idx_out] = elem_to_loc(
+      index_rest * shape_x,
+      shape.data(),
+      strides_in.data(),
+      strides_out.data(),
+      ndim);
+
+  auto in_vec =
+      load_vector<N_READS>(in + idx_in, index_x, shape_x, in_stride_x, In(0));
+  AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+  for (int i = 0; i < N_READS; ++i) {
+    out_vec[i] = CastOp<In, Out>{}(in_vec[i]);
+  }
+  store_vector(out + idx_out, index_x, out_vec, shape_x, out_stride_x);
+}
+
+} // namespace cu
+
+void copy_general(
+    cu::CommandEncoder& encoder,
+    CopyType ctype,
+    const array& in,
+    array& out,
+    int64_t offset_in,
+    int64_t offset_out,
+    const Shape& shape,
+    const Strides& strides_in,
+    const Strides& strides_out) {
+  dispatch_all_types(in.dtype(), [&](auto in_type_tag) {
+    dispatch_all_types(out.dtype(), [&](auto out_type_tag) {
+      dispatch_bool(
+          in.data_size() > INT32_MAX || out.data_size() > INT32_MAX,
+          [&](auto large) {
+            using InType = cuda_type_t<MLX_GET_TYPE(in_type_tag)>;
+            using OutType = cuda_type_t<MLX_GET_TYPE(out_type_tag)>;
+            using IdxT = std::conditional_t<large(), int64_t, int32_t>;
+            const InType* in_ptr = in.data<InType>() + offset_in;
+            OutType* out_ptr = out.data<OutType>() + offset_out;
+            int ndim = shape.size();
+            size_t data_size = 1;
+            for (auto& s : shape)
+              data_size *= s;
+
+            int work_per_thread = 1;
+            auto dim0 = ndim > 0 ? shape.back() : 1;
+            auto rest = data_size / dim0;
+            if (dim0 >= 4) {
+              work_per_thread = 4;
+            }
+
+            dim0 = (dim0 + work_per_thread - 1) / work_per_thread;
+            auto block_dims = get_block_dims(dim0, rest, 1);
+            uint32_t num_blocks_x = cuda::ceil_div(dim0, block_dims.x);
+            uint32_t num_blocks_y = cuda::ceil_div(rest, block_dims.y);
+
+            if (ndim <= 3) {
+              dispatch_1_2_3(ndim, [&](auto ndim_constant) {
+                auto kernel =
+                    cu::copy_gg_nd<InType, OutType, IdxT, ndim_constant(), 1>;
+                if (work_per_thread == 4) {
+                  kernel =
+                      cu::copy_gg_nd<InType, OutType, IdxT, ndim_constant(), 4>;
+                }
+                encoder.add_kernel_node(
+                    kernel,
+                    {num_blocks_x, num_blocks_y},
+                    block_dims,
+                    0,
+                    in_ptr,
+                    out_ptr,
+                    rest,
+                    const_param<ndim_constant()>(shape),
+                    const_param<ndim_constant()>(strides_in),
+                    const_param<ndim_constant()>(strides_out));
+              });
+            } else { // ndim >= 4
+              auto kernel = cu::copy_gg<InType, OutType, IdxT, 1>;
+              if (work_per_thread == 4) {
+                kernel = cu::copy_gg<InType, OutType, IdxT, 4>;
+              }
+              encoder.add_kernel_node(
+                  kernel,
+                  {num_blocks_x, num_blocks_y},
+                  block_dims,
+                  0,
+                  in_ptr,
+                  out_ptr,
+                  rest,
+                  const_param(shape),
+                  const_param(strides_in),
+                  const_param(strides_out),
+                  ndim);
+            }
+          });
+    });
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy_general_dynamic.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy_general_dynamic.cu
new file mode 100644
index 0000000000000000000000000000000000000000..7a7f0dca5828db8cffd4c6f5ba387ab086a4f0f4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy_general_dynamic.cu
@@ -0,0 +1,118 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/copy/copy.cuh"
+
+#include <cooperative_groups.h>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename In, typename Out, typename IdxT, int NDIM>
+__global__ void copy_gg_dynamic_nd(
+    const In* in,
+    Out* out,
+    IdxT size,
+    const __grid_constant__ cuda::std::array<int32_t, NDIM> shape,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> strides_in,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> strides_out,
+    const int64_t* offset_in,
+    const int64_t* offset_out) {
+  IdxT index = cg::this_grid().thread_rank();
+  if (index < size) {
+    auto [idx_in, idx_out] = elem_to_loc_nd<NDIM>(
+        index, shape.data(), strides_in.data(), strides_out.data());
+    out[idx_out + *offset_out] = CastOp<In, Out>{}(in[idx_in + *offset_in]);
+  }
+}
+
+template <typename In, typename Out, typename IdxT>
+__global__ void copy_gg_dynamic(
+    const In* in,
+    Out* out,
+    IdxT size,
+    const __grid_constant__ Shape shape,
+    const __grid_constant__ Strides strides_in,
+    const __grid_constant__ Strides strides_out,
+    int ndim,
+    const int64_t* offset_in,
+    const int64_t* offset_out) {
+  IdxT index = cg::this_grid().thread_rank();
+  if (index < size) {
+    auto [idx_in, idx_out] = elem_to_loc(
+        index, shape.data(), strides_in.data(), strides_out.data(), ndim);
+    out[idx_out + *offset_out] = CastOp<In, Out>{}(in[idx_in + *offset_in]);
+  }
+}
+
+} // namespace cu
+
+void copy_general_dynamic(
+    cu::CommandEncoder& encoder,
+    CopyType ctype,
+    const array& in,
+    array& out,
+    int64_t offset_in,
+    int64_t offset_out,
+    const Shape& shape,
+    const Strides& strides_in,
+    const Strides& strides_out,
+    const array& dynamic_offset_in,
+    const array& dynamic_offset_out) {
+  dispatch_all_types(in.dtype(), [&](auto in_type_tag) {
+    dispatch_all_types(out.dtype(), [&](auto out_type_tag) {
+      dispatch_bool(
+          in.data_size() > INT32_MAX || out.data_size() > INT32_MAX,
+          [&](auto large) {
+            using InType = cuda_type_t<MLX_GET_TYPE(in_type_tag)>;
+            using OutType = cuda_type_t<MLX_GET_TYPE(out_type_tag)>;
+            using IdxT = std::conditional_t<large(), int64_t, int32_t>;
+            const InType* in_ptr = in.data<InType>() + offset_in;
+            OutType* out_ptr = out.data<OutType>() + offset_out;
+            int ndim = shape.size();
+            if (ndim <= 3) {
+              dispatch_1_2_3(ndim, [&](auto dims_constant) {
+                auto [num_blocks, block_dims] = get_launch_args(out, large());
+                encoder.add_kernel_node(
+                    cu::copy_gg_dynamic_nd<
+                        InType,
+                        OutType,
+                        IdxT,
+                        dims_constant()>,
+                    num_blocks,
+                    block_dims,
+                    0,
+                    in_ptr,
+                    out_ptr,
+                    out.size(),
+                    const_param<dims_constant()>(shape),
+                    const_param<dims_constant()>(strides_in),
+                    const_param<dims_constant()>(strides_out),
+                    dynamic_offset_in.data<int64_t>(),
+                    dynamic_offset_out.data<int64_t>());
+              });
+            } else { // ndim >= 4
+              auto [num_blocks, block_dims] = get_launch_args(out, large());
+              encoder.add_kernel_node(
+                  cu::copy_gg_dynamic<InType, OutType, IdxT>,
+                  num_blocks,
+                  block_dims,
+                  0,
+                  in_ptr,
+                  out_ptr,
+                  out.size(),
+                  const_param(shape),
+                  const_param(strides_in),
+                  const_param(strides_out),
+                  ndim,
+                  dynamic_offset_in.data<int64_t>(),
+                  dynamic_offset_out.data<int64_t>());
+            }
+          });
+    });
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy_general_input.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy_general_input.cu
new file mode 100644
index 0000000000000000000000000000000000000000..ce8bb1b78ead181ff40030161474e83d7f2f0d89
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/copy/copy_general_input.cu
@@ -0,0 +1,150 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/copy/copy.cuh"
+
+#include <cooperative_groups.h>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename In, typename Out, typename IdxT, int NDIM, int N_READS>
+__global__ void copy_g_nd(
+    const In* in,
+    Out* out,
+    IdxT size_rest,
+    const __grid_constant__ cuda::std::array<int32_t, NDIM> shape,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> strides) {
+  auto block = cg::this_thread_block();
+  auto grid = cg::this_grid();
+  IdxT index_rest =
+      grid.block_index().y * block.dim_threads().y + block.thread_index().y;
+  if (index_rest >= size_rest) {
+    return;
+  }
+
+  auto shape_x = shape[NDIM - 1];
+  auto stride_x = strides[NDIM - 1];
+  IdxT index_x =
+      grid.block_index().x * block.dim_threads().x + block.thread_index().x;
+  auto idx =
+      elem_to_loc_nd<NDIM>(index_rest * shape_x, shape.data(), strides.data());
+  auto in_vec =
+      load_vector<N_READS>(in + idx, index_x, shape_x, stride_x, In(0));
+  AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+  for (int i = 0; i < N_READS; ++i) {
+    out_vec[i] = CastOp<In, Out>{}(in_vec[i]);
+  }
+  store_vector(out + shape_x * index_rest, index_x, out_vec, shape_x);
+}
+
+template <typename In, typename Out, typename IdxT, int N_READS>
+__global__ void copy_g(
+    const In* in,
+    Out* out,
+    IdxT size_rest,
+    const __grid_constant__ Shape shape,
+    const __grid_constant__ Strides strides,
+    int ndim) {
+  auto block = cg::this_thread_block();
+  auto grid = cg::this_grid();
+  IdxT index_rest =
+      grid.block_index().y * block.dim_threads().y + block.thread_index().y;
+  if (index_rest >= size_rest) {
+    return;
+  }
+
+  auto shape_x = shape[ndim - 1];
+  auto stride_x = strides[ndim - 1];
+  IdxT index_x =
+      grid.block_index().x * block.dim_threads().x + block.thread_index().x;
+  auto idx =
+      elem_to_loc(index_rest * shape_x, shape.data(), strides.data(), ndim);
+  auto in_vec =
+      load_vector<N_READS>(in + idx, index_x, shape_x, stride_x, In(0));
+  AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+  for (int i = 0; i < N_READS; ++i) {
+    out_vec[i] = CastOp<In, Out>{}(in_vec[i]);
+  }
+  store_vector(out + shape_x * index_rest, index_x, out_vec, shape_x);
+}
+
+} // namespace cu
+
+void copy_general_input(
+    cu::CommandEncoder& encoder,
+    CopyType ctype,
+    const array& in,
+    array& out,
+    int64_t offset_in,
+    int64_t offset_out,
+    const Shape& shape,
+    const Strides& strides_in) {
+  dispatch_all_types(in.dtype(), [&](auto in_type_tag) {
+    dispatch_all_types(out.dtype(), [&](auto out_type_tag) {
+      dispatch_bool(
+          in.data_size() > INT32_MAX || out.data_size() > INT32_MAX,
+          [&](auto large) {
+            using InType = cuda_type_t<MLX_GET_TYPE(in_type_tag)>;
+            using OutType = cuda_type_t<MLX_GET_TYPE(out_type_tag)>;
+            using IdxT = std::conditional_t<large(), int64_t, int32_t>;
+            const InType* in_ptr = in.data<InType>() + offset_in;
+            OutType* out_ptr = out.data<OutType>() + offset_out;
+            int ndim = shape.size();
+            int work_per_thread = 1;
+            auto dim0 = ndim > 0 ? shape.back() : 1;
+            auto rest = out.size() / dim0;
+            if (dim0 >= 4) {
+              work_per_thread = 4;
+            }
+            dim0 = (dim0 + work_per_thread - 1) / work_per_thread;
+            auto block_dims = get_block_dims(dim0, rest, 1);
+            uint32_t num_blocks_x = cuda::ceil_div(dim0, block_dims.x);
+            uint32_t num_blocks_y = cuda::ceil_div(rest, block_dims.y);
+
+            if (ndim <= 3) {
+              dispatch_1_2_3(ndim, [&](auto dims_constant) {
+                auto kernel =
+                    cu::copy_g_nd<InType, OutType, IdxT, dims_constant(), 1>;
+                if (work_per_thread == 4) {
+                  kernel =
+                      cu::copy_g_nd<InType, OutType, IdxT, dims_constant(), 4>;
+                }
+                encoder.add_kernel_node(
+                    kernel,
+                    {num_blocks_x, num_blocks_y},
+                    block_dims,
+                    0,
+                    in_ptr,
+                    out_ptr,
+                    rest,
+                    const_param<dims_constant()>(shape),
+                    const_param<dims_constant()>(strides_in));
+              });
+            } else { // ndim >= 4
+              auto kernel = cu::copy_g<InType, OutType, IdxT, 1>;
+              if (work_per_thread == 4) {
+                kernel = cu::copy_g<InType, OutType, IdxT, 4>;
+              }
+              encoder.add_kernel_node(
+                  kernel,
+                  {num_blocks_x, num_blocks_y},
+                  block_dims,
+                  0,
+                  in_ptr,
+                  out_ptr,
+                  rest,
+                  const_param(shape),
+                  const_param(strides_in),
+                  ndim);
+            }
+          });
+    });
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ceb4d7dfef98140f00656d806666d501588e3aed
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.cpp
@@ -0,0 +1,11 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/cuda.h"
+
+namespace mlx::core::cu {
+
+bool is_available() {
+  return true;
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c6a5c724b9f468d718b84e168b4eea8bfef8294
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/cuda.h
@@ -0,0 +1,10 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+namespace mlx::core::cu {
+
+/* Check if the CUDA backend is available. */
+bool is_available();
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/cudnn_utils.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/cudnn_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4fc1128915a4d8a05a641c2e106bdede6d3824f5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/cudnn_utils.cpp
@@ -0,0 +1,272 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/cudnn_utils.h"
+#include "mlx/backend/cuda/device.h"
+
+namespace mlx::core {
+
+namespace {
+
+// Create a cudnn tensor descriptor.
+template <typename Vec>
+inline cudnn_frontend::Tensor build_cudnn_tensor(
+    int64_t id,
+    const array& x,
+    const Vec& shape,
+    const Vec& strides) {
+  return cudnn_frontend::TensorBuilder()
+      .setDim(shape.size(), shape.data())
+      .setStrides(strides.size(), strides.data())
+      .setId(id)
+      .setAlignment(get_alignment(x))
+      .setDataType(dtype_to_cudnn_type(x.dtype()))
+      .build();
+}
+
+// In MLX a singleton dim (shape[dim] == 1) can have any stride, but in cuDNN
+// whether a tensor is contiguous is determined with:
+// shape[dim] == shape[dim + 1] * strides[dim + 1]
+// So a contiguous array with singleton dims in MLX may be mistakenly treated
+// as strided in cuDNN, and we work around it by normalizing the strides.
+Strides normalized_strides(const array& x) {
+  if (!x.flags().row_contiguous || x.ndim() < 2) {
+    return x.strides();
+  }
+  Strides strides = x.strides();
+  for (int i = x.ndim() - 2; i >= 0; --i) {
+    if (x.shape(i) == 1) {
+      strides[i] = x.shape(i + 1) * strides[i + 1];
+    }
+  }
+  return strides;
+}
+
+// Return the shape and strides after transposing from NHWC to NCHW.
+auto nhwc_to_nchw(SmallVector<int64_t> shape, SmallVector<int64_t> strides) {
+  assert(shape.size() >= 3);
+  shape.insert(shape.begin() + 1, shape.back());
+  shape.erase(shape.end() - 1);
+  strides.insert(strides.begin() + 1, strides.back());
+  strides.erase(strides.end() - 1);
+  return std::make_tuple(std::move(shape), std::move(strides));
+}
+
+inline auto nhwc_to_nchw(const array& x) {
+  return nhwc_to_nchw(
+      convert_vector<int64_t>(x.shape()), normalized_strides(x));
+}
+
+// Return available engines for a |op_graph|.
+cudnn_frontend::EngineConfigList get_cudnn_engine_configs(
+    cudnnBackendDescriptorType_t backend_type,
+    Dtype dtype,
+    cudnn_frontend::OperationGraph& op_graph,
+    bool use_fallback = true) {
+  SmallVector<cudnn_frontend::GeneratorSource, 2> sources;
+  sources.push_back([](auto& op_graph) {
+    auto heuristics = cudnn_frontend::EngineHeuristicsBuilder()
+                          .setOperationGraph(op_graph)
+                          .setHeurMode(CUDNN_HEUR_MODE_A)
+                          .build();
+    return heuristics.getEngineConfig(heuristics.getEngineConfigCount());
+  });
+  if (use_fallback) {
+    sources.push_back([&backend_type](auto& op_graph) {
+      auto fallback = cudnn_frontend::EngineFallbackListBuilder()
+                          .setOperationGraph(op_graph)
+                          .setOperation(backend_type)
+                          .build();
+      return fallback.getFallbackList();
+    });
+  }
+
+  auto configs =
+      cudnn_frontend::EngineConfigGenerator(sources.size(), sources.data())
+          .generate_engine_config(op_graph);
+
+  cudnn_frontend::EngineConfigList filtered_configs;
+  cudnn_frontend::filter(configs, filtered_configs, [dtype](auto c) {
+    if (cudnn_frontend::hasNumericalNote<
+            CUDNN_NUMERICAL_NOTE_DOWN_CONVERT_INPUTS>(c)) {
+      return true;
+    }
+    if (cudnn_frontend::hasNumericalNote<CUDNN_NUMERICAL_NOTE_TENSOR_CORE>(c) &&
+        dtype == float32 && !env::enable_tf32()) {
+      return true;
+    }
+    return false;
+  });
+  return filtered_configs;
+}
+
+// Take |engine_configs| and |op_graph| and find a working execution plans
+// from them.
+std::optional<cudnn_frontend::ExecutionPlan>
+find_cudnn_plan_from_engine_configs(
+    cudnnHandle_t handle,
+    const cudnn_frontend::EngineConfigList& engine_configs,
+    const cudnn_frontend::OperationGraph& op_graph) {
+  auto op_graph_tag = op_graph.getTag();
+  for (const auto& config : engine_configs) {
+    try {
+      return cudnn_frontend::ExecutionPlanBuilder()
+          .setHandle(handle)
+          .setEngineConfig(config, op_graph_tag)
+          .build();
+    } catch (cudnn_frontend::cudnnException& error) {
+      if (error.getCudnnStatus() != CUDNN_STATUS_NOT_SUPPORTED) {
+        throw;
+      }
+    }
+  }
+  return std::nullopt;
+}
+
+// Prepare workspace and args to execute plan.
+template <typename F>
+bool prepare_cudnn_plan(
+    cu::CommandEncoder& encoder,
+    cudnn_frontend::ExecutionPlan& plan,
+    int num_args,
+    const int64_t* uids,
+    void** data_ptrs,
+    F&& execute) {
+  int workspace_size = plan.getWorkspaceSize();
+  array workspace(
+      workspace_size > 0 ? allocator::malloc(workspace_size)
+                         : allocator::Buffer(nullptr),
+      {workspace_size},
+      uint8);
+
+  auto args = cudnn_frontend::VariantPackBuilder()
+                  .setWorkspacePointer(workspace.data<void>())
+                  .setDataPointers(num_args, data_ptrs)
+                  .setUids(num_args, uids)
+                  .build();
+
+  auto handle = encoder.device().cudnn_handle();
+  cudnnSetStream(handle, encoder.stream());
+
+  if (!execute(handle, plan.get_raw_desc(), args.get_raw_desc())) {
+    return false;
+  }
+
+  encoder.add_temporary(workspace);
+  return true;
+}
+
+} // namespace
+
+cudnn_frontend::Tensor build_cudnn_tensor(int64_t id, const array& x) {
+  auto shape = convert_vector<int64_t>(x.shape());
+  return build_cudnn_tensor(id, x, shape, normalized_strides(x));
+}
+
+cudnn_frontend::Tensor build_cudnn_tensor_nchw(int64_t id, const array& x) {
+  auto [shape, strides] = nhwc_to_nchw(x);
+  return build_cudnn_tensor(id, x, shape, strides);
+}
+
+cudnn_frontend::Tensor build_cudnn_tensor_4d_nchw(int64_t id, const array& x) {
+  if (x.ndim() == 0) {
+    SmallVector<int64_t, 4> scalar_dims = {1, 1, 1, 1};
+    return build_cudnn_tensor(id, x, scalar_dims, scalar_dims);
+  }
+  if (x.ndim() == 1) {
+    int64_t s = x.shape(0);
+    SmallVector<int64_t, 4> shape = {1, x.shape(0), 1, 1};
+    SmallVector<int64_t, 4> strides = {s, 1, s, s};
+    return build_cudnn_tensor(id, x, shape, strides);
+  }
+  if (x.ndim() == 2) {
+    int64_t s =
+        x.flags().row_contiguous ? x.shape(1) * x.strides(1) : x.strides(0);
+    SmallVector<int64_t, 4> shape = {x.shape(0), x.shape(1), 1, 1};
+    SmallVector<int64_t, 4> strides = {s, x.strides(1), s, s};
+    return build_cudnn_tensor(id, x, shape, strides);
+  }
+  if (x.ndim() == 3 || x.ndim() == 4) {
+    return build_cudnn_tensor_nchw(id, x);
+  }
+  throw std::runtime_error(
+      fmt::format("Unsupported array with {} dims.", x.ndim()));
+}
+
+cudnn_frontend::Tensor build_cudnn_scalar_4d(int64_t id, Dtype dtype) {
+  SmallVector<int64_t, 4> scalar_dims = {1, 1, 1, 1};
+  return cudnn_frontend::TensorBuilder()
+      .setDim(scalar_dims.size(), scalar_dims.data())
+      .setStrides(scalar_dims.size(), scalar_dims.data())
+      .setId(id)
+      .setAlignment(16)
+      .setDataType(dtype_to_cudnn_type(dtype))
+      .setByValue(true)
+      .build();
+}
+
+std::optional<cudnn_frontend::ExecutionPlan> find_cudnn_plan_from_op_graph(
+    cudnnHandle_t handle,
+    cudnnBackendDescriptorType_t backend_type,
+    Dtype dtype,
+    cudnn_frontend::OperationGraph& op_graph) {
+  auto engine_configs = get_cudnn_engine_configs(backend_type, dtype, op_graph);
+  return find_cudnn_plan_from_engine_configs(handle, engine_configs, op_graph);
+}
+
+bool encode_cudnn_plan_with_capturing(
+    cu::CommandEncoder& encoder,
+    cudnn_frontend::ExecutionPlan& plan,
+    int num_args,
+    const int64_t* uids,
+    void** data_ptrs) {
+  return prepare_cudnn_plan(
+      encoder,
+      plan,
+      num_args,
+      uids,
+      data_ptrs,
+      [&](auto handle, auto plan, auto args) {
+        auto capture = encoder.capture_context();
+        if (cudnnBackendExecute(handle, plan, args) != CUDNN_STATUS_SUCCESS) {
+          // Discard the captured graph when failed.
+          capture.discard = true;
+          return false;
+        }
+        return true;
+      });
+}
+
+#if CUDNN_VERSION >= 90500
+bool encode_cudnn_plan_with_graph_api(
+    cu::CommandEncoder& encoder,
+    cudnn_frontend::ExecutionPlan& plan,
+    CudaGraph& graph,
+    int num_args,
+    const int64_t* uids,
+    void** data_ptrs) {
+  return prepare_cudnn_plan(
+      encoder,
+      plan,
+      num_args,
+      uids,
+      data_ptrs,
+      [&](auto handle, auto plan, auto args) {
+        if (!graph) {
+          graph = CudaGraph(encoder.device());
+          if (cudnnBackendPopulateCudaGraph(handle, plan, args, graph) !=
+              CUDNN_STATUS_SUCCESS) {
+            return false;
+          }
+        } else {
+          if (cudnnBackendUpdateCudaGraph(handle, plan, args, graph) !=
+              CUDNN_STATUS_SUCCESS) {
+            return false;
+          }
+        }
+        encoder.add_graph_node(graph);
+        return true;
+      });
+}
+#endif
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/cudnn_utils.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/cudnn_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..c35c5cac9aa3676cc8d33c8694db0fae9cd0dc2e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/cudnn_utils.h
@@ -0,0 +1,164 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+#include "mlx/backend/cuda/device/config.h"
+#include "mlx/backend/cuda/utils.h"
+#include "mlx/dtype_utils.h"
+
+#include <cudnn_frontend.h>
+#include <cudnn_frontend_find_plan.h>
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <array>
+
+namespace mlx::core {
+
+namespace cu {
+class CommandEncoder;
+}
+
+// Return pointer alignment of |x|'s data.
+inline uint8_t get_alignment(const array& x) {
+  uint8_t alignment = 1;
+  uintptr_t address = reinterpret_cast<uintptr_t>(x.data<void>());
+  for (; alignment < 32; alignment *= 2) {
+    if (address % (alignment * 2)) {
+      return alignment;
+    }
+  }
+  return alignment;
+}
+
+// Convert the type of elements in |vec| to |T|.
+template <typename T, typename Vec>
+inline SmallVector<T> convert_vector(const Vec& vec) {
+  return SmallVector<T>(vec.begin(), vec.end());
+}
+
+// Return an array that can be used as map key for |vec| with size <= MAX_NDIM.
+//
+// There are 2 differences from the const_param util from kernel_utils.cuh:
+// 1. The rest of array is filled with 0.
+// 2. This util can be used in .cpp files.
+template <typename T, template <typename U> class Vec>
+inline std::array<T, MAX_NDIM> vector_key(const Vec<T>& vec) {
+  if (vec.size() > MAX_NDIM) {
+    throw std::runtime_error(
+        fmt::format("ndim can not be larger than {}.", MAX_NDIM));
+  }
+  std::array<T, MAX_NDIM> result = {};
+  std::copy_n(vec.begin(), vec.size(), result.begin());
+  return result;
+}
+
+// Helpers used by get_data_ptrs to get pointers.
+inline void* get_data_ptr(const array& arr) {
+  return const_cast<void*>(arr.data<void>());
+}
+
+template <typename T, typename = std::enable_if_t<std::is_scalar_v<T>>>
+inline void* get_data_ptr(T& scalar) {
+  return &scalar;
+}
+
+// Return an array filled with data pointers of args.
+template <typename... Args>
+inline std::array<void*, sizeof...(Args)> get_data_ptrs(Args&... args) {
+  return {get_data_ptr(args)...};
+}
+
+// Map dtype to cudnn data type.
+inline cudnnDataType_t dtype_to_cudnn_type(Dtype dtype) {
+  switch (dtype) {
+    case int8:
+      return CUDNN_DATA_INT8;
+    case int32:
+      return CUDNN_DATA_INT32;
+    case uint8:
+      return CUDNN_DATA_UINT8;
+    case float16:
+      return CUDNN_DATA_HALF;
+    case bfloat16:
+      return CUDNN_DATA_BFLOAT16;
+    case float32:
+      return CUDNN_DATA_FLOAT;
+    case float64:
+      return CUDNN_DATA_DOUBLE;
+    default:
+      throw std::runtime_error(fmt::format(
+          "Unsupported dtype in Convolution: {}.", dtype_to_string(dtype)));
+  }
+}
+
+// Create a tensor descriptor from |x|.
+cudnn_frontend::Tensor build_cudnn_tensor(int64_t id, const array& x);
+
+// Create a tensor descriptor from |x|, and transpose from NHWC to NCHW.
+cudnn_frontend::Tensor build_cudnn_tensor_nchw(int64_t id, const array& x);
+
+// Create a tensor descriptor from |x|, make sure it is 4D, and transpose it
+// from NHWC to NCHW.
+cudnn_frontend::Tensor build_cudnn_tensor_4d_nchw(int64_t id, const array& x);
+
+// Create a 4D scalar tensor descriptor, which is passed by value.
+cudnn_frontend::Tensor build_cudnn_scalar_4d(int64_t id, Dtype dtype);
+
+// Find a working plan for |op_graph|.
+std::optional<cudnn_frontend::ExecutionPlan> find_cudnn_plan_from_op_graph(
+    cudnnHandle_t handle,
+    cudnnBackendDescriptorType_t backend_type,
+    Dtype dtype,
+    cudnn_frontend::OperationGraph& op_graph);
+
+// Encode the plan to command buffer by capturing.
+bool encode_cudnn_plan_with_capturing(
+    cu::CommandEncoder& encoder,
+    cudnn_frontend::ExecutionPlan& plan,
+    int num_args,
+    const int64_t* uids,
+    void** data_ptrs);
+
+#if CUDNN_VERSION >= 90500
+// Encode the plan to command buffer by using native graph api of cudnn. If the
+// |graph| is empty it will be populated, otherwise it will be updated.
+bool encode_cudnn_plan_with_graph_api(
+    cu::CommandEncoder& encoder,
+    cudnn_frontend::ExecutionPlan& plan,
+    CudaGraph& graph,
+    int num_args,
+    const int64_t* uids,
+    void** data_ptrs);
+#endif
+
+// Helpers to make calls like encode_cudnn_plan(..., {'x', 'y', 'z'}, x, y, z).
+template <typename... Args>
+bool encode_cudnn_plan(
+    cu::CommandEncoder& encoder,
+    cudnn_frontend::ExecutionPlan& plan,
+    std::initializer_list<int64_t> uids,
+    Args&... args) {
+  assert(uids.size() == sizeof...(args));
+  auto data_ptrs = get_data_ptrs(args...);
+  return encode_cudnn_plan_with_capturing(
+      encoder, plan, uids.size(), uids.begin(), data_ptrs.data());
+}
+
+#if CUDNN_VERSION >= 90500
+template <typename... Args>
+bool encode_cudnn_plan(
+    cu::CommandEncoder& encoder,
+    cudnn_frontend::ExecutionPlan& plan,
+    CudaGraph& graph,
+    std::initializer_list<int64_t> uids,
+    Args&... args) {
+  assert(uids.size() == sizeof...(args));
+  auto data_ptrs = get_data_ptrs(args...);
+  return encode_cudnn_plan_with_graph_api(
+      encoder, plan, graph, uids.size(), uids.begin(), data_ptrs.data());
+}
+#endif
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/custom_kernel.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/custom_kernel.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ee1778fd872a0a88f95fe2d8db7f466f947fd015
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/custom_kernel.cpp
@@ -0,0 +1,379 @@
+// Copyright © 2025 Apple Inc.
+
+#include <iostream>
+
+#include "mlx/backend/common/compiled.h"
+#include "mlx/backend/cuda/jit_module.h"
+#include "mlx/backend/cuda/utils.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/fast.h"
+#include "mlx/fast_primitives.h"
+
+#include <fmt/format.h>
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core::fast {
+
+namespace {
+
+constexpr const char* default_header = R"(
+#include "mlx/backend/cuda/device/utils.cuh"
+
+#include <cooperative_groups.h>
+
+#define inf cuda::std::numeric_limits<float>::infinity()
+
+)";
+
+std::string template_arguments_hash(
+    const std::vector<std::pair<std::string, TemplateArg>>& template_args) {
+  if (template_args.empty()) {
+    return "";
+  }
+
+  std::string hash;
+  hash.reserve(512);
+
+  for (const auto& [name, arg] : template_args) {
+    if (std::holds_alternative<int>(arg)) {
+      hash += fmt::format("_{}", std::get<int>(arg));
+    } else if (std::holds_alternative<bool>(arg)) {
+      hash += (std::get<bool>(arg)) ? "_t" : "_f";
+    } else if (std::holds_alternative<Dtype>(arg)) {
+      hash += "_";
+      hash += get_type_string(std::get<Dtype>(arg));
+    }
+  }
+
+  return hash;
+}
+
+std::string build_kernel(
+    const std::string& func_name,
+    const std::string& header,
+    const std::string& source,
+    const std::vector<std::string>& input_names,
+    const std::vector<array>& inputs,
+    const std::vector<std::string>& output_names,
+    const std::vector<Dtype>& output_dtypes,
+    const std::vector<std::pair<std::string, TemplateArg>>& template_args,
+    const std::vector<CustomKernelShapeInfo>& shape_infos) {
+  std::string kernel_source;
+  kernel_source.reserve(header.size() + source.size() + 8192);
+  kernel_source += default_header;
+  kernel_source += header;
+  kernel_source +=
+      "namespace mlx::core::cu {\n\n"
+      "namespace cg = cooperative_groups;\n\n";
+
+  kernel_source += "__global__ void ";
+  kernel_source += func_name;
+  kernel_source += "(\n";
+
+  // Add inputs
+  for (int i = 0; i < inputs.size(); ++i) {
+    const auto& name = input_names[i];
+    const auto& arr = inputs[i];
+    kernel_source += "    const ";
+    kernel_source += dtype_to_cuda_type(arr.dtype());
+    kernel_source += "* ";
+    kernel_source += name;
+    kernel_source += ",\n";
+    // Add input shape, strides and ndim if present in the source
+    if (arr.ndim() > 0) {
+      if (shape_infos[i].shape) {
+        kernel_source += "    const __grid_constant__ Shape ";
+        kernel_source += name;
+        kernel_source += "_shape,\n";
+      }
+      if (shape_infos[i].strides) {
+        kernel_source += "    const __grid_constant__ Strides ";
+        kernel_source += name;
+        kernel_source += "_strides,\n";
+      }
+      if (shape_infos[i].ndim) {
+        kernel_source += "    const __grid_constant__ int ";
+        kernel_source += name;
+        kernel_source += "_ndim,\n";
+      }
+    }
+  }
+
+  // Add outputs
+  for (int i = 0; i < output_names.size(); ++i) {
+    const auto& name = output_names[i];
+    const auto& dtype = output_dtypes[i];
+    kernel_source += "    ";
+    kernel_source += dtype_to_cuda_type(dtype);
+    kernel_source += "* ";
+    kernel_source += name;
+    if (i < output_names.size() - 1) {
+      kernel_source += ",\n";
+    } else {
+      kernel_source += ") {\n";
+    }
+  }
+
+  // Set compile time constants
+  if (!template_args.empty()) {
+    for (const auto& [name, arg] : template_args) {
+      if (std::holds_alternative<int>(arg)) {
+        kernel_source +=
+            fmt::format("  constexpr int {} = {};\n", name, std::get<int>(arg));
+      } else if (std::holds_alternative<bool>(arg)) {
+        kernel_source += fmt::format(
+            "  constexpr bool {} = {};\n", name, std::get<bool>(arg));
+      } else {
+        kernel_source += fmt::format(
+            "  using {} = {};\n",
+            name,
+            dtype_to_cuda_type(std::get<Dtype>(arg)));
+      }
+    }
+    kernel_source += "\n";
+  }
+
+  kernel_source += source;
+  kernel_source += "\n}\n\n} // namespace mlx::core::cu\n";
+
+  return kernel_source;
+}
+
+} // namespace
+
+CustomKernelFunction cuda_kernel(
+    const std::string& name,
+    const std::vector<std::string>& input_names,
+    const std::vector<std::string>& output_names,
+    const std::string& source,
+    const std::string& header,
+    bool ensure_row_contiguous,
+    int shared_memory) {
+  if (output_names.empty()) {
+    throw std::invalid_argument(
+        "[custom_kernel] Must specify at least one output.");
+  }
+
+  std::vector<CustomKernelShapeInfo> shape_infos;
+  for (auto& n : input_names) {
+    CustomKernelShapeInfo shape_info;
+    shape_info.shape = source.find(n + "_shape") != std::string::npos;
+    shape_info.strides = source.find(n + "_strides") != std::string::npos;
+    shape_info.ndim = source.find(n + "_ndim") != std::string::npos;
+    shape_infos.push_back(shape_info);
+  }
+
+  return [=, shape_infos = std::move(shape_infos)](
+             const std::vector<array>& inputs,
+             const std::vector<Shape>& output_shapes,
+             const std::vector<Dtype>& output_dtypes,
+             std::tuple<int, int, int> grid,
+             std::tuple<int, int, int> threadgroup,
+             const std::vector<std::pair<std::string, TemplateArg>>&
+                 template_args = {},
+             std::optional<float> init_value = std::nullopt,
+             bool verbose = false,
+             StreamOrDevice s_ = {}) {
+    if (inputs.size() != input_names.size()) {
+      std::ostringstream msg;
+      msg << "[custom_kernel] Expected `inputs` to have size "
+          << input_names.size() << " but got size " << inputs.size() << "."
+          << std::endl;
+      throw std::invalid_argument(msg.str());
+    }
+    if (output_shapes.size() != output_names.size()) {
+      std::ostringstream msg;
+      msg << "[custom_kernel] Expected `output_shapes` to have size "
+          << output_names.size() << " but got size " << output_shapes.size()
+          << "." << std::endl;
+      throw std::invalid_argument(msg.str());
+    }
+    if (output_dtypes.size() != output_names.size()) {
+      std::ostringstream msg;
+      msg << "[custom_kernel] Expected `output_dtypes` to have size "
+          << output_names.size() << " but got size " << output_dtypes.size()
+          << "." << std::endl;
+      throw std::invalid_argument(msg.str());
+    }
+
+    auto s = to_stream(s_);
+    if (s.device != Device::gpu) {
+      throw std::invalid_argument("[custom_kernel] Only supports the GPU.");
+    }
+
+    std::string kernel_name =
+        "custom_kernel_" + name + template_arguments_hash(template_args);
+    std::string kernel_source = build_kernel(
+        kernel_name,
+        header,
+        source,
+        input_names,
+        inputs,
+        output_names,
+        output_dtypes,
+        template_args,
+        shape_infos);
+
+    if (verbose) {
+      std::cout << "Generated source code for `" << kernel_name
+                << "`:" << std::endl
+                << "```" << std::endl
+                << kernel_source << std::endl
+                << "```" << std::endl;
+    }
+
+    return array::make_arrays(
+        std::move(output_shapes),
+        std::move(output_dtypes),
+        std::make_shared<CustomKernel>(
+            s,
+            std::move(kernel_name),
+            std::move(kernel_source),
+            grid,
+            threadgroup,
+            shape_infos,
+            ensure_row_contiguous,
+            init_value,
+            std::vector<ScalarArg>{},
+            false,
+            shared_memory),
+        std::move(inputs));
+  };
+}
+
+std::vector<array> precompiled_cuda_kernel(
+    const std::string& name,
+    const std::string& compiled_source,
+    const std::vector<array>& inputs,
+    const std::vector<Shape>& output_shapes,
+    const std::vector<Dtype>& output_dtypes,
+    const std::vector<ScalarArg>& scalars,
+    std::tuple<int, int, int> grid,
+    std::tuple<int, int, int> threadgroup,
+    int shared_memory,
+    std::optional<float> init_value,
+    bool ensure_row_contiguous,
+    StreamOrDevice s) {
+  std::vector<CustomKernelShapeInfo> shape_infos(
+      inputs.size(), CustomKernelShapeInfo{false, false, false});
+  return array::make_arrays(
+      output_shapes,
+      output_dtypes,
+      std::make_shared<CustomKernel>(
+          to_stream(s),
+          name,
+          compiled_source,
+          grid,
+          threadgroup,
+          shape_infos,
+          ensure_row_contiguous,
+          init_value,
+          scalars,
+          true,
+          shared_memory),
+      inputs);
+}
+
+void CustomKernel::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  nvtx3::scoped_range r("CustomKernel::eval_gpu");
+  auto& s = stream();
+
+  std::vector<array> copies;
+
+  // Allocate and initialize the output arrays
+  for (auto& out : outputs) {
+    if (init_value_) {
+      copies.emplace_back(init_value_.value(), out.dtype());
+      fill_gpu(copies.back(), out, s);
+    } else {
+      out.set_data(allocator::malloc(out.nbytes()));
+    }
+  }
+
+  // Create the input arrays and copy if needed
+  auto check_input = [&copies, &s, this](const array& x) -> const array {
+    bool no_copy = x.flags().row_contiguous;
+    if (!ensure_row_contiguous_ || no_copy) {
+      return x;
+    } else {
+      copies.push_back(array(x.shape(), x.dtype(), nullptr, {}));
+      copy_gpu(x, copies.back(), CopyType::General, s);
+      return copies.back();
+    }
+  };
+  std::vector<array> checked_inputs;
+  for (const array& in : inputs) {
+    checked_inputs.push_back(check_input(in));
+  }
+
+  // Compile the custom kernel
+  std::string kernel_name =
+      (is_precompiled_) ? name_ : "mlx::core::cu::" + name_;
+  cu::JitModule& mod = cu::get_jit_module(
+      s.device,
+      name_,
+      [&]() {
+        return std::make_tuple(
+            is_precompiled_, source_, std::vector{kernel_name});
+      },
+      false);
+
+  // Make the arguments
+  cu::KernelArgs args;
+  for (int i = 0; i < checked_inputs.size(); i++) {
+    const array& in = checked_inputs[i];
+    auto& shape_info = shape_infos_[i];
+    args.append(in);
+    if (shape_info.shape) {
+      args.append_ndim(in.shape());
+    }
+    if (shape_info.strides) {
+      args.append_ndim(in.strides());
+    }
+    if (shape_info.ndim) {
+      args.append<int32_t>(in.ndim());
+    }
+  }
+  for (auto& out : outputs) {
+    args.append(out);
+  }
+  for (auto& s : scalar_arguments_) {
+    if (std::holds_alternative<bool>(s)) {
+      args.append(std::get<bool>(s));
+    } else if (std::holds_alternative<int>(s)) {
+      args.append(std::get<int>(s));
+    } else if (std::holds_alternative<float>(s)) {
+      args.append(std::get<float>(s));
+    }
+  }
+
+  // Make the grid
+  const auto [tx, ty, tz] = threadgroup_;
+  const auto [gx, gy, gz] = grid_;
+  dim3 block(std::min(tx, gx), std::min(ty, gy), std::min(tz, gz));
+  dim3 grid((gx + tx - 1) / tx, (gy + ty - 1) / ty, (gz + tz - 1) / tz);
+
+  // Call the kernel
+  auto& encoder = cu::get_command_encoder(s);
+  for (const auto& in : checked_inputs) {
+    encoder.set_input_array(in);
+  }
+  for (const auto& out : outputs) {
+    encoder.set_output_array(out);
+  }
+  for (const auto& t : copies) {
+    encoder.add_temporary(t);
+  }
+  auto kernel =
+      mod.get_kernel(kernel_name, [smem = shared_memory_](CUfunction kernel) {
+        if (smem > 0 && smem > 48000) {
+          cuFuncSetAttribute(
+              kernel, CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES, smem);
+        }
+      });
+  encoder.add_kernel_node(kernel, grid, block, shared_memory_, args.args());
+}
+
+} // namespace mlx::core::fast
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/device.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7d0da0580fd8b4253c85746b5229bd27aaac6559
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device.cpp
@@ -0,0 +1,392 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/jit_module.h"
+#include "mlx/backend/cuda/worker.h"
+#include "mlx/utils.h"
+
+#include <fmt/format.h>
+#include <nvtx3/nvtx3.hpp>
+#include <future>
+#include <unordered_set>
+
+namespace mlx::core::cu {
+
+namespace {
+
+#define CHECK_CUDNN_ERROR(cmd) check_cudnn_error(#cmd, (cmd))
+
+void check_cudnn_error(const char* name, cudnnStatus_t err) {
+  if (err != CUDNN_STATUS_SUCCESS) {
+    throw std::runtime_error(
+        fmt::format("{} failed: {}.", name, cudnnGetErrorString(err)));
+  }
+}
+
+bool use_cuda_graphs() {
+  static bool use_graphs = []() {
+    return env::get_var("MLX_USE_CUDA_GRAPHS", true);
+  }();
+  return use_graphs;
+}
+
+} // namespace
+
+Device::Device(int device) : device_(device) {
+  CHECK_CUDA_ERROR(cudaDeviceGetAttribute(
+      &compute_capability_major_, cudaDevAttrComputeCapabilityMajor, device_));
+  CHECK_CUDA_ERROR(cudaDeviceGetAttribute(
+      &compute_capability_minor_, cudaDevAttrComputeCapabilityMinor, device_));
+  // Validate the requirements of device.
+  int attr = 0;
+  CHECK_CUDA_ERROR(cudaDeviceGetAttribute(
+      &attr, cudaDevAttrConcurrentManagedAccess, device_));
+  if (attr != 1) {
+    throw std::runtime_error(fmt::format(
+        "Device {} does not support synchronization in managed memory.",
+        device_));
+  }
+  // The cublasLt handle is used by matmul.
+  make_current();
+  CHECK_CUBLAS_ERROR(cublasLtCreate(&lt_));
+  // The cudnn handle is used by Convolution.
+  CHECK_CUDNN_ERROR(cudnnCreate(&cudnn_));
+
+  // Initialize the jit module cache here ensures it is not
+  // unloaded before any evaluation is done
+  get_jit_module_cache();
+}
+
+Device::~Device() {
+  CHECK_CUDNN_ERROR(cudnnDestroy(cudnn_));
+  CHECK_CUBLAS_ERROR(cublasLtDestroy(lt_));
+}
+
+void Device::make_current() {
+  // We need to set/get current CUDA device very frequently, cache it to reduce
+  // actual calls of CUDA APIs.
+  static thread_local int current = 0;
+  if (current != device_) {
+    CHECK_CUDA_ERROR(cudaSetDevice(device_));
+    current = device_;
+  }
+}
+
+CommandEncoder& Device::get_command_encoder(Stream s) {
+  auto it = encoders_.find(s.index);
+  if (it == encoders_.end()) {
+    it = encoders_.try_emplace(s.index, *this).first;
+  }
+  return it->second;
+}
+
+CommandEncoder::CaptureContext::CaptureContext(CommandEncoder& enc) : enc(enc) {
+  enc.device().make_current();
+  if (!use_cuda_graphs()) {
+    return;
+  }
+  CHECK_CUDA_ERROR(
+      cudaStreamBeginCapture(enc.stream(), cudaStreamCaptureModeGlobal));
+}
+
+CommandEncoder::CaptureContext::~CaptureContext() {
+  if (!use_cuda_graphs()) {
+    enc.node_count_++;
+    return;
+  }
+
+  graph.end_capture(enc.stream());
+  if (discard) {
+    return;
+  }
+  enc.add_graph_node(graph);
+}
+
+CommandEncoder::ConcurrentContext::ConcurrentContext(CommandEncoder& enc)
+    : enc(enc) {
+  enc.in_concurrent_ = true;
+}
+
+CommandEncoder::ConcurrentContext::~ConcurrentContext() {
+  enc.in_concurrent_ = false;
+  if (!use_cuda_graphs()) {
+    return;
+  }
+
+  // Use an empty graph node for synchronization
+  CommandEncoder::GraphNode empty{NULL, 'E', std::to_string(enc.node_count_++)};
+  enc.empty_node_count_++;
+  CHECK_CUDA_ERROR(cudaGraphAddEmptyNode(&empty.node, enc.graph_, NULL, 0));
+
+  // Insert the concurrent -> empty node dependencies
+  for (auto& from : enc.concurrent_nodes_) {
+    enc.from_nodes_.push_back(from.node);
+    enc.to_nodes_.push_back(empty.node);
+    enc.graph_key_ += from.id;
+    enc.graph_key_ += from.node_type;
+    enc.graph_key_ += empty.id;
+    enc.graph_key_ += empty.node_type;
+  }
+
+  // Insert the input -> concurrent node dependencies without updating output
+  // nodes
+  auto outputs = std::move(enc.active_outputs_);
+  enc.insert_graph_dependencies(std::move(enc.concurrent_nodes_));
+
+  // Update output node to be the empty node
+  for (auto o : outputs) {
+    enc.node_map_.emplace(o, empty).first->second = empty;
+  }
+}
+
+void CommandEncoder::insert_graph_dependencies(GraphNode node) {
+  if (node.node_type == 'G') {
+    graph_node_count_++;
+  }
+  node.id = std::to_string(node_count_++);
+  if (in_concurrent_) {
+    concurrent_nodes_.push_back(std::move(node));
+  } else {
+    std::vector<GraphNode> nodes;
+    nodes.push_back(std::move(node));
+    insert_graph_dependencies(std::move(nodes));
+  }
+}
+
+void CommandEncoder::insert_graph_dependencies(std::vector<GraphNode> nodes) {
+  std::vector<GraphNode> deps;
+  {
+    // Dependencies must be added in the same order to produce a consistent
+    // topology
+    std::unordered_set<cudaGraphNode_t> set_deps;
+    for (auto d : active_deps_) {
+      if (auto it = node_map_.find(d); it != node_map_.end()) {
+        auto [_, inserted] = set_deps.insert(it->second.node);
+        if (inserted) {
+          deps.push_back(it->second);
+        }
+      }
+    }
+  }
+  active_deps_.clear();
+
+  for (auto o : active_outputs_) {
+    for (auto& node : nodes) {
+      node_map_.emplace(o, node).first->second = node;
+    }
+  }
+  active_outputs_.clear();
+
+  for (auto& from : deps) {
+    for (auto& to : nodes) {
+      from_nodes_.push_back(from.node);
+      to_nodes_.push_back(to.node);
+      graph_key_ += from.id;
+      graph_key_ += from.node_type;
+      graph_key_ += to.id;
+      graph_key_ += to.node_type;
+    }
+  }
+}
+
+CommandEncoder::CommandEncoder(Device& d)
+    : device_(d),
+      stream_(d),
+      graph_(d),
+      worker_(d),
+      graph_cache_("MLX_CUDA_GRAPH_CACHE_SIZE", /* default_capacity */ 400) {}
+
+void CommandEncoder::add_completed_handler(std::function<void()> task) {
+  worker_.add_task(std::move(task));
+}
+
+void CommandEncoder::set_input_array(const array& arr) {
+  if (!use_cuda_graphs()) {
+    return;
+  }
+  auto id = reinterpret_cast<std::uintptr_t>(arr.buffer().ptr());
+  active_deps_.push_back(id);
+}
+
+void CommandEncoder::set_output_array(const array& arr) {
+  if (!use_cuda_graphs()) {
+    return;
+  }
+
+  auto id = reinterpret_cast<std::uintptr_t>(arr.buffer().ptr());
+  active_deps_.push_back(id);
+  active_outputs_.push_back(id);
+}
+
+void CommandEncoder::add_kernel_node(
+    void* func,
+    dim3 grid_dim,
+    dim3 block_dim,
+    uint32_t smem_bytes,
+    void** params) {
+  if (!use_cuda_graphs()) {
+    node_count_++;
+    CHECK_CUDA_ERROR(cudaLaunchKernel(
+        func, grid_dim, block_dim, params, smem_bytes, stream()));
+    return;
+  }
+  cudaKernelNodeParams kernel_params = {0};
+  kernel_params.func = func;
+  kernel_params.gridDim = grid_dim;
+  kernel_params.blockDim = block_dim;
+  kernel_params.kernelParams = params;
+  kernel_params.sharedMemBytes = smem_bytes;
+  add_kernel_node(kernel_params);
+}
+
+void CommandEncoder::add_kernel_node(
+    CUfunction func,
+    dim3 grid_dim,
+    dim3 block_dim,
+    uint32_t smem_bytes,
+    void** params) {
+  if (!use_cuda_graphs()) {
+    node_count_++;
+    CHECK_CUDA_ERROR(cuLaunchKernel(
+        func,
+        grid_dim.x,
+        grid_dim.y,
+        grid_dim.z,
+        block_dim.x,
+        block_dim.y,
+        block_dim.z,
+        smem_bytes,
+        stream(),
+        params,
+        nullptr));
+    return;
+  }
+
+  CUDA_KERNEL_NODE_PARAMS kernel_params = {0};
+  kernel_params.func = func;
+  kernel_params.gridDimX = grid_dim.x;
+  kernel_params.gridDimY = grid_dim.y;
+  kernel_params.gridDimZ = grid_dim.z;
+  kernel_params.blockDimX = block_dim.x;
+  kernel_params.blockDimY = block_dim.y;
+  kernel_params.blockDimZ = block_dim.z;
+  kernel_params.kernelParams = params;
+  kernel_params.sharedMemBytes = smem_bytes;
+  add_kernel_node(kernel_params);
+}
+
+void CommandEncoder::add_kernel_node(const cudaKernelNodeParams& params) {
+  cudaGraphNode_t node;
+  CHECK_CUDA_ERROR(cudaGraphAddKernelNode(&node, graph_, NULL, 0, &params));
+  insert_graph_dependencies(GraphNode{node, 'K'});
+}
+
+void CommandEncoder::add_kernel_node(const CUDA_KERNEL_NODE_PARAMS& params) {
+  CUgraphNode node;
+  CHECK_CUDA_ERROR(cuGraphAddKernelNode(&node, graph_, NULL, 0, &params));
+  insert_graph_dependencies(GraphNode{node, 'K'});
+}
+
+void CommandEncoder::add_graph_node(cudaGraph_t child) {
+  if (!use_cuda_graphs()) {
+    node_count_++;
+    CudaGraphExec graph_exec;
+    graph_exec.instantiate(child);
+    device_.make_current();
+    CHECK_CUDA_ERROR(cudaGraphLaunch(graph_exec, stream()));
+    return;
+  }
+  cudaGraphNode_t node;
+  CHECK_CUDA_ERROR(cudaGraphAddChildGraphNode(&node, graph_, NULL, 0, child));
+  insert_graph_dependencies(GraphNode{node, 'G'});
+}
+
+int CommandEncoder::get_num_ops() {
+  return node_count_;
+}
+
+void CommandEncoder::commit() {
+  nvtx3::scoped_range r("CommandEncoder::commit");
+  if (!temporaries_.empty()) {
+    add_completed_handler([temporaries = std::move(temporaries_)]() {});
+  }
+  if (use_cuda_graphs() && node_count_ > 0) {
+    if (!from_nodes_.empty()) {
+      CHECK_CUDA_ERROR(cudaGraphAddDependencies(
+          graph_,
+          from_nodes_.data(),
+          to_nodes_.data(),
+#if CUDART_VERSION >= 13000
+          nullptr, // edgeData
+#endif // CUDART_VERSION >= 13000
+          from_nodes_.size()));
+    }
+
+    graph_key_ += ".";
+    graph_key_ += std::to_string(node_count_);
+    graph_key_ += ".";
+    graph_key_ += std::to_string(graph_node_count_);
+    graph_key_ += ".";
+    graph_key_ += std::to_string(empty_node_count_);
+
+    CudaGraphExec& graph_exec = graph_cache_[graph_key_];
+
+    if (graph_exec != nullptr) {
+      cudaGraphExecUpdateResult update_result;
+#if CUDART_VERSION >= 12000
+      cudaGraphExecUpdateResultInfo info;
+      cudaGraphExecUpdate(graph_exec, graph_, &info);
+      update_result = info.result;
+#else
+      cudaGraphNode_t error_node;
+      cudaGraphExecUpdate(graph_exec, graph_, &error_node, &update_result);
+#endif // CUDART_VERSION >= 12000
+      if (update_result != cudaGraphExecUpdateSuccess) {
+        cudaGetLastError(); // reset error
+        graph_exec.reset();
+      }
+    }
+    if (graph_exec == nullptr) {
+      graph_exec.instantiate(graph_);
+    }
+    device_.make_current();
+    CHECK_CUDA_ERROR(cudaGraphLaunch(graph_exec, stream_));
+
+    // Reset state
+    graph_node_count_ = 0;
+    empty_node_count_ = 0;
+    from_nodes_.clear();
+    to_nodes_.clear();
+    graph_key_.clear();
+    node_map_.clear();
+    graph_ = CudaGraph(device_);
+  }
+
+  // Put completion handlers in a batch.
+  worker_.commit(stream_);
+  node_count_ = 0;
+}
+
+void CommandEncoder::synchronize() {
+  cudaStreamSynchronize(stream_);
+  auto p = std::make_shared<std::promise<void>>();
+  std::future<void> f = p->get_future();
+  add_completed_handler([p = std::move(p)]() { p->set_value(); });
+  commit();
+  f.wait();
+}
+
+Device& device(mlx::core::Device device) {
+  static std::unordered_map<int, Device> devices;
+  auto it = devices.find(device.index);
+  if (it == devices.end()) {
+    it = devices.try_emplace(device.index, device.index).first;
+  }
+  return it->second;
+}
+
+CommandEncoder& get_command_encoder(Stream s) {
+  return device(s.device).get_command_encoder(s);
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/device.h
new file mode 100644
index 0000000000000000000000000000000000000000..d1809232855677fb4d6f7dd8c5f888ea83dc3c8a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device.h
@@ -0,0 +1,183 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+#include "mlx/backend/cuda/lru_cache.h"
+#include "mlx/backend/cuda/worker.h"
+#include "mlx/stream.h"
+
+#include <cublasLt.h>
+#include <cuda.h>
+#include <cudnn.h>
+#include <thrust/execution_policy.h>
+
+#include <unordered_map>
+
+namespace mlx::core::cu {
+
+class CommandEncoder {
+ public:
+  struct CaptureContext {
+    CaptureContext(CommandEncoder& enc);
+    ~CaptureContext();
+    CudaGraph graph;
+    CommandEncoder& enc;
+    bool discard{false};
+  };
+  struct ConcurrentContext {
+    ConcurrentContext(CommandEncoder& enc);
+    ~ConcurrentContext();
+    CommandEncoder& enc;
+  };
+
+  explicit CommandEncoder(Device& d);
+
+  CommandEncoder(const CommandEncoder&) = delete;
+  CommandEncoder& operator=(const CommandEncoder&) = delete;
+
+  CaptureContext capture_context() {
+    return CaptureContext{*this};
+  }
+  ConcurrentContext concurrent_context() {
+    return ConcurrentContext{*this};
+  }
+
+  void set_input_array(const array& arr);
+  void set_output_array(const array& arr);
+
+  template <typename F, typename... Params>
+  void add_kernel_node(
+      F* func,
+      dim3 grid_dim,
+      dim3 block_dim,
+      uint32_t smem_bytes,
+      Params&&... params) {
+    constexpr size_t num = sizeof...(Params);
+    void* ptrs[num];
+    size_t i = 0;
+    ([&](auto&& p) { ptrs[i++] = static_cast<void*>(&p); }(
+         std::forward<Params>(params)),
+     ...);
+    add_kernel_node((void*)func, grid_dim, block_dim, smem_bytes, ptrs);
+  }
+
+  void add_kernel_node(
+      CUfunction func,
+      dim3 grid_dim,
+      dim3 block_dim,
+      uint32_t smem_bytes,
+      void** params);
+
+  void add_kernel_node(
+      void* func,
+      dim3 grid_dim,
+      dim3 block_dim,
+      uint32_t smem_bytes,
+      void** params);
+
+  void add_graph_node(cudaGraph_t child);
+
+  void add_temporary(const array& arr) {
+    temporaries_.push_back(arr.data_shared_ptr());
+  }
+
+  void add_completed_handler(std::function<void()> task);
+  int get_num_ops();
+  void commit();
+
+  Device& device() {
+    return device_;
+  }
+
+  CudaStream& stream() {
+    return stream_;
+  }
+
+  // Wait until kernels and completion handlers are finished
+  void synchronize();
+
+ private:
+  void add_kernel_node(const cudaKernelNodeParams& params);
+  void add_kernel_node(const CUDA_KERNEL_NODE_PARAMS& params);
+
+  struct GraphNode {
+    cudaGraphNode_t node;
+    // K = kernel
+    // E = empty
+    // G = subgraph
+    char node_type;
+    std::string id;
+  };
+
+  void insert_graph_dependencies(GraphNode node);
+  void insert_graph_dependencies(std::vector<GraphNode> nodes);
+
+  Device& device_;
+  CudaStream stream_;
+  CudaGraph graph_;
+  Worker worker_;
+  char node_count_{0};
+  char graph_node_count_{0};
+  char empty_node_count_{0};
+  bool in_concurrent_{false};
+  std::vector<cudaGraphNode_t> from_nodes_;
+  std::vector<cudaGraphNode_t> to_nodes_;
+  std::string graph_key_;
+  std::vector<GraphNode> concurrent_nodes_;
+  std::vector<std::shared_ptr<array::Data>> temporaries_;
+  LRUCache<std::string, CudaGraphExec> graph_cache_;
+  std::vector<std::uintptr_t> active_deps_;
+  std::vector<std::uintptr_t> active_outputs_;
+  std::unordered_map<std::uintptr_t, GraphNode> node_map_;
+};
+
+class Device {
+ public:
+  explicit Device(int device);
+  ~Device();
+
+  Device(const Device&) = delete;
+  Device& operator=(const Device&) = delete;
+
+  // Make this device the current cuda device, this method is thread-safe.
+  void make_current();
+
+  CommandEncoder& get_command_encoder(Stream s);
+
+  int cuda_device() const {
+    return device_;
+  }
+  int compute_capability_major() const {
+    return compute_capability_major_;
+  }
+  int compute_capability_minor() const {
+    return compute_capability_minor_;
+  }
+  cublasLtHandle_t lt_handle() const {
+    return lt_;
+  }
+  cudnnHandle_t cudnn_handle() const {
+    return cudnn_;
+  }
+
+ private:
+  int device_;
+  int compute_capability_major_;
+  int compute_capability_minor_;
+  cublasLtHandle_t lt_;
+  cudnnHandle_t cudnn_;
+  std::unordered_map<int, CommandEncoder> encoders_;
+};
+
+Device& device(mlx::core::Device device);
+CommandEncoder& get_command_encoder(Stream s);
+
+// Return an execution policy that does not sync for result.
+// Note that not all thrust APIs support async policy, confirm before using.
+inline auto thrust_policy(cudaStream_t stream) {
+  // TODO: Connect thrust's custom allocator with mlx's allocator.
+  return thrust::cuda::par_nosync.on(stream);
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/atomic_ops.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/atomic_ops.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..cfb185c439bc74168bddf7c3da9a24179b6875e1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/atomic_ops.cuh
@@ -0,0 +1,63 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cuda/device/complex.cuh"
+#include "mlx/backend/cuda/device/fp16_math.cuh"
+
+#include <cuda/atomic>
+
+namespace mlx::core::cu {
+
+template <typename T>
+inline __device__ void atomic_add(T* out, T val) {
+  cuda::atomic_ref<T, cuda::thread_scope_device> ref(*out);
+  ref += val;
+}
+
+template <typename T>
+inline __device__ void atomic_prod(T* out, T val) {
+  cuda::atomic_ref<T, cuda::thread_scope_device> ref(*out);
+  T old = ref.load();
+  while (!ref.compare_exchange_strong(old, old * val)) {
+  }
+}
+
+template <typename T>
+inline __device__ void atomic_max(T* out, T val) {
+  cuda::atomic_ref<T, cuda::thread_scope_device> ref(*out);
+  ref.fetch_max(val);
+}
+
+template <typename T>
+inline __device__ void atomic_min(T* out, T val) {
+  cuda::atomic_ref<T, cuda::thread_scope_device> ref(*out);
+  ref.fetch_min(val);
+}
+
+// Somehow cuda::atomic_ref does not provide atomic add for following types.
+template <typename T>
+inline __device__ void atomic_add_general(T* out, T val) {
+  cuda::atomic_ref<T, cuda::thread_scope_device> ref(*out);
+  T old = ref.load();
+  while (!ref.compare_exchange_strong(old, old + val)) {
+  }
+}
+
+inline __device__ void atomic_add(__half* out, __half val) {
+  atomicAdd(out, val);
+}
+
+inline __device__ void atomic_add(complex64_t* out, complex64_t val) {
+  atomic_add_general(out, val);
+}
+
+inline __device__ void atomic_add(__nv_bfloat16* out, __nv_bfloat16 val) {
+#if __CUDA_ARCH__ < 800
+  atomic_add_general(out, val);
+#else
+  atomicAdd(out, val);
+#endif
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/binary_ops.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/binary_ops.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..1ff22cff89c63435e27442a1177206f108830ecb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/binary_ops.cuh
@@ -0,0 +1,299 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device/unary_ops.cuh"
+
+#include <cuda/std/array>
+
+namespace mlx::core::cu {
+
+struct Add {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    return x + y;
+  }
+};
+
+struct FloorDivide {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    if constexpr (cuda::std::is_integral_v<T>) {
+      return x / y;
+    } else {
+      return truncf(x / y);
+    }
+  }
+};
+
+struct Divide {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    return x / y;
+  }
+};
+
+struct Remainder {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    if constexpr (cuda::std::is_integral_v<T>) {
+      if constexpr (cuda::std::is_signed_v<T>) {
+        auto r = x % y;
+        if (r != 0 && (r < 0 != y < 0)) {
+          r += y;
+        }
+        return r;
+      } else {
+        return x % y;
+      }
+    } else if constexpr (is_complex_v<T>) {
+      return x % y;
+    } else {
+      T r = fmod(x, y);
+      if (r != 0 && (r < 0 != y < 0)) {
+        r = r + y;
+      }
+      return r;
+    }
+  }
+};
+
+struct Equal {
+  template <typename T>
+  __device__ bool operator()(T x, T y) {
+    return x == y;
+  }
+};
+
+struct NaNEqual {
+  template <typename T>
+  __device__ bool operator()(T x, T y) {
+    if constexpr (is_complex_v<T>) {
+      return x == y ||
+          (isnan(x.real()) && isnan(y.real()) && isnan(x.imag()) &&
+           isnan(y.imag())) ||
+          (x.real() == y.real() && isnan(x.imag()) && isnan(y.imag())) ||
+          (isnan(x.real()) && isnan(y.real()) && x.imag() == y.imag());
+    } else {
+      return x == y || (isnan(x) && isnan(y));
+    }
+  }
+};
+
+struct Greater {
+  template <typename T>
+  __device__ bool operator()(T x, T y) {
+    return x > y;
+  }
+};
+
+struct GreaterEqual {
+  template <typename T>
+  __device__ bool operator()(T x, T y) {
+    return x >= y;
+  }
+};
+
+struct Less {
+  template <typename T>
+  __device__ bool operator()(T x, T y) {
+    return x < y;
+  }
+};
+
+struct LessEqual {
+  template <typename T>
+  __device__ bool operator()(T x, T y) {
+    return x <= y;
+  }
+};
+
+struct LogAddExp {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    if constexpr (is_complex_v<T>) {
+      if (isnan(x.real()) || isnan(x.imag()) || isnan(y.real()) ||
+          isnan(y.imag())) {
+        return {
+            cuda::std::numeric_limits<float>::quiet_NaN(),
+            cuda::std::numeric_limits<float>::quiet_NaN()};
+      }
+      auto max = x.real() > y.real() ? x : y;
+      auto min = x.real() < y.real() ? x : y;
+      auto min_real = min.real();
+      auto max_real = max.real();
+      if (!isfinite(min_real) && (min_real == max_real)) {
+        if (min_real < 0) {
+          return min;
+        } else {
+          return Log{}(Exp{}(min) + Exp{}(max));
+        }
+      } else {
+        return Log1p{}(Exp{}(min - max)) + max;
+      }
+    } else {
+      if (isnan(x) || isnan(y)) {
+        return cuda::std::numeric_limits<T>::quiet_NaN();
+      }
+      T maxval = max(x, y);
+      T minval = min(x, y);
+      return (minval == -cuda::std::numeric_limits<T>::infinity() ||
+              maxval == cuda::std::numeric_limits<T>::infinity())
+          ? maxval
+          : T(float(maxval) + log1p(expf(minval - maxval)));
+    }
+  };
+};
+
+struct Maximum {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    if constexpr (cuda::std::is_integral_v<T>) {
+      return max(x, y);
+    } else if constexpr (is_complex_v<T>) {
+      if (isnan(x.real()) || isnan(x.imag())) {
+        return x;
+      }
+      return x > y ? x : y;
+    } else {
+      if (isnan(x)) {
+        return x;
+      }
+      return x > y ? x : y;
+    }
+  }
+};
+
+struct Minimum {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    if constexpr (cuda::std::is_integral_v<T>) {
+      return min(x, y);
+    } else if constexpr (is_complex_v<T>) {
+      if (isnan(x.real()) || isnan(x.imag())) {
+        return x;
+      }
+      return x < y ? x : y;
+    } else {
+      if (isnan(x)) {
+        return x;
+      }
+      return x < y ? x : y;
+    }
+  }
+};
+
+struct Multiply {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    return x * y;
+  }
+};
+
+struct NotEqual {
+  template <typename T>
+  __device__ bool operator()(T x, T y) {
+    if constexpr (is_complex_v<T>) {
+      return x.real() != y.real() || x.imag() != y.imag();
+    } else {
+      return x != y;
+    }
+  }
+};
+
+struct Power {
+  template <typename T>
+  __device__ T operator()(T base, T exp) {
+    if constexpr (cuda::std::is_integral_v<T>) {
+      T res = 1;
+      // Raising an integer to a negative power is undefined
+      if constexpr (cuda::std::is_signed_v<T>) {
+        if (exp < 0) {
+          return 0;
+        }
+      }
+      while (exp) {
+        if (exp & 1) {
+          res *= base;
+        }
+        exp >>= 1;
+        base *= base;
+      }
+      return res;
+    } else if constexpr (is_complex_v<T>) {
+      return pow(base, exp);
+    } else {
+      return powf(base, exp);
+    }
+  }
+};
+
+struct Subtract {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    return x - y;
+  }
+};
+
+struct LogicalAnd {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    return x && y;
+  };
+};
+
+struct LogicalOr {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    return x || y;
+  };
+};
+
+struct BitwiseAnd {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    return x & y;
+  };
+};
+
+struct BitwiseOr {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    return x | y;
+  };
+};
+
+struct BitwiseXor {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    return x ^ y;
+  };
+};
+
+struct LeftShift {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    return x << y;
+  };
+};
+
+struct RightShift {
+  template <typename T>
+  __device__ T operator()(T x, T y) {
+    return x >> y;
+  };
+};
+
+struct ArcTan2 {
+  template <typename T>
+  __device__ T operator()(T y, T x) {
+    return atan2f(y, x);
+  }
+};
+
+struct DivMod {
+  template <typename T>
+  __device__ cuda::std::array<T, 2> operator()(T x, T y) {
+    return {FloorDivide{}(x, y), Remainder{}(x, y)};
+  };
+};
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/cast_op.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/cast_op.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..b85a40c83d4ccb746805b94ce13209a214c84e08
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/cast_op.cuh
@@ -0,0 +1,118 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cuda/device/complex.cuh"
+
+#include <cuda_bf16.h>
+#include <cuda_fp16.h>
+
+namespace mlx::core::cu {
+
+// An op that does static_cast, with custom conversions for some types.
+template <typename SrcT, typename DstT, typename = void>
+struct CastOp {
+  static constexpr bool is_castable = cuda::std::is_convertible_v<SrcT, DstT>;
+
+  __device__ DstT operator()(SrcT x) {
+    return static_cast<DstT>(x);
+  }
+};
+
+// Castings between complex and boolean.
+template <typename T>
+struct CastOp<complex_t<T>, bool> {
+  static constexpr bool is_castable = true;
+
+  __device__ bool operator()(complex_t<T> x) {
+    return x.real() != 0 && x.imag() != 0;
+  }
+};
+
+template <typename T>
+struct CastOp<bool, complex_t<T>> {
+  static constexpr bool is_castable = true;
+
+  __device__ complex_t<T> operator()(bool x) {
+    return x ? complex_t<T>{1, 1} : complex_t<T>{0, 0};
+  }
+};
+
+// Converting a complex number to real number discards the imaginary part.
+template <typename T, typename DstT>
+struct CastOp<complex_t<T>, DstT, cuda::std::enable_if_t<!is_complex_v<DstT>>> {
+  static constexpr bool is_castable = cuda::std::is_convertible_v<T, DstT>;
+
+  __device__ DstT operator()(complex_t<T> x) {
+    static_assert(!is_complex_v<DstT>);
+    return static_cast<DstT>(x.real());
+  }
+};
+
+// Allow converting a real number to complex number.
+template <typename SrcT, typename T>
+struct CastOp<SrcT, complex_t<T>, cuda::std::enable_if_t<!is_complex_v<SrcT>>> {
+  static constexpr bool is_castable = cuda::std::is_convertible_v<SrcT, T>;
+
+  __device__ complex_t<T> operator()(SrcT x) {
+    static_assert(!is_complex_v<SrcT>);
+    return complex_t<T>{static_cast<T>(x), 0};
+  }
+};
+
+// Do nothing when no casting is needed.
+template <typename SrcT, typename DstT>
+struct CastOp<
+    SrcT,
+    DstT,
+    cuda::std::enable_if_t<cuda::std::is_same_v<SrcT, DstT>>> {
+  static constexpr bool is_castable = true;
+
+  __device__ SrcT operator()(SrcT x) {
+    return x;
+  }
+};
+
+// In CUDA 11 the half types do not define conversions between some types,
+// provide fallbacks here.
+#if CUDART_VERSION < 12000
+template <typename SrcT, typename DstT>
+struct CastOp<
+    SrcT,
+    DstT,
+    cuda::std::enable_if_t<
+        !cuda::std::is_convertible_v<SrcT, DstT> && !is_complex_v<SrcT> &&
+        (cuda::std::is_same_v<DstT, __half> ||
+         cuda::std::is_same_v<DstT, __nv_bfloat16>)>> {
+  static constexpr bool is_castable = true;
+
+  __device__ DstT operator()(SrcT x) {
+    return DstT(static_cast<float>(x));
+  }
+};
+
+template <typename SrcT, typename DstT>
+struct CastOp<
+    SrcT,
+    DstT,
+    cuda::std::enable_if_t<
+        !cuda::std::is_convertible_v<SrcT, DstT> && !is_complex_v<SrcT> &&
+        !cuda::std::is_same_v<DstT, __half> &&
+        !cuda::std::is_same_v<DstT, __nv_bfloat16> &&
+        (cuda::std::is_same_v<SrcT, __half> ||
+         cuda::std::is_same_v<SrcT, __nv_bfloat16>)>> {
+  static constexpr bool is_castable = true;
+
+  __device__ DstT operator()(SrcT x) {
+    return DstT(static_cast<float>(x));
+  }
+};
+#endif // CUDART_VERSION < 12000
+
+// Helper to deduce the SrcT.
+template <typename DstT, typename SrcT>
+inline __host__ __device__ auto cast_to(SrcT x) {
+  return CastOp<SrcT, DstT>{}(x);
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/complex.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/complex.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..03a7bff83fc35f32cca6e16bfcac6c02f2146608
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/complex.cuh
@@ -0,0 +1,60 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+// Make multiplication and division faster.
+#define LIBCUDACXX_ENABLE_SIMPLIFIED_COMPLEX_OPERATIONS
+
+#include <cuda/std/complex>
+#include <cuda/std/type_traits>
+
+namespace mlx::core::cu {
+
+// TODO: Consider using a faster implementation as cuda::std::complex has to
+// conform to C++ standard.
+template <typename T>
+using complex_t = cuda::std::complex<T>;
+
+using complex64_t = complex_t<float>;
+using complex128_t = complex_t<double>;
+
+template <typename T>
+struct is_complex : cuda::std::false_type {};
+
+template <typename T>
+struct is_complex<cuda::std::complex<T>> : cuda::std::true_type {};
+
+template <typename T>
+inline constexpr bool is_complex_v = is_complex<T>::value;
+
+// cuda::std::complex is missing some operators.
+template <typename T>
+inline __host__ __device__ complex_t<T> operator%(
+    complex_t<T> a,
+    complex_t<T> b) {
+  T r = a.real() - floor(a.real() / b.real()) * b.real();
+  T i = a.imag() - floor(a.imag() / b.imag()) * b.imag();
+  return complex_t<T>{r, i};
+}
+
+template <typename T>
+inline __host__ __device__ bool operator>(complex_t<T> a, complex_t<T> b) {
+  return (a.real() > b.real()) || (a.real() == b.real() && a.imag() > b.imag());
+}
+
+template <typename T>
+inline __host__ __device__ bool operator<(complex_t<T> a, complex_t<T> b) {
+  return operator>(b, a);
+}
+
+template <typename T>
+inline __host__ __device__ bool operator<=(complex_t<T> a, complex_t<T> b) {
+  return !(a > b);
+}
+
+template <typename T>
+inline __host__ __device__ bool operator>=(complex_t<T> a, complex_t<T> b) {
+  return !(a < b);
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/config.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/config.h
new file mode 100644
index 0000000000000000000000000000000000000000..5a3402905a4e682efe861030381a2cab61313d7e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/config.h
@@ -0,0 +1,12 @@
+// Copyright © 2025 Apple Inc.
+
+// This file is used by both CUDA kernel code and host-only C++ code.
+
+#pragma once
+
+// The maximum dimensions of shape/strides passed as kernel parameters.
+#define MAX_NDIM 10
+
+// All existing NVIDIA hardware has a fixed 32 warp size. Though a built-in
+// warpSize variable exists, using it would prevent compile-time optimizations.
+#define WARP_SIZE 32
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/fp16_math.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/fp16_math.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..f6fa17bb99c136747bf668fe74ffcdedbb0efec9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/fp16_math.cuh
@@ -0,0 +1,194 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include <cuda_bf16.h>
+#include <cuda_fp16.h>
+#include <cuda/std/limits>
+#include <cuda/std/type_traits>
+
+namespace mlx::core::cu {
+
+///////////////////////////////////////////////////////////////////////////////
+// Unary ops for half types.
+///////////////////////////////////////////////////////////////////////////////
+
+#if CUDART_VERSION < 12000 && __CUDA_ARCH__ < 800
+#define MLX_DEFINE_UNARY_OP(NAME, HALF_OP)           \
+  template <typename T>                              \
+  __forceinline__ __device__ auto NAME(T x) {        \
+    if constexpr (cuda::std::is_same_v<T, __half>) { \
+      return HALF_OP(x);                             \
+    } else {                                         \
+      return ::NAME(x);                              \
+    }                                                \
+  }
+#else
+#define MLX_DEFINE_UNARY_OP(NAME, HALF_OP)                         \
+  template <typename T>                                            \
+  __forceinline__ __device__ auto NAME(T x) {                      \
+    if constexpr (cuda::std::is_same_v<T, __half>) {               \
+      return HALF_OP(x);                                           \
+    } else if constexpr (cuda::std::is_same_v<T, __nv_bfloat16>) { \
+      return HALF_OP(x);                                           \
+    } else {                                                       \
+      return ::NAME(x);                                            \
+    }                                                              \
+  }
+#endif
+
+#define MLX_DEFINE_UNARY_OP_FALLBCK(NAME)                          \
+  template <typename T>                                            \
+  __forceinline__ __device__ auto NAME(T x) {                      \
+    if constexpr (cuda::std::is_same_v<T, __half>) {               \
+      return ::NAME(__half2float(x));                              \
+    } else if constexpr (cuda::std::is_same_v<T, __nv_bfloat16>) { \
+      return ::NAME(__bfloat162float(x));                          \
+    } else {                                                       \
+      return ::NAME(x);                                            \
+    }                                                              \
+  }
+
+MLX_DEFINE_UNARY_OP(abs, __habs)
+MLX_DEFINE_UNARY_OP(ceil, hceil)
+MLX_DEFINE_UNARY_OP(cos, hcos)
+MLX_DEFINE_UNARY_OP(exp, hexp)
+MLX_DEFINE_UNARY_OP(floor, hfloor)
+MLX_DEFINE_UNARY_OP(isnan, __hisnan)
+MLX_DEFINE_UNARY_OP(log, hlog)
+MLX_DEFINE_UNARY_OP(log2, hlog2)
+MLX_DEFINE_UNARY_OP(log10, hlog10)
+MLX_DEFINE_UNARY_OP(rint, hrint)
+MLX_DEFINE_UNARY_OP(rsqrt, hrsqrt)
+MLX_DEFINE_UNARY_OP(sin, hsin)
+MLX_DEFINE_UNARY_OP(sqrt, hsqrt)
+MLX_DEFINE_UNARY_OP_FALLBCK(acos)
+MLX_DEFINE_UNARY_OP_FALLBCK(acosh)
+MLX_DEFINE_UNARY_OP_FALLBCK(asin)
+MLX_DEFINE_UNARY_OP_FALLBCK(asinh)
+MLX_DEFINE_UNARY_OP_FALLBCK(atan)
+MLX_DEFINE_UNARY_OP_FALLBCK(atanh)
+MLX_DEFINE_UNARY_OP_FALLBCK(cosh)
+MLX_DEFINE_UNARY_OP_FALLBCK(log1p)
+MLX_DEFINE_UNARY_OP_FALLBCK(sinh)
+MLX_DEFINE_UNARY_OP_FALLBCK(tan)
+#if __CUDA_ARCH__ >= 1280
+MLX_DEFINE_UNARY_OP(tanh, htanh)
+#else
+MLX_DEFINE_UNARY_OP_FALLBCK(tanh)
+#endif
+
+#undef MLX_DEFINE_UNARY_OP
+#undef MLX_DEFINE_UNARY_OP_FALLBCK
+
+///////////////////////////////////////////////////////////////////////////////
+// Binary ops for half types.
+///////////////////////////////////////////////////////////////////////////////
+
+#if CUDART_VERSION < 12000 && __CUDA_ARCH__ < 800
+#define MLX_DEFINE_BINARY_OP(NAME, HALF_OP)          \
+  template <typename T>                              \
+  __forceinline__ __device__ auto NAME(T x, T y) {   \
+    if constexpr (cuda::std::is_same_v<T, __half>) { \
+      return HALF_OP(x, y);                          \
+    } else {                                         \
+      return ::NAME(x, y);                           \
+    }                                                \
+  }
+#else
+#define MLX_DEFINE_BINARY_OP(NAME, HALF_OP)                        \
+  template <typename T>                                            \
+  __forceinline__ __device__ auto NAME(T x, T y) {                 \
+    if constexpr (cuda::std::is_same_v<T, __half>) {               \
+      return HALF_OP(x, y);                                        \
+    } else if constexpr (cuda::std::is_same_v<T, __nv_bfloat16>) { \
+      return HALF_OP(x, y);                                        \
+    } else {                                                       \
+      return ::NAME(x, y);                                         \
+    }                                                              \
+  }
+#endif
+
+MLX_DEFINE_BINARY_OP(max, __hmax)
+MLX_DEFINE_BINARY_OP(min, __hmin)
+
+#undef MLX_DEFINE_BINARY_OP
+
+template <typename T>
+__forceinline__ __device__ T fmod(T x, T y) {
+  if constexpr (cuda::std::is_same_v<T, __half>) {
+    return __float2half(::fmod(__half2float(x), __half2float(y)));
+#if CUDART_VERSION >= 12000 || __CUDA_ARCH__ >= 800
+  } else if constexpr (cuda::std::is_same_v<T, __nv_bfloat16>) {
+    return __float2bfloat16(::fmod(__bfloat162float(x), __bfloat162float(y)));
+#endif
+  } else {
+    return ::fmod(x, y);
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Additional C++ operator overrides between half types and native types.
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, typename U>
+constexpr bool is_integral_except =
+    cuda::std::is_integral_v<T> && !cuda::std::is_same_v<T, U>;
+
+template <typename T, typename U>
+constexpr bool is_arithmetic_except =
+    cuda::std::is_arithmetic_v<T> && !cuda::std::is_same_v<T, U>;
+
+#define MLX_DEFINE_HALF_OP(HALF, HALF2FLOAT, FLOAT2HALF, OP)          \
+  template <                                                          \
+      typename T,                                                     \
+      typename = cuda::std::enable_if_t<is_integral_except<T, HALF>>> \
+  __forceinline__ __device__ HALF operator OP(HALF x, T y) {          \
+    return FLOAT2HALF(HALF2FLOAT(x) OP static_cast<float>(y));        \
+  }                                                                   \
+  template <                                                          \
+      typename T,                                                     \
+      typename = cuda::std::enable_if_t<is_integral_except<T, HALF>>> \
+  __forceinline__ __device__ HALF operator OP(T x, HALF y) {          \
+    return FLOAT2HALF(static_cast<float>(x) OP HALF2FLOAT(y));        \
+  }
+
+#define MLX_DEFINE_HALF_CMP(HALF, HALF2FLOAT, OP)                       \
+  template <                                                            \
+      typename T,                                                       \
+      typename = cuda::std::enable_if_t<is_arithmetic_except<T, HALF>>> \
+  __forceinline__ __device__ bool operator OP(HALF x, T y) {            \
+    return HALF2FLOAT(x) OP static_cast<float>(y);                      \
+  }                                                                     \
+  template <                                                            \
+      typename T,                                                       \
+      typename = cuda::std::enable_if_t<is_arithmetic_except<T, HALF>>> \
+  __forceinline__ __device__ bool operator OP(T x, HALF y) {            \
+    return static_cast<float>(y) OP HALF2FLOAT(x);                      \
+  }
+
+MLX_DEFINE_HALF_OP(__half, __half2float, __float2half, +)
+MLX_DEFINE_HALF_OP(__half, __half2float, __float2half, -)
+MLX_DEFINE_HALF_OP(__half, __half2float, __float2half, *)
+MLX_DEFINE_HALF_OP(__half, __half2float, __float2half, /)
+MLX_DEFINE_HALF_OP(__nv_bfloat16, __bfloat162float, __float2bfloat16, +)
+MLX_DEFINE_HALF_OP(__nv_bfloat16, __bfloat162float, __float2bfloat16, -)
+MLX_DEFINE_HALF_OP(__nv_bfloat16, __bfloat162float, __float2bfloat16, *)
+MLX_DEFINE_HALF_OP(__nv_bfloat16, __bfloat162float, __float2bfloat16, /)
+MLX_DEFINE_HALF_CMP(__half, __half2float, <)
+MLX_DEFINE_HALF_CMP(__half, __half2float, >)
+MLX_DEFINE_HALF_CMP(__half, __half2float, <=)
+MLX_DEFINE_HALF_CMP(__half, __half2float, >=)
+MLX_DEFINE_HALF_CMP(__half, __half2float, ==)
+MLX_DEFINE_HALF_CMP(__half, __half2float, !=)
+MLX_DEFINE_HALF_CMP(__nv_bfloat16, __bfloat162float, <)
+MLX_DEFINE_HALF_CMP(__nv_bfloat16, __bfloat162float, >)
+MLX_DEFINE_HALF_CMP(__nv_bfloat16, __bfloat162float, <=)
+MLX_DEFINE_HALF_CMP(__nv_bfloat16, __bfloat162float, >=)
+MLX_DEFINE_HALF_CMP(__nv_bfloat16, __bfloat162float, ==)
+MLX_DEFINE_HALF_CMP(__nv_bfloat16, __bfloat162float, !=)
+
+#undef MLX_DEFINE_HALF_OP
+#undef MLX_DEFINE_HALF_CMP
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/gather.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/gather.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..7dbd84ac320212521ead2778b692364abf9f32b6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/gather.cuh
@@ -0,0 +1,53 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device/indexing.cuh"
+#include "mlx/backend/cuda/device/utils.cuh"
+
+#include <cooperative_groups.h>
+
+namespace mlx::core::cu {
+
+namespace cg = cooperative_groups;
+
+template <typename T, typename IdxT, int NIDX, int IDX_NDIM, typename LocT>
+__global__ void gather(
+    const T* src,
+    T* out,
+    LocT size,
+    const __grid_constant__ Shape src_shape,
+    const __grid_constant__ Strides src_strides,
+    int32_t src_ndim,
+    const __grid_constant__ Shape slice_sizes,
+    uint32_t slice_size,
+    const __grid_constant__ cuda::std::array<int32_t, NIDX> axes,
+    const __grid_constant__ cuda::std::array<IdxT*, NIDX> indices,
+    const __grid_constant__ cuda::std::array<int32_t, NIDX * IDX_NDIM>
+        indices_shape,
+    const __grid_constant__ cuda::std::array<int64_t, NIDX * IDX_NDIM>
+        indices_strides) {
+  LocT out_idx = cg::this_grid().thread_rank();
+  if (out_idx >= size) {
+    return;
+  }
+
+  LocT src_elem = out_idx % slice_size;
+  LocT idx_elem = out_idx / slice_size;
+
+  LocT src_loc =
+      elem_to_loc(src_elem, slice_sizes.data(), src_strides.data(), src_ndim);
+
+#pragma unroll
+  for (int i = 0; i < NIDX; ++i) {
+    LocT idx_loc = elem_to_loc_nd<IDX_NDIM>(
+        idx_elem,
+        indices_shape.data() + i * IDX_NDIM,
+        indices_strides.data() + i * IDX_NDIM);
+    int32_t axis = axes[i];
+    LocT idx_val = absolute_index(indices[i][idx_loc], src_shape[axis]);
+    src_loc += idx_val * src_strides[axis];
+  }
+
+  out[out_idx] = src[src_loc];
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/gather_axis.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/gather_axis.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..f863b2d9510347cac562093eba5c2582d6a8929a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/gather_axis.cuh
@@ -0,0 +1,65 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device/indexing.cuh"
+#include "mlx/backend/cuda/device/utils.cuh"
+
+#include <cooperative_groups.h>
+
+namespace mlx::core::cu {
+
+namespace cg = cooperative_groups;
+
+template <
+    typename T,
+    typename IdxT,
+    int NDIM,
+    bool SrcC,
+    bool IdxC,
+    typename LocT>
+__global__ void gather_axis(
+    const T* src,
+    const IdxT* indices,
+    T* out,
+    LocT idx_size_pre,
+    LocT idx_size_axis,
+    LocT idx_size_post,
+    const __grid_constant__ cuda::std::array<int32_t, NDIM> shape,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> src_strides,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> idx_strides,
+    int32_t axis,
+    int32_t axis_size,
+    int64_t src_stride_axis,
+    int64_t idx_stride_axis) {
+  LocT index = cg::this_grid().thread_rank();
+  if (index >= idx_size_pre * idx_size_axis * idx_size_post) {
+    return;
+  }
+
+  auto [x, y, z] = index_to_dims(index, idx_size_axis, idx_size_pre);
+
+  LocT elem_idx = z * idx_size_post;
+
+  LocT idx_loc = y * idx_stride_axis;
+  if constexpr (IdxC) {
+    idx_loc += elem_idx * idx_size_axis + x;
+  } else {
+    idx_loc +=
+        elem_to_loc_nd<NDIM>(elem_idx + x, shape.data(), idx_strides.data());
+  }
+
+  auto idx_val = absolute_index(indices[idx_loc], axis_size);
+
+  LocT src_loc = idx_val * src_stride_axis;
+  if constexpr (SrcC) {
+    src_loc += elem_idx * axis_size + x;
+  } else {
+    src_loc +=
+        elem_to_loc_nd<NDIM>(elem_idx + x, shape.data(), src_strides.data());
+  }
+
+  LocT out_idx = y * idx_size_post + elem_idx * idx_size_axis + x;
+
+  out[out_idx] = src[src_loc];
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/indexing.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/indexing.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..31cba1a9078bcb37db9b2f71c6c13a05b11fccab
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/indexing.cuh
@@ -0,0 +1,30 @@
+// Copyright © 2025 Apple Inc.
+
+#include <cuda/std/tuple>
+#include <cuda/std/type_traits>
+
+namespace mlx::core::cu {
+
+// Convert an absolute index to positions in a 3d grid, assuming the index is
+// calculated with:
+// index = x * dim1 * dim2 + y * dim2 + z
+template <typename T>
+inline __host__ __device__ cuda::std::tuple<T, T, T>
+index_to_dims(T index, T dim1, T dim2) {
+  T x = index / (dim1 * dim2);
+  T y = (index % (dim1 * dim2)) / dim2;
+  T z = index % dim2;
+  return cuda::std::make_tuple(x, y, z);
+}
+
+// Get absolute index from possible negative index.
+template <typename IdxT>
+inline __host__ __device__ auto absolute_index(IdxT idx, int32_t size) {
+  if constexpr (cuda::std::is_unsigned_v<IdxT>) {
+    return idx;
+  } else {
+    return static_cast<int32_t>(idx < 0 ? idx + size : idx);
+  }
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/scatter.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/scatter.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..b2f6403505a8fe2c7f67c9ceced76c8d8235ea7c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/scatter.cuh
@@ -0,0 +1,68 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device/indexing.cuh"
+#include "mlx/backend/cuda/device/scatter_ops.cuh"
+#include "mlx/backend/cuda/device/utils.cuh"
+
+#include <cooperative_groups.h>
+
+namespace mlx::core::cu {
+
+namespace cg = cooperative_groups;
+
+template <
+    typename T,
+    typename IdxT,
+    typename Op,
+    int NIDX,
+    int IDX_NDIM,
+    typename LocT>
+__global__ void scatter(
+    const T* upd,
+    T* out,
+    LocT size,
+    const __grid_constant__ Shape upd_shape,
+    const __grid_constant__ Strides upd_strides,
+    int32_t upd_ndim,
+    LocT upd_post_idx_size,
+    const __grid_constant__ Shape out_shape,
+    const __grid_constant__ Strides out_strides,
+    int32_t out_ndim,
+    const __grid_constant__ cuda::std::array<int32_t, NIDX> axes,
+    const __grid_constant__ cuda::std::array<IdxT*, NIDX> indices,
+    const __grid_constant__ cuda::std::array<int32_t, NIDX * IDX_NDIM>
+        indices_shape,
+    const __grid_constant__ cuda::std::array<int64_t, NIDX * IDX_NDIM>
+        indices_strides) {
+  LocT upd_idx = cg::this_grid().thread_rank();
+  if (upd_idx >= size) {
+    return;
+  }
+
+  LocT out_elem = upd_idx % upd_post_idx_size;
+  LocT idx_elem = upd_idx / upd_post_idx_size;
+
+  LocT out_idx = elem_to_loc(
+      out_elem, upd_shape.data() + IDX_NDIM, out_strides.data(), out_ndim);
+
+#pragma unroll
+  for (int i = 0; i < NIDX; ++i) {
+    LocT idx_loc = elem_to_loc_nd<IDX_NDIM>(
+        idx_elem,
+        indices_shape.data() + i * IDX_NDIM,
+        indices_strides.data() + i * IDX_NDIM);
+    int32_t axis = axes[i];
+    LocT idx_val = absolute_index(indices[i][idx_loc], out_shape[axis]);
+    out_idx += idx_val * out_strides[axis];
+  }
+
+  LocT upd_loc = elem_to_loc(
+      out_elem + idx_elem * upd_post_idx_size,
+      upd_shape.data(),
+      upd_strides.data(),
+      upd_ndim);
+
+  Op{}(out + out_idx, upd[upd_loc]);
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/scatter_axis.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/scatter_axis.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..1f30f2ebdd1f1785e85c8e17c1cdf28f044e4f5c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/scatter_axis.cuh
@@ -0,0 +1,67 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device/indexing.cuh"
+#include "mlx/backend/cuda/device/scatter_ops.cuh"
+#include "mlx/backend/cuda/device/utils.cuh"
+
+#include <cooperative_groups.h>
+
+namespace mlx::core::cu {
+
+namespace cg = cooperative_groups;
+
+template <
+    typename T,
+    typename IdxT,
+    typename Op,
+    int NDIM,
+    bool UpdC,
+    bool IdxC,
+    typename LocT>
+__global__ void scatter_axis(
+    const T* upd,
+    const IdxT* indices,
+    T* out,
+    LocT idx_size_pre,
+    LocT idx_size_axis,
+    LocT idx_size_post,
+    const __grid_constant__ cuda::std::array<int32_t, NDIM> shape,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> upd_strides,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> idx_strides,
+    int32_t axis,
+    int32_t axis_size,
+    int64_t upd_stride_axis,
+    int64_t idx_stride_axis) {
+  LocT index = cg::this_grid().thread_rank();
+  if (index >= idx_size_pre * idx_size_axis * idx_size_post) {
+    return;
+  }
+
+  auto [x, y, z] = index_to_dims(index, idx_size_axis, idx_size_pre);
+
+  LocT elem_idx = z * idx_size_post;
+
+  LocT idx_loc = y * idx_stride_axis;
+  if constexpr (IdxC) {
+    idx_loc += elem_idx * idx_size_axis + x;
+  } else {
+    idx_loc +=
+        elem_to_loc_nd<NDIM>(elem_idx + x, shape.data(), idx_strides.data());
+  }
+
+  auto idx_val = absolute_index(indices[idx_loc], axis_size);
+
+  LocT upd_loc = y * upd_stride_axis;
+  if constexpr (UpdC) {
+    upd_loc += elem_idx * idx_size_axis + x;
+  } else {
+    upd_loc +=
+        elem_to_loc_nd<NDIM>(elem_idx + x, shape.data(), upd_strides.data());
+  }
+
+  LocT out_idx = idx_val * idx_size_post + elem_idx * axis_size + x;
+
+  Op{}(out + out_idx, upd[upd_loc]);
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/scatter_ops.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/scatter_ops.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..d88f896ad234c03944da1c9ba4e1fd165d08d4a8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/scatter_ops.cuh
@@ -0,0 +1,44 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cuda/device/atomic_ops.cuh"
+
+namespace mlx::core::cu {
+
+struct ScatterAssign {
+  template <typename T>
+  __device__ void operator()(T* out, T val) const {
+    *out = val;
+  }
+};
+
+struct ScatterSum {
+  template <typename T>
+  __device__ void operator()(T* out, T val) const {
+    atomic_add(out, val);
+  }
+};
+
+struct ScatterProd {
+  template <typename T>
+  __device__ void operator()(T* out, T val) const {
+    atomic_prod(out, val);
+  }
+};
+
+struct ScatterMax {
+  template <typename T>
+  __device__ void operator()(T* out, T val) const {
+    atomic_max(out, val);
+  }
+};
+
+struct ScatterMin {
+  template <typename T>
+  __device__ void operator()(T* out, T val) const {
+    atomic_min(out, val);
+  }
+};
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/ternary_ops.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/ternary_ops.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..44184547171953261654023543722ef869269899
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/ternary_ops.cuh
@@ -0,0 +1,13 @@
+// Copyright © 2025 Apple Inc.
+#pragma once
+
+namespace mlx::core::cu {
+
+struct Select {
+  template <typename T>
+  __device__ T operator()(bool condition, T x, T y) {
+    return condition ? x : y;
+  }
+};
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/unary_ops.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/unary_ops.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..aebed1e4d3d0f1d987635e96c236bc15d1e7454a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/unary_ops.cuh
@@ -0,0 +1,337 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cuda/device/fp16_math.cuh"
+#include "mlx/backend/cuda/device/utils.cuh"
+
+#include <math_constants.h>
+
+namespace mlx::core::cu {
+
+struct Abs {
+  template <typename T>
+  __device__ T operator()(T x) {
+    if constexpr (cuda::std::is_unsigned_v<T>) {
+      return x;
+    } else {
+      return abs(x);
+    }
+  }
+};
+
+struct ArcCos {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return acos(x);
+  }
+};
+
+struct ArcCosh {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return acosh(x);
+  }
+};
+
+struct ArcSin {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return asin(x);
+  }
+};
+
+struct ArcSinh {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return asinh(x);
+  }
+};
+
+struct ArcTan {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return atan(x);
+  }
+};
+
+struct ArcTanh {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return atanh(x);
+  }
+};
+
+struct BitwiseInvert {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return ~x;
+  }
+};
+
+struct Ceil {
+  template <typename T>
+  __device__ T operator()(T x) {
+    if constexpr (cuda::std::is_integral_v<T>) {
+      return x;
+    } else if constexpr (is_complex_v<T>) {
+      return T{ceil(x.real()), ceil(x.imag())};
+    } else {
+      return ceil(x);
+    }
+  }
+};
+
+struct Conjugate {
+  template <typename T>
+  __device__ complex_t<T> operator()(complex_t<T> x) {
+    return conj(x);
+  }
+};
+
+struct Cos {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return cos(x);
+  }
+};
+
+struct Cosh {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return cosh(x);
+  }
+};
+
+struct Erf {
+  template <typename T>
+  __device__ T operator()(T x) {
+    if constexpr (cuda::std::is_same_v<T, __half>) {
+      return erf(__half2float(x));
+    } else if constexpr (cuda::std::is_same_v<T, __nv_bfloat16>) {
+      return erf(__bfloat162float(x));
+    } else {
+      return erf(x);
+    }
+  }
+};
+
+struct ErfInv {
+  template <typename T>
+  __device__ T operator()(T x) {
+    if constexpr (cuda::std::is_same_v<T, __half>) {
+      return erfinv(__half2float(x));
+    } else if constexpr (cuda::std::is_same_v<T, __nv_bfloat16>) {
+      return erfinv(__bfloat162float(x));
+    } else {
+      return erfinv(x);
+    }
+  }
+};
+
+struct Exp {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return exp(x);
+  }
+};
+
+struct Expm1 {
+  template <typename T>
+  __device__ T operator()(T x) {
+    if constexpr (cuda::std::is_same_v<T, __half>) {
+      return expm1(__half2float(x));
+    } else if constexpr (cuda::std::is_same_v<T, __nv_bfloat16>) {
+      return expm1(__bfloat162float(x));
+    } else {
+      return expm1(x);
+    }
+  }
+};
+
+struct Floor {
+  template <typename T>
+  __device__ T operator()(T x) {
+    if constexpr (cuda::std::is_integral_v<T>) {
+      return x;
+    } else if constexpr (is_complex_v<T>) {
+      return T{floor(x.real()), floor(x.imag())};
+    } else {
+      return floor(x);
+    }
+  }
+};
+
+struct Imag {
+  template <typename T>
+  __device__ auto operator()(complex_t<T> x) {
+    return x.imag();
+  }
+};
+
+struct Log {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return log(x);
+  }
+};
+
+struct Log2 {
+  template <typename T>
+  __device__ T operator()(T x) {
+    if constexpr (is_complex_v<T>) {
+      auto y = Log{}(x);
+      return {y.real() / CUDART_LN2_F, y.imag() / CUDART_LN2_F};
+    } else {
+      return log2(x);
+    }
+  }
+};
+
+struct Log10 {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return log10(x);
+  }
+};
+
+struct Log1p {
+  template <typename T>
+  __device__ T operator()(T z) {
+    if constexpr (is_complex_v<T>) {
+      float x = z.real();
+      float y = z.imag();
+      float zabs = Abs{}(z).real();
+      float theta = atan2f(y, x + 1);
+      if (zabs < 0.5f) {
+        float r = x * (2 + x) + y * y;
+        if (r == 0) { // handle underflow
+          return {x, theta};
+        }
+        return {0.5f * log1pf(r), theta};
+      } else {
+        float z0 = hypotf(x + 1, y);
+        return {logf(z0), theta};
+      }
+    } else {
+      return log1p(z);
+    }
+  }
+};
+
+struct LogicalNot {
+  __device__ bool operator()(bool x) {
+    return !x;
+  }
+};
+
+struct Negative {
+  template <typename T>
+  __device__ T operator()(T x) {
+    if constexpr (is_complex_v<T>) {
+      return T{0, 0} - x;
+    } else {
+      return -x;
+    }
+  }
+};
+
+struct Real {
+  template <typename T>
+  __device__ auto operator()(complex_t<T> x) {
+    return x.real();
+  }
+};
+
+struct Round {
+  template <typename T>
+  __device__ T operator()(T x) {
+    if constexpr (is_complex_v<T>) {
+      return {rint(x.real()), rint(x.imag())};
+    } else {
+      return rint(x);
+    }
+  }
+};
+
+struct Sigmoid {
+  template <typename T>
+  __device__ T operator()(T x) {
+    T y = 1 / (1 + exp(-abs(x)));
+    return (x < 0) ? 1 - y : y;
+  }
+};
+
+struct Sign {
+  template <typename T>
+  __device__ T operator()(T x) {
+    if constexpr (cuda::std::is_unsigned_v<T>) {
+      return x != 0;
+    } else if constexpr (is_complex_v<T>) {
+      if (x.real() == 0 && x.imag() == 0) {
+        return x;
+      } else {
+        return x / Abs()(x);
+      }
+    } else if constexpr (cuda::std::is_same_v<T, __nv_bfloat16>) {
+      return static_cast<float>((x > T(0.f)) - (x < T(0.f)));
+    } else {
+      return (x > T(0)) - (x < T(0));
+    }
+  }
+};
+
+struct Sin {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return sin(x);
+  }
+};
+
+struct Sinh {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return sinh(x);
+  }
+};
+
+struct Square {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return x * x;
+  }
+};
+
+struct Sqrt {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return sqrt(x);
+  }
+};
+
+struct Rsqrt {
+  template <typename T>
+  __device__ T operator()(T x) {
+    if constexpr (is_complex_v<T>) {
+      return 1.0f / Sqrt{}(x);
+    } else {
+      return rsqrt(x);
+    }
+  }
+};
+
+struct Tan {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return tan(x);
+  }
+};
+
+struct Tanh {
+  template <typename T>
+  __device__ T operator()(T x) {
+    return tanh(x);
+  }
+};
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/device/utils.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/utils.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..7ebc5d654732faf5c7e637b7107f0315c0d07e79
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/device/utils.cuh
@@ -0,0 +1,464 @@
+// Copyright © 2025 Apple Inc.
+
+// This file must not include any host-only code, utilies that work under both
+// host and device can be put here.
+//
+// See more about the requirements at:
+// https://docs.nvidia.com/cuda/nvrtc/#language
+
+#pragma once
+
+#include "mlx/backend/cuda/device/complex.cuh"
+#include "mlx/backend/cuda/device/config.h"
+
+#include <cuda_bf16.h>
+#include <cuda_fp16.h>
+#include <cuda/std/array>
+#include <cuda/std/limits>
+#include <cuda/std/tuple>
+
+namespace mlx::core::cu {
+
+///////////////////////////////////////////////////////////////////////////////
+// CUDA kernel utils
+///////////////////////////////////////////////////////////////////////////////
+
+// To pass shape/strides to kernels via constant memory, their size must be
+// known at compile time.
+using Shape = cuda::std::array<int32_t, MAX_NDIM>;
+using Strides = cuda::std::array<int64_t, MAX_NDIM>;
+
+// Vectorized load/store.
+template <typename T, int N>
+struct alignas(sizeof(T) * N) AlignedVector {
+  T val[N];
+
+  __device__ T& operator[](int i) {
+    return val[i];
+  }
+
+  __device__ T operator[](int i) const {
+    return val[i];
+  }
+};
+
+template <int N, typename T>
+inline __host__ __device__ bool is_aligned(T* x) {
+  return (reinterpret_cast<uintptr_t>(x) % (N * sizeof(T))) == 0;
+}
+
+template <int N, typename T>
+inline __device__ AlignedVector<T, N> unsafe_load_vector(
+    const T* ptr,
+    uint32_t offset) {
+  auto* from = reinterpret_cast<const AlignedVector<T, N>*>(ptr);
+  return from[offset];
+}
+
+template <int N, typename T>
+inline __device__ AlignedVector<T, N> load_vector(
+    const T* ptr,
+    uint32_t offset) {
+  if (is_aligned<N>(ptr)) {
+    auto* from = reinterpret_cast<const AlignedVector<T, N>*>(ptr);
+    return from[offset];
+  } else {
+    AlignedVector<T, N> v;
+#pragma unroll
+    for (int i = 0; i < N; ++i) {
+      v[i] = ptr[offset * N + i];
+    }
+    return v;
+  }
+}
+
+template <int N, typename T, typename SizeT>
+inline __device__ AlignedVector<T, N>
+load_vector(const T* ptr, uint32_t offset, SizeT size, T fallback) {
+  if (is_aligned<N>(ptr) && (offset + 1) * N <= size) {
+    auto* from = reinterpret_cast<const AlignedVector<T, N>*>(ptr);
+    return from[offset];
+  } else {
+    AlignedVector<T, N> v;
+#pragma unroll
+    for (int i = 0; i < N; ++i) {
+      v[i] = (N * offset + i) < size ? ptr[offset * N + i] : fallback;
+    }
+    return v;
+  }
+}
+
+template <int N, typename T, typename SizeT>
+inline __device__ AlignedVector<T, N> load_vector(
+    const T* ptr,
+    uint32_t offset,
+    SizeT size,
+    int64_t stride,
+    T fallback) {
+  if (is_aligned<N>(ptr) && stride == 1 && (offset + 1) * N <= size) {
+    auto* from = reinterpret_cast<const AlignedVector<T, N>*>(ptr);
+    return from[offset];
+  } else {
+    AlignedVector<T, N> v;
+#pragma unroll
+    for (int i = 0; i < N; ++i) {
+      v[i] =
+          (N * offset + i) < size ? ptr[stride * (offset * N + i)] : fallback;
+    }
+    return v;
+  }
+}
+
+template <int N, typename T>
+inline __device__ void
+unsafe_store_vector(T* ptr, uint32_t offset, const AlignedVector<T, N>& vec) {
+  auto* to = reinterpret_cast<AlignedVector<T, N>*>(ptr);
+  to[offset] = vec;
+}
+
+template <int N, typename T>
+inline __device__ void
+store_vector(T* ptr, uint32_t offset, const AlignedVector<T, N>& vec) {
+  if (is_aligned<N>(ptr)) {
+    auto* to = reinterpret_cast<AlignedVector<T, N>*>(ptr);
+    to[offset] = vec;
+  } else {
+#pragma unroll
+    for (int i = 0; i < N; ++i) {
+      ptr[offset * N + i] = vec[i];
+    }
+  }
+}
+
+template <int N, typename T, typename SizeT>
+inline __device__ void store_vector(
+    T* ptr,
+    uint32_t offset,
+    const AlignedVector<T, N>& vec,
+    SizeT size) {
+  if (is_aligned<N>(ptr) && (offset + 1) * N <= size) {
+    auto* to = reinterpret_cast<AlignedVector<T, N>*>(ptr);
+    to[offset] = vec;
+  } else {
+    for (int i = 0; (offset * N + i) < size && i < N; ++i) {
+      ptr[offset * N + i] = vec[i];
+    }
+  }
+}
+
+template <int N, typename T, typename SizeT>
+inline __device__ void store_vector(
+    T* ptr,
+    uint32_t offset,
+    const AlignedVector<T, N>& vec,
+    SizeT size,
+    int64_t stride) {
+  if (is_aligned<N>(ptr) && (offset + 1) * N <= size && stride == 1) {
+    auto* to = reinterpret_cast<AlignedVector<T, N>*>(ptr);
+    to[offset] = vec;
+  } else {
+    for (int i = 0; (offset * N + i) < size && i < N; ++i) {
+      ptr[stride * (offset * N + i)] = vec[i];
+    }
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Type limits utils
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, typename = void>
+struct Limits {
+  static constexpr __host__ __device__ T max() {
+    return cuda::std::numeric_limits<T>::max();
+  }
+  static constexpr __host__ __device__ T min() {
+    return cuda::std::numeric_limits<T>::min();
+  }
+  static constexpr __host__ __device__ T finite_max() {
+    return cuda::std::numeric_limits<T>::max();
+  }
+  static constexpr __host__ __device__ T finite_min() {
+    return cuda::std::numeric_limits<T>::min();
+  }
+};
+
+template <typename T>
+struct Limits<
+    T,
+    cuda::std::enable_if_t<
+        cuda::std::is_same_v<T, float> || cuda::std::is_same_v<T, double>>> {
+  static constexpr __host__ __device__ T max() {
+    return cuda::std::numeric_limits<T>::infinity();
+  }
+  static constexpr __host__ __device__ T min() {
+    return -cuda::std::numeric_limits<T>::infinity();
+  }
+  static constexpr __host__ __device__ T finite_max() {
+    return cuda::std::numeric_limits<T>::max();
+  }
+  static constexpr __host__ __device__ T finite_min() {
+    return cuda::std::numeric_limits<T>::lowest();
+  }
+};
+
+// CUDA 11 does not have host side arithmatic operators for half types.
+template <typename T>
+struct Limits<
+    T,
+    cuda::std::enable_if_t<
+        cuda::std::is_same_v<T, __half> ||
+        cuda::std::is_same_v<T, __nv_bfloat16>>> {
+  static constexpr __host__ __device__ T max() {
+    return cuda::std::numeric_limits<T>::infinity();
+  }
+  static constexpr __host__ __device__ T min() {
+#if CUDART_VERSION < 12000 && __CUDA_ARCH__ < 800
+    return -cuda::std::numeric_limits<float>::infinity();
+#else
+    return -cuda::std::numeric_limits<T>::infinity();
+#endif
+  }
+  static constexpr __host__ __device__ T finite_max() {
+    return cuda::std::numeric_limits<T>::max();
+  }
+  static constexpr __host__ __device__ T finite_min() {
+#if CUDART_VERSION < 12000 && __CUDA_ARCH__ < 800
+    return cuda::std::numeric_limits<float>::lowest();
+#else
+    return cuda::std::numeric_limits<T>::lowest();
+#endif
+  }
+};
+
+template <>
+struct Limits<bool> {
+  static constexpr __host__ __device__ bool max() {
+    return true;
+  }
+  static constexpr __host__ __device__ bool min() {
+    return false;
+  }
+};
+
+template <typename T>
+struct Limits<complex_t<T>> {
+  static constexpr __host__ __device__ complex_t<T> max() {
+    return {Limits<T>::max(), Limits<T>::max()};
+  }
+  static constexpr __host__ __device__ complex_t<T> min() {
+    return {Limits<T>::min(), Limits<T>::min()};
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Indexing utils
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename IdxT = int64_t>
+inline __host__ __device__ IdxT
+elem_to_loc(IdxT elem, const int* shape, const int64_t* strides, int ndim) {
+  IdxT loc = 0;
+  for (int i = ndim - 1; i >= 0 && elem > 0; --i) {
+    loc += (elem % shape[i]) * IdxT(strides[i]);
+    elem /= shape[i];
+  }
+  return loc;
+}
+
+// Optimize when the ndim is known at compile time.
+template <int NDIM, typename IdxT = int64_t>
+inline __host__ __device__ IdxT
+elem_to_loc_nd(IdxT elem, const int* shape, const int64_t* strides) {
+  IdxT loc = 0;
+#pragma unroll
+  for (int i = NDIM - 1; i >= 0; --i) {
+    loc += (elem % shape[i]) * IdxT(strides[i]);
+    elem /= shape[i];
+  }
+  return loc;
+}
+
+template <int NDIM, typename IdxT = int64_t>
+inline __host__ __device__ cuda::std::tuple<IdxT, IdxT> elem_to_loc_nd(
+    IdxT elem,
+    const int* shape,
+    const int64_t* a_strides,
+    const int64_t* b_strides) {
+  IdxT a_loc = 0;
+  IdxT b_loc = 0;
+#pragma unroll
+  for (int i = NDIM - 1; i >= 0; --i) {
+    int dim_idx = elem % shape[i];
+    a_loc += dim_idx * IdxT(a_strides[i]);
+    b_loc += dim_idx * IdxT(b_strides[i]);
+    elem /= shape[i];
+  }
+  return cuda::std::make_tuple(a_loc, b_loc);
+}
+
+template <int NDIM, typename IdxT = int64_t>
+inline __host__ __device__ cuda::std::tuple<IdxT, IdxT, IdxT> elem_to_loc_nd(
+    IdxT elem,
+    const int* shape,
+    const int64_t* a_strides,
+    const int64_t* b_strides,
+    const int64_t* c_strides) {
+  IdxT a_loc = 0;
+  IdxT b_loc = 0;
+  IdxT c_loc = 0;
+#pragma unroll
+  for (int i = NDIM - 1; i >= 0; --i) {
+    int dim_idx = elem % shape[i];
+    a_loc += dim_idx * IdxT(a_strides[i]);
+    b_loc += dim_idx * IdxT(b_strides[i]);
+    c_loc += dim_idx * IdxT(c_strides[i]);
+    elem /= shape[i];
+  }
+  return cuda::std::make_tuple(a_loc, b_loc, c_loc);
+}
+
+template <typename IdxT = int64_t>
+inline __host__ __device__ cuda::std::tuple<IdxT, IdxT> elem_to_loc(
+    IdxT elem,
+    const int* shape,
+    const int64_t* a_strides,
+    const int64_t* b_strides,
+    int ndim) {
+  IdxT a_loc = 0;
+  IdxT b_loc = 0;
+  for (int i = ndim - 1; i >= 0; --i) {
+    int dim_idx = elem % shape[i];
+    a_loc += dim_idx * IdxT(a_strides[i]);
+    b_loc += dim_idx * IdxT(b_strides[i]);
+    elem /= shape[i];
+  }
+  return cuda::std::make_tuple(a_loc, b_loc);
+}
+
+template <typename IdxT = int64_t>
+inline __host__ __device__ cuda::std::tuple<IdxT, IdxT, IdxT> elem_to_loc(
+    IdxT elem,
+    const int* shape,
+    const int64_t* a_strides,
+    const int64_t* b_strides,
+    const int64_t* c_strides,
+    int ndim) {
+  IdxT a_loc = 0;
+  IdxT b_loc = 0;
+  IdxT c_loc = 0;
+  for (int i = ndim - 1; i >= 0; --i) {
+    int dim_idx = elem % shape[i];
+    a_loc += dim_idx * IdxT(a_strides[i]);
+    b_loc += dim_idx * IdxT(b_strides[i]);
+    c_loc += dim_idx * IdxT(c_strides[i]);
+    elem /= shape[i];
+  }
+  return cuda::std::make_tuple(a_loc, b_loc, c_loc);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Elem to loc in a loop utils
+///////////////////////////////////////////////////////////////////////////////
+
+template <int DIM, bool General = true, typename OffsetT = size_t>
+struct LoopedElemToLoc {
+  int dim;
+  LoopedElemToLoc<DIM - 1, General, OffsetT> inner_looper;
+  OffsetT offset{0};
+  int index{0};
+
+  __device__ LoopedElemToLoc(int dim) : dim(dim), inner_looper(dim - 1) {}
+
+  __device__ void next(const int* shape, const int64_t* strides) {
+    if (dim == 0) {
+      return;
+    }
+    index++;
+    offset += OffsetT(strides[dim - 1]);
+    if (index >= shape[dim - 1]) {
+      index = 0;
+      inner_looper.next(shape, strides);
+      offset = inner_looper.offset;
+    }
+  }
+
+  __device__ void next(int n, const int* shape, const int64_t* strides) {
+    if (dim == 0) {
+      return;
+    }
+    index += n;
+    offset += n * OffsetT(strides[dim - 1]);
+
+    if (index >= shape[dim - 1]) {
+      int extra = index - shape[dim - 1];
+      if (extra >= shape[dim - 1]) {
+        inner_looper.next(1 + extra / shape[dim - 1], shape, strides);
+        extra = extra % shape[dim - 1];
+      } else {
+        inner_looper.next(shape, strides);
+      }
+      index = 0;
+      offset = inner_looper.offset;
+      if (extra > 0) {
+        next(extra, shape, strides);
+      }
+    }
+  }
+
+  __device__ OffsetT location() {
+    return offset;
+  }
+};
+
+template <typename OffsetT>
+struct LoopedElemToLoc<1, true, OffsetT> {
+  int dim;
+  OffsetT offset{0};
+  int index{0};
+
+  __device__ LoopedElemToLoc(int dim) : dim(dim) {}
+
+  __device__ void next(const int* shape, const int64_t* strides) {
+    index++;
+    if (dim > 1) {
+      offset = elem_to_loc<OffsetT>(index, shape, strides, dim);
+    } else {
+      offset += OffsetT(strides[0]);
+    }
+  }
+
+  __device__ void next(int n, const int* shape, const int64_t* strides) {
+    index += n;
+    if (dim > 1) {
+      offset = elem_to_loc<OffsetT>(index, shape, strides, dim);
+    } else {
+      offset = index * OffsetT(strides[0]);
+    }
+  }
+
+  __device__ OffsetT location() {
+    return offset;
+  }
+};
+
+template <typename OffsetT>
+struct LoopedElemToLoc<1, false, OffsetT> {
+  OffsetT offset{0};
+
+  __device__ LoopedElemToLoc(int) {}
+
+  __device__ void next(const int*, const int64_t* strides) {
+    offset += OffsetT(strides[0]);
+  }
+
+  __device__ void next(int n, const int*, const int64_t* strides) {
+    offset += n * OffsetT(strides[0]);
+  }
+
+  __device__ OffsetT location() {
+    return offset;
+  }
+};
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/distributed.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/distributed.cu
new file mode 100644
index 0000000000000000000000000000000000000000..4d2658534f0f1a194379e0fc14f1aebe89e31d1d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/distributed.cu
@@ -0,0 +1,56 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/distributed/primitives.h"
+#include "mlx/primitives.h"
+
+#include <cassert>
+
+namespace mlx::core::distributed {
+void AllReduce::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  assert(inputs.size() == 1);
+  assert(outputs.size() == 1);
+
+  auto set_input_output =
+      [s = stream()](const array& in, array& out) -> std::pair<array, array> {
+    if (!in.flags().row_contiguous) {
+      copy_gpu(in, out, CopyType::General, s);
+      return {out, out};
+    } else if (in.is_donatable()) {
+      out.copy_shared_buffer(in);
+      return {in, out};
+    } else {
+      out.set_data(allocator::malloc(out.nbytes()));
+      return {in, out};
+    }
+  };
+
+  auto [input, output] = set_input_output(inputs[0], outputs[0]);
+
+  auto& encoder = cu::get_command_encoder(stream());
+  encoder.set_input_array(input);
+  encoder.set_output_array(output);
+
+  auto capture = encoder.capture_context();
+  auto& s = stream();
+
+  switch (reduce_type_) {
+    case Sum:
+      distributed::detail::all_sum(group(), input, output, s);
+      break;
+    case Max:
+      distributed::detail::all_max(group(), input, output, s);
+      break;
+    case Min:
+      distributed::detail::all_min(group(), input, output, s);
+      break;
+    default:
+      throw std::runtime_error(
+          "Only all reduce sum, max, and min are supported.");
+  }
+}
+} // namespace mlx::core::distributed
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/eval.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/eval.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..07b3ad63e93f46b7a8f7bde25ed7cee8d6f6c3c2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/eval.cpp
@@ -0,0 +1,75 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/gpu/eval.h"
+#include "mlx/backend/cuda/allocator.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/gpu/available.h"
+#include "mlx/primitives.h"
+#include "mlx/scheduler.h"
+
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core::gpu {
+
+// Can be tuned with MLX_MAX_OPS_PER_BUFFER
+constexpr int default_max_nodes_per_graph = 20;
+
+bool is_available() {
+  return true;
+}
+
+void new_stream(Stream s) {
+  // Force initalization of CUDA, so CUDA runtime get destroyed at last.
+  cudaFree(nullptr);
+  // Make sure CUDA event pool get destroyed after device and stream.
+  cu::CudaEvent::init_pool();
+  // Ensure the static stream objects get created.
+  cu::get_command_encoder(s);
+}
+
+void eval(array& arr) {
+  nvtx3::scoped_range r("gpu::eval");
+  auto outputs = arr.outputs();
+  {
+    // If the array is a tracer hold a reference
+    // to its inputs so they don't get donated
+    std::vector<array> inputs;
+    if (arr.is_tracer()) {
+      inputs = arr.inputs();
+    }
+    arr.primitive().eval_gpu(arr.inputs(), outputs);
+  }
+
+  auto& stream = arr.primitive().stream();
+  auto& encoder = cu::get_command_encoder(stream);
+  // Keep used buffers alive until kernel finishes running.
+  for (auto& in : arr.inputs()) {
+    // Except for the donated one.
+    if (in.data_shared_ptr() != arr.data_shared_ptr()) {
+      encoder.add_temporary(in);
+    }
+  }
+  for (auto& s : arr.siblings()) {
+    encoder.add_temporary(s);
+  }
+
+  if (encoder.get_num_ops() >=
+      env::max_ops_per_buffer(default_max_nodes_per_graph)) {
+    scheduler::notify_new_task(stream);
+    encoder.add_completed_handler(
+        [stream]() { scheduler::notify_task_completion(stream); });
+    encoder.commit();
+  }
+}
+
+void finalize(Stream s) {
+  nvtx3::scoped_range r("gpu::finalize");
+  cu::get_command_encoder(s).commit();
+}
+
+void synchronize(Stream s) {
+  nvtx3::scoped_range r("gpu::synchronize");
+  cu::get_command_encoder(s).synchronize();
+}
+
+} // namespace mlx::core::gpu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/event.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/event.cu
new file mode 100644
index 0000000000000000000000000000000000000000..55b8d1e64bfc2e8fc06aea076a13b120fafcb7f4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/event.cu
@@ -0,0 +1,345 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/backend/cuda/allocator.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/event.h"
+#include "mlx/event.h"
+#include "mlx/scheduler.h"
+
+#include <map>
+#include <vector>
+
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core {
+
+namespace cu {
+
+///////////////////////////////////////////////////////////////////////////////
+// CudaEvent implementations
+///////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
+// Manage cached cudaEvent_t objects.
+class CudaEventPool {
+ public:
+  CudaEventHandle create(Device& d, int flags) {
+    if (!on_creation_thread()) {
+      return CudaEventHandle(d, flags);
+    }
+    auto& cache = cache_for(d, flags);
+    if (cache.empty()) {
+      return CudaEventHandle(d, flags);
+    } else {
+      CudaEventHandle ret = std::move(cache.back());
+      cache.pop_back();
+      return ret;
+    }
+  }
+
+  void release(CudaEventHandle event) {
+    if (!on_creation_thread()) {
+      // Event will be destroyed directly instead of getting moved to cache.
+      return;
+    }
+    cache_for(event.device, event.flags).push_back(std::move(event));
+  }
+
+ private:
+  std::vector<CudaEventHandle>& cache_for(Device& d, int flags) {
+    return cache_[d.cuda_device()][flags];
+  }
+
+  bool on_creation_thread() {
+    return std::this_thread::get_id() == thread_id_;
+  }
+
+  // The CudaEvent may be created and destroyed on different threads (for
+  // example when waiting on GPU work in CPU stream), we don't want to make
+  // the cache thread-safe as it adds overhead, so we just skip cache when
+  // using events in worker threads.
+  std::thread::id thread_id_{std::this_thread::get_id()};
+
+  // {device: {flags: [events]}}
+  std::map<int, std::map<int, std::vector<CudaEventHandle>>> cache_;
+};
+
+CudaEventPool& cuda_event_pool() {
+  static CudaEventPool pool;
+  return pool;
+}
+
+} // namespace
+
+CudaEventHandle::CudaEventHandle(Device& d, int flags)
+    : device(d), flags(flags) {
+  device.make_current();
+  CHECK_CUDA_ERROR(cudaEventCreateWithFlags(&handle_, flags));
+  assert(handle_ != nullptr);
+}
+
+CudaEvent::CudaEvent(Device& d, int flags)
+    : event_(cuda_event_pool().create(d, flags)) {}
+
+CudaEvent::~CudaEvent() {
+  cuda_event_pool().release(std::move(event_));
+}
+
+void CudaEvent::wait() {
+  nvtx3::scoped_range r("cu::CudaEvent::wait");
+  event_.device.make_current();
+  cudaEventSynchronize(event_);
+}
+
+void CudaEvent::wait(cudaStream_t stream) {
+  event_.device.make_current();
+  cudaStreamWaitEvent(stream, event_);
+}
+
+void CudaEvent::record(cudaStream_t stream) {
+  event_.device.make_current();
+  cudaEventRecord(event_, stream);
+}
+
+bool CudaEvent::completed() const {
+  // Note: cudaEventQuery can be safely called from any device.
+  return cudaEventQuery(event_) == cudaSuccess;
+}
+
+// static
+void CudaEvent::init_pool() {
+  cuda_event_pool();
+}
+
+// Wraps CudaEvent with a few features:
+// 1. The class can be copied.
+// 2. Make wait/record work with CPU streams.
+// 3. Add checks for waiting on un-recorded event.
+class CopyableCudaEvent {
+ public:
+  explicit CopyableCudaEvent(Device& d)
+      : event_(std::make_shared<CudaEvent>(
+            d,
+            cudaEventDisableTiming | cudaEventBlockingSync)) {}
+
+  void wait() {
+    event_->wait();
+  }
+
+  void wait(Stream s) {
+    if (s.device == mlx::core::Device::cpu) {
+      scheduler::enqueue(s, [*this]() mutable {
+        check_recorded();
+        event_->wait();
+      });
+    } else {
+      check_recorded();
+      auto& encoder = cu::get_command_encoder(s);
+      encoder.commit();
+      event_->wait(encoder.stream());
+    }
+  }
+
+  void record(Stream s) {
+    if (s.device == mlx::core::Device::cpu) {
+      throw std::runtime_error("CudaEvent can not wait on CPU stream.");
+    } else {
+      auto& encoder = cu::get_command_encoder(s);
+      encoder.commit();
+      event_->record(encoder.stream());
+      recorded_ = true;
+    }
+  }
+
+  bool is_signaled() const {
+    return recorded_ && event_->completed();
+  }
+
+ private:
+  void check_recorded() const {
+    if (!recorded_) {
+      throw std::runtime_error(
+          "Should not wait on a CudaEvent before recording.");
+    }
+  }
+
+  std::shared_ptr<CudaEvent> event_;
+  bool recorded_{false};
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// AtomicEvent implementations
+///////////////////////////////////////////////////////////////////////////////
+
+__host__ __device__ void event_wait(AtomicEvent::Atomic* ac, uint64_t value) {
+  uint64_t current;
+  while ((current = ac->load()) < value) {
+    ac->wait(current);
+  }
+}
+
+__host__ __device__ void event_signal(AtomicEvent::Atomic* ac, uint64_t value) {
+  ac->store(value);
+  ac->notify_all();
+}
+
+__global__ void event_wait_kernel(AtomicEvent::Atomic* ac, uint64_t value) {
+  event_wait(ac, value);
+}
+
+__global__ void event_signal_kernel(AtomicEvent::Atomic* ac, uint64_t value) {
+  event_signal(ac, value);
+}
+
+AtomicEvent::AtomicEvent() {
+  buf_ = std::shared_ptr<Buffer>(
+      new Buffer{allocator().malloc(sizeof(Atomic))}, [](Buffer* ptr) {
+        allocator().free(*ptr);
+        delete ptr;
+      });
+  *static_cast<uint64_t*>(buf_->raw_ptr()) = 0;
+}
+
+void AtomicEvent::wait(uint64_t value) {
+  nvtx3::scoped_range r("cu::AtomicEvent::wait");
+  event_wait(atomic(), value);
+}
+
+void AtomicEvent::wait(cudaStream_t stream, uint64_t value) {
+  event_wait_kernel<<<1, 1, 0, stream>>>(atomic(), value);
+}
+
+void AtomicEvent::wait(Stream s, uint64_t value) {
+  nvtx3::scoped_range r("cu::AtomicEvent::wait(s)");
+  if (s.device == mlx::core::Device::cpu) {
+    scheduler::enqueue(s, [*this, value]() mutable { wait(value); });
+  } else {
+    auto& encoder = get_command_encoder(s);
+    encoder.commit();
+    wait(encoder.stream(), value);
+    encoder.add_completed_handler([buf = buf_]() {});
+  }
+}
+
+void AtomicEvent::signal(uint64_t value) {
+  nvtx3::scoped_range r("cu::AtomicEvent::signal");
+  event_signal(atomic(), value);
+}
+
+void AtomicEvent::signal(cudaStream_t stream, uint64_t value) {
+  event_signal_kernel<<<1, 1, 0, stream>>>(atomic(), value);
+}
+
+void AtomicEvent::signal(Stream s, uint64_t value) {
+  nvtx3::scoped_range r("cu::AtomicEvent::signal(s)");
+  if (s.device == mlx::core::Device::cpu) {
+    // Signal through a GPU stream so the atomic is updated in GPU - updating
+    // the atomic in CPU sometimes does not get GPU notified.
+    static CudaStream stream(device(mlx::core::Device::gpu));
+    scheduler::enqueue(s, [*this, value]() mutable { signal(stream, value); });
+  } else {
+    auto& encoder = get_command_encoder(s);
+    encoder.commit();
+    signal(encoder.stream(), value);
+    encoder.add_completed_handler([buf = buf_]() {});
+  }
+}
+
+bool AtomicEvent::is_signaled(uint64_t value) const {
+  nvtx3::scoped_range r("cu::AtomicEvent::is_signaled");
+  return atomic()->load() >= value;
+}
+
+uint64_t AtomicEvent::value() const {
+  nvtx3::scoped_range r("cu::AtomicEvent::value");
+  return atomic()->load();
+}
+
+} // namespace cu
+
+///////////////////////////////////////////////////////////////////////////////
+// Event implementations
+///////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
+struct EventImpl {
+  // CudaEvent is preferred when possible because it is fast, however we have
+  // to fallback to AtomicEvent in following cases:
+  // 1. the event is used to wait/signal a cpu stream;
+  // 2. signal value other than 1 has been specified.
+  std::unique_ptr<cu::CopyableCudaEvent> cuda;
+  std::unique_ptr<cu::AtomicEvent> atomic;
+
+  bool is_created() const {
+    return cuda || atomic;
+  }
+
+  void ensure_created(Stream s, uint64_t signal_value) {
+    if (is_created()) {
+      return;
+    }
+    if (s.device == mlx::core::Device::cpu || signal_value > 1) {
+      nvtx3::mark("Using slow AtomicEvent");
+      atomic = std::make_unique<cu::AtomicEvent>();
+    } else {
+      cuda = std::make_unique<cu::CopyableCudaEvent>(cu::device(s.device));
+    }
+  }
+};
+
+} // namespace
+
+Event::Event(Stream s) : stream_(s) {
+  event_ = std::shared_ptr<void>(
+      new EventImpl(), [](void* ptr) { delete static_cast<EventImpl*>(ptr); });
+}
+
+void Event::wait() {
+  auto* event = static_cast<EventImpl*>(event_.get());
+  assert(event->is_created());
+  if (event->cuda) {
+    assert(value() == 1);
+    event->cuda->wait();
+  } else {
+    event->atomic->wait(value());
+  }
+}
+
+void Event::wait(Stream s) {
+  auto* event = static_cast<EventImpl*>(event_.get());
+  assert(event->is_created());
+  if (event->cuda) {
+    assert(value() == 1);
+    event->cuda->wait(s);
+  } else {
+    event->atomic->wait(s, value());
+  }
+}
+
+void Event::signal(Stream s) {
+  auto* event = static_cast<EventImpl*>(event_.get());
+  event->ensure_created(s, value());
+  if (event->cuda) {
+    assert(value() == 1);
+    event->cuda->record(s);
+  } else {
+    event->atomic->signal(s, value());
+  }
+}
+
+bool Event::is_signaled() const {
+  auto* event = static_cast<EventImpl*>(event_.get());
+  if (!event->is_created()) {
+    return false;
+  }
+  if (event->cuda) {
+    assert(value() == 1);
+    return event->cuda->is_signaled();
+  } else {
+    return event->atomic->is_signaled(value());
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/event.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/event.h
new file mode 100644
index 0000000000000000000000000000000000000000..342e6ae3f4af24278e8d12760a513ec2aa9e1b5f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/event.h
@@ -0,0 +1,78 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/allocator.h"
+#include "mlx/backend/cuda/utils.h"
+#include "mlx/stream.h"
+
+#include <memory>
+
+#include <cuda_runtime.h>
+#include <cuda/atomic>
+
+namespace mlx::core::cu {
+
+class Device;
+
+// RAII-managed move-only wrapper of cudaEvent_t.
+struct CudaEventHandle : public CudaHandle<cudaEvent_t, cudaEventDestroy> {
+  CudaEventHandle(Device& d, int flags);
+  Device& device;
+  int flags;
+};
+
+// Wrapper of native cuda event. It can synchronize between GPU streams, or wait
+// on GPU stream in CPU stream, but can not wait on CPU stream.
+class CudaEvent {
+ public:
+  CudaEvent(Device& d, int flags);
+  ~CudaEvent();
+
+  CudaEvent(CudaEvent&&) = default;
+  CudaEvent& operator=(CudaEvent&&) = default;
+
+  CudaEvent(const CudaEvent&) = delete;
+  CudaEvent& operator=(const CudaEvent&) = delete;
+
+  void wait();
+  void wait(cudaStream_t stream);
+  void record(cudaStream_t stream);
+
+  // Return whether the recorded kernels have completed. Note that this method
+  // returns true if record() has not been called.
+  bool completed() const;
+
+  // Internal: make sure event pool is initialized.
+  static void init_pool();
+
+ private:
+  CudaEventHandle event_;
+};
+
+// Event that can synchronize between CPU and GPU. It is much slower than
+// CudaEvent so the latter should always be preferred when possible.
+class AtomicEvent {
+ public:
+  using Atomic = cuda::atomic<uint64_t>;
+
+  AtomicEvent();
+
+  void wait(uint64_t value);
+  void wait(cudaStream_t stream, uint64_t value);
+  void wait(Stream s, uint64_t value);
+  void signal(uint64_t value);
+  void signal(cudaStream_t stream, uint64_t value);
+  void signal(Stream s, uint64_t value);
+  bool is_signaled(uint64_t value) const;
+  uint64_t value() const;
+
+ private:
+  Atomic* atomic() const {
+    return static_cast<AtomicEvent::Atomic*>(buf_->raw_ptr());
+  }
+
+  std::shared_ptr<allocator::Buffer> buf_;
+};
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/fence.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/fence.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9121c7f4e6c9198f291d75a5dd176f26c8479a80
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/fence.cpp
@@ -0,0 +1,29 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/fence.h"
+#include "mlx/backend/cuda/event.h"
+
+namespace mlx::core {
+
+struct FenceImpl {
+  uint32_t count;
+  cu::AtomicEvent event;
+};
+
+Fence::Fence(Stream s) {
+  fence_ = std::shared_ptr<void>(
+      new FenceImpl{0}, [](void* ptr) { delete static_cast<FenceImpl*>(ptr); });
+}
+
+void Fence::wait(Stream s, const array&) {
+  auto* fence = static_cast<FenceImpl*>(fence_.get());
+  fence->event.wait(fence->count);
+}
+
+void Fence::update(Stream s, const array&) {
+  auto* fence = static_cast<FenceImpl*>(fence_.get());
+  fence->count++;
+  fence->event.signal(s, fence->count);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/cublas_gemm.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/cublas_gemm.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fc2380fc3cbc7f6e4b503e97d1f1a76ae9224e79
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/cublas_gemm.cpp
@@ -0,0 +1,400 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/gemms/cublas_gemm.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/dtype_utils.h"
+#include "mlx/utils.h"
+
+#include <fmt/format.h>
+
+namespace mlx::core {
+
+namespace {
+
+struct CublasPreference {
+  CublasPreference(cu::Device& device) {
+    // The recommended cublas workspace size is 4 MiB for pre-Hopper and 32 MiB
+    // for Hopper+:
+    // https://docs.nvidia.com/cuda/cublas/#cublassetworkspace
+    uint64_t MiB = 1024 * 1024;
+    uint64_t workspace_size =
+        device.compute_capability_major() >= 9 ? 32 * MiB : 4 * MiB;
+
+    CHECK_CUBLAS_ERROR(cublasLtMatmulPreferenceCreate(&pref_));
+    CHECK_CUBLAS_ERROR(cublasLtMatmulPreferenceSetAttribute(
+        pref_,
+        CUBLASLT_MATMUL_PREF_MAX_WORKSPACE_BYTES,
+        &workspace_size,
+        sizeof(uint64_t)));
+  }
+
+  ~CublasPreference() {
+    CHECK_CUBLAS_ERROR(cublasLtMatmulPreferenceDestroy(pref_));
+  }
+
+  cublasLtMatmulPreference_t pref_{nullptr};
+};
+
+cublasLtMatmulPreference_t cublas_preference(cu::Device& device) {
+  static CublasPreference pref(device);
+  return pref.pref_;
+}
+
+cublasComputeType_t dtype_to_compute_type(Dtype dtype) {
+  switch (dtype) {
+    case float16:
+      return CUBLAS_COMPUTE_32F;
+    case bfloat16:
+      return CUBLAS_COMPUTE_32F;
+    case float32:
+      return mlx::core::env::enable_tf32() ? CUBLAS_COMPUTE_32F_FAST_TF32
+                                           : CUBLAS_COMPUTE_32F;
+    case float64:
+      return CUBLAS_COMPUTE_64F;
+    case complex64:
+      return mlx::core::env::enable_tf32() ? CUBLAS_COMPUTE_32F_FAST_TF32
+                                           : CUBLAS_COMPUTE_32F;
+    default:
+      throw std::runtime_error(fmt::format(
+          "Unsupported dtype in CublasGemm: {}.", dtype_to_string(dtype)));
+  }
+}
+
+cudaDataType_t dtype_to_cublas_type(Dtype dtype) {
+  switch (dtype) {
+    case float16:
+      return CUDA_R_16F;
+    case bfloat16:
+      return CUDA_R_16BF;
+    case float32:
+      return CUDA_R_32F;
+    case float64:
+      return CUDA_R_64F;
+    case complex64:
+      return CUDA_C_32F;
+    default:
+      throw std::runtime_error(fmt::format(
+          "Unsupported dtype in CublasGemm: {}.", dtype_to_string(dtype)));
+  }
+}
+
+cublasLtMatrixLayout_t create_matrix_layout(
+    cudaDataType_t type,
+    uint64_t rows,
+    uint64_t cols,
+    bool transposed,
+    int64_t ld,
+    int32_t batch_count,
+    int64_t batch_stride) {
+  cublasLtMatrixLayout_t desc;
+  if (transposed) {
+    std::swap(rows, cols);
+  }
+  CHECK_CUBLAS_ERROR(cublasLtMatrixLayoutCreate(&desc, type, rows, cols, ld));
+  if (batch_count > 1) {
+    CHECK_CUBLAS_ERROR(cublasLtMatrixLayoutSetAttribute(
+        desc,
+        CUBLASLT_MATRIX_LAYOUT_BATCH_COUNT,
+        &batch_count,
+        sizeof(int32_t)));
+    CHECK_CUBLAS_ERROR(cublasLtMatrixLayoutSetAttribute(
+        desc,
+        CUBLASLT_MATRIX_LAYOUT_STRIDED_BATCH_OFFSET,
+        &batch_stride,
+        sizeof(int64_t)));
+  }
+  return desc;
+}
+
+} // namespace
+
+CublasGemm::CublasGemm(
+    cu::Device& device,
+    Dtype dtype,
+    bool a_transposed,
+    uint64_t a_rows,
+    uint64_t a_cols,
+    int64_t lda,
+    bool b_transposed,
+    uint64_t b_rows,
+    uint64_t b_cols,
+    int64_t ldb,
+    int32_t batch_count,
+    int64_t a_batch_stride,
+    int64_t b_batch_stride)
+    : handle_(device.lt_handle()),
+      pref_(cublas_preference(device)),
+      M_(a_rows),
+      N_(b_cols) {
+  heuristic_.state = CUBLAS_STATUS_NOT_INITIALIZED;
+
+  scale_type_ = dtype_to_cublas_type(dtype);
+  if (dtype == bfloat16 || dtype == float16) {
+    scale_type_ = CUDA_R_32F;
+  }
+
+  CHECK_CUBLAS_ERROR(cublasLtMatmulDescCreate(
+      &matmul_desc_, dtype_to_compute_type(dtype), scale_type_));
+  int32_t pointer_mode = CUBLASLT_POINTER_MODE_HOST;
+  CHECK_CUBLAS_ERROR(cublasLtMatmulDescSetAttribute(
+      matmul_desc_,
+      CUBLASLT_MATMUL_DESC_POINTER_MODE,
+      &pointer_mode,
+      sizeof(int32_t)));
+
+  // In cublasLt matrices use column-major layout, while it is possible to use
+  // the CUBLASLT_ORDER_ROW option to switch to row-major layout, the bias
+  // epilogue does not work with the option. So instead we swap A and B to make
+  // cublasLt return the row-major result, which works because:
+  // - the data of a matrix in row-major layout is identical to its transpose in
+  //   column-major layout
+  // - C^T = (A @ B)^T = B^T @ A^T
+  cublasOperation_t a_op = b_transposed ? CUBLAS_OP_T : CUBLAS_OP_N;
+  CHECK_CUBLAS_ERROR(cublasLtMatmulDescSetAttribute(
+      matmul_desc_,
+      CUBLASLT_MATMUL_DESC_TRANSA,
+      &a_op,
+      sizeof(cublasOperation_t)));
+  cublasOperation_t b_op = a_transposed ? CUBLAS_OP_T : CUBLAS_OP_N;
+  CHECK_CUBLAS_ERROR(cublasLtMatmulDescSetAttribute(
+      matmul_desc_,
+      CUBLASLT_MATMUL_DESC_TRANSB,
+      &b_op,
+      sizeof(cublasOperation_t)));
+
+  auto type = dtype_to_cublas_type(dtype);
+  a_desc_ = create_matrix_layout(
+      type, b_cols, b_rows, b_transposed, ldb, batch_count, b_batch_stride);
+  b_desc_ = create_matrix_layout(
+      type, a_cols, a_rows, a_transposed, lda, batch_count, a_batch_stride);
+  out_desc_ = create_matrix_layout(
+      type, b_cols, a_rows, false, b_cols, batch_count, a_rows * b_cols);
+}
+
+CublasGemm::CublasGemm(
+    cu::Device& device,
+    Dtype dtype,
+    bool a_transposed,
+    uint64_t a_rows,
+    uint64_t a_cols,
+    int64_t lda,
+    bool b_transposed,
+    uint64_t b_rows,
+    uint64_t b_cols,
+    int64_t ldb,
+    int64_t ldc,
+    int32_t batch_count,
+    int64_t a_batch_stride,
+    int64_t b_batch_stride,
+    int64_t c_batch_stride)
+    : CublasGemm(
+          device,
+          dtype,
+          a_transposed,
+          a_rows,
+          a_cols,
+          lda,
+          b_transposed,
+          b_rows,
+          b_cols,
+          ldb,
+          batch_count,
+          a_batch_stride,
+          b_batch_stride) {
+  auto type = dtype_to_cublas_type(dtype);
+  c_desc_ = create_matrix_layout(
+      type, b_cols, a_rows, false, ldc, batch_count, c_batch_stride);
+}
+
+CublasGemm::~CublasGemm() {
+  CHECK_CUBLAS_ERROR(cublasLtMatrixLayoutDestroy(a_desc_));
+  CHECK_CUBLAS_ERROR(cublasLtMatrixLayoutDestroy(b_desc_));
+  CHECK_CUBLAS_ERROR(cublasLtMatrixLayoutDestroy(c_desc_));
+  CHECK_CUBLAS_ERROR(cublasLtMatrixLayoutDestroy(out_desc_));
+  CHECK_CUBLAS_ERROR(cublasLtMatmulDescDestroy(matmul_desc_));
+}
+
+void CublasGemm::set_out(
+    Dtype dtype,
+    bool transposed,
+    uint64_t rows,
+    uint64_t cols,
+    int64_t ld,
+    int32_t batch_count,
+    int64_t batch_stride) {
+  CHECK_CUBLAS_ERROR(cublasLtMatrixLayoutDestroy(out_desc_));
+  out_desc_ = create_matrix_layout(
+      dtype_to_cublas_type(dtype),
+      cols,
+      rows,
+      transposed,
+      ld,
+      batch_count,
+      batch_stride);
+}
+
+void CublasGemm::set_bias(cu::CommandEncoder& encoder, const array& bias) {
+  encoder.set_input_array(bias);
+  cublasLtEpilogue_t epilogue = CUBLASLT_EPILOGUE_BIAS;
+  CHECK_CUBLAS_ERROR(cublasLtMatmulDescSetAttribute(
+      matmul_desc_,
+      CUBLASLT_MATMUL_DESC_EPILOGUE,
+      &epilogue,
+      sizeof(epilogue)));
+  auto* bias_ptr = bias.data<void>();
+  CHECK_CUBLAS_ERROR(cublasLtMatmulDescSetAttribute(
+      matmul_desc_,
+      CUBLASLT_MATMUL_DESC_BIAS_POINTER,
+      &bias_ptr,
+      sizeof(bias_ptr)));
+}
+
+void CublasGemm::run(
+    cu::CommandEncoder& encoder,
+    array& out,
+    const array& a,
+    const array& b,
+    const Shape& batch_shape,
+    const Strides& a_batch_strides,
+    const Strides& b_batch_strides,
+    float alpha) {
+  int batch_count = out.size() / (M_ * N_);
+  if (batch_count / batch_shape.back() > 1) {
+    run_batched(
+        encoder,
+        out,
+        a,
+        b,
+        batch_shape,
+        a_batch_strides,
+        b_batch_strides,
+        alpha);
+    return;
+  }
+
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_output_array(out);
+
+  execute(
+      encoder,
+      out.data<void>(),
+      a.data<void>(),
+      b.data<void>(),
+      nullptr,
+      alpha);
+}
+
+void CublasGemm::run(
+    cu::CommandEncoder& encoder,
+    array& out,
+    const array& a,
+    const array& b,
+    const array& c,
+    const Shape& batch_shape,
+    const Strides& a_batch_strides,
+    const Strides& b_batch_strides,
+    const Strides& c_batch_strides,
+    float alpha,
+    float beta) {
+  int batch_count = out.size() / (M_ * N_);
+  if (batch_count / batch_shape.back() > 1) {
+    run_batched(
+        encoder,
+        out,
+        a,
+        b,
+        c,
+        batch_shape,
+        a_batch_strides,
+        b_batch_strides,
+        c_batch_strides,
+        alpha,
+        beta);
+    return;
+  }
+
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_input_array(c);
+  encoder.set_output_array(out);
+
+  execute(
+      encoder,
+      out.data<void>(),
+      a.data<void>(),
+      b.data<void>(),
+      c.data<void>(),
+      alpha,
+      beta);
+}
+
+void CublasGemm::execute(
+    cu::CommandEncoder& encoder,
+    void* out,
+    const void* a,
+    const void* b,
+    const void* c,
+    float alpha /* = 1 */,
+    float beta /* = 0 */) {
+  if (heuristic_.state != CUBLAS_STATUS_SUCCESS) {
+    int ret = 0;
+    CHECK_CUBLAS_ERROR(cublasLtMatmulAlgoGetHeuristic(
+        handle_,
+        matmul_desc_,
+        a_desc_,
+        b_desc_,
+        c ? c_desc_ : out_desc_,
+        out_desc_,
+        pref_,
+        1,
+        &heuristic_,
+        &ret));
+    if (ret == 0) {
+      throw std::runtime_error("Can not find algorithm for matmul.");
+    }
+  }
+
+  const void* alpha_ptr = &alpha;
+  const void* beta_ptr = &beta;
+  complex64_t alpha_c, beta_c;
+  if (scale_type_ == CUDA_C_32F) {
+    alpha_c = complex64_t{alpha, 0.0f};
+    beta_c = complex64_t{beta, 0.0f};
+    alpha_ptr = &alpha_c;
+    beta_ptr = &beta_c;
+  }
+
+  void* workspace_ptr = nullptr;
+  if (heuristic_.workspaceSize > 0) {
+    // Ensure workspace is 256-byte aligned
+    int nbytes = cuda::ceil_div(heuristic_.workspaceSize, 256) * 256;
+    array workspace(
+        allocator::malloc(nbytes),
+        {static_cast<int>(heuristic_.workspaceSize)},
+        int8);
+    encoder.add_temporary(workspace);
+    workspace_ptr = workspace.data<void>();
+  }
+
+  auto capture = encoder.capture_context();
+  CHECK_CUBLAS_ERROR(cublasLtMatmul(
+      handle_,
+      matmul_desc_,
+      alpha_ptr,
+      b, // a and b are swapped
+      a_desc_,
+      a,
+      b_desc_,
+      beta_ptr,
+      c ? c : out,
+      c ? c_desc_ : out_desc_,
+      out,
+      out_desc_,
+      &heuristic_.algo,
+      workspace_ptr,
+      heuristic_.workspaceSize,
+      encoder.stream()));
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/cublas_gemm.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/cublas_gemm.h
new file mode 100644
index 0000000000000000000000000000000000000000..d6d2189b95bf4e39674660b35ff32966e674c8d3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/cublas_gemm.h
@@ -0,0 +1,129 @@
+// Copyright © 2025 Apple Inc.
+#pragma once
+
+#include "mlx/array.h"
+#include "mlx/backend/cuda/device.h"
+
+#include <cublasLt.h>
+
+namespace mlx::core {
+
+class CublasGemm {
+ public:
+  CublasGemm(
+      cu::Device& device,
+      Dtype dtype,
+      bool a_transposed,
+      uint64_t a_rows,
+      uint64_t a_cols,
+      int64_t lda,
+      bool b_transposed,
+      uint64_t b_rows,
+      uint64_t b_cols,
+      int64_t ldb,
+      int32_t batch_count,
+      int64_t a_batch_stride,
+      int64_t b_batch_stride);
+
+  CublasGemm(
+      cu::Device& device,
+      Dtype dtype,
+      bool a_transposed,
+      uint64_t a_rows,
+      uint64_t a_cols,
+      int64_t lda,
+      bool b_transposed,
+      uint64_t b_rows,
+      uint64_t b_cols,
+      int64_t ldb,
+      int64_t ldc,
+      int32_t batch_count,
+      int64_t a_batch_stride,
+      int64_t b_batch_stride,
+      int64_t c_batch_stride);
+
+  ~CublasGemm();
+
+  // The output's descriptor is inferred from inputs by default, use this method
+  // for unusual output.
+  void set_out(
+      Dtype dtype,
+      bool transposed,
+      uint64_t rows,
+      uint64_t cols,
+      int64_t ld,
+      int32_t batch_count,
+      int64_t batch_stride);
+
+  void set_bias(cu::CommandEncoder& encoder, const array& bias);
+
+  void run(
+      cu::CommandEncoder& encoder,
+      array& out,
+      const array& a,
+      const array& b,
+      const Shape& batch_shape,
+      const Strides& a_batch_strides,
+      const Strides& b_batch_strides,
+      float alpha = 1.0f);
+
+  void run(
+      cu::CommandEncoder& encoder,
+      array& out,
+      const array& a,
+      const array& b,
+      const array& c,
+      const Shape& batch_shape,
+      const Strides& a_batch_strides,
+      const Strides& b_batch_strides,
+      const Strides& c_batch_strides,
+      float alpha,
+      float beta);
+
+ private:
+  void run_batched(
+      cu::CommandEncoder& encoder,
+      array& out,
+      const array& a,
+      const array& b,
+      const Shape& batch_shape,
+      const Strides& a_batch_strides,
+      const Strides& b_batch_strides,
+      float alpha);
+
+  void run_batched(
+      cu::CommandEncoder& encoder,
+      array& out,
+      const array& a,
+      const array& b,
+      const array& c,
+      const Shape& batch_shape,
+      const Strides& a_batch_strides,
+      const Strides& b_batch_strides,
+      const Strides& c_batch_strides,
+      float alpha,
+      float beta);
+
+  void execute(
+      cu::CommandEncoder& encoder,
+      void* out,
+      const void* a,
+      const void* b,
+      const void* c,
+      float alpha = 1,
+      float beta = 0);
+
+  uint64_t M_;
+  uint64_t N_;
+  cudaDataType_t scale_type_;
+  cublasLtMatmulPreference_t pref_{nullptr};
+  cublasLtHandle_t handle_{nullptr};
+  cublasLtMatmulDesc_t matmul_desc_{nullptr};
+  cublasLtMatrixLayout_t a_desc_{nullptr};
+  cublasLtMatrixLayout_t b_desc_{nullptr};
+  cublasLtMatrixLayout_t c_desc_{nullptr};
+  cublasLtMatrixLayout_t out_desc_{nullptr};
+  cublasLtMatmulHeuristicResult_t heuristic_;
+};
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/cublas_gemm_batched_12_0.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/cublas_gemm_batched_12_0.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..70df21fda792f0afd802c5279dd63c42ccb9a924
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/cublas_gemm_batched_12_0.cpp
@@ -0,0 +1,75 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/gemms/cublas_gemm.h"
+
+namespace mlx::core {
+
+void CublasGemm::run_batched(
+    cu::CommandEncoder& encoder,
+    array& out,
+    const array& a,
+    const array& b,
+    const Shape& batch_shape,
+    const Strides& a_batch_strides,
+    const Strides& b_batch_strides,
+    float alpha) {
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_output_array(out);
+  auto nbatch = out.size() / (M_ * N_ * batch_shape.back());
+  ContiguousIterator a_it(batch_shape, a_batch_strides, batch_shape.size() - 1);
+  ContiguousIterator b_it(batch_shape, b_batch_strides, batch_shape.size() - 1);
+  auto concurrent = encoder.concurrent_context();
+  for (size_t i = 0; i < nbatch; ++i) {
+    execute(
+        encoder,
+        out.data<int8_t>() + out.itemsize() * i * batch_shape.back() * M_ * N_,
+        a.data<int8_t>() + a.itemsize() * a_it.loc,
+        b.data<int8_t>() + b.itemsize() * b_it.loc,
+        nullptr,
+        alpha);
+    a_it.step();
+    b_it.step();
+  }
+}
+
+void CublasGemm::run_batched(
+    cu::CommandEncoder& encoder,
+    array& out,
+    const array& a,
+    const array& b,
+    const array& c,
+    const Shape& batch_shape,
+    const Strides& a_batch_strides,
+    const Strides& b_batch_strides,
+    const Strides& c_batch_strides,
+    float alpha,
+    float beta) {
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_input_array(c);
+  encoder.set_output_array(out);
+
+  auto nbatch = out.size() / (M_ * N_ * batch_shape.back());
+  ContiguousIterator a_it(batch_shape, a_batch_strides, batch_shape.size() - 1);
+  ContiguousIterator b_it(batch_shape, b_batch_strides, batch_shape.size() - 1);
+  ContiguousIterator c_it(batch_shape, c_batch_strides, batch_shape.size() - 1);
+  auto concurrent = encoder.concurrent_context();
+  for (size_t i = 0; i < nbatch; ++i) {
+    execute(
+        encoder,
+        out.data<int8_t>() + out.itemsize() * i * batch_shape.back() * M_ * N_,
+        a.data<int8_t>() + a.itemsize() * a_it.loc,
+        b.data<int8_t>() + b.itemsize() * b_it.loc,
+        c.data<int8_t>() + c.itemsize() * c_it.loc,
+        alpha,
+        beta);
+    a_it.step();
+    b_it.step();
+    c_it.step();
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/cublas_gemm_batched_12_9.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/cublas_gemm_batched_12_9.cu
new file mode 100644
index 0000000000000000000000000000000000000000..41ab9c8bd4359eef9951e3b0b339bb4bda17c5eb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/cublas_gemm_batched_12_9.cu
@@ -0,0 +1,329 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/gemms/cublas_gemm.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+
+#include <cooperative_groups.h>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <int NDIM>
+__global__ void set_mm_device_pointers_nd(
+    int8_t** pointers,
+    int8_t* a_start,
+    int8_t* b_start,
+    int8_t* out_start,
+    int item_size,
+    const __grid_constant__ cuda::std::array<int32_t, NDIM> batch_shape,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> a_batch_strides,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> b_batch_strides,
+    int64_t batch_stride,
+    int batch_count) {
+  auto index = cg::this_grid().thread_rank();
+  if (index >= batch_count) {
+    return;
+  }
+  auto [a_offset, b_offset] = elem_to_loc_nd<NDIM>(
+      index,
+      batch_shape.data(),
+      a_batch_strides.data(),
+      b_batch_strides.data());
+  pointers[index] = a_start + item_size * a_offset;
+  pointers[index + batch_count] = b_start + item_size * b_offset;
+  pointers[index + 2 * batch_count] =
+      out_start + item_size * index * batch_stride;
+}
+
+__global__ void set_mm_device_pointers_g(
+    int8_t** pointers,
+    int8_t* a_start,
+    int8_t* b_start,
+    int8_t* out_start,
+    int item_size,
+    const __grid_constant__ Shape batch_shape,
+    const __grid_constant__ Strides a_batch_strides,
+    const __grid_constant__ Strides b_batch_strides,
+    int64_t batch_stride,
+    int batch_ndim,
+    int batch_count) {
+  auto index = cg::this_grid().thread_rank();
+  if (index >= batch_count) {
+    return;
+  }
+  auto [a_offset, b_offset] = elem_to_loc(
+      index,
+      batch_shape.data(),
+      a_batch_strides.data(),
+      b_batch_strides.data(),
+      batch_ndim);
+  pointers[index] = a_start + item_size * a_offset;
+  pointers[index + batch_count] = b_start + item_size * b_offset;
+  pointers[index + 2 * batch_count] =
+      out_start + item_size * index * batch_stride;
+}
+
+template <int NDIM>
+__global__ void set_addmm_device_pointers_nd(
+    int8_t** pointers,
+    int8_t* a_start,
+    int8_t* b_start,
+    int8_t* c_start,
+    int8_t* out_start,
+    int item_size,
+    const __grid_constant__ cuda::std::array<int32_t, NDIM> batch_shape,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> a_batch_strides,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> b_batch_strides,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> c_batch_strides,
+    int64_t batch_stride,
+    int batch_count) {
+  auto index = cg::this_grid().thread_rank();
+  if (index >= batch_count) {
+    return;
+  }
+  auto [a_offset, b_offset, c_offset] = elem_to_loc_nd<NDIM>(
+      index,
+      batch_shape.data(),
+      a_batch_strides.data(),
+      b_batch_strides.data(),
+      c_batch_strides.data());
+  pointers[index] = a_start + item_size * a_offset;
+  pointers[index + batch_count] = b_start + item_size * b_offset;
+  pointers[index + 2 * batch_count] = c_start + item_size * c_offset;
+  pointers[index + 3 * batch_count] =
+      out_start + item_size * index * batch_stride;
+}
+
+__global__ void set_addmm_device_pointers_g(
+    int8_t** pointers,
+    int8_t* a_start,
+    int8_t* b_start,
+    int8_t* c_start,
+    int8_t* out_start,
+    int item_size,
+    const __grid_constant__ Shape batch_shape,
+    const __grid_constant__ Strides a_batch_strides,
+    const __grid_constant__ Strides b_batch_strides,
+    const __grid_constant__ Strides c_batch_strides,
+    int64_t batch_stride,
+    int batch_ndim,
+    int batch_count) {
+  auto index = cg::this_grid().thread_rank();
+  if (index >= batch_count) {
+    return;
+  }
+  auto [a_offset, b_offset, c_offset] = elem_to_loc(
+      index,
+      batch_shape.data(),
+      a_batch_strides.data(),
+      b_batch_strides.data(),
+      c_batch_strides.data(),
+      batch_ndim);
+  pointers[index] = a_start + item_size * a_offset;
+  pointers[index + batch_count] = b_start + item_size * b_offset;
+  pointers[index + 2 * batch_count] = c_start + item_size * c_offset;
+  pointers[index + 3 * batch_count] =
+      out_start + item_size * index * batch_stride;
+}
+
+} // namespace cu
+
+namespace {
+
+void set_pointer_mode(cublasLtMatrixLayout_t desc, int batch_count) {
+  auto batch_mode = CUBLASLT_BATCH_MODE_POINTER_ARRAY;
+  CHECK_CUBLAS_ERROR(cublasLtMatrixLayoutSetAttribute(
+      desc,
+      CUBLASLT_MATRIX_LAYOUT_BATCH_MODE,
+      &batch_mode,
+      sizeof(batch_mode)));
+  CHECK_CUBLAS_ERROR(cublasLtMatrixLayoutSetAttribute(
+      desc, CUBLASLT_MATRIX_LAYOUT_BATCH_COUNT, &batch_count, sizeof(int32_t)));
+}
+
+} // namespace
+
+void CublasGemm::run_batched(
+    cu::CommandEncoder& encoder,
+    array& out,
+    const array& a,
+    const array& b,
+    const Shape& batch_shape,
+    const Strides& a_batch_strides,
+    const Strides& b_batch_strides,
+    float alpha) {
+  int batch_count = out.size() / (M_ * N_);
+  set_pointer_mode(a_desc_, batch_count);
+  set_pointer_mode(b_desc_, batch_count);
+  set_pointer_mode(out_desc_, batch_count);
+
+  // Launch kernel to set device offsets
+  auto pointers = array(
+      allocator::malloc(batch_count * sizeof(void*) * 3),
+      {batch_count * 3},
+      uint64);
+
+  encoder.add_temporary(pointers);
+  encoder.set_output_array(pointers);
+
+  int block_dims = std::min(batch_count, 256);
+  int num_blocks = cuda::ceil_div(batch_count, block_dims);
+  int64_t batch_stride = M_ * N_;
+  int item_size = out.itemsize();
+
+  int ndim = batch_shape.size();
+  if (ndim <= 3) {
+    dispatch_1_2_3(ndim, [&](auto ndim_constant) {
+      encoder.add_kernel_node(
+          cu::set_mm_device_pointers_nd<ndim_constant()>,
+          num_blocks,
+          block_dims,
+          0,
+          pointers.data<int8_t*>(),
+          a.data<int8_t>(),
+          b.data<int8_t>(),
+          out.data<int8_t>(),
+          item_size,
+          const_param<ndim_constant()>(batch_shape),
+          const_param<ndim_constant()>(a_batch_strides),
+          const_param<ndim_constant()>(b_batch_strides),
+          batch_stride,
+          batch_count);
+    });
+  } else {
+    encoder.add_kernel_node(
+        cu::set_mm_device_pointers_g,
+        num_blocks,
+        block_dims,
+        0,
+        pointers.data<int8_t*>(),
+        a.data<int8_t>(),
+        b.data<int8_t>(),
+        out.data<int8_t>(),
+        item_size,
+        const_param(batch_shape),
+        const_param(a_batch_strides),
+        const_param(b_batch_strides),
+        batch_stride,
+        ndim,
+        batch_count);
+  }
+
+  // Run matmul
+  encoder.set_input_array(pointers);
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_output_array(out);
+
+  auto a_pointers = pointers.data<int8_t*>();
+  auto b_pointers = a_pointers + batch_count;
+  auto out_pointers = b_pointers + batch_count;
+  execute(
+      encoder,
+      reinterpret_cast<void*>(out_pointers),
+      reinterpret_cast<void*>(a_pointers),
+      reinterpret_cast<void*>(b_pointers),
+      nullptr,
+      alpha);
+}
+
+void CublasGemm::run_batched(
+    cu::CommandEncoder& encoder,
+    array& out,
+    const array& a,
+    const array& b,
+    const array& c,
+    const Shape& batch_shape,
+    const Strides& a_batch_strides,
+    const Strides& b_batch_strides,
+    const Strides& c_batch_strides,
+    float alpha,
+    float beta) {
+  int batch_count = out.size() / (M_ * N_);
+  set_pointer_mode(a_desc_, batch_count);
+  set_pointer_mode(b_desc_, batch_count);
+  set_pointer_mode(c_desc_, batch_count);
+  set_pointer_mode(out_desc_, batch_count);
+
+  // Launch kernel to set device offsets
+  auto pointers = array(
+      allocator::malloc(batch_count * sizeof(uint64_t) * 4),
+      {batch_count * 4},
+      uint64);
+
+  encoder.add_temporary(pointers);
+  encoder.set_output_array(pointers);
+
+  int block_dims = std::min(batch_count, 256);
+  int num_blocks = cuda::ceil_div(batch_count, block_dims);
+  int64_t batch_stride = M_ * N_;
+  int item_size = out.itemsize();
+
+  int ndim = batch_shape.size();
+  if (ndim <= 3) {
+    dispatch_1_2_3(ndim, [&](auto ndim_constant) {
+      encoder.add_kernel_node(
+          cu::set_addmm_device_pointers_nd<ndim_constant()>,
+          num_blocks,
+          block_dims,
+          0,
+          pointers.data<int8_t*>(),
+          a.data<int8_t>(),
+          b.data<int8_t>(),
+          c.data<int8_t>(),
+          out.data<int8_t>(),
+          item_size,
+          const_param<ndim_constant()>(batch_shape),
+          const_param<ndim_constant()>(a_batch_strides),
+          const_param<ndim_constant()>(b_batch_strides),
+          const_param<ndim_constant()>(c_batch_strides),
+          batch_stride,
+          batch_count);
+    });
+  } else {
+    encoder.add_kernel_node(
+        cu::set_addmm_device_pointers_g,
+        num_blocks,
+        block_dims,
+        0,
+        pointers.data<int8_t*>(),
+        a.data<int8_t>(),
+        b.data<int8_t>(),
+        c.data<int8_t>(),
+        out.data<int8_t>(),
+        item_size,
+        const_param(batch_shape),
+        const_param(a_batch_strides),
+        const_param(b_batch_strides),
+        const_param(c_batch_strides),
+        batch_stride,
+        ndim,
+        batch_count);
+  }
+
+  // Run matmul
+  encoder.set_input_array(pointers);
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_input_array(c);
+  encoder.set_output_array(out);
+
+  auto a_pointers = pointers.data<int8_t*>();
+  auto b_pointers = a_pointers + batch_count;
+  auto c_pointers = b_pointers + batch_count;
+  auto out_pointers = c_pointers + batch_count;
+  execute(
+      encoder,
+      reinterpret_cast<void*>(out_pointers),
+      reinterpret_cast<void*>(a_pointers),
+      reinterpret_cast<void*>(b_pointers),
+      reinterpret_cast<void*>(c_pointers),
+      alpha,
+      beta);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/gemv.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/gemv.cu
new file mode 100644
index 0000000000000000000000000000000000000000..e1c7550396734bdb6d474bf8676a7d9dec505f9b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/gemv.cu
@@ -0,0 +1,204 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/gemms/gemv.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/dtype_utils.h"
+
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+
+namespace mlx::core::cu {
+
+namespace cg = cooperative_groups;
+
+static constexpr int rows_per_block = 8;
+
+// Accumulator type selection per input element type T.
+template <typename T>
+struct GemvAccType {
+  using type = T;
+};
+
+template <>
+struct GemvAccType<__half> {
+  using type = float;
+};
+
+template <>
+struct GemvAccType<__nv_bfloat16> {
+  using type = float;
+};
+
+template <>
+struct GemvAccType<float> {
+  using type = float;
+};
+
+template <>
+struct GemvAccType<double> {
+  using type = double;
+};
+
+template <>
+struct GemvAccType<cu::complex64_t> {
+  using type = cu::complex64_t;
+};
+
+template <typename T, int rows_per_block, int n_per_thread>
+__device__ void
+gemv_impl(const T* mat, const T* vec, T* out, int rows, int cols) {
+  auto block = cg::this_thread_block();
+  auto warp = cg::tiled_partition<WARP_SIZE>(block);
+
+  auto g_idx = block.group_index();
+  auto t_idx = block.thread_index();
+  int row = g_idx.x * rows_per_block + t_idx.y;
+
+  if (row < rows) {
+    using Acc = typename GemvAccType<T>::type;
+    Acc sum = Acc(0);
+    for (int col = n_per_thread * warp.thread_rank(); col < cols;
+         col += (WARP_SIZE * n_per_thread)) {
+      auto local_mat =
+          unsafe_load_vector<n_per_thread>(mat + row * cols + col, 0);
+      auto local_vec = unsafe_load_vector<n_per_thread>(vec + col, 0);
+#pragma unroll
+      for (int j = 0; j < n_per_thread; ++j) {
+        sum += static_cast<Acc>(local_mat[j]) * static_cast<Acc>(local_vec[j]);
+      }
+    }
+
+    sum = cg::reduce(warp, sum, cg::plus<Acc>{});
+    if (warp.thread_rank() == 0) {
+      out[row] = static_cast<T>(sum);
+    }
+  }
+}
+
+template <typename T, int rows_per_block, int n_per_thread>
+__global__ void
+gemv_single(const T* mat, const T* vec, T* out, int rows, int cols) {
+  gemv_impl<T, rows_per_block, n_per_thread>(mat, vec, out, rows, cols);
+}
+
+template <typename T, int rows_per_block, int n_per_thread>
+__global__ void gemv_batched(
+    const T* mat,
+    const T* vec,
+    T* out,
+    int rows,
+    int cols,
+    const __grid_constant__ Shape batch_shape,
+    const __grid_constant__ Strides mat_batch_strides,
+    const __grid_constant__ Strides vec_batch_strides,
+    int batch_ndim) {
+  auto block = cg::this_thread_block();
+  auto batch_idx = block.group_index().y;
+  auto [vec_offset, mat_offset] = elem_to_loc(
+      batch_idx,
+      batch_shape.data(),
+      vec_batch_strides.data(),
+      mat_batch_strides.data(),
+      batch_ndim);
+  gemv_impl<T, rows_per_block, n_per_thread>(
+      mat + mat_offset, vec + vec_offset, out + batch_idx * rows, rows, cols);
+}
+
+bool can_use_gemv(int M, int N, int K, bool a_transposed, bool b_transposed) {
+  return K % 32 == 0 && ((M == 1 && b_transposed) || (N == 1 && !a_transposed));
+}
+
+template <typename F>
+void dispatch_n_per_thread(int n_per_thread, F&& f) {
+  switch (n_per_thread) {
+    case 1:
+      f(std::integral_constant<int, 1>{});
+      break;
+    case 2:
+      f(std::integral_constant<int, 2>{});
+      break;
+    case 4:
+      f(std::integral_constant<int, 4>{});
+      break;
+  }
+}
+
+void gemv(
+    const array& a,
+    const array& b,
+    array& out,
+    int M,
+    int N,
+    int K,
+    uint32_t batch_count,
+    const mlx::core::Shape& batch_shape,
+    const mlx::core::Strides& a_batch_strides,
+    const mlx::core::Strides& b_batch_strides,
+    CommandEncoder& encoder) {
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_output_array(out);
+  dispatch_inexact_types(out.dtype(), "gemv", [&](auto type_tag) {
+    using DataType = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+    dim3 block_dims{WARP_SIZE, rows_per_block};
+    const DataType* mat;
+    const DataType* vec;
+    int rows;
+    int cols = K;
+    auto mat_strides = const_param(a_batch_strides);
+    auto vec_strides = const_param(b_batch_strides);
+
+    if (M == 1) {
+      mat = b.data<DataType>();
+      vec = a.data<DataType>();
+      rows = N;
+      std::swap(mat_strides, vec_strides);
+    } else {
+      mat = a.data<DataType>();
+      vec = b.data<DataType>();
+      rows = M;
+    }
+    uint32_t num_blocks_x = (rows + rows_per_block - 1) / rows_per_block;
+    int n_per_t;
+    if (K % 128 == 0 && is_aligned<4>(mat) && is_aligned<4>(vec)) {
+      n_per_t = 4;
+    } else if (K % 64 == 0 && is_aligned<2>(mat) && is_aligned<2>(vec)) {
+      n_per_t = 2;
+    } else {
+      n_per_t = 1;
+    }
+    dispatch_n_per_thread(n_per_t, [&](auto n_per_thread) {
+      if (batch_count == 1) {
+        auto kernel = gemv_single<DataType, rows_per_block, n_per_thread()>;
+        encoder.add_kernel_node(
+            kernel,
+            num_blocks_x,
+            block_dims,
+            0,
+            mat,
+            vec,
+            out.data<DataType>(),
+            rows,
+            cols);
+      } else {
+        auto kernel = gemv_batched<DataType, rows_per_block, n_per_thread()>;
+        encoder.add_kernel_node(
+            kernel,
+            dim3{num_blocks_x, batch_count},
+            block_dims,
+            0,
+            mat,
+            vec,
+            out.data<DataType>(),
+            rows,
+            cols,
+            const_param(batch_shape),
+            mat_strides,
+            vec_strides,
+            batch_shape.size());
+      }
+    });
+  });
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/gemv.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/gemv.h
new file mode 100644
index 0000000000000000000000000000000000000000..27173aad5adcbda24303571b34c9ce020640770f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/gemms/gemv.h
@@ -0,0 +1,24 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cuda/device.h"
+
+namespace mlx::core::cu {
+
+bool can_use_gemv(int M, int N, int K, bool a_transposed, bool b_transposed);
+
+void gemv(
+    const array& a,
+    const array& b,
+    array& out,
+    int M,
+    int N,
+    int K,
+    uint32_t batch_count,
+    const mlx::core::Shape& batch_shape,
+    const mlx::core::Strides& a_batch_strides,
+    const mlx::core::Strides& b_batch_strides,
+    CommandEncoder& encoder);
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/indexing.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/indexing.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1d867e063638de7cbc10fde3851cd8a1916d5615
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/indexing.cpp
@@ -0,0 +1,430 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/compiled.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/jit_module.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+#include "cuda_jit_sources.h"
+
+#include <cuda.h>
+#include <fmt/format.h>
+#include <nvrtc.h>
+#include <nvtx3/nvtx3.hpp>
+
+#include <cassert>
+#include <numeric>
+
+namespace mlx::core {
+
+namespace {
+
+constexpr const char* g_scatter_ops[] = {"Max", "Min", "Sum", "Prod", "Assign"};
+
+void append_indices_arg(
+    cu::KernelArgs& args,
+    const std::vector<array>& inputs,
+    int nidx,
+    int idx_ndim) {
+  SmallVector<const void*> indices(nidx);
+  for (int i = 0; i < nidx; ++i) {
+    indices[i] = inputs[i + 1].data<void>();
+  }
+  args.append(std::move(indices));
+  SmallVector<int32_t> indices_shape(nidx * idx_ndim);
+  for (int i = 0; i < nidx; ++i) {
+    std::copy_n(
+        inputs[i + 1].shape().begin(),
+        idx_ndim,
+        indices_shape.data() + i * idx_ndim);
+  }
+  args.append(std::move(indices_shape));
+  SmallVector<int64_t> indices_strides(nidx * idx_ndim);
+  for (int i = 0; i < nidx; ++i) {
+    std::copy_n(
+        inputs[i + 1].strides().begin(),
+        idx_ndim,
+        indices_strides.data() + i * idx_ndim);
+  }
+  args.append(std::move(indices_strides));
+}
+
+} // namespace
+
+void Gather::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Gather::eval_gpu");
+  assert(inputs.size() > 0);
+  const auto& src = inputs[0];
+
+  out.set_data(allocator::malloc(out.nbytes()));
+  if (out.size() == 0) {
+    return;
+  }
+
+  int nidx = inputs.size() - 1;
+  Dtype idx_dtype = nidx > 0 ? inputs[1].dtype() : int32;
+  int32_t idx_ndim = nidx > 0 ? inputs[1].ndim() : 0;
+
+  bool large = (nidx > 0 && inputs[1].size() > INT32_MAX) ||
+      (src.size() > INT32_MAX) || (out.size() > INT32_MAX);
+
+  uint32_t slice_size = std::accumulate(
+      slice_sizes_.begin(), slice_sizes_.end(), 1, std::multiplies<uint32_t>());
+
+  std::string module_name = fmt::format(
+      "gather_{}_{}_{}",
+      dtype_to_string(out.dtype()),
+      dtype_to_string(idx_dtype),
+      nidx);
+
+  auto& s = stream();
+  cu::JitModule& mod = cu::get_jit_module(s.device, module_name, [&]() {
+    std::vector<std::string> kernel_names;
+    for (int ndim = 0; ndim <= MAX_NDIM; ++ndim) {
+      for (int large = 0; large <= 1; ++large) {
+        kernel_names.push_back(fmt::format(
+            "mlx::core::cu::gather<{}, {}, {}, {}, {}>",
+            dtype_to_cuda_type(out.dtype()),
+            dtype_to_cuda_type(idx_dtype),
+            nidx,
+            ndim,
+            large ? "int64_t" : "int32_t"));
+      }
+    }
+    return std::make_tuple(false, jit_source_gather, std::move(kernel_names));
+  });
+
+  cu::KernelArgs args;
+  args.append(src);
+  args.append(out);
+  if (large) {
+    args.append<int64_t>(out.size());
+  } else {
+    args.append<int32_t>(out.size());
+  }
+  args.append_ndim(src.shape());
+  args.append_ndim(src.strides());
+  args.append<int32_t>(src.ndim());
+  args.append_ndim(slice_sizes_);
+  args.append(slice_size);
+  args.append(axes_);
+  append_indices_arg(args, inputs, nidx, idx_ndim);
+
+  std::string kernel_name = fmt::format(
+      "mlx::core::cu::gather<{}, {}, {}, {}, {}>",
+      dtype_to_cuda_type(out.dtype()),
+      dtype_to_cuda_type(idx_dtype),
+      nidx,
+      idx_ndim,
+      large ? "int64_t" : "int32_t");
+
+  auto& encoder = cu::get_command_encoder(s);
+  for (const auto& in : inputs) {
+    encoder.set_input_array(in);
+  }
+  encoder.set_output_array(out);
+
+  auto kernel = mod.get_kernel(kernel_name);
+  auto [num_blocks, block_dims] = get_launch_args(out, large);
+  encoder.add_kernel_node(kernel, num_blocks, block_dims, 0, args.args());
+}
+
+void Scatter::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Gather::eval_gpu");
+  assert(inputs.size() > 1);
+  auto& upd = inputs.back();
+
+  // Copy src into out.
+  CopyType copy_type;
+  if (inputs[0].data_size() == 1) {
+    copy_type = CopyType::Scalar;
+  } else if (inputs[0].flags().row_contiguous) {
+    copy_type = CopyType::Vector;
+  } else {
+    copy_type = CopyType::General;
+  }
+  copy_gpu(inputs[0], out, copy_type);
+
+  // Empty update.
+  if (upd.size() == 0) {
+    return;
+  }
+
+  int nidx = axes_.size();
+  Dtype idx_dtype = nidx > 0 ? inputs[1].dtype() : int32;
+  int32_t idx_ndim = nidx > 0 ? inputs[1].ndim() : 0;
+
+  bool large = (nidx > 0 && inputs[1].size() > INT32_MAX) ||
+      (upd.size() > INT32_MAX) || (out.size() > INT32_MAX);
+
+  int32_t upd_post_idx_size = std::accumulate(
+      upd.shape().begin() + idx_ndim,
+      upd.shape().end(),
+      1,
+      std::multiplies<int32_t>());
+
+  const char* op = g_scatter_ops[reduce_type_];
+  std::string module_name = fmt::format(
+      "scatter_{}_{}_{}_{}",
+      dtype_to_string(out.dtype()),
+      dtype_to_string(idx_dtype),
+      op,
+      nidx);
+
+  auto& s = stream();
+  cu::JitModule& mod = cu::get_jit_module(s.device, module_name, [&]() {
+    std::vector<std::string> kernel_names;
+    for (int ndim = 0; ndim <= MAX_NDIM; ++ndim) {
+      for (int large = 0; large <= 1; ++large) {
+        kernel_names.push_back(fmt::format(
+            "mlx::core::cu::scatter<{}, {}, mlx::core::cu::Scatter{}, {}, {}, {}>",
+            dtype_to_cuda_type(out.dtype()),
+            dtype_to_cuda_type(idx_dtype),
+            op,
+            nidx,
+            ndim,
+            large ? "int64_t" : "int32_t"));
+      }
+    }
+    return std::make_tuple(false, jit_source_scatter, std::move(kernel_names));
+  });
+
+  cu::KernelArgs args;
+  args.append(upd);
+  args.append(out);
+  if (large) {
+    args.append<int64_t>(upd.size());
+  } else {
+    args.append<int32_t>(upd.size());
+  }
+  args.append_ndim(upd.shape());
+  args.append_ndim(upd.strides());
+  args.append<int32_t>(upd.ndim());
+  if (large) {
+    args.append<int64_t>(upd_post_idx_size);
+  } else {
+    args.append<int32_t>(upd_post_idx_size);
+  }
+  args.append_ndim(out.shape());
+  args.append_ndim(out.strides());
+  args.append<int32_t>(out.ndim());
+  args.append(axes_);
+  append_indices_arg(args, inputs, nidx, idx_ndim);
+
+  std::string kernel_name = fmt::format(
+      "mlx::core::cu::scatter<{}, {}, mlx::core::cu::Scatter{}, {}, {}, {}>",
+      dtype_to_cuda_type(out.dtype()),
+      dtype_to_cuda_type(idx_dtype),
+      op,
+      nidx,
+      idx_ndim,
+      large ? "int64_t" : "int32_t");
+
+  auto& encoder = cu::get_command_encoder(s);
+  for (const auto& in : inputs) {
+    encoder.set_input_array(in);
+  }
+  encoder.set_output_array(out);
+  auto kernel = mod.get_kernel(kernel_name);
+  auto [num_blocks, block_dims] = get_launch_args(upd, large);
+  encoder.add_kernel_node(kernel, num_blocks, block_dims, 0, args.args());
+}
+
+void GatherAxis::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("GatherAxis::eval_gpu");
+  assert(inputs.size() > 1);
+  const auto& src = inputs[0];
+  const auto& idx = inputs[1];
+
+  out.set_data(allocator::malloc(out.nbytes()));
+  if (out.size() == 0) {
+    return;
+  }
+
+  bool large = idx.size() > INT32_MAX || src.size() > INT32_MAX;
+
+  std::string module_name = fmt::format(
+      "gather_axis_{}_{}",
+      dtype_to_string(out.dtype()),
+      dtype_to_string(idx.dtype()));
+
+  auto& s = stream();
+  cu::JitModule& mod = cu::get_jit_module(s.device, module_name, [&]() {
+    std::vector<std::string> kernel_names;
+    for (int ndim = 0; ndim <= MAX_NDIM; ++ndim) {
+      for (int contiguous = 0; contiguous < 4; ++contiguous) {
+        for (int large = 0; large <= 1; ++large) {
+          kernel_names.push_back(fmt::format(
+              "mlx::core::cu::gather_axis<{}, {}, {}, {}, {}, {}>",
+              dtype_to_cuda_type(out.dtype()),
+              dtype_to_cuda_type(idx.dtype()),
+              ndim,
+              contiguous & 1 ? true : false,
+              contiguous & 2 ? true : false,
+              large ? "int64_t" : "int32_t"));
+        }
+      }
+    }
+    return std::make_tuple(
+        false, jit_source_gather_axis, std::move(kernel_names));
+  });
+
+  size_t idx_size_pre = 1;
+  size_t idx_size_post = 1;
+  for (int i = 0; i < axis_; ++i) {
+    idx_size_pre *= idx.shape(i);
+  }
+  for (int i = axis_ + 1; i < idx.ndim(); ++i) {
+    idx_size_post *= idx.shape(i);
+  }
+  size_t idx_size_axis = idx.shape(axis_);
+
+  cu::KernelArgs args;
+  args.append(src);
+  args.append(idx);
+  args.append(out);
+  if (large) {
+    args.append<int64_t>(idx_size_pre);
+    args.append<int64_t>(idx_size_axis);
+    args.append<int64_t>(idx_size_post);
+  } else {
+    args.append<int32_t>(idx_size_pre);
+    args.append<int32_t>(idx_size_axis);
+    args.append<int32_t>(idx_size_post);
+  }
+  args.append(remove_index(idx.shape(), axis_));
+  args.append(remove_index(src.strides(), axis_));
+  args.append(remove_index(idx.strides(), axis_));
+  args.append<int32_t>(axis_);
+  args.append(src.shape(axis_));
+  args.append(src.strides(axis_));
+  args.append(idx.strides(axis_));
+
+  std::string kernel_name = fmt::format(
+      "mlx::core::cu::gather_axis<{}, {}, {}, {}, {}, {}>",
+      dtype_to_cuda_type(out.dtype()),
+      dtype_to_cuda_type(idx.dtype()),
+      src.ndim() - 1,
+      src.flags().row_contiguous,
+      idx.flags().row_contiguous,
+      large ? "int64_t" : "int32_t");
+
+  auto& encoder = cu::get_command_encoder(s);
+  for (const auto& in : inputs) {
+    encoder.set_input_array(in);
+  }
+  encoder.set_output_array(out);
+  auto kernel = mod.get_kernel(kernel_name);
+  auto [num_blocks, block_dims] = get_launch_args(idx, large);
+  encoder.add_kernel_node(kernel, num_blocks, block_dims, 0, args.args());
+}
+
+void ScatterAxis::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("ScatterAxis::eval_gpu");
+  assert(inputs.size() > 2);
+  const auto& src = inputs[0];
+  const auto& idx = inputs[1];
+  const auto& upd = inputs[2];
+
+  // Copy src into out.
+  CopyType copy_type;
+  if (src.data_size() == 1) {
+    copy_type = CopyType::Scalar;
+  } else if (src.flags().row_contiguous) {
+    copy_type = CopyType::Vector;
+  } else {
+    copy_type = CopyType::General;
+  }
+  copy_gpu(src, out, copy_type);
+
+  // Empty update.
+  if (upd.size() == 0) {
+    return;
+  }
+
+  bool large = idx.size() > INT32_MAX || src.size() > INT32_MAX;
+
+  const char* op = reduce_type_ == ScatterAxis::Sum ? "Sum" : "Assign";
+  std::string module_name = fmt::format(
+      "scatter_axis_{}_{}_{}",
+      dtype_to_string(out.dtype()),
+      dtype_to_string(idx.dtype()),
+      op);
+
+  auto& s = stream();
+  cu::JitModule& mod = cu::get_jit_module(s.device, module_name, [&]() {
+    std::vector<std::string> kernel_names;
+    for (int ndim = 0; ndim <= MAX_NDIM; ++ndim) {
+      for (int contiguous = 0; contiguous < 4; ++contiguous) {
+        for (int large = 0; large <= 1; ++large) {
+          kernel_names.push_back(fmt::format(
+              "mlx::core::cu::scatter_axis<{}, {}, mlx::core::cu::Scatter{}, {}, {}, {}, {}>",
+              dtype_to_cuda_type(out.dtype()),
+              dtype_to_cuda_type(idx.dtype()),
+              op,
+              ndim,
+              contiguous & 1 ? true : false,
+              contiguous & 2 ? true : false,
+              large ? "int64_t" : "int32_t"));
+        }
+      }
+    }
+    return std::make_tuple(
+        false, jit_source_scatter_axis, std::move(kernel_names));
+  });
+
+  size_t idx_size_pre = 1;
+  size_t idx_size_post = 1;
+  for (int i = 0; i < axis_; ++i) {
+    idx_size_pre *= idx.shape(i);
+  }
+  for (int i = axis_ + 1; i < idx.ndim(); ++i) {
+    idx_size_post *= idx.shape(i);
+  }
+  size_t idx_size_axis = idx.shape(axis_);
+
+  cu::KernelArgs args;
+  args.append(upd);
+  args.append(idx);
+  args.append(out);
+  if (large) {
+    args.append<int64_t>(idx_size_pre);
+    args.append<int64_t>(idx_size_axis);
+    args.append<int64_t>(idx_size_post);
+  } else {
+    args.append<int32_t>(idx_size_pre);
+    args.append<int32_t>(idx_size_axis);
+    args.append<int32_t>(idx_size_post);
+  }
+  args.append(remove_index(idx.shape(), axis_));
+  args.append(remove_index(upd.strides(), axis_));
+  args.append(remove_index(idx.strides(), axis_));
+  args.append<int32_t>(axis_);
+  args.append(out.shape(axis_));
+  args.append(upd.strides(axis_));
+  args.append(idx.strides(axis_));
+
+  std::string kernel_name = fmt::format(
+      "mlx::core::cu::scatter_axis<{}, {}, mlx::core::cu::Scatter{}, {}, {}, {}, {}>",
+      dtype_to_cuda_type(out.dtype()),
+      dtype_to_cuda_type(idx.dtype()),
+      op,
+      idx.ndim() - 1,
+      upd.flags().row_contiguous,
+      idx.flags().row_contiguous,
+      large ? "int64_t" : "int32_t");
+
+  auto& encoder = cu::get_command_encoder(s);
+  for (const auto& in : inputs) {
+    encoder.set_input_array(in);
+  }
+  encoder.set_output_array(out);
+  auto kernel = mod.get_kernel(kernel_name);
+  auto [num_blocks, block_dims] = get_launch_args(idx, large);
+  encoder.add_kernel_node(kernel, num_blocks, block_dims, 0, args.args());
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/jit_module.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/jit_module.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2801e4a67a1950ead7e883464c60b92b66578b0e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/jit_module.cpp
@@ -0,0 +1,443 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/jit_module.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/version.h"
+
+#include "cuda_jit_sources.h"
+
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+
+#include <fmt/format.h>
+#include <nvrtc.h>
+#include <unistd.h>
+
+namespace mlx::core::cu {
+
+namespace {
+
+#define CHECK_NVRTC_ERROR(cmd) check_nvrtc_error(#cmd, (cmd))
+
+void check_nvrtc_error(const char* name, nvrtcResult err) {
+  if (err != NVRTC_SUCCESS) {
+    throw std::runtime_error(
+        fmt::format("{} failed: {}", name, nvrtcGetErrorString(err)));
+  }
+}
+
+// Return the location of the CUDA toolkit.
+const std::string& cuda_home() {
+  static std::string home = []() -> std::string {
+    const char* home = std::getenv("CUDA_HOME");
+    if (home) {
+      return home;
+    }
+    home = std::getenv("CUDA_PATH");
+    if (home) {
+      return home;
+    }
+#if defined(__linux__)
+    home = "/usr/local/cuda";
+    if (std::filesystem::exists(home)) {
+      return home;
+    }
+#endif
+    throw std::runtime_error(
+        "Environment variable CUDA_HOME or CUDA_PATH is not set.");
+  }();
+  return home;
+}
+
+// Return the location of CCCL headers shipped with the distribution.
+const std::string& cccl_dir() {
+  static std::string dir = []() {
+    std::filesystem::path path;
+#if defined(MLX_CCCL_DIR)
+    // First search the install dir if defined.
+    path = MLX_CCCL_DIR;
+    if (std::filesystem::exists(path)) {
+      return path.string();
+    }
+#endif
+    // Then search dynamically from the dir of libmlx.so file.
+    path = current_binary_dir().parent_path() / "include" / "cccl";
+    if (std::filesystem::exists(path)) {
+      return path.string();
+    }
+    // Finally check the environment variable.
+    if (const char* env = std::getenv("MLX_CCCL_DIR"); env) {
+      path = env;
+      if (!path.empty() && std::filesystem::exists(path)) {
+        return path.string();
+      }
+    }
+    return std::string();
+  }();
+  return dir;
+}
+
+// Get the cache directory for storing compiled results.
+const std::filesystem::path& ptx_cache_dir() {
+  static std::filesystem::path cache = []() -> std::filesystem::path {
+    std::filesystem::path cache;
+    if (auto c = std::getenv("MLX_PTX_CACHE_DIR"); c) {
+      cache = c;
+    } else {
+      cache =
+          std::filesystem::temp_directory_path() / "mlx" / version() / "ptx";
+    }
+    if (!std::filesystem::exists(cache)) {
+      std::error_code error;
+      if (!std::filesystem::create_directories(cache, error)) {
+        return std::filesystem::path();
+      }
+    }
+    return cache;
+  }();
+  return cache;
+}
+
+std::filesystem::path get_ptx_path(
+    const std::filesystem::path& cache_dir,
+    const std::string& module_name) {
+#ifdef _WIN32
+  constexpr int max_file_name_length = 140;
+#else
+  constexpr int max_file_name_length = 245;
+#endif
+
+  if (module_name.size() <= max_file_name_length) {
+    return cache_dir / (module_name + ".ptx");
+  }
+
+  auto ptx_path = cache_dir;
+  int offset = 0;
+  while (module_name.size() - offset > max_file_name_length) {
+    ptx_path /= module_name.substr(offset, max_file_name_length);
+    offset += max_file_name_length;
+  }
+  ptx_path /= module_name.substr(offset) + ".ptx";
+
+  return ptx_path;
+}
+
+// Try to read the cached |ptx| and |ptx_kernels| from |cache_dir|.
+bool read_cached_ptx(
+    const std::filesystem::path& cache_dir,
+    const std::string& module_name,
+    std::string& ptx,
+    std::vector<std::pair<std::string, std::string>>& ptx_kernels) {
+  if (cache_dir.empty()) {
+    return false;
+  }
+
+  auto ptx_path = get_ptx_path(cache_dir, module_name);
+  std::error_code error;
+  auto ptx_size = std::filesystem::file_size(ptx_path, error);
+  if (error) {
+    return false;
+  }
+  std::ifstream ptx_file(ptx_path, std::ios::binary);
+  if (!ptx_file.good()) {
+    return false;
+  }
+  ptx.resize(ptx_size);
+  ptx_file.read(ptx.data(), ptx_size);
+
+  std::ifstream txt_file(ptx_path.replace_extension(".txt"), std::ios::binary);
+  std::string line;
+  while (std::getline(txt_file, line)) {
+    auto tab = line.find('\t');
+    if (tab != std::string::npos) {
+      ptx_kernels.emplace_back(line.substr(0, tab), line.substr(tab + 1));
+    }
+  }
+  return true;
+}
+
+// Write the |ptx| and |ptx_kernels| to |cache_dir| with |name|.
+void write_cached_ptx(
+    const std::filesystem::path& cache_dir,
+    const std::string& module_name,
+    const std::string& ptx,
+    const std::vector<std::pair<std::string, std::string>>& ptx_kernels,
+    const std::string& source_code) {
+  if (cache_dir.empty()) {
+    return;
+  }
+
+  auto ptx_path = get_ptx_path(cache_dir, module_name);
+
+  // Ensure that the directory exists
+  auto parent = ptx_path.parent_path();
+  if (parent != cache_dir) {
+    std::filesystem::create_directories(parent);
+  }
+
+  // Write the compiled code and mangled names
+  std::ofstream ptx_file(ptx_path, std::ios::binary);
+  if (!ptx.empty()) {
+    ptx_file.write(&ptx.front(), ptx.size());
+  }
+  std::ofstream txt_file(ptx_path.replace_extension(".txt"), std::ios::binary);
+  for (const auto& [name, mangled] : ptx_kernels) {
+    txt_file << name << "\t" << mangled << std::endl;
+  }
+
+  // Write the generated code
+  std::ofstream source_file(ptx_path.replace_extension(".cu"));
+  source_file << source_code;
+}
+
+// Return if |device|'s version is not newer than |major|.|minor| version.
+inline bool version_lower_equal(Device& device, int major, int minor) {
+  if (device.compute_capability_major() < major) {
+    return true;
+  } else if (device.compute_capability_major() == major) {
+    return device.compute_capability_minor() <= minor;
+  } else {
+    return false;
+  }
+}
+
+// Return whether NVRTC supports compiling to |device|'s SASS code.
+bool compiler_supports_device_sass(Device& device) {
+  int nvrtc_major, nvrtc_minor;
+  CHECK_NVRTC_ERROR(nvrtcVersion(&nvrtc_major, &nvrtc_minor));
+  if (nvrtc_major < 9) {
+    return false;
+  } else if (nvrtc_major == 9) {
+    return version_lower_equal(device, 7, 2);
+  } else if (nvrtc_major == 10) {
+    return version_lower_equal(device, 7, 5);
+  } else if (nvrtc_major == 11 && nvrtc_minor == 0) {
+    return version_lower_equal(device, 8, 0);
+  } else if (nvrtc_major == 11 && nvrtc_minor < 8) {
+    return version_lower_equal(device, 8, 6);
+  } else {
+    return true;
+  }
+}
+
+#define INCLUDE_PREFIX "mlx/backend/cuda/device/"
+
+constexpr const char* g_include_names[] = {
+    INCLUDE_PREFIX "atomic_ops.cuh",
+    INCLUDE_PREFIX "binary_ops.cuh",
+    INCLUDE_PREFIX "cast_op.cuh",
+    INCLUDE_PREFIX "config.h",
+    INCLUDE_PREFIX "complex.cuh",
+    INCLUDE_PREFIX "fp16_math.cuh",
+    INCLUDE_PREFIX "indexing.cuh",
+    INCLUDE_PREFIX "scatter_ops.cuh",
+    INCLUDE_PREFIX "unary_ops.cuh",
+    INCLUDE_PREFIX "ternary_ops.cuh",
+    INCLUDE_PREFIX "utils.cuh",
+};
+
+#undef INCLUDE_PREFIX
+
+constexpr const char* g_headers[] = {
+    jit_source_atomic_ops,
+    jit_source_binary_ops,
+    jit_source_cast_op,
+    jit_source_config,
+    jit_source_complex,
+    jit_source_fp16_math,
+    jit_source_indexing,
+    jit_source_scatter_ops,
+    jit_source_unary_ops,
+    jit_source_ternary_ops,
+    jit_source_utils,
+};
+
+void compile(
+    Device& device,
+    const std::string& module_name,
+    const std::string& source,
+    const std::vector<std::string>& kernel_names,
+    std::string& ptx,
+    std::vector<std::pair<std::string, std::string>>& ptx_kernels) {
+  // Create the program
+  nvrtcProgram prog;
+  CHECK_NVRTC_ERROR(nvrtcCreateProgram(
+      &prog,
+      source.c_str(),
+      (module_name + ".cu").c_str(),
+      std::size(g_headers),
+      g_headers,
+      g_include_names));
+  std::unique_ptr<nvrtcProgram, void (*)(nvrtcProgram*)> prog_freer(
+      &prog,
+      [](nvrtcProgram* p) { CHECK_NVRTC_ERROR(nvrtcDestroyProgram(p)); });
+  for (const auto& name : kernel_names) {
+    CHECK_NVRTC_ERROR(nvrtcAddNameExpression(prog, name.c_str()));
+  }
+
+  // Compile program.
+  std::vector<const char*> args;
+  bool use_sass = compiler_supports_device_sass(device);
+  std::string compute = fmt::format(
+      "--gpu-architecture={}_{}{}",
+      use_sass ? "sm" : "compute",
+      device.compute_capability_major(),
+      device.compute_capability_minor());
+  args.push_back(compute.c_str());
+  std::string cccl_include = cccl_dir();
+  if (!cccl_include.empty()) {
+    cccl_include = fmt::format("--include-path={}", cccl_include);
+    args.push_back(cccl_include.c_str());
+  }
+  std::string cuda_include =
+      fmt::format("--include-path={}/include", cuda_home());
+  args.push_back(cuda_include.c_str());
+  nvrtcResult compile_result =
+      nvrtcCompileProgram(prog, args.size(), args.data());
+  if (compile_result != NVRTC_SUCCESS) {
+    size_t log_size;
+    CHECK_NVRTC_ERROR(nvrtcGetProgramLogSize(prog, &log_size));
+    std::vector<char> log(log_size + 1, 0);
+    CHECK_NVRTC_ERROR(nvrtcGetProgramLog(prog, log.data()));
+    throw std::runtime_error(
+        fmt::format("Failed to compile kernel: {}.", log.data()));
+  }
+
+  // Get mangled names of kernel names.
+  for (const auto& name : kernel_names) {
+    const char* mangled;
+    CHECK_NVRTC_ERROR(nvrtcGetLoweredName(prog, name.c_str(), &mangled));
+    ptx_kernels.emplace_back(name, mangled);
+  }
+
+  // Get ptx data.
+  size_t ptx_size;
+  if (use_sass) {
+    CHECK_NVRTC_ERROR(nvrtcGetCUBINSize(prog, &ptx_size));
+  } else {
+    CHECK_NVRTC_ERROR(nvrtcGetPTXSize(prog, &ptx_size));
+  }
+  ptx.resize(ptx_size);
+  if (use_sass) {
+    CHECK_NVRTC_ERROR(nvrtcGetCUBIN(prog, ptx.data()));
+  } else {
+    CHECK_NVRTC_ERROR(nvrtcGetPTX(prog, ptx.data()));
+  }
+}
+
+void load_module(
+    const std::string& module_name,
+    const std::string& ptx,
+    const std::vector<std::pair<std::string, std::string>>& ptx_kernels,
+    CUmodule& module_,
+    std::unordered_map<std::string, std::tuple<CUfunction, bool, uint>>&
+        kernels) {
+  // Load module.
+  char jit_log[4089] = {};
+  CUjit_option options[] = {
+      CU_JIT_ERROR_LOG_BUFFER, CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES};
+  void* values[] = {jit_log, reinterpret_cast<void*>(std::size(jit_log) - 1)};
+  CUresult jit_result = cuModuleLoadDataEx(
+      &module_, ptx.data(), std::size(options), options, values);
+  if (jit_result != CUDA_SUCCESS) {
+    throw std::runtime_error(fmt::format(
+        "Failed to load compiled {} kernel: {}.", module_name, jit_log));
+  }
+
+  // Load kernels.
+  for (const auto& [name, mangled] : ptx_kernels) {
+    CUfunction kernel;
+    CHECK_CUDA_ERROR(cuModuleGetFunction(&kernel, module_, mangled.c_str()));
+    kernels[name] = std::make_tuple(kernel, false, 0);
+  }
+}
+
+} // namespace
+
+JitModule::JitModule(
+    Device& device,
+    const std::string& module_name,
+    const KernelBuilder& builder,
+    bool use_disk_cache) {
+  // Will hold the actual device executable source code and kernel names
+  std::string ptx;
+  std::vector<std::pair<std::string, std::string>> ptx_kernels;
+
+  // Try to load them from the file cache
+  if (!read_cached_ptx(ptx_cache_dir(), module_name, ptx, ptx_kernels)) {
+    auto [precompiled, source_code, kernel_names] = builder();
+
+    // Get the PTX or cubin
+    if (precompiled) {
+      ptx = std::move(source_code);
+      for (auto& name : kernel_names) {
+        ptx_kernels.emplace_back(name, name);
+      }
+    } else {
+      compile(device, module_name, source_code, kernel_names, ptx, ptx_kernels);
+    }
+
+    // If requested save them in the file cache for the next launch
+    if (use_disk_cache) {
+      write_cached_ptx(
+          ptx_cache_dir(), module_name, ptx, ptx_kernels, source_code);
+    }
+  }
+
+  // Load the module
+  load_module(module_name, ptx, ptx_kernels, module_, kernels_);
+}
+
+JitModule::~JitModule() {
+  CHECK_CUDA_ERROR(cuModuleUnload(module_));
+}
+
+std::pair<CUfunction, uint> JitModule::get_kernel_and_dims(
+    const std::string& kernel_name,
+    std::function<void(CUfunction)> configure_kernel) {
+  auto it = kernels_.find(kernel_name);
+  if (it == kernels_.end()) {
+    throw std::runtime_error(
+        fmt::format("There is no kernel named {}.", kernel_name));
+  }
+
+  // If it is the first time we run this kernel then configure it. Do it only
+  // once!
+  auto kernel = std::get<0>(it->second);
+  if (!std::get<1>(it->second)) {
+    if (configure_kernel) {
+      configure_kernel(kernel);
+    }
+    std::get<1>(it->second) = true;
+    std::get<2>(it->second) = max_occupancy_block_dim(kernel);
+  }
+
+  return {kernel, std::get<2>(it->second)};
+}
+
+CUfunction JitModule::get_kernel(
+    const std::string& kernel_name,
+    std::function<void(CUfunction)> configure_kernel) {
+  return get_kernel_and_dims(kernel_name, std::move(configure_kernel)).first;
+}
+
+std::unordered_map<std::string, JitModule>& get_jit_module_cache() {
+  static std::unordered_map<std::string, JitModule> map;
+  return map;
+}
+
+JitModule& get_jit_module(
+    const mlx::core::Device& device,
+    const std::string& name,
+    const KernelBuilder& builder,
+    bool cache) {
+  auto& map = get_jit_module_cache();
+  auto it = map.find(name);
+  if (it == map.end()) {
+    it = map.try_emplace(name, cu::device(device), name, builder, cache).first;
+  }
+  return it->second;
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/jit_module.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/jit_module.h
new file mode 100644
index 0000000000000000000000000000000000000000..e2fd0c8b8faf4e6d9a66610e6e0bdb75d7bcb9bd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/jit_module.h
@@ -0,0 +1,119 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/device/config.h"
+
+#include <deque>
+#include <unordered_map>
+#include <utility>
+#include <variant>
+
+#include <cuda.h>
+#include <fmt/format.h>
+
+namespace mlx::core::cu {
+
+class Device;
+
+using KernelBuilderResult = std::tuple<
+    /* precompiled */ bool,
+    /* source code */ std::string,
+    /* kernel names */ std::vector<std::string>>;
+using KernelBuilder = std::function<KernelBuilderResult()>;
+
+struct KernelArgs {
+  void** args() {
+    return args_.data();
+  }
+
+  void append(const array& a) {
+    append(reinterpret_cast<CUdeviceptr>(a.data<void>()));
+  }
+
+  template <typename T>
+  void append(T val) {
+    storage_.emplace_back(val);
+    append_ptr(&storage_.back());
+  }
+
+  template <typename T>
+  void append(SmallVector<T> vec) {
+    storage_.emplace_back(std::move(vec));
+    append_ptr(std::get<SmallVector<T>>(storage_.back()).data());
+  }
+
+  template <typename T>
+  void append(const std::vector<T>& vec) {
+    append(SmallVector<T>(vec.begin(), vec.end()));
+  }
+
+  // Make sure the arg is copied to an array with size of NDIM.
+  template <size_t NDIM = MAX_NDIM, typename T>
+  void append_ndim(SmallVector<T> vec) {
+    if (vec.size() > NDIM) {
+      throw std::runtime_error(
+          fmt::format("ndim can not be larger than {}.", NDIM));
+    }
+    vec.resize(NDIM);
+    append(std::move(vec));
+  }
+
+  void append_ptr(const void* v) {
+    args_.push_back(const_cast<void*>(v));
+  }
+
+ private:
+  std::vector<void*> args_;
+
+  // The cuGraphAddKernelNode API requires passing pointers to arguments so
+  // store temporary values until the node is created.
+  using Arg = std::variant<
+      std::monostate,
+      CUdeviceptr,
+      bool,
+      int32_t,
+      uint32_t,
+      int64_t,
+      float,
+      SmallVector<const void*>,
+      SmallVector<int32_t>,
+      SmallVector<int64_t>>;
+  std::deque<Arg> storage_;
+};
+
+class JitModule {
+ public:
+  JitModule(
+      Device& device,
+      const std::string& module_name,
+      const KernelBuilder& builder,
+      bool cache);
+  ~JitModule();
+
+  JitModule(const JitModule&) = delete;
+  JitModule& operator=(const JitModule&) = delete;
+  CUfunction get_kernel(
+      const std::string& kernel_name,
+      std::function<void(CUfunction)> configure_kernel = nullptr);
+  std::pair<CUfunction, uint> get_kernel_and_dims(
+      const std::string& kernel_name,
+      std::function<void(CUfunction)> configure_kernel = nullptr);
+
+ private:
+  CUmodule module_{nullptr};
+  std::unordered_map<std::string, std::tuple<CUfunction, bool, uint>> kernels_;
+};
+
+std::unordered_map<std::string, JitModule>& get_jit_module_cache();
+
+JitModule& get_jit_module(
+    const mlx::core::Device& device,
+    const std::string& name,
+    const KernelBuilder& builder,
+    bool use_disk_cache = true);
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/kernel_utils.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/kernel_utils.cu
new file mode 100644
index 0000000000000000000000000000000000000000..4304318a66ae5dbfb08d8239b2281d074dee93e3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/kernel_utils.cu
@@ -0,0 +1,52 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+
+namespace mlx::core {
+
+dim3 get_block_dims(int dim0, int dim1, int dim2, int pow2) {
+  Dims dims = get_block_dims_common(dim0, dim1, dim2, pow2);
+  return dim3(std::get<0>(dims), std::get<1>(dims), std::get<2>(dims));
+}
+
+dim3 get_2d_grid_dims(const Shape& shape, const Strides& strides) {
+  Dims dims = get_2d_grid_dims_common(shape, strides);
+  return dim3(std::get<0>(dims), std::get<1>(dims), std::get<2>(dims));
+}
+
+dim3 get_2d_grid_dims(
+    const Shape& shape,
+    const Strides& strides,
+    size_t divisor) {
+  Dims dims = get_2d_grid_dims_common(shape, strides, divisor);
+  return dim3(std::get<0>(dims), std::get<1>(dims), std::get<2>(dims));
+}
+
+std::pair<dim3, dim3> get_grid_and_block(int dim0, int dim1, int dim2) {
+  auto [grid, block] = get_grid_and_block_common(dim0, dim1, dim2);
+  auto [gx, gy, gz] = grid;
+  auto [bx, by, bz] = block;
+  return std::make_pair(dim3(gx, gy, gz), dim3(bx, by, bz));
+}
+
+std::tuple<dim3, uint> get_launch_args(
+    size_t size,
+    const Shape& shape,
+    const Strides& strides,
+    bool large,
+    int work_per_thread /* = 1 */,
+    uint max_block_dim /* = 1024 */) {
+  size_t nthreads = cuda::ceil_div(size, work_per_thread);
+  uint block_dim = max_block_dim < nthreads ? max_block_dim : nthreads;
+  dim3 num_blocks;
+  if (large) {
+    num_blocks = get_2d_grid_dims(shape, strides, work_per_thread);
+    num_blocks.x = cuda::ceil_div(num_blocks.x, block_dim);
+  } else {
+    num_blocks.x = cuda::ceil_div(nthreads, block_dim);
+  }
+  return std::make_tuple(num_blocks, block_dim);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/kernel_utils.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/kernel_utils.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..9fca2911628ab58ddc92b921f7145d96743a34c9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/kernel_utils.cuh
@@ -0,0 +1,147 @@
+// Copyright © 2025 Apple Inc.
+
+// This file includes host-only utilies for writing CUDA kernels, the difference
+// from backend/cuda/device/utils.cuh is that the latter file only include
+// device-only code.
+
+#pragma once
+
+#include <type_traits>
+
+#include "mlx/array.h"
+#include "mlx/backend/cuda/device/utils.cuh"
+
+#include <cuda.h>
+#include <cuda_bf16.h>
+#include <cuda_fp16.h>
+#include <fmt/format.h>
+#include <cuda/cmath>
+
+namespace mlx::core {
+
+template <typename F>
+void dispatch_1_2_3(int n, F&& f) {
+  switch (n) {
+    case 1:
+      f(std::integral_constant<int, 1>{});
+      break;
+    case 2:
+      f(std::integral_constant<int, 2>{});
+      break;
+    case 3:
+      f(std::integral_constant<int, 3>{});
+      break;
+  }
+}
+
+template <typename F>
+void dispatch_bool(bool v, F&& f) {
+  if (v) {
+    f(std::true_type{});
+  } else {
+    f(std::false_type{});
+  }
+}
+
+template <typename F>
+void dispatch_block_dim(int threads, F&& f) {
+  if (threads <= WARP_SIZE) {
+    f(std::integral_constant<int, WARP_SIZE>{});
+  } else if (threads <= WARP_SIZE * 2) {
+    f(std::integral_constant<int, WARP_SIZE * 2>{});
+  } else if (threads <= WARP_SIZE * 4) {
+    f(std::integral_constant<int, WARP_SIZE * 4>{});
+  } else if (threads <= WARP_SIZE * 8) {
+    f(std::integral_constant<int, WARP_SIZE * 8>{});
+  } else if (threads <= WARP_SIZE * 16) {
+    f(std::integral_constant<int, WARP_SIZE * 16>{});
+  } else {
+    f(std::integral_constant<int, WARP_SIZE * 32>{});
+  }
+}
+
+// Maps CPU types to CUDA types.
+template <typename T>
+struct CTypeToCudaType {
+  using type = T;
+};
+
+template <>
+struct CTypeToCudaType<float16_t> {
+  using type = __half;
+};
+
+template <>
+struct CTypeToCudaType<bfloat16_t> {
+  using type = __nv_bfloat16;
+};
+
+template <>
+struct CTypeToCudaType<complex64_t> {
+  using type = cu::complex64_t;
+};
+
+template <typename T>
+using cuda_type_t = typename CTypeToCudaType<T>::type;
+
+// Type traits for detecting floating numbers.
+template <typename T>
+inline constexpr bool is_floating_v =
+    cuda::std::is_same_v<T, float> || cuda::std::is_same_v<T, double> ||
+    cuda::std::is_same_v<T, float16_t> || cuda::std::is_same_v<T, bfloat16_t>;
+
+// Type traits for detecting complex numbers.
+template <typename T>
+inline constexpr bool is_complex_v = cuda::std::is_same_v<T, complex64_t> ||
+    cuda::std::is_same_v<T, complex128_t>;
+
+// Type traits for detecting complex or real floating point numbers.
+template <typename T>
+inline constexpr bool is_inexact_v = is_floating_v<T> || is_complex_v<T>;
+
+// Utility to copy data from vector to array in host.
+template <int NDIM = MAX_NDIM, typename T = int32_t>
+inline cuda::std::array<T, NDIM> const_param(const SmallVector<T>& vec) {
+  if (vec.size() > NDIM) {
+    throw std::runtime_error(
+        fmt::format("ndim can not be larger than {}.", NDIM));
+  }
+  cuda::std::array<T, NDIM> result;
+  std::copy_n(vec.begin(), vec.size(), result.begin());
+  return result;
+}
+
+// Compute the grid and block dimensions, check backend/common/utils.h for docs.
+dim3 get_block_dims(int dim0, int dim1, int dim2, int pow2 = 10);
+dim3 get_2d_grid_dims(const Shape& shape, const Strides& strides);
+dim3 get_2d_grid_dims(
+    const Shape& shape,
+    const Strides& strides,
+    size_t divisor);
+std::pair<dim3, dim3> get_grid_and_block(int dim0, int dim1, int dim2);
+
+// Get the num_blocks and block_dims assuming each thread handles
+// |work_per_thread| elements of |arr|.
+std::tuple<dim3, uint> get_launch_args(
+    size_t size,
+    const Shape& shape,
+    const Strides& strides,
+    bool large,
+    int work_per_thread = 1,
+    uint max_block_dim = 1024);
+
+inline std::tuple<dim3, uint> get_launch_args(
+    const array& arr,
+    bool large,
+    int work_per_thread = 1,
+    uint max_block_dim = 1024) {
+  return get_launch_args(
+      arr.size(),
+      arr.shape(),
+      arr.strides(),
+      large,
+      work_per_thread,
+      max_block_dim);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/layer_norm.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/layer_norm.cu
new file mode 100644
index 0000000000000000000000000000000000000000..369b2547e2cd0a69989d429fa419bb7883098edf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/layer_norm.cu
@@ -0,0 +1,417 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/backend/cuda/reduce/reduce.cuh"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/dtype_utils.h"
+#include "mlx/fast_primitives.h"
+
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+inline __device__ float3 plus_f3(const float3& a, const float3& b) {
+  return {a.x + b.x, a.y + b.y, a.z + b.z};
+}
+
+// Similar to cub::BlockReduce, but result is broadcasted to every thread.
+template <typename T, int BLOCK_DIM>
+struct BlockBroadcastReduce {
+  static_assert(WARP_SIZE <= BLOCK_DIM && BLOCK_DIM <= WARP_SIZE * WARP_SIZE);
+  static_assert(BLOCK_DIM % WARP_SIZE == 0);
+  using TempStorage = T[BLOCK_DIM / WARP_SIZE];
+
+  cg::thread_block& block;
+  TempStorage& temp;
+
+  template <typename Op>
+  __device__ T Reduce(const T& input, const Op& op, const T& init_value) {
+    auto warp = cg::tiled_partition<WARP_SIZE>(block);
+    T x = cg::reduce(warp, input, op);
+    if (warp.thread_rank() == 0) {
+      temp[warp.meta_group_rank()] = x;
+    }
+    block.sync();
+    x = warp.thread_rank() < warp.meta_group_size() ? temp[warp.thread_rank()]
+                                                    : init_value;
+    return cg::reduce(warp, x, op);
+  }
+
+  __device__ T Sum(const T& input) {
+    return Reduce(input, cg::plus<T>{}, T{});
+  }
+};
+
+template <typename T, int BLOCK_DIM, int N_READS = 4>
+__global__ void layer_norm(
+    const T* x,
+    const T* w,
+    const T* b,
+    T* out,
+    float eps,
+    int32_t axis_size,
+    int64_t w_stride,
+    int64_t b_stride) {
+  auto grid = cg::this_grid();
+  auto block = cg::this_thread_block();
+
+  using BlockReduceT = BlockBroadcastReduce<float, BLOCK_DIM>;
+  __shared__ typename BlockReduceT::TempStorage temp;
+
+  x += grid.block_rank() * axis_size;
+  out += grid.block_rank() * axis_size;
+
+  // Sum.
+  float sum = 0;
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); ++r) {
+    auto index = r * BLOCK_DIM + block.thread_rank();
+    auto xn = load_vector<N_READS>(x, index, axis_size, T(0));
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      sum += static_cast<float>(xn[i]);
+    }
+  }
+  sum = BlockReduceT{block, temp}.Sum(sum);
+
+  // Mean.
+  float mean = sum / axis_size;
+
+  // Normalizer.
+  float normalizer = 0;
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); ++r) {
+    auto index = r * BLOCK_DIM + block.thread_rank();
+    if ((index + 1) * N_READS <= axis_size) {
+      auto xn = load_vector<N_READS>(x, index);
+#pragma unroll
+      for (int i = 0; i < N_READS; ++i) {
+        float t = static_cast<float>(xn[i]) - mean;
+        normalizer += t * t;
+      }
+    } else {
+      for (int i = index * N_READS; i < axis_size; ++i) {
+        float t = static_cast<float>(x[i]) - mean;
+        normalizer += t * t;
+      }
+    }
+  }
+  normalizer = BlockReduceT{block, temp}.Sum(normalizer);
+  normalizer = rsqrt(normalizer / axis_size + eps);
+
+  // Outputs.
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); ++r) {
+    auto index = r * BLOCK_DIM + block.thread_rank();
+    auto xn = load_vector<N_READS>(x, index, axis_size, T(0));
+    auto wn = load_vector<N_READS>(w, index, axis_size, w_stride, T(0));
+    auto bn = load_vector<N_READS>(b, index, axis_size, b_stride, T(0));
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      float norm = (static_cast<float>(xn[i]) - mean) * normalizer;
+      xn[i] = wn[i] * static_cast<T>(norm) + bn[i];
+    }
+    store_vector<N_READS>(out, index, xn, axis_size);
+  }
+}
+
+template <typename T, bool HAS_W, int BLOCK_DIM, int N_READS = 4>
+__global__ void layer_norm_vjp(
+    const T* x,
+    const T* w,
+    const T* g,
+    T* gx,
+    T* gw,
+    float eps,
+    int32_t axis_size,
+    int64_t w_stride) {
+  auto grid = cg::this_grid();
+  auto block = cg::this_thread_block();
+
+  using BlockReduceF = BlockBroadcastReduce<float, BLOCK_DIM>;
+  using BlockReduceF3 = BlockBroadcastReduce<float3, BLOCK_DIM>;
+  __shared__ union {
+    typename BlockReduceF::TempStorage f;
+    typename BlockReduceF3::TempStorage f3;
+  } temp;
+
+  x += grid.block_rank() * axis_size;
+  g += grid.block_rank() * axis_size;
+  gx += grid.block_rank() * axis_size;
+  gw += grid.block_rank() * axis_size;
+
+  // Sum.
+  float sum = 0;
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); ++r) {
+    auto index = r * BLOCK_DIM + block.thread_rank();
+    auto xn = load_vector<N_READS>(x, index, axis_size, T(0));
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      sum += static_cast<float>(xn[i]);
+    }
+  }
+  sum = BlockReduceF{block, temp.f}.Sum(sum);
+
+  // Mean.
+  float mean = sum / axis_size;
+
+  // Normalizer.
+  float3 factors = {};
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); ++r) {
+    auto index = r * BLOCK_DIM + block.thread_rank();
+    auto gn = load_vector<N_READS>(g, index, axis_size, T(0));
+    auto wn = load_vector<N_READS>(w, index, axis_size, w_stride, T(0));
+
+    if ((index + 1) * N_READS <= axis_size) {
+      auto xn = load_vector<N_READS>(x, index);
+#pragma unroll
+      for (int i = 0; i < N_READS; ++i) {
+        float t = static_cast<float>(xn[i]) - mean;
+        float wi = wn[i];
+        float gi = gn[i];
+        float wg = wi * gi;
+        factors = plus_f3(factors, {wg, wg * t, t * t});
+      }
+    } else {
+      for (int i = index * N_READS; i < axis_size; ++i) {
+        float t = static_cast<float>(x[i]) - mean;
+        float wi = wn[i];
+        float gi = gn[i];
+        float wg = wi * gi;
+        factors = plus_f3(factors, {wg, wg * t, t * t});
+      }
+    }
+  }
+  factors = BlockReduceF3{block, temp.f3}.Reduce(factors, plus_f3, {});
+  float meanwg = factors.x / axis_size;
+  float meanwgxc = factors.y / axis_size;
+  float normalizer2 = 1 / (factors.z / axis_size + eps);
+  float normalizer = sqrt(normalizer2);
+
+  // Outputs.
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); ++r) {
+    auto index = r * BLOCK_DIM + block.thread_rank();
+    auto xn = load_vector<N_READS>(x, index, axis_size, T(0));
+    auto gn = load_vector<N_READS>(g, index, axis_size, T(0));
+    auto wn = load_vector<N_READS>(w, index, axis_size, w_stride, T(0));
+
+    for (int i = 0; i < N_READS; i++) {
+      float xi = (static_cast<float>(xn[i]) - mean) * normalizer;
+      float wi = wn[i];
+      float gi = gn[i];
+      xn[i] = normalizer * (wi * gi - meanwg) - xi * meanwgxc * normalizer2;
+      if constexpr (HAS_W) {
+        wn[i] = gi * xi;
+      }
+    }
+    store_vector<N_READS>(gx, index, xn, axis_size);
+    if constexpr (HAS_W) {
+      store_vector<N_READS>(gw, index, wn, axis_size);
+    }
+  }
+}
+
+} // namespace cu
+
+namespace fast {
+
+bool LayerNorm::use_fallback(Stream s) {
+  return s.device == Device::cpu;
+}
+
+// TODO: There are duplicate code with backend/metal/normalization.cpp
+void LayerNorm::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  nvtx3::scoped_range r("LayerNorm::eval_gpu");
+  auto& s = stream();
+  auto& out = outputs[0];
+
+  // Make sure that the last dimension is contiguous.
+  auto set_output = [&s, &out](const array& x) {
+    bool no_copy = x.flags().contiguous && x.strides()[x.ndim() - 1] == 1;
+    if (no_copy && x.ndim() > 1) {
+      auto s = x.strides()[x.ndim() - 2];
+      no_copy &= (s == 0 || s == x.shape().back());
+    }
+    if (no_copy) {
+      if (x.is_donatable()) {
+        out.copy_shared_buffer(x);
+      } else {
+        out.set_data(
+            allocator::malloc(x.data_size() * x.itemsize()),
+            x.data_size(),
+            x.strides(),
+            x.flags());
+      }
+      return x;
+    } else {
+      array x_copy = contiguous_copy_gpu(x, s);
+      out.copy_shared_buffer(x_copy);
+      return x_copy;
+    }
+  };
+
+  const array x = set_output(inputs[0]);
+  const array& w = inputs[1];
+  const array& b = inputs[2];
+
+  int32_t axis_size = x.shape().back();
+  int32_t n_rows = x.data_size() / axis_size;
+  int64_t w_stride = (w.ndim() == 1) ? w.strides()[0] : 0;
+  int64_t b_stride = (b.ndim() == 1) ? b.strides()[0] : 0;
+
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(x);
+  encoder.set_input_array(w);
+  encoder.set_input_array(b);
+  encoder.set_output_array(out);
+  dispatch_float_types(out.dtype(), "layernorm", [&](auto type_tag) {
+    using DataType = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+    constexpr int N_READS = 16 / sizeof(DataType);
+    dispatch_block_dim(cuda::ceil_div(axis_size, N_READS), [&](auto block_dim) {
+      auto kernel = cu::layer_norm<DataType, block_dim(), N_READS>;
+      encoder.add_kernel_node(
+          kernel,
+          n_rows,
+          block_dim(),
+          0,
+          x.data<DataType>(),
+          w.data<DataType>(),
+          b.data<DataType>(),
+          out.data<DataType>(),
+          eps_,
+          axis_size,
+          w_stride,
+          b_stride);
+    });
+  });
+}
+
+void LayerNormVJP::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  nvtx3::scoped_range r("LayerNormVJP::eval_gpu");
+  auto& s = stream();
+  auto& encoder = cu::get_command_encoder(s);
+
+  // Ensure row contiguity. We could relax this step by checking that the array
+  // is contiguous (no broadcasts or holes) and that the input strides are the
+  // same as the cotangent strides but for now this is simpler.
+  auto check_input = [&s](const array& x, bool& copied) {
+    if (x.flags().row_contiguous) {
+      copied = false;
+      return x;
+    }
+    copied = true;
+    return contiguous_copy_gpu(x, s);
+  };
+  bool donate_x = inputs[0].is_donatable();
+  bool donate_g = inputs[3].is_donatable();
+  bool copied;
+  auto x = check_input(inputs[0], copied);
+  donate_x |= copied;
+  const array& w = inputs[1];
+  const array& b = inputs[2];
+  bool g_copied;
+  auto g = check_input(inputs[3], g_copied);
+  donate_g |= g_copied;
+  array& gx = outputs[0];
+  array& gw = outputs[1];
+  array& gb = outputs[2];
+
+  // Check whether we had a weight.
+  bool has_w = w.ndim() != 0;
+
+  // Allocate space for the outputs.
+  bool g_in_gx = false;
+  if (donate_x) {
+    gx.copy_shared_buffer(x);
+  } else if (donate_g) {
+    gx.copy_shared_buffer(g);
+    g_in_gx = true;
+  } else {
+    gx.set_data(allocator::malloc(gx.nbytes()));
+  }
+  if (g_copied && !g_in_gx) {
+    encoder.add_temporary(g);
+  }
+
+  int32_t axis_size = x.shape().back();
+  int32_t n_rows = x.data_size() / axis_size;
+  int64_t w_stride = (w.ndim() == 1) ? w.strides()[0] : 0;
+
+  // Allocate a temporary to store the gradients for w and allocate the output
+  // gradient accumulators.
+  array gw_temp =
+      (has_w) ? array({n_rows, x.shape().back()}, gw.dtype(), nullptr, {}) : w;
+  bool g_in_gw = false;
+  if (has_w) {
+    if (!g_in_gx && donate_g) {
+      g_in_gw = true;
+      gw_temp.copy_shared_buffer(g);
+    } else {
+      gw_temp.set_data(allocator::malloc(gw_temp.nbytes()));
+      encoder.add_temporary(gw_temp);
+    }
+  }
+
+  // The gradient for b in case we had a b.
+  bool has_gb = (gb.ndim() == 1 && gb.size() == axis_size);
+  if (has_gb) {
+    ReductionPlan plan(
+        ReductionOpType::ContiguousStridedReduce, {n_rows}, {axis_size});
+    col_reduce(encoder, g, gb, Reduce::ReduceType::Sum, {0}, plan);
+  }
+
+  // Insert dependency if `g` was donated
+  if ((g_in_gx || g_in_gw) && has_gb) {
+    encoder.set_input_array(gb);
+  }
+  encoder.set_input_array(x);
+  encoder.set_input_array(w);
+  encoder.set_input_array(g);
+  encoder.set_output_array(gx);
+  encoder.set_output_array(gw_temp);
+  dispatch_float_types(gx.dtype(), "layernorm_vjp", [&](auto type_tag) {
+    dispatch_bool(has_w, [&](auto has_w_constant) {
+      using DataType = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+      constexpr int N_READS = 16 / sizeof(DataType);
+      dispatch_block_dim(
+          cuda::ceil_div(axis_size, N_READS), [&](auto block_dim) {
+            auto kernel = cu::layer_norm_vjp<
+                DataType,
+                has_w_constant.value,
+                block_dim(),
+                N_READS>;
+            encoder.add_kernel_node(
+                kernel,
+                n_rows,
+                block_dim(),
+                0,
+                x.data<DataType>(),
+                w.data<DataType>(),
+                g.data<DataType>(),
+                gx.data<DataType>(),
+                gw_temp.data<DataType>(),
+                eps_,
+                axis_size,
+                w_stride);
+          });
+    });
+  });
+
+  if (has_w) {
+    ReductionPlan plan(
+        ReductionOpType::ContiguousStridedReduce, {n_rows}, {axis_size});
+    col_reduce(encoder, gw_temp, gw, Reduce::ReduceType::Sum, {0}, plan);
+  }
+}
+
+} // namespace fast
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/logsumexp.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/logsumexp.cu
new file mode 100644
index 0000000000000000000000000000000000000000..b90c300d03c3681874eb5eb6fbe4bab2e55d1d73
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/logsumexp.cu
@@ -0,0 +1,161 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/device/cast_op.cuh"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+#include <nvtx3/nvtx3.hpp>
+#include <cub/block/block_load.cuh>
+
+#include <cassert>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename T>
+inline __device__ T softmax_exp(T x) {
+  // Softmax doesn't need high precision exponential cause x is gonna be in
+  // (-oo, 0] anyway and subsequently it will be divided by sum(exp(x_i)).
+  return __expf(x);
+}
+
+template <typename T, typename AccT, int BLOCK_DIM, int N_READS = 4>
+__global__ void logsumexp(const T* in, T* out, int axis_size) {
+  auto grid = cg::this_grid();
+  auto block = cg::this_thread_block();
+  auto warp = cg::tiled_partition<WARP_SIZE>(block);
+
+  in += grid.block_rank() * axis_size;
+
+  cg::greater<AccT> max_op;
+  cg::plus<AccT> plus_op;
+
+  // Thread reduce.
+  AccT prevmax;
+  AccT maxval = Limits<AccT>::finite_min();
+  AccT normalizer = 0;
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); r++) {
+    auto index = r * BLOCK_DIM + block.thread_rank();
+    auto vals = load_vector<N_READS>(in, index, axis_size, Limits<T>::min());
+    prevmax = maxval;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      maxval = max_op(maxval, static_cast<AccT>(vals[i]));
+    }
+    // Online normalizer calculation for softmax:
+    // https://github.com/NVIDIA/online-softmax
+    normalizer = normalizer * softmax_exp(prevmax - maxval);
+    for (int i = 0; i < N_READS; i++) {
+      normalizer =
+          normalizer + softmax_exp(static_cast<AccT>(vals[i]) - maxval);
+    }
+  }
+
+  // First warp reduce.
+  prevmax = maxval;
+  maxval = cg::reduce(warp, maxval, max_op);
+  normalizer = normalizer * softmax_exp(prevmax - maxval);
+  normalizer = cg::reduce(warp, normalizer, plus_op);
+
+  __shared__ AccT local_max[WARP_SIZE];
+  __shared__ AccT local_normalizer[WARP_SIZE];
+
+  // Write to shared memory and do second warp reduce.
+  prevmax = maxval;
+  if (warp.thread_rank() == 0) {
+    local_max[warp.meta_group_rank()] = maxval;
+  }
+  block.sync();
+  maxval = warp.thread_rank() < warp.meta_group_size()
+      ? local_max[warp.thread_rank()]
+      : Limits<AccT>::finite_min();
+  maxval = cg::reduce(warp, maxval, max_op);
+  normalizer = normalizer * softmax_exp(prevmax - maxval);
+  if (warp.thread_rank() == 0) {
+    local_normalizer[warp.meta_group_rank()] = normalizer;
+  }
+  block.sync();
+  normalizer = warp.thread_rank() < warp.meta_group_size()
+      ? local_normalizer[warp.thread_rank()]
+      : AccT{};
+  normalizer = cg::reduce(warp, normalizer, plus_op);
+
+  // Write output.
+  if (block.thread_rank() == 0) {
+    out[grid.block_rank()] = isinf(maxval) ? maxval : log(normalizer) + maxval;
+  }
+}
+
+} // namespace cu
+
+void LogSumExp::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("LogSumExp::eval_gpu");
+  assert(inputs.size() == 1);
+  auto& s = stream();
+  auto& encoder = cu::get_command_encoder(s);
+
+  // Make sure that the last dimension is contiguous.
+  auto ensure_contiguous = [&s, &encoder](const array& x) {
+    if (x.flags().contiguous && x.strides()[x.ndim() - 1] == 1) {
+      return x;
+    } else {
+      array x_copy = contiguous_copy_gpu(x, s);
+      encoder.add_temporary(x_copy);
+      return x_copy;
+    }
+  };
+
+  auto in = ensure_contiguous(inputs[0]);
+  if (in.flags().row_contiguous) {
+    out.set_data(allocator::malloc(out.nbytes()));
+  } else {
+    auto n = in.shape(-1);
+    auto flags = in.flags();
+    auto strides = in.strides();
+    for (auto& s : strides) {
+      s /= n;
+    }
+    bool col_contig = strides[0] == 1;
+    for (int i = 1; col_contig && i < strides.size(); ++i) {
+      col_contig &=
+          (out.shape(i) == 1 || strides[i - 1] == out.shape(i) * strides[i]);
+    }
+    flags.col_contiguous = col_contig;
+    out.set_data(
+        allocator::malloc(in.nbytes() / n),
+        in.data_size() / n,
+        std::move(strides),
+        flags);
+  }
+
+  int axis_size = in.shape().back();
+  int n_rows = in.data_size() / axis_size;
+
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  dispatch_float_types(out.dtype(), "logsumexp", [&](auto type_tag) {
+    using DataType = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+    constexpr int N_READS = 16 / sizeof(DataType);
+    dispatch_block_dim(cuda::ceil_div(axis_size, N_READS), [&](auto block_dim) {
+      auto kernel = cu::logsumexp<DataType, float, block_dim(), N_READS>;
+      encoder.add_kernel_node(
+          kernel,
+          n_rows,
+          block_dim(),
+          0,
+          in.data<DataType>(),
+          out.data<DataType>(),
+          axis_size);
+    });
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/lru_cache.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/lru_cache.h
new file mode 100644
index 0000000000000000000000000000000000000000..dc8325fcd4b4ad215a7c189ab7f2b7993c3c92dd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/lru_cache.h
@@ -0,0 +1,182 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/utils.h"
+
+#include <cstring>
+#include <list>
+#include <unordered_map>
+#include <utility>
+
+#include <fmt/format.h>
+
+namespace mlx::core {
+
+template <
+    typename K,
+    typename V,
+    template <typename...> typename M = std::unordered_map>
+class LRUCache {
+ public:
+  using value_type = std::pair<K, V>;
+  using list_type = std::list<value_type>;
+  using iterator = typename list_type::iterator;
+  using const_iterator = typename list_type::const_iterator;
+  using map_type = M<K, iterator>;
+
+  explicit LRUCache(size_t capacity) : capacity_(capacity) {
+    if (capacity == 0) {
+      throw std::runtime_error("LRUCache requires capacity > 0.");
+    }
+  }
+
+  // Initialize with capacity read from |env_name|.
+  LRUCache(const char* env_name, int default_capacity)
+      : LRUCache(env::get_var(env_name, default_capacity)) {
+    if (env::get_var("MLX_ENABLE_CACHE_THRASHING_CHECK", 1)) {
+      env_name_ = env_name;
+    }
+  }
+
+  size_t size() const {
+    return map_.size();
+  }
+  size_t capacity() const {
+    return capacity_;
+  }
+  bool empty() const {
+    return vlist_.empty();
+  }
+
+  void resize(size_t new_capacity) {
+    capacity_ = new_capacity;
+    trim();
+  }
+
+  iterator begin() {
+    return vlist_.begin();
+  }
+  const_iterator begin() const {
+    return vlist_.begin();
+  }
+  iterator end() {
+    return vlist_.end();
+  }
+  const_iterator end() const {
+    return vlist_.end();
+  }
+
+  void clear() {
+    map_.clear();
+    vlist_.clear();
+  }
+
+  iterator find(const K& key) {
+    auto it = map_.find(key);
+    if (it == map_.end())
+      return end();
+    vlist_.splice(vlist_.begin(), vlist_, it->second);
+    return it->second;
+  }
+
+  template <typename U>
+  std::pair<iterator, bool> emplace(const K& key, U&& value) {
+    auto it = map_.find(key);
+    if (it != map_.end()) {
+      vlist_.splice(vlist_.begin(), vlist_, it->second);
+      return {it->second, false};
+    }
+
+    if (env_name_ && ++cache_misses_ > 2 * capacity_) {
+      throw std::runtime_error(fmt::format(
+          "Cache thrashing is happening, please set the environment variable "
+          "{} to a larger value than {} to fix degraded performance.",
+          env_name_,
+          capacity_));
+    }
+
+    vlist_.emplace_front(key, std::forward<U>(value));
+    map_[key] = vlist_.begin();
+
+    trim();
+
+    return {vlist_.begin(), true};
+  }
+
+  iterator erase(iterator pos) {
+    map_.erase(pos->first);
+    return vlist_.erase(pos);
+  }
+
+  V& operator[](const K& key) {
+    auto it = find(key);
+    if (it == end()) {
+      it = emplace(key, V{}).first;
+    }
+    return it->second;
+  }
+
+ private:
+  void trim() {
+    while (map_.size() > capacity_) {
+      auto last = std::prev(vlist_.end());
+      map_.erase(last->first);
+      vlist_.pop_back();
+    }
+  }
+
+  const char* env_name_{nullptr};
+  size_t cache_misses_{0};
+
+  list_type vlist_;
+  map_type map_;
+  size_t capacity_;
+};
+
+// Turn a POD struct into a container key by doing bytes compare.
+template <typename T>
+struct BytesKey {
+  T pod;
+  static_assert(std::is_standard_layout_v<T>, "T is not POD");
+
+  BytesKey(T pod) : pod(std::move(pod)) {}
+
+  BytesKey(const BytesKey& other) {
+    memcpy(&pod, &other.pod, sizeof(T));
+  }
+
+  BytesKey(BytesKey&& other) {
+    memcpy(&pod, &other.pod, sizeof(T));
+  }
+
+  bool operator==(const BytesKey& other) const {
+    auto* ptr1 = reinterpret_cast<const uint8_t*>(&pod);
+    auto* ptr2 = reinterpret_cast<const uint8_t*>(&other.pod);
+    return memcmp(ptr1, ptr2, sizeof(T)) == 0;
+  }
+};
+
+// Compute hash according to the bytes value of T.
+template <typename T>
+struct BytesHash {
+  static_assert(std::is_standard_layout_v<T>, "T is not POD");
+
+  size_t operator()(const T& pod) const {
+    auto* ptr = reinterpret_cast<const uint8_t*>(&pod);
+    uint32_t value = 0x811C9DC5;
+    for (int i = 0; i < sizeof(T); ++i) {
+      value ^= ptr[i];
+      value *= 0x01000193;
+    }
+    return value;
+  }
+};
+
+template <typename K, typename V>
+using BytesKeyHashMap = std::unordered_map<K, V, BytesHash<K>>;
+
+template <typename K, typename V>
+using LRUBytesKeyCache = LRUCache<BytesKey<K>, V, BytesKeyHashMap>;
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/matmul.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/matmul.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8a79b172b9c1f84b88bc16f7794d6babc7ec7b9c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/matmul.cpp
@@ -0,0 +1,257 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/matmul.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/gemms/cublas_gemm.h"
+#include "mlx/backend/cuda/gemms/gemv.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/primitives.h"
+
+#include <nvtx3/nvtx3.hpp>
+#include <numeric>
+
+namespace mlx::core {
+
+namespace {
+
+std::tuple<bool, int64_t, array>
+check_transpose(cu::CommandEncoder& enc, const Stream& s, const array& arr) {
+  auto stx = arr.strides()[arr.ndim() - 2];
+  auto sty = arr.strides()[arr.ndim() - 1];
+  if (sty == 1 && stx == arr.shape(-1)) {
+    return std::make_tuple(false, stx, arr);
+  } else if (stx == 1 && sty == arr.shape(-2)) {
+    return std::make_tuple(true, sty, arr);
+  } else {
+    array arr_copy = contiguous_copy_gpu(arr, s);
+    enc.add_temporary(arr_copy);
+    return std::make_tuple(false, arr.shape(-1), arr_copy);
+  }
+}
+
+void gemm_and_bias(
+    cu::CommandEncoder& encoder,
+    int M,
+    int N,
+    int K,
+    bool a_transposed,
+    int64_t lda,
+    bool b_transposed,
+    int64_t ldb,
+    array& out,
+    const array& a,
+    const array& b,
+    const std::optional<array>& bias = std::nullopt,
+    float alpha = 1.0f) {
+  // Check and collapse batch dimensions
+  auto [batch_shape, a_batch_strides, b_batch_strides] = collapse_batches(a, b);
+
+  auto batch_count = out.size() / (M * N);
+
+  // Collapse batches into M if needed
+  if (batch_count > 1 && !a_transposed && batch_shape.size() == 1 &&
+      a.strides()[a.ndim() - 2] == K && a_batch_strides.back() == M * K &&
+      b_batch_strides.back() == 0) {
+    M *= batch_shape.back();
+    batch_count = 1;
+
+    a_batch_strides = {0};
+    b_batch_strides = {0};
+    batch_shape = {1};
+  }
+
+  // Use gemmv when possible
+  if (!bias && cu::can_use_gemv(M, N, K, a_transposed, b_transposed)) {
+    cu::gemv(
+        a,
+        b,
+        out,
+        M,
+        N,
+        K,
+        batch_count,
+        batch_shape,
+        a_batch_strides,
+        b_batch_strides,
+        encoder);
+    return;
+  }
+
+  // Invoke cublasLt
+  CublasGemm gemm(
+      encoder.device(),
+      a.dtype(),
+      a_transposed,
+      M,
+      K,
+      lda,
+      b_transposed,
+      K,
+      N,
+      ldb,
+      batch_shape.back(),
+      a_batch_strides.back(),
+      b_batch_strides.back());
+  if (bias) {
+    if (a.dtype() == complex64) {
+      throw std::runtime_error(
+          "[gemm_and_bias] complex64 bias epilogue isn’t supported in cublasLtMatmul.");
+    }
+    gemm.set_bias(encoder, *bias);
+  }
+  gemm.run(
+      encoder, out, a, b, batch_shape, a_batch_strides, b_batch_strides, alpha);
+}
+
+} // namespace
+
+void Matmul::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Matmul::eval_gpu");
+  auto& s = stream();
+  auto& encoder = cu::get_command_encoder(s);
+
+  assert(inputs.size() == 2);
+  auto& a_pre = inputs[0];
+  auto& b_pre = inputs[1];
+  // Return 0s if either input is empty.
+  if (a_pre.size() == 0 || b_pre.size() == 0) {
+    array zero(0, a_pre.dtype());
+    encoder.add_temporary(zero);
+    fill_gpu(zero, out, s);
+    return;
+  }
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  int M = a_pre.shape(-2);
+  int N = b_pre.shape(-1);
+  int K = a_pre.shape(-1);
+
+  // Keep a vector with copies to be cleared in the completed buffer to release
+  // the arrays
+  auto [a_transposed, lda, a] = check_transpose(encoder, s, a_pre);
+  auto [b_transposed, ldb, b] = check_transpose(encoder, s, b_pre);
+
+  gemm_and_bias(
+      encoder, M, N, K, a_transposed, lda, b_transposed, ldb, out, a, b);
+}
+
+void AddMM::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("AddMM::eval_gpu");
+  auto& s = stream();
+  auto& encoder = cu::get_command_encoder(s);
+
+  assert(inputs.size() == 3);
+  auto& a_pre = inputs[0];
+  auto& b_pre = inputs[1];
+  auto c = inputs[2];
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Init checks and prep
+
+  int M = a_pre.shape(-2);
+  int N = b_pre.shape(-1);
+  int K = a_pre.shape(-1);
+
+  // Keep a vector with copies to be cleared in the completed buffer to release
+  // the arrays
+  auto [a_transposed, lda, a] = check_transpose(encoder, s, a_pre);
+  auto [b_transposed, ldb, b] = check_transpose(encoder, s, b_pre);
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Dispatch to GEMM with epilogue or AddMM
+
+  if (beta_ == 1 && a.dtype() != complex64 && c.strides(-1) == 1 &&
+      c.data_size() == out.shape(-1)) {
+    out.set_data(allocator::malloc(out.nbytes()));
+    gemm_and_bias(
+        encoder,
+        M,
+        N,
+        K,
+        a_transposed,
+        lda,
+        b_transposed,
+        ldb,
+        out,
+        a,
+        b,
+        c,
+        alpha_);
+    return;
+  }
+
+  int64_t ldc;
+  {
+    auto stx = c.strides()[c.ndim() - 2];
+    auto sty = c.strides()[c.ndim() - 1];
+    if (sty == 1 && stx == c.shape(-1)) {
+      ldc = stx;
+      out.set_data(allocator::malloc(out.nbytes()));
+    } else if (sty == 1 && stx == 0) {
+      ldc = 0;
+      out.set_data(allocator::malloc(out.nbytes()));
+    } else {
+      // Copy C into out and set C to out
+      ldc = c.shape(-1);
+      copy_gpu(c, out, CopyType::General, s);
+      c = out;
+    }
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Check and collapse batch dimensions
+
+  auto [batch_shape, a_batch_strides, b_batch_strides, c_batch_strides] =
+      collapse_batches(a, b, c);
+
+  auto batch_count = out.size() / (M * N);
+
+  // Collapse batches into M if needed
+  if (batch_count > 1 && !a_transposed && batch_shape.size() == 1 &&
+      a.strides()[a.ndim() - 2] == K && a_batch_strides.back() == M * K &&
+      c_batch_strides.back() == M * c.strides()[c.ndim() - 2] &&
+      b_batch_strides.back() == 0) {
+    M *= batch_shape.back();
+    batch_count = 1;
+
+    a_batch_strides = {0};
+    b_batch_strides = {0};
+    c_batch_strides = {0};
+    batch_shape = {1};
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Invoke cublasLt with AddMM settings
+
+  CublasGemm gemm(
+      cu::device(s.device),
+      a.dtype(),
+      a_transposed,
+      M,
+      K,
+      lda,
+      b_transposed,
+      K,
+      N,
+      ldb,
+      ldc,
+      batch_shape.back(),
+      a_batch_strides.back(),
+      b_batch_strides.back(),
+      c_batch_strides.back());
+  gemm.run(
+      encoder,
+      out,
+      a,
+      b,
+      c,
+      batch_shape,
+      a_batch_strides,
+      b_batch_strides,
+      c_batch_strides,
+      alpha_,
+      beta_);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..175a505b4b27b86ace8780f4bd7ea1faa6a8d4cc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/no_cuda.cpp
@@ -0,0 +1,47 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/cuda.h"
+#include "mlx/fast.h"
+
+namespace mlx::core {
+
+namespace cu {
+
+bool is_available() {
+  return false;
+}
+
+} // namespace cu
+
+namespace fast {
+
+CustomKernelFunction cuda_kernel(
+    const std::string&,
+    const std::vector<std::string>&,
+    const std::vector<std::string>&,
+    const std::string&,
+    const std::string&,
+    bool,
+    int) {
+  throw std::runtime_error("[cuda_kernel] No CUDA back-end.");
+}
+
+std::vector<array> precompiled_cuda_kernel(
+    const std::string&,
+    const std::string&,
+    const std::vector<array>&,
+    const std::vector<Shape>&,
+    const std::vector<Dtype>&,
+    const std::vector<ScalarArg>&,
+    std::tuple<int, int, int>,
+    std::tuple<int, int, int>,
+    int shared_memory,
+    std::optional<float> init_value,
+    bool ensure_row_contiguous,
+    StreamOrDevice) {
+  throw std::runtime_error("[cuda_kernel] No CUDA back-end.");
+}
+
+} // namespace fast
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/primitives.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/primitives.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..77c295665596cddee1f5c94f7c671be43787da23
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/primitives.cpp
@@ -0,0 +1,48 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/distributed/primitives.h"
+#include "mlx/fast_primitives.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+#define NO_GPU_MULTI(func)                                             \
+  void func::eval_gpu(                                                 \
+      const std::vector<array>& inputs, std::vector<array>& outputs) { \
+    throw std::runtime_error(#func " has no CUDA implementation.");    \
+  }
+
+#define NO_GPU_USE_FALLBACK(func)     \
+  bool func::use_fallback(Stream s) { \
+    return true;                      \
+  }                                   \
+  NO_GPU_MULTI(func)
+
+#define NO_GPU(func)                                                  \
+  void func::eval_gpu(const std::vector<array>& inputs, array& out) { \
+    throw std::runtime_error(#func " has no CUDA implementation.");   \
+  }
+
+NO_GPU(BlockMaskedMM)
+NO_GPU(FFT)
+NO_GPU(GatherMM)
+NO_GPU(GatherQMM)
+NO_GPU(Hadamard)
+NO_GPU(Load)
+NO_GPU_MULTI(LUF)
+NO_GPU_MULTI(QRF)
+NO_GPU(QuantizedMatmul)
+NO_GPU(SegmentedMM)
+NO_GPU_MULTI(SVD)
+NO_GPU(Inverse)
+NO_GPU(Cholesky)
+NO_GPU_MULTI(Eig)
+NO_GPU_MULTI(Eigh)
+
+namespace distributed {
+NO_GPU_MULTI(AllGather)
+NO_GPU_MULTI(Send)
+NO_GPU_MULTI(Recv)
+} // namespace distributed
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/quantized/affine_quantize.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/quantized/affine_quantize.cu
new file mode 100644
index 0000000000000000000000000000000000000000..94e67d135c9941d5465b48d2885226bfc04ca028
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/quantized/affine_quantize.cu
@@ -0,0 +1,331 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/backend/cuda/quantized/quantized_utils.cuh"
+#include "mlx/dtype_utils.h"
+
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+
+namespace mlx::core {
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename T, int group_size, int bits>
+__global__ void
+affine_quantize(const T* w, uint8_t* out, T* scales, T* biases, size_t size) {
+  auto block_size = cg::this_thread_block().dim_threads();
+  auto block_idx = cg::this_thread_block().group_index();
+  auto idx_in_block = cg::this_thread_block().thread_index();
+
+  auto tidx = block_idx.x * block_size.x + idx_in_block.x;
+  auto tidy = block_idx.y * block_size.y + idx_in_block.y;
+
+  auto grid_dim_x =
+      cg::this_grid().dim_blocks().x * cg::this_grid().block_index().x;
+  constexpr float eps = 1e-7;
+  constexpr int simd_size = WARP_SIZE;
+  constexpr float n_bins = (1 << bits) - 1;
+  constexpr int pack_factor = get_pack_factor<bits, 8>();
+  constexpr int bytes_per_pack = get_bytes_per_pack<bits>();
+  constexpr int values_per_reduce = group_size / simd_size;
+  constexpr int writes_per_reduce = pack_factor / values_per_reduce;
+  constexpr int writes_per_pack =
+      writes_per_reduce > 1 ? 1 : values_per_reduce / pack_factor;
+  constexpr int power_of_2_bits = (bits & (bits - 1)) == 0;
+
+  size_t offset = tidx + grid_dim_x * size_t(tidy);
+  size_t in_index = offset * values_per_reduce;
+  if (in_index >= size) {
+    return;
+  }
+  size_t out_index = power_of_2_bits
+      ? offset * writes_per_pack
+      : offset * bytes_per_pack / writes_per_reduce;
+
+  float w_thread[values_per_reduce];
+  float w_min = Limits<float>::max();
+  float w_max = 0;
+
+#pragma clang loop unroll(full)
+  for (int i = 0; i < values_per_reduce; i++) {
+    float val = w[in_index + i];
+    w_thread[i] = val;
+    w_min = min(w_min, val);
+    w_max = max(w_max, val);
+  }
+
+  cg::greater<float> max_op;
+  cg::less<float> min_op;
+  auto warp = cg::tiled_partition<WARP_SIZE>(cg::this_thread_block());
+
+  w_min = cg::reduce(warp, w_min, min_op);
+  w_max = cg::reduce(warp, w_max, max_op);
+
+  float scale = max((w_max - w_min) / n_bins, eps);
+  bool side = abs(w_min) > abs(w_max);
+  scale = side ? scale : -scale;
+  float edge = side ? w_min : w_max;
+  float q0 = round(edge / scale);
+  bool at_zero = q0 == 0.0f;
+  scale = at_zero ? scale : edge / q0;
+  float bias = at_zero ? 0 : edge;
+
+  // Write out the scales and biases
+  size_t gindex = in_index / group_size;
+  if (in_index % group_size == 0) {
+    scales[gindex] = static_cast<T>(scale);
+    biases[gindex] = static_cast<T>(bias);
+  }
+
+  using OutType = std::conditional_t<bits == 5, uint64_t, uint32_t>;
+  OutType output = 0;
+
+#pragma clang loop unroll(full)
+  for (int i = 0; i < values_per_reduce; i++) {
+    uint8_t val = min(round((w_thread[i] - bias) / scale), n_bins);
+    if (bits == 8) {
+      output = val;
+    } else {
+      output |= val << (bits * (i % pack_factor));
+    }
+
+    if (pack_factor < values_per_reduce && i % pack_factor == pack_factor - 1) {
+      out[out_index + i / pack_factor] = output;
+      output = 0;
+    } else {
+#pragma clang loop unroll(full)
+      for (int j = 1; j < writes_per_reduce; j++) {
+        uint8_t sval = warp.shfl_down(val, j);
+        output |= static_cast<OutType>(sval)
+            << (bits * (j * values_per_reduce + i));
+      }
+    }
+  }
+  if constexpr (bits == 3 || bits == 6) {
+    if (in_index % pack_factor == 0 && out_index % bytes_per_pack == 0) {
+      out[out_index] = output & 0xff;
+      out[out_index + 1] = (output & 0xff00) >> 8;
+      out[out_index + 2] = (output & 0xff0000) >> 16;
+    }
+  } else if constexpr (bits == 5) {
+    if (in_index % pack_factor == 0 && out_index % bytes_per_pack == 0) {
+      out[out_index] = output & 0xff;
+      out[out_index + 1] = (output & 0xff00) >> 8;
+      out[out_index + 2] = (output & 0xff0000) >> 16;
+      out[out_index + 3] = (output & 0xff000000) >> 24;
+      out[out_index + 4] = (output & 0xff00000000) >> 32;
+    }
+  } else {
+    if constexpr (writes_per_reduce > 0) {
+      if (out_index % writes_per_reduce == 0) {
+        out[out_index / writes_per_reduce] = output;
+      }
+    }
+  }
+}
+
+template <typename T, int group_size, int bits>
+__global__ void affine_dequantize(
+    const uint8_t* w,
+    const T* scales,
+    const T* biases,
+    T* out,
+    size_t size) {
+  auto block_size = cg::this_thread_block().dim_threads();
+  auto block_idx = cg::this_thread_block().group_index();
+  auto idx_in_block = cg::this_thread_block().thread_index();
+
+  auto tidx = block_idx.x * block_size.x + idx_in_block.x;
+  auto tidy = block_idx.y * block_size.y + idx_in_block.y;
+
+  auto grid_dim_x =
+      cg::this_grid().dim_blocks().x * cg::this_grid().block_index().x;
+
+  constexpr int pack_factor = get_pack_factor<bits, 8>();
+  constexpr int bytes_per_pack = get_bytes_per_pack<bits>();
+
+  size_t offset = tidx + grid_dim_x * size_t(tidy);
+  size_t oindex = offset * pack_factor;
+
+  if (oindex >= size) {
+    return;
+  }
+
+  size_t gindex = oindex / group_size;
+  T scale = scales[gindex];
+  T bias = biases[gindex];
+  out += oindex;
+
+  if constexpr (bits == 3) {
+    w += offset * bytes_per_pack;
+    out[0] = static_cast<T>(w[0] & 0x7) * scale + bias;
+    out[1] = static_cast<T>((w[0] & 0x38) >> 3) * scale + bias;
+    out[2] = (static_cast<T>((w[0] & 0xc0) >> 6) +
+              static_cast<T>((w[1] & 0x1) << 2)) *
+            scale +
+        bias;
+    out[3] = static_cast<T>((w[1] & 0xe) >> 1) * scale + bias;
+    out[4] = static_cast<T>((w[1] & 0x70) >> 4) * scale + bias;
+    out[5] = (static_cast<T>((w[1] & 0x80) >> 7) +
+              static_cast<T>((w[2] & 0x3) << 1)) *
+            scale +
+        bias;
+    out[6] = static_cast<T>((w[2] & 0x1c) >> 2) * scale + bias;
+    out[7] = static_cast<T>((w[2] & 0xe0) >> 5) * scale + bias;
+  } else if constexpr (bits == 5) {
+    w += offset * bytes_per_pack;
+    out[0] = static_cast<T>(w[0] & 0x1f) * scale + bias;
+    out[1] = (static_cast<T>((w[0] & 0xe0) >> 5) +
+              static_cast<T>((w[1] & 0x3) << 3)) *
+            scale +
+        bias;
+    out[2] = static_cast<T>((w[1] & 0x7c) >> 2) * scale + bias;
+    out[3] = (static_cast<T>((w[1] & 0x80) >> 7) +
+              static_cast<T>((w[2] & 0xf) << 1)) *
+            scale +
+        bias;
+    out[4] = (static_cast<T>((w[2] & 0xf0) >> 4) +
+              static_cast<T>((w[3] & 0x1) << 4)) *
+            scale +
+        bias;
+    out[5] = static_cast<T>((w[3] & 0x3e) >> 1) * scale + bias;
+    out[6] = (static_cast<T>((w[3] & 0xc0) >> 6) +
+              static_cast<T>((w[4] & 0x7) << 2)) *
+            scale +
+        bias;
+    out[7] = static_cast<T>((w[4] & 0xf8) >> 3) * scale + bias;
+  } else if constexpr (bits == 6) {
+    w += offset * bytes_per_pack;
+    out[0] = static_cast<T>(w[0] & 0x3f) * scale + bias;
+    out[1] = (static_cast<T>((w[0] >> 6) & 0x03) +
+              static_cast<T>((w[1] & 0x0f) << 2)) *
+            scale +
+        bias;
+    out[2] = (static_cast<T>((w[1] >> 4) & 0x0f) +
+              static_cast<T>((w[2] & 0x03) << 4)) *
+            scale +
+        bias;
+    out[3] = static_cast<T>((w[2] >> 2) & 0x3f) * scale + bias;
+  } else {
+    uint val = w[offset];
+#pragma clang loop unroll(full)
+    for (int i = 0; i < pack_factor; i++) {
+      uint8_t d;
+      if (bits == 2) {
+        d = (val >> (bits * i)) & 0x03;
+      } else if (bits == 4) {
+        d = (val >> (bits * i)) & 0x0f;
+      } else if (bits == 8) {
+        d = val;
+      }
+      out[i] = scale * static_cast<T>(d) + bias;
+    }
+  }
+}
+
+} // namespace cu
+
+void affine_quantize(
+    const array& w,
+    array& wq,
+    array& scales,
+    array& biases,
+    int group_size_,
+    int bits_,
+    cu::CommandEncoder& enc,
+    const Stream& s) {
+  // Calculate the number of elements per thread
+  int per_thread = group_size_ / WARP_SIZE;
+  size_t size = w.size() / per_thread;
+
+  // Calculate the thread grid that we need to launch
+  bool large = size > UINT_MAX;
+  auto grid_shape = w.shape();
+  grid_shape.back() /= per_thread;
+
+  enc.set_input_array(w);
+  enc.set_output_array(wq);
+  enc.set_output_array(scales);
+  enc.set_output_array(biases);
+  dispatch_float_types(w.dtype(), "affine_quantize", [&](auto type_tag) {
+    dispatch_groups(group_size_, [&](auto group_size) {
+      dispatch_bits(bits_, [&](auto bits) {
+        using T = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+        auto kernel = cu::affine_quantize<T, group_size.value, bits.value>;
+        auto [num_blocks, block_dims] =
+            get_launch_args(size, grid_shape, w.strides(), large);
+        enc.add_kernel_node(
+            kernel,
+            num_blocks,
+            block_dims,
+            0,
+            w.data<T>(),
+            wq.data<uint8_t>(),
+            scales.data<T>(),
+            biases.data<T>(),
+            w.size());
+      });
+    });
+  });
+}
+
+void affine_dequantize(
+    const array& wq,
+    const array& scales,
+    const array& biases,
+    array& w,
+    int group_size_,
+    int bits_,
+    cu::CommandEncoder& enc,
+    const Stream& s) {
+  // Calculate how many numbers we pack together. For 2, 4, 8 bits we pack in
+  // one uint8, for 3, 6 in 3 uint8 and for 5 in 5 uint8.
+  constexpr int uint8_per_uint32 = 4;
+  int packs_per_int;
+  switch (bits_) {
+    case 3:
+    case 5:
+      packs_per_int = 8;
+      break;
+    case 6:
+      packs_per_int = 4;
+      break;
+    default:
+      packs_per_int = 8 / bits_;
+  }
+
+  size_t size = w.size() / packs_per_int;
+  bool large = size > UINT_MAX;
+  auto grid_shape = w.shape();
+  grid_shape.back() *= uint8_per_uint32;
+
+  enc.set_input_array(wq);
+  enc.set_input_array(scales);
+  enc.set_input_array(biases);
+  enc.set_output_array(w);
+  dispatch_float_types(w.dtype(), "affine_quantize", [&](auto type_tag) {
+    dispatch_groups(group_size_, [&](auto group_size) {
+      dispatch_bits(bits_, [&](auto bits) {
+        using T = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+        auto kernel = cu::affine_dequantize<T, group_size.value, bits.value>;
+        auto [num_blocks, block_dims] =
+            get_launch_args(size, grid_shape, w.strides(), large);
+        enc.add_kernel_node(
+            kernel,
+            num_blocks,
+            block_dims,
+            0,
+            wq.data<uint8_t>(),
+            scales.data<T>(),
+            biases.data<T>(),
+            w.data<T>(),
+            w.size());
+      });
+    });
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/quantized/quantized.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/quantized/quantized.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..71c687d854a6e0542d79982af55d47d807a8fcd8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/quantized/quantized.cpp
@@ -0,0 +1,80 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/quantized/quantized.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/fast_primitives.h"
+
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core {
+
+namespace {
+
+inline array ensure_row_contiguous(
+    const array& x,
+    cu::CommandEncoder& enc,
+    const Stream& s) {
+  if (!x.flags().row_contiguous) {
+    array x_copy = contiguous_copy_gpu(x, s);
+    enc.add_temporary(x_copy);
+    return x_copy;
+  } else {
+    return x;
+  }
+}
+
+inline array ensure_row_contiguous_matrix(
+    const array& x,
+    cu::CommandEncoder& enc,
+    const Stream& s) {
+  if (x.ndim() < 2) {
+    if (x.strides()[0] == 1) {
+      return x;
+    }
+  } else {
+    auto stride_0 = x.strides()[x.ndim() - 2];
+    auto stride_1 = x.strides()[x.ndim() - 1];
+    if (stride_0 == x.shape(-1) && stride_1 == 1) {
+      return x;
+    }
+  }
+  array x_copy = contiguous_copy_gpu(x, s);
+  enc.add_temporary(x_copy);
+  return x_copy;
+}
+
+} // namespace
+
+void fast::Quantize::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  nvtx3::scoped_range r("Quantize::eval_gpu");
+  auto& s = stream();
+  auto& d = cu::device(s.device);
+  auto& enc = d.get_command_encoder(s);
+
+  if (dequantize_) {
+    auto wq = ensure_row_contiguous(inputs[0], enc, s);
+    auto scales = ensure_row_contiguous(inputs[1], enc, s);
+    auto biases = ensure_row_contiguous(inputs[2], enc, s);
+    auto& w = outputs[0];
+
+    w.set_data(allocator::malloc(w.nbytes()));
+
+    affine_dequantize(wq, scales, biases, w, group_size_, bits_, enc, s);
+  } else {
+    auto w = ensure_row_contiguous(inputs[0], enc, s);
+    auto& wq = outputs[0];
+    auto& scales = outputs[1];
+    auto& biases = outputs[2];
+
+    wq.set_data(allocator::malloc(wq.nbytes()));
+    scales.set_data(allocator::malloc(scales.nbytes()));
+    biases.set_data(allocator::malloc(biases.nbytes()));
+
+    affine_quantize(w, wq, scales, biases, group_size_, bits_, enc, s);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/quantized/quantized.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/quantized/quantized.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec6a08000b80af6d42e9148d00c59eb97a19d53c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/quantized/quantized.h
@@ -0,0 +1,27 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+
+namespace mlx::core {
+
+void affine_quantize(
+    const array& w,
+    array& wq,
+    array& scales,
+    array& biases,
+    int group_size_,
+    int bits_,
+    cu::CommandEncoder& enc,
+    const Stream& s);
+
+void affine_dequantize(
+    const array& wq,
+    const array& scales,
+    const array& biases,
+    array& w,
+    int group_size_,
+    int bits_,
+    cu::CommandEncoder& enc,
+    const Stream& s);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/quantized/quantized_utils.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/quantized/quantized_utils.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..c6a85527cc188e5a9b1f978445f4afc45e76802a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/quantized/quantized_utils.cuh
@@ -0,0 +1,59 @@
+// Copyright © 2025 Apple Inc.
+
+namespace mlx::core {
+
+namespace cu {
+
+template <int bits, int wsize = 8>
+inline constexpr __device__ short get_pack_factor() {
+  return (bits == 3 || bits == 5) ? 8 : (bits == 6 ? 4 : wsize / bits);
+}
+
+template <int bits, int wsize = 8>
+inline constexpr __device__ short get_bytes_per_pack() {
+  constexpr int power_of_2_bits = (bits & (bits - 1)) == 0;
+  return power_of_2_bits ? (wsize / 8) : (bits == 5 ? 5 : 3);
+}
+
+} // namespace cu
+
+template <typename F>
+void dispatch_groups(int group_size, F&& f) {
+  switch (group_size) {
+    case 32:
+      f(std::integral_constant<int, 32>{});
+      break;
+    case 64:
+      f(std::integral_constant<int, 64>{});
+      break;
+    case 128:
+      f(std::integral_constant<int, 128>{});
+      break;
+  }
+}
+
+template <typename F>
+void dispatch_bits(int bits, F&& f) {
+  switch (bits) {
+    case 2:
+      f(std::integral_constant<int, 2>{});
+      break;
+    case 3:
+      f(std::integral_constant<int, 3>{});
+      break;
+    case 4:
+      f(std::integral_constant<int, 4>{});
+      break;
+    case 5:
+      f(std::integral_constant<int, 5>{});
+      break;
+    case 6:
+      f(std::integral_constant<int, 6>{});
+      break;
+    case 8:
+      f(std::integral_constant<int, 8>{});
+      break;
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/random.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/random.cu
new file mode 100644
index 0000000000000000000000000000000000000000..26a3eb8b71b0e6e6182d8a4dc5dea43b90e8bc21
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/random.cu
@@ -0,0 +1,196 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/primitives.h"
+
+#include <cooperative_groups.h>
+#include <nvtx3/nvtx3.hpp>
+
+#include <cassert>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+__constant__ constexpr uint32_t rotations[2][4] = {
+    {13, 15, 26, 6},
+    {17, 29, 16, 24}};
+
+union rbits {
+  uint2 val;
+  uint8_t bytes[2][4];
+};
+
+__device__ rbits threefry2x32_hash(uint2 key, uint2 count) {
+  uint32_t ks[] = {key.x, key.y, key.x ^ key.y ^ 0x1BD11BDA};
+
+  rbits v;
+  v.val.x = count.x + ks[0];
+  v.val.y = count.y + ks[1];
+
+  for (int i = 0; i < 5; ++i) {
+    for (auto r : rotations[i % 2]) {
+      v.val.x += v.val.y;
+      v.val.y = (v.val.y << r) | (v.val.y >> (32 - r));
+      v.val.y ^= v.val.x;
+    }
+    v.val.x += ks[(i + 1) % 3];
+    v.val.y += ks[(i + 2) % 3] + i + 1;
+  }
+
+  return v;
+}
+
+__global__ void rbitsc(
+    const uint32_t* keys,
+    uint8_t* out,
+    dim3 grid_dims,
+    bool odd,
+    uint32_t bytes_per_key) {
+  auto grid = cg::this_grid();
+  uint thread_index = grid.thread_rank();
+  uint index_x = thread_index % grid_dims.x;
+  uint index_y = thread_index / grid_dims.x;
+  if (index_x >= grid_dims.x || index_y >= grid_dims.y) {
+    return;
+  }
+
+  auto kidx = 2 * index_x;
+  auto key = uint2{keys[kidx], keys[kidx + 1]};
+  auto half_size = grid_dims.y - odd;
+  out += index_x * bytes_per_key;
+  bool drop_last = odd && (index_y == half_size);
+  auto bits = threefry2x32_hash(
+      key, uint2{index_y, drop_last ? 0 : index_y + grid_dims.y});
+  size_t idx = size_t(index_y) << 2;
+  for (int i = 0; i < 4; ++i) {
+    out[idx + i] = bits.bytes[0][i];
+  }
+  if (!drop_last) {
+    idx = (drop_last ? 0 : size_t(index_y) + grid_dims.y) << 2;
+    if ((index_y + 1) == half_size && (bytes_per_key % 4) > 0) {
+      int edge_bytes = (bytes_per_key % 4);
+      for (int i = 0; i < edge_bytes; ++i) {
+        out[idx + i] = bits.bytes[1][i];
+      }
+    } else {
+      for (int i = 0; i < 4; ++i) {
+        out[idx + i] = bits.bytes[1][i];
+      }
+    }
+  }
+}
+
+__global__ void rbits(
+    const uint32_t* keys,
+    uint8_t* out,
+    dim3 grid_dims,
+    bool odd,
+    uint32_t bytes_per_key,
+    int32_t ndim,
+    const __grid_constant__ Shape key_shape,
+    const __grid_constant__ Strides key_strides) {
+  auto grid = cg::this_grid();
+  uint thread_index = grid.thread_rank();
+  uint index_x = thread_index % grid_dims.x;
+  uint index_y = thread_index / grid_dims.x;
+  if (index_x >= grid_dims.x || index_y >= grid_dims.y) {
+    return;
+  }
+
+  auto kidx = 2 * index_x;
+  auto k1_elem = elem_to_loc(kidx, key_shape.data(), key_strides.data(), ndim);
+  auto k2_elem =
+      elem_to_loc(kidx + 1, key_shape.data(), key_strides.data(), ndim);
+  auto key = uint2{keys[k1_elem], keys[k2_elem]};
+  auto half_size = grid_dims.y - odd;
+  out += size_t(index_x) * bytes_per_key;
+  bool drop_last = odd && (index_y == half_size);
+  auto bits = threefry2x32_hash(
+      key, uint2{index_y, drop_last ? 0 : index_y + grid_dims.y});
+  size_t idx = size_t(index_y) << 2;
+  for (int i = 0; i < 4; ++i) {
+    out[idx + i] = bits.bytes[0][i];
+  }
+  if (!drop_last) {
+    idx = (drop_last ? 0 : size_t(index_y) + grid_dims.y) << 2;
+    if ((index_y + 1) == half_size && (bytes_per_key % 4) > 0) {
+      int edge_bytes = (bytes_per_key % 4);
+      for (int i = 0; i < edge_bytes; ++i) {
+        out[idx + i] = bits.bytes[1][i];
+      }
+    } else {
+      for (int i = 0; i < 4; ++i) {
+        out[idx + i] = bits.bytes[1][i];
+      }
+    }
+  }
+}
+
+} // namespace cu
+
+void RandomBits::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("RandomBits::eval_gpu");
+  assert(inputs.size() == 1);
+
+  // keys has shape (N1, ..., NK, 2)
+  // out has shape (N1, ..., NK, M1, M2, ...)
+  auto& keys = inputs[0];
+  uint32_t num_keys = keys.size() / 2;
+
+  uint32_t elems_per_key = out.size() / num_keys;
+  uint32_t bytes_per_key = out.itemsize() * elems_per_key;
+  out.set_data(allocator::malloc(out.nbytes()));
+  if (out.size() == 0) {
+    return;
+  }
+
+  uint32_t out_per_key = (bytes_per_key + 4 - 1) / 4;
+  uint32_t half_size = out_per_key / 2;
+  bool odd = out_per_key % 2;
+
+  auto& s = stream();
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(keys);
+  encoder.set_output_array(out);
+  dim3 grid_dims{num_keys, half_size + odd};
+  int64_t total = grid_dims.x * grid_dims.y;
+  int32_t threads_y = 1;
+  while ((total / threads_y) >= (1U << 31)) {
+    threads_y *= 2;
+  }
+  int32_t threads_x = cuda::ceil_div(total, threads_y);
+  auto [grid, block] = get_grid_and_block(threads_x, threads_y, 1);
+  auto& stream = encoder.stream();
+  if (keys.flags().row_contiguous) {
+    encoder.add_kernel_node(
+        cu::rbitsc,
+        grid,
+        block,
+        0,
+        keys.data<uint32_t>(),
+        out.data<uint8_t>(),
+        grid_dims,
+        odd,
+        bytes_per_key);
+  } else {
+    encoder.add_kernel_node(
+        cu::rbits,
+        grid,
+        block,
+        0,
+        keys.data<uint32_t>(),
+        out.data<uint8_t>(),
+        grid_dims,
+        odd,
+        bytes_per_key,
+        keys.ndim(),
+        const_param(keys.shape()),
+        const_param(keys.strides()));
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce.cu
new file mode 100644
index 0000000000000000000000000000000000000000..269efc034b96528720709fd6498d85e91c1f26c6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce.cu
@@ -0,0 +1,73 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/reduce/reduce.cuh"
+#include "mlx/backend/gpu/copy.h"
+
+#include <nvtx3/nvtx3.hpp>
+
+#include <cassert>
+
+namespace mlx::core {
+
+void Reduce::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Reduce::eval_gpu");
+  assert(inputs.size() == 1);
+  array in = inputs[0];
+
+  // Make sure no identity reductions trickle down here.
+  assert(!axes_.empty());
+  assert(out.size() != in.size());
+
+  auto& s = stream();
+  auto& encoder = cu::get_command_encoder(s);
+
+  if (in.size() == 0) {
+    init_reduce(encoder, in, out, reduce_type_);
+    return;
+  }
+
+  // Reduce.
+  ReductionPlan plan = get_reduction_plan(in, axes_);
+
+  // If it is a general reduce then copy the input to a contiguous array and
+  // recompute the plan.
+  //
+  // TODO: Instead of copying we can use elem-to-loc to deal with broadcasting
+  //       like we do in Metal. When it comes to broadcasted reduction axes
+  //       some can be ignored eg for min/max.
+  bool broadcasted = false;
+  for (int i = 0, j = 0; i < in.ndim() && !broadcasted; i++) {
+    if (j < axes_.size() && axes_[j] == i) {
+      j++;
+    } else {
+      broadcasted = in.strides(i) == 0;
+    }
+  }
+  if (plan.type == GeneralReduce || broadcasted || !in.flags().contiguous) {
+    array in_copy = contiguous_copy_gpu(in, s);
+    encoder.add_temporary(in_copy);
+    in = in_copy;
+    plan = get_reduction_plan(in, axes_);
+  }
+
+  if (plan.type == ContiguousAllReduce) {
+    all_reduce(encoder, in, out, reduce_type_);
+    return;
+  }
+
+  if (plan.type == ContiguousReduce || plan.type == GeneralContiguousReduce) {
+    row_reduce(encoder, in, out, reduce_type_, axes_, plan);
+    return;
+  }
+
+  if (plan.type == ContiguousStridedReduce ||
+      plan.type == GeneralStridedReduce) {
+    col_reduce(encoder, in, out, reduce_type_, axes_, plan);
+    return;
+  }
+
+  throw std::runtime_error("No plan reached in reduce.");
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/all_reduce.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/all_reduce.cu
new file mode 100644
index 0000000000000000000000000000000000000000..b815597bd470e3c872156d29b6b4c618aaf25989
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/all_reduce.cu
@@ -0,0 +1,159 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/reduce/reduce.cuh"
+
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+#include <cub/block/block_load.cuh>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename T, typename U, typename ReduceOp, int N = 4>
+__global__ void all_reduce(T* in, U* out, size_t block_step, size_t size) {
+  // TODO: Process multiple "rows" in each thread
+  constexpr int M = 1;
+
+  auto grid = cg::this_grid();
+  auto block = cg::this_thread_block();
+  auto warp = cg::tiled_partition<WARP_SIZE>(block);
+
+  const U init = cu::ReduceInit<ReduceOp, T>::value();
+  ReduceOp op;
+
+  T vals[N];
+  U accs[M];
+  accs[0] = init;
+
+  size_t start = grid.block_rank() * block_step;
+  size_t end = start + block_step;
+  size_t check = min(end, size);
+
+  size_t i = start;
+  for (; i + block.size() * N <= check; i += block.size() * N) {
+    cub::LoadDirectBlockedVectorized<T, N>(block.thread_rank(), in + i, vals);
+    for (int j = 0; j < N; j++) {
+      accs[0] = op(accs[0], cast_to<U>(vals[j]));
+    }
+  }
+
+  if (i < check) {
+    cub::LoadDirectBlocked(
+        block.thread_rank(), in + i, vals, check - i, cast_to<T>(init));
+    for (int i = 0; i < N; i++) {
+      accs[0] = op(accs[0], cast_to<U>(vals[i]));
+    }
+  }
+
+  __shared__ U shared_accumulators[32];
+  block_reduce(block, warp, accs, shared_accumulators, op, init);
+
+  if (block.thread_rank() == 0) {
+    out[grid.block_rank()] = accs[0];
+  }
+}
+
+} // namespace cu
+
+void all_reduce(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    array& out,
+    Reduce::ReduceType reduce_type) {
+  constexpr int N_READS = 8;
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto get_args = [](size_t size, int N) {
+    int threads = std::min(512UL, (size + N - 1) / N);
+    threads = ((threads + WARP_SIZE - 1) / WARP_SIZE) * WARP_SIZE;
+    int reductions_per_step = threads * N;
+    size_t steps_needed =
+        (size + reductions_per_step - 1) / reductions_per_step;
+
+    int blocks;
+    if (steps_needed < 32) {
+      blocks = 1;
+    } else if (steps_needed < 128) {
+      blocks = 32;
+    } else if (steps_needed < 512) {
+      blocks = 128;
+    } else if (steps_needed < 1024) {
+      blocks = 512;
+    } else {
+      blocks = 1024;
+    }
+
+    size_t steps_per_block = (steps_needed + blocks - 1) / blocks;
+    size_t block_step = steps_per_block * reductions_per_step;
+
+    return std::make_tuple(blocks, threads, block_step);
+  };
+
+  int blocks, threads;
+  size_t block_step;
+  size_t insize = in.size();
+  Dtype dt = in.dtype();
+
+  // Cub doesn't like const pointers for load (sigh).
+  void* indata = const_cast<void*>(in.data<void>());
+
+  // Large array so allocate an intermediate and accumulate there
+  std::tie(blocks, threads, block_step) = get_args(insize, N_READS);
+  encoder.set_input_array(in);
+  if (blocks > 1) {
+    array intermediate({blocks}, out.dtype(), nullptr, {});
+    intermediate.set_data(allocator::malloc(intermediate.nbytes()));
+    encoder.add_temporary(intermediate);
+    encoder.set_output_array(intermediate);
+    dispatch_all_types(dt, [&](auto type_tag) {
+      dispatch_reduce_ops(reduce_type, [&](auto reduce_type_tag) {
+        using OP = MLX_GET_TYPE(reduce_type_tag);
+        using T = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+        using U = typename cu::ReduceResult<OP, T>::type;
+        auto kernel = cu::all_reduce<T, U, OP, N_READS>;
+        encoder.add_kernel_node(
+            kernel,
+            blocks,
+            threads,
+            0,
+            static_cast<T*>(indata),
+            intermediate.data<U>(),
+            block_step,
+            insize);
+      });
+    });
+
+    // Set the input for the next step and recalculate the blocks
+    indata = intermediate.data<void>();
+    dt = intermediate.dtype();
+    insize = intermediate.size();
+    std::tie(blocks, threads, block_step) = get_args(insize, N_READS);
+    encoder.set_input_array(intermediate);
+  }
+
+  encoder.set_output_array(out);
+  dispatch_all_types(dt, [&](auto type_tag) {
+    dispatch_reduce_ops(reduce_type, [&](auto reduce_type_tag) {
+      using OP = MLX_GET_TYPE(reduce_type_tag);
+      using T = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+      using U = typename cu::ReduceResult<OP, T>::type;
+      auto kernel = cu::all_reduce<T, U, OP, N_READS>;
+      encoder.add_kernel_node(
+          kernel,
+          blocks,
+          threads,
+          0,
+          static_cast<T*>(indata),
+          out.data<U>(),
+          block_step,
+          insize);
+    });
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/col_reduce.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/col_reduce.cu
new file mode 100644
index 0000000000000000000000000000000000000000..feafc2fb0c7bf817c6a793076b436bf50260baf8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/col_reduce.cu
@@ -0,0 +1,356 @@
+// Copyright © 2025 Apple Inc.
+
+#include <numeric>
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/reduce/reduce.cuh"
+
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+#include <cub/block/block_load.cuh>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+struct ColReduceArgs {
+  // The size of the contiguous column reduction.
+  size_t reduction_size;
+  int64_t reduction_stride;
+
+  // Input shape and strides excluding the reduction axes.
+  Shape shape;
+  Strides strides;
+  int ndim;
+
+  // Input shape and strides of the reduction axes (including last dimension).
+  Shape reduce_shape;
+  Strides reduce_strides;
+  int reduce_ndim;
+
+  // The number of column we are reducing. Namely prod(reduce_shape).
+  size_t non_col_reductions;
+
+  ColReduceArgs(
+      const array& in,
+      const ReductionPlan& plan,
+      const std::vector<int>& axes) {
+    using ShapeVector = decltype(plan.shape);
+    using StridesVector = decltype(plan.strides);
+
+    ShapeVector shape_vec;
+    StridesVector strides_vec;
+
+    assert(!plan.shape.empty());
+    reduction_size = plan.shape.back();
+    reduction_stride = plan.strides.back();
+
+    int64_t stride_back = 1;
+    std::tie(shape_vec, strides_vec) = shapes_without_reduction_axes(in, axes);
+    while (!shape_vec.empty() && stride_back < reduction_stride) {
+      stride_back *= shape_vec.back();
+      shape_vec.pop_back();
+      strides_vec.pop_back();
+    }
+    std::vector<int> indices(shape_vec.size());
+    std::iota(indices.begin(), indices.end(), 0);
+    std::sort(indices.begin(), indices.end(), [&](int left, int right) {
+      return strides_vec[left] > strides_vec[right];
+    });
+    ShapeVector sorted_shape;
+    StridesVector sorted_strides;
+    for (auto idx : indices) {
+      sorted_shape.push_back(shape_vec[idx]);
+      sorted_strides.push_back(strides_vec[idx]);
+    }
+    std::tie(shape_vec, strides_vec) =
+        collapse_contiguous_dims(sorted_shape, sorted_strides);
+    shape = const_param(shape_vec);
+    strides = const_param(strides_vec);
+    ndim = shape_vec.size();
+
+    reduce_shape = const_param(plan.shape);
+    reduce_strides = const_param(plan.strides);
+    reduce_ndim = plan.shape.size();
+
+    non_col_reductions = 1;
+    for (int i = 0; i < reduce_ndim - 1; i++) {
+      non_col_reductions *= reduce_shape[i];
+    }
+  }
+};
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    int NDIM,
+    int BM,
+    int BN,
+    int N_READS = 4>
+__global__ void
+col_reduce_looped(T* in, U* out, const __grid_constant__ ColReduceArgs args) {
+  auto grid = cg::this_grid();
+  auto block = cg::this_thread_block();
+  auto warp = cg::tiled_partition<WARP_SIZE>(block);
+
+  constexpr int threads_per_row = BN / N_READS;
+
+  // Compute the indices for the tile
+  size_t tile_idx = grid.block_rank();
+  size_t tile_x = tile_idx % ((args.reduction_stride + BN - 1) / BN);
+  size_t tile_y = tile_idx / ((args.reduction_stride + BN - 1) / BN);
+
+  // Compute the indices for the thread within the tile
+  short thread_x = block.thread_rank() % threads_per_row;
+  short thread_y = block.thread_rank() / threads_per_row;
+
+  // Move the input pointer
+  in += elem_to_loc(tile_y, args.shape.data(), args.strides.data(), args.ndim) +
+      tile_x * BN;
+
+  // Initialize the running totals
+  Op op;
+  U totals[N_READS];
+  for (int i = 0; i < N_READS; i++) {
+    totals[i] = ReduceInit<Op, T>::value();
+  }
+
+  LoopedElemToLoc<NDIM, (NDIM > 2)> loop(args.reduce_ndim);
+  loop.next(thread_y, args.reduce_shape.data(), args.reduce_strides.data());
+  size_t total = args.non_col_reductions * args.reduction_size;
+  if (tile_x * BN + BN <= args.reduction_stride) {
+    if (args.reduction_stride % N_READS == 0) {
+      for (size_t r = thread_y; r < total; r += BM) {
+        T vals[N_READS];
+        cub::LoadDirectBlockedVectorized(thread_x, in + loop.location(), vals);
+        for (int i = 0; i < N_READS; i++) {
+          totals[i] = op(totals[i], cast_to<U>(vals[i]));
+        }
+        loop.next(BM, args.reduce_shape.data(), args.reduce_strides.data());
+      }
+    } else {
+      for (size_t r = thread_y; r < total; r += BM) {
+        T vals[N_READS];
+        cub::LoadDirectBlocked(thread_x, in + loop.location(), vals);
+        for (int i = 0; i < N_READS; i++) {
+          totals[i] = op(totals[i], cast_to<U>(vals[i]));
+        }
+        loop.next(BM, args.reduce_shape.data(), args.reduce_strides.data());
+      }
+    }
+  } else {
+    for (size_t r = thread_y; r < total; r += BM) {
+      T vals[N_READS];
+      cub::LoadDirectBlocked(
+          thread_x,
+          in + loop.location(),
+          vals,
+          args.reduction_stride - tile_x * BN,
+          cast_to<T>(ReduceInit<Op, T>::value()));
+      for (int i = 0; i < N_READS; i++) {
+        totals[i] = op(totals[i], cast_to<U>(vals[i]));
+      }
+      loop.next(BM, args.reduce_shape.data(), args.reduce_strides.data());
+    }
+  }
+
+  // Do warp reduce for each output.
+  constexpr int n_outputs = BN / threads_per_row;
+  static_assert(BM == 32 && n_outputs == N_READS);
+  __shared__ U shared_vals[BM * BN];
+  short s_idx = thread_y * BN + thread_x * N_READS;
+  for (int i = 0; i < N_READS; i++) {
+    shared_vals[s_idx + i] = totals[i];
+  }
+  block.sync();
+  s_idx = warp.thread_rank() * BN + warp.meta_group_rank() * n_outputs;
+  for (int i = 0; i < n_outputs; i++) {
+    totals[i] = cg::reduce(warp, shared_vals[s_idx + i], op);
+  }
+
+  // Write result.
+  if (warp.thread_rank() == 0) {
+    cub::StoreDirectBlocked(
+        warp.meta_group_rank(),
+        out + tile_y * args.reduction_stride + tile_x * BN,
+        totals,
+        args.reduction_stride - tile_x * BN);
+  }
+}
+
+template <typename T, typename U, typename Op, int N_READS = 4>
+__global__ void col_reduce_small(
+    const T* in,
+    U* out,
+    const __grid_constant__ ColReduceArgs args,
+    size_t total) {
+  Op op;
+  auto grid = cg::this_grid();
+  auto block = cg::this_thread_block();
+
+  const auto idx = grid.thread_rank() * N_READS;
+  const auto before_axis = idx / args.reduction_stride;
+  const auto after_axis = idx % args.reduction_stride;
+  const auto offset =
+      before_axis * args.reduction_stride * args.reduction_size + after_axis;
+
+  if (idx >= total) {
+    return;
+  }
+
+  in += offset;
+  out += idx;
+
+  AlignedVector<U, N_READS> accumulator;
+  for (int i = 0; i < N_READS; i++) {
+    accumulator[i] = ReduceInit<Op, T>::value();
+  }
+
+  for (int i = 0; i < args.reduction_size; i++) {
+    auto values = load_vector<N_READS>(in, 0);
+
+    for (int j = 0; j < N_READS; j++) {
+      accumulator[j] = op(accumulator[j], cast_to<U>(values[j]));
+    }
+
+    in += args.reduction_stride;
+  }
+
+  store_vector(out, 0, accumulator);
+}
+
+} // namespace cu
+
+inline auto output_grid_for_col_reduce(
+    const array& out,
+    const cu::ColReduceArgs& args,
+    int bn) {
+  int gx, gy = 1;
+  size_t n_inner_blocks = cuda::ceil_div(args.reduction_stride, bn);
+  size_t n_outer_blocks = out.size() / args.reduction_stride;
+  size_t n_blocks = n_outer_blocks * n_inner_blocks;
+  while (n_blocks / gy > INT32_MAX) {
+    gy *= 2;
+  }
+  gx = cuda::ceil_div(n_blocks, gy);
+
+  return dim3(gx, gy, 1);
+}
+
+void col_reduce_looped(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    array& out,
+    Reduce::ReduceType reduce_type,
+    const std::vector<int>& axes,
+    const ReductionPlan& plan,
+    const cu::ColReduceArgs& args) {
+  // Allocate data for the output using in's layout to access them as
+  // contiguously as possible.
+  allocate_same_layout(out, in, axes);
+
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  dispatch_all_types(in.dtype(), [&](auto type_tag) {
+    dispatch_reduce_ops(reduce_type, [&](auto reduce_type_tag) {
+      dispatch_reduce_ndim(args.reduce_ndim, [&](auto reduce_ndim) {
+        using OP = MLX_GET_TYPE(reduce_type_tag);
+        using T = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+        using U = typename cu::ReduceResult<OP, T>::type;
+        // Cub doesn't like const pointers for vectorized loads. (sigh)
+        T* indata = const_cast<T*>(in.data<T>());
+
+        constexpr int N_READS = 4;
+        constexpr int BM = 32;
+        constexpr int BN = 32;
+        dim3 grid = output_grid_for_col_reduce(out, args, BN);
+        int blocks = BM * BN / N_READS;
+        auto kernel =
+            cu::col_reduce_looped<T, U, OP, reduce_ndim(), BM, BN, N_READS>;
+        encoder.add_kernel_node(
+            kernel,
+            grid,
+            blocks,
+            0,
+            indata,
+            out.data<U>(),
+            static_cast<cu::ColReduceArgs>(args));
+      });
+    });
+  });
+}
+
+void col_reduce_small(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    array& out,
+    Reduce::ReduceType reduce_type,
+    const std::vector<int>& axes,
+    const ReductionPlan& plan,
+    const cu::ColReduceArgs& args) {
+  // Allocate data for the output using in's layout to access them as
+  // contiguously as possible.
+  allocate_same_layout(out, in, axes);
+
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  dispatch_all_types(in.dtype(), [&](auto type_tag) {
+    dispatch_reduce_ops(reduce_type, [&](auto reduce_type_tag) {
+      using OP = MLX_GET_TYPE(reduce_type_tag);
+      using T = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+      using U = typename cu::ReduceResult<OP, T>::type;
+
+      constexpr int N_READS = 16 / sizeof(T);
+      auto tmp_grid = get_2d_grid_dims(out.shape(), out.strides());
+      auto [grid, block] = get_grid_and_block(tmp_grid.x, tmp_grid.y, 1);
+      auto kernel = cu::col_reduce_small<T, U, OP, N_READS>;
+      encoder.add_kernel_node(
+          kernel,
+          grid,
+          block,
+          0,
+          in.data<T>(),
+          out.data<U>(),
+          static_cast<cu::ColReduceArgs>(args),
+          out.size());
+    });
+  });
+}
+
+void col_reduce(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    array& out,
+    Reduce::ReduceType reduce_type,
+    const std::vector<int>& axes,
+    const ReductionPlan& plan) {
+  // Current col reduce options
+  //
+  // - col_reduce_looped
+  //
+  //   It is a general strided reduce. Each threadblock computes the output for
+  //   a subrow of the fast moving axis. For instance 32 elements.
+  //
+  // Notes: As in row reduce we opt to read as much in order as possible and
+  //        leave transpositions as they are (contrary to our Metal backend).
+  //
+  //        Moreover we need different kernels for short rows and tuning
+
+  // Make the args struct to help route to the best kernel
+  cu::ColReduceArgs args(in, plan, axes);
+
+  // Small col reduce with a single or contiguous reduction axis
+  if (args.non_col_reductions == 1 && args.reduction_size <= 32 &&
+      args.reduction_stride % (16 / in.itemsize()) == 0) {
+    col_reduce_small(encoder, in, out, reduce_type, axes, plan, args);
+    return;
+  }
+
+  // Fallback col reduce
+  col_reduce_looped(encoder, in, out, reduce_type, axes, plan, args);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/init_reduce.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/init_reduce.cu
new file mode 100644
index 0000000000000000000000000000000000000000..8c0d380f52ec637c96d7099cede9a21432d29524
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/init_reduce.cu
@@ -0,0 +1,50 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/reduce/reduce.cuh"
+
+#include <cooperative_groups.h>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename T, typename U, typename Op>
+__global__ void init_reduce(U* out, size_t size) {
+  auto index = cg::this_grid().thread_rank();
+  if (index < size) {
+    out[index] = ReduceInit<Op, T>::value();
+  }
+}
+
+} // namespace cu
+
+void init_reduce(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    array& out,
+    Reduce::ReduceType reduce_type) {
+  // Allocate if needed
+  if (out.data_shared_ptr() == nullptr) {
+    out.set_data(allocator::malloc(out.nbytes()));
+  }
+
+  encoder.set_output_array(out);
+  dispatch_all_types(in.dtype(), [&](auto type_tag) {
+    dispatch_reduce_ops(reduce_type, [&](auto reduce_type_tag) {
+      using OP = MLX_GET_TYPE(reduce_type_tag);
+      using T = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+      using U = typename cu::ReduceResult<OP, T>::type;
+      auto kernel = cu::init_reduce<T, U, OP>;
+      dim3 grid = get_2d_grid_dims(out.shape(), out.strides());
+      dim3 block(grid.x < 1024 ? grid.x : 1024, 1, 1);
+      grid.x = (grid.x + 1023) / 1024;
+      encoder.add_kernel_node(
+          kernel, grid, block, 0, out.data<U>(), out.size());
+    });
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/reduce.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/reduce.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..02e495594adeb713798a26aac1bf2fd1e5b24d00
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/reduce.cuh
@@ -0,0 +1,71 @@
+// Copyright © 2025 Apple Inc.
+
+#include <type_traits>
+
+#include "mlx/backend/common/reduce.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/backend/cuda/reduce/reduce_ops.cuh"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+template <typename F>
+void dispatch_reduce_ndim(int ndim, F&& f) {
+  if (ndim == 1) {
+    f(std::integral_constant<int, 1>{});
+  } else if (ndim == 2) {
+    f(std::integral_constant<int, 2>{});
+  } else {
+    f(std::integral_constant<int, 5>{});
+  }
+}
+
+template <typename F>
+void dispatch_reduce_ops(Reduce::ReduceType reduce_type, F&& f) {
+  if (reduce_type == Reduce::ReduceType::And) {
+    f(type_identity<cu::And>{});
+  } else if (reduce_type == Reduce::ReduceType::Or) {
+    f(type_identity<cu::Or>{});
+  } else if (reduce_type == Reduce::ReduceType::Sum) {
+    f(type_identity<cu::Sum>{});
+  } else if (reduce_type == Reduce::ReduceType::Prod) {
+    f(type_identity<cu::Prod>{});
+  } else if (reduce_type == Reduce::ReduceType::Max) {
+    f(type_identity<cu::Max>{});
+  } else if (reduce_type == Reduce::ReduceType::Min) {
+    f(type_identity<cu::Min>{});
+  } else {
+    throw std::invalid_argument("Unknown reduce type.");
+  }
+}
+
+void all_reduce(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    array& out,
+    Reduce::ReduceType reduce_type);
+
+void row_reduce(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    array& out,
+    Reduce::ReduceType reduce_type,
+    const std::vector<int>& axes,
+    const ReductionPlan& plan);
+
+void col_reduce(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    array& out,
+    Reduce::ReduceType reduce_type,
+    const std::vector<int>& axes,
+    const ReductionPlan& plan);
+
+void init_reduce(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    array& out,
+    Reduce::ReduceType reduce_type);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/reduce_ops.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/reduce_ops.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..7f8cad0c4e85aa66619be491aad38e22df04b988
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/reduce_ops.cuh
@@ -0,0 +1,211 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cuda/device/atomic_ops.cuh"
+#include "mlx/backend/cuda/device/cast_op.cuh"
+#include "mlx/backend/cuda/device/utils.cuh"
+#include "mlx/backend/cuda/reduce/reduce_utils.cuh"
+
+namespace mlx::core::cu {
+
+// Reduce ops.
+struct And {
+  __device__ __forceinline__ bool operator()(bool a, bool b) {
+    return a && b;
+  }
+
+  __device__ void atomic_update(bool* x, bool y) {
+    atomic_reduce<bool, And>(x, y);
+  }
+};
+
+struct Or {
+  __device__ __forceinline__ bool operator()(bool a, bool b) {
+    return a || b;
+  }
+
+  __device__ void atomic_update(bool* x, bool y) {
+    atomic_reduce<bool, Or>(x, y);
+  }
+};
+
+struct Sum {
+  template <typename T>
+  __device__ __forceinline__ T operator()(T a, T b) {
+    return a + b;
+  }
+
+  template <typename T>
+  __device__ void atomic_update(T* x, T y) {
+    atomic_reduce<T, Sum>(x, y);
+  }
+
+  __device__ void atomic_update(__nv_bfloat16* x, __nv_bfloat16 y) {
+    atomic_add(x, y);
+  }
+
+  __device__ void atomic_update(int* x, int y) {
+    atomic_add(x, y);
+  }
+
+  __device__ void atomic_update(float* x, float y) {
+    atomic_add(x, y);
+  }
+};
+
+struct Prod {
+  template <typename T>
+  __device__ __forceinline__ T operator()(T a, T b) {
+    return a * b;
+  }
+
+  template <typename T>
+  __device__ void atomic_update(T* x, T y) {
+    atomic_reduce<T, Prod>(x, y);
+  }
+};
+
+struct Min {
+  template <typename T>
+  __device__ __forceinline__ T operator()(T a, T b) {
+    if constexpr (is_complex_v<T>) {
+      if (isnan(a.real()) || isnan(a.imag())) {
+        return a;
+      }
+      if (isnan(b.real()) || isnan(b.imag())) {
+        return b;
+      }
+    } else if constexpr (!cuda::std::is_integral_v<T>) {
+      if (isnan(a) || isnan(b)) {
+        return cuda::std::numeric_limits<float>::quiet_NaN();
+      }
+    }
+    return a < b ? a : b;
+  }
+
+  template <typename T>
+  __device__ void atomic_update(T* x, T y) {
+    atomic_reduce<T, Min>(x, y);
+  }
+};
+
+struct Max {
+  template <typename T>
+  __device__ __forceinline__ T operator()(T a, T b) {
+    if constexpr (is_complex_v<T>) {
+      if (isnan(a.real()) || isnan(a.imag())) {
+        return a;
+      }
+      if (isnan(b.real()) || isnan(b.imag())) {
+        return b;
+      }
+    } else if constexpr (!cuda::std::is_integral_v<T>) {
+      if (isnan(a) || isnan(b)) {
+        return cuda::std::numeric_limits<float>::quiet_NaN();
+      }
+    }
+    return a > b ? a : b;
+  }
+
+  template <typename T>
+  __device__ void atomic_update(T* x, T y) {
+    atomic_reduce<T, Max>(x, y);
+  }
+};
+
+// Traits to get the result type of reduce op.
+template <typename Op, typename T>
+struct ReduceResult;
+
+template <typename T>
+struct ReduceResult<And, T> {
+  using type = bool;
+};
+
+template <typename T>
+struct ReduceResult<Or, T> {
+  using type = bool;
+};
+
+template <typename T>
+struct ReduceResult<Sum, T> {
+  using type = cuda::std::conditional_t<
+      (cuda::std::is_integral_v<T> && sizeof(T) <= 4),
+      int32_t,
+      T>;
+};
+
+template <typename T>
+struct ReduceResult<Prod, T> {
+  using type = cuda::std::conditional_t<
+      (cuda::std::is_integral_v<T> && sizeof(T) <= 4),
+      int32_t,
+      T>;
+};
+
+template <typename T>
+struct ReduceResult<Min, T> {
+  using type = T;
+};
+
+template <typename T>
+struct ReduceResult<Max, T> {
+  using type = T;
+};
+
+// Traits to get the init value of reduce op.
+template <typename Op, typename T>
+struct ReduceInit;
+
+template <typename T>
+struct ReduceInit<And, T> {
+  static constexpr __host__ __device__ bool value() {
+    return true;
+  }
+};
+
+template <typename T>
+struct ReduceInit<Or, T> {
+  static constexpr __host__ __device__ bool value() {
+    return false;
+  }
+};
+
+template <typename T>
+struct ReduceInit<Sum, T> {
+  static constexpr __host__ __device__ auto value() {
+    if constexpr (is_complex_v<T>) {
+      return T{0, 0};
+    } else {
+      return cast_to<typename ReduceResult<Sum, T>::type>(0);
+    }
+  }
+};
+
+template <typename T>
+struct ReduceInit<Prod, T> {
+  static constexpr __host__ __device__ auto value() {
+    if constexpr (is_complex_v<T>) {
+      return T{1, 0};
+    } else {
+      return cast_to<typename ReduceResult<Prod, T>::type>(1);
+    }
+  }
+};
+
+template <typename T>
+struct ReduceInit<Min, T> {
+  static constexpr __host__ __device__ T value() {
+    return Limits<T>::max();
+  }
+};
+
+template <typename T>
+struct ReduceInit<Max, T> {
+  static constexpr __host__ __device__ T value() {
+    return Limits<T>::min();
+  }
+};
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/reduce_utils.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/reduce_utils.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..d993bacbbb8c971fccb3ff5cde988497d4966654
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/reduce_utils.cuh
@@ -0,0 +1,143 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include <numeric>
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/cuda/device/utils.cuh"
+
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <size_t N>
+struct uint_by_size;
+template <>
+struct uint_by_size<2> {
+  using type = uint16_t;
+};
+template <>
+struct uint_by_size<4> {
+  using type = uint32_t;
+};
+template <>
+struct uint_by_size<8> {
+  using type = unsigned long long int;
+};
+
+template <typename T, typename Op>
+__device__ void atomic_reduce(T* x, T y) {
+  if constexpr (sizeof(T) == 1) {
+    using U = uint16_t;
+    U* x_int = (U*)((char*)x - ((size_t)x % 2));
+    int shift = ((char*)x - (char*)x_int) * 8;
+    int mask = 0xff << shift;
+    U old_val, new_val;
+    do {
+      old_val = *x_int;
+      T result = Op{}(static_cast<T>((old_val >> shift) & 0xff), y);
+      new_val = (old_val & ~mask) | (result << shift);
+    } while (atomicCAS(x_int, old_val, new_val) != old_val);
+  } else {
+    using U = typename uint_by_size<sizeof(T)>::type;
+    U* x_int = (U*)(x);
+    U old_val, new_val;
+    do {
+      old_val = *x_int;
+      T result = Op{}(*((T*)&old_val), y);
+      new_val = *((U*)&result);
+    } while (atomicCAS(x_int, old_val, new_val) != old_val);
+  }
+}
+
+template <typename T, int N, typename Block, typename Warp, typename Op>
+inline __device__ void
+block_reduce(Block block, Warp warp, T (&vals)[N], T* smem, Op op, T init) {
+  // First reduce in the current warp
+  for (int i = 0; i < N; i++) {
+    vals[i] = cg::reduce(warp, vals[i], op);
+  }
+
+  // Reduce across warps
+  if (warp.meta_group_size() > 1) {
+    if (warp.thread_rank() == 0) {
+      for (int i = 0; i < N; i++) {
+        smem[warp.meta_group_rank() * N + i] = vals[i];
+      }
+    }
+    block.sync();
+    if (warp.thread_rank() < warp.meta_group_size()) {
+      for (int i = 0; i < N; i++) {
+        vals[i] = smem[warp.thread_rank() * N + i];
+      }
+    } else {
+      for (int i = 0; i < N; i++) {
+        vals[i] = init;
+      }
+    }
+    for (int i = 0; i < N; i++) {
+      vals[i] = cg::reduce(warp, vals[i], op);
+    }
+  }
+}
+
+} // namespace cu
+
+inline void allocate_same_layout(
+    array& out,
+    const array& in,
+    const std::vector<int>& axes) {
+  if (in.flags().row_contiguous) {
+    out.set_data(allocator::malloc(out.nbytes()));
+    return;
+  }
+
+  if (out.ndim() < in.ndim()) {
+    throw std::runtime_error(
+        "Reduction without keepdims only supported for row-contiguous inputs");
+  }
+
+  // Calculate the transpositions applied to in in order to apply them to out.
+  std::vector<int> axis_order(in.ndim());
+  std::iota(axis_order.begin(), axis_order.end(), 0);
+  std::sort(axis_order.begin(), axis_order.end(), [&](int left, int right) {
+    return in.strides(left) > in.strides(right);
+  });
+
+  // Transpose the shape and calculate the strides
+  Shape out_shape(in.ndim());
+  Strides out_strides(in.ndim(), 1);
+  for (int i = 0; i < in.ndim(); i++) {
+    out_shape[i] = out.shape(axis_order[i]);
+  }
+  for (int i = in.ndim() - 2; i >= 0; i--) {
+    out_strides[i] = out_shape[i + 1] * out_strides[i + 1];
+  }
+
+  // Reverse the axis order to get the final strides
+  Strides final_strides(in.ndim());
+  for (int i = 0; i < in.ndim(); i++) {
+    final_strides[axis_order[i]] = out_strides[i];
+  }
+
+  // Calculate the resulting contiguity and do the memory allocation
+  auto [data_size, rc, cc] = check_contiguity(out.shape(), final_strides);
+  auto fl = in.flags();
+  fl.row_contiguous = rc;
+  fl.col_contiguous = cc;
+  fl.contiguous = true;
+  out.set_data(
+      allocator::malloc(out.nbytes()),
+      data_size,
+      final_strides,
+      fl,
+      allocator::free);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/row_reduce.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/row_reduce.cu
new file mode 100644
index 0000000000000000000000000000000000000000..1ae46d0a3e2a16680332fb1cf6fd14047fd74294
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/reduce/row_reduce.cu
@@ -0,0 +1,361 @@
+// Copyright © 2025 Apple Inc.
+
+#include <numeric>
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/reduce/reduce.cuh"
+
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+struct RowReduceArgs {
+  // The size of the row being reduced, i.e. the size of last dimension.
+  int row_size;
+
+  // Input shape and strides excluding the reduction axes.
+  Shape shape;
+  Strides strides;
+  int ndim;
+
+  // Input shape and strides of the reduction axes excluding last dimension.
+  Shape reduce_shape;
+  Strides reduce_strides;
+  int reduce_ndim;
+
+  // The number of rows we are reducing. Namely prod(reduce_shape).
+  size_t non_row_reductions;
+
+  RowReduceArgs(
+      const array& in,
+      const ReductionPlan& plan,
+      const std::vector<int>& axes) {
+    assert(!plan.shape.empty());
+    row_size = plan.shape.back();
+
+    auto [shape_vec, strides_vec] = shapes_without_reduction_axes(in, axes);
+    std::tie(shape_vec, strides_vec) =
+        collapse_contiguous_dims(shape_vec, strides_vec);
+    shape = const_param(shape_vec);
+    strides = const_param(strides_vec);
+    ndim = shape_vec.size();
+
+    reduce_shape = const_param(plan.shape);
+    reduce_strides = const_param(plan.strides);
+    reduce_ndim = plan.shape.size() - 1;
+
+    non_row_reductions = 1;
+    for (int i = 0; i < reduce_ndim; i++) {
+      non_row_reductions *= reduce_shape[i];
+    }
+  }
+
+  // Convert shape and strides as if in was contiguous
+  void sort_access_pattern(const array& in, const std::vector<int>& axes) {
+    auto shape_vec = in.shape();
+    auto strides_vec = in.strides();
+    std::tie(shape_vec, strides_vec) =
+        shapes_without_reduction_axes(shape_vec, strides_vec, axes);
+    std::vector<int> indices(shape_vec.size());
+    std::iota(indices.begin(), indices.end(), 0);
+    std::sort(indices.begin(), indices.end(), [&](int left, int right) {
+      return strides_vec[left] > strides_vec[right];
+    });
+    decltype(shape_vec) sorted_shape;
+    decltype(strides_vec) sorted_strides;
+    for (auto idx : indices) {
+      sorted_shape.push_back(shape_vec[idx]);
+      sorted_strides.push_back(strides_vec[idx]);
+    }
+    std::tie(shape_vec, strides_vec) =
+        collapse_contiguous_dims(sorted_shape, sorted_strides);
+    shape = const_param(shape_vec);
+    strides = const_param(strides_vec);
+    ndim = shape_vec.size();
+  }
+};
+
+template <typename T, typename U, typename ReduceOp, int N = 4, int M = 1>
+__global__ void
+row_reduce_simple(const T* in, U* out, size_t n_rows, int size) {
+  auto grid = cg::this_grid();
+  auto block = cg::this_thread_block();
+  auto warp = cg::tiled_partition<WARP_SIZE>(block);
+
+  const U init = cu::ReduceInit<ReduceOp, T>::value();
+  ReduceOp op;
+
+  AlignedVector<T, N> vals[M];
+  AlignedVector<U, M> accs;
+  for (int i = 0; i < M; i++) {
+    accs[i] = init;
+  }
+
+  const size_t start_row =
+      min(n_rows - M, static_cast<size_t>(grid.block_rank() * M));
+  const size_t full_blocks = size / (block.size() * N);
+  const size_t final_offset = full_blocks * (block.size() * N);
+  in += start_row * size + block.thread_rank() * N;
+  out += start_row;
+
+  for (size_t r = 0; r < full_blocks; r++) {
+    for (int k = 0; k < M; k++) {
+      vals[k] = load_vector<N>(in + k * size, 0);
+    }
+    for (int k = 0; k < M; k++) {
+      for (int j = 0; j < N; j++) {
+        accs[k] = op(accs[k], cast_to<U>(vals[k][j]));
+      }
+    }
+
+    in += block.size() * N;
+  }
+
+  if (final_offset < size) {
+    for (int k = 0; k < M; k++) {
+      for (int i = 0; i < N; i++) {
+        vals[k][i] = ((final_offset + block.thread_rank() * N + i) < size)
+            ? in[k * size + i]
+            : cast_to<T>(init);
+      }
+    }
+    for (int k = 0; k < M; k++) {
+      for (int j = 0; j < N; j++) {
+        accs[k] = op(accs[k], cast_to<U>(vals[k][j]));
+      }
+    }
+  }
+
+  __shared__ U shared_accumulators[32 * M];
+  block_reduce(block, warp, accs.val, shared_accumulators, op, init);
+
+  if (block.thread_rank() == 0) {
+    if (grid.block_rank() * M + M <= n_rows) {
+      store_vector(out, 0, accs);
+    } else {
+      short offset = grid.block_rank() * M + M - n_rows;
+      for (int i = offset; i < M; i++) {
+        out[i] = accs[i];
+      }
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, int NDIM, int N_READS = 4>
+__global__ void row_reduce_looped(
+    const T* in,
+    U* out,
+    const __grid_constant__ RowReduceArgs args) {
+  auto grid = cg::this_grid();
+  auto block = cg::this_thread_block();
+  auto warp = cg::tiled_partition<WARP_SIZE>(block);
+
+  size_t out_idx = grid.block_rank();
+
+  Op op;
+
+  U total[1];
+  U init = ReduceInit<Op, T>::value();
+  total[0] = init;
+  LoopedElemToLoc<NDIM, (NDIM > 2)> loop(args.reduce_ndim);
+  const size_t full_blocks = args.row_size / (block.size() * N_READS);
+  const size_t final_offset = full_blocks * (block.size() * N_READS);
+
+  in += elem_to_loc(out_idx, args.shape.data(), args.strides.data(), args.ndim);
+  in += block.thread_rank() * N_READS;
+
+  // Unaligned reduce
+  if (final_offset < args.row_size) {
+    bool mask[N_READS];
+    for (int i = 0; i < N_READS; i++) {
+      mask[i] =
+          (final_offset + block.thread_rank() * N_READS + i) < args.row_size;
+    }
+
+    for (size_t n = 0; n < args.non_row_reductions; n++) {
+      const T* inlocal = in + loop.location();
+
+      for (size_t r = 0; r < full_blocks; r++) {
+        auto vals = load_vector<N_READS>(inlocal, 0);
+        for (int i = 0; i < N_READS; i++) {
+          total[0] = op(total[0], cast_to<U>(vals[i]));
+        }
+        inlocal += block.size() * N_READS;
+      }
+
+      {
+        T vals[N_READS];
+        for (int i = 0; i < N_READS; i++) {
+          vals[i] = mask[i] ? inlocal[i] : cast_to<T>(init);
+        }
+        for (int i = 0; i < N_READS; i++) {
+          total[0] = op(total[0], cast_to<U>(vals[i]));
+        }
+      }
+
+      loop.next(args.reduce_shape.data(), args.reduce_strides.data());
+    }
+  }
+
+  // Aligned case
+  else {
+    for (size_t n = 0; n < args.non_row_reductions; n++) {
+      const T* inlocal = in + loop.location();
+
+      for (size_t r = 0; r < full_blocks; r++) {
+        auto vals = load_vector<N_READS>(inlocal, 0);
+        for (int i = 0; i < N_READS; i++) {
+          total[0] = op(total[0], cast_to<U>(vals[i]));
+        }
+        inlocal += block.size() * N_READS;
+      }
+
+      loop.next(args.reduce_shape.data(), args.reduce_strides.data());
+    }
+  }
+
+  __shared__ U shared_accumulators[32];
+  block_reduce(block, warp, total, shared_accumulators, op, init);
+
+  if (block.thread_rank() == 0) {
+    out[out_idx] = total[0];
+  }
+}
+
+} // namespace cu
+
+void row_reduce_simple(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    array& out,
+    Reduce::ReduceType reduce_type,
+    const std::vector<int>& axes,
+    const ReductionPlan& plan) {
+  // Allocate data for the output using in's layout to avoid elem_to_loc in the
+  // kernel.
+  allocate_same_layout(out, in, axes);
+
+  // TODO: If out.size() < 1024 which will be a common case then write this in
+  //       2 passes. Something like 32 * out.size() and then do a warp reduce.
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  dispatch_all_types(in.dtype(), [&](auto type_tag) {
+    dispatch_reduce_ops(reduce_type, [&](auto reduce_type_tag) {
+      using OP = MLX_GET_TYPE(reduce_type_tag);
+      using T = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+      using U = typename cu::ReduceResult<OP, T>::type;
+
+      constexpr int N_READS = 16 / sizeof(T);
+
+      // Calculate the grid and block dims
+      size_t reductions = (plan.shape.back() + N_READS - 1) / N_READS;
+      dim3 grid = get_2d_grid_dims(out.shape(), out.strides());
+      int warps = (reductions + WARP_SIZE - 1) / WARP_SIZE;
+      warps /= 4;
+      warps = std::max(std::min(warps, 32), 1);
+      int threads = warps * WARP_SIZE;
+      dim3 block(threads, 1, 1);
+
+      // Pick the kernel
+      auto kernel = cu::row_reduce_simple<T, U, OP, N_READS>;
+      if (grid.x >= 1024) {
+        grid.x = (grid.x + 1) / 2;
+        kernel = cu::row_reduce_simple<T, U, OP, N_READS, 2>;
+      }
+
+      T* indata = const_cast<T*>(in.data<T>());
+      int size = plan.shape.back();
+      encoder.add_kernel_node(
+          kernel, grid, block, 0, indata, out.data<U>(), out.size(), size);
+    });
+  });
+}
+
+void row_reduce_looped(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    array& out,
+    Reduce::ReduceType reduce_type,
+    const std::vector<int>& axes,
+    const ReductionPlan& plan,
+    cu::RowReduceArgs args) {
+  // Allocate data for the output using in's layout to access them as
+  // contiguously as possible.
+  allocate_same_layout(out, in, axes);
+
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  dispatch_all_types(in.dtype(), [&](auto type_tag) {
+    dispatch_reduce_ops(reduce_type, [&](auto reduce_type_tag) {
+      using OP = MLX_GET_TYPE(reduce_type_tag);
+      using T = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+      using U = typename cu::ReduceResult<OP, T>::type;
+
+      constexpr int N_READS = 16 / sizeof(T);
+
+      // Calculate the grid and block dims
+      args.sort_access_pattern(in, axes);
+      dim3 grid = get_2d_grid_dims(out.shape(), out.strides());
+      size_t reductions = (args.row_size + N_READS - 1) / N_READS;
+      int warps = (reductions + WARP_SIZE - 1) / WARP_SIZE;
+      warps /= 4;
+      warps = std::max(std::min(warps, 32), 1);
+      int threads = warps * WARP_SIZE;
+      dim3 block(threads, 1, 1);
+
+      // Pick the kernel
+      auto kernel = cu::row_reduce_looped<T, U, OP, 1, N_READS>;
+      dispatch_reduce_ndim(args.reduce_ndim, [&](auto reduce_ndim) {
+        kernel = cu::row_reduce_looped<T, U, OP, reduce_ndim.value, N_READS>;
+      });
+
+      encoder.add_kernel_node(
+          kernel, grid, block, 0, in.data<T>(), out.data<U>(), args);
+    });
+  });
+}
+
+void row_reduce(
+    cu::CommandEncoder& encoder,
+    const array& in,
+    array& out,
+    Reduce::ReduceType reduce_type,
+    const std::vector<int>& axes,
+    const ReductionPlan& plan) {
+  // Current row reduction options
+  //
+  // - row_reduce_simple
+  //
+  //   That means that we are simply reducing across the fastest moving axis.
+  //   We are reducing 1 or 2 rows per threadblock depending on the size of
+  //   output.
+  //
+  // - row_reduce_looped
+  //
+  //   It is a general row reduction. We are computing 1 output per
+  //   threadblock. We read the fastest moving axis vectorized and loop over
+  //   the rest of the axes.
+  //
+  // Notes: We opt to read as much in order as possible and leave
+  //        transpositions as they are (contrary to our Metal backend).
+
+  // Simple row reduce means that we have 1 axis that we are reducing over and
+  // it has stride 1.
+  if (plan.shape.size() == 1) {
+    row_reduce_simple(encoder, in, out, reduce_type, axes, plan);
+    return;
+  }
+
+  // Make the args struct to help route to the best kernel
+  cu::RowReduceArgs args(in, plan, axes);
+
+  // Fallback row reduce
+  row_reduce_looped(encoder, in, out, reduce_type, axes, plan, std::move(args));
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/rms_norm.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/rms_norm.cu
new file mode 100644
index 0000000000000000000000000000000000000000..bc879c6f8e7b2e3c6f223f81690258e668864956
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/rms_norm.cu
@@ -0,0 +1,342 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/backend/cuda/reduce/reduce.cuh"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/dtype_utils.h"
+#include "mlx/fast_primitives.h"
+
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+inline __device__ float2 plus_f2(const float2& a, const float2& b) {
+  return {a.x + b.x, a.y + b.y};
+}
+
+// Similar to cub::BlockReduce, but result is broadcasted to every thread.
+template <typename T, int BLOCK_DIM>
+struct BlockBroadcastReduce {
+  static_assert(WARP_SIZE <= BLOCK_DIM && BLOCK_DIM <= WARP_SIZE * WARP_SIZE);
+  static_assert(BLOCK_DIM % WARP_SIZE == 0);
+  using TempStorage = T[BLOCK_DIM / WARP_SIZE];
+
+  cg::thread_block& block;
+  TempStorage& temp;
+
+  template <typename Op>
+  __device__ T Reduce(const T& input, const Op& op, const T& init_value) {
+    auto warp = cg::tiled_partition<WARP_SIZE>(block);
+    T x = cg::reduce(warp, input, op);
+    if (warp.thread_rank() == 0) {
+      temp[warp.meta_group_rank()] = x;
+    }
+    block.sync();
+    x = warp.thread_rank() < warp.meta_group_size() ? temp[warp.thread_rank()]
+                                                    : init_value;
+    return cg::reduce(warp, x, op);
+  }
+
+  __device__ T Sum(const T& input) {
+    return Reduce(input, cg::plus<T>{}, T{});
+  }
+};
+
+template <typename T, int BLOCK_DIM, int N_READS = 4>
+__global__ void rms_norm(
+    const T* x,
+    const T* w,
+    T* out,
+    float eps,
+    uint32_t axis_size,
+    int64_t w_stride) {
+  auto grid = cg::this_grid();
+  auto block = cg::this_thread_block();
+
+  using BlockReduceT = BlockBroadcastReduce<float, BLOCK_DIM>;
+  __shared__ typename BlockReduceT::TempStorage temp;
+
+  x += grid.block_rank() * axis_size;
+  out += grid.block_rank() * axis_size;
+
+  // Normalizer.
+  float normalizer = 0;
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); ++r) {
+    auto index = r * BLOCK_DIM + block.thread_rank();
+    auto xn = load_vector<N_READS>(x, index, axis_size, T(0));
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      float t = static_cast<float>(xn[i]);
+      normalizer += t * t;
+    }
+  }
+  normalizer = BlockReduceT{block, temp}.Sum(normalizer);
+  normalizer = rsqrt(normalizer / axis_size + eps);
+
+  // Outputs.
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); ++r) {
+    auto index = r * BLOCK_DIM + block.thread_rank();
+    auto xn = load_vector<N_READS>(x, index, axis_size, T(0));
+    auto wn = load_vector<N_READS>(w, index, axis_size, w_stride, T(0));
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      float y = static_cast<float>(xn[i]) * normalizer;
+      xn[i] = wn[i] * static_cast<T>(y);
+    }
+    store_vector<N_READS>(out, index, xn, axis_size);
+  }
+}
+
+template <typename T, bool HAS_W, int BLOCK_DIM, int N_READS = 4>
+__global__ void rms_norm_vjp(
+    const T* x,
+    const T* w,
+    const T* g,
+    T* gx,
+    T* gw,
+    float eps,
+    int32_t axis_size,
+    int64_t w_stride) {
+  auto grid = cg::this_grid();
+  auto block = cg::this_thread_block();
+
+  using BlockReduceF = BlockBroadcastReduce<float, BLOCK_DIM>;
+  using BlockReduceF2 = BlockBroadcastReduce<float2, BLOCK_DIM>;
+  __shared__ union {
+    typename BlockReduceF::TempStorage f;
+    typename BlockReduceF2::TempStorage f2;
+  } temp;
+
+  x += grid.block_rank() * axis_size;
+  g += grid.block_rank() * axis_size;
+  gx += grid.block_rank() * axis_size;
+  gw += grid.block_rank() * axis_size;
+
+  // Normalizer.
+  float2 factors = {};
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); ++r) {
+    auto index = r * BLOCK_DIM + block.thread_rank();
+    auto xn = load_vector<N_READS>(x, index, axis_size, T(0));
+    auto gn = load_vector<N_READS>(g, index, axis_size, T(0));
+    auto wn = load_vector<N_READS>(w, index, axis_size, w_stride, T(0));
+    for (int i = 0; i < N_READS; i++) {
+      float t = static_cast<float>(xn[i]);
+      float wi = wn[i];
+      float gi = gn[i];
+      float wg = wi * gi;
+      factors = plus_f2(factors, {wg * t, t * t});
+    }
+  }
+  factors = BlockReduceF2{block, temp.f2}.Reduce(factors, plus_f2, {});
+  float meangwx = factors.x / axis_size;
+  float normalizer = rsqrt(factors.y / axis_size + eps);
+  float normalizer3 = normalizer * normalizer * normalizer;
+
+  // Outputs.
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); ++r) {
+    auto index = r * BLOCK_DIM + block.thread_rank();
+    auto xn = load_vector<N_READS>(x, index, axis_size, T(0));
+    auto gn = load_vector<N_READS>(g, index, axis_size, T(0));
+    auto wn = load_vector<N_READS>(w, index, axis_size, w_stride, T(0));
+    for (int i = 0; i < N_READS; i++) {
+      float xi = xn[i];
+      float wi = wn[i];
+      float gi = gn[i];
+      xn[i] = static_cast<T>(normalizer * wi * gi - xi * meangwx * normalizer3);
+      if constexpr (HAS_W) {
+        wn[i] = static_cast<T>(gi * xi * normalizer);
+      }
+    }
+    store_vector<N_READS>(gx, index, xn, axis_size);
+    if constexpr (HAS_W) {
+      store_vector<N_READS>(gw, index, wn, axis_size);
+    }
+  }
+}
+
+} // namespace cu
+
+namespace fast {
+
+bool RMSNorm::use_fallback(Stream s) {
+  return s.device == Device::cpu;
+}
+
+// TODO: There are duplicate code with backend/metal/normalization.cpp
+void RMSNorm::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  nvtx3::scoped_range r("RMSNorm::eval_gpu");
+  auto& s = stream();
+  auto& out = outputs[0];
+
+  // Make sure that the last dimension is contiguous.
+  auto set_output = [&s, &out](const array& x) {
+    bool no_copy = x.flags().contiguous && x.strides()[x.ndim() - 1] == 1;
+    if (no_copy && x.ndim() > 1) {
+      auto s = x.strides()[x.ndim() - 2];
+      no_copy &= (s == 0 || s == x.shape().back());
+    }
+    if (no_copy) {
+      if (x.is_donatable()) {
+        out.copy_shared_buffer(x);
+      } else {
+        out.set_data(
+            allocator::malloc(x.data_size() * x.itemsize()),
+            x.data_size(),
+            x.strides(),
+            x.flags());
+      }
+      return x;
+    } else {
+      array x_copy = contiguous_copy_gpu(x, s);
+      out.copy_shared_buffer(x_copy);
+      return x_copy;
+    }
+  };
+
+  const array x = set_output(inputs[0]);
+  const array& w = inputs[1];
+
+  int32_t axis_size = x.shape().back();
+  int32_t n_rows = x.data_size() / axis_size;
+  int64_t w_stride = (w.ndim() == 1) ? w.strides()[0] : 0;
+
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(x);
+  encoder.set_input_array(w);
+  encoder.set_output_array(out);
+  dispatch_float_types(out.dtype(), "rms_norm", [&](auto type_tag) {
+    using DataType = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+    constexpr int N_READS = 16 / sizeof(DataType);
+    dispatch_block_dim(cuda::ceil_div(axis_size, N_READS), [&](auto block_dim) {
+      auto kernel = cu::rms_norm<DataType, block_dim(), N_READS>;
+      encoder.add_kernel_node(
+          kernel,
+          n_rows,
+          block_dim(),
+          0,
+          x.data<DataType>(),
+          w.data<DataType>(),
+          out.data<DataType>(),
+          eps_,
+          axis_size,
+          w_stride);
+    });
+  });
+}
+
+void RMSNormVJP::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  nvtx3::scoped_range r("RMSNormVJP::eval_gpu");
+  auto& s = stream();
+  auto& encoder = cu::get_command_encoder(s);
+
+  // Ensure row contiguity. We could relax this step by checking that the array
+  // is contiguous (no broadcasts or holes) and that the input strides are the
+  // same as the cotangent strides but for now this is simpler.
+  auto check_input = [&s](const array& x, bool& copied) {
+    if (x.flags().row_contiguous) {
+      copied = false;
+      return x;
+    }
+    copied = true;
+    return contiguous_copy_gpu(x, s);
+  };
+  bool donate_x = inputs[0].is_donatable();
+  bool donate_g = inputs[2].is_donatable();
+  bool copied;
+  auto x = check_input(inputs[0], copied);
+  donate_x |= copied;
+  const array& w = inputs[1];
+  bool g_copied;
+  auto g = check_input(inputs[2], g_copied);
+  donate_g |= g_copied;
+  array& gx = outputs[0];
+  array& gw = outputs[1];
+
+  // Check whether we had a weight.
+  bool has_w = w.ndim() != 0;
+
+  // Allocate space for the outputs.
+  bool g_in_gx = false;
+  if (donate_x) {
+    gx.copy_shared_buffer(x);
+  } else if (donate_g) {
+    gx.copy_shared_buffer(g);
+    g_in_gx = true;
+  } else {
+    gx.set_data(allocator::malloc(gx.nbytes()));
+  }
+  if (g_copied && !g_in_gx) {
+    encoder.add_temporary(g);
+  }
+
+  int32_t axis_size = x.shape().back();
+  int32_t n_rows = x.data_size() / axis_size;
+  int64_t w_stride = (w.ndim() == 1) ? w.strides()[0] : 0;
+
+  // Allocate a temporary to store the gradients for w and allocate the output
+  // gradient accumulators.
+  array gw_temp =
+      (has_w) ? array({n_rows, x.shape().back()}, gw.dtype(), nullptr, {}) : w;
+  if (has_w) {
+    if (!g_in_gx && donate_g) {
+      gw_temp.copy_shared_buffer(g);
+    } else {
+      gw_temp.set_data(allocator::malloc(gw_temp.nbytes()));
+      encoder.add_temporary(gw_temp);
+    }
+  }
+
+  encoder.set_input_array(x);
+  encoder.set_input_array(w);
+  encoder.set_input_array(g);
+  encoder.set_output_array(gx);
+  encoder.set_output_array(gw_temp);
+  dispatch_float_types(gx.dtype(), "rms_norm_vjp", [&](auto type_tag) {
+    dispatch_bool(has_w, [&](auto has_w_constant) {
+      using DataType = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+      constexpr int N_READS = 16 / sizeof(DataType);
+      dispatch_block_dim(
+          cuda::ceil_div(axis_size, N_READS), [&](auto block_dim) {
+            auto kernel = cu::rms_norm_vjp<
+                DataType,
+                has_w_constant.value,
+                block_dim(),
+                N_READS>;
+            encoder.add_kernel_node(
+                kernel,
+                n_rows,
+                block_dim(),
+                0,
+                x.data<DataType>(),
+                w.data<DataType>(),
+                g.data<DataType>(),
+                gx.data<DataType>(),
+                gw_temp.data<DataType>(),
+                eps_,
+                axis_size,
+                w_stride);
+          });
+    });
+  });
+
+  if (has_w) {
+    ReductionPlan plan(
+        ReductionOpType::ContiguousStridedReduce, {n_rows}, {axis_size});
+    col_reduce(encoder, gw_temp, gw, Reduce::ReduceType::Sum, {0}, plan);
+  }
+}
+
+} // namespace fast
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/rope.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/rope.cu
new file mode 100644
index 0000000000000000000000000000000000000000..bac67cf900bfefad12171ec119f4f6c4612a473d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/rope.cu
@@ -0,0 +1,429 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/dtype_utils.h"
+#include "mlx/fast_primitives.h"
+
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core {
+
+namespace cu {
+
+template <typename T, bool traditional, bool forward>
+__device__ void rope_single_impl(
+    const T* in,
+    T* out,
+    int32_t offset,
+    float inv_freq,
+    float scale,
+    int64_t stride,
+    uint2 pos,
+    uint2 dims) {
+  float L = scale * static_cast<float>(offset);
+
+  // Compute costheta, sintheta
+  float theta = L * inv_freq;
+  float costheta = cos(theta);
+  float sintheta = sin(theta);
+
+  // Compute the input and output indices
+  uint index_1, index_2;
+  if (traditional) {
+    index_1 = 2 * pos.x + pos.y * stride;
+    index_2 = index_1 + 1;
+  } else {
+    index_1 = pos.x + pos.y * stride;
+    index_2 = index_1 + dims.x;
+  }
+
+  // Read and write the output
+  float x1 = static_cast<float>(in[index_1]);
+  float x2 = static_cast<float>(in[index_2]);
+  float rx1;
+  float rx2;
+  if (forward) {
+    rx1 = x1 * costheta - x2 * sintheta;
+    rx2 = x1 * sintheta + x2 * costheta;
+  } else {
+    rx1 = x2 * sintheta + x1 * costheta;
+    rx2 = x2 * costheta - x1 * sintheta;
+  }
+  out[index_1] = static_cast<T>(rx1);
+  out[index_2] = static_cast<T>(rx2);
+}
+
+template <typename T, bool traditional, bool forward>
+__global__ void rope_single(
+    const T* in,
+    T* out,
+    const int32_t* offset,
+    float scale,
+    float base,
+    int64_t stride,
+    uint2 dims) {
+  uint2 pos = make_uint2(
+      blockIdx.x * blockDim.x + threadIdx.x,
+      blockIdx.y * blockDim.y + threadIdx.y);
+  if (pos.x >= dims.x || pos.y >= dims.y) {
+    return;
+  }
+
+  float d = static_cast<float>(pos.x) / static_cast<float>(dims.x);
+  float inv_freq = exp2(-d * base);
+  rope_single_impl<T, traditional, forward>(
+      in, out, *offset, inv_freq, scale, stride, pos, dims);
+}
+
+template <typename T, bool traditional, bool forward>
+__global__ void rope_single_freqs(
+    const T* in,
+    T* out,
+    const int32_t* offset,
+    const float* freqs,
+    float scale,
+    int64_t stride,
+    uint2 dims,
+    int64_t freq_stride) {
+  uint2 pos = make_uint2(
+      blockIdx.x * blockDim.x + threadIdx.x,
+      blockIdx.y * blockDim.y + threadIdx.y);
+  if (pos.x >= dims.x || pos.y >= dims.y) {
+    return;
+  }
+
+  float inv_freq = 1.0 / freqs[freq_stride * pos.x];
+  rope_single_impl<T, traditional, forward>(
+      in, out, *offset, inv_freq, scale, stride, pos, dims);
+}
+
+template <typename T, bool traditional, bool forward, int N = 4>
+__device__ void rope_impl(
+    const T* in,
+    T* out,
+    const int* offset,
+    float inv_freq,
+    float scale,
+    const cuda::std::array<int64_t, 3> strides,
+    const cuda::std::array<int64_t, 3> out_strides,
+    int64_t offset_stride,
+    int n_head,
+    uint3 pos,
+    uint3 dims) {
+  auto n_head_up = N * ((n_head + N - 1) / N);
+  auto head_idx = static_cast<int>((pos.z * N) % n_head_up);
+  auto batch_idx = (pos.z * N) / n_head_up;
+  auto batch_offset = offset[batch_idx * offset_stride];
+  float L = scale * static_cast<float>(pos.y + batch_offset);
+  auto mat_idx = batch_idx * n_head + head_idx;
+
+  // Compute costheta, sintheta
+  float theta = L * inv_freq;
+  float costheta = cos(theta);
+  float sintheta = sin(theta);
+
+  // Compute the input and output indices
+  size_t in_index_1, in_index_2;
+  size_t out_index_1, out_index_2;
+  if (traditional) {
+    out_index_1 = 2 * pos.x * out_strides[2] + pos.y * out_strides[1] +
+        mat_idx * out_strides[0];
+    out_index_2 = out_index_1 + 1;
+    in_index_1 =
+        2 * pos.x * strides[2] + pos.y * strides[1] + mat_idx * strides[0];
+    in_index_2 = in_index_1 + strides[2];
+  } else {
+    out_index_1 = pos.x * out_strides[2] + pos.y * out_strides[1] +
+        mat_idx * out_strides[0];
+    out_index_2 = out_index_1 + dims.x * out_strides[2];
+    in_index_1 = pos.x * strides[2] + pos.y * strides[1] + mat_idx * strides[0];
+    in_index_2 = in_index_1 + dims.x * strides[2];
+  }
+  for (int i = 0; i < N && head_idx + i < n_head; ++i) {
+    // Read and write the output
+    float x1 = static_cast<float>(in[in_index_1]);
+    float x2 = static_cast<float>(in[in_index_2]);
+    float rx1;
+    float rx2;
+    if (forward) {
+      rx1 = x1 * costheta - x2 * sintheta;
+      rx2 = x1 * sintheta + x2 * costheta;
+    } else {
+      rx1 = x2 * sintheta + x1 * costheta;
+      rx2 = x2 * costheta - x1 * sintheta;
+    }
+    out[out_index_1] = static_cast<T>(rx1);
+    out[out_index_2] = static_cast<T>(rx2);
+    in_index_1 += strides[0];
+    in_index_2 += strides[0];
+    out_index_1 += out_strides[0];
+    out_index_2 += out_strides[0];
+  }
+}
+
+template <typename T, bool traditional, bool forward>
+__global__ void rope(
+    const T* in,
+    T* out,
+    const int32_t* offset,
+    float scale,
+    float base,
+    const __grid_constant__ cuda::std::array<int64_t, 3> strides,
+    const __grid_constant__ cuda::std::array<int64_t, 3> out_strides,
+    int64_t offset_stride,
+    int n_head,
+    uint3 dims) {
+  uint3 pos = make_uint3(
+      blockIdx.x * blockDim.x + threadIdx.x,
+      blockIdx.y * blockDim.y + threadIdx.y,
+      blockIdx.z * blockDim.z + threadIdx.z);
+  if (pos.x >= dims.x || pos.y >= dims.y || pos.z >= dims.z) {
+    return;
+  }
+
+  float d = static_cast<float>(pos.x) / static_cast<float>(dims.x);
+  float inv_freq = exp2(-d * base);
+  rope_impl<T, traditional, forward>(
+      in,
+      out,
+      offset,
+      inv_freq,
+      scale,
+      strides,
+      out_strides,
+      offset_stride,
+      n_head,
+      pos,
+      dims);
+}
+
+template <typename T, bool traditional, bool forward>
+__global__ void rope_freqs(
+    const T* in,
+    T* out,
+    const int32_t* offset,
+    const float* freqs,
+    float scale,
+    float base,
+    const __grid_constant__ cuda::std::array<int64_t, 3> strides,
+    const __grid_constant__ cuda::std::array<int64_t, 3> out_strides,
+    int64_t offset_stride,
+    int n_head,
+    uint3 dims,
+    int64_t freq_stride) {
+  uint3 pos = make_uint3(
+      blockIdx.x * blockDim.x + threadIdx.x,
+      blockIdx.y * blockDim.y + threadIdx.y,
+      blockIdx.z * blockDim.z + threadIdx.z);
+  if (pos.x >= dims.x || pos.y >= dims.y || pos.z >= dims.z) {
+    return;
+  }
+
+  float inv_freq = 1.0 / freqs[freq_stride * pos.x];
+  rope_impl<T, traditional, forward>(
+      in,
+      out,
+      offset,
+      inv_freq,
+      scale,
+      strides,
+      out_strides,
+      offset_stride,
+      n_head,
+      pos,
+      dims);
+}
+
+} // namespace cu
+
+namespace fast {
+
+bool RoPE::use_fallback(Stream s) {
+  return s.device == Device::cpu;
+}
+
+void RoPE::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  nvtx3::scoped_range r("RoPE::eval_gpu");
+
+  auto& s = stream();
+  auto& in = inputs[0];
+  auto& offset = inputs[1];
+  auto& out = outputs[0];
+
+  cuda::std::array<int64_t, 3> strides;
+  cuda::std::array<int64_t, 3> out_strides;
+  bool donated = false;
+  int ndim = in.ndim();
+
+  int B = in.shape(0);
+  int T = in.shape(-2);
+  int D = in.shape(-1);
+  size_t mat_size = T * D;
+  int dispatch_ndim = ndim;
+  while (in.shape(-dispatch_ndim) == 1 && dispatch_ndim > 3) {
+    dispatch_ndim--;
+  }
+
+  int N = 1;
+  for (int i = 1; i < (ndim - 2); ++i) {
+    N *= in.shape(i);
+  }
+
+  // We apply rope to less that the whole vector so copy to output and then
+  // apply in-place.
+  if (dims_ < D) {
+    donated = true;
+    auto ctype =
+        (in.flags().row_contiguous) ? CopyType::Vector : CopyType::General;
+    copy_gpu(in, out, ctype, s);
+    strides[0] = mat_size;
+    strides[1] = out.strides()[ndim - 2];
+    strides[2] = out.strides()[ndim - 1];
+  }
+
+  // Either copy or apply in-place
+  else if (in.flags().row_contiguous) {
+    if (in.is_donatable()) {
+      donated = true;
+      out.copy_shared_buffer(in);
+    } else {
+      out.set_data(allocator::malloc(out.nbytes()));
+    }
+    strides[0] = mat_size;
+    strides[1] = in.strides()[ndim - 2];
+    strides[2] = in.strides()[ndim - 1];
+  } else if (dispatch_ndim == 3) {
+    // Handle non-contiguous 3D inputs
+    out.set_data(allocator::malloc(out.nbytes()));
+    strides[0] = in.strides()[ndim - 3];
+    strides[1] = in.strides()[ndim - 2];
+    strides[2] = in.strides()[ndim - 1];
+  } else {
+    // Copy non-contiguous > 3D inputs into the output and treat
+    // input as donated
+    donated = true;
+    copy_gpu(in, out, CopyType::General, s);
+    strides[0] = mat_size;
+    strides[1] = out.strides()[ndim - 2];
+    strides[2] = out.strides()[ndim - 1];
+  }
+  out_strides[0] = mat_size;
+  out_strides[1] = out.strides()[ndim - 2];
+  out_strides[2] = out.strides()[ndim - 1];
+
+  // Some flags to help us dispatch below
+  bool single = in.flags().row_contiguous && B == 1 && T == 1;
+  bool with_freqs = inputs.size() == 3;
+
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(donated ? out : in);
+  encoder.set_input_array(offset);
+  if (with_freqs) {
+    encoder.set_input_array(inputs[2]);
+  }
+  encoder.set_output_array(out);
+  dispatch_float_types(out.dtype(), "rope", [&](auto type_tag) {
+    dispatch_bool(traditional_, [&](auto traditional) {
+      dispatch_bool(forward_, [&](auto forward) {
+        using DataType = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+        if (single && !with_freqs) {
+          auto kernel =
+              cu::rope_single<DataType, traditional.value, forward.value>;
+          uint2 dims = make_uint2(dims_ / 2, N);
+          auto [grid, block] = get_grid_and_block(dims.x, dims.y, 1);
+          encoder.add_kernel_node(
+              kernel,
+              grid,
+              block,
+              0,
+              (donated ? out : in).data<DataType>(),
+              out.data<DataType>(),
+              offset.data<int32_t>(),
+              scale_,
+              std::log2(base_),
+              mat_size,
+              dims);
+        } else if (single) {
+          auto kernel =
+              cu::rope_single_freqs<DataType, traditional.value, forward.value>;
+          uint2 dims = make_uint2(dims_ / 2, N);
+          auto [grid, block] = get_grid_and_block(dims.x, dims.y, 1);
+          encoder.add_kernel_node(
+              kernel,
+              grid,
+              block,
+              0,
+              (donated ? out : in).data<DataType>(),
+              out.data<DataType>(),
+              offset.data<int32_t>(),
+              inputs[2].data<float>(),
+              scale_,
+              mat_size,
+              dims,
+              inputs[2].strides(0));
+        } else if (with_freqs) {
+          auto kernel =
+              cu::rope_freqs<DataType, traditional.value, forward.value>;
+          int n_per_thread = 4;
+          uint32_t dimz = B * ((N + n_per_thread - 1) / n_per_thread);
+          uint3 dims = make_uint3(dims_ / 2, T, dimz);
+          auto [grid, block] = get_grid_and_block(dims.x, dims.y, dims.z);
+          int64_t offset_stride = 0;
+          if (inputs[1].ndim() > 0) {
+            offset_stride = inputs[1].strides()[0];
+          }
+          encoder.add_kernel_node(
+              kernel,
+              grid,
+              block,
+              0,
+              (donated ? out : in).data<DataType>(),
+              out.data<DataType>(),
+              offset.data<int32_t>(),
+              inputs[2].data<float>(),
+              scale_,
+              std::log2(base_),
+              strides,
+              out_strides,
+              offset_stride,
+              N,
+              dims,
+              inputs[2].strides(0));
+        } else {
+          auto kernel = cu::rope<DataType, traditional.value, forward.value>;
+          int n_per_thread = 4;
+          uint32_t dimz = B * ((N + n_per_thread - 1) / n_per_thread);
+          uint3 dims = make_uint3(dims_ / 2, T, dimz);
+          auto [grid, block] = get_grid_and_block(dims.x, dims.y, dims.z);
+          int64_t offset_stride = 0;
+          if (inputs[1].ndim() > 0) {
+            offset_stride = inputs[1].strides()[0];
+          }
+          encoder.add_kernel_node(
+              kernel,
+              grid,
+              block,
+              0,
+              (donated ? out : in).data<DataType>(),
+              out.data<DataType>(),
+              offset.data<int32_t>(),
+              scale_,
+              std::log2(base_),
+              strides,
+              out_strides,
+              offset_stride,
+              N,
+              dims);
+        }
+      });
+    });
+  });
+}
+
+} // namespace fast
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/scaled_dot_product_attention.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/scaled_dot_product_attention.cu
new file mode 100644
index 0000000000000000000000000000000000000000..825da5cd367b11d6b7fb2dc8eb182fde88651e87
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/scaled_dot_product_attention.cu
@@ -0,0 +1,812 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/device/config.h"
+#include "mlx/backend/cuda/device/utils.cuh"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/dtype_utils.h"
+#include "mlx/fast_primitives.h"
+#include "mlx/transforms_impl.h"
+
+#include <nvtx3/nvtx3.hpp>
+
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+#define PRAGMA_LOOP_UNROLL #pragma unroll
+
+struct AttnParams {
+  int B;
+  int H;
+  int D;
+
+  int qL;
+  int kL;
+
+  int gqa_factor;
+  float scale;
+
+  int64_t Q_strides[3];
+  int64_t K_strides[3];
+  int64_t V_strides[3];
+  int64_t O_strides[3];
+};
+
+template <typename T, bool do_causal, int D>
+__global__ void kernel_sdpav_1pass(
+    const T* Q,
+    const T* K,
+    const T* V,
+    T* O,
+    const T* sinks,
+    __grid_constant__ const AttnParams params) {
+  constexpr int BN = 32;
+  constexpr int BD = 32;
+
+  constexpr int v_per_thread = D / BD;
+
+  const int inner_k_stride = BN * int(params.K_strides[2]);
+  const int inner_v_stride = BN * int(params.V_strides[2]);
+
+  typedef float U;
+
+  U q[v_per_thread];
+  U k[v_per_thread];
+  U o[v_per_thread];
+
+  __shared__ U outputs[BN][BD + 1];
+  __shared__ U max_scores[BN];
+  __shared__ U sum_exp_scores[BN];
+
+  const U scale_log2 = params.scale * M_LOG2E;
+
+  auto block = cg::this_thread_block();
+  auto warp = cg::tiled_partition<32>(block);
+
+  const int lane_idx = warp.thread_rank();
+  const int warp_idx = warp.meta_group_rank();
+
+  // Adjust to thread block and thread
+  const int batch_idx = blockIdx.z;
+  const int head_idx = blockIdx.x;
+  const int kv_head_idx = head_idx / params.gqa_factor;
+
+  const int q_seq_idx = blockIdx.y;
+  const int kv_seq_idx = warp_idx;
+
+  Q += batch_idx * params.Q_strides[0] + // Batch
+      head_idx * params.Q_strides[1] + // Head
+      q_seq_idx * params.Q_strides[2]; // Sequence
+
+  K += batch_idx * params.K_strides[0] + // Batch
+      kv_head_idx * params.K_strides[1] + // Head
+      kv_seq_idx * params.K_strides[2]; // Sequence
+
+  V += batch_idx * params.V_strides[0] + // Batch
+      kv_head_idx * params.V_strides[1] + // Head
+      kv_seq_idx * params.V_strides[2]; // Sequence
+
+  O += batch_idx * params.O_strides[0] + // Batch
+      head_idx * params.O_strides[1] + // Head
+      q_seq_idx * params.O_strides[2]; // Sequence
+
+  // Read the query and 0 the output accumulator
+  PRAGMA_LOOP_UNROLL
+  for (int i = 0; i < v_per_thread; i++) {
+    q[i] = scale_log2 * static_cast<U>(Q[v_per_thread * lane_idx + i]);
+  }
+
+  PRAGMA_LOOP_UNROLL
+  for (int i = 0; i < v_per_thread; i++) {
+    o[i] = 0.f;
+  }
+
+  U max_score = Limits<U>::finite_min();
+  U sum_exp_score = 0.f;
+  if (sinks && warp_idx == 0) {
+    max_score = M_LOG2E * static_cast<U>(sinks[head_idx]);
+    sum_exp_score = 1.f;
+  }
+
+  // For each key
+  for (int i = kv_seq_idx; i < params.kL; i += BN) {
+    bool use_key = true;
+    if constexpr (do_causal) {
+      use_key = i <= (params.kL - params.qL + q_seq_idx);
+    }
+
+    if (use_key) {
+      // Read the key
+      PRAGMA_LOOP_UNROLL
+      for (int j = 0; j < v_per_thread; j++) {
+        k[j] = K[v_per_thread * lane_idx + j];
+      }
+
+      // Compute the i-th score
+      U score = 0.f;
+      PRAGMA_LOOP_UNROLL
+      for (int j = 0; j < v_per_thread; j++) {
+        score += q[j] * k[j];
+      }
+
+      // Warp sum
+      score = cg::reduce(warp, score, cg::plus<U>());
+
+      // Update the accumulators
+      U new_max = max(max_score, score);
+      U factor = exp2f(max_score - new_max);
+      U exp_score = exp2f(score - new_max);
+
+      max_score = new_max;
+      sum_exp_score = sum_exp_score * factor + exp_score;
+
+      // Update the output accumulator
+      PRAGMA_LOOP_UNROLL
+      for (int j = 0; j < v_per_thread; j++) {
+        o[j] = o[j] * factor +
+            exp_score * static_cast<U>(V[v_per_thread * lane_idx + j]);
+      }
+    }
+
+    // Move the pointers to the next kv
+    K += inner_k_stride;
+    V += inner_v_stride;
+  }
+
+  if (lane_idx == 0) {
+    max_scores[warp_idx] = max_score;
+    sum_exp_scores[warp_idx] = sum_exp_score;
+  }
+  block.sync();
+
+  max_score = max_scores[lane_idx];
+  U new_max = cg::reduce(warp, max_score, cg::greater<U>());
+  U factor = exp2f(max_score - new_max);
+  sum_exp_score =
+      cg::reduce(warp, sum_exp_scores[lane_idx] * factor, cg::plus<U>());
+  sum_exp_score = sum_exp_score == 0 ? 0 : __frcp_rn(sum_exp_score);
+
+  // Now we need to aggregate all the outputs
+  PRAGMA_LOOP_UNROLL
+  for (int i = 0; i < v_per_thread; i++) {
+    outputs[lane_idx][warp_idx] = o[i];
+    block.sync();
+    U ot = outputs[warp_idx][lane_idx] * factor;
+    o[i] = cg::reduce(warp, ot, cg::plus<U>()) * sum_exp_score;
+    block.sync();
+  }
+
+  // And write the output
+  if (lane_idx == 0) {
+    PRAGMA_LOOP_UNROLL
+    for (int i = 0; i < v_per_thread; i++) {
+      O[v_per_thread * warp_idx + i] = static_cast<T>(o[i]);
+    }
+  }
+}
+
+template <typename T, bool do_causal, int D>
+__global__ void kernel_sdpav_2pass_1(
+    const T* Q,
+    const T* K,
+    const T* V,
+    const T* sinks,
+    float* partials,
+    float* sums,
+    float* maxs,
+    __grid_constant__ const AttnParams params) {
+  constexpr int BN = 8;
+  constexpr int BD = 32;
+  constexpr int blocks = 32;
+
+  constexpr int v_per_thread = D / BD;
+
+  const int inner_k_stride = blocks * BN * int(params.K_strides[2]);
+  const int inner_v_stride = blocks * BN * int(params.V_strides[2]);
+
+  typedef float U;
+
+  U q[v_per_thread];
+  U k[v_per_thread];
+  U o[v_per_thread];
+
+  __shared__ U outputs[BN][BD + 1];
+  __shared__ U max_scores[BN];
+  __shared__ U sum_exp_scores[BN];
+
+  const U scale_log2 = params.scale * 1.44269504089f;
+
+  auto block = cg::this_thread_block();
+  auto warp = cg::tiled_partition<32>(block);
+
+  const int lane_idx = warp.thread_rank();
+  const int warp_idx = warp.meta_group_rank();
+
+  // Adjust to thread block and thread
+  const int batch_idx = blockIdx.z / blocks;
+  const int block_idx = blockIdx.z % blocks;
+  const int head_idx = blockIdx.x;
+  const int kv_head_idx = head_idx / params.gqa_factor;
+
+  const int q_seq_idx = blockIdx.y;
+  const int kv_seq_idx = block_idx * BN + warp_idx;
+
+  Q += batch_idx * params.Q_strides[0] + // Batch
+      head_idx * params.Q_strides[1] + // Head
+      q_seq_idx * params.Q_strides[2]; // Sequence
+
+  K += batch_idx * params.K_strides[0] + // Batch
+      kv_head_idx * params.K_strides[1] + // Head
+      kv_seq_idx * params.K_strides[2]; // Sequence
+
+  V += batch_idx * params.V_strides[0] + // Batch
+      kv_head_idx * params.V_strides[1] + // Head
+      kv_seq_idx * params.V_strides[2]; // Sequence
+
+  const int p_stride_s = blocks;
+  const int p_stride_h = params.qL * p_stride_s;
+  const int p_stride_b = params.H * p_stride_h;
+  const int p_offset = batch_idx * p_stride_b + // Batch
+      head_idx * p_stride_h + // Head
+      q_seq_idx * p_stride_s + // Sequence
+      block_idx; // Block
+
+  partials += p_offset * D;
+  sums += p_offset;
+  maxs += p_offset;
+
+  // Read the query and 0 the output accumulator
+  PRAGMA_LOOP_UNROLL
+  for (int i = 0; i < v_per_thread; i++) {
+    q[i] = scale_log2 * static_cast<U>(Q[v_per_thread * lane_idx + i]);
+  }
+
+  PRAGMA_LOOP_UNROLL
+  for (int i = 0; i < v_per_thread; i++) {
+    o[i] = 0.f;
+  }
+
+  U max_score = Limits<U>::finite_min();
+  U sum_exp_score = 0.f;
+  if (sinks && warp_idx == 0 && block_idx == 0) {
+    max_score = M_LOG2E * static_cast<U>(sinks[head_idx]);
+    sum_exp_score = 1.f;
+  }
+
+  // For each key
+  for (int i = kv_seq_idx; i < params.kL; i += blocks * BN) {
+    bool use_key = true;
+    if constexpr (do_causal) {
+      use_key = i <= (params.kL - params.qL + q_seq_idx);
+    }
+
+    if (use_key) {
+      // Read the key
+      PRAGMA_LOOP_UNROLL
+      for (int j = 0; j < v_per_thread; j++) {
+        k[j] = K[v_per_thread * lane_idx + j];
+      }
+
+      // Compute the i-th score
+      U score = 0.f;
+      PRAGMA_LOOP_UNROLL
+      for (int j = 0; j < v_per_thread; j++) {
+        score += q[j] * k[j];
+      }
+
+      // Warp sum
+      score = cg::reduce(warp, score, cg::plus<U>());
+
+      // Update the accumulators
+      U new_max = max(max_score, score);
+      U factor = exp2f(max_score - new_max);
+      U exp_score = exp2f(score - new_max);
+
+      max_score = new_max;
+      sum_exp_score = sum_exp_score * factor + exp_score;
+
+      // Update the output accumulator
+      PRAGMA_LOOP_UNROLL
+      for (int j = 0; j < v_per_thread; j++) {
+        o[j] = o[j] * factor +
+            exp_score * static_cast<U>(V[v_per_thread * lane_idx + j]);
+      }
+    }
+
+    // Move the pointers to the next kv
+    K += inner_k_stride;
+    V += inner_v_stride;
+  }
+
+  if (lane_idx == 0) {
+    max_scores[warp_idx] = max_score;
+    sum_exp_scores[warp_idx] = sum_exp_score;
+  }
+
+  block.sync();
+
+  max_score = (lane_idx < BN) ? max_scores[lane_idx] : -1e9;
+  U new_max = cg::reduce(warp, max_score, cg::greater<U>());
+  U factor = exp2f(max_score - new_max);
+  sum_exp_score = (lane_idx < BN) ? sum_exp_scores[lane_idx] : 0.f;
+  sum_exp_score = cg::reduce(warp, sum_exp_score * factor, cg::plus<U>());
+
+  // Write the sum and new max
+  if (warp_idx == 0) {
+    sums[0] = sum_exp_score;
+    maxs[0] = new_max;
+  }
+
+  // Now we need to aggregate all the outputs
+  auto ff = exp2f(max_scores[warp_idx] - new_max);
+  PRAGMA_LOOP_UNROLL
+  for (int i = 0; i < v_per_thread; i++) {
+    outputs[warp_idx][lane_idx] = o[i] * ff;
+    block.sync();
+
+    if (warp_idx == 0) {
+      U ot = outputs[0][lane_idx];
+      PRAGMA_LOOP_UNROLL
+      for (int j = 1; j < BN; j++) {
+        ot += outputs[j][lane_idx];
+        warp.sync();
+      }
+      o[i] = ot;
+    }
+    block.sync();
+  }
+
+  if (warp_idx == 0) {
+    PRAGMA_LOOP_UNROLL
+    for (int i = 0; i < v_per_thread; i++) {
+      partials[v_per_thread * lane_idx + i] = o[i];
+    }
+  }
+}
+
+template <typename T, bool do_causal, int D>
+__global__ void kernel_sdpav_2pass_2(
+    const float* partials,
+    const float* sums,
+    const float* maxs,
+    T* O,
+    __grid_constant__ const AttnParams params) {
+  constexpr int BN = 32;
+  constexpr int BD = 32;
+  constexpr int blocks = 32;
+
+  constexpr int v_per_thread = D / BD;
+
+  typedef float U;
+
+  U o[v_per_thread];
+  __shared__ U outputs[BN][BD + 1];
+
+  auto block = cg::this_thread_block();
+  auto warp = cg::tiled_partition<32>(block);
+
+  const int lane_idx = warp.thread_rank();
+  const int warp_idx = warp.meta_group_rank();
+
+  // Adjust to thread block and thread
+  const int batch_idx = blockIdx.z;
+  const int head_idx = blockIdx.x;
+  const int q_seq_idx = blockIdx.y;
+
+  const int p_stride_s = blocks;
+  const int p_stride_h = params.qL * p_stride_s;
+  const int p_stride_b = params.H * p_stride_h;
+  const int p_offset = batch_idx * p_stride_b + // Batch
+      head_idx * p_stride_h + // Head
+      q_seq_idx * p_stride_s; // Sequence
+
+  partials += p_offset * D + warp_idx * D;
+  sums += p_offset;
+  maxs += p_offset;
+
+  O += batch_idx * params.O_strides[0] + // Batch
+      head_idx * params.O_strides[1] + // Head
+      q_seq_idx * params.O_strides[2]; // Sequence
+
+  U max_score = maxs[lane_idx];
+  U new_max = cg::reduce(warp, max_score, cg::greater<U>());
+  U factor = exp2f(max_score - new_max);
+  U sum_exp_score = cg::reduce(warp, sums[lane_idx] * factor, cg::plus<U>());
+  sum_exp_score = sum_exp_score == 0 ? 0 : __frcp_rn(sum_exp_score);
+
+  PRAGMA_LOOP_UNROLL
+  for (int i = 0; i < v_per_thread; i++) {
+    o[i] = partials[v_per_thread * lane_idx + i];
+  }
+
+  // Now we need to aggregate all the outputs
+  PRAGMA_LOOP_UNROLL
+  for (int i = 0; i < v_per_thread; i++) {
+    outputs[lane_idx][warp_idx] = o[i];
+    block.sync();
+    U ot = outputs[warp_idx][lane_idx] * factor;
+    o[i] = cg::reduce(warp, ot, cg::plus<U>()) * sum_exp_score;
+    block.sync();
+  }
+
+  // And write the output
+  if (lane_idx == 0) {
+    PRAGMA_LOOP_UNROLL
+    for (int i = 0; i < v_per_thread; i++) {
+      O[v_per_thread * warp_idx + i] = static_cast<T>(o[i]);
+    }
+  }
+}
+
+} // namespace cu
+
+namespace {
+
+template <typename F>
+void dispatch_headdim(int n, F&& f) {
+  switch (n) {
+    case 64:
+      f(std::integral_constant<int, 64>{});
+      break;
+    case 96:
+      f(std::integral_constant<int, 96>{});
+      break;
+    case 128:
+      f(std::integral_constant<int, 128>{});
+      break;
+  }
+}
+
+void sdpa_vector_1pass_fallback(
+    const Stream& s,
+    cu::CommandEncoder& encoder,
+    const array& q,
+    const array& k,
+    const array& v,
+    const float scale,
+    array& o,
+    bool do_causal,
+    const std::optional<array>& sinks) {
+  encoder.set_input_array(q);
+  encoder.set_input_array(k);
+  encoder.set_input_array(v);
+  if (sinks) {
+    encoder.set_input_array(*sinks);
+  }
+  encoder.set_output_array(o);
+
+  cu::AttnParams params{
+      /* int B = */ q.shape(0),
+      /* int H = */ q.shape(1),
+      /* int D = */ q.shape(3),
+
+      /* int qL = */ q.shape(2),
+      /* int kL = */ k.shape(2),
+
+      /* int gqa_factor = */ q.shape(1) / k.shape(1),
+      /* float scale = */ scale,
+
+      /* int64_t Q_strides[3] = */ {q.strides(0), q.strides(1), q.strides(2)},
+      /* int64_t K_strides[3] = */ {k.strides(0), k.strides(1), k.strides(2)},
+      /* int64_t V_strides[3] = */ {v.strides(0), v.strides(1), v.strides(2)},
+      /* int64_t O_strides[3] = */ {o.strides(0), o.strides(1), o.strides(2)}};
+
+  dim3 grid_dim(params.H, params.qL, params.B);
+  dim3 block_dim(1024, 1, 1);
+
+  dispatch_float_types(o.dtype(), "kernel_sdpav_1pass", [&](auto type_tag) {
+    dispatch_bool(do_causal, [&](auto do_causal) {
+      dispatch_headdim(params.D, [&](auto headdim) {
+        using DataType = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+
+        auto kernel =
+            cu::kernel_sdpav_1pass<DataType, do_causal.value, headdim.value>;
+        encoder.add_kernel_node(
+            kernel,
+            grid_dim,
+            block_dim,
+            0,
+            q.data<DataType>(),
+            k.data<DataType>(),
+            v.data<DataType>(),
+            o.data<DataType>(),
+            sinks ? (*sinks).data<DataType>() : nullptr,
+            params);
+      });
+    });
+  });
+}
+
+void sdpa_vector_2pass_fallback(
+    const Stream& s,
+    cu::CommandEncoder& encoder,
+    const array& q,
+    const array& k,
+    const array& v,
+    const float scale,
+    array& o,
+    bool do_causal,
+    const std::optional<array>& sinks) {
+  cu::AttnParams params{
+      /* int B = */ q.shape(0),
+      /* int H = */ q.shape(1),
+      /* int D = */ q.shape(3),
+
+      /* int qL = */ q.shape(2),
+      /* int kL = */ k.shape(2),
+
+      /* int gqa_factor = */ q.shape(1) / k.shape(1),
+      /* float scale = */ scale,
+
+      /* int64_t Q_strides[3] = */ {q.strides(0), q.strides(1), q.strides(2)},
+      /* int64_t K_strides[3] = */ {k.strides(0), k.strides(1), k.strides(2)},
+      /* int64_t V_strides[3] = */ {v.strides(0), v.strides(1), v.strides(2)},
+      /* int64_t O_strides[3] = */ {o.strides(0), o.strides(1), o.strides(2)}};
+
+  // Allocate the intermediates
+  int blocks = 32;
+
+  Shape intermediate_shape;
+  intermediate_shape.reserve(o.ndim() + 1);
+  intermediate_shape.insert(
+      intermediate_shape.end(), o.shape().begin(), o.shape().end() - 1);
+  intermediate_shape.push_back(blocks);
+  intermediate_shape.push_back(o.shape().back());
+
+  array intermediate(intermediate_shape, float32, nullptr, {});
+  intermediate_shape.pop_back();
+  array sums(intermediate_shape, float32, nullptr, {});
+  array maxs(std::move(intermediate_shape), float32, nullptr, {});
+
+  intermediate.set_data(allocator::malloc(intermediate.nbytes()));
+  sums.set_data(allocator::malloc(sums.nbytes()));
+  maxs.set_data(allocator::malloc(maxs.nbytes()));
+
+  encoder.add_temporary(intermediate);
+  encoder.add_temporary(sums);
+  encoder.add_temporary(maxs);
+
+  dispatch_float_types(o.dtype(), "kernel_sdpav_2pass", [&](auto type_tag) {
+    dispatch_bool(do_causal, [&](auto do_causal) {
+      dispatch_headdim(params.D, [&](auto headdim) {
+        using DataType = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+
+        {
+          auto kernel = cu::
+              kernel_sdpav_2pass_1<DataType, do_causal.value, headdim.value>;
+
+          encoder.set_input_array(q);
+          encoder.set_input_array(k);
+          encoder.set_input_array(v);
+          if (sinks) {
+            encoder.set_input_array(*sinks);
+          }
+
+          encoder.set_output_array(intermediate);
+          encoder.set_output_array(sums);
+          encoder.set_output_array(maxs);
+
+          dim3 grid_dim(params.H, params.qL, params.B * 32);
+          dim3 block_dim(8 * 32, 1, 1);
+
+          encoder.add_kernel_node(
+              kernel,
+              grid_dim,
+              block_dim,
+              0,
+              q.data<DataType>(),
+              k.data<DataType>(),
+              v.data<DataType>(),
+              sinks ? (*sinks).data<DataType>() : nullptr,
+              intermediate.data<float>(),
+              sums.data<float>(),
+              maxs.data<float>(),
+              params);
+        }
+
+        {
+          auto kernel = cu::
+              kernel_sdpav_2pass_2<DataType, do_causal.value, headdim.value>;
+
+          encoder.set_input_array(intermediate);
+          encoder.set_input_array(sums);
+          encoder.set_input_array(maxs);
+          encoder.set_output_array(o);
+
+          dim3 grid_dim(params.H, params.qL, params.B);
+          dim3 block_dim(1024, 1, 1);
+
+          encoder.add_kernel_node(
+              kernel,
+              grid_dim,
+              block_dim,
+              0,
+              intermediate.data<float>(),
+              sums.data<float>(),
+              maxs.data<float>(),
+              o.data<DataType>(),
+              params);
+        }
+      });
+    });
+  });
+}
+
+void sdpa_vector_fallback(
+    const Stream& s,
+    cu::CommandEncoder& encoder,
+    const array& q,
+    const array& k,
+    const array& v,
+    const float scale,
+    array& o,
+    bool do_causal,
+    const std::optional<array>& sinks) {
+  int kL = k.shape(2);
+
+  if (kL > 1024) {
+    return sdpa_vector_2pass_fallback(
+        s, encoder, q, k, v, scale, o, do_causal, sinks);
+  } else {
+    return sdpa_vector_1pass_fallback(
+        s, encoder, q, k, v, scale, o, do_causal, sinks);
+  }
+}
+
+} // namespace
+
+namespace fast {
+
+bool ScaledDotProductAttention::use_fallback(
+    const array& q,
+    const array& k,
+    const array& v,
+    bool has_mask,
+    bool has_arr_mask,
+    bool do_causal,
+    Stream s) {
+  if (detail::in_grad_tracing()) {
+    return true;
+  }
+  if (s.device == Device::cpu) {
+    return true;
+  }
+
+  const int value_head_dim = v.shape(-1);
+  const int query_head_dim = q.shape(-1);
+  const int query_sequence_length = q.shape(2);
+  const int key_sequence_length = k.shape(2);
+
+  const bool sdpa_supported_head_dim = query_head_dim == value_head_dim &&
+      (query_head_dim == 64 || query_head_dim == 96 || query_head_dim == 128);
+
+  const bool supported_vector_config =
+      sdpa_supported_head_dim && query_sequence_length < 4;
+
+  const bool supported_config = supported_vector_config;
+
+  return has_arr_mask || !supported_config;
+}
+
+void ScaledDotProductAttention::eval_gpu(
+    const std::vector<array>& inputs,
+    array& out) {
+  nvtx3::scoped_range r("ScaledDotProductAttention::eval_gpu");
+
+  auto& s = stream();
+  auto& encoder = cu::get_command_encoder(s);
+
+  auto& q_pre = inputs[0];
+  auto& k_pre = inputs[1];
+  auto& v_pre = inputs[2];
+  auto& o = out;
+
+  std::vector<array> copies;
+
+  // Define some copy functions to ensure the layout of the inputs is as
+  // expected.
+  copies.reserve(inputs.size());
+  auto copy_unless = [&copies, &s](
+                         auto predicate, const array& arr) -> const array& {
+    if (!predicate(arr)) {
+      array arr_copy = contiguous_copy_gpu(arr, s);
+      copies.push_back(std::move(arr_copy));
+      return copies.back();
+    } else {
+      return arr;
+    }
+  };
+
+  // Checks that the headdim dimension has stride 1.
+  auto is_matrix_contiguous = [](const array& arr) {
+    return arr.strides(-1) == 1;
+  };
+
+  std::optional<array> sinks = std::nullopt;
+  if (has_sinks_) {
+    sinks = copy_unless(is_matrix_contiguous, inputs.back());
+  }
+
+  // We are in vector mode ie single query
+  if (q_pre.shape(2) < 4) {
+    auto q_copy_unless = [](const array& arr) {
+      if (arr.flags().row_contiguous) {
+        return true;
+      }
+      auto& strides = arr.strides();
+      auto& shape = arr.shape();
+      if (shape[0] == 1 || shape[1] == 1) {
+        // If either the batch or head dimension is a singleton, the other can
+        // be transposed with the sequence dimension
+        auto bidx = shape[0] == 1 ? 1 : 0;
+        return (strides[3] == 1) && (strides[2] == shape[3] * shape[bidx]) &&
+            (strides[bidx] == shape[3]);
+      }
+      return false;
+    };
+
+    auto kv_copy_unless = [](const array& arr) {
+      // keys and values should be copied if:
+      // - the last dimension is not contiguous
+      // - the batch and head dim are not contiguous
+      auto& strides = arr.strides();
+      auto& shape = arr.shape();
+      if (strides.back() != 1) {
+        return false;
+      }
+      if (shape[0] == 1 || shape[1] == 1) {
+        return true;
+      }
+      return (strides[0] == strides[1] * shape[1]);
+    };
+
+    const auto& q = copy_unless(q_copy_unless, q_pre);
+    const auto& k = copy_unless(kv_copy_unless, k_pre);
+    const auto& v = copy_unless(kv_copy_unless, v_pre);
+
+    // Donate the query if possible
+    if (q.is_donatable() && q.flags().row_contiguous && q.size() == o.size()) {
+      o.copy_shared_buffer(q);
+    } else {
+      int64_t str_oD = 1;
+      int64_t str_oH = o.shape(3);
+      int64_t str_oL = o.shape(1) * str_oH;
+      int64_t str_oB = o.shape(2) * str_oL;
+
+      array::Flags flags{
+          /* bool contiguous = */ 1,
+          /* bool row_contiguous = */ o.shape(2) == 1,
+          /* bool col_contiguous = */ o.size() == o.shape(3),
+      };
+
+      o.set_data(
+          allocator::malloc(o.nbytes()),
+          o.size(),
+          {str_oB, str_oH, str_oL, str_oD},
+          flags);
+    }
+
+    for (const auto& cp : copies) {
+      encoder.add_temporary(cp);
+    }
+
+    return sdpa_vector_fallback(
+        s, encoder, q, k, v, scale_, o, do_causal_, sinks);
+  }
+
+  // Full attention mode should never reach here
+  else {
+    throw std::runtime_error("Doesn't support matrix yet.");
+  }
+}
+
+} // namespace fast
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/scan.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/scan.cu
new file mode 100644
index 0000000000000000000000000000000000000000..56d4ae27541fb308d80c724a6b6550b63b928d64
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/scan.cu
@@ -0,0 +1,467 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/device/binary_ops.cuh"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/backend/cuda/reduce/reduce_ops.cuh"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+#include <cooperative_groups.h>
+#include <cooperative_groups/scan.h>
+#include <nvtx3/nvtx3.hpp>
+
+#include <cassert>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename Op, typename T>
+struct ScanResult {
+  using type = T;
+};
+
+template <>
+struct ScanResult<Sum, bool> {
+  using type = int32_t;
+};
+
+template <typename T>
+struct ReduceInit<LogAddExp, T> {
+  static constexpr __host__ __device__ T value() {
+    return Limits<T>::min();
+  }
+};
+
+template <bool reverse, typename T, typename U, int N_READS>
+inline __device__ void
+load_values(int index, const T* in, U (&values)[N_READS], int size, U init) {
+  int remaining = size - index * N_READS;
+  if constexpr (reverse) {
+    in += remaining - N_READS;
+    if (remaining < N_READS) {
+      for (int i = 0; i < N_READS; ++i) {
+        values[N_READS - i - 1] =
+            (N_READS - i - 1 < remaining) ? cast_to<U>(in[i]) : init;
+      }
+    } else {
+      for (int i = 0; i < N_READS; ++i) {
+        values[N_READS - i - 1] = cast_to<U>(in[i]);
+      }
+    }
+  } else {
+    in += index * N_READS;
+    if (remaining < N_READS) {
+      for (int i = 0; i < N_READS; ++i) {
+        values[i] = (i < remaining) ? cast_to<U>(in[i]) : init;
+      }
+    } else {
+      for (int i = 0; i < N_READS; ++i) {
+        values[i] = cast_to<U>(in[i]);
+      }
+    }
+  }
+}
+
+template <bool reverse, int offset, typename T, int N_READS>
+inline __device__ void
+store_values(int index, T* out, T (&values)[N_READS], int size) {
+  int start = index * N_READS + offset;
+  int remaining = size - start;
+  if constexpr (reverse) {
+    out += remaining - N_READS;
+    if (remaining < N_READS) {
+      for (int i = 0; i < N_READS; ++i) {
+        if (N_READS - i - 1 < remaining) {
+          out[i] = values[N_READS - i - 1];
+        }
+      }
+    } else {
+      for (int i = 0; i < N_READS; ++i) {
+        out[i] = values[N_READS - i - 1];
+      }
+    }
+  } else {
+    out += start;
+    if (remaining < N_READS) {
+      for (int i = 0; i < N_READS; ++i) {
+        if (i < remaining) {
+          out[i] = values[i];
+        }
+      }
+    } else {
+      for (int i = 0; i < N_READS; ++i) {
+        out[i] = values[i];
+      }
+    }
+  }
+}
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    int N_READS,
+    bool inclusive,
+    bool reverse>
+__global__ void contiguous_scan(const T* in, U* out, int32_t axis_size) {
+  auto grid = cg::this_grid();
+  auto block = cg::this_thread_block();
+  auto warp = cg::tiled_partition<WARP_SIZE>(block);
+
+  in += grid.block_rank() * axis_size;
+  out += grid.block_rank() * axis_size;
+
+  __shared__ U warp_sums[WARP_SIZE];
+
+  Op op;
+  U init = ReduceInit<Op, T>::value();
+  U prefix = init;
+
+  // Scan per block.
+  for (int r = 0; r < cuda::ceil_div(axis_size, block.size() * N_READS); ++r) {
+    int32_t index = r * block.size() + block.thread_rank();
+    U values[N_READS];
+    load_values<reverse>(index, in, values, axis_size, init);
+
+    // Compute an inclusive scan per thread.
+    for (int i = 1; i < N_READS; ++i) {
+      values[i] = op(values[i], values[i - 1]);
+    }
+
+    // Compute exclusive scan of thread sums.
+    U prev_thread_sum = cg::exclusive_scan(warp, values[N_READS - 1], op);
+    if (warp.thread_rank() == 0) {
+      prev_thread_sum = init;
+    }
+
+    // Write wrap's sum to shared memory.
+    if (warp.thread_rank() == WARP_SIZE - 1) {
+      warp_sums[warp.meta_group_rank()] =
+          op(prev_thread_sum, values[N_READS - 1]);
+    }
+    block.sync();
+
+    // Compute exclusive scan of warp sums.
+    if (warp.meta_group_rank() == 0) {
+      U prev_warp_sum =
+          cg::exclusive_scan(warp, warp_sums[warp.thread_rank()], op);
+      if (warp.thread_rank() == 0) {
+        prev_warp_sum = init;
+      }
+      warp_sums[warp.thread_rank()] = prev_warp_sum;
+    }
+    block.sync();
+
+    // Compute the output.
+    for (int i = 0; i < N_READS; ++i) {
+      values[i] = op(values[i], prefix);
+      values[i] = op(values[i], warp_sums[warp.meta_group_rank()]);
+      values[i] = op(values[i], prev_thread_sum);
+    }
+
+    // Write the values.
+    if (inclusive) {
+      store_values<reverse, 0>(index, out, values, axis_size);
+    } else {
+      store_values<reverse, 1>(index, out, values, axis_size);
+      if (reverse) {
+        if (block.thread_rank() == 0 && index == 0) {
+          out[axis_size - 1] = init;
+        }
+      } else {
+        if (block.thread_rank() == 0 && index == 0) {
+          out[0] = init;
+        }
+      }
+    }
+    block.sync();
+
+    // Share the prefix.
+    if ((warp.meta_group_rank() == warp.meta_group_size() - 1) &&
+        (warp.thread_rank() == WARP_SIZE - 1)) {
+      warp_sums[0] = values[N_READS - 1];
+    }
+    block.sync();
+    prefix = warp_sums[0];
+  }
+}
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    int N_READS,
+    int BM,
+    int BN,
+    bool inclusive,
+    bool reverse>
+__global__ void strided_scan(
+    const T* in,
+    U* out,
+    int32_t axis_size,
+    int64_t stride,
+    int64_t stride_blocks) {
+  auto grid = cg::this_grid();
+  auto block = cg::this_thread_block();
+  auto warp = cg::tiled_partition<WARP_SIZE>(block);
+
+  constexpr int BN_pad = WARP_SIZE + 16 / sizeof(U);
+  constexpr int n_warps = BN / N_READS;
+  constexpr int n_scans = BN / n_warps;
+
+  __shared__ U read_buffer[BM * BN_pad];
+
+  Op op;
+  U init = ReduceInit<Op, T>::value();
+  U values[n_scans];
+  U prefix[n_scans];
+  for (int i = 0; i < n_scans; ++i) {
+    prefix[i] = init;
+  }
+
+  // Compute offsets.
+  int64_t offset = (grid.block_rank() / stride_blocks) * axis_size * stride;
+  int64_t global_index_x = (grid.block_rank() % stride_blocks) * BN;
+  uint read_offset_y = (block.thread_rank() * N_READS) / BN;
+  uint read_offset_x = (block.thread_rank() * N_READS) % BN;
+  uint scan_offset_y = warp.thread_rank();
+  uint scan_offset_x = warp.meta_group_rank() * n_scans;
+
+  uint stride_limit = stride - global_index_x;
+  in += offset + global_index_x + read_offset_x;
+  out += offset + global_index_x + read_offset_x;
+  U* read_into = read_buffer + read_offset_y * BN_pad + read_offset_x;
+  U* read_from = read_buffer + scan_offset_y * BN_pad + scan_offset_x;
+
+  for (uint j = 0; j < axis_size; j += BM) {
+    // Calculate the indices for the current thread.
+    uint index_y = j + read_offset_y;
+    uint check_index_y = index_y;
+    if (reverse) {
+      index_y = axis_size - 1 - index_y;
+    }
+
+    // Read in SM.
+    if (check_index_y < axis_size && (read_offset_x + N_READS) < stride_limit) {
+      for (int i = 0; i < N_READS; ++i) {
+        read_into[i] = in[index_y * stride + i];
+      }
+    } else {
+      for (int i = 0; i < N_READS; ++i) {
+        if (check_index_y < axis_size && (read_offset_x + i) < stride_limit) {
+          read_into[i] = in[index_y * stride + i];
+        } else {
+          read_into[i] = init;
+        }
+      }
+    }
+    block.sync();
+
+    // Read strided into registers.
+    for (int i = 0; i < n_scans; ++i) {
+      values[i] = read_from[i];
+    }
+
+    // Perform the scan.
+    for (int i = 0; i < n_scans; ++i) {
+      values[i] = cg::inclusive_scan(warp, values[i], op);
+      values[i] = op(values[i], prefix[i]);
+      prefix[i] = warp.shfl(values[i], WARP_SIZE - 1);
+    }
+
+    // Write to SM.
+    for (int i = 0; i < n_scans; ++i) {
+      read_from[i] = values[i];
+    }
+    block.sync();
+
+    // Write to device memory.
+    if (!inclusive) {
+      if (check_index_y == 0) {
+        if ((read_offset_x + N_READS) < stride_limit) {
+          for (int i = 0; i < N_READS; ++i) {
+            out[index_y * stride + i] = init;
+          }
+        } else {
+          for (int i = 0; i < N_READS; ++i) {
+            if ((read_offset_x + i) < stride_limit) {
+              out[index_y * stride + i] = init;
+            }
+          }
+        }
+      }
+      if (reverse) {
+        index_y -= 1;
+        check_index_y += 1;
+      } else {
+        index_y += 1;
+        check_index_y += 1;
+      }
+    }
+    if (check_index_y < axis_size && (read_offset_x + N_READS) < stride_limit) {
+      for (int i = 0; i < N_READS; ++i) {
+        out[index_y * stride + i] = read_into[i];
+      }
+    } else {
+      for (int i = 0; i < N_READS; ++i) {
+        if (check_index_y < axis_size && (read_offset_x + i) < stride_limit) {
+          out[index_y * stride + i] = read_into[i];
+        }
+      }
+    }
+  }
+}
+
+} // namespace cu
+
+template <typename F>
+void dispatch_scan_ops(Scan::ReduceType scan_op, F&& f) {
+  if (scan_op == Scan::ReduceType::Max) {
+    f(type_identity<cu::Max>{});
+  } else if (scan_op == Scan::ReduceType::Min) {
+    f(type_identity<cu::Min>{});
+  } else if (scan_op == Scan::ReduceType::Sum) {
+    f(type_identity<cu::Sum>{});
+  } else if (scan_op == Scan::ReduceType::Prod) {
+    f(type_identity<cu::Prod>{});
+  } else if (scan_op == Scan::ReduceType::LogAddExp) {
+    f(type_identity<cu::LogAddExp>{});
+  } else {
+    throw std::invalid_argument("Unknown reduce type.");
+  }
+}
+
+template <typename Op>
+const char* op_to_string() {
+  if (cuda::std::is_same_v<Op, cu::Max>) {
+    return "Max";
+  } else if (cuda::std::is_same_v<Op, cu::Min>) {
+    return "Min";
+  } else if (cuda::std::is_same_v<Op, cu::Sum>) {
+    return "Sum";
+  } else if (cuda::std::is_same_v<Op, cu::Prod>) {
+    return "Prod";
+  } else if (cuda::std::is_same_v<Op, cu::LogAddExp>) {
+    return "LogAddExp";
+  } else {
+    throw std::invalid_argument("Unknown op.");
+  }
+}
+
+template <typename Op, typename T>
+constexpr bool supports_scan_op() {
+  if constexpr (cuda::std::is_same_v<Op, LogAddExp>) {
+    return is_inexact_v<T>;
+  } else {
+    return true;
+  }
+}
+
+void Scan::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Scan::eval_gpu");
+  assert(inputs.size() == 1);
+  auto in = inputs[0];
+  auto& s = stream();
+
+  if (in.flags().contiguous && in.strides()[axis_] != 0) {
+    if (in.is_donatable() && in.itemsize() == out.itemsize()) {
+      out.copy_shared_buffer(in);
+    } else {
+      out.set_data(
+          allocator::malloc(in.data_size() * out.itemsize()),
+          in.data_size(),
+          in.strides(),
+          in.flags());
+    }
+  } else {
+    in = contiguous_copy_gpu(in, s);
+    out.copy_shared_buffer(in);
+  }
+
+  constexpr int N_READS = 4;
+  int32_t axis_size = in.shape(axis_);
+  bool contiguous = in.strides()[axis_] == 1;
+
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+
+  dispatch_all_types(in.dtype(), [&](auto type_tag) {
+    using T = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+    dispatch_scan_ops(reduce_type_, [&](auto scan_op_tag) {
+      using Op = MLX_GET_TYPE(scan_op_tag);
+      if constexpr (supports_scan_op<Op, T>) {
+        using U = typename cu::ScanResult<Op, T>::type;
+        dispatch_bool(inclusive_, [&](auto inclusive) {
+          dispatch_bool(reverse_, [&](auto reverse) {
+            if (contiguous) {
+              auto kernel = cu::contiguous_scan<
+                  T,
+                  U,
+                  Op,
+                  N_READS,
+                  inclusive.value,
+                  reverse.value>;
+              int block_dim = cuda::ceil_div(axis_size, N_READS);
+              block_dim = cuda::ceil_div(block_dim, WARP_SIZE) * WARP_SIZE;
+              block_dim = std::min(block_dim, WARP_SIZE * WARP_SIZE);
+              encoder.add_kernel_node(
+                  kernel,
+                  in.data_size() / axis_size,
+                  block_dim,
+                  0,
+                  in.data<T>(),
+                  out.data<U>(),
+                  axis_size);
+            } else {
+              constexpr int BM = WARP_SIZE;
+              constexpr int BN = WARP_SIZE;
+              auto kernel = cu::strided_scan<
+                  T,
+                  U,
+                  Op,
+                  N_READS,
+                  BM,
+                  BN,
+                  inclusive.value,
+                  reverse.value>;
+              int64_t stride = in.strides()[axis_];
+              int64_t stride_blocks = cuda::ceil_div(stride, BN);
+              dim3 num_blocks = get_2d_grid_dims(
+                  in.shape(), in.strides(), axis_size * stride);
+              if (num_blocks.x * stride_blocks <= UINT32_MAX) {
+                num_blocks.x *= stride_blocks;
+              } else {
+                num_blocks.y *= stride_blocks;
+              }
+              int block_dim = (BN / N_READS) * WARP_SIZE;
+              encoder.add_kernel_node(
+                  kernel,
+                  num_blocks,
+                  block_dim,
+                  0,
+                  in.data<T>(),
+                  out.data<U>(),
+                  axis_size,
+                  stride,
+                  stride_blocks);
+            }
+          });
+        });
+      } else {
+        throw std::runtime_error(fmt::format(
+            "Can not do scan op {} on inputs of {} with result of {}.",
+            op_to_string<Op>(),
+            dtype_to_string(in.dtype()),
+            dtype_to_string(out.dtype())));
+      }
+    });
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/slicing.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/slicing.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..93241936b3e6978f0f245f5c63074141c0dd55dc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/slicing.cpp
@@ -0,0 +1,110 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/slicing.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/jit_module.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/gpu/slicing.h"
+#include "mlx/dtype_utils.h"
+
+#include <numeric>
+
+namespace mlx::core {
+
+void concatenate_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    int axis,
+    const Stream& s) {
+  std::vector<int> sizes;
+  sizes.push_back(0);
+  for (auto& p : inputs) {
+    sizes.push_back(p.shape(axis));
+  }
+  std::partial_sum(sizes.cbegin(), sizes.cend(), sizes.begin());
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto strides = out.strides();
+  auto flags = out.flags();
+  flags.row_contiguous = false;
+  flags.col_contiguous = false;
+  flags.contiguous = false;
+  auto concurrent = cu::get_command_encoder(s).concurrent_context();
+  for (int i = 0; i < inputs.size(); i++) {
+    array out_slice(inputs[i].shape(), out.dtype(), nullptr, {});
+    size_t data_offset = strides[axis] * sizes[i];
+    out_slice.copy_shared_buffer(
+        out, strides, flags, out_slice.size(), data_offset);
+    copy_gpu_inplace(inputs[i], out_slice, CopyType::GeneralGeneral, s);
+  }
+}
+
+array compute_dynamic_offset(
+    const array& indices,
+    const Strides& strides,
+    const std::vector<int>& axes,
+    const Stream& s) {
+  Dtype dtype = indices.dtype();
+  int nidx = axes.size();
+
+  std::string module_name =
+      fmt::format("compute_dynamic_offset_{}_{}", dtype_to_string(dtype), nidx);
+  std::string kernel_name = fmt::format(
+      "mlx::core::cu::compute_dynamic_offset<{}, {}>",
+      dtype_to_cuda_type(dtype),
+      nidx);
+
+  cu::JitModule& mod = cu::get_jit_module(s.device, module_name, [&]() {
+    std::string source = R"(
+        #include "mlx/backend/cuda/device/utils.cuh"
+
+        namespace mlx::core::cu {
+
+        template <typename T, int NIDX>
+        __global__ void compute_dynamic_offset(
+            const T* indices,
+            int64_t* offset,
+            const __grid_constant__ Strides strides,
+            const __grid_constant__ cuda::std::array<int, NIDX> axes) {
+          int64_t acc = 0;
+          #pragma unroll
+          for (int i = 0; i < NIDX; ++i) {
+            acc += indices[i] * strides[axes[i]];
+          }
+          *offset = acc;
+        }
+
+        } // namespace mlx::core::cu
+    )";
+    return std::make_tuple(false, std::move(source), std::vector{kernel_name});
+  });
+
+  // Prepare output.
+  array offset({1}, int64, nullptr, {});
+  bool donate = indices.is_donatable() &&
+      (indices.data_size() * indices.itemsize()) >= offset.itemsize();
+  if (donate) {
+    offset.copy_shared_buffer(indices);
+  } else {
+    offset.set_data(allocator::malloc(offset.itemsize()));
+  }
+
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.add_temporary(offset);
+  encoder.set_input_array(indices);
+  encoder.set_output_array(offset);
+
+  cu::KernelArgs args;
+  args.append(indices);
+  args.append(offset);
+  args.append_ndim(strides);
+  args.append(axes);
+
+  auto kernel = mod.get_kernel(kernel_name);
+  encoder.add_kernel_node(kernel, 1, 1, 0, args.args());
+
+  return offset;
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/softmax.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/softmax.cu
new file mode 100644
index 0000000000000000000000000000000000000000..d808bce382e53ba6707ac1254502632853d0ad69
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/softmax.cu
@@ -0,0 +1,162 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/device/cast_op.cuh"
+#include "mlx/backend/cuda/device/fp16_math.cuh"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+#include <cooperative_groups.h>
+#include <cooperative_groups/reduce.h>
+#include <nvtx3/nvtx3.hpp>
+
+#include <cassert>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename T>
+inline __device__ T softmax_exp(T x) {
+  // Softmax doesn't need high precision exponential cause x is gonna be in
+  // (-oo, 0] anyway and subsequently it will be divided by sum(exp(x_i)).
+  return __expf(x);
+}
+
+template <typename T, typename AccT, int BLOCK_DIM, int N_READS = 4>
+__global__ void softmax(const T* in, T* out, int axis_size) {
+  auto grid = cg::this_grid();
+  auto block = cg::this_thread_block();
+  auto warp = cg::tiled_partition<WARP_SIZE>(block);
+
+  in += grid.block_rank() * axis_size;
+  out += grid.block_rank() * axis_size;
+
+  cg::greater<AccT> max_op;
+  cg::plus<AccT> plus_op;
+
+  // Thread reduce.
+  AccT prevmax;
+  AccT maxval = Limits<AccT>::finite_min();
+  AccT normalizer = cast_to<AccT>(0);
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); r++) {
+    auto index = r * BLOCK_DIM + block.thread_rank();
+    auto vals = load_vector<N_READS>(in, index, axis_size, Limits<T>::min());
+    prevmax = maxval;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      maxval = max_op(maxval, static_cast<AccT>(vals[i]));
+    }
+
+    // Online normalizer calculation for softmax:
+    // https://github.com/NVIDIA/online-softmax
+    normalizer = normalizer * softmax_exp(prevmax - maxval);
+#pragma unroll
+    for (int i = 0; i < N_READS; i++) {
+      normalizer =
+          normalizer + softmax_exp(static_cast<AccT>(vals[i]) - maxval);
+    }
+  }
+
+  // First warp reduce.
+  prevmax = maxval;
+  maxval = cg::reduce(warp, maxval, max_op);
+  normalizer = normalizer * softmax_exp(prevmax - maxval);
+  normalizer = cg::reduce(warp, normalizer, plus_op);
+
+  __shared__ AccT local_max[WARP_SIZE];
+  __shared__ AccT local_normalizer[WARP_SIZE];
+
+  // Write to shared memory and do second warp reduce.
+  prevmax = maxval;
+  if (warp.thread_rank() == 0) {
+    local_max[warp.meta_group_rank()] = maxval;
+  }
+  block.sync();
+  maxval = warp.thread_rank() < warp.meta_group_size()
+      ? local_max[warp.thread_rank()]
+      : Limits<AccT>::min();
+  maxval = cg::reduce(warp, maxval, max_op);
+  normalizer = normalizer * softmax_exp(prevmax - maxval);
+  if (warp.thread_rank() == 0) {
+    local_normalizer[warp.meta_group_rank()] = normalizer;
+  }
+  block.sync();
+  normalizer = warp.thread_rank() < warp.meta_group_size()
+      ? local_normalizer[warp.thread_rank()]
+      : AccT{};
+  normalizer = cg::reduce(warp, normalizer, plus_op);
+  normalizer = 1 / normalizer;
+
+  // Write output.
+  for (int r = 0; r < cuda::ceil_div(axis_size, BLOCK_DIM * N_READS); r++) {
+    auto index = r * BLOCK_DIM + block.thread_rank();
+    auto vals = load_vector<N_READS>(in, index, axis_size, T(0));
+    for (int i = 0; i < N_READS; i++) {
+      vals[i] = softmax_exp(static_cast<AccT>(vals[i]) - maxval) * normalizer;
+    }
+    store_vector<N_READS>(out, index, vals, axis_size);
+  }
+}
+
+} // namespace cu
+
+void Softmax::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Softmax::eval_gpu");
+  assert(inputs.size() == 1);
+  auto& s = stream();
+
+  // Make sure that the last dimension is contiguous.
+  auto set_output = [&s, &out](const array& x) {
+    if (x.flags().contiguous && x.strides()[x.ndim() - 1] == 1) {
+      if (x.is_donatable()) {
+        out.copy_shared_buffer(x);
+      } else {
+        out.set_data(
+            allocator::malloc(x.data_size() * x.itemsize()),
+            x.data_size(),
+            x.strides(),
+            x.flags());
+      }
+      return x;
+    } else {
+      array x_copy = contiguous_copy_gpu(x, s);
+      out.copy_shared_buffer(x_copy);
+      return x_copy;
+    }
+  };
+
+  array in = set_output(inputs[0]);
+  bool precise = in.dtype() != float32 && precise_;
+
+  int axis_size = in.shape().back();
+  int n_rows = in.data_size() / axis_size;
+
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  dispatch_float_types(out.dtype(), "softmax", [&](auto type_tag) {
+    using DataType = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+    constexpr int N_READS = 16 / sizeof(DataType);
+    dispatch_block_dim(cuda::ceil_div(axis_size, N_READS), [&](auto block_dim) {
+      auto kernel = cu::softmax<DataType, DataType, block_dim(), N_READS>;
+      if (precise) {
+        kernel = cu::softmax<DataType, float, block_dim(), N_READS>;
+      }
+      encoder.add_kernel_node(
+          kernel,
+          n_rows,
+          block_dim(),
+          0,
+          in.data<DataType>(),
+          out.data<DataType>(),
+          axis_size);
+    });
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/sort.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/sort.cu
new file mode 100644
index 0000000000000000000000000000000000000000..95a2d263ccc3d5e3e7ac7299e88851e38dae4451
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/sort.cu
@@ -0,0 +1,193 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+#include <nvtx3/nvtx3.hpp>
+#include <thrust/device_ptr.h>
+#include <thrust/transform.h>
+#include <cub/device/device_segmented_radix_sort.cuh>
+
+#include <cassert>
+
+namespace mlx::core {
+
+namespace {
+
+template <typename T>
+struct ModOp {
+  T divisor;
+  __device__ T operator()(T x) {
+    return x % divisor;
+  }
+};
+
+struct OffsetTransform {
+  int nsort;
+
+  int __device__ operator()(int i) {
+    return i * nsort;
+  }
+};
+
+void gpu_sort(const Stream& s, array in, array& out_, int axis, bool argsort) {
+  array out = out_;
+  auto& encoder = cu::get_command_encoder(s);
+  if (axis < 0) {
+    axis += in.ndim();
+  }
+  int nsort = in.shape(axis);
+  int last_dim = in.ndim() - 1;
+
+  // If we are not sorting the innermost dimension of a contiguous array,
+  // transpose and make a copy.
+  bool is_segmented_sort = in.flags().contiguous && in.strides()[axis] == 1;
+  if (!is_segmented_sort) {
+    array trans = swapaxes_in_eval(in, axis, last_dim);
+    in = contiguous_copy_gpu(trans, s);
+    encoder.add_temporary(in);
+    out = array(allocator::malloc(out.nbytes()), in.shape(), out.dtype());
+    encoder.add_temporary(out);
+  } else {
+    out.set_data(
+        allocator::malloc(in.data_size() * out.itemsize()),
+        in.data_size(),
+        in.strides(),
+        in.flags());
+  }
+
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  dispatch_all_types(in.dtype(), [&](auto type_tag) {
+    using CTYPE = MLX_GET_TYPE(type_tag);
+    auto& stream = encoder.stream();
+    if constexpr (!std::is_same_v<CTYPE, complex64_t>) {
+      using Type = cuda_type_t<CTYPE>;
+      auto offsets = thrust::make_transform_iterator(
+          thrust::make_counting_iterator(0), OffsetTransform{nsort});
+      if (argsort) {
+        // Indices in the sorted dimension.
+        array indices(allocator::malloc(out.nbytes()), in.shape(), out.dtype());
+        encoder.add_temporary(indices);
+
+        // In argsort though we don't need the result of sorted values, the
+        // API requires us to provide an array to store it.
+        array discard(allocator::malloc(in.nbytes()), in.shape(), in.dtype());
+        encoder.add_temporary(discard);
+
+        size_t size;
+        CHECK_CUDA_ERROR(cub::DeviceSegmentedRadixSort::SortPairs(
+            nullptr,
+            size,
+            in.data<Type>(),
+            discard.data<Type>(),
+            indices.data<uint32_t>(),
+            out.data<uint32_t>(),
+            in.data_size(),
+            in.data_size() / nsort,
+            offsets,
+            offsets + 1,
+            0,
+            sizeof(Type) * 8,
+            stream));
+
+        array temp(allocator::malloc(size), {static_cast<int>(size)}, uint8);
+        encoder.add_temporary(temp);
+
+        // Start capturing after allocations
+        auto capture = encoder.capture_context();
+        thrust::transform(
+            cu::thrust_policy(stream),
+            thrust::counting_iterator<uint32_t>(0),
+            thrust::counting_iterator<uint32_t>(indices.data_size()),
+            thrust::device_pointer_cast(indices.data<uint32_t>()),
+            ModOp<uint32_t>{static_cast<uint32_t>(nsort)});
+
+        CHECK_CUDA_ERROR(cub::DeviceSegmentedRadixSort::SortPairs(
+            temp.data<void>(),
+            size,
+            in.data<Type>(),
+            discard.data<Type>(),
+            indices.data<uint32_t>(),
+            out.data<uint32_t>(),
+            in.data_size(),
+            in.data_size() / nsort,
+            offsets,
+            offsets + 1,
+            0,
+            sizeof(Type) * 8,
+            stream));
+      } else {
+        size_t size;
+        CHECK_CUDA_ERROR(cub::DeviceSegmentedRadixSort::SortKeys(
+            nullptr,
+            size,
+            in.data<Type>(),
+            out.data<Type>(),
+            in.data_size(),
+            in.data_size() / nsort,
+            offsets,
+            offsets + 1,
+            0,
+            sizeof(Type) * 8,
+            stream));
+
+        array temp(allocator::malloc(size), {static_cast<int>(size)}, uint8);
+        encoder.add_temporary(temp);
+
+        // Start capturing after allocations
+        auto capture = encoder.capture_context();
+        CHECK_CUDA_ERROR(cub::DeviceSegmentedRadixSort::SortKeys(
+            temp.data<void>(),
+            size,
+            in.data<Type>(),
+            out.data<Type>(),
+            in.data_size(),
+            in.data_size() / nsort,
+            offsets,
+            offsets + 1,
+            0,
+            sizeof(Type) * 8,
+            stream));
+      }
+    } else {
+      throw std::runtime_error(
+          "CUDA backend does not support sorting complex numbers");
+    }
+  });
+
+  if (!is_segmented_sort) {
+    // Swap the sorted axis back.
+    // TODO: Do in-place transpose instead of using a temporary out array.
+    copy_gpu(swapaxes_in_eval(out, axis, last_dim), out_, CopyType::General, s);
+  }
+}
+
+} // namespace
+
+void ArgSort::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("ArgSort::eval_gpu");
+  assert(inputs.size() == 1);
+  gpu_sort(stream(), inputs[0], out, axis_, true);
+}
+
+void Sort::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Sort::eval_gpu");
+  assert(inputs.size() == 1);
+  gpu_sort(stream(), inputs[0], out, axis_, false);
+}
+
+void ArgPartition::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("ArgPartition::eval_gpu");
+  gpu_sort(stream(), inputs[0], out, axis_, true);
+}
+
+void Partition::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Partition::eval_gpu");
+  gpu_sort(stream(), inputs[0], out, axis_, false);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/defines.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/defines.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..bf920428fb9da6cf1eb6b58789808247b86acd16
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/defines.cuh
@@ -0,0 +1,9 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#define MLX_UNROLL _Pragma("unroll")
+
+#if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 800)
+#define MLX_CUDA_SM_80_ENABLED
+#endif
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/gemm.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/gemm.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..99580d2def6d83db10c18815b82210602b64f697
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/gemm.cuh
@@ -0,0 +1,101 @@
+
+#include "mlx/backend/cuda/steel/mma.cuh"
+#include "mlx/backend/cuda/steel/tiles.cuh"
+
+namespace mlx::core::cu {
+
+/**
+ * An example gemm written with the utils.
+ *
+ * Computes A @ B.T when A and B are all aligned with the block sizes.
+ */
+template <typename T, int BM, int BN, int BK>
+__global__ void ab_t_aligned(const T* a, const T* b, T* y, int N, int K) {
+  constexpr int WARPS_M = 2;
+  constexpr int WARPS_N = 2;
+  constexpr int NUM_WARPS = WARPS_M * WARPS_N;
+  constexpr int WARP_STEP_M = BM / WARPS_M;
+  constexpr int WARP_STEP_N = BN / WARPS_N;
+
+  // Precompute some offsets for each thread
+  const int warpid = threadIdx.x / 32;
+  const int laneid = threadIdx.x % 32;
+  const int wm = warpid / WARPS_N;
+  const int wn = warpid % WARPS_N;
+  const int offset_m = wm * WARP_STEP_M;
+  const int offset_n = wn * WARP_STEP_N;
+
+  // Allocate shared memory
+  extern __shared__ char shmem[];
+  SharedTile<T, BM, BK>(&as)[2] = *(SharedTile<T, BM, BK>(*)[2])(&shmem[0]);
+  SharedTile<T, BN, BK>(&bs)[2] =
+      *(SharedTile<T, BN, BK>(*)[2])(&shmem[sizeof(T) * 2 * BM * BK]);
+
+  // Allocate registers for the MMA
+  RegisterTile<float, BM / WARPS_M, BN / WARPS_N> C;
+  RegisterTile<T, BM / WARPS_M, 16> A;
+  RegisterTile<T, BN / WARPS_N, 16> B;
+
+  // Move the global pointers to the tile
+  a += blockIdx.y * BM * K;
+  b += blockIdx.x * BN * K;
+  y += blockIdx.y * BM * N + blockIdx.x * BN;
+
+  // Zero the accumulators
+  C.fill(0);
+
+  // Start the SM pipeline
+  load_async<NUM_WARPS>(as[0], as[0].base_addr(), a, K);
+  load_async<NUM_WARPS>(bs[0], bs[0].base_addr(), b, K);
+  cp_async_commit();
+
+  int tic = 0;
+  for (int k_block = BK; k_block < K; k_block += BK) {
+    load_async<NUM_WARPS>(as[tic ^ 1], as[tic ^ 1].base_addr(), a + k_block, K);
+    load_async<NUM_WARPS>(bs[tic ^ 1], bs[tic ^ 1].base_addr(), b + k_block, K);
+    cp_async_commit();
+    cp_async_wait<1>();
+    __syncthreads();
+
+    MLX_UNROLL
+    for (int k = 0; k < BK / 16; k++) {
+      A.load(
+          as[tic],
+          as[tic].base_addr(),
+          offset_m + laneid % 16,
+          k * 16 + laneid / 16 * 8);
+      B.load(
+          bs[tic],
+          bs[tic].base_addr(),
+          offset_n + laneid % 16,
+          k * 16 + laneid / 16 * 8);
+
+      mma_t(C, A, B);
+    }
+
+    tic ^= 1;
+  }
+
+  // Empty the pipeline
+  cp_async_wait_all();
+  __syncthreads();
+  MLX_UNROLL
+  for (int k = 0; k < BK / 16; k++) {
+    A.load(
+        as[tic],
+        as[tic].base_addr(),
+        offset_m + laneid % 16,
+        k * 16 + laneid / 16 * 8);
+    B.load(
+        bs[tic],
+        bs[tic].base_addr(),
+        offset_n + laneid % 16,
+        k * 16 + laneid / 16 * 8);
+
+    mma_t(C, A, B);
+  }
+
+  C.store_global(y, N, offset_m, offset_n);
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/mma.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/mma.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..94e314909bc109bd2ecec20dba97b8610c14ea9a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/mma.cuh
@@ -0,0 +1,117 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cuda/steel/defines.cuh"
+#include "mlx/backend/cuda/steel/tiles.cuh"
+
+namespace mlx::core::cu {
+
+/**
+ * Fallback mma.
+ *
+ * We should probably a) implement a fallback or complain about it to the
+ * compiler.
+ */
+template <typename U, typename T>
+__device__ inline void
+mma_t(Tile16x16<U>& C, Tile16x16<T>& A, Tile16x16<T>& B) {}
+
+/**
+ * Multiply the 16x16 bfloat16 tiles and accumulate the result in one 16x16
+ * float tile.
+ *
+ * We actually perform C += A @ B.T
+ */
+__device__ __forceinline__ void mma_t(
+    Tile16x16<float>& C,
+    Tile16x16<__nv_bfloat16>& A,
+    Tile16x16<__nv_bfloat16>& B) {
+#if defined(MLX_CUDA_SM_80_ENABLED)
+  asm volatile(
+      "mma.sync.aligned.m16n8k16.row.col.f32.bf16.bf16.f32 "
+      "{%0, %1, %2, %3}, "
+      "{%4, %5, %6, %7}, "
+      "{%8, %9}, "
+      "{%10, %11, %12, %13};"
+
+      // D matrix
+      : "+f"(C.values[0].x),
+        "+f"(C.values[0].y),
+        "+f"(C.values[1].x),
+        "+f"(C.values[1].y)
+
+      // A matrix
+      : "r"(*(uint32_t*)(&A.values[0])),
+        "r"(*(uint32_t*)(&A.values[1])),
+        "r"(*(uint32_t*)(&A.values[2])),
+        "r"(*(uint32_t*)(&A.values[3])),
+
+        // B matrix
+        "r"(*(uint32_t*)(&B.values[0])),
+        "r"(*(uint32_t*)(&B.values[2])),
+
+        // C matrix
+        "f"(C.values[0].x),
+        "f"(C.values[0].y),
+        "f"(C.values[1].x),
+        "f"(C.values[1].y));
+  asm volatile(
+      "mma.sync.aligned.m16n8k16.row.col.f32.bf16.bf16.f32 "
+      "{%0, %1, %2, %3}, "
+      "{%4, %5, %6, %7}, "
+      "{%8, %9}, "
+      "{%10, %11, %12, %13};"
+
+      // D matrix
+      : "+f"(C.values[2].x),
+        "+f"(C.values[2].y),
+        "+f"(C.values[3].x),
+        "+f"(C.values[3].y)
+
+      // A matrix
+      : "r"(*(uint32_t*)(&A.values[0])),
+        "r"(*(uint32_t*)(&A.values[1])),
+        "r"(*(uint32_t*)(&A.values[2])),
+        "r"(*(uint32_t*)(&A.values[3])),
+
+        // B matrix
+        "r"(*(uint32_t*)(&B.values[1])),
+        "r"(*(uint32_t*)(&B.values[3])),
+
+        // C matrix
+        "f"(C.values[2].x),
+        "f"(C.values[2].y),
+        "f"(C.values[3].x),
+        "f"(C.values[3].y));
+#endif
+}
+
+/**
+ * Multiply larger register tiles by delegating to mma_t.
+ */
+template <typename U, typename T, int M, int N, int K>
+__device__ __forceinline__ void mma_t(
+    RegisterTile<U, M, N>& C,
+    RegisterTile<T, M, K>& A,
+    RegisterTile<T, N, K>& B) {
+  constexpr int TILES_M = RegisterTile<T, M, K>::TILES_Y;
+  constexpr int TILES_K = RegisterTile<T, M, K>::TILES_X;
+  constexpr int TILES_N = RegisterTile<T, N, K>::TILES_Y;
+
+  MLX_UNROLL
+  for (int k = 0; k < TILES_K; k++) {
+    MLX_UNROLL
+    for (int m = 0; m < TILES_M; m++) {
+      MLX_UNROLL
+      for (int n = 0; n < TILES_N; n++) {
+        mma_t(
+            C.data[m * TILES_N + n],
+            A.data[m * TILES_K + k],
+            B.data[n * TILES_K + k]);
+      }
+    }
+  }
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/tiles.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/tiles.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..be6c46648bb2d62510409ed2486d72618c332be8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/tiles.cuh
@@ -0,0 +1,471 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cuda/steel/utils.cuh"
+
+namespace mlx::core::cu {
+
+// Map types to their vector of 2 type float -> float2, double -> double2 etc
+template <typename T>
+struct Vector2;
+template <>
+struct Vector2<double> {
+  using type = double2;
+};
+template <>
+struct Vector2<float> {
+  using type = float2;
+};
+template <>
+struct Vector2<__half> {
+  using type = __half2;
+};
+template <>
+struct Vector2<__nv_bfloat16> {
+  using type = __nv_bfloat162;
+};
+template <typename T>
+using Vector2_t = typename Vector2<T>::type;
+
+/**
+ * The basic building block for Ampere mmas. A 16x16 tile distributed across
+ * the warp.
+ *
+ * Each thread holds 8 values. They are distributed according to
+ * https://docs.nvidia.com/cuda/parallel-thread-execution/#warp-level-matrix-fragment-mma-16816-float
+ *
+ * For use instructions see the individual methods eg load().
+ */
+template <typename T>
+struct Tile16x16 {
+  using T2 = Vector2_t<T>;
+
+  T2 values[4];
+
+  __device__ inline void fill(T v) {
+    T2 v2 = {v, v};
+    for (int i = 0; i < 4; i++) {
+      values[i] = v2;
+    }
+  }
+
+  /**
+   * Load a 16x16 tile from shared memory.
+   *
+   * The instruction is a bit weird in the sense that the address provided by
+   * each thread and the elements loaded are not the same.
+   *
+   * We load 4 8x8 tiles. The tile rows are stored contiguously in memory. As a
+   * result the warp provides 4*8 = 32 addresses one per row.
+   *
+   * Threads 0-7 provide the addresses for the first tile, 8-15 for the second
+   * and so on. For instance to load a non swizzled tile we would do
+   *
+   *    base_addr + (laneid % 16) * BK + (laneid / 2) * 8
+   *
+   * See
+   * https://docs.nvidia.com/cuda/parallel-thread-execution/#warp-level-matrix-instructions-ldmatrix
+   */
+  __device__ __forceinline__ void load(uint32_t row_address) {
+    if constexpr (
+        std::is_same_v<T2, __nv_bfloat162> || std::is_same_v<T2, __half2>) {
+      asm volatile(
+          "ldmatrix.sync.aligned.m8n8.x4.shared::cta.b16 {%0, %1, %2, %3}, [%4];\n"
+          : "=r"(*(uint32_t*)&(values[0])),
+            "=r"(*(uint32_t*)&(values[1])),
+            "=r"(*(uint32_t*)&(values[2])),
+            "=r"(*(uint32_t*)&(values[3]))
+          : "r"(row_address));
+    }
+  }
+
+  /**
+   * Store the tile to the address pointed to by `x`.
+   *
+   * The provided pointer is a generic pointer but this is meant to be used to
+   * store to global memory. For storing to shared memory we should use
+   * `stmatrix`.
+   *
+   * This also showcases the format of the tile quite nicely. Each register is
+   * holding to adjacent values. The indices are
+   *
+   *    row + 0, col + 0
+   *    row + 8, col + 0
+   *    row + 0, col + 8
+   *    row + 8, col + 8
+   *
+   * Given that we are dealing with Vector2_t<U> the column offsets are 4
+   * instead of 8.
+   */
+  template <typename U>
+  __device__ inline void store_global(U* x, int N) {
+    using U2 = Vector2_t<U>;
+    U2* x2 = reinterpret_cast<U2*>(x);
+    const int laneid = threadIdx.x % 32;
+    const int row = laneid / 4;
+    const int col = laneid % 4;
+    if constexpr (std::is_same_v<U2, T2>) {
+      x2[(row + 0) * (N / 2) + col + 0] = values[0];
+      x2[(row + 0) * (N / 2) + col + 4] = values[2];
+      x2[(row + 8) * (N / 2) + col + 0] = values[1];
+      x2[(row + 8) * (N / 2) + col + 4] = values[3];
+    } else if constexpr (
+        std::is_same_v<T2, float2> && std::is_same_v<U, __nv_bfloat16>) {
+      x2[(row + 0) * (N / 2) + col + 0] =
+          __floats2bfloat162_rn(values[0].x, values[0].y);
+      x2[(row + 0) * (N / 2) + col + 4] =
+          __floats2bfloat162_rn(values[2].x, values[2].y);
+      x2[(row + 8) * (N / 2) + col + 0] =
+          __floats2bfloat162_rn(values[1].x, values[1].y);
+      x2[(row + 8) * (N / 2) + col + 4] =
+          __floats2bfloat162_rn(values[3].x, values[3].y);
+    }
+  }
+
+  template <typename U>
+  __device__ inline void store_global_safe(U* x, int N, int max_rows) {
+    const int laneid = threadIdx.x % 32;
+    const int row = laneid / 4;
+    const int col = laneid % 4;
+    if (row < max_rows) {
+      x[(row + 0) * N + 2 * col + 0] = static_cast<U>(values[0].x);
+      x[(row + 0) * N + 2 * col + 1] = static_cast<U>(values[0].y);
+      x[(row + 0) * N + 2 * col + 8] = static_cast<U>(values[2].x);
+      x[(row + 0) * N + 2 * col + 9] = static_cast<U>(values[2].y);
+    }
+    if (row + 8 < max_rows) {
+      x[(row + 8) * N + 2 * col + 0] = static_cast<U>(values[1].x);
+      x[(row + 8) * N + 2 * col + 1] = static_cast<U>(values[1].y);
+      x[(row + 8) * N + 2 * col + 8] = static_cast<U>(values[3].x);
+      x[(row + 8) * N + 2 * col + 9] = static_cast<U>(values[3].y);
+    }
+  }
+};
+
+/**
+ * A simple container of multiple Tile16x16.
+ *
+ * Provides utility functions for loading and manipulating collections of basic
+ * tiles.
+ */
+template <typename T, int ROWS_, int COLS_>
+struct RegisterTile {
+  static constexpr int ROWS = ROWS_;
+  static constexpr int COLS = COLS_;
+  static constexpr int TILES_X = COLS / 16;
+  static constexpr int TILES_Y = ROWS / 16;
+
+  Tile16x16<T> data[TILES_X * TILES_Y];
+
+  __device__ inline void fill(T v) {
+    MLX_UNROLL
+    for (int i = 0; i < TILES_Y; i++) {
+      MLX_UNROLL
+      for (int j = 0; j < TILES_X; j++) {
+        data[i * TILES_X + j].fill(v);
+      }
+    }
+  }
+
+  template <typename Tile>
+  __device__ __forceinline__ void
+  load(Tile& tile, uint32_t base_address, int row, int col) {
+    MLX_UNROLL
+    for (int i = 0; i < TILES_Y; i++) {
+      MLX_UNROLL
+      for (int j = 0; j < TILES_X; j++) {
+        data[i * TILES_X + j].load(
+            tile.loc(base_address, row + i * 16, col + j * 16));
+      }
+    }
+  }
+
+  template <typename Tile, typename F>
+  __device__ __forceinline__ void
+  load(Tile& tile, F f, uint32_t base_address, int row, int col) {
+    MLX_UNROLL
+    for (int i = 0; i < TILES_Y; i++) {
+      MLX_UNROLL
+      for (int j = 0; j < TILES_X; j++) {
+        f(data[i * TILES_X + j],
+          tile,
+          base_address,
+          row + i * 16,
+          col + j * 16);
+      }
+    }
+  }
+
+  template <typename U>
+  __device__ inline void store_global(U* x, int N, int row, int col) {
+    MLX_UNROLL
+    for (int i = 0; i < TILES_Y; i++) {
+      MLX_UNROLL
+      for (int j = 0; j < TILES_X; j++) {
+        data[i * TILES_X + j].store_global(
+            x + (row + i * 16) * N + col + j * 16, N);
+      }
+    }
+  }
+
+  template <typename U>
+  __device__ inline void
+  store_global_safe(U* x, int N, int row, int col, int max_rows) {
+    MLX_UNROLL
+    for (int i = 0; i < TILES_Y; i++) {
+      MLX_UNROLL
+      for (int j = 0; j < TILES_X; j++) {
+        data[i * TILES_X + j].store_global_safe(
+            x + (row + i * 16) * N + col + j * 16, N, max_rows - row - i * 16);
+      }
+    }
+  }
+};
+
+/**
+ * A simple container of multiple Tile16x16.
+ *
+ * Provides utility functions for loading and manipulating collections of basic
+ * tiles.
+ */
+template <typename T, int ROWS_, int COLS_>
+struct RegisterTile {
+  static constexpr int ROWS = ROWS_;
+  static constexpr int COLS = COLS_;
+  static constexpr int TILES_X = COLS / 16;
+  static constexpr int TILES_Y = ROWS / 16;
+
+  Tile16x16<T> data[TILES_X * TILES_Y];
+
+  __device__ inline void fill(T v) {
+    MLX_UNROLL
+    for (int i = 0; i < TILES_Y; i++) {
+      MLX_UNROLL
+      for (int j = 0; j < TILES_X; j++) {
+        data[i * TILES_X + j].fill(v);
+      }
+    }
+  }
+
+  template <typename Tile>
+  __device__ inline void
+  load(Tile& tile, uint32_t base_address, int row, int col) {
+    MLX_UNROLL
+    for (int i = 0; i < TILES_Y; i++) {
+      MLX_UNROLL
+      for (int j = 0; j < TILES_X; j++) {
+        data[i * TILES_X + j].load(
+            tile.loc(base_address, row + i * 16, col + j * 16));
+      }
+    }
+  }
+
+  template <typename U>
+  __device__ inline void store_global(U* x, int N, int row, int col) {
+    MLX_UNROLL
+    for (int i = 0; i < TILES_Y; i++) {
+      MLX_UNROLL
+      for (int j = 0; j < TILES_X; j++) {
+        data[i * TILES_X + j].store_global(
+            x + (row + i * 16) * N + col + j * 16, N);
+      }
+    }
+  }
+};
+
+template <typename T, int ROWS_, int COLS_>
+struct SharedTile {
+  static constexpr int ROWS = ROWS_;
+  static constexpr int COLS = COLS_;
+  static constexpr int TILES_X = COLS / 16;
+  static constexpr int TILES_Y = ROWS / 16;
+  static constexpr int NUMEL = ROWS * COLS;
+
+  // Swizzle taken from ThunderKittens. Should be changed when we switch to
+  // cute Layouts.
+  //
+  // See inludes/types/shared/st.cuh
+  //
+  // I do feel that it is too math heavy and can be improved. Also the math is
+  // done every time although the addresses don't change from load to load. I
+  // guess we are expecting the compiler to figure that out.
+  static constexpr int swizzle_bytes =
+      (sizeof(T) == 2 ? (TILES_X % 4 == 0 ? 128 : (TILES_X % 2 == 0 ? 64 : 32))
+                      : (sizeof(T) == 4 ? (TILES_X % 2 == 0 ? 128 : 64) : 0));
+
+  T data[ROWS * COLS];
+
+  __device__ inline uint32_t base_addr() const {
+    return __cvta_generic_to_shared(&data[0]);
+  }
+
+  // Return a pointer to the element at (row, col) using the swizzle.
+  __device__ static inline T* ptr(T* ptr, int row, int col) {
+    if constexpr (swizzle_bytes > 0) {
+      static constexpr int swizzle_repeat = swizzle_bytes * 8;
+      static constexpr int subtile_cols = swizzle_bytes / sizeof(T);
+      const int outer_idx = col / subtile_cols;
+      const uint64_t addr =
+          (uint64_t)(&ptr
+                         [outer_idx * ROWS * subtile_cols + row * subtile_cols +
+                          col % subtile_cols]);
+      const int swizzle = ((addr % swizzle_repeat) >> 7) << 4;
+      return (T*)(addr ^ swizzle);
+    } else {
+      return ptr + row * COLS + col;
+    }
+  }
+
+  // Return the location of the element at (row, col) using the swizzle.
+  __device__ static inline uint32_t loc(uint32_t ptr, int row, int col) {
+    if constexpr (swizzle_bytes > 0) {
+      static constexpr int swizzle_repeat = swizzle_bytes * 8;
+      static constexpr int subtile_cols = swizzle_bytes / sizeof(T);
+      const int outer_idx = col / subtile_cols;
+      const uint32_t addr = ptr +
+          sizeof(T) *
+              (outer_idx * ROWS * subtile_cols + row * subtile_cols +
+               col % subtile_cols);
+      const int swizzle = ((addr % swizzle_repeat) >> 7) << 4;
+      return (addr ^ swizzle);
+    } else {
+      return ptr + sizeof(T) * (row * COLS + col);
+    }
+  }
+
+  // Convenience functions to edit elements going through the swizzle.
+  __device__ inline T& operator()(int row, int col) {
+    return *ptr(data, row, col);
+  }
+  __device__ inline void store(float4& v, int row, int col) {
+    *(reinterpret_cast<float4*>(ptr(data, row, col))) = v;
+  }
+  __device__ inline void store(float2& v, int row, int col) {
+    *(reinterpret_cast<float2*>(ptr(data, row, col))) = v;
+  }
+  __device__ inline void store(float& v, int row, int col) {
+    *(reinterpret_cast<float*>(ptr(data, row, col))) = v;
+  }
+  template <int N>
+  __device__ inline void store(T (&v)[N], int row, int col) {
+    if constexpr (sizeof(T) * N == 4) {
+      store(*(reinterpret_cast<float*>(&v[0])), row, col);
+    } else if constexpr (sizeof(T) * N == 8) {
+      store(*(reinterpret_cast<float2*>(&v[0])), row, col);
+    } else if constexpr (sizeof(T) * N == 16) {
+      store(*(reinterpret_cast<float4*>(&v[0])), row, col);
+    } else {
+      MLX_UNROLL
+      for (int i = 0; i < N; i++) {
+        *ptr(data, row, col + i) = v[i];
+      }
+    }
+  }
+};
+
+/**
+ * Load the tile from global memory by loading 16 bytes at a time and storing
+ * them immediately.
+ *
+ * Can also be used as a fallback for architectures before sm_80.
+ */
+template <int NUM_WARPS, typename T, typename Tile>
+__device__ inline void load(Tile& tile, const T* x, int N) {
+  constexpr int NUM_THREADS = NUM_WARPS * 32;
+  constexpr int ELEMENTS_PER_LOAD = sizeof(float4) / sizeof(T);
+  constexpr int NUM_LOADS = Tile::NUMEL / ELEMENTS_PER_LOAD;
+  constexpr int NUM_LOADS_PER_THREAD = NUM_LOADS / NUM_THREADS;
+  constexpr int NUM_LOADS_PER_ROW = Tile::COLS / ELEMENTS_PER_LOAD;
+  constexpr int STEP_ROWS = NUM_THREADS / NUM_LOADS_PER_ROW;
+
+  const int row = threadIdx.x / NUM_LOADS_PER_ROW;
+  const int col = threadIdx.x % NUM_LOADS_PER_ROW;
+
+  x += row * N + col * ELEMENTS_PER_LOAD;
+
+  MLX_UNROLL
+  for (int i = 0; i < NUM_LOADS_PER_THREAD; i++) {
+    float4 tmp;
+    tmp = *(reinterpret_cast<const float4*>(&x[i * STEP_ROWS * N]));
+    tile.store(tmp, row + i * STEP_ROWS, col * ELEMENTS_PER_LOAD);
+  }
+}
+
+/**
+ * The asynchronous equivalent of load.
+ *
+ * Loads the tile from global memory by submitting a bunch of async copy
+ * instructions. The copy won't start until commit is called and we don't have
+ * a guarantee it will finish until wait is called.
+ *
+ * It should be used as follows
+ *
+ *    load(...)
+ *    load(...)
+ *    cp_async_commit()
+ *    do_other_stuff()
+ *    cp_async_wait_all()
+ *    do_stuff_with_shmem()
+ */
+template <int NUM_WARPS, typename T, typename Tile>
+__device__ inline void
+load_async(Tile& tile, uint32_t base_address, const T* x, int N) {
+  constexpr int NUM_THREADS = NUM_WARPS * 32;
+  constexpr int ELEMENTS_PER_LOAD = sizeof(float4) / sizeof(T);
+  constexpr int NUM_LOADS = Tile::NUMEL / ELEMENTS_PER_LOAD;
+  constexpr int NUM_LOADS_PER_THREAD = NUM_LOADS / NUM_THREADS;
+  constexpr int NUM_LOADS_PER_ROW = Tile::COLS / ELEMENTS_PER_LOAD;
+  constexpr int STEP_ROWS = NUM_THREADS / NUM_LOADS_PER_ROW;
+
+  const int row = threadIdx.x / NUM_LOADS_PER_ROW;
+  const int col = threadIdx.x % NUM_LOADS_PER_ROW;
+
+  x += row * N + col * ELEMENTS_PER_LOAD;
+
+  MLX_UNROLL
+  for (int i = 0; i < NUM_LOADS_PER_THREAD; i++) {
+    cp_async<16>(
+        tile.loc(base_address, row + i * STEP_ROWS, col * ELEMENTS_PER_LOAD),
+        x + i * STEP_ROWS * N);
+  }
+}
+
+/**
+ * Same as load_async but checks if we can load the row.
+ *
+ * NOTE: It should be changed to use a predicated cp async instead.
+ */
+template <int NUM_WARPS, typename T, typename Tile>
+__device__ inline void load_async_safe(
+    Tile& tile,
+    uint32_t base_address,
+    const T* x,
+    int N,
+    int max_rows) {
+  constexpr int NUM_THREADS = NUM_WARPS * 32;
+  constexpr int ELEMENTS_PER_LOAD = sizeof(float4) / sizeof(T);
+  constexpr int NUM_LOADS = Tile::NUMEL / ELEMENTS_PER_LOAD;
+  constexpr int NUM_LOADS_PER_THREAD = NUM_LOADS / NUM_THREADS;
+  constexpr int NUM_LOADS_PER_ROW = Tile::COLS / ELEMENTS_PER_LOAD;
+  constexpr int STEP_ROWS = NUM_THREADS / NUM_LOADS_PER_ROW;
+
+  const int row = threadIdx.x / NUM_LOADS_PER_ROW;
+  const int col = threadIdx.x % NUM_LOADS_PER_ROW;
+
+  x += row * N + col * ELEMENTS_PER_LOAD;
+
+  MLX_UNROLL
+  for (int i = 0; i < NUM_LOADS_PER_THREAD; i++) {
+    if (row + i * STEP_ROWS < max_rows) {
+      cp_async<16>(
+          tile.loc(base_address, row + i * STEP_ROWS, col * ELEMENTS_PER_LOAD),
+          x + i * STEP_ROWS * N);
+    } else {
+      float4 tmp = {0, 0, 0, 0};
+      tile.store(tmp, row + i * STEP_ROWS, col * ELEMENTS_PER_LOAD);
+    }
+  }
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/utils.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/utils.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..0957c09d0ce90fce12a157d3f726b4514ac595f4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/steel/utils.cuh
@@ -0,0 +1,89 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cuda/device/utils.cuh"
+#include "mlx/backend/cuda/steel/defines.cuh"
+
+namespace mlx::core::cu {
+
+/**
+ * Copy bytes from the global memory address pointed to by x to the smem
+ * address pointed to by row_address.
+ *
+ * A simple wrapper over the PTX.
+ */
+template <int N, typename T>
+__device__ inline void cp_async(uint32_t row_address, const T* x) {
+  static_assert(
+      N == 16 || N == 8 || N == 4,
+      "cp.async is only supported for N in {4, 8, 16}.");
+#if defined(MLX_CUDA_SM_80_ENABLED)
+  if constexpr (N == 16) {
+    asm volatile(
+        "cp.async.ca.shared::cta.global [%0], [%1], 16;\n" ::"r"(row_address),
+        "l"(reinterpret_cast<const int4*>(x)));
+  } else if constexpr (N == 8) {
+    asm volatile(
+        "cp.async.ca.shared::cta.global [%0], [%1], 8;\n" ::"r"(row_address),
+        "l"(reinterpret_cast<const int2*>(x)));
+  } else if constexpr (N == 4) {
+    asm volatile(
+        "cp.async.ca.shared::cta.global [%0], [%1], 4;\n" ::"r"(row_address),
+        "l"(reinterpret_cast<const int*>(x)));
+  }
+#endif
+}
+
+/**
+ * Submit all the previous async copies to be executed.
+ */
+__device__ inline void cp_async_commit() {
+#if defined(MLX_CUDA_SM_80_ENABLED)
+  asm volatile("cp.async.commit_group;\n" ::);
+#endif
+}
+
+/**
+ * Wait for all but N of the async copies to finish.
+ */
+template <int N>
+__device__ inline void cp_async_wait() {
+#if defined(MLX_CUDA_SM_80_ENABLED)
+  if constexpr (N == 0) {
+    asm volatile("cp.async.wait_all;\n" ::);
+  } else {
+    asm volatile("cp.async.wait_group %0;\n" ::"n"(N));
+  }
+#endif
+}
+
+/**
+ * Wait for all the async copies to finish.
+ */
+__device__ inline void cp_async_wait_all() {
+  cp_async_wait<0>();
+}
+
+/**
+ * Extract ``bits`` bits from the 32 bit value.
+ *
+ * Single instruction shift and mask.
+ */
+template <int bits>
+__device__ inline uint32_t extract_bits(uint32_t value, int start_bit) {
+  static_assert(
+      bits == 2 || bits == 4 || bits == 8,
+      "extract_bits only supports 2, 4, 8 for now.");
+  uint32_t result;
+  if constexpr (bits == 2) {
+    asm("bfe.u32 %0, %1, %2, 2;" : "=r"(result) : "r"(value), "r"(start_bit));
+  } else if constexpr (bits == 4) {
+    asm("bfe.u32 %0, %1, %2, 4;" : "=r"(result) : "r"(value), "r"(start_bit));
+  } else if constexpr (bits == 8) {
+    asm("bfe.u32 %0, %1, %2, 8;" : "=r"(result) : "r"(value), "r"(start_bit));
+  }
+  return result;
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/ternary.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/ternary.cu
new file mode 100644
index 0000000000000000000000000000000000000000..84ae996aa070a1dbf61bab2c5f4e495e3d72aee4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/ternary.cu
@@ -0,0 +1,269 @@
+// Copyright © 2025 Apple Inc.
+#include "mlx/backend/common/ternary.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/device/ternary_ops.cuh"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+#include <cooperative_groups.h>
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename Op, typename T, typename IdxT, int N_READS>
+__global__ void
+ternary_v(const bool* a, const T* b, const T* c, T* out, IdxT size) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_READS > size) {
+    for (IdxT i = index * N_READS; i < size; ++i) {
+      out[i] = Op{}(a[i], b[i], c[i]);
+    }
+  } else {
+    auto a_vec = load_vector<N_READS>(a, index);
+    auto b_vec = load_vector<N_READS>(b, index);
+    auto c_vec = load_vector<N_READS>(c, index);
+
+    AlignedVector<T, N_READS> out_vec;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      out_vec[i] = Op{}(a_vec[i], b_vec[i], c_vec[i]);
+    }
+
+    store_vector<N_READS>(out, index, out_vec);
+  }
+}
+
+template <typename Op, typename T, typename IdxT, int NDIM, int N_READS>
+__global__ void ternary_g_nd(
+    const bool* a,
+    const T* b,
+    const T* c,
+    T* out,
+    IdxT size_rest,
+    const __grid_constant__ cuda::std::array<int32_t, NDIM> shape,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> a_strides,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> b_strides,
+    const __grid_constant__ cuda::std::array<int64_t, NDIM> c_strides) {
+  auto block = cg::this_thread_block();
+  auto grid = cg::this_grid();
+  IdxT index_rest =
+      grid.block_index().y * block.dim_threads().y + block.thread_index().y;
+  if (index_rest >= size_rest) {
+    return;
+  }
+
+  auto shape_x = shape[NDIM - 1];
+  auto a_stride_x = a_strides[NDIM - 1];
+  auto b_stride_x = b_strides[NDIM - 1];
+  auto c_stride_x = c_strides[NDIM - 1];
+  IdxT index_x =
+      grid.block_index().x * block.dim_threads().x + block.thread_index().x;
+  auto [a_idx, b_idx, c_idx] = elem_to_loc_nd<NDIM>(
+      index_rest * shape_x,
+      shape.data(),
+      a_strides.data(),
+      b_strides.data(),
+      c_strides.data());
+  auto a_vec =
+      load_vector<N_READS>(a + a_idx, index_x, shape_x, a_stride_x, false);
+  auto b_vec =
+      load_vector<N_READS>(b + b_idx, index_x, shape_x, b_stride_x, T(0));
+  auto c_vec =
+      load_vector<N_READS>(c + c_idx, index_x, shape_x, c_stride_x, T(0));
+
+  AlignedVector<T, N_READS> out_vec;
+#pragma unroll
+  for (int i = 0; i < N_READS; ++i) {
+    out_vec[i] = Op{}(a_vec[i], b_vec[i], c_vec[i]);
+  }
+  store_vector(out + shape_x * index_rest, index_x, out_vec, shape_x);
+}
+
+template <typename Op, typename T, typename IdxT, int N_READS>
+__global__ void ternary_g(
+    const bool* a,
+    const T* b,
+    const T* c,
+    T* out,
+    IdxT size_rest,
+    const __grid_constant__ Shape shape,
+    const __grid_constant__ Strides a_strides,
+    const __grid_constant__ Strides b_strides,
+    const __grid_constant__ Strides c_strides,
+    int ndim) {
+  auto block = cg::this_thread_block();
+  auto grid = cg::this_grid();
+  IdxT index_rest =
+      grid.block_index().y * block.dim_threads().y + block.thread_index().y;
+  if (index_rest >= size_rest) {
+    return;
+  }
+
+  auto shape_x = shape[ndim - 1];
+  auto a_stride_x = a_strides[ndim - 1];
+  auto b_stride_x = b_strides[ndim - 1];
+  auto c_stride_x = c_strides[ndim - 1];
+  IdxT index_x =
+      grid.block_index().x * block.dim_threads().x + block.thread_index().x;
+  auto [a_idx, b_idx, c_idx] = elem_to_loc(
+      index_rest * shape_x,
+      shape.data(),
+      a_strides.data(),
+      b_strides.data(),
+      c_strides.data(),
+      ndim);
+  auto a_vec =
+      load_vector<N_READS>(a + a_idx, index_x, shape_x, a_stride_x, false);
+  auto b_vec =
+      load_vector<N_READS>(b + b_idx, index_x, shape_x, b_stride_x, T(0));
+  auto c_vec =
+      load_vector<N_READS>(c + c_idx, index_x, shape_x, c_stride_x, T(0));
+
+  AlignedVector<T, N_READS> out_vec;
+#pragma unroll
+  for (int i = 0; i < N_READS; ++i) {
+    out_vec[i] = Op{}(a_vec[i], b_vec[i], c_vec[i]);
+  }
+  store_vector(out + shape_x * index_rest, index_x, out_vec, shape_x);
+}
+
+} // namespace cu
+
+template <typename Op>
+void ternary_op_gpu_inplace(
+    const std::vector<array>& inputs,
+    array& out,
+    const Stream& s) {
+  const auto& a = inputs[0];
+  const auto& b = inputs[1];
+  const auto& c = inputs[2];
+  if (out.size() == 0) {
+    return;
+  }
+
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(a);
+  encoder.set_input_array(b);
+  encoder.set_input_array(c);
+  encoder.set_output_array(out);
+  dispatch_all_types(out.dtype(), [&](auto type_tag) {
+    using DType = cuda_type_t<MLX_GET_TYPE(type_tag)>;
+
+    auto topt = get_ternary_op_type(a, b, c);
+    if (topt == TernaryOpType::VectorVectorVector ||
+        topt == TernaryOpType::ScalarScalarScalar) {
+      dispatch_bool(out.data_size() > UINT32_MAX, [&](auto large) {
+        using IdxT = std::conditional_t<large(), int64_t, uint32_t>;
+        constexpr int N_READS = 16 / sizeof(DType);
+        auto [num_blocks, block_dims] = get_launch_args(
+            out.data_size(), out.shape(), out.strides(), large(), N_READS);
+        encoder.add_kernel_node(
+            cu::ternary_v<Op, DType, IdxT, N_READS>,
+            num_blocks,
+            block_dims,
+            0,
+            a.data<bool>(),
+            b.data<DType>(),
+            c.data<DType>(),
+            out.data<DType>(),
+            out.data_size());
+      });
+    } else {
+      dispatch_bool(
+          a.data_size() > INT32_MAX || b.data_size() > INT32_MAX ||
+              c.data_size() > INT32_MAX || out.data_size() > INT32_MAX,
+          [&](auto large) {
+            using IdxT = std::conditional_t<large(), int64_t, int32_t>;
+            Shape shape;
+            std::vector<Strides> strides;
+            std::tie(shape, strides) = collapse_contiguous_dims(a, b, c, out);
+            auto& a_strides = strides[0];
+            auto& b_strides = strides[1];
+            auto& c_strides = strides[2];
+            int ndim = shape.size();
+            int work_per_thread = 1;
+            auto dim0 = ndim > 0 ? shape.back() : 1;
+            auto rest = out.size() / dim0;
+            if (dim0 >= 4) {
+              work_per_thread = 4;
+            }
+            dim0 = (dim0 + work_per_thread - 1) / work_per_thread;
+            auto block_dims = get_block_dims(dim0, rest, 1);
+            uint32_t num_blocks_x = cuda::ceil_div(dim0, block_dims.x);
+            uint32_t num_blocks_y = cuda::ceil_div(rest, block_dims.y);
+
+            if (ndim <= 3) {
+              dispatch_1_2_3(ndim, [&](auto dims_constant) {
+                auto kernel =
+                    cu::ternary_g_nd<Op, DType, IdxT, dims_constant(), 1>;
+                if (work_per_thread == 4) {
+                  kernel =
+                      cu::ternary_g_nd<Op, DType, IdxT, dims_constant(), 4>;
+                }
+                encoder.add_kernel_node(
+                    kernel,
+                    {num_blocks_x, num_blocks_y},
+                    block_dims,
+                    0,
+                    a.data<bool>(),
+                    b.data<DType>(),
+                    c.data<DType>(),
+                    out.data<DType>(),
+                    rest,
+                    const_param<dims_constant()>(shape),
+                    const_param<dims_constant()>(a_strides),
+                    const_param<dims_constant()>(b_strides),
+                    const_param<dims_constant()>(c_strides));
+              });
+            } else {
+              auto kernel = cu::ternary_g<Op, DType, IdxT, 1>;
+              if (work_per_thread == 4) {
+                kernel = cu::ternary_g<Op, DType, IdxT, 4>;
+              }
+              encoder.add_kernel_node(
+                  kernel,
+                  {num_blocks_x, num_blocks_y},
+                  block_dims,
+                  0,
+                  a.data<bool>(),
+                  b.data<DType>(),
+                  c.data<DType>(),
+                  out.data<DType>(),
+                  rest,
+                  const_param(shape),
+                  const_param(a_strides),
+                  const_param(b_strides),
+                  const_param(c_strides),
+                  ndim);
+            }
+          });
+    }
+  });
+}
+
+template <typename Op>
+void ternary_op_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    const Stream& s) {
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  auto& c = inputs[2];
+  auto topt = get_ternary_op_type(a, b, c);
+  set_ternary_op_output_data(a, b, c, out, topt);
+  ternary_op_gpu_inplace<Op>(inputs, out, s);
+}
+
+void Select::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Select::eval_gpu");
+  auto& s = out.primitive().stream();
+  ternary_op_gpu<cu::Select>(inputs, out, s);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary.cu
new file mode 100644
index 0000000000000000000000000000000000000000..4102dbfb36c92d5c8f2dd56b94feb2bca11d73c7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary.cu
@@ -0,0 +1,284 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/unary.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/device/unary_ops.cuh"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+#include <cooperative_groups.h>
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void unary_v(const In* in, Out* out, IdxT size) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_READS > size) {
+    for (IdxT i = index * N_READS; i < size; ++i) {
+      out[i] = Op{}(in[i]);
+    }
+  } else {
+    auto in_vec = load_vector<N_READS>(in, index);
+
+    AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      out_vec[i] = Op{}(in_vec[i]);
+    }
+
+    store_vector<N_READS>(out, index, out_vec);
+  }
+}
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void unary_g(
+    const In* in,
+    Out* out,
+    IdxT size_rest,
+    const __grid_constant__ Shape shape,
+    const __grid_constant__ Strides strides,
+    int ndim) {
+  auto block = cg::this_thread_block();
+  auto grid = cg::this_grid();
+  IdxT index_rest =
+      grid.block_index().y * block.dim_threads().y + block.thread_index().y;
+  if (index_rest >= size_rest) {
+    return;
+  }
+
+  auto shape_x = shape[ndim - 1];
+  auto stride_x = strides[ndim - 1];
+  IdxT index_x =
+      grid.block_index().x * block.dim_threads().x + block.thread_index().x;
+  auto idx =
+      elem_to_loc(index_rest * shape_x, shape.data(), strides.data(), ndim);
+  auto in_vec =
+      load_vector<N_READS>(in + idx, index_x, shape_x, stride_x, In(0));
+  AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+  for (int i = 0; i < N_READS; ++i) {
+    out_vec[i] = Op{}(in_vec[i]);
+  }
+  store_vector(out + shape_x * index_rest, index_x, out_vec, shape_x);
+}
+
+template <typename Op, typename In, typename Out>
+constexpr bool supports_unary_op() {
+  if (std::is_same_v<Op, Abs> || std::is_same_v<Op, Negative> ||
+      std::is_same_v<Op, Sign> || std::is_same_v<Op, Square>) {
+    return std::is_same_v<In, Out>;
+  }
+  if (std::is_same_v<Op, ArcCosh> || std::is_same_v<Op, ArcSinh> ||
+      std::is_same_v<Op, ArcTanh> || std::is_same_v<Op, Erf> ||
+      std::is_same_v<Op, ErfInv> || std::is_same_v<Op, Expm1> ||
+      std::is_same_v<Op, Sigmoid>) {
+    return std::is_same_v<In, Out> && is_floating_v<In>;
+  }
+  if (std::is_same_v<Op, BitwiseInvert>) {
+    return std::is_same_v<In, Out> && std::is_integral_v<In> &&
+        !std::is_same_v<In, bool>;
+  }
+  if (std::is_same_v<Op, Ceil> || std::is_same_v<Op, Floor>) {
+    return std::is_same_v<In, Out> && !mlx::core::is_complex_v<In>;
+  }
+  if (std::is_same_v<Op, Conjugate>) {
+    return std::is_same_v<In, Out> && mlx::core::is_complex_v<In>;
+  }
+  if (std::is_same_v<Op, ArcCos> || std::is_same_v<Op, ArcSin> ||
+      std::is_same_v<Op, ArcTan> || std::is_same_v<Op, Cos> ||
+      std::is_same_v<Op, Cosh> || std::is_same_v<Op, Exp> ||
+      std::is_same_v<Op, Log> || std::is_same_v<Op, Log2> ||
+      std::is_same_v<Op, Log10> || std::is_same_v<Op, Log1p> ||
+      std::is_same_v<Op, Round> || std::is_same_v<Op, Rsqrt> ||
+      std::is_same_v<Op, Sqrt> || std::is_same_v<Op, Sin> ||
+      std::is_same_v<Op, Sinh> || std::is_same_v<Op, Tan> ||
+      std::is_same_v<Op, Tanh>) {
+    return std::is_same_v<In, Out> && is_inexact_v<In>;
+  }
+  if (std::is_same_v<Op, Imag> || std::is_same_v<Op, Real>) {
+    return mlx::core::is_complex_v<In> && std::is_same_v<Out, float>;
+  }
+  if (std::is_same_v<Op, LogicalNot>) {
+    return std::is_same_v<In, Out> && std::is_same_v<In, bool>;
+  }
+  return false;
+}
+
+} // namespace cu
+
+template <typename Op>
+void unary_op_gpu_inplace(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s) {
+  auto& in = inputs[0];
+  if (in.size() == 0) {
+    return;
+  }
+  bool contig = in.flags().contiguous;
+  bool large;
+  if (!contig) {
+    large = in.data_size() > INT32_MAX || out.size() > INT32_MAX;
+  } else {
+    large = in.data_size() > UINT32_MAX;
+  }
+
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  dispatch_all_types(in.dtype(), [&](auto in_type_tag) {
+    dispatch_all_types(out.dtype(), [&](auto out_type_tag) {
+      using CTYPE_IN = MLX_GET_TYPE(in_type_tag);
+      using CTYPE_OUT = MLX_GET_TYPE(out_type_tag);
+      if constexpr (cu::supports_unary_op<Op, CTYPE_IN, CTYPE_OUT>()) {
+        dispatch_bool(large, [&](auto large) {
+          using InType = cuda_type_t<CTYPE_IN>;
+          using OutType = cuda_type_t<CTYPE_OUT>;
+          if (contig) {
+            using IdxT = std::conditional_t<large(), int64_t, uint32_t>;
+            constexpr int N_READS = 16 / sizeof(OutType);
+            auto [num_blocks, block_dims] = get_launch_args(
+                out.data_size(), out.shape(), out.strides(), large, N_READS);
+            encoder.add_kernel_node(
+                cu::unary_v<Op, InType, OutType, IdxT, N_READS>,
+                num_blocks,
+                block_dims,
+                0,
+                in.data<InType>(),
+                out.data<OutType>(),
+                out.data_size());
+          } else {
+            using IdxT = std::conditional_t<large(), int64_t, int32_t>;
+            auto [shape, strides] = collapse_contiguous_dims(in);
+            auto ndim = shape.size();
+            int work_per_thread = 1;
+            auto kernel = cu::unary_g<Op, InType, OutType, IdxT, 1>;
+            auto dim0 = ndim > 0 ? shape.back() : 1;
+            auto rest = out.size() / dim0;
+            if (dim0 >= 4) {
+              kernel = cu::unary_g<Op, InType, OutType, IdxT, 4>;
+              work_per_thread = 4;
+            }
+            dim0 = (dim0 + work_per_thread - 1) / work_per_thread;
+            auto block_dims = get_block_dims(dim0, rest, 1);
+            uint32_t num_blocks_x = cuda::ceil_div(dim0, block_dims.x);
+            uint32_t num_blocks_y = cuda::ceil_div(rest, block_dims.y);
+            encoder.add_kernel_node(
+                kernel,
+                {num_blocks_x, num_blocks_y},
+                block_dims,
+                0,
+                in.data<InType>(),
+                out.data<OutType>(),
+                rest,
+                const_param(shape),
+                const_param(strides),
+                ndim);
+          }
+        });
+      } else {
+        throw std::runtime_error(fmt::format(
+            "Can not do unary op {} on input of {} with output of {}.",
+            op,
+            dtype_to_string(in.dtype()),
+            dtype_to_string(out.dtype())));
+      }
+    });
+  });
+}
+
+template <typename Op>
+void unary_op_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s) {
+  set_unary_output_data(inputs[0], out);
+  unary_op_gpu_inplace<Op>(inputs, out, op, s);
+}
+
+#define UNARY_GPU(func)                                               \
+  void func::eval_gpu(const std::vector<array>& inputs, array& out) { \
+    nvtx3::scoped_range r(#func "::eval_gpu");                        \
+    auto& s = out.primitive().stream();                               \
+    unary_op_gpu<cu::func>(inputs, out, name(), s);                   \
+  }
+
+UNARY_GPU(Abs)
+UNARY_GPU(ArcCos)
+UNARY_GPU(ArcCosh)
+UNARY_GPU(ArcSin)
+UNARY_GPU(ArcSinh)
+UNARY_GPU(ArcTan)
+UNARY_GPU(ArcTanh)
+UNARY_GPU(BitwiseInvert)
+UNARY_GPU(Ceil)
+UNARY_GPU(Conjugate)
+UNARY_GPU(Cos)
+UNARY_GPU(Cosh)
+UNARY_GPU(Erf)
+UNARY_GPU(ErfInv)
+UNARY_GPU(Exp)
+UNARY_GPU(Expm1)
+UNARY_GPU(Floor)
+UNARY_GPU(Imag)
+UNARY_GPU(Log1p)
+UNARY_GPU(LogicalNot)
+UNARY_GPU(Negative)
+UNARY_GPU(Real)
+UNARY_GPU(Sigmoid)
+UNARY_GPU(Sign)
+UNARY_GPU(Sin)
+UNARY_GPU(Sinh)
+UNARY_GPU(Square)
+UNARY_GPU(Tan)
+UNARY_GPU(Tanh)
+
+void Log::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Log::eval_gpu");
+  auto& s = out.primitive().stream();
+  switch (base_) {
+    case Base::e:
+      unary_op_gpu<cu::Log>(inputs, out, name(), s);
+      break;
+    case Base::two:
+      unary_op_gpu<cu::Log2>(inputs, out, name(), s);
+      break;
+    case Base::ten:
+      unary_op_gpu<cu::Log10>(inputs, out, name(), s);
+      break;
+  }
+}
+
+void Round::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Round::eval_gpu");
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  auto& s = out.primitive().stream();
+  if (issubdtype(in.dtype(), inexact)) {
+    unary_op_gpu<cu::Round>(inputs, out, name(), s);
+  } else {
+    // No-op integer types
+    out.copy_shared_buffer(in);
+  }
+}
+
+void Sqrt::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Sort::eval_gpu");
+  auto& s = out.primitive().stream();
+  if (recip_) {
+    unary_op_gpu<cu::Rsqrt>(inputs, out, "Rsqrt", s);
+  } else {
+    unary_op_gpu<cu::Sqrt>(inputs, out, "Sqrt", s);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..532c5645edacc012f81db3c7b51e2f29050b2f4d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/CMakeLists.txt
@@ -0,0 +1,34 @@
+target_sources(
+  mlx
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/abs.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/arccos.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/arccosh.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/arcsin.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/arcsinh.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/arctan.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/arctanh.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/bitwise_invert.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/ceil.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/conjugate.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/cos.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/cosh.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/erf.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/erf_inv.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/exp.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/expm1.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/floor.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/imag.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/log.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/log1p.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/logical_not.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/negative.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/real.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/round.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/sigmoid.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/sign.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/sin.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/sinh.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/sqrt.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/square.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/tan.cu
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/tanh.cu)
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/abs.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/abs.cu
new file mode 100644
index 0000000000000000000000000000000000000000..90b197d213e1be28b79dcc82c065e33370bb9a65
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/abs.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Abs)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arccos.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arccos.cu
new file mode 100644
index 0000000000000000000000000000000000000000..38849970d9388a3b8cf386c44823e70f46264f48
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arccos.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(ArcCos)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arccosh.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arccosh.cu
new file mode 100644
index 0000000000000000000000000000000000000000..0ef0738a49a45dae53e6301f9487615e2438e175
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arccosh.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(ArcCosh)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arcsin.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arcsin.cu
new file mode 100644
index 0000000000000000000000000000000000000000..07956ee9bb97c8a3bc82d8440c9da1fc5c2b8131
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arcsin.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(ArcSin)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arcsinh.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arcsinh.cu
new file mode 100644
index 0000000000000000000000000000000000000000..a7ab63e17265dd24d332346082ef507fba243bde
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arcsinh.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(ArcSinh)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arctan.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arctan.cu
new file mode 100644
index 0000000000000000000000000000000000000000..78639afaa6179fa60cf255b6da033962a7034865
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arctan.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(ArcTan)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arctanh.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arctanh.cu
new file mode 100644
index 0000000000000000000000000000000000000000..488268c9e70742bfa8ceba4014383ffc76d7e78c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/arctanh.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(ArcTanh)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/bitwise_invert.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/bitwise_invert.cu
new file mode 100644
index 0000000000000000000000000000000000000000..77b88f30fea98e86da40d97f2e97a2f171ebc71d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/bitwise_invert.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(BitwiseInvert)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/ceil.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/ceil.cu
new file mode 100644
index 0000000000000000000000000000000000000000..5ee300ffeea5aa4ede46c429bdecfac31023b295
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/ceil.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Ceil)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/conjugate.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/conjugate.cu
new file mode 100644
index 0000000000000000000000000000000000000000..1d1d60e7774ec1a5befb0ea6cdaa170ebbc6cf66
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/conjugate.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Conjugate)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/cos.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/cos.cu
new file mode 100644
index 0000000000000000000000000000000000000000..cfceb86ab2728f82291ce5198c0acae5a2dde361
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/cos.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Cos)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/cosh.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/cosh.cu
new file mode 100644
index 0000000000000000000000000000000000000000..d5fcc7081b993e101aad03d7798becb0ac32d60b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/cosh.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Cosh)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/erf.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/erf.cu
new file mode 100644
index 0000000000000000000000000000000000000000..c7859322b8e16cdb18f7bc4d66b4338d3e22dc9a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/erf.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Erf)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/erf_inv.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/erf_inv.cu
new file mode 100644
index 0000000000000000000000000000000000000000..16bbaba19d99ab843dc7a489fbb916b328873e7b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/erf_inv.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(ErfInv)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/exp.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/exp.cu
new file mode 100644
index 0000000000000000000000000000000000000000..5a566691dc44c10ed55d8e145c56ec565ce10d0d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/exp.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Exp)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/expm1.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/expm1.cu
new file mode 100644
index 0000000000000000000000000000000000000000..15e6ce44510cc7947f5d6bc1d21aa53fcd360a67
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/expm1.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Expm1)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/floor.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/floor.cu
new file mode 100644
index 0000000000000000000000000000000000000000..a8c7ab0bb6c17dedc3972d4af6ddcd38f1709de3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/floor.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Floor)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/imag.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/imag.cu
new file mode 100644
index 0000000000000000000000000000000000000000..9e3c05c3b1a0e51020179afd0ccbf64228e705b8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/imag.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Imag)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/log.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/log.cu
new file mode 100644
index 0000000000000000000000000000000000000000..1fd2aa68054995be0b32939d0f522d2f3ee3fccd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/log.cu
@@ -0,0 +1,21 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+void Log::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Log::eval_gpu");
+  auto& s = out.primitive().stream();
+  switch (base_) {
+    case Base::e:
+      unary_op_gpu<cu::Log>(inputs, out, name(), s);
+      break;
+    case Base::two:
+      unary_op_gpu<cu::Log2>(inputs, out, name(), s);
+      break;
+    case Base::ten:
+      unary_op_gpu<cu::Log10>(inputs, out, name(), s);
+      break;
+  }
+}
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/log1p.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/log1p.cu
new file mode 100644
index 0000000000000000000000000000000000000000..5396c3da051b93ad25042d14297c949adfe3fa58
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/log1p.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Log1p)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/logical_not.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/logical_not.cu
new file mode 100644
index 0000000000000000000000000000000000000000..7f398707fa7b6318a8269fa5c0f7cc894c96f039
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/logical_not.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(LogicalNot)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/negative.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/negative.cu
new file mode 100644
index 0000000000000000000000000000000000000000..9c7e576ec508ea3cb71f00331fef014fc19c794a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/negative.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Negative)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/real.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/real.cu
new file mode 100644
index 0000000000000000000000000000000000000000..361ffd3f92e7f229e9d5de936e8d40fb753ac8ba
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/real.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Real)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/round.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/round.cu
new file mode 100644
index 0000000000000000000000000000000000000000..4e80fdb6003504c64a0d9886955d123e5dad8ff2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/round.cu
@@ -0,0 +1,18 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+void Round::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Round::eval_gpu");
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  auto& s = out.primitive().stream();
+  if (issubdtype(in.dtype(), inexact)) {
+    unary_op_gpu<cu::Round>(inputs, out, name(), s);
+  } else {
+    // No-op integer types
+    out.copy_shared_buffer(in);
+  }
+}
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sigmoid.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sigmoid.cu
new file mode 100644
index 0000000000000000000000000000000000000000..3d943726c631f806229673bc92760c71fbab211b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sigmoid.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Sigmoid)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sign.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sign.cu
new file mode 100644
index 0000000000000000000000000000000000000000..d586d82751734c4be6b002a1ffcce0660362856d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sign.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Sign)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sin.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sin.cu
new file mode 100644
index 0000000000000000000000000000000000000000..47a5adc84b0d296b14fba019eb0de2fece2f05da
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sin.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Sin)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sinh.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sinh.cu
new file mode 100644
index 0000000000000000000000000000000000000000..7a73b7fd43d3fab0cc99eb3c2200a1e735bec30b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sinh.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Sinh)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sqrt.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sqrt.cu
new file mode 100644
index 0000000000000000000000000000000000000000..21f5f08f26e8468a223df5a4c33590210ec31fe4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/sqrt.cu
@@ -0,0 +1,15 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+void Sqrt::eval_gpu(const std::vector<array>& inputs, array& out) {
+  nvtx3::scoped_range r("Sqrt::eval_gpu");
+  auto& s = out.primitive().stream();
+  if (recip_) {
+    unary_op_gpu<cu::Rsqrt>(inputs, out, "Rsqrt", s);
+  } else {
+    unary_op_gpu<cu::Sqrt>(inputs, out, "Sqrt", s);
+  }
+}
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/square.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/square.cu
new file mode 100644
index 0000000000000000000000000000000000000000..bbb5f51308b1d03bd7517bdae9d15f32209be784
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/square.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Square)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/tan.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/tan.cu
new file mode 100644
index 0000000000000000000000000000000000000000..3039dcdc171df8d8c2474e76939b9e272247a201
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/tan.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Tan)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/tanh.cu b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/tanh.cu
new file mode 100644
index 0000000000000000000000000000000000000000..ae69a51b5c1e68c0c1c6cc8df438f59375788471
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/tanh.cu
@@ -0,0 +1,7 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/unary/unary.cuh"
+
+namespace mlx::core {
+UNARY_GPU(Tanh)
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/unary.cuh b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/unary.cuh
new file mode 100644
index 0000000000000000000000000000000000000000..a20e119cab9d97390e361cc83adac25731ec51a2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/unary/unary.cuh
@@ -0,0 +1,215 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/unary.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/backend/cuda/device/unary_ops.cuh"
+#include "mlx/backend/cuda/kernel_utils.cuh"
+#include "mlx/dtype_utils.h"
+#include "mlx/primitives.h"
+
+#include <cooperative_groups.h>
+#include <nvtx3/nvtx3.hpp>
+
+namespace mlx::core {
+
+namespace cu {
+
+namespace cg = cooperative_groups;
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void unary_v(const In* in, Out* out, IdxT size) {
+  IdxT index = cg::this_grid().thread_rank();
+
+  if ((index + 1) * N_READS > size) {
+    for (IdxT i = index * N_READS; i < size; ++i) {
+      out[i] = Op{}(in[i]);
+    }
+  } else {
+    auto in_vec = load_vector<N_READS>(in, index);
+
+    AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+    for (int i = 0; i < N_READS; ++i) {
+      out_vec[i] = Op{}(in_vec[i]);
+    }
+
+    store_vector<N_READS>(out, index, out_vec);
+  }
+}
+
+template <typename Op, typename In, typename Out, typename IdxT, int N_READS>
+__global__ void unary_g(
+    const In* in,
+    Out* out,
+    IdxT size_rest,
+    const __grid_constant__ Shape shape,
+    const __grid_constant__ Strides strides,
+    int ndim) {
+  auto block = cg::this_thread_block();
+  auto grid = cg::this_grid();
+  IdxT index_rest =
+      grid.block_index().y * block.dim_threads().y + block.thread_index().y;
+  if (index_rest >= size_rest) {
+    return;
+  }
+
+  auto shape_x = shape[ndim - 1];
+  auto stride_x = strides[ndim - 1];
+  IdxT index_x =
+      grid.block_index().x * block.dim_threads().x + block.thread_index().x;
+  auto idx =
+      elem_to_loc(index_rest * shape_x, shape.data(), strides.data(), ndim);
+  auto in_vec =
+      load_vector<N_READS>(in + idx, index_x, shape_x, stride_x, In(0));
+  AlignedVector<Out, N_READS> out_vec;
+#pragma unroll
+  for (int i = 0; i < N_READS; ++i) {
+    out_vec[i] = Op{}(in_vec[i]);
+  }
+  store_vector(out + shape_x * index_rest, index_x, out_vec, shape_x);
+}
+
+template <typename Op, typename In, typename Out>
+constexpr bool supports_unary_op() {
+  if (std::is_same_v<Op, Abs> || std::is_same_v<Op, Negative> ||
+      std::is_same_v<Op, Sign> || std::is_same_v<Op, Square>) {
+    return std::is_same_v<In, Out>;
+  }
+  if (std::is_same_v<Op, ArcCosh> || std::is_same_v<Op, ArcSinh> ||
+      std::is_same_v<Op, ArcTanh> || std::is_same_v<Op, Erf> ||
+      std::is_same_v<Op, ErfInv> || std::is_same_v<Op, Expm1> ||
+      std::is_same_v<Op, Sigmoid>) {
+    return std::is_same_v<In, Out> && is_floating_v<In>;
+  }
+  if (std::is_same_v<Op, BitwiseInvert>) {
+    return std::is_same_v<In, Out> && std::is_integral_v<In> &&
+        !std::is_same_v<In, bool>;
+  }
+  if (std::is_same_v<Op, Ceil> || std::is_same_v<Op, Floor>) {
+    return std::is_same_v<In, Out> && !mlx::core::is_complex_v<In>;
+  }
+  if (std::is_same_v<Op, Conjugate>) {
+    return std::is_same_v<In, Out> && mlx::core::is_complex_v<In>;
+  }
+  if (std::is_same_v<Op, ArcCos> || std::is_same_v<Op, ArcSin> ||
+      std::is_same_v<Op, ArcTan> || std::is_same_v<Op, Cos> ||
+      std::is_same_v<Op, Cosh> || std::is_same_v<Op, Exp> ||
+      std::is_same_v<Op, Log> || std::is_same_v<Op, Log2> ||
+      std::is_same_v<Op, Log10> || std::is_same_v<Op, Log1p> ||
+      std::is_same_v<Op, Round> || std::is_same_v<Op, Rsqrt> ||
+      std::is_same_v<Op, Sqrt> || std::is_same_v<Op, Sin> ||
+      std::is_same_v<Op, Sinh> || std::is_same_v<Op, Tan> ||
+      std::is_same_v<Op, Tanh>) {
+    return std::is_same_v<In, Out> && is_inexact_v<In>;
+  }
+  if (std::is_same_v<Op, Imag> || std::is_same_v<Op, Real>) {
+    return mlx::core::is_complex_v<In> && std::is_same_v<Out, float>;
+  }
+  if (std::is_same_v<Op, LogicalNot>) {
+    return std::is_same_v<In, Out> && std::is_same_v<In, bool>;
+  }
+  return false;
+}
+
+} // namespace cu
+
+template <typename Op>
+void unary_op_gpu_inplace(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s) {
+  auto& in = inputs[0];
+  if (in.size() == 0) {
+    return;
+  }
+  bool contig = in.flags().contiguous;
+  bool large;
+  if (!contig) {
+    large = in.data_size() > INT32_MAX || out.size() > INT32_MAX;
+  } else {
+    large = in.data_size() > UINT32_MAX;
+  }
+
+  auto& encoder = cu::get_command_encoder(s);
+  encoder.set_input_array(in);
+  encoder.set_output_array(out);
+  dispatch_all_types(in.dtype(), [&](auto in_type_tag) {
+    dispatch_all_types(out.dtype(), [&](auto out_type_tag) {
+      using CTYPE_IN = MLX_GET_TYPE(in_type_tag);
+      using CTYPE_OUT = MLX_GET_TYPE(out_type_tag);
+      if constexpr (cu::supports_unary_op<Op, CTYPE_IN, CTYPE_OUT>()) {
+        dispatch_bool(large, [&](auto large) {
+          using InType = cuda_type_t<CTYPE_IN>;
+          using OutType = cuda_type_t<CTYPE_OUT>;
+          if (contig) {
+            using IdxT = std::conditional_t<large(), int64_t, uint32_t>;
+            constexpr int N_READS = 16 / sizeof(OutType);
+            auto [num_blocks, block_dims] = get_launch_args(
+                out.data_size(), out.shape(), out.strides(), large, N_READS);
+            encoder.add_kernel_node(
+                cu::unary_v<Op, InType, OutType, IdxT, N_READS>,
+                num_blocks,
+                block_dims,
+                0,
+                in.data<InType>(),
+                out.data<OutType>(),
+                out.data_size());
+          } else {
+            using IdxT = std::conditional_t<large(), int64_t, int32_t>;
+            auto [shape, strides] = collapse_contiguous_dims(in);
+            auto ndim = shape.size();
+            int work_per_thread = 1;
+            auto kernel = cu::unary_g<Op, InType, OutType, IdxT, 1>;
+            auto dim0 = ndim > 0 ? shape.back() : 1;
+            auto rest = out.size() / dim0;
+            if (dim0 >= 4) {
+              kernel = cu::unary_g<Op, InType, OutType, IdxT, 4>;
+              work_per_thread = 4;
+            }
+            dim0 = (dim0 + work_per_thread - 1) / work_per_thread;
+            auto block_dims = get_block_dims(dim0, rest, 1);
+            uint32_t num_blocks_x = cuda::ceil_div(dim0, block_dims.x);
+            uint32_t num_blocks_y = cuda::ceil_div(rest, block_dims.y);
+            encoder.add_kernel_node(
+                kernel,
+                {num_blocks_x, num_blocks_y},
+                block_dims,
+                0,
+                in.data<InType>(),
+                out.data<OutType>(),
+                rest,
+                const_param(shape),
+                const_param(strides),
+                ndim);
+          }
+        });
+      } else {
+        throw std::runtime_error(fmt::format(
+            "Can not do unary op {} on input of {} with output of {}.",
+            op,
+            dtype_to_string(in.dtype()),
+            dtype_to_string(out.dtype())));
+      }
+    });
+  });
+}
+
+template <typename Op>
+void unary_op_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s) {
+  set_unary_output_data(inputs[0], out);
+  unary_op_gpu_inplace<Op>(inputs, out, op, s);
+}
+
+#define UNARY_GPU(func)                                               \
+  void func::eval_gpu(const std::vector<array>& inputs, array& out) { \
+    nvtx3::scoped_range r(#func "::eval_gpu");                        \
+    auto& s = out.primitive().stream();                               \
+    unary_op_gpu<cu::func>(inputs, out, name(), s);                   \
+  }
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/utils.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..09894d4cabae37adfb96e373779c76ed85bc3ca0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/utils.cpp
@@ -0,0 +1,89 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/utils.h"
+#include "mlx/backend/cuda/device.h"
+#include "mlx/dtype_utils.h"
+
+#include <fmt/format.h>
+
+namespace mlx::core {
+
+void check_cublas_error(const char* name, cublasStatus_t err) {
+  if (err != CUBLAS_STATUS_SUCCESS) {
+    // TODO: Use cublasGetStatusString when it is widely available.
+    throw std::runtime_error(
+        fmt::format("{} failed with code: {}.", name, static_cast<int>(err)));
+  }
+}
+
+void check_cuda_error(const char* name, cudaError_t err) {
+  if (err != cudaSuccess) {
+    throw std::runtime_error(
+        fmt::format("{} failed: {}", name, cudaGetErrorString(err)));
+  }
+}
+
+void check_cuda_error(const char* name, CUresult err) {
+  if (err != CUDA_SUCCESS) {
+    const char* err_str = "Unknown error";
+    cuGetErrorString(err, &err_str);
+    throw std::runtime_error(fmt::format("{} failed: {}", name, err_str));
+  }
+}
+
+const char* dtype_to_cuda_type(const Dtype& dtype) {
+  switch (dtype) {
+    case bool_:
+      return "bool";
+    case int8:
+      return "int8_t";
+    case int16:
+      return "int16_t";
+    case int32:
+      return "int32_t";
+    case int64:
+      return "int64_t";
+    case uint8:
+      return "uint8_t";
+    case uint16:
+      return "uint16_t";
+    case uint32:
+      return "uint32_t";
+    case uint64:
+      return "uint64_t";
+    case float16:
+      return "__half";
+    case bfloat16:
+      return "__nv_bfloat16";
+    case float32:
+      return "float";
+    case float64:
+      return "double";
+    case complex64:
+      return "complex64_t";
+    default:
+      return "unknown";
+  }
+}
+
+CudaGraph::CudaGraph(cu::Device& device) {
+  device.make_current();
+  CHECK_CUDA_ERROR(cudaGraphCreate(&handle_, 0));
+}
+
+void CudaGraph::end_capture(cudaStream_t stream) {
+  assert(handle_ == nullptr);
+  CHECK_CUDA_ERROR(cudaStreamEndCapture(stream, &handle_));
+}
+
+void CudaGraphExec::instantiate(cudaGraph_t graph) {
+  assert(handle_ == nullptr);
+  CHECK_CUDA_ERROR(cudaGraphInstantiate(&handle_, graph, nullptr, nullptr, 0));
+}
+
+CudaStream::CudaStream(cu::Device& device) {
+  device.make_current();
+  CHECK_CUDA_ERROR(cudaStreamCreateWithFlags(&handle_, cudaStreamNonBlocking));
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/utils.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..81b19e346a725746b3894b0474cf95b18f0be085
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/utils.h
@@ -0,0 +1,103 @@
+// Copyright © 2025 Apple Inc.
+
+// This file include utilies that are used by C++ code (i.e. .cpp files).
+
+#pragma once
+
+#include <cublasLt.h>
+#include <cuda.h>
+#include <cuda_runtime.h>
+
+namespace mlx::core {
+
+namespace cu {
+class Device;
+
+}
+
+struct Dtype;
+
+// Throw exception if the cuda API does not succeed.
+void check_cublas_error(const char* name, cublasStatus_t err);
+void check_cuda_error(const char* name, cudaError_t err);
+void check_cuda_error(const char* name, CUresult err);
+
+// The macro version that prints the command that failed.
+#define CHECK_CUBLAS_ERROR(cmd) check_cublas_error(#cmd, (cmd))
+#define CHECK_CUDA_ERROR(cmd) check_cuda_error(#cmd, (cmd))
+
+// Convert Dtype to CUDA C++ types.
+const char* dtype_to_cuda_type(const Dtype& dtype);
+
+// Base class for RAII managed CUDA resources.
+template <typename Handle, cudaError_t (*Destroy)(Handle)>
+class CudaHandle {
+ public:
+  CudaHandle(Handle handle = nullptr) : handle_(handle) {}
+
+  CudaHandle(CudaHandle&& other) : handle_(other.handle_) {
+    assert(this != &other);
+    other.handle_ = nullptr;
+  }
+
+  ~CudaHandle() {
+    reset();
+  }
+
+  CudaHandle(const CudaHandle&) = delete;
+  CudaHandle& operator=(const CudaHandle&) = delete;
+
+  CudaHandle& operator=(CudaHandle&& other) {
+    assert(this != &other);
+    reset();
+    std::swap(handle_, other.handle_);
+    return *this;
+  }
+
+  void reset() {
+    if (handle_ != nullptr) {
+      CHECK_CUDA_ERROR(Destroy(handle_));
+      handle_ = nullptr;
+    }
+  }
+
+  operator Handle() const {
+    return handle_;
+  }
+
+ protected:
+  Handle handle_;
+};
+
+// Wrappers of CUDA resources.
+class CudaGraph : public CudaHandle<cudaGraph_t, cudaGraphDestroy> {
+ public:
+  using CudaHandle::CudaHandle;
+  explicit CudaGraph(cu::Device& device);
+  void end_capture(cudaStream_t stream);
+};
+
+class CudaGraphExec : public CudaHandle<cudaGraphExec_t, cudaGraphExecDestroy> {
+ public:
+  void instantiate(cudaGraph_t graph);
+};
+
+class CudaStream : public CudaHandle<cudaStream_t, cudaStreamDestroy> {
+ public:
+  explicit CudaStream(cu::Device& device);
+};
+
+template <typename T>
+inline uint max_occupancy_block_dim(T kernel) {
+  int _, block_dim;
+  if constexpr (std::is_same_v<T, CUfunction>) {
+    CHECK_CUDA_ERROR(
+        cuOccupancyMaxPotentialBlockSize(&_, &block_dim, kernel, 0, 0, 0));
+  } else {
+    CHECK_CUDA_ERROR(
+        cudaOccupancyMaxPotentialBlockSize(&_, &block_dim, kernel));
+  }
+  return block_dim;
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/worker.cpp b/ml-stable-diffusion/mlx/mlx/backend/cuda/worker.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c468b850186a29481c03a0b0f6f7d9fb67b1ecb8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/worker.cpp
@@ -0,0 +1,79 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cuda/worker.h"
+#include "mlx/backend/cuda/device.h"
+
+namespace mlx::core::cu {
+
+Worker::Worker(Device& d)
+    : signal_stream_(d),
+      signal_event_(d, cudaEventDisableTiming | cudaEventBlockingSync),
+      worker_(&Worker::thread_fn, this) {}
+
+Worker::~Worker() {
+  {
+    std::lock_guard lock(mtx_);
+    stop_ = true;
+  }
+  cond_.notify_one();
+  worker_.join();
+}
+
+void Worker::add_task(std::function<void()> task) {
+  pending_tasks_.push_back(std::move(task));
+}
+
+void Worker::signal(void* data) {
+  auto w = static_cast<Worker*>(data);
+  {
+    std::lock_guard lock(w->mtx_);
+    w->signaled_batch_++;
+  }
+  w->cond_.notify_one();
+}
+
+void Worker::commit(cudaStream_t stream) {
+  // Move pending tasks into tasks
+  if (pending_tasks_.empty()) {
+    return;
+  }
+  {
+    std::lock_guard lock(mtx_);
+    // Move pending tasks into ready tasks
+    worker_tasks_[++committed_batch_] = std::move(pending_tasks_);
+  }
+  signal_event_.record(stream);
+  signal_event_.wait(signal_stream_);
+  cudaLaunchHostFunc(signal_stream_, signal, this);
+}
+
+void Worker::thread_fn() {
+  while (!stop_) {
+    uint64_t current_batch = 0;
+    Tasks tasks;
+    {
+      std::unique_lock<std::mutex> lk(mtx_);
+      cond_.wait(lk, [this, &current_batch] {
+        return this->signaled_batch_ > current_batch || this->stop_;
+      });
+      current_batch = signaled_batch_;
+      auto end = worker_tasks_.upper_bound(current_batch);
+      for (auto it = worker_tasks_.begin(); it != end; ++it) {
+        if (tasks.empty()) {
+          tasks = std::move(it->second);
+        } else {
+          std::move(
+              it->second.begin(), it->second.end(), std::back_inserter(tasks));
+        }
+      }
+      worker_tasks_.erase(worker_tasks_.begin(), end);
+    }
+    // Make sure tasks are cleared before the next wait
+    for (int i = 0; i < tasks.size(); ++i) {
+      auto task = std::move(tasks[i]);
+      task();
+    }
+  }
+}
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/cuda/worker.h b/ml-stable-diffusion/mlx/mlx/backend/cuda/worker.h
new file mode 100644
index 0000000000000000000000000000000000000000..8f05e7b97d4cded6290d8984514a1442ce2919fc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/cuda/worker.h
@@ -0,0 +1,55 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/cuda/event.h"
+
+#include <condition_variable>
+#include <functional>
+#include <map>
+#include <mutex>
+#include <thread>
+
+namespace mlx::core::cu {
+
+// Run tasks in worker thread, synchronized with cuda stream.
+class Worker {
+ public:
+  explicit Worker(Device& d);
+  ~Worker();
+
+  Worker(const Worker&) = delete;
+  Worker& operator=(const Worker&) = delete;
+
+  // Add a pending |task| that will run when consumed or commited.
+  void add_task(std::function<void()> task);
+
+  // Inform worker thread to run current batches after kernels in |stream|
+  // finish running.
+  void commit(cudaStream_t stream);
+
+ private:
+  static void signal(void*);
+
+  void thread_fn();
+  std::mutex mtx_;
+  std::condition_variable cond_;
+
+  uint64_t committed_batch_{0};
+  uint64_t signaled_batch_{0};
+
+  // Cuda stream and event for signaling kernel completion.
+  CudaStream signal_stream_;
+  CudaEvent signal_event_;
+
+  bool stop_{false};
+
+  // Tasks are put in |pending_tasks_| first, and then moved to
+  // |worker_tasks_| when end_batch() is called.
+  using Tasks = std::vector<std::function<void()>>;
+  Tasks pending_tasks_;
+  std::map<uint64_t, Tasks> worker_tasks_;
+  std::thread worker_;
+};
+
+} // namespace mlx::core::cu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/gpu/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/backend/gpu/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0396ae03a40977936669c6e96303a7d3fbca8a99
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/gpu/CMakeLists.txt
@@ -0,0 +1,5 @@
+target_sources(
+  mlx
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/copy.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/primitives.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/slicing.cpp)
diff --git a/ml-stable-diffusion/mlx/mlx/backend/gpu/available.h b/ml-stable-diffusion/mlx/mlx/backend/gpu/available.h
new file mode 100644
index 0000000000000000000000000000000000000000..476c7acf27c2c5e05744d9526ac91bb9cf4329ef
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/gpu/available.h
@@ -0,0 +1,9 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+namespace mlx::core::gpu {
+
+bool is_available();
+
+} // namespace mlx::core::gpu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/gpu/copy.cpp b/ml-stable-diffusion/mlx/mlx/backend/gpu/copy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..472ee486bd5d9437a2182eb5634c473201670e0e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/gpu/copy.cpp
@@ -0,0 +1,121 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/primitives.h"
+
+#include <cassert>
+
+namespace mlx::core {
+
+void copy_gpu(const array& in, array& out, CopyType ctype, const Stream& s) {
+  bool donated = set_copy_output_data(in, out, ctype);
+  if (donated && in.dtype() == out.dtype()) {
+    // If the output has the same type as the input then there is nothing to
+    // copy, just use the buffer.
+    return;
+  }
+  if (ctype == CopyType::GeneralGeneral) {
+    ctype = CopyType::General;
+  }
+  copy_gpu_inplace(in, out, ctype, s);
+}
+
+void copy_gpu(const array& in, array& out, CopyType ctype) {
+  copy_gpu(in, out, ctype, out.primitive().stream());
+}
+
+void copy_gpu_inplace(
+    const array& in,
+    array& out,
+    CopyType ctype,
+    const Stream& s) {
+  assert(in.shape() == out.shape());
+  return copy_gpu_inplace(
+      in, out, in.shape(), in.strides(), out.strides(), 0, 0, ctype, s);
+}
+
+void copy_gpu_inplace(
+    const array& in,
+    array& out,
+    const Strides& i_strides,
+    int64_t i_offset,
+    CopyType ctype,
+    const Stream& s) {
+  assert(in.shape() == out.shape());
+  return copy_gpu_inplace(
+      in, out, in.shape(), i_strides, out.strides(), i_offset, 0, ctype, s);
+}
+
+array contiguous_copy_gpu(const array& arr, const Stream& s) {
+  array arr_copy(arr.shape(), arr.dtype(), nullptr, {});
+  copy_gpu(arr, arr_copy, CopyType::General, s);
+  return arr_copy;
+}
+
+void reshape_gpu(const array& in, array& out, Stream s) {
+  auto [copy_necessary, out_strides] = prepare_reshape(in, out);
+  if (copy_necessary) {
+    out.set_data(allocator::malloc(out.nbytes()));
+    copy_gpu_inplace(
+        in,
+        out,
+        in.shape(),
+        in.strides(),
+        make_contiguous_strides(in.shape()),
+        0,
+        0,
+        CopyType::General,
+        s);
+  } else {
+    shared_buffer_reshape(in, out_strides, out);
+  }
+}
+
+array flatten_in_eval(const array& x, int start_axis, int end_axis, Stream s) {
+  int ndim = x.ndim();
+  if (start_axis < 0) {
+    start_axis += ndim;
+  }
+  if (end_axis < 0) {
+    end_axis += ndim;
+  }
+  start_axis = std::max(0, start_axis);
+  end_axis = std::min(ndim - 1, end_axis);
+
+  return reshape_in_eval(x, Flatten::output_shape(x, start_axis, end_axis), s);
+}
+
+array reshape_in_eval(const array& x, Shape shape, Stream s) {
+  array out(std::move(shape), x.dtype(), nullptr, {});
+  reshape_gpu(x, out, s);
+  return out;
+}
+
+array swapaxes_in_eval(const array& x, int axis1, int axis2) {
+  int ndim = x.ndim();
+  if (axis1 < 0) {
+    axis1 += ndim;
+  }
+  if (axis2 < 0) {
+    axis2 += ndim;
+  }
+
+  auto shape = x.shape();
+  std::swap(shape[axis1], shape[axis2]);
+  auto strides = x.strides();
+  std::swap(strides[axis1], strides[axis2]);
+
+  auto [data_size, row_contiguous, col_contiguous] =
+      check_contiguity(shape, strides);
+  bool contiguous = data_size == x.data_size();
+
+  array out(std::move(shape), x.dtype(), nullptr, {});
+  out.copy_shared_buffer(
+      x,
+      std::move(strides),
+      {contiguous, row_contiguous, col_contiguous},
+      x.data_size());
+  return out;
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/gpu/copy.h b/ml-stable-diffusion/mlx/mlx/backend/gpu/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e6bc7978d1177454faa81f862b5bae32e2dd94b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/gpu/copy.h
@@ -0,0 +1,57 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/common/copy.h"
+#include "mlx/stream.h"
+
+#include <optional>
+
+namespace mlx::core {
+
+// Generic copy inplace
+void copy_gpu_inplace(
+    const array& in,
+    array& out,
+    const Shape& data_shape,
+    const Strides& i_strides,
+    const Strides& o_strides,
+    int64_t i_offset,
+    int64_t o_offset,
+    CopyType ctype,
+    const Stream& s,
+    std::optional<array> dynamic_i_offset = std::nullopt,
+    std::optional<array> dynamic_o_offset = std::nullopt);
+
+void copy_gpu(const array& src, array& out, CopyType ctype, const Stream& s);
+void copy_gpu(const array& src, array& out, CopyType ctype);
+
+void copy_gpu_inplace(
+    const array& in,
+    array& out,
+    CopyType ctype,
+    const Stream& s);
+
+void copy_gpu_inplace(
+    const array& in,
+    array& out,
+    const Strides& i_strides,
+    int64_t i_offset,
+    CopyType ctype,
+    const Stream& s);
+
+// Fill the output with the scalar val
+void fill_gpu(const array& val, array& out, const Stream& s);
+
+// Return a contiguous array with same shape that copies the data of |arr|.
+array contiguous_copy_gpu(const array& arr, const Stream& s);
+
+// Copy data from |in| and transpose to |out|'s shape.
+void reshape_gpu(const array& in, array& out, Stream s);
+
+// Like the normal ops but safe to call in eval_gpu.
+array flatten_in_eval(const array& x, int start_axis, int end_axis, Stream s);
+array reshape_in_eval(const array& x, Shape shape, Stream s);
+array swapaxes_in_eval(const array& x, int axis1, int axis2);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h b/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
new file mode 100644
index 0000000000000000000000000000000000000000..f646c2ec9d5151d710b88134c8afb4ecbbe610aa
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/gpu/eval.h
@@ -0,0 +1,18 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <future>
+#include <memory>
+
+#include "mlx/array.h"
+#include "mlx/stream.h"
+
+namespace mlx::core::gpu {
+
+void new_stream(Stream stream);
+void eval(array& arr);
+void finalize(Stream s);
+void synchronize(Stream s);
+
+} // namespace mlx::core::gpu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/gpu/primitives.cpp b/ml-stable-diffusion/mlx/mlx/backend/gpu/primitives.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ee40799df66a8d2b3e98dc3f0df5e521071d3aea
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/gpu/primitives.cpp
@@ -0,0 +1,307 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/primitives.h"
+#include "mlx/backend/common/slicing.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/gpu/slicing.h"
+
+#if defined(MLX_USE_CUDA)
+#include <nvtx3/nvtx3.hpp>
+#endif
+
+#include <cassert>
+
+#if defined(MLX_USE_CUDA)
+#define MLX_PROFILER_RANGE(message) nvtx3::scoped_range r(message)
+#else
+#define MLX_PROFILER_RANGE(message)
+#endif
+
+namespace mlx::core {
+
+void AsStrided::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("AsStrided::eval_gpu");
+  eval(inputs, out);
+}
+
+void AsType::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("AsType::eval_gpu");
+  CopyType ctype =
+      inputs[0].flags().contiguous ? CopyType::Vector : CopyType::General;
+  copy_gpu(inputs[0], out, ctype);
+}
+
+void Broadcast::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("Broadcast::eval_gpu");
+  eval(inputs, out);
+}
+
+void BroadcastAxes::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("BroadcastAxes::eval_gpu");
+  eval(inputs, out);
+}
+
+void Concatenate::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("Concatenate::eval_gpu");
+  concatenate_gpu(inputs, out, axis_, stream());
+}
+
+void Contiguous::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("Contiguous::eval_gpu");
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  constexpr size_t extra_bytes = 16384;
+  if (in.buffer_size() <= out.nbytes() + extra_bytes &&
+      (in.flags().row_contiguous ||
+       (allow_col_major_ && in.flags().col_contiguous))) {
+    out.copy_shared_buffer(in);
+  } else {
+    copy_gpu(in, out, CopyType::General);
+  }
+}
+
+void Copy::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("Copy::eval_gpu");
+  eval(inputs, out);
+}
+
+void CustomTransforms::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  MLX_PROFILER_RANGE("CustomTransforms::eval_gpu");
+  eval(inputs, outputs);
+}
+
+void Depends::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  MLX_PROFILER_RANGE("Depends::eval_gpu");
+  eval(inputs, outputs);
+}
+
+void DynamicSlice::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("DynamicSlice::eval_gpu");
+  if (out.size() == 0) {
+    out.set_data(nullptr);
+    return;
+  }
+
+  auto& in = inputs[0];
+  auto& start = inputs[1];
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto s = stream();
+  auto in_offset = compute_dynamic_offset(start, in.strides(), axes_, s);
+  copy_gpu_inplace(
+      /* const array& src = */ in,
+      /* array& dst = */ out,
+      /* const Shape& data_shape = */ out.shape(),
+      /* const Strides& i_strides = */ in.strides(),
+      /* const Strides& o_strides = */ out.strides(),
+      /* int64_t i_offset = */ 0,
+      /* int64_t o_offset = */ 0,
+      /* CopyType ctype = */ CopyType::GeneralGeneral,
+      /* const Stream& s = */ s,
+      /* std::optional<array> dynamic_i_offset = */ std::move(in_offset),
+      /* std::optional<array> dynamic_o_offset = */ std::nullopt);
+}
+
+void DynamicSliceUpdate::eval_gpu(
+    const std::vector<array>& inputs,
+    array& out) {
+  MLX_PROFILER_RANGE("DynamicSliceUpdate::eval_gpu");
+  if (out.size() == 0) {
+    out.set_data(nullptr);
+    return;
+  }
+
+  auto& in = inputs[0];
+  auto& upd = inputs[1];
+  auto& start_indices = inputs[2];
+
+  if (upd.size() == 0) {
+    out.copy_shared_buffer(in);
+    return;
+  }
+
+  // Copy or donate input to output
+  auto s = stream();
+  auto ctype = in.flags().contiguous && in.size() == in.data_size()
+      ? CopyType::Vector
+      : CopyType::General;
+  copy_gpu(in, out, in.data_size() == 1 ? CopyType::Scalar : ctype, s);
+
+  auto out_offset =
+      compute_dynamic_offset(start_indices, out.strides(), axes_, s);
+  copy_gpu_inplace(
+      /* const array& src = */ upd,
+      /* array& dst = */ out,
+      /* const Shape& data_shape = */ upd.shape(),
+      /* const Strides& i_strides = */ upd.strides(),
+      /* const Strides& o_strides = */ out.strides(),
+      /* int64_t i_offset = */ 0,
+      /* int64_t o_offset = */ 0,
+      /* CopyType ctype = */ CopyType::GeneralGeneral,
+      /* const Stream& s = */ s,
+      /* std::optional<array> dynamic_i_offset = */ std::nullopt,
+      /* std::optional<array> dynamic_o_offset = */ std::move(out_offset));
+}
+
+void ExpandDims::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("ExpandDims::eval_gpu");
+  eval(inputs, out);
+}
+
+void Full::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("Full::eval_gpu");
+  auto in = inputs[0];
+  CopyType ctype;
+  if (in.data_size() == 1) {
+    ctype = CopyType::Scalar;
+  } else if (in.flags().contiguous) {
+    ctype = CopyType::Vector;
+  } else {
+    ctype = CopyType::General;
+  }
+  copy_gpu(in, out, ctype);
+}
+
+void Flatten::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("Flatten::eval_gpu");
+  reshape_gpu(inputs[0], out, stream());
+}
+
+void NumberOfElements::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("NumberOfElements::eval_gpu");
+  eval(inputs, out);
+}
+
+void Pad::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("Pad::eval_gpu");
+  // Inputs must be base input array and scalar val array
+  assert(inputs.size() == 2);
+  auto& in = inputs[0];
+  auto& val = inputs[1];
+
+  // Padding value must be a scalar
+  assert(val.size() == 1);
+
+  // Padding value, input and output must be of the same type
+  assert(val.dtype() == in.dtype() && in.dtype() == out.dtype());
+
+  pad_gpu(in, val, out, axes_, low_pad_size_, stream());
+}
+
+void Reshape::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("Reshape::eval_gpu");
+  reshape_gpu(inputs[0], out, stream());
+}
+
+void Split::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  MLX_PROFILER_RANGE("Split::eval_gpu");
+  eval(inputs, outputs);
+}
+
+void Slice::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("Slice::eval_gpu");
+  assert(inputs.size() == 1);
+  if (out.size() == 0) {
+    out.set_data(nullptr);
+    return;
+  }
+
+  auto& in = inputs[0];
+  slice_gpu(in, out, start_indices_, strides_, stream());
+}
+
+void SliceUpdate::eval_gpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  if (out.size() == 0) {
+    out.set_data(nullptr);
+    return;
+  }
+
+  auto& in = inputs[0];
+  auto& upd = inputs[1];
+
+  if (upd.size() == 0) {
+    out.copy_shared_buffer(in);
+    return;
+  }
+
+  auto ctype = in.flags().contiguous && in.size() == in.data_size()
+      ? CopyType::Vector
+      : CopyType::General;
+  copy_gpu(in, out, in.data_size() == 1 ? CopyType::Scalar : ctype, stream());
+  auto [data_offset, out_strides] =
+      prepare_slice(out, start_indices_, strides_);
+
+  // Do copy
+  copy_gpu_inplace(
+      /* const array& src = */ upd,
+      /* array& dst = */ out,
+      /* const Shape& data_shape = */ upd.shape(),
+      /* const Strides& i_strides = */ upd.strides(),
+      /* const Strides& o_strides = */ out_strides,
+      /* int64_t i_offset = */ 0,
+      /* int64_t o_offset = */ data_offset,
+      /* CopyType ctype = */ CopyType::GeneralGeneral,
+      /* const Stream& s = */ stream());
+}
+
+void Squeeze::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("Squeeze::eval_gpu");
+  eval(inputs, out);
+}
+
+void StopGradient::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("StopGradient::eval_gpu");
+  eval(inputs, out);
+}
+
+void Transpose::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("Transpose::eval_gpu");
+  eval(inputs, out);
+}
+
+void Unflatten::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("Unflatten::eval_gpu");
+  reshape_gpu(inputs[0], out, stream());
+}
+
+void View::eval_gpu(const std::vector<array>& inputs, array& out) {
+  MLX_PROFILER_RANGE("View::eval_gpu");
+  auto& in = inputs[0];
+  auto ibytes = size_of(in.dtype());
+  auto obytes = size_of(out.dtype());
+  // Conditions for buffer copying (disjunction):
+  // - type size is the same
+  // - type size is smaller and the last axis is contiguous
+  // - the entire array is row contiguous
+  if (ibytes == obytes || (obytes < ibytes && in.strides().back() == 1) ||
+      in.flags().row_contiguous) {
+    auto strides = in.strides();
+    for (int i = 0; i < static_cast<int>(strides.size()) - 1; ++i) {
+      strides[i] *= ibytes;
+      strides[i] /= obytes;
+    }
+    out.copy_shared_buffer(
+        in, strides, in.flags(), in.data_size() * ibytes / obytes);
+  } else {
+    auto tmp = array(in.shape(), in.dtype(), nullptr, {});
+    tmp.set_data(allocator::malloc(tmp.nbytes()));
+    copy_gpu_inplace(in, tmp, CopyType::General, stream());
+
+    auto flags = out.flags();
+    flags.contiguous = true;
+    flags.row_contiguous = true;
+    auto max_dim = std::max_element(out.shape().begin(), out.shape().end());
+    flags.col_contiguous = out.size() <= 1 || out.size() == *max_dim;
+    out.copy_shared_buffer(tmp, out.strides(), flags, out.size());
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/gpu/slicing.cpp b/ml-stable-diffusion/mlx/mlx/backend/gpu/slicing.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fde2a01cd61cab42b35c6070682f489ce45135a4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/gpu/slicing.cpp
@@ -0,0 +1,44 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/common/slicing.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/gpu/slicing.h"
+
+namespace mlx::core {
+
+void slice_gpu(
+    const array& in,
+    array& out,
+    const Shape& start_indices,
+    const Shape& strides,
+    const Stream& s) {
+  slice(in, out, start_indices, strides);
+}
+
+void pad_gpu(
+    const array& in,
+    const array& val,
+    array& out,
+    const std::vector<int>& axes,
+    const Shape& low_pad_size,
+    const Stream& s) {
+  // Fill output with val
+  fill_gpu(val, out, s);
+
+  // Find offset for start of input values
+  size_t data_offset = 0;
+  for (int i = 0; i < axes.size(); i++) {
+    auto ax = axes[i] < 0 ? out.ndim() + axes[i] : axes[i];
+    data_offset += out.strides()[ax] * low_pad_size[i];
+  }
+
+  // Extract slice from output where input will be pasted
+  array out_slice(in.shape(), out.dtype(), nullptr, {});
+  out_slice.copy_shared_buffer(
+      out, out.strides(), out.flags(), out_slice.size(), data_offset);
+
+  // Copy input values into the slice
+  copy_gpu_inplace(in, out_slice, CopyType::GeneralGeneral, s);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/gpu/slicing.h b/ml-stable-diffusion/mlx/mlx/backend/gpu/slicing.h
new file mode 100644
index 0000000000000000000000000000000000000000..596f7afa54e0593590235afdf71314ce1ec63ac8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/gpu/slicing.h
@@ -0,0 +1,36 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+void slice_gpu(
+    const array& in,
+    array& out,
+    const Shape& start_indices,
+    const Shape& strides,
+    const Stream& s);
+
+void concatenate_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    int axis,
+    const Stream& s);
+
+void pad_gpu(
+    const array& in,
+    const array& val,
+    array& out,
+    const std::vector<int>& axes,
+    const Shape& low_pad_size,
+    const Stream& s);
+
+array compute_dynamic_offset(
+    const array& indices,
+    const Strides& strides,
+    const std::vector<int>& axes,
+    const Stream& s);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/backend/metal/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..16225e181f77ae3592bedc35f926a9a26a488028
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/CMakeLists.txt
@@ -0,0 +1,131 @@
+function(make_jit_source SRC_FILE)
+  # This function takes a metal header file, runs the C preprocessesor on it,
+  # and makes the processed contents available as a string in a C++ function
+  # mlx::core::metal::${SRC_NAME}()
+  #
+  # To use the function, declare it in jit/includes.h and include
+  # jit/includes.h.
+  #
+  # Additional arguments to this function are treated as dependencies in the
+  # Cmake build system.
+  get_filename_component(SRC_NAME ${SRC_FILE} NAME)
+  add_custom_command(
+    OUTPUT jit/${SRC_NAME}.cpp
+    COMMAND
+      bash ${CMAKE_CURRENT_SOURCE_DIR}/make_compiled_preamble.sh
+      ${CMAKE_CURRENT_BINARY_DIR}/jit ${CMAKE_C_COMPILER} ${PROJECT_SOURCE_DIR}
+      ${SRC_FILE}
+    DEPENDS make_compiled_preamble.sh kernels/${SRC_FILE}.h ${ARGN})
+  add_custom_target(${SRC_NAME} DEPENDS jit/${SRC_NAME}.cpp)
+  add_dependencies(mlx ${SRC_NAME})
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/jit/${SRC_NAME}.cpp)
+endfunction(make_jit_source)
+
+make_jit_source(
+  utils
+  kernels/jit/bf16.h
+  kernels/metal_3_0/bf16.h
+  kernels/metal_3_1/bf16.h
+  kernels/bf16_math.h
+  kernels/complex.h
+  kernels/defines.h)
+make_jit_source(unary_ops kernels/erf.h kernels/expm1f.h)
+make_jit_source(binary_ops)
+make_jit_source(ternary_ops)
+make_jit_source(reduce_utils kernels/atomic.h kernels/reduction/ops.h)
+make_jit_source(indexing/scatter kernels/indexing/indexing.h)
+make_jit_source(indexing/gather kernels/indexing/indexing.h)
+make_jit_source(indexing/gather_front kernels/indexing/indexing.h)
+make_jit_source(indexing/gather_axis)
+make_jit_source(indexing/scatter_axis)
+make_jit_source(hadamard)
+
+if(MLX_METAL_JIT)
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/jit_kernels.cpp)
+  make_jit_source(arange)
+  make_jit_source(copy)
+  make_jit_source(unary)
+  make_jit_source(binary)
+  make_jit_source(binary_two)
+  make_jit_source(fft kernels/fft/radix.h kernels/fft/readwrite.h)
+  make_jit_source(logsumexp)
+  make_jit_source(ternary)
+  make_jit_source(softmax)
+  make_jit_source(scan)
+  make_jit_source(sort)
+  make_jit_source(
+    reduce kernels/reduction/reduce_all.h kernels/reduction/reduce_col.h
+    kernels/reduction/reduce_row.h kernels/reduction/reduce_init.h)
+  make_jit_source(
+    steel/gemm/gemm kernels/steel/utils.h kernels/steel/gemm/loader.h
+    kernels/steel/gemm/mma.h kernels/steel/gemm/params.h
+    kernels/steel/gemm/transforms.h)
+  make_jit_source(steel/gemm/kernels/steel_gemm_fused)
+  make_jit_source(steel/gemm/kernels/steel_gemm_masked kernels/steel/defines.h)
+  make_jit_source(steel/gemm/kernels/steel_gemm_gather)
+  make_jit_source(steel/gemm/kernels/steel_gemm_splitk)
+  make_jit_source(steel/gemm/kernels/steel_gemm_segmented)
+  make_jit_source(
+    steel/conv/conv
+    kernels/steel/utils.h
+    kernels/steel/defines.h
+    kernels/steel/gemm/mma.h
+    kernels/steel/gemm/transforms.h
+    kernels/steel/conv/params.h
+    kernels/steel/conv/loader.h
+    kernels/steel/conv/loaders/loader_channel_l.h
+    kernels/steel/conv/loaders/loader_channel_n.h)
+  make_jit_source(steel/conv/kernels/steel_conv)
+  make_jit_source(steel/conv/kernels/steel_conv_general kernels/steel/defines.h
+                  kernels/steel/conv/loaders/loader_general.h)
+
+  make_jit_source(quantized_utils)
+  make_jit_source(quantized kernels/quantized_utils.h)
+  make_jit_source(fp4_quantized kernels/quantized_utils.h)
+  make_jit_source(gemv_masked)
+else()
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/nojit_kernels.cpp)
+endif()
+
+target_sources(
+  mlx
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/allocator.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/binary.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/compiled.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/conv.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/copy.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/custom_kernel.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/distributed.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/device.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/event.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/eval.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/fence.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/fft.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/hadamard.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/indexing.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/logsumexp.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/matmul.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/scaled_dot_product_attention.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/metal.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/primitives.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/quantized.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/normalization.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/rope.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/scan.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/slicing.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/softmax.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/sort.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/reduce.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/ternary.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/unary.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/resident.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/utils.cpp)
+
+if(NOT MLX_METAL_PATH)
+  set(MLX_METAL_PATH ${CMAKE_CURRENT_BINARY_DIR}/kernels/)
+endif()
+
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/kernels)
+
+target_compile_definitions(mlx
+                           PRIVATE METAL_PATH="${MLX_METAL_PATH}/mlx.metallib")
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/allocator.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/allocator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8eb70bcbca37957685f56d760d855c8b27ed3c52
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/allocator.cpp
@@ -0,0 +1,248 @@
+// Copyright © 2023-2024 Apple Inc.
+#include "mlx/backend/metal/allocator.h"
+#include "mlx/backend/metal/metal.h"
+#include "mlx/backend/metal/resident.h"
+#include "mlx/memory.h"
+
+#include <mach/vm_page_size.h>
+#include <unistd.h>
+#include <cstdlib>
+
+namespace mlx::core {
+
+constexpr size_t resource_options =
+    MTL::ResourceStorageModeShared | MTL::ResourceHazardTrackingModeUntracked;
+
+namespace allocator {
+
+Allocator& allocator() {
+  return metal::allocator();
+}
+
+void* Buffer::raw_ptr() {
+  if (!ptr_) {
+    return nullptr;
+  }
+  return static_cast<MTL::Buffer*>(ptr_)->contents();
+}
+
+} // namespace allocator
+
+namespace metal {
+
+MetalAllocator::MetalAllocator()
+    : device_(device(mlx::core::Device::gpu).mtl_device()),
+      residency_set_(device_),
+      buffer_cache_(
+          vm_page_size,
+          [](MTL::Buffer* buf) { return buf->length(); },
+          [this](MTL::Buffer* buf) {
+            if (!buf->heap()) {
+              residency_set_.erase(buf);
+            }
+            buf->release();
+          }) {
+  auto pool = metal::new_scoped_memory_pool();
+  auto memsize = std::get<size_t>(device_info().at("memory_size"));
+  auto max_rec_size =
+      std::get<size_t>(device_info().at("max_recommended_working_set_size"));
+  resource_limit_ = std::get<size_t>(device_info().at("resource_limit"));
+  block_limit_ = std::min(1.5 * max_rec_size, 0.95 * memsize);
+  gc_limit_ = std::min(static_cast<size_t>(0.95 * max_rec_size), block_limit_);
+  max_pool_size_ = block_limit_;
+  device(mlx::core::Device::gpu)
+      .set_residency_set(residency_set_.mtl_residency_set());
+  bool is_vm = std::get<std::string>(device_info().at("device_name")) ==
+      "Apple Paravirtual device";
+  if (is_vm) {
+    return;
+  }
+  auto heap_desc = MTL::HeapDescriptor::alloc()->init();
+  heap_desc->setResourceOptions(resource_options);
+  heap_desc->setSize(heap_size_);
+  heap_ = device_->newHeap(heap_desc);
+  heap_desc->release();
+  residency_set_.insert(heap_);
+}
+
+MetalAllocator::~MetalAllocator() {
+  auto pool = metal::new_scoped_memory_pool();
+  if (heap_) {
+    heap_->release();
+  }
+  buffer_cache_.clear();
+}
+
+size_t MetalAllocator::set_cache_limit(size_t limit) {
+  std::unique_lock lk(mutex_);
+  std::swap(limit, max_pool_size_);
+  return limit;
+};
+
+size_t MetalAllocator::set_memory_limit(size_t limit) {
+  std::unique_lock lk(mutex_);
+  std::swap(limit, block_limit_);
+  gc_limit_ = std::min(
+      block_limit_,
+      static_cast<size_t>(0.95 * device_->recommendedMaxWorkingSetSize()));
+  return limit;
+};
+
+size_t MetalAllocator::get_memory_limit() {
+  return block_limit_;
+}
+
+size_t MetalAllocator::set_wired_limit(size_t limit) {
+  std::unique_lock lk(mutex_);
+  std::swap(limit, wired_limit_);
+  residency_set_.resize(wired_limit_);
+  return limit;
+};
+
+Buffer MetalAllocator::malloc(size_t size) {
+  // Metal doesn't like empty buffers
+  if (size == 0) {
+    return Buffer{nullptr};
+  }
+
+  // More helpful message if maximum buffer length is exceeded
+  if (size > device_->maxBufferLength()) {
+    std::ostringstream msg;
+    msg << "[metal::malloc] Attempting to allocate " << size
+        << " bytes which is greater than"
+        << " the maximum allowed buffer size of " << device_->maxBufferLength()
+        << " bytes.";
+    throw std::runtime_error(msg.str());
+  }
+
+  // Align up memory
+  if (size > vm_page_size) {
+    size = vm_page_size * ((size + vm_page_size - 1) / vm_page_size);
+  }
+
+  // Try the cache
+  std::unique_lock lk(mutex_);
+  MTL::Buffer* buf = buffer_cache_.reuse_from_cache(size);
+  if (!buf) {
+    size_t mem_required = get_active_memory() + get_cache_memory() + size;
+
+    auto pool = metal::new_scoped_memory_pool();
+
+    // If we have a lot of memory pressure try to reclaim memory from the cache
+    if (mem_required >= gc_limit_ || num_resources_ >= resource_limit_) {
+      num_resources_ -=
+          buffer_cache_.release_cached_buffers(mem_required - gc_limit_);
+    }
+
+    // Allocate new buffer if needed
+    if (num_resources_ >= resource_limit_) {
+      std::ostringstream msg;
+      msg << "[metal::malloc] Resource limit (" << resource_limit_
+          << ") exceeded.";
+      throw std::runtime_error(msg.str());
+    }
+    lk.unlock();
+    if (size < small_size_ && heap_) {
+      buf = heap_->newBuffer(size, resource_options);
+    }
+    if (!buf) {
+      buf = device_->newBuffer(size, resource_options);
+    }
+    if (!buf) {
+      return Buffer{nullptr};
+    }
+    lk.lock();
+    num_resources_++;
+    if (!buf->heap()) {
+      residency_set_.insert(buf);
+    }
+  }
+
+  active_memory_ += buf->length();
+  peak_memory_ = std::max(peak_memory_, active_memory_);
+
+  // Maintain the cache below the requested limit
+  if (get_cache_memory() > max_pool_size_) {
+    auto pool = metal::new_scoped_memory_pool();
+    num_resources_ -= buffer_cache_.release_cached_buffers(
+        get_cache_memory() - max_pool_size_);
+  }
+
+  return Buffer{static_cast<void*>(buf)};
+}
+
+void MetalAllocator::clear_cache() {
+  std::unique_lock lk(mutex_);
+  auto pool = metal::new_scoped_memory_pool();
+  num_resources_ -= buffer_cache_.clear();
+}
+
+void MetalAllocator::free(Buffer buffer) {
+  auto buf = static_cast<MTL::Buffer*>(buffer.ptr());
+  if (buf == nullptr) {
+    return;
+  }
+  std::unique_lock lk(mutex_);
+  active_memory_ -= buf->length();
+  if (get_cache_memory() < max_pool_size_) {
+    buffer_cache_.recycle_to_cache(buf);
+  } else {
+    num_resources_--;
+    if (!buf->heap()) {
+      residency_set_.erase(buf);
+    }
+    lk.unlock();
+    auto pool = metal::new_scoped_memory_pool();
+    buf->release();
+  }
+}
+
+size_t MetalAllocator::size(Buffer buffer) const {
+  return static_cast<MTL::Buffer*>(buffer.ptr())->length();
+}
+
+MetalAllocator& allocator() {
+  // By creating the |allocator_| on heap, the destructor of MetalAllocator
+  // will not be called on exit and buffers in the cache will be leaked. This
+  // can save some time at program exit.
+  static MetalAllocator* allocator_ = new MetalAllocator;
+  return *allocator_;
+}
+
+} // namespace metal
+
+size_t set_cache_limit(size_t limit) {
+  return metal::allocator().set_cache_limit(limit);
+}
+size_t set_memory_limit(size_t limit) {
+  return metal::allocator().set_memory_limit(limit);
+}
+size_t get_memory_limit() {
+  return metal::allocator().get_memory_limit();
+}
+size_t set_wired_limit(size_t limit) {
+  if (limit > std::get<size_t>(metal::device_info().at(
+                  "max_recommended_working_set_size"))) {
+    throw std::invalid_argument(
+        "[metal::set_wired_limit] Setting a wired limit larger than "
+        "the maximum working set size is not allowed.");
+  }
+  return metal::allocator().set_wired_limit(limit);
+}
+size_t get_active_memory() {
+  return metal::allocator().get_active_memory();
+}
+size_t get_peak_memory() {
+  return metal::allocator().get_peak_memory();
+}
+void reset_peak_memory() {
+  metal::allocator().reset_peak_memory();
+}
+size_t get_cache_memory() {
+  return metal::allocator().get_cache_memory();
+}
+void clear_cache() {
+  return metal::allocator().clear_cache();
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/allocator.h b/ml-stable-diffusion/mlx/mlx/backend/metal/allocator.h
new file mode 100644
index 0000000000000000000000000000000000000000..691317916cbff429abc1b01350745842681aeb26
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/allocator.h
@@ -0,0 +1,77 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <map>
+#include <mutex>
+#include <vector>
+
+#include "mlx/allocator.h"
+#include "mlx/backend/common/buffer_cache.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/resident.h"
+
+namespace mlx::core::metal {
+
+using allocator::Buffer;
+
+class MetalAllocator : public allocator::Allocator {
+  /** Allocator for Metal GPUs. */
+ public:
+  virtual Buffer malloc(size_t size) override;
+  virtual void free(Buffer buffer) override;
+  virtual size_t size(Buffer buffer) const override;
+  size_t get_active_memory() {
+    return active_memory_;
+  };
+  size_t get_peak_memory() {
+    return peak_memory_;
+  };
+  void reset_peak_memory() {
+    std::unique_lock lk(mutex_);
+    peak_memory_ = 0;
+  };
+  size_t get_cache_memory() {
+    return buffer_cache_.cache_size();
+  };
+  size_t set_cache_limit(size_t limit);
+  size_t set_memory_limit(size_t limit);
+  size_t get_memory_limit();
+  size_t set_wired_limit(size_t limit);
+  void clear_cache();
+
+ private:
+  MTL::Device* device_;
+
+  // The size of allocations which go on the heap until it is full. This size
+  // is chosen because it is the actual minimum size of a buffer allocated from
+  // the heap, a heap can have at most heap.size() / 256 buffers.
+  static constexpr int small_size_ = 256;
+  static constexpr int heap_size_ = 1 << 20;
+  MTL::Heap* heap_;
+  MetalAllocator();
+  ~MetalAllocator();
+  friend MetalAllocator& allocator();
+
+  // Caching allocator
+  BufferCache<MTL::Buffer> buffer_cache_;
+
+  ResidencySet residency_set_;
+
+  // Allocation stats
+  size_t block_limit_;
+  size_t gc_limit_;
+  size_t active_memory_{0};
+  size_t peak_memory_{0};
+  size_t max_pool_size_;
+  size_t wired_limit_{0};
+  bool relaxed_{true};
+  size_t num_resources_{0};
+  size_t resource_limit_{0};
+
+  std::mutex mutex_;
+};
+
+MetalAllocator& allocator();
+
+} // namespace mlx::core::metal
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/binary.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/binary.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8c0e8c33325e7330af0de81247c3f5e4f2b95f13
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/binary.cpp
@@ -0,0 +1,257 @@
+// Copyright © 2024 Apple Inc.
+#include "mlx/backend/common/binary.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+
+#define BINARY_GPU(func)                                              \
+  void func::eval_gpu(const std::vector<array>& inputs, array& out) { \
+    binary_op_gpu(inputs, out, name());                               \
+  }
+
+#define BINARY_GPU_MULTI(func)                                         \
+  void func::eval_gpu(                                                 \
+      const std::vector<array>& inputs, std::vector<array>& outputs) { \
+    binary_op_gpu(inputs, outputs, name());                            \
+  }
+
+namespace mlx::core {
+
+std::string get_kernel_name(
+    BinaryOpType bopt,
+    const char* op,
+    const array& a,
+    bool large,
+    int ndim,
+    int work_per_thread) {
+  std::string kname;
+  switch (bopt) {
+    case BinaryOpType::ScalarScalar:
+      kname = "ss";
+      break;
+    case BinaryOpType::ScalarVector:
+      kname = "sv";
+      break;
+    case BinaryOpType::VectorScalar:
+      kname = "vs";
+      break;
+    case BinaryOpType::VectorVector:
+      kname = "vv";
+      break;
+    case BinaryOpType::General:
+      kname = "g";
+      if (ndim <= 3) {
+        kname += std::to_string(ndim);
+      } else {
+        concatenate(kname, "n", std::to_string(work_per_thread));
+      }
+      if (large) {
+        kname += "large";
+      }
+      break;
+  }
+  if (bopt != BinaryOpType::General && bopt != BinaryOpType::ScalarScalar) {
+    if (large) {
+      kname += "2";
+    } else if (work_per_thread > 1) {
+      kname += "n";
+    }
+  }
+  concatenate(kname, "_", op, type_to_name(a));
+  return kname;
+}
+
+void binary_op_gpu_inplace(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs,
+    const char* op,
+    const Stream& s) {
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  auto bopt = get_binary_op_type(a, b);
+
+  auto& out = outputs[0];
+  if (out.size() == 0) {
+    return;
+  }
+
+  // Try to collapse contiguous dims
+  auto maybe_collapse = [bopt, &a, &b, &out]() {
+    if (bopt == BinaryOpType::General) {
+      auto [shape, strides] = collapse_contiguous_dims(a, b, out);
+      return std::make_tuple(shape, strides[0], strides[1], strides[2]);
+    } else {
+      decltype(a.strides()) e{};
+      return std::make_tuple(decltype(a.shape()){}, e, e, e);
+    }
+  };
+  auto [shape, strides_a, strides_b, strides_out] = maybe_collapse();
+
+  bool large;
+  auto ndim = shape.size();
+  int work_per_thread;
+  if (bopt == BinaryOpType::General) {
+    large = a.data_size() > INT32_MAX || b.data_size() > INT32_MAX ||
+        out.size() > INT32_MAX;
+    work_per_thread = large ? 4 : 2;
+  } else {
+    large = out.data_size() > UINT32_MAX;
+    work_per_thread = get_work_per_thread(a.dtype(), out.data_size());
+  }
+  std::string kernel_name =
+      get_kernel_name(bopt, op, a, large, shape.size(), work_per_thread);
+  auto& d = metal::device(s.device);
+
+  auto kernel = outputs.size() == 2
+      ? get_binary_two_kernel(d, kernel_name, a.dtype(), out.dtype(), op)
+      : get_binary_kernel(d, kernel_name, a.dtype(), out.dtype(), op);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  int arg_idx = 0;
+  compute_encoder.set_input_array(a, arg_idx++);
+  compute_encoder.set_input_array(b, arg_idx++);
+  compute_encoder.set_output_array(outputs[0], arg_idx++);
+  if (outputs.size() == 2) {
+    compute_encoder.set_output_array(outputs[1], arg_idx++);
+  }
+
+  auto thread_group_size = kernel->maxTotalThreadsPerThreadgroup();
+  if (bopt == BinaryOpType::General) {
+    // Launch up to 3D grid of threads
+    size_t dim0 = ndim > 0 ? shape[ndim - 1] : 1;
+    size_t dim1 = ndim > 1 ? shape[ndim - 2] : 1;
+    size_t rest = out.size() / (dim0 * dim1);
+
+    if (ndim > 3) {
+      compute_encoder.set_vector_bytes(shape, arg_idx++);
+      compute_encoder.set_vector_bytes(strides_a, arg_idx++);
+      compute_encoder.set_vector_bytes(strides_b, arg_idx++);
+      compute_encoder.set_bytes<int>(ndim, arg_idx++);
+      dim0 = (dim0 + work_per_thread - 1) / work_per_thread;
+    } else {
+      // The shape is implicit in the grid for <= 3D
+      compute_encoder.set_vector_bytes(strides_a, arg_idx++);
+      compute_encoder.set_vector_bytes(strides_b, arg_idx++);
+    }
+
+    if (thread_group_size != 1024) {
+      throw std::runtime_error("[Metal::binary] Must use 1024 sized block");
+    }
+    auto group_dims = get_block_dims(dim0, dim1, rest);
+    MTL::Size grid_dims = MTL::Size(dim0, dim1, rest);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  } else {
+    // Launch a 1D or 2D grid of threads
+    size_t nthreads = ceildiv(out.data_size(), work_per_thread);
+    if (thread_group_size > nthreads) {
+      thread_group_size = nthreads;
+    }
+
+    MTL::Size group_dims = MTL::Size(thread_group_size, 1, 1);
+    MTL::Size grid_dims;
+    if (large) {
+      compute_encoder.set_bytes<int64_t>(out.data_size(), arg_idx++);
+      grid_dims = get_2d_grid_dims(out.shape(), out.strides(), work_per_thread);
+    } else {
+      compute_encoder.set_bytes<int>(out.data_size(), arg_idx++);
+      grid_dims = MTL::Size(nthreads, 1, 1);
+    }
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+}
+
+void binary_op_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs,
+    const char* op,
+    const Stream& s) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  auto bopt = get_binary_op_type(a, b);
+  set_binary_op_output_data(a, b, outputs[0], bopt);
+  set_binary_op_output_data(a, b, outputs[1], bopt);
+  binary_op_gpu_inplace(inputs, outputs, op, s);
+}
+
+void binary_op_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs,
+    const char* op) {
+  auto& s = outputs[0].primitive().stream();
+  binary_op_gpu(inputs, outputs, op, s);
+}
+
+void binary_op_gpu_inplace(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s) {
+  std::vector<array> outputs = {out};
+  binary_op_gpu_inplace(inputs, outputs, op, s);
+}
+
+void binary_op_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s) {
+  assert(inputs.size() == 2);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  auto bopt = get_binary_op_type(a, b);
+  set_binary_op_output_data(a, b, out, bopt);
+  binary_op_gpu_inplace(inputs, out, op, s);
+}
+
+void binary_op_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op) {
+  auto& s = out.primitive().stream();
+  binary_op_gpu(inputs, out, op, s);
+}
+
+BINARY_GPU(Add)
+BINARY_GPU(ArcTan2)
+BINARY_GPU(Divide)
+BINARY_GPU_MULTI(DivMod)
+BINARY_GPU(Remainder)
+BINARY_GPU(Equal)
+BINARY_GPU(Greater)
+BINARY_GPU(GreaterEqual)
+BINARY_GPU(Less)
+BINARY_GPU(LessEqual)
+BINARY_GPU(LogicalAnd)
+BINARY_GPU(LogicalOr)
+BINARY_GPU(LogAddExp)
+BINARY_GPU(Maximum)
+BINARY_GPU(Minimum)
+BINARY_GPU(Multiply)
+BINARY_GPU(NotEqual)
+BINARY_GPU(Power)
+BINARY_GPU(Subtract)
+
+void BitwiseBinary::eval_gpu(const std::vector<array>& inputs, array& out) {
+  switch (op_) {
+    case BitwiseBinary::And:
+      binary_op_gpu(inputs, out, name());
+      break;
+    case BitwiseBinary::Or:
+      binary_op_gpu(inputs, out, name());
+      break;
+    case BitwiseBinary::Xor:
+      binary_op_gpu(inputs, out, name());
+      break;
+    case BitwiseBinary::LeftShift:
+      binary_op_gpu(inputs, out, name());
+      break;
+    case BitwiseBinary::RightShift:
+      binary_op_gpu(inputs, out, name());
+      break;
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/binary.h b/ml-stable-diffusion/mlx/mlx/backend/metal/binary.h
new file mode 100644
index 0000000000000000000000000000000000000000..0341a2f83221cac56047349d039926b92d4d23fd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/binary.h
@@ -0,0 +1,33 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+void binary_op_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs,
+    const char* op,
+    const Stream& s);
+
+void binary_op_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s);
+
+void binary_op_gpu_inplace(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs,
+    const char* op,
+    const Stream& s);
+
+void binary_op_gpu_inplace(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/compiled.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/compiled.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eb51ab750e24bba02dc44aa7f34e684a5713e690
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/compiled.cpp
@@ -0,0 +1,471 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <fmt/format.h>
+#include <sstream>
+
+#include "mlx/backend/common/compiled.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/jit/includes.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/graph_utils.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+inline void build_kernel(
+    std::string& os,
+    const std::string& kernel_name,
+    const std::vector<array>& inputs,
+    const std::vector<array>& outputs,
+    const std::vector<array>& tape,
+    const std::function<bool(size_t)>& is_constant,
+    bool contiguous,
+    int ndim,
+    bool dynamic_dims,
+    bool use_big_index = false,
+    int work_per_thread = 1) {
+  NodeNamer namer;
+  bool add_indices = false;
+  int cnt = 0;
+
+  // Start the kernel
+  os += fmt::format(
+      "[[host_name(\"{0}\")]]\n[[kernel]] void {0}(\n", kernel_name);
+
+  // Add the input arguments
+  for (size_t i = 0; i < inputs.size(); ++i) {
+    // Skip constants from the input list
+    if (is_constant(i)) {
+      continue;
+    }
+
+    const auto& x = inputs[i];
+    auto& xname = namer.get_name(x);
+
+    // Scalars and contiguous need no strides
+    if (!is_scalar(x) && !contiguous) {
+      add_indices = true;
+    }
+    os += fmt::format(
+        "    device const {0}* {1} [[buffer({2})]],\n",
+        get_type_string(x.dtype()),
+        xname,
+        cnt++);
+  }
+
+  std::string idx_type = use_big_index ? "int64_t" : "uint";
+  if (add_indices) {
+    os += fmt::format(
+        "    constant const int64_t* in_strides [[buffer({0})]],\n", cnt++);
+  }
+
+  // Add the output arguments
+  for (auto& x : outputs) {
+    os += fmt::format(
+        "    device {0}* {1} [[buffer({2})]],\n",
+        get_type_string(x.dtype()),
+        namer.get_name(x),
+        cnt++);
+  }
+  // Add output strides and shape to extract the indices.
+  if (!contiguous) {
+    os += fmt::format(
+        "    constant const int* output_shape [[buffer({0})]],\n", cnt++);
+  } else {
+    os += fmt::format(
+        "    constant const {0}& size [[buffer({1})]],\n", idx_type, cnt++);
+  }
+  if (dynamic_dims) {
+    os += fmt::format("    constant const int& ndim [[buffer({0})]],\n", cnt++);
+  }
+
+  // The thread index in the whole grid
+  os += "    uint3 pos [[thread_position_in_grid]],\n";
+  os += "    uint3 grid [[threads_per_grid]]) {\n";
+
+  os += fmt::format("  constexpr int N_ = {0};\n", work_per_thread);
+  if (contiguous && use_big_index) {
+    // This is only used for contiguous kernels which don't have
+    // a third grid dimension
+    os += "  int64_t index = N_ * (pos.x + grid.x * int64_t(pos.y));\n";
+  } else if (contiguous) {
+    os += "  uint index = N_ * pos.x;\n";
+  } else if (work_per_thread > 1) {
+    os += fmt::format(
+        "  int xshape = output_shape[{0}];\n",
+        dynamic_dims ? "ndim - 1" : std::to_string(ndim - 1));
+    os += fmt::format(
+        "  {0} index = N_ * pos.x + xshape * (pos.y + {0}(grid.y) * pos.z);\n",
+        idx_type);
+  } else {
+    os += fmt::format(
+        "  {0} index = pos.x + grid.x * (pos.y + {0}(grid.y) * pos.z);\n",
+        idx_type);
+  }
+  if (work_per_thread > 1 && contiguous) {
+    os += "  for (int i = 0; i < N_ && index < size; ++i) {\n";
+  }
+
+  // Read constant / contiguous inputs in tmps
+  std::vector<array> nc_inputs;
+  for (int i = 0; i < inputs.size(); ++i) {
+    auto& x = inputs[i];
+    auto& xname = namer.get_name(x);
+
+    if (is_constant(i)) {
+      auto type_str = get_type_string(x.dtype());
+      std::ostringstream ss;
+      print_constant(ss, x);
+      os += fmt::format(
+          "  auto tmp_{0} = static_cast<{1}>({2});\n",
+          xname,
+          get_type_string(x.dtype()),
+          ss.str());
+    } else if (is_scalar(x)) {
+      os += fmt::format(
+          "  {0} tmp_{1} = {1}[0];\n", get_type_string(x.dtype()), xname);
+    } else if (contiguous) {
+      os += fmt::format(
+          "  {0} tmp_{1} = {1}[index];\n", get_type_string(x.dtype()), xname);
+    } else {
+      nc_inputs.push_back(x);
+    }
+  }
+
+  // Initialize the indices for non-contiguous inputs
+  for (int i = 0; i < nc_inputs.size(); ++i) {
+    auto& xname = namer.get_name(nc_inputs[i]);
+    os += fmt::format("  {0} index_{1} = ", idx_type, xname);
+    if (ndim == 1) {
+      int offset = i * ndim;
+      os +=
+          fmt::format("elem_to_loc_1<uint>(pos.x, in_strides[{0}]);\n", offset);
+    } else if (ndim == 2) {
+      int offset = i * ndim;
+      os += fmt::format(
+          "elem_to_loc_2<{0}>({{pos.x, pos.y}}, in_strides + {1});\n",
+          idx_type,
+          offset);
+    } else if (ndim == 3) {
+      int offset = i * ndim;
+      os += fmt::format(
+          "elem_to_loc_3<{0}>(pos, in_strides + {1});\n", idx_type, offset);
+    } else if (!dynamic_dims) {
+      int offset = (i + 1) * ndim;
+      os += fmt::format(
+          "N_ * pos.x * {0}(in_strides[{1}]) + pos.y * {0}(in_strides[{2}]);\n",
+          idx_type,
+          offset - 1,
+          offset - 2);
+    } else {
+      os += fmt::format(
+          "N_ * pos.x * {0}(in_strides[ndim * {1} + ndim - 1]) + pos.y * {0}(in_strides[ndim * {1} + ndim - 2]);\n",
+          idx_type,
+          i);
+    }
+  }
+
+  if (!nc_inputs.empty() && (ndim > 3 || dynamic_dims)) {
+    os += "  uint zpos = pos.z;\n";
+    if (dynamic_dims) {
+      os += "  for (int d = ndim - 3; d >= 0; --d) {\n";
+    } else {
+      os += fmt::format("  for (int d = {0}; d >= 0; --d) {{\n", ndim - 3);
+    }
+    os += "    uint l = zpos % output_shape[d];\n";
+    for (int i = 0; i < nc_inputs.size(); ++i) {
+      auto& xname = namer.get_name(nc_inputs[i]);
+      os += fmt::format("    index_{0} += ", xname);
+      if (dynamic_dims) {
+        os +=
+            fmt::format("l * {0}(in_strides[{1} * ndim + d]);\n", idx_type, i);
+      } else {
+        os +=
+            fmt::format("l * {0}(in_strides[{1} + d]);\n", idx_type, i * ndim);
+      }
+    }
+    os += "    zpos /= output_shape[d];\n  }\n";
+  }
+
+  // Open per-thread loop
+  if (work_per_thread > 1 && !contiguous) {
+    os +=
+        "  for (int i = 0; i < N_ && (int(N_ * pos.x) + i) < xshape; ++i) {\n";
+  }
+
+  // Read non-contiguous inputs into tmps
+  for (int i = 0; i < nc_inputs.size(); ++i) {
+    auto& x = nc_inputs[i];
+    auto& xname = namer.get_name(x);
+    os += fmt::format(
+        "  {0} tmp_{1} = {1}[index_{1}];\n", get_type_string(x.dtype()), xname);
+  }
+
+  // Actually write the computation
+  for (auto& x : tape) {
+    os += fmt::format(
+        "  {0} tmp_{1} = ", get_type_string(x.dtype()), namer.get_name(x));
+    if (is_static_cast(x.primitive())) {
+      os += fmt::format(
+          "static_cast<{0}>(tmp_{1});\n",
+          get_type_string(x.dtype()),
+          namer.get_name(x.inputs()[0]));
+    } else {
+      os += x.primitive().name();
+      os += "()(";
+      for (int i = 0; i < x.inputs().size() - 1; i++) {
+        os += fmt::format("tmp_{0}, ", namer.get_name(x.inputs()[i]));
+      }
+      os += fmt::format("tmp_{0});\n", namer.get_name(x.inputs().back()));
+    }
+  }
+
+  // Write the outputs from tmps
+  for (auto& x : outputs) {
+    os += fmt::format("  {0}[index] = tmp_{0};\n", namer.get_name(x));
+  }
+  // Increment indices and close per thread loop
+  if (work_per_thread > 1) {
+    for (int i = 0; i < nc_inputs.size(); ++i) {
+      auto& x = nc_inputs[i];
+      auto& xname = namer.get_name(x);
+      if (!dynamic_dims) {
+        os += fmt::format(
+            "  index_{0} += in_strides[{1}];\n", xname, i * ndim + ndim - 1);
+      } else {
+        os += fmt::format(
+            "  index_{0} += in_strides[{1} * ndim + ndim - 1];\n", xname, i);
+      }
+    }
+    os += "  index++;\n  }\n";
+  }
+
+  // Finish the kernel
+  os += "}\n";
+
+  if (cnt > 31) {
+    std::ostringstream msg;
+    msg << "[compile] Too many inputs/outputs fused in the Metal Compiled "
+        << "primitive which exhausted the available argument buffers for "
+        << "the kernel. Please file an issue with the function that results "
+        << "in this error. The name of the kernel is '" << kernel_name << "'";
+    throw std::runtime_error(msg.str());
+  }
+}
+
+void Compiled::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  // Get the kernel if someone else built it already
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+  auto lib = d.get_library(kernel_lib_, [&]() {
+    int work_per_thread = get_work_per_thread(outputs_[0].dtype());
+    std::string kernel = metal::utils();
+    concatenate(
+        kernel, metal::unary_ops(), metal::binary_ops(), metal::ternary_ops());
+    build_kernel(
+        kernel,
+        kernel_lib_ + "_contiguous",
+        inputs_,
+        outputs_,
+        tape_,
+        is_constant_,
+        /* contiguous = */ true,
+        /* ndim = */ 0,
+        /* dynamic_dims = */ false,
+        /* use_big_index = */ false,
+        /* work_per_thread = */ 1);
+    if (work_per_thread > 1) {
+      build_kernel(
+          kernel,
+          kernel_lib_ + "_contiguous_n",
+          inputs_,
+          outputs_,
+          tape_,
+          is_constant_,
+          /* contiguous = */ true,
+          /* ndim = */ 0,
+          /* dynamic_dims = */ false,
+          /* use_big_index = */ false,
+          /* work_per_thread = */ work_per_thread);
+    }
+    build_kernel(
+        kernel,
+        kernel_lib_ + "_contiguous_large",
+        inputs_,
+        outputs_,
+        tape_,
+        is_constant_,
+        /* contiguous = */ true,
+        /* ndim = */ 0,
+        /* dynamic_dims = */ false,
+        /* use_big_index = */ true,
+        /* work_per_thread = */ work_per_thread);
+    for (int i = 1; i < 8; i++) {
+      build_kernel(
+          kernel,
+          kernel_lib_ + "_strided_" + std::to_string(i),
+          inputs_,
+          outputs_,
+          tape_,
+          is_constant_,
+          /* contiguous = */ false,
+          /* ndim = */ i,
+          /* dynamic_dims = */ false,
+          /* use_big_index = */ false,
+          /* work_per_thread = */ i > 3 ? 2 : 1);
+      if (i > 1) {
+        build_kernel(
+            kernel,
+            kernel_lib_ + "_strided_" + std::to_string(i) + "_large",
+            inputs_,
+            outputs_,
+            tape_,
+            is_constant_,
+            /* contiguous = */ false,
+            /* ndim = */ i,
+            /* dynamic_dims = */ false,
+            /* use_big_index = */ true,
+            /* work_per_thread = */ i > 3 ? 4 : 1);
+      }
+    }
+    build_kernel(
+        kernel,
+        kernel_lib_ + "_strided_dynamic",
+        inputs_,
+        outputs_,
+        tape_,
+        is_constant_,
+        /* contiguous = */ false,
+        /* ndim = */ 0,
+        /* dynamic_dims = */ true,
+        /* use_big_index = */ false,
+        /* work_per_thread = */ 2);
+    build_kernel(
+        kernel,
+        kernel_lib_ + "_strided_dynamic_large",
+        inputs_,
+        outputs_,
+        tape_,
+        is_constant_,
+        /* contiguous = */ false,
+        /* ndim = */ 0,
+        /* dynamic_dims = */ true,
+        /* use_big_index = */ true,
+        /* work_per_thread = */ 4);
+    return kernel;
+  });
+
+  // Collapse contiguous dims to route to a faster kernel if possible. Also
+  // handle all broadcasting.
+  auto [contiguous, shape, strides] =
+      compiled_collapse_contiguous_dims(inputs, outputs[0], is_constant_);
+
+  // Whether to use large index.
+  bool large = compiled_use_large_index(inputs, outputs, contiguous);
+
+  // Get the kernel from the lib
+  int ndim = shape.size();
+  bool dynamic = ndim >= 8;
+  auto kernel_name = kernel_lib_ + (contiguous ? "_contiguous" : "_strided_");
+  int work_per_thread = 1;
+  if (!contiguous) {
+    if (dynamic) {
+      kernel_name += "dynamic";
+    } else {
+      kernel_name += std::to_string(shape.size());
+    }
+    work_per_thread = ndim > 3 ? (large ? 4 : 2) : 1;
+  } else {
+    work_per_thread =
+        get_work_per_thread(outputs[0].dtype(), outputs[0].data_size());
+    if (work_per_thread > 1 && !large) {
+      kernel_name += "_n";
+    }
+  }
+  if (large) {
+    kernel_name += "_large";
+  }
+  auto kernel = d.get_kernel(kernel_name, lib);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Put the inputs in
+  int cnt = 0;
+  int stride_idx = 1; // idx 0 is the output strides
+  Strides in_strides;
+  for (int i = 0; i < inputs.size(); i++) {
+    if (is_constant_(i)) {
+      continue;
+    }
+    auto& x = inputs[i];
+    compute_encoder.set_input_array(x, cnt++);
+    if (!contiguous && !is_scalar(x)) {
+      in_strides.insert(
+          in_strides.end(),
+          strides[stride_idx].begin(),
+          strides[stride_idx].end());
+      stride_idx++;
+    }
+  }
+  if (!in_strides.empty()) {
+    compute_encoder.set_vector_bytes(in_strides, cnt++);
+  }
+
+  compiled_allocate_outputs(inputs, outputs, is_constant_, contiguous);
+
+  // Put the outputs in
+  for (auto& x : outputs) {
+    compute_encoder.set_output_array(x, cnt++);
+  }
+
+  // Put the output shape and strides in
+  if (!contiguous) {
+    compute_encoder.set_vector_bytes(shape, cnt++);
+  } else {
+    auto size = outputs[0].data_size();
+    if (large) {
+      compute_encoder.set_bytes<int64_t>(size, cnt++);
+    } else {
+      compute_encoder.set_bytes<int>(size, cnt++);
+    }
+  }
+
+  // Put the number of dims in if it is dynamic
+  if (dynamic) {
+    compute_encoder.set_bytes(ndim, cnt++);
+  }
+
+  // Launch the kernel
+  if (contiguous) {
+    size_t nthreads = ceildiv(outputs[0].data_size(), work_per_thread);
+    MTL::Size group_dims(
+        std::min(nthreads, kernel->maxTotalThreadsPerThreadgroup()), 1, 1);
+    MTL::Size grid_dims = large
+        ? get_2d_grid_dims(
+              outputs[0].shape(), outputs[0].strides(), work_per_thread)
+        : MTL::Size(nthreads, 1, 1);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  } else {
+    size_t dim0 = ndim > 0 ? shape[ndim - 1] : 1;
+    size_t dim1 = ndim > 1 ? shape[ndim - 2] : 1;
+    size_t rest = outputs[0].size() / (dim0 * dim1);
+    dim0 = (dim0 + work_per_thread - 1) / work_per_thread;
+    NS::UInteger thread_group_size = kernel->maxTotalThreadsPerThreadgroup();
+    int pow2;
+    if (thread_group_size == 1024) {
+      pow2 = 10;
+    } else if (thread_group_size > 512) {
+      pow2 = 9;
+    } else {
+      throw std::runtime_error("[Metal::compiled] Must use > 512 sized block");
+    }
+    auto group_dims = get_block_dims(dim0, dim1, rest, pow2);
+    MTL::Size grid_dims = MTL::Size(dim0, dim1, rest);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/conv.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/conv.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4a674ff0ef1f2036a9a9afbb5a30bd47d99479f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/conv.cpp
@@ -0,0 +1,1118 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <algorithm>
+#include <cassert>
+#include <numeric>
+
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/kernels/defines.h"
+#include "mlx/backend/metal/kernels/steel/conv/params.h"
+#include "mlx/backend/metal/matmul.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+using namespace mlx::steel;
+
+namespace mlx::core {
+
+namespace {
+
+template <int N>
+void explicit_gemm_conv_ND_gpu(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    const array& wt,
+    array out,
+    const MLXConvParams<N>& conv_params) {
+  // Get gemm shapes
+  int implicit_M = out.size() / conv_params.O;
+  int implicit_K = wt.size() / conv_params.O;
+  int implicit_N = conv_params.O;
+  // Prepare unfolding array
+  Shape unfolded_shape{implicit_M, implicit_K};
+  array in_unfolded(unfolded_shape, in.dtype(), nullptr, {});
+
+  in_unfolded.set_data(allocator::malloc(in_unfolded.nbytes()));
+
+  // Prepare unfolding kernel
+  std::string kname;
+  kname.reserve(32);
+  concatenate(kname, "naive_unfold_nd_", type_to_name(in_unfolded), "_", N);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel(kname);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_output_array(in_unfolded, 1);
+
+  compute_encoder.set_bytes(conv_params, 2);
+
+  // Launch unfolding kernel
+  size_t tgp_x = std::min(conv_params.C, 64);
+  tgp_x = 32 * ((tgp_x + 32 - 1) / 32);
+  size_t tgp_y = 256 / tgp_x;
+
+  MTL::Size grid_dims = MTL::Size(
+      conv_params.C, unfolded_shape[1] / conv_params.C, unfolded_shape[0]);
+  MTL::Size group_dims = MTL::Size(
+      std::min(tgp_x, grid_dims.width), std::min(tgp_y, grid_dims.height), 1);
+
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+
+  // Reshape weight
+  Shape wt_reshape{implicit_K, implicit_N};
+  Strides wt_restride{1, implicit_K};
+  array wt_reshaped(wt_reshape, wt.dtype(), nullptr, {});
+  auto wt_flags = wt.flags();
+  wt_flags.row_contiguous = false;
+  wt_flags.col_contiguous = true;
+  wt_reshaped.copy_shared_buffer(wt, wt_restride, wt_flags, wt.data_size());
+
+  // Perform gemm
+  std::vector<array> copies = {in_unfolded};
+  return steel_matmul(
+      s,
+      d,
+      /*a = */ in_unfolded,
+      /*b = */ wt_reshaped,
+      /*c = */ out,
+      /*M = */ implicit_M,
+      /*N = */ implicit_N,
+      /*K = */ implicit_K,
+      /*batch_size_out = */ 1,
+      /*a_cols = */ implicit_K,
+      /*b_cols = */ implicit_K,
+      /*a_transposed = */ false,
+      /*b_transposed = */ true,
+      /*copies = */ copies);
+}
+
+template <int N>
+void explicit_gemm_conv_group_ND_gpu(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    const array& wt,
+    array out,
+    const MLXConvParams<N>& conv_params) {
+  const int groups = conv_params.groups;
+  const int C_per_group = conv_params.C / conv_params.groups;
+  const int O_per_group = conv_params.O / conv_params.groups;
+  // Get gemm shapes
+  const int implicit_M = out.size() / conv_params.O;
+  const int implicit_K = wt.size() / conv_params.O;
+  const int implicit_N = O_per_group;
+
+  int kernel_size = 1;
+  for (int i = 0; i < N; ++i) {
+    kernel_size *= conv_params.wS[i];
+  }
+
+  // Prepare unfolding array
+  Shape unfolded_shape{implicit_M, implicit_K * groups};
+  array in_unfolded(unfolded_shape, in.dtype(), nullptr, {});
+  in_unfolded.set_data(allocator::malloc(in_unfolded.nbytes()));
+
+  // Prepare unfolding kernel
+  std::string kname;
+  kname.reserve(32);
+  concatenate(
+      kname, "naive_unfold_transpose_nd_", type_to_name(in_unfolded), "_", N);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel(kname);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_output_array(in_unfolded, 1);
+
+  compute_encoder.set_bytes(conv_params, 2);
+
+  // Launch unfolding kernel
+  size_t tgp_x = std::min(conv_params.C, 64);
+  tgp_x = 32 * ((tgp_x + 32 - 1) / 32);
+  size_t tgp_y = 256 / tgp_x;
+
+  MTL::Size grid_dims = MTL::Size(
+      conv_params.C, unfolded_shape[1] / conv_params.C, unfolded_shape[0]);
+  MTL::Size group_dims = MTL::Size(
+      std::min(tgp_x, grid_dims.width), std::min(tgp_y, grid_dims.height), 1);
+
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+
+  // Transpose kernel weights so that we can slice them by contiguous chunks
+  // of channel groups.
+  array wt_view(
+      {wt.shape(0), C_per_group, kernel_size}, wt.dtype(), nullptr, {});
+  wt_view.copy_shared_buffer(
+      wt, {wt.strides(0), 1, C_per_group}, wt.flags(), wt.size());
+
+  // Materialize
+  array wt_transpose = contiguous_copy_gpu(wt_view, s);
+
+  // Perform gemm
+  std::vector<array> copies = {in_unfolded, wt_transpose};
+  return steel_matmul_regular(
+      /* const Stream& s = */ s,
+      /* Device& d = */ d,
+      /* const array& a = */ in_unfolded,
+      /* const array& b = */ wt_transpose,
+      /* array& c = */ out,
+      /* int M = */ implicit_M,
+      /* int N = */ implicit_N,
+      /* int K = */ implicit_K,
+      /* int batch_size_out = */ groups,
+      /* int lda = */ implicit_K * groups,
+      /* int ldb = */ implicit_K,
+      /* int ldd = */ implicit_N * groups,
+      /* bool transpose_a = */ false,
+      /* bool transpose_b = */ true,
+      /* std::vector<array>& copies = */ copies,
+      /* Shape batch_shape = */ {1},
+      /* Strides batch_strides = */ {0},
+      /* int64_t A_batch_strides = */ int64_t(implicit_K),
+      /* int64_t B_batch_strides = */ int64_t(implicit_N) * implicit_K,
+      /* int64_t matrix_stride_out = */ int64_t(implicit_N));
+}
+
+void implicit_gemm_conv_2D_gpu(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    const array& wt,
+    array out,
+    const MLXConvParams<2>& conv_params) {
+  const int groups = conv_params.groups;
+  const int C_per_group = conv_params.C / conv_params.groups;
+  const int O_per_group = conv_params.O / conv_params.groups;
+
+  // Deduce implicit gemm size
+  const int implicit_M = conv_params.N * conv_params.oS[0] * conv_params.oS[1];
+  const int implicit_N = O_per_group;
+  const int implicit_K = conv_params.wS[0] * conv_params.wS[1] * C_per_group;
+
+  // Determine block and warp tiles
+  int wm = 2, wn = 2;
+
+  int bm = implicit_M >= 8192 && C_per_group >= 64 ? 64 : 32;
+  int bn = (bm == 64 || implicit_N >= 64) ? 64 : 32;
+  int bk = 16;
+
+  if (implicit_N <= 16) {
+    bn = 8;
+    wm = 4;
+    wn = 1;
+  }
+
+  int tn = (implicit_N + bn - 1) / bn;
+  int tm = (implicit_M + bm - 1) / bm;
+  int swizzle_log = 0;
+
+  // Fix small channel specialization
+  int n_channel_specialization = 0;
+  int channel_k_iters = ((C_per_group + bk - 1) / bk);
+  int gemm_k_iters = conv_params.wS[0] * conv_params.wS[1] * channel_k_iters;
+
+  if (C_per_group <= 2) {
+    gemm_k_iters = (implicit_K + bk - 1) / bk;
+    n_channel_specialization = C_per_group;
+  } else if (C_per_group <= 4) {
+    gemm_k_iters = ((conv_params.wS[0] * conv_params.wS[1] * 4) + bk - 1) / bk;
+    n_channel_specialization = C_per_group;
+  }
+
+  bool small_filter = (!n_channel_specialization) &&
+      (conv_params.wS[0] <= 16 && conv_params.wS[1] <= 16);
+
+  // Fix host side helper params
+  int sign = (conv_params.flip ? -1 : 1);
+  int ijw = conv_params.in_strides[2] * conv_params.kdil[1];
+  int ijh = conv_params.in_strides[1] * conv_params.kdil[0];
+
+  int inp_jump_w = sign * ijw;
+  int inp_jump_h = sign * (ijh - (conv_params.wS[1] - 1) * ijw);
+  int inp_jump_c = bk - sign * (conv_params.wS[0] - 1) * ijh -
+      sign * (conv_params.wS[1] - 1) * ijw;
+
+  // Build implicit gemm params
+  ImplicitGemmConv2DParams gemm_params{
+      /* const int M = */ implicit_M,
+      /* const int N = */ implicit_N,
+      /* const int K = */ implicit_K,
+
+      /* const int gemm_k_iterations = */ gemm_k_iters,
+
+      /* const int inp_jump_w = */ inp_jump_w,
+      /* const int inp_jump_h = */ inp_jump_h,
+      /* const int inp_jump_c = */ inp_jump_c,
+
+      /* const int tiles_n = */ tn,
+      /* const int tiles_m = */ tm,
+      /* const int swizzle_log = */ swizzle_log};
+
+  // Determine kernel
+  std::string kname;
+  kname.reserve(64);
+  concatenate(
+      kname,
+      "implicit_gemm_conv_2d_",
+      type_to_name(out),
+      "_bm",
+      bm,
+      "_bn",
+      bn,
+      "_bk",
+      bk,
+      "_wm",
+      wm,
+      "_wn",
+      wn,
+      "_channel_",
+      n_channel_specialization ? std::to_string(n_channel_specialization) : "l",
+      "_filter_",
+      small_filter ? 's' : 'l');
+
+  // Encode and dispatch kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = get_steel_conv_kernel(
+      d,
+      kname,
+      out,
+      bm,
+      bn,
+      bk,
+      wm,
+      wn,
+      n_channel_specialization,
+      small_filter);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Deduce grid launch dimensions
+  int tile = 1 << swizzle_log;
+  size_t grid_dim_y = (tm + tile - 1) / tile;
+  size_t grid_dim_x = tn * tile;
+
+  MTL::Size group_dims = MTL::Size(32, wn, wm);
+  MTL::Size grid_dims = MTL::Size(grid_dim_x, grid_dim_y, groups);
+
+  // Encode arrays
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_input_array(wt, 1);
+  compute_encoder.set_output_array(out, 2);
+
+  // Encode params
+  compute_encoder.set_bytes(conv_params, 3);
+  compute_encoder.set_bytes(gemm_params, 4);
+
+  // Launch kernel
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void implicit_gemm_conv_2D_general_gpu(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    const array& wt,
+    array out,
+    const MLXConvParams<2>& conv_params) {
+  // Deduce implicit gemm size
+  int implicit_M = conv_params.N * conv_params.oS[0] * conv_params.oS[1];
+  int implicit_N = conv_params.O;
+  int implicit_K = conv_params.wS[0] * conv_params.wS[1] * conv_params.C;
+
+  // Determine block and warp tiles
+  int wm = 2, wn = 2;
+
+  // Make jump params
+  int f_wgt_jump_h =
+      std::lcm(conv_params.idil[0], conv_params.kdil[0]) / conv_params.kdil[0];
+  int f_wgt_jump_w =
+      std::lcm(conv_params.idil[1], conv_params.kdil[1]) / conv_params.kdil[1];
+
+  int f_out_jump_h =
+      std::lcm(conv_params.idil[0], conv_params.str[0]) / conv_params.str[0];
+  int f_out_jump_w =
+      std::lcm(conv_params.idil[1], conv_params.str[1]) / conv_params.str[1];
+
+  int adj_out_h = (conv_params.oS[0] + f_out_jump_h - 1) / f_out_jump_h;
+  int adj_out_w = (conv_params.oS[1] + f_out_jump_w - 1) / f_out_jump_w;
+  int adj_out_hw = adj_out_h * adj_out_w;
+  int adj_implicit_m = conv_params.N * adj_out_hw;
+
+  Conv2DGeneralJumpParams jump_params{
+      /* const int f_wgt_jump_h = */ f_wgt_jump_h,
+      /* const int f_wgt_jump_w = */ f_wgt_jump_w,
+
+      /* const int f_out_jump_h = */ f_out_jump_h,
+      /* const int f_out_jump_w = */ f_out_jump_w,
+
+      /* const int adj_out_h = */ adj_out_h,
+      /* const int adj_out_w = */ adj_out_w,
+      /* const int adj_out_hw = */ adj_out_hw,
+      /* const int adj_implicit_m = */ adj_implicit_m};
+
+  // Make base info
+  std::vector<Conv2DGeneralBaseInfo> base_h(f_out_jump_h);
+  std::vector<Conv2DGeneralBaseInfo> base_w(f_out_jump_w);
+
+  int jump_h = conv_params.flip ? -conv_params.kdil[0] : conv_params.kdil[0];
+  int jump_w = conv_params.flip ? -conv_params.kdil[1] : conv_params.kdil[1];
+
+  int init_h =
+      (conv_params.flip ? (conv_params.wS[0] - 1) * conv_params.kdil[0] : 0);
+  int init_w =
+      (conv_params.flip ? (conv_params.wS[1] - 1) * conv_params.kdil[1] : 0);
+
+  for (int i = 0; i < f_out_jump_h; ++i) {
+    int ih_loop = i * conv_params.str[0] - conv_params.pad[0] + init_h;
+
+    int wh_base = 0;
+    while (wh_base < conv_params.wS[0] && ih_loop % conv_params.idil[0] != 0) {
+      wh_base++;
+      ih_loop += jump_h;
+    }
+
+    int wh_size =
+        ((conv_params.wS[0] - wh_base) + f_wgt_jump_h - 1) / f_wgt_jump_h;
+    base_h[i] = {wh_base, wh_size};
+  }
+
+  for (int j = 0; j < f_out_jump_w; ++j) {
+    int iw_loop = j * conv_params.str[1] - conv_params.pad[1] + init_w;
+
+    int ww_base = 0;
+    while (ww_base < conv_params.wS[1] && iw_loop % conv_params.idil[1] != 0) {
+      ww_base++;
+      iw_loop += jump_w;
+    }
+
+    int ww_size =
+        ((conv_params.wS[1] - ww_base) + f_wgt_jump_w - 1) / f_wgt_jump_w;
+    base_w[j] = {ww_base, ww_size};
+  }
+
+  // Collect block sizes
+  int bm = adj_implicit_m >= 8192 && conv_params.C >= 64 ? 64 : 32;
+  int bn = (bm == 64 && implicit_N >= 64) ? 64 : 32;
+  int bk = 16;
+
+  int tn = (implicit_N + bn - 1) / bn;
+  int tm = (adj_implicit_m + bm - 1) / bm;
+  int swizzle_log = 0;
+
+  // Get channel iteration info
+  int channel_k_iters = ((conv_params.C + bk - 1) / bk);
+  int gemm_k_iters = channel_k_iters;
+  bool align_C = conv_params.C % bk == 0;
+
+  // Fix host side helper params
+  int sign = (conv_params.flip ? -1 : 1);
+  int ijw = conv_params.in_strides[2] * conv_params.kdil[1];
+  int ijh = conv_params.in_strides[1] * conv_params.kdil[0];
+
+  int inp_jump_w = sign * ijw;
+  int inp_jump_h = sign * (ijh - (conv_params.wS[1] - 1) * ijw);
+  int inp_jump_c = bk - sign * (conv_params.wS[0] - 1) * ijh -
+      sign * (conv_params.wS[1] - 1) * ijw;
+
+  // Build implicit gemm params
+  ImplicitGemmConv2DParams gemm_params{
+      /* const int M = */ implicit_M,
+      /* const int N = */ implicit_N,
+      /* const int K = */ implicit_K,
+
+      /* const int gemm_k_iterations = */ gemm_k_iters,
+
+      /* const int inp_jump_w = */ inp_jump_w,
+      /* const int inp_jump_h = */ inp_jump_h,
+      /* const int inp_jump_c = */ inp_jump_c,
+
+      /* const int tiles_n = */ tn,
+      /* const int tiles_m = */ tm,
+      /* const int swizzle_log = */ swizzle_log};
+
+  // Determine kernel
+  std::string kname;
+  kname.reserve(64);
+  concatenate(
+      kname,
+      "implicit_gemm_conv_2d_general_",
+      type_to_name(out),
+      "_bm",
+      bm,
+      "_bn",
+      bn,
+      "_bk",
+      bk,
+      "_wm",
+      wm,
+      "_wn",
+      wn);
+  std::string hash_name;
+  hash_name.reserve(64);
+  concatenate(hash_name, kname, "_alC_", align_C);
+  metal::MTLFCList func_consts = {
+      {&align_C, MTL::DataType::DataTypeBool, 200},
+  };
+
+  // Encode and dispatch kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = get_steel_conv_general_kernel(
+      d, kname, hash_name, func_consts, out, bm, bn, bk, wm, wn);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Deduce grid launch dimensions
+  int tile = 1 << swizzle_log;
+  size_t grid_dim_y = (tm + tile - 1) / tile;
+  size_t grid_dim_x = tn * tile;
+  size_t grid_dim_z = f_out_jump_h * f_out_jump_w;
+
+  MTL::Size group_dims = MTL::Size(32, wn, wm);
+  MTL::Size grid_dims = MTL::Size(grid_dim_x, grid_dim_y, grid_dim_z);
+
+  // Encode arrays
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_input_array(wt, 1);
+  compute_encoder.set_output_array(out, 2);
+
+  // Encode params
+  compute_encoder.set_bytes(conv_params, 3);
+  compute_encoder.set_bytes(gemm_params, 4);
+  compute_encoder.set_bytes(jump_params, 5);
+
+  compute_encoder.set_vector_bytes(base_h, 6);
+  compute_encoder.set_vector_bytes(base_w, 7);
+
+  // Launch kernel
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void winograd_conv_2D_gpu(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    const array& wt,
+    array out,
+    const MLXConvParams<2>& conv_params,
+    std::vector<array>& copies_w) {
+  Shape padded_shape = {
+      conv_params.N,
+      conv_params.iS[0] + 2 * conv_params.pad[0],
+      conv_params.iS[1] + 2 * conv_params.pad[1],
+      conv_params.C};
+
+  padded_shape[1] = 6 * ((padded_shape[1] - 2 + 5) / 6) + 2;
+  padded_shape[2] = 6 * ((padded_shape[2] - 2 + 5) / 6) + 2;
+
+  array in_padded(std::move(padded_shape), in.dtype(), nullptr, {});
+
+  // Fill with zeros
+  array zero_arr = array(0, in.dtype());
+  fill_gpu(zero_arr, in_padded, s);
+  copies_w.push_back(zero_arr);
+
+  // Pick input slice from padded
+  size_t data_offset = conv_params.pad[0] * in_padded.strides()[1] +
+      conv_params.pad[1] * in_padded.strides()[2];
+  array in_padded_slice(in.shape(), in_padded.dtype(), nullptr, {});
+  in_padded_slice.copy_shared_buffer(
+      in_padded,
+      in_padded.strides(),
+      in_padded.flags(),
+      in_padded_slice.size(),
+      data_offset);
+
+  // Copy input values into the slice
+  copy_gpu_inplace(in, in_padded_slice, CopyType::GeneralGeneral, s);
+
+  copies_w.push_back(in_padded_slice);
+  copies_w.push_back(in_padded);
+
+  MLXConvParams<2> conv_params_updated{
+      /* const int  N = */ static_cast<int>(in_padded.shape(0)),
+      /* const int  C = */ static_cast<int>(in_padded.shape(3)),
+      /* const int  O = */ static_cast<int>(wt.shape(0)),
+      /* const int iS[NDIM] = */
+      {static_cast<int>(in_padded.shape(1)),
+       static_cast<int>(in_padded.shape(2))},
+      /* const int wS[NDIM] = */
+      {static_cast<int>(wt.shape(1)), static_cast<int>(wt.shape(2))},
+      /* const int oS[NDIM] = */
+      {static_cast<int>(out.shape(1)), static_cast<int>(out.shape(2))},
+      /* const int str[NDIM] = */ {1, 1},
+      /* const int pad[NDIM] = */ {0, 0},
+      /* const int kdil[NDIM] = */ {1, 1},
+      /* const int idil[NDIM] = */ {1, 1},
+      /* const size_t in_strides[NDIM + 2] = */
+      {in_padded.strides()[0],
+       in_padded.strides()[1],
+       in_padded.strides()[2],
+       in_padded.strides()[3]},
+      /* const size_t wt_strides[NDIM + 2] = */
+      {wt.strides()[0], wt.strides()[1], wt.strides()[2], wt.strides()[3]},
+      /* const size_t out_strides[NDIM + 2] = */
+      {out.strides()[0], out.strides()[1], out.strides()[2], out.strides()[3]},
+      /* const int groups = */ 1,
+      /* const bool flip = */ false,
+  };
+
+  int O_c = conv_params.O;
+  int C_c = conv_params.C;
+
+  int N_tiles_n = conv_params.N;
+  int N_tiles_h = (conv_params.oS[0] + 5) / 6;
+  int N_tiles_w = (conv_params.oS[1] + 5) / 6;
+  int N_tiles = N_tiles_n * N_tiles_h * N_tiles_w;
+
+  // Do filter transform
+  Shape filt_wg_shape = {8 * 8, conv_params.C, conv_params.O};
+  array filt_wg(std::move(filt_wg_shape), wt.dtype(), nullptr, {});
+  filt_wg.set_data(allocator::malloc(filt_wg.nbytes()));
+  copies_w.push_back(filt_wg);
+  {
+    int bc = 32;
+    int bo = 4;
+    std::string kname;
+    kname.reserve(32);
+    concatenate(
+        kname,
+        "winograd_conv_2d_weight_transform_",
+        type_to_name(out),
+        "_bc",
+        bc);
+    auto& compute_encoder = d.get_command_encoder(s.index);
+    auto kernel = d.get_kernel(kname);
+    compute_encoder.set_compute_pipeline_state(kernel);
+
+    compute_encoder.set_input_array(wt, 0);
+    compute_encoder.set_output_array(filt_wg, 1);
+
+    compute_encoder.set_bytes(C_c, 2);
+    compute_encoder.set_bytes(O_c, 3);
+
+    MTL::Size group_dims = MTL::Size(32, bo, 1);
+    MTL::Size grid_dims = MTL::Size(O_c / bo, 1, 1);
+
+    compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+  }
+
+  // Do input transform
+  Shape inp_wg_shape = {8 * 8, N_tiles, conv_params.C};
+  array inp_wg(std::move(inp_wg_shape), in.dtype(), nullptr, {});
+  inp_wg.set_data(allocator::malloc(inp_wg.nbytes()));
+  copies_w.push_back(inp_wg);
+  {
+    int bc = 32;
+    int wm = 2;
+    int wn = 2;
+    std::string kname;
+    kname.reserve(32);
+    concatenate(
+        kname,
+        "winograd_conv_2d_input_transform_",
+        type_to_name(out),
+        "_bc",
+        bc);
+    auto& compute_encoder = d.get_command_encoder(s.index);
+    auto kernel = d.get_kernel(kname);
+    compute_encoder.set_compute_pipeline_state(kernel);
+
+    compute_encoder.set_input_array(in_padded, 0);
+    compute_encoder.set_output_array(inp_wg, 1);
+
+    compute_encoder.set_bytes(conv_params_updated, 2);
+
+    MTL::Size group_dims = MTL::Size(32, wn, wm);
+    MTL::Size grid_dims = MTL::Size(N_tiles_w, N_tiles_h, N_tiles_n);
+
+    compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+  }
+
+  // Do batched gemm
+  Shape out_wg_shape = {8 * 8, N_tiles, conv_params.O};
+  array out_wg(std::move(out_wg_shape), in.dtype(), nullptr, {});
+  out_wg.set_data(allocator::malloc(out_wg.nbytes()));
+  copies_w.push_back(out_wg);
+  {
+    std::vector<array> empty_copies;
+    steel_matmul(
+        s,
+        d,
+        /*a = */ inp_wg,
+        /*b = */ filt_wg,
+        /*c = */ out_wg,
+        /*M = */ N_tiles,
+        /*N = */ conv_params.O,
+        /*K = */ conv_params.C,
+        /*batch_size_out = */ 8 * 8,
+        /*a_cols = */ conv_params.C,
+        /*b_cols = */ conv_params.O,
+        /*a_transposed = */ false,
+        /*b_transposed = */ false,
+        /*copies = */ empty_copies);
+  }
+
+  // Do output transform
+  {
+    int bc = 32;
+    int wm = 2;
+    int wn = 2;
+    std::string kname;
+    kname.reserve(32);
+    concatenate(
+        kname,
+        "winograd_conv_2d_output_transform_",
+        type_to_name(out),
+        "_bo",
+        bc);
+    auto& compute_encoder = d.get_command_encoder(s.index);
+    auto kernel = d.get_kernel(kname);
+    compute_encoder.set_compute_pipeline_state(kernel);
+
+    compute_encoder.set_input_array(out_wg, 0);
+    compute_encoder.set_output_array(out, 1);
+
+    compute_encoder.set_bytes(conv_params_updated, 2);
+
+    MTL::Size group_dims = MTL::Size(32, wn, wm);
+    MTL::Size grid_dims = MTL::Size(N_tiles_w, N_tiles_h, N_tiles_n);
+
+    compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+  }
+}
+
+void depthwise_conv_2D_gpu(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    const array& wt,
+    array out,
+    const MLXConvParams<2>& conv_params) {
+  std::string base_name;
+  base_name.reserve(32);
+  concatenate(base_name, "depthwise_conv_2d_", type_to_name(out));
+
+  const int N = conv_params.N;
+  const int ker_h = conv_params.wS[0];
+  const int ker_w = conv_params.wS[1];
+  const int str_h = conv_params.str[0];
+  const int str_w = conv_params.str[1];
+  const int tc = 8;
+  const int tw = 8;
+  const int th = 4;
+  const bool do_flip = conv_params.flip;
+
+  metal::MTLFCList func_consts = {
+      {&ker_h, MTL::DataType::DataTypeInt, 00},
+      {&ker_w, MTL::DataType::DataTypeInt, 01},
+      {&str_h, MTL::DataType::DataTypeInt, 10},
+      {&str_w, MTL::DataType::DataTypeInt, 11},
+      {&th, MTL::DataType::DataTypeInt, 100},
+      {&tw, MTL::DataType::DataTypeInt, 101},
+      {&do_flip, MTL::DataType::DataTypeBool, 200},
+  };
+
+  // clang-format off
+  std::string hash_name;
+  hash_name.reserve(64);
+  concatenate(
+      hash_name,
+      base_name,
+  "_ker_h_", ker_h,
+  "_ker_w_", ker_w,
+  "_str_h_", str_h,
+  "_str_w_", str_w,
+  "_tgp_h_", th,
+  "_tgp_w_", tw,
+  "_do_flip_", do_flip ? 't' : 'n'); // clang-format on
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel(base_name, hash_name, func_consts);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_input_array(wt, 1);
+  compute_encoder.set_output_array(out, 2);
+
+  compute_encoder.set_bytes(conv_params, 3);
+
+  MTL::Size group_dims = MTL::Size(tc, tw, th);
+  MTL::Size grid_dims = MTL::Size(
+      conv_params.C / tc, conv_params.oS[1] / tw, (conv_params.oS[0] / th) * N);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void dispatch_conv_2D_gpu(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    const array& wt,
+    array out,
+    const MLXConvParams<2>& conv_params,
+    std::vector<array>& copies) {
+  bool is_stride_one = conv_params.str[0] == 1 && conv_params.str[1] == 1;
+  bool is_kdil_one = conv_params.kdil[0] == 1 && conv_params.kdil[1] == 1;
+  bool is_idil_one = conv_params.idil[0] == 1 && conv_params.idil[1] == 1;
+
+  if (is_idil_one && conv_params.groups > 1) {
+    const int C_per_group = conv_params.C / conv_params.groups;
+    const int O_per_group = conv_params.O / conv_params.groups;
+
+    if (C_per_group == 1 && O_per_group == 1 && is_kdil_one &&
+        conv_params.wS[0] <= 7 && conv_params.wS[1] <= 7 &&
+        conv_params.str[0] <= 2 && conv_params.str[1] <= 2 &&
+        conv_params.oS[0] % 8 == 0 && conv_params.oS[1] % 8 == 0 &&
+        conv_params.wt_strides[1] == conv_params.wS[1] &&
+        conv_params.C % 16 == 0 && conv_params.C == conv_params.O) {
+      return depthwise_conv_2D_gpu(s, d, in, wt, out, conv_params);
+    }
+
+    if ((C_per_group <= 4 || C_per_group % 16 == 0) &&
+        (O_per_group <= 16 || O_per_group % 16 == 0)) {
+      return implicit_gemm_conv_2D_gpu(s, d, in, wt, out, conv_params);
+    } else {
+      return explicit_gemm_conv_group_ND_gpu(s, d, in, wt, out, conv_params);
+    }
+  }
+
+  // Direct to winograd conv
+  bool inp_large =
+      (conv_params.N * conv_params.iS[0] * conv_params.iS[1]) >= 4096;
+  bool channels_large = (conv_params.C + conv_params.O) >= 256;
+  bool out_large =
+      (conv_params.N * conv_params.oS[0] * conv_params.oS[1]) >= 256;
+  if (!conv_params.flip && is_stride_one && is_kdil_one && is_idil_one &&
+      conv_params.wS[0] == 3 && conv_params.wS[1] == 3 &&
+      conv_params.C % 32 == 0 && conv_params.O % 32 == 0 && inp_large &&
+      channels_large) {
+    return winograd_conv_2D_gpu(s, d, in, wt, out, conv_params, copies);
+  }
+
+  // Direct to implicit gemm conv
+  if (is_idil_one && (conv_params.C <= 4 || conv_params.C % 16 == 0) &&
+      (conv_params.O <= 16 || conv_params.O % 16 == 0)) {
+    return implicit_gemm_conv_2D_gpu(s, d, in, wt, out, conv_params);
+  }
+
+  else if ((conv_params.C % 16 == 0 && conv_params.O % 16 == 0) || out_large) {
+    return implicit_gemm_conv_2D_general_gpu(s, d, in, wt, out, conv_params);
+  }
+
+  // Direct to explicit gemm conv
+  else {
+    return explicit_gemm_conv_ND_gpu(s, d, in, wt, out, conv_params);
+  }
+}
+
+void depthwise_conv_1D_gpu(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    array wt,
+    array out) {
+  bool large = in.size() > INT32_MAX || in.data_size() > INT32_MAX;
+  std::string base_name;
+  base_name.reserve(32);
+  concatenate(
+      base_name,
+      "depthwise_conv_1d_",
+      large ? "_large" : "",
+      type_to_name(out));
+
+  if (!wt.flags().row_contiguous) {
+    wt = contiguous_copy_gpu(wt, s);
+    d.add_temporary(wt, s.index);
+  }
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel(base_name);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  auto B = in.shape(0);
+  auto Tout = out.shape(1);
+  auto D = in.shape(2);
+  auto K = wt.shape(1);
+
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_input_array(wt, 1);
+  compute_encoder.set_output_array(out, 2);
+  if (large) {
+    int64_t strides[3] = {in.strides(0), in.strides(1), in.strides(2)};
+    compute_encoder.set_bytes(strides, 3, 3);
+
+  } else {
+    int strides[3] = {
+        static_cast<int>(in.strides(0)),
+        static_cast<int>(in.strides(1)),
+        static_cast<int>(in.strides(2))};
+    compute_encoder.set_bytes(strides, 3, 3);
+  }
+
+  compute_encoder.set_bytes(K, 4);
+  auto group_dims = get_block_dims(D, Tout, B);
+  MTL::Size grid_dims = MTL::Size(D, Tout, B);
+
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+void conv_1D_gpu(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    const std::vector<int>& in_dilation,
+    int groups,
+    bool flip,
+    std::vector<array>& copies) {
+  bool is_idil_one = in_dilation[0] == 1;
+  int C = in.shape(2);
+  int O = wt.shape(0);
+  // Fast path for fully separable 1D convolution
+  if (is_idil_one && (groups == C) && groups == O && wt_strides[0] == 1 &&
+      wt_dilation[0] == 1 && padding[0] == 0 && !flip) {
+    depthwise_conv_1D_gpu(s, d, in, wt, out);
+    return;
+  }
+
+  const int C_per_group = C / groups;
+  const int O_per_group = O / groups;
+
+  // Direct to implicit gemm conv
+  if (is_idil_one && (C_per_group <= 4 || C_per_group % 16 == 0) &&
+      (O_per_group <= 16 || O_per_group % 16 == 0)) {
+    MLXConvParams<2> conv_params{
+        /* const int  N = */ static_cast<int>(in.shape(0)),
+        /* const int  C = */ C,
+        /* const int  O = */ O,
+        /* const int iS[NDIM] = */ {static_cast<int>(in.shape(1)), 1},
+        /* const int wS[NDIM] = */ {static_cast<int>(wt.shape(1)), 1},
+        /* const int oS[NDIM] = */ {static_cast<int>(out.shape(1)), 1},
+        /* const int str[NDIM] = */ {wt_strides[0], 1},
+        /* const int pad[NDIM] = */ {padding[0], 0},
+        /* const int kdil[NDIM] = */ {wt_dilation[0], 1},
+        /* const int idil[NDIM] = */ {in_dilation[0], 1},
+        /* const size_t in_strides[NDIM + 2] = */
+        {in.strides()[0], in.strides()[1], 0, in.strides()[2]},
+        /* const size_t wt_strides[NDIM + 2] = */
+        {wt.strides()[0], wt.strides()[1], 0, wt.strides()[2]},
+        /* const size_t out_strides[NDIM + 2] = */
+        {out.strides()[0], out.strides()[1], 0, out.strides()[2]},
+        /* const int groups = */ groups,
+        /* const bool flip = */ flip};
+
+    dispatch_conv_2D_gpu(s, d, in, wt, out, conv_params, copies);
+    return;
+  }
+
+  // Make conv params
+  MLXConvParams<1> conv_params{
+      /* const int  N = */ static_cast<int>(in.shape(0)),
+      /* const int  C = */ static_cast<int>(in.shape(2)),
+      /* const int  O = */ static_cast<int>(wt.shape(0)),
+      /* const int iS[NDIM] = */ {static_cast<int>(in.shape(1))},
+      /* const int wS[NDIM] = */ {static_cast<int>(wt.shape(1))},
+      /* const int oS[NDIM] = */ {static_cast<int>(out.shape(1))},
+      /* const int str[NDIM] = */ {wt_strides[0]},
+      /* const int pad[NDIM] = */ {padding[0]},
+      /* const int kdil[NDIM] = */ {wt_dilation[0]},
+      /* const int idil[NDIM] = */ {in_dilation[0]},
+      /* const size_t in_strides[NDIM + 2] = */
+      {in.strides()[0], in.strides()[1], in.strides()[2]},
+      /* const size_t wt_strides[NDIM + 2] = */
+      {wt.strides()[0], wt.strides()[1], wt.strides()[2]},
+      /* const size_t out_strides[NDIM + 2] = */
+      {out.strides()[0], out.strides()[1], out.strides()[2]},
+      /* const int groups = */ groups,
+      /* const bool flip = */ flip};
+
+  // Direct to explicit gemm conv
+  if (groups > 1) {
+    return explicit_gemm_conv_group_ND_gpu(s, d, in, wt, out, conv_params);
+  } else {
+    return explicit_gemm_conv_ND_gpu(s, d, in, wt, out, conv_params);
+  }
+}
+
+void conv_2D_gpu(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    const std::vector<int>& in_dilation,
+    const int groups,
+    bool flip,
+    std::vector<array>& copies) {
+  // Make conv params
+  MLXConvParams<2> conv_params{
+      /* const int  N = */ static_cast<int>(in.shape(0)),
+      /* const int  C = */ static_cast<int>(in.shape(3)),
+      /* const int  O = */ static_cast<int>(wt.shape(0)),
+      /* const int iS[NDIM] = */
+      {static_cast<int>(in.shape(1)), static_cast<int>(in.shape(2))},
+      /* const int wS[NDIM] = */
+      {static_cast<int>(wt.shape(1)), static_cast<int>(wt.shape(2))},
+      /* const int oS[NDIM] = */
+      {static_cast<int>(out.shape(1)), static_cast<int>(out.shape(2))},
+      /* const int str[NDIM] = */ {wt_strides[0], wt_strides[1]},
+      /* const int pad[NDIM] = */ {padding[0], padding[1]},
+      /* const int kdil[NDIM] = */ {wt_dilation[0], wt_dilation[1]},
+      /* const int idil[NDIM] = */ {in_dilation[0], in_dilation[1]},
+      /* const size_t in_strides[NDIM + 2] = */
+      {in.strides(0), in.strides(1), in.strides(2), in.strides(3)},
+      /* const size_t wt_strides[NDIM + 2] = */
+      {wt.strides(0), wt.strides(1), wt.strides(2), wt.strides(3)},
+      /* const size_t out_strides[NDIM + 2] = */
+      {out.strides(0), out.strides(1), out.strides(2), out.strides(3)},
+      /* const int groups = */ groups,
+      /* const bool flip = */ flip,
+  };
+  dispatch_conv_2D_gpu(s, d, in, wt, out, conv_params, copies);
+}
+
+void conv_3D_gpu(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    const array& wt,
+    array out,
+    const std::vector<int>& padding,
+    const std::vector<int>& wt_strides,
+    const std::vector<int>& wt_dilation,
+    const std::vector<int>& in_dilation,
+    bool flip,
+    std::vector<array>& copies) {
+  // Make conv params
+  MLXConvParams<3> conv_params{
+      /* const int  N = */ static_cast<int>(in.shape(0)),
+      /* const int  C = */ static_cast<int>(in.shape(4)),
+      /* const int  O = */ static_cast<int>(wt.shape(0)),
+      /* const int iS[NDIM] = */
+      {static_cast<int>(in.shape(1)),
+       static_cast<int>(in.shape(2)),
+       static_cast<int>(in.shape(3))},
+      /* const int wS[NDIM] = */
+      {static_cast<int>(wt.shape(1)),
+       static_cast<int>(wt.shape(2)),
+       static_cast<int>(wt.shape(3))},
+      /* const int oS[NDIM] = */
+      {static_cast<int>(out.shape(1)),
+       static_cast<int>(out.shape(2)),
+       static_cast<int>(out.shape(3))},
+      /* const int str[NDIM] = */ {wt_strides[0], wt_strides[1], wt_strides[2]},
+      /* const int pad[NDIM] = */ {padding[0], padding[1], padding[2]},
+      /* const int kdil[NDIM] = */
+      {wt_dilation[0], wt_dilation[1], wt_dilation[2]},
+      /* const int idil[NDIM] = */
+      {in_dilation[0], in_dilation[1], in_dilation[2]},
+      /* const size_t in_strides[NDIM + 2] = */
+      {in.strides()[0],
+       in.strides()[1],
+       in.strides()[2],
+       in.strides()[3],
+       in.strides()[4]},
+      /* const size_t wt_strides[NDIM + 2] = */
+      {wt.strides()[0],
+       wt.strides()[1],
+       wt.strides()[2],
+       wt.strides()[3],
+       wt.strides()[4]},
+      /* const size_t out_strides[NDIM + 2] = */
+      {out.strides()[0],
+       out.strides()[1],
+       out.strides()[2],
+       out.strides()[3],
+       out.strides()[4]},
+      /* const int groups = */ 1,
+      /* const bool flip = */ flip,
+  };
+  return explicit_gemm_conv_ND_gpu(s, d, in, wt, out, conv_params);
+}
+
+} // namespace
+
+void Convolution::eval_gpu(const std::vector<array>& inputs, array& out) {
+  out.set_data(allocator::malloc(out.nbytes()));
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  // Ensure contiguity
+  std::vector<array> copies;
+  auto in = inputs[0];
+  auto wt = inputs[1];
+  if (!in.flags().row_contiguous) {
+    in = contiguous_copy_gpu(in, s);
+    copies.push_back(in);
+  }
+  if (!wt.flags().row_contiguous) {
+    wt = contiguous_copy_gpu(wt, s);
+    copies.push_back(wt);
+  }
+
+  // 3D conv
+  if (out.ndim() == 5) {
+    conv_3D_gpu(
+        s,
+        d,
+        in,
+        wt,
+        out,
+        padding_lo_,
+        kernel_strides_,
+        kernel_dilation_,
+        input_dilation_,
+        flip_,
+        copies);
+  }
+  // 2D conv
+  else if (out.ndim() == 4) {
+    conv_2D_gpu(
+        s,
+        d,
+        in,
+        wt,
+        out,
+        padding_lo_,
+        kernel_strides_,
+        kernel_dilation_,
+        input_dilation_,
+        groups_,
+        flip_,
+        copies);
+  }
+  // 1D conv
+  else if (out.ndim() == 3) {
+    conv_1D_gpu(
+        s,
+        d,
+        in,
+        wt,
+        out,
+        padding_lo_,
+        kernel_strides_,
+        kernel_dilation_,
+        input_dilation_,
+        groups_,
+        flip_,
+        copies);
+  }
+  // Throw error
+  else {
+    throw std::invalid_argument(
+        "[Convolution::eval_gpu] Only supports 1D, 2D or 3D convolutions.");
+  }
+
+  // Record copies
+  d.add_temporaries(std::move(copies), s.index);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/copy.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/copy.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d9c568e52dd67f358c4ee62ad2d0620175969092
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/copy.cpp
@@ -0,0 +1,204 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/utils.h"
+
+namespace mlx::core {
+
+constexpr int MAX_COPY_SPECIALIZED_DIMS = 3;
+
+void copy_gpu_inplace(
+    const array& in,
+    array& out,
+    const Shape& data_shape,
+    const Strides& strides_in_pre,
+    const Strides& strides_out_pre,
+    int64_t inp_offset,
+    int64_t out_offset,
+    CopyType ctype,
+    const Stream& s,
+    std::optional<array> dynamic_i_offset /* = std::nullopt */,
+    std::optional<array> dynamic_o_offset /* = std::nullopt */) {
+  if (out.size() == 0) {
+    return;
+  }
+
+  // Try to collapse contiguous dims
+  auto maybe_collapse =
+      [ctype, &data_shape, &strides_in_pre, &strides_out_pre]() {
+        if (ctype == CopyType::General || ctype == CopyType::GeneralGeneral) {
+          auto [shape, strides] = collapse_contiguous_dims(
+              data_shape,
+              std::vector{strides_in_pre, strides_out_pre},
+              /* size_cap = */ INT32_MAX);
+          return std::make_tuple(shape, strides[0], strides[1]);
+        } else {
+          Strides e{};
+          return std::make_tuple(Shape{}, e, e);
+        }
+      };
+  auto [shape, strides_in_, strides_out_] = maybe_collapse();
+  int ndim = shape.size();
+  bool large;
+  if (ctype == CopyType::General || ctype == CopyType::GeneralGeneral) {
+    // Allow for negative strides
+    large = in.data_size() > INT32_MAX || out.data_size() > INT32_MAX;
+  } else {
+    large = out.data_size() > UINT32_MAX;
+  }
+  bool dynamic = dynamic_i_offset || dynamic_o_offset;
+  auto& d = metal::device(s.device);
+  int work_per_thread = 1;
+  std::string kernel_name;
+  switch (ctype) {
+    case CopyType::Scalar:
+      kernel_name = large ? "s2" : "s";
+      break;
+    case CopyType::Vector:
+      kernel_name = large ? "v2" : "v";
+      break;
+    case CopyType::General:
+      kernel_name = "g";
+      break;
+    case CopyType::GeneralGeneral:
+      kernel_name = "gg";
+      break;
+  }
+  if (ctype == CopyType::General || ctype == CopyType::GeneralGeneral) {
+    if (shape.size() <= MAX_COPY_SPECIALIZED_DIMS) {
+      kernel_name += std::to_string(shape.size());
+    } else {
+      work_per_thread = large ? 4 : 2;
+      concatenate(kernel_name, "n", std::to_string(work_per_thread));
+    }
+    if (large) {
+      kernel_name += "large";
+    }
+    if (dynamic) {
+      kernel_name += "_dynamic";
+      if (ctype != CopyType::GeneralGeneral) {
+        throw std::runtime_error(
+            "[Copy::eval_gpu] Dynamic output offset requires GeneralGeneral copy");
+      }
+    }
+  } else {
+    work_per_thread = get_work_per_thread(out.dtype(), out.data_size());
+    if (!large && work_per_thread > 1) {
+      kernel_name += "n";
+    }
+  }
+  concatenate(kernel_name, "_copy", type_to_name(in), type_to_name(out));
+  auto kernel = dynamic ? get_dynamic_copy_kernel(d, kernel_name, in, out)
+                        : get_copy_kernel(d, kernel_name, in, out);
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+  bool donate_in = in.data_shared_ptr() == nullptr;
+
+  inp_offset *= size_of(in.dtype());
+  out_offset *= size_of(out.dtype());
+
+  compute_encoder.set_input_array(donate_in ? out : in, 0, inp_offset);
+  compute_encoder.set_output_array(out, 1, out_offset);
+
+  auto thread_group_size = kernel->maxTotalThreadsPerThreadgroup();
+  if (ctype == CopyType::General || ctype == CopyType::GeneralGeneral) {
+    Strides strides_in{strides_in_.begin(), strides_in_.end()};
+    Strides strides_out{strides_out_.begin(), strides_out_.end()};
+    if (ndim > 3) {
+      compute_encoder.set_vector_bytes(shape, ndim, 2);
+    }
+    compute_encoder.set_vector_bytes(strides_in, ndim, 3);
+    if (ctype == CopyType::GeneralGeneral) {
+      compute_encoder.set_vector_bytes(strides_out, ndim, 4);
+    }
+
+    size_t dim0 = ndim > 0 ? shape[ndim - 1] : 1;
+    size_t dim1 = ndim > 1 ? shape[ndim - 2] : 1;
+
+    size_t data_size = 1;
+    for (auto& s : shape)
+      data_size *= s;
+    size_t rest = data_size / (dim0 * dim1);
+
+    if (ndim > MAX_COPY_SPECIALIZED_DIMS) {
+      compute_encoder.set_bytes(ndim, 5);
+      dim0 = (dim0 + work_per_thread - 1) / work_per_thread;
+    }
+    if (dynamic) {
+      if (dynamic_i_offset) {
+        compute_encoder.set_input_array(*dynamic_i_offset, 6);
+      } else {
+        compute_encoder.set_bytes(0ll, 6);
+      }
+      if (dynamic_o_offset) {
+        compute_encoder.set_input_array(*dynamic_o_offset, 7);
+      } else {
+        compute_encoder.set_bytes(0ll, 7);
+      }
+    }
+
+    // NB assuming thread_group_size is a power of 2 larger than 32 x 32
+    if (thread_group_size != 1024) {
+      throw std::runtime_error("[Metal::copy] Must use 1024 sized block");
+    }
+
+    auto group_dims = get_block_dims(dim0, dim1, rest);
+    MTL::Size grid_dims = MTL::Size(dim0, dim1, rest);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  } else {
+    size_t nthreads = ceildiv(out.data_size(), work_per_thread);
+    if (thread_group_size > nthreads) {
+      thread_group_size = nthreads;
+    }
+    MTL::Size group_dims = MTL::Size(thread_group_size, 1, 1);
+    MTL::Size grid_dims;
+    if (large) {
+      compute_encoder.set_bytes<int64_t>(out.data_size(), 2);
+      grid_dims = get_2d_grid_dims(out.shape(), out.strides(), work_per_thread);
+    } else {
+      compute_encoder.set_bytes<int>(out.data_size(), 2);
+      grid_dims = MTL::Size(nthreads, 1, 1);
+    }
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+}
+
+void fill_gpu(const array& val, array& out, const Stream& s) {
+  if (out.size() == 0) {
+    return;
+  }
+  out.set_data(allocator::malloc(out.nbytes()));
+  bool large = out.data_size() > UINT32_MAX;
+  int work_per_thread = get_work_per_thread(out.dtype(), out.data_size());
+  auto& d = metal::device(s.device);
+  std::string kernel_name = large ? "s2" : (work_per_thread > 1 ? "sn" : "s");
+  concatenate(kernel_name, "_copy", type_to_name(val), type_to_name(out));
+  auto kernel = get_copy_kernel(d, kernel_name, val, out);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  compute_encoder.set_input_array(val, 0);
+  compute_encoder.set_output_array(out, 1);
+
+  auto thread_group_size = kernel->maxTotalThreadsPerThreadgroup();
+  size_t nthreads = ceildiv(out.data_size(), work_per_thread);
+  if (thread_group_size > nthreads) {
+    thread_group_size = nthreads;
+  }
+  MTL::Size group_dims = MTL::Size(thread_group_size, 1, 1);
+  MTL::Size grid_dims;
+  if (large) {
+    compute_encoder.set_bytes<int64_t>(out.data_size(), 2);
+    grid_dims = get_2d_grid_dims(out.shape(), out.strides(), work_per_thread);
+  } else {
+    compute_encoder.set_bytes<int>(out.data_size(), 2);
+    grid_dims = MTL::Size(nthreads, 1, 1);
+  }
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/custom_kernel.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/custom_kernel.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..41e399ce392195a7805c6dde8d518a4fc75e85af
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/custom_kernel.cpp
@@ -0,0 +1,426 @@
+// Copyright © 2024 Apple Inc.
+
+#include <iostream>
+#include <regex>
+
+#include "mlx/backend/common/compiled.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/jit/includes.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/fast.h"
+#include "mlx/fast_primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core::fast {
+
+struct CustomKernelCache {
+  std::unordered_map<std::string, std::string> libraries;
+};
+
+static CustomKernelCache& cache() {
+  static CustomKernelCache cache_;
+  return cache_;
+};
+
+std::string write_signature(
+    std::string func_name,
+    const std::string& header,
+    const std::string& source,
+    const std::vector<std::string>& input_names,
+    const std::vector<array>& inputs,
+    const std::vector<std::string>& output_names,
+    const std::vector<Dtype>& output_dtypes,
+    const std::vector<std::pair<std::string, TemplateArg>>& template_args,
+    const std::vector<std::string>& attributes,
+    const std::vector<CustomKernelShapeInfo>& shape_infos,
+    bool atomic_outputs) {
+  std::string kernel_source;
+  kernel_source.reserve(header.size() + source.size() + 16384);
+  kernel_source += header;
+  // Auto-generate a function signature based on `template_args`
+  // and the dtype/shape of the arrays passed as `inputs`.
+  if (!template_args.empty()) {
+    kernel_source += "template <";
+    int i = 0;
+    for (const auto& [name, arg] : template_args) {
+      std::string param_type;
+      if (std::holds_alternative<int>(arg)) {
+        param_type = "int";
+      } else if (std::holds_alternative<bool>(arg)) {
+        param_type = "bool";
+      } else if (std::holds_alternative<Dtype>(arg)) {
+        param_type = "typename";
+      }
+      if (i > 0) {
+        kernel_source += ", ";
+      }
+      kernel_source += param_type;
+      kernel_source += " ";
+      kernel_source += name;
+      i++;
+    }
+    kernel_source += ">\n";
+  }
+  kernel_source += "[[kernel]] void ";
+  kernel_source += func_name;
+  kernel_source += "(\n";
+
+  int index = 0;
+  constexpr int max_constant_array_size = 8;
+  // Add inputs
+  for (int i = 0; i < inputs.size(); ++i) {
+    const auto& name = input_names[i];
+    const auto& arr = inputs[i];
+    auto dtype = get_type_string(arr.dtype());
+    std::string location =
+        arr.size() < max_constant_array_size ? "constant" : "device";
+    std::string ref = arr.ndim() == 0 ? "&" : "*";
+    kernel_source += "  const ";
+    kernel_source += location;
+    kernel_source += " ";
+    kernel_source += dtype;
+    kernel_source += ref;
+    kernel_source += " ";
+    kernel_source += name;
+    kernel_source += " [[buffer(";
+    kernel_source += std::to_string(index);
+    kernel_source += ")]],\n";
+    index++;
+    // Add input shape, strides and ndim if present in the source
+    if (arr.ndim() > 0) {
+      if (shape_infos[i].shape) {
+        kernel_source +=
+            ("  const constant int* " + name + "_shape [[buffer(" +
+             std::to_string(index) + ")]],\n");
+        index++;
+      }
+      if (shape_infos[i].strides) {
+        kernel_source +=
+            ("  const constant int64_t* " + name + "_strides [[buffer(" +
+             std::to_string(index) + ")]],\n");
+        index++;
+      }
+      if (shape_infos[i].ndim) {
+        kernel_source +=
+            ("  const constant int& " + name + "_ndim [[buffer(" +
+             std::to_string(index) + ")]],\n");
+        index++;
+      }
+    }
+  }
+  // Add outputs
+  for (int i = 0; i < output_names.size(); ++i) {
+    const auto& name = output_names[i];
+    const auto& dtype = output_dtypes[i];
+    kernel_source += "  device ";
+    auto type_string = get_type_string(dtype);
+    if (atomic_outputs) {
+      kernel_source += "atomic<";
+    }
+    kernel_source += type_string;
+    if (atomic_outputs) {
+      kernel_source += ">";
+    }
+    kernel_source += "* ";
+    kernel_source += name;
+    kernel_source += " [[buffer(";
+    kernel_source += std::to_string(index);
+    kernel_source += ")]]";
+    if (index < inputs.size() + output_names.size() - 1 ||
+        attributes.size() > 0) {
+      kernel_source += ",\n";
+    } else {
+      kernel_source += ") {\n";
+    }
+    index++;
+  }
+
+  index = 0;
+  for (const auto& attr : attributes) {
+    kernel_source += attr;
+    if (index < attributes.size() - 1) {
+      kernel_source += ",\n";
+    } else {
+      kernel_source += ") {\n";
+    }
+    index++;
+  }
+  kernel_source += source;
+  kernel_source += "\n}\n";
+  return kernel_source;
+}
+
+std::string write_template(
+    const std::vector<std::pair<std::string, TemplateArg>>& template_args) {
+  std::ostringstream template_def;
+  template_def << "<";
+  int i = 0;
+  for (const auto& [name, arg] : template_args) {
+    if (i > 0) {
+      template_def << ", ";
+    }
+    if (std::holds_alternative<int>(arg)) {
+      template_def << std::get<int>(arg);
+    } else if (std::holds_alternative<bool>(arg)) {
+      template_def << std::get<bool>(arg);
+    } else if (std::holds_alternative<Dtype>(arg)) {
+      template_def << get_type_string(std::get<Dtype>(arg));
+    }
+    i++;
+  }
+  template_def << ">";
+  return template_def.str();
+}
+
+CustomKernelFunction metal_kernel(
+    const std::string& name,
+    const std::vector<std::string>& input_names,
+    const std::vector<std::string>& output_names,
+    const std::string& source,
+    const std::string& header /* = "" */,
+    bool ensure_row_contiguous /* = true */,
+    bool atomic_outputs /* = false */) {
+  if (output_names.empty()) {
+    throw std::invalid_argument(
+        "[metal_kernel] Must specify at least one output.");
+  }
+  std::vector<CustomKernelShapeInfo> shape_infos;
+  for (auto& n : input_names) {
+    CustomKernelShapeInfo shape_info;
+    shape_info.shape = source.find(n + "_shape") != std::string::npos;
+    shape_info.strides = source.find(n + "_strides") != std::string::npos;
+    shape_info.ndim = source.find(n + "_ndim") != std::string::npos;
+    shape_infos.push_back(shape_info);
+  }
+  const std::vector<std::pair<std::string, std::string>> metal_attributes = {
+      {"dispatch_quadgroups_per_threadgroup", "uint"},
+      {"dispatch_simdgroups_per_threadgroup", "uint"},
+      {"dispatch_threads_per_threadgroup", "uint3"},
+      {"grid_origin", "uint3"},
+      {"grid_size", "uint3"},
+      {"quadgroup_index_in_threadgroup", "uint"},
+      {"quadgroups_per_threadgroup", "uint"},
+      {"simdgroup_index_in_threadgroup", "uint"},
+      {"simdgroups_per_threadgroup", "uint"},
+      {"thread_execution_width", "uint"},
+      {"thread_index_in_quadgroup", "uint"},
+      {"thread_index_in_simdgroup", "uint"},
+      {"thread_index_in_threadgroup", "uint"},
+      {"thread_position_in_grid", "uint3"},
+      {"thread_position_in_threadgroup", "uint3"},
+      {"threadgroup_position_in_grid", "uint3"},
+      {"threadgroups_per_grid", "uint3"},
+      {"threads_per_grid", "uint3"},
+      {"threads_per_simdgroup", "uint"},
+      {"threads_per_threadgroup", "uint3"},
+  };
+
+  std::vector<std::string> attributes;
+  for (const auto& [attr, dtype] : metal_attributes) {
+    if (source.find(attr) != std::string::npos) {
+      attributes.push_back("  " + dtype + " " + attr + " [[" + attr + "]]");
+    }
+  }
+
+  return [=,
+          shape_infos = std::move(shape_infos),
+          attributes = std::move(attributes)](
+             const std::vector<array>& inputs,
+             const std::vector<Shape>& output_shapes,
+             const std::vector<Dtype>& output_dtypes,
+             std::tuple<int, int, int> grid,
+             std::tuple<int, int, int> threadgroup,
+             const std::vector<std::pair<std::string, TemplateArg>>&
+                 template_args = {},
+             std::optional<float> init_value = std::nullopt,
+             bool verbose = false,
+             StreamOrDevice s_ = {}) {
+    if (inputs.size() != input_names.size()) {
+      std::ostringstream msg;
+      msg << "[metal_kernel] Expected `inputs` to have size "
+          << input_names.size() << " but got size " << inputs.size() << "."
+          << std::endl;
+      throw std::invalid_argument(msg.str());
+    }
+    if (output_shapes.size() != output_names.size()) {
+      std::ostringstream msg;
+      msg << "[metal_kernel] Expected `output_shapes` to have size "
+          << output_names.size() << " but got size " << output_shapes.size()
+          << "." << std::endl;
+      throw std::invalid_argument(msg.str());
+    }
+    if (output_dtypes.size() != output_names.size()) {
+      std::ostringstream msg;
+      msg << "[metal_kernel] Expected `output_dtypes` to have size "
+          << output_names.size() << " but got size " << output_dtypes.size()
+          << "." << std::endl;
+      throw std::invalid_argument(msg.str());
+    }
+
+    auto s = to_stream(s_);
+    if (s.device != Device::gpu) {
+      throw std::invalid_argument("[metal_kernel] Only supports the GPU.");
+    }
+
+    std::string kernel_name = "custom_kernel_" + name;
+    std::string template_def = "";
+    if (!template_args.empty()) {
+      std::regex disallowed_chars("\\<|\\>|(, )");
+      template_def = write_template(template_args);
+      auto template_hash =
+          std::regex_replace(template_def, disallowed_chars, "_");
+      template_hash.pop_back();
+      kernel_name += "_";
+      kernel_name += template_hash;
+    }
+
+    std::string kernel_source = write_signature(
+        kernel_name,
+        header,
+        source,
+        input_names,
+        inputs,
+        output_names,
+        output_dtypes,
+        template_args,
+        attributes,
+        shape_infos,
+        atomic_outputs);
+
+    if (!template_args.empty()) {
+      template_def = kernel_name + template_def;
+      kernel_source += "\ntemplate [[host_name(\"";
+      kernel_source += kernel_name;
+      kernel_source += "\")]] [[kernel]] decltype(";
+      kernel_source += template_def;
+      kernel_source += ") ";
+      kernel_source += template_def;
+      kernel_source += ";\n";
+    }
+
+    if (verbose) {
+      std::cout << "Generated source code for `" << name << "`:" << std::endl
+                << "```" << std::endl
+                << kernel_source << std::endl
+                << "```" << std::endl;
+    }
+
+    return array::make_arrays(
+        std::move(output_shapes),
+        std::move(output_dtypes),
+        std::make_shared<CustomKernel>(
+            s,
+            std::move(kernel_name),
+            std::move(kernel_source),
+            grid,
+            threadgroup,
+            shape_infos,
+            ensure_row_contiguous,
+            init_value,
+            std::vector<ScalarArg>{},
+            false,
+            0),
+        std::move(inputs));
+  };
+}
+
+void CustomKernel::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  auto& s = stream();
+
+  std::vector<array> copies;
+
+  for (auto& out : outputs) {
+    if (init_value_) {
+      copies.emplace_back(init_value_.value(), out.dtype());
+      fill_gpu(copies.back(), out, s);
+    } else {
+      out.set_data(allocator::malloc(out.nbytes()));
+    }
+  }
+
+  auto check_input = [&copies, &s, this](const array& x) -> const array {
+    bool no_copy = x.flags().row_contiguous;
+    if (!ensure_row_contiguous_ || no_copy) {
+      return x;
+    } else {
+      copies.push_back(array(x.shape(), x.dtype(), nullptr, {}));
+      copy_gpu(x, copies.back(), CopyType::General, s);
+      return copies.back();
+    }
+  };
+  std::vector<array> checked_inputs;
+  for (const array& in : inputs) {
+    checked_inputs.push_back(check_input(in));
+  }
+
+  auto& d = metal::device(s.device);
+
+  {
+    // Clear kernels from the device library cache if needed
+    auto& kernel_cache = cache();
+    if (auto it = kernel_cache.libraries.find(name_);
+        it != kernel_cache.libraries.end()) {
+      if (it->second != source_) {
+        auto& d = metal::device(s.device);
+        d.clear_library(name_);
+        it->second = source_;
+      }
+    } else {
+      kernel_cache.libraries.emplace(name_, source_);
+    }
+  }
+
+  auto lib = d.get_library(name_, [this] { return metal::utils() + source_; });
+  auto kernel = d.get_kernel(name_, lib);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+  int index = 0;
+  for (int i = 0; i < checked_inputs.size(); i++) {
+    const array& in = checked_inputs[i];
+    auto& shape_info = shape_infos_[i];
+    compute_encoder.set_input_array(in, index);
+    index++;
+    if (in.ndim() > 0) {
+      int ndim = in.ndim();
+      if (shape_info.shape) {
+        compute_encoder.set_vector_bytes(in.shape(), ndim, index);
+        index++;
+      }
+      if (shape_info.strides) {
+        compute_encoder.set_vector_bytes(in.strides(), ndim, index);
+        index++;
+      }
+      if (shape_info.ndim) {
+        compute_encoder.set_bytes(ndim, index);
+        index++;
+      }
+    }
+  }
+  for (auto& out : outputs) {
+    compute_encoder.set_output_array(out, index);
+    index++;
+  }
+
+  const auto [tx, ty, tz] = threadgroup_;
+  auto tg_size = tx * ty * tz;
+  auto max_tg_size = kernel->maxTotalThreadsPerThreadgroup();
+  if (tg_size > max_tg_size) {
+    std::ostringstream msg;
+    msg << "Thread group size (" << tg_size << ") is greater than "
+        << " the maximum allowed threads per threadgroup (" << max_tg_size
+        << ").";
+    throw std::invalid_argument(msg.str());
+  }
+
+  const auto [gx, gy, gz] = grid_;
+  MTL::Size group_dims =
+      MTL::Size(std::min(tx, gx), std::min(ty, gy), std::min(tz, gz));
+  MTL::Size grid_dims = MTL::Size(gx, gy, gz);
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+
+  d.add_temporaries(std::move(copies), s.index);
+}
+
+} // namespace mlx::core::fast
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/device.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/device.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..352958a89b18a2af2546468e6a84a3524b62d31c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/device.cpp
@@ -0,0 +1,789 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <cstdlib>
+#include <sstream>
+
+#define NS_PRIVATE_IMPLEMENTATION
+#define CA_PRIVATE_IMPLEMENTATION
+#define MTL_PRIVATE_IMPLEMENTATION
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/metal.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/utils.h"
+
+namespace mlx::core::metal {
+
+namespace {
+
+constexpr const char* default_mtllib_path = METAL_PATH;
+
+auto get_metal_version() {
+  auto get_metal_version_ = []() {
+    if (__builtin_available(macOS 15, iOS 18, tvOS 18, visionOS 2, *)) {
+      return MTL::LanguageVersion3_2;
+    } else if (__builtin_available(macOS 14, iOS 17, tvOS 17, visionOS 1, *)) {
+      return MTL::LanguageVersion3_1;
+    } else {
+      return MTL::LanguageVersion3_0;
+    }
+  };
+  static auto metal_version_ = get_metal_version_();
+  return metal_version_;
+}
+
+auto load_device() {
+  auto devices = MTL::CopyAllDevices();
+  auto device = static_cast<MTL::Device*>(devices->object(0))
+      ?: MTL::CreateSystemDefaultDevice();
+  if (!device) {
+    throw std::runtime_error("Failed to load device");
+  }
+  return device;
+}
+std::pair<MTL::Library*, NS::Error*> load_library_from_path(
+    MTL::Device* device,
+    const char* path) {
+  auto library = NS::String::string(path, NS::UTF8StringEncoding);
+  NS::Error* error;
+  auto lib = device->newLibrary(library, &error);
+
+  return std::make_pair(lib, error);
+}
+
+#ifdef SWIFTPM_BUNDLE
+MTL::Library* try_load_bundle(
+    MTL::Device* device,
+    NS::URL* url,
+    const std::string& lib_name) {
+  std::string bundle_path = std::string(url->fileSystemRepresentation()) + "/" +
+      SWIFTPM_BUNDLE + ".bundle";
+  auto bundle = NS::Bundle::alloc()->init(
+      NS::String::string(bundle_path.c_str(), NS::UTF8StringEncoding));
+  if (bundle != nullptr) {
+    std::string resource_path =
+        std::string(bundle->resourceURL()->fileSystemRepresentation()) + "/" +
+        lib_name + ".metallib";
+    auto [lib, error] = load_library_from_path(device, resource_path.c_str());
+    if (lib) {
+      return lib;
+    }
+  }
+  return nullptr;
+}
+#endif
+
+// Firstly, search for the metallib in the same path as this binary
+std::pair<MTL::Library*, NS::Error*> load_colocated_library(
+    MTL::Device* device,
+    const std::string& relative_path) {
+  auto path = current_binary_dir() / relative_path;
+  if (!path.has_extension()) {
+    path.replace_extension(".metallib");
+  }
+
+  return load_library_from_path(device, path.c_str());
+}
+
+std::pair<MTL::Library*, NS::Error*> load_swiftpm_library(
+    MTL::Device* device,
+    const std::string& lib_name) {
+#ifdef SWIFTPM_BUNDLE
+  MTL::Library* library =
+      try_load_bundle(device, NS::Bundle::mainBundle()->bundleURL(), lib_name);
+  if (library != nullptr) {
+    return {library, nullptr};
+  }
+  auto bundles = NS::Bundle::allBundles();
+  for (int i = 0, c = (int)bundles->count(); i < c; i++) {
+    auto bundle = reinterpret_cast<NS::Bundle*>(bundles->object(i));
+    library = try_load_bundle(device, bundle->resourceURL(), lib_name);
+    if (library != nullptr) {
+      return {library, nullptr};
+    }
+  }
+#endif
+  return {nullptr, nullptr};
+}
+
+MTL::Library* load_default_library(MTL::Device* device) {
+  NS::Error* error[5];
+  MTL::Library* lib;
+  // First try the colocated mlx.metallib
+  std::tie(lib, error[0]) = load_colocated_library(device, "mlx");
+  if (lib) {
+    return lib;
+  }
+
+  std::tie(lib, error[1]) = load_colocated_library(device, "Resources/mlx");
+  if (lib) {
+    return lib;
+  }
+
+  // Then try default.metallib in a SwiftPM bundle if we have one
+  std::tie(lib, error[2]) = load_swiftpm_library(device, "default");
+  if (lib) {
+    return lib;
+  }
+
+  // Try lo load resources from Framework resources if SwiftPM wrapped as a
+  // dynamic framework.
+  std::tie(lib, error[3]) = load_colocated_library(device, "Resources/default");
+  if (lib) {
+    return lib;
+  }
+
+  // Finally try default_mtllib_path
+  std::tie(lib, error[4]) = load_library_from_path(device, default_mtllib_path);
+  if (!lib) {
+    std::ostringstream msg;
+    msg << "Failed to load the default metallib. ";
+    for (int i = 0; i < 5; i++) {
+      if (error[i] != nullptr) {
+        msg << error[i]->localizedDescription()->utf8String() << " ";
+      }
+    }
+    throw std::runtime_error(msg.str());
+  }
+  return lib;
+}
+
+MTL::Library* load_library(
+    MTL::Device* device,
+    const std::string& lib_name,
+    const std::string& lib_path) {
+  // We have been given a path that ends in metallib so try to load it
+  if (lib_path.size() > 9 &&
+      std::equal(lib_path.end() - 9, lib_path.end(), ".metallib")) {
+    auto [lib, error] = load_library_from_path(device, lib_path.c_str());
+    if (!lib) {
+      std::ostringstream msg;
+      msg << "Failed to load the metallib from <" << lib_path << "> with error "
+          << error->localizedDescription()->utf8String();
+      throw std::runtime_error(msg.str());
+    }
+    return lib;
+  }
+
+  // We have been given a path so try to load from lib_path / lib_name.metallib
+  if (lib_path.size() > 0) {
+    std::string full_path = lib_path + "/" + lib_name + ".metallib";
+    auto [lib, error] = load_library_from_path(device, full_path.c_str());
+    if (!lib) {
+      std::ostringstream msg;
+      msg << "Failed to load the metallib from <" << full_path
+          << "> with error " << error->localizedDescription()->utf8String();
+      throw std::runtime_error(msg.str());
+    }
+    return lib;
+  }
+
+  // Try to load the colocated library
+  {
+    auto [lib, error] = load_colocated_library(device, lib_name);
+    if (lib) {
+      return lib;
+    }
+  }
+
+  // Try to load the library from swiftpm
+  {
+    auto [lib, error] = load_swiftpm_library(device, lib_name);
+    if (lib) {
+      return lib;
+    }
+  }
+
+  std::ostringstream msg;
+  msg << "Failed to load the metallib " << lib_name << ".metallib. "
+      << "We attempted to load it from <" << current_binary_dir() << "/"
+      << lib_name << ".metallib" << ">";
+#ifdef SWIFTPM_BUNDLE
+  msg << " and from the Swift PM bundle.";
+#endif
+  throw std::runtime_error(msg.str());
+}
+
+} // namespace
+
+CommandEncoder::CommandEncoder(DeviceStream& stream) : stream_(stream) {
+  enc_ = stream_.buffer->computeCommandEncoder(MTL::DispatchTypeConcurrent);
+  enc_->retain();
+}
+
+CommandEncoder::~CommandEncoder() {
+  enc_->endEncoding();
+  enc_->release();
+}
+
+void CommandEncoder::set_buffer(
+    const MTL::Buffer* buf,
+    int idx,
+    int64_t offset /* = 0 */) {
+  enc_->setBuffer(buf, offset, idx);
+}
+
+void CommandEncoder::set_input_array(
+    const array& a,
+    int idx,
+    int64_t offset /* = 0 */) {
+  if (all_inputs_.insert(a.buffer().ptr()).second) {
+    stream_.buffer_sizes += a.data_size();
+  }
+  auto r_buf = static_cast<MTL::Resource*>(const_cast<void*>(a.buffer().ptr()));
+  needs_barrier_ =
+      needs_barrier_ | (prev_outputs_.find(r_buf) != prev_outputs_.end());
+  auto a_buf = static_cast<const MTL::Buffer*>(a.buffer().ptr());
+  auto base_offset = a.data<char>() -
+      static_cast<char*>(const_cast<MTL::Buffer*>(a_buf)->contents());
+  base_offset += offset;
+  enc_->setBuffer(a_buf, base_offset, idx);
+}
+
+void CommandEncoder::set_output_array(
+    array& a,
+    int idx,
+    int64_t offset /* = 0 */) {
+  // Add barriers before adding the output to the output set
+  set_input_array(a, idx, offset);
+  register_output_array(a);
+}
+
+void CommandEncoder::register_output_array(const array& a) {
+  all_outputs_.insert(a.buffer().ptr());
+
+  auto buf = static_cast<MTL::Resource*>(const_cast<void*>(a.buffer().ptr()));
+  if (concurrent_) {
+    concurrent_outputs_.insert(buf);
+  } else {
+    next_outputs_.insert(buf);
+  }
+}
+
+void CommandEncoder::maybeInsertBarrier() {
+  if (needs_barrier_) {
+    enc_->memoryBarrier(MTL::BarrierScopeBuffers);
+    needs_barrier_ = false;
+    prev_outputs_ = std::move(next_outputs_);
+  } else {
+    prev_outputs_.insert(next_outputs_.begin(), next_outputs_.end());
+  }
+  next_outputs_.clear();
+}
+
+void CommandEncoder::dispatch_threadgroups(
+    MTL::Size grid_dims,
+    MTL::Size group_dims) {
+  maybeInsertBarrier();
+  stream_.buffer_ops++;
+  enc_->dispatchThreadgroups(grid_dims, group_dims);
+}
+
+void CommandEncoder::dispatch_threads(
+    MTL::Size grid_dims,
+    MTL::Size group_dims) {
+  maybeInsertBarrier();
+  stream_.buffer_ops++;
+  enc_->dispatchThreads(grid_dims, group_dims);
+}
+
+void CommandEncoder::barrier() {
+  enc_->memoryBarrier(MTL::BarrierScopeBuffers);
+}
+
+Device::Device() {
+  auto pool = new_scoped_memory_pool();
+  device_ = load_device();
+  default_library_ = load_default_library(device_);
+  arch_ = std::string(device_->architecture()->name()->utf8String());
+  int ag_tens = arch_[arch_.size() - 3] - '0';
+  int ag_ones = arch_[arch_.size() - 2] - '0';
+  arch_gen_ = ag_tens * 10 + ag_ones;
+  auto arch = arch_.back();
+  switch (arch) {
+    case 'p': // phone
+      max_ops_per_buffer_ = 20;
+      max_mb_per_buffer_ = 40;
+      break;
+    case 'g': // base, pro
+      max_ops_per_buffer_ = 40;
+      max_mb_per_buffer_ = 40;
+      break;
+    case 's': // max
+      max_ops_per_buffer_ = 50;
+      max_mb_per_buffer_ = 50;
+      break;
+    case 'd': // ultra
+      max_ops_per_buffer_ = 50;
+      max_mb_per_buffer_ = 50;
+      break;
+    default: // default to medium
+      max_ops_per_buffer_ = 40;
+      max_mb_per_buffer_ = 40;
+      break;
+  }
+  max_ops_per_buffer_ = env::max_ops_per_buffer(max_ops_per_buffer_);
+  max_mb_per_buffer_ = env::max_mb_per_buffer(max_mb_per_buffer_);
+}
+
+Device::~Device() {
+  auto pool = new_scoped_memory_pool();
+  for (auto& [l, kernel_map] : library_kernels_) {
+    l->release();
+    for (auto& [_, k] : kernel_map) {
+      k->release();
+    }
+  }
+  stream_map_.clear();
+  device_->release();
+}
+
+void Device::new_queue(int index) {
+  auto thread_pool = metal::new_scoped_memory_pool();
+  auto q = device_->newCommandQueue();
+  debug_set_stream_queue_label(q, index);
+  if (!q) {
+    throw std::runtime_error(
+        "[metal::Device] Failed to make new command queue.");
+  }
+  stream_map_.emplace(index, q);
+  if (residency_set_ != nullptr) {
+    q->addResidencySet(residency_set_);
+  }
+}
+
+MTL::CommandQueue* Device::get_queue(Stream stream) {
+  return get_stream_(stream.index).queue;
+}
+
+bool Device::command_buffer_needs_commit(int index) {
+  auto& stream = get_stream_(index);
+  if (stream.buffer_ops > max_ops_per_buffer_ ||
+      (stream.buffer_sizes >> 20) > max_mb_per_buffer_) {
+    return true;
+  }
+  return false;
+}
+
+MTL::CommandBuffer* Device::get_command_buffer(int index) {
+  auto& stream = get_stream_(index);
+  if (stream.buffer == nullptr) {
+    stream.buffer = stream.queue->commandBufferWithUnretainedReferences();
+    if (!stream.buffer) {
+      throw std::runtime_error(
+          "[metal::Device] Unable to create new command buffer");
+    }
+    // Increment ref count so the buffer is not garbage collected
+    stream.buffer->retain();
+  }
+  return stream.buffer;
+}
+
+void Device::commit_command_buffer(int index) {
+  auto& stream = get_stream_(index);
+  stream.buffer->commit();
+  stream.buffer->release();
+  stream.buffer = nullptr;
+  stream.buffer_ops = 0;
+  stream.buffer_sizes = 0;
+}
+
+void Device::add_temporary(array arr, int index) {
+  get_stream_(index).temporaries.push_back(std::move(arr));
+}
+
+void Device::add_temporaries(std::vector<array> arrays, int index) {
+  if (arrays.empty()) {
+    return;
+  }
+  auto& stream = get_stream_(index);
+  stream.temporaries.insert(
+      stream.temporaries.end(),
+      std::make_move_iterator(arrays.begin()),
+      std::make_move_iterator(arrays.end()));
+}
+
+void Device::end_encoding(int index) {
+  auto& stream = get_stream_(index);
+  if (stream.encoder != nullptr) {
+    // Each command encoder has a unique fence. We also store a map of
+    // all previous outputs of command encoders to their corresponding fence.
+    // - The command encoder records its inputs and outputs.
+    // - Wait on a fence if any inputs in the encoder are outputs of a previous
+    //   encoder.
+    // - Update the map of outputs to include this command encoder's outputs.
+    // - Always signal this command encoders fence.
+    // - Add a completion handler for this command encoder that removes outputs
+    //   from the map to limit the growth of the map and avoid unnecessary waits
+    // - Temporaries are a special case as they do not cross command encoder
+    //   boundaries. These can be removed early from the encoders inputs and
+    //   outputs since they don't need synchronization.
+    auto& enc = *stream.encoder;
+    // Remove temporaries from inputs and outputs
+    for (auto& t : stream.temporaries) {
+      if (t.data<void>() != nullptr) {
+        enc.outputs().erase(t.buffer().ptr());
+        enc.inputs().erase(t.buffer().ptr());
+      }
+    }
+
+    // Keep references to the fences we waited on and put them
+    // in the completion handler so they are not prematurely released
+    std::unordered_set<std::shared_ptr<Fence>> waiting_on;
+    {
+      std::lock_guard<std::mutex> lk(stream.fence_mtx);
+      for (auto in : enc.inputs()) {
+        if (auto it = stream.outputs.find(in); it != stream.outputs.end()) {
+          // If we've already waited on a fence, don't wait on it again.
+          if (waiting_on.find(it->second) == waiting_on.end()) {
+            enc.wait_for_fence(it->second->fence);
+            waiting_on.insert(it->second);
+          }
+        }
+      }
+      for (auto out : enc.outputs()) {
+        stream.outputs[out] = stream.fence;
+      }
+    }
+    enc.update_fence(stream.fence->fence);
+    stream.buffer->addCompletedHandler(
+        [&stream,
+         waiting_on = std::move(waiting_on),
+         fence = std::move(stream.fence),
+         outputs = std::move(enc.outputs()),
+         temporaries =
+             std::move(stream.temporaries)](MTL::CommandBuffer*) mutable {
+          temporaries.clear();
+          std::lock_guard<std::mutex> lk(stream.fence_mtx);
+          for (auto o : outputs) {
+            if (auto it = stream.outputs.find(o); it != stream.outputs.end()) {
+              if (it->second == fence) {
+                stream.outputs.erase(it);
+              }
+            }
+          }
+        });
+  }
+  stream.encoder = nullptr;
+}
+
+CommandEncoder& Device::get_command_encoder(int index) {
+  auto& stream = get_stream_(index);
+  if (stream.encoder == nullptr) {
+    stream.encoder = std::make_unique<CommandEncoder>(stream);
+    stream.fence = std::make_shared<Fence>(device_->newFence());
+  }
+  return *stream.encoder;
+}
+
+MTL::Library* Device::get_library(
+    const std::string& name,
+    const std::string& path /* = "" */) {
+  {
+    std::shared_lock rlock(library_mtx_);
+    if (auto it = library_map_.find(name); it != library_map_.end()) {
+      return it->second;
+    }
+  }
+
+  std::unique_lock wlock(library_mtx_);
+  if (auto it = library_map_.find(name); it != library_map_.end()) {
+    return it->second;
+  }
+
+  auto new_lib = load_library(device_, name, path.c_str());
+  library_map_.insert({name, new_lib});
+  return new_lib;
+}
+
+MTL::Library* Device::build_library_(const std::string& source_string) {
+  auto pool = new_scoped_memory_pool();
+
+  auto ns_code =
+      NS::String::string(source_string.c_str(), NS::ASCIIStringEncoding);
+
+  NS::Error* error = nullptr;
+  auto options = MTL::CompileOptions::alloc()->init();
+  options->setFastMathEnabled(false);
+  options->setLanguageVersion(get_metal_version());
+  auto mtl_lib = device_->newLibrary(ns_code, options, &error);
+  options->release();
+
+  // Throw error if unable to compile library
+  if (!mtl_lib) {
+    std::ostringstream msg;
+    msg << "[metal::Device] Unable to build metal library from source\n";
+    if (error) {
+      msg << error->localizedDescription()->utf8String() << "\n";
+    }
+    throw std::runtime_error(msg.str());
+  }
+
+  return mtl_lib;
+}
+
+MTL::Function* Device::get_function_(
+    const std::string& name,
+    MTL::Library* mtl_lib) {
+  // Pull kernel from library
+  auto ns_name = NS::String::string(name.c_str(), NS::ASCIIStringEncoding);
+  auto mtl_function = mtl_lib->newFunction(ns_name);
+
+  return mtl_function;
+}
+
+MTL::Function* Device::get_function_(
+    const std::string& name,
+    const std::string& specialized_name,
+    const MTLFCList& func_consts,
+    MTL::Library* mtl_lib) {
+  if (func_consts.empty() && (specialized_name == name)) {
+    return get_function_(name, mtl_lib);
+  }
+
+  // Prepare function constants
+  auto mtl_func_consts = MTL::FunctionConstantValues::alloc()->init();
+
+  for (auto [value, type, index] : func_consts) {
+    mtl_func_consts->setConstantValue(value, type, index);
+  }
+
+  // Prepare function desc
+  auto desc = MTL::FunctionDescriptor::functionDescriptor();
+  desc->setName(NS::String::string(name.c_str(), NS::ASCIIStringEncoding));
+  desc->setSpecializedName(
+      NS::String::string(specialized_name.c_str(), NS::ASCIIStringEncoding));
+  desc->setConstantValues(mtl_func_consts);
+
+  // Pull kernel from library
+  NS::Error* error = nullptr;
+  auto mtl_function = mtl_lib->newFunction(desc, &error);
+
+  // Throw error if unable to build metal function
+  if (!mtl_function) {
+    std::ostringstream msg;
+    msg << "[metal::Device] Unable to load function " << name << "\n";
+    if (error) {
+      msg << error->localizedDescription()->utf8String() << "\n";
+    }
+    throw std::runtime_error(msg.str());
+  }
+
+  mtl_func_consts->release();
+
+  return mtl_function;
+}
+
+MTL::ComputePipelineState* Device::get_kernel_(
+    const std::string& name,
+    const MTL::Function* mtl_function) {
+  // Compile kernel to compute pipeline
+  NS::Error* error = nullptr;
+  MTL::ComputePipelineState* kernel;
+
+  if (mtl_function) {
+    kernel = device_->newComputePipelineState(mtl_function, &error);
+  }
+
+  // Throw error if unable to compile metal function
+  if (!mtl_function || !kernel) {
+    std::ostringstream msg;
+    msg << "[metal::Device] Unable to load kernel " << name << "\n";
+    if (error) {
+      msg << error->localizedDescription()->utf8String() << "\n";
+    }
+    throw std::runtime_error(msg.str());
+  }
+
+  return kernel;
+}
+
+MTL::ComputePipelineState* Device::get_kernel_(
+    const std::string& name,
+    const MTL::Function* mtl_function,
+    const MTL::LinkedFunctions* linked_functions) {
+  // Check inputs
+  if (!linked_functions) {
+    return get_kernel_(name, mtl_function);
+  }
+
+  if (!mtl_function) {
+    std::ostringstream msg;
+    msg << "[metal::Device] Unable to load kernel " << name << "\n";
+    throw std::runtime_error(msg.str());
+  }
+
+  // Prepare compute pipeline state descriptor
+  auto desc = MTL::ComputePipelineDescriptor::alloc()->init();
+  desc->setComputeFunction(mtl_function);
+  desc->setLinkedFunctions(linked_functions);
+
+  // Compile kernel to compute pipeline
+  NS::Error* error = nullptr;
+  auto kernel = device_->newComputePipelineState(
+      desc, MTL::PipelineOptionNone, nullptr, &error);
+
+  // Throw error if unable to compile metal function
+  if (!kernel) {
+    std::ostringstream msg;
+    msg << "[metal::Device] Unable to load kernel " << name << "\n";
+    if (error) {
+      msg << error->localizedDescription()->utf8String() << "\n";
+    }
+    throw std::runtime_error(msg.str());
+  }
+
+  return kernel;
+}
+
+MTL::Library* Device::get_library_(const std::string& name) {
+  std::shared_lock lock(library_mtx_);
+  auto it = library_map_.find(name);
+  return (it != library_map_.end()) ? it->second : nullptr;
+}
+
+MTL::Library* Device::get_library(
+    const std::string& name,
+    const std::function<std::string(void)>& builder) {
+  {
+    std::shared_lock rlock(library_mtx_);
+    if (auto it = library_map_.find(name); it != library_map_.end()) {
+      return it->second;
+    }
+  }
+
+  std::unique_lock wlock(library_mtx_);
+  if (auto it = library_map_.find(name); it != library_map_.end()) {
+    return it->second;
+  }
+
+  auto mtl_lib = build_library_(builder());
+  library_map_.insert({name, mtl_lib});
+  return mtl_lib;
+}
+
+void Device::clear_library(const std::string& name) {
+  std::unique_lock wlock(library_mtx_);
+  if (auto it = library_map_.find(name); it != library_map_.end()) {
+    auto kernel_map_it = library_kernels_.find(it->second);
+    for (auto& [_, kernel] : kernel_map_it->second) {
+      kernel->release();
+    }
+    library_kernels_.erase(kernel_map_it);
+    it->second->release();
+    library_map_.erase(it);
+  }
+}
+
+MTL::LinkedFunctions* Device::get_linked_functions_(
+    const std::vector<MTL::Function*>& funcs) {
+  if (funcs.empty()) {
+    return nullptr;
+  }
+
+  auto lfuncs = MTL::LinkedFunctions::linkedFunctions();
+
+  std::vector<NS::Object*> objs(funcs.size());
+  for (int i = 0; i < funcs.size(); i++) {
+    objs[i] = funcs[i];
+  }
+
+  NS::Array* funcs_arr = NS::Array::array(objs.data(), funcs.size());
+
+  lfuncs->setPrivateFunctions(funcs_arr);
+
+  return lfuncs;
+}
+
+MTL::ComputePipelineState* Device::get_kernel_(
+    const std::string& base_name,
+    MTL::Library* mtl_lib,
+    const std::string& hash_name,
+    const MTLFCList& func_consts /* = {} */,
+    const std::vector<MTL::Function*>& linked_functions /* = {} */) {
+  // Single writer allowed
+  std::unique_lock wlock(kernel_mtx_);
+
+  // Try loading again to avoid loading twice
+  auto& kernel_map_ = library_kernels_[mtl_lib];
+  if (auto it = kernel_map_.find(hash_name); it != kernel_map_.end()) {
+    return it->second;
+  }
+
+  auto pool = new_scoped_memory_pool();
+
+  // Pull kernel from library
+  auto mtl_function = get_function_(base_name, hash_name, func_consts, mtl_lib);
+
+  // Compile kernel to compute pipeline
+  auto mtl_linked_funcs = get_linked_functions_(linked_functions);
+  auto kernel = get_kernel_(hash_name, mtl_function, mtl_linked_funcs);
+
+  mtl_function->release();
+  mtl_linked_funcs->release();
+
+  // Add kernel to cache
+  auto inserted = kernel_map_.insert({hash_name, kernel});
+
+  return kernel;
+}
+
+MTL::ComputePipelineState* Device::get_kernel(
+    const std::string& base_name,
+    MTL::Library* mtl_lib,
+    const std::string& hash_name /* = "" */,
+    const MTLFCList& func_consts /* = {} */,
+    const std::vector<MTL::Function*>& linked_functions /* = {} */) {
+  const auto& kname = hash_name.empty() ? base_name : hash_name;
+  {
+    // Multiple readers allowed
+    std::shared_lock lock(kernel_mtx_);
+
+    // Look for cached kernel
+    auto& kernel_map_ = library_kernels_[mtl_lib];
+    if (auto it = kernel_map_.find(kname); it != kernel_map_.end()) {
+      return it->second;
+    }
+  }
+  return get_kernel_(base_name, mtl_lib, kname, func_consts, linked_functions);
+}
+
+MTL::ComputePipelineState* Device::get_kernel(
+    const std::string& base_name,
+    const std::string& hash_name /*  = "" */,
+    const MTLFCList& func_consts /*  = {} */,
+    const std::vector<MTL::Function*>& linked_functions /*  = {} */) {
+  return get_kernel(
+      base_name, default_library_, hash_name, func_consts, linked_functions);
+}
+
+void Device::set_residency_set(const MTL::ResidencySet* residency_set) {
+  if (residency_set_ != nullptr) {
+    throw std::runtime_error(
+        "[Device::set_residency_set] Can only be set once.");
+  }
+  if (residency_set == nullptr) {
+    return;
+  }
+  residency_set_ = residency_set;
+  // Attach residency set to existing command queues
+  for (auto& [_, stream] : stream_map_) {
+    stream.queue->addResidencySet(residency_set_);
+  }
+}
+
+Device& device(mlx::core::Device) {
+  static Device metal_device;
+  return metal_device;
+}
+
+std::unique_ptr<void, std::function<void(void*)>> new_scoped_memory_pool() {
+  auto dtor = [](void* ptr) {
+    static_cast<NS::AutoreleasePool*>(ptr)->release();
+  };
+  return std::unique_ptr<void, std::function<void(void*)>>(
+      NS::AutoreleasePool::alloc()->init(), dtor);
+}
+
+} // namespace mlx::core::metal
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/device.h b/ml-stable-diffusion/mlx/mlx/backend/metal/device.h
new file mode 100644
index 0000000000000000000000000000000000000000..fefb7cdc0c5b55be3be0600e92cdd34ddf7b7a4c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/device.h
@@ -0,0 +1,268 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <Metal/Metal.hpp>
+#include <functional>
+#include <mutex>
+#include <shared_mutex>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "mlx/array.h"
+#include "mlx/device.h"
+
+namespace mlx::core::metal {
+
+using MTLFCList =
+    std::vector<std::tuple<const void*, MTL::DataType, NS::UInteger>>;
+
+struct DeviceStream;
+
+struct CommandEncoder {
+  explicit CommandEncoder(DeviceStream& stream);
+  CommandEncoder(const CommandEncoder&) = delete;
+  CommandEncoder& operator=(const CommandEncoder&) = delete;
+
+  struct ConcurrentContext {
+    ConcurrentContext(CommandEncoder& enc) : enc(enc) {
+      enc.concurrent_ = true;
+    }
+    ~ConcurrentContext() {
+      enc.concurrent_ = false;
+      enc.prev_outputs_.insert(
+          enc.concurrent_outputs_.begin(), enc.concurrent_outputs_.end());
+      enc.concurrent_outputs_.clear();
+    }
+
+   private:
+    CommandEncoder& enc;
+  };
+
+  void set_input_array(const array& a, int idx, int64_t offset = 0);
+  void set_output_array(array& a, int idx, int64_t offset = 0);
+  void register_output_array(const array& a);
+  void dispatch_threadgroups(MTL::Size grid_dims, MTL::Size group_dims);
+  void dispatch_threads(MTL::Size grid_dims, MTL::Size group_dims);
+  void maybeInsertBarrier();
+  void set_buffer(const MTL::Buffer* buf, int idx, int64_t offset = 0);
+
+  void set_compute_pipeline_state(MTL::ComputePipelineState* kernel) {
+    enc_->setComputePipelineState(kernel);
+  }
+
+  void wait_for_fence(MTL::Fence* fence) {
+    enc_->waitForFence(fence);
+  }
+
+  void update_fence(MTL::Fence* fence) {
+    enc_->updateFence(fence);
+  }
+
+  template <typename Vec, typename = std::enable_if_t<is_vector_v<Vec>>>
+  void set_vector_bytes(const Vec& vec, size_t nelems, int idx) {
+    enc_->setBytes(vec.data(), nelems * sizeof(typename Vec::value_type), idx);
+  }
+  template <typename Vec, typename = std::enable_if_t<is_vector_v<Vec>>>
+  void set_vector_bytes(const Vec& vec, int idx) {
+    return set_vector_bytes(vec, vec.size(), idx);
+  }
+
+  template <typename T>
+  void set_bytes(const T* v, int n, int idx) {
+    return enc_->setBytes(v, n * sizeof(T), idx);
+  }
+
+  template <typename T>
+  void set_bytes(const T& v, int idx) {
+    return enc_->setBytes(&v, sizeof(T), idx);
+  }
+
+  void set_threadgroup_memory_length(size_t length, int idx) {
+    enc_->setThreadgroupMemoryLength(length, idx);
+  }
+
+  ConcurrentContext start_concurrent() {
+    return ConcurrentContext(*this);
+  }
+  ~CommandEncoder();
+
+  // Inputs to all kernels in the encoder including temporaries
+  std::unordered_set<const void*>& inputs() {
+    return all_inputs_;
+  };
+
+  // Outputs of all kernels in the encoder including temporaries
+  std::unordered_set<const void*>& outputs() {
+    return all_outputs_;
+  };
+
+  void barrier();
+
+ private:
+  DeviceStream& stream_;
+  MTL::ComputeCommandEncoder* enc_;
+  bool needs_barrier_{false};
+  bool concurrent_{false};
+  std::unordered_set<MTL::Resource*> prev_outputs_;
+  std::unordered_set<MTL::Resource*> next_outputs_;
+  std::unordered_set<MTL::Resource*> concurrent_outputs_;
+  std::unordered_set<const void*> all_inputs_;
+  std::unordered_set<const void*> all_outputs_;
+};
+
+struct Fence {
+  Fence(MTL::Fence* fence) : fence(fence) {}
+  ~Fence() {
+    fence->release();
+  }
+  MTL::Fence* fence;
+};
+
+struct DeviceStream {
+  DeviceStream(MTL::CommandQueue* queue) : queue(queue) {};
+  ~DeviceStream() {
+    queue->release();
+    if (buffer != nullptr) {
+      buffer->release();
+    }
+  };
+  MTL::CommandQueue* queue;
+  // A map of prior command encoder outputs to their corresponding fence
+  std::unordered_map<const void*, std::shared_ptr<Fence>> outputs;
+  // Used to allow thread-safe access to the outputs map
+  std::mutex fence_mtx;
+
+  // Data updated between command buffers
+  MTL::CommandBuffer* buffer{nullptr};
+  int buffer_ops{0};
+  size_t buffer_sizes{0};
+
+  // The command encoder, fence, and temporaries are updated between command
+  // encoders
+  std::unique_ptr<CommandEncoder> encoder{nullptr};
+  std::shared_ptr<Fence> fence;
+  std::vector<array> temporaries;
+};
+
+class Device {
+ public:
+  Device();
+  Device(const Device&) = delete;
+  Device& operator=(const Device&) = delete;
+  ~Device();
+
+  MTL::Device* mtl_device() {
+    return device_;
+  };
+
+  const std::string& get_architecture() {
+    return arch_;
+  }
+
+  int get_architecture_gen() const {
+    return arch_gen_;
+  }
+
+  void new_queue(int index);
+
+  MTL::CommandQueue* get_queue(Stream stream);
+
+  MTL::CommandBuffer* get_command_buffer(int index);
+  bool command_buffer_needs_commit(int index);
+  void commit_command_buffer(int index);
+  CommandEncoder& get_command_encoder(int index);
+  void end_encoding(int index);
+
+  MTL::Library* get_library(
+      const std::string& name,
+      const std::string& path = "");
+
+  MTL::Library* get_library(
+      const std::string& name,
+      const std::function<std::string(void)>& builder);
+
+  void clear_library(const std::string& name);
+
+  MTL::ComputePipelineState* get_kernel(
+      const std::string& base_name,
+      MTL::Library* mtl_lib,
+      const std::string& hash_name = "",
+      const MTLFCList& func_consts = {},
+      const std::vector<MTL::Function*>& linked_functions = {});
+
+  MTL::ComputePipelineState* get_kernel(
+      const std::string& base_name,
+      const std::string& hash_name = "",
+      const MTLFCList& func_consts = {},
+      const std::vector<MTL::Function*>& linked_functions = {});
+
+  MTL::ArgumentEncoder* argument_encoder(
+      const std::vector<MTL::ArgumentDescriptor*>& arg_descs) const;
+
+  // Record temporary arrays for the given stream index
+  void add_temporary(array arr, int index);
+  void add_temporaries(std::vector<array> arrays, int index);
+
+  void set_residency_set(const MTL::ResidencySet* residency_set);
+
+ private:
+  DeviceStream& get_stream_(int index) {
+    return stream_map_.find(index)->second;
+  }
+  MTL::Library* get_library_cache_(const std::string& name);
+
+  MTL::Library* get_library_(const std::string& name);
+  MTL::Library* build_library_(const std::string& source_string);
+
+  MTL::Function* get_function_(const std::string& name, MTL::Library* mtl_lib);
+
+  MTL::Function* get_function_(
+      const std::string& name,
+      const std::string& specialized_name,
+      const MTLFCList& func_consts,
+      MTL::Library* mtl_lib);
+
+  MTL::LinkedFunctions* get_linked_functions_(
+      const std::vector<MTL::Function*>& funcs);
+
+  MTL::ComputePipelineState* get_kernel_(
+      const std::string& name,
+      const MTL::Function* mtl_function);
+
+  MTL::ComputePipelineState* get_kernel_(
+      const std::string& name,
+      const MTL::Function* mtl_function,
+      const MTL::LinkedFunctions* linked_functions);
+
+  MTL::ComputePipelineState* get_kernel_(
+      const std::string& base_name,
+      MTL::Library* mtl_lib,
+      const std::string& hash_name,
+      const MTLFCList& func_consts = {},
+      const std::vector<MTL::Function*>& linked_functions = {});
+
+  MTL::Device* device_;
+  std::unordered_map<int32_t, DeviceStream> stream_map_;
+
+  std::shared_mutex kernel_mtx_;
+  std::shared_mutex library_mtx_;
+  std::unordered_map<std::string, MTL::Library*> library_map_;
+  MTL::Library* default_library_;
+  std::unordered_map<
+      MTL::Library*,
+      std::unordered_map<std::string, MTL::ComputePipelineState*>>
+      library_kernels_;
+  const MTL::ResidencySet* residency_set_{nullptr};
+  std::string arch_;
+  int arch_gen_;
+  int max_ops_per_buffer_;
+  int max_mb_per_buffer_;
+};
+
+Device& device(mlx::core::Device);
+
+std::unique_ptr<void, std::function<void(void*)>> new_scoped_memory_pool();
+
+} // namespace mlx::core::metal
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/distributed.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/distributed.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a800d2e0fe7aee8d9103c9127554da677fb2d019
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/distributed.cpp
@@ -0,0 +1,33 @@
+// Copyright © 2024 Apple Inc.
+
+#include <cassert>
+
+#include "mlx/allocator.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/distributed/ops.h"
+#include "mlx/distributed/primitives.h"
+#include "mlx/fence.h"
+#include "mlx/scheduler.h"
+
+namespace mlx::core::distributed {
+
+void AllReduce::eval_gpu(const std::vector<array>&, std::vector<array>&) {
+  throw std::runtime_error("[AllReduce::eval_gpu] has no GPU implementation.");
+}
+
+void AllGather::eval_gpu(const std::vector<array>&, std::vector<array>&) {
+  throw std::runtime_error("[AllGather::eval_gpu] has no GPU implementation.");
+}
+
+void Send::eval_gpu(const std::vector<array>&, std::vector<array>&) {
+  throw std::runtime_error("[Send::eval_gpu] has no GPU implementation.");
+}
+
+void Recv::eval_gpu(const std::vector<array>&, std::vector<array>&) {
+  throw std::runtime_error("[Recv::eval_gpu] has no GPU implementation.");
+}
+
+} // namespace mlx::core::distributed
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/eval.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/eval.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..49783200a128d39ff3148e7544cc6f4a372ebecb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/eval.cpp
@@ -0,0 +1,102 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <memory>
+
+#include "mlx/backend/gpu/available.h"
+#include "mlx/backend/gpu/eval.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+#include "mlx/scheduler.h"
+
+namespace mlx::core::gpu {
+
+bool is_available() {
+  return true;
+}
+
+void new_stream(Stream stream) {
+  if (stream.device == mlx::core::Device::gpu) {
+    metal::device(stream.device).new_queue(stream.index);
+  }
+}
+
+inline void check_error(MTL::CommandBuffer* cbuf) {
+  if (cbuf->status() == MTL::CommandBufferStatusError) {
+    std::ostringstream msg;
+    msg << "[METAL] Command buffer execution failed: "
+        << cbuf->error()->localizedDescription()->utf8String();
+    throw std::runtime_error(msg.str());
+  }
+}
+
+void eval(array& arr) {
+  auto pool = metal::new_scoped_memory_pool();
+  auto s = arr.primitive().stream();
+  auto& d = metal::device(s.device);
+  auto command_buffer = d.get_command_buffer(s.index);
+
+  auto outputs = arr.outputs();
+  {
+    // If the array is a tracer hold a reference
+    // to its inputs so they don't get donated
+    std::vector<array> inputs;
+    if (arr.is_tracer()) {
+      inputs = arr.inputs();
+    }
+
+    debug_set_primitive_buffer_label(command_buffer, arr.primitive());
+    arr.primitive().eval_gpu(arr.inputs(), outputs);
+  }
+  std::unordered_set<std::shared_ptr<array::Data>> buffers;
+  for (auto& in : arr.inputs()) {
+    buffers.insert(in.data_shared_ptr());
+  }
+  for (auto& s : arr.siblings()) {
+    buffers.insert(s.data_shared_ptr());
+  }
+  // Remove the output if it was donated to by an input
+  if (auto it = buffers.find(arr.data_shared_ptr()); it != buffers.end()) {
+    buffers.erase(it);
+  }
+
+  if (d.command_buffer_needs_commit(s.index)) {
+    d.end_encoding(s.index);
+    scheduler::notify_new_task(s);
+    command_buffer->addCompletedHandler(
+        [s, buffers = std::move(buffers)](MTL::CommandBuffer* cbuf) {
+          scheduler::notify_task_completion(s);
+          check_error(cbuf);
+        });
+    d.commit_command_buffer(s.index);
+    d.get_command_buffer(s.index);
+  } else {
+    command_buffer->addCompletedHandler(
+        [s, buffers = std::move(buffers)](MTL::CommandBuffer* cbuf) {
+          check_error(cbuf);
+        });
+  }
+}
+
+void finalize(Stream s) {
+  auto pool = metal::new_scoped_memory_pool();
+  auto& d = metal::device(s.device);
+  auto cb = d.get_command_buffer(s.index);
+  d.end_encoding(s.index);
+  cb->addCompletedHandler([s](MTL::CommandBuffer* cbuf) { check_error(cbuf); });
+  d.commit_command_buffer(s.index);
+  d.get_command_buffer(s.index);
+}
+
+void synchronize(Stream s) {
+  auto pool = metal::new_scoped_memory_pool();
+  auto& d = metal::device(s.device);
+  auto cb = d.get_command_buffer(s.index);
+  cb->retain();
+  d.end_encoding(s.index);
+  d.commit_command_buffer(s.index);
+  cb->waitUntilCompleted();
+  check_error(cb);
+  cb->release();
+}
+
+} // namespace mlx::core::gpu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/event.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/event.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..39a49230d20f6e15756d0ca21c9cc5e58fa04ccc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/event.cpp
@@ -0,0 +1,62 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/event.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/scheduler.h"
+
+namespace mlx::core {
+
+Event::Event(Stream stream) : stream_(stream) {
+  auto dtor = [](void* ptr) {
+    auto p = metal::new_scoped_memory_pool();
+    static_cast<MTL::SharedEvent*>(ptr)->release();
+  };
+  auto p = metal::new_scoped_memory_pool();
+  event_ = std::shared_ptr<void>(
+      metal::device(Device::gpu).mtl_device()->newSharedEvent(), dtor);
+  if (event_ == nullptr) {
+    throw std::runtime_error(
+        "[Event::Event] Failed to create Metal shared event.");
+  }
+}
+
+void Event::wait() {
+  if (!static_cast<MTL::SharedEvent*>(event_.get())
+           ->waitUntilSignaledValue(value(), -1)) {
+    throw std::runtime_error("[Event::wait] Timed out");
+  }
+}
+
+void Event::wait(Stream stream) {
+  if (stream.device == Device::cpu) {
+    scheduler::enqueue(stream, [*this]() mutable { wait(); });
+  } else {
+    auto& d = metal::device(stream.device);
+    d.end_encoding(stream.index);
+    auto command_buffer = d.get_command_buffer(stream.index);
+    command_buffer->encodeWait(static_cast<MTL::Event*>(event_.get()), value());
+    command_buffer->addCompletedHandler([*this](MTL::CommandBuffer*) {});
+  }
+}
+
+void Event::signal(Stream stream) {
+  if (stream.device == Device::cpu) {
+    scheduler::enqueue(stream, [*this]() mutable {
+      static_cast<MTL::SharedEvent*>(event_.get())->setSignaledValue(value());
+    });
+  } else {
+    auto& d = metal::device(stream.device);
+    d.end_encoding(stream.index);
+    auto command_buffer = d.get_command_buffer(stream.index);
+    command_buffer->encodeSignalEvent(
+        static_cast<MTL::Event*>(event_.get()), value());
+    command_buffer->addCompletedHandler([*this](MTL::CommandBuffer*) {});
+  }
+}
+
+bool Event::is_signaled() const {
+  return static_cast<MTL::SharedEvent*>(event_.get())->signaledValue() >=
+      value();
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/fence.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/fence.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5abdf7309e44067e29beb3574df68f233d6370d8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/fence.cpp
@@ -0,0 +1,160 @@
+// Copyright © 2024 Apple Inc.
+#include "mlx/fence.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/scheduler.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+struct FenceImpl {
+  FenceImpl() {
+    auto d = metal::device(Device::gpu).mtl_device();
+    if (!d->supportsFamily(MTL::GPUFamilyMetal3)) {
+      use_fast = false;
+    } else if (__builtin_available(macOS 15, iOS 18, *)) {
+      use_fast = env::metal_fast_synch();
+    }
+
+    if (!use_fast) {
+      auto p = metal::new_scoped_memory_pool();
+      fence = static_cast<void*>(d->newSharedEvent());
+    } else {
+      auto buf = allocator::malloc(sizeof(uint32_t)).ptr();
+      fence = static_cast<void*>(buf);
+      cpu_value()[0] = 0;
+    }
+  }
+
+  ~FenceImpl() {
+    if (!use_fast) {
+      // Wraps Metal SharedEvent
+      auto p = metal::new_scoped_memory_pool();
+      static_cast<MTL::SharedEvent*>(fence)->release();
+    } else {
+      allocator::free(static_cast<MTL::Buffer*>(fence));
+    }
+  }
+  bool use_fast{false};
+  uint32_t count{0};
+  void* fence;
+
+  std::atomic_uint* cpu_value() {
+    return static_cast<std::atomic_uint*>(
+        static_cast<MTL::Buffer*>(fence)->contents());
+  }
+};
+
+Fence::Fence(Stream) {
+  auto dtor = [](void* ptr) { delete static_cast<FenceImpl*>(ptr); };
+  fence_ = std::shared_ptr<void>(new FenceImpl{}, dtor);
+}
+
+void Fence::wait(Stream stream, const array& x) {
+  auto& f = *static_cast<FenceImpl*>(fence_.get());
+
+  if (stream.device == Device::cpu) {
+    scheduler::enqueue(stream, [fence_ = fence_, count = f.count]() mutable {
+      auto& f = *static_cast<FenceImpl*>(fence_.get());
+      if (!f.use_fast) {
+        if (!static_cast<MTL::SharedEvent*>(f.fence)->waitUntilSignaledValue(
+                count, -1)) {
+          throw std::runtime_error("[Fence::wait] Timed out");
+        }
+        return;
+      }
+      while (f.cpu_value()[0] < count) {
+      }
+    });
+    return;
+  }
+
+  auto& d = metal::device(stream.device);
+  auto idx = stream.index;
+
+  if (!f.use_fast) {
+    d.end_encoding(idx);
+    auto command_buffer = d.get_command_buffer(idx);
+    command_buffer->encodeWait(static_cast<MTL::Event*>(f.fence), f.count);
+    command_buffer->addCompletedHandler(
+        [fence_ = fence_](MTL::CommandBuffer* cbuf) {});
+    return;
+  }
+
+  auto& compute_encoder = d.get_command_encoder(idx);
+
+  // Register outputs to ensure that no kernels which depends on the
+  // output starts before this one is done
+  compute_encoder.register_output_array(x);
+
+  auto kernel = d.get_kernel("fence_wait");
+  MTL::Size kernel_dims = MTL::Size(1, 1, 1);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  auto buf = static_cast<MTL::Buffer*>(f.fence);
+  compute_encoder.set_buffer(buf, 0);
+  compute_encoder.set_bytes(f.count, 1);
+  compute_encoder.dispatch_threads(kernel_dims, kernel_dims);
+
+  d.get_command_buffer(idx)->addCompletedHandler(
+      [fence_ = fence_](MTL::CommandBuffer* cbuf) {});
+}
+
+void Fence::update(Stream stream, const array& x) {
+  auto& f = *static_cast<FenceImpl*>(fence_.get());
+  f.count++;
+
+  if (stream.device == Device::cpu) {
+    scheduler::enqueue(stream, [fence_ = fence_, count = f.count]() mutable {
+      auto& f = *static_cast<FenceImpl*>(fence_.get());
+      if (!f.use_fast) {
+        static_cast<MTL::SharedEvent*>(f.fence)->setSignaledValue(count);
+        return;
+      }
+
+      f.cpu_value()[0] = count;
+    });
+    return;
+  }
+
+  auto& d = metal::device(stream.device);
+  auto idx = stream.index;
+  if (!f.use_fast) {
+    d.end_encoding(idx);
+    auto command_buffer = d.get_command_buffer(idx);
+    command_buffer->encodeSignalEvent(
+        static_cast<MTL::Event*>(f.fence), f.count);
+    command_buffer->addCompletedHandler(
+        [fence_ = fence_](MTL::CommandBuffer* cbuf) {});
+    return;
+  }
+
+  // Launch input visibility kernels
+  auto& compute_encoder = d.get_command_encoder(idx);
+  auto kernel = d.get_kernel("input_coherent");
+  uint32_t nthreads =
+      (x.data_size() * x.itemsize() + sizeof(uint32_t) - 1) / sizeof(uint32_t);
+  MTL::Size group_dims = MTL::Size(1024, 1, 1);
+  MTL::Size grid_dims = MTL::Size((nthreads + 1024 - 1) / 1024, 1, 1);
+  compute_encoder.set_compute_pipeline_state(kernel);
+  compute_encoder.set_input_array(x, 0);
+  compute_encoder.set_bytes(nthreads, 1);
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+
+  // Barrier on previous kernels
+  compute_encoder.barrier();
+
+  // Launch value update kernel
+  kernel = d.get_kernel("fence_update");
+  MTL::Size kernel_dims = MTL::Size(1, 1, 1);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  auto buf = static_cast<MTL::Buffer*>(f.fence);
+  compute_encoder.set_buffer(buf, 0);
+  compute_encoder.set_bytes(f.count, 1);
+  compute_encoder.dispatch_threads(kernel_dims, kernel_dims);
+
+  d.get_command_buffer(idx)->addCompletedHandler(
+      [fence_ = fence_](MTL::CommandBuffer* cbuf) {});
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/fft.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/fft.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1e23160a653c7f891739ba126eac20a55fa5f620
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/fft.cpp
@@ -0,0 +1,810 @@
+// Copyright © 2024 Apple Inc.
+#include <cassert>
+#include <complex>
+#include <map>
+#include <numeric>
+#include <set>
+
+#include "mlx/3rdparty/pocketfft.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/gpu/slicing.h"
+#include "mlx/backend/metal/binary.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/unary.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+using MTLFC = std::tuple<const void*, MTL::DataType, NS::UInteger>;
+
+#define MAX_STOCKHAM_FFT_SIZE 4096
+#define MAX_RADER_FFT_SIZE 2048
+#define MAX_BLUESTEIN_FFT_SIZE 2048
+// Threadgroup memory batching improves throughput for small n
+#define MIN_THREADGROUP_MEM_SIZE 256
+// For strided reads/writes, coalesce at least this many complex64s
+#define MIN_COALESCE_WIDTH 4
+
+inline const std::vector<int> supported_radices() {
+  // Ordered by preference in decomposition.
+  return {13, 11, 8, 7, 6, 5, 4, 3, 2};
+}
+
+std::vector<int> prime_factors(int n) {
+  int z = 2;
+  std::vector<int> factors;
+  while (z * z <= n) {
+    if (n % z == 0) {
+      factors.push_back(z);
+      n /= z;
+    } else {
+      z++;
+    }
+  }
+  if (n > 1) {
+    factors.push_back(n);
+  }
+  return factors;
+}
+
+struct FourStepParams {
+  bool required = false;
+  bool first_step = true;
+  int n1 = 0;
+  int n2 = 0;
+};
+
+// Forward Declaration
+void fft_op(
+    const array& in,
+    array& out,
+    size_t axis,
+    bool inverse,
+    bool real,
+    const FourStepParams four_step_params,
+    bool inplace,
+    const Stream& s);
+
+struct FFTPlan {
+  int n = 0;
+  // Number of steps for each radix in the Stockham decomposition
+  std::vector<int> stockham;
+  // Number of steps for each radix in the Rader decomposition
+  std::vector<int> rader;
+  // Rader factor, 1 if no rader factors
+  int rader_n = 1;
+  int bluestein_n = -1;
+  // Four step FFT
+  bool four_step = false;
+  int n1 = 0;
+  int n2 = 0;
+};
+
+int next_fast_n(int n) {
+  return next_power_of_2(n);
+}
+
+std::vector<int> plan_stockham_fft(int n) {
+  auto radices = supported_radices();
+  std::vector<int> plan(radices.size(), 0);
+  int orig_n = n;
+  if (n == 1) {
+    return plan;
+  }
+  for (int i = 0; i < radices.size(); i++) {
+    int radix = radices[i];
+    // Manually tuned radices for powers of 2
+    if (is_power_of_2(orig_n) && orig_n < 512 && radix > 4) {
+      continue;
+    }
+    while (n % radix == 0) {
+      plan[i] += 1;
+      n /= radix;
+      if (n == 1) {
+        return plan;
+      }
+    }
+  }
+  throw std::runtime_error("Unplannable");
+}
+
+FFTPlan plan_fft(int n) {
+  auto radices = supported_radices();
+  std::set<int> radices_set(radices.begin(), radices.end());
+
+  FFTPlan plan;
+  plan.n = n;
+  plan.rader = std::vector<int>(radices.size(), 0);
+  auto factors = prime_factors(n);
+  int remaining_n = n;
+
+  // Four Step FFT when N is too large for shared mem.
+  if (n > MAX_STOCKHAM_FFT_SIZE && is_power_of_2(n)) {
+    // For power's of two we have a fast, no transpose four step implementation.
+    plan.four_step = true;
+    // Rough heuristic for choosing faster powers of two when we can
+    plan.n2 = n > 65536 ? 1024 : 64;
+    plan.n1 = n / plan.n2;
+    return plan;
+  } else if (n > MAX_STOCKHAM_FFT_SIZE) {
+    // Otherwise we use a multi-upload Bluestein's
+    plan.four_step = true;
+    plan.bluestein_n = next_fast_n(2 * n - 1);
+    return plan;
+  }
+
+  for (int factor : factors) {
+    // Make sure the factor is a supported radix
+    if (radices_set.find(factor) == radices_set.end()) {
+      // We only support a single Rader factor currently
+      // TODO(alexbarron) investigate weirdness with large
+      // Rader sizes -- possibly a compiler issue?
+      if (plan.rader_n > 1 || n > MAX_RADER_FFT_SIZE) {
+        plan.four_step = n > MAX_BLUESTEIN_FFT_SIZE;
+        plan.bluestein_n = next_fast_n(2 * n - 1);
+        plan.stockham = plan_stockham_fft(plan.bluestein_n);
+        plan.rader = std::vector<int>(radices.size(), 0);
+        return plan;
+      }
+      // See if we can use Rader's algorithm to Stockham decompose n - 1
+      auto rader_factors = prime_factors(factor - 1);
+      int last_factor = -1;
+      for (int rf : rader_factors) {
+        // We don't nest Rader's algorithm so if `factor - 1`
+        // isn't Stockham decomposable we give up and do Bluestein's.
+        if (radices_set.find(rf) == radices_set.end()) {
+          plan.four_step = n > MAX_BLUESTEIN_FFT_SIZE;
+          plan.bluestein_n = next_fast_n(2 * n - 1);
+          plan.stockham = plan_stockham_fft(plan.bluestein_n);
+          plan.rader = std::vector<int>(radices.size(), 0);
+          return plan;
+        }
+      }
+      plan.rader = plan_stockham_fft(factor - 1);
+      plan.rader_n = factor;
+      remaining_n /= factor;
+    }
+  }
+
+  plan.stockham = plan_stockham_fft(remaining_n);
+  return plan;
+}
+
+int compute_elems_per_thread(FFTPlan plan) {
+  // Heuristics for selecting an efficient number
+  // of threads to use for a particular mixed-radix FFT.
+  auto n = plan.n;
+
+  std::vector<int> steps;
+  auto radices = supported_radices();
+  steps.insert(steps.end(), plan.stockham.begin(), plan.stockham.end());
+  steps.insert(steps.end(), plan.rader.begin(), plan.rader.end());
+  std::set<int> used_radices;
+  for (int i = 0; i < steps.size(); i++) {
+    int radix = radices[i % radices.size()];
+    if (steps[i] > 0) {
+      used_radices.insert(radix);
+    }
+  }
+
+  // Manual tuning for 7/11/13
+  if (used_radices.find(7) != used_radices.end() &&
+      (used_radices.find(11) != used_radices.end() ||
+       used_radices.find(13) != used_radices.end())) {
+    return 7;
+  } else if (
+      used_radices.find(11) != used_radices.end() &&
+      used_radices.find(13) != used_radices.end()) {
+    return 11;
+  }
+
+  // TODO(alexbarron) Some really weird stuff is going on
+  // for certain `elems_per_thread` on large composite n.
+  // Possibly a compiler issue?
+  if (n == 3159)
+    return 13;
+  if (n == 3645)
+    return 5;
+  if (n == 3969)
+    return 7;
+  if (n == 1982)
+    return 5;
+
+  if (used_radices.size() == 1) {
+    return *(used_radices.begin());
+  }
+  if (used_radices.size() == 2) {
+    if (used_radices.find(11) != used_radices.end() ||
+        used_radices.find(13) != used_radices.end()) {
+      return std::accumulate(used_radices.begin(), used_radices.end(), 0) / 2;
+    }
+    std::vector<int> radix_vec(used_radices.begin(), used_radices.end());
+    return radix_vec[1];
+  }
+  // In all other cases use the second smallest radix.
+  std::vector<int> radix_vec(used_radices.begin(), used_radices.end());
+  return radix_vec[1];
+}
+
+// Rader
+int mod_exp(int x, int y, int n) {
+  int out = 1;
+  while (y) {
+    if (y & 1) {
+      out = out * x % n;
+    }
+    y >>= 1;
+    x = x * x % n;
+  }
+  return out;
+}
+
+int primitive_root(int n) {
+  auto factors = prime_factors(n - 1);
+
+  for (int r = 2; r < n - 1; r++) {
+    bool found = true;
+    for (int factor : factors) {
+      if (mod_exp(r, (n - 1) / factor, n) == 1) {
+        found = false;
+        break;
+      }
+    }
+    if (found) {
+      return r;
+    }
+  }
+  return -1;
+}
+
+std::tuple<array, array, array> compute_raders_constants(
+    int rader_n,
+    const Stream& s) {
+  int proot = primitive_root(rader_n);
+  // Fermat's little theorem
+  int inv = mod_exp(proot, rader_n - 2, rader_n);
+  std::vector<short> g_q(rader_n - 1);
+  std::vector<short> g_minus_q(rader_n - 1);
+  for (int i = 0; i < rader_n - 1; i++) {
+    g_q[i] = mod_exp(proot, i, rader_n);
+    g_minus_q[i] = mod_exp(inv, i, rader_n);
+  }
+  array g_q_arr(g_q.begin(), {rader_n - 1});
+  array g_minus_q_arr(g_minus_q.begin(), {rader_n - 1});
+
+  std::vector<std::complex<float>> b_q(rader_n - 1);
+  for (int i = 0; i < rader_n - 1; i++) {
+    float pi_i = (float)g_minus_q[i] * -2.0 * M_PI / rader_n;
+    b_q[i] = std::exp(std::complex<float>(0, pi_i));
+  }
+
+  array b_q_fft({rader_n - 1}, complex64, nullptr, {});
+  b_q_fft.set_data(allocator::malloc(b_q_fft.nbytes()));
+  auto b_q_fft_ptr =
+      reinterpret_cast<std::complex<float>*>(b_q_fft.data<complex64_t>());
+  std::ptrdiff_t item_size = b_q_fft.itemsize();
+  size_t fft_size = rader_n - 1;
+  // This FFT is always small (<4096, batch 1) so save some overhead
+  // and do it on the CPU
+  pocketfft::c2c(
+      /* shape= */ {fft_size},
+      /* stride_in= */ {item_size},
+      /* stride_out= */ {item_size},
+      /* axes= */ {0},
+      /* forward= */ true,
+      /* data_in= */ b_q.data(),
+      /* data_out= */ b_q_fft_ptr,
+      /* scale= */ 1.0f);
+  return std::make_tuple(b_q_fft, g_q_arr, g_minus_q_arr);
+}
+
+// Bluestein
+std::pair<array, array> compute_bluestein_constants(int n, int bluestein_n) {
+  // We need to calculate the Bluestein twiddle factors
+  // in double precision for the overall numerical stability
+  // of Bluestein's FFT algorithm to be acceptable.
+  //
+  // Metal doesn't support float64, so instead we
+  // manually implement the required operations on cpu.
+  //
+  // In numpy:
+  // w_k = np.exp(-1j * np.pi / N * (np.arange(-N + 1, N) ** 2))
+  // w_q = np.fft.fft(1/w_k)
+  // return w_k, w_q
+  int length = 2 * n - 1;
+
+  std::vector<std::complex<float>> w_k_vec(n);
+  std::vector<std::complex<float>> w_q_vec(bluestein_n, 0);
+
+  for (int i = -n + 1; i < n; i++) {
+    double theta = pow(i, 2) * M_PI / (double)n;
+    w_q_vec[i + n - 1] = std::exp(std::complex<double>(0, theta));
+    if (i >= 0) {
+      w_k_vec[i] = std::exp(std::complex<double>(0, -theta));
+    }
+  }
+
+  array w_k({n}, complex64, nullptr, {});
+  w_k.set_data(allocator::malloc(w_k.nbytes()));
+  std::copy(w_k_vec.begin(), w_k_vec.end(), w_k.data<complex64_t>());
+
+  array w_q({bluestein_n}, complex64, nullptr, {});
+  w_q.set_data(allocator::malloc(w_q.nbytes()));
+  auto w_q_ptr =
+      reinterpret_cast<std::complex<float>*>(w_q.data<complex64_t>());
+
+  std::ptrdiff_t item_size = w_q.itemsize();
+  size_t fft_size = bluestein_n;
+  pocketfft::c2c(
+      /* shape= */ {fft_size},
+      /* stride_in= */ {item_size},
+      /* stride_out= */ {item_size},
+      /* axes= */ {0},
+      /* forward= */ true,
+      /* data_in= */ w_q_vec.data(),
+      /* data_out= */ w_q_ptr,
+      /* scale= */ 1.0f);
+  return std::make_tuple(w_k, w_q);
+}
+
+void multi_upload_bluestein_fft(
+    const array& in,
+    array& out,
+    size_t axis,
+    bool inverse,
+    bool real,
+    FFTPlan& plan,
+    std::vector<array>& copies,
+    const Stream& s) {
+  // TODO(alexbarron) Implement fused kernels for mutli upload bluestein's
+  // algorithm
+  int n = inverse ? out.shape(axis) : in.shape(axis);
+  auto [w_k, w_q] = compute_bluestein_constants(n, plan.bluestein_n);
+  copies.push_back(w_k);
+  copies.push_back(w_q);
+
+  auto temp_shape = inverse ? out.shape() : in.shape();
+  array temp(temp_shape, complex64, nullptr, {});
+  array temp1(temp_shape, complex64, nullptr, {});
+
+  if (real && !inverse) {
+    // Convert float32->complex64
+    copy_gpu(in, temp, CopyType::General, s);
+    copies.push_back(temp);
+  } else if (real && inverse) {
+    int back_offset = n % 2 == 0 ? 2 : 1;
+    auto slice_shape = in.shape();
+    slice_shape[axis] -= back_offset;
+    array slice_temp(slice_shape, complex64, nullptr, {});
+    array conj_temp(in.shape(), complex64, nullptr, {});
+    copies.push_back(conj_temp);
+
+    Shape rstarts(in.ndim(), 0);
+    Shape rstrides(in.ndim(), 1);
+    rstarts[axis] = in.shape(axis) - back_offset;
+    rstrides[axis] = -1;
+    unary_op_gpu({in}, conj_temp, "Conjugate", s);
+    slice_gpu(in, slice_temp, rstarts, rstrides, s);
+    concatenate_gpu({conj_temp, slice_temp}, temp, (int)axis, s);
+    copies.push_back(temp);
+  } else if (inverse) {
+    unary_op_gpu({in}, temp, "Conjugate", s);
+    copies.push_back(temp);
+  } else {
+    temp.copy_shared_buffer(in);
+  }
+
+  Strides b_strides(in.ndim(), 0);
+  b_strides[axis] = 1;
+  array w_k_broadcast(temp.shape(), complex64, nullptr, {});
+  w_k_broadcast.copy_shared_buffer(w_k, b_strides, {}, w_k.data_size());
+  binary_op_gpu({temp, w_k_broadcast}, temp1, "Multiply", s);
+
+  std::vector<std::pair<int, int>> pads;
+  auto padded_shape = out.shape();
+  padded_shape[axis] = plan.bluestein_n;
+  array pad_temp(padded_shape, complex64, nullptr, {});
+  auto zero = array(complex64_t{0.0f, 0.0f});
+  copies.push_back(zero);
+  pad_gpu(temp1, zero, pad_temp, {(int)axis}, {0}, s);
+  copies.push_back(pad_temp);
+
+  array pad_temp1(padded_shape, complex64, nullptr, {});
+  fft_op(
+      pad_temp,
+      pad_temp1,
+      axis,
+      /*inverse=*/false,
+      /*real=*/false,
+      FourStepParams(),
+      /*inplace=*/false,
+      s);
+  copies.push_back(pad_temp1);
+
+  array w_q_broadcast(pad_temp1.shape(), complex64, nullptr, {});
+  w_q_broadcast.copy_shared_buffer(w_q, b_strides, {}, w_q.data_size());
+  binary_op_gpu_inplace({pad_temp1, w_q_broadcast}, pad_temp, "Multiply", s);
+
+  fft_op(
+      pad_temp,
+      pad_temp1,
+      axis,
+      /* inverse= */ true,
+      /* real= */ false,
+      FourStepParams(),
+      /*inplace=*/true,
+      s);
+
+  int offset = plan.bluestein_n - (2 * n - 1);
+  Shape starts(in.ndim(), 0);
+  Shape strides(in.ndim(), 1);
+  starts[axis] = plan.bluestein_n - offset - n;
+
+  array temp2(temp_shape, complex64, nullptr, {});
+  slice_gpu(pad_temp1, temp2, starts, strides, s);
+
+  binary_op_gpu_inplace({temp2, w_k_broadcast}, temp1, "Multiply", s);
+
+  if (real && !inverse) {
+    Shape rstarts(in.ndim(), 0);
+    Shape rstrides(in.ndim(), 1);
+    slice_gpu(temp1, out, rstarts, strides, s);
+  } else if (real && inverse) {
+    Strides b_strides(in.ndim(), 0);
+    auto inv_n = array({1.0f / n}, {1}, float32);
+    array temp_float(out.shape(), out.dtype(), nullptr, {});
+    copies.push_back(temp_float);
+    copies.push_back(inv_n);
+    copies.push_back(temp1);
+
+    copy_gpu(temp1, temp_float, CopyType::General, s);
+    binary_op_gpu({temp_float, inv_n}, out, "Multiply", s);
+  } else if (inverse) {
+    auto inv_n = array({1.0f / n}, {1}, complex64);
+    array temp3(temp_shape, complex64, nullptr, {});
+    unary_op_gpu({temp1}, temp3, "Conjugate", s);
+    binary_op_gpu({temp3, inv_n}, out, "Multiply", s);
+    copies.push_back(inv_n);
+    copies.push_back(temp1);
+    copies.push_back(temp3);
+  } else {
+    out.copy_shared_buffer(temp1);
+  }
+}
+
+void four_step_fft(
+    const array& in,
+    array& out,
+    size_t axis,
+    bool inverse,
+    bool real,
+    FFTPlan& plan,
+    std::vector<array>& copies,
+    const Stream& s,
+    bool in_place) {
+  auto& d = metal::device(s.device);
+
+  if (plan.bluestein_n == -1) {
+    // Fast no transpose implementation for powers of 2.
+    FourStepParams four_step_params = {
+        /* required= */ true, /* first_step= */ true, plan.n1, plan.n2};
+    auto temp_shape = (real && inverse) ? out.shape() : in.shape();
+    array temp(temp_shape, complex64, nullptr, {});
+    fft_op(
+        in, temp, axis, inverse, real, four_step_params, /*inplace=*/false, s);
+    four_step_params.first_step = false;
+    fft_op(
+        temp,
+        out,
+        axis,
+        inverse,
+        real,
+        four_step_params,
+        /*inplace=*/in_place,
+        s);
+    copies.push_back(temp);
+  } else {
+    multi_upload_bluestein_fft(in, out, axis, inverse, real, plan, copies, s);
+  }
+}
+
+void fft_op(
+    const array& in,
+    array& out,
+    size_t axis,
+    bool inverse,
+    bool real,
+    const FourStepParams four_step_params,
+    bool inplace,
+    const Stream& s) {
+  auto& d = metal::device(s.device);
+
+  size_t n = out.dtype() == float32 ? out.shape(axis) : in.shape(axis);
+  if (n == 1) {
+    out.copy_shared_buffer(in);
+    return;
+  }
+
+  if (four_step_params.required) {
+    // Four Step FFT decomposes into two FFTs: n1 on columns, n2 on rows
+    n = four_step_params.first_step ? four_step_params.n1 : four_step_params.n2;
+  }
+
+  // Make sure that the array is contiguous and has stride 1 in the FFT dim
+  std::vector<array> copies;
+  auto check_input = [&axis, &copies, &s](const array& x) {
+    // TODO: Pass the strides to the kernel so
+    // we can avoid the copy when x is not contiguous.
+    bool no_copy = x.strides()[axis] == 1 &&
+        (x.flags().row_contiguous || x.flags().col_contiguous);
+    if (no_copy) {
+      return x;
+    } else {
+      array x_copy(x.shape(), x.dtype(), nullptr, {});
+      Strides strides;
+      int64_t cur_stride = x.shape(axis);
+      for (int a = 0; a < x.ndim(); a++) {
+        if (a == axis) {
+          strides.push_back(1);
+        } else {
+          strides.push_back(cur_stride);
+          cur_stride *= x.shape(a);
+        }
+      }
+
+      auto flags = x.flags();
+      auto [data_size, is_row_contiguous, is_col_contiguous] =
+          check_contiguity(x.shape(), strides);
+
+      flags.col_contiguous = is_col_contiguous;
+      flags.row_contiguous = is_row_contiguous;
+      flags.contiguous = data_size == x_copy.size();
+
+      x_copy.set_data(allocator::malloc(x.nbytes()), data_size, strides, flags);
+      copy_gpu_inplace(x, x_copy, CopyType::GeneralGeneral, s);
+      copies.push_back(x_copy);
+      return x_copy;
+    }
+  };
+  const array& in_contiguous = check_input(in);
+
+  // real to complex: n -> (n/2)+1
+  // complex to real: (n/2)+1 -> n
+  auto out_strides = in_contiguous.strides();
+  size_t out_data_size = in_contiguous.data_size();
+  if (in.shape(axis) != out.shape(axis)) {
+    for (int i = 0; i < out_strides.size(); i++) {
+      if (out_strides[i] != 1) {
+        out_strides[i] = out_strides[i] / in.shape(axis) * out.shape(axis);
+      }
+    }
+    out_data_size = out_data_size / in.shape(axis) * out.shape(axis);
+  }
+
+  auto plan = plan_fft(n);
+  if (plan.four_step) {
+    four_step_fft(in, out, axis, inverse, real, plan, copies, s, inplace);
+    d.add_temporaries(std::move(copies), s.index);
+    return;
+  }
+
+  // TODO: allow donation here
+  if (!inplace) {
+    out.set_data(
+        allocator::malloc(out.nbytes()),
+        out_data_size,
+        out_strides,
+        in_contiguous.flags());
+  }
+
+  auto radices = supported_radices();
+  int fft_size = plan.bluestein_n > 0 ? plan.bluestein_n : n;
+
+  // Setup function constants
+  bool power_of_2 = is_power_of_2(fft_size);
+
+  auto make_int = [](int* a, int i) {
+    return std::make_tuple(a, MTL::DataType::DataTypeInt, i);
+  };
+  auto make_bool = [](bool* a, int i) {
+    return std::make_tuple(a, MTL::DataType::DataTypeBool, i);
+  };
+
+  std::vector<MTLFC> func_consts = {
+      make_bool(&inverse, 0), make_bool(&power_of_2, 1)};
+
+  // Start of radix/rader step constants
+  int index = 4;
+  for (int i = 0; i < plan.stockham.size(); i++) {
+    func_consts.push_back(make_int(&plan.stockham[i], index));
+    index += 1;
+  }
+  for (int i = 0; i < plan.rader.size(); i++) {
+    func_consts.push_back(make_int(&plan.rader[i], index));
+    index += 1;
+  }
+  int elems_per_thread = compute_elems_per_thread(plan);
+  func_consts.push_back(make_int(&elems_per_thread, 2));
+
+  int rader_m = n / plan.rader_n;
+  func_consts.push_back(make_int(&rader_m, 3));
+
+  // The overall number of FFTs we're going to compute for this input
+  size_t size = out.dtype() == float32 ? out.size() : in.size();
+  if (real && inverse && four_step_params.required) {
+    size = out.size();
+  }
+  int total_batch_size = size / n;
+  int threads_per_fft = (fft_size + elems_per_thread - 1) / elems_per_thread;
+
+  // We batch among threadgroups for improved efficiency when n is small
+  int threadgroup_batch_size = std::max(MIN_THREADGROUP_MEM_SIZE / fft_size, 1);
+  if (four_step_params.required) {
+    // Require a threadgroup batch size of at least 4 for four step FFT
+    // so we can coalesce the memory accesses.
+    threadgroup_batch_size =
+        std::max(threadgroup_batch_size, MIN_COALESCE_WIDTH);
+  }
+  int threadgroup_mem_size = next_power_of_2(threadgroup_batch_size * fft_size);
+  // FFTs up to 2^20 are currently supported
+  assert(threadgroup_mem_size <= MAX_STOCKHAM_FFT_SIZE);
+
+  // ceil divide
+  int batch_size =
+      (total_batch_size + threadgroup_batch_size - 1) / threadgroup_batch_size;
+
+  if (real && !four_step_params.required) {
+    // We can perform 2 RFFTs at once so the batch size is halved.
+    batch_size = (batch_size + 2 - 1) / 2;
+  }
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto in_type_str = in.dtype() == float32 ? "float" : "float2";
+  auto out_type_str = out.dtype() == float32 ? "float" : "float2";
+  // Only required by four step
+  int step = -1;
+  {
+    std::ostringstream kname;
+    std::string inv_string = inverse ? "true" : "false";
+    std::string real_string = real ? "true" : "false";
+    std::string func_name;
+    if (plan.bluestein_n > 0) {
+      kname << "bluestein_fft_mem_" << threadgroup_mem_size << "_"
+            << in_type_str << "_" << out_type_str;
+      func_name = "bluestein_fft";
+    } else if (plan.rader_n > 1) {
+      kname << "rader_fft_mem_" << threadgroup_mem_size << "_" << in_type_str
+            << "_" << out_type_str;
+      func_name = "rader_fft";
+    } else if (four_step_params.required) {
+      step = four_step_params.first_step ? 0 : 1;
+      kname << "four_step_mem_" << threadgroup_mem_size << "_" << in_type_str
+            << "_" << out_type_str << "_" << step << "_" << real_string;
+      func_name = "four_step_fft";
+    } else {
+      kname << "fft_mem_" << threadgroup_mem_size << "_" << in_type_str << "_"
+            << out_type_str;
+      func_name = "fft";
+    }
+    std::string base_name = kname.str();
+    // We use a specialized kernel for each FFT size
+    kname << "_n" << fft_size << "_inv_" << inverse;
+    std::string hash_name = kname.str();
+    auto template_def = func_name == "four_step_fft" ? get_template_definition(
+                                                           base_name,
+                                                           func_name,
+                                                           threadgroup_mem_size,
+                                                           in_type_str,
+                                                           out_type_str,
+                                                           step,
+                                                           real)
+                                                     : get_template_definition(
+                                                           base_name,
+                                                           func_name,
+                                                           threadgroup_mem_size,
+                                                           in_type_str,
+                                                           out_type_str);
+    auto kernel =
+        get_fft_kernel(d, base_name, hash_name, func_consts, template_def);
+
+    compute_encoder.set_compute_pipeline_state(kernel);
+    compute_encoder.set_input_array(in_contiguous, 0);
+    compute_encoder.set_output_array(out, 1);
+
+    if (plan.bluestein_n > 0) {
+      // Precomputed twiddle factors for Bluestein's
+      auto [w_k, w_q] = compute_bluestein_constants(n, plan.bluestein_n);
+      copies.push_back(w_q);
+      copies.push_back(w_k);
+
+      compute_encoder.set_input_array(w_q, 2); // w_q
+      compute_encoder.set_input_array(w_k, 3); // w_k
+      compute_encoder.set_bytes(n, 4);
+      compute_encoder.set_bytes(plan.bluestein_n, 5);
+      compute_encoder.set_bytes(total_batch_size, 6);
+    } else if (plan.rader_n > 1) {
+      auto [b_q, g_q, g_minus_q] = compute_raders_constants(plan.rader_n, s);
+      copies.push_back(b_q);
+      copies.push_back(g_q);
+      copies.push_back(g_minus_q);
+
+      compute_encoder.set_input_array(b_q, 2);
+      compute_encoder.set_input_array(g_q, 3);
+      compute_encoder.set_input_array(g_minus_q, 4);
+      compute_encoder.set_bytes(n, 5);
+      compute_encoder.set_bytes(total_batch_size, 6);
+      compute_encoder.set_bytes(plan.rader_n, 7);
+    } else if (four_step_params.required) {
+      compute_encoder.set_bytes(four_step_params.n1, 2);
+      compute_encoder.set_bytes(four_step_params.n2, 3);
+      compute_encoder.set_bytes(total_batch_size, 4);
+    } else {
+      compute_encoder.set_bytes(n, 2);
+      compute_encoder.set_bytes(total_batch_size, 3);
+    }
+
+    auto group_dims = MTL::Size(1, threadgroup_batch_size, threads_per_fft);
+    auto grid_dims =
+        MTL::Size(batch_size, threadgroup_batch_size, threads_per_fft);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+
+  d.add_temporaries(std::move(copies), s.index);
+}
+
+void fft_op(
+    const array& in,
+    array& out,
+    size_t axis,
+    bool inverse,
+    bool real,
+    bool inplace,
+    const Stream& s) {
+  fft_op(in, out, axis, inverse, real, FourStepParams(), inplace, s);
+}
+
+void nd_fft_op(
+    const array& in,
+    array& out,
+    const std::vector<size_t>& axes,
+    bool inverse,
+    bool real,
+    const Stream& s) {
+  // Perform ND FFT on GPU as a series of 1D FFTs
+  auto temp_shape = inverse ? in.shape() : out.shape();
+  array temp1(temp_shape, complex64, nullptr, {});
+  array temp2(temp_shape, complex64, nullptr, {});
+  std::vector<array> temp_arrs = {temp1, temp2};
+  for (int i = axes.size() - 1; i >= 0; i--) {
+    int reverse_index = axes.size() - i - 1;
+    // For 5D and above, we don't want to reallocate our two temporary arrays
+    bool inplace = reverse_index >= 3 && i != 0;
+    // Opposite order for fft vs ifft
+    int index = inverse ? reverse_index : i;
+    size_t axis = axes[index];
+    // Mirror np.fft.(i)rfftn and perform a real transform
+    // only on the final axis.
+    bool step_real = (real && index == axes.size() - 1);
+    auto step_shape = inverse ? out.shape(axis) : in.shape(axis);
+    const array& in_arr = i == axes.size() - 1 ? in : temp_arrs[1 - i % 2];
+    array& out_arr = i == 0 ? out : temp_arrs[i % 2];
+    fft_op(in_arr, out_arr, axis, inverse, step_real, inplace, s);
+  }
+
+  auto& d = metal::device(s.device);
+  d.add_temporaries(std::move(temp_arrs), s.index);
+}
+
+void FFT::eval_gpu(const std::vector<array>& inputs, array& out) {
+  auto& s = stream();
+  auto& in = inputs[0];
+
+  if (axes_.size() > 1) {
+    nd_fft_op(in, out, axes_, inverse_, real_, s);
+  } else {
+    fft_op(in, out, axes_[0], inverse_, real_, /*inplace=*/false, s);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/hadamard.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/hadamard.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..65a87715136e2b804493ce157c2f0e75dbcc3350
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/hadamard.cpp
@@ -0,0 +1,198 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/backend/common/hadamard.h"
+#include "mlx/backend/common/compiled.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/jit/includes.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+constexpr int MAX_HADAMARD_THREADS_PER_GROUP = 256;
+
+std::string gen_hadamard_codelet(int m) {
+  // Generate a O(m^2) hadamard codelet for a given M
+  // using the hadamard matrices above
+  //
+  // e.g. m = 2
+  // METAL_FUNC void hadamard_m(thread float *x) {
+  //   float tmp[2];
+  //   tmp[0] = + x[0] + x[1];
+  //   tmp[1] = + x[0] - x[1];
+  //   for (int i = 0; i < 2; i++) { x[i] = tmp[i]; }
+  // }
+  //
+  auto h_matrices = hadamard_matrices();
+  auto& matrix = h_matrices[m];
+
+  std::ostringstream source;
+  source << "METAL_FUNC void hadamard_radix_m(thread float *x) {" << std::endl;
+  if (m == 1) {
+    source << "}" << std::endl;
+    return source.str();
+  }
+  source << "  float tmp[" << m << "];" << std::endl;
+  auto start = 1;
+  auto end = matrix.find('\n', start);
+
+  int index = 0;
+  while (end != std::string_view::npos) {
+    source << "  tmp[" << index << "] = ";
+    auto row = matrix.substr(start, end - start);
+    for (int i = 0; i < row.length(); i++) {
+      source << " " << row[i] << " x[" << i << "]";
+    }
+    source << ";" << std::endl;
+    start = end + 1;
+    end = matrix.find('\n', start);
+    index++;
+  }
+  source << "  for (int i = 0; i < " << m << "; i++) { x[i] = tmp[i]; }"
+         << std::endl;
+  source << "}" << std::endl;
+  return source.str();
+}
+
+void hadamard_mn_contiguous(
+    const array& x,
+    array& y,
+    int m,
+    int n1,
+    int n2,
+    float scale,
+    metal::Device& d,
+    const Stream& s) {
+  int n = n1 * n2;
+  int read_width_n1 = n1 == 2 ? 2 : 4;
+  int read_width_n2 = n2 == 2 ? 2 : 4;
+  int read_width_m = (n == 2 || m == 28) ? 2 : 4;
+  int max_radix_1 = std::min(n1, 16);
+  int max_radix_2 = std::min(n2, 16);
+  float scale_n1 = 1.0;
+  float scale_n2 = (m == 1) ? scale : 1.0;
+  float scale_m = scale;
+
+  // n2 is a row contiguous power of 2 hadamard transform
+  MTL::Size group_dims_n2(n2 / max_radix_2, 1, 1);
+  MTL::Size grid_dims_n2(n2 / max_radix_2, x.size() / n2, 1);
+
+  // n1 is a strided power of 2 hadamard transform with stride n2
+  MTL::Size group_dims_n1(n1 / max_radix_1, 1, 1);
+  MTL::Size grid_dims_n1(n1 / max_radix_1, x.size() / n, n2);
+
+  // m is a strided hadamard transform with stride n = n1 * n2
+  MTL::Size group_dims_m(
+      std::min(n / read_width_m, MAX_HADAMARD_THREADS_PER_GROUP), 1, 1);
+  MTL::Size grid_dims_m(
+      group_dims_m.width, x.size() / m / read_width_m / group_dims_m.width, 1);
+
+  // Make the kernel
+  std::string kname;
+  kname.reserve(32);
+  concatenate(kname, "hadamard_", n * m, "_", type_to_name(x));
+  auto lib = d.get_library(kname, [&]() {
+    std::string kernel;
+    concatenate(
+        kernel,
+        metal::utils(),
+        gen_hadamard_codelet(m),
+        metal::hadamard(),
+        get_template_definition(
+            "n2" + kname,
+            "hadamard_n",
+            get_type_string(x.dtype()),
+            n2,
+            max_radix_2,
+            read_width_n2));
+    if (n1 > 1) {
+      kernel += get_template_definition(
+          "n1" + kname,
+          "hadamard_n",
+          get_type_string(x.dtype()),
+          n1,
+          max_radix_1,
+          read_width_n1,
+          n2);
+    }
+    if (m > 1) {
+      kernel += get_template_definition(
+          "m" + kname,
+          "hadamard_m",
+          get_type_string(x.dtype()),
+          n,
+          m,
+          read_width_m);
+    }
+    return kernel;
+  });
+
+  // Launch the strided transform for n1
+  if (n1 > 1) {
+    auto& compute_encoder = d.get_command_encoder(s.index);
+    auto kernel = d.get_kernel("n1" + kname, lib);
+    compute_encoder.set_compute_pipeline_state(kernel);
+    compute_encoder.set_input_array(x, 0);
+    compute_encoder.set_output_array(y, 1);
+    compute_encoder.set_bytes(scale_n1, 2);
+    compute_encoder.dispatch_threads(grid_dims_n1, group_dims_n1);
+  }
+
+  // Launch the transform for n2
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel("n2" + kname, lib);
+  compute_encoder.set_compute_pipeline_state(kernel);
+  compute_encoder.set_input_array(n1 > 1 ? y : x, 0);
+  compute_encoder.set_output_array(y, 1);
+  compute_encoder.set_bytes(scale_n2, 2);
+  compute_encoder.dispatch_threads(grid_dims_n2, group_dims_n2);
+
+  // Launch the strided transform for m
+  if (m > 1) {
+    auto kernel = d.get_kernel("m" + kname, lib);
+    compute_encoder.set_compute_pipeline_state(kernel);
+    compute_encoder.set_input_array(y, 0);
+    compute_encoder.set_output_array(y, 1);
+    compute_encoder.set_bytes(scale_m, 2);
+    compute_encoder.dispatch_threads(grid_dims_m, group_dims_m);
+  }
+}
+
+void Hadamard::eval_gpu(const std::vector<array>& inputs, array& out) {
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+  auto& in = inputs[0];
+
+  // Split the hadamard transform so that all of them work on vectors smaller
+  // than 8192 elements.
+  //
+  // We decompose it in the following way:
+  //
+  // n = m * n1 * n2 = m * 2^k1 * 2^k2
+  //
+  // where m is in (1, 12, 20, 28) and n1 and n2 <= 8192
+  auto [n, m] = decompose_hadamard(in.shape().back());
+  int n1 = 1, n2 = n;
+  if (n > 8192) {
+    for (n2 = 2; n2 * n2 < n; n2 *= 2) {
+    }
+    n1 = n / n2;
+  }
+
+  if (in.flags().row_contiguous) {
+    if (in.is_donatable()) {
+      out.copy_shared_buffer(in);
+    } else {
+      out.set_data(allocator::malloc(out.nbytes()));
+    }
+    hadamard_mn_contiguous(in, out, m, n1, n2, scale_, d, s);
+  } else {
+    copy_gpu(in, out, CopyType::General, s);
+    hadamard_mn_contiguous(out, out, m, n1, n2, scale_, d, s);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/indexing.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/indexing.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0250987573f51b31a15b285ec0fc817d0d74889f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/indexing.cpp
@@ -0,0 +1,644 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <fmt/format.h>
+
+#include "mlx/backend/common/compiled.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/jit/includes.h"
+#include "mlx/backend/metal/jit/indexing.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+constexpr int METAL_MAX_INDEX_ARRAYS = 20;
+
+std::pair<std::string, std::string> make_index_args(
+    const std::string& idx_type,
+    int nidx) {
+  std::ostringstream idx_args;
+  std::ostringstream idx_arr;
+  for (int i = 0; i < nidx; ++i) {
+    idx_args << fmt::format(
+        "const device {0} *idx{1} [[buffer({2})]],", idx_type, i, 20 + i);
+    idx_arr << fmt::format("idx{0}", i);
+    if (i < nidx - 1) {
+      idx_args << "\n";
+      idx_arr << ",";
+    }
+  }
+  return {idx_args.str(), idx_arr.str()};
+}
+
+void Gather::eval_gpu(const std::vector<array>& inputs, array& out) {
+  auto& src = inputs[0];
+  int nidx = inputs.size() - 1;
+
+  if (nidx > METAL_MAX_INDEX_ARRAYS) {
+    std::ostringstream msg;
+    msg << "[Gather::eval_gpu] Gathering with more than "
+        << METAL_MAX_INDEX_ARRAYS << " index arrays not yet supported.";
+    throw std::runtime_error(msg.str());
+  }
+
+  out.set_data(allocator::malloc(out.nbytes()));
+  if (out.size() == 0) {
+    return;
+  }
+
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  size_t slice_size = 1;
+  for (auto s : slice_sizes_) {
+    slice_size *= s;
+  }
+
+  bool large_index = nidx && inputs[1].size() > INT32_MAX;
+  bool large_src = src.size() > INT32_MAX;
+  bool large_out = out.size() > INT32_MAX;
+  bool large = large_index || large_src || large_out;
+
+  std::string idx_type_name = nidx ? type_to_name(inputs[1]) : "";
+
+  if (src.flags().row_contiguous && nidx == 1 && axes_[0] == 0 &&
+      inputs[1].flags().row_contiguous && slice_size == src.strides()[0]) {
+    int work_per_thread = (slice_size > 8 && src.dtype().size() < 4) ? 2 : 1;
+    auto& indices = inputs[1];
+    std::string kernel_name = fmt::format(
+        "gather_front{0}_{1}_{2}_{3}",
+        type_to_name(out),
+        idx_type_name,
+        large ? "int64_t" : "int",
+        work_per_thread);
+    std::string lib_name = kernel_name;
+
+    auto lib = d.get_library(lib_name, [&]() {
+      std::string kernel_source = metal::utils();
+      kernel_source += metal::gather_front();
+      kernel_source += get_template_definition(
+          kernel_name,
+          "gather_front",
+          get_type_string(out.dtype()),
+          get_type_string(indices.dtype()),
+          large ? "int64_t" : "int",
+          work_per_thread);
+
+      return kernel_source;
+    });
+
+    auto& compute_encoder = d.get_command_encoder(s.index);
+    auto kernel = d.get_kernel(kernel_name, lib);
+    compute_encoder.set_compute_pipeline_state(kernel);
+
+    size_t dim_x = (slice_size + work_per_thread - 1) / work_per_thread;
+    size_t dim_y = indices.size();
+    auto group_dims = get_block_dims(dim_x, dim_y, 1);
+    MTL::Size grid_dims = MTL::Size(dim_x, dim_y, 1);
+
+    compute_encoder.set_input_array(src, 0);
+    compute_encoder.set_input_array(indices, 1);
+    compute_encoder.set_output_array(out, 2);
+    compute_encoder.set_bytes(slice_size, 3);
+    compute_encoder.set_bytes(src.shape(0), 4);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+
+    return;
+  }
+
+  int idx_ndim = nidx ? inputs[1].ndim() : 0;
+  size_t ndim = src.ndim();
+
+  std::string kernel_name = fmt::format(
+      "gather{0}{1}_{2}_{3}_{4}",
+      type_to_name(out),
+      idx_type_name,
+      nidx,
+      idx_ndim,
+      large ? "int64_t" : "int");
+  std::string lib_name = kernel_name;
+
+  auto lib = d.get_library(lib_name, [&]() {
+    std::string kernel_source = metal::utils();
+    kernel_source += metal::gather();
+    std::string out_type_str = get_type_string(out.dtype());
+    std::string idx_type_str =
+        nidx ? get_type_string(inputs[1].dtype()) : "bool";
+    auto [idx_args, idx_arr] = make_index_args(idx_type_str, nidx);
+
+    // Index dimension specializations
+    kernel_source += fmt::format(
+        gather_kernels,
+        type_to_name(out) + idx_type_name,
+        out_type_str,
+        idx_type_str,
+        nidx,
+        idx_args,
+        idx_arr,
+        idx_ndim,
+        large ? "int64_t" : "int");
+    return kernel_source;
+  });
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel(kernel_name, lib);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Launch 3D grid of threads
+  // First two dimensions for the indices, the last one for the slice
+  size_t dim0 = 1;
+  size_t dim1 = 1;
+  if (nidx) {
+    if (inputs[1].ndim() >= 1) {
+      dim0 = inputs[1].shape(0);
+    }
+    if (inputs[1].ndim() >= 2) {
+      dim1 = inputs[1].size() / dim0;
+    }
+  }
+  size_t dim2 = slice_size;
+  auto group_dims = get_block_dims(dim0, dim1, dim2);
+  MTL::Size grid_dims = MTL::Size(dim0, dim1, dim2);
+
+  // Collect all idx shapes and strides into one place
+  std::vector<int> idx_shapes;
+  std::vector<size_t> idx_strides;
+  std::vector<char> idx_contigs;
+  for (int i = 0; i < nidx; ++i) {
+    idx_shapes.insert(
+        idx_shapes.end(),
+        inputs[i + 1].shape().begin(),
+        inputs[i + 1].shape().end());
+    idx_strides.insert(
+        idx_strides.end(),
+        inputs[i + 1].strides().begin(),
+        inputs[i + 1].strides().end());
+    idx_contigs.push_back(inputs[i + 1].flags().row_contiguous);
+  }
+
+  // Set all the buffers
+  compute_encoder.set_input_array(src, 0);
+  compute_encoder.set_output_array(out, 1);
+
+  // Set source info
+  compute_encoder.set_vector_bytes(src.shape(), 2);
+  compute_encoder.set_vector_bytes(src.strides(), 3);
+  compute_encoder.set_bytes(ndim, 4);
+  compute_encoder.set_vector_bytes(slice_sizes_, 5);
+  compute_encoder.set_vector_bytes(axes_, 6);
+
+  // Set index info
+  //
+  // We don't need to check for empty idx_shapes because gather has a
+  // idx_ndim == 0 specialization
+  compute_encoder.set_vector_bytes(idx_shapes, 7);
+  compute_encoder.set_vector_bytes(idx_strides, 8);
+  compute_encoder.set_vector_bytes(idx_contigs, 9);
+  compute_encoder.set_bytes(idx_ndim, 10);
+
+  // Set index buffers
+  for (int i = 0; i < nidx; ++i) {
+    compute_encoder.set_input_array(inputs[i + 1], 20 + i);
+  }
+
+  // Launch grid
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+void Scatter::eval_gpu(const std::vector<array>& inputs, array& out) {
+  if (size_of(out.dtype()) == 8) {
+    std::ostringstream msg;
+    msg << "[Scatter::eval_gpu] Does not support " << out.dtype();
+    throw std::invalid_argument(msg.str());
+  }
+
+  int nidx = axes_.size();
+  if (nidx > METAL_MAX_INDEX_ARRAYS) {
+    std::ostringstream msg;
+    msg << "[Scatter::eval_gpu] Gathering with more than "
+        << METAL_MAX_INDEX_ARRAYS << " index arrays not yet supported.";
+    throw std::runtime_error(msg.str());
+  }
+
+  // Copy src into out
+  CopyType copy_type;
+  if (inputs[0].data_size() == 1) {
+    copy_type = CopyType::Scalar;
+  } else if (inputs[0].flags().row_contiguous) {
+    copy_type = CopyType::Vector;
+  } else {
+    copy_type = CopyType::General;
+  }
+  copy_gpu(inputs[0], out, copy_type);
+
+  auto& upd = inputs.back();
+
+  // Empty update
+  if (upd.size() == 0) {
+    return;
+  }
+
+  // Get stream
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  int idx_ndim = nidx ? inputs[1].ndim() : 0;
+  size_t idx_size = nidx ? inputs[1].size() : 1;
+
+  auto idx_to_out = idx_size / out.size();
+  int nwork;
+  if (idx_ndim <= 1 || idx_to_out < 1) {
+    nwork = 1;
+  } else if (idx_to_out <= 4) {
+    nwork = 4;
+  } else if (idx_to_out < 16) {
+    nwork = 8;
+  } else if (idx_to_out < 32) {
+    nwork = 16;
+  } else {
+    nwork = 32;
+  }
+
+  std::string idx_type_name = nidx ? type_to_name(inputs[1]) : "";
+  std::string op_name;
+  switch (reduce_type_) {
+    case Scatter::None:
+      op_name = "none";
+      break;
+    case Scatter::Sum:
+      op_name = "sum";
+      break;
+    case Scatter::Prod:
+      op_name = "prod";
+      break;
+    case Scatter::Max:
+      op_name = "max";
+      break;
+    case Scatter::Min:
+      op_name = "min";
+      break;
+  }
+  auto upd_contig = upd.flags().row_contiguous;
+  bool large_out = out.size() > INT32_MAX;
+  bool large_idx = nidx && (inputs[1].size() > INT32_MAX);
+  bool large_upd = upd.size() > INT32_MAX;
+  bool large = large_out || large_idx || large_upd;
+  std::string kernel_name = fmt::format(
+      "scatter{0}{1}_{2}_{3}_{4}_nwork{5}_{6}",
+      type_to_name(out),
+      idx_type_name,
+      op_name,
+      nidx,
+      upd_contig ? "updc_true" : "updc_false",
+      nwork,
+      large ? "int64_t" : "int");
+  std::string lib_name = kernel_name;
+
+  auto lib = d.get_library(lib_name, [&]() {
+    std::string kernel_source = metal::utils();
+    concatenate(kernel_source, metal::reduce_utils(), metal::scatter());
+
+    std::string out_type_str = get_type_string(out.dtype());
+    std::string idx_type_str =
+        nidx ? get_type_string(inputs[1].dtype()) : "bool";
+    std::string op_type;
+    switch (reduce_type_) {
+      case Scatter::None:
+        op_type = "None";
+        break;
+      case Scatter::Sum:
+        op_type = "Sum<{0}>";
+        break;
+      case Scatter::Prod:
+        op_type = "Prod<{0}>";
+        break;
+      case Scatter::Max:
+        op_type = "Max<{0}>";
+        break;
+      case Scatter::Min:
+        op_type = "Min<{0}>";
+        break;
+    }
+    if (reduce_type_ != Scatter::None) {
+      op_type = fmt::format(fmt::runtime(op_type), out_type_str);
+    }
+    auto [idx_args, idx_arr] = make_index_args(idx_type_str, nidx);
+
+    kernel_source += fmt::format(
+        scatter_kernels,
+        type_to_name(out) + idx_type_name + "_" + op_name,
+        out_type_str,
+        idx_type_str,
+        op_type,
+        nidx,
+        idx_args,
+        idx_arr,
+        upd_contig,
+        nwork,
+        large ? "int64_t" : "int");
+    return kernel_source;
+  });
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel(kernel_name, lib);
+
+  size_t nthreads = upd.size();
+
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Set all the buffers
+  compute_encoder.set_input_array(upd, 1);
+  compute_encoder.set_output_array(out, 2);
+
+  // Set update info
+  size_t upd_ndim = upd.ndim();
+  size_t upd_size = 1;
+  for (int i = idx_ndim; i < upd.ndim(); ++i) {
+    upd_size *= upd.shape(i);
+  }
+  // Collect all idx shapes and strides into one place
+  Shape idx_shapes;
+  Strides idx_strides;
+  // To access .data() use char instead of bool
+  // bool is 1 byte in Metal so this is safe
+  std::vector<char> idx_contigs;
+  for (int i = 0; i < nidx; ++i) {
+    idx_shapes.insert(
+        idx_shapes.end(),
+        inputs[i + 1].shape().begin(),
+        inputs[i + 1].shape().end());
+    idx_strides.insert(
+        idx_strides.end(),
+        inputs[i + 1].strides().begin(),
+        inputs[i + 1].strides().end());
+    idx_contigs.push_back(inputs[i + 1].flags().row_contiguous);
+  }
+
+  if (upd_ndim == 0) {
+    // Need placeholders so Metal doesn't complain
+    int shape_ = 0;
+    int64_t stride_ = 0;
+    compute_encoder.set_bytes(shape_, 3);
+    compute_encoder.set_bytes(stride_, 4);
+  } else {
+    compute_encoder.set_vector_bytes(upd.shape(), 3);
+    compute_encoder.set_vector_bytes(upd.strides(), 4);
+  }
+  compute_encoder.set_bytes(upd_ndim, 5);
+  compute_encoder.set_bytes(upd_size, 6);
+
+  // Set output info
+  size_t out_ndim = out.ndim();
+  if (out_ndim == 0) {
+    // Need placeholders so Metal doesn't complain
+    int shape_ = 0;
+    int64_t stride_ = 0;
+    compute_encoder.set_bytes(shape_, 7);
+    compute_encoder.set_bytes(stride_, 8);
+  } else {
+    compute_encoder.set_vector_bytes(out.shape(), 7);
+    compute_encoder.set_vector_bytes(out.strides(), 8);
+  }
+  compute_encoder.set_bytes(out_ndim, 9);
+  compute_encoder.set_vector_bytes(axes_, 10);
+
+  // Set index info
+  if (idx_ndim == 0) {
+    // Add a 0 in idx_shapes and strides to avoid the missing buffer binding
+    // error in the metal API.
+    idx_shapes.push_back(0);
+    idx_strides.push_back(0);
+    idx_contigs.push_back(false);
+  }
+  compute_encoder.set_vector_bytes(idx_shapes, 11);
+  compute_encoder.set_vector_bytes(idx_strides, 12);
+  compute_encoder.set_vector_bytes(idx_contigs, 13);
+  compute_encoder.set_bytes(idx_ndim, 14);
+  compute_encoder.set_bytes(idx_size, 15);
+
+  // Set index buffers
+  for (int i = 0; i < nidx; ++i) {
+    compute_encoder.set_input_array(inputs[i + 1], 20 + i);
+  }
+
+  // Launch grid
+  auto grid_y = (nthreads / upd_size);
+  grid_y = (grid_y + nwork - 1) / nwork;
+  MTL::Size grid_dims = MTL::Size(upd_size, grid_y, 1);
+  auto thread_group_size = kernel->maxTotalThreadsPerThreadgroup();
+  if (thread_group_size != 1024) {
+    throw std::runtime_error("[Scatter::eval_gpu] Invalid number of threads");
+  }
+  MTL::Size group_dims = get_block_dims(upd_size, grid_y, 1);
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+void GatherAxis::eval_gpu(const std::vector<array>& inputs, array& out) {
+  auto& src = inputs[0];
+  auto& idx = inputs[1];
+
+  out.set_data(allocator::malloc(out.nbytes()));
+  if (out.size() == 0) {
+    return;
+  }
+
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  size_t ndim = src.ndim();
+
+  bool large = idx.size() > INT32_MAX || src.size() > INT32_MAX;
+
+  std::string kernel_name = fmt::format(
+      "gather_axis{0}{1}_{2}",
+      type_to_name(out),
+      type_to_name(idx),
+      large ? "int64_t" : "int");
+  std::string lib_name = kernel_name;
+  kernel_name += src.flags().row_contiguous ? "c" : "nc";
+  kernel_name += idx.flags().row_contiguous ? "c" : "nc";
+
+  auto lib = d.get_library(lib_name, [&]() {
+    std::string kernel_source = metal::utils();
+    kernel_source += metal::gather_axis();
+    std::string out_type_str = get_type_string(out.dtype());
+    std::string idx_type_str = get_type_string(idx.dtype());
+    for (int i = 0; i < 4; ++i) {
+      bool sc = i & 1;
+      bool ic = i & 2;
+      kernel_source += get_template_definition(
+          lib_name + (sc ? "c" : "nc") + (ic ? "c" : "nc"),
+          "gather_axis",
+          out_type_str,
+          idx_type_str,
+          large ? "int64_t" : "int",
+          sc ? "true" : "false",
+          ic ? "true" : "false");
+    }
+    return kernel_source;
+  });
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel(kernel_name, lib);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Grid [size post, index size, size pre]
+  size_t size_pre = 1;
+  size_t size_post = 1;
+  for (int i = 0; i < axis_; ++i) {
+    size_pre *= idx.shape(i);
+  }
+  for (int i = axis_ + 1; i < idx.ndim(); ++i) {
+    size_post *= idx.shape(i);
+  }
+
+  int idx_ax_size = idx.shape(axis_);
+  auto group_dims = get_block_dims(size_post, idx_ax_size, size_pre);
+  MTL::Size grid_dims = MTL::Size(size_post, idx_ax_size, size_pre);
+
+  // Set all the buffers
+  compute_encoder.set_input_array(src, 0);
+  compute_encoder.set_input_array(idx, 1);
+  compute_encoder.set_output_array(out, 2);
+
+  // Set source info
+  compute_encoder.set_vector_bytes(remove_index(idx.shape(), axis_), 3);
+  compute_encoder.set_vector_bytes(remove_index(src.strides(), axis_), 4);
+  compute_encoder.set_vector_bytes(remove_index(idx.strides(), axis_), 5);
+  compute_encoder.set_bytes(ndim - 1, 6);
+  compute_encoder.set_bytes(axis_, 7);
+  compute_encoder.set_bytes(src.shape(axis_), 8);
+  compute_encoder.set_bytes(src.strides(axis_), 9);
+  compute_encoder.set_bytes(idx.strides(axis_), 10);
+
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+void ScatterAxis::eval_gpu(const std::vector<array>& inputs, array& out) {
+  auto& src = inputs[0];
+  auto& idx = inputs[1];
+  auto& upd = inputs[2];
+
+  // Copy src into out
+  CopyType copy_type;
+  if (src.data_size() == 1) {
+    copy_type = CopyType::Scalar;
+  } else if (src.flags().row_contiguous) {
+    copy_type = CopyType::Vector;
+  } else {
+    copy_type = CopyType::General;
+  }
+  copy_gpu(src, out, copy_type);
+
+  // Empty update
+  if (upd.size() == 0) {
+    return;
+  }
+
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  size_t ndim = src.ndim();
+
+  bool large = idx.size() > INT32_MAX || src.size() > INT32_MAX;
+
+  std::string op_name;
+  switch (reduce_type_) {
+    case ScatterAxis::None:
+      op_name = "none";
+      break;
+    case ScatterAxis::Sum:
+      op_name = "sum";
+      break;
+  }
+
+  std::string kernel_name = fmt::format(
+      "scatter_axis{0}{1}_{2}_{3}",
+      type_to_name(out),
+      type_to_name(idx),
+      op_name,
+      large ? "int64_t" : "int");
+  std::string lib_name = kernel_name;
+  kernel_name += upd.flags().row_contiguous ? "c" : "nc";
+  kernel_name += idx.flags().row_contiguous ? "c" : "nc";
+
+  auto lib = d.get_library(lib_name, [&]() {
+    std::string kernel_source = metal::utils();
+    kernel_source += metal::reduce_utils();
+    kernel_source += metal::scatter_axis();
+    std::string out_type_str = get_type_string(out.dtype());
+    std::string idx_type_str = get_type_string(idx.dtype());
+    std::string op_type;
+    switch (reduce_type_) {
+      case ScatterAxis::None:
+        op_type = "None";
+        break;
+      case ScatterAxis::Sum:
+        op_type = "Sum<" + out_type_str + ">";
+        break;
+    }
+
+    for (int i = 0; i < 4; ++i) {
+      bool uc = i & 1;
+      bool ic = i & 2;
+      kernel_source += get_template_definition(
+          lib_name + (uc ? "c" : "nc") + (ic ? "c" : "nc"),
+          "scatter_axis",
+          out_type_str,
+          idx_type_str,
+          large ? "int64_t" : "int",
+          op_type,
+          uc ? "true" : "false",
+          ic ? "true" : "false");
+    }
+    return kernel_source;
+  });
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel(kernel_name, lib);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Grid [size post, index size, size pre]
+  size_t size_pre = 1;
+  size_t size_post = 1;
+  for (int i = 0; i < axis_; ++i) {
+    size_pre *= idx.shape(i);
+  }
+  for (int i = axis_ + 1; i < idx.ndim(); ++i) {
+    size_post *= idx.shape(i);
+  }
+
+  int idx_ax_size = idx.shape(axis_);
+  auto group_dims = get_block_dims(size_post, idx_ax_size, size_pre);
+  MTL::Size grid_dims = MTL::Size(size_post, idx_ax_size, size_pre);
+
+  // Set all the buffers
+  compute_encoder.set_input_array(upd, 0);
+  compute_encoder.set_input_array(idx, 1);
+  compute_encoder.set_output_array(out, 2);
+
+  // Set source info
+  if (ndim > 1) {
+    compute_encoder.set_vector_bytes(remove_index(idx.shape(), axis_), 3);
+    compute_encoder.set_vector_bytes(remove_index(upd.strides(), axis_), 4);
+    compute_encoder.set_vector_bytes(remove_index(idx.strides(), axis_), 5);
+  } else {
+    // The following will be ignored in the kernel but we still have to set
+    // some value so that metal validation passes.
+    compute_encoder.set_vector_bytes(idx.shape(), 3);
+    compute_encoder.set_vector_bytes(upd.strides(), 4);
+    compute_encoder.set_vector_bytes(idx.strides(), 5);
+  }
+  compute_encoder.set_bytes(ndim - 1, 6);
+  compute_encoder.set_bytes(axis_, 7);
+  compute_encoder.set_bytes(out.shape(axis_), 8);
+  compute_encoder.set_bytes(upd.strides(axis_), 9);
+  compute_encoder.set_bytes(idx.strides(axis_), 10);
+
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/jit/includes.h b/ml-stable-diffusion/mlx/mlx/backend/metal/jit/includes.h
new file mode 100644
index 0000000000000000000000000000000000000000..f3b57c7f99d4c92b0a5a02222489364855c3f34f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/jit/includes.h
@@ -0,0 +1,46 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+namespace mlx::core::metal {
+
+const char* utils();
+const char* binary_ops();
+const char* unary_ops();
+const char* ternary_ops();
+const char* reduce_utils();
+const char* gather();
+const char* scatter();
+
+const char* arange();
+const char* unary();
+const char* binary();
+const char* binary_two();
+const char* copy();
+const char* fft();
+const char* gather_axis();
+const char* gather_front();
+const char* hadamard();
+const char* logsumexp();
+const char* quantized_utils();
+const char* quantized();
+const char* fp4_quantized();
+const char* ternary();
+const char* scan();
+const char* scatter_axis();
+const char* softmax();
+const char* sort();
+const char* reduce();
+
+const char* gemm();
+const char* steel_gemm_fused();
+const char* steel_gemm_masked();
+const char* steel_gemm_splitk();
+const char* steel_gemm_gather();
+const char* steel_gemm_segmented();
+const char* conv();
+const char* steel_conv();
+const char* steel_conv_general();
+const char* gemv_masked();
+
+} // namespace mlx::core::metal
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/jit/indexing.h b/ml-stable-diffusion/mlx/mlx/backend/metal/jit/indexing.h
new file mode 100644
index 0000000000000000000000000000000000000000..57bafc229b39fb0f75009c2a8a2489c3cf30cec2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/jit/indexing.h
@@ -0,0 +1,72 @@
+// Copyright © 2023-2024 Apple Inc.
+
+constexpr std::string_view gather_kernels = R"(
+[[kernel]] void gather{0}_{3}_{6}_{7}(
+    const device {1}* src [[buffer(0)]],
+    device {1}* out [[buffer(1)]],
+    const constant int* src_shape [[buffer(2)]],
+    const constant int64_t* src_strides [[buffer(3)]],
+    const constant size_t& src_ndim [[buffer(4)]],
+    const constant int* slice_sizes [[buffer(5)]],
+    const constant int* axes [[buffer(6)]],
+    const constant int* idx_shapes [[buffer(7)]],
+    const constant int64_t* idx_strides [[buffer(8)]],
+    const constant bool* idx_contigs [[buffer(9)]],
+    const constant int& idx_ndim [[buffer(10)]],
+    {4}
+    uint3 index [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {{
+  Indices<{2}, {3}> idxs{{
+    {{ {5} }}, idx_shapes, idx_strides, idx_contigs, idx_ndim}};
+
+  return gather_impl<{1}, {2}, {3}, {6}, {7}>(
+      src,
+      out,
+      src_shape,
+      src_strides,
+      src_ndim,
+      slice_sizes,
+      axes,
+      idxs,
+      index,
+      grid_dim);
+}}
+)";
+
+constexpr std::string_view scatter_kernels = R"(
+[[kernel]] void scatter{0}_{4}_updc_{7}_nwork{8}_{9}(
+    const device {1}* updates [[buffer(1)]],
+    device mlx_atomic<{1}>* out [[buffer(2)]],
+    const constant int* upd_shape [[buffer(3)]],
+    const constant int64_t* upd_strides [[buffer(4)]],
+    const constant size_t& upd_ndim [[buffer(5)]],
+    const constant size_t& upd_size [[buffer(6)]],
+    const constant int* out_shape [[buffer(7)]],
+    const constant int64_t* out_strides [[buffer(8)]],
+    const constant size_t& out_ndim [[buffer(9)]],
+    const constant int* axes [[buffer(10)]],
+    const constant int* idx_shapes [[buffer(11)]],
+    const constant int64_t* idx_strides [[buffer(12)]],
+    const constant bool* idx_contigs [[buffer(13)]],
+    const constant int& idx_ndim [[buffer(14)]],
+    const constant size_t& idx_size [[buffer(15)]],
+    {5}
+    uint2 gid [[thread_position_in_grid]]) {{
+  Indices<{2}, {4}> idxs{{ {{ {6} }}, idx_shapes, idx_strides, idx_contigs, idx_ndim}};
+
+  return scatter_impl<{1}, {2}, {3}, {4}, {7}, {8}, {9}>(
+      updates,
+      out,
+      upd_shape,
+      upd_strides,
+      upd_ndim,
+      upd_size,
+      out_shape,
+      out_strides,
+      out_ndim,
+      axes,
+      idx_size,
+      idxs,
+      gid);
+}}
+)";
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/jit_kernels.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/jit_kernels.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e70420cf8927b2db7e85180096ac912b4fd86308
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/jit_kernels.cpp
@@ -0,0 +1,897 @@
+// Copyright © 2024 Apple Inc.
+#include "mlx/backend/common/compiled.h"
+#include "mlx/backend/metal/jit/includes.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/utils.h"
+
+using namespace fmt::literals;
+
+namespace mlx::core {
+
+MTL::ComputePipelineState* get_arange_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& out) {
+  auto lib = d.get_library(kernel_name, [&]() {
+    std::string kernel_source = metal::utils();
+    kernel_source += metal::arange();
+    kernel_source += get_template_definition(
+        kernel_name, "arange", get_type_string(out.dtype()));
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_unary_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    Dtype in_type,
+    Dtype out_type,
+    const char* op) {
+  std::string lib_name = kernel_name.substr(kernel_name.find("_") + 1);
+  auto lib = d.get_library(lib_name, [&]() {
+    auto in_t = get_type_string(in_type);
+    auto out_t = get_type_string(out_type);
+    std::string kernel_source = metal::utils();
+    concatenate(kernel_source, metal::unary_ops(), metal::unary());
+    kernel_source +=
+        get_template_definition("v_" + lib_name, "unary_v", in_t, out_t, op, 1);
+    if (get_work_per_thread(in_type) > 1) {
+      kernel_source +=
+          get_template_definition("vn_" + lib_name, "unary_v", in_t, out_t, op);
+    }
+    kernel_source +=
+        get_template_definition("v2_" + lib_name, "unary_v2", in_t, out_t, op);
+    kernel_source += get_template_definition(
+        "gn1_" + lib_name, "unary_g", in_t, out_t, op, 1, "int");
+    kernel_source += get_template_definition(
+        "gn4large_" + lib_name, "unary_g", in_t, out_t, op, 4);
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+void append_binary_kernels(
+    const std::string& lib_name,
+    Dtype in_type,
+    Dtype out_type,
+    const char* op,
+    std::string& kernel_source) {
+  const std::array<std::pair<std::string, std::string>, 7> kernel_types = {{
+      {"ss", "binary_ss"},
+      {"vs2", "binary_vs2"},
+      {"sv2", "binary_sv2"},
+      {"vv2", "binary_vv2"},
+      {"g1large", "binary_g_nd1"},
+      {"g2large", "binary_g_nd2"},
+      {"g3large", "binary_g_nd3"},
+  }};
+  auto in_t = get_type_string(in_type);
+  auto out_t = get_type_string(out_type);
+
+  for (auto& [name, func] : kernel_types) {
+    kernel_source +=
+        get_template_definition(name + "_" + lib_name, func, in_t, out_t, op);
+  }
+  kernel_source += get_template_definition(
+      "vs_" + lib_name, "binary_vs", in_t, out_t, op, 1);
+  kernel_source += get_template_definition(
+      "sv_" + lib_name, "binary_sv", in_t, out_t, op, 1);
+  kernel_source += get_template_definition(
+      "vv_" + lib_name, "binary_vv", in_t, out_t, op, 1);
+
+  if (get_work_per_thread(in_type) > 1) {
+    kernel_source += get_template_definition(
+        "vsn_" + lib_name, "binary_vs", in_t, out_t, op);
+    kernel_source += get_template_definition(
+        "svn_" + lib_name, "binary_sv", in_t, out_t, op);
+    kernel_source += get_template_definition(
+        "vvn_" + lib_name, "binary_vv", in_t, out_t, op);
+  }
+
+  kernel_source += get_template_definition(
+      "g1_" + lib_name, "binary_g_nd1", in_t, out_t, op, "int");
+  kernel_source += get_template_definition(
+      "g2_" + lib_name, "binary_g_nd2", in_t, out_t, op, "int");
+  kernel_source += get_template_definition(
+      "g3_" + lib_name, "binary_g_nd3", in_t, out_t, op, "int");
+  kernel_source += get_template_definition(
+      "gn2_" + lib_name, "binary_g", in_t, out_t, op, 2, "int");
+  kernel_source += get_template_definition(
+      "gn4large_" + lib_name, "binary_g", in_t, out_t, op, 4);
+}
+
+MTL::ComputePipelineState* get_binary_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    Dtype in_type,
+    Dtype out_type,
+    const char* op) {
+  std::string lib_name = kernel_name.substr(kernel_name.find("_") + 1);
+  auto lib = d.get_library(lib_name, [&]() {
+    std::string kernel_source;
+    kernel_source = metal::utils();
+    concatenate(kernel_source, metal::binary_ops(), metal::binary());
+    append_binary_kernels(lib_name, in_type, out_type, op, kernel_source);
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_binary_two_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    Dtype in_type,
+    Dtype out_type,
+    const char* op) {
+  std::string lib_name = kernel_name.substr(kernel_name.find("_") + 1);
+  auto lib = d.get_library(lib_name, [&]() {
+    std::string kernel_source = metal::utils();
+    concatenate(kernel_source, metal::binary_ops(), metal::binary_two());
+    append_binary_kernels(lib_name, in_type, out_type, op, kernel_source);
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_ternary_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    Dtype type,
+    const char* op) {
+  std::string lib_name = kernel_name.substr(kernel_name.find("_") + 1);
+  auto lib = d.get_library(lib_name, [&]() {
+    auto t_str = get_type_string(type);
+    std::string kernel_source = metal::utils();
+    concatenate(kernel_source, metal::ternary_ops(), metal::ternary());
+    const std::array<std::pair<std::string, std::string>, 3> kernel_types = {{
+        {"g1large", "ternary_g_nd1"},
+        {"g2large", "ternary_g_nd2"},
+        {"g3large", "ternary_g_nd3"},
+    }};
+    for (auto& [name, func] : kernel_types) {
+      kernel_source +=
+          get_template_definition(name + "_" + lib_name, func, t_str, op);
+    }
+
+    kernel_source += get_template_definition(
+        "v2_" + lib_name, "ternary_v2", t_str, op, false, false);
+    kernel_source += get_template_definition(
+        "sv2_" + lib_name, "ternary_v2", t_str, op, true, false);
+    kernel_source += get_template_definition(
+        "vs2_" + lib_name, "ternary_v2", t_str, op, false, true);
+
+    if (get_work_per_thread(type) > 1) {
+      kernel_source += get_template_definition(
+          "vn_" + lib_name, "ternary_v", t_str, op, false, false);
+      kernel_source += get_template_definition(
+          "svn_" + lib_name, "ternary_v", t_str, op, true, false);
+      kernel_source += get_template_definition(
+          "vsn_" + lib_name, "ternary_v", t_str, op, false, true);
+    }
+
+    kernel_source += get_template_definition(
+        "v_" + lib_name, "ternary_v", t_str, op, false, false, 1);
+    kernel_source += get_template_definition(
+        "sv_" + lib_name, "ternary_v", t_str, op, true, false, 1);
+    kernel_source += get_template_definition(
+        "vs_" + lib_name, "ternary_v", t_str, op, false, true, 1);
+    kernel_source += get_template_definition(
+        "g1_" + lib_name, "ternary_g_nd1", t_str, op, "int");
+    kernel_source += get_template_definition(
+        "g2_" + lib_name, "ternary_g_nd2", t_str, op, "int");
+    kernel_source += get_template_definition(
+        "g3_" + lib_name, "ternary_g_nd3", t_str, op, "int");
+    kernel_source += get_template_definition(
+        "gn2_" + lib_name, "ternary_g", t_str, op, 2, "int");
+    kernel_source += get_template_definition(
+        "gn4large_" + lib_name, "ternary_g", t_str, op, 4);
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_copy_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& in,
+    const array& out) {
+  std::string lib_name = kernel_name.substr(kernel_name.find("_") + 1);
+  auto lib = d.get_library(lib_name, [&]() {
+    std::string kernel_source = metal::utils();
+    kernel_source += metal::copy();
+    auto in_type = get_type_string(in.dtype());
+    auto out_type = get_type_string(out.dtype());
+    kernel_source += get_template_definition(
+        "s_" + lib_name, "copy_s", in_type, out_type, 1);
+    kernel_source +=
+        get_template_definition("s2_" + lib_name, "copy_s2", in_type, out_type);
+    kernel_source += get_template_definition(
+        "v_" + lib_name, "copy_v", in_type, out_type, 1);
+    kernel_source +=
+        get_template_definition("v2_" + lib_name, "copy_v2", in_type, out_type);
+
+    if (get_work_per_thread(out.dtype()) > 1) {
+      kernel_source += get_template_definition(
+          "sn_" + lib_name, "copy_s", in_type, out_type);
+      kernel_source += get_template_definition(
+          "vn_" + lib_name, "copy_v", in_type, out_type);
+    }
+
+    kernel_source += get_template_definition(
+        "g1_" + lib_name, "copy_g_nd1", in_type, out_type, "int");
+    kernel_source += get_template_definition(
+        "g2_" + lib_name, "copy_g_nd2", in_type, out_type, "int");
+    kernel_source += get_template_definition(
+        "g3_" + lib_name, "copy_g_nd3", in_type, out_type, "int");
+    kernel_source += get_template_definition(
+        "gn2_" + lib_name, "copy_g", in_type, out_type, 2, "int");
+    kernel_source += get_template_definition(
+        "gg1_" + lib_name, "copy_gg_nd1", in_type, out_type, "int");
+    kernel_source += get_template_definition(
+        "gg2_" + lib_name, "copy_gg_nd2", in_type, out_type, "int");
+    kernel_source += get_template_definition(
+        "gg3_" + lib_name, "copy_gg_nd3", in_type, out_type, "int");
+    kernel_source += get_template_definition(
+        "ggn2_" + lib_name, "copy_gg", in_type, out_type, 2, "int");
+    kernel_source += get_template_definition(
+        "g1large_" + lib_name, "copy_g_nd1", in_type, out_type);
+    kernel_source += get_template_definition(
+        "g2large_" + lib_name, "copy_g_nd2", in_type, out_type);
+    kernel_source += get_template_definition(
+        "g3large_" + lib_name, "copy_g_nd3", in_type, out_type);
+    kernel_source += get_template_definition(
+        "gn4large_" + lib_name, "copy_g", in_type, out_type, 4);
+    kernel_source += get_template_definition(
+        "gg1large_" + lib_name, "copy_gg_nd1", in_type, out_type);
+    kernel_source += get_template_definition(
+        "gg2large_" + lib_name, "copy_gg_nd2", in_type, out_type);
+    kernel_source += get_template_definition(
+        "gg3large_" + lib_name, "copy_gg_nd3", in_type, out_type);
+    kernel_source += get_template_definition(
+        "ggn4large_" + lib_name, "copy_gg", in_type, out_type, 4);
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_dynamic_copy_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& in,
+    const array& out) {
+  std::string lib_name = kernel_name.substr(kernel_name.find("_") + 1);
+  auto lib = d.get_library(lib_name, [&]() {
+    std::string kernel_source = metal::utils();
+    kernel_source += metal::copy();
+    auto in_type = get_type_string(in.dtype());
+    auto out_type = get_type_string(out.dtype());
+    kernel_source += get_template_definition(
+        "gg1_" + lib_name, "copy_gg_dynamic_nd1", in_type, out_type, "int");
+    kernel_source += get_template_definition(
+        "gg2_" + lib_name, "copy_gg_dynamic_nd2", in_type, out_type, "int");
+    kernel_source += get_template_definition(
+        "gg3_" + lib_name, "copy_gg_dynamic_nd3", in_type, out_type, "int");
+    kernel_source += get_template_definition(
+        "ggn2_" + lib_name, "copy_gg_dynamic", in_type, out_type, 2, "int");
+    kernel_source += get_template_definition(
+        "gg1large_" + lib_name, "copy_gg_dynamic_nd1", in_type, out_type);
+    kernel_source += get_template_definition(
+        "gg2large_" + lib_name, "copy_gg_dynamic_nd2", in_type, out_type);
+    kernel_source += get_template_definition(
+        "gg3large_" + lib_name, "copy_gg_dynamic_nd3", in_type, out_type);
+    kernel_source += get_template_definition(
+        "ggn4large_" + lib_name, "copy_gg_dynamic", in_type, out_type, 4);
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_softmax_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    bool precise,
+    const array& out) {
+  std::string lib_name = kernel_name.substr(kernel_name.find("_") + 1);
+  auto lib = d.get_library(lib_name, [&] {
+    std::string kernel_source = metal::utils();
+    auto in_type = get_type_string(out.dtype());
+    auto acc_type = get_type_string(precise ? float32 : out.dtype());
+    kernel_source += metal::softmax();
+    kernel_source += get_template_definition(
+        "block_" + lib_name, "softmax_single_row", in_type, acc_type);
+    kernel_source += get_template_definition(
+        "looped_" + lib_name, "softmax_looped", in_type, acc_type);
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_logsumexp_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& out) {
+  std::string lib_name = kernel_name.substr(kernel_name.find("_") + 1);
+  auto lib = d.get_library(lib_name, [&] {
+    auto t_str = get_type_string(out.dtype());
+    std::string kernel_source;
+    kernel_source = metal::utils();
+    kernel_source += metal::logsumexp();
+    kernel_source +=
+        get_template_definition("block_" + lib_name, "logsumexp", t_str);
+    kernel_source += get_template_definition(
+        "looped_" + lib_name, "logsumexp_looped", t_str);
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_scan_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    bool reverse,
+    bool inclusive,
+    const std::string& reduce_type,
+    const array& in,
+    const array& out) {
+  std::string lib_name = kernel_name.substr(kernel_name.find("_") + 1);
+  auto lib = d.get_library(lib_name, [&]() {
+    auto out_type = get_type_string(out.dtype());
+    std::string op = "Cum" + reduce_type + "<" + out_type + ">";
+    op[3] = toupper(op[3]);
+    std::ostringstream kernel_source;
+    kernel_source << metal::utils() << metal::scan();
+    const std::array<std::pair<std::string, std::string>, 2> scan_kernels = {{
+        {"contig_", "contiguous_scan"},
+        {"strided_", "strided_scan"},
+    }};
+    for (auto& [prefix, kernel] : scan_kernels) {
+      kernel_source << get_template_definition(
+          prefix + lib_name,
+          kernel,
+          get_type_string(in.dtype()),
+          get_type_string(out.dtype()),
+          op,
+          in.itemsize() <= 4 ? 4 : 2,
+          inclusive,
+          reverse);
+    }
+    return kernel_source.str();
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_sort_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& in,
+    const array& out,
+    int bn,
+    int tn) {
+  std::string lib_name = kernel_name.substr(kernel_name.find("_") + 1);
+  auto lib = d.get_library(lib_name, [&]() {
+    std::ostringstream kernel_source;
+    auto in_type = get_type_string(in.dtype());
+    auto out_type = get_type_string(out.dtype());
+    kernel_source << metal::utils() << metal::sort();
+    for (bool is_argsort : {true, false}) {
+      std::string bool_string = is_argsort ? "true" : "false";
+      std::string func_string = is_argsort ? "carg_" : "c_";
+      kernel_source << get_template_definition(
+          func_string + lib_name,
+          "block_sort",
+          in_type,
+          out_type,
+          bool_string,
+          bn,
+          tn);
+      kernel_source << get_template_definition(
+          "n" + func_string + lib_name,
+          "block_sort_nc",
+          in_type,
+          out_type,
+          bool_string,
+          bn,
+          tn);
+    }
+    return kernel_source.str();
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_mb_sort_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& in,
+    const array& idx,
+    int bn,
+    int tn) {
+  std::string lib_name = kernel_name.substr(kernel_name.find("_") + 1);
+  auto lib = d.get_library(lib_name, [&]() {
+    std::ostringstream kernel_source;
+    kernel_source << metal::utils() << metal::sort();
+    std::array<std::pair<std::string, std::string>, 3> kernel_types = {
+        {{"sort_", "mb_block_sort"},
+         {"partition_", "mb_block_partition"},
+         {"merge_", "mb_block_merge"}}};
+    for (auto& [name, func] : kernel_types) {
+      kernel_source << get_template_definition(
+          name + lib_name,
+          func,
+          get_type_string(in.dtype()),
+          get_type_string(idx.dtype()),
+          "true",
+          bn,
+          tn);
+    }
+    return kernel_source.str();
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_reduce_init_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& func_name,
+    const std::string& op_name,
+    const Dtype& out_type) {
+  auto lib = d.get_library(kernel_name, [&]() {
+    std::string op_type = op_name;
+    op_type[0] = std::toupper(op_name[0]);
+    auto out_t = get_type_string(out_type);
+    std::string op = op_type + "<" + out_t + ">";
+    std::string kernel_source = metal::utils();
+    kernel_source += metal::reduce_utils();
+    kernel_source += metal::reduce();
+    kernel_source += get_template_definition(kernel_name, func_name, out_t, op);
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_reduce_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& func_name,
+    const std::string& op_name,
+    const Dtype& in_type,
+    const Dtype& out_type,
+    const std::string& idx_t,
+    int ndim /* = -1 */,
+    int bm /* = -1 */,
+    int bn /* = -1 */) {
+  auto lib = d.get_library(kernel_name, [&]() {
+    std::string op_type = op_name;
+    op_type[0] = std::toupper(op_name[0]);
+    auto in_t = get_type_string(in_type);
+    auto out_t = get_type_string(out_type);
+    std::string op = op_type + "<" + out_t + ">";
+    std::string kernel_source = metal::utils();
+    concatenate(kernel_source, metal::reduce_utils(), metal::reduce());
+    if (bm >= 0) {
+      kernel_source += get_template_definition(
+          kernel_name, func_name, in_t, out_t, op, idx_t, ndim, bm, bn);
+    } else if (ndim >= 0) {
+      kernel_source += get_template_definition(
+          kernel_name, func_name, in_t, out_t, op, idx_t, ndim);
+    } else {
+      kernel_source += get_template_definition(
+          kernel_name, func_name, in_t, out_t, op, idx_t);
+    }
+    return kernel_source;
+  });
+  auto st = d.get_kernel(kernel_name, lib);
+  return st;
+}
+
+MTL::ComputePipelineState* get_steel_gemm_fused_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array& out,
+    bool transpose_a,
+    bool transpose_b,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn) {
+  const auto& lib_name = kernel_name;
+  auto lib = d.get_library(lib_name, [&]() {
+    std::ostringstream kernel_source;
+    kernel_source << metal::utils() << metal::gemm()
+                  << metal::steel_gemm_fused()
+                  << get_template_definition(
+                         lib_name,
+                         "gemm",
+                         get_type_string(out.dtype()),
+                         bm,
+                         bn,
+                         bk,
+                         wm,
+                         wn,
+                         transpose_a,
+                         transpose_b);
+    return kernel_source.str();
+  });
+  return d.get_kernel(kernel_name, lib, hash_name, func_consts);
+}
+
+MTL::ComputePipelineState* get_steel_gemm_splitk_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& in,
+    const array& out,
+    bool transpose_a,
+    bool transpose_b,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn,
+    bool mn_aligned,
+    bool k_aligned) {
+  const auto& lib_name = kernel_name;
+  auto lib = d.get_library(lib_name, [&]() {
+    std::ostringstream kernel_source;
+    kernel_source << metal::utils() << metal::gemm()
+                  << metal::steel_gemm_splitk()
+                  << get_template_definition(
+                         lib_name,
+                         "gemm_splitk",
+                         get_type_string(in.dtype()),
+                         get_type_string(out.dtype()),
+                         bm,
+                         bn,
+                         bk,
+                         wm,
+                         wn,
+                         transpose_a,
+                         transpose_b,
+                         mn_aligned,
+                         k_aligned);
+    return kernel_source.str();
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_steel_gemm_splitk_accum_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& in,
+    const array& out,
+    bool axbpy) {
+  const auto& lib_name = kernel_name;
+  auto lib = d.get_library(lib_name, [&]() {
+    std::ostringstream kernel_source;
+    kernel_source << metal::utils() << metal::gemm()
+                  << metal::steel_gemm_splitk()
+                  << get_template_definition(
+                         lib_name,
+                         axbpy ? "gemm_splitk_accum_axpby"
+                               : "gemm_splitk_accum",
+                         get_type_string(in.dtype()),
+                         get_type_string(out.dtype()));
+    return kernel_source.str();
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_steel_gemm_masked_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& out,
+    const std::optional<array>& mask_out,
+    const std::optional<array>& mask_op,
+    bool transpose_a,
+    bool transpose_b,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn,
+    bool mn_aligned,
+    bool k_aligned) {
+  const auto& lib_name = kernel_name;
+  auto lib = d.get_library(lib_name, [&]() {
+    std::ostringstream kernel_source;
+    auto out_mask_type = mask_out.has_value()
+        ? get_type_string((*mask_out).dtype())
+        : "nomask_t";
+    auto op_mask_type =
+        mask_op.has_value() ? get_type_string((*mask_op).dtype()) : "nomask_t";
+    kernel_source << metal::utils() << metal::gemm()
+                  << metal::steel_gemm_masked()
+                  << get_template_definition(
+                         lib_name,
+                         "block_masked_gemm",
+                         get_type_string(out.dtype()),
+                         out_mask_type,
+                         op_mask_type,
+                         bm,
+                         bn,
+                         bk,
+                         wm,
+                         wn,
+                         transpose_a,
+                         transpose_b,
+                         mn_aligned,
+                         k_aligned);
+    return kernel_source.str();
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_steel_gemm_gather_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array& out,
+    bool transpose_a,
+    bool transpose_b,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn,
+    bool rhs) {
+  const auto& lib_name = kernel_name;
+  auto lib = d.get_library(lib_name, [&]() {
+    std::string kernel_source;
+    concatenate(
+        kernel_source,
+        metal::utils(),
+        metal::gemm(),
+        metal::steel_gemm_gather(),
+        get_template_definition(
+            lib_name,
+            rhs ? "gather_mm_rhs" : "gather_mm",
+            get_type_string(out.dtype()),
+            bm,
+            bn,
+            bk,
+            wm,
+            wn,
+            transpose_a,
+            transpose_b));
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib, hash_name, func_consts);
+}
+
+MTL::ComputePipelineState* get_steel_gemm_segmented_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array& out,
+    bool transpose_a,
+    bool transpose_b,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn) {
+  const auto& lib_name = kernel_name;
+  auto lib = d.get_library(lib_name, [&]() {
+    std::string kernel_source;
+    concatenate(
+        kernel_source,
+        metal::utils(),
+        metal::gemm(),
+        metal::steel_gemm_segmented(),
+        get_template_definition(
+            lib_name,
+            "segmented_mm",
+            get_type_string(out.dtype()),
+            bm,
+            bn,
+            bk,
+            wm,
+            wn,
+            transpose_a,
+            transpose_b));
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib, hash_name, func_consts);
+}
+
+MTL::ComputePipelineState* get_gemv_masked_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& out,
+    const std::optional<array>& mask_out,
+    const std::optional<array>& mask_op,
+    bool transpose_mat,
+    int bm,
+    int bn,
+    int sm,
+    int sn,
+    int tm,
+    int tn,
+    bool contiguous) {
+  const auto& lib_name = kernel_name;
+  auto lib = d.get_library(lib_name, [&]() {
+    std::ostringstream kernel_source;
+    auto out_mask_type = mask_out.has_value()
+        ? get_type_string((*mask_out).dtype())
+        : "nomask_t";
+    auto op_mask_type =
+        mask_op.has_value() ? get_type_string((*mask_op).dtype()) : "nomask_t";
+    kernel_source << metal::utils() << metal::gemv_masked()
+                  << get_template_definition(
+                         lib_name,
+                         (transpose_mat) ? "gemv_t_masked" : "gemv_masked",
+                         get_type_string(out.dtype()),
+                         out_mask_type,
+                         op_mask_type,
+                         bm,
+                         bn,
+                         sm,
+                         sn,
+                         tm,
+                         tn,
+                         contiguous ? 0 : 1);
+    return kernel_source.str();
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_steel_conv_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& out,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn,
+    int n_channel_specialization,
+    bool small_filter) {
+  const auto& lib_name = kernel_name;
+  auto lib = d.get_library(lib_name, [&]() {
+    std::ostringstream kernel_source;
+    kernel_source << metal::utils() << metal::conv() << metal::steel_conv()
+                  << get_template_definition(
+                         lib_name,
+                         "implicit_gemm_conv_2d",
+                         get_type_string(out.dtype()),
+                         bm,
+                         bn,
+                         bk,
+                         wm,
+                         wn,
+                         n_channel_specialization,
+                         small_filter);
+    return kernel_source.str();
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_steel_conv_general_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array& out,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn) {
+  const auto& lib_name = kernel_name;
+  auto lib = d.get_library(lib_name, [&]() {
+    std::ostringstream kernel_source;
+    kernel_source << metal::utils() << metal::conv()
+                  << metal::steel_conv_general()
+                  << get_template_definition(
+                         lib_name,
+                         "implicit_gemm_conv_2d_general",
+                         get_type_string(out.dtype()),
+                         bm,
+                         bn,
+                         bk,
+                         wm,
+                         wn);
+    return kernel_source.str();
+  });
+  return d.get_kernel(kernel_name, lib, hash_name, func_consts);
+}
+
+MTL::ComputePipelineState* get_fft_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const std::string& template_def) {
+  const auto& lib_name = kernel_name;
+  auto lib = d.get_library(lib_name, [&]() {
+    std::ostringstream kernel_source;
+    std::string kernel_string;
+    kernel_source << metal::fft() << template_def;
+    return kernel_source.str();
+  });
+  return d.get_kernel(kernel_name, lib, hash_name, func_consts);
+}
+
+MTL::ComputePipelineState* get_quantized_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& template_def,
+    const std::string& mode) {
+  const auto& lib_name = kernel_name;
+  auto lib = d.get_library(lib_name, [&]() {
+    std::string kernel_source;
+    concatenate(
+        kernel_source,
+        metal::utils(),
+        metal::gemm(),
+        metal::quantized_utils(),
+        (mode == "affine") ? metal::quantized() : metal::fp4_quantized(),
+        template_def);
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib);
+}
+
+MTL::ComputePipelineState* get_gather_qmm_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array& x,
+    int group_size,
+    int bits,
+    const std::string& mode,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn,
+    bool transpose) {
+  const auto& lib_name = kernel_name;
+  auto lib = d.get_library(lib_name, [&]() {
+    std::string kernel_source;
+    concatenate(
+        kernel_source, metal::utils(), metal::quantized_utils(), metal::gemm());
+    if (mode == "affine") {
+      concatenate(
+          kernel_source,
+          metal::quantized(),
+          get_template_definition(
+              lib_name,
+              mode + "_gather_qmm_rhs",
+              get_type_string(x.dtype()),
+              group_size,
+              bits,
+              bm,
+              bn,
+              bk,
+              wm,
+              wn,
+              transpose));
+    } else {
+      concatenate(
+          kernel_source,
+          metal::fp4_quantized(),
+          get_template_definition(
+              lib_name,
+              mode + "_gather_qmm_rhs",
+              get_type_string(x.dtype()),
+              group_size,
+              "uint8_t",
+              bm,
+              bn,
+              bk,
+              wm,
+              wn,
+              transpose));
+    }
+    return kernel_source;
+  });
+  return d.get_kernel(kernel_name, lib, hash_name, func_consts);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels.h
new file mode 100644
index 0000000000000000000000000000000000000000..0656f3c0fa972f5e45d32a5819ebd6ffeeb8aa45
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels.h
@@ -0,0 +1,284 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include <fmt/format.h>
+
+#include "mlx/array.h"
+#include "mlx/backend/metal/device.h"
+
+namespace mlx::core {
+
+MTL::ComputePipelineState* get_arange_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& out);
+
+MTL::ComputePipelineState* get_unary_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    Dtype in_type,
+    Dtype out_type,
+    const char* op);
+
+MTL::ComputePipelineState* get_binary_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    Dtype in_type,
+    Dtype out_type,
+    const char* op);
+
+MTL::ComputePipelineState* get_binary_two_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    Dtype in_type,
+    Dtype out_type,
+    const char* op);
+
+MTL::ComputePipelineState* get_ternary_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    Dtype type,
+    const char* op);
+
+MTL::ComputePipelineState* get_copy_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& in,
+    const array& out);
+
+MTL::ComputePipelineState* get_dynamic_copy_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& in,
+    const array& out);
+
+MTL::ComputePipelineState* get_softmax_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    bool precise,
+    const array& out);
+
+MTL::ComputePipelineState* get_logsumexp_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& out);
+
+MTL::ComputePipelineState* get_scan_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    bool reverse,
+    bool inclusive,
+    const std::string& reduce_type,
+    const array& in,
+    const array& out);
+
+MTL::ComputePipelineState* get_sort_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& in,
+    const array& out,
+    int bn,
+    int tn);
+
+MTL::ComputePipelineState* get_mb_sort_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& in,
+    const array& idx,
+    int bn,
+    int tn);
+
+MTL::ComputePipelineState* get_reduce_init_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& func_name,
+    const std::string& op_name,
+    const Dtype& out_type);
+
+MTL::ComputePipelineState* get_reduce_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& func_name,
+    const std::string& op_name,
+    const Dtype& in_type,
+    const Dtype& out_type,
+    const std::string& idx_t,
+    int ndim = -1,
+    int bm = -1,
+    int bn = -1);
+
+MTL::ComputePipelineState* get_steel_gemm_fused_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array& out,
+    bool transpose_a,
+    bool transpose_b,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn);
+
+MTL::ComputePipelineState* get_steel_gemm_splitk_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& in,
+    const array& out,
+    bool transpose_a,
+    bool transpose_b,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn,
+    bool mn_aligned,
+    bool k_aligned);
+
+MTL::ComputePipelineState* get_steel_gemm_splitk_accum_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& in,
+    const array& out,
+    bool axbpy);
+
+MTL::ComputePipelineState* get_steel_gemm_masked_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& out,
+    const std::optional<array>& mask_out,
+    const std::optional<array>& mask_op,
+    bool transpose_a,
+    bool transpose_b,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn,
+    bool mn_aligned,
+    bool k_aligned);
+
+MTL::ComputePipelineState* get_steel_gemm_gather_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array& out,
+    bool transpose_a,
+    bool transpose_b,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn,
+    bool rhs);
+
+MTL::ComputePipelineState* get_steel_gemm_segmented_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array& out,
+    bool transpose_a,
+    bool transpose_b,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn);
+
+MTL::ComputePipelineState* get_steel_conv_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& out,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn,
+    int n_channel_specialization,
+    bool small_filter);
+
+MTL::ComputePipelineState* get_gemv_masked_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array& out,
+    const std::optional<array>& mask_out,
+    const std::optional<array>& mask_op,
+    bool transpose_mat,
+    int bm,
+    int bn,
+    int sm,
+    int sn,
+    int tm,
+    int tn,
+    bool contiguous);
+
+MTL::ComputePipelineState* get_steel_conv_general_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array& out,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn);
+
+MTL::ComputePipelineState* get_fft_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const std::string& template_def);
+
+MTL::ComputePipelineState* get_quantized_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& template_def,
+    const std::string& mode);
+
+MTL::ComputePipelineState* get_gather_qmm_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array& x,
+    int group_size,
+    int bits,
+    const std::string& mode,
+    int bm,
+    int bn,
+    int bk,
+    int wm,
+    int wn,
+    bool transpose);
+
+// Create a GPU kernel template definition for JIT compilation
+template <typename... Args>
+std::string get_template_definition(
+    std::string_view name,
+    std::string_view func,
+    Args... args) {
+  std::ostringstream s;
+  s << func << "<";
+  bool first = true;
+  auto add_arg = [&s, &first](const auto& arg) {
+    if (!first) {
+      s << ", ";
+    }
+    first = false;
+    s << arg;
+  };
+  (add_arg(args), ...);
+  s << ">";
+  return fmt::format(
+      "\ntemplate [[host_name(\"{0}\")]] [[kernel]] decltype({1}) {1};\n",
+      name,
+      s.str());
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..70faa1d24320fe2786b51ee7198bbe455c38e6a6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/CMakeLists.txt
@@ -0,0 +1,147 @@
+set(BASE_HEADERS
+    metal_3_1/bf16.h
+    metal_3_0/bf16.h
+    bf16_math.h
+    complex.h
+    defines.h
+    erf.h
+    expm1f.h
+    utils.h)
+
+function(build_kernel_base TARGET SRCFILE DEPS)
+  set(METAL_FLAGS -Wall -Wextra -fno-fast-math -Wno-c++17-extensions)
+  if(MLX_METAL_DEBUG)
+    set(METAL_FLAGS ${METAL_FLAGS} -gline-tables-only -frecord-sources)
+  endif()
+  if(NOT CMAKE_OSX_DEPLOYMENT_TARGET STREQUAL "")
+    set(METAL_FLAGS ${METAL_FLAGS}
+                    "-mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
+  endif()
+  if(MLX_METAL_VERSION GREATER_EQUAL 310)
+    set(VERSION_INCLUDES
+        ${PROJECT_SOURCE_DIR}/mlx/backend/metal/kernels/metal_3_1)
+  else()
+    set(VERSION_INCLUDES
+        ${PROJECT_SOURCE_DIR}/mlx/backend/metal/kernels/metal_3_0)
+  endif()
+  add_custom_command(
+    COMMAND xcrun -sdk macosx metal ${METAL_FLAGS} -c ${SRCFILE}
+            -I${PROJECT_SOURCE_DIR} -I${VERSION_INCLUDES} -o ${TARGET}.air
+    DEPENDS ${SRCFILE} ${DEPS} ${BASE_HEADERS}
+    OUTPUT ${TARGET}.air
+    COMMENT "Building ${TARGET}.air"
+    VERBATIM)
+endfunction(build_kernel_base)
+
+function(build_kernel KERNEL)
+  set(SRCFILE ${CMAKE_CURRENT_SOURCE_DIR}/${KERNEL}.metal)
+  cmake_path(GET KERNEL STEM TARGET)
+  build_kernel_base(${TARGET} ${SRCFILE} "${ARGN}")
+  set(KERNEL_AIR
+      ${TARGET}.air ${KERNEL_AIR}
+      PARENT_SCOPE)
+endfunction(build_kernel)
+
+build_kernel(arg_reduce)
+build_kernel(conv steel/conv/params.h)
+build_kernel(gemv steel/utils.h)
+build_kernel(layer_norm)
+build_kernel(random)
+build_kernel(rms_norm)
+build_kernel(rope)
+build_kernel(scaled_dot_product_attention sdpa_vector.h)
+if(MLX_METAL_VERSION GREATER_EQUAL 320)
+  build_kernel(fence)
+endif()
+
+set(STEEL_HEADERS
+    steel/defines.h
+    steel/utils.h
+    steel/conv/conv.h
+    steel/conv/loader.h
+    steel/conv/loaders/loader_channel_l.h
+    steel/conv/loaders/loader_channel_n.h
+    steel/conv/loaders/loader_general.h
+    steel/conv/kernels/steel_conv.h
+    steel/conv/kernels/steel_conv_general.h
+    steel/gemm/gemm.h
+    steel/gemm/mma.h
+    steel/gemm/loader.h
+    steel/gemm/transforms.h
+    steel/gemm/kernels/steel_gemm_fused.h
+    steel/gemm/kernels/steel_gemm_gather.h
+    steel/gemm/kernels/steel_gemm_masked.h
+    steel/gemm/kernels/steel_gemm_segmented.h
+    steel/gemm/kernels/steel_gemm_splitk.h
+    steel/utils/type_traits.h
+    steel/utils/integral_constant.h)
+
+set(STEEL_ATTN_HEADERS
+    steel/defines.h
+    steel/utils.h
+    steel/gemm/gemm.h
+    steel/gemm/mma.h
+    steel/gemm/loader.h
+    steel/gemm/transforms.h
+    steel/utils/type_traits.h
+    steel/utils/integral_constant.h
+    steel/attn/attn.h
+    steel/attn/loader.h
+    steel/attn/mma.h
+    steel/attn/params.h
+    steel/attn/transforms.h
+    steel/attn/kernels/steel_attention.h)
+
+build_kernel(steel/attn/kernels/steel_attention ${STEEL_ATTN_HEADERS})
+
+if(NOT MLX_METAL_JIT)
+  build_kernel(arange arange.h)
+  build_kernel(binary binary.h binary_ops.h)
+  build_kernel(binary_two binary_two.h)
+  build_kernel(copy copy.h)
+  build_kernel(fft fft.h fft/radix.h fft/readwrite.h)
+  build_kernel(
+    reduce
+    atomic.h
+    reduction/ops.h
+    reduction/reduce_init.h
+    reduction/reduce_all.h
+    reduction/reduce_col.h
+    reduction/reduce_row.h)
+  build_kernel(quantized quantized.h quantized_utils.h ${STEEL_HEADERS})
+  build_kernel(fp4_quantized fp4_quantized.h quantized_utils.h ${STEEL_HEADERS})
+  build_kernel(scan scan.h)
+  build_kernel(softmax softmax.h)
+  build_kernel(logsumexp logsumexp.h)
+  build_kernel(sort sort.h)
+  build_kernel(ternary ternary.h ternary_ops.h)
+  build_kernel(unary unary.h unary_ops.h)
+  build_kernel(steel/conv/kernels/steel_conv ${STEEL_HEADERS})
+  build_kernel(steel/conv/kernels/steel_conv_general ${STEEL_HEADERS})
+  build_kernel(steel/gemm/kernels/steel_gemm_fused ${STEEL_HEADERS})
+  build_kernel(steel/gemm/kernels/steel_gemm_gather ${STEEL_HEADERS})
+  build_kernel(steel/gemm/kernels/steel_gemm_masked ${STEEL_HEADERS})
+  build_kernel(steel/gemm/kernels/steel_gemm_splitk ${STEEL_HEADERS})
+  build_kernel(steel/gemm/kernels/steel_gemm_segmented ${STEEL_HEADERS})
+  build_kernel(gemv_masked steel/utils.h)
+endif()
+
+add_custom_command(
+  OUTPUT ${MLX_METAL_PATH}/mlx.metallib
+  COMMAND xcrun -sdk macosx metallib ${KERNEL_AIR} -o
+          ${MLX_METAL_PATH}/mlx.metallib
+  DEPENDS ${KERNEL_AIR}
+  COMMENT "Building mlx.metallib"
+  VERBATIM)
+
+add_custom_target(mlx-metallib DEPENDS ${MLX_METAL_PATH}/mlx.metallib)
+
+add_dependencies(mlx mlx-metallib)
+
+# Install metallib
+include(GNUInstallDirs)
+
+install(
+  FILES ${MLX_METAL_PATH}/mlx.metallib
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  COMPONENT metallib)
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/arange.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/arange.h
new file mode 100644
index 0000000000000000000000000000000000000000..5448fe9aa773369303d330c027a0f02553e368be
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/arange.h
@@ -0,0 +1,9 @@
+// Copyright © 2023-2024 Apple Inc.
+template <typename T>
+[[kernel]] void arange(
+    constant const T& start,
+    constant const T& step,
+    device T* out,
+    uint index [[thread_position_in_grid]]) {
+  out[index] = start + index * step;
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/arange.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/arange.metal
new file mode 100644
index 0000000000000000000000000000000000000000..fb56c1c5fc7e73ba9fb9de60a961c99a1f360c17
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/arange.metal
@@ -0,0 +1,20 @@
+// Copyright © 2023-2024 Apple Inc.
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/arange.h"
+
+#define instantiate_arange(tname, type)                                 \
+  instantiate_kernel("arange" #tname, arange, type)
+
+instantiate_arange(uint8, uint8_t)
+instantiate_arange(uint16, uint16_t)
+instantiate_arange(uint32, uint32_t)
+instantiate_arange(uint64, uint64_t)
+instantiate_arange(int8, int8_t)
+instantiate_arange(int16, int16_t)
+instantiate_arange(int32, int32_t)
+instantiate_arange(int64, int64_t)
+instantiate_arange(float16, half)
+instantiate_arange(float32, float)
+instantiate_arange(bfloat16, bfloat16_t) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/arg_reduce.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/arg_reduce.metal
new file mode 100644
index 0000000000000000000000000000000000000000..4a83d8e57e4a242cbd8ba3ec6cd2ee332a84f10a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/arg_reduce.metal
@@ -0,0 +1,182 @@
+// Copyright © 2023 Apple Inc.
+
+#include <metal_simdgroup>
+
+#include "mlx/backend/metal/kernels/utils.h"
+
+using namespace metal;
+
+template <typename U>
+struct IndexValPair {
+  uint32_t index;
+  U val;
+};
+
+template <typename U>
+struct ArgMin {
+  static constexpr constant U init = Limits<U>::max;
+
+  IndexValPair<U> reduce(IndexValPair<U> best, IndexValPair<U> current) {
+    if (best.val > current.val ||
+        (best.val == current.val && best.index > current.index)) {
+      return current;
+    } else {
+      return best;
+    }
+  }
+
+  template <int N>
+  IndexValPair<U>
+  reduce_many(IndexValPair<U> best, thread U* vals, uint32_t offset) {
+    for (int i = 0; i < N; i++) {
+      if (vals[i] < best.val) {
+        best.val = vals[i];
+        best.index = offset + i;
+      }
+    }
+    return best;
+  }
+};
+
+template <typename U>
+struct ArgMax {
+  static constexpr constant U init = Limits<U>::min;
+
+  IndexValPair<U> reduce(IndexValPair<U> best, IndexValPair<U> current) {
+    if (best.val < current.val ||
+        (best.val == current.val && best.index > current.index)) {
+      return current;
+    } else {
+      return best;
+    }
+  }
+
+  template <int N>
+  IndexValPair<U>
+  reduce_many(IndexValPair<U> best, thread U* vals, uint32_t offset) {
+    for (int i = 0; i < N; i++) {
+      if (vals[i] > best.val) {
+        best.val = vals[i];
+        best.index = offset + i;
+      }
+    }
+    return best;
+  }
+};
+
+template <typename U>
+IndexValPair<U> simd_shuffle_down(IndexValPair<U> data, uint16_t delta) {
+  return IndexValPair<U>{
+      simd_shuffle_down(data.index, delta), simd_shuffle_down(data.val, delta)};
+}
+
+template <typename T, typename Op, int N_READS = 4>
+[[kernel]] void arg_reduce_general(
+    const device T* in [[buffer(0)]],
+    device uint32_t* out [[buffer(1)]],
+    const constant int* shape [[buffer(2)]],
+    const constant int64_t* in_strides [[buffer(3)]],
+    const constant int64_t* out_strides [[buffer(4)]],
+    const constant size_t& ndim [[buffer(5)]],
+    const constant int64_t& axis_stride [[buffer(6)]],
+    const constant size_t& axis_size [[buffer(7)]],
+    uint3 gid [[thread_position_in_grid]],
+    uint3 gsize [[threads_per_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint3 lsize [[threads_per_threadgroup]],
+    uint simd_size [[threads_per_simdgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  // Shapes and strides *do not* contain the reduction axis. The reduction size
+  // and stride are provided in axis_stride and axis_size.
+  //
+  // Note: in shape == out shape with this convention.
+  //
+  // The sketch of the kernel is as follows.
+  //    1. Launch prod(shape) * thread_group_size threads.
+  //    2. Loop ceildiv(axis_size / lsize) times
+  //    3. Read input values
+  //    4. Reduce among them and go to 3
+  //    4. Reduce in each simd_group
+  //    6. Write in the thread local memory
+  //    6. Reduce them across thread group
+  //    7. Write the output without need for atomic
+  Op op;
+
+  // Compute the input/output index. There is one beginning and one output for
+  // the whole threadgroup.
+  int64_t row_idx = gid.y + static_cast<int64_t>(gsize.y) * gid.z;
+  auto in_idx = elem_to_loc(row_idx, shape, in_strides, ndim);
+  auto out_idx = elem_to_loc(row_idx, shape, out_strides, ndim);
+
+  IndexValPair<T> best{0, Op::init};
+
+  threadgroup IndexValPair<T> local_data[32];
+
+  // Loop over the reduction axis in lsize*N_READS buckets
+  for (uint r = 0; r < ceildiv(axis_size, N_READS * lsize.x); r++) {
+    // Read the current value
+    uint32_t current_index = r * lsize.x * N_READS + lid.x * N_READS;
+    uint32_t offset = current_index;
+    const device T* current_in = in + in_idx + current_index * axis_stride;
+    T vals[N_READS];
+    for (int i = 0; i < N_READS; i++) {
+      vals[i] = (current_index < axis_size) ? *current_in : T(Op::init);
+      current_index++;
+      current_in += axis_stride;
+    }
+    best = op.template reduce_many<N_READS>(best, vals, offset);
+  }
+  // At this point we have reduced the axis into thread group best values so we
+  // need to reduce across the thread group.
+
+  // First per simd reduction.
+  for (uint offset = simd_size / 2; offset > 0; offset /= 2) {
+    IndexValPair<T> neighbor = simd_shuffle_down(best, offset);
+    best = op.reduce(best, neighbor);
+  }
+
+  // Write to the threadgroup memory
+  if (simd_lane_id == 0) {
+    local_data[simd_group_id] = best;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (simd_group_id != 0) {
+    return;
+  }
+
+  // Read the appropriate value from local data and perform one simd reduction
+  uint simd_groups = ceildiv(lsize.x, simd_size);
+  if (simd_lane_id < simd_groups) {
+    best = local_data[simd_lane_id];
+  }
+  for (uint offset = simd_size / 2; offset > 0; offset /= 2) {
+    IndexValPair<T> neighbor = simd_shuffle_down(best, offset);
+    best = op.reduce(best, neighbor);
+  }
+
+  // Finally write the output
+  if (lid.x == 0) {
+    out[out_idx] = best.index;
+  }
+}
+
+// clang-format off
+#define instantiate_arg_reduce(name, itype)                      \
+  instantiate_kernel(                                            \
+      "argmin_" #name, arg_reduce_general, itype, ArgMin<itype>) \
+  instantiate_kernel(                                            \
+      "argmax_" #name, arg_reduce_general, itype, ArgMax<itype>)
+
+instantiate_arg_reduce(bool_, bool)
+instantiate_arg_reduce(uint8, uint8_t)
+instantiate_arg_reduce(uint16, uint16_t)
+instantiate_arg_reduce(uint32, uint32_t)
+instantiate_arg_reduce(uint64, uint64_t)
+instantiate_arg_reduce(int8, int8_t)
+instantiate_arg_reduce(int16, int16_t)
+instantiate_arg_reduce(int32, int32_t)
+instantiate_arg_reduce(int64, int64_t)
+instantiate_arg_reduce(float16, half)
+instantiate_arg_reduce(float32, float)
+instantiate_arg_reduce(bfloat16, bfloat16_t) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/atomic.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/atomic.h
new file mode 100644
index 0000000000000000000000000000000000000000..93952c2cf2d06dc4d757241c56b378ce5b11b12f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/atomic.h
@@ -0,0 +1,345 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <metal_atomic>
+#include <metal_stdlib>
+
+using namespace metal;
+
+///////////////////////////////////////////////////////////////////////////////
+// Atomic utils
+///////////////////////////////////////////////////////////////////////////////
+
+#pragma METAL internals : enable
+template <typename T>
+constexpr constant bool is_metal_atomic = _disjunction<
+    is_same<T, int>,
+    is_same<T, uint>,
+    is_same<T, ulong>,
+    is_same<T, float>>::value;
+
+#pragma METAL internals : disable
+
+template <typename T, typename = void>
+struct mlx_atomic {
+  atomic<uint> val;
+};
+
+template <typename T>
+struct mlx_atomic<T, enable_if_t<is_metal_atomic<T>>> {
+  atomic<T> val;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Native metal atomics
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC T
+mlx_atomic_load_explicit(device mlx_atomic<T>* object, size_t offset) {
+  return atomic_load_explicit(&(object[offset].val), memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_store_explicit(device mlx_atomic<T>* object, T val, size_t offset) {
+  atomic_store_explicit(&(object[offset].val), val, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void mlx_atomic_fetch_and_explicit(
+    device mlx_atomic<T>* object,
+    T val,
+    size_t offset) {
+  atomic_fetch_and_explicit(&(object[offset].val), val, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void mlx_atomic_fetch_or_explicit(
+    device mlx_atomic<T>* object,
+    T val,
+    size_t offset) {
+  atomic_fetch_or_explicit(&(object[offset].val), val, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void mlx_atomic_fetch_min_explicit(
+    device mlx_atomic<T>* object,
+    T val,
+    size_t offset) {
+  atomic_fetch_min_explicit(&(object[offset].val), val, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void mlx_atomic_fetch_max_explicit(
+    device mlx_atomic<T>* object,
+    T val,
+    size_t offset) {
+  atomic_fetch_max_explicit(&(object[offset].val), val, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void mlx_atomic_fetch_add_explicit(
+    device mlx_atomic<T>* object,
+    T val,
+    size_t offset) {
+  atomic_fetch_add_explicit(&(object[offset].val), val, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC void mlx_atomic_fetch_mul_explicit(
+    device mlx_atomic<T>* object,
+    T val,
+    size_t offset) {
+  T expected = mlx_atomic_load_explicit(object, offset);
+  while (!mlx_atomic_compare_exchange_weak_explicit(
+      object, &expected, val * expected, offset)) {
+  }
+}
+
+template <typename T, enable_if_t<is_metal_atomic<T>, bool> = true>
+METAL_FUNC bool mlx_atomic_compare_exchange_weak_explicit(
+    device mlx_atomic<T>* object,
+    thread T* expected,
+    T val,
+    size_t offset) {
+  return atomic_compare_exchange_weak_explicit(
+      &(object[offset].val),
+      expected,
+      val,
+      memory_order_relaxed,
+      memory_order_relaxed);
+}
+
+// Specialization for float since it does not atomic_fetch_min_explicit
+template <>
+METAL_FUNC void mlx_atomic_fetch_min_explicit<float>(
+    device mlx_atomic<float>* object,
+    float val,
+    size_t offset) {
+  float expected = mlx_atomic_load_explicit(object, offset);
+  while (val < expected) {
+    if (mlx_atomic_compare_exchange_weak_explicit(
+            object, &expected, val, offset)) {
+      return;
+    }
+  }
+}
+
+// Specialization for float since it does not atomic_fetch_max_explicit
+template <>
+METAL_FUNC void mlx_atomic_fetch_max_explicit<float>(
+    device mlx_atomic<float>* object,
+    float val,
+    size_t offset) {
+  float expected = mlx_atomic_load_explicit(object, offset);
+  while (val > expected) {
+    if (mlx_atomic_compare_exchange_weak_explicit(
+            object, &expected, val, offset)) {
+      return;
+    }
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Custom atomics
+///////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
+template <typename T>
+constexpr constant uint packing_size = sizeof(uint) / sizeof(T);
+
+template <typename T>
+union uint_or_packed {
+  T val[packing_size<T>];
+  uint bits;
+};
+
+template <typename T, typename Op>
+struct mlx_atomic_update_helper {
+  uint operator()(uint_or_packed<T> init, T update, size_t elem_offset) {
+    Op op;
+    init.val[elem_offset] = op(update, init.val[elem_offset]);
+    return init.bits;
+  }
+};
+
+template <typename T, typename Op>
+METAL_FUNC void mlx_atomic_update_and_store(
+    device mlx_atomic<T>* object,
+    T update,
+    size_t offset) {
+  size_t pack_offset = offset / packing_size<T>;
+  size_t elem_offset = offset % packing_size<T>;
+
+  mlx_atomic_update_helper<T, Op> helper;
+  uint_or_packed<T> expected;
+  expected.bits =
+      atomic_load_explicit(&(object[pack_offset].val), memory_order_relaxed);
+
+  while (Op::condition(update, expected.val[elem_offset]) &&
+         !mlx_atomic_compare_exchange_weak_explicit(
+             object,
+             &(expected.bits),
+             helper(expected, update, elem_offset),
+             pack_offset)) {
+  }
+}
+
+template <typename T>
+struct __None {
+  static bool condition(T a, T b) {
+#pragma unused(a)
+#pragma unused(b)
+    return true;
+  }
+
+  T operator()(T a, T b) {
+#pragma unused(b)
+    return a;
+  }
+};
+
+template <typename T>
+struct __Add {
+  static bool condition(T a, T b) {
+#pragma unused(a)
+#pragma unused(b)
+    return true;
+  }
+
+  T operator()(T a, T b) {
+    return a + b;
+  }
+};
+
+template <typename T>
+struct __Mul {
+  static bool condition(T a, T b) {
+#pragma unused(a)
+    return b != 0;
+  }
+
+  T operator()(T a, T b) {
+    return a * b;
+  }
+};
+
+template <typename T>
+struct __Max {
+  static bool condition(T a, T b) {
+    return a > b;
+  }
+
+  T operator()(T a, T b) {
+    return max(a, b);
+  }
+};
+
+template <typename T>
+struct __Min {
+  static bool condition(T a, T b) {
+    return a < b;
+  }
+
+  T operator()(T a, T b) {
+    return min(a, b);
+  }
+};
+
+} // namespace
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC T
+mlx_atomic_load_explicit(device mlx_atomic<T>* object, size_t offset) {
+  size_t pack_offset = offset / sizeof(T);
+  size_t elem_offset = offset % sizeof(T);
+  uint_or_packed<T> packed_val;
+  packed_val.bits =
+      atomic_load_explicit(&(object[pack_offset].val), memory_order_relaxed);
+  return packed_val.val[elem_offset];
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void
+mlx_atomic_store_explicit(device mlx_atomic<T>* object, T val, size_t offset) {
+  mlx_atomic_update_and_store<T, __None<T>>(object, val, offset);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void mlx_atomic_fetch_and_explicit(
+    device mlx_atomic<T>* object,
+    T val,
+    size_t offset) {
+  size_t pack_offset = offset / packing_size<T>;
+  size_t elem_offset = offset % packing_size<T>;
+  uint_or_packed<T> identity;
+  identity.bits = __UINT32_MAX__;
+  identity.val[elem_offset] = val;
+
+  atomic_fetch_and_explicit(
+      &(object[pack_offset].val), identity.bits, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void mlx_atomic_fetch_or_explicit(
+    device mlx_atomic<T>* object,
+    T val,
+    size_t offset) {
+  size_t pack_offset = offset / packing_size<T>;
+  size_t elem_offset = offset % packing_size<T>;
+  uint_or_packed<T> identity;
+  identity.bits = 0;
+  identity.val[elem_offset] = val;
+
+  atomic_fetch_or_explicit(
+      &(object[pack_offset].val), identity.bits, memory_order_relaxed);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void mlx_atomic_fetch_min_explicit(
+    device mlx_atomic<T>* object,
+    T val,
+    size_t offset) {
+  mlx_atomic_update_and_store<T, __Min<T>>(object, val, offset);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void mlx_atomic_fetch_max_explicit(
+    device mlx_atomic<T>* object,
+    T val,
+    size_t offset) {
+  mlx_atomic_update_and_store<T, __Max<T>>(object, val, offset);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void mlx_atomic_fetch_add_explicit(
+    device mlx_atomic<T>* object,
+    T val,
+    size_t offset) {
+  mlx_atomic_update_and_store<T, __Add<T>>(object, val, offset);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC void mlx_atomic_fetch_mul_explicit(
+    device mlx_atomic<T>* object,
+    T val,
+    size_t offset) {
+  mlx_atomic_update_and_store<T, __Mul<T>>(object, val, offset);
+}
+
+template <typename T, enable_if_t<!is_metal_atomic<T>, bool> = true>
+METAL_FUNC bool mlx_atomic_compare_exchange_weak_explicit(
+    device mlx_atomic<T>* object,
+    thread uint* expected,
+    uint val,
+    size_t offset) {
+  return atomic_compare_exchange_weak_explicit(
+      &(object[offset].val),
+      expected,
+      val,
+      memory_order_relaxed,
+      memory_order_relaxed);
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/bf16_math.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/bf16_math.h
new file mode 100644
index 0000000000000000000000000000000000000000..0643fb3eadd71cd9fbb1e83f68ca277acf36508c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/bf16_math.h
@@ -0,0 +1,380 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+///////////////////////////////////////////////////////////////////////////////
+// Metal math for bfloat16
+///////////////////////////////////////////////////////////////////////////////
+
+/*
+
+Following the Metal Shading Language Specification (Metal 3.1)
+
+"bfloat is an extended itypeing point type that only allows implicit conversion
+ to a type of greater itypeing point rank. While bfloat can be implicitly
+ converted to itype, it cannot be implicitly converted to half, and neither
+ itype nor half can be implicitly converted to bfloat."
+
+Further, as far as I can tell, the stdlib math/simd functions are not defined
+for bfloat and calling with an argument of type bfloat will result in that
+argument getting implicitly converted to itype which then returns an output
+that is (likely) a itype which cannot be implicitly converted into a bfloat
+
+This leads to situations where
+bfloat a = 5.0bf;
+bfloat b = metal::abs(a); // this will throw an error since abs return itype
+bfloat c = static_cast<bfloat>(metal::abs(a)); // this is fine
+
+For the moment, I will be adding overloaded instantiations of the math
+functions to accordingly automatically handle the casting
+
+*/
+
+#define instantiate_metal_math_funcs(itype, otype, ctype, mfast)               \
+                                                                               \
+  METAL_FUNC otype abs(itype x) {                                              \
+    return static_cast<otype>(__metal_fabs(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype acos(itype x) {                                             \
+    return static_cast<otype>(__metal_acos(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype acosh(itype x) {                                            \
+    return static_cast<otype>(__metal_acosh(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype asin(itype x) {                                             \
+    return static_cast<otype>(__metal_asin(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype asinh(itype x) {                                            \
+    return static_cast<otype>(__metal_asinh(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype atan(itype y_over_x) {                                      \
+    return static_cast<otype>(                                                 \
+        __metal_atan(static_cast<ctype>(y_over_x), mfast));                    \
+  }                                                                            \
+  METAL_FUNC otype atan2(itype y, itype x) {                                   \
+    return static_cast<otype>(                                                 \
+        __metal_atan2(static_cast<ctype>(y), static_cast<ctype>(x), mfast));   \
+  }                                                                            \
+  METAL_FUNC otype atanh(itype x) {                                            \
+    return static_cast<otype>(__metal_atanh(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype ceil(itype x) {                                             \
+    return static_cast<otype>(__metal_ceil(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype cos(itype x) {                                              \
+    return static_cast<otype>(__metal_cos(static_cast<ctype>(x), mfast));      \
+  }                                                                            \
+  METAL_FUNC otype cosh(itype x) {                                             \
+    return static_cast<otype>(__metal_cosh(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype cospi(itype x) {                                            \
+    return static_cast<otype>(__metal_cospi(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype divide(itype x, itype y) {                                  \
+    return static_cast<otype>(                                                 \
+        __metal_divide(static_cast<ctype>(x), static_cast<ctype>(y), mfast));  \
+  }                                                                            \
+  METAL_FUNC otype exp(itype x) {                                              \
+    return static_cast<otype>(__metal_exp(static_cast<ctype>(x), mfast));      \
+  }                                                                            \
+  METAL_FUNC otype exp10(itype x) {                                            \
+    return static_cast<otype>(__metal_exp10(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype exp2(itype x) {                                             \
+    return static_cast<otype>(__metal_exp2(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype fabs(itype x) {                                             \
+    return static_cast<otype>(__metal_fabs(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype fdim(itype x, itype y) {                                    \
+    ctype t = static_cast<ctype>(x - y);                                       \
+    return static_cast<otype>(select(t, ctype(0), t < ctype(0) || x == y));    \
+  }                                                                            \
+  METAL_FUNC otype floor(itype x) {                                            \
+    return static_cast<otype>(__metal_floor(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype fma(itype x, itype y, itype z) {                            \
+    return static_cast<otype>(__metal_fma(                                     \
+        static_cast<ctype>(x), static_cast<ctype>(y), static_cast<ctype>(z))); \
+  }                                                                            \
+  METAL_FUNC otype fmax(itype x, itype y) {                                    \
+    return static_cast<otype>(                                                 \
+        __metal_fmax(static_cast<ctype>(x), static_cast<ctype>(y), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype fmax3(itype x, itype y, itype z) {                          \
+    return static_cast<otype>(__metal_fmax3(                                   \
+        static_cast<ctype>(x),                                                 \
+        static_cast<ctype>(y),                                                 \
+        static_cast<ctype>(z),                                                 \
+        mfast));                                                               \
+  }                                                                            \
+  METAL_FUNC otype fmedian3(itype x, itype y, itype z) {                       \
+    return static_cast<otype>(__metal_fmedian3(                                \
+        static_cast<ctype>(x),                                                 \
+        static_cast<ctype>(y),                                                 \
+        static_cast<ctype>(z),                                                 \
+        mfast));                                                               \
+  }                                                                            \
+  METAL_FUNC otype fmin(itype x, itype y) {                                    \
+    return static_cast<otype>(                                                 \
+        __metal_fmin(static_cast<ctype>(x), static_cast<ctype>(y), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype fmin3(itype x, itype y, itype z) {                          \
+    return static_cast<otype>(__metal_fmin3(                                   \
+        static_cast<ctype>(x),                                                 \
+        static_cast<ctype>(y),                                                 \
+        static_cast<ctype>(z),                                                 \
+        mfast));                                                               \
+  }                                                                            \
+  METAL_FUNC otype fmod(itype x, itype y) {                                    \
+    return static_cast<otype>(                                                 \
+        __metal_fmod(static_cast<ctype>(x), static_cast<ctype>(y), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype fract(itype x) {                                            \
+    return static_cast<otype>(__metal_fract(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype frexp(itype x, thread int& exp) {                           \
+    return static_cast<otype>(__metal_frexp(static_cast<ctype>(x), &exp));     \
+  }                                                                            \
+  METAL_FUNC otype ldexp(itype x, int k) {                                     \
+    return static_cast<otype>(__metal_ldexp(static_cast<ctype>(x), k, mfast)); \
+  }                                                                            \
+  METAL_FUNC otype log(itype x) {                                              \
+    return static_cast<otype>(__metal_log(static_cast<ctype>(x), mfast));      \
+  }                                                                            \
+  METAL_FUNC otype log10(itype x) {                                            \
+    return static_cast<otype>(__metal_log10(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype log2(itype x) {                                             \
+    return static_cast<otype>(__metal_log2(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype max(itype x, itype y) {                                     \
+    return static_cast<otype>(                                                 \
+        __metal_fmax(static_cast<ctype>(x), static_cast<ctype>(y), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype max3(itype x, itype y, itype z) {                           \
+    return static_cast<otype>(__metal_fmax3(                                   \
+        static_cast<ctype>(x),                                                 \
+        static_cast<ctype>(y),                                                 \
+        static_cast<ctype>(z),                                                 \
+        mfast));                                                               \
+  }                                                                            \
+  METAL_FUNC otype median3(itype x, itype y, itype z) {                        \
+    return static_cast<otype>(__metal_fmedian3(                                \
+        static_cast<ctype>(x),                                                 \
+        static_cast<ctype>(y),                                                 \
+        static_cast<ctype>(z),                                                 \
+        mfast));                                                               \
+  }                                                                            \
+  METAL_FUNC otype min(itype x, itype y) {                                     \
+    return static_cast<otype>(                                                 \
+        __metal_fmin(static_cast<ctype>(x), static_cast<ctype>(y), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype min3(itype x, itype y, itype z) {                           \
+    return static_cast<otype>(__metal_fmin3(                                   \
+        static_cast<ctype>(x),                                                 \
+        static_cast<ctype>(y),                                                 \
+        static_cast<ctype>(z),                                                 \
+        mfast));                                                               \
+  }                                                                            \
+  METAL_FUNC otype nextafter(itype x, itype y) {                               \
+    return static_cast<otype>(                                                 \
+        __metal_nextafter(static_cast<ctype>(x), static_cast<ctype>(y)));      \
+  }                                                                            \
+  METAL_FUNC otype pow(itype x, itype y) {                                     \
+    return static_cast<otype>(                                                 \
+        __metal_pow(static_cast<ctype>(x), static_cast<ctype>(y), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype powr(itype x, itype y) {                                    \
+    return static_cast<otype>(                                                 \
+        __metal_powr(static_cast<ctype>(x), static_cast<ctype>(y), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype rint(itype x) {                                             \
+    return static_cast<otype>(__metal_rint(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype round(itype x) {                                            \
+    return static_cast<otype>(__metal_round(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype rsqrt(itype x) {                                            \
+    return static_cast<otype>(__metal_rsqrt(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype sin(itype x) {                                              \
+    return static_cast<otype>(__metal_sin(static_cast<ctype>(x), mfast));      \
+  }                                                                            \
+  METAL_FUNC otype sinh(itype x) {                                             \
+    return static_cast<otype>(__metal_sinh(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype sinpi(itype x) {                                            \
+    return static_cast<otype>(__metal_sinpi(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype sqrt(itype x) {                                             \
+    return static_cast<otype>(__metal_sqrt(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype tan(itype x) {                                              \
+    return static_cast<otype>(__metal_tan(static_cast<ctype>(x), mfast));      \
+  }                                                                            \
+  METAL_FUNC otype tanh(itype x) {                                             \
+    return static_cast<otype>(__metal_tanh(static_cast<ctype>(x), mfast));     \
+  }                                                                            \
+  METAL_FUNC otype tanpi(itype x) {                                            \
+    return static_cast<otype>(__metal_tanpi(static_cast<ctype>(x), mfast));    \
+  }                                                                            \
+  METAL_FUNC otype trunc(itype x) {                                            \
+    return static_cast<otype>(__metal_trunc(static_cast<ctype>(x), mfast));    \
+  }
+
+namespace metal {
+
+instantiate_metal_math_funcs(
+    bfloat16_t,
+    bfloat16_t,
+    float,
+    __METAL_MAYBE_FAST_MATH__);
+
+namespace fast {
+
+instantiate_metal_math_funcs(
+    bfloat16_t,
+    bfloat16_t,
+    float,
+    __METAL_FAST_MATH__);
+
+} // namespace fast
+
+namespace precise {
+
+instantiate_metal_math_funcs(
+    bfloat16_t,
+    bfloat16_t,
+    float,
+    __METAL_PRECISE_MATH__);
+
+} // namespace precise
+
+} // namespace metal
+
+///////////////////////////////////////////////////////////////////////////////
+// Metal simd for bfloat16
+///////////////////////////////////////////////////////////////////////////////
+
+#define instantiate_metal_simd_comm_funcs(                                   \
+    itype, otype, ctype, itype_to_ctype, ctype_to_otype)                     \
+                                                                             \
+  METAL_FUNC otype simd_broadcast(itype data, ushort broadcast_lane_id) {    \
+    return ctype_to_otype(                                                   \
+        __metal_simd_broadcast(itype_to_ctype(data), broadcast_lane_id));    \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle(itype data, ushort simd_lane_id) {           \
+    return ctype_to_otype(                                                   \
+        __metal_simd_shuffle(itype_to_ctype(data), simd_lane_id));           \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_and_fill_down(                               \
+      itype data, itype filling_data, ushort delta, ushort modulo) {         \
+    return ctype_to_otype(__metal_simd_shuffle_and_fill_down(                \
+        itype_to_ctype(data), itype_to_ctype(filling_data), delta, modulo)); \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_and_fill_down(                               \
+      itype data, itype filling_data, ushort delta) {                        \
+    return ctype_to_otype(__metal_simd_shuffle_and_fill_down(                \
+        itype_to_ctype(data),                                                \
+        itype_to_ctype(filling_data),                                        \
+        delta,                                                               \
+        __metal_get_simdgroup_size(ushort())));                              \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_and_fill_up(                                 \
+      itype data, itype filling_data, ushort delta, ushort modulo) {         \
+    return ctype_to_otype(__metal_simd_shuffle_and_fill_up(                  \
+        itype_to_ctype(data), itype_to_ctype(filling_data), delta, modulo)); \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_and_fill_up(                                 \
+      itype data, itype filling_data, ushort delta) {                        \
+    return ctype_to_otype(__metal_simd_shuffle_and_fill_up(                  \
+        itype_to_ctype(data),                                                \
+        itype_to_ctype(filling_data),                                        \
+        delta,                                                               \
+        __metal_get_simdgroup_size(ushort())));                              \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_down(itype data, ushort delta) {             \
+    return ctype_to_otype(                                                   \
+        __metal_simd_shuffle_down(itype_to_ctype(data), delta));             \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_rotate_down(itype data, ushort delta) {      \
+    return ctype_to_otype(                                                   \
+        __metal_simd_shuffle_rotate_down(itype_to_ctype(data), delta));      \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_rotate_up(itype data, ushort delta) {        \
+    return ctype_to_otype(                                                   \
+        __metal_simd_shuffle_rotate_up(itype_to_ctype(data), delta));        \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_up(itype data, ushort delta) {               \
+    return ctype_to_otype(                                                   \
+        __metal_simd_shuffle_up(itype_to_ctype(data), delta));               \
+  }                                                                          \
+                                                                             \
+  METAL_FUNC otype simd_shuffle_xor(itype data, ushort mask) {               \
+    return ctype_to_otype(                                                   \
+        __metal_simd_shuffle_xor(itype_to_ctype(data), mask));               \
+  }
+
+#define instantiate_metal_simd_reduction_funcs(itype, otype, ctype)            \
+                                                                               \
+  METAL_FUNC otype simd_max(itype data) {                                      \
+    return static_cast<otype>(__metal_simd_max(static_cast<ctype>(data)));     \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_min(itype data) {                                      \
+    return static_cast<otype>(__metal_simd_min(static_cast<ctype>(data)));     \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_prefix_exclusive_product(itype data) {                 \
+    return static_cast<otype>(                                                 \
+        __metal_simd_prefix_exclusive_product(static_cast<ctype>(data)));      \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_prefix_exclusive_sum(itype data) {                     \
+    return static_cast<otype>(                                                 \
+        __metal_simd_prefix_exclusive_sum(static_cast<ctype>(data)));          \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_prefix_inclusive_product(itype data) {                 \
+    return static_cast<otype>(                                                 \
+        __metal_simd_prefix_inclusive_product(static_cast<ctype>(data)));      \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_prefix_inclusive_sum(itype data) {                     \
+    return static_cast<otype>(                                                 \
+        __metal_simd_prefix_inclusive_sum(static_cast<ctype>(data)));          \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_product(itype data) {                                  \
+    return static_cast<otype>(__metal_simd_product(static_cast<ctype>(data))); \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_sum(itype data) {                                      \
+    return static_cast<otype>(__metal_simd_sum(static_cast<ctype>(data)));     \
+  }                                                                            \
+                                                                               \
+  METAL_FUNC otype simd_xor(itype data) {                                      \
+    return static_cast<otype>(__metal_simd_xor(static_cast<ctype>(data)));     \
+  }
+
+namespace metal {
+
+instantiate_metal_simd_comm_funcs(
+    bfloat16_t,
+    bfloat16_t,
+    uint16_t,
+    bfloat16_to_uint16,
+    uint16_to_bfloat16);
+instantiate_metal_simd_reduction_funcs(bfloat16_t, bfloat16_t, float);
+
+} // namespace metal
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary.h
new file mode 100644
index 0000000000000000000000000000000000000000..f1df885350adc1807158d79c95e2e3b627dc2c38
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary.h
@@ -0,0 +1,199 @@
+// Copyright © 2024 Apple Inc.
+
+template <typename T, typename U, typename Op>
+[[kernel]] void binary_ss(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    uint index [[thread_position_in_grid]]) {
+  c[index] = Op()(a[0], b[0]);
+}
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void binary_sv(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    constant uint& size,
+    uint index [[thread_position_in_grid]]) {
+  index *= N;
+  if (N > 1 && index + N > size) {
+    for (int i = 0; index + i < size; ++i) {
+      c[index + i] = Op()(a[0], b[index + i]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      c[index + i] = Op()(a[0], b[index + i]);
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void binary_vs(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    constant uint& size,
+    uint index [[thread_position_in_grid]]) {
+  index *= N;
+  if (N > 1 && index + N > size) {
+    for (int i = 0; index + i < size; ++i) {
+      c[index + i] = Op()(a[index + i], b[0]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      c[index + i] = Op()(a[index + i], b[0]);
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void binary_vv(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    constant uint& size,
+    uint index [[thread_position_in_grid]]) {
+  index *= N;
+  if (N > 1 && index + N > size) {
+    for (int i = 0; index + i < size; ++i) {
+      c[index + i] = Op()(a[index + i], b[index + i]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      c[index + i] = Op()(a[index + i], b[index + i]);
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void binary_sv2(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    constant int64_t& size,
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  int64_t offset = N * (index.x + grid_dim.x * int64_t(index.y));
+  if (N > 1 && offset + N > size) {
+    for (int i = 0; offset + i < size; ++i) {
+      c[offset + i] = Op()(a[0], b[offset + i]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      c[offset + i] = Op()(a[0], b[offset + i]);
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void binary_vs2(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    constant int64_t& size,
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  int64_t offset = N * (index.x + grid_dim.x * int64_t(index.y));
+  if (N > 1 && offset + N > size) {
+    for (int i = 0; offset + i < size; ++i) {
+      c[offset + i] = Op()(a[offset + i], b[0]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      c[offset + i] = Op()(a[offset + i], b[0]);
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void binary_vv2(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    constant int64_t& size,
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  int64_t offset = N * (index.x + grid_dim.x * int64_t(index.y));
+  if (N > 1 && offset + N > size) {
+    for (int i = 0; offset + i < size; ++i) {
+      c[offset + i] = Op()(a[offset + i], b[offset + i]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      c[offset + i] = Op()(a[offset + i], b[offset + i]);
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, typename IdxT = int64_t>
+[[kernel]] void binary_g_nd1(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    constant const int64_t& a_stride,
+    constant const int64_t& b_stride,
+    uint index [[thread_position_in_grid]]) {
+  auto a_idx = elem_to_loc_1<IdxT>(index, a_stride);
+  auto b_idx = elem_to_loc_1<IdxT>(index, b_stride);
+  c[index] = Op()(a[a_idx], b[b_idx]);
+}
+
+template <typename T, typename U, typename Op, typename IdxT = int64_t>
+[[kernel]] void binary_g_nd2(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    constant const int64_t a_strides[2],
+    constant const int64_t b_strides[2],
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  auto a_idx = elem_to_loc_2<IdxT>(index, a_strides);
+  auto b_idx = elem_to_loc_2<IdxT>(index, b_strides);
+  IdxT out_idx = index.x + IdxT(grid_dim.x) * index.y;
+  c[out_idx] = Op()(a[a_idx], b[b_idx]);
+}
+
+template <typename T, typename U, typename Op, typename IdxT = int64_t>
+[[kernel]] void binary_g_nd3(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    constant const int64_t a_strides[3],
+    constant const int64_t b_strides[3],
+    uint3 index [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {
+  auto a_idx = elem_to_loc_3<IdxT>(index, a_strides);
+  auto b_idx = elem_to_loc_3<IdxT>(index, b_strides);
+  IdxT out_idx = index.x + grid_dim.x * (index.y + IdxT(grid_dim.y) * index.z);
+  c[out_idx] = Op()(a[a_idx], b[b_idx]);
+}
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    int N = 1,
+    typename IdxT = int64_t>
+[[kernel]] void binary_g(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    constant const int* shape,
+    constant const int64_t* a_strides,
+    constant const int64_t* b_strides,
+    constant const int& ndim,
+    uint3 index [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {
+  auto idx = elem_to_loc_2_nd<IdxT>(
+      {N * index.x, index.y, index.z}, shape, a_strides, b_strides, ndim);
+  auto xshape = shape[ndim - 1];
+  IdxT out_idx = N * index.x + xshape * (index.y + IdxT(grid_dim.y) * index.z);
+  IdxT a_xstride = a_strides[ndim - 1];
+  IdxT b_xstride = b_strides[ndim - 1];
+  for (int i = 0; i < N && (int(N * index.x) + i) < xshape; ++i) {
+    c[out_idx++] = Op()(a[idx.x], b[idx.y]);
+    idx.x += a_xstride;
+    idx.y += b_xstride;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary.metal
new file mode 100644
index 0000000000000000000000000000000000000000..17ed13c57fe272c9a7a131d5615702ba6e24f9ac
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary.metal
@@ -0,0 +1,109 @@
+// Copyright © 2024 Apple Inc.
+
+#include <metal_integer>
+#include <metal_math>
+
+// clang-format off
+#include "mlx/backend/metal/kernels/defines.h"
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/binary_ops.h"
+#include "mlx/backend/metal/kernels/binary.h"
+
+#define instantiate_binary_work_per_thread(op, tname, itype, otype)     \
+  instantiate_kernel("svn_" #op #tname, binary_sv, itype, otype, op)    \
+  instantiate_kernel("vsn_" #op #tname, binary_vs, itype, otype, op)    \
+  instantiate_kernel("vvn_" #op #tname, binary_vv, itype, otype, op)    \
+
+#define instantiate_binary_base(op, tname, itype, otype)                    \
+  instantiate_kernel("ss_" #op #tname, binary_ss, itype, otype, op)         \
+  instantiate_kernel("sv_" #op #tname, binary_sv, itype, otype, op, 1)      \
+  instantiate_kernel("vs_" #op #tname, binary_vs, itype, otype, op, 1)      \
+  instantiate_kernel("vv_" #op #tname, binary_vv, itype, otype, op, 1)      \
+  instantiate_kernel("sv2_" #op #tname, binary_sv2, itype, otype, op)       \
+  instantiate_kernel("vs2_" #op #tname, binary_vs2, itype, otype, op)       \
+  instantiate_kernel("vv2_" #op #tname, binary_vv2, itype, otype, op)       \
+  instantiate_kernel("gn2_" #op #tname, binary_g, itype, otype, op, 2, int) \
+  instantiate_kernel("gn4large_" #op #tname, binary_g, itype, otype, op, 4) \
+  instantiate_kernel("g1_" #op #tname, binary_g_nd1, itype, otype, op, int) \
+  instantiate_kernel("g1large_" #op #tname, binary_g_nd1, itype, otype, op) \
+  instantiate_kernel("g2_" #op #tname, binary_g_nd2, itype, otype, op, int) \
+  instantiate_kernel("g2large_" #op #tname, binary_g_nd2, itype, otype, op) \
+  instantiate_kernel("g3_" #op #tname, binary_g_nd3, itype, otype, op, int) \
+  instantiate_kernel("g3large_" #op #tname, binary_g_nd3, itype, otype, op)
+
+#define instantiate_binary_all(op, tname, itype, otype)       \
+  instantiate_binary_base(op, tname, itype, otype)            \
+  instantiate_binary_work_per_thread(op, tname, itype, otype)
+
+#define instantiate_binary_integer(op)                    \
+  instantiate_binary_all(op, uint8, uint8_t, uint8_t)     \
+  instantiate_binary_all(op, uint16, uint16_t, uint16_t)  \
+  instantiate_binary_all(op, uint32, uint32_t, uint32_t)  \
+  instantiate_binary_base(op, uint64, uint64_t, uint64_t) \
+  instantiate_binary_all(op, int8, int8_t, int8_t)        \
+  instantiate_binary_all(op, int16, int16_t, int16_t)     \
+  instantiate_binary_all(op, int32, int32_t, int32_t)     \
+  instantiate_binary_base(op, int64, int64_t, int64_t)
+
+#define instantiate_binary_float(op)                \
+  instantiate_binary_all(op, float16, half, half)   \
+  instantiate_binary_all(op, float32, float, float) \
+  instantiate_binary_all(op, bfloat16, bfloat16_t, bfloat16_t)
+
+#define instantiate_binary_types(op)                              \
+  instantiate_binary_all(op, bool_, bool, bool)                   \
+  instantiate_binary_integer(op)                                  \
+  instantiate_binary_base(op, complex64, complex64_t, complex64_t)\
+  instantiate_binary_float(op)
+
+#define instantiate_binary_types_bool(op)                \
+  instantiate_binary_all(op, bool_, bool, bool)          \
+  instantiate_binary_all(op, uint8, uint8_t, bool)       \
+  instantiate_binary_all(op, uint16, uint16_t, bool)     \
+  instantiate_binary_all(op, uint32, uint32_t, bool)     \
+  instantiate_binary_base(op, uint64, uint64_t, bool)    \
+  instantiate_binary_all(op, int8, int8_t, bool)         \
+  instantiate_binary_all(op, int16, int16_t, bool)       \
+  instantiate_binary_all(op, int32, int32_t, bool)       \
+  instantiate_binary_base(op, int64, int64_t, bool)      \
+  instantiate_binary_all(op, float16, half, bool)        \
+  instantiate_binary_all(op, float32, float, bool)       \
+  instantiate_binary_all(op, bfloat16, bfloat16_t, bool) \
+  instantiate_binary_base(op, complex64, complex64_t, bool)
+
+instantiate_binary_types(Add)
+instantiate_binary_types(Divide)
+instantiate_binary_types_bool(Equal)
+instantiate_binary_types_bool(Greater)
+instantiate_binary_types_bool(GreaterEqual)
+instantiate_binary_types_bool(Less)
+instantiate_binary_types_bool(LessEqual)
+instantiate_binary_types_bool(NotEqual)
+instantiate_binary_float(LogAddExp)
+instantiate_binary_base(LogAddExp, complex64, complex64_t, complex64_t)
+instantiate_binary_types(Maximum)
+instantiate_binary_types(Minimum)
+instantiate_binary_types(Multiply)
+instantiate_binary_types(Subtract)
+instantiate_binary_types(Power)
+instantiate_binary_types(Remainder)
+instantiate_binary_float(ArcTan2)
+
+// NaNEqual only needed for floating point types with boolean output
+instantiate_binary_all(NaNEqual, float16, half, bool)
+instantiate_binary_all(NaNEqual, float32, float, bool)
+instantiate_binary_all(NaNEqual, bfloat16, bfloat16_t, bool)
+instantiate_binary_base(NaNEqual, complex64, complex64_t, bool)
+
+instantiate_binary_all(LogicalOr, bool_, bool, bool)
+instantiate_binary_all(LogicalAnd, bool_, bool, bool)
+
+// Bitwise ops only need integer types and bool (except for l/r shift)
+instantiate_binary_integer(BitwiseAnd)
+instantiate_binary_all(BitwiseAnd, bool_, bool, bool)
+instantiate_binary_integer(BitwiseOr)
+instantiate_binary_all(BitwiseOr, bool_, bool, bool)
+instantiate_binary_integer(BitwiseXor)
+instantiate_binary_all(BitwiseXor, bool_, bool, bool)
+instantiate_binary_integer(LeftShift)
+instantiate_binary_integer(RightShift) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary_ops.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..cb3e8a3703ae99d02756f9a7cf93bcd304f79b18
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary_ops.h
@@ -0,0 +1,326 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <metal_integer>
+#include <metal_math>
+
+struct Add {
+  template <typename T>
+  T operator()(T x, T y) {
+    return x + y;
+  }
+};
+
+struct FloorDivide {
+  template <typename T>
+  T operator()(T x, T y) {
+    return x / y;
+  }
+  template <>
+  float operator()(float x, float y) {
+    return trunc(x / y);
+  }
+  template <>
+  half operator()(half x, half y) {
+    return trunc(x / y);
+  }
+  template <>
+  bfloat16_t operator()(bfloat16_t x, bfloat16_t y) {
+    return trunc(x / y);
+  }
+};
+
+struct Divide {
+  template <typename T>
+  T operator()(T x, T y) {
+    return x / y;
+  }
+};
+
+struct Remainder {
+  template <typename T>
+  metal::enable_if_t<metal::is_integral_v<T> & !metal::is_signed_v<T>, T>
+  operator()(T x, T y) {
+    return x % y;
+  }
+  template <typename T>
+  metal::enable_if_t<metal::is_integral_v<T> & metal::is_signed_v<T>, T>
+  operator()(T x, T y) {
+    auto r = x % y;
+    if (r != 0 && (r < 0 != y < 0)) {
+      r += y;
+    }
+    return r;
+  }
+  template <typename T>
+  metal::enable_if_t<!metal::is_integral_v<T>, T> operator()(T x, T y) {
+    T r = fmod(x, y);
+    if (r != 0 && (r < 0 != y < 0)) {
+      r += y;
+    }
+    return r;
+  }
+  template <>
+  complex64_t operator()(complex64_t x, complex64_t y) {
+    return x % y;
+  }
+};
+
+struct Equal {
+  template <typename T>
+  bool operator()(T x, T y) {
+    return x == y;
+  }
+};
+
+struct NaNEqual {
+  template <typename T>
+  bool operator()(T x, T y) {
+    return x == y || (metal::isnan(x) && metal::isnan(y));
+  }
+  template <>
+  bool operator()(complex64_t x, complex64_t y) {
+    return x == y ||
+        (metal::isnan(x.real) && metal::isnan(y.real) && metal::isnan(x.imag) &&
+         metal::isnan(y.imag)) ||
+        (x.real == y.real && metal::isnan(x.imag) && metal::isnan(y.imag)) ||
+        (metal::isnan(x.real) && metal::isnan(y.real) && x.imag == y.imag);
+  }
+};
+
+struct Greater {
+  template <typename T>
+  bool operator()(T x, T y) {
+    return x > y;
+  }
+};
+
+struct GreaterEqual {
+  template <typename T>
+  bool operator()(T x, T y) {
+    return x >= y;
+  }
+};
+
+struct Less {
+  template <typename T>
+  bool operator()(T x, T y) {
+    return x < y;
+  }
+};
+
+struct LessEqual {
+  template <typename T>
+  bool operator()(T x, T y) {
+    return x <= y;
+  }
+};
+
+struct LogAddExp {
+  template <typename T>
+  T operator()(T x, T y) {
+    if (metal::isnan(x) || metal::isnan(y)) {
+      return metal::numeric_limits<T>::quiet_NaN();
+    }
+    constexpr T inf = metal::numeric_limits<T>::infinity();
+    T maxval = metal::max(x, y);
+    T minval = metal::min(x, y);
+    return (minval == -inf || maxval == inf)
+        ? maxval
+        : (maxval + log1p(metal::exp(minval - maxval)));
+  };
+
+  complex64_t operator()(complex64_t x, complex64_t y) {
+    if (metal::isnan(x.real) || metal::isnan(x.imag) || metal::isnan(y.real) ||
+        metal::isnan(y.imag)) {
+      return metal::numeric_limits<float>::quiet_NaN();
+    }
+    constexpr float inf = metal::numeric_limits<float>::infinity();
+    complex64_t maxval = x > y ? x : y;
+    complex64_t minval = x < y ? x : y;
+    if (minval.real == -inf || maxval.real == inf)
+      return maxval;
+    float m = metal::exp(minval.real - maxval.real);
+    complex64_t dexp{
+        m * metal::cos(minval.imag - maxval.imag),
+        m * metal::sin(minval.imag - maxval.imag),
+    };
+    return maxval + log1p(dexp);
+  }
+};
+
+struct Maximum {
+  template <typename T>
+  metal::enable_if_t<metal::is_integral_v<T>, T> operator()(T x, T y) {
+    return metal::max(x, y);
+  }
+
+  template <typename T>
+  metal::enable_if_t<!metal::is_integral_v<T>, T> operator()(T x, T y) {
+    if (metal::isnan(x)) {
+      return x;
+    }
+    return x > y ? x : y;
+  }
+
+  template <>
+  complex64_t operator()(complex64_t x, complex64_t y) {
+    if (metal::isnan(x.real) || metal::isnan(x.imag)) {
+      return x;
+    }
+    return x > y ? x : y;
+  }
+};
+
+struct Minimum {
+  template <typename T>
+  metal::enable_if_t<metal::is_integral_v<T>, T> operator()(T x, T y) {
+    return metal::min(x, y);
+  }
+
+  template <typename T>
+  metal::enable_if_t<!metal::is_integral_v<T>, T> operator()(T x, T y) {
+    if (metal::isnan(x)) {
+      return x;
+    }
+    return x < y ? x : y;
+  }
+
+  template <>
+  complex64_t operator()(complex64_t x, complex64_t y) {
+    if (metal::isnan(x.real) || metal::isnan(x.imag)) {
+      return x;
+    }
+    return x < y ? x : y;
+  }
+};
+
+struct Multiply {
+  template <typename T>
+  T operator()(T x, T y) {
+    return x * y;
+  }
+};
+
+struct NotEqual {
+  template <typename T>
+  bool operator()(T x, T y) {
+    return x != y;
+  }
+  template <>
+  bool operator()(complex64_t x, complex64_t y) {
+    return x.real != y.real || x.imag != y.imag;
+  }
+};
+
+struct Power {
+  template <typename T>
+  metal::enable_if_t<!metal::is_integral_v<T>, T> operator()(T base, T exp) {
+    return metal::pow(base, exp);
+  }
+
+  template <typename T>
+  metal::enable_if_t<metal::is_integral_v<T>, T> operator()(T base, T exp) {
+    T res = 1;
+    // Undefined to raise integer to negative power
+    if (exp < 0) {
+      return 0;
+    }
+
+    while (exp) {
+      if (exp & 1) {
+        res *= base;
+      }
+      exp >>= 1;
+      base *= base;
+    }
+    return res;
+  }
+
+  template <>
+  complex64_t operator()(complex64_t x, complex64_t y) {
+    if (x.real == 0 && x.imag == 0) {
+      if (metal::isnan(y.real) || metal::isnan(y.imag)) {
+        auto nan = metal::numeric_limits<float>::quiet_NaN();
+        return {nan, nan};
+      }
+      return {0.0, 0.0};
+    }
+    auto x_theta = metal::atan2(x.imag, x.real);
+    auto x_ln_r = 0.5 * metal::log(x.real * x.real + x.imag * x.imag);
+    auto mag = metal::exp(y.real * x_ln_r - y.imag * x_theta);
+    auto phase = y.imag * x_ln_r + y.real * x_theta;
+    return {mag * metal::cos(phase), mag * metal::sin(phase)};
+  }
+};
+
+struct Subtract {
+  template <typename T>
+  T operator()(T x, T y) {
+    return x - y;
+  }
+};
+
+struct LogicalAnd {
+  template <typename T>
+  T operator()(T x, T y) {
+    return x && y;
+  };
+};
+
+struct LogicalOr {
+  template <typename T>
+  T operator()(T x, T y) {
+    return x || y;
+  };
+};
+
+struct BitwiseAnd {
+  template <typename T>
+  T operator()(T x, T y) {
+    return x & y;
+  };
+};
+
+struct BitwiseOr {
+  template <typename T>
+  T operator()(T x, T y) {
+    return x | y;
+  };
+};
+
+struct BitwiseXor {
+  template <typename T>
+  T operator()(T x, T y) {
+    return x ^ y;
+  };
+};
+
+struct LeftShift {
+  template <typename T>
+  T operator()(T x, T y) {
+    return x << y;
+  };
+};
+
+struct RightShift {
+  template <typename T>
+  T operator()(T x, T y) {
+    return x >> y;
+  };
+};
+
+struct ArcTan2 {
+  template <typename T>
+  T operator()(T y, T x) {
+    return metal::precise::atan2(y, x);
+  }
+};
+
+struct DivMod {
+  template <typename T>
+  metal::array<T, 2> operator()(T x, T y) {
+    return {FloorDivide{}(x, y), Remainder{}(x, y)};
+  };
+};
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary_two.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary_two.h
new file mode 100644
index 0000000000000000000000000000000000000000..4455e4ca977b250e3af264716b8ec3113ea67976
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary_two.h
@@ -0,0 +1,244 @@
+// Copyright © 2024 Apple Inc.
+
+template <typename T, typename U, typename Op>
+[[kernel]] void binary_ss(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    device U* d,
+    uint index [[thread_position_in_grid]]) {
+  auto out = Op()(a[0], b[0]);
+  c[index] = out[0];
+  d[index] = out[1];
+}
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void binary_sv(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    device U* d,
+    constant uint& size,
+    uint index [[thread_position_in_grid]]) {
+  index *= N;
+  if (N > 1 && index + N > size) {
+    for (int i = 0; index + i < size; ++i) {
+      auto out = Op()(a[0], b[index + i]);
+      c[index + i] = out[0];
+      d[index + i] = out[1];
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      auto out = Op()(a[0], b[index + i]);
+      c[index + i] = out[0];
+      d[index + i] = out[1];
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void binary_vs(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    device U* d,
+    constant uint& size,
+    uint index [[thread_position_in_grid]]) {
+  index *= N;
+  if (N > 1 && index + N > size) {
+    for (int i = 0; index + i < size; ++i) {
+      auto out = Op()(a[index + i], b[0]);
+      c[index + i] = out[0];
+      d[index + i] = out[1];
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      auto out = Op()(a[index + i], b[0]);
+      c[index + i] = out[0];
+      d[index + i] = out[1];
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void binary_vv(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    device U* d,
+    constant uint& size,
+    uint index [[thread_position_in_grid]]) {
+  index *= N;
+  if (N > 1 && index + N > size) {
+    for (int i = 0; index + i < size; ++i) {
+      auto out = Op()(a[index + i], b[index + i]);
+      c[index + i] = out[0];
+      d[index + i] = out[1];
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      auto out = Op()(a[index + i], b[index + i]);
+      c[index + i] = out[0];
+      d[index + i] = out[1];
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void binary_sv2(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    device U* d,
+    constant int64_t& size,
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  int64_t offset = N * (index.x + grid_dim.x * int64_t(index.y));
+  if (N > 1 && offset + N > size) {
+    for (int i = 0; offset + i < size; ++i) {
+      auto out = Op()(a[0], b[offset + i]);
+      c[offset + i] = out[0];
+      d[offset + i] = out[1];
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      auto out = Op()(a[0], b[offset + i]);
+      c[offset + i] = out[0];
+      d[offset + i] = out[1];
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void binary_vs2(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    device U* d,
+    constant int64_t& size,
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  int64_t offset = N * (index.x + grid_dim.x * int64_t(index.y));
+  if (N > 1 && offset + N > size) {
+    for (int i = 0; offset + i < size; ++i) {
+      auto out = Op()(a[offset + i], b[0]);
+      c[offset + i] = out[0];
+      d[offset + i] = out[1];
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      auto out = Op()(a[offset + i], b[0]);
+      c[offset + i] = out[0];
+      d[offset + i] = out[1];
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void binary_vv2(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    device U* d,
+    constant int64_t& size,
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  int64_t offset = N * (index.x + grid_dim.x * int64_t(index.y));
+  if (N > 1 && offset + N > size) {
+    for (int i = 0; offset + i < size; ++i) {
+      auto out = Op()(a[offset + i], b[offset + i]);
+      c[offset + i] = out[0];
+      d[offset + i] = out[1];
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      auto out = Op()(a[offset + i], b[offset + i]);
+      c[offset + i] = out[0];
+      d[offset + i] = out[1];
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, typename IdxT = int64_t>
+[[kernel]] void binary_g_nd1(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    device U* d,
+    constant const int64_t& a_stride,
+    constant const int64_t& b_stride,
+    uint index [[thread_position_in_grid]]) {
+  auto a_idx = elem_to_loc_1<IdxT>(index, a_stride);
+  auto b_idx = elem_to_loc_1<IdxT>(index, b_stride);
+  auto out = Op()(a[a_idx], b[b_idx]);
+  c[index] = out[0];
+  d[index] = out[1];
+}
+
+template <typename T, typename U, typename Op, typename IdxT = int64_t>
+[[kernel]] void binary_g_nd2(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    device U* d,
+    constant const int64_t a_strides[2],
+    constant const int64_t b_strides[2],
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  auto a_idx = elem_to_loc_2<IdxT>(index, a_strides);
+  auto b_idx = elem_to_loc_2<IdxT>(index, b_strides);
+  IdxT out_idx = index.x + IdxT(grid_dim.x) * index.y;
+  auto out = Op()(a[a_idx], b[b_idx]);
+  c[out_idx] = out[0];
+  d[out_idx] = out[1];
+}
+
+template <typename T, typename U, typename Op, typename IdxT = int64_t>
+[[kernel]] void binary_g_nd3(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    device U* d,
+    constant const int64_t a_strides[3],
+    constant const int64_t b_strides[3],
+    uint3 index [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {
+  auto a_idx = elem_to_loc_3<IdxT>(index, a_strides);
+  auto b_idx = elem_to_loc_3<IdxT>(index, b_strides);
+  IdxT out_idx = index.x + grid_dim.x * (index.y + IdxT(grid_dim.y) * index.z);
+  auto out = Op()(a[a_idx], b[b_idx]);
+  c[out_idx] = out[0];
+  d[out_idx] = out[1];
+}
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    int N = 1,
+    typename IdxT = int64_t>
+[[kernel]] void binary_g(
+    device const T* a,
+    device const T* b,
+    device U* c,
+    device U* d,
+    constant const int* shape,
+    constant const int64_t* a_strides,
+    constant const int64_t* b_strides,
+    constant const int& ndim,
+    uint3 index [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {
+  auto idx = elem_to_loc_2_nd<IdxT>(
+      {N * index.x, index.y, index.z}, shape, a_strides, b_strides, ndim);
+  auto xshape = shape[ndim - 1];
+  IdxT out_idx = N * index.x + xshape * (index.y + IdxT(grid_dim.y) * index.z);
+  IdxT a_xstride = a_strides[ndim - 1];
+  IdxT b_xstride = b_strides[ndim - 1];
+  for (int i = 0; i < N && (int(N * index.x) + i) < xshape; ++i) {
+    auto out = Op()(a[idx.x], b[idx.y]);
+    c[out_idx] = out[0];
+    d[out_idx++] = out[1];
+    idx.x += a_xstride;
+    idx.y += b_xstride;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary_two.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary_two.metal
new file mode 100644
index 0000000000000000000000000000000000000000..c7d3ecdf02cbc253207832329ecea08bfbff9cd8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/binary_two.metal
@@ -0,0 +1,54 @@
+// Copyright © 2024 Apple Inc.
+#include <metal_integer>
+#include <metal_math>
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/binary_ops.h"
+#include "mlx/backend/metal/kernels/binary_two.h"
+
+#define instantiate_binary_work_per_thread(op, tname, itype, otype)     \
+  instantiate_kernel("svn_" #op #tname, binary_sv, itype, otype, op)    \
+  instantiate_kernel("vsn_" #op #tname, binary_vs, itype, otype, op)    \
+  instantiate_kernel("vvn_" #op #tname, binary_vv, itype, otype, op)
+
+#define instantiate_binary_base(op, tname, itype, otype)                    \
+  instantiate_kernel("ss_" #op #tname, binary_ss, itype, otype, op)         \
+  instantiate_kernel("sv_" #op #tname, binary_sv, itype, otype, op, 1)      \
+  instantiate_kernel("vs_" #op #tname, binary_vs, itype, otype, op, 1)      \
+  instantiate_kernel("vv_" #op #tname, binary_vv, itype, otype, op, 1)      \
+  instantiate_kernel("sv2_" #op #tname, binary_sv2, itype, otype, op)       \
+  instantiate_kernel("vs2_" #op #tname, binary_vs2, itype, otype, op)       \
+  instantiate_kernel("vv2_" #op #tname, binary_vv2, itype, otype, op)       \
+  instantiate_kernel("gn2_" #op #tname, binary_g, itype, otype, op, 2, int) \
+  instantiate_kernel("gn4large_" #op #tname, binary_g, itype, otype, op, 4) \
+  instantiate_kernel("g1_" #op #tname, binary_g_nd1, itype, otype, op, int) \
+  instantiate_kernel("g2_" #op #tname, binary_g_nd2, itype, otype, op, int) \
+  instantiate_kernel("g3_" #op #tname, binary_g_nd3, itype, otype, op, int) \
+  instantiate_kernel("g1large_" #op #tname, binary_g_nd1, itype, otype, op) \
+  instantiate_kernel("g2large_" #op #tname, binary_g_nd2, itype, otype, op) \
+  instantiate_kernel("g3large_" #op #tname, binary_g_nd3, itype, otype, op)
+
+#define instantiate_binary_all(op, tname, itype, otype)       \
+  instantiate_binary_base(op, tname, itype, otype)            \
+  instantiate_binary_work_per_thread(op, tname, itype, otype)
+
+#define instantiate_binary_float(op)                \
+  instantiate_binary_all(op, float16, half, half)   \
+  instantiate_binary_all(op, float32, float, float) \
+  instantiate_binary_all(op, bfloat16, bfloat16_t, bfloat16_t)
+
+#define instantiate_binary_types(op)                               \
+  instantiate_binary_all(op, bool_, bool, bool)                    \
+  instantiate_binary_all(op, uint8, uint8_t, uint8_t)              \
+  instantiate_binary_all(op, uint16, uint16_t, uint16_t)           \
+  instantiate_binary_all(op, uint32, uint32_t, uint32_t)           \
+  instantiate_binary_base(op, uint64, uint64_t, uint64_t)          \
+  instantiate_binary_all(op, int8, int8_t, int8_t)                 \
+  instantiate_binary_all(op, int16, int16_t, int16_t)              \
+  instantiate_binary_all(op, int32, int32_t, int32_t)              \
+  instantiate_binary_base(op, int64, int64_t, int64_t)             \
+  instantiate_binary_base(op, complex64, complex64_t, complex64_t) \
+  instantiate_binary_float(op)
+
+instantiate_binary_types(DivMod) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/cexpf.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/cexpf.h
new file mode 100644
index 0000000000000000000000000000000000000000..b45fe6a2f1a1e57a7be4872c2ef10ba479334eb7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/cexpf.h
@@ -0,0 +1,134 @@
+// Copyright © 2025 Apple Inc.
+// Copyright © 2008-2013 NVIDIA Corporation
+// Copyright © 2013 Filipe RNC Maia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Forked from
+// https://github.com/NVIDIA/cccl/blob/main/thrust/thrust/detail/complex/cexpf.h
+
+// TODO: We should use thrust::exp but the thrust header in old CUDA versions
+// can not be used in JIT.
+
+#pragma once
+
+#include <metal_math>
+
+using ieee_float_shape_type = union {
+  float value;
+  uint32_t word;
+};
+
+inline void get_float_word(thread uint32_t& i, float d) {
+  ieee_float_shape_type gf_u;
+  gf_u.value = (d);
+  (i) = gf_u.word;
+}
+
+inline void get_float_word(thread int32_t& i, float d) {
+  ieee_float_shape_type gf_u;
+  gf_u.value = (d);
+  (i) = gf_u.word;
+}
+
+inline void set_float_word(thread float& d, uint32_t i) {
+  ieee_float_shape_type sf_u;
+  sf_u.word = (i);
+  (d) = sf_u.value;
+}
+
+inline float frexp_expf(float x, thread int* expt) {
+  const uint32_t k = 235;
+  const float kln2 = 162.88958740F;
+
+  float exp_x;
+  uint32_t hx;
+
+  exp_x = metal::exp(x - kln2);
+  get_float_word(hx, exp_x);
+  *expt = (hx >> 23) - (0x7f + 127) + k;
+  set_float_word(exp_x, (hx & 0x7fffff) | ((0x7f + 127) << 23));
+  return exp_x;
+}
+
+inline complex64_t ldexp_cexpf(complex64_t z, int expt) {
+  float x, y, exp_x, scale1, scale2;
+  int ex_expt, half_expt;
+
+  x = z.real;
+  y = z.imag;
+  exp_x = frexp_expf(x, &ex_expt);
+  expt += ex_expt;
+
+  half_expt = expt / 2;
+  set_float_word(scale1, (0x7f + half_expt) << 23);
+  half_expt = expt - half_expt;
+  set_float_word(scale2, (0x7f + half_expt) << 23);
+
+  return complex64_t{
+      metal::cos(y) * exp_x * scale1 * scale2,
+      metal::sin(y) * exp_x * scale1 * scale2};
+}
+
+inline complex64_t cexpf(const thread complex64_t& z) {
+  float x, y, exp_x;
+  uint32_t hx, hy;
+
+  const uint32_t exp_ovfl = 0x42b17218, cexp_ovfl = 0x43400074;
+
+  x = z.real;
+  y = z.imag;
+
+  get_float_word(hy, y);
+  hy &= 0x7fffffff;
+
+  /* cexp(x + I 0) = exp(x) + I 0 */
+  if (hy == 0) {
+    return complex64_t{metal::exp(x), y};
+  }
+  get_float_word(hx, x);
+  /* cexp(0 + I y) = cos(y) + I sin(y) */
+  if ((hx & 0x7fffffff) == 0) {
+    return complex64_t{metal::cos(y), metal::sin(y)};
+  }
+  if (hy >= 0x7f800000) {
+    if ((hx & 0x7fffffff) != 0x7f800000) {
+      /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */
+      return complex64_t{y - y, y - y};
+    } else if (hx & 0x80000000) {
+      /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */
+      return complex64_t{0.0, 0.0};
+    } else {
+      /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */
+      return complex64_t{x, y - y};
+    }
+  }
+
+  if (hx >= exp_ovfl && hx <= cexp_ovfl) {
+    /*
+     * x is between 88.7 and 192, so we must scale to avoid
+     * overflow in expf(x).
+     */
+    return ldexp_cexpf(z, 0);
+  } else {
+    /*
+     * Cases covered here:
+     *  -  x < exp_ovfl and exp(x) won't overflow (common case)
+     *  -  x > cexp_ovfl, so exp(x) * s overflows for all s > 0
+     *  -  x = +-Inf (generated by exp())
+     *  -  x = NaN (spurious inexact exception from y)
+     */
+    exp_x = metal::exp(x);
+    return complex64_t{exp_x * metal::cos(y), exp_x * metal::sin(y)};
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/complex.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/complex.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e391483d3ee1c59e144773d00e5c4eb74516600
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/complex.h
@@ -0,0 +1,173 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <metal_stdlib>
+
+using namespace metal;
+
+struct complex64_t;
+
+template <typename T>
+static constexpr constant bool can_convert_to_complex64 =
+    !is_same_v<T, complex64_t> && is_convertible_v<T, float>;
+
+template <typename T>
+static constexpr constant bool can_convert_from_complex64 =
+    !is_same_v<T, complex64_t> &&
+    (is_convertible_v<float, T> || is_convertible_v<bfloat16_t, T>);
+
+struct complex64_t {
+  float real;
+  float imag;
+
+  // Constructors
+  constexpr complex64_t(float real, float imag) : real(real), imag(imag) {};
+  constexpr complex64_t() : real(0), imag(0) {};
+  constexpr complex64_t() threadgroup : real(0), imag(0) {};
+
+  // Conversions to complex64_t
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_complex64<T>>::type>
+  constexpr complex64_t(T x) thread : real(x), imag(0) {}
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_complex64<T>>::type>
+  constexpr complex64_t(T x) threadgroup : real(x), imag(0) {}
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_complex64<T>>::type>
+  constexpr complex64_t(T x) device : real(x), imag(0) {}
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_complex64<T>>::type>
+  constexpr complex64_t(T x) constant : real(x), imag(0) {}
+
+  // Conversions from complex64_t
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_complex64<T>>::type>
+  constexpr operator T() const thread {
+    return static_cast<T>(real);
+  }
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_complex64<T>>::type>
+  constexpr operator T() const threadgroup {
+    return static_cast<T>(real);
+  }
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_complex64<T>>::type>
+  constexpr operator T() const device {
+    return static_cast<T>(real);
+  }
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_complex64<T>>::type>
+  constexpr operator T() const constant {
+    return static_cast<T>(real);
+  }
+};
+
+constexpr complex64_t operator-(complex64_t x) {
+  return {-x.real, -x.imag};
+}
+
+constexpr bool operator>=(complex64_t a, complex64_t b) {
+  return (a.real > b.real) || (a.real == b.real && a.imag >= b.imag);
+}
+
+constexpr bool operator>(complex64_t a, complex64_t b) {
+  return (a.real > b.real) || (a.real == b.real && a.imag > b.imag);
+}
+
+constexpr bool operator<=(complex64_t a, complex64_t b) {
+  return operator>=(b, a);
+}
+
+constexpr bool operator<(complex64_t a, complex64_t b) {
+  return operator>(b, a);
+}
+
+constexpr bool operator==(complex64_t a, complex64_t b) {
+  return a.real == b.real && a.imag == b.imag;
+}
+
+constexpr complex64_t operator+(complex64_t a, complex64_t b) {
+  return {a.real + b.real, a.imag + b.imag};
+}
+
+constexpr thread complex64_t& operator+=(thread complex64_t& a, complex64_t b) {
+  a.real += b.real;
+  a.imag += b.imag;
+  return a;
+}
+
+constexpr threadgroup complex64_t& operator+=(
+    threadgroup complex64_t& a,
+    complex64_t b) {
+  a.real += b.real;
+  a.imag += b.imag;
+  return a;
+}
+
+constexpr device complex64_t& operator+=(device complex64_t& a, complex64_t b) {
+  a.real += b.real;
+  a.imag += b.imag;
+  return a;
+}
+
+constexpr complex64_t operator+(float a, complex64_t b) {
+  return {a + b.real, b.imag};
+}
+constexpr complex64_t operator+(complex64_t a, float b) {
+  return {a.real + b, a.imag};
+}
+
+constexpr complex64_t operator-(complex64_t a, complex64_t b) {
+  return {a.real - b.real, a.imag - b.imag};
+}
+constexpr complex64_t operator-(float a, complex64_t b) {
+  return {a - b.real, -b.imag};
+}
+constexpr complex64_t operator-(complex64_t a, float b) {
+  return {a.real - b, a.imag};
+}
+
+constexpr complex64_t operator*(complex64_t a, complex64_t b) {
+  return {a.real * b.real - a.imag * b.imag, a.real * b.imag + a.imag * b.real};
+}
+
+constexpr complex64_t operator/(complex64_t a, complex64_t b) {
+  auto denom = b.real * b.real + b.imag * b.imag;
+  auto x = a.real * b.real + a.imag * b.imag;
+  auto y = a.imag * b.real - a.real * b.imag;
+  return {x / denom, y / denom};
+}
+
+constexpr complex64_t operator/(float a, complex64_t b) {
+  auto denom = b.real * b.real + b.imag * b.imag;
+  auto x = a * b.real;
+  auto y = -a * b.imag;
+  return {x / denom, y / denom};
+}
+
+constexpr complex64_t operator%(complex64_t a, complex64_t b) {
+  auto real = a.real - (b.real * static_cast<int64_t>(a.real / b.real));
+  auto imag = a.imag - (b.imag * static_cast<int64_t>(a.imag / b.imag));
+  if (real != 0 && (real < 0 != b.real < 0)) {
+    real += b.real;
+  }
+  if (imag != 0 && (imag < 0 != b.imag < 0)) {
+    imag += b.imag;
+  }
+  return {real, imag};
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/conv.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/conv.metal
new file mode 100644
index 0000000000000000000000000000000000000000..fdec515e24b4f1ab27560fa0ce4f5d4fd320d8f0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/conv.metal
@@ -0,0 +1,701 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <metal_simdgroup>
+#include <metal_simdgroup_matrix>
+#include <metal_stdlib>
+
+#include "mlx/backend/metal/kernels/steel/conv/params.h"
+#include "mlx/backend/metal/kernels/utils.h"
+
+#define MLX_MTL_CONST static constant constexpr const
+
+using namespace metal;
+
+///////////////////////////////////////////////////////////////////////////////
+/// Naive unfold with dilation
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, int N>
+[[kernel]] void naive_unfold_Nd(
+    const device T* in [[buffer(0)]],
+    device T* out [[buffer(1)]],
+    const constant MLXConvParams<N>* params [[buffer(2)]],
+    uint3 gid [[thread_position_in_grid]]) {
+  int filter_size = params->C;
+  for (short i = 0; i < N; i++)
+    filter_size *= params->wS[i];
+
+  int out_pixels = 1;
+  for (short i = 0; i < N; i++)
+    out_pixels *= params->oS[i];
+
+  // Set out
+  out += gid.z * filter_size + gid.y * (params->C);
+
+  // Coordinates in input
+  int is[N] = {0};
+
+  // gid.z: N oS (Batch and row in unfolded output)
+  // gid.y: wS (Filter location to unfold input)
+  // gid.x: C (channel)
+
+  int n = (gid.z) / out_pixels;
+  int oS = (gid.z) % out_pixels;
+  int wS = gid.y;
+
+  bool valid = n < params->N;
+
+  // Unroll dimensions
+  for (int i = N - 1; i >= 0; --i) {
+    int os_ = (oS % params->oS[i]);
+    int ws_ = (wS % params->wS[i]);
+
+    ws_ = params->flip ? params->wS[i] - ws_ - 1 : ws_;
+
+    int is_ = os_ * params->str[i] - params->pad[i] + ws_ * params->kdil[i];
+    int is_max = 1 + params->idil[i] * (params->iS[i] - 1);
+
+    valid &= is_ >= 0 && is_ < is_max && (is_ % params->idil[i] == 0);
+
+    is[i] = is_ / params->idil[i];
+
+    oS /= params->oS[i];
+    wS /= params->wS[i];
+  }
+
+  if (valid) {
+    size_t in_offset = n * params->in_strides[0];
+
+    for (int i = 0; i < N; ++i) {
+      in_offset += is[i] * params->in_strides[i + 1];
+    }
+
+    out[gid.x] = in[in_offset + gid.x];
+  } else {
+    out[gid.x] = T(0);
+  }
+}
+
+// This kernel unfolds the input array of size (N, *spatial_dims, C)
+// into an array of size (N x *spatial_dims, C x *kernel_dims).
+template <typename T, int N>
+[[kernel]] void naive_unfold_transpose_Nd(
+    const device T* in [[buffer(0)]],
+    device T* out [[buffer(1)]],
+    const constant MLXConvParams<N>* params [[buffer(2)]],
+    uint3 gid [[thread_position_in_grid]]) {
+  int filter_size = params->C;
+  for (short i = 0; i < N; i++)
+    filter_size *= params->wS[i];
+
+  int out_pixels = 1;
+  for (short i = 0; i < N; i++)
+    out_pixels *= params->oS[i];
+
+  // Set out
+  out += gid.z * filter_size + gid.x * (filter_size / params->C);
+
+  // Coordinates in input
+  int is[N] = {0};
+
+  // gid.z: N oS (Batch and row in unfolded output)
+  // gid.y: wS (Filter location to unfold input)
+  // gid.x: C (channel)
+
+  int n = (gid.z) / out_pixels;
+  int oS = (gid.z) % out_pixels;
+  int wS = gid.y;
+
+  bool valid = n < params->N;
+
+  // Unroll dimensions
+  int kernel_stride = 1;
+  for (int i = N - 1; i >= 0; --i) {
+    int os_ = (oS % params->oS[i]);
+    int ws_ = (wS % params->wS[i]);
+    out += ws_ * kernel_stride;
+
+    ws_ = params->flip ? params->wS[i] - ws_ - 1 : ws_;
+
+    int is_ = os_ * params->str[i] - params->pad[i] + ws_ * params->kdil[i];
+    int is_max = 1 + params->idil[i] * (params->iS[i] - 1);
+
+    valid &= is_ >= 0 && is_ < is_max && (is_ % params->idil[i] == 0);
+
+    is[i] = is_ / params->idil[i];
+
+    oS /= params->oS[i];
+    wS /= params->wS[i];
+
+    kernel_stride *= params->wS[i];
+  }
+
+  if (valid) {
+    size_t in_offset = n * params->in_strides[0];
+
+    for (int i = 0; i < N; ++i) {
+      in_offset += is[i] * params->in_strides[i + 1];
+    }
+
+    out[0] = in[in_offset + gid.x];
+  } else {
+    out[0] = T(0);
+  }
+}
+
+#define instantiate_naive_unfold_nd(name, itype, n)                            \
+  template [[host_name("naive_unfold_nd_" #name "_" #n)]] [[kernel]] void      \
+  naive_unfold_Nd(                                                             \
+      const device itype* in [[buffer(0)]],                                    \
+      device itype* out [[buffer(1)]],                                         \
+      const constant MLXConvParams<n>* params [[buffer(2)]],                   \
+      uint3 gid [[thread_position_in_grid]]);                                  \
+  template                                                                     \
+      [[host_name("naive_unfold_transpose_nd_" #name "_" #n)]] [[kernel]] void \
+      naive_unfold_transpose_Nd(                                               \
+          const device itype* in [[buffer(0)]],                                \
+          device itype* out [[buffer(1)]],                                     \
+          const constant MLXConvParams<n>* params [[buffer(2)]],               \
+          uint3 gid [[thread_position_in_grid]]);
+
+#define instantiate_naive_unfold_nd_dims(name, itype)                      \
+  instantiate_naive_unfold_nd(name, itype, 1) instantiate_naive_unfold_nd( \
+      name, itype, 2) instantiate_naive_unfold_nd(name, itype, 3)
+
+instantiate_naive_unfold_nd_dims(float32, float);
+instantiate_naive_unfold_nd_dims(float16, half);
+instantiate_naive_unfold_nd_dims(bfloat16, bfloat16_t);
+
+///////////////////////////////////////////////////////////////////////////////
+/// Depthwise convolution kernels
+///////////////////////////////////////////////////////////////////////////////
+
+constant int ker_h [[function_constant(00)]];
+constant int ker_w [[function_constant(01)]];
+constant int str_h [[function_constant(10)]];
+constant int str_w [[function_constant(11)]];
+constant int tgp_h [[function_constant(100)]];
+constant int tgp_w [[function_constant(101)]];
+constant bool do_flip [[function_constant(200)]];
+
+constant int span_h = tgp_h * str_h + ker_h - 1;
+constant int span_w = tgp_w * str_w + ker_w - 1;
+constant int span_hw = span_h * span_w;
+
+template <typename T>
+[[kernel]] void depthwise_conv_2d(
+    const device T* in [[buffer(0)]],
+    const device T* wt [[buffer(1)]],
+    device T* out [[buffer(2)]],
+    const constant MLXConvParams<2>& params [[buffer(3)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint3 gid [[thread_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  constexpr int tc = 8;
+  constexpr int tw = 8;
+  constexpr int th = 4;
+
+  constexpr int c_per_thr = 8;
+
+  constexpr int TGH = th * 2 + 6;
+  constexpr int TGW = tw * 2 + 6;
+  constexpr int TGC = tc;
+
+  threadgroup T ins[TGH * TGW * TGC];
+
+  const int n_tgblocks_h = params.oS[0] / th;
+  const int n = tid.z / n_tgblocks_h;
+  const int tghid = tid.z % n_tgblocks_h;
+  const int oh = tghid * th + lid.z;
+  const int ow = gid.y;
+  const int c = gid.x;
+
+  in += n * params.in_strides[0];
+
+  // Load in
+  {
+    constexpr int n_threads = th * tw * tc;
+    const int tg_oh = (tghid * th) * str_h - params.pad[0];
+    const int tg_ow = (tid.y * tw) * str_w - params.pad[1];
+    const int tg_c = tid.x * tc;
+
+    const int thread_idx = simd_gid * 32 + simd_lid;
+    constexpr int thr_per_hw = tc / c_per_thr;
+    constexpr int hw_per_group = n_threads / thr_per_hw;
+
+    const int thr_c = thread_idx % thr_per_hw;
+    const int thr_hw = thread_idx / thr_per_hw;
+
+    for (int hw = thr_hw; hw < span_hw; hw += hw_per_group) {
+      const int h = hw / span_w;
+      const int w = hw % span_w;
+
+      const int ih = tg_oh + h;
+      const int iw = tg_ow + w;
+
+      const int in_s_offset = h * span_w * TGC + w * TGC;
+
+      if (ih >= 0 && ih < params.iS[0] && iw >= 0 && iw < params.iS[1]) {
+        const auto in_load =
+            in + ih * params.in_strides[1] + iw * params.in_strides[2] + tg_c;
+
+        MLX_MTL_PRAGMA_UNROLL
+        for (int cc = 0; cc < c_per_thr; ++cc) {
+          ins[in_s_offset + c_per_thr * thr_c + cc] =
+              in_load[c_per_thr * thr_c + cc];
+        }
+      } else {
+        MLX_MTL_PRAGMA_UNROLL
+        for (int cc = 0; cc < c_per_thr; ++cc) {
+          ins[in_s_offset + c_per_thr * thr_c + cc] = T(0);
+        }
+      }
+    }
+  }
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  wt += c * params.wt_strides[0];
+
+  const auto ins_ptr =
+      &ins[lid.z * str_h * span_w * TGC + lid.y * str_w * TGC + lid.x];
+  float o = 0.;
+  for (int h = 0; h < ker_h; ++h) {
+    for (int w = 0; w < ker_w; ++w) {
+      int wt_h = h;
+      int wt_w = w;
+      if (do_flip) {
+        wt_h = ker_h - h - 1;
+        wt_w = ker_w - w - 1;
+      }
+      auto inv = ins_ptr[h * span_w * TGC + w * TGC];
+      auto wtv = wt[wt_h * ker_w + wt_w];
+      o += inv * wtv;
+    }
+  }
+  threadgroup_barrier(mem_flags::mem_none);
+
+  out += n * params.out_strides[0] + oh * params.out_strides[1] +
+      ow * params.out_strides[2];
+  out[c] = static_cast<T>(o);
+}
+
+#define instantiate_depthconv2d(iname, itype) \
+  instantiate_kernel("depthwise_conv_2d_" #iname, depthwise_conv_2d, itype)
+
+instantiate_depthconv2d(float32, float);
+instantiate_depthconv2d(float16, half);
+instantiate_depthconv2d(bfloat16, bfloat16_t);
+
+template <typename T, typename IdxT>
+[[kernel]] void depthwise_conv_1d(
+    const device T* in [[buffer(0)]],
+    const device T* w [[buffer(1)]],
+    device T* out [[buffer(2)]],
+    constant const IdxT strides[3],
+    constant const int& kernel_size,
+    uint3 tid [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {
+  out += (tid.z * static_cast<IdxT>(grid_dim.y) + tid.y) * grid_dim.x + tid.x;
+  in += tid.z * strides[0] + tid.y * strides[1] + tid.x * strides[2];
+  w += tid.x * kernel_size;
+
+  float acc = 0.0;
+  for (int i = 0; i < kernel_size; ++i) {
+    acc += static_cast<float>(in[0]) * w[i];
+    in += strides[1];
+  }
+  *out = static_cast<T>(acc);
+}
+
+#define instantiate_depthconv1d(iname, itype)                         \
+  instantiate_kernel(                                                 \
+      "depthwise_conv_1d_" #iname, depthwise_conv_1d, itype, int32_t) \
+      instantiate_kernel(                                             \
+          "depthwise_conv_1d_" #iname "_large",                       \
+          depthwise_conv_1d,                                          \
+          itype,                                                      \
+          int64_t)
+
+instantiate_depthconv1d(float32, float);
+instantiate_depthconv1d(float16, half);
+instantiate_depthconv1d(bfloat16, bfloat16_t);
+
+///////////////////////////////////////////////////////////////////////////////
+/// Winograd kernels
+///////////////////////////////////////////////////////////////////////////////
+
+template <int M, int R, int S>
+struct WinogradTransforms {};
+
+template <>
+struct WinogradTransforms<6, 3, 8> {
+  MLX_MTL_CONST int OUT_TILE_SIZE = 6;
+  MLX_MTL_CONST int FILTER_SIZE = 3;
+  MLX_MTL_CONST int IN_TILE_SIZE = OUT_TILE_SIZE + FILTER_SIZE - 1;
+  MLX_MTL_CONST int SIMD_MATRIX_SIZE = 8;
+  MLX_MTL_CONST float in_transform[SIMD_MATRIX_SIZE][SIMD_MATRIX_SIZE] = {
+      {1.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f},
+      {0.00f, 1.00f, -1.00f, 0.50f, -0.50f, 2.00f, -2.00f, -1.00f},
+      {-5.25f, 1.00f, 1.00f, 0.25f, 0.25f, 4.00f, 4.00f, 0.00f},
+      {0.00f, -4.25f, 4.25f, -2.50f, 2.50f, -2.50f, 2.50f, 5.25f},
+      {5.25f, -4.25f, -4.25f, -1.25f, -1.25f, -5.00f, -5.00f, 0.00f},
+      {0.00f, 1.00f, -1.00f, 2.00f, -2.00f, 0.50f, -0.50f, -5.25f},
+      {-1.00f, 1.00f, 1.00f, 1.00f, 1.00f, 1.00f, 1.00f, 0.00f},
+      {0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 1.00f},
+  };
+
+  MLX_MTL_CONST float out_transform[SIMD_MATRIX_SIZE][SIMD_MATRIX_SIZE] = {
+      {1.00f, 0.00f, 0.00f, 0.00f, 0.00f, 0.00f},
+      {1.00f, 1.00f, 1.00f, 1.00f, 1.00f, 1.00f},
+      {1.00f, -1.00f, 1.00f, -1.00f, 1.00f, -1.00f},
+      {1.00f, 2.00f, 4.00f, 8.00f, 16.00f, 32.00f},
+      {1.00f, -2.00f, 4.00f, -8.00f, 16.00f, -32.00f},
+      {1.00f, 0.50f, 0.25f, 0.125f, 0.0625f, 0.03125f},
+      {1.00f, -0.50f, 0.25f, -0.125f, 0.0625f, -0.03125f},
+      {0.00f, 0.00f, 0.00f, 0.00f, 0.00f, 1.00f},
+  };
+
+  MLX_MTL_CONST float wt_transform[SIMD_MATRIX_SIZE][SIMD_MATRIX_SIZE] = {
+      {1.00, 0.00, 0.00},
+      {-2.0 / 9.00, -2.0 / 9.00, -2.0 / 9.00},
+      {-2.0 / 9.00, 2.0 / 9.00, -2.0 / 9.00},
+      {1.0 / 90.0, 1.0 / 45.0, 2.0 / 45.0},
+      {1.0 / 90.0, -1.0 / 45.0, 2.0 / 45.0},
+      {32.0 / 45.0, 16.0 / 45.0, 8.0 / 45.0},
+      {32.0 / 45.0, -16.0 / 45.0, 8.0 / 45.0},
+      {0.00, 0.00, 1.00},
+  };
+};
+
+constant constexpr const float WinogradTransforms<6, 3, 8>::wt_transform[8][8];
+constant constexpr const float WinogradTransforms<6, 3, 8>::in_transform[8][8];
+constant constexpr const float WinogradTransforms<6, 3, 8>::out_transform[8][8];
+
+template <typename T, int BC = 32, int BO = 4, int M = 6, int R = 3>
+[[kernel, max_total_threads_per_threadgroup(BO * 32)]] void
+winograd_conv_2d_weight_transform(
+    const device T* wt_in [[buffer(0)]],
+    device T* wt_out [[buffer(1)]],
+    const constant int& C [[buffer(2)]],
+    const constant int& O [[buffer(3)]],
+    uint tid [[threadgroup_position_in_grid]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]]) {
+  using WGT = WinogradTransforms<M, R, 8>;
+
+  // Get lane position in simdgroup
+  const short qid = simd_lane_id / 4;
+  const short sm = (qid & 4) + (simd_lane_id / 2) % 4;
+  const short sn = (qid & 2) * 2 + (simd_lane_id % 2) * 2;
+
+  // Initialize G matrix
+  simdgroup_matrix<float, 8, 8> G;
+  G.thread_elements()[0] = WGT::wt_transform[sm][sn];
+  G.thread_elements()[1] = WGT::wt_transform[sm][sn + 1];
+
+  // Initialize Gt matrix
+  simdgroup_matrix<float, 8, 8> Gt;
+  Gt.thread_elements()[0] = WGT::wt_transform[sn][sm];
+  Gt.thread_elements()[1] = WGT::wt_transform[sn + 1][sm];
+
+  // Move to the correct output filter
+  size_t ko = BO * tid + simd_group_id;
+  wt_in += ko * R * R * C;
+
+  // wt_out is stored transposed (A x A x C x O)
+  short ohw_0 = sm * 8 + sn;
+  short ohw_1 = sm * 8 + sn + 1;
+  device T* wt_out_0 = wt_out + ohw_0 * C * O + ko;
+  device T* wt_out_1 = wt_out + ohw_1 * C * O + ko;
+
+  // Prepare shared memory
+  threadgroup T Ws[BO][R][R][BC];
+
+  // Loop over C
+  for (int bc = 0; bc < C; bc += BC) {
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    // Read into shared memory
+    for (int kh = 0; kh < R; ++kh) {
+      for (int kw = 0; kw < R; ++kw) {
+        for (int kc = simd_lane_id; kc < BC; kc += 32) {
+          Ws[simd_group_id][kh][kw][kc] = wt_in[kh * R * C + kw * C + kc];
+        }
+      }
+    }
+
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    // Do transform and store the result
+    for (int c = 0; c < BC; ++c) {
+      simdgroup_matrix<float, 8, 8> g;
+      g.thread_elements()[0] =
+          sm < R && sn < R ? Ws[simd_group_id][sm][sn][c] : T(0);
+      g.thread_elements()[1] =
+          sm < R && sn + 1 < R ? Ws[simd_group_id][sm][sn + 1][c] : T(0);
+
+      simdgroup_matrix<float, 8, 8> g_out = (G * g) * Gt;
+      wt_out_0[c * O] = static_cast<T>(g_out.thread_elements()[0]);
+      wt_out_1[c * O] = static_cast<T>(g_out.thread_elements()[1]);
+    }
+
+    wt_in += BC;
+    wt_out_0 += BC * O;
+    wt_out_1 += BC * O;
+  }
+}
+
+#define instantiate_winograd_conv_2d_weight_transform_base(name, itype, bc) \
+  template [[host_name("winograd_conv_2d_weight_transform_" #name           \
+                       "_bc" #bc)]] [[kernel]] void                         \
+  winograd_conv_2d_weight_transform<itype, bc>(                             \
+      const device itype* wt_in [[buffer(0)]],                              \
+      device itype* wt_out [[buffer(1)]],                                   \
+      const constant int& C [[buffer(2)]],                                  \
+      const constant int& O [[buffer(3)]],                                  \
+      uint tid [[threadgroup_position_in_grid]],                            \
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],                \
+      uint simd_lane_id [[thread_index_in_simdgroup]]);
+
+template <typename T, int BC, int WM, int WN, int M = 6, int R = 3>
+[[kernel, max_total_threads_per_threadgroup(WM* WN * 32)]] void
+winograd_conv_2d_input_transform(
+    const device T* inp_in [[buffer(0)]],
+    device T* inp_out [[buffer(1)]],
+    const constant MLXConvParams<2>& params [[buffer(2)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint3 tgp_per_grid [[threadgroups_per_grid]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]]) {
+  (void)lid;
+
+  using WGT = WinogradTransforms<M, R, 8>;
+  constexpr int A = WGT::IN_TILE_SIZE;
+  constexpr int N_SIMD_GROUPS = WM * WN;
+
+  // Get lane position in simdgroup
+  const short qid = simd_lane_id / 4;
+  const short sm = (qid & 4) + (simd_lane_id / 2) % 4;
+  const short sn = (qid & 2) * 2 + (simd_lane_id % 2) * 2;
+
+  // Initialize B matrix
+  simdgroup_matrix<float, 8, 8> B;
+  B.thread_elements()[0] = WGT::in_transform[sm][sn];
+  B.thread_elements()[1] = WGT::in_transform[sm][sn + 1];
+
+  // Initialize Bt matrix
+  simdgroup_matrix<float, 8, 8> Bt;
+  Bt.thread_elements()[0] = WGT::in_transform[sn][sm];
+  Bt.thread_elements()[1] = WGT::in_transform[sn + 1][sm];
+
+  // Resolve input tile
+  constexpr int TH = (A / WM);
+  constexpr int TW = (A / WN);
+  int kh = TH * (simd_group_id / WN);
+  int kw = TW * (simd_group_id % WN);
+  int bh = M * tid.y + kh;
+  int bw = M * tid.x + kw;
+
+  // Move to the correct input tile
+  inp_in += tid.z * params.in_strides[0] + bh * params.in_strides[1] +
+      bw * params.in_strides[2];
+
+  // Pre compute strides
+  int jump_in[TH][TW];
+
+  for (int h = 0; h < TH; h++) {
+    for (int w = 0; w < TW; w++) {
+      jump_in[h][w] = h * params.in_strides[1] + w * params.in_strides[2];
+    }
+  }
+
+  // inp_out is stored interleaved (A x A x tiles x C)
+  size_t N_TILES = tgp_per_grid.x * tgp_per_grid.y * tgp_per_grid.z;
+  size_t tile_id =
+      tid.z * tgp_per_grid.x * tgp_per_grid.y + tid.y * tgp_per_grid.x + tid.x;
+  size_t ohw_0 = sm * 8 + sn;
+  size_t ohw_1 = sm * 8 + sn + 1;
+  device T* inp_out_0 =
+      inp_out + ohw_0 * N_TILES * params.C + tile_id * params.C;
+  device T* inp_out_1 =
+      inp_out + ohw_1 * N_TILES * params.C + tile_id * params.C;
+
+  // Prepare shared memory
+  threadgroup T Is[A][A][BC];
+
+  // Loop over C
+  for (int bc = 0; bc < params.C; bc += BC) {
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    // Read into shared memory
+    for (int h = 0; h < TH; h++) {
+      for (int w = 0; w < TW; w++) {
+        const device T* in_ptr = inp_in + jump_in[h][w];
+        for (int c = simd_lane_id; c < BC; c += 32) {
+          Is[kh + h][kw + w][c] = in_ptr[c];
+        }
+      }
+    }
+
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    // Do transform and store the result
+    for (int c = simd_group_id; c < BC; c += N_SIMD_GROUPS) {
+      simdgroup_matrix<float, 8, 8> I;
+      I.thread_elements()[0] = Is[sm][sn][c];
+      I.thread_elements()[1] = Is[sm][sn + 1][c];
+
+      simdgroup_matrix<float, 8, 8> I_out = (Bt * I) * B;
+      inp_out_0[c] = static_cast<T>(I_out.thread_elements()[0]);
+      inp_out_1[c] = static_cast<T>(I_out.thread_elements()[1]);
+    }
+
+    inp_in += BC;
+    inp_out_0 += BC;
+    inp_out_1 += BC;
+  }
+}
+
+#define instantiate_winograd_conv_2d_input_transform(name, itype, bc) \
+  template [[host_name("winograd_conv_2d_input_transform_" #name      \
+                       "_bc" #bc)]] [[kernel]] void                   \
+  winograd_conv_2d_input_transform<itype, bc, 2, 2>(                  \
+      const device itype* inp_in [[buffer(0)]],                       \
+      device itype* inp_out [[buffer(1)]],                            \
+      const constant MLXConvParams<2>& params [[buffer(2)]],          \
+      uint3 tid [[threadgroup_position_in_grid]],                     \
+      uint3 lid [[thread_position_in_threadgroup]],                   \
+      uint3 tgp_per_grid [[threadgroups_per_grid]],                   \
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],          \
+      uint simd_lane_id [[thread_index_in_simdgroup]]);
+
+template <typename T, int BO, int WM, int WN, int M = 6, int R = 3>
+[[kernel, max_total_threads_per_threadgroup(WM* WN * 32)]] void
+winograd_conv_2d_output_transform(
+    const device T* out_in [[buffer(0)]],
+    device T* out_out [[buffer(1)]],
+    const constant MLXConvParams<2>& params [[buffer(2)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint3 tgp_per_grid [[threadgroups_per_grid]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]]) {
+  (void)lid;
+
+  using WGT = WinogradTransforms<M, R, 8>;
+  constexpr int N_SIMD_GROUPS = WM * WN;
+
+  // Get lane position in simdgroup
+  const short qid = simd_lane_id / 4;
+  const short sm = (qid & 4) + (simd_lane_id / 2) % 4;
+  const short sn = (qid & 2) * 2 + (simd_lane_id % 2) * 2;
+
+  // Initialize A matrix
+  simdgroup_matrix<float, 8, 8> B;
+  B.thread_elements()[0] = WGT::out_transform[sm][sn];
+  B.thread_elements()[1] = WGT::out_transform[sm][sn + 1];
+
+  // Initialize At matrix
+  simdgroup_matrix<float, 8, 8> Bt;
+  Bt.thread_elements()[0] = WGT::out_transform[sn][sm];
+  Bt.thread_elements()[1] = WGT::out_transform[sn + 1][sm];
+
+  // Out_in comes in shape (A x A x tiles x O)
+  // We do transform and then write out to out_out in shape (N, H, W, O)
+
+  // Resolve output tile
+  constexpr int TH = (M / WM);
+  constexpr int TW = (M / WN);
+  int kh = TH * (simd_group_id / WN);
+  int kw = TW * (simd_group_id % WN);
+  int bh = M * tid.y + kh;
+  int bw = M * tid.x + kw;
+
+  // Move to the correct input tile
+  out_out += tid.z * params.out_strides[0] + bh * params.out_strides[1] +
+      bw * params.out_strides[2];
+
+  // Pre compute strides
+  int jump_in[TH][TW];
+
+  for (int h = 0; h < TH; h++) {
+    for (int w = 0; w < TW; w++) {
+      bool valid = ((bh + h) < params.oS[0]) && ((bw + w) < params.oS[1]);
+      jump_in[h][w] =
+          valid ? h * params.out_strides[1] + w * params.out_strides[2] : -1;
+    }
+  }
+
+  // out_in is stored interleaved (A x A x tiles x O)
+  size_t N_TILES = tgp_per_grid.x * tgp_per_grid.y * tgp_per_grid.z;
+  size_t tile_id =
+      tid.z * tgp_per_grid.x * tgp_per_grid.y + tid.y * tgp_per_grid.x + tid.x;
+  size_t ohw_0 = sm * 8 + sn;
+  size_t ohw_1 = sm * 8 + sn + 1;
+  const device T* out_in_0 =
+      out_in + ohw_0 * N_TILES * params.O + tile_id * params.O;
+  const device T* out_in_1 =
+      out_in + ohw_1 * N_TILES * params.O + tile_id * params.O;
+
+  // Prepare shared memory
+  threadgroup T Os[M][M][BO];
+
+  // Loop over O
+  for (int bo = 0; bo < params.O; bo += BO) {
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    // Do transform and store the result
+    for (int c = simd_group_id; c < BO; c += N_SIMD_GROUPS) {
+      simdgroup_matrix<float, 8, 8> O_mat;
+      O_mat.thread_elements()[0] = out_in_0[c];
+      O_mat.thread_elements()[1] = out_in_1[c];
+
+      simdgroup_matrix<float, 8, 8> O_out = (Bt * (O_mat * B));
+      if ((sm < M) && (sn < M)) {
+        Os[sm][sn][c] = static_cast<T>(O_out.thread_elements()[0]);
+      }
+      if ((sm < M) && ((sn + 1) < M)) {
+        Os[sm][sn + 1][c] = static_cast<T>(O_out.thread_elements()[1]);
+      }
+    }
+
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    // Read out from shared memory
+    for (int h = 0; h < TH; h++) {
+      for (int w = 0; w < TW; w++) {
+        if (jump_in[h][w] >= 0) {
+          device T* out_ptr = out_out + jump_in[h][w];
+          for (int c = simd_lane_id; c < BO; c += 32) {
+            out_ptr[c] = Os[kh + h][kw + w][c];
+          }
+        }
+      }
+    }
+
+    out_out += BO;
+    out_in_0 += BO;
+    out_in_1 += BO;
+  }
+}
+
+#define instantiate_winograd_conv_2d_output_transform(name, itype, bo) \
+  template [[host_name("winograd_conv_2d_output_transform_" #name      \
+                       "_bo" #bo)]] [[kernel]] void                    \
+  winograd_conv_2d_output_transform<itype, bo, 2, 2>(                  \
+      const device itype* out_in [[buffer(0)]],                        \
+      device itype* out_out [[buffer(1)]],                             \
+      const constant MLXConvParams<2>& params [[buffer(2)]],           \
+      uint3 tid [[threadgroup_position_in_grid]],                      \
+      uint3 lid [[thread_position_in_threadgroup]],                    \
+      uint3 tgp_per_grid [[threadgroups_per_grid]],                    \
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],           \
+      uint simd_lane_id [[thread_index_in_simdgroup]]);
+
+// clang-format off
+#define instantiate_winograd_conv_2d(name, itype)                     \
+  instantiate_winograd_conv_2d_weight_transform_base(name, itype, 32) \
+  instantiate_winograd_conv_2d_input_transform(name, itype, 32)       \
+  instantiate_winograd_conv_2d_output_transform(name, itype, 32) // clang-format on
+
+// clang-format off
+instantiate_winograd_conv_2d(float32, float);
+instantiate_winograd_conv_2d(bfloat16, bfloat16_t);
+instantiate_winograd_conv_2d(float16, half); // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/copy.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/copy.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf22347ee51393616ac1ce464529e65f5068bc73
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/copy.h
@@ -0,0 +1,276 @@
+// Copyright © 2024 Apple Inc.
+
+template <typename T, typename U, int N = WorkPerThread<U>::n>
+[[kernel]] void copy_s(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant uint& size,
+    uint index [[thread_position_in_grid]]) {
+  index *= N;
+  if (N > 1 && index + N > size) {
+    for (int i = 0; index + i < size; ++i) {
+      dst[index + i] = static_cast<U>(src[0]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      dst[index + i] = static_cast<U>(src[0]);
+    }
+  }
+}
+
+template <typename T, typename U, int N = WorkPerThread<U>::n>
+[[kernel]] void copy_v(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant uint& size,
+    uint index [[thread_position_in_grid]]) {
+  index *= N;
+  if (N > 1 && index + N > size) {
+    for (int i = 0; index + i < size; ++i) {
+      dst[index + i] = static_cast<U>(src[index + i]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      dst[index + i] = static_cast<U>(src[index + i]);
+    }
+  }
+}
+
+template <typename T, typename U, int N = WorkPerThread<U>::n>
+[[kernel]] void copy_s2(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant int64_t& size,
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  int64_t offset = N * (index.x + grid_dim.x * int64_t(index.y));
+  if (N > 1 && offset + N > size) {
+    for (int i = 0; offset + i < size; ++i) {
+      dst[offset + i] = static_cast<U>(src[0]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      dst[offset + i] = static_cast<U>(src[0]);
+    }
+  }
+}
+
+template <typename T, typename U, int N = WorkPerThread<U>::n>
+[[kernel]] void copy_v2(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant int64_t& size,
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  int64_t offset = N * (index.x + grid_dim.x * int64_t(index.y));
+  if (N > 1 && offset + N > size) {
+    for (int i = 0; offset + i < size; ++i) {
+      dst[offset + i] = static_cast<U>(src[offset + i]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      dst[offset + i] = static_cast<U>(src[offset + i]);
+    }
+  }
+}
+
+template <typename T, typename U, typename IdxT = int64_t>
+[[kernel]] void copy_g_nd1(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant const int64_t& src_stride [[buffer(3)]],
+    uint index [[thread_position_in_grid]]) {
+  auto src_idx = elem_to_loc_1<IdxT>(index, src_stride);
+  dst[index] = static_cast<U>(src[src_idx]);
+}
+
+template <typename T, typename U, typename IdxT = int64_t>
+[[kernel]] void copy_g_nd2(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant const int64_t* src_strides [[buffer(3)]],
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  auto src_idx = elem_to_loc_2<IdxT>(index, src_strides);
+  IdxT dst_idx = index.x + IdxT(grid_dim.x) * index.y;
+  dst[dst_idx] = static_cast<U>(src[src_idx]);
+}
+
+template <typename T, typename U, typename IdxT = int64_t>
+[[kernel]] void copy_g_nd3(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant const int64_t* src_strides [[buffer(3)]],
+    uint3 index [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {
+  auto src_idx = elem_to_loc_3<IdxT>(index, src_strides);
+  IdxT dst_idx =
+      index.x + IdxT(grid_dim.x) * (index.y + IdxT(grid_dim.y) * index.z);
+  dst[dst_idx] = static_cast<U>(src[src_idx]);
+}
+
+template <typename T, typename U, int N = 1, typename IdxT = int64_t>
+[[kernel]] void copy_g(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant const int* src_shape [[buffer(2)]],
+    constant const int64_t* src_strides [[buffer(3)]],
+    constant const int& ndim [[buffer(5)]],
+    uint3 index [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {
+  auto src_idx = elem_to_loc<IdxT>(
+      {N * index.x, index.y, index.z}, src_shape, src_strides, ndim);
+  if (N == 1) {
+    IdxT dst_idx =
+        index.x + grid_dim.x * (index.y + IdxT(grid_dim.y) * index.z);
+    dst[dst_idx] = static_cast<U>(src[src_idx]);
+    return;
+  }
+  auto xshape = src_shape[ndim - 1];
+  IdxT dst_idx = N * index.x + xshape * (index.y + IdxT(grid_dim.y) * index.z);
+  auto src_xstride = src_strides[ndim - 1];
+  for (int i = 0; i < N && (int(N * index.x) + i) < xshape; ++i) {
+    dst[dst_idx + i] = static_cast<U>(src[src_idx]);
+    src_idx += src_xstride;
+  }
+}
+
+template <typename T, typename U, typename IdxT = int64_t>
+[[kernel]] void copy_gg_nd1(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant const int64_t& src_stride [[buffer(3)]],
+    constant const int64_t& dst_stride [[buffer(4)]],
+    uint index [[thread_position_in_grid]]) {
+  auto src_idx = elem_to_loc_1<IdxT>(index, src_stride);
+  auto dst_idx = elem_to_loc_1<IdxT>(index, dst_stride);
+  dst[dst_idx] = static_cast<U>(src[src_idx]);
+}
+
+template <typename T, typename U, typename IdxT = int64_t>
+[[kernel]] void copy_gg_nd2(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant const int64_t* src_strides [[buffer(3)]],
+    constant const int64_t* dst_strides [[buffer(4)]],
+    uint2 index [[thread_position_in_grid]]) {
+  auto src_idx = elem_to_loc_2<IdxT>(index, src_strides);
+  auto dst_idx = elem_to_loc_2<IdxT>(index, dst_strides);
+  dst[dst_idx] = static_cast<U>(src[src_idx]);
+}
+
+template <typename T, typename U, typename IdxT = int64_t>
+[[kernel]] void copy_gg_nd3(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant const int64_t* src_strides [[buffer(3)]],
+    constant const int64_t* dst_strides [[buffer(4)]],
+    uint3 index [[thread_position_in_grid]]) {
+  auto src_idx = elem_to_loc_3<IdxT>(index, src_strides);
+  auto dst_idx = elem_to_loc_3<IdxT>(index, dst_strides);
+  dst[dst_idx] = static_cast<U>(src[src_idx]);
+}
+
+template <typename T, typename U, int N = 1, typename IdxT = int64_t>
+[[kernel]] void copy_gg(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant const int* src_shape [[buffer(2)]],
+    constant const int64_t* src_strides [[buffer(3)]],
+    constant const int64_t* dst_strides [[buffer(4)]],
+    constant const int& ndim [[buffer(5)]],
+    uint3 index [[thread_position_in_grid]]) {
+  auto idx = elem_to_loc_2_nd<IdxT>(
+      {N * index.x, index.y, index.z},
+      src_shape,
+      src_strides,
+      dst_strides,
+      ndim);
+  if (N == 1) {
+    dst[idx.y] = static_cast<U>(src[idx.x]);
+    return;
+  }
+  IdxT src_xstride = src_strides[ndim - 1];
+  IdxT dst_xstride = dst_strides[ndim - 1];
+  auto xshape = src_shape[ndim - 1];
+  for (int i = 0; i < N && (int(N * index.x) + i) < xshape; ++i) {
+    dst[idx.y] = static_cast<U>(src[idx.x]);
+    idx.x += src_xstride;
+    idx.y += dst_xstride;
+  }
+}
+
+template <typename T, typename U, typename IdxT = int64_t>
+[[kernel]] void copy_gg_dynamic_nd1(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant const int64_t& src_stride [[buffer(3)]],
+    constant const int64_t& dst_stride [[buffer(4)]],
+    constant const int64_t& src_offset [[buffer(6)]],
+    constant const int64_t& dst_offset [[buffer(7)]],
+    uint index [[thread_position_in_grid]]) {
+  auto src_idx = elem_to_loc_1<IdxT>(index, src_stride);
+  auto dst_idx = elem_to_loc_1<IdxT>(index, dst_stride);
+  dst[dst_idx + dst_offset] = src[src_idx + src_offset];
+}
+
+template <typename T, typename U, typename IdxT = int64_t>
+[[kernel]] void copy_gg_dynamic_nd2(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant const int64_t* src_strides [[buffer(3)]],
+    constant const int64_t* dst_strides [[buffer(4)]],
+    constant const int64_t& src_offset [[buffer(6)]],
+    constant const int64_t& dst_offset [[buffer(7)]],
+    uint2 index [[thread_position_in_grid]]) {
+  auto src_idx = elem_to_loc_2<IdxT>(index, src_strides);
+  auto dst_idx = elem_to_loc_2<IdxT>(index, dst_strides);
+  dst[dst_idx + dst_offset] = src[src_idx + src_offset];
+}
+
+template <typename T, typename U, typename IdxT = int64_t>
+[[kernel]] void copy_gg_dynamic_nd3(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant const int64_t* src_strides [[buffer(3)]],
+    constant const int64_t* dst_strides [[buffer(4)]],
+    constant const int64_t& src_offset [[buffer(6)]],
+    constant const int64_t& dst_offset [[buffer(7)]],
+    uint3 index [[thread_position_in_grid]]) {
+  auto src_idx = elem_to_loc_3<IdxT>(index, src_strides);
+  auto dst_idx = elem_to_loc_3<IdxT>(index, dst_strides);
+  dst[dst_idx + dst_offset] = src[src_idx + src_offset];
+}
+
+template <typename T, typename U, int N = 1, typename IdxT = int64_t>
+[[kernel]] void copy_gg_dynamic(
+    device const T* src [[buffer(0)]],
+    device U* dst [[buffer(1)]],
+    constant const int* src_shape [[buffer(2)]],
+    constant const int64_t* src_strides [[buffer(3)]],
+    constant const int64_t* dst_strides [[buffer(4)]],
+    constant const int& ndim [[buffer(5)]],
+    constant const int64_t& src_offset [[buffer(6)]],
+    constant const int64_t& dst_offset [[buffer(7)]],
+    uint3 index [[thread_position_in_grid]]) {
+  src += src_offset;
+  dst += dst_offset;
+  auto idx = elem_to_loc_2_nd<IdxT>(
+      {N * index.x, index.y, index.z},
+      src_shape,
+      src_strides,
+      dst_strides,
+      ndim);
+  if (N == 1) {
+    dst[idx.y] = src[idx.x];
+    return;
+  }
+  IdxT src_xstride = src_strides[ndim - 1];
+  IdxT dst_xstride = dst_strides[ndim - 1];
+  auto xshape = src_shape[ndim - 1];
+  for (int i = 0; i < N && (int(N * index.x) + i) < xshape; ++i) {
+    dst[idx.y] = src[idx.x];
+    idx.x += src_xstride;
+    idx.y += dst_xstride;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/copy.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/copy.metal
new file mode 100644
index 0000000000000000000000000000000000000000..fcf8884f83deaf84b5781a3dc8e817bd0ae25f6f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/copy.metal
@@ -0,0 +1,75 @@
+// Copyright © 2024 Apple Inc.
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/copy.h"
+
+#define instantiate_copy_work_per_thread(tname, itype, otype)         \
+  instantiate_kernel("sn_copy" #tname, copy_s, itype, otype)          \
+  instantiate_kernel("vn_copy" #tname, copy_v, itype, otype)
+
+#define instantiate_copy_base(tname, itype, otype)                    \
+  instantiate_kernel("s_copy" #tname, copy_s, itype, otype, 1)        \
+  instantiate_kernel("v_copy" #tname, copy_v, itype, otype, 1)        \
+  instantiate_kernel("s2_copy" #tname, copy_s2, itype, otype)         \
+  instantiate_kernel("v2_copy" #tname, copy_v2, itype, otype)         \
+  instantiate_kernel("g1_copy" #tname, copy_g_nd1, itype, otype, int) \
+  instantiate_kernel("g2_copy" #tname, copy_g_nd2, itype, otype, int) \
+  instantiate_kernel("g3_copy" #tname, copy_g_nd3, itype, otype, int) \
+  instantiate_kernel("gn2_copy" #tname, copy_g, itype, otype, 2, int) \
+  instantiate_kernel("g1large_copy" #tname, copy_g_nd1, itype, otype) \
+  instantiate_kernel("g2large_copy" #tname, copy_g_nd2, itype, otype) \
+  instantiate_kernel("g3large_copy" #tname, copy_g_nd3, itype, otype) \
+  instantiate_kernel("gn4large_copy" #tname, copy_g, itype, otype, 4)
+
+#define instantiate_copy_all(tname, itype, otype) \
+  instantiate_copy_base(tname, itype, otype)      \
+  instantiate_copy_work_per_thread(tname, itype, otype)
+
+#define instantiate_copy_same(tname, type)                                            \
+  instantiate_kernel("gg1_copy" #tname, copy_gg_nd1, type, type, int)                 \
+  instantiate_kernel("gg2_copy" #tname, copy_gg_nd2, type, type, int)                 \
+  instantiate_kernel("gg3_copy" #tname, copy_gg_nd3, type, type, int)                 \
+  instantiate_kernel("ggn2_copy" #tname, copy_gg, type, type, 2, int)                 \
+  instantiate_kernel("gg1large_copy" #tname, copy_gg_nd1, type, type)                 \
+  instantiate_kernel("gg2large_copy" #tname, copy_gg_nd2, type, type)                 \
+  instantiate_kernel("gg3large_copy" #tname, copy_gg_nd3, type, type)                 \
+  instantiate_kernel("ggn4large_copy" #tname, copy_gg, type, type, 4)                 \
+  instantiate_kernel("gg1_dynamic_copy" #tname, copy_gg_dynamic_nd1, type, type, int) \
+  instantiate_kernel("gg2_dynamic_copy" #tname, copy_gg_dynamic_nd2, type, type, int) \
+  instantiate_kernel("gg3_dynamic_copy" #tname, copy_gg_dynamic_nd3, type, type, int) \
+  instantiate_kernel("ggn2_dynamic_copy" #tname, copy_gg_dynamic, type, type, 2, int) \
+  instantiate_kernel("gg1large_dynamic_copy" #tname, copy_gg_dynamic_nd1, type, type) \
+  instantiate_kernel("gg2large_dynamic_copy" #tname, copy_gg_dynamic_nd2, type, type) \
+  instantiate_kernel("gg3large_dynamic_copy" #tname, copy_gg_dynamic_nd3, type, type) \
+  instantiate_kernel("ggn4large_dynamic_copy" #tname, copy_gg_dynamic, type, type, 4)
+
+#define instantiate_copy_itype(itname, itype)                \
+  instantiate_copy_same(itname ##itname, itype)              \
+  instantiate_copy_all(itname ##bool_, itype, bool)          \
+  instantiate_copy_all(itname ##uint8, itype, uint8_t)       \
+  instantiate_copy_all(itname ##uint16, itype, uint16_t)     \
+  instantiate_copy_all(itname ##uint32, itype, uint32_t)     \
+  instantiate_copy_base(itname ##uint64, itype, uint64_t)    \
+  instantiate_copy_all(itname ##int8, itype, int8_t)         \
+  instantiate_copy_all(itname ##int16, itype, int16_t)       \
+  instantiate_copy_all(itname ##int32, itype, int32_t)       \
+  instantiate_copy_base(itname ##int64, itype, int64_t)      \
+  instantiate_copy_all(itname ##float16, itype, half)        \
+  instantiate_copy_all(itname ##float32, itype, float)       \
+  instantiate_copy_all(itname ##bfloat16, itype, bfloat16_t) \
+  instantiate_copy_base(itname ##complex64, itype, complex64_t)
+
+instantiate_copy_itype(bool_, bool)
+instantiate_copy_itype(uint8, uint8_t)
+instantiate_copy_itype(uint16, uint16_t)
+instantiate_copy_itype(uint32, uint32_t)
+instantiate_copy_itype(uint64, uint64_t)
+instantiate_copy_itype(int8, int8_t)
+instantiate_copy_itype(int16, int16_t)
+instantiate_copy_itype(int32, int32_t)
+instantiate_copy_itype(int64, int64_t)
+instantiate_copy_itype(float16, half)
+instantiate_copy_itype(float32, float)
+instantiate_copy_itype(bfloat16, bfloat16_t)
+instantiate_copy_itype(complex64, complex64_t) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/defines.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/defines.h
new file mode 100644
index 0000000000000000000000000000000000000000..c369adb7e8550865556b857aa37aa585dd1f0eeb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/defines.h
@@ -0,0 +1,24 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#if defined __METAL__ || defined MLX_METAL_JIT
+#define MTL_CONST constant
+#else
+#define MTL_CONST
+#endif
+
+static MTL_CONST constexpr int MAX_REDUCE_SPECIALIZED_DIMS = 4;
+static MTL_CONST constexpr int REDUCE_N_READS = 4;
+static MTL_CONST constexpr int REDUCE_N_WRITES = 4;
+static MTL_CONST constexpr int SOFTMAX_N_READS = 4;
+static MTL_CONST constexpr int RMS_N_READS = 4;
+static MTL_CONST constexpr int RMS_LOOPED_LIMIT = 4096;
+
+// Instantiate a templated kernel.
+// Extra args are used as template parameters:
+// e.g. instantiate_kernel(binary_int, binary, a, b) ->
+// [[host_name(binary_int)]] [kernel] binary<a, b>
+#define instantiate_kernel(name, func, ...) \
+  template [[host_name(                     \
+      name)]] [[kernel]] decltype(func<__VA_ARGS__>) func<__VA_ARGS__>;
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/erf.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/erf.h
new file mode 100644
index 0000000000000000000000000000000000000000..da6c2eacd017bc3a6e18e0e39bd24a0faabc227a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/erf.h
@@ -0,0 +1,69 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+#include <metal_math>
+
+/*
+ * Approximation to the error function.
+ * Based on code from:
+ * https://stackoverflow.com/questions/35148198/efficient-faithfully-rounded-implementation-of-error-function-erff#answer-35148199
+ */
+float erf(float a) {
+  float r, s, t, u;
+  t = metal::abs(a);
+  s = a * a;
+  if (t > 0.927734375f) {
+    // maximum error 0.99527 ulp
+    r = metal::fma(
+        -1.72853470e-5f, t, 3.83197126e-4f); // -0x1.220000p-16,0x1.91cfb2p-12
+    u = metal::fma(
+        -3.88396438e-3f, t, 2.42546219e-2f); // -0x1.fd1438p-9, 0x1.8d6342p-6
+    r = metal::fma(r, s, u);
+    r = metal::fma(r, t, -1.06777877e-1f); // -0x1.b55cb8p-4
+    r = metal::fma(r, t, -6.34846687e-1f); // -0x1.450aa0p-1
+    r = metal::fma(r, t, -1.28717512e-1f); // -0x1.079d0cp-3
+    r = metal::fma(r, t, -t);
+    // TODO, replace with expm1 when implemented
+    r = 1.0f - metal::exp(r);
+    r = metal::copysign(r, a);
+  } else {
+    // maximum error 0.98929 ulp
+    r = -5.96761703e-4f; // -0x1.38e000p-11
+    r = metal::fma(r, s, 4.99119423e-3f); //  0x1.471a58p-8
+    r = metal::fma(r, s, -2.67681349e-2f); // -0x1.b691b2p-6
+    r = metal::fma(r, s, 1.12819925e-1f); //  0x1.ce1c44p-4
+    r = metal::fma(r, s, -3.76125336e-1f); // -0x1.812700p-2
+    r = metal::fma(r, s, 1.28379166e-1f); //  0x1.06eba8p-3
+    r = metal::fma(r, a, a);
+  }
+  return r;
+}
+
+float erfinv(float a) {
+  auto t = metal::fma(a, 0.0f - a, 1.0f);
+  t = metal::log(t);
+  float p;
+  if (metal::abs(t) > 6.125f) { // maximum ulp error = 2.35793
+    p = 3.03697567e-10f; //  0x1.4deb44p-32
+    p = metal::fma(p, t, 2.93243101e-8f); //  0x1.f7c9aep-26
+    p = metal::fma(p, t, 1.22150334e-6f); //  0x1.47e512p-20
+    p = metal::fma(p, t, 2.84108955e-5f); //  0x1.dca7dep-16
+    p = metal::fma(p, t, 3.93552968e-4f); //  0x1.9cab92p-12
+    p = metal::fma(p, t, 3.02698812e-3f); //  0x1.8cc0dep-9
+    p = metal::fma(p, t, 4.83185798e-3f); //  0x1.3ca920p-8
+    p = metal::fma(p, t, -2.64646143e-1f); // -0x1.0eff66p-2
+    p = metal::fma(p, t, 8.40016484e-1f); //  0x1.ae16a4p-1
+  } else { // maximum ulp error = 2.35002
+    p = 5.43877832e-9f; //  0x1.75c000p-28
+    p = metal::fma(p, t, 1.43285448e-7f); //  0x1.33b402p-23
+    p = metal::fma(p, t, 1.22774793e-6f); //  0x1.499232p-20
+    p = metal::fma(p, t, 1.12963626e-7f); //  0x1.e52cd2p-24
+    p = metal::fma(p, t, -5.61530760e-5f); // -0x1.d70bd0p-15
+    p = metal::fma(p, t, -1.47697632e-4f); // -0x1.35be90p-13
+    p = metal::fma(p, t, 2.31468678e-3f); //  0x1.2f6400p-9
+    p = metal::fma(p, t, 1.15392581e-2f); //  0x1.7a1e50p-7
+    p = metal::fma(p, t, -2.32015476e-1f); // -0x1.db2aeep-3
+    p = metal::fma(p, t, 8.86226892e-1f); //  0x1.c5bf88p-1
+  }
+  return a * p;
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/expm1f.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/expm1f.h
new file mode 100644
index 0000000000000000000000000000000000000000..68224e1796e9f5a485914d94507d07b81d52b797
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/expm1f.h
@@ -0,0 +1,90 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <metal_math>
+
+// Original license copied below:
+//  Copyright (c) 2015-2023 Norbert Juffa
+//  All rights reserved.
+//
+//  Redistribution and use in source and binary forms, with or without
+//  modification, are permitted provided that the following conditions
+//  are met:
+//
+//  1. Redistributions of source code must retain the above copyright
+//     notice, this list of conditions and the following disclaimer.
+//
+//  2. Redistributions in binary form must reproduce the above copyright
+//     notice, this list of conditions and the following disclaimer in the
+//     documentation and/or other materials provided with the distribution.
+//
+//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+//  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+//  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+//  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+//  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+//  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+//  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+//  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+//  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/* Compute exponential base e minus 1. Maximum ulp error = 0.997458
+
+   i = rint(a/log(2)), f = a-i*log(2). Then expm1(a) = 2**i * (expm1(f)+1) - 1.
+   Compute r = expm1(f). Then expm1(a)= 2 * (0.5 * 2**i * r + 0.5 * 2**i - 0.5).
+   With t = 0.5*2**i, expm1(a) = 2*(r * t + t-0.5). However, for best accuracy,
+   when i == 1, expm1(a)= 2*(r + 0.5), and when i == 0, expm1(a) = r.
+
+   NOTE: Scale factor b is only applied if i < 0 or i > 1 (should be power of 2)
+*/
+float expm1f_scaled_unchecked(float a, float b) {
+  float f, j, r, s, t, u, v, x, y;
+  int i;
+
+  // exp(a) = 2**i * exp(f); i = rintf (a / log(2))
+  j = fma(1.442695f, a, 12582912.f); // 0x1.715476p0, 0x1.8p23
+  j = j - 12582912.0f; // 0x1.8p23
+  i = (int)j;
+  f = fma(j, -6.93145752e-1f, a);
+
+  // approximate r = exp(f)-1 on interval [-log(2)/2, +log(2)/2]
+  s = f * f;
+  if (a == 0.0f)
+    s = a; // ensure -0 is passed through
+  // err = 0.997458  ulp1 = 11081805
+  r = 1.97350979e-4f; // 0x1.9de000p-13
+  r = fma(r, f, 1.39309070e-3f); // 0x1.6d30bcp-10
+  r = fma(r, f, 8.33343994e-3f); // 0x1.1111f6p-7
+  r = fma(r, f, 4.16668020e-2f); // 0x1.55559ep-5
+  r = fma(r, f, 1.66666716e-1f); // 0x1.55555cp-3
+  r = fma(r, f, 4.99999970e-1f); // 0x1.fffffep-2
+  u = (j == 1) ? (f + 0.5f) : f;
+  v = fma(r, s, u);
+  s = 0.5f * b;
+  t = ldexp(s, i);
+  y = t - s;
+  x = (t - y) - s; // double-float canonicalization of difference
+  r = fma(v, t, x) + y;
+  r = r + r;
+  if (j == 0)
+    r = v;
+  if (j == 1)
+    r = v + v;
+  return r;
+}
+
+/* Compute exponential base e minus 1. max ulp err = 0.99746 */
+float expm1f(float a) {
+  float r;
+
+  r = expm1f_scaled_unchecked(a, 1.0f);
+  /* handle severe overflow and underflow */
+  if (abs(a - 1.0f) > 88.0f) {
+    r = pow(2, a);
+    r = fma(r, r, -1.0f);
+  }
+  return r;
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fence.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fence.metal
new file mode 100644
index 0000000000000000000000000000000000000000..f736b33b075f68babb020f45535da7f8b2550beb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fence.metal
@@ -0,0 +1,52 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma METAL internals : enable
+
+#ifndef __METAL_MEMORY_SCOPE_SYSTEM__
+#define __METAL_MEMORY_SCOPE_SYSTEM__ 3
+namespace metal {
+constexpr constant metal::thread_scope thread_scope_system =
+    static_cast<thread_scope>(__METAL_MEMORY_SCOPE_SYSTEM__);
+}
+#endif
+
+#include <metal_atomic>
+
+[[kernel]] void input_coherent(
+    volatile coherent(system) device uint* input [[buffer(0)]],
+    const constant uint& size [[buffer(1)]],
+    uint index [[thread_position_in_grid]]) {
+  if (index < size) {
+    input[index] = input[index];
+  }
+  metal::atomic_thread_fence(
+      metal::mem_flags::mem_device,
+      metal::memory_order_seq_cst,
+      metal::thread_scope_system);
+}
+
+// single thread kernel to update timestamp
+[[kernel]] void fence_update(
+    volatile coherent(system) device uint* timestamp [[buffer(0)]],
+    constant uint& value [[buffer(1)]]) {
+  timestamp[0] = value;
+  metal::atomic_thread_fence(
+      metal::mem_flags::mem_device,
+      metal::memory_order_seq_cst,
+      metal::thread_scope_system);
+}
+
+// single thread kernel to spin wait for timestamp value
+[[kernel]] void fence_wait(
+    volatile coherent(system) device uint* timestamp [[buffer(0)]],
+    constant uint& value [[buffer(1)]]) {
+  while (1) {
+    metal::atomic_thread_fence(
+        metal::mem_flags::mem_device,
+        metal::memory_order_seq_cst,
+        metal::thread_scope_system);
+    if (timestamp[0] >= value) {
+      break;
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fft.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fft.h
new file mode 100644
index 0000000000000000000000000000000000000000..e478a85b6cf5d4e1692de8c686641673d8989339
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fft.h
@@ -0,0 +1,486 @@
+// Copyright © 2024 Apple Inc.
+
+// Metal FFT using Stockham's algorithm
+//
+// References:
+// - VkFFT (https://github.com/DTolm/VkFFT)
+// - Eric Bainville's excellent page (http://www.bealto.com/gpu-fft.html)
+
+#include <metal_common>
+
+#include "mlx/backend/metal/kernels/fft/radix.h"
+#include "mlx/backend/metal/kernels/fft/readwrite.h"
+#include "mlx/backend/metal/kernels/steel/defines.h"
+
+using namespace metal;
+
+#define MAX_RADIX 13
+// Reached when elems_per_thread_ = 6, max_radix = 13
+// and some threads have to do 3 radix 6s requiring 18 float2s.
+#define MAX_OUTPUT_SIZE 18
+
+// Specialize for a particular value of N at runtime
+STEEL_CONST bool inv_ [[function_constant(0)]];
+STEEL_CONST bool is_power_of_2_ [[function_constant(1)]];
+STEEL_CONST int elems_per_thread_ [[function_constant(2)]];
+// rader_m = n / rader_n
+STEEL_CONST int rader_m_ [[function_constant(3)]];
+// Stockham steps
+STEEL_CONST int radix_13_steps_ [[function_constant(4)]];
+STEEL_CONST int radix_11_steps_ [[function_constant(5)]];
+STEEL_CONST int radix_8_steps_ [[function_constant(6)]];
+STEEL_CONST int radix_7_steps_ [[function_constant(7)]];
+STEEL_CONST int radix_6_steps_ [[function_constant(8)]];
+STEEL_CONST int radix_5_steps_ [[function_constant(9)]];
+STEEL_CONST int radix_4_steps_ [[function_constant(10)]];
+STEEL_CONST int radix_3_steps_ [[function_constant(11)]];
+STEEL_CONST int radix_2_steps_ [[function_constant(12)]];
+// Rader steps
+STEEL_CONST int rader_13_steps_ [[function_constant(13)]];
+STEEL_CONST int rader_11_steps_ [[function_constant(14)]];
+STEEL_CONST int rader_8_steps_ [[function_constant(15)]];
+STEEL_CONST int rader_7_steps_ [[function_constant(16)]];
+STEEL_CONST int rader_6_steps_ [[function_constant(17)]];
+STEEL_CONST int rader_5_steps_ [[function_constant(18)]];
+STEEL_CONST int rader_4_steps_ [[function_constant(19)]];
+STEEL_CONST int rader_3_steps_ [[function_constant(20)]];
+STEEL_CONST int rader_2_steps_ [[function_constant(21)]];
+
+// See "radix.h" for radix codelets
+typedef void (*RadixFunc)(thread float2*, thread float2*);
+
+// Perform a single radix n butterfly with appropriate twiddles
+template <int radix, RadixFunc radix_func>
+METAL_FUNC void radix_butterfly(
+    int i,
+    int p,
+    thread float2* x,
+    thread short* indices,
+    thread float2* y) {
+  // i: the index in the overall DFT that we're processing.
+  // p: the size of the DFTs we're merging at this step.
+  // m: how many threads are working on this DFT.
+  int k, j;
+
+  // Use faster bitwise operations when working with powers of two
+  constexpr bool radix_p_2 = (radix & (radix - 1)) == 0;
+  if (radix_p_2 && is_power_of_2_) {
+    constexpr short power = __builtin_ctz(radix);
+    k = i & (p - 1);
+    j = ((i - k) << power) + k;
+  } else {
+    k = i % p;
+    j = (i / p) * radix * p + k;
+  }
+
+  // Apply twiddles
+  if (p > 1) {
+    float2 twiddle_1 = get_twiddle(k, radix * p);
+    float2 twiddle = twiddle_1;
+    x[1] = complex_mul(x[1], twiddle);
+
+    STEEL_PRAGMA_UNROLL
+    for (int t = 2; t < radix; t++) {
+      twiddle = complex_mul(twiddle, twiddle_1);
+      x[t] = complex_mul(x[t], twiddle);
+    }
+  }
+
+  radix_func(x, y);
+
+  STEEL_PRAGMA_UNROLL
+  for (int t = 0; t < radix; t++) {
+    indices[t] = j + t * p;
+  }
+}
+
+// Perform all the radix steps required for a
+// particular radix size n.
+template <int radix, RadixFunc radix_func>
+METAL_FUNC void radix_n_steps(
+    int i,
+    thread int* p,
+    int m,
+    int n,
+    int num_steps,
+    thread float2* inputs,
+    thread short* indices,
+    thread float2* values,
+    threadgroup float2* buf) {
+  int m_r = n / radix;
+  // When combining different sized radices, we have to do
+  // multiple butterflies in a single thread.
+  // E.g. n = 28 = 4 * 7
+  // 4 threads, 7 elems_per_thread
+  // All threads do 1 radix7 butterfly.
+  // 3 threads do 2 radix4 butterflies.
+  // 1 thread does 1 radix4 butterfly.
+  int max_radices_per_thread = (elems_per_thread_ + radix - 1) / radix;
+
+  int index = 0;
+  int r_index = 0;
+  for (int s = 0; s < num_steps; s++) {
+    for (int t = 0; t < max_radices_per_thread; t++) {
+      index = i + t * m;
+      if (index < m_r) {
+        for (int r = 0; r < radix; r++) {
+          inputs[r] = buf[index + r * m_r];
+        }
+        radix_butterfly<radix, radix_func>(
+            index, *p, inputs, indices + t * radix, values + t * radix);
+      }
+    }
+
+    // Wait until all threads have read their inputs into thread local mem
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    for (int t = 0; t < max_radices_per_thread; t++) {
+      index = i + t * m;
+      if (index < m_r) {
+        for (int r = 0; r < radix; r++) {
+          r_index = t * radix + r;
+          buf[indices[r_index]] = values[r_index];
+        }
+      }
+    }
+
+    // Wait until all threads have written back to threadgroup mem
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    *p *= radix;
+  }
+}
+
+#define RADIX_STEP(radix, radix_func, num_steps) \
+  radix_n_steps<radix, radix_func>(              \
+      fft_idx, p, m, n, num_steps, inputs, indices, values, buf);
+
+template <bool rader = false>
+METAL_FUNC void
+perform_fft(int fft_idx, thread int* p, int m, int n, threadgroup float2* buf) {
+  float2 inputs[MAX_RADIX];
+  short indices[MAX_OUTPUT_SIZE];
+  float2 values[MAX_OUTPUT_SIZE];
+
+  RADIX_STEP(2, radix2, rader ? rader_2_steps_ : radix_2_steps_);
+  RADIX_STEP(3, radix3, rader ? rader_3_steps_ : radix_3_steps_);
+  RADIX_STEP(4, radix4, rader ? rader_4_steps_ : radix_4_steps_);
+  RADIX_STEP(5, radix5, rader ? rader_5_steps_ : radix_5_steps_);
+  RADIX_STEP(6, radix6, rader ? rader_6_steps_ : radix_6_steps_);
+  RADIX_STEP(7, radix7, rader ? rader_7_steps_ : radix_7_steps_);
+  RADIX_STEP(8, radix8, rader ? rader_8_steps_ : radix_8_steps_);
+  RADIX_STEP(11, radix11, rader ? rader_11_steps_ : radix_11_steps_);
+  RADIX_STEP(13, radix13, rader ? rader_13_steps_ : radix_13_steps_);
+}
+
+// Each FFT is computed entirely in shared GPU memory.
+//
+// N is decomposed into radix-n DFTs:
+// e.g. 128 = 2 * 4 * 4 * 4
+template <int tg_mem_size, typename in_T, typename out_T>
+[[kernel]] void fft(
+    const device in_T* in [[buffer(0)]],
+    device out_T* out [[buffer(1)]],
+    constant const int& n,
+    constant const int& batch_size,
+    uint3 elem [[thread_position_in_grid]],
+    uint3 grid [[threads_per_grid]]) {
+  threadgroup float2 shared_in[tg_mem_size];
+
+  thread ReadWriter<in_T, out_T> read_writer = ReadWriter<in_T, out_T>(
+      in,
+      &shared_in[0],
+      out,
+      n,
+      batch_size,
+      elems_per_thread_,
+      elem,
+      grid,
+      inv_);
+
+  if (read_writer.out_of_bounds()) {
+    return;
+  };
+  read_writer.load();
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  int p = 1;
+  int fft_idx = elem.z; // Thread index in DFT
+  int m = grid.z; // Threads per DFT
+  int tg_idx = elem.y * n; // Index of this DFT in threadgroup
+  threadgroup float2* buf = &shared_in[tg_idx];
+
+  perform_fft(fft_idx, &p, m, n, buf);
+
+  read_writer.write();
+}
+
+template <int tg_mem_size, typename in_T, typename out_T>
+[[kernel]] void rader_fft(
+    const device in_T* in [[buffer(0)]],
+    device out_T* out [[buffer(1)]],
+    const device float2* raders_b_q [[buffer(2)]],
+    const device short* raders_g_q [[buffer(3)]],
+    const device short* raders_g_minus_q [[buffer(4)]],
+    constant const int& n,
+    constant const int& batch_size,
+    constant const int& rader_n,
+    uint3 elem [[thread_position_in_grid]],
+    uint3 grid [[threads_per_grid]]) {
+  // Use Rader's algorithm to compute fast FFTs
+  // when a prime factor `p` of `n` is greater than 13 but
+  // has `p - 1` Stockham decomposable into to prime factors <= 13.
+  //
+  // E.g. n = 102
+  //        = 2 * 3 * 17
+  // .      = 2 * 3 * RADER(16)
+  // .      = 2 * 3 * RADER(4 * 4)
+  //
+  // In numpy:
+  //   x_perm = x[g_q]
+  //   y = np.fft.fft(x_perm) * b_q
+  //   z = np.fft.ifft(y) + x[0]
+  //   out = z[g_minus_q]
+  //   out[0]  = x[1:].sum()
+  //
+  // Where the g_q and g_minus_q are permutations formed
+  // by the group under multiplicative modulo N using the
+  // primitive root of N and b_q is a constant.
+  // See https://en.wikipedia.org/wiki/Rader%27s_FFT_algorithm
+  //
+  // Rader's uses fewer operations than Bluestein's and so
+  // is more accurate. It's also faster in most cases.
+  threadgroup float2 shared_in[tg_mem_size];
+
+  thread ReadWriter<in_T, out_T> read_writer = ReadWriter<in_T, out_T>(
+      in,
+      &shared_in[0],
+      out,
+      n,
+      batch_size,
+      elems_per_thread_,
+      elem,
+      grid,
+      inv_);
+
+  if (read_writer.out_of_bounds()) {
+    return;
+  };
+  read_writer.load();
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // The number of the threads we're using for each DFT
+  int m = grid.z;
+
+  int fft_idx = elem.z;
+  int tg_idx = elem.y * n;
+  threadgroup float2* buf = &shared_in[tg_idx];
+
+  // rader_m = n / rader_n;
+  int rader_m = rader_m_;
+
+  // We have to load two x_0s for each thread since sometimes
+  // elems_per_thread_ crosses a boundary.
+  // E.g. with n = 34, rader_n = 17, elems_per_thread_ = 4
+  // 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3 4 4 4 4 5 5 5 5 6 6 6 6 7 7 7 7 8 8
+  // 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
+  short x_0_index =
+      metal::min(fft_idx * elems_per_thread_ / (rader_n - 1), rader_m - 1);
+  float2 x_0[2] = {buf[x_0_index], buf[x_0_index + 1]};
+
+  // Do the Rader permutation in shared memory
+  float2 temp[MAX_RADIX];
+  int max_index = n - rader_m - 1;
+  for (int e = 0; e < elems_per_thread_; e++) {
+    short index = metal::min(fft_idx * elems_per_thread_ + e, max_index);
+    short g_q = raders_g_q[index / rader_m];
+    temp[e] = buf[rader_m + (g_q - 1) * rader_m + index % rader_m];
+  }
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  for (int e = 0; e < elems_per_thread_; e++) {
+    short index = metal::min(fft_idx * elems_per_thread_ + e, max_index);
+    buf[index + rader_m] = temp[e];
+  }
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // Rader FFT on x[rader_m:]
+  int p = 1;
+  perform_fft</*rader=*/true>(fft_idx, &p, m, n - rader_m, buf + rader_m);
+
+  // x_1 + ... + x_n is computed for us in the first FFT step so
+  // we save it in the first rader_m indices of the array for later.
+  int x_sum_index = metal::min(fft_idx, rader_m - 1);
+  buf[x_sum_index] = buf[rader_m + x_sum_index * (rader_n - 1)];
+
+  float2 inv = {1.0f, -1.0f};
+  for (int e = 0; e < elems_per_thread_; e++) {
+    short index = metal::min(fft_idx * elems_per_thread_ + e, max_index);
+    short interleaved_index =
+        index / rader_m + (index % rader_m) * (rader_n - 1);
+    temp[e] = complex_mul(
+        buf[rader_m + interleaved_index],
+        raders_b_q[interleaved_index % (rader_n - 1)]);
+  }
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  for (int e = 0; e < elems_per_thread_; e++) {
+    short index = metal::min(fft_idx * elems_per_thread_ + e, max_index);
+    buf[rader_m + index] = temp[e] * inv;
+  }
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // Rader IFFT on x[rader_m:]
+  p = 1;
+  perform_fft</*rader=*/true>(fft_idx, &p, m, n - rader_m, buf + rader_m);
+
+  float2 rader_inv_factor = {1.0f / (rader_n - 1), -1.0f / (rader_n - 1)};
+
+  for (int e = 0; e < elems_per_thread_; e++) {
+    short index = metal::min(fft_idx * elems_per_thread_ + e, n - rader_m - 1);
+    short diff_index = index / (rader_n - 1) - x_0_index;
+    temp[e] = buf[rader_m + index] * rader_inv_factor + x_0[diff_index];
+  }
+
+  // Use the sum of elements that was computed in the first FFT
+  float2 x_sum = buf[x_0_index] + x_0[0];
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  for (int e = 0; e < elems_per_thread_; e++) {
+    short index = metal::min(fft_idx * elems_per_thread_ + e, max_index);
+    short g_q_index = index % (rader_n - 1);
+    short g_q = raders_g_minus_q[g_q_index];
+    short out_index = index - g_q_index + g_q + (index / (rader_n - 1));
+    buf[out_index] = temp[e];
+  }
+
+  buf[x_0_index * rader_n] = x_sum;
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  p = rader_n;
+  perform_fft(fft_idx, &p, m, n, buf);
+
+  read_writer.write();
+}
+
+template <int tg_mem_size, typename in_T, typename out_T>
+[[kernel]] void bluestein_fft(
+    const device in_T* in [[buffer(0)]],
+    device out_T* out [[buffer(1)]],
+    const device float2* w_q [[buffer(2)]],
+    const device float2* w_k [[buffer(3)]],
+    constant const int& length,
+    constant const int& n,
+    constant const int& batch_size,
+    uint3 elem [[thread_position_in_grid]],
+    uint3 grid [[threads_per_grid]]) {
+  // Computes arbitrary length FFTs with Bluestein's algorithm
+  //
+  // In numpy:
+  //   bluestein_n = next_power_of_2(2*n - 1)
+  //   out = w_k * np.fft.ifft(np.fft.fft(w_k * in, bluestein_n) * w_q)
+  //
+  // Where w_k and w_q are precomputed on CPU in high precision as:
+  //   w_k = np.exp(-1j * np.pi / n * (np.arange(-n + 1, n) ** 2))
+  //   w_q = np.fft.fft(1/w_k[-n:])
+  threadgroup float2 shared_in[tg_mem_size];
+
+  thread ReadWriter<in_T, out_T> read_writer = ReadWriter<in_T, out_T>(
+      in,
+      &shared_in[0],
+      out,
+      n,
+      batch_size,
+      elems_per_thread_,
+      elem,
+      grid,
+      inv_);
+
+  if (read_writer.out_of_bounds()) {
+    return;
+  };
+  read_writer.load_padded(length, w_k);
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  int p = 1;
+  int fft_idx = elem.z; // Thread index in DFT
+  int m = grid.z; // Threads per DFT
+  int tg_idx = elem.y * n; // Index of this DFT in threadgroup
+  threadgroup float2* buf = &shared_in[tg_idx];
+
+  // fft
+  perform_fft(fft_idx, &p, m, n, buf);
+
+  float2 inv = float2(1.0f, -1.0f);
+  for (int t = 0; t < elems_per_thread_; t++) {
+    int index = fft_idx + t * m;
+    buf[index] = complex_mul(buf[index], w_q[index]) * inv;
+  }
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // ifft
+  p = 1;
+  perform_fft(fft_idx, &p, m, n, buf);
+
+  read_writer.write_padded(length, w_k);
+}
+
+template <
+    int tg_mem_size,
+    typename in_T,
+    typename out_T,
+    int step,
+    bool real = false>
+[[kernel]] void four_step_fft(
+    const device in_T* in [[buffer(0)]],
+    device out_T* out [[buffer(1)]],
+    constant const int& n1,
+    constant const int& n2,
+    constant const int& batch_size,
+    uint3 elem [[thread_position_in_grid]],
+    uint3 grid [[threads_per_grid]]) {
+  // Fast four step FFT implementation for powers of 2.
+  int overall_n = n1 * n2;
+  int n = step == 0 ? n1 : n2;
+  int stride = step == 0 ? n2 : n1;
+
+  // The number of the threads we're using for each DFT
+  int m = grid.z;
+  int fft_idx = elem.z;
+
+  threadgroup float2 shared_in[tg_mem_size];
+  threadgroup float2* buf = &shared_in[elem.y * n];
+
+  using read_writer_t = ReadWriter<in_T, out_T, step, real>;
+  read_writer_t read_writer = read_writer_t(
+      in,
+      &shared_in[0],
+      out,
+      n,
+      batch_size,
+      elems_per_thread_,
+      elem,
+      grid,
+      inv_);
+
+  if (read_writer.out_of_bounds()) {
+    return;
+  };
+  read_writer.load_strided(stride, overall_n);
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  int p = 1;
+  perform_fft(fft_idx, &p, m, n, buf);
+
+  read_writer.write_strided(stride, overall_n);
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fft.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fft.metal
new file mode 100644
index 0000000000000000000000000000000000000000..590b558efc70ce886dc81d218e449b0b94e36d3c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fft.metal
@@ -0,0 +1,67 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/backend/metal/kernels/defines.h"
+#include "mlx/backend/metal/kernels/fft.h"
+
+#define instantiate_fft(tg_mem_size, in_T, out_T)   \
+  instantiate_kernel(                               \
+      "fft_mem_" #tg_mem_size "_" #in_T "_" #out_T, \
+      fft,                                          \
+      tg_mem_size,                                  \
+      in_T,                                         \
+      out_T)
+
+#define instantiate_rader(tg_mem_size, in_T, out_T)       \
+  instantiate_kernel(                                     \
+      "rader_fft_mem_" #tg_mem_size "_" #in_T "_" #out_T, \
+      rader_fft,                                          \
+      tg_mem_size,                                        \
+      in_T,                                               \
+      out_T)
+
+#define instantiate_bluestein(tg_mem_size, in_T, out_T)       \
+  instantiate_kernel(                                         \
+      "bluestein_fft_mem_" #tg_mem_size "_" #in_T "_" #out_T, \
+      bluestein_fft,                                          \
+      tg_mem_size,                                            \
+      in_T,                                                   \
+      out_T)
+
+#define instantiate_four_step(tg_mem_size, in_T, out_T, step, real)           \
+  instantiate_kernel(                                                         \
+      "four_step_mem_" #tg_mem_size "_" #in_T "_" #out_T "_" #step "_" #real, \
+      four_step_fft,                                                          \
+      tg_mem_size,                                                            \
+      in_T,                                                                   \
+      out_T,                                                                  \
+      step,                                                                   \
+      real)
+
+// clang-format off
+#define instantiate_ffts(tg_mem_size)                        \
+  instantiate_fft(tg_mem_size, float2, float2) \
+  instantiate_fft(tg_mem_size, float, float2) \
+  instantiate_fft(tg_mem_size, float2, float) \
+  instantiate_rader(tg_mem_size, float2, float2) \
+  instantiate_rader(tg_mem_size, float, float2) \
+  instantiate_rader(tg_mem_size, float2, float) \
+  instantiate_bluestein(tg_mem_size, float2, float2) \
+  instantiate_bluestein(tg_mem_size, float, float2) \
+  instantiate_bluestein(tg_mem_size, float2, float) \
+  instantiate_four_step(tg_mem_size, float2, float2, 0, /*real=*/false) \
+  instantiate_four_step(tg_mem_size, float2, float2, 1, /*real=*/false) \
+  instantiate_four_step(tg_mem_size, float, float2, 0, /*real=*/true) \
+  instantiate_four_step(tg_mem_size, float2, float2, 1, /*real=*/true) \
+  instantiate_four_step(tg_mem_size, float2, float2, 0, /*real=*/true) \
+  instantiate_four_step(tg_mem_size, float2, float, 1, /*real=*/true)
+
+// It's substantially faster to statically define the
+// threadgroup memory size rather than using
+// `setThreadgroupMemoryLength` on the compute encoder.
+// For non-power of 2 sizes we round up the shared memory.
+instantiate_ffts(256)
+instantiate_ffts(512)
+instantiate_ffts(1024)
+instantiate_ffts(2048)
+// 4096 is the max that will fit into 32KB of threadgroup memory.
+instantiate_ffts(4096) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fft/radix.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fft/radix.h
new file mode 100644
index 0000000000000000000000000000000000000000..bd61eef6d708bea6551c145ec144dc9a59da9e00
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fft/radix.h
@@ -0,0 +1,328 @@
+// Copyright © 2024 Apple Inc.
+
+/* Radix kernels
+
+We provide optimized, single threaded Radix codelets
+for n=2,3,4,5,6,7,8,10,11,12,13.
+
+For n=2,3,4,5,6 we hand write the codelets.
+For n=8,10,12 we combine smaller codelets.
+For n=7,11,13 we use Rader's algorithm which decomposes
+them into (n-1)=6,10,12 codelets. */
+
+#pragma once
+
+#include <metal_common>
+#include <metal_math>
+#include <metal_stdlib>
+
+METAL_FUNC float2 complex_mul(float2 a, float2 b) {
+  return float2(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
+}
+
+// Complex mul followed by conjugate
+METAL_FUNC float2 complex_mul_conj(float2 a, float2 b) {
+  return float2(a.x * b.x - a.y * b.y, -a.x * b.y - a.y * b.x);
+}
+
+// Compute an FFT twiddle factor
+METAL_FUNC float2 get_twiddle(int k, int p) {
+  float theta = -2.0f * k * M_PI_F / p;
+
+  float2 twiddle = {metal::fast::cos(theta), metal::fast::sin(theta)};
+  return twiddle;
+}
+
+METAL_FUNC void radix2(thread float2* x, thread float2* y) {
+  y[0] = x[0] + x[1];
+  y[1] = x[0] - x[1];
+}
+
+METAL_FUNC void radix3(thread float2* x, thread float2* y) {
+  float pi_2_3 = -0.8660254037844387;
+
+  float2 a_1 = x[1] + x[2];
+  float2 a_2 = x[1] - x[2];
+
+  y[0] = x[0] + a_1;
+  float2 b_1 = x[0] - 0.5 * a_1;
+  float2 b_2 = pi_2_3 * a_2;
+
+  float2 b_2_j = {-b_2.y, b_2.x};
+  y[1] = b_1 + b_2_j;
+  y[2] = b_1 - b_2_j;
+}
+
+METAL_FUNC void radix4(thread float2* x, thread float2* y) {
+  float2 z_0 = x[0] + x[2];
+  float2 z_1 = x[0] - x[2];
+  float2 z_2 = x[1] + x[3];
+  float2 z_3 = x[1] - x[3];
+  float2 z_3_i = {z_3.y, -z_3.x};
+
+  y[0] = z_0 + z_2;
+  y[1] = z_1 + z_3_i;
+  y[2] = z_0 - z_2;
+  y[3] = z_1 - z_3_i;
+}
+
+METAL_FUNC void radix5(thread float2* x, thread float2* y) {
+  float2 root_5_4 = 0.5590169943749475;
+  float2 sin_2pi_5 = 0.9510565162951535;
+  float2 sin_1pi_5 = 0.5877852522924731;
+
+  float2 a_1 = x[1] + x[4];
+  float2 a_2 = x[2] + x[3];
+  float2 a_3 = x[1] - x[4];
+  float2 a_4 = x[2] - x[3];
+
+  float2 a_5 = a_1 + a_2;
+  float2 a_6 = root_5_4 * (a_1 - a_2);
+  float2 a_7 = x[0] - a_5 / 4;
+  float2 a_8 = a_7 + a_6;
+  float2 a_9 = a_7 - a_6;
+  float2 a_10 = sin_2pi_5 * a_3 + sin_1pi_5 * a_4;
+  float2 a_11 = sin_1pi_5 * a_3 - sin_2pi_5 * a_4;
+  float2 a_10_j = {a_10.y, -a_10.x};
+  float2 a_11_j = {a_11.y, -a_11.x};
+
+  y[0] = x[0] + a_5;
+  y[1] = a_8 + a_10_j;
+  y[2] = a_9 + a_11_j;
+  y[3] = a_9 - a_11_j;
+  y[4] = a_8 - a_10_j;
+}
+
+METAL_FUNC void radix6(thread float2* x, thread float2* y) {
+  float sin_pi_3 = 0.8660254037844387;
+  float2 a_1 = x[2] + x[4];
+  float2 a_2 = x[0] - a_1 / 2;
+  float2 a_3 = sin_pi_3 * (x[2] - x[4]);
+  float2 a_4 = x[5] + x[1];
+  float2 a_5 = x[3] - a_4 / 2;
+  float2 a_6 = sin_pi_3 * (x[5] - x[1]);
+  float2 a_7 = x[0] + a_1;
+
+  float2 a_3_i = {a_3.y, -a_3.x};
+  float2 a_6_i = {a_6.y, -a_6.x};
+  float2 a_8 = a_2 + a_3_i;
+  float2 a_9 = a_2 - a_3_i;
+  float2 a_10 = x[3] + a_4;
+  float2 a_11 = a_5 + a_6_i;
+  float2 a_12 = a_5 - a_6_i;
+
+  y[0] = a_7 + a_10;
+  y[1] = a_8 - a_11;
+  y[2] = a_9 + a_12;
+  y[3] = a_7 - a_10;
+  y[4] = a_8 + a_11;
+  y[5] = a_9 - a_12;
+}
+
+METAL_FUNC void radix7(thread float2* x, thread float2* y) {
+  // Rader's algorithm
+  float2 inv = {1 / 6.0, -1 / 6.0};
+
+  // fft
+  float2 in1[6] = {x[1], x[3], x[2], x[6], x[4], x[5]};
+  radix6(in1, y + 1);
+
+  y[0] = y[1] + x[0];
+
+  // b_q
+  y[1] = complex_mul_conj(y[1], float2(-1, 0));
+  y[2] = complex_mul_conj(y[2], float2(2.44013336, -1.02261879));
+  y[3] = complex_mul_conj(y[3], float2(2.37046941, -1.17510629));
+  y[4] = complex_mul_conj(y[4], float2(0, -2.64575131));
+  y[5] = complex_mul_conj(y[5], float2(2.37046941, 1.17510629));
+  y[6] = complex_mul_conj(y[6], float2(-2.44013336, -1.02261879));
+
+  // ifft
+  radix6(y + 1, x + 1);
+
+  y[1] = x[1] * inv + x[0];
+  y[5] = x[2] * inv + x[0];
+  y[4] = x[3] * inv + x[0];
+  y[6] = x[4] * inv + x[0];
+  y[2] = x[5] * inv + x[0];
+  y[3] = x[6] * inv + x[0];
+}
+
+METAL_FUNC void radix8(thread float2* x, thread float2* y) {
+  float cos_pi_4 = 0.7071067811865476;
+  float2 w_0 = {cos_pi_4, -cos_pi_4};
+  float2 w_1 = {-cos_pi_4, -cos_pi_4};
+  float2 temp[8] = {x[0], x[2], x[4], x[6], x[1], x[3], x[5], x[7]};
+  radix4(temp, x);
+  radix4(temp + 4, x + 4);
+
+  y[0] = x[0] + x[4];
+  y[4] = x[0] - x[4];
+  float2 x_5 = complex_mul(x[5], w_0);
+  y[1] = x[1] + x_5;
+  y[5] = x[1] - x_5;
+  float2 x_6 = {x[6].y, -x[6].x};
+  y[2] = x[2] + x_6;
+  y[6] = x[2] - x_6;
+  float2 x_7 = complex_mul(x[7], w_1);
+  y[3] = x[3] + x_7;
+  y[7] = x[3] - x_7;
+}
+
+template <bool raders_perm>
+METAL_FUNC void radix10(thread float2* x, thread float2* y) {
+  float2 w[4];
+  w[0] = {0.8090169943749475, -0.5877852522924731};
+  w[1] = {0.30901699437494745, -0.9510565162951535};
+  w[2] = {-w[1].x, w[1].y};
+  w[3] = {-w[0].x, w[0].y};
+
+  if (raders_perm) {
+    float2 temp[10] = {
+        x[0], x[3], x[4], x[8], x[2], x[1], x[7], x[9], x[6], x[5]};
+    radix5(temp, x);
+    radix5(temp + 5, x + 5);
+  } else {
+    float2 temp[10] = {
+        x[0], x[2], x[4], x[6], x[8], x[1], x[3], x[5], x[7], x[9]};
+    radix5(temp, x);
+    radix5(temp + 5, x + 5);
+  }
+
+  y[0] = x[0] + x[5];
+  y[5] = x[0] - x[5];
+  for (int t = 1; t < 5; t++) {
+    float2 a = complex_mul(x[t + 5], w[t - 1]);
+    y[t] = x[t] + a;
+    y[t + 5] = x[t] - a;
+  }
+}
+
+METAL_FUNC void radix11(thread float2* x, thread float2* y) {
+  // Raders Algorithm
+  float2 inv = {1 / 10.0, -1 / 10.0};
+
+  // fft
+  radix10<true>(x + 1, y + 1);
+
+  y[0] = y[1] + x[0];
+
+  // b_q
+  y[1] = complex_mul_conj(y[1], float2(-1, 0));
+  y[2] = complex_mul_conj(y[2], float2(0.955301878, -3.17606649));
+  y[3] = complex_mul_conj(y[3], float2(2.63610556, 2.01269656));
+  y[4] = complex_mul_conj(y[4], float2(2.54127802, 2.13117479));
+  y[5] = complex_mul_conj(y[5], float2(2.07016210, 2.59122150));
+  y[6] = complex_mul_conj(y[6], float2(0, -3.31662479));
+  y[7] = complex_mul_conj(y[7], float2(2.07016210, -2.59122150));
+  y[8] = complex_mul_conj(y[8], float2(-2.54127802, 2.13117479));
+  y[9] = complex_mul_conj(y[9], float2(2.63610556, -2.01269656));
+  y[10] = complex_mul_conj(y[10], float2(-0.955301878, -3.17606649));
+
+  // ifft
+  radix10<false>(y + 1, x + 1);
+
+  y[1] = x[1] * inv + x[0];
+  y[6] = x[2] * inv + x[0];
+  y[3] = x[3] * inv + x[0];
+  y[7] = x[4] * inv + x[0];
+  y[9] = x[5] * inv + x[0];
+  y[10] = x[6] * inv + x[0];
+  y[5] = x[7] * inv + x[0];
+  y[8] = x[8] * inv + x[0];
+  y[4] = x[9] * inv + x[0];
+  y[2] = x[10] * inv + x[0];
+}
+
+template <bool raders_perm>
+METAL_FUNC void radix12(thread float2* x, thread float2* y) {
+  float2 w[6];
+  float sin_pi_3 = 0.8660254037844387;
+  w[0] = {sin_pi_3, -0.5};
+  w[1] = {0.5, -sin_pi_3};
+  w[2] = {0, -1};
+  w[3] = {-0.5, -sin_pi_3};
+  w[4] = {-sin_pi_3, -0.5};
+
+  if (raders_perm) {
+    float2 temp[12] = {
+        x[0],
+        x[3],
+        x[2],
+        x[11],
+        x[8],
+        x[9],
+        x[1],
+        x[7],
+        x[5],
+        x[10],
+        x[4],
+        x[6]};
+    radix6(temp, x);
+    radix6(temp + 6, x + 6);
+  } else {
+    float2 temp[12] = {
+        x[0],
+        x[2],
+        x[4],
+        x[6],
+        x[8],
+        x[10],
+        x[1],
+        x[3],
+        x[5],
+        x[7],
+        x[9],
+        x[11]};
+    radix6(temp, x);
+    radix6(temp + 6, x + 6);
+  }
+
+  y[0] = x[0] + x[6];
+  y[6] = x[0] - x[6];
+  for (int t = 1; t < 6; t++) {
+    float2 a = complex_mul(x[t + 6], w[t - 1]);
+    y[t] = x[t] + a;
+    y[t + 6] = x[t] - a;
+  }
+}
+
+METAL_FUNC void radix13(thread float2* x, thread float2* y) {
+  // Raders Algorithm
+  float2 inv = {1 / 12.0, -1 / 12.0};
+
+  // fft
+  radix12<true>(x + 1, y + 1);
+
+  y[0] = y[1] + x[0];
+
+  // b_q
+  y[1] = complex_mul_conj(y[1], float2(-1, 0));
+  y[2] = complex_mul_conj(y[2], float2(3.07497206, -1.88269669));
+  y[3] = complex_mul_conj(y[3], float2(3.09912468, 1.84266823));
+  y[4] = complex_mul_conj(y[4], float2(3.45084438, -1.04483161));
+  y[5] = complex_mul_conj(y[5], float2(0.91083583, 3.48860690));
+  y[6] = complex_mul_conj(y[6], float2(-3.60286363, 0.139189267));
+  y[7] = complex_mul_conj(y[7], float2(3.60555128, 0));
+  y[8] = complex_mul_conj(y[8], float2(3.60286363, 0.139189267));
+  y[9] = complex_mul_conj(y[9], float2(0.91083583, -3.48860690));
+  y[10] = complex_mul_conj(y[10], float2(-3.45084438, -1.04483161));
+  y[11] = complex_mul_conj(y[11], float2(3.09912468, -1.84266823));
+  y[12] = complex_mul_conj(y[12], float2(-3.07497206, -1.88269669));
+
+  // ifft
+  radix12<false>(y + 1, x + 1);
+
+  y[1] = x[1] * inv + x[0];
+  y[7] = x[2] * inv + x[0];
+  y[10] = x[3] * inv + x[0];
+  y[5] = x[4] * inv + x[0];
+  y[9] = x[5] * inv + x[0];
+  y[11] = x[6] * inv + x[0];
+  y[12] = x[7] * inv + x[0];
+  y[6] = x[8] * inv + x[0];
+  y[3] = x[9] * inv + x[0];
+  y[8] = x[10] * inv + x[0];
+  y[4] = x[11] * inv + x[0];
+  y[2] = x[12] * inv + x[0];
+}
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fft/readwrite.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fft/readwrite.h
new file mode 100644
index 0000000000000000000000000000000000000000..0dc62992e64e288c5be12d6315758a396632b73c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fft/readwrite.h
@@ -0,0 +1,624 @@
+// Copyright © 2024 Apple Inc.
+
+#include <metal_common>
+
+#include "mlx/backend/metal/kernels/fft/radix.h"
+
+/* FFT helpers for reading and writing from/to device memory.
+
+For many sizes, GPU FFTs are memory bandwidth bound so
+read/write performance is important.
+
+Where possible, we read 128 bits sequentially in each thread,
+coalesced with accesses from adjacent threads for optimal performance.
+
+We implement specialized reading/writing for:
+  - FFT
+  - RFFT
+  - IRFFT
+
+Each with support for:
+  - Contiguous reads
+  - Padded reads
+  - Strided reads
+*/
+
+#define MAX_RADIX 13
+
+using namespace metal;
+
+template <
+    typename in_T,
+    typename out_T,
+    int step = 0,
+    bool four_step_real = false>
+struct ReadWriter {
+  const device in_T* in;
+  threadgroup float2* buf;
+  device out_T* out;
+  int n;
+  int batch_size;
+  int elems_per_thread;
+  uint3 elem;
+  uint3 grid;
+  int threads_per_tg;
+  bool inv;
+
+  // Used for strided access
+  int strided_device_idx = 0;
+  int strided_shared_idx = 0;
+
+  METAL_FUNC ReadWriter(
+      const device in_T* in_,
+      threadgroup float2* buf_,
+      device out_T* out_,
+      const short n_,
+      const int batch_size_,
+      const short elems_per_thread_,
+      const uint3 elem_,
+      const uint3 grid_,
+      const bool inv_)
+      : in(in_),
+        buf(buf_),
+        out(out_),
+        n(n_),
+        batch_size(batch_size_),
+        elems_per_thread(elems_per_thread_),
+        elem(elem_),
+        grid(grid_),
+        inv(inv_) {
+    // Account for padding on last threadgroup
+    threads_per_tg = elem.x == grid.x - 1
+        ? (batch_size - (grid.x - 1) * grid.y) * grid.z
+        : grid.y * grid.z;
+  }
+
+  // ifft(x) = 1/n * conj(fft(conj(x)))
+  METAL_FUNC float2 post_in(float2 elem) const {
+    return inv ? float2(elem.x, -elem.y) : elem;
+  }
+
+  // Handle float case for generic RFFT alg
+  METAL_FUNC float2 post_in(float elem) const {
+    return float2(elem, 0);
+  }
+
+  METAL_FUNC float2 pre_out(float2 elem) const {
+    return inv ? float2(elem.x / n, -elem.y / n) : elem;
+  }
+
+  METAL_FUNC float2 pre_out(float2 elem, int length) const {
+    return inv ? float2(elem.x / length, -elem.y / length) : elem;
+  }
+
+  METAL_FUNC bool out_of_bounds() const {
+    // Account for possible extra threadgroups
+    int grid_index = elem.x * grid.y + elem.y;
+    return grid_index >= batch_size;
+  }
+
+  METAL_FUNC void load() const {
+    size_t batch_idx = size_t(elem.x * grid.y) * n;
+    short tg_idx = elem.y * grid.z + elem.z;
+    short max_index = grid.y * n - 2;
+
+    // 2 complex64s = 128 bits
+    constexpr int read_width = 2;
+    for (short e = 0; e < (elems_per_thread / read_width); e++) {
+      short index = read_width * tg_idx + read_width * threads_per_tg * e;
+      index = metal::min(index, max_index);
+      // vectorized reads
+      buf[index] = post_in(in[batch_idx + index]);
+      buf[index + 1] = post_in(in[batch_idx + index + 1]);
+    }
+    max_index += 1;
+    if (elems_per_thread % 2 != 0) {
+      short index = tg_idx +
+          read_width * threads_per_tg * (elems_per_thread / read_width);
+      index = metal::min(index, max_index);
+      buf[index] = post_in(in[batch_idx + index]);
+    }
+  }
+
+  METAL_FUNC void write() const {
+    size_t batch_idx = size_t(elem.x * grid.y) * n;
+    short tg_idx = elem.y * grid.z + elem.z;
+    short max_index = grid.y * n - 2;
+
+    constexpr int read_width = 2;
+    for (short e = 0; e < (elems_per_thread / read_width); e++) {
+      short index = read_width * tg_idx + read_width * threads_per_tg * e;
+      index = metal::min(index, max_index);
+      // vectorized reads
+      out[batch_idx + index] = pre_out(buf[index]);
+      out[batch_idx + index + 1] = pre_out(buf[index + 1]);
+    }
+    max_index += 1;
+    if (elems_per_thread % 2 != 0) {
+      short index = tg_idx +
+          read_width * threads_per_tg * (elems_per_thread / read_width);
+      index = metal::min(index, max_index);
+      out[batch_idx + index] = pre_out(buf[index]);
+    }
+  }
+
+  // Padded IO for Bluestein's algorithm
+  METAL_FUNC void load_padded(int length, const device float2* w_k) const {
+    size_t batch_idx = size_t(elem.x * grid.y) * length + elem.y * length;
+    int fft_idx = elem.z;
+    int m = grid.z;
+
+    threadgroup float2* seq_buf = buf + elem.y * n;
+    for (int e = 0; e < elems_per_thread; e++) {
+      int index = metal::min(fft_idx + e * m, n - 1);
+      if (index < length) {
+        float2 elem = post_in(in[batch_idx + index]);
+        seq_buf[index] = complex_mul(elem, w_k[index]);
+      } else {
+        seq_buf[index] = 0.0;
+      }
+    }
+  }
+
+  METAL_FUNC void write_padded(int length, const device float2* w_k) const {
+    size_t batch_idx = size_t(elem.x * grid.y) * length + elem.y * length;
+    int fft_idx = elem.z;
+    int m = grid.z;
+    float2 inv_factor = {1.0f / n, -1.0f / n};
+
+    threadgroup float2* seq_buf = buf + elem.y * n;
+    for (int e = 0; e < elems_per_thread; e++) {
+      int index = metal::min(fft_idx + e * m, n - 1);
+      if (index < length) {
+        float2 elem = seq_buf[index + length - 1] * inv_factor;
+        out[batch_idx + index] = pre_out(complex_mul(elem, w_k[index]), length);
+      }
+    }
+  }
+
+  // Strided IO for four step FFT
+  METAL_FUNC void compute_strided_indices(int stride, int overall_n) {
+    // Use the batch threadgroup dimension to coalesce memory accesses:
+    // e.g. stride = 12
+    // device      | shared mem
+    // 0  1  2  3  |  0 12 - -
+    // -  -  -  -  |  1 13 - -
+    // -  -  -  -  |  2 14 - -
+    // 12 13 14 15 |  3 15 - -
+    int coalesce_width = grid.y;
+    int tg_idx = elem.y * grid.z + elem.z;
+    int outer_batch_size = stride / coalesce_width;
+
+    int strided_batch_idx = (elem.x % outer_batch_size) * coalesce_width +
+        overall_n * (elem.x / outer_batch_size);
+    strided_device_idx = strided_batch_idx +
+        tg_idx / coalesce_width * elems_per_thread * stride +
+        tg_idx % coalesce_width;
+    strided_shared_idx = (tg_idx % coalesce_width) * n +
+        tg_idx / coalesce_width * elems_per_thread;
+  }
+
+  // Four Step FFT First Step
+  METAL_FUNC void load_strided(int stride, int overall_n) {
+    compute_strided_indices(stride, overall_n);
+    for (int e = 0; e < elems_per_thread; e++) {
+      buf[strided_shared_idx + e] =
+          post_in(in[strided_device_idx + e * stride]);
+    }
+  }
+
+  METAL_FUNC void write_strided(int stride, int overall_n) {
+    for (int e = 0; e < elems_per_thread; e++) {
+      float2 output = buf[strided_shared_idx + e];
+      int combined_idx = (strided_device_idx + e * stride) % overall_n;
+      int ij = (combined_idx / stride) * (combined_idx % stride);
+      // Apply four step twiddles at end of first step
+      float2 twiddle = get_twiddle(ij, overall_n);
+      out[strided_device_idx + e * stride] = complex_mul(output, twiddle);
+    }
+  }
+};
+
+// Four Step FFT Second Step
+template <>
+METAL_FUNC void ReadWriter<float2, float2, /*step=*/1>::load_strided(
+    int stride,
+    int overall_n) {
+  // Silence compiler warnings
+  (void)stride;
+  (void)overall_n;
+  // Don't invert between steps
+  bool default_inv = inv;
+  inv = false;
+  load();
+  inv = default_inv;
+}
+
+template <>
+METAL_FUNC void ReadWriter<float2, float2, /*step=*/1>::write_strided(
+    int stride,
+    int overall_n) {
+  compute_strided_indices(stride, overall_n);
+  for (int e = 0; e < elems_per_thread; e++) {
+    float2 output = buf[strided_shared_idx + e];
+    out[strided_device_idx + e * stride] = pre_out(output, overall_n);
+  }
+}
+
+// For RFFT, we interleave batches of two real sequences into one complex one:
+//
+// z_k = x_k + j.y_k
+// X_k = (Z_k + Z_(N-k)*) / 2
+// Y_k = -j * ((Z_k - Z_(N-k)*) / 2)
+//
+// This roughly doubles the throughput over the regular FFT.
+template <>
+METAL_FUNC bool ReadWriter<float, float2>::out_of_bounds() const {
+  int grid_index = elem.x * grid.y + elem.y;
+  // We pack two sequences into one for RFFTs
+  return grid_index * 2 >= batch_size;
+}
+
+template <>
+METAL_FUNC void ReadWriter<float, float2>::load() const {
+  size_t batch_idx = size_t(elem.x * grid.y) * n * 2 + elem.y * n * 2;
+  threadgroup float2* seq_buf = buf + elem.y * n;
+
+  // No out of bounds accesses on odd batch sizes
+  int grid_index = elem.x * grid.y + elem.y;
+  short next_in =
+      batch_size % 2 == 1 && grid_index * 2 == batch_size - 1 ? 0 : n;
+
+  short m = grid.z;
+  short fft_idx = elem.z;
+
+  for (int e = 0; e < elems_per_thread; e++) {
+    int index = metal::min(fft_idx + e * m, n - 1);
+    seq_buf[index].x = in[batch_idx + index];
+    seq_buf[index].y = in[batch_idx + index + next_in];
+  }
+}
+
+template <>
+METAL_FUNC void ReadWriter<float, float2>::write() const {
+  short n_over_2 = (n / 2) + 1;
+
+  size_t batch_idx =
+      size_t(elem.x * grid.y) * n_over_2 * 2 + elem.y * n_over_2 * 2;
+  threadgroup float2* seq_buf = buf + elem.y * n;
+
+  int grid_index = elem.x * grid.y + elem.y;
+  short next_out =
+      batch_size % 2 == 1 && grid_index * 2 == batch_size - 1 ? 0 : n_over_2;
+
+  float2 conj = {1, -1};
+  float2 minus_j = {0, -1};
+
+  short m = grid.z;
+  short fft_idx = elem.z;
+
+  for (int e = 0; e < elems_per_thread / 2 + 1; e++) {
+    int index = metal::min(fft_idx + e * m, n_over_2 - 1);
+    // x_0 = z_0.real
+    // y_0 = z_0.imag
+    if (index == 0) {
+      out[batch_idx + index] = {seq_buf[index].x, 0};
+      out[batch_idx + index + next_out] = {seq_buf[index].y, 0};
+    } else {
+      float2 x_k = seq_buf[index];
+      float2 x_n_minus_k = seq_buf[n - index] * conj;
+      out[batch_idx + index] = (x_k + x_n_minus_k) / 2;
+      out[batch_idx + index + next_out] =
+          complex_mul(((x_k - x_n_minus_k) / 2), minus_j);
+    }
+  }
+}
+
+template <>
+METAL_FUNC void ReadWriter<float, float2>::load_padded(
+    int length,
+    const device float2* w_k) const {
+  size_t batch_idx = size_t(elem.x * grid.y) * length * 2 + elem.y * length * 2;
+  threadgroup float2* seq_buf = buf + elem.y * n;
+
+  // No out of bounds accesses on odd batch sizes
+  int grid_index = elem.x * grid.y + elem.y;
+  short next_in =
+      batch_size % 2 == 1 && grid_index * 2 == batch_size - 1 ? 0 : length;
+
+  short m = grid.z;
+  short fft_idx = elem.z;
+
+  for (int e = 0; e < elems_per_thread; e++) {
+    int index = metal::min(fft_idx + e * m, n - 1);
+    if (index < length) {
+      float2 elem =
+          float2(in[batch_idx + index], in[batch_idx + index + next_in]);
+      seq_buf[index] = complex_mul(elem, w_k[index]);
+    } else {
+      seq_buf[index] = 0;
+    }
+  }
+}
+
+template <>
+METAL_FUNC void ReadWriter<float, float2>::write_padded(
+    int length,
+    const device float2* w_k) const {
+  int length_over_2 = (length / 2) + 1;
+  size_t batch_idx =
+      size_t(elem.x * grid.y) * length_over_2 * 2 + elem.y * length_over_2 * 2;
+  threadgroup float2* seq_buf = buf + elem.y * n + length - 1;
+
+  int grid_index = elem.x * grid.y + elem.y;
+  short next_out = batch_size % 2 == 1 && grid_index * 2 == batch_size - 1
+      ? 0
+      : length_over_2;
+
+  float2 conj = {1, -1};
+  float2 inv_factor = {1.0f / n, -1.0f / n};
+  float2 minus_j = {0, -1};
+
+  short m = grid.z;
+  short fft_idx = elem.z;
+
+  for (int e = 0; e < elems_per_thread / 2 + 1; e++) {
+    int index = metal::min(fft_idx + e * m, length_over_2 - 1);
+    // x_0 = z_0.real
+    // y_0 = z_0.imag
+    if (index == 0) {
+      float2 elem = complex_mul(w_k[index], seq_buf[index] * inv_factor);
+      out[batch_idx + index] = float2(elem.x, 0);
+      out[batch_idx + index + next_out] = float2(elem.y, 0);
+    } else {
+      float2 x_k = complex_mul(w_k[index], seq_buf[index] * inv_factor);
+      float2 x_n_minus_k = complex_mul(
+          w_k[length - index], seq_buf[length - index] * inv_factor);
+      x_n_minus_k *= conj;
+      // w_k should happen before this extraction
+      out[batch_idx + index] = (x_k + x_n_minus_k) / 2;
+      out[batch_idx + index + next_out] =
+          complex_mul(((x_k - x_n_minus_k) / 2), minus_j);
+    }
+  }
+}
+
+// For IRFFT, we do the opposite
+//
+// Z_k = X_k + j.Y_k
+// x_k = Re(Z_k)
+// Y_k = Imag(Z_k)
+template <>
+METAL_FUNC bool ReadWriter<float2, float>::out_of_bounds() const {
+  int grid_index = elem.x * grid.y + elem.y;
+  // We pack two sequences into one for IRFFTs
+  return grid_index * 2 >= batch_size;
+}
+
+template <>
+METAL_FUNC void ReadWriter<float2, float>::load() const {
+  short n_over_2 = (n / 2) + 1;
+  size_t batch_idx =
+      size_t(elem.x * grid.y) * n_over_2 * 2 + elem.y * n_over_2 * 2;
+  threadgroup float2* seq_buf = buf + elem.y * n;
+
+  // No out of bounds accesses on odd batch sizes
+  int grid_index = elem.x * grid.y + elem.y;
+  short next_in =
+      batch_size % 2 == 1 && grid_index * 2 == batch_size - 1 ? 0 : n_over_2;
+
+  short m = grid.z;
+  short fft_idx = elem.z;
+
+  float2 conj = {1, -1};
+  float2 plus_j = {0, 1};
+
+  for (int t = 0; t < elems_per_thread / 2 + 1; t++) {
+    int index = metal::min(fft_idx + t * m, n_over_2 - 1);
+    float2 x = in[batch_idx + index];
+    float2 y = in[batch_idx + index + next_in];
+    // NumPy forces first input to be real
+    bool first_val = index == 0;
+    // NumPy forces last input on even irffts to be real
+    bool last_val = n % 2 == 0 && index == n_over_2 - 1;
+    if (first_val || last_val) {
+      x = float2(x.x, 0);
+      y = float2(y.x, 0);
+    }
+    seq_buf[index] = x + complex_mul(y, plus_j);
+    seq_buf[index].y = -seq_buf[index].y;
+    if (index > 0 && !last_val) {
+      seq_buf[n - index] = (x * conj) + complex_mul(y * conj, plus_j);
+      seq_buf[n - index].y = -seq_buf[n - index].y;
+    }
+  }
+}
+
+template <>
+METAL_FUNC void ReadWriter<float2, float>::write() const {
+  int batch_idx = elem.x * grid.y * n * 2 + elem.y * n * 2;
+  threadgroup float2* seq_buf = buf + elem.y * n;
+
+  int grid_index = elem.x * grid.y + elem.y;
+  short next_out =
+      batch_size % 2 == 1 && grid_index * 2 == batch_size - 1 ? 0 : n;
+
+  short m = grid.z;
+  short fft_idx = elem.z;
+
+  for (int e = 0; e < elems_per_thread; e++) {
+    int index = metal::min(fft_idx + e * m, n - 1);
+    out[batch_idx + index] = seq_buf[index].x / n;
+    out[batch_idx + index + next_out] = seq_buf[index].y / -n;
+  }
+}
+
+template <>
+METAL_FUNC void ReadWriter<float2, float>::load_padded(
+    int length,
+    const device float2* w_k) const {
+  int n_over_2 = (n / 2) + 1;
+  int length_over_2 = (length / 2) + 1;
+
+  size_t batch_idx =
+      size_t(elem.x * grid.y) * length_over_2 * 2 + elem.y * length_over_2 * 2;
+  threadgroup float2* seq_buf = buf + elem.y * n;
+
+  // No out of bounds accesses on odd batch sizes
+  int grid_index = elem.x * grid.y + elem.y;
+  short next_in = batch_size % 2 == 1 && grid_index * 2 == batch_size - 1
+      ? 0
+      : length_over_2;
+
+  short m = grid.z;
+  short fft_idx = elem.z;
+
+  float2 conj = {1, -1};
+  float2 plus_j = {0, 1};
+
+  for (int t = 0; t < elems_per_thread / 2 + 1; t++) {
+    int index = metal::min(fft_idx + t * m, n_over_2 - 1);
+    float2 x = in[batch_idx + index];
+    float2 y = in[batch_idx + index + next_in];
+    if (index < length_over_2) {
+      bool last_val = length % 2 == 0 && index == length_over_2 - 1;
+      if (last_val) {
+        x = float2(x.x, 0);
+        y = float2(y.x, 0);
+      }
+      float2 elem1 = x + complex_mul(y, plus_j);
+      seq_buf[index] = complex_mul(elem1 * conj, w_k[index]);
+      if (index > 0 && !last_val) {
+        float2 elem2 = (x * conj) + complex_mul(y * conj, plus_j);
+        seq_buf[length - index] =
+            complex_mul(elem2 * conj, w_k[length - index]);
+      }
+    } else {
+      short pad_index = metal::min(length + (index - length_over_2) * 2, n - 2);
+      seq_buf[pad_index] = 0;
+      seq_buf[pad_index + 1] = 0;
+    }
+  }
+}
+
+template <>
+METAL_FUNC void ReadWriter<float2, float>::write_padded(
+    int length,
+    const device float2* w_k) const {
+  size_t batch_idx = size_t(elem.x * grid.y) * length * 2 + elem.y * length * 2;
+  threadgroup float2* seq_buf = buf + elem.y * n + length - 1;
+
+  int grid_index = elem.x * grid.y + elem.y;
+  short next_out =
+      batch_size % 2 == 1 && grid_index * 2 == batch_size - 1 ? 0 : length;
+
+  short m = grid.z;
+  short fft_idx = elem.z;
+
+  float2 inv_factor = {1.0f / n, -1.0f / n};
+  for (int e = 0; e < elems_per_thread; e++) {
+    int index = fft_idx + e * m;
+    if (index < length) {
+      float2 output = complex_mul(seq_buf[index] * inv_factor, w_k[index]);
+      out[batch_idx + index] = output.x / length;
+      out[batch_idx + index + next_out] = output.y / -length;
+    }
+  }
+}
+
+// Four Step RFFT
+template <>
+METAL_FUNC void
+ReadWriter<float2, float2, /*step=*/1, /*real=*/true>::load_strided(
+    int stride,
+    int overall_n) {
+  // Silence compiler warnings
+  (void)stride;
+  (void)overall_n;
+  // Don't invert between steps
+  bool default_inv = inv;
+  inv = false;
+  load();
+  inv = default_inv;
+}
+
+template <>
+METAL_FUNC void
+ReadWriter<float2, float2, /*step=*/1, /*real=*/true>::write_strided(
+    int stride,
+    int overall_n) {
+  int overall_n_over_2 = overall_n / 2 + 1;
+  int coalesce_width = grid.y;
+  int tg_idx = elem.y * grid.z + elem.z;
+  int outer_batch_size = stride / coalesce_width;
+
+  int strided_batch_idx = (elem.x % outer_batch_size) * coalesce_width +
+      overall_n_over_2 * (elem.x / outer_batch_size);
+  strided_device_idx = strided_batch_idx +
+      tg_idx / coalesce_width * elems_per_thread / 2 * stride +
+      tg_idx % coalesce_width;
+  strided_shared_idx = (tg_idx % coalesce_width) * n +
+      tg_idx / coalesce_width * elems_per_thread / 2;
+  for (int e = 0; e < elems_per_thread / 2; e++) {
+    float2 output = buf[strided_shared_idx + e];
+    out[strided_device_idx + e * stride] = output;
+  }
+
+  // Add on n/2 + 1 element
+  if (tg_idx == 0 && elem.x % outer_batch_size == 0) {
+    out[strided_batch_idx + overall_n / 2] = buf[n / 2];
+  }
+}
+
+// Four Step IRFFT
+template <>
+METAL_FUNC void
+ReadWriter<float2, float2, /*step=*/0, /*real=*/true>::load_strided(
+    int stride,
+    int overall_n) {
+  int overall_n_over_2 = overall_n / 2 + 1;
+  auto conj = float2(1, -1);
+
+  compute_strided_indices(stride, overall_n);
+  // Translate indices in terms of N - k
+  for (int e = 0; e < elems_per_thread; e++) {
+    int device_idx = strided_device_idx + e * stride;
+    int overall_batch = device_idx / overall_n;
+    int overall_index = device_idx % overall_n;
+    if (overall_index < overall_n_over_2) {
+      device_idx -= overall_batch * (overall_n - overall_n_over_2);
+      buf[strided_shared_idx + e] = in[device_idx] * conj;
+    } else {
+      int conj_idx = overall_n - overall_index;
+      device_idx = overall_batch * overall_n_over_2 + conj_idx;
+      buf[strided_shared_idx + e] = in[device_idx];
+    }
+  }
+}
+
+template <>
+METAL_FUNC void
+ReadWriter<float2, float, /*step=*/1, /*real=*/true>::load_strided(
+    int stride,
+    int overall_n) {
+  // Silence compiler warnings
+  (void)stride;
+  (void)overall_n;
+  bool default_inv = inv;
+  inv = false;
+  load();
+  inv = default_inv;
+}
+
+template <>
+METAL_FUNC void
+ReadWriter<float2, float, /*step=*/1, /*real=*/true>::write_strided(
+    int stride,
+    int overall_n) {
+  compute_strided_indices(stride, overall_n);
+
+  for (int e = 0; e < elems_per_thread; e++) {
+    out[strided_device_idx + e * stride] =
+        pre_out(buf[strided_shared_idx + e], overall_n).x;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fp4_quantized.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fp4_quantized.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b22dc1e55a9b450cff67b3071e2b49146be13f4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fp4_quantized.h
@@ -0,0 +1,1791 @@
+// Copyright © 2025 Apple Inc.
+
+#include <metal_simdgroup>
+#include <metal_stdlib>
+
+constant bool align_M [[function_constant(200)]];
+constant bool align_N [[function_constant(201)]];
+constant bool align_K [[function_constant(202)]];
+
+using namespace metal;
+
+#define MLX_MTL_CONST static constant constexpr const
+
+MLX_MTL_CONST int SIMD_SIZE = 32;
+MLX_MTL_CONST int QUAD_SIZE = 4;
+
+template <int wsize = 8>
+inline constexpr short get_pack_factor() {
+  return wsize / 4;
+}
+
+template <int wsize = 8>
+inline constexpr short get_bytes_per_pack() {
+  return wsize / 8;
+}
+
+template <typename T>
+static inline T dequantize_scale(uint8_t s) {
+  using FOrI = union {
+    bfloat16_t f;
+    uint16_t i;
+  };
+  FOrI out;
+  out.i = (s == 0 ? 0x40 : (static_cast<uint16_t>(s) << 7));
+  return static_cast<T>(out.f);
+}
+
+template <typename T, typename U, int values_per_thread>
+inline void load_vector(const device T* x, thread U* x_thread) {
+  for (int i = 0; i < values_per_thread; i += 4) {
+    x_thread[i] = x[i];
+    x_thread[i + 1] = x[i + 1];
+    x_thread[i + 2] = x[i + 2];
+    x_thread[i + 3] = x[i + 3];
+  }
+}
+
+template <typename T, typename U, int values_per_thread>
+inline void load_vector_safe(const device T* x, thread U* x_thread, int N) {
+  for (int i = 0; i < N; i += 4) {
+    x_thread[i] = x[i];
+    x_thread[i + 1] = x[i + 1];
+    x_thread[i + 2] = x[i + 2];
+    x_thread[i + 3] = x[i + 3];
+  }
+
+  for (int i = N; i < values_per_thread; i++) {
+    x_thread[i] = 0;
+  }
+}
+
+constexpr constant static float MXFP4_LUT[16] = {
+    +0.0f,
+    +0.5f,
+    +1.0f,
+    +1.5f,
+    +2.0f,
+    +3.0f,
+    +4.0f,
+    +6.0f,
+    -0.0f,
+    -0.5f,
+    -1.0f,
+    -1.5f,
+    -2.0f,
+    -3.0f,
+    -4.0f,
+    -6.0f};
+
+template <typename T>
+void load_mxfp4_lut(threadgroup T* lut, uint simd_gid, uint simd_lid) {
+  if (simd_gid == 0 && simd_lid < 16) {
+    lut[simd_lid] = static_cast<T>(MXFP4_LUT[simd_lid]);
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+}
+
+template <typename U, int values_per_thread>
+inline U qdot(
+    const device uint8_t* w,
+    const thread U* x_thread,
+    U scale,
+    const threadgroup U* lut) {
+  U accum = 0;
+  const device uint16_t* ws = (const device uint16_t*)w;
+  for (int i = 0; i < (values_per_thread / 4); i++) {
+    accum +=
+        (x_thread[4 * i] * lut[ws[i] & 0xf] +
+         x_thread[4 * i + 1] * lut[(ws[i] >> 4) & 0xf] +
+         x_thread[4 * i + 2] * lut[(ws[i] >> 8) & 0xf] +
+         x_thread[4 * i + 3] * lut[(ws[i] >> 12) & 0xf]);
+  }
+  return scale * accum;
+}
+
+template <typename U, int values_per_thread>
+inline U qdot_safe(
+    const device uint8_t* w,
+    const thread U* x_thread,
+    U scale,
+    const threadgroup U* lut,
+    int N) {
+  U accum = 0;
+
+  const device uint16_t* ws = (const device uint16_t*)w;
+  for (int i = 0; i < (N / 4); i++) {
+    accum +=
+        (x_thread[4 * i] * lut[ws[i] & 0xf] +
+         x_thread[4 * i + 1] * lut[(ws[i] >> 4) & 0xf] +
+         x_thread[4 * i + 2] * lut[(ws[i] >> 8) & 0xf] +
+         x_thread[4 * i + 3] * lut[(ws[i] >> 12) & 0xf]);
+  }
+  return scale * accum;
+}
+
+template <typename U, int values_per_thread>
+inline void qouter(
+    const thread uint8_t* w,
+    U x,
+    U scale,
+    thread U* result,
+    const threadgroup U* lut) {
+  for (int i = 0; i < (values_per_thread / 2); i++) {
+    result[2 * i] += x * scale * lut[w[i] & 0xf];
+    result[2 * i + 1] += x * scale * lut[(w[i] >> 4) & 0xf];
+  }
+}
+
+template <typename U, int N>
+inline void dequantize(
+    const device uint8_t* w,
+    U scale,
+    threadgroup U* w_local,
+    const threadgroup U* lut) {
+  for (int i = 0; i < (N / 2); i++) {
+    w_local[2 * i] = scale * lut[w[i] & 0xf];
+    w_local[2 * i + 1] = scale * lut[(w[i] >> 4) & 0xf];
+  }
+}
+
+template <
+    typename T,
+    short BROWS,
+    short BCOLS,
+    short dst_ld,
+    short reduction_dim,
+    short tgp_size,
+    short group_size,
+    typename S>
+struct QuantizedBlockLoader {
+  static_assert(
+      BCOLS <= group_size,
+      "The group size should be larger than the columns");
+  static_assert(
+      group_size % BCOLS == 0,
+      "The group size should be divisible by the columns");
+
+  MLX_MTL_CONST short pack_factor = get_pack_factor<8>();
+  MLX_MTL_CONST short bytes_per_pack = get_bytes_per_pack();
+  MLX_MTL_CONST short BCOLS_PACKED = BCOLS / pack_factor;
+  MLX_MTL_CONST short n_reads =
+      (BCOLS_PACKED * BROWS < tgp_size) ? 1 : (BCOLS_PACKED * BROWS) / tgp_size;
+  MLX_MTL_CONST short group_steps = group_size / BCOLS;
+
+  const int src_ld;
+  const int tile_stride;
+  short group_step_cnt;
+  const int group_stride;
+
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  threadgroup T* dst;
+  const device uint8_t* src;
+  const device S* scales;
+  threadgroup T* lut;
+
+  QuantizedBlockLoader(
+      const device uint8_t* src_,
+      const device S* scales_,
+      const int src_ld_,
+      threadgroup T* dst_,
+      threadgroup T* lut_,
+      ushort simd_group_id [[simdgroup_index_in_threadgroup]],
+      ushort simd_lane_id [[thread_index_in_simdgroup]])
+      : src_ld(src_ld_),
+        tile_stride(
+            reduction_dim ? BCOLS_PACKED * bytes_per_pack
+                          : BROWS * src_ld * bytes_per_pack / pack_factor),
+        group_step_cnt(0),
+        group_stride(BROWS * src_ld / group_size),
+        thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(n_reads * thread_idx / BCOLS_PACKED),
+        bj((n_reads * thread_idx) % BCOLS_PACKED),
+        dst(dst_ + bi * dst_ld + bj * pack_factor),
+        src(src_ + bi * src_ld * bytes_per_pack / pack_factor +
+            bj * bytes_per_pack),
+        scales(scales_ + bi * src_ld / group_size),
+        lut(lut_) {
+    load_mxfp4_lut(lut, simd_group_id, simd_lane_id);
+  }
+
+  void load_unsafe() const {
+    if (BCOLS_PACKED * BROWS < tgp_size && bi >= BROWS) {
+      return;
+    }
+
+    T scale = dequantize_scale<T>(*scales);
+    for (int i = 0; i < n_reads; i++) {
+      dequantize<T, pack_factor>(
+          src + i * bytes_per_pack, scale, dst + i * pack_factor, lut);
+    }
+  }
+
+  void load_safe(short2 src_tile_dim) const {
+    if (BCOLS_PACKED * BROWS < tgp_size && bi >= BROWS) {
+      return;
+    }
+
+    if (reduction_dim == 1 && bi >= src_tile_dim.x) {
+      for (int i = 0; i < n_reads * pack_factor; i++) {
+        dst[i] = T(0);
+      }
+      return;
+    }
+
+    if (reduction_dim == 0 && bi >= src_tile_dim.y) {
+      for (int i = 0; i < n_reads * pack_factor; i++) {
+        dst[i] = T(0);
+      }
+      return;
+    }
+
+    T scale = dequantize_scale<T>(*scales);
+    for (int i = 0; i < n_reads; i++) {
+      dequantize<T, pack_factor>(
+          (device uint8_t*)(src + i * bytes_per_pack),
+          scale,
+          dst + i * pack_factor,
+          lut);
+    }
+  }
+
+  void next() {
+    src += tile_stride;
+    if (reduction_dim == 1) {
+      if (group_steps > 1) {
+        group_step_cnt++;
+        if (group_step_cnt == group_steps) {
+          group_step_cnt = 0;
+          scales++;
+        }
+      } else {
+        scales++;
+      }
+    } else {
+      scales += group_stride;
+    }
+  }
+};
+
+template <typename T, int group_size, typename S, int D>
+METAL_FUNC void mxfp4_qmv_quad_impl(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    device T* y,
+    constant int& in_vec_size,
+    const constant int& out_vec_size,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint quad_gid [[quadgroup_index_in_threadgroup]],
+    uint quad_lid [[thread_index_in_quadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]],
+    threadgroup float* lut) {
+  constexpr int quads_per_simd = SIMD_SIZE / QUAD_SIZE;
+  constexpr int pack_factor = 8;
+  constexpr int values_per_thread = D / QUAD_SIZE;
+  constexpr int packs_per_thread = values_per_thread / pack_factor;
+  constexpr int scale_step_per_thread = group_size / values_per_thread;
+  constexpr int results_per_quadgroup = 8;
+
+  typedef float U;
+
+  thread U x_thread[values_per_thread];
+  thread U result[results_per_quadgroup] = {0};
+  load_mxfp4_lut(lut, simd_gid, simd_lid);
+
+  // Adjust positions
+  const int in_vec_size_w = in_vec_size / pack_factor;
+  const int in_vec_size_g = in_vec_size / group_size;
+  const int out_row = tid.y * quads_per_simd * results_per_quadgroup + quad_gid;
+
+  w += out_row * in_vec_size_w + quad_lid * packs_per_thread;
+  scales += out_row * in_vec_size_g + quad_lid / scale_step_per_thread;
+  x += tid.x * in_vec_size + quad_lid * values_per_thread;
+  y += tid.x * out_vec_size + out_row;
+
+  load_vector<T, U, values_per_thread>(x, x_thread);
+
+  for (int row = 0; row < results_per_quadgroup; row++) {
+    auto wl = (const device uint8_t*)(w + row * in_vec_size_w * quads_per_simd);
+    const device S* sl = scales + row * in_vec_size_g * quads_per_simd;
+
+    U s = dequantize_scale<U>(sl[0]);
+    if (row * quads_per_simd + out_row < out_vec_size) {
+      result[row] += qdot<U, values_per_thread>(wl, x_thread, s, lut);
+    }
+  }
+
+  for (int row = 0; row < results_per_quadgroup; row++) {
+    result[row] = quad_sum(result[row]);
+    if (quad_lid == 0 && row * quads_per_simd + out_row < out_vec_size) {
+      y[row * quads_per_simd] = static_cast<T>(result[row]);
+    }
+  }
+}
+
+template <typename T, int group_size, typename S>
+METAL_FUNC void mxfp4_qmv_fast_impl(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    device T* y,
+    const constant int& in_vec_size,
+    const constant int& out_vec_size,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]],
+    threadgroup float* lut) {
+  constexpr int packs_per_thread = 2;
+  constexpr int num_simdgroups = 2;
+  constexpr int results_per_simdgroup = 4;
+  constexpr int pack_factor = get_pack_factor<32>();
+  constexpr int bytes_per_pack = get_bytes_per_pack<32>();
+  constexpr int values_per_thread = pack_factor * packs_per_thread;
+  constexpr int block_size = values_per_thread * SIMD_SIZE;
+  constexpr int scale_step_per_thread = group_size / values_per_thread;
+
+  const device uint8_t* ws = (const device uint8_t*)w;
+
+  typedef float U;
+  thread U x_thread[values_per_thread];
+  thread U result[results_per_simdgroup] = {0};
+  load_mxfp4_lut(lut, simd_gid, simd_lid);
+
+  // Adjust positions
+  const int in_vec_size_w = in_vec_size * bytes_per_pack / pack_factor;
+  const int in_vec_size_g = in_vec_size / group_size;
+  const int out_row = tid.y * (num_simdgroups * results_per_simdgroup) +
+      simd_gid * results_per_simdgroup;
+
+  ws += out_row * in_vec_size_w + simd_lid * packs_per_thread * bytes_per_pack;
+  scales += out_row * in_vec_size_g + simd_lid / scale_step_per_thread;
+  x += tid.x * in_vec_size + simd_lid * values_per_thread;
+  y += tid.x * out_vec_size + out_row;
+
+  for (int k = 0; k < in_vec_size; k += block_size) {
+    load_vector<T, U, values_per_thread>(x, x_thread);
+
+    for (int row = 0; row < results_per_simdgroup; row++) {
+      auto wl = (const device uint8_t*)(ws + row * in_vec_size_w);
+      const device auto* sl = scales + row * in_vec_size_g;
+
+      U s = dequantize_scale<U>(sl[0]);
+      result[row] += qdot<U, values_per_thread>(wl, x_thread, s, lut);
+    }
+
+    ws += block_size * bytes_per_pack / pack_factor;
+    scales += block_size / group_size;
+    x += block_size;
+  }
+
+  for (int row = 0; row < results_per_simdgroup; row++) {
+    result[row] = simd_sum(result[row]);
+    if (simd_lid == 0) {
+      y[row] = static_cast<T>(result[row]);
+    }
+  }
+}
+
+template <typename T, int group_size, typename S>
+METAL_FUNC void mxfp4_qmv_impl(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    device T* y,
+    const constant int& in_vec_size,
+    const constant int& out_vec_size,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]],
+    threadgroup float* lut) {
+  constexpr int num_simdgroups = 2;
+  constexpr int results_per_simdgroup = 4;
+  constexpr int packs_per_thread = 1;
+  constexpr int pack_factor = get_pack_factor<32>();
+  constexpr int bytes_per_pack = get_bytes_per_pack<32>();
+
+  constexpr int values_per_thread = pack_factor * packs_per_thread;
+  constexpr int block_size = values_per_thread * SIMD_SIZE;
+  constexpr int scale_step_per_thread = group_size / values_per_thread;
+
+  const device uint8_t* ws = (const device uint8_t*)w;
+
+  typedef float U;
+
+  thread U x_thread[values_per_thread];
+  thread U result[results_per_simdgroup] = {0};
+  load_mxfp4_lut(lut, simd_gid, simd_lid);
+
+  // Adjust positions
+  const int in_vec_size_w = in_vec_size * bytes_per_pack / pack_factor;
+  const int in_vec_size_g = in_vec_size / group_size;
+  const int out_row = tid.y * (num_simdgroups * results_per_simdgroup) +
+      simd_gid * results_per_simdgroup;
+  const int used_out_row = min(out_vec_size - results_per_simdgroup, out_row);
+
+  if (out_row >= out_vec_size) {
+    return;
+  }
+
+  // In this case we need to properly guard all our reads because there isn't
+  // even 1 tile in the matrix
+  if (out_vec_size < (num_simdgroups * results_per_simdgroup)) {
+    ws +=
+        out_row * in_vec_size_w + simd_lid * packs_per_thread * bytes_per_pack;
+    scales += out_row * in_vec_size_g + simd_lid / scale_step_per_thread;
+    x += tid.x * in_vec_size + simd_lid * values_per_thread;
+    y += tid.x * out_vec_size + out_row;
+
+    int k = 0;
+    for (; k < in_vec_size - block_size; k += block_size) {
+      load_vector<T, U, values_per_thread>(x, x_thread);
+
+      for (int row = 0; out_row + row < out_vec_size; row++) {
+        auto wl = (const device uint8_t*)(ws + row * in_vec_size_w);
+        const device auto* sl = scales + row * in_vec_size_g;
+
+        S s = sl[0];
+        result[row] += qdot<U, values_per_thread>(wl, x_thread, s, lut);
+      }
+
+      ws += block_size * bytes_per_pack / pack_factor;
+      scales += block_size / group_size;
+      x += block_size;
+    }
+    const int remaining = clamp(
+        static_cast<int>(in_vec_size - k - simd_lid * values_per_thread),
+        0,
+        values_per_thread);
+    if (remaining > 0) {
+      load_vector_safe<T, U, values_per_thread>(x, x_thread, remaining);
+
+      for (int row = 0; out_row + row < out_vec_size; row++) {
+        auto wl = (const device uint8_t*)(ws + row * in_vec_size_w);
+        const device auto* sl = scales + row * in_vec_size_g;
+
+        U s = dequantize_scale<U>(sl[0]);
+        result[row] += qdot<U, values_per_thread>(wl, x_thread, s, lut);
+      }
+    }
+
+    for (int row = 0; out_row + row < out_vec_size; row++) {
+      result[row] = simd_sum(result[row]);
+      if (simd_lid == 0) {
+        y[row] = static_cast<T>(result[row]);
+      }
+    }
+  }
+
+  // In this case the last tile is moved back to redo some output values
+  else {
+    ws += used_out_row * in_vec_size_w +
+        simd_lid * packs_per_thread * bytes_per_pack;
+    scales += used_out_row * in_vec_size_g + simd_lid / scale_step_per_thread;
+    x += tid.x * in_vec_size + simd_lid * values_per_thread;
+    y += tid.x * out_vec_size + used_out_row;
+
+    int k = 0;
+    for (; k < in_vec_size - block_size; k += block_size) {
+      load_vector<T, U, values_per_thread>(x, x_thread);
+
+      for (int row = 0; row < results_per_simdgroup; row++) {
+        auto wl = (const device uint8_t*)(ws + row * in_vec_size_w);
+        const device auto* sl = scales + row * in_vec_size_g;
+
+        U s = dequantize_scale<U>(sl[0]);
+        result[row] += qdot<U, values_per_thread>(wl, x_thread, s, lut);
+      }
+
+      ws += block_size * bytes_per_pack / pack_factor;
+      scales += block_size / group_size;
+      x += block_size;
+    }
+    const int remaining = clamp(
+        static_cast<int>(in_vec_size - k - simd_lid * values_per_thread),
+        0,
+        values_per_thread);
+    if (remaining > 0) {
+      load_vector_safe<T, U, values_per_thread>(x, x_thread, remaining);
+
+      for (int row = 0; row < results_per_simdgroup; row++) {
+        auto wl = (const device uint8_t*)(ws + row * in_vec_size_w);
+        const device auto* sl = scales + row * in_vec_size_g;
+
+        U s = dequantize_scale<U>(sl[0]);
+        result[row] +=
+            qdot_safe<U, values_per_thread>(wl, x_thread, s, lut, remaining);
+      }
+    }
+    for (int row = 0; row < results_per_simdgroup; row++) {
+      result[row] = simd_sum(result[row]);
+      if (simd_lid == 0) {
+        y[row] = static_cast<T>(result[row]);
+      }
+    }
+  }
+}
+
+template <typename T, const int group_size, typename S>
+METAL_FUNC void mxfp4_qvm_impl(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    device T* y,
+    const int in_vec_size,
+    const int out_vec_size,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]],
+    threadgroup float* lut) {
+  constexpr int num_simdgroups = 2;
+  constexpr int pack_factor = get_pack_factor<32>();
+  constexpr int bytes_per_pack = get_bytes_per_pack();
+
+  constexpr int tn = 32 / pack_factor;
+  constexpr int block_size = SIMD_SIZE;
+
+  using W_T = uint32_t;
+  const device W_T* ws = (const device W_T*)w;
+
+  typedef float U;
+  typedef struct {
+    W_T wi[tn * bytes_per_pack];
+  } vec_w;
+
+  thread vec_w w_local;
+  thread U result[tn * pack_factor] = {0};
+  thread U scale = 0;
+  thread U x_local = 0;
+
+  load_mxfp4_lut(lut, simd_gid, simd_lid);
+
+  // Adjust positions
+  const int out_vec_size_w = out_vec_size * bytes_per_pack / pack_factor;
+  const int out_vec_size_g = out_vec_size / group_size;
+  int out_col = pack_factor * tn * (tid.y * num_simdgroups + simd_gid);
+  ws += out_col * bytes_per_pack / pack_factor + simd_lid * out_vec_size_w;
+  scales += out_col / group_size + simd_lid * out_vec_size_g;
+  x += tid.x * in_vec_size + simd_lid;
+  y += tid.x * out_vec_size + out_col;
+
+  if (out_col >= out_vec_size) {
+    return;
+  }
+
+  // Loop over in_vec in blocks of block_size
+  int remaining = in_vec_size % block_size;
+  if (remaining == 0) {
+    for (int i = 0; i < in_vec_size; i += block_size) {
+      x_local = *x;
+      scale = dequantize_scale<U>(*scales);
+      w_local = *((device vec_w*)ws);
+      qouter<U, tn * pack_factor>(
+          (thread uint8_t*)&w_local, x_local, scale, result, lut);
+
+      x += block_size;
+      scales += block_size * out_vec_size_g;
+      ws += block_size * out_vec_size_w;
+    }
+  } else {
+    for (int i = block_size; i < in_vec_size; i += block_size) {
+      x_local = *x;
+      scale = dequantize_scale<U>(*scales);
+      w_local = *((device vec_w*)ws);
+
+      qouter<U, tn * pack_factor>(
+          (thread uint8_t*)&w_local, x_local, scale, result, lut);
+
+      x += block_size;
+      scales += block_size * out_vec_size_g;
+      ws += block_size * out_vec_size_w;
+    }
+    if (static_cast<int>(simd_lid) < remaining) {
+      x_local = *x;
+      scale = dequantize_scale<U>(*scales);
+      w_local = *((device vec_w*)ws);
+    } else {
+      x_local = 0;
+      scale = 0;
+    }
+    qouter<U, tn * pack_factor>(
+        (thread uint8_t*)&w_local, x_local, scale, result, lut);
+  }
+
+// Accumulate in the simdgroup
+#pragma clang loop unroll(full)
+  for (int k = 0; k < tn * pack_factor; k++) {
+    result[k] = simd_sum(result[k]);
+  }
+
+  // Store the result
+  if (simd_lid == 0) {
+#pragma clang loop unroll(full)
+    for (int k = 0; k < tn * pack_factor; k++) {
+      y[k] = static_cast<T>(result[k]);
+    }
+  }
+}
+
+template <
+    typename T,
+    const int group_size,
+    typename S,
+    const bool aligned_N,
+    const int BM = 32,
+    const int BK = 32,
+    const int BN = 32>
+METAL_FUNC void mxfp4_qmm_t_impl(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    device T* y,
+    threadgroup T* Xs,
+    threadgroup T* Ws,
+    const constant int& K,
+    const constant int& N,
+    const constant int& M,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint lid [[thread_index_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]],
+    threadgroup T* lut) {
+  static_assert(BK >= SIMD_SIZE, "BK should be larger than SIMD_SIZE");
+  static_assert(BK % SIMD_SIZE == 0, "BK should be divisible by SIMD_SIZE");
+
+  (void)lid;
+
+  constexpr int WM = 2;
+  constexpr int WN = 2;
+  constexpr int pack_factor = get_pack_factor<8>();
+  constexpr int bytes_per_pack = get_bytes_per_pack();
+
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+
+  // Instantiate the appropriate BlockMMA and Loader
+  using mma_t = mlx::steel::
+      BlockMMA<T, T, BM, BN, BK, WM, WN, false, true, BK_padded, BK_padded>;
+  using loader_x_t =
+      mlx::steel::BlockLoader<T, BM, BK, BK_padded, 1, WM * WN * SIMD_SIZE>;
+  using loader_w_t = QuantizedBlockLoader<
+      T,
+      BN,
+      BK,
+      BK_padded,
+      1,
+      WM * WN * SIMD_SIZE,
+      group_size,
+      S>;
+
+  // Set the block
+  const int K_w = K * bytes_per_pack / pack_factor;
+  const int K_g = K / group_size;
+  const int y_row = tid.y * BM;
+  const int y_col = tid.x * BN;
+
+  auto wl = (const device uint8_t*)w;
+
+  x += y_row * static_cast<int64_t>(K);
+  wl += y_col * K_w;
+  scales += y_col * K_g;
+  y += y_row * static_cast<int64_t>(N) + y_col;
+
+  // Make the x loader and mma operation
+  const short num_els = min(BM, M - y_row);
+  const short num_outs = min(BN, N - y_col);
+  loader_x_t loader_x(x, K, Xs, simd_gid, simd_lid);
+  loader_w_t loader_w(wl, scales, K, Ws, lut, simd_gid, simd_lid);
+  mma_t mma_op(simd_gid, simd_lid);
+
+  if (num_els < BM) {
+    if (!aligned_N && num_outs < BN) {
+      for (int k = 0; k < K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_safe(short2(BK, num_els));
+        loader_w.load_safe(short2(BK, num_outs));
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+    } else {
+      for (int k = 0; k < K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_safe(short2(BK, num_els));
+        loader_w.load_unsafe();
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+    }
+  } else {
+    if (!aligned_N && num_outs < BN) {
+      for (int k = 0; k < K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_unsafe();
+        loader_w.load_safe(short2(BK, num_outs));
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+    } else {
+      for (int k = 0; k < K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_unsafe();
+        loader_w.load_unsafe();
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+    }
+  }
+
+  // Store results to device memory
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (num_els < BM || num_outs < BN) {
+    mma_op.store_result_safe(y, N, short2(num_outs, num_els));
+  } else {
+    mma_op.store_result(y, N);
+  }
+}
+
+template <
+    typename T,
+    const int group_size,
+    typename S,
+    const int BM = 32,
+    const int BK = 32,
+    const int BN = 32>
+METAL_FUNC void mxfp4_qmm_n_impl(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    device T* y,
+    threadgroup T* Xs,
+    threadgroup T* Ws,
+    const constant int& K,
+    const constant int& N,
+    const constant int& M,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint lid [[thread_index_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]],
+    threadgroup T* lut) {
+  static_assert(BK >= SIMD_SIZE, "BK should be larger than SIMD_SIZE");
+  static_assert(BK % SIMD_SIZE == 0, "BK should be divisible by SIMD_SIZE");
+
+  (void)lid;
+
+  constexpr int WM = 2;
+  constexpr int WN = 2;
+  constexpr int pack_factor = get_pack_factor<8>();
+  constexpr int bytes_per_pack = get_bytes_per_pack();
+
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+  constexpr int BN_padded = (BN + 16 / sizeof(T));
+
+  // Instantiate the appropriate BlockMMA and Loader
+  using mma_t = mlx::steel::
+      BlockMMA<T, T, BM, BN, BK, WM, WN, false, false, BK_padded, BN_padded>;
+  using loader_x_t = mlx::steel::
+      BlockLoader<T, BM, BK, BK_padded, 1, WM * WN * SIMD_SIZE, 1, 4>;
+  using loader_w_t = QuantizedBlockLoader<
+      T,
+      BK,
+      BN,
+      BN_padded,
+      0,
+      WM * WN * SIMD_SIZE,
+      group_size,
+      S>;
+
+  auto wl = (const device uint8_t*)w;
+
+  // Set the block
+  const int y_row = tid.y * BM;
+  const int y_col = tid.x * BN;
+  x += y_row * static_cast<int64_t>(K);
+  wl += y_col * bytes_per_pack / pack_factor;
+  scales += y_col / group_size;
+  y += y_row * static_cast<int64_t>(N) + y_col;
+
+  // Make the x loader and mma operation
+  const short num_els = min(BM, M - y_row);
+  loader_x_t loader_x(x, K, Xs, simd_gid, simd_lid);
+  loader_w_t loader_w(wl, scales, N, Ws, lut, simd_gid, simd_lid);
+  mma_t mma_op(simd_gid, simd_lid);
+
+  if (num_els < BM) {
+    if ((K % BK) != 0) {
+      const int k_blocks = K / BK;
+      for (int k = 0; k < k_blocks; k++) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_safe(short2(BK, num_els));
+        loader_w.load_unsafe();
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+      const short num_k = K - k_blocks * BK;
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      loader_x.load_safe(short2(num_k, num_els));
+      loader_w.load_safe(short2(BN, num_k));
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      mma_op.mma(Xs, Ws);
+    } else {
+      for (int k = 0; k < K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_safe(short2(BK, num_els));
+        loader_w.load_unsafe();
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+    }
+  } else {
+    if ((K % BK) != 0) {
+      const int k_blocks = K / BK;
+      for (int k = 0; k < k_blocks; k++) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_unsafe();
+        loader_w.load_unsafe();
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+      const short num_k = K - k_blocks * BK;
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      loader_x.load_safe(short2(num_k, BM));
+      loader_w.load_safe(short2(BN, num_k));
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      mma_op.mma(Xs, Ws);
+    } else {
+      for (int k = 0; k < K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_unsafe();
+        loader_w.load_unsafe();
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+    }
+  }
+
+  // Store results to device memory
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (num_els < BM) {
+    mma_op.store_result_safe(y, N, short2(BN, num_els));
+  } else {
+    mma_op.store_result(y, N);
+  }
+}
+
+template <typename T, typename S>
+METAL_FUNC void adjust_matrix_offsets(
+    const device T*& x,
+    const device uint32_t*& w,
+    const device S*& scales,
+    device T*& y,
+    int output_stride,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    uint3 tid [[threadgroup_position_in_grid]]) {
+  // Set the input/output matrices
+  uint32_t x_idx = tid.z;
+  uint32_t w_idx = tid.z;
+  if (x_batch_ndims == 1) {
+    x += x_idx * x_strides[0];
+  } else {
+    x += elem_to_loc(x_idx, x_shape, x_strides, x_batch_ndims);
+  }
+  if (w_batch_ndims == 1) {
+    w += w_idx * w_strides[0];
+    scales += w_idx * s_strides[0];
+  } else {
+    ulong2 idx = elem_to_loc_broadcast(
+        w_idx, w_shape, w_strides, s_strides, w_batch_ndims);
+    w += idx.x;
+    scales += idx.y;
+  }
+  y += tid.z * output_stride;
+}
+
+template <typename T, typename S>
+METAL_FUNC void adjust_matrix_offsets(
+    const device T*& x,
+    const device uint32_t*& w,
+    const device S*& scales,
+    const device uint32_t* lhs_indices,
+    const device uint32_t* rhs_indices,
+    device T*& y,
+    int output_stride,
+    const constant int& batch_ndims,
+    const constant int* batch_shape,
+    const constant int64_t* lhs_strides,
+    const constant int64_t* rhs_strides,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    uint3 tid [[threadgroup_position_in_grid]]) {
+  // Set the input/output matrices
+  uint32_t x_idx;
+  uint32_t w_idx;
+  if (batch_ndims == 1) {
+    x_idx = lhs_indices[tid.z * lhs_strides[0]];
+    w_idx = rhs_indices[tid.z * rhs_strides[0]];
+  } else {
+    ulong2 idx = elem_to_loc_broadcast(
+        tid.z, batch_shape, lhs_strides, rhs_strides, batch_ndims);
+    x_idx = lhs_indices[idx.x];
+    w_idx = rhs_indices[idx.y];
+  }
+  if (x_batch_ndims == 1) {
+    x += x_idx * x_strides[0];
+  } else {
+    x += elem_to_loc(x_idx, x_shape, x_strides, x_batch_ndims);
+  }
+  if (w_batch_ndims == 1) {
+    w += w_idx * w_strides[0];
+    scales += w_idx * s_strides[0];
+  } else {
+    ulong2 idx = elem_to_loc_broadcast(
+        w_idx, w_shape, w_strides, s_strides, w_batch_ndims);
+    w += idx.x;
+    scales += idx.y;
+  }
+  y += tid.z * output_stride;
+}
+
+template <typename T, int group_size, typename S, int D, bool batched>
+[[kernel]] void mxfp4_qmv_quad(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    device T* y,
+    const constant int& in_vec_size,
+    const constant int& out_vec_size,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint quad_gid [[quadgroup_index_in_threadgroup]],
+    uint quad_lid [[thread_index_in_quadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  if (batched) {
+    int M = x_shape[x_batch_ndims];
+    adjust_matrix_offsets(
+        x,
+        w,
+        scales,
+        y,
+        out_vec_size * M,
+        x_batch_ndims,
+        x_shape,
+        x_strides,
+        w_batch_ndims,
+        w_shape,
+        w_strides,
+        s_strides,
+        tid);
+  }
+  threadgroup float lut[16];
+  mxfp4_qmv_quad_impl<T, group_size, S, D>(
+      w,
+      scales,
+      x,
+      y,
+      in_vec_size,
+      out_vec_size,
+      tid,
+      quad_gid,
+      quad_lid,
+      simd_gid,
+      simd_lid,
+      lut);
+}
+
+template <typename T, int group_size, typename S, bool batched>
+[[kernel]] void mxfp4_qmv_fast(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    device T* y,
+    const constant int& in_vec_size,
+    const constant int& out_vec_size,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  if (batched) {
+    int M = x_shape[x_batch_ndims];
+    adjust_matrix_offsets(
+        x,
+        w,
+        scales,
+        y,
+        out_vec_size * M,
+        x_batch_ndims,
+        x_shape,
+        x_strides,
+        w_batch_ndims,
+        w_shape,
+        w_strides,
+        s_strides,
+        tid);
+  }
+  threadgroup float lut[16];
+  mxfp4_qmv_fast_impl<T, group_size>(
+      w, scales, x, y, in_vec_size, out_vec_size, tid, simd_gid, simd_lid, lut);
+}
+
+template <typename T, const int group_size, typename S, bool batched>
+[[kernel]] void mxfp4_qmv(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    device T* y,
+    const constant int& in_vec_size,
+    const constant int& out_vec_size,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  if (batched) {
+    int M = x_shape[x_batch_ndims];
+    adjust_matrix_offsets(
+        x,
+        w,
+        scales,
+        y,
+        out_vec_size * M,
+        x_batch_ndims,
+        x_shape,
+        x_strides,
+        w_batch_ndims,
+        w_shape,
+        w_strides,
+        s_strides,
+        tid);
+  }
+  threadgroup float lut[16];
+  mxfp4_qmv_impl<T, group_size>(
+      w, scales, x, y, in_vec_size, out_vec_size, tid, simd_gid, simd_lid, lut);
+}
+
+template <typename T, const int group_size, typename S, bool batched>
+[[kernel]] void mxfp4_qvm(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    device T* y,
+    const constant int& in_vec_size,
+    const constant int& out_vec_size,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  if (batched) {
+    int M = x_shape[x_batch_ndims];
+    adjust_matrix_offsets(
+        x,
+        w,
+        scales,
+        y,
+        out_vec_size * M,
+        x_batch_ndims,
+        x_shape,
+        x_strides,
+        w_batch_ndims,
+        w_shape,
+        w_strides,
+        s_strides,
+        tid);
+  }
+  threadgroup float lut[16];
+  mxfp4_qvm_impl<T, group_size>(
+      w, scales, x, y, in_vec_size, out_vec_size, tid, simd_gid, simd_lid, lut);
+}
+
+template <typename T, const int group_size, typename S, int split_k = 32>
+[[kernel]] void mxfp4_qvm_split_k(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    device T* y,
+    const constant int& in_vec_size,
+    const constant int& out_vec_size,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    const constant int& final_block_size,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  int M = x_shape[x_batch_ndims];
+  adjust_matrix_offsets(
+      x,
+      w,
+      scales,
+      y,
+      out_vec_size * M,
+      x_batch_ndims,
+      x_shape,
+      x_strides,
+      w_batch_ndims,
+      w_shape,
+      w_strides,
+      s_strides,
+      tid);
+
+  // When (in_vec_size % split_k != 0) the final block needs to be smaller
+  int in_vec_size_adj =
+      tid.z % split_k == split_k - 1 ? final_block_size : in_vec_size;
+
+  threadgroup float lut[16];
+  mxfp4_qvm_impl<T, group_size>(
+      w,
+      scales,
+      x,
+      y,
+      in_vec_size_adj,
+      out_vec_size,
+      tid,
+      simd_gid,
+      simd_lid,
+      lut);
+}
+
+template <
+    typename T,
+    const int group_size,
+    typename S,
+    const bool aligned_N,
+    const bool batched,
+    const int BM = 32,
+    const int BK = 32,
+    const int BN = 32>
+[[kernel]] void mxfp4_qmm_t(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    device T* y,
+    const constant int& K,
+    const constant int& N,
+    const constant int& M,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint lid [[thread_index_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  (void)lid;
+
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+
+  threadgroup T Xs[BM * BK_padded];
+  threadgroup T Ws[BN * BK_padded];
+  threadgroup T lut[16];
+
+  if (batched) {
+    adjust_matrix_offsets(
+        x,
+        w,
+        scales,
+        y,
+        M * N,
+        x_batch_ndims,
+        x_shape,
+        x_strides,
+        w_batch_ndims,
+        w_shape,
+        w_strides,
+        s_strides,
+        tid);
+  }
+  mxfp4_qmm_t_impl<T, group_size, S, aligned_N, BM, BK, BN>(
+      w, scales, x, y, Xs, Ws, K, N, M, tid, lid, simd_gid, simd_lid, lut);
+}
+
+template <
+    typename T,
+    const int group_size,
+    typename S,
+    const bool batched,
+    const int BM = 32,
+    const int BK = 32,
+    const int BN = 32>
+[[kernel]] void mxfp4_qmm_n(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    device T* y,
+    const constant int& K,
+    const constant int& N,
+    const constant int& M,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint lid [[thread_index_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  (void)lid;
+
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+  constexpr int BN_padded = (BN + 16 / sizeof(T));
+
+  threadgroup T Xs[BM * BK_padded];
+  threadgroup T Ws[BK * BN_padded];
+  threadgroup T lut[16];
+
+  if (batched) {
+    adjust_matrix_offsets(
+        x,
+        w,
+        scales,
+        y,
+        M * N,
+        x_batch_ndims,
+        x_shape,
+        x_strides,
+        w_batch_ndims,
+        w_shape,
+        w_strides,
+        s_strides,
+        tid);
+  }
+
+  mxfp4_qmm_n_impl<T, group_size, S, BM, BK, BN>(
+      w, scales, x, y, Xs, Ws, K, N, M, tid, lid, simd_gid, simd_lid, lut);
+}
+
+template <typename T, int group_size, typename S>
+[[kernel]] void mxfp4_gather_qmv_fast(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    const device uint32_t* lhs_indices,
+    const device uint32_t* rhs_indices,
+    device T* y,
+    const constant int& in_vec_size,
+    const constant int& out_vec_size,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    const constant int& batch_ndims,
+    const constant int* batch_shape,
+    const constant int64_t* lhs_strides,
+    const constant int64_t* rhs_strides,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  int M = x_shape[x_batch_ndims];
+  adjust_matrix_offsets(
+      x,
+      w,
+      scales,
+      lhs_indices,
+      rhs_indices,
+      y,
+      out_vec_size * M,
+      batch_ndims,
+      batch_shape,
+      lhs_strides,
+      rhs_strides,
+      x_batch_ndims,
+      x_shape,
+      x_strides,
+      w_batch_ndims,
+      w_shape,
+      w_strides,
+      s_strides,
+      tid);
+  threadgroup float lut[16];
+  mxfp4_qmv_fast_impl<T, group_size>(
+      w, scales, x, y, in_vec_size, out_vec_size, tid, simd_gid, simd_lid, lut);
+}
+
+template <typename T, int group_size, typename S>
+[[kernel]] void mxfp4_gather_qmv(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    const device uint32_t* lhs_indices,
+    const device uint32_t* rhs_indices,
+    device T* y,
+    const constant int& in_vec_size,
+    const constant int& out_vec_size,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    const constant int& batch_ndims,
+    const constant int* batch_shape,
+    const constant int64_t* lhs_strides,
+    const constant int64_t* rhs_strides,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  int M = x_shape[x_batch_ndims];
+  adjust_matrix_offsets(
+      x,
+      w,
+      scales,
+      lhs_indices,
+      rhs_indices,
+      y,
+      out_vec_size * M,
+      batch_ndims,
+      batch_shape,
+      lhs_strides,
+      rhs_strides,
+      x_batch_ndims,
+      x_shape,
+      x_strides,
+      w_batch_ndims,
+      w_shape,
+      w_strides,
+      s_strides,
+      tid);
+  threadgroup float lut[16];
+  mxfp4_qmv_impl<T, group_size>(
+      w, scales, x, y, in_vec_size, out_vec_size, tid, simd_gid, simd_lid, lut);
+}
+
+template <typename T, int group_size, typename S>
+[[kernel]] void mxfp4_gather_qvm(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    const device uint32_t* lhs_indices,
+    const device uint32_t* rhs_indices,
+    device T* y,
+    const constant int& in_vec_size,
+    const constant int& out_vec_size,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    const constant int& batch_ndims,
+    const constant int* batch_shape,
+    const constant int64_t* lhs_strides,
+    const constant int64_t* rhs_strides,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  int M = x_shape[x_batch_ndims];
+  adjust_matrix_offsets(
+      x,
+      w,
+      scales,
+      lhs_indices,
+      rhs_indices,
+      y,
+      out_vec_size * M,
+      batch_ndims,
+      batch_shape,
+      lhs_strides,
+      rhs_strides,
+      x_batch_ndims,
+      x_shape,
+      x_strides,
+      w_batch_ndims,
+      w_shape,
+      w_strides,
+      s_strides,
+      tid);
+  threadgroup float lut[16];
+  mxfp4_qvm_impl<T, group_size>(
+      w, scales, x, y, in_vec_size, out_vec_size, tid, simd_gid, simd_lid, lut);
+}
+
+template <
+    typename T,
+    const int group_size,
+    typename S,
+    const bool aligned_N,
+    const int BM = 32,
+    const int BK = 32,
+    const int BN = 32>
+[[kernel]] void mxfp4_gather_qmm_t(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    const device uint32_t* lhs_indices,
+    const device uint32_t* rhs_indices,
+    device T* y,
+    const constant int& K,
+    const constant int& N,
+    const constant int& M,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    const constant int& batch_ndims,
+    const constant int* batch_shape,
+    const constant int64_t* lhs_strides,
+    const constant int64_t* rhs_strides,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint lid [[thread_index_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  (void)lid;
+
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+
+  threadgroup T Xs[BM * BK_padded];
+  threadgroup T Ws[BN * BK_padded];
+  threadgroup T lut[16];
+
+  adjust_matrix_offsets(
+      x,
+      w,
+      scales,
+      lhs_indices,
+      rhs_indices,
+      y,
+      M * N,
+      batch_ndims,
+      batch_shape,
+      lhs_strides,
+      rhs_strides,
+      x_batch_ndims,
+      x_shape,
+      x_strides,
+      w_batch_ndims,
+      w_shape,
+      w_strides,
+      s_strides,
+      tid);
+  mxfp4_qmm_t_impl<T, group_size, S, aligned_N, BM, BK, BN>(
+      w, scales, x, y, Xs, Ws, K, N, M, tid, lid, simd_gid, simd_lid, lut);
+}
+
+template <
+    typename T,
+    const int group_size,
+    typename S,
+    const int BM = 32,
+    const int BK = 32,
+    const int BN = 32>
+[[kernel]] void mxfp4_gather_qmm_n(
+    const device uint32_t* w,
+    const device S* scales,
+    const device T* x,
+    const device uint32_t* lhs_indices,
+    const device uint32_t* rhs_indices,
+    device T* y,
+    const constant int& K,
+    const constant int& N,
+    const constant int& M,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    const constant int& batch_ndims,
+    const constant int* batch_shape,
+    const constant int64_t* lhs_strides,
+    const constant int64_t* rhs_strides,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint lid [[thread_index_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  (void)lid;
+
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+  constexpr int BN_padded = (BN + 16 / sizeof(T));
+
+  threadgroup T Xs[BM * BK_padded];
+  threadgroup T Ws[BK * BN_padded];
+  threadgroup T lut[16];
+
+  adjust_matrix_offsets(
+      x,
+      w,
+      scales,
+      lhs_indices,
+      rhs_indices,
+      y,
+      M * N,
+      batch_ndims,
+      batch_shape,
+      lhs_strides,
+      rhs_strides,
+      x_batch_ndims,
+      x_shape,
+      x_strides,
+      w_batch_ndims,
+      w_shape,
+      w_strides,
+      s_strides,
+      tid);
+  mxfp4_qmm_n_impl<T, group_size, S, BM, BK, BN>(
+      w, scales, x, y, Xs, Ws, K, N, M, tid, lid, simd_gid, simd_lid, lut);
+}
+
+template <
+    typename T,
+    int group_size,
+    typename S,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose>
+[[kernel]] void mxfp4_gather_qmm_rhs(
+    const device T* x,
+    const device uint32_t* w,
+    const device S* scales,
+    const device uint32_t* indices,
+    device T* y,
+    const constant int& M,
+    const constant int& N,
+    const constant int& K,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]]) {
+  constexpr int pack_factor = get_pack_factor<8>();
+  constexpr int bytes_per_pack = get_bytes_per_pack();
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+  constexpr int BN_padded = (BN + 16 / sizeof(T));
+  threadgroup T lut[16];
+
+  using mma_t = mlx::steel::BlockMMA<
+      T,
+      T,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      false,
+      transpose,
+      BK_padded,
+      transpose ? BK_padded : BN_padded>;
+  using loader_x_t =
+      mlx::steel::BlockLoader<T, BM, BK, BK_padded, 1, WM * WN * SIMD_SIZE>;
+  using loader_w_t = QuantizedBlockLoader<
+      T,
+      transpose ? BN : BK,
+      transpose ? BK : BN,
+      transpose ? BK_padded : BN_padded,
+      transpose,
+      WM * WN * SIMD_SIZE,
+      group_size,
+      S>;
+
+  threadgroup T Xs[BM * BK_padded];
+  threadgroup T Ws[transpose ? BN * BK_padded : BK * BN_padded];
+
+  // Compute the block
+  const int K_w = K * bytes_per_pack / pack_factor;
+  const int K_g = K / group_size;
+  const int N_w = N * bytes_per_pack / pack_factor;
+  const int N_g = N / group_size;
+  const int K_it = K / BK;
+  const size_t stride_w = transpose ? N * K_w : K * N_w;
+  const size_t stride_s = transpose ? N * K_g : K * N_g;
+  const int y_row = tid.y * BM;
+  const int y_col = tid.x * BN;
+  const size_t y_row_long = size_t(y_row);
+  const size_t y_col_long = size_t(y_col);
+
+  // Prepare threadgroup bounds
+  const short tgp_bm = align_M ? BM : short(min(BM, M - y_row));
+  const short tgp_bn = align_N ? BN : short(min(BN, N - y_col));
+
+  // Calculate the final tiles in the case that K is not aligned
+  const int k_remain = K - K_it * BK;
+  const short2 tile_x = short2(k_remain, tgp_bm);
+  const short2 tile_w =
+      transpose ? short2(k_remain, tgp_bn) : short2(tgp_bn, k_remain);
+
+  // Move x and output to the correct block
+  auto wl = (const device uint8_t*)w;
+  x += y_row_long * K;
+  y += y_row_long * N + y_col_long;
+  wl += transpose ? y_col_long * K_w : y_col * bytes_per_pack / pack_factor;
+  scales += transpose ? y_col_long * K_g : y_col / group_size;
+
+  // Do as many matmuls as necessary
+  uint32_t index;
+  short offset;
+  uint32_t index_next = indices[y_row];
+  short offset_next = 0;
+  int n = 0;
+  while (n < tgp_bm) {
+    n++;
+    offset = offset_next;
+    index = index_next;
+    offset_next = tgp_bm;
+    for (; n < tgp_bm; n++) {
+      if (indices[y_row + n] != index) {
+        offset_next = n;
+        index_next = indices[y_row + n];
+        break;
+      }
+    }
+    threadgroup_barrier(mem_flags::mem_none);
+
+    // Prepare threadgroup mma operation
+    thread mma_t mma_op(simd_group_id, simd_lane_id);
+
+    // Prepare threadgroup loading operations
+    thread loader_x_t loader_x(x, K, Xs, simd_group_id, simd_lane_id);
+    thread loader_w_t loader_w(
+        wl + index * stride_w,
+        scales + index * stride_s,
+        transpose ? K : N,
+        Ws,
+        lut,
+        simd_group_id,
+        simd_lane_id);
+
+    // Matrices are all aligned check nothing
+    if (align_M && align_N) {
+      gemm_loop_aligned(Xs, Ws, mma_op, loader_x, loader_w, K_it);
+      if (!align_K) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        gemm_loop_finalize(Xs, Ws, mma_op, loader_x, loader_w, tile_x, tile_w);
+      }
+
+      // Store results to device memory
+      if (offset_next - offset == BM) {
+        mma_op.store_result(y, N);
+      } else {
+        mma_op.store_result_slice(
+            y, N, short2(0, offset), short2(BN, offset_next));
+      }
+    } else {
+      // Tile aligned so check outside of the hot loop
+      if ((align_M || tgp_bm == BM) && (align_N || tgp_bn == BN)) {
+        gemm_loop_aligned(Xs, Ws, mma_op, loader_x, loader_w, K_it);
+        if (!align_K) {
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+          gemm_loop_finalize(
+              Xs, Ws, mma_op, loader_x, loader_w, tile_x, tile_w);
+        }
+
+        // Store results to device memory
+        if (offset_next - offset == BM) {
+          mma_op.store_result(y, N);
+        } else {
+          mma_op.store_result_slice(
+              y, N, short2(0, offset), short2(BN, offset_next));
+        }
+      }
+
+      // Tile partially aligned check rows
+      else if (align_N || tgp_bn == BN) {
+        gemm_loop_unaligned<false, true, transpose>(
+            Xs, Ws, mma_op, loader_x, loader_w, K_it, tgp_bm, tgp_bn, BK);
+        if (!align_K) {
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+          gemm_loop_finalize(
+              Xs, Ws, mma_op, loader_x, loader_w, tile_x, tile_w);
+        }
+        mma_op.store_result_slice(
+            y, N, short2(0, offset), short2(BN, offset_next));
+      }
+
+      // Tile partially aligned check cols
+      else if (align_M || tgp_bm == BM) {
+        gemm_loop_unaligned<true, false, transpose>(
+            Xs, Ws, mma_op, loader_x, loader_w, K_it, tgp_bm, tgp_bn, BK);
+        if (!align_K) {
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+          gemm_loop_finalize(
+              Xs, Ws, mma_op, loader_x, loader_w, tile_x, tile_w);
+        }
+        mma_op.store_result_slice(
+            y, N, short2(0, offset), short2(tgp_bn, offset_next));
+      }
+
+      // Nothing aligned so check both rows and cols
+      else {
+        gemm_loop_unaligned<false, false, transpose>(
+            Xs, Ws, mma_op, loader_x, loader_w, K_it, tgp_bm, tgp_bn, BK);
+        if (!align_K) {
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+          gemm_loop_finalize(
+              Xs, Ws, mma_op, loader_x, loader_w, tile_x, tile_w);
+        }
+        mma_op.store_result_slice(
+            y, N, short2(0, offset), short2(tgp_bn, offset_next));
+      }
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fp4_quantized.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fp4_quantized.metal
new file mode 100644
index 0000000000000000000000000000000000000000..6b2daf88c39dfdfa2456fd9021cd1a31a5980661
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/fp4_quantized.metal
@@ -0,0 +1,127 @@
+// Copyright © 2025 Apple Inc.
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/steel/gemm/gemm.h"
+#include "mlx/backend/metal/kernels/quantized_utils.h"
+#include "mlx/backend/metal/kernels/fp4_quantized.h"
+
+#define instantiate_quantized(name, type) \
+  instantiate_kernel( \
+      #name "_" #type "_gs_32_b_4", \
+      name, \
+      type, \
+      32,   \
+      uint8_t)
+
+#define instantiate_quantized_batched(name, type, batched) \
+  instantiate_kernel( \
+      #name "_" #type "_gs_32_b_4_batch_" #batched, \
+      name,    \
+      type,    \
+      32,      \
+      uint8_t, \
+      batched)
+
+#define instantiate_quantized_aligned(name, type, aligned) \
+  instantiate_kernel( \
+      #name "_" #type "_gs_32_b_4_alN_" #aligned, \
+      name,    \
+      type,    \
+      32,      \
+      uint8_t, \
+      aligned)
+
+#define instantiate_quantized_aligned_batched(name, type, aligned, batched) \
+  instantiate_kernel( \
+      #name "_" #type "_gs_32_b_4_alN_" #aligned "_batch_" #batched, \
+      name,    \
+      type,    \
+      32,      \
+      uint8_t, \
+      aligned, \
+      batched)
+
+#define instantiate_quantized_quad(name, type, D, batched) \
+  instantiate_kernel( \
+      #name "_" #type "_gs_32_b_4_d_" #D "_batch_" #batched, \
+      name,    \
+      type,    \
+      32,      \
+      uint8_t, \
+      D,       \
+      batched)
+
+#define instantiate_quantized_split_k(name, type, split_k) \
+  instantiate_kernel( \
+      #name "_" #type "_gs_32_b_4_spk_" #split_k, \
+      name,    \
+      type,    \
+      32,      \
+      uint8_t, \
+      split_k)
+
+#define instantiate_gather_qmm_rhs(func, name, type, bm, bn, bk, wm, wn, transpose) \
+  instantiate_kernel( \
+      #name "_" #type "_gs_32_b_4_bm_" #bm "_bn_" #bn "_bk_" #bk "_wm_" #wm "_wn_" #wn, \
+      func,    \
+      type,    \
+      32,      \
+      uint8_t, \
+      bm,      \
+      bn,      \
+      bk,      \
+      wm,      \
+      wn,      \
+      transpose)
+
+#define instantiate_quantized_batched_wrap(name, type) \
+  instantiate_quantized_batched(name, type, 1)         \
+  instantiate_quantized_batched(name, type, 0)
+
+#define instantiate_quantized_all_batched(type) \
+  instantiate_quantized_batched_wrap(mxfp4_qmv_fast, type) \
+  instantiate_quantized_batched_wrap(mxfp4_qmv, type)      \
+  instantiate_quantized_batched_wrap(mxfp4_qvm, type)      \
+  instantiate_quantized_batched_wrap(mxfp4_qmm_n, type)
+
+#define instantiate_quantized_all_single(type) \
+  instantiate_quantized(mxfp4_gather_qmv_fast, type) \
+  instantiate_quantized(mxfp4_gather_qmv, type)      \
+  instantiate_quantized(mxfp4_gather_qvm, type)      \
+  instantiate_quantized(mxfp4_gather_qmm_n, type)
+
+#define instantiate_quantized_all_aligned(type) \
+  instantiate_quantized_aligned(mxfp4_gather_qmm_t, type, true)      \
+  instantiate_quantized_aligned(mxfp4_gather_qmm_t, type, false)     \
+  instantiate_quantized_aligned_batched(mxfp4_qmm_t, type, true, 1)  \
+  instantiate_quantized_aligned_batched(mxfp4_qmm_t, type, true, 0)  \
+  instantiate_quantized_aligned_batched(mxfp4_qmm_t, type, false, 1) \
+  instantiate_quantized_aligned_batched(mxfp4_qmm_t, type, false, 0)
+
+#define instantiate_quantized_all_quad(type) \
+  instantiate_quantized_quad(mxfp4_qmv_quad, type, 64, 1)  \
+  instantiate_quantized_quad(mxfp4_qmv_quad, type, 64, 0)  \
+  instantiate_quantized_quad(mxfp4_qmv_quad, type, 128, 1) \
+  instantiate_quantized_quad(mxfp4_qmv_quad, type, 128, 0)
+
+#define instantiate_quantized_all_splitk(type) \
+  instantiate_quantized_split_k(mxfp4_qvm_split_k, type, 8) \
+  instantiate_quantized_split_k(mxfp4_qvm_split_k, type, 32)
+
+#define instantiate_quantized_all_rhs(type) \
+  instantiate_gather_qmm_rhs(mxfp4_gather_qmm_rhs, mxfp4_gather_qmm_rhs_nt, type, 16, 32, 32, 1, 2, true) \
+  instantiate_gather_qmm_rhs(mxfp4_gather_qmm_rhs, mxfp4_gather_qmm_rhs_nn, type, 16, 32, 32, 1, 2, false)
+
+#define instantiate_quantized_types(type) \
+  instantiate_quantized_all_batched(type) \
+  instantiate_quantized_all_quad(type)    \
+  instantiate_quantized_all_splitk(type)  \
+  instantiate_quantized_all_single(type)  \
+  instantiate_quantized_all_aligned(type) \
+  instantiate_quantized_all_rhs(type)
+
+instantiate_quantized_types(float)
+instantiate_quantized_types(bfloat16_t)
+instantiate_quantized_types(float16_t)
+    // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/gemv.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/gemv.metal
new file mode 100644
index 0000000000000000000000000000000000000000..0914d80247b3fb027773458ad3ae1aac800508dc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/gemv.metal
@@ -0,0 +1,868 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <metal_simdgroup>
+#include <metal_stdlib>
+
+#include "mlx/backend/metal/kernels/utils.h"
+
+#include "mlx/backend/metal/kernels/steel/utils.h"
+
+using namespace metal;
+
+///////////////////////////////////////////////////////////////////////////////
+/// Matrix vector multiplication
+///////////////////////////////////////////////////////////////////////////////
+
+#define MLX_MTL_CONST static constant constexpr const
+
+template <typename U>
+struct DefaultAccT {
+  using type = float;
+};
+template <>
+struct DefaultAccT<complex64_t> {
+  using type = complex64_t;
+};
+
+template <
+    typename T,
+    const int BM, /* Threadgroup rows (in simdgroups) */
+    const int BN, /* Threadgroup cols (in simdgroups) */
+    const int SM, /* Simdgroup rows (in threads) */
+    const int SN, /* Simdgroup cols (in threads) */
+    const int TM, /* Thread rows (in elements) */
+    const int TN, /* Thread cols (in elements) */
+    const bool kDoAxpby, /* Do out = alpha * out + beta * bias */
+    typename AccT = typename DefaultAccT<T>::type>
+struct GEMVKernel {
+  using acc_type = AccT;
+
+  MLX_MTL_CONST int threadsM = BM * SM;
+  MLX_MTL_CONST int threadsN = BN * SN;
+
+  MLX_MTL_CONST int blockM = threadsM * TM;
+  MLX_MTL_CONST int blockN = threadsN * TN;
+
+  static_assert(SM * SN == 32, "simdgroup can only have 32 threads");
+
+  static_assert(
+      SN == 4 || SN == 8 || SN == 16 || SN == 32,
+      "gemv block must have a width of 4, 8, 16, or 32");
+
+  // - The matrix of size (M = out_vec_size, K = in_vec_size) is divided up
+  //   into blocks of (blockM, blockN) divided among threadgroups
+  // - Every thread works on a block of (TM, TN)
+  // - We assume each threadgroup has (threadsN, threadsM, 1) threads
+  //
+  // 1. A thread loads TN elements each from mat along TM rows
+  //    and the corresponding scalar from the vector
+  // 2. The thread then multiplies and adds to accumulate its local result for
+  //    the block
+  // 3. At the end, each thread has accumulated results over all blocks across
+  //    the rows. These are then summed up across the threadgroup
+  // 4. Each threadgroup writes its accumulated blockM outputs
+  //
+  // Edge case handling:
+  // - The threadgroup with the largest tid has blocks that exceed the matrix
+  //   * The blocks that start outside the matrix are never read (thread results
+  //     remain zero)
+  //   * The last thread that partially overlaps with the matrix is shifted
+  //     inwards such that the thread block fits exactly in the matrix
+
+  MLX_MTL_CONST short tgp_mem_size = BN > 1 ? BN*(blockM + TM) : 0;
+  MLX_MTL_CONST bool needs_tgp_reduction = BN > 1;
+
+  template <typename U = T>
+  static METAL_FUNC void
+  load_unsafe(const device T* src, thread U dst[TN], const int src_offset = 0) {
+    MLX_MTL_PRAGMA_UNROLL
+    for (int tn = 0; tn < TN; tn++) {
+      dst[tn] = static_cast<U>(src[src_offset + tn]);
+    }
+  }
+
+  template <typename U = T>
+  static METAL_FUNC void load_safe(
+      const device T* src,
+      thread U dst[TN],
+      const int src_offset = 0,
+      const int src_size = TN) {
+    if (src_offset + TN <= src_size) {
+      MLX_MTL_PRAGMA_UNROLL
+      for (int tn = 0; tn < TN; tn++) {
+        dst[tn] = static_cast<U>(src[src_offset + tn]);
+      }
+    } else { // Edgecase
+      MLX_MTL_PRAGMA_UNROLL
+      for (int tn = 0; tn < TN; tn++) {
+        dst[tn] = src_offset + tn < src_size
+            ? static_cast<U>(src[src_offset + tn])
+            : U(0);
+      }
+    }
+  }
+
+  static METAL_FUNC void run(
+      const device T* mat [[buffer(0)]],
+      const device T* in_vec [[buffer(1)]],
+      const device T* bias [[buffer(2)]],
+      device T* out_vec [[buffer(3)]],
+      const constant int& in_vec_size [[buffer(4)]],
+      const constant int& out_vec_size [[buffer(5)]],
+      const constant int& matrix_ld [[buffer(6)]],
+      const constant float& alpha [[buffer(7)]],
+      const constant float& beta [[buffer(8)]],
+      const constant int& bias_stride [[buffer(14)]],
+      threadgroup AccT* tgp_memory [[threadgroup(0)]],
+      uint3 tid [[threadgroup_position_in_grid]],
+      uint3 lid [[thread_position_in_threadgroup]],
+      uint simd_gid [[simdgroup_index_in_threadgroup]],
+      uint simd_lid [[thread_index_in_simdgroup]]) {
+    // Appease compiler
+    (void)lid;
+
+    // Thread local accumulation results
+    thread AccT result[TM] = {0};
+    thread T inter[TN];
+    thread AccT v_coeff[TN];
+
+    const int thrM = SN != 32 ? simd_lid / SN : 0;
+    const int thrN = SN != 32 ? simd_lid % SN : int(simd_lid);
+
+    const int sgN = BN != 1 ? (simd_gid % BN) : 0;
+
+    const int simdM = BN != 1 ? SM * (simd_gid / BN) : int(SM * simd_gid);
+    const int simdN = BN != 1 ? SN * (simd_gid % BN) : 0;
+
+    int bm = (simdM + thrM) * TM;
+    int bn = (simdN + thrN) * TN;
+
+    // Block position
+    int out_row = tid.x * blockM + bm;
+
+    // Exit simdgroup if rows out of bound
+    if (out_row >= out_vec_size)
+      return;
+
+    // Adjust tail simdgroup to ensure in bound reads
+    out_row = out_row + TM <= out_vec_size ? out_row : out_vec_size - TM;
+
+    // Advance matrix
+    mat += out_row * matrix_ld;
+
+    constexpr const uniform<int> loop_stride = make_uniform(blockN);
+    const uniform<int> in_size = make_uniform(in_vec_size);
+    const uniform<int> n_iter = in_size / loop_stride;
+    const uniform<int> last_iter = loop_stride * n_iter;
+    const uniform<int> leftover = in_size - last_iter;
+
+    // Loop over in_vec in blocks of blockN
+    for (int i = 0; i < n_iter; ++i) {
+      load_unsafe<AccT>(in_vec, v_coeff, bn);
+
+      // Per thread work loop
+      int mat_offset = 0;
+      MLX_MTL_PRAGMA_UNROLL
+      for (int tm = 0; tm < TM; tm++) {
+        // Load for the row
+        load_unsafe(mat, inter, mat_offset + bn);
+
+        // Accumulate results
+        MLX_MTL_PRAGMA_UNROLL
+        for (int tn = 0; tn < TN; tn++) {
+          result[tm] += inter[tn] * v_coeff[tn];
+        }
+
+        mat_offset += matrix_ld;
+      }
+
+      bn += blockN;
+    }
+
+    if (leftover > 0) {
+      load_safe<AccT>(in_vec, v_coeff, bn, in_size);
+
+      // Per thread work loop
+      MLX_MTL_PRAGMA_UNROLL
+      for (int tm = 0; tm < TM; tm++) {
+        // Load for the row
+        load_safe(&mat[tm * matrix_ld], inter, bn, in_size);
+
+        // Accumulate results
+        MLX_MTL_PRAGMA_UNROLL
+        for (int tn = 0; tn < TN; tn++) {
+          result[tm] += inter[tn] * v_coeff[tn];
+        }
+      }
+    }
+
+    // Simdgroup accumulations
+    MLX_MTL_PRAGMA_UNROLL
+    for (int tm = 0; tm < TM; tm++) {
+      MLX_MTL_PRAGMA_UNROLL
+      for (ushort sn = (SN / 2); sn >= 1; sn >>= 1) {
+        result[tm] += simd_shuffle_down(result[tm], sn);
+      }
+    }
+
+    // Threadgroup accumulation results
+    if (needs_tgp_reduction) {
+      threadgroup AccT* tgp_results = tgp_memory + sgN * (blockM + TM) + bm;
+      if (thrN == 0) {
+        MLX_MTL_PRAGMA_UNROLL
+        for (int tm = 0; tm < TM; tm++) {
+          tgp_results[tm] = result[tm];
+        }
+
+        threadgroup_barrier(mem_flags::mem_none);
+
+        if (sgN == 0) {
+          MLX_MTL_PRAGMA_UNROLL
+          for (int sgn = 1; sgn < BN; sgn++) {
+            MLX_MTL_PRAGMA_UNROLL
+            for (int tm = 0; tm < TM; tm++) {
+              result[tm] += tgp_results[sgn * (blockM + TM) + tm];
+            }
+          }
+        }
+      }
+    }
+
+    // Write outputs
+    if (simdN == 0 && thrN == 0) {
+      MLX_MTL_PRAGMA_UNROLL
+      for (int tm = 0; tm < TM; tm++) {
+        if (kDoAxpby) {
+          out_vec[out_row + tm] =
+              static_cast<T>(alpha) * static_cast<T>(result[tm]) +
+              static_cast<T>(beta) * bias[(out_row + tm) * bias_stride];
+        } else {
+          out_vec[out_row + tm] = static_cast<T>(result[tm]);
+        }
+      }
+    }
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+/// Vector matrix multiplication
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    const int BM, /* Threadgroup rows (in simdgroups) */
+    const int BN, /* Threadgroup cols (in simdgroups) */
+    const int SM, /* Simdgroup rows (in threads) */
+    const int SN, /* Simdgroup cols (in threads) */
+    const int TM, /* Thread rows (in elements) */
+    const int TN, /* Thread cols (in elements) */
+    const bool kDoAxpby, /* Do out = alpha * out + beta * bias */
+    typename AccT = typename DefaultAccT<T>::type>
+struct GEMVTKernel {
+  using acc_type = AccT;
+
+  MLX_MTL_CONST int threadsM = BM * SM;
+  MLX_MTL_CONST int threadsN = BN * SN;
+
+  MLX_MTL_CONST int blockM = threadsM * TM;
+  MLX_MTL_CONST int blockN = threadsN * TN;
+
+  static_assert(SM * SN == 32, "simdgroup can only have 32 threads");
+
+  // - The matrix of size (M = in_vec_size, N = out_vec_size) is divided up
+  //   into blocks of (blockM, blockN) divided among threadgroups
+  // - Every thread works on a block of (TM, TN)
+  // - We assume each threadgroup has (threadsN, threadsM, 1) threads
+  //
+  // 1. A thread loads TN elements each from mat along TM contiguous rows
+  //    and the corresponding scalar from the vector
+  // 2. The thread then accumulates its local result for the block
+  // 3. At the end, each thread has accumulated results over all blocks across
+  //    the rows. These are then summed up across the threadgroup
+  // 4. Each threadgroup writes its accumulated BN * TN outputs
+  //
+  // Edge case handling:
+  // - The threadgroup with the largest tid has blocks that exceed the matrix
+  //   * The blocks that start outside the matrix are never read (thread results
+  //     remain zero)
+  //   * The last thread that partially overlaps with the matrix is shifted
+  //     inwards such that the thread block fits exactly in the matrix
+
+  MLX_MTL_CONST short tgp_mem_size = BM > 1 ? BM*(blockN + TN) : 0;
+  MLX_MTL_CONST bool needs_tgp_reduction = BM > 1;
+
+  static METAL_FUNC void run(
+      const device T* mat [[buffer(0)]],
+      const device T* in_vec [[buffer(1)]],
+      const device T* bias [[buffer(2)]],
+      device T* out_vec [[buffer(3)]],
+      const constant int& in_vec_size [[buffer(4)]],
+      const constant int& out_vec_size [[buffer(5)]],
+      const constant int& marix_ld [[buffer(6)]],
+      const constant float& alpha [[buffer(7)]],
+      const constant float& beta [[buffer(8)]],
+      const constant int& bias_stride [[buffer(14)]],
+      threadgroup AccT* tgp_memory [[threadgroup(0)]],
+      uint3 tid [[threadgroup_position_in_grid]],
+      uint3 lid [[thread_position_in_threadgroup]],
+      uint simd_gid [[simdgroup_index_in_threadgroup]],
+      uint simd_lid [[thread_index_in_simdgroup]]) {
+    // Appease compiler
+    (void)lid;
+
+    // Thread local accumulation results
+    AccT result[TN] = {0};
+    T inter[TN];
+    AccT v_coeff[TM];
+    const int thrM = SN != 32 ? simd_lid / SN : 0;
+    const int thrN = SN != 32 ? simd_lid % SN : int(simd_lid);
+
+    const int sgM = BN != 1 ? (simd_gid / BN) : int(simd_gid);
+    const int sgN = BN != 1 ? (simd_gid % BN) : 0;
+
+    const int simdM = SM * sgM;
+    const int simdN = SN * sgN;
+
+    int cm = (simdM + thrM);
+    int cn = (simdN + thrN);
+
+    int bm = cm * TM;
+    int bn = cn * TN;
+
+    int out_col = tid.x * blockN + bn;
+
+    constexpr const uniform<int> loop_stride = make_uniform(blockM);
+    const uniform<int> in_size = make_uniform(in_vec_size);
+    const uniform<int> n_iter = in_size / loop_stride;
+    const uniform<int> last_iter = loop_stride * n_iter;
+    const uniform<int> leftover = in_size - last_iter;
+
+    // Edgecase handling
+    if (out_col < out_vec_size) {
+      out_col = out_col + TN < out_vec_size ? out_col : out_vec_size - TN;
+
+      // Per thread accumulation main loop
+      for (int i = 0; i < n_iter; ++i) {
+        // Adding a threadgroup_barrier improves performance slightly
+        // This is possibly it may help exploit cache better
+        threadgroup_barrier(mem_flags::mem_none);
+
+        MLX_MTL_PRAGMA_UNROLL
+        for (int tm = 0; tm < TM; tm++) {
+          v_coeff[tm] = static_cast<AccT>(in_vec[bm + tm]);
+        }
+
+        MLX_MTL_PRAGMA_UNROLL
+        for (int tm = 0; tm < TM; tm++) {
+          auto vc = static_cast<AccT>(v_coeff[tm]);
+          for (int tn = 0; tn < TN; tn++) {
+            inter[tn] = mat[(bm + tm) * marix_ld + out_col + tn];
+          }
+          for (int tn = 0; tn < TN; tn++) {
+            result[tn] += vc * inter[tn];
+          }
+        }
+
+        bm += blockM;
+      }
+
+      if (leftover > 0) {
+        for (int tm = 0; tm < TM && bm + tm < in_vec_size; tm++) {
+          v_coeff[tm] = static_cast<AccT>(in_vec[bm + tm]);
+
+          MLX_MTL_PRAGMA_UNROLL
+          for (int tn = 0; tn < TN; tn++) {
+            inter[tn] = mat[(bm + tm) * marix_ld + out_col + tn];
+          }
+
+          MLX_MTL_PRAGMA_UNROLL
+          for (int tn = 0; tn < TN; tn++) {
+            result[tn] += v_coeff[tm] * inter[tn];
+          }
+        }
+      }
+    }
+
+    // Simdgroup accumulations
+    MLX_MTL_PRAGMA_UNROLL
+    for (int tn = 0; tn < TN; tn++) {
+      MLX_MTL_PRAGMA_UNROLL
+      for (ushort sm = (SM / 2); sm >= 1; sm >>= 1) {
+        result[tn] += simd_shuffle_down(result[tn], SN * sm);
+      }
+    }
+
+    // Threadgroup accumulation results
+    if (needs_tgp_reduction) {
+      threadgroup AccT* tgp_results = tgp_memory + sgM * (blockN + TN) + bn;
+      if (thrM == 0) {
+        MLX_MTL_PRAGMA_UNROLL
+        for (int tn = 0; tn < TN; tn++) {
+          tgp_results[tn] = result[tn];
+        }
+
+        threadgroup_barrier(mem_flags::mem_none);
+
+        if (sgM == 0) {
+          MLX_MTL_PRAGMA_UNROLL
+          for (int sgm = 1; sgm < BM; sgm++) {
+            MLX_MTL_PRAGMA_UNROLL
+            for (int tn = 0; tn < TN; tn++) {
+              result[tn] += tgp_results[sgm * (blockN + TN) + tn];
+            }
+          }
+        }
+      }
+    }
+
+    // Threadgroup accumulation and writing out results
+    if (cm == 0 && out_col < out_vec_size) {
+      MLX_MTL_PRAGMA_UNROLL
+      for (int j = 0; j < TN; j++) {
+        if (kDoAxpby) {
+          out_vec[out_col + j] =
+              static_cast<T>(alpha) * static_cast<T>(result[j]) +
+              static_cast<T>(beta) * bias[(out_col + j) * bias_stride];
+        } else {
+          out_vec[out_col + j] = static_cast<T>(result[j]);
+        }
+      }
+    }
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+/// Matrix vector multiplication
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    const int BM, /* Threadgroup rows (in simdgroups) */
+    const int BN, /* Threadgroup cols (in simdgroups) */
+    const int SM, /* Simdgroup rows (in threads) */
+    const int SN, /* Simdgroup cols (in threads) */
+    const int TM, /* Thread rows (in elements) */
+    const int TN, /* Thread cols (in elements) */
+    const bool kDoNCBatch, /* Batch ndim > 1 */
+    const bool kDoAxpby> /* Do out = alpha * out + beta * bias */
+[[kernel, max_total_threads_per_threadgroup(BM* BN * 32)]] void gemv(
+    const device T* mat [[buffer(0)]],
+    const device T* in_vec [[buffer(1)]],
+    const device T* bias [[buffer(2)]],
+    device T* out_vec [[buffer(3)]],
+    const constant int& in_vec_size [[buffer(4)]],
+    const constant int& out_vec_size [[buffer(5)]],
+    const constant int& marix_ld [[buffer(6)]],
+    const constant float& alpha [[buffer(7)]],
+    const constant float& beta [[buffer(8)]],
+    const constant int& batch_ndim [[buffer(9)]],
+    const constant int* batch_shape [[buffer(10)]],
+    const constant int64_t* vector_batch_stride [[buffer(11)]],
+    const constant int64_t* matrix_batch_stride [[buffer(12)]],
+    const constant int64_t* bias_batch_stride [[buffer(13)]],
+    const constant int& bias_stride [[buffer(14)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  using gemv_kernel = GEMVKernel<T, BM, BN, SM, SN, TM, TN, kDoAxpby>;
+  threadgroup typename gemv_kernel::acc_type tgp_memory
+      [gemv_kernel::tgp_mem_size == 0 ? 1 : gemv_kernel::tgp_mem_size];
+
+  // Update batch offsets
+  if (kDoNCBatch) {
+    in_vec += elem_to_loc(tid.z, batch_shape, vector_batch_stride, batch_ndim);
+    mat += elem_to_loc(tid.z, batch_shape, matrix_batch_stride, batch_ndim);
+
+    if (kDoAxpby) {
+      bias += elem_to_loc(tid.z, batch_shape, bias_batch_stride, batch_ndim);
+    }
+
+  } else {
+    in_vec += tid.z * vector_batch_stride[0];
+    mat += tid.z * matrix_batch_stride[0];
+
+    if (kDoAxpby) {
+      bias += tid.z * bias_batch_stride[0];
+    }
+  }
+
+  out_vec += tid.z * out_vec_size;
+
+  gemv_kernel::run(
+      mat,
+      in_vec,
+      bias,
+      out_vec,
+      in_vec_size,
+      out_vec_size,
+      marix_ld,
+      alpha,
+      beta,
+      bias_stride,
+      gemv_kernel::tgp_mem_size == 0 ? nullptr : tgp_memory,
+      tid,
+      lid,
+      simd_gid,
+      simd_lid);
+}
+
+#define instantiate_gemv_helper(                                      \
+    name, itype, bm, bn, sm, sn, tm, tn, nc, axpby)                   \
+  instantiate_kernel(                                                 \
+      "gemv_" #name "_bm" #bm "_bn" #bn "_sm" #sm "_sn" #sn "_tm" #tm \
+      "_tn" #tn "_nc" #nc "_axpby" #axpby,                            \
+      gemv,                                                           \
+      itype,                                                          \
+      bm,                                                             \
+      bn,                                                             \
+      sm,                                                             \
+      sn,                                                             \
+      tm,                                                             \
+      tn,                                                             \
+      nc,                                                             \
+      axpby)
+
+// clang-format off
+#define instantiate_gemv(name, itype, bm, bn, sm, sn, tm, tn)        \
+  instantiate_gemv_helper(name, itype, bm, bn, sm, sn, tm, tn, 0, 0) \
+  instantiate_gemv_helper(name, itype, bm, bn, sm, sn, tm, tn, 0, 1) \
+  instantiate_gemv_helper(name, itype, bm, bn, sm, sn, tm, tn, 1, 0) \
+  instantiate_gemv_helper(name, itype, bm, bn, sm, sn, tm, tn, 1, 1) // clang-format on
+
+// clang-format off
+#define instantiate_gemv_blocks(name, itype) \
+  instantiate_gemv(name, itype, 1,  8, 1, 32, 4, 4) \
+  instantiate_gemv(name, itype, 1,  8, 1, 32, 1, 4) \
+  instantiate_gemv(name, itype, 1,  1, 8,  4, 4, 4) \
+  instantiate_gemv(name, itype, 1,  1, 8,  4, 1, 4) \
+  instantiate_gemv(name, itype, 4,  1, 1, 32, 1, 4) \
+  instantiate_gemv(name, itype, 4,  1, 1, 32, 4, 4) \
+  instantiate_gemv(name, itype, 8,  1, 1, 32, 4, 4) // clang-format on
+
+instantiate_gemv_blocks(float32, float);
+instantiate_gemv_blocks(float16, half);
+instantiate_gemv_blocks(bfloat16, bfloat16_t);
+instantiate_gemv_blocks(complex64, complex64_t);
+
+template <
+    typename T,
+    const int BM, /* Threadgroup rows (in simdgroups) */
+    const int BN, /* Threadgroup cols (in simdgroups) */
+    const int SM, /* Simdgroup rows (in threads) */
+    const int SN, /* Simdgroup cols (in threads) */
+    const int TM, /* Thread rows (in elements) */
+    const int TN> /* Thread cols (in elements) */
+[[kernel, max_total_threads_per_threadgroup(BM* BN * 32)]] void gemv_gather(
+    const device T* mat [[buffer(0)]],
+    const device T* in_vec [[buffer(1)]],
+    const device T* bias [[buffer(2)]],
+    device T* out_vec [[buffer(3)]],
+    const constant int& in_vec_size [[buffer(4)]],
+    const constant int& out_vec_size [[buffer(5)]],
+    const constant int& marix_ld [[buffer(6)]],
+    const constant float& alpha [[buffer(7)]],
+    const constant float& beta [[buffer(8)]],
+    const constant int& batch_ndim [[buffer(9)]],
+    const constant int* batch_shape [[buffer(10)]],
+    const constant int64_t* index_batch_strides [[buffer(11)]],
+    const constant int& vector_batch_ndim [[buffer(12)]],
+    const constant int* vector_batch_shape [[buffer(13)]],
+    const constant int64_t* vector_batch_stride [[buffer(14)]],
+    const constant int& matrix_batch_ndim [[buffer(15)]],
+    const constant int* matrix_batch_shape [[buffer(16)]],
+    const constant int64_t* matrix_batch_stride [[buffer(17)]],
+    const constant uint32_t* vec_indices [[buffer(18)]],
+    const constant uint32_t* mat_indices [[buffer(19)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  using gemv_kernel = GEMVKernel<T, BM, BN, SM, SN, TM, TN, false>;
+  threadgroup typename gemv_kernel::acc_type tgp_memory
+      [gemv_kernel::tgp_mem_size == 0 ? 1 : gemv_kernel::tgp_mem_size];
+
+  uint32_t indx_vec;
+  uint32_t indx_mat;
+
+  // Update batch offsets
+  if (batch_ndim > 1) {
+    const constant auto* veci_bstrides = index_batch_strides;
+    const constant auto* mati_bstrides = index_batch_strides + batch_ndim;
+
+    ulong2 batch_offsets = elem_to_loc_broadcast(
+        tid.z, batch_shape, veci_bstrides, mati_bstrides, batch_ndim);
+
+    indx_vec = vec_indices[batch_offsets.x];
+    indx_mat = mat_indices[batch_offsets.y];
+
+  } else {
+    indx_vec = vec_indices[index_batch_strides[0] * tid.z];
+    indx_mat = mat_indices[index_batch_strides[batch_ndim] * tid.z];
+  }
+
+  if (vector_batch_ndim > 1) {
+    in_vec += elem_to_loc(
+        indx_vec, vector_batch_shape, vector_batch_stride, vector_batch_ndim);
+  } else {
+    in_vec += indx_vec * vector_batch_stride[0];
+  }
+
+  if (matrix_batch_ndim > 1) {
+    mat += elem_to_loc(
+        indx_mat, matrix_batch_shape, matrix_batch_stride, matrix_batch_ndim);
+  } else {
+    mat += indx_mat * matrix_batch_stride[0];
+  }
+
+  out_vec += tid.z * out_vec_size;
+
+  gemv_kernel::run(
+      mat,
+      in_vec,
+      bias,
+      out_vec,
+      in_vec_size,
+      out_vec_size,
+      marix_ld,
+      alpha,
+      beta,
+      batch_ndim, // Not used
+      gemv_kernel::tgp_mem_size == 0 ? nullptr : tgp_memory,
+      tid,
+      lid,
+      simd_gid,
+      simd_lid);
+}
+
+// clang-format off
+#define instantiate_gemv_bs_helper(nm, itype, bm, bn, sm, sn, tm, tn) \
+  instantiate_kernel(                                                 \
+    "gemv_gather_" #nm "_bm" #bm "_bn" #bn "_sm" #sm                  \
+                       "_sn" #sn "_tm" #tm "_tn" #tn,                 \
+    gemv_gather, itype, bm, bn, sm, sn, tm, tn)
+
+#define instantiate_gemv_bs_blocks(name, itype)              \
+  instantiate_gemv_bs_helper(name, itype, 4, 1, 1, 32, 1, 4) \
+  instantiate_gemv_bs_helper(name, itype, 4, 1, 1, 32, 4, 4) \
+  instantiate_gemv_bs_helper(name, itype, 8, 1, 1, 32, 4, 4) // clang-format on
+
+instantiate_gemv_bs_blocks(float32, float);
+instantiate_gemv_bs_blocks(float16, half);
+instantiate_gemv_bs_blocks(bfloat16, bfloat16_t);
+instantiate_gemv_bs_blocks(complex64, complex64_t);
+
+///////////////////////////////////////////////////////////////////////////////
+/// Vector matrix multiplication
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    const int BM, /* Threadgroup rows (in simdgroups) */
+    const int BN, /* Threadgroup cols (in simdgroups) */
+    const int SM, /* Simdgroup rows (in threads) */
+    const int SN, /* Simdgroup cols (in threads) */
+    const int TM, /* Thread rows (in elements) */
+    const int TN, /* Thread cols (in elements) */
+    const bool kDoNCBatch, /* Batch ndim > 1 */
+    const bool kDoAxpby> /* Do out = alpha * out + beta * bias */
+[[kernel, max_total_threads_per_threadgroup(BM* BN * 32)]] void gemv_t(
+    const device T* mat [[buffer(0)]],
+    const device T* in_vec [[buffer(1)]],
+    const device T* bias [[buffer(2)]],
+    device T* out_vec [[buffer(3)]],
+    const constant int& in_vec_size [[buffer(4)]],
+    const constant int& out_vec_size [[buffer(5)]],
+    const constant int& marix_ld [[buffer(6)]],
+    const constant float& alpha [[buffer(7)]],
+    const constant float& beta [[buffer(8)]],
+    const constant int& batch_ndim [[buffer(9)]],
+    const constant int* batch_shape [[buffer(10)]],
+    const constant int64_t* vector_batch_stride [[buffer(11)]],
+    const constant int64_t* matrix_batch_stride [[buffer(12)]],
+    const constant int64_t* bias_batch_stride [[buffer(13)]],
+    const constant int& bias_stride [[buffer(14)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  using gemv_kernel = GEMVTKernel<T, BM, BN, SM, SN, TM, TN, kDoAxpby>;
+  threadgroup typename gemv_kernel::acc_type tgp_memory
+      [gemv_kernel::tgp_mem_size == 0 ? 1 : gemv_kernel::tgp_mem_size];
+
+  // Update batch offsets
+  if (kDoNCBatch) {
+    in_vec += elem_to_loc(tid.z, batch_shape, vector_batch_stride, batch_ndim);
+    mat += elem_to_loc(tid.z, batch_shape, matrix_batch_stride, batch_ndim);
+
+    if (kDoAxpby) {
+      bias += elem_to_loc(tid.z, batch_shape, bias_batch_stride, batch_ndim);
+    }
+
+  } else {
+    in_vec += tid.z * vector_batch_stride[0];
+    mat += tid.z * matrix_batch_stride[0];
+
+    if (kDoAxpby) {
+      bias += tid.z * bias_batch_stride[0];
+    }
+  }
+
+  out_vec += tid.z * out_vec_size;
+
+  gemv_kernel::run(
+      mat,
+      in_vec,
+      bias,
+      out_vec,
+      in_vec_size,
+      out_vec_size,
+      marix_ld,
+      alpha,
+      beta,
+      bias_stride,
+      gemv_kernel::tgp_mem_size == 0 ? nullptr : tgp_memory,
+      tid,
+      lid,
+      simd_gid,
+      simd_lid);
+}
+
+// clang-format off
+#define instantiate_gemv_t_helper(                          \
+    name, itype, bm, bn, sm, sn, tm, tn, nc, axpby)         \
+  instantiate_kernel(                                       \
+    "gemv_t_" #name "_bm" #bm "_bn" #bn "_sm" #sm "_sn" #sn \
+       "_tm" #tm "_tn" #tn "_nc" #nc "_axpby" #axpby,       \
+  gemv_t, itype, bm, bn, sm, sn, tm, tn, nc, axpby)
+
+#define instantiate_gemv_t(name, itype, bm, bn, sm, sn, tm, tn)        \
+  instantiate_gemv_t_helper(name, itype, bm, bn, sm, sn, tm, tn, 0, 0) \
+  instantiate_gemv_t_helper(name, itype, bm, bn, sm, sn, tm, tn, 0, 1) \
+  instantiate_gemv_t_helper(name, itype, bm, bn, sm, sn, tm, tn, 1, 0) \
+  instantiate_gemv_t_helper(name, itype, bm, bn, sm, sn, tm, tn, 1, 1) // clang-format on
+
+// clang-format off
+#define instantiate_gemv_t_blocks(name, itype) \
+  instantiate_gemv_t(name, itype, 1, 2,  8, 4, 4, 1) \
+  instantiate_gemv_t(name, itype, 1, 2,  8, 4, 4, 4) \
+  instantiate_gemv_t(name, itype, 1, 4,  8, 4, 4, 4) \
+  instantiate_gemv_t(name, itype, 1, 16, 8, 4, 4, 4) \
+  instantiate_gemv_t(name, itype, 1, 16, 4, 8, 4, 4) // clang-format on
+
+// clang-format off
+instantiate_gemv_t_blocks(float32, float);
+instantiate_gemv_t_blocks(float16, half);
+instantiate_gemv_t_blocks(bfloat16, bfloat16_t);
+instantiate_gemv_t_blocks(complex64, complex64_t); // clang-format on
+
+template <
+    typename T,
+    const int BM, /* Threadgroup rows (in simdgroups) */
+    const int BN, /* Threadgroup cols (in simdgroups) */
+    const int SM, /* Simdgroup rows (in threads) */
+    const int SN, /* Simdgroup cols (in threads) */
+    const int TM, /* Thread rows (in elements) */
+    const int TN> /* Thread cols (in elements) */
+[[kernel, max_total_threads_per_threadgroup(BM* BN * 32)]] void gemv_t_gather(
+    const device T* mat [[buffer(0)]],
+    const device T* in_vec [[buffer(1)]],
+    const device T* bias [[buffer(2)]],
+    device T* out_vec [[buffer(3)]],
+    const constant int& in_vec_size [[buffer(4)]],
+    const constant int& out_vec_size [[buffer(5)]],
+    const constant int& marix_ld [[buffer(6)]],
+    const constant float& alpha [[buffer(7)]],
+    const constant float& beta [[buffer(8)]],
+    const constant int& batch_ndim [[buffer(9)]],
+    const constant int* batch_shape [[buffer(10)]],
+    const constant int64_t* index_batch_strides [[buffer(11)]],
+    const constant int& vector_batch_ndim [[buffer(12)]],
+    const constant int* vector_batch_shape [[buffer(13)]],
+    const constant int64_t* vector_batch_stride [[buffer(14)]],
+    const constant int& matrix_batch_ndim [[buffer(15)]],
+    const constant int* matrix_batch_shape [[buffer(16)]],
+    const constant int64_t* matrix_batch_stride [[buffer(17)]],
+    const constant uint32_t* vec_indices [[buffer(18)]],
+    const constant uint32_t* mat_indices [[buffer(19)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  using gemv_kernel = GEMVTKernel<T, BM, BN, SM, SN, TM, TN, false>;
+  threadgroup typename gemv_kernel::acc_type tgp_memory
+      [gemv_kernel::tgp_mem_size == 0 ? 1 : gemv_kernel::tgp_mem_size];
+
+  uint32_t indx_vec;
+  uint32_t indx_mat;
+
+  // Update batch offsets
+  if (batch_ndim > 1) {
+    const constant auto* veci_bstrides = index_batch_strides;
+    const constant auto* mati_bstrides = index_batch_strides + batch_ndim;
+
+    ulong2 batch_offsets = elem_to_loc_broadcast(
+        tid.z, batch_shape, veci_bstrides, mati_bstrides, batch_ndim);
+
+    indx_vec = vec_indices[batch_offsets.x];
+    indx_mat = mat_indices[batch_offsets.y];
+
+  } else {
+    indx_vec = vec_indices[index_batch_strides[0] * tid.z];
+    indx_mat = mat_indices[index_batch_strides[batch_ndim] * tid.z];
+  }
+
+  if (vector_batch_ndim > 1) {
+    in_vec += elem_to_loc(
+        indx_vec, vector_batch_shape, vector_batch_stride, vector_batch_ndim);
+  } else {
+    in_vec += indx_vec * vector_batch_stride[0];
+  }
+
+  if (matrix_batch_ndim > 1) {
+    mat += elem_to_loc(
+        indx_mat, matrix_batch_shape, matrix_batch_stride, matrix_batch_ndim);
+  } else {
+    mat += indx_mat * matrix_batch_stride[0];
+  }
+
+  out_vec += tid.z * out_vec_size;
+
+  gemv_kernel::run(
+      mat,
+      in_vec,
+      bias,
+      out_vec,
+      in_vec_size,
+      out_vec_size,
+      marix_ld,
+      alpha,
+      beta,
+      batch_ndim, // Not used,
+      gemv_kernel::tgp_mem_size == 0 ? nullptr : tgp_memory,
+      tid,
+      lid,
+      simd_gid,
+      simd_lid);
+}
+
+// clang-format off
+#define instantiate_gemv_t_bs_helper(                  \
+    nm, itype, bm, bn, sm, sn, tm, tn)                 \
+  instantiate_kernel(                                  \
+    "gemv_t_gather_" #nm "_bm" #bm "_bn" #bn "_sm" #sm \
+       "_sn" #sn "_tm" #tm "_tn" #tn,                  \
+  gemv_t_gather, itype, bm, bn, sm, sn, tm, tn)
+
+#define instantiate_gemv_t_bs_blocks(name, itype)              \
+  instantiate_gemv_t_bs_helper(name, itype, 1,  2, 8, 4, 4, 1) \
+  instantiate_gemv_t_bs_helper(name, itype, 1,  2, 8, 4, 4, 4) \
+  instantiate_gemv_t_bs_helper(name, itype, 1,  4, 8, 4, 4, 4) \
+  instantiate_gemv_t_bs_helper(name, itype, 1, 16, 8, 4, 4, 4) \
+  instantiate_gemv_t_bs_helper(name, itype, 1, 16, 4, 8, 4, 4) // clang-format on
+
+// clang-format off
+instantiate_gemv_t_bs_blocks(float32, float);
+instantiate_gemv_t_bs_blocks(float16, half);
+instantiate_gemv_t_bs_blocks(bfloat16, bfloat16_t);
+instantiate_gemv_t_bs_blocks(complex64, complex64_t); // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/gemv_masked.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/gemv_masked.h
new file mode 100644
index 0000000000000000000000000000000000000000..96b0c2821f1128128dbfe942f0e4940b499e7008
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/gemv_masked.h
@@ -0,0 +1,827 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/backend/metal/kernels/steel/utils.h"
+
+using namespace metal;
+
+#define MLX_MTL_CONST static constant constexpr const
+#define MLX_MTL_PRAGMA_UNROLL _Pragma("clang loop unroll(full)")
+
+struct _NoMask {
+  char x;
+
+  constexpr METAL_FUNC operator bool() {
+    return true;
+  }
+  constexpr METAL_FUNC operator bool() const threadgroup {
+    return true;
+  }
+  constexpr METAL_FUNC operator bool() const device {
+    return true;
+  }
+  constexpr METAL_FUNC operator bool() const constant {
+    return true;
+  }
+};
+
+typedef struct _NoMask nomask_t;
+
+template <typename OutT, typename InT = OutT>
+struct ScaleOp {
+  OutT scale;
+
+  METAL_FUNC OutT apply(InT x) const {
+    return static_cast<OutT>(x) * scale;
+  }
+};
+
+template <
+    typename T,
+    typename out_mask_t,
+    typename op_mask_t,
+    const int BM, /* Threadgroup rows (in simdgroups) */
+    const int BN, /* Threadgroup cols (in simdgroups) */
+    const int SM, /* Simdgroup rows (in threads) */
+    const int SN, /* Simdgroup cols (in threads) */
+    const int TM, /* Thread rows (in elements) */
+    const int TN, /* Thread cols (in elements) */
+    typename AccT = float>
+struct GEMVKernel {
+  MLX_MTL_CONST int threadsM = BM * SM;
+  MLX_MTL_CONST int threadsN = BN * SN;
+
+  MLX_MTL_CONST int blockM = threadsM * TM;
+  MLX_MTL_CONST int blockN = threadsN * TN;
+
+  static_assert(SM * SN == 32, "simdgroup can only have 32 threads");
+
+  static_assert(
+      SN == 8 || SN == 16 || SN == 32,
+      "gemv block must have a width of 8, 16, or 32");
+
+  static_assert(blockN >= blockM, "Masked gemv must have blockN >= blockM");
+
+  MLX_MTL_CONST bool has_operand_mask = !metal::is_same_v<op_mask_t, nomask_t>;
+  MLX_MTL_CONST bool has_output_mask = !metal::is_same_v<out_mask_t, nomask_t>;
+
+  MLX_MTL_CONST bool has_mul_operand_mask =
+      has_operand_mask && !metal::is_same_v<op_mask_t, bool>;
+  MLX_MTL_CONST bool has_mul_output_mask =
+      has_output_mask && !metal::is_same_v<out_mask_t, bool>;
+
+  // - The matrix of size (M = out_vec_size, K = in_vec_size) is divided up
+  //   into blocks of (blockM, blockN) divided among threadgroups
+  // - Every thread works on a block of (TM, TN)
+  // - We assume each threadgroup has (threadsN, threadsM, 1) threads
+  //
+  // 1. A thread loads TN elements each from mat along TM rows
+  //    and the corresponding scalar from the vector
+  // 2. The thread then multiplies and adds to accumulate its local result for
+  //    the block
+  // 3. At the end, each thread has accumulated results over all blocks across
+  //    the rows. These are then summed up across the threadgroup
+  // 4. Each threadgroup writes its accumulated blockM outputs
+  //
+  // Edge case handling:
+  // - The threadgroup with the largest tid has blocks that exceed the matrix
+  //   * The blocks that start outside the matrix are never read (thread results
+  //     remain zero)
+  //   * The last thread that partially overlaps with the matrix is shifted
+  //     inwards such that the thread block fits exactly in the matrix
+
+  MLX_MTL_CONST short tgp_mem_size = BN > 1 ? BN*(blockM + TM) : 0;
+  MLX_MTL_CONST bool needs_tgp_reduction = BN > 1;
+
+  template <typename U = T>
+  static METAL_FUNC void
+  load_unsafe(const device T* src, thread U dst[TN], const int src_offset = 0) {
+    MLX_MTL_PRAGMA_UNROLL
+    for (int tn = 0; tn < TN; tn++) {
+      dst[tn] = static_cast<U>(src[src_offset + tn]);
+    }
+  }
+
+  template <typename U = T>
+  static METAL_FUNC void load_safe(
+      const device T* src,
+      thread U dst[TN],
+      const int src_offset = 0,
+      const int src_size = TN) {
+    if (src_offset + TN <= src_size) {
+      MLX_MTL_PRAGMA_UNROLL
+      for (int tn = 0; tn < TN; tn++) {
+        dst[tn] = static_cast<U>(src[src_offset + tn]);
+      }
+    } else { // Edgecase
+      MLX_MTL_PRAGMA_UNROLL
+      for (int tn = 0; tn < TN; tn++) {
+        dst[tn] = src_offset + tn < src_size
+            ? static_cast<U>(src[src_offset + tn])
+            : U(0);
+      }
+    }
+  }
+
+  static METAL_FUNC void run(
+      const device T* mat [[buffer(0)]],
+      const device T* in_vec [[buffer(1)]],
+      device T* out_vec [[buffer(3)]],
+      const constant int& in_vec_size [[buffer(4)]],
+      const constant int& out_vec_size [[buffer(5)]],
+      const constant int& matrix_ld [[buffer(6)]],
+      const device out_mask_t* out_mask [[buffer(20)]],
+      const device op_mask_t* mat_mask [[buffer(21)]],
+      const device op_mask_t* vec_mask [[buffer(22)]],
+      const constant int* mask_strides [[buffer(23)]],
+      threadgroup AccT* tgp_memory [[threadgroup(0)]],
+      uint3 tid [[threadgroup_position_in_grid]],
+      uint3 lid [[thread_position_in_threadgroup]],
+      uint simd_gid [[simdgroup_index_in_threadgroup]],
+      uint simd_lid [[thread_index_in_simdgroup]]) {
+    // Appease compiler
+    (void)lid;
+
+    // Thread local accumulation results
+    thread AccT result[TM] = {0};
+    thread T inter[TN];
+    thread AccT v_coeff[TN];
+
+    const int thrM = SN != 32 ? simd_lid / SN : 0;
+    const int thrN = SN != 32 ? simd_lid % SN : int(simd_lid);
+
+    const int sgN = BN != 1 ? (simd_gid % BN) : 0;
+
+    const int simdM = BN != 1 ? SM * (simd_gid / BN) : int(SM * simd_gid);
+    const int simdN = BN != 1 ? SN * (simd_gid % BN) : 0;
+
+    int bm = (simdM + thrM) * TM;
+    int bn = (simdN + thrN) * TN;
+
+    // Block position
+    int out_row = tid.x * blockM + bm;
+
+    // Exit simdgroup if rows out of bound
+    if (out_row >= out_vec_size)
+      return;
+
+    // Adjust tail simdgroup to ensure in bound reads
+    out_row = out_row + TM <= out_vec_size ? out_row : out_vec_size - TM;
+
+    // Prepare mask offsets
+    const constant int* out_mask_strides = mask_strides;
+    const constant int* mat_mask_strides =
+        mask_strides + (has_output_mask ? 2 : 0);
+    const constant int* vec_mask_strides =
+        mat_mask_strides + (has_operand_mask ? 2 : 0);
+
+    const int m_block_idx = blockN > blockM ? out_row / blockN : int(tid.x);
+
+    const int out_mask_offset =
+        !has_output_mask ? 0 : m_block_idx * out_mask_strides[1];
+
+    int mat_mask_offset =
+        !has_operand_mask ? 0 : m_block_idx * mat_mask_strides[1];
+    int vec_mask_offset = 0;
+    const int mat_mask_step = !has_operand_mask ? 0 : mat_mask_strides[0];
+    const int vec_mask_step = !has_operand_mask ? 0 : vec_mask_strides[1];
+
+    T out_scale{1};
+
+    // Check output mask
+    if (has_output_mask) {
+      auto mask_out = out_mask[out_mask_offset];
+
+      // Write zeros and return if mask is 0
+      if (!mask_out) {
+        if (simdN == 0 && thrN == 0) {
+          MLX_MTL_PRAGMA_UNROLL
+          for (int tm = 0; tm < TM; tm++) {
+            out_vec[out_row + tm] = T(0.);
+          }
+        }
+
+        return;
+      }
+
+      // Store scalar if multiplicative mask
+      if (has_mul_output_mask) {
+        out_scale = T(mask_out);
+      }
+    }
+
+    // Advance matrix
+    mat += out_row * matrix_ld;
+
+    // Prepare for loop
+    constexpr const uniform<int> loop_stride = make_uniform(blockN);
+    const uniform<int> in_size = make_uniform(in_vec_size);
+    const uniform<int> n_iter = in_size / loop_stride;
+    const uniform<int> last_iter = loop_stride * n_iter;
+    const uniform<int> leftover = in_size - last_iter;
+
+    // Loop over in_vec in blocks of blockN
+    for (int i = 0; i < n_iter; ++i) {
+      if (!has_operand_mask ||
+          (bool(mat_mask[mat_mask_offset]) &&
+           bool(vec_mask[vec_mask_offset]))) {
+        T block_scale{1};
+        if (has_mul_operand_mask) {
+          block_scale =
+              T(mat_mask[mat_mask_offset]) * T(vec_mask[vec_mask_offset]);
+        }
+
+        load_unsafe<AccT>(in_vec, v_coeff, bn);
+
+        // Apply scale
+        if (has_mul_operand_mask) {
+          MLX_MTL_PRAGMA_UNROLL
+          for (int tn = 0; tn < TN; tn++) {
+            v_coeff[tn] *= block_scale;
+          }
+        }
+
+        // Per thread work loop
+        int mat_offset = 0;
+        MLX_MTL_PRAGMA_UNROLL
+        for (int tm = 0; tm < TM; tm++) {
+          // Load for the row
+          load_unsafe(mat, inter, mat_offset + bn);
+
+          // Accumulate results
+          MLX_MTL_PRAGMA_UNROLL
+          for (int tn = 0; tn < TN; tn++) {
+            result[tm] += inter[tn] * v_coeff[tn];
+          }
+
+          mat_offset += matrix_ld;
+        }
+      }
+
+      bn += blockN;
+      mat_mask_offset += mat_mask_step;
+      vec_mask_offset += vec_mask_step;
+    }
+
+    if (leftover > 0) {
+      if (!has_operand_mask ||
+          (bool(mat_mask[mat_mask_offset]) &&
+           bool(vec_mask[vec_mask_offset]))) {
+        T block_scale{1};
+        if (has_mul_operand_mask) {
+          block_scale =
+              T(mat_mask[mat_mask_offset]) * T(vec_mask[vec_mask_offset]);
+        }
+
+        load_safe<AccT>(in_vec, v_coeff, bn, in_size);
+
+        // Apply scale
+        if (has_mul_operand_mask) {
+          MLX_MTL_PRAGMA_UNROLL
+          for (int tn = 0; tn < TN; tn++) {
+            v_coeff[tn] *= block_scale;
+          }
+        }
+
+        // Per thread work loop
+        MLX_MTL_PRAGMA_UNROLL
+        for (int tm = 0; tm < TM; tm++) {
+          // Load for the row
+          load_safe(&mat[tm * matrix_ld], inter, bn, in_size);
+
+          // Accumulate results
+          MLX_MTL_PRAGMA_UNROLL
+          for (int tn = 0; tn < TN; tn++) {
+            result[tm] += inter[tn] * v_coeff[tn];
+          }
+        }
+      }
+    }
+
+    // Apply out scale
+    if (has_mul_output_mask) {
+      MLX_MTL_PRAGMA_UNROLL
+      for (int tm = 0; tm < TM; tm++) {
+        result[tm] *= out_scale;
+      }
+    }
+
+    // Simdgroup accumulations
+    MLX_MTL_PRAGMA_UNROLL
+    for (int tm = 0; tm < TM; tm++) {
+      MLX_MTL_PRAGMA_UNROLL
+      for (ushort sn = (SN / 2); sn >= 1; sn >>= 1) {
+        result[tm] += simd_shuffle_down(result[tm], sn);
+      }
+    }
+
+    // Threadgroup accumulation results
+    if (needs_tgp_reduction) {
+      threadgroup AccT* tgp_results = tgp_memory + sgN * (blockM + TM) + bm;
+      if (thrN == 0) {
+        MLX_MTL_PRAGMA_UNROLL
+        for (int tm = 0; tm < TM; tm++) {
+          tgp_results[tm] = result[tm];
+        }
+
+        threadgroup_barrier(mem_flags::mem_none);
+
+        if (sgN == 0) {
+          MLX_MTL_PRAGMA_UNROLL
+          for (int sgn = 1; sgn < BN; sgn++) {
+            MLX_MTL_PRAGMA_UNROLL
+            for (int tm = 0; tm < TM; tm++) {
+              result[tm] += tgp_results[sgn * (blockM + TM) + tm];
+            }
+          }
+        }
+      }
+    }
+
+    // Write outputs
+    if (simdN == 0 && thrN == 0) {
+      MLX_MTL_PRAGMA_UNROLL
+      for (int tm = 0; tm < TM; tm++) {
+        out_vec[out_row + tm] = static_cast<T>(result[tm]);
+      }
+    }
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+/// Vector matrix multiplication
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    typename out_mask_t,
+    typename op_mask_t,
+    const int BM, /* Threadgroup rows (in simdgroups) */
+    const int BN, /* Threadgroup cols (in simdgroups) */
+    const int SM, /* Simdgroup rows (in threads) */
+    const int SN, /* Simdgroup cols (in threads) */
+    const int TM, /* Thread rows (in elements) */
+    const int TN, /* Thread cols (in elements) */
+    typename AccT = float>
+struct GEMVTKernel {
+  MLX_MTL_CONST int threadsM = BM * SM;
+  MLX_MTL_CONST int threadsN = BN * SN;
+
+  MLX_MTL_CONST int blockM = threadsM * TM;
+  MLX_MTL_CONST int blockN = threadsN * TN;
+
+  static_assert(SM * SN == 32, "simdgroup can only have 32 threads");
+
+  MLX_MTL_CONST bool has_operand_mask = !metal::is_same_v<op_mask_t, nomask_t>;
+  MLX_MTL_CONST bool has_output_mask = !metal::is_same_v<out_mask_t, nomask_t>;
+
+  MLX_MTL_CONST bool has_mul_operand_mask =
+      has_operand_mask && !metal::is_same_v<op_mask_t, bool>;
+  MLX_MTL_CONST bool has_mul_output_mask =
+      has_output_mask && !metal::is_same_v<out_mask_t, bool>;
+
+  // - The matrix of size (M = in_vec_size, N = out_vec_size) is divided up
+  //   into blocks of (blockM, blockN) divided among threadgroups
+  // - Every thread works on a block of (TM, TN)
+  // - We assume each threadgroup has (threadsN, threadsM, 1) threads
+  //
+  // 1. A thread loads TN elements each from mat along TM contiguous rows
+  //    and the corresponding scalar from the vector
+  // 2. The thread then accumulates its local result for the block
+  // 3. At the end, each thread has accumulated results over all blocks across
+  //    the rows. These are then summed up across the threadgroup
+  // 4. Each threadgroup writes its accumulated BN * TN outputs
+  //
+  // Edge case handling:
+  // - The threadgroup with the largest tid has blocks that exceed the matrix
+  //   * The blocks that start outside the matrix are never read (thread results
+  //     remain zero)
+  //   * The last thread that partially overlaps with the matrix is shifted
+  //     inwards such that the thread block fits exactly in the matrix
+
+  MLX_MTL_CONST short tgp_mem_size = BM > 1 ? BM*(blockN + TN) : 0;
+  MLX_MTL_CONST bool needs_tgp_reduction = BM > 1;
+
+  static METAL_FUNC void run(
+      const device T* mat [[buffer(0)]],
+      const device T* in_vec [[buffer(1)]],
+      device T* out_vec [[buffer(3)]],
+      const constant int& in_vec_size [[buffer(4)]],
+      const constant int& out_vec_size [[buffer(5)]],
+      const constant int& marix_ld [[buffer(6)]],
+      const device out_mask_t* out_mask [[buffer(20)]],
+      const device op_mask_t* mat_mask [[buffer(21)]],
+      const device op_mask_t* vec_mask [[buffer(22)]],
+      const constant int* mask_strides [[buffer(23)]],
+      threadgroup AccT* tgp_memory [[threadgroup(0)]],
+      uint3 tid [[threadgroup_position_in_grid]],
+      uint3 lid [[thread_position_in_threadgroup]],
+      uint simd_gid [[simdgroup_index_in_threadgroup]],
+      uint simd_lid [[thread_index_in_simdgroup]]) {
+    // Appease compiler
+    (void)lid;
+
+    // Thread local accumulation results
+    AccT result[TN] = {0};
+    T inter[TN];
+    AccT v_coeff[TM];
+
+    const int thrM = SN != 32 ? simd_lid / SN : 0;
+    const int thrN = SN != 32 ? simd_lid % SN : int(simd_lid);
+
+    const int sgM = BN != 1 ? (simd_gid / BN) : int(simd_gid);
+    const int sgN = BN != 1 ? (simd_gid % BN) : 0;
+
+    const int simdM = SM * sgM;
+    const int simdN = SN * sgN;
+
+    int cm = (simdM + thrM);
+    int cn = (simdN + thrN);
+
+    int bm = cm * TM;
+    int bn = cn * TN;
+
+    int out_col = tid.x * blockN + bn;
+
+    // Prepare mask offsets
+    const constant int* out_mask_strides = mask_strides;
+    const constant int* mat_mask_strides =
+        out_mask_strides + (has_output_mask ? 2 : 0);
+    const constant int* vec_mask_strides =
+        mat_mask_strides + (has_operand_mask ? 2 : 0);
+
+    const int n_block_idx = blockM > blockN ? out_col / blockM : int(tid.x);
+
+    const int out_mask_offset =
+        !has_output_mask ? 0 : n_block_idx; // * out_mask_strides[0];
+
+    int mat_mask_offset =
+        !has_operand_mask ? 0 : n_block_idx * mat_mask_strides[0];
+    int vec_mask_offset = 0;
+    const int mat_mask_step = !has_operand_mask ? 0 : mat_mask_strides[1];
+    const int vec_mask_step = !has_operand_mask ? 0 : vec_mask_strides[0];
+
+    T out_scale{1};
+
+    // Check output mask
+    if (has_output_mask) {
+      auto mask_out = out_mask[out_mask_offset];
+
+      // Write zeros and return if mask is 0
+      if (!mask_out) {
+        if (cm == 0 && out_col < out_vec_size) {
+          if (out_col + TN <= out_vec_size) {
+            MLX_MTL_PRAGMA_UNROLL
+            for (int tn = 0; tn < TN; tn++) {
+              out_vec[out_col + tn] = T(0.);
+            }
+          } else {
+            for (int tn = 0; tn < TN && (out_col + tn) < out_vec_size; tn++) {
+              out_vec[out_col + tn] = T(0.);
+            }
+          }
+        }
+
+        return;
+      }
+
+      // Store scalar if multiplicative mask
+      if (has_mul_output_mask) {
+        out_scale = T(mask_out);
+      }
+    }
+
+    // Prepare for loop
+    constexpr const uniform<int> loop_stride = make_uniform(blockM);
+    const uniform<int> in_size = make_uniform(in_vec_size);
+    const uniform<int> n_iter = in_size / loop_stride;
+    const uniform<int> last_iter = loop_stride * n_iter;
+    const uniform<int> leftover = in_size - last_iter;
+
+    // Edgecase handling
+    if (out_col < out_vec_size) {
+      out_col = (out_col + TN) <= out_vec_size ? out_col : out_vec_size - TN;
+
+      // Per thread accumulation main loop
+      for (int i = 0; i < n_iter; ++i) {
+        // Adding a threadgroup_barrier improves performance slightly
+        // This is possibly it may help exploit cache better
+        threadgroup_barrier(mem_flags::mem_none);
+
+        if (!has_operand_mask ||
+            (bool(mat_mask[mat_mask_offset]) &&
+             bool(vec_mask[vec_mask_offset]))) {
+          T block_scale{1};
+          if (has_mul_operand_mask) {
+            block_scale =
+                T(mat_mask[mat_mask_offset]) * T(vec_mask[vec_mask_offset]);
+          }
+
+          MLX_MTL_PRAGMA_UNROLL
+          for (int tm = 0; tm < TM; tm++) {
+            v_coeff[tm] = static_cast<AccT>(in_vec[bm + tm]);
+          }
+
+          // Apply scale
+          if (has_mul_operand_mask) {
+            MLX_MTL_PRAGMA_UNROLL
+            for (int tm = 0; tm < TM; tm++) {
+              v_coeff[tm] *= block_scale;
+            }
+          }
+
+          MLX_MTL_PRAGMA_UNROLL
+          for (int tm = 0; tm < TM; tm++) {
+            for (int tn = 0; tn < TN; tn++) {
+              inter[tn] = mat[(bm + tm) * marix_ld + out_col + tn];
+            }
+            for (int tn = 0; tn < TN; tn++) {
+              result[tn] += v_coeff[tm] * inter[tn];
+            }
+          }
+        }
+
+        bm += blockM;
+        mat_mask_offset += mat_mask_step;
+        vec_mask_offset += vec_mask_step;
+      }
+
+      if (leftover > 0) {
+        if (!has_operand_mask ||
+            (bool(mat_mask[mat_mask_offset]) &&
+             bool(vec_mask[vec_mask_offset]))) {
+          T block_scale{1};
+          if (has_mul_operand_mask) {
+            block_scale =
+                T(mat_mask[mat_mask_offset]) * T(vec_mask[vec_mask_offset]);
+          }
+
+          for (int tm = 0; tm < TM && bm + tm < in_vec_size; tm++) {
+            v_coeff[tm] = static_cast<AccT>(in_vec[bm + tm]);
+
+            if (has_mul_operand_mask) {
+              v_coeff[tm] *= block_scale;
+            }
+
+            MLX_MTL_PRAGMA_UNROLL
+            for (int tn = 0; tn < TN; tn++) {
+              inter[tn] = mat[(bm + tm) * marix_ld + out_col + tn];
+            }
+
+            MLX_MTL_PRAGMA_UNROLL
+            for (int tn = 0; tn < TN; tn++) {
+              result[tn] += v_coeff[tm] * inter[tn];
+            }
+          }
+        }
+      }
+    }
+
+    // Apply out scale
+    if (has_mul_output_mask) {
+      MLX_MTL_PRAGMA_UNROLL
+      for (int tn = 0; tn < TN; tn++) {
+        result[tn] *= out_scale;
+      }
+    }
+
+    // Simdgroup accumulations
+    MLX_MTL_PRAGMA_UNROLL
+    for (int tn = 0; tn < TN; tn++) {
+      MLX_MTL_PRAGMA_UNROLL
+      for (ushort sm = (SM / 2); sm >= 1; sm >>= 1) {
+        result[tn] += simd_shuffle_down(result[tn], SN * sm);
+      }
+    }
+
+    // Threadgroup accumulation results
+    if (needs_tgp_reduction) {
+      threadgroup AccT* tgp_results = tgp_memory + sgM * (blockN + TN) + bn;
+      if (thrM == 0) {
+        MLX_MTL_PRAGMA_UNROLL
+        for (int tn = 0; tn < TN; tn++) {
+          tgp_results[tn] = result[tn];
+        }
+
+        threadgroup_barrier(mem_flags::mem_none);
+
+        if (sgM == 0) {
+          MLX_MTL_PRAGMA_UNROLL
+          for (int sgm = 1; sgm < BM; sgm++) {
+            MLX_MTL_PRAGMA_UNROLL
+            for (int tn = 0; tn < TN; tn++) {
+              result[tn] += tgp_results[sgm * (blockN + TN) + tn];
+            }
+          }
+        }
+      }
+    }
+
+    // Threadgroup accumulation and writing out results
+    if (cm == 0 && out_col < out_vec_size) {
+      MLX_MTL_PRAGMA_UNROLL
+      for (int j = 0; j < TN; j++) {
+        out_vec[out_col + j] = static_cast<T>(result[j]);
+      }
+    }
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+/// Matrix vector multiplication
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    typename out_mask_t,
+    typename op_mask_t,
+    const int BM, /* Threadgroup rows (in simdgroups) */
+    const int BN, /* Threadgroup cols (in simdgroups) */
+    const int SM, /* Simdgroup rows (in threads) */
+    const int SN, /* Simdgroup cols (in threads) */
+    const int TM, /* Thread rows (in elements) */
+    const int TN, /* Thread cols (in elements) */
+    const bool kDoNCBatch> /* Batch ndim > 1 */
+[[kernel, max_total_threads_per_threadgroup(BM* BN * 32)]] void gemv_masked(
+    const device T* mat [[buffer(0)]],
+    const device T* in_vec [[buffer(1)]],
+    device T* out_vec [[buffer(3)]],
+    const constant int& in_vec_size [[buffer(4)]],
+    const constant int& out_vec_size [[buffer(5)]],
+    const constant int& marix_ld [[buffer(6)]],
+    const constant int& batch_ndim [[buffer(9)]],
+    const constant int* batch_shape [[buffer(10)]],
+    const constant int64_t* vector_batch_stride [[buffer(11)]],
+    const constant int64_t* matrix_batch_stride [[buffer(12)]],
+    const device out_mask_t* out_mask [[buffer(20)]],
+    const device op_mask_t* mat_mask [[buffer(21)]],
+    const device op_mask_t* vec_mask [[buffer(22)]],
+    const constant int* mask_strides [[buffer(23)]],
+    const constant int64_t* mask_batch_strides [[buffer(24)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  using gemv_kernel =
+      GEMVKernel<T, out_mask_t, op_mask_t, BM, BN, SM, SN, TM, TN>;
+  threadgroup float tgp_memory
+      [gemv_kernel::tgp_mem_size == 0 ? 1 : gemv_kernel::tgp_mem_size];
+
+  constexpr bool has_operand_mask = !metal::is_same_v<op_mask_t, nomask_t>;
+  constexpr bool has_output_mask = !metal::is_same_v<out_mask_t, nomask_t>;
+
+  // Update batch offsets
+  if (kDoNCBatch) {
+    in_vec += elem_to_loc(tid.z, batch_shape, vector_batch_stride, batch_ndim);
+    mat += elem_to_loc(tid.z, batch_shape, matrix_batch_stride, batch_ndim);
+
+    if (has_output_mask) {
+      out_mask +=
+          elem_to_loc(tid.z, batch_shape, mask_batch_strides, batch_ndim);
+      mask_batch_strides += batch_ndim;
+    }
+
+    if (has_operand_mask) {
+      const constant auto* mask_strides_mat = mask_batch_strides;
+      const constant auto* mask_strides_vec = mask_strides_mat + batch_ndim;
+
+      ulong2 batch_offsets = elem_to_loc_broadcast(
+          tid.z, batch_shape, mask_strides_mat, mask_strides_vec, batch_ndim);
+
+      mat_mask += batch_offsets.x;
+      vec_mask += batch_offsets.y;
+    }
+
+  } else {
+    in_vec += tid.z * vector_batch_stride[0];
+    mat += tid.z * matrix_batch_stride[0];
+
+    if (has_output_mask) {
+      out_mask += tid.z * mask_batch_strides[0];
+      mask_batch_strides += batch_ndim;
+    }
+
+    if (has_operand_mask) {
+      mat_mask += tid.z * mask_batch_strides[0];
+      vec_mask += tid.z * mask_batch_strides[batch_ndim];
+    }
+  }
+
+  out_vec += tid.z * out_vec_size;
+
+  gemv_kernel::run(
+      mat,
+      in_vec,
+      out_vec,
+      in_vec_size,
+      out_vec_size,
+      marix_ld,
+      out_mask,
+      mat_mask,
+      vec_mask,
+      mask_strides,
+      gemv_kernel::tgp_mem_size == 0 ? nullptr : tgp_memory,
+      tid,
+      lid,
+      simd_gid,
+      simd_lid);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// Vector matrix multiplication
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    typename out_mask_t,
+    typename op_mask_t,
+    const int BM, /* Threadgroup rows (in simdgroups) */
+    const int BN, /* Threadgroup cols (in simdgroups) */
+    const int SM, /* Simdgroup rows (in threads) */
+    const int SN, /* Simdgroup cols (in threads) */
+    const int TM, /* Thread rows (in elements) */
+    const int TN, /* Thread cols (in elements) */
+    const bool kDoNCBatch> /* Batch ndim > 1 */
+[[kernel, max_total_threads_per_threadgroup(BM* BN * 32)]] void gemv_t_masked(
+    const device T* mat [[buffer(0)]],
+    const device T* in_vec [[buffer(1)]],
+    device T* out_vec [[buffer(3)]],
+    const constant int& in_vec_size [[buffer(4)]],
+    const constant int& out_vec_size [[buffer(5)]],
+    const constant int& marix_ld [[buffer(6)]],
+    const constant int& batch_ndim [[buffer(9)]],
+    const constant int* batch_shape [[buffer(10)]],
+    const constant int64_t* vector_batch_stride [[buffer(11)]],
+    const constant int64_t* matrix_batch_stride [[buffer(12)]],
+    const device out_mask_t* out_mask [[buffer(20)]],
+    const device op_mask_t* mat_mask [[buffer(21)]],
+    const device op_mask_t* vec_mask [[buffer(22)]],
+    const constant int* mask_strides [[buffer(23)]],
+    const constant int64_t* mask_batch_strides [[buffer(24)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  using gemv_kernel =
+      GEMVTKernel<T, out_mask_t, op_mask_t, BM, BN, SM, SN, TM, TN>;
+  threadgroup float tgp_memory
+      [gemv_kernel::tgp_mem_size == 0 ? 1 : gemv_kernel::tgp_mem_size];
+
+  constexpr bool has_operand_mask = !metal::is_same_v<op_mask_t, nomask_t>;
+  constexpr bool has_output_mask = !metal::is_same_v<out_mask_t, nomask_t>;
+
+  // Update batch offsets
+  if (kDoNCBatch) {
+    in_vec += elem_to_loc(tid.z, batch_shape, vector_batch_stride, batch_ndim);
+    mat += elem_to_loc(tid.z, batch_shape, matrix_batch_stride, batch_ndim);
+
+    if (has_output_mask) {
+      out_mask +=
+          elem_to_loc(tid.z, batch_shape, mask_batch_strides, batch_ndim);
+      mask_batch_strides += batch_ndim;
+    }
+
+    if (has_operand_mask) {
+      const constant auto* mask_strides_mat = mask_batch_strides;
+      const constant auto* mask_strides_vec = mask_strides_mat + batch_ndim;
+
+      ulong2 batch_offsets = elem_to_loc_broadcast(
+          tid.z, batch_shape, mask_strides_mat, mask_strides_vec, batch_ndim);
+
+      mat_mask += batch_offsets.x;
+      vec_mask += batch_offsets.y;
+    }
+
+  } else {
+    in_vec += tid.z * vector_batch_stride[0];
+    mat += tid.z * matrix_batch_stride[0];
+
+    if (has_output_mask) {
+      out_mask += tid.z * mask_batch_strides[0];
+      mask_batch_strides += batch_ndim;
+    }
+
+    if (has_operand_mask) {
+      mat_mask += tid.z * mask_batch_strides[0];
+      vec_mask += tid.z * mask_batch_strides[batch_ndim];
+    }
+  }
+
+  out_vec += tid.z * out_vec_size;
+
+  gemv_kernel::run(
+      mat,
+      in_vec,
+      out_vec,
+      in_vec_size,
+      out_vec_size,
+      marix_ld,
+      out_mask,
+      mat_mask,
+      vec_mask,
+      mask_strides,
+      gemv_kernel::tgp_mem_size == 0 ? nullptr : tgp_memory,
+      tid,
+      lid,
+      simd_gid,
+      simd_lid);
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/gemv_masked.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/gemv_masked.metal
new file mode 100644
index 0000000000000000000000000000000000000000..394250e29245128386d54413d704402cdb1ddcf1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/gemv_masked.metal
@@ -0,0 +1,76 @@
+// Copyright © 2023-2024 Apple Inc.
+
+// clang-format off
+#include <metal_simdgroup>
+#include <metal_stdlib>
+
+#include "mlx/backend/metal/kernels/utils.h"
+
+#include "mlx/backend/metal/kernels/gemv_masked.h"
+
+#define instantiate_gemv_helper(                                           \
+    outm_n, outm_t, opm_n, opm_t, name, itype, bm, bn, sm, sn, tm, tn, nc) \
+  instantiate_kernel(                                                      \
+    "gemv_outmask_" #outm_n "_opmask_" #opm_n "_" #name                    \
+      "_bm" #bm "_bn" #bn "_sm" #sm "_sn" #sn "_tm" #tm                    \
+      "_tn" #tn "_nc" #nc,                                                 \
+  gemv_masked, itype, outm_t, opm_t, bm, bn, sm, sn, tm, tn, nc)
+
+#define instantiate_gemv_base(name, itype, bm, bn, sm, sn, tm, tn, nc) \
+  instantiate_gemv_helper(bool_, bool, bool_, bool, name, itype, bm, bn, sm, sn, tm, tn, nc)      \
+  instantiate_gemv_helper(name, itype, name, itype, name, itype, bm, bn, sm, sn, tm, tn, nc)      \
+  instantiate_gemv_helper(bool_, bool, name, itype, name, itype, bm, bn, sm, sn, tm, tn, nc)      \
+  instantiate_gemv_helper(name, itype, bool_, bool, name, itype, bm, bn, sm, sn, tm, tn, nc)      \
+  instantiate_gemv_helper(nomask, nomask_t, name, itype, name, itype, bm, bn, sm, sn, tm, tn, nc) \
+  instantiate_gemv_helper(nomask, nomask_t, bool_, bool, name, itype, bm, bn, sm, sn, tm, tn, nc) \
+  instantiate_gemv_helper(bool_, bool, nomask, nomask_t, name, itype, bm, bn, sm, sn, tm, tn, nc) \
+  instantiate_gemv_helper(name, itype, nomask, nomask_t, name, itype, bm, bn, sm, sn, tm, tn, nc)
+
+#define instantiate_gemv(name, itype, bm, bn, sm, sn, tm, tn)   \
+  instantiate_gemv_base(name, itype, bm, bn, sm, sn, tm, tn, 0) \
+  instantiate_gemv_base(name, itype, bm, bn, sm, sn, tm, tn, 1)
+
+#define instantiate_gemv_blocks(name, itype) \
+  instantiate_gemv(name, itype, 2, 1, 4,  8, 1, 4) \
+  instantiate_gemv(name, itype, 2, 1, 4,  8, 4, 4) \
+  instantiate_gemv(name, itype, 2, 1, 2, 16, 1, 4) \
+  instantiate_gemv(name, itype, 2, 1, 2, 16, 4, 4) \
+  instantiate_gemv(name, itype, 4, 1, 2, 16, 4, 4)
+
+instantiate_gemv_blocks(float32, float);
+instantiate_gemv_blocks(float16, half);
+instantiate_gemv_blocks(bfloat16, bfloat16_t);
+
+#define instantiate_gemv_t_helper(                                           \
+    outm_n, outm_t, opm_n, opm_t, name, itype, bm, bn, sm, sn, tm, tn, nc)   \
+  instantiate_kernel(                                                        \
+    "gemv_t_outmask_" #outm_n "_opmask_" #opm_n "_" #name                    \
+      "_bm" #bm "_bn" #bn "_sm" #sm "_sn" #sn "_tm" #tm                      \
+      "_tn" #tn "_nc" #nc,                                                   \
+  gemv_t_masked, itype, outm_t, opm_t, bm, bn, sm, sn, tm, tn, nc)
+
+#define instantiate_gemv_t_base(name, itype, bm, bn, sm, sn, tm, tn, nc) \
+  instantiate_gemv_t_helper(bool_, bool, bool_, bool, name, itype, bm, bn, sm, sn, tm, tn, nc)      \
+  instantiate_gemv_t_helper(name, itype, name, itype, name, itype, bm, bn, sm, sn, tm, tn, nc)      \
+  instantiate_gemv_t_helper(bool_, bool, name, itype, name, itype, bm, bn, sm, sn, tm, tn, nc)      \
+  instantiate_gemv_t_helper(name, itype, bool_, bool, name, itype, bm, bn, sm, sn, tm, tn, nc)      \
+  instantiate_gemv_t_helper(nomask, nomask_t, name, itype, name, itype, bm, bn, sm, sn, tm, tn, nc) \
+  instantiate_gemv_t_helper(nomask, nomask_t, bool_, bool, name, itype, bm, bn, sm, sn, tm, tn, nc) \
+  instantiate_gemv_t_helper(bool_, bool, nomask, nomask_t, name, itype, bm, bn, sm, sn, tm, tn, nc) \
+  instantiate_gemv_t_helper(name, itype, nomask, nomask_t, name, itype, bm, bn, sm, sn, tm, tn, nc)
+
+#define instantiate_gemv_t(name, itype, bm, bn, sm, sn, tm, tn)   \
+  instantiate_gemv_t_base(name, itype, bm, bn, sm, sn, tm, tn, 0) \
+  instantiate_gemv_t_base(name, itype, bm, bn, sm, sn, tm, tn, 1)
+
+#define instantiate_gemv_t_blocks(name, itype) \
+  instantiate_gemv_t(name, itype, 1, 1,  8, 4, 4, 1) \
+  instantiate_gemv_t(name, itype, 1, 2,  8, 4, 4, 4) \
+  instantiate_gemv_t(name, itype, 1, 1,  8, 4, 8, 1) \
+  instantiate_gemv_t(name, itype, 1, 1,  8, 4, 8, 4) \
+  instantiate_gemv_t(name, itype, 1, 2,  8, 4, 8, 4) \
+  instantiate_gemv_t(name, itype, 1, 4,  8, 4, 8, 4)
+
+instantiate_gemv_t_blocks(float32, float);
+instantiate_gemv_t_blocks(float16, half);
+instantiate_gemv_t_blocks(bfloat16, bfloat16_t); // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/hadamard.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/hadamard.h
new file mode 100644
index 0000000000000000000000000000000000000000..9f2311c10155726a773271be890943cc60def673
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/hadamard.h
@@ -0,0 +1,182 @@
+// Copyright © 2024 Apple Inc.
+#include <metal_common>
+#include <metal_compute>
+
+#include "mlx/backend/metal/kernels/steel/defines.h"
+
+using namespace metal;
+
+// Thread local Hadamard transform for 2^R
+template <short R>
+METAL_FUNC void radix_func(thread float* x) {
+  constexpr short logR = __builtin_ctz(R);
+  short h = 1;
+  STEEL_PRAGMA_UNROLL
+  for (short s = 0; s < logR; s++) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < R / 2; i++) {
+      short k = i & (h - 1);
+      short j = ((i - k) << 1) + k;
+      float a = x[j];
+      float b = x[j + h];
+      x[j] = a + b;
+      x[j + h] = a - b;
+    }
+    h <<= 1;
+  }
+}
+
+template <typename T, int N, int max_radix, int read_width, int stride = 1>
+[[kernel]] void hadamard_n(
+    const device T* in [[buffer(0)]],
+    device T* out [[buffer(1)]],
+    constant const float& scale,
+    uint3 elem [[thread_position_in_grid]],
+    uint3 grid [[threads_per_grid]]) {
+  // Compute a Hadamard transform of size N = 2^k
+  //
+  // Equivalent to:
+  //    from scipy.linalg import hadamard
+  //    y = hadamard(len(x)) @ x
+
+  constexpr short num_threads = N / max_radix;
+  constexpr short logN = __builtin_ctz(N);
+  constexpr short logR = __builtin_ctz(max_radix);
+  constexpr short num_steps = logN / logR;
+  constexpr short logFinal = logN % logR;
+  constexpr short final_radix = 1 << (logFinal);
+
+  int batch_idx = elem.y * N * stride + elem.z;
+  short i = elem.x;
+
+  threadgroup T buf[N];
+
+  // Read values from device
+  if (stride == 1) {
+    STEEL_PRAGMA_UNROLL
+    for (short j = 0; j < max_radix / read_width; j++) {
+      short index = j * read_width * num_threads + i * read_width;
+      STEEL_PRAGMA_UNROLL
+      for (short r = 0; r < read_width; r++) {
+        buf[index + r] = in[batch_idx + index + r];
+      }
+    }
+  } else {
+    STEEL_PRAGMA_UNROLL
+    for (short j = 0; j < max_radix; j++) {
+      buf[j * num_threads + i] = in[batch_idx + (j * num_threads + i) * stride];
+    }
+  }
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  float x[max_radix];
+  short h = 1;
+
+  STEEL_PRAGMA_UNROLL
+  for (short s = 0; s < num_steps; s++) {
+    short k = i & (h - 1);
+    short j = ((i - k) << logR) + k;
+
+    STEEL_PRAGMA_UNROLL
+    for (short r = 0; r < max_radix; r++) {
+      x[r] = buf[j + h * r];
+    }
+
+    radix_func<max_radix>(x);
+
+    STEEL_PRAGMA_UNROLL
+    for (short r = 0; r < max_radix; r++) {
+      buf[j + h * r] = T(x[r]);
+    }
+
+    h <<= logR;
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+  }
+
+  // Do the final radix
+  // e.g. max_radix = 16
+  //      N = 1024 = 16 * 16 * 4
+  if (final_radix > 1) {
+    // Each thread does multiple butterflies
+    STEEL_PRAGMA_UNROLL
+    for (int t = 0; t < max_radix / final_radix; t++) {
+      short index = i + t * num_threads;
+      short k = index & (h - 1);
+      short j = ((index - k) << logFinal) + k;
+      STEEL_PRAGMA_UNROLL
+      for (short r = 0; r < final_radix; r++) {
+        x[r] = buf[j + h * r];
+      }
+
+      radix_func<final_radix>(x);
+
+      STEEL_PRAGMA_UNROLL
+      for (short r = 0; r < final_radix; r++) {
+        buf[j + h * r] = T(x[r]);
+      }
+    }
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+  }
+
+  // Write values to device
+  if (stride == 1) {
+    STEEL_PRAGMA_UNROLL
+    for (short j = 0; j < max_radix / read_width; j++) {
+      short index = j * read_width * num_threads + i * read_width;
+      STEEL_PRAGMA_UNROLL
+      for (short r = 0; r < read_width; r++) {
+        out[batch_idx + index + r] = T(buf[index + r] * scale);
+      }
+    }
+  } else {
+    STEEL_PRAGMA_UNROLL
+    for (short j = 0; j < max_radix; j++) {
+      out[batch_idx + (j * num_threads + i) * stride] =
+          buf[j * num_threads + i];
+    }
+  }
+}
+
+template <typename T, int N, int M, int read_width>
+[[kernel]] void hadamard_m(
+    const device T* in [[buffer(0)]],
+    device T* out [[buffer(1)]],
+    constant const float& scale,
+    uint3 elem [[thread_position_in_grid]],
+    uint3 grid [[threads_per_grid]]) {
+  // Compute a Hadamard transform of size M
+  // using a naive O(M^2) codelet.
+  //
+  // This kernel is the second stage in the computation
+  // of a Hadamard transform of size M*N where N = 2^k.
+
+  int index = elem.x * grid.y + elem.y;
+  short i = index % (N / read_width);
+  int batch_idx = index / (N / read_width) * M * N;
+
+  float x[read_width][M];
+  STEEL_PRAGMA_UNROLL
+  for (short c = 0; c < M; c++) {
+    STEEL_PRAGMA_UNROLL
+    for (short r = 0; r < read_width; r++) {
+      x[r][c] = in[batch_idx + c * N + i * read_width + r];
+    }
+  }
+
+  STEEL_PRAGMA_UNROLL
+  for (short r = 0; r < read_width; r++) {
+    // This function is JIT compiled for M
+    // using the Hadamard matrix strings in `metal/hadamard.cpp`
+    hadamard_radix_m(x[r]);
+  }
+
+  // Write back to device
+  STEEL_PRAGMA_UNROLL
+  for (short c = 0; c < M; c++) {
+    STEEL_PRAGMA_UNROLL
+    for (short r = 0; r < read_width; r++) {
+      out[batch_idx + c * N + i * read_width + r] = T(x[r][c] * scale);
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/gather.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/gather.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b93c01679c13707479907a0285213e36334d749
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/gather.h
@@ -0,0 +1,51 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/indexing/indexing.h"
+
+template <typename T, typename IdxT, int NIDX, int IDX_NDIM, typename LocT>
+METAL_FUNC void gather_impl(
+    const device T* src [[buffer(0)]],
+    device T* out [[buffer(1)]],
+    const constant int* src_shape [[buffer(2)]],
+    const constant int64_t* src_strides [[buffer(3)]],
+    const constant size_t& src_ndim [[buffer(4)]],
+    const constant int* slice_sizes [[buffer(5)]],
+    const constant int* axes [[buffer(6)]],
+    const thread Indices<IdxT, NIDX>& indices,
+    uint3 index [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {
+  LocT src_idx = 0;
+  for (int i = 0; i < NIDX; ++i) {
+    LocT idx_loc;
+    if (IDX_NDIM == 0) {
+      idx_loc = 0;
+    } else if (IDX_NDIM == 1) {
+      idx_loc = index.x * static_cast<LocT>(indices.strides[indices.ndim * i]);
+    } else {
+      idx_loc = index.x * static_cast<LocT>(indices.strides[indices.ndim * i]);
+      idx_loc += indices.row_contiguous[i]
+          ? index.y
+          : elem_to_loc<LocT>(
+                index.y,
+                &indices.shapes[indices.ndim * i + 1],
+                &indices.strides[indices.ndim * i + 1],
+                indices.ndim - 1);
+    }
+    auto ax = axes[i];
+    auto idx_val = offset_neg_idx(indices.buffers[i][idx_loc], src_shape[ax]);
+    src_idx += static_cast<LocT>(idx_val) * static_cast<LocT>(src_strides[ax]);
+  }
+
+  auto src_offset =
+      elem_to_loc<LocT>(index.z, slice_sizes, src_strides, src_ndim);
+
+  LocT out_idx = index.z;
+  if (IDX_NDIM == 1) {
+    out_idx += static_cast<LocT>(grid_dim.z) * index.x;
+  } else if (IDX_NDIM >= 2) {
+    out_idx += grid_dim.z * (index.x * static_cast<LocT>(grid_dim.y) + index.y);
+  }
+  out[out_idx] = src[src_offset + src_idx];
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/gather_axis.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/gather_axis.h
new file mode 100644
index 0000000000000000000000000000000000000000..bf490ade06bbee92a55779d20455eecb079c9d1e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/gather_axis.h
@@ -0,0 +1,44 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+template <typename T, typename IdxT, typename LocT, bool SrcC, bool IdxC>
+[[kernel]] void gather_axis(
+    const device T* src [[buffer(0)]],
+    const device IdxT* indices [[buffer(1)]],
+    device T* out [[buffer(2)]],
+    const constant int* shape [[buffer(3)]],
+    const constant int64_t* src_strides [[buffer(4)]],
+    const constant int64_t* idx_strides [[buffer(5)]],
+    const constant size_t& ndim [[buffer(6)]],
+    const constant int& axis [[buffer(7)]],
+    const constant int& axis_size [[buffer(8)]],
+    const constant size_t& src_ax_stride [[buffer(9)]],
+    const constant size_t& idx_ax_stride [[buffer(10)]],
+    uint3 index [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {
+  LocT elem_idx = index.z * static_cast<LocT>(grid_dim.x);
+  LocT out_idx = elem_idx * grid_dim.y + index.x;
+
+  LocT idx_loc = index.y * static_cast<LocT>(idx_ax_stride);
+  if (IdxC) {
+    idx_loc += out_idx;
+  } else {
+    idx_loc += elem_to_loc<LocT>(elem_idx + index.x, shape, idx_strides, ndim);
+  }
+
+  auto idx_val = indices[idx_loc];
+  if (is_signed_v<IdxT>) {
+    idx_val = (idx_val < 0) ? idx_val + axis_size : idx_val;
+  }
+
+  LocT src_idx = idx_val * static_cast<LocT>(src_ax_stride);
+  if (SrcC) {
+    src_idx += elem_idx * axis_size + index.x;
+  } else {
+    src_idx += elem_to_loc<LocT>(elem_idx + index.x, shape, src_strides, ndim);
+  }
+
+  out_idx += index.y * static_cast<LocT>(grid_dim.x);
+  out[out_idx] = src[src_idx];
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/gather_front.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/gather_front.h
new file mode 100644
index 0000000000000000000000000000000000000000..1389e4c621cff0b804b8a331f51ac945d8875ce1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/gather_front.h
@@ -0,0 +1,24 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/indexing/indexing.h"
+
+template <typename T, typename IdxT, typename LocT, int N>
+[[kernel]] void gather_front(
+    const device T* src,
+    const device IdxT* indices,
+    device T* out,
+    const constant int64_t& stride,
+    const constant int& size,
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  auto idx = offset_neg_idx(indices[index.y], size);
+  LocT src_idx = static_cast<LocT>(stride) * idx;
+  LocT out_idx = static_cast<LocT>(stride) * index.y;
+
+  int s_idx = N * index.x;
+  for (int i = 0; i < N && s_idx < stride; ++i, ++s_idx) {
+    out[out_idx + s_idx] = src[src_idx + s_idx];
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/indexing.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/indexing.h
new file mode 100644
index 0000000000000000000000000000000000000000..2a4b4f929895d5546b7222e73690c1951737ab9c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/indexing.h
@@ -0,0 +1,23 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <metal_stdlib>
+
+template <typename IdxT, int NIDX>
+struct Indices {
+  const array<const device IdxT*, NIDX> buffers;
+  const constant int* shapes;
+  const constant int64_t* strides;
+  const constant bool* row_contiguous;
+  const int ndim;
+};
+
+template <typename IdxT>
+METAL_FUNC size_t offset_neg_idx(IdxT idx, int size) {
+  if (is_unsigned_v<IdxT>) {
+    return idx;
+  } else {
+    return (idx < 0) ? idx + size : idx;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/scatter.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/scatter.h
new file mode 100644
index 0000000000000000000000000000000000000000..f0217b3369f2c87c826a963ba900773d3b59bc91
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/scatter.h
@@ -0,0 +1,59 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/indexing/indexing.h"
+
+template <
+    typename T,
+    typename IdxT,
+    typename Op,
+    int NIDX,
+    bool UPD_ROW_CONTIG,
+    int NWORK,
+    typename LocT>
+METAL_FUNC void scatter_impl(
+    const device T* updates,
+    device mlx_atomic<T>* out,
+    const constant int* upd_shape,
+    const constant int64_t* upd_strides,
+    const constant size_t& upd_ndim,
+    const constant size_t& upd_size,
+    const constant int* out_shape,
+    const constant int64_t* out_strides,
+    const constant size_t& out_ndim,
+    const constant int* axes,
+    const constant size_t& idx_size,
+    const thread Indices<IdxT, NIDX>& indices,
+    uint2 gid [[thread_position_in_grid]]) {
+  Op op;
+
+  auto ind_idx = gid.y * NWORK;
+  LocT out_offset = 0;
+  if (upd_size > 1) {
+    out_offset = elem_to_loc<LocT>(
+        gid.x, upd_shape + indices.ndim, out_strides, out_ndim);
+  }
+
+  for (int j = 0; j < NWORK && ind_idx < idx_size; ++j, ind_idx++) {
+    LocT out_idx = out_offset;
+    for (int i = 0; i < NIDX; ++i) {
+      auto idx_loc = indices.row_contiguous[i]
+          ? ind_idx
+          : elem_to_loc<LocT>(
+                ind_idx,
+                &indices.shapes[indices.ndim * i],
+                &indices.strides[indices.ndim * i],
+                indices.ndim);
+      auto ax = axes[i];
+      auto idx_val = offset_neg_idx(indices.buffers[i][idx_loc], out_shape[ax]);
+      out_idx +=
+          static_cast<LocT>(idx_val) * static_cast<LocT>(out_strides[ax]);
+    }
+    auto upd_idx = ind_idx * static_cast<LocT>(upd_size) + gid.x;
+    if constexpr (!UPD_ROW_CONTIG) {
+      upd_idx = elem_to_loc<LocT>(upd_idx, upd_shape, upd_strides, upd_ndim);
+    }
+    op.atomic_update(out, updates[upd_idx], out_idx);
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/scatter_axis.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/scatter_axis.h
new file mode 100644
index 0000000000000000000000000000000000000000..73fd7ab4a3dfbf75e7a92451997bcf56cfa71f23
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/indexing/scatter_axis.h
@@ -0,0 +1,52 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+template <
+    typename T,
+    typename IdxT,
+    typename LocT,
+    typename Op,
+    bool UpdC,
+    bool IdxC>
+[[kernel]] void scatter_axis(
+    const device T* upd [[buffer(0)]],
+    const device IdxT* indices [[buffer(1)]],
+    device mlx_atomic<T>* out [[buffer(2)]],
+    const constant int* shape [[buffer(3)]],
+    const constant int64_t* upd_strides [[buffer(4)]],
+    const constant int64_t* idx_strides [[buffer(5)]],
+    const constant size_t& ndim [[buffer(6)]],
+    const constant int& axis [[buffer(7)]],
+    const constant int& out_axis_size [[buffer(8)]],
+    const constant size_t& upd_ax_stride [[buffer(9)]],
+    const constant size_t& idx_ax_stride [[buffer(10)]],
+    uint3 index [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {
+  Op op;
+
+  LocT elem_idx = index.z * static_cast<LocT>(grid_dim.x);
+
+  LocT idx_loc = index.y * static_cast<LocT>(idx_ax_stride);
+  if (IdxC) {
+    idx_loc += elem_idx * grid_dim.y + index.x;
+  } else {
+    idx_loc += elem_to_loc<LocT>(elem_idx + index.x, shape, idx_strides, ndim);
+  }
+
+  auto idx_val = indices[idx_loc];
+  if (is_signed_v<IdxT>) {
+    idx_val = (idx_val < 0) ? idx_val + out_axis_size : idx_val;
+  }
+
+  LocT upd_idx = index.y * static_cast<LocT>(upd_ax_stride);
+  if (UpdC) {
+    upd_idx += elem_idx * grid_dim.y + index.x;
+  } else {
+    upd_idx += elem_to_loc<LocT>(elem_idx + index.x, shape, upd_strides, ndim);
+  }
+
+  LocT out_idx = elem_idx * static_cast<LocT>(out_axis_size) +
+      idx_val * grid_dim.x + index.x;
+  op.atomic_update(out, upd[upd_idx], out_idx);
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/jit/bf16.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/jit/bf16.h
new file mode 100644
index 0000000000000000000000000000000000000000..702e8a4eb54edce7391ca57c7bc43387c57de1b7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/jit/bf16.h
@@ -0,0 +1,16 @@
+// Copyright © 2024 Apple Inc.
+
+// clang-format off
+#define jit_if #if
+#define jit_else #else
+#define jit_endif #endif
+
+jit_if (__METAL_VERSION__ >= 310)
+
+#include "mlx/backend/metal/kernels/metal_3_1/bf16.h"
+
+jit_else
+
+#include "mlx/backend/metal/kernels/metal_3_0/bf16.h"
+
+jit_endif // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/layer_norm.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/layer_norm.metal
new file mode 100644
index 0000000000000000000000000000000000000000..ea77b53dcaa1c64e72c50f5917e64b5b7b93817e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/layer_norm.metal
@@ -0,0 +1,433 @@
+// Copyright © 2024 Apple Inc.
+
+#include <metal_common>
+#include <metal_simdgroup>
+
+#include "mlx/backend/metal/kernels/utils.h"
+
+using namespace metal;
+
+constant bool has_w [[function_constant(20)]];
+
+template <int N = 1>
+inline void initialize_buffer(
+    threadgroup float* xs,
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  if (simd_group_id == 0) {
+    for (int i = 0; i < N; i++) {
+      xs[N * simd_lane_id + i] = 0;
+    }
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+}
+
+template <int N = 1>
+inline void threadgroup_sum(
+    thread float* x,
+    threadgroup float* xs,
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  for (int i = 0; i < N; i++) {
+    x[i] = simd_sum(x[i]);
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (simd_lane_id == 0) {
+    for (int i = 0; i < N; i++) {
+      xs[N * simd_group_id + i] = x[i];
+    }
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  for (int i = 0; i < N; i++) {
+    x[i] = xs[N * simd_lane_id + i];
+    x[i] = simd_sum(x[i]);
+  }
+}
+
+template <typename T, int N_READS = 8>
+[[kernel]] void layer_norm_single_row(
+    const device T* x,
+    const device T* w,
+    const device T* b,
+    device T* out,
+    constant float& eps,
+    constant uint& axis_size,
+    constant uint& w_stride,
+    constant uint& b_stride,
+    uint gid [[threadgroup_position_in_grid]],
+    uint lid [[thread_position_in_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  constexpr int SIMD_SIZE = 32;
+
+  // Initialize the registers and threadgroup memory
+  float thread_x[N_READS] = {0};
+  threadgroup float local_buffer[SIMD_SIZE] = {0};
+  initialize_buffer(local_buffer, simd_lane_id, simd_group_id);
+
+  // Advance the pointers
+  x += gid * size_t(axis_size) + lid * N_READS;
+  w += w_stride * lid * N_READS;
+  b += b_stride * lid * N_READS;
+  out += gid * size_t(axis_size) + lid * N_READS;
+
+  // Compute some variables for reading writing etc
+  const bool safe = lid * N_READS + N_READS <= axis_size;
+  const int n = axis_size - lid * N_READS;
+
+  // Read the inputs
+  if (safe) {
+    for (int i = 0; i < N_READS; i++) {
+      thread_x[i] = x[i];
+    }
+  } else {
+    for (int i = 0; i < n; i++) {
+      thread_x[i] = x[i];
+    }
+  }
+
+  // Compute the mean
+  float mean = 0;
+  for (int i = 0; i < N_READS; i++) {
+    mean += thread_x[i];
+  }
+  threadgroup_sum(&mean, local_buffer, simd_lane_id, simd_group_id);
+  mean /= axis_size;
+
+  // Compute the normalizer
+  float normalizer = 0;
+  if (!safe) {
+    for (int i = n; i < N_READS; i++) {
+      thread_x[i] = mean;
+    }
+  }
+  for (int i = 0; i < N_READS; i++) {
+    thread_x[i] -= mean;
+    normalizer += thread_x[i] * thread_x[i];
+  }
+  threadgroup_sum(&normalizer, local_buffer, simd_lane_id, simd_group_id);
+  normalizer = metal::precise::rsqrt(normalizer / axis_size + eps);
+
+  // Write the outputs
+  if (safe) {
+    for (int i = 0; i < N_READS; i++) {
+      thread_x[i] *= normalizer;
+      out[i] = w[w_stride * i] * static_cast<T>(thread_x[i]) + b[b_stride * i];
+    }
+  } else {
+    for (int i = 0; i < n; i++) {
+      thread_x[i] *= normalizer;
+      out[i] = w[w_stride * i] * static_cast<T>(thread_x[i]) + b[b_stride * i];
+    }
+  }
+}
+
+template <typename T, int N_READS = 4>
+[[kernel]] void layer_norm_looped(
+    const device T* x,
+    const device T* w,
+    const device T* b,
+    device T* out,
+    constant float& eps,
+    constant uint& axis_size,
+    constant uint& w_stride,
+    constant uint& b_stride,
+    uint gid [[threadgroup_position_in_grid]],
+    uint lid [[thread_position_in_threadgroup]],
+    uint lsize [[threads_per_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  constexpr int SIMD_SIZE = 32;
+
+  threadgroup float local_buffer[SIMD_SIZE];
+  initialize_buffer(local_buffer, simd_lane_id, simd_group_id);
+
+  x += gid * size_t(axis_size) + lid * N_READS;
+  w += w_stride * lid * N_READS;
+  b += b_stride * lid * N_READS;
+
+  // Compute the mean
+  float mean = 0;
+  for (uint r = 0; r < axis_size; r += lsize * N_READS) {
+    if (r + lid * N_READS + N_READS <= axis_size) {
+      for (int i = 0; i < N_READS; i++) {
+        mean += x[i + r];
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        if ((r + lid * N_READS + i) < axis_size) {
+          mean += x[i + r];
+        }
+      }
+    }
+  }
+  threadgroup_sum(&mean, local_buffer, simd_lane_id, simd_group_id);
+  mean /= axis_size;
+
+  // Compute the normalizer
+  float normalizer = 0;
+  for (uint r = 0; r < axis_size; r += lsize * N_READS) {
+    if (r + lid * N_READS + N_READS <= axis_size) {
+      for (int i = 0; i < N_READS; i++) {
+        float t = x[i + r] - mean;
+        normalizer += t * t;
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        if ((r + lid * N_READS + i) < axis_size) {
+          float t = x[i + r] - mean;
+          normalizer += t * t;
+        }
+      }
+    }
+  }
+  threadgroup_sum(&normalizer, local_buffer, simd_lane_id, simd_group_id);
+  normalizer = metal::precise::rsqrt(normalizer / axis_size + eps);
+
+  // Write the outputs
+  out += gid * size_t(axis_size) + lid * N_READS;
+  for (uint r = 0; r < axis_size; r += lsize * N_READS) {
+    if (r + lid * N_READS + N_READS <= axis_size) {
+      for (int i = 0; i < N_READS; i++) {
+        float xi = (x[r + i] - mean) * normalizer;
+        out[r + i] =
+            w[w_stride * (i + r)] * static_cast<T>(xi) + b[b_stride * (i + r)];
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        if ((r + lid * N_READS + i) < axis_size) {
+          float xi = (x[r + i] - mean) * normalizer;
+          out[r + i] = w[w_stride * (i + r)] * static_cast<T>(xi) +
+              b[b_stride * (i + r)];
+        }
+      }
+    }
+  }
+}
+
+template <typename T, int N_READS = 8>
+[[kernel]] void vjp_layer_norm_single_row(
+    const device T* x,
+    const device T* w,
+    const device T* g,
+    device T* gx,
+    device T* gw,
+    constant float& eps,
+    constant uint& axis_size,
+    constant uint& w_stride,
+    uint gid [[threadgroup_position_in_grid]],
+    uint lid [[thread_position_in_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  constexpr int SIMD_SIZE = 32;
+
+  // Advance the input pointers
+  x += gid * size_t(axis_size) + lid * N_READS;
+  g += gid * size_t(axis_size) + lid * N_READS;
+  w += w_stride * lid * N_READS;
+
+  // Initialize the registers and threadgroup memory
+  float thread_x[N_READS] = {0};
+  float thread_w[N_READS] = {0};
+  float thread_g[N_READS] = {0};
+  threadgroup float local_buffer[3 * SIMD_SIZE];
+  initialize_buffer<3>(local_buffer, simd_lane_id, simd_group_id);
+
+  // Compute some variables for reading writing etc
+  const bool safe = lid * N_READS + N_READS <= axis_size;
+  const int n = axis_size - lid * N_READS;
+
+  // Read the inputs
+  if (safe) {
+    for (int i = 0; i < N_READS; i++) {
+      thread_x[i] = x[i];
+      thread_g[i] = g[i];
+      thread_w[i] = w[i * w_stride];
+    }
+  } else {
+    for (int i = 0; i < n; i++) {
+      thread_x[i] = x[i];
+      thread_g[i] = g[i];
+      thread_w[i] = w[i * w_stride];
+    }
+  }
+
+  // Compute the mean
+  float mean = 0;
+  for (int i = 0; i < N_READS; i++) {
+    mean += thread_x[i];
+  }
+  threadgroup_sum(&mean, local_buffer, simd_lane_id, simd_group_id);
+  mean /= axis_size;
+
+  // Compute the neccesary scaling factors using the mean
+  if (!safe) {
+    for (int i = n; i < N_READS; i++) {
+      thread_x[i] = mean;
+    }
+  }
+  float factors[3] = {0};
+  constexpr int meanwg = 0;
+  constexpr int meanwgxc = 1;
+  constexpr int normalizer2 = 2;
+  for (int i = 0; i < N_READS; i++) {
+    thread_x[i] -= mean;
+    factors[meanwg] += thread_w[i] * thread_g[i];
+    factors[meanwgxc] += thread_w[i] * thread_g[i] * thread_x[i];
+    factors[normalizer2] += thread_x[i] * thread_x[i];
+  }
+  threadgroup_sum<3>(factors, local_buffer, simd_lane_id, simd_group_id);
+  factors[meanwg] /= axis_size;
+  factors[meanwgxc] /= axis_size;
+  factors[normalizer2] = 1 / (factors[normalizer2] / axis_size + eps);
+  float normalizer = metal::precise::sqrt(factors[normalizer2]);
+
+  // Write the outputs
+  gx += gid * size_t(axis_size) + lid * N_READS;
+  gw += gid * size_t(axis_size) + lid * N_READS;
+  if (safe) {
+    for (int i = 0; i < N_READS; i++) {
+      thread_x[i] *= normalizer;
+      gx[i] = static_cast<T>(
+          normalizer * (thread_w[i] * thread_g[i] - factors[meanwg]) -
+          thread_x[i] * factors[meanwgxc] * factors[normalizer2]);
+      if (has_w) {
+        gw[i] = static_cast<T>(thread_g[i] * thread_x[i]);
+      }
+    }
+  } else {
+    for (int i = 0; i < n; i++) {
+      thread_x[i] *= normalizer;
+      gx[i] = static_cast<T>(
+          normalizer * (thread_w[i] * thread_g[i] - factors[meanwg]) -
+          thread_x[i] * factors[meanwgxc] * factors[normalizer2]);
+      if (has_w) {
+        gw[i] = static_cast<T>(thread_g[i] * thread_x[i]);
+      }
+    }
+  }
+}
+
+template <typename T, int N_READS = 4>
+[[kernel]] void vjp_layer_norm_looped(
+    const device T* x,
+    const device T* w,
+    const device T* g,
+    device T* gx,
+    device T* gw,
+    constant float& eps,
+    constant uint& axis_size,
+    constant uint& w_stride,
+    uint gid [[threadgroup_position_in_grid]],
+    uint lid [[thread_position_in_threadgroup]],
+    uint lsize [[threads_per_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  constexpr int SIMD_SIZE = 32;
+
+  // Advance the input pointers
+  x += gid * size_t(axis_size) + lid * N_READS;
+  g += gid * size_t(axis_size) + lid * N_READS;
+  w += w_stride * lid * N_READS;
+
+  threadgroup float local_buffer[3 * SIMD_SIZE];
+  initialize_buffer<3>(local_buffer, simd_lane_id, simd_group_id);
+
+  // Compute the mean
+  float mean = 0;
+  for (uint r = 0; r < axis_size; r += lsize * N_READS) {
+    if (r + lid * N_READS + N_READS <= axis_size) {
+      for (int i = 0; i < N_READS; i++) {
+        mean += x[i + r];
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        if ((r + lid * N_READS + i) < axis_size) {
+          mean += x[i + r];
+        }
+      }
+    }
+  }
+  threadgroup_sum(&mean, local_buffer, simd_lane_id, simd_group_id);
+  mean /= axis_size;
+
+  // Compute the neccesary scaling factors using the mean
+  float factors[3] = {0};
+  constexpr int meanwg = 0;
+  constexpr int meanwgxc = 1;
+  constexpr int normalizer2 = 2;
+  for (uint r = 0; r < axis_size; r += lsize * N_READS) {
+    if (r + lid * N_READS + N_READS <= axis_size) {
+      for (int i = 0; i < N_READS; i++) {
+        float t = x[i + r] - mean;
+        float wi = w[(i + r) * w_stride];
+        float gi = g[i + r];
+        float wg = wi * gi;
+        factors[meanwg] += wg;
+        factors[meanwgxc] += wg * t;
+        factors[normalizer2] += t * t;
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        if ((r + lid * N_READS + i) < axis_size) {
+          float t = x[i + r] - mean;
+          float wi = w[(i + r) * w_stride];
+          float gi = g[i + r];
+          float wg = wi * gi;
+          factors[meanwg] += wg;
+          factors[meanwgxc] += wg * t;
+          factors[normalizer2] += t * t;
+        }
+      }
+    }
+  }
+  threadgroup_sum<3>(factors, local_buffer, simd_lane_id, simd_group_id);
+  factors[meanwg] /= axis_size;
+  factors[meanwgxc] /= axis_size;
+  factors[normalizer2] = 1 / (factors[normalizer2] / axis_size + eps);
+  float normalizer = metal::precise::sqrt(factors[normalizer2]);
+
+  // Write the outputs
+  gx += gid * size_t(axis_size) + lid * N_READS;
+  gw += gid * size_t(axis_size) + lid * N_READS;
+  for (uint r = 0; r < axis_size; r += lsize * N_READS) {
+    if (r + lid * N_READS + N_READS <= axis_size) {
+      for (int i = 0; i < N_READS; i++) {
+        float xi = (x[i + r] - mean) * normalizer;
+        float wi = w[(i + r) * w_stride];
+        float gi = g[i + r];
+        gx[i + r] = static_cast<T>(
+            normalizer * (wi * gi - factors[meanwg]) -
+            xi * factors[meanwgxc] * factors[normalizer2]);
+        if (has_w) {
+          gw[i + r] = static_cast<T>(gi * xi);
+        }
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        if ((r + lid * N_READS + i) < axis_size) {
+          float xi = (x[i + r] - mean) * normalizer;
+          float wi = w[(i + r) * w_stride];
+          float gi = g[i + r];
+          gx[i + r] = static_cast<T>(
+              normalizer * (wi * gi - factors[meanwg]) -
+              xi * factors[meanwgxc] * factors[normalizer2]);
+          if (has_w) {
+            gw[i + r] = static_cast<T>(gi * xi);
+          }
+        }
+      }
+    }
+  }
+}
+
+// clang-format off
+#define instantiate_layer_norm(name, itype)                                       \
+  instantiate_kernel("layer_norm" #name, layer_norm_single_row, itype)            \
+  instantiate_kernel("vjp_layer_norm" #name, vjp_layer_norm_single_row, itype)    \
+  instantiate_kernel("layer_norm_looped" #name, layer_norm_looped, itype)         \
+  instantiate_kernel("vjp_layer_norm_looped" #name, vjp_layer_norm_looped, itype)
+
+instantiate_layer_norm(float32, float)
+instantiate_layer_norm(float16, half)
+instantiate_layer_norm(bfloat16, bfloat16_t) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/logsumexp.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/logsumexp.h
new file mode 100644
index 0000000000000000000000000000000000000000..c746050b3f766b41e0c6112734385f3620e21ed8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/logsumexp.h
@@ -0,0 +1,140 @@
+// Copyright © 2025 Apple Inc.
+
+template <typename T, typename AccT = float, int N_READS = 4>
+[[kernel]] void logsumexp(
+    const device T* in,
+    device T* out,
+    constant int& axis_size,
+    uint gid [[threadgroup_position_in_grid]],
+    uint _lid [[thread_position_in_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  int lid = _lid;
+
+  constexpr int SIMD_SIZE = 32;
+
+  threadgroup AccT local_max[SIMD_SIZE];
+  threadgroup AccT local_normalizer[SIMD_SIZE];
+
+  AccT ld[N_READS];
+
+  in += gid * size_t(axis_size) + lid * N_READS;
+  if (lid * N_READS + N_READS <= axis_size) {
+    for (int i = 0; i < N_READS; i++) {
+      ld[i] = AccT(in[i]);
+    }
+  } else {
+    for (int i = 0; i < N_READS; i++) {
+      ld[i] =
+          ((lid * N_READS + i) < axis_size) ? AccT(in[i]) : Limits<AccT>::min;
+    }
+  }
+  if (simd_group_id == 0) {
+    local_max[simd_lane_id] = Limits<AccT>::min;
+    local_normalizer[simd_lane_id] = 0;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // Get the max
+  AccT maxval = Limits<AccT>::finite_min;
+  for (int i = 0; i < N_READS; i++) {
+    maxval = (maxval < ld[i]) ? ld[i] : maxval;
+  }
+  maxval = simd_max(maxval);
+  if (simd_lane_id == 0) {
+    local_max[simd_group_id] = maxval;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (simd_group_id == 0) {
+    maxval = simd_max(local_max[simd_lane_id]);
+    if (simd_lane_id == 0) {
+      local_max[0] = maxval;
+    }
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  maxval = local_max[0];
+
+  // Compute exp(x_i - maxval) and store the partial sums in local_normalizer
+  AccT normalizer = 0;
+  for (int i = 0; i < N_READS; i++) {
+    normalizer += fast::exp(ld[i] - maxval);
+  }
+  normalizer = simd_sum(normalizer);
+  if (simd_lane_id == 0) {
+    local_normalizer[simd_group_id] = normalizer;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (simd_group_id == 0) {
+    normalizer = simd_sum(local_normalizer[simd_lane_id]);
+    if (simd_lane_id == 0) {
+      out[gid] = isinf(maxval) ? T(maxval) : T(log(normalizer) + maxval);
+    }
+  }
+}
+
+template <typename T, typename AccT = float, int N_READS = 4>
+[[kernel]] void logsumexp_looped(
+    const device T* in,
+    device T* out,
+    constant int& axis_size,
+    uint gid [[threadgroup_position_in_grid]],
+    uint lid [[thread_position_in_threadgroup]],
+    uint lsize [[threads_per_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  in += gid * size_t(axis_size);
+
+  constexpr int SIMD_SIZE = 32;
+
+  threadgroup AccT local_max[SIMD_SIZE];
+  threadgroup AccT local_normalizer[SIMD_SIZE];
+
+  // Get the max and the normalizer in one go
+  AccT prevmax;
+  AccT maxval = Limits<AccT>::finite_min;
+  AccT normalizer = 0;
+  for (int r = 0; r < static_cast<int>(ceildiv(axis_size, N_READS * lsize));
+       r++) {
+    int offset = r * lsize * N_READS + lid * N_READS;
+    AccT vals[N_READS];
+    if (offset + N_READS <= axis_size) {
+      for (int i = 0; i < N_READS; i++) {
+        vals[i] = AccT(in[offset + i]);
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        vals[i] =
+            (offset + i < axis_size) ? AccT(in[offset + i]) : Limits<AccT>::min;
+      }
+    }
+    prevmax = maxval;
+    for (int i = 0; i < N_READS; i++) {
+      maxval = (maxval < vals[i]) ? vals[i] : maxval;
+    }
+    normalizer *= fast::exp(prevmax - maxval);
+    for (int i = 0; i < N_READS; i++) {
+      normalizer += fast::exp(vals[i] - maxval);
+    }
+  }
+  prevmax = maxval;
+  maxval = simd_max(maxval);
+  normalizer *= fast::exp(prevmax - maxval);
+  normalizer = simd_sum(normalizer);
+
+  prevmax = maxval;
+  if (simd_lane_id == 0) {
+    local_max[simd_group_id] = maxval;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  maxval = simd_max(local_max[simd_lane_id]);
+  normalizer *= fast::exp(prevmax - maxval);
+  if (simd_lane_id == 0) {
+    local_normalizer[simd_group_id] = normalizer;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  normalizer = simd_sum(local_normalizer[simd_lane_id]);
+
+  if (lid == 0) {
+    out[gid] = isinf(maxval) ? T(maxval) : T(log(normalizer) + maxval);
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/logsumexp.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/logsumexp.metal
new file mode 100644
index 0000000000000000000000000000000000000000..eb76436cf0c0b478277482fde3372d269cd186db
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/logsumexp.metal
@@ -0,0 +1,18 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <metal_common>
+#include <metal_simdgroup>
+
+using namespace metal;
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/logsumexp.h"
+
+#define instantiate_logsumexp(name, itype)                               \
+  instantiate_kernel("block_logsumexp_" #name, logsumexp, itype)         \
+  instantiate_kernel("looped_logsumexp_" #name, logsumexp_looped, itype) \
+
+instantiate_logsumexp(float32, float)
+instantiate_logsumexp(float16, half)
+instantiate_logsumexp(bfloat16, bfloat16_t) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/metal_3_0/bf16.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/metal_3_0/bf16.h
new file mode 100644
index 0000000000000000000000000000000000000000..f5d4867069de6a70f3917dc2f5eb0245b3abaca8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/metal_3_0/bf16.h
@@ -0,0 +1,314 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <metal_stdlib>
+
+using namespace metal;
+
+/////////////////////////////////////////////////////////////////////////////
+// Helpers
+/////////////////////////////////////////////////////////////////////////////
+
+constexpr METAL_FUNC uint16_t float_to_bfloat_bits(float x) {
+  // Check for nan
+  if ((as_type<uint32_t>(x) & ~_fp_encoding_traits<float>::sign_mask) >
+      _fp_encoding_traits<float>::inf_mask) {
+    return uint16_t(as_type<uint32_t>(0x7FC0));
+  }
+  // Take bits
+  uint32_t float_bits = as_type<uint32_t>(x);
+
+  // Round to nearest even
+  float_bits += ((float_bits >> 16) & 1) + as_type<uint32_t>(0x7FFF);
+
+  // Take upper 16 bits
+  return float_bits >> 16;
+}
+
+constexpr METAL_FUNC float bfloat_bits_to_float(uint16_t x) {
+  // Upper 16 bits are the data and lower 16 bits are 0s
+  return as_type<float>((uint32_t)x << 16);
+}
+
+struct _MLX_BFloat16;
+
+template <typename T>
+static constexpr constant bool can_convert_to_bfloat =
+    !is_same_v<T, _MLX_BFloat16> && is_convertible_v<T, float>;
+
+template <typename T>
+static constexpr constant bool can_convert_from_bfloat =
+    !is_same_v<T, _MLX_BFloat16> && is_convertible_v<float, T>;
+
+/////////////////////////////////////////////////////////////////////////////
+// Bfloat struct
+/////////////////////////////////////////////////////////////////////////////
+
+struct _MLX_BFloat16 {
+  /////////////////////////////////////////////////////////////////////////////
+  // Constructors
+  uint16_t bits_;
+  _MLX_BFloat16() thread = default;
+  _MLX_BFloat16() threadgroup = default;
+  _MLX_BFloat16() device = default;
+  _MLX_BFloat16() constant = default;
+
+  struct bits_to_bfloat_struct {};
+  static constexpr METAL_FUNC bits_to_bfloat_struct bits_to_bfloat() {
+    return bits_to_bfloat_struct();
+  }
+  constexpr METAL_FUNC _MLX_BFloat16(uint16_t bits, bits_to_bfloat_struct)
+      : bits_(bits) {}
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Conversions to bfloat
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_bfloat<T>>::type>
+  constexpr METAL_FUNC _MLX_BFloat16(T x) thread
+      : bits_(float_to_bfloat_bits(static_cast<float>(x))) {}
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_bfloat<T>>::type>
+  constexpr METAL_FUNC _MLX_BFloat16(T x) threadgroup
+      : bits_(float_to_bfloat_bits(static_cast<float>(x))) {}
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_bfloat<T>>::type>
+  constexpr METAL_FUNC _MLX_BFloat16(T x) device
+      : bits_(float_to_bfloat_bits(static_cast<float>(x))) {}
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_to_bfloat<T>>::type>
+  constexpr METAL_FUNC _MLX_BFloat16(T x) constant
+      : bits_(float_to_bfloat_bits(static_cast<float>(x))) {}
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Conversions from bfloat
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_bfloat<T>>::type>
+  constexpr METAL_FUNC operator T() const thread {
+    return static_cast<T>(bfloat_bits_to_float(bits_));
+  }
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_bfloat<T>>::type>
+  constexpr METAL_FUNC operator T() const threadgroup {
+    return static_cast<T>(bfloat_bits_to_float(bits_));
+  }
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_bfloat<T>>::type>
+  constexpr METAL_FUNC operator T() const device {
+    return static_cast<T>(bfloat_bits_to_float(bits_));
+  }
+
+  template <
+      typename T,
+      typename = typename enable_if<can_convert_from_bfloat<T>>::type>
+  constexpr METAL_FUNC operator T() const constant {
+    return static_cast<T>(bfloat_bits_to_float(bits_));
+  }
+};
+
+/////////////////////////////////////////////////////////////////////////////
+// Bfloat operators
+/////////////////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////////////////
+// Unary ops
+constexpr METAL_FUNC _MLX_BFloat16 operator-(_MLX_BFloat16 x) {
+  return -static_cast<float>(x);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Binary operators
+#define bfloat_binop_base(__op__, __operator__, otype, atype, btype, ctype) \
+  constexpr METAL_FUNC otype __operator__(atype lhs, btype rhs) {           \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);          \
+  }
+
+#define bfloat_binop_helper(__op__, __operator__, otype, itype, ctype)    \
+  constexpr METAL_FUNC otype __operator__(_MLX_BFloat16 lhs, itype rhs) { \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);        \
+  }                                                                       \
+  constexpr METAL_FUNC otype __operator__(itype lhs, _MLX_BFloat16 rhs) { \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);        \
+  }
+
+/////////////////////////////////////////////////////////////////////////////
+// Arithmetic Operators
+#define bfloat_binop(_op_, _operator_)                                       \
+  bfloat_binop_base(                                                         \
+      _op_, _operator_, _MLX_BFloat16, _MLX_BFloat16, _MLX_BFloat16, float); \
+  bfloat_binop_helper(_op_, _operator_, float, float, float);                \
+  bfloat_binop_helper(_op_, _operator_, float, half, float);                 \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, int32_t, float);      \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, uint32_t, float);     \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, int64_t, float);      \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, uint64_t, float);
+
+bfloat_binop(+, operator+);
+bfloat_binop(-, operator-);
+bfloat_binop(*, operator*);
+bfloat_binop(/, operator/);
+
+/////////////////////////////////////////////////////////////////////////////
+// Comparison ops
+#define bfloat_compop(__op__, __operator__)                             \
+  bfloat_binop_base(                                                    \
+      __op__, __operator__, bool, _MLX_BFloat16, _MLX_BFloat16, float); \
+  bfloat_binop_helper(__op__, __operator__, bool, float, float);        \
+  bfloat_binop_helper(__op__, __operator__, bool, half, float);         \
+  bfloat_binop_helper(__op__, __operator__, bool, int32_t, float);      \
+  bfloat_binop_helper(__op__, __operator__, bool, uint32_t, float);     \
+  bfloat_binop_helper(__op__, __operator__, bool, int64_t, float);      \
+  bfloat_binop_helper(__op__, __operator__, bool, uint64_t, float);
+
+bfloat_compop(>, operator>);
+bfloat_compop(<, operator<);
+bfloat_compop(>=, operator>=);
+bfloat_compop(<=, operator<=);
+bfloat_compop(==, operator==);
+bfloat_compop(!=, operator!=);
+
+#undef bfloat_compop
+#undef bfloat_binop_base
+#undef bfloat_binop_helper
+#undef bfloat_binop
+
+/////////////////////////////////////////////////////////////////////////////
+// Inplace Operators
+#define bfloat_inplace_op_helper(__op__, __operator__, itype, addr_space) \
+  constexpr METAL_FUNC addr_space _MLX_BFloat16& __operator__(            \
+      addr_space _MLX_BFloat16& lhs, itype rhs) {                         \
+    lhs = static_cast<float>(lhs) __op__ static_cast<float>(rhs);         \
+    return lhs;                                                           \
+  }                                                                       \
+  constexpr METAL_FUNC addr_space itype& __operator__(                    \
+      addr_space itype& lhs, _MLX_BFloat16 rhs) {                         \
+    lhs = static_cast<float>(lhs) __op__ static_cast<float>(rhs);         \
+    return lhs;                                                           \
+  }
+
+#define bfloat_inplace_op_addr_space_helper(__op__, __operator__, itype) \
+  bfloat_inplace_op_helper(__op__, __operator__, itype, device);         \
+  bfloat_inplace_op_helper(__op__, __operator__, itype, thread);         \
+  bfloat_inplace_op_helper(__op__, __operator__, itype, threadgroup);
+
+#define bfloat_inplace_op(itype)                             \
+  bfloat_inplace_op_addr_space_helper(+, operator+=, itype); \
+  bfloat_inplace_op_addr_space_helper(-, operator-=, itype); \
+  bfloat_inplace_op_addr_space_helper(*, operator*=, itype); \
+  bfloat_inplace_op_addr_space_helper(/, operator/=, itype);
+
+bfloat_inplace_op(float);
+bfloat_inplace_op(half);
+bfloat_inplace_op(int16_t);
+bfloat_inplace_op(int32_t);
+bfloat_inplace_op(int64_t);
+bfloat_inplace_op(uint16_t);
+bfloat_inplace_op(uint32_t);
+bfloat_inplace_op(uint64_t);
+
+#undef bfloat_inplace_op_helper
+#undef bfloat_inplace_op_addr_space_helper
+#undef bfloat_inplace_op
+
+#define bfloat_inplace_op_helper(__op__, __operator__, addr_space) \
+  constexpr METAL_FUNC addr_space _MLX_BFloat16& __operator__(     \
+      addr_space _MLX_BFloat16& lhs, _MLX_BFloat16 rhs) {          \
+    lhs = static_cast<float>(lhs) __op__ static_cast<float>(rhs);  \
+    return lhs;                                                    \
+  }
+
+#define bfloat_inplace_op_addr_space_helper(__op__, __operator__) \
+  bfloat_inplace_op_helper(__op__, __operator__, device);         \
+  bfloat_inplace_op_helper(__op__, __operator__, thread);         \
+  bfloat_inplace_op_helper(__op__, __operator__, threadgroup);
+
+bfloat_inplace_op_addr_space_helper(+, operator+=);
+bfloat_inplace_op_addr_space_helper(-, operator-=);
+bfloat_inplace_op_addr_space_helper(*, operator*=);
+bfloat_inplace_op_addr_space_helper(/, operator/=);
+
+#undef bfloat_inplace_op_helper
+#undef bfloat_inplace_op_addr_space_helper
+
+/////////////////////////////////////////////////////////////////////////////
+// Bfloat typedef
+/////////////////////////////////////////////////////////////////////////////
+
+typedef struct _MLX_BFloat16 bfloat16_t;
+
+/////////////////////////////////////////////////////////////////////////////
+// Bfloat numeric limits
+/////////////////////////////////////////////////////////////////////////////
+
+#pragma METAL internals : enable
+
+namespace metal {
+
+template <>
+struct _numeric_limits_impl<bfloat16_t> : _fp_numeric_limits_impl_base {
+  static constexpr constant int digits = 8;
+  static constexpr constant int digits10 = 2;
+  static constexpr constant int max_digits10 = 4;
+  static constexpr constant int radix = 2;
+  static constexpr constant int min_exponent = -125;
+  static constexpr constant int min_exponent10 = -37;
+  static constexpr constant int max_exponent = 128;
+  static constexpr constant int max_exponent10 = 38;
+
+  static constexpr bfloat16_t min() {
+    return _MLX_BFloat16(0x0080, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t lowest() {
+    return _MLX_BFloat16(0xFF7F, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t max() {
+    return _MLX_BFloat16(0x7F7F, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t epsilon() {
+    return _MLX_BFloat16(0x3C00, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t round_error() {
+    return _MLX_BFloat16(0x3F00, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t infinity() {
+    return _MLX_BFloat16(0x7F80, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t quiet_NaN() {
+    return _MLX_BFloat16(0x7FC0, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t signaling_NaN() {
+    return _MLX_BFloat16(0x7F80, _MLX_BFloat16::bits_to_bfloat());
+  }
+  static constexpr bfloat16_t denorm_min() {
+    return _MLX_BFloat16(0x0001, _MLX_BFloat16::bits_to_bfloat());
+  }
+};
+
+METAL_FUNC bool isnan(_MLX_BFloat16 x) {
+  return x != x;
+}
+
+} // namespace metal
+
+#pragma METAL internals : disable
+inline uint16_t bfloat16_to_uint16(const bfloat16_t x) {
+  return x.bits_;
+}
+
+inline bfloat16_t uint16_to_bfloat16(const uint16_t x) {
+  return _MLX_BFloat16(x, _MLX_BFloat16::bits_to_bfloat());
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/metal_3_1/bf16.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/metal_3_1/bf16.h
new file mode 100644
index 0000000000000000000000000000000000000000..aa3c3c7803a9adc70f3f13a649d57a3cc0cd0438
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/metal_3_1/bf16.h
@@ -0,0 +1,16 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <metal_stdlib>
+
+using namespace metal;
+
+typedef bfloat bfloat16_t;
+inline uint16_t bfloat16_to_uint16(const bfloat16_t x) {
+  return as_type<uint16_t>(x);
+}
+
+inline bfloat16_t uint16_to_bfloat16(const uint16_t x) {
+  return as_type<bfloat16_t>(x);
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/quantized.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/quantized.h
new file mode 100644
index 0000000000000000000000000000000000000000..bf639814b3ce2f22b1c9880a45b106b06dda6a03
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/quantized.h
@@ -0,0 +1,2502 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <metal_simdgroup>
+#include <metal_stdlib>
+
+constant bool align_M [[function_constant(200)]];
+constant bool align_N [[function_constant(201)]];
+constant bool align_K [[function_constant(202)]];
+
+using namespace metal;
+
+#define MLX_MTL_CONST static constant constexpr const
+
+MLX_MTL_CONST int SIMD_SIZE = 32;
+MLX_MTL_CONST int QUAD_SIZE = 4;
+
+template <int bits, int wsize = 8>
+inline constexpr short get_pack_factor() {
+  return (bits == 3 || bits == 5) ? 8 : (bits == 6 ? 4 : wsize / bits);
+}
+
+template <int bits, int wsize = 8>
+inline constexpr short get_bytes_per_pack() {
+  constexpr int power_of_2_bits = (bits & (bits - 1)) == 0;
+  return power_of_2_bits ? (wsize / 8) : (bits == 5 ? 5 : 3);
+}
+
+template <typename T, typename U, int values_per_thread, int bits>
+inline U load_vector(const device T* x, thread U* x_thread) {
+  static_assert(
+      bits == 2 || bits == 3 || bits == 4 || bits == 5 || bits == 6 ||
+          bits == 8,
+      "Template undefined for bits not in {2, 3, 4, 5, 6, 8}");
+
+  U sum = 0;
+
+  if (bits == 2) {
+    for (int i = 0; i < values_per_thread; i += 4) {
+      sum += x[i] + x[i + 1] + x[i + 2] + x[i + 3];
+      x_thread[i] = x[i];
+      x_thread[i + 1] = x[i + 1] / 4.0f;
+      x_thread[i + 2] = x[i + 2] / 16.0f;
+      x_thread[i + 3] = x[i + 3] / 64.0f;
+    }
+  }
+
+  else if (bits == 3) {
+    for (int i = 0; i < values_per_thread; i += 8) {
+      sum += x[i] + x[i + 1] + x[i + 2] + x[i + 3] + x[i + 4] + x[i + 5] +
+          x[i + 6] + x[i + 7];
+      x_thread[i] = x[i];
+      x_thread[i + 1] = x[i + 1] / 8.0f;
+      x_thread[i + 2] = x[i + 2] / 64.0f;
+      x_thread[i + 3] = x[i + 3] / 2.0f;
+      x_thread[i + 4] = x[i + 4] / 16.0f;
+      x_thread[i + 5] = x[i + 5] / 128.0f;
+      x_thread[i + 6] = x[i + 6] / 4.0f;
+      x_thread[i + 7] = x[i + 7] / 32.0f;
+    }
+  }
+
+  else if (bits == 4) {
+    for (int i = 0; i < values_per_thread; i += 4) {
+      sum += x[i] + x[i + 1] + x[i + 2] + x[i + 3];
+      x_thread[i] = x[i];
+      x_thread[i + 1] = x[i + 1] / 16.0f;
+      x_thread[i + 2] = x[i + 2] / 256.0f;
+      x_thread[i + 3] = x[i + 3] / 4096.0f;
+    }
+  }
+
+  else if (bits == 5) {
+    for (int i = 0; i < values_per_thread; i += 8) {
+      sum += x[i] + x[i + 1] + x[i + 2] + x[i + 3] + x[i + 4] + x[i + 5] +
+          x[i + 6] + x[i + 7];
+      x_thread[i] = x[i];
+      x_thread[i + 1] = x[i + 1] / 32.0f;
+      x_thread[i + 2] = x[i + 2] / 4.0f;
+      x_thread[i + 3] = x[i + 3] / 128.0f;
+      x_thread[i + 4] = x[i + 4] / 16.0f;
+      x_thread[i + 5] = x[i + 5] / 2.0f;
+      x_thread[i + 6] = x[i + 6] / 64.0f;
+      x_thread[i + 7] = x[i + 7] / 8.0f;
+    }
+  }
+
+  else if (bits == 6) {
+    for (int i = 0; i < values_per_thread; i += 4) {
+      sum += x[i] + x[i + 1] + x[i + 2] + x[i + 3];
+      x_thread[i] = x[i];
+      x_thread[i + 1] = x[i + 1] / 64.0f;
+      x_thread[i + 2] = x[i + 2] / 16.0f;
+      x_thread[i + 3] = x[i + 3] / 4.0f;
+    }
+  }
+
+  else if (bits == 8) {
+    for (int i = 0; i < values_per_thread; i++) {
+      sum += x[i];
+      x_thread[i] = x[i];
+    }
+  }
+
+  return sum;
+}
+
+template <typename T, typename U, int values_per_thread, int bits>
+inline U load_vector_safe(const device T* x, thread U* x_thread, int N) {
+  static_assert(
+      bits == 2 || bits == 3 || bits == 4 || bits == 5 || bits == 6 ||
+          bits == 8,
+      "Template undefined for bits not in {2, 3, 4, 5, 6, 8}");
+
+  U sum = 0;
+
+  if (bits == 2) {
+    for (int i = 0; i < N; i += 4) {
+      sum += x[i] + x[i + 1] + x[i + 2] + x[i + 3];
+      x_thread[i] = x[i];
+      x_thread[i + 1] = x[i + 1] / 4.0f;
+      x_thread[i + 2] = x[i + 2] / 16.0f;
+      x_thread[i + 3] = x[i + 3] / 64.0f;
+    }
+  }
+
+  else if (bits == 3) {
+    for (int i = 0; i < N; i += 8) {
+      sum += x[i] + x[i + 1] + x[i + 2] + x[i + 3] + x[i + 4] + x[i + 5] +
+          x[i + 6] + x[i + 7];
+
+      x_thread[i] = x[i];
+      x_thread[i + 1] = x[i + 1] / 8.0f;
+      x_thread[i + 2] = x[i + 2] / 64.0f;
+      x_thread[i + 3] = x[i + 3] / 2.0f;
+      x_thread[i + 4] = x[i + 4] / 16.0f;
+      x_thread[i + 5] = x[i + 5] / 128.0f;
+      x_thread[i + 6] = x[i + 6] / 4.0f;
+      x_thread[i + 7] = x[i + 7] / 32.0f;
+    }
+  }
+
+  else if (bits == 4) {
+    for (int i = 0; i < N; i += 4) {
+      sum += x[i] + x[i + 1] + x[i + 2] + x[i + 3];
+      x_thread[i] = x[i];
+      x_thread[i + 1] = x[i + 1] / 16.0f;
+      x_thread[i + 2] = x[i + 2] / 256.0f;
+      x_thread[i + 3] = x[i + 3] / 4096.0f;
+    }
+  }
+
+  else if (bits == 5) {
+    for (int i = 0; i < N; i += 8) {
+      sum += x[i] + x[i + 1] + x[i + 2] + x[i + 3] + x[i + 4] + x[i + 5] +
+          x[i + 6] + x[i + 7];
+      x_thread[i] = x[i];
+      x_thread[i + 1] = x[i + 1] / 32.0f;
+      x_thread[i + 2] = x[i + 2] / 4.0f;
+      x_thread[i + 3] = x[i + 3] / 128.0f;
+      x_thread[i + 4] = x[i + 4] / 16.0f;
+      x_thread[i + 5] = x[i + 5] / 2.0f;
+      x_thread[i + 6] = x[i + 6] / 64.0f;
+      x_thread[i + 7] = x[i + 7] / 8.0f;
+    }
+  }
+
+  else if (bits == 6) {
+    for (int i = 0; i < N; i += 4) {
+      sum += x[i] + x[i + 1] + x[i + 2] + x[i + 3];
+      x_thread[i] = x[i];
+      x_thread[i + 1] = x[i + 1] / 64.0f;
+      x_thread[i + 2] = x[i + 2] / 16.0f;
+      x_thread[i + 3] = x[i + 3] / 4.0f;
+    }
+  }
+
+  else if (bits == 8) {
+    for (int i = 0; i < N; i++) {
+      sum += x[i];
+      x_thread[i] = x[i];
+    }
+  }
+
+  for (int i = N; i < values_per_thread; i++) {
+    x_thread[i] = 0;
+  }
+
+  return sum;
+}
+
+template <typename U, int values_per_thread, int bits>
+inline U qdot(
+    const device uint8_t* w,
+    const thread U* x_thread,
+    U scale,
+    U bias,
+    U sum) {
+  static_assert(
+      bits == 2 || bits == 3 || bits == 4 || bits == 5 || bits == 6 ||
+          bits == 8,
+      "Template undefined for bits not in {2, 3, 4, 5, 6, 8}");
+
+  U accum = 0;
+
+  if (bits == 2) {
+    for (int i = 0; i < (values_per_thread / 4); i++) {
+      accum +=
+          (x_thread[4 * i] * (w[i] & 0x03) +
+           x_thread[4 * i + 1] * (w[i] & 0x0c) +
+           x_thread[4 * i + 2] * (w[i] & 0x30) +
+           x_thread[4 * i + 3] * (w[i] & 0xc0));
+    }
+  }
+
+  else if (bits == 3) {
+    for (int i = 0; i < (values_per_thread / 8); i++) {
+      x_thread += 8 * i;
+      w += 3 * i;
+
+      accum += (w[0] & 0x07) * x_thread[0];
+      accum += (w[0] & 0x38) * x_thread[1];
+      accum += (w[0] & 0xc0) * x_thread[2];
+      accum += (w[1] & 0x01) * (x_thread[2] * 256.0f);
+
+      accum += (w[1] & 0x0e) * x_thread[3];
+      accum += (w[1] & 0x70) * x_thread[4];
+      accum += (w[1] & 0x80) * x_thread[5];
+      accum += (w[2] & 0x03) * (x_thread[5] * 256.0f);
+
+      accum += (w[2] & 0x1c) * x_thread[6];
+      accum += (w[2] & 0xe0) * x_thread[7];
+    }
+  }
+
+  else if (bits == 4) {
+    const device uint16_t* ws = (const device uint16_t*)w;
+    for (int i = 0; i < (values_per_thread / 4); i++) {
+      accum +=
+          (x_thread[4 * i] * (ws[i] & 0x000f) +
+           x_thread[4 * i + 1] * (ws[i] & 0x00f0) +
+           x_thread[4 * i + 2] * (ws[i] & 0x0f00) +
+           x_thread[4 * i + 3] * (ws[i] & 0xf000));
+    }
+  }
+
+  else if (bits == 5) {
+    for (int i = 0; i < (values_per_thread / 8); i++) {
+      x_thread += 8 * i;
+      w += 5 * i;
+
+      accum += (w[0] & 0x1f) * x_thread[0];
+      accum += (w[0] & 0xe0) * x_thread[1];
+      accum += (w[1] & 0x3) * (x_thread[1] * 256.0f);
+      accum += (w[1] & 0x7c) * x_thread[2];
+      accum += (w[1] & 0x80) * x_thread[3];
+      accum += (w[2] & 0xf) * (x_thread[3] * 256.0f);
+      accum += (w[2] & 0xf0) * x_thread[4];
+      accum += (w[3] & 0x1) * (x_thread[4] * 256.0f);
+      accum += (w[3] & 0x3e) * x_thread[5];
+      accum += (w[3] & 0xc0) * x_thread[6];
+      accum += (w[4] & 0x7) * (x_thread[6] * 256.0f);
+      accum += (w[4] & 0xf8) * x_thread[7];
+    }
+  }
+
+  else if (bits == 6) {
+    for (int i = 0; i < (values_per_thread / 4); i++) {
+      x_thread += 4 * i;
+      w += 3 * i;
+
+      accum += (w[0] & 0x3f) * x_thread[0];
+
+      accum += (w[0] & 0xc0) * x_thread[1];
+      accum += (w[1] & 0x0f) * (x_thread[1] * 256.0f);
+
+      accum += (w[1] & 0xf0) * x_thread[2];
+      accum += (w[2] & 0x03) * (x_thread[2] * 256.0f);
+
+      accum += (w[2] & 0xfc) * x_thread[3];
+    }
+  }
+
+  else if (bits == 8) {
+    for (int i = 0; i < values_per_thread; i++) {
+      accum += x_thread[i] * w[i];
+    }
+  }
+
+  return scale * accum + sum * bias;
+}
+
+template <typename U, int values_per_thread, int bits>
+inline U qdot_safe(
+    const device uint8_t* w,
+    const thread U* x_thread,
+    U scale,
+    U bias,
+    U sum,
+    int N) {
+  static_assert(
+      bits == 2 || bits == 3 || bits == 4 || bits == 5 || bits == 6 ||
+          bits == 8,
+      "Template undefined for bits not in {2, 3, 4, 5, 6, 8}");
+
+  U accum = 0;
+
+  if (bits == 2) {
+    for (int i = 0; i < (N / 4); i++) {
+      accum +=
+          (x_thread[4 * i] * (w[i] & 0x03) +
+           x_thread[4 * i + 1] * (w[i] & 0x0c) +
+           x_thread[4 * i + 2] * (w[i] & 0x30) +
+           x_thread[4 * i + 3] * (w[i] & 0xc0));
+    }
+  }
+
+  else if (bits == 3) {
+    for (int i = 0; i < (N / 8); i++) {
+      x_thread += 8 * i;
+      w += 3 * i;
+
+      accum += (w[0] & 0x07) * x_thread[0];
+      accum += (w[0] & 0x38) * x_thread[1];
+      accum += (w[0] & 0xc0) * x_thread[2];
+      accum += (w[1] & 0x01) * (x_thread[2] * 256.0f);
+
+      accum += (w[1] & 0x0e) * x_thread[3];
+      accum += (w[1] & 0x70) * x_thread[4];
+      accum += (w[1] & 0x80) * x_thread[5];
+      accum += (w[2] & 0x03) * (x_thread[5] * 256.0f);
+
+      accum += (w[2] & 0x1c) * x_thread[6];
+      accum += (w[2] & 0xe0) * x_thread[7];
+    }
+  }
+
+  else if (bits == 4) {
+    const device uint16_t* ws = (const device uint16_t*)w;
+    for (int i = 0; i < (N / 4); i++) {
+      accum +=
+          (x_thread[4 * i] * (ws[i] & 0x000f) +
+           x_thread[4 * i + 1] * (ws[i] & 0x00f0) +
+           x_thread[4 * i + 2] * (ws[i] & 0x0f00) +
+           x_thread[4 * i + 3] * (ws[i] & 0xf000));
+    }
+  }
+
+  else if (bits == 5) {
+    for (int i = 0; i < (N / 8); i++) {
+      x_thread += 8 * i;
+      w += 5 * i;
+
+      accum += (w[0] & 0x1f) * x_thread[0];
+      accum += (w[0] & 0xe0) * x_thread[1];
+      accum += (w[1] & 0x3) * (x_thread[1] * 256.0f);
+      accum += (w[1] & 0x7c) * x_thread[2];
+      accum += (w[1] & 0x80) * x_thread[3];
+      accum += (w[2] & 0xf) * (x_thread[3] * 256.0f);
+      accum += (w[2] & 0xf0) * x_thread[4];
+      accum += (w[3] & 0x1) * (x_thread[4] * 256.0f);
+      accum += (w[3] & 0x3e) * x_thread[5];
+      accum += (w[3] & 0xc0) * x_thread[6];
+      accum += (w[4] & 0x7) * (x_thread[6] * 256.0f);
+      accum += (w[4] & 0xf8) * x_thread[7];
+    }
+  }
+
+  else if (bits == 6) {
+    for (int i = 0; i < (N / 4); i++) {
+      x_thread += 4 * i;
+      w += 3 * i;
+
+      accum += (w[0] & 0x3f) * x_thread[0];
+
+      accum += (w[0] & 0xc0) * x_thread[1];
+      accum += (w[1] & 0x0f) * (x_thread[1] * 256.0f);
+
+      accum += (w[1] & 0xf0) * x_thread[2];
+      accum += (w[2] & 0x03) * (x_thread[2] * 256.0f);
+
+      accum += (w[2] & 0xfc) * x_thread[3];
+    }
+  }
+
+  else if (bits == 8) {
+    for (int i = 0; i < N; i++) {
+      accum += x_thread[i] * w[i];
+    }
+  }
+
+  return scale * accum + sum * bias;
+}
+
+template <typename U, int values_per_thread, int bits>
+inline void
+qouter(const thread uint8_t* w, U x, U scale, U bias, thread U* result) {
+  static_assert(
+      bits == 2 || bits == 3 || bits == 4 || bits == 5 || bits == 6 ||
+          bits == 8,
+      "Template undefined for bits not in {2, 3, 4, 5, 6, 8}");
+
+  if (bits == 2) {
+    U s[4] = {scale, scale / 4.0f, scale / 16.0f, scale / 64.0f};
+    for (int i = 0; i < (values_per_thread / 4); i++) {
+      result[4 * i] += x * (s[0] * (w[i] & 0x03) + bias);
+      result[4 * i + 1] += x * (s[1] * (w[i] & 0x0c) + bias);
+      result[4 * i + 2] += x * (s[2] * (w[i] & 0x30) + bias);
+      result[4 * i + 3] += x * (s[3] * (w[i] & 0xc0) + bias);
+    }
+  }
+
+  else if (bits == 3) {
+    for (int i = 0; i < (values_per_thread / 8); i++) {
+      uint8_t w0 = w[3 * i];
+      uint8_t w1 = w[3 * i + 1];
+      uint8_t w2 = w[3 * i + 2];
+
+      result[8 * i] += x * ((w0 & 0x7) * scale + bias);
+      result[8 * i + 1] += x * (((w0 & 0x38) >> 3) * scale + bias);
+      result[8 * i + 2] +=
+          x * ((((w0 & 0xc0) >> 6) + ((w1 & 0x1) << 2)) * scale + bias);
+      result[8 * i + 3] += x * (((w1 & 0xe) >> 1) * scale + bias);
+      result[8 * i + 4] += x * (((w1 & 0x70) >> 4) * scale + bias);
+      result[8 * i + 5] +=
+          x * ((((w1 & 0x80) >> 7) + ((w2 & 0x3) << 1)) * scale + bias);
+      result[8 * i + 6] += x * (((w2 & 0x1c) >> 2) * scale + bias);
+      result[8 * i + 7] += x * (((w2 & 0xe0) >> 5) * scale + bias);
+    }
+  }
+
+  else if (bits == 4) {
+    U s[2] = {scale, scale / 16.0f};
+    for (int i = 0; i < (values_per_thread / 2); i++) {
+      result[2 * i] += x * (s[0] * (w[i] & 0x0f) + bias);
+      result[2 * i + 1] += x * (s[1] * (w[i] & 0xf0) + bias);
+    }
+  }
+
+  else if (bits == 5) {
+    for (int i = 0; i < (values_per_thread / 8); i++) {
+      uint8_t w0 = w[5 * i];
+      uint8_t w1 = w[5 * i + 1];
+      uint8_t w2 = w[5 * i + 2];
+      uint8_t w3 = w[5 * i + 3];
+      uint8_t w4 = w[5 * i + 4];
+      result[8 * i] += x * ((w0 & 0x1f) * scale + bias);
+      result[8 * i + 1] +=
+          x * ((((w0 & 0xe0) >> 5) + ((w1 & 0x3) << 3)) * scale + bias);
+      result[8 * i + 2] += x * (((w1 & 0x7c) >> 2) * scale + bias);
+      result[8 * i + 3] +=
+          x * ((((w1 & 0x80) >> 7) + ((w2 & 0xf) << 1)) * scale + bias);
+      result[8 * i + 4] +=
+          x * ((((w2 & 0xf0) >> 4) + ((w3 & 0x1) << 4)) * scale + bias);
+      result[8 * i + 5] += x * (((w3 & 0x3e) >> 1) * scale + bias);
+      result[8 * i + 6] +=
+          x * ((((w3 & 0xc0) >> 6) + ((w4 & 0x7) << 2)) * scale + bias);
+      result[8 * i + 7] += x * (((w4 & 0xf8) >> 3) * scale + bias);
+    }
+  }
+
+  else if (bits == 6) {
+    for (int i = 0; i < (values_per_thread / 4); i++) {
+      uint8_t w0 = w[3 * i];
+      uint8_t w1 = w[3 * i + 1];
+      uint8_t w2 = w[3 * i + 2];
+
+      result[4 * i] += x * ((w0 & 0x3f) * scale + bias);
+      result[4 * i + 1] +=
+          x * ((((w0 >> 6) & 0x03) + ((w1 & 0x0f) << 2)) * scale + bias);
+      result[4 * i + 2] +=
+          x * ((((w1 >> 4) & 0x0f) + ((w2 & 0x03) << 4)) * scale + bias);
+      result[4 * i + 3] += x * (((w2 >> 2) & 0x3f) * scale + bias);
+    }
+  }
+
+  else if (bits == 8) {
+    for (int i = 0; i < values_per_thread; i++) {
+      result[i] += x * (scale * w[i] + bias);
+    }
+  }
+}
+
+template <typename U, int N, int bits>
+inline void
+dequantize(const device uint8_t* w, U scale, U bias, threadgroup U* w_local) {
+  static_assert(
+      bits == 2 || bits == 3 || bits == 4 || bits == 5 || bits == 6 ||
+          bits == 8,
+      "Template undefined for bits not in {2, 3, 4, 5, 6, 8}");
+
+  if (bits == 2) {
+    U s[4] = {
+        scale,
+        scale / static_cast<U>(4.0f),
+        scale / static_cast<U>(16.0f),
+        scale / static_cast<U>(64.0f)};
+    for (int i = 0; i < (N / 4); i++) {
+      w_local[4 * i] = s[0] * (w[i] & 0x03) + bias;
+      w_local[4 * i + 1] = s[1] * (w[i] & 0x0c) + bias;
+      w_local[4 * i + 2] = s[2] * (w[i] & 0x30) + bias;
+      w_local[4 * i + 3] = s[3] * (w[i] & 0xc0) + bias;
+    }
+  }
+
+  else if (bits == 3) {
+    for (int i = 0; i < (N / 8); i++) {
+      w_local += 8 * i;
+      w += 3 * i;
+
+      w_local[0] = (w[0] & 0x7) * scale + bias;
+      w_local[1] = ((w[0] & 0x38) >> 3) * scale + bias;
+      w_local[2] = (((w[0] & 0xc0) >> 6) + ((w[1] & 0x1) << 2)) * scale + bias;
+      w_local[3] = ((w[1] & 0xe) >> 1) * scale + bias;
+      w_local[4] = ((w[1] & 0x70) >> 4) * scale + bias;
+      w_local[5] = (((w[1] & 0x80) >> 7) + ((w[2] & 0x3) << 1)) * scale + bias;
+      w_local[6] = ((w[2] & 0x1c) >> 2) * scale + bias;
+      w_local[7] = ((w[2] & 0xe0) >> 5) * scale + bias;
+    }
+  }
+
+  else if (bits == 4) {
+    U s[2] = {scale, scale / static_cast<U>(16.0f)};
+    for (int i = 0; i < (N / 2); i++) {
+      w_local[2 * i] = s[0] * (w[i] & 0x0f) + bias;
+      w_local[2 * i + 1] = s[1] * (w[i] & 0xf0) + bias;
+    }
+  }
+
+  else if (bits == 5) {
+    for (int i = 0; i < (N / 8); i++) {
+      w_local += 8 * i;
+      w += 5 * i;
+
+      w_local[0] = (w[0] & 0x1f) * scale + bias;
+      w_local[1] = (((w[0] & 0xe0) >> 5) + ((w[1] & 0x3) << 3)) * scale + bias;
+      w_local[2] = ((w[1] & 0x7c) >> 2) * scale + bias;
+      w_local[3] = (((w[1] & 0x80) >> 7) + ((w[2] & 0xf) << 1)) * scale + bias;
+      w_local[4] = (((w[2] & 0xf0) >> 4) + ((w[3] & 0x1) << 4)) * scale + bias;
+      w_local[5] = ((w[3] & 0x3e) >> 1) * scale + bias;
+      w_local[6] = (((w[3] & 0xc0) >> 6) + ((w[4] & 0x7) << 2)) * scale + bias;
+      w_local[7] = ((w[4] & 0xf8) >> 3) * scale + bias;
+    }
+  }
+
+  else if (bits == 6) {
+    for (int i = 0; i < (N / 4); i++) {
+      w_local += 4 * i;
+      w += 3 * i;
+      w_local[0] = (w[0] & 0x3f) * scale + bias;
+      w_local[1] = (((w[0] >> 6) & 0x03) + ((w[1] & 0x0f) << 2)) * scale + bias;
+      w_local[2] = (((w[1] >> 4) & 0x0f) + ((w[2] & 0x03) << 4)) * scale + bias;
+      w_local[3] = ((w[2] >> 2) & 0x3f) * scale + bias;
+    }
+  }
+
+  else if (bits == 8) {
+    for (int i = 0; i < N; i++) {
+      w_local[i] = scale * w[i] + bias;
+    }
+  }
+}
+
+template <
+    typename T,
+    short BROWS,
+    short BCOLS,
+    short dst_ld,
+    short reduction_dim,
+    short tgp_size,
+    short group_size,
+    short bits>
+struct QuantizedBlockLoader {
+  static_assert(
+      BCOLS <= group_size,
+      "The group size should be larger than the columns");
+  static_assert(
+      group_size % BCOLS == 0,
+      "The group size should be divisible by the columns");
+  static_assert(
+      bits == 2 || bits == 3 || bits == 4 || bits == 5 || bits == 6 ||
+          bits == 8,
+      "Template undefined for bits not in {2, 3, 4, 5, 6, 8}");
+
+  MLX_MTL_CONST short pack_factor = get_pack_factor<bits, 8>();
+  MLX_MTL_CONST short bytes_per_pack = get_bytes_per_pack<bits>();
+  MLX_MTL_CONST short BCOLS_PACKED = BCOLS / pack_factor;
+  MLX_MTL_CONST short n_reads =
+      (BCOLS_PACKED * BROWS < tgp_size) ? 1 : (BCOLS_PACKED * BROWS) / tgp_size;
+  MLX_MTL_CONST short group_steps = group_size / BCOLS;
+
+  const int src_ld;
+  const int tile_stride;
+  short group_step_cnt;
+  const int group_stride;
+
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  threadgroup T* dst;
+  const device uint8_t* src;
+  const device T* scales;
+  const device T* biases;
+
+  QuantizedBlockLoader(
+      const device uint8_t* src_,
+      const device T* scales_,
+      const device T* biases_,
+      const int src_ld_,
+      threadgroup T* dst_,
+      ushort simd_group_id [[simdgroup_index_in_threadgroup]],
+      ushort simd_lane_id [[thread_index_in_simdgroup]])
+      : src_ld(src_ld_),
+        tile_stride(
+            reduction_dim ? BCOLS_PACKED * bytes_per_pack
+                          : BROWS * src_ld * bytes_per_pack / pack_factor),
+        group_step_cnt(0),
+        group_stride(BROWS * src_ld / group_size),
+        thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(n_reads * thread_idx / BCOLS_PACKED),
+        bj((n_reads * thread_idx) % BCOLS_PACKED),
+        dst(dst_ + bi * dst_ld + bj * pack_factor),
+        src(src_ + bi * src_ld * bytes_per_pack / pack_factor +
+            bj * bytes_per_pack),
+        scales(scales_ + bi * src_ld / group_size),
+        biases(biases_ + bi * src_ld / group_size) {}
+
+  void load_unsafe() const {
+    if (BCOLS_PACKED * BROWS < tgp_size && bi >= BROWS) {
+      return;
+    }
+
+    T scale = *scales;
+    T bias = *biases;
+    for (int i = 0; i < n_reads; i++) {
+      dequantize<T, pack_factor, bits>(
+          src + i * bytes_per_pack, scale, bias, dst + i * pack_factor);
+    }
+  }
+
+  void load_safe(short2 src_tile_dim) const {
+    if (BCOLS_PACKED * BROWS < tgp_size && bi >= BROWS) {
+      return;
+    }
+
+    if (reduction_dim == 1 && bi >= src_tile_dim.x) {
+      for (int i = 0; i < n_reads * pack_factor; i++) {
+        dst[i] = T(0);
+      }
+      return;
+    }
+
+    if (reduction_dim == 0 && bi >= src_tile_dim.y) {
+      for (int i = 0; i < n_reads * pack_factor; i++) {
+        dst[i] = T(0);
+      }
+      return;
+    }
+
+    T scale = *scales;
+    T bias = *biases;
+    for (int i = 0; i < n_reads; i++) {
+      dequantize<T, pack_factor, bits>(
+          (device uint8_t*)(src + i * bytes_per_pack),
+          scale,
+          bias,
+          dst + i * pack_factor);
+    }
+  }
+
+  void next() {
+    src += tile_stride;
+    if (reduction_dim == 1) {
+      if (group_steps > 1) {
+        group_step_cnt++;
+        if (group_step_cnt == group_steps) {
+          group_step_cnt = 0;
+          scales++;
+          biases++;
+        }
+      } else {
+        scales++;
+        biases++;
+      }
+    } else {
+      scales += group_stride;
+      biases += group_stride;
+    }
+  }
+};
+
+template <typename T, int group_size, int bits, int D>
+METAL_FUNC void qmv_quad_impl(
+    const device uint32_t* w,
+    const device T* scales,
+    const device T* biases,
+    const device T* x,
+    device T* y,
+    constant int& in_vec_size,
+    const constant int& out_vec_size,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint quad_gid [[quadgroup_index_in_threadgroup]],
+    uint quad_lid [[thread_index_in_quadgroup]]) {
+  constexpr int quads_per_simd = SIMD_SIZE / QUAD_SIZE;
+  constexpr int pack_factor = 32 / bits;
+  constexpr int values_per_thread = D / QUAD_SIZE;
+  constexpr int packs_per_thread = values_per_thread / pack_factor;
+  constexpr int scale_step_per_thread = group_size / values_per_thread;
+  constexpr int results_per_quadgroup = 8;
+
+  typedef float U;
+
+  thread U x_thread[values_per_thread];
+  thread U result[results_per_quadgroup] = {0};
+
+  // Adjust positions
+  const int in_vec_size_w = in_vec_size / pack_factor;
+  const int in_vec_size_g = in_vec_size / group_size;
+  const int out_row = tid.y * quads_per_simd * results_per_quadgroup + quad_gid;
+
+  w += out_row * in_vec_size_w + quad_lid * packs_per_thread;
+  scales += out_row * in_vec_size_g + quad_lid / scale_step_per_thread;
+  biases += out_row * in_vec_size_g + quad_lid / scale_step_per_thread;
+  x += tid.x * in_vec_size + quad_lid * values_per_thread;
+  y += tid.x * out_vec_size + out_row;
+
+  U sum = load_vector<T, U, values_per_thread, bits>(x, x_thread);
+
+  for (int row = 0; row < results_per_quadgroup; row++) {
+    auto wl = (const device uint8_t*)(w + row * in_vec_size_w * quads_per_simd);
+    const device T* sl = scales + row * in_vec_size_g * quads_per_simd;
+    const device T* bl = biases + row * in_vec_size_g * quads_per_simd;
+
+    U s = sl[0];
+    U b = bl[0];
+    if (row * quads_per_simd + out_row < out_vec_size) {
+      result[row] += qdot<U, values_per_thread, bits>(wl, x_thread, s, b, sum);
+    }
+  }
+
+  for (int row = 0; row < results_per_quadgroup; row++) {
+    result[row] = quad_sum(result[row]);
+    if (quad_lid == 0 && row * quads_per_simd + out_row < out_vec_size) {
+      y[row * quads_per_simd] = static_cast<T>(result[row]);
+    }
+  }
+}
+
+template <typename T, int group_size, int bits>
+METAL_FUNC void qmv_fast_impl(
+    const device uint32_t* w,
+    const device T* scales,
+    const device T* biases,
+    const device T* x,
+    device T* y,
+    const constant int& in_vec_size,
+    const constant int& out_vec_size,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  constexpr int packs_per_thread = bits == 2 ? 1 : 2;
+  constexpr int num_simdgroups = 2;
+  constexpr int results_per_simdgroup = 4;
+  constexpr int pack_factor = get_pack_factor<bits, 32>();
+  constexpr int bytes_per_pack = get_bytes_per_pack<bits, 32>();
+  constexpr int values_per_thread = pack_factor * packs_per_thread;
+  constexpr int block_size = values_per_thread * SIMD_SIZE;
+  constexpr int scale_step_per_thread = group_size / values_per_thread;
+
+  const device uint8_t* ws = (const device uint8_t*)w;
+
+  typedef float U;
+
+  thread U x_thread[values_per_thread];
+  thread U result[results_per_simdgroup] = {0};
+
+  // Adjust positions
+  const int in_vec_size_w = in_vec_size * bytes_per_pack / pack_factor;
+  const int in_vec_size_g = in_vec_size / group_size;
+  const int out_row = tid.y * (num_simdgroups * results_per_simdgroup) +
+      simd_gid * results_per_simdgroup;
+
+  ws += out_row * in_vec_size_w + simd_lid * packs_per_thread * bytes_per_pack;
+  scales += out_row * in_vec_size_g + simd_lid / scale_step_per_thread;
+  biases += out_row * in_vec_size_g + simd_lid / scale_step_per_thread;
+  x += tid.x * in_vec_size + simd_lid * values_per_thread;
+  y += tid.x * out_vec_size + out_row;
+
+  for (int k = 0; k < in_vec_size; k += block_size) {
+    U sum = load_vector<T, U, values_per_thread, bits>(x, x_thread);
+
+    for (int row = 0; row < results_per_simdgroup; row++) {
+      auto wl = (const device uint8_t*)(ws + row * in_vec_size_w);
+      const device T* sl = scales + row * in_vec_size_g;
+      const device T* bl = biases + row * in_vec_size_g;
+
+      U s = sl[0];
+      U b = bl[0];
+      result[row] += qdot<U, values_per_thread, bits>(wl, x_thread, s, b, sum);
+    }
+
+    ws += block_size * bytes_per_pack / pack_factor;
+    scales += block_size / group_size;
+    biases += block_size / group_size;
+    x += block_size;
+  }
+
+  for (int row = 0; row < results_per_simdgroup; row++) {
+    result[row] = simd_sum(result[row]);
+    if (simd_lid == 0) {
+      y[row] = static_cast<T>(result[row]);
+    }
+  }
+}
+
+template <typename T, int group_size, int bits>
+METAL_FUNC void qmv_impl(
+    const device uint32_t* w,
+    const device T* scales,
+    const device T* biases,
+    const device T* x,
+    device T* y,
+    const constant int& in_vec_size,
+    const constant int& out_vec_size,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  constexpr int num_simdgroups = 2;
+  constexpr int results_per_simdgroup = 4;
+  constexpr int packs_per_thread = 1;
+  constexpr int pack_factor = get_pack_factor<bits, 32>();
+  constexpr int bytes_per_pack = get_bytes_per_pack<bits, 32>();
+
+  constexpr int values_per_thread = pack_factor * packs_per_thread;
+  constexpr int block_size = values_per_thread * SIMD_SIZE;
+  constexpr int scale_step_per_thread = group_size / values_per_thread;
+
+  const device uint8_t* ws = (const device uint8_t*)w;
+
+  typedef float U;
+
+  thread U x_thread[values_per_thread];
+  thread U result[results_per_simdgroup] = {0};
+
+  // Adjust positions
+  const int in_vec_size_w = in_vec_size * bytes_per_pack / pack_factor;
+  const int in_vec_size_g = in_vec_size / group_size;
+  const int out_row = tid.y * (num_simdgroups * results_per_simdgroup) +
+      simd_gid * results_per_simdgroup;
+  const int used_out_row = min(out_vec_size - results_per_simdgroup, out_row);
+
+  if (out_row >= out_vec_size) {
+    return;
+  }
+
+  // In this case we need to properly guard all our reads because there isn't
+  // even 1 tile in the matrix
+  if (out_vec_size < (num_simdgroups * results_per_simdgroup)) {
+    ws +=
+        out_row * in_vec_size_w + simd_lid * packs_per_thread * bytes_per_pack;
+    scales += out_row * in_vec_size_g + simd_lid / scale_step_per_thread;
+    biases += out_row * in_vec_size_g + simd_lid / scale_step_per_thread;
+    x += tid.x * in_vec_size + simd_lid * values_per_thread;
+    y += tid.x * out_vec_size + out_row;
+
+    int k = 0;
+    for (; k < in_vec_size - block_size; k += block_size) {
+      U sum = load_vector<T, U, values_per_thread, bits>(x, x_thread);
+
+      for (int row = 0; out_row + row < out_vec_size; row++) {
+        auto wl = (const device uint8_t*)(ws + row * in_vec_size_w);
+        const device T* sl = scales + row * in_vec_size_g;
+        const device T* bl = biases + row * in_vec_size_g;
+
+        U s = sl[0];
+        U b = bl[0];
+        result[row] +=
+            qdot<U, values_per_thread, bits>(wl, x_thread, s, b, sum);
+      }
+
+      ws += block_size * bytes_per_pack / pack_factor;
+      scales += block_size / group_size;
+      biases += block_size / group_size;
+      x += block_size;
+    }
+    const int remaining = clamp(
+        static_cast<int>(in_vec_size - k - simd_lid * values_per_thread),
+        0,
+        values_per_thread);
+    if (remaining > 0) {
+      U sum = load_vector_safe<T, U, values_per_thread, bits>(
+          x, x_thread, remaining);
+
+      for (int row = 0; out_row + row < out_vec_size; row++) {
+        auto wl = (const device uint8_t*)(ws + row * in_vec_size_w);
+        const device T* sl = scales + row * in_vec_size_g;
+        const device T* bl = biases + row * in_vec_size_g;
+
+        U s = sl[0];
+        U b = bl[0];
+        result[row] +=
+            qdot<U, values_per_thread, bits>(wl, x_thread, s, b, sum);
+      }
+    }
+
+    for (int row = 0; out_row + row < out_vec_size; row++) {
+      result[row] = simd_sum(result[row]);
+      if (simd_lid == 0) {
+        y[row] = static_cast<T>(result[row]);
+      }
+    }
+  }
+
+  // In this case the last tile is moved back to redo some output values
+  else {
+    ws += used_out_row * in_vec_size_w +
+        simd_lid * packs_per_thread * bytes_per_pack;
+    scales += used_out_row * in_vec_size_g + simd_lid / scale_step_per_thread;
+    biases += used_out_row * in_vec_size_g + simd_lid / scale_step_per_thread;
+    x += tid.x * in_vec_size + simd_lid * values_per_thread;
+    y += tid.x * out_vec_size + used_out_row;
+
+    int k = 0;
+    for (; k < in_vec_size - block_size; k += block_size) {
+      U sum = load_vector<T, U, values_per_thread, bits>(x, x_thread);
+
+      for (int row = 0; row < results_per_simdgroup; row++) {
+        auto wl = (const device uint8_t*)(ws + row * in_vec_size_w);
+        const device T* sl = scales + row * in_vec_size_g;
+        const device T* bl = biases + row * in_vec_size_g;
+
+        U s = sl[0];
+        U b = bl[0];
+        result[row] +=
+            qdot<U, values_per_thread, bits>(wl, x_thread, s, b, sum);
+      }
+
+      ws += block_size * bytes_per_pack / pack_factor;
+      scales += block_size / group_size;
+      biases += block_size / group_size;
+      x += block_size;
+    }
+    const int remaining = clamp(
+        static_cast<int>(in_vec_size - k - simd_lid * values_per_thread),
+        0,
+        values_per_thread);
+    if (remaining > 0) {
+      U sum = load_vector_safe<T, U, values_per_thread, bits>(
+          x, x_thread, remaining);
+
+      for (int row = 0; row < results_per_simdgroup; row++) {
+        auto wl = (const device uint8_t*)(ws + row * in_vec_size_w);
+        const device T* sl = scales + row * in_vec_size_g;
+        const device T* bl = biases + row * in_vec_size_g;
+
+        U s = sl[0];
+        U b = bl[0];
+        result[row] += qdot_safe<U, values_per_thread, bits>(
+            wl, x_thread, s, b, sum, remaining);
+      }
+    }
+    for (int row = 0; row < results_per_simdgroup; row++) {
+      result[row] = simd_sum(result[row]);
+      if (simd_lid == 0) {
+        y[row] = static_cast<T>(result[row]);
+      }
+    }
+  }
+}
+
+template <typename T, const int group_size, const int bits>
+METAL_FUNC void qvm_impl(
+    const device uint32_t* w,
+    const device T* scales,
+    const device T* biases,
+    const device T* x,
+    device T* y,
+    const int in_vec_size,
+    const int out_vec_size,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  constexpr int power_of_2_bits = (bits & (bits - 1)) == 0;
+  constexpr int num_simdgroups = 2;
+  constexpr int pack_factor = get_pack_factor<bits, 32>();
+  constexpr int bytes_per_pack = get_bytes_per_pack<bits>();
+
+  constexpr int tn = 32 / pack_factor;
+  constexpr int block_size = SIMD_SIZE;
+
+  using W_T =
+      typename ConditionalType<power_of_2_bits, uint32_t, uint8_t>::type;
+  const device W_T* ws = (const device W_T*)w;
+
+  typedef float U;
+  typedef struct {
+    W_T wi[tn * bytes_per_pack];
+  } vec_w;
+
+  thread vec_w w_local;
+  thread U result[tn * pack_factor] = {0};
+  thread U scale = 1;
+  thread U bias = 0;
+  thread U x_local = 0;
+
+  // Adjust positions
+  const int out_vec_size_w = out_vec_size * bytes_per_pack / pack_factor;
+  const int out_vec_size_g = out_vec_size / group_size;
+  int out_col = pack_factor * tn * (tid.y * num_simdgroups + simd_gid);
+  ws += out_col * bytes_per_pack / pack_factor + simd_lid * out_vec_size_w;
+  scales += out_col / group_size + simd_lid * out_vec_size_g;
+  biases += out_col / group_size + simd_lid * out_vec_size_g;
+  x += tid.x * in_vec_size + simd_lid;
+  y += tid.x * out_vec_size + out_col;
+
+  if (out_col >= out_vec_size) {
+    return;
+  }
+
+  // Loop over in_vec in blocks of block_size
+  int remaining = in_vec_size % block_size;
+  if (remaining == 0) {
+    for (int i = 0; i < in_vec_size; i += block_size) {
+      x_local = *x;
+      scale = *scales;
+      bias = *biases;
+      w_local = *((device vec_w*)ws);
+      qouter<U, tn * pack_factor, bits>(
+          (thread uint8_t*)&w_local, x_local, scale, bias, result);
+
+      x += block_size;
+      scales += block_size * out_vec_size_g;
+      biases += block_size * out_vec_size_g;
+      ws += block_size * out_vec_size_w;
+    }
+  } else {
+    for (int i = block_size; i < in_vec_size; i += block_size) {
+      x_local = *x;
+      scale = *scales;
+      bias = *biases;
+      w_local = *((device vec_w*)ws);
+
+      qouter<U, tn * pack_factor, bits>(
+          (thread uint8_t*)&w_local, x_local, scale, bias, result);
+
+      x += block_size;
+      scales += block_size * out_vec_size_g;
+      biases += block_size * out_vec_size_g;
+      ws += block_size * out_vec_size_w;
+    }
+    if (static_cast<int>(simd_lid) < remaining) {
+      x_local = *x;
+      scale = *scales;
+      bias = *biases;
+      w_local = *((device vec_w*)ws);
+    } else {
+      x_local = 0;
+      scale = 0;
+      bias = 0;
+    }
+    qouter<U, tn * pack_factor, bits>(
+        (thread uint8_t*)&w_local, x_local, scale, bias, result);
+  }
+
+// Accumulate in the simdgroup
+#pragma clang loop unroll(full)
+  for (int k = 0; k < tn * pack_factor; k++) {
+    result[k] = simd_sum(result[k]);
+  }
+
+  // Store the result
+  if (simd_lid == 0) {
+#pragma clang loop unroll(full)
+    for (int k = 0; k < tn * pack_factor; k++) {
+      y[k] = static_cast<T>(result[k]);
+    }
+  }
+}
+
+template <
+    typename T,
+    const int group_size,
+    const int bits,
+    const bool aligned_N,
+    const int BM = 32,
+    const int BK = 32,
+    const int BN = 32>
+METAL_FUNC void qmm_t_impl(
+    const device uint32_t* w,
+    const device T* scales,
+    const device T* biases,
+    const device T* x,
+    device T* y,
+    threadgroup T* Xs,
+    threadgroup T* Ws,
+    const constant int& K,
+    const constant int& N,
+    const constant int& M,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint lid [[thread_index_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  static_assert(BK >= SIMD_SIZE, "BK should be larger than SIMD_SIZE");
+  static_assert(BK % SIMD_SIZE == 0, "BK should be divisible by SIMD_SIZE");
+
+  (void)lid;
+
+  constexpr int WM = 2;
+  constexpr int WN = 2;
+  constexpr int pack_factor = get_pack_factor<bits, 8>();
+  constexpr int bytes_per_pack = get_bytes_per_pack<bits>();
+
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+
+  // Instantiate the appropriate BlockMMA and Loader
+  using mma_t = mlx::steel::
+      BlockMMA<T, T, BM, BN, BK, WM, WN, false, true, BK_padded, BK_padded>;
+  using loader_x_t =
+      mlx::steel::BlockLoader<T, BM, BK, BK_padded, 1, WM * WN * SIMD_SIZE>;
+  using loader_w_t = QuantizedBlockLoader<
+      T,
+      BN,
+      BK,
+      BK_padded,
+      1,
+      WM * WN * SIMD_SIZE,
+      group_size,
+      bits>;
+
+  // Set the block
+  const int K_w = K * bytes_per_pack / pack_factor;
+  const int K_g = K / group_size;
+  const int y_row = tid.y * BM;
+  const int y_col = tid.x * BN;
+
+  auto wl = (const device uint8_t*)w;
+
+  x += y_row * static_cast<int64_t>(K);
+  wl += y_col * K_w;
+  scales += y_col * K_g;
+  biases += y_col * K_g;
+  y += y_row * static_cast<int64_t>(N) + y_col;
+
+  // Make the x loader and mma operation
+  const short num_els = min(BM, M - y_row);
+  const short num_outs = min(BN, N - y_col);
+  loader_x_t loader_x(x, K, Xs, simd_gid, simd_lid);
+  loader_w_t loader_w(wl, scales, biases, K, Ws, simd_gid, simd_lid);
+  mma_t mma_op(simd_gid, simd_lid);
+
+  if (num_els < BM) {
+    if (!aligned_N && num_outs < BN) {
+      for (int k = 0; k < K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_safe(short2(BK, num_els));
+        loader_w.load_safe(short2(BK, num_outs));
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+    } else {
+      for (int k = 0; k < K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_safe(short2(BK, num_els));
+        loader_w.load_unsafe();
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+    }
+  } else {
+    if (!aligned_N && num_outs < BN) {
+      for (int k = 0; k < K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_unsafe();
+        loader_w.load_safe(short2(BK, num_outs));
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+    } else {
+      for (int k = 0; k < K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_unsafe();
+        loader_w.load_unsafe();
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+    }
+  }
+
+  // Store results to device memory
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (num_els < BM || num_outs < BN) {
+    mma_op.store_result_safe(y, N, short2(num_outs, num_els));
+  } else {
+    mma_op.store_result(y, N);
+  }
+}
+
+template <
+    typename T,
+    const int group_size,
+    const int bits,
+    const int BM = 32,
+    const int BK = 32,
+    const int BN = 32>
+METAL_FUNC void qmm_n_impl(
+    const device uint32_t* w,
+    const device T* scales,
+    const device T* biases,
+    const device T* x,
+    device T* y,
+    threadgroup T* Xs,
+    threadgroup T* Ws,
+    const constant int& K,
+    const constant int& N,
+    const constant int& M,
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint lid [[thread_index_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  static_assert(BK >= SIMD_SIZE, "BK should be larger than SIMD_SIZE");
+  static_assert(BK % SIMD_SIZE == 0, "BK should be divisible by SIMD_SIZE");
+
+  (void)lid;
+
+  constexpr int WM = 2;
+  constexpr int WN = 2;
+  constexpr int pack_factor = get_pack_factor<bits, 8>();
+  constexpr int bytes_per_pack = get_bytes_per_pack<bits>();
+
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+  constexpr int BN_padded = (BN + 16 / sizeof(T));
+
+  // Instantiate the appropriate BlockMMA and Loader
+  using mma_t = mlx::steel::
+      BlockMMA<T, T, BM, BN, BK, WM, WN, false, false, BK_padded, BN_padded>;
+  using loader_x_t = mlx::steel::
+      BlockLoader<T, BM, BK, BK_padded, 1, WM * WN * SIMD_SIZE, 1, 4>;
+  using loader_w_t = QuantizedBlockLoader<
+      T,
+      BK,
+      BN,
+      BN_padded,
+      0,
+      WM * WN * SIMD_SIZE,
+      group_size,
+      bits>;
+
+  auto wl = (const device uint8_t*)w;
+
+  // Set the block
+  const int y_row = tid.y * BM;
+  const int y_col = tid.x * BN;
+  x += y_row * static_cast<int64_t>(K);
+  wl += y_col * bytes_per_pack / pack_factor;
+  scales += y_col / group_size;
+  biases += y_col / group_size;
+  y += y_row * static_cast<int64_t>(N) + y_col;
+
+  // Make the x loader and mma operation
+  const short num_els = min(BM, M - y_row);
+  loader_x_t loader_x(x, K, Xs, simd_gid, simd_lid);
+  loader_w_t loader_w(wl, scales, biases, N, Ws, simd_gid, simd_lid);
+  mma_t mma_op(simd_gid, simd_lid);
+
+  if (num_els < BM) {
+    if ((K % BK) != 0) {
+      const int k_blocks = K / BK;
+      for (int k = 0; k < k_blocks; k++) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_safe(short2(BK, num_els));
+        loader_w.load_unsafe();
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+      const short num_k = K - k_blocks * BK;
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      loader_x.load_safe(short2(num_k, num_els));
+      loader_w.load_safe(short2(BN, num_k));
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      mma_op.mma(Xs, Ws);
+    } else {
+      for (int k = 0; k < K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_safe(short2(BK, num_els));
+        loader_w.load_unsafe();
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+    }
+  } else {
+    if ((K % BK) != 0) {
+      const int k_blocks = K / BK;
+      for (int k = 0; k < k_blocks; k++) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_unsafe();
+        loader_w.load_unsafe();
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+      const short num_k = K - k_blocks * BK;
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      loader_x.load_safe(short2(num_k, BM));
+      loader_w.load_safe(short2(BN, num_k));
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      mma_op.mma(Xs, Ws);
+    } else {
+      for (int k = 0; k < K; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_x.load_unsafe();
+        loader_w.load_unsafe();
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(Xs, Ws);
+        loader_x.next();
+        loader_w.next();
+      }
+    }
+  }
+
+  // Store results to device memory
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (num_els < BM) {
+    mma_op.store_result_safe(y, N, short2(BN, num_els));
+  } else {
+    mma_op.store_result(y, N);
+  }
+}
+
+template <typename T>
+METAL_FUNC void adjust_matrix_offsets(
+    const device T*& x,
+    const device uint32_t*& w,
+    const device T*& scales,
+    const device T*& biases,
+    device T*& y,
+    int output_stride,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    const constant int64_t* b_strides,
+    uint3 tid [[threadgroup_position_in_grid]]) {
+  // Set the input/output matrices
+  uint32_t x_idx = tid.z;
+  uint32_t w_idx = tid.z;
+  if (x_batch_ndims == 1) {
+    x += x_idx * x_strides[0];
+  } else {
+    x += elem_to_loc(x_idx, x_shape, x_strides, x_batch_ndims);
+  }
+  if (w_batch_ndims == 1) {
+    w += w_idx * w_strides[0];
+    scales += w_idx * s_strides[0];
+    biases += w_idx * b_strides[0];
+  } else {
+    ulong3 idx = elem_to_loc_broadcast(
+        w_idx, w_shape, w_strides, s_strides, b_strides, w_batch_ndims);
+    w += idx.x;
+    scales += idx.y;
+    biases += idx.z;
+  }
+  y += tid.z * output_stride;
+}
+
+template <typename T>
+METAL_FUNC void adjust_matrix_offsets(
+    const device T*& x,
+    const device uint32_t*& w,
+    const device T*& scales,
+    const device T*& biases,
+    const device uint32_t* lhs_indices,
+    const device uint32_t* rhs_indices,
+    device T*& y,
+    int output_stride,
+    const constant int& batch_ndims,
+    const constant int* batch_shape,
+    const constant int64_t* lhs_strides,
+    const constant int64_t* rhs_strides,
+    const constant int& x_batch_ndims,
+    const constant int* x_shape,
+    const constant int64_t* x_strides,
+    const constant int& w_batch_ndims,
+    const constant int* w_shape,
+    const constant int64_t* w_strides,
+    const constant int64_t* s_strides,
+    const constant int64_t* b_strides,
+    uint3 tid [[threadgroup_position_in_grid]]) {
+  // Set the input/output matrices
+  uint32_t x_idx;
+  uint32_t w_idx;
+  if (batch_ndims == 1) {
+    x_idx = lhs_indices[tid.z * lhs_strides[0]];
+    w_idx = rhs_indices[tid.z * rhs_strides[0]];
+  } else {
+    ulong2 idx = elem_to_loc_broadcast(
+        tid.z, batch_shape, lhs_strides, rhs_strides, batch_ndims);
+    x_idx = lhs_indices[idx.x];
+    w_idx = rhs_indices[idx.y];
+  }
+  if (x_batch_ndims == 1) {
+    x += x_idx * x_strides[0];
+  } else {
+    x += elem_to_loc(x_idx, x_shape, x_strides, x_batch_ndims);
+  }
+  if (w_batch_ndims == 1) {
+    w += w_idx * w_strides[0];
+    scales += w_idx * s_strides[0];
+    biases += w_idx * b_strides[0];
+  } else {
+    ulong3 idx = elem_to_loc_broadcast(
+        w_idx, w_shape, w_strides, s_strides, b_strides, w_batch_ndims);
+    w += idx.x;
+    scales += idx.y;
+    biases += idx.z;
+  }
+  y += tid.z * output_stride;
+}
+
+template <typename T, int group_size, int bits, int D, bool batched>
+[[kernel]] void affine_qmv_quad(
+    const device uint32_t* w [[buffer(0)]],
+    const device T* scales [[buffer(1)]],
+    const device T* biases [[buffer(2)]],
+    const device T* x [[buffer(3)]],
+    device T* y [[buffer(4)]],
+    const constant int& in_vec_size [[buffer(5)]],
+    const constant int& out_vec_size [[buffer(6)]],
+    const constant int& x_batch_ndims [[buffer(7)]],
+    const constant int* x_shape [[buffer(8)]],
+    const constant int64_t* x_strides [[buffer(9)]],
+    const constant int& w_batch_ndims [[buffer(10)]],
+    const constant int* w_shape [[buffer(11)]],
+    const constant int64_t* w_strides [[buffer(12)]],
+    const constant int64_t* s_strides [[buffer(13)]],
+    const constant int64_t* b_strides [[buffer(14)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint quad_gid [[quadgroup_index_in_threadgroup]],
+    uint quad_lid [[thread_index_in_quadgroup]]) {
+  if (batched) {
+    int M = x_shape[x_batch_ndims];
+    adjust_matrix_offsets<T>(
+        x,
+        w,
+        scales,
+        biases,
+        y,
+        out_vec_size * M,
+        x_batch_ndims,
+        x_shape,
+        x_strides,
+        w_batch_ndims,
+        w_shape,
+        w_strides,
+        s_strides,
+        b_strides,
+        tid);
+  }
+  qmv_quad_impl<T, group_size, bits, D>(
+      w,
+      scales,
+      biases,
+      x,
+      y,
+      in_vec_size,
+      out_vec_size,
+      tid,
+      quad_gid,
+      quad_lid);
+}
+
+template <typename T, int group_size, int bits, bool batched>
+[[kernel]] void affine_qmv_fast(
+    const device uint32_t* w [[buffer(0)]],
+    const device T* scales [[buffer(1)]],
+    const device T* biases [[buffer(2)]],
+    const device T* x [[buffer(3)]],
+    device T* y [[buffer(4)]],
+    const constant int& in_vec_size [[buffer(5)]],
+    const constant int& out_vec_size [[buffer(6)]],
+    const constant int& x_batch_ndims [[buffer(7)]],
+    const constant int* x_shape [[buffer(8)]],
+    const constant int64_t* x_strides [[buffer(9)]],
+    const constant int& w_batch_ndims [[buffer(10)]],
+    const constant int* w_shape [[buffer(11)]],
+    const constant int64_t* w_strides [[buffer(12)]],
+    const constant int64_t* s_strides [[buffer(13)]],
+    const constant int64_t* b_strides [[buffer(14)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  if (batched) {
+    int M = x_shape[x_batch_ndims];
+    adjust_matrix_offsets<T>(
+        x,
+        w,
+        scales,
+        biases,
+        y,
+        out_vec_size * M,
+        x_batch_ndims,
+        x_shape,
+        x_strides,
+        w_batch_ndims,
+        w_shape,
+        w_strides,
+        s_strides,
+        b_strides,
+        tid);
+  }
+  qmv_fast_impl<T, group_size, bits>(
+      w,
+      scales,
+      biases,
+      x,
+      y,
+      in_vec_size,
+      out_vec_size,
+      tid,
+      simd_gid,
+      simd_lid);
+}
+
+template <typename T, const int group_size, const int bits, bool batched>
+[[kernel]] void affine_qmv(
+    const device uint32_t* w [[buffer(0)]],
+    const device T* scales [[buffer(1)]],
+    const device T* biases [[buffer(2)]],
+    const device T* x [[buffer(3)]],
+    device T* y [[buffer(4)]],
+    const constant int& in_vec_size [[buffer(5)]],
+    const constant int& out_vec_size [[buffer(6)]],
+    const constant int& x_batch_ndims [[buffer(7)]],
+    const constant int* x_shape [[buffer(8)]],
+    const constant int64_t* x_strides [[buffer(9)]],
+    const constant int& w_batch_ndims [[buffer(10)]],
+    const constant int* w_shape [[buffer(11)]],
+    const constant int64_t* w_strides [[buffer(12)]],
+    const constant int64_t* s_strides [[buffer(13)]],
+    const constant int64_t* b_strides [[buffer(14)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  if (batched) {
+    int M = x_shape[x_batch_ndims];
+    adjust_matrix_offsets<T>(
+        x,
+        w,
+        scales,
+        biases,
+        y,
+        out_vec_size * M,
+        x_batch_ndims,
+        x_shape,
+        x_strides,
+        w_batch_ndims,
+        w_shape,
+        w_strides,
+        s_strides,
+        b_strides,
+        tid);
+  }
+  qmv_impl<T, group_size, bits>(
+      w,
+      scales,
+      biases,
+      x,
+      y,
+      in_vec_size,
+      out_vec_size,
+      tid,
+      simd_gid,
+      simd_lid);
+}
+
+template <typename T, const int group_size, const int bits, bool batched>
+[[kernel]] void affine_qvm(
+    const device uint32_t* w [[buffer(0)]],
+    const device T* scales [[buffer(1)]],
+    const device T* biases [[buffer(2)]],
+    const device T* x [[buffer(3)]],
+    device T* y [[buffer(4)]],
+    const constant int& in_vec_size [[buffer(5)]],
+    const constant int& out_vec_size [[buffer(6)]],
+    const constant int& x_batch_ndims [[buffer(7)]],
+    const constant int* x_shape [[buffer(8)]],
+    const constant int64_t* x_strides [[buffer(9)]],
+    const constant int& w_batch_ndims [[buffer(10)]],
+    const constant int* w_shape [[buffer(11)]],
+    const constant int64_t* w_strides [[buffer(12)]],
+    const constant int64_t* s_strides [[buffer(13)]],
+    const constant int64_t* b_strides [[buffer(14)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  if (batched) {
+    int M = x_shape[x_batch_ndims];
+    adjust_matrix_offsets<T>(
+        x,
+        w,
+        scales,
+        biases,
+        y,
+        out_vec_size * M,
+        x_batch_ndims,
+        x_shape,
+        x_strides,
+        w_batch_ndims,
+        w_shape,
+        w_strides,
+        s_strides,
+        b_strides,
+        tid);
+  }
+  qvm_impl<T, group_size, bits>(
+      w,
+      scales,
+      biases,
+      x,
+      y,
+      in_vec_size,
+      out_vec_size,
+      tid,
+      simd_gid,
+      simd_lid);
+}
+
+template <typename T, const int group_size, const int bits, int split_k = 32>
+[[kernel]] void affine_qvm_split_k(
+    const device uint32_t* w [[buffer(0)]],
+    const device T* scales [[buffer(1)]],
+    const device T* biases [[buffer(2)]],
+    const device T* x [[buffer(3)]],
+    device T* y [[buffer(4)]],
+    const constant int& in_vec_size [[buffer(5)]],
+    const constant int& out_vec_size [[buffer(6)]],
+    const constant int& x_batch_ndims [[buffer(7)]],
+    const constant int* x_shape [[buffer(8)]],
+    const constant int64_t* x_strides [[buffer(9)]],
+    const constant int& w_batch_ndims [[buffer(10)]],
+    const constant int* w_shape [[buffer(11)]],
+    const constant int64_t* w_strides [[buffer(12)]],
+    const constant int64_t* s_strides [[buffer(13)]],
+    const constant int64_t* b_strides [[buffer(14)]],
+    const constant int& final_block_size [[buffer(15)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  int M = x_shape[x_batch_ndims];
+  adjust_matrix_offsets<T>(
+      x,
+      w,
+      scales,
+      biases,
+      y,
+      out_vec_size * M,
+      x_batch_ndims,
+      x_shape,
+      x_strides,
+      w_batch_ndims,
+      w_shape,
+      w_strides,
+      s_strides,
+      b_strides,
+      tid);
+
+  // When (in_vec_size % split_k != 0) the final block needs to be smaller
+  int in_vec_size_adj =
+      tid.z % split_k == split_k - 1 ? final_block_size : in_vec_size;
+
+  qvm_impl<T, group_size, bits>(
+      w,
+      scales,
+      biases,
+      x,
+      y,
+      in_vec_size_adj,
+      out_vec_size,
+      tid,
+      simd_gid,
+      simd_lid);
+}
+
+template <
+    typename T,
+    const int group_size,
+    const int bits,
+    const bool aligned_N,
+    const bool batched,
+    const int BM = 32,
+    const int BK = 32,
+    const int BN = 32>
+[[kernel]] void affine_qmm_t(
+    const device uint32_t* w [[buffer(0)]],
+    const device T* scales [[buffer(1)]],
+    const device T* biases [[buffer(2)]],
+    const device T* x [[buffer(3)]],
+    device T* y [[buffer(4)]],
+    const constant int& K [[buffer(5)]],
+    const constant int& N [[buffer(6)]],
+    const constant int& M [[buffer(7)]],
+    const constant int& x_batch_ndims [[buffer(8)]],
+    const constant int* x_shape [[buffer(9)]],
+    const constant int64_t* x_strides [[buffer(10)]],
+    const constant int& w_batch_ndims [[buffer(11)]],
+    const constant int* w_shape [[buffer(12)]],
+    const constant int64_t* w_strides [[buffer(13)]],
+    const constant int64_t* s_strides [[buffer(14)]],
+    const constant int64_t* b_strides [[buffer(15)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint lid [[thread_index_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  (void)lid;
+
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+
+  threadgroup T Xs[BM * BK_padded];
+  threadgroup T Ws[BN * BK_padded];
+
+  if (batched) {
+    adjust_matrix_offsets<T>(
+        x,
+        w,
+        scales,
+        biases,
+        y,
+        M * N,
+        x_batch_ndims,
+        x_shape,
+        x_strides,
+        w_batch_ndims,
+        w_shape,
+        w_strides,
+        s_strides,
+        b_strides,
+        tid);
+  }
+  qmm_t_impl<T, group_size, bits, aligned_N, BM, BK, BN>(
+      w, scales, biases, x, y, Xs, Ws, K, N, M, tid, lid, simd_gid, simd_lid);
+}
+
+template <
+    typename T,
+    const int group_size,
+    const int bits,
+    const bool batched,
+    const int BM = 32,
+    const int BK = 32,
+    const int BN = 32>
+[[kernel]] void affine_qmm_n(
+    const device uint32_t* w [[buffer(0)]],
+    const device T* scales [[buffer(1)]],
+    const device T* biases [[buffer(2)]],
+    const device T* x [[buffer(3)]],
+    device T* y [[buffer(4)]],
+    const constant int& K [[buffer(5)]],
+    const constant int& N [[buffer(6)]],
+    const constant int& M [[buffer(7)]],
+    const constant int& x_batch_ndims [[buffer(8)]],
+    const constant int* x_shape [[buffer(9)]],
+    const constant int64_t* x_strides [[buffer(10)]],
+    const constant int& w_batch_ndims [[buffer(11)]],
+    const constant int* w_shape [[buffer(12)]],
+    const constant int64_t* w_strides [[buffer(13)]],
+    const constant int64_t* s_strides [[buffer(14)]],
+    const constant int64_t* b_strides [[buffer(15)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint lid [[thread_index_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  (void)lid;
+
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+  constexpr int BN_padded = (BN + 16 / sizeof(T));
+
+  threadgroup T Xs[BM * BK_padded];
+  threadgroup T Ws[BK * BN_padded];
+
+  if (batched) {
+    adjust_matrix_offsets<T>(
+        x,
+        w,
+        scales,
+        biases,
+        y,
+        M * N,
+        x_batch_ndims,
+        x_shape,
+        x_strides,
+        w_batch_ndims,
+        w_shape,
+        w_strides,
+        s_strides,
+        b_strides,
+        tid);
+  }
+
+  qmm_n_impl<T, group_size, bits, BM, BK, BN>(
+      w, scales, biases, x, y, Xs, Ws, K, N, M, tid, lid, simd_gid, simd_lid);
+}
+
+template <typename T, int group_size, int bits>
+[[kernel]] void affine_gather_qmv_fast(
+    const device uint32_t* w [[buffer(0)]],
+    const device T* scales [[buffer(1)]],
+    const device T* biases [[buffer(2)]],
+    const device T* x [[buffer(3)]],
+    const device uint32_t* lhs_indices [[buffer(4)]],
+    const device uint32_t* rhs_indices [[buffer(5)]],
+    device T* y [[buffer(6)]],
+    const constant int& in_vec_size [[buffer(7)]],
+    const constant int& out_vec_size [[buffer(8)]],
+    const constant int& x_batch_ndims [[buffer(9)]],
+    const constant int* x_shape [[buffer(10)]],
+    const constant int64_t* x_strides [[buffer(11)]],
+    const constant int& w_batch_ndims [[buffer(12)]],
+    const constant int* w_shape [[buffer(13)]],
+    const constant int64_t* w_strides [[buffer(14)]],
+    const constant int64_t* s_strides [[buffer(15)]],
+    const constant int64_t* b_strides [[buffer(16)]],
+    const constant int& batch_ndims [[buffer(17)]],
+    const constant int* batch_shape [[buffer(18)]],
+    const constant int64_t* lhs_strides [[buffer(19)]],
+    const constant int64_t* rhs_strides [[buffer(20)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  int M = x_shape[x_batch_ndims];
+  adjust_matrix_offsets<T>(
+      x,
+      w,
+      scales,
+      biases,
+      lhs_indices,
+      rhs_indices,
+      y,
+      out_vec_size * M,
+      batch_ndims,
+      batch_shape,
+      lhs_strides,
+      rhs_strides,
+      x_batch_ndims,
+      x_shape,
+      x_strides,
+      w_batch_ndims,
+      w_shape,
+      w_strides,
+      s_strides,
+      b_strides,
+      tid);
+  qmv_fast_impl<T, group_size, bits>(
+      w,
+      scales,
+      biases,
+      x,
+      y,
+      in_vec_size,
+      out_vec_size,
+      tid,
+      simd_gid,
+      simd_lid);
+}
+
+template <typename T, int group_size, int bits>
+[[kernel]] void affine_gather_qmv(
+    const device uint32_t* w [[buffer(0)]],
+    const device T* scales [[buffer(1)]],
+    const device T* biases [[buffer(2)]],
+    const device T* x [[buffer(3)]],
+    const device uint32_t* lhs_indices [[buffer(4)]],
+    const device uint32_t* rhs_indices [[buffer(5)]],
+    device T* y [[buffer(6)]],
+    const constant int& in_vec_size [[buffer(7)]],
+    const constant int& out_vec_size [[buffer(8)]],
+    const constant int& x_batch_ndims [[buffer(9)]],
+    const constant int* x_shape [[buffer(10)]],
+    const constant int64_t* x_strides [[buffer(11)]],
+    const constant int& w_batch_ndims [[buffer(12)]],
+    const constant int* w_shape [[buffer(13)]],
+    const constant int64_t* w_strides [[buffer(14)]],
+    const constant int64_t* s_strides [[buffer(15)]],
+    const constant int64_t* b_strides [[buffer(16)]],
+    const constant int& batch_ndims [[buffer(17)]],
+    const constant int* batch_shape [[buffer(18)]],
+    const constant int64_t* lhs_strides [[buffer(19)]],
+    const constant int64_t* rhs_strides [[buffer(20)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  int M = x_shape[x_batch_ndims];
+  adjust_matrix_offsets<T>(
+      x,
+      w,
+      scales,
+      biases,
+      lhs_indices,
+      rhs_indices,
+      y,
+      out_vec_size * M,
+      batch_ndims,
+      batch_shape,
+      lhs_strides,
+      rhs_strides,
+      x_batch_ndims,
+      x_shape,
+      x_strides,
+      w_batch_ndims,
+      w_shape,
+      w_strides,
+      s_strides,
+      b_strides,
+      tid);
+  qmv_impl<T, group_size, bits>(
+      w,
+      scales,
+      biases,
+      x,
+      y,
+      in_vec_size,
+      out_vec_size,
+      tid,
+      simd_gid,
+      simd_lid);
+}
+
+template <typename T, int group_size, int bits>
+[[kernel]] void affine_gather_qvm(
+    const device uint32_t* w [[buffer(0)]],
+    const device T* scales [[buffer(1)]],
+    const device T* biases [[buffer(2)]],
+    const device T* x [[buffer(3)]],
+    const device uint32_t* lhs_indices [[buffer(4)]],
+    const device uint32_t* rhs_indices [[buffer(5)]],
+    device T* y [[buffer(6)]],
+    const constant int& in_vec_size [[buffer(7)]],
+    const constant int& out_vec_size [[buffer(8)]],
+    const constant int& x_batch_ndims [[buffer(9)]],
+    const constant int* x_shape [[buffer(10)]],
+    const constant int64_t* x_strides [[buffer(11)]],
+    const constant int& w_batch_ndims [[buffer(12)]],
+    const constant int* w_shape [[buffer(13)]],
+    const constant int64_t* w_strides [[buffer(14)]],
+    const constant int64_t* s_strides [[buffer(15)]],
+    const constant int64_t* b_strides [[buffer(16)]],
+    const constant int& batch_ndims [[buffer(17)]],
+    const constant int* batch_shape [[buffer(18)]],
+    const constant int64_t* lhs_strides [[buffer(19)]],
+    const constant int64_t* rhs_strides [[buffer(20)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  int M = x_shape[x_batch_ndims];
+  adjust_matrix_offsets<T>(
+      x,
+      w,
+      scales,
+      biases,
+      lhs_indices,
+      rhs_indices,
+      y,
+      out_vec_size * M,
+      batch_ndims,
+      batch_shape,
+      lhs_strides,
+      rhs_strides,
+      x_batch_ndims,
+      x_shape,
+      x_strides,
+      w_batch_ndims,
+      w_shape,
+      w_strides,
+      s_strides,
+      b_strides,
+      tid);
+  qvm_impl<T, group_size, bits>(
+      w,
+      scales,
+      biases,
+      x,
+      y,
+      in_vec_size,
+      out_vec_size,
+      tid,
+      simd_gid,
+      simd_lid);
+}
+
+template <
+    typename T,
+    const int group_size,
+    const int bits,
+    const bool aligned_N,
+    const int BM = 32,
+    const int BK = 32,
+    const int BN = 32>
+[[kernel]] void affine_gather_qmm_t(
+    const device uint32_t* w [[buffer(0)]],
+    const device T* scales [[buffer(1)]],
+    const device T* biases [[buffer(2)]],
+    const device T* x [[buffer(3)]],
+    const device uint32_t* lhs_indices [[buffer(4)]],
+    const device uint32_t* rhs_indices [[buffer(5)]],
+    device T* y [[buffer(6)]],
+    const constant int& K [[buffer(7)]],
+    const constant int& N [[buffer(8)]],
+    const constant int& M [[buffer(9)]],
+    const constant int& x_batch_ndims [[buffer(10)]],
+    const constant int* x_shape [[buffer(11)]],
+    const constant int64_t* x_strides [[buffer(12)]],
+    const constant int& w_batch_ndims [[buffer(13)]],
+    const constant int* w_shape [[buffer(14)]],
+    const constant int64_t* w_strides [[buffer(15)]],
+    const constant int64_t* s_strides [[buffer(16)]],
+    const constant int64_t* b_strides [[buffer(17)]],
+    const constant int& batch_ndims [[buffer(18)]],
+    const constant int* batch_shape [[buffer(19)]],
+    const constant int64_t* lhs_strides [[buffer(20)]],
+    const constant int64_t* rhs_strides [[buffer(21)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint lid [[thread_index_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  (void)lid;
+
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+
+  threadgroup T Xs[BM * BK_padded];
+  threadgroup T Ws[BN * BK_padded];
+
+  adjust_matrix_offsets<T>(
+      x,
+      w,
+      scales,
+      biases,
+      lhs_indices,
+      rhs_indices,
+      y,
+      M * N,
+      batch_ndims,
+      batch_shape,
+      lhs_strides,
+      rhs_strides,
+      x_batch_ndims,
+      x_shape,
+      x_strides,
+      w_batch_ndims,
+      w_shape,
+      w_strides,
+      s_strides,
+      b_strides,
+      tid);
+  qmm_t_impl<T, group_size, bits, aligned_N, BM, BK, BN>(
+      w, scales, biases, x, y, Xs, Ws, K, N, M, tid, lid, simd_gid, simd_lid);
+}
+
+template <
+    typename T,
+    const int group_size,
+    const int bits,
+    const int BM = 32,
+    const int BK = 32,
+    const int BN = 32>
+[[kernel]] void affine_gather_qmm_n(
+    const device uint32_t* w [[buffer(0)]],
+    const device T* scales [[buffer(1)]],
+    const device T* biases [[buffer(2)]],
+    const device T* x [[buffer(3)]],
+    const device uint32_t* lhs_indices [[buffer(4)]],
+    const device uint32_t* rhs_indices [[buffer(5)]],
+    device T* y [[buffer(6)]],
+    const constant int& K [[buffer(7)]],
+    const constant int& N [[buffer(8)]],
+    const constant int& M [[buffer(9)]],
+    const constant int& x_batch_ndims [[buffer(10)]],
+    const constant int* x_shape [[buffer(11)]],
+    const constant int64_t* x_strides [[buffer(12)]],
+    const constant int& w_batch_ndims [[buffer(13)]],
+    const constant int* w_shape [[buffer(14)]],
+    const constant int64_t* w_strides [[buffer(15)]],
+    const constant int64_t* s_strides [[buffer(16)]],
+    const constant int64_t* b_strides [[buffer(17)]],
+    const constant int& batch_ndims [[buffer(18)]],
+    const constant int* batch_shape [[buffer(19)]],
+    const constant int64_t* lhs_strides [[buffer(20)]],
+    const constant int64_t* rhs_strides [[buffer(21)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint lid [[thread_index_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  (void)lid;
+
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+  constexpr int BN_padded = (BN + 16 / sizeof(T));
+
+  threadgroup T Xs[BM * BK_padded];
+  threadgroup T Ws[BK * BN_padded];
+
+  adjust_matrix_offsets<T>(
+      x,
+      w,
+      scales,
+      biases,
+      lhs_indices,
+      rhs_indices,
+      y,
+      M * N,
+      batch_ndims,
+      batch_shape,
+      lhs_strides,
+      rhs_strides,
+      x_batch_ndims,
+      x_shape,
+      x_strides,
+      w_batch_ndims,
+      w_shape,
+      w_strides,
+      s_strides,
+      b_strides,
+      tid);
+  qmm_n_impl<T, group_size, bits, BM, BK, BN>(
+      w, scales, biases, x, y, Xs, Ws, K, N, M, tid, lid, simd_gid, simd_lid);
+}
+
+template <
+    typename T,
+    int group_size,
+    int bits,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose>
+[[kernel]] void affine_gather_qmm_rhs(
+    const device T* x [[buffer(0)]],
+    const device uint32_t* w [[buffer(1)]],
+    const device T* scales [[buffer(2)]],
+    const device T* biases [[buffer(3)]],
+    const device uint32_t* indices [[buffer(4)]],
+    device T* y [[buffer(5)]],
+    const constant int& M [[buffer(6)]],
+    const constant int& N [[buffer(7)]],
+    const constant int& K [[buffer(8)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]]) {
+  constexpr int pack_factor = get_pack_factor<bits, 8>();
+  constexpr int bytes_per_pack = get_bytes_per_pack<bits>();
+  constexpr int BK_padded = (BK + 16 / sizeof(T));
+  constexpr int BN_padded = (BN + 16 / sizeof(T));
+
+  using mma_t = mlx::steel::BlockMMA<
+      T,
+      T,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      false,
+      transpose,
+      BK_padded,
+      transpose ? BK_padded : BN_padded>;
+  using loader_x_t =
+      mlx::steel::BlockLoader<T, BM, BK, BK_padded, 1, WM * WN * SIMD_SIZE>;
+  using loader_w_t = QuantizedBlockLoader<
+      T,
+      transpose ? BN : BK,
+      transpose ? BK : BN,
+      transpose ? BK_padded : BN_padded,
+      transpose,
+      WM * WN * SIMD_SIZE,
+      group_size,
+      bits>;
+
+  threadgroup T Xs[BM * BK_padded];
+  threadgroup T Ws[transpose ? BN * BK_padded : BK * BN_padded];
+
+  // Compute the block
+  const int K_w = K * bytes_per_pack / pack_factor;
+  const int K_g = K / group_size;
+  const int N_w = N * bytes_per_pack / pack_factor;
+  const int N_g = N / group_size;
+  const int K_it = K / BK;
+  const size_t stride_w = transpose ? N * K_w : K * N_w;
+  const size_t stride_s = transpose ? N * K_g : K * N_g;
+  const int y_row = tid.y * BM;
+  const int y_col = tid.x * BN;
+  const size_t y_row_long = size_t(y_row);
+  const size_t y_col_long = size_t(y_col);
+
+  // Prepare threadgroup bounds
+  const short tgp_bm = align_M ? BM : short(min(BM, M - y_row));
+  const short tgp_bn = align_N ? BN : short(min(BN, N - y_col));
+
+  // Calculate the final tiles in the case that K is not aligned
+  const int k_remain = K - K_it * BK;
+  const short2 tile_x = short2(k_remain, tgp_bm);
+  const short2 tile_w =
+      transpose ? short2(k_remain, tgp_bn) : short2(tgp_bn, k_remain);
+
+  // Move x and output to the correct block
+  auto wl = (const device uint8_t*)w;
+  x += y_row_long * K;
+  y += y_row_long * N + y_col_long;
+  wl += transpose ? y_col_long * K_w : y_col * bytes_per_pack / pack_factor;
+  scales += transpose ? y_col_long * K_g : y_col / group_size;
+  biases += transpose ? y_col_long * K_g : y_col / group_size;
+
+  // Do as many matmuls as necessary
+  uint32_t index;
+  short offset;
+  uint32_t index_next = indices[y_row];
+  short offset_next = 0;
+  int n = 0;
+  while (n < tgp_bm) {
+    n++;
+    offset = offset_next;
+    index = index_next;
+    offset_next = tgp_bm;
+    for (; n < tgp_bm; n++) {
+      if (indices[y_row + n] != index) {
+        offset_next = n;
+        index_next = indices[y_row + n];
+        break;
+      }
+    }
+    threadgroup_barrier(mem_flags::mem_none);
+
+    // Prepare threadgroup mma operation
+    thread mma_t mma_op(simd_group_id, simd_lane_id);
+
+    // Prepare threadgroup loading operations
+    thread loader_x_t loader_x(x, K, Xs, simd_group_id, simd_lane_id);
+    thread loader_w_t loader_w(
+        wl + index * stride_w,
+        scales + index * stride_s,
+        biases + index * stride_s,
+        transpose ? K : N,
+        Ws,
+        simd_group_id,
+        simd_lane_id);
+
+    // Matrices are all aligned check nothing
+    if (align_M && align_N) {
+      gemm_loop_aligned(Xs, Ws, mma_op, loader_x, loader_w, K_it);
+      if (!align_K) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        gemm_loop_finalize(Xs, Ws, mma_op, loader_x, loader_w, tile_x, tile_w);
+      }
+
+      // Store results to device memory
+      if (offset_next - offset == BM) {
+        mma_op.store_result(y, N);
+      } else {
+        mma_op.store_result_slice(
+            y, N, short2(0, offset), short2(BN, offset_next));
+      }
+    } else {
+      // Tile aligned so check outside of the hot loop
+      if ((align_M || tgp_bm == BM) && (align_N || tgp_bn == BN)) {
+        gemm_loop_aligned(Xs, Ws, mma_op, loader_x, loader_w, K_it);
+        if (!align_K) {
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+          gemm_loop_finalize(
+              Xs, Ws, mma_op, loader_x, loader_w, tile_x, tile_w);
+        }
+
+        // Store results to device memory
+        if (offset_next - offset == BM) {
+          mma_op.store_result(y, N);
+        } else {
+          mma_op.store_result_slice(
+              y, N, short2(0, offset), short2(BN, offset_next));
+        }
+      }
+
+      // Tile partially aligned check rows
+      else if (align_N || tgp_bn == BN) {
+        gemm_loop_unaligned<false, true, transpose>(
+            Xs, Ws, mma_op, loader_x, loader_w, K_it, tgp_bm, tgp_bn, BK);
+        if (!align_K) {
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+          gemm_loop_finalize(
+              Xs, Ws, mma_op, loader_x, loader_w, tile_x, tile_w);
+        }
+        mma_op.store_result_slice(
+            y, N, short2(0, offset), short2(BN, offset_next));
+      }
+
+      // Tile partially aligned check cols
+      else if (align_M || tgp_bm == BM) {
+        gemm_loop_unaligned<true, false, transpose>(
+            Xs, Ws, mma_op, loader_x, loader_w, K_it, tgp_bm, tgp_bn, BK);
+        if (!align_K) {
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+          gemm_loop_finalize(
+              Xs, Ws, mma_op, loader_x, loader_w, tile_x, tile_w);
+        }
+        mma_op.store_result_slice(
+            y, N, short2(0, offset), short2(tgp_bn, offset_next));
+      }
+
+      // Nothing aligned so check both rows and cols
+      else {
+        gemm_loop_unaligned<false, false, transpose>(
+            Xs, Ws, mma_op, loader_x, loader_w, K_it, tgp_bm, tgp_bn, BK);
+        if (!align_K) {
+          threadgroup_barrier(mem_flags::mem_threadgroup);
+          gemm_loop_finalize(
+              Xs, Ws, mma_op, loader_x, loader_w, tile_x, tile_w);
+        }
+        mma_op.store_result_slice(
+            y, N, short2(0, offset), short2(tgp_bn, offset_next));
+      }
+    }
+  }
+}
+
+template <typename T, const int group_size, const int bits>
+[[kernel]] void affine_quantize(
+    const device T* w [[buffer(0)]],
+    device uint8_t* out [[buffer(1)]],
+    device T* scales [[buffer(2)]],
+    device T* biases [[buffer(3)]],
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  constexpr float eps = 1e-7;
+  constexpr int simd_size = 32;
+  constexpr float n_bins = (1 << bits) - 1;
+  constexpr int pack_factor = get_pack_factor<bits, 8>();
+  constexpr int bytes_per_pack = get_bytes_per_pack<bits>();
+  constexpr int values_per_reduce = group_size / simd_size;
+  constexpr int writes_per_reduce = pack_factor / values_per_reduce;
+  constexpr int writes_per_pack =
+      writes_per_reduce > 1 ? 1 : values_per_reduce / pack_factor;
+  constexpr int power_of_2_bits = (bits & (bits - 1)) == 0;
+
+  static_assert(
+      group_size % simd_size == 0,
+      "Group size must be divisible by simd size.");
+
+  size_t offset = index.x + grid_dim.x * size_t(index.y);
+  size_t in_index = offset * values_per_reduce;
+  size_t out_index = power_of_2_bits
+      ? offset * writes_per_pack
+      : offset * bytes_per_pack / writes_per_reduce;
+
+  float w_thread[values_per_reduce];
+  float w_min = Limits<T>::max;
+  float w_max = 0;
+
+#pragma clang loop unroll(full)
+  for (int i = 0; i < values_per_reduce; i++) {
+    float val = w[in_index + i];
+    w_thread[i] = val;
+    w_min = min(w_min, val);
+    w_max = max(w_max, val);
+  }
+
+  w_min = simd_min(w_min);
+  w_max = simd_max(w_max);
+
+  float scale = max((w_max - w_min) / n_bins, eps);
+  bool side = abs(w_min) > abs(w_max);
+  scale = side ? scale : -scale;
+  float edge = side ? w_min : w_max;
+  float q0 = round(edge / scale);
+  bool at_zero = q0 == 0.0f;
+  scale = at_zero ? scale : edge / q0;
+  float bias = at_zero ? 0 : edge;
+
+  // Write out the scales and biases
+  size_t gindex = in_index / group_size;
+  if (in_index % group_size == 0) {
+    scales[gindex] = static_cast<T>(scale);
+    biases[gindex] = static_cast<T>(bias);
+  }
+
+  using OutType = metal::conditional_t<bits == 5, uint64_t, uint32_t>;
+  OutType output = 0;
+
+#pragma clang loop unroll(full)
+  for (int i = 0; i < values_per_reduce; i++) {
+    uint8_t val = min(round((w_thread[i] - bias) / scale), n_bins);
+    if (bits == 8) {
+      output = val;
+    } else {
+      output |= val << (bits * (i % pack_factor));
+    }
+
+    if (pack_factor < values_per_reduce && i % pack_factor == pack_factor - 1) {
+      out[out_index + i / pack_factor] = output;
+      output = 0;
+    } else {
+#pragma clang loop unroll(full)
+      for (int j = 1; j < writes_per_reduce; j++) {
+        uint8_t sval = simd_shuffle_down(val, j);
+        output |= static_cast<OutType>(sval)
+            << (bits * (j * values_per_reduce + i));
+      }
+    }
+  }
+  if (bits == 3 || bits == 6) {
+    if (in_index % pack_factor == 0 && out_index % bytes_per_pack == 0) {
+      out[out_index] = output & 0xff;
+      out[out_index + 1] = (output & 0xff00) >> 8;
+      out[out_index + 2] = (output & 0xff0000) >> 16;
+    }
+  } else if (bits == 5) {
+    if (in_index % pack_factor == 0 && out_index % bytes_per_pack == 0) {
+      out[out_index] = output & 0xff;
+      out[out_index + 1] = (output & 0xff00) >> 8;
+      out[out_index + 2] = (output & 0xff0000) >> 16;
+      out[out_index + 3] = (output & 0xff000000) >> 24;
+      out[out_index + 4] = (output & 0xff00000000) >> 32;
+    }
+  } else {
+    if (writes_per_reduce > 0 && out_index % writes_per_reduce == 0) {
+      out[out_index / writes_per_reduce] = output;
+    }
+  }
+}
+
+template <typename T, const int group_size, const int bits>
+[[kernel]] void affine_dequantize(
+    const device uint8_t* w [[buffer(0)]],
+    const device T* scales [[buffer(1)]],
+    const device T* biases [[buffer(2)]],
+    device T* out [[buffer(3)]],
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  constexpr int pack_factor = get_pack_factor<bits, 8>();
+  constexpr int bytes_per_pack = get_bytes_per_pack<bits>();
+
+  size_t offset = index.x + grid_dim.x * size_t(index.y);
+  size_t oindex = offset * pack_factor;
+  size_t gindex = oindex / group_size;
+  T scale = scales[gindex];
+  T bias = biases[gindex];
+
+  out += oindex;
+
+  if (bits == 3) {
+    w += offset * bytes_per_pack;
+    out[0] = (w[0] & 0x7) * scale + bias;
+    out[1] = ((w[0] & 0x38) >> 3) * scale + bias;
+    out[2] = (((w[0] & 0xc0) >> 6) + ((w[1] & 0x1) << 2)) * scale + bias;
+    out[3] = ((w[1] & 0xe) >> 1) * scale + bias;
+    out[4] = ((w[1] & 0x70) >> 4) * scale + bias;
+    out[5] = (((w[1] & 0x80) >> 7) + ((w[2] & 0x3) << 1)) * scale + bias;
+    out[6] = ((w[2] & 0x1c) >> 2) * scale + bias;
+    out[7] = ((w[2] & 0xe0) >> 5) * scale + bias;
+  } else if (bits == 5) {
+    w += offset * bytes_per_pack;
+    out[0] = (w[0] & 0x1f) * scale + bias;
+    out[1] = (((w[0] & 0xe0) >> 5) + ((w[1] & 0x3) << 3)) * scale + bias;
+    out[2] = ((w[1] & 0x7c) >> 2) * scale + bias;
+    out[3] = (((w[1] & 0x80) >> 7) + ((w[2] & 0xf) << 1)) * scale + bias;
+    out[4] = (((w[2] & 0xf0) >> 4) + ((w[3] & 0x1) << 4)) * scale + bias;
+    out[5] = ((w[3] & 0x3e) >> 1) * scale + bias;
+    out[6] = (((w[3] & 0xc0) >> 6) + ((w[4] & 0x7) << 2)) * scale + bias;
+    out[7] = ((w[4] & 0xf8) >> 3) * scale + bias;
+  } else if (bits == 6) {
+    w += offset * bytes_per_pack;
+    out[0] = (w[0] & 0x3f) * scale + bias;
+    out[1] = (((w[0] >> 6) & 0x03) + ((w[1] & 0x0f) << 2)) * scale + bias;
+    out[2] = (((w[1] >> 4) & 0x0f) + ((w[2] & 0x03) << 4)) * scale + bias;
+    out[3] = ((w[2] >> 2) & 0x3f) * scale + bias;
+  } else {
+    uint val = w[offset];
+#pragma clang loop unroll(full)
+    for (int i = 0; i < pack_factor; i++) {
+      uint8_t d;
+      if (bits == 2) {
+        d = (val >> (bits * i)) & 0x03;
+      } else if (bits == 4) {
+        d = (val >> (bits * i)) & 0x0f;
+      } else if (bits == 8) {
+        d = val;
+      }
+      out[i] = scale * d + bias;
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/quantized.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/quantized.metal
new file mode 100644
index 0000000000000000000000000000000000000000..f734b9bcee287009a40ad411181be87d9134dcd3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/quantized.metal
@@ -0,0 +1,144 @@
+// Copyright © 2023-2024 Apple Inc.
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/steel/gemm/gemm.h"
+#include "mlx/backend/metal/kernels/quantized_utils.h"
+#include "mlx/backend/metal/kernels/quantized.h"
+
+#define instantiate_quantized(name, type, group_size, bits)     \
+  instantiate_kernel(                                                    \
+      #name "_" #type "_gs_" #group_size "_b_" #bits,                    \
+      name,                                                              \
+      type,                                                              \
+      group_size,                                                        \
+      bits)
+
+#define instantiate_quantized_batched(name, type, group_size, bits, batched)     \
+  instantiate_kernel(                                                    \
+      #name "_" #type "_gs_" #group_size "_b_" #bits "_batch_" #batched, \
+      name,                                                              \
+      type,                                                              \
+      group_size,                                                        \
+      bits,                                                              \
+      batched)
+
+#define instantiate_quantized_aligned(name, type, group_size, bits, aligned)     \
+  instantiate_kernel(                                                                     \
+      #name "_" #type "_gs_" #group_size "_b_" #bits "_alN_" #aligned, \
+      name,                                                                  \
+      type,                                                                  \
+      group_size,                                                            \
+      bits,                                                                  \
+      aligned)
+
+#define instantiate_quantized_aligned_batched(name, type, group_size, bits, aligned, batched)     \
+  instantiate_kernel(                                                                     \
+      #name "_" #type "_gs_" #group_size "_b_" #bits "_alN_" #aligned "_batch_" #batched, \
+      name,                                                                  \
+      type,                                                                  \
+      group_size,                                                            \
+      bits,                                                                  \
+      aligned,                                                               \
+      batched)
+
+#define instantiate_quantized_quad(name, type, group_size, bits, D, batched)     \
+  instantiate_kernel(                                                            \
+      #name "_" #type "_gs_" #group_size "_b_" #bits "_d_" #D "_batch_" #batched, \
+      name,                                                         \
+      type,                                                         \
+      group_size,                                                   \
+      bits,                                                         \
+      D,                                                            \
+      batched)
+
+#define instantiate_quantized_split_k(name, type, group_size, bits, split_k)     \
+  instantiate_kernel(                                                            \
+      #name "_" #type "_gs_" #group_size "_b_" #bits "_spk_" #split_k, \
+      name,                                                         \
+      type,                                                         \
+      group_size,                                                   \
+      bits,                                                         \
+      split_k)
+
+#define instantiate_gather_qmm_rhs(func, name, type, group_size, bits, bm, bn, bk, wm, wn, transpose)        \
+  instantiate_kernel(                                                                                        \
+      #name "_" #type "_gs_" #group_size "_b_" #bits "_bm_" #bm "_bn_" #bn "_bk_" #bk "_wm_" #wm "_wn_" #wn, \
+      func,                                                         \
+      type,                                                         \
+      group_size,                                                   \
+      bits,                                                         \
+      bm,                                                           \
+      bn,                                                           \
+      bk,                                                           \
+      wm,                                                           \
+      wn,                                                           \
+      transpose)
+
+#define instantiate_quantized_batched_wrap(name, type, group_size, bits) \
+  instantiate_quantized_batched(name, type, group_size, bits, 1)      \
+  instantiate_quantized_batched(name, type, group_size, bits, 0)
+
+#define instantiate_quantized_all_batched(type, group_size, bits) \
+  instantiate_quantized_batched_wrap(affine_qmv_fast, type, group_size, bits)     \
+  instantiate_quantized_batched_wrap(affine_qmv, type, group_size, bits)     \
+  instantiate_quantized_batched_wrap(affine_qvm, type, group_size, bits)     \
+  instantiate_quantized_batched_wrap(affine_qmm_n, type, group_size, bits)
+
+#define instantiate_quantized_all_single(type, group_size, bits) \
+  instantiate_quantized(affine_quantize, type, group_size, bits) \
+  instantiate_quantized(affine_dequantize, type, group_size, bits)     \
+  instantiate_quantized(affine_gather_qmv_fast, type, group_size, bits)     \
+  instantiate_quantized(affine_gather_qmv, type, group_size, bits)     \
+  instantiate_quantized(affine_gather_qvm, type, group_size, bits)     \
+  instantiate_quantized(affine_gather_qmm_n, type, group_size, bits)
+
+#define instantiate_quantized_all_aligned(type, group_size, bits)   \
+  instantiate_quantized_aligned(affine_gather_qmm_t, type, group_size, bits, true) \
+  instantiate_quantized_aligned(affine_gather_qmm_t, type, group_size, bits, false) \
+  instantiate_quantized_aligned_batched(affine_qmm_t, type, group_size, bits, true, 1) \
+  instantiate_quantized_aligned_batched(affine_qmm_t, type, group_size, bits, true, 0) \
+  instantiate_quantized_aligned_batched(affine_qmm_t, type, group_size, bits, false, 1) \
+  instantiate_quantized_aligned_batched(affine_qmm_t, type, group_size, bits, false, 0)
+
+#define instantiate_quantized_all_quad(type, group_size, bits)   \
+  instantiate_quantized_quad(affine_qmv_quad, type, group_size, bits, 64, 1)   \
+  instantiate_quantized_quad(affine_qmv_quad, type, group_size, bits, 64, 0)   \
+  instantiate_quantized_quad(affine_qmv_quad, type, group_size, bits, 128, 1)  \
+  instantiate_quantized_quad(affine_qmv_quad, type, group_size, bits, 128, 0)
+
+#define instantiate_quantized_all_splitk(type, group_size, bits)   \
+  instantiate_quantized_split_k(affine_qvm_split_k, type, group_size, bits, 8)   \
+  instantiate_quantized_split_k(affine_qvm_split_k, type, group_size, bits, 32)
+
+#define instantiate_quantized_all_rhs(type, group_size, bits) \
+  instantiate_gather_qmm_rhs(affine_gather_qmm_rhs, affine_gather_qmm_rhs_nt, type, group_size, bits, 16, 32, 32, 1, 2, true) \
+  instantiate_gather_qmm_rhs(affine_gather_qmm_rhs, affine_gather_qmm_rhs_nn, type, group_size, bits, 16, 32, 32, 1, 2, false)
+
+#define instantiate_quantized_funcs(type, group_size, bits) \
+  instantiate_quantized_all_single(type, group_size, bits)  \
+  instantiate_quantized_all_batched(type, group_size, bits) \
+  instantiate_quantized_all_aligned(type, group_size, bits) \
+  instantiate_quantized_all_quad(type, group_size, bits)    \
+  instantiate_quantized_all_splitk(type, group_size, bits)  \
+  instantiate_quantized_all_rhs(type, group_size, bits)
+
+#define instantiate_quantized_types(group_size, bits)       \
+  instantiate_quantized_funcs(float, group_size, bits)      \
+  instantiate_quantized_funcs(float16_t, group_size, bits)  \
+  instantiate_quantized_funcs(bfloat16_t, group_size, bits)
+
+#define instantiate_quantized_groups(bits) \
+  instantiate_quantized_types(128, bits)   \
+  instantiate_quantized_types(64, bits)    \
+  instantiate_quantized_types(32, bits)
+
+#define instantiate_quantized_all() \
+  instantiate_quantized_groups(2) \
+  instantiate_quantized_groups(3) \
+  instantiate_quantized_groups(4) \
+  instantiate_quantized_groups(5) \
+  instantiate_quantized_groups(6) \
+  instantiate_quantized_groups(8)
+
+instantiate_quantized_all() // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/quantized_utils.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/quantized_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..38253f8fe9354f8980c01bbd5eab9de766e8efb8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/quantized_utils.h
@@ -0,0 +1,90 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <metal_simdgroup>
+#include <metal_stdlib>
+
+template <typename T, typename mma_t, typename loader_a_t, typename loader_b_t>
+METAL_FUNC void gemm_loop_aligned(
+    threadgroup T* As,
+    threadgroup T* Bs,
+    thread mma_t& mma_op,
+    thread loader_a_t& loader_a,
+    thread loader_b_t& loader_b,
+    const int k_iterations) {
+  for (int k = 0; k < k_iterations; k++) {
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Load elements into threadgroup memory
+    loader_a.load_unsafe();
+    loader_b.load_unsafe();
+
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Multiply and accumulate threadgroup elements
+    mma_op.mma(As, Bs);
+
+    // Prepare for next iteration
+    loader_a.next();
+    loader_b.next();
+  }
+}
+
+template <
+    bool rows_aligned,
+    bool cols_aligned,
+    bool transpose,
+    typename T,
+    typename mma_t,
+    typename loader_a_t,
+    typename loader_b_t>
+METAL_FUNC void gemm_loop_unaligned(
+    threadgroup T* As,
+    threadgroup T* Bs,
+    thread mma_t& mma_op,
+    thread loader_a_t& loader_a,
+    thread loader_b_t& loader_b,
+    const int k_iterations,
+    const short tgp_bm,
+    const short tgp_bn,
+    const short tgp_bk) {
+  for (int k = 0; k < k_iterations; k++) {
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Load elements into threadgroup memory
+    if (rows_aligned) {
+      loader_a.load_unsafe();
+    } else {
+      loader_a.load_safe(short2(tgp_bk, tgp_bm));
+    }
+    if (cols_aligned) {
+      loader_b.load_unsafe();
+    } else {
+      loader_b.load_safe(
+          transpose ? short2(tgp_bk, tgp_bn) : short2(tgp_bn, tgp_bk));
+    }
+
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Multiply and accumulate threadgroup elements
+    mma_op.mma(As, Bs);
+
+    // Prepare for next iteration
+    loader_a.next();
+    loader_b.next();
+  }
+}
+
+template <typename T, typename mma_t, typename loader_a_t, typename loader_b_t>
+METAL_FUNC void gemm_loop_finalize(
+    threadgroup T* As,
+    threadgroup T* Bs,
+    thread mma_t& mma_op,
+    thread loader_a_t& loader_a,
+    thread loader_b_t& loader_b,
+    const short2 tile_a,
+    const short2 tile_b) {
+  loader_a.load_safe(tile_a);
+  loader_b.load_safe(tile_b);
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  mma_op.mma(As, Bs);
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/random.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/random.metal
new file mode 100644
index 0000000000000000000000000000000000000000..ccbd464d3b2572c754a690c4d5e90ed645eb6310
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/random.metal
@@ -0,0 +1,103 @@
+// Copyright © 2023 Apple Inc.
+
+#include "mlx/backend/metal/kernels/utils.h"
+
+static constexpr constant uint32_t rotations[2][4] = {
+    {13, 15, 26, 6},
+    {17, 29, 16, 24}};
+
+union rbits {
+  uint2 val;
+  uchar4 bytes[2];
+};
+
+rbits threefry2x32_hash(const thread uint2& key, uint2 count) {
+  uint4 ks = {key.x, key.y, key.x ^ key.y ^ 0x1BD11BDA};
+
+  rbits v;
+  v.val.x = count.x + ks[0];
+  v.val.y = count.y + ks[1];
+
+  for (int i = 0; i < 5; ++i) {
+    for (auto r : rotations[i % 2]) {
+      v.val.x += v.val.y;
+      v.val.y = (v.val.y << r) | (v.val.y >> (32 - r));
+      v.val.y ^= v.val.x;
+    }
+    v.val.x += ks[(i + 1) % 3];
+    v.val.y += ks[(i + 2) % 3] + i + 1;
+  }
+
+  return v;
+}
+
+[[kernel]] void rbitsc(
+    device const uint32_t* keys,
+    device char* out,
+    constant const bool& odd,
+    constant const uint& bytes_per_key,
+    uint2 grid_dim [[threads_per_grid]],
+    uint2 index [[thread_position_in_grid]]) {
+  auto kidx = 2 * index.x;
+  auto key = uint2(keys[kidx], keys[kidx + 1]);
+  auto half_size = grid_dim.y - odd;
+  out += index.x * bytes_per_key;
+  bool drop_last = odd && (index.y == half_size);
+  auto bits = threefry2x32_hash(
+      key, uint2(index.y, drop_last ? 0 : index.y + grid_dim.y));
+  size_t idx = size_t(index.y) << 2;
+  for (int i = 0; i < 4; ++i) {
+    out[idx + i] = bits.bytes[0][i];
+  }
+  if (!drop_last) {
+    idx = (drop_last ? 0 : size_t(index.y) + grid_dim.y) << 2;
+    if ((index.y + 1) == half_size && (bytes_per_key % 4) > 0) {
+      int edge_bytes = (bytes_per_key % 4);
+      for (int i = 0; i < edge_bytes; ++i) {
+        out[idx + i] = bits.bytes[1][i];
+      }
+    } else {
+      for (int i = 0; i < 4; ++i) {
+        out[idx + i] = bits.bytes[1][i];
+      }
+    }
+  }
+}
+
+[[kernel]] void rbits(
+    device const uint32_t* keys,
+    device char* out,
+    constant const bool& odd,
+    constant const uint& bytes_per_key,
+    constant const int& ndim,
+    constant const int* key_shape,
+    constant const int64_t* key_strides,
+    uint2 grid_dim [[threads_per_grid]],
+    uint2 index [[thread_position_in_grid]]) {
+  auto kidx = 2 * index.x;
+  auto k1_elem = elem_to_loc(kidx, key_shape, key_strides, ndim);
+  auto k2_elem = elem_to_loc(kidx + 1, key_shape, key_strides, ndim);
+  auto key = uint2(keys[k1_elem], keys[k2_elem]);
+  auto half_size = grid_dim.y - odd;
+  out += size_t(index.x) * bytes_per_key;
+  bool drop_last = odd && (index.y == half_size);
+  auto bits = threefry2x32_hash(
+      key, uint2(index.y, drop_last ? 0 : index.y + grid_dim.y));
+  size_t idx = size_t(index.y) << 2;
+  for (int i = 0; i < 4; ++i) {
+    out[idx + i] = bits.bytes[0][i];
+  }
+  if (!drop_last) {
+    idx = (drop_last ? 0 : size_t(index.y) + grid_dim.y) << 2;
+    if ((index.y + 1) == half_size && (bytes_per_key % 4) > 0) {
+      int edge_bytes = (bytes_per_key % 4);
+      for (int i = 0; i < edge_bytes; ++i) {
+        out[idx + i] = bits.bytes[1][i];
+      }
+    } else {
+      for (int i = 0; i < 4; ++i) {
+        out[idx + i] = bits.bytes[1][i];
+      }
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduce.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduce.h
new file mode 100644
index 0000000000000000000000000000000000000000..ee5c3d5c02ac7a88144c336191e49bc73adc7264
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduce.h
@@ -0,0 +1,5 @@
+#pragma once
+#include "mlx/backend/metal/kernels/reduction/reduce_all.h"
+#include "mlx/backend/metal/kernels/reduction/reduce_col.h"
+#include "mlx/backend/metal/kernels/reduction/reduce_init.h"
+#include "mlx/backend/metal/kernels/reduction/reduce_row.h"
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduce.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduce.metal
new file mode 100644
index 0000000000000000000000000000000000000000..de5dfbad7d0c6d90d0ec4ccd0461d96a7c01e7db
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduce.metal
@@ -0,0 +1,169 @@
+// Copyright © 2024 Apple Inc.
+
+#include <metal_atomic>
+#include <metal_simdgroup>
+
+// clang-format off
+#include "mlx/backend/metal/kernels/defines.h"
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/atomic.h"
+#include "mlx/backend/metal/kernels/reduction/ops.h"
+#include "mlx/backend/metal/kernels/reduce.h"
+
+#define instantiate_init_reduce(name, tname, type, op) \
+  instantiate_kernel("init_reduce_" #name #tname, init_reduce, type, op<type>)
+
+instantiate_init_reduce(and, bool_, bool, And)
+instantiate_init_reduce(or, bool_, bool, Or)
+
+#define instantiate_init_sum_prod(name, op)                 \
+  instantiate_init_reduce(name, int32, int32_t, op)         \
+  instantiate_init_reduce(name, int64, int64_t, op)         \
+  instantiate_init_reduce(name, float16, float16_t, op)     \
+  instantiate_init_reduce(name, bfloat16, bfloat16_t, op)   \
+  instantiate_init_reduce(name, float32, float, op)         \
+  instantiate_init_reduce(name, complex64, complex64_t, op)
+
+instantiate_init_sum_prod(sum, Sum)
+instantiate_init_sum_prod(prod, Prod)
+
+#define instantiate_init_min_max(name, op)                   \
+  instantiate_init_reduce(name, bool_, bool, op)             \
+  instantiate_init_reduce(name, int8, int8_t, op)            \
+  instantiate_init_reduce(name, int16, int16_t, op)          \
+  instantiate_init_reduce(name, int32, int32_t, op)          \
+  instantiate_init_reduce(name, int64, int64_t, op)          \
+  instantiate_init_reduce(name, uint8, uint8_t, op)          \
+  instantiate_init_reduce(name, uint16, uint16_t, op)        \
+  instantiate_init_reduce(name, uint32, uint32_t, op)        \
+  instantiate_init_reduce(name, uint64, uint64_t, op)        \
+  instantiate_init_reduce(name, float16, float16_t, op)      \
+  instantiate_init_reduce(name, bfloat16, bfloat16_t, op)    \
+  instantiate_init_reduce(name, float32, float, op)          \
+  instantiate_init_reduce(name, complex64, complex64_t, op)
+
+instantiate_init_min_max(min, Min)
+instantiate_init_min_max(max, Max)
+
+#define instantiate_all_reduce(name, itype, otype, op) \
+  instantiate_kernel("all_reduce_" #name,              \
+                     all_reduce,                       \
+                     itype, otype, op)
+
+#define instantiate_col_reduce_small(name, itype, otype, op, dim)          \
+  instantiate_kernel("col_reduce_small_" #dim "_reduce_" #name,            \
+                     col_reduce_small,                                     \
+                     itype, otype, op, int, dim)                           \
+  instantiate_kernel("col_reduce_longcolumn_" #dim "_reduce_" #name,       \
+                     col_reduce_longcolumn,                                \
+                     itype, otype, op, int, dim)                           \
+  instantiate_kernel("col_reduce_small_large_" #dim "_reduce_" #name,      \
+                     col_reduce_small,                                     \
+                     itype, otype, op, int64_t, dim)                       \
+  instantiate_kernel("col_reduce_longcolumn_large_" #dim "_reduce_" #name, \
+                     col_reduce_longcolumn,                                \
+                     itype, otype, op, int64_t, dim)
+
+#define instantiate_col_reduce_looped_tile(name, itype, otype, op, dim, bm, bn)        \
+  instantiate_kernel("col_reduce_looped_" #dim "_" #bm "_" #bn "_reduce_" #name,       \
+                     col_reduce_looped,                                                \
+                     itype, otype, op, int, dim, bm, bn)                               \
+  instantiate_kernel("col_reduce_looped_large_" #dim "_" #bm "_" #bn "_reduce_" #name, \
+                     col_reduce_looped,                                                \
+                     itype, otype, op, int64_t, dim, bm, bn)
+
+#define instantiate_col_reduce_2pass_tile(name, itype, otype, op, dim, bm, bn)        \
+  instantiate_kernel("col_reduce_2pass_" #dim "_" #bm "_" #bn "_reduce_" #name,       \
+                     col_reduce_2pass,                                                \
+                     itype, otype, op, int, dim, bm, bn)                              \
+  instantiate_kernel("col_reduce_2pass_large_" #dim "_" #bm "_" #bn "_reduce_" #name, \
+                     col_reduce_2pass,                                                \
+                     itype, otype, op, int64_t, dim, bm, bn)
+
+#define instantiate_col_reduce_looped(name, itype, otype, op, dim)        \
+  instantiate_col_reduce_looped_tile(name, itype, otype, op, dim, 32, 32) \
+  instantiate_col_reduce_2pass_tile(name, itype, otype, op, dim, 32, 32)
+
+#define instantiate_col_reduce_general(name, itype, otype, op) \
+  instantiate_col_reduce_small(name, itype, otype, op, 1)      \
+  instantiate_col_reduce_small(name, itype, otype, op, 2)      \
+  instantiate_col_reduce_small(name, itype, otype, op, 5)      \
+  instantiate_col_reduce_looped(name, itype, otype, op, 1)     \
+  instantiate_col_reduce_looped(name, itype, otype, op, 2)     \
+  instantiate_col_reduce_looped(name, itype, otype, op, 5)
+
+#define instantiate_row_reduce_small(name, itype, otype, op, dim)     \
+  instantiate_kernel("row_reduce_small_" #dim "_reduce_" #name,       \
+                     row_reduce_small,                                \
+                     itype, otype, op, int, dim)                      \
+  instantiate_kernel("row_reduce_small_large_" #dim "_reduce_" #name, \
+                     row_reduce_small,                                \
+                     itype, otype, op, int64_t, dim)
+
+#define instantiate_row_reduce_looped(name, itype, otype, op, dim)       \
+  instantiate_kernel("row_reduce_looped_" #dim "_reduce_" #name,         \
+                     row_reduce_looped,                                  \
+                     itype, otype, op, int, dim)                         \
+  instantiate_kernel("row_reduce_looped_large_" #dim "_reduce_" #name,   \
+                     row_reduce_looped,                                  \
+                     itype, otype, op, int64_t, dim)
+
+#define instantiate_row_reduce_general(name, itype, otype, op) \
+  instantiate_row_reduce_small(name, itype, otype, op, 1)      \
+  instantiate_row_reduce_small(name, itype, otype, op, 2)      \
+  instantiate_row_reduce_small(name, itype, otype, op, 5)      \
+  instantiate_row_reduce_looped(name, itype, otype, op, 1)     \
+  instantiate_row_reduce_looped(name, itype, otype, op, 2)     \
+  instantiate_row_reduce_looped(name, itype, otype, op, 5)     \
+  instantiate_kernel("row_reduce_simple_" #name,               \
+                     row_reduce_simple,                        \
+                     itype, otype, op)
+
+#define instantiate_reduce_functions(name, tname, itype, otype, op)    \
+  instantiate_all_reduce(name##tname, itype, otype, op<otype>)         \
+  instantiate_row_reduce_general(name##tname, itype, otype, op<otype>) \
+  instantiate_col_reduce_general(name##tname, itype, otype, op<otype>)
+
+#define instantiate_and_or(name, op)                           \
+  instantiate_reduce_functions(name, bool_, bool, bool, op)    \
+  instantiate_reduce_functions(name, int16, int16_t, bool, op) \
+  instantiate_reduce_functions(name, int32, int32_t, bool, op) \
+  instantiate_reduce_functions(name, int64, int64_t, bool, op)
+
+instantiate_and_or(and, And)
+instantiate_and_or(or, Or)
+
+#define instantiate_sum_prod(name, op)                                       \
+  instantiate_reduce_functions(name, uint8, uint8_t, int32_t, op)            \
+  instantiate_reduce_functions(name, uint16, uint16_t, uint32_t, op)         \
+  instantiate_reduce_functions(name, uint32, uint32_t, uint32_t, op)         \
+  instantiate_reduce_functions(name, uint64, uint64_t, uint64_t, op)         \
+  instantiate_reduce_functions(name, int8, int8_t, int32_t, op)              \
+  instantiate_reduce_functions(name, int16, int16_t, int32_t, op)            \
+  instantiate_reduce_functions(name, int32, int32_t, int32_t, op)            \
+  instantiate_reduce_functions(name, int64, int64_t, int64_t, op)            \
+  instantiate_reduce_functions(name, float16, float16_t, float16_t, op)      \
+  instantiate_reduce_functions(name, bfloat16, bfloat16_t, bfloat16_t, op)   \
+  instantiate_reduce_functions(name, float32, float, float, op)              \
+  instantiate_reduce_functions(name, complex64, complex64_t, complex64_t, op)
+
+instantiate_sum_prod(sum, Sum)
+instantiate_sum_prod(prod, Prod)
+
+#define instantiate_min_max(name, op)                                        \
+  instantiate_reduce_functions(name, int8, int8_t, int8_t, op)               \
+  instantiate_reduce_functions(name, int16, int16_t, int16_t, op)            \
+  instantiate_reduce_functions(name, int32, int32_t, int32_t, op)            \
+  instantiate_reduce_functions(name, int64, int64_t, int64_t, op)            \
+  instantiate_reduce_functions(name, uint8, uint8_t, uint8_t, op)            \
+  instantiate_reduce_functions(name, uint16, uint16_t, uint16_t, op)         \
+  instantiate_reduce_functions(name, uint32, uint32_t, uint32_t, op)         \
+  instantiate_reduce_functions(name, uint64, uint64_t, uint64_t, op)         \
+  instantiate_reduce_functions(name, float16, float16_t, float16_t, op)      \
+  instantiate_reduce_functions(name, bfloat16, bfloat16_t, bfloat16_t, op)   \
+  instantiate_reduce_functions(name, float32, float, float, op)              \
+  instantiate_reduce_functions(name, complex64, complex64_t, complex64_t, op)
+
+instantiate_min_max(min, Min)
+instantiate_min_max(max, Max)
+    // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduce_utils.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduce_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..279a7afe78f4c3f7b0b528da69bdd5d85e4a15df
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduce_utils.h
@@ -0,0 +1,6 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/atomic.h"
+#include "mlx/backend/metal/kernels/reduction/ops.h"
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/ops.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..11d8e83ac62f080a0f605d8778fa1cabca469e61
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/ops.h
@@ -0,0 +1,275 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <metal_atomic>
+#include <metal_simdgroup>
+
+#define DEFINE_SIMD_REDUCE()                                             \
+  template <typename T, metal::enable_if_t<sizeof(T) < 8, bool> = true>  \
+  T simd_reduce(T val) {                                                 \
+    return simd_reduce_impl(val);                                        \
+  }                                                                      \
+                                                                         \
+  template <typename T, metal::enable_if_t<sizeof(T) == 8, bool> = true> \
+  T simd_reduce(T val) {                                                 \
+    for (short i = simd_size / 2; i > 0; i /= 2) {                       \
+      val = operator()(val, simd_shuffle_down(val, i));                  \
+    }                                                                    \
+    return val;                                                          \
+  }
+
+static constant constexpr const uint8_t simd_size = 32;
+
+union bool4_or_uint {
+  bool4 b;
+  unsigned int i;
+};
+
+struct None {
+  template <typename T>
+  void atomic_update(device mlx_atomic<T>* out, T val, size_t offset = 0) {
+    mlx_atomic_store_explicit(out, val, offset);
+  }
+};
+
+template <typename U = bool>
+struct And {
+  DEFINE_SIMD_REDUCE()
+
+  bool simd_reduce_impl(bool val) {
+    return simd_all(val);
+  }
+
+  static constexpr constant bool init = true;
+
+  void atomic_update(
+      device mlx_atomic<unsigned int>* out,
+      bool val,
+      int elem_idx,
+      size_t offset = 0) {
+    if (!val) {
+      bool4_or_uint update;
+      update.b = {true, true, true, true};
+      update.b[elem_idx] = false;
+      mlx_atomic_fetch_and_explicit(out, update.i, offset);
+    }
+  }
+
+  void
+  atomic_update(device mlx_atomic<bool>* out, bool val, size_t offset = 0) {
+    if (!val) {
+      mlx_atomic_store_explicit(out, val, offset);
+    }
+  }
+
+  // Non atomic update
+  void update(device bool* out, bool val) {
+    *out &= val;
+  }
+
+  // Operator
+  bool operator()(bool a, bool b) {
+    return a && b;
+  }
+};
+
+template <typename U = bool>
+struct Or {
+  DEFINE_SIMD_REDUCE()
+
+  bool simd_reduce_impl(bool val) {
+    return simd_any(val);
+  }
+
+  static constexpr constant bool init = false;
+
+  void atomic_update(
+      device mlx_atomic<unsigned int>* out,
+      bool val,
+      int elem_idx,
+      size_t offset = 0) {
+    if (val) {
+      bool4_or_uint update;
+      update.b = {false, false, false, false};
+      update.b[elem_idx] = true;
+      mlx_atomic_fetch_or_explicit(out, update.i, offset);
+    }
+  }
+
+  void
+  atomic_update(device mlx_atomic<bool>* out, bool val, size_t offset = 0) {
+    if (val) {
+      mlx_atomic_store_explicit(out, val, offset);
+    }
+  }
+
+  // Non atomic update
+  void update(device bool* out, bool val) {
+    *out |= val;
+  }
+
+  // Operator
+  bool operator()(bool a, bool b) {
+    return a || b;
+  }
+};
+
+template <typename U>
+struct Sum {
+  DEFINE_SIMD_REDUCE()
+
+  template <typename T>
+  T simd_reduce_impl(T val) {
+    return simd_sum(val);
+  }
+
+  static constexpr constant U init = U(0);
+
+  template <typename T>
+  void atomic_update(device mlx_atomic<T>* out, T val, size_t offset = 0) {
+    mlx_atomic_fetch_add_explicit(out, val, offset);
+  }
+
+  // Operator
+  U operator()(U a, U b) {
+    return a + b;
+  }
+};
+
+template <typename U>
+struct Prod {
+  DEFINE_SIMD_REDUCE()
+
+  template <typename T>
+  T simd_reduce_impl(T val) {
+    return simd_product(val);
+  }
+
+  static constexpr constant U init = U(1);
+
+  template <typename T>
+  void atomic_update(device mlx_atomic<T>* out, T val, size_t offset = 0) {
+    mlx_atomic_fetch_mul_explicit(out, val, offset);
+  }
+
+  // Operator
+  U operator()(U a, U b) {
+    return a * b;
+  }
+};
+
+template <typename U>
+struct Min {
+  DEFINE_SIMD_REDUCE()
+
+  template <typename T>
+  metal::enable_if_t<metal::is_integral_v<T>, T> simd_reduce_impl(T val) {
+    return simd_min(val);
+  }
+
+  template <typename T>
+  metal::enable_if_t<!metal::is_integral_v<T>, T> simd_reduce_impl(T val) {
+    if (simd_any(val != val)) {
+      return static_cast<T>(NAN);
+    }
+    return simd_min(val);
+  }
+
+  static constexpr constant U init = Limits<U>::max;
+
+  template <typename T>
+  void atomic_update(device mlx_atomic<T>* out, T val, size_t offset = 0) {
+    mlx_atomic_fetch_min_explicit(out, val, offset);
+  }
+
+  // Operator
+  template <typename T>
+  metal::enable_if_t<metal::is_integral_v<T>, T> operator()(T a, T b) {
+    return a < b ? a : b;
+  }
+
+  template <typename T>
+  metal::enable_if_t<!metal::is_integral_v<T>, T> operator()(T a, T b) {
+    if (metal::isnan(a) || metal::isnan(b)) {
+      return static_cast<T>(NAN);
+    } else {
+      return a < b ? a : b;
+    }
+  }
+
+  template <>
+  complex64_t operator()(complex64_t a, complex64_t b) {
+    bool real_is_nan = metal::isnan(a.real) || metal::isnan(b.real);
+    bool imag_is_nan = metal::isnan(a.imag) || metal::isnan(b.imag);
+
+    if (!real_is_nan && !imag_is_nan) {
+      return a < b ? a : b;
+    } else if (real_is_nan && !imag_is_nan) {
+      return complex64_t(
+          static_cast<float>(NAN), a.imag < b.imag ? a.imag : b.imag);
+    } else if (!real_is_nan && imag_is_nan) {
+      return complex64_t(
+          a.real < b.real ? a.real : b.real, static_cast<float>(NAN));
+    } else {
+      return complex64_t(static_cast<float>(NAN), static_cast<float>(NAN));
+    }
+  };
+};
+template <typename U>
+struct Max {
+  DEFINE_SIMD_REDUCE()
+
+  template <typename T>
+  metal::enable_if_t<metal::is_integral_v<T>, T> simd_reduce_impl(T val) {
+    return simd_max(val);
+  }
+
+  template <typename T>
+  metal::enable_if_t<!metal::is_integral_v<T>, T> simd_reduce_impl(T val) {
+    if (simd_any(val != val)) {
+      return static_cast<T>(NAN);
+    }
+    return simd_max(val);
+  }
+
+  static constexpr constant U init = Limits<U>::min;
+
+  template <typename T>
+  void atomic_update(device mlx_atomic<T>* out, T val, size_t offset = 0) {
+    mlx_atomic_fetch_max_explicit(out, val, offset);
+  }
+
+  // Operator
+  template <typename T>
+  metal::enable_if_t<metal::is_integral_v<T>, T> operator()(T a, T b) {
+    return a > b ? a : b;
+  }
+
+  template <typename T>
+  metal::enable_if_t<!metal::is_integral_v<T>, T> operator()(T a, T b) {
+    if (metal::isnan(a) || metal::isnan(b)) {
+      return static_cast<T>(NAN);
+    } else {
+      return a > b ? a : b;
+    }
+  }
+
+  template <>
+  complex64_t operator()(complex64_t a, complex64_t b) {
+    bool real_is_nan = metal::isnan(a.real) || metal::isnan(b.real);
+    bool imag_is_nan = metal::isnan(a.imag) || metal::isnan(b.imag);
+
+    if (!real_is_nan && !imag_is_nan) {
+      return a > b ? a : b;
+    } else if (real_is_nan && !imag_is_nan) {
+      return complex64_t(
+          static_cast<float>(NAN), a.imag > b.imag ? a.imag : b.imag);
+    } else if (!real_is_nan && imag_is_nan) {
+      return complex64_t(
+          a.real > b.real ? a.real : b.real, static_cast<float>(NAN));
+    } else {
+      return complex64_t(static_cast<float>(NAN), static_cast<float>(NAN));
+    }
+  }
+};
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/reduce_all.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/reduce_all.h
new file mode 100644
index 0000000000000000000000000000000000000000..e0d08392c0b0e7efd8c85f7191efafe3f9333ed7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/reduce_all.h
@@ -0,0 +1,66 @@
+// Copyright © 2023-2024 Apple Inc.
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    typename IdxT = int64_t,
+    int N_READS = REDUCE_N_READS>
+[[kernel]] void all_reduce(
+    const device T* in [[buffer(0)]],
+    device U* out [[buffer(1)]],
+    const constant size_t& in_size [[buffer(2)]],
+    const constant size_t& row_size [[buffer(3)]],
+    uint3 gid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint3 lsize [[threads_per_threadgroup]],
+    uint simd_per_group [[simdgroups_per_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  Op op;
+  threadgroup U shared_vals[simd_size];
+
+  U total = Op::init;
+  IdxT start_idx = gid.y * IdxT(row_size);
+  IdxT actual_row =
+      (start_idx + row_size <= in_size) ? row_size : in_size - start_idx;
+  IdxT blocks = actual_row / (lsize.x * N_READS);
+  int extra = actual_row - blocks * (lsize.x * N_READS);
+  extra -= lid.x * N_READS;
+  start_idx += lid.x * N_READS;
+  in += start_idx;
+
+  if (extra >= N_READS) {
+    blocks++;
+    extra = 0;
+  }
+
+  for (IdxT b = 0; b < blocks; b++) {
+    for (int i = 0; i < N_READS; i++) {
+      total = op(static_cast<U>(in[i]), total);
+    }
+    in += lsize.x * N_READS;
+  }
+  if (extra > 0) {
+    for (int i = 0; i < extra; i++) {
+      total = op(static_cast<U>(in[i]), total);
+    }
+  }
+
+  // Reduction within simd group
+  total = op.simd_reduce(total);
+  if (simd_per_group > 1) {
+    if (simd_lane_id == 0) {
+      shared_vals[simd_group_id] = total;
+    }
+
+    // Reduction within thread group
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    total = lid.x < simd_per_group ? shared_vals[lid.x] : op.init;
+    total = op.simd_reduce(total);
+  }
+
+  if (lid.x == 0) {
+    out[gid.y] = total;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/reduce_col.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/reduce_col.h
new file mode 100644
index 0000000000000000000000000000000000000000..c109faf0bce51f9f58a8218832f4726770877e3e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/reduce_col.h
@@ -0,0 +1,398 @@
+// Copyright © 2023-2024 Apple Inc.
+
+template <typename T, typename U, typename Op, typename IdxT, int NDIMS>
+[[kernel]] void col_reduce_small(
+    const device T* in [[buffer(0)]],
+    device U* out [[buffer(1)]],
+    const constant size_t& reduction_size [[buffer(2)]],
+    const constant int64_t& reduction_stride [[buffer(3)]],
+    const constant int* shape [[buffer(4)]],
+    const constant int64_t* strides [[buffer(5)]],
+    const constant int& ndim [[buffer(6)]],
+    const constant int* reduce_shape [[buffer(7)]],
+    const constant int64_t* reduce_strides [[buffer(8)]],
+    const constant int& reduce_ndim [[buffer(9)]],
+    const constant size_t& non_col_reductions [[buffer(10)]],
+    uint3 gid [[threadgroup_position_in_grid]],
+    uint3 gsize [[threadgroups_per_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint3 lsize [[threads_per_threadgroup]]) {
+  constexpr int n_reads = 4;
+  Op op;
+  LoopedElemToLoc<NDIMS, IdxT, (NDIMS > 2)> loop(reduce_ndim);
+  const device T* row;
+
+  U totals[n_reads];
+  for (int i = 0; i < n_reads; i++) {
+    totals[i] = Op::init;
+  }
+
+  IdxT column = IdxT(gid.x) * lsize.x * n_reads + lid.x * n_reads;
+  if (column >= reduction_stride) {
+    return;
+  }
+  bool safe = column + n_reads <= reduction_stride;
+
+  IdxT out_idx = gid.y + gsize.y * IdxT(gid.z);
+  IdxT in_idx = elem_to_loc<IdxT>(out_idx, shape, strides, ndim);
+  in += in_idx + column;
+
+  IdxT total_rows = IdxT(non_col_reductions) * IdxT(reduction_size);
+  loop.next(lid.y, reduce_shape, reduce_strides);
+  for (IdxT r = lid.y; r < total_rows; r += lsize.y) {
+    row = in + loop.location();
+    if (safe) {
+      for (int i = 0; i < n_reads; i++) {
+        totals[i] = op(static_cast<U>(row[i]), totals[i]);
+      }
+    } else {
+      U vals[n_reads];
+      for (int i = 0; i < n_reads; i++) {
+        vals[i] =
+            (column + i < reduction_stride) ? static_cast<U>(row[i]) : op.init;
+      }
+      for (int i = 0; i < n_reads; i++) {
+        totals[i] = op(vals[i], totals[i]);
+      }
+    }
+    loop.next(lsize.y, reduce_shape, reduce_strides);
+  }
+
+  if (lsize.y > 1) {
+    // lsize.y should be <= 8
+    threadgroup U shared_vals[32 * 8 * n_reads];
+    for (int i = 0; i < n_reads; i++) {
+      shared_vals[lid.y * lsize.x * n_reads + lid.x * n_reads + i] = totals[i];
+    }
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    if (lid.y == 0) {
+      for (int i = 0; i < n_reads; i++) {
+        totals[i] = shared_vals[lid.x * n_reads + i];
+      }
+      for (uint j = 1; j < lsize.y; j++) {
+        for (int i = 0; i < n_reads; i++) {
+          totals[i] =
+              op(shared_vals[j * lsize.x * n_reads + lid.x * n_reads + i],
+                 totals[i]);
+        }
+      }
+    }
+  }
+
+  if (lid.y == 0) {
+    out += out_idx * IdxT(reduction_stride) + column;
+    if (safe) {
+      for (int i = 0; i < n_reads; i++) {
+        out[i] = totals[i];
+      }
+    } else {
+      for (int i = 0; column + i < reduction_stride; i++) {
+        out[i] = totals[i];
+      }
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, typename IdxT, int NDIMS>
+[[kernel]] void col_reduce_longcolumn(
+    const device T* in [[buffer(0)]],
+    device U* out [[buffer(1)]],
+    const constant size_t& reduction_size [[buffer(2)]],
+    const constant size_t& reduction_stride [[buffer(3)]],
+    const constant int* shape [[buffer(4)]],
+    const constant int64_t* strides [[buffer(5)]],
+    const constant int& ndim [[buffer(6)]],
+    const constant int* reduce_shape [[buffer(7)]],
+    const constant int64_t* reduce_strides [[buffer(8)]],
+    const constant int& reduce_ndim [[buffer(9)]],
+    const constant size_t& non_col_reductions [[buffer(10)]],
+    const constant size_t& out_size [[buffer(11)]],
+    uint3 gid [[threadgroup_position_in_grid]],
+    uint3 gsize [[threadgroups_per_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint3 lsize [[threads_per_threadgroup]]) {
+  Op op;
+  LoopedElemToLoc<NDIMS, IdxT, (NDIMS > 2)> loop(reduce_ndim);
+  const device T* row;
+
+  IdxT out_idx = gid.x + gsize.x * IdxT(gid.y);
+  IdxT in_idx = elem_to_loc<IdxT>(out_idx, shape, strides, ndim);
+  in += in_idx + lid.x;
+
+  U total = Op::init;
+  IdxT total_rows = IdxT(non_col_reductions) * IdxT(reduction_size);
+  loop.next(gid.z * lsize.y + lid.y, reduce_shape, reduce_strides);
+  for (IdxT r = gid.z * lsize.y + lid.y; r < total_rows;
+       r += lsize.y * gsize.z) {
+    row = in + loop.location();
+    total = op(static_cast<U>(*row), total);
+    loop.next(lsize.y * gsize.z, reduce_shape, reduce_strides);
+  }
+
+  threadgroup U shared_vals[32 * 32];
+  shared_vals[lid.y * lsize.x + lid.x] = total;
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (lid.y == 0) {
+    for (uint i = 1; i < lsize.y; i++) {
+      total = op(total, shared_vals[i * lsize.x + lid.x]);
+    }
+    out[gid.z * IdxT(out_size) + out_idx * IdxT(reduction_stride) + lid.x] =
+        total;
+  }
+}
+
+/**
+ * Our approach is the following simple looped approach:
+ *  1. Each thread keeps running totals for BN / n_simdgroups outputs.
+ *  2. Load a tile BM, BN in registers and accumulate in the running totals
+ *  3. Move ahead by BM steps until the column axis and the non column
+ *     reductions are exhausted.
+ *  6. If BM == 32 then transpose in SM and simd reduce the running totals.
+ *     Otherwise write in shared memory and BN threads accumulate the running
+ *     totals with a loop.
+ *  7. Write them to the output
+ */
+template <
+    typename T,
+    typename U,
+    typename Op,
+    typename IdxT,
+    int NDIMS,
+    int BM,
+    int BN>
+[[kernel]] void col_reduce_looped(
+    const device T* in [[buffer(0)]],
+    device U* out [[buffer(1)]],
+    const constant size_t& reduction_size [[buffer(2)]],
+    const constant int64_t& reduction_stride [[buffer(3)]],
+    const constant int* shape [[buffer(4)]],
+    const constant int64_t* strides [[buffer(5)]],
+    const constant int& ndim [[buffer(6)]],
+    const constant int* reduce_shape [[buffer(7)]],
+    const constant int64_t* reduce_strides [[buffer(8)]],
+    const constant int& reduce_ndim [[buffer(9)]],
+    const constant size_t& non_col_reductions [[buffer(10)]],
+    uint3 gid [[threadgroup_position_in_grid]],
+    uint3 gsize [[threadgroups_per_grid]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  Op op;
+  constexpr int n_simdgroups = 8;
+  constexpr short tgp_size = n_simdgroups * simd_size;
+  constexpr short n_reads = (BM * BN) / tgp_size;
+  constexpr short n_read_blocks = BN / n_reads;
+
+  threadgroup U shared_vals[BN * BM];
+  U totals[n_reads];
+  LoopedElemToLoc<NDIMS, IdxT, (NDIMS > 2)> loop(reduce_ndim);
+  const device T* row;
+
+  for (int i = 0; i < n_reads; i++) {
+    totals[i] = Op::init;
+  }
+
+  short lid = simd_group_id * simd_size + simd_lane_id;
+  short2 offset((lid % n_read_blocks) * n_reads, lid / n_read_blocks);
+  IdxT column = BN * gid.x + offset.x;
+  bool safe = column + n_reads <= reduction_stride;
+
+  IdxT out_idx = gid.y + gsize.y * IdxT(gid.z);
+  IdxT in_idx = elem_to_loc<IdxT>(out_idx, shape, strides, ndim);
+  in += in_idx + column;
+
+  IdxT total = IdxT(non_col_reductions) * IdxT(reduction_size);
+  loop.next(offset.y, reduce_shape, reduce_strides);
+  for (IdxT r = offset.y; r < total; r += BM) {
+    row = in + loop.location();
+
+    if (safe) {
+      for (int i = 0; i < n_reads; i++) {
+        totals[i] = op(static_cast<U>(row[i]), totals[i]);
+      }
+    } else {
+      U vals[n_reads];
+      for (int i = 0; i < n_reads; i++) {
+        vals[i] =
+            (column + i < reduction_stride) ? static_cast<U>(row[i]) : op.init;
+      }
+      for (int i = 0; i < n_reads; i++) {
+        totals[i] = op(vals[i], totals[i]);
+      }
+    }
+
+    loop.next(BM, reduce_shape, reduce_strides);
+  }
+
+  // We can use a simd reduction to accumulate across BM so each thread writes
+  // the partial output to SM and then each simdgroup does BN / n_simdgroups
+  // accumulations.
+  if (BM == 32) {
+    constexpr int n_outputs = BN / n_simdgroups;
+    static_assert(
+        BM != 32 || n_outputs == n_reads,
+        "The tile should be selected such that n_outputs == n_reads");
+    for (int i = 0; i < n_reads; i++) {
+      shared_vals[offset.y * BN + offset.x + i] = totals[i];
+    }
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    short2 out_offset(simd_group_id * n_outputs, simd_lane_id);
+    for (int i = 0; i < n_outputs; i++) {
+      totals[i] =
+          op.simd_reduce(shared_vals[out_offset.y * BN + out_offset.x + i]);
+    }
+
+    // Write the output.
+    if (simd_lane_id == 0) {
+      IdxT out_column = BN * gid.x + out_offset.x;
+      out += out_idx * IdxT(reduction_stride) + out_column;
+      if (out_column + n_outputs <= reduction_stride) {
+        for (int i = 0; i < n_outputs; i++) {
+          out[i] = totals[i];
+        }
+      } else {
+        for (int i = 0; out_column + i < reduction_stride; i++) {
+          out[i] = totals[i];
+        }
+      }
+    }
+  }
+
+  // Each thread holds n_reads partial results. We write them all out to shared
+  // memory and threads with offset.y == 0 aggregate the columns and write the
+  // outputs.
+  else {
+    short x_block = offset.x / n_reads;
+    for (int i = 0; i < n_reads; i++) {
+      shared_vals[x_block * BM * n_reads + i * BM + offset.y] = totals[i];
+    }
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    if (offset.y == 0) {
+      for (int i = 0; i < n_reads; i++) {
+        for (int j = 1; j < BM; j++) {
+          totals[i] =
+              op(shared_vals[x_block * BM * n_reads + i * BM + j], totals[i]);
+        }
+      }
+    }
+
+    // Write the output.
+    if (offset.y == 0) {
+      out += out_idx * IdxT(reduction_stride) + column;
+      if (safe) {
+        for (int i = 0; i < n_reads; i++) {
+          out[i] = totals[i];
+        }
+      } else {
+        for (int i = 0; column + i < reduction_stride; i++) {
+          out[i] = totals[i];
+        }
+      }
+    }
+  }
+}
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    typename IdxT,
+    int NDIMS,
+    int BM,
+    int BN>
+[[kernel]] void col_reduce_2pass(
+    const device T* in [[buffer(0)]],
+    device U* out [[buffer(1)]],
+    const constant size_t& reduction_size [[buffer(2)]],
+    const constant int64_t& reduction_stride [[buffer(3)]],
+    const constant int* shape [[buffer(4)]],
+    const constant int64_t* strides [[buffer(5)]],
+    const constant int& ndim [[buffer(6)]],
+    const constant int* reduce_shape [[buffer(7)]],
+    const constant int64_t* reduce_strides [[buffer(8)]],
+    const constant int& reduce_ndim [[buffer(9)]],
+    const constant size_t& non_col_reductions [[buffer(10)]],
+    const constant size_t& out_size [[buffer(11)]],
+    uint3 gid [[threadgroup_position_in_grid]],
+    uint3 gsize [[threadgroups_per_grid]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  Op op;
+  constexpr int n_simdgroups = 8;
+  constexpr short tgp_size = n_simdgroups * simd_size;
+  constexpr short n_reads = (BM * BN) / tgp_size;
+  constexpr short n_read_blocks = BN / n_reads;
+  constexpr int n_outputs = BN / n_simdgroups;
+  constexpr short outer_blocks = 32;
+  static_assert(BM == 32, "BM should be equal to 32");
+
+  threadgroup U shared_vals[BN * BM];
+  U totals[n_reads];
+  LoopedElemToLoc<NDIMS, IdxT, (NDIMS > 2)> loop(reduce_ndim);
+  const device T* row;
+
+  for (int i = 0; i < n_reads; i++) {
+    totals[i] = Op::init;
+  }
+
+  short lid = simd_group_id * simd_size + simd_lane_id;
+  short2 offset((lid % n_read_blocks) * n_reads, lid / n_read_blocks);
+  IdxT column = BN * gid.x + offset.x;
+  bool safe = column + n_reads <= reduction_stride;
+
+  IdxT full_idx = gid.y + gsize.y * IdxT(gid.z);
+  IdxT block_idx = full_idx / IdxT(out_size);
+  IdxT out_idx = full_idx % IdxT(out_size);
+  IdxT in_idx = elem_to_loc<IdxT>(out_idx, shape, strides, ndim);
+  in += in_idx + column;
+
+  IdxT total = IdxT(non_col_reductions) * IdxT(reduction_size);
+  loop.next(offset.y + block_idx * BM, reduce_shape, reduce_strides);
+  for (IdxT r = offset.y + block_idx * BM; r < total; r += outer_blocks * BM) {
+    row = in + loop.location();
+
+    if (safe) {
+      for (int i = 0; i < n_reads; i++) {
+        totals[i] = op(static_cast<U>(row[i]), totals[i]);
+      }
+    } else {
+      U vals[n_reads];
+      for (int i = 0; i < n_reads; i++) {
+        vals[i] =
+            (column + i < reduction_stride) ? static_cast<U>(row[i]) : op.init;
+      }
+      for (int i = 0; i < n_reads; i++) {
+        totals[i] = op(vals[i], totals[i]);
+      }
+    }
+
+    loop.next(outer_blocks * BM, reduce_shape, reduce_strides);
+  }
+
+  // We can use a simd reduction to accumulate across BM so each thread writes
+  // the partial output to SM and then each simdgroup does BN / n_simdgroups
+  // accumulations.
+  for (int i = 0; i < n_reads; i++) {
+    shared_vals[offset.y * BN + offset.x + i] = totals[i];
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  short2 out_offset(simd_group_id * n_outputs, simd_lane_id);
+  for (int i = 0; i < n_outputs; i++) {
+    totals[i] =
+        op.simd_reduce(shared_vals[out_offset.y * BN + out_offset.x + i]);
+  }
+
+  // Write the output.
+  if (simd_lane_id == 0) {
+    IdxT out_column = BN * gid.x + out_offset.x;
+    out += full_idx * IdxT(reduction_stride) + out_column;
+    if (out_column + n_outputs <= reduction_stride) {
+      for (int i = 0; i < n_outputs; i++) {
+        out[i] = totals[i];
+      }
+    } else {
+      for (int i = 0; out_column + i < reduction_stride; i++) {
+        out[i] = totals[i];
+      }
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/reduce_init.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/reduce_init.h
new file mode 100644
index 0000000000000000000000000000000000000000..604efa785f63027071842e0c32cffb41dc5ebb7f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/reduce_init.h
@@ -0,0 +1,8 @@
+// Copyright © 2023-2024 Apple Inc.
+
+template <typename T, typename Op>
+[[kernel]] void init_reduce(
+    device T* out [[buffer(0)]],
+    uint tid [[thread_position_in_grid]]) {
+  out[tid] = Op::init;
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/reduce_row.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/reduce_row.h
new file mode 100644
index 0000000000000000000000000000000000000000..936d75bb52629f5ed54839a75bc81795f06e52ec
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/reduction/reduce_row.h
@@ -0,0 +1,369 @@
+// Copyright © 2023-2024 Apple Inc.
+
+// Row reduction utilities
+// - `per_thread_row_reduce` collaborative partial reduction in the threadgroup
+// - `threadgroup_reduce` collaborative reduction in the threadgroup such that
+//   lid.x == 0 holds the reduced value
+// - `thread_reduce` simple loop and reduce the row
+
+/**
+ * The thread group collaboratively reduces across the rows with bounds
+ * checking. In the end each thread holds a part of the reduction.
+ */
+template <
+    typename T,
+    typename U,
+    typename Op,
+    int N_READS = REDUCE_N_READS,
+    int N_WRITES = REDUCE_N_WRITES>
+METAL_FUNC void per_thread_row_reduce(
+    thread U totals[N_WRITES],
+    const device T* inputs[N_WRITES],
+    int blocks,
+    int extra,
+    uint lsize_x,
+    uint lid_x) {
+  Op op;
+
+  // Set up the accumulator registers
+  for (int i = 0; i < N_WRITES; i++) {
+    totals[i] = Op::init;
+  }
+
+  // Loop over the reduction size within thread group
+  for (int i = 0; i < blocks; i++) {
+    for (int j = 0; j < N_WRITES; j++) {
+      for (int i = 0; i < N_READS; i++) {
+        totals[j] = op(static_cast<U>(inputs[j][i]), totals[j]);
+      }
+
+      inputs[j] += lsize_x * N_READS;
+    }
+  }
+
+  // Separate case for the last set as we close the reduction size
+  int index = lid_x * N_READS;
+  if (index + N_READS <= extra) {
+    for (int j = 0; j < N_WRITES; j++) {
+      for (int i = 0; i < N_READS; i++) {
+        totals[j] = op(static_cast<U>(inputs[j][i]), totals[j]);
+      }
+    }
+  } else {
+    for (int j = 0; j < N_WRITES; j++) {
+      for (int i = 0; index + i < extra; i++) {
+        totals[j] = op(static_cast<U>(inputs[j][i]), totals[j]);
+      }
+    }
+  }
+}
+
+/**
+ * Consecutive rows in a contiguous array.
+ */
+template <
+    typename T,
+    typename U,
+    typename Op,
+    int N_READS = REDUCE_N_READS,
+    int N_WRITES = REDUCE_N_WRITES>
+METAL_FUNC void per_thread_row_reduce(
+    thread U totals[N_WRITES],
+    const device T* in,
+    const constant size_t& reduction_size,
+    int blocks,
+    int extra,
+    uint lsize_x,
+    uint lid_x) {
+  // Set up the input pointers
+  const device T* inputs[N_WRITES];
+  inputs[0] = in + lid_x * N_READS;
+  for (int i = 1; i < N_READS; i++) {
+    inputs[i] = inputs[i - 1] + reduction_size;
+  }
+
+  per_thread_row_reduce<T, U, Op, N_READS, N_WRITES>(
+      totals, inputs, blocks, extra, lsize_x, lid_x);
+}
+
+/**
+ * Consecutive rows in an arbitrarily ordered array.
+ */
+template <
+    typename T,
+    typename U,
+    typename Op,
+    int N_READS = REDUCE_N_READS,
+    int N_WRITES = REDUCE_N_WRITES>
+METAL_FUNC void per_thread_row_reduce(
+    thread U totals[N_WRITES],
+    const device T* in,
+    const int64_t row_idx,
+    int blocks,
+    int extra,
+    const constant int* shape,
+    const constant int64_t* strides,
+    const constant int& ndim,
+    uint lsize_x,
+    uint lid_x) {
+  // Set up the input pointers
+  const device T* inputs[N_WRITES];
+  in += lid_x * N_READS;
+  for (int i = 0; i < N_READS; i++) {
+    inputs[i] = in + elem_to_loc(row_idx + i, shape, strides, ndim);
+  }
+
+  per_thread_row_reduce<T, U, Op, N_READS, N_WRITES>(
+      totals, inputs, blocks, extra, lsize_x, lid_x);
+}
+
+/**
+ * Reduce within the threadgroup.
+ */
+template <
+    typename T,
+    typename U,
+    typename Op,
+    int N_READS = REDUCE_N_READS,
+    int N_WRITES = REDUCE_N_WRITES>
+METAL_FUNC void threadgroup_reduce(
+    thread U totals[N_WRITES],
+    threadgroup U* shared_vals,
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_per_group [[simdgroups_per_threadgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  Op op;
+
+  // Simdgroup first
+  for (int i = 0; i < N_WRITES; i++) {
+    totals[i] = op.simd_reduce(totals[i]);
+  }
+
+  // Across simdgroups
+  if (simd_per_group > 1) {
+    if (simd_lane_id == 0) {
+      for (int i = 0; i < N_WRITES; i++) {
+        shared_vals[simd_group_id * N_WRITES + i] = totals[i];
+      }
+    }
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    U values[N_WRITES];
+    for (int i = 0; i < N_WRITES; i++) {
+      values[i] = (lid.x < simd_per_group) ? shared_vals[lid.x * N_WRITES + i]
+                                           : op.init;
+    }
+
+    for (int i = 0; i < N_WRITES; i++) {
+      totals[i] = op.simd_reduce(values[i]);
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, int N_READS = REDUCE_N_READS>
+METAL_FUNC void
+thread_reduce(thread U& total, const device T* row, int blocks, int extra) {
+  Op op;
+  for (int i = 0; i < blocks; i++) {
+    U vals[N_READS];
+    for (int j = 0; j < N_READS; j++) {
+      vals[j] = row[j];
+    }
+    for (int j = 0; j < N_READS; j++) {
+      total = op(vals[j], total);
+    }
+    row += N_READS;
+  }
+  for (int i = 0; i < extra; i++) {
+    total = op(*row++, total);
+  }
+}
+
+// Reduction kernels
+// - `row_reduce_small` depending on the non-row reductions and row size it
+//   either just loops over everything or a simd collaboratively reduces the
+//   non_row reductions. In the first case one thread is responsible for one
+//   output on the 2nd one simd is responsible for one output.
+// - `row_reduce_simple` simple contiguous row reduction
+// - `row_reduce_looped` simply loop and reduce each row for each non-row
+//   reduction. One threadgroup is responsible for one output.
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    typename IdxT,
+    int NDIMS,
+    int N_READS = REDUCE_N_READS>
+[[kernel]] void row_reduce_small(
+    const device T* in [[buffer(0)]],
+    device U* out [[buffer(1)]],
+    const constant int64_t& row_size [[buffer(2)]],
+    const constant int64_t& non_row_reductions [[buffer(3)]],
+    const constant int* shape [[buffer(4)]],
+    const constant int64_t* strides [[buffer(5)]],
+    const constant int& ndim [[buffer(6)]],
+    const constant int* reduce_shape [[buffer(7)]],
+    const constant int64_t* reduce_strides [[buffer(8)]],
+    const constant int& reduce_ndim [[buffer(9)]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint3 gid [[threadgroup_position_in_grid]],
+    uint3 gsize [[threadgroups_per_grid]],
+    uint3 tid [[thread_position_in_grid]],
+    uint3 tsize [[threads_per_grid]]) {
+  Op op;
+
+  U total_val = Op::init;
+  LoopedElemToLoc<NDIMS, IdxT, (NDIMS > 2)> loop(reduce_ndim);
+
+  // Precompute some row reduction numbers
+  const device T* row;
+  int blocks = IdxT(row_size) / N_READS;
+  int extra = IdxT(row_size) % N_READS;
+
+  if ((non_row_reductions < 32 && row_size <= 8) || non_row_reductions <= 8) {
+    // Simple loop over non_row_reductions and reduce the row in the thread.
+    IdxT out_idx = tid.x + tsize.x * IdxT(tid.y);
+    in += elem_to_loc<IdxT>(out_idx, shape, strides, ndim);
+
+    for (uint r = 0; r < non_row_reductions; r++) {
+      row = in + loop.location();
+      thread_reduce<T, U, Op, N_READS>(total_val, row, blocks, extra);
+      loop.next(reduce_shape, reduce_strides);
+    }
+
+    out[out_idx] = total_val;
+  } else {
+    // Collaboratively reduce over non_row_reductions in the simdgroup. Each
+    // thread reduces every 32nd row and then a simple simd reduce.
+    IdxT out_idx = gid.y + gsize.y * IdxT(gid.z);
+    in += elem_to_loc<IdxT>(out_idx, shape, strides, ndim);
+
+    loop.next(simd_lane_id, reduce_shape, reduce_strides);
+
+    for (uint r = simd_lane_id; r < non_row_reductions; r += simd_size) {
+      row = in + loop.location();
+      thread_reduce<T, U, Op, N_READS>(total_val, row, blocks, extra);
+      loop.next(simd_size, reduce_shape, reduce_strides);
+    }
+
+    total_val = op.simd_reduce(total_val);
+
+    if (simd_lane_id == 0) {
+      out[out_idx] = total_val;
+    }
+  }
+}
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    typename IdxT = int64_t,
+    int N_READS = REDUCE_N_READS,
+    int N_WRITES = REDUCE_N_WRITES>
+[[kernel]] void row_reduce_simple(
+    const device T* in [[buffer(0)]],
+    device U* out [[buffer(1)]],
+    const constant size_t& reduction_size [[buffer(2)]],
+    const constant int64_t& out_size [[buffer(3)]],
+    uint3 gid [[threadgroup_position_in_grid]],
+    uint3 gsize [[threadgroups_per_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint3 lsize [[threads_per_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_per_group [[simdgroups_per_threadgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  threadgroup U shared_vals[simd_size * N_WRITES];
+  U totals[N_WRITES];
+
+  // Move to the row
+  IdxT out_idx = N_WRITES * (gid.y + gsize.y * IdxT(gid.z));
+  if (out_idx + N_WRITES > out_size) {
+    out_idx = out_size - N_WRITES;
+  }
+  in += out_idx * IdxT(reduction_size);
+  out += out_idx;
+
+  // Each thread reduces across the row
+  int blocks = IdxT(reduction_size) / (lsize.x * N_READS);
+  int extra = reduction_size - blocks * (lsize.x * N_READS);
+  per_thread_row_reduce<T, U, Op, N_READS, N_WRITES>(
+      totals, in, reduction_size, blocks, extra, lsize.x, lid.x);
+
+  // Reduce across the threadgroup
+  threadgroup_reduce<T, U, Op, N_READS, N_WRITES>(
+      totals, shared_vals, lid, simd_lane_id, simd_per_group, simd_group_id);
+
+  // Write the output
+  if (lid.x == 0) {
+    for (int i = 0; i < N_WRITES; i++) {
+      out[i] = totals[i];
+    }
+  }
+}
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    typename IdxT,
+    int NDIMS,
+    int N_READS = REDUCE_N_READS>
+[[kernel]] void row_reduce_looped(
+    const device T* in [[buffer(0)]],
+    device U* out [[buffer(1)]],
+    const constant int64_t& row_size [[buffer(2)]],
+    const constant int64_t& non_row_reductions [[buffer(3)]],
+    const constant int* shape [[buffer(4)]],
+    const constant int64_t* strides [[buffer(5)]],
+    const constant int& ndim [[buffer(6)]],
+    const constant int* reduce_shape [[buffer(7)]],
+    const constant int64_t* reduce_strides [[buffer(8)]],
+    const constant int& reduce_ndim [[buffer(9)]],
+    uint3 gid [[threadgroup_position_in_grid]],
+    uint3 gsize [[threadgroups_per_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint3 lsize [[threads_per_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_per_group [[simdgroups_per_threadgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  Op op;
+  threadgroup U shared_vals[simd_size];
+  U total = Op::init;
+
+  IdxT out_idx = gid.y + gsize.y * IdxT(gid.z);
+
+  // lid.x * N_READS breaks the per_thread_row_reduce interface a bit. Maybe it
+  // needs a small refactor.
+  in += elem_to_loc<IdxT>(out_idx, shape, strides, ndim) + lid.x * N_READS;
+
+  LoopedElemToLoc<NDIMS, IdxT, (NDIMS > 2)> loop(reduce_ndim);
+  const device T* row;
+  int blocks = IdxT(row_size) / (lsize.x * N_READS);
+  int extra = row_size - blocks * (lsize.x * N_READS);
+
+  for (IdxT i = 0; i < non_row_reductions; i++) {
+    row = in + loop.location();
+
+    // Each thread reduces across the row
+    U row_total;
+    per_thread_row_reduce<T, U, Op, N_READS, 1>(
+        &row_total, &row, blocks, extra, lsize.x, lid.x);
+
+    // Aggregate across rows
+    total = op(total, row_total);
+
+    loop.next(reduce_shape, reduce_strides);
+  }
+
+  // Reduce across the threadgroup
+  threadgroup_reduce<T, U, Op, N_READS, 1>(
+      &total, shared_vals, lid, simd_lane_id, simd_per_group, simd_group_id);
+
+  // Write the output
+  if (lid.x == 0) {
+    out[out_idx] = total;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/rms_norm.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/rms_norm.metal
new file mode 100644
index 0000000000000000000000000000000000000000..62f2457b728c015f92ba16a16a13fe11d37ed57d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/rms_norm.metal
@@ -0,0 +1,391 @@
+// Copyright © 2024 Apple Inc.
+
+#include <metal_common>
+#include <metal_simdgroup>
+
+#include "mlx/backend/metal/kernels/utils.h"
+
+using namespace metal;
+
+constant bool has_w [[function_constant(20)]];
+
+template <typename T, int N_READS = RMS_N_READS>
+[[kernel]] void rms_single_row(
+    const device T* x,
+    const device T* w,
+    device T* out,
+    constant float& eps,
+    constant uint& axis_size,
+    constant uint& w_stride,
+    uint gid [[threadgroup_position_in_grid]],
+    uint lid [[thread_position_in_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  constexpr int SIMD_SIZE = 32;
+
+  threadgroup float local_inv_mean[1];
+  threadgroup float local_sums[SIMD_SIZE];
+
+  float acc = 0;
+  x += gid * size_t(axis_size) + lid * N_READS;
+  w += w_stride * lid * N_READS;
+  if (lid * N_READS + N_READS <= axis_size) {
+    for (int i = 0; i < N_READS; i++) {
+      float xi = x[i];
+      acc += xi * xi;
+    }
+  } else {
+    for (int i = 0; i < N_READS; i++) {
+      if ((lid * N_READS + i) < axis_size) {
+        float xi = x[i];
+        acc += xi * xi;
+      }
+    }
+  }
+  acc = simd_sum(acc);
+  //  Initialize shared memory
+  if (simd_group_id == 0) {
+    local_sums[simd_lane_id] = 0;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // Write simd accumulations into shared memory
+  if (simd_lane_id == 0) {
+    local_sums[simd_group_id] = acc;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // Accumulate over simd groups
+  if (simd_group_id == 0) {
+    acc = simd_sum(local_sums[simd_lane_id]);
+    if (simd_lane_id == 0) {
+      local_inv_mean[0] = metal::precise::rsqrt(acc / axis_size + eps);
+    }
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // Write the outputs
+  out += gid * size_t(axis_size) + lid * N_READS;
+  if (lid * N_READS + N_READS <= axis_size) {
+    for (int i = 0; i < N_READS; i++) {
+      out[i] = w[w_stride * i] * static_cast<T>(x[i] * local_inv_mean[0]);
+    }
+  } else {
+    for (int i = 0; i < N_READS; i++) {
+      if ((lid * N_READS + i) < axis_size) {
+        out[i] = w[w_stride * i] * static_cast<T>(x[i] * local_inv_mean[0]);
+      }
+    }
+  }
+}
+
+template <typename T, int N_READS = RMS_N_READS>
+[[kernel]] void rms_looped(
+    const device T* x,
+    const device T* w,
+    device T* out,
+    constant float& eps,
+    constant uint& axis_size,
+    constant uint& w_stride,
+    uint gid [[threadgroup_position_in_grid]],
+    uint lid [[thread_position_in_threadgroup]],
+    uint lsize [[threads_per_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  constexpr int SIMD_SIZE = 32;
+  threadgroup float local_inv_mean[1];
+  threadgroup float local_sums[SIMD_SIZE];
+
+  float acc = 0;
+  x += gid * size_t(axis_size) + lid * N_READS;
+  w += w_stride * lid * N_READS;
+  for (uint r = 0; r < axis_size; r += lsize * N_READS) {
+    if (r + lid * N_READS + N_READS <= axis_size) {
+      for (int i = 0; i < N_READS; i++) {
+        float xi = x[i + r];
+        acc += xi * xi;
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        if ((r + lid * N_READS + i) < axis_size) {
+          float xi = x[i + r];
+          acc += xi * xi;
+        }
+      }
+    }
+  }
+  acc = simd_sum(acc);
+  //  Initialize shared memory
+  if (simd_group_id == 0) {
+    local_sums[simd_lane_id] = 0;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // Write simd accumulations into shared memory
+  if (simd_lane_id == 0) {
+    local_sums[simd_group_id] = acc;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // Accumulate over simd groups
+  if (simd_group_id == 0) {
+    acc = simd_sum(local_sums[simd_lane_id]);
+    if (simd_lane_id == 0) {
+      local_inv_mean[0] = metal::precise::rsqrt(acc / axis_size + eps);
+    }
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // Write the outputs
+  out += gid * size_t(axis_size) + lid * N_READS;
+  for (uint r = 0; r < axis_size; r += lsize * N_READS) {
+    if (r + lid * N_READS + N_READS <= axis_size) {
+      for (int i = 0; i < N_READS; i++) {
+        out[r + i] = w[w_stride * (i + r)] *
+            static_cast<T>(x[r + i] * local_inv_mean[0]);
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        if ((r + lid * N_READS + i) < axis_size) {
+          out[r + i] = w[w_stride * (i + r)] *
+              static_cast<T>(x[r + i] * local_inv_mean[0]);
+        }
+      }
+    }
+  }
+}
+
+template <typename T, int N_READS = RMS_N_READS>
+[[kernel]] void vjp_rms_single_row(
+    const device T* x,
+    const device T* w,
+    const device T* g,
+    device T* gx,
+    device T* gw,
+    constant float& eps,
+    constant uint& axis_size,
+    constant uint& w_stride,
+    uint gid [[threadgroup_position_in_grid]],
+    uint lid [[thread_position_in_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  // Advance the input pointers
+  x += gid * size_t(axis_size) + lid * N_READS;
+  g += gid * size_t(axis_size) + lid * N_READS;
+  w += w_stride * lid * N_READS;
+
+  // Allocate registers for the computation and accumulators
+  float thread_x[N_READS];
+  float thread_w[N_READS];
+  float thread_g[N_READS];
+  float sumx2 = 0;
+  float sumgwx = 0;
+
+  // Allocate shared memory to implement the reduction
+  constexpr int SIMD_SIZE = 32;
+  threadgroup float local_sumx2[SIMD_SIZE];
+  threadgroup float local_sumgwx[SIMD_SIZE];
+  threadgroup float local_normalizer[1];
+  threadgroup float local_meangwx[1];
+
+  // Read and accumulate locally
+  if (lid * N_READS + N_READS <= axis_size) {
+    for (int i = 0; i < N_READS; i++) {
+      thread_x[i] = x[i];
+      thread_w[i] = w[w_stride * i];
+      thread_g[i] = g[i];
+
+      sumx2 += thread_x[i] * thread_x[i];
+      sumgwx += thread_x[i] * thread_w[i] * thread_g[i];
+    }
+  } else {
+    for (int i = 0; i < N_READS; i++) {
+      if ((lid * N_READS + i) < axis_size) {
+        thread_x[i] = x[i];
+        thread_w[i] = w[w_stride * i];
+        thread_g[i] = g[i];
+
+        sumx2 += thread_x[i] * thread_x[i];
+        sumgwx += thread_x[i] * thread_w[i] * thread_g[i];
+      }
+    }
+  }
+
+  // Accumulate across threads
+  sumx2 = simd_sum(sumx2);
+  sumgwx = simd_sum(sumgwx);
+  if (simd_group_id == 0) {
+    local_sumx2[simd_lane_id] = 0;
+    local_sumgwx[simd_lane_id] = 0;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (simd_lane_id == 0) {
+    local_sumx2[simd_group_id] = sumx2;
+    local_sumgwx[simd_group_id] = sumgwx;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (simd_group_id == 0) {
+    sumx2 = simd_sum(local_sumx2[simd_lane_id]);
+    sumgwx = simd_sum(local_sumgwx[simd_lane_id]);
+    if (simd_lane_id == 0) {
+      local_meangwx[0] = sumgwx / axis_size;
+      local_normalizer[0] = metal::precise::rsqrt(sumx2 / axis_size + eps);
+    }
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  float meangwx = local_meangwx[0];
+  float normalizer = local_normalizer[0];
+  float normalizer3 = normalizer * normalizer * normalizer;
+
+  // Write the outputs
+  gx += gid * size_t(axis_size) + lid * N_READS;
+  gw += gid * size_t(axis_size) + lid * N_READS;
+  if (lid * N_READS + N_READS <= axis_size) {
+    for (int i = 0; i < N_READS; i++) {
+      gx[i] = static_cast<T>(
+          thread_g[i] * thread_w[i] * normalizer -
+          thread_x[i] * meangwx * normalizer3);
+      if (has_w) {
+        gw[i] = static_cast<T>(thread_g[i] * thread_x[i] * normalizer);
+      }
+    }
+  } else {
+    for (int i = 0; i < N_READS; i++) {
+      if ((lid * N_READS + i) < axis_size) {
+        gx[i] = static_cast<T>(
+            thread_g[i] * thread_w[i] * normalizer -
+            thread_x[i] * meangwx * normalizer3);
+        if (has_w) {
+          gw[i] = static_cast<T>(thread_g[i] * thread_x[i] * normalizer);
+        }
+      }
+    }
+  }
+}
+
+template <typename T, int N_READS = RMS_N_READS>
+[[kernel]] void vjp_rms_looped(
+    const device T* x,
+    const device T* w,
+    const device T* g,
+    device T* gx,
+    device T* gw,
+    constant float& eps,
+    constant uint& axis_size,
+    constant uint& w_stride,
+    uint gid [[threadgroup_position_in_grid]],
+    uint lid [[thread_position_in_threadgroup]],
+    uint lsize [[threads_per_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  // Advance the input pointers
+  x += gid * size_t(axis_size) + lid * N_READS;
+  g += gid * size_t(axis_size) + lid * N_READS;
+  w += w_stride * lid * N_READS;
+
+  // Allocate registers for the accumulators
+  float sumx2 = 0;
+  float sumgwx = 0;
+
+  // Allocate shared memory to implement the reduction
+  constexpr int SIMD_SIZE = 32;
+  threadgroup float local_sumx2[SIMD_SIZE];
+  threadgroup float local_sumgwx[SIMD_SIZE];
+  threadgroup float local_normalizer[1];
+  threadgroup float local_meangwx[1];
+
+  // Read and accumulate locally
+  for (uint r = 0; r < axis_size; r += lsize * N_READS) {
+    if (r + lid * N_READS + N_READS <= axis_size) {
+      for (int i = 0; i < N_READS; i++) {
+        float xi = x[i + r];
+        float wi = w[w_stride * (i + r)];
+        float gi = g[i + r];
+
+        sumx2 += xi * xi;
+        sumgwx += xi * wi * gi;
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        if ((r + lid * N_READS + i) < axis_size) {
+          float xi = x[i + r];
+          float wi = w[w_stride * (i + r)];
+          float gi = g[i + r];
+
+          sumx2 += xi * xi;
+          sumgwx += xi * wi * gi;
+        }
+      }
+    }
+  }
+
+  // Accumulate across threads
+  sumx2 = simd_sum(sumx2);
+  sumgwx = simd_sum(sumgwx);
+  if (simd_group_id == 0) {
+    local_sumx2[simd_lane_id] = 0;
+    local_sumgwx[simd_lane_id] = 0;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (simd_lane_id == 0) {
+    local_sumx2[simd_group_id] = sumx2;
+    local_sumgwx[simd_group_id] = sumgwx;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (simd_group_id == 0) {
+    sumx2 = simd_sum(local_sumx2[simd_lane_id]);
+    sumgwx = simd_sum(local_sumgwx[simd_lane_id]);
+    if (simd_lane_id == 0) {
+      local_meangwx[0] = sumgwx / axis_size;
+      local_normalizer[0] = metal::precise::rsqrt(sumx2 / axis_size + eps);
+    }
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  float meangwx = local_meangwx[0];
+  float normalizer = local_normalizer[0];
+  float normalizer3 = normalizer * normalizer * normalizer;
+
+  // Write the outputs
+  gx += gid * size_t(axis_size) + lid * N_READS;
+  gw += gid * size_t(axis_size) + lid * N_READS;
+  for (uint r = 0; r < axis_size; r += lsize * N_READS) {
+    if (r + lid * N_READS + N_READS <= axis_size) {
+      for (int i = 0; i < N_READS; i++) {
+        float xi = x[i + r];
+        float wi = w[w_stride * (i + r)];
+        float gi = g[i + r];
+
+        gx[i + r] =
+            static_cast<T>(gi * wi * normalizer - xi * meangwx * normalizer3);
+        if (has_w) {
+          gw[i + r] = static_cast<T>(gi * xi * normalizer);
+        }
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        if ((r + lid * N_READS + i) < axis_size) {
+          float xi = x[i + r];
+          float wi = w[w_stride * (i + r)];
+          float gi = g[i + r];
+
+          gx[i + r] =
+              static_cast<T>(gi * wi * normalizer - xi * meangwx * normalizer3);
+          if (has_w) {
+            gw[i + r] = static_cast<T>(gi * xi * normalizer);
+          }
+        }
+      }
+    }
+  }
+}
+
+// clang-format off
+#define instantiate_rms(name, itype)                                \
+  instantiate_kernel("rms" #name, rms_single_row, itype)            \
+  instantiate_kernel("vjp_rms" #name, vjp_rms_single_row, itype)    \
+  instantiate_kernel("rms_looped" #name, rms_looped, itype)         \
+  instantiate_kernel("vjp_rms_looped" #name, vjp_rms_looped, itype)
+
+instantiate_rms(float32, float)
+instantiate_rms(float16, half)
+instantiate_rms(bfloat16, bfloat16_t) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/rope.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/rope.metal
new file mode 100644
index 0000000000000000000000000000000000000000..fce444a1a7a9f8ec3c22d947755003b53d72c4a2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/rope.metal
@@ -0,0 +1,229 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <metal_math>
+
+#include "mlx/backend/metal/kernels/utils.h"
+
+constant bool forward [[function_constant(1)]];
+constant bool traditional [[function_constant(2)]];
+constant bool hs_transpose [[function_constant(3)]];
+
+template <typename T>
+void rope_single_impl(
+    const device T* in,
+    device T* out,
+    constant const int& offset,
+    const float inv_freq,
+    constant const float& scale,
+    constant const int64_t& stride,
+    uint2 pos,
+    uint2 grid) {
+  float L = scale * static_cast<float>(offset);
+
+  // Compute costheta, sintheta
+  float theta = L * inv_freq;
+  float costheta = metal::fast::cos(theta);
+  float sintheta = metal::fast::sin(theta);
+
+  // Compute the input and output indices
+  uint index_1, index_2;
+  if (traditional) {
+    index_1 = 2 * pos.x + pos.y * stride;
+    index_2 = index_1 + 1;
+  } else {
+    index_1 = pos.x + pos.y * stride;
+    index_2 = index_1 + grid.x;
+  }
+
+  // Read and write the output
+  float x1 = static_cast<float>(in[index_1]);
+  float x2 = static_cast<float>(in[index_2]);
+  float rx1;
+  float rx2;
+  if (forward) {
+    rx1 = x1 * costheta - x2 * sintheta;
+    rx2 = x1 * sintheta + x2 * costheta;
+  } else {
+    rx1 = x2 * sintheta + x1 * costheta;
+    rx2 = x2 * costheta - x1 * sintheta;
+  }
+  out[index_1] = static_cast<T>(rx1);
+  out[index_2] = static_cast<T>(rx2);
+}
+
+template <typename T>
+[[kernel]] void rope_single(
+    const device T* in [[buffer(0)]],
+    device T* out [[buffer(1)]],
+    constant const int& offset,
+    constant const float& scale,
+    constant const int64_t& stride,
+    constant const float& base [[buffer(10)]],
+    uint2 pos [[thread_position_in_grid]],
+    uint2 grid [[threads_per_grid]]) {
+  float d = static_cast<float>(pos.x) / static_cast<float>(grid.x);
+  float inv_freq = metal::exp2(-d * base);
+  rope_single_impl<T>(in, out, offset, inv_freq, scale, stride, pos, grid);
+}
+
+template <typename T>
+[[kernel]] void rope_single_freqs(
+    const device T* in [[buffer(0)]],
+    device T* out [[buffer(1)]],
+    constant const int& offset,
+    constant const float& scale,
+    constant const int64_t& stride,
+    const device float* freqs [[buffer(10)]],
+    constant const int64_t& freq_stride [[buffer(11)]],
+    uint2 pos [[thread_position_in_grid]],
+    uint2 grid [[threads_per_grid]]) {
+  float inv_freq = 1.0 / (freqs[freq_stride * pos.x]);
+  rope_single_impl<T>(in, out, offset, inv_freq, scale, stride, pos, grid);
+}
+
+template <typename T, typename IdxT, int N = 4>
+void rope_impl(
+    const device T* in,
+    device T* out,
+    const device int* offset,
+    const float inv_freq,
+    constant const float& scale,
+    constant const int64_t strides[3],
+    constant const int64_t out_strides[3],
+    constant const int64_t& offset_stride,
+    constant const int& n_head,
+    uint3 pos,
+    uint3 grid) {
+  auto n_head_up = N * ((n_head + N - 1) / N);
+  auto head_idx = static_cast<int>((pos.z * N) % n_head_up);
+  auto batch_idx = (pos.z * N) / n_head_up;
+  auto batch_offset = offset[batch_idx * offset_stride];
+  float L = scale * static_cast<float>(pos.y + batch_offset);
+  auto mat_idx = batch_idx * n_head + head_idx;
+
+  // Compute costheta, sintheta
+  float theta = L * inv_freq;
+  float costheta = metal::fast::cos(theta);
+  float sintheta = metal::fast::sin(theta);
+  // Compute the input and output indices
+  IdxT in_index_1;
+  if (hs_transpose) {
+    IdxT batch_stride = grid.y * IdxT(strides[1]);
+    in_index_1 =
+        batch_idx * batch_stride + pos.y * strides[1] + head_idx * strides[0];
+  } else {
+    in_index_1 = pos.y * IdxT(strides[1]) + mat_idx * IdxT(strides[0]);
+  }
+  IdxT in_index_2;
+  IdxT out_index_1 =
+      pos.y * IdxT(out_strides[1]) + mat_idx * IdxT(out_strides[0]);
+  IdxT out_index_2;
+  if (traditional) {
+    out_index_1 += 2 * pos.x * IdxT(out_strides[2]);
+    out_index_2 = out_index_1 + 1;
+    in_index_1 += 2 * pos.x * IdxT(strides[2]);
+    in_index_2 = in_index_1 + IdxT(strides[2]);
+  } else {
+    out_index_1 += pos.x * IdxT(out_strides[2]);
+    out_index_2 = out_index_1 + grid.x * IdxT(out_strides[2]);
+    in_index_1 += pos.x * IdxT(strides[2]);
+    in_index_2 = in_index_1 + grid.x * IdxT(strides[2]);
+  }
+  for (int i = 0; i < N && head_idx + i < n_head; ++i) {
+    // Read and write the output
+    float x1 = static_cast<float>(in[in_index_1]);
+    float x2 = static_cast<float>(in[in_index_2]);
+    float rx1;
+    float rx2;
+    if (forward) {
+      rx1 = x1 * costheta - x2 * sintheta;
+      rx2 = x1 * sintheta + x2 * costheta;
+    } else {
+      rx1 = x2 * sintheta + x1 * costheta;
+      rx2 = x2 * costheta - x1 * sintheta;
+    }
+    out[out_index_1] = static_cast<T>(rx1);
+    out[out_index_2] = static_cast<T>(rx2);
+    in_index_1 += IdxT(strides[0]);
+    in_index_2 += IdxT(strides[0]);
+    out_index_1 += IdxT(out_strides[0]);
+    out_index_2 += IdxT(out_strides[0]);
+  }
+}
+
+template <typename T, typename IdxT, int N = 4>
+[[kernel]] void rope(
+    const device T* in [[buffer(0)]],
+    device T* out [[buffer(1)]],
+    const device int* offset,
+    constant const float& scale,
+    constant const int64_t strides[3],
+    constant const int64_t out_strides[3],
+    constant const int64_t& offset_stride,
+    constant const int& n_head,
+    constant const float& base [[buffer(10)]],
+    uint3 pos [[thread_position_in_grid]],
+    uint3 grid [[threads_per_grid]]) {
+  float d = static_cast<float>(pos.x) / static_cast<float>(grid.x);
+  float inv_freq = metal::exp2(-d * base);
+  rope_impl<T, IdxT, N>(
+      in,
+      out,
+      offset,
+      inv_freq,
+      scale,
+      strides,
+      out_strides,
+      offset_stride,
+      n_head,
+      pos,
+      grid);
+}
+
+template <typename T, typename IdxT, int N = 4>
+[[kernel]] void rope_freqs(
+    const device T* in [[buffer(0)]],
+    device T* out [[buffer(1)]],
+    const device int* offset,
+    constant const float& scale,
+    constant const int64_t strides[3],
+    constant const int64_t out_strides[3],
+    constant const int64_t& offset_stride,
+    constant const int& n_head,
+    const device float* freqs [[buffer(10)]],
+    constant const int64_t& freq_stride [[buffer(11)]],
+    uint3 pos [[thread_position_in_grid]],
+    uint3 grid [[threads_per_grid]]) {
+  float inv_freq = 1.0 / (freqs[freq_stride * pos.x]);
+  rope_impl<T, IdxT, N>(
+      in,
+      out,
+      offset,
+      inv_freq,
+      scale,
+      strides,
+      out_strides,
+      offset_stride,
+      n_head,
+      pos,
+      grid);
+}
+
+// clang-format off
+#define instantiate_rope_g(name, type) \
+  instantiate_kernel("rope_" #name, rope, type, int32_t) \
+  instantiate_kernel("rope_freqs_" #name, rope_freqs, type, int32_t) \
+  instantiate_kernel("rope_large_" #name, rope, type, int64_t) \
+  instantiate_kernel("rope_freqs_large_" #name, rope_freqs, type, int64_t)
+
+#define instantiate_rope_s(name, type) \
+  instantiate_kernel("rope_single_" #name, rope_single, type) \
+  instantiate_kernel("rope_single_freqs_" #name, rope_single_freqs, type)
+
+#define instantiate_rope(name, type) \
+  instantiate_rope_s(name, type)     \
+  instantiate_rope_g(name, type)
+
+instantiate_rope(float16, half)
+instantiate_rope(bfloat16, bfloat16_t)
+instantiate_rope(float32, float) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/scaled_dot_product_attention.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/scaled_dot_product_attention.metal
new file mode 100644
index 0000000000000000000000000000000000000000..c668d9d8c574c866202fc43cee9e325d07c108b7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/scaled_dot_product_attention.metal
@@ -0,0 +1,44 @@
+#include <metal_stdlib>
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/sdpa_vector.h"
+
+using namespace metal;
+
+// SDPA vector instantiations
+#define instantiate_sdpa_vector_aggregation(type, value_dim) \
+  instantiate_kernel(                                        \
+      "sdpa_vector_2pass_2_" #type "_" #value_dim,           \
+      sdpa_vector_2pass_2,                                   \
+      type,                                                  \
+      value_dim)
+
+#define instantiate_sdpa_vector(type, qk_dim, value_dim)       \
+  instantiate_kernel(                                          \
+      "sdpa_vector_" #type "_" #qk_dim "_" #value_dim,         \
+      sdpa_vector,                                             \
+      type,                                                    \
+      qk_dim,                                                  \
+      value_dim)                                               \
+  instantiate_kernel(                                          \
+      "sdpa_vector_2pass_1_" #type "_" #qk_dim "_" #value_dim, \
+      sdpa_vector_2pass_1,                                     \
+      type,                                                    \
+      qk_dim,                                                  \
+      value_dim)
+
+#define instantiate_sdpa_vector_heads(type)      \
+  instantiate_sdpa_vector(type, 64, 64)          \
+  instantiate_sdpa_vector(type, 96, 96)          \
+  instantiate_sdpa_vector(type, 128, 128)        \
+  instantiate_sdpa_vector(type, 256, 256)        \
+  instantiate_sdpa_vector_aggregation(type, 64)  \
+  instantiate_sdpa_vector_aggregation(type, 96)  \
+  instantiate_sdpa_vector_aggregation(type, 128) \
+  instantiate_sdpa_vector_aggregation(type, 256)
+
+instantiate_sdpa_vector_heads(float)
+instantiate_sdpa_vector_heads(bfloat16_t)
+instantiate_sdpa_vector_heads(float16_t)
+    // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/scan.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/scan.h
new file mode 100644
index 0000000000000000000000000000000000000000..16682613b9a10d2b6076c3ee5934dffaa5d89b9d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/scan.h
@@ -0,0 +1,514 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/binary_ops.h"
+
+#define DEFINE_SIMD_SCAN()                                               \
+  template <typename T, metal::enable_if_t<sizeof(T) < 8, bool> = true>  \
+  T simd_scan(T val) {                                                   \
+    return simd_scan_impl(val);                                          \
+  }                                                                      \
+                                                                         \
+  template <typename T, metal::enable_if_t<sizeof(T) == 8, bool> = true> \
+  T simd_scan(T val) {                                                   \
+    for (int i = 1; i <= 16; i *= 2) {                                   \
+      val = operator()(val, simd_shuffle_and_fill_up(val, init, i));     \
+    }                                                                    \
+    return val;                                                          \
+  }
+
+#define DEFINE_SIMD_EXCLUSIVE_SCAN()                                     \
+  template <typename T, metal::enable_if_t<sizeof(T) < 8, bool> = true>  \
+  T simd_exclusive_scan(T val) {                                         \
+    return simd_exclusive_scan_impl(val);                                \
+  }                                                                      \
+                                                                         \
+  template <typename T, metal::enable_if_t<sizeof(T) == 8, bool> = true> \
+  T simd_exclusive_scan(T val) {                                         \
+    val = simd_scan(val);                                                \
+    return simd_shuffle_and_fill_up(val, init, 1);                       \
+  }
+
+template <typename U>
+struct CumSum {
+  DEFINE_SIMD_SCAN()
+  DEFINE_SIMD_EXCLUSIVE_SCAN()
+
+  static constexpr constant U init = static_cast<U>(0);
+
+  template <typename T>
+  U operator()(U a, T b) {
+    return a + b;
+  }
+
+  U simd_scan_impl(U x) {
+    return simd_prefix_inclusive_sum(x);
+  }
+
+  U simd_exclusive_scan_impl(U x) {
+    return simd_prefix_exclusive_sum(x);
+  }
+};
+
+template <typename U>
+struct CumProd {
+  DEFINE_SIMD_SCAN()
+  DEFINE_SIMD_EXCLUSIVE_SCAN()
+
+  static constexpr constant U init = static_cast<U>(1.0f);
+
+  template <typename T>
+  U operator()(U a, T b) {
+    return a * b;
+  }
+
+  U simd_scan_impl(U x) {
+    return simd_prefix_inclusive_product(x);
+  }
+
+  U simd_exclusive_scan_impl(U x) {
+    return simd_prefix_exclusive_product(x);
+  }
+};
+
+template <>
+struct CumProd<bool> {
+  static constexpr constant bool init = true;
+
+  template <typename T>
+  bool operator()(bool a, T b) {
+    return a & static_cast<bool>(b);
+  }
+
+  bool simd_scan(bool x) {
+    for (int i = 1; i <= 16; i *= 2) {
+      bool other = simd_shuffle_and_fill_up(x, init, i);
+      x &= other;
+    }
+    return x;
+  }
+
+  bool simd_exclusive_scan(bool x) {
+    x = simd_scan(x);
+    return simd_shuffle_and_fill_up(x, init, 1);
+  }
+};
+
+template <typename U>
+struct CumMax {
+  static constexpr constant U init = Limits<U>::min;
+
+  template <typename T>
+  U operator()(U a, T b) {
+    return (a >= b) ? a : b;
+  }
+
+  U simd_scan(U x) {
+    for (int i = 1; i <= 16; i *= 2) {
+      U other = simd_shuffle_and_fill_up(x, init, i);
+      x = (x >= other) ? x : other;
+    }
+    return x;
+  }
+
+  U simd_exclusive_scan(U x) {
+    x = simd_scan(x);
+    return simd_shuffle_and_fill_up(x, init, 1);
+  }
+};
+
+template <typename U>
+struct CumMin {
+  static constexpr constant U init = Limits<U>::max;
+
+  template <typename T>
+  U operator()(U a, T b) {
+    return (a <= b) ? a : b;
+  }
+
+  U simd_scan(U x) {
+    for (int i = 1; i <= 16; i *= 2) {
+      U other = simd_shuffle_and_fill_up(x, init, i);
+      x = (x <= other) ? x : other;
+    }
+    return x;
+  }
+
+  U simd_exclusive_scan(U x) {
+    x = simd_scan(x);
+    return simd_shuffle_and_fill_up(x, init, 1);
+  }
+};
+
+template <typename U>
+struct CumLogaddexp {
+  static constexpr constant U init = Limits<U>::min;
+
+  template <typename T>
+  U operator()(U a, T b) {
+    return LogAddExp{}(a, static_cast<U>(b));
+  }
+
+  U simd_scan(U x) {
+    for (int i = 1; i <= 16; i *= 2) {
+      U other = simd_shuffle_and_fill_up(x, init, i);
+      x = LogAddExp{}(x, other);
+    }
+    return x;
+  }
+
+  U simd_exclusive_scan(U x) {
+    x = simd_scan(x);
+    return simd_shuffle_and_fill_up(x, init, 1);
+  }
+};
+
+template <typename T, typename U, int N_READS, bool reverse>
+inline void load_unsafe(U values[N_READS], const device T* input) {
+  if (reverse) {
+    for (int i = 0; i < N_READS; i++) {
+      values[N_READS - i - 1] = input[i];
+    }
+  } else {
+    for (int i = 0; i < N_READS; i++) {
+      values[i] = input[i];
+    }
+  }
+}
+
+template <typename T, typename U, int N_READS, bool reverse>
+inline void load_safe(
+    U values[N_READS],
+    const device T* input,
+    int start,
+    int total,
+    U init) {
+  if (reverse) {
+    for (int i = 0; i < N_READS; i++) {
+      values[N_READS - i - 1] =
+          (start + N_READS - i - 1 < total) ? input[i] : init;
+    }
+  } else {
+    for (int i = 0; i < N_READS; i++) {
+      values[i] = (start + i < total) ? input[i] : init;
+    }
+  }
+}
+
+template <typename U, int N_READS, bool reverse>
+inline void write_unsafe(U values[N_READS], device U* out) {
+  if (reverse) {
+    for (int i = 0; i < N_READS; i++) {
+      out[i] = values[N_READS - i - 1];
+    }
+  } else {
+    for (int i = 0; i < N_READS; i++) {
+      out[i] = values[i];
+    }
+  }
+}
+
+template <typename U, int N_READS, bool reverse>
+inline void write_safe(U values[N_READS], device U* out, int start, int total) {
+  if (reverse) {
+    for (int i = 0; i < N_READS; i++) {
+      if (start + N_READS - i - 1 < total) {
+        out[i] = values[N_READS - i - 1];
+      }
+    }
+  } else {
+    for (int i = 0; i < N_READS; i++) {
+      if (start + i < total) {
+        out[i] = values[i];
+      }
+    }
+  }
+}
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    int N_READS,
+    bool inclusive,
+    bool reverse>
+[[kernel]] void contiguous_scan(
+    const device T* in [[buffer(0)]],
+    device U* out [[buffer(1)]],
+    const constant size_t& axis_size [[buffer(2)]],
+    uint3 gid [[threadgroup_position_in_grid]],
+    uint3 gsize [[threadgroups_per_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint3 lsize [[threads_per_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  constexpr int simd_size = 32;
+  Op op;
+
+  // Position the pointers
+  size_t offset = (gid.y + gsize.y * size_t(gid.z)) * axis_size;
+  in += offset;
+  out += offset;
+
+  // Compute the number of simd_groups
+  uint simd_groups = lsize.x / simd_size;
+
+  // Allocate memory
+  U prefix = Op::init;
+  U values[N_READS];
+  threadgroup U simdgroup_sums[32];
+
+  // Loop over the reduced axis in blocks of size ceildiv(axis_size,
+  // N_READS*lsize)
+  //    Read block
+  //    Compute inclusive scan of the block
+  //      Compute inclusive scan per thread
+  //      Compute exclusive scan of thread sums in simdgroup
+  //      Write simdgroup sums in SM
+  //      Compute exclusive scan of simdgroup sums
+  //      Compute the output by scanning prefix, prev_simdgroup, prev_thread,
+  //      value
+  //    Write block
+
+  for (uint r = 0; r < ceildiv(axis_size, N_READS * lsize.x); r++) {
+    // Compute the block offset
+    uint offset = r * lsize.x * N_READS + lid.x * N_READS;
+
+    // Read the values
+    if (reverse) {
+      if ((offset + N_READS) < axis_size) {
+        load_unsafe<T, U, N_READS, reverse>(
+            values, in + axis_size - offset - N_READS);
+      } else {
+        load_safe<T, U, N_READS, reverse>(
+            values,
+            in + axis_size - offset - N_READS,
+            offset,
+            axis_size,
+            Op::init);
+      }
+    } else {
+      if ((offset + N_READS) < axis_size) {
+        load_unsafe<T, U, N_READS, reverse>(values, in + offset);
+      } else {
+        load_safe<T, U, N_READS, reverse>(
+            values, in + offset, offset, axis_size, Op::init);
+      }
+    }
+
+    // Compute an inclusive scan per thread
+    for (int i = 1; i < N_READS; i++) {
+      values[i] = op(values[i], values[i - 1]);
+    }
+
+    // Compute exclusive scan of thread sums
+    U prev_thread = op.simd_exclusive_scan(values[N_READS - 1]);
+
+    // Write simdgroup_sums to SM
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    if (simd_lane_id == simd_size - 1) {
+      simdgroup_sums[simd_group_id] = op(prev_thread, values[N_READS - 1]);
+    }
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Compute exclusive scan of simdgroup_sums
+    if (simd_group_id == 0) {
+      U prev_simdgroup = op.simd_exclusive_scan(simdgroup_sums[simd_lane_id]);
+      simdgroup_sums[simd_lane_id] = prev_simdgroup;
+    }
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Compute the output
+    for (int i = 0; i < N_READS; i++) {
+      values[i] = op(values[i], prefix);
+      values[i] = op(values[i], simdgroup_sums[simd_group_id]);
+      values[i] = op(values[i], prev_thread);
+    }
+
+    // Write the values
+    if (reverse) {
+      if (inclusive) {
+        if ((offset + N_READS) < axis_size) {
+          write_unsafe<U, N_READS, reverse>(
+              values, out + axis_size - offset - N_READS);
+        } else {
+          write_safe<U, N_READS, reverse>(
+              values, out + axis_size - offset - N_READS, offset, axis_size);
+        }
+      } else {
+        if (lid.x == 0 && offset == 0) {
+          out[axis_size - 1] = Op::init;
+        }
+        if ((offset + N_READS + 1) < axis_size) {
+          write_unsafe<U, N_READS, reverse>(
+              values, out + axis_size - offset - 1 - N_READS);
+        } else {
+          write_safe<U, N_READS, reverse>(
+              values,
+              out + axis_size - offset - 1 - N_READS,
+              offset + 1,
+              axis_size);
+        }
+      }
+    } else {
+      if (inclusive) {
+        if ((offset + N_READS) < axis_size) {
+          write_unsafe<U, N_READS, reverse>(values, out + offset);
+        } else {
+          write_safe<U, N_READS, reverse>(
+              values, out + offset, offset, axis_size);
+        }
+      } else {
+        if (lid.x == 0 && offset == 0) {
+          out[0] = Op::init;
+        }
+        if ((offset + N_READS + 1) < axis_size) {
+          write_unsafe<U, N_READS, reverse>(values, out + offset + 1);
+        } else {
+          write_safe<U, N_READS, reverse>(
+              values, out + offset + 1, offset + 1, axis_size);
+        }
+      }
+    }
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Share the prefix
+    if (simd_group_id == simd_groups - 1 && simd_lane_id == simd_size - 1) {
+      simdgroup_sums[0] = values[N_READS - 1];
+    }
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    prefix = simdgroup_sums[0];
+  }
+}
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    int N_READS,
+    bool inclusive,
+    bool reverse>
+[[kernel]] void strided_scan(
+    const device T* in [[buffer(0)]],
+    device U* out [[buffer(1)]],
+    const constant size_t& axis_size [[buffer(2)]],
+    const constant size_t& stride [[buffer(3)]],
+    const constant size_t& stride_blocks [[buffer(4)]],
+    uint3 gid [[threadgroup_position_in_grid]],
+    uint3 gsize [[threadgroups_per_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  constexpr int simd_size = 32;
+  constexpr int BM = 32;
+  constexpr int BN = 32;
+  constexpr int BN_pad = 32 + 16 / sizeof(U);
+  constexpr int n_simds = BN / N_READS;
+  constexpr int n_scans = BN / n_simds;
+  Op op;
+
+  threadgroup U read_buffer[BM * BN_pad];
+  U values[n_scans];
+  U prefix[n_scans];
+  for (int i = 0; i < n_scans; i++) {
+    prefix[i] = Op::init;
+  }
+
+  // Compute offsets
+  size_t full_gid = gid.y + gsize.y * size_t(gid.z);
+  size_t offset = full_gid / stride_blocks * axis_size * stride;
+  size_t global_index_x = full_gid % stride_blocks * BN;
+  uint read_offset_y = (lid.x * N_READS) / BN;
+  uint read_offset_x = (lid.x * N_READS) % BN;
+  uint scan_offset_y = simd_lane_id;
+  uint scan_offset_x = simd_group_id * n_scans;
+
+  uint stride_limit = stride - global_index_x;
+  in += offset + global_index_x + read_offset_x;
+  out += offset + global_index_x + read_offset_x;
+  threadgroup U* read_into =
+      read_buffer + read_offset_y * BN_pad + read_offset_x;
+  threadgroup U* read_from =
+      read_buffer + scan_offset_y * BN_pad + scan_offset_x;
+
+  for (uint j = 0; j < axis_size; j += BM) {
+    // Calculate the indices for the current thread
+    uint index_y = j + read_offset_y;
+    uint check_index_y = index_y;
+    if (reverse) {
+      index_y = axis_size - 1 - index_y;
+    }
+
+    // Read in SM
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    if (check_index_y < axis_size && (read_offset_x + N_READS) < stride_limit) {
+      for (int i = 0; i < N_READS; i++) {
+        read_into[i] = in[index_y * stride + i];
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        if (check_index_y < axis_size && (read_offset_x + i) < stride_limit) {
+          read_into[i] = in[index_y * stride + i];
+        } else {
+          read_into[i] = Op::init;
+        }
+      }
+    }
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Read strided into registers
+    for (int i = 0; i < n_scans; i++) {
+      values[i] = read_from[i];
+    }
+    simdgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Perform the scan
+    for (int i = 0; i < n_scans; i++) {
+      values[i] = op.simd_scan(values[i]);
+      values[i] = op(values[i], prefix[i]);
+      prefix[i] = simd_shuffle(values[i], simd_size - 1);
+    }
+
+    // Write to SM
+    for (int i = 0; i < n_scans; i++) {
+      read_from[i] = values[i];
+    }
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Write to device memory
+    if (!inclusive) {
+      if (check_index_y == 0) {
+        if ((read_offset_x + N_READS) < stride_limit) {
+          for (int i = 0; i < N_READS; i++) {
+            out[index_y * stride + i] = Op::init;
+          }
+        } else {
+          for (int i = 0; i < N_READS; i++) {
+            if ((read_offset_x + i) < stride_limit) {
+              out[index_y * stride + i] = Op::init;
+            }
+          }
+        }
+      }
+      if (reverse) {
+        index_y -= 1;
+        check_index_y += 1;
+      } else {
+        index_y += 1;
+        check_index_y += 1;
+      }
+    }
+    if (check_index_y < axis_size && (read_offset_x + N_READS) < stride_limit) {
+      for (int i = 0; i < N_READS; i++) {
+        out[index_y * stride + i] = read_into[i];
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        if (check_index_y < axis_size && (read_offset_x + i) < stride_limit) {
+          out[index_y * stride + i] = read_into[i];
+        }
+      }
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/scan.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/scan.metal
new file mode 100644
index 0000000000000000000000000000000000000000..f38f8757ebff9b3acd2af08d0ae29b34467f01c3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/scan.metal
@@ -0,0 +1,108 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <metal_math>
+#include <metal_simdgroup>
+
+// clang-format off
+
+using namespace metal;
+
+#include "mlx/backend/metal/kernels/defines.h"
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/scan.h"
+
+#define instantiate_contiguous_scan(                                    \
+    name, itype, otype, op, inclusive, reverse, nreads)                 \
+  template [[host_name("contig_scan_" #name)]] [[kernel]] void          \
+  contiguous_scan<itype, otype, op<otype>, nreads, inclusive, reverse>( \
+      const device itype* in [[buffer(0)]],                             \
+      device otype* out [[buffer(1)]],                                  \
+      const constant size_t& axis_size [[buffer(2)]],                   \
+      uint3 gid [[threadgroup_position_in_grid]],                       \
+      uint3 gsize [[threadgroups_per_grid]],                            \
+      uint3 lid [[thread_position_in_threadgroup]],                     \
+      uint3 lsize [[threads_per_threadgroup]],                          \
+      uint simd_lane_id [[thread_index_in_simdgroup]],                  \
+      uint simd_group_id [[simdgroup_index_in_threadgroup]]);
+
+#define instantiate_strided_scan(                                    \
+    name, itype, otype, op, inclusive, reverse, nreads)              \
+  template [[host_name("strided_scan_" #name)]] [[kernel]] void      \
+  strided_scan<itype, otype, op<otype>, nreads, inclusive, reverse>( \
+      const device itype* in [[buffer(0)]],                          \
+      device otype* out [[buffer(1)]],                               \
+      const constant size_t& axis_size [[buffer(2)]],                \
+      const constant size_t& stride [[buffer(3)]],                   \
+      const constant size_t& stride_blocks [[buffer(4)]],            \
+      uint3 gid [[threadgroup_position_in_grid]],                    \
+      uint3 gsize [[threadgroups_per_grid]],                         \
+      uint3 lid [[thread_position_in_threadgroup]],                  \
+      uint simd_lane_id [[thread_index_in_simdgroup]],               \
+      uint simd_group_id [[simdgroup_index_in_threadgroup]]);
+
+#define instantiate_scan_helper(name, itype, otype, op, nreads)                                \
+  instantiate_contiguous_scan(inclusive_##name, itype, otype, op, true, false, nreads)         \
+  instantiate_contiguous_scan(exclusive_##name, itype, otype, op, false, false, nreads)        \
+  instantiate_contiguous_scan(reverse_inclusive_##name, itype, otype, op, true, true, nreads)  \
+  instantiate_contiguous_scan(reverse_exclusive_##name, itype, otype, op, false, true, nreads) \
+  instantiate_strided_scan(inclusive_##name, itype, otype, op, true, false, nreads)            \
+  instantiate_strided_scan(exclusive_##name, itype, otype, op, false, false, nreads)           \
+  instantiate_strided_scan(reverse_inclusive_##name, itype, otype, op, true, true, nreads)     \
+  instantiate_strided_scan(reverse_exclusive_##name, itype, otype, op, false, true, nreads)
+
+instantiate_scan_helper(sum_bool__int32,         bool,        int32_t,     CumSum, 4)
+instantiate_scan_helper(sum_uint8_uint8,         uint8_t,     uint8_t,     CumSum, 4)
+instantiate_scan_helper(sum_uint16_uint16,       uint16_t,    uint16_t,    CumSum, 4)
+instantiate_scan_helper(sum_uint32_uint32,       uint32_t,    uint32_t,    CumSum, 4)
+instantiate_scan_helper(sum_uint64_uint64,       uint64_t,    uint64_t,    CumSum, 2)
+instantiate_scan_helper(sum_int8_int8,           int8_t,      int8_t,      CumSum, 4)
+instantiate_scan_helper(sum_int16_int16,         int16_t,     int16_t,     CumSum, 4)
+instantiate_scan_helper(sum_int32_int32,         int32_t,     int32_t,     CumSum, 4)
+instantiate_scan_helper(sum_int64_int64,         int64_t,     int64_t,     CumSum, 2)
+instantiate_scan_helper(sum_float16_float16,     half,        half,        CumSum, 4)
+instantiate_scan_helper(sum_float32_float32,     float,       float,       CumSum, 4)
+instantiate_scan_helper(sum_bfloat16_bfloat16,   bfloat16_t,  bfloat16_t,  CumSum, 4)
+instantiate_scan_helper(sum_complex64_complex64, complex64_t, complex64_t, CumSum, 2)
+instantiate_scan_helper(prod_bool__bool_,         bool,        bool,        CumProd, 4)
+instantiate_scan_helper(prod_uint8_uint8,         uint8_t,     uint8_t,     CumProd, 4)
+instantiate_scan_helper(prod_uint16_uint16,       uint16_t,    uint16_t,    CumProd, 4)
+instantiate_scan_helper(prod_uint32_uint32,       uint32_t,    uint32_t,    CumProd, 4)
+instantiate_scan_helper(prod_uint64_uint64,       uint64_t,    uint64_t,    CumProd, 2)
+instantiate_scan_helper(prod_int8_int8,           int8_t,      int8_t,      CumProd, 4)
+instantiate_scan_helper(prod_int16_int16,         int16_t,     int16_t,     CumProd, 4)
+instantiate_scan_helper(prod_int32_int32,         int32_t,     int32_t,     CumProd, 4)
+instantiate_scan_helper(prod_int64_int64,         int64_t,     int64_t,     CumProd, 2)
+instantiate_scan_helper(prod_float16_float16,     half,        half,        CumProd, 4)
+instantiate_scan_helper(prod_float32_float32,     float,       float,       CumProd, 4)
+instantiate_scan_helper(prod_bfloat16_bfloat16,   bfloat16_t,  bfloat16_t,  CumProd, 4)
+instantiate_scan_helper(prod_complex64_complex64, complex64_t, complex64_t, CumProd, 2)
+instantiate_scan_helper(max_bool__bool_,         bool,        bool,        CumMax, 4)
+instantiate_scan_helper(max_uint8_uint8,         uint8_t,     uint8_t,     CumMax, 4)
+instantiate_scan_helper(max_uint16_uint16,       uint16_t,    uint16_t,    CumMax, 4)
+instantiate_scan_helper(max_uint32_uint32,       uint32_t,    uint32_t,    CumMax, 4)
+instantiate_scan_helper(max_uint64_uint64,       uint64_t,    uint64_t,    CumMax, 2)
+instantiate_scan_helper(max_int8_int8,           int8_t,      int8_t,      CumMax, 4)
+instantiate_scan_helper(max_int16_int16,         int16_t,     int16_t,     CumMax, 4)
+instantiate_scan_helper(max_int32_int32,         int32_t,     int32_t,     CumMax, 4)
+instantiate_scan_helper(max_int64_int64,         int64_t,     int64_t,     CumMax, 2)
+instantiate_scan_helper(max_float16_float16,     half,        half,        CumMax, 4)
+instantiate_scan_helper(max_float32_float32,     float,       float,       CumMax, 4)
+instantiate_scan_helper(max_bfloat16_bfloat16,   bfloat16_t,  bfloat16_t,  CumMax, 4)
+instantiate_scan_helper(max_complex64_complex64, complex64_t, complex64_t, CumMax, 2)
+instantiate_scan_helper(min_bool__bool_,         bool,        bool,        CumMin, 4)
+instantiate_scan_helper(min_uint8_uint8,         uint8_t,     uint8_t,     CumMin, 4)
+instantiate_scan_helper(min_uint16_uint16,       uint16_t,    uint16_t,    CumMin, 4)
+instantiate_scan_helper(min_uint32_uint32,       uint32_t,    uint32_t,    CumMin, 4)
+instantiate_scan_helper(min_uint64_uint64,       uint64_t,    uint64_t,    CumMin, 2)
+instantiate_scan_helper(min_int8_int8,           int8_t,      int8_t,      CumMin, 4)
+instantiate_scan_helper(min_int16_int16,         int16_t,     int16_t,     CumMin, 4)
+instantiate_scan_helper(min_int32_int32,         int32_t,     int32_t,     CumMin, 4)
+instantiate_scan_helper(min_int64_int64,         int64_t,     int64_t,     CumMin, 2)
+instantiate_scan_helper(min_float16_float16,     half,        half,        CumMin, 4)
+instantiate_scan_helper(min_float32_float32,     float,       float,       CumMin, 4)
+instantiate_scan_helper(min_bfloat16_bfloat16,   bfloat16_t,  bfloat16_t,  CumMin, 4)
+instantiate_scan_helper(min_complex64_complex64, complex64_t, complex64_t, CumMin, 2)
+instantiate_scan_helper(logaddexp_float16_float16,     half,        half,        CumLogaddexp, 4)
+instantiate_scan_helper(logaddexp_float32_float32,     float,       float,       CumLogaddexp, 4)
+instantiate_scan_helper(logaddexp_bfloat16_bfloat16,   bfloat16_t,  bfloat16_t,  CumLogaddexp, 4)
+instantiate_scan_helper(logaddexp_complex64_complex64, complex64_t, complex64_t, CumLogaddexp, 2) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/sdpa_vector.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/sdpa_vector.h
new file mode 100644
index 0000000000000000000000000000000000000000..96d22d8e410dac8bb1cb6b91d01a75b502230669
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/sdpa_vector.h
@@ -0,0 +1,415 @@
+// Copyright © 2024 Apple Inc.
+
+#include <metal_simdgroup>
+
+using namespace metal;
+
+constant bool has_mask [[function_constant(20)]];
+constant bool query_transposed [[function_constant(21)]];
+constant bool do_causal [[function_constant(22)]];
+constant bool bool_mask [[function_constant(23)]];
+constant bool float_mask [[function_constant(24)]];
+constant bool has_sinks [[function_constant(25)]];
+
+template <typename T, int D, int V = D>
+[[kernel]] void sdpa_vector(
+    const device T* queries [[buffer(0)]],
+    const device T* keys [[buffer(1)]],
+    const device T* values [[buffer(2)]],
+    device T* out [[buffer(3)]],
+    const constant int& gqa_factor [[buffer(4)]],
+    const constant int& N [[buffer(5)]],
+    const constant size_t& k_head_stride [[buffer(6)]],
+    const constant size_t& k_seq_stride [[buffer(7)]],
+    const constant size_t& v_head_stride [[buffer(8)]],
+    const constant size_t& v_seq_stride [[buffer(9)]],
+    const constant float& scale [[buffer(10)]],
+    const device bool* bmask [[buffer(11), function_constant(bool_mask)]],
+    const device T* fmask [[buffer(12), function_constant(float_mask)]],
+    const constant int& mask_kv_seq_stride
+    [[buffer(13), function_constant(has_mask)]],
+    const constant int& mask_q_seq_stride
+    [[buffer(14), function_constant(has_mask)]],
+    const constant int& mask_head_stride
+    [[buffer(15), function_constant(has_mask)]],
+    const device T* sinks [[buffer(16), function_constant(has_sinks)]],
+    const constant int& num_q_heads
+    [[buffer(17), function_constant(has_sinks)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 tpg [[threadgroups_per_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  constexpr int BN = 32;
+  constexpr int BD = 32;
+  constexpr int qk_per_thread = D / BD;
+  constexpr int v_per_thread = V / BD;
+  int inner_k_stride = BN * int(k_seq_stride);
+  int inner_v_stride = BN * int(v_seq_stride);
+
+  typedef float U;
+
+  thread U q[qk_per_thread];
+  thread U k[qk_per_thread];
+  thread U o[v_per_thread];
+
+  threadgroup U outputs[BN * BD];
+  threadgroup U max_scores[BN];
+  threadgroup U sum_exp_scores[BN];
+
+  // Adjust positions
+  const int q_batch_head_idx = tid.x;
+  const int q_seq_idx = tid.y;
+  const int kv_head_idx = q_batch_head_idx / gqa_factor;
+  const int o_offset = q_batch_head_idx * tpg.y + q_seq_idx;
+  const int q_offset =
+      query_transposed ? tpg.x * q_seq_idx + q_batch_head_idx : o_offset;
+  queries += q_offset * D + simd_lid * qk_per_thread;
+  keys += kv_head_idx * k_head_stride + simd_gid * k_seq_stride +
+      simd_lid * qk_per_thread;
+  values += kv_head_idx * v_head_stride + simd_gid * v_seq_stride +
+      simd_lid * v_per_thread;
+  if (bool_mask) {
+    bmask += q_batch_head_idx * mask_head_stride +
+        simd_gid * mask_kv_seq_stride + q_seq_idx * mask_q_seq_stride;
+  }
+  if (float_mask) {
+    fmask += q_batch_head_idx * mask_head_stride +
+        simd_gid * mask_kv_seq_stride + q_seq_idx * mask_q_seq_stride;
+  }
+
+  out += o_offset * V + simd_gid * v_per_thread;
+
+  // Read the query and 0 the output accumulator
+  for (int i = 0; i < qk_per_thread; i++) {
+    q[i] = static_cast<U>(scale) * queries[i];
+  }
+  for (int i = 0; i < v_per_thread; i++) {
+    o[i] = 0;
+  }
+
+  U max_score = Limits<U>::finite_min;
+  U sum_exp_score = 0;
+  if (has_sinks && simd_gid == 0) {
+    max_score = static_cast<U>(sinks[q_batch_head_idx % num_q_heads]);
+    sum_exp_score = 1;
+  }
+
+  // For each key
+  for (int i = simd_gid; i < N; i += BN) {
+    bool use_key = true;
+    if (do_causal) {
+      use_key = i <= (N - int(tpg.y) + int(q_seq_idx));
+    } else if (bool_mask) {
+      use_key = bmask[0];
+    } else if (float_mask) {
+      use_key = (fmask[0] >= Limits<T>::finite_min);
+    }
+    if (use_key) {
+      // Read the key
+      for (int j = 0; j < qk_per_thread; j++) {
+        k[j] = keys[j];
+      }
+
+      // Compute the i-th score
+      U score = 0;
+      for (int j = 0; j < qk_per_thread; j++) {
+        score += q[j] * k[j];
+      }
+      score = simd_sum(score);
+      if (float_mask) {
+        score += static_cast<U>(fmask[0]);
+      }
+
+      // Update the accumulators
+      U new_max = max(max_score, score);
+      U factor = fast::exp(max_score - new_max);
+      U exp_score = fast::exp(score - new_max);
+
+      max_score = new_max;
+      sum_exp_score = sum_exp_score * factor + exp_score;
+
+      // Update the output accumulator
+      for (int j = 0; j < v_per_thread; j++) {
+        o[j] = o[j] * factor + exp_score * values[j];
+      }
+    }
+
+    // Move the pointers to the next kv
+    keys += inner_k_stride;
+    values += inner_v_stride;
+    if (bool_mask) {
+      bmask += BN * mask_kv_seq_stride;
+    }
+    if (float_mask) {
+      fmask += BN * mask_kv_seq_stride;
+    }
+  }
+
+  // Each thread has a partial part of the output so we need to combine them.
+
+  // First let's communicate the max and sum_exp
+  if (simd_lid == 0) {
+    max_scores[simd_gid] = max_score;
+    sum_exp_scores[simd_gid] = sum_exp_score;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  max_score = max_scores[simd_lid];
+  U new_max = simd_max(max_score);
+  U factor = fast::exp(max_score - new_max);
+  sum_exp_score = simd_sum(sum_exp_scores[simd_lid] * factor);
+
+  // Now we need to aggregate all the outputs
+  for (int i = 0; i < v_per_thread; i++) {
+    outputs[simd_lid * BD + simd_gid] = o[i];
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    o[i] = simd_sum(outputs[simd_gid * BD + simd_lid] * factor);
+    o[i] = sum_exp_score == 0 ? o[i] : (o[i] / sum_exp_score);
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+  }
+
+  // And write the output
+  if (simd_lid == 0) {
+    for (int i = 0; i < v_per_thread; i++) {
+      out[i] = static_cast<T>(o[i]);
+    }
+  }
+}
+
+template <typename T, int D, int V = D>
+[[kernel]] void sdpa_vector_2pass_1(
+    const device T* queries [[buffer(0)]],
+    const device T* keys [[buffer(1)]],
+    const device T* values [[buffer(2)]],
+    device float* out [[buffer(3)]],
+    device float* sums [[buffer(4)]],
+    device float* maxs [[buffer(5)]],
+    const constant int& gqa_factor [[buffer(6)]],
+    const constant int& N [[buffer(7)]],
+    const constant size_t& k_head_stride [[buffer(8)]],
+    const constant size_t& k_seq_stride [[buffer(9)]],
+    const constant size_t& v_head_stride [[buffer(10)]],
+    const constant size_t& v_seq_stride [[buffer(11)]],
+    const constant float& scale [[buffer(12)]],
+    const device bool* bmask [[buffer(13), function_constant(bool_mask)]],
+    const device T* fmask [[buffer(14), function_constant(float_mask)]],
+    const constant int& mask_kv_seq_stride
+    [[buffer(15), function_constant(has_mask)]],
+    const constant int& mask_q_seq_stride
+    [[buffer(16), function_constant(has_mask)]],
+    const constant int& mask_head_stride
+    [[buffer(17), function_constant(has_mask)]],
+    const device T* sinks [[buffer(18), function_constant(has_sinks)]],
+    const constant int& num_q_heads
+    [[buffer(19), function_constant(has_sinks)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 tpg [[threadgroups_per_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  constexpr int BN = 8;
+  constexpr int BD = 32;
+  constexpr int qk_per_thread = D / BD;
+  constexpr int v_per_thread = V / BD;
+  int inner_k_stride = BN * int(k_seq_stride);
+  int inner_v_stride = BN * int(v_seq_stride);
+  constexpr int blocks = 32;
+
+  typedef float U;
+
+  thread U q[qk_per_thread];
+  thread U k[qk_per_thread];
+  thread U o[v_per_thread];
+
+  threadgroup U outputs[BN * BD];
+  threadgroup U max_scores[BN];
+  threadgroup U sum_exp_scores[BN];
+
+  // Adjust positions
+  const int block_idx = tid.z;
+  const int q_batch_head_idx = tid.x;
+  const int q_seq_idx = tid.y;
+  const int o_offset = q_batch_head_idx * tpg.y + q_seq_idx;
+  const int q_offset =
+      query_transposed ? tpg.x * q_seq_idx + q_batch_head_idx : o_offset;
+  const int kv_head_idx = q_batch_head_idx / gqa_factor;
+
+  queries += q_offset * D + simd_lid * qk_per_thread;
+  keys += kv_head_idx * k_head_stride +
+      (block_idx * BN + simd_gid) * k_seq_stride + simd_lid * qk_per_thread;
+  values += kv_head_idx * v_head_stride +
+      (block_idx * BN + simd_gid) * v_seq_stride + simd_lid * v_per_thread;
+  out += o_offset * blocks * V + block_idx * V + simd_lid * v_per_thread;
+  if (bool_mask) {
+    bmask += q_batch_head_idx * mask_head_stride +
+        (block_idx * BN + simd_gid) * mask_kv_seq_stride +
+        q_seq_idx * mask_q_seq_stride;
+  }
+  if (float_mask) {
+    fmask += q_batch_head_idx * mask_head_stride +
+        (block_idx * BN + simd_gid) * mask_kv_seq_stride +
+        q_seq_idx * mask_q_seq_stride;
+  }
+  sums += o_offset * blocks + block_idx;
+  maxs += o_offset * blocks + block_idx;
+
+  // Read the query and 0 the output accumulator
+  for (int i = 0; i < qk_per_thread; i++) {
+    q[i] = static_cast<U>(scale) * queries[i];
+  }
+  for (int i = 0; i < v_per_thread; i++) {
+    o[i] = 0;
+  }
+
+  U max_score = Limits<U>::finite_min;
+  U sum_exp_score = 0;
+  if (has_sinks && block_idx == 0 && simd_gid == 0) {
+    int q_head_idx = q_batch_head_idx % num_q_heads;
+    max_score = static_cast<U>(sinks[q_head_idx]);
+    sum_exp_score = 1;
+  }
+
+  // For each key
+  for (int i = block_idx * BN + simd_gid; i < N; i += blocks * BN) {
+    bool use_key = true;
+    if (do_causal) {
+      use_key = i <= (N - int(tpg.y) + int(q_seq_idx));
+    } else if (bool_mask) {
+      use_key = bmask[0];
+    } else if (float_mask) {
+      use_key = (fmask[0] >= Limits<T>::finite_min);
+    }
+    if (use_key) {
+      // Read the key
+      for (int i = 0; i < qk_per_thread; i++) {
+        k[i] = keys[i];
+      }
+
+      // Compute the i-th score
+      U score = 0;
+      for (int i = 0; i < qk_per_thread; i++) {
+        score += q[i] * k[i];
+      }
+      score = simd_sum(score);
+
+      if (float_mask) {
+        score += fmask[0];
+      }
+
+      // Update the accumulators
+      U new_max = max(max_score, score);
+      U factor = fast::exp(max_score - new_max);
+      U exp_score = fast::exp(score - new_max);
+
+      max_score = new_max;
+      sum_exp_score = sum_exp_score * factor + exp_score;
+
+      // Update the output accumulator
+      for (int i = 0; i < v_per_thread; i++) {
+        o[i] = o[i] * factor + exp_score * values[i];
+      }
+    }
+
+    // Move the pointers to the next kv
+    keys += blocks * inner_k_stride;
+    values += blocks * inner_v_stride;
+    if (bool_mask) {
+      bmask += BN * blocks * mask_kv_seq_stride;
+    }
+    if (float_mask) {
+      fmask += BN * blocks * mask_kv_seq_stride;
+    }
+  }
+
+  // Each thread has a partial part of the output so we need to combine them.
+
+  // First let's communicate the max and sum_exp
+  if (simd_lid == 0) {
+    max_scores[simd_gid] = max_score;
+    sum_exp_scores[simd_gid] = sum_exp_score;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  max_score = (simd_lid < BN) ? max_scores[simd_lid] : -1e9;
+  U new_max = simd_max(max_score);
+  U factor = fast::exp(max_score - new_max);
+  sum_exp_score = (simd_lid < BN) ? sum_exp_scores[simd_lid] : 0;
+  sum_exp_score = simd_sum(sum_exp_score * factor);
+
+  // Write the sum and new max
+  if (simd_gid == 0) {
+    sums[0] = sum_exp_score;
+    maxs[0] = new_max;
+  }
+
+  // Now we need to aggregate all the outputs
+  for (int i = 0; i < v_per_thread; i++) {
+    outputs[simd_lid * BN + simd_gid] =
+        o[i] * fast::exp(max_scores[simd_gid] - new_max);
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // And write the output
+    if (simd_gid == 0) {
+      U output = outputs[simd_lid * BN];
+      for (int j = 1; j < BN; j++) {
+        output += outputs[simd_lid * BN + j];
+      }
+      out[i] = static_cast<T>(output);
+    }
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+  }
+}
+
+template <typename T, int D>
+[[kernel]] void sdpa_vector_2pass_2(
+    const device float* partials [[buffer(0)]],
+    const device float* sums [[buffer(1)]],
+    const device float* maxs [[buffer(2)]],
+    device T* out [[buffer(3)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 tpg [[threadgroups_per_grid]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  constexpr int BN = 32;
+  constexpr int BD = 32;
+  constexpr int elem_per_thread = D / BD;
+  constexpr int blocks = 32;
+
+  typedef float U;
+
+  thread U o[elem_per_thread];
+  threadgroup U outputs[BN * BD];
+
+  // Adjust positions
+  const int head_idx = tid.x;
+  const int q_seq_idx = tid.y;
+  const int q_offset = head_idx * tpg.y + q_seq_idx;
+  ;
+  partials += q_offset * blocks * D + simd_gid * D + simd_lid * elem_per_thread;
+  sums += q_offset * blocks;
+  maxs += q_offset * blocks;
+  out += q_offset * D + simd_gid * elem_per_thread;
+
+  // First everybody reads the max and sum_exp
+  U max_score = maxs[simd_lid];
+  U new_max = simd_max(max_score);
+  U factor = fast::exp(max_score - new_max);
+  U sum_exp_score = simd_sum(sums[simd_lid] * factor);
+
+  // Now read the block into registers and then use shared memory to transpose
+  // it
+  for (int i = 0; i < elem_per_thread; i++) {
+    o[i] = partials[i];
+  }
+  for (int i = 0; i < elem_per_thread; i++) {
+    outputs[simd_lid * BD + simd_gid] = o[i];
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    o[i] = simd_sum(outputs[simd_gid * BD + simd_lid] * factor);
+    o[i] = sum_exp_score == 0 ? o[i] : (o[i] / sum_exp_score);
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+  }
+
+  // And write the output
+  if (simd_lid == 0) {
+    for (int i = 0; i < elem_per_thread; i++) {
+      out[i] = static_cast<T>(o[i]);
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/softmax.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/softmax.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ea4ac7329cf14b0df61b288c31d2711608d14e0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/softmax.h
@@ -0,0 +1,190 @@
+// Copyright © 2023-2024 Apple Inc.
+
+template <typename T>
+inline T softmax_exp(T x) {
+  // Softmax doesn't need high precision exponential cause x is gonna be in
+  // (-oo, 0] anyway and subsequently it will be divided by sum(exp(x_i)).
+  return fast::exp(x);
+}
+
+template <typename T, typename AccT = T, int N_READS = SOFTMAX_N_READS>
+[[kernel]] void softmax_single_row(
+    const device T* in,
+    device T* out,
+    constant int& axis_size,
+    uint gid [[threadgroup_position_in_grid]],
+    uint _lid [[thread_position_in_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  int lid = _lid;
+
+  constexpr int SIMD_SIZE = 32;
+
+  threadgroup AccT local_max[SIMD_SIZE];
+  threadgroup AccT local_normalizer[SIMD_SIZE];
+
+  AccT ld[N_READS];
+
+  in += gid * size_t(axis_size) + lid * N_READS;
+  if (lid * N_READS + N_READS <= axis_size) {
+    for (int i = 0; i < N_READS; i++) {
+      ld[i] = AccT(in[i]);
+    }
+  } else {
+    for (int i = 0; i < N_READS; i++) {
+      ld[i] =
+          ((lid * N_READS + i) < axis_size) ? AccT(in[i]) : Limits<AccT>::min;
+    }
+  }
+  if (simd_group_id == 0) {
+    local_max[simd_lane_id] = Limits<AccT>::min;
+    local_normalizer[simd_lane_id] = 0;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // Get the max
+  AccT maxval = Limits<AccT>::finite_min;
+  for (int i = 0; i < N_READS; i++) {
+    maxval = (maxval < ld[i]) ? ld[i] : maxval;
+  }
+  maxval = simd_max(maxval);
+  if (simd_lane_id == 0) {
+    local_max[simd_group_id] = maxval;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (simd_group_id == 0) {
+    maxval = simd_max(local_max[simd_lane_id]);
+    if (simd_lane_id == 0) {
+      local_max[0] = maxval;
+    }
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  maxval = local_max[0];
+
+  // Compute exp(x_i - maxval) and store the partial sums in local_normalizer
+  AccT normalizer = 0;
+  for (int i = 0; i < N_READS; i++) {
+    AccT exp_x = softmax_exp(ld[i] - maxval);
+    ld[i] = exp_x;
+    normalizer += exp_x;
+  }
+  normalizer = simd_sum(normalizer);
+  if (simd_lane_id == 0) {
+    local_normalizer[simd_group_id] = normalizer;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  if (simd_group_id == 0) {
+    normalizer = simd_sum(local_normalizer[simd_lane_id]);
+    if (simd_lane_id == 0) {
+      local_normalizer[0] = normalizer;
+    }
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  normalizer = 1 / local_normalizer[0];
+
+  // Normalize and write to the output
+  out += gid * size_t(axis_size) + lid * N_READS;
+  if (lid * N_READS + N_READS <= axis_size) {
+    for (int i = 0; i < N_READS; i++) {
+      out[i] = T(ld[i] * normalizer);
+    }
+  } else {
+    for (int i = 0; i < N_READS; i++) {
+      if ((lid * N_READS + i) < axis_size) {
+        out[i] = T(ld[i] * normalizer);
+      }
+    }
+  }
+}
+
+template <typename T, typename AccT = T, int N_READS = SOFTMAX_N_READS>
+[[kernel]] void softmax_looped(
+    const device T* in,
+    device T* out,
+    constant int& axis_size,
+    uint gid [[threadgroup_position_in_grid]],
+    uint lid [[thread_position_in_threadgroup]],
+    uint lsize [[threads_per_threadgroup]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]]) {
+  in += gid * size_t(axis_size);
+
+  constexpr int SIMD_SIZE = 32;
+
+  threadgroup AccT local_max[SIMD_SIZE];
+  threadgroup AccT local_normalizer[SIMD_SIZE];
+
+  // Get the max and the normalizer in one go
+  AccT prevmax;
+  AccT maxval = Limits<AccT>::finite_min;
+  AccT normalizer = 0;
+  for (int r = 0; r < static_cast<int>(ceildiv(axis_size, N_READS * lsize));
+       r++) {
+    int offset = r * lsize * N_READS + lid * N_READS;
+    AccT vals[N_READS];
+    if (offset + N_READS <= axis_size) {
+      for (int i = 0; i < N_READS; i++) {
+        vals[i] = AccT(in[offset + i]);
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        vals[i] =
+            (offset + i < axis_size) ? AccT(in[offset + i]) : Limits<AccT>::min;
+      }
+    }
+    prevmax = maxval;
+    for (int i = 0; i < N_READS; i++) {
+      maxval = (maxval < vals[i]) ? vals[i] : maxval;
+    }
+    normalizer *= softmax_exp(prevmax - maxval);
+    for (int i = 0; i < N_READS; i++) {
+      normalizer += softmax_exp(vals[i] - maxval);
+    }
+  }
+  // Now we got partial normalizer of N_READS * ceildiv(axis_size, N_READS *
+  // lsize) parts. We need to combine them.
+  //    1. We start by finding the max across simd groups
+  //    2. We then change the partial normalizers to account for a possible
+  //       change in max
+  //    3. We sum all normalizers
+  prevmax = maxval;
+  maxval = simd_max(maxval);
+  normalizer *= softmax_exp(prevmax - maxval);
+  normalizer = simd_sum(normalizer);
+
+  // Now the normalizer and max value is correct for each simdgroup. We write
+  // them shared memory and combine them.
+  prevmax = maxval;
+  if (simd_lane_id == 0) {
+    local_max[simd_group_id] = maxval;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  maxval = simd_max(local_max[simd_lane_id]);
+  normalizer *= softmax_exp(prevmax - maxval);
+  if (simd_lane_id == 0) {
+    local_normalizer[simd_group_id] = normalizer;
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  normalizer = simd_sum(local_normalizer[simd_lane_id]);
+  normalizer = 1 / normalizer;
+
+  // Finally given the normalizer and max value we can directly write the
+  // softmax output
+  out += gid * size_t(axis_size);
+  for (int r = 0; r < static_cast<int>(ceildiv(axis_size, N_READS * lsize));
+       r++) {
+    int offset = r * lsize * N_READS + lid * N_READS;
+    if (offset + N_READS <= axis_size) {
+      for (int i = 0; i < N_READS; i++) {
+        out[offset + i] = T(softmax_exp(in[offset + i] - maxval) * normalizer);
+      }
+    } else {
+      for (int i = 0; i < N_READS; i++) {
+        if (offset + i < axis_size) {
+          out[offset + i] =
+              T(softmax_exp(in[offset + i] - maxval) * normalizer);
+        }
+      }
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/softmax.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/softmax.metal
new file mode 100644
index 0000000000000000000000000000000000000000..79d5d3fca15fa0136649ea62bfd883ebfb21ef64
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/softmax.metal
@@ -0,0 +1,24 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <metal_common>
+#include <metal_simdgroup>
+
+using namespace metal;
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/softmax.h"
+
+#define instantiate_softmax(name, itype)                                \
+  instantiate_kernel("block_softmax_" #name, softmax_single_row, itype) \
+  instantiate_kernel("looped_softmax_" #name, softmax_looped, itype)
+
+#define instantiate_softmax_precise(name, itype)                                       \
+  instantiate_kernel("block_softmax_precise_" #name, softmax_single_row, itype, float) \
+  instantiate_kernel("looped_softmax_precise_" #name, softmax_looped, itype, float)
+
+instantiate_softmax(float32, float)
+instantiate_softmax(float16, half)
+instantiate_softmax(bfloat16, bfloat16_t)
+instantiate_softmax_precise(float16, half)
+instantiate_softmax_precise(bfloat16, bfloat16_t) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/sort.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/sort.h
new file mode 100644
index 0000000000000000000000000000000000000000..5823e430076527fadc1355bf1260a2962555ca28
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/sort.h
@@ -0,0 +1,698 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#define MLX_MTL_CONST static constant constexpr const
+#define MLX_MTL_LOOP_UNROLL _Pragma("clang loop unroll(full)")
+
+using namespace metal;
+
+// Based on GPU merge sort algorithm at
+// https://github.com/NVIDIA/cccl/tree/main/cub/cub
+
+///////////////////////////////////////////////////////////////////////////////
+// Thread-level sort
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+METAL_FUNC void thread_swap(thread T& a, thread T& b) {
+  T w = a;
+  a = b;
+  b = w;
+}
+
+template <typename T>
+struct LessThan {
+  static constexpr constant T init = Limits<T>::max;
+
+  METAL_FUNC bool operator()(T a, T b) {
+    return a < b;
+  }
+};
+
+template <
+    typename ValT,
+    typename IdxT,
+    bool ARG_SORT,
+    short N_PER_THREAD,
+    typename CompareOp>
+struct ThreadSort {
+  static METAL_FUNC void sort(
+      thread ValT (&vals)[N_PER_THREAD],
+      thread IdxT (&idxs)[N_PER_THREAD]) {
+    CompareOp op;
+    MLX_MTL_LOOP_UNROLL
+    for (short i = 0; i < N_PER_THREAD; ++i) {
+      MLX_MTL_LOOP_UNROLL
+      for (short j = i & 1; j < N_PER_THREAD - 1; j += 2) {
+        if (op(vals[j + 1], vals[j])) {
+          thread_swap(vals[j + 1], vals[j]);
+          if (ARG_SORT) {
+            thread_swap(idxs[j + 1], idxs[j]);
+          }
+        }
+      }
+    }
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Threadgroup-level sort
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename ValT,
+    typename IdxT,
+    bool ARG_SORT,
+    short BLOCK_THREADS,
+    short N_PER_THREAD,
+    typename CompareOp>
+struct BlockMergeSort {
+  using thread_sort_t =
+      ThreadSort<ValT, IdxT, ARG_SORT, N_PER_THREAD, CompareOp>;
+  static METAL_FUNC int merge_partition(
+      const threadgroup ValT* As,
+      const threadgroup ValT* Bs,
+      short A_sz,
+      short B_sz,
+      short sort_md) {
+    CompareOp op;
+
+    short A_st = max(0, sort_md - B_sz);
+    short A_ed = min(sort_md, A_sz);
+
+    while (A_st < A_ed) {
+      short md = A_st + (A_ed - A_st) / 2;
+      auto a = As[md];
+      auto b = Bs[sort_md - 1 - md];
+
+      if (op(b, a)) {
+        A_ed = md;
+      } else {
+        A_st = md + 1;
+      }
+    }
+
+    return A_ed;
+  }
+
+  static METAL_FUNC void merge_step(
+      const threadgroup ValT* As,
+      const threadgroup ValT* Bs,
+      const threadgroup IdxT* As_idx,
+      const threadgroup IdxT* Bs_idx,
+      short A_sz,
+      short B_sz,
+      thread ValT (&vals)[N_PER_THREAD],
+      thread IdxT (&idxs)[N_PER_THREAD]) {
+    CompareOp op;
+    short a_idx = 0;
+    short b_idx = 0;
+
+    for (int i = 0; i < N_PER_THREAD; ++i) {
+      auto a = As[a_idx];
+      auto b = Bs[b_idx];
+      bool pred = (b_idx < B_sz) && (a_idx >= A_sz || op(b, a));
+
+      vals[i] = pred ? b : a;
+      if (ARG_SORT) {
+        idxs[i] = pred ? Bs_idx[b_idx] : As_idx[a_idx];
+      }
+
+      b_idx += short(pred);
+      a_idx += short(!pred);
+    }
+  }
+
+  static METAL_FUNC void sort(
+      threadgroup ValT* tgp_vals [[threadgroup(0)]],
+      threadgroup IdxT* tgp_idxs [[threadgroup(1)]],
+      int size_sorted_axis,
+      uint3 lid [[thread_position_in_threadgroup]]) {
+    // Get thread location
+    int idx = lid.x * N_PER_THREAD;
+
+    // Load from shared memory
+    thread ValT thread_vals[N_PER_THREAD];
+    thread IdxT thread_idxs[N_PER_THREAD];
+    for (int i = 0; i < N_PER_THREAD; ++i) {
+      thread_vals[i] = tgp_vals[idx + i];
+      if (ARG_SORT) {
+        thread_idxs[i] = tgp_idxs[idx + i];
+      }
+    }
+
+    // Per thread sort
+    if (idx < size_sorted_axis) {
+      thread_sort_t::sort(thread_vals, thread_idxs);
+    }
+
+    // Do merges using threadgroup memory
+    for (int merge_threads = 2; merge_threads <= BLOCK_THREADS;
+         merge_threads *= 2) {
+      // Update threadgroup memory
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      for (int i = 0; i < N_PER_THREAD; ++i) {
+        tgp_vals[idx + i] = thread_vals[i];
+        if (ARG_SORT) {
+          tgp_idxs[idx + i] = thread_idxs[i];
+        }
+      }
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      // Find location in merge step
+      int merge_group = lid.x / merge_threads;
+      int merge_lane = lid.x % merge_threads;
+
+      int sort_sz = N_PER_THREAD * merge_threads;
+      int sort_st = N_PER_THREAD * merge_threads * merge_group;
+
+      // As = tgp_vals[A_st:A_ed] is sorted
+      // Bs = tgp_vals[B_st:B_ed] is sorted
+      int A_st = sort_st;
+      int A_ed = sort_st + sort_sz / 2;
+      int B_st = sort_st + sort_sz / 2;
+      int B_ed = sort_st + sort_sz;
+
+      const threadgroup ValT* As = tgp_vals + A_st;
+      const threadgroup ValT* Bs = tgp_vals + B_st;
+      int A_sz = A_ed - A_st;
+      int B_sz = B_ed - B_st;
+
+      // Find a partition of merge elements
+      //  Ci = merge(As[partition:], Bs[sort_md - partition:])
+      //       of size N_PER_THREAD for each merge lane i
+      //  C = [Ci] is sorted
+      int sort_md = N_PER_THREAD * merge_lane;
+      int partition = merge_partition(As, Bs, A_sz, B_sz, sort_md);
+
+      As += partition;
+      Bs += sort_md - partition;
+
+      A_sz -= partition;
+      B_sz -= sort_md - partition;
+
+      const threadgroup IdxT* As_idx =
+          ARG_SORT ? tgp_idxs + A_st + partition : nullptr;
+      const threadgroup IdxT* Bs_idx =
+          ARG_SORT ? tgp_idxs + B_st + sort_md - partition : nullptr;
+
+      // Merge starting at the partition and store results in thread registers
+      merge_step(As, Bs, As_idx, Bs_idx, A_sz, B_sz, thread_vals, thread_idxs);
+    }
+
+    // Write out to shared memory
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    for (int i = 0; i < N_PER_THREAD; ++i) {
+      tgp_vals[idx + i] = thread_vals[i];
+      if (ARG_SORT) {
+        tgp_idxs[idx + i] = thread_idxs[i];
+      }
+    }
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Kernel sort
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    typename U,
+    bool ARG_SORT,
+    short BLOCK_THREADS,
+    short N_PER_THREAD,
+    typename CompareOp = LessThan<T>>
+struct KernelMergeSort {
+  using ValT = T;
+  using IdxT = uint;
+  using block_merge_sort_t = BlockMergeSort<
+      ValT,
+      IdxT,
+      ARG_SORT,
+      BLOCK_THREADS,
+      N_PER_THREAD,
+      CompareOp>;
+
+  MLX_MTL_CONST short N_PER_BLOCK = BLOCK_THREADS * N_PER_THREAD;
+
+  static METAL_FUNC void block_sort(
+      const device T* inp,
+      device U* out,
+      const constant int& size_sorted_axis,
+      const constant int& in_stride_sorted_axis,
+      const constant int& out_stride_sorted_axis,
+      const constant int& in_stride_segment_axis,
+      const constant int& out_stride_segment_axis,
+      threadgroup ValT* tgp_vals,
+      threadgroup IdxT* tgp_idxs,
+      uint3 tid [[threadgroup_position_in_grid]],
+      uint3 lid [[thread_position_in_threadgroup]]) {
+    // tid.y tells us the segment index
+    inp += tid.y * in_stride_segment_axis;
+    out += tid.y * out_stride_segment_axis;
+
+    // Copy into threadgroup memory
+    for (short i = lid.x; i < N_PER_BLOCK; i += BLOCK_THREADS) {
+      tgp_vals[i] = i < size_sorted_axis ? inp[i * in_stride_sorted_axis]
+                                         : ValT(CompareOp::init);
+      if (ARG_SORT) {
+        tgp_idxs[i] = i;
+      }
+    }
+
+    // Sort elements within the block
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    block_merge_sort_t::sort(tgp_vals, tgp_idxs, size_sorted_axis, lid);
+
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Write output
+    for (int i = lid.x; i < size_sorted_axis; i += BLOCK_THREADS) {
+      if (ARG_SORT) {
+        out[i * out_stride_sorted_axis] = tgp_idxs[i];
+      } else {
+        out[i * out_stride_sorted_axis] = tgp_vals[i];
+      }
+    }
+  }
+};
+
+template <
+    typename T,
+    typename U,
+    bool ARG_SORT,
+    short BLOCK_THREADS,
+    short N_PER_THREAD>
+[[kernel, max_total_threads_per_threadgroup(BLOCK_THREADS)]] void block_sort(
+    const device T* inp [[buffer(0)]],
+    device U* out [[buffer(1)]],
+    const constant int& size_sorted_axis [[buffer(2)]],
+    const constant int& in_stride_sorted_axis [[buffer(3)]],
+    const constant int& out_stride_sorted_axis [[buffer(4)]],
+    const constant int& in_stride_segment_axis [[buffer(5)]],
+    const constant int& out_stride_segment_axis [[buffer(6)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]]) {
+  using sort_kernel =
+      KernelMergeSort<T, U, ARG_SORT, BLOCK_THREADS, N_PER_THREAD>;
+  using ValT = typename sort_kernel::ValT;
+  using IdxT = typename sort_kernel::IdxT;
+
+  if (ARG_SORT) {
+    threadgroup ValT tgp_vals[sort_kernel::N_PER_BLOCK];
+    threadgroup IdxT tgp_idxs[sort_kernel::N_PER_BLOCK];
+    sort_kernel::block_sort(
+        inp,
+        out,
+        size_sorted_axis,
+        in_stride_sorted_axis,
+        out_stride_sorted_axis,
+        in_stride_segment_axis,
+        out_stride_segment_axis,
+        tgp_vals,
+        tgp_idxs,
+        tid,
+        lid);
+  } else {
+    threadgroup ValT tgp_vals[sort_kernel::N_PER_BLOCK];
+    sort_kernel::block_sort(
+        inp,
+        out,
+        size_sorted_axis,
+        in_stride_sorted_axis,
+        out_stride_sorted_axis,
+        in_stride_segment_axis,
+        out_stride_segment_axis,
+        tgp_vals,
+        nullptr,
+        tid,
+        lid);
+  }
+}
+
+constant constexpr const int zero_helper = 0;
+
+template <
+    typename T,
+    typename U,
+    bool ARG_SORT,
+    short BLOCK_THREADS,
+    short N_PER_THREAD>
+[[kernel, max_total_threads_per_threadgroup(BLOCK_THREADS)]] void block_sort_nc(
+    const device T* inp [[buffer(0)]],
+    device U* out [[buffer(1)]],
+    const constant int& size_sorted_axis [[buffer(2)]],
+    const constant int& in_stride_sorted_axis [[buffer(3)]],
+    const constant int& out_stride_sorted_axis [[buffer(4)]],
+    const constant int& nc_dim [[buffer(5)]],
+    const constant int* nc_shape [[buffer(6)]],
+    const constant int64_t* in_nc_strides [[buffer(7)]],
+    const constant int64_t* out_nc_strides [[buffer(8)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]]) {
+  using sort_kernel =
+      KernelMergeSort<T, U, ARG_SORT, BLOCK_THREADS, N_PER_THREAD>;
+  using ValT = typename sort_kernel::ValT;
+  using IdxT = typename sort_kernel::IdxT;
+
+  auto in_block_idx = elem_to_loc(tid.y, nc_shape, in_nc_strides, nc_dim);
+  auto out_block_idx = elem_to_loc(tid.y, nc_shape, out_nc_strides, nc_dim);
+  inp += in_block_idx;
+  out += out_block_idx;
+
+  if (ARG_SORT) {
+    threadgroup ValT tgp_vals[sort_kernel::N_PER_BLOCK];
+    threadgroup IdxT tgp_idxs[sort_kernel::N_PER_BLOCK];
+    sort_kernel::block_sort(
+        inp,
+        out,
+        size_sorted_axis,
+        in_stride_sorted_axis,
+        out_stride_sorted_axis,
+        zero_helper,
+        zero_helper,
+        tgp_vals,
+        tgp_idxs,
+        tid,
+        lid);
+  } else {
+    threadgroup ValT tgp_vals[sort_kernel::N_PER_BLOCK];
+    sort_kernel::block_sort(
+        inp,
+        out,
+        size_sorted_axis,
+        in_stride_sorted_axis,
+        out_stride_sorted_axis,
+        zero_helper,
+        zero_helper,
+        tgp_vals,
+        nullptr,
+        tid,
+        lid);
+  }
+}
+
+template <
+    typename ValT,
+    typename IdxT,
+    bool ARG_SORT,
+    short BLOCK_THREADS,
+    short N_PER_THREAD,
+    typename CompareOp = LessThan<ValT>>
+struct KernelMultiBlockMergeSort {
+  using block_merge_sort_t = BlockMergeSort<
+      ValT,
+      IdxT,
+      ARG_SORT,
+      BLOCK_THREADS,
+      N_PER_THREAD,
+      CompareOp>;
+
+  MLX_MTL_CONST short N_PER_BLOCK = BLOCK_THREADS * N_PER_THREAD;
+
+  static METAL_FUNC void block_sort(
+      const device ValT* inp,
+      device ValT* out_vals,
+      device IdxT* out_idxs,
+      const constant int& size_sorted_axis,
+      const constant int& stride_sorted_axis,
+      threadgroup ValT* tgp_vals,
+      threadgroup IdxT* tgp_idxs,
+      uint3 tid [[threadgroup_position_in_grid]],
+      uint3 lid [[thread_position_in_threadgroup]]) {
+    // tid.y tells us the segment index
+    int base_idx = tid.x * N_PER_BLOCK;
+
+    // Copy into threadgroup memory
+    for (short i = lid.x; i < N_PER_BLOCK; i += BLOCK_THREADS) {
+      int idx = base_idx + i;
+      tgp_vals[i] = idx < size_sorted_axis ? inp[idx * stride_sorted_axis]
+                                           : ValT(CompareOp::init);
+      tgp_idxs[i] = idx;
+    }
+
+    // Sort elements within the block
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    block_merge_sort_t::sort(tgp_vals, tgp_idxs, size_sorted_axis, lid);
+
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Write output
+    for (int i = lid.x; i < N_PER_BLOCK; i += BLOCK_THREADS) {
+      int idx = base_idx + i;
+      if (idx < size_sorted_axis) {
+        out_vals[idx] = tgp_vals[i];
+        out_idxs[idx] = tgp_idxs[i];
+      }
+    }
+  }
+
+  static METAL_FUNC int merge_partition(
+      const device ValT* As,
+      const device ValT* Bs,
+      int A_sz,
+      int B_sz,
+      int sort_md) {
+    CompareOp op;
+
+    int A_st = max(0, sort_md - B_sz);
+    int A_ed = min(sort_md, A_sz);
+
+    while (A_st < A_ed) {
+      int md = A_st + (A_ed - A_st) / 2;
+      auto a = As[md];
+      auto b = Bs[sort_md - 1 - md];
+
+      if (op(b, a)) {
+        A_ed = md;
+      } else {
+        A_st = md + 1;
+      }
+    }
+
+    return A_ed;
+  }
+};
+
+template <
+    typename ValT,
+    typename IdxT,
+    bool ARG_SORT,
+    short BLOCK_THREADS,
+    short N_PER_THREAD>
+[[kernel, max_total_threads_per_threadgroup(BLOCK_THREADS)]] void mb_block_sort(
+    const device ValT* inp [[buffer(0)]],
+    device ValT* out_vals [[buffer(1)]],
+    device IdxT* out_idxs [[buffer(2)]],
+    const constant int& size_sorted_axis [[buffer(3)]],
+    const constant int& stride_sorted_axis [[buffer(4)]],
+    const constant int& nc_dim [[buffer(5)]],
+    const constant int* nc_shape [[buffer(6)]],
+    const constant int64_t* nc_strides [[buffer(7)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]]) {
+  using sort_kernel = KernelMultiBlockMergeSort<
+      ValT,
+      IdxT,
+      ARG_SORT,
+      BLOCK_THREADS,
+      N_PER_THREAD>;
+
+  auto block_idx = elem_to_loc(tid.y, nc_shape, nc_strides, nc_dim);
+  inp += block_idx;
+  out_vals += tid.y * size_sorted_axis;
+  out_idxs += tid.y * size_sorted_axis;
+
+  threadgroup ValT tgp_vals[sort_kernel::N_PER_BLOCK];
+  threadgroup IdxT tgp_idxs[sort_kernel::N_PER_BLOCK];
+
+  sort_kernel::block_sort(
+      inp,
+      out_vals,
+      out_idxs,
+      size_sorted_axis,
+      stride_sorted_axis,
+      tgp_vals,
+      tgp_idxs,
+      tid,
+      lid);
+}
+
+template <
+    typename ValT,
+    typename IdxT,
+    bool ARG_SORT,
+    short BLOCK_THREADS,
+    short N_PER_THREAD>
+[[kernel]] void mb_block_partition(
+    device IdxT* block_partitions [[buffer(0)]],
+    const device ValT* dev_vals [[buffer(1)]],
+    const device IdxT* dev_idxs [[buffer(2)]],
+    const constant int& size_sorted_axis [[buffer(3)]],
+    const constant int& merge_tiles [[buffer(4)]],
+    const constant int& n_blocks [[buffer(5)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint3 tgp_dims [[threads_per_threadgroup]]) {
+  using sort_kernel = KernelMultiBlockMergeSort<
+      ValT,
+      IdxT,
+      ARG_SORT,
+      BLOCK_THREADS,
+      N_PER_THREAD>;
+
+  block_partitions += tid.y * tgp_dims.x;
+  dev_vals += tid.y * size_sorted_axis;
+  dev_idxs += tid.y * size_sorted_axis;
+
+  for (int i = lid.x; i <= n_blocks; i += tgp_dims.x) {
+    // Find location in merge step
+    int merge_group = i / merge_tiles;
+    int merge_lane = i % merge_tiles;
+
+    int sort_sz = sort_kernel::N_PER_BLOCK * merge_tiles;
+    int sort_st = sort_kernel::N_PER_BLOCK * merge_tiles * merge_group;
+
+    int A_st = min(size_sorted_axis, sort_st);
+    int A_ed = min(size_sorted_axis, sort_st + sort_sz / 2);
+    int B_st = A_ed;
+    int B_ed = min(size_sorted_axis, B_st + sort_sz / 2);
+
+    int partition_at = min(B_ed - A_st, sort_kernel::N_PER_BLOCK * merge_lane);
+    int partition = sort_kernel::merge_partition(
+        dev_vals + A_st,
+        dev_vals + B_st,
+        A_ed - A_st,
+        B_ed - B_st,
+        partition_at);
+
+    block_partitions[i] = A_st + partition;
+  }
+}
+
+template <
+    typename ValT,
+    typename IdxT,
+    bool ARG_SORT,
+    short BLOCK_THREADS,
+    short N_PER_THREAD,
+    typename CompareOp = LessThan<ValT>>
+[[kernel, max_total_threads_per_threadgroup(BLOCK_THREADS)]] void
+mb_block_merge(
+    const device IdxT* block_partitions [[buffer(0)]],
+    const device ValT* dev_vals_in [[buffer(1)]],
+    const device IdxT* dev_idxs_in [[buffer(2)]],
+    device ValT* dev_vals_out [[buffer(3)]],
+    device IdxT* dev_idxs_out [[buffer(4)]],
+    const constant int& size_sorted_axis [[buffer(5)]],
+    const constant int& merge_tiles [[buffer(6)]],
+    const constant int& num_tiles [[buffer(7)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]]) {
+  using sort_kernel = KernelMultiBlockMergeSort<
+      ValT,
+      IdxT,
+      ARG_SORT,
+      BLOCK_THREADS,
+      N_PER_THREAD,
+      CompareOp>;
+
+  using block_sort_t = typename sort_kernel::block_merge_sort_t;
+
+  block_partitions += tid.y * (num_tiles + 1);
+  dev_vals_in += tid.y * size_sorted_axis;
+  dev_idxs_in += tid.y * size_sorted_axis;
+  dev_vals_out += tid.y * size_sorted_axis;
+  dev_idxs_out += tid.y * size_sorted_axis;
+
+  int block_idx = tid.x;
+  int merge_group = block_idx / merge_tiles;
+  int sort_st = sort_kernel::N_PER_BLOCK * merge_tiles * merge_group;
+  int sort_sz = sort_kernel::N_PER_BLOCK * merge_tiles;
+  int sort_md = sort_kernel::N_PER_BLOCK * block_idx - sort_st;
+
+  int A_st = block_partitions[block_idx + 0];
+  int A_ed = block_partitions[block_idx + 1];
+  int B_st = min(size_sorted_axis, 2 * sort_st + sort_sz / 2 + sort_md - A_st);
+  int B_ed = min(
+      size_sorted_axis,
+      2 * sort_st + sort_sz / 2 + sort_md + sort_kernel::N_PER_BLOCK - A_ed);
+
+  if ((block_idx % merge_tiles) == merge_tiles - 1) {
+    A_ed = min(size_sorted_axis, sort_st + sort_sz / 2);
+    B_ed = min(size_sorted_axis, sort_st + sort_sz);
+  }
+
+  int A_sz = A_ed - A_st;
+  int B_sz = B_ed - B_st;
+
+  // Load from global memory
+  thread ValT thread_vals[N_PER_THREAD];
+  thread IdxT thread_idxs[N_PER_THREAD];
+  for (int i = 0; i < N_PER_THREAD; i++) {
+    int idx = BLOCK_THREADS * i + lid.x;
+    if (idx < (A_sz + B_sz)) {
+      thread_vals[i] = (idx < A_sz) ? dev_vals_in[A_st + idx]
+                                    : dev_vals_in[B_st + idx - A_sz];
+      thread_idxs[i] = (idx < A_sz) ? dev_idxs_in[A_st + idx]
+                                    : dev_idxs_in[B_st + idx - A_sz];
+    } else {
+      thread_vals[i] = CompareOp::init;
+      thread_idxs[i] = 0;
+    }
+  }
+
+  // Write to shared memory
+  threadgroup ValT tgp_vals[sort_kernel::N_PER_BLOCK];
+  threadgroup IdxT tgp_idxs[sort_kernel::N_PER_BLOCK];
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  for (int i = 0; i < N_PER_THREAD; i++) {
+    int idx = BLOCK_THREADS * i + lid.x;
+    tgp_vals[idx] = thread_vals[i];
+    tgp_idxs[idx] = thread_idxs[i];
+  }
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // Merge
+  int sort_md_local = min(A_sz + B_sz, N_PER_THREAD * int(lid.x));
+
+  int A_st_local = block_sort_t::merge_partition(
+      tgp_vals, tgp_vals + A_sz, A_sz, B_sz, sort_md_local);
+  int A_ed_local = A_sz;
+
+  int B_st_local = sort_md_local - A_st_local;
+  int B_ed_local = B_sz;
+
+  int A_sz_local = A_ed_local - A_st_local;
+  int B_sz_local = B_ed_local - B_st_local;
+
+  // Do merge
+  block_sort_t::merge_step(
+      tgp_vals + A_st_local,
+      tgp_vals + A_ed_local + B_st_local,
+      tgp_idxs + A_st_local,
+      tgp_idxs + A_ed_local + B_st_local,
+      A_sz_local,
+      B_sz_local,
+      thread_vals,
+      thread_idxs);
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  for (int i = 0; i < N_PER_THREAD; ++i) {
+    int idx = lid.x * N_PER_THREAD;
+    tgp_vals[idx + i] = thread_vals[i];
+    tgp_idxs[idx + i] = thread_idxs[i];
+  }
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+  // Write output
+  int base_idx = tid.x * sort_kernel::N_PER_BLOCK;
+  for (int i = lid.x; i < sort_kernel::N_PER_BLOCK; i += BLOCK_THREADS) {
+    int idx = base_idx + i;
+    if (idx < size_sorted_axis) {
+      dev_vals_out[idx] = tgp_vals[i];
+      dev_idxs_out[idx] = tgp_idxs[i];
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/sort.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/sort.metal
new file mode 100644
index 0000000000000000000000000000000000000000..7f198d55d31251bb6ee3a231be3190260a5d2ed3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/sort.metal
@@ -0,0 +1,80 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <metal_stdlib>
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/sort.h"
+
+#define instantiate_block_sort(                                          \
+    name, itname, itype, otname, otype, arg_sort, bn, tn)                \
+  instantiate_kernel("c" #name "_" #itname "_" #otname "_bn" #bn "_tn" #tn, \
+                     block_sort, itype, otype, arg_sort, bn, tn) \
+  instantiate_kernel("nc" #name "_" #itname "_" #otname "_bn" #bn "_tn" #tn, \
+                     block_sort_nc, itype, otype, arg_sort, bn, tn)
+
+#define instantiate_arg_block_sort_base(itname, itype, bn, tn) \
+  instantiate_block_sort(                                      \
+      arg_block_sort, itname, itype, uint32, uint32_t, true, bn, tn)
+
+#define instantiate_block_sort_base(itname, itype, bn, tn) \
+  instantiate_block_sort(                                  \
+      _block_sort, itname, itype, itname, itype, false, bn, tn)
+
+#define instantiate_block_sort_tn(itname, itype, bn) \
+  instantiate_block_sort_base(itname, itype, bn, 4)  \
+  instantiate_arg_block_sort_base(itname, itype, bn, 4)
+
+#define instantiate_block_sort_bn(itname, itype) \
+  instantiate_block_sort_tn(itname, itype, 32)  \
+  instantiate_block_sort_tn(itname, itype, 64)  \
+  instantiate_block_sort_tn(itname, itype, 128)  \
+  instantiate_block_sort_tn(itname, itype, 256)  \
+  instantiate_block_sort_tn(itname, itype, 512)
+
+instantiate_block_sort_bn(uint8, uint8_t)
+instantiate_block_sort_bn(uint16, uint16_t)
+instantiate_block_sort_bn(uint32, uint32_t)
+instantiate_block_sort_bn(int8, int8_t)
+instantiate_block_sort_bn(int16, int16_t)
+instantiate_block_sort_bn(int32, int32_t)
+instantiate_block_sort_bn(float16, half)
+instantiate_block_sort_bn(float32, float)
+instantiate_block_sort_bn(bfloat16, bfloat16_t)
+
+#define instantiate_block_sort_long(itname, itype) \
+  instantiate_block_sort_tn(itname, itype, 32)     \
+  instantiate_block_sort_tn(itname, itype, 64)     \
+  instantiate_block_sort_tn(itname, itype, 128)    \
+  instantiate_block_sort_tn(itname, itype, 256)
+
+instantiate_block_sort_long(uint64, uint64_t)
+instantiate_block_sort_long(int64, int64_t)
+
+#define instantiate_multi_block_sort(                                      \
+    vtname, vtype, itname, itype, arg_sort, bn, tn)                        \
+  instantiate_kernel("sort_mbsort_" #vtname "_" #itname "_bn" #bn "_tn" #tn, \
+                     mb_block_sort, vtype, itype, arg_sort, bn, tn) \
+  instantiate_kernel("partition_mbsort_" #vtname "_" #itname "_bn" #bn "_tn" #tn, \
+                     mb_block_partition, vtype, itype, arg_sort, bn, tn) \
+  instantiate_kernel("merge_mbsort_" #vtname "_" #itname "_bn" #bn "_tn" #tn, \
+                     mb_block_merge, vtype, itype, arg_sort, bn, tn)
+
+#define instantiate_multi_block_sort_base(vtname, vtype) \
+  instantiate_multi_block_sort(vtname, vtype, uint32, uint32_t, true, 512, 4)
+
+instantiate_multi_block_sort_base(uint8, uint8_t)
+instantiate_multi_block_sort_base(uint16, uint16_t)
+instantiate_multi_block_sort_base(uint32, uint32_t)
+instantiate_multi_block_sort_base(int8, int8_t)
+instantiate_multi_block_sort_base(int16, int16_t)
+instantiate_multi_block_sort_base(int32, int32_t)
+instantiate_multi_block_sort_base(float16, half)
+instantiate_multi_block_sort_base(float32, float)
+instantiate_multi_block_sort_base(bfloat16, bfloat16_t)
+
+#define instantiate_multi_block_sort_long(vtname, vtype) \
+  instantiate_multi_block_sort(vtname, vtype, uint32, uint32_t, true, 256, 4)
+
+instantiate_multi_block_sort_long(uint64, uint64_t)
+instantiate_multi_block_sort_long(int64, int64_t) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/attn.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/attn.h
new file mode 100644
index 0000000000000000000000000000000000000000..991d4d69c96922057ae285263e452b176b148315
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/attn.h
@@ -0,0 +1,296 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/steel/attn/loader.h"
+#include "mlx/backend/metal/kernels/steel/attn/mma.h"
+#include "mlx/backend/metal/kernels/steel/attn/params.h"
+#include "mlx/backend/metal/kernels/steel/attn/transforms.h"
+#include "mlx/backend/metal/kernels/steel/gemm/params.h"
+#include "mlx/backend/metal/kernels/steel/utils.h"
+
+using namespace metal;
+
+///////////////////////////////////////////////////////////////////////////////
+// GEMM kernel class
+///////////////////////////////////////////////////////////////////////////////
+
+namespace mlx {
+namespace steel {
+
+template <bool M_aligned, bool N_aligned, bool K_aligned>
+struct LoopAlignment {};
+
+template <
+    typename T,
+    typename U,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    bool MN_aligned,
+    bool K_aligned,
+    typename AccumType = typename AccumHelper<T>::accum_type,
+    typename Epilogue = TransformNone<U, AccumType>>
+struct GEMMKernel {
+  STEEL_CONST short tgp_padding_a = 16 / sizeof(T);
+  STEEL_CONST short tgp_padding_b = 16 / sizeof(T);
+  STEEL_CONST short tgp_mem_size_a =
+      transpose_a ? BK * (BM + tgp_padding_a) : BM * (BK + tgp_padding_a);
+  STEEL_CONST short tgp_mem_size_b =
+      transpose_b ? BN * (BK + tgp_padding_b) : BK * (BN + tgp_padding_b);
+  STEEL_CONST short tgp_mem_size = tgp_mem_size_a + tgp_mem_size_b;
+
+  STEEL_CONST short tgp_size = WM * WN * 32;
+
+  using loader_a_t = BlockLoader<
+      T,
+      transpose_a ? BK : BM,
+      transpose_a ? BM : BK,
+      transpose_a ? BM + tgp_padding_a : BK + tgp_padding_a,
+      !transpose_a,
+      tgp_size>;
+  using loader_b_t = BlockLoader<
+      T,
+      transpose_b ? BN : BK,
+      transpose_b ? BK : BN,
+      transpose_b ? BK + tgp_padding_b : BN + tgp_padding_b,
+      transpose_b,
+      tgp_size>;
+  using mma_t = BlockMMA<
+      T,
+      U,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      transpose_a,
+      transpose_b,
+      transpose_a ? BM + tgp_padding_a : BK + tgp_padding_a,
+      transpose_b ? BK + tgp_padding_b : BN + tgp_padding_b,
+      AccumType,
+      Epilogue>;
+
+  /* Main kernel function */
+  template <bool M_aligned, bool N_aligned, bool K_aligned_>
+  static METAL_FUNC void gemm_loop(
+      threadgroup T* As [[threadgroup(0)]],
+      threadgroup T* Bs [[threadgroup(1)]],
+      const int gemm_k_iterations,
+      thread loader_a_t& loader_a,
+      thread loader_b_t& loader_b,
+      thread mma_t& mma_op,
+      thread const short& tgp_bm,
+      thread const short& tgp_bn,
+      thread const short& lbk,
+      LoopAlignment<M_aligned, N_aligned, K_aligned_> l = {}) {
+    // Appease the compiler
+    (void)l;
+
+    short2 tile_dims_A = transpose_a ? short2(tgp_bm, BK) : short2(BK, tgp_bm);
+
+    short2 tile_dims_B = transpose_b ? short2(BK, tgp_bn) : short2(tgp_bn, BK);
+
+    for (int k = 0; k < gemm_k_iterations; k++) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      // Load elements into threadgroup
+      if (M_aligned) {
+        loader_a.load_unsafe();
+      } else {
+        loader_a.load_safe(tile_dims_A);
+      }
+
+      if (N_aligned) {
+        loader_b.load_unsafe();
+      } else {
+        loader_b.load_safe(tile_dims_B);
+      }
+
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      // Multiply and accumulate threadgroup elements
+      mma_op.mma(As, Bs);
+
+      // Prepare for next iteration
+      loader_a.next();
+      loader_b.next();
+    }
+
+    if (!K_aligned_) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      short2 tile_dims_A_last =
+          transpose_a ? short2(tgp_bm, lbk) : short2(lbk, tgp_bm);
+      short2 tile_dims_B_last =
+          transpose_b ? short2(lbk, tgp_bn) : short2(tgp_bn, lbk);
+
+      loader_a.load_safe(tile_dims_A_last);
+      loader_b.load_safe(tile_dims_B_last);
+
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      mma_op.mma(As, Bs);
+    }
+  }
+
+  /* Main kernel function */
+  static METAL_FUNC void run(
+      const device T* A [[buffer(0)]],
+      const device T* B [[buffer(1)]],
+      device U* D [[buffer(2)]],
+      const constant GEMMParams* params [[buffer(3)]],
+      threadgroup T* As [[threadgroup(0)]],
+      threadgroup T* Bs [[threadgroup(1)]],
+      uint simd_lane_id [[thread_index_in_simdgroup]],
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint3 tid [[threadgroup_position_in_grid]],
+      uint3 lid [[thread_position_in_threadgroup]]) {
+    // Pacifying compiler
+    (void)lid;
+
+    const int tid_y = ((tid.y) << params->swizzle_log) +
+        ((tid.x) & ((1 << params->swizzle_log) - 1));
+    const int tid_x = (tid.x) >> params->swizzle_log;
+
+    if (params->tiles_n <= tid_x || params->tiles_m <= tid_y) {
+      return;
+    }
+
+    threadgroup_barrier(mem_flags::mem_none);
+
+    // Find block in A, B, C
+    const int c_row = tid_y * BM;
+    const int c_col = tid_x * BN;
+    const size_t c_row_long = size_t(c_row);
+    const size_t c_col_long = size_t(c_col);
+
+    A += transpose_a ? c_row_long : c_row_long * params->lda;
+    B += transpose_b ? c_col_long * params->ldb : c_col_long;
+    D += c_row_long * params->ldd + c_col_long;
+
+    // Prepare threadgroup loading operations
+    thread loader_a_t loader_a(A, params->lda, As, simd_group_id, simd_lane_id);
+    thread loader_b_t loader_b(B, params->ldb, Bs, simd_group_id, simd_lane_id);
+
+    // Prepare threadgroup mma operation
+    thread mma_t mma_op(simd_group_id, simd_lane_id);
+
+    int gemm_k_iterations = params->gemm_k_iterations_aligned;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // MNK aligned loop
+    if (MN_aligned) {
+      for (int k = 0; k < gemm_k_iterations; k++) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        // Load elements into threadgroup
+        loader_a.load_unsafe();
+        loader_b.load_unsafe();
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+
+        // Prepare for next iteration
+        loader_a.next();
+        loader_b.next();
+      }
+
+      threadgroup_barrier(mem_flags::mem_none);
+
+      // Loop tail
+      if (!K_aligned) {
+        int lbk = params->K - params->gemm_k_iterations_aligned * BK;
+        short2 tile_dims_A = transpose_a ? short2(BM, lbk) : short2(lbk, BM);
+        short2 tile_dims_B = transpose_b ? short2(lbk, BN) : short2(BN, lbk);
+
+        loader_a.load_safe(tile_dims_A);
+        loader_b.load_safe(tile_dims_B);
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        mma_op.mma(As, Bs);
+      }
+
+      // Store results to device memory
+      mma_op.store_result(D, params->ldd);
+      return;
+
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    // MN unaligned loop
+    else { // Loop over K - unaligned case
+      short tgp_bm = min(BM, params->M - c_row);
+      short tgp_bn = min(BN, params->N - c_col);
+      short leftover_bk = params->K - params->gemm_k_iterations_aligned * BK;
+
+      if (tgp_bm == BM && tgp_bn == BN) {
+        gemm_loop<true, true, K_aligned>(
+            As,
+            Bs,
+            gemm_k_iterations,
+            loader_a,
+            loader_b,
+            mma_op,
+            tgp_bm,
+            tgp_bn,
+            leftover_bk);
+
+        mma_op.store_result(D, params->ldd);
+        return;
+
+      } else if (tgp_bn == BN) {
+        gemm_loop<false, true, K_aligned>(
+            As,
+            Bs,
+            gemm_k_iterations,
+            loader_a,
+            loader_b,
+            mma_op,
+            tgp_bm,
+            tgp_bn,
+            leftover_bk);
+
+        mma_op.store_result_safe(D, params->ldd, short2(tgp_bn, tgp_bm));
+        return;
+
+      } else if (tgp_bm == BM) {
+        gemm_loop<true, false, K_aligned>(
+            As,
+            Bs,
+            gemm_k_iterations,
+            loader_a,
+            loader_b,
+            mma_op,
+            tgp_bm,
+            tgp_bn,
+            leftover_bk);
+
+        mma_op.store_result_safe(D, params->ldd, short2(tgp_bn, tgp_bm));
+        return;
+
+      } else {
+        gemm_loop<false, false, K_aligned>(
+            As,
+            Bs,
+            gemm_k_iterations,
+            loader_a,
+            loader_b,
+            mma_op,
+            tgp_bm,
+            tgp_bn,
+            leftover_bk);
+
+        mma_op.store_result_safe(D, params->ldd, short2(tgp_bn, tgp_bm));
+        return;
+      }
+    }
+  }
+};
+
+} // namespace steel
+} // namespace mlx
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/kernels/steel_attention.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/kernels/steel_attention.h
new file mode 100644
index 0000000000000000000000000000000000000000..7397039b5a057b9ba092d2c2d3a32569b56827cc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/kernels/steel_attention.h
@@ -0,0 +1,474 @@
+// Copyright © 2024-25 Apple Inc.
+
+using namespace mlx::steel;
+
+///////////////////////////////////////////////////////////////////////////////
+// GEMM kernels
+///////////////////////////////////////////////////////////////////////////////
+
+constant bool align_Q [[function_constant(200)]];
+constant bool align_K [[function_constant(201)]];
+
+constant bool has_mask [[function_constant(300)]];
+constant bool do_causal [[function_constant(301)]];
+constant bool has_sinks [[function_constant(302)]];
+
+template <typename T>
+struct TransformScale {
+  T scale;
+  METAL_FUNC TransformScale(T scale_) : scale(scale_) {}
+
+  METAL_FUNC T apply(T x) const {
+    return scale * x;
+  }
+};
+
+struct MaxOp {
+  template <typename T>
+  METAL_FUNC static constexpr T apply(T x, T y) {
+    return metal::max(x, y);
+  }
+};
+
+struct SumOp {
+  template <typename T>
+  METAL_FUNC static constexpr T apply(T x, T y) {
+    return x + y;
+  }
+};
+
+struct MulOp {
+  template <typename T>
+  METAL_FUNC static constexpr T apply(T x, T y) {
+    return x * y;
+  }
+};
+
+struct SubOp {
+  template <typename T>
+  METAL_FUNC static constexpr T apply(T x, T y) {
+    return x - y;
+  }
+};
+
+struct ExpSubOp {
+  template <typename T>
+  METAL_FUNC static constexpr T apply(T x, T y) {
+    return fast::exp2(x - y);
+  }
+};
+
+struct DivOp {
+  template <typename T>
+  METAL_FUNC static constexpr T apply(T x, T y) {
+    return x / y;
+  }
+};
+
+// clang-format off
+template <
+    typename T,
+    int BQ,
+    int BK,
+    int BD,
+    int WM,
+    int WN,
+    typename MaskType = float,
+    typename AccumType = float>
+[[kernel, max_total_threads_per_threadgroup(WM * WN * 32)]] void attention(
+    const device T* Q [[buffer(0)]],
+    const device T* K [[buffer(1)]],
+    const device T* V [[buffer(2)]],
+    device T* O [[buffer(3)]],
+    const constant AttnParams* params [[buffer(4)]],
+    const constant AttnMaskParams* mask_params [[buffer(5), function_constant(has_mask)]],
+    const device MaskType* mask [[buffer(6), function_constant(has_mask)]],
+    const device T* sinks [[buffer(7), function_constant(has_sinks)]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]]) { // clang-format on
+
+  // Pacifying compiler
+  (void)lid;
+
+  // Move to correct block
+  ulong3 tidl{tid.x, tid.y, tid.z};
+
+  Q += tidl.z * params->Q_strides[0] + // Batch
+      tidl.y * params->Q_strides[1] + // Head
+      tidl.x * BQ * params->Q_strides[2]; // Sequence
+
+  ulong kv_head_idx = int(tid.y) / params->gqa_factor;
+  K += tidl.z * params->K_strides[0] + // Batch
+      kv_head_idx * params->K_strides[1]; // Head
+
+  V += tidl.z * params->V_strides[0] + // Batch
+      kv_head_idx * params->V_strides[1]; // Head
+
+  O += tidl.z * params->O_strides[0] + // Batch
+      tidl.y * params->O_strides[1] + // Head
+      tidl.x * BQ * params->O_strides[2]; // Sequence
+
+  if (has_mask) {
+    mask += tidl.z * mask_params->M_strides[0] + // Batch
+        tidl.y * mask_params->M_strides[1]; // Head
+  }
+
+  // Prepare threadgroup memory
+  constexpr short padQ = 16 / sizeof(T);
+  constexpr short padK = 16 / sizeof(T);
+  constexpr short padV = 16 / sizeof(T);
+
+  constexpr short LDQ_tgp = BD + padQ;
+  constexpr short LDK_tgp = BK + padK;
+  constexpr short LDV_tgp = BD + padV;
+
+  constexpr short tgp_mem_0 = (BK + padK) * (BD);
+  constexpr short tgp_mem_1 = BK * (BD + padV);
+  constexpr short tgp_mem_s = tgp_mem_0 > tgp_mem_1 ? tgp_mem_0 : tgp_mem_1;
+
+  threadgroup T Q_smem[BQ * (BD + padQ)];
+  threadgroup T KV_smem[tgp_mem_s];
+
+  threadgroup T* Qs = Q_smem;
+  threadgroup T* Ks = KV_smem;
+  threadgroup T* Vs = KV_smem;
+
+  // Prepare block loaders
+  using QBlockLoader = BlockLoaderT<
+      /* typename T = */ T,
+      /* short BROWS = */ BQ,
+      /* short BCOLS = */ BD,
+      /* short kDstStrRow = */ LDQ_tgp,
+      /* short kDstStrCol = */ 1,
+      /* short reduction_dim = */ 1,
+      /* short tgp_size = */ WM * WN * 32>;
+
+  // K is loaded in transposed
+  using KBlockLoader = BlockLoaderT<
+      /* typename T = */ T,
+      /* short BROWS = */ BK,
+      /* short BCOLS = */ BD,
+      /* short kDstStrRow = */ 1,
+      /* short kDstStrCol = */ LDK_tgp,
+      /* short reduction_dim = */ 0,
+      /* short tgp_size = */ WM * WN * 32>;
+
+  using VBlockLoader = BlockLoaderT<
+      /* typename T = */ T,
+      /* short BROWS = */ BK,
+      /* short BCOLS = */ BD,
+      /* short kDstStrRow = */ LDV_tgp,
+      /* short kDstStrCol = */ 1,
+      /* short reduction_dim = */ 0,
+      /* short tgp_size = */ WM * WN * 32>;
+
+  QBlockLoader loader_q(
+      Q, params->Q_strides[2], Qs, simd_group_id, simd_lane_id);
+  KBlockLoader loader_k(
+      K, params->K_strides[2], Ks, simd_group_id, simd_lane_id);
+  VBlockLoader loader_v(
+      V, params->V_strides[2], Vs, simd_group_id, simd_lane_id);
+
+  TransformScale<T> ts(static_cast<T>(params->scale * M_LOG2E_F));
+
+  // Prepare MMA tiles
+  constexpr short kFragSize = 8; // MMAFrag size
+  using MMAFrag_acc_t = BaseMMAFrag<AccumType, kFragSize, kFragSize>;
+
+  constexpr int kNWarps = WM * WN;
+  static_assert(
+      BQ >= (kNWarps * kFragSize) && BQ % (kNWarps * kFragSize) == 0,
+      "Each simdgroup must host atleast 1 simdgroup matrix along Q sequence.");
+
+  // Q seq frags per warp
+  constexpr int TQ = BQ / (kNWarps * kFragSize);
+  // KV sequence frags (all warps load the same frags)
+  constexpr int TK = BK / kFragSize;
+  // HeadDim frags (all warps load the same frags)
+  constexpr int TD = BD / kFragSize;
+
+  static_assert(TQ == 1, "Check TQ");
+
+  MMATile<AccumType, TQ, 1, MMAFrag_acc_t> Qtile;
+  MMATile<AccumType, 1, TK, MMAFrag_acc_t> Ktile;
+  MMATile<AccumType, TQ, TK, MMAFrag_acc_t> Stile;
+  MMATile<AccumType, 1, 1, MMAFrag_acc_t> Vtile;
+  MMATile<AccumType, TQ, TD, MMAFrag_acc_t> Otile;
+
+  Otile.clear();
+
+  // Prepare mma tile offsets
+  const short2 simd_coord = MMAFrag_acc_t::get_coord(simd_lane_id);
+  const short sm = simd_coord.y;
+  const short sn = simd_coord.x;
+  const short tm = kFragSize * TQ * simd_group_id;
+
+  const short Qs_offset = (tm + sm) * LDQ_tgp + sn;
+  const short Ks_offset = sm * LDK_tgp + sn;
+  const short Vs_offset = sm * LDV_tgp + sn;
+
+  constexpr short Qs_tile_stride = kFragSize;
+  constexpr short Ks_tile_stride = kFragSize * LDK_tgp;
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  // Load Q blocks apply scale
+  if (!align_Q && int(tid.x) == (params->NQ_aligned)) {
+    loader_q.load_safe(short2(BD, params->qL_rem));
+  } else {
+    loader_q.load_unsafe();
+  }
+  loader_q.apply_inplace_op(ts);
+
+  // Init row reduction variables
+  constexpr short kRowsPT = decltype(Stile)::kRowsPerThread;
+
+  AccumType max_score[kRowsPT];
+  AccumType sum_score[kRowsPT] = {0};
+
+  // Init to -Inf
+  STEEL_PRAGMA_UNROLL
+  for (short i = 0; i < kRowsPT; ++i) {
+    max_score[i] = Limits<AccumType>::finite_min;
+  }
+
+  if (has_sinks) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kRowsPT; ++i) {
+      max_score[i] = M_LOG2E_F * static_cast<AccumType>(sinks[tidl.y]);
+      sum_score[i] = 1;
+    }
+  }
+
+  int kb_lim = params->NK;
+
+  if (do_causal) {
+    int q_max = (tid.x + 1) * BQ + params->qL_off;
+    kb_lim = (q_max + BK - 1) / BK;
+    kb_lim = min(params->NK, kb_lim);
+  }
+
+  // Loop over KV seq length
+  for (int kb = 0; kb < kb_lim; kb++) {
+    // Load K block and apply scale
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    if (!align_K && kb == (params->NK_aligned)) {
+      loader_k.load_safe(short2(BD, params->kL_rem));
+    } else {
+      loader_k.load_unsafe();
+    }
+
+    // Do S = Q @ K.T
+    Stile.clear();
+
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    STEEL_PRAGMA_UNROLL
+    for (short dd = 0; dd < TD; dd++) {
+      simdgroup_barrier(mem_flags::mem_none);
+
+      Qtile.template load<T, 1, 1, LDQ_tgp, 1>(
+          &Qs[Qs_offset + dd * Qs_tile_stride]);
+      Ktile.template load<T, 1, 1, LDK_tgp, 1>(
+          &Ks[Ks_offset + dd * Ks_tile_stride]);
+
+      simdgroup_barrier(mem_flags::mem_none);
+
+      tile_matmad(Stile, Qtile, Ktile, Stile);
+    }
+
+    // Mask out length sequence
+    if (!align_K && kb == (params->NK_aligned)) {
+      using stile_t = decltype(Stile);
+      using selem_t = typename stile_t::elem_type;
+      constexpr auto neg_inf = Limits<selem_t>::finite_min;
+
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < stile_t::kTileRows; i++) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < stile_t::kTileCols; j++) {
+          short col_pos = sn + (j * stile_t::kFragCols);
+          STEEL_PRAGMA_UNROLL
+          for (short jj = 0; jj < stile_t::MMAFrag_t::kElemCols; jj++) {
+            if ((col_pos + jj) >= params->kL_rem) {
+              Stile.frag_at(i, j)[jj] = neg_inf;
+            }
+          }
+        }
+      }
+    }
+
+    // Mask out if causal
+    if (do_causal && kb >= (kb_lim - ((BQ + BK - 1) / BK) - int(!align_K))) {
+      using stile_t = decltype(Stile);
+      using selem_t = typename stile_t::elem_type;
+      constexpr auto neg_inf = Limits<selem_t>::finite_min;
+
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < stile_t::kTileRows; i++) {
+        const int row_pos =
+            tid.x * BQ + params->qL_off + tm + sm + (i * stile_t::kFragRows);
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < stile_t::kTileCols; j++) {
+          const int col_pos = kb * BK + sn + (j * stile_t::kFragCols);
+          STEEL_PRAGMA_UNROLL
+          for (short jj = 0; jj < stile_t::MMAFrag_t::kElemCols; jj++) {
+            if (row_pos < (col_pos + jj)) {
+              Stile.frag_at(i, j)[jj] = neg_inf;
+            }
+          }
+        }
+      }
+    }
+
+    // Other masking as needed
+    if (has_mask) {
+      using stile_t = decltype(Stile);
+      using selem_t = typename stile_t::elem_type;
+      constexpr auto neg_inf = Limits<selem_t>::finite_min;
+
+      constexpr bool is_bool = is_same_v<MaskType, bool>;
+      using melem_t = typename metal::conditional_t<is_bool, bool, selem_t>;
+
+      using MMAFrag_mask_t = BaseMMAFrag<melem_t, kFragSize, kFragSize>;
+      using frag_t = typename MMAFrag_mask_t::frag_type;
+
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < stile_t::kTileRows; i++) {
+        const int row_pos = tid.x * BQ + tm + sm + (i * stile_t::kFragRows);
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < stile_t::kTileCols; j++) {
+          const int col_pos = kb * BK + sn + (j * stile_t::kFragCols);
+
+          frag_t mfrag;
+
+          MMAFrag_mask_t::load_safe(
+              mfrag,
+              mask,
+              int(mask_params->M_strides[2]),
+              Int<1>{},
+              params->qL,
+              params->kL,
+              row_pos,
+              col_pos);
+
+          STEEL_PRAGMA_UNROLL
+          for (short jj = 0; jj < stile_t::MMAFrag_t::kElemsPerFrag; jj++) {
+            if constexpr (is_bool) {
+              Stile.frag_at(i, j)[jj] =
+                  mfrag[jj] ? Stile.frag_at(i, j)[jj] : neg_inf;
+            } else {
+              Stile.frag_at(i, j)[jj] += M_LOG2E_F * selem_t(mfrag[jj]);
+            }
+          }
+        }
+      }
+    }
+
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Load V blocks
+    if (!align_K && kb == (params->NK_aligned)) {
+      loader_v.load_safe(short2(BD, params->kL_rem));
+    } else {
+      loader_v.load_unsafe();
+    }
+
+    // Do softmax
+
+    // Temp variables
+    AccumType new_max[kRowsPT];
+    AccumType factor[kRowsPT];
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kRowsPT; ++i) {
+      new_max[i] = max_score[i];
+    }
+
+    // Row max
+    Stile.template row_reduce<MaxOp>(new_max);
+
+    // exp(Si - rowmax(Si))
+    Stile.template row_bin_op<ExpSubOp>(new_max);
+
+    // Factor exp(rowmax(Si) - rowmax(Si-1))
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kRowsPT; ++i) {
+      factor[i] = fast::exp2(max_score[i] - new_max[i]);
+    }
+
+    // Save max for next iteration
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kRowsPT; ++i) {
+      max_score[i] = new_max[i];
+    }
+
+    // Row Sum
+    AccumType sum_score_tmp[kRowsPT] = {0};
+    Stile.template row_reduce<SumOp>(sum_score_tmp);
+
+    // Update norm
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kRowsPT; ++i) {
+      sum_score[i] = sum_score[i] * factor[i] + sum_score_tmp[i];
+    }
+
+    // Update O
+    Otile.template row_bin_op<MulOp>(factor);
+
+    // Load V into registers
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    STEEL_PRAGMA_UNROLL
+    for (short iq = 0; iq < TQ; iq++) {
+      STEEL_PRAGMA_UNROLL
+      for (short id = 0; id < TD; id++) {
+        STEEL_PRAGMA_UNROLL
+        for (short ik = 0; ik < TK; ik++) {
+          if constexpr (BD == 128) {
+            simdgroup_barrier(mem_flags::mem_none);
+          }
+
+          const short kk = ik * kFragSize;
+          const short dd = id * kFragSize;
+
+          Vtile.template load<T, 1, 1, LDV_tgp, 1>(
+              &Vs[Vs_offset + kk * LDV_tgp + dd]);
+
+          if constexpr (BD == 128) {
+            simdgroup_barrier(mem_flags::mem_none);
+          }
+
+          MMAFrag_acc_t::mma(
+              Otile.frag_at(iq, id),
+              Stile.frag_at(iq, ik),
+              Vtile.frag_at(0, 0),
+              Otile.frag_at(iq, id));
+        }
+      }
+    }
+
+    // Prepare for next iteration
+    loader_k.next();
+    loader_v.next();
+  }
+
+  // Normalize output
+  Otile.template row_bin_op<DivOp>(sum_score);
+  threadgroup_barrier(mem_flags::mem_none);
+
+  // Store results
+  O += (tm + sm) * params->O_strides[2] + sn;
+
+  if (!align_Q && int(tid.x) == (params->NQ_aligned)) {
+    auto dst_tile_dims = short2(BD - sn, params->qL_rem - (tm + sm));
+
+    if (dst_tile_dims.x <= 0 || dst_tile_dims.y <= 0)
+      return;
+
+    Otile.template store_safe<T, 1, 1>(O, params->O_strides[2], dst_tile_dims);
+  } else {
+    Otile.template store<T, 1, 1>(O, params->O_strides[2]);
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/kernels/steel_attention.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/kernels/steel_attention.metal
new file mode 100644
index 0000000000000000000000000000000000000000..fee28fed10a006798aeefc754acaf84a598950af
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/kernels/steel_attention.metal
@@ -0,0 +1,28 @@
+// Copyright © 2024-25 Apple Inc.
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+
+#include "mlx/backend/metal/kernels/steel/attn/attn.h"
+#include "mlx/backend/metal/kernels/steel/attn/kernels/steel_attention.h"
+
+#define instantiate_attn(tname, dtype, bq, bk, bd, wm, wn, mname, mtype) \
+  instantiate_kernel(                                                    \
+      "steel_attention_" #tname "_bq" #bq "_bk" #bk "_bd" #bd            \
+      "_wm" #wm "_wn" #wn "_mask" #mname,                                \
+  attention, dtype, bq, bk, bd, wm, wn, mtype, float)
+
+#define instantiate_attn_shapes_helper(iname, itype, mname, mtype)  \
+    instantiate_attn(iname, itype, 32, 16, 128, 4, 1, mname, mtype) \
+    instantiate_attn(iname, itype, 32, 32,  80, 4, 1, mname, mtype) \
+    instantiate_attn(iname, itype, 32, 32,  64, 4, 1, mname, mtype)
+
+#define instantiate_attn_mask_helper(iname, itype) \
+    instantiate_attn_shapes_helper(iname, itype, iname, itype) \
+    instantiate_attn_shapes_helper(iname, itype, bool_, bool)
+
+instantiate_attn_mask_helper(float16, half);
+instantiate_attn_mask_helper(bfloat16, bfloat16_t);
+
+instantiate_attn_mask_helper(float32, float);
+// clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/loader.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/loader.h
new file mode 100644
index 0000000000000000000000000000000000000000..7ec798146b29f35efcfe3379a21ff90a53f41e67
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/loader.h
@@ -0,0 +1,264 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/steel/defines.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Loading helper
+///////////////////////////////////////////////////////////////////////////////
+
+namespace mlx {
+namespace steel {
+
+template <
+    typename T,
+    short BROWS,
+    short BCOLS,
+    short dst_ld,
+    short reduction_dim,
+    short tgp_size,
+    short alignment = 1,
+    short n_reads = (BCOLS * BROWS) / (tgp_size),
+    short TCOLS = BCOLS / n_reads,
+    short TROWS = tgp_size / TCOLS>
+struct BlockLoader {
+  STEEL_CONST short n_rows = (BROWS + TROWS - 1) / TROWS;
+  STEEL_CONST short vec_size = n_reads;
+
+  // Leading dimension for src
+  const int src_ld;
+  const int tile_stride;
+
+  // Thread location indices
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  // threadgroup and device memory
+  threadgroup T* dst;
+  const device T* src;
+
+  struct alignas(alignment * sizeof(T)) ReadVector {
+    uint8_t v[sizeof(T) * vec_size];
+  };
+
+  /* Constructor */
+  METAL_FUNC BlockLoader(
+      const device T* src_,
+      const int src_ld_,
+      threadgroup T* dst_,
+      ushort simd_group_id [[simdgroup_index_in_threadgroup]],
+      ushort simd_lane_id [[thread_index_in_simdgroup]])
+      : src_ld(src_ld_),
+        tile_stride(reduction_dim ? BCOLS : BROWS * src_ld),
+        thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(thread_idx / TCOLS),
+        bj(vec_size * (thread_idx % TCOLS)),
+        dst(dst_ + bi * dst_ld + bj),
+        src(src_ + bi * src_ld + bj) {}
+
+  /* Apply operation to threadgroup without bound checking */
+  template <typename UnaryOp>
+  METAL_FUNC void apply_inplace_op(thread const UnaryOp& op) const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < BROWS; i += TROWS) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        dst[i * dst_ld + j] = op.apply(dst[i * dst_ld + j]);
+      }
+    }
+  }
+
+  /* Load from device memory into threadgroup memory - without bound checking */
+  METAL_FUNC void load_unsafe() const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < BROWS; i += TROWS) {
+      *((threadgroup ReadVector*)(&dst[i * dst_ld])) =
+          *((const device ReadVector*)(&src[i * src_ld]));
+    }
+  }
+
+  /* Load from device memory into threadgroup memory - with bound checking */
+  METAL_FUNC void load_safe(short2 src_tile_dim) const {
+    src_tile_dim = src_tile_dim - short2(bj, bi);
+
+    // Skip loading if thread has no valid reads
+    if (src_tile_dim.x <= 0 || src_tile_dim.y <= 0) {
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < BROWS; i += TROWS) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; j++) {
+          dst[i * dst_ld + j] = T(0);
+        }
+      }
+      return;
+    }
+
+    // Use fast thread memory for bound checks
+    bool tmp_idx[vec_size];
+    T tmp_val[vec_size];
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < BROWS; i += TROWS) {
+      // Make sure tmp_idx only contains valid indices
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        tmp_idx[j] = (i < src_tile_dim.y) && (j < src_tile_dim.x);
+      }
+
+      // Read valid indices into tmp_val
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        tmp_val[j] = src[(tmp_idx[j] ? i * src_ld + j : 0)];
+      }
+
+      // Zero out unneeded values
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        tmp_val[j] = tmp_idx[j] ? tmp_val[j] : T(0);
+      }
+
+      // Copy values to threadgroup memory
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        dst[i * dst_ld + j] = tmp_val[j];
+      }
+    }
+  }
+
+  /* Iteration helper */
+  METAL_FUNC void next() {
+    src += tile_stride;
+  }
+};
+
+template <int R, int C>
+struct CShape {
+  STEEL_CONST int kRows = R;
+  STEEL_CONST int kCols = C;
+};
+
+template <
+    typename T,
+    short BROWS,
+    short BCOLS,
+    short kDstStrRow,
+    short kDstStrCol,
+    short reduction_dim,
+    short tgp_size,
+    short n_reads = (BCOLS * BROWS) / (tgp_size),
+    short TCOLS = BCOLS / n_reads,
+    short TROWS = tgp_size / TCOLS>
+struct BlockLoaderT {
+  STEEL_CONST short n_rows = (BROWS + TROWS - 1) / TROWS;
+  STEEL_CONST short vec_size = n_reads;
+
+  // Leading dimension for src
+  const int src_ld;
+  const int tile_stride;
+
+  // Thread location indices
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  // threadgroup and device memory
+  threadgroup T* dst;
+  const device T* src;
+
+  /* Constructor */
+  METAL_FUNC BlockLoaderT(
+      const device T* src_,
+      const int src_ld_,
+      threadgroup T* dst_,
+      ushort simd_group_id [[simdgroup_index_in_threadgroup]],
+      ushort simd_lane_id [[thread_index_in_simdgroup]])
+      : src_ld(src_ld_),
+        tile_stride(reduction_dim ? BCOLS : BROWS * src_ld),
+        thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(thread_idx / TCOLS),
+        bj(vec_size * (thread_idx % TCOLS)),
+        dst(dst_ + bi * kDstStrRow + bj * kDstStrCol),
+        src(src_ + bi * src_ld + bj) {}
+
+  /* Apply operation to threadgroup without bound checking */
+  template <typename UnaryOp>
+  METAL_FUNC void apply_inplace_op(thread const UnaryOp& op) const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < BROWS; i += TROWS) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        dst[i * kDstStrRow + j * kDstStrCol] =
+            op.apply(dst[i * kDstStrRow + j * kDstStrCol]);
+      }
+    }
+  }
+
+  /* Load from device memory into threadgroup memory - without bound checking */
+  METAL_FUNC void load_unsafe() const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < BROWS; i += TROWS) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        dst[i * kDstStrRow + j * kDstStrCol] = src[i * src_ld + j];
+      }
+    }
+  }
+
+  /* Load from device memory into threadgroup memory - with bound checking */
+  METAL_FUNC void load_safe(short2 src_tile_dim) const {
+    src_tile_dim = src_tile_dim - short2(bj, bi);
+
+    // Skip loading if thread has no valid reads
+    if (src_tile_dim.x <= 0 || src_tile_dim.y <= 0) {
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < BROWS; i += TROWS) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; j++) {
+          dst[i * kDstStrRow + j * kDstStrCol] = T(0);
+        }
+      }
+      return;
+    }
+
+    // Use fast thread memory for bound checks
+    bool tmp_idx[vec_size];
+    T tmp_val[vec_size];
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < BROWS; i += TROWS) {
+      // Make sure tmp_idx only contains valid indices
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        tmp_idx[j] = (i < src_tile_dim.y) && (j < src_tile_dim.x);
+      }
+
+      // Read valid indices into tmp_val
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        tmp_val[j] = src[(tmp_idx[j] ? i * src_ld + j : 0)];
+      }
+
+      // Zero out unneeded values
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        tmp_val[j] = tmp_idx[j] ? tmp_val[j] : T(0);
+      }
+
+      // Copy values to threadgroup memory
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        dst[i * kDstStrRow + j * kDstStrCol] = tmp_val[j];
+      }
+    }
+  }
+
+  /* Iteration helper */
+  METAL_FUNC void next() {
+    src += tile_stride;
+  }
+};
+
+} // namespace steel
+} // namespace mlx
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/mma.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/mma.h
new file mode 100644
index 0000000000000000000000000000000000000000..db5127c33a14ad72eface52d717f21c63a9d8a92
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/mma.h
@@ -0,0 +1,747 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include <metal_simdgroup>
+#include <metal_simdgroup_matrix>
+#include <metal_stdlib>
+
+#include "mlx/backend/metal/kernels/steel/attn/transforms.h"
+#include "mlx/backend/metal/kernels/steel/defines.h"
+#include "mlx/backend/metal/kernels/steel/utils/integral_constant.h"
+
+using namespace metal;
+
+///////////////////////////////////////////////////////////////////////////////
+// MMA helper
+///////////////////////////////////////////////////////////////////////////////
+
+namespace mlx {
+namespace steel {
+
+template <typename RInt, typename CInt>
+struct Shape2D {
+  RInt r;
+  CInt c;
+
+  Shape2D(RInt r_, CInt c_) : r(r_), c(c_) {}
+};
+
+template <typename Shape, typename Layout>
+struct Layout2D {
+  Shape shape;
+  Layout layout;
+};
+
+template <typename T, int kFragRows_, int kFragCols_>
+struct BaseMMAFrag {
+  static_assert(
+      kFragRows_ == 8,
+      "Only 8 x 8 fragment matrices are currently supported");
+  static_assert(
+      kFragCols_ == 8,
+      "Only 8 x 8 fragment matrices are currently supported");
+};
+
+template <typename T>
+struct BaseMMAFrag<T, 8, 8> {
+  STEEL_CONST int kFragRows = 8;
+  STEEL_CONST int kFragCols = 8;
+
+  STEEL_CONST int kElemsPerFrag = (kFragRows * kFragCols) / 32;
+
+  STEEL_CONST int kElemRows = 1;
+  STEEL_CONST int kElemCols = 2;
+
+  static_assert(
+      kElemRows * kElemCols == kElemsPerFrag,
+      "MMAFrag shape is not consistent with MMAFrag size");
+
+  typedef metal::simdgroup_matrix<T, kFragRows, kFragCols> mat_type;
+  typedef metal::vec<T, kElemsPerFrag> frag_type;
+  typedef metal::vec<T, kElemRows> row_frag_type;
+  typedef metal::vec<T, kElemCols> col_frag_type;
+
+  template <typename U>
+  using dtype_mat_t = typename metal::simdgroup_matrix<U, kFragRows, kFragCols>;
+
+  template <typename U>
+  using dtype_frag_t = typename metal::vec<U, kElemsPerFrag>;
+
+  METAL_FUNC static constexpr short2 get_coord(ushort simd_lane_id
+                                               [[thread_index_in_simdgroup]]) {
+    const short qid = simd_lane_id / 4;
+    const short fm = (qid & 4) + ((simd_lane_id / 2) % 4);
+    const short fn = (qid & 2) * 2 + (simd_lane_id % 2) * 2;
+    return short2{fn, fm};
+  }
+
+  template <typename SrcPtrType, typename StrX, typename StrY>
+  METAL_FUNC static constexpr void
+  load(thread frag_type& dst, SrcPtrType src, StrX str_x, StrY str_y) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kElemRows; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kElemCols; j++) {
+        dst[i * kElemCols + j] = static_cast<T>(src[i * str_x + j * str_y]);
+      }
+    }
+  }
+
+  template <
+      typename SrcPtrType,
+      typename StrX,
+      typename StrY,
+      typename LimX,
+      typename LimY,
+      typename OffX,
+      typename OffY>
+  METAL_FUNC static constexpr void load_safe(
+      thread frag_type& dst,
+      SrcPtrType src,
+      StrX str_x,
+      StrY str_y,
+      LimX lim_x,
+      LimY lim_y,
+      OffX off_x = Int<0>{},
+      OffY off_y = Int<0>{}) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kElemRows; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kElemCols; j++) {
+        if ((off_x + i) < lim_x && (off_y + j) < lim_y) {
+          dst[i * kElemCols + j] =
+              static_cast<T>(src[(off_x + i) * str_x + (off_y + j) * str_y]);
+        } else {
+          dst[i * kElemCols + j] = T(0);
+        }
+      }
+    }
+  }
+
+  template <typename DstPtrType, typename StrX, typename StrY>
+  METAL_FUNC static constexpr void
+  store(const thread frag_type& src, DstPtrType dst, StrX str_x, StrY str_y) {
+    using U = pointer_element_t<DstPtrType>;
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kElemRows; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kElemCols; j++) {
+        dst[i * str_x + j * str_y] = static_cast<U>(src[i * kElemCols + j]);
+      }
+    }
+  }
+
+  template <
+      typename DstPtrType,
+      typename StrX,
+      typename StrY,
+      typename LimX,
+      typename LimY,
+      typename OffX,
+      typename OffY>
+  METAL_FUNC static constexpr void store_safe(
+      const thread frag_type& src,
+      DstPtrType dst,
+      StrX str_x,
+      StrY str_y,
+      LimX lim_x,
+      LimY lim_y,
+      OffX off_x = Int<0>{},
+      OffY off_y = Int<0>{}) {
+    using U = pointer_element_t<DstPtrType>;
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kElemRows; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kElemCols; j++) {
+        if ((off_x + i) < lim_x && (off_y + j) < lim_y) {
+          dst[(off_x + i) * str_x + (off_y + j) * str_y] =
+              static_cast<U>(src[i * kElemCols + j]);
+        }
+      }
+    }
+  }
+
+  template <typename Atype, typename Btype, typename Ctype>
+  METAL_FUNC static constexpr void mma(
+      thread frag_type& D,
+      thread dtype_frag_t<Atype>& A,
+      thread dtype_frag_t<Btype>& B,
+      thread dtype_frag_t<Ctype>& C) {
+    mat_type D_mat;
+    dtype_mat_t<Atype> A_mat;
+    dtype_mat_t<Btype> B_mat;
+    dtype_mat_t<Ctype> C_mat;
+
+    reinterpret_cast<thread dtype_frag_t<Atype>&>(A_mat.thread_elements()) = A;
+    reinterpret_cast<thread dtype_frag_t<Btype>&>(B_mat.thread_elements()) = B;
+    reinterpret_cast<thread dtype_frag_t<Ctype>&>(C_mat.thread_elements()) = C;
+
+    mma(D_mat, A_mat, B_mat, C_mat);
+
+    D = reinterpret_cast<thread frag_type&>(D_mat.thread_elements());
+  }
+
+  template <typename Atype, typename Btype, typename Ctype>
+  METAL_FUNC static constexpr void mma(
+      thread mat_type& D,
+      thread dtype_mat_t<Atype>& A,
+      thread dtype_mat_t<Btype>& B,
+      thread dtype_mat_t<Ctype>& C) {
+    simdgroup_multiply_accumulate(D, A, B, C);
+  }
+
+  template <typename Op>
+  METAL_FUNC static constexpr void row_reduce(
+      thread const frag_type& inp_vals,
+      thread T* reduced_vals) {
+    T thr_reduce = Op::apply(inp_vals.x, inp_vals.y);
+
+    T qgr_reduce = simd_shuffle_xor(thr_reduce, ushort(1));
+    qgr_reduce = Op::apply(thr_reduce, qgr_reduce);
+
+    T sgr_reduce = simd_shuffle_xor(qgr_reduce, ushort(8));
+    sgr_reduce = Op::apply(qgr_reduce, sgr_reduce);
+
+    reduced_vals[0] = Op::apply(reduced_vals[0], sgr_reduce);
+  }
+
+  template <typename Op>
+  METAL_FUNC static constexpr void row_bin_op(
+      thread frag_type& inp_vals,
+      thread T* row_vals) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kElemRows; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kElemCols; j++) {
+        inp_vals[i * kElemCols + j] =
+            Op::apply(inp_vals[i * kElemCols + j], row_vals[i]);
+      }
+    }
+  }
+};
+
+template <
+    typename T,
+    int kTileRows_,
+    int kTileCols_,
+    class MMAFrag_ = BaseMMAFrag<T, 8, 8>>
+struct MMATile {
+  using MMAFrag_t = MMAFrag_;
+  using elem_type = T;
+  STEEL_CONST int kFragRows = MMAFrag_t::kFragRows;
+  STEEL_CONST int kFragCols = MMAFrag_t::kFragCols;
+  STEEL_CONST int kElemsPerFrag = MMAFrag_t::kElemsPerFrag;
+
+  STEEL_CONST int kTileRows = kTileRows_;
+  STEEL_CONST int kTileCols = kTileCols_;
+
+  STEEL_CONST int kRows = kTileRows * kFragRows;
+  STEEL_CONST int kCols = kTileCols * kFragCols;
+
+  STEEL_CONST int kNumFrags = kTileRows * kTileCols;
+  STEEL_CONST int kElemsPerTile = kNumFrags * kElemsPerFrag;
+
+  STEEL_CONST int kRowsPerThread = kTileRows * MMAFrag_t::kElemRows;
+  STEEL_CONST int kColsPerThread = kTileCols * MMAFrag_t::kElemCols;
+
+  typedef typename MMAFrag_t::mat_type mat_type;
+  typedef typename MMAFrag_t::frag_type frag_type;
+
+  frag_type val_frags[kNumFrags]; // = {frag_type(0)};
+
+  METAL_FUNC MMATile() thread {}
+
+  METAL_FUNC constexpr void clear() {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kNumFrags; ++i) {
+      val_frags[i] = frag_type(0);
+    }
+  }
+
+  METAL_FUNC constexpr thread frag_type& frag_at(const short i, const short j) {
+    return val_frags[i * kTileCols + j];
+  }
+
+  METAL_FUNC constexpr const thread frag_type& frag_at(
+      const short i,
+      const short j) const {
+    return val_frags[i * kTileCols + j];
+  }
+
+  METAL_FUNC mat_type mat_at(const short i, const short j) {
+    mat_type val_mat;
+    STEEL_PRAGMA_UNROLL
+    for (short ii = 0; ii < kElemsPerFrag; ++ii) {
+      val_mat.thread_elements()[ii] = frag_at(i, j)[ii];
+    }
+    return val_mat;
+  }
+
+  METAL_FUNC thread elem_type* elems() {
+    return reinterpret_cast<thread elem_type*>(val_frags);
+  }
+
+  METAL_FUNC const thread elem_type* elems() const {
+    return reinterpret_cast<const thread elem_type*>(val_frags);
+  }
+
+  template <typename Op>
+  METAL_FUNC void row_reduce(thread T vals[kRowsPerThread]) const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::template row_reduce<Op>(
+            frag_at(i, j), &vals[i * MMAFrag_t::kElemRows]);
+      }
+    }
+  }
+
+  template <typename Op>
+  METAL_FUNC void row_bin_op(thread T vals[kRowsPerThread]) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::template row_bin_op<Op>(
+            frag_at(i, j), &vals[i * MMAFrag_t::kElemRows]);
+      }
+    }
+  }
+
+  template <typename U, int w_x, int w_y, int str_x, int str_y>
+  METAL_FUNC void load(const threadgroup U* src) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::load(
+            frag_at(i, j),
+            &(
+                src[(i * kFragRows) * w_x * str_x +
+                    (j * kFragCols) * w_y * str_y]),
+            Int<str_x>{},
+            Int<str_y>{});
+      }
+    }
+  }
+
+  template <typename U, int w_x, int w_y, int str_x, int str_y>
+  METAL_FUNC void store(threadgroup U* dst) const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::store(
+            frag_at(i, j),
+            &(
+                dst[(i * kFragRows) * w_x * str_x +
+                    (j * kFragCols) * w_y * str_y]),
+            Int<str_x>{},
+            Int<str_y>{});
+      }
+    }
+  }
+
+  template <typename U, int w_x, int w_y>
+  METAL_FUNC void load(const device U* src, const int ld) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::load(
+            frag_at(i, j),
+            &(src[(i * kFragRows) * w_x * ld + (j * kFragCols) * w_y]),
+            ld,
+            Int<1>{});
+      }
+    }
+  }
+
+  template <typename U, int w_x, int w_y>
+  METAL_FUNC void store(device U* dst, const int ld) const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::store(
+            frag_at(i, j),
+            &(dst[(i * kFragRows) * w_x * ld + (j * kFragCols) * w_y]),
+            ld,
+            Int<1>{});
+      }
+    }
+  }
+
+  template <typename U, int w_x, int w_y>
+  METAL_FUNC void
+  load_safe(const device U* src, const int ld, const short2 src_tile_dims) {
+    STEEL_PRAGMA_UNROLL
+    for (int i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (int j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::load_safe(
+            frag_at(i, j),
+            src,
+            ld,
+            Int<1>{},
+            src_tile_dims.y,
+            src_tile_dims.x,
+            (i * kFragRows) * w_x,
+            (j * kFragCols) * w_y);
+      }
+    }
+  }
+
+  template <typename U, int w_x, int w_y>
+  METAL_FUNC void
+  store_safe(device U* dst, const int ld, const short2 dst_tile_dims) const {
+    STEEL_PRAGMA_UNROLL
+    for (int i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (int j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::store_safe(
+            frag_at(i, j),
+            dst,
+            ld,
+            Int<1>{},
+            dst_tile_dims.y,
+            dst_tile_dims.x,
+            (i * kFragRows) * w_x,
+            (j * kFragCols) * w_y);
+      }
+    }
+  }
+};
+
+template <
+    typename Dtype,
+    typename Atype,
+    typename Btype,
+    typename Ctype,
+    int M,
+    int N,
+    int K,
+    class MMAFragD,
+    class MMAFragA,
+    class MMAFragB,
+    class MMAFragC>
+METAL_FUNC void tile_matmad(
+    thread MMATile<Dtype, M, N, MMAFragD>& D,
+    thread MMATile<Atype, M, K, MMAFragA>& A,
+    thread MMATile<Btype, K, N, MMAFragB>& B,
+    thread MMATile<Ctype, M, N, MMAFragC>& C) {
+  STEEL_PRAGMA_UNROLL
+  for (short m = 0; m < M; ++m) {
+    STEEL_PRAGMA_UNROLL
+    for (short n = 0; n < N; ++n) {
+      short m_serp = m; //(n % 2) ? (M - 1 - m) : m;
+      short n_serp = (m % 2) ? (N - 1 - n) : n;
+
+      STEEL_PRAGMA_UNROLL
+      for (short k = 0; k < K; ++k) {
+        MMAFragD::mma(
+            D.frag_at(m_serp, n_serp),
+            A.frag_at(m_serp, k),
+            B.frag_at(k, n_serp),
+            C.frag_at(m_serp, n_serp));
+      }
+    }
+  }
+}
+
+template <
+    typename T,
+    typename U,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    short lda_tgp,
+    short ldb_tgp,
+    typename AccumType = float,
+    typename Epilogue = TransformNone<U, AccumType>>
+struct BlockMMA {
+  // MMAFrag size
+  STEEL_CONST short kFragSize = 8;
+  using MMAFrag_acc_t = BaseMMAFrag<AccumType, kFragSize, kFragSize>;
+
+  // Warp tile simdgroup matrix strides along M
+  STEEL_CONST short TM_stride = kFragSize * WM;
+  // Warp tile simdgroup matrix strides along M
+  STEEL_CONST short TN_stride = kFragSize * WN;
+
+  // Warp tile size along M
+  STEEL_CONST short TM = BM / TM_stride;
+  // Warp tile size along N
+  STEEL_CONST short TN = BN / TN_stride;
+
+  // Threadgroup A strides
+  STEEL_CONST short A_str_m = transpose_a ? 1 : lda_tgp; // M
+  STEEL_CONST short A_str_k = transpose_a ? lda_tgp : 1; // K
+
+  // Threadgroup B strides
+  STEEL_CONST short B_str_k = transpose_b ? 1 : ldb_tgp; // K
+  STEEL_CONST short B_str_n = transpose_b ? ldb_tgp : 1; // N
+
+  // Threadgroup strides along K
+  STEEL_CONST short tile_stride_a = kFragSize * A_str_k;
+  STEEL_CONST short tile_stride_b = kFragSize * B_str_k;
+
+  // Simdgroup matrices
+  MMATile<AccumType, TM, 1, MMAFrag_acc_t> Atile;
+  MMATile<AccumType, 1, TN, MMAFrag_acc_t> Btile;
+  MMATile<AccumType, TM, TN, MMAFrag_acc_t> Ctile;
+
+  // Offsets within threadgroup
+  short sm;
+  short sn;
+
+  short As_offset;
+  short Bs_offset;
+
+  /* Constructor */
+  METAL_FUNC BlockMMA(
+      ushort simd_group_id [[simdgroup_index_in_threadgroup]],
+      ushort simd_lane_id [[thread_index_in_simdgroup]]) {
+    // Determine thread position in simdgroup matrix
+    short tm = kFragSize * (simd_group_id / WN);
+    short tn = kFragSize * (simd_group_id % WN);
+
+    short2 simd_coord = MMAFrag_acc_t::get_coord(simd_lane_id);
+    sm = simd_coord.y;
+    sn = simd_coord.x;
+
+    // Determine thread and simdgroup offset
+    As_offset = (tm + sm) * A_str_m + (sn)*A_str_k; // M, K
+    Bs_offset = (sm)*B_str_k + (tn + sn) * B_str_n; // K, N
+
+    sm += tm;
+    sn += tn;
+  }
+
+  /* (BM, BK) X (BK, BN) multiply accumulate function */
+  METAL_FUNC void mma(const threadgroup T* As, const threadgroup T* Bs) {
+    // Adjust for simdgroup and thread location
+    As += As_offset;
+    Bs += Bs_offset;
+
+    // Iterate over BK in blocks of kFragSize
+    STEEL_PRAGMA_UNROLL
+    for (short kk = 0; kk < BK; kk += kFragSize) {
+      simdgroup_barrier(mem_flags::mem_none);
+
+      Atile.template load<T, WM, 1, A_str_m, A_str_k>(As);
+
+      simdgroup_barrier(mem_flags::mem_none);
+
+      Btile.template load<T, 1, WN, B_str_k, B_str_n>(Bs);
+
+      simdgroup_barrier(mem_flags::mem_none);
+
+      tile_matmad(Ctile, Atile, Btile, Ctile);
+
+      // Progress to next simdgroup tile
+      As += tile_stride_a;
+      Bs += tile_stride_b;
+    }
+  }
+
+  /* Store results from simdgroup_matrix results into device memory */
+  METAL_FUNC void store_result(device U* D, const int ldd) {
+    // Apply epilogue
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < decltype(Ctile)::kElemsPerTile; i++) {
+      Ctile.elems()[i] = Epilogue::apply(Ctile.elems()[i]);
+    }
+
+    // Adjust for simdgroup and thread location
+    D += sm * ldd + sn;
+
+    Ctile.template store<U, WM, WN>(D, ldd);
+  }
+
+  METAL_FUNC void
+  store_result_safe(device U* D, const int ldd, short2 dst_tile_dims) {
+    // Apply epilogue
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < decltype(Ctile)::kElemsPerTile; i++) {
+      Ctile.elems()[i] = Epilogue::apply(Ctile.elems()[i]);
+    }
+
+    // Adjust for simdgroup and thread location
+    D += sm * ldd + sn;
+    dst_tile_dims -= short2(sn, sm);
+
+    if (dst_tile_dims.x <= 0 || dst_tile_dims.y <= 0)
+      return;
+
+    Ctile.template store_safe<U, WM, WN>(D, ldd, dst_tile_dims);
+  }
+
+  /* Apply epilogue */
+  template <typename UnaryEpilogue>
+  METAL_FUNC void apply_epilogue(thread const UnaryEpilogue& epilogue_op) {
+    // Loop over all simdgroup tiles
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < decltype(Ctile)::kElemsPerTile; i++) {
+      Ctile.elems()[i] = epilogue_op.apply(Ctile.elems()[i]);
+    }
+  }
+
+  /* Apply epilogue */
+  template <typename BinaryEpilogue>
+  METAL_FUNC void apply_epilogue(
+      const device U* C,
+      const int ldc,
+      const int fdc,
+      thread const BinaryEpilogue& epilogue_op) {
+    // Adjust for simdgroup and thread location
+    C += (sm)*ldc + (sn)*fdc;
+
+    // Loop over all simdgroup tiles
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < TM; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < TN; j++) {
+        // Get accumulated result and associated offset in C
+        thread auto& accum = Ctile.frag_at(i, j);
+        int offset_c = (i * TM_stride) * ldc + (j * TN_stride) * fdc;
+
+        // Apply epilogue
+        STEEL_PRAGMA_UNROLL
+        for (short k = 0; k < decltype(Ctile)::kElemsPerFrag; k++) {
+          accum[k] = epilogue_op.apply(accum[k], C[offset_c + k * fdc]);
+        }
+      }
+    }
+  }
+
+  /* Apply epilogue */
+  template <typename BinaryEpilogue>
+  METAL_FUNC void apply_epilogue_safe(
+      const device U* C,
+      const int ldc,
+      const int fdc,
+      short2 dst_tile_dims,
+      thread const BinaryEpilogue& epilogue_op) {
+    // Adjust for simdgroup and thread location
+    C += (sm)*ldc + (sn)*fdc;
+    dst_tile_dims -= short2(sn, sm);
+
+    if (dst_tile_dims.x <= 0 || dst_tile_dims.y <= 0)
+      return;
+
+    // Loop over all simdgroup tiles
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < TM; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < TN; j++) {
+        // Get accumulated result and associated offset in C
+        thread auto& accum = Ctile.frag_at(i, j);
+        int offset_c = (i * TM_stride) * ldc + (j * TN_stride) * fdc;
+
+        constexpr short kelems = decltype(Ctile)::kElemsPerFrag;
+
+        // Read C
+        U c_elems[kelems] = {0};
+
+        STEEL_PRAGMA_UNROLL
+        for (short k = 0; k < kelems; k++) {
+          if ((j * TN_stride + k) < dst_tile_dims.x) {
+            c_elems[k] = C[offset_c + k * fdc];
+          }
+        }
+
+        // Apply epilogue
+        STEEL_PRAGMA_UNROLL
+        for (short k = 0; k < kelems; k++) {
+          accum[k] = epilogue_op.apply(accum[k], c_elems[k]);
+        }
+      }
+    }
+  }
+
+  /* Store results from simdgroup_matrix results into device memory */
+  METAL_FUNC void store_result(
+      device U* D,
+      const int ldd,
+      const device U* C,
+      const int ldc,
+      const int fdc,
+      thread const Epilogue& epilogue_op) const {
+    // Adjust for simdgroup and thread location
+    C += (sm)*ldc + (sn)*fdc;
+    D += (sm)*ldd + sn;
+
+    constexpr short kelems = decltype(Ctile)::kElemsPerFrag;
+
+    // Loop over all simdgroup tiles
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < TM; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < TN; j++) {
+        // Get accumulated result and associated offset in C
+        thread const auto& accum = Ctile.frag_at(i, j);
+        int offset_c = (i * TM_stride) * ldc + (j * TN_stride) * fdc;
+        int offset_d = (i * TM_stride) * ldd + (j * TN_stride);
+
+        // Apply epilogue
+        STEEL_PRAGMA_UNROLL
+        for (short k = 0; k < kelems; k++) {
+          D[offset_d + k] = epilogue_op.apply(accum[k], C[offset_c + k * fdc]);
+        }
+      }
+    }
+  }
+
+  METAL_FUNC void store_result_safe(
+      device U* D,
+      const int ldd,
+      const device U* C,
+      const int ldc,
+      const int fdc,
+      short2 dst_tile_dims,
+      thread const Epilogue& epilogue_op) const {
+    // Adjust for simdgroup and thread location
+    C += (sm)*ldc + (sn)*fdc;
+    D += (sm)*ldd + sn;
+    dst_tile_dims -= short2(sn, sm);
+
+    if (dst_tile_dims.x <= 0 || dst_tile_dims.y <= 0)
+      return;
+
+    constexpr short kelems = decltype(Ctile)::kElemsPerFrag;
+
+    STEEL_PRAGMA_UNROLL
+    for (int i = 0; i < TM; i++) {
+      if (i * TM_stride < dst_tile_dims.y) {
+        STEEL_PRAGMA_UNROLL
+        for (int j = 0; j < TN; j++) {
+          // Get accumulated result and associated offset in C
+          thread const auto& accum = Ctile.frag_at(i, j);
+          int offset_c = (i * TM_stride) * ldc + (j * TN_stride) * fdc;
+          int offset_d = (i * TM_stride) * ldd + (j * TN_stride);
+
+          // Apply epilogue
+          STEEL_PRAGMA_UNROLL
+          for (short k = 0; k < kelems; k++) {
+            if ((j * TN_stride + k) < dst_tile_dims.x) {
+              D[offset_d + k] =
+                  epilogue_op.apply(accum[k], C[offset_c + k * fdc]);
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+} // namespace steel
+} // namespace mlx
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/params.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/params.h
new file mode 100644
index 0000000000000000000000000000000000000000..f1cf09fadaea47d5c03cd1159316cdbb5e1bd136
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/params.h
@@ -0,0 +1,44 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+///////////////////////////////////////////////////////////////////////////////
+// Attn param classes
+///////////////////////////////////////////////////////////////////////////////
+
+namespace mlx {
+namespace steel {
+
+struct AttnParams {
+  int B; ///< Batch Size
+  int H; ///< Heads
+  int D; ///< Head Dim
+
+  int qL; ///< Query Sequence Length
+  int kL; ///< Key Sequence Length
+
+  int gqa_factor; ///< Group Query factor
+  float scale; ///< Attention scale
+
+  int NQ; ///< Number of query blocks
+  int NK; ///< Number of key/value blocks
+
+  int NQ_aligned; ///< Number of full query blocks
+  int NK_aligned; ///< Number of full key/value blocks
+
+  int qL_rem; ///< Remainder in last query block
+  int kL_rem; ///< Remainder in last key/value block
+  int qL_off; ///< Offset in query sequence start
+
+  int64_t Q_strides[3]; ///< Query  strides (B, H, L, D = 1)
+  int64_t K_strides[3]; ///< Key    strides (B, H, L, D = 1)
+  int64_t V_strides[3]; ///< Value  strides (B, H, L, D = 1)
+  int64_t O_strides[3]; ///< Output strides (B, H, L, D = 1)
+};
+
+struct AttnMaskParams {
+  int64_t M_strides[3]; ///< Mask  strides (B, H, qL, kL = 1)
+};
+
+} // namespace steel
+} // namespace mlx
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/transforms.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/transforms.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0624d21b917f26a1c0e3b2787b5271765070dd2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/attn/transforms.h
@@ -0,0 +1,71 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/steel/utils.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Transforms and Epilogues
+///////////////////////////////////////////////////////////////////////////////
+
+namespace mlx {
+namespace steel {
+
+template <typename OutT, typename InT>
+struct TransformNone {
+  static METAL_FUNC OutT apply(InT x) {
+    return static_cast<OutT>(x);
+  }
+
+  static METAL_FUNC OutT apply(InT x, OutT) {
+    return static_cast<OutT>(x);
+  }
+};
+
+template <typename OutT, typename InT>
+struct TransformAdd {
+  TransformAdd(const float, const float) {}
+
+  static METAL_FUNC OutT apply(InT x) {
+    return static_cast<OutT>(x);
+  }
+
+  static METAL_FUNC OutT apply(InT x, OutT c) {
+    return static_cast<OutT>(x) + c;
+  }
+};
+
+template <typename OutT, typename InT>
+struct TransformAxpby {
+  const float alpha;
+  const float beta;
+
+  TransformAxpby(const float alpha_, const float beta_)
+      : alpha(alpha_), beta(beta_) {}
+
+  static METAL_FUNC OutT apply(InT x) {
+    return static_cast<OutT>(x);
+  }
+
+  METAL_FUNC OutT apply(InT x, OutT c) const {
+    return static_cast<OutT>(x * alpha + (beta * c));
+  }
+};
+
+template <typename T>
+struct AccumHelper {
+  typedef float accum_type;
+};
+
+struct BlockSwizzle {
+  static METAL_FUNC int2
+  swizzle(uint3 tid [[threadgroup_position_in_grid]], const int swizzle_log) {
+    const int tid_x = (tid.x) >> swizzle_log;
+    const int tid_y =
+        ((tid.y) << swizzle_log) + ((tid.x) & ((1 << swizzle_log) - 1));
+    return int2(tid_x, tid_y);
+  }
+};
+
+} // namespace steel
+} // namespace mlx
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/conv.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/conv.h
new file mode 100644
index 0000000000000000000000000000000000000000..d2e718f2e3c988823bf4d2243fe2120bcb56ad51
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/conv.h
@@ -0,0 +1,13 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/steel/defines.h"
+#include "mlx/backend/metal/kernels/steel/utils.h"
+
+#include "mlx/backend/metal/kernels/steel/conv/loader.h"
+#include "mlx/backend/metal/kernels/steel/conv/params.h"
+#include "mlx/backend/metal/kernels/steel/gemm/mma.h"
+
+using namespace metal;
+using namespace mlx::steel;
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/kernels/steel_conv.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/kernels/steel_conv.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f822c1dd9a2f52029b239adfe14fe91fccc1a0e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/kernels/steel_conv.h
@@ -0,0 +1,176 @@
+// Copyright © 2024 Apple Inc.
+
+#include <metal_stdlib>
+
+using namespace metal;
+
+template <
+    typename T,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    int N_CHANNELS = 0,
+    bool SMALL_FILTER = false>
+[[kernel, max_total_threads_per_threadgroup(WM* WN * 32)]] void
+implicit_gemm_conv_2d(
+    const device T* A [[buffer(0)]],
+    const device T* B [[buffer(1)]],
+    device T* C [[buffer(2)]],
+    const constant MLXConvParams<2>* params [[buffer(3)]],
+    const constant ImplicitGemmConv2DParams* gemm_params [[buffer(4)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  using namespace mlx::steel;
+
+  (void)lid;
+
+  constexpr bool transpose_a = false;
+  constexpr bool transpose_b = true;
+  constexpr short tgp_padding_a = 16 / sizeof(T);
+  constexpr short tgp_padding_b = 16 / sizeof(T);
+
+  constexpr short shape_a_cols = (transpose_a ? BM : BK) + tgp_padding_a;
+  constexpr short shape_b_cols = (transpose_b ? BK : BN) + tgp_padding_b;
+  constexpr short shape_a_rows = (transpose_a ? BK : BM);
+  constexpr short shape_b_rows = (transpose_b ? BN : BK);
+  constexpr short tgp_mem_size_a = shape_a_cols * shape_a_rows;
+  constexpr short tgp_mem_size_b = shape_b_cols * shape_b_rows;
+
+  constexpr short tgp_size = WM * WN * 32;
+
+  // Input loader
+
+  using loader_a_t = typename metal::conditional_t<
+      // Check for small channel specialization
+      N_CHANNELS != 0 && N_CHANNELS <= 4,
+
+      // Go to small channel specialization
+      Conv2DInputBlockLoaderSmallChannels<
+          T,
+          BM,
+          BN,
+          BK,
+          tgp_size,
+          N_CHANNELS,
+          tgp_padding_a>,
+
+      // Else go to general loader
+      typename metal::conditional_t<
+          // Check if filter size is small enough
+          SMALL_FILTER,
+
+          // Go to small filter specialization
+          Conv2DInputBlockLoaderSmallFilter<
+              T,
+              BM,
+              BN,
+              BK,
+              tgp_size,
+              tgp_padding_a>,
+
+          // Else go to large filter generalization
+          Conv2DInputBlockLoaderLargeFilter<
+              T,
+              BM,
+              BN,
+              BK,
+              tgp_size,
+              tgp_padding_a>>>;
+
+  // Weight loader
+  using loader_b_t = typename metal::conditional_t<
+      // Check for small channel specialization
+      N_CHANNELS != 0 && N_CHANNELS <= 4,
+
+      // Go to small channel specialization
+      Conv2DWeightBlockLoaderSmallChannels<
+          T,
+          BM,
+          BN,
+          BK,
+          tgp_size,
+          N_CHANNELS,
+          tgp_padding_b>,
+
+      // Else go to general loader
+      Conv2DWeightBlockLoader<T, BM, BN, BK, tgp_size, tgp_padding_b>>;
+
+  using mma_t = BlockMMA<
+      T,
+      T,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      transpose_a,
+      transpose_b,
+      shape_a_cols,
+      shape_b_cols>;
+
+  threadgroup T As[tgp_mem_size_a];
+  threadgroup T Bs[tgp_mem_size_b];
+
+  const int tid_y = ((tid.y) << gemm_params->swizzle_log) +
+      ((tid.x) & ((1 << gemm_params->swizzle_log) - 1));
+  const int tid_x = (tid.x) >> gemm_params->swizzle_log;
+
+  if (gemm_params->tiles_n <= tid_x || gemm_params->tiles_m <= tid_y) {
+    return;
+  }
+
+  const int c_row = tid_y * BM;
+  const int c_col = tid_x * BN;
+  const int K = gemm_params->K;
+  const int N = gemm_params->N;
+  const int C_per_group = params->C / params->groups;
+
+  // Groups
+  A += tid.z * C_per_group;
+  B += tid.z * N * K;
+  C += tid.z * N;
+
+  B += c_col * K;
+  C += c_row * (N * params->groups) + c_col;
+
+  const int2 offsets_a(0, c_row);
+  const int2 offsets_b(0, c_col);
+
+  // Prepare threadgroup loading operations
+  loader_a_t loader_a(
+      A, As, offsets_a, params, gemm_params, simd_gid, simd_lid);
+  loader_b_t loader_b(
+      B, Bs, offsets_b, params, gemm_params, simd_gid, simd_lid);
+
+  // Prepare threadgroup mma operation
+  mma_t mma_op(simd_gid, simd_lid);
+
+  int gemm_k_iterations = gemm_params->gemm_k_iterations;
+  for (int k = 0; k < gemm_k_iterations; k++) {
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+    // Load elements into threadgroup
+    loader_a.load_unsafe();
+    loader_b.load_unsafe();
+
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Multiply and accumulate threadgroup elements
+    mma_op.mma(As, Bs);
+
+    // Prepare for next iteration
+    loader_a.next();
+    loader_b.next();
+  }
+
+  threadgroup_barrier(mem_flags::mem_none);
+
+  // Store results to device memory
+  short tgp_bm = min(BM, gemm_params->M - c_row);
+  short tgp_bn = min(BN, gemm_params->N - c_col);
+  const int ldc = N * params->groups;
+  mma_op.store_result_safe(C, ldc, short2(tgp_bn, tgp_bm));
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/kernels/steel_conv.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/kernels/steel_conv.metal
new file mode 100644
index 0000000000000000000000000000000000000000..7851e5ef14bdef0757bc0731027c2ae1f4730f17
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/kernels/steel_conv.metal
@@ -0,0 +1,56 @@
+// Copyright © 2024 Apple Inc.
+
+#include <metal_stdlib>
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/steel/gemm/mma.h"
+#include "mlx/backend/metal/kernels/steel/conv/conv.h"
+#include "mlx/backend/metal/kernels/steel/conv/params.h"
+#include "mlx/backend/metal/kernels/steel/conv/kernels/steel_conv.h"
+
+#define instantiate_implicit_conv_2d(                                          \
+    name,                                                                      \
+    itype,                                                                     \
+    bm,                                                                        \
+    bn,                                                                        \
+    bk,                                                                        \
+    wm,                                                                        \
+    wn,                                                                        \
+    channel_name,                                                              \
+    n_channels,                                                                \
+    filter_name,                                                               \
+    small_filter)                                                              \
+  template [[host_name("implicit_gemm_conv_2d_" #name "_bm" #bm "_bn" #bn      \
+                       "_bk" #bk "_wm" #wm "_wn" #wn "_channel_" #channel_name \
+                       "_filter_" #filter_name)]] [[kernel]] void              \
+  implicit_gemm_conv_2d<itype, bm, bn, bk, wm, wn, n_channels, small_filter>(  \
+      const device itype* A [[buffer(0)]],                                     \
+      const device itype* B [[buffer(1)]],                                     \
+      device itype* C [[buffer(2)]],                                           \
+      const constant MLXConvParams<2>* params [[buffer(3)]],                   \
+      const constant ImplicitGemmConv2DParams* gemm_params [[buffer(4)]],      \
+      uint3 tid [[threadgroup_position_in_grid]],                              \
+      uint3 lid [[thread_position_in_threadgroup]],                            \
+      uint simd_gid [[simdgroup_index_in_threadgroup]],                        \
+      uint simd_lid [[thread_index_in_simdgroup]]);
+
+#define instantiate_implicit_2d_filter(name, itype, bm, bn, bk, wm, wn)           \
+    instantiate_implicit_conv_2d(name, itype, bm, bn, bk, wm, wn, l, 0, s, true)  \
+    instantiate_implicit_conv_2d(name, itype, bm, bn, bk, wm, wn, l, 0, l, false) \
+    instantiate_implicit_conv_2d(name, itype, bm, bn, bk, wm, wn, 1, 1, l, false) \
+    instantiate_implicit_conv_2d(name, itype, bm, bn, bk, wm, wn, 2, 2, l, false) \
+    instantiate_implicit_conv_2d(name, itype, bm, bn, bk, wm, wn, 3, 3, l, false) \
+    instantiate_implicit_conv_2d(name, itype, bm, bn, bk, wm, wn, 4, 4, l, false)
+
+#define instantiate_implicit_2d_blocks(name, itype)               \
+    instantiate_implicit_2d_filter(name, itype, 32,  8, 16, 4, 1) \
+    instantiate_implicit_2d_filter(name, itype, 64,  8, 16, 4, 1) \
+    instantiate_implicit_2d_filter(name, itype, 32, 32, 16, 2, 2) \
+    instantiate_implicit_2d_filter(name, itype, 32, 64, 16, 2, 2) \
+    instantiate_implicit_2d_filter(name, itype, 64, 32, 16, 2, 2) \
+    instantiate_implicit_2d_filter(name, itype, 64, 64, 16, 2, 2)
+
+instantiate_implicit_2d_blocks(float32, float);
+instantiate_implicit_2d_blocks(float16, half);
+instantiate_implicit_2d_blocks(bfloat16, bfloat16_t); // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/kernels/steel_conv_general.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/kernels/steel_conv_general.h
new file mode 100644
index 0000000000000000000000000000000000000000..9afebd307c4e169f460ae279f2d24a100a665d70
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/kernels/steel_conv_general.h
@@ -0,0 +1,225 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/backend/metal/kernels/steel/conv/loaders/loader_general.h"
+
+constant bool align_C [[function_constant(200)]];
+
+template <
+    typename T,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    typename AccumType = float,
+    typename Epilogue = TransformNone<T, AccumType>>
+[[kernel, max_total_threads_per_threadgroup(WM* WN * 32)]] void
+implicit_gemm_conv_2d_general(
+    const device T* A [[buffer(0)]],
+    const device T* B [[buffer(1)]],
+    device T* C [[buffer(2)]],
+    const constant MLXConvParams<2>* params [[buffer(3)]],
+    const constant ImplicitGemmConv2DParams* gemm_params [[buffer(4)]],
+    const constant Conv2DGeneralJumpParams* jump_params [[buffer(5)]],
+    const constant Conv2DGeneralBaseInfo* base_h [[buffer(6)]],
+    const constant Conv2DGeneralBaseInfo* base_w [[buffer(7)]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]],
+    uint simd_gid [[simdgroup_index_in_threadgroup]],
+    uint simd_lid [[thread_index_in_simdgroup]]) {
+  (void)lid;
+
+  constexpr bool transpose_a = false;
+  constexpr bool transpose_b = true;
+  constexpr short tgp_padding_a = 16 / sizeof(T);
+  constexpr short tgp_padding_b = 16 / sizeof(T);
+
+  constexpr short shape_a_cols = (transpose_a ? BM : BK) + tgp_padding_a;
+  constexpr short shape_b_cols = (transpose_b ? BK : BN) + tgp_padding_b;
+  constexpr short shape_a_rows = (transpose_a ? BK : BM);
+  constexpr short shape_b_rows = (transpose_b ? BN : BK);
+  constexpr short tgp_mem_size_a = shape_a_cols * shape_a_rows;
+  constexpr short tgp_mem_size_b = shape_b_cols * shape_b_rows;
+
+  constexpr short tgp_size = WM * WN * 32;
+
+  // Input loader
+  using loader_a_t =
+      Conv2DInputBlockLoaderGeneral<T, BM, BN, BK, tgp_size, tgp_padding_a>;
+
+  // Weight loader
+  using loader_b_t =
+      Conv2DWeightBlockLoaderGeneral<T, BM, BN, BK, tgp_size, tgp_padding_b>;
+
+  using mma_t = BlockMMA<
+      T,
+      T,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      transpose_a,
+      transpose_b,
+      shape_a_cols,
+      shape_b_cols>;
+
+  threadgroup T As[tgp_mem_size_a];
+  threadgroup T Bs[tgp_mem_size_b];
+
+  const int tid_y = ((tid.y) << gemm_params->swizzle_log) +
+      ((tid.x) & ((1 << gemm_params->swizzle_log) - 1));
+  const int tid_x = (tid.x) >> gemm_params->swizzle_log;
+
+  if (gemm_params->tiles_n <= tid_x || gemm_params->tiles_m <= tid_y) {
+    return;
+  }
+
+  const int tid_z = tid.z;
+
+  const int base_oh = tid_z / jump_params->f_out_jump_w;
+  const int base_ow = tid_z % jump_params->f_out_jump_w;
+
+  const int base_wh = base_h[base_oh].weight_base;
+  const int base_ww = base_w[base_ow].weight_base;
+
+  const int base_wh_size = base_h[base_oh].weight_size;
+  const int base_ww_size = base_w[base_ow].weight_size;
+
+  const int c_row = tid_y * BM;
+  const int c_col = tid_x * BN;
+  const int K = gemm_params->K;
+
+  B += c_col * K;
+
+  const int4 offsets_a(0, c_row, base_oh, base_ow);
+  const int2 offsets_b(0, c_col);
+
+  // Prepare threadgroup loading operations
+  loader_a_t loader_a(
+      A,
+      As,
+      offsets_a,
+      params,
+      jump_params,
+      base_wh,
+      base_ww,
+      simd_gid,
+      simd_lid);
+  loader_b_t loader_b(
+      B,
+      Bs,
+      offsets_b,
+      params,
+      jump_params,
+      base_wh,
+      base_ww,
+      simd_gid,
+      simd_lid);
+
+  // Prepare threadgroup mma operation
+  mma_t mma_op(simd_gid, simd_lid);
+
+  if (align_C) {
+    int gemm_k_iterations =
+        base_wh_size * base_ww_size * gemm_params->gemm_k_iterations;
+
+    for (int k = 0; k < gemm_k_iterations; k++) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      // Load elements into threadgroup
+      loader_a.load_unsafe();
+      loader_b.load_unsafe();
+
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      // Multiply and accumulate threadgroup elements
+      mma_op.mma(As, Bs);
+
+      // Prepare for next iteration
+      loader_a.next();
+      loader_b.next();
+    }
+  }
+
+  else {
+    for (int k = 1; k < gemm_params->gemm_k_iterations; k++) {
+      for (int j = 0; j < base_wh_size * base_ww_size; j++) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        // Load elements into threadgroup
+        loader_a.load_unsafe();
+        loader_b.load_unsafe();
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+
+        // Prepare for next iteration
+        loader_a.next();
+        loader_b.next();
+      }
+    }
+    const short remaining_k = params->C % BK;
+    for (int j = 0; j < base_wh_size * base_ww_size; j++) {
+      // Load elements into threadgroup
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      loader_a.load_safe(remaining_k);
+      loader_b.load_safe(remaining_k);
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      // Multiply and accumulate threadgroup elements
+      mma_op.mma(As, Bs);
+      // Prepare for next iteration
+      loader_a.next();
+      loader_b.next();
+    }
+  }
+
+  threadgroup_barrier(mem_flags::mem_none);
+
+  // Store results to device memory
+  {
+    // Adjust for simdgroup and thread location
+    int offset_m = c_row + mma_op.sm;
+    int offset_n = c_col + mma_op.sn;
+    C += offset_n;
+
+    if (offset_n >= gemm_params->N)
+      return;
+
+    short diff = gemm_params->N - offset_n;
+
+    STEEL_PRAGMA_UNROLL
+    for (int i = 0; i < mma_t::TM; i++) {
+      int cm = offset_m + i * mma_t::TM_stride;
+
+      int n = cm / jump_params->adj_out_hw;
+      int hw = cm % jump_params->adj_out_hw;
+      int oh =
+          (hw / jump_params->adj_out_w) * jump_params->f_out_jump_h + base_oh;
+      int ow =
+          (hw % jump_params->adj_out_w) * jump_params->f_out_jump_w + base_ow;
+
+      if (n < params->N && oh < params->oS[0] && ow < params->oS[1]) {
+        int offset_cm = n * params->out_strides[0] +
+            oh * params->out_strides[1] + ow * params->out_strides[2];
+
+        STEEL_PRAGMA_UNROLL
+        for (int j = 0; j < mma_t::TN; j++) {
+          // Get accumulated result and associated offset in C
+          thread const auto& accum = mma_op.Ctile.frag_at(i, j);
+          int offset = offset_cm + (j * mma_t::TN_stride);
+
+          constexpr short kelems = decltype(mma_op.Ctile)::kElemsPerFrag;
+
+          // Apply epilogue and output C
+          STEEL_PRAGMA_UNROLL
+          for (short k = 0; k < kelems; k++) {
+            if ((j * mma_t::TN_stride + k) < diff) {
+              C[offset + k] = Epilogue::apply(accum[k]);
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/kernels/steel_conv_general.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/kernels/steel_conv_general.metal
new file mode 100644
index 0000000000000000000000000000000000000000..23e8575ce661d7b7ea965164eb5310983c78ddb1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/kernels/steel_conv_general.metal
@@ -0,0 +1,47 @@
+// Copyright © 2024 Apple Inc.
+
+#include <metal_stdlib>
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/steel/gemm/mma.h"
+#include "mlx/backend/metal/kernels/steel/conv/conv.h"
+#include "mlx/backend/metal/kernels/steel/conv/params.h"
+#include "mlx/backend/metal/kernels/steel/utils.h"
+#include "mlx/backend/metal/kernels/steel/conv/kernels/steel_conv_general.h"
+
+using namespace metal;
+using namespace mlx::steel;
+
+#define instantiate_implicit_conv_2d(name, itype, bm, bn, bk, wm, wn)         \
+  template                                                                    \
+      [[host_name("implicit_gemm_conv_2d_general_" #name "_bm" #bm "_bn" #bn  \
+                  "_bk" #bk "_wm" #wm "_wn" #wn)]] [[kernel]] void            \
+      implicit_gemm_conv_2d_general<itype, bm, bn, bk, wm, wn>(               \
+          const device itype* A [[buffer(0)]],                                \
+          const device itype* B [[buffer(1)]],                                \
+          device itype* C [[buffer(2)]],                                      \
+          const constant MLXConvParams<2>* params [[buffer(3)]],              \
+          const constant ImplicitGemmConv2DParams* gemm_params [[buffer(4)]], \
+          const constant Conv2DGeneralJumpParams* jump_params [[buffer(5)]],  \
+          const constant Conv2DGeneralBaseInfo* base_h [[buffer(6)]],         \
+          const constant Conv2DGeneralBaseInfo* base_w [[buffer(7)]],         \
+          uint3 tid [[threadgroup_position_in_grid]],                         \
+          uint3 lid [[thread_position_in_threadgroup]],                       \
+          uint simd_gid [[simdgroup_index_in_threadgroup]],                   \
+          uint simd_lid [[thread_index_in_simdgroup]]);
+
+#define instantiate_implicit_2d_filter(name, itype, bm, bn, bk, wm, wn) \
+  instantiate_implicit_conv_2d(name, itype, bm, bn, bk, wm, wn)
+
+#define instantiate_implicit_2d_blocks(name, itype)               \
+    instantiate_implicit_2d_filter(name, itype, 32,  8, 16, 4, 1) \
+    instantiate_implicit_2d_filter(name, itype, 64,  8, 16, 4, 1) \
+    instantiate_implicit_2d_filter(name, itype, 32, 32, 16, 2, 2) \
+    instantiate_implicit_2d_filter(name, itype, 32, 64, 16, 2, 2) \
+    instantiate_implicit_2d_filter(name, itype, 64, 32, 16, 2, 2) \
+    instantiate_implicit_2d_filter(name, itype, 64, 64, 16, 2, 2)
+
+instantiate_implicit_2d_blocks(float32, float);
+instantiate_implicit_2d_blocks(float16, half);
+instantiate_implicit_2d_blocks(bfloat16, bfloat16_t); // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/loader.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/loader.h
new file mode 100644
index 0000000000000000000000000000000000000000..f84a640f4d34990ad7d19db218e7f4dbd2818ac0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/loader.h
@@ -0,0 +1,6 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/steel/conv/loaders/loader_channel_l.h"
+#include "mlx/backend/metal/kernels/steel/conv/loaders/loader_channel_n.h"
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/loaders/loader_channel_l.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/loaders/loader_channel_l.h
new file mode 100644
index 0000000000000000000000000000000000000000..d52642b7349eb50347f527b68820be9ead278e96
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/loaders/loader_channel_l.h
@@ -0,0 +1,451 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/steel/utils.h"
+
+#include "mlx/backend/metal/kernels/steel/conv/params.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Loading helper
+///////////////////////////////////////////////////////////////////////////////
+
+namespace mlx {
+namespace steel {
+
+template <
+    typename T,
+    short BM,
+    short BN,
+    short BK,
+    short tgp_size,
+    short tgp_padding = 0>
+struct Conv2DInputBlockLoaderLargeFilter {
+  // Destination dimensions
+  STEEL_CONST short BROWS = BM;
+  STEEL_CONST short BCOLS = BK;
+
+  // Read dimensions
+  STEEL_CONST short dst_ld = BCOLS + tgp_padding;
+  STEEL_CONST short vec_size = tgp_size / (BROWS * BCOLS) >= 8 ? 8 : 4;
+
+  // Thread read shape
+  STEEL_CONST short TCOLS = BCOLS / vec_size;
+  STEEL_CONST short TROWS = tgp_size / TCOLS;
+
+  // Rows / strided reads within the block
+  STEEL_CONST short n_rows = BROWS / TROWS;
+
+  // Thread location indices
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  // threadgroup and device memory
+  threadgroup T* dst;
+
+  const constant MLXConvParams<2>* params;
+  const constant ImplicitGemmConv2DParams* gemm_params;
+
+  short weight_h;
+  short weight_w;
+
+  const device T* src[n_rows];
+
+  int read_n[n_rows];
+  int read_ih[n_rows];
+  int read_iw[n_rows];
+
+  /* Constructor */
+  METAL_FUNC Conv2DInputBlockLoaderLargeFilter(
+      const device T* src_,
+      threadgroup T* dst_,
+      const int2 offsets,
+      const constant MLXConvParams<2>* params_,
+      const constant ImplicitGemmConv2DParams* gemm_params_,
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint simd_lane_id [[thread_index_in_simdgroup]])
+      : thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(thread_idx / TCOLS),
+        bj(vec_size * (thread_idx % TCOLS)),
+        dst(dst_ + bi * dst_ld + bj),
+        params(params_),
+        gemm_params(gemm_params_),
+        weight_h(0),
+        weight_w(0) {
+    int out_n_pixels = params->oS[0] * params->oS[1];
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < n_rows; ++i) {
+      int offset_nhw = offsets.y + bi + i * TROWS;
+      int n = offset_nhw / out_n_pixels;
+      int hw = offset_nhw % out_n_pixels;
+      int oh = hw / params->oS[1];
+      int ow = hw % params->oS[1];
+
+      int ih = oh * params->str[0] - params->pad[0];
+      int iw = ow * params->str[1] - params->pad[1];
+
+      read_n[i] = n;
+      read_ih[i] = ih;
+      read_iw[i] = iw;
+
+      // Adjust for flip
+      if (params->flip) {
+        ih += (params->wS[0] - 1) * params->kdil[0];
+        iw += (params->wS[1] - 1) * params->kdil[1];
+      }
+
+      // Read from input if in bounds
+      src[i] = src_ + n * params->in_strides[0] + ih * params->in_strides[1] +
+          iw * params->in_strides[2] + bj;
+    }
+  }
+
+  /* Load from device memory into threadgroup memory - without bound checking */
+  METAL_FUNC void load_unsafe() const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0, is = 0; i < n_rows; ++i, is += TROWS) {
+      // Find bounds
+      int n = read_n[i];
+      int ih = read_ih[i] + weight_h * params->kdil[0];
+      int iw = read_iw[i] + weight_w * params->kdil[1];
+
+      // Read from input if in bounds
+      if ((n < params->N) && (ih >= 0 && ih < params->iS[0]) &&
+          (iw >= 0 && iw < params->iS[1])) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; ++j) {
+          dst[is * dst_ld + j] = src[i][j];
+        }
+      }
+
+      // Zero pad otherwise
+      else {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; ++j) {
+          dst[is * dst_ld + j] = T(0);
+        }
+      }
+    }
+  }
+
+  /* Iteration helper */
+  METAL_FUNC void next() {
+    if (++weight_w < params->wS[1]) {
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < n_rows; i++) {
+        src[i] += gemm_params->inp_jump_w;
+      }
+
+      return;
+    }
+
+    weight_w = 0;
+
+    if (++weight_h < params->wS[0]) {
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < n_rows; i++) {
+        src[i] += gemm_params->inp_jump_h;
+      }
+
+      return;
+    }
+
+    weight_h = 0;
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < n_rows; i++) {
+      src[i] += gemm_params->inp_jump_c;
+    }
+  }
+};
+
+template <
+    typename T,
+    short BM,
+    short BN,
+    short BK,
+    short tgp_size,
+    short tgp_padding = 0>
+struct Conv2DInputBlockLoaderSmallFilter {
+  // Destination dimensions
+  STEEL_CONST short BROWS = BM;
+  STEEL_CONST short BCOLS = BK;
+
+  // Read dimensions
+  STEEL_CONST short dst_ld = BCOLS + tgp_padding;
+  STEEL_CONST short vec_size = tgp_size / (BROWS * BCOLS) >= 8 ? 8 : 4;
+
+  // Thread read shape
+  STEEL_CONST short TCOLS = BCOLS / vec_size;
+  STEEL_CONST short TROWS = tgp_size / TCOLS;
+
+  // Rows / strided reads within the block
+  STEEL_CONST short n_rows = BROWS / TROWS;
+
+  using mask_t = short;
+
+  // Thread location indices
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  // threadgroup and device memory
+  threadgroup T* dst;
+
+  const constant MLXConvParams<2>* params;
+  const constant ImplicitGemmConv2DParams* gemm_params;
+
+  short weight_h;
+  short weight_w;
+
+  const device T* src[n_rows];
+
+  mask_t mask_h[n_rows];
+  mask_t mask_w[n_rows];
+
+  /* Constructor */
+  METAL_FUNC Conv2DInputBlockLoaderSmallFilter(
+      const device T* src_,
+      threadgroup T* dst_,
+      const int2 offsets,
+      const constant MLXConvParams<2>* params_,
+      const constant ImplicitGemmConv2DParams* gemm_params_,
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint simd_lane_id [[thread_index_in_simdgroup]])
+      : thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(thread_idx / TCOLS),
+        bj(vec_size * (thread_idx % TCOLS)),
+        dst(dst_ + bi * dst_ld + bj),
+        params(params_),
+        gemm_params(gemm_params_),
+        weight_h(0),
+        weight_w(0) {
+    int out_n_pixels = params->oS[0] * params->oS[1];
+
+    int read_n[n_rows];
+    int read_ih[n_rows];
+    int read_iw[n_rows];
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < n_rows; ++i) {
+      int offset_nhw = offsets.y + bi + i * TROWS;
+      int n = offset_nhw / out_n_pixels;
+      int hw = offset_nhw % out_n_pixels;
+      int oh = hw / params->oS[1];
+      int ow = hw % params->oS[1];
+
+      int ih = oh * params->str[0] - params->pad[0];
+      int iw = ow * params->str[1] - params->pad[1];
+
+      read_n[i] = n;
+      read_ih[i] = ih;
+      read_iw[i] = iw;
+
+      // Adjust for flip
+      if (params->flip) {
+        ih += (params->wS[0] - 1) * params->kdil[0];
+        iw += (params->wS[1] - 1) * params->kdil[1];
+      }
+
+      // Read from input if in bounds
+      src[i] = src_ + n * params->in_strides[0] + ih * params->in_strides[1] +
+          iw * params->in_strides[2] + bj;
+    }
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < n_rows; ++i) {
+      mask_h[i] = 0;
+      mask_w[i] = 0;
+    }
+
+    for (short kh = 0; kh < params->wS[0]; kh++) {
+      short flip_h = params->flip ? params->wS[0] - kh - 1 : kh;
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < n_rows; ++i) {
+        int n = read_n[i];
+        int ih = read_ih[i] + flip_h * params->kdil[0];
+
+        bool in_bounds = n < params->N && ih >= 0 && ih < params->iS[0];
+
+        mask_h[i] |= (in_bounds << kh);
+      }
+    }
+
+    for (short kw = 0; kw < params->wS[1]; kw++) {
+      short flip_w = params->flip ? params->wS[1] - kw - 1 : kw;
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < n_rows; ++i) {
+        int iw = read_iw[i] + flip_w * params->kdil[1];
+
+        bool in_bounds = iw >= 0 && iw < params->iS[1];
+
+        mask_w[i] |= (in_bounds << kw);
+      }
+    }
+  }
+
+  /* Load from device memory into threadgroup memory - without bound checking */
+  METAL_FUNC void load_unsafe() const {
+    mask_t h_mask = mask_t(1) << weight_h;
+    mask_t w_mask = mask_t(1) << weight_w;
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0, is = 0; i < n_rows; ++i, is += TROWS) {
+      // Read from input if in bounds
+      if ((mask_h[i] & h_mask) && (mask_w[i] & w_mask)) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; ++j) {
+          dst[is * dst_ld + j] = src[i][j];
+        }
+      }
+
+      // Zero pad otherwise
+      else {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; ++j) {
+          dst[is * dst_ld + j] = T(0);
+        }
+      }
+    }
+  }
+
+  /* Iteration helper */
+  METAL_FUNC void next() {
+    if (++weight_w < params->wS[1]) {
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < n_rows; i++) {
+        src[i] += gemm_params->inp_jump_w;
+      }
+
+      return;
+    }
+
+    weight_w = 0;
+
+    if (++weight_h < params->wS[0]) {
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < n_rows; i++) {
+        src[i] += gemm_params->inp_jump_h;
+      }
+
+      return;
+    }
+
+    weight_h = 0;
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < n_rows; i++) {
+      src[i] += gemm_params->inp_jump_c;
+    }
+  }
+};
+
+template <
+    typename T,
+    short BM,
+    short BN,
+    short BK,
+    short tgp_size,
+    short tgp_padding = 0>
+struct Conv2DWeightBlockLoader {
+  // Destination dimensions
+  STEEL_CONST short BROWS = BN;
+  STEEL_CONST short BCOLS = BK;
+
+  // Read dimensions
+  STEEL_CONST short dst_ld = BCOLS + tgp_padding;
+  STEEL_CONST short vec_size =
+      (BN == 8) ? 1 : (tgp_size / (BROWS * BCOLS) >= 8 ? 8 : 4);
+
+  // Thread read shape
+  STEEL_CONST short TCOLS = BCOLS / vec_size;
+  STEEL_CONST short TROWS = tgp_size / TCOLS;
+
+  // Rows / strided reads within the block
+  STEEL_CONST short n_rows = BROWS / TROWS;
+
+  // Leading dimension for src
+  const int src_ld;
+
+  // Thread location indices
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  // threadgroup and device memory
+  threadgroup T* dst;
+  const device T* src;
+
+  const constant MLXConvParams<2>* params;
+
+  int weight_hw;
+  int weight_step;
+
+  const int read_n;
+  const bool do_read;
+
+  /* Constructor */
+  METAL_FUNC Conv2DWeightBlockLoader(
+      const device T* src_,
+      threadgroup T* dst_,
+      const int2 offsets,
+      const constant MLXConvParams<2>* params_,
+      const constant ImplicitGemmConv2DParams* gemm_params_,
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint simd_lane_id [[thread_index_in_simdgroup]])
+      : src_ld(params_->wt_strides[0]),
+        thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(thread_idx / TCOLS),
+        bj(vec_size * (thread_idx % TCOLS)),
+        dst(dst_ + bi * dst_ld + bj),
+        src(src_ + bi * src_ld + bj),
+        params(params_),
+        weight_hw(0),
+        weight_step(params->C / params->groups),
+        read_n(offsets.y + bi),
+        do_read(read_n + n_rows * TROWS <= gemm_params_->N) {}
+
+  /* Load from device memory into threadgroup memory - without bound checking */
+  METAL_FUNC void load_unsafe() const {
+    if (BN != 8 || do_read) {
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < BN; i += TROWS) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; j++) {
+          dst[i * dst_ld + j] = src[i * src_ld + j];
+        }
+      }
+    } else {
+      for (short i = 0; i < BN; i += TROWS) {
+        if ((read_n + i) < params->O) {
+          STEEL_PRAGMA_UNROLL
+          for (short j = 0; j < vec_size; j++) {
+            dst[i * dst_ld + j] = src[i * src_ld + j];
+          }
+        } else {
+          STEEL_PRAGMA_UNROLL
+          for (short j = 0; j < vec_size; j++) {
+            dst[i * dst_ld + j] = T(0);
+          }
+        }
+      }
+    }
+  }
+
+  /* Iteration helper */
+  METAL_FUNC void next() {
+    if (++weight_hw < (params->wS[1] * params->wS[0])) {
+      src += weight_step;
+      return;
+    }
+
+    weight_hw = 0;
+
+    src += BK - (params->wS[1] * params->wS[0] - 1) * weight_step;
+  }
+};
+
+} // namespace steel
+} // namespace mlx
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/loaders/loader_channel_n.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/loaders/loader_channel_n.h
new file mode 100644
index 0000000000000000000000000000000000000000..2312e1ca6ea53c58b05775885ad2c750c21ff59e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/loaders/loader_channel_n.h
@@ -0,0 +1,319 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/steel/utils.h"
+
+#include "mlx/backend/metal/kernels/steel/conv/params.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Loading helper
+///////////////////////////////////////////////////////////////////////////////
+
+namespace mlx {
+namespace steel {
+
+template <short n_channels_>
+struct ChannelHelper {
+  STEEL_CONST short n_channels = n_channels_;
+  STEEL_CONST short vec_size = n_channels_ <= 4 ? 4 : 8;
+  STEEL_CONST short excess = vec_size - n_channels_;
+};
+
+template <>
+struct ChannelHelper<1> {
+  STEEL_CONST short n_channels = 1;
+  STEEL_CONST short vec_size = 1;
+  STEEL_CONST short excess = 0;
+};
+
+template <>
+struct ChannelHelper<2> {
+  STEEL_CONST short n_channels = 2;
+  STEEL_CONST short vec_size = 2;
+  STEEL_CONST short excess = 0;
+};
+
+template <>
+struct ChannelHelper<3> {
+  STEEL_CONST short n_channels = 3;
+  STEEL_CONST short vec_size = 4;
+  STEEL_CONST short excess = 1;
+};
+
+template <>
+struct ChannelHelper<4> {
+  STEEL_CONST short n_channels = 4;
+  STEEL_CONST short vec_size = 4;
+  STEEL_CONST short excess = 0;
+};
+
+template <
+    typename T,
+    short BM,
+    short BN,
+    short BK,
+    short tgp_size,
+    short n_channels,
+    short tgp_padding = 0>
+struct Conv2DInputBlockLoaderSmallChannels {
+  // Destination dimensions
+  STEEL_CONST short BROWS = BM;
+  STEEL_CONST short BCOLS = BK;
+
+  // Read dimensions
+  STEEL_CONST short dst_ld = BCOLS + tgp_padding;
+  STEEL_CONST short vec_size = ChannelHelper<n_channels>::vec_size;
+
+  // Thread read shape
+  STEEL_CONST short TCOLS = BCOLS / vec_size;
+  STEEL_CONST short TROWS = tgp_size / TCOLS;
+
+  // Rows / strided reads within the block
+  STEEL_CONST short n_rows = BROWS / TROWS;
+
+  // Thread location indices
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  // threadgroup and device memory
+  threadgroup T* dst;
+
+  const constant MLXConvParams<2>* params;
+  const constant ImplicitGemmConv2DParams* gemm_params;
+
+  int weight_hw;
+
+  const device T* src[n_rows];
+
+  int read_n[n_rows];
+  int read_ih[n_rows];
+  int read_iw[n_rows];
+
+  /* Constructor */
+  METAL_FUNC Conv2DInputBlockLoaderSmallChannels(
+      const device T* src_,
+      threadgroup T* dst_,
+      const int2 offsets,
+      const constant MLXConvParams<2>* params_,
+      const constant ImplicitGemmConv2DParams* gemm_params_,
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint simd_lane_id [[thread_index_in_simdgroup]])
+      : thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(thread_idx / TCOLS),
+        bj(vec_size * (thread_idx % TCOLS)),
+        dst(dst_ + bi * dst_ld + bj),
+        params(params_),
+        gemm_params(gemm_params_),
+        weight_hw(thread_idx % TCOLS) {
+    int out_n_pixels = params->oS[0] * params->oS[1];
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < n_rows; ++i) {
+      int offset_nhw = offsets.y + bi + i * TROWS;
+      int n = offset_nhw / out_n_pixels;
+      int hw = offset_nhw % out_n_pixels;
+      int oh = hw / params->oS[1];
+      int ow = hw % params->oS[1];
+
+      int ih = oh * params->str[0] - params->pad[0];
+      int iw = ow * params->str[1] - params->pad[1];
+
+      // Read from input if in bounds
+      src[i] = src_ + n * params->in_strides[0] + ih * params->in_strides[1] +
+          iw * params->in_strides[2];
+
+      read_n[i] = n;
+      read_ih[i] = ih;
+      read_iw[i] = iw;
+    }
+  }
+
+  /* Load from device memory into threadgroup memory - without bound checking */
+  METAL_FUNC void load_unsafe() const {
+    if (weight_hw >= params->wS[1] * params->wS[0]) {
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < BROWS; i += TROWS) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; j++) {
+          dst[i * dst_ld + j] = T(0);
+        }
+      }
+      return;
+    }
+
+    int wh = (weight_hw / params->wS[1]);
+    int ww = (weight_hw % params->wS[1]);
+
+    int flip_h = params->flip ? params->wS[0] - wh - 1 : wh;
+    int flip_w = params->flip ? params->wS[1] - ww - 1 : ww;
+
+    int weight_h = flip_h * params->kdil[0];
+    int weight_w = flip_w * params->kdil[1];
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0, is = 0; i < n_rows; ++i, is += TROWS) {
+      // Find bounds
+      int n = read_n[i];
+      int ih = read_ih[i] + weight_h;
+      int iw = read_iw[i] + weight_w;
+
+      // Read from input if in bounds
+      if ((n < params->N) && (ih >= 0 && ih < params->iS[0]) &&
+          (iw >= 0 && iw < params->iS[1])) {
+        const device T* curr_src = src[i] + weight_h * params->in_strides[1] +
+            weight_w * params->in_strides[2];
+
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < n_channels; ++j) {
+          dst[is * dst_ld + j] = curr_src[j];
+        }
+
+        STEEL_PRAGMA_UNROLL
+        for (short j = n_channels; j < vec_size; ++j) {
+          dst[is * dst_ld + j] = T(0);
+        }
+      }
+
+      // Zero pad otherwise
+      else {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; ++j) {
+          dst[is * dst_ld + j] = T(0);
+        }
+      }
+    }
+  }
+
+  /* Iteration helper */
+  METAL_FUNC void next() {
+    weight_hw += TCOLS;
+  }
+};
+
+template <
+    typename T,
+    short BM,
+    short BN,
+    short BK,
+    short tgp_size,
+    short n_channels,
+    short tgp_padding = 0>
+struct Conv2DWeightBlockLoaderSmallChannels {
+  // Destination dimensions
+  STEEL_CONST short BROWS = BN;
+  STEEL_CONST short BCOLS = BK;
+
+  // Read dimensions
+  STEEL_CONST short dst_ld = BCOLS + tgp_padding;
+  STEEL_CONST short vec_size = ChannelHelper<n_channels>::vec_size;
+
+  // Thread read shape
+  STEEL_CONST short TCOLS = BCOLS / vec_size;
+  STEEL_CONST short TROWS = tgp_size / TCOLS;
+
+  // Rows / strided reads within the block
+  STEEL_CONST short n_rows = BROWS / TROWS;
+
+  // Leading dimension for src
+  const int src_ld;
+
+  // Thread location indices
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  // threadgroup and device memory
+  threadgroup T* dst;
+  const device T* src;
+
+  const constant MLXConvParams<2>* params;
+
+  int weight_hw;
+
+  const int read_n;
+  const bool do_read;
+
+  /* Constructor */
+  METAL_FUNC Conv2DWeightBlockLoaderSmallChannels(
+      const device T* src_,
+      threadgroup T* dst_,
+      const int2 offsets,
+      const constant MLXConvParams<2>* params_,
+      const constant ImplicitGemmConv2DParams* gemm_params_,
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint simd_lane_id [[thread_index_in_simdgroup]])
+      : src_ld(params_->wt_strides[0]),
+        thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(thread_idx / TCOLS),
+        bj(vec_size * (thread_idx % TCOLS)),
+        dst(dst_ + bi * dst_ld + bj),
+        src(src_ + bi * src_ld),
+        params(params_),
+        weight_hw(thread_idx % TCOLS),
+        read_n(offsets.y + bi),
+        do_read(read_n + BN <= gemm_params_->N) {}
+
+  /* Load from device memory into threadgroup memory - without bound checking */
+  METAL_FUNC void load_unsafe() const {
+    if (bi >= BROWS || bj >= BCOLS)
+      return;
+
+    if (read_n >= params->O || weight_hw >= params->wS[1] * params->wS[0]) {
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < BROWS; i += TROWS) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; j++) {
+          dst[i * dst_ld + j] = T(0);
+        }
+      }
+
+      return;
+    }
+
+    const device T* curr_src = src + weight_hw * (params->C / params->groups);
+
+    if (BN != 8 || do_read) {
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < BROWS; i += TROWS) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < n_channels; j++) {
+          dst[i * dst_ld + j] = curr_src[i * src_ld + j];
+        }
+
+        STEEL_PRAGMA_UNROLL
+        for (short j = n_channels; j < vec_size; j++) {
+          dst[i * dst_ld + j] = T(0);
+        }
+      }
+    } else {
+      for (short i = 0; i < BROWS; i += TROWS) {
+        if (((read_n + i) < params->O)) {
+          STEEL_PRAGMA_UNROLL
+          for (short j = 0; j < n_channels; j++) {
+            dst[i * dst_ld + j] = curr_src[i * src_ld + j];
+          }
+
+          STEEL_PRAGMA_UNROLL
+          for (short j = n_channels; j < vec_size; j++) {
+            dst[i * dst_ld + j] = T(0);
+          }
+        } else {
+          STEEL_PRAGMA_UNROLL
+          for (short j = 0; j < vec_size; j++) {
+            dst[i * dst_ld + j] = T(0);
+          }
+        }
+      }
+    }
+  }
+
+  /* Iteration helper */
+  METAL_FUNC void next() {
+    weight_hw += TCOLS;
+  }
+};
+
+} // namespace steel
+} // namespace mlx
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/loaders/loader_general.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/loaders/loader_general.h
new file mode 100644
index 0000000000000000000000000000000000000000..9b7ddc2eec05368bc2d27b92aa727fd62bcbe342
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/loaders/loader_general.h
@@ -0,0 +1,381 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/steel/defines.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Loading helper
+///////////////////////////////////////////////////////////////////////////////
+
+namespace mlx {
+namespace steel {
+
+template <
+    typename T,
+    short BM,
+    short BN,
+    short BK,
+    short tgp_size,
+    short tgp_padding = 0>
+struct Conv2DInputBlockLoaderGeneral {
+  // Destination dimensions
+  STEEL_CONST short BROWS = BM;
+  STEEL_CONST short BCOLS = BK;
+
+  // Read dimensions
+  STEEL_CONST short dst_ld = BCOLS + tgp_padding;
+  STEEL_CONST short vec_size = tgp_size / (BROWS * BCOLS) >= 8 ? 8 : 4;
+
+  // Thread read shape
+  STEEL_CONST short TCOLS = BCOLS / vec_size;
+  STEEL_CONST short TROWS = tgp_size / TCOLS;
+
+  // Rows / strided reads within the block
+  STEEL_CONST short n_rows = BROWS / TROWS;
+
+  // Thread location indices
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  // threadgroup and device memory
+  threadgroup T* dst;
+
+  const constant MLXConvParams<2>* params;
+  const constant Conv2DGeneralJumpParams* jump_params;
+
+  const short base_wh;
+  const short base_ww;
+
+  short weight_h;
+  short weight_w;
+
+  const device T* src[n_rows];
+
+  int read_n[n_rows];
+  int read_ih[n_rows];
+  int read_iw[n_rows];
+
+  /* Constructor */
+  METAL_FUNC Conv2DInputBlockLoaderGeneral(
+      const device T* src_,
+      threadgroup T* dst_,
+      const int4 offsets,
+      const constant MLXConvParams<2>* params_,
+      const constant Conv2DGeneralJumpParams* jump_params_,
+      const short base_wh_,
+      const short base_ww_,
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint simd_lane_id [[thread_index_in_simdgroup]])
+      : thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(thread_idx / TCOLS),
+        bj(vec_size * (thread_idx % TCOLS)),
+        dst(dst_ + bi * dst_ld + bj),
+        params(params_),
+        jump_params(jump_params_),
+        base_wh(base_wh_),
+        base_ww(base_ww_),
+        weight_h(base_wh_),
+        weight_w(base_ww_) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < n_rows; ++i) {
+      int offset_nhw = offsets.y + bi + i * TROWS;
+      int n = offset_nhw / jump_params->adj_out_hw;
+      int hw = offset_nhw % jump_params->adj_out_hw;
+      int oh =
+          (hw / jump_params->adj_out_w) * jump_params->f_out_jump_h + offsets.z;
+      int ow =
+          (hw % jump_params->adj_out_w) * jump_params->f_out_jump_w + offsets.w;
+
+      int ih = oh * params->str[0] - params->pad[0];
+      int iw = ow * params->str[1] - params->pad[1];
+
+      read_n[i] = n;
+      read_ih[i] = ih;
+      read_iw[i] = iw;
+
+      // Read from input if in bounds
+      src[i] = src_ + n * params->in_strides[0] + bj;
+    }
+  }
+
+  /* Load from device memory into threadgroup memory - without bound checking */
+  METAL_FUNC void load_unsafe() const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0, is = 0; i < n_rows; ++i, is += TROWS) {
+      // Find bounds
+      int n = read_n[i];
+
+      int h_flip = params->flip ? params->wS[0] - weight_h - 1 : weight_h;
+      int w_flip = params->flip ? params->wS[1] - weight_w - 1 : weight_w;
+
+      int ih_dil = read_ih[i] + h_flip * params->kdil[0];
+      int iw_dil = read_iw[i] + w_flip * params->kdil[1];
+
+      int ih = ih_dil / params->idil[0];
+      int iw = iw_dil / params->idil[1];
+
+      size_t offset = ih * params->in_strides[1] + iw * params->in_strides[2];
+
+      // Read from input if in bounds
+      if ((n < params->N) && (ih_dil >= 0 && ih < params->iS[0]) &&
+          (iw_dil >= 0 && iw < params->iS[1])) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; ++j) {
+          dst[is * dst_ld + j] = (src[i])[offset + j];
+        }
+      }
+
+      // Zero pad otherwise
+      else {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; ++j) {
+          dst[is * dst_ld + j] = T(0);
+        }
+      }
+    }
+  }
+
+  METAL_FUNC void load_safe(const short remaining_k) const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0, is = 0; i < n_rows; ++i, is += TROWS) {
+      // Find bounds
+      int n = read_n[i];
+
+      int h_flip = params->flip ? params->wS[0] - weight_h - 1 : weight_h;
+      int w_flip = params->flip ? params->wS[1] - weight_w - 1 : weight_w;
+
+      int ih_dil = read_ih[i] + h_flip * params->kdil[0];
+      int iw_dil = read_iw[i] + w_flip * params->kdil[1];
+
+      int ih = ih_dil / params->idil[0];
+      int iw = iw_dil / params->idil[1];
+
+      size_t offset = ih * params->in_strides[1] + iw * params->in_strides[2];
+
+      // Read from input if in bounds
+      if ((n < params->N) && (ih_dil >= 0 && ih < params->iS[0]) &&
+          (iw_dil >= 0 && iw < params->iS[1])) {
+        if (bj + vec_size <= remaining_k) {
+          STEEL_PRAGMA_UNROLL
+          for (short j = 0; j < vec_size; ++j) {
+            dst[is * dst_ld + j] = (src[i])[offset + j];
+          }
+        } else {
+          for (short j = 0; j < vec_size; ++j) {
+            if (bj + j < remaining_k) {
+              dst[is * dst_ld + j] = (src[i])[offset + j];
+            } else {
+              dst[is * dst_ld + j] = T(0);
+            }
+          }
+        }
+      }
+
+      // Zero pad otherwise
+      else {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; ++j) {
+          dst[is * dst_ld + j] = T(0);
+        }
+      }
+    }
+  }
+
+  /* Iteration helper */
+  METAL_FUNC void next() {
+    weight_w += jump_params->f_wgt_jump_w;
+    if (weight_w < params->wS[1]) {
+      return;
+    }
+
+    weight_w = base_ww;
+
+    weight_h += jump_params->f_wgt_jump_h;
+    if (weight_h < params->wS[0]) {
+      return;
+    }
+
+    weight_h = base_wh;
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < n_rows; i++) {
+      src[i] += BK;
+    }
+  }
+};
+
+template <
+    typename T,
+    short BM,
+    short BN,
+    short BK,
+    short tgp_size,
+    short tgp_padding = 0>
+struct Conv2DWeightBlockLoaderGeneral {
+  // Destination dimensions
+  STEEL_CONST short BROWS = BN;
+  STEEL_CONST short BCOLS = BK;
+
+  // Read dimensions
+  STEEL_CONST short dst_ld = BCOLS + tgp_padding;
+  STEEL_CONST short vec_size =
+      (BN == 8) ? 1 : (tgp_size / (BROWS * BCOLS) >= 8 ? 8 : 4);
+
+  // Thread read shape
+  STEEL_CONST short TCOLS = BCOLS / vec_size;
+  STEEL_CONST short TROWS = tgp_size / TCOLS;
+
+  // Rows / strided reads within the block
+  STEEL_CONST short n_rows = BROWS / TROWS;
+
+  // Leading dimension for src
+  const int src_ld;
+
+  // Thread location indices
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  // threadgroup and device memory
+  threadgroup T* dst;
+  const device T* src;
+
+  const constant MLXConvParams<2>* params;
+  const constant Conv2DGeneralJumpParams* jump_params;
+
+  const short base_wh;
+  const short base_ww;
+
+  short weight_h;
+  short weight_w;
+
+  const int start_row;
+
+  /* Constructor */
+  METAL_FUNC Conv2DWeightBlockLoaderGeneral(
+      const device T* src_,
+      threadgroup T* dst_,
+      const int2 offsets,
+      const constant MLXConvParams<2>* params_,
+      const constant Conv2DGeneralJumpParams* jump_params_,
+      const short base_wh_,
+      const short base_ww_,
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint simd_lane_id [[thread_index_in_simdgroup]])
+      : src_ld(params_->wt_strides[0]),
+        thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(thread_idx / TCOLS),
+        bj(vec_size * (thread_idx % TCOLS)),
+        dst(dst_ + bi * dst_ld + bj),
+        src(src_ + bi * src_ld + bj),
+        params(params_),
+        jump_params(jump_params_),
+        base_wh(base_wh_),
+        base_ww(base_ww_),
+        weight_h(base_wh_),
+        weight_w(base_ww_),
+        start_row(offsets.y + bi) {}
+
+  /* Load from device memory into threadgroup memory - without bound checking */
+  METAL_FUNC void load_unsafe() const {
+    const device T* curr_src = src + weight_h * params->wt_strides[1] +
+        weight_w * params->wt_strides[2];
+
+    if ((start_row + BN <= params->O)) {
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < BN; i += TROWS) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; j++) {
+          dst[i * dst_ld + j] = curr_src[i * src_ld + j];
+        }
+      }
+    } else {
+      for (short i = 0; i < BN; i += TROWS) {
+        if ((start_row + i) < params->O) {
+          STEEL_PRAGMA_UNROLL
+          for (short j = 0; j < vec_size; j++) {
+            dst[i * dst_ld + j] = curr_src[i * src_ld + j];
+          }
+        } else {
+          STEEL_PRAGMA_UNROLL
+          for (short j = 0; j < vec_size; j++) {
+            dst[i * dst_ld + j] = T(0);
+          }
+        }
+      }
+    }
+  }
+
+  METAL_FUNC void load_safe(const short remaining_k) const {
+    const device T* curr_src = src + weight_h * params->wt_strides[1] +
+        weight_w * params->wt_strides[2];
+
+    if ((start_row + BN <= params->O)) {
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < BN; i += TROWS) {
+        if (bj + vec_size <= remaining_k) {
+          STEEL_PRAGMA_UNROLL
+          for (short j = 0; j < vec_size; j++) {
+            dst[i * dst_ld + j] = curr_src[i * src_ld + j];
+          }
+        } else {
+          for (short j = 0; j < vec_size; j++) {
+            if (bj + j < remaining_k) {
+              dst[i * dst_ld + j] = curr_src[i * src_ld + j];
+            } else {
+              dst[i * dst_ld + j] = T(0);
+            }
+          }
+        }
+      }
+    } else {
+      for (short i = 0; i < BN; i += TROWS) {
+        if ((start_row + i) < params->O) {
+          if (bj + vec_size <= remaining_k) {
+            STEEL_PRAGMA_UNROLL
+            for (short j = 0; j < vec_size; j++) {
+              dst[i * dst_ld + j] = curr_src[i * src_ld + j];
+            }
+          } else {
+            for (short j = 0; j < vec_size; j++) {
+              if (bj + j < remaining_k) {
+                dst[i * dst_ld + j] = curr_src[i * src_ld + j];
+              } else {
+                dst[i * dst_ld + j] = T(0);
+              }
+            }
+          }
+        } else {
+          STEEL_PRAGMA_UNROLL
+          for (short j = 0; j < vec_size; j++) {
+            dst[i * dst_ld + j] = T(0);
+          }
+        }
+      }
+    }
+  }
+
+  /* Iteration helper */
+  METAL_FUNC void next() {
+    weight_w += jump_params->f_wgt_jump_w;
+    if (weight_w < params->wS[1]) {
+      return;
+    }
+
+    weight_w = base_ww;
+
+    weight_h += jump_params->f_wgt_jump_h;
+    if (weight_h < params->wS[0]) {
+      return;
+    }
+
+    weight_h = base_wh;
+
+    src += BK;
+  }
+};
+
+} // namespace steel
+} // namespace mlx
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/params.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/params.h
new file mode 100644
index 0000000000000000000000000000000000000000..61b8474f8200fabd806d8326eab2d14c86f24797
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/conv/params.h
@@ -0,0 +1,62 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+template <int NDIM>
+struct MLXConvParams {
+  const int N; // Batch size
+  const int C; // In channels
+  const int O; // Out channels
+  const int iS[NDIM]; // Input spatial dim
+  const int wS[NDIM]; // Weight spatial dim
+  const int oS[NDIM]; // Output spatial dim
+  const int str[NDIM]; // Kernel strides
+  const int pad[NDIM]; // Input padding
+  const int kdil[NDIM]; // Kernel dilation
+  const int idil[NDIM]; // Input dilation
+  const int64_t in_strides[NDIM + 2]; // In strides
+  const int64_t wt_strides[NDIM + 2]; // Wt strides
+  const int64_t out_strides[NDIM + 2]; // Out strides
+  const int groups; // Input channel groups
+  const bool flip;
+};
+
+namespace mlx {
+namespace steel {
+
+struct ImplicitGemmConv2DParams {
+  const int M;
+  const int N;
+  const int K;
+
+  const int gemm_k_iterations;
+
+  const int inp_jump_w;
+  const int inp_jump_h;
+  const int inp_jump_c;
+
+  const int tiles_n;
+  const int tiles_m;
+  const int swizzle_log;
+};
+
+struct Conv2DGeneralJumpParams {
+  const int f_wgt_jump_h;
+  const int f_wgt_jump_w;
+
+  const int f_out_jump_h;
+  const int f_out_jump_w;
+
+  const int adj_out_h;
+  const int adj_out_w;
+  const int adj_out_hw;
+  const int adj_implicit_m;
+};
+
+struct Conv2DGeneralBaseInfo {
+  int weight_base;
+  int weight_size;
+};
+
+} // namespace steel
+} // namespace mlx
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/defines.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/defines.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c3bfcf4edeeddd136d108670f773bb525b7d3dc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/defines.h
@@ -0,0 +1,4 @@
+// Copyright © 2024 Apple Inc.
+
+#define STEEL_CONST static constant constexpr const
+#define STEEL_PRAGMA_UNROLL _Pragma("clang loop unroll(full)")
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/gemm.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/gemm.h
new file mode 100644
index 0000000000000000000000000000000000000000..bbe1d96cc0a657e729b2be8a0808382886866ba0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/gemm.h
@@ -0,0 +1,295 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/steel/gemm/loader.h"
+#include "mlx/backend/metal/kernels/steel/gemm/mma.h"
+#include "mlx/backend/metal/kernels/steel/gemm/params.h"
+#include "mlx/backend/metal/kernels/steel/gemm/transforms.h"
+#include "mlx/backend/metal/kernels/steel/utils.h"
+
+using namespace metal;
+
+///////////////////////////////////////////////////////////////////////////////
+// GEMM kernel class
+///////////////////////////////////////////////////////////////////////////////
+
+namespace mlx {
+namespace steel {
+
+template <bool M_aligned, bool N_aligned, bool K_aligned>
+struct LoopAlignment {};
+
+template <
+    typename T,
+    typename U,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    bool MN_aligned,
+    bool K_aligned,
+    typename AccumType = typename AccumHelper<T>::accum_type,
+    typename Epilogue = TransformNone<U, AccumType>>
+struct GEMMKernel {
+  STEEL_CONST short tgp_padding_a = 16 / sizeof(T);
+  STEEL_CONST short tgp_padding_b = 16 / sizeof(T);
+  STEEL_CONST short tgp_mem_size_a =
+      transpose_a ? BK * (BM + tgp_padding_a) : BM * (BK + tgp_padding_a);
+  STEEL_CONST short tgp_mem_size_b =
+      transpose_b ? BN * (BK + tgp_padding_b) : BK * (BN + tgp_padding_b);
+  STEEL_CONST short tgp_mem_size = tgp_mem_size_a + tgp_mem_size_b;
+
+  STEEL_CONST short tgp_size = WM * WN * 32;
+
+  using loader_a_t = BlockLoader<
+      T,
+      transpose_a ? BK : BM,
+      transpose_a ? BM : BK,
+      transpose_a ? BM + tgp_padding_a : BK + tgp_padding_a,
+      !transpose_a,
+      tgp_size>;
+  using loader_b_t = BlockLoader<
+      T,
+      transpose_b ? BN : BK,
+      transpose_b ? BK : BN,
+      transpose_b ? BK + tgp_padding_b : BN + tgp_padding_b,
+      transpose_b,
+      tgp_size>;
+  using mma_t = BlockMMA<
+      T,
+      U,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      transpose_a,
+      transpose_b,
+      transpose_a ? BM + tgp_padding_a : BK + tgp_padding_a,
+      transpose_b ? BK + tgp_padding_b : BN + tgp_padding_b,
+      AccumType,
+      Epilogue>;
+
+  /* Main kernel function */
+  template <bool M_aligned, bool N_aligned, bool K_aligned_>
+  static METAL_FUNC void gemm_loop(
+      threadgroup T* As [[threadgroup(0)]],
+      threadgroup T* Bs [[threadgroup(1)]],
+      const int gemm_k_iterations,
+      thread loader_a_t& loader_a,
+      thread loader_b_t& loader_b,
+      thread mma_t& mma_op,
+      thread const short& tgp_bm,
+      thread const short& tgp_bn,
+      thread const short& lbk,
+      LoopAlignment<M_aligned, N_aligned, K_aligned_> l = {}) {
+    // Appease the compiler
+    (void)l;
+
+    short2 tile_dims_A = transpose_a ? short2(tgp_bm, BK) : short2(BK, tgp_bm);
+
+    short2 tile_dims_B = transpose_b ? short2(BK, tgp_bn) : short2(tgp_bn, BK);
+
+    for (int k = 0; k < gemm_k_iterations; k++) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      // Load elements into threadgroup
+      if (M_aligned) {
+        loader_a.load_unsafe();
+      } else {
+        loader_a.load_safe(tile_dims_A);
+      }
+
+      if (N_aligned) {
+        loader_b.load_unsafe();
+      } else {
+        loader_b.load_safe(tile_dims_B);
+      }
+
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      // Multiply and accumulate threadgroup elements
+      mma_op.mma(As, Bs);
+
+      // Prepare for next iteration
+      loader_a.next();
+      loader_b.next();
+    }
+
+    if (!K_aligned_) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      short2 tile_dims_A_last =
+          transpose_a ? short2(tgp_bm, lbk) : short2(lbk, tgp_bm);
+      short2 tile_dims_B_last =
+          transpose_b ? short2(lbk, tgp_bn) : short2(tgp_bn, lbk);
+
+      loader_a.load_safe(tile_dims_A_last);
+      loader_b.load_safe(tile_dims_B_last);
+
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      mma_op.mma(As, Bs);
+    }
+  }
+
+  /* Main kernel function */
+  static METAL_FUNC void run(
+      const device T* A [[buffer(0)]],
+      const device T* B [[buffer(1)]],
+      device U* D [[buffer(2)]],
+      const constant GEMMParams* params [[buffer(3)]],
+      threadgroup T* As [[threadgroup(0)]],
+      threadgroup T* Bs [[threadgroup(1)]],
+      uint simd_lane_id [[thread_index_in_simdgroup]],
+      uint simd_group_id [[simdgroup_index_in_threadgroup]],
+      uint3 tid [[threadgroup_position_in_grid]],
+      uint3 lid [[thread_position_in_threadgroup]]) {
+    // Pacifying compiler
+    (void)lid;
+
+    const int tid_y = ((tid.y) << params->swizzle_log) +
+        ((tid.x) & ((1 << params->swizzle_log) - 1));
+    const int tid_x = (tid.x) >> params->swizzle_log;
+
+    if (params->tiles_n <= tid_x || params->tiles_m <= tid_y) {
+      return;
+    }
+
+    threadgroup_barrier(mem_flags::mem_none);
+
+    // Find block in A, B, C
+    const int c_row = tid_y * BM;
+    const int c_col = tid_x * BN;
+    const size_t c_row_long = size_t(c_row);
+    const size_t c_col_long = size_t(c_col);
+
+    A += transpose_a ? c_row_long : c_row_long * params->lda;
+    B += transpose_b ? c_col_long * params->ldb : c_col_long;
+    D += c_row_long * params->ldd + c_col_long;
+
+    // Prepare threadgroup loading operations
+    thread loader_a_t loader_a(A, params->lda, As, simd_group_id, simd_lane_id);
+    thread loader_b_t loader_b(B, params->ldb, Bs, simd_group_id, simd_lane_id);
+
+    // Prepare threadgroup mma operation
+    thread mma_t mma_op(simd_group_id, simd_lane_id);
+
+    int gemm_k_iterations = params->gemm_k_iterations_aligned;
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // MNK aligned loop
+    if (MN_aligned) {
+      for (int k = 0; k < gemm_k_iterations; k++) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        // Load elements into threadgroup
+        loader_a.load_unsafe();
+        loader_b.load_unsafe();
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+
+        // Prepare for next iteration
+        loader_a.next();
+        loader_b.next();
+      }
+
+      threadgroup_barrier(mem_flags::mem_none);
+
+      // Loop tail
+      if (!K_aligned) {
+        int lbk = params->K - params->gemm_k_iterations_aligned * BK;
+        short2 tile_dims_A = transpose_a ? short2(BM, lbk) : short2(lbk, BM);
+        short2 tile_dims_B = transpose_b ? short2(lbk, BN) : short2(BN, lbk);
+
+        loader_a.load_safe(tile_dims_A);
+        loader_b.load_safe(tile_dims_B);
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        mma_op.mma(As, Bs);
+      }
+
+      // Store results to device memory
+      mma_op.store_result(D, params->ldd);
+      return;
+
+    }
+    ///////////////////////////////////////////////////////////////////////////////
+    // MN unaligned loop
+    else { // Loop over K - unaligned case
+      short tgp_bm = min(BM, params->M - c_row);
+      short tgp_bn = min(BN, params->N - c_col);
+      short leftover_bk = params->K - params->gemm_k_iterations_aligned * BK;
+
+      if (tgp_bm == BM && tgp_bn == BN) {
+        gemm_loop<true, true, K_aligned>(
+            As,
+            Bs,
+            gemm_k_iterations,
+            loader_a,
+            loader_b,
+            mma_op,
+            tgp_bm,
+            tgp_bn,
+            leftover_bk);
+
+        mma_op.store_result(D, params->ldd);
+        return;
+
+      } else if (tgp_bn == BN) {
+        gemm_loop<false, true, K_aligned>(
+            As,
+            Bs,
+            gemm_k_iterations,
+            loader_a,
+            loader_b,
+            mma_op,
+            tgp_bm,
+            tgp_bn,
+            leftover_bk);
+
+        mma_op.store_result_safe(D, params->ldd, short2(tgp_bn, tgp_bm));
+        return;
+
+      } else if (tgp_bm == BM) {
+        gemm_loop<true, false, K_aligned>(
+            As,
+            Bs,
+            gemm_k_iterations,
+            loader_a,
+            loader_b,
+            mma_op,
+            tgp_bm,
+            tgp_bn,
+            leftover_bk);
+
+        mma_op.store_result_safe(D, params->ldd, short2(tgp_bn, tgp_bm));
+        return;
+
+      } else {
+        gemm_loop<false, false, K_aligned>(
+            As,
+            Bs,
+            gemm_k_iterations,
+            loader_a,
+            loader_b,
+            mma_op,
+            tgp_bm,
+            tgp_bn,
+            leftover_bk);
+
+        mma_op.store_result_safe(D, params->ldd, short2(tgp_bn, tgp_bm));
+        return;
+      }
+    }
+  }
+};
+
+} // namespace steel
+} // namespace mlx
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_fused.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_fused.h
new file mode 100644
index 0000000000000000000000000000000000000000..85830872d17e650bf2633f0e52cc3185068cebbd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_fused.h
@@ -0,0 +1,346 @@
+// Copyright © 2024 Apple Inc.
+
+using namespace mlx::steel;
+
+///////////////////////////////////////////////////////////////////////////////
+// GEMM kernels
+///////////////////////////////////////////////////////////////////////////////
+
+constant bool has_batch [[function_constant(10)]];
+
+constant bool use_out_source [[function_constant(100)]];
+constant bool do_axpby [[function_constant(110)]];
+
+constant bool align_M [[function_constant(200)]];
+constant bool align_N [[function_constant(201)]];
+constant bool align_K [[function_constant(202)]];
+
+// clang-format off
+template <
+    typename T,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    typename AccumType = float>
+[[kernel, max_total_threads_per_threadgroup(WM* WN * 32)]] void gemm(
+    const device T* A [[buffer(0)]],
+    const device T* B [[buffer(1)]],
+    const device T* C [[buffer(2), function_constant(use_out_source)]],
+    device T* D [[buffer(3)]],
+    const constant GEMMParams* params [[buffer(4)]],
+    const constant GEMMAddMMParams* addmm_params [[buffer(5), function_constant(use_out_source)]],
+    const constant int* batch_shape [[buffer(6), function_constant(has_batch)]],
+    const constant int64_t* batch_strides [[buffer(7), function_constant(has_batch)]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]]) { // clang-format on
+  // Pacifying compiler
+  (void)lid;
+
+  using gemm_kernel = GEMMKernel<
+      T,
+      T,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      transpose_a,
+      transpose_b,
+      true,
+      true,
+      AccumType>;
+
+  using loader_a_t = typename gemm_kernel::loader_a_t;
+  using loader_b_t = typename gemm_kernel::loader_b_t;
+  using mma_t = typename gemm_kernel::mma_t;
+
+  // Find block
+  const int tid_y = ((tid.y) << params->swizzle_log) +
+      ((tid.x) & ((1 << params->swizzle_log) - 1));
+  const int tid_x = (tid.x) >> params->swizzle_log;
+
+  // Exit early if out of bounds
+  if (params->tiles_n <= tid_x || params->tiles_m <= tid_y) {
+    return;
+  }
+
+  // Adjust for batch
+  if (has_batch) {
+    const constant auto* A_bstrides = batch_strides;
+    const constant auto* B_bstrides = batch_strides + params->batch_ndim;
+
+    ulong2 batch_offsets = elem_to_loc_broadcast(
+        tid.z, batch_shape, A_bstrides, B_bstrides, params->batch_ndim);
+
+    A += batch_offsets.x;
+    B += batch_offsets.y;
+
+    if (use_out_source) {
+      const constant auto* C_bstrides = B_bstrides + params->batch_ndim;
+      C += elem_to_loc(tid.z, batch_shape, C_bstrides, params->batch_ndim);
+    }
+  } else {
+    A += params->batch_stride_a * tid.z;
+    B += params->batch_stride_b * tid.z;
+
+    if (use_out_source) {
+      C += addmm_params->batch_stride_c * tid.z;
+    }
+  }
+
+  D += params->batch_stride_d * tid.z;
+
+  // Prepare threadgroup memory
+  threadgroup T As[gemm_kernel::tgp_mem_size_a];
+  threadgroup T Bs[gemm_kernel::tgp_mem_size_b];
+
+  threadgroup_barrier(mem_flags::mem_none);
+
+  // Find block in A, B, C
+  const int c_row = tid_y * BM;
+  const int c_col = tid_x * BN;
+  const size_t c_row_long = size_t(c_row);
+  const size_t c_col_long = size_t(c_col);
+
+  A += transpose_a ? c_row_long : c_row_long * params->lda;
+  B += transpose_b ? c_col_long * params->ldb : c_col_long;
+  D += c_row_long * params->ldd + c_col_long;
+
+  if (use_out_source) {
+    C += c_row_long * addmm_params->ldc + c_col_long * addmm_params->fdc;
+  }
+
+  // Prepare threadgroup mma operation
+  thread mma_t mma_op(simd_group_id, simd_lane_id);
+
+  // Prepare threadgroup loading operations
+  thread loader_a_t loader_a(A, params->lda, As, simd_group_id, simd_lane_id);
+  thread loader_b_t loader_b(B, params->ldb, Bs, simd_group_id, simd_lane_id);
+
+  // Prepare threadgroup bounds
+  const short tgp_bm = align_M ? BM : short(min(BM, params->M - c_row));
+  const short tgp_bn = align_N ? BN : short(min(BN, params->N - c_col));
+
+  // Prepare iterations
+  int gemm_k_iterations = params->gemm_k_iterations_aligned;
+
+  // Do unaligned K iterations first
+  if (!align_K) {
+    const int k_last = params->gemm_k_iterations_aligned * BK;
+    const int k_remain = params->K - k_last;
+    const size_t k_jump_a =
+        transpose_a ? params->lda * size_t(k_last) : size_t(k_last);
+    const size_t k_jump_b =
+        transpose_b ? size_t(k_last) : params->ldb * size_t(k_last);
+
+    // Move loader source ahead to end
+    loader_a.src += k_jump_a;
+    loader_b.src += k_jump_b;
+
+    // Load tile
+    const short2 tile_dims_A =
+        transpose_a ? short2(tgp_bm, k_remain) : short2(k_remain, tgp_bm);
+    const short2 tile_dims_B =
+        transpose_b ? short2(k_remain, tgp_bn) : short2(tgp_bn, k_remain);
+
+    loader_a.load_safe(tile_dims_A);
+    loader_b.load_safe(tile_dims_B);
+
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Do matmul
+    mma_op.mma(As, Bs);
+
+    // Reset source back to start
+    loader_a.src -= k_jump_a;
+    loader_b.src -= k_jump_b;
+  }
+
+  const TransformAdd<AccumType, AccumType> epilogue_op_add(
+      addmm_params->alpha, addmm_params->beta);
+  const TransformAxpby<AccumType, AccumType> epilogue_op_axpby(
+      addmm_params->alpha, addmm_params->beta);
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // MNK aligned loop
+  if (align_M && align_N) {
+    // Do gemm
+    for (int k = 0; k < gemm_k_iterations; k++) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      // Load elements into threadgroup
+      loader_a.load_unsafe();
+      loader_b.load_unsafe();
+
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      // Multiply and accumulate threadgroup elements
+      mma_op.mma(As, Bs);
+
+      // Prepare for next iteration
+      loader_a.next();
+      loader_b.next();
+    }
+
+    threadgroup_barrier(mem_flags::mem_none);
+
+    // Do epilogue
+    if (use_out_source) {
+      if (do_axpby) {
+        mma_op.apply_epilogue(
+            C, addmm_params->ldc, addmm_params->fdc, epilogue_op_axpby);
+      } else {
+        mma_op.apply_epilogue(
+            C, addmm_params->ldc, addmm_params->fdc, epilogue_op_add);
+      }
+    }
+
+    // Store results to device memory
+    return mma_op.store_result(D, params->ldd);
+
+  }
+  ///////////////////////////////////////////////////////////////////////////////
+  // MN unaligned loop
+  else { // Loop over K - unaligned case
+    const int leftover_bk = 0;
+
+    if ((align_M || tgp_bm == BM) && (align_N || tgp_bn == BN)) {
+      // Do gemm
+      gemm_kernel::gemm_loop(
+          As,
+          Bs,
+          gemm_k_iterations,
+          loader_a,
+          loader_b,
+          mma_op,
+          tgp_bm,
+          tgp_bn,
+          leftover_bk,
+          LoopAlignment<true, true, true>{});
+
+      // Do epilogue
+      if (use_out_source) {
+        if (do_axpby) {
+          mma_op.apply_epilogue(
+              C, addmm_params->ldc, addmm_params->fdc, epilogue_op_axpby);
+        } else {
+          mma_op.apply_epilogue(
+              C, addmm_params->ldc, addmm_params->fdc, epilogue_op_add);
+        }
+      }
+
+      // Store results to device memory
+      return mma_op.store_result(D, params->ldd);
+
+    } else if (align_N || tgp_bn == BN) {
+      gemm_kernel::gemm_loop(
+          As,
+          Bs,
+          gemm_k_iterations,
+          loader_a,
+          loader_b,
+          mma_op,
+          tgp_bm,
+          tgp_bn,
+          leftover_bk,
+          LoopAlignment<false, true, true>{});
+
+      // Do epilogue
+      if (use_out_source) {
+        if (do_axpby) {
+          mma_op.apply_epilogue_safe(
+              C,
+              addmm_params->ldc,
+              addmm_params->fdc,
+              short2(tgp_bn, tgp_bm),
+              epilogue_op_axpby);
+        } else {
+          mma_op.apply_epilogue_safe(
+              C,
+              addmm_params->ldc,
+              addmm_params->fdc,
+              short2(tgp_bn, tgp_bm),
+              epilogue_op_add);
+        }
+      }
+
+      // Store results to device memory
+      return mma_op.store_result_safe(D, params->ldd, short2(tgp_bn, tgp_bm));
+
+    } else if (align_M || tgp_bm == BM) {
+      gemm_kernel::gemm_loop(
+          As,
+          Bs,
+          gemm_k_iterations,
+          loader_a,
+          loader_b,
+          mma_op,
+          tgp_bm,
+          tgp_bn,
+          leftover_bk,
+          LoopAlignment<true, false, true>{});
+
+      // Do epilogue
+      if (use_out_source) {
+        if (do_axpby) {
+          mma_op.apply_epilogue_safe(
+              C,
+              addmm_params->ldc,
+              addmm_params->fdc,
+              short2(tgp_bn, tgp_bm),
+              epilogue_op_axpby);
+        } else {
+          mma_op.apply_epilogue_safe(
+              C,
+              addmm_params->ldc,
+              addmm_params->fdc,
+              short2(tgp_bn, tgp_bm),
+              epilogue_op_add);
+        }
+      }
+
+      // Store results to device memory
+      return mma_op.store_result_safe(D, params->ldd, short2(tgp_bn, tgp_bm));
+
+    } else {
+      gemm_kernel::gemm_loop(
+          As,
+          Bs,
+          gemm_k_iterations,
+          loader_a,
+          loader_b,
+          mma_op,
+          tgp_bm,
+          tgp_bn,
+          leftover_bk,
+          LoopAlignment<false, false, true>{});
+
+      // Do epilogue
+      if (use_out_source) {
+        if (do_axpby) {
+          mma_op.apply_epilogue_safe(
+              C,
+              addmm_params->ldc,
+              addmm_params->fdc,
+              short2(tgp_bn, tgp_bm),
+              epilogue_op_axpby);
+        } else {
+          mma_op.apply_epilogue_safe(
+              C,
+              addmm_params->ldc,
+              addmm_params->fdc,
+              short2(tgp_bn, tgp_bm),
+              epilogue_op_add);
+        }
+      }
+
+      // Store results to device memory
+      return mma_op.store_result_safe(D, params->ldd, short2(tgp_bn, tgp_bm));
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_fused.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_fused.metal
new file mode 100644
index 0000000000000000000000000000000000000000..5549580f94465e3d04a6bfe4dc7b2646cf3fbeae
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_fused.metal
@@ -0,0 +1,34 @@
+// Copyright © 2024 Apple Inc.
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+
+#include "mlx/backend/metal/kernels/steel/gemm/gemm.h"
+#include "mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_fused.h"
+
+#define instantiate_gemm(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+  instantiate_kernel(                                                                             \
+      "steel_gemm_fused_" #tname "_"  #iname "_" #oname                                           \
+      "_bm" #bm "_bn" #bn "_bk" #bk "_wm" #wm "_wn" #wn,                                          \
+  gemm, itype, bm, bn, bk, wm, wn, trans_a, trans_b, float)
+
+#define instantiate_gemm_transpose_helper(iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+    instantiate_gemm(nn, false, false, iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+    instantiate_gemm(nt, false, true , iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+    instantiate_gemm(tn, true , false, iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+    instantiate_gemm(tt, true , true , iname, itype, oname, otype, bm, bn, bk, wm, wn)
+
+#define instantiate_gemm_shapes_helper(iname, itype, oname, otype) \
+    instantiate_gemm_transpose_helper(iname, itype, oname, otype, 64, 64, 16, 2, 2) \
+    instantiate_gemm_transpose_helper(iname, itype, oname, otype, 64, 64, 16, 1, 2) \
+    instantiate_gemm_transpose_helper(iname, itype, oname, otype, 64, 32, 32, 2, 2) \
+    instantiate_gemm_transpose_helper(iname, itype, oname, otype, 32, 64, 16, 1, 2) \
+    instantiate_gemm_transpose_helper(iname, itype, oname, otype, 32, 32, 16, 2, 2) \
+    instantiate_gemm_transpose_helper(iname, itype, oname, otype, 64, 32,  8, 4, 1)
+
+instantiate_gemm_shapes_helper(float16, half, float16, half);
+instantiate_gemm_shapes_helper(bfloat16, bfloat16_t, bfloat16, bfloat16_t);
+
+instantiate_gemm_shapes_helper(float32, float, float32, float);
+instantiate_gemm_shapes_helper(complex64, complex64_t, complex64, complex64_t);
+// clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_gather.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_gather.h
new file mode 100644
index 0000000000000000000000000000000000000000..4493375c1126f75c3d877a43aa674319488679c5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_gather.h
@@ -0,0 +1,459 @@
+// Copyright © 2024 Apple Inc.
+
+using namespace mlx::steel;
+
+constant bool has_batch [[function_constant(10)]];
+constant bool align_M [[function_constant(200)]];
+constant bool align_N [[function_constant(201)]];
+constant bool align_K [[function_constant(202)]];
+
+template <
+    typename T,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    typename AccumType = float>
+[[kernel, max_total_threads_per_threadgroup(WM* WN * 32)]] void gather_mm_rhs(
+    const device T* A [[buffer(0)]],
+    const device T* B [[buffer(1)]],
+    const device uint32_t* rhs_indices [[buffer(2)]],
+    device T* C [[buffer(3)]],
+    const constant GEMMParams* params [[buffer(4)]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]],
+    uint3 tid [[threadgroup_position_in_grid]]) {
+  using gemm_kernel = GEMMKernel<
+      T,
+      T,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      transpose_a,
+      transpose_b,
+      true,
+      true,
+      AccumType>;
+
+  using loader_a_t = typename gemm_kernel::loader_a_t;
+  using loader_b_t = typename gemm_kernel::loader_b_t;
+  using mma_t = typename gemm_kernel::mma_t;
+
+  if (params->tiles_n <= static_cast<int>(tid.x) ||
+      params->tiles_m <= static_cast<int>(tid.y)) {
+    return;
+  }
+
+  // Prepare threadgroup memory
+  threadgroup T As[gemm_kernel::tgp_mem_size_a];
+  threadgroup T Bs[gemm_kernel::tgp_mem_size_b];
+
+  // Find the block in A, B, C
+  const int c_row = tid.y * BM;
+  const int c_col = tid.x * BN;
+  const size_t c_row_long = size_t(c_row);
+  const size_t c_col_long = size_t(c_col);
+
+  // Prepare threadgroup bounds
+  const short tgp_bm = align_M ? BM : short(min(BM, params->M - c_row));
+  const short tgp_bn = align_N ? BN : short(min(BN, params->N - c_col));
+
+  A += transpose_a ? c_row_long : c_row_long * params->lda;
+  B += transpose_b ? c_col_long * params->ldb : c_col_long;
+  C += c_row_long * params->ldd + c_col_long;
+
+  // Do as many matmuls as necessary
+  uint32_t index;
+  short offset;
+  uint32_t index_next = rhs_indices[c_row];
+  short offset_next = 0;
+  int n = 0;
+  while (n < tgp_bm) {
+    n++;
+    offset = offset_next;
+    index = index_next;
+    offset_next = tgp_bm;
+    for (; n < tgp_bm; n++) {
+      if (rhs_indices[c_row + n] != index) {
+        offset_next = n;
+        index_next = rhs_indices[c_row + n];
+        break;
+      }
+    }
+    threadgroup_barrier(mem_flags::mem_none);
+
+    // Prepare threadgroup mma operation
+    thread mma_t mma_op(simd_group_id, simd_lane_id);
+
+    // Prepare threadgroup loading operations
+    thread loader_a_t loader_a(A, params->lda, As, simd_group_id, simd_lane_id);
+    thread loader_b_t loader_b(
+        B + index * params->batch_stride_b,
+        params->ldb,
+        Bs,
+        simd_group_id,
+        simd_lane_id);
+
+    // Prepare iterations
+    const int gemm_k_iterations = params->gemm_k_iterations_aligned;
+
+    // Do unaligned K iterations first
+    if (!align_K) {
+      const int k_last = params->gemm_k_iterations_aligned * BK;
+      const int k_remain = params->K - k_last;
+      const size_t k_jump_a =
+          transpose_a ? params->lda * size_t(k_last) : size_t(k_last);
+      const size_t k_jump_b =
+          transpose_b ? size_t(k_last) : params->ldb * size_t(k_last);
+
+      // Move loader source ahead to end
+      loader_a.src += k_jump_a;
+      loader_b.src += k_jump_b;
+
+      // Load tile
+      const short2 tile_dims_A =
+          transpose_a ? short2(tgp_bm, k_remain) : short2(k_remain, tgp_bm);
+      const short2 tile_dims_B =
+          transpose_b ? short2(k_remain, tgp_bn) : short2(tgp_bn, k_remain);
+
+      loader_a.load_safe(tile_dims_A);
+      loader_b.load_safe(tile_dims_B);
+
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      // Do matmul
+      mma_op.mma(As, Bs);
+
+      // Reset source back to start
+      loader_a.src -= k_jump_a;
+      loader_b.src -= k_jump_b;
+    }
+
+    // Matrix level aligned never check
+    if (align_M && align_N) {
+      for (int k = 0; k < gemm_k_iterations; k++) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Load elements into threadgroup
+        loader_a.load_unsafe();
+        loader_b.load_unsafe();
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+
+        // Prepare for next iteration
+        loader_a.next();
+        loader_b.next();
+      }
+
+      // Store results to device memory
+      if (offset_next - offset == BM) {
+        mma_op.store_result(C, params->ldd);
+      } else {
+        mma_op.store_result_slice(
+            C, params->ldd, short2(0, offset), short2(BN, offset_next));
+      }
+    } else {
+      const short lbk = 0;
+
+      // Tile aligned don't check
+      if ((align_M || tgp_bm == BM) && (align_N || tgp_bn == BN)) {
+        gemm_kernel::gemm_loop(
+            As,
+            Bs,
+            gemm_k_iterations,
+            loader_a,
+            loader_b,
+            mma_op,
+            tgp_bm,
+            tgp_bn,
+            lbk,
+            LoopAlignment<true, true, true>{});
+        if (offset_next - offset == BM) {
+          mma_op.store_result(C, params->ldd);
+        } else {
+          mma_op.store_result_slice(
+              C, params->ldd, short2(0, offset), short2(BN, offset_next));
+        }
+      }
+
+      // Tile partially aligned check rows
+      else if (align_N || tgp_bn == BN) {
+        gemm_kernel::gemm_loop(
+            As,
+            Bs,
+            gemm_k_iterations,
+            loader_a,
+            loader_b,
+            mma_op,
+            tgp_bm,
+            tgp_bn,
+            lbk,
+            LoopAlignment<false, true, true>{});
+        mma_op.store_result_slice(
+            C, params->ldd, short2(0, offset), short2(BN, offset_next));
+      }
+
+      // Tile partially aligned check cols
+      else if (align_M || tgp_bm == BM) {
+        gemm_kernel::gemm_loop(
+            As,
+            Bs,
+            gemm_k_iterations,
+            loader_a,
+            loader_b,
+            mma_op,
+            tgp_bm,
+            tgp_bn,
+            lbk,
+            LoopAlignment<true, false, true>{});
+        mma_op.store_result_slice(
+            C, params->ldd, short2(0, offset), short2(tgp_bn, offset_next));
+      }
+
+      // Nothing aligned so check both rows and cols
+      else {
+        gemm_kernel::gemm_loop(
+            As,
+            Bs,
+            gemm_k_iterations,
+            loader_a,
+            loader_b,
+            mma_op,
+            tgp_bm,
+            tgp_bn,
+            lbk,
+            LoopAlignment<false, false, true>{});
+        mma_op.store_result_slice(
+            C, params->ldd, short2(0, offset), short2(tgp_bn, offset_next));
+      }
+    }
+  }
+}
+
+template <
+    typename T,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    typename AccumType = float>
+[[kernel, max_total_threads_per_threadgroup(WM* WN * 32)]] void gather_mm(
+    const device T* A [[buffer(0)]],
+    const device T* B [[buffer(1)]],
+    const device uint32_t* lhs_indices [[buffer(2)]],
+    const device uint32_t* rhs_indices [[buffer(3)]],
+    device T* C [[buffer(4)]],
+    const constant GEMMParams* params [[buffer(5)]],
+    const constant int* indices_shape [[buffer(6)]],
+    const constant int64_t* lhs_strides [[buffer(7)]],
+    const constant int64_t* rhs_strides [[buffer(8)]],
+    const constant int& batch_ndim_a [[buffer(9)]],
+    const constant int* batch_shape_a [[buffer(10)]],
+    const constant int64_t* batch_strides_a [[buffer(11)]],
+    const constant int& batch_ndim_b [[buffer(12)]],
+    const constant int* batch_shape_b [[buffer(13)]],
+    const constant int64_t* batch_strides_b [[buffer(14)]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]],
+    uint3 tid [[threadgroup_position_in_grid]]) {
+  using gemm_kernel = GEMMKernel<
+      T,
+      T,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      transpose_a,
+      transpose_b,
+      true,
+      true,
+      AccumType>;
+
+  using loader_a_t = typename gemm_kernel::loader_a_t;
+  using loader_b_t = typename gemm_kernel::loader_b_t;
+  using mma_t = typename gemm_kernel::mma_t;
+
+  if (params->tiles_n <= static_cast<int>(tid.x) ||
+      params->tiles_m <= static_cast<int>(tid.y)) {
+    return;
+  }
+
+  // Move A and B to the locations pointed by lhs_indices and rhs_indices.
+  uint32_t indx_A, indx_B;
+  if (has_batch) {
+    ulong2 indices_offsets = elem_to_loc_broadcast(
+        tid.z, indices_shape, lhs_strides, rhs_strides, params->batch_ndim);
+    indx_A = lhs_indices[indices_offsets.x];
+    indx_B = rhs_indices[indices_offsets.y];
+  } else {
+    indx_A = lhs_indices[params->batch_stride_a * tid.z];
+    indx_B = rhs_indices[params->batch_stride_b * tid.z];
+  }
+  A += elem_to_loc(indx_A, batch_shape_a, batch_strides_a, batch_ndim_a);
+  B += elem_to_loc(indx_B, batch_shape_b, batch_strides_b, batch_ndim_b);
+  C += params->batch_stride_d * tid.z;
+
+  // Prepare threadgroup memory
+  threadgroup T As[gemm_kernel::tgp_mem_size_a];
+  threadgroup T Bs[gemm_kernel::tgp_mem_size_b];
+
+  // Just make sure everybody's finished with the indexing math above.
+  threadgroup_barrier(mem_flags::mem_none);
+
+  // Find block in A, B, C
+  const int c_row = tid.y * BM;
+  const int c_col = tid.x * BN;
+  const size_t c_row_long = size_t(c_row);
+  const size_t c_col_long = size_t(c_col);
+
+  A += transpose_a ? c_row_long : c_row_long * params->lda;
+  B += transpose_b ? c_col_long * params->ldb : c_col_long;
+  C += c_row_long * params->ldd + c_col_long;
+
+  // Prepare threadgroup mma operation
+  thread mma_t mma_op(simd_group_id, simd_lane_id);
+
+  // Prepare threadgroup loading operations
+  thread loader_a_t loader_a(A, params->lda, As, simd_group_id, simd_lane_id);
+  thread loader_b_t loader_b(B, params->ldb, Bs, simd_group_id, simd_lane_id);
+
+  // Prepare threadgroup bounds
+  const short tgp_bm = align_M ? BM : short(min(BM, params->M - c_row));
+  const short tgp_bn = align_N ? BN : short(min(BN, params->N - c_col));
+
+  // Prepare iterations
+  int gemm_k_iterations = params->gemm_k_iterations_aligned;
+
+  // Do unaligned K iterations first
+  if (!align_K) {
+    const int k_last = params->gemm_k_iterations_aligned * BK;
+    const int k_remain = params->K - k_last;
+    const size_t k_jump_a =
+        transpose_a ? params->lda * size_t(k_last) : size_t(k_last);
+    const size_t k_jump_b =
+        transpose_b ? size_t(k_last) : params->ldb * size_t(k_last);
+
+    // Move loader source ahead to end
+    loader_a.src += k_jump_a;
+    loader_b.src += k_jump_b;
+
+    // Load tile
+    const short2 tile_dims_A =
+        transpose_a ? short2(tgp_bm, k_remain) : short2(k_remain, tgp_bm);
+    const short2 tile_dims_B =
+        transpose_b ? short2(k_remain, tgp_bn) : short2(tgp_bn, k_remain);
+
+    loader_a.load_safe(tile_dims_A);
+    loader_b.load_safe(tile_dims_B);
+
+    threadgroup_barrier(mem_flags::mem_threadgroup);
+
+    // Do matmul
+    mma_op.mma(As, Bs);
+
+    // Reset source back to start
+    loader_a.src -= k_jump_a;
+    loader_b.src -= k_jump_b;
+  }
+
+  // Matrix level aligned never check
+  if (align_M && align_N) {
+    for (int k = 0; k < gemm_k_iterations; k++) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      // Load elements into threadgroup
+      loader_a.load_unsafe();
+      loader_b.load_unsafe();
+
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      // Multiply and accumulate threadgroup elements
+      mma_op.mma(As, Bs);
+
+      // Prepare for next iteration
+      loader_a.next();
+      loader_b.next();
+    }
+
+    // Store results to device memory
+    mma_op.store_result(C, params->ldd);
+  } else {
+    const short lbk = 0;
+
+    // Tile aligned don't check
+    if ((align_M || tgp_bm == BM) && (align_N || tgp_bn == BN)) {
+      gemm_kernel::gemm_loop(
+          As,
+          Bs,
+          gemm_k_iterations,
+          loader_a,
+          loader_b,
+          mma_op,
+          tgp_bm,
+          tgp_bn,
+          lbk,
+          LoopAlignment<true, true, true>{});
+      mma_op.store_result(C, params->ldd);
+    }
+
+    // Tile partially aligned check rows
+    else if (align_N || tgp_bn == BN) {
+      gemm_kernel::gemm_loop(
+          As,
+          Bs,
+          gemm_k_iterations,
+          loader_a,
+          loader_b,
+          mma_op,
+          tgp_bm,
+          tgp_bn,
+          lbk,
+          LoopAlignment<false, true, true>{});
+      mma_op.store_result_safe(C, params->ldd, short2(tgp_bn, tgp_bm));
+    }
+
+    // Tile partially aligned check cols
+    else if (align_M || tgp_bm == BM) {
+      gemm_kernel::gemm_loop(
+          As,
+          Bs,
+          gemm_k_iterations,
+          loader_a,
+          loader_b,
+          mma_op,
+          tgp_bm,
+          tgp_bn,
+          lbk,
+          LoopAlignment<true, false, true>{});
+      mma_op.store_result_safe(C, params->ldd, short2(tgp_bn, tgp_bm));
+    }
+
+    // Nothing aligned so check both rows and cols
+    else {
+      gemm_kernel::gemm_loop(
+          As,
+          Bs,
+          gemm_k_iterations,
+          loader_a,
+          loader_b,
+          mma_op,
+          tgp_bm,
+          tgp_bn,
+          lbk,
+          LoopAlignment<false, false, true>{});
+      mma_op.store_result_safe(C, params->ldd, short2(tgp_bn, tgp_bm));
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_gather.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_gather.metal
new file mode 100644
index 0000000000000000000000000000000000000000..f8e5a2a378403178f22ee21e509feaec5da38815
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_gather.metal
@@ -0,0 +1,59 @@
+// Copyright © 2024 Apple Inc.
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/steel/gemm/gemm.h"
+#include "mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_gather.h"
+
+#define instantiate_gather_mm_rhs(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+  instantiate_kernel(                                                         \
+      "steel_gather_mm_rhs_" #tname "_" #iname "_" #oname "_bm" #bm "_bn" #bn \
+      "_bk" #bk "_wm" #wm "_wn" #wn,                                          \
+      gather_mm_rhs,                                                          \
+      itype,                                                                  \
+      bm,                                                                     \
+      bn,                                                                     \
+      bk,                                                                     \
+      wm,                                                                     \
+      wn,                                                                     \
+      trans_a,                                                                \
+      trans_b,                                                                \
+      float)
+
+#define instantiate_gather_mm(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+  instantiate_kernel(                                                     \
+      "steel_gather_mm_" #tname "_" #iname "_" #oname "_bm" #bm "_bn" #bn \
+      "_bk" #bk "_wm" #wm "_wn" #wn,                                      \
+      gather_mm,                                                          \
+      itype,                                                              \
+      bm,                                                                 \
+      bn,                                                                 \
+      bk,                                                                 \
+      wm,                                                                 \
+      wn,                                                                 \
+      trans_a,                                                            \
+      trans_b,                                                            \
+      float)
+
+#define instantiate_gather_mm_rhs_transpose_helper(iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+  instantiate_gather_mm_rhs(nn, false, false, iname, itype, oname, otype, bm, bn, bk, wm, wn)  \
+  instantiate_gather_mm_rhs(nt, false,  true, iname, itype, oname, otype, bm, bn, bk, wm, wn)
+
+#define instantiate_gather_mm_transpose_helper(iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+  instantiate_gather_mm(nn, false, false, iname, itype, oname, otype, bm, bn, bk, wm, wn)      \
+  instantiate_gather_mm(nt, false, true , iname, itype, oname, otype, bm, bn, bk, wm, wn)      \
+  instantiate_gather_mm(tn, true , false, iname, itype, oname, otype, bm, bn, bk, wm, wn)      \
+  instantiate_gather_mm(tt, true , true , iname, itype, oname, otype, bm, bn, bk, wm, wn)
+
+#define instantiate_gather_mm_shapes_helper(iname, itype, oname, otype)                     \
+  instantiate_gather_mm_rhs_transpose_helper(iname, itype, oname, otype, 16, 64, 16, 1, 2)  \
+  instantiate_gather_mm_transpose_helper(iname, itype, oname, otype, 64, 64, 16, 2, 2)      \
+  instantiate_gather_mm_transpose_helper(iname, itype, oname, otype, 64, 64, 16, 1, 2)      \
+  instantiate_gather_mm_transpose_helper(iname, itype, oname, otype, 64, 32, 32, 2, 2)      \
+  instantiate_gather_mm_transpose_helper(iname, itype, oname, otype, 32, 64, 16, 1, 2)      \
+  instantiate_gather_mm_transpose_helper(iname, itype, oname, otype, 32, 32, 16, 2, 2)
+// clang-format on
+
+instantiate_gather_mm_shapes_helper(float16, half, float16, half);
+instantiate_gather_mm_shapes_helper(bfloat16, bfloat16_t, bfloat16, bfloat16_t);
+instantiate_gather_mm_shapes_helper(float32, float, float32, float);
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_masked.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_masked.h
new file mode 100644
index 0000000000000000000000000000000000000000..c8ffe2b8efd1bd6ab2684c39c6daac3fbf02c683
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_masked.h
@@ -0,0 +1,719 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/backend/metal/kernels/steel/defines.h"
+using namespace metal;
+using namespace mlx::steel;
+
+///////////////////////////////////////////////////////////////////////////////
+// GEMM kernels
+///////////////////////////////////////////////////////////////////////////////
+
+struct _NoMask {
+  char x;
+
+  constexpr METAL_FUNC operator bool() {
+    return true;
+  }
+  constexpr METAL_FUNC operator bool() const threadgroup {
+    return true;
+  }
+  constexpr METAL_FUNC operator bool() const device {
+    return true;
+  }
+  constexpr METAL_FUNC operator bool() const constant {
+    return true;
+  }
+};
+
+template <typename OutT, typename InT = OutT>
+struct ScaleOp {
+  OutT scale;
+
+  METAL_FUNC OutT apply(InT x) const {
+    return static_cast<OutT>(x) * scale;
+  }
+};
+
+typedef struct _NoMask nomask_t;
+
+template <
+    typename T,
+    typename out_mask_t,
+    typename op_mask_t,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    bool MN_aligned,
+    bool K_aligned>
+[[kernel, max_total_threads_per_threadgroup(WM* WN * 32)]] void
+block_masked_gemm(
+    const device T* A [[buffer(0)]],
+    const device T* B [[buffer(1)]],
+    device T* D [[buffer(3)]],
+    const constant GEMMParams* params [[buffer(4)]],
+    const constant int* batch_shape [[buffer(6)]],
+    const constant int64_t* batch_strides [[buffer(7)]],
+    const device out_mask_t* out_mask [[buffer(10)]],
+    const device op_mask_t* lhs_mask [[buffer(11)]],
+    const device op_mask_t* rhs_mask [[buffer(12)]],
+    const constant int* mask_strides [[buffer(13)]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]]) {
+  // Appease the compiler
+  (void)lid;
+
+  static_assert(
+      BM == BN,
+      "block_masked_gemm must have the same block M and block N size");
+  static_assert(BM % BK == 0, "block_masked_gemm must have BM % BK == 0");
+
+  constexpr bool has_operand_mask = !metal::is_same_v<op_mask_t, nomask_t>;
+  constexpr bool has_output_mask = !metal::is_same_v<out_mask_t, nomask_t>;
+
+  constexpr bool has_mul_operand_mask =
+      has_operand_mask && !metal::is_same_v<op_mask_t, bool>;
+  constexpr bool has_mul_output_mask =
+      has_output_mask && !metal::is_same_v<out_mask_t, bool>;
+
+  constexpr short k_mask_factor = short(BM / BK);
+
+  using gemm_kernel = GEMMKernel<
+      T,
+      T,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      transpose_a,
+      transpose_b,
+      MN_aligned,
+      K_aligned>;
+
+  const int tid_y = ((tid.y) << params->swizzle_log) +
+      ((tid.x) & ((1 << params->swizzle_log) - 1));
+  const int tid_x = (tid.x) >> params->swizzle_log;
+
+  if (params->tiles_n <= tid_x || params->tiles_m <= tid_y) {
+    return;
+  }
+
+  const constant auto* mask_batch_strides =
+      batch_strides + 2 * params->batch_ndim;
+
+  if (params->batch_ndim > 1) {
+    if (has_output_mask) {
+      out_mask += elem_to_loc(
+          tid.z, batch_shape, mask_batch_strides, params->batch_ndim);
+
+      mask_batch_strides += params->batch_ndim;
+    }
+
+    if (has_operand_mask) {
+      const constant auto* mask_strides_lhs = mask_batch_strides;
+      const constant auto* mask_strides_rhs =
+          mask_strides_lhs + params->batch_ndim;
+
+      ulong2 batch_offsets = elem_to_loc_broadcast(
+          tid.z,
+          batch_shape,
+          mask_strides_lhs,
+          mask_strides_rhs,
+          params->batch_ndim);
+
+      lhs_mask += batch_offsets.x;
+      rhs_mask += batch_offsets.y;
+    }
+  } else {
+    if (has_output_mask) {
+      out_mask += tid.z * mask_batch_strides[0];
+      mask_batch_strides += params->batch_ndim;
+    }
+
+    if (has_operand_mask) {
+      lhs_mask += tid.z * mask_batch_strides[0];
+      rhs_mask += tid.z * mask_batch_strides[params->batch_ndim];
+    }
+  }
+
+  // Adjust for batch
+  if (params->batch_ndim > 1) {
+    const constant auto* A_bstrides = batch_strides;
+    const constant auto* B_bstrides = batch_strides + params->batch_ndim;
+
+    ulong2 batch_offsets = elem_to_loc_broadcast(
+        tid.z, batch_shape, A_bstrides, B_bstrides, params->batch_ndim);
+
+    A += batch_offsets.x;
+    B += batch_offsets.y;
+
+  } else {
+    A += params->batch_stride_a * tid.z;
+    B += params->batch_stride_b * tid.z;
+  }
+
+  D += params->batch_stride_d * tid.z;
+
+  // Find block in A, B, C
+  const int c_row = tid_y * BM;
+  const int c_col = tid_x * BN;
+  const size_t c_row_long = size_t(c_row);
+  const size_t c_col_long = size_t(c_col);
+
+  A += transpose_a ? c_row_long : c_row_long * params->lda;
+  B += transpose_b ? c_col_long * params->ldb : c_col_long;
+  D += c_row_long * params->ldd + c_col_long;
+
+  const constant int* out_mask_strides = mask_strides;
+  const constant int* lhs_mask_strides =
+      mask_strides + (has_output_mask ? 2 : 0);
+  const constant int* rhs_mask_strides =
+      lhs_mask_strides + (has_operand_mask ? 2 : 0);
+
+  const int out_mask_offset = !has_output_mask
+      ? 0
+      : tid_y * out_mask_strides[1] + tid_x * out_mask_strides[0];
+  int lhs_mask_offset = !has_operand_mask ? 0 : tid_y * lhs_mask_strides[1];
+  int rhs_mask_offset = !has_operand_mask ? 0 : tid_x * rhs_mask_strides[0];
+  const int lhs_mask_step = !has_operand_mask ? 0 : lhs_mask_strides[0];
+  const int rhs_mask_step = !has_operand_mask ? 0 : rhs_mask_strides[1];
+  short k_factor_cnt = k_mask_factor;
+
+  ScaleOp<float> out_mask_op;
+  ScaleOp<T> lhs_mask_op;
+  ScaleOp<T> rhs_mask_op;
+
+  if (has_output_mask) {
+    auto mask_out = out_mask[out_mask_offset];
+
+    if (has_mul_output_mask) {
+      out_mask_op.scale = float(mask_out);
+    }
+
+    // Write zeros and return
+    if (!mask_out) {
+      constexpr short tgp_size = WM * WN * 32;
+      constexpr short vec_size = 4;
+
+      // Tile threads in threadgroup
+      constexpr short TN = BN / vec_size;
+      constexpr short TM = tgp_size / TN;
+
+      const short thread_idx = simd_group_id * 32 + simd_lane_id;
+      const short bi = thread_idx / TN;
+      const short bj = vec_size * (thread_idx % TN);
+
+      D += bi * params->ldd + bj;
+
+      short tgp_bm = min(BM, params->M - c_row);
+      short tgp_bn = min(BN, params->N - c_col);
+
+      if (MN_aligned || (tgp_bm == BM && tgp_bn == BN)) {
+        for (short ti = 0; ti < BM; ti += TM) {
+          STEEL_PRAGMA_UNROLL
+          for (short j = 0; j < vec_size; j++) {
+            D[ti * params->ldd + j] = T(0.);
+          }
+        }
+      } else {
+        short jmax = tgp_bn - bj;
+        jmax = jmax < vec_size ? jmax : vec_size;
+        for (short ti = 0; (bi + ti) < tgp_bm; ti += TM) {
+          for (short j = 0; j < jmax; j++) {
+            D[ti * params->ldd + j] = T(0.);
+          }
+        }
+      }
+
+      return;
+    }
+  }
+
+  threadgroup_barrier(mem_flags::mem_none);
+
+  // Prepare threadgroup mma operation
+  thread typename gemm_kernel::mma_t mma_op(simd_group_id, simd_lane_id);
+
+  threadgroup T As[gemm_kernel::tgp_mem_size_a];
+  threadgroup T Bs[gemm_kernel::tgp_mem_size_b];
+
+  // Prepare threadgroup loading operations
+  thread typename gemm_kernel::loader_a_t loader_a(
+      A, params->lda, As, simd_group_id, simd_lane_id);
+  thread typename gemm_kernel::loader_b_t loader_b(
+      B, params->ldb, Bs, simd_group_id, simd_lane_id);
+
+  // Prepare threadgroup bounds
+  const short tgp_bm =
+      MN_aligned ? short(BM) : short(min(BM, params->M - c_row));
+  const short tgp_bn =
+      MN_aligned ? short(BN) : short(min(BN, params->N - c_col));
+
+  int gemm_k_iterations = params->gemm_k_iterations_aligned;
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // Do unaligned K iterations first
+  if (!K_aligned) {
+    const int k_last = params->gemm_k_iterations_aligned * BK;
+    const int mask_idx_last = k_last / BM;
+
+    if (!has_operand_mask ||
+        (bool(lhs_mask[lhs_mask_offset + mask_idx_last * lhs_mask_step]) &&
+         bool(rhs_mask[rhs_mask_offset + mask_idx_last * rhs_mask_step]))) {
+      if (has_mul_operand_mask) {
+        lhs_mask_op.scale =
+            lhs_mask[lhs_mask_offset + mask_idx_last * lhs_mask_step];
+        rhs_mask_op.scale =
+            rhs_mask[rhs_mask_offset + mask_idx_last * rhs_mask_step];
+      }
+
+      // Move loader source ahead to end
+      const int k_remain = params->K - k_last;
+      const size_t k_jump_a =
+          transpose_a ? params->lda * size_t(k_last) : size_t(k_last);
+      const size_t k_jump_b =
+          transpose_b ? size_t(k_last) : params->ldb * size_t(k_last);
+
+      loader_a.src += k_jump_a;
+      loader_b.src += k_jump_b;
+
+      // Load tile
+      const short2 tile_dims_A =
+          transpose_a ? short2(tgp_bm, k_remain) : short2(k_remain, tgp_bm);
+      const short2 tile_dims_B =
+          transpose_b ? short2(k_remain, tgp_bn) : short2(tgp_bn, k_remain);
+
+      loader_a.load_safe(tile_dims_A);
+      loader_b.load_safe(tile_dims_B);
+
+      if (has_mul_operand_mask) {
+        loader_a.apply_inplace_op(lhs_mask_op);
+        loader_b.apply_inplace_op(rhs_mask_op);
+      }
+
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      // Do matmul
+      mma_op.mma(As, Bs);
+
+      // Reset source back to start
+      loader_a.src -= k_jump_a;
+      loader_b.src -= k_jump_b;
+    }
+  }
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // MNK aligned loop
+  if (MN_aligned) {
+    for (; gemm_k_iterations > 0; gemm_k_iterations--) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      if (!has_operand_mask ||
+          (bool(lhs_mask[lhs_mask_offset]) &&
+           bool(rhs_mask[rhs_mask_offset]))) {
+        if (has_mul_operand_mask) {
+          lhs_mask_op.scale = lhs_mask[lhs_mask_offset];
+          rhs_mask_op.scale = rhs_mask[rhs_mask_offset];
+        }
+
+        // Load elements into threadgroup
+        loader_a.load_unsafe();
+        loader_b.load_unsafe();
+
+        if (has_mul_operand_mask) {
+          loader_a.apply_inplace_op(lhs_mask_op);
+          loader_b.apply_inplace_op(rhs_mask_op);
+        }
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+      }
+
+      // Prepare for next iteration
+      loader_a.next();
+      loader_b.next();
+
+      k_factor_cnt--;
+      lhs_mask_offset += k_factor_cnt == 0 ? lhs_mask_step : 0;
+      rhs_mask_offset += k_factor_cnt == 0 ? rhs_mask_step : 0;
+      k_factor_cnt = k_factor_cnt == 0 ? k_mask_factor : k_factor_cnt;
+    }
+
+    if (has_mul_output_mask) {
+      mma_op.apply_epilogue(out_mask_op);
+    }
+
+    // Store results to device memory
+    mma_op.store_result(D, params->ldd);
+    return;
+
+  }
+  ///////////////////////////////////////////////////////////////////////////////
+  // MN unaligned loop
+  else {
+    const bool M_aligned = (tgp_bm == BM);
+    const bool N_aligned = (tgp_bn == BN);
+
+    const short2 tile_dims_A =
+        transpose_a ? short2(tgp_bm, BK) : short2(BK, tgp_bm);
+    const short2 tile_dims_B =
+        transpose_b ? short2(BK, tgp_bn) : short2(tgp_bn, BK);
+
+    for (; gemm_k_iterations > 0; gemm_k_iterations--) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      if (!has_operand_mask ||
+          (bool(lhs_mask[lhs_mask_offset]) &&
+           bool(rhs_mask[rhs_mask_offset]))) {
+        if (has_mul_operand_mask) {
+          lhs_mask_op.scale = lhs_mask[lhs_mask_offset];
+          rhs_mask_op.scale = rhs_mask[rhs_mask_offset];
+        }
+
+        // Load elements into threadgroup
+        if (M_aligned) {
+          loader_a.load_unsafe();
+        } else {
+          loader_a.load_safe(tile_dims_A);
+        }
+
+        if (N_aligned) {
+          loader_b.load_unsafe();
+        } else {
+          loader_b.load_safe(tile_dims_B);
+        }
+
+        if (has_mul_operand_mask) {
+          loader_a.apply_inplace_op(lhs_mask_op);
+          loader_b.apply_inplace_op(rhs_mask_op);
+        }
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+      }
+
+      // Prepare for next iteration
+      loader_a.next();
+      loader_b.next();
+
+      k_factor_cnt--;
+      lhs_mask_offset += k_factor_cnt == 0 ? lhs_mask_step : 0;
+      rhs_mask_offset += k_factor_cnt == 0 ? rhs_mask_step : 0;
+      k_factor_cnt = k_factor_cnt == 0 ? k_mask_factor : k_factor_cnt;
+    }
+
+    if (has_mul_output_mask) {
+      mma_op.apply_epilogue(out_mask_op);
+    }
+
+    if (M_aligned && N_aligned) {
+      mma_op.store_result(D, params->ldd);
+    } else {
+      mma_op.store_result_safe(D, params->ldd, short2(tgp_bn, tgp_bm));
+    }
+  }
+}
+
+template <
+    typename T,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    bool MN_aligned,
+    bool K_aligned,
+    bool has_operand_mask = false>
+[[kernel, max_total_threads_per_threadgroup(WM* WN * 32)]] void
+block_masked_gemm(
+    const device T* A [[buffer(0)]],
+    const device T* B [[buffer(1)]],
+    device T* D [[buffer(3)]],
+    const constant GEMMParams* params [[buffer(4)]],
+    const constant int* batch_shape [[buffer(6)]],
+    const constant int64_t* batch_strides [[buffer(7)]],
+    const device bool* out_mask [[buffer(10)]],
+    const device bool* lhs_mask [[buffer(11)]],
+    const device bool* rhs_mask [[buffer(12)]],
+    const constant int* mask_strides [[buffer(13)]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]]) {
+  // Appease the compiler
+  (void)lid;
+
+  using gemm_kernel = GEMMKernel<
+      T,
+      T,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      transpose_a,
+      transpose_b,
+      MN_aligned,
+      K_aligned>;
+
+  const int tid_y = ((tid.y) << params->swizzle_log) +
+      ((tid.x) & ((1 << params->swizzle_log) - 1));
+  const int tid_x = (tid.x) >> params->swizzle_log;
+
+  if (params->tiles_n <= tid_x || params->tiles_m <= tid_y) {
+    return;
+  }
+
+  if (params->batch_ndim > 1) {
+    const constant auto* mask_batch_strides =
+        batch_strides + 2 * params->batch_ndim;
+    out_mask +=
+        elem_to_loc(tid.z, batch_shape, mask_batch_strides, params->batch_ndim);
+
+    if (has_operand_mask) {
+      const constant auto* mask_strides_lhs =
+          mask_batch_strides + params->batch_ndim;
+      const constant auto* mask_strides_rhs =
+          mask_strides_lhs + params->batch_ndim;
+
+      ulong2 batch_offsets = elem_to_loc_broadcast(
+          tid.z,
+          batch_shape,
+          mask_strides_lhs,
+          mask_strides_rhs,
+          params->batch_ndim);
+
+      lhs_mask += batch_offsets.x;
+      rhs_mask += batch_offsets.y;
+    }
+  } else {
+    out_mask += tid.z * batch_strides[2 * params->batch_ndim];
+    if (has_operand_mask) {
+      lhs_mask += tid.z * batch_strides[3 * params->batch_ndim];
+      rhs_mask += tid.z * batch_strides[4 * params->batch_ndim];
+    }
+  }
+
+  // Adjust for batch
+  if (params->batch_ndim > 1) {
+    const constant auto* A_bstrides = batch_strides;
+    const constant auto* B_bstrides = batch_strides + params->batch_ndim;
+
+    ulong2 batch_offsets = elem_to_loc_broadcast(
+        tid.z, batch_shape, A_bstrides, B_bstrides, params->batch_ndim);
+
+    A += batch_offsets.x;
+    B += batch_offsets.y;
+
+  } else {
+    A += params->batch_stride_a * tid.z;
+    B += params->batch_stride_b * tid.z;
+  }
+
+  D += params->batch_stride_d * tid.z;
+
+  // Find block in A, B, C
+  const int c_row = tid_y * BM;
+  const int c_col = tid_x * BN;
+  const size_t c_row_long = size_t(c_row);
+  const size_t c_col_long = size_t(c_col);
+
+  A += transpose_a ? c_row_long : c_row_long * params->lda;
+  B += transpose_b ? c_col_long * params->ldb : c_col_long;
+  D += c_row_long * params->ldd + c_col_long;
+
+  bool mask_out = out_mask[tid_y * mask_strides[1] + tid_x * mask_strides[0]];
+
+  // Write zeros and return
+  if (!mask_out) {
+    constexpr short tgp_size = WM * WN * 32;
+    constexpr short vec_size = 4;
+
+    // Tile threads in threadgroup
+    constexpr short TN = BN / vec_size;
+    constexpr short TM = tgp_size / TN;
+
+    const short thread_idx = simd_group_id * 32 + simd_lane_id;
+    const short bi = thread_idx / TN;
+    const short bj = vec_size * (thread_idx % TN);
+
+    D += bi * params->ldd + bj;
+
+    short tgp_bm = min(BM, params->M - c_row);
+    short tgp_bn = min(BN, params->N - c_col);
+
+    if (MN_aligned || (tgp_bm == BM && tgp_bn == BN)) {
+      for (short ti = 0; ti < BM; ti += TM) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; j++) {
+          D[ti * params->ldd + j] = T(0.);
+        }
+      }
+    } else {
+      short jmax = tgp_bn - bj;
+      jmax = jmax < vec_size ? jmax : vec_size;
+      for (short ti = 0; (bi + ti) < tgp_bm; ti += TM) {
+        for (short j = 0; j < jmax; j++) {
+          D[ti * params->ldd + j] = T(0.);
+        }
+      }
+    }
+
+    return;
+  }
+
+  threadgroup_barrier(mem_flags::mem_none);
+
+  // Prepare threadgroup mma operation
+  thread typename gemm_kernel::mma_t mma_op(simd_group_id, simd_lane_id);
+
+  int gemm_k_iterations = params->gemm_k_iterations_aligned;
+
+  threadgroup T As[gemm_kernel::tgp_mem_size_a];
+  threadgroup T Bs[gemm_kernel::tgp_mem_size_b];
+
+  // Prepare threadgroup loading operations
+  thread typename gemm_kernel::loader_a_t loader_a(
+      A, params->lda, As, simd_group_id, simd_lane_id);
+  thread typename gemm_kernel::loader_b_t loader_b(
+      B, params->ldb, Bs, simd_group_id, simd_lane_id);
+
+  ///////////////////////////////////////////////////////////////////////////////
+  // MNK aligned loop
+  if (MN_aligned) {
+    for (int k = 0; k < gemm_k_iterations; k++) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      if (!has_operand_mask ||
+          (lhs_mask
+               [tid_y * mask_strides[3] + ((k * BK) / BM) * mask_strides[2]] &&
+           rhs_mask
+               [((k * BK) / BM) * mask_strides[5] + tid_x * mask_strides[4]])) {
+        // Load elements into threadgroup
+        loader_a.load_unsafe();
+        loader_b.load_unsafe();
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+      }
+
+      // Prepare for next iteration
+      loader_a.next();
+      loader_b.next();
+    }
+
+    threadgroup_barrier(mem_flags::mem_none);
+
+    // Loop tail
+    if (!K_aligned) {
+      if (!has_operand_mask ||
+          (lhs_mask
+               [tid_y * mask_strides[3] + (params->K / BM) * mask_strides[2]] &&
+           rhs_mask
+               [(params->K / BM) * mask_strides[5] +
+                tid_x * mask_strides[4]])) {
+        int lbk = params->K - params->gemm_k_iterations_aligned * BK;
+        short2 tile_dims_A = transpose_a ? short2(BM, lbk) : short2(lbk, BM);
+        short2 tile_dims_B = transpose_b ? short2(lbk, BN) : short2(BN, lbk);
+
+        loader_a.load_safe(tile_dims_A);
+        loader_b.load_safe(tile_dims_B);
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        mma_op.mma(As, Bs);
+      }
+    }
+
+    // Store results to device memory
+    mma_op.store_result(D, params->ldd);
+    return;
+
+  }
+  ///////////////////////////////////////////////////////////////////////////////
+  // MN unaligned loop
+  else { // Loop over K - unaligned case
+    short tgp_bm = min(BM, params->M - c_row);
+    short tgp_bn = min(BN, params->N - c_col);
+    short lbk = params->K - params->gemm_k_iterations_aligned * BK;
+
+    bool M_aligned = (tgp_bm == BM);
+    bool N_aligned = (tgp_bn == BN);
+
+    short2 tile_dims_A = transpose_a ? short2(tgp_bm, BK) : short2(BK, tgp_bm);
+    short2 tile_dims_B = transpose_b ? short2(BK, tgp_bn) : short2(tgp_bn, BK);
+
+    for (int k = 0; k < gemm_k_iterations; k++) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      if (!has_operand_mask ||
+          (lhs_mask
+               [tid_y * mask_strides[3] + ((k * BK) / BM) * mask_strides[2]] &&
+           rhs_mask
+               [((k * BK) / BM) * mask_strides[5] + tid_x * mask_strides[4]])) {
+        // Load elements into threadgroup
+        if (M_aligned) {
+          loader_a.load_unsafe();
+        } else {
+          loader_a.load_safe(tile_dims_A);
+        }
+
+        if (N_aligned) {
+          loader_b.load_unsafe();
+        } else {
+          loader_b.load_safe(tile_dims_B);
+        }
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+      }
+
+      // Prepare for next iteration
+      loader_a.next();
+      loader_b.next();
+    }
+
+    if (!K_aligned) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      if (!has_operand_mask ||
+          (lhs_mask
+               [tid_y * mask_strides[3] + (params->K / BM) * mask_strides[2]] &&
+           rhs_mask
+               [(params->K / BM) * mask_strides[5] +
+                tid_x * mask_strides[4]])) {
+        short2 tile_dims_A_last =
+            transpose_a ? short2(tgp_bm, lbk) : short2(lbk, tgp_bm);
+        short2 tile_dims_B_last =
+            transpose_b ? short2(lbk, tgp_bn) : short2(tgp_bn, lbk);
+
+        loader_a.load_safe(tile_dims_A_last);
+        loader_b.load_safe(tile_dims_B_last);
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        mma_op.mma(As, Bs);
+      }
+    }
+
+    if (M_aligned && N_aligned) {
+      mma_op.store_result(D, params->ldd);
+    } else {
+      mma_op.store_result_safe(D, params->ldd, short2(tgp_bn, tgp_bm));
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_masked.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_masked.metal
new file mode 100644
index 0000000000000000000000000000000000000000..aa1274c94f58085a8c9280d6bb983a69781a3428
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_masked.metal
@@ -0,0 +1,76 @@
+// Copyright © 2024 Apple Inc.
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/steel/gemm/gemm.h"
+#include "mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_masked.h"
+
+#define instantiate_gemm(                                              \
+    outmaskname,                                                       \
+    outmasktype,                                                       \
+    opmaskname,                                                        \
+    opmasktype,                                                        \
+    tname,                                                             \
+    trans_a,                                                           \
+    trans_b,                                                           \
+    iname,                                                             \
+    itype,                                                             \
+    oname,                                                             \
+    otype,                                                             \
+    bm,                                                                \
+    bn,                                                                \
+    bk,                                                                \
+    wm,                                                                \
+    wn,                                                                \
+    aname,                                                             \
+    mn_aligned,                                                        \
+    kname,                                                             \
+    k_aligned)                                                         \
+  instantiate_kernel(                                                  \
+    "steel_gemm_block_outmask_" #outmaskname                           \
+      "_opmask_" #opmaskname "_" #tname "_" #iname "_" #oname          \
+      "_bm" #bm "_bn" #bn "_bk" #bk "_wm" #wm "_wn" #wn                \
+      "_MN_" #aname "_K_" #kname,                                      \
+    block_masked_gemm,                                                 \
+      itype,                                                           \
+      outmasktype,                                                     \
+      opmasktype,                                                      \
+      bm,                                                              \
+      bn,                                                              \
+      bk,                                                              \
+      wm,                                                              \
+      wn,                                                              \
+      trans_a,                                                         \
+      trans_b,                                                         \
+      mn_aligned,                                                      \
+      k_aligned)
+
+#define instantiate_gemm_mask_helper(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, aname, mn_aligned, kname, k_aligned)                \
+  instantiate_gemm(bool_, bool, bool_, bool, tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, aname, mn_aligned, kname, k_aligned)        \
+  instantiate_gemm(iname, itype, iname, itype, tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, aname, mn_aligned, kname, k_aligned)      \
+  instantiate_gemm(bool_, bool, iname, itype, tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, aname, mn_aligned, kname, k_aligned)       \
+  instantiate_gemm(iname, itype, bool_, bool, tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, aname, mn_aligned, kname, k_aligned)       \
+  instantiate_gemm(nomask, nomask_t, bool_, bool, tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, aname, mn_aligned, kname, k_aligned)   \
+  instantiate_gemm(nomask, nomask_t, iname, itype, tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, aname, mn_aligned, kname, k_aligned)  \
+  instantiate_gemm(bool_, bool, nomask, nomask_t, tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, aname, mn_aligned, kname, k_aligned)   \
+  instantiate_gemm(iname, itype, nomask, nomask_t, tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, aname, mn_aligned, kname, k_aligned)
+
+#define instantiate_gemm_aligned_helper(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn)                         \
+  instantiate_gemm_mask_helper(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, taligned, true, taligned, true)  \
+  instantiate_gemm_mask_helper(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, taligned, true, naligned, false) \
+  instantiate_gemm_mask_helper(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, naligned, false, taligned, true) \
+  instantiate_gemm_mask_helper(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, naligned, false, naligned, false)
+
+#define instantiate_gemm_transpose_helper(iname, itype, oname, otype, bm, bn, bk, wm, wn)             \
+    instantiate_gemm_aligned_helper(nn, false, false, iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+    instantiate_gemm_aligned_helper(nt, false, true , iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+    instantiate_gemm_aligned_helper(tn, true , false, iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+    instantiate_gemm_aligned_helper(tt, true , true , iname, itype, oname, otype, bm, bn, bk, wm, wn)
+
+#define instantiate_gemm_shapes_helper(iname, itype, oname, otype)                  \
+    instantiate_gemm_transpose_helper(iname, itype, oname, otype, 32, 32, 16, 2, 2) \
+    instantiate_gemm_transpose_helper(iname, itype, oname, otype, 64, 64, 16, 2, 2)
+
+instantiate_gemm_shapes_helper(float16, half, float16, half);
+instantiate_gemm_shapes_helper(bfloat16, bfloat16_t, bfloat16, bfloat16_t);
+instantiate_gemm_shapes_helper(float32, float, float32, float); // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_segmented.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_segmented.h
new file mode 100644
index 0000000000000000000000000000000000000000..b915eb343223cbffb64efc372f9de3e36b5fc8cf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_segmented.h
@@ -0,0 +1,266 @@
+// Copyright © 2025 Apple Inc.
+
+using namespace mlx::steel;
+
+constant bool segments_contiguous [[function_constant(199)]];
+constant bool align_M [[function_constant(200)]];
+constant bool align_N [[function_constant(201)]];
+
+template <
+    typename T,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    typename AccumType = float>
+[[kernel, max_total_threads_per_threadgroup(WM* WN * 32)]] void segmented_mm(
+    const device T* A [[buffer(0)]],
+    const device T* B [[buffer(1)]],
+    const device uint32_t* segments [[buffer(2)]],
+    device T* C [[buffer(3)]],
+    const constant GEMMParams* params [[buffer(4)]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]],
+    uint3 tid [[threadgroup_position_in_grid]]) {
+  using gemm_kernel = GEMMKernel<
+      T,
+      T,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      transpose_a,
+      transpose_b,
+      true,
+      true,
+      AccumType>;
+
+  using loader_a_t = typename gemm_kernel::loader_a_t;
+  using loader_b_t = typename gemm_kernel::loader_b_t;
+  using mma_t = typename gemm_kernel::mma_t;
+
+  if (params->tiles_n <= static_cast<int>(tid.x) ||
+      params->tiles_m <= static_cast<int>(tid.y)) {
+    return;
+  }
+
+  // Prepare threadgroup memory
+  threadgroup T As[gemm_kernel::tgp_mem_size_a];
+  threadgroup T Bs[gemm_kernel::tgp_mem_size_b];
+
+  // Find the block in A, B, C
+  const int c_row = tid.y * BM;
+  const int c_col = tid.x * BN;
+  const size_t c_row_long = size_t(c_row);
+  const size_t c_col_long = size_t(c_col);
+
+  // Prepare threadgroup bounds
+  const short tgp_bm = align_M ? BM : short(min(BM, params->M - c_row));
+  const short tgp_bn = align_N ? BN : short(min(BN, params->N - c_col));
+
+  // Move the pointers to the output tile
+  A += transpose_a ? c_row_long : c_row_long * params->lda;
+  B += transpose_b ? c_col_long * params->ldb : c_col_long;
+  C += c_row_long * params->ldd + c_col_long;
+
+  // Move the pointers to the start of the segment
+  uint32_t k_start, k_end;
+  if (segments_contiguous) {
+    k_start = segments[2 * tid.z];
+    k_end = segments[2 * tid.z + 1];
+  } else {
+    // We accept either contiguous (above) or weird strides where the beginning
+    // of the next one is the previous one. Basically the last two strides are
+    // both 1!
+    k_start = segments[tid.z];
+    k_end = segments[tid.z + 1];
+  }
+  A += transpose_a ? k_start * params->lda : k_start;
+  B += transpose_b ? k_start : k_start * params->ldb;
+  C += tid.z * params->batch_stride_d;
+
+  // Prepare threadgroup mma operation
+  thread mma_t mma_op(simd_group_id, simd_lane_id);
+
+  // Prepare threadgroup loading operations
+  thread loader_a_t loader_a(A, params->lda, As, simd_group_id, simd_lane_id);
+  thread loader_b_t loader_b(B, params->ldb, Bs, simd_group_id, simd_lane_id);
+
+  // Matrix level alignment so only check K
+  if (align_M && align_N) {
+    uint32_t k = k_start + BK;
+    for (; k <= k_end; k += BK) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      // Load elements into threadgroup
+      loader_a.load_unsafe();
+      loader_b.load_unsafe();
+
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+
+      // Multiply and accumulate threadgroup elements
+      mma_op.mma(As, Bs);
+
+      // Prepare for next iteration
+      loader_a.next();
+      loader_b.next();
+    }
+    short k_remain = BK - short(k - k_end);
+    const short2 tile_dims_A =
+        transpose_a ? short2(tgp_bm, k_remain) : short2(k_remain, tgp_bm);
+    const short2 tile_dims_B =
+        transpose_b ? short2(k_remain, tgp_bn) : short2(tgp_bn, k_remain);
+    if (k_remain > 0) {
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      loader_a.load_safe(tile_dims_A);
+      loader_b.load_safe(tile_dims_B);
+      threadgroup_barrier(mem_flags::mem_threadgroup);
+      mma_op.mma(As, Bs);
+    }
+    mma_op.store_result(C, params->ldd);
+  } else {
+    // Tile aligned do the same as above
+    if ((align_M || tgp_bm == BM) && (align_N || tgp_bn == BN)) {
+      uint32_t k = k_start + BK;
+      for (; k <= k_end; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Load elements into threadgroup
+        loader_a.load_unsafe();
+        loader_b.load_unsafe();
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+
+        // Prepare for next iteration
+        loader_a.next();
+        loader_b.next();
+      }
+      short k_remain = BK - short(k - k_end);
+      const short2 tile_dims_A =
+          transpose_a ? short2(tgp_bm, k_remain) : short2(k_remain, tgp_bm);
+      const short2 tile_dims_B =
+          transpose_b ? short2(k_remain, tgp_bn) : short2(tgp_bn, k_remain);
+      if (k_remain > 0) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_a.load_safe(tile_dims_A);
+        loader_b.load_safe(tile_dims_B);
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(As, Bs);
+      }
+      mma_op.store_result(C, params->ldd);
+    }
+
+    // Tile partially aligned check rows
+    else if (align_N || tgp_bn == BN) {
+      uint32_t k = k_start + BK;
+      for (; k <= k_end; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Load elements into threadgroup
+        loader_a.load_safe(
+            transpose_a ? short2(tgp_bm, BK) : short2(BK, tgp_bm));
+        loader_b.load_unsafe();
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+
+        // Prepare for next iteration
+        loader_a.next();
+        loader_b.next();
+      }
+      short k_remain = BK - short(k - k_end);
+      const short2 tile_dims_A =
+          transpose_a ? short2(tgp_bm, k_remain) : short2(k_remain, tgp_bm);
+      const short2 tile_dims_B =
+          transpose_b ? short2(k_remain, tgp_bn) : short2(tgp_bn, k_remain);
+      if (k_remain > 0) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_a.load_safe(tile_dims_A);
+        loader_b.load_safe(tile_dims_B);
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(As, Bs);
+      }
+      mma_op.store_result_safe(C, params->ldd, short2(tgp_bn, tgp_bm));
+    }
+
+    // Tile partially aligned check cols
+    else if (align_M || tgp_bm == BM) {
+      uint32_t k = k_start + BK;
+      for (; k <= k_end; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Load elements into threadgroup
+        loader_a.load_unsafe();
+        loader_b.load_safe(
+            transpose_b ? short2(BK, tgp_bn) : short2(tgp_bn, BK));
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+
+        // Prepare for next iteration
+        loader_a.next();
+        loader_b.next();
+      }
+      short k_remain = BK - short(k - k_end);
+      const short2 tile_dims_A =
+          transpose_a ? short2(tgp_bm, k_remain) : short2(k_remain, tgp_bm);
+      const short2 tile_dims_B =
+          transpose_b ? short2(k_remain, tgp_bn) : short2(tgp_bn, k_remain);
+      if (k_remain > 0) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_a.load_safe(tile_dims_A);
+        loader_b.load_safe(tile_dims_B);
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(As, Bs);
+      }
+      mma_op.store_result_safe(C, params->ldd, short2(tgp_bn, tgp_bm));
+    }
+
+    // Nothing aligned so check both rows and cols
+    else {
+      uint32_t k = k_start + BK;
+      for (; k <= k_end; k += BK) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Load elements into threadgroup
+        loader_a.load_safe(
+            transpose_a ? short2(tgp_bm, BK) : short2(BK, tgp_bm));
+        loader_b.load_safe(
+            transpose_b ? short2(BK, tgp_bn) : short2(tgp_bn, BK));
+
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+
+        // Multiply and accumulate threadgroup elements
+        mma_op.mma(As, Bs);
+
+        // Prepare for next iteration
+        loader_a.next();
+        loader_b.next();
+      }
+      short k_remain = BK - short(k - k_end);
+      const short2 tile_dims_A =
+          transpose_a ? short2(tgp_bm, k_remain) : short2(k_remain, tgp_bm);
+      const short2 tile_dims_B =
+          transpose_b ? short2(k_remain, tgp_bn) : short2(tgp_bn, k_remain);
+      if (k_remain > 0) {
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        loader_a.load_safe(tile_dims_A);
+        loader_b.load_safe(tile_dims_B);
+        threadgroup_barrier(mem_flags::mem_threadgroup);
+        mma_op.mma(As, Bs);
+      }
+      mma_op.store_result_safe(C, params->ldd, short2(tgp_bn, tgp_bm));
+    }
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_segmented.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_segmented.metal
new file mode 100644
index 0000000000000000000000000000000000000000..a7515c359124fe0abc84639e8113d72611402b6b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_segmented.metal
@@ -0,0 +1,43 @@
+// Copyright © 2024 Apple Inc.
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/steel/gemm/gemm.h"
+#include "mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_segmented.h"
+
+#define instantiate_segmented_mm(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+  instantiate_kernel(                                                         \
+      "steel_segmented_mm_" #tname "_" #iname "_" #oname "_bm" #bm "_bn" #bn  \
+      "_bk" #bk "_wm" #wm "_wn" #wn,                                          \
+      segmented_mm,                                                           \
+      itype,                                                                  \
+      bm,                                                                     \
+      bn,                                                                     \
+      bk,                                                                     \
+      wm,                                                                     \
+      wn,                                                                     \
+      trans_a,                                                                \
+      trans_b,                                                                \
+      float)
+
+#define instantiate_segmented_mm_transpose_helper(iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+  instantiate_segmented_mm(nn, false, false, iname, itype, oname, otype, bm, bn, bk, wm, wn)      \
+  instantiate_segmented_mm(nt, false, true , iname, itype, oname, otype, bm, bn, bk, wm, wn)      \
+  instantiate_segmented_mm(tn, true , false, iname, itype, oname, otype, bm, bn, bk, wm, wn)      \
+  instantiate_segmented_mm(tt, true , true , iname, itype, oname, otype, bm, bn, bk, wm, wn)
+
+#define instantiate_segmented_mm_shapes_helper(iname, itype, oname, otype)                 \
+  instantiate_segmented_mm_transpose_helper(iname, itype, oname, otype, 64, 64, 16, 2, 2)  \
+  instantiate_segmented_mm_transpose_helper(iname, itype, oname, otype, 64, 64, 16, 1, 2)  \
+  instantiate_segmented_mm_transpose_helper(iname, itype, oname, otype, 64, 32, 32, 2, 2)  \
+  instantiate_segmented_mm_transpose_helper(iname, itype, oname, otype, 32, 64, 16, 1, 2)  \
+  instantiate_segmented_mm_transpose_helper(iname, itype, oname, otype, 32, 32, 16, 2, 2)
+// clang-format on
+
+instantiate_segmented_mm_shapes_helper(float16, half, float16, half);
+instantiate_segmented_mm_shapes_helper(
+    bfloat16,
+    bfloat16_t,
+    bfloat16,
+    bfloat16_t);
+instantiate_segmented_mm_shapes_helper(float32, float, float32, float);
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_splitk.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_splitk.h
new file mode 100644
index 0000000000000000000000000000000000000000..1ff97ea48d90bb929143d9287143b6f107aca1ec
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_splitk.h
@@ -0,0 +1,227 @@
+// Copyright © 2024 Apple Inc.
+
+using namespace mlx::steel;
+
+///////////////////////////////////////////////////////////////////////////////
+// GEMM kernels
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename T,
+    typename U,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    bool MN_aligned,
+    bool K_aligned>
+[[kernel, max_total_threads_per_threadgroup(WM* WN * 32)]] void gemm_splitk(
+    const device T* A [[buffer(0)]],
+    const device T* B [[buffer(1)]],
+    device U* C [[buffer(2)]],
+    const constant GEMMSpiltKParams* params [[buffer(3)]],
+    uint simd_lane_id [[thread_index_in_simdgroup]],
+    uint simd_group_id [[simdgroup_index_in_threadgroup]],
+    uint3 tid [[threadgroup_position_in_grid]],
+    uint3 lid [[thread_position_in_threadgroup]]) {
+  (void)lid;
+
+  using gemm_kernel = GEMMKernel<
+      T,
+      U,
+      BM,
+      BN,
+      BK,
+      WM,
+      WN,
+      transpose_a,
+      transpose_b,
+      MN_aligned,
+      K_aligned>;
+  using loader_a_t = typename gemm_kernel::loader_a_t;
+  using loader_b_t = typename gemm_kernel::loader_b_t;
+  using mma_t = typename gemm_kernel::mma_t;
+
+  threadgroup T As[gemm_kernel::tgp_mem_size_a];
+  threadgroup T Bs[gemm_kernel::tgp_mem_size_b];
+
+  const int tid_x = tid.x;
+  const int tid_y = tid.y;
+  const int tid_z = tid.z;
+
+  if (params->tiles_n <= tid_x || params->tiles_m <= tid_y) {
+    return;
+  }
+
+  // Find block in A, B, C
+  const int c_row = tid_y * BM;
+  const int c_col = tid_x * BN;
+  const int k_start = params->split_k_partition_size * tid_z;
+
+  const size_t c_row_long = size_t(c_row);
+  const size_t c_col_long = size_t(c_col);
+  const size_t k_start_long = size_t(k_start);
+
+  A += transpose_a ? (c_row_long + k_start_long * params->lda)
+                   : (k_start_long + c_row_long * params->lda);
+  B += transpose_b ? (k_start_long + c_col_long * params->ldb)
+                   : (c_col_long + k_start_long * params->ldb);
+  C += (size_t(params->split_k_partition_stride) * tid_z) +
+      (c_row_long * params->ldc + c_col_long);
+
+  // Prepare threadgroup loading operations
+  thread loader_a_t loader_a(A, params->lda, As, simd_group_id, simd_lane_id);
+  thread loader_b_t loader_b(B, params->ldb, Bs, simd_group_id, simd_lane_id);
+
+  // Prepare threadgroup mma operation
+  thread mma_t mma_op(simd_group_id, simd_lane_id);
+
+  int gemm_k_iterations = params->gemm_k_iterations_aligned;
+
+  short tgp_bm = min(BM, params->M - c_row);
+  short tgp_bn = min(BN, params->N - c_col);
+  short leftover_bk = params->K % BK;
+
+  if (MN_aligned || (tgp_bm == BM && tgp_bn == BN)) {
+    gemm_kernel::gemm_loop(
+        As,
+        Bs,
+        gemm_k_iterations,
+        loader_a,
+        loader_b,
+        mma_op,
+        tgp_bm,
+        tgp_bn,
+        leftover_bk,
+        LoopAlignment<true, true, true>{});
+  } else if (tgp_bn == BN) {
+    gemm_kernel::gemm_loop(
+        As,
+        Bs,
+        gemm_k_iterations,
+        loader_a,
+        loader_b,
+        mma_op,
+        tgp_bm,
+        tgp_bn,
+        leftover_bk,
+        LoopAlignment<false, true, true>{});
+  } else if (tgp_bm == BM) {
+    gemm_kernel::gemm_loop(
+        As,
+        Bs,
+        gemm_k_iterations,
+        loader_a,
+        loader_b,
+        mma_op,
+        tgp_bm,
+        tgp_bn,
+        leftover_bk,
+        LoopAlignment<true, false, true>{});
+  } else {
+    gemm_kernel::gemm_loop(
+        As,
+        Bs,
+        gemm_k_iterations,
+        loader_a,
+        loader_b,
+        mma_op,
+        tgp_bm,
+        tgp_bn,
+        leftover_bk,
+        LoopAlignment<false, false, true>{});
+  }
+
+  threadgroup_barrier(mem_flags::mem_threadgroup);
+
+  if ((tid_z + 1) == (params->split_k_partitions)) {
+    int gemm_k_iter_remaining =
+        (params->K - (k_start + params->split_k_partition_size)) / BK;
+    if (!K_aligned || gemm_k_iter_remaining > 0)
+      gemm_kernel::gemm_loop(
+          As,
+          Bs,
+          gemm_k_iter_remaining,
+          loader_a,
+          loader_b,
+          mma_op,
+          tgp_bm,
+          tgp_bn,
+          leftover_bk,
+          LoopAlignment<false, false, K_aligned>{});
+  }
+
+  if (MN_aligned || (tgp_bm == BM && tgp_bn == BN)) {
+    mma_op.store_result(C, params->ldc);
+  } else {
+    mma_op.store_result_safe(C, params->ldc, short2(tgp_bn, tgp_bm));
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Split k accumulation kernel
+///////////////////////////////////////////////////////////////////////////////
+
+template <
+    typename AccT,
+    typename OutT,
+    typename Epilogue = TransformNone<OutT, AccT>>
+[[kernel]] void gemm_splitk_accum(
+    const device AccT* C_split [[buffer(0)]],
+    device OutT* D [[buffer(1)]],
+    const constant int& k_partitions [[buffer(2)]],
+    const constant int& partition_stride [[buffer(3)]],
+    const constant int& ldd [[buffer(4)]],
+    uint2 gid [[thread_position_in_grid]]) {
+  // Ajust D and C
+  D += gid.x + gid.y * size_t(ldd);
+  C_split += gid.x + gid.y * size_t(ldd);
+
+  size_t offset = 0;
+  AccT out = 0;
+
+  for (int i = 0; i < k_partitions; i++) {
+    out += C_split[offset];
+    offset += partition_stride;
+  }
+
+  // Write output
+  D[0] = Epilogue::apply(out);
+}
+
+template <
+    typename AccT,
+    typename OutT,
+    typename Epilogue = TransformAxpby<OutT, AccT>>
+[[kernel]] void gemm_splitk_accum_axpby(
+    const device AccT* C_split [[buffer(0)]],
+    device OutT* D [[buffer(1)]],
+    const constant int& k_partitions [[buffer(2)]],
+    const constant int& partition_stride [[buffer(3)]],
+    const constant int& ldd [[buffer(4)]],
+    const device OutT* C [[buffer(5)]],
+    const constant int& ldc [[buffer(6)]],
+    const constant int& fdc [[buffer(7)]],
+    const constant float& alpha [[buffer(8)]],
+    const constant float& beta [[buffer(9)]],
+    uint2 gid [[thread_position_in_grid]]) {
+  // Ajust D and C
+  C += gid.x * size_t(fdc) + gid.y * size_t(ldc);
+  D += gid.x + gid.y * size_t(ldd);
+  C_split += gid.x + gid.y * size_t(ldd);
+
+  size_t offset = 0;
+  AccT out = 0;
+
+  for (int i = 0; i < k_partitions; i++) {
+    out += C_split[offset];
+    offset += partition_stride;
+  }
+
+  // Write output
+  Epilogue op(alpha, beta);
+  D[0] = op.apply(out, *C);
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_splitk.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_splitk.metal
new file mode 100644
index 0000000000000000000000000000000000000000..8c60b426c2150189502c52066d1da991ef231ab7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_splitk.metal
@@ -0,0 +1,76 @@
+// Copyright © 2024 Apple Inc.
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/steel/gemm/gemm.h"
+#include "mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_splitk.h"
+
+#define instantiate_gemm(                                     \
+    tname,                                                    \
+    trans_a,                                                  \
+    trans_b,                                                  \
+    iname,                                                    \
+    itype,                                                    \
+    oname,                                                    \
+    otype,                                                    \
+    bm,                                                       \
+    bn,                                                       \
+    bk,                                                       \
+    wm,                                                       \
+    wn,                                                       \
+    aname,                                                    \
+    mn_aligned,                                               \
+    kname,                                                    \
+    k_aligned)                                                \
+  instantiate_kernel(                                         \
+      "steel_gemm_splitk_" #tname "_" #iname "_" #oname       \
+         "_bm" #bm "_bn" #bn "_bk" #bk "_wm" #wm "_wn" #wn    \
+         "_MN_" #aname "_K_" #kname,                          \
+  gemm_splitk,                                                \
+      itype,                                                  \
+      otype,                                                  \
+      bm,                                                     \
+      bn,                                                     \
+      bk,                                                     \
+      wm,                                                     \
+      wn,                                                     \
+      trans_a,                                                \
+      trans_b,                                                \
+      mn_aligned,                                             \
+      k_aligned)
+
+#define instantiate_gemm_aligned_helper(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn)             \
+  instantiate_gemm(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, taligned, true, taligned, true)  \
+  instantiate_gemm(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, taligned, true, naligned, false) \
+  instantiate_gemm(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, naligned, false, taligned, true) \
+  instantiate_gemm(tname, trans_a, trans_b, iname, itype, oname, otype, bm, bn, bk, wm, wn, naligned, false, naligned, false)
+
+#define instantiate_gemm_transpose_helper(iname, itype, oname, otype, bm, bn, bk, wm, wn)             \
+    instantiate_gemm_aligned_helper(nn, false, false, iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+    instantiate_gemm_aligned_helper(nt, false, true , iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+    instantiate_gemm_aligned_helper(tn, true , false, iname, itype, oname, otype, bm, bn, bk, wm, wn) \
+    instantiate_gemm_aligned_helper(tt, true , true , iname, itype, oname, otype, bm, bn, bk, wm, wn)
+
+#define instantiate_gemm_shapes_helper(iname, itype, oname, otype)                  \
+    instantiate_gemm_transpose_helper(iname, itype, oname, otype, 16, 16, 16, 2, 2) \
+    instantiate_gemm_transpose_helper(iname, itype, oname, otype, 16, 32, 16, 2, 2) \
+    instantiate_gemm_transpose_helper(iname, itype, oname, otype, 32, 16, 16, 2, 2) \
+    instantiate_gemm_transpose_helper(iname, itype, oname, otype, 32, 32, 16, 2, 2)
+
+instantiate_gemm_shapes_helper(float16, half, float32, float);
+instantiate_gemm_shapes_helper(bfloat16, bfloat16_t, float32, float);
+instantiate_gemm_shapes_helper(float32, float, float32, float);
+instantiate_gemm_shapes_helper(complex64, complex64_t, complex64, complex64_t);
+
+#define instantiate_accum(oname, otype, aname, atype)      \
+  instantiate_kernel(                                      \
+    "steel_gemm_splitk_accum_" #oname "_" #aname,          \
+    gemm_splitk_accum, atype, otype)                       \
+  instantiate_kernel(                                      \
+    "steel_gemm_splitk_accum_" #oname "_" #aname "_axbpy", \
+  gemm_splitk_accum_axpby, atype, otype)                   \
+
+instantiate_accum(bfloat16, bfloat16_t, float32, float);
+instantiate_accum(float16, half, float32, float);
+instantiate_accum(float32, float, float32, float);
+instantiate_accum(complex64, complex64_t, complex64, complex64_t); // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/loader.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/loader.h
new file mode 100644
index 0000000000000000000000000000000000000000..d421b2d1f98b25c65742203c9b25faf08e109c3e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/loader.h
@@ -0,0 +1,137 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/steel/defines.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Loading helper
+///////////////////////////////////////////////////////////////////////////////
+
+namespace mlx {
+namespace steel {
+
+template <
+    typename T,
+    short BROWS,
+    short BCOLS,
+    short dst_ld,
+    short reduction_dim,
+    short tgp_size,
+    short alignment = 1,
+    short n_reads = (BCOLS * BROWS) / (tgp_size),
+    short TCOLS = BCOLS / n_reads,
+    short TROWS = tgp_size / TCOLS>
+struct BlockLoader {
+  STEEL_CONST short n_rows = (BROWS + TROWS - 1) / TROWS;
+  STEEL_CONST short vec_size = n_reads;
+
+  // Leading dimension for src
+  const int src_ld;
+  const int tile_stride;
+
+  // Thread location indices
+  const short thread_idx;
+  const short bi;
+  const short bj;
+
+  // threadgroup and device memory
+  threadgroup T* dst;
+  const device T* src;
+
+  struct alignas(alignment * sizeof(T)) ReadVector {
+    uint8_t v[sizeof(T) * vec_size];
+  };
+
+  /* Constructor */
+  METAL_FUNC BlockLoader(
+      const device T* src_,
+      const int src_ld_,
+      threadgroup T* dst_,
+      ushort simd_group_id [[simdgroup_index_in_threadgroup]],
+      ushort simd_lane_id [[thread_index_in_simdgroup]])
+      : src_ld(src_ld_),
+        tile_stride(reduction_dim ? BCOLS : BROWS * src_ld),
+        thread_idx(simd_group_id * 32 + simd_lane_id),
+        bi(thread_idx / TCOLS),
+        bj(vec_size * (thread_idx % TCOLS)),
+        dst(dst_ + bi * dst_ld + bj),
+        src(src_ + bi * src_ld + bj) {}
+
+  /* Apply operation to threadgroup without bound checking */
+  template <typename UnaryOp>
+  METAL_FUNC void apply_inplace_op(thread const UnaryOp& op) const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < BROWS; i += TROWS) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        dst[i * dst_ld + j] = op.apply(dst[i * dst_ld + j]);
+      }
+    }
+  }
+
+  /* Load from device memory into threadgroup memory - without bound checking */
+  METAL_FUNC void load_unsafe() const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < BROWS; i += TROWS) {
+      *((threadgroup ReadVector*)(&dst[i * dst_ld])) =
+          *((const device ReadVector*)(&src[i * src_ld]));
+    }
+  }
+
+  /* Load from device memory into threadgroup memory - with bound checking */
+  METAL_FUNC void load_safe(short2 src_tile_dim) const {
+    src_tile_dim = src_tile_dim - short2(bj, bi);
+
+    // Skip loading if thread has no valid reads
+    if (src_tile_dim.x <= 0 || src_tile_dim.y <= 0) {
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < BROWS; i += TROWS) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < vec_size; j++) {
+          dst[i * dst_ld + j] = T(0);
+        }
+      }
+      return;
+    }
+
+    // Use fast thread memory for bound checks
+    bool tmp_idx[vec_size];
+    T tmp_val[vec_size];
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < BROWS; i += TROWS) {
+      // Make sure tmp_idx only contains valid indices
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        tmp_idx[j] = (i < src_tile_dim.y) && (j < src_tile_dim.x);
+      }
+
+      // Read valid indices into tmp_val
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        tmp_val[j] = src[(tmp_idx[j] ? i * src_ld + j : 0)];
+      }
+
+      // Zero out unneeded values
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        tmp_val[j] = tmp_idx[j] ? tmp_val[j] : T(0);
+      }
+
+      // Copy values to threadgroup memory
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < vec_size; j++) {
+        dst[i * dst_ld + j] = tmp_val[j];
+      }
+    }
+  }
+
+  /* Iteration helper */
+  METAL_FUNC void next() {
+    src += tile_stride;
+  }
+};
+
+} // namespace steel
+} // namespace mlx
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/mma.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/mma.h
new file mode 100644
index 0000000000000000000000000000000000000000..74151a9543b0d29da5a7a8a93169f26098a845a0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/mma.h
@@ -0,0 +1,1146 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include <metal_simdgroup>
+#include <metal_simdgroup_matrix>
+#include <metal_stdlib>
+
+#include "mlx/backend/metal/kernels/steel/defines.h"
+#include "mlx/backend/metal/kernels/steel/gemm/transforms.h"
+#include "mlx/backend/metal/kernels/steel/utils/integral_constant.h"
+
+using namespace metal;
+
+///////////////////////////////////////////////////////////////////////////////
+// MMA helper
+///////////////////////////////////////////////////////////////////////////////
+
+namespace mlx {
+namespace steel {
+
+template <typename T, int kFragRows_, int kFragCols_>
+struct BaseMMAFrag {
+  static_assert(
+      kFragRows_ == 8,
+      "Only 8 x 8 fragment matrices are currently supported");
+  static_assert(
+      kFragCols_ == 8,
+      "Only 8 x 8 fragment matrices are currently supported");
+};
+
+template <typename T>
+struct BaseMMAFrag<T, 8, 8> {
+  STEEL_CONST int kFragRows = 8;
+  STEEL_CONST int kFragCols = 8;
+
+  STEEL_CONST int kElemsPerFrag = (kFragRows * kFragCols) / 32;
+
+  STEEL_CONST int kElemRows = 1;
+  STEEL_CONST int kElemCols = 2;
+
+  static_assert(
+      kElemRows * kElemCols == kElemsPerFrag,
+      "MMAFrag shape is not consistent with MMAFrag size");
+
+  typedef metal::simdgroup_matrix<T, kFragRows, kFragCols> mat_type;
+  typedef metal::vec<T, kElemsPerFrag> frag_type;
+
+  METAL_FUNC static constexpr short2 get_coord(ushort simd_lane_id
+                                               [[thread_index_in_simdgroup]]) {
+    const short qid = simd_lane_id / 4;
+    const short fm = (qid & 4) + ((simd_lane_id / 2) % 4);
+    const short fn = (qid & 2) * 2 + (simd_lane_id % 2) * 2;
+    return short2{fn, fm};
+  }
+
+  template <typename SrcPtrType, typename StrX, typename StrY>
+  METAL_FUNC static constexpr void
+  load(thread frag_type& dst, SrcPtrType src, StrX str_x, StrY str_y) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kElemRows; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kElemCols; j++) {
+        dst[i * kElemCols + j] = static_cast<T>(src[i * str_x + j * str_y]);
+      }
+    }
+  }
+
+  template <
+      typename SrcPtrType,
+      typename StrX,
+      typename StrY,
+      typename LimX,
+      typename LimY,
+      typename OffX,
+      typename OffY>
+  METAL_FUNC static constexpr void load_safe(
+      thread frag_type& dst,
+      SrcPtrType src,
+      StrX str_x,
+      StrY str_y,
+      LimX lim_x,
+      LimY lim_y,
+      OffX off_x = Int<0>{},
+      OffY off_y = Int<0>{}) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kElemRows; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kElemCols; j++) {
+        if ((off_x + i) < lim_x && (off_y + j) < lim_y) {
+          dst[i * kElemCols + j] =
+              static_cast<T>(src[(off_x + i) * str_x + (off_x + j) * str_y]);
+        } else {
+          dst[i * kElemCols + j] = T(0);
+        }
+      }
+    }
+  }
+
+  template <typename DstPtrType, typename StrX, typename StrY>
+  METAL_FUNC static constexpr void
+  store(const thread frag_type& src, DstPtrType dst, StrX str_x, StrY str_y) {
+    using U = pointer_element_t<DstPtrType>;
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kElemRows; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kElemCols; j++) {
+        dst[i * str_x + j * str_y] = static_cast<U>(src[i * kElemCols + j]);
+      }
+    }
+  }
+
+  template <
+      typename DstPtrType,
+      typename StrX,
+      typename StrY,
+      typename LimX,
+      typename LimY,
+      typename OffX,
+      typename OffY>
+  METAL_FUNC static constexpr void store_safe(
+      const thread frag_type& src,
+      DstPtrType dst,
+      StrX str_x,
+      StrY str_y,
+      LimX lim_x,
+      LimY lim_y,
+      OffX off_x = Int<0>{},
+      OffY off_y = Int<0>{}) {
+    using U = pointer_element_t<DstPtrType>;
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kElemRows; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kElemCols; j++) {
+        if ((off_x + i) < lim_x && (off_y + j) < lim_y) {
+          dst[(off_x + i) * str_x + (off_y + j) * str_y] =
+              static_cast<U>(src[i * kElemCols + j]);
+        }
+      }
+    }
+  }
+
+  template <
+      typename DstPtrType,
+      typename StrX,
+      typename StrY,
+      typename StartX,
+      typename StopX,
+      typename StartY,
+      typename StopY,
+      typename OffX,
+      typename OffY>
+  METAL_FUNC static constexpr void store_slice(
+      const thread frag_type& src,
+      DstPtrType dst,
+      StrX str_x,
+      StrY str_y,
+      StartX start_x,
+      StopX stop_x,
+      StartY start_y,
+      StopY stop_y,
+      OffX off_x = Int<0>{},
+      OffY off_y = Int<0>{}) {
+    using U = pointer_element_t<DstPtrType>;
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kElemRows; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kElemCols; j++) {
+        if ((off_x + i) < stop_x && (off_x + i) >= start_x &&
+            (off_y + j) < stop_y && (off_y + j) >= start_y) {
+          dst[(off_x + i) * str_x + (off_y + j) * str_y] =
+              static_cast<U>(src[i * kElemCols + j]);
+        }
+      }
+    }
+  }
+
+  METAL_FUNC static constexpr void mma(
+      thread frag_type& D,
+      thread frag_type& A,
+      thread frag_type& B,
+      thread frag_type& C) {
+    mat_type D_mat;
+    mat_type A_mat;
+    mat_type B_mat;
+    mat_type C_mat;
+
+    reinterpret_cast<thread frag_type&>(A_mat.thread_elements()) = A;
+    reinterpret_cast<thread frag_type&>(B_mat.thread_elements()) = B;
+    reinterpret_cast<thread frag_type&>(C_mat.thread_elements()) = C;
+
+    mma(D_mat, A_mat, B_mat, C_mat);
+
+    D = reinterpret_cast<thread frag_type&>(D_mat.thread_elements());
+  }
+
+  METAL_FUNC static constexpr void mma(
+      thread mat_type& D,
+      thread mat_type& A,
+      thread mat_type& B,
+      thread mat_type& C) {
+    simdgroup_multiply_accumulate(D, A, B, C);
+  }
+};
+
+template <
+    typename T,
+    int kTileRows_,
+    int kTileCols_,
+    class MMAFrag_ = BaseMMAFrag<T, 8, 8>>
+struct MMATile {
+  using MMAFrag_t = MMAFrag_;
+  using elem_type = T;
+  STEEL_CONST int kFragRows = MMAFrag_t::kFragRows;
+  STEEL_CONST int kFragCols = MMAFrag_t::kFragCols;
+  STEEL_CONST int kElemsPerFrag = MMAFrag_t::kElemsPerFrag;
+
+  STEEL_CONST int kTileRows = kTileRows_;
+  STEEL_CONST int kTileCols = kTileCols_;
+
+  STEEL_CONST int kRows = kTileRows * kFragRows;
+  STEEL_CONST int kCols = kTileCols * kFragCols;
+
+  STEEL_CONST int kNumFrags = kTileRows * kTileCols;
+  STEEL_CONST int kElemsPerTile = kNumFrags * kElemsPerFrag;
+
+  typedef typename MMAFrag_t::mat_type mat_type;
+  typedef typename MMAFrag_t::frag_type frag_type;
+
+  frag_type val_frags[kNumFrags] = {frag_type(0)};
+
+  METAL_FUNC MMATile() thread {}
+
+  METAL_FUNC constexpr void clear() {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kNumFrags; ++i) {
+      val_frags[i] = frag_type(0);
+    }
+  }
+
+  METAL_FUNC constexpr thread frag_type& frag_at(const short i, const short j) {
+    return val_frags[i * kTileCols + j];
+  }
+
+  METAL_FUNC constexpr const thread frag_type& frag_at(
+      const short i,
+      const short j) const {
+    return val_frags[i * kTileCols + j];
+  }
+
+  METAL_FUNC mat_type mat_at(const short i, const short j) {
+    mat_type val_mat;
+    STEEL_PRAGMA_UNROLL
+    for (short ii = 0; ii < kElemsPerFrag; ++ii) {
+      val_mat.thread_elements()[ii] = frag_at(i, j)[ii];
+    }
+    return val_mat;
+  }
+
+  METAL_FUNC thread elem_type* elems() {
+    return reinterpret_cast<thread elem_type*>(val_frags);
+  }
+
+  METAL_FUNC const thread elem_type* elems() const {
+    return reinterpret_cast<const thread elem_type*>(val_frags);
+  }
+
+  template <typename U, int w_x, int w_y, int str_x, int str_y>
+  METAL_FUNC void load(const threadgroup U* src) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::load(
+            frag_at(i, j),
+            &(
+                src[(i * kFragRows) * w_x * str_x +
+                    (j * kFragCols) * w_y * str_y]),
+            Int<str_x>{},
+            Int<str_y>{});
+      }
+    }
+  }
+
+  template <typename U, int w_x, int w_y, int str_x, int str_y>
+  METAL_FUNC void store(threadgroup U* dst) const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::store(
+            frag_at(i, j),
+            &(
+                dst[(i * kFragRows) * w_x * str_x +
+                    (j * kFragCols) * w_y * str_y]),
+            Int<str_x>{},
+            Int<str_y>{});
+      }
+    }
+  }
+
+  template <typename U, int w_x, int w_y>
+  METAL_FUNC void load(const device U* src, const int ld) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::load(
+            frag_at(i, j),
+            &(src[(i * kFragRows) * w_x * ld + (j * kFragCols) * w_y]),
+            ld,
+            Int<1>{});
+      }
+    }
+  }
+
+  template <typename U, int w_x, int w_y>
+  METAL_FUNC void store(device U* dst, const int ld) const {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::store(
+            frag_at(i, j),
+            &(dst[(i * kFragRows) * w_x * ld + (j * kFragCols) * w_y]),
+            ld,
+            Int<1>{});
+      }
+    }
+  }
+
+  template <typename U, int w_x, int w_y>
+  METAL_FUNC void
+  load_safe(const device U* src, const int ld, const short2 src_tile_dims) {
+    STEEL_PRAGMA_UNROLL
+    for (int i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (int j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::load_safe(
+            frag_at(i, j),
+            src,
+            ld,
+            Int<1>{},
+            src_tile_dims.y,
+            src_tile_dims.x,
+            (i * kFragRows) * w_x,
+            (j * kFragCols) * w_y);
+      }
+    }
+  }
+
+  template <typename U, int w_x, int w_y>
+  METAL_FUNC void
+  store_safe(device U* dst, const int ld, const short2 dst_tile_dims) const {
+    STEEL_PRAGMA_UNROLL
+    for (int i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (int j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::store_safe(
+            frag_at(i, j),
+            dst,
+            ld,
+            Int<1>{},
+            dst_tile_dims.y,
+            dst_tile_dims.x,
+            (i * kFragRows) * w_x,
+            (j * kFragCols) * w_y);
+      }
+    }
+  }
+
+  template <typename U, int w_x, int w_y>
+  METAL_FUNC void store_slice(
+      device U* dst,
+      const int ld,
+      const short2 start,
+      const short2 stop) const {
+    STEEL_PRAGMA_UNROLL
+    for (int i = 0; i < kTileRows; ++i) {
+      STEEL_PRAGMA_UNROLL
+      for (int j = 0; j < kTileCols; ++j) {
+        MMAFrag_t::store_slice(
+            frag_at(i, j),
+            dst,
+            ld,
+            Int<1>{},
+            start.y,
+            stop.y,
+            start.x,
+            stop.x,
+            (i * kFragRows) * w_x,
+            (j * kFragCols) * w_y);
+      }
+    }
+  }
+};
+
+template <typename T, typename U, int M, int N, int K>
+METAL_FUNC void tile_matmad(
+    thread MMATile<T, M, N>& D,
+    thread MMATile<U, M, K>& A,
+    thread MMATile<U, K, N>& B,
+    thread MMATile<T, M, N>& C) {
+  STEEL_PRAGMA_UNROLL
+  for (short m = 0; m < M; ++m) {
+    STEEL_PRAGMA_UNROLL
+    for (short n = 0; n < N; ++n) {
+      short n_serp = (m % 2) ? (N - 1 - n) : n;
+      STEEL_PRAGMA_UNROLL
+      for (short k = 0; k < K; ++k) {
+        MMATile<T, M, N>::MMAFrag_t::mma(
+            D.frag_at(m, n_serp),
+            A.frag_at(m, k),
+            B.frag_at(k, n_serp),
+            C.frag_at(m, n_serp));
+      }
+    }
+  }
+}
+
+template <typename InT>
+struct TransformNone<complex64_t, InT> {
+  static METAL_FUNC complex64_t apply(complex64_t x) {
+    return x;
+  }
+  static METAL_FUNC complex64_t apply(complex64_t x, complex64_t) {
+    return x;
+  }
+};
+
+template <
+    typename T,
+    typename U,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    short lda_tgp,
+    short ldb_tgp,
+    typename AccumType = float,
+    typename Epilogue = TransformNone<U, AccumType>>
+struct BlockMMA {
+  // MMAFrag size
+  STEEL_CONST short kFragSize = 8;
+  using MMAFrag_acc_t = BaseMMAFrag<AccumType, kFragSize, kFragSize>;
+
+  // Warp tile simdgroup matrix strides along M
+  STEEL_CONST short TM_stride = kFragSize * WM;
+  // Warp tile simdgroup matrix strides along M
+  STEEL_CONST short TN_stride = kFragSize * WN;
+
+  // Warp tile size along M
+  STEEL_CONST short TM = BM / (kFragSize * WM);
+  // Warp tile size along N
+  STEEL_CONST short TN = BN / (kFragSize * WN);
+
+  // Threadgroup A strides
+  STEEL_CONST short A_str_m = transpose_a ? 1 : lda_tgp; // M
+  STEEL_CONST short A_str_k = transpose_a ? lda_tgp : 1; // K
+
+  // Threadgroup B strides
+  STEEL_CONST short B_str_k = transpose_b ? 1 : ldb_tgp; // K
+  STEEL_CONST short B_str_n = transpose_b ? ldb_tgp : 1; // N
+
+  // Threadgroup strides along K
+  STEEL_CONST short tile_stride_a = kFragSize * A_str_k;
+  STEEL_CONST short tile_stride_b = kFragSize * B_str_k;
+
+  // Simdgroup matrices
+  MMATile<AccumType, TM, 1, MMAFrag_acc_t> Atile;
+  MMATile<AccumType, 1, TN, MMAFrag_acc_t> Btile;
+  MMATile<AccumType, TM, TN, MMAFrag_acc_t> Ctile;
+
+  // Offsets within threadgroup
+  short sm;
+  short sn;
+
+  short As_offset;
+  short Bs_offset;
+
+  /* Constructor */
+  METAL_FUNC BlockMMA(
+      ushort simd_group_id [[simdgroup_index_in_threadgroup]],
+      ushort simd_lane_id [[thread_index_in_simdgroup]]) {
+    // Determine thread position in simdgroup matrix
+    short tm = kFragSize * (simd_group_id / WN);
+    short tn = kFragSize * (simd_group_id % WN);
+
+    short2 simd_coord = MMAFrag_acc_t::get_coord(simd_lane_id);
+    sm = simd_coord.y;
+    sn = simd_coord.x;
+
+    // Determine thread and simdgroup offset
+    As_offset = (tm + sm) * A_str_m + (sn)*A_str_k; // M, K
+    Bs_offset = (sm)*B_str_k + (tn + sn) * B_str_n; // K, N
+
+    sm += tm;
+    sn += tn;
+  }
+
+  /* (BM, BK) X (BK, BN) multiply accumulate function */
+  METAL_FUNC void mma(const threadgroup T* As, const threadgroup T* Bs) {
+    // Adjust for simdgroup and thread location
+    As += As_offset;
+    Bs += Bs_offset;
+
+    // Iterate over BK in blocks of kFragSize
+    STEEL_PRAGMA_UNROLL
+    for (short kk = 0; kk < BK; kk += kFragSize) {
+      simdgroup_barrier(mem_flags::mem_none);
+
+      Atile.template load<T, WM, 1, A_str_m, A_str_k>(As);
+
+      simdgroup_barrier(mem_flags::mem_none);
+
+      Btile.template load<T, 1, WN, B_str_k, B_str_n>(Bs);
+
+      simdgroup_barrier(mem_flags::mem_none);
+
+      tile_matmad(Ctile, Atile, Btile, Ctile);
+
+      // Progress to next simdgroup tile
+      As += tile_stride_a;
+      Bs += tile_stride_b;
+    }
+  }
+
+  /* Store results from simdgroup_matrix results into device memory */
+  METAL_FUNC void store_result(device U* D, const int ldd) {
+    // Apply epilogue
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < decltype(Ctile)::kElemsPerTile; i++) {
+      Ctile.elems()[i] = Epilogue::apply(Ctile.elems()[i]);
+    }
+
+    // Adjust for simdgroup and thread location
+    D += sm * ldd + sn;
+
+    Ctile.template store<U, WM, WN>(D, ldd);
+  }
+
+  METAL_FUNC void
+  store_result_slice(device U* D, const int ldd, short2 start, short2 stop) {
+    // Apply epilogue
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < decltype(Ctile)::kElemsPerTile; i++) {
+      Ctile.elems()[i] = Epilogue::apply(Ctile.elems()[i]);
+    }
+
+    D += sm * ldd + sn;
+    start -= short2(sn, sm);
+    stop -= short2(sn, sm);
+
+    // TODO: Check the start as well
+    if (stop.y <= 0 || stop.x <= 0) {
+      return;
+    }
+
+    Ctile.template store_slice<U, WM, WN>(D, ldd, start, stop);
+  }
+
+  METAL_FUNC void
+  store_result_safe(device U* D, const int ldd, short2 dst_tile_dims) {
+    // Apply epilogue
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < decltype(Ctile)::kElemsPerTile; i++) {
+      Ctile.elems()[i] = Epilogue::apply(Ctile.elems()[i]);
+    }
+
+    // Adjust for simdgroup and thread location
+    D += sm * ldd + sn;
+    dst_tile_dims -= short2(sn, sm);
+
+    if (dst_tile_dims.x <= 0 || dst_tile_dims.y <= 0)
+      return;
+
+    Ctile.template store_safe<U, WM, WN>(D, ldd, dst_tile_dims);
+  }
+
+  /* Apply epilogue */
+  template <typename UnaryEpilogue>
+  METAL_FUNC void apply_epilogue(thread const UnaryEpilogue& epilogue_op) {
+    // Loop over all simdgroup tiles
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < decltype(Ctile)::kElemsPerTile; i++) {
+      Ctile.elems()[i] = epilogue_op.apply(Ctile.elems()[i]);
+    }
+  }
+
+  /* Apply epilogue */
+  template <typename BinaryEpilogue>
+  METAL_FUNC void apply_epilogue(
+      const device U* C,
+      const int ldc,
+      const int fdc,
+      thread const BinaryEpilogue& epilogue_op) {
+    // Adjust for simdgroup and thread location
+    C += (sm)*ldc + (sn)*fdc;
+
+    // Loop over all simdgroup tiles
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < TM; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < TN; j++) {
+        // Get accumulated result and associated offset in C
+        thread auto& accum = Ctile.frag_at(i, j);
+        int offset_c = (i * TM_stride) * ldc + (j * TN_stride) * fdc;
+
+        // Apply epilogue
+        STEEL_PRAGMA_UNROLL
+        for (short k = 0; k < decltype(Ctile)::kElemsPerFrag; k++) {
+          accum[k] = epilogue_op.apply(accum[k], C[offset_c + k * fdc]);
+        }
+      }
+    }
+  }
+
+  /* Apply epilogue */
+  template <typename BinaryEpilogue>
+  METAL_FUNC void apply_epilogue_safe(
+      const device U* C,
+      const int ldc,
+      const int fdc,
+      short2 dst_tile_dims,
+      thread const BinaryEpilogue& epilogue_op) {
+    // Adjust for simdgroup and thread location
+    C += (sm)*ldc + (sn)*fdc;
+    dst_tile_dims -= short2(sn, sm);
+
+    if (dst_tile_dims.x <= 0 || dst_tile_dims.y <= 0)
+      return;
+
+    // Loop over all simdgroup tiles
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < TM; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < TN; j++) {
+        // Get accumulated result and associated offset in C
+        thread auto& accum = Ctile.frag_at(i, j);
+        int offset_c = (i * TM_stride) * ldc + (j * TN_stride) * fdc;
+
+        constexpr short kelems = decltype(Ctile)::kElemsPerFrag;
+
+        // Read C
+        U c_elems[kelems] = {0};
+
+        STEEL_PRAGMA_UNROLL
+        for (short k = 0; k < kelems; k++) {
+          if ((j * TN_stride + k) < dst_tile_dims.x) {
+            c_elems[k] = C[offset_c + k * fdc];
+          }
+        }
+
+        // Apply epilogue
+        STEEL_PRAGMA_UNROLL
+        for (short k = 0; k < kelems; k++) {
+          accum[k] = epilogue_op.apply(accum[k], c_elems[k]);
+        }
+      }
+    }
+  }
+
+  /* Store results from simdgroup_matrix results into device memory */
+  METAL_FUNC void store_result(
+      device U* D,
+      const int ldd,
+      const device U* C,
+      const int ldc,
+      const int fdc,
+      thread const Epilogue& epilogue_op) const {
+    // Adjust for simdgroup and thread location
+    C += (sm)*ldc + (sn)*fdc;
+    D += (sm)*ldd + sn;
+
+    constexpr short kelems = decltype(Ctile)::kElemsPerFrag;
+
+    // Loop over all simdgroup tiles
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < TM; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < TN; j++) {
+        // Get accumulated result and associated offset in C
+        thread const auto& accum = Ctile.frag_at(i, j);
+        int offset_c = (i * TM_stride) * ldc + (j * TN_stride) * fdc;
+        int offset_d = (i * TM_stride) * ldd + (j * TN_stride);
+
+        // Apply epilogue
+        STEEL_PRAGMA_UNROLL
+        for (short k = 0; k < kelems; k++) {
+          D[offset_d + k] = epilogue_op.apply(accum[k], C[offset_c + k * fdc]);
+        }
+      }
+    }
+  }
+
+  METAL_FUNC void store_result_safe(
+      device U* D,
+      const int ldd,
+      const device U* C,
+      const int ldc,
+      const int fdc,
+      short2 dst_tile_dims,
+      thread const Epilogue& epilogue_op) const {
+    // Adjust for simdgroup and thread location
+    C += (sm)*ldc + (sn)*fdc;
+    D += (sm)*ldd + sn;
+    dst_tile_dims -= short2(sn, sm);
+
+    if (dst_tile_dims.x <= 0 || dst_tile_dims.y <= 0)
+      return;
+
+    constexpr short kelems = decltype(Ctile)::kElemsPerFrag;
+
+    STEEL_PRAGMA_UNROLL
+    for (int i = 0; i < TM; i++) {
+      if (i * TM_stride < dst_tile_dims.y) {
+        STEEL_PRAGMA_UNROLL
+        for (int j = 0; j < TN; j++) {
+          // Get accumulated result and associated offset in C
+          thread const auto& accum = Ctile.frag_at(i, j);
+          int offset_c = (i * TM_stride) * ldc + (j * TN_stride) * fdc;
+          int offset_d = (i * TM_stride) * ldd + (j * TN_stride);
+
+          // Apply epilogue
+          STEEL_PRAGMA_UNROLL
+          for (short k = 0; k < kelems; k++) {
+            if ((j * TN_stride + k) < dst_tile_dims.x) {
+              D[offset_d + k] =
+                  epilogue_op.apply(accum[k], C[offset_c + k * fdc]);
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+template <
+    typename U,
+    int BM,
+    int BN,
+    int BK,
+    int WM,
+    int WN,
+    bool transpose_a,
+    bool transpose_b,
+    short lda_tgp,
+    short ldb_tgp,
+    typename AccumType,
+    typename Epilogue>
+struct BlockMMA<
+    complex64_t,
+    U,
+    BM,
+    BN,
+    BK,
+    WM,
+    WN,
+    transpose_a,
+    transpose_b,
+    lda_tgp,
+    ldb_tgp,
+    AccumType,
+    Epilogue> {
+  static_assert(
+      metal::is_same_v<AccumType, float>,
+      "BlockMMA<complex64_t,...> expects float accumulators");
+  static_assert(
+      metal::is_same_v<U, complex64_t>,
+      "For complex BlockMMA, U must be complex64_t; use a different epilogue for projections");
+  // MMAFrag size
+  STEEL_CONST short kFragSize = 8;
+  using MMAFrag_acc_t = BaseMMAFrag<AccumType, kFragSize, kFragSize>;
+
+  // Warp tile simdgroup matrix strides along M
+  STEEL_CONST short TM_stride = kFragSize * WM;
+  // Warp tile simdgroup matrix strides along M
+  STEEL_CONST short TN_stride = kFragSize * WN;
+
+  // Warp tile size along M
+  STEEL_CONST short TM = BM / (kFragSize * WM);
+  // Warp tile size along N
+  STEEL_CONST short TN = BN / (kFragSize * WN);
+
+  // Threadgroup A strides
+  STEEL_CONST short A_str_m = transpose_a ? 1 : lda_tgp; // M
+  STEEL_CONST short A_str_k = transpose_a ? lda_tgp : 1; // K
+
+  // Threadgroup B strides
+  STEEL_CONST short B_str_k = transpose_b ? 1 : ldb_tgp; // K
+  STEEL_CONST short B_str_n = transpose_b ? ldb_tgp : 1; // N
+
+  // Threadgroup strides along K
+  STEEL_CONST short tile_stride_a = kFragSize * A_str_k;
+  STEEL_CONST short tile_stride_b = kFragSize * B_str_k;
+
+  // When indexing complex as float[2]
+  STEEL_CONST short A_str_m_f = A_str_m * 2;
+  STEEL_CONST short A_str_k_f = A_str_k * 2;
+  STEEL_CONST short B_str_k_f = B_str_k * 2;
+  STEEL_CONST short B_str_n_f = B_str_n * 2;
+  STEEL_CONST short tile_stride_a_f = tile_stride_a * 2;
+  STEEL_CONST short tile_stride_b_f = tile_stride_b * 2;
+
+  // Accumulators (real/imag)
+  MMATile<AccumType, TM, TN, MMAFrag_acc_t> Ctile_r;
+  MMATile<AccumType, TM, TN, MMAFrag_acc_t> Ctile_i;
+
+  // Offsets within threadgroup
+  short sm, sn;
+  short As_offset, Bs_offset;
+
+  /* Constructor */
+  METAL_FUNC BlockMMA(
+      ushort simd_group_id [[simdgroup_index_in_threadgroup]],
+      ushort simd_lane_id [[thread_index_in_simdgroup]]) {
+    // Determine thread position in simdgroup matrix
+    short tm = kFragSize * (simd_group_id / WN);
+    short tn = kFragSize * (simd_group_id % WN);
+
+    short2 simd_coord = MMAFrag_acc_t::get_coord(simd_lane_id);
+    sm = simd_coord.y;
+    sn = simd_coord.x;
+
+    // Determine thread and simdgroup offset
+    As_offset = (tm + sm) * A_str_m + (sn)*A_str_k; // (M,K)
+    Bs_offset = (sm)*B_str_k + (tn + sn) * B_str_n; // (K,N)
+
+    sm += tm;
+    sn += tn;
+  }
+
+  /* Karatsuba MMA: 3 real MMAs per K-chunk */
+  METAL_FUNC void mma(
+      const threadgroup complex64_t* As,
+      const threadgroup complex64_t* Bs) {
+    // Adjust for simdgroup and thread location
+    As += As_offset;
+    Bs += Bs_offset;
+    threadgroup const float* As_f =
+        reinterpret_cast<threadgroup const float*>(As);
+    threadgroup const float* Bs_f =
+        reinterpret_cast<threadgroup const float*>(Bs);
+
+    // Iterate over BK in blocks of kFragSize
+    STEEL_PRAGMA_UNROLL
+    for (short kk = 0; kk < BK; kk += kFragSize) {
+      simdgroup_barrier(mem_flags::mem_none);
+
+      MMATile<AccumType, TM, 1, MMAFrag_acc_t> Ar, Ai;
+      Ar.template load<float, WM, 1, A_str_m_f, A_str_k_f>(As_f + 0);
+      Ai.template load<float, WM, 1, A_str_m_f, A_str_k_f>(As_f + 1);
+
+      simdgroup_barrier(mem_flags::mem_none);
+
+      MMATile<AccumType, 1, TN, MMAFrag_acc_t> Br, Bi;
+      Br.template load<float, 1, WN, B_str_k_f, B_str_n_f>(Bs_f + 0);
+      Bi.template load<float, 1, WN, B_str_k_f, B_str_n_f>(Bs_f + 1);
+
+      simdgroup_barrier(mem_flags::mem_none);
+
+      // P = Ar*Br ; Q = Ai*Bi ; R = (Ar+Ai)*(Br+Bi)
+      MMATile<AccumType, TM, TN, MMAFrag_acc_t> P, Q, R;
+
+      tile_matmad(P, Ar, Br, P);
+      tile_matmad(Q, Ai, Bi, Q);
+
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < decltype(Ar)::kElemsPerTile; ++i)
+        Ar.elems()[i] += Ai.elems()[i];
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < decltype(Br)::kElemsPerTile; ++i)
+        Br.elems()[i] += Bi.elems()[i];
+
+      tile_matmad(R, Ar, Br, R);
+
+      // C_r += P - Q ; C_i -= Q
+      STEEL_PRAGMA_UNROLL
+      for (short i = 0; i < decltype(Ctile_r)::kElemsPerTile; ++i) {
+        const auto p = P.elems()[i];
+        const auto q = Q.elems()[i];
+        const auto r = R.elems()[i];
+        Ctile_r.elems()[i] += (p - q);
+        Ctile_i.elems()[i] += (r - p - q);
+      }
+
+      // Progress to next simdgroup tile
+      As_f += tile_stride_a_f;
+      Bs_f += tile_stride_b_f;
+    }
+  }
+
+  /* Store results from simdgroup_matrix results into device memory */
+  METAL_FUNC void store_result(device U* D, const int ldd) {
+    // Adjust for simdgroup and thread location
+    D += sm * ldd + sn;
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < TM; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < TN; j++) {
+        thread const auto& r = Ctile_r.frag_at(i, j);
+        thread const auto& im = Ctile_i.frag_at(i, j);
+        int off = (i * TM_stride) * ldd + (j * TN_stride);
+        STEEL_PRAGMA_UNROLL
+        for (short k = 0; k < decltype(Ctile_r)::kElemsPerFrag; k++) {
+          D[off + k] = Epilogue::apply(complex64_t(r[k], im[k]));
+        }
+      }
+    }
+  }
+
+  METAL_FUNC void
+  store_result_slice(device U* D, const int ldd, short2 start, short2 stop) {
+    D += sm * ldd + sn;
+    start -= short2(sn, sm);
+    stop -= short2(sn, sm);
+
+    if (stop.y <= 0 || stop.x <= 0)
+      return;
+
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < TM; ++i) {
+      const int row = i * TM_stride;
+      if (row >= start.y && row < stop.y) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < TN; ++j) {
+          const int off = row * ldd + (j * TN_stride);
+          thread const auto& r = Ctile_r.frag_at(i, j);
+          thread const auto& im = Ctile_i.frag_at(i, j);
+
+          STEEL_PRAGMA_UNROLL
+          for (short k = 0; k < decltype(Ctile_r)::kElemsPerFrag; ++k) {
+            const int col = j * TN_stride + k;
+            if (col >= start.x && col < stop.x) {
+              D[off + k] = Epilogue::apply(complex64_t(r[k], im[k]));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  METAL_FUNC void
+  store_result_safe(device U* D, const int ldd, short2 dst_tile_dims) {
+    D += sm * ldd + sn;
+    dst_tile_dims -= short2(sn, sm);
+    if (dst_tile_dims.x <= 0 || dst_tile_dims.y <= 0)
+      return;
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < TM; i++) {
+      if (i * TM_stride < dst_tile_dims.y) {
+        STEEL_PRAGMA_UNROLL
+        for (short j = 0; j < TN; j++) {
+          int off = (i * TM_stride) * ldd + (j * TN_stride);
+          thread const auto& r = Ctile_r.frag_at(i, j);
+          thread const auto& im = Ctile_i.frag_at(i, j);
+          STEEL_PRAGMA_UNROLL
+          for (short k = 0; k < decltype(Ctile_r)::kElemsPerFrag; k++) {
+            if ((j * TN_stride + k) < dst_tile_dims.x) {
+              D[off + k] = Epilogue::apply(complex64_t(r[k], im[k]));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /* Apply epilogue */
+  template <typename UnaryEpilogue>
+  METAL_FUNC void apply_epilogue(thread const UnaryEpilogue& epilogue_op) {
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < decltype(Ctile_r)::kElemsPerTile; i++) {
+      complex64_t out = epilogue_op.apply(
+          complex64_t(Ctile_r.elems()[i], Ctile_i.elems()[i]));
+      Ctile_r.elems()[i] = out.real;
+      Ctile_i.elems()[i] = out.imag;
+    }
+  }
+
+  /* Apply epilogue */
+  template <typename BinaryEpilogue>
+  METAL_FUNC void apply_epilogue(
+      const device U* C,
+      const int ldc,
+      const int fdc,
+      thread const BinaryEpilogue& epilogue_op) {
+    // Adjust for simdgroup and thread location
+    C += (sm)*ldc + (sn)*fdc;
+
+    // Loop over all simdgroup tiles
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < TM; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < TN; j++) {
+        // Get accumulated result and associated offset in Cr, Ci
+        thread auto& r = Ctile_r.frag_at(i, j);
+        thread auto& im = Ctile_i.frag_at(i, j);
+        int offset_c = (i * TM_stride) * ldc + (j * TN_stride) * fdc;
+
+        STEEL_PRAGMA_UNROLL
+        for (short k = 0; k < decltype(Ctile_r)::kElemsPerFrag; k++) {
+          complex64_t out = epilogue_op.apply(
+              complex64_t(r[k], im[k]), C[offset_c + k * fdc]);
+          r[k] = out.real;
+          im[k] = out.imag;
+        }
+      }
+    }
+  }
+
+  /* Apply epilogue */
+  template <typename BinaryEpilogue>
+  METAL_FUNC void apply_epilogue_safe(
+      const device U* C,
+      const int ldc,
+      const int fdc,
+      short2 dst_tile_dims,
+      thread const BinaryEpilogue& epilogue_op) {
+    // Adjust for simdgroup and thread location
+    C += (sm)*ldc + (sn)*fdc;
+    dst_tile_dims -= short2(sn, sm);
+
+    if (dst_tile_dims.x <= 0 || dst_tile_dims.y <= 0)
+      return;
+
+    // Loop over all simdgroup tiles
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < TM; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < TN; j++) {
+        // Get accumulated result and associated offset in Cr, Ci
+        thread auto& r = Ctile_r.frag_at(i, j);
+        thread auto& im = Ctile_i.frag_at(i, j);
+        int offset_c = (i * TM_stride) * ldc + (j * TN_stride) * fdc;
+
+        constexpr short kelems = decltype(Ctile_r)::kElemsPerFrag;
+        complex64_t tmp[kelems];
+
+        STEEL_PRAGMA_UNROLL
+        for (short k = 0; k < kelems; k++) {
+          if ((j * TN_stride + k) < dst_tile_dims.x &&
+              (i * TM_stride) < dst_tile_dims.y) {
+            tmp[k] = C[offset_c + k * fdc];
+          } else {
+            tmp[k] = complex64_t(0.0f, 0.0f);
+          }
+        }
+
+        // Apply epilogue
+        STEEL_PRAGMA_UNROLL
+        for (short k = 0; k < kelems; k++) {
+          complex64_t out = epilogue_op.apply(complex64_t(r[k], im[k]), tmp[k]);
+          r[k] = out.real;
+          im[k] = out.imag;
+        }
+      }
+    }
+  }
+
+  /* Store results from simdgroup_matrix results into device memory */
+  METAL_FUNC void store_result(
+      device U* D,
+      const int ldd,
+      const device U* C,
+      const int ldc,
+      const int fdc,
+      thread const Epilogue& epilogue_op) const {
+    // Adjust for simdgroup and thread location
+    C += (sm)*ldc + (sn)*fdc;
+    D += (sm)*ldd + sn;
+
+    constexpr short kelems = decltype(Ctile_r)::kElemsPerFrag;
+
+    // Loop over all simdgroup tiles
+    STEEL_PRAGMA_UNROLL
+    for (short i = 0; i < TM; i++) {
+      STEEL_PRAGMA_UNROLL
+      for (short j = 0; j < TN; j++) {
+        // Get accumulated result and associated offset in Cr, Ci
+        thread const auto& r = Ctile_r.frag_at(i, j);
+        thread const auto& im = Ctile_i.frag_at(i, j);
+        int off_c = (i * TM_stride) * ldc + (j * TN_stride) * fdc;
+        int off_d = (i * TM_stride) * ldd + (j * TN_stride);
+
+        // Apply epilogue
+        STEEL_PRAGMA_UNROLL
+        for (short k = 0; k < kelems; k++) {
+          D[off_d + k] =
+              epilogue_op.apply(complex64_t(r[k], im[k]), C[off_c + k * fdc]);
+        }
+      }
+    }
+  }
+
+  METAL_FUNC void store_result_safe(
+      device U* D,
+      const int ldd,
+      const device U* C,
+      const int ldc,
+      const int fdc,
+      short2 dst_tile_dims,
+      thread const Epilogue& epilogue_op) const {
+    // Adjust for simdgroup and thread location
+    C += (sm)*ldc + (sn)*fdc;
+    D += (sm)*ldd + sn;
+    dst_tile_dims -= short2(sn, sm);
+
+    if (dst_tile_dims.x <= 0 || dst_tile_dims.y <= 0)
+      return;
+
+    constexpr short kelems = decltype(Ctile_r)::kElemsPerFrag;
+
+    STEEL_PRAGMA_UNROLL
+    for (int i = 0; i < TM; i++) {
+      if (i * TM_stride < dst_tile_dims.y) {
+        STEEL_PRAGMA_UNROLL
+        for (int j = 0; j < TN; j++) {
+          // Get accumulated result and associated offset in Cr, Ci
+          thread const auto& r = Ctile_r.frag_at(i, j);
+          thread const auto& im = Ctile_i.frag_at(i, j);
+          int off_c = (i * TM_stride) * ldc + (j * TN_stride) * fdc;
+          int off_d = (i * TM_stride) * ldd + (j * TN_stride);
+
+          // Apply epilogue
+          STEEL_PRAGMA_UNROLL
+          for (short k = 0; k < kelems; k++) {
+            if ((j * TN_stride + k) < dst_tile_dims.x) {
+              D[off_d + k] = epilogue_op.apply(
+                  complex64_t(r[k], im[k]), C[off_c + k * fdc]);
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+} // namespace steel
+} // namespace mlx
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/params.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/params.h
new file mode 100644
index 0000000000000000000000000000000000000000..3cb7bdc30fb9ce79103af7c31787cc1fe7f3a673
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/params.h
@@ -0,0 +1,64 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+///////////////////////////////////////////////////////////////////////////////
+// GEMM param classes
+///////////////////////////////////////////////////////////////////////////////
+
+namespace mlx {
+namespace steel {
+
+struct GEMMParams {
+  const int M;
+  const int N;
+  const int K;
+
+  const int lda;
+  const int ldb;
+  const int ldd;
+
+  const int tiles_n;
+  const int tiles_m;
+
+  const int64_t batch_stride_a;
+  const int64_t batch_stride_b;
+  const int64_t batch_stride_d;
+
+  const int swizzle_log;
+  const int gemm_k_iterations_aligned;
+
+  const int batch_ndim;
+};
+
+struct GEMMSpiltKParams {
+  const int M;
+  const int N;
+  const int K;
+
+  const int lda;
+  const int ldb;
+  const int ldc;
+
+  const int tiles_n;
+  const int tiles_m;
+
+  const int split_k_partitions;
+  const int split_k_partition_stride;
+  const int split_k_partition_size;
+
+  const int gemm_k_iterations_aligned;
+};
+
+struct GEMMAddMMParams {
+  const int ldc;
+  const int fdc;
+
+  const int64_t batch_stride_c;
+
+  const float alpha;
+  const float beta;
+};
+
+} // namespace steel
+} // namespace mlx
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/transforms.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/transforms.h
new file mode 100644
index 0000000000000000000000000000000000000000..0282a1223fecaac848695dbad604e808b496c5d8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/gemm/transforms.h
@@ -0,0 +1,72 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/kernels/steel/utils.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Transforms and Epilogues
+///////////////////////////////////////////////////////////////////////////////
+
+namespace mlx {
+namespace steel {
+
+template <typename OutT, typename InT>
+struct TransformNone {
+  static METAL_FUNC OutT apply(InT x) {
+    return static_cast<OutT>(x);
+  }
+
+  static METAL_FUNC OutT apply(InT x, OutT) {
+    return static_cast<OutT>(x);
+  }
+};
+
+template <typename OutT, typename InT>
+struct TransformAdd {
+  TransformAdd(const float, const float) {}
+
+  static METAL_FUNC OutT apply(InT x) {
+    return static_cast<OutT>(x);
+  }
+
+  static METAL_FUNC OutT apply(InT x, OutT c) {
+    return static_cast<OutT>(x) + c;
+  }
+};
+
+template <typename OutT, typename InT>
+struct TransformAxpby {
+  const float alpha;
+  const float beta;
+
+  TransformAxpby(const float alpha_, const float beta_)
+      : alpha(alpha_), beta(beta_) {}
+
+  static METAL_FUNC OutT apply(InT x) {
+    return static_cast<OutT>(x);
+  }
+
+  METAL_FUNC OutT apply(InT x, OutT c) const {
+    return static_cast<OutT>(
+        x * static_cast<InT>(alpha) + (static_cast<OutT>(beta) * c));
+  }
+};
+
+template <typename T>
+struct AccumHelper {
+  typedef float accum_type;
+};
+
+struct BlockSwizzle {
+  static METAL_FUNC int2
+  swizzle(uint3 tid [[threadgroup_position_in_grid]], const int swizzle_log) {
+    const int tid_x = (tid.x) >> swizzle_log;
+    const int tid_y =
+        ((tid.y) << swizzle_log) + ((tid.x) & ((1 << swizzle_log) - 1));
+    return int2(tid_x, tid_y);
+  }
+};
+
+} // namespace steel
+} // namespace mlx
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/utils.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..55720a28fb7448b3868fb321ad686f40d9b4d780
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/utils.h
@@ -0,0 +1,42 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include <metal_stdlib>
+
+METAL_FUNC ulong2 elem_to_loc_broadcast(
+    uint elem,
+    constant const int* shape,
+    constant const int64_t* a_strides,
+    constant const int64_t* b_strides,
+    int ndim) {
+  ulong loc_a{0};
+  ulong loc_b{0};
+  for (int i = ndim - 1; i >= 0 && elem > 0; --i) {
+    int pos_in_dim = (elem % shape[i]);
+    elem /= shape[i];
+    loc_a += pos_in_dim * a_strides[i];
+    loc_b += pos_in_dim * b_strides[i];
+  }
+  return ulong2(loc_a, loc_b);
+}
+
+METAL_FUNC ulong3 elem_to_loc_broadcast(
+    uint elem,
+    constant const int* shape,
+    constant const int64_t* a_strides,
+    constant const int64_t* b_strides,
+    constant const int64_t* c_strides,
+    int ndim) {
+  ulong loc_a{0};
+  ulong loc_b{0};
+  ulong loc_c{0};
+  for (int i = ndim - 1; i >= 0 && elem > 0; --i) {
+    int pos_in_dim = (elem % shape[i]);
+    elem /= shape[i];
+    loc_a += pos_in_dim * a_strides[i];
+    loc_b += pos_in_dim * b_strides[i];
+    loc_c += pos_in_dim * c_strides[i];
+  }
+  return ulong3(loc_a, loc_b, loc_c);
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/utils/integral_constant.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/utils/integral_constant.h
new file mode 100644
index 0000000000000000000000000000000000000000..b616acc67618c361ace47cea894ed9322ad0ca1c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/utils/integral_constant.h
@@ -0,0 +1,96 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include <metal_stdlib>
+#include "mlx/backend/metal/kernels/steel/utils/type_traits.h"
+
+#pragma METAL internals : enable
+
+namespace mlx {
+namespace steel {
+
+///////////////////////////////////////////////////////////////////////////////
+// Integral constant with casting
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T, T v>
+struct integral_constant {
+  static constexpr constant T value = v;
+  using value_type = T;
+  using type = integral_constant;
+
+  METAL_FUNC constexpr operator value_type() const noexcept {
+    return value;
+  }
+
+  // METAL_FUNC constexpr value_type operator()() const noexcept {
+  //   return value;
+  // }
+};
+
+template <bool B>
+using bool_constant = integral_constant<bool, B>;
+using true_type = bool_constant<true>;
+using false_type = bool_constant<false>;
+
+template <class T>
+struct is_integral : bool_constant<metal::is_integral<T>::value> {};
+
+template <class T, T v>
+struct is_integral<integral_constant<T, v>>
+    : bool_constant<metal::is_integral<T>::value> {};
+
+template <typename T>
+constexpr constant bool is_integral_v = is_integral<T>::value;
+
+template <int val>
+using Int = integral_constant<int, val>;
+
+///////////////////////////////////////////////////////////////////////////////
+// Binary Operators on Integral constants
+///////////////////////////////////////////////////////////////////////////////
+
+#define integral_const_binop(__op__, __operator__)          \
+  template <typename T, T tv, typename U, U uv>             \
+  METAL_FUNC constexpr auto __operator__(                   \
+      integral_constant<T, tv>, integral_constant<U, uv>) { \
+    constexpr auto res = tv __op__ uv;                      \
+    return integral_constant<decltype(res), res>{};         \
+  }
+
+integral_const_binop(+, operator+);
+integral_const_binop(-, operator-);
+integral_const_binop(*, operator*);
+integral_const_binop(/, operator/);
+
+integral_const_binop(==, operator==);
+integral_const_binop(!=, operator!=);
+integral_const_binop(<, operator<);
+integral_const_binop(>, operator>);
+integral_const_binop(<=, operator<=);
+integral_const_binop(>=, operator>=);
+
+integral_const_binop(&&, operator&&);
+integral_const_binop(||, operator||);
+
+#undef integral_const_binop
+
+///////////////////////////////////////////////////////////////////////////////
+// Reduction operators
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+METAL_FUNC constexpr T sum(T x) {
+  return x;
+}
+
+template <typename T, typename... Us>
+METAL_FUNC constexpr auto sum(T x, Us... us) {
+  return x + sum(us...);
+}
+
+} // namespace steel
+} // namespace mlx
+
+#pragma METAL internals : disable
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/utils/type_traits.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/utils/type_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..f004dc836a687bcd95a813bbc105768c71957f56
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/steel/utils/type_traits.h
@@ -0,0 +1,55 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include <metal_stdlib>
+
+#pragma METAL internals : enable
+
+namespace metal {
+
+template <typename T>
+struct is_empty : metal::bool_constant<__is_empty(T)> {};
+
+#ifdef __cpp_variable_templates
+template <typename T>
+constexpr constant bool is_empty_v = is_empty<T>::value;
+#endif
+
+template <typename... Ts>
+struct make_void {
+  typedef void type;
+};
+
+template <typename... Ts>
+using void_t = typename make_void<Ts...>::type;
+
+template <class T>
+struct is_static : metal::bool_constant<is_empty<remove_cv_t<T>>::value> {};
+
+template <typename T>
+struct pointer_element {};
+
+template <typename T>
+struct pointer_element<thread T*> {
+  using type = remove_cv_t<T>;
+};
+template <typename T>
+struct pointer_element<device T*> {
+  using type = remove_cv_t<T>;
+};
+template <typename T>
+struct pointer_element<constant T*> {
+  using type = remove_cv_t<T>;
+};
+template <typename T>
+struct pointer_element<threadgroup T*> {
+  using type = remove_cv_t<T>;
+};
+
+template <typename T>
+using pointer_element_t = typename pointer_element<remove_cv_t<T>>::type;
+
+} // namespace metal
+
+#pragma METAL internals : disable
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/ternary.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/ternary.h
new file mode 100644
index 0000000000000000000000000000000000000000..705b73e25db55143861e8a7b21b1075ad2ec9ef5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/ternary.h
@@ -0,0 +1,145 @@
+// Copyright © 2024 Apple Inc.
+
+template <
+    typename T,
+    typename Op,
+    bool BSCALAR,
+    bool CSCALAR,
+    int N = WorkPerThread<T>::n>
+[[kernel]] void ternary_v(
+    device const bool* a,
+    device const T* b,
+    device const T* c,
+    device T* d,
+    constant uint& size,
+    uint index [[thread_position_in_grid]]) {
+  index *= N;
+  if (N > 1 && index + N > size) {
+    for (int i = 0; index + i < size; ++i) {
+      auto bidx = BSCALAR ? 0 : index + i;
+      auto cidx = CSCALAR ? 0 : index + i;
+      d[index + i] = Op()(a[index + i], b[bidx], c[cidx]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      auto bidx = BSCALAR ? 0 : index + i;
+      auto cidx = CSCALAR ? 0 : index + i;
+      d[index + i] = Op()(a[index + i], b[bidx], c[cidx]);
+    }
+  }
+}
+
+template <
+    typename T,
+    typename Op,
+    bool BSCALAR,
+    bool CSCALAR,
+    int N = WorkPerThread<T>::n>
+[[kernel]] void ternary_v2(
+    device const bool* a,
+    device const T* b,
+    device const T* c,
+    device T* d,
+    constant int64_t& size,
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  int64_t offset = N * (index.x + grid_dim.x * int64_t(index.y));
+  if (N > 1 && offset + N > size) {
+    for (int i = 0; offset + i < size; ++i) {
+      auto bidx = BSCALAR ? 0 : offset + i;
+      auto cidx = CSCALAR ? 0 : offset + i;
+      d[offset + i] = Op()(a[offset + i], b[bidx], c[cidx]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      auto bidx = BSCALAR ? 0 : offset + i;
+      auto cidx = CSCALAR ? 0 : offset + i;
+      d[offset + i] = Op()(a[offset + i], b[bidx], c[cidx]);
+    }
+  }
+}
+
+template <typename T, typename Op, typename IdxT = int64_t>
+[[kernel]] void ternary_g_nd1(
+    device const bool* a,
+    device const T* b,
+    device const T* c,
+    device T* d,
+    constant const int64_t& a_strides,
+    constant const int64_t& b_strides,
+    constant const int64_t& c_strides,
+    uint index [[thread_position_in_grid]]) {
+  auto a_idx = elem_to_loc_1<IdxT>(index, a_strides);
+  auto b_idx = elem_to_loc_1<IdxT>(index, b_strides);
+  auto c_idx = elem_to_loc_1<IdxT>(index, c_strides);
+  d[index] = Op()(a[a_idx], b[b_idx], c[c_idx]);
+}
+
+template <typename T, typename Op, typename IdxT = int64_t>
+[[kernel]] void ternary_g_nd2(
+    device const bool* a,
+    device const T* b,
+    device const T* c,
+    device T* d,
+    constant const int64_t a_strides[2],
+    constant const int64_t b_strides[2],
+    constant const int64_t c_strides[2],
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  auto a_idx = elem_to_loc_2<IdxT>(index, a_strides);
+  auto b_idx = elem_to_loc_2<IdxT>(index, b_strides);
+  auto c_idx = elem_to_loc_2<IdxT>(index, c_strides);
+  IdxT out_idx = index.x + IdxT(grid_dim.x) * index.y;
+  d[out_idx] = Op()(a[a_idx], b[b_idx], c[c_idx]);
+}
+
+template <typename T, typename Op, typename IdxT = int64_t>
+[[kernel]] void ternary_g_nd3(
+    device const bool* a,
+    device const T* b,
+    device const T* c,
+    device T* d,
+    constant const int64_t a_strides[3],
+    constant const int64_t b_strides[3],
+    constant const int64_t c_strides[3],
+    uint3 index [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {
+  auto a_idx = elem_to_loc_3<IdxT>(index, a_strides);
+  auto b_idx = elem_to_loc_3<IdxT>(index, b_strides);
+  auto c_idx = elem_to_loc_3<IdxT>(index, c_strides);
+  IdxT out_idx = index.x + grid_dim.x * (index.y + IdxT(grid_dim.y) * index.z);
+  d[out_idx] = Op()(a[a_idx], b[b_idx], c[c_idx]);
+}
+
+template <typename T, typename Op, int N = 1, typename IdxT = int64_t>
+[[kernel]] void ternary_g(
+    device const bool* a,
+    device const T* b,
+    device const T* c,
+    device T* d,
+    constant const int* shape,
+    constant const int64_t* a_strides,
+    constant const int64_t* b_strides,
+    constant const int64_t* c_strides,
+    constant const int& ndim,
+    uint3 index [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {
+  auto idx = elem_to_loc_3_nd<IdxT>(
+      {N * index.x, index.y, index.z},
+      shape,
+      a_strides,
+      b_strides,
+      c_strides,
+      ndim);
+  auto xshape = shape[ndim - 1];
+  IdxT out_idx = N * index.x + xshape * (index.y + IdxT(grid_dim.y) * index.z);
+  IdxT a_xstride = a_strides[ndim - 1];
+  IdxT b_xstride = b_strides[ndim - 1];
+  IdxT c_xstride = c_strides[ndim - 1];
+  for (int i = 0; i < N && (int(N * index.x) + i) < xshape; ++i) {
+    d[out_idx++] = Op()(a[idx.x], b[idx.y], c[idx.z]);
+    idx.x += a_xstride;
+    idx.y += b_xstride;
+    idx.z += c_xstride;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/ternary.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/ternary.metal
new file mode 100644
index 0000000000000000000000000000000000000000..ac1cd4160d3f89e4f6774d92bf83bfc0c014bfab
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/ternary.metal
@@ -0,0 +1,48 @@
+// Copyright © 2024 Apple Inc.
+
+#include <metal_integer>
+#include <metal_math>
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/ternary_ops.h"
+#include "mlx/backend/metal/kernels/ternary.h"
+
+#define instantiate_ternary_base(op, tname, type)                    \
+  instantiate_kernel("v_" #op #tname, ternary_v, type, op, false, false, 1) \
+  instantiate_kernel("v2_" #op #tname, ternary_v2, type, op, false, false)  \
+  instantiate_kernel("vs_" #op #tname, ternary_v, type, op, false, true, 1) \
+  instantiate_kernel("vs2_" #op #tname, ternary_v2, type, op, false, true)  \
+  instantiate_kernel("sv_" #op #tname, ternary_v, type, op, true, false, 1) \
+  instantiate_kernel("sv2_" #op #tname, ternary_v2, type, op, true, false)  \
+  instantiate_kernel("gn2_" #op #tname, ternary_g, type, op, 2, int) \
+  instantiate_kernel("g1_" #op #tname, ternary_g_nd1, type, op, int) \
+  instantiate_kernel("g2_" #op #tname, ternary_g_nd2, type, op, int) \
+  instantiate_kernel("g3_" #op #tname, ternary_g_nd3, type, op, int) \
+  instantiate_kernel("g1large_" #op #tname, ternary_g_nd1, type, op) \
+  instantiate_kernel("g2large_" #op #tname, ternary_g_nd2, type, op) \
+  instantiate_kernel("g3large_" #op #tname, ternary_g_nd3, type, op) \
+  instantiate_kernel("gn4large_" #op #tname, ternary_g, type, op, 4) \
+
+#define instantiate_ternary_all(op, tname, type)            \
+  instantiate_kernel("vn_" #op #tname, ternary_v, type, op, false, false) \
+  instantiate_kernel("vsn_" #op #tname, ternary_v, type, op, false, true) \
+  instantiate_kernel("svn_" #op #tname, ternary_v, type, op, true, false) \
+  instantiate_ternary_base(op, tname, type)
+
+#define instantiate_ternary_types(op)               \
+  instantiate_ternary_all(op, bool_, bool)          \
+  instantiate_ternary_all(op, uint8, uint8_t)       \
+  instantiate_ternary_all(op, uint16, uint16_t)     \
+  instantiate_ternary_all(op, uint32, uint32_t)     \
+  instantiate_ternary_base(op, uint64, uint64_t)    \
+  instantiate_ternary_all(op, int8, int8_t)         \
+  instantiate_ternary_all(op, int16, int16_t)       \
+  instantiate_ternary_all(op, int32, int32_t)       \
+  instantiate_ternary_base(op, int64, int64_t)      \
+  instantiate_ternary_all(op, float16, half)        \
+  instantiate_ternary_all(op, float32, float)       \
+  instantiate_ternary_all(op, bfloat16, bfloat16_t) \
+  instantiate_ternary_base(op, complex64, complex64_t) // clang-format on
+
+instantiate_ternary_types(Select)
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/ternary_ops.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/ternary_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..e0235d9dd3cecdacc647975ed0067328b37c1840
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/ternary_ops.h
@@ -0,0 +1,10 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+struct Select {
+  template <typename T>
+  T operator()(bool condition, T x, T y) {
+    return condition ? x : y;
+  }
+};
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/unary.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/unary.h
new file mode 100644
index 0000000000000000000000000000000000000000..649ba7f2ca60e0892419a5a58ca56a9230414259
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/unary.h
@@ -0,0 +1,63 @@
+// Copyright © 2024 Apple Inc.
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void unary_v(
+    device const T* in,
+    device U* out,
+    constant uint& size,
+    uint index [[thread_position_in_grid]]) {
+  index *= N;
+  if (N > 1 && index + N > size) {
+    for (int i = 0; index + i < size; ++i) {
+      out[index + i] = Op()(in[index + i]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      out[index + i] = Op()(in[index + i]);
+    }
+  }
+}
+
+template <typename T, typename U, typename Op, int N = WorkPerThread<T>::n>
+[[kernel]] void unary_v2(
+    device const T* in,
+    device U* out,
+    constant int64_t& size,
+    uint2 index [[thread_position_in_grid]],
+    uint2 grid_dim [[threads_per_grid]]) {
+  int64_t offset = N * (index.x + grid_dim.x * int64_t(index.y));
+  if (N > 1 && offset + N > size) {
+    for (int i = 0; offset + i < size; ++i) {
+      out[offset + i] = Op()(in[offset + i]);
+    }
+  } else {
+    for (int i = 0; i < N; ++i) {
+      out[offset + i] = Op()(in[offset + i]);
+    }
+  }
+}
+
+template <
+    typename T,
+    typename U,
+    typename Op,
+    int N = 1,
+    typename IdxT = int64_t>
+[[kernel]] void unary_g(
+    device const T* in,
+    device U* out,
+    constant const int* in_shape,
+    constant const int64_t* in_strides,
+    device const int& ndim,
+    uint3 index [[thread_position_in_grid]],
+    uint3 grid_dim [[threads_per_grid]]) {
+  auto idx = elem_to_loc<IdxT>(
+      {N * index.x, index.y, index.z}, in_shape, in_strides, ndim);
+  auto xshape = in_shape[ndim - 1];
+  IdxT xstride = in_strides[ndim - 1];
+  IdxT out_idx = N * index.x + xshape * (index.y + IdxT(grid_dim.y) * index.z);
+  for (int i = 0; i < N && (int(N * index.x) + i) < xshape; ++i) {
+    out[out_idx++] = Op()(in[idx]);
+    idx += xstride;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/unary.metal b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/unary.metal
new file mode 100644
index 0000000000000000000000000000000000000000..160ef4af1e0810afa5736a8931be058b5cb8f01c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/unary.metal
@@ -0,0 +1,106 @@
+// Copyright © 2024 Apple Inc.
+
+// clang-format off
+#include "mlx/backend/metal/kernels/utils.h"
+#include "mlx/backend/metal/kernels/unary_ops.h"
+#include "mlx/backend/metal/kernels/unary.h"
+
+#define instantiate_unary_work_per_thread(op, in_tname, out_tname, in_type, out_type) \
+  instantiate_kernel("vn_" #op #in_tname #out_tname, unary_v, in_type, out_type, op)
+
+#define instantiate_unary_base(op, in_tname, out_tname, in_type, out_type)             \
+  instantiate_kernel("v_" #op #in_tname #out_tname, unary_v, in_type, out_type, op, 1) \
+  instantiate_kernel("v2_" #op #in_tname #out_tname, unary_v2, in_type, out_type, op)  \
+  instantiate_kernel(                                                                  \
+      "gn1_" #op #in_tname #out_tname, unary_g, in_type, out_type, op, 1, int)         \
+  instantiate_kernel(                                                                  \
+      "gn4large_" #op #in_tname #out_tname, unary_g, in_type, out_type, op, 4)
+
+#define instantiate_unary_all(op, in_tname, out_tname, in_type, out_type)       \
+  instantiate_unary_base(op, in_tname, out_tname, in_type, out_type)            \
+  instantiate_unary_work_per_thread(op, in_tname, out_tname, in_type, out_type)
+
+#define instantiate_unary_all_same(op, tname, type)   \
+  instantiate_unary_all(op, tname, tname, type, type)
+
+#define instantiate_unary_base_same(op, tname, type)   \
+  instantiate_unary_base(op, tname, tname, type, type)
+
+#define instantiate_unary_float(op)                    \
+  instantiate_unary_all_same(op, float16, half)        \
+  instantiate_unary_all_same(op, float32, float)       \
+  instantiate_unary_all_same(op, bfloat16, bfloat16_t)
+
+#define instantiate_unary_int(op)                   \
+  instantiate_unary_all_same(op, uint8, uint8_t)    \
+  instantiate_unary_all_same(op, uint16, uint16_t)  \
+  instantiate_unary_all_same(op, uint32, uint32_t)  \
+  instantiate_unary_base_same(op, uint64, uint64_t) \
+  instantiate_unary_all_same(op, int8, int8_t)      \
+  instantiate_unary_all_same(op, int16, int16_t)    \
+  instantiate_unary_all_same(op, int32, int32_t)    \
+  instantiate_unary_base_same(op, int64, int64_t)
+
+#define instantiate_unary_types(op)                \
+  instantiate_unary_all_same(op, bool_, bool)      \
+  instantiate_unary_int(op)                        \
+  instantiate_unary_float(op)
+
+instantiate_unary_types(Abs)
+instantiate_unary_float(ArcCos)
+instantiate_unary_float(ArcCosh)
+instantiate_unary_float(ArcSin)
+instantiate_unary_float(ArcSinh)
+instantiate_unary_float(ArcTan)
+instantiate_unary_float(ArcTanh)
+instantiate_unary_types(Ceil)
+instantiate_unary_float(Cos)
+instantiate_unary_float(Cosh)
+instantiate_unary_float(Exp)
+instantiate_unary_float(Expm1)
+instantiate_unary_types(Floor)
+instantiate_unary_float(Log)
+instantiate_unary_float(Log2)
+instantiate_unary_float(Log10)
+instantiate_unary_float(Log1p)
+instantiate_unary_types(Negative)
+instantiate_unary_float(Sigmoid)
+instantiate_unary_float(Erf)
+instantiate_unary_float(ErfInv)
+instantiate_unary_types(Sign)
+instantiate_unary_float(Sin)
+instantiate_unary_float(Sinh)
+instantiate_unary_types(Square)
+instantiate_unary_float(Sqrt)
+instantiate_unary_float(Rsqrt)
+instantiate_unary_float(Tan)
+instantiate_unary_float(Tanh)
+instantiate_unary_float(Round)
+instantiate_unary_int(BitwiseInvert)
+
+instantiate_unary_base_same(Abs, complex64, complex64_t)
+instantiate_unary_base_same(ArcCos, complex64, complex64_t)
+instantiate_unary_base_same(ArcSin, complex64, complex64_t)
+instantiate_unary_base_same(ArcTan, complex64, complex64_t)
+instantiate_unary_base_same(Conjugate, complex64, complex64_t)
+instantiate_unary_base_same(Cos, complex64, complex64_t)
+instantiate_unary_base_same(Cosh, complex64, complex64_t)
+instantiate_unary_base_same(Exp, complex64, complex64_t)
+instantiate_unary_base_same(Log, complex64, complex64_t)
+instantiate_unary_base_same(Log1p, complex64, complex64_t)
+instantiate_unary_base_same(Log2, complex64, complex64_t)
+instantiate_unary_base_same(Log10, complex64, complex64_t)
+instantiate_unary_base_same(Negative, complex64, complex64_t)
+instantiate_unary_base_same(Sign, complex64, complex64_t)
+instantiate_unary_base_same(Sin, complex64, complex64_t)
+instantiate_unary_base_same(Sinh, complex64, complex64_t)
+instantiate_unary_base_same(Square, complex64, complex64_t)
+instantiate_unary_base_same(Sqrt, complex64, complex64_t)
+instantiate_unary_base_same(Rsqrt, complex64, complex64_t)
+instantiate_unary_base_same(Tan, complex64, complex64_t)
+instantiate_unary_base_same(Tanh, complex64, complex64_t)
+instantiate_unary_base_same(Round, complex64, complex64_t)
+instantiate_unary_base(Real, complex64, float32, complex64_t, float)
+instantiate_unary_base(Imag, complex64, float32, complex64_t, float)
+
+instantiate_unary_all_same(LogicalNot, bool_, bool) // clang-format on
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/unary_ops.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/unary_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..b34bc44ba1018996f95a4a53f4b157ccfd84f226
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/unary_ops.h
@@ -0,0 +1,442 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <metal_integer>
+#include <metal_math>
+
+#include "mlx/backend/metal/kernels/cexpf.h"
+#include "mlx/backend/metal/kernels/erf.h"
+#include "mlx/backend/metal/kernels/expm1f.h"
+
+namespace {
+constant float inf = metal::numeric_limits<float>::infinity();
+}
+
+struct Abs {
+  template <typename T>
+  T operator()(T x) {
+    return metal::abs(x);
+  };
+  uint8_t operator()(uint8_t x) {
+    return x;
+  };
+  uint16_t operator()(uint16_t x) {
+    return x;
+  };
+  uint32_t operator()(uint32_t x) {
+    return x;
+  };
+  uint64_t operator()(uint64_t x) {
+    return x;
+  };
+  bool operator()(bool x) {
+    return x;
+  };
+  complex64_t operator()(complex64_t x) {
+    return {metal::precise::sqrt(x.real * x.real + x.imag * x.imag), 0};
+  };
+};
+
+struct ArcCos {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::acos(x);
+  };
+
+  complex64_t operator()(complex64_t x);
+};
+
+struct ArcCosh {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::acosh(x);
+  };
+};
+
+struct ArcSin {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::asin(x);
+  };
+
+  complex64_t operator()(complex64_t x);
+};
+
+struct ArcSinh {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::asinh(x);
+  };
+};
+
+struct ArcTan {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::atan(x);
+  };
+
+  complex64_t operator()(complex64_t x);
+};
+
+struct ArcTanh {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::atanh(x);
+  };
+};
+
+struct BitwiseInvert {
+  template <typename T>
+  T operator()(T x) {
+    return ~x;
+  };
+};
+
+struct Ceil {
+  template <typename T>
+  T operator()(T x) {
+    return metal::ceil(x);
+  };
+  int8_t operator()(int8_t x) {
+    return x;
+  };
+  int16_t operator()(int16_t x) {
+    return x;
+  };
+  int32_t operator()(int32_t x) {
+    return x;
+  };
+  int64_t operator()(int64_t x) {
+    return x;
+  };
+  uint8_t operator()(uint8_t x) {
+    return x;
+  };
+  uint16_t operator()(uint16_t x) {
+    return x;
+  };
+  uint32_t operator()(uint32_t x) {
+    return x;
+  };
+  uint64_t operator()(uint64_t x) {
+    return x;
+  };
+  bool operator()(bool x) {
+    return x;
+  };
+};
+
+struct Cos {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::cos(x);
+  };
+
+  complex64_t operator()(complex64_t x) {
+    return {
+        metal::precise::cos(x.real) * metal::precise::cosh(x.imag),
+        -metal::precise::sin(x.real) * metal::precise::sinh(x.imag)};
+  };
+};
+
+struct Cosh {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::cosh(x);
+  };
+
+  complex64_t operator()(complex64_t x) {
+    return {
+        metal::precise::cosh(x.real) * metal::precise::cos(x.imag),
+        metal::precise::sinh(x.real) * metal::precise::sin(x.imag)};
+  };
+};
+
+struct Conjugate {
+  complex64_t operator()(complex64_t x) {
+    return complex64_t{x.real, -x.imag};
+  }
+};
+
+struct Erf {
+  template <typename T>
+  T operator()(T x) {
+    return static_cast<T>(erf(static_cast<float>(x)));
+  };
+};
+
+struct ErfInv {
+  template <typename T>
+  T operator()(T x) {
+    return static_cast<T>(erfinv(static_cast<float>(x)));
+  };
+};
+
+struct Exp {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::exp(x);
+  };
+  complex64_t operator()(complex64_t x) {
+    return cexpf(x);
+  }
+};
+
+struct Expm1 {
+  template <typename T>
+  T operator()(T x) {
+    return static_cast<T>(expm1f(static_cast<float>(x)));
+  };
+};
+
+struct Floor {
+  template <typename T>
+  T operator()(T x) {
+    return metal::floor(x);
+  };
+  int8_t operator()(int8_t x) {
+    return x;
+  };
+  int16_t operator()(int16_t x) {
+    return x;
+  };
+  int32_t operator()(int32_t x) {
+    return x;
+  };
+  int64_t operator()(int64_t x) {
+    return x;
+  };
+  uint8_t operator()(uint8_t x) {
+    return x;
+  };
+  uint16_t operator()(uint16_t x) {
+    return x;
+  };
+  uint32_t operator()(uint32_t x) {
+    return x;
+  };
+  uint64_t operator()(uint64_t x) {
+    return x;
+  };
+  bool operator()(bool x) {
+    return x;
+  };
+};
+
+struct Imag {
+  template <typename T>
+  T operator()(T x) {
+    return x.imag;
+  };
+};
+
+struct Log {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::log(x);
+  };
+
+  complex64_t operator()(complex64_t x) {
+    auto r = metal::precise::log(Abs{}(x).real);
+    auto i = metal::precise::atan2(x.imag, x.real);
+    return {r, i};
+  };
+};
+
+struct Log2 {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::log2(x);
+  };
+
+  complex64_t operator()(complex64_t x) {
+    auto y = Log{}(x);
+    return {y.real / M_LN2_F, y.imag / M_LN2_F};
+  };
+};
+
+struct Log10 {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::log10(x);
+  };
+
+  complex64_t operator()(complex64_t x) {
+    auto y = Log{}(x);
+    return {y.real / M_LN10_F, y.imag / M_LN10_F};
+  };
+};
+
+struct Log1p {
+  template <typename T>
+  T operator()(T x) {
+    return log1p(x);
+  };
+};
+
+struct LogicalNot {
+  template <typename T>
+  T operator()(T x) {
+    return !x;
+  };
+};
+
+struct Negative {
+  template <typename T>
+  T operator()(T x) {
+    return -x;
+  };
+};
+
+struct Real {
+  template <typename T>
+  T operator()(T x) {
+    return x.real;
+  };
+};
+
+struct Round {
+  template <typename T>
+  T operator()(T x) {
+    return metal::rint(x);
+  };
+  complex64_t operator()(complex64_t x) {
+    return {metal::rint(x.real), metal::rint(x.imag)};
+  };
+};
+
+struct Sigmoid {
+  template <typename T>
+  T operator()(T x) {
+    auto y = 1 / (1 + metal::exp(-metal::abs(x)));
+    return (x < 0) ? 1 - y : y;
+  }
+};
+
+struct Sign {
+  template <typename T>
+  T operator()(T x) {
+    return (x > T(0)) - (x < T(0));
+  };
+  uint32_t operator()(uint32_t x) {
+    return x != 0;
+  };
+  complex64_t operator()(complex64_t x) {
+    if (x == complex64_t(0)) {
+      return x;
+    }
+    return x /
+        (complex64_t)metal::precise::sqrt(x.real * x.real + x.imag * x.imag);
+  };
+};
+
+struct Sin {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::sin(x);
+  };
+
+  complex64_t operator()(complex64_t x) {
+    return {
+        metal::precise::sin(x.real) * metal::precise::cosh(x.imag),
+        metal::precise::cos(x.real) * metal::precise::sinh(x.imag)};
+  };
+};
+
+struct Sinh {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::sinh(x);
+  };
+
+  complex64_t operator()(complex64_t x) {
+    return {
+        metal::precise::sinh(x.real) * metal::precise::cos(x.imag),
+        metal::precise::cosh(x.real) * metal::precise::sin(x.imag)};
+  };
+};
+
+struct Square {
+  template <typename T>
+  T operator()(T x) {
+    return x * x;
+  };
+};
+
+struct Sqrt {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::sqrt(x);
+  };
+
+  complex64_t operator()(complex64_t x) {
+    if (x.real == 0.0 && x.imag == 0.0) {
+      return {0.0, 0.0};
+    }
+    auto r = Abs{}(x).real;
+    auto a = metal::precise::sqrt((r + x.real) / 2.0);
+    auto b_abs = metal::precise::sqrt((r - x.real) / 2.0);
+    auto b = metal::copysign(b_abs, x.imag);
+    return {a, b};
+  }
+};
+
+struct Rsqrt {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::rsqrt(x);
+  };
+
+  complex64_t operator()(complex64_t x) {
+    return 1.0 / Sqrt{}(x);
+  }
+};
+
+struct Tan {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::tan(x);
+  };
+
+  complex64_t operator()(complex64_t x) {
+    float tan_a = metal::precise::tan(x.real);
+    float tanh_b = metal::precise::tanh(x.imag);
+    float t1 = tan_a * tanh_b;
+    float denom = 1. + t1 * t1;
+    return {(tan_a - tanh_b * t1) / denom, (tanh_b + tan_a * t1) / denom};
+  };
+};
+
+struct Tanh {
+  template <typename T>
+  T operator()(T x) {
+    return metal::precise::tanh(x);
+  };
+
+  complex64_t operator()(complex64_t x) {
+    float tanh_a = metal::precise::tanh(x.real);
+    float tan_b = metal::precise::tan(x.imag);
+    float t1 = tanh_a * tan_b;
+    float denom = 1. + t1 * t1;
+    return {(tanh_a + tan_b * t1) / denom, (tan_b - tanh_a * t1) / denom};
+  };
+};
+
+complex64_t ArcCos::operator()(complex64_t x) {
+  auto i = complex64_t{0.0, 1.0};
+  auto y = Log{}(x + i * Sqrt{}(1.0 - x * x));
+  return {y.imag, -y.real};
+};
+
+complex64_t ArcSin::operator()(complex64_t x) {
+  auto i = complex64_t{0.0, 1.0};
+  auto y = Log{}(i * x + Sqrt{}(1.0 - x * x));
+  return {y.imag, -y.real};
+};
+
+complex64_t ArcTan::operator()(complex64_t x) {
+  auto i = complex64_t{0.0, 1.0};
+  auto ix = i * x;
+  return (1.0 / complex64_t{0.0, 2.0}) * Log{}((1.0 + ix) / (1.0 - ix));
+};
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/utils.h b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..c30d186b8642a6689c279e180e6a0faef6a30228
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/kernels/utils.h
@@ -0,0 +1,448 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <metal_math>
+
+// The correct bf16.h is included based on the metal version
+// by giving the correct path to -I during compilation
+// e.g. mlx/backend/metal/kernels/metal_3_0/ for Metal 3.0
+#include "bf16.h"
+
+#include "mlx/backend/metal/kernels/bf16_math.h"
+#include "mlx/backend/metal/kernels/complex.h"
+#include "mlx/backend/metal/kernels/defines.h"
+
+typedef half float16_t;
+
+// Work per thread values for different types. The values here are expected to
+// match get_work_per_thread in mlx/backend/metal/utils.h
+template <typename U>
+struct WorkPerThread {
+  static_assert(sizeof(U) <= 8, "Type too large");
+  static constexpr int constant n = 8 / sizeof(U);
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Type limits utils
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename U>
+struct Limits {
+  static const constant U max = metal::numeric_limits<U>::max();
+  static const constant U min = metal::numeric_limits<U>::min();
+  static const constant U finite_max = metal::numeric_limits<U>::max();
+  static const constant U finite_min = metal::numeric_limits<U>::min();
+};
+
+#define instantiate_default_limit(type)                                      \
+  template <>                                                                \
+  struct Limits<type> {                                                      \
+    static constexpr constant type max = metal::numeric_limits<type>::max(); \
+    static constexpr constant type min = metal::numeric_limits<type>::min(); \
+    static constexpr constant type finite_max =                              \
+        metal::numeric_limits<type>::max();                                  \
+    static constexpr constant type finite_min =                              \
+        metal::numeric_limits<type>::min();                                  \
+  };
+
+instantiate_default_limit(uint8_t);
+instantiate_default_limit(uint16_t);
+instantiate_default_limit(uint32_t);
+instantiate_default_limit(uint64_t);
+instantiate_default_limit(int8_t);
+instantiate_default_limit(int16_t);
+instantiate_default_limit(int32_t);
+instantiate_default_limit(int64_t);
+
+#define instantiate_float_limit(type)             \
+  template <>                                     \
+  struct Limits<type> {                           \
+    static constexpr constant type max =          \
+        metal::numeric_limits<type>::infinity();  \
+    static constexpr constant type min =          \
+        -metal::numeric_limits<type>::infinity(); \
+    static constexpr constant type finite_max =   \
+        metal::numeric_limits<type>::max();       \
+    static constexpr constant type finite_min =   \
+        -metal::numeric_limits<type>::max();      \
+  };
+
+instantiate_float_limit(half);
+instantiate_float_limit(float);
+instantiate_float_limit(bfloat16_t);
+
+template <>
+struct Limits<bool> {
+  static constexpr constant bool max = true;
+  static constexpr constant bool min = false;
+};
+
+template <>
+struct Limits<complex64_t> {
+  static constexpr constant complex64_t max = complex64_t(
+      metal::numeric_limits<float>::infinity(),
+      metal::numeric_limits<float>::infinity());
+  static constexpr constant complex64_t min = complex64_t(
+      -metal::numeric_limits<float>::infinity(),
+      -metal::numeric_limits<float>::infinity());
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Indexing utils
+///////////////////////////////////////////////////////////////////////////////
+
+#define MLX_MTL_PRAGMA_UNROLL _Pragma("clang loop unroll(full)")
+
+///////////////////////////////////////////////////////////////////////////////
+// Single Array with generic dims
+
+template <typename IdxT = int64_t>
+METAL_FUNC IdxT elem_to_loc(
+    IdxT elem,
+    constant const int* shape,
+    constant const int64_t* strides,
+    int ndim) {
+  IdxT loc = 0;
+  for (int i = ndim - 1; i >= 0 && elem > 0; --i) {
+    loc += (elem % shape[i]) * IdxT(strides[i]);
+    elem /= shape[i];
+  }
+  return loc;
+}
+
+// Non templated version to handle arbitrary dims
+template <typename IdxT = int64_t>
+METAL_FUNC IdxT elem_to_loc(
+    uint3 elem,
+    constant const int* shape,
+    constant const int64_t* strides,
+    int ndim) {
+  IdxT loc =
+      elem.x * IdxT(strides[ndim - 1]) + elem.y * IdxT(strides[ndim - 2]);
+  for (int d = ndim - 3; d >= 0; --d) {
+    loc += (elem.z % shape[d]) * IdxT(strides[d]);
+    elem.z /= shape[d];
+  }
+  return loc;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Single Array with fixed N dims
+
+template <typename IdxT = int64_t>
+METAL_FUNC IdxT elem_to_loc_1(uint elem, constant const int64_t& stride) {
+  return elem * IdxT(stride);
+}
+
+template <typename IdxT = int64_t>
+METAL_FUNC IdxT elem_to_loc_2(uint2 elem, constant const int64_t strides[2]) {
+  return elem.x * IdxT(strides[1]) + elem.y * IdxT(strides[0]);
+}
+
+template <typename IdxT = int64_t>
+METAL_FUNC IdxT elem_to_loc_3(uint3 elem, constant const int64_t strides[3]) {
+  return elem.x * IdxT(strides[2]) + elem.y * IdxT(strides[1]) +
+      elem.z * IdxT(strides[0]);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Multiple Arrays with generic dims
+
+template <typename IdxT = int64_t>
+METAL_FUNC vec<IdxT, 2> elem_to_loc_2_nd(
+    uint3 elem,
+    constant const int* shape,
+    constant const int64_t* a_strides,
+    constant const int64_t* b_strides,
+    int ndim) {
+  vec<IdxT, 2> loc = {
+      IdxT(
+          elem.x * IdxT(a_strides[ndim - 1]) +
+          IdxT(elem.y) * IdxT(a_strides[ndim - 2])),
+      IdxT(
+          elem.x * IdxT(b_strides[ndim - 1]) +
+          elem.y * IdxT(b_strides[ndim - 2]))};
+  for (int d = ndim - 3; d >= 0; --d) {
+    uint l = elem.z % shape[d];
+    loc.x += l * IdxT(a_strides[d]);
+    loc.y += l * IdxT(b_strides[d]);
+    elem.z /= shape[d];
+  }
+  return loc;
+}
+
+template <typename IdxT = int64_t>
+METAL_FUNC vec<IdxT, 3> elem_to_loc_3_nd(
+    uint3 elem,
+    constant const int* shape,
+    constant const int64_t* a_strides,
+    constant const int64_t* b_strides,
+    constant const int64_t* c_strides,
+    int ndim) {
+  vec<IdxT, 3> loc = {
+      IdxT(elem.x * IdxT(a_strides[ndim - 1])) +
+          IdxT(elem.y * IdxT(a_strides[ndim - 2])),
+      IdxT(elem.x * IdxT(b_strides[ndim - 1])) +
+          IdxT(elem.y * IdxT(b_strides[ndim - 2])),
+      IdxT(elem.x * IdxT(c_strides[ndim - 1])) +
+          IdxT(elem.y * IdxT(c_strides[ndim - 2]))};
+  for (int d = ndim - 3; d >= 0; --d) {
+    uint l = elem.z % shape[d];
+    loc.x += l * IdxT(a_strides[d]);
+    loc.y += l * IdxT(b_strides[d]);
+    loc.z += l * IdxT(c_strides[d]);
+    elem.z /= shape[d];
+  }
+  return loc;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Elem to loc in a loop utils
+///////////////////////////////////////////////////////////////////////////////
+
+template <int DIM, typename OffsetT = size_t, bool General = true>
+struct LoopedElemToLoc {
+  int dim;
+  LoopedElemToLoc<DIM - 1, OffsetT, General> inner_looper;
+  OffsetT offset{0};
+  int index{0};
+
+  LoopedElemToLoc(int dim) : dim(dim), inner_looper(dim - 1) {}
+
+  void next(const constant int* shape, const constant int64_t* strides) {
+    if (dim == 0) {
+      return;
+    }
+    index++;
+    offset += OffsetT(strides[dim - 1]);
+    if (index >= shape[dim - 1]) {
+      index = 0;
+      inner_looper.next(shape, strides);
+      offset = inner_looper.offset;
+    }
+  }
+
+  void next(int n, const constant int* shape, const constant int64_t* strides) {
+    if (dim == 0) {
+      return;
+    }
+    index += n;
+    offset += n * OffsetT(strides[dim - 1]);
+
+    if (index >= shape[dim - 1]) {
+      int extra = index - shape[dim - 1];
+      if (extra >= shape[dim - 1]) {
+        inner_looper.next(1 + extra / shape[dim - 1], shape, strides);
+        extra = extra % shape[dim - 1];
+      } else {
+        inner_looper.next(shape, strides);
+      }
+      index = 0;
+      offset = inner_looper.offset;
+      if (extra > 0) {
+        next(extra, shape, strides);
+      }
+    }
+  }
+
+  OffsetT location() {
+    return offset;
+  }
+};
+
+template <typename OffsetT>
+struct LoopedElemToLoc<1, OffsetT, true> {
+  int dim;
+  OffsetT offset{0};
+  uint index{0};
+
+  LoopedElemToLoc(int dim) : dim(dim) {}
+
+  void next(const constant int* shape, const constant int64_t* strides) {
+    index++;
+    if (dim > 1) {
+      offset = elem_to_loc<OffsetT>(index, shape, strides, dim);
+    } else {
+      offset += OffsetT(strides[0]);
+    }
+  }
+
+  void next(int n, const constant int* shape, const constant int64_t* strides) {
+    index += n;
+    if (dim > 1) {
+      offset = elem_to_loc<OffsetT>(index, shape, strides, dim);
+    } else {
+      offset = index * OffsetT(strides[0]);
+    }
+  }
+
+  OffsetT location() {
+    return offset;
+  }
+};
+
+template <typename OffsetT>
+struct LoopedElemToLoc<1, OffsetT, false> {
+  OffsetT offset{0};
+
+  LoopedElemToLoc(int) {}
+
+  void next(const constant int*, const constant int64_t* strides) {
+    offset += OffsetT(strides[0]);
+  }
+
+  void next(int n, const constant int*, const constant int64_t* strides) {
+    offset += n * OffsetT(strides[0]);
+  }
+
+  OffsetT location() {
+    return offset;
+  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Calculation utils
+///////////////////////////////////////////////////////////////////////////////
+
+/** Compute ceil((float)N/(float)M) */
+template <typename T, typename U>
+inline T ceildiv(T N, U M) {
+  return (N + M - 1) / M;
+}
+
+// https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html#1202
+inline float log1p(float x) {
+  float xp1 = 1.0f + x;
+  if (xp1 == Limits<float>::max) {
+    return Limits<float>::max;
+  }
+  if (xp1 == 1.0f) {
+    return x;
+  }
+
+  return x * (metal::log(xp1) / (xp1 - 1.0f));
+}
+
+inline bfloat16_t log1p(bfloat16_t x) {
+  float xp1 = 1.0f + static_cast<float>(x);
+  if (xp1 == Limits<float>::max) {
+    return Limits<bfloat16_t>::max;
+  }
+  if (xp1 == 1.0f) {
+    return x;
+  }
+
+  return bfloat16_t(x * (metal::log(xp1) / (xp1 - 1.0f)));
+}
+
+inline complex64_t log1p(complex64_t in) {
+  float x = in.real;
+  float y = in.imag;
+  float zabs = metal::precise::sqrt(x * x + y * y);
+  float theta = metal::atan2(y, x + 1);
+  if (zabs < 0.5f) {
+    float r = x * (2 + x) + y * y;
+    if (r == 0) { // handle underflow
+      return {x, theta};
+    }
+    return {0.5f * log1p(r), theta};
+  } else {
+    auto z0 = metal::sqrt((x + 1) * (x + 1) + y * y);
+    return {metal::log(z0), theta};
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// SIMD shuffle ops
+///////////////////////////////////////////////////////////////////////////////
+
+inline uint64_t simd_shuffle_down(uint64_t data, uint16_t delta) {
+  return as_type<uint64_t>(
+      metal::simd_shuffle_down(as_type<uint2>(data), delta));
+}
+
+inline int64_t simd_shuffle_down(int64_t data, uint16_t delta) {
+  return as_type<int64_t>(
+      metal::simd_shuffle_down(as_type<uint2>(data), delta));
+}
+
+inline bool simd_shuffle_down(bool data, uint16_t delta) {
+  return simd_shuffle_down(static_cast<uint32_t>(data), delta);
+}
+
+inline complex64_t simd_shuffle_down(complex64_t data, uint16_t delta) {
+  return complex64_t(
+      simd_shuffle_down(data.real, delta), simd_shuffle_down(data.imag, delta));
+}
+
+inline uint64_t simd_shuffle_up(uint64_t data, uint16_t delta) {
+  return as_type<uint64_t>(metal::simd_shuffle_up(as_type<uint2>(data), delta));
+}
+
+inline int64_t simd_shuffle_up(int64_t data, uint16_t delta) {
+  return as_type<int64_t>(metal::simd_shuffle_up(as_type<uint2>(data), delta));
+}
+
+inline bool simd_shuffle_up(bool data, uint16_t delta) {
+  return simd_shuffle_up(static_cast<uint32_t>(data), delta);
+}
+
+inline complex64_t simd_shuffle_up(complex64_t data, uint16_t delta) {
+  return complex64_t(
+      simd_shuffle_up(data.real, delta), simd_shuffle_up(data.imag, delta));
+}
+
+inline uint64_t
+simd_shuffle_and_fill_up(uint64_t data, uint64_t filling, uint16_t delta) {
+  return as_type<uint64_t>(metal::simd_shuffle_and_fill_up(
+      as_type<uint2>(data), as_type<uint2>(filling), delta));
+}
+
+inline int64_t
+simd_shuffle_and_fill_up(int64_t data, int64_t filling, uint16_t delta) {
+  return as_type<int64_t>(metal::simd_shuffle_and_fill_up(
+      as_type<uint2>(data), as_type<uint2>(filling), delta));
+}
+
+inline bool simd_shuffle_and_fill_up(bool data, bool filling, uint16_t delta) {
+  return simd_shuffle_and_fill_up(
+      static_cast<uint32_t>(data), static_cast<uint32_t>(filling), delta);
+}
+
+inline complex64_t simd_shuffle_and_fill_up(
+    complex64_t data,
+    complex64_t filling,
+    uint16_t delta) {
+  return complex64_t(
+      simd_shuffle_and_fill_up(data.real, filling.real, delta),
+      simd_shuffle_and_fill_up(data.imag, filling.imag, delta));
+}
+
+inline uint64_t simd_shuffle(uint64_t data, uint16_t lane) {
+  return as_type<uint64_t>(metal::simd_shuffle(as_type<uint2>(data), lane));
+}
+
+inline int64_t simd_shuffle(int64_t data, uint16_t lane) {
+  return as_type<int64_t>(metal::simd_shuffle(as_type<uint2>(data), lane));
+}
+
+inline bool simd_shuffle(bool data, uint16_t lane) {
+  return simd_shuffle(static_cast<uint32_t>(data), lane);
+}
+
+inline complex64_t simd_shuffle(complex64_t data, uint16_t lane) {
+  return complex64_t(
+      simd_shuffle(data.real, lane), simd_shuffle(data.imag, lane));
+}
+
+// std::conditional is not included with Metal
+template <bool condition, typename T, typename U>
+struct ConditionalType {
+  using type = U;
+};
+
+template <typename T, typename U>
+struct ConditionalType<true, T, U> {
+  using type = T;
+};
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/logsumexp.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/logsumexp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2cfdcdc8a0d48f151fb6d22d77a0ef4bf92e1d22
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/logsumexp.cpp
@@ -0,0 +1,95 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <algorithm>
+
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+constexpr int LOGSUMEXP_LOOPED_LIMIT = 4096;
+
+void LogSumExp::eval_gpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  if (!issubdtype(out.dtype(), floating)) {
+    throw std::runtime_error(
+        "[logsumexp] Does not support non-floating point types.");
+  }
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  // Make sure that the last dimension is contiguous
+  auto ensure_contiguous = [&s, &d](const array& x) {
+    if (x.flags().contiguous && x.strides()[x.ndim() - 1] == 1) {
+      return x;
+    } else {
+      array x_copy = contiguous_copy_gpu(x, s);
+      d.add_temporary(x_copy, s.index);
+      return x_copy;
+    }
+  };
+
+  auto in = ensure_contiguous(inputs[0]);
+  if (in.flags().row_contiguous) {
+    out.set_data(allocator::malloc(out.nbytes()));
+  } else {
+    auto n = in.shape(-1);
+    auto flags = in.flags();
+    auto strides = in.strides();
+    for (auto& s : strides) {
+      s /= n;
+    }
+    bool col_contig = strides[0] == 1;
+    for (int i = 1; col_contig && i < strides.size(); ++i) {
+      col_contig &=
+          (out.shape(i) == 1 || strides[i - 1] == out.shape(i) * strides[i]);
+    }
+    flags.col_contiguous = col_contig;
+    out.set_data(
+        allocator::malloc(in.nbytes() / n),
+        in.data_size() / n,
+        std::move(strides),
+        flags);
+  }
+
+  int axis_size = in.shape().back();
+  int n_rows = in.data_size() / axis_size;
+
+  const int simd_size = 32;
+  const int n_reads = 4;
+  const int looped_limit = LOGSUMEXP_LOOPED_LIMIT;
+
+  std::string kernel_name = (axis_size > looped_limit) ? "looped_" : "block_";
+  kernel_name += "logsumexp_";
+  kernel_name += type_to_name(out);
+
+  auto kernel = get_logsumexp_kernel(d, kernel_name, out);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  {
+    MTL::Size grid_dims, group_dims;
+    if (axis_size <= looped_limit) {
+      size_t threadgroup_needed = (axis_size + n_reads - 1) / n_reads;
+      size_t simds_needed = (threadgroup_needed + simd_size - 1) / simd_size;
+      size_t threadgroup_size = simd_size * simds_needed;
+      assert(threadgroup_size <= kernel->maxTotalThreadsPerThreadgroup());
+      size_t n_threads = n_rows * threadgroup_size;
+      grid_dims = MTL::Size(n_threads, 1, 1);
+      group_dims = MTL::Size(threadgroup_size, 1, 1);
+    } else {
+      size_t threadgroup_size = kernel->maxTotalThreadsPerThreadgroup();
+      size_t n_threads = n_rows * threadgroup_size;
+      grid_dims = MTL::Size(n_threads, 1, 1);
+      group_dims = MTL::Size(threadgroup_size, 1, 1);
+    }
+
+    compute_encoder.set_compute_pipeline_state(kernel);
+    compute_encoder.set_input_array(in, 0);
+    compute_encoder.set_output_array(out, 1);
+    compute_encoder.set_bytes(axis_size, 2);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/make_compiled_preamble.sh b/ml-stable-diffusion/mlx/mlx/backend/metal/make_compiled_preamble.sh
new file mode 100644
index 0000000000000000000000000000000000000000..425cd8d70a631a519a9d223fbd48eec39fe5f944
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/make_compiled_preamble.sh
@@ -0,0 +1,31 @@
+#!/bin/bash
+#
+# This script generates a C++ function that provides the Metal unary and binary
+# ops at runtime for use with kernel generation.
+#
+# Copyright © 2023-24 Apple Inc.
+
+OUTPUT_DIR=$1
+CC=$2
+SRC_DIR=$3
+SRC_FILE=$4
+CFLAGS=$5
+SRC_NAME=$(basename -- "${SRC_FILE}")
+JIT_INCLUDES=${SRC_DIR}/mlx/backend/metal/kernels/jit
+INPUT_FILE=${SRC_DIR}/mlx/backend/metal/kernels/${SRC_FILE}.h
+OUTPUT_FILE=${OUTPUT_DIR}/${SRC_NAME}.cpp
+
+mkdir -p "$OUTPUT_DIR"
+CONTENT=$($CC -I"$SRC_DIR" -I"$JIT_INCLUDES" -DMLX_METAL_JIT -E -P "$INPUT_FILE" $CFLAGS 2>/dev/null)
+
+cat << EOF > "$OUTPUT_FILE"
+namespace mlx::core::metal {
+
+const char* $SRC_NAME() {
+  return R"preamble(
+$CONTENT
+)preamble";
+}
+
+} // namespace mlx::core::metal
+EOF
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/matmul.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/matmul.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d9497a665a92712c5ae31ae8c9e3faf4e948a6a2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/matmul.cpp
@@ -0,0 +1,2044 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <algorithm>
+#include <cassert>
+#include <numeric>
+#include <sstream>
+
+#include "mlx/backend/common/broadcasting.h"
+#include "mlx/backend/common/matmul.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/kernels/defines.h"
+#include "mlx/backend/metal/kernels/steel/gemm/params.h"
+#include "mlx/backend/metal/matmul.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+namespace {
+
+std::tuple<bool, int64_t, array> check_transpose(
+    std::vector<array>& copies,
+    const Stream& s,
+    const array& arr,
+    bool is_vector) {
+  auto stx = arr.strides()[arr.ndim() - 2];
+  auto sty = arr.strides()[arr.ndim() - 1];
+  if (sty == 1 && (!is_vector || stx == arr.shape(-1))) {
+    return std::make_tuple(false, stx, arr);
+  } else if (stx == 1 && (!is_vector || sty == arr.shape(-2))) {
+    return std::make_tuple(true, sty, arr);
+  } else {
+    array arr_copy = contiguous_copy_gpu(arr, s);
+    copies.push_back(arr_copy);
+    return std::make_tuple(false, arr.shape(-1), arr_copy);
+  }
+};
+
+inline array
+ensure_row_contiguous(const array& x, metal::Device& d, const Stream& s) {
+  if (!x.flags().row_contiguous) {
+    array x_copy = contiguous_copy_gpu(x, s);
+    d.add_temporary(x_copy, s.index);
+    return x_copy;
+  } else {
+    return x;
+  }
+}
+
+inline std::tuple<bool, int64_t, array>
+ensure_batch_contiguous(const array& x, metal::Device& d, const Stream& s) {
+  if (x.flags().row_contiguous) {
+    return std::make_tuple(false, x.strides()[x.ndim() - 2], x);
+  }
+
+  bool rc = true;
+  for (int i = 0; i < x.ndim() - 3; i++) {
+    rc &= x.strides()[i + 1] * x.shape(i) == x.strides()[i];
+  }
+  if (rc) {
+    auto stx = x.strides()[x.ndim() - 2];
+    auto sty = x.strides()[x.ndim() - 1];
+    auto K = x.shape(-2);
+    auto N = x.shape(-1);
+    if (sty == 1 && (N != 1 || stx == N)) {
+      return std::make_tuple(false, stx, x);
+    }
+    if (stx == 1 && (N != 1 || sty == K)) {
+      return std::make_tuple(true, sty, x);
+    }
+  }
+
+  array x_copy = contiguous_copy_gpu(x, s);
+  d.add_temporary(x_copy, s.index);
+  return std::make_tuple(false, x_copy.strides()[x_copy.ndim() - 2], x_copy);
+}
+
+} // namespace
+
+///////////////////////////////////////////////////////////////////////////////
+// Steel matmul fallback
+///////////////////////////////////////////////////////////////////////////////
+
+#define GEMM_TPARAM_MACRO(devc)                                           \
+  if (devc == 'g' || devc == 'p') { /* Small device */                    \
+    if (out.dtype() == complex64) {                                       \
+      bm = 64;                                                            \
+      bn = 32;                                                            \
+      bk = 8;                                                             \
+      wm = 4;                                                             \
+      wn = 1;                                                             \
+    } else if (!transpose_a && transpose_b) { /* nt */                    \
+      bm = 64;                                                            \
+      bn = 32;                                                            \
+      bk = 32;                                                            \
+      wm = 2;                                                             \
+      wn = 2;                                                             \
+    } else if (out.dtype() != float32) { /* half and bfloat */            \
+      bm = 64;                                                            \
+      bn = 64;                                                            \
+      bk = 16;                                                            \
+      wm = 1;                                                             \
+      wn = 2;                                                             \
+    }                                                                     \
+  } else if (devc == 'd') { /* Large device */                            \
+    if ((size_t)batch_size_out * M * N >= 1ul << 20) { /* large matmul */ \
+      if (out.dtype() != float32) { /* half and bfloat */                 \
+        if (2 * std::max(M, N) > K) { /* Reasonable K */                  \
+          bm = 64;                                                        \
+          bn = 64;                                                        \
+          bk = 16;                                                        \
+          wm = 1;                                                         \
+          wn = 2;                                                         \
+        } else if (!transpose_a && transpose_b) { /* nt with large k */   \
+          bm = 64;                                                        \
+          bn = 32;                                                        \
+          bk = 32;                                                        \
+          wm = 2;                                                         \
+          wn = 2;                                                         \
+        } else { /* nn with large K */                                    \
+          bm = 32;                                                        \
+          bn = 64;                                                        \
+          bk = 16;                                                        \
+          wm = 1;                                                         \
+          wn = 2;                                                         \
+        }                                                                 \
+      } /* float takes default */                                         \
+    } else { /* smaller matmul */                                         \
+      if (out.dtype() != float32) { /* half and bfloat */                 \
+        if (!transpose_a && transpose_b) { /* nt */                       \
+          bm = 64;                                                        \
+          bn = 32;                                                        \
+          bk = 32;                                                        \
+          wm = 2;                                                         \
+          wn = 2;                                                         \
+        } else { /* nn */                                                 \
+          bm = 64;                                                        \
+          bn = 64;                                                        \
+          bk = 16;                                                        \
+          wm = 1;                                                         \
+          wn = 2;                                                         \
+        }                                                                 \
+      } else { /* floats */                                               \
+        if (!transpose_a && transpose_b) { /* nt */                       \
+          bm = 32;                                                        \
+          bn = 64;                                                        \
+          bk = 16;                                                        \
+          wm = 1;                                                         \
+          wn = 2;                                                         \
+        } else { /* nn */                                                 \
+          bm = 64;                                                        \
+          bn = 32;                                                        \
+          bk = 32;                                                        \
+          wm = 2;                                                         \
+          wn = 2;                                                         \
+        }                                                                 \
+      }                                                                   \
+    }                                                                     \
+  } else { /* Medium device */                                            \
+    bm = 64;                                                              \
+    bn = 64;                                                              \
+    bk = 16;                                                              \
+    wm = 2;                                                               \
+    wn = 2;                                                               \
+  }
+
+///////////////////////////////////////////////////////////////////////////////
+// Regular steel matmul dispatch
+///////////////////////////////////////////////////////////////////////////////
+
+template <bool CHECK_AB>
+void steel_matmul_regular_axpby(
+    const Stream& s,
+    metal::Device& d,
+    const array& a,
+    const array& b,
+    const array& c,
+    array& out,
+    int M,
+    int N,
+    int K,
+    int batch_size_out,
+    int lda,
+    int ldb,
+    int ldd,
+    bool transpose_a,
+    bool transpose_b,
+    std::vector<array>& copies,
+    Shape batch_shape,
+    Strides batch_strides,
+    int64_t A_batch_stride,
+    int64_t B_batch_stride,
+    int64_t matrix_stride_out,
+    int64_t C_batch_stride /* = 0*/,
+    float alpha /* = 1.0f */,
+    float beta /* = 0.0f */) {
+  using namespace mlx::steel;
+
+  // Determine dispatch kernel
+  int bm = 64, bn = 64, bk = 16;
+  int wm = 2, wn = 2;
+
+  char devc = d.get_architecture().back();
+  GEMM_TPARAM_MACRO(devc)
+
+  // Prepare kernel name
+  std::ostringstream kname;
+
+  // clang-format off
+  kname << "steel_gemm_fused_" 
+        << (transpose_a ? 't' : 'n')
+        << (transpose_b ? 't' : 'n') 
+        << "_" << type_to_name(a) 
+        << "_" << type_to_name(out) 
+        << "_bm" << bm << "_bn" << bn << "_bk" << bk
+        << "_wm" << wm << "_wn" << wn; // clang-format on
+
+  std::string base_name = kname.str();
+
+  const bool has_batch = (batch_shape.size() > 1);
+  const bool use_out_source = CHECK_AB && (alpha != 0.0f || beta != 1.0f);
+  const bool do_axpby = use_out_source && (alpha != 1.0f || beta != 1.0f);
+  const bool align_M = (M % bm) == 0;
+  const bool align_N = (N % bn) == 0;
+  const bool align_K = (K % bk) == 0;
+
+  metal::MTLFCList func_consts = {
+      {&has_batch, MTL::DataType::DataTypeBool, 10},
+      {&use_out_source, MTL::DataType::DataTypeBool, 100},
+      {&do_axpby, MTL::DataType::DataTypeBool, 110},
+      {&align_M, MTL::DataType::DataTypeBool, 200},
+      {&align_N, MTL::DataType::DataTypeBool, 201},
+      {&align_K, MTL::DataType::DataTypeBool, 202},
+  };
+
+  // clang-format off
+  kname << "_has_batch_" << (has_batch ? 't' : 'n')
+        << "_use_out_source_" << (use_out_source ? 't' : 'n')
+        << "_do_axpby_" << (do_axpby ? 't' : 'n')
+        << "_align_M_" << (align_M ? 't' : 'n')
+        << "_align_N_" << (align_N ? 't' : 'n')
+        << "_align_K_" << (align_K ? 't' : 'n'); // clang-format on
+
+  std::string hash_name = kname.str();
+
+  // Encode and dispatch kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = get_steel_gemm_fused_kernel(
+      /* metal::Device& d = */ d,
+      /* const std::string& kernel_name = */ base_name,
+      /* const std::string& hash_name = */ hash_name,
+      /* const metal::MTLFCList& func_consts = */ func_consts,
+      /* const array& out = */ out,
+      /* bool transpose_a = */ transpose_a,
+      /* bool transpose_b = */ transpose_b,
+      /* int bm = */ bm,
+      /* int bn = */ bn,
+      /* int bk = */ bk,
+      /* int wm = */ wm,
+      /* int wn = */ wn);
+
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Use problem size to determine threadblock swizzle
+  int tn = (N + bn - 1) / bn;
+  int tm = (M + bm - 1) / bm;
+
+  // TODO: Explore device-based tuning for swizzle
+  int swizzle_log = 0; // tm >= 6 ? 3 : (tm <= 3 ? 0 : 2);
+
+  // Prepare steel matmul params
+  GEMMParams params{
+      /* const int M = */ M,
+      /* const int N = */ N,
+      /* const int K = */ K,
+      /* const int lda = */ lda,
+      /* const int ldb = */ ldb,
+      /* const int ldd = */ ldd,
+      /* const int tiles_n = */ tn,
+      /* const int tiles_m = */ tm,
+      /* const int64_t batch_stride_a = */ A_batch_stride,
+      /* const int64_t batch_stride_b = */ B_batch_stride,
+      /* const int64_t batch_stride_d = */ matrix_stride_out,
+      /* const int swizzle_log = */ swizzle_log,
+      /* const int gemm_k_iterations_aligned = */ (K / bk),
+      /* const int batch_ndim = */ int(batch_shape.size())};
+
+  // Prepare launch grid params
+  int tile = 1 << swizzle_log;
+  tm = (tm + tile - 1) / tile;
+  tn = tn * tile;
+
+  MTL::Size group_dims = MTL::Size(32, wn, wm);
+  MTL::Size grid_dims = MTL::Size(tn, tm, batch_size_out);
+
+  // Launch kernel
+  compute_encoder.set_input_array(a, 0);
+  compute_encoder.set_input_array(b, 1);
+  compute_encoder.set_output_array(out, 3);
+
+  compute_encoder.set_bytes(params, 4);
+
+  if (has_batch) {
+    compute_encoder.set_vector_bytes(batch_shape, 6);
+    compute_encoder.set_vector_bytes(batch_strides, 7);
+  }
+
+  if (use_out_source) {
+    int ldc = c.strides()[c.ndim() - 2];
+    int fdc = c.strides()[c.ndim() - 1];
+
+    GEMMAddMMParams params{
+        /* const int ldc = */ ldc,
+        /* const int fdc = */ fdc,
+        /* const int64_t batch_stride_c = */ C_batch_stride,
+        /* const float alpha = */ alpha,
+        /* const float beta = */ beta};
+
+    compute_encoder.set_input_array(c, 2);
+    compute_encoder.set_bytes(params, 5);
+  }
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+
+  // Record copies
+  d.add_temporaries(std::move(copies), s.index);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Split k steel matmul
+///////////////////////////////////////////////////////////////////////////////
+
+template <bool CHECK_AB = true>
+void steel_gemm_splitk_axpby(
+    const Stream& s,
+    metal::Device& d,
+    const array& a,
+    const array& b,
+    const array& c,
+    array& out,
+    int M,
+    int N,
+    int K,
+    int batch_size_out,
+    int lda,
+    int ldb,
+    bool transpose_a,
+    bool transpose_b,
+    std::vector<array>& copies,
+    float alpha = 1.0f,
+    float beta = 0.0f) {
+  using namespace mlx::steel;
+
+  int _tm = M / 16;
+  int _tn = N / 16;
+  int _tk = K / 16;
+
+  int bm = M < 40 ? 16 : 32;
+  int bn = N < 40 ? 16 : 32;
+  int bk = 16;
+  int wm = 2, wn = 2;
+
+  int split_k_partitions = _tk < 16 ? 2 : (_tk < 32 ? 4 : (_tk < 64 ? 8 : 16));
+  int split_k_partition_stride = M * N;
+  int gemm_k_iterations = (K / bk) / split_k_partitions;
+  int split_k_partition_size = gemm_k_iterations * bk;
+
+  array C_split(
+      {split_k_partitions, M, N},
+      issubdtype(out.dtype(), complexfloating) ? complex64 : float32,
+      nullptr,
+      {});
+  C_split.set_data(allocator::malloc(C_split.nbytes()));
+  copies.push_back(C_split);
+
+  bool mn_aligned = M % bm == 0 && N % bn == 0;
+  bool k_aligned = K % bk == 0;
+  std::ostringstream kname;
+
+  // clang-format off
+  kname << "steel_gemm_splitk_" 
+        << (transpose_a ? 't' : 'n')
+        << (transpose_b ? 't' : 'n') 
+        << "_" << type_to_name(a) 
+        << "_" << type_to_name(C_split) 
+        << "_bm" << bm << "_bn" << bn << "_bk" << bk
+        << "_wm" << wm << "_wn" << wn 
+        << "_MN_" << (mn_aligned ? "t" : "n") << "aligned" 
+        << "_K_" << (k_aligned ? "t" : "n") << "aligned"; // clang-format on
+
+  // Encode and dispatch gemm kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = get_steel_gemm_splitk_kernel(
+      /* metal::Device& d = */ d,
+      /* const std::string& kernel_name = */ kname.str(),
+      /* const array& in = */ a,
+      /* const array& out = */ C_split,
+      /* bool transpose_a = */ transpose_a,
+      /* bool transpose_b = */ transpose_b,
+      /* int bm = */ bm,
+      /* int bn = */ bn,
+      /* int bk = */ bk,
+      /* int wm = */ wm,
+      /* int wn = */ wn,
+      /* bool mn_aligned = */ mn_aligned,
+      /* bool k_aligned = */ k_aligned);
+
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  int tn = (N + bn - 1) / bn;
+  int tm = (M + bm - 1) / bm;
+
+  GEMMSpiltKParams params{
+      /* const int M = */ M,
+      /* const int N = */ N,
+      /* const int K = */ K,
+      /* const int lda = */ lda,
+      /* const int ldb = */ ldb,
+      /* const int ldc = */ N,
+      /* const int tiles_n = */ tn,
+      /* const int tiles_m = */ tm,
+      /* const int split_k_partitions = */ split_k_partitions,
+      /* const int split_k_partition_stride = */ split_k_partition_stride,
+      /* const int split_k_partition_size = */ split_k_partition_size,
+      /* const int gemm_k_iterations_aligned = */ gemm_k_iterations};
+
+  MTL::Size group_dims = MTL::Size(32, wn, wm);
+  MTL::Size grid_dims = MTL::Size(tn, tm, split_k_partitions);
+
+  compute_encoder.set_input_array(a, 0);
+  compute_encoder.set_input_array(b, 1);
+  compute_encoder.set_output_array(C_split, 2);
+
+  compute_encoder.set_bytes(params, 3);
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+
+  // Do accum kernel
+  {
+    const bool do_axpby = CHECK_AB && (alpha != 1.0f || beta != 0.0f);
+
+    auto kernel_name = "steel_gemm_splitk_accum_" + type_to_name(out) + "_" +
+        type_to_name(C_split);
+
+    if (do_axpby) {
+      kernel_name = kernel_name + "_axbpy";
+    }
+
+    auto kernel = get_steel_gemm_splitk_accum_kernel(
+        /* metal::Device& d = */ d,
+        /* const std::string& kernel_name = */ kernel_name,
+        /* const array& in = */ C_split,
+        /* const array& out = */ out,
+        /* bool axbpy = */ do_axpby);
+    compute_encoder.set_compute_pipeline_state(kernel);
+
+    // Set the arguments for the kernel
+    compute_encoder.set_input_array(C_split, 0);
+    compute_encoder.set_output_array(out, 1);
+    compute_encoder.set_bytes(split_k_partitions, 2);
+    compute_encoder.set_bytes(split_k_partition_stride, 3);
+    compute_encoder.set_bytes(N, 4);
+
+    if (do_axpby) {
+      int ldc = c.strides()[c.ndim() - 2];
+      int fdc = c.strides()[c.ndim() - 1];
+
+      compute_encoder.set_input_array(c, 5);
+      compute_encoder.set_bytes(ldc, 6);
+      compute_encoder.set_bytes(fdc, 7);
+      compute_encoder.set_bytes(alpha, 8);
+      compute_encoder.set_bytes(beta, 9);
+    }
+
+    // Launch enough thread groups for each output
+    MTL::Size grid_dims = MTL::Size(N, M, 1);
+    auto group_dims = get_block_dims(N, M, 1);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+
+  d.add_temporaries(std::move(copies), s.index);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Split matmul routing
+///////////////////////////////////////////////////////////////////////////////
+
+template <bool CHECK_AB>
+void steel_matmul_axpby(
+    const Stream& s,
+    metal::Device& d,
+    const array& a,
+    const array& b,
+    const array& c,
+    array& out,
+    int M,
+    int N,
+    int K,
+    int batch_size_out,
+    int lda,
+    int ldb,
+    bool transpose_a,
+    bool transpose_b,
+    std::vector<array>& copies,
+    Shape batch_shape /* = {} */,
+    Strides A_batch_stride /* = {} */,
+    Strides B_batch_stride /* = {} */,
+    Strides C_batch_stride /* = {} */,
+    float alpha /* = 1.0f */,
+    float beta /* = 0.0f */) {
+  if (batch_shape.empty()) {
+    /////////////////////////////////////////////////////////////////////////////
+    // Check and collapse batch dimensions
+    if constexpr (CHECK_AB) {
+      auto [batch_shape_, A_bstride_, B_bstride_, C_bstride_] =
+          collapse_batches(a, b, c);
+
+      batch_shape = batch_shape_;
+      A_batch_stride = A_bstride_;
+      B_batch_stride = B_bstride_;
+      C_batch_stride = C_bstride_;
+      // Collapse batches into M if needed
+      if (batch_size_out > 1 && !transpose_a && batch_shape.size() == 1 &&
+          a.strides()[a.ndim() - 2] == K && A_batch_stride.back() == M * K &&
+          C_batch_stride.back() == M * c.strides()[c.ndim() - 2] &&
+          B_batch_stride.back() == 0) {
+        M *= batch_shape.back();
+        batch_size_out = 1;
+
+        A_batch_stride = {0};
+        B_batch_stride = {0};
+        C_batch_stride = {0};
+        batch_shape = {1};
+      }
+    } else {
+      auto [batch_shape_, A_bstride_, B_bstride_] = collapse_batches(a, b);
+
+      batch_shape = batch_shape_;
+      A_batch_stride = A_bstride_;
+      B_batch_stride = B_bstride_;
+      // Collapse batches into M if needed
+      if (batch_size_out > 1 && !transpose_a && batch_shape.size() == 1 &&
+          a.strides()[a.ndim() - 2] == K && A_batch_stride.back() == M * K &&
+          B_batch_stride.back() == 0) {
+        M *= batch_shape.back();
+        batch_size_out = 1;
+
+        A_batch_stride = {0};
+        B_batch_stride = {0};
+        batch_shape = {1};
+      }
+    }
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Split K specialization
+
+  int _tm = M / 16;
+  int _tn = N / 16;
+  int _tk = K / 16;
+
+  if (batch_size_out == 1 && (_tm * _tn) <= 32 && _tk >= 8) {
+    return steel_gemm_splitk_axpby<CHECK_AB>(
+        /* const Stream& s = */ s,
+        /* metal::Device& d = */ d,
+        /* const array& a = */ a,
+        /* const array& b = */ b,
+        /* const array& c = */ c,
+        /* array& out = */ out,
+        /* int M = */ M,
+        /* int N = */ N,
+        /* int K = */ K,
+        /* int batch_size_out = */ batch_size_out,
+        /* int lda = */ lda,
+        /* int ldb = */ ldb,
+        /* bool transpose_a = */ transpose_a,
+        /* bool transpose_b = */ transpose_b,
+        /* std::vector<array>& copies = */ copies,
+        /* float alpha = */ alpha,
+        /* float beta = */ beta);
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Regular kernel dispatch
+  auto batch_strides = A_batch_stride;
+  batch_strides.insert(
+      batch_strides.end(), B_batch_stride.begin(), B_batch_stride.end());
+  if (CHECK_AB && !C_batch_stride.empty()) {
+    batch_strides.insert(
+        batch_strides.end(), C_batch_stride.begin(), C_batch_stride.end());
+  }
+
+  int64_t A_batch_stride_ = A_batch_stride.empty() ? 0 : A_batch_stride.back();
+  int64_t B_batch_stride_ = B_batch_stride.empty() ? 0 : B_batch_stride.back();
+  int64_t C_batch_stride_ = C_batch_stride.empty() ? 0 : C_batch_stride.back();
+
+  return steel_matmul_regular_axpby<CHECK_AB>(
+      /* const Stream& s = */ s,
+      /* metal::Device& d = */ d,
+      /* const array& a = */ a,
+      /* const array& b = */ b,
+      /* const array& c = */ c,
+      /* array& out = */ out,
+      /* int M = */ M,
+      /* int N = */ N,
+      /* int K = */ K,
+      /* int batch_size_out = */ batch_size_out,
+      /* int lda = */ lda,
+      /* int ldb = */ ldb,
+      /* int ldd = */ N,
+      /* bool transpose_a = */ transpose_a,
+      /* bool transpose_b = */ transpose_b,
+      /* std::vector<array>& copies = */ copies,
+      /* Shape batch_shape = */ std::move(batch_shape),
+      /* Strides batch_strides = */ std::move(batch_strides),
+      /* int64_t A_batch_stride = */ A_batch_stride_,
+      /* int64_t B_batch_stride = */ B_batch_stride_,
+      /* int64_t matrix_stride_out = */ int64_t(M) * N,
+      /* int64_t C_batch_stride = */ C_batch_stride_,
+      /* float alpha = */ alpha,
+      /* float beta = */ beta);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// GEMV dispatch
+///////////////////////////////////////////////////////////////////////////////
+
+template <bool CHECK_AB = true>
+void gemv_axbpy(
+    const Stream& s,
+    metal::Device& d,
+    const array& a,
+    const array& b,
+    const array& c,
+    array& out,
+    int M,
+    int N,
+    int K,
+    int batch_size_out,
+    int lda,
+    int ldb,
+    bool transpose_a,
+    bool transpose_b,
+    std::vector<array>& copies,
+    Shape batch_shape = {},
+    Strides A_batch_stride = {},
+    Strides B_batch_stride = {},
+    Strides C_batch_stride = {},
+    float alpha = 1.0f,
+    float beta = 0.0f) {
+  // Collect problem info
+  bool is_b_matrix = N != 1;
+
+  auto& mat = is_b_matrix ? b : a;
+  auto& vec = is_b_matrix ? a : b;
+  bool transpose_mat = is_b_matrix ? !transpose_b : transpose_a;
+  int in_vector_len = K;
+  int out_vector_len = is_b_matrix ? N : M;
+
+  int mat_cols = transpose_mat ? out_vector_len : in_vector_len;
+  int mat_rows = transpose_mat ? in_vector_len : out_vector_len;
+  int mat_ld = is_b_matrix ? ldb : lda;
+
+  auto batch_strides_mat = is_b_matrix ? B_batch_stride : A_batch_stride;
+  auto batch_strides_vec = is_b_matrix ? A_batch_stride : B_batch_stride;
+
+  int stride_mat = batch_strides_mat.back();
+  int stride_vec = batch_strides_vec.back();
+
+  // Determine if inputs have simple batching / broadcasting
+  bool contiguous_kernel = (batch_shape.size() == 1);
+
+  int batch_ndim = batch_shape.size();
+
+  // Determine dispatch kernel
+  int tm = 4, tn = 4;
+  int sm = 1, sn = 32;
+  int bm = 1, bn = 1;
+  int n_out_per_tgp;
+  std::ostringstream kname;
+
+  if (transpose_mat) {
+    if (in_vector_len >= 8192 && out_vector_len >= 2048) {
+      sm = 4;
+      sn = 8;
+    } else {
+      sm = 8;
+      sn = 4;
+    }
+
+    if (out_vector_len >= 2048) {
+      bn = 16;
+    } else if (out_vector_len >= 512) {
+      bn = 4;
+    } else {
+      bn = 2;
+    }
+
+    // Specialized kernel for very small outputs
+    tn = out_vector_len < tn ? 1 : tn;
+
+    n_out_per_tgp = bn * sn * tn;
+    kname << "gemv_t_" << type_to_name(out);
+
+  } else {
+    bm = out_vector_len >= 4096 ? 8 : 4;
+    sn = 32;
+
+    if (K <= 64) {
+      bm = 1;
+      sm = 8;
+      sn = 4;
+    } else if (K >= 16 * out_vector_len) {
+      bm = 1;
+      bn = 8;
+    }
+
+    // Specialized kernel for very small outputs
+    tm = out_vector_len < tm ? 1 : tm;
+
+    n_out_per_tgp = bm * sm * tm;
+    kname << "gemv_" << type_to_name(out);
+  }
+
+  const bool do_axpby = CHECK_AB && (alpha != 1.0f || beta != 0.0f);
+
+  // clang-format off
+  kname << "_bm" << bm << "_bn" << bn 
+        << "_sm" << sm << "_sn" << sn 
+        << "_tm" << tm << "_tn" << tn
+        << "_nc" << !contiguous_kernel 
+        << "_axpby" << do_axpby; // clang-format on
+
+  // Encode and dispatch kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel(kname.str());
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  int n_tgp = (out_vector_len + n_out_per_tgp - 1) / n_out_per_tgp;
+  MTL::Size group_dims = MTL::Size(32, bn, bm);
+  MTL::Size grid_dims = MTL::Size(n_tgp, 1, batch_size_out);
+
+  compute_encoder.set_input_array(mat, 0);
+  compute_encoder.set_input_array(vec, 1);
+  compute_encoder.set_output_array(out, 3);
+
+  compute_encoder.set_bytes(in_vector_len, 4);
+  compute_encoder.set_bytes(out_vector_len, 5);
+  compute_encoder.set_bytes(mat_ld, 6);
+
+  compute_encoder.set_bytes(batch_ndim, 9);
+  compute_encoder.set_vector_bytes(batch_shape, 10);
+  compute_encoder.set_vector_bytes(batch_strides_vec, 11);
+  compute_encoder.set_vector_bytes(batch_strides_mat, 12);
+
+  if (do_axpby) {
+    compute_encoder.set_input_array(c, 2);
+
+    compute_encoder.set_bytes(alpha, 7);
+    compute_encoder.set_bytes(beta, 8);
+
+    compute_encoder.set_vector_bytes(C_batch_stride, 13);
+
+    int bias_stride = c.strides()[c.ndim() - 1];
+    compute_encoder.set_bytes(bias_stride, 14);
+  }
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+
+  d.add_temporaries(std::move(copies), s.index);
+}
+
+inline void gemv(
+    const Stream& s,
+    metal::Device& d,
+    const array& a,
+    const array& b,
+    array& out,
+    int M,
+    int N,
+    int K,
+    int batch_size_out,
+    int lda,
+    int ldb,
+    bool transpose_a,
+    bool transpose_b,
+    std::vector<array>& copies,
+    Shape batch_shape = {},
+    Strides A_batch_stride = {},
+    Strides B_batch_stride = {}) {
+  return gemv_axbpy<false>(
+      /* const Stream& s = */ s,
+      /* metal::Device& d = */ d,
+      /* const array& a = */ a,
+      /* const array& b = */ b,
+      /* const array& c = */ b,
+      /* array& out = */ out,
+      /* int M = */ M,
+      /* int N = */ N,
+      /* int K = */ K,
+      /* int batch_size_out = */ batch_size_out,
+      /* int lda = */ lda,
+      /* int ldb = */ ldb,
+      /* bool transpose_a = */ transpose_a,
+      /* bool transpose_b = */ transpose_b,
+      /* std::vector<array>& copies = */ copies,
+      /* Shape batch_shape = */ batch_shape,
+      /* Strides A_batch_stride = */ A_batch_stride,
+      /* Strides B_batch_stride = */ B_batch_stride);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Matmul implementation
+///////////////////////////////////////////////////////////////////////////////
+
+void Matmul::eval_gpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 2);
+  if (!issubdtype(out.dtype(), inexact)) {
+    throw std::runtime_error("[matmul] dtype must be inexact.");
+  }
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  auto& a_pre = inputs[0];
+  auto& b_pre = inputs[1];
+  // Return 0s if either input is empty
+  if (a_pre.size() == 0 || b_pre.size() == 0) {
+    array zero = array(0, a_pre.dtype());
+    fill_gpu(zero, out, s);
+    d.add_temporary(std::move(zero), s.index);
+    return;
+  }
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Init checks and prep
+
+  int M = a_pre.shape(-2);
+  int N = b_pre.shape(-1);
+  int K = a_pre.shape(-1);
+
+  // Keep a vector with copies to be cleared in the completed buffer to release
+  // the arrays
+  std::vector<array> copies;
+  auto [a_transposed, a_cols, a] = check_transpose(copies, s, a_pre, M == 1);
+  auto [b_transposed, b_cols, b] = check_transpose(copies, s, b_pre, N == 1);
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Check and collapse batch dimensions
+
+  auto [batch_shape, A_batch_stride, B_batch_stride] = collapse_batches(a, b);
+
+  auto batch_size_out = out.size() / (size_t(M) * size_t(N));
+
+  // Collapse batches into M if needed
+  if (batch_size_out > 1 && !a_transposed && batch_shape.size() == 1 &&
+      a.strides()[a.ndim() - 2] == K && A_batch_stride.back() == M * K &&
+      B_batch_stride.back() == 0) {
+    M *= batch_shape.back();
+    batch_size_out = 1;
+
+    A_batch_stride = {0};
+    B_batch_stride = {0};
+    batch_shape = {1};
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Gemv specialization
+
+  // Route to gemv if needed
+  if (std::min(M, N) == 1) {
+    return gemv(
+        /* const Stream& s = */ s,
+        /* metal::Device& d = */ d,
+        /* const array& a = */ a,
+        /* const array& b = */ b,
+        /* array& out = */ out,
+        /* int M = */ M,
+        /* int N = */ N,
+        /* int K = */ K,
+        /* int batch_size_out = */ batch_size_out,
+        /* int lda = */ a_cols,
+        /* int ldb = */ b_cols,
+        /* bool transpose_a = */ a_transposed,
+        /* bool transpose_b = */ b_transposed,
+        /* std::vector<array>& copies = */ copies,
+        /* Shape batch_shape = */ std::move(batch_shape),
+        /* Strides A_batch_stride = */ std::move(A_batch_stride),
+        /* Strides B_batch_stride = */ std::move(B_batch_stride));
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Gemm specialization
+
+  return steel_matmul(
+      /* const Stream& s = */ s,
+      /* metal::Device& d = */ d,
+      /* const array& a = */ a,
+      /* const array& b = */ b,
+      /* array& out = */ out,
+      /* int M = */ M,
+      /* int N = */ N,
+      /* int K = */ K,
+      /* int batch_size_out = */ batch_size_out,
+      /* int lda = */ a_cols,
+      /* int ldb = */ b_cols,
+      /* bool transpose_a = */ a_transposed,
+      /* bool transpose_b = */ b_transposed,
+      /* std::vector<array>& copies = */ copies,
+      /* Shape batch_shape = */ std::move(batch_shape),
+      /* Strides A_batch_stride = */ std::move(A_batch_stride),
+      /* Strides B_batch_stride = */ std::move(B_batch_stride));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// AddMM implementation
+///////////////////////////////////////////////////////////////////////////////
+
+void AddMM::eval_gpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 3);
+  if (!issubdtype(out.dtype(), floating)) {
+    throw std::runtime_error(
+        "[matmul] Does not yet support non-floating point types.");
+  }
+
+  // Return 0s if either input is empty
+  if (out.size() == 0) {
+    out.set_data(allocator::malloc(out.nbytes()));
+    return;
+  }
+
+  // Copy c into out and return
+  if (inputs[0].shape(-1) == 0) {
+    copy_gpu(
+        inputs[2],
+        out,
+        inputs[2].flags().row_contiguous ? CopyType::Vector : CopyType::General,
+        stream());
+    return;
+  }
+
+  out.set_data(allocator::malloc(out.nbytes()));
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  auto& a_pre = inputs[0];
+  auto& b_pre = inputs[1];
+  auto& c_pre = inputs[2];
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Init checks and prep
+
+  int M = a_pre.shape(-2);
+  int N = b_pre.shape(-1);
+  int K = a_pre.shape(-1);
+
+  // Keep a vector with copies to be cleared in the completed buffer to release
+  // the arrays
+  std::vector<array> copies;
+  auto [transpose_a, a_cols, a] = check_transpose(copies, s, a_pre, M == 1);
+  auto [transpose_b, b_cols, b] = check_transpose(copies, s, b_pre, N == 1);
+
+  array c = c_pre;
+  int ldc = c.strides()[c.ndim() - 2];
+  int fdc = c.strides()[c.ndim() - 1];
+
+  int lda = a_cols;
+  int ldb = b_cols;
+  int ldd = N;
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Check and collapse batch dimensions
+  auto [batch_shape, A_batch_stride, B_batch_stride, C_batch_stride] =
+      collapse_batches(a, b, c);
+
+  int64_t matrix_stride_out = M * static_cast<int64_t>(N);
+  auto batch_size_out = out.size() / (matrix_stride_out);
+
+  // Collapse batches into M if needed
+  if (batch_size_out > 1 && !transpose_a && batch_shape.size() == 1 &&
+      a.strides()[a.ndim() - 2] == K && A_batch_stride.back() == M * K &&
+      C_batch_stride.back() == M * c.strides()[c.ndim() - 2] &&
+      B_batch_stride.back() == 0) {
+    M *= batch_shape.back();
+    batch_size_out = 1;
+
+    A_batch_stride = {0};
+    B_batch_stride = {0};
+    C_batch_stride = {0};
+    batch_shape = {1};
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Gemv specialization
+
+  // Route to gemv if needed
+  if (std::min(M, N) == 1) {
+    return gemv_axbpy(
+        /* const Stream& s = */ s,
+        /* metal::Device& d = */ d,
+        /* const array& a = */ a,
+        /* const array& b = */ b,
+        /* const array& c = */ c,
+        /* array& out = */ out,
+        /* int M = */ M,
+        /* int N = */ N,
+        /* int K = */ K,
+        /* int batch_size_out = */ batch_size_out,
+        /* int lda = */ lda,
+        /* int ldb = */ ldb,
+        /* bool transpose_a = */ transpose_a,
+        /* bool transpose_b = */ transpose_b,
+        /* std::vector<array>& copies = */ copies,
+        /* Shape batch_shape = */ batch_shape,
+        /* Strides A_batch_stride = */ A_batch_stride,
+        /* Strides B_batch_stride = */ B_batch_stride,
+        /* Strides C_batch_stride = */ C_batch_stride,
+        /* float alpha = */ alpha_,
+        /* float beta = */ beta_);
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Regular addmm dispatch
+
+  return steel_matmul_axpby(
+      /* const Stream& s = */ s,
+      /* metal::Device& d = */ d,
+      /* const array& a = */ a,
+      /* const array& b = */ b,
+      /* const array& c = */ c,
+      /* array& out = */ out,
+      /* int M = */ M,
+      /* int N = */ N,
+      /* int K = */ K,
+      /* int batch_size_out = */ batch_size_out,
+      /* int lda = */ lda,
+      /* int ldb = */ ldb,
+      /* bool transpose_a = */ transpose_a,
+      /* bool transpose_b = */ transpose_b,
+      /* std::vector<array>& copies = */ copies,
+      /* Shape batch_shape = */ batch_shape,
+      /* Strides A_batch_stride = */ A_batch_stride,
+      /* Strides B_batch_stride = */ B_batch_stride,
+      /* Strides B_batch_stride = */ C_batch_stride,
+      /* float alpha = */ alpha_,
+      /* float beta = */ beta_);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// BlockMaskedMM implementation
+///////////////////////////////////////////////////////////////////////////////
+
+void BlockMaskedMM::eval_gpu(const std::vector<array>& inputs, array& out) {
+  using namespace mlx::steel;
+  // assert(inputs.size() == 2);
+  if (!issubdtype(out.dtype(), floating)) {
+    throw std::runtime_error(
+        "[matmul] Does not yet support non-floating point types.");
+  }
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  auto& a_pre = inputs[0];
+  auto& b_pre = inputs[1];
+  // Return 0s if either input is empty
+  if (a_pre.size() == 0 || b_pre.size() == 0) {
+    array zero = array(0, a_pre.dtype());
+    fill_gpu(zero, out, s);
+    d.add_temporary(std::move(zero), s.index);
+    return;
+  }
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Init checks and prep
+
+  int M = a_pre.shape(-2);
+  int N = b_pre.shape(-1);
+  int K = a_pre.shape(-1);
+
+  // Keep a vector with copies to be cleared in the completed buffer to release
+  // the arrays
+  std::vector<array> copies;
+  auto [transpose_a, a_cols, a] = check_transpose(copies, s, a_pre, M == 1);
+  auto [transpose_b, b_cols, b] = check_transpose(copies, s, b_pre, N == 1);
+
+  int lda = a_cols;
+  int ldb = b_cols;
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Check and collapse batch dimensions
+
+  bool has_op_mask = inputs.size() > 3;
+  bool has_out_mask = inputs.size() == 3 || inputs.size() == 5;
+
+  // Prepare kernel name
+  std::string out_mask_nm = has_out_mask ? type_to_name(inputs[2]) : "nomask";
+  std::string op_mask_nm = has_op_mask ? type_to_name(inputs.back()) : "nomask";
+
+  auto get_batch_dims = [](const auto& v) {
+    return decltype(v){v.begin(), v.end() - 2};
+  };
+
+  Shape batch_shape{1};
+  Strides A_batch_stride{0};
+  Strides B_batch_stride{0};
+  Strides outmask_bstride{0};
+  Strides Amask_bstride{0};
+  Strides Bmask_bstride{0};
+  int64_t A_batch_str = 0;
+  int64_t B_batch_str = 0;
+
+  Strides batch_strides;
+
+  if (out.ndim() > 2) {
+    Shape bshape{out.shape().begin(), out.shape().end() - 2};
+    std::vector<Strides> bstrides;
+
+    for (auto& arr : inputs) {
+      bstrides.emplace_back(arr.strides().begin(), arr.strides().end() - 2);
+    }
+
+    // auto [bshape_c, bstrides_c] = collapse_contiguous_dims(bshape, bstrides);
+    batch_shape = bshape;
+    A_batch_str = bstrides[0].back();
+    B_batch_str = bstrides[1].back();
+
+    for (auto& bstr : bstrides) {
+      batch_strides.insert(batch_strides.end(), bstr.begin(), bstr.end());
+    }
+
+    A_batch_stride = bstrides[0];
+    B_batch_stride = bstrides[1];
+
+    if (has_out_mask) {
+      outmask_bstride = bstrides[2];
+    }
+    if (has_op_mask) {
+      Amask_bstride = bstrides[has_out_mask + 2];
+      Bmask_bstride = bstrides[has_out_mask + 3];
+    }
+
+  } else {
+    batch_strides = Strides(inputs.size(), 0);
+  }
+
+  int64_t matrix_stride_out = static_cast<int64_t>(M) * N;
+  size_t batch_size_out = out.size() / (matrix_stride_out);
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Gemv specialization
+
+  // Route to gemv if needed
+  if (std::min(M, N) == 1) {
+    // Collect problem info
+    bool is_b_matrix = N != 1;
+
+    auto& mat = is_b_matrix ? b : a;
+    auto& vec = is_b_matrix ? a : b;
+    bool transpose_mat = is_b_matrix ? !transpose_b : transpose_a;
+    int in_vector_len = K;
+    int out_vector_len = is_b_matrix ? N : M;
+
+    int mat_cols = transpose_mat ? out_vector_len : in_vector_len;
+    int mat_rows = transpose_mat ? in_vector_len : out_vector_len;
+    int mat_ld = is_b_matrix ? b_cols : a_cols;
+
+    auto batch_strides_mat = is_b_matrix ? B_batch_stride : A_batch_stride;
+    auto batch_strides_vec = is_b_matrix ? A_batch_stride : B_batch_stride;
+
+    auto mask_bstrides_mat = is_b_matrix ? Bmask_bstride : Amask_bstride;
+    auto mask_bstrides_vec = is_b_matrix ? Amask_bstride : Bmask_bstride;
+
+    auto mat_mask_idx = int(has_out_mask) + (is_b_matrix ? 3 : 2);
+    auto vec_mask_idx = int(has_out_mask) + (is_b_matrix ? 2 : 3);
+
+    // Determine if inputs have simple batching / broadcasting
+    bool contiguous_kernel = (batch_shape.size() == 1);
+
+    int batch_ndim = batch_shape.size();
+
+    // Determine dispatch kernel
+    int tm = 4, tn = 4;
+    int sm = 1, sn = 32;
+    int bm = 1, bn = 1;
+    int n_out_per_tgp;
+    std::ostringstream kname;
+
+    if (transpose_mat) {
+      sm = 8;
+      sn = 4;
+      bm = 1;
+      bn = (block_size_ == 64 && out_vector_len >= 2048) ? 4 : 2;
+      tm = block_size_ == 32 ? 4 : 8;
+      tn = 4;
+
+      // Specialized kernel for very small outputs
+      tn = out_vector_len < tn ? 1 : tn;
+
+      n_out_per_tgp = bn * sn * tn;
+      kname << "gemv_t";
+
+    } else {
+      if (block_size_ == 32) {
+        sm = 4;
+        sn = 8;
+        bm = 2;
+      } else {
+        sm = 2;
+        sn = 16;
+        bm = out_vector_len >= 512 ? 4 : 2;
+      }
+
+      // Specialized kernel for very small outputs
+      tm = out_vector_len < tm ? 1 : tm;
+
+      n_out_per_tgp = bm * sm * tm;
+      kname << "gemv";
+    }
+
+    kname << "_outmask_" << out_mask_nm;
+    kname << "_opmask_" << op_mask_nm;
+    kname << "_" << type_to_name(out);
+    kname << "_bm" << bm << "_bn" << bn;
+    kname << "_sm" << sm << "_sn" << sn;
+    kname << "_tm" << tm << "_tn" << tn;
+    kname << "_nc" << !contiguous_kernel;
+
+    // Encode and dispatch kernel
+    auto kernel = get_gemv_masked_kernel(
+        d,
+        kname.str(),
+        out,
+        has_out_mask ? std::optional<array>{inputs[2]} : std::nullopt,
+        has_op_mask ? std::optional<array>{inputs.back()} : std::nullopt,
+        transpose_mat,
+        bm,
+        bn,
+        sm,
+        sn,
+        tm,
+        tn,
+        contiguous_kernel);
+
+    auto& compute_encoder = d.get_command_encoder(s.index);
+    compute_encoder.set_compute_pipeline_state(kernel);
+
+    int n_tgp = (out_vector_len + n_out_per_tgp - 1) / n_out_per_tgp;
+    MTL::Size group_dims = MTL::Size(32, bn, bm);
+    MTL::Size grid_dims = MTL::Size(n_tgp, 1, batch_size_out);
+
+    // Get mask params
+    std::vector<int> mask_strides;
+    Strides mask_batch_strides;
+    if (has_out_mask) {
+      auto& out_mask = inputs[2];
+
+      if (transpose_mat) {
+        mask_strides.push_back(out_mask.strides(out.shape(-2) == 1 ? -1 : -2));
+        mask_strides.push_back(out_mask.strides(out.shape(-2) == 1 ? -2 : -1));
+      } else {
+        mask_strides.push_back(out_mask.strides(out.shape(-1) == 1 ? -1 : -2));
+        mask_strides.push_back(out_mask.strides(out.shape(-1) == 1 ? -2 : -1));
+      }
+
+      mask_batch_strides.insert(
+          mask_batch_strides.end(),
+          outmask_bstride.begin(),
+          outmask_bstride.end());
+
+      compute_encoder.set_input_array(out_mask, 20);
+    }
+
+    if (has_op_mask) {
+      auto& mat_mask = inputs[mat_mask_idx];
+
+      if (transpose_mat) {
+        mask_strides.push_back(mat_mask.strides(!is_b_matrix ? -2 : -1));
+        mask_strides.push_back(mat_mask.strides(!is_b_matrix ? -1 : -2));
+      } else {
+        mask_strides.push_back(mat_mask.strides(is_b_matrix ? -2 : -1));
+        mask_strides.push_back(mat_mask.strides(is_b_matrix ? -1 : -2));
+      }
+
+      mask_batch_strides.insert(
+          mask_batch_strides.end(),
+          mask_bstrides_mat.begin(),
+          mask_bstrides_mat.end());
+
+      compute_encoder.set_input_array(mat_mask, 21);
+
+      auto& vec_mask = inputs[vec_mask_idx];
+      if (transpose_mat) {
+        mask_strides.push_back(vec_mask.strides(vec.shape(-2) == 1 ? -1 : -2));
+        mask_strides.push_back(vec_mask.strides(vec.shape(-2) == 1 ? -2 : -1));
+      } else {
+        mask_strides.push_back(vec_mask.strides(vec.shape(-1) == 1 ? -1 : -2));
+        mask_strides.push_back(vec_mask.strides(vec.shape(-1) == 1 ? -2 : -1));
+      }
+
+      mask_batch_strides.insert(
+          mask_batch_strides.end(),
+          mask_bstrides_vec.begin(),
+          mask_bstrides_vec.end());
+
+      compute_encoder.set_input_array(vec_mask, 22);
+    }
+
+    // Get gemv params
+    compute_encoder.set_input_array(mat, 0);
+    compute_encoder.set_input_array(vec, 1);
+    compute_encoder.set_output_array(out, 3);
+
+    compute_encoder.set_bytes(in_vector_len, 4);
+    compute_encoder.set_bytes(out_vector_len, 5);
+    compute_encoder.set_bytes(mat_ld, 6);
+    compute_encoder.set_bytes(batch_ndim, 9);
+    compute_encoder.set_vector_bytes(batch_shape, 10);
+    compute_encoder.set_vector_bytes(batch_strides_vec, 11);
+    compute_encoder.set_vector_bytes(batch_strides_mat, 12);
+
+    compute_encoder.set_vector_bytes(mask_strides, 23);
+    compute_encoder.set_vector_bytes(mask_batch_strides, 24);
+
+    compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+
+    d.add_temporaries(std::move(copies), s.index);
+    return;
+  }
+
+  /////////////////////////////////////////////////////////////////////////////
+  // Regular kernel dispatch
+
+  // Determine dispatch kernel
+  int bm = block_size_, bn = block_size_, bk = 16;
+  int wm = 2, wn = 2;
+  bool mn_aligned = M % bm == 0 && N % bn == 0;
+  bool k_aligned = K % bk == 0;
+
+  std::ostringstream kname;
+  kname << "steel_gemm_block_outmask_" << out_mask_nm << "_opmask_"
+        << op_mask_nm << "_" << (transpose_a ? 't' : 'n')
+        << (transpose_b ? 't' : 'n') << "_" << type_to_name(a) << "_"
+        << type_to_name(out) << "_bm" << bm << "_bn" << bn << "_bk" << bk
+        << "_wm" << wm << "_wn" << wn << "_MN_" << (mn_aligned ? "t" : "n")
+        << "aligned"
+        << "_K_" << (k_aligned ? "t" : "n") << "aligned";
+
+  // Encode and dispatch kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = get_steel_gemm_masked_kernel(
+      d,
+      kname.str(),
+      out,
+      has_out_mask ? std::optional<array>{inputs[2]} : std::nullopt,
+      has_op_mask ? std::optional<array>{inputs.back()} : std::nullopt,
+      transpose_a,
+      transpose_b,
+      bm,
+      bn,
+      bk,
+      wm,
+      wn,
+      mn_aligned,
+      k_aligned);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Use problem size to determine threadblock swizzle
+  int tn = (N + bn - 1) / bn;
+  int tm = (M + bm - 1) / bm;
+
+  // TODO: Explore device-based tuning for swizzle
+  int swizzle_log = 0; // tm >= 6 ? 3 : (tm <= 3 ? 0 : 2);
+
+  // Prepare steel matmul params
+  GEMMParams params{
+      /* const int M = */ M,
+      /* const int N = */ N,
+      /* const int K = */ K,
+      /* const int lda = */ lda,
+      /* const int ldb = */ ldb,
+      /* const int ldd = */ N,
+      /* const int tiles_n = */ tn,
+      /* const int tiles_m = */ tm,
+      /* const int64_t batch_stride_a = */ A_batch_str,
+      /* const int64_t batch_stride_b = */ B_batch_str,
+      /* const int64_t batch_stride_d = */ matrix_stride_out,
+      /* const int swizzle_log = */ swizzle_log,
+      /* const int gemm_k_iterations_aligned = */ (K / bk),
+      /* const int batch_ndim = */ int(batch_shape.size())};
+
+  // Prepare launch grid params
+  int tile = 1 << swizzle_log;
+  tm = (tm + tile - 1) / tile;
+  tn = tn * tile;
+
+  MTL::Size group_dims = MTL::Size(32, wn, wm);
+  MTL::Size grid_dims = MTL::Size(tn, tm, batch_size_out);
+
+  std::vector<int> mask_strides;
+
+  if (has_out_mask) {
+    auto& out_mask = inputs[2];
+    mask_strides.push_back(*(out_mask.strides().end() - 1));
+    mask_strides.push_back(*(out_mask.strides().end() - 2));
+
+    compute_encoder.set_input_array(out_mask, 10);
+  }
+
+  if (has_op_mask) {
+    auto& lhs_mask = inputs[2 + has_out_mask];
+    mask_strides.push_back(*(lhs_mask.strides().end() - 1));
+    mask_strides.push_back(*(lhs_mask.strides().end() - 2));
+
+    compute_encoder.set_input_array(lhs_mask, 11);
+
+    auto& rhs_mask = inputs[3 + has_out_mask];
+    mask_strides.push_back(*(rhs_mask.strides().end() - 1));
+    mask_strides.push_back(*(rhs_mask.strides().end() - 2));
+
+    compute_encoder.set_input_array(rhs_mask, 12);
+  }
+
+  // Launch kernel
+  compute_encoder.set_input_array(a, 0);
+  compute_encoder.set_input_array(b, 1);
+  compute_encoder.set_output_array(out, 3);
+
+  compute_encoder.set_bytes(params, 4);
+
+  compute_encoder.set_vector_bytes(batch_shape, 6);
+  compute_encoder.set_vector_bytes(batch_strides, 7);
+
+  compute_encoder.set_vector_bytes(mask_strides, 13);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+
+  d.add_temporaries(std::move(copies), s.index);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// GatherMM implementation
+///////////////////////////////////////////////////////////////////////////////
+
+void gather_mm_rhs(
+    const array& a_,
+    const array& b_,
+    const array& indices_,
+    array& out,
+    metal::Device& d,
+    const Stream& s) {
+  array indices = ensure_row_contiguous(indices_, d, s);
+  auto [transpose_b, ldb, b] = ensure_batch_contiguous(b_, d, s);
+
+  // Broadcast a with indices. If we are here that means lhs_indices were not
+  // provided so the lhs_indices are implied to be the shape of a broadcasted
+  // with rhs_indices. We need only broadcast a and copy it as if applying the
+  // lhs_indices.
+  auto broadcast_with_indices = [&d, &s, &indices](const array& x) {
+    if (x.size() / x.shape(-2) / x.shape(-1) == indices.size()) {
+      return ensure_row_contiguous(x, d, s);
+    }
+
+    auto x_shape = indices.shape();
+    x_shape.push_back(x.shape(-2));
+    x_shape.push_back(x.shape(-1));
+    array new_x(std::move(x_shape), x.dtype(), nullptr, {});
+    broadcast(x, new_x);
+    return ensure_row_contiguous(new_x, d, s);
+  };
+  array a = broadcast_with_indices(a_);
+
+  // Extract the matmul shapes
+  int K = a.shape(-1);
+  int M = a.size() / K;
+  int N = b.shape(-1);
+  int lda = a.strides()[a.ndim() - 2]; // should be K
+
+  // Define the dispatch blocks
+  int bm = 16, bn = 64, bk = 16;
+  int wm = 1, wn = 2;
+
+  const bool align_M = (M % bm) == 0;
+  const bool align_N = (N % bn) == 0;
+  const bool align_K = (K % bk) == 0;
+
+  // Define the kernel name
+  std::string base_name;
+  base_name.reserve(64);
+  concatenate(
+      base_name,
+      "steel_gather_mm_rhs_n",
+      transpose_b ? 't' : 'n',
+      '_',
+      type_to_name(a),
+      '_',
+      type_to_name(out),
+      "_bm",
+      bm,
+      "_bn",
+      bn,
+      "_bk",
+      bk,
+      "_wm",
+      wm,
+      "_wn",
+      wn);
+
+  metal::MTLFCList func_consts = {
+      {&align_M, MTL::DataType::DataTypeBool, 200},
+      {&align_N, MTL::DataType::DataTypeBool, 201},
+      {&align_K, MTL::DataType::DataTypeBool, 202},
+  };
+
+  // And the kernel hash that includes the function constants
+  std::string hash_name;
+  hash_name.reserve(128);
+  concatenate(
+      hash_name,
+      base_name,
+      "_align_M_",
+      align_M ? 't' : 'n',
+      "_align_N_",
+      align_N ? 't' : 'n',
+      "_align_K_",
+      align_K ? 't' : 'n');
+
+  // Get and set the kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = get_steel_gemm_gather_kernel(
+      d,
+      base_name,
+      hash_name,
+      func_consts,
+      out,
+      false,
+      transpose_b,
+      bm,
+      bn,
+      bk,
+      wm,
+      wn,
+      true);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Prepare the matmul params
+  auto batch_stride_b = b.ndim() > 2 ? b.strides()[b.ndim() - 3] : b.size();
+  steel::GEMMParams params{
+      /* const int M = */ M,
+      /* const int N = */ N,
+      /* const int K = */ K,
+      /* const int lda = */ lda,
+      /* const int ldb = */ static_cast<int>(ldb),
+      /* const int ldd = */ N,
+      /* const int tiles_n = */ (N + bn - 1) / bn,
+      /* const int tiles_m = */ (M + bm - 1) / bm,
+      /* const int64_t batch_stride_a = */ 0,
+      /* const int64_t batch_stride_b = */ static_cast<int64_t>(batch_stride_b),
+      /* const int64_t batch_stride_d = */ 0,
+      /* const int swizzle_log = */ 0,
+      /* const int gemm_k_iterations_aligned = */ (K / bk),
+      /* const int batch_ndim = */ 0};
+
+  // Prepare the grid
+  MTL::Size group_dims = MTL::Size(32, wn, wm);
+  MTL::Size grid_dims = MTL::Size(params.tiles_n, params.tiles_m, 1);
+
+  // Launch kernel
+  compute_encoder.set_input_array(a, 0);
+  compute_encoder.set_input_array(b, 1);
+  compute_encoder.set_input_array(indices, 2);
+  compute_encoder.set_output_array(out, 3);
+  compute_encoder.set_bytes(params, 4);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void gather_mv(
+    const array& mat_,
+    const array& vec_,
+    const array& mat_indices_,
+    const array& vec_indices_,
+    array& out,
+    int N,
+    int K,
+    bool is_mv,
+    metal::Device& d,
+    const Stream& s) {
+  // Copy if needed
+  std::vector<array> copies;
+  auto [transpose_mat, mat_cols, mat] =
+      check_transpose(copies, s, mat_, N == 1);
+  auto [transpose_vec, vec_cols, vec] = check_transpose(copies, s, vec_, true);
+  d.add_temporaries(std::move(copies), s.index);
+
+  // If we are doing vector matrix instead of matrix vector we need to flip the
+  // matrix transposition. Basically m @ v = v @ m.T assuming that v is treated
+  // as a one dimensional array.
+  transpose_mat = (!is_mv) ^ transpose_mat;
+
+  // Define some shapes
+  int in_vector_len = K;
+  int out_vector_len = N;
+  int mat_ld = mat_cols;
+
+  int batch_size_out = out.size() / N;
+  int batch_ndim = out.ndim() - 2;
+  int batch_ndim_mat = mat.ndim() - 2;
+  int batch_ndim_vec = vec.ndim() - 2;
+  Strides index_strides = vec_indices_.strides();
+  index_strides.insert(
+      index_strides.end(),
+      mat_indices_.strides().begin(),
+      mat_indices_.strides().end());
+
+  // Determine dispatch kernel
+  int tm = 4, tn = 4;
+  int sm = 1, sn = 32;
+  int bm = 1, bn = 1;
+  int n_out_per_tgp;
+  std::ostringstream kname;
+
+  if (transpose_mat) {
+    if (in_vector_len >= 8192 && out_vector_len >= 2048) {
+      sm = 4;
+      sn = 8;
+    } else {
+      sm = 8;
+      sn = 4;
+    }
+
+    if (out_vector_len >= 2048) {
+      bn = 16;
+    } else if (out_vector_len >= 512) {
+      bn = 4;
+    } else {
+      bn = 2;
+    }
+
+    // Specialized kernel for very small outputs
+    tn = out_vector_len < tn ? 1 : tn;
+
+    n_out_per_tgp = bn * sn * tn;
+    kname << "gemv_t_gather_" << type_to_name(out);
+
+  } else {
+    bm = out_vector_len >= 4096 ? 8 : 4;
+    sn = 32;
+
+    // Specialized kernel for very small outputs
+    tm = out_vector_len < tm ? 1 : tm;
+
+    n_out_per_tgp = bm * sm * tm;
+    kname << "gemv_gather_" << type_to_name(out);
+  }
+
+  kname << "_bm" << bm << "_bn" << bn << "_sm" << sm << "_sn" << sn << "_tm"
+        << tm << "_tn" << tn;
+
+  // Encode and dispatch kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel(kname.str());
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  int n_tgp = (out_vector_len + n_out_per_tgp - 1) / n_out_per_tgp;
+  MTL::Size group_dims = MTL::Size(32, bn, bm);
+  MTL::Size grid_dims = MTL::Size(n_tgp, 1, batch_size_out);
+
+  compute_encoder.set_input_array(mat, 0);
+  compute_encoder.set_input_array(vec, 1);
+  compute_encoder.set_output_array(out, 3);
+
+  compute_encoder.set_bytes(in_vector_len, 4);
+  compute_encoder.set_bytes(out_vector_len, 5);
+  compute_encoder.set_bytes(mat_ld, 6);
+
+  compute_encoder.set_bytes(batch_ndim, 9);
+  compute_encoder.set_vector_bytes(out.shape(), 10);
+  compute_encoder.set_vector_bytes(index_strides, 11);
+
+  compute_encoder.set_bytes(batch_ndim_vec, 12);
+  compute_encoder.set_vector_bytes(vec.shape(), 13);
+  compute_encoder.set_vector_bytes(vec.strides(), 14);
+
+  compute_encoder.set_bytes(batch_ndim_mat, 15);
+  compute_encoder.set_vector_bytes(mat.shape(), 16);
+  compute_encoder.set_vector_bytes(mat.strides(), 17);
+
+  compute_encoder.set_input_array(vec_indices_, 18);
+  compute_encoder.set_input_array(mat_indices_, 19);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void gather_mm(
+    const array& a_,
+    const array& b_,
+    const array& lhs_indices,
+    const array& rhs_indices,
+    array& out,
+    int M,
+    int N,
+    int K,
+    metal::Device& d,
+    const Stream& s) {
+  // Copy if needed
+  std::vector<array> copies;
+  auto [transpose_a, lda, a] = check_transpose(copies, s, a_, false);
+  auto [transpose_b, ldb, b] = check_transpose(copies, s, b_, false);
+  d.add_temporaries(std::move(copies), s.index);
+
+  // Determine dispatch kernel
+  int bm = 64, bn = 64, bk = 16;
+  int wm = 2, wn = 2;
+  size_t batch_size_out = out.size() / M / N;
+  int batch_ndim = out.ndim() - 2;
+  int batch_ndim_a = a.ndim() - 2;
+  int batch_ndim_b = b.ndim() - 2;
+
+  char devc = d.get_architecture().back();
+  GEMM_TPARAM_MACRO(devc)
+
+  const bool has_batch = batch_ndim > 1;
+  const bool align_M = (M % bm) == 0;
+  const bool align_N = (N % bn) == 0;
+  const bool align_K = (K % bk) == 0;
+
+  // Define the kernel name
+  std::string base_name;
+  base_name.reserve(128);
+  concatenate(
+      base_name,
+      "steel_gather_mm_",
+      transpose_a ? 't' : 'n',
+      transpose_b ? 't' : 'n',
+      "_",
+      type_to_name(a),
+      "_",
+      type_to_name(out),
+      "_bm",
+      bm,
+      "_bn",
+      bn,
+      "_bk",
+      bk,
+      "_wm",
+      wm,
+      "_wn",
+      wn);
+
+  metal::MTLFCList func_consts = {
+      {&has_batch, MTL::DataType::DataTypeBool, 10},
+      {&align_M, MTL::DataType::DataTypeBool, 200},
+      {&align_N, MTL::DataType::DataTypeBool, 201},
+      {&align_K, MTL::DataType::DataTypeBool, 202},
+  };
+
+  // And the kernel hash that includes the function constants
+  std::string hash_name;
+  hash_name.reserve(128);
+  concatenate(
+      hash_name,
+      base_name,
+      "_has_batch_",
+      has_batch ? 't' : 'n',
+      "_align_M_",
+      align_M ? 't' : 'n',
+      "_align_N_",
+      align_N ? 't' : 'n',
+      "_align_K_",
+      align_K ? 't' : 'n');
+
+  // Get and set the kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = get_steel_gemm_gather_kernel(
+      d,
+      base_name,
+      hash_name,
+      func_consts,
+      out,
+      transpose_a,
+      transpose_b,
+      bm,
+      bn,
+      bk,
+      wm,
+      wn,
+      false);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Prepare the matmul params
+  steel::GEMMParams params{
+      /* const int M = */ M,
+      /* const int N = */ N,
+      /* const int K = */ K,
+      /* const int lda = */ static_cast<int>(lda),
+      /* const int ldb = */ static_cast<int>(ldb),
+      /* const int ldd = */ N,
+      /* const int tiles_n = */ (N + bn - 1) / bn,
+      /* const int tiles_m = */ (M + bm - 1) / bm,
+      /* const int64_t batch_stride_a = */
+      (batch_ndim > 0) ? lhs_indices.strides()[0] : 0,
+      /* const int64_t batch_stride_b = */
+      (batch_ndim > 0) ? rhs_indices.strides()[0] : 0,
+      /* const int64_t batch_stride_d = */ M * N,
+      /* const int swizzle_log = */ 0,
+      /* const int gemm_k_iterations_aligned = */ (K / bk),
+      /* const int batch_ndim = */ batch_ndim};
+
+  // Prepare the grid
+  MTL::Size group_dims = MTL::Size(32, wn, wm);
+  MTL::Size grid_dims =
+      MTL::Size(params.tiles_n, params.tiles_m, batch_size_out);
+
+  // Launch kernel
+  compute_encoder.set_input_array(a, 0);
+  compute_encoder.set_input_array(b, 1);
+  compute_encoder.set_input_array(lhs_indices, 2);
+  compute_encoder.set_input_array(rhs_indices, 3);
+  compute_encoder.set_output_array(out, 4);
+  compute_encoder.set_bytes(params, 5);
+  compute_encoder.set_vector_bytes(lhs_indices.shape(), 6);
+  compute_encoder.set_vector_bytes(lhs_indices.strides(), 7);
+  compute_encoder.set_vector_bytes(rhs_indices.strides(), 8);
+  compute_encoder.set_bytes(batch_ndim_a, 9);
+  compute_encoder.set_vector_bytes(a.shape(), 10);
+  compute_encoder.set_vector_bytes(a.strides(), 11);
+  compute_encoder.set_bytes(batch_ndim_b, 12);
+  compute_encoder.set_vector_bytes(b.shape(), 13);
+  compute_encoder.set_vector_bytes(b.strides(), 14);
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void GatherMM::eval_gpu(const std::vector<array>& inputs, array& out) {
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  auto& lhs_indices = inputs[2];
+  auto& rhs_indices = inputs[3];
+
+  // Return 0s if either input is empty
+  if (a.size() == 0 || b.size() == 0) {
+    array zero = array(0, a.dtype());
+    fill_gpu(zero, out, s);
+    d.add_temporary(std::move(zero), s.index);
+    return;
+  }
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  // Extract shapes from inputs.
+  int M = a.shape(-2);
+  int N = b.shape(-1);
+  int K = a.shape(-1);
+
+  // We are walking a in order and b is also in order so we can batch up the
+  // matmuls and reuse reading a and b.
+  if (M == 1 && right_sorted_ == true) {
+    gather_mm_rhs(a, b, rhs_indices, out, d, s);
+    return;
+  }
+
+  // Route to gather gemv if any of a or b are vectors
+  if (M == 1) {
+    gather_mv(b, a, rhs_indices, lhs_indices, out, N, K, false, d, s);
+    return;
+  }
+  if (N == 1) {
+    gather_mv(a, b, lhs_indices, rhs_indices, out, M, K, true, d, s);
+    return;
+  }
+
+  // Route to non specialized gather mm
+  gather_mm(a, b, lhs_indices, rhs_indices, out, M, N, K, d, s);
+}
+
+void segmented_mm(
+    const array& a_,
+    const array& b_,
+    const array& segments_,
+    array& out,
+    int M,
+    int N,
+    int K,
+    metal::Device& d,
+    const Stream& s) {
+  auto check_segments_layout = [&d, &s](const array& x) {
+    // Contiguous so return early
+    if (x.flags().row_contiguous) {
+      return std::make_tuple(true, x);
+    }
+
+    bool rc = true;
+    for (int i = 0; i < x.ndim() - 2; i++) {
+      rc &=
+          (x.strides(i + 1) * x.shape(i) == x.strides(i)) || (x.shape(i) == 1);
+    }
+    rc &= x.strides(x.ndim() - 1) == 1;
+    if (x.ndim() > 1) {
+      rc &= x.strides(x.ndim() - 2) == 1;
+    }
+
+    if (rc) {
+      return std::make_tuple(false, x);
+    }
+
+    array x_copy = contiguous_copy_gpu(x, s);
+    d.add_temporary(x_copy, s.index);
+    return std::make_tuple(true, x_copy);
+  };
+
+  // Copy if needed
+  std::vector<array> copies;
+  auto [transpose_a, lda, a] = check_transpose(copies, s, a_, false);
+  auto [transpose_b, ldb, b] = check_transpose(copies, s, b_, false);
+  auto [segments_contiguous, segments] = check_segments_layout(segments_);
+  d.add_temporaries(std::move(copies), s.index);
+
+  // Determine dispatch kernel
+  int bm = 64, bn = 64, bk = 16;
+  int wm = 2, wn = 2;
+  size_t batch_size_out = out.size() / M / N;
+
+  char devc = d.get_architecture().back();
+  GEMM_TPARAM_MACRO(devc)
+
+  const bool align_M = (M % bm) == 0;
+  const bool align_N = (N % bn) == 0;
+
+  // Define the kernel name
+  std::string base_name;
+  base_name.reserve(128);
+  concatenate(
+      base_name,
+      "steel_segmented_mm_",
+      transpose_a ? 't' : 'n',
+      transpose_b ? 't' : 'n',
+      "_",
+      type_to_name(a),
+      "_",
+      type_to_name(out),
+      "_bm",
+      bm,
+      "_bn",
+      bn,
+      "_bk",
+      bk,
+      "_wm",
+      wm,
+      "_wn",
+      wn);
+
+  metal::MTLFCList func_consts = {
+      {&segments_contiguous, MTL::DataType::DataTypeBool, 199},
+      {&align_M, MTL::DataType::DataTypeBool, 200},
+      {&align_N, MTL::DataType::DataTypeBool, 201},
+  };
+
+  // And the kernel hash that includes the function constants
+  std::string hash_name;
+  hash_name.reserve(128);
+  concatenate(
+      hash_name,
+      base_name,
+      "_segments_contiguous_",
+      segments_contiguous ? 't' : 'n',
+      "_align_M_",
+      align_M ? 't' : 'n',
+      "_align_N_",
+      align_N ? 't' : 'n');
+
+  // Get and set the kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = get_steel_gemm_segmented_kernel(
+      d,
+      base_name,
+      hash_name,
+      func_consts,
+      out,
+      transpose_a,
+      transpose_b,
+      bm,
+      bn,
+      bk,
+      wm,
+      wn);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Prepare the matmul params
+  steel::GEMMParams params{
+      /* const int M = */ M,
+      /* const int N = */ N,
+      /* const int K = */ K,
+      /* const int lda = */ static_cast<int>(lda),
+      /* const int ldb = */ static_cast<int>(ldb),
+      /* const int ldd = */ N,
+      /* const int tiles_n = */ (N + bn - 1) / bn,
+      /* const int tiles_m = */ (M + bm - 1) / bm,
+      /* const int64_t batch_stride_a = */ 0,
+      /* const int64_t batch_stride_b = */ 0,
+      /* const int64_t batch_stride_d = */ M * N,
+      /* const int swizzle_log = */ 0,
+      /* const int gemm_k_iterations_aligned = */ 0,
+      /* const int batch_ndim = */ 0};
+
+  // Prepare the grid
+  MTL::Size group_dims = MTL::Size(32, wn, wm);
+  MTL::Size grid_dims =
+      MTL::Size(params.tiles_n, params.tiles_m, batch_size_out);
+
+  // Launch kernel
+  compute_encoder.set_input_array(a, 0);
+  compute_encoder.set_input_array(b, 1);
+  compute_encoder.set_input_array(segments, 2);
+  compute_encoder.set_output_array(out, 3);
+  compute_encoder.set_bytes(params, 4);
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void SegmentedMM::eval_gpu(const std::vector<array>& inputs, array& out) {
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  auto& segments = inputs[2];
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  // Extract shapes from inputs.
+  int M = a.shape(-2);
+  int N = b.shape(-1);
+  int K = a.shape(-1);
+
+  segmented_mm(a, b, segments, out, M, N, K, d, s);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/matmul.h b/ml-stable-diffusion/mlx/mlx/backend/metal/matmul.h
new file mode 100644
index 0000000000000000000000000000000000000000..218664b1ffe3ba8d844a3fc72beb3c9f7d8e5b9a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/matmul.h
@@ -0,0 +1,144 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/device.h"
+
+namespace mlx::core {
+
+template <bool CHECK_AB = true>
+void steel_matmul_regular_axpby(
+    const Stream& s,
+    metal::Device& d,
+    const array& a,
+    const array& b,
+    const array& c,
+    array& out,
+    int M,
+    int N,
+    int K,
+    int batch_size_out,
+    int lda,
+    int ldb,
+    int ldd,
+    bool transpose_a,
+    bool transpose_b,
+    std::vector<array>& copies,
+    Shape batch_shape,
+    Strides batch_strides,
+    int64_t A_batch_stride,
+    int64_t B_batch_stride,
+    int64_t matrix_stride_out,
+    int64_t C_batch_stride = 0,
+    float alpha = 1.0f,
+    float beta = 0.0f);
+
+inline void steel_matmul_regular(
+    const Stream& s,
+    metal::Device& d,
+    const array& a,
+    const array& b,
+    array& out,
+    int M,
+    int N,
+    int K,
+    int batch_size_out,
+    int lda,
+    int ldb,
+    int ldd,
+    bool transpose_a,
+    bool transpose_b,
+    std::vector<array>& copies,
+    Shape batch_shape,
+    Strides batch_strides,
+    int64_t A_batch_stride,
+    int64_t B_batch_stride,
+    int64_t matrix_stride_out) {
+  return steel_matmul_regular_axpby<false>(
+      /* const Stream& s = */ s,
+      /* metal::Device& d = */ d,
+      /* const array& a = */ a,
+      /* const array& b = */ b,
+      /* const array& c = */ b,
+      /* array& out = */ out,
+      /* int M = */ M,
+      /* int N = */ N,
+      /* int K = */ K,
+      /* int batch_size_out = */ batch_size_out,
+      /* int lda = */ lda,
+      /* int ldb = */ ldb,
+      /* int ldd = */ ldd,
+      /* bool transpose_a = */ transpose_a,
+      /* bool transpose_b = */ transpose_b,
+      /* std::vector<array>& copies = */ copies,
+      /* Shape batch_shape = */ batch_shape,
+      /* Strides batch_strides = */ batch_strides,
+      /* int64_t A_batch_stride = */ A_batch_stride,
+      /* int64_t B_batch_stride = */ B_batch_stride,
+      /* int64_t matrix_stride_out = */ matrix_stride_out);
+}
+
+template <bool CHECK_AB = true>
+void steel_matmul_axpby(
+    const Stream& s,
+    metal::Device& d,
+    const array& a,
+    const array& b,
+    const array& c,
+    array& out,
+    int M,
+    int N,
+    int K,
+    int batch_size_out,
+    int lda,
+    int ldb,
+    bool transpose_a,
+    bool transpose_b,
+    std::vector<array>& copies,
+    Shape batch_shape = {},
+    Strides A_batch_stride = {},
+    Strides B_batch_stride = {},
+    Strides C_batch_stride = {},
+    float alpha = 1.0f,
+    float beta = 0.0f);
+
+inline void steel_matmul(
+    const Stream& s,
+    metal::Device& d,
+    const array& a,
+    const array& b,
+    array& out,
+    int M,
+    int N,
+    int K,
+    int batch_size_out,
+    int lda,
+    int ldb,
+    bool transpose_a,
+    bool transpose_b,
+    std::vector<array>& copies,
+    Shape batch_shape = {},
+    Strides A_batch_stride = {},
+    Strides B_batch_stride = {}) {
+  return steel_matmul_axpby<false>(
+      /* const Stream& s = */ s,
+      /* metal::Device& d = */ d,
+      /* const array& a = */ a,
+      /* const array& b = */ b,
+      /* const array& c = */ b,
+      /* array& out = */ out,
+      /* int M = */ M,
+      /* int N = */ N,
+      /* int K = */ K,
+      /* int batch_size_out = */ batch_size_out,
+      /* int lda = */ lda,
+      /* int ldb = */ ldb,
+      /* bool transpose_a = */ transpose_a,
+      /* bool transpose_b = */ transpose_b,
+      /* std::vector<array>& copies = */ copies,
+      /* Shape batch_shape = */ batch_shape,
+      /* Strides A_batch_stride = */ A_batch_stride,
+      /* Strides B_batch_stride = */ B_batch_stride);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/metal.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/metal.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..888207322398d34f836a065b4dc7fe01d1eb845b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/metal.cpp
@@ -0,0 +1,84 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <memory>
+
+#include <sys/sysctl.h>
+
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/metal.h"
+#include "mlx/backend/metal/utils.h"
+
+namespace mlx::core::metal {
+
+bool is_available() {
+  return true;
+}
+
+void start_capture(std::string path, id object) {
+  auto pool = new_scoped_memory_pool();
+
+  auto descriptor = MTL::CaptureDescriptor::alloc()->init();
+  descriptor->setCaptureObject(object);
+
+  if (!path.empty()) {
+    auto string = NS::String::string(path.c_str(), NS::UTF8StringEncoding);
+    auto url = NS::URL::fileURLWithPath(string);
+    descriptor->setDestination(MTL::CaptureDestinationGPUTraceDocument);
+    descriptor->setOutputURL(url);
+  }
+
+  auto manager = MTL::CaptureManager::sharedCaptureManager();
+  NS::Error* error;
+  bool started = manager->startCapture(descriptor, &error);
+  descriptor->release();
+  if (!started) {
+    std::ostringstream msg;
+    msg << "[metal::start_capture] Failed to start: "
+        << error->localizedDescription()->utf8String();
+    throw std::runtime_error(msg.str());
+  }
+}
+
+void start_capture(std::string path) {
+  auto& device = metal::device(mlx::core::Device::gpu);
+  return start_capture(path, device.mtl_device());
+}
+
+void stop_capture() {
+  auto pool = new_scoped_memory_pool();
+  auto manager = MTL::CaptureManager::sharedCaptureManager();
+  manager->stopCapture();
+}
+
+const std::unordered_map<std::string, std::variant<std::string, size_t>>&
+device_info() {
+  auto init_device_info = []()
+      -> std::unordered_map<std::string, std::variant<std::string, size_t>> {
+    auto pool = new_scoped_memory_pool();
+    auto raw_device = device(default_device()).mtl_device();
+    auto name = std::string(raw_device->name()->utf8String());
+    auto arch = std::string(raw_device->architecture()->name()->utf8String());
+
+    size_t memsize = 0;
+    size_t length = sizeof(memsize);
+    sysctlbyname("hw.memsize", &memsize, &length, NULL, 0);
+
+    size_t rsrc_limit = 0;
+    sysctlbyname("iogpu.rsrc_limit", &rsrc_limit, &length, NULL, 0);
+    if (rsrc_limit == 0) {
+      rsrc_limit = 499000;
+    }
+
+    return {
+        {"device_name", name},
+        {"architecture", arch},
+        {"max_buffer_length", raw_device->maxBufferLength()},
+        {"max_recommended_working_set_size",
+         raw_device->recommendedMaxWorkingSetSize()},
+        {"memory_size", memsize},
+        {"resource_limit", rsrc_limit}};
+  };
+  static auto device_info_ = init_device_info();
+  return device_info_;
+}
+
+} // namespace mlx::core::metal
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/metal.h b/ml-stable-diffusion/mlx/mlx/backend/metal/metal.h
new file mode 100644
index 0000000000000000000000000000000000000000..af2995b63b2a70303b412ab99649ee8a700cb1dd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/metal.h
@@ -0,0 +1,22 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include <variant>
+
+namespace mlx::core::metal {
+
+/* Check if the Metal backend is available. */
+bool is_available();
+
+/** Capture a GPU trace, saving it to an absolute file `path` */
+void start_capture(std::string path = "");
+void stop_capture();
+
+/** Get information about the GPU and system settings. */
+const std::unordered_map<std::string, std::variant<std::string, size_t>>&
+device_info();
+
+} // namespace mlx::core::metal
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9d6a734611778a3bef29992068da18a63408da8e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/no_metal.cpp
@@ -0,0 +1,42 @@
+// Copyright © 2025 Apple Inc.
+
+#include <stdexcept>
+
+#include "mlx/backend/metal/metal.h"
+#include "mlx/fast.h"
+
+namespace mlx::core {
+
+namespace metal {
+
+bool is_available() {
+  return false;
+}
+
+void start_capture(std::string) {}
+void stop_capture() {}
+
+const std::unordered_map<std::string, std::variant<std::string, size_t>>&
+device_info() {
+  throw std::runtime_error(
+      "[metal::device_info] Cannot get device info without metal backend");
+};
+
+} // namespace metal
+
+namespace fast {
+
+CustomKernelFunction metal_kernel(
+    const std::string&,
+    const std::vector<std::string>&,
+    const std::vector<std::string>&,
+    const std::string&,
+    const std::string&,
+    bool,
+    bool) {
+  throw std::runtime_error("[metal_kernel] No Metal back-end.");
+}
+
+} // namespace fast
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/nojit_kernels.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/nojit_kernels.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..109dd8df78dd034c2f48446b59ae2005dde4dc46
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/nojit_kernels.cpp
@@ -0,0 +1,309 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+MTL::ComputePipelineState* get_arange_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array&) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_unary_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    Dtype,
+    Dtype,
+    const char*) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_binary_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    Dtype,
+    Dtype,
+    const char*) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_binary_two_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    Dtype,
+    Dtype,
+    const char*) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_ternary_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    Dtype,
+    const char*) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_copy_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array&,
+    const array&) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_dynamic_copy_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array&,
+    const array&) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_softmax_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    bool,
+    const array&) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_logsumexp_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array&) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_scan_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    bool,
+    bool,
+    const std::string&,
+    const array&,
+    const array&) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_sort_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array&,
+    const array&,
+    int,
+    int) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_mb_sort_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array&,
+    const array&,
+    int,
+    int) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_reduce_init_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string&,
+    const std::string&,
+    const Dtype&) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_reduce_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string&,
+    const std::string&,
+    const Dtype&,
+    const Dtype&,
+    const std::string&,
+    int,
+    int,
+    int) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_steel_gemm_fused_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array&,
+    bool,
+    bool,
+    int,
+    int,
+    int,
+    int,
+    int) {
+  return d.get_kernel(kernel_name, hash_name, func_consts);
+}
+
+MTL::ComputePipelineState* get_steel_gemm_splitk_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array&,
+    const array&,
+    bool,
+    bool,
+    int,
+    int,
+    int,
+    int,
+    int,
+    bool,
+    bool) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_steel_gemm_splitk_accum_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array&,
+    const array&,
+    bool) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_steel_gemm_masked_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array&,
+    const std::optional<array>& mask_out,
+    const std::optional<array>& mask_op,
+    bool,
+    bool,
+    int,
+    int,
+    int,
+    int,
+    int,
+    bool,
+    bool) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_steel_gemm_gather_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array&,
+    bool,
+    bool,
+    int,
+    int,
+    int,
+    int,
+    int,
+    bool) {
+  return d.get_kernel(kernel_name, hash_name, func_consts);
+}
+
+MTL::ComputePipelineState* get_steel_gemm_segmented_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array&,
+    bool,
+    bool,
+    int,
+    int,
+    int,
+    int,
+    int) {
+  return d.get_kernel(kernel_name, hash_name, func_consts);
+}
+
+MTL::ComputePipelineState* get_gemv_masked_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array&,
+    const std::optional<array>&,
+    const std::optional<array>&,
+    bool,
+    int,
+    int,
+    int,
+    int,
+    int,
+    int,
+    bool) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_steel_conv_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const array&,
+    int,
+    int,
+    int,
+    int,
+    int,
+    int,
+    bool) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_steel_conv_general_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array&,
+    int,
+    int,
+    int,
+    int,
+    int) {
+  return d.get_kernel(kernel_name, hash_name, func_consts);
+}
+
+MTL::ComputePipelineState* get_fft_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const std::string&) {
+  return d.get_kernel(kernel_name, hash_name, func_consts);
+}
+
+MTL::ComputePipelineState* get_quantized_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string&,
+    const std::string&) {
+  return d.get_kernel(kernel_name);
+}
+
+MTL::ComputePipelineState* get_gather_qmm_kernel(
+    metal::Device& d,
+    const std::string& kernel_name,
+    const std::string& hash_name,
+    const metal::MTLFCList& func_consts,
+    const array&,
+    int,
+    int,
+    const std::string&,
+    int,
+    int,
+    int,
+    int,
+    int,
+    bool) {
+  return d.get_kernel(kernel_name, hash_name, func_consts);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/normalization.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/normalization.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..40e7b5bc8149d11fea2fad03063830074e706a51
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/normalization.cpp
@@ -0,0 +1,438 @@
+// Copyright © 2024 Apple Inc.
+#include <algorithm>
+
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels/defines.h"
+#include "mlx/backend/metal/reduce.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/fast_primitives.h"
+
+namespace mlx::core::fast {
+
+bool RMSNorm::use_fallback(Stream s) {
+  return s.device == Device::cpu;
+}
+
+void RMSNorm::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+  auto& out = outputs[0];
+
+  // Make sure that the last dimension is contiguous
+  auto set_output = [&s, &out](const array& x) {
+    bool no_copy = x.flags().contiguous && x.strides()[x.ndim() - 1] == 1;
+    if (no_copy && x.ndim() > 1) {
+      auto s = x.strides()[x.ndim() - 2];
+      no_copy &= (s == 0 || s == x.shape().back() || x.shape(-2) == 1);
+    }
+    if (no_copy) {
+      if (x.is_donatable()) {
+        out.copy_shared_buffer(x);
+      } else {
+        out.set_data(
+            allocator::malloc(x.data_size() * x.itemsize()),
+            x.data_size(),
+            x.strides(),
+            x.flags());
+      }
+      return x;
+    } else {
+      array x_copy = contiguous_copy_gpu(x, s);
+      out.copy_shared_buffer(x_copy);
+      return x_copy;
+    }
+  };
+
+  const array x = set_output(inputs[0]);
+  const array& w = inputs[1];
+
+  auto axis_size = static_cast<uint32_t>(x.shape().back());
+  int n_rows = x.data_size() / axis_size;
+
+  const int simd_size = 32;
+  const int n_reads = RMS_N_READS;
+  const int looped_limit = RMS_LOOPED_LIMIT;
+  std::string op_name = "rms";
+  if (axis_size > looped_limit) {
+    op_name += "_looped";
+  }
+  op_name += type_to_name(out);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  {
+    auto kernel = d.get_kernel(op_name);
+
+    MTL::Size grid_dims, group_dims;
+    if (axis_size <= looped_limit) {
+      size_t threadgroup_needed = (axis_size + n_reads - 1) / n_reads;
+      size_t simds_needed = (threadgroup_needed + simd_size - 1) / simd_size;
+      size_t threadgroup_size = simd_size * simds_needed;
+      assert(threadgroup_size <= kernel->maxTotalThreadsPerThreadgroup());
+      size_t n_threads = n_rows * threadgroup_size;
+      grid_dims = MTL::Size(n_threads, 1, 1);
+      group_dims = MTL::Size(threadgroup_size, 1, 1);
+    } else {
+      size_t threadgroup_size = kernel->maxTotalThreadsPerThreadgroup();
+      size_t n_threads = n_rows * threadgroup_size;
+      grid_dims = MTL::Size(n_threads, 1, 1);
+      group_dims = MTL::Size(threadgroup_size, 1, 1);
+    }
+
+    uint32_t w_stride = (w.ndim() == 1) ? w.strides()[0] : 0;
+    compute_encoder.set_compute_pipeline_state(kernel);
+    compute_encoder.set_input_array(
+        x.data_shared_ptr() == nullptr ? out : x, 0);
+    compute_encoder.set_input_array(w, 1);
+    compute_encoder.set_output_array(out, 2);
+    compute_encoder.set_bytes(eps_, 3);
+    compute_encoder.set_bytes(axis_size, 4);
+    compute_encoder.set_bytes(w_stride, 5);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+}
+
+void RMSNormVJP::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  // Ensure row contiguity. We could relax this step by checking that the array
+  // is contiguous (no broadcasts or holes) and that the input strides are the
+  // same as the cotangent strides but for now this is simpler.
+  auto check_input = [&d, &s](const array& x) -> std::pair<array, bool> {
+    if (x.flags().row_contiguous) {
+      return {x, false};
+    }
+    array x_copy = contiguous_copy_gpu(x, s);
+    return {x_copy, true};
+  };
+  bool donate_x = inputs[0].is_donatable();
+  bool donate_g = inputs[2].is_donatable();
+  auto [x, copied] = check_input(inputs[0]);
+  donate_x |= copied;
+  const array& w = inputs[1];
+  auto [g, g_copied] = check_input(inputs[2]);
+  donate_g |= g_copied;
+  array& gx = outputs[0];
+  array& gw = outputs[1];
+
+  // Check whether we had a weight
+  bool has_w = w.ndim() != 0;
+
+  // Allocate space for the outputs
+  bool g_in_gx = false;
+  if (x.is_donatable()) {
+    gx.copy_shared_buffer(x);
+  } else if (g.is_donatable()) {
+    gx.copy_shared_buffer(g);
+    g_in_gx = true;
+  } else {
+    gx.set_data(allocator::malloc(gx.nbytes()));
+  }
+  if (g_copied && !g_in_gx) {
+    d.add_temporary(g, s.index);
+  }
+
+  auto axis_size = static_cast<uint32_t>(x.shape().back());
+  int n_rows = x.data_size() / axis_size;
+
+  // Allocate the gradient accumulator gw and a temporary to store the
+  // gradients before they are accumulated.
+  array gw_temp =
+      (has_w) ? array({n_rows, x.shape().back()}, gw.dtype(), nullptr, {}) : w;
+  if (has_w) {
+    if (!g_in_gx && donate_g) {
+      gw_temp.copy_shared_buffer(g);
+    } else {
+      gw_temp.set_data(allocator::malloc(gw_temp.nbytes()));
+      d.add_temporary(gw_temp, s.index);
+    }
+  }
+  gw.set_data(allocator::malloc(gw.nbytes()));
+
+  const int simd_size = 32;
+  const int n_reads = RMS_N_READS;
+  const int looped_limit = RMS_LOOPED_LIMIT;
+  std::string op_name = "vjp_rms";
+  if (axis_size > looped_limit) {
+    op_name += "_looped";
+  }
+  op_name += type_to_name(gx);
+
+  std::string hash_name = op_name + ((has_w) ? "_w" : "_now");
+  metal::MTLFCList func_consts = {
+      {&has_w, MTL::DataType::DataTypeBool, 20},
+  };
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  {
+    auto kernel = d.get_kernel(op_name, hash_name, func_consts);
+
+    MTL::Size grid_dims, group_dims;
+    if (axis_size <= looped_limit) {
+      size_t threadgroup_needed = (axis_size + n_reads - 1) / n_reads;
+      size_t simds_needed = (threadgroup_needed + simd_size - 1) / simd_size;
+      size_t threadgroup_size = simd_size * simds_needed;
+      assert(threadgroup_size <= kernel->maxTotalThreadsPerThreadgroup());
+      size_t n_threads = n_rows * threadgroup_size;
+      grid_dims = MTL::Size(n_threads, 1, 1);
+      group_dims = MTL::Size(threadgroup_size, 1, 1);
+    } else {
+      size_t threadgroup_size = kernel->maxTotalThreadsPerThreadgroup();
+      size_t n_threads = n_rows * threadgroup_size;
+      grid_dims = MTL::Size(n_threads, 1, 1);
+      group_dims = MTL::Size(threadgroup_size, 1, 1);
+    }
+
+    uint32_t w_stride = (w.ndim() == 1) ? w.strides()[0] : 0;
+    compute_encoder.set_compute_pipeline_state(kernel);
+    compute_encoder.set_input_array(x, 0);
+    compute_encoder.set_input_array(w, 1);
+    compute_encoder.set_input_array(g, 2);
+    compute_encoder.set_output_array(gx, 3);
+    compute_encoder.set_output_array(gw_temp, 4);
+    compute_encoder.set_bytes(eps_, 5);
+    compute_encoder.set_bytes(axis_size, 6);
+    compute_encoder.set_bytes(w_stride, 7);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+
+  if (has_w) {
+    ReductionPlan plan(
+        ReductionOpType::ContiguousStridedReduce, {n_rows}, {axis_size});
+    strided_reduce_general_dispatch(
+        gw_temp, gw, "sum", plan, {0}, compute_encoder, d, s);
+  }
+}
+
+bool LayerNorm::use_fallback(Stream s) {
+  return s.device == Device::cpu;
+}
+
+void LayerNorm::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+  auto& out = outputs[0];
+
+  // Make sure that the last dimension is contiguous
+  auto set_output = [&s, &out](const array& x) {
+    bool no_copy = x.flags().contiguous && x.strides()[x.ndim() - 1] == 1;
+    if (no_copy && x.ndim() > 1) {
+      auto s = x.strides()[x.ndim() - 2];
+      no_copy &= (s == 0 || s == x.shape().back() || x.shape(-2) == 1);
+    }
+    if (no_copy) {
+      if (x.is_donatable()) {
+        out.copy_shared_buffer(x);
+      } else {
+        out.set_data(
+            allocator::malloc(x.data_size() * x.itemsize()),
+            x.data_size(),
+            x.strides(),
+            x.flags());
+      }
+      return x;
+    } else {
+      array x_copy = contiguous_copy_gpu(x, s);
+      out.copy_shared_buffer(x_copy);
+      return x_copy;
+    }
+  };
+
+  const array x = set_output(inputs[0]);
+  const array& w = inputs[1];
+  const array& b = inputs[2];
+
+  auto axis_size = static_cast<uint32_t>(x.shape().back());
+  int n_rows = x.data_size() / axis_size;
+
+  int simd_size = 32;
+  int n_reads = 8;
+  int looped_limit = 6656;
+  std::string op_name = "layer_norm";
+  if (axis_size > looped_limit) {
+    op_name += "_looped";
+    n_reads = 4;
+  }
+  op_name += type_to_name(out);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  {
+    auto kernel = d.get_kernel(op_name);
+
+    MTL::Size grid_dims, group_dims;
+    if (axis_size <= looped_limit) {
+      size_t threadgroup_needed = (axis_size + n_reads - 1) / n_reads;
+      size_t simds_needed = (threadgroup_needed + simd_size - 1) / simd_size;
+      size_t threadgroup_size = simd_size * simds_needed;
+      if (threadgroup_size > kernel->maxTotalThreadsPerThreadgroup()) {
+        std::ostringstream msg;
+        msg << "[layer_norm] Threadgroup size " << threadgroup_size
+            << " is larger than the maximum allowed threadgroup size "
+            << kernel->maxTotalThreadsPerThreadgroup();
+        throw std::runtime_error(msg.str());
+      }
+      size_t n_threads = n_rows * threadgroup_size;
+      grid_dims = MTL::Size(n_threads, 1, 1);
+      group_dims = MTL::Size(threadgroup_size, 1, 1);
+    } else {
+      size_t threadgroup_size = kernel->maxTotalThreadsPerThreadgroup();
+      size_t n_threads = n_rows * threadgroup_size;
+      grid_dims = MTL::Size(n_threads, 1, 1);
+      group_dims = MTL::Size(threadgroup_size, 1, 1);
+    }
+
+    uint32_t w_stride = (w.ndim() == 1) ? w.strides()[0] : 0;
+    uint32_t b_stride = (b.ndim() == 1) ? b.strides()[0] : 0;
+    compute_encoder.set_compute_pipeline_state(kernel);
+    compute_encoder.set_input_array(
+        x.data_shared_ptr() == nullptr ? out : x, 0);
+    compute_encoder.set_input_array(w, 1);
+    compute_encoder.set_input_array(b, 2);
+    compute_encoder.set_output_array(out, 3);
+    compute_encoder.set_bytes(eps_, 4);
+    compute_encoder.set_bytes(axis_size, 5);
+    compute_encoder.set_bytes(w_stride, 6);
+    compute_encoder.set_bytes(b_stride, 7);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+}
+
+void LayerNormVJP::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  // Ensure row contiguity. We could relax this step by checking that the array
+  // is contiguous (no broadcasts or holes) and that the input strides are the
+  // same as the cotangent strides but for now this is simpler.
+  auto check_input = [&s](const array& x) -> std::pair<array, bool> {
+    if (x.flags().row_contiguous) {
+      return {x, false};
+    }
+    array x_copy = contiguous_copy_gpu(x, s);
+    return {x_copy, true};
+  };
+  bool donate_x = inputs[0].is_donatable();
+  bool donate_g = inputs[3].is_donatable();
+  auto [x, copied] = check_input(inputs[0]);
+  donate_x |= copied;
+  const array& w = inputs[1];
+  const array& b = inputs[2];
+  auto [g, g_copied] = check_input(inputs[3]);
+  donate_g |= g_copied;
+  array& gx = outputs[0];
+  array& gw = outputs[1];
+  array& gb = outputs[2];
+
+  // Check whether we had a weight
+  bool has_w = w.ndim() != 0;
+
+  // Allocate space for the outputs
+  bool g_in_gx = false;
+  if (donate_x) {
+    gx.copy_shared_buffer(x);
+  } else if (donate_g) {
+    gx.copy_shared_buffer(g);
+    g_in_gx = true;
+  } else {
+    gx.set_data(allocator::malloc(gx.nbytes()));
+  }
+  if (g_copied && !g_in_gx) {
+    d.add_temporary(g, s.index);
+  }
+
+  auto axis_size = static_cast<uint32_t>(x.shape().back());
+  int n_rows = x.data_size() / axis_size;
+
+  // Allocate a temporary to store the gradients for w and allocate the output
+  // gradient accumulators.
+  array gw_temp =
+      (has_w) ? array({n_rows, x.shape().back()}, gw.dtype(), nullptr, {}) : w;
+  if (has_w) {
+    if (!g_in_gx && donate_g) {
+      gw_temp.copy_shared_buffer(g);
+    } else {
+      gw_temp.set_data(allocator::malloc(gw_temp.nbytes()));
+      d.add_temporary(gw_temp, s.index);
+    }
+  }
+  gw.set_data(allocator::malloc(gw.nbytes()));
+  gb.set_data(allocator::malloc(gb.nbytes()));
+
+  // Finish with the gradient for b in case we had a b
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  if (gb.ndim() == 1 && gb.size() == axis_size) {
+    ReductionPlan plan(
+        ReductionOpType::ContiguousStridedReduce, {n_rows}, {axis_size});
+    strided_reduce_general_dispatch(
+        g, gb, "sum", plan, {0}, compute_encoder, d, s);
+  }
+
+  int simd_size = 32;
+  int n_reads = 8;
+  int looped_limit = 8192;
+  std::string op_name = "vjp_layer_norm";
+  if (axis_size > looped_limit) {
+    op_name += "_looped";
+    n_reads = 4;
+  }
+  op_name += type_to_name(gx);
+
+  std::string hash_name = op_name + ((has_w) ? "_w" : "_now");
+  metal::MTLFCList func_consts = {
+      {&has_w, MTL::DataType::DataTypeBool, 20},
+  };
+
+  {
+    auto kernel = d.get_kernel(op_name, hash_name, func_consts);
+
+    MTL::Size grid_dims, group_dims;
+    if (axis_size <= looped_limit) {
+      size_t threadgroup_needed = (axis_size + n_reads - 1) / n_reads;
+      size_t simds_needed = (threadgroup_needed + simd_size - 1) / simd_size;
+      size_t threadgroup_size = simd_size * simds_needed;
+      if (threadgroup_size > kernel->maxTotalThreadsPerThreadgroup()) {
+        std::ostringstream msg;
+        msg << "[vjp_layer_norm] Threadgroup size " << threadgroup_size
+            << " is larger than the maximum allowed threadgroup size "
+            << kernel->maxTotalThreadsPerThreadgroup();
+        throw std::runtime_error(msg.str());
+      }
+      size_t n_threads = n_rows * threadgroup_size;
+      grid_dims = MTL::Size(n_threads, 1, 1);
+      group_dims = MTL::Size(threadgroup_size, 1, 1);
+    } else {
+      size_t threadgroup_size = kernel->maxTotalThreadsPerThreadgroup();
+      size_t n_threads = n_rows * threadgroup_size;
+      grid_dims = MTL::Size(n_threads, 1, 1);
+      group_dims = MTL::Size(threadgroup_size, 1, 1);
+    }
+
+    uint32_t w_stride = (w.ndim() == 1) ? w.strides()[0] : 0;
+    compute_encoder.set_compute_pipeline_state(kernel);
+    compute_encoder.set_input_array(x, 0);
+    compute_encoder.set_input_array(w, 1);
+    compute_encoder.set_input_array(g, 2);
+    compute_encoder.set_output_array(gx, 3);
+    compute_encoder.set_output_array(gw_temp, 4);
+    compute_encoder.set_bytes(eps_, 5);
+    compute_encoder.set_bytes(axis_size, 6);
+    compute_encoder.set_bytes(w_stride, 7);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+
+  if (has_w) {
+    ReductionPlan plan(
+        ReductionOpType::ContiguousStridedReduce, {n_rows}, {axis_size});
+    strided_reduce_general_dispatch(
+        gw_temp, gw, "sum", plan, {0}, compute_encoder, d, s);
+  }
+}
+
+} // namespace mlx::core::fast
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/primitives.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/primitives.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..92a9a41585cd94bbfa054e935691f799314284c8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/primitives.cpp
@@ -0,0 +1,243 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <algorithm>
+#include <cassert>
+#include <numeric>
+#include <sstream>
+
+#include "mlx/backend/common/slicing.h"
+#include "mlx/backend/common/utils.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/gpu/slicing.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+#include "mlx/scheduler.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+template <typename T>
+void arange_set_scalars(T start, T next, metal::CommandEncoder& enc) {
+  enc.set_bytes(start, 0);
+  T step = next - start;
+  enc.set_bytes(step, 1);
+}
+
+void Arange::eval_gpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 0);
+  out.set_data(allocator::malloc(out.nbytes()));
+  if (out.size() == 0) {
+    return;
+  }
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+  auto kernel = get_arange_kernel(d, "arange" + type_to_name(out), out);
+  size_t nthreads = out.size();
+  MTL::Size grid_dims = MTL::Size(nthreads, 1, 1);
+  MTL::Size group_dims = MTL::Size(
+      std::min(nthreads, kernel->maxTotalThreadsPerThreadgroup()), 1, 1);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  switch (out.dtype()) {
+    case bool_: // unsupported
+      throw std::runtime_error("[Arange::eval_gpu] Does not support bool");
+    case uint8:
+      arange_set_scalars<uint8_t>(start_, start_ + step_, compute_encoder);
+      break;
+    case uint16:
+      arange_set_scalars<uint16_t>(start_, start_ + step_, compute_encoder);
+      break;
+    case uint32:
+      arange_set_scalars<uint32_t>(start_, start_ + step_, compute_encoder);
+      break;
+    case uint64:
+      arange_set_scalars<uint64_t>(start_, start_ + step_, compute_encoder);
+      break;
+    case int8:
+      arange_set_scalars<int8_t>(start_, start_ + step_, compute_encoder);
+      break;
+    case int16:
+      arange_set_scalars<int16_t>(start_, start_ + step_, compute_encoder);
+      break;
+    case int32:
+      arange_set_scalars<int32_t>(start_, start_ + step_, compute_encoder);
+      break;
+    case int64:
+      arange_set_scalars<int64_t>(start_, start_ + step_, compute_encoder);
+      break;
+    case float16:
+      arange_set_scalars<float16_t>(start_, start_ + step_, compute_encoder);
+      break;
+    case float32:
+      arange_set_scalars<float>(start_, start_ + step_, compute_encoder);
+      break;
+    case bfloat16:
+      arange_set_scalars<bfloat16_t>(start_, start_ + step_, compute_encoder);
+      break;
+    default:
+      throw std::runtime_error("[Arange::eval_gpu] Does not support type.");
+  }
+
+  compute_encoder.set_output_array(out, 2);
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+void ArgReduce::eval_gpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  auto& in = inputs[0];
+  out.set_data(allocator::malloc(out.nbytes()));
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+  std::string op_name;
+  switch (reduce_type_) {
+    case ArgReduce::ArgMin:
+      op_name = "argmin_";
+      break;
+    case ArgReduce::ArgMax:
+      op_name = "argmax_";
+      break;
+  }
+
+  // Prepare the shapes, strides and axis arguments.
+  auto in_strides = in.strides();
+  auto shape = in.shape();
+  auto out_strides = out.strides();
+  auto axis_stride = in_strides[axis_];
+  size_t axis_size = shape[axis_];
+  if (out_strides.size() == in_strides.size()) {
+    out_strides.erase(out_strides.begin() + axis_);
+  }
+  in_strides.erase(in_strides.begin() + axis_);
+  shape.erase(shape.begin() + axis_);
+  size_t ndim = shape.size();
+
+  // ArgReduce
+  int simd_size = 32;
+  int n_reads = 4;
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  {
+    auto kernel = d.get_kernel(op_name + type_to_name(in));
+    NS::UInteger thread_group_size = std::min(
+        (axis_size + n_reads - 1) / n_reads,
+        kernel->maxTotalThreadsPerThreadgroup());
+    // round up to the closest number divisible by simd_size
+    thread_group_size =
+        (thread_group_size + simd_size - 1) / simd_size * simd_size;
+    assert(thread_group_size <= kernel->maxTotalThreadsPerThreadgroup());
+
+    auto gd = get_2d_grid_dims(out.shape(), out.strides());
+    MTL::Size grid_dims = MTL::Size(thread_group_size, gd.width, gd.height);
+    MTL::Size group_dims = MTL::Size(thread_group_size, 1, 1);
+    compute_encoder.set_compute_pipeline_state(kernel);
+    compute_encoder.set_input_array(in, 0);
+    compute_encoder.set_output_array(out, 1);
+    if (ndim == 0) {
+      // Pass place holders so metal doesn't complain
+      int shape_ = 0;
+      int64_t stride_ = 0;
+      compute_encoder.set_bytes(shape_, 2);
+      compute_encoder.set_bytes(stride_, 3);
+      compute_encoder.set_bytes(stride_, 4);
+    } else {
+      compute_encoder.set_vector_bytes(shape, 2);
+      compute_encoder.set_vector_bytes(in_strides, 3);
+      compute_encoder.set_vector_bytes(out_strides, 4);
+    }
+    compute_encoder.set_bytes(ndim, 5);
+    compute_encoder.set_bytes(axis_stride, 6);
+    compute_encoder.set_bytes(axis_size, 7);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+}
+
+void Load::eval_gpu(const std::vector<array>& inputs, array& out) {
+  throw std::runtime_error("[Load::eval_gpu] Not implemented.");
+}
+
+void RandomBits::eval_gpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+
+  // keys has shape (N1, ..., NK, 2)
+  // out has shape (N1, ..., NK, M1, M2, ...)
+  auto& keys = inputs[0];
+  size_t num_keys = keys.size() / 2;
+
+  size_t elems_per_key = out.size() / num_keys;
+  size_t bytes_per_key = out.itemsize() * elems_per_key;
+  out.set_data(allocator::malloc(out.nbytes()));
+  if (out.size() == 0) {
+    return;
+  }
+
+  size_t out_per_key = (bytes_per_key + 4 - 1) / 4;
+  size_t half_size = out_per_key / 2;
+  bool odd = out_per_key % 2;
+
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+  std::string kname = keys.flags().row_contiguous ? "rbitsc" : "rbits";
+  auto kernel = d.get_kernel(kname);
+
+  // organize into grid nkeys x elem_per_key
+  MTL::Size grid_dims = MTL::Size(num_keys, half_size + odd, 1);
+  NS::UInteger thread_group_size = kernel->maxTotalThreadsPerThreadgroup();
+  auto group_dims = get_block_dims(num_keys, half_size + odd, 1);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+  compute_encoder.set_input_array(keys, 0);
+  compute_encoder.set_output_array(out, 1);
+  compute_encoder.set_bytes(odd, 2);
+  compute_encoder.set_bytes(bytes_per_key, 3);
+
+  if (!keys.flags().row_contiguous) {
+    int ndim = keys.ndim();
+    compute_encoder.set_bytes(ndim, 4);
+    compute_encoder.set_vector_bytes(keys.shape(), 5);
+    compute_encoder.set_vector_bytes(keys.strides(), 6);
+  }
+
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+void QRF::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  throw std::runtime_error("[QRF::eval_gpu] Metal QR factorization NYI.");
+}
+
+void SVD::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  throw std::runtime_error("[SVD::eval_gpu] Metal SVD NYI.");
+}
+
+void Inverse::eval_gpu(const std::vector<array>& inputs, array& output) {
+  throw std::runtime_error("[Inverse::eval_gpu] Metal inversion NYI.");
+}
+
+void Cholesky::eval_gpu(const std::vector<array>& inputs, array& out) {
+  throw std::runtime_error(
+      "[Cholesky::eval_gpu] Metal Cholesky decomposition NYI.");
+}
+
+void Eig::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  throw std::runtime_error("[Eig::eval_gpu] Metal Eig NYI.");
+}
+
+void Eigh::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  throw std::runtime_error("[Eigh::eval_gpu] Metal Eigh NYI.");
+}
+
+void LUF::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  throw std::runtime_error("[LUF::eval_gpu] Metal LU factorization NYI.");
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/quantized.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/quantized.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..452bc4faa48607df5475e744c47c3da285ea8d81
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/quantized.cpp
@@ -0,0 +1,1111 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/backend/common/broadcasting.h"
+#include "mlx/backend/common/compiled.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/reduce.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/fast_primitives.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+namespace {
+
+template <typename... Args>
+auto get_quantized_kernel_wrapped(
+    metal::Device& d,
+    const std::string& name,
+    const std::string& func,
+    const std::string& mode,
+    const std::string& type,
+    int group_size,
+    int bits,
+    Args... args) {
+  std::string template_def;
+  auto fname = mode + "_" + func;
+  if (mode == "affine") {
+    template_def = get_template_definition(
+        name, fname, type, group_size, bits, std::forward<Args>(args)...);
+  } else {
+    template_def = get_template_definition(
+        name, fname, type, group_size, "uint8_t", std::forward<Args>(args)...);
+  }
+  return get_quantized_kernel(d, name, template_def, mode);
+}
+
+inline array
+ensure_row_contiguous(const array& x, metal::Device& d, const Stream& s) {
+  if (!x.flags().row_contiguous) {
+    array x_copy = contiguous_copy_gpu(x, s);
+    d.add_temporary(x_copy, s.index);
+    return x_copy;
+  } else {
+    return x;
+  }
+}
+
+inline array ensure_row_contiguous_matrix(
+    const array& x,
+    metal::Device& d,
+    const Stream& s) {
+  if (x.ndim() < 2) {
+    if (x.strides()[0] == 1) {
+      return x;
+    }
+  } else {
+    auto stride_0 = x.strides()[x.ndim() - 2];
+    auto stride_1 = x.strides()[x.ndim() - 1];
+    if (stride_0 == x.shape(-1) && stride_1 == 1) {
+      return x;
+    }
+  }
+  array x_copy = contiguous_copy_gpu(x, s);
+  d.add_temporary(x_copy, s.index);
+  return x_copy;
+}
+
+inline int get_qmv_batch_limit(int D, int O, metal::Device& d) {
+  auto arch = d.get_architecture();
+  auto arch_size = arch.back();
+  auto arch_gen = arch.substr(arch.size() - 3, 2);
+  if (arch_gen == "13" || arch_gen == "14") {
+    switch (arch_size) {
+      case 'd':
+        if (D <= 2048 && O <= 2048) {
+          return 32;
+        } else if (D <= 4096 && O <= 4096) {
+          return 18;
+        } else {
+          return 12;
+        }
+      default:
+        if (D <= 2048 && O <= 2048) {
+          return 14;
+        } else if (D <= 4096 && O <= 4096) {
+          return 10;
+        } else {
+          return 6;
+        }
+    }
+  } else {
+    switch (arch_size) {
+      case 'd':
+        if (D <= 2048 && O <= 2048) {
+          return 32;
+        } else if (D <= 4096 && O <= 4096) {
+          return 18;
+        } else {
+          return 12;
+        }
+      default:
+        if (D <= 2048 && O <= 2048) {
+          return 18;
+        } else if (D <= 4096 && O <= 4096) {
+          return 12;
+        } else {
+          return 10;
+        }
+    }
+  }
+}
+
+inline int add_strides_and_shapes(
+    CommandEncoder& compute_encoder,
+    bool skip,
+    const array& x,
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases,
+    int offset) {
+  if (skip) {
+    return 0;
+  }
+
+  // TODO: Collapse batch dimensions
+
+  int x_batch_ndims = x.ndim() - 2;
+  int w_batch_ndims = w.ndim() - 2;
+  compute_encoder.set_bytes(x_batch_ndims, offset++);
+  compute_encoder.set_vector_bytes(x.shape(), offset++);
+  compute_encoder.set_vector_bytes(x.strides(), offset++);
+  compute_encoder.set_bytes(w_batch_ndims, offset++);
+  compute_encoder.set_vector_bytes(w.shape(), offset++);
+  compute_encoder.set_vector_bytes(w.strides(), offset++);
+  compute_encoder.set_vector_bytes(scales.strides(), offset++);
+  if (biases) {
+    compute_encoder.set_vector_bytes(biases->strides(), offset++);
+  }
+
+  return offset;
+}
+
+inline int add_gather_strides_and_shapes(
+    CommandEncoder& compute_encoder,
+    const array& lhs_indices,
+    const array& rhs_indices,
+    int offset) {
+  auto [shape, strides] = collapse_contiguous_dims(
+      lhs_indices.shape(), {lhs_indices.strides(), rhs_indices.strides()});
+  int ndims = shape.size();
+
+  compute_encoder.set_bytes(ndims, offset++);
+  compute_encoder.set_vector_bytes(shape, offset++);
+  compute_encoder.set_vector_bytes(strides[0], offset++);
+  compute_encoder.set_vector_bytes(strides[1], offset++);
+
+  return offset;
+}
+
+} // namespace
+
+void qmv_quad(
+    const array& x,
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases,
+    array& out,
+    int group_size,
+    int bits,
+    int M,
+    int N,
+    int K,
+    metal::Device& d,
+    const Stream& s,
+    const std::string& mode) {
+  int B = out.size() / M / N;
+
+  constexpr int quads_per_simd = 8;
+  constexpr int results_per_quadgroup = 8;
+  int bn = quads_per_simd * results_per_quadgroup;
+  int simdgroup_size = 32;
+  MTL::Size group_dims(simdgroup_size, 1, 1);
+  MTL::Size grid_dims(M, (N + bn - 1) / bn, B);
+
+  std::string kname;
+  kname.reserve(64);
+  std::string type_string = get_type_string(x.dtype());
+
+  concatenate(
+      kname,
+      mode + "_qmv_quad_",
+      type_string,
+      "_gs_",
+      group_size,
+      "_b_",
+      bits,
+      "_d_",
+      K,
+      B > 1 ? "_batch_1" : "_batch_0");
+  auto kernel = get_quantized_kernel_wrapped(
+      d, kname, "qmv_quad", mode, type_string, group_size, bits, K, B > 1);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  int c = 0;
+  compute_encoder.set_input_array(w, c++);
+  compute_encoder.set_input_array(scales, c++);
+  if (biases) {
+    compute_encoder.set_input_array(*biases, c++);
+  }
+  compute_encoder.set_input_array(x, c++);
+  compute_encoder.set_output_array(out, c++);
+  compute_encoder.set_bytes(K, c++);
+  compute_encoder.set_bytes(N, c++);
+  add_strides_and_shapes(compute_encoder, B <= 1, x, w, scales, biases, c++);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void qmv(
+    const array& x,
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases,
+    array& out,
+    int group_size,
+    int bits,
+    int M,
+    int N,
+    int K,
+    metal::Device& d,
+    const Stream& s,
+    const std::string& mode) {
+  int B = out.size() / M / N;
+
+  int bn = 8;
+  int bk = 32;
+  MTL::Size group_dims(bk, 2, 1);
+  MTL::Size grid_dims(M, (N + bn - 1) / bn, B);
+
+  std::string kname;
+  kname.reserve(64);
+  std::string type_string = get_type_string(x.dtype());
+  bool fast = N % bn == 0 && K % 512 == 0;
+
+  concatenate(
+      kname,
+      mode + (fast ? "_qmv_fast_" : "_qmv_"),
+      type_string,
+      "_gs_",
+      group_size,
+      "_b_",
+      bits,
+      B > 1 ? "_batch_1" : "_batch_0");
+  auto kernel = get_quantized_kernel_wrapped(
+      d,
+      kname,
+      (fast ? "qmv_fast" : "qmv"),
+      mode,
+      type_string,
+      group_size,
+      bits,
+      B > 1);
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  int c = 0;
+  compute_encoder.set_input_array(w, c++);
+  compute_encoder.set_input_array(scales, c++);
+  if (biases) {
+    compute_encoder.set_input_array(*biases, c++);
+  }
+  compute_encoder.set_input_array(x, c++);
+  compute_encoder.set_output_array(out, c++);
+  compute_encoder.set_bytes(K, c++);
+  compute_encoder.set_bytes(N, c++);
+  add_strides_and_shapes(compute_encoder, B <= 1, x, w, scales, biases, c);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void qvm_split_k(
+    const array& x,
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases,
+    array& out,
+    int group_size,
+    int bits,
+    int M,
+    int N,
+    int K,
+    metal::Device& d,
+    const Stream& s,
+    const std::string& mode) {
+  int split_k = K > 8192 ? 32 : 8;
+  int split_D = (K + split_k - 1) / split_k;
+  int B = out.size() / M / N;
+  B *= split_k;
+
+  int bn = 64;
+  int bk = 32;
+  MTL::Size group_dims = MTL::Size(bk, 2, 1);
+  MTL::Size grid_dims = MTL::Size(M, N / bn, B);
+
+  auto x_shape = x.shape();
+  auto x_strides = x.strides();
+  if (x_shape.size() == 1) {
+    x_shape.insert(x_shape.begin(), 1);
+    x_strides.insert(x_strides.begin(), 0);
+  }
+
+  int x_ndim = x_shape.size();
+  int x_batch_ndims = x_ndim - 2;
+  int w_batch_ndims = w.ndim() - 2;
+  auto w_shape = w.shape();
+  auto w_strides = w.strides();
+  auto s_strides = scales.strides();
+
+  // Add split_k dim with reshapes
+  x_shape.insert(x_shape.end() - 2, split_k);
+  x_shape.back() /= split_k;
+  x_strides.insert(x_strides.end() - 2, split_D);
+  x_strides[x_ndim - 1] = split_D;
+  x_batch_ndims += 1;
+
+  w_shape.insert(w_shape.end() - 2, split_k);
+  w_shape[w.ndim() - 1] /= split_k;
+  w_strides.insert(w_strides.end() - 2, split_D * w.shape(-1));
+  w_batch_ndims += 1;
+  s_strides.insert(s_strides.end() - 2, split_D * scales.shape(-1));
+
+  int final_block_size = K - (split_k - 1) * split_D;
+
+  auto temp_shape = out.shape();
+  if (temp_shape.size() == 1) {
+    temp_shape.insert(temp_shape.begin(), 1);
+  }
+  temp_shape.insert(temp_shape.end() - 2, split_k);
+  array intermediate(temp_shape, x.dtype(), nullptr, {});
+  intermediate.set_data(allocator::malloc(intermediate.nbytes()));
+  d.add_temporary(intermediate, s.index);
+
+  std::string type_string = get_type_string(x.dtype());
+  std::string kname;
+  kname.reserve(64);
+  concatenate(
+      kname,
+      mode + "_qvm_split_k_",
+      type_string,
+      "_gs_",
+      group_size,
+      "_b_",
+      bits,
+      "_spk_",
+      split_k);
+
+  // Encode and dispatch kernel
+  auto kernel = get_quantized_kernel_wrapped(
+      d, kname, "qvm_split_k", mode, type_string, group_size, bits, split_k);
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  int c = 0;
+  compute_encoder.set_input_array(w, c++);
+  compute_encoder.set_input_array(scales, c++);
+  if (biases) {
+    compute_encoder.set_input_array(*biases, c++);
+  }
+  compute_encoder.set_input_array(x, c++);
+  compute_encoder.set_output_array(intermediate, c++);
+  compute_encoder.set_bytes(split_D, c++);
+  compute_encoder.set_bytes(N, c++);
+
+  compute_encoder.set_bytes(x_batch_ndims, c++);
+  compute_encoder.set_vector_bytes(x_shape, c++);
+  compute_encoder.set_vector_bytes(x_strides, c++);
+  compute_encoder.set_bytes(w_batch_ndims, c++);
+  compute_encoder.set_vector_bytes(w_shape, c++);
+  compute_encoder.set_vector_bytes(w_strides, c++);
+  compute_encoder.set_vector_bytes(s_strides, c++);
+  if (biases) {
+    auto b_strides = biases->strides();
+    b_strides.insert(b_strides.end() - 2, split_D * biases->shape(-1));
+    compute_encoder.set_vector_bytes(b_strides, c++);
+  }
+  compute_encoder.set_bytes(final_block_size, c++);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+
+  int axis = intermediate.ndim() - 3;
+  ReductionPlan plan(
+      ReductionOpType::ContiguousStridedReduce,
+      {intermediate.shape(axis)},
+      {intermediate.strides(axis)});
+  strided_reduce_general_dispatch(
+      intermediate, out, "sum", plan, {axis}, compute_encoder, d, s);
+}
+
+void qvm(
+    const array& x,
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases,
+    array& out,
+    int group_size,
+    int bits,
+    int M,
+    int N,
+    int K,
+    metal::Device& d,
+    const Stream& s,
+    const std::string& mode) {
+  int B = out.size() / M / N;
+
+  int bn = 64;
+  int bk = 32;
+  MTL::Size group_dims(bk, 2, 1);
+  MTL::Size grid_dims(M, (N + bn - 1) / bn, B);
+
+  std::string kname;
+  kname.reserve(64);
+  std::string type_string = get_type_string(x.dtype());
+  concatenate(
+      kname,
+      mode + "_qvm_",
+      type_string,
+      "_gs_",
+      group_size,
+      "_b_",
+      bits,
+      B > 1 ? "_batch_1" : "_batch_0");
+  auto kernel = get_quantized_kernel_wrapped(
+      d, kname, "qvm", mode, type_string, group_size, bits, B > 1);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  int c = 0;
+  compute_encoder.set_input_array(w, c++);
+  compute_encoder.set_input_array(scales, c++);
+  if (biases) {
+    compute_encoder.set_input_array(*biases, c++);
+  }
+  compute_encoder.set_input_array(x, c++);
+  compute_encoder.set_output_array(out, c++);
+  compute_encoder.set_bytes(K, c++);
+  compute_encoder.set_bytes(N, c++);
+  add_strides_and_shapes(compute_encoder, B <= 1, x, w, scales, biases, c++);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void qmm(
+    const array& x,
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases,
+    array& out,
+    bool transpose,
+    int group_size,
+    int bits,
+    int M,
+    int N,
+    int K,
+    metal::Device& d,
+    const Stream& s,
+    const std::string& mode) {
+  int B = out.size() / M / N;
+
+  int wm = 2;
+  int wn = 2;
+  int bm = 32;
+  int bn = 32;
+  MTL::Size group_dims(32, wn, wm);
+  MTL::Size grid_dims((N + bn - 1) / bn, (M + bm - 1) / bm, B);
+
+  std::string kname;
+  kname.reserve(64);
+  bool aligned = N % 32 == 0;
+  bool batched = B > 1;
+  std::string type_string = get_type_string(x.dtype());
+  concatenate(
+      kname,
+      mode + (transpose ? "_qmm_t_" : "_qmm_n_"),
+      type_string,
+      "_gs_",
+      group_size,
+      "_b_",
+      bits,
+      transpose ? (aligned ? "_alN_true" : "_alN_false") : "",
+      batched ? "_batch_1" : "_batch_0");
+  std::string template_def;
+  MTL::ComputePipelineState* kernel;
+  if (transpose) {
+    kernel = get_quantized_kernel_wrapped(
+        d,
+        kname,
+        "qmm_t",
+        mode,
+        type_string,
+        group_size,
+        bits,
+        aligned,
+        batched);
+  } else {
+    kernel = get_quantized_kernel_wrapped(
+        d, kname, "qmm_n", mode, type_string, group_size, bits, batched);
+  }
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  int c = 0;
+  compute_encoder.set_input_array(w, c++);
+  compute_encoder.set_input_array(scales, c++);
+  if (biases) {
+    compute_encoder.set_input_array(*biases, c++);
+  }
+  compute_encoder.set_input_array(x, c++);
+  compute_encoder.set_output_array(out, c++);
+  compute_encoder.set_bytes(K, c++);
+  compute_encoder.set_bytes(N, c++);
+  compute_encoder.set_bytes(M, c++);
+  add_strides_and_shapes(compute_encoder, B <= 1, x, w, scales, biases, c);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void gather_qmm(
+    const array& x,
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases,
+    const array& lhs_indices,
+    const array& rhs_indices,
+    array& out,
+    bool transpose,
+    int group_size,
+    int bits,
+    int M,
+    int N,
+    int K,
+    metal::Device& d,
+    const Stream& s,
+    const std::string& mode) {
+  int B = out.size() / M / N;
+
+  int wm = 2;
+  int wn = 2;
+  int bm = 32;
+  int bn = 32;
+  MTL::Size group_dims(32, wn, wm);
+  MTL::Size grid_dims((N + bn - 1) / bn, (M + bm - 1) / bm, B);
+
+  std::string kname;
+  kname.reserve(64);
+  bool aligned = N % 32 == 0;
+  std::string type_string = get_type_string(x.dtype());
+  concatenate(
+      kname,
+      mode + (transpose ? "_gather_qmm_t_" : "_gather_qmm_n_"),
+      type_string,
+      "_gs_",
+      group_size,
+      "_b_",
+      bits,
+      transpose ? (aligned ? "_alN_true" : "_alN_false") : "");
+  MTL::ComputePipelineState* kernel;
+  if (transpose) {
+    kernel = get_quantized_kernel_wrapped(
+        d, kname, "gather_qmm_t", mode, type_string, group_size, bits, aligned);
+  } else {
+    kernel = get_quantized_kernel_wrapped(
+        d, kname, "gather_qmm_n", mode, type_string, group_size, bits);
+  }
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  int c = 0;
+  compute_encoder.set_input_array(w, c++);
+  compute_encoder.set_input_array(scales, c++);
+  if (biases) {
+    compute_encoder.set_input_array(*biases, c++);
+  }
+  compute_encoder.set_input_array(x, c++);
+  compute_encoder.set_input_array(lhs_indices, c++);
+  compute_encoder.set_input_array(rhs_indices, c++);
+  compute_encoder.set_output_array(out, c++);
+  compute_encoder.set_bytes(K, c++);
+  compute_encoder.set_bytes(N, c++);
+  compute_encoder.set_bytes(M, c++);
+  c = add_strides_and_shapes(compute_encoder, false, x, w, scales, biases, c);
+  add_gather_strides_and_shapes(compute_encoder, lhs_indices, rhs_indices, c);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void gather_qmv(
+    const array& x,
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases,
+    const array& lhs_indices,
+    const array& rhs_indices,
+    array& out,
+    int group_size,
+    int bits,
+    int M,
+    int N,
+    int K,
+    metal::Device& d,
+    const Stream& s,
+    const std::string& mode) {
+  int B = out.size() / M / N;
+
+  int bn = 8;
+  int bk = 32;
+  MTL::Size group_dims(bk, 2, 1);
+  MTL::Size grid_dims(M, (N + bn - 1) / bn, B);
+
+  std::string kname;
+  kname.reserve(64);
+  std::string type_string = get_type_string(x.dtype());
+  bool fast = N % bn == 0 && K % 512 == 0;
+  concatenate(
+      kname,
+      mode + (fast ? "_gather_qmv_fast_" : "_gather_qmv_"),
+      type_string,
+      "_gs_",
+      group_size,
+      "_b_",
+      bits);
+
+  auto kernel = get_quantized_kernel_wrapped(
+      d,
+      kname,
+      (fast ? "gather_qmv_fast" : "gather_qmv"),
+      mode,
+      type_string,
+      group_size,
+      bits);
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  int c = 0;
+  compute_encoder.set_input_array(w, c++);
+  compute_encoder.set_input_array(scales, c++);
+  if (biases) {
+    compute_encoder.set_input_array(*biases, c++);
+  }
+  compute_encoder.set_input_array(x, c++);
+  compute_encoder.set_input_array(lhs_indices, c++);
+  compute_encoder.set_input_array(rhs_indices, c++);
+  compute_encoder.set_output_array(out, c++);
+  compute_encoder.set_bytes(K, c++);
+  compute_encoder.set_bytes(N, c++);
+  c = add_strides_and_shapes(compute_encoder, false, x, w, scales, biases, c);
+  add_gather_strides_and_shapes(compute_encoder, lhs_indices, rhs_indices, c);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void gather_qvm(
+    const array& x,
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases,
+    const array& lhs_indices,
+    const array& rhs_indices,
+    array& out,
+    int group_size,
+    int bits,
+    int M,
+    int N,
+    int K,
+    metal::Device& d,
+    const Stream& s,
+    const std::string& mode) {
+  int B = out.size() / M / N;
+
+  int bn = 64;
+  int bk = 32;
+  MTL::Size group_dims(bk, 2, 1);
+  MTL::Size grid_dims(M, (N + bn - 1) / bn, B);
+
+  std::string kname;
+  kname.reserve(64);
+  std::string type_string = get_type_string(x.dtype());
+  concatenate(
+      kname,
+      mode + "_gather_qvm_",
+      type_string,
+      "_gs_",
+      group_size,
+      "_b_",
+      bits);
+  auto kernel = get_quantized_kernel_wrapped(
+      d, kname, "gather_qvm", mode, type_string, group_size, bits);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  int c = 0;
+  compute_encoder.set_input_array(w, c++);
+  compute_encoder.set_input_array(scales, c++);
+  if (biases) {
+    compute_encoder.set_input_array(*biases, c++);
+  }
+  compute_encoder.set_input_array(x, c++);
+  compute_encoder.set_input_array(lhs_indices, c++);
+  compute_encoder.set_input_array(rhs_indices, c++);
+  compute_encoder.set_output_array(out, c++);
+  compute_encoder.set_bytes(K, c++);
+  compute_encoder.set_bytes(N, c++);
+  c = add_strides_and_shapes(compute_encoder, false, x, w, scales, biases, c++);
+  add_gather_strides_and_shapes(compute_encoder, lhs_indices, rhs_indices, c);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void gather_qmm_rhs(
+    const array& x_,
+    const array& w_,
+    const array& scales_,
+    const std::optional<array>& biases_,
+    const array& indices_,
+    array& out,
+    bool transpose,
+    int group_size,
+    int bits,
+    int M,
+    int N,
+    int K,
+    metal::Device& d,
+    const Stream& s,
+    const std::string mode) {
+  // Start by normalizing the indices
+  array indices = ensure_row_contiguous(indices_, d, s);
+
+  // Broadcast x with indices. If we are here that means lhs_indices were not
+  // provided so the lhs_indices are implied to be the shape of x broadcasted
+  // with rhs_indices. We need only broadcast x and copy it as if applying the
+  // lhs_indices.
+  auto broadcast_with_indices = [&d, &s, &indices](const array& x) {
+    if (x.size() / x.shape(-2) / x.shape(-1) == indices.size()) {
+      return ensure_row_contiguous(x, d, s);
+    }
+
+    auto x_shape = indices.shape();
+    x_shape.push_back(x.shape(-2));
+    x_shape.push_back(x.shape(-1));
+    array new_x(std::move(x_shape), x.dtype(), nullptr, {});
+    broadcast(x, new_x);
+    return ensure_row_contiguous(new_x, d, s);
+  };
+
+  // Normalize the input arrays
+  array x = broadcast_with_indices(x_);
+  array w = ensure_row_contiguous(w_, d, s);
+  array scales = ensure_row_contiguous(scales_, d, s);
+
+  // TODO: Tune the block sizes
+  int bm = 16, bn = 32, bk = 32;
+  int wm = 1, wn = 2;
+
+  const bool align_M = (M % bm) == 0;
+  const bool align_N = (N % bn) == 0;
+  const bool align_K = (K % bk) == 0;
+
+  // Make the kernel name
+  std::string kname;
+  kname.reserve(64);
+  std::string type_string = get_type_string(x.dtype());
+  concatenate(
+      kname,
+      mode + (transpose ? "_gather_qmm_rhs_nt_" : "_gather_qmm_rhs_nn_"),
+      type_string,
+      "_gs_",
+      group_size,
+      "_b_",
+      bits,
+      "_bm_",
+      bm,
+      "_bn_",
+      bn,
+      "_bk_",
+      bk,
+      "_wm_",
+      wm,
+      "_wn_",
+      wn);
+
+  metal::MTLFCList func_consts = {
+      {&align_M, MTL::DataType::DataTypeBool, 200},
+      {&align_N, MTL::DataType::DataTypeBool, 201},
+      {&align_K, MTL::DataType::DataTypeBool, 202},
+  };
+
+  // And the kernel hash that includes the function constants
+  std::string hash_name;
+  hash_name.reserve(128);
+  concatenate(
+      hash_name,
+      kname,
+      "_align_M_",
+      align_M ? 't' : 'n',
+      "_align_N_",
+      align_N ? 't' : 'n',
+      "_align_K_",
+      align_K ? 't' : 'n');
+
+  // Get and set the kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = get_gather_qmm_kernel(
+      d,
+      kname,
+      hash_name,
+      func_consts,
+      x,
+      group_size,
+      bits,
+      mode,
+      bm,
+      bn,
+      bk,
+      wm,
+      wn,
+      transpose);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  MTL::Size group_dims(32, wn, wm);
+  MTL::Size grid_dims((N + bn - 1) / bn, (M + bm - 1) / bm, 1);
+
+  int c = 0;
+  compute_encoder.set_input_array(x, c++);
+  compute_encoder.set_input_array(w, c++);
+  compute_encoder.set_input_array(scales, c++);
+  if (biases_) {
+    array biases = ensure_row_contiguous(*biases_, d, s);
+    compute_encoder.set_input_array(biases, c++);
+  }
+  compute_encoder.set_input_array(indices, c++);
+  compute_encoder.set_output_array(out, c++);
+  compute_encoder.set_bytes(M, c++);
+  compute_encoder.set_bytes(N, c++);
+  compute_encoder.set_bytes(K, c++);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void QuantizedMatmul::eval_gpu(const std::vector<array>& inputs, array& out) {
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  // Make sure the last two dims of x and w, s, b are contiguous. This should
+  // be relaxed for x.
+  array x = ensure_row_contiguous_matrix(inputs[0], d, s);
+  array w = ensure_row_contiguous_matrix(inputs[1], d, s);
+  array scales = ensure_row_contiguous_matrix(inputs[2], d, s);
+  std::optional<array> biases = std::nullopt;
+  if (inputs.size() == 4) {
+    biases = ensure_row_contiguous_matrix(inputs[3], d, s);
+  }
+
+  // Extract the matmul shapes
+  bool non_batched = w.ndim() == 2 && x.flags().row_contiguous;
+  int K = x.shape(-1);
+  int M = non_batched ? x.size() / K : x.shape(-2);
+  int N = out.shape(-1);
+
+  int vector_limit = transpose_ ? get_qmv_batch_limit(K, N, d) : 4;
+  auto mode = quantization_mode_to_string(mode_);
+  // It is a matrix matrix product.
+  if (M >= vector_limit) {
+    qmm(x,
+        w,
+        scales,
+        biases,
+        out,
+        transpose_,
+        group_size_,
+        bits_,
+        M,
+        N,
+        K,
+        d,
+        s,
+        mode);
+    return;
+  }
+
+  // It is a qmv with a small inner dimension so route to qmv_quad kernel
+  if (transpose_ && (K == 128 || K == 64) && is_power_of_2(bits_)) {
+    qmv_quad(
+        x, w, scales, biases, out, group_size_, bits_, M, N, K, d, s, mode);
+    return;
+  }
+
+  // Run of the mill qmv
+  if (transpose_) {
+    qmv(x, w, scales, biases, out, group_size_, bits_, M, N, K, d, s, mode);
+    return;
+  }
+
+  // Run of the mill qvm
+  if (K < 1024) {
+    qvm(x, w, scales, biases, out, group_size_, bits_, M, N, K, d, s, mode);
+    return;
+  }
+
+  // Qvm with large dimension so route to a split K kernel for more parallelism
+  qvm_split_k(
+      x, w, scales, biases, out, group_size_, bits_, M, N, K, d, s, mode);
+  return;
+}
+
+void GatherQMM::eval_gpu(const std::vector<array>& inputs, array& out) {
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  array x = ensure_row_contiguous_matrix(inputs[0], d, s);
+  array w = ensure_row_contiguous_matrix(inputs[1], d, s);
+  array scales = ensure_row_contiguous_matrix(inputs[2], d, s);
+  std::optional<array> biases = std::nullopt;
+  if (inputs.size() == 6) {
+    biases = ensure_row_contiguous_matrix(inputs[3], d, s);
+  }
+  const array& lhs_indices = inputs[inputs.size() - 2];
+  const array& rhs_indices = inputs[inputs.size() - 1];
+
+  int K = x.shape(-1);
+  int M = x.shape(-2);
+  int N = out.shape(-1);
+  int B = out.size() / M / N;
+  int E = w.size() / w.shape(-1) / w.shape(-2);
+  int vector_limit = transpose_ ? get_qmv_batch_limit(K, N, d) : 4;
+  auto mode = quantization_mode_to_string(mode_);
+
+  // We are walking x in order and w is also in order so we can batch up the
+  // matmuls and reuse reading x and w.
+  //
+  // TODO: Tune 16 and 4 here a bit better.
+  if (M == 1 && B >= 16 && right_sorted_ == true && B / E >= 4) {
+    gather_qmm_rhs(
+        x,
+        w,
+        scales,
+        biases,
+        rhs_indices,
+        out,
+        transpose_,
+        group_size_,
+        bits_,
+        x.size() / K,
+        N,
+        K,
+        d,
+        s,
+        mode);
+    return;
+  }
+
+  // It is a matrix matrix product
+  if (M >= vector_limit) {
+    gather_qmm(
+        x,
+        w,
+        scales,
+        biases,
+        lhs_indices,
+        rhs_indices,
+        out,
+        transpose_,
+        group_size_,
+        bits_,
+        M,
+        N,
+        K,
+        d,
+        s,
+        mode);
+    return;
+  }
+
+  if (transpose_) {
+    gather_qmv(
+        x,
+        w,
+        scales,
+        biases,
+        lhs_indices,
+        rhs_indices,
+        out,
+        group_size_,
+        bits_,
+        M,
+        N,
+        K,
+        d,
+        s,
+        mode);
+    return;
+  }
+
+  gather_qvm(
+      x,
+      w,
+      scales,
+      biases,
+      lhs_indices,
+      rhs_indices,
+      out,
+      group_size_,
+      bits_,
+      M,
+      N,
+      K,
+      d,
+      s,
+      mode);
+}
+
+void fast::Quantize::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  auto& w_pre = inputs[0];
+  auto& out = outputs[0];
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+
+  auto w = ensure_row_contiguous(w_pre, d, s);
+  compute_encoder.set_input_array(w, 0);
+  if (dequantize_) {
+    auto scales = ensure_row_contiguous(inputs[1], d, s);
+    auto biases = ensure_row_contiguous(inputs[2], d, s);
+    compute_encoder.set_input_array(scales, 1);
+    compute_encoder.set_input_array(biases, 2);
+    compute_encoder.set_output_array(out, 3);
+  } else {
+    auto& scales = outputs[1];
+    auto& biases = outputs[2];
+    scales.set_data(allocator::malloc(scales.nbytes()));
+    biases.set_data(allocator::malloc(biases.nbytes()));
+    compute_encoder.set_output_array(out, 1);
+    compute_encoder.set_output_array(scales, 2);
+    compute_encoder.set_output_array(biases, 3);
+  }
+
+  auto type_string = dequantize_ ? get_type_string(out.dtype())
+                                 : get_type_string(w_pre.dtype());
+  std::string kname;
+  concatenate(
+      kname,
+      dequantize_ ? "affine_dequantize" : "affine_quantize",
+      "_",
+      type_string,
+      "_gs_",
+      group_size_,
+      "_b_",
+      bits_);
+  auto kernel = get_quantized_kernel_wrapped(
+      d,
+      kname,
+      dequantize_ ? "dequantize" : "quantize",
+      "affine",
+      type_string,
+      group_size_,
+      bits_);
+
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Treat uint32 as uint8 in kernel
+  constexpr int uint8_per_uint32 = 4;
+  constexpr int simd_size = 32;
+  int packs_per_int = (bits_ == 3 || bits_ == 5) ? 8
+      : bits_ == 6                               ? 4
+                                                 : 8 / bits_;
+  int per_thread = dequantize_ ? packs_per_int : group_size_ / simd_size;
+  size_t nthreads =
+      dequantize_ ? out.size() / packs_per_int : w.size() / per_thread;
+
+  NS::UInteger thread_group_size = kernel->maxTotalThreadsPerThreadgroup();
+  if (thread_group_size > nthreads) {
+    thread_group_size = nthreads;
+  }
+  auto group_dims = MTL::Size(thread_group_size, 1, 1);
+  bool use_2d = nthreads > UINT_MAX;
+  auto grid_shape = w.shape();
+  if (dequantize_) {
+    grid_shape.back() *= uint8_per_uint32;
+  } else {
+    grid_shape.back() /= per_thread;
+  }
+  MTL::Size grid_dims = use_2d ? get_2d_grid_dims(grid_shape, w.strides())
+                               : MTL::Size(nthreads, 1, 1);
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/reduce.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/reduce.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..504943d823b6f3adfa8356833d05027f18f638b5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/reduce.cpp
@@ -0,0 +1,1038 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <algorithm>
+#include <cassert>
+
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/kernels/defines.h"
+#include "mlx/backend/metal/reduce.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+namespace {
+
+struct RowReduceArgs {
+  // Input shape and strides not including the reduction axes
+  Shape shape;
+  Strides strides;
+  int ndim;
+
+  // Input shape and strides for the reduction axes
+  Shape reduce_shape;
+  Strides reduce_strides;
+  int reduce_ndim;
+
+  // The number of rows we are reducing. Namely prod(reduce_shape).
+  size_t non_row_reductions;
+
+  // The size of the row.
+  size_t row_size;
+
+  RowReduceArgs(
+      const array& in,
+      const ReductionPlan& plan,
+      const std::vector<int>& axes) {
+    row_size = plan.shape.back();
+
+    reduce_shape = plan.shape;
+    reduce_strides = plan.strides;
+    reduce_shape.pop_back();
+    reduce_strides.pop_back();
+    reduce_ndim = reduce_shape.size();
+
+    non_row_reductions = 1;
+    for (auto s : reduce_shape) {
+      non_row_reductions *= s;
+    }
+
+    std::tie(shape, strides) = shapes_without_reduction_axes(in, axes);
+    std::tie(shape, strides) = collapse_contiguous_dims(shape, strides);
+    ndim = shape.size();
+  }
+
+  void encode(CommandEncoder& compute_encoder) {
+    // Push 0s to avoid encoding empty vectors.
+    if (reduce_ndim == 0) {
+      reduce_shape.push_back(0);
+      reduce_strides.push_back(0);
+    }
+    if (ndim == 0) {
+      shape.push_back(0);
+      strides.push_back(0);
+    }
+
+    compute_encoder.set_bytes(row_size, 2);
+    compute_encoder.set_bytes(non_row_reductions, 3);
+    compute_encoder.set_vector_bytes(shape, 4);
+    compute_encoder.set_vector_bytes(strides, 5);
+    compute_encoder.set_bytes(ndim, 6);
+    compute_encoder.set_vector_bytes(reduce_shape, 7);
+    compute_encoder.set_vector_bytes(reduce_strides, 8);
+    compute_encoder.set_bytes(reduce_ndim, 9);
+
+    if (reduce_ndim == 0) {
+      reduce_shape.pop_back();
+      reduce_strides.pop_back();
+    }
+    if (ndim == 0) {
+      shape.pop_back();
+      strides.pop_back();
+    }
+  }
+};
+
+struct ColReduceArgs {
+  // Input shape and strides not including the reduction axes
+  Shape shape;
+  Strides strides;
+  int ndim;
+
+  // Input shape and strides for the reduction axes
+  Shape reduce_shape;
+  Strides reduce_strides;
+  int reduce_ndim;
+
+  // The number of column reductions we are doing. Namely prod(reduce_shape).
+  size_t non_col_reductions;
+
+  // The size of the contiguous column reduction.
+  size_t reduction_size;
+  int64_t reduction_stride;
+
+  ColReduceArgs(
+      const array& in,
+      const ReductionPlan& plan,
+      const std::vector<int>& axes) {
+    reduction_size = plan.shape.back();
+    reduction_stride = plan.strides.back();
+
+    reduce_shape = plan.shape;
+    reduce_strides = plan.strides;
+    reduce_shape.pop_back();
+    reduce_strides.pop_back();
+    reduce_ndim = reduce_shape.size();
+
+    non_col_reductions = 1;
+    for (auto s : reduce_shape) {
+      non_col_reductions *= s;
+    }
+
+    // We 'll use a stride_back variable because strides.back() could be 0 but
+    // yet we may have removed the appropriate amount of elements. It is safe
+    // to compute the stride by multiplying shapes (while < reduction_stride)
+    // because it is a contiguous section.
+    int64_t stride_back = 1;
+    std::tie(shape, strides) = shapes_without_reduction_axes(in, axes);
+    while (!shape.empty() && stride_back < reduction_stride) {
+      stride_back *= shape.back();
+      shape.pop_back();
+      strides.pop_back();
+    }
+    std::tie(shape, strides) = collapse_contiguous_dims(shape, strides);
+    ndim = shape.size();
+  }
+
+  /**
+   * Create the col reduce arguments for reducing the 1st axis of the row
+   * contiguous intermediate array.
+   */
+  ColReduceArgs(const array& intermediate) {
+    assert(intermediate.flags().row_contiguous);
+
+    reduction_size = intermediate.shape(0);
+    reduction_stride = intermediate.size() / reduction_size;
+    non_col_reductions = 1;
+    reduce_ndim = 0;
+    ndim = 0;
+  }
+
+  void encode(CommandEncoder& compute_encoder) {
+    // Push 0s to avoid encoding empty vectors.
+    if (reduce_ndim == 0) {
+      reduce_shape.push_back(0);
+      reduce_strides.push_back(0);
+    }
+    if (ndim == 0) {
+      shape.push_back(0);
+      strides.push_back(0);
+    }
+
+    compute_encoder.set_bytes(reduction_size, 2);
+    compute_encoder.set_bytes(reduction_stride, 3);
+    compute_encoder.set_vector_bytes(shape, 4);
+    compute_encoder.set_vector_bytes(strides, 5);
+    compute_encoder.set_bytes(ndim, 6);
+    compute_encoder.set_vector_bytes(reduce_shape, 7);
+    compute_encoder.set_vector_bytes(reduce_strides, 8);
+    compute_encoder.set_bytes(reduce_ndim, 9);
+    compute_encoder.set_bytes(non_col_reductions, 10);
+
+    if (reduce_ndim == 0) {
+      reduce_shape.pop_back();
+      reduce_strides.pop_back();
+    }
+    if (ndim == 0) {
+      shape.pop_back();
+      strides.pop_back();
+    }
+  }
+};
+
+} // namespace
+
+inline auto safe_div(size_t n, size_t m) {
+  return m == 0 ? 0 : (n + m - 1) / m;
+}
+
+inline auto safe_divup(size_t n, size_t m) {
+  return safe_div(n, m) * m;
+}
+
+inline bool is_64b_int(Dtype dtype) {
+  return dtype == int64 || dtype == uint64;
+}
+
+inline bool is_64b_dtype(Dtype dtype) {
+  return dtype == int64 || dtype == uint64 || dtype == complex64;
+}
+
+inline int get_kernel_reduce_ndim(int reduce_ndim) {
+  if (reduce_ndim <= 1) {
+    return 1;
+  } else if (reduce_ndim == 2) {
+    return 2;
+  } else {
+    return 5;
+  }
+}
+
+inline int threadgroup_size_from_row_size(int row_size) {
+  // 1 simdgroup per row smallish rows
+  if (row_size <= 512) {
+    return 32;
+  }
+
+  // 2 simdgroups per row for medium rows
+  if (row_size <= 1024) {
+    return 128;
+  }
+
+  // up to 32 simdgroups after that
+  int thread_group_size;
+  thread_group_size = (row_size + REDUCE_N_READS - 1) / REDUCE_N_READS;
+  thread_group_size = ((thread_group_size + 31) / 32) * 32;
+  thread_group_size = std::min(1024, thread_group_size);
+  return thread_group_size;
+}
+
+inline auto output_grid_for_col_reduce(
+    const array& out,
+    const ColReduceArgs& args) {
+  auto out_shape = out.shape();
+  auto out_strides = out.strides();
+  while (!out_shape.empty() && out_strides.back() < args.reduction_stride) {
+    out_shape.pop_back();
+    out_strides.pop_back();
+  }
+  return get_2d_grid_dims(out_shape, out_strides);
+}
+
+std::pair<Dtype, Dtype> remap_reduce_types(
+    const array& in,
+    const std::string& op_name) {
+  if (op_name == "sum" || op_name == "prod") {
+    if (issubdtype(in.dtype(), integer)) {
+      switch (in.dtype()) {
+        case uint8:
+          return {uint8, uint32};
+        case uint16:
+          return {uint16, uint32};
+        case uint32:
+          return {uint32, uint32};
+        case uint64:
+          return {uint64, uint64};
+        case int8:
+          return {int8, int32};
+        case int16:
+          return {int16, int32};
+        case int32:
+          return {int32, int32};
+        case int64:
+          return {int64, int64};
+        default:
+          throw std::runtime_error("Unsupported integer type");
+      }
+    }
+    if (in.dtype() == bool_) {
+      return {int8, int32};
+    }
+    return {in.dtype(), in.dtype()};
+  } else if (op_name == "and" || op_name == "or") {
+    if (in.dtype().size() == 1) {
+      return {bool_, bool_};
+    } else if (in.dtype().size() == 2) {
+      return {int16, bool_};
+    } else if (in.dtype().size() == 4) {
+      return {int32, bool_};
+    } else {
+      return {int64, bool_};
+    }
+  }
+  return {in.dtype(), in.dtype()};
+}
+
+void init_reduce(
+    array& out,
+    const std::string& op_name,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s) {
+  auto [_, out_type] = remap_reduce_types(out, op_name);
+  const std::string func_name = "init_reduce";
+  std::string kname = func_name;
+  concatenate(kname, "_", op_name, type_to_name(out_type));
+  auto kernel = get_reduce_init_kernel(d, kname, func_name, op_name, out_type);
+  size_t nthreads = out.size();
+  MTL::Size grid_dims = MTL::Size(nthreads, 1, 1);
+  NS::UInteger thread_group_size = kernel->maxTotalThreadsPerThreadgroup();
+  if (thread_group_size > nthreads) {
+    thread_group_size = nthreads;
+  }
+  MTL::Size group_dims = MTL::Size(thread_group_size, 1, 1);
+  compute_encoder.set_compute_pipeline_state(kernel);
+  compute_encoder.set_output_array(out, 0);
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+void all_reduce_dispatch(
+    const array& in,
+    array& out,
+    const std::string& op_name,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s) {
+  // Set the kernel
+  auto [in_type, out_type] = remap_reduce_types(in, op_name);
+  const std::string func_name = "all_reduce";
+  std::string kname = func_name;
+  concatenate(kname, "_", op_name, type_to_name(in_type));
+  auto kernel = get_reduce_kernel(
+      d, kname, func_name, op_name, in_type, out_type, "int64_t");
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  size_t in_size = in.size();
+
+  // Small array so dispatch a single threadgroup
+  if (in_size <= REDUCE_N_READS * 1024) {
+    int threadgroup_size = (in_size + REDUCE_N_READS - 1) / REDUCE_N_READS;
+    threadgroup_size = ((threadgroup_size + 31) / 32) * 32;
+    MTL::Size grid_dims(threadgroup_size, 1, 1);
+
+    compute_encoder.set_input_array(in, 0);
+    compute_encoder.set_output_array(out, 1);
+    compute_encoder.set_bytes(in_size, 2);
+    compute_encoder.set_bytes(in_size, 3);
+    compute_encoder.dispatch_threads(grid_dims, grid_dims);
+  }
+
+  // We need multiple threadgroups so we 'll do it in 2 passes.
+  else {
+    int n_rows, threadgroup_2nd_pass;
+    // Less than 2**26 bytes
+    if (in.nbytes() <= (1 << 26)) {
+      n_rows = 32 * REDUCE_N_READS;
+      threadgroup_2nd_pass = 32;
+    }
+
+    // Really large matrix so parallelize as much as possible
+    else {
+      n_rows = 1024 * REDUCE_N_READS;
+      threadgroup_2nd_pass = 1024;
+    }
+
+    // Allocate an intermediate tensor to hold results if needed
+    array intermediate({n_rows}, out_type, nullptr, {});
+    intermediate.set_data(allocator::malloc(intermediate.nbytes()));
+    d.add_temporary(intermediate, s.index);
+
+    // 1st pass
+    size_t row_size = (in_size + n_rows - 1) / n_rows;
+    int threadgroup_size =
+        std::min((row_size + REDUCE_N_READS - 1) / REDUCE_N_READS, 1024ul);
+    threadgroup_size = ((threadgroup_size + 31) / 32) * 32;
+    MTL::Size grid_dims(threadgroup_size, n_rows, 1);
+    MTL::Size group_dims(threadgroup_size, 1, 1);
+    compute_encoder.set_input_array(in, 0);
+    compute_encoder.set_output_array(intermediate, 1);
+    compute_encoder.set_bytes(in_size, 2);
+    compute_encoder.set_bytes(row_size, 3);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+
+    // 2nd pass
+    std::string kname_2nd_pass = func_name;
+    concatenate(kname_2nd_pass, "_", op_name, type_to_name(intermediate));
+    auto kernel_2nd_pass = get_reduce_kernel(
+        d, kname_2nd_pass, func_name, op_name, out_type, out_type, "int64_t");
+    compute_encoder.set_compute_pipeline_state(kernel_2nd_pass);
+    size_t intermediate_size = n_rows;
+    grid_dims = MTL::Size(threadgroup_2nd_pass, 1, 1);
+    group_dims = MTL::Size(threadgroup_2nd_pass, 1, 1);
+    compute_encoder.set_input_array(intermediate, 0);
+    compute_encoder.set_output_array(out, 1);
+    compute_encoder.set_bytes(intermediate_size, 2);
+    compute_encoder.set_bytes(intermediate_size, 3);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+}
+
+void row_reduce_small(
+    const array& in,
+    array& out,
+    const std::string& op_name,
+    RowReduceArgs& args,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s) {
+  // Set the kernel
+  int n = get_kernel_reduce_ndim(args.reduce_ndim);
+  auto [in_type, out_type] = remap_reduce_types(in, op_name);
+  const std::string func_name = "row_reduce_small";
+  std::string kname = func_name;
+  bool large = in.size() > INT32_MAX;
+  if (large) {
+    kname += "_large";
+  }
+  concatenate(
+      kname,
+      "_",
+      std::to_string(n),
+      "_reduce_",
+      op_name,
+      type_to_name(in_type));
+  auto kernel = get_reduce_kernel(
+      d,
+      kname,
+      func_name,
+      op_name,
+      in_type,
+      out_type,
+      large ? "size_t" : "int",
+      n);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Figure out the grid dims
+  MTL::Size grid_dims;
+  MTL::Size group_dims;
+  if ((args.non_row_reductions < 32 && args.row_size <= 8) ||
+      args.non_row_reductions <= 8) {
+    grid_dims = get_2d_grid_dims(out.shape(), out.strides());
+    group_dims =
+        MTL::Size((grid_dims.width < 1024) ? grid_dims.width : 1024, 1, 1);
+  } else {
+    auto out_grid_size = get_2d_grid_dims(out.shape(), out.strides());
+    grid_dims = MTL::Size(32, out_grid_size.width, out_grid_size.height);
+    group_dims = MTL::Size(32, 1, 1);
+  }
+
+  // Launch
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_output_array(out, 1);
+  args.encode(compute_encoder);
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+void row_reduce_simple(
+    const array& in,
+    array& out,
+    const std::string& op_name,
+    RowReduceArgs& args,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s) {
+  // Set the kernel
+  auto [in_type, out_type] = remap_reduce_types(in, op_name);
+  const std::string func_name = "row_reduce_simple";
+  std::string kname = func_name;
+  concatenate(kname, "_", op_name, type_to_name(in_type));
+
+  auto kernel = get_reduce_kernel(
+      d, kname, func_name, op_name, in_type, out_type, "size_t");
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Figure out the grid dims
+  size_t row_size = args.row_size;
+  size_t out_size = out.size();
+  auto out_grid_size = get_2d_grid_dims(out.shape(), out.strides());
+  out_grid_size.width =
+      (out_grid_size.width + REDUCE_N_WRITES - 1) / REDUCE_N_WRITES;
+  int threadgroup_size = threadgroup_size_from_row_size(row_size);
+  if (in.itemsize() == 8) {
+    threadgroup_size = std::min(threadgroup_size, 512);
+  }
+  MTL::Size grid_dims(
+      threadgroup_size, out_grid_size.width, out_grid_size.height);
+  MTL::Size group_dims(threadgroup_size, 1, 1);
+
+  // Launch
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_output_array(out, 1);
+  compute_encoder.set_bytes(row_size, 2);
+  compute_encoder.set_bytes(out_size, 3);
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+void row_reduce_looped(
+    const array& in,
+    array& out,
+    const std::string& op_name,
+    RowReduceArgs& args,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s) {
+  auto [in_type, out_type] = remap_reduce_types(in, op_name);
+
+  // Set the kernel
+  int n = get_kernel_reduce_ndim(args.reduce_ndim);
+  const std::string func_name = "row_reduce_looped";
+  std::string kname = func_name;
+  bool large = in.size() > INT32_MAX;
+  if (large) {
+    kname += "_large";
+  }
+  concatenate(
+      kname,
+      "_",
+      std::to_string(n),
+      "_reduce_",
+      op_name,
+      type_to_name(in_type));
+  auto kernel = get_reduce_kernel(
+      d,
+      kname,
+      func_name,
+      op_name,
+      in_type,
+      out_type,
+      large ? "size_t" : "int",
+      n);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Figure out the grid
+  auto out_grid_size = get_2d_grid_dims(out.shape(), out.strides());
+  int threadgroup_size = threadgroup_size_from_row_size(args.row_size);
+  MTL::Size grid_dims(
+      threadgroup_size, out_grid_size.width, out_grid_size.height);
+  MTL::Size group_dims(threadgroup_size, 1, 1);
+
+  // Launch
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_output_array(out, 1);
+  args.encode(compute_encoder);
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+void row_reduce_general_dispatch(
+    const array& in,
+    array& out,
+    const std::string& op_name,
+    const ReductionPlan& plan,
+    const std::vector<int>& axes,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s) {
+  // Prepare the arguments for the kernel
+  RowReduceArgs args(in, plan, axes);
+
+  // Case 1: The row is small
+  if (args.row_size <= 64) {
+    return row_reduce_small(in, out, op_name, args, compute_encoder, d, s);
+  }
+
+  // Case 2: Contiguous reduce without non-row reductions
+  if (plan.type == ContiguousReduce && args.reduce_ndim == 0 &&
+      in.size() / args.row_size >= 32) {
+    return row_reduce_simple(in, out, op_name, args, compute_encoder, d, s);
+  }
+
+  // Case 3: General row reduce including non-row reductions
+  return row_reduce_looped(in, out, op_name, args, compute_encoder, d, s);
+}
+
+void strided_reduce_small(
+    const array& in,
+    array& out,
+    const std::string& op_name,
+    ColReduceArgs& args,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s) {
+  auto [in_type, out_type] = remap_reduce_types(in, op_name);
+
+  // Figure out the grid dims
+  MTL::Size grid_dims, group_dims;
+
+  // Prepare the arguments for the kernel
+  args.reduce_shape.push_back(args.reduction_size);
+  args.reduce_strides.push_back(args.reduction_stride);
+  args.reduce_ndim++;
+
+  int n = get_kernel_reduce_ndim(args.reduce_ndim);
+  const std::string func_name = "col_reduce_small";
+  std::string kname = func_name;
+  bool large = in.size() > INT32_MAX;
+  if (large) {
+    kname += "_large";
+  }
+  concatenate(
+      kname,
+      "_",
+      std::to_string(n),
+      "_reduce_",
+      op_name,
+      type_to_name(in_type));
+  auto kernel = get_reduce_kernel(
+      d,
+      kname,
+      func_name,
+      op_name,
+      in_type,
+      out_type,
+      large ? "size_t" : "int",
+      n);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  const int n_reads = 4;
+  size_t reduction_stride_blocks =
+      (args.reduction_stride + n_reads - 1) / n_reads;
+  size_t total = args.reduction_size * args.non_col_reductions;
+  size_t threadgroup_x = std::min(reduction_stride_blocks, 32ul);
+  size_t threadgroup_y = std::min(
+      8ul,
+      std::min(kernel->maxTotalThreadsPerThreadgroup() / threadgroup_x, total));
+
+  group_dims = MTL::Size(threadgroup_x, threadgroup_y, 1);
+  grid_dims = output_grid_for_col_reduce(out, args);
+  grid_dims = MTL::Size(
+      (reduction_stride_blocks + threadgroup_x - 1) / threadgroup_x,
+      grid_dims.width,
+      grid_dims.height);
+
+  // Launch
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_output_array(out, 1);
+  args.encode(compute_encoder);
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void strided_reduce_longcolumn(
+    const array& in,
+    array& out,
+    const std::string& op_name,
+    ColReduceArgs& args,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s) {
+  auto [in_type, out_type] = remap_reduce_types(in, op_name);
+  size_t total_reduction_size = args.reduction_size * args.non_col_reductions;
+  size_t outer_blocks = 32;
+  if (total_reduction_size >= 32768) {
+    outer_blocks = 128;
+  }
+
+  // Prepare the temporary accumulator
+  Shape intermediate_shape;
+  intermediate_shape.reserve(out.ndim() + 1);
+  intermediate_shape.push_back(outer_blocks);
+  intermediate_shape.insert(
+      intermediate_shape.end(), out.shape().begin(), out.shape().end());
+  array intermediate(std::move(intermediate_shape), out_type, nullptr, {});
+  intermediate.set_data(allocator::malloc(intermediate.nbytes()));
+  d.add_temporary(intermediate, s.index);
+
+  // Prepare the arguments for the kernel
+  args.reduce_shape.push_back(args.reduction_size);
+  args.reduce_strides.push_back(args.reduction_stride);
+  args.reduce_ndim++;
+
+  // Figure out the grid dims
+  size_t out_size = out.size();
+  size_t threadgroup_x = args.reduction_stride;
+  size_t threadgroup_y =
+      (args.non_col_reductions * args.reduction_size + outer_blocks - 1) /
+      outer_blocks;
+  threadgroup_y = std::min(32ul, threadgroup_y);
+
+  auto out_grid_size = output_grid_for_col_reduce(out, args);
+  MTL::Size grid_dims(out_grid_size.width, out_grid_size.height, outer_blocks);
+  MTL::Size group_dims(threadgroup_x, threadgroup_y, 1);
+
+  // Set the kernel
+  int n = get_kernel_reduce_ndim(args.reduce_ndim);
+  std::string func_name = "col_reduce_longcolumn";
+  std::string kname = func_name;
+  bool large = in.size() > INT32_MAX;
+  if (large) {
+    kname += "_large";
+  }
+  concatenate(
+      kname,
+      "_",
+      std::to_string(n),
+      "_reduce_",
+      op_name,
+      type_to_name(in_type));
+  auto kernel = get_reduce_kernel(
+      d,
+      kname,
+      func_name,
+      op_name,
+      in_type,
+      out_type,
+      large ? "int64_t" : "int",
+      n);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Launch
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_output_array(intermediate, 1);
+  args.encode(compute_encoder);
+  compute_encoder.set_bytes(out_size, 11);
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+
+  // Make the 2nd pass arguments and grid_dims
+  ColReduceArgs second_args(intermediate);
+  second_args.reduce_shape.push_back(outer_blocks);
+  second_args.reduce_strides.push_back(out.size());
+  second_args.reduce_ndim++;
+  int BN = 32;
+  grid_dims = MTL::Size(256 * ((out.size() + BN - 1) / BN), 1, 1);
+  group_dims = MTL::Size(256, 1, 1);
+
+  // Set the 2nd kernel
+  func_name = "col_reduce_looped";
+  kname = func_name;
+  large = intermediate.size() > INT32_MAX;
+  if (large) {
+    kname += "_large";
+  }
+  concatenate(kname, "_1_32_32_reduce_", op_name, type_to_name(intermediate));
+  kernel = get_reduce_kernel(
+      d,
+      kname,
+      func_name,
+      op_name,
+      intermediate.dtype(),
+      out_type,
+      large ? "int64_t" : "int",
+      1,
+      32,
+      32);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  compute_encoder.set_input_array(intermediate, 0);
+  compute_encoder.set_output_array(out, 1);
+  second_args.encode(compute_encoder);
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+void strided_reduce_looped(
+    const array& in,
+    array& out,
+    const std::string& op_name,
+    ColReduceArgs& args,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s) {
+  auto [in_type, out_type] = remap_reduce_types(in, op_name);
+
+  // Prepare the arguments for the kernel
+  args.reduce_shape.push_back(args.reduction_size);
+  args.reduce_strides.push_back(args.reduction_stride);
+  args.reduce_ndim++;
+
+  // Figure out the grid dims
+  auto out_grid_size = output_grid_for_col_reduce(out, args);
+  int BN = 32;
+  int BM = 1024 / BN;
+  int threadgroup_size = 8 * 32;
+  MTL::Size grid_dims(
+      threadgroup_size * ((args.reduction_stride + BN - 1) / BN),
+      out_grid_size.width,
+      out_grid_size.height);
+  MTL::Size group_dims(threadgroup_size, 1, 1);
+
+  // Set the kernel
+  int n = get_kernel_reduce_ndim(args.reduce_ndim);
+  std::string func_name = "col_reduce_looped";
+  std::string kname = func_name;
+  bool large = in.size() > INT32_MAX;
+  if (large) {
+    kname += "_large";
+  }
+  concatenate(
+      kname,
+      "_",
+      std::to_string(n),
+      "_",
+      std::to_string(BM),
+      "_",
+      std::to_string(BN),
+      "_reduce_",
+      op_name,
+      type_to_name(in_type));
+  auto kernel = get_reduce_kernel(
+      d,
+      kname,
+      func_name,
+      op_name,
+      in_type,
+      out_type,
+      large ? "int64_t" : "int",
+      n,
+      BM,
+      BN);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Launch
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_output_array(out, 1);
+  args.encode(compute_encoder);
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+void strided_reduce_2pass(
+    const array& in,
+    array& out,
+    const std::string& op_name,
+    ColReduceArgs& args,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s) {
+  auto [in_type, out_type] = remap_reduce_types(in, op_name);
+
+  // Prepare the temporary accumulator
+  Shape intermediate_shape;
+  intermediate_shape.reserve(out.ndim() + 1);
+  intermediate_shape.push_back(32);
+  intermediate_shape.insert(
+      intermediate_shape.end(), out.shape().begin(), out.shape().end());
+  array intermediate(std::move(intermediate_shape), out_type, nullptr, {});
+  intermediate.set_data(allocator::malloc(intermediate.nbytes()));
+  d.add_temporary(intermediate, s.index);
+
+  // Prepare the arguments for the kernel
+  args.reduce_shape.push_back(args.reduction_size);
+  args.reduce_strides.push_back(args.reduction_stride);
+  args.reduce_ndim++;
+
+  // Figure out the grid dims
+  size_t out_size = out.size() / args.reduction_stride;
+  auto out_grid_size = output_grid_for_col_reduce(out, args);
+  int outer_blocks = 32;
+  int BN = 32;
+  int BM = 1024 / BN;
+  int threadgroup_size = 8 * 32;
+  MTL::Size grid_dims(
+      threadgroup_size * ((args.reduction_stride + BN - 1) / BN),
+      out_grid_size.width * outer_blocks,
+      out_grid_size.height);
+  MTL::Size group_dims(threadgroup_size, 1, 1);
+
+  // Set the kernel
+  int n = get_kernel_reduce_ndim(args.reduce_ndim);
+  std::string func_name = "col_reduce_2pass";
+  std::string kname = func_name;
+  bool large = in.size() > INT32_MAX;
+  if (large) {
+    kname += "_large";
+  }
+  concatenate(
+      kname,
+      "_",
+      std::to_string(n),
+      "_",
+      std::to_string(BM),
+      "_",
+      std::to_string(BN),
+      "_reduce_",
+      op_name,
+      type_to_name(in_type));
+  auto kernel = get_reduce_kernel(
+      d,
+      kname,
+      func_name,
+      op_name,
+      in_type,
+      out_type,
+      large ? "int64_t" : "int",
+      n,
+      BM,
+      BN);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Launch
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_output_array(intermediate, 1);
+  args.encode(compute_encoder);
+  compute_encoder.set_bytes(out_size, 11);
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+
+  // Make the 2nd pass arguments and grid_dims
+  ColReduceArgs second_args(intermediate);
+  second_args.reduce_shape.push_back(outer_blocks);
+  second_args.reduce_strides.push_back(out.size());
+  second_args.reduce_ndim++;
+  grid_dims = MTL::Size(threadgroup_size * ((out.size() + BN - 1) / BN), 1, 1);
+
+  // Set the 2nd kernel
+  func_name = "col_reduce_looped";
+  kname = func_name;
+  large = intermediate.size() > INT32_MAX;
+  if (large) {
+    kname += "_large";
+  }
+  concatenate(kname, "_1_32_32_reduce_", op_name, type_to_name(intermediate));
+  kernel = get_reduce_kernel(
+      d,
+      kname,
+      func_name,
+      op_name,
+      intermediate.dtype(),
+      out_type,
+      large ? "int64_t" : "int",
+      1,
+      32,
+      32);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  compute_encoder.set_input_array(intermediate, 0);
+  compute_encoder.set_output_array(out, 1);
+  second_args.encode(compute_encoder);
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+void strided_reduce_general_dispatch(
+    const array& in,
+    array& out,
+    const std::string& op_name,
+    const ReductionPlan& plan,
+    const std::vector<int>& axes,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s) {
+  // Prepare the arguments for the kernel
+  ColReduceArgs args(in, plan, axes);
+
+  // Small column
+  if (args.reduction_size * args.non_col_reductions < 32) {
+    return strided_reduce_small(in, out, op_name, args, compute_encoder, d, s);
+  }
+
+  // Long column but small row
+  if (args.reduction_stride < 32 &&
+      args.reduction_size * args.non_col_reductions >= 1024) {
+    return strided_reduce_longcolumn(
+        in, out, op_name, args, compute_encoder, d, s);
+  }
+
+  if (args.reduction_size * args.non_col_reductions > 256 &&
+      out.size() / 32 < 1024) {
+    return strided_reduce_2pass(in, out, op_name, args, compute_encoder, d, s);
+  }
+
+  return strided_reduce_looped(in, out, op_name, args, compute_encoder, d, s);
+}
+
+void Reduce::eval_gpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  array in = inputs[0];
+
+  // Make sure no identity reductions trickle down here
+  assert(!axes_.empty());
+  assert(out.size() != in.size());
+
+  // Continue with reduction operation
+  // Minimum of 4 bytes since we use size 4 structs for all reduce
+  // and metal will complain o/w
+  size_t min_bytes = std::max(out.nbytes(), 4ul);
+  out.set_data(allocator::malloc(min_bytes));
+  std::string op_name;
+  switch (reduce_type_) {
+    case Reduce::And:
+      op_name = "and";
+      break;
+    case Reduce::Or:
+      op_name = "or";
+      break;
+    case Reduce::Sum:
+      op_name = "sum";
+      break;
+    case Reduce::Prod:
+      op_name = "prod";
+      break;
+    case Reduce::Min:
+      op_name = out.dtype() == bool_ ? "and" : "min";
+      break;
+    case Reduce::Max:
+      op_name = out.dtype() == bool_ ? "or" : "max";
+      break;
+  }
+
+  // Initialize output
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+
+  // Reduce
+  if (in.size() > 0) {
+    ReductionPlan plan = get_reduction_plan(in, axes_);
+
+    // If it is a general reduce then copy the input to a contiguous array and
+    // recompute the plan.
+    //
+    // TODO: This can be avoided by making the output have the same strides as
+    //       input for the axes with stride smaller than the minimum reduction
+    //       stride.
+    if (plan.type == GeneralReduce) {
+      array in_copy = contiguous_copy_gpu(in, s);
+      d.add_temporary(in_copy, s.index);
+      in = in_copy;
+      plan = get_reduction_plan(in, axes_);
+    }
+
+    // Reducing over everything and the data is all there no broadcasting or
+    // slicing etc.
+    if (plan.type == ContiguousAllReduce) {
+      all_reduce_dispatch(in, out, op_name, compute_encoder, d, s);
+    }
+
+    // At least the last dimension is row contiguous and we are reducing over
+    // the last dim.
+    else if (
+        plan.type == ContiguousReduce || plan.type == GeneralContiguousReduce) {
+      row_reduce_general_dispatch(
+          in, out, op_name, plan, axes_, compute_encoder, d, s);
+    }
+
+    // At least the last two dimensions are contiguous and we are doing a
+    // strided reduce over these.
+    else if (
+        plan.type == ContiguousStridedReduce ||
+        plan.type == GeneralStridedReduce) {
+      strided_reduce_general_dispatch(
+          in, out, op_name, plan, axes_, compute_encoder, d, s);
+    }
+  }
+
+  // Nothing to reduce just initialize the output
+  else {
+    init_reduce(out, op_name, compute_encoder, d, s);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/reduce.h b/ml-stable-diffusion/mlx/mlx/backend/metal/reduce.h
new file mode 100644
index 0000000000000000000000000000000000000000..a997d7e245e46a7fbb218cd70912ee3cfb00a89e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/reduce.h
@@ -0,0 +1,41 @@
+// Copyright @ 2023 - 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/common/reduce.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/stream.h"
+
+namespace mlx::core {
+
+using metal::CommandEncoder;
+
+void all_reduce_dispatch(
+    const array& in,
+    array& out,
+    const std::string& op_name,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s);
+
+void row_reduce_general_dispatch(
+    const array& in,
+    array& out,
+    const std::string& op_name,
+    const ReductionPlan& plan,
+    const std::vector<int>& axes,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s);
+
+void strided_reduce_general_dispatch(
+    const array& in,
+    array& out,
+    const std::string& op_name,
+    const ReductionPlan& plan,
+    const std::vector<int>& axes,
+    CommandEncoder& compute_encoder,
+    metal::Device& d,
+    const Stream& s);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/resident.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/resident.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..798824c2fbf4d49591018d4e2b59df4b3479f12f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/resident.cpp
@@ -0,0 +1,100 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/backend/metal/resident.h"
+
+namespace mlx::core::metal {
+
+ResidencySet::ResidencySet(MTL::Device* d) {
+  if (!d->supportsFamily(MTL::GPUFamilyMetal3)) {
+    return;
+  } else if (__builtin_available(macOS 15, iOS 18, *)) {
+    auto pool = new_scoped_memory_pool();
+    auto desc = MTL::ResidencySetDescriptor::alloc()->init();
+    NS::Error* error;
+    wired_set_ = d->newResidencySet(desc, &error);
+    desc->release();
+    if (!wired_set_) {
+      std::ostringstream msg;
+      msg << "[metal::Device] Unable to construct residency set.\n";
+      if (error) {
+        msg << error->localizedDescription()->utf8String() << "\n";
+      }
+      throw std::runtime_error(msg.str());
+    }
+    wired_set_->requestResidency();
+  }
+}
+
+void ResidencySet::insert(MTL::Allocation* buf) {
+  if (!wired_set_) {
+    return;
+  }
+  if (wired_set_->allocatedSize() + buf->allocatedSize() <= capacity_) {
+    wired_set_->addAllocation(buf);
+    wired_set_->commit();
+  } else {
+    unwired_set_.insert(buf);
+  }
+}
+
+void ResidencySet::erase(MTL::Allocation* buf) {
+  if (!wired_set_) {
+    return;
+  }
+  if (auto it = unwired_set_.find(buf); it != unwired_set_.end()) {
+    unwired_set_.erase(it);
+  } else {
+    wired_set_->removeAllocation(buf);
+    wired_set_->commit();
+  }
+}
+
+void ResidencySet::resize(size_t size) {
+  if (!wired_set_) {
+    return;
+  }
+
+  if (capacity_ == size) {
+    return;
+  }
+  capacity_ = size;
+
+  size_t current_size = wired_set_->allocatedSize();
+
+  if (current_size < size) {
+    auto pool = new_scoped_memory_pool();
+    // Add unwired allocations to the set
+    for (auto it = unwired_set_.begin(); it != unwired_set_.end();) {
+      auto buf_size = (*it)->allocatedSize();
+      if (current_size + buf_size > size) {
+        it++;
+      } else {
+        current_size += buf_size;
+        wired_set_->addAllocation(*it);
+        unwired_set_.erase(it++);
+      }
+    }
+    wired_set_->commit();
+  } else if (current_size > size) {
+    auto pool = new_scoped_memory_pool();
+    // Remove wired allocations until under capacity
+    auto allocations = wired_set_->allAllocations();
+    auto num_allocations = wired_set_->allocationCount();
+    for (int i = 0; i < num_allocations && current_size > size; ++i) {
+      auto buf = static_cast<const MTL::Allocation*>(allocations->object(i));
+      wired_set_->removeAllocation(buf);
+      current_size -= buf->allocatedSize();
+      unwired_set_.insert(buf);
+    }
+    wired_set_->commit();
+  }
+}
+
+ResidencySet::~ResidencySet() {
+  if (wired_set_) {
+    auto pool = new_scoped_memory_pool();
+    wired_set_->release();
+  }
+}
+
+} // namespace mlx::core::metal
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/resident.h b/ml-stable-diffusion/mlx/mlx/backend/metal/resident.h
new file mode 100644
index 0000000000000000000000000000000000000000..5db55828630e68a6b4f121a185dbfae54a5eb1f1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/resident.h
@@ -0,0 +1,32 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/backend/metal/device.h"
+
+namespace mlx::core::metal {
+
+class ResidencySet {
+ public:
+  ResidencySet(MTL::Device* d);
+  ~ResidencySet();
+
+  ResidencySet(const ResidencySet&) = delete;
+  ResidencySet& operator=(const ResidencySet&) = delete;
+
+  const MTL::ResidencySet* mtl_residency_set() {
+    return wired_set_;
+  }
+
+  void insert(MTL::Allocation* buf);
+  void erase(MTL::Allocation* buf);
+
+  void resize(size_t size);
+
+ private:
+  MTL::ResidencySet* wired_set_{nullptr};
+  std::unordered_set<const MTL::Allocation*> unwired_set_;
+  size_t capacity_{0};
+};
+
+} // namespace mlx::core::metal
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/rope.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/rope.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ca0a66221269b43f834a35d366027ab1ef27b921
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/rope.cpp
@@ -0,0 +1,165 @@
+// Copyright © 2023-2024 Apple Inc.
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/fast_primitives.h"
+
+namespace mlx::core::fast {
+
+constexpr int n_per_thread = 4;
+
+bool RoPE::use_fallback(Stream s) {
+  return s.device == Device::cpu;
+}
+
+void RoPE::eval_gpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  assert(outputs.size() == 1);
+  auto& in = inputs[0];
+  auto& out = outputs[0];
+
+  auto& s = out.primitive().stream();
+  auto& d = metal::device(s.device);
+
+  int64_t strides[3];
+  int64_t out_strides[3];
+  bool donated = false;
+  int ndim = in.ndim();
+  int B = in.shape(0);
+  int T = in.shape(-2);
+  int D = in.shape(-1);
+  size_t mat_size = T * D;
+  bool large = in.data_size() > INT32_MAX || in.size() > INT32_MAX;
+
+  int dispatch_ndim = ndim;
+  while (in.shape(-dispatch_ndim) == 1 && dispatch_ndim > 3) {
+    dispatch_ndim--;
+  }
+
+  int N = 1;
+  for (int i = 1; i < (ndim - 2); ++i) {
+    N *= in.shape(i);
+  }
+
+  bool head_seq_transpose = false;
+
+  if (dims_ < D) {
+    donated = true;
+    auto ctype =
+        (in.flags().row_contiguous) ? CopyType::Vector : CopyType::General;
+    copy_gpu(in, out, ctype, s);
+    strides[0] = mat_size;
+    strides[1] = out.strides()[ndim - 2];
+    strides[2] = out.strides()[ndim - 1];
+  } else if (in.flags().row_contiguous) {
+    if (in.is_donatable()) {
+      donated = true;
+      out.copy_shared_buffer(in);
+    } else {
+      out.set_data(allocator::malloc(out.nbytes()));
+    }
+    strides[0] = mat_size;
+    strides[1] = in.strides()[ndim - 2];
+    strides[2] = in.strides()[ndim - 1];
+  } else if (dispatch_ndim == 3) {
+    // Handle non-contiguous 3D inputs
+    out.set_data(allocator::malloc(out.nbytes()));
+    strides[0] = in.strides()[ndim - 3];
+    strides[1] = in.strides()[ndim - 2];
+    strides[2] = in.strides()[ndim - 1];
+  } else if (
+      ndim == 4 &&
+      // batch dim is regularly strided
+      in.strides()[0] == T * N * D &&
+      // sequence and head dimensions are transposed
+      in.strides()[1] == D && in.strides()[2] == N * D) {
+    head_seq_transpose = true;
+    out.set_data(allocator::malloc(out.nbytes()));
+    strides[0] = in.strides()[1];
+    strides[1] = in.strides()[2];
+    strides[2] = in.strides()[3];
+  } else {
+    // Copy non-contiguous > 3D inputs into the output and treat
+    // input as donated
+    donated = true;
+    copy_gpu(in, out, CopyType::General, s);
+    strides[0] = mat_size;
+    strides[1] = out.strides()[ndim - 2];
+    strides[2] = out.strides()[ndim - 1];
+  }
+  out_strides[0] = mat_size;
+  out_strides[1] = out.strides()[ndim - 2];
+  out_strides[2] = out.strides()[ndim - 1];
+
+  // Special case for inference (single time step, contiguous, one offset)
+  auto& offset = inputs[1];
+  bool single = in.flags().row_contiguous && T == 1 && offset.size() == 1;
+
+  bool with_freqs = inputs.size() == 3;
+  std::string kname;
+  concatenate(
+      kname,
+      "rope_",
+      single ? "single_" : "",
+      (with_freqs) ? "freqs_" : "",
+      large ? "large_" : "",
+      type_to_name(in));
+  std::string hash_name;
+  concatenate(
+      hash_name,
+      kname,
+      "_",
+      forward_ ? "" : "vjp_",
+      traditional_ ? "traditional_" : "",
+      head_seq_transpose ? "transpose" : "");
+  metal::MTLFCList func_consts = {
+      {&forward_, MTL::DataType::DataTypeBool, 1},
+      {&traditional_, MTL::DataType::DataTypeBool, 2},
+      {&head_seq_transpose, MTL::DataType::DataTypeBool, 3}};
+
+  auto kernel = d.get_kernel(kname, hash_name, func_consts);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+
+  float base = std::log2(base_);
+  compute_encoder.set_compute_pipeline_state(kernel);
+  compute_encoder.set_input_array(donated ? out : in, 0);
+  compute_encoder.set_output_array(out, 1);
+
+  compute_encoder.set_input_array(offset, 2);
+  compute_encoder.set_bytes(scale_, 3);
+
+  MTL::Size group_dims;
+  MTL::Size grid_dims;
+  if (single) {
+    compute_encoder.set_bytes(out_strides, 1, 4);
+    uint32_t dim0 = dims_ / 2;
+    group_dims = get_block_dims(dim0, N, 1);
+    grid_dims = MTL::Size(dim0, N, 1);
+  } else {
+    compute_encoder.set_bytes(strides, 3, 4);
+    compute_encoder.set_bytes(out_strides, 3, 5);
+    int64_t offset_stride = 0;
+    if (offset.ndim() > 0) {
+      offset_stride = offset.strides()[0];
+    }
+    compute_encoder.set_bytes(offset_stride, 6);
+    compute_encoder.set_bytes(N, 7);
+    uint32_t dim0 = dims_ / 2;
+    uint32_t dim1 = T;
+    uint32_t dim2 = B * ((N + n_per_thread - 1) / n_per_thread);
+    group_dims = get_block_dims(dim0, dim1, dim2);
+    grid_dims = MTL::Size(dim0, dim1, dim2);
+  }
+
+  if (with_freqs) {
+    auto& freqs = inputs[2];
+    compute_encoder.set_input_array(freqs, 10);
+    auto freq_stride = freqs.strides()[0];
+    compute_encoder.set_bytes(freq_stride, 11);
+  } else {
+    compute_encoder.set_bytes(base, 10);
+  }
+  compute_encoder.dispatch_threads(grid_dims, group_dims);
+}
+
+} // namespace mlx::core::fast
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/scaled_dot_product_attention.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/scaled_dot_product_attention.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0aca3170e66b50ab598d2a4ca57a30b4d8f88a4a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/scaled_dot_product_attention.cpp
@@ -0,0 +1,556 @@
+// Copyright © 2024 Apple Inc.
+#include <sstream>
+
+#include "mlx/backend/common/compiled.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels/steel/attn/params.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/fast_primitives.h"
+#include "mlx/transforms_impl.h"
+#include "mlx/utils.h"
+
+namespace mlx::core::fast {
+
+namespace {
+void sdpa_full_self_attention_metal(
+    const Stream& s,
+    metal::Device& d,
+    const array& q,
+    const array& k,
+    const array& v,
+    const float scale,
+    array& o,
+    bool do_causal_,
+    const std::optional<array>& mask,
+    const std::optional<array>& sinks) {
+  using namespace mlx::steel;
+
+  int wm = 4;
+  int wn = 1;
+
+  int bd = q.shape(-1);
+  int bq = 32;
+  int bk = bd < 128 ? 32 : 16;
+
+  int B = q.shape(0);
+  int H = q.shape(1);
+  int D = q.shape(3);
+  int gqa_factor = q.shape(1) / k.shape(1);
+
+  int qL = q.shape(2);
+  int kL = k.shape(2);
+
+  const bool align_Q = (qL % bq) == 0;
+  const bool align_K = (kL % bk) == 0;
+  const bool has_mask = mask.has_value();
+  const bool do_causal = do_causal_;
+  const bool has_sinks = sinks.has_value();
+
+  metal::MTLFCList func_consts = {
+      {&align_Q, MTL::DataType::DataTypeBool, 200},
+      {&align_K, MTL::DataType::DataTypeBool, 201},
+      {&has_mask, MTL::DataType::DataTypeBool, 300},
+      {&do_causal, MTL::DataType::DataTypeBool, 301},
+      {&has_sinks, MTL::DataType::DataTypeBool, 302}};
+
+  std::string base_name;
+  concatenate(
+      base_name,
+      "steel_attention_",
+      type_to_name(q),
+      "_bq",
+      bq,
+      "_bk",
+      bk,
+      "_bd",
+      bd,
+      "_wm",
+      wm,
+      "_wn",
+      wn,
+      "_mask",
+      type_to_name(has_mask ? *mask : q));
+
+  std::string hash_name;
+  concatenate(
+      hash_name,
+      base_name,
+      "_align_Q_",
+      (align_Q ? 't' : 'n'),
+      "_align_K_",
+      (align_K ? 't' : 'n'),
+      "_has_mask_",
+      (has_mask ? 't' : 'n'),
+      "_do_causal_",
+      (do_causal ? 't' : 'n'),
+      "_has_sinks_",
+      (has_sinks ? 't' : 'n'));
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel(base_name, hash_name, func_consts);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  const int NQ = (qL + bq - 1) / bq;
+  const int NK = (kL + bk - 1) / bk;
+
+  const int NQ_aligned = qL / bq;
+  const int NK_aligned = kL / bk;
+
+  AttnParams params{
+      /* int B = */ B,
+      /* int H = */ H,
+      /* int D = */ D,
+
+      /* int qL = */ qL,
+      /* int kL = */ kL,
+
+      /* int gqa_factor = */ gqa_factor,
+      /* float scale = */ scale,
+
+      /* int NQ = */ NQ,
+      /* int NK = */ NK,
+
+      /* int NQ_aligned = */ NQ_aligned,
+      /* int NK_aligned = */ NK_aligned,
+
+      /* int qL_rem = */ (qL - NQ_aligned * bq),
+      /* int kL_rem = */ (kL - NK_aligned * bk),
+      /* int qL_off = */ (kL - qL),
+
+      /* int64_t Q_strides[3] = */ {q.strides(0), q.strides(1), q.strides(2)},
+      /* int64_t K_strides[3] = */ {k.strides(0), k.strides(1), k.strides(2)},
+      /* int64_t V_strides[3] = */ {v.strides(0), v.strides(1), v.strides(2)},
+      /* int64_t O_strides[3] = */ {o.strides(0), o.strides(1), o.strides(2)}};
+
+  compute_encoder.set_input_array(q, 0);
+  compute_encoder.set_input_array(k, 1);
+  compute_encoder.set_input_array(v, 2);
+  compute_encoder.set_output_array(o, 3);
+  compute_encoder.set_bytes(params, 4);
+
+  if (has_mask) {
+    auto& m = *mask;
+
+    AttnMaskParams mask_params{/* int64_t M_strides[3] = */ {
+        m.strides(0), m.strides(1), m.strides(2)}};
+
+    compute_encoder.set_bytes(mask_params, 5);
+    compute_encoder.set_input_array(m, 6);
+  }
+  if (has_sinks) {
+    compute_encoder.set_input_array(*sinks, 7);
+  }
+
+  MTL::Size grid_dims = MTL::Size(NQ, H, B);
+  MTL::Size group_dims = MTL::Size(32, wm, wn);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void sdpa_vector(
+    const Stream& s,
+    metal::Device& d,
+    const array& q,
+    const array& k,
+    const array& v,
+    array& out,
+    float scale,
+    bool do_causal,
+    const std::optional<array>& mask,
+    const std::optional<array>& sinks) {
+  // Set the kernel name
+  std::string kname;
+  kname.reserve(64);
+  kname += "sdpa_vector_";
+  kname += get_type_string(q.dtype());
+  kname += "_";
+  kname += std::to_string(q.shape(-1));
+  kname += "_";
+  kname += std::to_string(v.shape(-1));
+
+  // Compute the necessary sizes
+  int gqa_factor = q.shape(1) / k.shape(1);
+  int N = k.shape(2);
+  size_t k_head_stride = k.shape(1) == 1 ? k.strides(0) : k.strides(1);
+  size_t k_seq_stride = k.strides()[2];
+  size_t v_head_stride = v.shape(1) == 1 ? v.strides(0) : v.strides(1);
+  size_t v_seq_stride = v.strides()[2];
+
+  MTL::Size group_dims(1024, 1, 1);
+  MTL::Size grid_dims(q.shape(0) * q.shape(1), q.shape(2), 1);
+
+  bool has_mask = mask.has_value();
+  bool bool_mask = has_mask && (*mask).dtype() == bool_;
+  bool float_mask = has_mask && !bool_mask;
+  bool query_transposed = !q.flags().row_contiguous;
+  bool has_sinks = sinks.has_value();
+  metal::MTLFCList func_consts = {
+      {&has_mask, MTL::DataType::DataTypeBool, 20},
+      {&query_transposed, MTL::DataType::DataTypeBool, 21},
+      {&do_causal, MTL::DataType::DataTypeBool, 22},
+      {&bool_mask, MTL::DataType::DataTypeBool, 23},
+      {&float_mask, MTL::DataType::DataTypeBool, 24},
+      {&has_sinks, MTL::DataType::DataTypeBool, 25},
+  };
+  std::string hash_name = kname;
+  hash_name += has_mask ? (bool_mask ? "_boolmask" : "_floatmask") : "_nomask";
+  hash_name += query_transposed ? "_qt" : "_qnt";
+  hash_name += do_causal ? "_c" : "_nc";
+  hash_name += has_sinks ? "_sinks" : "_nosinks";
+
+  // Get the kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel(kname, hash_name, func_consts);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Set its arguments
+  compute_encoder.set_input_array(q, 0);
+  compute_encoder.set_input_array(k, 1);
+  compute_encoder.set_input_array(v, 2);
+  compute_encoder.set_output_array(out, 3);
+  compute_encoder.set_bytes(gqa_factor, 4);
+  compute_encoder.set_bytes(N, 5);
+  compute_encoder.set_bytes(k_head_stride, 6);
+  compute_encoder.set_bytes(k_seq_stride, 7);
+  compute_encoder.set_bytes(v_head_stride, 8);
+  compute_encoder.set_bytes(v_seq_stride, 9);
+
+  compute_encoder.set_bytes(scale, 10);
+  if (has_mask) {
+    auto& m = *mask;
+    compute_encoder.set_input_array(m, 11 + float_mask);
+    int32_t kv_seq_stride = m.shape(3) > 1 ? m.strides(3) : 0;
+    int32_t q_seq_stride = m.shape(2) > 1 ? m.strides(2) : 0;
+    int32_t head_stride =
+        m.shape(1) > 1 ? m.strides(1) : (m.shape(0) > 1 ? m.strides(0) : 0);
+    compute_encoder.set_bytes(kv_seq_stride, 13);
+    compute_encoder.set_bytes(q_seq_stride, 14);
+    compute_encoder.set_bytes(head_stride, 15);
+  }
+  if (has_sinks) {
+    compute_encoder.set_input_array(*sinks, 16);
+    compute_encoder.set_bytes(q.shape(1), 17);
+  }
+
+  // Launch
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void sdpa_vector_2pass(
+    const Stream& s,
+    metal::Device& d,
+    const array& q,
+    const array& k,
+    const array& v,
+    array& out,
+    float scale,
+    bool do_causal,
+    const std::optional<array>& mask,
+    const std::optional<array>& sinks) {
+  // Set the kernel name
+  std::string kname;
+  kname.reserve(64);
+  kname += "sdpa_vector_2pass_1_";
+  kname += get_type_string(q.dtype());
+  kname += "_";
+  kname += std::to_string(q.shape(-1));
+  kname += "_";
+  kname += std::to_string(v.shape(-1));
+
+  // Compute the necessary sizes
+  int gqa_factor = q.shape(1) / k.shape(1);
+  int N = k.shape(2);
+  int blocks = 32;
+  int B = q.shape(0) * q.shape(1);
+
+  size_t k_head_stride = k.shape(1) == 1 ? k.strides(0) : k.strides(1);
+  size_t k_seq_stride = k.strides()[2];
+  size_t v_head_stride = v.shape(1) == 1 ? v.strides(0) : v.strides(1);
+  size_t v_seq_stride = v.strides()[2];
+  MTL::Size group_dims(8 * 32, 1, 1);
+  MTL::Size grid_dims(B, q.shape(2), blocks);
+
+  // Allocate the intermediates
+  Shape intermediate_shape;
+  intermediate_shape.reserve(out.ndim() + 1);
+  intermediate_shape.insert(
+      intermediate_shape.end(), out.shape().begin(), out.shape().end() - 1);
+  intermediate_shape.push_back(blocks);
+  intermediate_shape.push_back(out.shape().back());
+  array intermediate(intermediate_shape, float32, nullptr, {});
+  intermediate_shape.pop_back();
+  array sums(intermediate_shape, float32, nullptr, {});
+  array maxs(std::move(intermediate_shape), float32, nullptr, {});
+  intermediate.set_data(allocator::malloc(intermediate.nbytes()));
+  sums.set_data(allocator::malloc(sums.nbytes()));
+  maxs.set_data(allocator::malloc(maxs.nbytes()));
+  d.add_temporary(intermediate, s.index);
+  d.add_temporary(sums, s.index);
+  d.add_temporary(maxs, s.index);
+
+  bool has_mask = mask.has_value();
+  bool bool_mask = has_mask && (*mask).dtype() == bool_;
+  bool float_mask = has_mask && !bool_mask;
+  bool query_transposed = !q.flags().row_contiguous;
+  bool has_sinks = sinks.has_value();
+  metal::MTLFCList func_consts = {
+      {&has_mask, MTL::DataType::DataTypeBool, 20},
+      {&query_transposed, MTL::DataType::DataTypeBool, 21},
+      {&do_causal, MTL::DataType::DataTypeBool, 22},
+      {&bool_mask, MTL::DataType::DataTypeBool, 23},
+      {&float_mask, MTL::DataType::DataTypeBool, 24},
+      {&has_sinks, MTL::DataType::DataTypeBool, 25},
+  };
+  std::string hash_name = kname;
+  hash_name += has_mask ? (bool_mask ? "_boolmask" : "_floatmask") : "_nomask";
+  hash_name += query_transposed ? "_qt" : "_qnt";
+  hash_name += do_causal ? "_c" : "_nc";
+  hash_name += has_sinks ? "_sinks" : "_nosinks";
+
+  // Get the kernel
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto kernel = d.get_kernel(kname, hash_name, func_consts);
+
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Set its arguments
+  compute_encoder.set_input_array(q, 0);
+  compute_encoder.set_input_array(k, 1);
+  compute_encoder.set_input_array(v, 2);
+  compute_encoder.set_output_array(intermediate, 3);
+  compute_encoder.set_output_array(sums, 4);
+  compute_encoder.set_output_array(maxs, 5);
+  compute_encoder.set_bytes(gqa_factor, 6);
+  compute_encoder.set_bytes(N, 7);
+  compute_encoder.set_bytes(k_head_stride, 8);
+  compute_encoder.set_bytes(k_seq_stride, 9);
+  compute_encoder.set_bytes(v_head_stride, 10);
+  compute_encoder.set_bytes(v_seq_stride, 11);
+  compute_encoder.set_bytes(scale, 12);
+  if (has_mask) {
+    auto& m = *mask;
+    compute_encoder.set_input_array(m, 13 + float_mask);
+    int32_t kv_seq_stride = m.shape(3) > 1 ? m.strides(3) : 0;
+    int32_t q_seq_stride = m.shape(2) > 1 ? m.strides(2) : 0;
+    int32_t head_stride =
+        m.shape(1) > 1 ? m.strides(1) : (m.shape(0) > 1 ? m.strides(0) : 0);
+    compute_encoder.set_bytes(kv_seq_stride, 15);
+    compute_encoder.set_bytes(q_seq_stride, 16);
+    compute_encoder.set_bytes(head_stride, 17);
+  }
+  if (has_sinks) {
+    compute_encoder.set_input_array(*sinks, 18);
+    compute_encoder.set_bytes(q.shape(1), 19);
+  }
+
+  // Launch
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+
+  // Final pass
+  kname.clear();
+  kname += "sdpa_vector_2pass_2_";
+  kname += get_type_string(q.dtype());
+  kname += "_";
+  kname += std::to_string(v.shape(-1));
+
+  // Get the kernel
+  kernel = d.get_kernel(kname);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Set its arguments
+  compute_encoder.set_input_array(intermediate, 0);
+  compute_encoder.set_input_array(sums, 1);
+  compute_encoder.set_input_array(maxs, 2);
+  compute_encoder.set_output_array(out, 3);
+
+  // Launch
+  group_dims = MTL::Size(1024, 1, 1);
+  grid_dims = MTL::Size(B, q.shape(2), 1);
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+} // namespace
+
+bool ScaledDotProductAttention::use_fallback(
+    const array& q,
+    const array& k,
+    const array& v,
+    bool has_mask,
+    bool has_arr_mask,
+    bool do_causal,
+    Stream s) {
+  if (detail::in_grad_tracing()) {
+    return true;
+  }
+  if (s.device == Device::cpu) {
+    return true;
+  }
+
+  const int value_head_dim = v.shape(-1);
+  const int query_head_dim = q.shape(-1);
+  const int query_sequence_length = q.shape(2);
+  const int key_sequence_length = k.shape(2);
+
+  const bool sdpa_vector_supported_head_dim =
+      query_head_dim == value_head_dim &&
+      (query_head_dim == 64 || query_head_dim == 96 || query_head_dim == 128 ||
+       query_head_dim == 256);
+  const bool sdpa_full_supported_head_dim = query_head_dim == value_head_dim &&
+      (query_head_dim == 64 || query_head_dim == 80 || query_head_dim == 128);
+
+  const bool sdpa_full_supported_mask = !has_mask || has_arr_mask ||
+      (query_sequence_length <= key_sequence_length && do_causal);
+
+  const bool supports_sdpa_full = query_sequence_length > 8 &&
+      sdpa_full_supported_mask && sdpa_full_supported_head_dim;
+
+  const bool supports_sdpa_vector = (query_sequence_length <= 8) &&
+      (query_sequence_length <= key_sequence_length) &&
+      sdpa_vector_supported_head_dim;
+
+  return !(supports_sdpa_full || supports_sdpa_vector);
+}
+
+void ScaledDotProductAttention::eval_gpu(
+    const std::vector<array>& inputs,
+    array& out) {
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  auto& q_pre = inputs[0];
+  auto& k_pre = inputs[1];
+  auto& v_pre = inputs[2];
+  auto& o = out;
+
+  std::vector<array> copies;
+
+  // Define some copy functions to ensure the layout of the inputs is as
+  // expected.
+  copies.reserve(inputs.size());
+  auto copy_unless = [&copies, &s](
+                         auto predicate, const array& arr) -> const array& {
+    if (!predicate(arr)) {
+      array arr_copy = contiguous_copy_gpu(arr, s);
+      copies.push_back(std::move(arr_copy));
+      return copies.back();
+    } else {
+      return arr;
+    }
+  };
+
+  // Checks that the headdim dimension has stride 1.
+  auto is_matrix_contiguous = [](const array& arr) {
+    return arr.strides(-1) == 1;
+  };
+
+  std::optional<array> sinks = std::nullopt;
+  if (has_sinks_) {
+    sinks = copy_unless(is_matrix_contiguous, inputs.back());
+  }
+  bool has_arr_mask = inputs.size() > (3 + has_sinks_);
+
+  // We are in vector mode ie single query
+  if (q_pre.shape(2) <= 8) {
+    auto q_copy_unless = [](const array& arr) {
+      if (arr.flags().row_contiguous) {
+        return true;
+      }
+      auto& strides = arr.strides();
+      auto& shape = arr.shape();
+      if (shape[0] == 1 || shape[1] == 1) {
+        // If either the batch or head dimension is a singleton, the other can
+        // be transposed with the sequence dimension
+        auto bidx = shape[0] == 1 ? 1 : 0;
+        return (strides[3] == 1) && (strides[2] == shape[3] * shape[bidx]) &&
+            (strides[bidx] == shape[3]);
+      }
+      return false;
+    };
+
+    auto kv_copy_unless = [](const array& arr) {
+      // keys and values should be copied if:
+      // - the last dimension is not contiguous
+      // - the batch and head dim are not contiguous
+      auto& strides = arr.strides();
+      auto& shape = arr.shape();
+      if (strides.back() != 1) {
+        return false;
+      }
+      if (shape[0] == 1 || shape[1] == 1) {
+        return true;
+      }
+      return (strides[0] == strides[1] * shape[1]);
+    };
+
+    const auto& q = copy_unless(q_copy_unless, q_pre);
+    const auto& k = copy_unless(kv_copy_unless, k_pre);
+    const auto& v = copy_unless(kv_copy_unless, v_pre);
+
+    // Donate the query if possible
+    if (q.is_donatable() && q.flags().row_contiguous && q.size() == o.size()) {
+      o.copy_shared_buffer(q);
+    } else {
+      o.set_data(allocator::malloc(o.nbytes()));
+    }
+
+    auto mask_copy_unless = [&q](const array& arr) {
+      auto& strides = arr.strides();
+      auto& shape = arr.shape();
+      return arr.flags().row_contiguous || q.shape(0) == 1 || q.shape(1) == 1 ||
+          (strides[0] == strides[1] * shape[1]);
+    };
+
+    auto mask = has_arr_mask
+        ? std::optional<array>{copy_unless(mask_copy_unless, inputs[3])}
+        : std::nullopt;
+
+    // We route to the 2 pass fused attention if
+    // - The device is large and the sequence length long
+    // - The sequence length is even longer and we have gqa
+    bool do_causal = do_causal_ && q.shape(2) > 1;
+    char devc = d.get_architecture().back();
+    if ((devc == 'd' && k.shape(2) >= 1024) ||
+        (k.shape(1) < q.shape(1) && k.shape(2) >= 4096)) {
+      sdpa_vector_2pass(s, d, q, k, v, o, scale_, do_causal, mask, sinks);
+    } else {
+      sdpa_vector(s, d, q, k, v, o, scale_, do_causal, mask, sinks);
+    }
+  }
+
+  // Full attention mode
+  else {
+    const auto& q = copy_unless(is_matrix_contiguous, q_pre);
+    const auto& k = copy_unless(is_matrix_contiguous, k_pre);
+    const auto& v = copy_unless(is_matrix_contiguous, v_pre);
+
+    int64_t str_oD = 1;
+    int64_t str_oH = o.shape(3);
+    int64_t str_oL = o.shape(1) * str_oH;
+    int64_t str_oB = o.shape(2) * str_oL;
+    size_t data_size = o.shape(0) * str_oB;
+
+    array::Flags flags{
+        /* bool contiguous = */ 1,
+        /* bool row_contiguous = */ 0,
+        /* bool col_contiguous = */ 0,
+    };
+
+    o.set_data(
+        allocator::malloc(o.nbytes()),
+        data_size,
+        {str_oB, str_oH, str_oL, str_oD},
+        flags);
+
+    auto mask = has_arr_mask
+        ? std::optional<array>{copy_unless(is_matrix_contiguous, inputs[3])}
+        : std::nullopt;
+
+    sdpa_full_self_attention_metal(
+        s, d, q, k, v, scale_, o, do_causal_, mask, sinks);
+  }
+
+  d.add_temporaries(std::move(copies), s.index);
+}
+
+} // namespace mlx::core::fast
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/scan.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/scan.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ca208a36ccfabd241279e8ce13b8230f05addc49
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/scan.cpp
@@ -0,0 +1,136 @@
+// Copyright © 2023 Apple Inc.
+
+#include <cassert>
+#include <sstream>
+
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+void Scan::eval_gpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  bool donate = inputs[0].is_donatable();
+  auto in = inputs[0];
+  if (in.flags().contiguous && in.strides()[axis_] != 0) {
+    if (donate && in.itemsize() == out.itemsize()) {
+      out.copy_shared_buffer(in);
+    } else {
+      out.set_data(
+          allocator::malloc(in.data_size() * out.itemsize()),
+          in.data_size(),
+          in.strides(),
+          in.flags());
+    }
+  } else {
+    in = contiguous_copy_gpu(in, s);
+    out.copy_shared_buffer(in);
+  }
+
+  bool contiguous = in.strides()[axis_] == 1;
+
+  std::string reduce_type;
+  switch (reduce_type_) {
+    case Scan::Sum:
+      reduce_type = "sum";
+      break;
+    case Scan::Prod:
+      reduce_type = "prod";
+      break;
+    case Scan::Max:
+      reduce_type = "max";
+      break;
+    case Scan::Min:
+      reduce_type = "min";
+      break;
+    case Scan::LogAddExp:
+      reduce_type = "logaddexp";
+      break;
+  }
+
+  std::string kname;
+  concatenate(
+      kname,
+      contiguous ? "contig_" : "strided_",
+      "scan_",
+      reverse_ ? "reverse_" : "",
+      (inclusive_) ? "inclusive_" : "exclusive_",
+      reduce_type,
+      "_",
+      type_to_name(in),
+      "_",
+      type_to_name(out));
+
+  auto kernel =
+      get_scan_kernel(d, kname, reverse_, inclusive_, reduce_type, in, out);
+
+  if (contiguous) {
+    auto& compute_encoder = d.get_command_encoder(s.index);
+    compute_encoder.set_compute_pipeline_state(kernel);
+    compute_encoder.set_input_array(in, 0);
+    compute_encoder.set_output_array(out, 1);
+    size_t size = in.shape(axis_);
+    compute_encoder.set_bytes(size, 2);
+
+    // Compute the thread grid
+    int n_reads = (in.itemsize() <= 4) ? 4 : 2;
+    constexpr int simd_size = 32;
+    int elements_per_simd = n_reads * simd_size;
+    int thread_group_size = kernel->maxTotalThreadsPerThreadgroup();
+    if (size <= n_reads * 1024) {
+      thread_group_size =
+          ((size + elements_per_simd - 1) / elements_per_simd) * simd_size;
+    } else if (size <= n_reads * 2048) {
+      thread_group_size =
+          ((size / 2 + elements_per_simd - 1) / elements_per_simd) * simd_size;
+    }
+    thread_group_size = std::min(
+        thread_group_size,
+        static_cast<int>(kernel->maxTotalThreadsPerThreadgroup()));
+    auto tmp_grid_dims =
+        get_2d_grid_dims(in.shape(), in.strides(), /** divisor= */ size);
+    MTL::Size grid_dims(
+        thread_group_size, tmp_grid_dims.width, tmp_grid_dims.height);
+    MTL::Size group_dims(thread_group_size, 1, 1);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  } else {
+    auto& compute_encoder = d.get_command_encoder(s.index);
+    compute_encoder.set_compute_pipeline_state(kernel);
+    compute_encoder.set_input_array(
+        in.data_shared_ptr() == nullptr ? out : in, 0);
+    compute_encoder.set_output_array(out, 1);
+    size_t size = in.shape(axis_);
+    size_t stride = in.strides()[axis_];
+    int bm = 32;
+    int bn = 32;
+    size_t stride_blocks = (stride + bn - 1) / bn;
+    compute_encoder.set_bytes(size, 2);
+    compute_encoder.set_bytes(stride, 3);
+    compute_encoder.set_bytes(stride_blocks, 4);
+
+    // Compute the thread grid
+    int n_reads = (in.itemsize() <= 4) ? 4 : 2;
+    int n_simdgroups = bn / n_reads;
+    int thread_group_size = n_simdgroups * 32;
+    auto tmp_grid_dims = get_2d_grid_dims(
+        in.shape(), in.strides(), /** divisor= */ size * stride);
+    if (tmp_grid_dims.width * stride_blocks <= UINT_MAX) {
+      tmp_grid_dims.width *= stride_blocks;
+    } else {
+      tmp_grid_dims.height *= stride_blocks;
+    }
+    MTL::Size grid_dims(
+        thread_group_size, tmp_grid_dims.width, tmp_grid_dims.height);
+    MTL::Size group_dims(thread_group_size, 1, 1);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/slicing.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/slicing.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1e14c35c8a7ce8f02e7f036d6e4abba37d3ad3e0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/slicing.cpp
@@ -0,0 +1,99 @@
+// Copyright © 2024 Apple Inc.
+
+#include <numeric>
+
+#include "mlx/backend/common/compiled.h"
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/gpu/slicing.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/utils.h"
+
+namespace mlx::core {
+
+void concatenate_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    int axis,
+    const Stream& s) {
+  std::vector<int> sizes;
+  sizes.push_back(0);
+  for (auto& p : inputs) {
+    sizes.push_back(p.shape(axis));
+  }
+  std::partial_sum(sizes.cbegin(), sizes.cend(), sizes.begin());
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto strides = out.strides();
+  auto flags = out.flags();
+  flags.row_contiguous = false;
+  flags.col_contiguous = false;
+  flags.contiguous = false;
+  auto& d = metal::device(s.device);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  auto concurrent_ctx = compute_encoder.start_concurrent();
+  for (int i = 0; i < inputs.size(); i++) {
+    array out_slice(inputs[i].shape(), out.dtype(), nullptr, {});
+    size_t data_offset = strides[axis] * sizes[i];
+    out_slice.copy_shared_buffer(
+        out, strides, flags, out_slice.size(), data_offset);
+    copy_gpu_inplace(inputs[i], out_slice, CopyType::GeneralGeneral, s);
+  }
+}
+
+array compute_dynamic_offset(
+    const array& indices,
+    const Strides& strides,
+    const std::vector<int>& axes,
+    const Stream& s) {
+  auto& d = metal::device(s.device);
+
+  // Kernel to compute offset here.
+  array offset({1}, int64, nullptr, {});
+  bool donate = indices.is_donatable() &&
+      (indices.data_size() * indices.itemsize()) >= offset.itemsize();
+  if (donate) {
+    offset.copy_shared_buffer(indices);
+  } else {
+    offset.set_data(allocator::malloc(offset.itemsize()));
+  }
+  d.add_temporary(offset, s.index);
+
+  auto dtype = indices.dtype();
+  std::string lib_name = "compute_dynamic_offset_" + type_to_name(dtype);
+  auto lib = d.get_library(lib_name, [dtype]() {
+    return fmt::format(
+        R"(
+        [[kernel]] void compute_dynamic_offset_{0}(
+            constant const {1}* indices [[buffer(0)]],
+            device int64_t& offset [[buffer(1)]],
+            constant const int64_t* strides [[buffer(2)]],
+            constant const int* axes [[buffer(3)]],
+            constant const int& n_axes [[buffer(4)]],
+            uint index [[thread_position_in_grid]]) {{
+          int64_t acc = 0;
+          for (int i = 0; i < n_axes; ++i) {{
+            acc += indices[i] * strides[axes[i]];
+          }}
+          offset = acc;
+        }})",
+        type_to_name(dtype),
+        get_type_string(dtype));
+  });
+  auto kernel = d.get_kernel(lib_name, lib);
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+  compute_encoder.set_input_array(indices, 0);
+  compute_encoder.set_output_array(offset, 1);
+  compute_encoder.set_vector_bytes(strides, 2);
+  compute_encoder.set_vector_bytes(axes, 3);
+  int n_axes = axes.size();
+  compute_encoder.set_bytes(n_axes, 4);
+  MTL::Size dims = MTL::Size(1, 1, 1);
+  compute_encoder.dispatch_threads(dims, dims);
+  return offset;
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/softmax.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/softmax.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0b1a1848df113314361817ede2f054a682835c02
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/softmax.cpp
@@ -0,0 +1,87 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <algorithm>
+
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/kernels/defines.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+constexpr int SOFTMAX_LOOPED_LIMIT = 4096;
+
+void Softmax::eval_gpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  if (!issubdtype(out.dtype(), floating)) {
+    throw std::runtime_error(
+        "[softmax] Does not support non-floating point types.");
+  }
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+
+  // Make sure that the last dimension is contiguous
+  auto set_output = [&s, &out](const array& x) {
+    if (x.flags().contiguous && x.strides()[x.ndim() - 1] == 1) {
+      if (x.is_donatable()) {
+        out.copy_shared_buffer(x);
+      } else {
+        out.set_data(
+            allocator::malloc(x.data_size() * x.itemsize()),
+            x.data_size(),
+            x.strides(),
+            x.flags());
+      }
+      return x;
+    } else {
+      array x_copy = contiguous_copy_gpu(x, s);
+      out.copy_shared_buffer(x_copy);
+      return x_copy;
+    }
+  };
+
+  const array in = set_output(inputs[0]);
+
+  int axis_size = in.shape().back();
+  int n_rows = in.data_size() / axis_size;
+
+  const int simd_size = 32;
+  const int n_reads = SOFTMAX_N_READS;
+  const int looped_limit = SOFTMAX_LOOPED_LIMIT;
+
+  std::string kernel_name = (axis_size > looped_limit) ? "looped_" : "block_";
+  kernel_name += "softmax_";
+  if (in.dtype() != float32 && precise_) {
+    kernel_name += "precise_";
+  }
+  kernel_name += type_to_name(out);
+
+  auto kernel = get_softmax_kernel(d, kernel_name, precise_, out);
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  {
+    MTL::Size grid_dims, group_dims;
+    if (axis_size <= looped_limit) {
+      size_t threadgroup_needed = (axis_size + n_reads - 1) / n_reads;
+      size_t simds_needed = (threadgroup_needed + simd_size - 1) / simd_size;
+      size_t threadgroup_size = simd_size * simds_needed;
+      assert(threadgroup_size <= kernel->maxTotalThreadsPerThreadgroup());
+      size_t n_threads = n_rows * threadgroup_size;
+      grid_dims = MTL::Size(n_threads, 1, 1);
+      group_dims = MTL::Size(threadgroup_size, 1, 1);
+    } else {
+      size_t threadgroup_size = kernel->maxTotalThreadsPerThreadgroup();
+      size_t n_threads = n_rows * threadgroup_size;
+      grid_dims = MTL::Size(n_threads, 1, 1);
+      group_dims = MTL::Size(threadgroup_size, 1, 1);
+    }
+
+    compute_encoder.set_compute_pipeline_state(kernel);
+    compute_encoder.set_input_array(in, 0);
+    compute_encoder.set_output_array(out, 1);
+    compute_encoder.set_bytes(axis_size, 2);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/sort.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/sort.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3c84022f2c8e2afa56ee8513bfa28ee14006e7ee
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/sort.cpp
@@ -0,0 +1,368 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <algorithm>
+
+#include "mlx/backend/gpu/copy.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+namespace {
+
+void single_block_sort(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    array& out,
+    int axis,
+    int bn,
+    int tn,
+    bool argsort) {
+  // Prepare shapes
+  int n_rows = in.size() / in.shape(axis);
+
+  auto in_nc_str = in.strides();
+  in_nc_str.erase(in_nc_str.begin() + axis);
+
+  auto out_nc_str = out.strides();
+  out_nc_str.erase(out_nc_str.begin() + axis);
+
+  auto nc_shape = in.shape();
+  nc_shape.erase(nc_shape.begin() + axis);
+
+  int nc_dim = nc_shape.size();
+
+  int size_sorted_axis = in.shape(axis);
+  int in_stride_sorted_axis = in.strides()[axis];
+  int out_stride_sorted_axis = out.strides()[axis];
+
+  // We can only use the contiguous kernel if the sorted axis
+  // has the largest or smallest stride.
+  // We also need the input to be contiguous
+  bool contiguous = in.flags().contiguous;
+  auto check_strides = [](array x, int sort_stride) {
+    int min_stride = *std::min_element(x.strides().begin(), x.strides().end());
+    int max_stride = *std::max_element(x.strides().begin(), x.strides().end());
+    return sort_stride == min_stride || sort_stride == max_stride;
+  };
+  contiguous &= check_strides(in, in_stride_sorted_axis);
+  contiguous &= check_strides(out, out_stride_sorted_axis);
+
+  // Prepare kernel name
+  std::ostringstream kname;
+  kname << (contiguous ? "c" : "nc");
+  if (argsort) {
+    kname << "arg";
+  }
+
+  kname << "_block_sort_" << type_to_name(in) << "_" << type_to_name(out)
+        << "_bn" << bn << "_tn" << tn;
+  auto kernel = get_sort_kernel(d, kname.str(), in, out, bn, tn);
+
+  // Prepare command encoder
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+
+  // Set inputs
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_output_array(out, 1);
+  compute_encoder.set_bytes(size_sorted_axis, 2);
+  compute_encoder.set_bytes(in_stride_sorted_axis, 3);
+  compute_encoder.set_bytes(out_stride_sorted_axis, 4);
+
+  if (contiguous) {
+    int in_stride_segment_axis = INT32_MAX;
+    int out_stride_segment_axis = INT32_MAX;
+    for (int i = 0; i < in_nc_str.size(); i++) {
+      if (nc_shape[i] == 1) {
+        continue;
+      }
+      if (in_nc_str[i] > INT32_MAX || out_nc_str[i] > INT32_MAX) {
+        throw std::runtime_error("[Sort::eval_gpu] Stride too large.");
+      }
+      in_stride_segment_axis =
+          std::min(in_stride_segment_axis, static_cast<int>(in_nc_str[i]));
+      out_stride_segment_axis =
+          std::min(out_stride_segment_axis, static_cast<int>(out_nc_str[i]));
+    }
+    compute_encoder.set_bytes(in_stride_segment_axis, 5);
+    compute_encoder.set_bytes(out_stride_segment_axis, 6);
+  } else {
+    compute_encoder.set_bytes(nc_dim, 5);
+    if (nc_shape.empty()) {
+      int shape = 0;
+      int64_t stride = 0;
+      compute_encoder.set_bytes(shape, 6);
+      compute_encoder.set_bytes(stride, 7);
+      compute_encoder.set_bytes(stride, 8);
+    } else {
+      compute_encoder.set_vector_bytes(nc_shape, 6);
+      compute_encoder.set_vector_bytes(in_nc_str, 7);
+      compute_encoder.set_vector_bytes(out_nc_str, 8);
+    }
+  }
+
+  MTL::Size group_dims = MTL::Size(bn, 1, 1);
+  MTL::Size grid_dims = MTL::Size(1, n_rows, 1);
+
+  compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+}
+
+void multi_block_sort(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    array& out,
+    int axis,
+    int bn,
+    int tn,
+    int n_blocks,
+    bool argsort) {
+  // Prepare shapes
+  int n_rows = in.size() / in.shape(axis);
+
+  auto nc_str = in.strides();
+  nc_str.erase(nc_str.begin() + axis);
+
+  auto nc_shape = in.shape();
+  nc_shape.erase(nc_shape.begin() + axis);
+
+  int nc_dim = nc_shape.size();
+
+  if (nc_dim == 0) {
+    nc_shape = {0};
+    nc_str = {1};
+  }
+
+  int size_sorted_axis = in.shape(axis);
+  int stride_sorted_axis = in.strides()[axis];
+
+  // Make temporary copies
+  array dev_vals_0({n_rows, size_sorted_axis}, in.dtype(), nullptr, {});
+  array dev_vals_1({n_rows, size_sorted_axis}, in.dtype(), nullptr, {});
+
+  array dev_idxs_0({n_rows, size_sorted_axis}, uint32, nullptr, {});
+  array dev_idxs_1({n_rows, size_sorted_axis}, uint32, nullptr, {});
+
+  array block_partitions({n_rows, n_blocks + 1}, uint32, nullptr, {});
+
+  // Do allocations
+  dev_vals_0.set_data(allocator::malloc(dev_vals_0.nbytes()));
+  dev_vals_1.set_data(allocator::malloc(dev_vals_1.nbytes()));
+  dev_idxs_0.set_data(allocator::malloc(dev_idxs_0.nbytes()));
+  dev_idxs_1.set_data(allocator::malloc(dev_idxs_1.nbytes()));
+  block_partitions.set_data(allocator::malloc(block_partitions.nbytes()));
+
+  std::vector<array> copies = {
+      dev_vals_0, dev_vals_1, dev_idxs_0, dev_idxs_1, block_partitions};
+
+  // Prepare command encoder
+  auto& compute_encoder = d.get_command_encoder(s.index);
+
+  // Do blockwise sort
+  {
+    std::ostringstream kname;
+    kname << "sort_mbsort_" << type_to_name(dev_vals_0) << "_"
+          << type_to_name(dev_idxs_0) << "_bn" << bn << "_tn" << tn;
+    auto kernel =
+        get_mb_sort_kernel(d, kname.str(), dev_vals_0, dev_idxs_0, bn, tn);
+    compute_encoder.set_compute_pipeline_state(kernel);
+
+    compute_encoder.set_input_array(in, 0);
+    compute_encoder.set_output_array(dev_vals_0, 1);
+    compute_encoder.set_output_array(dev_idxs_0, 2);
+    compute_encoder.set_bytes(size_sorted_axis, 3);
+    compute_encoder.set_bytes(stride_sorted_axis, 4);
+    compute_encoder.set_bytes(nc_dim, 5);
+    compute_encoder.set_vector_bytes(nc_shape, 6);
+    compute_encoder.set_vector_bytes(nc_str, 7);
+
+    MTL::Size group_dims = MTL::Size(bn, 1, 1);
+    MTL::Size grid_dims = MTL::Size(n_blocks, n_rows, 1);
+
+    compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+  }
+
+  // Do merges
+  bool ping = false;
+  array dev_vals_in = dev_vals_0;
+  array dev_idxs_in = dev_idxs_0;
+  array dev_vals_out = dev_vals_1;
+  array dev_idxs_out = dev_idxs_1;
+
+  int n_thr_per_group = (n_blocks + 1) < 1024 ? (n_blocks + 1) : 1024;
+
+  for (int merge_tiles = 2; (merge_tiles / 2) < n_blocks; merge_tiles *= 2) {
+    dev_vals_in = ping ? dev_vals_1 : dev_vals_0;
+    dev_idxs_in = ping ? dev_idxs_1 : dev_idxs_0;
+    dev_vals_out = ping ? dev_vals_0 : dev_vals_1;
+    dev_idxs_out = ping ? dev_idxs_0 : dev_idxs_1;
+    ping = !ping;
+
+    // Do partition
+    {
+      std::ostringstream kname;
+      kname << "partition_mbsort_" << type_to_name(dev_vals_in) << "_"
+            << type_to_name(dev_idxs_in) << "_bn" << bn << "_tn" << tn;
+
+      auto kernel =
+          get_mb_sort_kernel(d, kname.str(), dev_vals_0, dev_idxs_0, bn, tn);
+      compute_encoder.set_compute_pipeline_state(kernel);
+
+      compute_encoder.set_output_array(block_partitions, 0);
+      compute_encoder.set_input_array(dev_vals_in, 1);
+      compute_encoder.set_input_array(dev_idxs_in, 2);
+      compute_encoder.set_bytes(size_sorted_axis, 3);
+      compute_encoder.set_bytes(merge_tiles, 4);
+      compute_encoder.set_bytes(n_blocks, 5);
+
+      MTL::Size group_dims = MTL::Size(n_thr_per_group, 1, 1);
+      MTL::Size grid_dims = MTL::Size(1, n_rows, 1);
+
+      compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+    }
+
+    // Do merge
+    {
+      std::ostringstream kname;
+      kname << "merge_mbsort_" << type_to_name(dev_vals_in) << "_"
+            << type_to_name(dev_idxs_in) << "_bn" << bn << "_tn" << tn;
+
+      auto kernel =
+          get_mb_sort_kernel(d, kname.str(), dev_vals_0, dev_idxs_0, bn, tn);
+      compute_encoder.set_compute_pipeline_state(kernel);
+
+      compute_encoder.set_input_array(block_partitions, 0);
+      compute_encoder.set_input_array(dev_vals_in, 1);
+      compute_encoder.set_input_array(dev_idxs_in, 2);
+      compute_encoder.set_output_array(dev_vals_out, 3);
+      compute_encoder.set_output_array(dev_idxs_out, 4);
+      compute_encoder.set_bytes(size_sorted_axis, 5);
+      compute_encoder.set_bytes(merge_tiles, 6);
+      compute_encoder.set_bytes(n_blocks, 7);
+
+      MTL::Size group_dims = MTL::Size(bn, 1, 1);
+      MTL::Size grid_dims = MTL::Size(n_blocks, n_rows, 1);
+
+      compute_encoder.dispatch_threadgroups(grid_dims, group_dims);
+    }
+  }
+
+  // Copy outputs with appropriate strides
+  auto strides = out.strides();
+  for (int ax = axis + 1; ax < strides.size(); ax++) {
+    strides[ax] *= out.shape(axis);
+  }
+  strides[axis] = 1;
+  copy_gpu_inplace(
+      (argsort) ? dev_idxs_out : dev_vals_out,
+      out,
+      out.shape(),
+      strides,
+      out.strides(),
+      0,
+      0,
+      (axis == in.ndim() - 1) ? CopyType::Vector : CopyType::General,
+      s);
+
+  d.add_temporaries(std::move(copies), s.index);
+}
+
+void gpu_merge_sort(
+    const Stream& s,
+    metal::Device& d,
+    const array& in,
+    array& out,
+    int axis_,
+    bool argsort) {
+  // Get size info
+  int axis = axis_ < 0 ? axis_ + in.ndim() : axis_;
+  int size_sorted_axis = in.shape(axis);
+
+  // Get kernel size
+  int tn = 4;
+  int potential_bn = (size_sorted_axis + tn - 1) / tn;
+
+  int bn;
+  if (potential_bn > 256) {
+    bn = 512;
+  } else if (potential_bn > 128) {
+    bn = 256;
+  } else if (potential_bn > 64) {
+    bn = 128;
+  } else if (potential_bn > 32) {
+    bn = 64;
+  } else {
+    bn = 32;
+  }
+
+  if (bn == 512 && size_of(in.dtype()) > 4) {
+    bn = 256;
+  }
+
+  int n_per_block = bn * tn;
+  int n_blocks = (size_sorted_axis + n_per_block - 1) / n_per_block;
+
+  if (n_blocks > 1) {
+    return multi_block_sort(s, d, in, out, axis, bn, tn, n_blocks, argsort);
+  } else {
+    return single_block_sort(s, d, in, out, axis, bn, tn, argsort);
+  }
+}
+
+} // namespace
+
+void ArgSort::eval_gpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+  auto& in = inputs[0];
+
+  gpu_merge_sort(s, d, in, out, axis_, true);
+}
+
+void Sort::eval_gpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+  auto& in = inputs[0];
+
+  gpu_merge_sort(s, d, in, out, axis_, false);
+}
+
+void ArgPartition::eval_gpu(const std::vector<array>& inputs, array& out) {
+  // We direct arg partition to sort for now
+  assert(inputs.size() == 1);
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+  auto& in = inputs[0];
+
+  gpu_merge_sort(s, d, in, out, axis_, true);
+}
+
+void Partition::eval_gpu(const std::vector<array>& inputs, array& out) {
+  // We direct partition to sort for now
+  assert(inputs.size() == 1);
+
+  out.set_data(allocator::malloc(out.nbytes()));
+
+  auto& s = stream();
+  auto& d = metal::device(s.device);
+  auto& in = inputs[0];
+
+  gpu_merge_sort(s, d, in, out, axis_, false);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/ternary.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/ternary.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..252815aae521db17717258f57b12c50944ced916
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/ternary.cpp
@@ -0,0 +1,160 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/backend/common/ternary.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+void ternary_op_gpu_inplace(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s) {
+  assert(inputs.size() == 3);
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  auto& c = inputs[2];
+  TernaryOpType topt = get_ternary_op_type(a, b, c);
+
+  if (out.size() == 0) {
+    return;
+  }
+
+  // Try to collapse contiguous dims
+  auto maybe_collapse = [topt, &a, &b, &c, &out]() {
+    if (topt == TernaryOpType::General) {
+      auto [shape, strides] = collapse_contiguous_dims(a, b, c, out);
+      return std::make_tuple(
+          shape, strides[0], strides[1], strides[2], strides[3]);
+    } else {
+      Strides e;
+      return std::make_tuple(Shape{}, e, e, e, e);
+    }
+  };
+  auto [shape, strides_a, strides_b, strides_c, strides_out] = maybe_collapse();
+
+  bool large;
+  auto ndim = shape.size();
+  int work_per_thread;
+  if (topt == TernaryOpType::General) {
+    large = a.data_size() > INT32_MAX || b.data_size() > INT32_MAX ||
+        c.data_size() > INT32_MAX || out.size() > INT32_MAX;
+    work_per_thread = large ? 4 : 2;
+  } else {
+    large = out.data_size() > INT32_MAX;
+    work_per_thread = get_work_per_thread(b.dtype(), out.data_size());
+  }
+  std::string kernel_name;
+  if (topt == TernaryOpType::General) {
+    kernel_name = "g";
+    if (shape.size() <= 3) {
+      kernel_name += std::to_string(shape.size());
+    } else if (work_per_thread > 1) {
+      concatenate(kernel_name, "n", std::to_string(work_per_thread));
+    }
+    if (large) {
+      kernel_name += "large";
+    }
+  } else {
+    if (topt == TernaryOpType::VectorScalarVector) {
+      kernel_name = "sv";
+    } else if (topt == TernaryOpType::VectorVectorScalar) {
+      kernel_name = "vs";
+    } else {
+      kernel_name = "v";
+    }
+    if (large) {
+      kernel_name += "2";
+    } else if (work_per_thread > 1) {
+      kernel_name += "n";
+    }
+  }
+  concatenate(kernel_name, "_", op, type_to_name(b));
+
+  auto& d = metal::device(s.device);
+
+  auto kernel = get_ternary_kernel(d, kernel_name, out.dtype(), op);
+
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+  compute_encoder.set_input_array(a, 0);
+  compute_encoder.set_input_array(b, 1);
+  compute_encoder.set_input_array(c, 2);
+  compute_encoder.set_output_array(out, 3);
+
+  auto thread_group_size = kernel->maxTotalThreadsPerThreadgroup();
+  if (topt == TernaryOpType::General) {
+    // Launch up to 3D grid of threads
+    size_t dim0 = ndim > 0 ? shape[ndim - 1] : 1;
+    size_t dim1 = ndim > 1 ? shape[ndim - 2] : 1;
+    size_t rest = out.size() / (dim0 * dim1);
+
+    if (ndim > 3) {
+      compute_encoder.set_vector_bytes(shape, 4);
+      compute_encoder.set_vector_bytes(strides_a, 5);
+      compute_encoder.set_vector_bytes(strides_b, 6);
+      compute_encoder.set_vector_bytes(strides_c, 7);
+
+      compute_encoder.set_bytes(ndim, 8);
+      dim0 = (dim0 + work_per_thread - 1) / work_per_thread;
+    } else {
+      // The shape is implicit in the grid for <= 3D
+      compute_encoder.set_vector_bytes(strides_a, 4);
+      compute_encoder.set_vector_bytes(strides_b, 5);
+      compute_encoder.set_vector_bytes(strides_c, 6);
+    }
+
+    if (thread_group_size != 1024) {
+      throw std::runtime_error("[Metal::ternary] Must use 1024 sized block");
+    }
+    MTL::Size group_dims = get_block_dims(dim0, dim1, rest);
+    MTL::Size grid_dims = MTL::Size(dim0, dim1, rest);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  } else {
+    // Launch a 1D or 2D grid of threads
+    size_t nthreads = ceildiv(out.data_size(), work_per_thread);
+    if (thread_group_size > nthreads) {
+      thread_group_size = nthreads;
+    }
+    MTL::Size group_dims = MTL::Size(thread_group_size, 1, 1);
+    MTL::Size grid_dims;
+    if (large) {
+      compute_encoder.set_bytes<int64_t>(out.data_size(), 4);
+      grid_dims = get_2d_grid_dims(out.shape(), out.strides(), work_per_thread);
+    } else {
+      compute_encoder.set_bytes<int>(out.data_size(), 4);
+      grid_dims = MTL::Size(nthreads, 1, 1);
+    }
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+}
+
+void ternary_op_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s) {
+  auto& a = inputs[0];
+  auto& b = inputs[1];
+  auto& c = inputs[2];
+  TernaryOpType topt = get_ternary_op_type(a, b, c);
+  set_ternary_op_output_data(a, b, c, out, topt);
+  ternary_op_gpu_inplace(inputs, out, op, s);
+}
+
+void ternary_op_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op) {
+  auto& s = out.primitive().stream();
+  ternary_op_gpu(inputs, out, op, s);
+}
+
+void Select::eval_gpu(const std::vector<array>& inputs, array& out) {
+  ternary_op_gpu(inputs, out, name());
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/ternary.h b/ml-stable-diffusion/mlx/mlx/backend/metal/ternary.h
new file mode 100644
index 0000000000000000000000000000000000000000..91c6fbbebf8fbe1f346becb444258e2668521883
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/ternary.h
@@ -0,0 +1,21 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+void ternary_op_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s);
+
+void ternary_op_gpu_inplace(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/unary.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/unary.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..48f85635ba77990aaffcbdee3adb4ea605e4cee9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/unary.cpp
@@ -0,0 +1,171 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/backend/common/unary.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/backend/metal/kernels.h"
+#include "mlx/backend/metal/utils.h"
+#include "mlx/primitives.h"
+
+#define UNARY_GPU(func)                                               \
+  void func::eval_gpu(const std::vector<array>& inputs, array& out) { \
+    unary_op_gpu(inputs, out, name());                                \
+  }
+
+namespace mlx::core {
+
+void unary_op_gpu_inplace(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s) {
+  auto& in = inputs[0];
+  bool contig = in.flags().contiguous;
+  if (in.size() == 0) {
+    return;
+  }
+
+  auto& d = metal::device(s.device);
+
+  auto maybe_collapse = [contig, &in, &out]() {
+    if (!contig) {
+      return collapse_contiguous_dims(in);
+    } else {
+      return std::make_pair(Shape{}, Strides{});
+    }
+  };
+  auto [shape, strides] = maybe_collapse();
+  int ndim = shape.size();
+  bool large;
+  if (!contig) {
+    large = in.data_size() > INT32_MAX || out.size() > INT32_MAX;
+  } else {
+    large = in.data_size() > UINT32_MAX;
+  }
+  int work_per_thread;
+  std::string kernel_name;
+  if (contig) {
+    work_per_thread = get_work_per_thread(in.dtype(), in.data_size());
+    kernel_name = (large ? "v2" : (work_per_thread > 1 ? "vn" : "v"));
+  } else {
+    work_per_thread = large ? 4 : 1;
+    kernel_name = "gn" + std::to_string(work_per_thread);
+    if (large) {
+      kernel_name += "large";
+    }
+  }
+  concatenate(kernel_name, "_", op, type_to_name(in), type_to_name(out));
+  auto kernel = get_unary_kernel(d, kernel_name, in.dtype(), out.dtype(), op);
+
+  auto thread_group_size = kernel->maxTotalThreadsPerThreadgroup();
+  auto& compute_encoder = d.get_command_encoder(s.index);
+  compute_encoder.set_compute_pipeline_state(kernel);
+  compute_encoder.set_input_array(in, 0);
+  compute_encoder.set_output_array(out, 1);
+  if (!contig) {
+    // Launch up to 3D grid of threads
+    size_t dim0 = ndim > 0 ? shape[ndim - 1] : 1;
+    size_t dim1 = ndim > 1 ? shape[ndim - 2] : 1;
+    size_t rest = out.size() / (dim0 * dim1);
+    compute_encoder.set_vector_bytes(shape, 2);
+    compute_encoder.set_vector_bytes(strides, 3);
+    compute_encoder.set_bytes(ndim, 4);
+    if (thread_group_size != 1024) {
+      throw std::runtime_error("[Metal::unary] Must use 1024 sized block");
+    }
+    dim0 = (dim0 + work_per_thread - 1) / work_per_thread;
+    auto group_dims = get_block_dims(dim0, dim1, rest);
+    MTL::Size grid_dims = MTL::Size(dim0, dim1, rest);
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  } else {
+    size_t nthreads = ceildiv(in.data_size(), work_per_thread);
+    if (thread_group_size > nthreads) {
+      thread_group_size = nthreads;
+    }
+
+    MTL::Size group_dims = MTL::Size(thread_group_size, 1, 1);
+    MTL::Size grid_dims;
+    if (large) {
+      compute_encoder.set_bytes<int64_t>(in.data_size(), 2);
+      grid_dims = get_2d_grid_dims(out.shape(), out.strides(), work_per_thread);
+    } else {
+      compute_encoder.set_bytes<int>(in.data_size(), 2);
+      grid_dims = MTL::Size(nthreads, 1, 1);
+    }
+    compute_encoder.dispatch_threads(grid_dims, group_dims);
+  }
+}
+
+void unary_op_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s) {
+  set_unary_output_data(inputs[0], out);
+  unary_op_gpu_inplace(inputs, out, op, s);
+}
+
+void unary_op_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op) {
+  auto& s = out.primitive().stream();
+  unary_op_gpu(inputs, out, op, s);
+}
+
+UNARY_GPU(Abs)
+UNARY_GPU(ArcCos)
+UNARY_GPU(ArcCosh)
+UNARY_GPU(ArcSin)
+UNARY_GPU(ArcSinh)
+UNARY_GPU(ArcTan)
+UNARY_GPU(ArcTanh)
+UNARY_GPU(BitwiseInvert)
+UNARY_GPU(Conjugate)
+UNARY_GPU(Cos)
+UNARY_GPU(Cosh)
+UNARY_GPU(Erf)
+UNARY_GPU(ErfInv)
+UNARY_GPU(Exp)
+UNARY_GPU(Expm1)
+UNARY_GPU(Imag)
+UNARY_GPU(Log1p)
+UNARY_GPU(LogicalNot)
+UNARY_GPU(Floor)
+UNARY_GPU(Ceil)
+UNARY_GPU(Negative)
+UNARY_GPU(Real)
+UNARY_GPU(Sigmoid)
+UNARY_GPU(Sign)
+UNARY_GPU(Sin)
+UNARY_GPU(Sinh)
+UNARY_GPU(Square)
+UNARY_GPU(Sqrt)
+UNARY_GPU(Tan)
+UNARY_GPU(Tanh)
+
+void Log::eval_gpu(const std::vector<array>& inputs, array& out) {
+  switch (base_) {
+    case Base::e:
+      unary_op_gpu(inputs, out, name());
+      break;
+    case Base::two:
+      unary_op_gpu(inputs, out, name());
+      break;
+    case Base::ten:
+      unary_op_gpu(inputs, out, name());
+      break;
+  }
+}
+
+void Round::eval_gpu(const std::vector<array>& inputs, array& out) {
+  assert(inputs.size() == 1);
+  const auto& in = inputs[0];
+  if (issubdtype(in.dtype(), inexact)) {
+    unary_op_gpu(inputs, out, name());
+  } else {
+    // No-op integer types
+    out.copy_shared_buffer(in);
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/unary.h b/ml-stable-diffusion/mlx/mlx/backend/metal/unary.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d6ecf02780cee0b4c8638053b48b5269e7dc479
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/unary.h
@@ -0,0 +1,21 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+void unary_op_gpu(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s);
+
+void unary_op_gpu_inplace(
+    const std::vector<array>& inputs,
+    array& out,
+    const char* op,
+    const Stream& s);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/utils.cpp b/ml-stable-diffusion/mlx/mlx/backend/metal/utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9785018357b8b39f62dbb8d3ea12e68048b89631
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/utils.cpp
@@ -0,0 +1,77 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/backend/metal/utils.h"
+#include "mlx/backend/common/utils.h"
+
+namespace mlx::core {
+
+std::string type_to_name(const Dtype& t) {
+  std::string tname;
+  switch (t) {
+    case bool_:
+      tname = "bool_";
+      break;
+    case uint8:
+      tname = "uint8";
+      break;
+    case uint16:
+      tname = "uint16";
+      break;
+    case uint32:
+      tname = "uint32";
+      break;
+    case uint64:
+      tname = "uint64";
+      break;
+    case int8:
+      tname = "int8";
+      break;
+    case int16:
+      tname = "int16";
+      break;
+    case int32:
+      tname = "int32";
+      break;
+    case int64:
+      tname = "int64";
+      break;
+    case float16:
+      tname = "float16";
+      break;
+    case float32:
+      tname = "float32";
+      break;
+    case float64:
+      tname = "double";
+      break;
+    case bfloat16:
+      tname = "bfloat16";
+      break;
+    case complex64:
+      tname = "complex64";
+      break;
+  }
+  return tname;
+}
+
+std::string type_to_name(const array& a) {
+  return type_to_name(a.dtype());
+}
+
+MTL::Size get_block_dims(int dim0, int dim1, int dim2, int pow2) {
+  Dims dims = get_block_dims_common(dim0, dim1, dim2, pow2);
+  return MTL::Size(std::get<0>(dims), std::get<1>(dims), std::get<2>(dims));
+}
+
+MTL::Size get_2d_grid_dims(const Shape& shape, const Strides& strides) {
+  Dims dims = get_2d_grid_dims_common(shape, strides);
+  return MTL::Size(std::get<0>(dims), std::get<1>(dims), std::get<2>(dims));
+}
+
+MTL::Size
+get_2d_grid_dims(const Shape& shape, const Strides& strides, size_t divisor) {
+  Dims dims = get_2d_grid_dims_common(shape, strides, divisor);
+  return MTL::Size(std::get<0>(dims), std::get<1>(dims), std::get<2>(dims));
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/metal/utils.h b/ml-stable-diffusion/mlx/mlx/backend/metal/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..e7784e5997ead020624e77aea7919229ed19d077
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/metal/utils.h
@@ -0,0 +1,84 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <type_traits>
+
+#include "mlx/array.h"
+#include "mlx/backend/metal/device.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+std::string type_to_name(const Dtype& t);
+std::string type_to_name(const array& a);
+
+// Compute the grid and block dimensions, check backend/common/utils.h for docs.
+MTL::Size get_block_dims(int dim0, int dim1, int dim2, int pow2 = 10);
+MTL::Size get_2d_grid_dims(const Shape& shape, const Strides& strides);
+MTL::Size
+get_2d_grid_dims(const Shape& shape, const Strides& strides, size_t divisor);
+
+inline NS::String* make_string(std::ostringstream& os) {
+  std::string string = os.str();
+  return NS::String::string(string.c_str(), NS::UTF8StringEncoding);
+}
+
+inline void debug_set_stream_queue_label(MTL::CommandQueue* queue, int index) {
+#ifdef MLX_METAL_DEBUG
+  std::ostringstream label;
+  label << "Stream " << index;
+  queue->setLabel(make_string(label));
+#endif
+}
+
+inline void debug_set_primitive_buffer_label(
+    MTL::CommandBuffer* command_buffer,
+    Primitive& primitive) {
+#ifdef MLX_METAL_DEBUG
+  std::ostringstream label;
+  if (auto cbuf_label = command_buffer->label(); cbuf_label) {
+    label << cbuf_label->utf8String();
+  }
+  label << primitive.name();
+  command_buffer->setLabel(make_string(label));
+#endif
+}
+
+template <typename T>
+constexpr bool is_numeric_except_char = std::is_arithmetic_v<T> &&
+    !std::is_same_v<T, char> && !std::is_same_v<T, signed char> &&
+    !std::is_same_v<T, unsigned char> && !std::is_same_v<T, wchar_t>;
+
+template <typename T>
+void concatenate(std::string& acc, T first) {
+  if constexpr (is_numeric_except_char<T>) {
+    acc += std::to_string(first);
+  } else {
+    acc += first;
+  }
+}
+
+template <typename T, typename... Args>
+void concatenate(std::string& acc, T first, Args... args) {
+  if constexpr (is_numeric_except_char<T>) {
+    acc += std::to_string(first);
+  } else {
+    acc += first;
+  }
+  concatenate(acc, args...);
+}
+
+inline int get_work_per_thread(Dtype dtype) {
+  return std::max(1, 8 / dtype.size());
+}
+inline int get_work_per_thread(Dtype dtype, size_t size) {
+  constexpr size_t wpt_threshold = 1 << 16;
+  return size < wpt_threshold ? 1 : std::max(1, 8 / dtype.size());
+}
+
+inline size_t ceildiv(size_t n, size_t m) {
+  return (n + m - 1) / m;
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/no_cpu/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/backend/no_cpu/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2e696082967bbcbea22676c427c66aa172bb04b7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/no_cpu/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(
+  mlx
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/available.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/primitives.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/../cpu/eval.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/../cpu/encoder.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/compiled.cpp)
diff --git a/ml-stable-diffusion/mlx/mlx/backend/no_cpu/available.cpp b/ml-stable-diffusion/mlx/mlx/backend/no_cpu/available.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..04c1bac8ea99f3750446fb594e9b9f55b41ea0f7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/no_cpu/available.cpp
@@ -0,0 +1,11 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/backend/cpu/available.h"
+
+namespace mlx::core::cpu {
+
+bool is_available() {
+  return false;
+}
+
+} // namespace mlx::core::cpu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/no_cpu/compiled.cpp b/ml-stable-diffusion/mlx/mlx/backend/no_cpu/compiled.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2eeddab47c34cb2b644703f8b0d2c691fbee582b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/no_cpu/compiled.cpp
@@ -0,0 +1,24 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/compile_impl.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core {
+
+// GPU compile is always available if the GPU is available and since we are in
+// this file CPU compile is not available so check if the device is a GPU
+// device.
+namespace detail {
+bool compile_available_for_device(const Device& device) {
+  return device == Device::gpu;
+}
+} // namespace detail
+
+void Compiled::eval_cpu(
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  throw std::runtime_error(
+      "[Compiled::eval_cpu] CPU compilation not supported on the platform.");
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/no_cpu/primitives.cpp b/ml-stable-diffusion/mlx/mlx/backend/no_cpu/primitives.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dba82c6dc4236c9a02da253070ece2f73c4322dd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/no_cpu/primitives.cpp
@@ -0,0 +1,142 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/primitives.h"
+#include "mlx/distributed/primitives.h"
+#include "mlx/fast_primitives.h"
+
+#define NO_CPU_MULTI(func)                                             \
+  void func::eval_cpu(                                                 \
+      const std::vector<array>& inputs, std::vector<array>& outputs) { \
+    throw std::runtime_error(#func " has no CPU implementation.");     \
+  }
+
+#define NO_CPU(func)                                                  \
+  void func::eval_cpu(const std::vector<array>& inputs, array& out) { \
+    throw std::runtime_error(#func " has no CPU implementation.");    \
+  }
+
+namespace mlx::core {
+
+NO_CPU(Abs)
+NO_CPU(Add)
+NO_CPU(AddMM)
+NO_CPU(Arange)
+NO_CPU(ArcCos)
+NO_CPU(ArcCosh)
+NO_CPU(ArcSin)
+NO_CPU(ArcSinh)
+NO_CPU(ArcTan)
+NO_CPU(ArcTan2)
+NO_CPU(ArcTanh)
+NO_CPU(ArgPartition)
+NO_CPU(ArgReduce)
+NO_CPU(ArgSort)
+NO_CPU(AsType)
+NO_CPU(AsStrided)
+NO_CPU(BitwiseBinary)
+NO_CPU(BitwiseInvert)
+NO_CPU(BlockMaskedMM)
+NO_CPU(Broadcast)
+NO_CPU(BroadcastAxes)
+NO_CPU(Ceil)
+NO_CPU(Cholesky)
+NO_CPU(Concatenate)
+NO_CPU(Conjugate)
+NO_CPU(Contiguous)
+NO_CPU(Convolution)
+NO_CPU(Copy)
+NO_CPU(Cos)
+NO_CPU(Cosh)
+NO_CPU_MULTI(CustomTransforms)
+NO_CPU_MULTI(Depends)
+NO_CPU(Divide)
+NO_CPU_MULTI(DivMod)
+NO_CPU(DynamicSlice)
+NO_CPU(DynamicSliceUpdate)
+NO_CPU(NumberOfElements)
+NO_CPU(Remainder)
+NO_CPU_MULTI(Eig)
+NO_CPU_MULTI(Eigh)
+NO_CPU(Equal)
+NO_CPU(Erf)
+NO_CPU(ErfInv)
+NO_CPU(Exp)
+NO_CPU(ExpandDims)
+NO_CPU(Expm1)
+NO_CPU(FFT)
+NO_CPU(Flatten)
+NO_CPU(Floor)
+NO_CPU(Full)
+NO_CPU(Gather)
+NO_CPU(GatherAxis)
+NO_CPU(GatherMM)
+NO_CPU(GatherQMM)
+NO_CPU(Greater)
+NO_CPU(GreaterEqual)
+NO_CPU(Hadamard)
+NO_CPU(Imag)
+NO_CPU(Less)
+NO_CPU(LessEqual)
+NO_CPU(Log)
+NO_CPU(Log1p)
+NO_CPU(LogicalNot)
+NO_CPU(LogicalAnd)
+NO_CPU(LogicalOr)
+NO_CPU(LogAddExp)
+NO_CPU(LogSumExp)
+NO_CPU_MULTI(LUF)
+NO_CPU(Matmul)
+NO_CPU(Maximum)
+NO_CPU(Minimum)
+NO_CPU(Multiply)
+NO_CPU(Negative)
+NO_CPU(NotEqual)
+NO_CPU(Pad)
+NO_CPU(Partition)
+NO_CPU(Power)
+NO_CPU_MULTI(QRF)
+NO_CPU(QuantizedMatmul)
+NO_CPU(RandomBits)
+NO_CPU(Real)
+NO_CPU(Reduce)
+NO_CPU(Reshape)
+NO_CPU(Round)
+NO_CPU(Scan)
+NO_CPU(Scatter)
+NO_CPU(ScatterAxis)
+NO_CPU(Select)
+NO_CPU(SegmentedMM)
+NO_CPU(Sigmoid)
+NO_CPU(Sign)
+NO_CPU(Sin)
+NO_CPU(Sinh)
+NO_CPU(Slice)
+NO_CPU(SliceUpdate)
+NO_CPU(Softmax)
+NO_CPU(Sort)
+NO_CPU_MULTI(Split)
+NO_CPU(Square)
+NO_CPU(Squeeze)
+NO_CPU(Sqrt)
+NO_CPU(StopGradient)
+NO_CPU(Subtract)
+NO_CPU_MULTI(SVD)
+NO_CPU(Tan)
+NO_CPU(Tanh)
+NO_CPU(Transpose)
+NO_CPU(Unflatten)
+NO_CPU(Inverse)
+NO_CPU(View)
+
+namespace fast {
+NO_CPU_MULTI(Quantize)
+} // namespace fast
+
+namespace distributed {
+NO_CPU_MULTI(AllReduce)
+NO_CPU_MULTI(AllGather)
+NO_CPU_MULTI(Send)
+NO_CPU_MULTI(Recv)
+} // namespace distributed
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/no_gpu/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..78e15ac69564dfefbc4cbfa3021d64d0bfd335a0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/CMakeLists.txt
@@ -0,0 +1,7 @@
+target_sources(
+  mlx
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/allocator.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/event.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/fence.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/eval.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/primitives.cpp)
diff --git a/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..320d1a2670fc27b8de03b60d17898e28d1d4a473
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/allocator.cpp
@@ -0,0 +1,132 @@
+// Copyright © 2023 Apple Inc.
+
+#include <algorithm>
+#include <mutex>
+
+#include "mlx/allocator.h"
+
+#ifdef __APPLE__
+#include "mlx/backend/no_gpu/apple_memory.h"
+#elif defined(__linux__)
+#include "mlx/backend/no_gpu/linux_memory.h"
+#else
+size_t get_memory_size() {
+  return 0;
+}
+#endif
+
+namespace mlx::core {
+
+namespace allocator {
+
+class CommonAllocator : public Allocator {
+  /** A general CPU allocator. */
+ public:
+  virtual Buffer malloc(size_t size) override;
+  virtual void free(Buffer buffer) override;
+  virtual size_t size(Buffer buffer) const override;
+  size_t get_active_memory() const {
+    return active_memory_;
+  };
+  size_t get_peak_memory() const {
+    return peak_memory_;
+  };
+  void reset_peak_memory() {
+    std::unique_lock lk(mutex_);
+    peak_memory_ = 0;
+  };
+  size_t get_memory_limit() {
+    return memory_limit_;
+  }
+  size_t set_memory_limit(size_t limit) {
+    std::unique_lock lk(mutex_);
+    std::swap(memory_limit_, limit);
+    return limit;
+  }
+
+ private:
+  size_t memory_limit_;
+  size_t active_memory_{0};
+  size_t peak_memory_{0};
+  std::mutex mutex_;
+  CommonAllocator() : memory_limit_(0.8 * get_memory_size()) {
+    if (memory_limit_ == 0) {
+      memory_limit_ = 1UL << 33;
+    }
+  };
+
+  friend CommonAllocator& common_allocator();
+};
+
+CommonAllocator& common_allocator() {
+  static CommonAllocator allocator_;
+  return allocator_;
+}
+
+Allocator& allocator() {
+  return common_allocator();
+}
+
+void* Buffer::raw_ptr() {
+  if (!ptr_) {
+    return nullptr;
+  }
+  return static_cast<size_t*>(ptr_) + 1;
+}
+
+Buffer CommonAllocator::malloc(size_t size) {
+  void* ptr = std::malloc(size + sizeof(size_t));
+  if (ptr != nullptr) {
+    *static_cast<size_t*>(ptr) = size;
+  }
+  std::unique_lock lk(mutex_);
+  active_memory_ += size;
+  peak_memory_ = std::max(active_memory_, peak_memory_);
+  return Buffer{ptr};
+}
+
+void CommonAllocator::free(Buffer buffer) {
+  auto sz = size(buffer);
+  std::free(buffer.ptr());
+  std::unique_lock lk(mutex_);
+  active_memory_ -= sz;
+}
+
+size_t CommonAllocator::size(Buffer buffer) const {
+  if (buffer.ptr() == nullptr) {
+    return 0;
+  }
+  return *static_cast<size_t*>(buffer.ptr());
+}
+
+} // namespace allocator
+
+size_t get_active_memory() {
+  return allocator::common_allocator().get_active_memory();
+}
+size_t get_peak_memory() {
+  return allocator::common_allocator().get_peak_memory();
+}
+void reset_peak_memory() {
+  return allocator::common_allocator().reset_peak_memory();
+}
+size_t set_memory_limit(size_t limit) {
+  return allocator::common_allocator().set_memory_limit(limit);
+}
+size_t get_memory_limit() {
+  return allocator::common_allocator().get_memory_limit();
+}
+
+// No-ops for common allocator
+size_t get_cache_memory() {
+  return 0;
+}
+size_t set_cache_limit(size_t) {
+  return 0;
+}
+size_t set_wired_limit(size_t) {
+  return 0;
+}
+void clear_cache() {}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/no_gpu/apple_memory.h b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/apple_memory.h
new file mode 100644
index 0000000000000000000000000000000000000000..7fdc53014ee21ed22e09299b7eddee5a926692be
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/apple_memory.h
@@ -0,0 +1,16 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include <sys/sysctl.h>
+
+namespace {
+
+size_t get_memory_size() {
+  size_t memsize = 0;
+  size_t length = sizeof(memsize);
+  sysctlbyname("hw.memsize", &memsize, &length, NULL, 0);
+  return memsize;
+}
+
+} // namespace
diff --git a/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8bff86a98eee8bc375fc275d843e317933638451
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/eval.cpp
@@ -0,0 +1,28 @@
+// Copyright © 2025 Apple Inc.
+
+#include <stdexcept>
+
+#include "mlx/backend/gpu/available.h"
+#include "mlx/backend/gpu/eval.h"
+
+namespace mlx::core::gpu {
+
+bool is_available() {
+  return false;
+}
+
+void new_stream(Stream) {}
+
+void eval(array&) {
+  throw std::runtime_error("[gpu::eval] GPU backend is not available");
+}
+
+void finalize(Stream) {
+  throw std::runtime_error("[gpu::finalize] GPU backend is not available");
+}
+
+void synchronize(Stream) {
+  throw std::runtime_error("[gpu::synchronize]  GPU backend is not available");
+}
+
+} // namespace mlx::core::gpu
diff --git a/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6dde047ab4343aeda5e2f21ff83e7dfb4fe61ad3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/event.cpp
@@ -0,0 +1,53 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/event.h"
+#include "mlx/scheduler.h"
+
+#include <condition_variable>
+#include <mutex>
+
+namespace mlx::core {
+
+struct EventCounter {
+  uint64_t value{0};
+  std::mutex mtx;
+  std::condition_variable cv;
+};
+
+Event::Event(Stream stream) : stream_(stream) {
+  auto dtor = [](void* ptr) { delete static_cast<EventCounter*>(ptr); };
+  event_ = std::shared_ptr<void>(new EventCounter{}, dtor);
+}
+
+void Event::wait() {
+  auto ec = static_cast<EventCounter*>(event_.get());
+  std::unique_lock<std::mutex> lk(ec->mtx);
+  if (ec->value >= value()) {
+    return;
+  }
+  ec->cv.wait(lk, [value = value(), ec] { return ec->value >= value; });
+}
+
+void Event::wait(Stream stream) {
+  scheduler::enqueue(stream, [*this]() mutable { wait(); });
+}
+
+void Event::signal(Stream stream) {
+  scheduler::enqueue(stream, [*this]() mutable {
+    auto ec = static_cast<EventCounter*>(event_.get());
+    {
+      std::lock_guard<std::mutex> lk(ec->mtx);
+      ec->value = value();
+    }
+    ec->cv.notify_all();
+  });
+}
+
+bool Event::is_signaled() const {
+  auto ec = static_cast<EventCounter*>(event_.get());
+  {
+    std::lock_guard<std::mutex> lk(ec->mtx);
+    return (ec->value >= value());
+  }
+}
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..af22108a8360a9b1f28dcc8407f70d83f54beea2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/fence.cpp
@@ -0,0 +1,54 @@
+// Copyright © 2024 Apple Inc.
+
+#include <condition_variable>
+#include <mutex>
+
+#include "mlx/fence.h"
+#include "mlx/scheduler.h"
+
+namespace mlx::core {
+
+struct FenceImpl {
+  uint32_t count{0};
+  uint32_t value{0};
+  std::mutex mtx;
+  std::condition_variable cv;
+};
+
+Fence::Fence(Stream) {
+  auto dtor = [](void* ptr) { delete static_cast<FenceImpl*>(ptr); };
+  fence_ = std::shared_ptr<void>(new FenceImpl{}, dtor);
+}
+
+void Fence::wait(Stream stream, const array&) {
+  auto& f = *static_cast<FenceImpl*>(fence_.get());
+  if (stream.device == Device::cpu) {
+    scheduler::enqueue(stream, [count = f.count, fence_ = fence_]() mutable {
+      auto& f = *static_cast<FenceImpl*>(fence_.get());
+      std::unique_lock<std::mutex> lk(f.mtx);
+      if (f.value >= count) {
+        return;
+      }
+      f.cv.wait(lk, [&f, count] { return f.value >= count; });
+    });
+  } else {
+    throw std::runtime_error("[Fence::wait] Invalid stream.");
+  }
+}
+
+void Fence::update(Stream stream, const array&) {
+  auto& f = *static_cast<FenceImpl*>(fence_.get());
+  f.count++;
+  if (stream.device == Device::cpu) {
+    scheduler::enqueue(stream, [count = f.count, fence_ = fence_]() mutable {
+      auto& f = *static_cast<FenceImpl*>(fence_.get());
+      std::unique_lock<std::mutex> lk(f.mtx);
+      f.value = count;
+      f.cv.notify_all();
+    });
+  } else {
+    throw std::runtime_error("[Fence::update] Invalid stream.");
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/backend/no_gpu/linux_memory.h b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/linux_memory.h
new file mode 100644
index 0000000000000000000000000000000000000000..f909edcd78f767f366d36afcb165672f02151ec6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/linux_memory.h
@@ -0,0 +1,22 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include <sys/sysinfo.h>
+
+namespace {
+
+size_t get_memory_size() {
+  struct sysinfo info;
+
+  if (sysinfo(&info) != 0) {
+    return 0;
+  }
+
+  size_t total_ram = info.totalram;
+  total_ram *= info.mem_unit;
+
+  return total_ram;
+}
+
+} // namespace
diff --git a/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..22a0c8acc41c11cb903eaf81d63f0f1052290a1a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/backend/no_gpu/primitives.cpp
@@ -0,0 +1,168 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/primitives.h"
+#include "mlx/distributed/primitives.h"
+#include "mlx/fast_primitives.h"
+
+#define NO_GPU_MULTI(func)                                             \
+  void func::eval_gpu(                                                 \
+      const std::vector<array>& inputs, std::vector<array>& outputs) { \
+    throw std::runtime_error(#func " has no GPU implementation.");     \
+  }
+
+#define NO_GPU_USE_FALLBACK(func)     \
+  bool func::use_fallback(Stream s) { \
+    return true;                      \
+  }                                   \
+  NO_GPU_MULTI(func)
+
+#define NO_GPU(func)                                                  \
+  void func::eval_gpu(const std::vector<array>& inputs, array& out) { \
+    throw std::runtime_error(#func " has no GPU implementation.");    \
+  }
+
+namespace mlx::core {
+
+bool fast::ScaledDotProductAttention::use_fallback(
+    const array& q,
+    const array& k,
+    const array& v,
+    bool has_mask,
+    bool has_arr_mask,
+    bool do_causal,
+    Stream s) {
+  return true;
+}
+
+NO_GPU(Abs)
+NO_GPU(Add)
+NO_GPU(AddMM)
+NO_GPU(Arange)
+NO_GPU(ArcCos)
+NO_GPU(ArcCosh)
+NO_GPU(ArcSin)
+NO_GPU(ArcSinh)
+NO_GPU(ArcTan)
+NO_GPU(ArcTan2)
+NO_GPU(ArcTanh)
+NO_GPU(ArgPartition)
+NO_GPU(ArgReduce)
+NO_GPU(ArgSort)
+NO_GPU(AsType)
+NO_GPU(AsStrided)
+NO_GPU(BitwiseBinary)
+NO_GPU(BitwiseInvert)
+NO_GPU(BlockMaskedMM)
+NO_GPU(Broadcast)
+NO_GPU(BroadcastAxes)
+NO_GPU(Ceil)
+NO_GPU_MULTI(Compiled)
+NO_GPU(Concatenate)
+NO_GPU(Conjugate)
+NO_GPU(Contiguous)
+NO_GPU(Convolution)
+NO_GPU(Copy)
+NO_GPU(Cos)
+NO_GPU(Cosh)
+NO_GPU_MULTI(CustomTransforms)
+NO_GPU_MULTI(Depends)
+NO_GPU(Divide)
+NO_GPU_MULTI(DivMod)
+NO_GPU(DynamicSlice)
+NO_GPU(DynamicSliceUpdate)
+NO_GPU(NumberOfElements)
+NO_GPU(Remainder)
+NO_GPU(Equal)
+NO_GPU(Erf)
+NO_GPU(ErfInv)
+NO_GPU(Exp)
+NO_GPU(ExpandDims)
+NO_GPU(Expm1)
+NO_GPU(FFT)
+NO_GPU(Flatten)
+NO_GPU(Floor)
+NO_GPU(Full)
+NO_GPU(Gather)
+NO_GPU(GatherAxis)
+NO_GPU(GatherMM)
+NO_GPU(GatherQMM)
+NO_GPU(Greater)
+NO_GPU(GreaterEqual)
+NO_GPU(Hadamard)
+NO_GPU(Imag)
+NO_GPU(Less)
+NO_GPU(LessEqual)
+NO_GPU(Load)
+NO_GPU(Log)
+NO_GPU(Log1p)
+NO_GPU(LogicalNot)
+NO_GPU(LogicalAnd)
+NO_GPU(LogicalOr)
+NO_GPU(LogAddExp)
+NO_GPU(LogSumExp)
+NO_GPU_MULTI(LUF)
+NO_GPU(Matmul)
+NO_GPU(Maximum)
+NO_GPU(Minimum)
+NO_GPU(Multiply)
+NO_GPU(Negative)
+NO_GPU(NotEqual)
+NO_GPU(Pad)
+NO_GPU(Partition)
+NO_GPU(Power)
+NO_GPU_MULTI(QRF)
+NO_GPU(QuantizedMatmul)
+NO_GPU(RandomBits)
+NO_GPU(Real)
+NO_GPU(Reduce)
+NO_GPU(Reshape)
+NO_GPU(Round)
+NO_GPU(Scan)
+NO_GPU(Scatter)
+NO_GPU(ScatterAxis)
+NO_GPU(Select)
+NO_GPU(SegmentedMM)
+NO_GPU(Sigmoid)
+NO_GPU(Sign)
+NO_GPU(Sin)
+NO_GPU(Sinh)
+NO_GPU(Slice)
+NO_GPU(SliceUpdate)
+NO_GPU(Softmax)
+NO_GPU(Sort)
+NO_GPU_MULTI(Split)
+NO_GPU(Square)
+NO_GPU(Squeeze)
+NO_GPU(Sqrt)
+NO_GPU(StopGradient)
+NO_GPU(Subtract)
+NO_GPU_MULTI(SVD)
+NO_GPU(Tan)
+NO_GPU(Tanh)
+NO_GPU(Transpose)
+NO_GPU(Unflatten)
+NO_GPU(Inverse)
+NO_GPU(Cholesky)
+NO_GPU_MULTI(Eigh)
+NO_GPU_MULTI(Eig)
+NO_GPU(View)
+
+namespace fast {
+NO_GPU_USE_FALLBACK(LayerNorm)
+NO_GPU_MULTI(LayerNormVJP)
+NO_GPU_USE_FALLBACK(RMSNorm)
+NO_GPU_MULTI(RMSNormVJP)
+NO_GPU_USE_FALLBACK(RoPE)
+NO_GPU(ScaledDotProductAttention)
+NO_GPU_MULTI(Quantize)
+NO_GPU_MULTI(CustomKernel)
+} // namespace fast
+
+namespace distributed {
+NO_GPU_MULTI(AllReduce)
+NO_GPU_MULTI(AllGather)
+NO_GPU_MULTI(Send)
+NO_GPU_MULTI(Recv)
+} // namespace distributed
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/compile.cpp b/ml-stable-diffusion/mlx/mlx/compile.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..90791b02e441e2389d326464d498fcd06050989e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/compile.cpp
@@ -0,0 +1,1165 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <cstdlib>
+#include <map>
+#include <sstream>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "mlx/allocator.h"
+#include "mlx/backend/common/compiled.h"
+#include "mlx/compile.h"
+#include "mlx/compile_impl.h"
+#include "mlx/fast_primitives.h"
+#include "mlx/graph_utils.h"
+#include "mlx/primitives.h"
+#include "mlx/transforms.h"
+#include "mlx/transforms_impl.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+constexpr int max_compile_depth = 11;
+constexpr int max_compile_arrays = 24;
+
+bool is_unary(const Primitive& p) {
+  return (
+      typeid(p) == typeid(Abs) || typeid(p) == typeid(ArcCos) ||
+      typeid(p) == typeid(ArcCosh) || typeid(p) == typeid(ArcSin) ||
+      typeid(p) == typeid(ArcSinh) || typeid(p) == typeid(ArcTan) ||
+      typeid(p) == typeid(ArcTanh) || typeid(p) == typeid(AsType) ||
+      typeid(p) == typeid(Ceil) || typeid(p) == typeid(Cos) ||
+      typeid(p) == typeid(Conjugate) || typeid(p) == typeid(Cosh) ||
+      typeid(p) == typeid(Remainder) || typeid(p) == typeid(Erf) ||
+      typeid(p) == typeid(ErfInv) || typeid(p) == typeid(Exp) ||
+      typeid(p) == typeid(Floor) || typeid(p) == typeid(Log) ||
+      typeid(p) == typeid(Log1p) || typeid(p) == typeid(LogicalNot) ||
+      typeid(p) == typeid(Negative) || typeid(p) == typeid(Round) ||
+      typeid(p) == typeid(Sigmoid) || typeid(p) == typeid(Sign) ||
+      typeid(p) == typeid(Sin) || typeid(p) == typeid(Sinh) ||
+      typeid(p) == typeid(Square) || typeid(p) == typeid(Sqrt) ||
+      typeid(p) == typeid(Tan) || typeid(p) == typeid(Tanh) ||
+      typeid(p) == typeid(Expm1) || typeid(p) == typeid(Real) ||
+      typeid(p) == typeid(Imag) || typeid(p) == typeid(BitwiseInvert));
+}
+
+bool is_binary(const Primitive& p) {
+  return (
+      typeid(p) == typeid(Add) || typeid(p) == typeid(Divide) ||
+      typeid(p) == typeid(Equal) || typeid(p) == typeid(Greater) ||
+      typeid(p) == typeid(GreaterEqual) || typeid(p) == typeid(Less) ||
+      typeid(p) == typeid(LessEqual) || typeid(p) == typeid(LogicalNot) ||
+      typeid(p) == typeid(LogicalAnd) || typeid(p) == typeid(LogicalOr) ||
+      typeid(p) == typeid(LogAddExp) || typeid(p) == typeid(Maximum) ||
+      typeid(p) == typeid(Minimum) || typeid(p) == typeid(Multiply) ||
+      typeid(p) == typeid(NotEqual) || typeid(p) == typeid(Power) ||
+      typeid(p) == typeid(Subtract) || typeid(p) == typeid(BitwiseBinary) ||
+      typeid(p) == typeid(ArcTan2));
+}
+
+bool is_ternary(const Primitive& p) {
+  return typeid(p) == typeid(Select);
+}
+
+bool is_broadcast(const Primitive& p) {
+  return typeid(p) == typeid(Broadcast);
+}
+
+bool is_noop(const Primitive& p) {
+  return typeid(p) == typeid(Copy) || typeid(p) == typeid(StopGradient);
+}
+
+bool is_reduction(const Primitive& p) {
+  return typeid(p) == typeid(Reduce) || typeid(p) == typeid(ArgReduce);
+}
+
+bool is_fusable(const Primitive& p) {
+  return is_unary(p) || is_binary(p) || is_ternary(p) || is_broadcast(p);
+}
+
+Compiled::Compiled(
+    Stream stream,
+    std::vector<array> inputs,
+    std::vector<array> outputs,
+    std::vector<array> tape,
+    std::unordered_set<uintptr_t> constant_ids)
+    : Primitive(stream),
+      inputs_(std::move(inputs)),
+      outputs_(std::move(outputs)),
+      tape_(std::move(tape)),
+      constant_ids_(std::move(constant_ids)),
+      is_constant_([this](size_t i) {
+        return constant_ids_.find(inputs_[i].id()) != constant_ids_.end();
+      }) {
+  // Build the kernel name.
+  NodeNamer namer;
+  std::ostringstream os;
+  std::ostringstream constant_hasher;
+
+  std::unordered_set<uintptr_t> output_ids;
+  for (auto& o : outputs_) {
+    output_ids.insert(o.id());
+  }
+
+  // Fill the input names. This is not really necessary, I just like having A,
+  // B, C, ... as the inputs.
+  for (const auto& x : inputs_) {
+    namer.get_name(x);
+  }
+
+  // The primitives describing the tape. For unary and binary primitives this
+  // must be enough to describe the full computation.
+  for (const auto& a : tape_) {
+    // name and type of output
+    os << namer.get_name(a) << kindof(a.dtype()) << a.itemsize();
+    // whether or not it's an output
+    if (output_ids.find(a.id()) != output_ids.end()) {
+      os << "O";
+    } else {
+      os << "I";
+    }
+    // computation performed
+    os << a.primitive().name();
+    // name of inputs to the function
+    for (auto& inp : a.inputs()) {
+      os << namer.get_name(inp);
+    }
+  }
+  os << "_";
+
+  for (const auto& x : inputs_) {
+    if (constant_ids_.find(x.id()) != constant_ids_.end()) {
+      os << "C";
+      print_constant(constant_hasher, x);
+    } else {
+      os << (is_scalar(x) ? "S" : "V");
+    }
+  }
+  os << "_";
+  for (const auto& x : inputs) {
+    if (constant_ids.find(x.id()) != constant_ids.end()) {
+      continue;
+    }
+    os << kindof(x.dtype()) << x.itemsize();
+  }
+  os << "_" << std::hash<std::string>{}(constant_hasher.str());
+
+  kernel_lib_ = os.str();
+}
+
+std::vector<array> Compiled::vjp(
+    const std::vector<array>&,
+    const std::vector<array>&,
+    const std::vector<int>&,
+    const std::vector<array>&) {
+  throw std::runtime_error("[Compiled] Cannot vjp primitive.");
+}
+
+std::vector<array> Compiled::jvp(
+    const std::vector<array>&,
+    const std::vector<array>&,
+    const std::vector<int>&) {
+  throw std::runtime_error("[Compiled] Cannot jvp primitive.");
+}
+
+std::pair<std::vector<array>, std::vector<int>> Compiled::vmap(
+    const std::vector<array>&,
+    const std::vector<int>&) {
+  throw std::runtime_error("[Compiled] Cannot vmap primitive.");
+}
+
+bool Compiled::is_equivalent(const Primitive& other) const {
+  const Compiled& a_other = static_cast<const Compiled&>(other);
+  return std::equal(
+      tape_.begin(),
+      tape_.end(),
+      a_other.tape_.begin(),
+      a_other.tape_.end(),
+      [](const array& a1, const array& a2) {
+        auto& p1 = a1.primitive();
+        auto& p2 = a2.primitive();
+        return typeid(p1) == typeid(p2) && p1.is_equivalent(p2);
+      });
+}
+
+const char* Compiled::name() const {
+  if (name_.empty()) {
+    std::ostringstream os;
+    os << "Compiled";
+    for (auto& a : tape_) {
+      os << a.primitive().name();
+    }
+    name_ = os.str();
+  }
+  return name_.c_str();
+}
+
+std::vector<Shape> Compiled::output_shapes(const std::vector<array>& inputs) {
+  size_t nd = 0;
+  for (auto& in : inputs) {
+    nd = std::max(nd, in.ndim());
+  }
+  Shape out_shape(nd, 0);
+  for (auto& in : inputs) {
+    auto dd = nd - in.ndim();
+    for (auto i = dd; i < nd; ++i) {
+      out_shape[i] = std::max(out_shape[i], in.shape()[i - dd]);
+    }
+  }
+  // All outputs have the same shape
+  return std::vector<Shape>(outputs_.size(), out_shape);
+}
+
+namespace detail {
+
+CompileMode& compile_mode() {
+  auto get_val = []() {
+    if (const char* buff_str = std::getenv("MLX_DISABLE_COMPILE")) {
+      return CompileMode::disabled;
+    } else {
+      return CompileMode::enabled;
+    }
+  };
+  static CompileMode compile_mode_ = get_val();
+  return compile_mode_;
+}
+
+// Helper like below but only merges the two provided arrays. If the src has
+// siblings then these won't be merged to the dst.
+void merge_one(array& dst, array& src, ParentsMap& parents_map) {
+  auto src_parents = parents_map.find(src.id());
+  if (src_parents == parents_map.end()) {
+    return;
+  }
+  auto& pairs = parents_map[dst.id()];
+  for (auto& parent : src_parents->second) {
+    parent.first.inputs()[parent.second] = dst;
+    pairs.push_back(parent);
+  }
+
+  // If src is a parent of dst, remove it from dst's parents
+  for (auto it = pairs.begin(); it != pairs.end();) {
+    if (it->first.id() == src.id()) {
+      it = pairs.erase(it);
+    } else {
+      it++;
+    }
+  }
+  // Remove the source from the map to avoid fusing with it again
+  parents_map.erase(src_parents);
+}
+
+// Helper that merges two arrays in the graph by setting the parents of the
+// source to point to the destination. The arrays are assumed to be coming from
+// equivalent primitives so their siblings are merged as well.
+void merge(array& dst, array& src, ParentsMap& parents_map) {
+  // Canonicalize the order of the primitives outputs
+  auto sources = src.outputs();
+  auto dests = dst.outputs();
+  // For each src parent, point it to the corresponding dst
+  for (int i = 0; i < sources.size(); ++i) {
+    merge_one(dests[i], sources[i], parents_map);
+  }
+}
+
+// Any parent in the divider will continue to refer to `x` but any parent not
+// in the divider will refer to a copy of the operation.
+array split_one(
+    const array& x,
+    ParentsMap& parents_map,
+    const std::unordered_set<uintptr_t>& divider) {
+  array y(x.shape(), x.dtype(), x.primitive_ptr(), x.inputs());
+
+  auto& x_parents = parents_map[x.id()];
+  auto& y_parents = parents_map[y.id()];
+
+  for (auto it = x_parents.begin(); it != x_parents.end();) {
+    if (divider.find(it->first.id()) != divider.end()) {
+      it->first.inputs()[it->second] = y;
+      y_parents.emplace_back(std::move(*it));
+      it = x_parents.erase(it);
+    } else {
+      it++;
+    }
+  }
+
+  return std::move(y);
+}
+
+template <typename T, typename... U>
+std::uintptr_t get_function_address(const std::function<T(U...)>& fun) {
+  using FunType = T (*)(U...);
+  const FunType* fun_ptr = fun.template target<FunType>();
+  if (fun_ptr == nullptr) {
+    return 0;
+  }
+  return reinterpret_cast<std::uintptr_t>(*fun_ptr);
+}
+
+class CompilerCache {
+ public:
+  struct CacheEntry {
+    CacheEntry(Stream stream, bool shapeless)
+        : stream(stream), shapeless(shapeless) {};
+    Stream stream;
+    bool shapeless;
+    std::vector<array> inputs;
+    std::vector<array> outputs;
+    std::vector<array> tape;
+    bool empty{true};
+    std::vector<uint64_t> constants;
+    std::shared_ptr<void> extra;
+  };
+
+  // Returns a reference to a CacheEntry which can be updated
+  // by the caller to avoid copying large tapes / inputs / outputs
+  CacheEntry& find(
+      std::uintptr_t fun_id,
+      const std::vector<array>& inputs,
+      bool shapeless,
+      const std::vector<uint64_t>& constants) {
+    // Find the cache entries for |fun_id|.
+    std::vector<CacheEntry>& entries = cache_[fun_id];
+
+    // Compare if 2 arrays have same shape and dtype.
+    auto has_same_shape_and_dtype = [shapeless](
+                                        const std::vector<array>& in1,
+                                        const std::vector<array>& in2) {
+      if (in1.size() != in2.size()) {
+        return false;
+      }
+      for (size_t i = 0; i < in1.size(); ++i) {
+        if (in1[i].ndim() != in2[i].ndim()) {
+          return false;
+        }
+        if (!shapeless && in1[i].shape() != in2[i].shape()) {
+          return false;
+        }
+        if (in1[i].dtype() != in2[i].dtype()) {
+          return false;
+        }
+      }
+      return true;
+    };
+    // Loop over entries and check:
+    // - Default stream and device match the entry's default stream
+    // - Inputs match i.e. shapes and types must be equal.
+    auto stream = default_stream(default_device());
+    for (CacheEntry& entry : entries) {
+      // Check that the default stream and device match
+      if (entry.stream != stream) {
+        continue;
+      }
+      if (entry.shapeless != shapeless) {
+        continue;
+      }
+
+      // Check the inputs match and return if so
+      if (has_same_shape_and_dtype(inputs, entry.inputs) &&
+          constants == entry.constants) {
+        return entry;
+      }
+    }
+    // Otherwise append a new cache entry
+    entries.push_back(CacheEntry{stream, shapeless});
+    return entries.back();
+  }
+
+  void erase(std::uintptr_t fun_id) {
+    cache_.erase(fun_id);
+  }
+
+  void clear() {
+    cache_.clear();
+  }
+
+ private:
+  CompilerCache() {
+    // Make sure the allocator is fully
+    // initialized before the compiler cache
+    allocator::allocator();
+  }
+
+  friend CompilerCache& compiler_cache();
+  std::unordered_map<std::uintptr_t, std::vector<CacheEntry>> cache_;
+};
+
+CompilerCache& compiler_cache() {
+  static CompilerCache compiler_cache_;
+  return compiler_cache_;
+}
+
+std::tuple<std::vector<array>, std::vector<array>, std::shared_ptr<void>>
+compile_trace(
+    const ArrayFnWithExtra& fun,
+    const std::vector<array>& inputs,
+    bool shapeless) {
+  // Set the global tracing flag.
+  detail::InTracing in_tracing{shapeless};
+
+  // Run the function on placeholder inputs
+  // to get compute graph
+  std::vector<array> tracer_inputs;
+  for (int i = 0; i < inputs.size(); ++i) {
+    array in(inputs[i].shape(), inputs[i].dtype(), nullptr, {});
+    in.set_tracer(true);
+    tracer_inputs.push_back(std::move(in));
+  }
+
+  auto output = fun(tracer_inputs);
+  return {tracer_inputs, output.first, output.second};
+}
+
+// Traverses the graph to build a tape and a map of array ids to their parents
+std::pair<std::vector<array>, ParentsMap> compile_dfs(
+    const std::vector<array>& inputs,
+    const std::vector<array>& outputs,
+    const std::vector<array>& original_inputs) {
+  std::function<void(const array&)> recurse;
+  std::vector<array> tape;
+  std::unordered_set<std::uintptr_t> input_set;
+  std::unordered_set<std::uintptr_t> original_input_set;
+  std::unordered_map<std::uintptr_t, std::vector<std::pair<array, int>>>
+      parents_map;
+  for (int i = 0; i < inputs.size(); ++i) {
+    input_set.insert(inputs[i].id());
+    original_input_set.insert(original_inputs[i].id());
+  }
+
+  // DFS the graph to build the tape, and log parents and scalars
+  std::unordered_set<std::uintptr_t> cache;
+  recurse = [&](const array& a) {
+    auto id = a.id();
+    if (original_input_set.find(id) != original_input_set.end()) {
+      throw std::invalid_argument(
+          "[compile] Attempting to compile a function with uncaptured inputs is not allowed.");
+    }
+    if (cache.find(id) != cache.end()) {
+      return;
+    }
+    for (int i = 0; i < a.inputs().size(); i++) {
+      auto& in = a.inputs()[i];
+      parents_map[in.id()].push_back({a, i});
+      for (auto& s : a.siblings()) {
+        parents_map[in.id()].push_back({s, i});
+      }
+      // Don't recurse on inputs (but add them to the tape for the purpose
+      // of future optimizations)
+      if (input_set.find(a.id()) == input_set.end()) {
+        recurse(in);
+      }
+    }
+    cache.insert(id);
+    for (auto& s : a.siblings()) {
+      cache.insert(s.id());
+    }
+    tape.push_back(a);
+  };
+  for (auto& a : outputs) {
+    recurse(a);
+  }
+  return {tape, parents_map};
+}
+
+static inline uint64_t splitmix64(uint64_t x) noexcept {
+  x += 0x9e3779b97f4a7c15ull;
+  x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9ull;
+  x = (x ^ (x >> 27)) * 0x94d049bb133111ebull;
+  return x ^ (x >> 31);
+}
+
+struct VecU64Hash {
+  size_t operator()(const std::vector<uint64_t>& s) const noexcept {
+    uint64_t h =
+        0x243f6a8885a308d3ull ^ (uint64_t)s.size() * 0x9e3779b97f4a7c15ull;
+    for (uint64_t x : s) {
+      h = splitmix64(x ^ splitmix64(h + 0x9e3779b97f4a7c15ull));
+    }
+    return (size_t)h;
+  }
+};
+
+// Simplify the tape. Note, this function modifies in-place both the tape,
+// the parents map to remove orphaned arrays, and potentially the outputs
+void compile_simplify(
+    std::vector<array>& tape,
+    ParentsMap& parents_map,
+    std::vector<array>& outputs,
+    int passes) {
+  // Helpers to identify identical scalars
+  std::map<std::pair<uint64_t, Dtype::Val>, array> scalars;
+  auto is_scalar = [](const array& a) {
+    // Condition for when it's safe to read an array
+    return a.is_available() && a.ndim() == 0;
+  };
+  auto get_scalar_rep = [](const array& a) {
+    uint64_t v = 0;
+    int dtype;
+    switch (a.dtype().size()) {
+      case 1:
+        v = *a.data<uint8_t>();
+        break;
+      case 2:
+        v = *a.data<uint16_t>();
+        break;
+      case 4:
+        v = *a.data<uint32_t>();
+        break;
+      case 8:
+        v = *a.data<uint64_t>();
+        break;
+    }
+    return std::make_pair(v, a.dtype().val());
+  };
+
+  for (auto& a : tape) {
+    if (is_scalar(a)) {
+      scalars.insert({get_scalar_rep(a), a});
+    }
+  }
+
+  // Depth-1 array equivalence check.
+  auto array_equivalent = [](const array& a, const array& b) {
+    if (!a.has_primitive() || !b.has_primitive()) {
+      return false;
+    }
+    if (a.primitive_id() == b.primitive_id()) {
+      return false;
+    }
+    const auto& pa = a.primitive();
+    const auto& pb = b.primitive();
+    if (typeid(pa) != typeid(pb)) {
+      return false;
+    }
+
+    if (a.inputs().size() != b.inputs().size()) {
+      return false;
+    }
+
+    for (int i = 0; i < a.inputs().size(); i++) {
+      if (a.inputs()[i].id() != b.inputs()[i].id()) {
+        return false;
+      }
+    }
+
+    return pa.is_equivalent(pb);
+  };
+
+  // Merge scalars
+  std::vector<array> new_tape;
+  for (auto& arr : tape) {
+    // Check if we can merge scalars
+    if (is_scalar(arr)) {
+      auto scalar = scalars.find(get_scalar_rep(arr));
+      if (scalar->second.id() != arr.id()) {
+        merge(scalar->second, arr, parents_map);
+        // Don't keep orphaned scalars in the tape
+        continue;
+      }
+    }
+    new_tape.push_back(std::move(arr));
+  }
+  tape = std::move(new_tape);
+
+  // Remove no-ops
+  {
+    std::unordered_map<uintptr_t, array> output_map;
+    for (auto& o : outputs) {
+      output_map.insert({o.id(), o});
+    }
+    for (auto& arr : tape) {
+      if (!arr.has_primitive() || !is_noop(arr.primitive())) {
+        new_tape.push_back(std::move(arr));
+        continue;
+      }
+      merge_one(arr.inputs()[0], arr, parents_map);
+      if (auto it = output_map.find(arr.id()); it != output_map.end()) {
+        it->second = arr.inputs()[0];
+      }
+    }
+    tape = std::move(new_tape);
+    for (auto& o : outputs) {
+      o = output_map.at(o.id());
+    }
+  }
+
+  std::unordered_map<std::uintptr_t, uint32_t> tape_order;
+  for (uint32_t i = 0; i < tape.size(); ++i) {
+    tape_order.insert({tape[i].id(), i});
+  }
+
+  std::unordered_set<uintptr_t> output_set;
+  for (auto& o : outputs) {
+    output_set.insert(o.id());
+  }
+
+  // Multi-pass merge only keeping non-orphaned arrays in the tape
+  for (int pass = 0; pass < passes; ++pass) {
+    for (auto& arr : tape) {
+      // Helper to check if we can merge the parents of the
+      // given array
+      auto maybe_merge_parents = [&](auto& a) {
+        auto parents = parents_map.find(a.id());
+        if (parents != parents_map.end()) {
+          auto N = parents->second.size();
+          std::vector<bool> mask(N, false);
+
+          auto try_merge = [&](int dst_idx, int src_idx) {
+            if (tape_order[parents->second[src_idx].first.id()] <
+                tape_order[parents->second[dst_idx].first.id()]) {
+              std::swap(src_idx, dst_idx);
+            }
+            auto& src = parents->second[src_idx].first;
+            auto& dst = parents->second[dst_idx].first;
+            if (src.id() != dst.id() && array_equivalent(src, dst) &&
+                output_set.find(src.id()) == output_set.end()) {
+              merge(dst, src, parents_map);
+              mask[src_idx] = true;
+            }
+          };
+
+          if (N > 100) {
+            std::unordered_map<
+                std::vector<uint64_t>,
+                std::vector<int>,
+                VecU64Hash>
+                dst_map;
+            // Find possibly mergeable groups
+            for (int i = 0; i < N; i++) {
+              // Make the hash key
+              std::vector<uint64_t> key;
+              auto& curr = parents->second[i].first;
+              key.reserve(curr.inputs().size() + 2);
+              for (auto& in : curr.inputs()) {
+                key.push_back(in.id());
+              }
+              auto& p = curr.primitive();
+              key.push_back(curr.inputs().size());
+              key.push_back(typeid(p).hash_code());
+              auto it = dst_map.find(key);
+              if (it == dst_map.end()) {
+                bool _;
+                std::tie(it, _) = dst_map.insert({key, std::vector<int>{}});
+              }
+              it->second.push_back(i);
+            }
+            for (auto& [_, group] : dst_map) {
+              for (int i = 0; i < group.size(); ++i) {
+                if (mask[group[i]]) {
+                  continue;
+                }
+                for (int j = i + 1; j < group.size(); ++j) {
+                  if (mask[group[j]]) {
+                    continue;
+                  }
+                  try_merge(group[i], group[j]);
+                }
+              }
+            }
+          } else {
+            for (int i = 0; i < N; ++i) {
+              if (mask[i]) {
+                continue;
+              }
+              for (int j = i + 1; j < N; ++j) {
+                if (mask[j]) {
+                  continue;
+                }
+                try_merge(i, j);
+              }
+            }
+          }
+
+          // Erase orphaned parents so we don't keep fusing with them
+          for (int i = N - 1; i >= 0; --i) {
+            if (mask[i]) {
+              parents->second.erase(parents->second.begin() + i);
+            }
+          }
+          return false;
+        } else {
+          return output_set.find(a.id()) == output_set.end();
+        }
+      };
+      bool discard = maybe_merge_parents(arr);
+      for (auto& s : arr.siblings()) {
+        discard &= maybe_merge_parents(s);
+      }
+      // If an array and its siblings have no parents, and none of them are
+      // outputs, it is safe to remove it from the tape
+      if (!discard) {
+        new_tape.push_back(std::move(arr));
+      }
+    }
+    tape = std::move(new_tape);
+  }
+}
+
+// Extract sub-graphs of the graph that can be compiled
+// and replace them with a Compiled Primitive.
+void compile_fuse(
+    std::vector<array>& tape,
+    ParentsMap& parents_map,
+    const std::vector<array>& inputs,
+    std::vector<array>& outputs) {
+  // Track outputs to replace with new compiled outputs
+  std::unordered_map<uintptr_t, array> output_map;
+  for (auto& o : outputs) {
+    output_map.insert({o.id(), o});
+  }
+
+  // Set of inputs to distinguish constants
+  std::unordered_set<uintptr_t> input_ids;
+  for (auto& in : inputs) {
+    input_ids.insert(in.id());
+  }
+
+  // Go through the tape in reverse order and check for fusable sub-graphs
+  std::vector<array> new_tape;
+  std::unordered_set<uintptr_t> global_cache;
+  for (int i = tape.size() - 1; i >= 0; --i) {
+    auto& arr = tape[i];
+
+    // Already compiled
+    if (global_cache.find(arr.id()) != global_cache.end()) {
+      continue;
+    }
+
+    // Two pass recursion:
+    // First pass:
+    //  - Collect all the primitives which we can fuse with
+    //  - Keeps a cache of fusable primitives which may be added out of
+    //    DAG order. We have to determine if all of a fused primitive's
+    //    outputs are also in the fused section, and this may not be the
+    //    case the first time we visit it.
+    // Second pass:
+    //  - Collect inputs to the new compiled primitive
+    //  - Add fusable primitives to a tape in the correct order
+
+    std::function<void(const array&, int, const Stream&, const Shape&)> recurse;
+    std::unordered_set<uintptr_t> cache;
+    std::unordered_set<uintptr_t> input_set;
+    recurse = [&](const array& a,
+                  int depth,
+                  const Stream& s,
+                  const Shape& shape) {
+      if (cache.find(a.id()) != cache.end()) {
+        return;
+      }
+
+      // Stop fusing if:
+      // - Depth limit exceeded
+      // - Constant input
+      // - Stream mismatch
+      // - Non fusable primitive
+      // - Is global output but has a different shape
+      if (depth >= max_compile_depth || !a.has_primitive() ||
+          a.primitive().stream() != s || !is_fusable(a.primitive()) ||
+          (output_map.find(a.id()) != output_map.end() && a.shape() != shape)) {
+        // Possible input
+        input_set.insert(a.id());
+        return;
+      }
+
+      bool all_parents_in = true;
+      if (depth > 0) {
+        // Guaranteed to have a parent since nested in the
+        // recursion.
+        auto& parents = parents_map.at(a.id());
+        for (auto& [p, idx] : parents) {
+          auto in_cache = cache.find(p.id()) != cache.end();
+          if (!in_cache) {
+            all_parents_in = false;
+            break;
+          }
+        }
+      }
+
+      // Arrays with a mix of parents outside the compilable section
+      // are not fusable except for broadcast which we can split to avoid
+      // stopping fusion
+      if (!all_parents_in) {
+        if (a.has_primitive() && is_broadcast(a.primitive())) {
+          array b = split_one(a, parents_map, cache);
+          recurse(b, depth, s, shape);
+        } else {
+          // Possible input
+          input_set.insert(a.id());
+        }
+        return;
+      }
+
+      if (output_map.find(a.id()) != output_map.end()) {
+        input_set.insert(a.id());
+      } else {
+        // Not an input anymore since fusing it
+        input_set.erase(a.id());
+      }
+      if (input_set.size() >= max_compile_arrays) {
+        return;
+      }
+      cache.insert({a.id()});
+
+      for (auto& in : a.inputs()) {
+        recurse(in, depth + 1, s, shape);
+      }
+    };
+
+    // This will be the result of the fused operation so it needs
+    //   a) to not be already computed ie have a primitive
+    //   b) that primitive to not be a broadcast since it will unnecessarily
+    //      cast to a contiguous array potentially blowing up memory
+    if (arr.has_primitive() && !is_broadcast(arr.primitive())) {
+      Stream s = arr.primitive().stream();
+      recurse(arr, 0, s, arr.shape());
+    }
+
+    // Not worth fusing a single primitive
+    if (cache.size() <= 1) {
+      new_tape.push_back(arr);
+      continue;
+    }
+
+    // Recurse a second time to build the tape in the right
+    // order and collect the inputs
+    input_set.clear();
+    std::vector<array> inputs;
+    std::vector<array> fused_tape;
+    std::unordered_set<uintptr_t> tape_set;
+    std::function<void(const array&)> recurse_tape;
+    recurse_tape = [&](const array& a) {
+      if (cache.find(a.id()) == cache.end()) {
+        if (input_set.find(a.id()) == input_set.end()) {
+          input_set.insert(a.id());
+          inputs.push_back(a);
+        }
+        return;
+      }
+      if (tape_set.find(a.id()) != tape_set.end()) {
+        return;
+      }
+      tape_set.insert(a.id());
+      for (auto& in : a.inputs()) {
+        recurse_tape(in);
+      }
+      fused_tape.push_back(a);
+    };
+    recurse_tape(arr);
+
+    std::vector<array> old_outputs;
+    // Add to global cache and add any global outputs to outputs
+    // of new primitive
+    for (int j = 0; j < fused_tape.size() - 1; ++j) {
+      auto& f = fused_tape[j];
+      if (output_map.find(f.id()) != output_map.end()) {
+        old_outputs.push_back(f);
+        // Parents are now siblings, update the parent map
+        auto& pairs = parents_map[f.id()];
+        pairs.erase(
+            std::remove_if(
+                pairs.begin(),
+                pairs.end(),
+                [&](auto& p) {
+                  return cache.find(p.first.id()) != cache.end();
+                }),
+            pairs.end());
+      } else {
+        // Remove inner fused arrays parents from the parents map
+        // to keep the parents map in a valid state
+        parents_map.erase(f.id());
+      }
+      global_cache.insert({f.id()});
+    }
+    old_outputs.push_back(arr);
+
+    std::vector<Shape> shapes;
+    std::vector<Dtype> types;
+    for (auto& o : old_outputs) {
+      if (o.shape() != old_outputs.back().shape()) {
+        throw std::runtime_error(
+            "[compile] Compilation failed. Tried to fuse operations with different output shapes");
+      }
+      shapes.push_back(o.shape());
+      types.push_back(o.dtype());
+    }
+    std::unordered_set<uintptr_t> constant_ids;
+    for (auto& in : inputs) {
+      // Scalar constant
+      if (in.size() == 1 && !in.has_primitive() &&
+          input_ids.find(in.id()) == input_ids.end()) {
+        constant_ids.insert(in.id());
+      }
+    }
+    auto compiled_outputs = array::make_arrays(
+        std::move(shapes),
+        types,
+        std::make_shared<Compiled>(
+            old_outputs.back().primitive().stream(),
+            inputs,
+            old_outputs,
+            std::move(fused_tape),
+            std::move(constant_ids)),
+        inputs);
+
+    // One output per primitive
+    new_tape.push_back(compiled_outputs.back());
+
+    // Replace inputs old parents with compiled_outputs
+    for (int i = 0; i < inputs.size(); ++i) {
+      auto& pairs = parents_map[inputs[i].id()];
+      pairs.erase(
+          std::remove_if(
+              pairs.begin(),
+              pairs.end(),
+              [&](auto& p) { return cache.find(p.first.id()) != cache.end(); }),
+          pairs.end());
+      for (auto& o : compiled_outputs) {
+        pairs.push_back({o, i});
+      }
+    }
+
+    // - Update outputs parents to point to compiled outputs
+    // - Update any overall graph outputs to be compiled outputs
+    for (int o = 0; o < old_outputs.size(); ++o) {
+      merge_one(compiled_outputs[o], old_outputs[o], parents_map);
+      if (auto it = output_map.find(old_outputs[o].id());
+          it != output_map.end()) {
+        it->second = compiled_outputs[o];
+      }
+    }
+  }
+
+  std::reverse(new_tape.begin(), new_tape.end());
+  tape = std::move(new_tape);
+
+  // Replace output with potentially compiled output
+  for (auto& o : outputs) {
+    o = output_map.at(o.id());
+  }
+}
+
+std::vector<array> compile_replace(
+    const std::vector<array>& tape,
+    const std::vector<array>& trace_inputs,
+    const std::vector<array>& trace_outputs,
+    const std::vector<array>& inputs,
+    bool shapeless) {
+  std::unordered_map<uintptr_t, array> trace_to_real;
+  for (int i = 0; i < inputs.size(); ++i) {
+    trace_to_real.insert({trace_inputs[i].id(), inputs[i]});
+  }
+
+  auto is_load = [](const Primitive& p) { return typeid(p) == typeid(Load); };
+
+  for (auto& a : tape) {
+    // Arrays in the tape without primitives are either:
+    // - inputs, which are already in the map
+    // - constants, which can be used directly
+    // - a load primitive which has no inputs and will become a constant
+    //   after the first eval
+    if (!a.has_primitive() || is_load(a.primitive())) {
+      trace_to_real.insert({a.id(), a});
+    } else {
+      // Find real inputs
+      std::vector<array> real_inputs;
+      for (auto& in : a.inputs()) {
+        real_inputs.push_back(trace_to_real.at(in.id()));
+      }
+      if (a.siblings().empty()) {
+        auto shape =
+            shapeless ? a.primitive().output_shapes(real_inputs)[0] : a.shape();
+        auto real_a = array(
+            std::move(shape),
+            a.dtype(),
+            a.primitive_ptr(),
+            std::move(real_inputs));
+        trace_to_real.insert({a.id(), std::move(real_a)});
+      } else {
+        // Ensure the order is correct for multi-output primitives
+        std::vector<Dtype> types;
+        auto trace_out = a.outputs();
+        for (auto& o : trace_out) {
+          types.push_back(o.dtype());
+        }
+        std::vector<Shape> shapes;
+        if (shapeless) {
+          shapes = a.primitive().output_shapes(real_inputs);
+        } else {
+          for (auto& o : trace_out) {
+            shapes.push_back(o.shape());
+          }
+        }
+        auto real_out = array::make_arrays(
+            std::move(shapes), types, a.primitive_ptr(), real_inputs);
+        for (int i = 0; i < trace_out.size(); ++i) {
+          trace_to_real.insert({trace_out[i].id(), std::move(real_out[i])});
+        }
+      }
+    }
+  }
+
+  std::vector<array> outputs;
+  for (auto& o : trace_outputs) {
+    outputs.push_back(trace_to_real.at(o.id()));
+  }
+  return outputs;
+}
+
+bool skip_compile() {
+  return compile_mode() == CompileMode::disabled ||
+      !(compile_available_for_device(default_device()));
+}
+
+ArrayFnWithExtra compile(
+    ArrayFnWithExtra fun,
+    std::uintptr_t fun_id,
+    bool shapeless /* = false */,
+    std::vector<uint64_t> constants /* = {} */) {
+  if (skip_compile()) {
+    return fun;
+  }
+  if (!fun) {
+    throw std::invalid_argument(
+        "[compile] Cannot compile a function without a target.");
+  }
+
+  return [fun = std::move(fun),
+          fun_id,
+          shapeless,
+          constants = std::move(constants)](const std::vector<array>& inputs) {
+    // If the inputs are tracers, trace the original graph
+    if (std::any_of(inputs.begin(), inputs.end(), [](auto& in) {
+          return in.is_tracer();
+        })) {
+      return fun(inputs);
+    }
+
+    // Find a cache entry with the correct inputs
+    auto& entry = compiler_cache().find(fun_id, inputs, shapeless, constants);
+
+    // No matching cache entry existed, so compile
+    if (entry.empty) {
+      // Mark the entry as not empty since we are about to fill it
+      entry.empty = false;
+      // Set the constants
+      entry.constants = std::move(constants);
+      // Trace to build the graph
+      std::tie(entry.inputs, entry.outputs, entry.extra) =
+          compile_trace(fun, inputs, shapeless);
+
+      // DFS the graph and get a tape, and a map of array id to (parent,
+      // position in parent inputs)
+      std::unordered_map<uintptr_t, std::vector<std::pair<array, int>>>
+          parents_map;
+      std::tie(entry.tape, parents_map) =
+          compile_dfs(entry.inputs, entry.outputs, inputs);
+
+      // Simplify the tape
+      if (compile_mode() != CompileMode::no_simplify) {
+        compile_simplify(
+            entry.tape, parents_map, entry.outputs, /* passes */ 3);
+      }
+
+      // Kernel fusion to generate Compiled primitives. The tape and
+      // new outputs must be updated accordingly
+      if (compile_mode() != CompileMode::no_fuse) {
+        compile_fuse(entry.tape, parents_map, entry.inputs, entry.outputs);
+      }
+    }
+
+    // At this point we must have a tape, now replace the placeholders
+    // with real arrays that can be evaluated
+    return ArraysAndExtra{
+        compile_replace(
+            entry.tape, entry.inputs, entry.outputs, inputs, shapeless),
+        entry.extra};
+  };
+}
+
+std::function<std::vector<array>(const std::vector<array>&)> compile(
+    std::function<std::vector<array>(const std::vector<array>&)> fun,
+    std::uintptr_t fun_id,
+    bool shapeless /* = false */,
+    std::vector<uint64_t> constants /* = {} */) {
+  if (skip_compile()) {
+    return fun;
+  }
+  if (!fun) {
+    throw std::invalid_argument(
+        "[compile] Cannot compile a function without a target.");
+  }
+
+  ArrayFnWithExtra fun_with_extra =
+      [fun = std::move(fun)](const std::vector<array>& inputs) {
+        return ArraysAndExtra{fun(inputs), nullptr};
+      };
+
+  auto compiled_fun = compile(
+      std::move(fun_with_extra), fun_id, shapeless, std::move(constants));
+
+  return [compiled_fun =
+              std::move(compiled_fun)](const std::vector<array>& inputs) {
+    return compiled_fun(inputs).first;
+  };
+}
+
+void compile_erase(std::uintptr_t fun_id) {
+  detail::compiler_cache().erase(fun_id);
+}
+
+void compile_clear_cache() {
+  detail::compiler_cache().clear();
+}
+
+} // namespace detail
+
+std::function<std::vector<array>(const std::vector<array>&)> compile(
+    std::function<std::vector<array>(const std::vector<array>&)> fun,
+    bool shapeless /* false */) {
+  if (detail::skip_compile()) {
+    return fun;
+  }
+  auto fun_id = detail::get_function_address(fun);
+  if (fun_id) {
+    // If the function has an addressable target then no need to manage it's
+    // lifetime
+    return detail::compile(std::move(fun), fun_id, shapeless);
+  } else {
+    auto pfun = std::shared_ptr<
+        std::function<std::vector<array>(const std::vector<array>&)>>(
+        new std::function<std::vector<array>(const std::vector<array>&)>{fun},
+        [](auto* p) {
+          detail::compile_erase(reinterpret_cast<std::uintptr_t>(p));
+          delete p;
+        });
+    fun_id = reinterpret_cast<std::uintptr_t>(pfun.get());
+    return detail::compile(
+        [pfun = std::move(pfun)](const auto& inputs) {
+          return (*pfun)(inputs);
+        },
+        fun_id,
+        shapeless);
+  }
+}
+
+std::function<std::vector<array>(const std::vector<array>&)> compile(
+    std::vector<array> (*fun)(const std::vector<array>&),
+    bool shapeless /* = false */) {
+  if (detail::skip_compile()) {
+    return fun;
+  }
+  return detail::compile(fun, reinterpret_cast<std::uintptr_t>(fun), shapeless);
+}
+
+void disable_compile() {
+  detail::compile_mode() = CompileMode::disabled;
+}
+
+void enable_compile() {
+  detail::compile_mode() = CompileMode::enabled;
+}
+
+void set_compile_mode(CompileMode mode) {
+  detail::compile_mode() = mode;
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/compile.h b/ml-stable-diffusion/mlx/mlx/compile.h
new file mode 100644
index 0000000000000000000000000000000000000000..a076cfbca284af2e0a6fd5fae170f85208bb95bf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/compile.h
@@ -0,0 +1,44 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+enum class CompileMode { disabled, no_simplify, no_fuse, enabled };
+
+/** Compile takes a function and returns a compiled function. */
+std::function<std::vector<array>(const std::vector<array>&)> compile(
+    std::function<std::vector<array>(const std::vector<array>&)> fun,
+    bool shapeless = false);
+
+std::function<std::vector<array>(const std::vector<array>&)> compile(
+    std::vector<array> (*fun)(const std::vector<array>&),
+    bool shapeless = false);
+
+// Convert capture-less lambdas to function pointers.
+template <
+    typename F,
+    typename = std::enable_if_t<
+        std::is_convertible_v<F, decltype(+std::declval<F>())>>>
+std::function<std::vector<array>(const std::vector<array>&)> compile(
+    F&& f,
+    bool shapeless = false) {
+  return compile(+f, shapeless);
+}
+
+/** Globally disable compilation.
+ * Setting the environment variable ``MLX_DISABLE_COMPILE`` can also
+ * be used to disable compilation.
+ */
+void disable_compile();
+
+/** Globally enable compilation.
+ * This will override the environment variable ``MLX_DISABLE_COMPILE``.
+ */
+void enable_compile();
+
+/** Set the compiler mode to the given value. */
+void set_compile_mode(CompileMode mode);
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/compile_impl.h b/ml-stable-diffusion/mlx/mlx/compile_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b48c88aaf97c2104483ca99dd372d4cfb4405c4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/compile_impl.h
@@ -0,0 +1,69 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <unordered_map>
+
+#include "mlx/array.h"
+
+namespace mlx::core::detail {
+
+using ArraysAndExtra = std::pair<std::vector<array>, std::shared_ptr<void>>;
+using ArrayFnWithExtra =
+    std::function<ArraysAndExtra(const std::vector<array>&)>;
+
+// This is not part of the general C++ API as calling with a bad id is a bad
+// idea.
+std::function<std::vector<array>(const std::vector<array>&)> compile(
+    std::function<std::vector<array>(const std::vector<array>&)> fun,
+    std::uintptr_t fun_id,
+    bool shapeless = false,
+    std::vector<uint64_t> constants = {});
+
+ArrayFnWithExtra compile(
+    ArrayFnWithExtra fun,
+    std::uintptr_t fun_id,
+    bool shapeless,
+    std::vector<uint64_t> constants);
+
+// Erase cached compile functions
+void compile_erase(std::uintptr_t fun_id);
+
+// Clear the compiler cache causing a recompilation of all compiled functions
+// when called again.
+void compile_clear_cache();
+
+bool compile_available_for_device(const Device& device);
+
+std::tuple<std::vector<array>, std::vector<array>, std::shared_ptr<void>>
+compile_trace(
+    const ArrayFnWithExtra& fun,
+    const std::vector<array>& inputs,
+    bool shapeless);
+
+using ParentsMap =
+    std::unordered_map<std::uintptr_t, std::vector<std::pair<array, int>>>;
+
+// Traverses the graph to build a tape and a map of array ids to their parents
+std::pair<std::vector<array>, ParentsMap> compile_dfs(
+    const std::vector<array>& inputs,
+    const std::vector<array>& outputs,
+    const std::vector<array>& original_inputs);
+
+// Simplify the tape.
+void compile_simplify(
+    std::vector<array>& tape,
+    ParentsMap& parents_map,
+    std::vector<array>& outputs,
+    int passes);
+
+std::vector<array> compile_replace(
+    const std::vector<array>& tape,
+    const std::vector<array>& trace_inputs,
+    const std::vector<array>& trace_outputs,
+    const std::vector<array>& inputs,
+    bool shapeless);
+
+void compile_validate_shapeless(const std::vector<array>& tape);
+
+} // namespace mlx::core::detail
diff --git a/ml-stable-diffusion/mlx/mlx/device.cpp b/ml-stable-diffusion/mlx/mlx/device.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ec17a509a9ba85cd30d72934e764bd28cb26d03b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/device.cpp
@@ -0,0 +1,47 @@
+// Copyright © 2023 Apple Inc.
+
+#include <stdexcept>
+
+#include "mlx/backend/cpu/available.h"
+#include "mlx/backend/gpu/available.h"
+#include "mlx/device.h"
+
+namespace mlx::core {
+
+Device& mutable_default_device() {
+  static Device default_device{gpu::is_available() ? Device::gpu : Device::cpu};
+  return default_device;
+}
+
+const Device& default_device() {
+  return mutable_default_device();
+}
+
+void set_default_device(const Device& d) {
+  if (!gpu::is_available() && d == Device::gpu) {
+    throw std::invalid_argument(
+        "[set_default_device] Cannot set gpu device without gpu backend.");
+  }
+  mutable_default_device() = d;
+}
+
+bool operator==(const Device& lhs, const Device& rhs) {
+  return lhs.type == rhs.type && lhs.index == rhs.index;
+}
+
+bool operator!=(const Device& lhs, const Device& rhs) {
+  return !(lhs == rhs);
+}
+
+bool is_available(const Device& d) {
+  switch (d.type) {
+    case Device::cpu:
+      return cpu::is_available();
+    case Device::gpu:
+      return gpu::is_available();
+  }
+  // appease compiler
+  return false;
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/device.h b/ml-stable-diffusion/mlx/mlx/device.h
new file mode 100644
index 0000000000000000000000000000000000000000..80c624c1c9b01383c314373272314c83d01dcde4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/device.h
@@ -0,0 +1,31 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+namespace mlx::core {
+
+struct Device {
+  enum class DeviceType {
+    cpu,
+    gpu,
+  };
+
+  static constexpr DeviceType cpu = DeviceType::cpu;
+  static constexpr DeviceType gpu = DeviceType::gpu;
+
+  Device(DeviceType type, int index = 0) : type(type), index(index) {}
+
+  DeviceType type;
+  int index;
+};
+
+const Device& default_device();
+
+void set_default_device(const Device& d);
+
+bool operator==(const Device& lhs, const Device& rhs);
+bool operator!=(const Device& lhs, const Device& rhs);
+
+bool is_available(const Device& d);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/distributed/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b7762f6a746072dc910a275eafabc054ef9a226e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/CMakeLists.txt
@@ -0,0 +1,9 @@
+target_sources(
+  mlx
+  PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/primitives.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/ops.cpp
+          ${CMAKE_CURRENT_SOURCE_DIR}/distributed.cpp)
+
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/mpi)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ring)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/nccl)
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp b/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d71ebb9b12d0330153049e6553975dbdec6ea718
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/distributed.cpp
@@ -0,0 +1,158 @@
+// Copyright © 2024 Apple Inc.
+
+#include <unordered_map>
+
+#include "mlx/backend/cuda/cuda.h"
+#include "mlx/distributed/distributed.h"
+#include "mlx/distributed/distributed_impl.h"
+#include "mlx/distributed/mpi/mpi.h"
+#include "mlx/distributed/nccl/nccl.h"
+#include "mlx/distributed/ring/ring.h"
+
+namespace mlx::core::distributed {
+
+namespace detail {
+
+Stream communication_stream(Group group, StreamOrDevice s /* = {} */) {
+  return group.raw_group()->communication_stream(s);
+}
+
+void all_sum(Group group, const array& input, array& output, Stream stream) {
+  group.raw_group()->all_sum(input, output, stream);
+}
+
+void all_max(Group group, const array& input, array& output, Stream stream) {
+  group.raw_group()->all_max(input, output, stream);
+}
+
+void all_min(Group group, const array& input, array& output, Stream stream) {
+  group.raw_group()->all_min(input, output, stream);
+}
+
+void all_gather(Group group, const array& input, array& output, Stream stream) {
+  group.raw_group()->all_gather(input, output, stream);
+}
+
+void send(Group group, const array& input, int dst, Stream stream) {
+  group.raw_group()->send(input, dst, stream);
+}
+
+void recv(Group group, array& out, int src, Stream stream) {
+  group.raw_group()->recv(out, src, stream);
+}
+
+class EmptyGroup : public GroupImpl {
+ public:
+  Stream communication_stream(StreamOrDevice s) override {
+    return to_stream(s);
+  }
+
+  int rank() override {
+    return 0;
+  }
+
+  int size() override {
+    return 1;
+  }
+
+  std::shared_ptr<GroupImpl> split(int color, int key = -1) override {
+    throw std::runtime_error("Cannot split the distributed group further.");
+  }
+
+  void all_sum(const array&, array&, Stream) override {
+    throw std::runtime_error(
+        "Communication not implemented in an empty distributed group.");
+  }
+  void all_gather(const array&, array&, Stream) override {
+    throw std::runtime_error(
+        "Communication not implemented in an empty distributed group.");
+  }
+  void send(const array&, int, Stream) override {
+    throw std::runtime_error(
+        "Communication not implemented in an empty distributed group.");
+  }
+  void recv(array&, int, Stream) override {
+    throw std::runtime_error(
+        "Communication not implemented in an empty distributed group.");
+  }
+
+  void all_max(const array&, array&, Stream) override {
+    throw std::runtime_error(
+        "Communication not implemented in an empty distributed group.");
+  }
+
+  void all_min(const array&, array&, Stream) override {
+    throw std::runtime_error(
+        "Communication not implemented in an empty distributed group.");
+  }
+};
+
+} // namespace detail
+
+bool is_available() {
+  return mpi::is_available() || ring::is_available() || nccl::is_available();
+}
+
+int Group::rank() const {
+  return group_->rank();
+}
+
+int Group::size() const {
+  return group_->size();
+}
+
+Group Group::split(int color, int key /* = -1 */) const {
+  return Group(group_->split(color, key));
+}
+
+Group init(bool strict /* = false */, const std::string& bk /* = "any" */) {
+  static std::unordered_map<std::string, std::shared_ptr<detail::GroupImpl>>
+      backends;
+
+  // Already initialized so return the group.
+  if (auto g = backends.find(bk); g != backends.end()) {
+    return Group(g->second);
+  }
+
+  // Create the requested communication group
+  std::shared_ptr<detail::GroupImpl> group{nullptr};
+  std::string bk_ = bk;
+  if (bk == "mpi") {
+    group = mpi::init(strict);
+  } else if (bk == "ring") {
+    group = ring::init(strict);
+  } else if (bk == "nccl") {
+    group = nccl::init(strict);
+  } else if (bk == "any") {
+    if (mlx::core::cu::is_available()) {
+      group = nccl::init(false);
+      bk_ = "nccl";
+    }
+    if (group == nullptr) {
+      group = ring::init(false);
+      bk_ = "ring";
+    }
+    if (group == nullptr) {
+      group = mpi::init(false);
+      bk_ = "mpi";
+    }
+    if (group == nullptr && strict) {
+      throw std::runtime_error("[distributed] Couldn't initialize any backend");
+    }
+  } else {
+    std::ostringstream msg;
+    msg << "[distributed] The only valid values for backend are 'any', 'mpi' "
+        << "and 'ring' but '" << bk << "' was provided.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (group == nullptr) {
+    group = std::make_shared<detail::EmptyGroup>();
+  } else {
+    backends.insert({"any", group});
+  }
+  backends.insert({std::move(bk_), group});
+  return Group(group);
+}
+
+} // namespace mlx::core::distributed
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/distributed.h b/ml-stable-diffusion/mlx/mlx/distributed/distributed.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa5c42a1f1d3559942ade0c215a7af017320b08e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/distributed.h
@@ -0,0 +1,59 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include <memory>
+
+#include "mlx/array.h"
+#include "mlx/utils.h"
+
+namespace mlx::core::distributed {
+
+// Forward declaration of the base group implementation.
+namespace detail {
+class GroupImpl;
+};
+
+/* Check if a communication backend is available */
+bool is_available();
+
+/**
+ * A distributed::Group represents a group of independent mlx processes that
+ * can communicate. We must also be able to create sub-groups from a group in
+ * order to define more granular communication.
+ */
+struct Group {
+  Group(std::shared_ptr<detail::GroupImpl> group) : group_(std::move(group)) {}
+
+  int rank() const;
+  int size() const;
+
+  /**
+   * Split the group according to the provided color. Namely processes that use
+   * the same color will go to the same group.
+   *
+   * The key defines the rank of the processes in the new group. The smaller
+   * the key the smaller the rank. If the provided key is negative, then the
+   * rank in the current group is used.
+   */
+  Group split(int color, int key = -1) const;
+
+  const std::shared_ptr<detail::GroupImpl>& raw_group() const {
+    return group_;
+  }
+
+ private:
+  std::shared_ptr<detail::GroupImpl> group_{nullptr};
+};
+
+/**
+ * Initialize the distributed backend and return the group containing all
+ * discoverable processes.
+ *
+ * If strict is true then throw an error if we couldn't initialize the
+ * distributed subsystem. Otherwise simply return a singleton group which will
+ * render communication operations as no-op.
+ */
+Group init(bool strict = false, const std::string& bk = "any");
+
+} // namespace mlx::core::distributed
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h b/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..c90b0ba47bc7cfe5dcf50b9c9b51305bebe760ee
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/distributed_impl.h
@@ -0,0 +1,54 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/distributed/distributed.h"
+
+namespace mlx::core::distributed::detail {
+
+/**
+ * Abstract base class of a distributed group implementation.
+ */
+class GroupImpl {
+ public:
+  virtual ~GroupImpl() {}
+
+  // Choose the stream this communication group can operate on
+  virtual Stream communication_stream(StreamOrDevice s = {}) = 0;
+
+  // Group operations
+  virtual int rank() = 0;
+  virtual int size() = 0;
+  virtual std::shared_ptr<GroupImpl> split(int color, int key = -1) = 0;
+
+  // Actual communication operations
+  virtual void all_sum(const array& input, array& output, Stream stream) = 0;
+  virtual void all_gather(const array& input, array& output, Stream stream) = 0;
+  virtual void send(const array& input, int dst, Stream stream) = 0;
+  virtual void recv(array& out, int src, Stream stream) = 0;
+  virtual void all_max(const array& input, array& output, Stream stream) = 0;
+  virtual void all_min(const array& input, array& output, Stream stream) = 0;
+};
+
+/* Define the MLX stream that the communication should happen in. */
+Stream communication_stream(Group group, StreamOrDevice s = {});
+
+/* Perform an all reduce sum operation */
+void all_sum(Group group, const array& input, array& output, Stream stream);
+
+/* Perform an all gather operation */
+void all_gather(Group group, const array& input, array& output, Stream stream);
+
+/** Send an array to the dst rank */
+void send(Group group, const array& input, int dst, Stream stream);
+
+/** Recv an array from the src rank */
+void recv(Group group, array& out, int src, Stream stream);
+
+/** Max reduction */
+void all_max(Group group, const array& input, array& output, Stream stream);
+
+/** Min reduction */
+void all_min(Group group, const array& input, array& output, Stream stream);
+
+} // namespace mlx::core::distributed::detail
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/mpi/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/distributed/mpi/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..842f70b55a91dfcf8eb550251f14ac0a4751dc22
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/mpi/CMakeLists.txt
@@ -0,0 +1,5 @@
+if(MLX_BUILD_CPU)
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/mpi.cpp)
+else()
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/no_mpi.cpp)
+endif()
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp b/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..494fb02dccdd7c18e768cf13a3b84c4f216eda5e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.cpp
@@ -0,0 +1,490 @@
+// Copyright © 2024 Apple Inc.
+
+#include <dlfcn.h>
+#include <iostream>
+
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/distributed/distributed.h"
+#include "mlx/distributed/distributed_impl.h"
+#include "mlx/distributed/mpi/mpi.h"
+#include "mlx/distributed/mpi/mpi_declarations.h"
+
+#define LOAD_SYMBOL(symbol, variable)                              \
+  {                                                                \
+    variable = (decltype(variable))dlsym(libmpi_handle_, #symbol); \
+    char* error = dlerror();                                       \
+    if (error != nullptr) {                                        \
+      libmpi_handle_ = nullptr;                                    \
+      return;                                                      \
+    }                                                              \
+  }
+
+#ifdef __APPLE__
+static constexpr const char* libmpi_name = "libmpi.dylib";
+#else
+static constexpr const char* libmpi_name = "libmpi.so";
+#endif
+
+namespace mlx::core::distributed::mpi {
+
+using GroupImpl = mlx::core::distributed::detail::GroupImpl;
+
+namespace {
+
+template <typename T>
+void simple_sum(
+    void* input,
+    void* accumulator,
+    int* len,
+    MPI_Datatype* datatype) {
+  T* in = (T*)input;
+  T* acc = (T*)accumulator;
+  int N = *len;
+
+  while (N-- > 0) {
+    *acc += *in;
+    acc++;
+    in++;
+  }
+}
+template void simple_sum<float16_t>(void*, void*, int*, MPI_Datatype*);
+template void simple_sum<bfloat16_t>(void*, void*, int*, MPI_Datatype*);
+
+template <typename T>
+void simple_max(
+    void* input,
+    void* accumulator,
+    int* len,
+    MPI_Datatype* datatype) {
+  T* in = (T*)input;
+  T* acc = (T*)accumulator;
+  int N = *len;
+
+  while (N-- > 0) {
+    *acc = std::max(*acc, *in);
+    acc++;
+    in++;
+  }
+}
+template void simple_max<float16_t>(void*, void*, int*, MPI_Datatype*);
+template void simple_max<bfloat16_t>(void*, void*, int*, MPI_Datatype*);
+template void simple_max<complex64_t>(void*, void*, int*, MPI_Datatype*);
+
+template <typename T>
+void simple_min(
+    void* input,
+    void* accumulator,
+    int* len,
+    MPI_Datatype* datatype) {
+  T* in = (T*)input;
+  T* acc = (T*)accumulator;
+  int N = *len;
+
+  while (N-- > 0) {
+    *acc = std::min(*acc, *in);
+    acc++;
+    in++;
+  }
+}
+template void simple_min<float16_t>(void*, void*, int*, MPI_Datatype*);
+template void simple_min<bfloat16_t>(void*, void*, int*, MPI_Datatype*);
+template void simple_min<complex64_t>(void*, void*, int*, MPI_Datatype*);
+
+struct MPIWrapper {
+  MPIWrapper() {
+    initialized_ = false;
+
+    libmpi_handle_ = dlopen(libmpi_name, RTLD_NOW | RTLD_GLOBAL);
+    if (libmpi_handle_ == nullptr) {
+      return;
+    }
+
+    // Check library version and warn if it isn't Open MPI
+    int (*get_version)(char*, int*);
+    LOAD_SYMBOL(MPI_Get_library_version, get_version);
+    char version_ptr[MPI_MAX_LIBRARY_VERSION_STRING];
+    int version_length = 0;
+    get_version(version_ptr, &version_length);
+    std::string_view version(version_ptr, version_length);
+    if (version.find("Open MPI") == std::string::npos) {
+      std::cerr << "[mpi] MPI found but it does not appear to be Open MPI."
+                << "MLX requires Open MPI but this is " << version << std::endl;
+      libmpi_handle_ = nullptr;
+      return;
+    }
+
+    // API
+    LOAD_SYMBOL(MPI_Init, init);
+    LOAD_SYMBOL(MPI_Finalize, finalize);
+    LOAD_SYMBOL(MPI_Comm_rank, rank);
+    LOAD_SYMBOL(MPI_Comm_size, size);
+    LOAD_SYMBOL(MPI_Comm_split, comm_split);
+    LOAD_SYMBOL(MPI_Comm_free, comm_free);
+    LOAD_SYMBOL(MPI_Allreduce, all_reduce);
+    LOAD_SYMBOL(MPI_Allgather, all_gather);
+    LOAD_SYMBOL(MPI_Send, send);
+    LOAD_SYMBOL(MPI_Recv, recv);
+    LOAD_SYMBOL(MPI_Type_contiguous, mpi_type_contiguous);
+    LOAD_SYMBOL(MPI_Type_commit, mpi_type_commit);
+    LOAD_SYMBOL(MPI_Op_create, mpi_op_create);
+
+    // Objects
+    LOAD_SYMBOL(ompi_mpi_comm_world, comm_world_);
+
+    // Ops
+    LOAD_SYMBOL(ompi_mpi_op_sum, op_sum_);
+    LOAD_SYMBOL(ompi_mpi_op_max, op_max_);
+    LOAD_SYMBOL(ompi_mpi_op_min, op_min_);
+
+    // Datatypes
+    LOAD_SYMBOL(ompi_mpi_c_bool, mpi_bool_);
+    LOAD_SYMBOL(ompi_mpi_int8_t, mpi_int8_);
+    LOAD_SYMBOL(ompi_mpi_uint8_t, mpi_uint8_);
+    LOAD_SYMBOL(ompi_mpi_int16_t, mpi_int16_);
+    LOAD_SYMBOL(ompi_mpi_uint16_t, mpi_uint16_);
+    LOAD_SYMBOL(ompi_mpi_int32_t, mpi_int32_);
+    LOAD_SYMBOL(ompi_mpi_uint32_t, mpi_uint32_);
+    LOAD_SYMBOL(ompi_mpi_int64_t, mpi_int64_);
+    LOAD_SYMBOL(ompi_mpi_uint64_t, mpi_uint64_);
+    LOAD_SYMBOL(ompi_mpi_float, mpi_float_);
+    LOAD_SYMBOL(ompi_mpi_double, mpi_double_);
+    LOAD_SYMBOL(ompi_mpi_c_complex, mpi_complex_);
+  }
+
+  bool is_available() {
+    return libmpi_handle_ != nullptr;
+  }
+
+  bool init_safe() {
+    if (!is_available()) {
+      return false;
+    }
+    bool success = init(nullptr, nullptr) == MPI_SUCCESS;
+
+    // Initialize custom types and ops
+    if (success && !initialized_) {
+      // Custom float16 dtypes
+      mpi_type_contiguous(2, mpi_uint8_, &mpi_float16_);
+      mpi_type_commit(&mpi_float16_);
+      mpi_type_contiguous(2, mpi_uint8_, &mpi_bfloat16_);
+      mpi_type_commit(&mpi_bfloat16_);
+
+      // Custom reduction ops
+      mpi_op_create(&simple_sum<float16_t>, 1, &op_sum_f16_);
+      mpi_op_create(&simple_sum<bfloat16_t>, 1, &op_sum_bf16_);
+      mpi_op_create(&simple_max<float16_t>, 1, &op_max_f16_);
+      mpi_op_create(&simple_max<bfloat16_t>, 1, &op_max_bf16_);
+      mpi_op_create(&simple_max<complex64_t>, 1, &op_max_c64_);
+      mpi_op_create(&simple_min<float16_t>, 1, &op_min_f16_);
+      mpi_op_create(&simple_min<bfloat16_t>, 1, &op_min_bf16_);
+      mpi_op_create(&simple_min<complex64_t>, 1, &op_min_c64_);
+
+      initialized_ = true;
+    }
+
+    return success;
+  }
+
+  void finalize_safe() {
+    if (is_available()) {
+      finalize();
+    }
+  }
+
+  MPI_Comm world() {
+    return comm_world_;
+  }
+
+  MPI_Datatype datatype(const array& arr) {
+    switch (arr.dtype()) {
+      case bool_:
+        return mpi_bool_;
+      case int8:
+        return mpi_int8_;
+      case uint8:
+        return mpi_uint8_;
+      case int16:
+        return mpi_int16_;
+      case uint16:
+        return mpi_uint16_;
+      case int32:
+        return mpi_int32_;
+      case uint32:
+        return mpi_uint32_;
+      case int64:
+        return mpi_int64_;
+      case uint64:
+        return mpi_uint64_;
+      case float32:
+        return mpi_float_;
+      case complex64:
+        return mpi_complex_;
+      case float16:
+        return mpi_float16_;
+      case bfloat16:
+        return mpi_bfloat16_;
+      case float64:
+        return mpi_double_;
+      default:
+        throw std::runtime_error("Invalid type");
+    }
+  }
+
+  MPI_Op op_sum(const array& arr) {
+    switch (arr.dtype()) {
+      case float16:
+        return op_sum_f16_;
+      case bfloat16:
+        return op_sum_bf16_;
+      default:
+        return op_sum_;
+    }
+  }
+
+  MPI_Op op_max(const array& arr) {
+    switch (arr.dtype()) {
+      case float16:
+        return op_max_f16_;
+      case bfloat16:
+        return op_max_bf16_;
+      case complex64:
+        return op_max_c64_;
+      default:
+        return op_max_;
+    }
+  }
+
+  MPI_Op op_min(const array& arr) {
+    switch (arr.dtype()) {
+      case float16:
+        return op_min_f16_;
+      case bfloat16:
+        return op_min_bf16_;
+      case complex64:
+        return op_min_c64_;
+      default:
+        return op_min_;
+    }
+  }
+
+  void* libmpi_handle_;
+
+  // API
+  int (*init)(int*, char***);
+  int (*finalize)();
+  int (*rank)(MPI_Comm, int*);
+  int (*size)(MPI_Comm, int*);
+  int (*all_reduce)(const void*, void*, int, MPI_Datatype, MPI_Op, MPI_Comm);
+  int (*all_gather)(
+      const void*,
+      int,
+      MPI_Datatype,
+      void*,
+      int,
+      MPI_Datatype,
+      MPI_Comm);
+  int (*comm_split)(MPI_Comm, int, int, MPI_Comm*);
+  int (*comm_free)(MPI_Comm*);
+  int (*send)(const void*, int, MPI_Datatype, int, int, MPI_Comm);
+  int (*recv)(void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Status*);
+
+  // Objects
+  MPI_Comm comm_world_;
+
+  // Ops
+  MPI_Op op_sum_;
+  MPI_Op op_sum_f16_;
+  MPI_Op op_sum_bf16_;
+  MPI_Op op_max_;
+  MPI_Op op_max_f16_;
+  MPI_Op op_max_bf16_;
+  MPI_Op op_max_c64_;
+  MPI_Op op_min_;
+  MPI_Op op_min_f16_;
+  MPI_Op op_min_bf16_;
+  MPI_Op op_min_c64_;
+
+  // Datatypes
+  MPI_Datatype mpi_bool_;
+  MPI_Datatype mpi_int8_;
+  MPI_Datatype mpi_uint8_;
+  MPI_Datatype mpi_int16_;
+  MPI_Datatype mpi_uint16_;
+  MPI_Datatype mpi_int32_;
+  MPI_Datatype mpi_uint32_;
+  MPI_Datatype mpi_int64_;
+  MPI_Datatype mpi_uint64_;
+  MPI_Datatype mpi_float_;
+  MPI_Datatype mpi_double_;
+  MPI_Datatype mpi_complex_;
+  MPI_Datatype mpi_float16_;
+  MPI_Datatype mpi_bfloat16_;
+
+ private:
+  bool initialized_;
+
+  // Private API
+  int (*mpi_type_contiguous)(int, MPI_Datatype, MPI_Datatype*);
+  int (*mpi_type_commit)(MPI_Datatype*);
+  int (*mpi_op_create)(MPI_User_function*, int, MPI_Op*);
+};
+
+MPIWrapper& mpi() {
+  static MPIWrapper wrapper;
+  return wrapper;
+}
+
+} // namespace
+
+class MPIGroup : public GroupImpl {
+ public:
+  MPIGroup(MPI_Comm comm, bool global)
+      : comm_(comm), global_(global), rank_(-1), size_(-1) {}
+
+  virtual ~MPIGroup() {
+    if (global_) {
+      mpi().finalize_safe();
+    } else {
+      mpi().comm_free(&comm_);
+    }
+  }
+
+  Stream communication_stream(StreamOrDevice s) override {
+    return to_stream(s, Device::cpu);
+  }
+
+  int rank() override {
+    if (rank_ < 0) {
+      mpi().rank(comm_, &rank_);
+    }
+    return rank_;
+  }
+
+  int size() override {
+    if (size_ < 0) {
+      mpi().size(comm_, &size_);
+    }
+    return size_;
+  }
+
+  std::shared_ptr<GroupImpl> split(int color, int key = -1) override {
+    key = (key < 0) ? rank() : key;
+
+    MPI_Comm new_comm;
+    int result = mpi().comm_split(comm_, color, key, &new_comm);
+    if (result != MPI_SUCCESS) {
+      throw std::runtime_error("MPI could not split this group");
+    }
+
+    return std::make_shared<MPIGroup>(new_comm, false);
+  }
+
+  void all_sum(const array& input, array& output, Stream stream) override {
+    auto& encoder = cpu::get_command_encoder(stream);
+    encoder.set_input_array(input);
+    encoder.set_output_array(output);
+    encoder.dispatch(
+        mpi().all_reduce,
+        (input.data<void>() == output.data<void>()) ? MPI_IN_PLACE
+                                                    : input.data<void>(),
+        output.data<void>(),
+        input.size(),
+        mpi().datatype(input),
+        mpi().op_sum(input),
+        comm_);
+  }
+
+  void all_max(const array& input, array& output, Stream stream) override {
+    auto& encoder = cpu::get_command_encoder(stream);
+    encoder.set_input_array(input);
+    encoder.set_output_array(output);
+    encoder.dispatch(
+        mpi().all_reduce,
+        (input.data<void>() == output.data<void>()) ? MPI_IN_PLACE
+                                                    : input.data<void>(),
+        output.data<void>(),
+        input.size(),
+        mpi().datatype(input),
+        mpi().op_max(input),
+        comm_);
+  }
+
+  void all_min(const array& input, array& output, Stream stream) override {
+    auto& encoder = cpu::get_command_encoder(stream);
+    encoder.set_input_array(input);
+    encoder.set_output_array(output);
+    encoder.dispatch(
+        mpi().all_reduce,
+        (input.data<void>() == output.data<void>()) ? MPI_IN_PLACE
+                                                    : input.data<void>(),
+        output.data<void>(),
+        input.size(),
+        mpi().datatype(input),
+        mpi().op_min(input),
+        comm_);
+  }
+
+  void all_gather(const array& input, array& output, Stream stream) override {
+    auto& encoder = cpu::get_command_encoder(stream);
+    encoder.set_input_array(input);
+    encoder.set_output_array(output);
+    encoder.dispatch(
+        mpi().all_gather,
+        input.data<void>(),
+        input.size(),
+        mpi().datatype(input),
+        output.data<void>(),
+        input.size(),
+        mpi().datatype(output),
+        comm_);
+  }
+
+  void send(const array& input, int dst, Stream stream) override {
+    auto& encoder = cpu::get_command_encoder(stream);
+    encoder.set_input_array(input);
+    encoder.dispatch(
+        mpi().send,
+        input.data<void>(),
+        input.size(),
+        mpi().datatype(input),
+        dst,
+        0,
+        comm_);
+  }
+
+  void recv(array& out, int src, Stream stream) override {
+    auto& encoder = cpu::get_command_encoder(stream);
+    encoder.set_output_array(out);
+    encoder.dispatch([out_ptr = out.data<void>(),
+                      out_size = out.size(),
+                      out_type = mpi().datatype(out),
+                      src,
+                      comm = comm_]() {
+      MPI_Status status;
+      mpi().recv(out_ptr, out_size, out_type, src, MPI_ANY_TAG, comm, &status);
+    });
+  }
+
+ private:
+  MPI_Comm comm_;
+  bool global_;
+  int rank_;
+  int size_;
+};
+
+bool is_available() {
+  return mpi().is_available();
+}
+
+std::shared_ptr<GroupImpl> init(bool strict /* = false */) {
+  if (!mpi().init_safe()) {
+    if (strict) {
+      throw std::runtime_error("Cannot initialize MPI");
+    }
+    return nullptr;
+  }
+
+  return std::make_shared<MPIGroup>(mpi().world(), true);
+}
+
+} // namespace mlx::core::distributed::mpi
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.h b/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd11a4785f0df6a22806c2fc856e4dde1039264a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi.h
@@ -0,0 +1,12 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/distributed/distributed.h"
+
+namespace mlx::core::distributed::mpi {
+
+using GroupImpl = mlx::core::distributed::detail::GroupImpl;
+
+bool is_available();
+std::shared_ptr<GroupImpl> init(bool strict = false);
+
+} // namespace mlx::core::distributed::mpi
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi_declarations.h b/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi_declarations.h
new file mode 100644
index 0000000000000000000000000000000000000000..99c1a9cbbdaba3317b0cd3e983581ca55a699334
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/mpi/mpi_declarations.h
@@ -0,0 +1,28 @@
+// Copyright © 2024 Apple Inc.
+
+// Constants
+
+#define MPI_SUCCESS 0
+#define MPI_ANY_SOURCE -1
+#define MPI_ANY_TAG -1
+#define MPI_IN_PLACE ((void*)1)
+#define MPI_MAX_LIBRARY_VERSION_STRING 256
+
+// Define all the types that we use so that we don't include <mpi.h> which
+// causes linker errors on some platforms.
+//
+// NOTE: We define everything for openmpi.
+
+typedef void* MPI_Comm;
+typedef void* MPI_Datatype;
+typedef void* MPI_Op;
+
+typedef void(MPI_User_function)(void*, void*, int*, MPI_Datatype*);
+
+typedef struct ompi_status_public_t {
+  int MPI_SOURCE;
+  int MPI_TAG;
+  int MPI_ERROR;
+  int _cancelled;
+  size_t _ucount;
+} MPI_Status;
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/mpi/no_mpi.cpp b/ml-stable-diffusion/mlx/mlx/distributed/mpi/no_mpi.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4a7fc66539c6286240602531559e7aacf020982a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/mpi/no_mpi.cpp
@@ -0,0 +1,20 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/distributed/mpi/mpi.h"
+
+namespace mlx::core::distributed::mpi {
+
+using GroupImpl = mlx::core::distributed::detail::GroupImpl;
+
+bool is_available() {
+  return false;
+}
+
+std::shared_ptr<GroupImpl> init(bool strict /* = false */) {
+  if (strict) {
+    throw std::runtime_error("Cannot initialize MPI");
+  }
+  return nullptr;
+}
+
+} // namespace mlx::core::distributed::mpi
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/nccl/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/distributed/nccl/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4c59c56e2e2b5b326c20165524d55195e035b185
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/nccl/CMakeLists.txt
@@ -0,0 +1,26 @@
+if(MLX_BUILD_CUDA)
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/nccl.cpp)
+  find_package(NCCL)
+  if(NCCL_FOUND)
+    target_link_libraries(mlx PRIVATE ${NCCL_LIBRARIES})
+    target_include_directories(mlx PRIVATE ${NCCL_INCLUDE_DIRS})
+  else()
+    message(
+      STATUS
+        "NCCL not found, using stubs. To run distributed with NCCL backend, install NCCL."
+    )
+
+    include(ExternalProject)
+    ExternalProject_Add(
+      nccl_stub
+      SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/nccl_stub"
+      BUILD_COMMAND ${CMAKE_COMMAND} --build .
+      INSTALL_COMMAND "")
+    set(NCCL_PATH
+        "${CMAKE_CURRENT_BINARY_DIR}/nccl_stub-prefix/src/nccl_stub-build/")
+    target_link_libraries(mlx PRIVATE ${NCCL_PATH}/libnccl.so)
+    target_include_directories(mlx PRIVATE ${NCCL_PATH})
+  endif()
+else()
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/no_nccl.cpp)
+endif()
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl.cpp b/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..751ba913055b3c3b03fc47edf7a70abfb7208a72
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl.cpp
@@ -0,0 +1,372 @@
+#include <arpa/inet.h>
+#include <cuda_runtime.h>
+#include <nccl.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+
+#include "mlx/backend/cuda/device.h"
+#include "mlx/distributed/distributed.h"
+#include "mlx/distributed/distributed_impl.h"
+#include "mlx/dtype_utils.h"
+#include "mlx/utils.h"
+
+namespace mlx::core::distributed::nccl {
+
+#define CHECK_CUDA(cmd)              \
+  do {                               \
+    cudaError_t e = cmd;             \
+    if (e != cudaSuccess) {          \
+      fprintf(                       \
+          stderr,                    \
+          "CUDA error %s:%d '%s'\n", \
+          __FILE__,                  \
+          __LINE__,                  \
+          cudaGetErrorString(e));    \
+      exit(1);                       \
+    }                                \
+  } while (0)
+
+#define CHECK_NCCL(cmd)              \
+  do {                               \
+    ncclResult_t r = cmd;            \
+    if (r != ncclSuccess) {          \
+      fprintf(                       \
+          stderr,                    \
+          "NCCL error %s:%d '%s'\n", \
+          __FILE__,                  \
+          __LINE__,                  \
+          ncclGetErrorString(r));    \
+      exit(1);                       \
+    }                                \
+  } while (0)
+
+#define MLX_NCCL_TYPE_LIST(X) \
+  X(int8_t, ncclChar)         \
+  X(uint8_t, ncclUint8)       \
+  X(int32_t, ncclInt)         \
+  X(uint32_t, ncclUint32)     \
+  X(int64_t, ncclInt64)       \
+  X(uint64_t, ncclUint64)     \
+  X(float16_t, ncclHalf)      \
+  X(bfloat16_t, ncclBfloat16) \
+  X(float, ncclFloat)         \
+  X(double, ncclDouble)
+
+template <class>
+struct nccl_map {
+  static constexpr bool ok = false; // default: unsupported
+};
+
+#define MLX_DEF_NCCL_MAP(T, E)                 \
+  template <>                                  \
+  struct nccl_map<T> {                         \
+    static constexpr bool ok = true;           \
+    static constexpr ncclDataType_t value = E; \
+  };
+
+MLX_NCCL_TYPE_LIST(MLX_DEF_NCCL_MAP)
+#undef MLX_DEF_NCCL_MAP
+
+namespace detail {
+
+template <typename F>
+void dispatch_dtype(const array& arr, F&& f) {
+  dispatch_all_types(arr.dtype(), [&](auto type_tag) {
+    using T = MLX_GET_TYPE(type_tag);
+    if constexpr (nccl_map<T>::ok) {
+      f(type_tag, nccl_map<T>::value);
+    } else {
+      throw std::invalid_argument("[nccl] Unknown or unsupported dtype");
+    }
+  });
+}
+
+inline void sendAll(int sock, const void* buf, size_t len) {
+  const char* ptr = reinterpret_cast<const char*>(buf);
+  while (len > 0) {
+    ssize_t sent = send(sock, ptr, len, 0);
+    if (sent <= 0) {
+      perror("send");
+      exit(1);
+    }
+    ptr += sent;
+    len -= sent;
+  }
+}
+
+inline void recvAll(int sock, void* buf, size_t len) {
+  char* ptr = reinterpret_cast<char*>(buf);
+  while (len > 0) {
+    ssize_t rec = recv(sock, ptr, len, 0);
+    if (rec <= 0) {
+      perror("recv");
+      exit(1);
+    }
+    ptr += rec;
+    len -= rec;
+  }
+}
+
+inline void bootstrap_unique_id(
+    ncclUniqueId& id,
+    int rank,
+    int size,
+    const std::string& initMethod) {
+  // Parse the init method to extract the host and port
+  if (initMethod.rfind("tcp://", 0) != 0)
+    throw;
+  auto hostport = initMethod.substr(6);
+  auto colon = hostport.find(':');
+  std::string host = hostport.substr(0, colon);
+  int port = std::stoi(hostport.substr(colon + 1));
+
+  if (rank == 0) {
+    // create a unique id on the rank 0
+    CHECK_NCCL(ncclGetUniqueId(&id));
+
+    // create a socket to send the unique id to all other ranks
+    int sock = socket(AF_INET, SOCK_STREAM, 0);
+
+    if (sock < 0) {
+      std::ostringstream msg;
+      msg << "[nccl] Couldn't create socket (error: " << errno << ")";
+      throw std::runtime_error(msg.str());
+    }
+
+    sockaddr_in serv = {};
+    serv.sin_family = AF_INET;
+    serv.sin_addr.s_addr = htonl(INADDR_ANY);
+    serv.sin_port = htons(port);
+
+    int reuse = 1;
+    // Without this, if rank-0 crashes or restarts process quickly,
+    // the OS might refuse to let binding to the same port, so reuse
+
+    if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0) {
+      std::ostringstream msg;
+      msg << "[nccl] setsockopt() failed: " << strerror(errno);
+      throw std::runtime_error(msg.str());
+    }
+
+    if (bind(sock, reinterpret_cast<sockaddr*>(&serv), sizeof(serv)) < 0) {
+      std::ostringstream msg;
+      msg << "[nccl] bind() failed: " << strerror(errno);
+      throw std::runtime_error(msg.str());
+    }
+    if (listen(sock, size - 1) < 0) {
+      std::ostringstream msg;
+      msg << "[nccl] listen() failed: " << strerror(errno);
+      throw std::runtime_error(msg.str());
+    }
+
+    for (int peer = 1; peer < size; ++peer) {
+      int conn = accept(sock, nullptr, nullptr);
+      if (conn < 0) {
+        std::ostringstream msg;
+        msg << "[nccl] accept() failed: " << strerror(errno);
+        throw std::runtime_error(msg.str());
+      }
+      sendAll(conn, &id, sizeof(id));
+      close(conn);
+    }
+    close(sock);
+
+  } else {
+    // Here just wanted to make show that rank 0 has enough time to bind
+    // so we will retry to connect until max attempts
+
+    int sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock < 0) {
+      std::ostringstream msg;
+      msg << "[nccl] socket() failed: " << strerror(errno);
+      throw std::runtime_error(msg.str());
+    }
+
+    hostent* he = gethostbyname(host.c_str());
+    if (!he) {
+      throw std::runtime_error("[nccl] lookup failed for host: " + host);
+    }
+    sockaddr_in serv = {};
+    serv.sin_family = AF_INET;
+    memcpy(&serv.sin_addr, he->h_addr_list[0], he->h_length);
+    serv.sin_port = htons(port);
+
+    const int max_retries = 30;
+    int attempt = 0;
+    bool connected = false;
+
+    bool do_log = std::getenv("NCCL_DEBUG") == "INFO";
+    for (attempt = 0; attempt < max_retries; ++attempt) {
+      if (connect(sock, reinterpret_cast<sockaddr*>(&serv), sizeof(serv)) ==
+          0) {
+        connected = true;
+        if (do_log) {
+          std::cout << "[Rank " << rank
+                    << "] Connected successfully on attempt " << attempt + 1
+                    << std::endl;
+          break;
+        }
+      }
+      if (errno != ECONNREFUSED) {
+        break;
+      }
+      std::this_thread::sleep_for(std::chrono::milliseconds(500));
+    }
+
+    if (!connected) {
+      std::ostringstream msg;
+      msg << "[Rank " << rank << "] connect() failed after " << attempt
+          << " retries: " << strerror(errno);
+      close(sock);
+      throw std::runtime_error(msg.str());
+    }
+    recvAll(sock, &id, sizeof(id));
+    close(sock);
+  }
+}
+
+} // namespace detail
+
+using GroupImpl = mlx::core::distributed::detail::GroupImpl;
+class NCCLGroup : public GroupImpl {
+ public:
+  NCCLGroup(int worldRank, int worldSize, const std::string initMethod)
+      : rank_(worldRank),
+        size_(worldSize),
+        comm_(nullptr),
+        initMethod_(initMethod) {
+    if (initialized_)
+      return;
+    int ndev;
+    CHECK_CUDA(cudaGetDeviceCount(&ndev));
+    CHECK_CUDA(cudaSetDevice(rank_ % ndev));
+    detail::bootstrap_unique_id(uniqueId_, rank_, size_, initMethod_);
+    CHECK_NCCL(ncclCommInitRank(&comm_, size_, uniqueId_, rank_));
+    initialized_ = true;
+  }
+
+  ~NCCLGroup() {
+    ncclCommDestroy(comm_);
+    ncclGroupEnd();
+    initialized_ = false;
+  }
+
+  Stream communication_stream(StreamOrDevice s) override {
+    return to_stream(s, Device::gpu);
+  }
+
+  int rank() override {
+    return rank_;
+  }
+
+  int size() override {
+    return size_;
+  }
+
+  void all_sum(const array& input, array& output, Stream stream) override {
+    detail::dispatch_dtype(input, [&](auto type_tag, ncclDataType_t dt) {
+      using T = typename decltype(type_tag)::type;
+      all_reduce_impl<T>(input, output, stream, dt, ncclSum);
+    });
+  }
+
+  virtual std::shared_ptr<GroupImpl> split(int color, int key = -1) override {
+    throw std::runtime_error("[nccl] Group split not supported.");
+  }
+
+  void all_gather(const array& input, array& output, Stream stream) override {
+    throw std::runtime_error(
+        "[nccl] All gather not supported in NCCL backend.");
+  }
+
+  void send(const array& input, int dst, Stream stream) override {
+    throw std::runtime_error("[nccl] Send not supported in NCCL backend.");
+  }
+
+  void recv(array& output, int src, Stream stream) override {
+    throw std::runtime_error("[nccl] Recv not supported in NCCL backend.");
+  }
+
+  void all_max(const array& input, array& output, Stream stream) override {
+    throw std::runtime_error("[nccl] All max not supported in NCCL backend.");
+  }
+
+  void all_min(const array& input, array& output, Stream stream) override {
+    throw std::runtime_error("[nccl] All min not supported in NCCL backend.");
+  }
+
+  template <typename T>
+  void all_reduce_impl(
+      const array& input,
+      array& output,
+      Stream stream,
+      ncclDataType_t dt,
+      ncclRedOp_t op) {
+    auto& encoder = cu::get_command_encoder(stream);
+
+    CHECK_NCCL(ncclAllReduce(
+        input.data<T>(),
+        output.data<T>(),
+        input.size(),
+        dt,
+        op,
+        comm_,
+        encoder.stream()));
+  }
+
+  int rank_, size_;
+  std::string initMethod_;
+  ncclUniqueId uniqueId_;
+  ncclComm_t comm_;
+  bool initialized_ = false;
+};
+
+bool is_available() {
+  return true;
+}
+
+namespace detail {
+std::string get_env_var_or_throw(const char* env_var_name, bool strict) {
+  const char* value = std::getenv(env_var_name);
+  if (value == nullptr && strict) {
+    std::ostringstream msg;
+    msg << "[nccl] Required environment variable '" << env_var_name
+        << "' is not set. "
+        << "Please set it before initializing the distributed backend.";
+    throw std::runtime_error(msg.str());
+  }
+  if (value == nullptr) {
+    return "";
+  }
+  return std::string(value);
+}
+} // namespace detail
+
+std::shared_ptr<GroupImpl> init(bool strict /* = false */) {
+  std::string host = detail::get_env_var_or_throw("NCCL_HOST_IP", strict);
+  std::string port = detail::get_env_var_or_throw("NCCL_PORT", strict);
+  std::string rank_str = detail::get_env_var_or_throw("MLX_RANK", strict);
+  std::string n_nodes_str =
+      detail::get_env_var_or_throw("MLX_WORLD_SIZE", strict);
+  if (!strict &&
+      (host.empty() || port.empty() || rank_str.empty() ||
+       n_nodes_str.empty())) {
+    return nullptr;
+  }
+
+  int rank = std::stoi(rank_str);
+  int n_nodes = std::stoi(n_nodes_str);
+  std::string init_method = "tcp://" + host + ":" + port;
+
+  return std::make_shared<NCCLGroup>(rank, n_nodes, init_method);
+}
+} // namespace mlx::core::distributed::nccl
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl.h b/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl.h
new file mode 100644
index 0000000000000000000000000000000000000000..5370d2daf1bb24f6e5e52fc00ef24b643c39e79d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl.h
@@ -0,0 +1,12 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/distributed/distributed.h"
+
+namespace mlx::core::distributed::nccl {
+
+using GroupImpl = mlx::core::distributed::detail::GroupImpl;
+
+bool is_available();
+std::shared_ptr<GroupImpl> init(bool strict = false);
+
+} // namespace mlx::core::distributed::nccl
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl_stub/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl_stub/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a93ba3c062260f857bbc706e793d57c225e406d4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl_stub/CMakeLists.txt
@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.25)
+
+project(nccl LANGUAGES C CXX)
+
+file(
+  DOWNLOAD
+  "https://raw.githubusercontent.com/NVIDIA/nccl/refs/tags/v2.27.5-1/src/nccl.h.in"
+  "${CMAKE_CURRENT_BINARY_DIR}/nccl.h")
+
+add_library(nccl SHARED nccl_stubs.cpp)
+set_target_properties(nccl PROPERTIES SOVERSION 2)
+find_package(CUDAToolkit REQUIRED)
+target_include_directories(nccl PRIVATE ${CUDAToolkit_INCLUDE_DIRS})
+target_include_directories(nccl PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl_stub/nccl_stubs.cpp b/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl_stub/nccl_stubs.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..171340f67d3a1a0ee32877e7158b27440964f9fb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/nccl/nccl_stub/nccl_stubs.cpp
@@ -0,0 +1,7 @@
+#include <arpa/inet.h>
+#include <cuda_runtime.h>
+#include <nccl.h>
+
+ncclResult_t ncclGetUniqueId(ncclUniqueId*) {
+  return ncclSuccess;
+}
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp b/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1be256a11b52ff61e4dedcf513c892e029522f78
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/nccl/no_nccl.cpp
@@ -0,0 +1,20 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/distributed/nccl/nccl.h"
+
+namespace mlx::core::distributed::nccl {
+
+using GroupImpl = mlx::core::distributed::detail::GroupImpl;
+
+bool is_available() {
+  return false;
+}
+
+std::shared_ptr<GroupImpl> init(bool strict /* = false */) {
+  if (strict) {
+    throw std::runtime_error("Cannot initialize nccl distributed backend.");
+  }
+  return nullptr;
+}
+
+} // namespace mlx::core::distributed::nccl
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp b/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..157bc261292e557fe459d8e6817f8181fc8c8f31
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/ops.cpp
@@ -0,0 +1,160 @@
+// Copyright © 2024 Apple Inc.
+
+#include <sstream>
+
+#include "mlx/backend/cuda/cuda.h"
+#include "mlx/backend/metal/metal.h"
+#include "mlx/distributed/distributed_impl.h"
+#include "mlx/distributed/ops.h"
+#include "mlx/distributed/primitives.h"
+
+namespace mlx::core::distributed {
+
+namespace {
+
+Group to_group(std::optional<Group> group) {
+  if (group.has_value()) {
+    return group.value();
+  } else {
+    return distributed::init();
+  }
+}
+
+} // namespace
+
+array all_sum(
+    const array& x,
+    std::optional<Group> group_ /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  auto group = to_group(group_);
+
+  if (group.size() == 1) {
+    return x;
+  }
+  auto stream = detail::communication_stream(group, s);
+
+  return array(
+      x.shape(),
+      x.dtype(),
+      std::make_shared<AllReduce>(stream, group, AllReduce::Sum),
+      {x});
+}
+
+array all_max(
+    const array& x,
+    std::optional<Group> group_ /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  auto group = to_group(group_);
+
+  if (group.size() == 1) {
+    return x;
+  }
+  auto stream = detail::communication_stream(group, s);
+
+  return array(
+      x.shape(),
+      x.dtype(),
+      std::make_shared<AllReduce>(stream, group, AllReduce::Max),
+      {x});
+}
+
+array all_min(
+    const array& x,
+    std::optional<Group> group_ /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  auto group = to_group(group_);
+
+  if (group.size() == 1) {
+    return x;
+  }
+  auto stream = detail::communication_stream(group, s);
+
+  return array(
+      x.shape(),
+      x.dtype(),
+      std::make_shared<AllReduce>(stream, group, AllReduce::Min),
+      {x});
+}
+
+array all_gather(
+    const array& x,
+    std::optional<Group> group_ /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  auto group = to_group(group_);
+
+  if (group.size() == 1) {
+    return x;
+  }
+  auto stream = detail::communication_stream(group, s);
+
+  auto result_shape = x.shape();
+  if (result_shape.size() == 0) {
+    result_shape.push_back(group.size());
+  } else {
+    result_shape[0] *= group.size();
+  }
+  return array(
+      std::move(result_shape),
+      x.dtype(),
+      std::make_shared<AllGather>(stream, group),
+      {x});
+}
+
+array send(
+    const array& x,
+    int dst,
+    std::optional<Group> group_ /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  auto group = to_group(group_);
+
+  if (group.size() == 1) {
+    throw std::invalid_argument("Cannot send to a singleton group");
+  }
+  auto stream = detail::communication_stream(group, s);
+
+  if (dst < 0 || dst >= group.size()) {
+    std::ostringstream msg;
+    msg << "Invalid destination=" << dst << " for a group of size "
+        << group.size();
+    throw std::invalid_argument(msg.str());
+  }
+
+  return array(
+      x.shape(), x.dtype(), std::make_shared<Send>(stream, group, dst), {x});
+}
+
+array recv(
+    Shape shape,
+    Dtype dtype,
+    int src,
+    std::optional<Group> group_ /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  auto group = to_group(group_);
+
+  if (group.size() == 1) {
+    throw std::invalid_argument("Cannot recv from a singleton group");
+  }
+  auto stream = detail::communication_stream(group, s);
+
+  if (src < 0 || src >= group.size()) {
+    std::ostringstream msg;
+    msg << "Invalid source=" << src << " for a group of size " << group.size();
+    throw std::invalid_argument(msg.str());
+  }
+
+  return array(
+      std::move(shape),
+      std::move(dtype),
+      std::make_shared<Recv>(stream, group, src),
+      std::vector<array>{});
+}
+
+array recv_like(
+    const array& x,
+    int src,
+    std::optional<Group> group_ /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  return recv(x.shape(), x.dtype(), src, group_, s);
+}
+
+} // namespace mlx::core::distributed
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/ops.h b/ml-stable-diffusion/mlx/mlx/distributed/ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..edd1fc9f4075636ed180514d22f31e7a05d4e36e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/ops.h
@@ -0,0 +1,51 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include <optional>
+
+#include "mlx/distributed/distributed.h"
+#include "mlx/utils.h"
+
+namespace mlx::core::distributed {
+
+array all_sum(
+    const array& x,
+    std::optional<Group> group = std::nullopt,
+    StreamOrDevice s = {});
+
+array all_gather(
+    const array& x,
+    std::optional<Group> group = std::nullopt,
+    StreamOrDevice S = {});
+
+array send(
+    const array& x,
+    int dst,
+    std::optional<Group> group = std::nullopt,
+    StreamOrDevice s = {});
+
+array recv(
+    Shape shape,
+    Dtype dtype,
+    int src,
+    std::optional<Group> group = std::nullopt,
+    StreamOrDevice s = {});
+
+array recv_like(
+    const array& x,
+    int src,
+    std::optional<Group> group = std::nullopt,
+    StreamOrDevice s = {});
+
+array all_max(
+    const array& x,
+    std::optional<Group> group = std::nullopt,
+    StreamOrDevice s = {});
+
+array all_min(
+    const array& x,
+    std::optional<Group> group = std::nullopt,
+    StreamOrDevice s = {});
+
+} // namespace mlx::core::distributed
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp b/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..576424cdd600994ec5874141bd50dc5dd4bb95ae
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/primitives.cpp
@@ -0,0 +1,86 @@
+// Copyright © 2024 Apple Inc.
+
+#include <cassert>
+
+#include "mlx/allocator.h"
+#include "mlx/distributed/ops.h"
+#include "mlx/distributed/primitives.h"
+#include "mlx/ops.h"
+
+namespace mlx::core::distributed {
+
+std::pair<std::vector<array>, std::vector<int>> AllReduce::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  switch (reduce_type_) {
+    case Sum:
+      return {{all_sum(inputs[0], group(), stream())}, axes};
+    case Max:
+      return {{all_max(inputs[0], group(), stream())}, axes};
+    case Min:
+      return {{all_min(inputs[0], group(), stream())}, axes};
+    default:
+
+      throw std::runtime_error(
+          "Only all reduce sum, max and min are supported for now");
+  }
+}
+
+std::vector<array> AllReduce::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  switch (reduce_type_) {
+    case Sum:
+      return {all_sum(tangents[0], group(), stream())};
+    case Max:
+      return {all_max(tangents[0], group(), stream())};
+    case Min:
+      return {all_min(tangents[0], group(), stream())};
+    default:
+      throw std::runtime_error(
+          "Only all reduce sum, max and min are supported for now");
+  }
+}
+
+std::vector<array> AllReduce::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  return cotangents;
+}
+
+std::pair<std::vector<array>, std::vector<int>> AllGather::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  return {{all_gather(inputs[0], group(), stream())}, axes};
+}
+
+std::vector<array> AllGather::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  return {all_gather(tangents[0], group(), stream())};
+}
+
+std::vector<array> AllGather::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  auto g = group();
+  Shape starts(primals[0].ndim(), 0);
+  auto stops = primals[0].shape();
+  starts[0] = g.rank() * stops[0];
+  stops[0] += starts[0];
+  return {slice(cotangents[0], starts, stops)};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Send::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  return {{send(inputs[0], dst_, group(), stream())}, axes};
+}
+
+} // namespace mlx::core::distributed
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/primitives.h b/ml-stable-diffusion/mlx/mlx/distributed/primitives.h
new file mode 100644
index 0000000000000000000000000000000000000000..7ad00a0d63af74c6e10b15351f2bfec9437cc06c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/primitives.h
@@ -0,0 +1,130 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include "mlx/distributed/distributed.h"
+#include "mlx/distributed/distributed_impl.h"
+#include "mlx/primitives.h"
+
+namespace mlx::core::distributed {
+
+class DistPrimitive : public Primitive {
+ public:
+  DistPrimitive(Stream stream, Group group)
+      : Primitive(stream), group_(group) {}
+
+  const Group& group() const {
+    return group_;
+  }
+
+ private:
+  Group group_;
+};
+
+class AllReduce : public DistPrimitive {
+ public:
+  enum ReduceType { And, Or, Sum, Prod, Min, Max };
+
+  AllReduce(Stream stream, Group group, ReduceType reduce_type)
+      : DistPrimitive(stream, group), reduce_type_(reduce_type) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  std::pair<std::vector<array>, std::vector<int>> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+  std::vector<array> jvp(
+      const std::vector<array>& primals,
+      const std::vector<array>& tangents,
+      const std::vector<int>& argnums) override;
+  std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const std::vector<array>& cotangents,
+      const std::vector<int>& argnums,
+      const std::vector<array>& outputs) override;
+
+  const char* name() const override {
+    switch (reduce_type_) {
+      case And:
+        return "And AllReduce";
+      case Or:
+        return "Or AllReduce";
+      case Sum:
+        return "Sum AllReduce";
+      case Prod:
+        return "Prod AllReduce";
+      case Min:
+        return "Min AllReduce";
+      case Max:
+        return "Max AllReduce";
+    }
+    return "<unknwon AllReduce>";
+  }
+
+ private:
+  ReduceType reduce_type_;
+};
+
+class AllGather : public DistPrimitive {
+ public:
+  AllGather(Stream stream, Group group) : DistPrimitive(stream, group) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  std::pair<std::vector<array>, std::vector<int>> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+  std::vector<array> jvp(
+      const std::vector<array>& primals,
+      const std::vector<array>& tangents,
+      const std::vector<int>& argnums) override;
+  std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const std::vector<array>& cotangents,
+      const std::vector<int>& argnums,
+      const std::vector<array>& outputs) override;
+
+  DEFINE_NAME(AllGather);
+};
+
+class Send : public DistPrimitive {
+ public:
+  Send(Stream stream, Group group, int dst)
+      : DistPrimitive(stream, group), dst_(dst) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  std::pair<std::vector<array>, std::vector<int>> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  DEFINE_NAME(Send);
+
+ private:
+  int dst_;
+};
+
+class Recv : public DistPrimitive {
+ public:
+  Recv(Stream stream, Group group, int src)
+      : DistPrimitive(stream, group), src_(src) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_NAME(Recv);
+
+ private:
+  int src_;
+};
+
+} // namespace mlx::core::distributed
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/ring/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/distributed/ring/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..346f7cdb7e6bcf9671a4717be5efe24ae53647b6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/ring/CMakeLists.txt
@@ -0,0 +1,5 @@
+if(MLX_BUILD_CPU AND NOT WIN32)
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/ring.cpp)
+else()
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/no_ring.cpp)
+endif()
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/ring/no_ring.cpp b/ml-stable-diffusion/mlx/mlx/distributed/ring/no_ring.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c31d28392bc3163c36cad6b814af6758a75357b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/ring/no_ring.cpp
@@ -0,0 +1,20 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/distributed/ring/ring.h"
+
+namespace mlx::core::distributed::ring {
+
+using GroupImpl = mlx::core::distributed::detail::GroupImpl;
+
+bool is_available() {
+  return false;
+}
+
+std::shared_ptr<GroupImpl> init(bool strict /* = false */) {
+  if (strict) {
+    throw std::runtime_error("Cannot initialize ring distributed backend.");
+  }
+  return nullptr;
+}
+
+} // namespace mlx::core::distributed::ring
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp b/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7c3dcf09507daafe572b94a30d61732c7fbf75dc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.cpp
@@ -0,0 +1,1021 @@
+// Copyright © 2024 Apple Inc.
+
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <iostream>
+#include <list>
+#include <sstream>
+#include <thread>
+#include <unordered_map>
+
+#include <json.hpp>
+
+#include "mlx/backend/cpu/encoder.h"
+#include "mlx/distributed/distributed.h"
+#include "mlx/distributed/distributed_impl.h"
+#include "mlx/threadpool.h"
+
+#ifndef SOL_TCP
+#define SOL_TCP IPPROTO_TCP
+#endif
+
+#define SWITCH_TYPE(x, ...)  \
+  switch ((x).dtype()) {     \
+    case bool_: {            \
+      using T = bool;        \
+      __VA_ARGS__;           \
+    } break;                 \
+    case int8: {             \
+      using T = int8_t;      \
+      __VA_ARGS__;           \
+    } break;                 \
+    case int16: {            \
+      using T = int16_t;     \
+      __VA_ARGS__;           \
+    } break;                 \
+    case int32: {            \
+      using T = int32_t;     \
+      __VA_ARGS__;           \
+    } break;                 \
+    case int64: {            \
+      using T = int64_t;     \
+      __VA_ARGS__;           \
+    } break;                 \
+    case uint8: {            \
+      using T = uint8_t;     \
+      __VA_ARGS__;           \
+    } break;                 \
+    case uint16: {           \
+      using T = uint16_t;    \
+      __VA_ARGS__;           \
+    } break;                 \
+    case uint32: {           \
+      using T = uint32_t;    \
+      __VA_ARGS__;           \
+    } break;                 \
+    case uint64: {           \
+      using T = uint64_t;    \
+      __VA_ARGS__;           \
+    } break;                 \
+    case bfloat16: {         \
+      using T = bfloat16_t;  \
+      __VA_ARGS__;           \
+    } break;                 \
+    case float16: {          \
+      using T = float16_t;   \
+      __VA_ARGS__;           \
+    } break;                 \
+    case float32: {          \
+      using T = float;       \
+      __VA_ARGS__;           \
+    } break;                 \
+    case float64: {          \
+      using T = double;      \
+      __VA_ARGS__;           \
+    } break;                 \
+    case complex64: {        \
+      using T = complex64_t; \
+      __VA_ARGS__;           \
+    } break;                 \
+  }
+
+namespace mlx::core::distributed::ring {
+
+constexpr const size_t ALL_SUM_SIZE = 8 * 1024 * 1024;
+constexpr const size_t ALL_SUM_BUFFERS = 2;
+constexpr const int CONN_ATTEMPTS = 5;
+constexpr const int CONN_WAIT = 1000;
+
+using GroupImpl = mlx::core::distributed::detail::GroupImpl;
+using json = nlohmann::json;
+using namespace std::chrono_literals;
+
+namespace {
+
+template <typename T>
+void log(std::ostream& os, T first) {
+  os << first << std::endl;
+}
+
+template <typename T, typename... Args>
+void log(std::ostream& os, T first, Args... args) {
+  log(os << first << " ", args...);
+}
+
+template <typename... Args>
+void log_info(bool verbose, Args... args) {
+  if (!verbose) {
+    return;
+  }
+
+  log(std::cerr, "[ring]", args...);
+}
+
+template <typename T, typename U>
+decltype(T() * U()) ceildiv(T a, U b) {
+  return (a + b - 1) / b;
+}
+
+class SocketThread {
+ public:
+  SocketThread(int fd) : fd_(fd), stop_(false) {
+    worker_ = std::thread(&SocketThread::worker, this);
+    int flags = fcntl(fd, F_GETFL, 0);
+    fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+  }
+  ~SocketThread() {
+    stop_ = true;
+    condition_.notify_all();
+    worker_.join();
+    int flags = fcntl(fd_, F_GETFL, 0);
+    fcntl(fd_, F_SETFL, flags & ~O_NONBLOCK);
+  }
+
+  template <typename T>
+  std::future<void> send(const T* buffer, size_t size) {
+    return send_impl(reinterpret_cast<const char*>(buffer), size * sizeof(T));
+  }
+
+  template <typename T>
+  std::future<void> recv(T* buffer, size_t size) {
+    return recv_impl(reinterpret_cast<char*>(buffer), size * sizeof(T));
+  }
+
+ private:
+  struct SocketTask {
+    SocketTask(void* b, size_t s, std::promise<void>&& p)
+        : buffer(b), size(s), promise(std::move(p)) {}
+    SocketTask(SocketTask&& t)
+        : buffer(t.buffer), size(t.size), promise(std::move(t.promise)) {}
+    void* buffer;
+    size_t size;
+    std::promise<void> promise;
+  };
+
+  std::future<void> send_impl(const char* buffer, size_t size) {
+    std::promise<void> send_completed_promise;
+    auto send_completed_future = send_completed_promise.get_future();
+    if (size == 0) {
+      send_completed_promise.set_value();
+      return send_completed_future;
+    }
+
+    {
+      std::unique_lock lock(queue_mutex_);
+      sends_.emplace_back(SocketTask(
+          const_cast<char*>(buffer), size, std::move(send_completed_promise)));
+    }
+    condition_.notify_one();
+    return send_completed_future;
+  }
+
+  std::future<void> recv_impl(char* buffer, size_t size) {
+    std::promise<void> recv_completed_promise;
+    auto recv_completed_future = recv_completed_promise.get_future();
+    if (size == 0) {
+      recv_completed_promise.set_value();
+      return recv_completed_future;
+    }
+
+    {
+      std::unique_lock lock(queue_mutex_);
+      recvs_.emplace_back(
+          SocketTask(buffer, size, std::move(recv_completed_promise)));
+    }
+    condition_.notify_one();
+    return recv_completed_future;
+  }
+
+  bool have_tasks() {
+    return !(sends_.empty() && recvs_.empty());
+  }
+
+  void worker() {
+    int error_count = 0;
+    bool delete_recv = false;
+    bool delete_send = false;
+    while (true) {
+      {
+        std::unique_lock lock(queue_mutex_);
+
+        if (delete_recv) {
+          recvs_.front().promise.set_value();
+          recvs_.pop_front();
+          delete_recv = false;
+        }
+        if (delete_send) {
+          sends_.front().promise.set_value();
+          sends_.pop_front();
+          delete_send = false;
+        }
+
+        if (stop_) {
+          return;
+        }
+
+        if (!have_tasks()) {
+          condition_.wait(lock, [this] { return stop_ || have_tasks(); });
+          if (stop_) {
+            return;
+          }
+        }
+      }
+
+      if (!recvs_.empty()) {
+        auto& task = recvs_.front();
+        ssize_t r = ::recv(fd_, task.buffer, task.size, 0);
+        if (r > 0) {
+          task.buffer = static_cast<char*>(task.buffer) + r;
+          task.size -= r;
+          delete_recv = task.size == 0;
+          error_count = 0;
+        } else if (errno != EAGAIN) {
+          error_count++;
+          log_info(
+              true, "Receiving from socket", fd_, "failed with errno", errno);
+        }
+      }
+      if (!sends_.empty()) {
+        auto& task = sends_.front();
+        ssize_t r = ::send(fd_, task.buffer, task.size, 0);
+        if (r > 0) {
+          task.buffer = static_cast<char*>(task.buffer) + r;
+          task.size -= r;
+          delete_send = task.size == 0;
+          error_count = 0;
+        } else if (errno != EAGAIN) {
+          error_count++;
+          log_info(true, "Sending to socket", fd_, "failed with errno", errno);
+        }
+      }
+
+      if (error_count >= 10) {
+        log_info(true, "Too many send/recv errors. Aborting...");
+        return;
+      }
+    }
+  }
+
+  int fd_;
+  bool stop_;
+  std::thread worker_;
+  std::mutex queue_mutex_;
+  std::condition_variable condition_;
+  std::list<SocketTask> sends_;
+  std::list<SocketTask> recvs_;
+};
+
+class CommunicationThreads {
+ public:
+  void add(const std::vector<int>& sockets) {
+    for (int sock : sockets) {
+      threads_.emplace(sock, sock);
+    }
+  }
+
+  template <typename T>
+  std::future<void> send(int socket, T* buffer, size_t size) {
+    return threads_.at(socket).send<T>(buffer, size);
+  }
+
+  template <typename T>
+  std::future<void> recv(int socket, T* buffer, size_t size) {
+    return threads_.at(socket).recv<T>(buffer, size);
+  }
+
+ private:
+  std::unordered_map<int, SocketThread> threads_;
+};
+
+struct address_t {
+  sockaddr_storage addr;
+  socklen_t len;
+
+  const sockaddr* get() const {
+    return (struct sockaddr*)&addr;
+  }
+};
+
+/**
+ * Parse a sockaddr from an ip and port provided as strings.
+ */
+address_t parse_address(const std::string& ip, const std::string& port) {
+  struct addrinfo hints, *res;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+
+  int status = getaddrinfo(ip.c_str(), port.c_str(), &hints, &res);
+  if (status != 0) {
+    std::ostringstream msg;
+    msg << "Can't parse address " << ip << ":" << port;
+    throw std::runtime_error(msg.str());
+  }
+
+  address_t result;
+  memcpy(&result.addr, res->ai_addr, res->ai_addrlen);
+  result.len = res->ai_addrlen;
+  freeaddrinfo(res);
+
+  return result;
+}
+
+/**
+ * Parse a sockaddr provided as an <ip>:<port> string.
+ */
+address_t parse_address(const std::string& ip_port) {
+  auto colon = ip_port.find(":");
+  if (colon == std::string::npos) {
+    std::ostringstream msg;
+    msg << "Can't parse address " << ip_port;
+    throw std::runtime_error(msg.str());
+  }
+  std::string ip(ip_port.begin(), ip_port.begin() + colon);
+  std::string port(ip_port.begin() + colon + 1, ip_port.end());
+
+  return parse_address(ip, port);
+}
+
+/**
+ * Load all addresses from the json hostfile. The hostfile is a list of
+ * addresses in order of rank. For each rank there can be many addresses so
+ * that we can have multiple connections between peers.
+ *
+ * For example:
+ *  [
+ *    ["ip1:5000", "ip1:5001"],
+ *    ["ip2:5000", "ip2:5001"],
+ *    ["ip3:5000", "ip3:5001"],
+ *  ]
+ */
+std::vector<std::vector<address_t>> load_nodes(const char* hostfile) {
+  std::vector<std::vector<address_t>> nodes;
+  std::ifstream f(hostfile);
+
+  json hosts = json::parse(f);
+  for (auto& h : hosts) {
+    std::vector<address_t> host;
+    for (auto& ips : h) {
+      host.push_back(std::move(parse_address(ips.get<std::string>())));
+    }
+    nodes.push_back(std::move(host));
+  }
+
+  return nodes;
+}
+
+/**
+ * Create a socket and accept one connection for each of the provided
+ * addresses.
+ */
+std::vector<int> accept_connections(const std::vector<address_t>& addresses) {
+  std::vector<int> sockets;
+  int success;
+
+  for (auto& address : addresses) {
+    // Create the socket to wait for connections from the peers
+    int sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock < 0) {
+      std::ostringstream msg;
+      msg << "[ring] Couldn't create socket (error: " << errno << ")";
+      throw std::runtime_error(msg.str());
+    }
+
+    // Make sure we can launch immediately after shutdown by setting the
+    // reuseaddr option so that we don't get address already in use errors
+    int enable = 1;
+    success = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int));
+    if (success < 0) {
+      shutdown(sock, 2);
+      close(sock);
+      std::ostringstream msg;
+      msg << "[ring] Couldn't enable reuseaddr (error: " << errno << ")";
+      throw std::runtime_error(msg.str());
+    }
+    success = setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(int));
+    if (success < 0) {
+      shutdown(sock, 2);
+      close(sock);
+      std::ostringstream msg;
+      msg << "[ring] Couldn't enable reuseport (error: " << errno << ")";
+      throw std::runtime_error(msg.str());
+    }
+
+    // Bind the socket to the address and port
+    success = bind(sock, address.get(), address.len);
+    if (success < 0) {
+      shutdown(sock, 2);
+      close(sock);
+      std::ostringstream msg;
+      msg << "[ring] Couldn't bind socket (error: " << errno << ")";
+      throw std::runtime_error(msg.str());
+    }
+
+    // Wait for connections
+    success = listen(sock, 0);
+    if (success < 0) {
+      shutdown(sock, 2);
+      close(sock);
+      std::ostringstream msg;
+      msg << "[ring] Couldn't listen (error: " << errno << ")";
+      throw std::runtime_error(msg.str());
+    }
+
+    int peer_socket = accept(sock, nullptr, nullptr);
+    if (peer_socket < 0) {
+      shutdown(sock, 2);
+      close(sock);
+      std::ostringstream msg;
+      msg << "[ring] Accept failed (error: " << errno << ")";
+      throw std::runtime_error(msg.str());
+    }
+
+    // Close the listening socket
+    shutdown(sock, 2);
+    close(sock);
+
+    sockets.push_back(peer_socket);
+  }
+
+  return sockets;
+}
+
+/**
+ * The counterpoint of `accept_connections`. Basically connect to each of the
+ * provided addresses.
+ */
+std::vector<int> make_connections(
+    const std::vector<address_t>& addresses,
+    bool verbose) {
+  std::vector<int> sockets;
+  int success;
+
+  for (auto& address : addresses) {
+    int sock;
+
+    // Attempt to connect to the peer CONN_ATTEMPTS times with exponential
+    // backoff. TODO: Do we need that?
+    for (int attempt = 0; attempt < CONN_ATTEMPTS; attempt++) {
+      // Create the socket
+      sock = socket(AF_INET, SOCK_STREAM, 0);
+      if (sock < 0) {
+        std::ostringstream msg;
+        msg << "[ring] Couldn't create socket (error: " << errno << ")";
+        throw std::runtime_error(msg.str());
+      }
+
+      if (attempt > 0) {
+        int wait = (1 << (attempt - 1)) * CONN_WAIT;
+        log_info(
+            verbose,
+            "Attempt",
+            attempt,
+            "wait",
+            wait,
+            "ms (error:",
+            errno,
+            ")");
+        std::this_thread::sleep_for(std::chrono::milliseconds(wait));
+      }
+
+      success = connect(sock, address.get(), address.len);
+      if (success == 0) {
+        break;
+      }
+    }
+    if (success < 0) {
+      std::ostringstream msg;
+      msg << "[ring] Couldn't connect (error: " << errno << ")";
+      throw std::runtime_error(msg.str());
+    }
+
+    sockets.push_back(sock);
+  }
+
+  return sockets;
+}
+template <typename T>
+struct SumOp {
+  void operator()(const T* input, T* output, size_t N) {
+    while (N-- > 0) {
+      *output += *input;
+      input++;
+      output++;
+    }
+  }
+};
+
+template <typename T>
+struct MaxOp {
+  void operator()(const T* input, T* output, size_t N) {
+    while (N-- > 0) {
+      *output = std::max(*output, *input);
+      input++;
+      output++;
+    }
+  }
+};
+
+template <typename T>
+struct MinOp {
+  void operator()(const T* input, T* output, size_t N) {
+    while (N-- > 0) {
+      *output = std::min(*output, *input);
+      input++;
+      output++;
+    }
+  }
+};
+
+} // namespace
+
+class RingGroup : public GroupImpl {
+ public:
+  RingGroup(int rank, std::vector<std::vector<address_t>> nodes, bool verbose)
+      : rank_(rank), verbose_(verbose), pool_(0) {
+    if (rank_ > 0 && rank_ >= nodes.size()) {
+      throw std::runtime_error(
+          "[ring] Rank cannot be larger than the size of the group");
+    }
+
+    size_ = nodes.size();
+    int connect_to = (rank_ + 1) % size_;
+
+    // We define the connection order by having the rank_ == size_ - 1 connect
+    // first and accept after.
+    if (rank_ < connect_to) {
+      log_info(verbose_, "Rank", rank_, "accepting");
+      sockets_left_ = std::move(accept_connections(nodes[rank_]));
+      log_info(verbose_, "Rank", rank_, "connecting to", connect_to);
+      sockets_right_ = std::move(make_connections(nodes[connect_to], verbose));
+    } else {
+      log_info(verbose_, "Rank", rank_, "connecting to", connect_to);
+      sockets_right_ = std::move(make_connections(nodes[connect_to], verbose));
+      log_info(verbose_, "Rank", rank_, "accepting");
+      sockets_left_ = std::move(accept_connections(nodes[rank_]));
+    }
+
+    // Failure if we couldn't make right or left sockets
+    if (sockets_right_.empty()) {
+      std::ostringstream msg;
+      msg << "[ring] Rank " << rank_ << " has no sockets to the right.";
+      throw std::invalid_argument(msg.str());
+    }
+    if (sockets_left_.empty()) {
+      std::ostringstream msg;
+      msg << "[ring] Rank " << rank_ << " has no sockets to the left.";
+      throw std::invalid_argument(msg.str());
+    }
+
+    // The following could be relaxed since we can define non-homogeneous rings
+    // but it makes things a bit simpler for now.
+    if (sockets_right_.size() != sockets_left_.size()) {
+      std::ostringstream msg;
+      msg << "[ring] It is required to have as many connections to the left as "
+          << "to the right but rank " << rank_ << " has "
+          << sockets_right_.size() << " connections to the right and "
+          << sockets_left_.size() << " to the left.";
+      throw std::invalid_argument(msg.str());
+    }
+
+    // Configure all sockets to use TCP no delay.
+    int one = 1;
+    for (int i = 0; i < sockets_right_.size(); i++) {
+      setsockopt(sockets_right_[i], SOL_TCP, TCP_NODELAY, &one, sizeof(one));
+      setsockopt(sockets_left_[i], SOL_TCP, TCP_NODELAY, &one, sizeof(one));
+    }
+
+    // Start the all reduce threads. One all reduce per direction per ring.
+    pool_.resize(sockets_right_.size() + sockets_left_.size());
+
+    // Create a communication thread per socket. This also converts them to
+    // non-blocking.
+    comm_.add(sockets_right_);
+    comm_.add(sockets_left_);
+
+    // Allocate buffers for the all sum
+    buffers_.resize(
+        (sockets_right_.size() + sockets_left_.size()) * ALL_SUM_BUFFERS *
+        ALL_SUM_SIZE);
+  }
+
+  ~RingGroup() {
+    for (auto s : sockets_right_) {
+      shutdown(s, 2);
+      close(s);
+    }
+    for (auto s : sockets_left_) {
+      shutdown(s, 2);
+      close(s);
+    }
+  }
+
+  Stream communication_stream(StreamOrDevice s) override {
+    return to_stream(s, Device::cpu);
+  }
+
+  int rank() override {
+    return rank_;
+  }
+
+  int size() override {
+    return size_;
+  }
+
+  void all_sum(const array& input, array& output, Stream stream) override {
+    SWITCH_TYPE(
+        output, all_reduce<T, SumOp<T>>(input, output, stream, SumOp<T>()));
+  }
+
+  void all_max(const array& input, array& output, Stream stream) override {
+    SWITCH_TYPE(
+        output, all_reduce<T, MaxOp<T>>(input, output, stream, MaxOp<T>()));
+  }
+
+  void all_min(const array& input, array& output, Stream stream) override {
+    SWITCH_TYPE(
+        output, all_reduce<T, MinOp<T>>(input, output, stream, MinOp<T>()));
+  }
+
+  std::shared_ptr<GroupImpl> split(int color, int key = -1) override {
+    throw std::runtime_error("[ring] Group split not supported.");
+  }
+
+  void all_gather(const array& input, array& output, Stream stream) override {
+    auto& encoder = cpu::get_command_encoder(stream);
+    encoder.set_input_array(input);
+    encoder.set_output_array(output);
+    encoder.dispatch([input_ptr = input.data<char>(),
+                      nbytes = input.nbytes(),
+                      output_ptr = output.data<char>(),
+                      this]() {
+      constexpr size_t min_send_size = 262144;
+      size_t n_gathers = std::max(
+          std::min(
+              sockets_right_.size() + sockets_left_.size(),
+              nbytes / min_send_size),
+          size_t(1));
+      size_t bytes_per_gather = ceildiv(nbytes, n_gathers);
+      std::vector<std::future<void>> all_gathers;
+      for (int i = 0; i < n_gathers; i++) {
+        auto offset = i * bytes_per_gather;
+        all_gathers.emplace_back(pool_.enqueue(std::bind(
+            &RingGroup::all_gather_impl,
+            this,
+            input_ptr + offset,
+            output_ptr + offset,
+            nbytes,
+            offset + bytes_per_gather > nbytes ? nbytes - offset
+                                               : bytes_per_gather,
+            sockets_right_[i / 2],
+            sockets_left_[i / 2],
+            (i % 2) ? -1 : 1)));
+      }
+      for (auto& f : all_gathers) {
+        f.wait();
+      }
+    });
+  }
+
+  void send(const array& input, int dst, Stream stream) override {
+    auto& encoder = cpu::get_command_encoder(stream);
+    encoder.set_input_array(input);
+    encoder.dispatch(
+        [input_ptr = input.data<char>(), nbytes = input.nbytes(), dst, this]() {
+          int right = (rank_ + 1) % size_;
+          int left = (rank_ + size_ - 1) % size_;
+          if (dst == right) {
+            send(sockets_right_, input_ptr, nbytes);
+          } else if (dst == left) {
+            send(sockets_left_, input_ptr, nbytes);
+          } else {
+            std::ostringstream msg;
+            msg << "[ring] Send only supported to direct neighbors "
+                << "but tried to send to " << dst << " from " << rank_
+                << std::endl;
+            throw std::runtime_error(msg.str());
+          }
+        });
+  }
+
+  void recv(array& out, int src, Stream stream) override {
+    auto& encoder = cpu::get_command_encoder(stream);
+    encoder.set_output_array(out);
+    encoder.dispatch(
+        [out_ptr = out.data<char>(), nbytes = out.nbytes(), src, this]() {
+          // NOTE: We 'll check the sockets with the opposite order of send so
+          // that they work even with 2 nodes where left and right is the same
+          // neighbor.
+          int right = (rank_ + 1) % size_;
+          int left = (rank_ + size_ - 1) % size_;
+          if (src == left) {
+            recv(sockets_left_, out_ptr, nbytes);
+          } else if (src == right) {
+            recv(sockets_right_, out_ptr, nbytes);
+          } else {
+            std::ostringstream msg;
+            msg << "[ring] Recv only supported from direct neighbors "
+                << "but tried to recv from " << src << " to " << rank_
+                << std::endl;
+            throw std::runtime_error(msg.str());
+          }
+        });
+  }
+
+ private:
+  template <typename T, typename ReduceOp>
+  void all_reduce(
+      const array& input,
+      array& output,
+      Stream stream,
+      ReduceOp reduce_op) {
+    auto in_ptr = input.data<char>();
+    auto out_ptr = output.data<char>();
+    auto& encoder = cpu::get_command_encoder(stream);
+    encoder.set_output_array(output);
+    encoder.dispatch([in_ptr, out_ptr, size = input.size(), this, reduce_op]() {
+      // If the input data cannot be split into size_ segments then copy it and
+      // all reduce a local buffer prefilled with 0s.
+      size_t nbytes = size * sizeof(T);
+      if (size < size_) {
+        // TODO: Maybe allocate dynamically so we don't have the constraint
+        // below?
+        if (sizeof(T) * size_ > 1024) {
+          std::ostringstream msg;
+          msg << "Can't perform the ring all reduce of " << size
+              << " elements with a ring of size " << size_;
+          throw std::runtime_error(msg.str());
+        }
+
+        char buffer[1024];
+        std::memset(buffer, 0, size_ * sizeof(T));
+        std::memcpy(buffer, in_ptr, nbytes);
+        all_reduce_impl<T, ReduceOp>(
+            reinterpret_cast<T*>(buffers_.data()),
+            reinterpret_cast<T*>(buffer),
+            size_,
+            sockets_right_[0],
+            sockets_left_[0],
+            -1,
+            reduce_op);
+        std::memcpy(out_ptr, buffer, nbytes);
+        return;
+      }
+
+      // If not inplace all reduce then copy the input to the output first
+      if (in_ptr != out_ptr) {
+        std::memcpy(out_ptr, in_ptr, nbytes);
+      }
+
+      // Split the all reduces so that each member has at least 1 buffer to
+      // send/recv per segment.
+      constexpr size_t min_send_size = 262144;
+      size_t n_reduces = std::max(
+          std::min(
+              sockets_right_.size() + sockets_left_.size(),
+              nbytes / (size_ * min_send_size)),
+          size_t(1));
+      size_t step = ceildiv(size, n_reduces);
+      std::vector<std::future<void>> all_sums;
+
+      for (int i = 0; i < n_reduces; i++) {
+        all_sums.emplace_back(pool_.enqueue(std::bind(
+            &RingGroup::all_reduce_impl<T, ReduceOp>,
+            this,
+            reinterpret_cast<T*>(
+                buffers_.data() + i * ALL_SUM_SIZE * ALL_SUM_BUFFERS),
+            reinterpret_cast<T*>(out_ptr) + i * step,
+            std::min(size, (i + 1) * step) - i * step,
+            sockets_right_[i / 2],
+            sockets_left_[i / 2],
+            (i % 2) ? -1 : 1,
+            reduce_op)));
+      }
+      for (auto& f : all_sums) {
+        f.wait();
+      }
+    });
+  }
+
+  template <typename T, typename ReduceOp>
+  void all_reduce_impl(
+      T* buffer,
+      T* data,
+      size_t data_size,
+      int socket_right,
+      int socket_left,
+      int direction,
+      ReduceOp reduce_op) {
+    // Choose which socket we send to and recv from
+    int socket_send = (direction < 0) ? socket_right : socket_left;
+    int socket_recv = (direction < 0) ? socket_left : socket_right;
+
+    // We split the data into `size_` segments of size `segment_size` and each
+    // of these in smaller segments of ALL_SUM_SIZE which we 'll call packets.
+    size_t segment_size = ceildiv(data_size, size_);
+    size_t BUFFER_SIZE = std::max(
+        size_t(32768), std::min(ALL_SUM_SIZE / sizeof(T), segment_size / 2));
+    size_t n_packets = ceildiv(segment_size, BUFFER_SIZE);
+
+    // Initial segments
+    int send_segment = rank_;
+    int recv_segment = (rank_ + direction + size_) % size_;
+
+    // Plan the whole reduce in terms of sends and recvs as indices in data.
+    // It makes the actual async send and recv a bit simpler to follow when
+    // there are less offset calculations around.
+    std::vector<std::pair<size_t, size_t>> send_plan;
+    std::vector<std::pair<size_t, size_t>> recv_plan;
+
+    // Two times the same send/recv operations, first scatter reduce and then
+    // gather.
+    for (int k = 0; k < 2; k++) {
+      for (int i = 0; i < size_ - 1; i++) {
+        size_t send_start = send_segment * segment_size;
+        size_t send_stop =
+            std::min((send_segment + 1) * segment_size, data_size);
+        size_t recv_start = recv_segment * segment_size;
+        size_t recv_stop =
+            std::min((recv_segment + 1) * segment_size, data_size);
+
+        for (size_t j = 0; j < n_packets; j++) {
+          send_plan.emplace_back(
+              std::min(send_start + j * BUFFER_SIZE, send_stop),
+              std::min(send_start + (j + 1) * BUFFER_SIZE, send_stop));
+          recv_plan.emplace_back(
+              std::min(recv_start + j * BUFFER_SIZE, recv_stop),
+              std::min(recv_start + (j + 1) * BUFFER_SIZE, recv_stop));
+        }
+
+        send_segment = (send_segment + size_ + direction) % size_;
+        recv_segment = (recv_segment + size_ + direction) % size_;
+      }
+    }
+
+    // Running the plan is fairly simple, we keep a send and a recv in flight
+    // while doing the summation.
+    T* recv_buffers[ALL_SUM_BUFFERS];
+    for (int i = 0; i < ALL_SUM_BUFFERS; i++) {
+      recv_buffers[i] = buffer + i * BUFFER_SIZE;
+    }
+    std::future<void> sends[2], recvs[2];
+    int a = 0;
+    int b = (n_packets > 1) ? 1 : 0;
+    for (int i = 0, j = -b; i < send_plan.size(); j++, i++) {
+      sends[a] = comm_.send(
+          socket_send,
+          data + send_plan[i].first,
+          send_plan[i].second - send_plan[i].first);
+      if (2 * i < send_plan.size()) {
+        recvs[a] = comm_.recv(
+            socket_recv,
+            recv_buffers[i % ALL_SUM_BUFFERS],
+            recv_plan[i].second - recv_plan[i].first);
+      } else {
+        recvs[a] = comm_.recv(
+            socket_recv,
+            data + recv_plan[i].first,
+            recv_plan[i].second - recv_plan[i].first);
+      }
+
+      if (j >= 0) {
+        sends[b].wait();
+        recvs[b].wait();
+        if (2 * j < send_plan.size()) {
+          reduce_op(
+              recv_buffers[j % ALL_SUM_BUFFERS],
+              data + recv_plan[j].first,
+              recv_plan[j].second - recv_plan[j].first);
+        }
+      }
+
+      std::swap(a, b);
+    }
+    sends[b].wait();
+    recvs[b].wait();
+  }
+
+  void all_gather_impl(
+      const char* input,
+      char* output,
+      size_t input_size,
+      size_t data_size,
+      int socket_right,
+      int socket_left,
+      int direction) {
+    // Choose which socket we send to and recv from
+    int socket_send = (direction < 0) ? socket_right : socket_left;
+    int socket_recv = (direction < 0) ? socket_left : socket_right;
+
+    // Initial segments
+    int send_segment = rank_;
+    int recv_segment = (rank_ + direction + size_) % size_;
+
+    // Copy our own segment in the output
+    std::memcpy(output + rank_ * input_size, input, data_size);
+
+    // Simple send/recv all gather. Possible performance improvement by
+    // splitting to multiple chunks and allowing send/recv to run a bit ahead.
+    // See all_sum_impl for an example.
+    for (int i = 0; i < size_ - 1; i++) {
+      auto sent = comm_.send(
+          socket_send, output + send_segment * input_size, data_size);
+      auto recvd = comm_.recv(
+          socket_recv, output + recv_segment * input_size, data_size);
+
+      send_segment = (send_segment + size_ + direction) % size_;
+      recv_segment = (recv_segment + size_ + direction) % size_;
+
+      sent.wait();
+      recvd.wait();
+    }
+  }
+
+  void
+  send(const std::vector<int>& sockets, const char* data, size_t data_size) {
+    size_t segment_size =
+        std::max(size_t(1024), ceildiv(data_size, sockets.size()));
+    std::vector<std::future<void>> sends;
+    for (int i = 0; i < sockets.size(); i++) {
+      if (i * segment_size >= data_size) {
+        break;
+      }
+      sends.emplace_back(comm_.send(
+          sockets[i],
+          data + i * segment_size,
+          std::min(data_size, (i + 1) * segment_size) - i * segment_size));
+    }
+    for (auto& f : sends) {
+      f.wait();
+    }
+  }
+
+  void recv(const std::vector<int>& sockets, char* data, size_t data_size) {
+    size_t segment_size =
+        std::max(size_t(1024), ceildiv(data_size, sockets.size()));
+    std::vector<std::future<void>> recvs;
+    for (int i = 0; i < sockets.size(); i++) {
+      if (i * segment_size >= data_size) {
+        break;
+      }
+      recvs.emplace_back(comm_.recv(
+          sockets[i],
+          data + i * segment_size,
+          std::min(data_size, (i + 1) * segment_size) - i * segment_size));
+    }
+    for (auto& f : recvs) {
+      f.wait();
+    }
+  }
+
+  int rank_;
+  int size_;
+
+  bool verbose_;
+
+  ThreadPool pool_;
+  CommunicationThreads comm_;
+
+  std::vector<int> sockets_right_;
+  std::vector<int> sockets_left_;
+
+  std::vector<char> buffers_;
+};
+
+bool is_available() {
+  return true;
+}
+
+std::shared_ptr<GroupImpl> init(bool strict /* = false */) {
+  const char* hostfile = std::getenv("MLX_HOSTFILE");
+  const char* rank_str = std::getenv("MLX_RANK");
+  const char* ring_verbose = std::getenv("MLX_RING_VERBOSE");
+
+  if (!hostfile || !rank_str) {
+    if (strict) {
+      std::ostringstream msg;
+      msg << "[ring] You need to provide via environment variables both a rank (MLX_RANK) "
+          << "and a hostfile (MLX_HOSTFILE) but provided MLX_RANK=\""
+          << ((rank_str) ? rank_str : "") << "\" and MLX_HOSTFILE=\""
+          << ((hostfile) ? hostfile : "") << "\"";
+      throw std::runtime_error(msg.str());
+    }
+    return nullptr;
+  }
+
+  auto nodes = load_nodes(hostfile);
+  int rank = std::atoi(rank_str);
+
+  return std::make_shared<RingGroup>(rank, nodes, ring_verbose != nullptr);
+}
+
+} // namespace mlx::core::distributed::ring
diff --git a/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.h b/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.h
new file mode 100644
index 0000000000000000000000000000000000000000..e0b3fd093c624dd634f9f900f4f7a42f58d89725
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/distributed/ring/ring.h
@@ -0,0 +1,12 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/distributed/distributed.h"
+
+namespace mlx::core::distributed::ring {
+
+using GroupImpl = mlx::core::distributed::detail::GroupImpl;
+
+bool is_available();
+std::shared_ptr<GroupImpl> init(bool strict = false);
+
+} // namespace mlx::core::distributed::ring
diff --git a/ml-stable-diffusion/mlx/mlx/dtype.cpp b/ml-stable-diffusion/mlx/mlx/dtype.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..429fa420204bf96aa301ce7fd8f03100d8e00d2e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/dtype.cpp
@@ -0,0 +1,182 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <cstdint>
+
+#include "mlx/dtype.h"
+
+namespace mlx::core {
+
+namespace {
+
+constexpr int num_types = 14;
+constexpr int num_cats = 8;
+
+constexpr Dtype::Kind type_kinds[num_types] = {
+    Dtype::Kind::b, // bool_,
+    Dtype::Kind::u, // uint8,
+    Dtype::Kind::u, // uint16,
+    Dtype::Kind::u, // uint32,
+    Dtype::Kind::u, // uint64,
+    Dtype::Kind::i, // int8,
+    Dtype::Kind::i, // int16,
+    Dtype::Kind::i, // int32,
+    Dtype::Kind::i, // int64,
+    Dtype::Kind::f, // float16,
+    Dtype::Kind::f, // float32,
+    Dtype::Kind::f, // float64,
+    Dtype::Kind::V, // bfloat16,
+    Dtype::Kind::c // complex64,
+};
+
+// Following Jax type promotion rules:
+// https://jax.readthedocs.io/en/latest/type_promotion.html
+// clang-format off
+constexpr Dtype type_rules[num_types][num_types] = {
+// bool       uint8      uint16     uint32     uint64     int8       int16      int32      int64      float16    float32   float64    bfloat16   complex64
+  {bool_,     uint8,     uint16,    uint32,    uint64,    int8,      int16,     int32,     int64,     float16,   float32,  float64,   bfloat16,  complex64}, // bool
+  {uint8,     uint8,     uint16,    uint32,    uint64,    int16,     int16,     int32,     int64,     float16,   float32,  float64,   bfloat16,  complex64}, // uint8
+  {uint16,    uint16,    uint16,    uint32,    uint64,    int32,     int32,     int32,     int64,     float16,   float32,  float64,   bfloat16,  complex64}, // uint16
+  {uint32,    uint32,    uint32,    uint32,    uint64,    int64,     int64,     int64,     int64,     float16,   float32,  float64,   bfloat16,  complex64}, // uint32
+  {uint64,    uint64,    uint64,    uint64,    uint64,    float32,   float32,   float32,   float32,   float16,   float32,  float64,   bfloat16,  complex64}, // uint64
+  {int8,      int16,     int32,     int64,     float32,   int8,      int16,     int32,     int64,     float16,   float32,  float64,   bfloat16,  complex64}, // int8
+  {int16,     int16,     int32,     int64,     float32,   int16,     int16,     int32,     int64,     float16,   float32,  float64,   bfloat16,  complex64}, // int16
+  {int32,     int32,     int32,     int64,     float32,   int32,     int32,     int32,     int64,     float16,   float32,  float64,   bfloat16,  complex64}, // int32
+  {int64,     int64,     int64,     int64,     float32,   int64,     int64,     int64,     int64,     float16,   float32,  float64,   bfloat16,  complex64}, // int64
+  {float16,   float16,   float16,   float16,   float16,   float16,   float16,   float16,   float16,   float16,   float32,  float64,   float32,   complex64}, // float16
+  {float32,   float32,   float32,   float32,   float32,   float32,   float32,   float32,   float32,   float32,   float32,  float64,   float32,   complex64}, // float32
+  {float64,   float64,   float64,   float64,   float64,   float64,   float64,   float64,   float64,   float64,   float64,  float64,   float64,   complex64}, // float64
+  {bfloat16,  bfloat16,  bfloat16,  bfloat16,  bfloat16,  bfloat16,  bfloat16,  bfloat16,  bfloat16,  float32,   float32,  float64,   bfloat16,  complex64}, // bfloat16
+  {complex64, complex64, complex64, complex64, complex64, complex64, complex64, complex64, complex64, complex64, complex64,complex64, complex64, complex64}, // complex64
+};
+
+
+constexpr bool subcategory_to_category[num_cats][num_cats] = {
+// complexfloating floating inexact signedinteger unsignedinteger integer number generic
+  {true,           false,   true,   false,        false,          false,  true,  true}, // complexfloating
+  {false,          true,    true,   false,        false,          false,  true,  true}, // floating
+  {false,          false,   true,   false,        false,          false,  true,  true}, // inexact
+  {false,          false,   false,  true,         false,          true,   true,  true}, // signedinteger
+  {false,          false,   false,  false,        true,           true,   true,  true}, // unsignedinteger
+  {false,          false,   false,  false,        false,          true,   true,  true}, // integer
+  {false,          false,   false,  false,        false,          false,  true,  true}, // number
+  {false,          false,   false,  false,        false,          false,  false, true}, // generic
+};
+
+constexpr Dtype::Category type_to_category[num_types] = {
+    Dtype::Category::generic, // bool_,
+    Dtype::Category::unsignedinteger, // uint8,
+    Dtype::Category::unsignedinteger, // uint16,
+    Dtype::Category::unsignedinteger, // uint32,
+    Dtype::Category::unsignedinteger, // uint64,
+    Dtype::Category::signedinteger, // int8,
+    Dtype::Category::signedinteger, // int16,
+    Dtype::Category::signedinteger, // int32,
+    Dtype::Category::signedinteger, // int64,
+    Dtype::Category::floating, // float16,
+    Dtype::Category::floating, // float32,
+    Dtype::Category::floating, // float64,
+    Dtype::Category::floating, // bfloat16,
+    Dtype::Category::complexfloating, // complex64,
+};
+
+// clang-format on
+
+} // namespace
+
+Dtype promote_types(const Dtype& t1, const Dtype& t2) {
+  return Dtype(
+      type_rules[static_cast<int>(t1.val())][static_cast<int>(t2.val())]);
+}
+
+Dtype::Kind kindof(const Dtype& t) {
+  return type_kinds[static_cast<int>(t.val())];
+}
+
+template <>
+TypeToDtype<bool>::operator Dtype() {
+  return bool_;
+}
+
+template <>
+TypeToDtype<uint8_t>::operator Dtype() {
+  return uint8;
+}
+
+template <>
+TypeToDtype<uint16_t>::operator Dtype() {
+  return uint16;
+}
+
+template <>
+TypeToDtype<uint32_t>::operator Dtype() {
+  return uint32;
+}
+
+template <>
+TypeToDtype<uint64_t>::operator Dtype() {
+  return uint64;
+}
+
+template <>
+TypeToDtype<int8_t>::operator Dtype() {
+  return int8;
+}
+
+template <>
+TypeToDtype<int16_t>::operator Dtype() {
+  return int16;
+}
+
+template <>
+TypeToDtype<int32_t>::operator Dtype() {
+  return int32;
+}
+
+template <>
+TypeToDtype<int64_t>::operator Dtype() {
+  return int64;
+}
+
+template <>
+TypeToDtype<float16_t>::operator Dtype() {
+  return float16;
+}
+
+template <>
+TypeToDtype<float>::operator Dtype() {
+  return float32;
+}
+
+template <>
+TypeToDtype<double>::operator Dtype() {
+  return float32;
+}
+
+template <>
+TypeToDtype<bfloat16_t>::operator Dtype() {
+  return bfloat16;
+}
+
+template <>
+TypeToDtype<complex64_t>::operator Dtype() {
+  return complex64;
+}
+
+bool issubdtype(const Dtype& a, const Dtype& b) {
+  return a == b;
+}
+
+bool issubdtype(const Dtype::Category& cat, const Dtype& type) {
+  return false;
+}
+
+bool issubdtype(const Dtype& type, const Dtype::Category& cat) {
+  return issubdtype(type_to_category[static_cast<uint32_t>(type.val())], cat);
+}
+
+bool issubdtype(const Dtype::Category& a, const Dtype::Category& b) {
+  return subcategory_to_category[static_cast<uint32_t>(a)]
+                                [static_cast<uint32_t>(b)];
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/dtype.h b/ml-stable-diffusion/mlx/mlx/dtype.h
new file mode 100644
index 0000000000000000000000000000000000000000..e02b6ca35fd3298fecadc5f9651b28c8b6ba9780
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/dtype.h
@@ -0,0 +1,115 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <complex>
+#include <cstdint>
+
+#include "mlx/types/complex.h"
+#include "mlx/types/half_types.h"
+
+namespace mlx::core {
+
+struct Dtype {
+  enum class Val {
+    bool_,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+    int8,
+    int16,
+    int32,
+    int64,
+    float16,
+    float32,
+    float64,
+    bfloat16,
+    complex64,
+  };
+
+  enum class Kind {
+    b, /* bool */
+    u, /* unsigned int */
+    i, /* signed int */
+    f, /* float */
+    c, /* complex */
+    V, /* void - used for brain float */
+  };
+
+  enum class Category {
+    complexfloating,
+    floating,
+    inexact,
+    signedinteger,
+    unsignedinteger,
+    integer,
+    number,
+    generic
+  };
+
+  constexpr explicit Dtype(Val val, uint8_t size) : val_(val), size_(size) {}
+
+  constexpr operator Val() const {
+    return val_;
+  }
+  constexpr Val val() const {
+    return val_;
+  }
+  constexpr uint8_t size() const {
+    return size_;
+  }
+
+ private:
+  Val val_;
+  uint8_t size_;
+};
+
+inline constexpr Dtype bool_{Dtype::Val::bool_, sizeof(bool)};
+
+inline constexpr Dtype uint8{Dtype::Val::uint8, sizeof(uint8_t)};
+inline constexpr Dtype uint16{Dtype::Val::uint16, sizeof(uint16_t)};
+inline constexpr Dtype uint32{Dtype::Val::uint32, sizeof(uint32_t)};
+inline constexpr Dtype uint64{Dtype::Val::uint64, sizeof(uint64_t)};
+
+inline constexpr Dtype int8{Dtype::Val::int8, sizeof(int8_t)};
+inline constexpr Dtype int16{Dtype::Val::int16, sizeof(int16_t)};
+inline constexpr Dtype int32{Dtype::Val::int32, sizeof(int32_t)};
+inline constexpr Dtype int64{Dtype::Val::int64, sizeof(int64_t)};
+
+inline constexpr Dtype float16{Dtype::Val::float16, sizeof(uint16_t)};
+inline constexpr Dtype float32{Dtype::Val::float32, sizeof(float)};
+inline constexpr Dtype float64{Dtype::Val::float64, sizeof(double)};
+inline constexpr Dtype bfloat16{Dtype::Val::bfloat16, sizeof(uint16_t)};
+inline constexpr Dtype complex64{Dtype::Val::complex64, sizeof(complex64_t)};
+
+inline constexpr Dtype::Category complexfloating =
+    Dtype::Category::complexfloating;
+inline constexpr Dtype::Category floating = Dtype::Category::floating;
+inline constexpr Dtype::Category inexact = Dtype::Category::inexact;
+inline constexpr Dtype::Category signedinteger = Dtype::Category::signedinteger;
+inline constexpr Dtype::Category unsignedinteger =
+    Dtype::Category::unsignedinteger;
+inline constexpr Dtype::Category integer = Dtype::Category::integer;
+inline constexpr Dtype::Category number = Dtype::Category::number;
+inline constexpr Dtype::Category generic = Dtype::Category::generic;
+
+bool issubdtype(const Dtype& a, const Dtype& b);
+bool issubdtype(const Dtype::Category& a, const Dtype& b);
+bool issubdtype(const Dtype& a, const Dtype::Category& b);
+bool issubdtype(const Dtype::Category& a, const Dtype::Category& b);
+
+Dtype promote_types(const Dtype& t1, const Dtype& t2);
+
+inline uint8_t size_of(const Dtype& t) {
+  return t.size();
+}
+
+Dtype::Kind kindof(const Dtype& t);
+
+template <typename T>
+struct TypeToDtype {
+  operator Dtype();
+};
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp b/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9f10e6a9a93a95be86bba7878ec26b5c8cb882ed
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/dtype_utils.cpp
@@ -0,0 +1,42 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/dtype_utils.h"
+
+namespace mlx::core {
+
+const char* dtype_to_string(Dtype arg) {
+  switch (arg) {
+    case bool_:
+      return "bool";
+    case int8:
+      return "int8";
+    case int16:
+      return "int16";
+    case int32:
+      return "int32";
+    case int64:
+      return "int64";
+    case uint8:
+      return "uint8";
+    case uint16:
+      return "uint16";
+    case uint32:
+      return "uint32";
+    case uint64:
+      return "uint64";
+    case float16:
+      return "float16";
+    case bfloat16:
+      return "bfloat16";
+    case float32:
+      return "float32";
+    case float64:
+      return "float64";
+    case complex64:
+      return "complex64";
+    default:
+      return "unknown";
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/dtype_utils.h b/ml-stable-diffusion/mlx/mlx/dtype_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..47c6ed66126000e1817b5175755ef8ec5866224b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/dtype_utils.h
@@ -0,0 +1,119 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include <sstream>
+
+#include "mlx/dtype.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+// Return string representation of dtype.
+const char* dtype_to_string(Dtype arg);
+
+#define MLX_INTERNAL_DTYPE_SWITCH_CASE(DTYPE, TYPE) \
+  case DTYPE:                                       \
+    f(type_identity<TYPE>{});                       \
+    break
+
+#define MLX_INTERNAL_DTYPE_SWITCH_INTS()            \
+  MLX_INTERNAL_DTYPE_SWITCH_CASE(int8, int8_t);     \
+  MLX_INTERNAL_DTYPE_SWITCH_CASE(int16, int16_t);   \
+  MLX_INTERNAL_DTYPE_SWITCH_CASE(int32, int32_t);   \
+  MLX_INTERNAL_DTYPE_SWITCH_CASE(int64, int64_t);   \
+  MLX_INTERNAL_DTYPE_SWITCH_CASE(uint8, uint8_t);   \
+  MLX_INTERNAL_DTYPE_SWITCH_CASE(uint16, uint16_t); \
+  MLX_INTERNAL_DTYPE_SWITCH_CASE(uint32, uint32_t); \
+  MLX_INTERNAL_DTYPE_SWITCH_CASE(uint64, uint64_t)
+
+#define MLX_INTERNAL_DTYPE_SWITCH_FLOATS()              \
+  MLX_INTERNAL_DTYPE_SWITCH_CASE(float16, float16_t);   \
+  MLX_INTERNAL_DTYPE_SWITCH_CASE(bfloat16, bfloat16_t); \
+  MLX_INTERNAL_DTYPE_SWITCH_CASE(float32, float);       \
+  MLX_INTERNAL_DTYPE_SWITCH_CASE(float64, double)
+
+// This already exists in C++20 but in C++20 we can also just use templated
+// lambdas which will make this so much nicer.
+template <typename T>
+struct type_identity {
+  using type = T;
+};
+
+#define MLX_GET_TYPE(x) typename decltype(x)::type
+#define MLX_GET_VALUE(x) decltype(x)::value
+
+template <typename F>
+void dispatch_all_types(Dtype dt, F&& f) {
+  switch (dt) {
+    MLX_INTERNAL_DTYPE_SWITCH_CASE(bool_, bool);
+    MLX_INTERNAL_DTYPE_SWITCH_INTS();
+    MLX_INTERNAL_DTYPE_SWITCH_FLOATS();
+    MLX_INTERNAL_DTYPE_SWITCH_CASE(complex64, complex64_t);
+  }
+}
+
+template <typename F>
+void dispatch_int_types(Dtype dt, std::string_view tag, F&& f) {
+  switch (dt) {
+    MLX_INTERNAL_DTYPE_SWITCH_INTS();
+    default:
+      std::ostringstream msg;
+      msg << tag << " Only integer types supported but " << dt
+          << " was provided";
+      throw std::invalid_argument(msg.str());
+  }
+}
+
+template <typename F>
+void dispatch_float_types(Dtype dt, std::string_view tag, F&& f) {
+  switch (dt) {
+    MLX_INTERNAL_DTYPE_SWITCH_FLOATS();
+    default:
+      std::ostringstream msg;
+      msg << tag << " Only float types supported but " << dt << " was provided";
+      throw std::invalid_argument(msg.str());
+  }
+}
+
+template <typename F>
+void dispatch_inexact_types(Dtype dt, std::string_view tag, F&& f) {
+  switch (dt) {
+    MLX_INTERNAL_DTYPE_SWITCH_FLOATS();
+    MLX_INTERNAL_DTYPE_SWITCH_CASE(complex64, complex64_t);
+    default:
+      std::ostringstream msg;
+      msg << tag << " Only inexact (float/complex) types supported but " << dt
+          << " was provided";
+      throw std::invalid_argument(msg.str());
+  }
+}
+
+template <typename F>
+void dispatch_int_float_types(Dtype dt, std::string_view tag, F&& f) {
+  switch (dt) {
+    MLX_INTERNAL_DTYPE_SWITCH_INTS();
+    MLX_INTERNAL_DTYPE_SWITCH_FLOATS();
+    default:
+      std::ostringstream msg;
+      msg << tag << " Only integer and float types supported but " << dt
+          << " was provided";
+      throw std::invalid_argument(msg.str());
+  }
+}
+
+template <typename F>
+void dispatch_real_types(Dtype dt, std::string_view tag, F&& f) {
+  switch (dt) {
+    MLX_INTERNAL_DTYPE_SWITCH_CASE(bool_, bool);
+    MLX_INTERNAL_DTYPE_SWITCH_INTS();
+    MLX_INTERNAL_DTYPE_SWITCH_FLOATS();
+    default:
+      std::ostringstream msg;
+      msg << tag << " Only real numbers supported but " << dt
+          << " was provided";
+      throw std::invalid_argument(msg.str());
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/einsum.cpp b/ml-stable-diffusion/mlx/mlx/einsum.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cfc9fb2adcc44f546a4520020982ef352b643853
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/einsum.cpp
@@ -0,0 +1,929 @@
+// Copyright © 2024 Apple Inc.
+#include <numeric>
+#include <sstream>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "mlx/einsum.h"
+#include "mlx/ops.h"
+
+namespace mlx::core {
+
+namespace {
+
+// The MLX einsum implementation is based on NumPy (which is based on
+// opt_einsum):
+// https://github.com/numpy/numpy/blob/1d49c7f7ff527c696fc26ab2278ad51632a66660/numpy/_core/einsumfunc.py#L743
+// https://github.com/dgasmith/opt_einsum
+
+using CharSet = std::unordered_set<char>;
+
+// A helper struct to hold the string and set
+// representation of a subscript to avoid needing
+// to recompute the set
+struct Subscript {
+  Subscript(std::string str, CharSet set)
+      : str(std::move(str)), set(std::move(set)) {};
+  std::string str;
+  CharSet set;
+};
+
+struct PathInfo {
+  size_t naive_cost;
+  size_t naive_scaling;
+  size_t optimized_cost;
+  size_t optimized_scaling;
+  size_t largest_term;
+};
+
+struct PathNode {
+  PathNode(
+      std::vector<Subscript> inputs,
+      Subscript output,
+      std::vector<int> positions)
+      : inputs(std::move(inputs)),
+        output(std::move(output)),
+        positions(std::move(positions)) {};
+
+  std::vector<Subscript> inputs;
+  Subscript output;
+
+  std::vector<int> positions;
+};
+
+// Parse the comma separated subscripts into a vector of strings. If the
+// output subscripts are missing they are inferred.
+//
+// For example:
+//  "ij,jk -> ik" becomes {{"ij", "jk"}, "ik"}
+//  "ij,jk" becomes {{"ij", "jk"}, "ik"}
+std::pair<std::vector<std::string>, std::string> parse(std::string subscripts) {
+  std::string lhs, rhs;
+
+  // Start by removing all white space
+  subscripts.erase(
+      std::remove(subscripts.begin(), subscripts.end(), ' '), subscripts.end());
+
+  if (auto pos = subscripts.find("->"); pos != std::string::npos) {
+    // Explicit mode
+    lhs = subscripts.substr(0, pos);
+    rhs = subscripts.substr(pos + 2);
+  } else {
+    // Implicit mode:
+    // - repeats are summed
+    // - ellipses are placed in the beginning of the output
+    // - remaining output axes are ordered alphabetically
+    lhs = subscripts;
+    std::unordered_map<char, int> temp;
+    for (auto& c : subscripts) {
+      if (c == ',') {
+        continue;
+      }
+      if (c == '.' && rhs.empty()) {
+        rhs += "...";
+        continue;
+      }
+
+      auto inserted = temp.insert({c, 0});
+      inserted.first->second++;
+    }
+    for (auto& k : temp) {
+      if (k.second == 1) {
+        rhs += k.first;
+      }
+    }
+    std::sort(rhs.begin(), rhs.end());
+  }
+  std::vector<std::string> input_list;
+  std::stringstream ss(lhs);
+  std::string token;
+  while (getline(ss, token, ',')) {
+    input_list.push_back(token);
+  }
+  return {input_list, rhs};
+}
+
+// Check if two sets are disjoint
+bool disjoint(const CharSet& x, const CharSet& y) {
+  for (auto& c : x) {
+    if (y.find(c) != y.end()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+template <typename T>
+size_t term_size(const T& term, std::unordered_map<char, ShapeElem> dict) {
+  size_t size = 1;
+  for (auto c : term) {
+    size *= dict[c];
+  }
+  return size;
+}
+
+size_t flop_count(
+    const CharSet& term,
+    bool inner,
+    int num_terms,
+    std::unordered_map<char, ShapeElem> dict) {
+  size_t size = term_size(term, dict);
+  auto op_factor = 1;
+  if ((num_terms - 1) > op_factor) {
+    op_factor = num_terms - 1;
+  }
+  if (inner) {
+    op_factor += 1;
+  }
+  return size * op_factor;
+}
+
+std::pair<size_t, int> compute_cost_and_scaling(
+    const std::vector<Subscript>& inputs,
+    const Subscript& output,
+    std::unordered_map<char, ShapeElem> dim_map) {
+  CharSet contractions;
+  for (auto& in : inputs) {
+    contractions.insert(in.set.begin(), in.set.end());
+  }
+
+  bool inner = false;
+  for (auto c : contractions) {
+    if (output.set.find(c) == output.set.end()) {
+      inner = true;
+      break;
+    }
+  }
+  auto cost = flop_count(contractions, inner, inputs.size(), dim_map);
+  return {cost, contractions.size()};
+}
+
+std::tuple<std::vector<PathNode>, size_t, int> greedy_path(
+    std::vector<Subscript> inputs,
+    const Subscript& output,
+    std::unordered_map<char, ShapeElem> dim_map,
+    size_t cost_limit,
+    size_t memory_limit) {
+  // Helper struct for building the greedy path
+  struct Contraction {
+    Contraction(
+        size_t size,
+        size_t cost,
+        CharSet output,
+        int dims,
+        int x,
+        int y)
+        : size(size),
+          cost(cost),
+          output(std::move(output)),
+          dims(dims),
+          x(x),
+          y(y) {};
+
+    int64_t size; // Size difference, can be negative
+    size_t cost;
+    CharSet output;
+    int dims; // Number of dimensions in the contraction
+    int x;
+    int y;
+  };
+
+  // Start by iterating over all possible combinations
+  std::vector<std::pair<int, int>> pos_pairs;
+  for (int i = 0; i < inputs.size(); ++i) {
+    for (int j = i + 1; j < inputs.size(); ++j) {
+      pos_pairs.emplace_back(i, j);
+    }
+  }
+
+  std::vector<PathNode> path;
+  std::vector<Contraction> possible_contractions;
+  size_t path_cost = 0;
+  int path_scaling = 0;
+  auto num_in = inputs.size();
+  for (int i = 0; i < num_in - 1; ++i) {
+    auto add_contraction = [&](int p1, int p2) {
+      CharSet new_term;
+      CharSet contractions(inputs[p1].set.begin(), inputs[p1].set.end());
+      contractions.insert(inputs[p2].set.begin(), inputs[p2].set.end());
+      for (int i = 0; i < inputs.size(); i++) {
+        if (i == p1 || i == p2) {
+          continue;
+        }
+        auto& in = inputs[i].set;
+        for (auto c : in) {
+          if (contractions.find(c) != contractions.end()) {
+            new_term.insert(c);
+          }
+        }
+      }
+      for (auto c : output.set) {
+        if (contractions.find(c) != contractions.end()) {
+          new_term.insert(c);
+        }
+      }
+
+      // Ignore if:
+      // - The size of the new result is greater than the memory limit
+      // - The cost is larger than the naive cost
+      auto new_size = term_size(new_term, dim_map);
+      if (new_size > memory_limit) {
+        return;
+      }
+      int64_t removed_size = term_size(inputs[p1].set, dim_map) +
+          term_size(inputs[p2].set, dim_map) - new_size;
+
+      bool inner = contractions.size() > new_term.size();
+      auto cost = flop_count(contractions, inner, 2, dim_map);
+      if (path_cost + cost > cost_limit) {
+        return;
+      }
+      possible_contractions.emplace_back(
+          removed_size, cost, std::move(new_term), contractions.size(), p1, p2);
+    };
+
+    for (auto& [p1, p2] : pos_pairs) {
+      // Ignore outer products
+      if (!disjoint(inputs[p1].set, inputs[p2].set)) {
+        add_contraction(p1, p2);
+      }
+    }
+
+    // If there's nothing in the contraction list,
+    // go over the pairs again without ignoring outer products
+    if (possible_contractions.empty()) {
+      for (auto& [p1, p2] : pos_pairs) {
+        add_contraction(p1, p2);
+      }
+    }
+
+    if (possible_contractions.empty()) {
+      // Default to naive einsum for the remaining inputs
+      std::vector<int> positions(inputs.size());
+      std::iota(positions.begin(), positions.end(), 0);
+      auto [cost, scale] = compute_cost_and_scaling(inputs, output, dim_map);
+      path.emplace_back(std::move(inputs), output, std::move(positions));
+
+      path_cost += cost;
+      path_scaling = std::max(scale, path_scaling);
+      break;
+    }
+
+    // Find the best contraction
+    auto& best = *std::min_element(
+        possible_contractions.begin(),
+        possible_contractions.end(),
+        [](const auto& x, const auto& y) {
+          return x.size > y.size || (x.size == y.size && x.cost < y.cost);
+        });
+    path_scaling = std::max(best.dims, path_scaling);
+
+    // Construct the output subscripts
+    std::string out_str(best.output.begin(), best.output.end());
+    // TODO, sorting by dimension size seems suboptimal?
+    std::sort(out_str.begin(), out_str.end(), [&dim_map](auto x, auto y) {
+      return dim_map[x] < dim_map[y];
+    });
+    Subscript new_output(std::move(out_str), std::move(best.output));
+
+    // Add the chosen contraction to the path
+    {
+      std::vector<Subscript> in_terms;
+      in_terms.push_back(std::move(inputs[best.x]));
+      in_terms.push_back(std::move(inputs[best.y]));
+      path.emplace_back(
+          std::move(in_terms), new_output, std::vector<int>{best.x, best.y});
+    }
+    // Remove used terms
+    inputs.erase(inputs.begin() + best.y);
+    inputs.erase(inputs.begin() + best.x);
+
+    // Add the new result
+    inputs.push_back(std::move(new_output));
+
+    // Update the existing contractions based on the selected one
+    std::vector<Contraction> updated_contractions;
+    for (auto& contraction : possible_contractions) {
+      // Drop contractions which contain either selected term
+      if (contraction.x == best.x || contraction.x == best.y ||
+          contraction.y == best.x || contraction.y == best.y) {
+        continue;
+      }
+
+      // Update the positions of other contractions
+      int x =
+          contraction.x - (contraction.x > best.x) - (contraction.x > best.y);
+      int y =
+          contraction.y - (contraction.y > best.x) - (contraction.y > best.y);
+      contraction.x = x;
+      contraction.y = y;
+      updated_contractions.push_back(std::move(contraction));
+    }
+
+    pos_pairs.clear();
+    for (int i = 0; i < inputs.size() - 1; ++i) {
+      pos_pairs.emplace_back(i, inputs.size() - 1);
+    }
+    path_cost += best.cost;
+
+    possible_contractions = std::move(updated_contractions);
+  }
+  return {path, path_cost, path_scaling};
+}
+
+// Assumes inputs have already have had repeats and single axis sums collapsed
+bool can_dot(const std::vector<Subscript>& inputs, const Subscript& output) {
+  if (inputs.size() != 2) {
+    return false;
+  }
+
+  for (auto c : inputs[0].set) {
+    // Use batched tensordot if anything is being contracted
+    if (output.set.find(c) == output.set.end()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+array batch_tensordot(
+    array a,
+    array b,
+    std::vector<int> a_contract,
+    std::vector<int> a_batch,
+    std::vector<int> a_concat,
+    std::vector<int> b_contract,
+    std::vector<int> b_batch,
+    std::vector<int> b_concat,
+    StreamOrDevice s) {
+  // Broadcast contracting dimensions
+  {
+    auto a_shape = a.shape();
+    auto b_shape = b.shape();
+    for (int i = 0; i < a_contract.size(); ++i) {
+      auto d = std::max(a.shape(a_contract[i]), b.shape(b_contract[i]));
+      a_shape[a_contract[i]] = d;
+      b_shape[b_contract[i]] = d;
+    }
+    a = broadcast_to(a, a_shape, s);
+    b = broadcast_to(b, b_shape, s);
+  }
+  auto transpose_reshape = [&s](
+                               const array& x,
+                               const std::vector<int>& i,
+                               const std::vector<int>& j,
+                               const std::vector<int>& k) {
+    std::vector<int> reorder(i.begin(), i.end());
+    reorder.insert(reorder.end(), j.begin(), j.end());
+    reorder.insert(reorder.end(), k.begin(), k.end());
+
+    int size1 = 1;
+    for (auto s : j) {
+      size1 *= x.shape(s);
+    }
+
+    int size2 = 1;
+    for (auto s : k) {
+      size2 *= x.shape(s);
+    }
+
+    Shape shape;
+    for (auto ax : i) {
+      shape.push_back(x.shape(ax));
+    }
+    shape.push_back(size1);
+    shape.push_back(size2);
+
+    return reshape(transpose(x, reorder, s), std::move(shape), s);
+  };
+
+  Shape out_shape;
+  for (auto ax : a_batch) {
+    out_shape.push_back(a.shape(ax));
+  }
+  for (auto ax : a_concat) {
+    out_shape.push_back(a.shape(ax));
+  }
+  for (auto ax : b_concat) {
+    out_shape.push_back(b.shape(ax));
+  }
+
+  a = transpose_reshape(a, a_batch, a_concat, a_contract);
+  b = transpose_reshape(b, b_batch, b_contract, b_concat);
+
+  return reshape(matmul(a, b, s), std::move(out_shape), s);
+}
+
+// Collapse repeated subscripts and return the resulting array. The subscript
+// is also updated in place. For example:
+// - Given an input with shape (4, 4) and subscript "ii", returns
+//   the diagonal of shape (4,) and updates the subscript to "i".
+// - Given an input with shape (4, 2, 4, 2) and subscript "ijij",
+//   returns an output with shape (4, 2) and updates the subscript
+//   to "ij".
+array collapse_repeats(array in, Subscript& subscript, StreamOrDevice s) {
+  // Build a list of (repeat chars, num repeats)
+  auto& str = subscript.str;
+  std::vector<std::pair<char, int>> repeats;
+  std::string new_str;
+  {
+    std::string repeat_str;
+    std::string no_repeat_str;
+    std::unordered_map<char, int> counts;
+    for (int i = 0; i < str.size(); ++i) {
+      auto [it, _] = counts.insert({str[i], 0});
+      it->second++;
+    }
+
+    for (auto& v : counts) {
+      if (v.second > 1) {
+        repeats.emplace_back(v.first, v.second);
+        repeat_str += v.first;
+      }
+    }
+    for (auto& c : str) {
+      if (counts[c] == 1) {
+        no_repeat_str += c;
+      }
+    }
+    new_str = repeat_str + no_repeat_str;
+  }
+
+  // Build the inputs for gather
+  auto slice_sizes = in.shape();
+  std::vector<int> axes;
+  std::vector<array> indices;
+  int n_expand = repeats.size();
+  for (auto [c, v] : repeats) {
+    for (int i = 0; i < str.size(); ++i) {
+      if (str[i] == c) {
+        slice_sizes[i] = 1;
+        axes.push_back(i);
+      }
+    }
+    Shape idx_shape(n_expand--, 1);
+    idx_shape[0] = in.shape(axes.back());
+    auto idx = reshape(
+        arange(static_cast<ShapeElem>(in.shape(axes.back())), s), idx_shape, s);
+    for (int i = 0; i < v; ++i) {
+      indices.push_back(idx);
+    }
+  }
+
+  in = gather(in, indices, axes, slice_sizes, s);
+
+  // Update subscript string with removed dups
+  str = new_str;
+
+  // Squeeze singleton dimensions left over from the gather
+  for (auto& ax : axes) {
+    ax += indices[0].ndim();
+  }
+
+  return squeeze(in, axes, s);
+}
+
+// Collapse repeat indices and sum single dimensions.
+// For example:
+// - "aa" becomes "a"
+// - "ij,jk->k" becoms "j,jk->k"
+void preprocess_einsum_inputs(
+    std::vector<Subscript>& inputs,
+    const Subscript& output,
+    const std::vector<int>& positions,
+    std::vector<array>& operands,
+    StreamOrDevice s) {
+  // Collapse repeat indices
+  for (int i = 0; i < inputs.size(); ++i) {
+    auto& in = inputs[i];
+    if (in.set.size() < in.str.size()) {
+      operands[positions[i]] = collapse_repeats(operands[positions[i]], in, s);
+    }
+  }
+
+  // Sum indices that are only in a single input
+  {
+    std::unordered_map<char, int> counts;
+    for (auto& in : inputs) {
+      for (auto c : in.set) {
+        auto inserted = counts.insert({c, 0});
+        inserted.first->second++;
+      }
+    }
+    for (auto c : output.set) {
+      auto inserted = counts.insert({c, 0});
+      inserted.first->second++;
+    }
+    for (int i = 0; i < inputs.size(); ++i) {
+      auto& in = inputs[i];
+      std::vector<int> sum_axes;
+      for (int ax = 0; ax < in.str.size(); ++ax) {
+        if (counts[in.str[ax]] == 1) {
+          sum_axes.push_back(ax);
+        }
+      }
+      if (!sum_axes.empty()) {
+        operands[positions[i]] =
+            sum(operands[positions[i]], sum_axes, false, s);
+      }
+      for (auto it = sum_axes.rbegin(); it != sum_axes.rend(); ++it) {
+        in.set.erase(in.str[*it]);
+        in.str.erase(in.str.begin() + *it);
+      }
+    }
+  }
+}
+
+array einsum_naive(
+    std::vector<Subscript> inputs,
+    const Subscript& output,
+    const std::vector<int>& positions,
+    std::vector<array> operands,
+    StreamOrDevice s) {
+  // Map each character to an axis
+  std::unordered_map<char, int> char_to_ax;
+  for (auto& in : inputs) {
+    for (auto c : in.str) {
+      char_to_ax.insert({c, char_to_ax.size()});
+    }
+  }
+
+  // Expand and transpose inputs as needed
+  for (int i = 0; i < inputs.size(); ++i) {
+    int pos = positions[i];
+    auto& op = operands[pos];
+
+    // Add missing dimensions at the end
+    if (op.ndim() != char_to_ax.size()) {
+      auto shape = op.shape();
+      shape.insert(shape.end(), char_to_ax.size() - shape.size(), 1);
+      op = reshape(op, std::move(shape), s);
+    }
+
+    // Transpose:
+    // - Build a vector of (char, ax) pairs for the current input
+    // - Sort the vector by the canonical axis in char_to_ax
+    // - Extract the sorted axis to get transpose order
+    std::vector<std::pair<char, int>> str_ax;
+    for (auto c : inputs[i].str) {
+      str_ax.emplace_back(c, str_ax.size());
+    }
+    for (auto [c, ax] : char_to_ax) {
+      if (inputs[i].set.find(c) == inputs[i].set.end()) {
+        str_ax.emplace_back(c, str_ax.size());
+      }
+    }
+    std::sort(
+        str_ax.begin(),
+        str_ax.end(),
+        [&char_to_ax](const auto& x, const auto& y) {
+          return char_to_ax[x.first] < char_to_ax[y.first];
+        });
+
+    // Skip the transpose if not needed
+    if (std::is_sorted(
+            str_ax.begin(), str_ax.end(), [](const auto& x, const auto& y) {
+              return x.second < y.second;
+            })) {
+      continue;
+    }
+
+    std::vector<int> reorder;
+    for (auto [c, ax] : str_ax) {
+      reorder.push_back(ax);
+    }
+    op = transpose(op, reorder, s);
+  }
+
+  // Multiply and sum
+  auto out = operands[positions[0]];
+  for (int i = 1; i < positions.size(); ++i) {
+    out = multiply(out, operands[positions[i]], s);
+  }
+  std::vector<int> sum_axes;
+  for (auto [c, ax] : char_to_ax) {
+    if (output.set.find(c) == output.set.end()) {
+      sum_axes.push_back(ax);
+    }
+  }
+  if (!sum_axes.empty()) {
+    out = sum(out, sum_axes, false, s);
+  }
+
+  // Transpose output if needed
+  std::vector<int> reorder;
+  for (auto c : output.str) {
+    reorder.push_back(char_to_ax[c]);
+  }
+  for (auto& r : reorder) {
+    int offset = 0;
+    for (auto s : sum_axes) {
+      if (r > s) {
+        offset++;
+      }
+    }
+    r -= offset;
+  }
+  return transpose(out, reorder, s);
+}
+
+std::pair<std::vector<PathNode>, PathInfo> einsum_path_helper(
+    const std::string& subscripts,
+    const std::vector<array>& operands,
+    const std::string& fn_name) {
+  if (operands.size() == 0) {
+    std::ostringstream msg;
+    msg << "[" << fn_name << "] At least one operand is required.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto [in_subscripts, out_subscript] = parse(subscripts);
+
+  if (operands.size() != in_subscripts.size()) {
+    std::ostringstream msg;
+    msg << "[" << fn_name << "] Number of operands, " << operands.size()
+        << ", does not match number of input subscripts, "
+        << in_subscripts.size();
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Expand ellipses
+  // 1. Collect all the characters we can use for the missing axes.
+  // 2. Go over each subscript and check if all the characters are either
+  //    alphanumeric or an ellipsis.
+  // 3. Expand the ellipsis with as many characters from the unused ones as
+  //    necessary. We use the last N characters effectively prepending with
+  //    singleton dims for inputs with fewer dimensions.
+  // 4. For the output use the maximum size of ellipsis that we encountered in
+  //    the input.
+  CharSet used_chars(subscripts.begin(), subscripts.end());
+  std::string remaining_chars;
+  remaining_chars.reserve(52 - used_chars.size());
+  for (char c = 'a'; c <= 'z'; c++) {
+    if (used_chars.find(c) == used_chars.end()) {
+      remaining_chars += c;
+    }
+  }
+  for (char c = 'A'; c <= 'Z'; c++) {
+    if (used_chars.find(c) == used_chars.end()) {
+      remaining_chars += c;
+    }
+  }
+  int max_ellipsis_length = 0;
+  auto check_letters_and_expand_ellipsis = [&](auto& subscript,
+                                               const array* operand) {
+    bool have_ellipsis = false;
+    int cnt_before = 0, cnt_after = 0;
+    for (int i = 0; i < subscript.size(); i++) {
+      if (!isalpha(subscript[i])) {
+        if (i + 2 >= subscript.size() || subscript[i] != '.' ||
+            subscript[i + 1] != '.' || subscript[i + 2] != '.') {
+          std::ostringstream msg;
+          msg << "[" << fn_name << "] Subscripts must be letters, but got '"
+              << subscript[i] << "'.";
+          throw std::invalid_argument(msg.str());
+        }
+
+        if (have_ellipsis) {
+          std::ostringstream msg;
+          msg << "[" << fn_name
+              << "] Only one ellipsis per subscript is allowed but found more in '"
+              << subscript << "'.";
+          throw std::invalid_argument(msg.str());
+        }
+
+        have_ellipsis = true;
+        i += 2;
+        continue;
+      }
+
+      if (have_ellipsis) {
+        cnt_after++;
+      } else {
+        cnt_before++;
+      }
+    }
+
+    if (have_ellipsis) {
+      int ellipsis_length;
+      if (operand != nullptr) {
+        ellipsis_length = operand->ndim() - cnt_before - cnt_after;
+        max_ellipsis_length = std::max(ellipsis_length, max_ellipsis_length);
+      } else {
+        ellipsis_length = max_ellipsis_length;
+      }
+      subscript.replace(
+          subscript.begin() + cnt_before,
+          subscript.begin() + cnt_before + 3,
+          remaining_chars.end() - ellipsis_length,
+          remaining_chars.end());
+    }
+  };
+
+  for (int i = 0; i < operands.size(); i++) {
+    check_letters_and_expand_ellipsis(in_subscripts[i], &operands[i]);
+  }
+  check_letters_and_expand_ellipsis(out_subscript, nullptr);
+
+  CharSet out_set(out_subscript.begin(), out_subscript.end());
+  if (out_set.size() != out_subscript.size()) {
+    std::ostringstream msg;
+    msg << "[" << fn_name << "] Repeat indices not allowed in output.";
+    throw std::invalid_argument(msg.str());
+  }
+  Subscript output(out_subscript, std::move(out_set));
+
+  std::unordered_map<char, ShapeElem> dim_map;
+  std::vector<Subscript> inputs;
+  for (int i = 0; i < in_subscripts.size(); ++i) {
+    auto& in = in_subscripts[i];
+    CharSet in_set(in.begin(), in.end());
+    inputs.emplace_back(in, in_set);
+
+    if (in.size() != operands[i].ndim()) {
+      std::ostringstream msg;
+      msg << "[" << fn_name << "] Invalid number of subscripts " << in.size()
+          << " for input " << i << " with " << operands[i].ndim()
+          << " dimensions.";
+      throw std::invalid_argument(msg.str());
+    }
+
+    // Check repeat subscripts are valid
+    if (in_set.size() < in.size()) {
+      std::unordered_map<char, ShapeElem> local_dims;
+      for (int j = 0; j < in.size(); ++j) {
+        auto dim = operands[i].shape(j);
+        auto inserted = local_dims.insert({in[j], dim});
+        if (!inserted.second) {
+          if (inserted.first->second != dim) {
+            std::ostringstream msg;
+            msg << "[" << fn_name << "] Dimensions of repeated subscripts "
+                << "do not have the same size (" << inserted.first->second
+                << " != " << dim << ").";
+            throw std::invalid_argument(msg.str());
+          }
+        }
+      }
+    }
+
+    for (int j = 0; j < in.size(); j++) {
+      auto c = in[j];
+      auto dim = operands[i].shape(j);
+      auto inserted = dim_map.insert({c, dim});
+      auto& in_dim = inserted.first->second;
+      if (dim != 1 && in_dim != 1 && in_dim != dim) {
+        std::ostringstream msg;
+        msg << "[" << fn_name << "] Cannot broadcast dimension " << j
+            << " of input " << i << " with shape " << operands[i].shape()
+            << " to size " << in_dim << ".";
+        throw std::invalid_argument(msg.str());
+      }
+      // Ensure the broadcasted size is used
+      in_dim = std::max(in_dim, dim);
+    }
+  }
+
+  size_t max_size = term_size(out_subscript, dim_map);
+  for (auto& in : in_subscripts) {
+    max_size = std::max(max_size, term_size(in, dim_map));
+  }
+
+  PathInfo path_info;
+
+  // Get the full naive cost
+  std::tie(path_info.naive_cost, path_info.naive_scaling) =
+      compute_cost_and_scaling(inputs, output, dim_map);
+
+  // Calculate the path
+  std::vector<PathNode> path;
+  if (inputs.size() <= 2) {
+    std::vector<int> positions(in_subscripts.size());
+    std::iota(positions.begin(), positions.end(), 0);
+    path.emplace_back(
+        std::move(inputs), std::move(output), std::move(positions));
+  } else {
+    std::tie(path, path_info.optimized_cost, path_info.optimized_scaling) =
+        greedy_path(inputs, output, dim_map, path_info.naive_cost, max_size);
+    // Set the final output subscript to the actual output
+    path.back().output = std::move(output);
+  }
+  return {path, path_info};
+}
+
+} // namespace
+
+std::pair<std::vector<std::vector<int>>, std::string> einsum_path(
+    const std::string& subscripts,
+    const std::vector<array>& operands) {
+  auto [path, path_info] =
+      einsum_path_helper(subscripts, operands, "einsum_path");
+
+  std::vector<std::vector<int>> pos_path;
+  for (auto& p : path) {
+    pos_path.push_back(p.positions);
+  }
+
+  std::ostringstream path_print;
+  path_print << "  Complete contraction:  " << subscripts << "\n"
+             << "         Naive scaling:  " << path_info.naive_scaling << "\n"
+             << "     Optimized scaling:  " << path_info.optimized_scaling
+             << "\n"
+             << "      Naive FLOP count:  " << path_info.naive_cost << "\n"
+             << "  Optimized FLOP count:  " << path_info.optimized_cost << "\n";
+  // TODO add more info here
+  return {pos_path, path_print.str()};
+}
+
+array einsum(
+    const std::string& subscripts,
+    const std::vector<array>& operands,
+    StreamOrDevice s /* = {} */) {
+  auto [path, path_info] = einsum_path_helper(subscripts, operands, "einsum");
+  auto inputs = operands;
+  for (auto& node : path) {
+    preprocess_einsum_inputs(
+        node.inputs, node.output, node.positions, inputs, s);
+
+    if (can_dot(node.inputs, node.output)) {
+      auto& in_a = node.inputs[0];
+      auto& in_b = node.inputs[1];
+      auto& out = node.output;
+
+      std::vector<int> a_contract;
+      std::vector<int> a_batch;
+      std::vector<int> a_concat;
+      for (int i = 0; i < in_a.str.size(); ++i) {
+        auto c = in_a.str[i];
+        if (out.set.find(c) == out.set.end()) {
+          // Not in the output, contraction
+          a_contract.push_back(i);
+        } else if (in_b.set.find(c) != in_b.set.end()) {
+          // Not a contraction but in both inputs, batch dim
+          a_batch.push_back(i);
+        } else {
+          // Not a batch dim or contract dim, so concat dim
+          a_concat.push_back(i);
+        }
+      }
+
+      std::vector<int> b_contract;
+      std::vector<int> b_batch;
+      std::vector<int> b_concat;
+      for (auto a_i : a_contract) {
+        b_contract.push_back(in_b.str.find(in_a.str[a_i]));
+      }
+      for (auto a_i : a_batch) {
+        b_batch.push_back(in_b.str.find(in_a.str[a_i]));
+      }
+      for (int i = 0; i < in_b.str.size(); ++i) {
+        auto c = in_b.str[i];
+        if (out.set.find(c) != out.set.end() &&
+            in_a.set.find(c) == in_a.set.end()) {
+          b_concat.push_back(i);
+        }
+      }
+
+      auto& a = inputs[node.positions[0]];
+      auto& b = inputs[node.positions[1]];
+
+      std::unordered_map<char, int> char_map;
+      for (auto i : a_batch) {
+        char_map.insert({in_a.str[i], char_map.size()});
+      }
+      for (auto i : a_concat) {
+        char_map.insert({in_a.str[i], char_map.size()});
+      }
+      for (auto i : b_concat) {
+        char_map.insert({in_b.str[i], char_map.size()});
+      }
+      inputs.emplace_back(batch_tensordot(
+          a,
+          b,
+          std::move(a_contract),
+          std::move(a_batch),
+          std::move(a_concat),
+          std::move(b_contract),
+          std::move(b_batch),
+          std::move(b_concat),
+          s));
+
+      std::vector<int> reorder;
+      for (auto c : node.output.str) {
+        reorder.push_back(char_map[c]);
+      }
+      inputs.back() = transpose(inputs.back(), reorder, s);
+
+    } else {
+      inputs.emplace_back(
+          einsum_naive(node.inputs, node.output, node.positions, inputs, s));
+    }
+
+    // Positions are always sorted increasing, so start from the back
+    for (auto it = node.positions.rbegin(); it != node.positions.rend(); ++it) {
+      inputs.erase(inputs.begin() + *it);
+    }
+  }
+  return inputs.front();
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/einsum.h b/ml-stable-diffusion/mlx/mlx/einsum.h
new file mode 100644
index 0000000000000000000000000000000000000000..f57e9a77c8627e319942fd120289d11b7f1832e9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/einsum.h
@@ -0,0 +1,22 @@
+// Copyright © 2024 Apple Inc.
+#pragma once
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "mlx/array.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+std::pair<std::vector<std::vector<int>>, std::string> einsum_path(
+    const std::string& subscripts,
+    const std::vector<array>& operands);
+
+array einsum(
+    const std::string& subscripts,
+    const std::vector<array>& operands,
+    StreamOrDevice s = {});
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/event.h b/ml-stable-diffusion/mlx/mlx/event.h
new file mode 100644
index 0000000000000000000000000000000000000000..937028e2a6430548b964e417c17abbb657c856e8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/event.h
@@ -0,0 +1,57 @@
+// Copyright © 2024 Apple Inc.
+#pragma once
+
+#include <memory>
+#include <stdexcept>
+
+#include "mlx/stream.h"
+
+namespace mlx::core {
+
+class Event {
+ public:
+  Event() {};
+  explicit Event(Stream stream);
+
+  // Wait for the event to be signaled at its current value
+  void wait();
+
+  // Wait in the given stream for the event to be signaled at its current value
+  void wait(Stream stream);
+
+  // Signal the event at its current value in the given stream
+  void signal(Stream stream);
+
+  // Check if the event has been signaled at its current value
+  bool is_signaled() const;
+
+  // Check if the event is valid
+  bool valid() const {
+    return event_ != nullptr;
+  }
+
+  uint64_t value() const {
+    return value_;
+  }
+
+  void set_value(uint64_t v) {
+    value_ = v;
+  }
+
+  const Stream& stream() const {
+    if (!valid()) {
+      throw std::runtime_error(
+          "[Event::stream] Cannot access stream on invalid event.");
+    }
+    return stream_;
+  }
+
+ private:
+  // Default constructed stream should never be used
+  // since the event is not yet valid
+  Stream stream_{0, Device::cpu};
+  std::shared_ptr<void> event_{nullptr};
+  uint64_t value_{0};
+};
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/export.cpp b/ml-stable-diffusion/mlx/mlx/export.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ca7e316b3cf26c1d4b7c08d0db0a39655c790f00
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/export.cpp
@@ -0,0 +1,881 @@
+// Copyright © 2024 Apple Inc.
+#include "mlx/export.h"
+#include <map>
+#include "mlx/compile_impl.h"
+#include "mlx/fast_primitives.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+#include "mlx/version.h"
+
+// clang-format off
+#define SERIALIZE_PRIMITIVE(primitive, ...)  \
+  {                                          \
+    #primitive, {                            \
+      serialize_primitive<primitive>,        \
+      deserialize_primitive<primitive>,      \
+      {__VA_ARGS__}                          \
+    }                                        \
+  }
+// clang-format on
+
+bool is_big_endian() {
+  int num = 1;
+  return *reinterpret_cast<char*>(&num) != 1;
+}
+
+namespace mlx::core {
+
+using namespace mlx::core::fast;
+
+using Reader = io::ParallelFileReader;
+using Writer = io::FileWriter;
+
+struct PrimitiveSerializer {
+  using Serializer = std::function<void(Writer&, const Primitive&)>;
+  using Deserializer =
+      std::function<std::shared_ptr<Primitive>(Reader&, Stream s)>;
+  PrimitiveSerializer(
+      Serializer serialize,
+      Deserializer deserialize,
+      std::vector<std::string> keys = {})
+      : serialize(std::move(serialize)),
+        deserialize(std::move(deserialize)),
+        keys(std::move(keys)) {};
+  Serializer serialize;
+  Deserializer deserialize;
+  std::vector<std::string> keys;
+};
+
+template <typename, typename = void>
+constexpr bool is_iterable = false;
+
+template <typename T>
+constexpr bool is_iterable<
+    T,
+    std::void_t<
+        decltype(std::declval<T>().begin()),
+        decltype(std::declval<T>().end())>> = true;
+
+template <template <typename...> class T, typename U>
+constexpr bool is_specialization_of = false;
+
+template <template <typename...> class T, typename... Us>
+constexpr bool is_specialization_of<T, T<Us...>> = true;
+
+template <typename T>
+constexpr bool is_pair = is_specialization_of<std::pair, std::decay_t<T>>;
+
+template <typename T>
+constexpr bool is_tuple = is_specialization_of<std::tuple, std::decay_t<T>>;
+
+template <typename>
+constexpr bool dependent_false = false;
+
+template <typename T>
+struct NotSerializable {
+  static_assert(dependent_false<T>, "Type is not serializable.");
+};
+
+template <typename T>
+struct NotDeserializable {
+  static_assert(dependent_false<T>, "Type is not deserializable.");
+};
+
+template <typename T>
+void reverse_bytes(T& data) {
+  auto* bytes = reinterpret_cast<uint8_t*>(&data);
+  for (size_t j = 0; j < (sizeof(T) / 2); j++) {
+    std::swap(bytes[j], bytes[sizeof(T) - j - 1]);
+  }
+}
+
+template <typename T>
+void serialize(Writer& os, T v) {
+  if constexpr (std::is_arithmetic_v<T>) {
+    if (is_big_endian()) {
+      reverse_bytes(v);
+    }
+    os.write(reinterpret_cast<const char*>(&v), sizeof(T));
+  } else if constexpr (std::is_enum_v<T>) {
+    serialize(os, static_cast<int>(v));
+  } else if constexpr (std::is_same_v<T, std::nullptr_t>) {
+  } else if constexpr (is_iterable<T>) {
+    serialize(os, static_cast<uint64_t>(v.size()));
+    for (const auto& t : v) {
+      serialize(os, t);
+    }
+  } else if constexpr (is_pair<T> || is_tuple<T>) {
+    std::apply([&os](auto&... x) { (..., serialize(os, x)); }, v);
+  } else {
+    NotSerializable<T>();
+  }
+}
+
+template <typename T, std::size_t... I>
+decltype(auto) deserialize_tuple(Reader& is, std::index_sequence<I...>);
+
+template <typename T>
+T deserialize(Reader& is) {
+  if constexpr (std::is_arithmetic_v<T>) {
+    T v;
+    is.read(reinterpret_cast<char*>(&v), sizeof(T));
+    if (is_big_endian()) {
+      reverse_bytes(v);
+    }
+    return v;
+  } else if constexpr (std::is_enum_v<T>) {
+    return static_cast<T>(deserialize<int>(is));
+  } else if constexpr (std::is_same_v<T, std::nullptr_t>) {
+    return nullptr;
+  } else if constexpr (is_iterable<T>) {
+    T v;
+    auto size = deserialize<uint64_t>(is);
+    v.reserve(size);
+    for (int i = 0; i < size; ++i) {
+      v.push_back(deserialize<typename T::value_type>(is));
+    }
+    return v;
+  } else if constexpr (is_pair<T> || is_tuple<T>) {
+    return deserialize_tuple<T>(
+        is, std::make_index_sequence<std::tuple_size_v<std::decay_t<T>>>{});
+  } else {
+    NotDeserializable<T>();
+  }
+}
+
+template <typename T, std::size_t... I>
+decltype(auto) deserialize_tuple(Reader& is, std::index_sequence<I...>) {
+  return T{deserialize<std::tuple_element_t<I, T>>(is)...};
+};
+
+void serialize(Writer& os, const Stream& s) {
+  serialize(os, s.index);
+  serialize(os, s.device.type);
+  serialize(os, s.device.index);
+}
+template <>
+Stream deserialize(Reader& is) {
+  auto stream_index = deserialize<int>(is);
+  auto device_type = deserialize<Device::DeviceType>(is);
+  auto device_index = deserialize<int>(is);
+  return Stream(stream_index, Device(device_type, device_index));
+}
+
+void serialize(Writer& os, const Dtype& t) {
+  serialize(os, t.val());
+  serialize(os, t.size());
+}
+
+template <>
+Dtype deserialize(Reader& is) {
+  auto val = deserialize<Dtype::Val>(is);
+  auto size = deserialize<uint8_t>(is);
+  return Dtype(val, size);
+};
+
+void serialize(Writer& os, const array& arr) {
+  serialize(os, arr.shape());
+  serialize(os, arr.dtype());
+}
+template <>
+array deserialize(Reader& is) {
+  auto shape = deserialize<Shape>(is);
+  auto type = deserialize<Dtype>(is);
+  return array(std::move(shape), type, nullptr, std::vector<array>{});
+}
+
+template <typename, typename = void>
+constexpr bool has_state = false;
+
+template <typename T>
+constexpr bool has_state<T, std::void_t<decltype(std::declval<T>().state())>> =
+    true;
+
+template <typename T>
+void serialize_primitive(Writer& os, const Primitive& p) {
+  if constexpr (has_state<T>) {
+    serialize(os, static_cast<const T&>(p).state());
+  }
+}
+
+template <typename T>
+std::shared_ptr<T> deserialize_primitive(Reader& is, Stream s) {
+  if constexpr (has_state<T>) {
+    auto args = deserialize<decltype(std::declval<T>().state())>(is);
+    if constexpr (is_pair<decltype(args)> || is_tuple<decltype(args)>) {
+      auto fn = [s](auto&&... args) {
+        return std::make_shared<T>(s, std::move(args)...);
+      };
+      return std::apply(fn, std::move(args));
+    } else {
+      return std::make_shared<T>(s, std::move(args));
+    }
+  } else {
+    return std::make_shared<T>(s);
+  }
+}
+
+struct PrimitiveFactory {
+  std::unordered_map<std::string, PrimitiveSerializer> factory = {
+      SERIALIZE_PRIMITIVE(Abs),
+      SERIALIZE_PRIMITIVE(Add),
+      SERIALIZE_PRIMITIVE(AddMM),
+      SERIALIZE_PRIMITIVE(Arange),
+      SERIALIZE_PRIMITIVE(ArcCos),
+      SERIALIZE_PRIMITIVE(ArcCosh),
+      SERIALIZE_PRIMITIVE(ArcSin),
+      SERIALIZE_PRIMITIVE(ArcSinh),
+      SERIALIZE_PRIMITIVE(ArcTan),
+      SERIALIZE_PRIMITIVE(ArcTan2),
+      SERIALIZE_PRIMITIVE(ArcTanh),
+      SERIALIZE_PRIMITIVE(ArgPartition),
+      SERIALIZE_PRIMITIVE(ArgReduce),
+      SERIALIZE_PRIMITIVE(ArgSort),
+      SERIALIZE_PRIMITIVE(AsType),
+      SERIALIZE_PRIMITIVE(AsStrided),
+      SERIALIZE_PRIMITIVE(
+          BitwiseBinary,
+          "BitwiseAnd",
+          "BitwiseOr",
+          "BitwiseXor",
+          "LeftShift",
+          "RightShift"),
+      SERIALIZE_PRIMITIVE(BlockMaskedMM),
+      SERIALIZE_PRIMITIVE(Broadcast),
+      SERIALIZE_PRIMITIVE(BroadcastAxes),
+      SERIALIZE_PRIMITIVE(Ceil),
+      SERIALIZE_PRIMITIVE(Concatenate),
+      SERIALIZE_PRIMITIVE(Conjugate),
+      SERIALIZE_PRIMITIVE(Convolution),
+      SERIALIZE_PRIMITIVE(Copy),
+      SERIALIZE_PRIMITIVE(Cos),
+      SERIALIZE_PRIMITIVE(Cosh),
+      SERIALIZE_PRIMITIVE(Depends),
+      SERIALIZE_PRIMITIVE(Divide),
+      SERIALIZE_PRIMITIVE(DivMod),
+      SERIALIZE_PRIMITIVE(DynamicSlice),
+      SERIALIZE_PRIMITIVE(DynamicSliceUpdate),
+      SERIALIZE_PRIMITIVE(Equal, "NaNEqual"),
+      SERIALIZE_PRIMITIVE(Erf),
+      SERIALIZE_PRIMITIVE(ErfInv),
+      SERIALIZE_PRIMITIVE(Exp),
+      SERIALIZE_PRIMITIVE(Expm1),
+      SERIALIZE_PRIMITIVE(ExpandDims),
+      SERIALIZE_PRIMITIVE(FFT),
+      SERIALIZE_PRIMITIVE(Flatten),
+      SERIALIZE_PRIMITIVE(Floor),
+      SERIALIZE_PRIMITIVE(Full),
+      SERIALIZE_PRIMITIVE(Gather),
+      SERIALIZE_PRIMITIVE(GatherAxis),
+      SERIALIZE_PRIMITIVE(GatherMM),
+      SERIALIZE_PRIMITIVE(Greater),
+      SERIALIZE_PRIMITIVE(GreaterEqual),
+      SERIALIZE_PRIMITIVE(Hadamard),
+      SERIALIZE_PRIMITIVE(Imag),
+      SERIALIZE_PRIMITIVE(Less),
+      SERIALIZE_PRIMITIVE(LessEqual),
+      SERIALIZE_PRIMITIVE(Log, "Log2", "Log10"),
+      SERIALIZE_PRIMITIVE(Log1p),
+      SERIALIZE_PRIMITIVE(LogicalNot),
+      SERIALIZE_PRIMITIVE(LogicalAnd),
+      SERIALIZE_PRIMITIVE(LogicalOr),
+      SERIALIZE_PRIMITIVE(LogAddExp),
+      SERIALIZE_PRIMITIVE(LogSumExp),
+      SERIALIZE_PRIMITIVE(Matmul),
+      SERIALIZE_PRIMITIVE(Maximum),
+      SERIALIZE_PRIMITIVE(Minimum),
+      SERIALIZE_PRIMITIVE(Multiply),
+      SERIALIZE_PRIMITIVE(Negative),
+      SERIALIZE_PRIMITIVE(NotEqual),
+      SERIALIZE_PRIMITIVE(Reshape),
+      SERIALIZE_PRIMITIVE(NumberOfElements),
+      SERIALIZE_PRIMITIVE(Pad),
+      SERIALIZE_PRIMITIVE(Partition),
+      SERIALIZE_PRIMITIVE(Power),
+      SERIALIZE_PRIMITIVE(QuantizedMatmul),
+      SERIALIZE_PRIMITIVE(GatherQMM),
+      SERIALIZE_PRIMITIVE(RandomBits),
+      SERIALIZE_PRIMITIVE(Real),
+      SERIALIZE_PRIMITIVE(Remainder),
+      SERIALIZE_PRIMITIVE(Reshape),
+      SERIALIZE_PRIMITIVE(Reduce, "And", "Or", "Sum", "Prod", "Min", "Max"),
+      SERIALIZE_PRIMITIVE(Round),
+      SERIALIZE_PRIMITIVE(
+          Scan,
+          "CumSum",
+          "CumProd",
+          "CumMin",
+          "CumMax",
+          "CumLogaddexp"),
+      SERIALIZE_PRIMITIVE(Scatter),
+      SERIALIZE_PRIMITIVE(ScatterAxis),
+      SERIALIZE_PRIMITIVE(Select),
+      SERIALIZE_PRIMITIVE(Sigmoid),
+      SERIALIZE_PRIMITIVE(Sign),
+      SERIALIZE_PRIMITIVE(Sin),
+      SERIALIZE_PRIMITIVE(Sinh),
+      SERIALIZE_PRIMITIVE(Slice),
+      SERIALIZE_PRIMITIVE(SliceUpdate),
+      SERIALIZE_PRIMITIVE(Softmax),
+      SERIALIZE_PRIMITIVE(Sort),
+      SERIALIZE_PRIMITIVE(Split),
+      SERIALIZE_PRIMITIVE(Square),
+      SERIALIZE_PRIMITIVE(Squeeze),
+      SERIALIZE_PRIMITIVE(Sqrt, "Rsqrt", "Sqrt"),
+      SERIALIZE_PRIMITIVE(StopGradient),
+      SERIALIZE_PRIMITIVE(Subtract),
+      SERIALIZE_PRIMITIVE(Tan),
+      SERIALIZE_PRIMITIVE(Tanh),
+      SERIALIZE_PRIMITIVE(View),
+      SERIALIZE_PRIMITIVE(Transpose),
+      SERIALIZE_PRIMITIVE(Unflatten),
+      SERIALIZE_PRIMITIVE(QRF),
+      SERIALIZE_PRIMITIVE(SVD),
+      SERIALIZE_PRIMITIVE(Inverse),
+      SERIALIZE_PRIMITIVE(Cholesky),
+      SERIALIZE_PRIMITIVE(Eig),
+      SERIALIZE_PRIMITIVE(Eigh),
+      SERIALIZE_PRIMITIVE(Quantize),
+      SERIALIZE_PRIMITIVE(RMSNorm),
+      SERIALIZE_PRIMITIVE(RMSNormVJP),
+      SERIALIZE_PRIMITIVE(LayerNorm),
+      SERIALIZE_PRIMITIVE(LayerNormVJP),
+      SERIALIZE_PRIMITIVE(RoPE),
+      SERIALIZE_PRIMITIVE(ScaledDotProductAttention)};
+  std::unordered_map<std::string, std::string> name_remap;
+
+  PrimitiveFactory() {
+    for (auto& [n, f] : factory) {
+      for (auto& k : f.keys) {
+        name_remap[k] = n;
+      }
+    }
+  }
+
+  void save(Writer& os, const std::shared_ptr<Primitive>& p) {
+    serialize(os, p->stream());
+    std::string name = p->name();
+    name = name.substr(0, name.find(' '));
+    if (auto it = name_remap.find(name); it != name_remap.end()) {
+      name = it->second;
+    }
+    serialize(os, name);
+    if (auto it = factory.find(name); it != factory.end()) {
+      it->second.serialize(os, *p);
+    } else {
+      throw std::invalid_argument(
+          "[export_function] Unable to serialize primitive " + name);
+    }
+  };
+
+  std::shared_ptr<Primitive> load(Reader& is) {
+    auto stream = deserialize<Stream>(is);
+    if (get_stream(stream.index) != stream) {
+      std::ostringstream msg;
+      msg << "[import_function] Invalid stream encountered " << stream << ".";
+      throw std::invalid_argument(msg.str());
+    }
+    auto name = deserialize<std::string>(is);
+    if (auto it = factory.find(name); it != factory.end()) {
+      return it->second.deserialize(is, stream);
+    } else {
+      throw std::invalid_argument(
+          "[import_function] Unable to deserialize primitive " + name);
+    }
+  };
+};
+
+void write_header(Writer& os, int count, bool shapeless) {
+  serialize(os, std::string(version()));
+  serialize(os, count);
+  serialize(os, shapeless);
+}
+
+// A struct to hold and retrieve the graphs that are exported / imported
+struct FunctionTable {
+  FunctionTable(bool shapeless = false) : shapeless(shapeless) {};
+  struct Function {
+    Function(
+        std::vector<std::string> kwarg_keys,
+        std::vector<array> inputs,
+        std::vector<array> outputs,
+        std::vector<array> tape)
+        : kwarg_keys(std::move(kwarg_keys)),
+          inputs(std::move(inputs)),
+          outputs(std::move(outputs)),
+          tape(std::move(tape)) {}
+
+    std::vector<std::string> kwarg_keys;
+    std::vector<array> inputs;
+    std::vector<array> outputs;
+    std::vector<array> tape;
+    Function(const Function&) = delete;
+    Function& operator=(const Function&) = delete;
+    Function(Function&&) = default;
+    Function() = default;
+  };
+  bool shapeless;
+  std::unordered_map<int, std::vector<Function>> table;
+  Function* find(const Args& args, const Kwargs& kwargs);
+  std::pair<Function&, bool> emplace(const Args& args, const Kwargs& kwargs);
+  void insert(
+      std::vector<std::string> kwarg_keys,
+      std::vector<array> inputs,
+      std::vector<array> outputs,
+      std::vector<array> tape) {
+    auto [it, _] = table.emplace(inputs.size(), std::vector<Function>{});
+    it->second.emplace_back(
+        std::move(kwarg_keys),
+        std::move(inputs),
+        std::move(outputs),
+        std::move(tape));
+  }
+
+  void print_functions(std::ostream& os) {
+    int n = 1;
+    for (auto& [_, vec] : table) {
+      for (auto& fun : vec) {
+        auto npos = fun.inputs.size() - fun.kwarg_keys.size();
+        os << " " << n++ << ". Function with " << npos
+           << " positional inputs and " << fun.kwarg_keys.size()
+           << " keyword inputs:\n";
+        for (int j = 0; j < fun.inputs.size(); ++j) {
+          auto& in = fun.inputs[j];
+          if (j < npos) {
+            os << "   " << j + 1 << ": ";
+          } else {
+            os << "   \"" << fun.kwarg_keys[j - npos] << "\": ";
+          }
+          os << in.shape() << " " << in.dtype() << "\n";
+        }
+      }
+    }
+  }
+
+ private:
+  bool match(const Args& args, const Kwargs& kwargs, const Function& fun);
+};
+
+bool FunctionTable::match(
+    const Args& args,
+    const Kwargs& kwargs,
+    const Function& fun) {
+  for (auto& k : fun.kwarg_keys) {
+    if (kwargs.find(k) == kwargs.end()) {
+      return false;
+    }
+  }
+
+  auto match_inputs = [shapeless = this->shapeless](
+                          const array& x, const array& y) {
+    if (x.dtype() != y.dtype()) {
+      return false;
+    }
+    if (x.ndim() != y.ndim()) {
+      return false;
+    }
+    if (!shapeless && x.shape() != y.shape()) {
+      return false;
+    }
+    return true;
+  };
+
+  int i = 0;
+  for (; i < args.size(); ++i) {
+    if (!match_inputs(args[i], fun.inputs[i])) {
+      return false;
+    }
+  }
+  auto sorted_kwargs =
+      std::map<std::string, array>(kwargs.begin(), kwargs.end());
+  for (auto& [_, in] : sorted_kwargs) {
+    if (!match_inputs(in, fun.inputs[i++])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+std::pair<FunctionTable::Function&, bool> FunctionTable::emplace(
+    const Args& args,
+    const Kwargs& kwargs) {
+  auto n_inputs = args.size() + kwargs.size();
+  auto [it, _] = table.emplace(n_inputs, std::vector<Function>{});
+  auto& funs_vec = it->second;
+
+  for (auto& fun : funs_vec) {
+    if (match(args, kwargs, fun)) {
+      return {fun, false};
+    }
+  }
+
+  funs_vec.emplace_back();
+  return {funs_vec.back(), true};
+}
+
+FunctionTable::Function* FunctionTable::find(
+    const Args& args,
+    const Kwargs& kwargs) {
+  auto n_inputs = args.size() + kwargs.size();
+  auto it = table.find(n_inputs);
+  if (it == table.end()) {
+    return nullptr;
+  }
+
+  for (auto& fun : it->second) {
+    if (match(args, kwargs, fun)) {
+      return &fun;
+    }
+  }
+
+  return nullptr;
+}
+
+FunctionExporter::FunctionExporter(
+    const std::string& file,
+    std::function<std::vector<array>(const Args&, const Kwargs&)> fun,
+    bool shapeless)
+    : os(file),
+      fun(std::move(fun)),
+      ftable(std::make_shared<FunctionTable>(shapeless)) {
+  if (!os.is_open()) {
+    throw std::runtime_error("[export_function] Failed to open " + file);
+  }
+  write_header(os, count, shapeless);
+}
+
+void FunctionExporter::close() {
+  closed = true;
+};
+
+void FunctionExporter::export_function(const Args& args, const Kwargs& kwargs) {
+  if (closed) {
+    throw std::runtime_error(
+        "[export_function] Attempting to write after exporting is closed.");
+  }
+  auto [fentry, inserted] = ftable->emplace(args, kwargs);
+  if (!inserted) {
+    throw std::runtime_error(
+        "[export_function] Attempting to export a function twice with "
+        "the same signature is not allowed.");
+  }
+
+  // Flatten the inputs to the function for tracing
+  std::vector<std::string> kwarg_keys;
+  auto inputs = args;
+  auto sorted_kwargs =
+      std::map<std::string, array>(kwargs.begin(), kwargs.end());
+  for (auto& [k, v] : sorted_kwargs) {
+    kwarg_keys.push_back(k);
+    inputs.push_back(v);
+  }
+
+  auto flat_fun = [this, &kwarg_keys](const Args& flat_args) {
+    auto args = Args(flat_args.begin(), flat_args.end() - kwarg_keys.size());
+    Kwargs kwargs;
+    auto it = flat_args.end() - kwarg_keys.size();
+    ;
+    for (auto& k : kwarg_keys) {
+      kwargs.insert({k, *it++});
+    }
+    return detail::ArraysAndExtra{fun(args, kwargs), nullptr};
+  };
+
+  // Trace to build the graph
+  auto [trace_inputs, trace_outputs, extra] =
+      detail::compile_trace(flat_fun, inputs, ftable->shapeless);
+
+  // DFS the graph and get the tape
+  auto [tape, parents_map] =
+      detail::compile_dfs(trace_inputs, trace_outputs, inputs);
+
+  detail::compile_simplify(tape, parents_map, trace_outputs, /* passes */ 3);
+
+  // Update header
+  count++;
+
+  // Overwrite the header
+  auto pos = os.tell();
+  os.seek(0);
+  write_header(os, count, ftable->shapeless);
+  os.seek(pos);
+  serialize(os, kwarg_keys);
+
+  auto arrays_to_ids = [](const std::vector<array>& arrs) {
+    std::vector<uint64_t> ids;
+    for (auto& arr : arrs) {
+      ids.push_back(arr.id());
+    }
+    return ids;
+  };
+
+  // Inputs and outputs
+  auto trace_input_ids = arrays_to_ids(trace_inputs);
+  serialize(os, trace_input_ids);
+  serialize(os, trace_inputs);
+  serialize(os, arrays_to_ids(trace_outputs));
+
+  // Update the table entry
+  fentry.kwarg_keys = std::move(kwarg_keys);
+  fentry.inputs = std::move(trace_inputs);
+
+  std::unordered_set<std::uintptr_t> input_set(
+      trace_input_ids.begin(), trace_input_ids.end());
+
+  // Tape
+  auto factory = PrimitiveFactory();
+  serialize(os, static_cast<uint64_t>(tape.size()));
+  for (auto& arr : tape) {
+    serialize(os, static_cast<uint64_t>(arr.id()));
+    if (arr.has_primitive()) {
+      serialize(os, true);
+      serialize(os, arrays_to_ids(arr.inputs()));
+      factory.save(os, arr.primitive_ptr());
+      serialize(os, static_cast<uint64_t>(arr.siblings().size()));
+      if (arr.siblings().empty()) {
+        serialize(os, arr.shape());
+        serialize(os, arr.dtype());
+      } else {
+        auto outputs = arr.outputs();
+        serialize(os, arrays_to_ids(outputs));
+
+        std::vector<Shape> shapes;
+        std::vector<Dtype> dtypes;
+        for (auto& o : outputs) {
+          shapes.push_back(o.shape());
+          dtypes.push_back(o.dtype());
+        }
+        serialize(os, shapes);
+        serialize(os, dtypes);
+      }
+    } else {
+      serialize(os, false);
+      if (input_set.find(arr.id()) == input_set.end()) {
+        serialize(os, true);
+        // Save constant data if not already saved
+        if (constants.insert(arr.id()).second) {
+          serialize(os, arr.shape());
+          serialize(os, arr.dtype());
+          os.write(arr.data<char>(), arr.nbytes());
+        }
+      } else {
+        serialize(os, false);
+      }
+    }
+  }
+}
+
+void FunctionExporter::operator()(const Args& args) {
+  export_function(args, {});
+}
+
+void FunctionExporter::operator()(const Kwargs& kwargs) {
+  export_function({}, kwargs);
+}
+
+void FunctionExporter::operator()(const Args& args, const Kwargs& kwargs) {
+  export_function(args, kwargs);
+}
+
+FunctionExporter exporter(
+    const std::string& file,
+    const std::function<std::vector<array>(const Args&)>& fun,
+    bool shapeless /* = false */) {
+  return FunctionExporter{
+      file,
+      [fun](const Args& args, const Kwargs&) { return fun(args); },
+      shapeless};
+}
+
+FunctionExporter exporter(
+    const std::string& file,
+    const std::function<std::vector<array>(const Kwargs&)>& fun,
+    bool shapeless /* = false */) {
+  return exporter(
+      file,
+      [fun](const Args&, const Kwargs kwargs) { return fun(kwargs); },
+      shapeless);
+}
+
+FunctionExporter exporter(
+    const std::string& file,
+    const std::function<std::vector<array>(const Args&, const Kwargs&)>& fun,
+    bool shapeless /* = false */) {
+  return FunctionExporter{file, fun, shapeless};
+}
+
+void export_function(
+    const std::string& file,
+    const std::function<std::vector<array>(const Args&)>& fun,
+    const Args& args,
+    bool shapeless /* = false */) {
+  exporter(file, fun, shapeless)(args);
+}
+
+void export_function(
+    const std::string& file,
+    const std::function<std::vector<array>(const Kwargs&)>& fun,
+    const Kwargs& kwargs,
+    bool shapeless /* = false */) {
+  exporter(file, fun, shapeless)(kwargs);
+}
+
+void export_function(
+    const std::string& file,
+    const std::function<std::vector<array>(const Args&, const Kwargs&)>& fun,
+    const Args& args,
+    const Kwargs& kwargs,
+    bool shapeless /* = false */) {
+  exporter(file, fun, shapeless)(args, kwargs);
+}
+
+std::vector<array> ImportedFunction::operator()(const Kwargs& kwargs) const {
+  return this->operator()({}, kwargs);
+}
+
+std::vector<array> ImportedFunction::operator()(const Args& args) const {
+  return this->operator()(args, {});
+}
+
+std::vector<array> ImportedFunction::operator()(
+    const Args& args,
+    const Kwargs& kwargs) const {
+  auto* fun = ftable->find(args, kwargs);
+  if (fun == nullptr) {
+    std::ostringstream msg;
+    msg << "[import_function::call] No imported function found which matches "
+        << "the given positional and keyword arguments. Possible functions include:\n";
+    ftable->print_functions(msg);
+    msg << "\nCalled with " << args.size() << " positional inputs and "
+        << kwargs.size() << " keyword inputs:\n";
+    for (int i = 0; i < args.size(); ++i) {
+      auto& in = args[i];
+      msg << "  " << i + 1 << ": " << in.shape() << " " << in.dtype() << "\n";
+    }
+    for (auto& [k, in] : kwargs) {
+      msg << "  \"" << k << "\": " << in.shape() << " " << in.dtype() << "\n";
+    }
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto inputs = args;
+  for (auto& [_, v] : kwargs) {
+    inputs.push_back(v);
+  }
+  return detail::compile_replace(
+      fun->tape, fun->inputs, fun->outputs, inputs, ftable->shapeless);
+}
+
+ImportedFunction import_function(const std::string& file) {
+  return ImportedFunction{file};
+}
+
+ImportedFunction::ImportedFunction(const std::string& file)
+    : ftable(std::make_shared<FunctionTable>()) {
+  auto is_ptr = std::make_shared<Reader>(file);
+  auto& is = *is_ptr;
+  if (!is.is_open()) {
+    throw std::runtime_error("[import_function] Failed to open " + file);
+  }
+
+  // Parse header
+  auto mlx_version = deserialize<std::string>(is);
+  auto function_count = deserialize<int>(is);
+  ftable->shapeless = deserialize<bool>(is);
+  std::unordered_map<std::uintptr_t, array> constants;
+
+  auto import_one = [&]() {
+    auto kwarg_keys = deserialize<std::vector<std::string>>(is);
+
+    std::unordered_map<uint64_t, array> array_map;
+    auto trace_input_ids = deserialize<std::vector<uint64_t>>(is);
+    auto trace_inputs = deserialize<std::vector<array>>(is);
+    for (int i = 0; i < trace_inputs.size(); ++i) {
+      array_map.emplace(trace_input_ids[i], trace_inputs[i]);
+    }
+    auto trace_output_ids = deserialize<std::vector<uint64_t>>(is);
+
+    std::vector<array> tape;
+    auto tape_size = deserialize<uint64_t>(is);
+    tape.reserve(tape_size);
+
+    auto factory = PrimitiveFactory();
+    for (size_t i = 0; i < tape_size; ++i) {
+      auto id = deserialize<uint64_t>(is);
+      if (deserialize<bool>(is)) {
+        auto input_ids = deserialize<std::vector<uint64_t>>(is);
+        std::vector<array> inputs;
+        inputs.reserve(input_ids.size());
+        for (auto id : input_ids) {
+          inputs.push_back(array_map.at(id));
+        }
+        std::shared_ptr<Primitive> prim = factory.load(is);
+        auto num_siblings = deserialize<uint64_t>(is);
+        if (num_siblings == 0) {
+          auto shape = deserialize<Shape>(is);
+          auto type = deserialize<Dtype>(is);
+          tape.emplace_back(
+              std::move(shape), type, std::move(prim), std::move(inputs));
+          array_map.emplace(id, tape.back());
+        } else {
+          auto ids = deserialize<std::vector<uint64_t>>(is);
+          auto shapes = deserialize<std::vector<Shape>>(is);
+          auto types = deserialize<std::vector<Dtype>>(is);
+          auto arrays = array::make_arrays(
+              std::move(shapes),
+              std::move(types),
+              std::move(prim),
+              std::move(inputs));
+          for (int i = 0; i < arrays.size(); ++i) {
+            auto sid = ids[i];
+            if (sid == id) {
+              tape.push_back(arrays[i]);
+            }
+            array_map.emplace(sid, arrays[i]);
+          }
+        }
+      } else {
+        if (deserialize<bool>(is)) {
+          // Load constant
+          if (auto it = constants.find(id); it != constants.end()) {
+            tape.push_back(it->second);
+          } else {
+            auto shape = deserialize<Shape>(is);
+            auto type = deserialize<Dtype>(is);
+            size_t offset = is.tell();
+            tape.push_back(array(
+                std::move(shape),
+                type,
+                std::make_shared<Load>(
+                    default_stream(Device::cpu), is_ptr, offset),
+                {}));
+            is.seek(offset + tape.back().nbytes());
+            constants.insert({id, tape.back()});
+          }
+          array_map.emplace(id, tape.back());
+        } else {
+          // Function inputs are in the map
+          tape.push_back(array_map.at(id));
+        }
+      }
+    }
+
+    std::vector<array> trace_outputs;
+    trace_outputs.reserve(trace_output_ids.size());
+    for (auto id : trace_output_ids) {
+      trace_outputs.push_back(array_map.at(id));
+    }
+    ftable->insert(
+        std::move(kwarg_keys),
+        std::move(trace_inputs),
+        std::move(trace_outputs),
+        std::move(tape));
+  };
+
+  for (int i = 0; i < function_count; ++i) {
+    import_one();
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/export.h b/ml-stable-diffusion/mlx/mlx/export.h
new file mode 100644
index 0000000000000000000000000000000000000000..c6859c6d86d79183371785dfa0677442d8f31ffb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/export.h
@@ -0,0 +1,66 @@
+// Copyright © 2024 Apple Inc.
+
+#pragma once
+
+#include <set>
+#include <unordered_map>
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+using Args = std::vector<array>;
+using Kwargs = std::unordered_map<std::string, array>;
+
+struct FunctionExporter;
+
+/**
+ * Make an exporter to save multiple traces of a given function to
+ * the same file.
+ */
+FunctionExporter exporter(
+    const std::string& file,
+    const std::function<std::vector<array>(const Args&)>& fun,
+    bool shapeless = false);
+
+FunctionExporter exporter(
+    const std::string& file,
+    const std::function<std::vector<array>(const Kwargs&)>& fun,
+    bool shapeless = false);
+
+FunctionExporter exporter(
+    const std::string& path,
+    const std::function<std::vector<array>(const Args&, const Kwargs&)>& fun,
+    bool shapeless = false);
+
+/**
+ * Export a function to a file.
+ */
+void export_function(
+    const std::string& file,
+    const std::function<std::vector<array>(const Args&)>& fun,
+    const Args& args,
+    bool shapeless = false);
+
+void export_function(
+    const std::string& file,
+    const std::function<std::vector<array>(const Kwargs&)>& fun,
+    const Kwargs& kwargs,
+    bool shapeless = false);
+
+void export_function(
+    const std::string& file,
+    const std::function<std::vector<array>(const Args&, const Kwargs&)>& fun,
+    const Args& args,
+    const Kwargs& kwargs,
+    bool shapeless = false);
+
+struct ImportedFunction;
+
+/**
+ * Import a function from a file.
+ */
+ImportedFunction import_function(const std::string& file);
+
+} // namespace mlx::core
+
+#include "mlx/export_impl.h"
diff --git a/ml-stable-diffusion/mlx/mlx/export_impl.h b/ml-stable-diffusion/mlx/mlx/export_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..74a1c35c1dc8c248c0380ad48c691b53985db870
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/export_impl.h
@@ -0,0 +1,71 @@
+// Copyright © 2024 Apple Inc.
+
+#include "mlx/io/load.h"
+
+#pragma once
+
+namespace mlx::core {
+
+struct FunctionTable;
+
+struct FunctionExporter {
+  void operator()(const std::initializer_list<array>& args) {
+    this->operator()(Args(args));
+  }
+  void operator()(const Args& args);
+  void operator()(const Kwargs& kwargs);
+  void operator()(const Args& args, const Kwargs& kwargs);
+
+  void close();
+
+  FunctionExporter(const FunctionExporter&) = delete;
+  FunctionExporter& operator=(const FunctionExporter&) = delete;
+  FunctionExporter(FunctionExporter&& other) = default;
+
+ private:
+  friend FunctionExporter exporter(
+      const std::string&,
+      const std::function<std::vector<array>(const Args&)>&,
+      bool shapeless);
+
+  friend FunctionExporter exporter(
+      const std::string&,
+      const std::function<std::vector<array>(const Kwargs&)>&,
+      bool shapeless);
+
+  friend FunctionExporter exporter(
+      const std::string&,
+      const std::function<std::vector<array>(const Args&, const Kwargs&)>&,
+      bool shapeless);
+
+  FunctionExporter(
+      const std::string& file,
+      std::function<std::vector<array>(const Args&, const Kwargs&)> fun,
+      bool shapeless);
+  io::FileWriter os;
+  std::function<std::vector<array>(const Args&, const Kwargs& kwargs)> fun;
+  void export_function(const Args& args, const Kwargs& kwargs);
+  std::set<std::uintptr_t> constants;
+  int count{0};
+  bool closed{false};
+  std::shared_ptr<FunctionTable> ftable;
+};
+
+struct ImportedFunction {
+  std::vector<array> operator()(
+      const std::initializer_list<array>& args) const {
+    return this->operator()(Args(args));
+  }
+  std::vector<array> operator()(const Args& args) const;
+  std::vector<array> operator()(const Kwargs& kwargs) const;
+  std::vector<array> operator()(const Args& args, const Kwargs& kwargs) const;
+
+ private:
+  ImportedFunction(const std::string& file);
+  friend ImportedFunction import_function(const std::string&);
+  ImportedFunction();
+
+  std::shared_ptr<FunctionTable> ftable;
+};
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/fast.cpp b/ml-stable-diffusion/mlx/mlx/fast.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e5bd3ad721f431c7e1bdf0b78310ecbf6e313a13
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/fast.cpp
@@ -0,0 +1,849 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <cassert>
+#include <numeric>
+
+#include "mlx/fast.h"
+#include "mlx/fast_primitives.h"
+#include "mlx/ops.h"
+#include "mlx/transforms.h"
+
+namespace mlx::core::fast {
+
+std::vector<array> Custom::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  auto [_, vjps] = mlx::core::vjp(fallback_, primals, cotangents);
+  std::vector<array> vjp_outs;
+  for (int i = 0, j = 0; i < vjps.size(); ++i) {
+    if (j < argnums.size() && i == argnums[j]) {
+      vjp_outs.push_back(vjps[i]);
+      j++;
+    }
+  }
+  return vjp_outs;
+}
+
+std::vector<array> Custom::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  std::vector<array> all_tangents;
+  for (int i = 0, j = 0; i < primals.size(); i++) {
+    if (j < argnums.size() && i == argnums[j]) {
+      all_tangents.emplace_back(tangents[j++]);
+    } else {
+      all_tangents.emplace_back(zeros_like(primals[i]));
+    }
+  }
+  auto [_, jvps] = mlx::core::jvp(fallback_, primals, all_tangents);
+  return jvps;
+}
+
+std::pair<std::vector<array>, std::vector<int>> Custom::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto outputs = mlx::core::vmap(fallback_, axes)(inputs);
+  auto out_axes = std::vector<int>(outputs.size(), 0);
+  return {outputs, out_axes};
+}
+
+array rms_norm(
+    const array& x,
+    const std::optional<array>& weight,
+    float eps,
+    StreamOrDevice s_ /* = {} */) {
+  bool has_weight = weight.has_value();
+
+  if (x.ndim() == 0) {
+    std::ostringstream msg;
+    msg << "[rms_norm] Input must have at least 1 dimension but got input with "
+           "0 dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  if (has_weight) {
+    if ((*weight).ndim() != 1) {
+      std::ostringstream msg;
+      msg << "[rms_norm] (*weight) must have 1 dimension but has "
+          << (*weight).ndim() << " dimensions.";
+      throw std::invalid_argument(msg.str());
+    }
+    if ((*weight).size() != x.shape(-1)) {
+      std::ostringstream msg;
+      msg << "[rms_norm] (*weight) must have the same size as the last dimension of"
+             " x but has "
+          << (*weight).size() << " elements.";
+      throw std::invalid_argument(msg.str());
+    }
+  }
+
+  auto out_type = (weight.has_value()) ? result_type(x, (*weight)) : x.dtype();
+  if (!issubdtype(out_type, floating)) {
+    std::ostringstream msg;
+    msg << "[rms_norm] Received unsupported type " << out_type << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto s = to_stream(s_);
+  auto fallback =
+      [has_weight, eps, out_type, s](const std::vector<array>& inputs) {
+        auto x = astype(inputs[0], float32, s);
+        x = multiply(
+            x,
+            rsqrt(
+                add(mean(square(x, s), -1, /* keepdims */ true, s),
+                    array(eps, float32),
+                    s),
+                s),
+            s);
+        x = astype(x, out_type, s);
+
+        if (has_weight) {
+          x = multiply(x, inputs[1], s);
+        }
+
+        return std::vector<array>{x};
+      };
+
+  auto passed_weight =
+      (has_weight) ? astype(*weight, out_type, s) : array(1, out_type);
+
+  if (!RMSNorm::use_fallback(s)) {
+    return array(
+        x.shape(),
+        out_type,
+        std::make_shared<RMSNorm>(s, fallback, eps),
+        {astype(x, out_type, s), passed_weight});
+  }
+  return fallback({x, passed_weight})[0];
+}
+
+std::vector<array> RMSNorm::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  assert(primals.size() == 2);
+  assert(outputs.size() == 1);
+  assert(cotangents.size() == 1);
+
+  auto s = stream();
+  auto fallback = [eps = eps_, s](const std::vector<array>& inputs) {
+    auto& x = inputs[0];
+    auto& w = inputs[1];
+    auto& g = inputs[2];
+
+    std::vector<array> vjps;
+
+    auto n = rsqrt(
+        add(mean(square(x, s), /* axis= */ -1, /* keepdims= */ true, s),
+            array(eps, x.dtype()),
+            s),
+        s);
+    auto n3 = power(n, array(3, x.dtype()), s);
+
+    // df/dx
+    auto gw = multiply(g, w, s);
+    auto t = mean(multiply(gw, x, s), /* axis= */ -1, /* keepdims= */ true, s);
+    t = multiply(multiply(x, t, s), n3, s);
+    vjps.push_back(subtract(multiply(gw, n, s), t, s));
+
+    // df/dw
+    std::vector<int> axes(g.ndim() - 1);
+    std::iota(axes.begin(), axes.end(), 0);
+    if (w.ndim() == 0) {
+      vjps.push_back(zeros_like(w, s));
+    } else {
+      vjps.push_back(sum(
+          multiply(g, multiply(x, n, s), s), axes, /* keepdims= */ false, s));
+    }
+
+    return vjps;
+  };
+
+  auto vjps = array::make_arrays(
+      {primals[0].shape(), primals[1].shape()},
+      {primals[0].dtype(), primals[1].dtype()},
+      std::make_shared<RMSNormVJP>(s, fallback, eps_),
+      {primals[0], primals[1], cotangents[0]});
+
+  std::vector<array> returned_vjps;
+  for (auto& arg : argnums) {
+    returned_vjps.push_back(std::move(vjps[arg]));
+  }
+
+  return returned_vjps;
+}
+
+bool RMSNorm::is_equivalent(const Primitive& other) const {
+  const RMSNorm& a_other = static_cast<const RMSNorm&>(other);
+  return eps_ == a_other.eps_;
+}
+
+bool RMSNormVJP::is_equivalent(const Primitive& other) const {
+  const RMSNormVJP& a_other = static_cast<const RMSNormVJP&>(other);
+  return eps_ == a_other.eps_;
+}
+
+array layer_norm(
+    const array& x,
+    const std::optional<array>& weight,
+    const std::optional<array>& bias,
+    float eps,
+    StreamOrDevice s_ /* = {} */) {
+  bool has_weight = weight.has_value();
+  bool has_bias = bias.has_value();
+
+  if (x.ndim() == 0) {
+    std::ostringstream msg;
+    msg << "[layer_norm] Input must have at least 1 dimension but got input with "
+           "0 dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  if (has_weight && (*weight).ndim() != 1) {
+    std::ostringstream msg;
+    msg << "[layer_norm] weight must have 1 dimension but has "
+        << (*weight).ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  if (has_bias && (*bias).ndim() != 1) {
+    std::ostringstream msg;
+    msg << "[layer_norm] bias must have 1 dimension but has " << (*bias).ndim()
+        << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto out_type = (has_weight)
+      ? ((has_bias) ? result_type(x, *weight, *bias) : result_type(x, *weight))
+      : x.dtype();
+  if (!issubdtype(out_type, floating)) {
+    std::ostringstream msg;
+    msg << "[layer_norm] Received unsupported type " << out_type << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto s = to_stream(s_);
+  auto fallback = [has_weight, has_bias, eps, out_type, s](
+                      const std::vector<array>& inputs) {
+    auto x = astype(inputs[0], float32, s);
+
+    auto mu = mean(x, /* axis= */ -1, /* keepdims= */ true, s);
+    auto xc = subtract(x, mu, s);
+    auto v = mean(square(xc, s), /* axis= */ -1, /* keepdims= */ true, s);
+
+    x = multiply(xc, rsqrt(add(v, array(eps, float32), s), s));
+    x = astype(x, out_type, s);
+
+    // If the LN is affine then transform x according to the weight and bias
+    if (has_weight) {
+      x = multiply(x, inputs[1], s);
+    }
+    if (has_bias) {
+      x = add(x, inputs[2], s);
+    }
+
+    return std::vector<array>{x};
+  };
+
+  auto passed_weight =
+      (has_weight) ? astype(*weight, out_type, s) : array(1, out_type);
+  auto passed_bias =
+      (has_bias) ? astype(*bias, out_type, s) : array(0, out_type);
+
+  if (!LayerNorm::use_fallback(s)) {
+    return array(
+        x.shape(),
+        out_type,
+        std::make_shared<LayerNorm>(s, fallback, eps),
+        {astype(x, out_type, s), passed_weight, passed_bias});
+  }
+  return fallback({x, passed_weight, passed_bias})[0];
+}
+
+std::vector<array> LayerNorm::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  assert(primals.size() == 3);
+  assert(outputs.size() == 1);
+  assert(cotangents.size() == 1);
+
+  auto s = stream();
+  auto fallback = [eps = eps_, s](const std::vector<array>& inputs) {
+    auto& x = inputs[0];
+    auto& w = inputs[1];
+    auto& b = inputs[2];
+    auto& g = inputs[3];
+
+    std::vector<array> vjps;
+
+    auto norm = number_of_elements(x, {-1}, true, x.dtype(), s);
+    auto sumx = sum(x, /* axis= */ -1, /* keepdims= */ true, s);
+    auto sumx2 = sum(square(x, s), /* axis= */ -1, /* keepdims= */ true, s);
+    auto mu = multiply(sumx, norm, s);
+    auto mu2 = multiply(sumx2, norm, s);
+    auto var = subtract(mu2, square(mu, s), s);
+    auto n = rsqrt(add(var, array(eps, x.dtype()), s));
+    auto n3 = power(n, array(3, x.dtype()), s);
+    auto x_c = subtract(x, mu, s);
+
+    // df/dx
+    auto wg = multiply(w, g, s);
+    auto sumwg =
+        multiply(sum(wg, /* axis= */ -1, /* keepdims= */ true, s), norm, s);
+    auto sumwgxc = multiply(
+        sum(multiply(wg, x_c, s), /* axis= */ -1, /* keepdims= */ true, s),
+        norm,
+        s);
+    auto t1 = multiply(multiply(x_c, sumwgxc, s), n3, s);
+    auto t2 = multiply(subtract(wg, sumwg, s), n, s);
+    vjps.push_back(subtract(t2, t1, s));
+
+    // df/dw
+    std::vector<int> axes(g.ndim() - 1);
+    std::iota(axes.begin(), axes.end(), 0);
+    if (w.ndim() == 0) {
+      vjps.push_back(zeros_like(w, s));
+    } else {
+      vjps.push_back(sum(
+          multiply(g, multiply(x_c, n, s), s), axes, /* keepdims= */ false, s));
+    }
+
+    // df/db
+    if (b.ndim() == 0) {
+      vjps.push_back(zeros_like(w, s));
+    } else {
+      vjps.push_back(sum(g, axes, /* keepdims= */ false, s));
+    }
+
+    return vjps;
+  };
+
+  auto vjps = array::make_arrays(
+      {primals[0].shape(), primals[1].shape(), primals[2].shape()},
+      {primals[0].dtype(), primals[1].dtype(), primals[2].dtype()},
+      std::make_shared<LayerNormVJP>(s, fallback, eps_),
+      {primals[0], primals[1], primals[2], cotangents[0]});
+
+  std::vector<array> returned_vjps;
+  for (auto& arg : argnums) {
+    returned_vjps.push_back(std::move(vjps[arg]));
+  }
+
+  return returned_vjps;
+}
+
+bool LayerNorm::is_equivalent(const Primitive& other) const {
+  const LayerNorm& a_other = static_cast<const LayerNorm&>(other);
+  return eps_ == a_other.eps_;
+}
+
+bool LayerNormVJP::is_equivalent(const Primitive& other) const {
+  const LayerNormVJP& a_other = static_cast<const LayerNormVJP&>(other);
+  return eps_ == a_other.eps_;
+}
+
+array rope(
+    std::vector<array> inputs,
+    int dims,
+    bool traditional,
+    float base,
+    float scale,
+    bool forward,
+    StreamOrDevice s) {
+  auto& x = inputs[0];
+  auto& offset = inputs[1];
+  if (x.ndim() < 3) {
+    std::ostringstream msg;
+    msg << "[rope] Input must have at least 3 dimensions but got input with "
+        << x.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  if (!issubdtype(x.dtype(), floating)) {
+    std::ostringstream msg;
+    msg << "[rope] Input must be a floating type but got " << x.dtype() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  if (offset.ndim() > 1) {
+    std::ostringstream msg;
+    msg << "[rope] offset must have at most one dimension but has shape "
+        << offset.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  if (offset.size() != 1 && offset.size() != x.shape(0)) {
+    std::ostringstream msg;
+    msg << "[rope] offset must be a scalar or vector with " << x.shape(0)
+        << " elements but has shape " << offset.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  if (!issubdtype(offset.dtype(), integer)) {
+    std::ostringstream msg;
+    msg << "[rope] offset must be an integer but got type " << offset.dtype()
+        << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  if (offset.dtype().size() != 4) {
+    inputs[1] = astype(offset, int32, s);
+  }
+  if (inputs.size() == 3 &&
+      (inputs[2].ndim() != 1 || inputs[2].shape(0) != dims / 2)) {
+    std::ostringstream msg;
+    msg << "[rope] freqs must be one dimensional with size " << dims / 2
+        << " but got shape " << inputs[2].shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto fallback = [dims, traditional, base, scale, forward, s](
+                      std::vector<array> inputs) {
+    auto x = inputs[0];
+    auto shape = x.shape();
+    if (x.ndim() == 3) {
+      x = expand_dims(x, 1, s);
+    } else if (x.ndim() > 4) {
+      x = flatten(x, 1, 1 + (x.ndim() - 4), s);
+    }
+
+    auto B = x.shape(0);
+    auto N = x.shape(1);
+    auto T = x.shape(2);
+    auto t = x.dtype();
+    // Compute sines and cosines
+    auto half_dims = dims / 2;
+    auto offset = inputs[1];
+    if (offset.size() > 1) {
+      offset = expand_dims(offset, {-1, -2}, s);
+    }
+    auto positions =
+        multiply(add(arange(x.shape(2), t, s), offset, s), array(scale, t), s);
+
+    auto default_inv_freqs = [&inputs, &s, &t, base, half_dims]() {
+      return exp(
+          multiply(
+              arange(0, -half_dims, -1, t, s),
+              array(std::log(base) / half_dims, t),
+              s),
+          s);
+    };
+
+    auto inv_freqs = inputs.size() == 3 ? astype(reciprocal(inputs[2], s), t, s)
+                                        : default_inv_freqs();
+    auto theta = multiply(expand_dims(positions, -1, s), inv_freqs, s);
+    auto coss = cos(theta, s);
+    auto sins = sin(theta, s);
+
+    auto apply_rope = [forward, s](
+                          const array& x1,
+                          const array& x2,
+                          const array& coss,
+                          const array& sins) {
+      std::vector<array> outs;
+      if (forward) {
+        outs.push_back(
+            subtract(multiply(x1, coss, s), multiply(x2, sins, s), s));
+        outs.push_back(add(multiply(x1, sins, s), multiply(x2, coss, s), s));
+      } else {
+        outs.push_back(add(multiply(x2, sins, s), multiply(x1, coss, s), s));
+        outs.push_back(
+            subtract(multiply(x2, coss, s), multiply(x1, sins, s), s));
+      }
+      return outs;
+    };
+
+    if (traditional) {
+      auto x1 = slice(x, {0, 0, 0, 0}, {B, N, T, dims}, {1, 1, 1, 2}, s);
+      auto x2 = slice(x, {0, 0, 0, 1}, {B, N, T, dims}, {1, 1, 1, 2}, s);
+      auto outs = apply_rope(x1, x2, coss, sins);
+      for (auto& o : outs) {
+        o = expand_dims(o, -1, s);
+      }
+      auto out = reshape(concatenate(outs, -1, s), {B, N, T, dims}, s);
+      if (dims < x.shape(-1)) {
+        out =
+            concatenate({out, slice(x, {0, 0, 0, dims}, x.shape(), s)}, -1, s);
+      }
+      return std::vector<array>{reshape(out, shape, s)};
+    } else {
+      auto out_s = x.shape();
+      out_s.back() = half_dims;
+      auto x1 = slice(x, {0, 0, 0, 0}, out_s, s);
+      out_s.back() = dims;
+      auto x2 = slice(x, {0, 0, 0, half_dims}, out_s, s);
+
+      auto outs = apply_rope(x1, x2, coss, sins);
+      if (dims < x.shape(-1)) {
+        outs.push_back(slice(x, {0, 0, 0, dims}, x.shape(), s));
+      }
+      return std::vector<array>{reshape(concatenate(outs, -1, s), shape, s)};
+    }
+  };
+  auto stream = to_stream(s);
+  if (!RoPE::use_fallback(stream)) {
+    return array(
+        x.shape(),
+        x.dtype(),
+        std::make_shared<RoPE>(
+            stream, fallback, dims, traditional, base, scale, forward),
+        std::move(inputs));
+  }
+  return fallback(std::move(inputs))[0];
+}
+
+array rope(
+    const array& x,
+    int dims,
+    bool traditional,
+    std::optional<float> base,
+    float scale,
+    const array& offset,
+    const std::optional<array>& freqs /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  std::vector<array> inputs = {x, offset};
+  if (freqs) {
+    inputs.push_back(astype(*freqs, float32, s));
+    if (base) {
+      throw std::invalid_argument(
+          "[rope] Only one of base or freqs can have a value.");
+    }
+  } else if (!base) {
+    throw std::invalid_argument("[rope] Neither base nor freqs has a value.");
+  }
+  return rope(
+      std::move(inputs),
+      dims,
+      traditional,
+      base.has_value() ? *base : 1.0,
+      scale,
+      true,
+      s);
+}
+
+array rope(
+    const array& x,
+    int dims,
+    bool traditional,
+    std::optional<float> base,
+    float scale,
+    int offset,
+    const std::optional<array>& freqs /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  return rope(
+      x, dims, traditional, base, scale, array(offset, int32), freqs, s);
+}
+
+std::vector<array> RoPE::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  auto s = stream();
+  auto fallback = [dims = dims_,
+                   traditional = traditional_,
+                   base = base_,
+                   scale = scale_,
+                   forward = forward_,
+                   s](std::vector<array> inputs) {
+    return std::vector<array>{
+        rope(std::move(inputs), dims, traditional, base, scale, !forward, s)};
+  };
+  if (argnums.size() > 1 || argnums[0] != 0) {
+    throw std::invalid_argument(
+        "[RoPE::vjp] vjp for offset or frequencies not supported");
+  }
+  auto inputs = std::vector<array>{cotangents[0], primals[1]};
+  if (primals.size() == 3) {
+    inputs.push_back(primals[2]);
+  }
+  return {array(
+      cotangents[0].shape(),
+      cotangents[0].dtype(),
+      std::make_shared<RoPE>(
+          s, fallback, dims_, traditional_, base_, scale_, !forward_),
+      std::move(inputs))};
+}
+
+bool RoPE::is_equivalent(const Primitive& other) const {
+  const RoPE& a_other = static_cast<const RoPE&>(other);
+  return (
+      dims_ == a_other.dims_ && base_ == a_other.base_ &&
+      scale_ == a_other.scale_ && traditional_ == a_other.traditional_ &&
+      forward_ == a_other.forward_);
+}
+
+/** Computes: O = softmax(Q @ K.T) @ V **/
+array scaled_dot_product_attention(
+    const array& queries,
+    const array& keys,
+    const array& values,
+    const float scale,
+    const std::string& mask_mode /* = "" */,
+    const std::vector<array>& mask_arrs /* = {} */,
+    const std::optional<array>& sinks /* = {} */,
+    StreamOrDevice s /* = {}*/) {
+  for (const auto& tensor : {queries, keys, values}) {
+    if (tensor.ndim() != 4) {
+      std::ostringstream msg;
+      msg << "[scaled_dot_product_attention] input with shape "
+          << tensor.shape() << " expected to be rank 4";
+      throw std::invalid_argument(msg.str());
+    }
+  }
+  // Check valid mask
+  if (mask_mode != "" && mask_mode != "causal" && mask_mode != "array") {
+    std::ostringstream msg;
+    msg << "[scaled_dot_product_attention] Invalid mask_mode " << mask_mode
+        << ". mask_mode must be 'causal', 'array' or ''.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  bool do_causal = false;
+  bool has_mask = false;
+  bool has_arr_mask = false;
+  bool has_bool_mask = false;
+
+  if (mask_mode == "causal") {
+    has_mask = true;
+    do_causal = true;
+
+    if (!mask_arrs.empty()) {
+      std::ostringstream msg;
+      msg << "[scaled_dot_product_attention] Invalid mask_arrs for mask_mode "
+          << "'casusal'. No array masks supported.";
+      throw std::invalid_argument(msg.str());
+    }
+  }
+
+  if (mask_mode == "array" || (mask_mode == "" && !mask_arrs.empty())) {
+    if (mask_arrs.size() != 1) {
+      std::ostringstream msg;
+      msg << "[scaled_dot_product_attention] Invalid mask_arrs for mask_mode "
+          << "'" << mask_mode << "'. Only 1 mask array is supported, got "
+          << mask_arrs.size() << "arrays.";
+      throw std::invalid_argument(msg.str());
+    }
+
+    has_mask = true;
+    has_arr_mask = true;
+    has_bool_mask = mask_arrs[0].dtype() == bool_;
+  }
+
+  if (has_arr_mask && (mask_arrs[0]).ndim() > 4) {
+    std::ostringstream msg;
+    msg << "[scaled_dot_product_attention] the mask with shape "
+        << mask_arrs[0].shape() << " expected to have at most rank 4.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  const size_t batch_dim = queries.shape(0);
+  for (const auto& tensor : {keys, values}) {
+    if (tensor.shape(0) != batch_dim) {
+      std::ostringstream msg;
+      msg << "[scaled_dot_product_attention] mismatching batch dimension for input with shape "
+          << tensor.shape() << ".";
+      throw std::invalid_argument(msg.str());
+    }
+  }
+
+  // Q, K must have matching last dims (d_k aka 'head_dim');
+  if (queries.shape(-1) != keys.shape(-1)) {
+    std::ostringstream msg;
+    msg << "[scaled_dot_product_attention] query, keys expected to have matching last dimension; found query shape "
+        << queries.shape() << " for keys shape " << keys.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // K, V must have matching number of heads (n_kv_heads);
+  auto n_q_heads = queries.shape(-3);
+  auto n_kv_heads = keys.shape(-3);
+
+  if (keys.shape(-3) != values.shape(-3)) {
+    std::ostringstream msg;
+    msg << "[scaled_dot_product_attention] keys, values expected to have matching n_kv_heads; found keys with n_heads "
+        << keys.shape(-3) << " for values with n_heads " << values.shape(-3)
+        << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // n_heads % n_kv_heads == 0; n_heads >= 1, n_kv_heads >= 1.
+  if (n_q_heads % n_kv_heads != 0) {
+    std::ostringstream msg;
+    msg << "[scaled_dot_product_attention] n_heads must be a multiple of n_kv_heads, found n_heads "
+        << n_q_heads << " for n_kv_heads " << n_kv_heads << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto final_type = result_type(queries, keys, values);
+  if (!issubdtype(final_type, floating)) {
+    std::ostringstream msg;
+    msg << "[scaled_dot_product_attention] Received unsupported type "
+        << final_type << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  bool has_sinks = sinks.has_value();
+
+  auto q = astype(queries, final_type, s);
+  auto k = astype(keys, final_type, s);
+  auto v = astype(values, final_type, s);
+
+  auto fallback = [scale,
+                   final_type,
+                   n_q_heads,
+                   n_kv_heads,
+                   do_causal,
+                   has_sinks,
+                   has_arr_mask,
+                   s](const std::vector<array>& inputs) {
+    auto q = multiply(array(scale, inputs[0].dtype()), inputs[0], s);
+    int n_repeats = n_q_heads / n_kv_heads;
+    int B = q.shape(0);
+    int L = q.shape(2);
+    auto k = inputs[1];
+    auto v = inputs[2];
+    if (n_repeats > 1) {
+      q = unflatten(q, 1, {n_kv_heads, n_repeats}, s);
+      k = expand_dims(k, 2, s);
+      v = expand_dims(v, 2, s);
+    }
+    auto scores = matmul(q, swapaxes(k, -1, -2, s), s);
+    if (has_arr_mask || do_causal) {
+      // Mask must be broadcast-compatible with [B, n_q_heads, L_q, L_kv]
+      auto make_or_fetch_mask = [&]() {
+        if (do_causal) {
+          int kL = k.shape(-2);
+          int qL = q.shape(-2);
+          int q_off = (kL - qL) < 0 ? 0 : (kL - qL);
+          auto q_idx = arange(q_off, q_off + qL, s);
+          auto k_idx = arange(0, kL, s);
+          q_idx = expand_dims(q_idx, 1, s);
+          k_idx = expand_dims(k_idx, 0, s);
+          return greater_equal(q_idx, k_idx, s);
+        }
+        return inputs[3];
+      };
+      auto mask = make_or_fetch_mask();
+
+      if (n_repeats > 1 && mask.ndim() >= 3) {
+        if (mask.shape(-3) == 1) {
+          mask = expand_dims(mask, -3, s);
+        } else {
+          mask = unflatten(mask, -3, {n_kv_heads, n_repeats}, s);
+        }
+      }
+      if (mask.dtype() == bool_) {
+        scores = where(
+            mask, scores, array(finfo(scores.dtype()).min, scores.dtype()), s);
+      } else {
+        scores = add(scores, mask, s);
+      }
+    }
+    if (has_sinks) {
+      auto sinks = inputs.back();
+      // scores has shape B N_q N_k L_q L_k
+      sinks = expand_dims(sinks, {0, 2, 3}, s);
+      if (scores.ndim() == 5) {
+        sinks = unflatten(sinks, 1, {n_kv_heads, n_repeats}, s);
+      }
+      auto bsx_shape = scores.shape();
+      bsx_shape.back() = 1;
+      scores = concatenate({broadcast_to(sinks, bsx_shape, s), scores}, -1, s);
+    }
+    scores = softmax(scores, std::vector<int>{-1}, true, s);
+    if (has_sinks) {
+      // Slice off scores
+      auto start = Shape(scores.ndim(), 0);
+      start.back() = 1;
+      auto stop = scores.shape();
+      scores = slice(scores, std::move(start), std::move(stop), s);
+    }
+    auto out = matmul(scores, v, s);
+    if (n_repeats > 1) {
+      out = flatten(out, 1, 2, s);
+    }
+    return std::vector<array>{out};
+  };
+
+  auto stream = to_stream(s);
+  std::vector<array> inputs = {q, k, v};
+  if (has_arr_mask) {
+    // Check type
+    auto mask_arr = mask_arrs[0];
+    has_bool_mask = mask_arr.dtype() == bool_;
+    if (promote_types(mask_arr.dtype(), final_type) != final_type) {
+      std::ostringstream msg;
+      msg << "[scaled_dot_product_attention] Mask type must promote to output type "
+          << final_type << ".";
+      throw std::invalid_argument(msg.str());
+    } else if (!has_bool_mask) {
+      mask_arr = astype(mask_arr, final_type, stream);
+    }
+    // Broadcast mask
+    auto mask_shape = queries.shape();
+    mask_shape.back() = keys.shape(-2);
+    inputs.push_back(broadcast_to(mask_arr, mask_shape, stream));
+  }
+  if (has_sinks) {
+    if (promote_types(sinks->dtype(), final_type) != final_type) {
+      std::ostringstream msg;
+      msg << "[scaled_dot_product_attention] Type of sinks must promote to output type "
+          << final_type << ".";
+      throw std::invalid_argument(msg.str());
+    }
+    if (sinks->ndim() != 1 || sinks->shape(0) != n_q_heads) {
+      std::ostringstream msg;
+      msg << "[scaled_dot_product_attention] Received invalid shape for sinks "
+          << sinks->shape() << ".";
+      throw std::invalid_argument(msg.str());
+    }
+    inputs.push_back(astype(*sinks, final_type, stream));
+  }
+
+  if (!ScaledDotProductAttention::use_fallback(
+          q, k, v, has_mask, has_arr_mask, do_causal, stream)) {
+    auto out_shape = Shape{q.shape(0), q.shape(1), q.shape(2), v.shape(-1)};
+    return array(
+        std::move(out_shape),
+        final_type,
+        std::make_shared<ScaledDotProductAttention>(
+            stream, fallback, scale, do_causal, has_sinks),
+        std::move(inputs));
+  }
+  return fallback(std::move(inputs))[0];
+}
+
+bool ScaledDotProductAttention::is_equivalent(const Primitive& other) const {
+  const ScaledDotProductAttention& a_other =
+      static_cast<const ScaledDotProductAttention&>(other);
+  return scale_ == a_other.scale_ && do_causal_ == a_other.do_causal_ &&
+      has_sinks_ == a_other.has_sinks_;
+}
+
+bool Quantize::is_equivalent(const Primitive& other) const {
+  const Quantize& p_other = static_cast<const Quantize&>(other);
+  return (
+      p_other.group_size_ == group_size_ && p_other.bits_ == bits_ &&
+      p_other.mode_ == mode_ && p_other.dequantize_ == dequantize_);
+}
+
+std::vector<Shape> Quantize::output_shapes(const std::vector<array>& inputs) {
+  auto& w = inputs[0];
+  if (dequantize_) {
+    auto out_size = w.shape(-1) * 32 / bits_;
+    auto out_shape = w.shape();
+    out_shape.back() = out_size;
+    return {std::move(out_shape)};
+  } else {
+    auto wq_shape = w.shape();
+    wq_shape.back() = w.shape(-1) * bits_ / 32;
+    auto sshape = w.shape();
+    sshape.back() = w.shape(-1) / group_size_;
+    if (inputs.size() == 2) {
+      return {std::move(wq_shape), std::move(sshape)};
+    } else {
+      auto bshape = sshape;
+      return {std::move(wq_shape), std::move(sshape), std::move(bshape)};
+    }
+  }
+}
+
+} // namespace mlx::core::fast
diff --git a/ml-stable-diffusion/mlx/mlx/fast.h b/ml-stable-diffusion/mlx/mlx/fast.h
new file mode 100644
index 0000000000000000000000000000000000000000..3cbff60e462b888932b44b9950ec8dc10162a21b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/fast.h
@@ -0,0 +1,102 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <optional>
+#include <variant>
+
+#include "mlx/utils.h"
+
+namespace mlx::core::fast {
+
+array rms_norm(
+    const array& x,
+    const std::optional<array>& weight,
+    float eps,
+    StreamOrDevice s = {});
+
+array layer_norm(
+    const array& x,
+    const std::optional<array>& weight,
+    const std::optional<array>& bias,
+    float eps,
+    StreamOrDevice s = {});
+
+array rope(
+    const array& x,
+    int dims,
+    bool traditional,
+    std::optional<float> base,
+    float scale,
+    int offset,
+    const std::optional<array>& freqs = std::nullopt,
+    StreamOrDevice s = {});
+
+array rope(
+    const array& x,
+    int dims,
+    bool traditional,
+    std::optional<float> base,
+    float scale,
+    const array& offset,
+    const std::optional<array>& freqs = std::nullopt,
+    StreamOrDevice s = {});
+
+/** Computes: O = softmax(Q @ K.T) @ V **/
+array scaled_dot_product_attention(
+    const array& queries,
+    const array& keys,
+    const array& values,
+    const float scale,
+    const std::string& mask_mode = "",
+    const std::vector<array>& mask_arrs = {},
+    const std::optional<array>& sinks = {},
+    StreamOrDevice s = {});
+
+using TemplateArg = std::variant<int, bool, Dtype>;
+using ScalarArg = std::variant<bool, int, float>;
+
+using CustomKernelFunction = std::function<std::vector<array>(
+    const std::vector<array>&,
+    const std::vector<Shape>&,
+    const std::vector<Dtype>&,
+    std::tuple<int, int, int>,
+    std::tuple<int, int, int>,
+    std::vector<std::pair<std::string, TemplateArg>>,
+    std::optional<float>,
+    bool,
+    StreamOrDevice)>;
+
+CustomKernelFunction metal_kernel(
+    const std::string& name,
+    const std::vector<std::string>& input_names,
+    const std::vector<std::string>& output_names,
+    const std::string& source,
+    const std::string& header = "",
+    bool ensure_row_contiguous = true,
+    bool atomic_outputs = false);
+
+CustomKernelFunction cuda_kernel(
+    const std::string& name,
+    const std::vector<std::string>& input_names,
+    const std::vector<std::string>& output_names,
+    const std::string& source,
+    const std::string& header = "",
+    bool ensure_row_contiguous = true,
+    int shared_memory = 0);
+
+std::vector<array> precompiled_cuda_kernel(
+    const std::string& name,
+    const std::string& compiled_source,
+    const std::vector<array>& inputs,
+    const std::vector<Shape>& output_shapes,
+    const std::vector<Dtype>& output_dtypes,
+    const std::vector<ScalarArg>& scalars,
+    std::tuple<int, int, int> grid,
+    std::tuple<int, int, int> threadgroup,
+    int shared_memory = 0,
+    std::optional<float> init_value = std::nullopt,
+    bool ensure_row_contiguous = false,
+    StreamOrDevice s = {});
+
+} // namespace mlx::core::fast
diff --git a/ml-stable-diffusion/mlx/mlx/fast_primitives.h b/ml-stable-diffusion/mlx/mlx/fast_primitives.h
new file mode 100644
index 0000000000000000000000000000000000000000..a8000485a07b74cb27385582fe7bd9b236556294
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/fast_primitives.h
@@ -0,0 +1,346 @@
+// Copyright © 2024 Apple Inc.
+
+#include <optional>
+#include <variant>
+
+#include "mlx/primitives.h"
+
+namespace mlx::core::fast {
+
+// Custom primitive accepts a fallback function which it uses for
+// transformations. Transformations are virtual so that derived classes may
+// override the default behavior.
+class Custom : public Primitive {
+ public:
+  explicit Custom(
+      Stream stream,
+      std::function<std::vector<array>(std::vector<array>)> fallback)
+      : Primitive(stream), fallback_(fallback) {}
+
+  virtual std::pair<std::vector<array>, std::vector<int>> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes) override;
+
+  virtual std::vector<array> jvp(
+      const std::vector<array>& primals,
+      const std::vector<array>& tangents,
+      const std::vector<int>& argnums) override;
+
+  virtual std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const std::vector<array>& cotangents,
+      const std::vector<int>& argnums,
+      const std::vector<array>& outputs) override;
+
+ private:
+  std::function<std::vector<array>(std::vector<array>)> fallback_;
+};
+
+class RMSNorm : public Custom {
+ public:
+  RMSNorm(
+      Stream stream,
+      std::function<std::vector<array>(std::vector<array>)> fallback,
+      float eps)
+      : Custom(stream, fallback), eps_(eps) {}
+
+  static bool use_fallback(Stream stream);
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override {
+    throw std::runtime_error("NYI");
+  }
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const std::vector<array>& cotangents,
+      const std::vector<int>& argnums,
+      const std::vector<array>& outputs) override;
+
+  DEFINE_NAME(RMSNorm)
+  bool is_equivalent(const Primitive& other) const override;
+  DEFINE_INPUT_OUTPUT_SHAPE()
+
+  auto state() const {
+    return std::make_pair(nullptr, eps_);
+  }
+
+ private:
+  float eps_;
+};
+
+class RMSNormVJP : public Custom {
+ public:
+  RMSNormVJP(
+      Stream stream,
+      std::function<std::vector<array>(std::vector<array>)> fallback,
+      float eps)
+      : Custom(stream, fallback), eps_(eps) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override {
+    throw std::runtime_error("NYI");
+  }
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_NAME(RMSNormVJP)
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return std::make_pair(nullptr, eps_);
+  }
+
+ private:
+  float eps_;
+};
+
+class LayerNorm : public Custom {
+ public:
+  LayerNorm(
+      Stream stream,
+      std::function<std::vector<array>(std::vector<array>)> fallback,
+      float eps)
+      : Custom(stream, fallback), eps_(eps) {}
+
+  static bool use_fallback(Stream s);
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override {
+    throw std::runtime_error("NYI");
+  }
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const std::vector<array>& cotangents,
+      const std::vector<int>& argnums,
+      const std::vector<array>& outputs) override;
+
+  DEFINE_NAME(LayerNorm)
+  bool is_equivalent(const Primitive& other) const override;
+  DEFINE_INPUT_OUTPUT_SHAPE()
+  auto state() const {
+    return std::make_pair(nullptr, eps_);
+  }
+
+ private:
+  float eps_;
+};
+
+class LayerNormVJP : public Custom {
+ public:
+  LayerNormVJP(
+      Stream stream,
+      std::function<std::vector<array>(std::vector<array>)> fallback,
+      float eps)
+      : Custom(stream, fallback), eps_(eps) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override {
+    throw std::runtime_error("NYI");
+  }
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_NAME(LayerNormVJP)
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return std::make_pair(nullptr, eps_);
+  }
+
+ private:
+  float eps_;
+};
+
+class RoPE : public Custom {
+ public:
+  RoPE(
+      Stream stream,
+      std::function<std::vector<array>(std::vector<array>)> fallback,
+      int dims,
+      bool traditional,
+      float base,
+      float scale,
+      bool forward)
+      : Custom(stream, fallback),
+        dims_(dims),
+        traditional_(traditional),
+        base_(base),
+        scale_(scale),
+        forward_(forward) {}
+
+  static bool use_fallback(Stream s);
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override {
+    throw std::runtime_error("NYI");
+  }
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const std::vector<array>& cotangents,
+      const std::vector<int>& argnums,
+      const std::vector<array>& outputs) override;
+
+  DEFINE_NAME(RoPE)
+  bool is_equivalent(const Primitive& other) const override;
+  DEFINE_INPUT_OUTPUT_SHAPE()
+  auto state() const {
+    return std::make_tuple(
+        nullptr, dims_, traditional_, base_, scale_, forward_);
+  }
+
+ private:
+  int dims_;
+  bool traditional_;
+  float base_;
+  float scale_;
+  bool forward_;
+};
+
+class ScaledDotProductAttention : public Custom {
+ public:
+  explicit ScaledDotProductAttention(
+      Stream stream,
+      std::function<std::vector<array>(std::vector<array>)> fallback,
+      float scale,
+      bool do_causal,
+      bool has_sinks)
+      : Custom(stream, fallback),
+        scale_(scale),
+        do_causal_(do_causal),
+        has_sinks_(has_sinks) {}
+
+  static bool use_fallback(
+      const array& q,
+      const array& k,
+      const array& v,
+      bool has_mask,
+      bool has_arr_mask,
+      bool do_causal,
+      Stream s);
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override {
+    throw std::runtime_error("NYI");
+  }
+
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override {
+    eval_gpu(inputs, outputs[0]);
+  }
+
+  void eval_gpu(const std::vector<array>& inputs, array& out);
+  bool is_equivalent(const Primitive& other) const override;
+
+  DEFINE_NAME(ScaledDotProductAttention);
+  DEFINE_INPUT_OUTPUT_SHAPE()
+  auto state() const {
+    return std::make_tuple(nullptr, scale_, do_causal_, has_sinks_);
+  }
+
+ private:
+  float scale_;
+  bool do_causal_;
+  bool has_sinks_;
+};
+
+class Quantize : public Custom {
+ public:
+  explicit Quantize(
+      Stream stream,
+      std::function<std::vector<array>(std::vector<array>)> fallback,
+      int group_size,
+      int bits,
+      QuantizationMode mode,
+      bool dequantize)
+      : Custom(stream, fallback),
+        group_size_(group_size),
+        bits_(bits),
+        mode_(mode),
+        dequantize_(dequantize) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_NAME(Quantize);
+
+  bool is_equivalent(const Primitive& other) const override;
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  auto state() const {
+    return std::make_tuple(nullptr, group_size_, bits_, mode_, dequantize_);
+  }
+
+ private:
+  int group_size_;
+  int bits_;
+  QuantizationMode mode_;
+  bool dequantize_;
+};
+
+struct CustomKernelShapeInfo {
+  bool shape = false;
+  bool strides = false;
+  bool ndim = false;
+};
+
+using ScalarArg = std::variant<bool, int, float>;
+
+class CustomKernel : public Primitive {
+ public:
+  CustomKernel(
+      Stream stream,
+      std::string name,
+      std::string source,
+      std::tuple<int, int, int> grid,
+      std::tuple<int, int, int> threadgroup,
+      std::vector<CustomKernelShapeInfo> shape_infos,
+      bool ensure_row_contiguous,
+      std::optional<float> init_value,
+      std::vector<ScalarArg> scalar_arguments,
+      bool is_precompiled,
+      int shared_memory)
+      : Primitive(stream),
+        source_(std::move(source)),
+        name_(std::move(name)),
+        grid_(grid),
+        threadgroup_(threadgroup),
+        shape_infos_(std::move(shape_infos)),
+        ensure_row_contiguous_(ensure_row_contiguous),
+        init_value_(init_value),
+        scalar_arguments_(std::move(scalar_arguments)),
+        is_precompiled_(is_precompiled),
+        shared_memory_(shared_memory) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override {
+    throw std::runtime_error("Custom kernels only run on GPU.");
+  }
+
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_NAME(CustomKernel);
+
+ private:
+  std::string source_;
+  std::string name_;
+  std::tuple<int, int, int> grid_;
+  std::tuple<int, int, int> threadgroup_;
+  std::vector<CustomKernelShapeInfo> shape_infos_;
+  bool ensure_row_contiguous_;
+  std::optional<float> init_value_;
+  std::vector<ScalarArg> scalar_arguments_;
+  bool is_precompiled_;
+  int shared_memory_;
+};
+
+} // namespace mlx::core::fast
diff --git a/ml-stable-diffusion/mlx/mlx/fence.h b/ml-stable-diffusion/mlx/mlx/fence.h
new file mode 100644
index 0000000000000000000000000000000000000000..66c2b5f4911a3c8c27199ea9cb8f0e002cc3c706
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/fence.h
@@ -0,0 +1,39 @@
+// Copyright © 2024 Apple Inc.
+
+#include <vector>
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+/* A fence to be used for synchronizing work between streams.
+ *
+ * Calls to `wait` wait in the given stream until all previous calls to update
+ * are complete on their given stream.
+ *
+ * The array passed to `update` is computed and visible after the call to
+ * `wait` returns. The array passed to `wait` will not be read until all
+ * previous calls to `update` have completed.
+ *
+ * Note, calls to `update` should always from the same thread or explicitly
+ * synchronized so that they occur in sequence. Calls to `wait` can be on any
+ * thread.
+ *
+ * For the Metal back-end the fence supports slow (default) and fast mode.
+ * Fast mode requires setting the environment variable
+ * `MLX_METAL_FAST_SYNCH=1`. Fast mode also requires Metal 3.2+ (macOS 15+,
+ * iOS 18+).
+ */
+class Fence {
+ public:
+  Fence() {};
+  explicit Fence(Stream stream);
+
+  void update(Stream stream, const array& x);
+  void wait(Stream stream, const array& x);
+
+ private:
+  std::shared_ptr<void> fence_{nullptr};
+};
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/fft.cpp b/ml-stable-diffusion/mlx/mlx/fft.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6510faec1e8bee4eefd9dc2f5d83911e53b91fa6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/fft.cpp
@@ -0,0 +1,262 @@
+// Copyright © 2023 Apple Inc.
+#include <numeric>
+#include <set>
+
+#include "mlx/fft.h"
+#include "mlx/ops.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core::fft {
+
+array fft_impl(
+    const array& a,
+    Shape n,
+    const std::vector<int>& axes,
+    bool real,
+    bool inverse,
+    StreamOrDevice s) {
+  if (a.ndim() < 1) {
+    throw std::invalid_argument(
+        "[fftn] Requires array with at least one dimension.");
+  }
+  if (n.size() != axes.size()) {
+    throw std::invalid_argument("[fftn] Shape and axes have different sizes.");
+  }
+  if (axes.empty()) {
+    return a;
+  }
+
+  std::vector<size_t> valid_axes;
+  for (int ax : axes) {
+    valid_axes.push_back(ax < 0 ? ax + a.ndim() : ax);
+  }
+  std::set<int> unique_axes(valid_axes.begin(), valid_axes.end());
+  if (unique_axes.size() != axes.size()) {
+    std::ostringstream msg;
+    msg << "[fftn] Duplicated axis received " << axes;
+    throw std::invalid_argument(msg.str());
+  }
+  if (*unique_axes.begin() < 0 || *unique_axes.rbegin() >= a.ndim()) {
+    std::ostringstream msg;
+    msg << "[fftn] Invalid axis received for array with " << a.ndim()
+        << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // In the following shape manipulations there are three cases to consider:
+  // 1. In a complex to complex transform (fftn / ifftn) the output
+  //    and input shapes are the same.
+  // 2. In a real to complex transform (rfftn) n specifies the input dims
+  //    and the output dims are n[i] / 2 + 1
+  // 3  In a complex to real transform (irfftn) n specifies the output dims
+  //    and the input dims are n[i] / 2 + 1
+
+  if (std::any_of(n.begin(), n.end(), [](auto i) { return i <= 0; })) {
+    std::ostringstream msg;
+    msg << "[fftn] Invalid FFT output size requested " << n;
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto in_shape = a.shape();
+  for (int i = 0; i < valid_axes.size(); ++i) {
+    in_shape[valid_axes[i]] = n[i];
+  }
+  if (real && inverse) {
+    in_shape[valid_axes.back()] = n.back() / 2 + 1;
+  }
+
+  bool any_greater = false;
+  bool any_less = false;
+  for (int i = 0; i < in_shape.size(); ++i) {
+    any_greater |= in_shape[i] > a.shape()[i];
+    any_less |= in_shape[i] < a.shape()[i];
+  }
+
+  auto in = a;
+  if (any_less) {
+    in = slice(in, Shape(in.ndim(), 0), in_shape, s);
+  }
+  if (any_greater) {
+    // Pad with zeros
+    auto tmp = zeros(in_shape, a.dtype(), s);
+    in = slice_update(tmp, in, Shape(in.ndim(), 0), in.shape());
+  }
+
+  auto out_shape = in_shape;
+  if (real) {
+    auto ax = valid_axes.back();
+    out_shape[ax] = inverse ? n.back() : out_shape[ax] / 2 + 1;
+  }
+
+  auto in_type = real && !inverse ? float32 : complex64;
+  auto out_type = real && inverse ? float32 : complex64;
+  return array(
+      out_shape,
+      out_type,
+      std::make_shared<FFT>(to_stream(s), valid_axes, inverse, real),
+      {astype(in, in_type, s)});
+}
+
+array fft_impl(
+    const array& a,
+    const std::vector<int>& axes,
+    bool real,
+    bool inverse,
+    StreamOrDevice s) {
+  Shape n;
+  for (auto ax : axes) {
+    n.push_back(a.shape(ax));
+  }
+  if (real && inverse && a.ndim() > 0) {
+    n.back() = (n.back() - 1) * 2;
+  }
+  return fft_impl(a, n, axes, real, inverse, s);
+}
+
+array fft_impl(const array& a, bool real, bool inverse, StreamOrDevice s) {
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return fft_impl(a, axes, real, inverse, s);
+}
+
+array fftn(
+    const array& a,
+    const Shape& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  return fft_impl(a, n, axes, false, false, s);
+}
+array fftn(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  return fft_impl(a, axes, false, false, s);
+}
+array fftn(const array& a, StreamOrDevice s /* = {} */) {
+  return fft_impl(a, false, false, s);
+}
+
+array ifftn(
+    const array& a,
+    const Shape& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  return fft_impl(a, n, axes, false, true, s);
+}
+array ifftn(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  return fft_impl(a, axes, false, true, s);
+}
+array ifftn(const array& a, StreamOrDevice s /* = {} */) {
+  return fft_impl(a, false, true, s);
+}
+
+array rfftn(
+    const array& a,
+    const Shape& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  return fft_impl(a, n, axes, true, false, s);
+}
+array rfftn(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  return fft_impl(a, axes, true, false, s);
+}
+array rfftn(const array& a, StreamOrDevice s /* = {} */) {
+  return fft_impl(a, true, false, s);
+}
+
+array irfftn(
+    const array& a,
+    const Shape& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  return fft_impl(a, n, axes, true, true, s);
+}
+array irfftn(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  return fft_impl(a, axes, true, true, s);
+}
+
+array irfftn(const array& a, StreamOrDevice s /* = {} */) {
+  return fft_impl(a, true, true, s);
+}
+
+array fftshift(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  if (axes.empty()) {
+    return a;
+  }
+
+  Shape shifts;
+  for (int ax : axes) {
+    // Convert negative axes to positive
+    int axis = ax < 0 ? ax + a.ndim() : ax;
+    if (axis < 0 || axis >= a.ndim()) {
+      std::ostringstream msg;
+      msg << "[fftshift] Invalid axis " << ax << " for array with " << a.ndim()
+          << " dimensions.";
+      throw std::invalid_argument(msg.str());
+    }
+    // Match NumPy's implementation
+    shifts.push_back(a.shape(axis) / 2);
+  }
+
+  return roll(a, shifts, axes, s);
+}
+
+array ifftshift(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  if (axes.empty()) {
+    return a;
+  }
+
+  Shape shifts;
+  for (int ax : axes) {
+    // Convert negative axes to positive
+    int axis = ax < 0 ? ax + a.ndim() : ax;
+    if (axis < 0 || axis >= a.ndim()) {
+      std::ostringstream msg;
+      msg << "[ifftshift] Invalid axis " << ax << " for array with " << a.ndim()
+          << " dimensions.";
+      throw std::invalid_argument(msg.str());
+    }
+    // Match NumPy's implementation
+    int size = a.shape(axis);
+    shifts.push_back(-(size / 2));
+  }
+
+  return roll(a, shifts, axes, s);
+}
+
+// Default versions that operate on all axes
+array fftshift(const array& a, StreamOrDevice s /* = {} */) {
+  if (a.ndim() < 1) {
+    return a;
+  }
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return fftshift(a, axes, s);
+}
+
+array ifftshift(const array& a, StreamOrDevice s /* = {} */) {
+  if (a.ndim() < 1) {
+    return a;
+  }
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return ifftshift(a, axes, s);
+}
+
+} // namespace mlx::core::fft
diff --git a/ml-stable-diffusion/mlx/mlx/fft.h b/ml-stable-diffusion/mlx/mlx/fft.h
new file mode 100644
index 0000000000000000000000000000000000000000..163e06b804c58781641e2861ccdb15ce754aacf0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/fft.h
@@ -0,0 +1,167 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <variant>
+
+#include "array.h"
+#include "device.h"
+#include "utils.h"
+
+namespace mlx::core::fft {
+
+/** Compute the n-dimensional Fourier Transform. */
+array fftn(
+    const array& a,
+    const Shape& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array fftn(const array& a, const std::vector<int>& axes, StreamOrDevice s = {});
+array fftn(const array& a, StreamOrDevice s = {});
+
+/** Compute the n-dimensional inverse Fourier Transform. */
+array ifftn(
+    const array& a,
+    const Shape& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array ifftn(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array ifftn(const array& a, StreamOrDevice s = {});
+
+/** Compute the one-dimensional Fourier Transform. */
+inline array fft(const array& a, int n, int axis, StreamOrDevice s = {}) {
+  return fftn(a, {n}, {axis}, s);
+}
+inline array fft(const array& a, int axis = -1, StreamOrDevice s = {}) {
+  return fftn(a, {axis}, s);
+}
+
+/** Compute the one-dimensional inverse Fourier Transform. */
+inline array ifft(const array& a, int n, int axis, StreamOrDevice s = {}) {
+  return ifftn(a, {n}, {axis}, s);
+}
+inline array ifft(const array& a, int axis = -1, StreamOrDevice s = {}) {
+  return ifftn(a, {axis}, s);
+}
+
+/** Compute the two-dimensional Fourier Transform. */
+inline array fft2(
+    const array& a,
+    const Shape& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {}) {
+  return fftn(a, n, axes, s);
+}
+inline array fft2(
+    const array& a,
+    const std::vector<int>& axes = {-2, -1},
+    StreamOrDevice s = {}) {
+  return fftn(a, axes, s);
+}
+
+/** Compute the two-dimensional inverse Fourier Transform. */
+inline array ifft2(
+    const array& a,
+    const Shape& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {}) {
+  return ifftn(a, n, axes, s);
+}
+inline array ifft2(
+    const array& a,
+    const std::vector<int>& axes = {-2, -1},
+    StreamOrDevice s = {}) {
+  return ifftn(a, axes, s);
+}
+
+/** Compute the n-dimensional Fourier Transform on a real input. */
+array rfftn(
+    const array& a,
+    const Shape& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array rfftn(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array rfftn(const array& a, StreamOrDevice s = {});
+
+/** Compute the n-dimensional inverse of `rfftn`. */
+array irfftn(
+    const array& a,
+    const Shape& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array irfftn(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array irfftn(const array& a, StreamOrDevice s = {});
+
+/** Compute the one-dimensional Fourier Transform on a real input. */
+inline array rfft(const array& a, int n, int axis, StreamOrDevice s = {}) {
+  return rfftn(a, {n}, {axis}, s);
+}
+inline array rfft(const array& a, int axis = -1, StreamOrDevice s = {}) {
+  return rfftn(a, {axis}, s);
+}
+/** Compute the one-dimensional inverse of `rfft`. */
+inline array irfft(const array& a, int n, int axis, StreamOrDevice s = {}) {
+  return irfftn(a, {n}, {axis}, s);
+}
+inline array irfft(const array& a, int axis = -1, StreamOrDevice s = {}) {
+  return irfftn(a, {axis}, s);
+}
+
+/** Compute the two-dimensional Fourier Transform on a real input. */
+inline array rfft2(
+    const array& a,
+    const Shape& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {}) {
+  return rfftn(a, n, axes, s);
+}
+inline array rfft2(
+    const array& a,
+    const std::vector<int>& axes = {-2, -1},
+    StreamOrDevice s = {}) {
+  return rfftn(a, axes, s);
+}
+
+/** Compute the two-dimensional inverse of `rfft2`. */
+inline array irfft2(
+    const array& a,
+    const Shape& n,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {}) {
+  return irfftn(a, n, axes, s);
+}
+inline array irfft2(
+    const array& a,
+    const std::vector<int>& axes = {-2, -1},
+    StreamOrDevice s = {}) {
+  return irfftn(a, axes, s);
+}
+/** Shift the zero-frequency component to the center of the spectrum. */
+array fftshift(const array& a, StreamOrDevice s = {});
+
+/** Shift the zero-frequency component to the center of the spectrum along
+ * specified axes. */
+array fftshift(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+
+/** The inverse of fftshift. */
+array ifftshift(const array& a, StreamOrDevice s = {});
+
+/** The inverse of fftshift along specified axes. */
+array ifftshift(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+
+} // namespace mlx::core::fft
diff --git a/ml-stable-diffusion/mlx/mlx/graph_utils.cpp b/ml-stable-diffusion/mlx/mlx/graph_utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..854881bc942480a48fdba8a7532aa48d838c1ee7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/graph_utils.cpp
@@ -0,0 +1,175 @@
+// Copyright © 2023 Apple Inc.
+
+#include <functional>
+#include <optional>
+#include <sstream>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "mlx/graph_utils.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+const std::string& NodeNamer::get_name(const array& x) {
+  auto it = names.find(x.id());
+  if (it == names.end()) {
+    // Get the next name in the sequence
+    // [A, B, ..., Z, AA, AB, ...]
+    std::vector<char> letters;
+    auto var_num = names.size() + 1;
+    while (var_num > 0) {
+      letters.push_back('A' + (var_num - 1) % 26);
+      var_num = (var_num - 1) / 26;
+    }
+    names.emplace(x.id(), std::string(letters.rbegin(), letters.rend()));
+
+    return get_name(x);
+  }
+  return it->second;
+}
+
+void NodeNamer::set_name(const array& x, std::string n) {
+  names[x.id()] = std::move(n);
+}
+
+void depth_first_traversal(
+    std::function<void(array)> callback,
+    const std::vector<array>& outputs) {
+  std::function<void(const array&)> recurse;
+  std::unordered_set<std::uintptr_t> cache;
+  recurse = [&](const array& x) {
+    auto id = x.id();
+    if (cache.find(id) != cache.end()) {
+      return;
+    }
+    cache.insert(id);
+    for (auto& s : x.siblings()) {
+      cache.insert(s.id());
+    }
+    for (auto& in : x.inputs()) {
+      recurse(in);
+    }
+    callback(x);
+  };
+
+  for (auto& o : outputs) {
+    recurse(o);
+  }
+}
+
+void print_graph(
+    std::ostream& os,
+    NodeNamer namer,
+    const std::vector<array>& outputs) {
+  std::vector<array> tape;
+  std::vector<array> inputs;
+
+  depth_first_traversal(
+      [&](const array& x) {
+        if (x.has_primitive()) {
+          tape.push_back(x);
+        } else {
+          inputs.push_back(x);
+        }
+      },
+      outputs);
+
+  auto print_arrs = [&namer, &os](std::vector<array> arrs) {
+    for (auto& arr : arrs) {
+      os << namer.get_name(arr);
+      os << " [" << arr.shape() << ", " << arr.dtype() << "]";
+      if (&arr != &arrs.back()) {
+        os << ", ";
+      }
+    }
+  };
+
+  os << "Inputs: ";
+  print_arrs(inputs);
+  os << "\nOutputs: ";
+  print_arrs(outputs);
+  os << "\n";
+
+  for (auto& arr : tape) {
+    os << arr.primitive().name();
+    os << " ";
+    print_arrs(arr.inputs());
+    os << " -> ";
+    print_arrs(arr.outputs());
+    os << "\n";
+  }
+}
+
+void export_to_dot(
+    std::ostream& os,
+    NodeNamer namer,
+    const std::vector<array>& nodes) {
+  // Perform one DFS to mark arrays as intermediate if they are used as inputs
+  // to other arrays.
+  std::unordered_set<std::uintptr_t> intermediate_set;
+  depth_first_traversal(
+      [&](const array& x) {
+        // No primitive so it is an input
+        if (!x.has_primitive()) {
+          return;
+        }
+
+        for (auto& a : x.inputs()) {
+          intermediate_set.insert(a.id());
+        }
+      },
+      nodes);
+
+  // Now we got everything we need to make the graph. Arrays can be one of 3
+  // things:
+  //  1. Inputs, when they have no primitive ie are evaluated
+  //  2. Intermediates, when they are the intermediate set
+  //  3. Outputs, if they are not inputs and not intermediates
+
+  os << "digraph {" << std::endl;
+
+  depth_first_traversal(
+      [&](const array& x) {
+        if (!x.has_primitive()) {
+          os << "{ rank=source; \"" << namer.get_name(x) << "\"; }"
+             << std::endl;
+          return;
+        }
+
+        // Node for primitive
+        if (x.has_primitive()) {
+          os << "{ ";
+          os << x.primitive_id();
+          os << " [label =\"";
+          os << x.primitive().name();
+          os << "\", shape=rectangle]";
+          os << "; }" << std::endl;
+          // Arrows to primitive's inputs
+          for (auto& a : x.inputs()) {
+            os << '"' << namer.get_name(a) << "\" -> " << x.primitive_id()
+               << std::endl;
+          }
+        }
+
+        // Point outputs to their primitive
+        for (auto& a : x.outputs()) {
+          os << "{ ";
+          if (intermediate_set.find(a.id()) == intermediate_set.end()) {
+            os << "rank=sink; ";
+          }
+          os << '"' << namer.get_name(a);
+          os << "\"; }" << std::endl;
+          if (x.has_primitive()) {
+            os << x.primitive_id() << " -> \"" << namer.get_name(a) << '"'
+               << std::endl;
+          }
+        }
+      },
+      nodes);
+
+  os << "}";
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/graph_utils.h b/ml-stable-diffusion/mlx/mlx/graph_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..fcbeef15e6c00456ef7fa97217324e5b7c00eb3b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/graph_utils.h
@@ -0,0 +1,66 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <unordered_map>
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+struct NodeNamer {
+  std::unordered_map<std::uintptr_t, std::string> names;
+
+  const std::string& get_name(const array& x);
+  void set_name(const array& x, std::string n);
+};
+
+void print_graph(
+    std::ostream& os,
+    NodeNamer namer,
+    const std::vector<array>& outputs);
+
+inline void print_graph(std::ostream& os, const std::vector<array>& outputs) {
+  print_graph(os, NodeNamer{}, outputs);
+}
+
+template <typename... Arrays, typename = enable_for_arrays_t<Arrays...>>
+inline void print_graph(std::ostream& os, Arrays&&... outputs) {
+  print_graph(
+      os, NodeNamer{}, std::vector<array>{std::forward<Arrays>(outputs)...});
+}
+
+template <typename... Arrays, typename = enable_for_arrays_t<Arrays...>>
+inline void
+print_graph(std::ostream& os, NodeNamer namer, Arrays&&... outputs) {
+  print_graph(
+      os,
+      std::move(namer),
+      std::vector<array>{std::forward<Arrays>(outputs)...});
+}
+
+void export_to_dot(
+    std::ostream& os,
+    NodeNamer namer,
+    const std::vector<array>& outputs);
+
+inline void export_to_dot(std::ostream& os, const std::vector<array>& outputs) {
+  export_to_dot(os, NodeNamer{}, outputs);
+}
+
+template <typename... Arrays, typename = enable_for_arrays_t<Arrays...>>
+inline void export_to_dot(std::ostream& os, Arrays&&... outputs) {
+  export_to_dot(
+      os, NodeNamer{}, std::vector<array>{std::forward<Arrays>(outputs)...});
+}
+
+template <typename... Arrays, typename = enable_for_arrays_t<Arrays...>>
+inline void
+export_to_dot(std::ostream& os, NodeNamer namer, Arrays&&... outputs) {
+  export_to_dot(
+      os,
+      std::move(namer),
+      std::vector<array>{std::forward<Arrays>(outputs)...});
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/io.h b/ml-stable-diffusion/mlx/mlx/io.h
new file mode 100644
index 0000000000000000000000000000000000000000..23380b23e212928ad225fb707e24120836d1f188
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/io.h
@@ -0,0 +1,61 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <unordered_map>
+#include <variant>
+
+#include "mlx/array.h"
+#include "mlx/io/load.h"
+#include "mlx/stream.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+using GGUFMetaData =
+    std::variant<std::monostate, array, std::string, std::vector<std::string>>;
+using GGUFLoad = std::pair<
+    std::unordered_map<std::string, array>,
+    std::unordered_map<std::string, GGUFMetaData>>;
+using SafetensorsLoad = std::pair<
+    std::unordered_map<std::string, array>,
+    std::unordered_map<std::string, std::string>>;
+
+/** Save array to out stream in .npy format */
+void save(std::shared_ptr<io::Writer> out_stream, array a);
+
+/** Save array to file in .npy format */
+void save(std::string file, array a);
+
+/** Load array from reader in .npy format */
+array load(std::shared_ptr<io::Reader> in_stream, StreamOrDevice s = {});
+
+/** Load array from file in .npy format */
+array load(std::string file, StreamOrDevice s = {});
+
+/** Load array map from .safetensors file format */
+SafetensorsLoad load_safetensors(
+    std::shared_ptr<io::Reader> in_stream,
+    StreamOrDevice s = {});
+SafetensorsLoad load_safetensors(
+    const std::string& file,
+    StreamOrDevice s = {});
+
+void save_safetensors(
+    std::shared_ptr<io::Writer> in_stream,
+    std::unordered_map<std::string, array>,
+    std::unordered_map<std::string, std::string> metadata = {});
+void save_safetensors(
+    std::string file,
+    std::unordered_map<std::string, array>,
+    std::unordered_map<std::string, std::string> metadata = {});
+
+/** Load array map and metadata from .gguf file format */
+
+GGUFLoad load_gguf(const std::string& file, StreamOrDevice s = {});
+
+void save_gguf(
+    std::string file,
+    std::unordered_map<std::string, array> array_map,
+    std::unordered_map<std::string, GGUFMetaData> meta_data = {});
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/io/CMakeLists.txt b/ml-stable-diffusion/mlx/mlx/io/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..eebd7618b373d99ed53193e9457f5d394f4d5c35
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/io/CMakeLists.txt
@@ -0,0 +1,25 @@
+target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/load.cpp)
+
+if(MLX_BUILD_SAFETENSORS)
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/safetensors.cpp)
+else()
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/no_safetensors.cpp)
+endif()
+
+if(MLX_BUILD_GGUF)
+  message(STATUS "Downloading gguflib")
+  FetchContent_Declare(
+    gguflib
+    GIT_REPOSITORY https://github.com/antirez/gguf-tools/
+    GIT_TAG 8fa6eb65236618e28fd7710a0fba565f7faa1848)
+  FetchContent_MakeAvailable(gguflib)
+  target_include_directories(mlx
+                             PRIVATE $<BUILD_INTERFACE:${gguflib_SOURCE_DIR}>)
+  add_library(gguflib STATIC ${gguflib_SOURCE_DIR}/fp16.c
+                             ${gguflib_SOURCE_DIR}/gguflib.c)
+  target_link_libraries(mlx PRIVATE $<BUILD_INTERFACE:gguflib>)
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/gguf.cpp
+                             ${CMAKE_CURRENT_SOURCE_DIR}/gguf_quants.cpp)
+else()
+  target_sources(mlx PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/no_gguf.cpp)
+endif()
diff --git a/ml-stable-diffusion/mlx/mlx/io/gguf.cpp b/ml-stable-diffusion/mlx/mlx/io/gguf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ed6ea11dd6f240574f423a519110dcf3f8df0fb5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/io/gguf.cpp
@@ -0,0 +1,463 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <cstdint>
+#include <cstring>
+#include <fstream>
+#include <numeric>
+
+#include "mlx/io/gguf.h"
+#include "mlx/ops.h"
+
+namespace mlx::core {
+
+// https://github.com/antirez/gguf-tools/blob/af7d88d808a7608a33723fba067036202910acb3/gguflib.h#L102-L108
+constexpr int gguf_array_header_size = 12;
+
+std::optional<uint32_t> dtype_to_gguf_tensor_type(const Dtype& dtype) {
+  switch (dtype) {
+    case float32:
+      return GGUF_TYPE_F32;
+    case float16:
+      return GGUF_TYPE_F16;
+    case int8:
+      return GGUF_TYPE_I8;
+    case int16:
+      return GGUF_TYPE_I16;
+    case int32:
+      return GGUF_TYPE_I32;
+    default:
+      return {};
+  }
+}
+
+std::optional<Dtype> gguf_type_to_dtype(const uint32_t& gguf_type) {
+  switch (gguf_type) {
+    case GGUF_TYPE_F32:
+      return float32;
+    case GGUF_TYPE_F16:
+      return float16;
+    case GGUF_TYPE_I8:
+      return int8;
+    case GGUF_TYPE_I16:
+      return int16;
+    case GGUF_TYPE_I32:
+      return int32;
+    default:
+      return {};
+  }
+}
+
+Shape get_shape(const gguf_tensor& tensor) {
+  Shape shape;
+  // The dimension order in GGML is the reverse of the order used in MLX.
+  for (int i = tensor.ndim - 1; i >= 0; i--) {
+    shape.push_back(tensor.dim[i]);
+  }
+  return shape;
+}
+
+std::tuple<allocator::Buffer, Dtype> extract_tensor_data(gguf_tensor* tensor) {
+  std::optional<Dtype> equivalent_dtype = gguf_type_to_dtype(tensor->type);
+  // If there's an equivalent type, we can simply copy.
+  if (equivalent_dtype.has_value()) {
+    allocator::Buffer buffer = allocator::malloc(tensor->bsize);
+    memcpy(
+        buffer.raw_ptr(),
+        tensor->weights_data,
+        tensor->num_weights * equivalent_dtype.value().size());
+    return {buffer, equivalent_dtype.value()};
+  }
+  // Otherwise, we convert to float16.
+  // TODO: Add other dequantization options.
+  int16_t* data = gguf_tensor_to_f16(tensor);
+  if (data == NULL) {
+    throw std::runtime_error("[load_gguf] gguf_tensor_to_f16 failed");
+  }
+  const size_t new_size = tensor->num_weights * sizeof(int16_t);
+  allocator::Buffer buffer = allocator::malloc(new_size);
+  memcpy(buffer.raw_ptr(), data, new_size);
+  free(data);
+  return {buffer, float16};
+}
+
+void set_mx_value_from_gguf(
+    gguf_ctx* ctx,
+    uint32_t type,
+    gguf_value* val,
+    GGUFMetaData& value) {
+  switch (type) {
+    case GGUF_VALUE_TYPE_UINT8:
+      value = array(val->uint8, uint8);
+      break;
+    case GGUF_VALUE_TYPE_INT8:
+      value = array(val->int8, int8);
+      break;
+    case GGUF_VALUE_TYPE_UINT16:
+      value = array(val->uint16, uint16);
+      break;
+    case GGUF_VALUE_TYPE_INT16:
+      value = array(val->int16, int16);
+      break;
+    case GGUF_VALUE_TYPE_UINT32:
+      value = array(val->uint32, uint32);
+      break;
+    case GGUF_VALUE_TYPE_INT32:
+      value = array(val->int32, int32);
+      break;
+    case GGUF_VALUE_TYPE_UINT64:
+      value = array(val->uint64, uint64);
+      break;
+    case GGUF_VALUE_TYPE_INT64:
+      value = array(val->int64, int64);
+      break;
+    case GGUF_VALUE_TYPE_FLOAT32:
+      value = array(val->float32, float32);
+      break;
+    case GGUF_VALUE_TYPE_BOOL:
+      value = array(val->boolval, bool_);
+      break;
+    case GGUF_VALUE_TYPE_STRING:
+      value =
+          std::string(val->string.string, static_cast<int>(val->string.len));
+      break;
+    case GGUF_VALUE_TYPE_FLOAT64:
+      value = array(val->float64, float32);
+      break;
+    case GGUF_VALUE_TYPE_ARRAY: {
+      ctx->off += gguf_array_header_size; // Skip header
+      char* data = reinterpret_cast<char*>(val) + gguf_array_header_size;
+      auto size = static_cast<int>(val->array.len);
+      if (val->array.type == GGUF_VALUE_TYPE_ARRAY) {
+        throw std::invalid_argument(
+            "[load_gguf] Only supports loading 1-layer of nested arrays.");
+      }
+      switch (val->array.type) {
+        case GGUF_VALUE_TYPE_UINT8:
+          value = array(reinterpret_cast<uint8_t*>(data), {size}, uint8);
+          break;
+        case GGUF_VALUE_TYPE_INT8:
+          value = array(reinterpret_cast<int8_t*>(data), {size}, int8);
+          break;
+        case GGUF_VALUE_TYPE_UINT16:
+          value = array(reinterpret_cast<uint16_t*>(data), {size}, uint16);
+          break;
+        case GGUF_VALUE_TYPE_INT16:
+          value = array(reinterpret_cast<int16_t*>(data), {size}, int16);
+          break;
+        case GGUF_VALUE_TYPE_UINT32:
+          value = array(reinterpret_cast<uint32_t*>(data), {size}, uint32);
+          break;
+        case GGUF_VALUE_TYPE_INT32:
+          value = array(reinterpret_cast<int32_t*>(data), {size}, int32);
+          break;
+        case GGUF_VALUE_TYPE_UINT64:
+          value = array(reinterpret_cast<uint64_t*>(data), {size}, uint64);
+          break;
+        case GGUF_VALUE_TYPE_INT64:
+          value = array(reinterpret_cast<uint64_t*>(data), {size}, int64);
+          break;
+        case GGUF_VALUE_TYPE_FLOAT32:
+          value = array(reinterpret_cast<float*>(data), {size}, float32);
+          break;
+        case GGUF_VALUE_TYPE_BOOL:
+          value = array(reinterpret_cast<bool*>(data), {size}, bool_);
+          break;
+        case GGUF_VALUE_TYPE_STRING: {
+          std::vector<std::string> strs(size);
+          for (auto& str : strs) {
+            auto str_val = reinterpret_cast<gguf_string*>(data);
+            data += (str_val->len + sizeof(gguf_string));
+            str = std::string(str_val->string, static_cast<int>(str_val->len));
+            ctx->off += (str_val->len + sizeof(gguf_string));
+          }
+          value = std::move(strs);
+          break;
+        }
+        case GGUF_VALUE_TYPE_FLOAT64:
+          value = array(reinterpret_cast<double*>(data), {size}, float32);
+          break;
+        default:
+          throw std::runtime_error(
+              "[load_gguf] Multiple levels of nested arrays are not supported.");
+      }
+      break;
+    }
+    default:
+      throw std::runtime_error("[load_gguf] Received unexpected type.");
+      break;
+  }
+  if (type == GGUF_VALUE_TYPE_STRING) {
+    ctx->off += (sizeof(gguf_string) + std::get<std::string>(value).size());
+  } else if (auto pv = std::get_if<array>(&value); pv) {
+    ctx->off += pv->nbytes();
+  }
+}
+
+std::unordered_map<std::string, GGUFMetaData> load_metadata(gguf_ctx* ctx) {
+  std::unordered_map<std::string, GGUFMetaData> metadata;
+  gguf_key key;
+  while (gguf_get_key(ctx, &key)) {
+    std::string key_name = std::string(key.name, key.namelen);
+    auto& val = metadata.insert({key_name, GGUFMetaData{}}).first->second;
+    set_mx_value_from_gguf(ctx, key.type, key.val, val);
+  }
+  return metadata;
+}
+
+std::unordered_map<std::string, array> load_arrays(gguf_ctx* ctx) {
+  std::unordered_map<std::string, array> array_map;
+  gguf_tensor tensor;
+
+  auto check_insert = [](const auto& inserted) {
+    if (!inserted.second) {
+      std::ostringstream msg;
+      msg << "[load_gguf] Duplicate parameter name " << inserted.first->second
+          << " this can happend when loading quantized tensors.";
+      throw std::runtime_error(msg.str());
+    }
+  };
+
+  while (gguf_get_tensor(ctx, &tensor)) {
+    if (tensor.type == GGUF_TYPE_Q4_0 || tensor.type == GGUF_TYPE_Q4_1 ||
+        tensor.type == GGUF_TYPE_Q8_0) {
+      gguf_load_quantized(array_map, tensor);
+    } else {
+      std::string name(tensor.name, tensor.namelen);
+      const auto& [data, dtype] = extract_tensor_data(&tensor);
+      array loaded_array = array(data, get_shape(tensor), dtype);
+      check_insert(array_map.insert({name, loaded_array}));
+    }
+  }
+  return array_map;
+}
+
+GGUFLoad load_gguf(const std::string& file, StreamOrDevice s) {
+  bool exists;
+  {
+    std::ifstream f(file.c_str());
+    exists = f.good();
+  }
+  if (!exists) {
+    throw std::invalid_argument("[load_gguf] Failed to open " + file);
+  }
+
+  std::unique_ptr<gguf_ctx, decltype(&gguf_close)> ctx(
+      gguf_open(file.data()), gguf_close);
+  if (!ctx) {
+    throw std::runtime_error("[load_gguf] gguf_init failed");
+  }
+  auto metadata = load_metadata(ctx.get());
+  auto arrays = load_arrays(ctx.get());
+  return {arrays, metadata};
+}
+
+void append_kv_array(
+    gguf_ctx* ctx,
+    const std::string& key,
+    array& val,
+    uint32_t gguf_type) {
+  if (val.ndim() == 1) {
+    size_t gguf_size = val.nbytes() + gguf_array_header_size;
+    std::vector<char> val_vec(gguf_size);
+    gguf_value* gguf_val = reinterpret_cast<gguf_value*>(val_vec.data());
+    gguf_val->array.type = gguf_type;
+    gguf_val->array.len = val.size();
+    memcpy(
+        val_vec.data() + gguf_array_header_size,
+        val.data<char>(),
+        val.nbytes());
+    gguf_append_kv(
+        ctx,
+        key.c_str(),
+        key.length(),
+        GGUF_VALUE_TYPE_ARRAY,
+        reinterpret_cast<void*>(val_vec.data()),
+        gguf_size);
+  } else {
+    gguf_append_kv(
+        ctx,
+        key.c_str(),
+        key.length(),
+        gguf_type,
+        reinterpret_cast<void*>(val.data<char>()),
+        val.nbytes());
+  }
+}
+
+void save_gguf(
+    std::string file,
+    std::unordered_map<std::string, array> array_map,
+    std::unordered_map<std::string, GGUFMetaData> metadata /* = {} */) {
+  // Add .gguf to file name if it is not there
+  if (file.length() < 5 || file.substr(file.length() - 5, 5) != ".gguf") {
+    file += ".gguf";
+  }
+
+  std::unique_ptr<gguf_ctx, decltype(&gguf_close)> ctx(
+      gguf_create(file.c_str(), GGUF_OVERWRITE), gguf_close);
+  if (!ctx) {
+    throw std::runtime_error("[save_gguf] gguf_create failed");
+  }
+
+  auto string_to_gguf = [](char* dst, const std::string& src) {
+    gguf_string* val = reinterpret_cast<gguf_string*>(dst);
+    val->len = src.length();
+    memcpy(val->string, src.c_str(), src.length());
+  };
+
+  // Save any meta data
+  for (auto& [key, value] : metadata) {
+    if (auto pv = std::get_if<std::string>(&value); pv) {
+      const std::string& str = *pv;
+      size_t size = sizeof(gguf_string) + str.length();
+      std::vector<char> val_vec(size);
+      string_to_gguf(val_vec.data(), str);
+      gguf_append_kv(
+          ctx.get(),
+          key.c_str(),
+          key.length(),
+          GGUF_VALUE_TYPE_STRING,
+          static_cast<void*>(val_vec.data()),
+          size);
+    } else if (auto pv = std::get_if<std::vector<std::string>>(&value); pv) {
+      const auto& str_vec = *pv;
+      auto mem_size = std::accumulate(
+          str_vec.begin(), str_vec.end(), 0, [](size_t accum, const auto& s) {
+            return accum + s.size();
+          });
+      mem_size += str_vec.size() * sizeof(gguf_string) + gguf_array_header_size;
+      std::vector<char> val_vec(mem_size);
+      gguf_value* val = reinterpret_cast<gguf_value*>(val_vec.data());
+      val->array.type = GGUF_VALUE_TYPE_STRING;
+      val->array.len = str_vec.size();
+      auto str_ptr = val_vec.data() + gguf_array_header_size;
+      for (auto& str : str_vec) {
+        string_to_gguf(str_ptr, str);
+        str_ptr += str.length() + sizeof(gguf_string);
+      }
+      gguf_append_kv(
+          ctx.get(),
+          key.c_str(),
+          key.length(),
+          GGUF_VALUE_TYPE_ARRAY,
+          static_cast<void*>(val),
+          mem_size);
+    } else if (auto pv = std::get_if<array>(&value); pv) {
+      array v = *pv;
+      if (v.ndim() > 1) {
+        throw std::runtime_error(
+            "[save_gguf] Cannot save arrays with more than one dimension.");
+      }
+      if (v.size() == 0) {
+        throw std::runtime_error("[save_gguf] Cannot save empty arrays.");
+      }
+
+      eval(v);
+      if (!v.flags().row_contiguous) {
+        v = reshape(flatten(v), v.shape());
+      }
+      if (!v.flags().row_contiguous) {
+        throw std::runtime_error(
+            "[save_gguf] Cannot save non contiguous arrays.");
+      }
+      switch (v.dtype()) {
+        case float32:
+          append_kv_array(ctx.get(), key, v, GGUF_VALUE_TYPE_FLOAT32);
+          break;
+        case int64:
+          append_kv_array(ctx.get(), key, v, GGUF_VALUE_TYPE_INT64);
+          break;
+        case int32:
+          append_kv_array(ctx.get(), key, v, GGUF_VALUE_TYPE_INT32);
+          break;
+        case int16:
+          append_kv_array(ctx.get(), key, v, GGUF_VALUE_TYPE_INT16);
+          break;
+        case int8:
+          append_kv_array(ctx.get(), key, v, GGUF_VALUE_TYPE_INT8);
+          break;
+        case uint64:
+          append_kv_array(ctx.get(), key, v, GGUF_VALUE_TYPE_UINT64);
+          break;
+        case uint32:
+          append_kv_array(ctx.get(), key, v, GGUF_VALUE_TYPE_UINT32);
+          break;
+        case uint16:
+          append_kv_array(ctx.get(), key, v, GGUF_VALUE_TYPE_UINT16);
+          break;
+        case uint8:
+          append_kv_array(ctx.get(), key, v, GGUF_VALUE_TYPE_UINT8);
+          break;
+        case bool_:
+          append_kv_array(ctx.get(), key, v, GGUF_VALUE_TYPE_BOOL);
+          break;
+        default:
+          std::ostringstream msg;
+          msg << "[save_gguf] array type " << v.dtype()
+              << " not support for metadata.";
+          throw std::invalid_argument(msg.str());
+      }
+    } else {
+      throw std::runtime_error(
+          "[save_gguf] Received unexpected type in metadata");
+    }
+  }
+
+  // Tensor offsets are relative to data section, so we start at offset 0.
+  uint64_t tensor_offset = 0;
+
+  // First, append the tensor info
+  for (auto& [key, arr] : array_map) {
+    arr.eval();
+
+    // Try to make it row contiguous
+    if (!arr.flags().row_contiguous) {
+      arr = reshape(flatten(arr), arr.shape());
+      arr.eval();
+    }
+
+    // Has to be row-major now but, check one more time in case
+    // any of the above change in the future
+    if (!arr.flags().row_contiguous) {
+      throw std::invalid_argument(
+          "[save_gguf] can only serialize row-major arrays");
+    }
+
+    tensor_offset += gguf_get_alignment_padding(ctx->alignment, tensor_offset);
+    const std::optional<uint32_t> gguf_type =
+        dtype_to_gguf_tensor_type(arr.dtype());
+    if (!gguf_type.has_value()) {
+      std::ostringstream msg;
+      msg << "[save_gguf] dtype " << arr.dtype() << " is not supported";
+      throw std::runtime_error(msg.str());
+    }
+    const char* tensorname = key.c_str();
+    const uint64_t namelen = key.length();
+    const uint32_t num_dim = arr.ndim();
+    uint64_t dim[num_dim];
+    for (int i = 0; i < num_dim; i++) {
+      dim[i] = arr.shape()[num_dim - 1 - i];
+    }
+    if (!gguf_append_tensor_info(
+            ctx.get(),
+            tensorname,
+            namelen,
+            num_dim,
+            dim,
+            gguf_type.value(),
+            tensor_offset)) {
+      throw std::runtime_error("[save_gguf] gguf_append_tensor_info failed");
+    }
+    tensor_offset += arr.nbytes();
+  }
+
+  // Then, append the tensor weights
+  for (const auto& [key, arr] : array_map) {
+    if (!gguf_append_tensor_data(
+            ctx.get(), (void*)arr.data<void>(), arr.nbytes())) {
+      throw std::runtime_error("[save_gguf] gguf_append_tensor_data failed");
+    }
+  }
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/io/gguf.h b/ml-stable-diffusion/mlx/mlx/io/gguf.h
new file mode 100644
index 0000000000000000000000000000000000000000..fa5bc458de09ed951cbcbabaa784fee36bb05cb5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/io/gguf.h
@@ -0,0 +1,20 @@
+// Copyright © 2023-2024 Apple Inc.
+#pragma once
+
+#include "mlx/io.h"
+#include "mlx/primitives.h"
+#include "mlx/transforms.h"
+#include "mlx/utils.h"
+
+extern "C" {
+#include <gguflib.h>
+}
+
+namespace mlx::core {
+
+Shape get_shape(const gguf_tensor& tensor);
+void gguf_load_quantized(
+    std::unordered_map<std::string, array>& a,
+    const gguf_tensor& tensor);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp b/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..148ed6c4798e240b2d502c9ba4c2b31abad7312a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/io/gguf_quants.cpp
@@ -0,0 +1,164 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <cstdint>
+#include <cstring>
+#include <numeric>
+
+#include "mlx/io/gguf.h"
+
+namespace mlx::core {
+
+void unpack_32_4(uint8_t* data, int8_t* dst) {
+  std::fill_n(dst, 16, 0);
+  for (int j = 0; j < 16; ++j) {
+    uint8_t x = (data[j + 2] & 0x0F); // j+2 to skip scale bytes.
+    if (j % 2 != 0) {
+      x <<= 4;
+    }
+    dst[j / 2] += x;
+  }
+  // Last 16 weights are in the higher bits
+  for (int j = 0; j < 16; ++j) {
+    uint8_t x = (data[j + 2] >> 4);
+    if (j % 2 != 0) {
+      x <<= 4;
+    }
+    dst[8 + j / 2] += x;
+  }
+}
+
+// Extracts (weight, scales, biases) from Q4_0 tensors.
+// Data layout is: |16 bit scale|32 x 4bit weights|.
+void extract_q4_0_data(
+    const gguf_tensor& tensor,
+    array& weights_arr,
+    array& scales_arr,
+    array& biases_arr) {
+  const uint64_t bytes_per_block = 18; // 2 bytes scale, 32x0.5 byte weights
+  auto data = static_cast<uint8_t*>(tensor.weights_data);
+  auto weights = weights_arr.data<int8_t>();
+  auto scales = scales_arr.data<float16_t>();
+  auto biases = biases_arr.data<float16_t>();
+  for (int64_t i = 0; i < scales_arr.size(); i++) {
+    scales[i] = *((float16_t*)data);
+    biases[i] = -8 * scales[i];
+    unpack_32_4(data, weights);
+    weights += 16;
+    data += bytes_per_block;
+  }
+}
+
+// Extracts (weight, scales, biases) from Q4_1 tensors.
+// Data layout is: |16 bit scale|16 bit bias|32 x 4bit weights|.
+void extract_q4_1_data(
+    const gguf_tensor& tensor,
+    array& weights_arr,
+    array& scales_arr,
+    array& biases_arr) {
+  const uint64_t bytes_per_block =
+      20; // 2 bytes scale, 2 bytes bias, 32x0.5 byte weights
+  auto data = static_cast<uint8_t*>(tensor.weights_data);
+  auto weights = weights_arr.data<int8_t>();
+  auto scales = scales_arr.data<float16_t>();
+  auto biases = biases_arr.data<float16_t>();
+  for (int64_t i = 0; i < scales_arr.size(); i++) {
+    scales[i] = *((float16_t*)data);
+    biases[i] = *((float16_t*)(data) + 1);
+    unpack_32_4(data, weights);
+    weights += 16;
+    data += bytes_per_block;
+  }
+}
+
+// Extracts (weight, scales, biases) from Q8_0 tensors.
+// Data layout is: |16 bit scale|32 x 8bit weights|.
+void extract_q8_0_data(
+    const gguf_tensor& tensor,
+    array& weights_arr,
+    array& scales_arr,
+    array& biases_arr) {
+  const uint64_t weights_per_block = 32;
+  const uint64_t bytes_per_block = 34; // 2 bytes scale, 32x1 byte weights
+  auto data = static_cast<uint8_t*>(tensor.weights_data);
+  auto weights = weights_arr.data<int8_t>();
+  auto scales = scales_arr.data<float16_t>();
+  auto biases = biases_arr.data<float16_t>();
+  for (int64_t i = 0; i < scales_arr.size(); i++) {
+    uint8_t* block_data = data + i * bytes_per_block;
+    scales[i] = *((float16_t*)block_data);
+    biases[i] = -128 * scales[i];
+    for (int64_t j = 0; j < weights_per_block; ++j) {
+      uint8_t x = block_data[j + 2]; // j+2 to skip the scale bytes.
+      // Original data is in int8_t, so we add a bias of -128 and invert the
+      // first bit.
+      x ^= 1 << 7;
+      weights[i * weights_per_block + j] = x;
+    }
+  }
+}
+
+void gguf_load_quantized(
+    std::unordered_map<std::string, array>& a,
+    const gguf_tensor& tensor) {
+  uint64_t weights_per_byte;
+  if (tensor.type == GGUF_TYPE_Q4_0 || tensor.type == GGUF_TYPE_Q4_1) {
+    weights_per_byte = 2;
+  } else { // tensor.type == GGUF_TYPE_Q8_0
+    weights_per_byte = 1;
+  }
+
+  std::string name(tensor.name, tensor.namelen);
+
+  auto shape = get_shape(tensor);
+  const uint64_t weights_per_block = 32;
+  if (shape[shape.size() - 1] % weights_per_block != 0) {
+    std::ostringstream msg;
+    msg << "[load_gguf] tensor " << name
+        << "has incompatible last dim shape: " << shape[shape.size() - 1];
+    throw std::runtime_error(msg.str());
+  }
+
+  auto weights_shape = shape;
+  weights_shape.back() /= (weights_per_byte * 4);
+  auto w_nbytes = uint32.size() *
+      std::accumulate(weights_shape.begin(),
+                      weights_shape.end(),
+                      1,
+                      std::multiplies<size_t>());
+
+  array weights(allocator::malloc(w_nbytes), std::move(weights_shape), uint32);
+
+  // For scales and bias
+  shape[shape.size() - 1] = shape[shape.size() - 1] / weights_per_block;
+  auto sb_nbytes = float16.size() *
+      std::accumulate(shape.begin(), shape.end(), 1, std::multiplies<size_t>());
+
+  array scales(allocator::malloc(sb_nbytes), shape, float16);
+  array biases(allocator::malloc(sb_nbytes), std::move(shape), float16);
+  if (tensor.type == GGUF_TYPE_Q4_0) {
+    extract_q4_0_data(tensor, weights, scales, biases);
+  } else if (tensor.type == GGUF_TYPE_Q4_1) {
+    extract_q4_1_data(tensor, weights, scales, biases);
+  } else if (tensor.type == GGUF_TYPE_Q8_0) {
+    extract_q8_0_data(tensor, weights, scales, biases);
+  }
+
+  a.emplace(name, std::move(weights));
+
+  auto check_insert = [](const auto& inserted) {
+    if (!inserted.second) {
+      std::ostringstream msg;
+      msg << "[load_gguf] Duplicate parameter name " << inserted.first->second
+          << " this can happend when loading quantized tensors.";
+      throw std::runtime_error(msg.str());
+    }
+  };
+
+  constexpr std::string_view weight_suffix = ".weight";
+  const std::string name_prefix =
+      name.substr(0, name.length() - weight_suffix.length());
+  check_insert(a.emplace(name_prefix + ".scales", std::move(scales)));
+  check_insert(a.emplace(name_prefix + ".biases", std::move(biases)));
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/io/load.cpp b/ml-stable-diffusion/mlx/mlx/io/load.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2f9053f4daac37b5ced3e4237ce341a8c4a989ce
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/io/load.cpp
@@ -0,0 +1,393 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <algorithm>
+#include <cstring>
+#include <fstream>
+#include <limits>
+#include <sstream>
+
+// Used by pread implementation.
+#ifdef _WIN32
+#ifdef _MSC_VER
+#define NOMINMAX
+#endif
+#include <windows.h>
+#endif // _WIN32
+
+#include "mlx/io/load.h"
+#include "mlx/ops.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+// Adapted from
+// https://github.com/angeloskath/supervised-lda/blob/master/include/ldaplusplus/NumpyFormat.hpp
+
+namespace mlx::core {
+
+namespace {
+
+constexpr uint8_t MAGIC[] = {
+    0x93,
+    0x4e,
+    0x55,
+    0x4d,
+    0x50,
+    0x59,
+};
+
+inline bool is_big_endian() {
+  union ByteOrder {
+    int32_t i;
+    uint8_t c[4];
+  };
+  ByteOrder b = {0x01234567};
+
+  return b.c[0] == 0x01;
+}
+
+// Array protocol typestring for Dtype
+std::string dtype_to_array_protocol(const Dtype& t) {
+  std::ostringstream r;
+  if (size_of(t) > 1) {
+    r << (is_big_endian() ? ">" : "<");
+  } else {
+    r << "|";
+  }
+  r << kindof(t) << (int)size_of(t);
+  return r.str();
+}
+
+// Dtype from array protocol type string
+Dtype dtype_from_array_protocol(std::string_view t) {
+  if (t.length() == 2 || t.length() == 3) {
+    std::string_view r = t.length() == 3 ? t.substr(1, 2) : t;
+
+    if (r == "V2") {
+      return bfloat16;
+    }
+
+    uint8_t size = r[1] - '0';
+
+    switch (r[0]) {
+      case 'b': {
+        if (size == 1)
+          return bool_;
+      }
+      case 'i': {
+        if (size == 1)
+          return int8;
+        else if (size == 2)
+          return int16;
+        else if (size == 4)
+          return int32;
+        else if (size == 8)
+          return int64;
+      }
+      case 'u': {
+        if (size == 1)
+          return uint8;
+        else if (size == 2)
+          return uint16;
+        else if (size == 4)
+          return uint32;
+        else if (size == 8)
+          return uint64;
+      }
+      case 'f': {
+        if (size == 2)
+          return float16;
+        else if (size == 4)
+          return float32;
+      }
+      case 'c': {
+        return complex64;
+      }
+    }
+  }
+
+  throw std::invalid_argument(
+      "[from_str] Invalid array protocol type-string: " + std::string(t));
+}
+
+#ifdef _WIN32
+// There is no pread on Windows, emulate it with ReadFile.
+int64_t pread(int fd, void* buf, uint64_t size, uint64_t offset) {
+  HANDLE file = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
+  if (file == INVALID_HANDLE_VALUE) {
+    return -1;
+  }
+
+  OVERLAPPED overlapped = {0};
+  overlapped.Offset = offset & 0xFFFFFFFF;
+  overlapped.OffsetHigh = (offset >> 32) & 0xFFFFFFFF;
+
+  DWORD bytes_read;
+  if (!ReadFile(file, buf, size, &bytes_read, &overlapped)) {
+    if (GetLastError() != ERROR_HANDLE_EOF) {
+      return -1;
+    }
+  }
+
+  return bytes_read;
+}
+#endif
+
+} // namespace
+
+/** Save array to out stream in .npy format */
+void save(std::shared_ptr<io::Writer> out_stream, array a) {
+  ////////////////////////////////////////////////////////
+  // Check array
+
+  a = contiguous(a, true);
+  a.eval();
+
+  if (a.nbytes() == 0) {
+    throw std::invalid_argument("[save] cannot serialize an empty array");
+  }
+
+  ////////////////////////////////////////////////////////
+  // Check file
+  if (!out_stream->good() || !out_stream->is_open()) {
+    throw std::runtime_error("[save] Failed to open " + out_stream->label());
+  }
+
+  ////////////////////////////////////////////////////////
+  // Prepare header
+  std::ostringstream magic_ver_len;
+  magic_ver_len.write(reinterpret_cast<const char*>(MAGIC), 6);
+
+  std::string fortran_order = a.flags().col_contiguous ? "True" : "False";
+  std::ostringstream header;
+  header << "{'descr': '" << dtype_to_array_protocol(a.dtype()) << "',"
+         << " 'fortran_order': " << fortran_order << "," << " 'shape': (";
+  for (auto i : a.shape()) {
+    header << i << ", ";
+  }
+  header << ")}";
+
+  size_t header_len = static_cast<size_t>(header.tellp());
+  bool is_v1 = header_len + 15 < std::numeric_limits<uint16_t>::max();
+
+  // Pad out magic + version + header_len + header + \n to be divisible by 16
+  size_t padding = (6 + 2 + (2 + 2 * is_v1) + header_len + 1) % 16;
+
+  header << std::string(padding, ' ') << '\n';
+
+  if (is_v1) {
+    magic_ver_len << (char)0x01 << (char)0x00;
+
+    uint16_t v1_header_len = header.tellp();
+    const char* len_bytes = reinterpret_cast<const char*>(&v1_header_len);
+
+    if (!is_big_endian()) {
+      magic_ver_len.write(len_bytes, 2);
+    } else {
+      magic_ver_len.write(len_bytes + 1, 1);
+      magic_ver_len.write(len_bytes, 1);
+    }
+  } else {
+    magic_ver_len << (char)0x02 << (char)0x00;
+
+    uint32_t v2_header_len = header.tellp();
+    const char* len_bytes = reinterpret_cast<const char*>(&v2_header_len);
+
+    if (!is_big_endian()) {
+      magic_ver_len.write(len_bytes, 4);
+    } else {
+      magic_ver_len.write(len_bytes + 3, 1);
+      magic_ver_len.write(len_bytes + 2, 1);
+      magic_ver_len.write(len_bytes + 1, 1);
+      magic_ver_len.write(len_bytes, 1);
+    }
+  }
+  ////////////////////////////////////////////////////////
+  // Serialize array
+
+  out_stream->write(magic_ver_len.str().c_str(), magic_ver_len.str().length());
+  out_stream->write(header.str().c_str(), header.str().length());
+  out_stream->write(a.data<char>(), a.nbytes());
+}
+
+/** Save array to file in .npy format */
+void save(std::string file, array a) {
+  // Add .npy to file name if it is not there
+  if (file.length() < 4 || file.substr(file.length() - 4, 4) != ".npy")
+    file += ".npy";
+
+  // Serialize array
+  save(std::make_shared<io::FileWriter>(std::move(file)), a);
+}
+
+/** Load array from reader in .npy format */
+array load(std::shared_ptr<io::Reader> in_stream, StreamOrDevice s) {
+  ////////////////////////////////////////////////////////
+  // Open and check file
+  if (!in_stream->good() || !in_stream->is_open()) {
+    throw std::runtime_error("[load] Failed to open " + in_stream->label());
+  }
+
+  auto stream = to_stream(s, Device::cpu);
+  if (stream.device != Device::cpu) {
+    throw std::runtime_error("[load] Must run on a CPU stream.");
+  }
+
+  ////////////////////////////////////////////////////////
+  // Read header and prepare array details
+
+  // Read and check magic
+  char read_magic_and_ver[8];
+  in_stream->read(read_magic_and_ver, 8);
+  if (std::memcmp(read_magic_and_ver, MAGIC, 6) != 0) {
+    throw std::runtime_error("[load] Invalid header in " + in_stream->label());
+  }
+
+  // Read and check version
+  if (read_magic_and_ver[6] != 1 && read_magic_and_ver[6] != 2) {
+    throw std::runtime_error(
+        "[load] Unsupported npy format version in " + in_stream->label());
+  }
+
+  // Read header len and header
+  int header_len_size = read_magic_and_ver[6] == 1 ? 2 : 4;
+  size_t header_len;
+
+  if (header_len_size == 2) {
+    uint16_t v1_header_len;
+    in_stream->read(reinterpret_cast<char*>(&v1_header_len), header_len_size);
+    header_len = v1_header_len;
+  } else {
+    uint32_t v2_header_len;
+    in_stream->read(reinterpret_cast<char*>(&v2_header_len), header_len_size);
+    header_len = v2_header_len;
+  }
+
+  // Read the header
+  std::vector<char> buffer(header_len + 1);
+  in_stream->read(&buffer[0], header_len);
+  buffer[header_len] = 0;
+  std::string header(&buffer[0]);
+
+  // Read data type from header
+  std::string dtype_str = header.substr(11, 3);
+  bool read_is_big_endian = dtype_str[0] == '>';
+  Dtype dtype = dtype_from_array_protocol(dtype_str);
+
+  // Read contiguity order
+  bool col_contiguous = header[34] == 'T';
+
+  // Read array shape from header
+  Shape shape;
+
+  size_t st = header.find_last_of('(') + 1;
+  size_t ed = header.find_last_of(')');
+  std::string shape_str = header.substr(st, ed - st);
+
+  while (!shape_str.empty()) {
+    // Read current number and get position of comma
+    size_t pos;
+    int dim = std::stoi(shape_str, &pos);
+    shape.push_back(dim);
+
+    // Skip the comma and space and read the next number
+    if (pos + 2 <= shape_str.length())
+      shape_str = shape_str.substr(pos + 2);
+    else {
+      shape_str = shape_str.substr(pos);
+      if (!shape_str.empty() && shape_str != " " && shape_str != ",") {
+        throw std::runtime_error(
+            "[load] Unknown error while parsing header in " +
+            in_stream->label());
+      }
+      shape_str = "";
+    }
+  }
+
+  ////////////////////////////////////////////////////////
+  // Build primitive
+
+  size_t offset = 8 + header_len_size + header.length();
+  bool swap_endianness = read_is_big_endian != is_big_endian();
+
+  if (col_contiguous) {
+    std::reverse(shape.begin(), shape.end());
+  }
+  auto loaded_array = array(
+      shape,
+      dtype,
+      std::make_shared<Load>(stream, in_stream, offset, swap_endianness),
+      std::vector<array>{});
+  if (col_contiguous) {
+    loaded_array = transpose(loaded_array, s);
+  }
+
+  return loaded_array;
+}
+
+/** Load array from file in .npy format */
+array load(std::string file, StreamOrDevice s) {
+  return load(std::make_shared<io::ParallelFileReader>(std::move(file)), s);
+}
+
+namespace io {
+
+ThreadPool& thread_pool() {
+  static ThreadPool pool_{4};
+  return pool_;
+}
+
+ThreadPool& ParallelFileReader::thread_pool() {
+  static ThreadPool thread_pool{4};
+  return thread_pool;
+}
+
+void ParallelFileReader::read(char* data, size_t n) {
+  while (n != 0) {
+    auto m = ::read(fd_, data, std::min(n, static_cast<size_t>(INT32_MAX)));
+    if (m <= 0) {
+      std::ostringstream msg;
+      msg << "[read] Unable to read " << n << " bytes from file.";
+      throw std::runtime_error(msg.str());
+    }
+    data += m;
+    n -= m;
+  }
+}
+
+void ParallelFileReader::read(char* data, size_t n, size_t offset) {
+  auto readfn = [fd = fd_](size_t offset, size_t size, char* buffer) -> bool {
+    while (size != 0) {
+      auto m = pread(fd, buffer, size, offset);
+      if (m <= 0) {
+        return false;
+      }
+      buffer += m;
+      size -= m;
+    }
+    return true;
+  };
+  std::vector<std::future<bool>> futs;
+  while (n != 0) {
+    if (n < batch_size_) {
+      if (!readfn(offset, n, data)) {
+        throw std::runtime_error("[read] Unable to read from file.");
+      }
+      break;
+    } else {
+      size_t m = batch_size_;
+      futs.emplace_back(
+          ParallelFileReader::thread_pool().enqueue(readfn, offset, m, data));
+      data += m;
+      n -= m;
+      offset += m;
+    }
+  }
+  for (auto& f : futs) {
+    if (!f.get()) {
+      throw std::runtime_error("[read] Unable to read from file.");
+    }
+  }
+}
+
+} // namespace io
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/io/load.h b/ml-stable-diffusion/mlx/mlx/io/load.h
new file mode 100644
index 0000000000000000000000000000000000000000..8b5dd95b63190ed273ba10f5db91213ecd898811
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/io/load.h
@@ -0,0 +1,174 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <memory>
+#include <sstream>
+
+#include <fcntl.h>
+#ifdef _MSC_VER
+#include <io.h>
+#else
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
+#include "mlx/threadpool.h"
+
+// Strictly we need to operate on files in binary mode (to avoid \r getting
+// automatically inserted), but every modern system except for Windows no
+// longer differentiates between binary and text files and for them define
+// the flag as no-op.
+#ifndef O_BINARY
+#define O_BINARY 0
+#endif
+
+namespace mlx::core {
+
+namespace io {
+
+ThreadPool& thread_pool();
+
+class Reader {
+ public:
+  virtual bool is_open() const = 0;
+  virtual bool good() const = 0;
+  virtual size_t tell() = 0; // tellp is non-const in iostream
+  virtual void seek(
+      int64_t off,
+      std::ios_base::seekdir way = std::ios_base::beg) = 0;
+  virtual void read(char* data, size_t n) = 0;
+  virtual void read(char* data, size_t n, size_t offset) = 0;
+  virtual std::string label() const = 0;
+  virtual ~Reader() = default;
+};
+
+class Writer {
+ public:
+  virtual bool is_open() const = 0;
+  virtual bool good() const = 0;
+  virtual size_t tell() = 0;
+  virtual void seek(
+      int64_t off,
+      std::ios_base::seekdir way = std::ios_base::beg) = 0;
+  virtual void write(const char* data, size_t n) = 0;
+  virtual std::string label() const = 0;
+  virtual ~Writer() = default;
+};
+
+class ParallelFileReader : public Reader {
+ public:
+  explicit ParallelFileReader(std::string file_path)
+      : fd_(open(file_path.c_str(), O_RDONLY | O_BINARY)),
+        label_(std::move(file_path)) {}
+
+  ~ParallelFileReader() override {
+    close(fd_);
+  }
+
+  bool is_open() const override {
+    return fd_ > 0;
+  }
+
+  bool good() const override {
+    return is_open();
+  }
+
+  size_t tell() override {
+    return lseek(fd_, 0, SEEK_CUR);
+  }
+
+  // Warning: do not use this function from multiple threads as
+  // it advances the file descriptor
+  void seek(int64_t off, std::ios_base::seekdir way = std::ios_base::beg)
+      override {
+    if (way == std::ios_base::beg) {
+      lseek(fd_, off, 0);
+    } else {
+      lseek(fd_, off, SEEK_CUR);
+    }
+  }
+
+  // Warning: do not use this function from multiple threads as
+  // it advances the file descriptor
+  void read(char* data, size_t n) override;
+
+  void read(char* data, size_t n, size_t offset) override;
+
+  std::string label() const override {
+    return "file " + label_;
+  }
+
+ private:
+  static constexpr size_t batch_size_ = 1 << 25;
+  static ThreadPool& thread_pool();
+  int fd_;
+  std::string label_;
+};
+
+class FileWriter : public Writer {
+ public:
+  explicit FileWriter(std::string file_path)
+      : fd_(open(
+            file_path.c_str(),
+            O_CREAT | O_WRONLY | O_TRUNC | O_BINARY,
+            0644)),
+        label_(std::move(file_path)) {}
+
+  FileWriter(const FileWriter&) = delete;
+  FileWriter& operator=(const FileWriter&) = delete;
+  FileWriter(FileWriter&& other) {
+    std::swap(fd_, other.fd_);
+  }
+
+  ~FileWriter() override {
+    if (fd_ != 0) {
+      close(fd_);
+    }
+  }
+
+  bool is_open() const override {
+    return fd_ >= 0;
+  }
+
+  bool good() const override {
+    return is_open();
+  }
+
+  size_t tell() override {
+    return lseek(fd_, 0, SEEK_CUR);
+  }
+
+  void seek(int64_t off, std::ios_base::seekdir way = std::ios_base::beg)
+      override {
+    if (way == std::ios_base::beg) {
+      lseek(fd_, off, 0);
+    } else {
+      lseek(fd_, off, SEEK_CUR);
+    }
+  }
+
+  void write(const char* data, size_t n) override {
+    while (n != 0) {
+      auto m = ::write(fd_, data, std::min(n, static_cast<size_t>(INT32_MAX)));
+      if (m <= 0) {
+        std::ostringstream msg;
+        msg << "[write] Unable to write " << n << " bytes to file.";
+        throw std::runtime_error(msg.str());
+      }
+      data += m;
+      n -= m;
+    }
+  }
+
+  std::string label() const override {
+    return "file " + label_;
+  }
+
+ private:
+  int fd_{0};
+  std::string label_;
+};
+
+} // namespace io
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/io/no_gguf.cpp b/ml-stable-diffusion/mlx/mlx/io/no_gguf.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..822d8fcd65541f1fe3c3cd978b8e97b51d1a227e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/io/no_gguf.cpp
@@ -0,0 +1,20 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/io.h"
+
+namespace mlx::core {
+
+GGUFLoad load_gguf(const std::string&, StreamOrDevice s) {
+  throw std::runtime_error(
+      "[load_gguf] Compile with MLX_BUILD_GGUF=ON to enable GGUF support.");
+}
+
+void save_gguf(
+    std::string,
+    std::unordered_map<std::string, array>,
+    std::unordered_map<std::string, GGUFMetaData>) {
+  throw std::runtime_error(
+      "[save_gguf] Compile with MLX_BUILD_GGUF=ON to enable GGUF support.");
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/io/no_safetensors.cpp b/ml-stable-diffusion/mlx/mlx/io/no_safetensors.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..949c5d2e9a786dc86df6bcef3c371dedb15302cf
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/io/no_safetensors.cpp
@@ -0,0 +1,37 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "mlx/io.h"
+
+namespace mlx::core {
+
+SafetensorsLoad load_safetensors(std::shared_ptr<io::Reader>, StreamOrDevice) {
+  throw std::runtime_error(
+      "[load_safetensors] Compile with MLX_BUILD_SAFETENSORS=ON "
+      "to enable safetensors support.");
+}
+
+SafetensorsLoad load_safetensors(const std::string&, StreamOrDevice) {
+  throw std::runtime_error(
+      "[load_safetensors] Compile with MLX_BUILD_SAFETENSORS=ON "
+      "to enable safetensors support.");
+}
+
+void save_safetensors(
+    std::shared_ptr<io::Writer>,
+    std::unordered_map<std::string, array>,
+    std::unordered_map<std::string, std::string>) {
+  throw std::runtime_error(
+      "[save_safetensors] Compile with MLX_BUILD_SAFETENSORS=ON "
+      "to enable safetensors support.");
+}
+
+void save_safetensors(
+    std::string file,
+    std::unordered_map<std::string, array>,
+    std::unordered_map<std::string, std::string>) {
+  throw std::runtime_error(
+      "[save_safetensors] Compile with MLX_BUILD_SAFETENSORS=ON "
+      "to enable safetensors support.");
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp b/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ee974186be93043974bdfd14ab1fd9fa3d9ef20
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/io/safetensors.cpp
@@ -0,0 +1,326 @@
+// Copyright © 2023 Apple Inc.
+//
+#include <json.hpp>
+#include <memory>
+#include <stack>
+
+#include "mlx/fast.h"
+#include "mlx/io.h"
+#include "mlx/io/load.h"
+#include "mlx/ops.h"
+#include "mlx/primitives.h"
+#include "mlx/transforms.h"
+
+using json = nlohmann::json;
+
+#define ST_F16 "F16"
+#define ST_BF16 "BF16"
+#define ST_F32 "F32"
+
+#define ST_BOOL "BOOL"
+#define ST_I8 "I8"
+#define ST_I16 "I16"
+#define ST_I32 "I32"
+#define ST_I64 "I64"
+#define ST_U8 "U8"
+#define ST_U16 "U16"
+#define ST_U32 "U32"
+#define ST_U64 "U64"
+#define ST_F8_E4M3 "F8_E4M3"
+
+// Note: Complex numbers aren't in the spec yet so this could change -
+// https://github.com/huggingface/safetensors/issues/389
+#define ST_C64 "C64"
+
+namespace mlx::core {
+
+std::string dtype_to_safetensor_str(Dtype t) {
+  switch (t) {
+    case float32:
+      return ST_F32;
+    case bfloat16:
+      return ST_BF16;
+    case float16:
+      return ST_F16;
+    case int64:
+      return ST_I64;
+    case int32:
+      return ST_I32;
+    case int16:
+      return ST_I16;
+    case int8:
+      return ST_I8;
+    case uint64:
+      return ST_U64;
+    case uint32:
+      return ST_U32;
+    case uint16:
+      return ST_U16;
+    case uint8:
+      return ST_U8;
+    case bool_:
+      return ST_BOOL;
+    case complex64:
+      return ST_C64;
+    default:
+      throw std::runtime_error("[save_safetensors] received invalid dtype.");
+  }
+}
+
+Dtype dtype_from_safetensor_str(std::string_view str) {
+  if (str == ST_F32) {
+    return float32;
+  } else if (str == ST_F16) {
+    return float16;
+  } else if (str == ST_BF16) {
+    return bfloat16;
+  } else if (str == ST_I64) {
+    return int64;
+  } else if (str == ST_I32) {
+    return int32;
+  } else if (str == ST_I16) {
+    return int16;
+  } else if (str == ST_I8) {
+    return int8;
+  } else if (str == ST_U64) {
+    return uint64;
+  } else if (str == ST_U32) {
+    return uint32;
+  } else if (str == ST_U16) {
+    return uint16;
+  } else if (str == ST_U8) {
+    return uint8;
+  } else if (str == ST_BOOL) {
+    return bool_;
+  } else if (str == ST_C64) {
+    return complex64;
+  } else if (str == ST_F8_E4M3) {
+    // We convert this manually later
+    return uint8;
+  } else {
+    throw std::runtime_error(
+        "[safetensor] unsupported dtype " + std::string(str));
+  }
+}
+
+array f8_e4m3_to_float(array x, Dtype dtype, StreamOrDevice s) {
+  if (to_stream(s).device == Device::gpu) {
+    // From PyTorch:
+    // https://github.com/pytorch/pytorch/blob/e3643e1e0e923f0fc063dfab6f45c956d568919d/c10/util/Float8_e4m3fn.h#L46
+    std::string source = R"(
+      uint elem = thread_position_in_grid.x;
+      uint8_t val = x[elem];
+
+      const uint32_t w = (uint32_t)val << 24;
+      const uint32_t sign = w & 0x80000000;
+      const uint32_t nonsign = w & 0x7FFFFFFF;
+
+      uint32_t renorm_shift = metal::clz(nonsign);
+      renorm_shift = renorm_shift > 4 ? renorm_shift - 4 : 0;
+
+      const int32_t inf_nan_mask =
+          ((int32_t)(nonsign + 0x01000000) >> 8) & 0x7F800000;
+      const int32_t zero_mask = (int32_t)(nonsign - 1) >> 31;
+      uint32_t result = sign |
+          ((((nonsign << renorm_shift >> 4) + ((0x78 - renorm_shift) << 23)) |
+              inf_nan_mask) &
+              ~zero_mask);
+
+      float out = *(reinterpret_cast<thread float*>(&result));
+      y[elem] = static_cast<T>(out);
+    )";
+    auto kernel = fast::metal_kernel("f8_e4m3", {"x"}, {"y"}, source);
+    auto outputs = kernel(
+        {x},
+        {x.shape()},
+        {dtype},
+        {x.size(), 1, 1},
+        {256, 1, 1},
+        {{"T", dtype}},
+        std::nullopt,
+        false,
+        s);
+    return outputs[0];
+  } else {
+    auto w = left_shift(astype(x, uint32, s), array({24}, uint32), s);
+    auto sign = bitwise_and(w, array({0x80000000}, uint32), s);
+    auto nonsign = bitwise_and(w, array({0x7FFFFFFF}, uint32), s);
+
+    // Emulate a clz op with a lookup table
+    auto clz_table =
+        array({28, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0}, uint32);
+    auto renorm_shift = take(clz_table, bitwise_and(x, array({0xf}), s), s);
+    renorm_shift = where(
+        greater(
+            bitwise_and(x, array({0x70}, uint32), s), array({0}, uint32), s),
+        array({0}, uint32),
+        renorm_shift,
+        s);
+    auto inf_nan_mask = bitwise_and(
+        right_shift(
+            astype(add(nonsign, array(0x01000000, int32), s), int32, s),
+            array({8}, int32),
+            s),
+        array({0x7F800000}, int32),
+        s);
+    auto zero_mask = right_shift(
+        astype(subtract(nonsign, array({1}, uint32), s), int32, s),
+        array({31}, int32),
+        s);
+    zero_mask = astype(zero_mask, uint32, s);
+    inf_nan_mask = astype(inf_nan_mask, uint32, s);
+    auto result =
+        add(right_shift(
+                left_shift(nonsign, renorm_shift, s), array({4}, uint32), s),
+            left_shift(
+                subtract(array({0x78}, uint32), renorm_shift, s),
+                array({23}, uint32),
+                s),
+            s);
+    result = bitwise_or(
+        sign,
+        bitwise_and(
+            bitwise_or(result, inf_nan_mask, s),
+            bitwise_invert(zero_mask, s),
+            s),
+        s);
+    result = astype(view(result, float32, s), dtype, s);
+    return result;
+  }
+}
+
+/** Load array from reader in safetensor format */
+SafetensorsLoad load_safetensors(
+    std::shared_ptr<io::Reader> in_stream,
+    StreamOrDevice s) {
+  ////////////////////////////////////////////////////////
+  // Open and check file
+  if (!in_stream->good() || !in_stream->is_open()) {
+    throw std::runtime_error(
+        "[load_safetensors] Failed to open " + in_stream->label());
+  }
+
+  auto stream = to_stream(s, Device::cpu);
+  if (stream.device != Device::cpu) {
+    throw std::runtime_error("[load_safetensors] Must run on a CPU stream.");
+  }
+
+  uint64_t jsonHeaderLength = 0;
+  // This is the same limit as in the original Rust Safetensors code.
+  constexpr uint64_t kMaxJsonHeaderLength = 100000000;
+  in_stream->read(reinterpret_cast<char*>(&jsonHeaderLength), 8);
+  if (jsonHeaderLength <= 0 || jsonHeaderLength >= kMaxJsonHeaderLength) {
+    throw std::runtime_error(
+        "[load_safetensors] Invalid json header length " + in_stream->label());
+  }
+  // Load the json metadata
+  auto rawJson = std::make_unique<char[]>(jsonHeaderLength);
+  in_stream->read(rawJson.get(), jsonHeaderLength);
+  auto metadata = json::parse(rawJson.get(), rawJson.get() + jsonHeaderLength);
+  // Should always be an object on the top-level
+  if (!metadata.is_object()) {
+    throw std::runtime_error(
+        "[load_safetensors] Invalid json metadata " + in_stream->label());
+  }
+  size_t offset = jsonHeaderLength + 8;
+  // Load the arrays using metadata
+  std::unordered_map<std::string, array> res;
+  std::unordered_map<std::string, std::string> metadata_map;
+  for (const auto& item : metadata.items()) {
+    if (item.key() == "__metadata__") {
+      for (const auto& meta_item : item.value().items()) {
+        metadata_map.insert({meta_item.key(), meta_item.value()});
+      }
+      continue;
+    }
+    const std::string& dtype = item.value().at("dtype");
+    const Shape& shape = item.value().at("shape");
+    const std::vector<size_t>& data_offsets = item.value().at("data_offsets");
+    Dtype type = dtype_from_safetensor_str(dtype);
+    auto loaded_array = array(
+        shape,
+        type,
+        std::make_shared<Load>(
+            stream, in_stream, offset + data_offsets.at(0), false),
+        std::vector<array>{});
+    if (dtype == ST_F8_E4M3) {
+      loaded_array = f8_e4m3_to_float(loaded_array, bfloat16, s);
+    }
+    res.insert({item.key(), loaded_array});
+  }
+  return {res, metadata_map};
+}
+
+SafetensorsLoad load_safetensors(const std::string& file, StreamOrDevice s) {
+  return load_safetensors(std::make_shared<io::ParallelFileReader>(file), s);
+}
+
+void save_safetensors(
+    std::shared_ptr<io::Writer> out_stream,
+    std::unordered_map<std::string, array> a,
+    std::unordered_map<std::string, std::string> metadata /* = {} */) {
+  ////////////////////////////////////////////////////////
+  // Check file
+  if (!out_stream->good() || !out_stream->is_open()) {
+    throw std::runtime_error(
+        "[save_safetensors] Failed to open " + out_stream->label());
+  }
+
+  ////////////////////////////////////////////////////////
+  // Check array map
+  json parent;
+  json _metadata;
+  for (auto& [key, value] : metadata) {
+    _metadata[key] = value;
+  }
+  parent["__metadata__"] = _metadata;
+
+  {
+    std::vector<array> to_eval;
+    to_eval.reserve(a.size());
+    for (auto& p : a) {
+      p.second = contiguous(p.second);
+      to_eval.push_back(p.second);
+    }
+    eval(std::move(to_eval));
+  }
+
+  size_t offset = 0;
+  for (auto& [key, arr] : a) {
+    if (arr.nbytes() == 0) {
+      throw std::invalid_argument(
+          "[save_safetensors] cannot serialize an empty array key: " + key);
+    }
+
+    json child;
+    child["dtype"] = dtype_to_safetensor_str(arr.dtype());
+    child["shape"] = arr.shape();
+    child["data_offsets"] = std::vector<size_t>{offset, offset + arr.nbytes()};
+    parent[key] = child;
+    offset += arr.nbytes();
+  }
+
+  auto header = parent.dump();
+  uint64_t header_len = header.length();
+  out_stream->write(reinterpret_cast<char*>(&header_len), 8);
+  out_stream->write(header.c_str(), header_len);
+  for (auto& [key, arr] : a) {
+    out_stream->write(arr.data<char>(), arr.nbytes());
+  }
+}
+
+void save_safetensors(
+    std::string file,
+    std::unordered_map<std::string, array> a,
+    std::unordered_map<std::string, std::string> metadata /* = {} */) {
+  // Add .safetensors to file name if it is not there
+  if (file.length() < 12 ||
+      file.substr(file.length() - 12, 12) != ".safetensors")
+    file += ".safetensors";
+
+  // Serialize array
+  save_safetensors(
+      std::make_shared<io::FileWriter>(std::move(file)), a, metadata);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/linalg.cpp b/ml-stable-diffusion/mlx/mlx/linalg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e8a9e430e57e1761a3215b6edce5d2a0113c8b2a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/linalg.cpp
@@ -0,0 +1,706 @@
+// Copyright © 2023 Apple Inc.
+
+#include <numeric>
+#include <ostream>
+#include <vector>
+
+#include "mlx/linalg.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core::linalg {
+
+void check_cpu_stream(const StreamOrDevice& s, const std::string& prefix) {
+  if (to_stream(s).device == Device::gpu) {
+    throw std::invalid_argument(
+        prefix +
+        " This op is not yet supported on the GPU. "
+        "Explicitly pass a CPU stream to run it.");
+  }
+}
+void check_float(Dtype dtype, const std::string& prefix) {
+  if (dtype != float32 && dtype != float64) {
+    std::ostringstream msg;
+    msg << prefix << " Arrays must have type float32 or float64. "
+        << "Received array with type " << dtype << ".";
+    throw std::invalid_argument(msg.str());
+  }
+}
+
+void check_float_or_complex(Dtype dtype, const std::string& prefix) {
+  if (dtype != float32 && dtype != float64 && dtype != complex64) {
+    std::ostringstream msg;
+    msg << prefix << " Arrays must have type float32, float64 or complex64. "
+        << "Received array with type " << dtype << ".";
+    throw std::invalid_argument(msg.str());
+  }
+}
+
+Dtype at_least_float(const Dtype& d) {
+  return issubdtype(d, inexact) ? d : promote_types(d, float32);
+}
+
+inline array l2_norm(
+    const array& a,
+    const std::vector<int>& axis,
+    bool keepdims,
+    StreamOrDevice s) {
+  if (issubdtype(a.dtype(), complexfloating)) {
+    return sqrt(sum(abs(a, s) * abs(a, s), axis, keepdims, s), s);
+  } else {
+    return sqrt(sum(square(a, s), axis, keepdims, s), s);
+  }
+}
+
+inline array vector_norm(
+    const array& a,
+    const double ord,
+    const std::vector<int>& axis,
+    bool keepdims,
+    StreamOrDevice s) {
+  auto dtype = at_least_float(a.dtype());
+  if (ord == 0.0) {
+    return astype(sum(not_equal(a, array(0), s), axis, keepdims, s), dtype, s);
+  } else if (ord == 1.0) {
+    return astype(sum(abs(a, s), axis, keepdims, s), dtype, s);
+  } else if (ord == 2.0) {
+    return l2_norm(a, axis, keepdims, s);
+  } else if (ord == std::numeric_limits<double>::infinity()) {
+    return astype(max(abs(a, s), axis, keepdims, s), dtype, s);
+  } else if (ord == -std::numeric_limits<double>::infinity()) {
+    return astype(min(abs(a, s), axis, keepdims, s), dtype, s);
+  } else {
+    return power(
+        sum(power(abs(a, s), array(ord, dtype), s), axis, keepdims, s),
+        array(1.0 / ord, dtype),
+        s);
+  }
+}
+
+inline array matrix_norm(
+    const array& a,
+    const double ord,
+    const std::vector<int>& axis,
+    bool keepdims,
+    StreamOrDevice s) {
+  auto dtype = at_least_float(a.dtype());
+  auto row_axis = axis[0];
+  auto col_axis = axis[1];
+  if (ord == -1.0) {
+    col_axis -= (!keepdims && col_axis > row_axis && col_axis > 0);
+    return astype(
+        min(sum(abs(a, s), row_axis, keepdims, s), col_axis, keepdims, s),
+        dtype,
+        s);
+  } else if (ord == 1.0) {
+    col_axis -= (!keepdims && col_axis > row_axis && col_axis > 0);
+    return astype(
+        max(sum(abs(a, s), row_axis, keepdims, s), col_axis, keepdims, s),
+        dtype,
+        s);
+  } else if (ord == std::numeric_limits<double>::infinity()) {
+    row_axis -= (!keepdims && row_axis > col_axis && row_axis > 0);
+    return astype(
+        max(sum(abs(a, s), col_axis, keepdims, s), row_axis, keepdims, s),
+        dtype,
+        s);
+  } else if (ord == -std::numeric_limits<double>::infinity()) {
+    row_axis -= (!keepdims && row_axis > col_axis && row_axis > 0);
+    return astype(
+        min(sum(abs(a, s), col_axis, keepdims, s), row_axis, keepdims, s),
+        dtype,
+        s);
+  } else if (ord == 2.0 || ord == -2.0) {
+    row_axis = (axis[0] < 0) ? axis[0] + a.ndim() : axis[0];
+    col_axis = (axis[1] < 0) ? axis[1] + a.ndim() : axis[1];
+    auto a_matrix = (row_axis > col_axis)
+        ? moveaxis(moveaxis(a, row_axis, -1, s), col_axis, -1, s)
+        : moveaxis(moveaxis(a, col_axis, -1, s), row_axis, -2, s);
+    a_matrix = svd(a_matrix, false, s).at(0);
+    a_matrix = (ord == 2.0) ? max(a_matrix, -1, false, s)
+                            : min(a_matrix, -1, false, s);
+    if (keepdims) {
+      std::vector<int> sorted_axes = (row_axis < col_axis)
+          ? std::vector<int>{row_axis, col_axis}
+          : std::vector<int>{col_axis, row_axis};
+      a_matrix = expand_dims(a_matrix, sorted_axes, s);
+    }
+    return astype(a_matrix, dtype, s);
+  } else {
+    std::ostringstream msg;
+    msg << "[linalg::norm] Invalid ord " << ord << " for matrix norm.";
+    throw std::invalid_argument(msg.str());
+  }
+}
+
+inline array matrix_norm(
+    const array& a,
+    const std::string& ord,
+    const std::vector<int>& axis,
+    bool keepdims,
+    StreamOrDevice s) {
+  if (ord == "f" || ord == "fro") {
+    return l2_norm(a, axis, keepdims, s);
+  } else if (ord == "nuc") {
+    int row_axis = (axis[0] < 0) ? axis[0] + a.ndim() : axis[0];
+    int col_axis = (axis[1] < 0) ? axis[1] + a.ndim() : axis[1];
+    auto a_matrix = (row_axis > col_axis)
+        ? moveaxis(moveaxis(a, row_axis, -1, s), col_axis, -1, s)
+        : moveaxis(moveaxis(a, col_axis, -1, s), row_axis, -2, s);
+    a_matrix = sum(svd(a_matrix, false, s).at(0), -1, false, s);
+    if (keepdims) {
+      std::vector<int> sorted_axes = (row_axis < col_axis)
+          ? std::vector<int>{row_axis, col_axis}
+          : std::vector<int>{col_axis, row_axis};
+      a_matrix = expand_dims(a_matrix, sorted_axes, s);
+    }
+    return a_matrix;
+  } else {
+    std::ostringstream msg;
+    msg << "[linalg::norm] Invalid ord value '" << ord << "' for matrix norm.";
+    throw std::invalid_argument(msg.str());
+  }
+}
+
+array norm(
+    const array& a,
+    const std::optional<std::vector<int>>& axis /* = std::nullopt */,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {} */) {
+  if (!axis) {
+    return norm(flatten(a, s), std::vector<int>{0}, keepdims, s);
+  }
+
+  if (axis.value().size() > 2) {
+    throw std::invalid_argument(
+        "[linalg::norm] Received too many axes for norm.");
+  }
+  return l2_norm(a, axis.value(), keepdims, s);
+}
+
+array norm(
+    const array& a,
+    const double ord,
+    const std::optional<std::vector<int>>& axis /* = std::nullopt */,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {} */) {
+  std::vector<int> ax;
+  if (!axis) {
+    ax.resize(a.ndim());
+    std::iota(ax.begin(), ax.end(), 0);
+  } else {
+    ax = axis.value();
+  }
+  if (ax.size() == 1) {
+    return vector_norm(a, ord, ax, keepdims, s);
+  } else if (ax.size() == 2) {
+    return matrix_norm(a, ord, ax, keepdims, s);
+  } else {
+    throw std::invalid_argument(
+        "[linalg::norm] Received too many axes for norm.");
+  }
+}
+
+array norm(
+    const array& a,
+    const std::string& ord,
+    const std::optional<std::vector<int>>& axis /* = std::nullopt */,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {} */) {
+  std::vector<int> ax;
+  if (!axis) {
+    ax.resize(a.ndim());
+    std::iota(ax.begin(), ax.end(), 0);
+  } else {
+    ax = axis.value();
+  }
+  if (ax.size() != 2) {
+    std::ostringstream msg;
+    msg << "[linalg::norm] Norm '" << ord << "' only supported for matrices,"
+        << " but received " << ax.size() << " axis/axes.";
+    throw std::invalid_argument(msg.str());
+  }
+  return matrix_norm(a, ord, ax, keepdims, s);
+}
+
+std::pair<array, array> qr(const array& a, StreamOrDevice s /* = {} */) {
+  check_cpu_stream(s, "[linalg::qr]");
+  check_float(a.dtype(), "[linalg::qr]");
+
+  if (a.ndim() < 2) {
+    std::ostringstream msg;
+    msg << "[linalg::qr] Arrays must have >= 2 dimensions. Received array "
+           "with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  int k = std::min(a.shape(-2), a.shape(-1));
+  auto q_shape = a.shape();
+  q_shape.back() = k;
+  auto r_shape = a.shape();
+  r_shape[r_shape.size() - 2] = k;
+  auto out = array::make_arrays(
+      {std::move(q_shape), std::move(r_shape)},
+      {a.dtype(), a.dtype()},
+      std::make_shared<QRF>(to_stream(s)),
+      {astype(a, a.dtype(), s)});
+  return std::make_pair(out[0], out[1]);
+}
+
+std::vector<array>
+svd(const array& a, bool compute_uv, StreamOrDevice s /* = {} */) {
+  check_cpu_stream(s, "[linalg::svd]");
+  check_float(a.dtype(), "[linalg::svd]");
+
+  if (a.ndim() < 2) {
+    std::ostringstream msg;
+    msg << "[linalg::svd] Input array must have >= 2 dimensions. Received array "
+           "with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  const auto m = a.shape(-2);
+  const auto n = a.shape(-1);
+  const auto rank = a.ndim();
+
+  auto s_shape = a.shape();
+  s_shape.pop_back();
+  s_shape[rank - 2] = std::min(m, n);
+
+  if (!compute_uv) {
+    return {array(
+        std::move(s_shape),
+        std::move(a.dtype()),
+        std::make_shared<SVD>(to_stream(s), compute_uv),
+        {a})};
+  }
+
+  auto u_shape = a.shape();
+  u_shape[rank - 2] = m;
+  u_shape[rank - 1] = m;
+
+  auto vt_shape = a.shape();
+  vt_shape[rank - 2] = n;
+  vt_shape[rank - 1] = n;
+
+  return array::make_arrays(
+      {u_shape, s_shape, vt_shape},
+      {a.dtype(), a.dtype(), a.dtype()},
+      std::make_shared<SVD>(to_stream(s), compute_uv),
+      {a});
+}
+
+array inv_impl(const array& a, bool tri, bool upper, StreamOrDevice s) {
+  check_cpu_stream(s, "[linalg::inv]");
+  check_float(a.dtype(), "[linalg::inv]");
+
+  if (a.ndim() < 2) {
+    std::ostringstream msg;
+    msg << "[linalg::inv] Arrays must have >= 2 dimensions. Received array "
+           "with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  if (a.shape(-1) != a.shape(-2)) {
+    throw std::invalid_argument(
+        "[linalg::inv] Inverses are only defined for square matrices.");
+  }
+
+  return array(
+      a.shape(),
+      a.dtype(),
+      std::make_shared<Inverse>(to_stream(s), tri, upper),
+      {a});
+}
+
+array inv(const array& a, StreamOrDevice s /* = {} */) {
+  return inv_impl(a, /*tri=*/false, /*upper=*/true, s);
+}
+
+array tri_inv(
+    const array& a,
+    bool upper /* = false */,
+    StreamOrDevice s /* = {} */) {
+  return inv_impl(a, /*tri=*/true, upper, s);
+}
+
+array cholesky(
+    const array& a,
+    bool upper /* = false */,
+    StreamOrDevice s /* = {} */) {
+  check_cpu_stream(s, "[linalg::cholesky]");
+  check_float(a.dtype(), "[linalg::cholesky]");
+  if (a.ndim() < 2) {
+    std::ostringstream msg;
+    msg << "[linalg::cholesky] Arrays must have >= 2 dimensions. Received array "
+           "with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (a.shape(-1) != a.shape(-2)) {
+    throw std::invalid_argument(
+        "[linalg::cholesky] Cholesky decomposition is only defined for square "
+        "matrices.");
+  }
+  return array(
+      a.shape(),
+      a.dtype(),
+      std::make_shared<Cholesky>(to_stream(s), upper),
+      {a});
+}
+
+array pinv(const array& a, StreamOrDevice s /* = {} */) {
+  check_cpu_stream(s, "[linalg::pinv]");
+  check_float(a.dtype(), "[linalg::pinv]");
+
+  if (a.ndim() < 2) {
+    std::ostringstream msg;
+    msg << "[linalg::pinv] Arrays must have >= 2 dimensions. Received array "
+        << "with " << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  int m = a.shape(-2);
+  int n = a.shape(-1);
+  int k = std::min(m, n);
+  auto outs = linalg::svd(a, true, s);
+  array U = outs[0];
+  array S = outs[1];
+  array V = outs[2];
+
+  Shape starts(a.ndim(), 0);
+  auto ends = a.shape();
+  int i = a.ndim() - 2;
+  int j = a.ndim() - 1;
+
+  // Prepare U
+  ends[i] = m;
+  ends[j] = k;
+  U = swapaxes(slice(U, starts, ends, s), -1, -2, s);
+
+  // Prepare V
+  ends[i] = k;
+  ends[j] = n;
+  V = swapaxes(slice(V, starts, ends, s), -1, -2, s);
+
+  // Prepare S
+  S = expand_dims(S, -2, s);
+
+  auto rcond = 10. * std::max(m, n) * finfo(a.dtype()).eps;
+  auto cutoff = multiply(array(rcond, a.dtype()), max(S, -1, true, s), s);
+  auto rS =
+      where(greater(S, cutoff, s), reciprocal(S, s), array(0.0f, a.dtype()), s);
+
+  return matmul(multiply(V, rS, s), U, s);
+}
+
+array cholesky_inv(
+    const array& L,
+    bool upper /* = false */,
+    StreamOrDevice s /* = {} */) {
+  check_cpu_stream(s, "[linalg::cholesky_inv]");
+  check_float(L.dtype(), "[linalg::cholesky_inv]");
+
+  if (L.ndim() < 2) {
+    std::ostringstream msg;
+    msg << "[linalg::cholesky_inv] Arrays must have >= 2 dimensions. Received array "
+           "with "
+        << L.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (L.shape(-1) != L.shape(-2)) {
+    throw std::invalid_argument(
+        "[linalg::cholesky_inv] Cholesky inverse is only defined for square "
+        "matrices.");
+  }
+
+  array L_inv = tri_inv(L, upper, s);
+  if (upper) {
+    return matmul(L_inv, swapaxes(L_inv, -1, -2, s), s);
+  } else {
+    return matmul(swapaxes(L_inv, -1, -2, s), L_inv, s);
+  }
+}
+
+array cross(
+    const array& a,
+    const array& b,
+    int axis /* = -1 */,
+    StreamOrDevice s /* = {} */) {
+  auto check_ax = [axis](const array& arr) {
+    if (axis >= static_cast<int>(arr.ndim()) || axis + arr.ndim() < 0) {
+      std::ostringstream msg;
+      msg << "[linalg::cross] axis " << axis << " invalid for array with "
+          << arr.ndim() << " dimensions.";
+      throw std::invalid_argument(msg.str());
+    }
+    if (arr.shape(axis) < 2 || arr.shape(axis) > 3) {
+      throw std::invalid_argument(
+          "[linalg::cross] The specified axis must have size 2 or 3.");
+    }
+  };
+  check_ax(a);
+  check_ax(b);
+
+  bool a_2d = a.shape(axis) == 2;
+  bool b_2d = b.shape(axis) == 2;
+
+  auto out_type = promote_types(a.dtype(), b.dtype());
+  auto ashape = a.shape();
+  auto bshape = b.shape();
+
+  ashape[axis < 0 ? axis + a.ndim() : axis] = 3;
+  bshape[axis < 0 ? axis + b.ndim() : axis] = 3;
+  auto out_shape = broadcast_shapes(ashape, bshape);
+
+  if (axis < 0) {
+    axis += out_shape.size();
+  }
+
+  out_shape[axis] = a_2d ? 2 : 3;
+  auto a_ = broadcast_to(astype(a, out_type, s), out_shape, s);
+
+  out_shape[axis] = b_2d ? 2 : 3;
+  auto b_ = broadcast_to(astype(b, out_type, s), out_shape, s);
+
+  auto a_splits = split(a_, a_2d ? 2 : 3, axis);
+  auto b_splits = split(b_, b_2d ? 2 : 3, axis);
+
+  std::vector<array> outputs;
+  if (a_2d && b_2d) {
+    auto z = zeros_like(a_splits[0], s);
+    outputs.push_back(z);
+    outputs.push_back(z);
+  } else if (b_2d) {
+    outputs.push_back(negative(multiply(a_splits[2], b_splits[1], s), s));
+    outputs.push_back(multiply(a_splits[2], b_splits[0], s));
+  } else if (a_2d) {
+    outputs.push_back(multiply(a_splits[1], b_splits[2], s));
+    outputs.push_back(negative(multiply(a_splits[0], b_splits[2], s), s));
+  } else {
+    outputs.push_back(subtract(
+        multiply(a_splits[1], b_splits[2], s),
+        multiply(a_splits[2], b_splits[1], s),
+        s));
+    outputs.push_back(subtract(
+        multiply(a_splits[2], b_splits[0], s),
+        multiply(a_splits[0], b_splits[2], s),
+        s));
+  }
+  outputs.push_back(subtract(
+      multiply(a_splits[0], b_splits[1], s),
+      multiply(a_splits[1], b_splits[0], s),
+      s));
+  return concatenate(outputs, axis, s);
+}
+
+void validate_eig(
+    const array& a,
+    const StreamOrDevice& stream,
+    const std::string& fname) {
+  check_cpu_stream(stream, fname);
+  check_float_or_complex(a.dtype(), fname);
+
+  if (a.ndim() < 2) {
+    std::ostringstream msg;
+    msg << fname << " Arrays must have >= 2 dimensions. Received array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (a.shape(-1) != a.shape(-2)) {
+    throw std::invalid_argument(fname + " Only defined for square matrices.");
+  }
+}
+
+array eigvalsh(
+    const array& a,
+    std::string UPLO /* = "L" */,
+    StreamOrDevice s /* = {} */) {
+  validate_eig(a, s, "[linalg::eigvalsh]");
+  Shape out_shape(a.shape().begin(), a.shape().end() - 1);
+  Dtype eigval_type = a.dtype() == complex64 ? float32 : a.dtype();
+  return array(
+      std::move(out_shape),
+      eigval_type,
+      std::make_shared<Eigh>(to_stream(s), UPLO, false),
+      {a});
+}
+
+std::pair<array, array> eigh(
+    const array& a,
+    std::string UPLO /* = "L" */,
+    StreamOrDevice s /* = {} */) {
+  validate_eig(a, s, "[linalg::eigh]");
+  Dtype eigval_type = a.dtype() == complex64 ? float32 : a.dtype();
+  auto out = array::make_arrays(
+      {Shape(a.shape().begin(), a.shape().end() - 1), a.shape()},
+      {eigval_type, a.dtype()},
+      std::make_shared<Eigh>(to_stream(s), UPLO, true),
+      {a});
+  return std::make_pair(out[0], out[1]);
+}
+
+array eigvals(const array& a, StreamOrDevice s /* = {} */) {
+  validate_eig(a, s, "[linalg::eigvals]");
+  Shape out_shape(a.shape().begin(), a.shape().end() - 1);
+  return array(
+      std::move(out_shape),
+      complex64,
+      std::make_shared<Eig>(to_stream(s), false),
+      {a});
+}
+
+std::pair<array, array> eig(const array& a, StreamOrDevice s /* = {} */) {
+  validate_eig(a, s, "[linalg::eig]");
+  auto out = array::make_arrays(
+      {Shape(a.shape().begin(), a.shape().end() - 1), a.shape()},
+      {complex64, complex64},
+      std::make_shared<Eig>(to_stream(s), true),
+      {a});
+  return std::make_pair(out[0], out[1]);
+}
+
+void validate_lu(
+    const array& a,
+    const StreamOrDevice& stream,
+    const std::string& fname) {
+  check_cpu_stream(stream, fname);
+  check_float(a.dtype(), fname);
+
+  if (a.ndim() < 2) {
+    std::ostringstream msg;
+    msg << fname
+        << " Arrays must have >= 2 dimensions. Received array "
+           "with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+}
+
+std::vector<array> lu_helper(const array& a, StreamOrDevice s /* = {} */) {
+  int m = a.shape()[a.shape().size() - 2];
+  int n = a.shape()[a.shape().size() - 1];
+
+  Shape pivots_shape(a.shape().begin(), a.shape().end() - 2);
+  pivots_shape.push_back(std::min(m, n));
+
+  Shape row_idx_shape(a.shape().begin(), a.shape().end() - 1);
+
+  return array::make_arrays(
+      {a.shape(), pivots_shape, row_idx_shape},
+      {a.dtype(), uint32, uint32},
+      std::make_shared<LUF>(to_stream(s)),
+      {astype(a, a.dtype(), s)});
+}
+
+std::vector<array> lu(const array& a, StreamOrDevice s /* = {} */) {
+  validate_lu(a, s, "[linalg::lu]");
+
+  auto out = lu_helper(a, s);
+  auto& LU = out[0];
+  auto& row_pivots = out[2];
+  auto L = tril(LU, /* k = */ -1, s);
+  auto U = triu(LU, /* k = */ 0, s);
+
+  int M = a.shape(-2);
+  int N = a.shape(-1);
+  int K = std::min(M, N);
+  if (N != K) {
+    auto start = Shape(L.ndim(), 0);
+    auto stop = L.shape();
+    stop.back() = K;
+    L = slice(L, std::move(start), std::move(stop), s);
+  } else if (M != K) {
+    auto start = Shape(U.ndim(), 0);
+    auto stop = U.shape();
+    stop[U.ndim() - 2] = K;
+    U = slice(U, std::move(start), std::move(stop), s);
+  }
+  L = add(L, eye(M, K, s), s);
+  return {row_pivots, L, U};
+}
+
+std::pair<array, array> lu_factor(const array& a, StreamOrDevice s /* = {} */) {
+  validate_lu(a, s, "[linalg::lu_factor]");
+  auto out = lu_helper(a, s);
+  return std::make_pair(out[0], out[1]);
+}
+
+void validate_solve(
+    const array& a,
+    const array& b,
+    const StreamOrDevice& stream,
+    const std::string& fname) {
+  check_cpu_stream(stream, fname);
+  if (a.ndim() < 2) {
+    std::ostringstream msg;
+    msg << fname << " First input must have >= 2 dimensions. "
+        << "Received array with " << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (b.ndim() < 1) {
+    std::ostringstream msg;
+    msg << fname << " Second input must have >= 1 dimensions. "
+        << "Received array with " << b.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (a.shape(-1) != a.shape(-2)) {
+    std::ostringstream msg;
+    msg << fname << " First input must be a square matrix. "
+        << "Received array with shape " << a.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  int lastDim = b.ndim() > 1 ? -2 : -1;
+  if (a.shape(-1) != b.shape(lastDim)) {
+    std::ostringstream msg;
+    msg << fname << " Last dimension of first input with shape " << a.shape()
+        << " must match second to last dimension of"
+        << " second input with shape " << b.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto out_type = promote_types(a.dtype(), b.dtype());
+  if (out_type != float32 && out_type != float64) {
+    std::ostringstream msg;
+    msg << fname
+        << " Input arrays must promote to float32 or float64. "
+           " Received arrays with type "
+        << a.dtype() << " and " << b.dtype() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+}
+
+array solve(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  validate_solve(a, b, s, "[linalg::solve]");
+
+  // P, L, U matrices
+  const auto luf = lu(a, s);
+  auto perm = argsort(luf[0], -1, s);
+  int take_axis = -1;
+  if (b.ndim() >= 2) {
+    perm = expand_dims(perm, -1, s);
+    take_axis -= 1;
+  }
+  auto pb = take_along_axis(b, perm, take_axis, s);
+  auto y = solve_triangular(luf[1], pb, /* upper = */ false, s);
+  return solve_triangular(luf[2], y, /* upper = */ true, s);
+}
+
+array solve_triangular(
+    const array& a,
+    const array& b,
+    bool upper /* = false */,
+    StreamOrDevice s /* = {} */) {
+  validate_solve(a, b, s, "[linalg::solve_triangular]");
+  auto a_inv = tri_inv(a, upper, s);
+  return matmul(a_inv, b, s);
+}
+
+} // namespace mlx::core::linalg
diff --git a/ml-stable-diffusion/mlx/mlx/linalg.h b/ml-stable-diffusion/mlx/mlx/linalg.h
new file mode 100644
index 0000000000000000000000000000000000000000..0690fba9582792e641b15c1eeec9c9126d5405ea
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/linalg.h
@@ -0,0 +1,111 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <optional>
+
+#include "mlx/array.h"
+#include "mlx/device.h"
+#include "mlx/ops.h"
+#include "mlx/stream.h"
+
+namespace mlx::core::linalg {
+
+/**
+ * Compute vector or matrix norms.
+ *
+ * - If axis and ord are both unspecified, computes the 2-norm of flatten(x).
+ * - If axis is not provided but ord is, then x must be either 1D or 2D.
+ * - If axis is provided, but ord is not, then the 2-norm (or Frobenius norm
+ *   for matrices) is computed along the given axes. At most 2 axes can be
+ *   specified.
+ * - If both axis and ord are provided, then the corresponding matrix or vector
+ *   norm is computed. At most 2 axes can be specified.
+ */
+array norm(
+    const array& a,
+    const double ord,
+    const std::optional<std::vector<int>>& axis = std::nullopt,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+inline array norm(
+    const array& a,
+    const double ord,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {}) {
+  return norm(a, ord, std::vector<int>{axis}, keepdims, s);
+}
+array norm(
+    const array& a,
+    const std::string& ord,
+    const std::optional<std::vector<int>>& axis = std::nullopt,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+inline array norm(
+    const array& a,
+    const std::string& ord,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {}) {
+  return norm(a, ord, std::vector<int>{axis}, keepdims, s);
+}
+array norm(
+    const array& a,
+    const std::optional<std::vector<int>>& axis = std::nullopt,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+inline array
+norm(const array& a, int axis, bool keepdims = false, StreamOrDevice s = {}) {
+  return norm(a, std::vector<int>{axis}, keepdims, s);
+}
+
+std::pair<array, array> qr(const array& a, StreamOrDevice s = {});
+
+std::vector<array>
+svd(const array& a, bool compute_uv, StreamOrDevice s /* = {} */);
+inline std::vector<array> svd(const array& a, StreamOrDevice s = {}) {
+  return svd(a, true, s);
+}
+
+array inv(const array& a, StreamOrDevice s = {});
+
+array tri_inv(const array& a, bool upper = false, StreamOrDevice s = {});
+
+array cholesky(const array& a, bool upper = false, StreamOrDevice s = {});
+
+array pinv(const array& a, StreamOrDevice s = {});
+
+array cholesky_inv(const array& a, bool upper = false, StreamOrDevice s = {});
+
+std::vector<array> lu(const array& a, StreamOrDevice s = {});
+
+std::pair<array, array> lu_factor(const array& a, StreamOrDevice s = {});
+
+array solve(const array& a, const array& b, StreamOrDevice s = {});
+
+array solve_triangular(
+    const array& a,
+    const array& b,
+    bool upper = false,
+    StreamOrDevice s = {});
+
+/**
+ * Compute the cross product of two arrays along the given axis.
+ */
+array cross(
+    const array& a,
+    const array& b,
+    int axis = -1,
+    StreamOrDevice s = {});
+
+std::pair<array, array> eig(const array& a, StreamOrDevice s = {});
+
+array eigvals(const array& a, StreamOrDevice s = {});
+
+array eigvalsh(const array& a, std::string UPLO = "L", StreamOrDevice s = {});
+
+std::pair<array, array>
+eigh(const array& a, std::string UPLO = "L", StreamOrDevice s = {});
+
+} // namespace mlx::core::linalg
diff --git a/ml-stable-diffusion/mlx/mlx/memory.h b/ml-stable-diffusion/mlx/mlx/memory.h
new file mode 100644
index 0000000000000000000000000000000000000000..8a264734c34e346559e110616a3dbb5679369508
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/memory.h
@@ -0,0 +1,78 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include <cstdlib>
+
+namespace mlx::core {
+
+/* Get the actively used memory in bytes.
+ *
+ * Note, this will not always match memory use reported by the system because
+ * it does not include cached memory buffers.
+ * */
+size_t get_active_memory();
+
+/* Get the peak amount of used memory in bytes.
+ *
+ * The maximum memory used recorded from the beginning of the program
+ * execution or since the last call to reset_peak_memory.
+ * */
+size_t get_peak_memory();
+
+/* Reset the peak memory to zero.
+ * */
+void reset_peak_memory();
+
+/* Get the cache size in bytes.
+ *
+ * The cache includes memory not currently used that has not been returned
+ * to the system allocator.
+ * */
+size_t get_cache_memory();
+
+/* Set the memory limit.
+ * The memory limit is a guideline for the maximum amount of memory to use
+ * during graph evaluation. If the memory limit is exceeded and there is no
+ * more RAM (including swap when available) allocations will result in an
+ * exception.
+ *
+ * When Metal is available the memory limit defaults to 1.5 times the maximum
+ * recommended working set size reported by the device.
+ *
+ * Returns the previous memory limit.
+ * */
+size_t set_memory_limit(size_t limit);
+
+/* Get the current memory limit. */
+size_t get_memory_limit();
+
+/* Set the cache limit.
+ * If using more than the given limit, free memory will be reclaimed
+ * from the cache on the next allocation. To disable the cache,
+ * set the limit to 0.
+ *
+ * The cache limit defaults to the memory limit.
+ *
+ * Returns the previous cache limit.
+ * */
+size_t set_cache_limit(size_t limit);
+
+/* Clear the memory cache. */
+void clear_cache();
+
+/* Set the wired size limit.
+ *
+ * Note, this function is only useful when using the Metal backend with
+ * macOS 15.0 or higher.
+ *
+ * The wired limit is the total size in bytes of memory that will be kept
+ * resident. The default value is ``0``.
+ *
+ * Setting a wired limit larger than system wired limit is an error.
+ *
+ * Returns the previous wired limit.
+ * */
+size_t set_wired_limit(size_t limit);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/mlx.h b/ml-stable-diffusion/mlx/mlx/mlx.h
new file mode 100644
index 0000000000000000000000000000000000000000..dbc9014d3499b97e804a296c00ba347c3a81d6a5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/mlx.h
@@ -0,0 +1,25 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/array.h"
+#include "mlx/backend/cuda/cuda.h"
+#include "mlx/backend/gpu/available.h"
+#include "mlx/backend/metal/metal.h"
+#include "mlx/compile.h"
+#include "mlx/device.h"
+#include "mlx/distributed/distributed.h"
+#include "mlx/distributed/ops.h"
+#include "mlx/einsum.h"
+#include "mlx/export.h"
+#include "mlx/fast.h"
+#include "mlx/fft.h"
+#include "mlx/io.h"
+#include "mlx/linalg.h"
+#include "mlx/memory.h"
+#include "mlx/ops.h"
+#include "mlx/random.h"
+#include "mlx/stream.h"
+#include "mlx/transforms.h"
+#include "mlx/utils.h"
+#include "mlx/version.h"
diff --git a/ml-stable-diffusion/mlx/mlx/ops.cpp b/ml-stable-diffusion/mlx/mlx/ops.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ffc7e4bb4175b0892c74c538bad33db7c6d6239f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/ops.cpp
@@ -0,0 +1,5548 @@
+// Copyright © 2023-2024 Apple Inc.
+
+// Required for using M_PI in MSVC.
+#define _USE_MATH_DEFINES
+
+#include <algorithm>
+#include <climits>
+#include <cmath>
+#include <numeric>
+#include <set>
+#include <sstream>
+
+#include "mlx/fast_primitives.h"
+#include "mlx/ops.h"
+#include "mlx/primitives.h"
+#include "mlx/transforms.h"
+#include "mlx/transforms_impl.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+namespace {
+
+std::tuple<Shape, std::vector<int>, bool> compute_reduce_shape(
+    const std::vector<int>& axes,
+    const Shape& shape) {
+  bool is_noop = true;
+  std::set<int> axes_set;
+  auto ndim = shape.size();
+  for (auto ax : axes) {
+    int ax_ = (ax < 0) ? ax + ndim : ax;
+    if (ax_ < 0 || ax_ >= ndim) {
+      std::ostringstream msg;
+      msg << "Invalid axis " << ax << " for array with " << ndim
+          << " dimensions.";
+      throw std::out_of_range(msg.str());
+    }
+    axes_set.insert(ax_);
+  }
+  if (axes_set.size() != axes.size()) {
+    throw std::invalid_argument("Duplicate axes detected in reduction.");
+  }
+  Shape out_shape;
+  for (int i = 0; i < ndim; ++i) {
+    if (axes_set.count(i) == 0) {
+      out_shape.push_back(shape[i]);
+    } else {
+      out_shape.push_back(1);
+    }
+    is_noop &= (out_shape.back() == shape[i]);
+  }
+  std::vector<int> sorted_axes(axes_set.begin(), axes_set.end());
+  return {out_shape, sorted_axes, is_noop};
+}
+
+Dtype at_least_float(const Dtype& d) {
+  return issubdtype(d, inexact) ? d : promote_types(d, float32);
+}
+
+array indices_or_default(
+    std::optional<array> indices,
+    const array& x,
+    StreamOrDevice s) {
+  if (indices.has_value()) {
+    return indices.value();
+  }
+
+  Shape shape(x.shape().begin(), x.shape().end() - 2);
+  int total =
+      std::reduce(shape.begin(), shape.end(), 1, std::multiplies<int>());
+  return reshape(arange(total, uint32, s), std::move(shape), s);
+}
+
+std::pair<int, int> extract_quantized_matmul_dims(
+    std::string_view tag,
+    const array& x,
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases,
+    bool transpose,
+    int group_size,
+    int bits) {
+  if (w.dtype() != uint32) {
+    std::ostringstream msg;
+    msg << "[" << tag << "] The weight matrix should be uint32 "
+        << "but received " << w.dtype();
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (biases && scales.shape() != biases->shape()) {
+    std::ostringstream msg;
+    msg << "[" << tag << "] Scales and biases should have the same shape. "
+        << "Received scales with shape " << scales.shape()
+        << " and biases with " << biases->shape();
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (!std::equal(
+          w.shape().begin(), w.shape().end() - 2, scales.shape().begin())) {
+    std::ostringstream msg;
+    msg << "[" << tag
+        << "] Weight and scales should have the same batch shape. "
+        << "Received weight with shape " << w.shape() << ", scales with "
+        << scales.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (w.shape(-1) * 32 / bits != scales.shape(-1) * group_size) {
+    std::ostringstream msg;
+    msg << "[" << tag << "] The shapes of the weight and scales are "
+        << "incompatible based on bits and group_size. w.shape() == "
+        << w.shape() << " and scales.shape() == " << scales.shape()
+        << " with group_size=" << group_size << " and bits=" << bits;
+    throw std::invalid_argument(msg.str());
+  }
+
+  int x_inner_dims = x.shape(-1);
+
+  // Calculate the expanded w's dims
+  int w_inner_dims = (transpose) ? w.shape(-1) * 32 / bits : w.shape(-2);
+  int w_outer_dims = (transpose) ? w.shape(-2) : w.shape(-1) * 32 / bits;
+
+  if (w_inner_dims != x_inner_dims) {
+    std::ostringstream msg;
+    msg << "[" << tag << "] Last dimension of first input with "
+        << "shape (..., " << x_inner_dims << ") does not match "
+        << "the expanded quantized matrix (" << w_inner_dims << ", "
+        << w_outer_dims << ") computed from shape " << w.shape()
+        << " with group_size=" << group_size << ", bits=" << bits
+        << " and transpose=" << std::boolalpha << transpose;
+    throw std::invalid_argument(msg.str());
+  }
+
+  return {w_inner_dims, w_outer_dims};
+}
+
+} // namespace
+
+array arange(
+    double start,
+    double stop,
+    double step,
+    Dtype dtype,
+    StreamOrDevice s /* = {} */) {
+  if (dtype == bool_) {
+    std::ostringstream msg;
+    msg << bool_ << " not supported for arange.";
+    throw std::invalid_argument(msg.str());
+  }
+  if (std::isnan(start) || std::isnan(step) || std::isnan(stop)) {
+    throw std::invalid_argument("[arange] Cannot compute length.");
+  }
+
+  if (std::isinf(start) || std::isinf(stop)) {
+    throw std::invalid_argument("[arange] Cannot compute length.");
+  }
+
+  // Check if start and stop specify a valid range because if not, we have to
+  // return an empty array
+  if (std::isinf(step) &&
+      ((step > 0 && start < stop) || (step < 0 && start > stop))) {
+    return array({start}, dtype);
+  }
+
+  double real_size = std::ceil((stop - start) / step);
+
+  if (real_size > INT_MAX) {
+    throw std::invalid_argument("[arange] Maximum size exceeded.");
+  }
+
+  int size = std::max(static_cast<int>(real_size), 0);
+  return array(
+      {size},
+      dtype,
+      std::make_shared<Arange>(to_stream(s), start, stop, step),
+      {});
+}
+array arange(
+    double start,
+    double stop,
+    double step,
+    StreamOrDevice s /* = {} */) {
+  return arange(start, stop, step, float32, to_stream(s));
+}
+array arange(
+    double start,
+    double stop,
+    Dtype dtype,
+    StreamOrDevice s /* = {} */) {
+  return arange(start, stop, 1.0, dtype, to_stream(s));
+}
+array arange(double start, double stop, StreamOrDevice s /* = {} */) {
+  return arange(start, stop, 1.0, float32, to_stream(s));
+}
+array arange(double stop, Dtype dtype, StreamOrDevice s /* = {} */) {
+  return arange(0.0, stop, 1.0, dtype, to_stream(s));
+}
+array arange(double stop, StreamOrDevice s /* = {} */) {
+  return arange(0.0, stop, 1.0, float32, to_stream(s));
+}
+array arange(int start, int stop, int step, StreamOrDevice s /* = {} */) {
+  return arange(
+      static_cast<double>(start),
+      static_cast<double>(stop),
+      static_cast<double>(step),
+      int32,
+      to_stream(s));
+}
+array arange(int start, int stop, StreamOrDevice s /* = {} */) {
+  return arange(
+      static_cast<double>(start),
+      static_cast<double>(stop),
+      1.0,
+      int32,
+      to_stream(s));
+}
+array arange(int stop, StreamOrDevice s /* = {} */) {
+  return arange(0.0, static_cast<double>(stop), 1.0, int32, to_stream(s));
+}
+
+array linspace(
+    double start,
+    double stop,
+    int num /* = 50 */,
+    Dtype dtype /* = float32 */,
+    StreamOrDevice s /* = {} */) {
+  if (num < 0) {
+    std::ostringstream msg;
+    msg << "[linspace] number of samples, " << num << ", must be non-negative.";
+    throw std::invalid_argument(msg.str());
+  }
+  if (num == 1) {
+    return astype(array({start}), dtype, s);
+  }
+  array t = divide(arange(0, num, float32, s), array(num - 1, float32), s);
+  array t_bar = subtract(array(1, float32), t, s);
+  return astype(
+      add(multiply(t_bar, array(start, float32), s),
+          multiply(t, array(stop, float32), s),
+          s),
+      dtype,
+      s);
+}
+
+array astype(array a, Dtype dtype, StreamOrDevice s /* = {} */) {
+  if (dtype == a.dtype()) {
+    return std::move(a);
+  }
+  auto copied_shape = a.shape(); // |a| will be moved
+  return array(
+      std::move(copied_shape),
+      dtype,
+      std::make_shared<AsType>(to_stream(s), dtype),
+      {std::move(a)});
+}
+
+array as_strided(
+    array a,
+    Shape shape,
+    Strides strides,
+    size_t offset,
+    StreamOrDevice s /* = {} */) {
+  auto copied_shape = shape; // |shape| will be moved
+  auto dtype = a.dtype(); // |a| will be moved
+  return array(
+      std::move(copied_shape),
+      dtype,
+      std::make_shared<AsStrided>(
+          to_stream(s), std::move(shape), std::move(strides), offset),
+      // Force the input array to be contiguous.
+      {flatten(std::move(a), s)});
+}
+
+array copy(array a, StreamOrDevice s /* = {} */) {
+  auto copied_shape = a.shape(); // |a| will be moved
+  auto dtype = a.dtype();
+  return array(
+      std::move(copied_shape),
+      dtype,
+      std::make_shared<Copy>(to_stream(s)),
+      {std::move(a)});
+}
+
+array full(Shape shape, array vals, Dtype dtype, StreamOrDevice s /* = {} */) {
+  if (std::any_of(shape.begin(), shape.end(), [](auto i) { return i < 0; })) {
+    throw std::invalid_argument("[full] Negative dimensions not allowed.");
+  }
+  auto copied_shape = shape; // |shape| will be moved
+  return array(
+      std::move(copied_shape),
+      dtype,
+      std::make_shared<Full>(to_stream(s)),
+      {broadcast_to(astype(std::move(vals), dtype, s), std::move(shape), s)});
+}
+
+array full(Shape shape, array vals, StreamOrDevice s /* = {} */) {
+  auto dtype = vals.dtype(); // |vals| will be moved
+  return full(std::move(shape), std::move(vals), dtype, to_stream(s));
+}
+
+array zeros(const Shape& shape, Dtype dtype, StreamOrDevice s /* = {} */) {
+  return full(shape, array(0, dtype), to_stream(s));
+}
+
+array zeros_like(const array& a, StreamOrDevice s /* = {} */) {
+  return zeros(a.shape(), a.dtype(), to_stream(s));
+}
+
+array ones(const Shape& shape, Dtype dtype, StreamOrDevice s /* = {} */) {
+  return full(shape, array(1, dtype), to_stream(s));
+}
+
+array ones_like(const array& a, StreamOrDevice s /* = {} */) {
+  return ones(a.shape(), a.dtype(), to_stream(s));
+}
+
+array eye(int n, int m, int k, Dtype dtype, StreamOrDevice s /* = {} */) {
+  if (n <= 0 || m <= 0) {
+    throw std::invalid_argument("[eye] N and M must be positive integers.");
+  }
+  array result = zeros({n, m}, dtype, s);
+  if (k >= m || -k >= n) {
+    return result;
+  }
+
+  int diagonal_length = k >= 0 ? std::min(n, m - k) : std::min(n + k, m);
+
+  std::vector<array> indices;
+  auto s1 = std::max(0, -k);
+  auto s2 = std::max(0, k);
+  indices.push_back(arange(s1, diagonal_length + s1, int32, s));
+  indices.push_back(arange(s2, diagonal_length + s2, int32, s));
+  array ones_array = ones({diagonal_length, 1, 1}, dtype, s);
+  return scatter(result, indices, ones_array, {0, 1}, s);
+}
+
+array identity(int n, Dtype dtype, StreamOrDevice s /* = {} */) {
+  return eye(n, n, 0, dtype, s);
+}
+
+array tri(int n, int m, int k, Dtype type, StreamOrDevice s /* = {} */) {
+  auto l = expand_dims(arange(n, s), 1, s);
+  auto r = expand_dims(arange(-k, m - k, s), 0, s);
+  return astype(greater_equal(l, r, s), type, s);
+}
+
+array tril(array x, int k /* = 0 */, StreamOrDevice s /* = {} */) {
+  if (x.ndim() < 2) {
+    throw std::invalid_argument("[tril] array must be at least 2-D");
+  }
+  auto mask = tri(x.shape(-2), x.shape(-1), k, bool_, s);
+  return where(mask, x, array(0, x.dtype()), s);
+}
+
+array triu(array x, int k /* = 0 */, StreamOrDevice s /* = {} */) {
+  if (x.ndim() < 2) {
+    throw std::invalid_argument("[triu] array must be at least 2-D");
+  }
+  auto mask = tri(x.shape(-2), x.shape(-1), k - 1, bool_, s);
+  return where(mask, array(0, x.dtype()), x, s);
+}
+
+array reshape(const array& a, Shape shape, StreamOrDevice s /* = {} */) {
+  if (a.shape() == shape) {
+    return a;
+  }
+  auto out_shape = Reshape::output_shape(a, shape);
+  return array(
+      std::move(out_shape),
+      a.dtype(),
+      std::make_shared<Reshape>(to_stream(s), std::move(shape)),
+      {a});
+}
+
+array unflatten(
+    const array& a,
+    int axis,
+    Shape shape,
+    StreamOrDevice s /* = {} */) {
+  if (shape.empty()) {
+    throw std::invalid_argument(
+        "[unflatten] Shape to unflatten to cannot be empty.");
+  }
+  auto ndim = static_cast<int>(a.ndim());
+  auto ax = axis < 0 ? axis + ndim : axis;
+  if (ax < 0 || ax >= ndim) {
+    std::ostringstream msg;
+    msg << "[unflatten] Invalid axes " << ax << " for array with " << a.ndim()
+        << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  size_t size = 1;
+  int infer_idx = -1;
+  for (int i = 0; i < shape.size(); ++i) {
+    if (shape[i] == -1) {
+      if (infer_idx >= 0) {
+        throw std::invalid_argument(
+            "[Unflatten] Can only infer one dimension.");
+      }
+      infer_idx = i;
+    } else {
+      size *= shape[i];
+    }
+  }
+  if (infer_idx >= 0) {
+    shape[infer_idx] = a.shape(ax) / size;
+    size *= shape[infer_idx];
+  }
+  if (size != a.shape(ax)) {
+    std::ostringstream msg;
+    msg << "[Unflatten] Cannot unflatten axis " << axis << " with size "
+        << a.shape(ax) << " into shape " << shape << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  if (shape.size() == 1) {
+    return a;
+  }
+
+  auto out_shape = Unflatten::output_shape(a, ax, shape);
+  return array(
+      std::move(out_shape),
+      a.dtype(),
+      std::make_shared<Unflatten>(to_stream(s), ax, std::move(shape)),
+      {a});
+}
+
+array flatten(
+    const array& a,
+    int start_axis,
+    int end_axis /* = -1 */,
+    StreamOrDevice s /* = {} */) {
+  auto ndim = static_cast<int>(a.ndim());
+  auto start_ax = start_axis + (start_axis < 0 ? ndim : 0);
+  auto end_ax = end_axis + (end_axis < 0 ? ndim : 0);
+  start_ax = std::max(0, start_ax);
+  end_ax = std::min(ndim - 1, end_ax);
+  if (a.ndim() == 0) {
+    return reshape(a, {1}, s);
+  }
+  if (end_ax < start_ax) {
+    throw std::invalid_argument(
+        "[flatten] start_axis must be less than or equal to end_axis");
+  }
+  if (start_ax >= ndim) {
+    std::ostringstream msg;
+    msg << "[flatten] Invalid start_axis " << start_axis << " for array with "
+        << ndim << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  if (end_ax < 0) {
+    std::ostringstream msg;
+    msg << "[flatten] Invalid end_axis " << end_axis << " for array with "
+        << ndim << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  if (start_ax == end_ax) {
+    return a;
+  }
+  return array(
+      Flatten::output_shape(a, start_ax, end_ax),
+      a.dtype(),
+      std::make_shared<Flatten>(to_stream(s), start_ax, end_ax),
+      {a});
+}
+
+array flatten(const array& a, StreamOrDevice s /* = {} */) {
+  return flatten(a, 0, a.ndim() - 1, s);
+}
+
+array hadamard_transform(
+    const array& a,
+    std::optional<float> scale_ /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  if (a.size() == 0) {
+    throw std::invalid_argument(
+        "[hadamard_transform] Does not support empty arrays.");
+  }
+  // Default to an orthonormal Hadamard matrix scaled by 1/sqrt(N)
+  int n = a.ndim() > 0 ? a.shape(-1) : 1;
+  float scale = scale_.has_value() ? *scale_ : 1.0f / std::sqrt(n);
+  auto dtype = issubdtype(a.dtype(), floating) ? a.dtype() : float32;
+
+  // Nothing to do for a scalar
+  if (n == 1) {
+    if (scale == 1) {
+      return a;
+    }
+
+    return multiply(a, array(scale, dtype), s);
+  }
+
+  return array(
+      a.shape(),
+      dtype,
+      std::make_shared<Hadamard>(to_stream(s), scale),
+      {astype(a, dtype, s)});
+}
+
+array squeeze_impl(
+    const array& a,
+    std::vector<int> axes,
+    StreamOrDevice s /* = {} */) {
+  for (auto& ax : axes) {
+    auto new_ax = ax < 0 ? ax + a.ndim() : ax;
+    if (new_ax < 0 || new_ax >= a.ndim()) {
+      std::ostringstream msg;
+      msg << "[squeeze] Invalid axes " << ax << " for array with " << a.ndim()
+          << " dimensions.";
+      throw std::invalid_argument(msg.str());
+    }
+    if (a.shape(new_ax) != 1) {
+      std::ostringstream msg;
+      msg << "[squeeze] Cannot squeeze axis " << ax << " with size "
+          << a.shape(ax) << " which is not equal to 1.";
+      throw std::invalid_argument(msg.str());
+    }
+    ax = new_ax;
+  }
+  auto shape = Squeeze::output_shape(a, axes);
+  return array(
+      std::move(shape),
+      a.dtype(),
+      std::make_shared<Squeeze>(to_stream(s), std::move(axes)),
+      {a});
+}
+
+array squeeze(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  if (axes.empty()) {
+    return a;
+  }
+  std::set<int> unique_axes;
+  for (auto ax : axes) {
+    unique_axes.insert(ax < 0 ? ax + a.ndim() : ax);
+  }
+  if (unique_axes.size() != axes.size()) {
+    throw std::invalid_argument("[squeeze] Received duplicate axes.");
+  }
+  std::vector<int> sorted_axes(unique_axes.begin(), unique_axes.end());
+  return squeeze_impl(a, std::move(sorted_axes), s);
+}
+
+array squeeze(const array& a, int axis, StreamOrDevice s /* = {} */) {
+  return squeeze_impl(a, {axis}, s);
+}
+
+array squeeze(const array& a, StreamOrDevice s /* = {} */) {
+  std::vector<int> axes;
+  for (int i = 0; i < a.ndim(); ++i) {
+    if (a.shape(i) == 1) {
+      axes.push_back(i);
+    }
+  }
+  return squeeze_impl(a, std::move(axes), s);
+}
+
+array expand_dims_impl(
+    const array& a,
+    std::vector<int> axes,
+    StreamOrDevice s /* = {} */) {
+  auto out_ndim = a.ndim() + axes.size();
+  for (auto& ax : axes) {
+    auto new_ax = ax < 0 ? ax + out_ndim : ax;
+    if (new_ax < 0 || new_ax >= out_ndim) {
+      std::ostringstream msg;
+      msg << "[expand_dims] Invalid axis " << ax << " for output array with "
+          << a.ndim() << " dimensions.";
+      throw std::invalid_argument(msg.str());
+    }
+    ax = new_ax;
+  }
+  auto shape = ExpandDims::output_shape(a, axes);
+  return array(
+      std::move(shape),
+      a.dtype(),
+      std::make_shared<ExpandDims>(to_stream(s), std::move(axes)),
+      {a});
+}
+
+array expand_dims(const array& a, int axis, StreamOrDevice s /* = {} */) {
+  return expand_dims_impl(a, {axis}, s);
+}
+
+array expand_dims(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  if (axes.empty()) {
+    return a;
+  }
+  { // Check for repeats
+    std::set<int> unique_axes(axes.begin(), axes.end());
+    if (unique_axes.size() != axes.size()) {
+      throw std::invalid_argument("[expand_dims] Received duplicate axes.");
+    }
+  }
+  // Check for repeats again
+  auto out_ndim = a.ndim() + axes.size();
+  std::set<int> unique_axes;
+  for (auto ax : axes) {
+    unique_axes.insert(ax < 0 ? ax + out_ndim : ax);
+  }
+  if (unique_axes.size() != axes.size()) {
+    throw std::invalid_argument("[expand_dims] Received duplicate axes.");
+  }
+  std::vector<int> sorted_axes(unique_axes.begin(), unique_axes.end());
+  return expand_dims_impl(a, std::move(sorted_axes), s);
+}
+
+// Slice helper
+namespace {
+
+inline auto
+normalize_slice(const Shape& shape, Shape& start, Shape stop, Shape& strides) {
+  // - Start indices are normalized
+  // - End indices are unchanged as -1 means something different
+  //   pre-normalization (the end of the axis) versus post normalization (the
+  //   position left of 0).
+  // - Any strides corresponding to singleton dimension are set to 1
+
+  Shape out_shape(shape.size());
+  bool has_neg_strides = false;
+
+  for (int i = 0; i < shape.size(); ++i) {
+    // Following numpy docs
+    //  Negative i and j are interpreted as n + i and n + j where n is
+    //  the number of elements in the corresponding dimension. Negative
+    //  k makes stepping go towards smaller indices
+
+    auto n = shape[i];
+    auto s = start[i];
+    s = s < 0 ? s + n : s;
+    auto e = stop[i];
+    e = e < 0 ? e + n : e;
+
+    // Note: -ve strides require start >= stop
+    if (strides[i] < 0) {
+      has_neg_strides = true;
+
+      // Clamp to bounds
+      auto st = std::min(s, n - 1);
+      auto ed = e > -1 ? e : -1;
+
+      start[i] = st;
+      ed = ed > st ? st : ed;
+
+      auto str = -strides[i];
+      out_shape[i] = (start[i] - ed + str - 1) / str;
+
+    } else {
+      // Clamp to bounds
+      auto st = std::max(static_cast<ShapeElem>(0), std::min(s, n));
+      auto ed = std::max(static_cast<ShapeElem>(0), std::min(e, n));
+
+      start[i] = st;
+      ed = ed < st ? st : ed;
+
+      out_shape[i] = (ed - start[i] + strides[i] - 1) / strides[i];
+    }
+    // Simplify the stride if it's unused
+    if (out_shape[i] == 1) {
+      strides[i] = 1;
+    }
+  }
+
+  return std::make_pair(has_neg_strides, out_shape);
+}
+
+void normalize_dynamic_slice_inputs(
+    const array& a,
+    const array& start,
+    std::vector<int>& axes,
+    std::string_view prefix) {
+  if (start.size() > a.ndim()) {
+    std::ostringstream msg;
+    msg << prefix << " Invalid number of starting positions for "
+        << "array with dimension " << a.ndim() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  if (start.ndim() > 1) {
+    std::ostringstream msg;
+    msg << prefix << " array of starting indices "
+        << "must be zero or one dimensional but has dimension " << start.ndim()
+        << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  if (start.size() != axes.size()) {
+    std::ostringstream msg;
+    msg << prefix << " Number of starting indices " << start.size()
+        << " does not match number of axes " << axes.size() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  if (!issubdtype(start.dtype(), integer)) {
+    std::ostringstream msg;
+    msg << prefix << " Start indices must be integers, got type "
+        << start.dtype() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  for (auto& ax : axes) {
+    auto new_ax = ax < 0 ? ax + a.ndim() : ax;
+    if (new_ax < 0 || new_ax >= a.ndim()) {
+      std::ostringstream msg;
+      msg << prefix << " Invalid axis " << ax << " for array with dimension "
+          << a.ndim() << ".";
+      throw std::invalid_argument(msg.str());
+    }
+    ax = new_ax;
+  }
+  std::set dims(axes.begin(), axes.end());
+  if (dims.size() != axes.size()) {
+    std::ostringstream msg;
+    msg << prefix << " Repeat axes not allowed.";
+    throw std::invalid_argument(msg.str());
+  }
+}
+
+} // namespace
+
+array slice(
+    const array& a,
+    Shape start,
+    Shape stop,
+    Shape strides,
+    StreamOrDevice s /* = {} */) {
+  if (start.size() != a.ndim() || stop.size() != a.ndim() ||
+      strides.size() != a.ndim()) {
+    std::ostringstream msg;
+    msg << "[slice] Invalid number of indices or strides for "
+        << "array with dimension " << a.ndim() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto [has_neg_strides, out_shape] =
+      normalize_slice(a.shape(), start, stop, strides);
+
+  if (!has_neg_strides && out_shape == a.shape()) {
+    return a;
+  }
+
+  return array(
+      out_shape,
+      a.dtype(),
+      std::make_shared<Slice>(
+          to_stream(s), std::move(start), std::move(stop), std::move(strides)),
+      {a});
+}
+
+array slice(
+    const array& a,
+    Shape start,
+    Shape stop,
+    StreamOrDevice s /* = {} */) {
+  return slice(
+      a, std::move(start), std::move(stop), Shape(a.ndim(), 1), to_stream(s));
+}
+
+array slice(
+    const array& a,
+    const array& start,
+    std::vector<int> axes,
+    Shape slice_size,
+    StreamOrDevice s /* = {} */) {
+  normalize_dynamic_slice_inputs(a, start, axes, "[slice]");
+
+  // Check the slice_size
+  if (slice_size.size() != a.ndim()) {
+    std::ostringstream msg;
+    msg << "[slice] Invalid slice size for array with " << a.ndim()
+        << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  for (int i = 0; i < a.ndim(); ++i) {
+    if (slice_size[i] > a.shape(i)) {
+      std::ostringstream msg;
+      msg << "[slice] Invalid slice size " << slice_size
+          << " for array with shape " << a.shape() << ".";
+      throw std::invalid_argument(msg.str());
+    }
+  }
+  auto out_shape = slice_size;
+  return array(
+      std::move(out_shape),
+      a.dtype(),
+      std::make_shared<DynamicSlice>(
+          to_stream(s), std::move(axes), std::move(slice_size)),
+      {a, start});
+}
+
+/** Update a slice from the source array */
+array slice_update(
+    const array& src,
+    const array& update,
+    Shape start,
+    Shape stop,
+    Shape strides,
+    StreamOrDevice s /* = {} */) {
+  // Check dimensions
+  if (start.size() != src.ndim() || stop.size() != src.ndim() ||
+      strides.size() != src.ndim()) {
+    std::ostringstream msg;
+    msg << "[slice_update] Invalid number of indices or strides for "
+        << "array with dimension " << src.ndim() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Process slice dimensions
+  auto [has_neg_strides, upd_shape] =
+      normalize_slice(src.shape(), start, stop, strides);
+
+  // Cast update to src type and broadcast update shape to slice shape
+  auto upd = broadcast_to(astype(update, src.dtype(), s), upd_shape, s);
+
+  // If the entire src is the slice, just return the update
+  if (!has_neg_strides && upd_shape == src.shape()) {
+    return upd;
+  }
+  return array(
+      src.shape(),
+      src.dtype(),
+      std::make_shared<SliceUpdate>(
+          to_stream(s), std::move(start), std::move(stop), std::move(strides)),
+      {src, upd});
+}
+
+/** Update a slice from the source array with stride 1 in each dimension */
+array slice_update(
+    const array& src,
+    const array& update,
+    Shape start,
+    Shape stop,
+    StreamOrDevice s /* = {} */) {
+  return slice_update(
+      src, update, std::move(start), std::move(stop), Shape(src.ndim(), 1), s);
+}
+
+/** Update a slice from the source array */
+array slice_update(
+    const array& src,
+    const array& update,
+    const array& start,
+    std::vector<int> axes,
+    StreamOrDevice s /* = {} */) {
+  normalize_dynamic_slice_inputs(src, start, axes, "[slice_update]");
+
+  // Broadcast update with unspecified axes
+  auto up_shape = update.shape();
+  auto dim_diff = std::max(src.ndim() - update.ndim(), size_t(0));
+  up_shape.insert(
+      up_shape.begin(), src.shape().begin(), src.shape().begin() + dim_diff);
+  for (int d = dim_diff; d < src.ndim(); ++d) {
+    up_shape[d] = std::min(up_shape[d], src.shape(d));
+  }
+  for (auto ax : axes) {
+    if (ax < dim_diff) {
+      up_shape[ax] = 1;
+    }
+  }
+  auto upd = broadcast_to(astype(update, src.dtype(), s), up_shape, s);
+  return array(
+      src.shape(),
+      src.dtype(),
+      std::make_shared<DynamicSliceUpdate>(to_stream(s), std::move(axes)),
+      {src, upd, start});
+}
+
+std::vector<array> split(
+    const array& a,
+    const Shape& indices,
+    int axis,
+    StreamOrDevice s /* = {} */) {
+  auto ax = axis < 0 ? axis + a.ndim() : axis;
+  if (ax < 0 || ax >= a.ndim()) {
+    std::ostringstream msg;
+    msg << "Invalid axis (" << axis << ") passed to split"
+        << " for array with shape " << a.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (indices.empty()) {
+    return {a};
+  }
+
+  if (indices.size() < 10 &&
+      std::is_sorted(indices.begin(), indices.end(), std::less<>{}) &&
+      indices[0] > 0 && indices.back() < a.shape(ax)) {
+    std::vector<Dtype> dtypes(indices.size() + 1, a.dtype());
+    std::vector<Shape> shapes(indices.size() + 1, a.shape());
+    shapes[0][ax] = indices[0];
+    for (int i = 1; i < indices.size(); i++) {
+      shapes[i][ax] = indices[i] - indices[i - 1];
+    }
+    shapes.back()[ax] = a.shape(ax) - indices.back();
+
+    return array::make_arrays(
+        std::move(shapes),
+        dtypes,
+        std::make_shared<Split>(to_stream(s), indices, ax),
+        {a});
+  }
+
+  std::vector<array> res;
+  auto start_indices = Shape(a.ndim(), 0);
+  auto stop_indices = a.shape();
+  for (int i = 0; i < indices.size() + 1; ++i) {
+    stop_indices[ax] = i < indices.size() ? indices[i] : a.shape(ax);
+    res.push_back(slice(a, start_indices, stop_indices, to_stream(s)));
+    start_indices[ax] = stop_indices[ax];
+  }
+  return res;
+}
+
+std::vector<array>
+split(const array& a, const Shape& indices, StreamOrDevice s /* = {} */) {
+  return split(a, indices, 0, s);
+}
+
+std::vector<array>
+split(const array& a, int num_splits, int axis, StreamOrDevice s /* = {} */) {
+  auto ax = axis < 0 ? axis + a.ndim() : axis;
+  if (ax < 0 || ax >= a.ndim()) {
+    std::ostringstream msg;
+    msg << "Invalid axis " << axis << " passed to split"
+        << " for array with shape " << a.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  auto q_and_r = std::ldiv(a.shape(axis), num_splits);
+  if (q_and_r.rem) {
+    std::ostringstream msg;
+    msg << "Array split does not result in sub arrays with equal size:"
+        << " attempting " << num_splits << " splits along axis " << axis
+        << " for shape " << a.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  auto split_size = q_and_r.quot;
+  Shape indices(num_splits - 1);
+  for (int i = 0; i < indices.size(); ++i) {
+    indices[i] = (i + 1) * split_size;
+  }
+  return split(a, indices, axis, s);
+}
+
+std::vector<array>
+split(const array& a, int num_splits, StreamOrDevice s /* = {} */) {
+  return split(a, num_splits, 0, to_stream(s));
+}
+
+std::vector<array> meshgrid(
+    const std::vector<array>& arrays,
+    bool sparse /* = false */,
+    const std::string& indexing /* = "xy" */,
+    StreamOrDevice s /* = {} */) {
+  if (indexing != "xy" && indexing != "ij") {
+    throw std::invalid_argument(
+        "[meshgrid] Invalid indexing value. Valid values are 'xy' and 'ij'.");
+  }
+
+  auto ndim = arrays.size();
+  std::vector<array> outputs;
+  for (int i = 0; i < ndim; ++i) {
+    Shape shape(ndim, 1);
+    shape[i] = -1;
+    outputs.push_back(reshape(arrays[i], std::move(shape), s));
+  }
+
+  if (indexing == "xy" && ndim > 1) {
+    Shape shape(ndim, 1);
+
+    shape[1] = arrays[0].size();
+    outputs[0] = reshape(arrays[0], shape, s);
+    shape[1] = 1;
+    shape[0] = arrays[1].size();
+    outputs[1] = reshape(arrays[1], std::move(shape), s);
+  }
+
+  if (!sparse) {
+    outputs = broadcast_arrays(outputs, s);
+  }
+
+  return outputs;
+}
+
+array clip(
+    const array& a,
+    const std::optional<array>& a_min,
+    const std::optional<array>& a_max,
+    StreamOrDevice s /* = {} */) {
+  if (!a_min.has_value() && !a_max.has_value()) {
+    throw std::invalid_argument("At most one of a_min and a_max may be None");
+  }
+  array result = a;
+  if (a_min.has_value()) {
+    result = maximum(result, a_min.value(), s);
+  }
+  if (a_max.has_value()) {
+    result = minimum(result, a_max.value(), s);
+  }
+  return result;
+}
+
+array concatenate(
+    std::vector<array> arrays,
+    int axis,
+    StreamOrDevice s /* = {} */) {
+  if (arrays.size() == 0) {
+    throw std::invalid_argument(
+        "[concatenate] No arrays provided for concatenation");
+  }
+  if (arrays.size() == 1) {
+    return arrays[0];
+  }
+
+  auto ax = normalize_axis_index(axis, arrays[0].ndim(), "[concatenate] ");
+
+  auto throw_invalid_shapes = [&]() {
+    std::ostringstream msg;
+    msg << "[concatenate] All the input array dimensions must match exactly "
+        << "except for the concatenation axis. However, the provided shapes are ";
+    for (auto& a : arrays) {
+      msg << a.shape() << ", ";
+    }
+    msg << "and the concatenation axis is " << axis << ".";
+    throw std::invalid_argument(msg.str());
+  };
+
+  auto shape = arrays[0].shape();
+  shape[ax] = 0;
+  // Make the output shape and validate that all arrays have the same shape
+  // except for the concatenation axis.
+  for (auto& a : arrays) {
+    if (a.ndim() != shape.size()) {
+      std::ostringstream msg;
+      msg << "[concatenate] All the input arrays must have the same number of "
+          << "dimensions. However, got arrays with dimensions " << shape.size()
+          << " and " << a.ndim() << ".";
+      throw std::invalid_argument(msg.str());
+    }
+    for (int i = 0; i < a.ndim(); i++) {
+      if (i == ax) {
+        continue;
+      }
+      if (a.shape(i) != shape[i]) {
+        throw_invalid_shapes();
+      }
+    }
+    shape[ax] += a.shape(ax);
+  }
+
+  // Promote all the arrays to the same type
+  auto dtype = result_type(arrays);
+  for (auto& a : arrays) {
+    a = astype(a, dtype, s);
+  }
+
+  return array(
+      std::move(shape),
+      dtype,
+      std::make_shared<Concatenate>(to_stream(s), ax),
+      std::move(arrays));
+}
+
+array concatenate(std::vector<array> arrays, StreamOrDevice s /* = {} */) {
+  for (auto& a : arrays) {
+    a = flatten(a, s);
+  }
+  return concatenate(std::move(arrays), 0, s);
+}
+
+/** Stack arrays along a new axis */
+array stack(
+    const std::vector<array>& arrays,
+    int axis,
+    StreamOrDevice s /* = {} */) {
+  if (arrays.empty()) {
+    throw std::invalid_argument("[stack] No arrays provided for stacking");
+  }
+  if (!std::all_of(arrays.begin(), arrays.end(), [&](const auto& a) {
+        return arrays[0].shape() == a.shape();
+      })) {
+    throw std::invalid_argument("[stack] All arrays must have the same shape");
+  }
+  auto normalized_axis =
+      normalize_axis_index(axis, arrays[0].ndim() + 1, "[stack] ");
+  std::vector<array> new_arrays;
+  new_arrays.reserve(arrays.size());
+  for (auto& a : arrays) {
+    new_arrays.emplace_back(expand_dims(a, normalized_axis, s));
+  }
+  return concatenate(new_arrays, axis, s);
+}
+
+array stack(const std::vector<array>& arrays, StreamOrDevice s /* = {} */) {
+  return stack(arrays, 0, s);
+}
+
+/** array repeat with axis */
+array repeat(const array& arr, int repeats, int axis, StreamOrDevice s) {
+  axis = normalize_axis_index(axis, arr.ndim(), "[repeat] ");
+
+  if (repeats < 0) {
+    throw std::invalid_argument(
+        "[repeat] Number of repeats cannot be negative");
+  }
+
+  if (repeats == 0) {
+    return array({}, arr.dtype());
+  }
+
+  if (repeats == 1) {
+    return arr;
+  }
+
+  // Broadcast to (S_1, S_2, ..., S_axis, repeats, S_axis+1, ...)
+  auto shape = arr.shape();
+  shape.insert(shape.begin() + axis + 1, repeats);
+  array out = expand_dims(arr, axis + 1, s);
+  out = broadcast_to(out, shape, s);
+
+  // Reshape back into a contiguous array where S_axis is now S_axis * repeats
+  shape.erase(shape.begin() + axis + 1);
+  shape[axis] *= repeats;
+  out = reshape(out, shape, s);
+
+  return out;
+}
+
+array repeat(const array& arr, int repeats, StreamOrDevice s) {
+  return repeat(flatten(arr, s), repeats, 0, s);
+}
+
+array tile(
+    const array& arr,
+    std::vector<int> reps,
+    StreamOrDevice s /* = {} */) {
+  auto shape = arr.shape();
+  if (reps.size() < shape.size()) {
+    reps.insert(reps.begin(), shape.size() - reps.size(), 1);
+  }
+  if (reps.size() > shape.size()) {
+    shape.insert(shape.begin(), reps.size() - shape.size(), 1);
+  }
+
+  Shape expand_shape;
+  Shape broad_shape;
+  Shape final_shape;
+  for (int i = 0; i < shape.size(); i++) {
+    if (reps[i] != 1) {
+      expand_shape.push_back(1);
+      broad_shape.push_back(reps[i]);
+    }
+    expand_shape.push_back(shape[i]);
+    broad_shape.push_back(shape[i]);
+    final_shape.push_back(reps[i] * shape[i]);
+  }
+
+  auto x = reshape(arr, std::move(expand_shape), s);
+  x = broadcast_to(x, std::move(broad_shape), s);
+  return reshape(x, std::move(final_shape), s);
+}
+
+array edge_pad(
+    const array& a,
+    const std::vector<int>& axes,
+    const Shape& low_pad_size,
+    const Shape& high_pad_size,
+    const Shape& out_shape,
+    StreamOrDevice s /* = {}*/) {
+  array out = zeros(out_shape, a.dtype(), s);
+  auto stops = a.shape();
+  for (int i = 0; i < stops.size(); i++) {
+    stops[i] += low_pad_size[i];
+  }
+  // Copy over values from the unpadded array
+  array padded = slice_update(out, a, low_pad_size, stops, s);
+
+  for (int axis = 0; axis < a.ndim(); axis++) {
+    if (low_pad_size[axis] > 0) {
+      Shape starts(a.ndim(), 0);
+      starts[axis] = low_pad_size[axis];
+      auto stops = out.shape();
+      stops[axis] = low_pad_size[axis] + 1;
+      // Fetch edge values
+      array edge_value = slice(padded, starts, stops, s);
+
+      starts[axis] = 0;
+      stops[axis] = low_pad_size[axis];
+      // Update edge values in the padded array
+      padded = slice_update(padded, edge_value, starts, stops, s);
+    }
+
+    if (high_pad_size[axis] > 0) {
+      Shape starts(a.ndim(), 0);
+      starts[axis] = -high_pad_size[axis] - 1;
+      auto stops = out.shape();
+      stops[axis] = -high_pad_size[axis];
+      array edge_value = slice(padded, starts, stops, s);
+
+      starts[axis] = -high_pad_size[axis];
+      stops[axis] = out.shape(axis);
+      padded = slice_update(padded, edge_value, starts, stops, s);
+    }
+  }
+  return padded;
+}
+
+/** Pad an array with a constant value */
+array pad(
+    const array& a,
+    const std::vector<int>& axes,
+    const Shape& low_pad_size,
+    const Shape& high_pad_size,
+    const array& pad_value /*= array(0)*/,
+    const std::string& mode /*= "constant"*/,
+    StreamOrDevice s /* = {}*/) {
+  if (axes.size() != low_pad_size.size() ||
+      axes.size() != high_pad_size.size()) {
+    std::ostringstream msg;
+    msg << "Invalid number of padding sizes passed to pad "
+        << "with axes of size " << axes.size();
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto out_shape = a.shape();
+
+  for (int i = 0; i < axes.size(); i++) {
+    if (low_pad_size[i] < 0) {
+      std::ostringstream msg;
+      msg << "Invalid low padding size (" << low_pad_size[i]
+          << ") passed to pad for axis " << i
+          << ". Padding sizes must be non-negative";
+      throw std::invalid_argument(msg.str());
+    }
+    if (high_pad_size[i] < 0) {
+      std::ostringstream msg;
+      msg << "Invalid high padding size (" << high_pad_size[i]
+          << ") passed to pad for axis " << i
+          << ". Padding sizes must be non-negative";
+      throw std::invalid_argument(msg.str());
+    }
+
+    auto ax = axes[i] < 0 ? a.ndim() + axes[i] : axes[i];
+    out_shape[ax] += low_pad_size[i] + high_pad_size[i];
+  }
+
+  if (mode == "constant") {
+    return array(
+        std::move(out_shape),
+        a.dtype(),
+        std::make_shared<Pad>(to_stream(s), axes, low_pad_size, high_pad_size),
+        {a, astype(pad_value, a.dtype(), s)});
+  } else if (mode == "edge") {
+    return edge_pad(a, axes, low_pad_size, high_pad_size, out_shape, s);
+  } else {
+    std::ostringstream msg;
+    msg << "Invalid padding mode (" << mode << ") passed to pad";
+    throw std::invalid_argument(msg.str());
+  }
+}
+
+/** Pad an array with a constant value along all axes */
+array pad(
+    const array& a,
+    const std::vector<std::pair<int, int>>& pad_width,
+    const array& pad_value /*= array(0)*/,
+    const std::string& mode /*= "constant"*/,
+    StreamOrDevice s /*= {}*/) {
+  std::vector<int> axes(a.ndim(), 0);
+  std::iota(axes.begin(), axes.end(), 0);
+
+  Shape lows;
+  Shape highs;
+
+  for (auto& pads : pad_width) {
+    lows.push_back(pads.first);
+    highs.push_back(pads.second);
+  }
+
+  return pad(a, axes, lows, highs, pad_value, mode, s);
+}
+
+array pad(
+    const array& a,
+    const std::pair<int, int>& pad_width,
+    const array& pad_value /*= array(0)*/,
+    const std::string& mode /*= "constant"*/,
+    StreamOrDevice s /*= {}*/) {
+  return pad(
+      a,
+      std::vector<std::pair<int, int>>(a.ndim(), pad_width),
+      pad_value,
+      mode,
+      s);
+}
+
+array pad(
+    const array& a,
+    int pad_width,
+    const array& pad_value /*= array(0)*/,
+    const std::string& mode /*= "constant"*/,
+    StreamOrDevice s /*= {}*/) {
+  return pad(
+      a,
+      std::vector<std::pair<int, int>>(a.ndim(), {pad_width, pad_width}),
+      pad_value,
+      mode,
+      s);
+}
+
+array moveaxis(
+    const array& a,
+    int source,
+    int destination,
+    StreamOrDevice s /* = {} */) {
+  auto check_ax = [&a](int ax) {
+    auto ndim = static_cast<int>(a.ndim());
+    if (ax < -ndim || ax >= ndim) {
+      std::ostringstream msg;
+      msg << "[moveaxis] Invalid axis " << ax << " for array with " << ndim
+          << " dimensions.";
+      throw std::out_of_range(msg.str());
+    }
+    return ax < 0 ? ax + ndim : ax;
+  };
+  source = check_ax(source);
+  destination = check_ax(destination);
+  if (source == destination) {
+    return a;
+  }
+  std::vector<int> reorder(a.ndim());
+  std::iota(reorder.begin(), reorder.end(), 0);
+  reorder.erase(reorder.begin() + source);
+  reorder.insert(reorder.begin() + destination, source);
+  return transpose(a, reorder, s);
+}
+
+array swapaxes(
+    const array& a,
+    int axis1,
+    int axis2,
+    StreamOrDevice s /* = {} */) {
+  auto check_ax = [&a](int ax) {
+    auto ndim = static_cast<int>(a.ndim());
+    if (ax < -ndim || ax >= ndim) {
+      std::ostringstream msg;
+      msg << "[swapaxes] Invalid axis " << ax << " for array with " << ndim
+          << " dimensions.";
+      throw std::out_of_range(msg.str());
+    }
+    return ax < 0 ? ax + ndim : ax;
+  };
+  axis1 = check_ax(axis1);
+  axis2 = check_ax(axis2);
+  std::vector<int> reorder(a.ndim());
+  std::iota(reorder.begin(), reorder.end(), 0);
+  std::swap(reorder[axis1], reorder[axis2]);
+  return transpose(a, std::move(reorder), s);
+}
+
+array transpose(
+    const array& a,
+    std::vector<int> axes,
+    StreamOrDevice s /* = {} */) {
+  for (auto& ax : axes) {
+    ax = ax < 0 ? ax + a.ndim() : ax;
+  }
+  if (axes.size() != a.ndim()) {
+    std::ostringstream msg;
+    msg << "[transpose] Recived " << axes.size() << " axes for array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Check in bounds and for duplicates
+  Shape shape(axes.size(), 0);
+  for (auto& ax : axes) {
+    if (ax < 0 || ax >= a.ndim()) {
+      std::ostringstream msg;
+      msg << "[transpose] Invalid axis (" << ax << ") for array with "
+          << a.ndim() << " dimensions.";
+      throw std::invalid_argument(msg.str());
+    }
+    if (shape[ax] != 0) {
+      throw std::invalid_argument("[transpose] Repeat axes not allowed.");
+    }
+    shape[ax] = 1;
+  }
+
+  for (int i = 0; i < axes.size(); ++i) {
+    shape[i] = a.shape()[axes[i]];
+  }
+  return array(
+      std::move(shape),
+      a.dtype(),
+      std::make_shared<Transpose>(to_stream(s), std::move(axes)),
+      {a});
+}
+
+array transpose(const array& a, StreamOrDevice s /* = {} */) {
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.rbegin(), axes.rend(), 0);
+  return transpose(a, std::move(axes), to_stream(s));
+}
+
+array broadcast_to(
+    const array& a,
+    const Shape& shape,
+    StreamOrDevice s /* = {} */) {
+  if (a.shape() == shape) {
+    return a;
+  }
+
+  // Make sure the shapes are broadcastable
+  auto bxshape = broadcast_shapes(a.shape(), shape);
+  if (bxshape != shape) {
+    std::ostringstream msg;
+    msg << "Cannot broadcast array of shape " << a.shape() << " into shape "
+        << shape << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  return array(
+      std::move(bxshape),
+      a.dtype(),
+      std::make_shared<Broadcast>(to_stream(s), shape),
+      {a});
+}
+
+/** Broadcast the input arrays against one another while ignoring the
+ * axes specified in `ignore_axes`. Note, this API is internal only.
+ * The `ignore_axes` should be:
+ * - negative values indicating axes from the end
+ * - sorted in increasing order
+ */
+std::vector<array> broadcast_arrays(
+    const std::vector<array>& inputs,
+    std::vector<int> ignore_axes,
+    StreamOrDevice s) {
+  if (inputs.size() <= 1) {
+    return inputs;
+  }
+
+  std::vector<array> outputs;
+  auto shape = BroadcastAxes::output_shape(inputs, ignore_axes);
+  auto check_and_get_shape = [&shape, &ignore_axes](const array& in) {
+    auto out_shape = shape;
+    for (int i = 0; i < ignore_axes.size(); ++i) {
+      auto ax = ignore_axes[i];
+      auto pos_ax = in.ndim() + ax;
+      if (pos_ax < 0 || pos_ax > in.ndim() ||
+          (i > 0 && ax <= ignore_axes[i - 1])) {
+        throw std::invalid_argument(
+            "[broadcast_arrays] Received invalid axes to ignore.");
+      }
+      out_shape[out_shape.size() + ax] = in.shape(ax);
+    }
+    return out_shape;
+  };
+
+  if (!detail::in_dynamic_tracing()) {
+    for (auto& in : inputs) {
+      auto out_shape = check_and_get_shape(in);
+      if (in.shape() == out_shape) {
+        outputs.push_back(in);
+      } else {
+        outputs.push_back(array(
+            std::move(out_shape),
+            in.dtype(),
+            std::make_shared<Broadcast>(to_stream(s), out_shape),
+            {in}));
+      }
+    }
+    return outputs;
+  }
+
+  std::vector<array> stop_grad_inputs;
+  for (auto& in : inputs) {
+    stop_grad_inputs.push_back(stop_gradient(in, s));
+  }
+
+  for (int i = 0; i < inputs.size(); ++i) {
+    auto& in = inputs[i];
+    auto out_shape = check_and_get_shape(in);
+    if (in.shape() == out_shape) {
+      outputs.push_back(in);
+    } else {
+      // broadcasted array goes first followed by other stopgrad inputs
+      std::vector<array> p_inputs = {in};
+      for (int j = 0; j < inputs.size(); ++j) {
+        if (j == i) {
+          continue;
+        }
+        p_inputs.push_back(stop_grad_inputs[j]);
+      }
+      outputs.push_back(array(
+          std::move(out_shape),
+          in.dtype(),
+          std::make_shared<BroadcastAxes>(to_stream(s), ignore_axes),
+          std::move(p_inputs)));
+    }
+  }
+  return outputs;
+}
+
+std::vector<array> broadcast_arrays(
+    const std::vector<array>& inputs,
+    StreamOrDevice s /* = {} */) {
+  if (inputs.size() <= 1) {
+    return inputs;
+  }
+  auto shape = Broadcast::output_shape(inputs);
+  std::vector<array> outputs;
+
+  if (!detail::in_dynamic_tracing()) {
+    for (auto& in : inputs) {
+      if (in.shape() == shape) {
+        outputs.push_back(in);
+      } else {
+        outputs.push_back(array(
+            shape,
+            in.dtype(),
+            std::make_shared<Broadcast>(to_stream(s), shape),
+            {in}));
+      }
+    }
+    return outputs;
+  }
+
+  std::vector<array> stop_grad_inputs;
+  for (auto& in : inputs) {
+    stop_grad_inputs.push_back(stop_gradient(in, s));
+  }
+  for (int i = 0; i < inputs.size(); ++i) {
+    auto& in = inputs[i];
+    if (in.shape() == shape) {
+      outputs.push_back(in);
+    } else {
+      // broadcasted array goes first followed by other stopgrad inputs
+      std::vector<array> p_inputs = {in};
+      for (int j = 0; j < inputs.size(); ++j) {
+        if (j == i) {
+          continue;
+        }
+        p_inputs.push_back(stop_grad_inputs[j]);
+      }
+      outputs.push_back(array(
+          shape,
+          in.dtype(),
+          std::make_shared<Broadcast>(to_stream(s), shape),
+          std::move(p_inputs)));
+    }
+  }
+  return outputs;
+}
+
+std::pair<array, array>
+broadcast_arrays(const array& a, const array& b, StreamOrDevice s) {
+  auto out = broadcast_arrays({a, b}, s);
+  return {out[0], out[1]};
+}
+
+std::pair<array, array> broadcast_arrays(
+    const array& a,
+    const array& b,
+    std::vector<int> ignore_axes,
+    StreamOrDevice s) {
+  auto out = broadcast_arrays({a, b}, std::move(ignore_axes), s);
+  return {out[0], out[1]};
+}
+
+array equal(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto dtype = promote_types(a.dtype(), b.dtype());
+  auto inputs = broadcast_arrays({astype(a, dtype, s), astype(b, dtype, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape, bool_, std::make_shared<Equal>(to_stream(s)), std::move(inputs));
+}
+
+array not_equal(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto dtype = promote_types(a.dtype(), b.dtype());
+  auto inputs = broadcast_arrays({astype(a, dtype, s), astype(b, dtype, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape,
+      bool_,
+      std::make_shared<NotEqual>(to_stream(s)),
+      std::move(inputs));
+}
+
+array greater(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto dtype = promote_types(a.dtype(), b.dtype());
+  auto inputs = broadcast_arrays({astype(a, dtype, s), astype(b, dtype, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape, bool_, std::make_shared<Greater>(to_stream(s)), std::move(inputs));
+}
+
+array greater_equal(
+    const array& a,
+    const array& b,
+    StreamOrDevice s /* = {} */) {
+  auto dtype = promote_types(a.dtype(), b.dtype());
+  auto inputs = broadcast_arrays({astype(a, dtype, s), astype(b, dtype, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape,
+      bool_,
+      std::make_shared<GreaterEqual>(to_stream(s)),
+      std::move(inputs));
+}
+
+array less(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto dtype = promote_types(a.dtype(), b.dtype());
+  auto inputs = broadcast_arrays({astype(a, dtype, s), astype(b, dtype, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape, bool_, std::make_shared<Less>(to_stream(s)), std::move(inputs));
+}
+
+array less_equal(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto dtype = promote_types(a.dtype(), b.dtype());
+  auto inputs = broadcast_arrays({astype(a, dtype, s), astype(b, dtype, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape,
+      bool_,
+      std::make_shared<LessEqual>(to_stream(s)),
+      std::move(inputs));
+}
+
+array array_equal(
+    const array& a,
+    const array& b,
+    bool equal_nan,
+    StreamOrDevice s /* = {} */) {
+  if (a.shape() != b.shape()) {
+    return array(false);
+  } else {
+    auto dtype = promote_types(a.dtype(), b.dtype());
+    equal_nan &= issubdtype(dtype, inexact);
+    return all(
+        array(
+            a.shape(),
+            bool_,
+            std::make_shared<Equal>(to_stream(s), equal_nan),
+            {astype(a, dtype, s), astype(b, dtype, s)}),
+        false,
+        s);
+  }
+}
+
+array isnan(const array& a, StreamOrDevice s /* = {} */) {
+  if (issubdtype(a.dtype(), integer) || a.dtype() == bool_) {
+    return full(a.shape(), false, bool_, s);
+  }
+  return not_equal(a, a, s);
+}
+
+array isinf(const array& a, StreamOrDevice s /* = {} */) {
+  if (issubdtype(a.dtype(), integer) || a.dtype() == bool_) {
+    return full(a.shape(), false, bool_, s);
+  }
+  return logical_or(isposinf(a, s), isneginf(a, s), s);
+}
+
+array isfinite(const array& a, StreamOrDevice s /* = {} */) {
+  if (issubdtype(a.dtype(), integer) || a.dtype() == bool_) {
+    return full(a.shape(), true, bool_, s);
+  }
+  return logical_not(logical_or(isinf(a, s), isnan(a, s), s), s);
+}
+
+array isposinf(const array& a, StreamOrDevice s /* = {} */) {
+  if (issubdtype(a.dtype(), integer) || a.dtype() == bool_) {
+    return full(a.shape(), false, bool_, s);
+  }
+  return equal(a, array(std::numeric_limits<float>::infinity(), a.dtype()), s);
+}
+
+array isneginf(const array& a, StreamOrDevice s /* = {} */) {
+  if (issubdtype(a.dtype(), integer) || a.dtype() == bool_) {
+    return full(a.shape(), false, bool_, s);
+  }
+  return equal(a, array(-std::numeric_limits<float>::infinity(), a.dtype()), s);
+}
+
+array where(
+    const array& a,
+    const array& b,
+    const array& c,
+    StreamOrDevice s /* = {} */) {
+  auto condition = astype(a, bool_, s);
+  Dtype out_dtype = promote_types(b.dtype(), c.dtype());
+  auto inputs = broadcast_arrays(
+      {condition, astype(b, out_dtype, s), astype(c, out_dtype, s)}, s);
+
+  return array(
+      inputs[0].shape(),
+      out_dtype,
+      std::make_shared<Select>(to_stream(s)),
+      inputs);
+}
+
+array nan_to_num(
+    const array& a,
+    float nan /* = 0.0f */,
+    const std::optional<float> posinf_ /* = std::nullopt */,
+    const std::optional<float> neginf_ /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  Dtype dtype = a.dtype();
+  if (!issubdtype(dtype, inexact)) {
+    return a;
+  }
+
+  auto type_to_max = [](const auto& dtype) -> float {
+    if (dtype == float32) {
+      return std::numeric_limits<float>::max();
+    } else if (dtype == bfloat16) {
+      return std::numeric_limits<bfloat16_t>::max();
+    } else if (dtype == float16) {
+      return std::numeric_limits<float16_t>::max();
+    } else {
+      std::ostringstream msg;
+      msg << "[nan_to_num] Does not yet support given type: " << dtype << ".";
+      throw std::invalid_argument(msg.str());
+    }
+  };
+
+  float posinf = posinf_ ? *posinf_ : type_to_max(dtype);
+  float neginf = neginf_ ? *neginf_ : -type_to_max(dtype);
+
+  auto out = where(isnan(a, s), array(nan, dtype), a, s);
+  out = where(isposinf(a, s), array(posinf, dtype), out, s);
+  out = where(isneginf(a, s), array(neginf, dtype), out, s);
+  return out;
+}
+
+array allclose(
+    const array& a,
+    const array& b,
+    double rtol /* = 1e-5 */,
+    double atol /* = 1e-8 */,
+    bool equal_nan /* = false */,
+    StreamOrDevice s /* = {}*/) {
+  return all(isclose(a, b, rtol, atol, equal_nan, s), s);
+}
+
+array isclose(
+    const array& a,
+    const array& b,
+    double rtol /* = 1e-5 */,
+    double atol /* = 1e-8 */,
+    bool equal_nan /* = false */,
+    StreamOrDevice s /* = {}*/) {
+  // |a - b| <= atol + rtol * |b|
+  auto rhs = add(array(atol), multiply(array(rtol), abs(b, s), s), s);
+  auto lhs = abs(subtract(a, b, s), s);
+  auto out = less_equal(lhs, rhs, s);
+
+  // Correct the result for infinite values.
+  auto a_pos_inf = isposinf(a, s);
+  auto b_pos_inf = isposinf(b, s);
+  auto a_neg_inf = isneginf(a, s);
+  auto b_neg_inf = isneginf(b, s);
+  auto any_inf = logical_or(
+      logical_or(a_pos_inf, a_neg_inf, s),
+      logical_or(b_pos_inf, b_neg_inf, s),
+      s);
+  auto both_inf = logical_or(
+      logical_and(a_pos_inf, b_pos_inf, s),
+      logical_and(a_neg_inf, b_neg_inf, s),
+      s);
+
+  // Convert all elements where either value is infinite to False.
+  out = logical_and(out, logical_not(any_inf, s), s);
+
+  // Convert all the elements where both values are infinite and of the same
+  // sign to True.
+  out = logical_or(out, both_inf, s);
+
+  if (equal_nan) {
+    auto both_nan = logical_and(isnan(a, s), isnan(b, s), s);
+    out = logical_or(out, both_nan, s);
+  }
+
+  return out;
+}
+
+array all(const array& a, bool keepdims, StreamOrDevice s /* = {}*/) {
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return all(a, axes, keepdims, s);
+}
+
+array all(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {}*/) {
+  auto [out_shape, sorted_axes, is_noop] =
+      compute_reduce_shape(axes, a.shape());
+  auto out = (is_noop)
+      ? astype(a, bool_, s)
+      : array(
+            std::move(out_shape),
+            bool_,
+            std::make_shared<Reduce>(to_stream(s), Reduce::And, sorted_axes),
+            {a});
+  if (!keepdims) {
+    out = squeeze(out, sorted_axes, s);
+  }
+  return out;
+}
+
+array all(
+    const array& a,
+    int axis,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {} */) {
+  return all(a, std::vector<int>{axis}, keepdims, s);
+}
+
+array any(const array& a, bool keepdims, StreamOrDevice s /* = {}*/) {
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return any(a, axes, keepdims, s);
+}
+
+array any(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {}*/) {
+  auto [out_shape, sorted_axes, is_noop] =
+      compute_reduce_shape(axes, a.shape());
+  auto out = (is_noop)
+      ? astype(a, bool_, s)
+      : array(
+            std::move(out_shape),
+            bool_,
+            std::make_shared<Reduce>(to_stream(s), Reduce::Or, sorted_axes),
+            {a});
+  if (!keepdims) {
+    out = squeeze(out, sorted_axes, s);
+  }
+  return out;
+}
+
+array any(
+    const array& a,
+    int axis,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {} */) {
+  return any(a, std::vector<int>{axis}, keepdims, s);
+}
+
+array sum(const array& a, bool keepdims, StreamOrDevice s /* = {}*/) {
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return sum(a, axes, keepdims, s);
+}
+
+array sum(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {}*/) {
+  if (axes.empty()) {
+    return a;
+  }
+  auto [out_shape, sorted_axes, is_noop] =
+      compute_reduce_shape(axes, a.shape());
+  Dtype out_type = a.dtype();
+  if (issubdtype(a.dtype(), signedinteger)) {
+    out_type = a.dtype().size() <= 4 ? int32 : int64;
+  } else if (issubdtype(a.dtype(), unsignedinteger)) {
+    out_type = a.dtype().size() <= 4 ? uint32 : uint64;
+  } else if (a.dtype() == bool_) {
+    out_type = int32;
+  }
+  auto out = (is_noop)
+      ? astype(a, out_type, s)
+      : array(
+            std::move(out_shape),
+            out_type,
+            std::make_shared<Reduce>(to_stream(s), Reduce::Sum, sorted_axes),
+            {a});
+  if (!keepdims) {
+    out = squeeze(out, sorted_axes, s);
+  }
+  return out;
+}
+
+array sum(
+    const array& a,
+    int axis,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {} */) {
+  return sum(a, std::vector<int>{axis}, keepdims, s);
+}
+
+array mean(const array& a, bool keepdims, StreamOrDevice s /* = {}*/) {
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return mean(a, axes, keepdims, to_stream(s));
+}
+
+array mean(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {}*/) {
+  int ndim = a.ndim();
+  for (int axis : axes) {
+    if (axis < -ndim || axis >= ndim) {
+      std::ostringstream msg;
+      msg << "[mean] axis " << axis << " is out of bounds for array with "
+          << ndim << " dimensions.";
+      throw std::invalid_argument(msg.str());
+    }
+  }
+  auto dtype = at_least_float(a.dtype());
+  auto normalizer = number_of_elements(a, axes, true, dtype, s);
+  return multiply(sum(a, axes, keepdims, s), normalizer, s);
+}
+
+array mean(
+    const array& a,
+    int axis,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {} */) {
+  return mean(a, std::vector<int>{axis}, keepdims, to_stream(s));
+}
+
+array var(
+    const array& a,
+    bool keepdims,
+    int ddof /* = 0*/,
+    StreamOrDevice s /* = {}*/) {
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return var(a, axes, keepdims, ddof, to_stream(s));
+}
+
+array var(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims /* = false */,
+    int ddof /* = 0*/,
+    StreamOrDevice s /* = {}*/) {
+  auto dtype = at_least_float(a.dtype());
+  auto mu = mean(a, axes, /* keepdims= */ true, s);
+  auto v = sum(square(subtract(a, mu, s), s), axes, keepdims, s);
+
+  if (ddof != 0) {
+    auto normalizer = maximum(
+        subtract(
+            number_of_elements(a, axes, false, dtype, s),
+            array(ddof, dtype),
+            s),
+        array(0, dtype),
+        s);
+    v = divide(v, normalizer, s);
+  } else {
+    auto normalizer = number_of_elements(a, axes, true, dtype, s);
+    v = multiply(v, normalizer, s);
+  }
+
+  return v;
+}
+
+array var(
+    const array& a,
+    int axis,
+    bool keepdims /* = false */,
+    int ddof /* = 0*/,
+    StreamOrDevice s /* = {} */) {
+  return var(a, std::vector<int>{axis}, keepdims, ddof, to_stream(s));
+}
+
+array std(
+    const array& a,
+    bool keepdims,
+    int ddof /* = 0*/,
+    StreamOrDevice s /* = {}*/) {
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return std(a, axes, keepdims, ddof, to_stream(s));
+}
+
+array std(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims /* = false */,
+    int ddof /* = 0*/,
+    StreamOrDevice s /* = {}*/) {
+  return sqrt(var(a, axes, keepdims, ddof, s), s);
+}
+
+array std(
+    const array& a,
+    int axis,
+    bool keepdims /* = false */,
+    int ddof /* = 0*/,
+    StreamOrDevice s /* = {} */) {
+  return std(a, std::vector<int>{axis}, keepdims, ddof, to_stream(s));
+}
+
+array prod(const array& a, bool keepdims, StreamOrDevice s /* = {}*/) {
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return prod(a, axes, keepdims, s);
+}
+
+array prod(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {}*/) {
+  if (axes.empty()) {
+    return a;
+  }
+  auto [out_shape, sorted_axes, is_noop] =
+      compute_reduce_shape(axes, a.shape());
+  Dtype out_type = a.dtype();
+  if (issubdtype(a.dtype(), signedinteger)) {
+    out_type = a.dtype().size() <= 4 ? int32 : int64;
+  } else if (issubdtype(a.dtype(), unsignedinteger)) {
+    out_type = a.dtype().size() <= 4 ? uint32 : uint64;
+  } else if (a.dtype() == bool_) {
+    out_type = int32;
+  }
+  auto out = (is_noop)
+      ? a
+      : array(
+            std::move(out_shape),
+            out_type,
+            std::make_shared<Reduce>(to_stream(s), Reduce::Prod, sorted_axes),
+            {a});
+  if (!keepdims) {
+    out = squeeze(out, sorted_axes, s);
+  }
+  return out;
+}
+
+array prod(
+    const array& a,
+    int axis,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {} */) {
+  return prod(a, std::vector<int>{axis}, keepdims, s);
+}
+
+array max(const array& a, bool keepdims, StreamOrDevice s /* = {}*/) {
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return max(a, axes, keepdims, s);
+}
+
+array max(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {}*/) {
+  if (a.size() == 0) {
+    throw std::invalid_argument("[max] Cannot max reduce zero size array.");
+  }
+  auto [out_shape, sorted_axes, is_noop] =
+      compute_reduce_shape(axes, a.shape());
+  auto out = (is_noop)
+      ? a
+      : array(
+            std::move(out_shape),
+            a.dtype(),
+            std::make_shared<Reduce>(to_stream(s), Reduce::Max, sorted_axes),
+            {a});
+  if (!keepdims) {
+    out = squeeze(out, sorted_axes, s);
+  }
+  return out;
+}
+
+array max(
+    const array& a,
+    int axis,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {} */) {
+  return max(a, std::vector<int>{axis}, keepdims, s);
+}
+
+array min(const array& a, bool keepdims, StreamOrDevice s /* = {}*/) {
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return min(a, axes, keepdims, s);
+}
+
+array min(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {}*/) {
+  if (a.size() == 0) {
+    throw std::invalid_argument("[min] Cannot min reduce zero size array.");
+  }
+  if (axes.empty()) {
+    return a;
+  }
+  auto [out_shape, sorted_axes, is_noop] =
+      compute_reduce_shape(axes, a.shape());
+  auto out = (is_noop)
+      ? a
+      : array(
+            std::move(out_shape),
+            a.dtype(),
+            std::make_shared<Reduce>(to_stream(s), Reduce::Min, sorted_axes),
+            {a});
+  if (!keepdims) {
+    out = squeeze(out, sorted_axes, s);
+  }
+  return out;
+}
+
+array min(
+    const array& a,
+    int axis,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {} */) {
+  return min(a, std::vector<int>{axis}, keepdims, s);
+}
+
+array argmin(const array& a, bool keepdims, StreamOrDevice s /* = {} */) {
+  int size = a.size();
+  auto result = argmin(flatten(a, s), 0, true, s);
+  if (keepdims) {
+    std::vector<int> axes(a.ndim() - 1);
+    std::iota(axes.begin(), axes.end(), 0);
+    result = expand_dims(result, axes, s);
+  } else {
+    result = squeeze(result, s);
+  }
+  return result;
+}
+
+array argmin(
+    const array& a,
+    int axis,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {} */) {
+  if (a.size() == 0) {
+    throw std::invalid_argument(
+        "[argmin] Cannot argmin reduce zero size array.");
+  }
+  auto [out_shape, sorted_axes, is_noop] =
+      compute_reduce_shape({axis}, a.shape());
+  auto out = (is_noop)
+      ? zeros(out_shape, uint32, s)
+      : array(
+            std::move(out_shape),
+            uint32,
+            std::make_shared<ArgReduce>(
+                to_stream(s), ArgReduce::ArgMin, sorted_axes[0]),
+            {a});
+  if (!keepdims) {
+    out = squeeze(out, sorted_axes[0], s);
+  }
+  return out;
+}
+
+array argmax(const array& a, bool keepdims, StreamOrDevice s /* = {} */) {
+  int size = a.size();
+  auto result = argmax(flatten(a, s), 0, true, s);
+  if (keepdims) {
+    std::vector<int> axes(a.ndim() - 1);
+    std::iota(axes.begin(), axes.end(), 0);
+    result = expand_dims(result, axes, s);
+  } else {
+    result = squeeze(result, s);
+  }
+  return result;
+}
+
+array argmax(
+    const array& a,
+    int axis,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {} */) {
+  if (a.size() == 0) {
+    throw std::invalid_argument(
+        "[argmax] Cannot argmax reduce zero size array.");
+  }
+  auto [out_shape, sorted_axes, is_noop] =
+      compute_reduce_shape({axis}, a.shape());
+  auto out = (is_noop)
+      ? zeros(out_shape, uint32, s)
+      : array(
+            std::move(out_shape),
+            uint32,
+            std::make_shared<ArgReduce>(
+                to_stream(s), ArgReduce::ArgMax, sorted_axes[0]),
+            {a});
+  if (!keepdims) {
+    out = squeeze(out, sorted_axes[0], s);
+  }
+  return out;
+}
+
+/** Returns a sorted copy of the flattened array. */
+array sort(const array& a, StreamOrDevice s /* = {} */) {
+  int size = a.size();
+  return sort(reshape(a, {size}, s), 0, s);
+}
+
+/** Returns a sorted copy of the array along a given axis. */
+array sort(const array& a, int axis, StreamOrDevice s /* = {} */) {
+  // Check for valid axis
+  if (axis + static_cast<int>(a.ndim()) < 0 ||
+      axis >= static_cast<int>(a.ndim())) {
+    std::ostringstream msg;
+    msg << "[sort] Received invalid axis " << axis << " for array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  return array(
+      a.shape(), a.dtype(), std::make_shared<Sort>(to_stream(s), axis), {a});
+}
+
+/** Returns indices that sort the flattened array. */
+array argsort(const array& a, StreamOrDevice s /* = {} */) {
+  int size = a.size();
+  return argsort(reshape(a, {size}, s), 0, s);
+}
+
+/** Returns indices that sort the array along a given axis. */
+array argsort(const array& a, int axis, StreamOrDevice s /* = {} */) {
+  // Check for valid axis
+  if (axis + static_cast<int>(a.ndim()) < 0 ||
+      axis >= static_cast<int>(a.ndim())) {
+    std::ostringstream msg;
+    msg << "[argsort] Received invalid axis " << axis << " for array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  return array(
+      a.shape(), uint32, std::make_shared<ArgSort>(to_stream(s), axis), {a});
+}
+
+/**
+ * Returns a partitioned copy of the flattened array
+ * such that the smaller kth elements are first.
+ **/
+array partition(const array& a, int kth, StreamOrDevice s /* = {} */) {
+  int size = a.size();
+  return partition(reshape(a, {size}, s), kth, 0, s);
+}
+
+/**
+ * Returns a partitioned copy of the array along a given axis
+ * such that the smaller kth elements are first.
+ **/
+array partition(
+    const array& a,
+    int kth,
+    int axis,
+    StreamOrDevice s /* = {} */) {
+  // Check for valid axis
+  if (axis + static_cast<int>(a.ndim()) < 0 ||
+      axis >= static_cast<int>(a.ndim())) {
+    std::ostringstream msg;
+    msg << "[partition] Received invalid axis " << axis << " for array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  int axis_ = axis < 0 ? axis + a.ndim() : axis;
+  int kth_ = kth < 0 ? kth + a.shape(axis) : kth;
+  if (kth_ < 0 || kth_ >= a.shape(axis_)) {
+    std::ostringstream msg;
+    msg << "[partition] Received invalid kth " << kth << "along axis " << axis
+        << " for array with shape: " << a.shape();
+    throw std::invalid_argument(msg.str());
+  }
+  return array(
+      a.shape(),
+      a.dtype(),
+      std::make_shared<Partition>(to_stream(s), kth_, axis_),
+      {a});
+}
+
+/**
+ * Returns indices that partition the flattened array
+ * such that the smaller kth elements are first.
+ **/
+array argpartition(const array& a, int kth, StreamOrDevice s /* = {} */) {
+  int size = a.size();
+  return argpartition(reshape(a, {size}, s), kth, 0, s);
+}
+
+/**
+ * Returns indices that partition the array along a given axis
+ * such that the smaller kth elements are first.
+ **/
+array argpartition(
+    const array& a,
+    int kth,
+    int axis,
+    StreamOrDevice s /* = {} */) {
+  // Check for valid axis
+  if (axis + static_cast<int>(a.ndim()) < 0 ||
+      axis >= static_cast<int>(a.ndim())) {
+    std::ostringstream msg;
+    msg << "[argpartition] Received invalid axis " << axis << " for array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  int axis_ = axis < 0 ? axis + a.ndim() : axis;
+  int kth_ = kth < 0 ? kth + a.shape(axis) : kth;
+  if (kth_ < 0 || kth_ >= a.shape(axis_)) {
+    std::ostringstream msg;
+    msg << "[argpartition] Received invalid kth " << kth << " along axis "
+        << axis << " for array with shape: " << a.shape();
+    throw std::invalid_argument(msg.str());
+  }
+  return array(
+      a.shape(),
+      uint32,
+      std::make_shared<ArgPartition>(to_stream(s), kth_, axis_),
+      {a});
+}
+
+/** Returns topk elements of the flattened array. */
+array topk(const array& a, int k, StreamOrDevice s /* = {}*/) {
+  int size = a.size();
+  return topk(reshape(a, {size}, s), k, 0, s);
+}
+
+/** Returns topk elements of the array along a given axis. */
+array topk(const array& a, int k, int axis, StreamOrDevice s /* = {}*/) {
+  // Check for valid axis
+  int axis_ = axis < 0 ? axis + a.ndim() : axis;
+  if (axis_ < 0 || axis_ >= static_cast<int>(a.ndim())) {
+    std::ostringstream msg;
+    msg << "[topk] Received invalid axis " << axis << " for array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  if (k < 0 || k > a.shape(axis_)) {
+    std::ostringstream msg;
+    msg << "[topk] Received invalid k=" << k << " along axis " << axis
+        << " for array with shape: " << a.shape();
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Return early if the whole input was requested.
+  if (k == a.shape(axis_)) {
+    return a;
+  }
+
+  array a_partitioned = partition(a, -k, axis_, s);
+  Shape slice_starts(a.ndim(), 0);
+  auto slice_ends = a.shape();
+  slice_starts[axis_] = a.shape(axis_) - k;
+  return slice(a_partitioned, slice_starts, slice_ends, s);
+}
+
+array logsumexp(const array& a, bool keepdims, StreamOrDevice s /* = {}*/) {
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return logsumexp(a, axes, keepdims, s);
+}
+
+array logsumexp(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {}*/) {
+  if (a.size() == 0) {
+    throw std::invalid_argument("[logsumexp] Received empty array.");
+  }
+  if (a.ndim() == 0 && !axes.empty()) {
+    throw std::invalid_argument(
+        "[logsumexp] Received non-empty axes for array with 0 dimensions.");
+  }
+  bool reduce_last_dim =
+      !axes.empty() && (axes.back() == a.ndim() - 1 || axes.back() == -1);
+  if (reduce_last_dim) {
+    // For more than 2 axes check if axes is [0, 1, ..., NDIM - 1] and shape
+    // is [1, 1, ..., N].
+    for (int i = axes.size() - 2; i >= 0; --i) {
+      if ((axes[i] + 1 != axes[i + 1]) || (a.shape(axes[i]) != 1)) {
+        reduce_last_dim = false;
+        break;
+      }
+    }
+  }
+  bool is_complex = issubdtype(a.dtype(), complexfloating);
+  if (!is_complex && reduce_last_dim) {
+    auto dtype = at_least_float(a.dtype());
+    auto out_shape = a.shape();
+    out_shape.back() = 1;
+    auto out = array(
+        std::move(out_shape),
+        dtype,
+        std::make_shared<LogSumExp>(to_stream(s)),
+        {astype(a, dtype, s)});
+    if (!keepdims) {
+      out = squeeze(out, -1, s);
+    }
+    return out;
+  }
+  auto maxval = stop_gradient(max(a, axes, true, s), s);
+  auto out = log(sum(exp(subtract(a, maxval, s), s), axes, keepdims, s), s);
+  out = add(out, reshape(maxval, out.shape(), s), s);
+  if (!keepdims) {
+    maxval = squeeze(maxval, axes, s);
+  }
+  return where(isinf(maxval, s), maxval, out, s);
+}
+
+array logsumexp(
+    const array& a,
+    int axis,
+    bool keepdims /* = false */,
+    StreamOrDevice s /* = {} */) {
+  return logsumexp(a, std::vector<int>{axis}, keepdims, s);
+}
+
+array abs(const array& a, StreamOrDevice s /* = {} */) {
+  auto out =
+      array(a.shape(), a.dtype(), std::make_shared<Abs>(to_stream(s)), {a});
+  if (a.dtype() == complex64) {
+    out = astype(out, float32, s);
+  }
+  return out;
+}
+
+array negative(const array& a, StreamOrDevice s /* = {} */) {
+  if (a.dtype() == bool_) {
+    auto msg = "[negative] Not supported for bool, use logical_not instead.";
+    throw std::invalid_argument(msg);
+  }
+  return array(
+      a.shape(), a.dtype(), std::make_shared<Negative>(to_stream(s)), {a});
+}
+array operator-(const array& a) {
+  return negative(a);
+}
+
+array sign(const array& a, StreamOrDevice s /* = {} */) {
+  return array(a.shape(), a.dtype(), std::make_shared<Sign>(to_stream(s)), {a});
+}
+
+array logical_not(const array& a, StreamOrDevice s /* = {} */) {
+  return array(
+      a.shape(),
+      bool_,
+      std::make_shared<LogicalNot>(to_stream(s)),
+      {astype(a, bool_, s)});
+}
+
+array logical_and(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  // Broadcast arrays to a common shape
+  auto inputs = broadcast_arrays({astype(a, bool_, s), astype(b, bool_, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape,
+      bool_,
+      std::make_shared<LogicalAnd>(to_stream(s)),
+      std::move(inputs));
+}
+array operator&&(const array& a, const array& b) {
+  return logical_and(a, b);
+}
+
+array logical_or(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  // Broadcast arrays to a common shape
+  auto inputs = broadcast_arrays({astype(a, bool_, s), astype(b, bool_, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape,
+      bool_,
+      std::make_shared<LogicalOr>(to_stream(s)),
+      std::move(inputs));
+}
+array operator||(const array& a, const array& b) {
+  return logical_or(a, b);
+}
+
+array reciprocal(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  return divide(array(1.0f, dtype), a, to_stream(s));
+}
+
+array add(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto out_type = promote_types(a.dtype(), b.dtype());
+  auto inputs =
+      broadcast_arrays({astype(a, out_type, s), astype(b, out_type, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape, out_type, std::make_shared<Add>(to_stream(s)), std::move(inputs));
+}
+
+array operator+(const array& a, const array& b) {
+  return add(a, b);
+}
+
+array subtract(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto out_type = promote_types(a.dtype(), b.dtype());
+  auto inputs =
+      broadcast_arrays({astype(a, out_type, s), astype(b, out_type, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape,
+      out_type,
+      std::make_shared<Subtract>(to_stream(s)),
+      std::move(inputs));
+}
+
+array operator-(const array& a, const array& b) {
+  return subtract(a, b);
+}
+
+array multiply(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto out_type = promote_types(a.dtype(), b.dtype());
+  auto inputs =
+      broadcast_arrays({astype(a, out_type, s), astype(b, out_type, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape,
+      out_type,
+      std::make_shared<Multiply>(to_stream(s)),
+      std::move(inputs));
+}
+
+array operator*(const array& a, const array& b) {
+  return multiply(a, b);
+}
+
+array divide(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(promote_types(a.dtype(), b.dtype()));
+  auto inputs = broadcast_arrays(
+      {astype(a, dtype, s), astype(b, dtype, to_stream(s))}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape, dtype, std::make_shared<Divide>(to_stream(s)), std::move(inputs));
+}
+array operator/(const array& a, const array& b) {
+  return divide(a, b);
+}
+array operator/(double a, const array& b) {
+  return divide(array(a), b);
+}
+array operator/(const array& a, double b) {
+  return divide(a, array(b));
+}
+
+array floor_divide(
+    const array& a,
+    const array& b,
+    StreamOrDevice s /* = {} */) {
+  auto dtype = promote_types(a.dtype(), b.dtype());
+  if (issubdtype(dtype, inexact)) {
+    return floor(divide(a, b, s), s);
+  }
+
+  auto inputs = broadcast_arrays({astype(a, dtype, s), astype(b, dtype, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape, dtype, std::make_shared<Divide>(to_stream(s)), std::move(inputs));
+}
+
+array remainder(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto dtype = promote_types(a.dtype(), b.dtype());
+  auto inputs = broadcast_arrays(
+      {astype(a, dtype, s), astype(b, dtype, to_stream(s))}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape,
+      dtype,
+      std::make_shared<Remainder>(to_stream(s)),
+      std::move(inputs));
+}
+array operator%(const array& a, const array& b) {
+  return remainder(a, b);
+}
+
+std::vector<array>
+divmod(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto dtype = promote_types(a.dtype(), b.dtype());
+  if (issubdtype(dtype, complexfloating)) {
+    throw std::invalid_argument("[divmod] Complex type not supported.");
+  }
+  auto inputs = broadcast_arrays(
+      {astype(a, dtype, s), astype(b, dtype, to_stream(s))}, s);
+  return array::make_arrays(
+      {inputs[0].shape(), inputs[0].shape()},
+      {inputs[0].dtype(), inputs[0].dtype()},
+      std::make_shared<DivMod>(to_stream(s)),
+      inputs);
+}
+
+array maximum(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto out_type = promote_types(a.dtype(), b.dtype());
+  auto inputs =
+      broadcast_arrays({astype(a, out_type, s), astype(b, out_type, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape,
+      out_type,
+      std::make_shared<Maximum>(to_stream(s)),
+      std::move(inputs));
+}
+
+array minimum(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto out_type = promote_types(a.dtype(), b.dtype());
+  auto inputs =
+      broadcast_arrays({astype(a, out_type, s), astype(b, out_type, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape,
+      out_type,
+      std::make_shared<Minimum>(to_stream(s)),
+      std::move(inputs));
+}
+
+array floor(const array& a, StreamOrDevice s /* = {} */) {
+  if (a.dtype() == complex64) {
+    throw std::invalid_argument("[floor] Not supported for complex64.");
+  }
+  return array(
+      a.shape(), a.dtype(), std::make_shared<Floor>(to_stream(s)), {a});
+}
+
+array ceil(const array& a, StreamOrDevice s /* = {} */) {
+  if (a.dtype() == complex64) {
+    throw std::invalid_argument("[floor] Not supported for complex64.");
+  }
+  return array(a.shape(), a.dtype(), std::make_shared<Ceil>(to_stream(s)), {a});
+}
+
+array square(const array& a, StreamOrDevice s /* = {} */) {
+  return array(
+      a.shape(), a.dtype(), std::make_shared<Square>(to_stream(s)), {a});
+}
+
+array exp(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(a.shape(), dtype, std::make_shared<Exp>(to_stream(s)), {input});
+}
+
+array expm1(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(
+      a.shape(), dtype, std::make_shared<Expm1>(to_stream(s)), {input});
+}
+
+array sin(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(a.shape(), dtype, std::make_shared<Sin>(to_stream(s)), {input});
+}
+
+array cos(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(a.shape(), dtype, std::make_shared<Cos>(to_stream(s)), {input});
+}
+
+array tan(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(a.shape(), dtype, std::make_shared<Tan>(to_stream(s)), {input});
+}
+
+array arcsin(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(
+      a.shape(), dtype, std::make_shared<ArcSin>(to_stream(s)), {input});
+}
+
+array arccos(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(
+      a.shape(), dtype, std::make_shared<ArcCos>(to_stream(s)), {input});
+}
+
+array arctan(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(
+      a.shape(), dtype, std::make_shared<ArcTan>(to_stream(s)), {input});
+}
+
+array arctan2(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(promote_types(a.dtype(), b.dtype()));
+  auto inputs = broadcast_arrays({astype(a, dtype, s), astype(b, dtype, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape, dtype, std::make_shared<ArcTan2>(to_stream(s)), std::move(inputs));
+}
+
+array sinh(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(a.shape(), dtype, std::make_shared<Sinh>(to_stream(s)), {input});
+}
+
+array cosh(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(a.shape(), dtype, std::make_shared<Cosh>(to_stream(s)), {input});
+}
+
+array tanh(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(a.shape(), dtype, std::make_shared<Tanh>(to_stream(s)), {input});
+}
+
+array arcsinh(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(
+      a.shape(), dtype, std::make_shared<ArcSinh>(to_stream(s)), {input});
+}
+
+array arccosh(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(
+      a.shape(), dtype, std::make_shared<ArcCosh>(to_stream(s)), {input});
+}
+
+array arctanh(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(
+      a.shape(), dtype, std::make_shared<ArcTanh>(to_stream(s)), {input});
+}
+
+array degrees(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  return multiply(a, array(180.0 / M_PI, dtype), s);
+}
+
+array radians(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  return multiply(a, array(M_PI / 180.0, dtype), s);
+}
+
+array log(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(
+      a.shape(),
+      dtype,
+      std::make_shared<Log>(to_stream(s), Log::Base::e),
+      {input});
+}
+
+array log2(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(
+      a.shape(),
+      dtype,
+      std::make_shared<Log>(to_stream(s), Log::Base::two),
+      {input});
+}
+
+array log10(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(
+      a.shape(),
+      dtype,
+      std::make_shared<Log>(to_stream(s), Log::Base::ten),
+      {input});
+}
+
+array log1p(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(
+      a.shape(), dtype, std::make_shared<Log1p>(to_stream(s)), {input});
+}
+
+array logaddexp(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  // Make sure out type is floating point
+  auto out_type = at_least_float(promote_types(a.dtype(), b.dtype()));
+  auto inputs =
+      broadcast_arrays({astype(a, out_type, s), astype(b, out_type, s)}, s);
+  auto& shape = inputs[0].shape();
+  return array(
+      shape,
+      out_type,
+      std::make_shared<LogAddExp>(to_stream(s)),
+      std::move(inputs));
+}
+
+array sigmoid(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  auto input = astype(a, dtype, s);
+  return array(
+      a.shape(), dtype, std::make_shared<Sigmoid>(to_stream(s)), {input});
+}
+
+array erf(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  return array(
+      a.shape(),
+      dtype,
+      std::make_shared<Erf>(to_stream(s)),
+      {astype(a, dtype, s)});
+}
+
+array erfinv(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  return array(
+      a.shape(),
+      dtype,
+      std::make_shared<ErfInv>(to_stream(s)),
+      {astype(a, dtype, s)});
+}
+
+array stop_gradient(const array& a, StreamOrDevice s /* = {} */) {
+  return array(
+      a.shape(), a.dtype(), std::make_shared<StopGradient>(to_stream(s)), {a});
+}
+
+array round(const array& a, int decimals, StreamOrDevice s /* = {} */) {
+  if (decimals == 0) {
+    return array(
+        a.shape(), a.dtype(), std::make_shared<Round>(to_stream(s)), {a});
+  }
+
+  auto dtype = at_least_float(a.dtype());
+  float scale = std::pow(10, decimals);
+  auto result = multiply(a, array(scale, dtype), s);
+  result = round(result, 0, s);
+  result = multiply(result, array(1 / scale, dtype), s);
+
+  return astype(result, a.dtype(), s);
+}
+
+array matmul(
+    const array& in_a,
+    const array& in_b,
+    StreamOrDevice s /* = {} */) {
+  auto a = in_a;
+  auto b = in_b;
+  if (a.ndim() == 0 || b.ndim() == 0) {
+    throw std::invalid_argument(
+        "[matmul] Got 0 dimension input. Inputs must "
+        "have at least one dimension.");
+  }
+
+  if (a.ndim() == 1) {
+    // Insert a singleton dim in the beginning
+    a = expand_dims(a, 0, s);
+  }
+  if (b.ndim() == 1) {
+    // Insert a singleton dim at the end
+    b = expand_dims(b, 1, s);
+  }
+  if (a.shape(-1) != b.shape(-2)) {
+    std::ostringstream msg;
+    msg << "[matmul] Last dimension of first input with shape " << a.shape()
+        << " must match second to last dimension of"
+        << " second input with shape " << b.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Type promotion
+  auto out_type = promote_types(a.dtype(), b.dtype());
+
+  if (!issubdtype(out_type, inexact)) {
+    std::ostringstream msg;
+    msg << "[matmul] Only inexact types are supported but " << a.dtype()
+        << " and " << b.dtype() << " were provided which results"
+        << " in " << out_type << ", which is not a floating point type.";
+    throw std::invalid_argument(msg.str());
+  }
+  if (a.dtype() != out_type) {
+    a = astype(a, out_type, s);
+  }
+  if (b.dtype() != out_type) {
+    b = astype(b, out_type, s);
+  }
+
+  // We can batch the multiplication by reshaping a
+  if (in_a.ndim() > 2 && in_b.ndim() <= 2) {
+    a = flatten(a, 0, -2, s);
+  } else if (in_b.ndim() > 2) {
+    std::tie(a, b) = broadcast_arrays(a, b, {-2, -1}, s);
+  }
+
+  auto out_shape = a.shape();
+  out_shape.back() = b.shape(-1);
+
+  auto out = array(
+      std::move(out_shape),
+      out_type,
+      std::make_shared<Matmul>(to_stream(s)),
+      {a, b});
+  if (in_a.ndim() > 2 && in_b.ndim() <= 2) {
+    auto orig_shape = in_a.shape();
+    orig_shape.pop_back();
+    out = unflatten(out, 0, std::move(orig_shape), s);
+  }
+
+  // Remove the possibly inserted singleton dimensions
+  std::vector<int> axes;
+  if (in_a.ndim() == 1) {
+    axes.push_back(out.ndim() - 2);
+  }
+  if (in_b.ndim() == 1) {
+    axes.push_back(out.ndim() - 1);
+  }
+  return axes.empty() ? out : squeeze(out, axes, s);
+}
+
+array gather(
+    const array& a,
+    const std::vector<array>& indices,
+    const std::vector<int>& axes,
+    const Shape& slice_sizes,
+    StreamOrDevice s /* = {} */) {
+  // Checks that indices, dimensions, and slice_sizes are all valid
+  if (indices.size() > a.ndim()) {
+    std::ostringstream msg;
+    msg << "[gather] Too many index arrays. Got " << indices.size()
+        << " index arrays for input with " << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  std::set dims(axes.begin(), axes.end());
+  if (dims.size() != axes.size()) {
+    throw std::invalid_argument("[gather] Repeat axes not allowed in gather.");
+  }
+  if (!dims.empty() && (*dims.begin() < 0 || *dims.rbegin() >= a.ndim())) {
+    throw std::invalid_argument("[gather] Axes don't match array dimensions.");
+  }
+  if (indices.size() != axes.size()) {
+    throw std::invalid_argument(
+        "[gather] Number of index arrays does not match number of axes.");
+  }
+  for (auto& x : indices) {
+    if (x.dtype() == bool_) {
+      throw std::invalid_argument("[Gather] Boolean indices not supported.");
+    }
+  }
+
+  if (slice_sizes.size() != a.ndim()) {
+    std::ostringstream msg;
+    msg << "[gather] Got slice_sizes with size " << slice_sizes.size()
+        << " for array with " << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  // Promote indices to the same type
+  auto dtype = result_type(indices);
+  if (issubdtype(dtype, inexact)) {
+    throw std::invalid_argument(
+        "[gather] Got indices with invalid dtype. Indices must be integral.");
+  }
+
+  // Broadcast and cast indices if necessary
+  auto inputs = broadcast_arrays(indices);
+  for (auto& idx : inputs) {
+    idx = astype(idx, dtype, s);
+  }
+
+  if (a.size() == 0) {
+    // Empty input, either the total slice size is 0 or the indices are empty
+    auto total_slice = std::accumulate(
+        slice_sizes.begin(), slice_sizes.end(), 1, std::multiplies<int64_t>{});
+    auto idx_size = !inputs.empty() ? inputs[0].size() : 1;
+    if (idx_size != 0 && total_slice != 0) {
+      std::ostringstream msg;
+      msg << "[gather] If the input is empty, either the indices must be"
+          << " empty or the total slice size must be 0.";
+      throw std::invalid_argument(msg.str());
+    }
+  } else {
+    // Non-empty input, check slice sizes are valid
+    for (int i = 0; i < a.ndim(); ++i) {
+      if (slice_sizes[i] < 0 || slice_sizes[i] > a.shape(i)) {
+        std::ostringstream msg;
+        msg << "[gather] Slice sizes must be in [0, a.shape(i)]. Got "
+            << slice_sizes << " for array with shape " << a.shape() << ".";
+        throw std::invalid_argument(msg.str());
+      }
+    }
+  }
+
+  Shape out_shape;
+  if (!inputs.empty()) {
+    out_shape = inputs[0].shape();
+  }
+  out_shape.insert(out_shape.end(), slice_sizes.begin(), slice_sizes.end());
+
+  inputs.insert(inputs.begin(), a);
+  return array(
+      std::move(out_shape),
+      a.dtype(),
+      std::make_shared<Gather>(
+          to_stream(s), std::move(axes), std::move(slice_sizes)),
+      inputs);
+}
+
+array kron(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  if (a.size() == 0 || b.size() == 0) {
+    throw std::invalid_argument("[kron] Input arrays cannot be empty.");
+  }
+
+  int ndim = std::max(a.ndim(), b.ndim());
+  Shape a_shape(2 * ndim, 1);
+  Shape b_shape(2 * ndim, 1);
+  Shape out_shape(ndim, 1);
+
+  for (int i = ndim - 1, j = a.ndim() - 1; j >= 0; j--, i--) {
+    a_shape[2 * i] = a.shape(j);
+    out_shape[i] *= a.shape(j);
+  }
+  for (int i = ndim - 1, j = b.ndim() - 1; j >= 0; j--, i--) {
+    b_shape[2 * i + 1] = b.shape(j);
+    out_shape[i] *= b.shape(j);
+  }
+
+  return reshape(
+      multiply(
+          reshape(a, std::move(a_shape), s),
+          reshape(b, std::move(b_shape), s),
+          s),
+      std::move(out_shape),
+      s);
+}
+
+array take(
+    const array& a,
+    const array& indices,
+    int axis,
+    StreamOrDevice s /* = {} */) {
+  // Check for valid axis
+  if (axis + static_cast<int>(a.ndim()) < 0 ||
+      axis >= static_cast<int>(a.ndim())) {
+    std::ostringstream msg;
+    msg << "[take] Received invalid axis " << axis << " for array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Check for valid take
+  if (a.size() == 0 && indices.size() != 0) {
+    throw std::invalid_argument(
+        "[take] Cannot do a non-empty take from an array with zero elements.");
+  }
+
+  // Handle negative axis
+  axis = axis < 0 ? a.ndim() + axis : axis;
+
+  // Make slice sizes to pass to gather
+  Shape slice_sizes = a.shape();
+  slice_sizes[axis] = 1;
+
+  auto out = gather(a, indices, axis, slice_sizes, s);
+
+  // Transpose indices dimensions to axis dimension
+  if (axis != 0) {
+    std::vector<int> t_axes(out.ndim());
+    std::iota(t_axes.begin(), t_axes.begin() + axis, indices.ndim());
+    std::iota(t_axes.begin() + axis, t_axes.begin() + axis + indices.ndim(), 0);
+    std::iota(
+        t_axes.begin() + axis + indices.ndim(),
+        t_axes.end(),
+        indices.ndim() + axis);
+    out = transpose(out, t_axes, s);
+  }
+
+  // Squeeze the axis we take over
+  return squeeze(out, indices.ndim() + axis, s);
+}
+
+array take(const array& a, const array& indices, StreamOrDevice s /* = {} */) {
+  return take(flatten(a, s), indices, 0, s);
+}
+
+array take(const array& a, int index, int axis, StreamOrDevice s /* = {} */) {
+  // Check for valid axis
+  if (axis + static_cast<int>(a.ndim()) < 0 ||
+      axis >= static_cast<int>(a.ndim())) {
+    std::ostringstream msg;
+    msg << "[take] Received invalid axis " << axis << " for array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Check for valid take
+  if (a.size() == 0) {
+    throw std::invalid_argument(
+        "[take] Cannot do a non-empty take from an array with zero elements.");
+  }
+
+  // Handle negative axis
+  axis = axis < 0 ? a.ndim() + axis : axis;
+
+  Shape starts(a.ndim(), 0);
+  Shape stops = a.shape();
+  starts[axis] = index;
+  stops[axis] = index + 1;
+  return squeeze(slice(a, std::move(starts), std::move(stops), s), axis, s);
+}
+
+array take(const array& a, int index, StreamOrDevice s /* = {} */) {
+  return take(flatten(a, s), index, 0, s);
+}
+
+array take_along_axis(
+    const array& a,
+    const array& indices,
+    int axis,
+    StreamOrDevice s /* = {} */) {
+  if (axis + a.ndim() < 0 || axis >= static_cast<int>(a.ndim())) {
+    std::ostringstream msg;
+    msg << "[take_along_axis] Received invalid axis for array with " << a.ndim()
+        << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (indices.ndim() != a.ndim()) {
+    std::ostringstream msg;
+    msg << "[take_along_axis] Indices of dimension " << indices.ndim()
+        << " does not match array of dimension " << a.ndim() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Allow negative axis
+  axis = axis < 0 ? a.ndim() + axis : axis;
+
+  // Broadcast indices and input ignoring the take axis
+  auto inputs =
+      broadcast_arrays({a, indices}, std::vector<int>{axis - int(a.ndim())}, s);
+
+  auto out_shape = inputs[1].shape();
+  return array(
+      std::move(out_shape),
+      a.dtype(),
+      std::make_shared<GatherAxis>(to_stream(s), axis),
+      std::move(inputs));
+}
+
+array scatter_axis(
+    const array& a,
+    const array& indices,
+    const array& values,
+    int axis,
+    ScatterAxis::ReduceType mode,
+    StreamOrDevice s) {
+  std::string prefix =
+      (mode == ScatterAxis::None) ? "[put_along_axis]" : "[scatter_add_axis]";
+  if (axis + a.ndim() < 0 || axis >= static_cast<int>(a.ndim())) {
+    std::ostringstream msg;
+    msg << prefix << " Received invalid axis for array with " << a.ndim()
+        << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (indices.ndim() != a.ndim()) {
+    std::ostringstream msg;
+    msg << prefix << " Indices of dimension " << indices.ndim()
+        << " does not match array of dimension " << a.ndim() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (a.size() == 0) {
+    return a;
+  }
+
+  auto upd = astype(values, a.dtype(), s);
+
+  // Squeeze leading singletons out of update
+  if (upd.ndim() > indices.ndim()) {
+    std::vector<int> sq_ax(upd.ndim() - indices.ndim());
+    std::iota(sq_ax.begin(), sq_ax.end(), 0);
+    upd = squeeze(upd, sq_ax, s);
+  }
+
+  auto inputs = broadcast_arrays({indices, upd}, s);
+  inputs.insert(inputs.begin(), a);
+
+  // Allow negative axis
+  axis = axis < 0 ? a.ndim() + axis : axis;
+
+  // Broadcast src, indices, values while ignoring the take axis
+  inputs = broadcast_arrays(inputs, {axis - int(a.ndim())}, s);
+
+  auto out_shape = inputs[0].shape();
+  return array(
+      std::move(out_shape),
+      a.dtype(),
+      std::make_shared<ScatterAxis>(to_stream(s), mode, axis),
+      std::move(inputs));
+}
+
+array put_along_axis(
+    const array& a,
+    const array& indices,
+    const array& values,
+    int axis,
+    StreamOrDevice s /* = {} */) {
+  return scatter_axis(a, indices, values, axis, ScatterAxis::None, s);
+}
+
+array scatter_add_axis(
+    const array& a,
+    const array& indices,
+    const array& values,
+    int axis,
+    StreamOrDevice s /* = {} */) {
+  return scatter_axis(a, indices, values, axis, ScatterAxis::Sum, s);
+}
+
+/** Scatter updates to given indices */
+array scatter(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    Scatter::ReduceType mode,
+    StreamOrDevice s) {
+  // Checks that indices, dimensions, and slice_sizes are all valid
+  if (indices.size() > a.ndim()) {
+    std::ostringstream msg;
+    msg << "[scatter] Too many index arrays. Got " << indices.size()
+        << " index arrays for input with " << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  for (auto& x : indices) {
+    if (x.dtype() == bool_) {
+      throw("[scatter] Boolean indices not supported.");
+    }
+  }
+
+  std::set dims(axes.begin(), axes.end());
+  if (dims.size() != axes.size()) {
+    throw std::invalid_argument(
+        "[scatter] Repeat axes not allowed in scatter.");
+  }
+  if (!dims.empty() && (*dims.begin() < 0 || *dims.rbegin() >= a.ndim())) {
+    throw std::invalid_argument("[scatter] Axes don't match array dimensions.");
+  }
+  if (indices.size() != axes.size()) {
+    throw std::invalid_argument(
+        "[scatter] Number of index arrays does not match number of axes.");
+  }
+
+  // Broadcast and cast indices if necessary
+  auto inputs = broadcast_arrays(indices);
+
+  Shape idx_shape;
+  if (!inputs.empty()) {
+    idx_shape = inputs[0].shape();
+  }
+
+  if (updates.ndim() != (a.ndim() + idx_shape.size())) {
+    std::ostringstream msg;
+    msg << "[scatter] Updates with " << updates.ndim()
+        << " dimensions does not match the sum of the array (" << a.ndim()
+        << ") and indices (" << idx_shape.size() << ") dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  for (int i = 0; i < idx_shape.size(); ++i) {
+    if (updates.shape(i) != idx_shape[i]) {
+      std::ostringstream msg;
+      msg << "[scatter] Update shape " << updates.shape()
+          << " is not valid for broadcasted index shape " << idx_shape << ".";
+      throw std::invalid_argument(msg.str());
+    }
+  }
+  for (int i = 0; i < a.ndim(); ++i) {
+    auto up_shape = updates.shape(i + idx_shape.size());
+    if (up_shape > a.shape(i)) {
+      std::ostringstream msg;
+      msg << "[scatter] Updates with shape " << updates.shape()
+          << " are too large for array with shape " << a.shape() << ".";
+      throw std::invalid_argument(msg.str());
+    }
+  }
+
+  // Promote indices to the same type
+  auto dtype = result_type(indices);
+  if (issubdtype(dtype, inexact)) {
+    throw std::invalid_argument(
+        "[scatter] Got indices with invalid dtype. Indices must be integral.");
+  }
+  for (auto& idx : inputs) {
+    idx = astype(idx, dtype, s);
+  }
+
+  // TODO, remove when scatter supports 64-bit outputs
+  if (to_stream(s).device == Device::gpu && size_of(a.dtype()) == 8) {
+    std::ostringstream msg;
+    msg << "[scatter] GPU scatter does not yet support " << a.dtype()
+        << " for the input or updates.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  inputs.insert(inputs.begin(), a);
+  inputs.push_back(astype(updates, a.dtype(), s));
+
+  return array(
+      a.shape(),
+      a.dtype(),
+      std::make_shared<Scatter>(to_stream(s), mode, axes),
+      std::move(inputs));
+}
+
+array scatter(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s /*= {}*/) {
+  return scatter(a, indices, updates, axes, Scatter::None, s);
+}
+
+array scatter_add(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s /*= {}*/) {
+  return scatter(a, indices, updates, axes, Scatter::Sum, s);
+}
+
+array scatter_prod(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s /*= {}*/) {
+  return scatter(a, indices, updates, axes, Scatter::Prod, s);
+}
+
+array scatter_max(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s /*= {}*/) {
+  return scatter(a, indices, updates, axes, Scatter::Max, s);
+}
+
+array scatter_min(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s /*= {}*/) {
+  return scatter(a, indices, updates, axes, Scatter::Min, s);
+}
+
+array sqrt(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  return array(
+      a.shape(),
+      dtype,
+      std::make_shared<Sqrt>(to_stream(s)),
+      {astype(a, dtype, s)});
+}
+
+array rsqrt(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = at_least_float(a.dtype());
+  return array(
+      a.shape(),
+      dtype,
+      std::make_shared<Sqrt>(to_stream(s), true),
+      {astype(a, dtype, s)});
+}
+
+array softmax(
+    const array& a,
+    const std::vector<int>& axes,
+    bool precise /* = false */,
+    StreamOrDevice s /* = {}*/) {
+  if (a.size() == 0) {
+    return a;
+  }
+  if (a.ndim() == 0 && !axes.empty()) {
+    throw std::invalid_argument(
+        "[softmax] Received non-empty axes for array with 0 dimensions.");
+  }
+  bool reduce_last_dim =
+      !axes.empty() && (axes.back() == a.ndim() - 1 || axes.back() == -1);
+  if (reduce_last_dim) {
+    // For more than 2 axes check if axes is [0, 1, ..., NDIM - 1] and shape
+    // is [1, 1, ..., N].
+    for (int i = axes.size() - 2; i >= 0; --i) {
+      if ((axes[i] + 1 != axes[i + 1]) || (a.shape(axes[i]) != 1)) {
+        reduce_last_dim = false;
+        break;
+      }
+    }
+  }
+  bool is_complex = issubdtype(a.dtype(), complexfloating);
+  if (!is_complex && reduce_last_dim) {
+    auto dtype = at_least_float(a.dtype());
+    return array(
+        a.shape(),
+        dtype,
+        std::make_shared<Softmax>(to_stream(s), precise),
+        {astype(a, dtype, s)});
+  } else {
+    auto in = a;
+    if (precise && !is_complex) {
+      in = astype(a, float32, s);
+    }
+    auto a_max = stop_gradient(max(in, axes, /*keepdims = */ true, s), s);
+    auto ex = exp(subtract(in, a_max, s), s);
+    return astype(
+        divide(ex, sum(ex, axes, /*keepdims = */ true, s), s), a.dtype(), s);
+  }
+}
+
+array softmax(
+    const array& a,
+    bool precise /* = false */,
+    StreamOrDevice s /* = {}*/) {
+  std::vector<int> axes(a.ndim());
+  std::iota(axes.begin(), axes.end(), 0);
+  return softmax(a, axes, precise, s);
+}
+
+array power(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto dtype = promote_types(a.dtype(), b.dtype());
+  std::vector<array> inputs = {astype(a, dtype, s), astype(b, dtype, s)};
+  if (a.shape() != b.shape()) {
+    inputs = broadcast_arrays(inputs, s);
+  }
+  return array(
+      inputs[0].shape(), dtype, std::make_shared<Power>(to_stream(s)), inputs);
+}
+
+array cumsum(
+    const array& a,
+    int axis,
+    bool reverse /* = false*/,
+    bool inclusive /* = true*/,
+    StreamOrDevice s /* = {}*/) {
+  int ndim = a.ndim();
+  if (axis >= ndim || axis < -ndim) {
+    std::ostringstream msg;
+    msg << "[cumsum] Axis " << axis << " is out of bounds for array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  axis = (axis + a.ndim()) % a.ndim();
+  auto out_type = a.dtype() == bool_ ? int32 : a.dtype();
+  return array(
+      a.shape(),
+      out_type,
+      std::make_shared<Scan>(
+          to_stream(s), Scan::ReduceType::Sum, axis, reverse, inclusive),
+      {a});
+}
+
+array cumprod(
+    const array& a,
+    int axis,
+    bool reverse /* = false*/,
+    bool inclusive /* = true*/,
+    StreamOrDevice s /* = {}*/) {
+  int ndim = a.ndim();
+  if (axis >= ndim || axis < -ndim) {
+    std::ostringstream msg;
+    msg << "[cumprod] Axis " << axis << " is out of bounds for array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  axis = (axis + a.ndim()) % a.ndim();
+  return array(
+      a.shape(),
+      a.dtype(),
+      std::make_shared<Scan>(
+          to_stream(s), Scan::ReduceType::Prod, axis, reverse, inclusive),
+      {a});
+}
+
+array cummax(
+    const array& a,
+    int axis,
+    bool reverse /* = false*/,
+    bool inclusive /* = true*/,
+    StreamOrDevice s /* = {}*/) {
+  int ndim = a.ndim();
+  if (axis >= ndim || axis < -ndim) {
+    std::ostringstream msg;
+    msg << "[cummax] Axis " << axis << " is out of bounds for array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  axis = (axis + a.ndim()) % a.ndim();
+  return array(
+      a.shape(),
+      a.dtype(),
+      std::make_shared<Scan>(
+          to_stream(s), Scan::ReduceType::Max, axis, reverse, inclusive),
+      {a});
+}
+
+array cummin(
+    const array& a,
+    int axis,
+    bool reverse /* = false*/,
+    bool inclusive /* = true*/,
+    StreamOrDevice s /* = {}*/) {
+  int ndim = a.ndim();
+  if (axis >= ndim || axis < -ndim) {
+    std::ostringstream msg;
+    msg << "[cummin] Axis " << axis << " is out of bounds for array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  axis = (axis + a.ndim()) % a.ndim();
+  return array(
+      a.shape(),
+      a.dtype(),
+      std::make_shared<Scan>(
+          to_stream(s), Scan::ReduceType::Min, axis, reverse, inclusive),
+      {a});
+}
+
+array logcumsumexp(
+    const array& a,
+    int axis,
+    bool reverse /* = false*/,
+    bool inclusive /* = true*/,
+    StreamOrDevice s /* = {}*/) {
+  int ndim = a.ndim();
+  if (axis >= ndim || axis < -ndim) {
+    std::ostringstream msg;
+    msg << "[logcumsumexp] Axis " << axis << " is out of bounds for array with "
+        << a.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  axis = (axis + a.ndim()) % a.ndim();
+  return array(
+      a.shape(),
+      a.dtype(),
+      std::make_shared<Scan>(
+          to_stream(s), Scan::ReduceType::LogAddExp, axis, reverse, inclusive),
+      {a});
+}
+
+/** Convolution operations */
+
+namespace {
+
+inline void
+run_conv_checks(const array& in, const array& wt, int n_dim, int groups) {
+  if (!issubdtype(in.dtype(), floating)) {
+    std::ostringstream msg;
+    msg << "[conv] Invalid input array with type " << in.dtype() << "."
+        << " Convolution currently only supports floating point types";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (in.ndim() != n_dim + 2) {
+    std::ostringstream msg;
+    msg << "[conv] Invalid input array with " << in.ndim() << " dimensions for "
+        << n_dim << "D convolution. Expected an array with " << n_dim + 2
+        << " dimensions following the format [N, ..., C_in].";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (wt.ndim() != n_dim + 2) {
+    std::ostringstream msg;
+    msg << "[conv] Invalid weight array with " << wt.ndim()
+        << " dimensions for " << n_dim << "D convolution."
+        << " Expected an array with " << n_dim + 2
+        << " dimensions following the format [C_out, ..., C_in].";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (in.shape(n_dim + 1) % groups != 0) {
+    std::ostringstream msg;
+    msg << "[conv] The input channels must be divisible by the number"
+        << " of groups. Got input with shape " << in.shape() << " and "
+        << groups << " groups.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (groups > 1 && wt.shape(0) % groups != 0) {
+    std::ostringstream msg;
+    msg << "[conv] If groups > 1, the output channels must be divisible by the number"
+        << " of groups. Got " << wt.shape(0) << " output channels and "
+        << groups << " groups.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (in.shape(n_dim + 1) != (groups * wt.shape(n_dim + 1))) {
+    std::ostringstream msg;
+    if (groups == 1) {
+      msg << "[conv] Expect the input channels in the input"
+          << " and weight array to match but got shapes -"
+          << " input: " << in.shape() << " and weight: " << wt.shape();
+
+    } else {
+      msg << "Given groups=" << groups << " and weights of shape " << wt.shape()
+          << ", expected to have " << (groups * wt.shape(n_dim + 1))
+          << " input channels but got " << in.shape(n_dim + 1)
+          << " input channels instead.";
+    }
+    throw std::invalid_argument(msg.str());
+  }
+}
+
+} // namespace
+
+/** 1D convolution with a filter */
+array conv1d(
+    const array& in_,
+    const array& wt_,
+    int stride /* = 1 */,
+    int padding /* = 0 */,
+    int dilation /* = 1 */,
+    int groups /* = 1 */,
+    StreamOrDevice s /* = {} */) {
+  return conv_general(
+      /* const array& input = */ in_,
+      /* const array& weight = */ wt_,
+      /* std::vector<int> stride = */ {stride},
+      /* std::vector<int> padding = */ {padding},
+      /* std::vector<int> kernel_dilation = */ {dilation},
+      /* std::vector<int> input_dilation = */ {1},
+      /* int groups = */ groups,
+      /* bool flip = */ false,
+      s);
+}
+
+/** 2D convolution with a filter */
+array conv2d(
+    const array& in_,
+    const array& wt_,
+    const std::pair<int, int>& stride /* = {1, 1} */,
+    const std::pair<int, int>& padding /* = {0, 0} */,
+    const std::pair<int, int>& dilation /* = {1, 1} */,
+    int groups /* = 1 */,
+    StreamOrDevice s /* = {} */) {
+  return conv_general(
+      /* const array& input = */ in_,
+      /* const array& weight = */ wt_,
+      /* std::vector<int> stride = */ {stride.first, stride.second},
+      /* std::vector<int> padding = */ {padding.first, padding.second},
+      /* std::vector<int> kernel_dilation = */
+      {dilation.first, dilation.second},
+      /* std::vector<int> input_dilation = */ {1, 1},
+      /* int groups = */ groups,
+      /* bool flip = */ false,
+      s);
+}
+
+/** 3D convolution with a filter */
+array conv3d(
+    const array& in_,
+    const array& wt_,
+    const std::tuple<int, int, int>& stride /* = {1, 1, 1} */,
+    const std::tuple<int, int, int>& padding /* = {0, 0, 0} */,
+    const std::tuple<int, int, int>& dilation /* = {1, 1, 1} */,
+    int groups /* = 1 */,
+    StreamOrDevice s /* = {} */) {
+  return conv_general(
+      /* const array& input = */ in_,
+      /* const array& weight = */ wt_,
+      /* std::vector<int> stride = */
+      {std::get<0>(stride), std::get<1>(stride), std::get<2>(stride)},
+      /* std::vector<int> padding = */
+      {std::get<0>(padding), std::get<1>(padding), std::get<2>(padding)},
+      /* std::vector<int> kernel_dilation = */
+      {std::get<0>(dilation), std::get<1>(dilation), std::get<2>(dilation)},
+      /* std::vector<int> input_dilation = */ {1, 1, 1},
+      /* int groups = */ groups,
+      /* bool flip = */ false,
+      s);
+}
+
+// Helper function for transposed convolutions
+array conv_transpose_general(
+    const array& input,
+    const array& weight,
+    std::vector<int> stride,
+    std::vector<int> padding,
+    std::vector<int> dilation,
+    std::vector<int> output_padding,
+    int groups,
+    StreamOrDevice s) {
+  std::vector<int> padding_lo(padding.size());
+  std::vector<int> padding_hi(padding.size());
+  for (int i = 0; i < padding.size(); ++i) {
+    int wt_size = 1 + dilation[i] * (weight.shape(1 + i) - 1);
+    padding_lo[i] = wt_size - padding[i] - 1;
+
+    int conv_output_shape = (input.shape(i + 1) - 1) * stride[i] -
+        2 * padding[i] + dilation[i] * (weight.shape(i + 1) - 1) + 1;
+
+    int in_size = 1 + (conv_output_shape - 1);
+    int out_size = 1 + stride[i] * (input.shape(1 + i) - 1);
+    padding_hi[i] = in_size - out_size + padding[i] +
+        output_padding[i]; // Adjust with output_padding
+  }
+
+  return conv_general(
+      /* const array& input = */ input,
+      /* const array& weight = */ weight,
+      /* std::vector<int> stride = */ std::vector(stride.size(), 1),
+      /* std::vector<int> padding_lo = */ std::move(padding_lo),
+      /* std::vector<int> padding_hi = */ std::move(padding_hi),
+      /* std::vector<int> kernel_dilation = */ std::move(dilation),
+      /* std::vector<int> input_dilation = */ std::move(stride),
+      /* int groups = */ groups,
+      /* bool flip = */ true,
+      s);
+}
+
+/** 1D transposed convolution with a filter */
+array conv_transpose1d(
+    const array& in_,
+    const array& wt_,
+    int stride /* = 1 */,
+    int padding /* = 0 */,
+    int dilation /* = 1 */,
+    int output_padding /* = 0 */,
+    int groups /* = 1 */,
+    StreamOrDevice s /* = {} */) {
+  return conv_transpose_general(
+      in_, wt_, {stride}, {padding}, {dilation}, {output_padding}, groups, s);
+}
+
+/** 2D transposed convolution with a filter */
+array conv_transpose2d(
+    const array& in_,
+    const array& wt_,
+    const std::pair<int, int>& stride /* = {1, 1} */,
+    const std::pair<int, int>& padding /* = {0, 0} */,
+    const std::pair<int, int>& dilation /* = {1, 1} */,
+    const std::pair<int, int>& output_padding /* = {0, 0} */,
+    int groups /* = 1 */,
+    StreamOrDevice s /* = {} */) {
+  return conv_transpose_general(
+      in_,
+      wt_,
+      {stride.first, stride.second},
+      {padding.first, padding.second},
+      {dilation.first, dilation.second},
+      {output_padding.first, output_padding.second},
+      groups,
+      s);
+}
+
+/** 3D transposed convolution with a filter */
+array conv_transpose3d(
+    const array& in_,
+    const array& wt_,
+    const std::tuple<int, int, int>& stride /* = {1, 1, 1} */,
+    const std::tuple<int, int, int>& padding /* = {0, 0, 0} */,
+    const std::tuple<int, int, int>& dilation /* = {1, 1, 1} */,
+    const std::tuple<int, int, int>& output_padding /* = {0, 0, 0} */,
+    int groups /* = 1 */,
+    StreamOrDevice s /* = {} */) {
+  return conv_transpose_general(
+      in_,
+      wt_,
+      {std::get<0>(stride), std::get<1>(stride), std::get<2>(stride)},
+      {std::get<0>(padding), std::get<1>(padding), std::get<2>(padding)},
+      {std::get<0>(dilation), std::get<1>(dilation), std::get<2>(dilation)},
+      {std::get<0>(output_padding),
+       std::get<1>(output_padding),
+       std::get<2>(output_padding)},
+      groups,
+      s);
+}
+
+/** General convolution with a filter */
+array conv_general(
+    array in,
+    array wt,
+    std::vector<int> stride /* = {} */,
+    std::vector<int> padding_lo /* = {} */,
+    std::vector<int> padding_hi /* = {} */,
+    std::vector<int> kernel_dilation /* = {} */,
+    std::vector<int> input_dilation /* = {} */,
+    int groups /* = 1 */,
+    bool flip /* = false */,
+    StreamOrDevice s /* = {} */) {
+  // Run checks
+  if (groups != 1 && in.ndim() != 3 && in.ndim() != 4) {
+    throw std::invalid_argument(
+        "[conv] Can only handle groups != 1 in 1D or 2D convolutions.");
+  }
+
+  int spatial_dims = in.ndim() - 2;
+
+  if (spatial_dims < 1 || spatial_dims > 3) {
+    throw std::invalid_argument(
+        "[conv] Only works for inputs with 1-3 spatial dimensions."
+        " The inputs must be in the format [N, ..., C_in]");
+  }
+
+  // Run checks
+  run_conv_checks(in, wt, spatial_dims, groups);
+
+  // Type promotion
+  auto out_type = promote_types(in.dtype(), wt.dtype());
+  in = astype(in, out_type, s);
+  wt = astype(wt, out_type, s);
+
+  if (stride.size() <= 1) {
+    int stride_int = stride.size() ? stride[0] : 1;
+    stride = std::vector<int>(spatial_dims, stride_int);
+  }
+
+  if (padding_lo.size() <= 1) {
+    int padding_int = padding_lo.size() ? padding_lo[0] : 0;
+    padding_lo = std::vector<int>(spatial_dims, padding_int);
+  }
+
+  if (padding_hi.size() <= 1) {
+    int padding_int = padding_hi.size() ? padding_hi[0] : 0;
+    padding_hi = std::vector<int>(spatial_dims, padding_int);
+  }
+
+  if (kernel_dilation.size() <= 1) {
+    int kernel_dilation_int = kernel_dilation.size() ? kernel_dilation[0] : 1;
+    kernel_dilation = std::vector<int>(spatial_dims, kernel_dilation_int);
+  }
+
+  if (input_dilation.size() <= 1) {
+    int input_dilation_int = input_dilation.size() ? input_dilation[0] : 1;
+    input_dilation = std::vector<int>(spatial_dims, input_dilation_int);
+  }
+
+  // Check for negative padding
+  bool has_neg_padding = false;
+  for (auto& pd : padding_lo) {
+    has_neg_padding |= (pd < 0);
+  }
+  for (auto& pd : padding_hi) {
+    has_neg_padding |= (pd < 0);
+  }
+
+  // Handle negative padding
+  if (has_neg_padding) {
+    Shape starts(in.ndim(), 0);
+    auto stops = in.shape();
+
+    for (int i = 0; i < spatial_dims; i++) {
+      if (padding_lo[i] < 0) {
+        starts[i + 1] -= padding_lo[i];
+        padding_lo[i] = 0;
+      }
+
+      if (padding_hi[i] < 0) {
+        stops[i + 1] += padding_hi[i];
+        padding_hi[i] = 0;
+      }
+    }
+
+    in = slice(in, std::move(starts), std::move(stops), s);
+  }
+
+  // Get output shapes
+  auto out_shape = Convolution::conv_out_shape(
+      in.shape(),
+      wt.shape(),
+      stride,
+      padding_lo,
+      padding_hi,
+      kernel_dilation,
+      input_dilation);
+
+  return array(
+      std::move(out_shape),
+      in.dtype(),
+      std::make_shared<Convolution>(
+          to_stream(s),
+          stride,
+          padding_lo,
+          padding_hi,
+          kernel_dilation,
+          input_dilation,
+          groups,
+          flip),
+      {in, wt});
+}
+
+void validate_mode(std::string_view tag, const std::string& mode) {
+  if (mode != "affine" && mode != "mxfp4") {
+    std::ostringstream msg;
+    msg << "[" << tag << "] Invalid quantization mode '" << mode << "'.";
+    throw std::invalid_argument(msg.str());
+  }
+}
+
+Dtype validate_mode_with_type(
+    std::string_view tag,
+    const array& scales,
+    const std::optional<array>& biases,
+    const std::string& mode) {
+  validate_mode(tag, mode);
+  if (mode == "affine") {
+    if (!biases) {
+      std::ostringstream msg;
+      msg << "[" << tag << "] Biases must be provided for affine quantization.";
+      throw std::invalid_argument(msg.str());
+    }
+    auto dtype = result_type(scales, *biases);
+    if (!issubdtype(dtype, floating)) {
+      std::ostringstream msg;
+      msg << "[" << tag << "] Only real floating types are supported but "
+          << "scales.dtype() == " << scales.dtype()
+          << " and biases.dtype() == " << biases->dtype() << ".";
+      throw std::invalid_argument(msg.str());
+    }
+    return dtype;
+  }
+  if (biases) {
+    std::ostringstream msg;
+    msg << "[" << tag << "] Biases must be null for quantization mode '" << mode
+        << "'.";
+    throw std::invalid_argument(msg.str());
+  }
+  return bfloat16;
+}
+
+array quantized_matmul(
+    array x,
+    array w,
+    array scales,
+    std::optional<array> biases /* = std::nullopt */,
+    bool transpose /* = true */,
+    int group_size /* = 64 */,
+    int bits /* = 4 */,
+    const std::string& mode /* = "affine" */,
+    StreamOrDevice s /* = {} */) {
+  // Check and extract the quantized matrix shape against x
+  auto [w_inner_dims, w_outer_dims] = extract_quantized_matmul_dims(
+      "quantized_matmul", x, w, scales, biases, transpose, group_size, bits);
+
+  auto dtype =
+      validate_mode_with_type("quantized_matmul", scales, biases, mode);
+  dtype = promote_types(x.dtype(), dtype);
+
+  if (!issubdtype(dtype, floating)) {
+    std::ostringstream msg;
+    msg << "[quantized_matmul] Only real floating types are supported but "
+        << "x.dtype() == " << x.dtype() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  std::vector<array> inputs;
+  if (mode == "affine") {
+    inputs = {
+        astype(x, dtype), w, astype(scales, dtype), astype(*biases, dtype)};
+  } else {
+    inputs = {x, w, scales};
+  }
+
+  if (x.ndim() > 2 && w.ndim() > 2) {
+    inputs = broadcast_arrays(inputs, {-2, -1}, s);
+  }
+
+  auto out_shape = inputs[0].shape();
+  out_shape.back() = w_outer_dims;
+  return array(
+      std::move(out_shape),
+      dtype,
+      std::make_shared<QuantizedMatmul>(
+          to_stream(s),
+          group_size,
+          bits,
+          string_to_quantization_mode(mode),
+          transpose),
+      std::move(inputs));
+}
+
+array pack_and_quantize(
+    array& packed_w,
+    const array& scales,
+    const array& biases,
+    int bits,
+    const Stream& s) {
+  int el_per_int = 32 / bits;
+  array zero(0, packed_w.dtype());
+  array n_bins((1 << bits) - 1, packed_w.dtype()); // 2**bits - 1
+  packed_w = astype(
+      clip(
+          round(divide(subtract(packed_w, biases, s), scales, s), s),
+          zero,
+          n_bins,
+          s),
+      uint32,
+      s);
+  if (is_power_of_2(bits)) {
+    array shifts = power(array(2, uint32), arange(0, 32, bits, uint32, s), s);
+    packed_w = reshape(packed_w, {packed_w.shape(0), -1, el_per_int}, s);
+    packed_w = sum(
+        multiply(packed_w, shifts, s), /* axis= */ 2, /* keepdims= */ false, s);
+  } else {
+    // This is slow but we have fast GPU/CPU versions of this function so we
+    // shouldn't be here often.
+    packed_w = expand_dims(packed_w, /* axis= */ -1, s);
+    packed_w = bitwise_and(
+        right_shift(packed_w, arange(bits, uint32, s), s),
+        array({1}, uint32),
+        s);
+    auto new_shape = packed_w.shape();
+    new_shape[new_shape.size() - 2] = -1;
+    new_shape.back() = 32;
+    packed_w = reshape(packed_w, new_shape, s);
+    array shifts = arange(32, uint32, s);
+    packed_w =
+        sum(left_shift(packed_w, shifts, s),
+            /* axis= */ -1,
+            /* keepdims= */ false,
+            s);
+  }
+  return packed_w;
+}
+
+std::vector<array>
+affine_quantize(const array& w, int group_size, int bits, StreamOrDevice s_) {
+  auto s = to_stream(s_);
+  if (group_size != 32 && group_size != 64 && group_size != 128) {
+    std::ostringstream msg;
+    msg << "[quantize] The requested group size " << group_size
+        << " is not supported. The supported group sizes are 32, 64, and 128.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (bits < 2 || bits > 8 || bits == 7) {
+    std::ostringstream msg;
+    msg << "[quantize] The requested number of bits " << bits
+        << " is not supported. The supported bits are 2, 3, 4, 5, 6 and 8.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto fallback = [group_size, bits, s](
+                      const std::vector<array>& inputs) -> std::vector<array> {
+    auto& w = inputs[0];
+    auto wshape = w.shape();
+    wshape.back() = -1;
+
+    array zero(0, float32);
+    array n_bins((1 << bits) - 1, float32); // 2**bits - 1
+    array eps(1e-7, float32);
+
+    array packed_w = reshape(w, {-1, w.shape(-1) / group_size, group_size}, s);
+
+    array w_max = max(packed_w, /* axis= */ -1, /* keepdims= */ true, s);
+    array w_min = min(packed_w, /* axis= */ -1, /* keepdims= */ true, s);
+    w_max = astype(w_max, float32, s);
+    w_min = astype(w_min, float32, s);
+
+    array mask = greater(abs(w_min, s), abs(w_max, s), s);
+    array scales =
+        maximum(divide(subtract(w_max, w_min, s), n_bins, s), eps, s);
+    scales = where(mask, scales, negative(scales, s), s);
+    array edge = where(mask, w_min, w_max, s);
+    array q0 = round(divide(edge, scales, s), s);
+    scales = where(not_equal(q0, zero, s), divide(edge, q0, s), scales);
+    array biases = where(equal(q0, zero, s), zero, edge, s);
+
+    packed_w = pack_and_quantize(packed_w, scales, biases, bits, s);
+
+    scales = astype(scales, w.dtype(), s);
+    biases = astype(biases, w.dtype(), s);
+    return {
+        reshape(packed_w, wshape, s),
+        reshape(scales, wshape, s),
+        reshape(biases, wshape, s),
+    };
+  };
+
+  auto wq_shape = w.shape();
+  wq_shape.back() = w.shape(-1) * bits / 32;
+  auto sshape = w.shape();
+  sshape.back() = w.shape(-1) / group_size;
+  return array::make_arrays(
+      {std::move(wq_shape), sshape, sshape},
+      {uint32, w.dtype(), w.dtype()},
+      std::make_shared<fast::Quantize>(
+          s, fallback, group_size, bits, QuantizationMode::Affine, false),
+      {w});
+}
+
+std::vector<array> quantize(
+    const array& w,
+    int group_size /* = 64 */,
+    int bits /* = 4 */,
+    const std::string& mode /* = "affine" */,
+    StreamOrDevice s /* = {} */) {
+  validate_mode("quantize", mode);
+  if (!issubdtype(w.dtype(), floating)) {
+    std::ostringstream msg;
+    msg << "[quantize] Only real floating types can be quantized "
+        << "but w has type " << w.dtype() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (w.ndim() < 2) {
+    std::ostringstream msg;
+    msg << "[quantize] The matrix to be quantized must have at least 2 dimension "
+        << "but it has only " << w.ndim() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if ((w.shape(-1) % group_size) != 0) {
+    std::ostringstream msg;
+    msg << "[quantize] The last dimension of the matrix needs to be divisible by "
+        << "the quantization group size " << group_size
+        << ". However the provided "
+        << " matrix has shape " << w.shape();
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (mode == "affine") {
+    return affine_quantize(w, group_size, bits, s);
+  } else {
+    if (group_size != 32) {
+      std::ostringstream msg;
+      msg << "[quantize] mxfp4 quantization requires group size 32 "
+          << "but got " << group_size << ".";
+      throw std::invalid_argument(msg.str());
+    }
+    if (bits != 4) {
+      std::ostringstream msg;
+      msg << "[quantize] mxfp4 quantization requires bits to be 4 "
+          << "but got " << bits << ".";
+      throw std::invalid_argument(msg.str());
+    }
+
+    auto lut = array({
+        +0.0f,
+        +0.5f,
+        +1.0f,
+        +1.5f,
+        +2.0f,
+        +3.0f,
+        +4.0f,
+        +6.0f,
+        -0.0f,
+        -0.5f,
+        -1.0f,
+        -1.5f,
+        -2.0f,
+        -3.0f,
+        -4.0f,
+        -6.0f,
+    });
+    lut = astype(lut, w.dtype(), s);
+
+    auto new_shape = w.shape();
+    new_shape.back() = -1;
+    auto wq = reshape(w, {-1, group_size}, s);
+    auto scales =
+        divide(max(abs(wq, s), -1, true, s), array(6.0f, w.dtype()), s);
+    scales = astype(log2(scales, s), int32, s);
+    wq = divide(wq, power(array(2.0f, w.dtype()), scales, s), s);
+    scales = astype(add(scales, array(127, int32), s), uint8, s);
+    wq = argmin(abs(subtract(expand_dims(wq, -1, s), lut, s), s), -1, false, s);
+    auto shifts = power(array(2, uint32), arange(0, 32, 4, uint32, s), s);
+    wq = reshape(wq, {-1, group_size / 8, 8}, s);
+    wq = sum(multiply(wq, shifts, s), -1, false, s);
+    wq = reshape(wq, new_shape, s);
+    scales = reshape(scales, new_shape, s);
+    return {std::move(wq), std::move(scales)};
+  }
+}
+
+array affine_dequantize(
+    const array& w,
+    const array& scales,
+    const array& biases,
+    int group_size,
+    int bits,
+    StreamOrDevice s_) {
+  if (w.ndim() < 2 || scales.ndim() < 2 || biases.ndim() < 2) {
+    std::ostringstream msg;
+    msg << "[quantize] The matrix to be quantized must have at least 2 dimension "
+        << "but it has only " << w.ndim() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto wshape = w.shape();
+  auto sshape = scales.shape();
+  auto bshape = biases.shape();
+  wshape.back() = -1;
+  sshape.back() = -1;
+  bshape.back() = -1;
+
+  if (wshape != sshape || wshape != bshape) {
+    throw std::invalid_argument(
+        "[dequantize] Shape of scales and biases does not match the matrix");
+  }
+
+  // Packing into uint32
+  int out_size = w.shape(-1) * 32 / bits;
+
+  if (out_size != scales.shape(-1) * group_size) {
+    std::ostringstream msg;
+    msg << "[dequantize] Shape of scales and biases does not match the matrix "
+        << "given the quantization parameters. Provided matrix of shape "
+        << w.shape() << " and scales/biases of shape " << scales.shape()
+        << " with group_size=" << group_size << " and bits=" << bits << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto s = to_stream(s_);
+
+  auto fallback =
+      [wshape = std::move(wshape),
+       sshape = std::move(sshape),
+       group_size,
+       bits,
+       s](const std::vector<array>& inputs) mutable -> std::vector<array> {
+    auto w = inputs[0];
+    auto& scales = inputs[1];
+    auto& biases = inputs[2];
+    if (is_power_of_2(bits)) {
+      std::vector<array> parts;
+      for (int start = 0; start < 32; start += bits) {
+        int shift_left = 32 - (start + bits);
+        int shift_right = shift_left + start;
+
+        parts.push_back(expand_dims(
+            right_shift(
+                left_shift(w, array(32 - (start + bits), uint32), s),
+                array(32 - bits, uint32),
+                s),
+            -1,
+            s));
+      }
+      w = concatenate(parts, -1, s);
+    } else {
+      w = expand_dims(w, /* axis= */ -1, s);
+      w = bitwise_and(
+          right_shift(w, arange(32, uint32, s), s), array({1}, uint32), s);
+      auto new_shape = w.shape();
+      new_shape[new_shape.size() - 2] = -1;
+      new_shape.back() = bits;
+      w = reshape(w, new_shape, s);
+      array shifts = arange(bits, uint32, s);
+      w = sum(
+          left_shift(w, shifts, s), /* axis= */ -1, /* keepdims= */ false, s);
+    }
+
+    // Dequantize
+    wshape.push_back(group_size);
+    w = reshape(w, wshape, s);
+    w = multiply(w, expand_dims(scales, -1, s), s);
+    w = add(w, expand_dims(biases, -1, s), s);
+    w = reshape(w, sshape, s);
+
+    return {w};
+  };
+
+  if (s.device == Device::gpu) {
+    auto out_shape = w.shape();
+    out_shape.back() = out_size;
+    return array(
+        std::move(out_shape),
+        scales.dtype(),
+        std::make_shared<fast::Quantize>(
+            s, fallback, group_size, bits, QuantizationMode::Affine, true),
+        {w, scales, biases});
+  }
+  return fallback({w, scales, biases})[0];
+}
+
+array dequantize(
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases /* = std::nullopt */,
+    int group_size /* = 64 */,
+    int bits /* = 4 */,
+    const std::string& mode /* = "affine" */,
+    StreamOrDevice s /* = {} */) {
+  validate_mode_with_type("dequantize", scales, biases, mode);
+  if (bits <= 0) {
+    std::ostringstream msg;
+    msg << "[dequantize] Invalid value for bits: " << bits;
+    throw std::invalid_argument(msg.str());
+  }
+  if (group_size <= 0) {
+    std::ostringstream msg;
+    msg << "[dequantize] Invalid value for group_size: " << group_size;
+    throw std::invalid_argument(msg.str());
+  }
+  if (w.dtype() != uint32) {
+    throw std::invalid_argument(
+        "[dequantize] The matrix should be given as a uint32");
+  }
+
+  if (mode == "affine") {
+    return affine_dequantize(w, scales, *biases, group_size, bits, s);
+  } else {
+    if (group_size != 32) {
+      std::ostringstream msg;
+      msg << "[dequantize] mxfp4 quantization requires group size 32 "
+          << "but got " << group_size << ".";
+      throw std::invalid_argument(msg.str());
+    }
+    if (bits != 4) {
+      std::ostringstream msg;
+      msg << "[dequantize] mxfp4 quantization requires bits to be 4 "
+          << "but got " << bits << ".";
+      throw std::invalid_argument(msg.str());
+    }
+
+    if (w.ndim() < 2 || scales.ndim() < 2) {
+      std::ostringstream msg;
+      msg << "[quantize] The matrix to be quantized must have at least 2 dimension "
+          << "but it has only " << w.ndim() << ".";
+      throw std::invalid_argument(msg.str());
+    }
+
+    auto wshape = w.shape();
+    auto sshape = scales.shape();
+    wshape.back() = -1;
+    sshape.back() = -1;
+
+    if (wshape != sshape) {
+      throw std::invalid_argument(
+          "[dequantize] Shape of scales does not match the matrix");
+    }
+
+    if (w.dtype() != uint32) {
+      throw std::invalid_argument(
+          "[dequantize] The matrix should be given as a uint32");
+    }
+
+    // Packing into uint32
+    int out_size = w.shape(-1) * 32 / bits;
+
+    if (out_size != scales.shape(-1) * group_size) {
+      std::ostringstream msg;
+      msg << "[dequantize] Shape of scales does not match the matrix "
+          << "given the quantization parameters. Provided matrix of shape "
+          << w.shape() << " and scales of shape " << scales.shape() << ".";
+      throw std::invalid_argument(msg.str());
+    }
+
+    auto dtype = bfloat16;
+    auto lut = array(
+        {
+            +0.0f,
+            +0.5f,
+            +1.0f,
+            +1.5f,
+            +2.0f,
+            +3.0f,
+            +4.0f,
+            +6.0f,
+            -0.0f,
+            -0.5f,
+            -1.0f,
+            -1.5f,
+            -2.0f,
+            -3.0f,
+            -4.0f,
+            -6.0f,
+        },
+        dtype);
+
+    auto what = view(reshape(w, {-1, group_size / 8}, s), int8, s);
+
+    auto idx_lo = bitwise_and(what, array(0x0F, int8), s);
+    auto idx_hi = right_shift(what, array(4, int8), s);
+    auto lo = gather(lut, idx_lo, 0, {1}, s);
+    auto hi = gather(lut, idx_hi, 0, {1}, s);
+    what = flatten(concatenate({lo, hi}, -1, s), -2, -1, s);
+    auto exponent = subtract(astype(scales, dtype, s), array(127, dtype), s);
+    exponent = reshape(exponent, {-1, 1}, s);
+    return reshape(
+        multiply(power(array(2.0f, dtype), exponent, s), what, s), wshape, s);
+  }
+}
+
+array gather_qmm(
+    const array& x,
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases /* = std::nullopt */,
+    std::optional<array> lhs_indices_ /* = std::nullopt */,
+    std::optional<array> rhs_indices_ /* = std::nullopt */,
+    bool transpose /* = true */,
+    int group_size /* = 64 */,
+    int bits /* = 4 */,
+    const std::string& mode /* = "affine" */,
+    bool sorted_indices /* = false */,
+    StreamOrDevice s /* = {} */) {
+  if (!lhs_indices_ && !rhs_indices_) {
+    return quantized_matmul(
+        x, w, scales, biases, transpose, group_size, bits, mode, s);
+  }
+
+  auto [w_inner_dims, w_outer_dims] = extract_quantized_matmul_dims(
+      "gather_qmm", x, w, scales, biases, transpose, group_size, bits);
+
+  auto out_type = validate_mode_with_type("gather_qmm", scales, biases, mode);
+  out_type = promote_types(x.dtype(), out_type);
+
+  if (!issubdtype(out_type, floating)) {
+    std::ostringstream msg;
+    msg << "[gather_qmm] Only real floating types are supported but "
+        << "x.dtype() == " << x.dtype() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Extract indices and broadcast them
+  array lhs_indices = indices_or_default(lhs_indices_, x, s);
+  array rhs_indices = indices_or_default(rhs_indices_, w, s);
+  std::tie(lhs_indices, rhs_indices) =
+      broadcast_arrays(lhs_indices, rhs_indices, s);
+
+  if (!issubdtype(lhs_indices.dtype(), integer)) {
+    throw std::invalid_argument(
+        "[gather_qmm] Got lhs_indices with invalid dtype. Indices must be integral.");
+  }
+
+  if (!issubdtype(rhs_indices.dtype(), integer)) {
+    throw std::invalid_argument(
+        "[gather_qmm] Got rhs_indices with invalid dtype. Indices must be integral.");
+  }
+  if (x.ndim() < 2) {
+    std::ostringstream msg;
+    msg << "[gather_qmm] Non-quantized input must have at least two"
+        << " dimensions but got input with shape " << x.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  lhs_indices = astype(lhs_indices, uint32, s);
+  rhs_indices = astype(rhs_indices, uint32, s);
+
+  // Compute the full output shape
+  auto out_shape = lhs_indices.shape();
+  out_shape.push_back(x.shape(-2));
+  out_shape.push_back(w_outer_dims);
+  std::vector<array> inputs;
+  if (mode == "affine") {
+    inputs = {
+        astype(x, out_type, s),
+        std::move(w),
+        astype(scales, out_type, s),
+        astype(*biases, out_type, s),
+        std::move(lhs_indices),
+        std::move(rhs_indices)};
+  } else {
+    inputs = {
+        astype(x, out_type, s),
+        std::move(w),
+        std::move(scales),
+        std::move(lhs_indices),
+        std::move(rhs_indices)};
+  }
+  return array(
+      std::move(out_shape),
+      out_type,
+      std::make_shared<GatherQMM>(
+          to_stream(s),
+          group_size,
+          bits,
+          string_to_quantization_mode(mode),
+          transpose,
+          sorted_indices && !rhs_indices_,
+          sorted_indices && !lhs_indices_),
+      std::move(inputs));
+}
+
+array tensordot(
+    const array& a,
+    const array& b,
+    const int axis /* = 2 */,
+    StreamOrDevice s /* = {} */
+) {
+  if (axis < 0) {
+    throw std::invalid_argument(
+        "[tensordot] axis must be greater or equal to 0.");
+  }
+  if (axis > std::min(a.ndim(), b.ndim())) {
+    throw std::invalid_argument(
+        "[tensordot] axis must be less than the number of dimensions of a and b.");
+  }
+  std::vector<int> adims;
+  std::vector<int> bdims;
+  for (int i = 0; i < axis; i++) {
+    bdims.emplace_back(i);
+    adims.emplace_back(i - axis);
+  }
+  return tensordot(a, b, {adims}, {bdims}, s);
+}
+
+array tensordot(
+    const array& a,
+    const array& b,
+    const std::vector<int>& axes_a,
+    const std::vector<int>& axes_b,
+    StreamOrDevice s /* = {} */) {
+  if (axes_a.size() != axes_b.size()) {
+    throw std::invalid_argument("[tensordot] axes must have the same size.");
+  }
+  int csize = 1;
+  auto x = a;
+  auto y = b;
+  for (int i = 0; i < axes_a.size(); i++) {
+    if (x.shape(axes_a.at(i)) == y.shape(axes_b.at(i))) {
+      csize *= x.shape(axes_a.at(i));
+    } else {
+      throw std::invalid_argument(
+          "[tensordot] a and b must have the same shape on the contracted axes.");
+    }
+  }
+
+  std::vector<bool> cdims1(x.ndim(), false);
+  std::vector<bool> cdims2(y.ndim(), false);
+  for (const auto n : axes_a) {
+    int n_ = (n < 0) ? n + x.ndim() : n;
+    cdims1[n_] = true;
+  }
+  for (const auto n : axes_b) {
+    int n_ = (n < 0) ? n + y.ndim() : n;
+    cdims2[n_] = true;
+  }
+
+  std::vector<int> t1;
+  std::vector<int> t2;
+  Shape rshape;
+  int size1 = 1;
+  int size2 = 1;
+  for (int i = 0; i < a.ndim(); i++) {
+    if (!cdims1[i]) {
+      t1.emplace_back(i);
+      size1 *= a.shape(i);
+      rshape.emplace_back(a.shape(i));
+    }
+  }
+  for (const auto x : axes_a) {
+    t1.emplace_back(x);
+  }
+  for (const auto x : axes_b) {
+    t2.emplace_back(x);
+  }
+  for (int i = 0; i < b.ndim(); i++) {
+    if (!cdims2[i]) {
+      t2.emplace_back(i);
+      size2 *= b.shape(i);
+      rshape.emplace_back(b.shape(i));
+    }
+  }
+  x = reshape(transpose(x, t1, s), {size1, csize}, s);
+  y = reshape(transpose(y, t2, s), {csize, size2}, s);
+  return reshape(matmul(x, y, s), rshape, s);
+}
+
+array outer(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  return multiply(
+      reshape(a, {static_cast<int>(a.size()), 1}, s), flatten(b, s), s);
+}
+
+array inner(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  if (a.ndim() == 0 || b.ndim() == 0) {
+    return multiply(a, b, s);
+  }
+  if (a.shape(-1) != b.shape(-1)) {
+    throw std::invalid_argument(
+        "[inner] a and b must have the same last dimension.");
+  }
+
+  return tensordot(a, b, {-1}, {-1}, s);
+}
+
+/** Compute D = beta * C + alpha * (A @ B) */
+array addmm(
+    array c,
+    array a,
+    array b,
+    const float& alpha /* = 1.f */,
+    const float& beta /* = 1.f */,
+    StreamOrDevice s /* = {} */) {
+  int in_a_ndim = a.ndim();
+  int in_b_ndim = b.ndim();
+
+  if (a.ndim() == 0 || b.ndim() == 0) {
+    throw std::invalid_argument(
+        "[addmm] Got 0 dimension input. Inputs must "
+        "have at least one dimension.");
+  }
+
+  // Type promotion
+  auto out_type = result_type(a, b, c);
+
+  if (out_type == complex64) {
+    return add(
+        multiply(matmul(a, b, s), array(alpha), s),
+        multiply(array(beta), c, s),
+        s);
+  }
+
+  if (a.ndim() == 1) {
+    // Insert a singleton dim in the beginning
+    a = expand_dims(a, 0, s);
+  }
+  if (b.ndim() == 1) {
+    // Insert a singleton dim at the end
+    b = expand_dims(b, 1, s);
+  }
+
+  if (a.shape(-1) != b.shape(-2)) {
+    std::ostringstream msg;
+    msg << "[addmm] Last dimension of first input with shape " << a.shape()
+        << " must match second to last dimension of"
+        << " second input with shape " << b.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (!issubdtype(out_type, floating)) {
+    std::ostringstream msg;
+    msg << "[addmm] Only real floating point types are supported but "
+        << c.dtype() << ", " << a.dtype() << " and " << b.dtype()
+        << " were provided which results in " << out_type
+        << ", which is not a real floating point type.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  a = astype(a, out_type, s);
+  b = astype(b, out_type, s);
+  c = astype(c, out_type, s);
+
+  // We can batch the multiplication by reshaping a
+  if (a.ndim() > 2 && b.ndim() == 2 && c.ndim() <= 1) {
+    auto out_shape = a.shape();
+    a = reshape(a, {-1, out_shape.back()}, s);
+    out_shape.back() = b.shape(-1);
+
+    if (in_b_ndim == 1) {
+      out_shape.pop_back();
+    }
+
+    c = broadcast_to(c, {a.shape(0), b.shape(1)}, s);
+
+    auto out = array(
+        {a.shape(0), b.shape(1)},
+        out_type,
+        std::make_shared<AddMM>(to_stream(s), alpha, beta),
+        {a, b, c});
+    return reshape(out, out_shape, s);
+  }
+
+  if (a.ndim() > 2 || b.ndim() > 2) {
+    Shape bsx_a(a.shape().begin(), a.shape().end() - 2);
+    Shape bsx_b(b.shape().begin(), b.shape().end() - 2);
+    auto inner_shape = broadcast_shapes(bsx_a, bsx_b);
+
+    // Broadcast a
+    inner_shape.push_back(a.shape(-2));
+    inner_shape.push_back(a.shape(-1));
+    a = broadcast_to(a, inner_shape, s);
+
+    // Broadcast b
+    *(inner_shape.end() - 2) = b.shape(-2);
+    *(inner_shape.end() - 1) = b.shape(-1);
+    b = broadcast_to(b, inner_shape, s);
+  }
+
+  auto out_shape = a.shape();
+  out_shape.back() = b.shape(-1);
+
+  auto out_shape_adjusted = out_shape;
+
+  if (in_a_ndim == 1 || in_b_ndim == 1) {
+    out_shape_adjusted.erase(
+        out_shape_adjusted.end() - ((in_a_ndim == 1) ? 2 : 1),
+        out_shape_adjusted.end() - ((in_b_ndim == 1) ? 0 : 1));
+  }
+
+  auto c_broadcast_shape = broadcast_shapes(c.shape(), out_shape_adjusted);
+  c = broadcast_to(c, c_broadcast_shape, s);
+
+  if (in_a_ndim == 1 || in_b_ndim == 1) {
+    auto c_reshape = c.shape();
+    if (in_b_ndim == 1) {
+      c_reshape.push_back(1);
+    }
+
+    if (in_a_ndim == 1) {
+      c_reshape.push_back(c_reshape.back());
+      c_reshape[c_reshape.size() - 2] = 1;
+    }
+
+    c = reshape(c, c_reshape, s);
+  }
+  if (c.shape() != out_shape) {
+    throw std::invalid_argument(
+        "[addmm] input c must broadcast to the output shape");
+  }
+
+  auto out = array(
+      std::move(out_shape),
+      out_type,
+      std::make_shared<AddMM>(to_stream(s), alpha, beta),
+      {a, b, c});
+
+  // Remove the possibly inserted singleton dimensions
+  std::vector<int> axes;
+  if (in_a_ndim == 1) {
+    axes.push_back(out.ndim() - 2);
+  }
+  if (in_b_ndim == 1) {
+    axes.push_back(out.ndim() - 1);
+  }
+  return axes.empty() ? out : squeeze(out, axes, s);
+}
+
+/** Compute matrix product with tile-level masking */
+array block_masked_mm(
+    array a,
+    array b,
+    int block_size,
+    std::optional<array> mask_out /* = std::nullopt */,
+    std::optional<array> mask_lhs /* = std::nullopt */,
+    std::optional<array> mask_rhs /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  // If no masks, just perform regular matmul
+  if (!mask_out && !mask_lhs && !mask_rhs) {
+    return matmul(a, b, s);
+  }
+
+  bool has_out_mask = mask_out.has_value();
+  bool has_operand_mask = mask_lhs.has_value() || mask_rhs.has_value();
+
+  // Check valid tile sizes
+  // TODO: Add support for 16x16 tile
+  if (block_size != 32 && block_size != 64) {
+    std::ostringstream msg;
+    msg << "[block_masked_mm] Only block_sizes 32, 64 are supported."
+        << "Got block size " << block_size << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Do shape checks for operands
+  int in_a_ndim = a.ndim();
+  int in_b_ndim = b.ndim();
+
+  if (a.ndim() == 0 || b.ndim() == 0) {
+    throw std::invalid_argument(
+        "[block_masked_mm] Got 0 dimension input. Inputs must "
+        "have at least one dimension.");
+  }
+
+  if (a.ndim() == 1) {
+    // Insert a singleton dim in the beginning
+    a = expand_dims(a, 0, s);
+  }
+  if (b.ndim() == 1) {
+    // Insert a singleton dim at the end
+    b = expand_dims(b, 1, s);
+  }
+
+  if (a.shape(-1) != b.shape(-2)) {
+    std::ostringstream msg;
+    msg << "[block_masked_mm] Last dimension of first input with shape "
+        << a.shape() << " must match second to last dimension of"
+        << " second input with shape " << b.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Type promotion
+  auto out_type = result_type(a, b);
+  if (!issubdtype(out_type, floating)) {
+    std::ostringstream msg;
+    msg << "[block_masked_mm] Only real floating point types are supported but "
+        << a.dtype() << " and " << b.dtype()
+        << " were provided which results in " << out_type
+        << ", which is not a real floating point type.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  a = astype(a, out_type, s);
+  b = astype(b, out_type, s);
+
+  // Handle broadcasting
+  Shape bsx_a(a.shape().begin(), a.shape().end() - 2);
+  Shape bsx_b(b.shape().begin(), b.shape().end() - 2);
+
+  auto bsx_shape = broadcast_shapes(bsx_a, bsx_b);
+
+  bsx_shape.push_back(1);
+  bsx_shape.push_back(1);
+  int nd = bsx_shape.size();
+
+  int M = a.shape(-2);
+  int N = b.shape(-1);
+  int K = a.shape(-1);
+
+  // Prepare A
+  bsx_shape[nd - 2] = M;
+  bsx_shape[nd - 1] = K;
+  a = broadcast_to(a, bsx_shape, s);
+
+  // Prepare B
+  bsx_shape[nd - 2] = K;
+  bsx_shape[nd - 1] = N;
+  b = broadcast_to(b, bsx_shape, s);
+
+  // Get output shape
+  auto out_shape = bsx_shape;
+  out_shape[nd - 2] = M;
+  out_shape[nd - 1] = N;
+
+  // Determine mask shape requirments
+  int tm = (M + block_size - 1) / block_size;
+  int tn = (N + block_size - 1) / block_size;
+  int tk = (K + block_size - 1) / block_size;
+
+  std::vector<array> inputs = {a, b};
+
+  // Broadcast and astype mask
+  auto broadcast_mask = [](array mask,
+                           Shape& bs_shape,
+                           int y,
+                           int x,
+                           Dtype mask_dtype,
+                           StreamOrDevice s) {
+    int nd_bsx = bs_shape.size();
+    bs_shape[nd_bsx - 2] = y;
+    bs_shape[nd_bsx - 1] = x;
+    mask = astype(mask, mask_dtype, s);
+    return broadcast_to(mask, bs_shape, s);
+  };
+
+  // Out mask
+  if (mask_out.has_value()) {
+    array mask_out_p = mask_out.value_or(array({true}));
+    if (in_a_ndim == 1 || in_b_ndim == 1) {
+      std::vector<int> ex_dims;
+      if (in_a_ndim == 1)
+        ex_dims.push_back(-2);
+      if (in_b_ndim == 1)
+        ex_dims.push_back(-1);
+      mask_out_p = expand_dims(mask_out_p, ex_dims, s);
+    }
+    auto maskout_dtype = mask_out_p.dtype() == bool_ ? bool_ : out_type;
+    mask_out_p =
+        broadcast_mask(mask_out_p, bsx_shape, tm, tn, maskout_dtype, s);
+
+    inputs.push_back(mask_out_p);
+  }
+
+  // Operand masks
+  if (has_operand_mask) {
+    // Pull masks
+    array mask_lhs_p = mask_lhs.value_or(array({true}));
+    array mask_rhs_p = mask_rhs.value_or(array({true}));
+    auto mask_dtype =
+        (mask_lhs_p.dtype() == bool_ && mask_rhs_p.dtype() == bool_) ? bool_
+                                                                     : out_type;
+
+    // LHS mask
+    if (in_a_ndim == 1) {
+      mask_lhs_p = expand_dims(mask_lhs_p, -2, s);
+    }
+    mask_lhs_p = broadcast_mask(mask_lhs_p, bsx_shape, tm, tk, mask_dtype, s);
+
+    // RHS mask
+    if (in_b_ndim == 1) {
+      mask_rhs_p = expand_dims(mask_rhs_p, -1, s);
+    }
+    mask_rhs_p = broadcast_mask(mask_rhs_p, bsx_shape, tk, tn, mask_dtype, s);
+
+    inputs.push_back(mask_lhs_p);
+    inputs.push_back(mask_rhs_p);
+  }
+
+  // Caculate array
+  auto out = array(
+      std::move(out_shape),
+      out_type,
+      std::make_shared<BlockMaskedMM>(to_stream(s), block_size),
+      std::move(inputs));
+  // Remove the possibly inserted singleton dimensions
+  std::vector<int> axes;
+  if (in_a_ndim == 1) {
+    axes.push_back(out.ndim() - 2);
+  }
+  if (in_b_ndim == 1) {
+    axes.push_back(out.ndim() - 1);
+  }
+  return axes.empty() ? out : squeeze(out, axes, s);
+}
+
+/** Compute matrix product with matrix-level gather */
+array gather_mm(
+    array a,
+    array b,
+    std::optional<array> lhs_indices_ /* = std::nullopt */,
+    std::optional<array> rhs_indices_ /* = std::nullopt */,
+    bool sorted_indices /* = false */,
+    StreamOrDevice s /* = {} */) {
+  // If no indices, fall back to full matmul
+  if (!lhs_indices_ && !rhs_indices_) {
+    return matmul(a, b, s);
+  }
+
+  // Do shape checks for operands
+  int in_a_ndim = a.ndim();
+  int in_b_ndim = b.ndim();
+
+  if (a.ndim() == 0 || b.ndim() == 0) {
+    throw std::invalid_argument(
+        "[gather_mm] Got 0 dimension input. Inputs must "
+        "have at least one dimension.");
+  }
+
+  if (a.ndim() == 1) {
+    // Insert a singleton dim in the beginning
+    a = expand_dims(a, 0, s);
+  }
+  if (b.ndim() == 1) {
+    // Insert a singleton dim at the end
+    b = expand_dims(b, 1, s);
+  }
+
+  if (a.shape(-1) != b.shape(-2)) {
+    std::ostringstream msg;
+    msg << "[gather_mm] Last dimension of first input with shape " << a.shape()
+        << " must match second to last dimension of"
+        << " second input with shape " << b.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Type promotion
+  auto out_type = result_type(a, b);
+  if (!issubdtype(out_type, floating)) {
+    std::ostringstream msg;
+    msg << "[gather_mm] Only real floating point types are supported but "
+        << a.dtype() << " and " << b.dtype()
+        << " were provided which results in " << out_type
+        << ", which is not a real floating point type.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  a = astype(a, out_type, s);
+  b = astype(b, out_type, s);
+
+  // Handle broadcasting
+  array lhs_indices = indices_or_default(lhs_indices_, a, s);
+  array rhs_indices = indices_or_default(rhs_indices_, b, s);
+
+  if (!issubdtype(lhs_indices.dtype(), integer)) {
+    throw std::invalid_argument(
+        "[gather_mm] Got lhs_indices with invalid dtype. Indices must be integral.");
+  }
+
+  if (!issubdtype(rhs_indices.dtype(), integer)) {
+    throw std::invalid_argument(
+        "[gather_mm] Got rhs_indices with invalid dtype. Indices must be integral.");
+  }
+
+  lhs_indices = astype(lhs_indices, uint32, s);
+  rhs_indices = astype(rhs_indices, uint32, s);
+
+  int M = a.shape(-2);
+  int N = b.shape(-1);
+  int K = a.shape(-1);
+
+  std::tie(lhs_indices, rhs_indices) =
+      broadcast_arrays(lhs_indices, rhs_indices, s);
+
+  auto out_shape = lhs_indices.shape();
+  out_shape.push_back(M);
+  out_shape.push_back(N);
+
+  // Make the output array
+  auto out = array(
+      std::move(out_shape),
+      out_type,
+      std::make_shared<GatherMM>(
+          to_stream(s),
+          sorted_indices && !rhs_indices_,
+          sorted_indices && !lhs_indices_),
+      {std::move(a),
+       std::move(b),
+       std::move(lhs_indices),
+       std::move(rhs_indices)});
+
+  // Remove the possibly inserted singleton dimensions
+  std::vector<int> axes;
+  if (in_a_ndim == 1) {
+    axes.push_back(out.ndim() - 2);
+  }
+  if (in_b_ndim == 1) {
+    axes.push_back(out.ndim() - 1);
+  }
+  return axes.empty() ? out : squeeze(out, axes, s);
+}
+
+array segmented_mm(
+    array a,
+    array b,
+    array segments,
+    StreamOrDevice s /* = {} */) {
+  if (a.ndim() != 2 || b.ndim() != 2) {
+    throw std::invalid_argument("[segmented_mm] Batched matmul not supported");
+  }
+
+  if (segments.ndim() < 1 || segments.shape().back() != 2) {
+    std::ostringstream msg;
+    msg << "[segmented_mm] The segments should have shape (..., 2) but "
+        << segments.shape() << " was provided.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Type promotion
+  auto out_type = result_type(a, b);
+  if (!issubdtype(out_type, floating)) {
+    std::ostringstream msg;
+    msg << "[segmented_mm] Only real floating point types are supported but "
+        << a.dtype() << " and " << b.dtype()
+        << " were provided which results in " << out_type
+        << ", which is not a real floating point type.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (!issubdtype(segments.dtype(), integer)) {
+    throw std::invalid_argument(
+        "[segmented_mm] Got segments with invalid dtype. Segments must be integral.");
+  }
+
+  a = astype(a, out_type, s);
+  b = astype(b, out_type, s);
+  segments = astype(segments, uint32, s);
+
+  Shape out_shape = segments.shape();
+  out_shape.pop_back();
+  out_shape.push_back(a.shape(0));
+  out_shape.push_back(b.shape(1));
+
+  return array(
+      std::move(out_shape),
+      out_type,
+      std::make_shared<SegmentedMM>(to_stream(s)),
+      {std::move(a), std::move(b), std::move(segments)});
+}
+
+array diagonal(
+    const array& a,
+    int offset /* = 0 */,
+    int axis1 /* = 0 */,
+    int axis2 /* = 1 */,
+    StreamOrDevice s /* = {} */
+) {
+  int ndim = a.ndim();
+  if (ndim < 2) {
+    std::ostringstream msg;
+    msg << "[diagonal] Array must have at least two dimensions, but got "
+        << ndim << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto ax1 = (axis1 < 0) ? axis1 + ndim : axis1;
+  if (ax1 < 0 || ax1 >= ndim) {
+    std::ostringstream msg;
+    msg << "[diagonal] Invalid axis1 " << axis1 << " for array with " << ndim
+        << " dimensions.";
+    throw std::out_of_range(msg.str());
+  }
+
+  auto ax2 = (axis2 < 0) ? axis2 + ndim : axis2;
+  if (ax2 < 0 || ax2 >= ndim) {
+    std::ostringstream msg;
+    msg << "[diagonal] Invalid axis2 " << axis2 << " for array with " << ndim
+        << " dimensions.";
+    throw std::out_of_range(msg.str());
+  }
+
+  if (ax1 == ax2) {
+    throw std::invalid_argument(
+        "[diagonal] axis1 and axis2 cannot be the same axis");
+  }
+
+  ShapeElem off1 = std::max(-offset, 0);
+  ShapeElem off2 = std::max(offset, 0);
+
+  auto diag_size = std::min(a.shape(ax1) - off1, a.shape(ax2) - off2);
+  diag_size = diag_size < 0 ? 0 : diag_size;
+
+  std::vector<array> indices = {
+      arange(off1, off1 + diag_size, s), arange(off2, off2 + diag_size, s)};
+
+  Shape slice_sizes = a.shape();
+  slice_sizes[ax1] = 1;
+  slice_sizes[ax2] = 1;
+
+  auto out = gather(a, indices, {ax1, ax2}, slice_sizes, s);
+  return moveaxis(squeeze(out, {ax1 + 1, ax2 + 1}, s), 0, -1, s);
+}
+
+array diag(const array& a, int k /* = 0 */, StreamOrDevice s /* = {} */) {
+  if (a.ndim() == 1) {
+    int a_size = a.size();
+    int n = a_size + std::abs(k);
+    auto res = zeros({n, n}, a.dtype(), s);
+
+    std::vector<array> indices;
+    auto s1 = std::max(0, -k);
+    auto s2 = std::max(0, k);
+    indices.push_back(arange(s1, a_size + s1, uint32, s));
+    indices.push_back(arange(s2, a_size + s2, uint32, s));
+
+    return scatter(res, indices, reshape(a, {a_size, 1, 1}, s), {0, 1}, s);
+  } else if (a.ndim() == 2) {
+    return diagonal(a, k, 0, 1, s);
+  } else {
+    std::ostringstream msg;
+    msg << "[diag] array must be 1-D or 2-D, got array with " << a.ndim()
+        << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+}
+
+array trace(
+    const array& a,
+    int offset,
+    int axis1,
+    int axis2,
+    Dtype dtype,
+    StreamOrDevice s /* = {} */) {
+  int ndim = a.ndim();
+  if (ndim < 2) {
+    std::ostringstream msg;
+    msg << "[trace] Array must have at least two dimensions, but got " << ndim
+        << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto ax1 = (axis1 < 0) ? axis1 + ndim : axis1;
+  if (ax1 < 0 || ax1 >= ndim) {
+    std::ostringstream msg;
+    msg << "[trace] Invalid axis1 " << axis1 << " for array with " << ndim
+        << " dimensions.";
+    throw std::out_of_range(msg.str());
+  }
+
+  auto ax2 = (axis2 < 0) ? axis2 + ndim : axis2;
+  if (ax2 < 0 || ax2 >= ndim) {
+    std::ostringstream msg;
+    msg << "[trace] Invalid axis2 " << axis2 << " for array with " << ndim
+        << " dimensions.";
+    throw std::out_of_range(msg.str());
+  }
+
+  if (ax1 == ax2) {
+    throw std::invalid_argument(
+        "[trace] axis1 and axis2 cannot be the same axis");
+  }
+
+  return sum(
+      astype(diagonal(a, offset, axis1, axis2, s), dtype, s),
+      /* axis = */ -1,
+      /* keepdims = */ false,
+      s);
+}
+array trace(
+    const array& a,
+    int offset,
+    int axis1,
+    int axis2,
+    StreamOrDevice s /* = {} */) {
+  auto dtype = a.dtype();
+  return trace(a, offset, axis1, axis2, dtype, s);
+}
+array trace(const array& a, StreamOrDevice s /* = {} */) {
+  auto dtype = a.dtype();
+  return trace(a, 0, 0, 1, dtype, s);
+}
+
+std::vector<array> depends(
+    const std::vector<array>& inputs,
+    const std::vector<array>& dependencies) {
+  std::vector<array> all_inputs = inputs;
+  all_inputs.insert(all_inputs.end(), dependencies.begin(), dependencies.end());
+
+  // Compute the stream. Maybe do it in a smarter way at some point in the
+  // future.
+  Stream s = (inputs[0].has_primitive()) ? inputs[0].primitive().stream()
+                                         : to_stream({});
+  // Make the output info
+  std::vector<Shape> shapes;
+  std::vector<Dtype> dtypes;
+  for (const auto& in : inputs) {
+    shapes.emplace_back(in.shape());
+    dtypes.emplace_back(in.dtype());
+  }
+
+  return array::make_arrays(
+      std::move(shapes),
+      dtypes,
+      std::make_shared<Depends>(to_stream(s)),
+      all_inputs);
+}
+
+array atleast_1d(const array& a, StreamOrDevice s /* = {} */) {
+  if (a.ndim() == 0) {
+    return reshape(a, {1}, s);
+  }
+  return a;
+}
+
+std::vector<array> atleast_1d(
+    const std::vector<array>& arrays,
+    StreamOrDevice s /* = {} */) {
+  std::vector<array> out;
+  out.reserve(arrays.size());
+  for (const auto& a : arrays) {
+    out.push_back(atleast_1d(a, s));
+  }
+  return out;
+}
+
+array atleast_2d(const array& a, StreamOrDevice s /* = {} */) {
+  switch (a.ndim()) {
+    case 0:
+      return reshape(a, {1, 1}, s);
+    case 1:
+      return reshape(a, {1, a.shape(0)}, s);
+    default:
+      return a;
+  }
+}
+
+std::vector<array> atleast_2d(
+    const std::vector<array>& arrays,
+    StreamOrDevice s /* = {} */) {
+  std::vector<array> out;
+  out.reserve(arrays.size());
+  for (const auto& a : arrays) {
+    out.push_back(atleast_2d(a, s));
+  }
+  return out;
+}
+
+array atleast_3d(const array& a, StreamOrDevice s /* = {} */) {
+  switch (a.ndim()) {
+    case 0:
+      return reshape(a, {1, 1, 1}, s);
+    case 1:
+      return reshape(a, {1, a.shape(0), 1}, s);
+    case 2:
+      return reshape(a, {a.shape(0), a.shape(1), 1}, s);
+    default:
+      return a;
+  }
+}
+
+std::vector<array> atleast_3d(
+    const std::vector<array>& arrays,
+    StreamOrDevice s /* = {} */) {
+  std::vector<array> out;
+  out.reserve(arrays.size());
+  for (const auto& a : arrays) {
+    out.push_back(atleast_3d(a, s));
+  }
+  return out;
+}
+
+array number_of_elements(
+    const array& a,
+    std::vector<int> axes,
+    bool inverted,
+    Dtype dtype /* = int32 */,
+    StreamOrDevice s /* = {} */) {
+  for (auto& ax : axes) {
+    int normal_axis = (ax + a.ndim()) % a.ndim();
+    if (normal_axis >= a.ndim() || normal_axis < 0) {
+      std::ostringstream msg;
+      msg << "[number_of_elements] Can't get the shape for axis " << ax
+          << " from an array with " << a.ndim() << " dimensions.";
+      throw std::invalid_argument(msg.str());
+    }
+    ax = normal_axis;
+  }
+
+  if (!detail::in_dynamic_tracing()) {
+    double numel = 1;
+    for (auto ax : axes) {
+      numel *= a.shape(ax);
+    }
+    return array(inverted ? 1.0 / numel : numel, dtype);
+  }
+  return stop_gradient(array(
+      Shape{},
+      dtype,
+      std::make_shared<NumberOfElements>(
+          to_stream(s), std::move(axes), inverted, dtype),
+      {a}));
+}
+
+array conjugate(const array& a, StreamOrDevice s /* = {} */) {
+  // Mirror NumPy's behaviour for real input
+  if (a.dtype() != complex64) {
+    return a;
+  }
+  return array(
+      a.shape(), a.dtype(), std::make_shared<Conjugate>(to_stream(s)), {a});
+}
+
+array bitwise_impl(
+    const array& a,
+    const array& b,
+    BitwiseBinary::Op op,
+    const std::string& op_name,
+    const StreamOrDevice& s,
+    std::optional<Dtype> out_type_ = std::nullopt) {
+  auto out_type = out_type_ ? *out_type_ : promote_types(a.dtype(), b.dtype());
+  if (!(issubdtype(out_type, integer) || out_type == bool_)) {
+    std::ostringstream msg;
+    msg << "[" << op_name
+        << "] Only allowed on integer or boolean types "
+           "but got types "
+        << a.dtype() << " and " << b.dtype() << ".";
+    throw std::runtime_error(msg.str());
+  }
+  auto inputs =
+      broadcast_arrays({astype(a, out_type, s), astype(b, out_type, s)}, s);
+  auto& out_shape = inputs[0].shape();
+  return array(
+      out_shape,
+      out_type,
+      std::make_shared<BitwiseBinary>(to_stream(s), op),
+      std::move(inputs));
+}
+
+array bitwise_and(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  return bitwise_impl(a, b, BitwiseBinary::Op::And, "bitwise_and", s);
+}
+array operator&(const array& a, const array& b) {
+  return bitwise_and(a, b);
+}
+
+array bitwise_or(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  return bitwise_impl(a, b, BitwiseBinary::Op::Or, "bitwise_or", s);
+}
+array operator|(const array& a, const array& b) {
+  return bitwise_or(a, b);
+}
+
+array bitwise_xor(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  return bitwise_impl(a, b, BitwiseBinary::Op::Xor, "bitwise_xor", s);
+}
+array operator^(const array& a, const array& b) {
+  return bitwise_xor(a, b);
+}
+
+array left_shift(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto t = result_type(a, b);
+  if (t == bool_) {
+    t = uint8;
+  }
+  return bitwise_impl(a, b, BitwiseBinary::Op::LeftShift, "left_shift", s, t);
+}
+array operator<<(const array& a, const array& b) {
+  return left_shift(a, b);
+}
+
+array right_shift(const array& a, const array& b, StreamOrDevice s /* = {} */) {
+  auto t = result_type(a, b);
+  if (t == bool_) {
+    t = uint8;
+  }
+  return bitwise_impl(
+      astype(a, t, s),
+      astype(b, t, s),
+      BitwiseBinary::Op::RightShift,
+      "right_shift",
+      s,
+      t);
+}
+array operator>>(const array& a, const array& b) {
+  return right_shift(a, b);
+}
+
+array bitwise_invert(const array& a, StreamOrDevice s /* = {} */) {
+  if (issubdtype(a.dtype(), inexact)) {
+    throw std::invalid_argument(
+        "[bitwise_invert] Bitwise inverse only allowed on integer types.");
+  } else if (a.dtype() == bool_) {
+    return logical_not(a, s);
+  }
+  return array(
+      a.shape(), a.dtype(), std::make_shared<BitwiseInvert>(to_stream(s)), {a});
+}
+
+array operator~(const array& a) {
+  return bitwise_invert(a);
+}
+
+array view(const array& a, const Dtype& dtype, StreamOrDevice s /* = {} */) {
+  if (a.dtype() == dtype) {
+    return a;
+  }
+  auto out_shape = a.shape();
+  auto ibytes = size_of(a.dtype());
+  auto obytes = size_of(dtype);
+  if (a.ndim() == 0 && ibytes != obytes) {
+    throw std::invalid_argument(
+        "[view] Changing the type of a scalar is only allowed"
+        " for types with the same size.");
+  } else {
+    if (ibytes < obytes) {
+      if (out_shape.back() % (obytes / ibytes) != 0) {
+        throw std::invalid_argument(
+            "[view] When viewing as a larger dtype, the size in bytes of the last"
+            " axis must be a multiple of the requested type size.");
+      }
+      out_shape.back() /= (obytes / ibytes);
+    } else if (ibytes > obytes) {
+      // Type size ratios are always integers
+      out_shape.back() *= (ibytes / obytes);
+    }
+  }
+  return array(
+      out_shape, dtype, std::make_shared<View>(to_stream(s), dtype), {a});
+}
+
+array roll(
+    const array& a,
+    const Shape& shift,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  if (axes.empty()) {
+    return a;
+  }
+
+  if (shift.size() < axes.size()) {
+    std::ostringstream msg;
+    msg << "[roll] At least one shift value per axis is required, "
+        << shift.size() << " provided for " << axes.size() << " axes.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  array result = a;
+  for (int i = 0; i < axes.size(); i++) {
+    int ax = axes[i];
+    if (ax < 0) {
+      ax += a.ndim();
+    }
+    if (ax < 0 || ax >= a.ndim()) {
+      std::ostringstream msg;
+      msg << "[roll] Invalid axis " << axes[i] << " for array with " << a.ndim()
+          << " dimensions.";
+      throw std::invalid_argument(msg.str());
+    }
+
+    auto sh = shift[i];
+    auto size = a.shape(ax);
+    if (size == 0) {
+      continue; // skip rolling this axis if it has size 0
+    }
+    auto split_index = (sh < 0) ? (-sh) % size : size - sh % size;
+
+    auto parts = split(result, Shape{split_index}, ax, s);
+    std::swap(parts[0], parts[1]);
+    result = concatenate(parts, ax, s);
+  }
+
+  return result;
+}
+
+array roll(const array& a, int shift, StreamOrDevice s /* = {} */) {
+  auto shape = a.shape();
+  return reshape(
+      roll(flatten(a, s), Shape{shift}, std::vector<int>{0}, s),
+      std::move(shape),
+      s);
+}
+
+array roll(const array& a, const Shape& shift, StreamOrDevice s /* = {} */) {
+  int total_shift = 0;
+  for (auto& s : shift) {
+    total_shift += s;
+  }
+  return roll(a, total_shift, s);
+}
+
+array roll(const array& a, int shift, int axis, StreamOrDevice s /* = {} */) {
+  return roll(a, Shape{shift}, std::vector<int>{axis}, s);
+}
+
+array roll(
+    const array& a,
+    int shift,
+    const std::vector<int>& axes,
+    StreamOrDevice s /* = {} */) {
+  Shape shifts(axes.size(), shift);
+  return roll(a, shifts, axes, s);
+}
+
+array roll(
+    const array& a,
+    const Shape& shift,
+    int axis,
+    StreamOrDevice s /* = {} */) {
+  int total_shift = 0;
+  for (auto& s : shift) {
+    total_shift += s;
+  }
+  return roll(a, Shape{total_shift}, std::vector<int>{axis}, s);
+}
+
+array real(const array& a, StreamOrDevice s /* = {} */) {
+  if (!issubdtype(a.dtype(), complexfloating)) {
+    return a;
+  }
+  return array(a.shape(), float32, std::make_shared<Real>(to_stream(s)), {a});
+}
+
+array imag(const array& a, StreamOrDevice s /* = {} */) {
+  if (!issubdtype(a.dtype(), complexfloating)) {
+    return zeros_like(a);
+  }
+  return array(a.shape(), float32, std::make_shared<Imag>(to_stream(s)), {a});
+}
+
+array contiguous(
+    const array& a,
+    bool allow_col_major /* = false */,
+    StreamOrDevice s /* = {} */) {
+  return array(
+      a.shape(),
+      a.dtype(),
+      std::make_shared<Contiguous>(to_stream(s), allow_col_major),
+      {a});
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/ops.h b/ml-stable-diffusion/mlx/mlx/ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..826f6d47b9798026a3b5371d28e8fd793d3ba36e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/ops.h
@@ -0,0 +1,1538 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <optional>
+
+#include "mlx/array.h"
+#include "mlx/device.h"
+#include "mlx/stream.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+/**
+ * \defgroup ops Core array operations
+ * @{
+ */
+
+/**
+ * A 1D array of numbers starting at `start` (optional),
+ * stopping at stop, stepping by `step` (optional). */
+array arange(
+    double start,
+    double stop,
+    double step,
+    Dtype dtype,
+    StreamOrDevice s = {});
+array arange(double start, double stop, double step, StreamOrDevice s = {});
+array arange(double start, double stop, Dtype dtype, StreamOrDevice s = {});
+array arange(double start, double stop, StreamOrDevice s = {});
+array arange(double stop, Dtype dtype, StreamOrDevice s = {});
+array arange(double stop, StreamOrDevice s = {});
+
+array arange(int start, int stop, int step, StreamOrDevice s = {});
+array arange(int start, int stop, StreamOrDevice s = {});
+array arange(int stop, StreamOrDevice s = {});
+
+/** A 1D array of `num` evenly spaced numbers in the range `[start, stop]` */
+array linspace(
+    double start,
+    double stop,
+    int num = 50,
+    Dtype dtype = float32,
+    StreamOrDevice s = {});
+
+/** Convert an array to the given data type. */
+array astype(array a, Dtype dtype, StreamOrDevice s = {});
+
+/** Create a view of an array with the given shape and strides. */
+array as_strided(
+    array a,
+    Shape shape,
+    Strides strides,
+    size_t offset,
+    StreamOrDevice s = {});
+
+/** Copy another array. */
+array copy(array a, StreamOrDevice s = {});
+
+/** Fill an array of the given shape with the given value(s). */
+array full(Shape shape, array vals, Dtype dtype, StreamOrDevice s = {});
+array full(Shape shape, array vals, StreamOrDevice s = {});
+template <typename T>
+array full(Shape shape, T val, Dtype dtype, StreamOrDevice s = {}) {
+  return full(std::move(shape), array(val, dtype), to_stream(s));
+}
+template <typename T>
+array full(Shape shape, T val, StreamOrDevice s = {}) {
+  return full(std::move(shape), array(val), to_stream(s));
+}
+
+/** Fill an array of the given shape with zeros. */
+array zeros(const Shape& shape, Dtype dtype, StreamOrDevice s = {});
+inline array zeros(const Shape& shape, StreamOrDevice s = {}) {
+  return zeros(shape, float32, s);
+}
+array zeros_like(const array& a, StreamOrDevice s = {});
+
+/** Fill an array of the given shape with ones. */
+array ones(const Shape& shape, Dtype dtype, StreamOrDevice s = {});
+inline array ones(const Shape& shape, StreamOrDevice s = {}) {
+  return ones(shape, float32, s);
+}
+array ones_like(const array& a, StreamOrDevice s = {});
+
+/** Fill an array of the given shape (n,m) with ones in the specified diagonal
+ * k, and zeros everywhere else. */
+array eye(int n, int m, int k, Dtype dtype, StreamOrDevice s = {});
+inline array eye(int n, Dtype dtype, StreamOrDevice s = {}) {
+  return eye(n, n, 0, dtype, s);
+}
+inline array eye(int n, int m, StreamOrDevice s = {}) {
+  return eye(n, m, 0, float32, s);
+}
+inline array eye(int n, int m, int k, StreamOrDevice s = {}) {
+  return eye(n, m, k, float32, s);
+}
+inline array eye(int n, StreamOrDevice s = {}) {
+  return eye(n, n, 0, float32, s);
+}
+
+/** Create a square matrix of shape (n,n) of zeros, and ones in the major
+ * diagonal. */
+array identity(int n, Dtype dtype, StreamOrDevice s = {});
+inline array identity(int n, StreamOrDevice s = {}) {
+  return identity(n, float32, s);
+}
+
+array tri(int n, int m, int k, Dtype type, StreamOrDevice s = {});
+inline array tri(int n, Dtype type, StreamOrDevice s = {}) {
+  return tri(n, n, 0, type, s);
+}
+
+array tril(array x, int k = 0, StreamOrDevice s = {});
+array triu(array x, int k = 0, StreamOrDevice s = {});
+
+/** Reshape an array to the given shape. */
+array reshape(const array& a, Shape shape, StreamOrDevice s = {});
+
+/** Unflatten the axis to the given shape. */
+array unflatten(const array& a, int axis, Shape shape, StreamOrDevice s = {});
+
+/** Flatten the dimensions in the range `[start_axis, end_axis]` . */
+array flatten(
+    const array& a,
+    int start_axis,
+    int end_axis = -1,
+    StreamOrDevice s = {});
+
+/** Flatten the array to 1D. */
+array flatten(const array& a, StreamOrDevice s = {});
+
+/** Multiply the array by the Hadamard matrix of corresponding size. */
+array hadamard_transform(
+    const array& a,
+    std::optional<float> scale = std::nullopt,
+    StreamOrDevice s = {});
+
+/** Remove singleton dimensions at the given axes. */
+array squeeze(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+
+/** Remove singleton dimensions at the given axis. */
+array squeeze(const array& a, int axis, StreamOrDevice s = {});
+
+/** Remove all singleton dimensions. */
+array squeeze(const array& a, StreamOrDevice s = {});
+
+/** Add a singleton dimension at the given axes. */
+array expand_dims(
+    const array& a,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+
+/** Add a singleton dimension at the given axis. */
+array expand_dims(const array& a, int axis, StreamOrDevice s = {});
+
+/** Slice an array. */
+array slice(
+    const array& a,
+    Shape start,
+    Shape stop,
+    Shape strides,
+    StreamOrDevice s = {});
+inline array slice(
+    const array& a,
+    std::initializer_list<int> start,
+    Shape stop,
+    Shape strides,
+    StreamOrDevice s = {}) {
+  return slice(a, Shape(start), std::move(stop), std::move(strides), s);
+}
+
+/** Slice an array with a stride of 1 in each dimension. */
+array slice(const array& a, Shape start, Shape stop, StreamOrDevice s = {});
+
+/** Slice an array with dynamic starting indices. */
+array slice(
+    const array& a,
+    const array& start,
+    std::vector<int> axes,
+    Shape slice_size,
+    StreamOrDevice s = {});
+
+/** Update a slice from the source array. */
+array slice_update(
+    const array& src,
+    const array& update,
+    Shape start,
+    Shape stop,
+    Shape strides,
+    StreamOrDevice s = {});
+
+/** Update a slice from the source array with stride 1 in each dimension. */
+array slice_update(
+    const array& src,
+    const array& update,
+    Shape start,
+    Shape stop,
+    StreamOrDevice s = {});
+
+/** Update a slice from the source array with dynamic starting indices. */
+array slice_update(
+    const array& src,
+    const array& update,
+    const array& start,
+    std::vector<int> axes,
+    StreamOrDevice s = {});
+
+/** Split an array into sub-arrays along a given axis. */
+std::vector<array>
+split(const array& a, int num_splits, int axis, StreamOrDevice s = {});
+std::vector<array> split(const array& a, int num_splits, StreamOrDevice s = {});
+std::vector<array>
+split(const array& a, const Shape& indices, int axis, StreamOrDevice s = {});
+std::vector<array>
+split(const array& a, const Shape& indices, StreamOrDevice s = {});
+
+/** A vector of coordinate arrays from coordinate vectors. */
+std::vector<array> meshgrid(
+    const std::vector<array>& arrays,
+    bool sparse = false,
+    const std::string& indexing = "xy",
+    StreamOrDevice s = {});
+
+/**
+ * Clip (limit) the values in an array.
+ */
+array clip(
+    const array& a,
+    const std::optional<array>& a_min = std::nullopt,
+    const std::optional<array>& a_max = std::nullopt,
+    StreamOrDevice s = {});
+
+/** Concatenate arrays along a given axis. */
+array concatenate(std::vector<array> arrays, int axis, StreamOrDevice s = {});
+array concatenate(std::vector<array> arrays, StreamOrDevice s = {});
+
+/** Stack arrays along a new axis. */
+array stack(const std::vector<array>& arrays, int axis, StreamOrDevice s = {});
+array stack(const std::vector<array>& arrays, StreamOrDevice s = {});
+
+/** Repeat an array along an axis. */
+array repeat(const array& arr, int repeats, int axis, StreamOrDevice s = {});
+array repeat(const array& arr, int repeats, StreamOrDevice s = {});
+
+array tile(const array& arr, std::vector<int> reps, StreamOrDevice s = {});
+
+/** Permutes the dimensions according to the given axes. */
+array transpose(const array& a, std::vector<int> axes, StreamOrDevice s = {});
+inline array transpose(
+    const array& a,
+    std::initializer_list<int> axes,
+    StreamOrDevice s = {}) {
+  return transpose(a, std::vector<int>(axes), s);
+}
+
+/** Swap two axes of an array. */
+array swapaxes(const array& a, int axis1, int axis2, StreamOrDevice s = {});
+
+/** Move an axis of an array. */
+array moveaxis(
+    const array& a,
+    int source,
+    int destination,
+    StreamOrDevice s = {});
+
+/** Pad an array with a constant value */
+array pad(
+    const array& a,
+    const std::vector<int>& axes,
+    const Shape& low_pad_size,
+    const Shape& high_pad_size,
+    const array& pad_value = array(0),
+    const std::string& mode = "constant",
+    StreamOrDevice s = {});
+
+/** Pad an array with a constant value along all axes */
+array pad(
+    const array& a,
+    const std::vector<std::pair<int, int>>& pad_width,
+    const array& pad_value = array(0),
+    const std::string& mode = "constant",
+    StreamOrDevice s = {});
+array pad(
+    const array& a,
+    const std::pair<int, int>& pad_width,
+    const array& pad_value = array(0),
+    const std::string& mode = "constant",
+    StreamOrDevice s = {});
+array pad(
+    const array& a,
+    int pad_width,
+    const array& pad_value = array(0),
+    const std::string& mode = "constant",
+    StreamOrDevice s = {});
+
+/** Permutes the dimensions in reverse order. */
+array transpose(const array& a, StreamOrDevice s = {});
+
+/** Broadcast an array to a given shape. */
+array broadcast_to(const array& a, const Shape& shape, StreamOrDevice s = {});
+
+/** Broadcast a vector of arrays against one another. */
+std::vector<array> broadcast_arrays(
+    const std::vector<array>& inputs,
+    StreamOrDevice s = {});
+
+/** Returns the bool array with (a == b) element-wise. */
+array equal(const array& a, const array& b, StreamOrDevice s = {});
+inline array operator==(const array& a, const array& b) {
+  return equal(a, b);
+}
+template <typename T>
+array operator==(T a, const array& b) {
+  return equal(array(a), b);
+}
+template <typename T>
+array operator==(const array& a, T b) {
+  return equal(a, array(b));
+}
+
+/** Returns the bool array with (a != b) element-wise. */
+array not_equal(const array& a, const array& b, StreamOrDevice s = {});
+inline array operator!=(const array& a, const array& b) {
+  return not_equal(a, b);
+}
+template <typename T>
+array operator!=(T a, const array& b) {
+  return not_equal(array(a), b);
+}
+template <typename T>
+array operator!=(const array& a, T b) {
+  return not_equal(a, array(b));
+}
+
+/** Returns bool array with (a > b) element-wise. */
+array greater(const array& a, const array& b, StreamOrDevice s = {});
+inline array operator>(const array& a, const array& b) {
+  return greater(a, b);
+}
+template <typename T>
+array operator>(T a, const array& b) {
+  return greater(array(a), b);
+}
+template <typename T>
+array operator>(const array& a, T b) {
+  return greater(a, array(b));
+}
+
+/** Returns bool array with (a >= b) element-wise. */
+array greater_equal(const array& a, const array& b, StreamOrDevice s = {});
+inline array operator>=(const array& a, const array& b) {
+  return greater_equal(a, b);
+}
+template <typename T>
+array operator>=(T a, const array& b) {
+  return greater_equal(array(a), b);
+}
+template <typename T>
+array operator>=(const array& a, T b) {
+  return greater_equal(a, array(b));
+}
+
+/** Returns bool array with (a < b) element-wise. */
+array less(const array& a, const array& b, StreamOrDevice s = {});
+inline array operator<(const array& a, const array& b) {
+  return less(a, b);
+}
+template <typename T>
+array operator<(T a, const array& b) {
+  return less(array(a), b);
+}
+template <typename T>
+array operator<(const array& a, T b) {
+  return less(a, array(b));
+}
+
+/** Returns bool array with (a <= b) element-wise. */
+array less_equal(const array& a, const array& b, StreamOrDevice s = {});
+inline array operator<=(const array& a, const array& b) {
+  return less_equal(a, b);
+}
+template <typename T>
+array operator<=(T a, const array& b) {
+  return less_equal(array(a), b);
+}
+template <typename T>
+array operator<=(const array& a, T b) {
+  return less_equal(a, array(b));
+}
+
+/** True if two arrays have the same shape and elements. */
+array array_equal(
+    const array& a,
+    const array& b,
+    bool equal_nan,
+    StreamOrDevice s = {});
+inline array
+array_equal(const array& a, const array& b, StreamOrDevice s = {}) {
+  return array_equal(a, b, false, s);
+}
+
+array isnan(const array& a, StreamOrDevice s = {});
+
+array isinf(const array& a, StreamOrDevice s = {});
+
+array isfinite(const array& a, StreamOrDevice s = {});
+
+array isposinf(const array& a, StreamOrDevice s = {});
+
+array isneginf(const array& a, StreamOrDevice s = {});
+
+/** Select from x or y depending on condition. */
+array where(
+    const array& condition,
+    const array& x,
+    const array& y,
+    StreamOrDevice s = {});
+
+/** Replace NaN and infinities with finite numbers. */
+array nan_to_num(
+    const array& a,
+    float nan = 0.0f,
+    const std::optional<float> posinf = std::nullopt,
+    const std::optional<float> neginf = std::nullopt,
+    StreamOrDevice s = {});
+
+/** True if all elements in the array are true (or non-zero). **/
+array all(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array all(const array& a, StreamOrDevice s = {}) {
+  return all(a, false, to_stream(s));
+}
+
+/** True if the two arrays are equal within the specified tolerance. */
+array allclose(
+    const array& a,
+    const array& b,
+    double rtol = 1e-5,
+    double atol = 1e-8,
+    bool equal_nan = false,
+    StreamOrDevice s = {});
+
+/** Returns a boolean array where two arrays are element-wise equal within the
+ * specified tolerance. */
+array isclose(
+    const array& a,
+    const array& b,
+    double rtol = 1e-5,
+    double atol = 1e-8,
+    bool equal_nan = false,
+    StreamOrDevice s = {});
+
+/**
+ *  Reduces the input along the given axes. An output value is true
+ *  if all the corresponding inputs are true.
+ **/
+array all(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/**
+ *  Reduces the input along the given axis. An output value is true
+ *  if all the corresponding inputs are true.
+ **/
+array all(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** True if any elements in the array are true (or non-zero). **/
+array any(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array any(const array& a, StreamOrDevice s = {}) {
+  return any(a, false, to_stream(s));
+}
+
+/**
+ *  Reduces the input along the given axes. An output value is true
+ *  if any of the corresponding inputs are true.
+ **/
+array any(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/**
+ *  Reduces the input along the given axis. An output value is true
+ *  if any of the corresponding inputs are true.
+ **/
+array any(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Sums the elements of an array. */
+array sum(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array sum(const array& a, StreamOrDevice s = {}) {
+  return sum(a, false, to_stream(s));
+}
+
+/** Sums the elements of an array along the given axes. */
+array sum(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Sums the elements of an array along the given axis. */
+array sum(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Computes the mean of the elements of an array. */
+array mean(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array mean(const array& a, StreamOrDevice s = {}) {
+  return mean(a, false, to_stream(s));
+}
+
+/** Computes the mean of the elements of an array along the given axes */
+array mean(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Computes the mean of the elements of an array along the given axis */
+array mean(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Computes the variance of the elements of an array. */
+array var(const array& a, bool keepdims, int ddof = 0, StreamOrDevice s = {});
+inline array var(const array& a, StreamOrDevice s = {}) {
+  return var(a, false, 0, to_stream(s));
+}
+
+/** Computes the variance of the elements of an array along the given
+ * axes */
+array var(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    int ddof = 0,
+    StreamOrDevice s = {});
+
+/** Computes the variance of the elements of an array along the given
+ * axis */
+array var(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    int ddof = 0,
+    StreamOrDevice s = {});
+
+/** Computes the standard deviation of the elements of an array. */
+array std(const array& a, bool keepdims, int ddof = 0, StreamOrDevice s = {});
+inline array std(const array& a, StreamOrDevice s = {}) {
+  return std(a, false, 0, to_stream(s));
+}
+
+/** Computes the standard deviation of the elements of an array along the given
+ * axes */
+array std(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    int ddof = 0,
+    StreamOrDevice s = {});
+
+/** Computes the standard deviation of the elements of an array along the given
+ * axis */
+array std(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    int ddof = 0,
+    StreamOrDevice s = {});
+
+/** The product of all elements of the array. */
+array prod(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array prod(const array& a, StreamOrDevice s = {}) {
+  return prod(a, false, to_stream(s));
+}
+
+/** The product of the elements of an array along the given axes. */
+array prod(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** The product of the elements of an array along the given axis. */
+array prod(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** The maximum of all elements of the array. */
+array max(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array max(const array& a, StreamOrDevice s = {}) {
+  return max(a, false, to_stream(s));
+}
+
+/** The maximum of the elements of an array along the given axes. */
+array max(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** The maximum of the elements of an array along the given axis. */
+array max(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** The minimum of all elements of the array. */
+array min(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array min(const array& a, StreamOrDevice s = {}) {
+  return min(a, false, to_stream(s));
+}
+
+/** The minimum of the elements of an array along the given axes. */
+array min(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** The minimum of the elements of an array along the given axis. */
+array min(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Returns the index of the minimum value in the array. */
+array argmin(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array argmin(const array& a, StreamOrDevice s = {}) {
+  return argmin(a, false, s);
+}
+
+/** Returns the indices of the minimum values along a given axis. */
+array argmin(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Returns the index of the maximum value in the array. */
+array argmax(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array argmax(const array& a, StreamOrDevice s = {}) {
+  return argmax(a, false, s);
+}
+
+/** Returns the indices of the maximum values along a given axis. */
+array argmax(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Returns a sorted copy of the flattened array. */
+array sort(const array& a, StreamOrDevice s = {});
+
+/** Returns a sorted copy of the array along a given axis. */
+array sort(const array& a, int axis, StreamOrDevice s = {});
+
+/** Returns indices that sort the flattened array. */
+array argsort(const array& a, StreamOrDevice s = {});
+
+/** Returns indices that sort the array along a given axis. */
+array argsort(const array& a, int axis, StreamOrDevice s = {});
+
+/**
+ * Returns a partitioned copy of the flattened array
+ * such that the smaller kth elements are first.
+ **/
+array partition(const array& a, int kth, StreamOrDevice s = {});
+
+/**
+ * Returns a partitioned copy of the array along a given axis
+ * such that the smaller kth elements are first.
+ **/
+array partition(const array& a, int kth, int axis, StreamOrDevice s = {});
+
+/**
+ * Returns indices that partition the flattened array
+ * such that the smaller kth elements are first.
+ **/
+array argpartition(const array& a, int kth, StreamOrDevice s = {});
+
+/**
+ * Returns indices that partition the array along a given axis
+ * such that the smaller kth elements are first.
+ **/
+array argpartition(const array& a, int kth, int axis, StreamOrDevice s = {});
+
+/** Returns topk elements of the flattened array. */
+array topk(const array& a, int k, StreamOrDevice s = {});
+
+/** Returns topk elements of the array along a given axis. */
+array topk(const array& a, int k, int axis, StreamOrDevice s = {});
+
+/** Cumulative logsumexp of an array. */
+array logcumsumexp(
+    const array& a,
+    int axis,
+    bool reverse = false,
+    bool inclusive = true,
+    StreamOrDevice s = {});
+
+/** The logsumexp of all elements of the array. */
+array logsumexp(const array& a, bool keepdims, StreamOrDevice s = {});
+inline array logsumexp(const array& a, StreamOrDevice s = {}) {
+  return logsumexp(a, false, to_stream(s));
+}
+
+/** The logsumexp of the elements of an array along the given axes. */
+array logsumexp(
+    const array& a,
+    const std::vector<int>& axes,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** The logsumexp of the elements of an array along the given axis. */
+array logsumexp(
+    const array& a,
+    int axis,
+    bool keepdims = false,
+    StreamOrDevice s = {});
+
+/** Absolute value of elements in an array. */
+array abs(const array& a, StreamOrDevice s = {});
+
+/** Negate an array. */
+array negative(const array& a, StreamOrDevice s = {});
+array operator-(const array& a);
+
+/** The sign of the elements in an array. */
+array sign(const array& a, StreamOrDevice s = {});
+
+/** Logical not of an array */
+array logical_not(const array& a, StreamOrDevice s = {});
+
+/** Logical and of two arrays */
+array logical_and(const array& a, const array& b, StreamOrDevice s = {});
+array operator&&(const array& a, const array& b);
+
+/** Logical or of two arrays */
+array logical_or(const array& a, const array& b, StreamOrDevice s = {});
+array operator||(const array& a, const array& b);
+
+/** The reciprocal (1/x) of the elements in an array. */
+array reciprocal(const array& a, StreamOrDevice s = {});
+
+/** Add two arrays. */
+array add(const array& a, const array& b, StreamOrDevice s = {});
+array operator+(const array& a, const array& b);
+template <typename T>
+array operator+(T a, const array& b) {
+  return add(array(a), b);
+}
+template <typename T>
+array operator+(const array& a, T b) {
+  return add(a, array(b));
+}
+
+/** Subtract two arrays. */
+array subtract(const array& a, const array& b, StreamOrDevice s = {});
+array operator-(const array& a, const array& b);
+template <typename T>
+array operator-(T a, const array& b) {
+  return subtract(array(a), b);
+}
+template <typename T>
+array operator-(const array& a, T b) {
+  return subtract(a, array(b));
+}
+
+/** Multiply two arrays. */
+array multiply(const array& a, const array& b, StreamOrDevice s = {});
+array operator*(const array& a, const array& b);
+template <typename T>
+array operator*(T a, const array& b) {
+  return multiply(array(a), b);
+}
+template <typename T>
+array operator*(const array& a, T b) {
+  return multiply(a, array(b));
+}
+
+/** Divide two arrays. */
+array divide(const array& a, const array& b, StreamOrDevice s = {});
+array operator/(const array& a, const array& b);
+array operator/(double a, const array& b);
+array operator/(const array& a, double b);
+
+/** Compute the element-wise quotient and remainder. */
+std::vector<array>
+divmod(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Compute integer division. Equivalent to doing floor(a / x). */
+array floor_divide(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Compute the element-wise remainder of division */
+array remainder(const array& a, const array& b, StreamOrDevice s = {});
+array operator%(const array& a, const array& b);
+template <typename T>
+array operator%(T a, const array& b) {
+  return remainder(array(a), b);
+}
+template <typename T>
+array operator%(const array& a, T b) {
+  return remainder(a, array(b));
+}
+
+/** Element-wise maximum between two arrays. */
+array maximum(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Element-wise minimum between two arrays. */
+array minimum(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Floor the element of an array. **/
+array floor(const array& a, StreamOrDevice s = {});
+
+/** Ceil the element of an array. **/
+array ceil(const array& a, StreamOrDevice s = {});
+
+/** Square the elements of an array. */
+array square(const array& a, StreamOrDevice s = {});
+
+/** Exponential of the elements of an array. */
+array exp(const array& a, StreamOrDevice s = {});
+
+/** Sine of the elements of an array */
+array sin(const array& a, StreamOrDevice s = {});
+
+/** Cosine of the elements of an array */
+array cos(const array& a, StreamOrDevice s = {});
+
+/** Tangent of the elements of an array */
+array tan(const array& a, StreamOrDevice s = {});
+
+/** Arc Sine of the elements of an array */
+array arcsin(const array& a, StreamOrDevice s = {});
+
+/** Arc Cosine of the elements of an array */
+array arccos(const array& a, StreamOrDevice s = {});
+
+/** Arc Tangent of the elements of an array */
+array arctan(const array& a, StreamOrDevice s = {});
+
+/** Inverse tangent of the ratio of two arrays */
+array arctan2(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Hyperbolic Sine of the elements of an array */
+array sinh(const array& a, StreamOrDevice s = {});
+
+/** Hyperbolic Cosine of the elements of an array */
+array cosh(const array& a, StreamOrDevice s = {});
+
+/** Hyperbolic Tangent of the elements of an array */
+array tanh(const array& a, StreamOrDevice s = {});
+
+/** Inverse Hyperbolic Sine of the elements of an array */
+array arcsinh(const array& a, StreamOrDevice s = {});
+
+/** Inverse Hyperbolic Cosine of the elements of an array */
+array arccosh(const array& a, StreamOrDevice s = {});
+
+/** Inverse Hyperbolic Tangent of the elements of an array */
+array arctanh(const array& a, StreamOrDevice s = {});
+
+/** Convert the elements of an array from Radians to Degrees **/
+array degrees(const array& a, StreamOrDevice s = {});
+
+/** Convert the elements of an array from Degrees to Radians **/
+array radians(const array& a, StreamOrDevice s = {});
+
+/** Natural logarithm of the elements of an array. */
+array log(const array& a, StreamOrDevice s = {});
+
+/** Log base 2 of the elements of an array. */
+array log2(const array& a, StreamOrDevice s = {});
+
+/** Log base 10 of the elements of an array. */
+array log10(const array& a, StreamOrDevice s = {});
+
+/** Natural logarithm of one plus elements in the array: `log(1 + a)`. */
+array log1p(const array& a, StreamOrDevice s = {});
+
+/** Log-add-exp of one elements in the array: `log(exp(a) + exp(b))`. */
+array logaddexp(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Element-wise logistic sigmoid of the array: `1 / (1 + exp(-x)`. */
+array sigmoid(const array& a, StreamOrDevice s = {});
+
+/** Computes the error function of the elements of an array. */
+array erf(const array& a, StreamOrDevice s = {});
+
+/** Computes the inverse error function of the elements of an array. */
+array erfinv(const array& a, StreamOrDevice s = {});
+
+/** Computes the expm1 function of the elements of an array. */
+array expm1(const array& a, StreamOrDevice s = {});
+
+/** Stop the flow of gradients. */
+array stop_gradient(const array& a, StreamOrDevice s = {});
+
+/** Round a floating point number */
+array round(const array& a, int decimals, StreamOrDevice s = {});
+inline array round(const array& a, StreamOrDevice s = {}) {
+  return round(a, 0, s);
+}
+
+/** Matrix-matrix multiplication. */
+array matmul(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Gather array entries given indices and slices */
+array gather(
+    const array& a,
+    const std::vector<array>& indices,
+    const std::vector<int>& axes,
+    const Shape& slice_sizes,
+    StreamOrDevice s = {});
+inline array gather(
+    const array& a,
+    const array& indices,
+    int axis,
+    const Shape& slice_sizes,
+    StreamOrDevice s = {}) {
+  return gather(a, {indices}, std::vector<int>{axis}, slice_sizes, s);
+}
+
+/**  Compute the Kronecker product of two arrays. */
+array kron(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Take array slices at the given indices of the specified axis. */
+array take(
+    const array& a,
+    const array& indices,
+    int axis,
+    StreamOrDevice s = {});
+array take(const array& a, int index, int axis, StreamOrDevice s = {});
+
+/** Take array entries at the given indices treating the array as flattened. */
+array take(const array& a, const array& indices, StreamOrDevice s = {});
+array take(const array& a, int index, StreamOrDevice s = {});
+
+/** Take array entries given indices along the axis */
+array take_along_axis(
+    const array& a,
+    const array& indices,
+    int axis,
+    StreamOrDevice s = {});
+
+/** Put the values into the array at the given indices along the axis */
+array put_along_axis(
+    const array& a,
+    const array& indices,
+    const array& values,
+    int axis,
+    StreamOrDevice s = {});
+
+/** Add the values into the array at the given indices along the axis */
+array scatter_add_axis(
+    const array& a,
+    const array& indices,
+    const array& values,
+    int axis,
+    StreamOrDevice s = {});
+
+/** Scatter updates to the given indices.
+ *
+ * The parameters ``indices`` and ``axes`` determine the locations of ``a``
+ * that are updated with the values in ``updates``. Assuming 1-d ``indices``
+ * for simplicity, ``indices[i]`` are the indices on axis ``axes[i]`` to which
+ * the values in ``updates`` will be applied. Note each array in
+ * ``indices`` is assigned to a corresponding axis and hence ``indices.size() ==
+ * axes.size()``. If an index/axis pair is not provided then indices along that
+ * axis are assumed to be zero.
+ *
+ * Note the rank of ``updates`` must be equal to the sum of the rank of the
+ * broadcasted ``indices`` and the rank of ``a``. In other words, assuming the
+ * arrays in ``indices`` have the same shape, ``updates.ndim() ==
+ * indices[0].ndim() + a.ndim()``. The leading dimensions of ``updates``
+ * correspond to the indices, and the remaining ``a.ndim()`` dimensions are the
+ * values that will be applied to the given location in ``a``.
+ *
+ * For example:
+ *
+ * @code
+ * auto in = zeros({4, 4}, float32);
+ * auto indices = array({2});
+ * auto updates = reshape(arange(1, 3, float32), {1, 1, 2});
+ * std::vector<int> axes{0};
+ *
+ * auto out = scatter(in, {indices}, updates, axes);
+ * @endcode
+ *
+ * will produce:
+ *
+ * @code
+ * array([[0, 0, 0, 0],
+ *        [0, 0, 0, 0],
+ *        [1, 2, 0, 0],
+ *        [0, 0, 0, 0]], dtype=float32)
+ * @endcode
+ *
+ * This scatters the two-element row vector ``[1, 2]`` starting at the ``(2,
+ * 0)`` position of ``a``.
+ *
+ * Adding another element to ``indices`` will scatter into another location of
+ * ``a``. We also have to add an another update for the new index:
+ *
+ * @code
+ * auto in = zeros({4, 4}, float32);
+ * auto indices = array({2, 0});
+ * auto updates = reshape(arange(1, 5, float32), {2, 1, 2});
+ * std::vector<int> axes{0};
+ *
+ * auto out = scatter(in, {indices}, updates, axes):
+ * @endcode
+ *
+ * will produce:
+ *
+ * @code
+ * array([[3, 4, 0, 0],
+ *        [0, 0, 0, 0],
+ *        [1, 2, 0, 0],
+ *        [0, 0, 0, 0]], dtype=float32)
+ * @endcode
+ *
+ * To control the scatter location on an additional axis, add another index
+ * array to ``indices`` and another axis to ``axes``:
+ *
+ * @code
+ * auto in = zeros({4, 4}, float32);
+ * auto indices = std::vector{array({2, 0}), array({1, 2})};
+ * auto updates = reshape(arange(1, 5, float32), {2, 1, 2});
+ * std::vector<int> axes{0, 1};
+ *
+ * auto out = scatter(in, indices, updates, axes);
+ * @endcode
+ *
+ * will produce:
+ *
+ * @code
+ * array([[0, 0, 3, 4],
+ *       [0, 0, 0, 0],
+ *       [0, 1, 2, 0],
+ *       [0, 0, 0, 0]], dtype=float32)
+ * @endcode
+ *
+ * Items in indices are broadcasted together. This means:
+ *
+ * @code
+ * auto indices = std::vector{array({2, 0}), array({1})};
+ * @endcode
+ *
+ * is equivalent to:
+ *
+ * @code
+ * auto indices = std::vector{array({2, 0}), array({1, 1})};
+ * @endcode
+ *
+ * Note, ``scatter`` does not perform bounds checking on the indices and
+ * updates.  Out-of-bounds accesses on ``a`` are undefined and typically result
+ * in unintended or invalid memory writes.
+ */
+array scatter(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+inline array scatter(
+    const array& a,
+    const array& indices,
+    const array& updates,
+    int axis,
+    StreamOrDevice s = {}) {
+  return scatter(a, {indices}, updates, std::vector<int>{axis}, s);
+}
+
+/** Scatter and add updates to given indices */
+array scatter_add(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+inline array scatter_add(
+    const array& a,
+    const array& indices,
+    const array& updates,
+    int axis,
+    StreamOrDevice s = {}) {
+  return scatter_add(a, {indices}, updates, std::vector<int>{axis}, s);
+}
+
+/** Scatter and prod updates to given indices */
+array scatter_prod(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+inline array scatter_prod(
+    const array& a,
+    const array& indices,
+    const array& updates,
+    int axis,
+    StreamOrDevice s = {}) {
+  return scatter_prod(a, {indices}, updates, std::vector<int>{axis}, s);
+}
+
+/** Scatter and max updates to given linear indices */
+array scatter_max(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+inline array scatter_max(
+    const array& a,
+    const array& indices,
+    const array& updates,
+    int axis,
+    StreamOrDevice s = {}) {
+  return scatter_max(a, {indices}, updates, std::vector<int>{axis}, s);
+}
+/** Scatter and min updates to given linear indices */
+array scatter_min(
+    const array& a,
+    const std::vector<array>& indices,
+    const array& updates,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+inline array scatter_min(
+    const array& a,
+    const array& indices,
+    const array& updates,
+    int axis,
+    StreamOrDevice s = {}) {
+  return scatter_min(a, {indices}, updates, std::vector<int>{axis}, s);
+}
+
+/** Square root the elements of an array. */
+array sqrt(const array& a, StreamOrDevice s = {});
+
+/** Square root and reciprocal the elements of an array. */
+array rsqrt(const array& a, StreamOrDevice s = {});
+
+/** Softmax of an array. */
+array softmax(
+    const array& a,
+    const std::vector<int>& axes,
+    bool precise = false,
+    StreamOrDevice s = {});
+
+/** Softmax of an array. */
+array softmax(const array& a, bool precise = false, StreamOrDevice s = {});
+
+/** Softmax of an array. */
+inline array
+softmax(const array& a, int axis, bool precise = false, StreamOrDevice s = {}) {
+  return softmax(a, std::vector<int>{axis}, precise, s);
+}
+
+/** Raise elements of a to the power of b element-wise */
+array power(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Cumulative sum of an array. */
+array cumsum(
+    const array& a,
+    int axis,
+    bool reverse = false,
+    bool inclusive = true,
+    StreamOrDevice s = {});
+
+/** Cumulative product of an array. */
+array cumprod(
+    const array& a,
+    int axis,
+    bool reverse = false,
+    bool inclusive = true,
+    StreamOrDevice s = {});
+
+/** Cumulative max of an array. */
+array cummax(
+    const array& a,
+    int axis,
+    bool reverse = false,
+    bool inclusive = true,
+    StreamOrDevice s = {});
+
+/** Cumulative min of an array. */
+array cummin(
+    const array& a,
+    int axis,
+    bool reverse = false,
+    bool inclusive = true,
+    StreamOrDevice s = {});
+
+/** General convolution with a filter */
+array conv_general(
+    array input,
+    array weight,
+    std::vector<int> stride = {},
+    std::vector<int> padding_lo = {},
+    std::vector<int> padding_hi = {},
+    std::vector<int> kernel_dilation = {},
+    std::vector<int> input_dilation = {},
+    int groups = 1,
+    bool flip = false,
+    StreamOrDevice s = {});
+
+/** General convolution with a filter */
+inline array conv_general(
+    const array& input,
+    const array& weight,
+    std::vector<int> stride = {},
+    std::vector<int> padding = {},
+    std::vector<int> kernel_dilation = {},
+    std::vector<int> input_dilation = {},
+    int groups = 1,
+    bool flip = false,
+    StreamOrDevice s = {}) {
+  return conv_general(
+      /* const array& input = */ input,
+      /* const array& weight = */ weight,
+      /* std::vector<int> stride = */ stride,
+      /* std::vector<int> padding_lo = */ padding,
+      /* std::vector<int> padding_hi = */ padding,
+      /* std::vector<int> kernel_dilation = */ kernel_dilation,
+      /* std::vector<int> input_dilation = */ input_dilation,
+      /* int groups = */ groups,
+      /* bool flip = */ flip,
+      /* StreamOrDevice s = */ s);
+}
+
+/** 1D convolution with a filter */
+array conv1d(
+    const array& input,
+    const array& weight,
+    int stride = 1,
+    int padding = 0,
+    int dilation = 1,
+    int groups = 1,
+    StreamOrDevice s = {});
+
+/** 2D convolution with a filter */
+array conv2d(
+    const array& input,
+    const array& weight,
+    const std::pair<int, int>& stride = {1, 1},
+    const std::pair<int, int>& padding = {0, 0},
+    const std::pair<int, int>& dilation = {1, 1},
+    int groups = 1,
+    StreamOrDevice s = {});
+
+/** 3D convolution with a filter */
+array conv3d(
+    const array& input,
+    const array& weight,
+    const std::tuple<int, int, int>& stride = {1, 1, 1},
+    const std::tuple<int, int, int>& padding = {0, 0, 0},
+    const std::tuple<int, int, int>& dilation = {1, 1, 1},
+    int groups = 1,
+    StreamOrDevice s = {});
+
+/** 1D transposed convolution with a filter */
+array conv_transpose1d(
+    const array& input,
+    const array& weight,
+    int stride = 1,
+    int padding = 0,
+    int dilation = 1,
+    int output_padding = 0,
+    int groups = 1,
+    StreamOrDevice s = {});
+
+/** 2D transposed convolution with a filter */
+array conv_transpose2d(
+    const array& input,
+    const array& weight,
+    const std::pair<int, int>& stride = {1, 1},
+    const std::pair<int, int>& padding = {0, 0},
+    const std::pair<int, int>& dilation = {1, 1},
+    const std::pair<int, int>& output_padding = {0, 0},
+    int groups = 1,
+    StreamOrDevice s = {});
+
+/** 3D transposed convolution with a filter */
+array conv_transpose3d(
+    const array& input,
+    const array& weight,
+    const std::tuple<int, int, int>& stride = {1, 1, 1},
+    const std::tuple<int, int, int>& padding = {0, 0, 0},
+    const std::tuple<int, int, int>& dilation = {1, 1, 1},
+    const std::tuple<int, int, int>& output_padding = {0, 0, 0},
+    int groups = 1,
+    StreamOrDevice s = {});
+
+/** Quantized matmul multiplies x with a quantized matrix w*/
+array quantized_matmul(
+    array x,
+    array w,
+    array scales,
+    std::optional<array> biases = std::nullopt,
+    bool transpose = true,
+    int group_size = 64,
+    int bits = 4,
+    const std::string& mode = "affine",
+    StreamOrDevice s = {});
+
+/** Quantize a matrix along its last axis */
+std::vector<array> quantize(
+    const array& w,
+    int group_size = 64,
+    int bits = 4,
+    const std::string& mode = "affine",
+    StreamOrDevice s = {});
+
+/** Dequantize a matrix produced by quantize() */
+array dequantize(
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases = std::nullopt,
+    int group_size = 64,
+    int bits = 4,
+    const std::string& mode = "affine",
+    StreamOrDevice s = {});
+
+/** Compute matrix products with matrix-level gather. */
+array gather_qmm(
+    const array& x,
+    const array& w,
+    const array& scales,
+    const std::optional<array>& biases = std::nullopt,
+    std::optional<array> lhs_indices = std::nullopt,
+    std::optional<array> rhs_indices = std::nullopt,
+    bool transpose = true,
+    int group_size = 64,
+    int bits = 4,
+    const std::string& mode = "affine",
+    bool sorted_indices = false,
+    StreamOrDevice s = {});
+
+/** Returns a contraction of a and b over multiple dimensions. */
+array tensordot(
+    const array& a,
+    const array& b,
+    const int axis = 2,
+    StreamOrDevice s = {});
+
+array tensordot(
+    const array& a,
+    const array& b,
+    const std::vector<int>& axes_a,
+    const std::vector<int>& axes_b,
+    StreamOrDevice s = {});
+
+/** Compute the outer product of two vectors. */
+array outer(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Compute the inner product of two vectors. */
+array inner(const array& a, const array& b, StreamOrDevice s = {});
+
+/** Compute D = beta * C + alpha * (A @ B) */
+array addmm(
+    array c,
+    array a,
+    array b,
+    const float& alpha = 1.f,
+    const float& beta = 1.f,
+    StreamOrDevice s = {});
+
+/** Compute matrix product with block masking */
+array block_masked_mm(
+    array a,
+    array b,
+    int block_size,
+    std::optional<array> mask_out = std::nullopt,
+    std::optional<array> mask_lhs = std::nullopt,
+    std::optional<array> mask_rhs = std::nullopt,
+    StreamOrDevice s = {});
+
+/** Compute matrix product with matrix-level gather */
+array gather_mm(
+    array a,
+    array b,
+    std::optional<array> lhs_indices = std::nullopt,
+    std::optional<array> rhs_indices = std::nullopt,
+    bool sorted_indices = false,
+    StreamOrDevice s = {});
+
+/**
+ * Compute a matrix product but segment the inner dimension and write the
+ * result separately for each segment.
+ */
+array segmented_mm(array a, array b, array segments, StreamOrDevice s = {});
+
+/** Extract a diagonal or construct a diagonal array */
+array diagonal(
+    const array& a,
+    int offset = 0,
+    int axis1 = 0,
+    int axis2 = 1,
+    StreamOrDevice s = {});
+
+/** Extract diagonal from a 2d array or create a diagonal matrix. */
+array diag(const array& a, int k = 0, StreamOrDevice s = {});
+
+/** Return the sum along a specified diagonal in the given array. */
+array trace(
+    const array& a,
+    int offset,
+    int axis1,
+    int axis2,
+    Dtype dtype,
+    StreamOrDevice s = {});
+array trace(
+    const array& a,
+    int offset,
+    int axis1,
+    int axis2,
+    StreamOrDevice s = {});
+array trace(const array& a, StreamOrDevice s = {});
+
+/**
+ * Implements the identity function but allows injecting dependencies to other
+ * arrays. This ensures that these other arrays will have been computed
+ * when the outputs of this function are computed.
+ */
+std::vector<array> depends(
+    const std::vector<array>& inputs,
+    const std::vector<array>& dependencies);
+
+/** convert an array to an atleast ndim array */
+array atleast_1d(const array& a, StreamOrDevice s = {});
+std::vector<array> atleast_1d(
+    const std::vector<array>& a,
+    StreamOrDevice s = {});
+array atleast_2d(const array& a, StreamOrDevice s = {});
+std::vector<array> atleast_2d(
+    const std::vector<array>& a,
+    StreamOrDevice s = {});
+array atleast_3d(const array& a, StreamOrDevice s = {});
+std::vector<array> atleast_3d(
+    const std::vector<array>& a,
+    StreamOrDevice s = {});
+
+/**
+ * Extract the number of elements along some axes as a scalar array. Used to
+ * allow shape dependent shapeless compilation (pun intended).
+ */
+array number_of_elements(
+    const array& a,
+    std::vector<int> axes,
+    bool inverted,
+    Dtype dtype = int32,
+    StreamOrDevice s = {});
+
+array conjugate(const array& a, StreamOrDevice s = {});
+
+/** Bitwise and. */
+array bitwise_and(const array& a, const array& b, StreamOrDevice s = {});
+array operator&(const array& a, const array& b);
+
+/** Bitwise inclusive or. */
+array bitwise_or(const array& a, const array& b, StreamOrDevice s = {});
+array operator|(const array& a, const array& b);
+
+/** Bitwise exclusive or. */
+array bitwise_xor(const array& a, const array& b, StreamOrDevice s = {});
+array operator^(const array& a, const array& b);
+
+/** Shift bits to the left. */
+array left_shift(const array& a, const array& b, StreamOrDevice s = {});
+array operator<<(const array& a, const array& b);
+
+/** Shift bits to the right. */
+array right_shift(const array& a, const array& b, StreamOrDevice s = {});
+array operator>>(const array& a, const array& b);
+
+/** Invert the bits. */
+array bitwise_invert(const array& a, StreamOrDevice s = {});
+array operator~(const array& a);
+
+array view(const array& a, const Dtype& dtype, StreamOrDevice s = {});
+
+/** Roll elements along an axis and introduce them on the other side */
+array roll(const array& a, int shift, StreamOrDevice s = {});
+array roll(const array& a, const Shape& shift, StreamOrDevice s = {});
+array roll(const array& a, int shift, int axis, StreamOrDevice s = {});
+array roll(
+    const array& a,
+    int shift,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+array roll(const array& a, const Shape& shift, int axis, StreamOrDevice s = {});
+array roll(
+    const array& a,
+    const Shape& shift,
+    const std::vector<int>& axes,
+    StreamOrDevice s = {});
+
+/* The real part of a complex array. */
+array real(const array& a, StreamOrDevice s = {});
+
+/* The imaginary part of a complex array. */
+array imag(const array& a, StreamOrDevice s = {});
+
+/* Ensure the array's underlying memory is contiguous. */
+array contiguous(
+    const array& a,
+    bool allow_col_major = false,
+    StreamOrDevice s = {});
+
+/** @} */
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/primitives.cpp b/ml-stable-diffusion/mlx/mlx/primitives.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..655a5591096071764b40a047a16e63ca1bee4ff8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/primitives.cpp
@@ -0,0 +1,5574 @@
+// Copyright © 2023-2024 Apple Inc.
+
+// Required for using M_2_SQRTPI in MSVC.
+#define _USE_MATH_DEFINES
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <numeric>
+#include <sstream>
+#include <stdexcept>
+
+#include "mlx/backend/common/utils.h"
+#include "mlx/fft.h"
+#include "mlx/linalg.h"
+#include "mlx/ops.h"
+#include "mlx/primitives.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+namespace {
+
+std::tuple<array, array, int> vmap_binary_op(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes,
+    const Stream& stream) {
+  assert(inputs.size() == 2);
+  assert(axes.size() == 2);
+
+  if (axes[0] == -1 && axes[1] == -1) {
+    return {inputs[0], inputs[1], -1};
+  }
+
+  auto a = inputs[0];
+  auto b = inputs[1];
+  int ndim = std::max(a.ndim() + (axes[0] == -1), b.ndim() + (axes[1] == -1));
+
+  auto expand_dims = [stream, ndim](auto in) {
+    auto shape = in.shape();
+    shape.insert(shape.begin(), ndim - shape.size(), 1);
+    return reshape(in, shape, stream);
+  };
+
+  int to_ax = (ndim - a.ndim()) + axes[0];
+  int from_ax = (ndim - b.ndim()) + axes[1];
+  a = expand_dims(a);
+  b = expand_dims(b);
+
+  if (from_ax != to_ax) {
+    std::vector<int> tdims(b.ndim());
+    std::iota(tdims.begin(), tdims.end(), 0);
+    tdims.erase(tdims.begin() + from_ax);
+    tdims.insert(tdims.begin() + to_ax, from_ax);
+    b = transpose(b, tdims, stream);
+  }
+  return {a, b, to_ax};
+}
+
+std::tuple<array, array, array, int> vmap_ternary_op(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes,
+    const Stream& stream) {
+  assert(inputs.size() == 3);
+  assert(axes.size() == 3);
+
+  if (axes[0] == -1 && axes[1] == -1 && axes[2] == -1) {
+    return {inputs[0], inputs[1], inputs[2], -1};
+  }
+
+  auto a = inputs[0];
+  auto b = inputs[1];
+  auto c = inputs[2];
+  int ndim = std::max(
+      {a.ndim() + (axes[0] == -1),
+       b.ndim() + (axes[1] == -1),
+       c.ndim() + (axes[2] == -1)});
+
+  auto expand_dims = [stream, ndim](auto in) {
+    auto shape = in.shape();
+    shape.insert(shape.begin(), ndim - shape.size(), 1);
+    return reshape(in, shape, stream);
+  };
+
+  int to_ax = (ndim - a.ndim()) + axes[0];
+  int from_ax1 = (ndim - b.ndim()) + axes[1];
+  int from_ax2 = (ndim - c.ndim()) + axes[2];
+  a = expand_dims(a);
+  b = expand_dims(b);
+  c = expand_dims(c);
+
+  auto find_tdims = [](auto x, int to_ax, int from_ax) {
+    std::vector<int> tdims(x.ndim());
+    std::iota(tdims.begin(), tdims.end(), 0);
+    tdims.erase(tdims.begin() + from_ax);
+    tdims.insert(tdims.begin() + to_ax, from_ax);
+    return tdims;
+  };
+
+  if (to_ax != from_ax1) {
+    std::vector<int> tdims = find_tdims(b, to_ax, from_ax1);
+    b = transpose(b, tdims, stream);
+  }
+
+  if (to_ax != from_ax2) {
+    std::vector<int> tdims = find_tdims(c, to_ax, from_ax2);
+    c = transpose(c, tdims, stream);
+  }
+  return {a, b, c, to_ax};
+}
+
+// Calculate the gradient wrt to the weights of the following calculation
+//
+// y = gather_mm(x, w.T, lhs_indices, rhs_indices, sorted)
+//
+// Note the transpose above. This function returns the gradient for w.T so if w
+// was used instead then one needs to transpose the returned gradient.
+//
+// We define it as a separate function to reuse it for gather_mm and
+// gather_qmm.
+array gather_mm_grad(
+    const array& x,
+    const array& dy,
+    const array& lhs_indices,
+    const array& rhs_indices,
+    bool sorted,
+    Shape batch_shape,
+    const Stream& s) {
+  int M = x.shape(-2);
+  int K = x.shape(-1);
+  int N = dy.shape(-1);
+  int num_segments = std::accumulate(
+      batch_shape.begin(), batch_shape.end(), 1, std::multiplies<int>());
+  batch_shape.push_back(N);
+  batch_shape.push_back(K);
+
+  // If the indices are sorted then it means that we can do the whole gradient
+  // computation via a segmented matmul. We just need to calculate the segments
+  // using the indices.
+  if (sorted) {
+    auto segments = zeros({num_segments}, uint32, s);
+    segments = scatter_add_axis(segments, rhs_indices, array(M, uint32), 0, s);
+    segments = cumsum(segments, 0, false, true, s);
+    segments = concatenate({array({0}, {1}, uint32), segments}, 0, s);
+    segments = as_strided(segments, {num_segments, 2}, {1, 1}, 0, s);
+
+    return reshape(
+        segmented_mm(
+            swapaxes(flatten(dy, 0, -2, s), 0, 1, s),
+            flatten(x, 0, -2, s),
+            segments,
+            s),
+        std::move(batch_shape),
+        s);
+  }
+
+  // Otherwise we need to gather matmul the dy and then scatter add it to the
+  // correct locations.
+  else {
+    // TODO: If the lhs indices wasn't provided, this is always a sorted matmul
+    //       so we should add that check.
+    auto dw = gather_mm(
+        swapaxes(dy, -1, -2, s), x, std::nullopt, lhs_indices, false, s);
+    return reshape(
+        scatter_add(
+            zeros({num_segments, N, K}, dw.dtype(), s),
+            rhs_indices,
+            expand_dims(dw, -3, s),
+            0,
+            s),
+        std::move(batch_shape),
+        s);
+  }
+}
+
+} // namespace
+
+std::vector<array> Primitive::jvp(
+    const std::vector<array>&,
+    const std::vector<array>&,
+    const std::vector<int>&) {
+  std::ostringstream msg;
+  msg << "[Primitive::jvp] Not implemented for ";
+  msg << name();
+  msg << ".";
+  throw std::invalid_argument(msg.str());
+}
+
+std::vector<array> Primitive::vjp(
+    const std::vector<array>&,
+    const std::vector<array>&,
+    const std::vector<int>&,
+    const std::vector<array>&) {
+  std::ostringstream msg;
+  msg << "[Primitive::vjp] Not implemented for ";
+  msg << name();
+  msg << ".";
+  throw std::invalid_argument(msg.str());
+}
+
+std::pair<std::vector<array>, std::vector<int>> Primitive::vmap(
+    const std::vector<array>&,
+    const std::vector<int>&) {
+  std::ostringstream msg;
+  msg << "[Primitive::vmap] Not implemented for ";
+  msg << name();
+  msg << ".";
+  throw std::invalid_argument(msg.str());
+}
+
+std::vector<Shape> Primitive::output_shapes(const std::vector<array>&) {
+  std::ostringstream msg;
+  msg << "[Primitive::output_shapes] ";
+  msg << name();
+  msg << " cannot infer output shapes.";
+  throw std::invalid_argument(msg.str());
+}
+
+std::vector<array> Abs::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Abs::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {multiply(tangents[0], sign(primals[0], stream()), stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Abs::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{abs(inputs[0], stream())}, axes};
+}
+
+std::vector<array> Add::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  return {
+      tangents.size() > 1 ? add(tangents[0], tangents[1], stream())
+                          : tangents[0]};
+}
+
+std::vector<array> Add::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  if (argnums.size() == 1) {
+    return cotangents;
+  } else {
+    return {cotangents[0], cotangents[0]};
+  }
+}
+
+std::pair<std::vector<array>, std::vector<int>> Add::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{add(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> AddMM::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  auto& cotan = cotangents[0];
+  std::vector<int> reorder(cotan.ndim());
+  std::iota(reorder.begin(), reorder.end(), 0);
+  std::iter_swap(reorder.end() - 1, reorder.end() - 2);
+  for (auto arg : argnums) {
+    if (arg == 0) {
+      // M X N * (K X N).T -> M X K
+      auto cotan_scaled = cotan;
+      if (alpha_ != 1.) {
+        auto alpha_arr = array(alpha_, cotan.dtype());
+        cotan_scaled = (multiply(alpha_arr, cotan_scaled, stream()));
+      }
+      vjps.push_back(matmul(
+          cotan_scaled, transpose(primals[1], reorder, stream()), stream()));
+    } else if (arg == 1) {
+      // (M X K).T * M X N -> K X N
+      auto cotan_scaled = cotan;
+      if (alpha_ != 1.) {
+        auto alpha_arr = array(alpha_, cotan.dtype());
+        cotan_scaled = (multiply(alpha_arr, cotan_scaled, stream()));
+      }
+      vjps.push_back(matmul(
+          transpose(primals[0], reorder, stream()), cotan_scaled, stream()));
+    } else {
+      auto cotan_scaled = cotan;
+      if (beta_ != 1.) {
+        auto beta_arr = array(beta_, cotan.dtype());
+        cotan_scaled = (multiply(beta_arr, cotan_scaled, stream()));
+      }
+      vjps.push_back(cotan_scaled);
+    }
+  }
+  return vjps;
+}
+
+std::vector<array> AddMM::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  std::vector<array> jvp;
+  for (int i = 0; i < argnums.size(); ++i) {
+    auto arg = argnums[i];
+    if (arg == 0) {
+      if (jvp.empty()) {
+        jvp.push_back(matmul(tangents[i], primals[1], stream()));
+      } else {
+        jvp[0] = addmm(jvp[0], tangents[i], primals[1], 1.0f, 1.0f, stream());
+      }
+    } else if (arg == 1) {
+      if (jvp.empty()) {
+        jvp.push_back(matmul(primals[0], tangents[i], stream()));
+      } else {
+        jvp[0] = addmm(jvp[0], primals[0], tangents[i], 1.0f, 1.0f, stream());
+      }
+    } else {
+      if (jvp.empty()) {
+        jvp.push_back(tangents[i]);
+      } else {
+        jvp[0] = add(jvp[0], tangents[i], stream());
+      }
+    }
+  }
+  return jvp;
+}
+
+bool AddMM::is_equivalent(const Primitive& other) const {
+  const AddMM& a_other = static_cast<const AddMM&>(other);
+  return (alpha_ == a_other.alpha_ && beta_ == a_other.beta_);
+}
+
+std::pair<std::vector<array>, std::vector<int>> AddMM::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto maybe_move_ax = [this](auto& arr, auto ax) {
+    return ax > 0 ? moveaxis(arr, ax, 0, stream()) : arr;
+  };
+  auto a = maybe_move_ax(inputs[0], axes[0]);
+  auto b = maybe_move_ax(inputs[1], axes[1]);
+  auto c = maybe_move_ax(inputs[2], axes[2]);
+  return {{addmm(c, a, b, alpha_, beta_, stream())}, {0}};
+}
+
+bool Arange::is_equivalent(const Primitive& other) const {
+  const Arange& a_other = static_cast<const Arange&>(other);
+  return (
+      start_ == a_other.start_ && stop_ == a_other.stop_ &&
+      step_ == a_other.step_);
+}
+
+std::vector<Shape> Arange::output_shapes(const std::vector<array>&) {
+  auto real_size = std::ceil((stop_ - start_) / step_);
+  return {{std::max(static_cast<int>(real_size), 0)}};
+}
+
+std::vector<array> ArcCos::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> ArcCos::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  array one = array(1., primals[0].dtype());
+  array t = subtract(one, square(primals[0], stream()), stream());
+  array denom = negative(rsqrt(t, stream()), stream());
+  return {multiply(tangents[0], denom, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> ArcCos::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{arccos(inputs[0], stream())}, axes};
+}
+
+std::vector<array> ArcCosh::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> ArcCosh::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  array one = array(1., primals[0].dtype());
+  array t = subtract(square(primals[0], stream()), one, stream());
+  return {multiply(tangents[0], rsqrt(t, stream()), stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> ArcCosh::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{arccosh(inputs[0], stream())}, axes};
+}
+
+std::vector<array> ArcSin::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> ArcSin::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  array one = array(1., primals[0].dtype());
+  array t = subtract(one, square(primals[0], stream()), stream());
+  return {multiply(tangents[0], rsqrt(t, stream()), stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> ArcSin::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{arcsin(inputs[0], stream())}, axes};
+}
+
+std::vector<array> ArcSinh::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> ArcSinh::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  array one = array(1., primals[0].dtype());
+  array t = add(square(primals[0], stream()), one, stream());
+  return {multiply(tangents[0], rsqrt(t, stream()), stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> ArcSinh::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{arcsinh(inputs[0], stream())}, axes};
+}
+
+std::vector<array> ArcTan::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> ArcTan::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  array one = array(1., primals[0].dtype());
+  array t = add(one, square(primals[0], stream()), stream());
+  return {divide(tangents[0], t, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> ArcTan::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{arctan(inputs[0], stream())}, axes};
+}
+
+std::vector<array> ArcTan2::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 2);
+  assert(argnums.size() == 2);
+
+  const auto& s = stream();
+  const array& x1 = primals[0];
+  const array& x2 = primals[1];
+  const array& dy = cotangents[0];
+
+  std::vector<array> grads;
+  array dy_over_x1_x2_squared =
+      divide(dy, add(square(x1, s), square(x2, s)), s);
+
+  for (auto arg : argnums) {
+    if (arg == 0) {
+      grads.emplace_back(multiply(x2, dy_over_x1_x2_squared, s));
+    } else {
+      grads.emplace_back(multiply(negative(x1, s), dy_over_x1_x2_squared, s));
+    }
+  }
+
+  return grads;
+}
+
+std::vector<array> ArcTan2::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 2);
+  assert(argnums.size() == 2);
+
+  const auto& s = stream();
+  const array& x1 = primals[0];
+  const array& x2 = primals[1];
+  const array& dx1 = tangents[0];
+  const array& dx2 = tangents[1];
+
+  return {divide(
+      subtract(multiply(x2, dx1, s), multiply(x1, dx2, s), s),
+      add(square(x1, s), square(x2, s), s),
+      s)};
+}
+
+std::pair<std::vector<array>, std::vector<int>> ArcTan2::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 2);
+  assert(axes.size() == 2);
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{arctan2(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> ArcTanh::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> ArcTanh::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  array one = array(1., primals[0].dtype());
+  array t = subtract(one, square(primals[0], stream()), stream());
+  return {divide(tangents[0], t, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> ArcTanh::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{arctanh(inputs[0], stream())}, axes};
+}
+
+std::pair<std::vector<array>, std::vector<int>> ArgPartition::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+
+  int axis_left = axes[0] >= 0 && axes[0] <= axis_;
+  return {{argpartition(inputs[0], axis_ + axis_left, stream())}, axes};
+}
+
+std::vector<array> ArgPartition::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>&,
+    const std::vector<int>&,
+    const std::vector<array>&) {
+  return {zeros_like(primals[0], stream())};
+}
+
+std::vector<array> ArgPartition::jvp(
+    const std::vector<array>&,
+    const std::vector<array>& tangents,
+    const std::vector<int>&) {
+  return {zeros_like(tangents[0], stream())};
+}
+
+bool ArgPartition::is_equivalent(const Primitive& other) const {
+  const ArgPartition& r_other = static_cast<const ArgPartition&>(other);
+  return axis_ == r_other.axis_ && kth_ == r_other.kth_;
+}
+
+bool ArgReduce::is_equivalent(const Primitive& other) const {
+  const ArgReduce& r_other = static_cast<const ArgReduce&>(other);
+  return reduce_type_ == r_other.reduce_type_ && axis_ == r_other.axis_;
+}
+
+std::pair<std::vector<array>, std::vector<int>> ArgReduce::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  int reduce_ax = axis_ + (axes[0] >= 0 && axis_ >= axes[0]);
+  auto& in = inputs[0];
+  std::vector<array> out;
+  if (reduce_type_ == ArgReduce::ArgMin) {
+    out.push_back(argmin(in, reduce_ax, true, stream()));
+  } else {
+    out.push_back(argmax(in, reduce_ax, true, stream()));
+  }
+  return {out, axes};
+}
+
+std::vector<array> ArgReduce::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>&,
+    const std::vector<int>&,
+    const std::vector<array>&) {
+  return {zeros_like(primals[0], stream())};
+}
+
+std::vector<array> ArgReduce::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>&,
+    const std::vector<int>&) {
+  auto shape = output_shapes(primals)[0];
+  return {zeros(shape, uint32, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> ArgSort::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+
+  int axis_left = axes[0] >= 0 && axes[0] <= axis_;
+  return {{argsort(inputs[0], axis_ + axis_left, stream())}, axes};
+}
+
+std::vector<Shape> ArgReduce::output_shapes(const std::vector<array>& inputs) {
+  auto out_shape = inputs[0].shape();
+  out_shape[axis_] = 1;
+  return {std::move(out_shape)};
+}
+
+bool ArgSort::is_equivalent(const Primitive& other) const {
+  const ArgSort& r_other = static_cast<const ArgSort&>(other);
+  return axis_ == r_other.axis_;
+}
+
+std::vector<array> ArgSort::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>&,
+    const std::vector<int>&,
+    const std::vector<array>&) {
+  return {zeros_like(primals[0], stream())};
+}
+
+std::vector<array> ArgSort::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>&,
+    const std::vector<int>&) {
+  return {zeros(primals[0].shape(), uint32, stream())};
+}
+
+std::vector<array> AsType::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  if (cotangents[0].dtype() != dtype_) {
+    throw std::invalid_argument(
+        "[astype] Type of cotangents does not match primal output type.");
+  }
+  return {astype(cotangents[0], primals[0].dtype(), stream())};
+}
+
+std::vector<array> AsType::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  return {astype(tangents[0], dtype_, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> AsType::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  return {{astype(inputs[0], dtype_, stream())}, axes};
+}
+
+bool AsType::is_equivalent(const Primitive& other) const {
+  const AsType& a_other = static_cast<const AsType&>(other);
+  return dtype_ == a_other.dtype_;
+}
+
+std::vector<array> AsStrided::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(argnums.size() == 1);
+
+  // Extract the sizes and cast them to ints
+  int grad_size = primals[0].size();
+  int cotangents_size = cotangents[0].size();
+
+  // Make a flat container to hold the gradients
+  auto grad = zeros_like(primals[0], stream());
+  grad = reshape(grad, {grad_size}, stream());
+
+  // Create the indices that map output to input
+  auto idx = arange(grad_size, stream());
+  idx = as_strided(idx, shape_, strides_, offset_, stream());
+  idx = reshape(idx, {cotangents_size}, stream());
+
+  // Reshape the cotangentsgent for use with scatter
+  auto flat_cotangents = reshape(cotangents[0], {cotangents_size, 1}, stream());
+
+  // Finally accumulate the gradients and reshape them to look like the input
+  grad = scatter_add(grad, idx, flat_cotangents, 0, stream());
+  grad = reshape(grad, primals[0].shape(), stream());
+
+  return {grad};
+}
+
+std::vector<array> AsStrided::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+
+  return {as_strided(tangents[0], shape_, strides_, offset_, stream())};
+}
+
+bool AsStrided::is_equivalent(const Primitive& other) const {
+  const AsStrided& a_other = static_cast<const AsStrided&>(other);
+  return shape_ == a_other.shape_ && strides_ == a_other.strides_ &&
+      offset_ == a_other.offset_;
+}
+
+bool BitwiseBinary::is_equivalent(const Primitive& other) const {
+  const BitwiseBinary& a_other = static_cast<const BitwiseBinary&>(other);
+  return op_ == a_other.op_;
+}
+
+std::pair<std::vector<array>, std::vector<int>> BitwiseBinary::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {
+      {array(
+          a.shape(),
+          a.dtype(),
+          std::make_shared<BitwiseBinary>(stream(), op_),
+          {a, b})},
+      {to_ax}};
+}
+
+std::vector<array> BitwiseBinary::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 2);
+  std::vector<array> vjps = {zeros_like(tangents[0], stream())};
+  if (argnums.size() > 1) {
+    vjps.push_back(vjps.back());
+  }
+  return vjps;
+}
+
+std::vector<array> BitwiseBinary::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array>
+broadcast_vjp(const array& primal, const array& cotan, const Stream& s) {
+  // Reduce cotangents to the shape of the primal
+  auto& shape = primal.shape();
+  int diff = cotan.ndim() - shape.size();
+  std::vector<int> squeeze_axes(diff);
+  std::iota(squeeze_axes.begin(), squeeze_axes.end(), 0);
+  auto reduce_axes = squeeze_axes;
+  for (int i = diff; i < cotan.ndim(); ++i) {
+    if (shape[i - diff] != cotan.shape(i)) {
+      reduce_axes.push_back(i);
+    }
+  }
+  return {squeeze(sum(cotan, reduce_axes, true, s), squeeze_axes, s)};
+}
+
+std::vector<array> Broadcast::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>&,
+    const std::vector<array>&) {
+  return broadcast_vjp(primals[0], cotangents[0], stream());
+}
+
+std::vector<array> Broadcast::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  return {array(
+      shape_,
+      tangents[0].dtype(),
+      std::make_shared<Broadcast>(stream(), shape_),
+      tangents)};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Broadcast::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto ax = axes[0];
+  auto& in = inputs[0];
+  if (ax >= 0) {
+    int diff = shape_.size() - in.ndim() + 1;
+    assert(diff >= 0);
+    shape_.insert(shape_.begin() + ax + diff, in.shape(ax));
+    ax += diff;
+  }
+  return {{broadcast_to(in, shape_, stream())}, {ax}};
+}
+
+bool Broadcast::is_equivalent(const Primitive& other) const {
+  const Broadcast& b_other = static_cast<const Broadcast&>(other);
+  return shape_ == b_other.shape_;
+}
+
+Shape Broadcast::output_shape(const std::vector<array>& inputs) {
+  auto shape = inputs[0].shape();
+  for (int i = 1; i < inputs.size(); ++i) {
+    shape = broadcast_shapes(shape, inputs[i].shape());
+  }
+  return shape;
+}
+
+std::vector<Shape> Broadcast::output_shapes(const std::vector<array>& inputs) {
+  if (inputs.size() < 2) {
+    if (broadcast_shapes(inputs[0].shape(), shape_) != shape_) {
+      throw std::invalid_argument(
+          "[Broadcast] Unable to infer broadcast shape");
+    }
+    return {shape_};
+  }
+  return {output_shape(inputs)};
+};
+
+std::vector<array> BroadcastAxes::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>&,
+    const std::vector<array>&) {
+  return broadcast_vjp(primals[0], cotangents[0], stream());
+}
+
+std::vector<array> BroadcastAxes::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  return {array(
+      output_shape(primals, ignore_axes_),
+      tangents[0].dtype(),
+      std::make_shared<BroadcastAxes>(stream(), ignore_axes_),
+      tangents)};
+}
+
+std::pair<std::vector<array>, std::vector<int>> BroadcastAxes::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  throw std::invalid_argument("[BroadcastAxes] VMAP NYI");
+}
+
+bool BroadcastAxes::is_equivalent(const Primitive& other) const {
+  const auto& b_other = static_cast<const BroadcastAxes&>(other);
+  return ignore_axes_ == b_other.ignore_axes_;
+}
+
+Shape BroadcastAxes::output_shape(
+    const std::vector<array>& inputs,
+    const std::vector<int>& ignore_axes) {
+  auto shape = Shape{};
+  for (auto& in : inputs) {
+    auto in_shape = in.shape();
+    for (auto it = ignore_axes.rbegin(); it != ignore_axes.rend(); ++it) {
+      in_shape.erase(in_shape.begin() + in.ndim() + *it);
+    }
+    shape = broadcast_shapes(shape, in_shape);
+  }
+  int dims = ignore_axes.size() + shape.size();
+  for (auto ax : ignore_axes) {
+    shape.insert(shape.begin() + dims + ax, inputs[0].shape(ax));
+  }
+  return shape;
+}
+
+std::vector<Shape> BroadcastAxes::output_shapes(
+    const std::vector<array>& inputs) {
+  return {output_shape(inputs, ignore_axes_)};
+}
+
+std::vector<array> Ceil::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Ceil::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {zeros_like(primals[0], stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Ceil::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{ceil(inputs[0], stream())}, axes};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Cholesky::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto ax = axes[0] >= 0 ? 0 : -1;
+  auto a = axes[0] > 0 ? moveaxis(inputs[0], axes[0], 0, stream()) : inputs[0];
+  return {{linalg::cholesky(a, upper_, stream())}, {ax}};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Eig::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+
+  bool needs_move = axes[0] >= (inputs[0].ndim() - 2);
+  auto a = needs_move ? moveaxis(inputs[0], axes[0], 0, stream()) : inputs[0];
+  auto ax = needs_move ? 0 : axes[0];
+
+  std::vector<array> outputs;
+  if (compute_eigenvectors_) {
+    auto [values, vectors] = linalg::eig(a, stream());
+    outputs = {values, vectors};
+  } else {
+    outputs = {linalg::eigvals(a, stream())};
+  }
+
+  return {outputs, std::vector<int>(outputs.size(), ax)};
+}
+
+std::vector<Shape> Eig::output_shapes(const std::vector<array>& inputs) {
+  auto shape = inputs[0].shape();
+  shape.pop_back(); // Remove last dimension for eigenvalues
+  if (compute_eigenvectors_) {
+    return {
+        std::move(shape), inputs[0].shape()}; // Eigenvalues and eigenvectors
+  } else {
+    return {std::move(shape)}; // Only eigenvalues
+  }
+}
+
+bool Eig::is_equivalent(const Primitive& other) const {
+  auto& e_other = static_cast<const Eig&>(other);
+  return compute_eigenvectors_ == e_other.compute_eigenvectors_;
+}
+
+std::pair<std::vector<array>, std::vector<int>> Eigh::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+
+  bool needs_move = axes[0] >= (inputs[0].ndim() - 2);
+  auto a = needs_move ? moveaxis(inputs[0], axes[0], 0, stream()) : inputs[0];
+  auto ax = needs_move ? 0 : axes[0];
+
+  std::vector<array> outputs;
+  if (compute_eigenvectors_) {
+    auto [values, vectors] = linalg::eigh(a, uplo_, stream());
+    outputs = {values, vectors};
+  } else {
+    outputs = {linalg::eigvalsh(a, uplo_, stream())};
+  }
+
+  return {outputs, std::vector<int>(outputs.size(), ax)};
+}
+
+std::vector<Shape> Eigh::output_shapes(const std::vector<array>& inputs) {
+  auto shape = inputs[0].shape();
+  shape.pop_back(); // Remove last dimension for eigenvalues
+  if (compute_eigenvectors_) {
+    return {
+        std::move(shape), inputs[0].shape()}; // Eigenvalues and eigenvectors
+  } else {
+    return {std::move(shape)}; // Only eigenvalues
+  }
+}
+
+bool Eigh::is_equivalent(const Primitive& other) const {
+  auto& e_other = static_cast<const Eigh&>(other);
+  return uplo_ == e_other.uplo_ &&
+      compute_eigenvectors_ == e_other.compute_eigenvectors_;
+}
+
+std::vector<array> Concatenate::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  auto& cotan = cotangents[0];
+  Shape start(cotan.ndim(), 0);
+  Shape stop = cotan.shape();
+
+  Shape sizes;
+  sizes.push_back(0);
+  for (auto& p : primals) {
+    sizes.push_back(p.shape(axis_));
+  }
+  std::partial_sum(sizes.cbegin(), sizes.cend(), sizes.begin());
+
+  std::vector<array> grads;
+  for (auto i : argnums) {
+    start[axis_] = sizes[i];
+    stop[axis_] = sizes[i + 1];
+    grads.push_back(slice(cotan, start, stop, stream()));
+  }
+  return grads;
+}
+
+std::vector<array> Concatenate::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  std::vector<int> argidx(argnums.size());
+  std::iota(argidx.begin(), argidx.end(), 0);
+  std::sort(argidx.begin(), argidx.end(), [&argnums](int a, int b) {
+    return argnums[a] < argnums[b];
+  });
+
+  std::vector<array> vals;
+  for (int i = 0, j = 0; i < primals.size(); ++i) {
+    if (j < argnums.size() && argnums[argidx[j]] == i) {
+      vals.push_back(tangents[argidx[j++]]);
+    } else {
+      vals.push_back(zeros_like(primals[i], stream()));
+    }
+  }
+  return {concatenate(vals, axis_, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Concatenate::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  int out_ax = -1;
+  int first_vmap = -1;
+
+  // Find the first vmapped input
+  for (int i = 0; i < axes.size(); i++) {
+    if (axes[i] >= 0) {
+      out_ax = axes[i];
+      first_vmap = i;
+      break;
+    }
+  }
+
+  // No vmap, should we even be in here?
+  if (out_ax < 0) {
+    return {{concatenate(inputs, axis_, stream())}, {out_ax}};
+  }
+
+  // Make sure vmapped arrays have all vmapped axes in the same location and
+  // expand non-vmapped arrays to be compatible with the vmapped ones.
+  std::vector<array> t_inputs;
+  int N = inputs[first_vmap].shape(out_ax);
+  int axis = axis_ + (axis_ >= out_ax);
+  auto cat_shape = inputs[first_vmap].shape();
+  for (int i = 0; i < axes.size(); i++) {
+    if (axes[i] >= 0) {
+      if (out_ax != axes[i]) {
+        t_inputs.push_back(moveaxis(inputs[i], axes[i], out_ax, stream()));
+      } else {
+        t_inputs.push_back(inputs[i]);
+      }
+    } else {
+      cat_shape[axis] = inputs[i].shape(axis_);
+      t_inputs.push_back(broadcast_to(
+          expand_dims(inputs[i], out_ax, stream()), cat_shape, stream()));
+    }
+  }
+
+  return {{concatenate(t_inputs, axis, stream())}, {out_ax}};
+}
+
+bool Concatenate::is_equivalent(const Primitive& other) const {
+  const Concatenate& c_other = static_cast<const Concatenate&>(other);
+  return axis_ == c_other.axis_;
+}
+
+std::vector<Shape> Concatenate::output_shapes(
+    const std::vector<array>& inputs) {
+  auto shape = inputs[0].shape();
+  for (int i = 1; i < inputs.size(); ++i) {
+    shape[axis_] += inputs[i].shape(axis_);
+  }
+  return {std::move(shape)};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Conjugate::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{conjugate(inputs[0], stream())}, axes};
+}
+
+std::vector<array> Contiguous::vjp(
+    const std::vector<array>&,
+    const std::vector<array>& cotangents,
+    const std::vector<int>&,
+    const std::vector<array>&) {
+  return {cotangents};
+}
+
+std::vector<array> Contiguous::jvp(
+    const std::vector<array>&,
+    const std::vector<array>& tangents,
+    const std::vector<int>&) {
+  return {tangents};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Contiguous::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  return {{contiguous(inputs[0], allow_col_major_, stream())}, axes};
+}
+
+bool Contiguous::is_equivalent(const Primitive& other) const {
+  const Contiguous& c_other = static_cast<const Contiguous&>(other);
+  return allow_col_major_ == c_other.allow_col_major_;
+}
+
+array conv_weight_backward_patches(
+    const array& in,
+    const array& wt,
+    const array& cotan,
+    const std::vector<int>& kernel_strides,
+    const std::vector<int>& padding_lo,
+    const std::vector<int>& padding_hi,
+    StreamOrDevice s) {
+  // Resolve Padded input shapes and strides
+  Shape padding_starts(in.ndim(), 0);
+  auto padding_ends = in.shape();
+  auto in_padded_shape = in.shape();
+
+  // padded shape
+  for (int i = 1; i < in.ndim() - 1; i++) {
+    in_padded_shape[i] += padding_lo[i - 1] + padding_hi[i - 1];
+    padding_ends[i] += padding_lo[i - 1];
+    padding_starts[i] += padding_lo[i - 1];
+  }
+
+  // padded strides (contiguous)
+  Strides in_padded_strides(in.ndim(), 1);
+  for (int i = in.ndim() - 2; i >= 0; --i) {
+    in_padded_strides[i] = in_padded_strides[i + 1] * in_padded_shape[i + 1];
+  }
+
+  // Pad input
+  std::vector<int> padded_axes(in.ndim() - 2, 0);
+  std::iota(padded_axes.begin(), padded_axes.end(), 1);
+  auto in_padded =
+      pad(in,
+          padded_axes,
+          Shape(padding_lo.begin(), padding_lo.end()),
+          Shape(padding_hi.begin(), padding_hi.end()),
+          array(0, in.dtype()),
+          "constant",
+          s);
+
+  // Resolve strided patches
+
+  // patches are shaped as
+  // (batch_dim, out_spatial_dims, weight_spatial_dims, in_channels)
+  Shape patches_shape{cotan.shape().begin(), cotan.shape().end() - 1};
+  patches_shape.insert(
+      patches_shape.end(), wt.shape().begin() + 1, wt.shape().end());
+
+  // Resolve patch strides
+  int n_spatial_dim = in.ndim() - 2;
+  Strides patches_strides(patches_shape.size(), 1);
+  patches_strides[0] = in_padded_strides[0];
+  for (int i = 1; i < n_spatial_dim + 1; i++) {
+    patches_strides[i] = in_padded_strides[i] * kernel_strides[i - 1];
+  }
+  for (int i = 1; i < in.ndim(); i++) {
+    patches_strides[n_spatial_dim + i] = in_padded_strides[i];
+  }
+
+  // Make patches from in
+  auto in_patches = as_strided(in_padded, patches_shape, patches_strides, 0, s);
+
+  // Prepare for matmul
+  int O = wt.shape(0);
+  auto cotan_mat = reshape(cotan, {-1, O}, s);
+  in_patches = reshape(in_patches, {cotan_mat.shape(0), -1}, s);
+
+  auto grad = matmul(transpose(cotan_mat, {1, 0}, s), in_patches, s);
+  grad = reshape(grad, wt.shape(), s);
+  return grad;
+}
+
+namespace {
+
+// Conv helpers
+inline int conv_out_axis_size(int in_dim, int wt_dim, int stride, int padding) {
+  return ((in_dim + padding - wt_dim) / stride) + 1;
+}
+
+// Conv helpers
+inline int dilate_size(int dim, int dil) {
+  return 1 + dil * (dim - 1);
+}
+
+} // namespace
+
+Shape Convolution::conv_out_shape(
+    const Shape& in_shape,
+    const Shape& wt_shape,
+    const std::vector<int>& strides,
+    const std::vector<int>& pads_lo,
+    const std::vector<int>& pads_hi,
+    const std::vector<int>& kernel_dilation,
+    const std::vector<int>& input_dilation) {
+  int N = in_shape[0];
+  int O = wt_shape[0];
+  Shape out_shape(in_shape.size());
+  int i = 0;
+  out_shape[i++] = N;
+
+  int spatial_dims = in_shape.size() - 2;
+
+  if (strides.size() != spatial_dims) {
+    std::ostringstream msg;
+    msg << "[conv] Invalid strides " << strides << " for " << spatial_dims
+        << "D convolution.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (pads_lo.size() != spatial_dims || pads_hi.size() != spatial_dims) {
+    std::ostringstream msg;
+    msg << "[conv] Invalid padding " << pads_lo << " | " << pads_hi << " for "
+        << spatial_dims << "D convolution.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (kernel_dilation.size() != spatial_dims) {
+    std::ostringstream msg;
+    msg << "[conv] Invalid kernel dilation " << kernel_dilation << " for "
+        << spatial_dims << "D convolution.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  if (input_dilation.size() != spatial_dims) {
+    std::ostringstream msg;
+    msg << "[conv] Invalid input dilation " << input_dilation << " for "
+        << spatial_dims << "D convolution.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  for (; i < in_shape.size() - 1; i++) {
+    if (kernel_dilation[i - 1] <= 0) {
+      std::ostringstream msg;
+      msg << "[conv] Kernel dilation sizes must be positive."
+          << " Got kernel dilation " << kernel_dilation << ".";
+      throw std::invalid_argument(msg.str());
+    }
+
+    if (input_dilation[i - 1] <= 0) {
+      std::ostringstream msg;
+      msg << "[conv] Input dilation sizes must be positive."
+          << " Got input dilation " << input_dilation << ".";
+      throw std::invalid_argument(msg.str());
+    }
+
+    if (pads_lo[i - 1] < 0 || pads_hi[i - 1] < 0) {
+      std::ostringstream msg;
+      msg << "[conv] Padding sizes must be non-negative." << " Got padding "
+          << pads_lo << " | " << pads_hi << ".";
+      throw std::invalid_argument(msg.str());
+    }
+
+    if (strides[i - 1] <= 0) {
+      std::ostringstream msg;
+      msg << "[conv] Stride sizes must be positive." << " Got strides "
+          << strides << ".";
+      throw std::invalid_argument(msg.str());
+    }
+
+    int kd = dilate_size(wt_shape[i], kernel_dilation[i - 1]);
+    int id = dilate_size(in_shape[i], input_dilation[i - 1]);
+
+    out_shape[i] = conv_out_axis_size(
+        id, kd, strides[i - 1], pads_lo[i - 1] + pads_hi[i - 1]);
+
+    if (out_shape[i] <= 0) {
+      std::ostringstream msg;
+      msg << "[conv] Spatial dimensions of input after padding"
+          << " cannot be smaller than weight spatial dimensions."
+          << " Got error at axis " << i << " for input with shape " << in_shape
+          << ", padding low " << pads_lo << ", padding high " << pads_hi
+          << ", and weight of shape " << wt_shape << ".";
+      throw std::invalid_argument(msg.str());
+    }
+  }
+  out_shape[i] = O;
+
+  return out_shape;
+}
+
+std::vector<array> Convolution::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 2);
+  std::vector<array> grads;
+
+  // Collect info
+  auto& in = primals[0];
+  auto& wt = primals[1];
+  auto& cotan = cotangents[0];
+
+  auto group_transpose =
+      [this](const array& x, int group_dim, int ax_a, int ax_b) {
+        if (groups_ > 1) {
+          auto shape = x.shape();
+          if (group_dim < 0) {
+            group_dim += shape.size();
+          }
+          shape.insert(shape.begin() + group_dim, groups_);
+          shape[group_dim + 1] = shape[group_dim + 1] / groups_;
+          auto x_trans = swapaxes(
+              reshape(x, std::move(shape), stream()), ax_a, ax_b, stream());
+          return flatten(x_trans, group_dim, group_dim + 1, stream());
+        } else {
+          return swapaxes(x, 0, -1, stream());
+        }
+      };
+
+  for (int a : argnums) {
+    // Grads for input
+    if (a == 0) {
+      std::vector<int> padding_lo = padding_lo_;
+      std::vector<int> padding_hi = padding_hi_;
+
+      for (int i = 0; i < padding_lo.size(); ++i) {
+        int wt_size = 1 + kernel_dilation_[i] * (wt.shape(1 + i) - 1);
+        padding_lo[i] = wt_size - padding_lo_[i] - 1;
+
+        int in_size = 1 + input_dilation_[i] * (in.shape(1 + i) - 1);
+        int out_size = 1 + kernel_strides_[i] * (cotan.shape(1 + i) - 1);
+        padding_hi[i] = in_size - out_size + padding_hi_[i];
+      }
+
+      // Check for negative padding
+      bool has_neg_padding = false;
+      for (auto& pd : padding_lo) {
+        has_neg_padding |= (pd < 0);
+      }
+      for (auto& pd : padding_hi) {
+        has_neg_padding |= (pd < 0);
+      }
+
+      auto wt_trans = group_transpose(wt, 0, 1, -1);
+      auto grad = conv_general(
+          /* const array& input = */ cotan,
+          /* const array& weight = */ wt_trans,
+          /* std::vector<int> stride = */ input_dilation_,
+          /* std::vector<int> padding_lo = */ padding_lo,
+          /* std::vector<int> padding_hi = */ padding_hi,
+          /* std::vector<int> kernel_dilation = */ kernel_dilation_,
+          /* std::vector<int> input_dilation = */ kernel_strides_,
+          /* int groups = */ groups_,
+          /* bool flip = */ !flip_,
+          stream());
+
+      // Handle negative padding
+      if (has_neg_padding) {
+        Shape starts(grad.ndim(), 0);
+        auto stops = grad.shape();
+
+        for (int i = 0; i < grad.ndim() - 2; i++) {
+          if (padding_lo[i] < 0) {
+            starts[i + 1] -= padding_lo[i];
+          }
+          if (padding_hi[i] < 0) {
+            stops[i + 1] += padding_hi[i];
+          }
+        }
+
+        grad = slice(grad, std::move(starts), std::move(stops), stream());
+      }
+
+      grads.push_back(grad);
+    }
+    // Grads for weight
+    else if (a == 1) {
+      bool no_dilation = true;
+
+      for (int i = 0; i < input_dilation_.size(); i++) {
+        no_dilation &= (input_dilation_[i] == 1) && (kernel_dilation_[i] == 1);
+      }
+
+      if (no_dilation && !flip_ && groups_ == 1) {
+        auto grad = conv_weight_backward_patches(
+            in, wt, cotan, kernel_strides_, padding_lo_, padding_hi_, stream());
+        grads.push_back(grad);
+      } else {
+        auto padding_hi = padding_lo_;
+
+        for (int i = 0; i < padding_hi.size(); ++i) {
+          int in_size = 1 + input_dilation_[i] * (in.shape(1 + i) - 1);
+          int out_size = 1 + kernel_strides_[i] * (cotan.shape(1 + i) - 1);
+          int wt_size = 1 + kernel_dilation_[i] * (wt.shape(1 + i) - 1);
+          padding_hi[i] = out_size - in_size + wt_size - padding_hi[i] - 1;
+        }
+
+        auto cotan_trans = swapaxes(cotan, 0, -1, stream());
+        auto in_trans = group_transpose(in, -1, 0, -1);
+
+        auto grad_trans = conv_general(
+            /* const array& input = */ in_trans,
+            /* const array& weight = */ cotan_trans,
+            /* std::vector<int> stride = */ kernel_dilation_,
+            /* std::vector<int> padding_lo = */ padding_lo_,
+            /* std::vector<int> padding_hi = */ padding_hi,
+            /* std::vector<int> kernel_dilation = */ kernel_strides_,
+            /* std::vector<int> input_dilation = */ input_dilation_,
+            /* int groups = */ groups_,
+            /* bool flip = */ false,
+            stream());
+        if (flip_) {
+          auto start = Shape(grad_trans.ndim(), 0);
+          auto stop = Shape(grad_trans.ndim(), 0);
+          auto strides = Shape(grad_trans.ndim(), 1);
+          for (int i = 0; i < stop.size(); ++i) {
+            if (i >= 1 && i < stop.size() - 1) {
+              start[i] = grad_trans.shape(i);
+              stop[i] = -start[i] - 1;
+              strides[i] = -1;
+            } else {
+              stop[i] = grad_trans.shape(i);
+            }
+          }
+          grad_trans = slice(grad_trans, start, stop, strides, stream());
+        }
+        grads.push_back(swapaxes(grad_trans, 0, -1, stream()));
+      }
+    }
+  }
+
+  return grads;
+}
+
+std::pair<std::vector<array>, std::vector<int>> Convolution::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto do_conv = [&](const array& in, const array& w, int groups) {
+    return conv_general(
+        in,
+        w,
+        kernel_strides_,
+        padding_lo_,
+        padding_hi_,
+        kernel_dilation_,
+        input_dilation_,
+        groups,
+        flip_,
+        stream());
+  };
+  bool in_vmap = axes[0] >= 0;
+  bool w_vmap = axes[1] >= 0;
+  auto in = inputs[0];
+  auto w = inputs[1];
+  if (in_vmap && !w_vmap) {
+    // flatten / unflatten the batch dimension
+    // of the input / output
+    if (axes[0] > 0) {
+      in = moveaxis(in, axes[0], 0, stream());
+    }
+    auto out = do_conv(flatten(in, 0, 1, stream()), w, groups_);
+    out = unflatten(out, 0, {in.shape(0), in.shape(1)}, stream());
+    return {{out}, {0}};
+  } else if (!in_vmap && w_vmap) {
+    // flatten into the output channels of w
+    // unflatten the channels of the output
+    if (axes[1] > 0) {
+      w = moveaxis(w, axes[1], 0, stream());
+    }
+    auto out = do_conv(in, flatten(w, 0, 1, stream()), groups_);
+    out = unflatten(out, -1, {w.shape(0), w.shape(1)}, stream());
+    return {{out}, {static_cast<int>(out.ndim() - 2)}};
+  } else if (in_vmap && w_vmap) {
+    // use a group convolution when both inputs are vmapped
+    auto b = in.shape(axes[0]);
+    in = moveaxis(in, axes[0], -2, stream());
+    in = flatten(in, -2, -1, stream());
+    if (axes[1] > 0) {
+      w = moveaxis(w, axes[1], 0, stream());
+    }
+    auto c_out = w.shape(1);
+    w = flatten(w, 0, 1, stream());
+    auto out = do_conv(in, w, groups_ * b);
+    out = unflatten(out, -1, {b, c_out}, stream());
+    return {{out}, {static_cast<int>(out.ndim() - 2)}};
+  } else {
+    return {{do_conv(in, w, groups_)}, {-1}};
+  }
+}
+
+bool Convolution::is_equivalent(const Primitive& other) const {
+  const Convolution& c_other = static_cast<const Convolution&>(other);
+  return padding_lo_ == c_other.padding_lo_ &&
+      padding_hi_ == c_other.padding_hi_ &&
+      kernel_strides_ == c_other.kernel_strides_ &&
+      kernel_dilation_ == c_other.kernel_dilation_ &&
+      input_dilation_ == c_other.input_dilation_ &&
+      groups_ == c_other.groups_ && flip_ == c_other.flip_;
+}
+
+std::vector<Shape> Convolution::output_shapes(
+    const std::vector<array>& inputs) {
+  return {conv_out_shape(
+      inputs[0].shape(), // in_shape
+      inputs[1].shape(), // wt_shape
+      kernel_strides_,
+      padding_lo_,
+      padding_hi_,
+      kernel_dilation_,
+      input_dilation_)};
+}
+
+std::vector<array> Copy::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return cotangents;
+}
+
+std::vector<array> Copy::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return tangents;
+}
+
+std::pair<std::vector<array>, std::vector<int>> Copy::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{copy(inputs[0], stream())}, axes};
+}
+
+std::vector<array> Cos::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return {jvp(primals, cotangents, argnums)};
+}
+
+std::vector<array> Cos::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {multiply(
+      tangents[0], negative(sin(primals[0], stream()), stream()), stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Cos::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{cos(inputs[0], stream())}, axes};
+}
+
+std::vector<array> Cosh::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Cosh::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {multiply(tangents[0], sinh(primals[0], stream()), stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Cosh::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{cosh(inputs[0], stream())}, axes};
+}
+
+std::vector<array> CustomTransforms::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  // Extract the inputs to the VJP function
+  std::vector<array> inputs(primals.begin(), primals.end() - num_outputs_);
+
+  // Compute all the vjps
+  auto all_vjps = vjp_fun_(inputs, cotangents, outputs);
+  for (const auto& cot : cotangents) {
+    all_vjps.emplace_back(cot);
+  }
+
+  // Select the vjps requested
+  std::vector<array> vjps;
+  vjps.reserve(argnums.size());
+  for (auto arg : argnums) {
+    vjps.push_back(all_vjps[arg]);
+  }
+
+  return vjps;
+}
+
+std::vector<array> CustomTransforms::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  // Extract the inputs to the JVP function
+  std::vector<array> inputs(primals.begin(), primals.end() - num_outputs_);
+
+  // Compute the jvps
+  return jvp_fun_(inputs, tangents, argnums);
+}
+
+std::pair<std::vector<array>, std::vector<int>> CustomTransforms::vmap(
+    const std::vector<array>& inputs_,
+    const std::vector<int>& axes_) {
+  // Extract the inputs to the vmap function
+  std::vector<array> inputs(inputs_.begin(), inputs_.end() - num_outputs_);
+  std::vector<int> axes(axes_.begin(), axes_.end() - num_outputs_);
+  return vmap_fun_(inputs, axes);
+}
+
+std::vector<array> Depends::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  std::vector<array> vjps;
+
+  for (auto arg : argnums) {
+    if (arg < cotangents.size()) {
+      vjps.push_back(cotangents[arg]);
+    } else {
+      vjps.push_back(zeros_like(primals[arg]));
+    }
+  }
+  return vjps;
+}
+
+std::vector<array> Divide::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  array denominator_bar = conjugate(primals[1], stream());
+  for (auto arg : argnums) {
+    if (arg == 0) {
+      vjps.push_back(divide(cotangents[0], denominator_bar, stream()));
+    } else {
+      vjps.push_back(negative(
+          divide(
+              multiply(
+                  cotangents[0], conjugate(primals[0], stream()), stream()),
+              square(denominator_bar, stream()),
+              stream()),
+          stream()));
+    }
+  }
+  return vjps;
+}
+
+std::vector<array> DivMod::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    vjps.push_back(zeros_like(primals[arg], stream()));
+  }
+  return vjps;
+}
+
+std::vector<array> DivMod::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  return {zeros_like(primals[0], stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> DivMod::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {divmod(a, b, stream()), {to_ax}};
+}
+
+std::vector<array> Divide::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto jvp_fun = [&](int i) {
+    int arg = argnums[i];
+    if (arg == 0) {
+      return divide(tangents[i], primals[1], stream());
+    } else {
+      return negative(
+          divide(
+              multiply(tangents[i], primals[0], stream()),
+              square(primals[1], stream()),
+              stream()),
+          stream());
+    }
+  };
+  auto out = jvp_fun(0);
+  if (argnums.size() > 1) {
+    out = add(out, jvp_fun(1), stream());
+  }
+  return {out};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Divide::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{divide(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> Remainder::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    if (arg == 0) {
+      vjps.push_back(cotangents[0]);
+    } else {
+      auto x_over_y = divide(primals[0], primals[1], stream());
+      x_over_y = floor(x_over_y, stream());
+      vjps.push_back(
+          negative(multiply(x_over_y, cotangents[0], stream()), stream()));
+    }
+  }
+  return vjps;
+}
+
+std::vector<array> Remainder::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto jvp_fun = [&](int i) {
+    int arg = argnums[i];
+    if (arg == 0) {
+      return tangents[i];
+    } else {
+      auto x_over_y = divide(primals[0], primals[1], stream());
+      x_over_y = floor(x_over_y, stream());
+      return negative(multiply(x_over_y, tangents[i], stream()), stream());
+    }
+  };
+  auto out = jvp_fun(0);
+  if (argnums.size() > 1) {
+    out = add(out, jvp_fun(1), stream());
+  }
+  return {out};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Remainder::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{remainder(a, b, stream())}, {to_ax}};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Equal::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{equal(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> Equal::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    vjps.push_back(zeros_like(primals[arg], stream()));
+  }
+  return vjps;
+}
+
+std::vector<array> Equal::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto shape = broadcast_shapes(primals[0].shape(), primals[1].shape());
+  return {zeros(shape, bool_, stream())};
+}
+
+std::vector<array> Erf::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Erf::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  auto dtype = primals[0].dtype();
+  auto scale = multiply(array(M_2_SQRTPI, dtype), tangents[0], stream());
+  return {multiply(
+      scale,
+      exp(negative(square(primals[0], stream()), stream()), stream()),
+      stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Erf::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{erf(inputs[0], stream())}, axes};
+}
+
+std::vector<array> ErfInv::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  auto dtype = primals[0].dtype();
+  auto scale =
+      multiply(array(1.0 / M_2_SQRTPI, dtype), cotangents[0], stream());
+  return {
+      multiply(scale, exp(square(outputs[0], stream()), stream()), stream())};
+}
+
+std::vector<array> ErfInv::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  auto dtype = primals[0].dtype();
+  auto scale = multiply(array(1.0 / M_2_SQRTPI, dtype), tangents[0], stream());
+  return {multiply(
+      scale,
+      exp(square(erfinv(primals[0], stream()), stream()), stream()),
+      stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> ErfInv::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{erfinv(inputs[0], stream())}, axes};
+}
+
+std::vector<array> Exp::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  return {multiply(cotangents[0], outputs[0], stream())};
+}
+
+std::vector<array> Exp::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {multiply(tangents[0], exp(primals[0], stream()), stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Exp::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{exp(inputs[0], stream())}, axes};
+}
+
+std::vector<array> Expm1::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  return {multiply(
+      cotangents[0],
+      add(outputs[0], array(1.0f, outputs[0].dtype()), stream()),
+      stream())};
+}
+
+std::vector<array> Expm1::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {multiply(tangents[0], exp(primals[0], stream()), stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Expm1::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{expm1(inputs[0], stream())}, axes};
+}
+
+std::vector<array> ExpandDims::vjp(
+    const std::vector<array>&,
+    const std::vector<array>& cotangents,
+    const std::vector<int>&,
+    const std::vector<array>&) {
+  return {squeeze(cotangents[0], axes_, stream())};
+}
+
+std::vector<array> ExpandDims::jvp(
+    const std::vector<array>&,
+    const std::vector<array>& tangents,
+    const std::vector<int>&) {
+  return {expand_dims(tangents[0], axes_, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> ExpandDims::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto ax = axes[0];
+  auto expand_axes = axes_;
+  for (auto& s : expand_axes) {
+    if (s >= axes[0]) {
+      s++;
+    } else {
+      ax++;
+    }
+  }
+  return {{expand_dims(inputs[0], std::move(expand_axes), stream())}, {ax}};
+}
+
+bool ExpandDims::is_equivalent(const Primitive& other) const {
+  const ExpandDims& a_other = static_cast<const ExpandDims&>(other);
+  return (axes_ == a_other.axes_);
+}
+
+Shape ExpandDims::output_shape(
+    const array& input,
+    const std::vector<int>& axes) {
+  auto shape = input.shape();
+  for (auto ax : axes) {
+    shape.insert(shape.begin() + ax, 1);
+  }
+  return shape;
+}
+
+std::vector<Shape> ExpandDims::output_shapes(const std::vector<array>& inputs) {
+  return {ExpandDims::output_shape(inputs[0], axes_)};
+}
+
+std::vector<array> Flatten::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>&,
+    const std::vector<array>&) {
+  auto& in = primals[0];
+  Shape unflatten_shape(
+      in.shape().begin() + start_axis_, in.shape().begin() + end_axis_ + 1);
+  return {unflatten(
+      cotangents[0], start_axis_, std::move(unflatten_shape), stream())};
+}
+
+std::vector<array> Flatten::jvp(
+    const std::vector<array>&,
+    const std::vector<array>& tangents,
+    const std::vector<int>&) {
+  return {flatten(tangents[0], start_axis_, end_axis_, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Flatten::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto ax = axes[0];
+  auto start_axis = start_axis_;
+  auto end_axis = end_axis_;
+  auto in = inputs[0];
+  if (ax < start_axis) {
+    start_axis++;
+    end_axis++;
+  } else if (ax <= end_axis_) {
+    start_axis++;
+    end_axis++;
+    in = moveaxis(in, ax, 0, stream());
+    ax = 0;
+  } else {
+    ax -= (end_axis - start_axis);
+  }
+  return {{flatten(in, start_axis, end_axis, stream())}, {ax}};
+}
+
+bool Flatten::is_equivalent(const Primitive& other) const {
+  const Flatten& a_other = static_cast<const Flatten&>(other);
+  return start_axis_ == a_other.start_axis_ && end_axis_ == a_other.end_axis_;
+}
+
+Shape Flatten::output_shape(const array& input, int start_axis, int end_axis) {
+  Shape shape = input.shape();
+  auto flat_size = input.shape(start_axis);
+  for (int ax = start_axis + 1; ax <= end_axis; ++ax) {
+    flat_size *= input.shape(ax);
+  }
+  shape.erase(shape.begin() + start_axis + 1, shape.begin() + end_axis + 1);
+  shape[start_axis] = flat_size;
+  return shape;
+}
+
+std::vector<Shape> Flatten::output_shapes(const std::vector<array>& inputs) {
+  return {Flatten::output_shape(inputs[0], start_axis_, end_axis_)};
+}
+
+bool FFT::is_equivalent(const Primitive& other) const {
+  const FFT& r_other = static_cast<const FFT&>(other);
+  return axes_ == r_other.axes_ && inverse_ == r_other.inverse_ &&
+      real_ == r_other.real_;
+}
+
+std::vector<array> Unflatten::vjp(
+    const std::vector<array>&,
+    const std::vector<array>& cotangents,
+    const std::vector<int>&,
+    const std::vector<array>&) {
+  return {flatten(cotangents[0], axis_, axis_ + shape_.size() - 1, stream())};
+}
+
+std::vector<array> Unflatten::jvp(
+    const std::vector<array>&,
+    const std::vector<array>& tangents,
+    const std::vector<int>&) {
+  return {unflatten(tangents[0], axis_, shape_, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Unflatten::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto ax = axes[0];
+  auto axis = axis_;
+  if (ax <= axis_) {
+    axis++;
+  } else {
+    ax += (shape_.size() - 1);
+  }
+  return {{unflatten(inputs[0], axis, shape_, stream())}, {ax}};
+}
+
+bool Unflatten::is_equivalent(const Primitive& other) const {
+  const auto& a_other = static_cast<const Unflatten&>(other);
+  return axis_ == a_other.axis_ && shape_ == a_other.shape_;
+}
+
+Shape Unflatten::output_shape(
+    const array& input,
+    int axis,
+    const Shape& shape) {
+  Shape out_shape = input.shape();
+  out_shape[axis] = shape[0];
+  out_shape.insert(
+      out_shape.begin() + axis + 1, shape.begin() + 1, shape.end());
+  return out_shape;
+}
+
+std::vector<Shape> Unflatten::output_shapes(const std::vector<array>& inputs) {
+  return {Unflatten::output_shape(inputs[0], axis_, shape_)};
+}
+
+std::pair<std::vector<array>, std::vector<int>> FFT::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto& in = inputs[0];
+  int ax = axes[0];
+  auto fft_axes = axes_;
+  auto out_shape = in.shape();
+  if (ax >= 0) {
+    for (auto& fft_ax : fft_axes) {
+      if (fft_ax >= ax) {
+        fft_ax++;
+      }
+      if (real_) {
+        auto n = out_shape[fft_ax];
+        out_shape[fft_ax] = inverse_ ? 2 * (n - 1) : n / 2 + 1;
+      }
+    }
+  }
+  return {
+      {array(
+          out_shape,
+          real_ && inverse_ ? float32 : complex64,
+          std::make_shared<FFT>(stream(), fft_axes, inverse_, real_),
+          {in})},
+      {ax}};
+}
+
+std::vector<array> FFT::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  auto& in = primals[0];
+  std::vector<int> axes(axes_.begin(), axes_.end());
+
+  // TODO: Add it as an option to do an unnormalized or scaled fft so that this
+  //       isn't part of the graph.
+  double n_elements = 1;
+  for (auto ax : axes) {
+    n_elements *= inverse_ ? cotangents[0].shape(ax) : primals[0].shape(ax);
+  }
+
+  if (real_ && inverse_) {
+    // Make a mask to account for the double use in the forward pass.
+    // Everything except the DC and nyquist frequencies gets doubled.
+    int N = in.shape(axes_.back());
+    bool odd = cotangents[0].shape(axes_.back()) % 2;
+    Shape c(in.ndim(), 1);
+    c[axes_.back()] = N;
+    array indices = reshape(arange(N, stream()), std::move(c), stream());
+    array first(0, indices.dtype());
+    array last(N - 1 + odd, indices.dtype());
+    array one(1 / n_elements, in.dtype());
+    array two(2 / n_elements, in.dtype());
+    array mask = where(
+        logical_and(
+            greater(indices, first, stream()),
+            less(indices, last, stream()),
+            stream()),
+        two,
+        one,
+        stream());
+    return {
+        multiply(fft::rfftn(cotangents[0], axes, stream()), mask, stream())};
+  } else if (real_) {
+    Shape n;
+    for (auto ax : axes_) {
+      n.push_back(in.shape(ax));
+    }
+    // Make a mask to account for the double use in the forward pass.
+    // Everything except the DC and nyquist frequencies gets halved.
+    int N = cotangents[0].shape(axes_.back());
+    bool odd = in.shape(axes_.back()) % 2;
+    Shape c(in.ndim(), 1);
+    c[axes_.back()] = N;
+    array indices = reshape(arange(N, stream()), std::move(c), stream());
+    array first(0, indices.dtype());
+    array last(N - 1 + odd, indices.dtype());
+    array one(1, complex64);
+    array half(0.5, complex64);
+    array mask = where(
+        logical_and(
+            greater(indices, first, stream()),
+            less(indices, last, stream()),
+            stream()),
+        half,
+        one,
+        stream());
+    return {multiply(
+        fft::irfftn(multiply(cotangents[0], mask, stream()), n, axes, stream()),
+        array(n_elements, in.dtype()),
+        stream())};
+  } else if (inverse_) {
+    return {multiply(
+        fft::fftn(cotangents[0], axes, stream()),
+        array(1 / n_elements, complex64),
+        stream())};
+  } else {
+    return {multiply(
+        fft::ifftn(cotangents[0], axes, stream()),
+        array(n_elements, complex64),
+        stream())};
+  }
+}
+
+std::vector<array> FFT::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  auto& tan = tangents[0];
+  if (real_ & inverse_) {
+    return {fft::irfftn(tan, stream())};
+  } else if (real_) {
+    return {fft::rfftn(tan, stream())};
+  } else if (inverse_) {
+    return {fft::ifftn(tan, stream())};
+  } else {
+    return {fft::fftn(tan, stream())};
+  }
+}
+
+std::vector<array> Floor::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Floor::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {zeros_like(primals[0], stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Floor::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{floor(inputs[0], stream())}, axes};
+}
+
+std::vector<array> Full::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {multiply(cotangents[0], primals[0], stream())};
+}
+
+std::vector<array> Full::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return tangents;
+}
+
+std::pair<std::vector<array>, std::vector<int>> Full::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  auto& in = inputs[0];
+  auto out =
+      array(in.shape(), in.dtype(), std::make_shared<Full>(stream()), {in});
+  return {{out}, axes};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Gather::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto& src = inputs[0];
+  std::vector<array> indices(inputs.begin() + 1, inputs.end());
+  auto gather_axes = axes_;
+  auto slice_sizes = slice_sizes_;
+  auto src_vmapped = axes[0] >= 0;
+  auto ind_vmap_ax_ptr =
+      std::find_if(axes.begin() + 1, axes.end(), [](int a) { return a >= 0; });
+  int out_ax = -1;
+  bool indices_vmapped = (ind_vmap_ax_ptr != axes.end());
+  if (indices_vmapped) {
+    out_ax = *ind_vmap_ax_ptr;
+  } else if (src_vmapped) {
+    out_ax = axes[0];
+  }
+
+  // Reorder all the index arrays so the vmap axis is in the same spot.
+  if (indices_vmapped) {
+    for (int i = 1; i < axes.size(); ++i) {
+      if (out_ax != axes[i] && axes[i] >= 0) {
+        indices[i - 1] = moveaxis(indices[i - 1], axes[i], out_ax, stream());
+      } else if (axes[i] < 0) {
+        indices[i - 1] = expand_dims(indices[i - 1], out_ax, stream());
+      }
+    }
+  }
+
+  int idx_dims = indices.empty() ? 0 : indices[0].ndim();
+
+  if (src_vmapped) {
+    for (auto& ax : gather_axes) {
+      if (ax >= axes[0]) {
+        ax++;
+      }
+    }
+    if (indices_vmapped) {
+      // Make a new index array for the vmapped dimension
+      auto vmap_inds =
+          arange(static_cast<ShapeElem>(0), src.shape(axes[0]), stream());
+      // Reshape it so it broadcasts with other index arrays
+      {
+        auto shape = Shape(idx_dims, 1);
+        shape[out_ax] = vmap_inds.size();
+        vmap_inds = reshape(vmap_inds, std::move(shape), stream());
+      }
+      // Update gather axes and slice sizes accordingly
+      slice_sizes.insert(slice_sizes.begin() + axes[0], 1);
+      gather_axes.push_back(axes[0]);
+      indices.push_back(vmap_inds);
+    } else {
+      slice_sizes.insert(slice_sizes.begin() + out_ax, src.shape(out_ax));
+      out_ax += idx_dims;
+    }
+  }
+  auto out = gather(src, indices, gather_axes, slice_sizes, stream());
+  if (src_vmapped && indices_vmapped) {
+    out = squeeze(out, idx_dims + axes[0], stream());
+  }
+  return {{out}, {out_ax}};
+}
+
+std::vector<array> Gather::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  for (int argnum : argnums) {
+    if (argnum > 0) {
+      // Grads w.r.t. indices are zero
+      vjps.push_back(
+          zeros(primals[argnum].shape(), primals[argnum].dtype(), stream()));
+    } else {
+      auto src = zeros_like(primals[0], stream());
+      std::vector<array> inds(primals.begin() + 1, primals.end());
+      vjps.push_back(scatter_add(src, inds, cotangents[0], axes_, stream()));
+    }
+  }
+  return vjps;
+}
+
+std::vector<array> Gather::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  if (argnums.size() > 1 || argnums[0] != 0) {
+    throw std::invalid_argument(
+        "[gather] Cannot calculate JVP with respect to indices.");
+  }
+  std::vector<array> inds(primals.begin() + 1, primals.end());
+  return {gather(tangents[0], inds, axes_, slice_sizes_, stream())};
+}
+
+bool Gather::is_equivalent(const Primitive& other) const {
+  const Gather& g_other = static_cast<const Gather&>(other);
+  return axes_ == g_other.axes_ && slice_sizes_ == g_other.slice_sizes_;
+}
+
+std::pair<std::vector<array>, std::vector<int>> GatherAxis::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  bool vmap_in = axes[0] >= 0;
+  bool vmap_idx = axes[1] >= 0;
+
+  auto in = inputs[0];
+  auto idx = inputs[1];
+  int out_ax;
+  if (vmap_in && vmap_idx) {
+    // reorder the vmap axes to the same location
+    idx = moveaxis(idx, axes[1], axes[0], stream());
+    out_ax = axes[0];
+  } else if (vmap_in) {
+    // expand just the indices dimension
+    idx = expand_dims(idx, axes[0], stream());
+    out_ax = axes[0];
+  } else if (vmap_idx) {
+    // expand just the input dimension
+    in = expand_dims(in, axes[1], stream());
+    out_ax = axes[1];
+  } else {
+    out_ax = -1;
+  }
+  int axis = (out_ax >= 0 && axis_ >= out_ax) ? axis_ + 1 : axis_;
+  return {{take_along_axis(in, idx, axis, stream())}, {out_ax}};
+}
+
+std::vector<array> GatherAxis::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  for (int argnum : argnums) {
+    if (argnum > 0) {
+      // Grads w.r.t. indices are zero
+      vjps.push_back(
+          zeros(primals[argnum].shape(), primals[argnum].dtype(), stream()));
+    } else {
+      auto src = zeros_like(primals[0], stream());
+      vjps.push_back(array(
+          src.shape(),
+          src.dtype(),
+          std::make_shared<ScatterAxis>(stream(), ScatterAxis::Sum, axis_),
+          {src, primals[1], cotangents[0]}));
+    }
+  }
+  return vjps;
+}
+
+std::vector<array> GatherAxis::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  if (argnums.size() > 1 || argnums[0] != 0) {
+    throw std::invalid_argument(
+        "[gather_axis] Cannot calculate JVP with respect to indices.");
+  }
+  return {take_along_axis(tangents[0], primals[1], axis_, stream())};
+}
+
+std::vector<Shape> GatherAxis::output_shapes(const std::vector<array>& inputs) {
+  return {inputs[1].shape()};
+}
+
+bool GatherAxis::is_equivalent(const Primitive& other) const {
+  auto& g_other = static_cast<const GatherAxis&>(other);
+  return axis_ == g_other.axis_;
+}
+
+std::vector<Shape> Gather::output_shapes(const std::vector<array>& inputs) {
+  Shape out_shape;
+  if (inputs.size() > 1) {
+    out_shape = inputs[1].shape();
+  }
+  out_shape.insert(out_shape.end(), slice_sizes_.begin(), slice_sizes_.end());
+  return {std::move(out_shape)};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Greater::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{greater(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> Greater::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    vjps.push_back(zeros_like(primals[arg], stream()));
+  }
+  return vjps;
+}
+
+std::vector<array> Greater::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto shape = broadcast_shapes(primals[0].shape(), primals[1].shape());
+  return {zeros(shape, bool_, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> GreaterEqual::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{greater_equal(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> GreaterEqual::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    vjps.push_back(zeros_like(primals[arg], stream()));
+  }
+  return vjps;
+}
+
+std::vector<array> GreaterEqual::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto shape = broadcast_shapes(primals[0].shape(), primals[1].shape());
+  return {zeros(shape, bool_, stream())};
+}
+
+std::vector<array> Imag::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {multiply(
+      array(complex64_t{0.0f, 1.0f}, primals[0].dtype()),
+      cotangents[0],
+      stream())};
+}
+
+std::vector<array> Imag::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {imag(tangents[0], stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Imag::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{imag(inputs[0], stream())}, axes};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Less::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{less(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> Less::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    vjps.push_back(zeros_like(primals[arg], stream()));
+  }
+  return vjps;
+}
+
+std::vector<array> Less::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto shape = broadcast_shapes(primals[0].shape(), primals[1].shape());
+  return {zeros(shape, bool_, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> LessEqual::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{less_equal(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> LessEqual::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    vjps.push_back(zeros_like(primals[arg], stream()));
+  }
+  return vjps;
+}
+
+std::vector<array> LessEqual::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto shape = broadcast_shapes(primals[0].shape(), primals[1].shape());
+  return {zeros(shape, bool_, stream())};
+}
+
+std::vector<array> Log::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Log::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  auto out = divide(tangents[0], primals[0], stream());
+  if (base_ != Base::e) {
+    auto scale = 1 / std::log(base_ == Base::ten ? 10.0f : 2.0f);
+    out = multiply(array(scale, out.dtype()), out, stream());
+  }
+  return {out};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Log::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  auto& in = inputs[0];
+  return {
+      {array(
+          in.shape(),
+          in.dtype(),
+          std::make_shared<Log>(stream(), base_),
+          {in})},
+      axes};
+}
+
+std::vector<array> Log1p::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Log1p::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  auto dtype = primals[0].dtype();
+  return {divide(
+      tangents[0], add(array(1.0f, dtype), primals[0], stream()), stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Log1p::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{log1p(inputs[0], stream())}, axes};
+}
+
+std::vector<array> LogicalNot::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> LogicalNot::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {zeros_like(tangents[0], stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> LogicalNot::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{logical_not(inputs[0], stream())}, axes};
+}
+
+std::vector<array> LogicalAnd::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 2);
+  std::vector<array> vjps = {zeros_like(cotangents[0], stream())};
+  if (argnums.size() > 1) {
+    vjps.push_back(vjps.back());
+  }
+  return vjps;
+}
+
+std::vector<array> LogicalAnd::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 2);
+  assert(argnums.size() <= 2);
+  return {zeros_like(primals[0], stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> LogicalAnd::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 2);
+  assert(axes.size() == 2);
+
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{logical_and(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> LogicalOr::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 2);
+  std::vector<array> vjps = {zeros_like(cotangents[0], stream())};
+  if (argnums.size() > 1) {
+    vjps.push_back(vjps.back());
+  }
+  return vjps;
+}
+
+std::vector<array> LogicalOr::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 2);
+  assert(argnums.size() <= 2);
+
+  return {zeros_like(primals[0], stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> LogicalOr::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 2);
+  assert(axes.size() == 2);
+
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{logical_or(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> LogAddExp::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  auto a = primals[0];
+  auto b = primals[1];
+  auto s = sigmoid(subtract(a, b, stream()), stream());
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    vjps.push_back(multiply(
+        cotangents[0],
+        arg == 0 ? s : subtract(array(1.0f, s.dtype()), s, stream()),
+        stream()));
+  }
+  return vjps;
+}
+
+std::vector<array> LogAddExp::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto a = primals[0];
+  auto b = primals[1];
+  auto s = sigmoid(subtract(a, b, stream()), stream());
+  auto jvp_fun = [&](int i) {
+    int arg = argnums[i];
+    return multiply(
+        tangents[i],
+        arg == 0 ? s : subtract(array(1.0f, s.dtype()), s, stream()),
+        stream());
+  };
+  auto out = jvp_fun(0);
+  if (argnums.size() > 1) {
+    out = add(out, jvp_fun(1), stream());
+  }
+  return {out};
+}
+
+std::pair<std::vector<array>, std::vector<int>> LogAddExp::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{logaddexp(a, b, stream())}, {to_ax}};
+}
+
+std::pair<std::vector<array>, std::vector<int>> LogSumExp::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto ax = axes[0];
+  auto in = inputs[0];
+  if (ax == (in.ndim() - 1)) {
+    in = swapaxes(in, -1, -2, stream());
+    ax = in.ndim() - 2;
+  }
+  return {{logsumexp(in, -1, true, stream())}, {ax}};
+}
+
+std::vector<array> LogSumExp::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 1);
+  assert(cotangents.size() == 1);
+  return {multiply(
+      cotangents[0],
+      softmax(primals[0], std::vector<int>{-1}, true, stream()),
+      stream())};
+}
+
+std::vector<array> LogSumExp::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(tangents.size() == 1);
+  return {multiply(
+      tangents[0],
+      softmax(primals[0], std::vector<int>{-1}, true, stream()),
+      stream())};
+}
+
+std::vector<Shape> LogSumExp::output_shapes(const std::vector<array>& inputs) {
+  auto s = inputs[0].shape();
+  s.back() = 1;
+  return {s};
+}
+
+std::vector<array> Matmul::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  auto& cotan = cotangents[0];
+  std::vector<int> reorder(cotan.ndim());
+  std::iota(reorder.begin(), reorder.end(), 0);
+  std::iter_swap(reorder.end() - 1, reorder.end() - 2);
+  auto& s = stream();
+
+  auto complex_transpose = [&](const array& x) {
+    return transpose(conjugate(x, s), reorder, s);
+  };
+
+  for (auto arg : argnums) {
+    if (arg == 0) {
+      // M X N * (K X N).T -> M X K
+      vjps.push_back(matmul(cotan, complex_transpose(primals[1]), s));
+    } else {
+      // (M X K).T * M X N -> K X N
+      vjps.push_back(matmul(complex_transpose(primals[0]), cotan, s));
+    }
+  }
+  return vjps;
+}
+
+std::vector<array> Matmul::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  std::vector<array> jvp;
+  for (int i = 0; i < argnums.size(); ++i) {
+    auto arg = argnums[i];
+    if (arg == 0 && i == 0) {
+      jvp.push_back(matmul(tangents[0], primals[1], stream()));
+    } else if (arg == 0 && i == 1) {
+      jvp[0] = addmm(jvp[0], tangents[1], primals[1], 1.0f, 1.0f, stream());
+    } else if (i == 0) {
+      jvp.push_back(matmul(primals[0], tangents[0], stream()));
+    } else if (i == 1) {
+      jvp[0] = addmm(jvp[0], primals[0], tangents[1], 1.0f, 1.0f, stream());
+    }
+  }
+  return jvp;
+}
+
+std::pair<std::vector<array>, std::vector<int>> Matmul::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto maybe_move_ax = [this](auto& arr, auto ax) {
+    return ax > 0 ? moveaxis(arr, ax, 0, stream()) : arr;
+  };
+  auto a = maybe_move_ax(inputs[0], axes[0]);
+  auto b = maybe_move_ax(inputs[1], axes[1]);
+  return {{matmul(a, b, stream())}, {0}};
+}
+
+std::vector<Shape> Matmul::output_shapes(const std::vector<array>& inputs) {
+  auto out_shape = inputs[0].shape();
+  out_shape.back() = inputs[1].shape(-1);
+  return {std::move(out_shape)};
+}
+
+std::vector<array> Maximum::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  auto& a = primals[0];
+  auto& b = primals[1];
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    auto mask =
+        (arg == 0) ? greater(a, b, stream()) : less_equal(a, b, stream());
+    vjps.push_back(multiply(cotangents[0], mask, stream()));
+  }
+  return {vjps};
+}
+
+std::vector<array> Maximum::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto& a = primals[0];
+  auto& b = primals[1];
+  auto jvp_fun = [&](int i) {
+    int arg = argnums[i];
+    auto mask =
+        (arg == 0) ? greater(a, b, stream()) : less_equal(a, b, stream());
+    return multiply(tangents[i], mask, stream());
+  };
+  auto out = jvp_fun(0);
+  if (argnums.size() > 1) {
+    out = add(out, jvp_fun(1), stream());
+  }
+  return {out};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Maximum::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{maximum(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> Minimum::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  auto& a = primals[0];
+  auto& b = primals[1];
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    auto mask =
+        (arg == 0) ? less(a, b, stream()) : greater_equal(a, b, stream());
+    vjps.push_back(multiply(cotangents[0], mask, stream()));
+  }
+  return vjps;
+}
+
+std::vector<array> Minimum::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto& a = primals[0];
+  auto& b = primals[1];
+  auto jvp_fun = [&](int i) {
+    int arg = argnums[i];
+    auto mask =
+        (arg == 0) ? less(a, b, stream()) : greater_equal(a, b, stream());
+    return multiply(tangents[i], mask, stream());
+  };
+  auto out = jvp_fun(0);
+  if (argnums.size() > 1) {
+    out = add(out, jvp_fun(1), stream());
+  }
+  return {out};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Minimum::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{minimum(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> Multiply::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto arg = argnums[0];
+  auto jvp = multiply(tangents[0], primals[1 - arg], stream());
+  if (argnums.size() > 1) {
+    arg = argnums[1];
+    jvp = add(jvp, multiply(tangents[1], primals[1 - arg], stream()), stream());
+  }
+  return {jvp};
+}
+
+std::vector<array> Multiply::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    vjps.push_back(multiply(
+        conjugate(primals[1 - arg], stream()), cotangents[0], stream()));
+  }
+  return vjps;
+}
+
+std::pair<std::vector<array>, std::vector<int>> Multiply::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{multiply(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> Select::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 3);
+  assert(tangents.size() == 3);
+
+  auto jvp_fun = [&](int i) {
+    int arg = argnums[i];
+
+    if (arg == 0) {
+      return zeros_like(primals[0], stream());
+    } else if (arg == 1) {
+      return multiply(
+          astype(primals[0], tangents[1].dtype(), stream()),
+          tangents[1],
+          stream());
+    } else {
+      return multiply(
+          astype(
+              logical_not(primals[0], stream()), tangents[2].dtype(), stream()),
+          tangents[2],
+          stream());
+    }
+  };
+
+  array jvp = jvp_fun(argnums[0]);
+  for (int i = 1; i < argnums.size(); i++) {
+    jvp = add(jvp, jvp_fun(argnums[i]));
+  }
+  return {jvp};
+}
+
+std::vector<array> Select::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 3);
+  assert(cotangents.size() == 1);
+
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    if (arg == 0) {
+      vjps.push_back(zeros_like(primals[0], stream()));
+    } else if (arg == 1) {
+      vjps.push_back(multiply(
+          astype(primals[0], cotangents[0].dtype(), stream()),
+          cotangents[0],
+          stream()));
+    } else if (arg == 2) {
+      vjps.push_back(multiply(
+          astype(
+              logical_not(primals[0], stream()),
+              cotangents[0].dtype(),
+              stream()),
+          cotangents[0],
+          stream()));
+    }
+  }
+  return vjps;
+}
+
+std::pair<std::vector<array>, std::vector<int>> Select::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, c, to_ax] = vmap_ternary_op(inputs, axes, stream());
+  return {{where(a, b, c, stream())}, {to_ax}};
+}
+
+std::vector<array> Negative::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Negative::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {negative(tangents[0], stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Negative::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{negative(inputs[0], stream())}, axes};
+}
+
+std::pair<std::vector<array>, std::vector<int>> NotEqual::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{not_equal(a, b, stream())}, axes};
+}
+
+std::vector<array> NotEqual::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    vjps.push_back(zeros_like(primals[arg], stream()));
+  }
+  return vjps;
+}
+
+std::vector<array> NotEqual::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto shape = broadcast_shapes(primals[0].shape(), primals[1].shape());
+  return {zeros(shape, bool_, stream())};
+}
+
+std::vector<array> Pad::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(argnums.size() == 1 && argnums[0] == 0);
+
+  auto& cotan = cotangents[0];
+  Shape start(cotan.ndim(), 0);
+  auto stop = cotan.shape();
+
+  for (auto i : axes_) {
+    start[i] = low_pad_size_[i];
+    stop[i] -= high_pad_size_[i];
+  }
+
+  auto out = slice(cotan, start, stop, stream());
+
+  return {out};
+}
+
+std::vector<array> Pad::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(argnums.size() == 1 && argnums[0] == 0);
+
+  return {
+      pad(tangents[0],
+          axes_,
+          low_pad_size_,
+          high_pad_size_,
+          array(0, tangents[0].dtype()),
+          "constant",
+          stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Pad::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  throw std::runtime_error("Pad vmap is NYI.");
+}
+
+bool Pad::is_equivalent(const Primitive& other) const {
+  const Pad& p_other = static_cast<const Pad&>(other);
+  return (
+      p_other.axes_ == axes_ && p_other.low_pad_size_ == low_pad_size_ &&
+      p_other.high_pad_size_ == high_pad_size_);
+}
+
+std::vector<array> Partition::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  auto sort_idx = argpartition(primals[0], kth_, axis_, stream());
+  return {put_along_axis(
+      zeros_like(primals[0], stream()),
+      sort_idx,
+      cotangents[0],
+      axis_,
+      stream())};
+}
+
+std::vector<array> Partition::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(tangents.size() == 1);
+  auto sort_idx = argpartition(primals[0], kth_, axis_, stream());
+  auto out = take_along_axis(tangents[0], sort_idx, axis_, stream());
+  return {out};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Partition::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+
+  int axis_left = axes[0] >= 0 && axes[0] <= axis_;
+  return {{partition(inputs[0], axis_ + axis_left, stream())}, axes};
+}
+
+bool Partition::is_equivalent(const Primitive& other) const {
+  const Partition& r_other = static_cast<const Partition&>(other);
+  return axis_ == r_other.axis_ && kth_ == r_other.kth_;
+}
+
+std::vector<array> Power::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    if (arg == 0) {
+      vjps.push_back(multiply(
+          power(
+              primals[0],
+              subtract(primals[1], array(1, primals[0].dtype()), stream()),
+              stream()),
+          primals[1],
+          stream()));
+    } else {
+      auto& exp = outputs[0];
+      auto exp_vjp = multiply(log(primals[0], stream()), outputs[0], stream());
+      // 0 * log 0 -> 0
+      vjps.push_back(where(exp, exp_vjp, array(0.0f, exp.dtype()), stream()));
+    }
+    vjps.back() = multiply(cotangents[0], vjps.back(), stream());
+  }
+  return vjps;
+}
+
+std::vector<array> Power::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto output = power(primals[0], primals[1], stream());
+  auto grads = vjp(primals, tangents, argnums, {output});
+  if (argnums.size() > 1) {
+    return {add(grads[0], grads[1], stream())};
+  } else {
+    return grads;
+  }
+}
+
+std::pair<std::vector<array>, std::vector<int>> Power::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{power(a, b, stream())}, {to_ax}};
+}
+
+std::string quantization_mode_to_string(QuantizationMode mode) {
+  if (mode == QuantizationMode::Affine) {
+    return "affine";
+  } else {
+    return "mxfp4";
+  }
+}
+
+QuantizationMode string_to_quantization_mode(const std::string& mode) {
+  if (mode == "affine") {
+    return QuantizationMode::Affine;
+  } else {
+    return QuantizationMode::Mxfp4;
+  }
+}
+
+std::pair<std::vector<array>, std::vector<int>> QuantizedMatmul::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  throw std::runtime_error("[QuantizedMatmul::vmap] NYI");
+}
+
+std::vector<array> QuantizedMatmul::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+
+  // We rely on the fact that w is always 2D so transpose is simple
+  std::optional<array> dsb = std::nullopt;
+  for (auto arg : argnums) {
+    // gradient wrt to x
+    if (arg == 0) {
+      vjps.push_back(quantized_matmul(
+          cotangents[0],
+          primals[1],
+          primals[2],
+          mode_ == QuantizationMode::Affine ? std::optional<array>(primals[3])
+                                            : std::nullopt,
+          !transpose_,
+          group_size_,
+          bits_,
+          quantization_mode_to_string(mode_),
+          stream()));
+    }
+
+    // gradient wrt to w_q, scales or biases
+    else if (arg == 1) {
+      throw std::runtime_error(
+          "[QuantizedMatmul::vjp] no gradient wrt the quantized weights.");
+    } else {
+      if (mode_ == QuantizationMode::Mxfp4) {
+        throw std::invalid_argument(
+            "[QuantizedMatmul::vjp] no gradient wrt scales with mxfp4 quantization.");
+      }
+      if (!dsb) {
+        int ndim = primals[1].ndim();
+        auto fc = flatten(cotangents[0], 0, -ndim, stream());
+        auto fx = flatten(primals[0], 0, -ndim, stream());
+        auto dw = transpose_
+            ? matmul(swapaxes(fc, -1, -2, stream()), fx, stream())
+            : matmul(swapaxes(fx, -1, -2, stream()), fc, stream());
+        dsb = unflatten(dw, -1, {-1, group_size_}, stream());
+      }
+      if (arg == 3) {
+        // biases
+        vjps.push_back(sum(*dsb, -1, false, stream()));
+      } else {
+        // scales
+        auto wq = dequantize(
+            primals[1],
+            ones_like(primals[2], stream()),
+            zeros_like(primals[3], stream()),
+            group_size_,
+            bits_,
+            quantization_mode_to_string(mode_),
+            stream());
+        wq = unflatten(wq, -1, {-1, group_size_}, stream());
+        vjps.push_back(sum(multiply(*dsb, wq, stream()), -1, false, stream()));
+      }
+    }
+  }
+  return vjps;
+}
+
+std::vector<array> QuantizedMatmul::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  if (argnums.size() > 1 || argnums[0] != 0) {
+    throw std::runtime_error(
+        "[QuantizedMatmul::jvp] No JVP wrt the quantized matrix yet.");
+  }
+  return {quantized_matmul(
+      tangents[0],
+      primals[1],
+      primals[2],
+      mode_ == QuantizationMode::Affine ? std::optional<array>(primals[3])
+                                        : std::nullopt,
+      transpose_,
+      group_size_,
+      bits_,
+      quantization_mode_to_string(mode_),
+      stream())};
+}
+
+bool QuantizedMatmul::is_equivalent(const Primitive& other) const {
+  const QuantizedMatmul& qm_other = static_cast<const QuantizedMatmul&>(other);
+  return group_size_ == qm_other.group_size_ && bits_ == qm_other.bits_ &&
+      mode_ == qm_other.mode_ && transpose_ == qm_other.transpose_;
+}
+
+std::vector<Shape> QuantizedMatmul::output_shapes(
+    const std::vector<array>& inputs) {
+  auto& w = inputs[1];
+  int w_outer_dims = (transpose_) ? w.shape(-2) : w.shape(-1) * 32 / bits_;
+  auto out_shape = inputs[0].shape();
+  out_shape.back() = w_outer_dims;
+  return {std::move(out_shape)};
+}
+
+std::pair<std::vector<array>, std::vector<int>> GatherQMM::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  throw std::runtime_error("GatherQMM::vmap NYI");
+}
+
+std::vector<array> GatherQMM::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+
+  auto& cotan = cotangents[0];
+
+  auto& x = primals[0];
+  auto& w = primals[1];
+  auto& scales = primals[2];
+  auto& lhs_indices = primals[primals.size() - 2];
+  auto& rhs_indices = primals[primals.size() - 1];
+  auto biases = (mode_ == QuantizationMode::Affine)
+      ? std::optional<array>(primals[3])
+      : std::nullopt;
+
+  int M = cotan.shape(-2);
+  int N = cotan.shape(-1);
+  int K = x.shape(-1);
+
+  bool sorted = left_sorted_ || right_sorted_;
+  bool no_broadcast = rhs_indices.size() * M * K == x.size();
+  std::optional<array> dsb = std::nullopt;
+
+  for (auto arg : argnums) {
+    // gradient wrt to x
+    if (arg == 0) {
+      auto g = gather_qmm(
+          cotan,
+          w,
+          scales,
+          biases,
+          std::nullopt,
+          rhs_indices,
+          !transpose_,
+          group_size_,
+          bits_,
+          quantization_mode_to_string(mode_),
+          sorted,
+          stream());
+      if (sorted && no_broadcast) {
+        vjps.push_back(g);
+      } else {
+        vjps.push_back(reshape(
+            scatter_add(
+                flatten(zeros_like(x, stream()), 0, -3, stream()),
+                lhs_indices,
+                expand_dims(g, -3, stream()),
+                0,
+                stream()),
+            x.shape(),
+            stream()));
+      }
+    }
+
+    // gradient wrt to the indices is undefined
+    else if (arg > 3) {
+      throw std::runtime_error(
+          "[GatherQMM::vjp] cannot compute the gradient wrt the indices.");
+    }
+
+    // gradient wrt to w_q, scales or biases
+    else if (arg == 1) {
+      throw std::runtime_error(
+          "[GatherQMM::vjp] no gradient wrt the quantized weights.");
+    } else {
+      if (mode_ == QuantizationMode::Mxfp4) {
+        throw std::invalid_argument(
+            "[GatherQMM::vjp] no gradient wrt scales with mxfp4 quantization.");
+      }
+
+      if (!dsb) {
+        auto shape = w.shape();
+        shape.pop_back();
+        shape.pop_back();
+        dsb = unflatten(
+            gather_mm_grad(
+                x,
+                cotan,
+                lhs_indices,
+                rhs_indices,
+                sorted,
+                std::move(shape),
+                stream()),
+            -1,
+            {-1, group_size_},
+            stream());
+      }
+      if (arg == 3) {
+        vjps.push_back(sum(*dsb, -1, false, stream()));
+      } else {
+        vjps.push_back(
+            sum(multiply(
+                    *dsb,
+                    unflatten(
+                        dequantize(
+                            w,
+                            ones_like(scales, stream()),
+                            zeros_like(*biases, stream()),
+                            group_size_,
+                            bits_,
+                            quantization_mode_to_string(mode_),
+                            stream()),
+                        -1,
+                        {-1, group_size_},
+                        stream()),
+                    stream()),
+                -1,
+                false,
+                stream()));
+      }
+    }
+  }
+  return vjps;
+}
+
+std::vector<array> GatherQMM::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  throw std::runtime_error("GatherQMM::jvp NYI");
+}
+
+bool GatherQMM::is_equivalent(const Primitive& other) const {
+  const GatherQMM& qm_other = static_cast<const GatherQMM&>(other);
+  return group_size_ == qm_other.group_size_ && bits_ == qm_other.bits_ &&
+      mode_ == qm_other.mode_ && transpose_ == qm_other.transpose_;
+}
+
+std::pair<std::vector<array>, std::vector<int>> RandomBits::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+
+  // The last dimension of the key is always a key pair
+  auto key = inputs[0];
+  auto kax = axes[0];
+  if (kax == key.ndim() - 1) {
+    std::vector<int> reorder(key.ndim());
+    std::iota(reorder.begin(), reorder.end(), 0);
+    std::swap(reorder[kax], reorder[kax - 1]);
+    key = transpose(key, reorder, stream());
+    kax--;
+  }
+
+  auto shape = shape_;
+  if (kax >= 0) {
+    shape.insert(shape.begin() + kax, key.shape()[kax]);
+  }
+
+  auto get_dtype = [width = width_]() {
+    switch (width) {
+      case 1:
+        return uint8;
+      case 2:
+        return uint16;
+      default:
+        return uint32;
+    }
+  };
+
+  auto out = array(
+      shape,
+      get_dtype(),
+      std::make_shared<RandomBits>(stream(), shape, width_),
+      {key});
+  return {{out}, {kax}};
+}
+
+bool RandomBits::is_equivalent(const Primitive& other) const {
+  const RandomBits& r_other = static_cast<const RandomBits&>(other);
+  return shape_ == r_other.shape_;
+}
+
+std::vector<array> Real::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {astype(cotangents[0], primals[0].dtype(), stream())};
+}
+
+std::vector<array> Real::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {real(tangents[0], stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Real::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{real(inputs[0], stream())}, axes};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Reshape::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  // Transpose the input so that the vmap dim is first.
+  auto& in = inputs[0];
+  auto ax = axes[0];
+  if (ax >= 0) {
+    std::vector<int> reorder(in.ndim());
+    std::iota(reorder.begin(), reorder.end(), 0);
+    reorder.erase(reorder.begin() + ax);
+    reorder.insert(reorder.begin(), ax);
+    // Insert the vmap dim into the shape at the beginning.
+    auto out = transpose(in, reorder, stream());
+    shape_.insert(shape_.begin(), in.shape()[ax]);
+    // Reshape the transposed input to the new shape.
+    return {{reshape(out, shape_, stream())}, {0}};
+  } else {
+    return {{reshape(in, shape_, stream())}, {ax}};
+  }
+}
+
+std::vector<array> Reshape::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  assert(argnums[0] == 0);
+  return {reshape(cotangents[0], primals[0].shape(), stream())};
+}
+
+std::vector<array> Reshape::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  assert(argnums[0] == 0);
+  return {reshape(tangents[0], shape_, stream())};
+}
+
+bool Reshape::is_equivalent(const Primitive& other) const {
+  const Reshape& r_other = static_cast<const Reshape&>(other);
+  return shape_ == r_other.shape_;
+}
+
+Shape Reshape::output_shape(const array& input, Shape shape) {
+  size_t size = 1;
+  int infer_idx = -1;
+  for (int i = 0; i < shape.size(); ++i) {
+    if (shape[i] == -1) {
+      if (infer_idx >= 0) {
+        throw std::invalid_argument(
+            "[reshape] Reshape can only infer one dimension.");
+      }
+      infer_idx = i;
+    } else {
+      size *= shape[i];
+    }
+  }
+
+  // Infer the shape
+  if (size > 0 && infer_idx >= 0) {
+    shape[infer_idx] = input.size() / size;
+    size *= shape[infer_idx];
+  } else if (infer_idx >= 0) {
+    throw std::invalid_argument(
+        "[reshape] Cannot infer the shape of an empty array");
+  }
+
+  // Check that the reshaping is valid
+  if (input.size() != size) {
+    std::ostringstream msg;
+    msg << "[reshape] Cannot reshape array of size " << input.size()
+        << " into shape " << shape << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  return shape;
+}
+
+std::vector<Shape> Reshape::output_shapes(const std::vector<array>& inputs) {
+  return {output_shape(inputs[0], shape_)};
+}
+
+std::vector<array> Reduce::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  auto in = primals[0];
+
+  auto& cotan = cotangents[0];
+  if (reduce_type_ == Reduce::Sum) {
+    return {broadcast_arrays({cotan, in}, stream())[0]};
+  } else if (reduce_type_ == Reduce::Prod) {
+    auto s = stream();
+    auto prod_grad_single_axis =
+        [&s](const array& x, const array& cotan, int axis) {
+          auto p1 = cumprod(x, axis, /*reverse=*/false, /*inclusive=*/false, s);
+          auto p2 = cumprod(x, axis, /*reverse=*/true, /*inclusive=*/false, s);
+          auto exclusive_prod = multiply(p1, p2, s);
+          return multiply(exclusive_prod, cotan, s);
+        };
+
+    // To compute a numerically stable gradient for prod we need an exclusive
+    // product of all elements in axes_ . To achieve that we move axes_ to the
+    // last dim and perform two exclusive cumprods. Afterwards we move
+    // everything back to the original axes.
+    if (axes_.size() > 1) {
+      std::vector<int> transpose_to;
+      std::vector<int> transpose_back;
+      Shape shape_flat;
+      {
+        // Find the transpose needed to move axes_ to the back and the shape
+        // except the reduced over axes.
+        int j = 0;
+        for (int i = 0; i < in.ndim(); i++) {
+          if (j < axes_.size() && axes_[j] == i) {
+            j++;
+          } else {
+            transpose_to.push_back(i);
+            shape_flat.push_back(in.shape(i));
+          }
+        }
+        for (auto ax : axes_) {
+          transpose_to.push_back(ax);
+        }
+        shape_flat.push_back(-1);
+        transpose_back.resize(transpose_to.size());
+        for (int i = 0; i < transpose_to.size(); i++) {
+          transpose_back[transpose_to[i]] = i;
+        }
+      }
+
+      // Move axes to the back
+      auto x = transpose(in, transpose_to, s);
+      // Keep the shape in order to reshape back to the original
+      auto shape_to = x.shape();
+
+      // Flatten and compute the gradient
+      x = reshape(x, shape_flat, stream());
+      auto grad = prod_grad_single_axis(x, reshape(cotan, shape_flat, s), -1);
+
+      // Reshape and transpose to the original shape
+      grad = reshape(grad, shape_to, s);
+      grad = transpose(grad, transpose_back, s);
+
+      return {grad};
+    } else {
+      return {prod_grad_single_axis(in, cotan, axes_[0])};
+    }
+
+  } else if (reduce_type_ == Reduce::Min || reduce_type_ == Reduce::Max) {
+    auto out = outputs[0];
+    if (out.ndim() != in.ndim()) {
+      out = expand_dims(out, axes_, stream());
+    }
+    auto mask = equal(in, out, stream());
+    auto normalizer = sum(mask, axes_, true, stream());
+    return {multiply(divide(cotan, normalizer, stream()), mask, stream())};
+  }
+
+  else {
+    return {zeros_like(in, stream())};
+  }
+}
+
+std::pair<std::vector<array>, std::vector<int>> Reduce::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto ax = axes[0];
+  auto reduce_axes = axes_;
+  if (ax >= 0) {
+    for (auto& rax : reduce_axes) {
+      if (rax >= ax) {
+        rax++;
+      }
+    }
+  }
+  auto& in = inputs[0];
+  std::vector<array> out;
+  switch (reduce_type_) {
+    case Reduce::And:
+      out.push_back(all(in, reduce_axes, true, stream()));
+      break;
+    case Reduce::Or:
+      out.push_back(any(in, reduce_axes, true, stream()));
+      break;
+    case Reduce::Sum:
+      out.push_back(sum(in, reduce_axes, true, stream()));
+      break;
+    case Reduce::Prod:
+      out.push_back(prod(in, reduce_axes, true, stream()));
+      break;
+    case Reduce::Min:
+      out.push_back(min(in, reduce_axes, true, stream()));
+      break;
+    case Reduce::Max:
+      out.push_back(max(in, reduce_axes, true, stream()));
+      break;
+  }
+  return {out, axes};
+}
+
+bool Reduce::is_equivalent(const Primitive& other) const {
+  const Reduce& r_other = static_cast<const Reduce&>(other);
+  return reduce_type_ == r_other.reduce_type_ && axes_ == r_other.axes_;
+}
+
+std::vector<Shape> Reduce::output_shapes(const std::vector<array>& inputs) {
+  auto out_shape = inputs[0].shape();
+  for (auto i : axes_) {
+    out_shape[i] = 1;
+  }
+  return {std::move(out_shape)};
+}
+
+std::vector<array> Round::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Round::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {zeros_like(primals[0], stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Round::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{round(inputs[0], stream())}, axes};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Scan::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto& in = inputs[0];
+  auto out_dtype =
+      (in.dtype() == bool_ && reduce_type_ == Scan::Sum) ? int32 : in.dtype();
+  int axis_left = axes[0] >= 0 && axes[0] <= axis_;
+  return {
+      {array(
+          in.shape(),
+          out_dtype,
+          std::make_shared<Scan>(
+              stream(), reduce_type_, axis_ + axis_left, reverse_, inclusive_),
+          {in})},
+      axes};
+}
+
+std::vector<array> Scan::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  assert(primals.size() == 1);
+  assert(argnums[0] == 0);
+
+  if (reduce_type_ == Scan::Sum) {
+    return {cumsum(cotangents[0], axis_, !reverse_, inclusive_, stream())};
+  } else if (reduce_type_ == Scan::LogAddExp) {
+    // Ref:
+    // https://github.com/tensorflow/tensorflow/blob/2a5910906a0e0f3dbc186ff9db6386d81a63448c/tensorflow/python/ops/math_grad.py#L1832-L1863
+
+    auto x = primals[0];
+    auto grad = cotangents[0];
+    auto results = outputs[0];
+
+    auto zero = zeros({1}, grad.dtype(), stream());
+    auto grad_min = array(finfo(grad.dtype()).min, grad.dtype());
+
+    // Split the incoming gradient into positive and negative part
+    // in order to take logs. This is required for stable results.
+    auto log_abs_grad = log(abs(grad, stream()), stream());
+    auto log_grad_positive =
+        where(greater(grad, zero, stream()), log_abs_grad, grad_min, stream());
+    auto log_grad_negative =
+        where(less(grad, zero, stream()), log_abs_grad, grad_min, stream());
+
+    auto output_pos = exp(
+        add(logcumsumexp(
+                subtract(log_grad_positive, results, stream()),
+                axis_,
+                !reverse_,
+                inclusive_,
+                stream()),
+            x,
+            stream()));
+    auto output_neg = exp(
+        add(logcumsumexp(
+                subtract(log_grad_negative, results, stream()),
+                axis_,
+                !reverse_,
+                inclusive_,
+                stream()),
+            x,
+            stream()));
+
+    return {subtract(output_pos, output_neg, stream())};
+  } else if (reduce_type_ == Scan::Prod) {
+    auto in = primals[0];
+    // Find the location of the first 0 and set it to 1:
+    // - A: Exclusive cumprod
+    // - B: Inclusive cumprod
+    // - Find the location that is 0 in A and not zero B
+    // Compute the gradient by:
+    // - Compute the regular gradient for everything before the first zero
+    // - Set the first zero to 1 and redo the computation, use this for the
+    //   gradient of the first zero
+    // - Everything after the first zero has a gradient of 0
+
+    // Get inclusive and exclusive cum prods
+    auto cprod_exclusive = cumprod(in, axis_, reverse_, !inclusive_, stream());
+    auto cprod_inclusive = outputs[0];
+    if (!inclusive_) {
+      std::swap(cprod_exclusive, cprod_inclusive);
+    }
+
+    // Make the mask for the first zero
+    auto z = array(0, in.dtype());
+    auto eq_zero = equal(cprod_inclusive, z, stream());
+    auto first_zero =
+        logical_and(eq_zero, not_equal(cprod_exclusive, z, stream()), stream());
+
+    auto to_partial_grad = [this, &cotangents](const array& arr) {
+      return cumsum(
+          multiply(arr, cotangents[0], stream()),
+          axis_,
+          !reverse_,
+          inclusive_,
+          stream());
+    };
+
+    auto cprod_with_one = cumprod(
+        where(first_zero, array(1, in.dtype()), in, stream()),
+        axis_,
+        reverse_,
+        inclusive_,
+        stream());
+    auto grad_with_one = to_partial_grad(cprod_with_one);
+    auto grad = divide(to_partial_grad(outputs[0]), in, stream());
+    return {where(
+        first_zero,
+        grad_with_one,
+        where(eq_zero, z, grad, stream()),
+        stream())};
+  } else {
+    // Can probably be implemented by equals and then cummax to make the mask
+    throw std::runtime_error("VJP is not implemented for cumulative min/max");
+  }
+}
+
+std::vector<array> Scan::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(tangents.size() == 1);
+  assert(argnums[0] == 0);
+
+  if (reduce_type_ == Scan::Sum) {
+    return {cumsum(tangents[0], axis_, reverse_, inclusive_, stream())};
+  } else {
+    throw std::runtime_error(
+        "JVP is not implemented for cumulative prod/min/max");
+  }
+}
+
+bool Scan::is_equivalent(const Primitive& other) const {
+  const Scan& s_other = static_cast<const Scan&>(other);
+  return (
+      reduce_type_ == s_other.reduce_type_ && axis_ == s_other.axis_ &&
+      reverse_ == s_other.reverse_ && inclusive_ == s_other.inclusive_);
+}
+
+bool Scatter::is_equivalent(const Primitive& other) const {
+  const Scatter& s_other = static_cast<const Scatter&>(other);
+  return reduce_type_ == s_other.reduce_type_ && axes_ == s_other.axes_;
+}
+
+std::vector<array> Scatter::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  switch (reduce_type_) {
+    case Scatter::None:
+    case Scatter::Sum:
+    case Scatter::Max:
+    case Scatter::Min:
+      break;
+    default:
+      throw std::runtime_error(
+          "[scatter] VJP not implemented for scatter_prod");
+  }
+
+  const array& result = outputs[0];
+  const array& values = primals[0];
+  const array& updates = primals.back();
+  const std::vector<array> indices(primals.begin() + 1, primals.end() - 1);
+
+  std::vector<array> vjps;
+  for (auto num : argnums) {
+    // Gradient wrt to the input array
+    if (num == 0) {
+      switch (reduce_type_) {
+        case Scatter::None:
+          // Scatter 0s to the locations that were updated with the updates
+          vjps.push_back(scatter(
+              cotangents[0],
+              indices,
+              zeros_like(updates, stream()),
+              axes_,
+              stream()));
+          break;
+        case Scatter::Sum:
+          // The input array values are kept so they all get gradients
+          vjps.push_back(cotangents[0]);
+          break;
+        case Scatter::Max:
+        case Scatter::Min: {
+          vjps.push_back(where(
+              equal(result, values, stream()),
+              cotangents[0],
+              array(0, cotangents[0].dtype()),
+              stream()));
+          break;
+        }
+        default:
+          // Should never reach here
+          throw std::invalid_argument("");
+      }
+    } else if (num == primals.size() - 1) {
+      switch (reduce_type_) {
+        case Scatter::None:
+        case Scatter::Sum: {
+          // Gather the values from the cotangent
+          auto slice_sizes = cotangents[0].shape();
+          for (auto ax : axes_) {
+            slice_sizes[ax] = 1;
+          }
+          vjps.push_back(
+              gather(cotangents[0], indices, axes_, slice_sizes, stream()));
+          break;
+        }
+        case Scatter::Max:
+        case Scatter::Min: {
+          auto slice_sizes = cotangents[0].shape();
+          for (auto ax : axes_) {
+            slice_sizes[ax] = 1;
+          }
+          auto gathered_cotan =
+              gather(cotangents[0], indices, axes_, slice_sizes, stream());
+          auto gathered_result =
+              gather(result, indices, axes_, slice_sizes, stream());
+          vjps.push_back(
+              multiply(gathered_cotan, gathered_result == updates, stream()));
+          break;
+        }
+        default: {
+          // Should never reach here
+          throw std::invalid_argument("");
+        }
+      }
+    } else {
+      throw std::invalid_argument(
+          "[scatter] Cannot calculate VJP with respect to indices.");
+    }
+  }
+  return vjps;
+}
+
+std::vector<array> Scatter::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  throw std::runtime_error("[scatter] JVP not yet implemented");
+}
+
+std::pair<std::vector<array>, std::vector<int>> Scatter::vmap(
+    const std::vector<array>& inputs_,
+    const std::vector<int>& vmap_axes) {
+  assert(inputs_.size() >= 2);
+  assert(inputs_.size() == vmap_axes.size());
+
+  auto inputs = inputs_;
+
+  auto scatter_axes = axes_;
+  int src_ax = vmap_axes[0];
+
+  auto vmap_ax_it = std::find_if(
+      vmap_axes.begin(), vmap_axes.end(), [](int a) { return a >= 0; });
+  auto vmap_ax = *vmap_ax_it;
+  if (vmap_ax >= 0) {
+    auto vmap_size = inputs[vmap_ax_it - vmap_axes.begin()].shape(vmap_ax);
+    if (src_ax < 0) {
+      src_ax = 0;
+      inputs[0] =
+          repeat(expand_dims(inputs[0], 0, stream()), vmap_size, 0, stream());
+    }
+    for (int i = 1; i < vmap_axes.size() - 1; ++i) {
+      // vmap axis for indices goes to 0
+      if (vmap_axes[i] >= 0) {
+        inputs[i] = moveaxis(inputs[i], vmap_axes[i], 0, stream());
+      }
+      // insert a vmap axis and repeat
+      if (vmap_axes[i] < 0) {
+        auto idx_shape = inputs[i].shape();
+        inputs[i] =
+            repeat(expand_dims(inputs[i], 0, stream()), vmap_size, 0, stream());
+      }
+      // Adjust non-vmapped index axes to account for the extra vmap dimension.
+      if (scatter_axes[i - 1] >= src_ax) {
+        scatter_axes[i - 1]++;
+      }
+    }
+
+    auto vmap_inds = arange(vmap_size, inputs[1].dtype(), stream());
+    auto vmap_inds_shape = Shape(inputs[1].ndim(), 1);
+    vmap_inds_shape[0] = vmap_inds.size();
+    vmap_inds = reshape(vmap_inds, std::move(vmap_inds_shape), stream());
+    inputs.insert(
+        inputs.end() - 1, broadcast_to(vmap_inds, inputs[1].shape(), stream()));
+    scatter_axes.push_back(src_ax);
+
+    // Clone updates along the vmap dimension so they can be applied to each
+    // source tensor in the vmap.
+    auto& updates = inputs.back();
+    if (vmap_axes.back() < 0) {
+      updates = expand_dims(
+          updates, {0, static_cast<int>(inputs[1].ndim())}, stream());
+      updates = repeat(updates, vmap_size, 0, stream());
+    } else {
+      updates =
+          expand_dims(updates, static_cast<int>(inputs[1].ndim()), stream());
+      updates = moveaxis(updates, vmap_axes.back(), 0, stream());
+    }
+  }
+
+  auto& shape = inputs[0].shape();
+  auto dtype = inputs[0].dtype();
+  auto out = array(
+      shape,
+      dtype,
+      std::make_shared<Scatter>(stream(), reduce_type_, scatter_axes),
+      std::move(inputs));
+
+  return {{out}, {src_ax}};
+}
+
+std::vector<array> ScatterAxis::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  const auto& indices = primals[1];
+  const auto& updates = primals[2];
+
+  std::vector<array> vjps;
+  for (auto num : argnums) {
+    // Gradient wrt to the input array
+    if (num == 0) {
+      if (reduce_type_ == ScatterAxis::None) {
+        // Scatter 0s to the locations that were updated with the updates
+        vjps.push_back(put_along_axis(
+            cotangents[0],
+            indices,
+            zeros_like(updates, stream()),
+            axis_,
+            stream()));
+      } else {
+        // The input array values are kept so they all get gradients
+        vjps.push_back(cotangents[0]);
+      }
+    } else if (num == 2) {
+      vjps.push_back(take_along_axis(cotangents[0], indices, axis_, stream()));
+    } else {
+      throw std::invalid_argument(
+          "[scatter_axis] Cannot calculate VJP with respect to indices.");
+    }
+  }
+  return vjps;
+}
+
+std::vector<array> ScatterAxis::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  for (auto arg : argnums) {
+    if (arg == 1) {
+      throw std::invalid_argument(
+          "[scatter_axis] Cannot calculate JVP with respect to indices.");
+    }
+  }
+  if (argnums.size() == 2) {
+    return {array(
+        primals[0].shape(),
+        primals[0].dtype(),
+        std::make_shared<ScatterAxis>(stream(), reduce_type_, axis_),
+        {tangents[0], primals[1], tangents[1]})};
+  } else {
+    auto tan_a =
+        argnums[0] == 0 ? tangents[0] : zeros_like(primals[0], stream());
+    auto tan_b =
+        argnums[0] == 2 ? tangents[0] : zeros_like(primals[2], stream());
+    return {array(
+        primals[0].shape(),
+        primals[0].dtype(),
+        std::make_shared<ScatterAxis>(stream(), reduce_type_, axis_),
+        {tan_a, primals[1], tan_b})};
+  }
+}
+
+std::pair<std::vector<array>, std::vector<int>> ScatterAxis::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  // Find the first vmap axis
+  int out_ax = -1;
+  for (auto ax : axes) {
+    if (ax >= 0) {
+      out_ax = ax;
+      break;
+    }
+  }
+
+  if (out_ax < 0) {
+    return {
+        {array(
+            inputs[0].shape(),
+            inputs[0].dtype(),
+            std::make_shared<ScatterAxis>(stream(), reduce_type_, axis_),
+            inputs)},
+        {-1}};
+  }
+
+  auto v_in = inputs;
+  for (int i = 0; i < axes.size(); ++i) {
+    if (axes[i] >= 0) {
+      // if out_ax >= 0 move axis o/w set out_ax
+      if (out_ax != axes[i]) {
+        v_in[i] = moveaxis(v_in[i], axes[i], out_ax, stream());
+      }
+    } else {
+      v_in[i] = expand_dims(v_in[i], out_ax, stream());
+    }
+  }
+  int axis = axis_ >= out_ax ? axis_ + 1 : axis_;
+  auto fn = reduce_type_ == Sum ? scatter_add_axis : put_along_axis;
+  return {{fn(v_in[0], v_in[1], v_in[2], axis, stream())}, {out_ax}};
+}
+
+std::vector<Shape> ScatterAxis::output_shapes(
+    const std::vector<array>& inputs) {
+  return {inputs[0].shape()};
+}
+
+bool ScatterAxis::is_equivalent(const Primitive& other) const {
+  auto& s_other = static_cast<const ScatterAxis&>(other);
+  return reduce_type_ == s_other.reduce_type_ && axis_ == s_other.axis_;
+}
+
+std::vector<array> Sigmoid::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  auto& s = outputs[0];
+  auto sprime =
+      multiply(s, subtract(array(1.0f, s.dtype()), s, stream()), stream());
+  return {multiply(cotangents[0], sprime, stream())};
+}
+
+std::vector<array> Sigmoid::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  auto s = sigmoid(primals[0], stream());
+  auto sprime =
+      multiply(s, subtract(array(1.0f, s.dtype()), s, stream()), stream());
+  return {multiply(tangents[0], sprime, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Sigmoid::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{sigmoid(inputs[0], stream())}, axes};
+}
+
+std::vector<array> Sign::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Sign::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {zeros(primals[0].shape(), primals[0].dtype(), stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Sign::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{sign(inputs[0], stream())}, axes};
+}
+
+std::vector<array> Sin::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Sin::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {multiply(tangents[0], cos(primals[0], stream()), stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Sin::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{sin(inputs[0], stream())}, axes};
+}
+
+std::vector<array> Sinh::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Sinh::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {multiply(tangents[0], cosh(primals[0], stream()), stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Sinh::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{sinh(inputs[0], stream())}, axes};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Slice::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto start = start_indices_;
+  auto stop = end_indices_;
+  auto strides = strides_;
+  auto ax = axes[0];
+  auto& input = inputs[0];
+  if (ax >= 0) {
+    start.insert(start.begin() + ax, 0);
+    stop.insert(stop.begin() + ax, input.shape(ax));
+    strides.insert(strides.begin() + ax, 1);
+  }
+  return {{slice(input, start, stop, strides, stream())}, {ax}};
+}
+
+std::vector<array> Slice::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  // Check inputs
+  assert(primals.size() == 1);
+  auto out = zeros_like(primals[0], stream());
+  return {slice_update(
+      out, cotangents[0], start_indices_, end_indices_, strides_, stream())};
+}
+
+std::vector<array> Slice::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  // Check inputs
+  assert(primals.size() == 1);
+  return {slice(tangents[0], start_indices_, end_indices_, strides_, stream())};
+}
+
+bool Slice::is_equivalent(const Primitive& other) const {
+  const Slice& s_other = static_cast<const Slice&>(other);
+  return (
+      start_indices_ == s_other.start_indices_ &&
+      end_indices_ == s_other.end_indices_ && strides_ == s_other.strides_);
+}
+
+std::pair<std::vector<array>, std::vector<int>> SliceUpdate::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 2);
+  assert(axes.size() == 2);
+
+  auto start = start_indices_;
+  auto stop = end_indices_;
+  auto strides = strides_;
+
+  auto src = inputs[0];
+  auto upd = inputs[1];
+
+  auto src_ax = axes[0];
+  auto upd_ax = axes[1];
+
+  // No vmapping needed
+  if (src_ax == -1 && upd_ax == -1) {
+    return {{slice_update(src, upd, start, stop, strides, stream())}, {-1}};
+  }
+
+  // Broadcast src
+  if (src_ax == -1) {
+    src = expand_dims(src, upd_ax, stream());
+    auto shape = src.shape();
+    shape[upd_ax] = upd.shape(upd_ax);
+    src = broadcast_to(src, shape, stream());
+    src_ax = upd_ax;
+  }
+
+  // Broadcast upd
+  if (upd_ax == -1) {
+    upd = expand_dims(upd, src_ax, stream());
+    upd_ax = src_ax;
+  }
+
+  if (src_ax != upd_ax) {
+    upd = moveaxis(upd, upd_ax, src_ax, stream());
+  }
+
+  start.insert(start.begin() + src_ax, 0);
+  stop.insert(stop.begin() + src_ax, src.shape(src_ax));
+  strides.insert(strides.begin() + src_ax, 1);
+
+  return {{slice_update(src, upd, start, stop, strides, stream())}, {src_ax}};
+}
+
+std::vector<array> SliceUpdate::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  // Check inputs
+  assert(primals.size() == 2);
+
+  auto& cotan = cotangents[0];
+  auto& src = primals[0];
+  auto& upd = primals[1];
+
+  std::vector<array> vjps;
+
+  for (int num : argnums) {
+    // Vjp for source
+    if (num == 0) {
+      vjps.push_back(slice_update(
+          cotan,
+          zeros_like(upd, stream()),
+          start_indices_,
+          end_indices_,
+          strides_,
+          stream()));
+    }
+    // Vjp fpr updates
+    else {
+      vjps.push_back(
+          slice(cotan, start_indices_, end_indices_, strides_, stream()));
+    }
+  }
+
+  return vjps;
+}
+
+std::vector<array> SliceUpdate::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  // Check inputs
+  assert(primals.size() == 2);
+  return {slice_update(
+      tangents[0],
+      tangents[1],
+      start_indices_,
+      end_indices_,
+      strides_,
+      stream())};
+}
+
+bool SliceUpdate::is_equivalent(const Primitive& other) const {
+  const auto& s_other = static_cast<const SliceUpdate&>(other);
+  return (
+      start_indices_ == s_other.start_indices_ &&
+      end_indices_ == s_other.end_indices_ && strides_ == s_other.strides_);
+}
+
+std::pair<std::vector<array>, std::vector<int>> DynamicSlice::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto& in = inputs[0];
+  auto& start = inputs[1];
+  auto vax = axes[0];
+  if (axes[1] >= 0) {
+    throw std::invalid_argument(
+        "[DynamicSlice::vmap] vmap over start indices not yet supported.");
+  }
+  auto slice_size = slice_size_;
+  auto slice_axes = axes_;
+  if (vax >= 0) {
+    for (auto& ax : slice_axes) {
+      if (ax >= vax) {
+        ax++;
+      }
+    }
+    slice_size.insert(slice_size.begin() + vax, in.shape(vax));
+  }
+  return {
+      {slice(
+          in, start, std::move(slice_axes), std::move(slice_size), stream())},
+      {vax}};
+}
+
+std::vector<array> DynamicSlice::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  if (argnums[0] == 1 || argnums.size() > 1) {
+    throw std::invalid_argument(
+        "[DynamicSlice::vjp] Not supported for start indices.");
+  }
+  auto out = zeros_like(primals[0], stream());
+  return {slice_update(out, cotangents[0], primals[1], axes_, stream())};
+}
+
+std::vector<array> DynamicSlice::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>&) {
+  return {slice(tangents[0], primals[1], axes_, slice_size_, stream())};
+}
+
+bool DynamicSlice::is_equivalent(const Primitive& other) const {
+  const auto& s_other = static_cast<const DynamicSlice&>(other);
+  return (axes_ == s_other.axes_ && slice_size_ == s_other.slice_size_);
+}
+
+std::vector<Shape> DynamicSlice::output_shapes(const std::vector<array>&) {
+  return {slice_size_};
+}
+
+std::pair<std::vector<array>, std::vector<int>> DynamicSliceUpdate::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto src = inputs[0];
+  auto upd = inputs[1];
+  auto& start = inputs[2];
+  auto src_ax = axes[0];
+  auto upd_ax = axes[1];
+  if (axes[2] >= 0) {
+    throw std::runtime_error(
+        "[DynamicSliceUpdate::vmap] vmap over start indices not yet supported.");
+  }
+  // No vmapping needed
+  if (src_ax == -1 && upd_ax == -1) {
+    return {{slice_update(src, upd, start, axes_, stream())}, {-1}};
+  }
+
+  // Broadcast src
+  if (src_ax == -1) {
+    src = expand_dims(src, upd_ax, stream());
+    auto shape = src.shape();
+    shape[upd_ax] = upd.shape(upd_ax);
+    src = broadcast_to(src, shape, stream());
+    src_ax = upd_ax;
+  }
+
+  // Broadcast upd
+  if (upd_ax == -1) {
+    upd = expand_dims(upd, src_ax, stream());
+    upd_ax = src_ax;
+  }
+
+  if (src_ax != upd_ax) {
+    upd = moveaxis(upd, upd_ax, src_ax, stream());
+  }
+
+  auto slice_axes = axes_;
+  for (auto& ax : slice_axes) {
+    if (ax >= src_ax) {
+      ax++;
+    }
+  }
+  return {
+      {slice_update(src, upd, start, std::move(slice_axes), stream())},
+      {src_ax}};
+}
+
+std::vector<array> DynamicSliceUpdate::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  auto& cotan = cotangents[0];
+  auto& upd = primals[1];
+  auto& start = primals[2];
+
+  std::vector<array> vjps;
+
+  for (int num : argnums) {
+    if (num == 0) {
+      // Vjp for source
+      vjps.push_back(slice_update(
+          cotan, zeros_like(upd, stream()), start, axes_, stream()));
+    } else if (num == 1) {
+      // Vjp fpr updates
+      vjps.push_back(slice(cotan, start, axes_, upd.shape(), stream()));
+    } else {
+      throw std::invalid_argument(
+          "[DynamicSliceUpdate::vjp] Not supported for start indices");
+    }
+  }
+  return vjps;
+}
+
+std::vector<array> DynamicSliceUpdate::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>&) {
+  return {slice_update(tangents[0], tangents[1], primals[2], axes_, stream())};
+}
+
+bool DynamicSliceUpdate::is_equivalent(const Primitive& other) const {
+  const auto& s_other = static_cast<const DynamicSliceUpdate&>(other);
+  return axes_ == s_other.axes_;
+}
+
+std::pair<std::vector<array>, std::vector<int>> Softmax::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+
+  std::vector<int> softmax_axes;
+
+  // We are vectorizing over an axis other than the last one so keep the
+  // softmax axis unchanged
+  if (axes[0] >= 0 && axes[0] < inputs[0].ndim() - 1) {
+    softmax_axes.push_back(-1);
+  } else {
+    softmax_axes.push_back(-2);
+  }
+  return {{softmax(inputs[0], softmax_axes, precise_, stream())}, axes};
+}
+
+std::vector<array> Softmax::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  assert(primals.size() == 1);
+  assert(cotangents.size() == 1);
+  auto& s = outputs[0];
+  auto sv = multiply(s, cotangents[0], stream());
+  return {subtract(
+      sv,
+      multiply(s, sum(sv, std::vector<int>{-1}, true, stream()), stream()))};
+}
+
+std::vector<array> Softmax::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(tangents.size() == 1);
+  auto s = softmax(primals[0], std::vector<int>{-1}, precise_, stream());
+  auto sv = multiply(s, tangents[0], stream());
+  return {subtract(
+      sv,
+      multiply(s, sum(sv, std::vector<int>{-1}, true, stream()), stream()))};
+}
+
+bool Softmax::is_equivalent(const Primitive& other) const {
+  const Softmax& s_other = static_cast<const Softmax&>(other);
+  return precise_ == s_other.precise_;
+}
+
+std::pair<std::vector<array>, std::vector<int>> Sort::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+
+  int axis_left = axes[0] >= 0 && axes[0] <= axis_;
+  return {{sort(inputs[0], axis_ + axis_left, stream())}, axes};
+}
+
+std::vector<array> Sort::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Sort::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(tangents.size() == 1);
+  auto sort_idx = argsort(primals[0], axis_, stream());
+  auto out = take_along_axis(tangents[0], sort_idx, axis_, stream());
+  return {out};
+}
+
+bool Sort::is_equivalent(const Primitive& other) const {
+  const Sort& r_other = static_cast<const Sort&>(other);
+  return axis_ == r_other.axis_;
+}
+
+std::pair<std::vector<array>, std::vector<int>> Split::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  int axis_left = axes[0] >= 0 && axes[0] <= axis_;
+  auto output = split(inputs[0], indices_, axis_ + axis_left, stream());
+  std::vector<int> output_axes(output.size(), axes[0]);
+  return {std::move(output), std::move(output_axes)};
+}
+
+std::vector<array> Split::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return {concatenate(cotangents, axis_, stream())};
+}
+
+std::vector<array> Split::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  return split(tangents[0], indices_, axis_, stream());
+}
+
+bool Split::is_equivalent(const Primitive& other) const {
+  const Split& s_other = static_cast<const Split&>(other);
+  return axis_ == s_other.axis_ && indices_ == s_other.indices_;
+}
+
+std::vector<array> Square::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Square::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(tangents.size() == 1);
+  return {multiply(
+      primals[0],
+      multiply(array(2, primals[0].dtype()), tangents[0], stream()),
+      stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Square::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{square(inputs[0], stream())}, axes};
+}
+
+std::vector<array> Sqrt::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>& outputs) {
+  assert(primals.size() == 1);
+  assert(cotangents.size() == 1);
+  auto dtype = primals[0].dtype();
+  if (recip_) {
+    auto one_over_x_root_x = divide(outputs[0], primals[0], stream());
+    return {multiply(
+        multiply(array(-0.5, dtype), cotangents[0], stream()),
+        one_over_x_root_x,
+        stream())};
+  } else {
+    return {divide(
+        multiply(array(0.5, dtype), cotangents[0], stream()),
+        outputs[0],
+        stream())};
+  }
+}
+
+std::vector<array> Sqrt::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  if (recip_) {
+    return vjp(primals, tangents, argnums, {rsqrt(primals[0], stream())});
+  } else {
+    return vjp(primals, tangents, argnums, {sqrt(primals[0], stream())});
+  }
+}
+
+std::pair<std::vector<array>, std::vector<int>> Sqrt::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  if (recip_) {
+    return {{rsqrt(inputs[0], stream())}, axes};
+  }
+  return {{sqrt(inputs[0], stream())}, axes};
+}
+
+bool Sqrt::is_equivalent(const Primitive& other) const {
+  const Sqrt& s_other = static_cast<const Sqrt&>(other);
+  return recip_ == s_other.recip_;
+}
+
+std::pair<std::vector<array>, std::vector<int>> StopGradient::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  return {{stop_gradient(inputs[0], stream())}, axes};
+}
+
+std::vector<array> Subtract::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    auto vjp = cotangents[0];
+    if (arg == 1) {
+      vjp = negative(vjp, stream());
+    }
+    vjps.push_back(vjp);
+  }
+  return vjps;
+}
+
+std::vector<array> Subtract::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  auto jvp_fun = [&](int i) {
+    int arg = argnums[i];
+    return arg == 1 ? negative(tangents[i], stream()) : tangents[i];
+  };
+  auto out = jvp_fun(0);
+  if (argnums.size() > 1) {
+    out = add(out, jvp_fun(1), stream());
+  }
+  return {out};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Subtract::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto [a, b, to_ax] = vmap_binary_op(inputs, axes, stream());
+  return {{subtract(a, b, stream())}, {to_ax}};
+}
+
+std::vector<array> Squeeze::vjp(
+    const std::vector<array>&,
+    const std::vector<array>& cotangents,
+    const std::vector<int>&,
+    const std::vector<array>&) {
+  return {expand_dims(cotangents[0], axes_, stream())};
+}
+
+std::vector<array> Squeeze::jvp(
+    const std::vector<array>&,
+    const std::vector<array>& tangents,
+    const std::vector<int>&) {
+  return {squeeze(tangents[0], axes_, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Squeeze::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto ax = axes[0];
+  auto squeeze_axes = axes_;
+  for (auto& s : squeeze_axes) {
+    if (s >= axes[0]) {
+      s++;
+    } else {
+      ax--;
+    }
+  }
+  return {{squeeze(inputs[0], std::move(squeeze_axes), stream())}, {ax}};
+}
+
+bool Squeeze::is_equivalent(const Primitive& other) const {
+  const Squeeze& a_other = static_cast<const Squeeze&>(other);
+  return (axes_ == a_other.axes_);
+}
+
+Shape Squeeze::output_shape(const array& input, const std::vector<int>& axes) {
+  Shape shape;
+  for (int i = 0, j = 0; i < input.ndim(); ++i) {
+    if (j < axes.size() && i == axes[j]) {
+      j++;
+    } else {
+      shape.push_back(input.shape(i));
+    }
+  }
+  return shape;
+}
+
+std::vector<Shape> Squeeze::output_shapes(const std::vector<array>& inputs) {
+  return {Squeeze::output_shape(inputs[0], axes_)};
+}
+
+std::vector<array> Tan::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Tan::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  array cos_sq = square(cos(primals[0], stream()), stream());
+  return {divide(tangents[0], cos_sq, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Tan::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{tan(inputs[0], stream())}, axes};
+}
+
+std::vector<array> Tanh::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Tanh::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  array cosh_sq = square(cosh(primals[0], stream()), stream());
+  return {divide(tangents[0], cosh_sq, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Tanh::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{tanh(inputs[0], stream())}, axes};
+}
+
+std::pair<std::vector<array>, std::vector<int>> BitwiseInvert::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{bitwise_invert(inputs[0], stream())}, axes};
+}
+
+std::vector<array> BlockMaskedMM::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  /////////////////////////////////////////////////////////////////////////////
+  // The operation that is done w/o intermediates by the primitive is
+  //    - tm = (M + block_size - 1) // block_size; MP = tm * block_size;
+  //    - tn = (N + block_size - 1) // block_size; NP = tn * block_size;
+  //    - tm = (K + block_size - 1) // block_size; KP = tk * block_size;
+  //    - mask_b <- mask broadcasted to block sizes
+  //    - A_m = A [..., M, K] * mask_b_lhs [..., MP, KP]
+  //    - B_m = B [..., K, N] * mask_b_rhs [..., KP, MP]
+  //    - C = A_m [..., M, K]  @ B_m [..., K, N]
+  //    - C_m = C [..., M, N] * mask_b_out [..., MP, NP]
+  //
+  // The grads are therefore
+  //    - dC_m = cotan [..., M, N]
+  //    - dmask_b_out = cotan [..., M, N] * C [..., M, N]
+  //    - dC = cotan [..., M, N] * mask_b_out [..., MP, NP]
+  //    - dA_m = dC [..., M, N] @ B_m.T [..., N, K]
+  //    - dB_m = A_m.T [..., K, M] @ dC [..., M, N]
+  //    - dA = dA_m * mask_b_lhs [..., MP, KP]
+  //    - dB = dB_m * mask_b_rhs [..., KP, MP]
+  //    - dmask_b_lhs = dA_m [..., M, K] * A [..., M, K] // need [..., MP, KP]
+  //    - dmask_b_rhs = dB_m [..., K, N] * B [..., K, N] // need [..., KP, NP]
+  //
+  // Observations:
+  //  * If dmask_b_lhs is not needed, then dA can be calulated in one go as a
+  //    as a block_masked_mm with mask_b_lhs as the out_mask without needing to
+  //    materialize the intermediate dA_m. Similar for dB.
+  //  * If dmask_b_lhs is needed, we need to materialize dA_m directly and then
+  //    point-wise multiply with A. But the output needs to be padded
+
+  std::vector<array> vjps;
+  auto& cotan = cotangents[0];
+  std::vector<int> reorder(cotan.ndim());
+  std::iota(reorder.begin(), reorder.end(), 0);
+  std::iter_swap(reorder.end() - 1, reorder.end() - 2);
+
+  bool has_op_mask = primals.size() > 3;
+  bool has_out_mask = primals.size() == 3 || primals.size() == 5;
+
+  const int op_mask_idx = has_out_mask ? 3 : 2;
+  bool needs_lhs_mask_vjp = has_op_mask;
+  bool needs_rhs_mask_vjp = has_op_mask;
+  bool needs_lhs_vjp = false;
+  bool needs_rhs_vjp = false;
+
+  for (auto arg : argnums) {
+    needs_lhs_vjp = arg == 0;
+    needs_rhs_vjp = arg == 1;
+    needs_lhs_mask_vjp = arg == op_mask_idx;
+    needs_rhs_mask_vjp = arg == op_mask_idx + 1;
+  }
+
+  if ((needs_lhs_mask_vjp && primals[op_mask_idx].dtype() == bool_) ||
+      (needs_rhs_mask_vjp && primals[op_mask_idx + 1].dtype() == bool_)) {
+    throw std::invalid_argument(
+        "[BlockMaskedMM] Cannot calculate VJP with respect to boolean masks.");
+  }
+
+  auto expand_mask = [&](array mask, int Y, int X) {
+    // Exapnd mask
+    auto mask_reshape = mask.shape();
+    mask = expand_dims(mask, {-3, -1}, stream());
+    auto mask_shape = mask.shape();
+    int mask_ndim = mask_shape.size();
+
+    // Broadcast mask
+    mask_shape[mask_ndim - 1] = block_size_;
+    mask_shape[mask_ndim - 3] = block_size_;
+    mask = broadcast_to(mask, mask_shape, stream());
+
+    // Reshape mask to squeeze in braodcasted dims
+    mask_ndim = mask_reshape.size();
+    mask_reshape[mask_ndim - 2] *= block_size_;
+    mask_reshape[mask_ndim - 1] *= block_size_;
+    mask = reshape(mask, mask_reshape, stream());
+
+    // Slice mask
+    mask_reshape[mask_ndim - 2] = Y;
+    mask_reshape[mask_ndim - 1] = X;
+    mask = slice(mask, Shape(mask_ndim, 0), mask_reshape, stream());
+
+    return mask;
+  };
+
+  array zero = array(0, cotan.dtype());
+
+  auto multiply_pad_reduce = [&](array p, array q, int align_Y, int align_X) {
+    // Multiply with cotan
+    auto r = multiply(p, q, stream());
+
+    // Pad if needed
+    if ((align_Y != 0) || (align_X != 0)) {
+      r = pad(
+          r, {-2, -1}, {0, 0}, {align_Y, align_X}, zero, "constant", stream());
+    }
+
+    // Reshape
+    Shape r_reshape(r.shape().begin(), r.shape().end() - 2);
+    r_reshape.push_back(r.shape(-2) / block_size_);
+    r_reshape.push_back(block_size_);
+    r_reshape.push_back(r.shape(-1) / block_size_);
+    r_reshape.push_back(block_size_);
+    r = reshape(r, r_reshape, stream());
+
+    // Reduce
+    return sum(r, {-3, -1}, false, stream());
+  };
+
+  // Prepare for padding if needed
+  const int M = cotan.shape(-2);
+  const int N = cotan.shape(-1);
+  const int K = primals[0].shape(-1);
+  const int tm = (M + block_size_ - 1) / block_size_;
+  const int tn = (N + block_size_ - 1) / block_size_;
+  const int tk = (K + block_size_ - 1) / block_size_;
+  const int align_M = tm * block_size_ - M;
+  const int align_N = tn * block_size_ - N;
+  const int align_K = tk * block_size_ - K;
+
+  // Potential intermediates
+  array unmasked_lhs_grad = primals[0];
+  array unmasked_rhs_grad = primals[1];
+
+  bool unmasked_lhs_grad_calculated = false;
+  bool unmasked_rhs_grad_calculated = false;
+
+  for (auto arg : argnums) {
+    if (arg == 0) {
+      // M X N * (K X N).T -> M X K
+      auto b_t = transpose(primals[1], reorder, stream());
+      auto out_mask =
+          has_out_mask ? std::make_optional<array>(primals[2]) : std::nullopt;
+      auto lhs_mask = has_op_mask && !needs_lhs_mask_vjp
+          ? std::make_optional<array>(primals[op_mask_idx])
+          : std::nullopt;
+      auto rhs_mask_t = has_op_mask
+          ? std::make_optional<array>(
+                transpose(primals[op_mask_idx + 1], reorder, stream()))
+          : std::nullopt;
+
+      auto grad = block_masked_mm(
+          cotan, b_t, block_size_, lhs_mask, out_mask, rhs_mask_t, stream());
+
+      if (needs_lhs_mask_vjp) {
+        unmasked_lhs_grad = grad;
+        unmasked_lhs_grad_calculated = true;
+        auto exp_mask = expand_mask(primals[op_mask_idx], M, K);
+        grad = multiply(grad, exp_mask, stream());
+      }
+
+      vjps.push_back(grad);
+
+    } else if (arg == 1) {
+      // (M X K).T * M X N -> K X N
+      auto a_t = transpose(primals[0], reorder, stream());
+      auto out_mask =
+          has_out_mask ? std::make_optional<array>(primals[2]) : std::nullopt;
+      auto lhs_mask_t = has_op_mask
+          ? std::make_optional<array>(
+                transpose(primals[op_mask_idx], reorder, stream()))
+          : std::nullopt;
+      auto rhs_mask = has_op_mask && !needs_rhs_mask_vjp
+          ? std::make_optional<array>(primals[op_mask_idx + 1])
+          : std::nullopt;
+
+      auto grad = block_masked_mm(
+          a_t, cotan, block_size_, rhs_mask, lhs_mask_t, out_mask, stream());
+
+      if (needs_rhs_mask_vjp) {
+        unmasked_rhs_grad = grad;
+        unmasked_rhs_grad_calculated = true;
+        auto exp_mask = expand_mask(primals[op_mask_idx + 1], K, N);
+        grad = multiply(grad, exp_mask, stream());
+      }
+
+      vjps.push_back(grad);
+
+    } else if (arg == 2 && has_out_mask) {
+      // Produce the forward result
+      auto lhs_mask = has_op_mask
+          ? std::make_optional<array>(primals[op_mask_idx])
+          : std::nullopt;
+      auto rhs_mask = has_op_mask
+          ? std::make_optional<array>(primals[op_mask_idx + 1])
+          : std::nullopt;
+
+      auto C = block_masked_mm(
+          primals[0],
+          primals[1],
+          block_size_,
+          primals[2],
+          lhs_mask,
+          rhs_mask,
+          stream());
+
+      // Multiply, Pad and Reduce if needed
+      auto grad = multiply_pad_reduce(cotan, C, align_M, align_N);
+      vjps.push_back(grad);
+
+    } else if (arg == op_mask_idx && has_op_mask) {
+      if (!unmasked_lhs_grad_calculated) {
+        // (M X K).T * M X N -> K X N
+        auto b_t = transpose(primals[1], reorder, stream());
+        auto out_mask =
+            has_out_mask ? std::make_optional<array>(primals[2]) : std::nullopt;
+        auto rhs_mask_t =
+            transpose(primals[op_mask_idx + 1], reorder, stream());
+
+        unmasked_lhs_grad = block_masked_mm(
+            cotan,
+            b_t,
+            block_size_,
+            std::nullopt,
+            out_mask,
+            rhs_mask_t,
+            stream());
+
+        unmasked_lhs_grad_calculated = true;
+      }
+
+      // Multiply, Pad and Reduce if needed
+      auto grad =
+          multiply_pad_reduce(primals[0], unmasked_lhs_grad, align_M, align_K);
+      vjps.push_back(grad);
+
+    } else if (arg == op_mask_idx + 1 && has_op_mask) {
+      if (!unmasked_rhs_grad_calculated) {
+        // (M X K).T * M X N -> K X N
+        auto a_t = transpose(primals[0], reorder, stream());
+        auto out_mask =
+            has_out_mask ? std::make_optional<array>(primals[2]) : std::nullopt;
+        auto lhs_mask_t = transpose(primals[op_mask_idx], reorder, stream());
+
+        unmasked_rhs_grad = block_masked_mm(
+            a_t,
+            cotan,
+            block_size_,
+            std::nullopt,
+            lhs_mask_t,
+            out_mask,
+            stream());
+
+        unmasked_rhs_grad_calculated = true;
+      }
+
+      // Multiply, Pad and Reduce if needed
+      auto grad =
+          multiply_pad_reduce(primals[1], unmasked_rhs_grad, align_K, align_N);
+      vjps.push_back(grad);
+
+    } else {
+      throw std::invalid_argument(
+          "[BlockMaskedMM] Cannot calculate VJP with respect to masks.");
+    }
+  }
+  return vjps;
+}
+
+std::vector<array> GatherMM::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  std::vector<array> vjps;
+  auto& cotan = cotangents[0];
+
+  auto& a = primals[0];
+  auto& b = primals[1];
+  auto& lhs_indices = primals[2];
+  auto& rhs_indices = primals[3];
+
+  int M = cotan.shape(-2);
+  int N = cotan.shape(-1);
+  int K = primals[0].shape(-1);
+
+  bool sorted = left_sorted_ || right_sorted_;
+  bool no_broadcast = rhs_indices.size() * M * K == primals[0].size();
+
+  for (auto arg : argnums) {
+    if (arg == 0) {
+      auto g = gather_mm(
+          cotan,
+          swapaxes(b, -1, -2, stream()),
+          std::nullopt,
+          rhs_indices,
+          sorted,
+          stream());
+      if (sorted && no_broadcast) {
+        vjps.push_back(g);
+      } else {
+        vjps.push_back(reshape(
+            scatter_add(
+                flatten(zeros_like(a, stream()), 0, -3, stream()),
+                lhs_indices,
+                expand_dims(g, -3, stream()),
+                0,
+                stream()),
+            a.shape(),
+            stream()));
+      }
+    } else if (arg == 1) {
+      auto shape = b.shape();
+      shape.pop_back();
+      shape.pop_back();
+      vjps.push_back(swapaxes(
+          gather_mm_grad(
+              a,
+              cotan,
+              lhs_indices,
+              rhs_indices,
+              sorted,
+              std::move(shape),
+              stream()),
+          -1,
+          -2,
+          stream()));
+    } else {
+      throw std::invalid_argument(
+          "[GatherMM] Cannot calculate VJP with respect to indices.");
+    }
+  }
+  return vjps;
+}
+
+bool GatherMM::is_equivalent(const Primitive& other) const {
+  const GatherMM& g_other = static_cast<const GatherMM&>(other);
+  return left_sorted_ == g_other.left_sorted_ &&
+      right_sorted_ == g_other.right_sorted_;
+}
+
+bool BlockMaskedMM::is_equivalent(const Primitive& other) const {
+  const BlockMaskedMM& a_other = static_cast<const BlockMaskedMM&>(other);
+  return (block_size_ == a_other.block_size_);
+}
+
+std::vector<array> Transpose::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  std::vector<int> iaxes(axes_.size());
+  for (int i = 0; i < axes_.size(); ++i) {
+    iaxes[axes_[i]] = i;
+  }
+  return {transpose(cotangents[0], iaxes, stream())};
+}
+
+std::vector<array> Transpose::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(tangents.size() == 1);
+  return {transpose(tangents[0], axes_, stream())};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Transpose::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  auto vdim = axes[0];
+  if (vdim >= 0) {
+    for (auto& dim : axes_) {
+      if (dim >= vdim) {
+        dim++;
+      }
+    }
+    axes_.insert(axes_.begin() + vdim, vdim);
+  }
+  return {{transpose(inputs[0], axes_, stream())}, {vdim}};
+}
+
+bool Transpose::is_equivalent(const Primitive& other) const {
+  const Transpose& t_other = static_cast<const Transpose&>(other);
+  return axes_ == t_other.axes_;
+}
+
+std::vector<Shape> Transpose::output_shapes(const std::vector<array>& inputs) {
+  auto& in = inputs[0];
+  Shape shape(in.ndim(), 0);
+  for (int i = 0; i < axes_.size(); ++i) {
+    shape[i] = in.shape()[axes_[i]];
+  }
+  return {std::move(shape)};
+}
+
+std::pair<std::vector<array>, std::vector<int>> NumberOfElements::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+
+  std::vector<int> new_axes = axes_;
+  auto vdim = axes[0];
+  if (vdim >= 0) {
+    for (auto& dim : new_axes) {
+      if (dim >= vdim) {
+        dim++;
+      }
+    }
+  }
+
+  array out = array(
+      {},
+      dtype_,
+      std::make_shared<NumberOfElements>(stream(), new_axes, inverted_, dtype_),
+      inputs);
+
+  return {{out}, {-1}};
+}
+
+bool NumberOfElements::is_equivalent(const Primitive& other) const {
+  const NumberOfElements& n_other = static_cast<const NumberOfElements&>(other);
+  return axes_ == n_other.axes_ && inverted_ == n_other.inverted_ &&
+      dtype_ == n_other.dtype_;
+}
+
+std::pair<std::vector<array>, std::vector<int>> SVD::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto ax = axes[0] >= 0 ? 0 : -1;
+  auto a = axes[0] > 0 ? moveaxis(inputs[0], axes[0], 0, stream()) : inputs[0];
+  std::vector<int> new_axes(compute_uv_ ? 3 : 1, ax);
+  return {linalg::svd(a, compute_uv_, stream()), std::move(new_axes)};
+}
+
+std::pair<std::vector<array>, std::vector<int>> Inverse::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  auto ax = axes[0] >= 0 ? 0 : -1;
+  auto a = axes[0] > 0 ? moveaxis(inputs[0], axes[0], 0, stream()) : inputs[0];
+  return {{linalg::inv(a, stream())}, {ax}};
+}
+
+std::pair<std::vector<array>, std::vector<int>> View::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  return {{view(inputs[0], dtype_, stream())}, axes};
+}
+
+const char* View::name() const {
+  if (name_.empty()) {
+    std::ostringstream os;
+    os << "View " << dtype_;
+    name_ = os.str();
+  }
+  return name_.c_str();
+}
+
+bool View::is_equivalent(const Primitive& other) const {
+  const View& a_other = static_cast<const View&>(other);
+  return (dtype_ == a_other.dtype_);
+}
+
+std::pair<std::vector<array>, std::vector<int>> Hadamard::vmap(
+    const std::vector<array>& inputs,
+    const std::vector<int>& axes) {
+  assert(inputs.size() == 1);
+  assert(axes.size() == 1);
+  auto& s = stream();
+  if (axes[0] == inputs[0].ndim() - 1) {
+    auto a = moveaxis(inputs[0], axes[0], 0, s);
+    auto b = hadamard_transform(a, scale_, s);
+    return {{b}, {0}};
+  }
+  return {{hadamard_transform(inputs[0], scale_, s)}, axes};
+}
+
+std::vector<array> Hadamard::vjp(
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents,
+    const std::vector<int>& argnums,
+    const std::vector<array>&) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return jvp(primals, cotangents, argnums);
+}
+
+std::vector<array> Hadamard::jvp(
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents,
+    const std::vector<int>& argnums) {
+  assert(primals.size() == 1);
+  assert(argnums.size() == 1);
+  return {hadamard_transform(tangents[0], scale_, stream())};
+}
+
+bool Hadamard::is_equivalent(const Primitive& other) const {
+  const Hadamard& h_other = static_cast<const Hadamard&>(other);
+  return scale_ == h_other.scale_;
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/primitives.h b/ml-stable-diffusion/mlx/mlx/primitives.h
new file mode 100644
index 0000000000000000000000000000000000000000..2a843a0e4af791057fe6848f5ec54e3c5c6270ed
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/primitives.h
@@ -0,0 +1,2482 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <unordered_set>
+
+#include "mlx/array.h"
+#include "mlx/device.h"
+#include "mlx/io/load.h"
+#include "mlx/stream.h"
+
+#define DEFINE_VMAP()                                                 \
+  virtual std::pair<std::vector<array>, std::vector<int>> vmap(       \
+      const std::vector<array>& inputs, const std::vector<int>& axes) \
+      override;
+
+#define DEFINE_GRADS()                           \
+  std::vector<array> jvp(                        \
+      const std::vector<array>& primals,         \
+      const std::vector<array>& tangents,        \
+      const std::vector<int>& argnums) override; \
+                                                 \
+  std::vector<array> vjp(                        \
+      const std::vector<array>& primals,         \
+      const std::vector<array>& cotangents,      \
+      const std::vector<int>& argnums,           \
+      const std::vector<array>& outputs) override;
+
+#define DEFINE_NAME(PRIMITIVE)        \
+  const char* name() const override { \
+    return #PRIMITIVE;                \
+  }
+
+#define DEFINE_DEFAULT_IS_EQUIVALENT()                        \
+  bool is_equivalent(const Primitive& other) const override { \
+    return true;                                              \
+  }
+
+#define DEFINE_INPUT_OUTPUT_SHAPE()                                  \
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) \
+      override {                                                     \
+    return {inputs[0].shape()};                                      \
+  }
+
+namespace mlx::core {
+
+// Abstract base class
+class Primitive {
+ public:
+  explicit Primitive(Stream stream) : stream_(stream) {}
+
+  /** The device the primitive will run on. */
+  const Device& device() {
+    return stream().device;
+  }
+
+  /** The stream the primitive will run on. */
+  const Stream& stream() {
+    return stream_;
+  }
+
+  /**
+   * A primitive must know how to evaluate itself on
+   * the CPU/GPU for the given inputs and populate the output arrays.
+   *
+   * To avoid unnecessary allocations, the evaluation function
+   * is responsible for allocating space for the array.
+   */
+  virtual void eval_cpu(
+      const std::vector<array>& inputs,
+      std::vector<array>& outputs) = 0;
+  virtual void eval_gpu(
+      const std::vector<array>& inputs,
+      std::vector<array>& outputs) = 0;
+
+  /**
+   * The Jacobian-vector product.
+   */
+  virtual std::vector<array> jvp(
+      const std::vector<array>& primals,
+      const std::vector<array>& tangents,
+      const std::vector<int>& argnums);
+
+  /**
+   * The vector-Jacobian product.
+   */
+  virtual std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const std::vector<array>& cotangents,
+      const std::vector<int>& argnums,
+      const std::vector<array>& outputs);
+
+  /**
+   * The primitive must know how to vectorize itself across
+   * the given axes. The output is a pair containing the output arrays
+   * representing the vectorized computation and the axes which
+   * corresponds to the vectorized dimensions of each output.
+   */
+  virtual std::pair<std::vector<array>, std::vector<int>> vmap(
+      const std::vector<array>& inputs,
+      const std::vector<int>& axes);
+
+  /** Get the name of primitive. */
+  virtual const char* name() const = 0;
+
+  /** Equivalence check defaults to false unless overridden by the primitive */
+  virtual bool is_equivalent(const Primitive& other) const {
+    return false;
+  }
+
+  /** Get the output shapes of the primitive. This is not required to be
+   * implemented by derived classes, in which case it will throw. */
+  virtual std::vector<Shape> output_shapes(const std::vector<array>& inputs);
+
+  virtual ~Primitive() = default;
+  Primitive(const Primitive& other) = delete;
+  Primitive(Primitive&& other) = delete;
+  Primitive& operator=(const Primitive& other) = delete;
+  Primitive& operator=(Primitive&& other) = delete;
+
+ private:
+  // Every primitive stores the stream it should run in
+  Stream stream_;
+};
+
+class UnaryPrimitive : public Primitive {
+  /**
+   * An abstract base class for a primitive with a single output.
+   */
+ public:
+  explicit UnaryPrimitive(Stream stream) : Primitive(stream) {}
+
+  virtual void eval_cpu(const std::vector<array>& inputs, array& output) = 0;
+  virtual void eval_gpu(const std::vector<array>& inputs, array& output) = 0;
+
+  inline void eval_cpu(
+      const std::vector<array>& inputs,
+      std::vector<array>& outputs) override {
+    eval_cpu(inputs, outputs[0]);
+  }
+  inline void eval_gpu(
+      const std::vector<array>& inputs,
+      std::vector<array>& outputs) override {
+    eval_gpu(inputs, outputs[0]);
+  }
+
+  virtual ~UnaryPrimitive() = default;
+  UnaryPrimitive(const UnaryPrimitive& other) = delete;
+  UnaryPrimitive(UnaryPrimitive&& other) = delete;
+  UnaryPrimitive& operator=(const UnaryPrimitive& other) = delete;
+  UnaryPrimitive& operator=(UnaryPrimitive&& other) = delete;
+};
+
+enum class QuantizationMode { Affine, Mxfp4 };
+
+std::string quantization_mode_to_string(QuantizationMode mode);
+QuantizationMode string_to_quantization_mode(const std::string& mode);
+
+class Abs : public UnaryPrimitive {
+ public:
+  explicit Abs(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Abs)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Add : public UnaryPrimitive {
+ public:
+  explicit Add(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Add)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class AddMM : public UnaryPrimitive {
+ public:
+  explicit AddMM(Stream stream, float alpha, float beta)
+      : UnaryPrimitive(stream), alpha_(alpha), beta_(beta) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_GRADS()
+  DEFINE_VMAP()
+  DEFINE_NAME(AddMM)
+
+  bool is_equivalent(const Primitive& other) const override;
+  std::pair<float, float> state() const {
+    return {alpha_, beta_};
+  };
+
+ private:
+  const float alpha_;
+  const float beta_;
+};
+
+class Arange : public UnaryPrimitive {
+ public:
+  explicit Arange(Stream stream, double start, double stop, double step)
+      : UnaryPrimitive(stream), start_(start), stop_(stop), step_(step) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_NAME(Arange)
+  bool is_equivalent(const Primitive& other) const override;
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  std::tuple<double, double, double> state() const {
+    return {start_, stop_, step_};
+  };
+
+ private:
+  double start_;
+  double stop_;
+  double step_;
+};
+
+class ArcCos : public UnaryPrimitive {
+ public:
+  explicit ArcCos(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(ArcCos)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class ArcCosh : public UnaryPrimitive {
+ public:
+  explicit ArcCosh(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(ArcCosh)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class ArcSin : public UnaryPrimitive {
+ public:
+  explicit ArcSin(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(ArcSin)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class ArcSinh : public UnaryPrimitive {
+ public:
+  explicit ArcSinh(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(ArcSinh)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class ArcTan : public UnaryPrimitive {
+ public:
+  explicit ArcTan(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(ArcTan)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class ArcTan2 : public UnaryPrimitive {
+ public:
+  explicit ArcTan2(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(ArcTan2)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class ArcTanh : public UnaryPrimitive {
+ public:
+  explicit ArcTanh(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(ArcTanh)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class ArgPartition : public UnaryPrimitive {
+ public:
+  explicit ArgPartition(Stream stream, int kth, int axis)
+      : UnaryPrimitive(stream), kth_(kth), axis_(axis) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(ArgPartition)
+  DEFINE_INPUT_OUTPUT_SHAPE()
+  bool is_equivalent(const Primitive& other) const override;
+  std::pair<int, int> state() const {
+    return {kth_, axis_};
+  };
+
+ private:
+  int kth_;
+  int axis_;
+};
+
+class ArgReduce : public UnaryPrimitive {
+ public:
+  enum ReduceType {
+    ArgMin,
+    ArgMax,
+  };
+
+  explicit ArgReduce(Stream stream, ReduceType reduce_type, int axis)
+      : UnaryPrimitive(stream), reduce_type_(reduce_type), axis_(axis) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(ArgReduce)
+  bool is_equivalent(const Primitive& other) const override;
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  std::pair<ReduceType, int> state() const {
+    return {reduce_type_, axis_};
+  };
+
+ private:
+  ReduceType reduce_type_;
+  int axis_;
+};
+
+class ArgSort : public UnaryPrimitive {
+ public:
+  explicit ArgSort(Stream stream, int axis)
+      : UnaryPrimitive(stream), axis_(axis) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(ArgSort)
+  DEFINE_INPUT_OUTPUT_SHAPE()
+  bool is_equivalent(const Primitive& other) const override;
+  int state() const {
+    return axis_;
+  };
+
+ private:
+  int axis_;
+};
+
+class AsType : public UnaryPrimitive {
+ public:
+  explicit AsType(Stream stream, Dtype dtype)
+      : UnaryPrimitive(stream), dtype_(dtype) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(AsType)
+  DEFINE_INPUT_OUTPUT_SHAPE()
+  bool is_equivalent(const Primitive& other) const override;
+  Dtype state() const {
+    return dtype_;
+  };
+
+ private:
+  Dtype dtype_;
+};
+
+class AsStrided : public UnaryPrimitive {
+ public:
+  explicit AsStrided(Stream stream, Shape shape, Strides strides, size_t offset)
+      : UnaryPrimitive(stream),
+        shape_(std::move(shape)),
+        strides_(std::move(strides)),
+        offset_(offset) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_GRADS()
+  DEFINE_NAME(AsStrided)
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return std::make_tuple(shape_, strides_, offset_);
+  }
+
+ private:
+  Shape shape_;
+  Strides strides_;
+  size_t offset_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class BitwiseBinary : public UnaryPrimitive {
+ public:
+  enum Op { And, Or, Xor, LeftShift, RightShift };
+
+  explicit BitwiseBinary(Stream stream, Op op)
+      : UnaryPrimitive(stream), op_(op) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+
+  const char* name() const override {
+    switch (op_) {
+      case BitwiseBinary::And:
+        return "BitwiseAnd";
+      case BitwiseBinary::Or:
+        return "BitwiseOr";
+      case BitwiseBinary::Xor:
+        return "BitwiseXor";
+      case BitwiseBinary::LeftShift:
+        return "LeftShift";
+      case BitwiseBinary::RightShift:
+        return "RightShift";
+    }
+    return "<unknwon BitwiseBinary>";
+  }
+
+  bool is_equivalent(const Primitive& other) const override;
+  DEFINE_INPUT_OUTPUT_SHAPE()
+  auto state() const {
+    return op_;
+  }
+
+ private:
+  Op op_;
+};
+
+class BitwiseInvert : public UnaryPrimitive {
+ public:
+  explicit BitwiseInvert(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_NAME(BitwiseInvert)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class BlockMaskedMM : public UnaryPrimitive {
+ public:
+  explicit BlockMaskedMM(Stream stream, int block_size)
+      : UnaryPrimitive(stream), block_size_(block_size) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const std::vector<array>& cotangents,
+      const std::vector<int>& argnums,
+      const std::vector<array>& outputs) override;
+
+  DEFINE_NAME(BlockMaskedMM)
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return block_size_;
+  }
+
+ private:
+  int block_size_;
+};
+
+class GatherMM : public UnaryPrimitive {
+ public:
+  explicit GatherMM(
+      Stream stream,
+      bool left_sorted = false,
+      bool right_sorted = false)
+      : UnaryPrimitive(stream),
+        left_sorted_(left_sorted),
+        right_sorted_(right_sorted) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const std::vector<array>& cotangents,
+      const std::vector<int>& argnums,
+      const std::vector<array>& outputs) override;
+
+  DEFINE_NAME(GatherMM)
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return std::make_pair(left_sorted_, right_sorted_);
+  }
+
+ private:
+  bool left_sorted_;
+  bool right_sorted_;
+};
+
+class SegmentedMM : public UnaryPrimitive {
+ public:
+  explicit SegmentedMM(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_NAME(SegmentedMM)
+};
+
+class BroadcastAxes : public UnaryPrimitive {
+ public:
+  explicit BroadcastAxes(Stream stream, std::vector<int> ignore_axes = {})
+      : UnaryPrimitive(stream), ignore_axes_(std::move(ignore_axes)) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(BroadcastAxes)
+  bool is_equivalent(const Primitive& other) const override;
+  static Shape output_shape(
+      const std::vector<array>& inputs,
+      const std::vector<int>& ignore_axes);
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  auto state() const {
+    return ignore_axes_;
+  }
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+  std::vector<int> ignore_axes_;
+};
+
+class Broadcast : public UnaryPrimitive {
+ public:
+  explicit Broadcast(Stream stream, const Shape& shape)
+      : UnaryPrimitive(stream), shape_(shape) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Broadcast)
+  static Shape output_shape(const std::vector<array>& inputs);
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  bool is_equivalent(const Primitive& other) const override;
+  Shape state() const {
+    return shape_;
+  };
+
+ private:
+  Shape shape_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Ceil : public UnaryPrimitive {
+ public:
+  explicit Ceil(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Ceil)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Compiled : public Primitive {
+ public:
+  /*
+   * The inputs, outputs and tape are either tracers or constants.
+   * - The tape should not contain the inputs, but it should contain the
+   *   outputs.
+   * - The tape should also have only one array per primitive for multi-output
+   *   primitives.
+   * - The constant_ids contains ids of arrays in the input list that are safe
+   *   to treat as scalar constants.
+   */
+  explicit Compiled(
+      Stream stream,
+      std::vector<array> inputs,
+      std::vector<array> outputs,
+      std::vector<array> tape,
+      std::unordered_set<uintptr_t> constant_ids);
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  const char* name() const override;
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  bool is_equivalent(const Primitive& other) const override;
+
+  std::string lib_name() const {
+    return kernel_lib_;
+  }
+
+ private:
+  const std::vector<array> inputs_;
+  const std::vector<array> outputs_;
+  const std::vector<array> tape_;
+  const std::unordered_set<uintptr_t> constant_ids_;
+  const std::function<bool(size_t)> is_constant_;
+
+  mutable std::string name_;
+  std::string kernel_lib_;
+};
+
+class Concatenate : public UnaryPrimitive {
+ public:
+  explicit Concatenate(Stream stream, int axis)
+      : UnaryPrimitive(stream), axis_(axis) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Concatenate)
+  bool is_equivalent(const Primitive& other) const override;
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  auto state() const {
+    return axis_;
+  }
+
+ private:
+  int axis_;
+};
+
+class Conjugate : public UnaryPrimitive {
+ public:
+  explicit Conjugate(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_NAME(Conjugate)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Contiguous : public UnaryPrimitive {
+ public:
+  explicit Contiguous(Stream stream, bool allow_col_major)
+      : UnaryPrimitive(stream), allow_col_major_(allow_col_major) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Contiguous)
+  DEFINE_INPUT_OUTPUT_SHAPE()
+
+  bool is_equivalent(const Primitive& other) const override;
+
+ private:
+  bool allow_col_major_;
+};
+
+class Convolution : public UnaryPrimitive {
+ public:
+  explicit Convolution(
+      Stream stream,
+      const std::vector<int>& kernel_strides,
+      const std::vector<int>& padding_lo,
+      const std::vector<int>& padding_hi,
+      const std::vector<int>& kernel_dilation,
+      const std::vector<int>& input_dilation,
+      const int groups = 1,
+      const bool flip = false)
+      : UnaryPrimitive(stream),
+        padding_lo_(padding_lo),
+        padding_hi_(padding_hi),
+        kernel_strides_(kernel_strides),
+        kernel_dilation_(kernel_dilation),
+        input_dilation_(input_dilation),
+        groups_(groups),
+        flip_(flip) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const std::vector<array>& cotangents,
+      const std::vector<int>& argnums,
+      const std::vector<array>& outputs) override;
+
+  DEFINE_VMAP()
+  DEFINE_NAME(Convolution)
+  bool is_equivalent(const Primitive& other) const override;
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  auto state() const {
+    return std::make_tuple(
+        kernel_strides_,
+        padding_lo_,
+        padding_hi_,
+        kernel_dilation_,
+        input_dilation_,
+        groups_,
+        flip_);
+  }
+
+  static Shape conv_out_shape(
+      const Shape& in_shape,
+      const Shape& wt_shape,
+      const std::vector<int>& strides,
+      const std::vector<int>& pads_lo,
+      const std::vector<int>& pads_hi,
+      const std::vector<int>& kernel_dilation,
+      const std::vector<int>& input_dilation);
+
+ private:
+  std::vector<int> padding_lo_;
+  std::vector<int> padding_hi_;
+  std::vector<int> kernel_strides_;
+  std::vector<int> kernel_dilation_;
+  std::vector<int> input_dilation_;
+  int groups_;
+  bool flip_;
+};
+
+class Copy : public UnaryPrimitive {
+ public:
+  explicit Copy(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Copy)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Cos : public UnaryPrimitive {
+ public:
+  explicit Cos(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Cos)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Cosh : public UnaryPrimitive {
+ public:
+  explicit Cosh(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Cosh)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class CustomTransforms : public Primitive {
+ public:
+  explicit CustomTransforms(
+      Stream stream,
+      int num_outputs,
+      std::function<std::vector<array>(
+          const std::vector<array>&,
+          const std::vector<array>&,
+          const std::vector<array>&)> vjp,
+      std::function<std::vector<array>(
+          const std::vector<array>&,
+          const std::vector<array>&,
+          const std::vector<int>&)> jvp,
+      std::function<std::pair<std::vector<array>, std::vector<int>>(
+          const std::vector<array>&,
+          const std::vector<int>&)> vmap)
+      : Primitive(stream),
+        num_outputs_(num_outputs),
+        vjp_fun_(std::move(vjp)),
+        jvp_fun_(std::move(jvp)),
+        vmap_fun_(std::move(vmap)) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_GRADS();
+  DEFINE_VMAP();
+  DEFINE_NAME(CustomTransforms);
+
+ private:
+  void eval(const std::vector<array>& inputs, std::vector<array>& outputs);
+
+  int num_outputs_;
+
+  std::function<std::vector<array>(
+      const std::vector<array>&,
+      const std::vector<array>&,
+      const std::vector<array>&)>
+      vjp_fun_;
+  std::function<std::vector<array>(
+      const std::vector<array>&,
+      const std::vector<array>&,
+      const std::vector<int>&)>
+      jvp_fun_;
+  std::function<std::pair<std::vector<array>, std::vector<int>>(
+      const std::vector<array>&,
+      const std::vector<int>&)>
+      vmap_fun_;
+};
+
+class Depends : public Primitive {
+ public:
+  explicit Depends(Stream stream) : Primitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const std::vector<array>& cotan,
+      const std::vector<int>& argnums,
+      const std::vector<array>& outputs) override;
+
+  DEFINE_NAME(Depends);
+
+ private:
+  void eval(const std::vector<array>& inputs, std::vector<array>& outputs);
+};
+
+class Divide : public UnaryPrimitive {
+ public:
+  explicit Divide(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Divide)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class DivMod : public Primitive {
+ public:
+  explicit DivMod(Stream stream) : Primitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(DivMod)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override {
+    return std::vector{inputs[0].shape(), inputs[0].shape()};
+  }
+};
+
+class Select : public UnaryPrimitive {
+ public:
+  explicit Select(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Select)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Remainder : public UnaryPrimitive {
+ public:
+  explicit Remainder(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Remainder)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Equal : public UnaryPrimitive {
+ public:
+  explicit Equal(Stream stream, bool equal_nan = false)
+      : UnaryPrimitive(stream), equal_nan_(equal_nan) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+
+  const char* name() const override {
+    if (equal_nan_) {
+      return "NaNEqual";
+    } else {
+      return "Equal";
+    }
+  }
+  auto state() const {
+    return equal_nan_;
+  };
+
+ private:
+  bool equal_nan_;
+};
+
+class Erf : public UnaryPrimitive {
+ public:
+  explicit Erf(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Erf)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class ErfInv : public UnaryPrimitive {
+ public:
+  explicit ErfInv(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(ErfInv)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Exp : public UnaryPrimitive {
+ public:
+  explicit Exp(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Exp)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Expm1 : public UnaryPrimitive {
+ public:
+  explicit Expm1(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Expm1)
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class ExpandDims : public UnaryPrimitive {
+ public:
+  explicit ExpandDims(Stream stream, std::vector<int> axes)
+      : UnaryPrimitive(stream), axes_(std::move(axes)) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(ExpandDims)
+
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  bool is_equivalent(const Primitive& other) const override;
+
+  static Shape output_shape(const array& input, const std::vector<int>& axes);
+  auto state() const {
+    return axes_;
+  }
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+  std::vector<int> axes_;
+};
+
+class FFT : public UnaryPrimitive {
+ public:
+  explicit FFT(
+      Stream stream,
+      const std::vector<size_t>& axes,
+      bool inverse,
+      bool real)
+      : UnaryPrimitive(stream), axes_(axes), inverse_(inverse), real_(real) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(FFT)
+
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return std::make_tuple(axes_, inverse_, real_);
+  }
+
+ private:
+  std::vector<size_t> axes_;
+  bool inverse_;
+  bool real_;
+};
+
+class Flatten : public UnaryPrimitive {
+ public:
+  explicit Flatten(Stream stream, int start_axis, int end_axis)
+      : UnaryPrimitive(stream), start_axis_(start_axis), end_axis_(end_axis) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Flatten)
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  bool is_equivalent(const Primitive& other) const override;
+
+  static Shape output_shape(const array& input, int start_axis, int end_axis);
+  auto state() const {
+    return std::make_pair(start_axis_, end_axis_);
+  }
+
+ private:
+  int start_axis_;
+  int end_axis_;
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Floor : public UnaryPrimitive {
+ public:
+  explicit Floor(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Floor)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Full : public UnaryPrimitive {
+ public:
+  explicit Full(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Full)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+};
+
+class Gather : public UnaryPrimitive {
+ public:
+  explicit Gather(Stream stream, std::vector<int> axes, Shape slice_sizes)
+      : UnaryPrimitive(stream),
+        axes_(std::move(axes)),
+        slice_sizes_(std::move(slice_sizes)) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Gather)
+  bool is_equivalent(const Primitive& other) const override;
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  std::pair<std::vector<int>, Shape> state() const {
+    return {axes_, slice_sizes_};
+  }
+
+ private:
+  std::vector<int> axes_;
+  Shape slice_sizes_;
+};
+
+class GatherAxis : public UnaryPrimitive {
+ public:
+  explicit GatherAxis(Stream stream, int axis)
+      : UnaryPrimitive(stream), axis_(axis) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(GatherAxis)
+  bool is_equivalent(const Primitive& other) const override;
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  auto state() const {
+    return axis_;
+  }
+
+ private:
+  int axis_;
+};
+
+class Greater : public UnaryPrimitive {
+ public:
+  explicit Greater(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Greater)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class GreaterEqual : public UnaryPrimitive {
+ public:
+  explicit GreaterEqual(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(GreaterEqual)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Hadamard : public UnaryPrimitive {
+ public:
+  explicit Hadamard(Stream stream, float scale)
+      : UnaryPrimitive(stream), scale_(scale) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Hadamard)
+  DEFINE_INPUT_OUTPUT_SHAPE()
+
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return scale_;
+  }
+
+ private:
+  float scale_;
+};
+
+class Imag : public UnaryPrimitive {
+ public:
+  explicit Imag(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Imag)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Less : public UnaryPrimitive {
+ public:
+  explicit Less(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Less)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class LessEqual : public UnaryPrimitive {
+ public:
+  explicit LessEqual(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(LessEqual)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Load : public UnaryPrimitive {
+ public:
+  explicit Load(
+      Stream stream,
+      std::shared_ptr<io::Reader> reader,
+      size_t offset,
+      bool swap_endianness = false)
+      : UnaryPrimitive(stream),
+        reader_(std::move(reader)),
+        offset_(offset),
+        swap_endianness_(swap_endianness) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_NAME(Load)
+
+ private:
+  std::shared_ptr<io::Reader> reader_;
+  size_t offset_;
+  bool swap_endianness_;
+};
+
+class Log : public UnaryPrimitive {
+ public:
+  enum Base { two, ten, e };
+
+  explicit Log(Stream stream, Base base)
+      : UnaryPrimitive(stream), base_(base) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+
+  Base state() const {
+    return base_;
+  };
+
+  const char* name() const override {
+    switch (base_) {
+      case e:
+        return "Log";
+      case two:
+        return "Log2";
+      case ten:
+        return "Log10";
+    }
+    return "<unknwon Log>";
+  }
+
+ private:
+  Base base_;
+};
+
+class Log1p : public UnaryPrimitive {
+ public:
+  explicit Log1p(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Log1p)
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class LogicalNot : public UnaryPrimitive {
+ public:
+  explicit LogicalNot(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(LogicalNot)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class LogicalAnd : public UnaryPrimitive {
+ public:
+  explicit LogicalAnd(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(LogicalAnd)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class LogicalOr : public UnaryPrimitive {
+ public:
+  explicit LogicalOr(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(LogicalOr)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class LogAddExp : public UnaryPrimitive {
+ public:
+  explicit LogAddExp(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(LogAddExp)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class LogSumExp : public UnaryPrimitive {
+ public:
+  explicit LogSumExp(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(LogSumExp)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+};
+
+class Matmul : public UnaryPrimitive {
+ public:
+  explicit Matmul(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_GRADS()
+  DEFINE_VMAP()
+  DEFINE_NAME(Matmul)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+};
+
+class Maximum : public UnaryPrimitive {
+ public:
+  explicit Maximum(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Maximum)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Minimum : public UnaryPrimitive {
+ public:
+  explicit Minimum(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Minimum)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Multiply : public UnaryPrimitive {
+ public:
+  explicit Multiply(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Multiply)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Negative : public UnaryPrimitive {
+ public:
+  explicit Negative(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Negative)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class NotEqual : public UnaryPrimitive {
+ public:
+  explicit NotEqual(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(NotEqual)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class NumberOfElements : public UnaryPrimitive {
+ public:
+  explicit NumberOfElements(
+      Stream stream,
+      std::vector<int> axes,
+      bool inverted,
+      Dtype dtype)
+      : UnaryPrimitive(stream),
+        axes_(std::move(axes)),
+        inverted_(inverted),
+        dtype_(dtype) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_NAME(NumberOfElements)
+  bool is_equivalent(const Primitive& other) const override;
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override {
+    return {{}};
+  }
+  std::tuple<std::vector<int>, bool, Dtype> state() const {
+    return {axes_, inverted_, dtype_};
+  }
+
+ private:
+  std::vector<int> axes_;
+  bool inverted_;
+  Dtype dtype_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Pad : public UnaryPrimitive {
+ public:
+  explicit Pad(
+      Stream stream,
+      const std::vector<int>& axes,
+      const Shape& low_pad_size,
+      const Shape& high_pad_size)
+      : UnaryPrimitive(stream),
+        axes_(axes),
+        low_pad_size_(low_pad_size),
+        high_pad_size_(high_pad_size) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Pad)
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return std::make_tuple(axes_, low_pad_size_, high_pad_size_);
+  }
+
+ private:
+  std::vector<int> axes_;
+  Shape low_pad_size_;
+  Shape high_pad_size_;
+};
+
+class Partition : public UnaryPrimitive {
+ public:
+  explicit Partition(Stream stream, int kth, int axis)
+      : UnaryPrimitive(stream), kth_(kth), axis_(axis) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Partition)
+  DEFINE_INPUT_OUTPUT_SHAPE()
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return std::make_pair(kth_, axis_);
+  };
+
+ private:
+  int kth_;
+  int axis_;
+};
+
+class Power : public UnaryPrimitive {
+ public:
+  explicit Power(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Power)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class QuantizedMatmul : public UnaryPrimitive {
+ public:
+  explicit QuantizedMatmul(
+      Stream stream,
+      int group_size,
+      int bits,
+      QuantizationMode mode,
+      bool transpose)
+      : UnaryPrimitive(stream),
+        group_size_(group_size),
+        bits_(bits),
+        mode_(mode),
+        transpose_(transpose) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(QuantizedMatmul)
+  bool is_equivalent(const Primitive& other) const override;
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  auto state() const {
+    return std::make_tuple(group_size_, bits_, mode_, transpose_);
+  }
+
+ private:
+  int group_size_;
+  int bits_;
+  QuantizationMode mode_;
+  bool transpose_;
+};
+
+class GatherQMM : public UnaryPrimitive {
+ public:
+  explicit GatherQMM(
+      Stream stream,
+      int group_size,
+      int bits,
+      QuantizationMode mode,
+      bool transpose,
+      bool left_sorted = false,
+      bool right_sorted = false)
+      : UnaryPrimitive(stream),
+        group_size_(group_size),
+        bits_(bits),
+        mode_(mode),
+        transpose_(transpose),
+        left_sorted_(left_sorted),
+        right_sorted_(right_sorted) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(GatherQMM)
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return std::make_tuple(
+        group_size_, bits_, mode_, transpose_, left_sorted_, right_sorted_);
+  }
+
+ private:
+  int group_size_;
+  int bits_;
+  QuantizationMode mode_;
+  bool transpose_;
+  bool left_sorted_;
+  bool right_sorted_;
+};
+
+class RandomBits : public UnaryPrimitive {
+ public:
+  explicit RandomBits(Stream stream, const Shape& shape, int width)
+      : UnaryPrimitive(stream), shape_(shape), width_(width) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_NAME(RandomBits)
+  bool is_equivalent(const Primitive& other) const override;
+  std::pair<Shape, int> state() const {
+    return {shape_, width_};
+  };
+
+ private:
+  Shape shape_;
+  int width_;
+};
+
+class Real : public UnaryPrimitive {
+ public:
+  explicit Real(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Real)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Reshape : public UnaryPrimitive {
+ public:
+  explicit Reshape(Stream stream, const Shape& shape)
+      : UnaryPrimitive(stream), shape_(shape) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Reshape)
+  bool is_equivalent(const Primitive& other) const override;
+  Shape state() const {
+    return shape_;
+  };
+  static Shape output_shape(const array& input, Shape shape);
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+
+ private:
+  Shape shape_;
+};
+
+class Reduce : public UnaryPrimitive {
+ public:
+  enum ReduceType { And, Or, Sum, Prod, Min, Max };
+
+  explicit Reduce(
+      Stream stream,
+      ReduceType reduce_type,
+      const std::vector<int>& axes)
+      : UnaryPrimitive(stream), reduce_type_(reduce_type), axes_(axes) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+
+  std::vector<array> vjp(
+      const std::vector<array>& primals,
+      const std::vector<array>& cotangents,
+      const std::vector<int>& argnums,
+      const std::vector<array>& outputs) override;
+
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+
+  const char* name() const override {
+    switch (reduce_type_) {
+      case And:
+        return "And";
+      case Or:
+        return "Or";
+      case Sum:
+        return "Sum";
+      case Prod:
+        return "Prod";
+      case Min:
+        return "Min";
+      case Max:
+        return "Max";
+    }
+    return "<unknwon Reduce>";
+  }
+
+  bool is_equivalent(const Primitive& other) const override;
+  std::pair<ReduceType, std::vector<int>> state() const {
+    return {reduce_type_, axes_};
+  };
+
+ private:
+  ReduceType reduce_type_;
+  std::vector<int> axes_;
+};
+
+class Round : public UnaryPrimitive {
+ public:
+  explicit Round(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Round)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Scan : public UnaryPrimitive {
+ public:
+  enum ReduceType { Max, Min, Sum, Prod, LogAddExp };
+
+  explicit Scan(
+      Stream stream,
+      ReduceType reduce_type,
+      int axis,
+      bool reverse,
+      bool inclusive)
+      : UnaryPrimitive(stream),
+        reduce_type_(reduce_type),
+        axis_(axis),
+        reverse_(reverse),
+        inclusive_(inclusive) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS();
+
+  const char* name() const override {
+    switch (reduce_type_) {
+      case Sum:
+        return "CumSum";
+      case Prod:
+        return "CumProd";
+      case Min:
+        return "CumMin";
+      case Max:
+        return "CumMax";
+      case LogAddExp:
+        return "CumLogAddExp";
+    }
+    return "<unknwon Scan>";
+  }
+
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return std::make_tuple(reduce_type_, axis_, reverse_, inclusive_);
+  }
+
+ private:
+  ReduceType reduce_type_;
+  int axis_;
+  bool reverse_;
+  bool inclusive_;
+};
+
+class Scatter : public UnaryPrimitive {
+ public:
+  enum ReduceType { Max, Min, Sum, Prod, None };
+
+  explicit Scatter(
+      Stream stream,
+      ReduceType reduce_type,
+      const std::vector<int>& axes)
+      : UnaryPrimitive(stream), reduce_type_(reduce_type), axes_(axes) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP();
+  DEFINE_GRADS();
+
+  const char* name() const override {
+    switch (reduce_type_) {
+      case Sum:
+        return "ScatterSum";
+      case Prod:
+        return "ScatterProd";
+      case Min:
+        return "ScatterMin";
+      case Max:
+        return "ScatterMax";
+      case None:
+        return "Scatter";
+    }
+    return "<unknwon Scatter>";
+  }
+
+  bool is_equivalent(const Primitive& other) const override;
+  std::pair<ReduceType, std::vector<int>> state() const {
+    return {reduce_type_, axes_};
+  };
+
+ private:
+  ReduceType reduce_type_;
+  std::vector<int> axes_;
+};
+
+class ScatterAxis : public UnaryPrimitive {
+ public:
+  enum ReduceType { Sum, None };
+
+  explicit ScatterAxis(Stream stream, ReduceType reduce_type, int axis)
+      : UnaryPrimitive(stream), reduce_type_(reduce_type), axis_(axis) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+
+  const char* name() const override {
+    switch (reduce_type_) {
+      case Sum:
+        return "ScatterAxisSum";
+      case None:
+        return "ScatterAxis";
+    }
+    return "<unknwon ScatterAxis>";
+  }
+
+  bool is_equivalent(const Primitive& other) const override;
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  std::pair<ReduceType, int> state() const {
+    return {reduce_type_, axis_};
+  }
+
+ private:
+  ReduceType reduce_type_;
+  int axis_;
+};
+
+class Sigmoid : public UnaryPrimitive {
+ public:
+  explicit Sigmoid(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Sigmoid)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Sign : public UnaryPrimitive {
+ public:
+  explicit Sign(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Sign)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Sin : public UnaryPrimitive {
+ public:
+  explicit Sin(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Sin)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Sinh : public UnaryPrimitive {
+ public:
+  explicit Sinh(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Sinh)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Slice : public UnaryPrimitive {
+ public:
+  explicit Slice(
+      Stream stream,
+      const Shape& start_indices,
+      const Shape& end_indices,
+      const Shape& strides)
+      : UnaryPrimitive(stream),
+        start_indices_(start_indices),
+        end_indices_(end_indices),
+        strides_(strides) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Slice)
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return std::make_tuple(start_indices_, end_indices_, strides_);
+  }
+
+ private:
+  Shape start_indices_;
+  Shape end_indices_;
+  Shape strides_;
+};
+
+class SliceUpdate : public UnaryPrimitive {
+ public:
+  explicit SliceUpdate(
+      Stream stream,
+      const Shape& start_indices,
+      const Shape& end_indices,
+      const Shape& strides)
+      : UnaryPrimitive(stream),
+        start_indices_(start_indices),
+        end_indices_(end_indices),
+        strides_(strides) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(SliceUpdate)
+  bool is_equivalent(const Primitive& other) const override;
+  DEFINE_INPUT_OUTPUT_SHAPE()
+  auto state() const {
+    return std::make_tuple(start_indices_, end_indices_, strides_);
+  }
+
+ private:
+  Shape start_indices_;
+  Shape end_indices_;
+  Shape strides_;
+};
+
+class DynamicSlice : public UnaryPrimitive {
+ public:
+  explicit DynamicSlice(Stream stream, std::vector<int> axes, Shape slice_size)
+      : UnaryPrimitive(stream),
+        axes_(std::move(axes)),
+        slice_size_(std::move(slice_size)) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(DynamicSlice)
+  bool is_equivalent(const Primitive& other) const override;
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  auto state() const {
+    return std::make_pair(axes_, slice_size_);
+  }
+
+ private:
+  std::vector<int> axes_;
+  Shape slice_size_;
+};
+
+class DynamicSliceUpdate : public UnaryPrimitive {
+ public:
+  explicit DynamicSliceUpdate(Stream stream, std::vector<int> axes)
+      : UnaryPrimitive(stream), axes_(std::move(axes)) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(DynamicSliceUpdate)
+  bool is_equivalent(const Primitive& other) const override;
+  DEFINE_INPUT_OUTPUT_SHAPE()
+  auto state() const {
+    return axes_;
+  }
+
+ private:
+  std::vector<int> axes_;
+};
+
+class Softmax : public UnaryPrimitive {
+ public:
+  explicit Softmax(Stream stream, bool precise)
+      : UnaryPrimitive(stream), precise_(precise) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Softmax)
+  DEFINE_INPUT_OUTPUT_SHAPE()
+
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return precise_;
+  };
+
+ private:
+  bool precise_;
+};
+
+class Sort : public UnaryPrimitive {
+ public:
+  explicit Sort(Stream stream, int axis)
+      : UnaryPrimitive(stream), axis_(axis) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Sort)
+  DEFINE_INPUT_OUTPUT_SHAPE()
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return axis_;
+  }
+
+ private:
+  int axis_;
+};
+
+class Split : public Primitive {
+ public:
+  explicit Split(Stream stream, const Shape& indices, int axis)
+      : Primitive(stream), indices_(indices), axis_(axis) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Split)
+  bool is_equivalent(const Primitive& other) const override;
+  std::pair<Shape, int> state() const {
+    return {indices_, axis_};
+  };
+
+ private:
+  void eval(const std::vector<array>& inputs, std::vector<array>& outputs);
+
+  Shape indices_;
+  int axis_;
+};
+
+class Square : public UnaryPrimitive {
+ public:
+  explicit Square(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Square)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Sqrt : public UnaryPrimitive {
+ public:
+  explicit Sqrt(Stream stream, bool recip = false)
+      : UnaryPrimitive(stream), recip_(recip) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return recip_;
+  }
+
+  const char* name() const override {
+    if (recip_) {
+      return "Rsqrt";
+    } else {
+      return "Sqrt";
+    }
+  }
+
+ private:
+  bool recip_;
+};
+
+class StopGradient : public UnaryPrimitive {
+ public:
+  explicit StopGradient(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_NAME(StopGradient)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class Subtract : public UnaryPrimitive {
+ public:
+  explicit Subtract(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Subtract)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Squeeze : public UnaryPrimitive {
+ public:
+  explicit Squeeze(Stream stream, std::vector<int> axes)
+      : UnaryPrimitive(stream), axes_(std::move(axes)) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Squeeze)
+
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  bool is_equivalent(const Primitive& other) const override;
+
+  static Shape output_shape(const array& input, const std::vector<int>& axes);
+  auto state() const {
+    return axes_;
+  };
+
+ private:
+  void eval(const std::vector<array>& inputs, array& out);
+  std::vector<int> axes_;
+};
+
+class Tan : public UnaryPrimitive {
+ public:
+  explicit Tan(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Tan)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Tanh : public UnaryPrimitive {
+ public:
+  explicit Tanh(Stream stream) : UnaryPrimitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Tanh)
+  DEFINE_DEFAULT_IS_EQUIVALENT()
+  DEFINE_INPUT_OUTPUT_SHAPE()
+};
+
+class Unflatten : public UnaryPrimitive {
+ public:
+  explicit Unflatten(Stream stream, int axis, Shape shape)
+      : UnaryPrimitive(stream), axis_(axis), shape_(std::move(shape)) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Unflatten)
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  bool is_equivalent(const Primitive& other) const override;
+
+  static Shape output_shape(const array& input, int axis, const Shape& shape);
+  auto state() const {
+    return std::make_pair(axis_, shape_);
+  }
+
+ private:
+  int axis_;
+  Shape shape_;
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+class View : public UnaryPrimitive {
+ public:
+  explicit View(Stream stream, Dtype dtype)
+      : UnaryPrimitive(stream), dtype_(dtype) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  const char* name() const override;
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return dtype_;
+  }
+
+ private:
+  Dtype dtype_;
+  mutable std::string name_;
+};
+
+class Transpose : public UnaryPrimitive {
+ public:
+  explicit Transpose(Stream stream, const std::vector<int>& axes)
+      : UnaryPrimitive(stream), axes_(axes) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+
+  DEFINE_VMAP()
+  DEFINE_GRADS()
+  DEFINE_NAME(Transpose)
+  bool is_equivalent(const Primitive& other) const override;
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+  std::vector<int> state() const {
+    return axes_;
+  };
+
+ private:
+  std::vector<int> axes_;
+
+  void eval(const std::vector<array>& inputs, array& out);
+};
+
+/* QR Factorization primitive. */
+class QRF : public Primitive {
+ public:
+  explicit QRF(Stream stream) : Primitive(stream) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_NAME(QRF)
+};
+
+/* SVD primitive. */
+class SVD : public Primitive {
+ public:
+  explicit SVD(Stream stream, bool compute_uv)
+      : Primitive(stream), compute_uv_(compute_uv) {}
+
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_VMAP()
+  DEFINE_NAME(SVD)
+  auto state() const {
+    return compute_uv_;
+  }
+
+ private:
+  bool compute_uv_;
+};
+
+/* Matrix inversion primitive. */
+class Inverse : public UnaryPrimitive {
+ public:
+  explicit Inverse(Stream stream, bool tri, bool upper)
+      : UnaryPrimitive(stream), tri_(tri), upper_(upper) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& output) override;
+  void eval_gpu(const std::vector<array>& inputs, array& output) override;
+
+  DEFINE_VMAP()
+  DEFINE_NAME(Inverse)
+  auto state() const {
+    return std::make_pair(tri_, upper_);
+  }
+
+ private:
+  bool tri_;
+  bool upper_;
+};
+
+class Cholesky : public UnaryPrimitive {
+ public:
+  explicit Cholesky(Stream stream, bool upper)
+      : UnaryPrimitive(stream), upper_(upper) {}
+
+  void eval_cpu(const std::vector<array>& inputs, array& out) override;
+  void eval_gpu(const std::vector<array>& inputs, array& out) override;
+  auto state() const {
+    return upper_;
+  }
+
+  DEFINE_VMAP()
+  DEFINE_NAME(Cholesky)
+
+ private:
+  bool upper_;
+};
+
+class Eig : public Primitive {
+ public:
+  explicit Eig(Stream stream, bool compute_eigenvectors)
+      : Primitive(stream), compute_eigenvectors_(compute_eigenvectors) {}
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_VMAP()
+  DEFINE_NAME(Eig)
+
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return compute_eigenvectors_;
+  }
+
+ private:
+  bool compute_eigenvectors_;
+};
+
+class Eigh : public Primitive {
+ public:
+  explicit Eigh(Stream stream, std::string uplo, bool compute_eigenvectors)
+      : Primitive(stream),
+        uplo_(std::move(uplo)),
+        compute_eigenvectors_(compute_eigenvectors) {}
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_VMAP()
+  DEFINE_NAME(Eigh)
+
+  std::vector<Shape> output_shapes(const std::vector<array>& inputs) override;
+
+  bool is_equivalent(const Primitive& other) const override;
+  auto state() const {
+    return std::make_pair(uplo_, compute_eigenvectors_);
+  }
+
+ private:
+  std::string uplo_;
+  bool compute_eigenvectors_;
+};
+
+/* LU Factorization primitive. */
+class LUF : public Primitive {
+ public:
+  explicit LUF(Stream stream) : Primitive(stream) {}
+  void eval_cpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+  void eval_gpu(const std::vector<array>& inputs, std::vector<array>& outputs)
+      override;
+
+  DEFINE_NAME(LUF)
+};
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/random.cpp b/ml-stable-diffusion/mlx/mlx/random.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..def3169cb58f09a9f179710502b7d59648063fe6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/random.cpp
@@ -0,0 +1,492 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <cmath>
+#include <sstream>
+
+#include "mlx/linalg.h"
+#include "mlx/ops.h"
+#include "mlx/primitives.h"
+#include "mlx/random.h"
+#include "mlx/utils.h"
+
+namespace mlx::core::random {
+
+KeySequence::KeySequence(uint64_t seed) : key_(key(seed)) {}
+
+void KeySequence::seed(uint64_t seed) {
+  key_ = key((seed));
+}
+
+array KeySequence::next() {
+  auto out = split(key_);
+  key_ = out.first;
+  return out.second;
+}
+
+void seed(uint64_t seed) {
+  KeySequence::default_().seed(seed);
+}
+
+array key(uint64_t seed) {
+  uint32_t k1 = static_cast<uint32_t>(seed >> 32);
+  uint32_t k2 = static_cast<uint32_t>(seed);
+  return array({k1, k2});
+}
+
+array bits(
+    const Shape& shape,
+    int width /* 4 */,
+    const std::optional<array>& key_ /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  auto key = key_ ? *key_ : KeySequence::default_().next();
+  if (key.dtype() != uint32) {
+    std::ostringstream msg;
+    msg << "[bits] Expected key type uint32 but received " << key.dtype()
+        << ".";
+    throw std::invalid_argument(msg.str());
+  }
+  if (key.shape() != Shape{2}) {
+    std::ostringstream msg;
+    msg << "[bits] Expected key shape (2) but received " << key.shape() << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto get_dtype = [width]() {
+    switch (width) {
+      case 4:
+        return uint32;
+      case 2:
+        return uint16;
+      case 1:
+        return uint8;
+      default:
+        std::ostringstream msg;
+        msg << "[bits] Bit width must be in {1, 2, 4} but got " << width << ".";
+        throw std::invalid_argument(msg.str());
+    }
+  };
+  return array(
+      shape,
+      get_dtype(),
+      std::make_shared<RandomBits>(to_stream(s), shape, width),
+      {key});
+}
+
+std::pair<array, array> split(const array& key, StreamOrDevice s /* = {} */) {
+  auto stream = to_stream(s);
+  auto out = mlx::core::split(random::split(key, 2, stream), 2, stream);
+  return {reshape(out[0], {2}, stream), reshape(out[1], {2}, stream)};
+}
+
+array split(const array& key, int num, StreamOrDevice s /* = {} */) {
+  return bits({num, 2}, 4, key, s);
+}
+
+// Get the next representable value below 1.0 for half precision
+// floating point types (fp16, bf16)
+template <typename T>
+T below_one() {
+  T f = T(1.0);
+  uint16_t* m = (uint16_t*)&f;
+  *m -= 1;
+  return f;
+}
+
+array uniform(
+    const array& low,
+    const array& high,
+    const Shape& shape,
+    Dtype dtype /* = float32 */,
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  if (!issubdtype(dtype, floating)) {
+    throw std::invalid_argument(
+        "[uniform] Can only generate uniform numbers with real "
+        "floating point type.");
+  }
+
+  auto stream = to_stream(s);
+  auto lo = astype(low, dtype, stream);
+  auto hi = astype(high, dtype, stream);
+  auto range = subtract(hi, lo, stream);
+  auto out_shape = broadcast_shapes(shape, range.shape());
+  if (out_shape != shape) {
+    std::ostringstream msg;
+    msg << "[uniform] Cannot generate random values of shape " << shape
+        << " from broadcasted shape " << out_shape << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Get random values between [0, nextafter(1.0, 0.0)] since samples must
+  // be in [low, high)
+  auto get_upper = [&dtype]() {
+    switch (dtype) {
+      case float32:
+        return array(std::nextafter(1.0f, 0.0f), float32);
+      case float16:
+        return array(below_one<float16_t>(), float32);
+      case bfloat16:
+        return array(below_one<bfloat16_t>(), float32);
+      default:
+        throw std::runtime_error("[uniform] Unsupported type.");
+    }
+  };
+
+  auto upper = get_upper();
+  auto maxval = array(std::numeric_limits<uint32_t>::max(), float32);
+  auto out = bits(shape, size_of(float32), key, stream);
+  out = divide(out, maxval, stream);
+  out = astype(minimum(out, upper, stream), dtype, stream);
+  return add(multiply(range, out, stream), lo, stream);
+}
+
+array uniform(
+    const Shape& shape,
+    Dtype dtype,
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  return uniform(
+      array(0.0, dtype), array(1.0, dtype), shape, dtype, key, to_stream(s));
+}
+
+inline array complex_normal(
+    Shape shape,
+    const std::optional<array>& loc,
+    const std::optional<array>& scale,
+    const std::optional<array>& key,
+    StreamOrDevice s) {
+  auto stream = to_stream(s);
+  auto low = array(std::nextafter(-1.0f, 0.0f), float32);
+  auto high = array(1.0f, float32);
+  shape.push_back(2);
+  auto samples =
+      erfinv(uniform(low, high, shape, float32, key, stream), stream);
+  samples = squeeze(view(samples, complex64, stream), -1, stream);
+  if (scale.has_value()) {
+    samples = multiply(*scale, samples, stream);
+  }
+  if (loc.has_value()) {
+    samples = add(*loc, samples, stream);
+  }
+  return samples;
+}
+
+array normal(
+    const Shape& shape,
+    Dtype dtype,
+    const std::optional<array>& loc,
+    const std::optional<array>& scale,
+    const std::optional<array>& key,
+    StreamOrDevice s /* = {} */) {
+  if (dtype == complex64) {
+    return complex_normal(shape, loc, scale, key, s);
+  } else if (!issubdtype(dtype, floating)) {
+    throw std::invalid_argument(
+        "[normal] Can only generate uniform numbers with "
+        "floating point type.");
+  }
+
+  auto stream = to_stream(s);
+  auto low = array(std::nextafter(-1.0f, 0.0f), float32);
+  auto high = array(1.0f, float32);
+  auto samples = uniform(low, high, shape, float32, key, stream);
+  auto applied_scale = array(std::sqrt(2.0), dtype);
+  if (scale.has_value()) {
+    applied_scale =
+        multiply(applied_scale, astype(*scale, dtype, stream), stream);
+  }
+  samples = astype(erfinv(samples, stream), dtype, stream);
+  samples = multiply(applied_scale, samples, stream);
+  if (loc.has_value()) {
+    samples = add(astype(*loc, dtype, stream), samples, stream);
+  }
+  return samples;
+}
+
+array multivariate_normal(
+    const array& mean,
+    const array& cov,
+    const Shape& shape,
+    Dtype dtype,
+    const std::optional<array>& key /* = nullopt */,
+    StreamOrDevice s) {
+  auto stream = to_stream(s);
+
+  if (dtype != float32) {
+    throw std::invalid_argument("[multivariate_normal] dtype must be float32.");
+  }
+
+  if (mean.ndim() < 1) {
+    throw std::invalid_argument(
+        "[multivariate_normal] mean must have at least one dimension.");
+  }
+
+  if (cov.ndim() < 2) {
+    throw std::invalid_argument(
+        "[multivariate_normal] cov must have at least two dimensions.");
+  }
+
+  auto n = mean.shape(-1);
+
+  // Check shapes compatibility of mean and cov
+  if (cov.shape(-1) != cov.shape(-2)) {
+    throw std::invalid_argument(
+        "[multivariate_normal] last two dimensions of cov must be equal.");
+  }
+  if (n != cov.shape(-1)) {
+    throw std::invalid_argument(
+        "[multivariate_normal] mean and cov must have compatible shapes.");
+  }
+
+  // Compute output shape
+  auto truncated_mean_shape =
+      Shape(mean.shape().begin(), mean.shape().end() - 1);
+  auto truncated_cov_shape = Shape(cov.shape().begin(), cov.shape().end() - 2);
+  auto output_shape =
+      broadcast_shapes(truncated_cov_shape, truncated_mean_shape);
+  output_shape = broadcast_shapes(output_shape, shape);
+  output_shape.push_back(n);
+
+  // Compute the square-root of the covariance matrix, using the SVD
+  auto covariance = astype(cov, float32, stream);
+  auto SVD = linalg::svd(covariance, true, stream);
+  auto std = astype(
+      matmul(
+          multiply(
+              SVD[0], expand_dims(sqrt(SVD[1], stream), -2, stream), stream),
+          SVD[2],
+          stream),
+      dtype,
+      stream);
+
+  // Generate standard the samples
+  auto standard_normal = normal(output_shape, dtype, 0.0, 1.0, key, stream);
+  auto scaled_out = squeeze(
+      matmul(expand_dims(standard_normal, -2, stream), std, stream),
+      -2,
+      stream);
+  return add(mean, scaled_out, stream);
+}
+
+array randint(
+    const array& low,
+    const array& high,
+    const Shape& shape,
+    Dtype dtype /* = int32 */,
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  if (issubdtype(dtype, inexact)) {
+    throw std::invalid_argument(
+        "[randint] randint only accepts integer dtypes and bool.");
+  }
+  auto u = uniform(low, high, shape, float32, key, s);
+  return astype(maximum(u, low, s), dtype, s);
+}
+
+array bernoulli(
+    const array& p,
+    const Shape& shape,
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  if (!issubdtype(p.dtype(), floating)) {
+    throw std::invalid_argument(
+        "[bernoulli] bernoulli probability `p` must be a float type.");
+  }
+
+  // Place p on the scale [0, nexthigher(UINT32_MAX)] so that if p >= 1.0 we
+  // get all true and if p <= 0.0 we get all false
+  auto upper = array(
+      std::nextafter(
+          static_cast<float>(std::numeric_limits<uint32_t>::max()),
+          std::numeric_limits<float>::max()),
+      float32);
+  auto res = less(bits(shape, key, s), multiply(p, upper, s), s);
+  if (res.shape() != shape) {
+    throw std::invalid_argument(
+        "[bernoulli] shape of `p` is incompatible with argument `shape`.");
+  }
+  return res;
+}
+
+array bernoulli(
+    const array& p,
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  return bernoulli(p, p.shape(), key, s);
+}
+
+array bernoulli(
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  return bernoulli(array(0.5f), key, s);
+}
+
+array truncated_normal(
+    const array& lower,
+    const array& upper,
+    const Shape& shape,
+    Dtype dtype /* = float32 */,
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  // Same as
+  // https://jax.readthedocs.io/en/latest/_modules/jax/_src/random.html#truncated_normal
+
+  if (!issubdtype(dtype, floating)) {
+    throw std::invalid_argument(
+        "[trunc_normal] trunc_normal only accepts floating point dtypes.");
+  }
+
+  auto sqrt2 = array(std::sqrt(2.0), dtype);
+  auto lower_t = astype(lower, dtype, s);
+  auto upper_t = astype(upper, dtype, s);
+  auto a = erf(divide(lower_t, sqrt2, s), s);
+  auto b = erf(divide(upper_t, sqrt2, s), s);
+  auto u = uniform(a, b, shape, dtype, key, s);
+  auto out = multiply(sqrt2, erfinv(u, s), s);
+
+  // Clip in bounds
+  return maximum(minimum(upper_t, out, s), lower_t, s);
+}
+
+array truncated_normal(
+    const array& lower,
+    const array& upper,
+    Dtype dtype /* = float32 */,
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  auto shape = broadcast_shapes(lower.shape(), upper.shape());
+  return truncated_normal(lower, upper, shape, dtype, key, s);
+}
+
+array gumbel(
+    const Shape& shape,
+    Dtype dtype /* = float32 */,
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  // -log(-log(uniform(shape)))
+  return negative(
+      log(negative(log(uniform(shape, dtype, key, s), s), s), s), s);
+}
+
+int get_valid_axis(int axis, int ndim) {
+  int ax = axis < 0 ? axis + ndim : axis;
+  if (ax < 0 || ax >= ndim) {
+    std::ostringstream msg;
+    msg << "[categorical] Invalid axis " << axis << " for logits with " << ndim
+        << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  return ax;
+}
+
+array categorical_impl(
+    const array& logits,
+    int axis,
+    const Shape& shape,
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s) {
+  auto gumbel_shape = shape;
+  auto offset = axis + shape.size() - logits.ndim() + 1;
+  gumbel_shape.insert(gumbel_shape.begin() + offset, logits.shape(axis));
+  auto g = gumbel(gumbel_shape, float32, key, s);
+  return argmax(add(g, logits, s), offset, false, s);
+}
+
+array categorical(
+    const array& logits,
+    int axis,
+    const Shape& shape,
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  // Validate and normalize axis
+  axis = get_valid_axis(axis, logits.ndim());
+
+  // Check that shape broadcasts with reduce(logits, axis)
+  auto reduced_shape = logits.shape();
+  reduced_shape.erase(reduced_shape.begin() + axis);
+  if (broadcast_shapes(shape, reduced_shape) != shape) {
+    std::ostringstream msg;
+    msg << "[categorical] Requested shape " << shape
+        << " is not broadcast compatible with reduced logits shape"
+        << reduced_shape << ".";
+    throw std::invalid_argument(msg.str());
+  }
+
+  return categorical_impl(logits, axis, shape, key, s);
+}
+
+array categorical(
+    const array& logits_,
+    int axis,
+    int num_samples,
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  axis = get_valid_axis(axis, logits_.ndim());
+  auto logits = expand_dims(logits_, -1);
+  auto shape = logits.shape();
+  shape.erase(shape.begin() + axis);
+  shape.back() = num_samples;
+  return categorical_impl(logits, axis, shape, key, s);
+}
+
+array categorical(
+    const array& logits,
+    int axis /* = -1 */,
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  axis = get_valid_axis(axis, logits.ndim());
+  auto shape = logits.shape();
+  shape.erase(shape.begin() + axis);
+  return categorical_impl(logits, axis, shape, key, s);
+}
+
+array laplace(
+    const Shape& shape,
+    Dtype dtype,
+    const float loc /* = 0.0 */,
+    const float scale /* = 1.0 */,
+    const std::optional<array>& key /*= nullopt */,
+    StreamOrDevice s /* = {} */) {
+  if (!issubdtype(dtype, floating)) {
+    throw std::invalid_argument(
+        "[laplace] Can only generate uniform numbers with real"
+        "floating point type.");
+  }
+
+  auto stream = to_stream(s);
+  auto low = array(std::nextafter(-1.0f, 0.0f), float32);
+  auto high = array(1.0f, float32);
+  auto samples = uniform(low, high, shape, float32, key, stream);
+  // Use inverse CDF to generate Laplacian noise
+  samples = multiply(
+      sign(samples, stream),
+      log1p(
+          multiply(array(-1.0f, dtype), abs(samples, stream), stream), stream),
+      stream);
+  samples = astype(samples, dtype, stream);
+
+  if (scale != 1.0) {
+    samples = multiply(array(scale, dtype), samples, stream);
+  }
+  if (loc != 0.0) {
+    samples = add(array(loc, dtype), samples, stream);
+  }
+  return samples;
+}
+
+array permutation(
+    const array& x,
+    int axis /* = 0 */,
+    const std::optional<array>& key /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  return take(x, permutation(x.shape(axis), key, s), axis, s);
+}
+
+array permutation(
+    int x,
+    const std::optional<array>& key /* = std::nullopt */,
+    StreamOrDevice s /* = {} */) {
+  return argsort(bits({x}, key, s), s);
+}
+
+} // namespace mlx::core::random
diff --git a/ml-stable-diffusion/mlx/mlx/random.h b/ml-stable-diffusion/mlx/mlx/random.h
new file mode 100644
index 0000000000000000000000000000000000000000..0dfdab7a14d401ba972857b7f18f9e139f086bc1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/random.h
@@ -0,0 +1,282 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <chrono>
+#include <optional>
+
+#include "mlx/array.h"
+#include "mlx/stream.h"
+#include "mlx/utils.h"
+
+namespace mlx::core::random {
+
+class KeySequence {
+ public:
+  explicit KeySequence(uint64_t seed);
+
+  void seed(uint64_t seed);
+  array next();
+
+  // static default
+  static KeySequence& default_() {
+    static KeySequence ks(get_current_time_seed());
+    return ks;
+  }
+
+ private:
+  array key_;
+  static uint64_t get_current_time_seed() {
+    auto now = std::chrono::system_clock::now();
+    return std::chrono::duration_cast<std::chrono::milliseconds>(
+               now.time_since_epoch())
+        .count();
+  }
+};
+
+/** Get a PRNG key from a seed. */
+array key(uint64_t seed);
+
+/** Seed the default PRNG key. */
+void seed(uint64_t seed);
+
+/** Generate an array with type uint32 filled with random bits. */
+array bits(
+    const Shape& shape,
+    int width,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+inline array bits(
+    const Shape& shape,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return bits(shape, 4, key, s);
+}
+
+/** Split the rng key into a pair of keys. */
+std::pair<array, array> split(const array& key, StreamOrDevice s = {});
+
+/** Split the rng key into `num` keys. */
+array split(const array& key, int num, StreamOrDevice s = {});
+
+/** Generate uniform random numbers between low and high. */
+array uniform(
+    const array& low,
+    const array& high,
+    const Shape& shape,
+    Dtype dtype = float32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+template <typename T, typename U>
+array uniform(
+    T low,
+    U high,
+    const Shape& shape,
+    Dtype dtype = float32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return uniform(array(low), array(high), shape, dtype, key, to_stream(s));
+}
+
+/** Generate uniform random numbers between 0 and 1. */
+array uniform(
+    const Shape& shape,
+    Dtype dtype,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+inline array uniform(
+    const Shape& shape,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return uniform(shape, float32, key);
+}
+
+/** Generate samples from the standard normal distribution. */
+array normal(
+    const Shape& shape,
+    Dtype dtype,
+    const std::optional<array>& loc,
+    const std::optional<array>& scale,
+    const std::optional<array>& key,
+    StreamOrDevice s = {});
+inline array normal(
+    const Shape& shape,
+    Dtype dtype,
+    const float loc,
+    const float scale,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  auto loc_ = loc == 0 ? std::nullopt : std::make_optional(array(loc, dtype));
+  auto scale_ =
+      scale == 1 ? std::nullopt : std::make_optional(array(scale, dtype));
+  return normal(shape, dtype, loc_, scale_, key, s);
+}
+inline array normal(
+    const Shape& shape,
+    const float loc,
+    const float scale,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return normal(shape, float32, loc, scale, key, s);
+}
+inline array normal(
+    const Shape& shape,
+    const Dtype dtype,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return normal(shape, dtype, std::nullopt, std::nullopt, key, s);
+}
+inline array normal(
+    const Shape& shape,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return normal(shape, float32, std::nullopt, std::nullopt, key, s);
+}
+
+/** Generate samples from a multivariate normal distribution. **/
+array multivariate_normal(
+    const array& mean,
+    const array& cov,
+    const Shape& shape,
+    Dtype dtype,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+/** Generate integer samples uniformly at random */
+array randint(
+    const array& low,
+    const array& high,
+    const Shape& shape,
+    Dtype dtype = int32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+template <typename T, typename U>
+array randint(
+    T low,
+    U high,
+    const Shape& shape,
+    Dtype dtype = int32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return randint(array(low), array(high), shape, dtype, key, to_stream(s));
+}
+
+/** Generate binary variables with probability to be true equal to p */
+array bernoulli(
+    const array& p,
+    const Shape& shape,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+array bernoulli(
+    const array& p,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+template <typename T>
+array bernoulli(
+    T p,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return bernoulli(array(p), key, s);
+}
+
+template <typename T>
+array bernoulli(
+    T p,
+    const Shape& shape,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return bernoulli(array(p), shape, key, s);
+}
+
+array bernoulli(
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+array truncated_normal(
+    const array& lower,
+    const array& upper,
+    const Shape& shape,
+    Dtype dtype = float32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+array truncated_normal(
+    const array& lower,
+    const array& upper,
+    Dtype dtype = float32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+array gumbel(
+    const Shape& shape,
+    Dtype dtype = float32,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+array categorical(
+    const array& logits,
+    int axis,
+    const Shape& shape,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+array categorical(
+    const array& logits_,
+    int axis,
+    int num_samples,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+array categorical(
+    const array& logits,
+    int axis = -1,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+/** Generate samples from the laplace distribution. */
+array laplace(
+    const Shape& shape,
+    Dtype dtype,
+    const float loc,
+    const float scale,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+inline array laplace(
+    const Shape& shape,
+    const float loc,
+    const float scale,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return laplace(shape, float32, loc, scale, key, s);
+}
+inline array laplace(
+    const Shape& shape,
+    const Dtype dtype,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return laplace(shape, dtype, 0.0, 1.0, key, s);
+}
+inline array laplace(
+    const Shape& shape,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {}) {
+  return laplace(shape, float32, 0.0, 1.0, key, s);
+}
+
+/* Randomly permute the elements of x along the given axis. */
+array permutation(
+    const array& x,
+    int axis = 0,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+/* A random permutation of `arange(x)` */
+array permutation(
+    int x,
+    const std::optional<array>& key = std::nullopt,
+    StreamOrDevice s = {});
+
+} // namespace mlx::core::random
diff --git a/ml-stable-diffusion/mlx/mlx/scheduler.cpp b/ml-stable-diffusion/mlx/mlx/scheduler.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b19f6434a1629e571081bec55c61619c0d123fdd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/scheduler.cpp
@@ -0,0 +1,73 @@
+// Copyright © 2023 Apple Inc.
+
+#include "mlx/scheduler.h"
+#include "mlx/backend/gpu/available.h"
+#include "mlx/backend/gpu/eval.h"
+
+namespace mlx::core {
+
+Stream default_stream(Device d) {
+  if (!gpu::is_available() && d == Device::gpu) {
+    throw std::invalid_argument(
+        "[default_stream] Cannot get gpu stream without gpu backend.");
+  }
+  return scheduler::scheduler().get_default_stream(d);
+}
+
+void set_default_stream(Stream s) {
+  if (!gpu::is_available() && s.device == Device::gpu) {
+    throw std::invalid_argument(
+        "[set_default_stream] Cannot set gpu stream without gpu backend.");
+  }
+  return scheduler::scheduler().set_default_stream(s);
+}
+
+Stream get_stream(int index) {
+  return scheduler::scheduler().get_stream(index);
+}
+
+Stream new_stream(Device d) {
+  if (!gpu::is_available() && d == Device::gpu) {
+    throw std::invalid_argument(
+        "[new_stream] Cannot make gpu stream without gpu backend.");
+  }
+  return scheduler::scheduler().new_stream(d);
+}
+
+Stream new_stream() {
+  return scheduler::scheduler().new_stream(default_device());
+}
+
+void synchronize(Stream s) {
+  if (s.device == mlx::core::Device::cpu) {
+    auto p = std::make_shared<std::promise<void>>();
+    std::future<void> f = p->get_future();
+    scheduler::enqueue(s, [p = std::move(p)]() { p->set_value(); });
+    f.wait();
+  } else {
+    gpu::synchronize(s);
+  }
+}
+
+void synchronize() {
+  synchronize(default_stream(default_device()));
+}
+
+namespace scheduler {
+
+/** A singleton scheduler to manage devices, streams, and task execution. */
+Scheduler& scheduler() {
+  // Leak the scheduler on Windows to avoid joining threads on exit, can be
+  // removed after Visual Studio fixes bug:
+  // https://developercommunity.visualstudio.com/t/1654756
+#ifdef _WIN32
+  static Scheduler* scheduler = new Scheduler;
+  return *scheduler;
+#else
+  static Scheduler scheduler;
+  return scheduler;
+#endif
+}
+
+} // namespace scheduler
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/scheduler.h b/ml-stable-diffusion/mlx/mlx/scheduler.h
new file mode 100644
index 0000000000000000000000000000000000000000..877fdd5f6a0f64eebaa446e481c608b3cf8d6c28
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/scheduler.h
@@ -0,0 +1,184 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <atomic>
+#include <future>
+#include <queue>
+#include <thread>
+#include <unordered_map>
+
+#include "mlx/backend/gpu/eval.h"
+#include "mlx/device.h"
+#include "mlx/stream.h"
+
+namespace mlx::core::scheduler {
+
+struct StreamThread {
+  std::mutex mtx;
+  std::queue<std::function<void()>> q;
+  std::condition_variable cond;
+  bool stop;
+  std::thread thread;
+
+  StreamThread() : stop(false), thread(&StreamThread::thread_fn, this) {}
+
+  ~StreamThread() {
+    {
+      std::lock_guard<std::mutex> lk(mtx);
+      stop = true;
+    }
+    cond.notify_one();
+    thread.join();
+  }
+
+  void thread_fn() {
+    while (true) {
+      std::function<void()> task;
+      {
+        std::unique_lock<std::mutex> lk(mtx);
+        cond.wait(lk, [this] { return !this->q.empty() || this->stop; });
+        if (q.empty() && stop) {
+          return;
+        }
+        task = std::move(q.front());
+        q.pop();
+      }
+
+      task();
+    }
+  }
+
+  template <typename F>
+  void enqueue(F&& f) {
+    {
+      std::lock_guard<std::mutex> lk(mtx);
+      if (stop) {
+        throw std::runtime_error(
+            "Cannot enqueue work after stream is stopped.");
+      }
+      q.emplace(std::forward<F>(f));
+    }
+    cond.notify_one();
+  }
+};
+
+class Scheduler {
+ public:
+  Scheduler() : n_active_tasks_(0) {
+    if (is_available(Device::gpu)) {
+      default_streams_.insert({Device::gpu, new_stream(Device::gpu)});
+    }
+    default_streams_.insert({Device::cpu, new_stream(Device::cpu)});
+  }
+
+  // Not copyable or moveable
+  Scheduler(const Scheduler&) = delete;
+  Scheduler(Scheduler&&) = delete;
+  Scheduler& operator=(const Scheduler&) = delete;
+  Scheduler& operator=(Scheduler&&) = delete;
+
+  Stream new_stream(const Device& d) {
+    streams_.emplace_back(streams_.size(), d);
+    if (d == Device::gpu) {
+      threads_.push_back(nullptr);
+      gpu::new_stream(streams_.back());
+    } else {
+      threads_.push_back(new StreamThread{});
+    }
+    return streams_.back();
+  }
+
+  template <typename F>
+  void enqueue(const Stream& stream, F&& f);
+
+  Stream get_default_stream(const Device& d) const {
+    return default_streams_.at(d.type);
+  }
+  Stream get_stream(int index) const {
+    return streams_.at(index);
+  }
+
+  void set_default_stream(const Stream& s) {
+    default_streams_.at(s.device.type) = s;
+  }
+
+  void notify_new_task(const Stream& stream) {
+    {
+      std::lock_guard<std::mutex> lk(mtx);
+      n_active_tasks_++;
+    }
+    completion_cv.notify_all();
+  }
+
+  void notify_task_completion(const Stream& stream) {
+    {
+      std::lock_guard<std::mutex> lk(mtx);
+      n_active_tasks_--;
+    }
+    completion_cv.notify_all();
+  }
+
+  int n_active_tasks() const {
+    return n_active_tasks_;
+  }
+
+  void wait_for_one() {
+    std::unique_lock<std::mutex> lk(mtx);
+    int n_tasks_old = n_active_tasks();
+    if (n_tasks_old > 1) {
+      completion_cv.wait(lk, [this, n_tasks_old] {
+        return this->n_active_tasks() < n_tasks_old;
+      });
+    }
+  }
+
+  ~Scheduler() {
+    for (auto s : streams_) {
+      synchronize(s);
+    }
+    for (auto t : threads_) {
+      if (t != nullptr) {
+        delete t;
+      }
+    }
+  }
+
+ private:
+  int n_active_tasks_;
+  std::vector<StreamThread*> threads_;
+  std::vector<Stream> streams_;
+  std::unordered_map<Device::DeviceType, Stream> default_streams_;
+  std::condition_variable completion_cv;
+  std::mutex mtx;
+};
+
+template <typename F>
+void Scheduler::enqueue(const Stream& stream, F&& f) {
+  threads_[stream.index]->enqueue(std::forward<F>(f));
+}
+
+Scheduler& scheduler();
+
+template <typename F>
+void enqueue(const Stream& stream, F&& f) {
+  scheduler().enqueue(stream, std::forward<F>(f));
+}
+
+inline int n_active_tasks() {
+  return scheduler().n_active_tasks();
+}
+
+inline void notify_new_task(const Stream& stream) {
+  scheduler().notify_new_task(stream);
+}
+
+inline void notify_task_completion(const Stream& stream) {
+  scheduler().notify_task_completion(stream);
+}
+
+inline void wait_for_one() {
+  scheduler().wait_for_one();
+}
+
+} // namespace mlx::core::scheduler
diff --git a/ml-stable-diffusion/mlx/mlx/small_vector.h b/ml-stable-diffusion/mlx/mlx/small_vector.h
new file mode 100644
index 0000000000000000000000000000000000000000..143101c82fb0d74cca6caa0b17b86729055448a6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/small_vector.h
@@ -0,0 +1,540 @@
+// Copyright © 2025 Apple Inc.
+// Copyright © 2018 the V8 project authors.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <algorithm>
+#include <cassert>
+#include <type_traits>
+#include <utility>
+
+namespace mlx::core {
+
+#if defined(__has_builtin)
+#define MLX_HAS_BUILTIN(x) __has_builtin(x)
+#else
+#define MLX_HAS_BUILTIN(x) 0
+#endif
+
+#if defined(__has_attribute)
+#define MLX_HAS_ATTRIBUTE(x) __has_attribute(x)
+#else
+#define MLX_HAS_ATTRIBUTE(x) 0
+#endif
+
+#if MLX_HAS_BUILTIN(__builtin_expect)
+#define MLX_LIKELY(condition) (__builtin_expect(!!(condition), 1))
+#define MLX_UNLIKELY(condition) (__builtin_expect(!!(condition), 0))
+#else
+#define MLX_LIKELY(condition) (condition)
+#define MLX_UNLIKELY(condition) (condition)
+#endif
+
+#if MLX_HAS_ATTRIBUTE(noinline)
+#define MLX_NOINLINE __attribute__((noinline))
+#else
+#define MLX_NOINLINE
+#endif
+
+template <typename T, typename = void>
+struct is_iterator : std::false_type {};
+
+template <typename T>
+struct is_iterator<
+    T,
+    std::void_t<
+        typename std::iterator_traits<T>::difference_type,
+        typename std::iterator_traits<T>::iterator_category,
+        typename std::iterator_traits<T>::pointer,
+        typename std::iterator_traits<T>::reference,
+        typename std::iterator_traits<T>::value_type>> : std::true_type {};
+
+template <typename T>
+constexpr bool is_iterator_v = is_iterator<T>::value;
+
+// Minimal SmallVector implementation. Uses inline storage first, switches to
+// dynamic storage when it overflows.
+//
+// Notes:
+// * The default inline storage size is MAX_NDIM, as it is mainly used for
+//   shapes and strides, users should choose a better size for other cases.
+// * The data() returns real address even for empty vector.
+// * The pointer returned by data() will change after moving the vector as it
+//   points to the inline storage.
+// * For trivial elements the storage will not be default constructed,
+//   i.e. SmallVector<int>(10) will not be filled with 0 by default.
+template <typename T, size_t kSize = 10, typename Allocator = std::allocator<T>>
+class SmallVector {
+ public:
+  using value_type = T;
+  using reference = T&;
+  using const_reference = const T&;
+  using iterator = T*;
+  using const_iterator = const T*;
+  using difference_type = std::ptrdiff_t;
+  using size_type = std::size_t;
+
+  SmallVector() = default;
+
+  explicit SmallVector(const Allocator& allocator) : allocator_(allocator) {}
+
+  explicit SmallVector(size_t size, const Allocator& allocator = Allocator())
+      : allocator_(allocator) {
+    resize(size);
+  }
+
+  SmallVector(
+      size_t size,
+      const T& initial_value,
+      const Allocator& allocator = Allocator())
+      : allocator_(allocator) {
+    resize(size, initial_value);
+  }
+
+  SmallVector(
+      std::initializer_list<T> init,
+      const Allocator& allocator = Allocator())
+      : allocator_(allocator) {
+    if (init.size() > capacity()) {
+      grow(init.size());
+    }
+    assert(capacity() >= init.size()); // sanity check
+    std::uninitialized_move(init.begin(), init.end(), begin_);
+    end_ = begin_ + init.size();
+  }
+
+  template <typename Iter, typename = std::enable_if_t<is_iterator_v<Iter>>>
+  SmallVector(Iter begin, Iter end, const Allocator& allocator = Allocator())
+      : allocator_(allocator) {
+    size_t size = std::distance(begin, end);
+    if (size > capacity()) {
+      grow(size);
+    }
+    assert(capacity() >= size); // sanity check
+    std::uninitialized_copy(begin, end, begin_);
+    end_ = begin_ + size;
+  }
+
+  SmallVector(const SmallVector& other) : allocator_(other.allocator_) {
+    *this = other;
+  }
+  SmallVector(const SmallVector& other, const Allocator& allocator)
+      : allocator_(allocator) {
+    *this = other;
+  }
+  SmallVector(SmallVector&& other) : allocator_(std::move(other.allocator_)) {
+    *this = std::move(other);
+  }
+  SmallVector(SmallVector&& other, const Allocator& allocator)
+      : allocator_(allocator) {
+    *this = std::move(other);
+  }
+
+  ~SmallVector() {
+    free_storage();
+  }
+
+  SmallVector& operator=(const SmallVector& other) {
+    if (this == &other) {
+      return *this;
+    }
+    size_t other_size = other.size();
+    if (capacity() < other_size) {
+      // Create large-enough heap-allocated storage.
+      free_storage();
+      begin_ = allocator_.allocate(other_size);
+      end_of_storage_ = begin_ + other_size;
+      std::uninitialized_copy(other.begin_, other.end_, begin_);
+    } else if constexpr (kHasTrivialElement) {
+      std::copy(other.begin_, other.end_, begin_);
+    } else {
+      ptrdiff_t to_copy =
+          std::min(static_cast<ptrdiff_t>(other_size), end_ - begin_);
+      std::copy(other.begin_, other.begin_ + to_copy, begin_);
+      if (other.begin_ + to_copy < other.end_) {
+        std::uninitialized_copy(
+            other.begin_ + to_copy, other.end_, begin_ + to_copy);
+      } else {
+        std::destroy_n(begin_ + to_copy, size() - to_copy);
+      }
+    }
+    end_ = begin_ + other_size;
+    return *this;
+  }
+
+  SmallVector& operator=(SmallVector&& other) {
+    if (this == &other) {
+      return *this;
+    }
+    if (other.is_big()) {
+      free_storage();
+      begin_ = other.begin_;
+      end_ = other.end_;
+      end_of_storage_ = other.end_of_storage_;
+    } else {
+      assert(capacity() >= other.size()); // sanity check
+      size_t other_size = other.size();
+      if constexpr (kHasTrivialElement) {
+        std::move(other.begin_, other.end_, begin_);
+      } else {
+        ptrdiff_t to_move =
+            std::min(static_cast<ptrdiff_t>(other_size), end_ - begin_);
+        std::move(other.begin_, other.begin_ + to_move, begin_);
+        if (other.begin_ + to_move < other.end_) {
+          std::uninitialized_move(
+              other.begin_ + to_move, other.end_, begin_ + to_move);
+        } else {
+          std::destroy_n(begin_ + to_move, size() - to_move);
+        }
+      }
+      end_ = begin_ + other_size;
+    }
+    other.reset_to_inline_storage();
+    return *this;
+  }
+
+  bool operator==(const SmallVector& other) const {
+    if (size() != other.size()) {
+      return false;
+    }
+    return std::equal(begin_, end_, other.begin_);
+  }
+
+  bool operator!=(const SmallVector& other) const {
+    return !(*this == other);
+  }
+
+  T* data() {
+    return begin_;
+  }
+  const T* data() const {
+    return begin_;
+  }
+
+  iterator begin() {
+    return begin_;
+  }
+  const_iterator begin() const {
+    return begin_;
+  }
+
+  iterator end() {
+    return end_;
+  }
+  const_iterator end() const {
+    return end_;
+  }
+
+  const_iterator cbegin() const {
+    return begin_;
+  }
+
+  const_iterator cend() const {
+    return end_;
+  }
+
+  auto rbegin() {
+    return std::make_reverse_iterator(end_);
+  }
+  auto rbegin() const {
+    return std::make_reverse_iterator(end_);
+  }
+
+  auto rend() {
+    return std::make_reverse_iterator(begin_);
+  }
+  auto rend() const {
+    return std::make_reverse_iterator(begin_);
+  }
+
+  size_t size() const {
+    return end_ - begin_;
+  }
+  bool empty() const {
+    return end_ == begin_;
+  }
+  size_t capacity() const {
+    return end_of_storage_ - begin_;
+  }
+
+  T& front() {
+    assert(size() != 0);
+    return begin_[0];
+  }
+  const T& front() const {
+    assert(size() != 0);
+    return begin_[0];
+  }
+
+  T& back() {
+    assert(size() != 0);
+    return end_[-1];
+  }
+  const T& back() const {
+    assert(size() != 0);
+    return end_[-1];
+  }
+
+  T& at(size_t index) {
+    if (index >= size()) {
+      throw std::out_of_range("SmallVector out of range.");
+    }
+    return begin_[index];
+  }
+  const T& at(size_t index) const {
+    return const_cast<SmallVector*>(this)->at(index);
+  }
+
+  T& operator[](size_t index) {
+    assert(size() > index);
+    return begin_[index];
+  }
+  const T& operator[](size_t index) const {
+    return const_cast<SmallVector*>(this)->operator[](index);
+  }
+
+  template <typename... Args>
+  void emplace_back(Args&&... args) {
+    if (MLX_UNLIKELY(end_ == end_of_storage_)) {
+      grow();
+    }
+    void* storage = end_;
+    end_ += 1;
+    new (storage) T(std::forward<Args>(args)...);
+  }
+
+  void push_back(T x) {
+    emplace_back(std::move(x));
+  }
+
+  void pop_back(size_t count = 1) {
+    assert(size() >= count);
+    end_ -= count;
+    std::destroy_n(end_, count);
+  }
+
+  iterator insert(iterator pos, T value) {
+    return insert(pos, static_cast<size_t>(1), std::move(value));
+  }
+
+  iterator insert(iterator pos, size_t count, T value) {
+    assert(pos <= end_);
+    size_t offset = pos - begin_;
+    size_t old_size = size();
+    resize(old_size + count);
+    pos = begin_ + offset;
+    iterator old_end = begin_ + old_size;
+    assert(old_end <= end_);
+    std::move_backward(pos, old_end, end_);
+    if constexpr (kHasTrivialElement) {
+      std::fill_n(pos, count, value);
+    } else {
+      std::fill_n(pos + 1, count - 1, value);
+      *pos = std::move(value);
+    }
+    return pos;
+  }
+
+  template <typename Iter, typename = std::enable_if_t<is_iterator_v<Iter>>>
+  iterator insert(iterator pos, Iter begin, Iter end) {
+    if constexpr (std::is_same_v<std::decay_t<Iter>, iterator>) {
+      // The implementation can not take overlapping range.
+      assert(!(begin >= pos && begin < pos + std::distance(begin, end)));
+      assert(!(end > pos && end <= pos + std::distance(begin, end)));
+    }
+
+    assert(pos <= end_);
+    size_t offset = pos - begin_;
+    size_t count = std::distance(begin, end);
+    size_t old_size = size();
+    resize(old_size + count);
+    pos = begin_ + offset;
+    iterator old_end = begin_ + old_size;
+    assert(old_end <= end_);
+    std::move_backward(pos, old_end, end_);
+    std::copy(begin, end, pos);
+    return pos;
+  }
+
+  iterator insert(iterator pos, std::initializer_list<const T> values) {
+    return insert(pos, values.begin(), values.end());
+  }
+
+  iterator erase(iterator erase_start, iterator erase_end) {
+    assert(erase_start >= begin_);
+    assert(erase_start <= erase_end);
+    assert(erase_end <= end_);
+    iterator new_end = std::move(erase_end, end_, erase_start);
+    std::destroy_n(new_end, std::distance(new_end, end_));
+    end_ = new_end;
+    return erase_start;
+  }
+
+  iterator erase(iterator pos) {
+    return erase(pos, pos + 1);
+  }
+
+  void resize(size_t new_size) {
+    if (new_size > capacity()) {
+      grow(new_size);
+    }
+    T* new_end = begin_ + new_size;
+    if constexpr (!kHasTrivialElement) {
+      if (new_end > end_) {
+        std::uninitialized_default_construct(end_, new_end);
+      } else {
+        std::destroy_n(new_end, end_ - new_end);
+      }
+    }
+    end_ = new_end;
+  }
+
+  void resize(size_t new_size, const T& initial_value) {
+    if (new_size > capacity()) {
+      grow(new_size);
+    }
+    T* new_end = begin_ + new_size;
+    if (new_end > end_) {
+      std::uninitialized_fill(end_, new_end, initial_value);
+    } else {
+      std::destroy_n(new_end, end_ - new_end);
+    }
+    end_ = new_end;
+  }
+
+  void reserve(size_t new_capacity) {
+    if (new_capacity > capacity()) {
+      grow(new_capacity);
+    }
+  }
+
+  // Clear without reverting back to inline storage.
+  void clear() {
+    std::destroy_n(begin_, end_ - begin_);
+    end_ = begin_;
+  }
+
+ private:
+  // Grows the backing store by a factor of two, and at least to {min_capacity}.
+  // TODO: Move to private after removing external code using this method.
+  MLX_NOINLINE void grow(size_t min_capacity = 0) {
+    size_t new_capacity = std::max(min_capacity, 2 * capacity());
+    // Round up to power of 2.
+    new_capacity--;
+    new_capacity |= new_capacity >> 1;
+    new_capacity |= new_capacity >> 2;
+    new_capacity |= new_capacity >> 4;
+    new_capacity |= new_capacity >> 8;
+    new_capacity |= new_capacity >> 16;
+    if constexpr (sizeof(size_t) == sizeof(uint64_t)) {
+      new_capacity |= new_capacity >> 32;
+    }
+    new_capacity++;
+
+    T* new_storage = allocator_.allocate(new_capacity);
+    if (new_storage == nullptr) {
+      throw std::bad_alloc();
+    }
+
+    size_t in_use = end_ - begin_;
+    std::uninitialized_move(begin_, end_, new_storage);
+    free_storage();
+    begin_ = new_storage;
+    end_ = new_storage + in_use;
+    end_of_storage_ = new_storage + new_capacity;
+  }
+
+  MLX_NOINLINE void free_storage() {
+    std::destroy_n(begin_, end_ - begin_);
+    if (is_big()) {
+      allocator_.deallocate(begin_, end_of_storage_ - begin_);
+    }
+  }
+
+  // Clear and go back to inline storage. Dynamic storage is *not* freed. For
+  // internal use only.
+  void reset_to_inline_storage() {
+    if constexpr (!kHasTrivialElement) {
+      if (!is_big())
+        std::destroy_n(begin_, end_ - begin_);
+    }
+    begin_ = inline_storage_begin();
+    end_ = begin_;
+    end_of_storage_ = begin_ + kSize;
+  }
+
+  bool is_big() const {
+    return begin_ != inline_storage_begin();
+  }
+
+  T* inline_storage_begin() {
+    return reinterpret_cast<T*>(inline_storage_);
+  }
+  const T* inline_storage_begin() const {
+    return reinterpret_cast<const T*>(inline_storage_);
+  }
+
+  Allocator allocator_;
+
+  // Invariants:
+  // 1. The elements in the range between `begin_` (included) and `end_` (not
+  //    included) will be initialized at all times.
+  // 2. All other elements outside the range, both in the inline storage and in
+  //    the dynamic storage (if it exists), will be uninitialized at all times.
+
+  T* begin_ = inline_storage_begin();
+  T* end_ = begin_;
+  T* end_of_storage_ = begin_ + kSize;
+
+  alignas(T) char inline_storage_[sizeof(T) * kSize];
+
+  static constexpr bool kHasTrivialElement =
+      std::is_trivially_copyable<T>::value &&
+      std::is_trivially_destructible<T>::value;
+};
+
+template <typename>
+struct is_vector : std::false_type {};
+
+template <typename T, size_t Size, typename Allocator>
+struct is_vector<SmallVector<T, Size, Allocator>> : std::true_type {};
+
+template <typename T, typename Allocator>
+struct is_vector<std::vector<T, Allocator>> : std::true_type {};
+
+template <typename Vec>
+inline constexpr bool is_vector_v = is_vector<Vec>::value;
+
+#undef MLX_HAS_BUILTIN
+#undef MLX_HAS_ATTRIBUTE
+#undef MLX_LIKELY
+#undef MLX_UNLIKELY
+#undef MLX_NOINLINE
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/stream.h b/ml-stable-diffusion/mlx/mlx/stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ced4039fbcc8a6195ba7f1bd6595ba1dab5c915
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/stream.h
@@ -0,0 +1,41 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include "mlx/device.h"
+
+namespace mlx::core {
+
+struct Stream {
+  int index;
+  Device device;
+  explicit Stream(int index, Device device) : index(index), device(device) {}
+};
+
+/** Get the default stream for the given device. */
+Stream default_stream(Device d);
+
+/** Make the stream the default for its device. */
+void set_default_stream(Stream s);
+
+/** Make a new stream on the given device. */
+Stream new_stream(Device d);
+
+/** Get the stream with the given index. */
+Stream get_stream(int index);
+
+inline bool operator==(const Stream& lhs, const Stream& rhs) {
+  return lhs.index == rhs.index;
+}
+
+inline bool operator!=(const Stream& lhs, const Stream& rhs) {
+  return !(lhs == rhs);
+}
+
+/* Synchronize with the default stream. */
+void synchronize();
+
+/* Synchronize with the provided stream. */
+void synchronize(Stream);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/threadpool.h b/ml-stable-diffusion/mlx/mlx/threadpool.h
new file mode 100644
index 0000000000000000000000000000000000000000..b0e56d0f2c0c2271a9cb0250484ca67a003b73e3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/threadpool.h
@@ -0,0 +1,133 @@
+// This code was modified from https://github.com/progschj/ThreadPool
+// The original License is copied below:
+//
+// Copyright (c) 2012 Jakob Progsch, Václav Zeman
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+//    1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would be
+//    appreciated but is not required.
+//
+//    2. Altered source versions must be plainly marked as such, and must not be
+//    misrepresented as being the original software.
+//
+//    3. This notice may not be removed or altered from any source
+//    distribution.
+#pragma once
+
+#include <condition_variable>
+#include <functional>
+#include <future>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <stdexcept>
+#include <thread>
+#include <vector>
+
+class ThreadPool {
+ public:
+  ThreadPool(size_t);
+  template <class F, class... Args>
+  auto enqueue(F&& f, Args&&... args)
+      -> std::future<typename std::invoke_result_t<F, Args...>>;
+  void resize(size_t);
+  ~ThreadPool();
+
+ private:
+  void stop_and_wait();
+  void start_threads(size_t);
+
+  std::vector<std::thread> workers;
+  std::queue<std::function<void()>> tasks;
+  std::mutex queue_mutex;
+  std::condition_variable condition;
+  bool stop;
+};
+
+inline ThreadPool::ThreadPool(size_t threads) : stop(false) {
+  start_threads(threads);
+}
+
+template <class F, class... Args>
+auto ThreadPool::enqueue(F&& f, Args&&... args)
+    -> std::future<typename std::invoke_result_t<F, Args...>> {
+  using return_type = typename std::invoke_result_t<F, Args...>;
+
+  auto task = std::make_shared<std::packaged_task<return_type()>>(
+      std::bind(std::forward<F>(f), std::forward<Args>(args)...));
+
+  std::future<return_type> res = task->get_future();
+  {
+    std::unique_lock<std::mutex> lock(queue_mutex);
+
+    if (stop) {
+      throw std::runtime_error(
+          "[ThreadPool::enqueue] Not allowed on stopped ThreadPool");
+    }
+
+    tasks.emplace([task]() { (*task)(); });
+  }
+  condition.notify_one();
+  return res;
+}
+
+inline void ThreadPool::resize(size_t threads) {
+  if (workers.size() == threads) {
+    return;
+  }
+
+  if (workers.size() > threads) {
+    stop_and_wait();
+  }
+  start_threads(threads - workers.size());
+}
+
+inline ThreadPool::~ThreadPool() {
+  stop_and_wait();
+}
+
+inline void ThreadPool::stop_and_wait() {
+  // Stop the current threads and wait until they finish
+  {
+    std::unique_lock<std::mutex> lock(queue_mutex);
+    stop = true;
+  }
+  condition.notify_all();
+  for (std::thread& worker : workers) {
+    worker.join();
+  }
+
+  // Reset the member variables so that the threadpool is reusable
+  stop = false;
+  workers.clear();
+}
+
+inline void ThreadPool::start_threads(size_t threads) {
+  for (size_t i = 0; i < threads; ++i) {
+    workers.emplace_back([this] {
+      for (;;) {
+        std::function<void()> task;
+
+        {
+          std::unique_lock<std::mutex> lock(this->queue_mutex);
+          this->condition.wait(
+              lock, [this] { return this->stop || !this->tasks.empty(); });
+          if (this->stop && this->tasks.empty())
+            return;
+          task = std::move(this->tasks.front());
+          this->tasks.pop();
+        }
+
+        task();
+      }
+    });
+  }
+}
diff --git a/ml-stable-diffusion/mlx/mlx/transforms.cpp b/ml-stable-diffusion/mlx/mlx/transforms.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bcf0cc09f4dc6033e04db3b427207a2705b2c5db
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/transforms.cpp
@@ -0,0 +1,1059 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <algorithm>
+#include <deque>
+#include <future>
+#include <numeric>
+#include <set>
+#include <sstream>
+#include <stack>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "mlx/backend/cpu/eval.h"
+#include "mlx/backend/gpu/eval.h"
+#include "mlx/fence.h"
+#include "mlx/memory.h"
+#include "mlx/ops.h"
+#include "mlx/primitives.h"
+#include "mlx/scheduler.h"
+#include "mlx/transforms.h"
+#include "mlx/transforms_impl.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+static constexpr int MAX_ACTIVE_TASKS = 10;
+
+/* This class is only meant to be used in eval
+ * for synchronizing with the main thread. */
+class Synchronizer : public Primitive {
+ public:
+  explicit Synchronizer(Stream stream) : Primitive(stream) {}
+
+  void eval_cpu(const std::vector<array>&, std::vector<array>&) override {}
+  void eval_gpu(const std::vector<array>&, std::vector<array>&) override {}
+
+  DEFINE_NAME(Synchronize);
+};
+
+// Initialize the static tracing members from transforms_impl.h
+//
+// These are used to implement the in_tracing() function the returns true if we
+// are currently under a function transformation and the retain_graph()
+// function which returns true if we are forced to retain the graph during
+// evaluation.
+std::vector<std::pair<char, char>>& detail::InTracing::trace_stack() {
+  static std::vector<std::pair<char, char>> trace_stack_;
+  return trace_stack_;
+}
+int detail::InTracing::grad_counter{0};
+int detail::RetainGraph::tracing_counter{0};
+
+array eval_impl(std::vector<array> outputs, bool async) {
+  std::deque<array> tape;
+
+  // Make an effort to choose a good output stream
+  Stream stream = default_stream(default_device());
+  for (auto& o : outputs) {
+    if (o.status() == array::Status::unscheduled && o.has_primitive()) {
+      stream = o.primitive().stream();
+      break;
+    }
+  }
+
+  // Map of array id that needs fence and stream it's computed on
+  std::unordered_map<uintptr_t, uint32_t> needs_fence;
+
+  auto synchronizer = array(
+      {}, bool_, std::make_shared<Synchronizer>(stream), std::move(outputs));
+
+  // Stream fences for inter-stream synchronization
+  std::unordered_map<uint32_t, Fence> fences;
+
+  // Stream events for synchronization after eval
+  std::unordered_map<uint32_t, Event> events;
+  {
+    auto e = Event{stream};
+    e.set_value(1);
+    synchronizer.attach_event(e);
+    events.emplace(stream.index, std::move(e));
+  }
+
+  {
+    // Record the degree of each input
+    std::unordered_map<std::uintptr_t, int> cache;
+
+    std::stack<std::pair<std::reference_wrapper<array>, int>> dfs;
+    dfs.emplace(synchronizer, 0);
+    while (!dfs.empty()) {
+      auto& [a_ref, idx] = dfs.top();
+      auto& a = a_ref.get();
+
+      if (idx < a.inputs().size()) {
+        // Add an input, and continue
+        auto& in = a.inputs()[idx++];
+
+        if (in.status() == array::Status::unscheduled) {
+          if (async && in.is_tracer()) {
+            throw std::invalid_argument(
+                "[async_eval] Not allowed inside a graph transformation.");
+          }
+          if (!in.has_primitive()) {
+            if (in.is_tracer()) {
+              throw std::invalid_argument(
+                  "[eval] Attempting to eval an array during function"
+                  " transformations like compile or vmap is not allowed.");
+            }
+            throw std::runtime_error(
+                "[eval] Attempting to eval an array without a primitive.\n"
+                "If you are compiling a function, make sure all the inputs "
+                "and outputs are captured:\n"
+                "https://ml-explore.github.io/mlx/build/html/usage/compile.html#pure-functions.\n"
+                "If you are not using compile, this may be a bug. "
+                "Please file an issue here:\n"
+                "https://github.com/ml-explore/mlx/issues.");
+          }
+          if (a.primitive().stream() != in.primitive().stream()) {
+            needs_fence.emplace(in.id(), in.primitive().stream().index);
+          }
+        }
+
+        // All siblings have the same degree
+        auto cache_it = cache.find(in.id());
+        if (cache_it == cache.end()) {
+          dfs.emplace(in, 0);
+          cache.insert({in.id(), 1});
+          for (auto& s : in.siblings()) {
+            cache.insert({s.id(), 1});
+          }
+        } else {
+          cache_it->second++;
+          for (auto& s : in.siblings()) {
+            cache[s.id()]++;
+          }
+        }
+        continue;
+      }
+      if ((a.status() != array::Status::unscheduled) && !a.is_tracer() &&
+          a.has_primitive()) {
+        // If the array is evaluated and is no longer a tracer, detach it
+        a.detach();
+      }
+      dfs.pop();
+    }
+
+    // Build the tape in BFS order with a width limit
+    int max_width = env::bfs_max_width();
+    dfs = std::stack<std::pair<std::reference_wrapper<array>, int>>();
+    tape.push_back(synchronizer);
+    for (int i = 0; !cache.empty() && (i < tape.size() || !dfs.empty());) {
+      auto& a = (i >= tape.size()) ? dfs.top().first.get() : tape[i];
+      int j = 0;
+      if (i >= tape.size()) {
+        j = dfs.top().second;
+        dfs.pop();
+      } else {
+        i++;
+      }
+      for (; j < a.inputs().size(); ++j) {
+        auto& in = a.inputs()[j];
+        if (in.status() != array::Status::unscheduled) {
+          continue;
+        }
+
+        // If the width limit is exceeded, push the array on the stack
+        // and go down a level
+        if ((tape.size() - i) >= max_width) {
+          dfs.emplace(a, j);
+          break;
+        }
+
+        auto it = cache.find(in.id());
+        it->second -= 1;
+
+        if (it->second != 0) {
+          for (auto& s : in.siblings()) {
+            cache[s.id()] -= 1;
+          }
+          continue;
+        }
+
+        // Remove input and siblings from cache
+        cache.erase(it);
+        for (auto& s : in.siblings()) {
+          cache.erase(s.id());
+        }
+
+        tape.push_back(in);
+      }
+    }
+  }
+
+  std::unordered_set<int> open_streams;
+
+  while (!tape.empty()) {
+    auto arr = std::move(tape.back());
+    tape.pop_back();
+
+    auto stream = arr.primitive().stream();
+    open_streams.insert(stream.index);
+
+    if (async) {
+      // Lookup corresponding event
+      auto e = events.find(stream.index);
+      if (e == events.end()) {
+        e = events.emplace(stream.index, Event{stream}).first;
+      }
+      e->second.set_value(1);
+      arr.attach_event(e->second);
+      for (auto& s : arr.siblings()) {
+        s.attach_event(e->second);
+      }
+    }
+
+    for (auto& in : arr.inputs()) {
+      if (auto it = needs_fence.find(in.id()); it != needs_fence.end()) {
+        // Use fence to wait within a single eval
+        // Get the input array's stream fence and wait on the
+        // output arrays stream
+        fences[it->second].wait(stream, in);
+      } else if (in.event().valid()) {
+        if (in.event().is_signaled()) {
+          in.detach_event();
+        } else if (in.event().stream() != stream) {
+          // Use event to wait across async eval
+          in.event().wait(stream);
+        }
+      }
+    }
+
+    if (arr.primitive().device() == Device::gpu) {
+      gpu::eval(arr);
+    } else {
+      cpu::eval(arr);
+    }
+
+    if (scheduler::n_active_tasks() > MAX_ACTIVE_TASKS ||
+        (get_active_memory() > get_memory_limit() &&
+         scheduler::n_active_tasks() > 0)) {
+      // Commit any open streams
+      for (auto i : open_streams) {
+        auto s = get_stream(i);
+        if (s.device == Device::gpu) {
+          gpu::finalize(s);
+        }
+      }
+      scheduler::wait_for_one();
+      while (get_active_memory() > get_memory_limit() &&
+             scheduler::n_active_tasks() > 0) {
+        scheduler::wait_for_one();
+      }
+    }
+
+    auto maybe_update_fence = [&fences, &needs_fence, stream](const array& a) {
+      if (needs_fence.find(a.id()) != needs_fence.end()) {
+        auto it = fences.find(stream.index);
+        if (it == fences.end()) {
+          it = fences.emplace(stream.index, Fence{stream}).first;
+        }
+        it->second.update(stream, a);
+      }
+    };
+
+    arr.set_status(array::Status::evaluated);
+    // TODO Maybe always want the fence coherent kernel in the same cbuf
+    // as the other kernels?
+    maybe_update_fence(arr);
+    for (auto& sib : arr.siblings()) {
+      sib.set_status(array::Status::evaluated);
+      maybe_update_fence(sib);
+    }
+    if (!arr.is_tracer()) {
+      arr.detach();
+    }
+  }
+
+  // Signal the event in its stream
+  for (auto i : open_streams) {
+    auto s = get_stream(i);
+    if (auto e = events.find(i); e != events.end()) {
+      e->second.signal(s);
+    }
+    if (s.device == Device::gpu) {
+      gpu::finalize(s);
+    }
+  }
+
+  return synchronizer;
+}
+
+void async_eval(std::vector<array> outputs) {
+  if (outputs.empty()) {
+    return;
+  }
+
+  if (std::none_of(outputs.begin(), outputs.end(), [](array& x) {
+        return x.status() == array::Status::unscheduled;
+      })) {
+    return;
+  }
+
+  eval_impl(std::move(outputs), true);
+}
+
+void eval(std::vector<array> outputs) {
+  if (outputs.empty()) {
+    return;
+  }
+
+  if (std::none_of(outputs.begin(), outputs.end(), [](array& x) {
+        return x.status() == array::Status::unscheduled;
+      })) {
+    for (auto& x : outputs) {
+      x.wait();
+    }
+    return;
+  }
+
+  eval_impl(std::move(outputs), false).wait();
+}
+
+std::pair<std::vector<array>, std::vector<array>> vjp(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<array>& primals,
+    const std::vector<array>& cotans,
+    const std::vector<int>& argnums) {
+  // Set the global tracing flag.
+  detail::InTracing in_tracing{false, true};
+
+  // Make tracers from given primals
+  std::vector<array> primals_;
+  for (auto& p : primals) {
+    auto s = p.has_primitive() ? p.primitive().stream()
+                               : default_stream(default_device());
+    primals_.push_back(copy(p, s)); // Does not do a deep copy
+    primals_.back().set_tracer(true);
+  }
+
+  // Pass tracer primals through the function
+  // Any variables that depend on the primals are marked as tracers
+  auto outputs = fun(primals_);
+
+  // Map outputs to passed cotans while ignoring the outputs
+  // that have stop_gradient called on them
+  int cotan_index = 0;
+  std::vector<std::pair<int, int>> output_cotan_pairs;
+  for (int i = 0; i < outputs.size(); ++i) {
+    auto& out = outputs[i];
+    if (out.has_primitive()) {
+      if (auto& p = out.primitive(); typeid(p) == typeid(StopGradient)) {
+        continue;
+      }
+    }
+    if (cotan_index >= cotans.size()) {
+      std::ostringstream msg;
+      msg << "[vjp] Number of outputs to compute gradients for ("
+          << outputs.size() << ") does not match number of cotangents ("
+          << cotans.size() << ").";
+      throw std::invalid_argument(msg.str());
+    }
+    if (out.shape() != cotans[cotan_index].shape()) {
+      std::ostringstream msg;
+      msg << "[vjp] Output shape " << out.shape()
+          << " does not match cotangent shape " << cotans[cotan_index].shape()
+          << ".";
+      if (outputs.size() == 1 && out.size() == 1) {
+        msg << " If you are using grad your function must return a scalar.";
+      }
+      throw std::invalid_argument(msg.str());
+    }
+    output_cotan_pairs.emplace_back(i, cotan_index++);
+  }
+
+  // Topologically sort the compute graph, add graph nodes
+  // to the tape which need a gradient.
+  std::unordered_set<std::uintptr_t> cache;
+  std::unordered_set<std::uintptr_t> calc_grad;
+  for (int i = 0, j = 0; i < primals_.size(); ++i) {
+    auto& primal = primals_[i];
+    primal.set_tracer(false);
+    cache.insert(primal.id());
+    if (j < argnums.size() && argnums[j] == i) {
+      j++;
+      calc_grad.insert(primal.id());
+    }
+  }
+
+  std::vector<array> tape;
+
+  std::function<void(array&)> recurse;
+  recurse = [&](auto& a) {
+    // Check if visited and add to cache if not
+    if (auto inserted = cache.insert(a.id()); !inserted.second) {
+      return;
+    }
+    a.set_tracer(false);
+    for (auto& s : a.siblings()) {
+      s.set_tracer(false);
+      cache.insert(s.id());
+    }
+
+    for (auto& input : a.inputs()) {
+      recurse(input);
+    }
+
+    // Stop grad
+    if (a.has_primitive()) {
+      if (auto& p = a.primitive(); typeid(p) == typeid(StopGradient)) {
+        return;
+      }
+    }
+
+    // Calculate gradient if any inputs require gradient
+    for (auto& input : a.inputs()) {
+      if (calc_grad.find(input.id()) != calc_grad.end()) {
+        tape.push_back(a);
+        calc_grad.insert(a.id());
+        for (auto& s : a.siblings()) {
+          calc_grad.insert(s.id());
+        }
+        break;
+      }
+    }
+  };
+
+  for (auto out : outputs) {
+    recurse(out);
+  }
+
+  // Run the tape backwards, computing vector-jacobian
+  // products for each primitive
+  std::unordered_map<std::uintptr_t, array> cotan_map;
+  for (auto [out_idx, cotan_idx] : output_cotan_pairs) {
+    auto& o = outputs[out_idx];
+    auto s = o.has_primitive() ? o.primitive().stream()
+                               : default_stream(default_device());
+    cotan_map.insert({o.id(), astype(cotans[cotan_idx], o.dtype(), s)});
+  }
+  for (auto it = tape.rbegin(); it != tape.rend(); ++it) {
+    auto& a = *it;
+
+    // Get the arguments whose gradients are needed
+    std::vector<int> argnums;
+    for (int i = 0; i < a.inputs().size(); ++i) {
+      if (calc_grad.find(a.inputs()[i].id()) != calc_grad.end()) {
+        argnums.push_back(i);
+      }
+    }
+
+    // Check if any of the array or its siblings have cotangents,
+    // if not, we can skip this primitive
+    auto outputs = a.outputs();
+    bool has_cotans =
+        std::any_of(outputs.cbegin(), outputs.cend(), [&cotan_map](auto& s) {
+          return cotan_map.find(s.id()) != cotan_map.end();
+        });
+    if (!has_cotans) {
+      continue;
+    }
+
+    auto s = a.primitive().stream();
+    std::vector<array> cotangents{};
+    for (auto& o : outputs) {
+      if (auto cotan_it = cotan_map.find(o.id()); cotan_it != cotan_map.end()) {
+        cotangents.push_back(cotan_map.extract(cotan_it).mapped());
+      } else {
+        cotangents.push_back(zeros_like(o, s));
+      }
+    }
+
+    std::vector<array> vjps;
+    {
+      detail::RetainGraph retain;
+      vjps = a.primitive().vjp(a.inputs(), cotangents, argnums, outputs);
+    }
+    // Accumulate the vector-jacobian products for each input
+    for (int i = 0; i < argnums.size(); ++i) {
+      auto in_id = a.inputs()[argnums[i]].id();
+      if (auto cotan_it = cotan_map.find(in_id); cotan_it != cotan_map.end()) {
+        cotan_it->second = add(cotan_it->second, vjps[i], s);
+      } else {
+        cotan_map.insert({in_id, vjps[i]});
+      }
+    }
+  }
+  std::vector<array> vjps;
+  for (auto arg : argnums) {
+    auto& primal = primals_[arg];
+    if (auto cotan_it = cotan_map.find(primal.id());
+        cotan_it != cotan_map.end()) {
+      vjps.push_back(cotan_it->second);
+    } else {
+      auto s = primal.has_primitive() ? primal.primitive().stream()
+                                      : default_stream(default_device());
+      vjps.push_back(zeros_like(primal, s));
+    }
+  }
+  return {outputs, vjps};
+}
+
+std::pair<std::vector<array>, std::vector<array>> vjp(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<array>& primals,
+    const std::vector<array>& cotans) {
+  std::vector<int> argnums(primals.size());
+  std::iota(argnums.begin(), argnums.end(), 0);
+  return vjp(fun, primals, cotans, argnums);
+}
+
+std::pair<array, array> vjp(
+    const std::function<array(const array&)>& fun,
+    const array& primal,
+    const array& cotan) {
+  auto vec_fun = [fun](const std::vector<array>& inputs) {
+    return std::vector<array>{fun(inputs[0])};
+  };
+  auto [outputs, vjps] = vjp(vec_fun, {primal}, {cotan});
+  return {outputs[0], vjps[0]};
+}
+
+std::pair<std::vector<array>, std::vector<array>> jvp(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents) {
+  // Set the global tracing flag.
+  detail::InTracing in_tracing{false, true};
+
+  if (primals.size() != tangents.size()) {
+    throw std::invalid_argument(
+        "[jvp] Number of inputs does not match number of tangents.");
+  }
+  for (int i = 0; i < primals.size(); ++i) {
+    if (primals[i].shape() != tangents[i].shape()) {
+      throw std::invalid_argument(
+          "[jvp] Input shape does not match shape of tangent.");
+    }
+  }
+
+  std::vector<array> primals_;
+  for (auto& p : primals) {
+    auto s = p.has_primitive() ? p.primitive().stream()
+                               : default_stream(default_device());
+    primals_.push_back(copy(p, s)); // Does not do a deep copy
+    primals_.back().set_tracer(true);
+  }
+  auto outputs = fun(primals_);
+
+  // Topologically sort the compute graph, record outputs
+  // in the tape if a gradient is needed.
+  std::unordered_set<std::uintptr_t> cache;
+  std::unordered_set<std::uintptr_t> calc_grad;
+  for (auto& primal : primals_) {
+    primal.set_tracer(false);
+    calc_grad.insert(primal.id());
+    cache.insert(primal.id());
+  }
+
+  std::vector<array> tape;
+
+  std::function<void(array&)> recurse;
+  recurse = [&](auto& a) {
+    // Check if visited and add to cache if not
+    if (auto inserted = cache.insert(a.id()); !inserted.second) {
+      return;
+    }
+    a.set_tracer(false);
+    for (auto& s : a.siblings()) {
+      s.set_tracer(false);
+      cache.insert(s.id());
+    }
+
+    for (auto input : a.inputs()) {
+      recurse(input);
+    }
+
+    // Stop grad
+    if (a.has_primitive()) {
+      if (auto& p = a.primitive(); typeid(p) == typeid(StopGradient)) {
+        return;
+      }
+    }
+
+    // Calculate gradient if any inputs require gradient
+    for (auto& input : a.inputs()) {
+      if (calc_grad.find(input.id()) != calc_grad.end()) {
+        tape.push_back(a);
+        calc_grad.insert(a.id());
+        for (auto& s : a.siblings()) {
+          calc_grad.insert(s.id());
+        }
+        break;
+      }
+    }
+  };
+
+  for (auto out : outputs) {
+    recurse(out);
+  }
+
+  std::unordered_map<std::uintptr_t, array> tan_map;
+  for (int i = 0; i < primals_.size(); ++i) {
+    tan_map.insert({primals_[i].id(), tangents[i]});
+  }
+
+  for (auto& a : tape) {
+    // Get the arguments used in the jvp
+    std::vector<int> argnums;
+    std::vector<array> tangents;
+    for (int i = 0; i < a.inputs().size(); ++i) {
+      if (auto it = tan_map.find(a.inputs()[i].id()); it != tan_map.end()) {
+        argnums.push_back(i);
+        tangents.push_back(it->second);
+      }
+    }
+
+    auto jvps = a.primitive().jvp(a.inputs(), tangents, argnums);
+    auto outputs = a.outputs();
+    for (int i = 0; i < jvps.size(); ++i) {
+      tan_map.insert({outputs[i].id(), jvps[i]});
+    }
+  }
+
+  std::vector<array> jvps;
+  for (auto& out : outputs) {
+    if (auto it = tan_map.find(out.id()); it != tan_map.end()) {
+      jvps.push_back(it->second);
+    } else {
+      auto s = out.has_primitive() ? out.primitive().stream()
+                                   : default_stream(default_device());
+      jvps.push_back(zeros_like(out, s));
+    }
+  }
+  return {outputs, jvps};
+}
+
+std::pair<array, array> jvp(
+    const std::function<array(const array&)>& fun,
+    const array& primal,
+    const array& tangent) {
+  auto vec_fun = [fun](const std::vector<array>& inputs) {
+    return std::vector<array>{fun(inputs[0])};
+  };
+  auto [outputs, jvps] = jvp(vec_fun, {primal}, {tangent});
+  return {outputs[0], jvps[0]};
+}
+
+ValueAndGradFn value_and_grad(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<int>& argnums) {
+  if (argnums.empty()) {
+    throw std::invalid_argument("[grad] Must specify at least one argument.");
+  }
+  return [fun, argnums](const std::vector<array>& inputs) {
+    std::set<int> args;
+    for (auto& arg : argnums) {
+      args.insert(arg < 0 ? arg + inputs.size() : arg);
+    }
+    if (args.size() != argnums.size()) {
+      throw std::invalid_argument(
+          "[grad] Repeat argument number not allowed in grad.");
+    }
+    if (*args.begin() < 0 || *args.rbegin() >= inputs.size()) {
+      std::ostringstream msg;
+      msg << "[grad] Invalid argument number for function with "
+          << inputs.size() << " inputs.";
+      throw std::invalid_argument(msg.str());
+    }
+    std::vector<int> sorted_argnums(args.begin(), args.end());
+
+    auto gfun = [&fun](const std::vector<array>& inputs) {
+      auto outputs = fun(inputs);
+      for (int i = 1; i < outputs.size(); i++) {
+        auto& out = outputs[i];
+        auto s = out.has_primitive() ? out.primitive().stream()
+                                     : default_stream(default_device());
+        outputs[i] = stop_gradient(out, s);
+      }
+      return outputs;
+    };
+
+    // Set the incoming gradient to float32, vjp will cast it to the output type
+    auto [outputs, grads] = vjp(gfun, inputs, {array(1.0f)}, sorted_argnums);
+    return std::make_pair(outputs, grads);
+  };
+}
+
+namespace detail {
+
+std::pair<std::vector<array>, std::vector<array>> vmap_trace(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<array>& inputs,
+    const std::vector<int>& in_axes) {
+  // Set the global tracing flag.
+  detail::InTracing in_tracing;
+
+  if (in_axes.size() != inputs.size()) {
+    std::stringstream ss;
+    ss << "[vmap] The number of in axes (" << in_axes.size()
+       << ") must match the number of inputs (" << inputs.size() << ").";
+    throw std::invalid_argument(ss.str());
+  }
+
+  // Some error checking and get the vmap axis size
+  size_t vmap_ax_size;
+  for (int i = 0; i < inputs.size(); ++i) {
+    if (in_axes[i] != -1) {
+      if (inputs[i].ndim() == 0) {
+        throw std::invalid_argument(
+            "[vmap] Cannot vmap an input with zero dimensions.");
+      }
+      if (in_axes[i] > inputs[i].ndim()) {
+        std::ostringstream msg;
+        msg << "[vmap] Axis " << in_axes[i] << " invalid for input with "
+            << inputs[i].ndim() << " dimensions.";
+        throw std::invalid_argument(msg.str());
+      }
+      vmap_ax_size = inputs[i].shape(in_axes[i]);
+    }
+  }
+  // Check that all vmapped axes have the same size
+  for (int i = 0; i < inputs.size(); ++i) {
+    if (in_axes[i] != -1) {
+      if (size_t in_ax = inputs[i].shape(in_axes[i]); vmap_ax_size != in_ax) {
+        std::ostringstream msg;
+        msg << "[vmap] Inconsistent axis sizes: " << in_ax << " and "
+            << vmap_ax_size << ".";
+        throw std::invalid_argument(msg.str());
+      }
+    }
+  }
+
+  // Run the function on placeholder inputs
+  // to get the original graph
+  std::vector<array> s_inputs;
+  for (int i = 0; i < inputs.size(); ++i) {
+    if (in_axes[i] != -1) {
+      auto shape = inputs[i].shape();
+      shape.erase(shape.begin() + in_axes[i]);
+      array in(shape, inputs[i].dtype(), nullptr, {});
+      s_inputs.push_back(in);
+      s_inputs.back().set_tracer(true);
+    } else {
+      s_inputs.push_back(inputs[i]);
+    }
+  }
+  return {s_inputs, fun(s_inputs)};
+}
+
+std::vector<array> vmap_replace(
+    const std::vector<array>& inputs,
+    const std::vector<array>& s_inputs,
+    const std::vector<array>& s_outputs,
+    const std::vector<int>& in_axes,
+    const std::vector<int>& out_axes) {
+  if (out_axes.size() != s_outputs.size()) {
+    std::stringstream msg;
+    msg << "[vmap] The number of out axes (" << out_axes.size()
+        << ") must match the number of outputs (" << s_outputs.size() << ").";
+    throw std::invalid_argument(msg.str());
+  }
+
+  int vmap_size = -1;
+  for (int i = 0; i < inputs.size(); ++i) {
+    if (in_axes[i] >= 0) {
+      vmap_size = inputs[i].shape(in_axes[i]);
+      break;
+    }
+  }
+  if (vmap_size == -1) {
+    throw std::invalid_argument("At least one of in_axes must be non-None.");
+  }
+
+  std::unordered_map<std::uintptr_t, std::pair<array, int>> tmap;
+  std::unordered_set<std::uintptr_t> needs_vmap;
+  std::unordered_set<std::uintptr_t> cache;
+  for (int i = 0; i < s_inputs.size(); ++i) {
+    auto in = s_inputs[i];
+    if (in_axes[i] != -1) {
+      tmap.insert({in.id(), {inputs[i], in_axes[i]}});
+      needs_vmap.insert(in.id());
+      in.set_tracer(false);
+    }
+    cache.insert(in.id());
+  }
+
+  // Topologically sort the graph
+  std::vector<array> tape;
+
+  std::function<void(const array&)> recurse;
+
+  recurse = [&](const array& a) {
+    auto id = a.id();
+    if (cache.find(id) != cache.end()) {
+      return;
+    }
+    cache.insert(id);
+    for (auto& s : a.siblings()) {
+      cache.insert(s.id());
+    }
+
+    // Recurse on inputs
+    for (auto& input : a.inputs()) {
+      recurse(input);
+    }
+    // If any input needs a vmap, then the outputs also need
+    // a vmap
+    for (auto& input : a.inputs()) {
+      if (needs_vmap.find(input.id()) != needs_vmap.end()) {
+        tape.push_back(a);
+        tape.back().set_tracer(false);
+        needs_vmap.insert(a.id());
+        for (auto s : a.siblings()) {
+          needs_vmap.insert(s.id());
+          s.set_tracer(false);
+        }
+        break;
+      }
+    }
+  };
+
+  for (auto& out : s_outputs) {
+    if (out.has_primitive()) {
+      recurse(out);
+    }
+  }
+
+  // Transform each primitive in the graph with
+  // its vmap implementation
+  for (auto& a : tape) {
+    std::vector<array> v_inputs;
+    std::vector<int> v_axes;
+    for (auto& in : a.inputs()) {
+      auto map_it = tmap.find(in.id());
+      if (map_it != tmap.end()) {
+        v_inputs.push_back(map_it->second.first);
+        v_axes.push_back(map_it->second.second);
+      } else {
+        v_inputs.push_back(in);
+        v_axes.push_back(-1);
+      }
+    }
+
+    auto [v_outputs, v_out_axes] = a.primitive().vmap(v_inputs, v_axes);
+
+    // For each primitive's outputs add its id, the vout id and the vax
+    auto outputs = a.outputs();
+    for (int i = 0; i < v_outputs.size(); ++i) {
+      tmap.insert({outputs[i].id(), {v_outputs[i], v_out_axes[i]}});
+    }
+  }
+
+  // Populate the outputs and make sure all the output axes are
+  // in the right place
+  std::vector<array> outputs;
+  for (int i = 0; i < s_outputs.size(); ++i) {
+    if (auto map_it = tmap.find(s_outputs[i].id()); map_it != tmap.end()) {
+      auto& [out, vdim] = map_it->second;
+      if (vdim != out_axes[i]) {
+        if (out_axes[i] >= out.ndim()) {
+          std::ostringstream msg;
+          msg << "[vmap] Axis " << out_axes[i] << " invalid for output with "
+              << out.ndim() << " dimensions.";
+          throw std::invalid_argument(msg.str());
+        }
+        out = moveaxis(out, vdim, out_axes[i]);
+      }
+      outputs.push_back(out);
+    } else {
+      // When the output has no input dependencies
+      // use the size of the vmapped axis in the inputs to expand the output
+      array output = expand_dims(s_outputs[i], out_axes[i]);
+      output = repeat(output, vmap_size, out_axes[i]);
+      outputs.push_back(output);
+    }
+  }
+  return outputs;
+}
+
+} // namespace detail
+
+std::function<std::vector<array>(const std::vector<array>&)> vmap(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<int>& in_axes /* = {} */,
+    const std::vector<int>& out_axes /* = {} */) {
+  auto infer_axes = [](auto axes) {
+    return !axes.empty() &&
+        std::all_of(axes.begin(), axes.end(), [](int ax) { return ax < 0; });
+  };
+  if (infer_axes(in_axes) != infer_axes(out_axes)) {
+    throw std::invalid_argument(
+        "[vmap] Input (or output) axes must be "
+        "specified if output (or input) axes are.");
+  }
+  auto vfun = [fun, in_axes = in_axes, out_axes = out_axes](
+                  const std::vector<array>& inputs) mutable {
+    if (in_axes.size() == 0) {
+      in_axes.resize(inputs.size(), 0);
+    }
+
+    auto [trace_inputs, trace_outputs] =
+        detail::vmap_trace(fun, inputs, in_axes);
+
+    if (out_axes.size() == 0) {
+      out_axes.resize(trace_outputs.size(), 0);
+    }
+
+    return detail::vmap_replace(
+        inputs, trace_inputs, trace_outputs, in_axes, out_axes);
+  };
+
+  return vfun;
+}
+
+std::function<array(const array&, const array&)> vmap(
+    const std::function<array(const array&, const array&)>& fun,
+    int in_axis_a /* = 0 */,
+    int in_axis_b /* = 0 */,
+    int out_axis /* = 0 */) {
+  auto vfun = vmap(
+      [in_axis_a, in_axis_b, out_axis, fun](const std::vector<array>& inputs) {
+        return std::vector<array>{fun(inputs[0], inputs[1])};
+      },
+      {in_axis_a, in_axis_b},
+      {out_axis});
+  return [vfun](const array& a, const array& b) { return vfun({a, b})[0]; };
+}
+
+std::function<array(const array&)> vmap(
+    const std::function<array(const array&)>& fun,
+    int in_axis /* = 0 */,
+    int out_axis /* = 0 */) {
+  auto vfun = vmap(
+      [in_axis, out_axis, fun](const std::vector<array>& inputs) {
+        return std::vector<array>{fun(inputs[0])};
+      },
+      {in_axis},
+      {out_axis});
+  return [vfun](const array& a) { return vfun({a})[0]; };
+}
+
+std::function<std::vector<array>(const std::vector<array>&)> custom_function(
+    std::function<std::vector<array>(const std::vector<array>&)> fun,
+    std::optional<std::function<std::vector<array>(
+        const std::vector<array>&,
+        const std::vector<array>&,
+        const std::vector<array>&)>> fun_vjp /* = std::nullopt */,
+    std::optional<std::function<std::vector<array>(
+        const std::vector<array>&,
+        const std::vector<array>&,
+        const std::vector<int>&)>> fun_jvp /* = std::nullopt */,
+    std::optional<std::function<std::pair<std::vector<array>, std::vector<int>>(
+        const std::vector<array>&,
+        const std::vector<int>&)>> fun_vmap /* = std::nullopt */) {
+  if (!fun_vjp.has_value() && !fun_jvp.has_value() && !fun_vmap.has_value()) {
+    return fun;
+  }
+
+  return [fun = std::move(fun),
+          fun_vjp = std::move(fun_vjp),
+          fun_jvp = std::move(fun_jvp),
+          fun_vmap = std::move(fun_vmap)](const std::vector<array>& args) {
+    // Compute the outputs
+    auto outputs = fun(args);
+    for (auto& out : outputs) {
+      out = stop_gradient(out);
+    }
+
+    // Prepare the inputs to the primitive
+    // We also add the outputs to the primitive so that it can "run" the forward
+    // pass.
+    std::vector<array> inputs = args;
+    inputs.insert(inputs.end(), outputs.begin(), outputs.end());
+
+    // Compute the stream. Maybe do it in a smarter way at some point in the
+    // future.
+    Stream s = (outputs[0].has_primitive()) ? outputs[0].primitive().stream()
+                                            : default_stream(default_device());
+
+    // Make the output info
+    std::vector<Shape> shapes;
+    std::vector<Dtype> dtypes;
+    for (const auto& out : outputs) {
+      shapes.emplace_back(out.shape());
+      dtypes.emplace_back(out.dtype());
+    }
+
+    return array::make_arrays(
+        std::move(shapes),
+        dtypes,
+        std::make_shared<CustomTransforms>(
+            to_stream(s),
+            outputs.size(),
+
+            // We use the passed vjp function or compute it from the inputs and
+            // passed cotangents. Note that this may be less efficient than
+            // using `fun` directly because we may not be able to fully reuse
+            // the outputs of the forward pass.
+            fun_vjp.value_or(
+                [fun](auto primals, auto cotangents, auto outputs) {
+                  auto [__, vjps] = vjp(fun, primals, cotangents);
+                  return vjps;
+                }),
+
+            // We use the passed jvp function or compute it from the primals
+            // and tangents. Similarly we can't take full advantage of the
+            // argnums so it is best to use `fun` directly if we don't need a
+            // custom transform.
+            //
+            // TODO: Use stop_gradient to make full use of argnums and not
+            //       waste computation.
+            fun_jvp.value_or([fun](auto primals, auto tangents, auto argnums) {
+              std::vector<array> all_tangents;
+              for (int i = 0, j = 0; i < primals.size(); i++) {
+                if (j < argnums.size() && i == argnums[j]) {
+                  all_tangents.emplace_back(tangents[j++]);
+                } else {
+                  all_tangents.emplace_back(zeros_like(primals[i]));
+                }
+              }
+              auto [__, jvps] = jvp(fun, primals, all_tangents);
+              return jvps;
+            }),
+
+            // Same as above, we use the passed vmap function or we compute it
+            // from `fun`. The output axes is selected to be all 0s which again
+            // may be suboptimal but the only thing we can do without any
+            // information for `fun`.
+            fun_vmap.value_or(
+                [fun, out_size = outputs.size()](auto inputs, auto in_axes)
+                    -> std::pair<std::vector<array>, std::vector<int>> {
+                  std::vector<int> out_axes(out_size, 0);
+                  return {vmap(fun, in_axes, out_axes)(inputs), out_axes};
+                })),
+        inputs);
+  };
+}
+
+std::function<std::vector<array>(const std::vector<array>&)> custom_vjp(
+    std::function<std::vector<array>(const std::vector<array>&)> fun,
+    std::function<std::vector<array>(
+        const std::vector<array>&,
+        const std::vector<array>&,
+        const std::vector<array>&)> fun_vjp) {
+  return custom_function(fun, fun_vjp, std::nullopt, std::nullopt);
+}
+
+std::function<std::vector<array>(const std::vector<array>&)> checkpoint(
+    std::function<std::vector<array>(const std::vector<array>&)> fun) {
+  auto vjp_fun = [fun](
+                     const std::vector<array>& primals,
+                     const std::vector<array>& cotangents,
+                     const std::vector<array>& outputs) -> std::vector<array> {
+    auto [__, vjps] = vjp(fun, depends(primals, outputs), cotangents);
+    return vjps;
+  };
+
+  return custom_vjp(fun, vjp_fun);
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/transforms.h b/ml-stable-diffusion/mlx/mlx/transforms.h
new file mode 100644
index 0000000000000000000000000000000000000000..4afb21e2305bd42cd9d231bdf6b84b132ae40230
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/transforms.h
@@ -0,0 +1,229 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <optional>
+
+#include "mlx/array.h"
+
+namespace mlx::core {
+
+void async_eval(std::vector<array> outputs);
+
+template <typename... Arrays, typename = enable_for_arrays_t<Arrays...>>
+void async_eval(Arrays&&... outputs) {
+  async_eval(std::vector<array>{std::forward<Arrays>(outputs)...});
+}
+
+void eval(std::vector<array> outputs);
+
+template <typename... Arrays, typename = enable_for_arrays_t<Arrays...>>
+void eval(Arrays&&... outputs) {
+  eval(std::vector<array>{std::forward<Arrays>(outputs)...});
+}
+
+/**
+ *  Computes the output and vector-Jacobian product (VJP) of a function.
+ *
+ *  Computes the vector-Jacobian product of the vector of cotangents with the
+ *  Jacobian of the function evaluated at the primals. Returns a pair of
+ *  vectors of output arrays and VJP arrays.
+ **/
+std::pair<std::vector<array>, std::vector<array>> vjp(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<array>& primals,
+    const std::vector<array>& cotangents);
+
+/**
+ *  Computes the output and vector-Jacobian product (VJP) of a unary function.
+ */
+std::pair<array, array> vjp(
+    const std::function<array(const array&)>& fun,
+    const array& primal,
+    const array& cotangent);
+
+/**
+ *  Computes the output and Jacobian-vector product (JVP) of a function.
+ *
+ *  Computes the Jacobian-vector product of the Jacobian of the function
+ *  evaluated at the primals with the vector of tangents. Returns a pair of
+ *  vectors of output arrays and JVP arrays.
+ **/
+std::pair<std::vector<array>, std::vector<array>> jvp(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<array>& primals,
+    const std::vector<array>& tangents);
+
+/**
+ *  Computes the output and Jacobian-vector product (JVP) of a unary function.
+ */
+std::pair<array, array> jvp(
+    const std::function<array(const array&)>& fun,
+    const array& primal,
+    const array& tangent);
+
+// Return type of general value_and_grad: a function which takes an input
+// vector of arrays and returns a pair of vectors of arrays one for the
+// values and one for the gradients wrt the first value.
+using ValueAndGradFn =
+    std::function<std::pair<std::vector<array>, std::vector<array>>(
+        const std::vector<array>&)>;
+using SimpleValueAndGradFn = std::function<std::pair<array, std::vector<array>>(
+    const std::vector<array>&)>;
+
+/**
+ *  Returns a function which computes the value and gradient of the input
+ *  function with respect to a vector of input arrays.
+ **/
+ValueAndGradFn value_and_grad(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<int>& argnums);
+
+/**
+ *  Returns a function which computes the value and gradient of the input
+ *  function with respect to a single input array.
+ **/
+ValueAndGradFn inline value_and_grad(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    int argnum = 0) {
+  return value_and_grad(fun, std::vector<int>{argnum});
+}
+
+/**
+ *  Returns a function which computes the value and gradient of the unary
+ *  input function.
+ **/
+std::function<std::pair<array, array>(const array&)> inline value_and_grad(
+    const std::function<array(const array&)>& fun) {
+  return [fun](auto inputs) { return vjp(fun, inputs, array(1.0f)); };
+}
+
+SimpleValueAndGradFn inline value_and_grad(
+    const std::function<array(const std::vector<array>&)>& fun,
+    const std::vector<int>& argnums) {
+  return [fun, argnums](auto inputs) {
+    auto result = value_and_grad(
+        [fun](auto inputs) { return std::vector<array>{fun(inputs)}; },
+        argnums)(inputs);
+
+    return std::make_pair(result.first[0], result.second);
+  };
+}
+
+SimpleValueAndGradFn inline value_and_grad(
+    const std::function<array(const std::vector<array>&)>& fun,
+    int argnum = 0) {
+  return value_and_grad(fun, std::vector<int>{argnum});
+}
+
+/**
+ *  Returns a function which computes the gradient of the input function with
+ *  respect to a vector of input arrays.
+ *
+ *  The function being differentiated takes a vector of arrays and returns an
+ *  array. The vector of `argnums` specifies which the arguments to compute
+ *  the gradient with respect to. At least one argument must be specified.
+ **/
+std::function<std::vector<array>(const std::vector<array>&)> inline grad(
+    const std::function<array(const std::vector<array>&)>& fun,
+    const std::vector<int>& argnums) {
+  auto fn = value_and_grad(fun, argnums);
+  return [fn](const std::vector<array>& inputs) { return fn(inputs).second; };
+}
+
+/**
+ *  Returns a function which computes the gradient of the input function with
+ *  respect to a single input array.
+ *
+ *  The function being differentiated takes a vector of arrays and returns an
+ *  array. The optional `argnum` index specifies which the argument to compute
+ *  the gradient with respect to and defaults to 0.
+ **/
+std::function<std::vector<array>(const std::vector<array>&)> inline grad(
+    const std::function<array(const std::vector<array>&)>& fun,
+    int argnum = 0) {
+  return grad(fun, std::vector<int>{argnum});
+}
+
+/**
+ *  Returns a function which computes the gradient of the unary input function.
+ **/
+std::function<array(const array&)> inline grad(
+    const std::function<array(const array&)>& fun) {
+  auto fn = value_and_grad(fun);
+  return [fn](const array& input) { return fn(input).second; };
+}
+
+/**
+ * Automatically vectorize a unary function over the requested axes.
+ */
+std::function<array(const array&)> vmap(
+    const std::function<array(const array&)>& fun,
+    int in_axis = 0,
+    int out_axis = 0);
+
+/**
+ * Automatically vectorize a binary function over the requested axes.
+ */
+std::function<array(const array&, const array&)> vmap(
+    const std::function<array(const array&, const array&)>& fun,
+    int in_axis_a = 0,
+    int in_axis_b = 0,
+    int out_axis = 0);
+
+/**
+ * Automatically vectorize a function over the requested axes.
+ *
+ * The input function to `vmap` takes as an argument a vector of arrays and
+ * returns a vector of arrays. Optionally specify the axes to vectorize over
+ * with `in_axes` and `out_axes`, otherwise a default of 0 is used.
+ * Returns a vectorized function with the same signature as the input
+ * function.
+ */
+std::function<std::vector<array>(const std::vector<array>&)> vmap(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<int>& in_axes = {},
+    const std::vector<int>& out_axes = {});
+
+/**
+ * Redefine the transformations of `fun` according to the provided functions.
+ *
+ * Namely when calling the vjp of `fun` then `fun_vjp` will be called,
+ * `fun_jvp` for the jvp and `fun_vmap` for vmap.
+ *
+ * If any transformation is not provided, then a default one is created by
+ * calling `vjp`, `jvp` and `vmap` on the function directly.
+ */
+std::function<std::vector<array>(const std::vector<array>&)> custom_function(
+    std::function<std::vector<array>(const std::vector<array>&)> fun,
+    std::optional<std::function<std::vector<array>(
+        const std::vector<array>&,
+        const std::vector<array>&,
+        const std::vector<array>&)>> fun_vjp = std::nullopt,
+    std::optional<std::function<std::vector<array>(
+        const std::vector<array>&,
+        const std::vector<array>&,
+        const std::vector<int>&)>> fun_jvp = std::nullopt,
+    std::optional<std::function<std::pair<std::vector<array>, std::vector<int>>(
+        const std::vector<array>&,
+        const std::vector<int>&)>> fun_vmap = std::nullopt);
+
+/**
+ * Return a function that behaves exactly like `fun` but if the vjp of the
+ * results is computed `fun_vjp` will be used instead of `vjp(fun, ...)` .
+ */
+std::function<std::vector<array>(const std::vector<array>&)> custom_vjp(
+    std::function<std::vector<array>(const std::vector<array>&)> fun,
+    std::function<std::vector<array>(
+        const std::vector<array>&,
+        const std::vector<array>&,
+        const std::vector<array>&)> fun_vjp);
+
+/**
+ * Checkpoint the gradient of a function. Namely, discard all intermediate
+ * state and recalculate it when we need to compute the gradient.
+ */
+std::function<std::vector<array>(const std::vector<array>&)> checkpoint(
+    std::function<std::vector<array>(const std::vector<array>&)> fun);
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/transforms_impl.h b/ml-stable-diffusion/mlx/mlx/transforms_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..46851fa3d9398dc1a1b68e81633dae9a9e686e2f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/transforms_impl.h
@@ -0,0 +1,86 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+namespace mlx::core::detail {
+
+std::pair<std::vector<array>, std::vector<array>> vmap_trace(
+    const std::function<std::vector<array>(const std::vector<array>&)>& fun,
+    const std::vector<array>& inputs,
+    const std::vector<int>& in_axes);
+
+std::vector<array> vmap_replace(
+    const std::vector<array>& inputs,
+    const std::vector<array>& s_inputs,
+    const std::vector<array>& s_outputs,
+    const std::vector<int>& in_axes,
+    const std::vector<int>& out_axes);
+
+// Create an InTracing object during tracing operations to signify to the rest
+// of the codebase that we are during tracing so evals should not throw away
+// the graph.
+struct InTracing {
+  explicit InTracing(bool dynamic = false, bool grad = false) {
+    grad_counter += grad;
+    trace_stack().push_back({dynamic, grad});
+  }
+  ~InTracing() {
+    grad_counter -= trace_stack().back().second;
+    trace_stack().pop_back();
+  }
+
+  static bool in_tracing() {
+    return !trace_stack().empty();
+  }
+  static bool in_dynamic_tracing() {
+    // compile is always and only the outer-most transform
+    return in_tracing() && trace_stack().front().first;
+  }
+
+  static bool in_grad_tracing() {
+    return grad_counter > 0;
+  }
+
+ private:
+  static int grad_counter;
+  static std::vector<std::pair<char, char>>& trace_stack();
+};
+
+struct RetainGraph {
+  RetainGraph() {
+    tracing_counter++;
+  }
+  ~RetainGraph() {
+    tracing_counter--;
+  }
+
+  static bool retain_graph() {
+    return tracing_counter > 0;
+  }
+
+ private:
+  static int tracing_counter;
+};
+
+/** Return true if we are currently performing a function transformation in
+ * order to keep the graph when evaluating tracer arrays. */
+inline bool in_tracing() {
+  return detail::InTracing::in_tracing();
+}
+
+/** Return true if we are in a dynamic (shapeless) trace used for compiling or
+ * exporting graphs with dynamic shapes.  */
+inline bool in_dynamic_tracing() {
+  return detail::InTracing::in_dynamic_tracing();
+}
+
+/** Return true if we are in a gradient trace (vjp, jvp, etc).  */
+inline bool in_grad_tracing() {
+  return detail::InTracing::in_grad_tracing();
+}
+
+inline bool retain_graph() {
+  return detail::RetainGraph::retain_graph();
+}
+
+} // namespace mlx::core::detail
diff --git a/ml-stable-diffusion/mlx/mlx/types/bf16.h b/ml-stable-diffusion/mlx/mlx/types/bf16.h
new file mode 100644
index 0000000000000000000000000000000000000000..5951941747c022284e7926b88ac4bfebbdf78226
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/types/bf16.h
@@ -0,0 +1,187 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <vector>
+
+#define __MLX_BFLOAT_NAN__ 0x7FC0
+
+namespace mlx::core {
+
+namespace {
+union float_bits_bf16 {
+  float f;
+  uint32_t u;
+};
+} // namespace
+
+struct _MLX_BFloat16 {
+  uint16_t bits_;
+
+  // Default constructor
+  _MLX_BFloat16() = default;
+
+  // Default copy constructor
+  _MLX_BFloat16(_MLX_BFloat16 const&) = default;
+
+  // Appease std::vector<bool> for being special
+  _MLX_BFloat16& operator=(std::vector<bool>::reference x) {
+    bits_ = x;
+    return *this;
+  }
+
+  _MLX_BFloat16& operator=(const float& x) {
+    return (*this = _MLX_BFloat16(x));
+  }
+
+  // From float32
+  _MLX_BFloat16(const float& x) {
+    if (std::isnan(x)) {
+      bits_ = __MLX_BFLOAT_NAN__;
+    } else {
+      // Union
+      float_bits_bf16 in;
+
+      // Take bits
+      in.f = x;
+
+      // Round to nearest even
+      in.u += (in.u >> 16 & 1) + uint32_t(0x7FFF);
+
+      // Take upper 16 bits
+      bits_ = in.u >> 16;
+    }
+  }
+
+  // To float32
+  operator float() const {
+    // Union
+    float_bits_bf16 out;
+
+    // Upper 16 bits are the data and lower 16 bits are 0s
+    out.u = ((uint32_t)bits_) << 16;
+
+    return out.f;
+  }
+};
+
+#define bfloat_binop_base(__op__, __operator__, otype, atype, btype, ctype) \
+  inline otype __operator__(atype lhs, btype rhs) {                         \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);          \
+  }
+
+#define bfloat_binop_helper(__op__, __operator__, otype, itype, ctype) \
+  inline otype __operator__(_MLX_BFloat16 lhs, itype rhs) {            \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);     \
+  }                                                                    \
+  inline otype __operator__(itype lhs, _MLX_BFloat16 rhs) {            \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);     \
+  }
+
+// Operators
+#define bfloat_binop(_op_, _operator_)                                       \
+  bfloat_binop_base(                                                         \
+      _op_, _operator_, _MLX_BFloat16, _MLX_BFloat16, _MLX_BFloat16, float); \
+  bfloat_binop_helper(_op_, _operator_, float, float, float);                \
+  bfloat_binop_helper(_op_, _operator_, double, double, double);             \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, bool, float);         \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, int32_t, float);      \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, uint32_t, float);     \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, int64_t, float);      \
+  bfloat_binop_helper(_op_, _operator_, _MLX_BFloat16, uint64_t, float);
+
+bfloat_binop(+, operator+);
+bfloat_binop(-, operator-);
+bfloat_binop(*, operator*);
+bfloat_binop(/, operator/);
+
+#undef bfloat_binop
+
+// Comparison ops
+#define bfloat_compop(__op__, __operator__)                             \
+  bfloat_binop_base(                                                    \
+      __op__, __operator__, bool, _MLX_BFloat16, _MLX_BFloat16, float); \
+  bfloat_binop_helper(__op__, __operator__, bool, float, float);        \
+  bfloat_binop_helper(__op__, __operator__, bool, double, double);      \
+  bfloat_binop_helper(__op__, __operator__, bool, int32_t, float);      \
+  bfloat_binop_helper(__op__, __operator__, bool, uint32_t, float);     \
+  bfloat_binop_helper(__op__, __operator__, bool, int64_t, float);      \
+  bfloat_binop_helper(__op__, __operator__, bool, uint64_t, float);
+
+bfloat_compop(>, operator>);
+bfloat_compop(<, operator<);
+bfloat_compop(>=, operator>=);
+bfloat_compop(<=, operator<=);
+bfloat_compop(==, operator==);
+bfloat_compop(!=, operator!=);
+
+#undef bfloat_compop
+
+// Negative
+inline _MLX_BFloat16 operator-(_MLX_BFloat16 lhs) {
+  return -static_cast<float>(lhs);
+}
+
+// Inplace ops
+#define bfloat_inplace_op(__op__, __operator__)                              \
+  inline _MLX_BFloat16& __operator__(_MLX_BFloat16& lhs, const float& rhs) { \
+    lhs = lhs __op__ rhs;                                                    \
+    return lhs;                                                              \
+  }                                                                          \
+  inline float& __operator__(float& lhs, _MLX_BFloat16 rhs) {                \
+    lhs = lhs __op__ rhs;                                                    \
+    return lhs;                                                              \
+  }
+
+bfloat_inplace_op(+, operator+=);
+bfloat_inplace_op(-, operator-=);
+bfloat_inplace_op(*, operator*=);
+bfloat_inplace_op(/, operator/=);
+
+#undef bfloat_inplace_op
+
+// Bitwise ops
+
+#define bfloat_bitop(__op__, __operator__)                                  \
+  inline _MLX_BFloat16 __operator__(_MLX_BFloat16 lhs, _MLX_BFloat16 rhs) { \
+    _MLX_BFloat16 out;                                                      \
+    out.bits_ = lhs.bits_ __op__ rhs.bits_;                                 \
+    return out;                                                             \
+  }                                                                         \
+  inline _MLX_BFloat16 __operator__(_MLX_BFloat16 lhs, uint16_t rhs) {      \
+    _MLX_BFloat16 out;                                                      \
+    out.bits_ = lhs.bits_ __op__ rhs;                                       \
+    return out;                                                             \
+  }                                                                         \
+  inline _MLX_BFloat16 __operator__(uint16_t lhs, _MLX_BFloat16 rhs) {      \
+    _MLX_BFloat16 out;                                                      \
+    out.bits_ = lhs __op__ rhs.bits_;                                       \
+    return out;                                                             \
+  }
+
+bfloat_bitop(|, operator|);
+bfloat_bitop(&, operator&);
+bfloat_bitop(^, operator^);
+
+#undef bfloat_bitop
+
+#define bfloat_inplace_bitop(__op__, __operator__)                            \
+  inline _MLX_BFloat16& __operator__(_MLX_BFloat16& lhs, _MLX_BFloat16 rhs) { \
+    lhs.bits_ = lhs.bits_ __op__ rhs.bits_;                                   \
+    return lhs;                                                               \
+  }                                                                           \
+  inline _MLX_BFloat16& __operator__(_MLX_BFloat16& lhs, uint16_t rhs) {      \
+    lhs.bits_ = lhs.bits_ __op__ rhs;                                         \
+    return lhs;                                                               \
+  }
+
+bfloat_inplace_bitop(|, operator|=);
+bfloat_inplace_bitop(&, operator&=);
+bfloat_inplace_bitop(^, operator^=);
+
+#undef bfloat_inplace_bitop
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/types/complex.h b/ml-stable-diffusion/mlx/mlx/types/complex.h
new file mode 100644
index 0000000000000000000000000000000000000000..51101cc97b32579aeee5f118f1120ece0d78cd6e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/types/complex.h
@@ -0,0 +1,113 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+#include <complex>
+#include "mlx/types/half_types.h"
+
+namespace mlx::core {
+
+struct complex64_t;
+struct complex128_t;
+
+template <typename T>
+inline constexpr bool can_convert_to_complex128 =
+    !std::is_same_v<T, complex128_t> && std::is_convertible_v<T, double>;
+
+struct complex128_t : public std::complex<double> {
+  complex128_t() : std::complex<double>() {};
+  complex128_t(double v, double u) : std::complex<double>(v, u) {};
+  complex128_t(std::complex<double> v) : std::complex<double>(v) {};
+
+  template <
+      typename T,
+      typename = typename std::enable_if<can_convert_to_complex128<T>>::type>
+  complex128_t(T x) : std::complex<double>(x){};
+
+  operator float() const {
+    return real();
+  };
+};
+
+template <typename T>
+inline constexpr bool can_convert_to_complex64 =
+    !std::is_same_v<T, complex64_t> && std::is_convertible_v<T, float>;
+
+struct complex64_t : public std::complex<float> {
+  complex64_t() : std::complex<float>() {};
+  complex64_t(float v, float u) : std::complex<float>(v, u) {};
+  complex64_t(std::complex<float> v) : std::complex<float>(v) {};
+
+  template <
+      typename T,
+      typename = typename std::enable_if<can_convert_to_complex64<T>>::type>
+  complex64_t(T x) : std::complex<float>(x){};
+
+  operator float() const {
+    return real();
+  };
+};
+
+inline bool operator>=(const complex64_t& a, const complex64_t& b) {
+  return (a.real() > b.real()) ||
+      (a.real() == b.real() && a.imag() >= b.imag());
+}
+
+inline bool operator>(const complex64_t& a, const complex64_t& b) {
+  return (a.real() > b.real()) || (a.real() == b.real() && a.imag() > b.imag());
+}
+
+inline complex64_t operator%(complex64_t a, complex64_t b) {
+  auto real = a.real() - (b.real() * static_cast<int64_t>(a.real() / b.real()));
+  auto imag = a.imag() - (b.imag() * static_cast<int64_t>(a.imag() / b.imag()));
+  if (real != 0 && ((real < 0) != (b.real() < 0)))
+    real += b.real();
+  if (imag != 0 && ((imag < 0) != (b.imag() < 0)))
+    imag += b.imag();
+  return {real, imag};
+}
+
+inline bool operator<=(const complex64_t& a, const complex64_t& b) {
+  return operator>=(b, a);
+}
+
+inline bool operator<(const complex64_t& a, const complex64_t& b) {
+  return operator>(b, a);
+}
+
+inline complex64_t operator-(const complex64_t& v) {
+  return -static_cast<std::complex<float>>(v);
+}
+
+// clang-format off
+#define complex_binop_helper(_op_, _operator_, itype)            \
+  inline complex64_t _operator_(itype x, const complex64_t& y) { \
+    return static_cast<complex64_t>(x) _op_ y;           \
+  }                                                              \
+  inline complex64_t _operator_(const complex64_t& x, itype y) { \
+    return x _op_ static_cast<complex64_t>(y);           \
+  }
+
+#define complex_binop(_op_, _operator_)                                               \
+  inline complex64_t _operator_(const std::complex<float>& x, const complex64_t& y) { \
+    return x _op_ static_cast<std::complex<float>>(y);                                \
+  }                                                                                   \
+  inline complex64_t _operator_(const complex64_t& x, const std::complex<float>& y) { \
+    return static_cast<std::complex<float>>(x) _op_ y;                                \
+  }                                                                                   \
+  inline complex64_t _operator_(const complex64_t& x, const complex64_t& y) {         \
+    return static_cast<std::complex<float>>(x)                                        \
+        _op_ static_cast<std::complex<float>>(y);                                     \
+  }                                                                                   \
+  complex_binop_helper(_op_, _operator_, bool)                                        \
+  complex_binop_helper(_op_, _operator_, uint32_t)                                    \
+  complex_binop_helper(_op_, _operator_, uint64_t)                                    \
+  complex_binop_helper(_op_, _operator_, int32_t)                                     \
+  complex_binop_helper(_op_, _operator_, int64_t)                                     \
+  complex_binop_helper(_op_, _operator_, float16_t)                                   \
+  complex_binop_helper(_op_, _operator_, bfloat16_t)                                  \
+  complex_binop_helper(_op_, _operator_, float)
+// clang-format on
+
+complex_binop(+, operator+)
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/types/fp16.h b/ml-stable-diffusion/mlx/mlx/types/fp16.h
new file mode 100644
index 0000000000000000000000000000000000000000..c174afebcb4e221a7437af2ff6e0e6812fe97939
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/types/fp16.h
@@ -0,0 +1,234 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <vector>
+
+#define __MLX_HALF_NAN__ 0x7D00
+
+namespace mlx::core {
+
+namespace {
+union float_bits_fp16 {
+  float f;
+  uint32_t u;
+};
+} // namespace
+
+struct _MLX_Float16 {
+  uint16_t bits_;
+
+  // Default constructor
+  _MLX_Float16() = default;
+
+  // Default copy constructor
+  _MLX_Float16(_MLX_Float16 const&) = default;
+
+  // Appease std::vector<bool> for being special
+  _MLX_Float16& operator=(std::vector<bool>::reference x) {
+    bits_ = x;
+    return *this;
+  }
+
+  _MLX_Float16& operator=(const float& x) {
+    return (*this = _MLX_Float16(x));
+  }
+
+  // From float32
+  _MLX_Float16(const float& x) : bits_(0) {
+    // Conversion following
+    // https://github.com/Maratyszcza/FP16/blob/master/include/fp16/fp16.h
+
+    // Union
+    float_bits_fp16 in;
+
+    // Take fp32 bits
+    in.f = x;
+
+    // Find and take sign bit
+    uint32_t x_sign_32 = in.u & uint32_t(0x80000000);
+    uint16_t x_sign_16 = (x_sign_32 >> 16);
+
+    if (std::isnan(x)) {
+      bits_ = x_sign_16 | uint16_t(__MLX_HALF_NAN__);
+    } else {
+      // Union
+      float_bits_fp16 inf_scale, zero_scale, magic_bits;
+
+      // Find exponent bits and take the max supported by half
+      uint32_t x_expo_32 = in.u & uint32_t(0x7f800000);
+      uint32_t max_expo_32 = uint32_t(0x38800000);
+      x_expo_32 = x_expo_32 < max_expo_32 ? max_expo_32 : x_expo_32;
+      x_expo_32 += uint32_t(15) << 23;
+
+      // Handle scaling to inf as needed
+      inf_scale.u = uint32_t(0x77800000);
+      zero_scale.u = uint32_t(0x08800000);
+
+      // Combine with magic and let addition do rounding
+      magic_bits.u = x_expo_32;
+      magic_bits.f += (std::abs(x) * inf_scale.f) * zero_scale.f;
+
+      // Take the lower 5 bits of the exponent
+      uint32_t x_expo_16 = ((magic_bits.u >> 13) & uint32_t(0x7c00));
+
+      // Collect the lower 12 bits which have the mantissa
+      uint32_t x_mant_16 = magic_bits.u & uint32_t(0x0fff);
+
+      // Combine sign, exp and mantissa
+      bits_ = (x_sign_16 | uint16_t(x_expo_16 + x_mant_16));
+    }
+  }
+
+  // To float32
+  operator float() const {
+    // Conversion following
+    // https://github.com/Maratyszcza/FP16/blob/master/include/fp16/fp16.h
+
+    // Union
+    float_bits_fp16 out;
+
+    uint32_t x_sign_32 = (bits_ << 16) & uint32_t(0x80000000);
+    uint32_t base = (bits_ << 16);
+    uint32_t two_base = base + base;
+
+    uint32_t denorm_max = 1u << 27;
+    if (two_base < denorm_max) {
+      out.u = uint32_t(126) << 23; // magic mask
+      out.u |= (two_base >> 17); // Bits from fp16
+      out.f -= 0.5f; // magic bias
+    } else {
+      out.u = uint32_t(0xE0) << 23; // exponent offset
+      out.u += (two_base >> 4); // Bits from fp16
+      float out_unscaled = out.f; // Store value
+      out.u = uint32_t(0x7800000); // exponent scale
+      out.f *= out_unscaled;
+    }
+
+    // Add sign
+    out.u |= x_sign_32;
+
+    return out.f;
+  }
+};
+
+#define half_binop_base(__op__, __operator__, otype, atype, btype, ctype) \
+  inline otype __operator__(atype lhs, btype rhs) {                       \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);        \
+  }
+
+#define half_binop_helper(__op__, __operator__, otype, itype, ctype) \
+  inline otype __operator__(_MLX_Float16 lhs, itype rhs) {           \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);   \
+  }                                                                  \
+  inline otype __operator__(itype lhs, _MLX_Float16 rhs) {           \
+    return static_cast<ctype>(lhs) __op__ static_cast<ctype>(rhs);   \
+  }
+
+// Operators
+#define half_binop(__op__, __operator__)                                      \
+  half_binop_base(                                                            \
+      __op__, __operator__, _MLX_Float16, _MLX_Float16, _MLX_Float16, float); \
+  half_binop_helper(__op__, __operator__, float, float, float);               \
+  half_binop_helper(__op__, __operator__, double, double, double);            \
+  half_binop_helper(__op__, __operator__, _MLX_Float16, bool, float);         \
+  half_binop_helper(__op__, __operator__, _MLX_Float16, int32_t, float);      \
+  half_binop_helper(__op__, __operator__, _MLX_Float16, uint32_t, float);     \
+  half_binop_helper(__op__, __operator__, _MLX_Float16, int64_t, float);      \
+  half_binop_helper(__op__, __operator__, _MLX_Float16, uint64_t, float);
+
+half_binop(+, operator+);
+half_binop(-, operator-);
+half_binop(*, operator*);
+half_binop(/, operator/);
+
+#undef half_binop
+
+// Comparison ops
+#define half_compop(__op__, __operator__)                             \
+  half_binop_base(                                                    \
+      __op__, __operator__, bool, _MLX_Float16, _MLX_Float16, float); \
+  half_binop_helper(__op__, __operator__, bool, float, float);        \
+  half_binop_helper(__op__, __operator__, bool, double, double);      \
+  half_binop_helper(__op__, __operator__, bool, int32_t, float);      \
+  half_binop_helper(__op__, __operator__, bool, uint32_t, float);     \
+  half_binop_helper(__op__, __operator__, bool, int64_t, float);      \
+  half_binop_helper(__op__, __operator__, bool, uint64_t, float);
+
+half_compop(>, operator>);
+half_compop(<, operator<);
+half_compop(>=, operator>=);
+half_compop(<=, operator<=);
+half_compop(==, operator==);
+half_compop(!=, operator!=);
+
+#undef half_compop
+
+// Negative
+inline _MLX_Float16 operator-(_MLX_Float16 lhs) {
+  return -static_cast<float>(lhs);
+}
+
+// Inplace ops
+#define half_inplace_op(__op__, __operator__)                              \
+  inline _MLX_Float16& __operator__(_MLX_Float16& lhs, const float& rhs) { \
+    lhs = lhs __op__ rhs;                                                  \
+    return lhs;                                                            \
+  }                                                                        \
+  inline float& __operator__(float& lhs, _MLX_Float16 rhs) {               \
+    lhs = lhs __op__ rhs;                                                  \
+    return lhs;                                                            \
+  }
+
+half_inplace_op(+, operator+=);
+half_inplace_op(-, operator-=);
+half_inplace_op(*, operator*=);
+half_inplace_op(/, operator/=);
+
+#undef half_inplace_op
+
+// Bitwise ops
+
+#define half_bitop(__op__, __operator__)                                 \
+  inline _MLX_Float16 __operator__(_MLX_Float16 lhs, _MLX_Float16 rhs) { \
+    _MLX_Float16 out;                                                    \
+    out.bits_ = lhs.bits_ __op__ rhs.bits_;                              \
+    return out;                                                          \
+  }                                                                      \
+  inline _MLX_Float16 __operator__(_MLX_Float16 lhs, uint16_t rhs) {     \
+    _MLX_Float16 out;                                                    \
+    out.bits_ = lhs.bits_ __op__ rhs;                                    \
+    return out;                                                          \
+  }                                                                      \
+  inline _MLX_Float16 __operator__(uint16_t lhs, _MLX_Float16 rhs) {     \
+    _MLX_Float16 out;                                                    \
+    out.bits_ = lhs __op__ rhs.bits_;                                    \
+    return out;                                                          \
+  }
+
+half_bitop(|, operator|);
+half_bitop(&, operator&);
+half_bitop(^, operator^);
+
+#undef half_bitop
+
+#define half_inplace_bitop(__op__, __operator__)                           \
+  inline _MLX_Float16& __operator__(_MLX_Float16& lhs, _MLX_Float16 rhs) { \
+    lhs.bits_ = lhs.bits_ __op__ rhs.bits_;                                \
+    return lhs;                                                            \
+  }                                                                        \
+  inline _MLX_Float16& __operator__(_MLX_Float16& lhs, uint16_t rhs) {     \
+    lhs.bits_ = lhs.bits_ __op__ rhs;                                      \
+    return lhs;                                                            \
+  }
+
+half_inplace_bitop(|, operator|=);
+half_inplace_bitop(&, operator&=);
+half_inplace_bitop(^, operator^=);
+
+#undef half_inplace_bitop
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/types/half_types.h b/ml-stable-diffusion/mlx/mlx/types/half_types.h
new file mode 100644
index 0000000000000000000000000000000000000000..d9d6b9bf55127011d20a60c932ca3b667d008b7d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/types/half_types.h
@@ -0,0 +1,58 @@
+// Copyright © 2023 Apple Inc.
+
+#pragma once
+
+#ifdef __ARM_FEATURE_FP16_SCALAR_ARITHMETIC
+
+#include <arm_fp16.h>
+namespace mlx::core {
+using ::float16_t;
+} // namespace mlx::core
+
+#else
+
+#define ADD_HALF_BINOPS
+#include "mlx/types/fp16.h"
+namespace mlx::core {
+typedef struct _MLX_Float16 float16_t;
+} // namespace mlx::core
+
+#endif // __ARM_FEATURE_FP16_SCALAR_ARITHMETIC
+
+#ifdef __ARM_FEATURE_BF16
+
+#include <arm_bf16.h>
+namespace mlx::core {
+using ::bfloat16_t;
+} // namespace mlx::core
+
+#else
+
+#define ADD_HALF_BINOPS
+#include "mlx/types/bf16.h"
+namespace mlx::core {
+typedef struct _MLX_BFloat16 bfloat16_t;
+} // namespace mlx::core
+
+#endif // __ARM_FEATURE_BF16
+
+#ifdef ADD_HALF_BINOPS
+namespace mlx::core {
+
+// clang-format off
+#define fp16_bf16_binop_helper(__op__, __operator__)               \
+  inline float __operator__(float16_t lhs, bfloat16_t rhs) {       \
+    return static_cast<float>(lhs) __op__ static_cast<float>(rhs); \
+  }                                                                \
+  inline float __operator__(bfloat16_t lhs, float16_t rhs) {       \
+    return static_cast<float>(lhs) __op__ static_cast<float>(rhs); \
+  }
+
+fp16_bf16_binop_helper(+, operator+)
+fp16_bf16_binop_helper(-, operator-)
+fp16_bf16_binop_helper(*, operator*)
+fp16_bf16_binop_helper(/, operator/)
+// clang-format on
+
+} // namespace mlx::core
+#endif
diff --git a/ml-stable-diffusion/mlx/mlx/types/limits.h b/ml-stable-diffusion/mlx/mlx/types/limits.h
new file mode 100644
index 0000000000000000000000000000000000000000..5f2b1e9e0187fb6b8ea16fb020c177ef73afaf34
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/types/limits.h
@@ -0,0 +1,70 @@
+// Copyright © 2024 Apple Inc.
+#pragma once
+
+#include <limits>
+#include "mlx/types/half_types.h"
+
+namespace mlx::core {
+
+template <typename T>
+struct numeric_limits;
+
+template <>
+struct numeric_limits<float> : public std::numeric_limits<float> {};
+
+template <>
+struct numeric_limits<double> : public std::numeric_limits<double> {};
+
+template <>
+struct numeric_limits<float16_t> {
+ private:
+  union half_or_bits {
+    uint16_t bits;
+    float16_t value;
+  };
+  constexpr static float16_t bits_to_half(uint16_t v) {
+    return half_or_bits{v}.value;
+  }
+
+ public:
+  constexpr static float16_t lowest() {
+    return bits_to_half(0xFBFF);
+  }
+  static constexpr float16_t max() {
+    return bits_to_half(0x7BFF);
+  }
+  static constexpr float16_t epsilon() {
+    return bits_to_half(0x1400);
+  }
+  static constexpr float16_t infinity() {
+    return bits_to_half(0x7C00);
+  }
+};
+
+template <>
+struct numeric_limits<bfloat16_t> {
+ private:
+  union bfloat_or_bits {
+    uint16_t bits;
+    bfloat16_t value;
+  };
+  constexpr static bfloat16_t bits_to_bfloat(uint16_t v) {
+    return bfloat_or_bits{v}.value;
+  }
+
+ public:
+  constexpr static bfloat16_t lowest() {
+    return bits_to_bfloat(0xFF7F);
+  }
+  static constexpr bfloat16_t max() {
+    return bits_to_bfloat(0x7F7F);
+  }
+  static constexpr bfloat16_t epsilon() {
+    return bits_to_bfloat(0x3C00);
+  }
+  static constexpr bfloat16_t infinity() {
+    return bits_to_bfloat(0x7F80);
+  }
+};
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/utils.cpp b/ml-stable-diffusion/mlx/mlx/utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2a850d9f9972ed4d349bb68cccbc0ac5e4296038
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/utils.cpp
@@ -0,0 +1,313 @@
+// Copyright © 2023 Apple Inc.
+
+#include <cstdlib>
+#include <iostream>
+#include <sstream>
+#include <vector>
+
+#include "mlx/dtype_utils.h"
+#include "mlx/types/limits.h"
+#include "mlx/utils.h"
+
+namespace mlx::core {
+
+Stream to_stream(StreamOrDevice s) {
+  if (std::holds_alternative<std::monostate>(s)) {
+    return default_stream(default_device());
+  } else if (std::holds_alternative<Device>(s)) {
+    return default_stream(std::get<Device>(s));
+  } else {
+    return std::get<Stream>(s);
+  }
+}
+
+Stream to_stream(StreamOrDevice s, Device default_) {
+  if (std::holds_alternative<std::monostate>(s)) {
+    return default_stream(default_);
+  } else if (std::holds_alternative<Device>(s)) {
+    return default_stream(std::get<Device>(s));
+  } else {
+    return std::get<Stream>(s);
+  }
+}
+
+void PrintFormatter::print(std::ostream& os, bool val) {
+  if (capitalize_bool) {
+    os << (val ? "True" : "False");
+  } else {
+    os << val;
+  }
+}
+inline void PrintFormatter::print(std::ostream& os, int16_t val) {
+  os << val;
+}
+inline void PrintFormatter::print(std::ostream& os, uint16_t val) {
+  os << val;
+}
+inline void PrintFormatter::print(std::ostream& os, int32_t val) {
+  os << val;
+}
+inline void PrintFormatter::print(std::ostream& os, uint32_t val) {
+  os << val;
+}
+inline void PrintFormatter::print(std::ostream& os, int64_t val) {
+  os << val;
+}
+inline void PrintFormatter::print(std::ostream& os, uint64_t val) {
+  os << val;
+}
+inline void PrintFormatter::print(std::ostream& os, float16_t val) {
+  os << val;
+}
+inline void PrintFormatter::print(std::ostream& os, bfloat16_t val) {
+  os << val;
+}
+inline void PrintFormatter::print(std::ostream& os, float val) {
+  os << val;
+}
+inline void PrintFormatter::print(std::ostream& os, double val) {
+  os << val;
+}
+inline void PrintFormatter::print(std::ostream& os, complex64_t val) {
+  os << val.real();
+  if (val.imag() >= 0 || std::isnan(val.imag())) {
+    os << "+" << val.imag() << "j";
+  } else {
+    os << "-" << -val.imag() << "j";
+  }
+}
+
+PrintFormatter& get_global_formatter() {
+  static PrintFormatter formatter;
+  return formatter;
+}
+
+void abort_with_exception(const std::exception& error) {
+  std::ostringstream msg;
+  msg << "Terminating due to uncaught exception: " << error.what();
+  std::cerr << msg.str() << std::endl;
+  std::abort();
+}
+
+Dtype result_type(const std::vector<array>& arrays) {
+  Dtype t = bool_;
+  for (auto& arr : arrays) {
+    t = promote_types(t, arr.dtype());
+  }
+  return t;
+}
+
+Shape broadcast_shapes(const Shape& s1, const Shape& s2) {
+  // Use the same broadcasting rules as numpy
+  // https://numpy.org/doc/1.20/user/theory.broadcasting.html
+  // "The size of the trailing axes for both arrays in an operation must
+  // either be the same size or one of them must be one."
+  int ndim1 = s1.size();
+  int ndim2 = s2.size();
+  int ndim = std::max(ndim1, ndim2);
+  int diff = std::abs(ndim1 - ndim2);
+  const auto& big = ndim1 > ndim2 ? s1 : s2;
+  const auto& small = ndim1 > ndim2 ? s2 : s1;
+  Shape out_shape(ndim);
+  for (int i = ndim - 1; i >= diff; --i) {
+    auto a = big[i];
+    auto b = small[i - diff];
+    if (b == a) {
+      out_shape[i] = a;
+    } else if (a == 1 || b == 1) {
+      // 0 if a or b is 0 otherwise max(a, b)
+      out_shape[i] = a * b;
+    } else {
+      std::ostringstream msg;
+      msg << "[broadcast_shapes] Shapes " << s1 << " and " << s2
+          << " cannot be broadcast.";
+      throw std::invalid_argument(msg.str());
+    }
+  }
+  for (int i = diff - 1; i >= 0; --i) {
+    out_shape[i] = big[i];
+  }
+  return out_shape;
+}
+
+int normalize_axis_index(
+    int axis,
+    int ndim,
+    const std::string& msg_prefix /* = "" */) {
+  if (axis < -ndim || axis >= ndim) {
+    std::ostringstream msg;
+    msg << msg_prefix << "Axis " << axis << " is out of bounds for array with "
+        << ndim << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+  return axis < 0 ? axis + ndim : axis;
+}
+
+std::ostream& operator<<(std::ostream& os, const Device& d) {
+  os << "Device(";
+  switch (d.type) {
+    case Device::cpu:
+      os << "cpu";
+      break;
+    case Device::gpu:
+      os << "gpu";
+      break;
+  }
+  os << ", " << d.index << ")";
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, const Stream& s) {
+  os << "Stream(";
+  os << s.device;
+  os << ", " << s.index << ")";
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, int8_t x) {
+  os << static_cast<int>(x);
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, uint8_t x) {
+  os << static_cast<unsigned int>(x);
+  return os;
+}
+
+namespace {
+
+inline size_t
+elem_to_loc(int elem, const Shape& shape, const Strides& strides) {
+  size_t loc = 0;
+  for (int i = shape.size() - 1; i >= 0; --i) {
+    auto q_and_r = ldiv(elem, shape[i]);
+    loc += q_and_r.rem * strides[i];
+    elem = q_and_r.quot;
+  }
+  return loc;
+}
+
+template <typename T>
+void print_subarray(std::ostream& os, const array& a, size_t index, int dim) {
+  int num_print = 3;
+  int n = a.shape(dim);
+  size_t s = a.strides()[dim];
+  bool is_last = dim == a.ndim() - 1;
+  auto prefix = is_last ? "" : std::string(7 + dim, ' ');
+  auto postfix = is_last ? ", " : ",\n";
+  os << "[";
+  for (int i = 0; i < n; ++i) {
+    os << (i == 0 ? "" : prefix);
+    if (i == num_print && n > 2 * num_print) {
+      os << "...";
+      i = n - num_print - 1;
+      index += s * (n - 2 * num_print - 1);
+    } else if (is_last) {
+      get_global_formatter().print(os, a.data<T>()[index]);
+    } else {
+      print_subarray<T>(os, a, index, dim + 1);
+    }
+    os << (i == n - 1 ? "" : postfix);
+    index += s;
+  }
+  os << "]";
+}
+
+template <typename T>
+void print_array(std::ostream& os, const array& a) {
+  os << std::boolalpha;
+  os << "array(";
+  if (a.ndim() == 0) {
+    auto data = a.data<T>();
+    get_global_formatter().print(os, data[0]);
+  } else {
+    print_subarray<T>(os, a, 0, 0);
+  }
+  os << ", dtype=" << a.dtype() << ")";
+  os << std::noboolalpha;
+}
+
+} // namespace
+
+std::ostream& operator<<(std::ostream& os, const Dtype& dtype) {
+  return os << dtype_to_string(dtype);
+}
+
+std::ostream& operator<<(std::ostream& os, const Dtype::Kind& k) {
+  switch (k) {
+    case Dtype::Kind::b:
+      return os << "b";
+    case Dtype::Kind::i:
+      return os << "i";
+    case Dtype::Kind::u:
+      return os << "u";
+    case Dtype::Kind::f:
+      return os << "f";
+    case Dtype::Kind::c:
+      return os << "c";
+    case Dtype::Kind::V:
+      return os << "V";
+  }
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, array a) {
+  a.eval();
+  dispatch_all_types(a.dtype(), [&](auto type_tag) {
+    print_array<MLX_GET_TYPE(type_tag)>(os, a);
+  });
+  return os;
+}
+
+namespace env {
+
+int get_var(const char* name, int default_value) {
+  if (const char* buff_str = std::getenv(name)) {
+    return atoi(buff_str);
+  } else {
+    return default_value;
+  }
+}
+
+} // namespace env
+
+template <typename T>
+void set_finfo_limits(double& min, double& max, double& eps) {
+  min = numeric_limits<T>::lowest();
+  max = numeric_limits<T>::max();
+  eps = numeric_limits<T>::epsilon();
+}
+
+finfo::finfo(Dtype dtype) : dtype(dtype) {
+  if (!issubdtype(dtype, inexact)) {
+    std::ostringstream msg;
+    msg << "[finfo] dtype " << dtype << " is not inexact.";
+    throw std::invalid_argument(msg.str());
+  }
+  if (dtype == float32) {
+    set_finfo_limits<float>(min, max, eps);
+  } else if (dtype == float16) {
+    set_finfo_limits<float16_t>(min, max, eps);
+  } else if (dtype == bfloat16) {
+    set_finfo_limits<bfloat16_t>(min, max, eps);
+  } else if (dtype == float64) {
+    set_finfo_limits<double>(min, max, eps);
+  } else if (dtype == complex64) {
+    this->dtype = float32;
+    set_finfo_limits<float>(min, max, eps);
+  }
+}
+
+template <typename T>
+void set_iinfo_limits(int64_t& min, uint64_t& max) {
+  min = std::numeric_limits<T>::min();
+  max = std::numeric_limits<T>::max();
+}
+
+iinfo::iinfo(Dtype dtype) : dtype(dtype) {
+  dispatch_int_types(dtype, "[iinfo]", [&](auto type_tag) {
+    set_iinfo_limits<MLX_GET_TYPE(type_tag)>(min, max);
+  });
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/utils.h b/ml-stable-diffusion/mlx/mlx/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..076842f78a0cb0d6cf0fe61ea1ab4482502e899d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/utils.h
@@ -0,0 +1,170 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <exception>
+#include <variant>
+
+#include "mlx/array.h"
+#include "mlx/device.h"
+#include "mlx/dtype.h"
+#include "mlx/stream.h"
+
+namespace mlx::core {
+
+using StreamOrDevice = std::variant<std::monostate, Stream, Device>;
+Stream to_stream(StreamOrDevice s);
+Stream to_stream(StreamOrDevice s, Device default_);
+
+struct StreamContext {
+ public:
+  StreamContext(StreamOrDevice s) : _stream(default_stream(default_device())) {
+    if (std::holds_alternative<std::monostate>(s)) {
+      throw std::runtime_error(
+          "[StreamContext] Invalid argument, please specify a stream or device.");
+    }
+    auto _s = to_stream(s);
+    set_default_device(_s.device);
+    set_default_stream(_s);
+  }
+
+  ~StreamContext() {
+    set_default_device(_stream.device);
+    set_default_stream(_stream);
+  }
+
+ private:
+  Stream _stream;
+};
+
+struct PrintFormatter {
+  inline void print(std::ostream& os, bool val);
+  inline void print(std::ostream& os, int16_t val);
+  inline void print(std::ostream& os, uint16_t val);
+  inline void print(std::ostream& os, int32_t val);
+  inline void print(std::ostream& os, uint32_t val);
+  inline void print(std::ostream& os, int64_t val);
+  inline void print(std::ostream& os, uint64_t val);
+  inline void print(std::ostream& os, float16_t val);
+  inline void print(std::ostream& os, bfloat16_t val);
+  inline void print(std::ostream& os, float val);
+  inline void print(std::ostream& os, double val);
+  inline void print(std::ostream& os, complex64_t val);
+
+  bool capitalize_bool{false};
+};
+
+PrintFormatter& get_global_formatter();
+
+/** Print the exception and then abort. */
+void abort_with_exception(const std::exception& error);
+
+/** Holds information about floating-point types. */
+struct finfo {
+  explicit finfo(Dtype dtype);
+  Dtype dtype;
+  double min;
+  double max;
+  double eps;
+};
+
+/** Holds information about integral types. */
+struct iinfo {
+  explicit iinfo(Dtype dtype);
+  Dtype dtype;
+  int64_t min;
+  uint64_t max;
+};
+
+/** The type from promoting the arrays' types with one another. */
+inline Dtype result_type(const array& a, const array& b) {
+  return promote_types(a.dtype(), b.dtype());
+}
+inline Dtype result_type(const array& a, const array& b, const array& c) {
+  return promote_types(result_type(a, b), c.dtype());
+}
+Dtype result_type(const std::vector<array>& arrays);
+
+Shape broadcast_shapes(const Shape& s1, const Shape& s2);
+
+/**
+ * Returns the axis normalized to be in the range [0, ndim).
+ */
+int normalize_axis_index(
+    int axis,
+    int ndim,
+    const std::string& msg_prefix = "");
+
+std::ostream& operator<<(std::ostream& os, const Device& d);
+std::ostream& operator<<(std::ostream& os, const Stream& s);
+std::ostream& operator<<(std::ostream& os, const Dtype& d);
+std::ostream& operator<<(std::ostream& os, const Dtype::Kind& k);
+std::ostream& operator<<(std::ostream& os, array a);
+inline std::ostream& operator<<(std::ostream& os, const complex64_t& v) {
+  return os << v.real() << (v.imag() >= 0 ? "+" : "") << v.imag() << "j";
+}
+inline std::ostream& operator<<(std::ostream& os, const float16_t& v) {
+  return os << static_cast<float>(v);
+}
+inline std::ostream& operator<<(std::ostream& os, const bfloat16_t& v) {
+  return os << static_cast<float>(v);
+}
+
+template <typename Vec, typename = std::enable_if_t<is_vector_v<Vec>>>
+inline std::ostream& operator<<(std::ostream& os, const Vec& v) {
+  os << "(";
+  for (auto it = v.begin(); it != v.end(); ++it) {
+    os << *it;
+    if (it != std::prev(v.end())) {
+      os << ",";
+    }
+  }
+  os << ")";
+  return os;
+}
+
+inline bool is_power_of_2(int n) {
+  return ((n & (n - 1)) == 0) && n != 0;
+}
+
+inline int next_power_of_2(int n) {
+  if (is_power_of_2(n)) {
+    return n;
+  }
+  return pow(2, std::ceil(std::log2(n)));
+}
+
+namespace env {
+
+int get_var(const char* name, int default_value);
+
+inline int bfs_max_width() {
+  static int bfs_max_width_ = get_var("MLX_BFS_MAX_WIDTH", 20);
+  return bfs_max_width_;
+}
+
+inline int max_ops_per_buffer(int default_value) {
+  static int max_ops_per_buffer_ =
+      get_var("MLX_MAX_OPS_PER_BUFFER", default_value);
+  return max_ops_per_buffer_;
+}
+
+inline int max_mb_per_buffer(int default_value) {
+  static int max_mb_per_buffer_ =
+      get_var("MLX_MAX_MB_PER_BUFFER", default_value);
+  return max_mb_per_buffer_;
+}
+
+inline bool metal_fast_synch() {
+  static bool metal_fast_synch = get_var("MLX_METAL_FAST_SYNCH", 0);
+  return metal_fast_synch;
+}
+
+inline bool enable_tf32() {
+  static bool enable_tf32_ = get_var("MLX_ENABLE_TF32", 1);
+  return enable_tf32_;
+}
+
+} // namespace env
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/version.cpp b/ml-stable-diffusion/mlx/mlx/version.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b60168e0ea346a550344777b714439d1c0725fe8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/version.cpp
@@ -0,0 +1,9 @@
+// Copyright © 2025 Apple Inc.
+
+namespace mlx::core {
+
+const char* version() {
+  return MLX_VERSION;
+}
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/mlx/version.h b/ml-stable-diffusion/mlx/mlx/version.h
new file mode 100644
index 0000000000000000000000000000000000000000..86b6a1e3af5242af9342c5752dc0d0d3f72fd8f8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/mlx/version.h
@@ -0,0 +1,20 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#define MLX_VERSION_MAJOR 0
+#define MLX_VERSION_MINOR 29
+#define MLX_VERSION_PATCH 2
+#define MLX_VERSION_NUMERIC \
+  (100000 * MLX_VERSION_MAJOR + 1000 * MLX_VERSION_MINOR + MLX_VERSION_PATCH)
+
+namespace mlx::core {
+
+/* A string representation of the MLX version in the format
+ * "major.minor.patch".
+ *
+ * For dev builds, the version will include the suffix ".devYYYYMMDD+hash"
+ */
+const char* version();
+
+} // namespace mlx::core
diff --git a/ml-stable-diffusion/mlx/pyproject.toml b/ml-stable-diffusion/mlx/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4fc9675dfdcf9126c2a0f04ee8e12131e06948c3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/pyproject.toml
@@ -0,0 +1,7 @@
+[build-system]
+requires = [
+  "setuptools>=80",
+  "nanobind==2.4.0",
+  "cmake>=3.25,<4.1",
+]
+build-backend = "setuptools.build_meta"
diff --git a/ml-stable-diffusion/mlx/python/mlx.egg-info/PKG-INFO b/ml-stable-diffusion/mlx/python/mlx.egg-info/PKG-INFO
new file mode 100644
index 0000000000000000000000000000000000000000..1d4224d1d815cc359ad9fc2fd0299a5696ba0323
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx.egg-info/PKG-INFO
@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: mlx
+Version: 0.29.2.dev20251007+0073096d
+Summary: A framework for machine learning on Apple silicon.
+Home-page: https://github.com/ml-explore/mlx
+Author: MLX Contributors
+Author-email: mlx@group.apple.com
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: nanobind==2.4.0; extra == "dev"
+Requires-Dist: numpy; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: setuptools>=80; extra == "dev"
+Requires-Dist: torch; extra == "dev"
+Requires-Dist: typing_extensions; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
+
+# MLX
+
+[**Quickstart**](#quickstart) | [**Installation**](#installation) |
+[**Documentation**](https://ml-explore.github.io/mlx/build/html/index.html) |
+[**Examples**](#examples) 
+
+[![CircleCI](https://circleci.com/gh/ml-explore/mlx.svg?style=svg)](https://circleci.com/gh/ml-explore/mlx)
+
+MLX is an array framework for machine learning on Apple silicon,
+brought to you by Apple machine learning research.
+
+Some key features of MLX include:
+
+ - **Familiar APIs**: MLX has a Python API that closely follows NumPy. MLX
+   also has fully featured C++, [C](https://github.com/ml-explore/mlx-c), and
+   [Swift](https://github.com/ml-explore/mlx-swift/) APIs, which closely mirror
+   the Python API. MLX has higher-level packages like `mlx.nn` and
+   `mlx.optimizers` with APIs that closely follow PyTorch to simplify building
+   more complex models.
+
+ - **Composable function transformations**: MLX supports composable function
+   transformations for automatic differentiation, automatic vectorization,
+   and computation graph optimization.
+
+ - **Lazy computation**: Computations in MLX are lazy. Arrays are only
+   materialized when needed.
+
+ - **Dynamic graph construction**: Computation graphs in MLX are constructed
+   dynamically. Changing the shapes of function arguments does not trigger
+   slow compilations, and debugging is simple and intuitive.
+
+ - **Multi-device**: Operations can run on any of the supported devices
+   (currently the CPU and the GPU).
+
+ - **Unified memory**: A notable difference from MLX and other frameworks
+   is the *unified memory model*. Arrays in MLX live in shared memory.
+   Operations on MLX arrays can be performed on any of the supported
+   device types without transferring data.
+
+MLX is designed by machine learning researchers for machine learning
+researchers. The framework is intended to be user-friendly, but still efficient
+to train and deploy models. The design of the framework itself is also
+conceptually simple. We intend to make it easy for researchers to extend and
+improve MLX with the goal of quickly exploring new ideas. 
+
+The design of MLX is inspired by frameworks like
+[NumPy](https://numpy.org/doc/stable/index.html),
+[PyTorch](https://pytorch.org/), [Jax](https://github.com/google/jax), and
+[ArrayFire](https://arrayfire.org/).
+
+## Examples
+
+The [MLX examples repo](https://github.com/ml-explore/mlx-examples) has a
+variety of examples, including:
+
+- [Transformer language model](https://github.com/ml-explore/mlx-examples/tree/main/transformer_lm) training.
+- Large-scale text generation with
+  [LLaMA](https://github.com/ml-explore/mlx-examples/tree/main/llms/llama) and
+  finetuning with [LoRA](https://github.com/ml-explore/mlx-examples/tree/main/lora).
+- Generating images with [Stable Diffusion](https://github.com/ml-explore/mlx-examples/tree/main/stable_diffusion).
+- Speech recognition with [OpenAI's Whisper](https://github.com/ml-explore/mlx-examples/tree/main/whisper).
+
+## Quickstart
+
+See the [quick start
+guide](https://ml-explore.github.io/mlx/build/html/usage/quick_start.html)
+in the documentation.
+
+## Installation
+
+MLX is available on [PyPI](https://pypi.org/project/mlx/). To install MLX on
+macOS, run:
+
+```bash
+pip install mlx
+```
+
+To install the CUDA backend on Linux, run:
+
+```bash
+pip install mlx[cuda]
+```
+
+To install a CPU-only Linux package, run:
+
+```bash
+pip install mlx[cpu]
+```
+
+Checkout the
+[documentation](https://ml-explore.github.io/mlx/build/html/install.html#)
+for more information on building the C++ and Python APIs from source.
+
+## Contributing 
+
+Check out the [contribution guidelines](https://github.com/ml-explore/mlx/tree/main/CONTRIBUTING.md) for more information
+on contributing to MLX. See the
+[docs](https://ml-explore.github.io/mlx/build/html/install.html) for more
+information on building from source, and running tests.
+
+We are grateful for all of [our
+contributors](https://github.com/ml-explore/mlx/tree/main/ACKNOWLEDGMENTS.md#Individual-Contributors). If you contribute
+to MLX and wish to be acknowledged, please add your name to the list in your
+pull request.
+
+## Citing MLX
+
+The MLX software suite was initially developed with equal contribution by Awni
+Hannun, Jagrit Digani, Angelos Katharopoulos, and Ronan Collobert. If you find
+MLX useful in your research and wish to cite it, please use the following
+BibTex entry:
+
+```
+@software{mlx2023,
+  author = {Awni Hannun and Jagrit Digani and Angelos Katharopoulos and Ronan Collobert},
+  title = {{MLX}: Efficient and flexible machine learning on Apple silicon},
+  url = {https://github.com/ml-explore},
+  version = {0.0},
+  year = {2023},
+}
+```
diff --git a/ml-stable-diffusion/mlx/python/mlx.egg-info/SOURCES.txt b/ml-stable-diffusion/mlx/python/mlx.egg-info/SOURCES.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cff87f797155ee47e43ca0e1755ca1fba1898c47
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx.egg-info/SOURCES.txt
@@ -0,0 +1,576 @@
+CMakeLists.txt
+LICENSE
+MANIFEST.in
+README.md
+mlx.pc.in
+pyproject.toml
+setup.py
+cmake/FindNCCL.cmake
+cmake/extension.cmake
+mlx/CMakeLists.txt
+mlx/allocator.cpp
+mlx/allocator.h
+mlx/array.cpp
+mlx/array.h
+mlx/compile.cpp
+mlx/compile.h
+mlx/compile_impl.h
+mlx/device.cpp
+mlx/device.h
+mlx/dtype.cpp
+mlx/dtype.h
+mlx/dtype_utils.cpp
+mlx/dtype_utils.h
+mlx/einsum.cpp
+mlx/einsum.h
+mlx/event.h
+mlx/export.cpp
+mlx/export.h
+mlx/export_impl.h
+mlx/fast.cpp
+mlx/fast.h
+mlx/fast_primitives.h
+mlx/fence.h
+mlx/fft.cpp
+mlx/fft.h
+mlx/graph_utils.cpp
+mlx/graph_utils.h
+mlx/io.h
+mlx/linalg.cpp
+mlx/linalg.h
+mlx/memory.h
+mlx/mlx.h
+mlx/ops.cpp
+mlx/ops.h
+mlx/primitives.cpp
+mlx/primitives.h
+mlx/random.cpp
+mlx/random.h
+mlx/scheduler.cpp
+mlx/scheduler.h
+mlx/small_vector.h
+mlx/stream.h
+mlx/threadpool.h
+mlx/transforms.cpp
+mlx/transforms.h
+mlx/transforms_impl.h
+mlx/utils.cpp
+mlx/utils.h
+mlx/version.cpp
+mlx/version.h
+mlx/3rdparty/.clang-format
+mlx/3rdparty/pocketfft.h
+mlx/backend/common/CMakeLists.txt
+mlx/backend/common/binary.h
+mlx/backend/common/broadcasting.cpp
+mlx/backend/common/broadcasting.h
+mlx/backend/common/buffer_cache.h
+mlx/backend/common/common.cpp
+mlx/backend/common/compiled.cpp
+mlx/backend/common/compiled.h
+mlx/backend/common/copy.h
+mlx/backend/common/hadamard.h
+mlx/backend/common/load.cpp
+mlx/backend/common/matmul.h
+mlx/backend/common/reduce.cpp
+mlx/backend/common/reduce.h
+mlx/backend/common/slicing.cpp
+mlx/backend/common/slicing.h
+mlx/backend/common/ternary.h
+mlx/backend/common/unary.h
+mlx/backend/common/utils.cpp
+mlx/backend/common/utils.h
+mlx/backend/cpu/CMakeLists.txt
+mlx/backend/cpu/arange.h
+mlx/backend/cpu/arg_reduce.cpp
+mlx/backend/cpu/available.cpp
+mlx/backend/cpu/available.h
+mlx/backend/cpu/binary.cpp
+mlx/backend/cpu/binary.h
+mlx/backend/cpu/binary_ops.h
+mlx/backend/cpu/binary_two.h
+mlx/backend/cpu/cholesky.cpp
+mlx/backend/cpu/compiled.cpp
+mlx/backend/cpu/compiled_preamble.h
+mlx/backend/cpu/conv.cpp
+mlx/backend/cpu/copy.cpp
+mlx/backend/cpu/copy.h
+mlx/backend/cpu/distributed.cpp
+mlx/backend/cpu/eig.cpp
+mlx/backend/cpu/eigh.cpp
+mlx/backend/cpu/encoder.cpp
+mlx/backend/cpu/encoder.h
+mlx/backend/cpu/eval.cpp
+mlx/backend/cpu/eval.h
+mlx/backend/cpu/fft.cpp
+mlx/backend/cpu/gemm.h
+mlx/backend/cpu/hadamard.cpp
+mlx/backend/cpu/indexing.cpp
+mlx/backend/cpu/inverse.cpp
+mlx/backend/cpu/jit_compiler.cpp
+mlx/backend/cpu/jit_compiler.h
+mlx/backend/cpu/lapack.h
+mlx/backend/cpu/logsumexp.cpp
+mlx/backend/cpu/luf.cpp
+mlx/backend/cpu/make_compiled_preamble.ps1
+mlx/backend/cpu/make_compiled_preamble.sh
+mlx/backend/cpu/masked_mm.cpp
+mlx/backend/cpu/matmul.cpp
+mlx/backend/cpu/primitives.cpp
+mlx/backend/cpu/qrf.cpp
+mlx/backend/cpu/quantized.cpp
+mlx/backend/cpu/reduce.cpp
+mlx/backend/cpu/scan.cpp
+mlx/backend/cpu/select.cpp
+mlx/backend/cpu/slicing.h
+mlx/backend/cpu/softmax.cpp
+mlx/backend/cpu/sort.cpp
+mlx/backend/cpu/svd.cpp
+mlx/backend/cpu/ternary.h
+mlx/backend/cpu/threefry.cpp
+mlx/backend/cpu/threefry.h
+mlx/backend/cpu/unary.cpp
+mlx/backend/cpu/unary.h
+mlx/backend/cpu/unary_ops.h
+mlx/backend/cpu/gemms/bnns.cpp
+mlx/backend/cpu/gemms/cblas.cpp
+mlx/backend/cpu/gemms/simd_bf16.cpp
+mlx/backend/cpu/gemms/simd_fp16.cpp
+mlx/backend/cpu/gemms/simd_gemm.h
+mlx/backend/cpu/simd/accelerate_fp16_simd.h
+mlx/backend/cpu/simd/accelerate_simd.h
+mlx/backend/cpu/simd/base_simd.h
+mlx/backend/cpu/simd/math.h
+mlx/backend/cpu/simd/neon_fp16_simd.h
+mlx/backend/cpu/simd/simd.h
+mlx/backend/cpu/simd/type.h
+mlx/backend/cuda/CMakeLists.txt
+mlx/backend/cuda/allocator.cpp
+mlx/backend/cuda/allocator.h
+mlx/backend/cuda/arange.cu
+mlx/backend/cuda/arg_reduce.cu
+mlx/backend/cuda/bin2h.cmake
+mlx/backend/cuda/binary_two.cu
+mlx/backend/cuda/compiled.cpp
+mlx/backend/cuda/conv.cpp
+mlx/backend/cuda/copy.cu
+mlx/backend/cuda/cuda.cpp
+mlx/backend/cuda/cuda.h
+mlx/backend/cuda/cudnn_utils.cpp
+mlx/backend/cuda/cudnn_utils.h
+mlx/backend/cuda/custom_kernel.cpp
+mlx/backend/cuda/device.cpp
+mlx/backend/cuda/device.h
+mlx/backend/cuda/distributed.cu
+mlx/backend/cuda/eval.cpp
+mlx/backend/cuda/event.cu
+mlx/backend/cuda/event.h
+mlx/backend/cuda/fence.cpp
+mlx/backend/cuda/indexing.cpp
+mlx/backend/cuda/jit_module.cpp
+mlx/backend/cuda/jit_module.h
+mlx/backend/cuda/kernel_utils.cu
+mlx/backend/cuda/kernel_utils.cuh
+mlx/backend/cuda/layer_norm.cu
+mlx/backend/cuda/logsumexp.cu
+mlx/backend/cuda/lru_cache.h
+mlx/backend/cuda/matmul.cpp
+mlx/backend/cuda/no_cuda.cpp
+mlx/backend/cuda/primitives.cpp
+mlx/backend/cuda/random.cu
+mlx/backend/cuda/reduce.cu
+mlx/backend/cuda/rms_norm.cu
+mlx/backend/cuda/rope.cu
+mlx/backend/cuda/scaled_dot_product_attention.cu
+mlx/backend/cuda/scan.cu
+mlx/backend/cuda/slicing.cpp
+mlx/backend/cuda/softmax.cu
+mlx/backend/cuda/sort.cu
+mlx/backend/cuda/ternary.cu
+mlx/backend/cuda/unary.cu
+mlx/backend/cuda/utils.cpp
+mlx/backend/cuda/utils.h
+mlx/backend/cuda/worker.cpp
+mlx/backend/cuda/worker.h
+mlx/backend/cuda/binary/CMakeLists.txt
+mlx/backend/cuda/binary/add.cu
+mlx/backend/cuda/binary/arctan2.cu
+mlx/backend/cuda/binary/binary.cuh
+mlx/backend/cuda/binary/bitwise_binary.cu
+mlx/backend/cuda/binary/divide.cu
+mlx/backend/cuda/binary/equal.cu
+mlx/backend/cuda/binary/greater.cu
+mlx/backend/cuda/binary/greater_equal.cu
+mlx/backend/cuda/binary/less.cu
+mlx/backend/cuda/binary/less_equal.cu
+mlx/backend/cuda/binary/log_add_exp.cu
+mlx/backend/cuda/binary/logical_and.cu
+mlx/backend/cuda/binary/logical_or.cu
+mlx/backend/cuda/binary/maximum.cu
+mlx/backend/cuda/binary/minimum.cu
+mlx/backend/cuda/binary/multiply.cu
+mlx/backend/cuda/binary/not_equal.cu
+mlx/backend/cuda/binary/power.cu
+mlx/backend/cuda/binary/remainder.cu
+mlx/backend/cuda/binary/subtract.cu
+mlx/backend/cuda/conv/conv.h
+mlx/backend/cuda/conv/gemm_conv.cu
+mlx/backend/cuda/conv/gemm_grouped_conv.cu
+mlx/backend/cuda/copy/copy.cuh
+mlx/backend/cuda/copy/copy_contiguous.cu
+mlx/backend/cuda/copy/copy_general.cu
+mlx/backend/cuda/copy/copy_general_dynamic.cu
+mlx/backend/cuda/copy/copy_general_input.cu
+mlx/backend/cuda/device/atomic_ops.cuh
+mlx/backend/cuda/device/binary_ops.cuh
+mlx/backend/cuda/device/cast_op.cuh
+mlx/backend/cuda/device/complex.cuh
+mlx/backend/cuda/device/config.h
+mlx/backend/cuda/device/fp16_math.cuh
+mlx/backend/cuda/device/gather.cuh
+mlx/backend/cuda/device/gather_axis.cuh
+mlx/backend/cuda/device/indexing.cuh
+mlx/backend/cuda/device/scatter.cuh
+mlx/backend/cuda/device/scatter_axis.cuh
+mlx/backend/cuda/device/scatter_ops.cuh
+mlx/backend/cuda/device/ternary_ops.cuh
+mlx/backend/cuda/device/unary_ops.cuh
+mlx/backend/cuda/device/utils.cuh
+mlx/backend/cuda/gemms/cublas_gemm.cpp
+mlx/backend/cuda/gemms/cublas_gemm.h
+mlx/backend/cuda/gemms/cublas_gemm_batched_12_0.cpp
+mlx/backend/cuda/gemms/cublas_gemm_batched_12_9.cu
+mlx/backend/cuda/gemms/gemv.cu
+mlx/backend/cuda/gemms/gemv.h
+mlx/backend/cuda/quantized/affine_quantize.cu
+mlx/backend/cuda/quantized/quantized.cpp
+mlx/backend/cuda/quantized/quantized.h
+mlx/backend/cuda/quantized/quantized_utils.cuh
+mlx/backend/cuda/reduce/all_reduce.cu
+mlx/backend/cuda/reduce/col_reduce.cu
+mlx/backend/cuda/reduce/init_reduce.cu
+mlx/backend/cuda/reduce/reduce.cuh
+mlx/backend/cuda/reduce/reduce_ops.cuh
+mlx/backend/cuda/reduce/reduce_utils.cuh
+mlx/backend/cuda/reduce/row_reduce.cu
+mlx/backend/cuda/steel/defines.cuh
+mlx/backend/cuda/steel/gemm.cuh
+mlx/backend/cuda/steel/mma.cuh
+mlx/backend/cuda/steel/tiles.cuh
+mlx/backend/cuda/steel/utils.cuh
+mlx/backend/cuda/unary/CMakeLists.txt
+mlx/backend/cuda/unary/abs.cu
+mlx/backend/cuda/unary/arccos.cu
+mlx/backend/cuda/unary/arccosh.cu
+mlx/backend/cuda/unary/arcsin.cu
+mlx/backend/cuda/unary/arcsinh.cu
+mlx/backend/cuda/unary/arctan.cu
+mlx/backend/cuda/unary/arctanh.cu
+mlx/backend/cuda/unary/bitwise_invert.cu
+mlx/backend/cuda/unary/ceil.cu
+mlx/backend/cuda/unary/conjugate.cu
+mlx/backend/cuda/unary/cos.cu
+mlx/backend/cuda/unary/cosh.cu
+mlx/backend/cuda/unary/erf.cu
+mlx/backend/cuda/unary/erf_inv.cu
+mlx/backend/cuda/unary/exp.cu
+mlx/backend/cuda/unary/expm1.cu
+mlx/backend/cuda/unary/floor.cu
+mlx/backend/cuda/unary/imag.cu
+mlx/backend/cuda/unary/log.cu
+mlx/backend/cuda/unary/log1p.cu
+mlx/backend/cuda/unary/logical_not.cu
+mlx/backend/cuda/unary/negative.cu
+mlx/backend/cuda/unary/real.cu
+mlx/backend/cuda/unary/round.cu
+mlx/backend/cuda/unary/sigmoid.cu
+mlx/backend/cuda/unary/sign.cu
+mlx/backend/cuda/unary/sin.cu
+mlx/backend/cuda/unary/sinh.cu
+mlx/backend/cuda/unary/sqrt.cu
+mlx/backend/cuda/unary/square.cu
+mlx/backend/cuda/unary/tan.cu
+mlx/backend/cuda/unary/tanh.cu
+mlx/backend/cuda/unary/unary.cuh
+mlx/backend/gpu/CMakeLists.txt
+mlx/backend/gpu/available.h
+mlx/backend/gpu/copy.cpp
+mlx/backend/gpu/copy.h
+mlx/backend/gpu/eval.h
+mlx/backend/gpu/primitives.cpp
+mlx/backend/gpu/slicing.cpp
+mlx/backend/gpu/slicing.h
+mlx/backend/metal/CMakeLists.txt
+mlx/backend/metal/allocator.cpp
+mlx/backend/metal/allocator.h
+mlx/backend/metal/binary.cpp
+mlx/backend/metal/binary.h
+mlx/backend/metal/compiled.cpp
+mlx/backend/metal/conv.cpp
+mlx/backend/metal/copy.cpp
+mlx/backend/metal/custom_kernel.cpp
+mlx/backend/metal/device.cpp
+mlx/backend/metal/device.h
+mlx/backend/metal/distributed.cpp
+mlx/backend/metal/eval.cpp
+mlx/backend/metal/event.cpp
+mlx/backend/metal/fence.cpp
+mlx/backend/metal/fft.cpp
+mlx/backend/metal/hadamard.cpp
+mlx/backend/metal/indexing.cpp
+mlx/backend/metal/jit_kernels.cpp
+mlx/backend/metal/kernels.h
+mlx/backend/metal/logsumexp.cpp
+mlx/backend/metal/make_compiled_preamble.sh
+mlx/backend/metal/matmul.cpp
+mlx/backend/metal/matmul.h
+mlx/backend/metal/metal.cpp
+mlx/backend/metal/metal.h
+mlx/backend/metal/no_metal.cpp
+mlx/backend/metal/nojit_kernels.cpp
+mlx/backend/metal/normalization.cpp
+mlx/backend/metal/primitives.cpp
+mlx/backend/metal/quantized.cpp
+mlx/backend/metal/reduce.cpp
+mlx/backend/metal/reduce.h
+mlx/backend/metal/resident.cpp
+mlx/backend/metal/resident.h
+mlx/backend/metal/rope.cpp
+mlx/backend/metal/scaled_dot_product_attention.cpp
+mlx/backend/metal/scan.cpp
+mlx/backend/metal/slicing.cpp
+mlx/backend/metal/softmax.cpp
+mlx/backend/metal/sort.cpp
+mlx/backend/metal/ternary.cpp
+mlx/backend/metal/ternary.h
+mlx/backend/metal/unary.cpp
+mlx/backend/metal/unary.h
+mlx/backend/metal/utils.cpp
+mlx/backend/metal/utils.h
+mlx/backend/metal/jit/includes.h
+mlx/backend/metal/jit/indexing.h
+mlx/backend/metal/kernels/CMakeLists.txt
+mlx/backend/metal/kernels/arange.h
+mlx/backend/metal/kernels/arange.metal
+mlx/backend/metal/kernels/arg_reduce.metal
+mlx/backend/metal/kernels/atomic.h
+mlx/backend/metal/kernels/bf16_math.h
+mlx/backend/metal/kernels/binary.h
+mlx/backend/metal/kernels/binary.metal
+mlx/backend/metal/kernels/binary_ops.h
+mlx/backend/metal/kernels/binary_two.h
+mlx/backend/metal/kernels/binary_two.metal
+mlx/backend/metal/kernels/cexpf.h
+mlx/backend/metal/kernels/complex.h
+mlx/backend/metal/kernels/conv.metal
+mlx/backend/metal/kernels/copy.h
+mlx/backend/metal/kernels/copy.metal
+mlx/backend/metal/kernels/defines.h
+mlx/backend/metal/kernels/erf.h
+mlx/backend/metal/kernels/expm1f.h
+mlx/backend/metal/kernels/fence.metal
+mlx/backend/metal/kernels/fft.h
+mlx/backend/metal/kernels/fft.metal
+mlx/backend/metal/kernels/fp4_quantized.h
+mlx/backend/metal/kernels/fp4_quantized.metal
+mlx/backend/metal/kernels/gemv.metal
+mlx/backend/metal/kernels/gemv_masked.h
+mlx/backend/metal/kernels/gemv_masked.metal
+mlx/backend/metal/kernels/hadamard.h
+mlx/backend/metal/kernels/layer_norm.metal
+mlx/backend/metal/kernels/logsumexp.h
+mlx/backend/metal/kernels/logsumexp.metal
+mlx/backend/metal/kernels/quantized.h
+mlx/backend/metal/kernels/quantized.metal
+mlx/backend/metal/kernels/quantized_utils.h
+mlx/backend/metal/kernels/random.metal
+mlx/backend/metal/kernels/reduce.h
+mlx/backend/metal/kernels/reduce.metal
+mlx/backend/metal/kernels/reduce_utils.h
+mlx/backend/metal/kernels/rms_norm.metal
+mlx/backend/metal/kernels/rope.metal
+mlx/backend/metal/kernels/scaled_dot_product_attention.metal
+mlx/backend/metal/kernels/scan.h
+mlx/backend/metal/kernels/scan.metal
+mlx/backend/metal/kernels/sdpa_vector.h
+mlx/backend/metal/kernels/softmax.h
+mlx/backend/metal/kernels/softmax.metal
+mlx/backend/metal/kernels/sort.h
+mlx/backend/metal/kernels/sort.metal
+mlx/backend/metal/kernels/ternary.h
+mlx/backend/metal/kernels/ternary.metal
+mlx/backend/metal/kernels/ternary_ops.h
+mlx/backend/metal/kernels/unary.h
+mlx/backend/metal/kernels/unary.metal
+mlx/backend/metal/kernels/unary_ops.h
+mlx/backend/metal/kernels/utils.h
+mlx/backend/metal/kernels/fft/radix.h
+mlx/backend/metal/kernels/fft/readwrite.h
+mlx/backend/metal/kernels/indexing/gather.h
+mlx/backend/metal/kernels/indexing/gather_axis.h
+mlx/backend/metal/kernels/indexing/gather_front.h
+mlx/backend/metal/kernels/indexing/indexing.h
+mlx/backend/metal/kernels/indexing/scatter.h
+mlx/backend/metal/kernels/indexing/scatter_axis.h
+mlx/backend/metal/kernels/jit/bf16.h
+mlx/backend/metal/kernels/metal_3_0/bf16.h
+mlx/backend/metal/kernels/metal_3_1/bf16.h
+mlx/backend/metal/kernels/reduction/ops.h
+mlx/backend/metal/kernels/reduction/reduce_all.h
+mlx/backend/metal/kernels/reduction/reduce_col.h
+mlx/backend/metal/kernels/reduction/reduce_init.h
+mlx/backend/metal/kernels/reduction/reduce_row.h
+mlx/backend/metal/kernels/steel/defines.h
+mlx/backend/metal/kernels/steel/utils.h
+mlx/backend/metal/kernels/steel/attn/attn.h
+mlx/backend/metal/kernels/steel/attn/loader.h
+mlx/backend/metal/kernels/steel/attn/mma.h
+mlx/backend/metal/kernels/steel/attn/params.h
+mlx/backend/metal/kernels/steel/attn/transforms.h
+mlx/backend/metal/kernels/steel/attn/kernels/steel_attention.h
+mlx/backend/metal/kernels/steel/attn/kernels/steel_attention.metal
+mlx/backend/metal/kernels/steel/conv/conv.h
+mlx/backend/metal/kernels/steel/conv/loader.h
+mlx/backend/metal/kernels/steel/conv/params.h
+mlx/backend/metal/kernels/steel/conv/kernels/steel_conv.h
+mlx/backend/metal/kernels/steel/conv/kernels/steel_conv.metal
+mlx/backend/metal/kernels/steel/conv/kernels/steel_conv_general.h
+mlx/backend/metal/kernels/steel/conv/kernels/steel_conv_general.metal
+mlx/backend/metal/kernels/steel/conv/loaders/loader_channel_l.h
+mlx/backend/metal/kernels/steel/conv/loaders/loader_channel_n.h
+mlx/backend/metal/kernels/steel/conv/loaders/loader_general.h
+mlx/backend/metal/kernels/steel/gemm/gemm.h
+mlx/backend/metal/kernels/steel/gemm/loader.h
+mlx/backend/metal/kernels/steel/gemm/mma.h
+mlx/backend/metal/kernels/steel/gemm/params.h
+mlx/backend/metal/kernels/steel/gemm/transforms.h
+mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_fused.h
+mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_fused.metal
+mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_gather.h
+mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_gather.metal
+mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_masked.h
+mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_masked.metal
+mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_segmented.h
+mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_segmented.metal
+mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_splitk.h
+mlx/backend/metal/kernels/steel/gemm/kernels/steel_gemm_splitk.metal
+mlx/backend/metal/kernels/steel/utils/integral_constant.h
+mlx/backend/metal/kernels/steel/utils/type_traits.h
+mlx/backend/no_cpu/CMakeLists.txt
+mlx/backend/no_cpu/available.cpp
+mlx/backend/no_cpu/compiled.cpp
+mlx/backend/no_cpu/primitives.cpp
+mlx/backend/no_gpu/CMakeLists.txt
+mlx/backend/no_gpu/allocator.cpp
+mlx/backend/no_gpu/apple_memory.h
+mlx/backend/no_gpu/eval.cpp
+mlx/backend/no_gpu/event.cpp
+mlx/backend/no_gpu/fence.cpp
+mlx/backend/no_gpu/linux_memory.h
+mlx/backend/no_gpu/primitives.cpp
+mlx/distributed/CMakeLists.txt
+mlx/distributed/distributed.cpp
+mlx/distributed/distributed.h
+mlx/distributed/distributed_impl.h
+mlx/distributed/ops.cpp
+mlx/distributed/ops.h
+mlx/distributed/primitives.cpp
+mlx/distributed/primitives.h
+mlx/distributed/mpi/CMakeLists.txt
+mlx/distributed/mpi/mpi.cpp
+mlx/distributed/mpi/mpi.h
+mlx/distributed/mpi/mpi_declarations.h
+mlx/distributed/mpi/no_mpi.cpp
+mlx/distributed/nccl/CMakeLists.txt
+mlx/distributed/nccl/nccl.cpp
+mlx/distributed/nccl/nccl.h
+mlx/distributed/nccl/no_nccl.cpp
+mlx/distributed/nccl/nccl_stub/CMakeLists.txt
+mlx/distributed/nccl/nccl_stub/nccl_stubs.cpp
+mlx/distributed/ring/CMakeLists.txt
+mlx/distributed/ring/no_ring.cpp
+mlx/distributed/ring/ring.cpp
+mlx/distributed/ring/ring.h
+mlx/io/CMakeLists.txt
+mlx/io/gguf.cpp
+mlx/io/gguf.h
+mlx/io/gguf_quants.cpp
+mlx/io/load.cpp
+mlx/io/load.h
+mlx/io/no_gguf.cpp
+mlx/io/no_safetensors.cpp
+mlx/io/safetensors.cpp
+mlx/types/bf16.h
+mlx/types/complex.h
+mlx/types/fp16.h
+mlx/types/half_types.h
+mlx/types/limits.h
+python/mlx/__main__.py
+python/mlx/_os_warning.py
+python/mlx/_reprlib_fix.py
+python/mlx/distributed_run.py
+python/mlx/extension.py
+python/mlx/py.typed
+python/mlx/utils.py
+python/mlx.egg-info/PKG-INFO
+python/mlx.egg-info/SOURCES.txt
+python/mlx.egg-info/dependency_links.txt
+python/mlx.egg-info/entry_points.txt
+python/mlx.egg-info/not-zip-safe
+python/mlx.egg-info/requires.txt
+python/mlx.egg-info/top_level.txt
+python/mlx/nn/__init__.py
+python/mlx/nn/init.py
+python/mlx/nn/losses.py
+python/mlx/nn/utils.py
+python/mlx/nn/layers/__init__.py
+python/mlx/nn/layers/activations.py
+python/mlx/nn/layers/base.py
+python/mlx/nn/layers/containers.py
+python/mlx/nn/layers/convolution.py
+python/mlx/nn/layers/convolution_transpose.py
+python/mlx/nn/layers/distributed.py
+python/mlx/nn/layers/dropout.py
+python/mlx/nn/layers/embedding.py
+python/mlx/nn/layers/linear.py
+python/mlx/nn/layers/normalization.py
+python/mlx/nn/layers/pooling.py
+python/mlx/nn/layers/positional_encoding.py
+python/mlx/nn/layers/quantized.py
+python/mlx/nn/layers/recurrent.py
+python/mlx/nn/layers/transformer.py
+python/mlx/nn/layers/upsample.py
+python/mlx/optimizers/__init__.py
+python/mlx/optimizers/optimizers.py
+python/mlx/optimizers/schedulers.py
+python/src/CMakeLists.txt
+python/src/array.cpp
+python/src/buffer.h
+python/src/constants.cpp
+python/src/convert.cpp
+python/src/convert.h
+python/src/cuda.cpp
+python/src/device.cpp
+python/src/distributed.cpp
+python/src/export.cpp
+python/src/fast.cpp
+python/src/fft.cpp
+python/src/indexing.cpp
+python/src/indexing.h
+python/src/linalg.cpp
+python/src/load.cpp
+python/src/load.h
+python/src/memory.cpp
+python/src/metal.cpp
+python/src/mlx.cpp
+python/src/mlx_func.cpp
+python/src/mlx_func.h
+python/src/ops.cpp
+python/src/random.cpp
+python/src/small_vector.h
+python/src/stream.cpp
+python/src/transforms.cpp
+python/src/trees.cpp
+python/src/trees.h
+python/src/utils.cpp
+python/src/utils.h
\ No newline at end of file
diff --git a/ml-stable-diffusion/mlx/python/mlx.egg-info/dependency_links.txt b/ml-stable-diffusion/mlx/python/mlx.egg-info/dependency_links.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx.egg-info/dependency_links.txt
@@ -0,0 +1 @@
+
diff --git a/ml-stable-diffusion/mlx/python/mlx.egg-info/entry_points.txt b/ml-stable-diffusion/mlx/python/mlx.egg-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..21c0813a42d36323aef5854bd84cb4d2cf0ea3db
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx.egg-info/entry_points.txt
@@ -0,0 +1,3 @@
+[console_scripts]
+mlx.distributed_config = mlx.distributed_run:distributed_config
+mlx.launch = mlx.distributed_run:main
diff --git a/ml-stable-diffusion/mlx/python/mlx.egg-info/not-zip-safe b/ml-stable-diffusion/mlx/python/mlx.egg-info/not-zip-safe
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx.egg-info/not-zip-safe
@@ -0,0 +1 @@
+
diff --git a/ml-stable-diffusion/mlx/python/mlx.egg-info/requires.txt b/ml-stable-diffusion/mlx/python/mlx.egg-info/requires.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6d5ef9a6a646bce7a599d0f5543e72b5b7dac174
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx.egg-info/requires.txt
@@ -0,0 +1,8 @@
+
+[dev]
+nanobind==2.4.0
+numpy
+pre-commit
+setuptools>=80
+torch
+typing_extensions
diff --git a/ml-stable-diffusion/mlx/python/mlx.egg-info/top_level.txt b/ml-stable-diffusion/mlx/python/mlx.egg-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2bef5b38b10153d7f09657bf3adb775fc84ea055
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx.egg-info/top_level.txt
@@ -0,0 +1 @@
+mlx
diff --git a/ml-stable-diffusion/mlx/python/mlx/__main__.py b/ml-stable-diffusion/mlx/python/mlx/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c21ef112a98442d67864d338d5e66d5a5f2e915
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/__main__.py
@@ -0,0 +1,27 @@
+import argparse
+
+
+def main() -> None:
+    from mlx.core import __version__
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=__version__,
+        help="Print the version number.",
+    )
+    parser.add_argument(
+        "--cmake-dir",
+        action="store_true",
+        help="Print the path to the MLX CMake module directory.",
+    )
+    args = parser.parse_args()
+    if args.cmake_dir:
+        from pathlib import Path
+
+        print(Path(__file__).parent)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ml-stable-diffusion/mlx/python/mlx/_os_warning.py b/ml-stable-diffusion/mlx/python/mlx/_os_warning.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d40b9f4e46cad4e207f248a7222596bdaf60d33
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/_os_warning.py
@@ -0,0 +1,9 @@
+import platform
+
+if platform.system() == "Darwin":
+    version = tuple(map(int, platform.mac_ver()[0].split(".")))
+    major, minor = version[0], version[1]
+    if (major, minor) < (13, 5):
+        raise ImportError(
+            f"Only macOS 13.5 and newer are supported, not {major}.{minor}"
+        )
diff --git a/ml-stable-diffusion/mlx/python/mlx/_reprlib_fix.py b/ml-stable-diffusion/mlx/python/mlx/_reprlib_fix.py
new file mode 100644
index 0000000000000000000000000000000000000000..29485f3698380f07693f79640d322dcab060e47a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/_reprlib_fix.py
@@ -0,0 +1,16 @@
+# Copyright © 2023 Apple Inc.
+
+import array
+import reprlib
+
+_old_repr_array = reprlib.Repr.repr_array
+
+
+def repr_array(self, x, maxlevel):
+    if isinstance(x, array.array):
+        return _old_repr_array(self, x, maxlevel)
+    else:
+        return self.repr_instance(x, maxlevel)
+
+
+reprlib.Repr.repr_array = repr_array
diff --git a/ml-stable-diffusion/mlx/python/mlx/_stub_patterns.txt b/ml-stable-diffusion/mlx/python/mlx/_stub_patterns.txt
new file mode 100644
index 0000000000000000000000000000000000000000..637d7de4fe13db01b7c070a9e594a53b8eb3d1df
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/_stub_patterns.txt
@@ -0,0 +1,34 @@
+mlx.core.__prefix__:
+  from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
+  import sys
+  if sys.version_info >= (3, 10):
+    from typing import TypeAlias
+  else:
+    from typing_extensions import TypeAlias
+
+mlx.core.__suffix__:
+  from typing import Union
+  scalar: TypeAlias = Union[int, float, bool]
+  list_or_scalar: TypeAlias = Union[scalar, list["list_or_scalar"]]
+  bool_: Dtype = ...
+
+mlx.core.distributed.__prefix__:
+  from mlx.core import array, Dtype, Device, Stream, scalar
+  from mlx.core.distributed import Group
+  from typing import Sequence, Optional, Union
+
+mlx.core.fast.__prefix__:
+  from mlx.core import array, Dtype, Device, Stream, scalar
+  from typing import Sequence, Optional, Union
+
+mlx.core.linalg.__prefix__:
+  from mlx.core import array, Dtype, Device, Stream, scalar
+  from typing import Sequence, Optional, Tuple, Union
+
+mlx.core.metal.__prefix__:
+  from mlx.core import array, Dtype, Device, Stream, scalar
+  from typing import Sequence, Optional, Union
+
+mlx.core.random.__prefix__:
+  from mlx.core import array, Dtype, Device, Stream, scalar, float32, int32
+  from typing import Sequence, Optional, Union
diff --git a/ml-stable-diffusion/mlx/python/mlx/distributed_run.py b/ml-stable-diffusion/mlx/python/mlx/distributed_run.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb0e3c6334071b2023e9e364e337c48a98eabe2f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/distributed_run.py
@@ -0,0 +1,872 @@
+# Copyright © 2025 Apple Inc.
+
+import argparse
+import base64
+import ipaddress
+import json
+import os
+import shlex
+import shutil
+import sys
+import tempfile
+import threading
+import time
+from collections import Counter
+from dataclasses import dataclass
+from pathlib import Path
+from queue import Empty as QueueEmpty
+from queue import Queue
+from select import select
+from subprocess import PIPE, Popen, run
+from typing import Optional
+
+import mlx.core as mx
+
+
+@dataclass
+class Host:
+    rank: int
+    ssh_hostname: str
+    ips: list[str]
+
+
+@dataclass
+class ThunderboltPort:
+    iface: str
+    uuid: str
+    connected_to: Optional[str]
+
+
+@dataclass
+class ThunderboltHost:
+    name: str
+    ports: list[ThunderboltPort]
+
+
+def parse_hardware_ports(ports_string):
+    ports = {}
+    port_name = None
+    for l in ports_string.decode("utf-8").split("\n"):
+        if l.startswith("Hardware Port:"):
+            port_name = l.strip()[15:]
+        elif l.startswith("Device:"):
+            ports[port_name] = l.strip()[8:]
+            port_name = None
+    return ports
+
+
+def get_num_nvidia_gpus():
+    result = run(["nvidia-smi", "-L"], capture_output=True, text=True, check=True)
+    return len(result.stdout.strip().split("\n"))
+
+
+def extract_rings(hosts, index):
+    def usable_port(i, j, used_ports):
+        return (i, j) not in used_ports and hosts[i].ports[j].connected_to is not None
+
+    def dfs(start_node, node, path, visited, used_ports):
+        path.append(node)
+        visited.add(node)
+        for j, p in enumerate(hosts[node].ports):
+            if not usable_port(node, j, used_ports):
+                continue
+            next_node, _ = index[p.connected_to]
+            if next_node == start_node:
+                yield path[:]
+            if next_node not in visited:
+                yield from dfs(start_node, next_node, path, visited, used_ports)
+        path.pop()
+        visited.remove(node)
+
+    # Concretize maps the found cycle to real thunderbolt ports. It also adds
+    # those ports to the used set so next cycles can't use them again.
+    def concretize(cycle, used_ports):
+        concrete_path = []
+        for n1, n2 in zip(cycle, cycle[1:] + cycle[:1]):
+            for j, p in enumerate(hosts[n1].ports):
+                if not usable_port(n1, j, used_ports):
+                    continue
+                n2_hat, nj = index[p.connected_to]
+                if n2 == n2_hat:
+                    concrete_path.append(((n1, j), (n2, nj)))
+                    used_ports.add((n1, j))
+                    used_ports.add((n2, nj))
+                    break
+            if concrete_path[-1][0][0] != n1:
+                raise RuntimeError("Couldn't concretize the cycle")
+        return concrete_path
+
+    # Normalize tries to ensure that the cycles have the same direction so we can
+    # use them together. We achieve this by selecting the direction such that
+    # the smallest rank hosts connect to larger rank hosts.
+    def normalize(path):
+        small_to_large = sum(1 for p in path if p[0][0] < p[1][0])
+        if small_to_large > len(path) - small_to_large:
+            return path
+        else:
+            return [(p[1], p[0]) for p in path]
+
+    rings = []
+    used_ports = set()
+    for start_node in range(len(hosts)):
+        while True:
+            ring = []
+            for r in dfs(start_node, start_node, [], set(), used_ports):
+                if len(r) > len(ring):
+                    ring = r
+                # Break early since we won't find a bigger ring no matter what
+                if len(ring) == len(hosts):
+                    break
+            if not ring:
+                break
+            try:
+                rings.append(normalize(concretize(ring, used_ports)))
+            except RuntimeError:
+                if len(rings) > 0:
+                    return rings
+                raise
+
+    return rings
+
+
+def positive_number(x):
+    x = int(x)
+    if x <= 0:
+        raise ValueError("Number should be positive")
+    return x
+
+
+def log(verbose, *args, **kwargs):
+    if not verbose:
+        return
+    print("\033[32m[INFO]", *args, "\033[0m", **kwargs)
+
+
+def log_warning(*args, **kwargs):
+    kwargs["file"] = sys.stderr
+    print("\033[33m[WARN]", *args, "\033[0m", **kwargs)
+
+
+def log_error(*args, **kwargs):
+    kwargs["file"] = sys.stderr
+    print("\033[31m[ERROR]", *args, "\033[0m", **kwargs)
+
+
+def parse_hostfile(parser, hostfile):
+    """Parse the json hostfile that contains both the hostnames to ssh into and
+    the ips to communicate over when using the ring backend.
+
+    Example:
+
+        [
+            {"ssh": "hostname1", "ips": ["123.123.123.1"]},
+            {"ssh": "hostname2", "ips": ["123.123.123.2"]},
+            ...
+            {"ssh": "hostnameN", "ips": ["123.123.123.N"]},
+        ]
+
+    Args:
+        hostfile (str): The path to the json file containing the host
+            information
+    """
+    hostfile = Path(hostfile)
+    if not hostfile.exists():
+        parser.error(f"Hostfile {str(hostfile)} doesn't exist")
+
+    try:
+        hosts = []
+        with open(hostfile) as f:
+            for i, h in enumerate(json.load(f)):
+                hosts.append(Host(i, h["ssh"], h.get("ips", [])))
+        return hosts
+    except Exception as e:
+        parser.error(f"Failed to parse hostfile {str(hostfile)} ({str(e)})")
+
+
+def parse_hostlist(parser, hostlist, repeats):
+    hosts = []
+    for i, h in enumerate(hostlist.split(",")):
+        if h == "":
+            raise ValueError("Hostname cannot be empty")
+        try:
+            ipaddress.ip_address(h)
+            ips = [h]
+        except ValueError:
+            ips = []
+        for i in range(repeats):
+            hosts.append(Host(i, h, ips))
+    return hosts
+
+
+def make_monitor_script(rank, hostfile, cwd, env, command, verbose):
+    # Imports that are used throughout
+    script = ""
+    script += "import os\n"
+    script += "import sys\n"
+    script += "import tempfile\n"
+    script += "from pathlib import Path\n"
+
+    # Write the PID to a file so we can kill the process if needed
+    script += "_, pidfile = tempfile.mkstemp() \n"
+    script += "open(pidfile, 'w').write(str(os.getpid()))\n"
+    script += "print(pidfile, flush=True)\n"
+
+    # Change the working directory if one was requested. Otherwise attempt to
+    # change to the current one but don't fail if it wasn't possible.
+    d = cwd or os.getcwd()
+    script += f"if Path({repr(d)}).exists():\n"
+    script += f"    os.chdir({repr(d)})\n"
+    if cwd is not None:
+        script += "else:\n"
+        script += (
+            f"    print('Failed to change directory to', {repr(d)}, file=sys.stderr)\n"
+        )
+        script += f"    sys.exit(1)\n"
+
+    # Add the environment variables that were given to us
+    script += "env = dict(os.environ)\n"
+    for e in env:
+        key, *value = e.split("=", maxsplit=1)
+        value = shlex.quote(value[0]) if len(value) > 0 else ""
+        if not all(c.isalnum() or c == "_" for c in key):
+            log_warning(f"'{e}' is an invalid environment variable so it is ignored")
+            continue
+        script += f"env[{repr(key)}] = {repr(value)}\n"
+
+    # Add the environment variables to enable the ring distributed backend
+    if hostfile != "":
+        script += "_, hostfile = tempfile.mkstemp()\n"
+        script += "with open(hostfile, 'w') as f:\n"
+        script += f"    f.write({repr(hostfile)})\n"
+        if verbose:
+            script += "env['MLX_RING_VERBOSE'] = '1'\n"
+        script += "env['MLX_HOSTFILE'] = hostfile\n"
+        script += f"env['MLX_RANK'] = '{rank}'\n"
+        script += "\n"
+
+    # Replace the process with the script
+    script += f"command = [{','.join(map(repr, command))}]\n"
+    script += "os.execve(command[0], command, env)\n"
+
+    return script
+
+
+def launch_ring(parser, hosts, args, command):
+    stop = False
+    exit_codes = [None] * len(hosts)
+
+    def node_thread(rank, host, hostfile, input_queue):
+        is_local = host == "127.0.0.1"
+        script = make_monitor_script(
+            rank, hostfile, args.cwd, args.env, command, args.verbose
+        )
+        script_b64 = base64.b64encode(script.encode()).decode()
+        cmd = f'{sys.executable} -c "import base64; exec(base64.b64decode(\\"{script_b64}\\"));"'
+        if not is_local:
+            cmd = f"ssh {host} '{cmd}'"
+        p = Popen(
+            cmd,
+            shell=True,
+            stdin=PIPE,
+            stdout=PIPE,
+            stderr=PIPE,
+        )
+        os.set_blocking(p.stdout.fileno(), False)
+        os.set_blocking(p.stderr.fileno(), False)
+        os.set_blocking(p.stdin.fileno(), False)
+
+        # Repeat the stdout and stderr to the local machine
+        to_read = [p.stdout.fileno(), p.stderr.fileno()]
+        to_write = [p.stdin.fileno(), sys.stdout.fileno(), sys.stderr.fileno()]
+        pidfile = ""
+        stdin_buffer = b""
+        stdout_buffer = b""
+        stderr_buffer = b""
+        while p.poll() is None:
+            try:
+                stdin_buffer += input_queue.get_nowait()
+            except QueueEmpty:
+                pass
+            rlist, wlist, _ = select(to_read, to_write, [], 1.0)
+            for fd in rlist:
+                msg = os.read(fd, 8192).decode(errors="ignore")
+
+                # Fetch the PID file first if we haven't already
+                if pidfile == "":
+                    pidfile, *msg = msg.split("\n", maxsplit=1)
+                    msg = msg[0] if msg else ""
+
+                is_stdout = fd == p.stdout.fileno()
+                if is_stdout:
+                    stdout_buffer += msg.encode()
+                else:
+                    stderr_buffer += msg.encode()
+            for fd in wlist:
+                if fd == p.stdin.fileno() and len(stdin_buffer) > 0:
+                    n = os.write(fd, stdin_buffer)
+                    stdin_buffer = stdin_buffer[n:]
+                elif fd == sys.stdout.fileno() and len(stdout_buffer) > 0:
+                    n = os.write(fd, stdout_buffer)
+                    stdout_buffer = stdout_buffer[n:]
+                elif fd == sys.stderr.fileno() and len(stderr_buffer) > 0:
+                    n = os.write(fd, stderr_buffer)
+                    stderr_buffer = stderr_buffer[n:]
+            if stop:
+                p.terminate()
+                break
+        p.wait()
+        exit_codes[rank] = p.returncode
+
+        # Kill the remote program if possible
+        cmd = ""
+        cmd += f"pid=$(cat {pidfile}); "
+        cmd += "if ps -p $pid >/dev/null; then "
+        cmd += "    kill $pid; "
+        cmd += "    echo 1; "
+        cmd += "else "
+        cmd += "    echo 0; "
+        cmd += "fi; "
+        cmd += f"rm {pidfile}"
+        if not is_local:
+            cmd = f"ssh {host} '{cmd}'"
+        c = run(cmd, check=True, shell=True, capture_output=True, text=True)
+        if c.stdout.strip() == "1":
+            log_warning(f"Node with rank {rank} was killed")
+        elif p.returncode != 0:
+            log_warning(f"Node with rank {rank} exited with code {p.returncode}")
+        else:
+            log(args.verbose, f"Node with rank {rank} completed")
+
+    if all(len(h.ips) == 0 for h in hosts):
+        parser.error(
+            "The ring backend requires IPs to be provided instead of hostnames"
+        )
+
+    port = args.starting_port
+    ring_hosts = []
+    for h in hosts:
+        node = []
+        for ip in h.ips:
+            for i in range(args.connections_per_ip):
+                node.append(f"{ip}:{port}")
+                port += 1
+        ring_hosts.append(node)
+    hostfile = json.dumps(ring_hosts) if len(ring_hosts) > 1 else ""
+
+    log(args.verbose, "Running", shlex.join(command))
+
+    input_queues = []
+    threads = []
+    for i, h in enumerate(hosts):
+        if i + 1 == len(hosts):
+            time.sleep(1.0)
+        input_queues.append(Queue())
+        t = threading.Thread(
+            target=node_thread, args=(i, h.ssh_hostname, hostfile, input_queues[-1])
+        )
+        t.start()
+        threads.append(t)
+
+    os.set_blocking(sys.stdin.fileno(), False)
+    while not stop:
+        rlist, _, _ = select([sys.stdin.fileno()], [], [], 1.0)
+        for fd in rlist:
+            stdin_buffer = os.read(fd, 8192)
+            for q in input_queues:
+                q.put(stdin_buffer)
+        if any(t.is_alive() for t in threads):
+            for i, t in enumerate(threads):
+                if not t.is_alive():
+                    if exit_codes[i] != 0:
+                        stop = True
+                        break
+        else:
+            break
+    for t in threads:
+        t.join()
+
+
+def launch_mpi(parser, hosts, args, command):
+    mpirun = run(["which", "mpirun"], check=True, capture_output=True)
+    mpirun = mpirun.stdout.strip().decode()
+
+    # Homebrew libmpi doesn't work with anaconda python out of the box.
+    # TODO: Check if we should do this with every mpirun
+    if "homebrew" in mpirun:
+        dyld = Path(mpirun).parent.parent / "lib"
+        args.env = [f"DYLD_LIBRARY_PATH={str(dyld)}"] + args.env
+
+    log(args.verbose, f"Using '{mpirun}'")
+    with tempfile.NamedTemporaryFile(mode="w") as f:
+        hosts = Counter((h.ssh_hostname for h in hosts))
+        for h, n in hosts.items():
+            print(f"{h} slots={n}", file=f)
+        f.flush()
+
+        cmd = [
+            mpirun,
+            "--output",
+            ":raw",  # do not line buffer output
+            "--hostfile",
+            f.name,
+            *(["-cwd", args.cwd] if args.cwd else []),
+            *sum((["-x", e] for e in args.env), []),
+            *sum([shlex.split(arg) for arg in args.mpi_arg], []),
+            "--",
+            *command,
+        ]
+        log(args.verbose, "Running", " ".join(cmd))
+        try:
+            run(cmd)
+        except KeyboardInterrupt:
+            pass
+
+
+def launch_nccl(parser, hosts, args, command):
+    master_host = hosts[0].ips[0]
+
+    if master_host != "127.0.0.1":
+        raise ValueError("The NCCL backend only supports localhost for now.")
+    master_port = args.nccl_port
+    world_size = len(hosts)
+
+    base_env = os.environ.copy()
+    base_env.update(
+        {
+            "NCCL_DEBUG": base_env.get(
+                "NCCL_DEBUG", "INFO" if args.verbose else "DEBUG"
+            ),
+            "NCCL_SOCKET_IFNAME": "lo",  # Use loopback for local communication
+            "NCCL_HOST_IP": master_host,
+            "NCCL_PORT": str(master_port),
+            "MLX_WORLD_SIZE": str(world_size),
+        }
+    )
+    procs = []
+    num_gpus = get_num_nvidia_gpus()
+    if num_gpus == 0:
+        raise RuntimeError("Cannot run NCCL backend with no GPUs.")
+    if args.repeat_hosts > num_gpus:
+        raise RuntimeError("NCCL requires a separate GPU per process.")
+
+    try:
+        for rank in range(world_size):
+            env = base_env.copy()
+            mlx_rank = str(rank % args.repeat_hosts)
+            env["MLX_RANK"] = mlx_rank
+            env["CUDA_VISIBLE_DEVICES"] = mlx_rank
+            p = Popen(command, env=env)
+            procs.append(p)
+
+        for p in procs:
+            ret = p.wait()
+            if ret != 0:
+                raise RuntimeError(f"Rank process exited with {ret}")
+
+    except (RuntimeError, KeyboardInterrupt) as err:
+        for p in procs:
+            if p.poll() is None:
+                try:
+                    p.kill()
+                except Exception:
+                    pass
+        raise
+
+
+def check_ssh_connections(hosts):
+    results = [False] * len(hosts)
+
+    def _check(hostname, i):
+        result = run(
+            [
+                "ssh",
+                "-o",
+                "BatchMode=yes",
+                "-o",
+                "ConnectTimeout=5",
+                hostname,
+                "echo",
+                "success",
+            ],
+            stdout=PIPE,
+            stderr=PIPE,
+        )
+        results[i] = result.returncode == 0
+
+    threads = [
+        threading.Thread(target=_check, args=(h.ssh_hostname, i))
+        for i, h in enumerate(hosts)
+    ]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join()
+
+    if not all(results):
+        log_error("Could not ssh to the following hosts:")
+        for i, h in enumerate(hosts):
+            if not results[i]:
+                log_error("  - ", h.ssh_hostname)
+        log_error()
+        log_error("Maybe they are not set-up for password-less ssh?")
+        sys.exit(1)
+
+
+def prepare_tb_ring(args, hosts):
+    log(
+        args.verbose,
+        f"Preparing a thunderbolt ring for {', '.join(h.ssh_hostname for h in hosts)}",
+    )
+
+    # Check that we can ssh
+    check_ssh_connections(hosts)
+    if args.auto_setup and args.verbose:
+        log_warning(
+            "--auto-setup is requested which requires password-less sudo",
+            "on the remote hosts",
+        )
+
+    # Extract the current connectivity from the remote hosts
+    thunderbolt_connections = []
+    for h in hosts:
+        log(args.verbose, "Getting connectivity from", h.ssh_hostname)
+        thunderbolt_connections.append(
+            json.loads(
+                run(
+                    [
+                        "ssh",
+                        h.ssh_hostname,
+                        "system_profiler",
+                        "SPThunderboltDataType",
+                        "-json",
+                    ],
+                    capture_output=True,
+                ).stdout
+            )
+        )
+    interface_maps = []
+    for h in hosts:
+        log(args.verbose, "Getting interface names from", h.ssh_hostname)
+        interface_maps.append(
+            parse_hardware_ports(
+                run(
+                    [
+                        "ssh",
+                        h.ssh_hostname,
+                        "networksetup",
+                        "-listallhardwareports",
+                    ],
+                    capture_output=True,
+                ).stdout
+            )
+        )
+
+    # Parse the connectivity into some simple dataclasses
+    tb_hosts = []
+    for c, iface_map in zip(thunderbolt_connections, interface_maps):
+        name = ""
+        ports = []
+        for t in c["SPThunderboltDataType"]:
+            name = t["device_name_key"]
+            uuid = t["domain_uuid_key"]
+            tag = t["receptacle_1_tag"]["receptacle_id_key"]
+            if items := t.get("_items", []):
+                connected_to = items[0]["domain_uuid_key"]
+            else:
+                connected_to = None
+            iface = iface_map[f"Thunderbolt {tag}"]
+            ports.append(ThunderboltPort(iface, uuid, connected_to))
+        tb_hosts.append(ThunderboltHost(name, sorted(ports, key=lambda x: x.iface)))
+
+    # Create a reverse index to be able to map uuids to (host, port) quickly
+    uuid_reverse_index = {}
+    for i, h in enumerate(tb_hosts):
+        for j, p in enumerate(h.ports):
+            uuid_reverse_index[p.uuid] = (i, j)
+
+    # Find the rings by simply walking and marking visited (host, port) tuples
+    # and keeping the largest rings greedily.
+    log(args.verbose, "Extracting rings from the parsed connectivity")
+    rings = extract_rings(tb_hosts, uuid_reverse_index)
+
+    # Just output a DOT graphical representation of the found rings
+    if args.dot:
+        names = []
+        for i in range(len(tb_hosts)):
+            n = ""
+            j = i
+            while True:
+                n += chr(97 + j % 26)
+                j //= 26
+                if j == 0:
+                    break
+            names.append(n)
+
+        print("graph G {")
+        print("  node [shape=rectangle];")
+        for i, h in enumerate(hosts):
+            print(f'  {names[i]} [label="{h.ssh_hostname}"];')
+        for r in rings:
+            for (i, _), (j, _) in r:
+                print(f"  {names[i]} -- {names[j]};")
+        print("}")
+        return
+
+    # Assign IPs to each interface such that the interfaces can communicate
+    ips = {}
+    pairs = {}
+    expecting = set()
+    ip0 = 0
+    ip1 = 0
+    netmask = "255.255.255.252"
+    for r in rings:
+        for a, b in r:
+            ips[a] = f"192.168.{ip0}.{ip1 + 1}"
+            ips[b] = f"192.168.{ip0}.{ip1 + 2}"
+            pairs[a] = b
+            pairs[b] = a
+            expecting.add(b)
+            ip1 += 4
+            if ip1 > 255:
+                ip0 += 1
+                ip1 = 0
+            if ip0 > 255:
+                raise ValueError("Ran out of available local IPs for the ring")
+
+    # Create the hostfile
+    hostfile = []
+    for i, h in enumerate(hosts):
+        host = {
+            "ssh": h.ssh_hostname,
+            "ips": [
+                ips[i, j]
+                for j, p in enumerate(tb_hosts[i].ports)
+                if (i, j) in expecting
+            ],
+        }
+        hostfile.append(host)
+
+    if not args.hostfile_only:
+        for i, h in enumerate(hosts):
+            command = ""
+            command += "sudo ifconfig bridge0 down\n"
+            for j, p in enumerate(tb_hosts[i].ports):
+                if (i, j) not in ips:
+                    continue
+                iface = p.iface
+                ip = ips[i, j]
+                peer = ips[pairs[i, j]]
+                command += f"sudo ifconfig {iface} inet {ip} netmask {netmask}\n"
+                command += f"sudo route change {peer} -interface {iface}\n"
+            if args.auto_setup:
+                print(f"Running auto setup for {h.ssh_hostname}")
+                command = command.strip().replace("\n", " && ")
+                command = ["ssh", h.ssh_hostname, command]
+                log(args.verbose, shlex.join(command))
+                run(command)
+            else:
+                msg = f"Setup for {h.ssh_hostname}"
+                print(msg)
+                print("=" * len(msg))
+                print(command)
+                input("Enter to continue")
+            print()
+
+    if args.output_hostfile:
+        with open(args.output_hostfile, "w") as f:
+            json.dump(hostfile, f, indent=4)
+    else:
+        print("Hostfile")
+        print("========")
+        print(json.dumps(hostfile, indent=4))
+
+
+def prepare_hostfile(args, hosts):
+    log(
+        args.verbose,
+        f"Preparing an ethernet hostfile for {', '.join(h.ssh_hostname for h in hosts)}",
+    )
+
+    # Check that we can ssh
+    check_ssh_connections(hosts)
+
+    # Get the ips for each host
+    for h in hosts:
+        log(args.verbose, "Getting the ip from", h.ssh_hostname)
+        h.ips.append(
+            run(
+                ["ssh", h.ssh_hostname, "ipconfig", "getifaddr", "en0"],
+                capture_output=True,
+                text=True,
+            ).stdout.strip()
+        )
+
+    hostfile = []
+    for h in hosts:
+        hostfile.append(dict(ssh=h.ssh_hostname, ips=h.ips))
+
+    if args.output_hostfile:
+        with open(args.output_hostfile, "w") as f:
+            json.dump(hostfile, f, indent=4)
+    else:
+        print("Hostfile")
+        print("========")
+        print(json.dumps(hostfile, indent=4))
+
+
+def distributed_config():
+    parser = argparse.ArgumentParser(
+        description="Configure remote machines for use with MLX distributed"
+    )
+    parser.add_argument(
+        "--verbose", action="store_true", help="Print debug messages in stdout"
+    )
+    parser.add_argument(
+        "--backend",
+        choices=["ring", "mpi", "nccl"],
+        default="nccl" if mx.cuda.is_available() else "ring",
+        help="Which distributed backend to configure",
+    )
+    parser.add_argument(
+        "--over",
+        choices=["thunderbolt", "ethernet"],
+        default="thunderbolt",
+        help="What type of connectivity to configure",
+    )
+    parser.add_argument(
+        "--hosts", default="127.0.0.1", help="A comma separated list of hosts"
+    )
+    parser.add_argument("--hostfile", help="The file containing the hosts")
+    parser.add_argument(
+        "--dot", action="store_true", help="Output the topology in DOT format and exit"
+    )
+    parser.add_argument(
+        "--hostfile-only", action="store_true", help="If set only compute the hostfile"
+    )
+    parser.add_argument(
+        "--output-hostfile", help="If provided, save the hostfile to this path"
+    )
+    parser.add_argument(
+        "--auto-setup",
+        action="store_true",
+        help="If set we will attempt to automatically configure the machines via ssh",
+    )
+    args = parser.parse_args()
+
+    if args.backend == "mpi" and args.over == "thunderbolt":
+        raise ValueError(
+            (
+                "The configuration of MPI over thunderbolt is "
+                "not supported yet by mlx.distributed_config"
+            )
+        )
+
+    if args.hostfile is not None:
+        hosts = parse_hostfile(parser, args.hostfile)
+    else:
+        hosts = parse_hostlist(parser, args.hosts, 1)
+
+    if args.over == "thunderbolt":
+        prepare_tb_ring(args, hosts)
+    else:
+        prepare_hostfile(args, hosts)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Launch an MLX distributed program")
+    parser.add_argument(
+        "--print-python",
+        action="store_true",
+        help="Print the path to the current python executable and exit",
+    )
+    parser.add_argument(
+        "--verbose", action="store_true", help="Print debug messages in stdout"
+    )
+    parser.add_argument(
+        "--hosts", default="127.0.0.1", help="A comma separated list of hosts"
+    )
+    parser.add_argument(
+        "--repeat-hosts",
+        "-n",
+        type=positive_number,
+        default=1,
+        help="Repeat each host a given number of times",
+    )
+    parser.add_argument("--hostfile", help="The file containing the hosts")
+    parser.add_argument(
+        "--backend",
+        choices=["ring", "mpi", "nccl"],
+        default="nccl" if mx.cuda.is_available() else "ring",
+        help="Which distributed backend to launch",
+    )
+    parser.add_argument(
+        "--env",
+        action="append",
+        default=[],
+        help="Set environment variables for the jobs",
+    )
+    parser.add_argument(
+        "--mpi-arg",
+        action="append",
+        default=[],
+        help="Arguments to pass directly to mpirun",
+    )
+    parser.add_argument(
+        "--connections-per-ip",
+        default=1,
+        type=int,
+        help="How many connections per ip to use for the ring backend",
+    )
+    parser.add_argument(
+        "--starting-port",
+        "-p",
+        type=int,
+        default=5000,
+        help="For the ring backend listen on this port increasing by 1 per rank and IP",
+    )
+    parser.add_argument(
+        "--cwd", help="Set the working directory on each node to the provided one"
+    )
+    parser.add_argument(
+        "--nccl-port",
+        type=int,
+        default=12345,
+        help="The port to use for the NCCL communication (only for nccl backend)",
+    )
+
+    args, rest = parser.parse_known_args()
+
+    if args.print_python:
+        print(sys.executable)
+        return
+
+    if len(rest) == 0:
+        parser.error("No script is provided")
+    if rest[0] == "--":
+        rest.pop(0)
+
+    # Try to extract a list of hosts and corresponding ips
+    if args.hostfile is not None:
+        hosts = parse_hostfile(parser, args.hostfile)
+    else:
+        hosts = parse_hostlist(parser, args.hosts, args.repeat_hosts)
+
+    # Check if the script is a file and convert it to a full path
+    if (script := Path(rest[0])).exists():
+        rest[0:1] = [sys.executable, str(script.resolve())]
+    elif (command := shutil.which(rest[0])) is not None:
+        rest[0] = command
+    else:
+        raise ValueError(f"Invalid script or command {rest[0]}")
+
+    # Launch
+    if args.backend == "ring":
+        launch_ring(parser, hosts, args, rest)
+    if args.backend == "mpi":
+        launch_mpi(parser, hosts, args, rest)
+    if args.backend == "nccl":
+        launch_nccl(parser, hosts, args, rest)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ml-stable-diffusion/mlx/python/mlx/extension.py b/ml-stable-diffusion/mlx/python/mlx/extension.py
new file mode 100644
index 0000000000000000000000000000000000000000..c426d59531c6c19262af6b7e049b1b180b3edc95
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/extension.py
@@ -0,0 +1,88 @@
+# Copyright © 2023 Apple Inc.
+
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+from setuptools import Extension
+from setuptools.command.build_ext import build_ext
+
+import mlx
+
+_MLX_PATH = str(mlx.__path__[0])
+
+
+# A CMakeExtension needs a sourcedir instead of a file list.
+class CMakeExtension(Extension):
+    def __init__(self, name: str, sourcedir: str = "") -> None:
+        super().__init__(name, sources=[])
+        self.sourcedir = os.fspath(Path(sourcedir).resolve())
+
+
+class CMakeBuild(build_ext):
+    def build_extension(self, ext: CMakeExtension) -> None:
+        # Must be in this form due to bug in .resolve() only fixed in Python 3.10+
+        ext_fullpath = Path.cwd() / self.get_ext_fullpath(ext.name)  # type: ignore[no-untyped-call]
+        extdir = ext_fullpath.parent.resolve()
+
+        debug = int(os.environ.get("DEBUG", 0)) if self.debug is None else self.debug
+        cfg = "Debug" if debug else "Release"
+
+        # Set Python_EXECUTABLE instead if you use PYBIND11_FINDPYTHON
+        # EXAMPLE_VERSION_INFO shows you how to pass a value into the C++ code
+        # from Python.
+        cmake_args = [
+            f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}{os.sep}",
+            f"-DCMAKE_BUILD_TYPE={cfg}",
+            "-DBUILD_SHARED_LIBS=ON",
+        ]
+        build_args = []
+        # Adding CMake arguments set as environment variable
+        # (needed e.g. to build for ARM OSx on conda-forge)
+        if "CMAKE_ARGS" in os.environ:
+            cmake_args += [item for item in os.environ["CMAKE_ARGS"].split(" ") if item]
+
+        if sys.platform.startswith("darwin"):
+            # Cross-compile support for macOS - respect ARCHFLAGS if set
+            archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", ""))
+            if archs:
+                cmake_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs))]
+
+        # Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level
+        # across all generators.
+        if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ:
+            build_args += [f"-j{os.cpu_count()}"]
+
+        build_temp = Path(self.build_temp) / ext.name
+        if not build_temp.exists():
+            build_temp.mkdir(parents=True)
+
+        # Make sure cmake can find MLX
+        os.environ["MLX_DIR"] = _MLX_PATH
+
+        subprocess.run(
+            ["cmake", ext.sourcedir, *cmake_args], cwd=build_temp, check=True
+        )
+        subprocess.run(
+            ["cmake", "--build", ".", *build_args], cwd=build_temp, check=True
+        )
+
+    def run(self) -> None:
+        super().run()
+
+        # Based on https://github.com/pypa/setuptools/blob/main/setuptools/command/build_ext.py#L102
+        if self.inplace:
+            for ext in self.extensions:
+                if isinstance(ext, CMakeExtension):
+                    # Resolve inplace package dir
+                    build_py = self.get_finalized_command("build_py")
+                    inplace_file, regular_file = self._get_inplace_equivalent(
+                        build_py, ext
+                    )
+
+                    inplace_dir = str(Path(inplace_file).parent.resolve())
+                    regular_dir = str(Path(regular_file).parent.resolve())
+
+                    self.copy_tree(regular_dir, inplace_dir)
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/__init__.py b/ml-stable-diffusion/mlx/python/mlx/nn/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..df72e2a94fe0f203e152d591ec7e4703624610e0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/__init__.py
@@ -0,0 +1,5 @@
+# Copyright © 2023 Apple Inc.
+
+from mlx.nn import init, losses
+from mlx.nn.layers import *
+from mlx.nn.utils import average_gradients, value_and_grad
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/init.py b/ml-stable-diffusion/mlx/python/mlx/nn/init.py
new file mode 100644
index 0000000000000000000000000000000000000000..68a9221c45f671d3d34cb3bda1deb27c82cb59bb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/init.py
@@ -0,0 +1,441 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+from typing import Callable, Literal
+
+import mlx.core as mx
+
+
+def constant(
+    value: float, dtype: mx.Dtype = mx.float32
+) -> Callable[[mx.array], mx.array]:
+    r"""An initializer that returns an array filled with ``value``.
+
+    Args:
+        value (float): The value to fill the array with.
+        dtype (Dtype, optional): The data type of the array. Default:
+          ``float32``.
+
+    Returns:
+        Callable[[array], array]: An initializer that returns an array with the
+        same shape as the input, filled with ``value``.
+
+    Example:
+
+        >>> init_fn = nn.init.constant(0.5)
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[0.5, 0.5],
+               [0.5, 0.5]], dtype=float32)
+    """
+
+    def initializer(a: mx.array) -> mx.array:
+        return mx.full(a.shape, value, dtype=dtype)
+
+    return initializer
+
+
+def normal(
+    mean: float = 0.0, std: float = 1.0, dtype: mx.Dtype = mx.float32
+) -> Callable[[mx.array], mx.array]:
+    r"""An initializer that returns samples from a normal distribution.
+
+    Args:
+        mean (float, optional): Mean of the normal distribution. Default:
+          ``0.0``.
+        std (float, optional): Standard deviation of the normal distribution.
+          Default: ``1.0``.
+        dtype (Dtype, optional): The data type of the array. Default:
+          ``float32``.
+
+    Returns:
+        Callable[[array], array]: An initializer that returns an array with the
+        same shape as the input, filled with samples from a normal distribution.
+
+    Example:
+
+        >>> init_fn = nn.init.normal()
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[-0.982273, -0.534422],
+               [0.380709, 0.0645099]], dtype=float32)
+    """
+
+    def initializer(a: mx.array) -> mx.array:
+        return mx.random.normal(shape=a.shape, scale=std, loc=mean, dtype=dtype)
+
+    return initializer
+
+
+def uniform(
+    low: float = 0.0, high: float = 1.0, dtype: mx.Dtype = mx.float32
+) -> Callable[[mx.array], mx.array]:
+    r"""An initializer that returns samples from a uniform distribution.
+
+    Args:
+        low (float, optional): The lower bound of the uniform distribution.
+          Default: ``0.0``.
+        high (float, optional): The upper bound of the uniform distribution.
+          Default: ``1.0``
+        dtype (Dtype, optional): The data type of the array. Default: ``float32``.
+
+    Returns:
+        Callable[[array], array]: An initializer that returns an array
+        with the same shape as the input, filled with samples from a uniform
+        distribution
+
+    Example:
+
+        >>> init_fn = nn.init.uniform(low=0, high=1)
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[0.883935, 0.863726],
+               [0.617261, 0.417497]], dtype=float32)
+    """
+
+    def initializer(a: mx.array) -> mx.array:
+        return mx.random.uniform(low, high, a.shape, dtype=dtype)
+
+    return initializer
+
+
+def identity(dtype: mx.Dtype = mx.float32) -> Callable[[mx.array], mx.array]:
+    r"""An initializer that returns an identity matrix.
+
+    Args:
+        dtype (Dtype, optional): The data type of the array. Defaults:
+          ``float32``.
+
+    Returns:
+        Callable[[array], array]: An initializer that returns an identity
+        matrix with the same shape as the input.
+
+    Example:
+
+        >>> init_fn = nn.init.identity()
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[1, 0],
+               [0, 1]], dtype=float32)
+    """
+
+    def initializer(arr: mx.array) -> mx.array:
+        if arr.ndim != 2 or arr.shape[0] != arr.shape[1]:
+            raise ValueError(
+                f"The input array must be a square matrix but got shape {arr.shape}."
+            )
+        return mx.eye(n=arr.shape[0], dtype=dtype)
+
+    return initializer
+
+
+def _calculate_fan_in_fan_out(x):
+    if x.ndim < 2:
+        raise ValueError(
+            "Glorot / He initialization requires at least 2 dimensional input"
+            f" but input with {x.ndim} dimensions."
+        )
+
+    fan_in = x.shape[-1]
+    fan_out = x.shape[0]
+
+    if x.ndim > 2:
+        receptive_field = 1
+        for d in x.shape[1:-1]:
+            receptive_field *= d
+
+        fan_in = fan_in * receptive_field
+        fan_out = fan_out * receptive_field
+
+    return fan_in, fan_out
+
+
+def glorot_normal(
+    dtype: mx.Dtype = mx.float32,
+) -> Callable[[mx.array, float], mx.array]:
+    r"""A Glorot normal initializer.
+
+    This initializer samples from a normal distribution with a standard
+    deviation computed from the number of input (``fan_in``) and output
+    (``fan_out``) units according to:
+
+    .. math::
+        \sigma = \gamma \sqrt{\frac{2.0}{\text{fan\_in} + \text{fan\_out}}}
+
+    For more details see the original reference: `Understanding the difficulty
+    of training deep feedforward neural networks
+    <https://proceedings.mlr.press/v9/glorot10a.html>`_
+
+    Args:
+        dtype (Dtype, optional): The data type of the array. Default: ``float32``.
+
+    Returns:
+        Callable[[array, float], array]: An initializer that returns an array
+        with the same shape as the input, filled with samples from the Glorot
+        normal distribution.
+
+    Example:
+
+        >>> init_fn = nn.init.glorot_normal()
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[0.191107, 1.61278],
+               [-0.150594, -0.363207]], dtype=float32)
+        >>> init_fn(mx.zeros((2, 2)), gain=4.0)
+        array([[1.89613, -4.53947],
+               [4.48095, 0.995016]], dtype=float32)
+    """
+
+    def initializer(a: mx.array, gain: float = 1.0) -> mx.array:
+        fan_in, fan_out = _calculate_fan_in_fan_out(a)
+        std = gain * math.sqrt(2.0 / (fan_in + fan_out))
+        return mx.random.normal(shape=a.shape, scale=std, dtype=dtype)
+
+    return initializer
+
+
+def glorot_uniform(
+    dtype: mx.Dtype = mx.float32,
+) -> Callable[[mx.array, float], mx.array]:
+    r"""A Glorot uniform initializer.
+
+    This initializer samples from a uniform distribution with a range
+    computed from the number of input (``fan_in``) and output (``fan_out``)
+    units according to:
+
+    .. math::
+        \sigma = \gamma \sqrt{\frac{6.0}{\text{fan\_in} + \text{fan\_out}}}
+
+    For more details see the original reference: `Understanding the difficulty
+    of training deep feedforward neural networks
+    <https://proceedings.mlr.press/v9/glorot10a.html>`_
+
+    Args:
+        dtype (Dtype, optional): The data type of the array. Default: ``float32``.
+
+    Returns:
+        Callable[[array, float], array]: An initializer that returns an array
+        with the same shape as the input, filled with samples from the Glorot
+        uniform distribution.
+
+    Example:
+
+        >>> init_fn = nn.init.glorot_uniform()
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[0.223404, -0.890597],
+               [-0.379159, -0.776856]], dtype=float32)
+        >>> init_fn(mx.zeros((2, 2)), gain=4.0)
+        array([[-1.90041, 3.02264],
+               [-0.912766, 4.12451]], dtype=float32)
+    """
+
+    def initializer(a: mx.array, gain: float = 1.0) -> mx.array:
+        fan_in, fan_out = _calculate_fan_in_fan_out(a)
+        limit = gain * math.sqrt(6.0 / (fan_in + fan_out))
+        return mx.random.uniform(-limit, limit, a.shape, dtype=dtype)
+
+    return initializer
+
+
+def he_normal(
+    dtype: mx.Dtype = mx.float32,
+) -> Callable[[mx.array, Literal["fan_in", "fan_out"], float], mx.array]:
+    r"""Build a He normal initializer.
+
+    This initializer samples from a normal distribution with a standard
+    deviation computed from the number of input (``fan_in``) or output
+    (``fan_out``) units according to:
+
+    .. math::
+        \sigma = \gamma \frac{1}{\sqrt{\text{fan}}}
+
+    where :math:`\text{fan}` is either the number of input units when the
+    ``mode`` is ``"fan_in"`` or output units when the ``mode`` is
+    ``"fan_out"``.
+
+    For more details see the original reference: `Delving Deep into Rectifiers:
+    Surpassing Human-Level Performance on ImageNet Classification
+    <https://arxiv.org/abs/1502.01852>`_
+
+    Args:
+        dtype (Dtype, optional): The data type of the array. Defaults to mx.float32.
+
+    Returns:
+        Callable[[array, str, float], array]: An initializer that returns an
+        array with the same shape as the input, filled with samples from the He
+        normal distribution.
+
+    Example:
+
+        >>> init_fn = nn.init.he_normal()
+        >>> init_fn(mx.zeros((2, 2)))  # uses fan_in
+        array([[-1.25211, 0.458835],
+               [-0.177208, -0.0137595]], dtype=float32)
+        >>> init_fn(mx.zeros((2, 2)), mode="fan_out", gain=5)
+        array([[5.6967, 4.02765],
+               [-4.15268, -2.75787]], dtype=float32)
+    """
+
+    def initializer(
+        a: mx.array,
+        mode: Literal["fan_in", "fan_out"] = "fan_in",
+        gain: float = 1.0,
+    ) -> mx.array:
+        fan_in, fan_out = _calculate_fan_in_fan_out(a)
+        if mode == "fan_in":
+            fan = fan_in
+        elif mode == "fan_out":
+            fan = fan_out
+        else:
+            raise ValueError(f"Invalid mode: {mode}. Valid modes are: fan_in, fan_out")
+
+        std = gain / math.sqrt(fan)
+        return mx.random.normal(shape=a.shape, scale=std, dtype=dtype)
+
+    return initializer
+
+
+def he_uniform(
+    dtype: mx.Dtype = mx.float32,
+) -> Callable[[mx.array, Literal["fan_in", "fan_out"], float], mx.array]:
+    r"""A He uniform (Kaiming uniform) initializer.
+
+    This initializer samples from a uniform distribution with a range
+    computed from the number of input (``fan_in``) or output (``fan_out``)
+    units according to:
+
+    .. math::
+
+        \sigma = \gamma \sqrt{\frac{3.0}{\text{fan}}}
+
+    where :math:`\text{fan}` is either the number of input units when the
+    ``mode`` is ``"fan_in"`` or output units when the ``mode`` is
+    ``"fan_out"``.
+
+    For more details see the original reference: `Delving Deep into Rectifiers:
+    Surpassing Human-Level Performance on ImageNet Classification
+    <https://arxiv.org/abs/1502.01852>`_
+
+
+    Args:
+        dtype (Dtype, optional): The data type of the array. Default: ``float32``.
+
+    Returns:
+        Callable[[array, str, float], array]: An initializer that returns an
+        array with the same shape as the input, filled with samples from  the
+        He uniform distribution.
+
+    Example:
+
+        >>> init_fn = nn.init.he_uniform()
+        >>> init_fn(mx.zeros((2, 2)))  # uses fan_in
+        array([[0.0300242, -0.0184009],
+               [0.793615, 0.666329]], dtype=float32)
+        >>> init_fn(mx.zeros((2, 2)), mode="fan_out", gain=5)
+        array([[-1.64331, -2.16506],
+               [1.08619, 5.79854]], dtype=float32)
+    """
+
+    def initializer(
+        a: mx.array,
+        mode: Literal["fan_in", "fan_out"] = "fan_in",
+        gain: float = 1.0,
+    ) -> mx.array:
+        fan_in, fan_out = _calculate_fan_in_fan_out(a)
+        if mode == "fan_in":
+            fan = fan_in
+        elif mode == "fan_out":
+            fan = fan_out
+        else:
+            raise ValueError(f"Invalid mode: {mode}. Valid modes are: fan_in, fan_out")
+
+        limit = gain * math.sqrt(3.0 / fan)
+        return mx.random.uniform(-limit, limit, a.shape, dtype=dtype)
+
+    return initializer
+
+
+def sparse(
+    sparsity: float,
+    mean: float = 0.0,
+    std: float = 1.0,
+    dtype: mx.Dtype = mx.float32,
+) -> Callable[[mx.array], mx.array]:
+    r"""An initializer that returns a sparse matrix.
+
+    Args:
+        sparsity (float): The fraction of elements in each column to be set to
+        zero.
+        mean (float, optional): Mean of the normal distribution. Default:
+          ``0.0``.
+        std (float, optional): Standard deviation of the normal distribution.
+          Default: ``1.0``.
+        dtype (Dtype, optional): The data type of the array. Default:
+          ``float32``.
+
+    Returns:
+        Callable[[array], array]: An initializer that returns an array with the
+        same shape as the input, filled with samples from a normal distribution.
+
+    Example:
+
+        >>> init_fn = nn.init.sparse(sparsity=0.5)
+        >>> init_fn(mx.zeros((2, 2)))
+        array([[-1.91187, -0.117483],
+       [0, 0]], dtype=float32)
+    """
+
+    def initializer(a: mx.array) -> mx.array:
+        if a.ndim != 2:
+            raise ValueError("Only tensors with 2 dimensions are supported")
+
+        rows, cols = a.shape
+        num_zeros = int(math.ceil(sparsity * cols))
+
+        order = mx.argsort(mx.random.uniform(shape=a.shape), axis=1)
+        a = mx.random.normal(shape=a.shape, scale=std, loc=mean, dtype=dtype)
+
+        a[mx.arange(rows).reshape(rows, 1), order[:, :num_zeros]] = 0
+
+        return a
+
+    return initializer
+
+
+def orthogonal(
+    gain: float = 1.0, dtype: mx.Dtype = mx.float32
+) -> Callable[[mx.array], mx.array]:
+    r"""An initializer that returns an orthogonal matrix.
+
+    Args:
+        gain (float, optional): Scaling factor for the orthogonal matrix.
+            Default: ``1.0``.
+        dtype (Dtype, optional): Data type of the array. Default: ``float32``.
+
+    Returns:
+        Callable[[array], array]: An initializer that returns
+        an orthogonal matrix with the same shape as the input.
+    """
+
+    def initializer(a: mx.array) -> mx.array:
+        if a.ndim != 2:
+            raise ValueError(
+                f"Orthogonal initialization requires a 2D array but got"
+                " a {a.ndim}D array."
+            )
+
+        rows, cols = a.shape
+        n = max(rows, cols)
+
+        rmat = mx.random.normal(shape=(n, n))
+
+        # Perform QR decomposition on CPU
+        q, r = mx.linalg.qr(rmat, stream=mx.cpu)
+
+        # Adjust the sign of Q using the diagonal of R
+        d = mx.diag(r)
+        q = q * mx.sign(d)
+
+        # Slice Q to the desired shape
+        q = q[:rows, :cols]
+
+        # Scale Q by gain
+        q = q * gain
+        return q.astype(dtype)
+
+    return initializer
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/__init__.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea2d3029d8855ca3711c11580025ba891182676a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/__init__.py
@@ -0,0 +1,100 @@
+# Copyright © 2023 Apple Inc.
+
+from mlx.nn.layers.activations import (
+    CELU,
+    ELU,
+    GELU,
+    GLU,
+    SELU,
+    HardShrink,
+    Hardswish,
+    HardTanh,
+    LeakyReLU,
+    LogSigmoid,
+    LogSoftmax,
+    Mish,
+    PReLU,
+    ReLU,
+    ReLU2,
+    ReLU6,
+    Sigmoid,
+    SiLU,
+    Softmax,
+    Softmin,
+    Softplus,
+    Softshrink,
+    Softsign,
+    Step,
+    Tanh,
+    celu,
+    elu,
+    gelu,
+    gelu_approx,
+    gelu_fast_approx,
+    glu,
+    hard_shrink,
+    hard_tanh,
+    hardswish,
+    leaky_relu,
+    log_sigmoid,
+    log_softmax,
+    mish,
+    prelu,
+    relu,
+    relu2,
+    relu6,
+    selu,
+    sigmoid,
+    silu,
+    softmax,
+    softmin,
+    softplus,
+    softshrink,
+    softsign,
+    step,
+    tanh,
+)
+from mlx.nn.layers.base import Module
+from mlx.nn.layers.containers import Sequential
+from mlx.nn.layers.convolution import Conv1d, Conv2d, Conv3d
+from mlx.nn.layers.convolution_transpose import (
+    ConvTranspose1d,
+    ConvTranspose2d,
+    ConvTranspose3d,
+)
+from mlx.nn.layers.distributed import (
+    AllToShardedLinear,
+    QuantizedAllToShardedLinear,
+    QuantizedShardedToAllLinear,
+    ShardedToAllLinear,
+)
+from mlx.nn.layers.dropout import Dropout, Dropout2d, Dropout3d
+from mlx.nn.layers.embedding import Embedding
+from mlx.nn.layers.linear import Bilinear, Identity, Linear
+from mlx.nn.layers.normalization import (
+    BatchNorm,
+    GroupNorm,
+    InstanceNorm,
+    LayerNorm,
+    RMSNorm,
+)
+from mlx.nn.layers.pooling import (
+    AvgPool1d,
+    AvgPool2d,
+    AvgPool3d,
+    MaxPool1d,
+    MaxPool2d,
+    MaxPool3d,
+)
+from mlx.nn.layers.positional_encoding import ALiBi, RoPE, SinusoidalPositionalEncoding
+from mlx.nn.layers.quantized import QuantizedEmbedding, QuantizedLinear, quantize
+from mlx.nn.layers.recurrent import GRU, LSTM, RNN
+from mlx.nn.layers.transformer import (
+    MultiHeadAttention,
+    Transformer,
+    TransformerDecoder,
+    TransformerDecoderLayer,
+    TransformerEncoder,
+    TransformerEncoderLayer,
+)
+from mlx.nn.layers.upsample import Upsample
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/activations.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/activations.py
new file mode 100644
index 0000000000000000000000000000000000000000..360bb113d5a1cdecaba16f35068045329d77046f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/activations.py
@@ -0,0 +1,661 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from functools import partial
+from typing import Any
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+def _make_activation_module(f):
+    def decorator(klass):
+        klass.__call__ = lambda _, x: f(x)
+        return klass
+
+    return decorator
+
+
+@partial(mx.compile, shapeless=True)
+def sigmoid(x):
+    r"""Applies the sigmoid function.
+
+    .. math::
+        \text{Sigmoid}(x) = \sigma(x) = \frac{1}{1 + \exp(-x)}
+    """
+    return mx.sigmoid(x)
+
+
+@partial(mx.compile, shapeless=True)
+def relu(x):
+    r"""Applies the Rectified Linear Unit.
+
+    Simply ``mx.maximum(x, 0)``.
+    """
+    return mx.maximum(x, 0)
+
+
+@partial(mx.compile, shapeless=True)
+def relu2(x):
+    r"""Applies the ReLU² activation function.
+
+    Applies :math:`\max(0, x)^2` element wise.
+    """
+    return mx.square(mx.maximum(x, 0))
+
+
+@partial(mx.compile, shapeless=True)
+def relu6(x):
+    r"""Applies the Rectified Linear Unit 6.
+
+    Applies :math:`\min(\max(x, 0), 6)` element wise.
+    """
+    return mx.minimum(mx.maximum(x, 0), 6.0)
+
+
+@partial(mx.compile, shapeless=True)
+def leaky_relu(x, negative_slope=0.01):
+    r"""Applies the Leaky Rectified Linear Unit.
+
+    Simply ``mx.maximum(negative_slope * x, x)``.
+    """
+    return mx.maximum(negative_slope * x, x)
+
+
+@partial(mx.compile, shapeless=True)
+def log_softmax(x, axis=-1):
+    r"""Applies the Log Softmax function.
+
+    Applies :math:`x + \log \sum_i e^{x_i}` element wise.
+    """
+    return x - mx.logsumexp(x, axis=axis, keepdims=True)
+
+
+@partial(mx.compile, shapeless=True)
+def elu(x, alpha=1.0):
+    r"""Applies the Exponential Linear Unit.
+
+    Simply ``mx.where(x > 0, x, alpha * (mx.exp(x) - 1))``.
+    """
+    return mx.where(x > 0, x, alpha * (mx.exp(x) - 1))
+
+
+@partial(mx.compile, shapeless=True)
+def softmax(x, axis=-1):
+    r"""Applies the Softmax function.
+
+    Applies :math:`\frac{e^{x_i}}{\sum_j e^{x_j}}` element wise.
+    """
+    return mx.softmax(x, axis=axis)
+
+
+@partial(mx.compile, shapeless=True)
+def softplus(x):
+    r"""Applies the Softplus function.
+
+    Applies :math:`\log(1 + \exp(x))` element wise.
+    """
+    return mx.logaddexp(x, 0)
+
+
+@partial(mx.compile, shapeless=True)
+def softsign(x):
+    r"""Applies the Softsign function.
+
+    Applies :math:`\frac{x}{1 + |x|}` element wise.
+    """
+    return mx.divide(x, 1 + mx.abs(x))
+
+
+@partial(mx.compile, shapeless=True)
+def softshrink(x, lambd: float = 0.5):
+    r"""Applies the Softshrink activation function.
+
+    .. math::
+        \text{softshrink}(x) = \begin{cases}
+        x - \lambda & \text{if } x > \lambda \\
+        x + \lambda & \text{if } x < -\lambda \\
+        0 & \text{otherwise}
+        \end{cases}
+    """
+    return mx.where(mx.abs(x) > lambd, x - mx.sign(x) * lambd, 0)
+
+
+@partial(mx.compile, shapeless=True)
+def celu(x, alpha=1.0):
+    r"""Applies the Continuously Differentiable Exponential Linear Unit.
+
+    Applies :math:`\max(0, x) + \min(0, \alpha * (\exp(x / \alpha) - 1))`
+    element wise.
+    """
+    return mx.maximum(x, 0.0) + alpha * (mx.exp(mx.minimum(x, 0.0) / alpha) - 1)
+
+
+@partial(mx.compile, shapeless=True)
+def silu(x):
+    r"""Applies the Sigmoid Linear Unit. Also known as Swish.
+
+    Applies :math:`x \sigma(x)` element wise, where :math:`\sigma(\cdot)` is
+    the logistic sigmoid.
+    """
+    return x * mx.sigmoid(x)
+
+
+@partial(mx.compile, shapeless=True)
+def log_sigmoid(x):
+    r"""Applies the Log Sigmoid function.
+
+    Applies :math:`\log(\sigma(x)) = -\log(1 + e^{-x})` element wise.
+    """
+    return -softplus(-x)
+
+
+@partial(mx.compile, shapeless=True)
+def gelu(x) -> mx.array:
+    r"""Applies the Gaussian Error Linear Units function.
+
+    .. math::
+        \textrm{GELU}(x) = x * \Phi(x)
+
+    where :math:`\Phi(x)` is the Gaussian CDF.
+
+    See also :func:`gelu_approx` and :func:`gelu_fast_approx` for faster
+    approximations.
+    """
+    return x * (1 + mx.erf(x / math.sqrt(2))) / 2
+
+
+@partial(mx.compile, shapeless=True)
+def gelu_approx(x):
+    r"""An approximation to Gaussian Error Linear Unit.
+
+    See :func:`gelu` for the exact computation.
+
+    This function approximates ``gelu`` with a maximum absolute error :math:`<
+    0.0005` in the range :math:`[-6, 6]` using the following
+
+    .. math::
+
+        x = 0.5 * x * \left(1 + \text{Tanh}\left((\sqrt{2 / \pi} * \left(x + 0.044715 * x^3\right)\right)\right)
+
+    """
+    return 0.5 * x * (1 + mx.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * x**3)))
+
+
+@partial(mx.compile, shapeless=True)
+def gelu_fast_approx(x):
+    r"""A fast approximation to Gaussian Error Linear Unit.
+
+    See :func:`gelu` for the exact computation.
+
+    This function approximates ``gelu`` with a maximum absolute error :math:`<
+    0.015` in the range :math:`[-6, 6]` using the following
+
+    .. math::
+
+        x = x \sigma\left(1.702 x\right)
+
+    where :math:`\sigma(\cdot)` is the logistic sigmoid.
+
+    References:
+    - https://github.com/hendrycks/GELUs
+    - https://arxiv.org/abs/1606.08415
+    """
+    return x * mx.sigmoid(1.702 * x)
+
+
+def glu(x: mx.array, axis: int = -1) -> mx.array:
+    r"""Applies the gated linear unit function.
+
+    This function splits the ``axis`` dimension of the input into two halves
+    (:math:`a` and :math:`b`) and applies :math:`a * \sigma(b)`.
+
+    .. math::
+        \textrm{GLU}(x) = a * \sigma(b)
+
+    Args:
+        axis (int): The dimension to split along. Default: ``-1``
+    """
+    a, b = mx.split(x, indices_or_sections=2, axis=axis)
+    return a * mx.sigmoid(b)
+
+
+@partial(mx.compile, shapeless=True)
+def step(x: mx.array, threshold: float = 0.0):
+    r"""Applies the Step Activation Function.
+
+    This function implements a binary step activation, where the output is set
+    to 1 if the input is greater than a specified threshold, and 0 otherwise.
+
+    .. math::
+        \text{step}(x) = \begin{cases}
+        0 & \text{if } x < \text{threshold} \\
+        1 & \text{if } x \geq \text{threshold}
+        \end{cases}
+
+    Args:
+        threshold: The value to threshold at.
+    """
+
+    return mx.where(x > threshold, 1, 0)
+
+
+@partial(mx.compile, shapeless=True)
+def selu(x):
+    r"""Applies the Scaled Exponential Linear Unit.
+
+    .. math::
+        \text{selu}(x) = \begin{cases}
+        \lambda x & \text{if } x > 0 \\
+        \lambda \alpha (\exp(x) - 1) & \text{if } x \leq 0
+        \end{cases}
+
+    where :math:`\lambda = 1.0507` and :math:`\alpha = 1.67326`.
+
+    See also :func:`elu`.
+    """
+    return elu(x, 1.67326) * 1.0507
+
+
+@partial(mx.compile, shapeless=True)
+def prelu(x: mx.array, alpha: mx.array) -> mx.array:
+    r"""Applies the element-wise parametric ReLU.
+
+    .. math::
+        \text{PReLU}(x) = \max(0,x) + a * \min(0,x)
+
+    where :math:`a` is an array.
+    """
+    return mx.maximum(0, x) + alpha * mx.minimum(0, x)
+
+
+@partial(mx.compile, shapeless=True)
+def mish(x: mx.array) -> mx.array:
+    r"""Applies the Mish function, element-wise.
+
+    Mish: A Self Regularized Non-Monotonic Neural Activation Function.
+
+    Reference: https://arxiv.org/abs/1908.08681
+
+    .. math::
+        \text{Mish}(x) = x * \text{Tanh}(\text{Softplus}(x))
+
+    """
+    return x * mx.tanh(softplus(x))
+
+
+@partial(mx.compile, shapeless=True)
+def hardswish(x):
+    r"""Applies the hardswish function, element-wise.
+
+    .. math::
+        \text{Hardswish}(x) = x * \min(\max(x + 3, 0), 6) / 6
+    """
+    max_x_3 = mx.maximum(x + 3, 0)
+    return x * mx.minimum(max_x_3, 6) / 6
+
+
+@partial(mx.compile, shapeless=True)
+def hard_tanh(x, min_val=-1.0, max_val=1.0):
+    r"""Applies the HardTanh function.
+
+    Applies :math:`\max(\min(x, \text{max\_val}), \text{min\_val})` element-wise.
+    """
+    return mx.minimum(mx.maximum(x, min_val), max_val)
+
+
+@partial(mx.compile, shapeless=True)
+def hard_shrink(x, lambd=0.5):
+    r"""Applies the HardShrink activation function.
+
+    .. math::
+        \text{hardshrink}(x) = \begin{cases}
+        x & \text{if } x > \lambda \\
+        x & \text{if } x < -\lambda \\
+        0 & \text{otherwise}
+        \end{cases}
+    """
+    return mx.where(mx.abs(x) > lambd, x, 0)
+
+
+@partial(mx.compile, shapeless=True)
+def softmin(x, axis=-1):
+    r"""Applies the Softmin function.
+
+    Applies :math:`\frac{e^{-x_i}}{\sum_j e^{-x_j}}` element-wise.
+    """
+    return mx.softmax(-x, axis=axis)
+
+
+def tanh(x):
+    """Applies the hyperbolic tangent function.
+
+    Simply ``mx.tanh(x)``.
+    """
+    return mx.tanh(x)
+
+
+class GLU(Module):
+    r"""Applies the gated linear unit function.
+
+    This function splits the ``axis`` dimension of the input into two halves
+    (:math:`a` and :math:`b`) and applies :math:`a * \sigma(b)`.
+
+    .. math::
+        \textrm{GLU}(x) = a * \sigma(b)
+
+    Args:
+        axis (int): The dimension to split along. Default: ``-1``
+    """
+
+    def __init__(self, axis: int = -1):
+        super().__init__()
+        self.axis = axis
+
+    def __call__(self, x) -> Any:
+        return glu(x=x, axis=self.axis)
+
+
+@_make_activation_module(sigmoid)
+class Sigmoid(Module):
+    r"""Applies the sigmoid function, element-wise.
+
+    .. math::
+        \text{Sigmoid}(x) = \sigma(x) = \frac{1}{1 + \exp(-x)}
+    """
+
+
+@_make_activation_module(mish)
+class Mish(Module):
+    r"""Applies the Mish function, element-wise.
+
+    Reference: https://arxiv.org/abs/1908.08681
+
+    .. math::
+        \text{Mish}(x) = x * \text{Tanh}(\text{Softplus}(x))
+
+    """
+
+
+@_make_activation_module(relu)
+class ReLU(Module):
+    r"""Applies the Rectified Linear Unit.
+        Simply ``mx.maximum(x, 0)``.
+
+    See :func:`relu` for the functional equivalent.
+    """
+
+
+@_make_activation_module(relu2)
+class ReLU2(Module):
+    r"""Applies the ReLU² activation function.
+
+    See :func:`relu2` for the functional equivalent.
+    """
+
+
+@_make_activation_module(relu6)
+class ReLU6(Module):
+    r"""Applies the Rectified Linear Unit 6.
+
+    See :func:`relu6` for the functional equivalent.
+    """
+
+
+class LeakyReLU(Module):
+    r"""Applies the Leaky Rectified Linear Unit.
+
+    Simply ``mx.maximum(negative_slope * x, x)``.
+
+    Args:
+        negative_slope: Controls the angle of the negative slope. Default: ``1e-2``
+    """
+
+    def __init__(self, negative_slope=1e-2):
+        super().__init__()
+        self._negative_slope = negative_slope
+
+    def __call__(self, x):
+        return leaky_relu(x, self._negative_slope)
+
+
+class ELU(Module):
+    r"""Applies the Exponential Linear Unit.
+        Simply ``mx.where(x > 0, x, alpha * (mx.exp(x) - 1))``.
+
+    See :func:`elu` for the functional equivalent.
+
+    Args:
+        alpha: the :math:`\alpha` value for the ELU formulation. Default: ``1.0``
+    """
+
+    def __init__(self, alpha=1.0):
+        super().__init__()
+        self._alpha = alpha
+
+    def __call__(self, x):
+        return elu(x, self._alpha)
+
+
+@_make_activation_module(softmax)
+class Softmax(Module):
+    r"""Applies the Softmax function.
+
+    See :func:`softmax` for the functional equivalent.
+    """
+
+
+@_make_activation_module(softplus)
+class Softplus(Module):
+    r"""Applies the Softplus function.
+
+    See :func:`softplus` for the functional equivalent.
+    """
+
+
+@_make_activation_module(softsign)
+class Softsign(Module):
+    r"""Applies the Softsign function.
+
+    See :func:`softsign` for the functional equivalent.
+    """
+
+
+class Softshrink(Module):
+    r"""Applies the Softshrink function.
+
+    See :func:`softshrink` for the functional equivalent.
+
+    Args:
+        lambd: the :math:`\lambda` value for Softshrink. Default: ``0.5``
+    """
+
+    def __init__(self, lambd=0.5):
+        super().__init__()
+        self.lambd = lambd
+
+    def __call__(self, x):
+        return softshrink(x, self.lambd)
+
+
+class CELU(Module):
+    r"""Applies the Continuously Differentiable Exponential Linear Unit.
+        Applies :math:`\max(0, x) + \min(0, \alpha * (\exp(x / \alpha) - 1))`
+        element wise.
+
+    See :func:`celu` for the functional equivalent.
+
+    Args:
+        alpha: the :math:`\alpha` value for the CELU formulation. Default: ``1.0``
+    """
+
+    def __init__(self, alpha=1.0):
+        super().__init__()
+        self._alpha = alpha
+
+    def __call__(self, x):
+        return celu(x, self._alpha)
+
+
+@_make_activation_module(silu)
+class SiLU(Module):
+    r"""Applies the Sigmoid Linear Unit. Also known as Swish.
+
+    See :func:`silu` for the functional equivalent.
+    """
+
+
+@_make_activation_module(log_softmax)
+class LogSoftmax(Module):
+    r"""Applies the Log Softmax function.
+
+    See :func:`log_softmax` for the functional equivalent.
+    """
+
+
+@_make_activation_module(log_sigmoid)
+class LogSigmoid(Module):
+    r"""Applies the Log Sigmoid function.
+
+    See :func:`log_sigmoid` for the functional equivalent.
+    """
+
+
+class PReLU(Module):
+    r"""Applies the element-wise parametric ReLU.
+        Applies :math:`\max(0, x) + a * \min(0, x)` element wise, where :math:`a`
+        is an array.
+
+    See :func:`prelu` for the functional equivalent.
+
+    Args:
+        num_parameters: number of :math:`a` to learn. Default: ``1``
+        init: the initial value of :math:`a`. Default: ``0.25``
+    """
+
+    def __init__(self, num_parameters=1, init=0.25):
+        super().__init__()
+        self.weight = mx.full([num_parameters], init)
+
+    def __call__(self, x: mx.array):
+        return prelu(x, self.weight)
+
+
+class GELU(Module):
+    r"""Applies the Gaussian Error Linear Units.
+
+    .. math::
+        \textrm{GELU}(x) = x * \Phi(x)
+
+    where :math:`\Phi(x)` is the Gaussian CDF.
+
+    However, if ``approx`` is set to 'precise' or 'fast' it applies
+
+    .. math::
+        \textrm{GELUApprox}(x) &= 0.5 * x * \left(1 + \text{Tanh}\left((\sqrt{2 / \pi} * \left(x + 0.044715 * x^3\right)\right)\right) \\
+        \textrm{GELUFast}(x) &= x * \sigma\left(1.702 * x\right)
+
+    respectively.
+
+    .. note::
+       For compatibility with the PyTorch API, 'tanh' can be used as an alias
+       for 'precise'.
+
+    See :func:`gelu`, :func:`gelu_approx` and :func:`gelu_fast_approx` for the
+    functional equivalents and information regarding error bounds.
+
+
+    Args:
+        approx ('none' | 'precise' | 'fast'): Which approximation to gelu to use if any.
+    """
+
+    def __init__(self, approx="none"):
+        super().__init__()
+        self._approx = approx
+        allowed = ["none", "precise", "tanh", "fast"]
+        if approx not in allowed:
+            raise ValueError(
+                f"The approximation should be in {allowed} but '{approx}' was given"
+            )
+
+    def __call__(self, x):
+        if self._approx == "none":
+            return gelu(x)
+        elif self._approx in ["precise", "tanh"]:
+            return gelu_approx(x)
+        return gelu_fast_approx(x)
+
+
+@_make_activation_module(tanh)
+class Tanh(Module):
+    r"""Applies the hyperbolic tangent function.
+
+    See :func:`tanh` for the functional equivalent.
+    """
+
+
+@_make_activation_module(hardswish)
+class Hardswish(Module):
+    r"""Applies the hardswish function, element-wise.
+
+    See :func:`hardswish` for the functional equivalent.
+    """
+
+
+class Step(Module):
+    r"""Applies the Step Activation Function.
+
+    This function implements a binary step activation, where the output is set
+    to 1 if the input is greater than a specified threshold, and 0 otherwise.
+
+    .. math::
+        \text{step}(x) = \begin{cases}
+        0 & \text{if } x < \text{threshold} \\
+        1 & \text{if } x \geq \text{threshold}
+        \end{cases}
+
+    Args:
+        threshold: The value to threshold at.
+    """
+
+    def __init__(self, threshold: float = 0.0):
+        super().__init__()
+        self.threshold = threshold
+
+    def __call__(self, x: mx.array):
+        return step(x, self.threshold)
+
+
+@_make_activation_module(selu)
+class SELU(Module):
+    r"""Applies the Scaled Exponential Linear Unit.
+
+    See :func:`selu` for the functional equivalent.
+    """
+
+
+@_make_activation_module(hard_tanh)
+class HardTanh(Module):
+    r"""Applies the HardTanh function.
+
+    See :func:`hard_tanh` for the functional equivalent.
+    """
+
+
+@_make_activation_module(hard_shrink)
+class HardShrink(Module):
+    r"""Applies the HardShrink function.
+
+    See :func:`hard_shrink` for the functional equivalent.
+
+    Args:
+        lambd: the :math:`\lambda` value for Hardshrink. Default: ``0.5``
+    """
+
+
+@_make_activation_module(softmin)
+class Softmin(Module):
+    r"""Applies the Softmin function.
+
+    See :func:`softmin` for the functional equivalent.
+    """
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/base.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ae92727999dec83b3b4cb9f60598b4109eb228f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/base.py
@@ -0,0 +1,671 @@
+# Copyright © 2023 Apple Inc.
+
+from __future__ import annotations
+
+import textwrap
+from typing import Any, Callable, List, Optional, Tuple, Union
+
+import mlx.core as mx
+from mlx.utils import tree_flatten, tree_unflatten
+
+
+class Module(dict):
+    """Base class for building neural networks with MLX.
+
+    All the layers provided in :mod:`mlx.nn.layers` subclass this class and
+    your models should do the same.
+
+    A ``Module`` can contain other ``Module`` instances or :class:`mlx.core.array`
+    instances in arbitrary nesting of python lists or dicts. The ``Module``
+    then allows recursively extracting all the :class:`mlx.core.array` instances
+    using :meth:`mlx.nn.Module.parameters`.
+
+    In addition, the ``Module`` has the concept of trainable and non trainable
+    parameters (called "frozen"). When using :func:`mlx.nn.value_and_grad`
+    the gradients are returned only with respect to the trainable parameters.
+    All arrays in a module are trainable unless they are added in the "frozen"
+    set by calling :meth:`freeze`.
+
+    .. code-block:: python
+
+        import mlx.core as mx
+        import mlx.nn as nn
+
+        class MyMLP(nn.Module):
+            def __init__(self, in_dims: int, out_dims: int, hidden_dims: int = 16):
+                super().__init__()
+
+                self.in_proj = nn.Linear(in_dims, hidden_dims)
+                self.out_proj = nn.Linear(hidden_dims, out_dims)
+
+            def __call__(self, x):
+                x = self.in_proj(x)
+                x = mx.maximum(x, 0)
+                return self.out_proj(x)
+
+        model = MyMLP(2, 1)
+
+        # All the model parameters are created but since MLX is lazy by
+        # default, they are not evaluated yet. Calling `mx.eval` actually
+        # allocates memory and initializes the parameters.
+        mx.eval(model.parameters())
+
+        # Setting a parameter to a new value is as simply as accessing that
+        # parameter and assigning a new array to it.
+        model.in_proj.weight = model.in_proj.weight * 2
+        mx.eval(model.parameters())
+    """
+
+    __call__: Callable
+
+    def __init__(self):
+        """Should be called by the subclasses of ``Module``."""
+        self._no_grad = set()
+        self._training = True
+
+    @property
+    def training(self):
+        """Boolean indicating if the model is in training mode."""
+        return self._training
+
+    @property
+    def state(self):
+        """The module's state dictionary
+
+        The module's state dictionary contains any attribute set on the
+        module including parameters in :meth:`Module.parameters`
+
+        Unlike :meth:`Module.parameters`, the :attr:`Module.state` property is
+        a reference to the module's state. Updates to it will be reflected in
+        the original module.
+        """
+        return self
+
+    def _extra_repr(self) -> str:
+        return ""
+
+    def __repr__(self):
+        children = tree_flatten(self.children(), is_leaf=self.is_module)
+        value = f"{type(self).__name__}({self._extra_repr()}"
+        for k, v in children:
+            value += "\n"
+            value += textwrap.indent(f"({k}): {repr(v)}", prefix="  ")
+        if children:
+            value += "\n"
+        value += ")"
+
+        return value
+
+    def __getattr__(self, key: str):
+        if (value := self.get(key, None)) is not None:
+            return value
+        else:
+            super(Module, self).__getattribute__(key)
+
+    def __setattr__(self, key: str, val: Any):
+        if isinstance(val, (mx.array, dict, list, tuple)):
+            # If attribute was previously set but not in the
+            # dictionary, delete it so we pick it up in future
+            # calls to __getattr__
+            if hasattr(self, key) and key not in self:
+                delattr(self, key)
+            self[key] = val
+        else:
+            super(Module, self).__setattr__(key, val)
+            self.pop(key, None)
+
+    def __delattr__(self, name):
+        if (val := self.get(name, None)) is not None:
+            del self[name]
+        else:
+            super().__delattr__(name)
+
+    def load_weights(
+        self,
+        file_or_weights: Union[str, List[Tuple[str, mx.array]]],
+        strict: bool = True,
+    ) -> Module:
+        """
+        Update the model's weights from a ``.npz``, a ``.safetensors`` file, or a list.
+
+        Args:
+            file_or_weights (str or list(tuple(str, mx.array))): The path to
+                the weights ``.npz`` file (``.npz`` or ``.safetensors``) or a list
+                of pairs of parameter names and arrays.
+            strict (bool, optional): If ``True`` then checks that the provided
+              weights exactly match the parameters of the model. Otherwise,
+              only the weights actually contained in the model are loaded and
+              shapes are not checked. Default: ``True``.
+
+        Returns:
+            The module instance after updating the weights.
+
+        Example:
+
+            .. code-block:: python
+
+                import mlx.core as mx
+                import mlx.nn as nn
+                model = nn.Linear(10, 10)
+
+                # Load from file
+                model.load_weights("weights.npz")
+
+                # Load from .safetensors file
+                model.load_weights("weights.safetensors")
+
+                # Load from list
+                weights = [
+                    ("weight", mx.random.uniform(shape=(10, 10))),
+                    ("bias",  mx.zeros((10,))),
+                ]
+                model.load_weights(weights)
+
+                # Missing weight
+                weights = [
+                    ("weight", mx.random.uniform(shape=(10, 10))),
+                ]
+
+                # Raises a ValueError exception
+                model.load_weights(weights)
+
+                # Ok, only updates the weight but not the bias
+                model.load_weights(weights, strict=False)
+        """
+        weights = file_or_weights
+        if isinstance(weights, str):
+            weights = list(mx.load(weights).items())
+
+        if strict:
+            new_weights = dict(weights)
+            curr_weights = tree_flatten(self.parameters(), destination={})
+            if extras := (new_weights.keys() - curr_weights.keys()):
+                num_extra = len(extras)
+                extras = ",\n".join(sorted(extras))
+                raise ValueError(
+                    f"Received {num_extra} parameters not in model: \n{extras}."
+                )
+            if missing := (curr_weights.keys() - new_weights.keys()):
+                num_missing = len(missing)
+                missing = ",\n".join(sorted(missing))
+                raise ValueError(f"Missing {num_missing} parameters: \n{missing}.")
+            for k, v in curr_weights.items():
+                v_new = new_weights[k]
+                if not isinstance(v_new, mx.array):
+                    raise ValueError(
+                        "Expected mx.array but received "
+                        f"{type(v_new)} for parameter {k}"
+                    )
+                if v_new.shape != v.shape:
+                    raise ValueError(
+                        f"Expected shape {v.shape} but received "
+                        f"shape {v_new.shape} for parameter {k}"
+                    )
+
+        if len(weights) != 0:
+            self.update(tree_unflatten(weights), strict=False)
+        return self
+
+    def save_weights(self, file: str):
+        """
+        Save the model's weights to a file. The saving method is determined by the file extension:
+        - ``.npz`` will use :func:`mx.savez`
+        - ``.safetensors`` will use :func:`mx.save_safetensors`
+        """
+        params_dict = tree_flatten(self.parameters(), destination={})
+
+        if file.endswith(".npz"):
+            mx.savez(file, **params_dict)
+        elif file.endswith(".safetensors"):
+            mx.save_safetensors(file, params_dict)
+        else:
+            raise ValueError(
+                f"Unsupported file extension for {file}. Use '.npz' or '.safetensors'."
+            )
+
+    @staticmethod
+    def is_module(value):
+        return isinstance(value, Module)
+
+    @staticmethod
+    def valid_child_filter(module, key, value):
+        return isinstance(value, (dict, list))
+
+    @staticmethod
+    def valid_parameter_filter(module, key, value):
+        return isinstance(value, (dict, list, mx.array)) and not key.startswith("_")
+
+    @staticmethod
+    def trainable_parameter_filter(module, key, value):
+        return (
+            Module.valid_parameter_filter(module, key, value)
+            and key not in module._no_grad
+        )
+
+    def filter_and_map(
+        self,
+        filter_fn: Callable[[Module, str, Any], bool],
+        map_fn: Optional[Callable] = None,
+        is_leaf_fn: Optional[Callable[[Module, str, Any], bool]] = None,
+    ):
+        """Recursively filter the contents of the module using ``filter_fn``,
+        namely only select keys and values where ``filter_fn`` returns true.
+
+        This is used to implement :meth:`parameters` and :meth:`trainable_parameters`
+        but it can also be used to extract any subset of the module's parameters.
+
+        Args:
+            filter_fn (Callable): Given a value, the key in which it is found
+                and the containing module, decide whether to keep the value or
+                drop it.
+            map_fn (Callable, optional): Optionally transform the value before
+                returning it.
+            is_leaf_fn (Callable, optional): Given a value, the key in which it
+                is found and the containing module decide if it is a leaf.
+
+        Returns:
+            A dictionary containing the contents of the module recursively filtered
+        """
+
+        map_fn = map_fn or (lambda x: x)
+        is_leaf_fn = is_leaf_fn or (
+            lambda m, k, v: not isinstance(v, (Module, dict, list))
+        )
+        return {
+            k: _unwrap(self, k, v, filter_fn, map_fn, is_leaf_fn)
+            for k, v in self.items()
+            if filter_fn(self, k, v)
+        }
+
+    def parameters(self):
+        """Recursively return all the :class:`mlx.core.array` members of this Module
+        as a dict of dicts and lists."""
+        return self.filter_and_map(self.valid_parameter_filter)
+
+    def trainable_parameters(self):
+        """Recursively return all the non frozen :class:`mlx.core.array` members of
+        this Module as a dict of dicts and lists."""
+        return self.filter_and_map(self.trainable_parameter_filter)
+
+    def children(self):
+        """Return the direct descendants of this Module instance."""
+        return self.filter_and_map(
+            self.valid_child_filter, is_leaf_fn=lambda m, k, v: isinstance(v, Module)
+        )
+
+    def leaf_modules(self):
+        """Return the submodules that do not contain other modules."""
+
+        def _is_leaf_module(m, k, v):
+            return isinstance(v, Module) and len(tree_flatten(v.children())) == 0
+
+        return self.filter_and_map(self.valid_child_filter, is_leaf_fn=_is_leaf_module)
+
+    def update(self, parameters: dict, strict: bool = True) -> Module:
+        """Replace the parameters of this Module with the provided ones in the
+        dict of dicts and lists.
+
+        Commonly used by the optimizer to change the model to the updated
+        (optimized) parameters. Also used by the :meth:`mlx.nn.value_and_grad` to set the
+        tracers in the model in order to compute gradients.
+
+        The passed in parameters dictionary need not be a full dictionary
+        similar to :meth:`parameters`. Only the provided locations will be
+        updated.
+
+        Args:
+            parameters (dict): A complete or partial dictionary of the modules
+                parameters.
+            strict (bool): If ``True`` checks that ``parameters`` is a
+                subset of the module's parameters. Default: ``True``.
+        Returns:
+            The module instance after updating the parameters.
+        """
+
+        def apply(dst, parameters):
+            if isinstance(parameters, dict):
+                for k in parameters:
+                    if k in dst:
+                        current_value = dst[k]
+                        new_value = parameters[k]
+                        if isinstance(current_value, mx.array):
+                            if strict and not isinstance(new_value, mx.array):
+                                raise ValueError(
+                                    f"Received invalid type: {type(new_value).__name__}."
+                                )
+                            dst[k] = new_value
+                        else:
+                            apply(current_value, new_value)
+                    elif strict:
+                        raise ValueError(f'Module does not have parameter named "{k}".')
+            elif isinstance(parameters, list):
+                for i in range(len(parameters)):
+                    current_value = dst[i]
+                    new_value = parameters[i]
+                    if isinstance(current_value, mx.array):
+                        if strict and not isinstance(new_value, mx.array):
+                            raise ValueError(
+                                f"Received invalid type: {type(new_value).__name__}."
+                            )
+                        dst[i] = new_value
+                    else:
+                        apply(current_value, new_value)
+            elif strict:
+                raise ValueError(f"Received invalid type: {type(parameters).__name__}.")
+
+        apply(self, parameters)
+        return self
+
+    def apply(
+        self,
+        map_fn: Callable[[mx.array], mx.array],
+        filter_fn: Optional[Callable[[Module, str, Any], bool]] = None,
+    ) -> Module:
+        """Map all the parameters using the provided ``map_fn`` and immediately
+        update the module with the mapped parameters.
+
+        For instance running ``model.apply(lambda x: x.astype(mx.float16))``
+        casts all parameters to 16 bit floats.
+
+        Args:
+            map_fn (Callable): Maps an array to another array
+            filter_fn (Callable, optional): Filter to select which arrays to
+                map (default: :meth:`Module.valid_parameter_filter`).
+
+        Returns:
+            The module instance after updating the parameters.
+        """
+        filter_fn = filter_fn or Module.valid_parameter_filter
+        self.update(self.filter_and_map(filter_fn, map_fn))
+        return self
+
+    def update_modules(self, modules: dict, strict: bool = True) -> Module:
+        """Replace the child modules of this :class:`Module` instance with the
+        provided ones in the dict of dicts and lists.
+
+        It is the equivalent of :meth:`Module.update` but for modules instead
+        of parameters and allows us to flexibly edit complex architectures by
+        programmatically swapping layers.
+
+        The passed in parameters dictionary need not be a full dictionary
+        similar to :meth:`modules`. Only the provided locations will be
+        updated.
+
+        Args:
+            modules (dict): A complete or partial dictionary of the module's
+                submodules.
+            strict (bool): If ``True`` checks that ``modules`` is a
+                subset of the child modules of this instance. Default: ``True``.
+        Returns:
+            The module instance after updating the submodules.
+        """
+        _update_modules(self, modules, strict)
+        return self
+
+    def apply_to_modules(self, apply_fn: Callable[[str, Module], Any]) -> Module:
+        """Apply a function to all the modules in this instance (including this
+        instance).
+
+        Args:
+            apply_fn (Callable): The function to apply to the modules.
+
+        Returns:
+            The module instance after updating submodules.
+        """
+        module_stack = [("", self)]
+        while module_stack:
+            prefix, mod = module_stack.pop()
+            apply_fn(prefix, mod)
+            prefix = "." + prefix if prefix else ""
+            module_stack.extend(
+                tree_flatten(mod.children(), prefix=prefix, is_leaf=self.is_module)
+            )
+        return self
+
+    def modules(self):
+        """Return a list with all the modules in this instance.
+
+        Returns:
+            A list of :class:`mlx.nn.Module` instances.
+        """
+        modulelist = []
+        self.apply_to_modules(lambda k, m: modulelist.append(m))
+        return modulelist
+
+    def named_modules(self):
+        """Return a list with all the modules in this instance and their name
+        with dot notation.
+
+        Returns:
+            A list of tuples (str, :class:`mlx.nn.Module`).
+        """
+        modulelist = []
+        self.apply_to_modules(lambda k, m: modulelist.append((k, m)))
+        return modulelist
+
+    def _validate_keys(self, keys, strict):
+        keys = keys if isinstance(keys, list) else [keys]
+        if strict:
+            for k in keys:
+                if k not in self:
+                    raise KeyError(f"Module doesn't contain member {k}.")
+        return keys
+
+    def freeze(
+        self,
+        *,
+        recurse: bool = True,
+        keys: Optional[Union[str, List[str]]] = None,
+        strict: bool = False,
+    ) -> Module:
+        """Freeze the Module's parameters or some of them. Freezing a parameter means not
+        computing gradients for it.
+
+        This function is idempotent i.e. freezing a frozen model is a no-op.
+
+        Example:
+            For instance to only train the attention parameters from a Transformer:
+
+            .. code-block:: python
+
+                model = nn.Transformer()
+                model.freeze()
+                model.apply_to_modules(lambda k, v: v.unfreeze() if k.endswith("attention") else None)
+
+        Args:
+            recurse (bool, optional): If True then freeze the parameters of the
+                submodules as well. Default: ``True``.
+            keys (str or list[str], optional): If provided then only these
+                parameters will be frozen otherwise all the parameters of a
+                module. For instance freeze all biases by calling
+                ``module.freeze(keys="bias")``.
+            strict (bool, optional): If set to ``True`` validate that the passed keys exist.
+                Default: ``False``.
+
+        Returns:
+            The module instance after freezing the parameters.
+        """
+
+        def _freeze_impl(_, m):
+            local_keys = keys
+            if local_keys is None:
+                local_keys = tree_flatten(
+                    m.filter_and_map(
+                        lambda m, k, v: (not isinstance(v, Module))
+                        and m.valid_parameter_filter(m, k, v)
+                    )
+                )
+                local_keys = [k for (k, v) in local_keys]
+
+            local_keys = m._validate_keys(local_keys, strict)
+            m._no_grad.update(local_keys)
+
+        if recurse:
+            self.apply_to_modules(_freeze_impl)
+        else:
+            _freeze_impl("", self)
+        return self
+
+    def unfreeze(
+        self,
+        *,
+        recurse: bool = True,
+        keys: Optional[Union[str, List[str]]] = None,
+        strict: bool = False,
+    ) -> Module:
+        """Unfreeze the Module's parameters or some of them.
+
+        This function is idempotent ie unfreezing a model that is not frozen is
+        a noop.
+
+        Example:
+
+            For instance to only train the biases of a Transformer one can do:
+
+            .. code-block:: python
+
+                model = nn.Transformer()
+                model.freeze()
+                model.unfreeze(keys="bias")
+
+        Args:
+            recurse (bool, optional): If True then unfreeze the parameters of the
+                submodules as well. Default: ``True``.
+            keys (str or list[str], optional): If provided then only these
+                parameters will be unfrozen otherwise all the parameters of a
+                module. For instance unfreeze all biases by calling
+                ``module.unfreeze(keys="bias")``.
+            strict (bool, optional): If set to ``True`` validate that the passed keys exist.
+                Default: ``False``.
+
+        Returns:
+            The module instance after unfreezing the parameters.
+        """
+
+        def _unfreeze_impl(_, m):
+            if keys is None:
+                m._no_grad.clear()
+
+            else:
+                local_keys = m._validate_keys(keys, strict)
+                m._no_grad.difference_update(local_keys)
+
+        if recurse:
+            self.apply_to_modules(_unfreeze_impl)
+        else:
+            _unfreeze_impl("", self)
+        return self
+
+    def train(self, mode: bool = True) -> Module:
+        """Set the model in or out of training mode.
+
+        Training mode only applies to certain layers. For example
+        :obj:`Dropout` applies a random mask in training mode, but is the
+        identity in evaluation mode.
+
+        Args:
+            mode (bool): Indicate if the model should be in training or
+                evaluation mode. Default: ``True``.
+        Returns:
+            The module instance after updating the training mode.
+        """
+
+        def _set_train(_, m):
+            m._training = mode
+
+        self.apply_to_modules(_set_train)
+        return self
+
+    def eval(self) -> Module:
+        """Set the model to evaluation mode.
+
+        See :func:`train`.
+        """
+        return self.train(False)
+
+    def set_dtype(
+        self,
+        dtype: mx.Dtype,
+        predicate: Optional[Callable[[mx.Dtype], bool]] = lambda x: mx.issubdtype(
+            x, mx.floating
+        ),
+    ):
+        """Set the dtype of the module's parameters.
+
+        Args:
+            dtype (Dtype): The new dtype.
+            predicate (typing.Callable, optional): A predicate to select
+              parameters to cast. By default, only parameters of type
+              :attr:`floating` will be updated to avoid casting integer
+              parameters to the new dtype.
+        """
+        if predicate is None:
+            predicate = lambda _: True
+
+        self.apply(lambda x: x.astype(dtype) if predicate(x.dtype) else x)
+
+
+def _update_modules(dst, modules, strict):
+    if isinstance(modules, dict):
+        for k in modules:
+            if k in dst:
+                current_value = dst[k]
+                new_value = modules[k]
+                if Module.is_module(current_value) and Module.is_module(new_value):
+                    dst[k] = new_value
+                elif isinstance(current_value, (dict, list)):
+                    _update_modules(current_value, new_value, strict)
+                elif strict and new_value != {}:
+                    raise ValueError(
+                        f"Received invalid type: {type(new_value).__name__}."
+                    )
+            elif strict:
+                raise ValueError(f'Module does not have sub-module named "{k}".')
+    elif isinstance(modules, list):
+        for i in range(len(modules)):
+            current_value = dst[i]
+            new_value = modules[i]
+            if Module.is_module(current_value) and Module.is_module(new_value):
+                dst[i] = new_value
+            elif isinstance(current_value, (dict, list)):
+                _update_modules(current_value, new_value, strict)
+            elif strict and new_value != {}:
+                raise ValueError(f"Received invalid type: {type(new_value).__name__}.")
+    elif strict:
+        raise ValueError(f"Received invalid type: {type(modules).__name__}.")
+
+
+def _unwrap(model, value_key, value, filter_fn, map_fn, is_leaf_fn):
+    if is_leaf_fn(model, value_key, value):
+        return map_fn(value)
+
+    elif isinstance(value, Module):
+        return {
+            k: _unwrap(value, k, v, filter_fn, map_fn, is_leaf_fn)
+            for k, v in value.items()
+            if filter_fn(value, k, v)
+        }
+
+    elif isinstance(value, dict):
+        nd = {}
+        for k, v in value.items():
+            tk = f"{value_key}.{k}"
+            nd[k] = (
+                _unwrap(model, tk, v, filter_fn, map_fn, is_leaf_fn)
+                if filter_fn(model, tk, v)
+                else {}
+            )
+        return nd
+
+    elif isinstance(value, list):
+        nl = []
+        for i, vi in enumerate(value):
+            tk = f"{value_key}.{i}"
+            nl.append(
+                _unwrap(model, tk, vi, filter_fn, map_fn, is_leaf_fn)
+                if filter_fn(model, tk, vi)
+                else {}
+            )
+        return nl
+
+    raise RuntimeError("Unexpected leaf found while traversing the module")
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/containers.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/containers.py
new file mode 100644
index 0000000000000000000000000000000000000000..c57fbb9922b494e72f830419cd5e0277c311dd4b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/containers.py
@@ -0,0 +1,24 @@
+# Copyright © 2023 Apple Inc.
+
+from mlx.nn.layers.base import Module
+
+
+class Sequential(Module):
+    """A layer that calls the passed callables in order.
+
+    We can pass either modules or plain callables to the Sequential module. If
+    our functions have learnable parameters they should be implemented as
+    ``nn.Module`` instances.
+
+    Args:
+        modules (tuple of Callables): The modules to call in order
+    """
+
+    def __init__(self, *modules):
+        super().__init__()
+        self.layers = list(modules)
+
+    def __call__(self, x):
+        for m in self.layers:
+            x = m(x)
+        return x
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/convolution.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/convolution.py
new file mode 100644
index 0000000000000000000000000000000000000000..88b97add0d89a7378f969fc68fc92e6a5bd75eb3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/convolution.py
@@ -0,0 +1,232 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Union
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class Conv1d(Module):
+    """Applies a 1-dimensional convolution over the multi-channel input sequence.
+
+    The channels are expected to be last i.e. the input shape should be ``NLC`` where:
+
+    * ``N`` is the batch dimension
+    * ``L`` is the sequence length
+    * ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels
+        out_channels (int): The number of output channels
+        kernel_size (int): The size of the convolution filters
+        stride (int, optional): The stride when applying the filter.
+            Default: ``1``.
+        padding (int, optional): How many positions to 0-pad the input with.
+            Default: ``0``.
+        dilation (int, optional): The dilation of the convolution.
+        groups (int, optional): The number of groups for the convolution.
+            Default: ``1``.
+        bias (bool, optional): If ``True`` add a learnable bias to the output.
+            Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: int,
+        stride: int = 1,
+        padding: int = 0,
+        dilation: int = 1,
+        groups: int = 1,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        if in_channels % groups != 0:
+            raise ValueError(
+                f"The number of input channels ({in_channels}) must be "
+                f"divisible by the number of groups ({groups})"
+            )
+
+        scale = math.sqrt(1 / (in_channels * kernel_size))
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, kernel_size, in_channels // groups),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.dilation = dilation
+        self.stride = stride
+        self.groups = groups
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1]}, stride={self.stride}, "
+            f"padding={self.padding}, dilation={self.dilation}, "
+            f"groups={self.groups}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv1d(
+            x, self.weight, self.stride, self.padding, self.dilation, self.groups
+        )
+        if "bias" in self:
+            y = y + self.bias
+        return y
+
+
+class Conv2d(Module):
+    """Applies a 2-dimensional convolution over the multi-channel input image.
+
+    The channels are expected to be last i.e. the input shape should be ``NHWC`` where:
+
+    * ``N`` is the batch dimension
+    * ``H`` is the input image height
+    * ``W`` is the input image width
+    * ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        kernel_size (int or tuple): The size of the convolution filters.
+        stride (int or tuple, optional): The size of the stride when
+            applying the filter. Default: ``1``.
+        padding (int or tuple, optional): How many positions to 0-pad
+            the input with. Default: ``0``.
+        dilation (int or tuple, optional): The dilation of the convolution.
+        groups (int, optional): The number of groups for the convolution.
+            Default: ``1``.
+        bias (bool, optional): If ``True`` add a learnable bias to the
+            output. Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: Union[int, tuple],
+        stride: Union[int, tuple] = 1,
+        padding: Union[int, tuple] = 0,
+        dilation: Union[int, tuple] = 1,
+        groups: int = 1,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        if in_channels % groups != 0:
+            raise ValueError(
+                f"The number of input channels ({in_channels}) must be "
+                f"divisible by the number of groups ({groups})"
+            )
+
+        kernel_size, stride, padding = map(
+            lambda x: (x, x) if isinstance(x, int) else x,
+            (kernel_size, stride, padding),
+        )
+        scale = math.sqrt(1 / (in_channels * kernel_size[0] * kernel_size[1]))
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, *kernel_size, in_channels // groups),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.stride = stride
+        self.dilation = dilation
+        self.groups = groups
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1:3]}, stride={self.stride}, "
+            f"padding={self.padding}, dilation={self.dilation}, "
+            f"groups={self.groups}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv2d(
+            x, self.weight, self.stride, self.padding, self.dilation, self.groups
+        )
+        if "bias" in self:
+            y = y + self.bias
+        return y
+
+
+class Conv3d(Module):
+    """Applies a 3-dimensional convolution over the multi-channel input image.
+
+    The channels are expected to be last i.e. the input shape should be ``NDHWC`` where:
+
+    * ``N`` is the batch dimension
+    * ``D`` is the input image depth
+    * ``H`` is the input image height
+    * ``W`` is the input image width
+    * ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        kernel_size (int or tuple): The size of the convolution filters.
+        stride (int or tuple, optional): The size of the stride when
+            applying the filter. Default: ``1``.
+        dilation (int or tuple, optional): The dilation of the convolution.
+        padding (int or tuple, optional): How many positions to 0-pad
+            the input with. Default: ``0``.
+        bias (bool, optional): If ``True`` add a learnable bias to the
+            output. Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: Union[int, tuple],
+        stride: Union[int, tuple] = 1,
+        padding: Union[int, tuple] = 0,
+        dilation: Union[int, tuple] = 1,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        kernel_size, stride, padding = map(
+            lambda x: (x, x, x) if isinstance(x, int) else x,
+            (kernel_size, stride, padding),
+        )
+        scale = math.sqrt(
+            1 / (in_channels * kernel_size[0] * kernel_size[1] * kernel_size[2])
+        )
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, *kernel_size, in_channels),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.stride = stride
+        self.dilation = dilation
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1:4]}, stride={self.stride}, "
+            f"padding={self.padding}, dilation={self.dilation}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv3d(x, self.weight, self.stride, self.padding, self.dilation)
+        if "bias" in self:
+            y = y + self.bias
+        return y
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/convolution_transpose.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/convolution_transpose.py
new file mode 100644
index 0000000000000000000000000000000000000000..a11c4cb40379fc9b9398d15a1da411ce9d7ef4a3
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/convolution_transpose.py
@@ -0,0 +1,242 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Union
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class ConvTranspose1d(Module):
+    """Applies a 1-dimensional transposed convolution over the multi-channel input sequence.
+
+    The channels are expected to be last i.e. the input shape should be ``NLC`` where:
+
+    * ``N`` is the batch dimension
+    * ``L`` is the sequence length
+    * ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels
+        out_channels (int): The number of output channels
+        kernel_size (int): The size of the convolution filters
+        stride (int, optional): The stride when applying the filter.
+            Default: ``1``.
+        padding (int, optional): How many positions to 0-pad the input with.
+            Default: ``0``.
+        dilation (int, optional): The dilation of the convolution.
+        output_padding(int, optional): Additional size added to one side of the
+            output shape. Default: ``0``.
+        bias (bool, optional): If ``True`` add a learnable bias to the output.
+            Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: int,
+        stride: int = 1,
+        padding: int = 0,
+        dilation: int = 1,
+        output_padding: int = 0,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        scale = math.sqrt(1 / (in_channels * kernel_size))
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, kernel_size, in_channels),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.dilation = dilation
+        self.stride = stride
+        self.output_padding = output_padding
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1]}, stride={self.stride}, "
+            f"padding={self.padding}, dilation={self.dilation}, "
+            f"output_padding={self.output_padding}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv_transpose1d(
+            x,
+            self.weight,
+            self.stride,
+            self.padding,
+            self.dilation,
+            self.output_padding,
+        )
+        if "bias" in self:
+            y = y + self.bias
+        return y
+
+
+class ConvTranspose2d(Module):
+    """Applies a 2-dimensional transposed convolution over the multi-channel input image.
+
+    The channels are expected to be last i.e. the input shape should be ``NHWC`` where:
+
+    * ``N`` is the batch dimension
+    * ``H`` is the input image height
+    * ``W`` is the input image width
+    * ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        kernel_size (int or tuple): The size of the convolution filters.
+        stride (int or tuple, optional): The size of the stride when
+            applying the filter. Default: ``1``.
+        padding (int or tuple, optional): How many positions to 0-pad
+            the input with. Default: ``0``.
+        dilation (int or tuple, optional): The dilation of the convolution.
+        output_padding(int or tuple, optional): Additional size added to one
+            side of the output shape. Default: ``0``.
+        bias (bool, optional): If ``True`` add a learnable bias to the
+            output. Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: Union[int, tuple],
+        stride: Union[int, tuple] = 1,
+        padding: Union[int, tuple] = 0,
+        dilation: Union[int, tuple] = 1,
+        output_padding: Union[int, tuple] = 0,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        kernel_size, stride, padding, output_padding = map(
+            lambda x: (x, x) if isinstance(x, int) else x,
+            (kernel_size, stride, padding, output_padding),
+        )
+        scale = math.sqrt(1 / (in_channels * kernel_size[0] * kernel_size[1]))
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, *kernel_size, in_channels),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.stride = stride
+        self.dilation = dilation
+        self.output_padding = output_padding
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1:2]}, stride={self.stride}, "
+            f"padding={self.padding}, dilation={self.dilation}, "
+            f"output_padding={self.output_padding}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv_transpose2d(
+            x,
+            self.weight,
+            self.stride,
+            self.padding,
+            self.dilation,
+            self.output_padding,
+        )
+        if "bias" in self:
+            y = y + self.bias
+        return y
+
+
+class ConvTranspose3d(Module):
+    """Applies a 3-dimensional transposed convolution over the multi-channel input image.
+
+    The channels are expected to be last i.e. the input shape should be ``NDHWC`` where:
+
+    * ``N`` is the batch dimension
+    * ``D`` is the input image depth
+    * ``H`` is the input image height
+    * ``W`` is the input image width
+    * ``C`` is the number of input channels
+
+    Args:
+        in_channels (int): The number of input channels.
+        out_channels (int): The number of output channels.
+        kernel_size (int or tuple): The size of the convolution filters.
+        stride (int or tuple, optional): The size of the stride when
+            applying the filter. Default: ``1``.
+        padding (int or tuple, optional): How many positions to 0-pad
+            the input with. Default: ``0``.
+        dilation (int or tuple, optional): The dilation of the convolution.
+        output_padding(int or tuple, optional): Additional size added to one
+            side of the output shape. Default: ``0``.
+        bias (bool, optional): If ``True`` add a learnable bias to the
+            output. Default: ``True``
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: Union[int, tuple],
+        stride: Union[int, tuple] = 1,
+        padding: Union[int, tuple] = 0,
+        dilation: Union[int, tuple] = 1,
+        output_padding: Union[int, tuple] = 0,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        kernel_size, stride, padding, output_padding = map(
+            lambda x: (x, x, x) if isinstance(x, int) else x,
+            (kernel_size, stride, padding, output_padding),
+        )
+        scale = math.sqrt(
+            1 / (in_channels * kernel_size[0] * kernel_size[1] * kernel_size[2])
+        )
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(out_channels, *kernel_size, in_channels),
+        )
+        if bias:
+            self.bias = mx.zeros((out_channels,))
+
+        self.padding = padding
+        self.stride = stride
+        self.dilation = dilation
+        self.output_padding = output_padding
+
+    def _extra_repr(self):
+        return (
+            f"{self.weight.shape[-1]}, {self.weight.shape[0]}, "
+            f"kernel_size={self.weight.shape[1:3]}, stride={self.stride}, "
+            f"padding={self.padding}, dilation={self.dilation}, "
+            f"output_padding={self.output_padding}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x):
+        y = mx.conv_transpose3d(
+            x,
+            self.weight,
+            self.stride,
+            self.padding,
+            self.dilation,
+            self.output_padding,
+        )
+        if "bias" in self:
+            y = y + self.bias
+        return y
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/distributed.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/distributed.py
new file mode 100644
index 0000000000000000000000000000000000000000..92acde8f60185b93068241c8745739d8977a14f1
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/distributed.py
@@ -0,0 +1,599 @@
+# Copyright © 2024 Apple Inc.
+
+import math
+from functools import lru_cache
+from typing import Callable, Optional, Union
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+from mlx.nn.layers.linear import Linear
+from mlx.nn.layers.quantized import QuantizedLinear
+from mlx.utils import tree_map_with_path
+
+
+@lru_cache
+def sum_gradients(group):
+    if group.size() == 1:
+        return lambda x: x
+
+    @mx.custom_function
+    def f(x):
+        return x
+
+    @f.vjp
+    def f(x, dx, _):
+        return mx.distributed.all_sum(dx, group=group)
+
+    return f
+
+
+def _split(weight, segments, axis):
+    """Equivalent to mx.split but allows for fractional segments."""
+    if isinstance(segments, int) or isinstance(segments[0], int):
+        return mx.split(weight, segments, axis=axis)
+
+    N = weight.shape[axis]
+    indices = [int(s * N) for s in segments]
+    return mx.split(weight, indices, axis=axis)
+
+
+def _shard(
+    parameters: dict,
+    sharding_predicate: Callable,
+    group: Optional[mx.distributed.Group] = None,
+):
+    """Returns a new parameter tree with the weights sharded according to the
+    sharding_predicate.
+
+    The sharding predicate should return the sharding axis and optionally also
+    the segments that comprise the weight.
+    """
+    group = group or mx.distributed.init()
+    N = group.size()
+    r = group.rank()
+
+    def _shard_fn(path, weight):
+        if not isinstance(weight, mx.array):
+            return weight
+
+        s = sharding_predicate(path, weight)
+        if s is None:
+            return weight
+
+        axis = None
+        segments = 1
+        if isinstance(s, int):
+            axis = s
+        elif isinstance(s, tuple):
+            axis, segments = s
+        else:
+            raise ValueError(
+                "The sharding function should return int or tuple[int, list]"
+            )
+
+        return mx.contiguous(
+            mx.concatenate(
+                [_split(part, N, axis)[r] for part in _split(weight, segments, axis)],
+                axis=axis,
+            )
+        )
+
+    return tree_map_with_path(_shard_fn, parameters)
+
+
+def _all_to_sharded(segments):
+    """Simple predicate to shard fully connected layers such that a common
+    representation becomes a sharded representation."""
+
+    def _shard_fn(path, weight):
+        return max(weight.ndim - 2, 0), segments
+
+    return _shard_fn
+
+
+def _sharded_to_all(segments):
+    """Simple predicate to shard fully connected layers such that a sharded
+    representation becomes a common representation."""
+
+    def _shard_fn(path, weight):
+        if path.endswith("bias"):
+            return None
+        return -1, segments
+
+    return _shard_fn
+
+
+def _check_sharding(sharding):
+    if sharding not in ("all-to-sharded", "sharded-to-all"):
+        raise ValueError(
+            (
+                f"Sharding type {sharding=} not supported, "
+                "choose one of 'all-to-sharded' or 'sharded-to-all'"
+            )
+        )
+
+
+def shard_inplace(
+    module: Module,
+    sharding: Union[str, Callable],
+    *,
+    segments: Union[int, list] = 1,
+    group: Optional[mx.distributed.Group] = None,
+):
+    """Shard a module in-place by updating its parameter dictionary with the
+    sharded parameter dictionary.
+
+    The ``sharding`` argument can be any callable that given the path and the
+    weight returns the sharding axis and optionally also the segments that
+    comprise the unsharded weight. For instance if the weight is a fused QKV
+    matrix the segments should be 3.
+
+    .. note::
+        The module doesn't change so in order for distributed communication to
+        happen the module needs to natively support it and for it to be enabled.
+
+    Args:
+        module (mlx.nn.Module): The parameters of this module will be sharded
+            in-place.
+        sharding (str or callable): One of "all-to-sharded" and
+            "sharded-to-all" or a callable that returns the sharding axis and
+            segments.
+        segments (int or list): The segments to use if ``sharding`` is a
+            string. Default: ``1``.
+        group (mlx.core.distributed.Group): The distributed group to shard
+            across. If not set, the global group will be used. Default: ``None``.
+    """
+    if isinstance(sharding, str):
+        _check_sharding(sharding)
+        sharding = (
+            _all_to_sharded(segments)
+            if sharding == "all-to-sharded"
+            else _sharded_to_all(segments)
+        )
+    module.update(_shard(module.parameters(), sharding, group))
+
+
+def shard_linear(
+    module: Module,
+    sharding: str,
+    *,
+    segments: Union[int, list] = 1,
+    group: Optional[mx.distributed.Group] = None,
+):
+    """Create a new linear layer that has its parameters sharded and also
+    performs distributed communication either in the forward or backward
+    pass.
+
+    .. note::
+        Contrary to ``shard_inplace``, the original layer is not changed but a
+        new layer is returned.
+
+    Args:
+        module (mlx.nn.Module): The linear layer to be sharded.
+        sharding (str): One of "all-to-sharded" and
+            "sharded-to-all" that defines the type of sharding to perform.
+        segments (int or list): The segments to use. Default: ``1``.
+        group (mlx.core.distributed.Group): The distributed group to shard
+            across. If not set, the global group will be used. Default: ``None``.
+    """
+    _check_sharding(sharding)
+    fns = {
+        ("all-to-sharded", True): AllToShardedLinear.from_linear,
+        ("all-to-sharded", False): QuantizedAllToShardedLinear.from_quantized_linear,
+        ("sharded-to-all", True): ShardedToAllLinear.from_linear,
+        ("sharded-to-all", False): QuantizedShardedToAllLinear.from_quantized_linear,
+    }
+    return fns[sharding, isinstance(module, Linear)](
+        module, segments=segments, group=group
+    )
+
+
+class AllToShardedLinear(Module):
+    """Each member of the group applies part of the affine transformation such
+    that the result is sharded across the group.
+
+    The gradients are automatically aggregated from each member of the group.
+
+    Args:
+        input_dims (int): The dimensionality of the input features
+        output_dims (int): The dimensionality of the output features
+        bias (bool, optional): If set to ``False`` the the layer will not use a
+            bias. Default is ``True``.
+        group (mx.distributed.Group, optional): The sharding will happen across
+            this group. If not set then the global group is used. Default is
+            ``None``.
+    """
+
+    def __init__(
+        self,
+        input_dims: int,
+        output_dims: int,
+        bias: bool = True,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        super().__init__()
+
+        # Initialize the parameters
+        scale = math.sqrt(1.0 / input_dims)
+        self.group = group or mx.distributed.init()
+        N = self.group.size()
+
+        if (output_dims % N) != 0:
+            raise ValueError(
+                f"Cannot shard the output of size {output_dims} across {N} devices."
+            )
+
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims // N, input_dims),
+        )
+        if bias:
+            self.bias = mx.random.uniform(
+                low=-scale,
+                high=scale,
+                shape=(output_dims // N,),
+            )
+
+    def _extra_repr(self) -> str:
+        out_dims, in_dims = self.weight.shape
+        N = self.group.size()
+        out_dims *= N
+        return f"input_dims={in_dims}, output_dims={out_dims}, bias={'bias' in self}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        # Aggregate the gradients coming from each shard
+        x = sum_gradients(self.group)(x)
+
+        # Compute the affine projection
+        if "bias" in self:
+            x = mx.addmm(self["bias"], x, self["weight"].T)
+        else:
+            x = x @ self["weight"].T
+        return x
+
+    @classmethod
+    def from_linear(
+        cls,
+        linear_layer: Module,
+        *,
+        segments: Union[int, list] = 1,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        group = group or mx.distributed.init()
+        output_dims, input_dims = linear_layer.weight.shape
+
+        sl = cls(input_dims, output_dims, hasattr(linear_layer, "bias"), group)
+        sl.update(_shard(linear_layer.parameters(), _all_to_sharded(segments), group))
+
+        return sl
+
+
+class ShardedToAllLinear(Module):
+    """Each member of the group applies part of the affine transformation and
+    then aggregates the results.
+
+    All nodes will have the same exact result after this layer.
+
+    :class:`ShardedToAllLinear` provides a classmethod :meth:`from_linear` to
+    convert linear layers to sharded :obj:`ShardedToAllLinear` layers.
+
+    Args:
+        input_dims (int): The dimensionality of the input features
+        output_dims (int): The dimensionality of the output features
+        bias (bool, optional): If set to ``False`` the the layer will not use a
+            bias. Default is ``True``.
+        group (mx.distributed.Group, optional): The sharding will happen across
+            this group. If not set then the global group is used. Default is
+            ``None``.
+    """
+
+    def __init__(
+        self,
+        input_dims: int,
+        output_dims: int,
+        bias: bool = True,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        super().__init__()
+
+        # Initialize the parameters
+        scale = math.sqrt(1.0 / input_dims)
+        self.group = group or mx.distributed.init()
+        N = self.group.size()
+
+        if (input_dims % N) != 0:
+            raise ValueError(
+                f"The input of size {input_dims} cannot be sharded across {N} devices."
+            )
+
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims, input_dims // N),
+        )
+        if bias:
+            self.bias = mx.random.uniform(
+                low=-scale,
+                high=scale,
+                shape=(output_dims,),
+            )
+
+    def _extra_repr(self) -> str:
+        N = self.group.size()
+        out_dims, in_dims = self.weight.shape
+        in_dims *= N
+        return f"input_dims={in_dims}, output_dims={out_dims}, bias={'bias' in self}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        x = x @ self["weight"].T
+
+        x = mx.distributed.all_sum(x, group=self.group)
+
+        if "bias" in self:
+            x = x + self["bias"]
+
+        return x
+
+    @classmethod
+    def from_linear(
+        cls,
+        linear_layer: Module,
+        *,
+        segments: Union[int, list] = 1,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        group = group or mx.distributed.init()
+        output_dims, input_dims = linear_layer.weight.shape
+
+        sl = cls(input_dims, output_dims, hasattr(linear_layer, "bias"), group)
+        sl.update(_shard(linear_layer.parameters(), _sharded_to_all(segments), group))
+
+        return sl
+
+
+class QuantizedAllToShardedLinear(Module):
+    """Each member of the group applies part of the affine transformation with
+    a quantized matrix such that the result is sharded across the group.
+
+    It is the quantized equivalent of :class:`mlx.nn.AllToShardedLinear`.
+    Similar to :class:`mlx.nn.QuantizedLinear` its parameters are frozen and
+    will not be included in any gradient computation.
+
+    Args:
+        input_dims (int): The dimensionality of the input features.
+        output_dims (int): The dimensionality of the output features.
+        bias (bool, optional): If set to ``False`` then the layer will not use
+            a bias. Default: ``True``.
+        group_size (int, optional): The group size to use for the quantized
+            weight. See :func:`~mlx.core.quantize`. Default: ``64``.
+        bits (int, optional): The bit width to use for the quantized weight.
+            See :func:`~mlx.core.quantize`. Default: ``4``.
+        group (mx.distributed.Group, optional): The sharding will happen across
+            this group. If not set then the global group is used. Default is
+            ``None``.
+    """
+
+    def __init__(
+        self,
+        input_dims: int,
+        output_dims: int,
+        bias: bool = True,
+        group_size: int = 64,
+        bits: int = 4,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        super().__init__()
+
+        # Quantization config
+        self.group_size = group_size
+        self.bits = bits
+
+        # Initialize the quantized weight
+        scale = math.sqrt(1.0 / input_dims)
+        self.group = group or mx.distributed.init()
+        N = self.group.size()
+
+        if (output_dims % N) != 0:
+            raise ValueError(
+                f"Cannot shard the output of size {output_dims} across {N} devices."
+            )
+
+        weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims // N, input_dims),
+        )
+        self.weight, self.scales, self.biases = mx.quantize(weight, group_size, bits)
+
+        # And bias if needed
+        if bias:
+            self.bias = mx.zeros((output_dims // N,))
+
+        # Freeze this model's parameters
+        self.freeze()
+
+    def unfreeze(self, *args, **kwargs):
+        """Wrap unfreeze so that we unfreeze any layers we might contain but
+        our parameters will remain frozen."""
+        super().unfreeze(*args, **kwargs)
+        self.freeze(recurse=False)
+
+    def _extra_repr(self) -> str:
+        out_dims, in_dims = self.weight.shape
+        in_dims *= 32 // self.bits
+        out_dims *= self.group.size()
+        return (
+            f"input_dims={in_dims}, output_dims={out_dims}, bias={'bias' in self}, "
+            f"group_size={self.group_size}, bits={self.bits}"
+        )
+
+    def __call__(self, x: mx.array) -> mx.array:
+        # Aggregate the gradients coming from each shard
+        x = sum_gradients(self.group)(x)
+
+        x = mx.quantized_matmul(
+            x,
+            self["weight"],
+            scales=self["scales"],
+            biases=self["biases"],
+            transpose=True,
+            group_size=self.group_size,
+            bits=self.bits,
+        )
+        if "bias" in self:
+            x = x + self["bias"]
+        return x
+
+    @classmethod
+    def from_quantized_linear(
+        cls,
+        quantized_linear_layer: Module,
+        *,
+        segments: Union[int, list] = 1,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        group = group or mx.distributed.init()
+        output_dims, input_dims = quantized_linear_layer.weight.shape
+        input_dims *= 32 // quantized_linear_layer.bits
+
+        sl = cls(
+            input_dims,
+            output_dims,
+            hasattr(quantized_linear_layer, "bias"),
+            group_size=quantized_linear_layer.group_size,
+            bits=quantized_linear_layer.bits,
+            group=group,
+        )
+        sl.update(
+            _shard(
+                quantized_linear_layer.parameters(),
+                _all_to_sharded(segments),
+                group,
+            )
+        )
+
+        return sl
+
+
+class QuantizedShardedToAllLinear(Module):
+    """Each member of the group applies part of the affine transformation using
+    the quantized matrix and then aggregates the results.
+
+    All nodes will have the same exact result after this layer.
+
+    It is the quantized equivalent of :class:`mlx.nn.ShardedToAllLinear`.
+    Similar to :class:`mlx.nn.QuantizedLinear` its parameters are frozen and
+    will not be included in any gradient computation.
+
+    Args:
+        input_dims (int): The dimensionality of the input features.
+        output_dims (int): The dimensionality of the output features.
+        bias (bool, optional): If set to ``False`` then the layer will not use
+            a bias. Default: ``True``.
+        group_size (int, optional): The group size to use for the quantized
+            weight. See :func:`~mlx.core.quantize`. Default: ``64``.
+        bits (int, optional): The bit width to use for the quantized weight.
+            See :func:`~mlx.core.quantize`. Default: ``4``.
+        group (mx.distributed.Group, optional): The sharding will happen across
+            this group. If not set then the global group is used. Default is
+            ``None``.
+    """
+
+    def __init__(
+        self,
+        input_dims: int,
+        output_dims: int,
+        bias: bool = True,
+        group_size: int = 64,
+        bits: int = 4,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        super().__init__()
+
+        # Quantization config
+        self.group_size = group_size
+        self.bits = bits
+
+        # Initialize the quantized weight
+        scale = math.sqrt(1.0 / input_dims)
+        self.group = group or mx.distributed.init()
+        N = self.group.size()
+
+        if (input_dims % N) != 0:
+            raise ValueError(
+                f"The input of size {input_dims} cannot be sharded across {N} devices."
+            )
+
+        weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims, input_dims // N),
+        )
+        self.weight, self.scales, self.biases = mx.quantize(weight, group_size, bits)
+
+        # And bias if needed
+        if bias:
+            self.bias = mx.zeros((output_dims,))
+
+        # Freeze this model's parameters
+        self.freeze()
+
+    def unfreeze(self, *args, **kwargs):
+        """Wrap unfreeze so that we unfreeze any layers we might contain but
+        our parameters will remain frozen."""
+        super().unfreeze(*args, **kwargs)
+        self.freeze(recurse=False)
+
+    def _extra_repr(self) -> str:
+        out_dims, in_dims = self.weight.shape
+        in_dims *= (32 // self.bits) * self.group.size()
+        return (
+            f"input_dims={in_dims}, output_dims={out_dims}, bias={'bias' in self}, "
+            f"group_size={self.group_size}, bits={self.bits}"
+        )
+
+    def __call__(self, x: mx.array) -> mx.array:
+        x = mx.quantized_matmul(
+            x,
+            self["weight"],
+            scales=self["scales"],
+            biases=self["biases"],
+            transpose=True,
+            group_size=self.group_size,
+            bits=self.bits,
+        )
+        x = mx.distributed.all_sum(x, group=self.group)
+        if "bias" in self:
+            x = x + self["bias"]
+        return x
+
+    @classmethod
+    def from_quantized_linear(
+        cls,
+        quantized_linear_layer: Module,
+        *,
+        segments: Union[int, list] = 1,
+        group: Optional[mx.distributed.Group] = None,
+    ):
+        group = group or mx.distributed.init()
+        output_dims, input_dims = quantized_linear_layer.weight.shape
+        input_dims *= 32 // quantized_linear_layer.bits
+
+        sl = cls(
+            input_dims,
+            output_dims,
+            hasattr(quantized_linear_layer, "bias"),
+            group_size=quantized_linear_layer.group_size,
+            bits=quantized_linear_layer.bits,
+            group=group,
+        )
+        sl.update(
+            _shard(
+                quantized_linear_layer.parameters(),
+                _sharded_to_all(segments),
+                group,
+            )
+        )
+
+        return sl
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/dropout.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/dropout.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6a690996e718761aa3ed5942b99f97a0990fbff
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/dropout.py
@@ -0,0 +1,137 @@
+# Copyright © 2023 Apple Inc.
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class Dropout(Module):
+    r"""Randomly zero a portion of the elements during training.
+
+    The remaining elements are multiplied with :math:`\frac{1}{1-p}` where
+    :math:`p` is the probability of zeroing an element. This is done so the
+    expected value of a given element will remain the same.
+
+    Args:
+        p (float): The probability to zero an element
+    """
+
+    def __init__(self, p: float = 0.5):
+        super().__init__()
+
+        if p < 0 or p >= 1:
+            raise ValueError(f"The dropout probability {p} is not in [0, 1)")
+
+        self._p_1 = 1 - p
+
+    def _extra_repr(self) -> str:
+        return f"p={1-self._p_1}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        if self._p_1 == 1 or not self.training:
+            return x
+
+        mask = mx.random.bernoulli(self._p_1, x.shape)
+
+        return (mask * x) * (1 / self._p_1)
+
+
+class Dropout2d(Module):
+    r"""Apply 2D channel-wise dropout during training.
+
+    Randomly zero out entire channels independently with probability :math:`p`.
+    This layer expects the channels to be last, i.e. the input shape should be
+    ``NWHC`` or ``WHC`` where:``N`` is the batch dimension,``H`` is the input
+    image height,``W`` is the input image width, and``C`` is the number of
+    input channels
+
+    The remaining channels are scaled by :math:`\frac{1}{1-p}` to
+    maintain the expected value of each element. Unlike traditional dropout,
+    which zeros individual entries, this layer zeros entire channels. This is
+    beneficial for early convolution layers where adjacent pixels are
+    correlated. In such case, traditional dropout may not effectively
+    regularize activations. For more details, see [1].
+
+    [1]: Thompson, J., Goroshin, R., Jain, A., LeCun, Y. and Bregler C., 2015.
+    Efficient Object Localization Using Convolutional Networks. CVPR 2015.
+
+    Args:
+        p (float): Probability of zeroing a channel during training.
+    """
+
+    def __init__(self, p: float = 0.5):
+        super().__init__()
+
+        if p < 0 or p >= 1:
+            raise ValueError(f"The dropout probability {p} is not in [0, 1)")
+
+        self._p_1 = 1 - p
+
+    def _extra_repr(self) -> str:
+        return f"p={1-self._p_1}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        if x.ndim not in (3, 4):
+            raise ValueError(
+                f"Received input with {x.ndim} dimensions. Expected 3 or 4 dimensions."
+            )
+
+        if self._p_1 == 1 or not self.training:
+            return x
+
+        # Dropout is applied on the whole channel
+        # 3D input: (1, 1, C)
+        # 4D input: (B, 1, 1, C)
+        mask_shape = list(x.shape)
+        mask_shape[-2] = mask_shape[-3] = 1
+
+        mask = mx.random.bernoulli(p=self._p_1, shape=mask_shape)
+        return (mask * x) * (1 / self._p_1)
+
+
+class Dropout3d(Module):
+    r"""Apply 3D channel-wise dropout during training.
+
+    Randomly zero out entire channels independently with probability :math:`p`.
+    This layer expects the channels to be last, i.e., the input shape should be
+    `NDHWC` or `DHWC` where: `N` is the batch dimension, `D` is the depth,
+    `H` is the input image height, `W` is the input image width, and `C` is
+    the number of input channels.
+
+    The remaining channels are scaled by :math:`\frac{1}{1-p}` to
+    maintain the expected value of each element. Unlike traditional dropout,
+    which zeros individual entries, this layer zeros entire channels. This is
+    often beneficial for convolutional layers processing 3D data, like in
+    medical imaging or video processing.
+
+    Args:
+        p (float): Probability of zeroing a channel during training.
+    """
+
+    def __init__(self, p: float = 0.5):
+        super().__init__()
+
+        if p < 0 or p >= 1:
+            raise ValueError(f"The dropout probability {p} is not in [0, 1)")
+
+        self._p_1 = 1 - p
+
+    def _extra_repr(self) -> str:
+        return f"p={1-self._p_1}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        if x.ndim not in (4, 5):
+            raise ValueError(
+                f"Received input with {x.ndim} dimensions. Expected 4 or 5 dimensions."
+            )
+
+        if self._p_1 == 1 or not self.training:
+            return x
+
+        # Dropout is applied on the whole channel
+        # 4D input: (1, 1, 1, C)
+        # 5D input: (B, 1, 1, 1, C)
+        mask_shape = list(x.shape)
+        mask_shape[-2] = mask_shape[-3] = mask_shape[-4] = 1
+
+        mask = mx.random.bernoulli(p=self._p_1, shape=mask_shape)
+        return (mask * x) * (1 / self._p_1)
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/embedding.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/embedding.py
new file mode 100644
index 0000000000000000000000000000000000000000..1edf7e3a5d4365e546a0af9ac6974ec3b2520a78
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/embedding.py
@@ -0,0 +1,44 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+from mlx.nn.layers.quantized import QuantizedEmbedding
+
+
+class Embedding(Module):
+    """Implements a simple lookup table that maps each input integer to a
+    high-dimensional vector.
+
+    Typically used to embed discrete tokens for processing by neural networks.
+
+    Args:
+        num_embeddings (int): How many possible discrete tokens can we embed.
+           Usually called the vocabulary size.
+        dims (int): The dimensionality of the embeddings.
+    """
+
+    def __init__(self, num_embeddings: int, dims: int):
+        super().__init__()
+        scale = math.sqrt(1 / dims)
+        self.weight = mx.random.normal(shape=(num_embeddings, dims), scale=scale)
+
+    def _extra_repr(self):
+        return f"{self.weight.shape[0]}, {self.weight.shape[1]}"
+
+    def __call__(self, x):
+        return self.weight[x]
+
+    def as_linear(self, x):
+        """
+        Call the embedding layer as a linear layer.
+
+        Use this for example when input embedding and output projection
+        weights are tied.
+        """
+        return x @ self.weight.T
+
+    def to_quantized(self, group_size: int = 64, bits: int = 4, mode: str = "affine"):
+        """Return a :obj:`QuantizedEmbedding` layer that approximates this embedding layer."""
+        return QuantizedEmbedding.from_embedding(self, group_size, bits, mode)
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/linear.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/linear.py
new file mode 100644
index 0000000000000000000000000000000000000000..84a4d8327186fa0744f0d64b7fd978b590cfa404
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/linear.py
@@ -0,0 +1,147 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Any
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+from mlx.nn.layers.quantized import QuantizedLinear
+
+
+class Identity(Module):
+    r"""A placeholder identity operator that is argument-insensitive.
+
+    Args:
+        args: any argument (unused)
+        kwargs: any keyword argument (unused)
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__()
+
+    def __call__(self, x: mx.array) -> mx.array:
+        return x
+
+
+class Linear(Module):
+    r"""Applies an affine transformation to the input.
+
+    Concretely:
+
+    .. math::
+
+        y = x W^\top + b
+
+    where:
+    where :math:`W` has shape ``[output_dims, input_dims]`` and :math:`b` has shape ``[output_dims]``.
+
+    The values are initialized from the uniform distribution :math:`\mathcal{U}(-{k}, {k})`,
+    where :math:`k = \frac{1}{\sqrt{D_i}}` and :math:`D_i` is equal to ``input_dims``.
+
+    Args:
+        input_dims (int): The dimensionality of the input features
+        output_dims (int): The dimensionality of the output features
+        bias (bool, optional): If set to ``False`` then the layer will
+          not use a bias. Default is ``True``.
+    """
+
+    def __init__(self, input_dims: int, output_dims: int, bias: bool = True) -> None:
+        super().__init__()
+        scale = math.sqrt(1.0 / input_dims)
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims, input_dims),
+        )
+        if bias:
+            self.bias = mx.random.uniform(
+                low=-scale,
+                high=scale,
+                shape=(output_dims,),
+            )
+
+    def _extra_repr(self) -> str:
+        return f"input_dims={self.weight.shape[1]}, output_dims={self.weight.shape[0]}, bias={'bias' in self}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        if "bias" in self:
+            x = mx.addmm(self["bias"], x, self["weight"].T)
+        else:
+            x = x @ self["weight"].T
+        return x
+
+    def to_quantized(self, group_size: int = 64, bits: int = 4, mode: str = "affine"):
+        """Return a :obj:`QuantizedLinear` layer that approximates this layer."""
+        return QuantizedLinear.from_linear(self, group_size, bits, mode)
+
+
+class Bilinear(Module):
+    r"""Applies a bilinear transformation to the inputs.
+
+    Concretely:
+
+    .. math::
+
+        y_i = x_1^\top W_i x_2 + b_i
+
+    where:
+    :math:`W` has shape ``[output_dims, input1_dims, input2_dims]``, :math:`b` has shape ``[output_dims ]``,
+    and :math:`i` indexes the output dimension.
+
+    The values are initialized from the uniform distribution :math:`\mathcal{U}(-{k}, {k})`,
+    where :math:`k = \frac{1}{\sqrt{D_1}}` and :math:`D_1` is ``input1_dims``.
+
+    Args:
+        input1_dims (int): The dimensionality of the input1 features
+        input2_dims (int): The dimensionality of the input2 features
+        output_dims (int): The dimensionality of the output features
+        bias (bool, optional): If set to ``False`` then the layer will
+          not use a bias. Default is ``True``.
+    """
+
+    def __init__(
+        self, input1_dims: int, input2_dims: int, output_dims: int, bias: bool = True
+    ) -> None:
+        super().__init__()
+        scale = math.sqrt(1.0 / input1_dims)
+        self.weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims, input2_dims, input1_dims),
+        )
+        if bias:
+            self.bias = mx.random.uniform(
+                low=-scale,
+                high=scale,
+                shape=(output_dims,),
+            )
+
+    def _extra_repr(self) -> str:
+        out, in2, in1 = self.weight.shape
+        return (
+            f"input1_dims={in1}, input2_dims={in2}, output_dims={out}, "
+            f"bias={'bias' in self}"
+        )
+
+    def __call__(self, x1: mx.array, x2: mx.array) -> mx.array:
+        # Normalize shapes
+        out, in2, in1 = self.weight.shape
+        xshape = x1.shape[:-1]
+        x1 = x1.reshape(-1, in1)
+        x2 = x2.reshape(-1, 1, in2)
+
+        # Perform the bilinear transformation
+        w = self.weight.reshape(out * in2, in1)
+        y = x1 @ w.T
+        y = y.reshape(-1, out, in2).swapaxes(-2, -1)
+        y = x2 @ y
+        y = y.squeeze(1)
+
+        # Reset the shape
+        y = y.reshape(*xshape, out)
+
+        # Apply the bias
+        if "bias" in self:
+            y = y + self.bias
+
+        return y
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/normalization.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/normalization.py
new file mode 100644
index 0000000000000000000000000000000000000000..bdddb6ccfb0bbb7049c8b3364da03d9a86fbf58d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/normalization.py
@@ -0,0 +1,363 @@
+# Copyright © 2023 Apple Inc.
+
+from typing import Tuple
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class InstanceNorm(Module):
+    r"""Applies instance normalization [1] on the inputs.
+
+    Computes
+
+    .. math::
+
+        y = \frac{x - \mathrm{E}[x]}{ \sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta,
+
+    where :math:`\gamma` and :math:`\beta` are learned per feature dimension
+    parameters initialized at 1 and 0 respectively. Both are of size :attr:`dims`,
+    if :attr:`affine` is ``True``.
+
+    Args:
+        dims (int): The number of features of the input.
+        eps (float): A value added to the denominator for numerical stability. Default: ``1e-5``.
+        affine (bool): Default: ``False``.
+
+    Shape:
+      - Input: :math:`(..., C)` where :math:`C` is equal to :attr:`dims`.
+      - Output: Same shape as the input.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+        >>> x = mx.random.normal((8, 4, 4, 16))
+        >>> inorm = nn.InstanceNorm(dims=16)
+        >>> output = inorm(x)
+
+    References:
+        [1]: https://arxiv.org/abs/1607.08022
+    """
+
+    def __init__(
+        self,
+        dims: int,
+        eps: float = 1e-5,
+        affine: bool = False,
+    ):
+        super().__init__()
+        if affine:
+            self.weight = mx.ones((dims,))
+            self.bias = mx.zeros((dims,))
+        self.dims = dims
+        self.eps = eps
+
+    def _extra_repr(self):
+        return f"{self.dims}, eps={self.eps}, affine={'weight' in self}"
+
+    def __call__(self, x: mx.array) -> mx.array:
+        reduction_axes = tuple(range(1, x.ndim - 1))
+        # Compute stats
+        mean = mx.mean(x, axis=reduction_axes, keepdims=True)
+        var = mx.var(x, axis=reduction_axes, keepdims=True)
+        # Normalize
+        x = (x - mean) * mx.rsqrt(var + self.eps)
+        # Scale and shift if necessary
+        return (self.weight * x + self.bias) if "weight" in self else x
+
+
+class LayerNorm(Module):
+    r"""Applies layer normalization [1] on the inputs.
+
+    Computes
+
+    .. math::
+
+        y = \frac{x - E[x]}{\sqrt{Var[x]} + \epsilon} \gamma + \beta,
+
+    where :math:`\gamma` and :math:`\beta` are learned per feature dimension
+    parameters initialized at 1 and 0 respectively.
+
+    [1]: https://arxiv.org/abs/1607.06450
+
+    Args:
+        dims (int): The feature dimension of the input to normalize over
+        eps (float): A small additive constant for numerical stability
+        affine (bool): If True learn an affine transform to apply after the
+            normalization
+        bias (bool): If True include a translation to the affine
+            transformation. If set to False the transformation is not really affine
+            just scaling.
+    """
+
+    def __init__(
+        self, dims: int, eps: float = 1e-5, affine: bool = True, bias: bool = True
+    ):
+        super().__init__()
+        if affine:
+            self.weight = mx.ones((dims,))
+            if bias:
+                self.bias = mx.zeros((dims,))
+        self.eps = eps
+        self.dims = dims
+
+    def _extra_repr(self):
+        return f"{self.dims}, eps={self.eps}, affine={'weight' in self}"
+
+    def __call__(self, x):
+        weight = self.weight if "weight" in self else None
+        bias = self.bias if "bias" in self else None
+        return mx.fast.layer_norm(x, weight, bias, self.eps)
+
+
+class RMSNorm(Module):
+    r"""Applies Root Mean Square normalization [1] to the inputs.
+
+    Computes
+
+    ..  math::
+
+        y = \frac{x}{\sqrt{E[x^2] + \epsilon}} \gamma
+
+    where :math:`\gamma` is a learned per feature dimension parameter initialized at
+    1.
+
+    Note the accumulation for the mean is done in 32-bit precision.
+
+    [1]: https://arxiv.org/abs/1910.07467
+
+    Args:
+        dims (int): The feature dimension of the input to normalize over
+        eps (float): A small additive constant for numerical stability
+    """
+
+    def __init__(self, dims: int, eps: float = 1e-5):
+        super().__init__()
+        self.weight = mx.ones((dims,))
+        self.eps = eps
+
+    def _extra_repr(self):
+        return f"{self.weight.shape[0]}, eps={self.eps}"
+
+    def __call__(self, x):
+        return mx.fast.rms_norm(x, self["weight"], self.eps)
+
+
+class GroupNorm(Module):
+    r"""Applies Group Normalization [1] to the inputs.
+
+    Computes the same normalization as layer norm, namely
+
+    .. math::
+
+        y = \frac{x - E[x]}{\sqrt{Var[x]} + \epsilon} \gamma + \beta,
+
+    where :math:`\gamma` and :math:`\beta` are learned per feature dimension
+    parameters initialized at 1 and 0 respectively. However, the mean and
+    variance are computed over the spatial dimensions and each group of
+    features. In particular, the input is split into num_groups across the
+    feature dimension.
+
+    The feature dimension is assumed to be the last dimension and the dimensions
+    that precede it (except the first) are considered the spatial dimensions.
+
+    [1]: https://arxiv.org/abs/1803.08494
+
+    Args:
+        num_groups (int): Number of groups to separate the features into
+        dims (int): The feature dimensions of the input to normalize over
+        eps (float): A small additive constant for numerical stability
+        affine (bool): If True learn an affine transform to apply after the
+            normalization.
+        pytorch_compatible (bool): If True perform the group normalization in
+            the same order/grouping as PyTorch.
+    """
+
+    def __init__(
+        self,
+        num_groups: int,
+        dims: int,
+        eps: float = 1e-5,
+        affine: bool = True,
+        pytorch_compatible: bool = False,
+    ):
+        super().__init__()
+        if affine:
+            self.bias = mx.zeros((dims,))
+            self.weight = mx.ones((dims,))
+        self.num_groups = num_groups
+        self.dims = dims
+        self.eps = eps
+        self.pytorch_compatible = pytorch_compatible
+
+    def _extra_repr(self):
+        return (
+            f"{self.num_groups}, {self.dims}, eps={self.eps}, "
+            f"affine={'weight' in self}, pytorch_compatible={self.pytorch_compatible}"
+        )
+
+    def _pytorch_compatible_group_norm(self, x):
+        num_groups = self.num_groups
+        batch, *rest, dims = x.shape
+        group_size = dims // num_groups
+
+        # Split into groups
+        x = x.reshape(batch, -1, num_groups, group_size)
+        x = x.transpose(0, 2, 1, 3).reshape(batch, num_groups, -1)
+
+        # Normalize
+        x = mx.fast.layer_norm(x, eps=self.eps, weight=None, bias=None)
+
+        x = x.reshape(batch, num_groups, -1, group_size)
+        x = x.transpose(0, 2, 1, 3).reshape(batch, *rest, dims)
+        return x
+
+    def _group_norm(self, x):
+        num_groups = self.num_groups
+        batch, *rest, dims = x.shape
+
+        # Split into groups
+        x = x.reshape(batch, -1, num_groups)
+
+        # Normalize
+        means = mx.mean(x, axis=1, keepdims=True)
+        var = mx.var(x, axis=1, keepdims=True)
+        x = (x - means) * mx.rsqrt(var + self.eps)
+        x = x.reshape(batch, *rest, dims)
+
+        return x
+
+    def __call__(self, x):
+        group_norm = (
+            self._pytorch_compatible_group_norm
+            if self.pytorch_compatible
+            else self._group_norm
+        )
+        x = group_norm(x)
+        return (self.weight * x + self.bias) if "weight" in self else x
+
+
+class BatchNorm(Module):
+    r"""Applies Batch Normalization over a 2D or 3D input.
+
+    Computes
+
+    .. math::
+
+        y = \frac{x - E[x]}{\sqrt{Var[x]} + \epsilon} \gamma + \beta,
+
+    where :math:`\gamma` and :math:`\beta` are learned per feature dimension
+    parameters initialized at 1 and 0 respectively.
+
+    The input shape is specified as ``NC`` or ``NLC``, where ``N`` is the
+    batch, ``C`` is the number of features or channels, and ``L`` is the
+    sequence length. The output has the same shape as the input. For
+    four-dimensional arrays, the shape is ``NHWC``, where ``H`` and ``W`` are
+    the height and width respectively.
+
+    For more information on Batch Normalization, see the original paper `Batch
+    Normalization: Accelerating Deep Network Training by Reducing Internal
+    Covariate Shift <https://arxiv.org/abs/1502.03167>`_.
+
+    Args:
+        num_features (int): The feature dimension to normalize over.
+        eps (float, optional): A small additive constant for numerical
+            stability. Default: ``1e-5``.
+        momentum (float, optional): The momentum for updating the running
+            mean and variance. Default: ``0.1``.
+        affine (bool, optional): If ``True``, apply a learned affine
+            transformation after the normalization. Default: ``True``.
+        track_running_stats (bool, optional): If ``True``, track the
+            running mean and variance. Default: ``True``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+        >>> x = mx.random.normal((5, 4))
+        >>> bn = nn.BatchNorm(num_features=4, affine=True)
+        >>> output = bn(x)
+    """
+
+    def __init__(
+        self,
+        num_features: int,
+        eps: float = 1e-5,
+        momentum: float = 0.1,
+        affine: bool = True,
+        track_running_stats: bool = True,
+    ):
+        super().__init__()
+
+        self.num_features = num_features
+        self.eps = eps
+        self.momentum = momentum
+        self.track_running_stats = track_running_stats
+
+        if affine:
+            self.weight = mx.ones((num_features,))
+            self.bias = mx.zeros((num_features,))
+
+        if self.track_running_stats:
+            self.running_mean = mx.zeros((num_features,))
+            self.running_var = mx.ones((num_features,))
+            self.freeze(keys=["running_mean", "running_var"], recurse=False)
+
+    def unfreeze(self, *args, **kwargs):
+        """Wrap unfreeze to make sure that running_mean and var are always
+        frozen parameters."""
+        super().unfreeze(*args, **kwargs)
+        self.freeze(keys=["running_mean", "running_var"], recurse=False)
+
+    def _extra_repr(self):
+        return (
+            f"{self.num_features}, eps={self.eps}, "
+            f"momentum={self.momentum}, affine={'weight' in self}, "
+            f"track_running_stats={self.track_running_stats}"
+        )
+
+    def _calc_stats(self, x: mx.array) -> Tuple[mx.array, mx.array]:
+        """
+        Calculate the mean and variance of the input tensor across the batch
+        and spatial dimensions.
+
+        Args:
+            x (array): Input tensor.
+
+        Returns:
+            tuple: Tuple containing mean and variance.
+        """
+        reduction_axes = tuple(range(0, x.ndim - 1))
+
+        mean = mx.mean(x, axis=reduction_axes)
+        var = mx.var(x, axis=reduction_axes)
+
+        return mean, var
+
+    def __call__(self, x: mx.array) -> mx.array:
+        """
+        Forward pass of BatchNorm.
+
+        Args:
+            x (array): Input tensor.
+
+        Returns:
+            array: Normalized output tensor.
+        """
+        if x.ndim < 2 or x.ndim > 4:
+            raise ValueError(
+                f"Expected input tensor to have 2, 3 or 4 dimensions, but got {x.ndim}"
+            )
+
+        # Calculate the mean and variance used to normalize the input x. If we
+        # are in training mode update the running stats if needed.
+        mean, var = self._calc_stats(x)
+        if self.training and self.track_running_stats:
+            mu = self.momentum
+            self.running_mean = (1 - mu) * self.running_mean + mu * mean
+            self.running_var = (1 - mu) * self.running_var + mu * var
+        elif self.track_running_stats:
+            mean = self.running_mean
+            var = self.running_var
+
+        x = (x - mean) * mx.rsqrt(var + self.eps)
+        return (self.weight * x + self.bias) if "weight" in self else x
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/pooling.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/pooling.py
new file mode 100644
index 0000000000000000000000000000000000000000..2031176346532fb878ce2602674dfa60473eeb6a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/pooling.py
@@ -0,0 +1,398 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import operator
+from itertools import accumulate
+from typing import Optional, Tuple, Union
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+def _value_or_list(x, n, msg):
+    if isinstance(x, (list, tuple)):
+        if len(x) != n:
+            raise ValueError(msg)
+        return list(x)
+
+    if not isinstance(x, int):
+        raise ValueError(msg)
+
+    return [x] * n
+
+
+def _non_overlapping_sliding_windows(x, shape, window_shape):
+    # Compute the intermediate shape
+    new_shape = [shape[0]]
+    for s, w in zip(shape[1:], window_shape):
+        new_shape.append(s // w)
+        new_shape.append(w)
+    new_shape.append(shape[-1])
+
+    last_axis = len(new_shape) - 1
+    axis_order = [0, *range(1, last_axis, 2), *range(2, last_axis, 2), last_axis]
+
+    x = x.reshape(new_shape)
+    x = x.transpose(axis_order)
+    return x
+
+
+def _sliding_windows(x, window_shape, window_strides):
+    if x.ndim < 3:
+        raise ValueError(
+            f"To extract sliding windows at least 1 spatial dimension "
+            f"(3 total) is needed but the input only has {x.ndim} dimensions."
+        )
+
+    spatial_dims = x.shape[1:-1]
+    if not (len(spatial_dims) == len(window_shape) == len(window_strides)):
+        raise ValueError(
+            f"To extract sliding windows the window shapes and strides must have "
+            f"the same number of spatial dimensions as the signal but the signal "
+            f"has {len(spatial_dims)} dims and the window shape has {len(window_shape)} "
+            f"and strides have {len(window_strides)}."
+        )
+
+    shape = x.shape
+    if all(
+        window == stride and size % window == 0
+        for size, window, stride in zip(spatial_dims, window_shape, window_strides)
+    ):
+        return _non_overlapping_sliding_windows(x, shape, window_shape)
+
+    strides = list(reversed(list(accumulate(reversed(shape + (1,)), operator.mul))))[1:]
+
+    # Compute the output shape
+    final_shape = [shape[0]]
+    final_shape += [
+        (size - window) // stride + 1
+        for size, window, stride in zip(spatial_dims, window_shape, window_strides)
+    ]
+    final_shape += window_shape
+    final_shape += [shape[-1]]
+
+    # Compute the output strides
+    final_strides = strides[:1]
+    final_strides += [
+        og_stride * stride for og_stride, stride in zip(strides[1:-1], window_strides)
+    ]
+    final_strides += strides[1:-1]
+    final_strides += strides[-1:]  # should always be [1]
+
+    return mx.as_strided(x, final_shape, final_strides)
+
+
+class _Pool(Module):
+    def __init__(self, pooling_function, kernel_size, stride, padding, padding_value):
+        super().__init__()
+
+        self._pooling_function = pooling_function
+        self._kernel_size = kernel_size
+        self._stride = stride
+        self._padding = padding
+        self._padding_value = padding_value
+        self._axes = tuple(range(-len(self._kernel_size) - 1, -1, 1))
+
+    def _extra_repr(self):
+        ks = tuple(self._kernel_size)
+        st = tuple(self._stride)
+        pd = tuple(p[0] for p in self._padding)
+
+        return f"kernel_size={ks}, stride={st}, padding={pd}"
+
+    def __call__(self, x):
+        if any(p[0] > 0 for p in self._padding):
+            x = mx.pad(
+                x,
+                [(0, 0)] + self._padding + [(0, 0)],
+                constant_values=self._padding_value,
+            )
+        x = _sliding_windows(x, self._kernel_size, self._stride)
+        return self._pooling_function(x, self._axes)
+
+
+class _Pool1d(_Pool):
+    def __init__(
+        self,
+        pooling_function,
+        padding_value,
+        kernel_size: Union[int, Tuple[int]],
+        stride: Optional[Union[int, Tuple[int]]] = None,
+        padding: Union[int, Tuple[int]] = 0,
+    ):
+        class_name = type(self).__name__
+        msg = "[{}] '{}' must be an integer or a tuple containing 1 integer"
+        kernel_size = _value_or_list(
+            kernel_size, 1, msg.format(class_name, "kernel_size")
+        )
+        if stride is not None:
+            stride = _value_or_list(stride, 1, msg.format(class_name, "stride"))
+        else:
+            stride = kernel_size
+        padding = _value_or_list(padding, 1, msg.format(class_name, "padding"))
+        padding = [(p, p) for p in padding]
+
+        super().__init__(pooling_function, kernel_size, stride, padding, padding_value)
+
+
+class _Pool2d(_Pool):
+    def __init__(
+        self,
+        pooling_function,
+        padding_value,
+        kernel_size: Union[int, Tuple[int, int]],
+        stride: Optional[Union[int, Tuple[int, int]]] = None,
+        padding: Optional[Union[int, Tuple[int, int]]] = 0,
+    ):
+        class_name = type(self).__name__
+        msg = "[{}] '{}' must be an integer or a tuple containing 2 integers"
+        kernel_size = _value_or_list(
+            kernel_size, 2, msg.format(class_name, "kernel_size")
+        )
+        if stride is not None:
+            stride = _value_or_list(stride, 2, msg.format(class_name, "stride"))
+        else:
+            stride = kernel_size
+        padding = _value_or_list(padding, 2, msg.format(class_name, "padding"))
+        padding = [(p, p) for p in padding]
+
+        super().__init__(pooling_function, kernel_size, stride, padding, padding_value)
+
+
+class _Pool3d(_Pool):
+    def __init__(
+        self,
+        pooling_function,
+        padding_value,
+        kernel_size: Union[int, Tuple[int, int, int]],
+        stride: Optional[Union[int, Tuple[int, int, int]]] = None,
+        padding: Optional[Union[int, Tuple[int, int, int]]] = 0,
+    ):
+        class_name = type(self).__name__
+        msg = "[{}] '{}' must be an integer or a tuple containing 3 integers"
+        kernel_size = _value_or_list(
+            kernel_size, 3, msg.format(class_name, "kernel_size")
+        )
+        if stride is not None:
+            stride = _value_or_list(stride, 3, msg.format(class_name, "stride"))
+        else:
+            stride = kernel_size
+        padding = _value_or_list(padding, 3, msg.format(class_name, "padding"))
+        padding = [(p, p) for p in padding]
+
+        super().__init__(pooling_function, kernel_size, stride, padding, padding_value)
+
+
+class MaxPool1d(_Pool1d):
+    r"""Applies 1-dimensional max pooling.
+
+    Spatially downsamples the input by taking the maximum of a sliding window
+    of size ``kernel_size`` and sliding stride ``stride``.
+
+    Args:
+        kernel_size (int or tuple(int)): The size of the pooling window kernel.
+        stride (int or tuple(int), optional): The stride of the pooling window.
+            Default: ``kernel_size``.
+        padding (int or tuple(int), optional): How much negative infinity
+            padding to apply to the input. The padding amount is applied to
+            both sides of the spatial axis. Default: ``0``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn.layers as nn
+        >>> x = mx.random.normal(shape=(4, 16, 5))
+        >>> pool = nn.MaxPool1d(kernel_size=2, stride=2)
+        >>> pool(x)
+    """
+
+    def __init__(
+        self,
+        kernel_size: Union[int, Tuple[int]],
+        stride: Optional[Union[int, Tuple[int]]] = None,
+        padding: Union[int, Tuple[int]] = 0,
+    ):
+        super().__init__(mx.max, -float("inf"), kernel_size, stride, padding)
+
+
+class AvgPool1d(_Pool1d):
+    r"""Applies 1-dimensional average pooling.
+
+    Spatially downsamples the input by taking the average of a sliding window
+    of size ``kernel_size`` and sliding stride ``stride``.
+
+    Args:
+        kernel_size (int or tuple(int)): The size of the pooling window kernel.
+        stride (int or tuple(int), optional): The stride of the pooling window.
+            Default: ``kernel_size``.
+        padding (int or tuple(int), optional): How much zero padding to apply to
+            the input. The padding amount is applied to both sides of the spatial
+            axis. Default: ``0``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn.layers as nn
+        >>> x = mx.random.normal(shape=(4, 16, 5))
+        >>> pool = nn.AvgPool1d(kernel_size=2, stride=2)
+        >>> pool(x)
+    """
+
+    def __init__(
+        self,
+        kernel_size: Union[int, Tuple[int]],
+        stride: Optional[Union[int, Tuple[int]]] = None,
+        padding: Union[int, Tuple[int]] = 0,
+    ):
+        super().__init__(mx.mean, 0, kernel_size, stride, padding)
+
+
+class MaxPool2d(_Pool2d):
+    r"""Applies 2-dimensional max pooling.
+
+    Spatially downsamples the input by taking the maximum of a sliding window
+    of size ``kernel_size`` and sliding stride ``stride``.
+
+    The parameters ``kernel_size``, ``stride``, and ``padding`` can either be:
+
+    * a single ``int`` -- in which case the same value is used for both the
+      height and width axis.
+    * a ``tuple`` of two ``int`` s -- in which case, the first ``int`` is
+      used for the height axis, the second ``int`` for the width axis.
+
+    Args:
+        kernel_size (int or tuple(int, int)): The size of the pooling window.
+        stride (int or tuple(int, int), optional): The stride of the pooling
+            window. Default: ``kernel_size``.
+        padding (int or tuple(int, int), optional): How much negative infinity
+            padding to apply to the input. The padding is applied on both sides
+            of the height and width axis. Default: ``0``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn.layers as nn
+        >>> x = mx.random.normal(shape=(8, 32, 32, 4))
+        >>> pool = nn.MaxPool2d(kernel_size=2, stride=2)
+        >>> pool(x)
+    """
+
+    def __init__(
+        self,
+        kernel_size: Union[int, Tuple[int, int]],
+        stride: Optional[Union[int, Tuple[int, int]]] = None,
+        padding: Optional[Union[int, Tuple[int, int]]] = 0,
+    ):
+        super().__init__(mx.max, -float("inf"), kernel_size, stride, padding)
+
+
+class AvgPool2d(_Pool2d):
+    r"""Applies 2-dimensional average pooling.
+
+    Spatially downsamples the input by taking the average of a sliding window
+    of size ``kernel_size`` and sliding stride ``stride``.
+
+    The parameters ``kernel_size``, ``stride``, and ``padding`` can either be:
+
+    * a single ``int`` -- in which case the same value is used for both the
+      height and width axis.
+    * a ``tuple`` of two ``int`` s -- in which case, the first ``int`` is
+      used for the height axis, the second ``int`` for the width axis.
+
+    Args:
+        kernel_size (int or tuple(int, int)): The size of the pooling window.
+        stride (int or tuple(int, int), optional): The stride of the pooling
+            window. Default: ``kernel_size``.
+        padding (int or tuple(int, int), optional): How much zero
+            padding to apply to the input. The padding is applied on both sides
+            of the height and width axis. Default: ``0``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn.layers as nn
+        >>> x = mx.random.normal(shape=(8, 32, 32, 4))
+        >>> pool = nn.AvgPool2d(kernel_size=2, stride=2)
+        >>> pool(x)
+    """
+
+    def __init__(
+        self,
+        kernel_size: Union[int, Tuple[int, int]],
+        stride: Optional[Union[int, Tuple[int, int]]] = None,
+        padding: Optional[Union[int, Tuple[int, int]]] = 0,
+    ):
+        super().__init__(mx.mean, 0, kernel_size, stride, padding)
+
+
+class MaxPool3d(_Pool3d):
+    r"""Applies 3-dimensional max pooling.
+
+    Spatially downsamples the input by taking the maximum of a sliding window
+    of size ``kernel_size`` and sliding stride ``stride``.
+
+    The parameters ``kernel_size``, ``stride``, and ``padding`` can either be:
+
+    * a single ``int`` -- in which case the same value is used for the depth,
+      height, and width axis.
+    * a ``tuple`` of three ``int`` s -- in which case, the first ``int`` is used
+      for the depth axis, the second ``int`` for the height axis, and the third
+      ``int`` for the width axis.
+
+    Args:
+        kernel_size (int or tuple(int, int, int)): The size of the pooling window.
+        stride (int or tuple(int, int, int), optional): The stride of the pooling
+            window. Default: ``kernel_size``.
+        padding (int or tuple(int, int, int), optional): How much negative infinity
+            padding to apply to the input. The padding is applied on both sides
+            of the depth, height and width axis. Default: ``0``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn.layers as nn
+        >>> x = mx.random.normal(shape=(8, 16, 32, 32, 4))
+        >>> pool = nn.MaxPool3d(kernel_size=2, stride=2)
+        >>> pool(x)
+    """
+
+    def __init__(
+        self,
+        kernel_size: Union[int, Tuple[int, int, int]],
+        stride: Optional[Union[int, Tuple[int, int, int]]] = None,
+        padding: Optional[Union[int, Tuple[int, int, int]]] = 0,
+    ):
+        super().__init__(mx.max, -float("inf"), kernel_size, stride, padding)
+
+
+class AvgPool3d(_Pool3d):
+    r"""Applies 3-dimensional average pooling.
+
+    Spatially downsamples the input by taking the average of a sliding window
+    of size ``kernel_size`` and sliding stride ``stride``.
+
+    The parameters ``kernel_size``, ``stride``, and ``padding`` can either be:
+
+    * a single ``int`` -- in which case the same value is used for the depth,
+      height, and width axis.
+    * a ``tuple`` of three ``int`` s -- in which case, the first ``int`` is used
+      for the depth axis, the second ``int`` for the height axis, and the third
+      ``int`` for the width axis.
+
+    Args:
+        kernel_size (int or tuple(int, int, int)): The size of the pooling window.
+        stride (int or tuple(int, int, int), optional): The stride of the pooling
+            window. Default: ``kernel_size``.
+        padding (int or tuple(int, int, int), optional): How much zero
+            padding to apply to the input. The padding is applied on both sides
+            of the depth, height and width axis. Default: ``0``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn.layers as nn
+        >>> x = mx.random.normal(shape=(8, 16, 32, 32, 4))
+        >>> pool = nn.AvgPool3d(kernel_size=2, stride=2)
+        >>> pool(x)
+    """
+
+    def __init__(
+        self,
+        kernel_size: Union[int, Tuple[int, int, int]],
+        stride: Optional[Union[int, Tuple[int, int, int]]] = None,
+        padding: Optional[Union[int, Tuple[int, int, int]]] = 0,
+    ):
+        super().__init__(mx.mean, 0, kernel_size, stride, padding)
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/positional_encoding.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/positional_encoding.py
new file mode 100644
index 0000000000000000000000000000000000000000..950a93cd5d8dfd4a9c5ee50a67a5754c6c4170dc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/positional_encoding.py
@@ -0,0 +1,171 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+from typing import Optional
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+class RoPE(Module):
+    """Implements the rotary positional encoding.
+
+    The traditional implementation rotates consecutive pairs of elements in the
+    feature dimension while the default implementation rotates pairs with
+    stride half the feature dimensions for efficiency.
+
+    For more details see `RoFormer: Enhanced Transformer with Rotary Position
+    Embedding <https://arxiv.org/abs/2104.09864>`_.
+
+    Args:
+        dims (int): The feature dimensions to be rotated. If the input feature
+            is larger than dims then the rest is left unchanged.
+        traditional (bool, optional): If set to ``True`` choose the traditional
+            implementation which is slightly less efficient. Default: ``False``.
+        base (float, optional): The base used to compute angular frequency for
+            each dimension in the positional encodings. Default: ``10000``.
+        scale (float, optional): The scale used to scale the positions. Default: ``1.0``.
+    """
+
+    def __init__(
+        self,
+        dims: int,
+        traditional: bool = False,
+        base: float = 10000,
+        scale: float = 1.0,
+    ):
+        super().__init__()
+        self.dims = dims
+        self.traditional = traditional
+        self.base = base
+        self.scale = scale
+
+    def _extra_repr(self):
+        return f"{self.dims}, traditional={self.traditional}"
+
+    def __call__(self, x, offset: int = 0):
+        return mx.fast.rope(
+            x,
+            self.dims,
+            traditional=self.traditional,
+            base=self.base,
+            scale=self.scale,
+            offset=offset,
+        )
+
+
+class SinusoidalPositionalEncoding(Module):
+    r"""Implements sinusoidal positional encoding.
+
+    For more details see the paper `Attention Is All You Need
+    <https://arxiv.org/abs/1706.03762>`_.
+
+    Args:
+        dims (int): The dimensionality of the resulting positional embeddings.
+        min_freq (float, optional): The minimum frequency expected. Default:
+            ``0.0001``.
+        max_freq (float, optional): The maximum frequency expected. Default:
+            ``1``.
+        scale (float, optional): A multiplicative scale for the embeddings.
+            Default: ``sqrt(2/dims)``.
+        cos_first (bool, optional): If ``True`` embed using ``[cos(x); sin(x)]``
+            instead of the reverse. Default: ``False``.
+        full_turns (bool, optional): If ``True`` multiply the frequencies with
+            :math:`2\pi`. Default: ``False``.
+    """
+
+    def __init__(
+        self,
+        dims: int,
+        min_freq: float = 0.0001,
+        max_freq: float = 1,
+        scale: Optional[float] = None,
+        cos_first: bool = False,
+        full_turns: bool = False,
+    ):
+        super().__init__()
+
+        one_zero = 1 - mx.arange(0, dims // 2) / (dims // 2 - 1)
+        min_freq = math.log(min_freq)
+        max_freq = math.log(max_freq)
+
+        # Start with underscore so it is not included in the parameters
+        self._sigmas = mx.exp(one_zero * (max_freq - min_freq) + min_freq)
+        if full_turns:
+            self._sigmas = self._sigmas * (2 * math.pi)
+
+        # Save some constants that define the implementation
+        self.scale = scale or (2 / dims) ** 0.5
+        self.cos_first = cos_first
+
+    def __call__(self, x):
+        y = x[..., None] * self._sigmas
+        cosy = mx.cos(y)
+        siny = mx.sin(y)
+
+        if self.cos_first:
+            y = mx.concatenate([cosy, siny], axis=-1)
+        else:
+            y = mx.concatenate([siny, cosy], axis=-1)
+
+        if self.scale != 1:
+            y = y * self.scale
+
+        return y
+
+
+class ALiBi(Module):
+    _alibi_mask_key = None
+    _alibi_mask = None
+
+    @classmethod
+    def create_alibi_matrix(
+        cls,
+        q_sequence_length: int,
+        k_sequence_length: int,
+        num_heads: int,
+        offset: int,
+        dtype=mx.float32,
+    ):
+        if (
+            q_sequence_length,
+            k_sequence_length,
+            num_heads,
+            offset,
+            dtype,
+        ) != cls._alibi_mask_key:
+            x1 = mx.arange(offset, q_sequence_length)
+            x2 = mx.arange(0, k_sequence_length)
+            distance_matrix = -mx.abs(
+                mx.expand_dims(x1[:, None] - x2[None, :], axis=(0, 1))
+            )
+            alibi_slope = ALiBi.create_alibi_slope(num_heads=num_heads)
+            alibi_mask = (distance_matrix * alibi_slope).astype(dtype)
+            cls._alibi_mask_key = (
+                q_sequence_length,
+                k_sequence_length,
+                num_heads,
+                offset,
+                dtype,
+            )
+            cls._alibi_mask = alibi_mask
+
+        return cls._alibi_mask
+
+    @staticmethod
+    def create_alibi_slope(num_heads):
+        x = (2**8) ** (1 / num_heads)
+        out = mx.power(x, -mx.arange(1, num_heads + 1))
+        return mx.expand_dims(out, axis=(-1, -2))
+
+    def __call__(self, attention_scores, offset=0, mask=None):
+        alibi_mask = ALiBi.create_alibi_matrix(
+            q_sequence_length=attention_scores.shape[-2] + offset,
+            k_sequence_length=attention_scores.shape[-1],
+            num_heads=attention_scores.shape[1],
+            offset=offset,
+            dtype=attention_scores.dtype,
+        )
+        if mask is not None:
+            alibi_mask = alibi_mask + mask
+        return attention_scores + alibi_mask
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/quantized.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/quantized.py
new file mode 100644
index 0000000000000000000000000000000000000000..c308e884ba0c7ed415788b0d23921a8ac5a90212
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/quantized.py
@@ -0,0 +1,270 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+from typing import Callable, Optional, Union
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+from mlx.utils import tree_map_with_path
+
+
+def quantize(
+    model: Module,
+    group_size: int = 64,
+    bits: int = 4,
+    *,
+    mode: str = "affine",
+    class_predicate: Optional[Callable[[str, Module], Union[bool, dict]]] = None,
+):
+    """Quantize the sub-modules of a module according to a predicate.
+
+    By default all layers that define a ``to_quantized(group_size, bits)``
+    method will be quantized. Both :obj:`Linear` and :obj:`Embedding` layers
+    will be quantized. Note also, the module is updated in-place.
+
+    Args:
+        model (mlx.nn.Module): The model whose leaf modules may be quantized.
+        group_size (int): The quantization group size (see
+           :func:`mlx.core.quantize`). Default: ``64``.
+        bits (int): The number of bits per parameter (see
+           :func:`mlx.core.quantize`). Default: ``4``.
+        mode (str): The quantization method to use (see
+           :func:`mlx.core.quantize`). Default: ``"affine"``.
+        class_predicate (Optional[Callable]): A callable which receives the
+          :obj:`Module` path and :obj:`Module` itself and returns ``True`` or a
+          dict of params for `to_quantized` if it should be quantized and
+          ``False`` otherwise. If ``None``, then all layers that define a
+          ``to_quantized(group_size, bits)`` method are quantized.
+          Default: ``None``.
+    """
+    class_predicate = class_predicate or (lambda _, m: hasattr(m, "to_quantized"))
+
+    def _maybe_quantize(path, m):
+        if bool_or_params := class_predicate(path, m):
+            if hasattr(m, "to_quantized"):
+                if isinstance(bool_or_params, bool):
+                    return m.to_quantized(group_size=group_size, bits=bits, mode=mode)
+                elif isinstance(bool_or_params, dict):
+                    return m.to_quantized(**bool_or_params)
+                else:
+                    raise ValueError(
+                        "``class_predicate`` must return a bool"
+                        " or a dict of parameters to pass to ``to_quantized``"
+                    )
+            else:
+                raise ValueError(f"Unable to quantize model of type {type(m)}")
+        else:
+            return m
+
+    leaves = model.leaf_modules()
+    leaves = tree_map_with_path(_maybe_quantize, leaves, is_leaf=Module.is_module)
+    model.update_modules(leaves)
+
+
+class QuantizedEmbedding(Module):
+    """The same as :obj:`Embedding` but with a  quantized weight matrix.
+
+    :obj:`QuantizedEmbedding` also provides a :meth:`from_embedding`
+    classmethod to convert embedding layers to :obj:`QuantizedEmbedding`
+    layers.
+
+    Args:
+        num_embeddings (int): How many possible discrete tokens can we embed.
+           Usually called the vocabulary size.
+        dims (int): The dimensionality of the embeddings.
+        group_size (int, optional): The group size to use for the quantized
+            weight. See :func:`~mlx.core.quantize`. Default: ``64``.
+        bits (int, optional): The bit width to use for the quantized weight.
+            See :func:`~mlx.core.quantize`. Default: ``4``.
+        mode (str): The quantization method to use (see
+           :func:`mlx.core.quantize`). Default: ``"affine"``.
+    """
+
+    def __init__(
+        self,
+        num_embeddings: int,
+        dims: int,
+        group_size: int = 64,
+        bits: int = 4,
+        mode: str = "affine",
+    ):
+        super().__init__()
+
+        # Quantization config
+        self.group_size = group_size
+        self.bits = bits
+        self.mode = mode
+
+        # Initialize the quantized weight
+        scale = math.sqrt(1 / dims)
+        weight = mx.random.normal(shape=(num_embeddings, dims), scale=scale)
+        self.weight, self.scales, *biases = mx.quantize(
+            weight, group_size, bits, mode=mode
+        )
+        self.biases = biases[0] if biases else None
+        self.num_embeddings = num_embeddings
+        self.dims = dims
+
+        # Freeze this model's parameters
+        self.freeze()
+
+    def __call__(self, x):
+        biases = self.get("biases")
+        return mx.dequantize(
+            self["weight"][x],
+            scales=self["scales"][x],
+            biases=biases[x] if biases is not None else None,
+            group_size=self.group_size,
+            bits=self.bits,
+            mode=self.mode,
+        )
+
+    def as_linear(self, x):
+        """
+        Call the quantized embedding layer as a quantized linear layer.
+
+        Use this for example when input embedding and output projection
+        weights are tied.
+        """
+        return mx.quantized_matmul(
+            x,
+            self["weight"],
+            scales=self["scales"],
+            biases=self.get("biases"),
+            transpose=True,
+            group_size=self.group_size,
+            bits=self.bits,
+            mode=self.mode,
+        )
+
+    def _extra_repr(self):
+        return (
+            f"{self.num_embeddings}, {self.dims}, "
+            f"group_size={self.group_size}, bits={self.bits}, mode={self.mode}"
+        )
+
+    @classmethod
+    def from_embedding(
+        cls,
+        embedding_layer: Module,
+        group_size: int = 64,
+        bits: int = 4,
+        mode: str = "affine",
+    ):
+        """Create a :obj:`QuantizedEmbedding` layer from an :obj:`Embedding` layer."""
+        embedding_dims, dims = embedding_layer.weight.shape
+        ql = cls(embedding_dims, dims, group_size, bits, mode=mode)
+        ql.weight, ql.scales, *biases = mx.quantize(
+            embedding_layer.weight,
+            group_size,
+            bits,
+            mode=mode,
+        )
+        ql.biases = biases[0] if biases else None
+        return ql
+
+
+class QuantizedLinear(Module):
+    """Applies an affine transformation to the input using a quantized weight matrix.
+
+    It is the quantized equivalent of :class:`mlx.nn.Linear`. For now its
+    parameters are frozen and will not be included in any gradient computation
+    but this will probably change in the future.
+
+    :obj:`QuantizedLinear` also provides a classmethod :meth:`from_linear` to
+    convert linear layers to :obj:`QuantizedLinear` layers.
+
+    Args:
+        input_dims (int): The dimensionality of the input features.
+        output_dims (int): The dimensionality of the output features.
+        bias (bool, optional): If set to ``False`` then the layer will not use
+            a bias. Default: ``True``.
+        group_size (int, optional): The group size to use for the quantized
+            weight. See :func:`~mlx.core.quantize`. Default: ``64``.
+        bits (int, optional): The bit width to use for the quantized weight.
+            See :func:`~mlx.core.quantize`. Default: ``4``.
+        mode (str): The quantization method to use (see
+           :func:`mlx.core.quantize`). Default: ``"affine"``.
+    """
+
+    def __init__(
+        self,
+        input_dims: int,
+        output_dims: int,
+        bias: bool = True,
+        group_size: int = 64,
+        bits: int = 4,
+        mode: str = "affine",
+    ):
+        super().__init__()
+
+        # Quantization config
+        self.group_size = group_size
+        self.bits = bits
+        self.mode = mode
+
+        # Initialize the quantized weight
+        scale = math.sqrt(1 / input_dims)
+        weight = mx.random.uniform(
+            low=-scale,
+            high=scale,
+            shape=(output_dims, input_dims),
+        )
+        self.weight, self.scales, *biases = mx.quantize(
+            weight, group_size, bits, mode=mode
+        )
+        self.biases = biases[0] if biases else None
+
+        # And bias if needed
+        if bias:
+            self.bias = mx.zeros((output_dims,))
+
+        # Freeze this model's parameters
+        self.freeze()
+
+    def _extra_repr(self):
+        out_dims, in_dims = self.weight.shape
+        in_dims *= 32 // self.bits
+        return (
+            f"input_dims={in_dims}, output_dims={out_dims}, bias={'bias' in self}, "
+            f"group_size={self.group_size}, bits={self.bits}, mode={self.mode}"
+        )
+
+    def __call__(self, x):
+        x = mx.quantized_matmul(
+            x,
+            self["weight"],
+            scales=self["scales"],
+            biases=self.get("biases"),
+            transpose=True,
+            group_size=self.group_size,
+            bits=self.bits,
+            mode=self.mode,
+        )
+        if "bias" in self:
+            x = x + self["bias"]
+        return x
+
+    @classmethod
+    def from_linear(
+        cls,
+        linear_layer: Module,
+        group_size: int = 64,
+        bits: int = 4,
+        mode: str = "affine",
+    ):
+        """Create a :obj:`QuantizedLinear` layer from a :obj:`Linear` layer."""
+        output_dims, input_dims = linear_layer.weight.shape
+        ql = cls(input_dims, output_dims, False, group_size, bits, mode=mode)
+        ql.weight, ql.scales, *biases = mx.quantize(
+            linear_layer.weight,
+            group_size,
+            bits,
+            mode=mode,
+        )
+        ql.biases = biases[0] if biases else None
+
+        if "bias" in linear_layer:
+            ql.bias = linear_layer.bias
+
+        return ql
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/recurrent.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/recurrent.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ffa7654c3e07afbe6c091339179c2464747de18
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/recurrent.py
@@ -0,0 +1,289 @@
+# Copyright © 2024 Apple Inc.
+
+import math
+from typing import Callable, Optional
+
+import mlx.core as mx
+from mlx.nn.layers.activations import tanh
+from mlx.nn.layers.base import Module
+
+
+class RNN(Module):
+    r"""An Elman recurrent layer.
+
+    The input is a sequence of shape ``NLD`` or ``LD`` where:
+
+    * ``N`` is the optional batch dimension
+    * ``L`` is the sequence length
+    * ``D`` is the input's feature dimension
+
+    Concretely, for each element along the sequence length axis, this
+    layer applies the function:
+
+    .. math::
+
+        h_{t + 1} = \text{tanh} (W_{ih}x_t + W_{hh}h_t + b)
+
+    The hidden state :math:`h` has shape ``NH`` or ``H``, depending on
+    whether the input is batched or not. Returns the hidden state at each
+    time step, of shape ``NLH`` or ``LH``.
+
+    Args:
+        input_size (int): Dimension of the input, ``D``.
+        hidden_size (int): Dimension of the hidden state, ``H``.
+        bias (bool, optional): Whether to use a bias. Default: ``True``.
+        nonlinearity (callable, optional): Non-linearity to use. If ``None``,
+            then func:`tanh` is used. Default: ``None``.
+    """
+
+    def __init__(
+        self,
+        input_size: int,
+        hidden_size: int,
+        bias: bool = True,
+        nonlinearity: Optional[Callable] = None,
+    ):
+        super().__init__()
+
+        self.nonlinearity = nonlinearity or tanh
+        if not callable(self.nonlinearity):
+            raise ValueError(
+                f"Nonlinearity must be callable. Current value: {nonlinearity}."
+            )
+
+        scale = 1.0 / math.sqrt(hidden_size)
+        self.hidden_size = hidden_size
+        self.Wxh = mx.random.uniform(
+            low=-scale, high=scale, shape=(hidden_size, input_size)
+        )
+        self.Whh = mx.random.uniform(
+            low=-scale, high=scale, shape=(hidden_size, hidden_size)
+        )
+        self.bias = (
+            mx.random.uniform(low=-scale, high=scale, shape=(hidden_size,))
+            if bias
+            else None
+        )
+
+    def _extra_repr(self):
+        return (
+            f"input_dims={self.Wxh.shape[1]}, "
+            f"hidden_size={self.hidden_size}, "
+            f"nonlinearity={self.nonlinearity}, bias={self.bias is not None}"
+        )
+
+    def __call__(self, x, hidden=None):
+        if self.bias is not None:
+            x = mx.addmm(self.bias, x, self.Wxh.T)
+        else:
+            x = x @ self.Wxh.T
+
+        all_hidden = []
+        for idx in range(x.shape[-2]):
+            if hidden is not None:
+                hidden = mx.addmm(x[..., idx, :], hidden, self.Whh.T)
+            else:
+                hidden = x[..., idx, :]
+            hidden = self.nonlinearity(hidden)
+            all_hidden.append(hidden)
+
+        return mx.stack(all_hidden, axis=-2)
+
+
+class GRU(Module):
+    r"""A gated recurrent unit (GRU) RNN layer.
+
+    The input has shape ``NLD`` or ``LD`` where:
+
+    * ``N`` is the optional batch dimension
+    * ``L`` is the sequence length
+    * ``D`` is the input's feature dimension
+
+    Concretely, for each element of the sequence, this layer computes:
+
+    .. math::
+
+        \begin{aligned}
+        r_t &= \sigma (W_{xr}x_t + W_{hr}h_t + b_{r}) \\
+        z_t &= \sigma (W_{xz}x_t + W_{hz}h_t + b_{z}) \\
+        n_t &= \text{tanh}(W_{xn}x_t + b_{n} + r_t \odot (W_{hn}h_t + b_{hn})) \\
+        h_{t + 1} &= (1 - z_t) \odot n_t + z_t \odot h_t
+        \end{aligned}
+
+    The hidden state :math:`h` has shape ``NH`` or ``H`` depending on
+    whether the input is batched or not. Returns the hidden state at each
+    time step of shape ``NLH`` or ``LH``.
+
+    Args:
+        input_size (int): Dimension of the input, ``D``.
+        hidden_size (int): Dimension of the hidden state, ``H``.
+        bias (bool): Whether to use biases or not. Default: ``True``.
+    """
+
+    def __init__(
+        self,
+        input_size: int,
+        hidden_size: int,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        self.hidden_size = hidden_size
+        scale = 1.0 / math.sqrt(hidden_size)
+        self.Wx = mx.random.uniform(
+            low=-scale, high=scale, shape=(3 * hidden_size, input_size)
+        )
+        self.Wh = mx.random.uniform(
+            low=-scale, high=scale, shape=(3 * hidden_size, hidden_size)
+        )
+        self.b = (
+            mx.random.uniform(low=-scale, high=scale, shape=(3 * hidden_size,))
+            if bias
+            else None
+        )
+        self.bhn = (
+            mx.random.uniform(low=-scale, high=scale, shape=(hidden_size,))
+            if bias
+            else None
+        )
+
+    def _extra_repr(self):
+        return (
+            f"input_dims={self.Wx.shape[1]}, "
+            f"hidden_size={self.hidden_size}, bias={self.b is not None}"
+        )
+
+    def __call__(self, x, hidden=None):
+        if self.b is not None:
+            x = mx.addmm(self.b, x, self.Wx.T)
+        else:
+            x = x @ self.Wx.T
+
+        x_rz = x[..., : -self.hidden_size]
+        x_n = x[..., -self.hidden_size :]
+
+        all_hidden = []
+
+        for idx in range(x.shape[-2]):
+            rz = x_rz[..., idx, :]
+            if hidden is not None:
+                h_proj = hidden @ self.Wh.T
+                h_proj_rz = h_proj[..., : -self.hidden_size]
+                h_proj_n = h_proj[..., -self.hidden_size :]
+
+                if self.bhn is not None:
+                    h_proj_n += self.bhn
+
+                rz = rz + h_proj_rz
+
+            rz = mx.sigmoid(rz)
+
+            r, z = mx.split(rz, 2, axis=-1)
+
+            n = x_n[..., idx, :]
+
+            if hidden is not None:
+                n = n + r * h_proj_n
+            n = mx.tanh(n)
+
+            if hidden is not None:
+                hidden = (1 - z) * n + z * hidden
+            else:
+                hidden = (1 - z) * n
+
+            all_hidden.append(hidden)
+
+        return mx.stack(all_hidden, axis=-2)
+
+
+class LSTM(Module):
+    r"""An LSTM recurrent layer.
+
+    The input has shape ``NLD`` or ``LD`` where:
+
+    * ``N`` is the optional batch dimension
+    * ``L`` is the sequence length
+    * ``D`` is the input's feature dimension
+
+    Concretely, for each element of the sequence, this layer computes:
+
+    .. math::
+        \begin{aligned}
+        i_t &= \sigma (W_{xi}x_t + W_{hi}h_t + b_{i}) \\
+        f_t &= \sigma (W_{xf}x_t + W_{hf}h_t + b_{f}) \\
+        g_t &= \text{tanh} (W_{xg}x_t + W_{hg}h_t + b_{g}) \\
+        o_t &= \sigma (W_{xo}x_t + W_{ho}h_t + b_{o}) \\
+        c_{t + 1} &= f_t \odot c_t + i_t \odot g_t \\
+        h_{t + 1} &= o_t \text{tanh}(c_{t + 1})
+        \end{aligned}
+
+    The hidden state :math:`h` and cell state :math:`c` have shape ``NH``
+    or ``H``, depending on whether the input is batched or not.
+
+    The layer returns two arrays, the hidden state and the cell state at
+    each time step, both of shape ``NLH`` or ``LH``.
+
+    Args:
+        input_size (int): Dimension of the input, ``D``.
+        hidden_size (int): Dimension of the hidden state, ``H``.
+        bias (bool): Whether to use biases or not. Default: ``True``.
+    """
+
+    def __init__(
+        self,
+        input_size: int,
+        hidden_size: int,
+        bias: bool = True,
+    ):
+        super().__init__()
+
+        self.hidden_size = hidden_size
+        scale = 1.0 / math.sqrt(hidden_size)
+        self.Wx = mx.random.uniform(
+            low=-scale, high=scale, shape=(4 * hidden_size, input_size)
+        )
+        self.Wh = mx.random.uniform(
+            low=-scale, high=scale, shape=(4 * hidden_size, hidden_size)
+        )
+        self.bias = (
+            mx.random.uniform(low=-scale, high=scale, shape=(4 * hidden_size,))
+            if bias
+            else None
+        )
+
+    def _extra_repr(self):
+        return (
+            f"input_dims={self.Wx.shape[1]}, "
+            f"hidden_size={self.hidden_size}, bias={self.bias is not None}"
+        )
+
+    def __call__(self, x, hidden=None, cell=None):
+        if self.bias is not None:
+            x = mx.addmm(self.bias, x, self.Wx.T)
+        else:
+            x = x @ self.Wx.T
+
+        all_hidden = []
+        all_cell = []
+
+        for idx in range(x.shape[-2]):
+            ifgo = x[..., idx, :]
+            if hidden is not None:
+                ifgo = mx.addmm(ifgo, hidden, self.Wh.T)
+            i, f, g, o = mx.split(ifgo, 4, axis=-1)
+
+            i = mx.sigmoid(i)
+            f = mx.sigmoid(f)
+            g = mx.tanh(g)
+            o = mx.sigmoid(o)
+
+            if cell is not None:
+                cell = f * cell + i * g
+            else:
+                cell = i * g
+            hidden = o * mx.tanh(cell)
+
+            all_cell.append(cell)
+            all_hidden.append(hidden)
+
+        return mx.stack(all_hidden, axis=-2), mx.stack(all_cell, axis=-2)
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/transformer.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/transformer.py
new file mode 100644
index 0000000000000000000000000000000000000000..d856f2554f79a3a746ae1f4ef7e384007ccf3e29
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/transformer.py
@@ -0,0 +1,354 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Any, Callable, Optional
+
+import mlx.core as mx
+from mlx.nn.layers.activations import relu
+from mlx.nn.layers.base import Module
+from mlx.nn.layers.dropout import Dropout
+from mlx.nn.layers.linear import Linear
+from mlx.nn.layers.normalization import LayerNorm
+from mlx.nn.utils import checkpoint
+
+
+class MultiHeadAttention(Module):
+    """Implements the scaled dot product attention with multiple heads.
+
+    Given inputs for queries, keys and values the ``MultiHeadAttention``
+    produces new values by aggregating information from the input values
+    according to the similarities of the input queries and keys.
+
+    All inputs as well as the output are linearly projected without biases by
+    default.
+
+    ``MultiHeadAttention`` also takes an optional additive attention mask that
+    should be broadcastable with ``(batch, num_heads, # queries, # keys)``. The
+    mask should have ``-inf`` or very large negative numbers at the positions
+    that should *not* be attended to.
+
+    Args:
+        dims (int): The model dimensions. This is also the default
+            value for the queries, keys, values, and the output.
+        num_heads (int): The number of attention heads to use.
+        query_input_dims (int, optional): The input dimensions of the queries.
+            Default: ``dims``.
+        key_input_dims (int, optional): The input dimensions of the keys.
+            Default: ``dims``.
+        value_input_dims (int, optional): The input dimensions of the values.
+            Default: ``key_input_dims``.
+        value_dims (int, optional): The dimensions of the values after the
+            projection. Default: ``dims``.
+        value_output_dims (int, optional): The dimensions the new values will
+            be projected to. Default: ``dims``.
+        bias (bool, optional): Whether or not to use a bias in the projections.
+            Default: ``False``.
+    """
+
+    def __init__(
+        self,
+        dims: int,
+        num_heads: int,
+        query_input_dims: Optional[int] = None,
+        key_input_dims: Optional[int] = None,
+        value_input_dims: Optional[int] = None,
+        value_dims: Optional[int] = None,
+        value_output_dims: Optional[int] = None,
+        bias: bool = False,
+    ):
+        super().__init__()
+
+        if (dims % num_heads) != 0:
+            raise ValueError(
+                "The input feature dimensions should be divisible by the "
+                f"number of heads ({dims} % {num_heads}) != 0"
+            )
+
+        query_input_dims = query_input_dims or dims
+        key_input_dims = key_input_dims or dims
+        value_input_dims = value_input_dims or key_input_dims
+        value_dims = value_dims or dims
+        value_output_dims = value_output_dims or dims
+
+        self.num_heads = num_heads
+        self.query_proj = Linear(query_input_dims, dims, bias=bias)
+        self.key_proj = Linear(key_input_dims, dims, bias=bias)
+        self.value_proj = Linear(value_input_dims, value_dims, bias=bias)
+        self.out_proj = Linear(value_dims, value_output_dims, bias=bias)
+
+    def __call__(self, queries, keys, values, mask=None):
+        queries = self.query_proj(queries)
+        keys = self.key_proj(keys)
+        values = self.value_proj(values)
+
+        num_heads = self.num_heads
+        queries = mx.unflatten(queries, -1, (num_heads, -1)).transpose(0, 2, 1, 3)
+        keys = mx.unflatten(keys, -1, (num_heads, -1)).transpose(0, 2, 1, 3)
+        values = mx.unflatten(values, -1, (num_heads, -1)).transpose(0, 2, 1, 3)
+        scale = math.sqrt(1 / queries.shape[-1])
+        output = mx.fast.scaled_dot_product_attention(
+            queries, keys, values, scale=scale, mask=mask
+        )
+        output = output.transpose(0, 2, 1, 3).flatten(-2, -1)
+        return self.out_proj(output)
+
+    @staticmethod
+    def create_additive_causal_mask(N: int, dtype: mx.Dtype = mx.float32):
+        indices = mx.arange(N)
+        mask = indices[:, None] < indices[None]
+        mask = mask.astype(dtype) * mx.finfo(dtype).min
+        return mask
+
+
+class TransformerEncoderLayer(Module):
+    def __init__(
+        self,
+        dims: int,
+        num_heads: int,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation: Callable[[Any], Any] = relu,
+        norm_first: bool = True,
+    ):
+        super().__init__()
+        mlp_dims = mlp_dims or dims * 4
+        self.attention = MultiHeadAttention(dims, num_heads)
+        self.ln1 = LayerNorm(dims)
+        self.ln2 = LayerNorm(dims)
+        self.linear1 = Linear(dims, mlp_dims)
+        self.linear2 = Linear(mlp_dims, dims)
+        self.dropout1 = Dropout(dropout)
+        self.dropout2 = Dropout(dropout)
+        self.activation = activation
+        self.norm_first = norm_first
+
+    def __call__(self, x, mask):
+        if self.norm_first:
+            y = self.ln1(x)
+            y = self.attention(y, y, y, mask)
+            y = self.dropout1(y)
+            x = x + y
+
+            y = self.ln2(x)
+            y = self.linear1(y)
+            y = self.activation(y)
+            y = self.dropout2(y)
+            y = self.linear2(y)
+            y = x + y
+
+        else:
+            y = self.attention(x, x, x, mask)
+            y = self.dropout1(y)
+            x = self.ln1(x + y)
+
+            y = self.linear1(x)
+            y = self.activation(y)
+            y = self.dropout2(y)
+            y = self.linear2(y)
+            y = self.ln2(x + y)
+
+        return y
+
+
+class TransformerEncoder(Module):
+    def __init__(
+        self,
+        num_layers: int,
+        dims: int,
+        num_heads: int,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation=relu,
+        norm_first: bool = True,
+        checkpoint: bool = False,
+    ):
+        super().__init__()
+        self.layers = [
+            TransformerEncoderLayer(
+                dims, num_heads, mlp_dims, dropout, activation, norm_first
+            )
+            for i in range(num_layers)
+        ]
+        self.ln = LayerNorm(dims)
+        self.checkpoint = checkpoint
+
+    def __call__(self, x, mask):
+        for l in self.layers:
+            l = checkpoint(l) if self.checkpoint else l
+            x = l(x, mask)
+        return self.ln(x)
+
+
+class TransformerDecoderLayer(Module):
+    def __init__(
+        self,
+        dims: int,
+        num_heads: int,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation: Callable[[Any], Any] = relu,
+        norm_first: bool = True,
+    ):
+        super().__init__()
+        mlp_dims = mlp_dims or dims * 4
+        self.self_attention = MultiHeadAttention(dims, num_heads)
+        self.cross_attention = MultiHeadAttention(dims, num_heads)
+        self.ln1 = LayerNorm(dims)
+        self.ln2 = LayerNorm(dims)
+        self.ln3 = LayerNorm(dims)
+        self.linear1 = Linear(dims, mlp_dims)
+        self.linear2 = Linear(mlp_dims, dims)
+        self.dropout1 = Dropout(dropout)
+        self.dropout2 = Dropout(dropout)
+        self.dropout3 = Dropout(dropout)
+        self.activation = activation
+        self.norm_first = norm_first
+
+    def __call__(self, x, memory, x_mask, memory_mask):
+        if self.norm_first:
+            y = self.ln1(x)
+            y = self.self_attention(y, y, y, x_mask)
+            y = self.dropout1(y)
+            x = x + y
+
+            y = self.ln2(x)
+            y = self.cross_attention(y, memory, memory, memory_mask)
+            y = self.dropout2(y)
+            x = x + y
+
+            y = self.ln3(x)
+            y = self.linear1(y)
+            y = self.activation(y)
+            y = self.dropout3(y)
+            y = self.linear2(y)
+            y = x + y
+
+        else:
+            y = self.self_attention(x, x, x, x_mask)
+            y = self.dropout1(y)
+            x = self.ln1(x + y)
+
+            y = self.cross_attention(y, memory, memory, memory_mask)
+            y = self.dropout2(y)
+            x = self.ln2(x + y)
+
+            y = self.linear1(x)
+            y = self.activation(y)
+            y = self.dropout3(y)
+            y = self.linear2(y)
+            y = self.ln3(x + y)
+
+        return y
+
+
+class TransformerDecoder(Module):
+    def __init__(
+        self,
+        num_layers: int,
+        dims: int,
+        num_heads: int,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation=relu,
+        norm_first: bool = True,
+        checkpoint: bool = False,
+    ):
+        super().__init__()
+        self.layers = [
+            TransformerDecoderLayer(
+                dims, num_heads, mlp_dims, dropout, activation, norm_first
+            )
+            for i in range(num_layers)
+        ]
+        self.ln = LayerNorm(dims)
+        self.checkpoint = checkpoint
+
+    def __call__(self, x, memory, x_mask, memory_mask):
+        for l in self.layers:
+            l = checkpoint(l) if self.checkpoint else l
+            x = l(x, memory, x_mask, memory_mask)
+        return self.ln(x)
+
+
+class Transformer(Module):
+    """
+    Implements a standard Transformer model.
+
+    The implementation is based on `Attention Is All You Need
+    <https://arxiv.org/abs/1706.03762>`_.
+
+    The Transformer model contains an encoder and a decoder. The encoder
+    processes the input sequence and the decoder generates the output sequence.
+    The interaction between encoder and decoder happens through the attention
+    mechanism.
+
+    Args:
+        dims (int, optional): The number of expected features in the
+            encoder/decoder inputs. Default: ``512``.
+        num_heads (int, optional): The number of attention heads. Default:
+            ``8``.
+        num_encoder_layers (int, optional): The number of encoder layers in the
+            Transformer encoder. Default: ``6``.
+        num_decoder_layers (int, optional): The number of decoder layers in the
+            Transformer decoder. Default: ``6``.
+        mlp_dims (int, optional): The hidden dimension of the MLP block in each
+            Transformer layer. Defaults to ``4*dims`` if not provided. Default:
+            ``None``.
+        dropout (float, optional): The dropout value for the Transformer
+            encoder and decoder. Dropout is used after each attention layer and
+            the activation in the MLP layer. Default: ``0.0``.
+        activation (function, optional): the activation function for the MLP
+            hidden layer. Default: :func:`mlx.nn.relu`.
+        custom_encoder (nn.Module, optional): A custom encoder to replace the
+            standard Transformer encoder. Default: ``None``.
+        custom_decoder (nn.Module, optional): A custom decoder to replace the
+            standard Transformer decoder. Default: ``None``.
+        norm_first (bool, optional): if ``True``, encoder and decoder layers
+            will perform layer normalization before attention and MLP
+            operations, otherwise after. Default: ``True``.
+        checkpoint (bool, optional): if ``True`` perform gradient checkpointing
+            to reduce the memory usage at the expense of more computation.
+            Default: ``False``.
+    """
+
+    def __init__(
+        self,
+        dims: int = 512,
+        num_heads: int = 8,
+        num_encoder_layers: int = 6,
+        num_decoder_layers: int = 6,
+        mlp_dims: Optional[int] = None,
+        dropout: float = 0.0,
+        activation: Callable[[Any], Any] = relu,
+        custom_encoder: Optional[Any] = None,
+        custom_decoder: Optional[Any] = None,
+        norm_first: bool = True,
+        checkpoint: bool = False,
+    ):
+        super().__init__()
+
+        self.encoder = custom_encoder or TransformerEncoder(
+            num_encoder_layers,
+            dims,
+            num_heads,
+            mlp_dims,
+            dropout,
+            activation,
+            norm_first,
+            checkpoint,
+        )
+
+        self.decoder = custom_decoder or TransformerDecoder(
+            num_decoder_layers,
+            dims,
+            num_heads,
+            mlp_dims,
+            dropout,
+            activation,
+            norm_first,
+            checkpoint,
+        )
+
+    def __call__(self, src, tgt, src_mask, tgt_mask, memory_mask):
+        memory = self.encoder(src, src_mask)
+        return self.decoder(tgt, memory, tgt_mask, memory_mask)
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/layers/upsample.py b/ml-stable-diffusion/mlx/python/mlx/nn/layers/upsample.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6bd282af1a7f6538d3fb56ef83e48449c97954e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/layers/upsample.py
@@ -0,0 +1,277 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import operator
+from functools import partial, reduce
+from itertools import product
+from typing import Callable, Literal, Tuple, Union
+
+import mlx.core as mx
+from mlx.nn.layers.base import Module
+
+
+def _scaled_indices(N, scale, align_corners, dim, ndims):
+    M = int(scale * N)
+    if align_corners:
+        indices = mx.arange(M, dtype=mx.float32) * ((N - 1) / (M - 1))
+    else:
+        step = 1 / scale
+        start = ((M - 1) * step - N + 1) / 2
+        indices = mx.arange(M, dtype=mx.float32) * step - start
+
+    shape = [1] * ndims
+    shape[dim] = -1
+
+    return indices.reshape(shape)
+
+
+def _nearest_indices(N, scale, dim, ndims):
+    M = int(scale * N)
+    indices = mx.arange(M, dtype=mx.float32)
+    if M > N:
+        indices = (indices + 0.5) * (N / M) - 0.5
+        indices = indices.round()
+    else:
+        indices = indices * (N / M)
+    shape = [1] * ndims
+    shape[dim] = -1
+    return indices.astype(mx.uint32).reshape(shape)
+
+
+def _linear_indices(N, scale, align_corners, dim, ndims):
+    indices = _scaled_indices(N, scale, align_corners, dim, ndims)
+    indices = mx.clip(indices, a_min=0, a_max=N - 1)
+    indices_l = mx.floor(indices)
+    indices_r = mx.ceil(indices)
+    weight = indices - indices_l
+    weight = mx.expand_dims(weight, -1)
+
+    return (
+        (indices_l.astype(mx.uint32), 1 - weight),
+        (indices_r.astype(mx.uint32), weight),
+    )
+
+
+def _cubic_indices(N, scale, align_corners, dim, ndims):
+    indices = _scaled_indices(N, scale, align_corners, dim, ndims)
+    indices_l1 = mx.floor(indices)
+    indices_r1 = mx.floor(indices + 1)
+    indices_l2 = indices_l1 - 1
+    indices_r2 = indices_r1 + 1
+
+    @partial(mx.compile, shapeless=True)
+    def _get_weight(ind, grid, dist):
+        # PyTorch uses -0.5 for antialiasing=true (compatibility with PIL)
+        # and uses -0.75 for antialiasing=false (compatibility with OpenCV)
+        a = -0.75
+        x = mx.abs(ind - grid)
+        if dist == 1:
+            weight = ((a + 2.0) * x - (a + 3.0)) * x * x + 1
+        else:
+            weight = (((x - 5) * x + 8) * x - 4) * a
+        return weight
+
+    weight_l1 = _get_weight(indices, indices_l1, dist=1)[..., None]
+    weight_r1 = _get_weight(indices, indices_r1, dist=1)[..., None]
+    weight_l2 = _get_weight(indices, indices_l2, dist=2)[..., None]
+    weight_r2 = _get_weight(indices, indices_r2, dist=2)[..., None]
+
+    # padding with border value
+    indices_l1 = mx.clip(indices_l1, a_min=0, a_max=N - 1)
+    indices_r1 = mx.clip(indices_r1, a_min=0, a_max=N - 1)
+    indices_l2 = mx.clip(indices_l2, a_min=0, a_max=N - 1)
+    indices_r2 = mx.clip(indices_r2, a_min=0, a_max=N - 1)
+
+    return (
+        (indices_l1.astype(mx.uint32), weight_l1),
+        (indices_r1.astype(mx.uint32), weight_r1),
+        (indices_l2.astype(mx.uint32), weight_l2),
+        (indices_r2.astype(mx.uint32), weight_r2),
+    )
+
+
+def upsample_nearest(x: mx.array, scale_factor: Tuple):
+    dims = x.ndim - 2
+    if dims != len(scale_factor):
+        raise ValueError("A scale needs to be provided for each spatial dimension")
+
+    # Integer scale_factors means we can simply expand-broadcast and reshape
+    if tuple(map(int, scale_factor)) == scale_factor:
+        shape = list(x.shape)
+        for d in range(dims):
+            shape.insert(2 + 2 * d, 1)
+        x = x.reshape(shape)
+        for d in range(dims):
+            shape[2 + 2 * d] = int(scale_factor[d])
+        x = mx.broadcast_to(x, shape)
+        for d in range(dims):
+            shape[d + 1] *= shape[d + 2]
+            shape.pop(d + 2)
+        x = x.reshape(shape)
+        return x
+
+    else:
+        B, *N, C = x.shape
+        indices = [slice(None)]
+        for i, (n, s) in enumerate(zip(N, scale_factor)):
+            indices.append(_nearest_indices(n, s, i, dims))
+        indices = tuple(indices)
+
+        return x[indices]
+
+
+def _interpolate(
+    x: mx.array, scale_factor: Tuple, indices_fn: Callable, align_corners: bool = False
+):
+    dims = x.ndim - 2
+    if dims != len(scale_factor):
+        raise ValueError("A scale needs to be provided for each spatial dimension")
+
+    B, *N, C = x.shape
+
+    # Compute the sampling grid
+    indices = []
+    for i, (n, s) in enumerate(zip(N, scale_factor)):
+        indices.append(indices_fn(n, s, align_corners, i, dims))
+
+    # Sample and compute the weights
+    samples = []
+    weights = []
+    for idx_weight in product(*indices):
+        idx, weight = zip(*idx_weight)
+        samples.append(x[(slice(None),) + idx])
+        weights.append(reduce(operator.mul, weight))
+
+    # Interpolate
+    return sum(wi * xi for wi, xi in zip(weights, samples))
+
+
+def upsample_linear(x: mx.array, scale_factor: Tuple, align_corners: bool = False):
+    return _interpolate(
+        x=x,
+        scale_factor=scale_factor,
+        indices_fn=_linear_indices,
+        align_corners=align_corners,
+    )
+
+
+def upsample_cubic(x: mx.array, scale_factor: Tuple, align_corners: bool = False):
+    return _interpolate(
+        x=x,
+        scale_factor=scale_factor,
+        indices_fn=_cubic_indices,
+        align_corners=align_corners,
+    )
+
+
+class Upsample(Module):
+    r"""Upsample the input signal spatially.
+
+    The spatial dimensions are by convention dimensions ``1`` to ``x.ndim -
+    2``. The first is the batch dimension and the last is the feature
+    dimension.
+
+    For example, an audio signal would be 3D with 1 spatial dimension, an image
+    4D with 2 and so on and so forth.
+
+    There are three upsampling algorithms implemented nearest neighbor upsampling,
+    linear interpolation, and cubic interpolation. All can be applied to any number
+    of spatial dimensions. The linear interpolation will be bilinear, trilinear etc
+    when applied to more than one spatial dimension. And cubic interpolation will be
+    bicubic when there are 2 spatial dimensions.
+
+    .. note::
+       When using one of the linear or cubic interpolation modes the ``align_corners``
+       argument changes how the corners are treated in the input image. If
+       ``align_corners=True`` then the top and left edge of the input and
+       output will be matching as will the bottom right edge.
+
+    Parameters:
+        scale_factor (float or tuple): The multiplier for the spatial size.
+            If a ``float`` is provided, it is the multiplier for all spatial dimensions.
+            Otherwise, the number of scale factors provided must match the
+            number of spatial dimensions.
+        mode (str, optional): The upsampling algorithm, either ``"nearest"``,
+            ``"linear"`` or ``"cubic"``. Default: ``"nearest"``.
+        align_corners (bool, optional): Changes the way the corners are treated
+            during ``"linear"`` and ``"cubic"`` upsampling.  See the note above and the
+            examples below for more details.  Default: ``False``.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+        >>> x = mx.arange(1, 5).reshape((1, 2, 2, 1))
+        >>> x
+        array([[[[1],
+                 [2]],
+                [[3],
+                 [4]]]], dtype=int32)
+        >>> n = nn.Upsample(scale_factor=2, mode='nearest')
+        >>> n(x).squeeze()
+        array([[1, 1, 2, 2],
+               [1, 1, 2, 2],
+               [3, 3, 4, 4],
+               [3, 3, 4, 4]], dtype=int32)
+        >>> b = nn.Upsample(scale_factor=2, mode='linear')
+        >>> b(x).squeeze()
+        array([[1, 1.25, 1.75, 2],
+               [1.5, 1.75, 2.25, 2.5],
+               [2.5, 2.75, 3.25, 3.5],
+               [3, 3.25, 3.75, 4]], dtype=float32)
+        >>> b = nn.Upsample(scale_factor=2, mode='linear', align_corners=True)
+        >>> b(x).squeeze()
+        array([[1, 1.33333, 1.66667, 2],
+               [1.66667, 2, 2.33333, 2.66667],
+               [2.33333, 2.66667, 3, 3.33333],
+               [3, 3.33333, 3.66667, 4]], dtype=float32)
+    """
+
+    def __init__(
+        self,
+        scale_factor: Union[float, Tuple],
+        mode: Literal["nearest", "linear", "cubic"] = "nearest",
+        align_corners: bool = False,
+    ):
+        super().__init__()
+        if mode not in ["nearest", "linear", "cubic"]:
+            raise ValueError(f"[Upsample] Got unsupported upsampling algorithm: {mode}")
+        if isinstance(scale_factor, (list, tuple)):
+            self.scale_factor = tuple(map(float, scale_factor))
+        else:
+            self.scale_factor = float(scale_factor)
+        self.mode = mode
+        self.align_corners = align_corners
+
+    def _extra_repr(self) -> str:
+        return (
+            f"scale_factor={self.scale_factor}, mode={self.mode!r}, "
+            f"align_corners={self.align_corners}"
+        )
+
+    def __call__(self, x: mx.array) -> mx.array:
+        dims = x.ndim - 2
+        if dims <= 0:
+            raise ValueError(
+                f"[Upsample] The input should have at least 1 spatial "
+                f"dimension which means it should be at least 3D but "
+                f"{x.ndim}D was provided"
+            )
+
+        scale_factor = self.scale_factor
+        if isinstance(scale_factor, tuple):
+            if len(scale_factor) != dims:
+                raise ValueError(
+                    f"[Upsample] One scale per spatial dimension is required but "
+                    f"scale_factor={scale_factor} and the number of spatial "
+                    f"dimensions were {dims}"
+                )
+        else:
+            scale_factor = (scale_factor,) * dims
+
+        if self.mode == "nearest":
+            return upsample_nearest(x, scale_factor)
+        elif self.mode == "linear":
+            return upsample_linear(x, scale_factor, self.align_corners)
+        elif self.mode == "cubic":
+            return upsample_cubic(x, scale_factor, self.align_corners)
+        else:
+            raise Exception(f"Unknown interpolation mode: {self.mode}")
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/losses.py b/ml-stable-diffusion/mlx/python/mlx/nn/losses.py
new file mode 100644
index 0000000000000000000000000000000000000000..b765d25dee091db2dc4663f104288a1c3c3712ec
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/losses.py
@@ -0,0 +1,610 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+from typing import Literal, Optional, get_args
+
+import mlx.core as mx
+
+Reduction = Literal["none", "mean", "sum"]
+
+
+def _reduce(loss: mx.array, reduction: Reduction = "none"):
+    if reduction not in get_args(Reduction):
+        raise ValueError(f"Invalid reduction. Must be one of {get_args(Reduction)}.")
+
+    if reduction == "mean":
+        return mx.mean(loss)
+    elif reduction == "sum":
+        return mx.sum(loss)
+    elif reduction == "none":
+        return loss
+
+
+def cross_entropy(
+    logits: mx.array,
+    targets: mx.array,
+    weights: Optional[mx.array] = None,
+    axis: int = -1,
+    label_smoothing: float = 0.0,
+    reduction: Reduction = "none",
+) -> mx.array:
+    """
+    Computes the cross entropy loss.
+
+    Args:
+        logits (array): The unnormalized logits.
+        targets (array): The ground truth values. These can be class indices or
+            probabilities for each class. If the ``targets`` are class indices,
+            then ``targets`` shape should match the ``logits`` shape with
+            the ``axis`` dimension removed. If the ``targets`` are probabilities
+            (or one-hot encoded), then the ``targets`` shape should be the same as
+            the ``logits`` shape.
+        weights (array, optional): Optional weights for each target. Default: ``None``.
+        axis (int, optional): The axis over which to compute softmax. Default: ``-1``.
+        label_smoothing (float, optional): Label smoothing factor. Default: ``0``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+            ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed cross entropy loss.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+        >>>
+        >>> # Class indices as targets
+        >>> logits = mx.array([[2.0, -1.0], [-1.0, 2.0]])
+        >>> targets = mx.array([0, 1])
+        >>> nn.losses.cross_entropy(logits, targets)
+        array([0.0485873, 0.0485873], dtype=float32)
+        >>>
+        >>> # Probabilities (or one-hot vectors) as targets
+        >>> logits = mx.array([[2.0, -1.0], [-1.0, 2.0]])
+        >>> targets = mx.array([[0.9, 0.1], [0.1, 0.9]])
+        >>> nn.losses.cross_entropy(logits, targets)
+        array([0.348587, 0.348587], dtype=float32)
+    """
+    if label_smoothing < 0 or label_smoothing >= 1:
+        raise ValueError(f"Label smoothing must in [0, 1), got {label_smoothing}.")
+
+    # Whether targets are class indices or probabilities
+    targets_as_probs = targets.ndim == logits.ndim
+
+    def _drop_dim(shape, axis):
+        shape = list(shape)
+        shape.pop(axis)
+        return tuple(shape)
+
+    # Check shapes in two cases: targets as class indices and targets as probabilities
+    if (targets_as_probs and targets.shape != logits.shape) or (
+        not targets_as_probs and targets.shape != _drop_dim(logits.shape, axis)
+    ):
+        raise ValueError(
+            f"Targets shape {targets.shape} does not match logits shape {logits.shape}."
+        )
+
+    if targets_as_probs:
+        score = mx.sum(logits * targets, axis=axis)
+    else:
+        score = mx.take_along_axis(logits, mx.expand_dims(targets, axis), axis).squeeze(
+            axis
+        )
+
+    logsumexp_logits = mx.logsumexp(logits, axis=axis)
+    if label_smoothing > 0:
+        # Adjust the true class score with label smoothing
+        adjusted_score = (1 - label_smoothing) * score
+
+        # Calculate the mean logit across the classes for smoothed loss
+        mean_logits = logits.mean(axis=axis)
+        smoothed_loss = -mean_logits * label_smoothing
+
+        # Combine the adjusted score and smoothed loss with the logsumexp logits
+        loss = logsumexp_logits - adjusted_score + smoothed_loss
+    else:
+        loss = logsumexp_logits - score
+
+    # Apply weights if provided
+    if weights is not None:
+        if weights.shape != loss.shape:
+            raise ValueError(
+                f"Weights with shape {weights.shape} is not the same as "
+                f"output loss with shape {loss.shape}."
+            )
+        loss *= weights
+
+    # Apply reduction
+    return _reduce(loss, reduction)
+
+
+def binary_cross_entropy(
+    inputs: mx.array,
+    targets: mx.array,
+    weights: Optional[mx.array] = None,
+    with_logits: bool = True,
+    reduction: Reduction = "mean",
+) -> mx.array:
+    """
+    Computes the binary cross entropy loss.
+
+    By default, this function takes the pre-sigmoid logits, which results in a faster
+    and more precise loss. For improved numerical stability when ``with_logits=False``,
+    the loss calculation clips the input probabilities (in log-space) to a minimum value
+    of ``-100``.
+
+    Args:
+        inputs (array): The predicted values. If ``with_logits`` is ``True``, then
+            ``inputs`` are unnormalized logits. Otherwise, ``inputs`` are probabilities.
+        targets (array): The binary target values in {0, 1}.
+        with_logits (bool, optional): Whether ``inputs`` are logits. Default: ``True``.
+        weights (array, optional): Optional weights for each target. Default: ``None``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``.
+
+    Returns:
+        array: The computed binary cross entropy loss.
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+
+        >>> logits = mx.array([0.105361, 0.223144, 1.20397, 0.916291])
+        >>> targets = mx.array([0, 0, 1, 1])
+        >>> loss = nn.losses.binary_cross_entropy(logits, targets, reduction="mean")
+        >>> loss
+        array(0.539245, dtype=float32)
+
+        >>> probs = mx.array([0.1, 0.1, 0.4, 0.4])
+        >>> targets = mx.array([0, 0, 1, 1])
+        >>> loss = nn.losses.binary_cross_entropy(probs, targets, with_logits=False, reduction="mean")
+        >>> loss
+        array(0.510826, dtype=float32)
+    """
+    if inputs.shape != targets.shape:
+        raise ValueError(
+            f"Inputs shape {inputs.shape} does not match targets shape {targets.shape}."
+        )
+
+    if with_logits:
+        loss = mx.logaddexp(0.0, inputs) - inputs * targets
+    else:
+        log_inputs_clip = mx.clip(mx.log(inputs), a_min=-100, a_max=None)
+        log_inputs_inv_clip = mx.clip(mx.log(1 - inputs), a_min=-100, a_max=None)
+        loss = -(targets * log_inputs_clip + (1 - targets) * log_inputs_inv_clip)
+
+    # Apply weights if provided
+    if weights is not None:
+        if weights.shape != loss.shape:
+            raise ValueError(
+                f"Weights with shape {weights.shape} is not the same as "
+                f"output loss with shape {loss.shape}."
+            )
+        loss *= weights
+
+    return _reduce(loss, reduction)
+
+
+def l1_loss(
+    predictions: mx.array, targets: mx.array, reduction: Reduction = "mean"
+) -> mx.array:
+    """
+    Computes the L1 loss.
+
+    Args:
+        predictions (array): The predicted values.
+        targets (array): The target values.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``.
+
+    Returns:
+        array: The computed L1 loss.
+    """
+    if predictions.shape != targets.shape:
+        raise ValueError(
+            f"Predictions shape {predictions.shape} does not match "
+            f"targets shape {targets.shape}."
+        )
+    loss = mx.abs(predictions - targets)
+
+    return _reduce(loss, reduction)
+
+
+def mse_loss(
+    predictions: mx.array, targets: mx.array, reduction: Reduction = "mean"
+) -> mx.array:
+    """
+    Computes the mean squared error loss.
+
+    Args:
+        predictions (array): The predicted values.
+        targets (array): The target values.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``.
+
+    Returns:
+        array: The computed mean squared error loss.
+    """
+    if predictions.shape != targets.shape:
+        raise ValueError(
+            f"Predictions shape {predictions.shape} does not match "
+            f"targets shape {targets.shape}."
+        )
+
+    loss = mx.square(predictions - targets)
+    return _reduce(loss, reduction)
+
+
+def nll_loss(
+    inputs: mx.array, targets: mx.array, axis: int = -1, reduction: Reduction = "none"
+) -> mx.array:
+    """
+    Computes the negative log likelihood loss.
+
+    Args:
+        inputs (array): The predicted distribution in log space.
+        targets (array): The target values.
+        axis (int, optional): The distribution axis. Default: ``-1``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed NLL loss.
+    """
+    loss = -mx.take_along_axis(inputs, targets[..., None], axis).squeeze(-1)
+
+    return _reduce(loss, reduction)
+
+
+def gaussian_nll_loss(
+    inputs: mx.array,
+    targets: mx.array,
+    vars: mx.array,
+    full: bool = False,
+    eps: float = 1e-6,
+    reduction: Reduction = "mean",
+) -> mx.array:
+    r"""
+    Computes the negative log likelihood loss for a Gaussian distribution.
+
+    The loss is given by:
+
+    .. math::
+        \frac{1}{2}\left(\log\left(\max\left(\text{vars},
+        \ \epsilon\right)\right) + \frac{\left(\text{inputs} - \text{targets} \right)^2}
+        {\max\left(\text{vars}, \ \epsilon \right)}\right) + \text{const.}
+
+    where ``inputs`` are the predicted means and ``vars`` are the the
+    predicted variances.
+
+    Args:
+        inputs (array): The predicted expectation of the Gaussian distribution.
+        targets (array): The target values (samples from the Gaussian distribution).
+        vars (array): The predicted variance of the Gaussian distribution.
+        full (bool, optional): Whether to include the constant term in the loss calculation.
+            Default: ``False``.
+        eps (float, optional): Small positive constant for numerical stability.
+            Default: ``1e-6``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The Gaussian NLL loss.
+    """
+    if inputs.shape != targets.shape:
+        raise ValueError(
+            f"Inputs shape {inputs.shape} does not match targets shape {targets.shape}."
+        )
+
+    if inputs.shape != vars.shape:
+        raise ValueError(
+            f"Inputs shape {inputs.shape} does not match vars shape {vars.shape}."
+        )
+
+    # For stability
+    vars = mx.maximum(vars, eps)
+    loss = 0.5 * (mx.log(vars) + mx.square(targets - inputs) / vars)
+
+    if full:
+        loss += 0.5 * math.log(2 * math.pi)
+
+    return _reduce(loss, reduction)
+
+
+def kl_div_loss(
+    inputs: mx.array, targets: mx.array, axis: int = -1, reduction: Reduction = "none"
+) -> mx.array:
+    """
+    Computes the Kullback-Leibler divergence loss.
+
+    Computes the following when ``reduction == 'none'``:
+
+    .. code-block:: python
+
+        mx.exp(targets) * (targets - inputs).sum(axis)
+
+    Args:
+        inputs (array): Log probabilities for the predicted distribution.
+        targets (array): Log probabilities for the target distribution.
+        axis (int, optional): The distribution axis. Default: ``-1``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed Kullback-Leibler divergence loss.
+    """
+    loss = mx.sum(mx.exp(targets) * (targets - inputs), axis)
+
+    return _reduce(loss, reduction)
+
+
+def smooth_l1_loss(
+    predictions: mx.array,
+    targets: mx.array,
+    beta: float = 1.0,
+    reduction: Reduction = "mean",
+) -> mx.array:
+    r"""
+    Computes the smooth L1 loss.
+
+    The smooth L1 loss is a variant of the L1 loss which replaces the absolute
+    difference with a squared difference when the absolute difference is less
+    than ``beta``.
+
+    The formula for the smooth L1 Loss is:
+
+    .. math::
+
+      l = \begin{cases}
+            0.5 (x - y)^2 / \beta, & \text{if } |x - y| < \beta \\
+            |x - y| - 0.5 \beta, & \text{otherwise}
+          \end{cases}
+
+    Args:
+        predictions (array): Predicted values.
+        targets (array): Ground truth values.
+        beta (float, optional): The threshold after which the loss changes
+          from the squared to the absolute difference. Default: ``1.0``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'mean'``.
+
+    Returns:
+        array: The computed smooth L1 loss.
+    """
+    if predictions.shape != targets.shape:
+        raise ValueError(
+            f"Predictions shape {predictions.shape} does not match "
+            f"targets shape {targets.shape}."
+        )
+
+    diff = mx.abs(predictions - targets)
+    loss = mx.where(
+        diff < beta, 0.5 * mx.square(diff) / beta, mx.abs(diff) - 0.5 * beta
+    )
+
+    return _reduce(loss, reduction)
+
+
+def triplet_loss(
+    anchors: mx.array,
+    positives: mx.array,
+    negatives: mx.array,
+    axis: int = -1,
+    p: int = 2,
+    margin: float = 1.0,
+    eps: float = 1e-6,
+    reduction: Reduction = "none",
+) -> mx.array:
+    r"""
+    Computes the triplet loss for a set of anchor, positive, and negative samples.
+    Margin is represented with alpha in the math section.
+
+    .. math::
+
+       \max\left(\|A - P\|_p - \|A - N\|_p + \alpha, 0\right)
+
+    Args:
+        anchors (array): The anchor samples.
+        positives (array): The positive samples.
+        negatives (array): The negative samples.
+        axis (int, optional): The distribution axis. Default: ``-1``.
+        p (int, optional): The norm degree for pairwise distance. Default: ``2``.
+        margin (float, optional): Margin for the triplet loss. Defaults to ``1.0``.
+        eps (float, optional): Small positive constant to prevent numerical instability. Defaults to ``1e-6``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: Computed triplet loss. If reduction is "none", returns a tensor of the same shape as input;
+                  if reduction is "mean" or "sum", returns a scalar tensor.
+    """
+    loss = mx.maximum(
+        mx.sqrt(mx.power(anchors - positives, p).sum(axis) + eps)
+        - mx.sqrt(mx.power(anchors - negatives, p).sum(axis) + eps)
+        + margin,
+        0,
+    )
+    return _reduce(loss, reduction)
+
+
+def hinge_loss(
+    inputs: mx.array, targets: mx.array, reduction: Reduction = "none"
+) -> mx.array:
+    r"""
+    Computes the hinge loss between inputs and targets.
+
+    .. math::
+
+       \text{hinge}(y, y_{\text{pred}}) = \max(0, 1 - y \cdot y_{\text{pred}})
+
+
+    Args:
+        inputs (array): The predicted values.
+        targets (array): The target values. They should be -1 or 1.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed hinge loss.
+    """
+    loss = mx.maximum(1 - inputs * targets, 0)
+
+    return _reduce(loss, reduction)
+
+
+def huber_loss(
+    inputs: mx.array,
+    targets: mx.array,
+    delta: float = 1.0,
+    reduction: Reduction = "none",
+) -> mx.array:
+    r"""
+    Computes the Huber loss between inputs and targets.
+
+    .. math::
+
+        l_{\delta}(a) =
+        \left\{ \begin{array}{ll}
+            \frac{1}{2} a^2 & \text{for } |a| \leq \delta, \\
+            \delta \left( |a| - \frac{1}{2} \delta \right) & \text{otherwise.}
+        \end{array} \right.
+
+    Args:
+        inputs (array): The predicted values.
+        targets (array): The target values.
+        delta (float, optional): The threshold at which to change between L1 and L2 loss.
+          Default: ``1.0``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed Huber loss.
+    """
+    errors = inputs - targets
+    abs_errors = mx.abs(errors)
+    quadratic = mx.minimum(abs_errors, delta)
+    linear = abs_errors - quadratic
+    loss = 0.5 * quadratic**2 + delta * linear
+
+    return _reduce(loss, reduction)
+
+
+def log_cosh_loss(
+    inputs: mx.array, targets: mx.array, reduction: Reduction = "none"
+) -> mx.array:
+    r"""
+    Computes the log cosh loss between inputs and targets.
+
+    Logcosh acts like L2 loss for small errors, ensuring stable gradients,
+    and like the L1 loss for large errors, reducing sensitivity to outliers. This
+    dual behavior offers a balanced, robust approach for regression tasks.
+
+    .. math::
+
+       \text{logcosh}(y_{\text{true}}, y_{\text{pred}}) =
+            \frac{1}{n} \sum_{i=1}^{n}
+            \log(\cosh(y_{\text{pred}}^{(i)} - y_{\text{true}}^{(i)}))
+
+
+    Args:
+        inputs (array): The predicted values.
+        targets (array): The target values.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed log cosh loss.
+    """
+    errors = inputs - targets
+    loss = mx.logaddexp(errors, -errors) - math.log(2)
+
+    return _reduce(loss, reduction)
+
+
+def cosine_similarity_loss(
+    x1: mx.array,
+    x2: mx.array,
+    axis: int = 1,
+    eps: float = 1e-8,
+    reduction: Reduction = "none",
+) -> mx.array:
+    r"""
+    Computes the cosine similarity between the two inputs.
+
+    The cosine similarity loss is given by
+
+    .. math::
+
+        \frac{x_1 \cdot x_2}{\max(\|x_1\|  \cdot \|x_2\|, \epsilon)}
+
+    Args:
+        x1 (mx.array): The first set of inputs.
+        x2 (mx.array): The second set of inputs.
+        axis (int, optional): The embedding axis. Default: ``1``.
+        eps (float, optional): The minimum value of the denominator used for
+          numerical stability. Default: ``1e-8``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+          ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        mx.array: The computed cosine similarity loss.
+    """
+    x1_norm = mx.linalg.norm(x1, axis=axis)
+    x2_norm = mx.linalg.norm(x2, axis=axis)
+
+    loss = mx.sum(x1 * x2, axis=axis) / mx.maximum(x1_norm * x2_norm, eps)
+
+    return _reduce(loss, reduction)
+
+
+def margin_ranking_loss(
+    inputs1: mx.array,
+    inputs2: mx.array,
+    targets: mx.array,
+    margin: float = 0.0,
+    reduction: Reduction = "none",
+) -> mx.array:
+    r"""
+    Calculate the margin ranking loss that loss given inputs :math:`x_1`, :math:`x_2` and a label
+    :math:`y` (containing 1 or -1).
+
+    The loss is given by:
+
+    .. math::
+        \text{loss} = \max (0, -y * (x_1 - x_2) + \text{margin})
+
+    Where :math:`y` represents ``targets``, :math:`x_1` represents ``inputs1`` and :math:`x_2`
+    represents ``inputs2``.
+
+    Args:
+        inputs1 (array): Scores for the first input.
+        inputs2 (array): Scores for the second input.
+        targets (array): Labels indicating whether samples in ``inputs1`` should be ranked higher
+            than samples in ``inputs2``. Values should be 1 or -1.
+        margin (float, optional): The margin by which the scores should be separated.
+            Default: ``0.0``.
+        reduction (str, optional): Specifies the reduction to apply to the output:
+            ``'none'`` | ``'mean'`` | ``'sum'``. Default: ``'none'``.
+
+    Returns:
+        array: The computed margin ranking loss.
+
+    Examples:
+        >>> import mlx.core as mx
+        >>> import mlx.nn as nn
+        >>> targets = mx.array([1, 1, -1])
+        >>> inputs1 = mx.array([-0.573409, -0.765166, -0.0638])
+        >>> inputs2 = mx.array([0.75596, 0.225763, 0.256995])
+        >>> loss = nn.losses.margin_ranking_loss(inputs1, inputs2, targets)
+        >>> loss
+        array(0.773433, dtype=float32)
+    """
+    if not (inputs1.shape == inputs2.shape == targets.shape):
+        raise ValueError(
+            f"The shapes of the arguments do not match. The provided shapes are "
+            f"inputs1.shape={inputs1.shape}, inputs2.shape={inputs2.shape}, and "
+            f"targets.shape={targets.shape}."
+        )
+
+    differences = inputs1 - inputs2
+    loss = mx.maximum(0, -targets * differences + margin)
+
+    return _reduce(loss, reduction)
diff --git a/ml-stable-diffusion/mlx/python/mlx/nn/utils.py b/ml-stable-diffusion/mlx/python/mlx/nn/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..97354d112aae73ae9966eb31d6882b454e6803f6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/nn/utils.py
@@ -0,0 +1,165 @@
+# Copyright © 2023-2024 Apple Inc.
+
+from functools import reduce, wraps
+from typing import Any, Callable, Optional
+
+import mlx.core as mx
+
+from ..utils import tree_flatten, tree_map, tree_unflatten
+from .layers.base import Module
+
+
+def value_and_grad(model: Module, fn: Callable):
+    """Transform the passed function ``fn`` to a function that computes the
+    gradients of ``fn`` wrt the model's trainable parameters and also its
+    value.
+
+    Args:
+        model (mlx.nn.Module): The model whose trainable parameters to compute
+                               gradients for
+        fn (Callable): The scalar function to compute gradients for
+
+    Returns:
+        A callable that returns the value of ``fn`` and the gradients wrt the
+        trainable parameters of ``model``
+    """
+
+    def inner_fn(params, *args, **kwargs):
+        model.update(params)
+        return fn(*args, **kwargs)
+
+    value_grad_fn = mx.value_and_grad(inner_fn)
+
+    @wraps(fn)
+    def wrapped_value_grad_fn(*args, **kwargs):
+        value, grad = value_grad_fn(model.trainable_parameters(), *args, **kwargs)
+        return value, grad
+
+    return wrapped_value_grad_fn
+
+
+def checkpoint(module: Module, fn: Optional[Callable] = None):
+    """Transform the passed callable to one that performs gradient
+    checkpointing with respect to the trainable parameters of the module (and
+    the callable's inputs).
+
+    Args:
+        module (mlx.nn.Module): The module for whose parameters we will be
+            performing gradient checkpointing.
+        fn (Callable, optional): The function to checkpoint. If not provided it
+            defaults to the provided module.
+
+    Returns:
+        A callable that saves the inputs and outputs during the forward pass
+        and recomputes all intermediate states during the backward pass.
+    """
+    if fn is None:
+        # Capturing module instead of module.__call__ allows someone to
+        # monkey-patch __call__ later on and the correct method will be used
+        fn = module
+
+    def inner_fn(params, *args, **kwargs):
+        module.update(params)
+        return fn(*args, **kwargs)
+
+    checkpointed_fn = mx.checkpoint(inner_fn)
+
+    @wraps(fn)
+    def wrapped_checkpointed_fn(*args, **kwargs):
+        return checkpointed_fn(module.trainable_parameters(), *args, **kwargs)
+
+    return wrapped_checkpointed_fn
+
+
+def average_gradients(
+    gradients: Any,
+    group: Optional[mx.distributed.Group] = None,
+    all_reduce_size: int = 32 * 1024**2,
+    communication_type: Optional[mx.Dtype] = None,
+    communication_stream: Optional[mx.Stream] = None,
+):
+    """Average the gradients across the distributed processes in the passed group.
+
+    This helper enables concatenating several gradients of small arrays to one
+    big all reduce call for better networking performance.
+
+    Args:
+        gradients (Any): The Python tree containing the gradients (it should
+            have the same structure across processes)
+        group (Optional[mlx.core.distributed.Group]): The group of processes to
+            average the gradients. If set to ``None`` the global group is used.
+            Default: ``None``.
+        all_reduce_size (int): Group arrays until their size in bytes exceeds
+            this number. Perform one communication step per group of arrays. If
+            less or equal to 0 array grouping is disabled. Default: ``32MiB``.
+        communication_type (Optional[mlx.core.Dtype]): If provided cast to this
+            type before performing the communication. Typically cast to a
+            smaller float to reduce the communication size. Default: ``None``.
+        communication_stream (Optional[mlx.core.Stream]): The stream to usse
+            for the communication. If unspecified the default communication
+            stream is used which can vary by back-end. Default: ``None``.
+    """
+    group = group or mx.distributed.init()
+    N = group.size()
+
+    if N == 1:
+        return gradients
+
+    def _average(x):
+        dt = x.dtype
+        x = x.astype(communication_type) if communication_type is not None else x
+        return mx.distributed.all_sum(x, stream=communication_stream).astype(dt) / N
+
+    if all_reduce_size <= 0:
+        return tree_map(_average, gradients)
+
+    else:
+        flat_grads = tree_flatten(gradients)
+        if len(flat_grads) == 0:
+            return gradients
+
+        # Extract some info for the gradient
+        keys = [k for k, _ in flat_grads]
+        shapes = [v.shape for _, v in flat_grads]
+        sizes = [v.size for _, v in flat_grads]
+        dtypes = [v.dtype for _, v in flat_grads]
+
+        # We can't group them if they have mixed types
+        if not all(dt == dtypes[0] for dt in dtypes):
+            return average_gradients(gradients, group, 0, communication_type)
+        itemsize = (
+            communication_type.size
+            if communication_type is not None
+            else dtypes[0].size
+        )
+
+        # Gather the gradients in groups that are just above or equal to all_reduce_size
+        grad_groups = []
+        grad_group = []
+        grad_group_size = 0
+        for i in range(len(keys)):
+            grad_group.append(i)
+            grad_group_size += sizes[i] * itemsize
+            if grad_group_size >= all_reduce_size:
+                grad_groups.append(grad_group)
+                grad_group = []
+                grad_group_size = 0
+        if grad_group:
+            grad_groups.append(grad_group)
+            grad_group = []
+
+        # Concatenate-reduce-split
+        new_flat_grads = []
+        for grad_group in grad_groups:
+            indices = reduce(lambda x, y: x + [x[-1] + sizes[y]], grad_group, [0])
+            big_grad = mx.concatenate(
+                [flat_grads[i][1].reshape(-1) for i in grad_group]
+            )
+            big_grad = _average(big_grad)
+            big_grad = mx.split(big_grad, indices[1:-1])
+            new_flat_grads.extend(
+                (keys[j], big_grad[i].reshape(shapes[j]))
+                for i, j in enumerate(grad_group)
+            )
+
+        return tree_unflatten(new_flat_grads)
diff --git a/ml-stable-diffusion/mlx/python/mlx/optimizers/__init__.py b/ml-stable-diffusion/mlx/python/mlx/optimizers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e8e0ccd4539ea497c65303bed1a29730c54782f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/optimizers/__init__.py
@@ -0,0 +1,4 @@
+# Copyright © 2023-2024 Apple Inc.
+
+from mlx.optimizers.optimizers import *
+from mlx.optimizers.schedulers import *
diff --git a/ml-stable-diffusion/mlx/python/mlx/optimizers/optimizers.py b/ml-stable-diffusion/mlx/python/mlx/optimizers/optimizers.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cc9e26b1700d89fc579115b458c2a992433ce03
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/optimizers/optimizers.py
@@ -0,0 +1,976 @@
+# Copyright © 2023-2024 Apple Inc.
+
+from typing import Callable, List, Optional, Tuple, Union
+
+import mlx.core as mx
+from mlx.nn import Module
+from mlx.utils import tree_flatten, tree_map, tree_merge, tree_reduce, tree_unflatten
+
+
+class Optimizer:
+    """The base class for all optimizers. It allows us to implement an
+    optimizer on a per-parameter basis and apply it to a parameter tree.
+    """
+
+    def __init__(self, schedulers=None):
+        self._initialized = False
+        self._state = {"step": mx.array(0, mx.uint64)}
+        self._schedulers = {k: v for k, v in (schedulers or {}).items()}
+
+    def update(self, model: Module, gradients: dict):
+        """Apply the gradients to the parameters of the model and update the
+        model with the new parameters.
+
+        Args:
+            model (mlx.nn.Module): An mlx module to be updated.
+            gradients (dict): A Python tree of gradients, most likely computed
+                              via :func:`mlx.nn.value_and_grad`.
+        """
+        model.update(self.apply_gradients(gradients, model))
+
+    def init(self, parameters: dict):
+        """Initialize the optimizer's state
+
+        This function can be used to initialize optimizers which have state
+        (like momentum in :class:`SGD`). Using this method is optional as the
+        optimizer will initialize itself if the state is not yet set. However,
+        there are some cases where explicit initialization is useful in order
+        to have access to the :attr:`Optimizer.state` before the first call to
+        :meth:`Optimizer.update`.
+
+        Args:
+            model (dict): A Python tree of parameters.
+
+        Example:
+            >>> optimizer = optim.SGD(learning_rate=1e-1, momentum=0.9)
+            >>> model = nn.Linear(2, 2)
+            >>> optimizer.init(model.trainable_parameters())
+            >>> optimizer.state.keys()
+            dict_keys(['step', 'learning_rate', 'weight', 'bias'])
+        """
+
+        # Initialize the optimizer state to match the parameter state
+        def update_state(params, state):
+            if isinstance(params, (list, tuple)):
+                state = list(state)
+                for i in range(len(state)):
+                    state[i] = update_state(params[i], state[i])
+                if len(state) != len(params):
+                    state.extend(tree_map(lambda _: {}, params[len(state) :]))
+                return type(params)(state)
+            elif isinstance(params, dict):
+                for k, v in params.items():
+                    if k not in state:
+                        state[k] = tree_map(lambda _: {}, v)
+                    else:
+                        state[k] = update_state(v, state[k])
+                return state
+            else:
+                return state
+
+        update_state(parameters, self._state)
+        tree_map(lambda p, s: s or self.init_single(p, s), parameters, self._state)
+        self._initialized = True
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """To be extended by the children classes to implement each optimizer's
+        state initialization.
+
+        Args:
+            parameter (mx.array): A single parameter that will be optimized.
+            state (dict): The optimizer's state.
+        """
+        raise NotImplementedError()
+
+    def apply_gradients(self, gradients: dict, parameters: dict):
+        """Apply the gradients to the parameters and return the updated parameters.
+
+        Can be used to update a model via
+        ``model.update(opt.apply_gradients(grads, model))`` which is precisely
+        how :meth:`Optimizer.update` is implemented.
+
+        Args:
+            gradients (dict): A Python tree of gradients.
+            parameters (dict): A Python tree of parameters. It can be a
+              superset of the gradients. In that case the returned python
+              tree will be of the same structure as the gradients.
+        """
+        if not self._initialized:
+            self.init(gradients)
+
+        # Update any scheduled variables
+        for param, scheduler in self._schedulers.items():
+            self.state[param] = scheduler(self.step)
+
+        # Increment the step
+        self.state["step"] = self.step + 1
+
+        # Apply the update
+        return tree_map(self.apply_single, gradients, parameters, self.state)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """To be extended by derived classes to implement the optimizer's update.
+
+        Args:
+            gradient (mx.array): The ``parameter`` gradient.
+            parameter (mx.array): The ``parameter`` to update.
+            state (dict): The optimizer's state.
+        """
+        raise NotImplementedError()
+
+    @property
+    def state(self):
+        """The optimizer's state dictionary."""
+        return self._state
+
+    @state.setter
+    def state(self, state: dict):
+        self._initialized = False
+        self._state = state
+
+    @property
+    def step(self):
+        return self.state["step"]
+
+    @property
+    def learning_rate(self):
+        return self.state["learning_rate"]
+
+    @learning_rate.setter
+    def learning_rate(self, learning_rate: Union[float, mx.array]):
+        self.state["learning_rate"] = mx.array(learning_rate)
+
+    def _maybe_schedule(
+        self, name: str, param: Union[float, Callable[[mx.array], mx.array]]
+    ):
+        """
+        To be used by derived classes to optionally put a parameter on a schedule.
+        """
+        if isinstance(param, Callable):
+            self._schedulers[name] = param
+            parameter = param(self.step)
+        else:
+            parameter = mx.array(param)
+        self.state[name] = parameter
+
+
+class MultiOptimizer(Optimizer):
+    """Wraps a list of optimizers with corresponding weight predicates/filters
+    to make it easy to use different optimizers for different weights.
+
+    The predicates take the full "path" of the weight and the weight itself and
+    return True if it should be considered for this optimizer. The last
+    optimizer in the list is a fallback optimizer and no predicate should be
+    given for it.
+
+    Args:
+        optimizers (list[Optimizer]): A list of optimizers to delegate to
+        filters (list[Callable[[str, array], bool]): A list of predicates that
+            should be one less than the provided optimizers.
+    """
+
+    def __init__(self, optimizers, filters: list = []):
+        super().__init__()
+        self._state = {}
+
+        if len(filters) != len(optimizers) - 1:
+            raise ValueError(
+                f"Given {len(filters)} filters but {len(optimizers)-1} needed."
+            )
+
+        self.optimizers = optimizers
+        self.filters = filters + [lambda *args, **kwargs: True]
+
+    def _split_dictionary(self, gradients: dict):
+        if len(self.optimizers) == 1:
+            return [gradients]
+
+        parts = [[] for _ in range(len(self.optimizers))]
+        flat_gradients = tree_flatten(gradients)
+        for k, g in flat_gradients:
+            for i, fn in enumerate(self.filters):
+                if fn(k, g):
+                    parts[i].append((k, g))
+                    break
+
+        return [tree_unflatten(p) for p in parts]
+
+    def init(self, parameters: dict):
+        for o, p in zip(self.optimizers, self._split_dictionary(parameters)):
+            o.init(p)
+
+    def apply_gradients(self, gradients: dict, parameters: dict):
+        tree = {}
+        for o, g in zip(self.optimizers, self._split_dictionary(gradients)):
+            tree = tree_merge(tree, o.apply_gradients(g, parameters))
+        return tree
+
+    @property
+    def state(self):
+        return {"states": [o.state for o in self.optimizers]}
+
+    @state.setter
+    def state(self, state: dict):
+        if "states" not in state or len(state["states"]) != len(self.optimizers):
+            raise ValueError("Invalid state provided")
+
+        for o, s in zip(self.optimizers, state["states"]):
+            o.state = s
+
+    @property
+    def learning_rate(self):
+        return self.optimizers[0].learning_rate
+
+    @learning_rate.setter
+    def learning_rate(self, learning_rate: Union[float, mx.array]):
+        for o in self.optimizers:
+            o.learning_rate = learning_rate
+
+
+class SGD(Optimizer):
+    r"""The stochastic gradient descent optimizer.
+
+    Updates a parameter :math:`w` with a gradient :math:`g` as follows
+
+    .. math::
+
+        v_{t+1} &= \mu v_t + (1 - \tau) g_t \\
+        w_{t+1} &= w_t - \lambda v_{t+1}
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\lambda`.
+        momentum (float, optional): The momentum strength :math:`\mu`. Default: ``0``
+        weight_decay (float, optional): The weight decay (L2 penalty). Default: ``0``
+        dampening (float, optional): Dampening for momentum :math:`\tau`. Default: ``0``
+        nesterov (bool, optional): Enables Nesterov momentum. Default: ``False``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        momentum: float = 0.0,
+        weight_decay: float = 0.0,
+        dampening: float = 0.0,
+        nesterov: bool = False,
+    ):
+        if nesterov and (momentum <= 0 or dampening != 0):
+            raise ValueError(
+                "Nesterov momentum requires a momentum and zero dampening."
+            )
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.momentum = momentum
+        self.weight_decay = weight_decay
+        self.dampening = dampening
+        self.nesterov = nesterov
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["v"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the SGD parameter update and stores :math:`v` in the
+        optimizer state."""
+
+        if self.weight_decay != 0:
+            gradient += self.weight_decay * parameter
+
+        if self.momentum <= 0:
+            return parameter - self.learning_rate.astype(gradient.dtype) * gradient
+
+        v = self.momentum * state.get("v")
+        if self.dampening > 0:
+            v += (1 - self.dampening) * gradient
+        else:
+            v += gradient
+
+        if self.nesterov:
+            update = gradient + self.momentum * v
+        else:
+            update = v
+
+        state["v"] = v
+        return parameter - self.learning_rate.astype(gradient.dtype) * update
+
+
+class RMSprop(Optimizer):
+    r"""The RMSprop optimizer [1].
+
+    [1]: Tieleman, T. and Hinton, G. 2012. Lecture 6.5-rmsprop, coursera: Neural networks for machine learning
+
+    .. math::
+
+        v_{t+1} &= \alpha v_t + (1 - \alpha) g_t^2 \\
+        w_{t+1} &= w_t - \lambda \frac{g_t}{\sqrt{v_{t+1}} + \epsilon}
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\lambda`.
+        alpha (float, optional): The smoothing constant :math:`\alpha`.
+          Default: ``0.99``
+        eps (float, optional): The term :math:`\epsilon` added to the denominator
+          to improve numerical stability. Default: ``1e-8``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        alpha: float = 0.99,
+        eps: float = 1e-8,
+    ):
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.alpha = alpha
+        self.eps = eps
+
+        if self.alpha < 0.0:
+            raise ValueError(
+                f"RMSprop alpha should be >=0, {self.alpha} was provided instead"
+            )
+        if self.eps < 0.0:
+            raise ValueError(
+                f"RMSprop epsilon should be >0, {self.eps} was provided instead"
+            )
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["v"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the RMSprop parameter update and stores :math:`v` in the optimizer state."""
+        lr = self.learning_rate.astype(gradient.dtype)
+        alpha = self.alpha
+        eps = self.eps
+
+        v = state["v"]
+        v = alpha * v + (1 - alpha) * mx.square(gradient)
+        state["v"] = v
+
+        return parameter - lr * gradient / (mx.sqrt(v) + eps)
+
+
+class Adagrad(Optimizer):
+    r"""The Adagrad optimizer [1].
+
+    Our Adagrad implementation follows the original paper. In detail,
+
+    [1]: Duchi, J., Hazan, E. and Singer, Y., 2011. Adaptive subgradient methods
+    for online learning and stochastic optimization. JMLR 2011.
+
+    .. math::
+
+        v_{t+1} &= v_t + g_t^2 \\
+        w_{t+1} &= w_t - \lambda \frac{g_t}{\sqrt{v_{t+1}} + \epsilon}
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\lambda`.
+        eps (float, optional): The term :math:`\epsilon` added to the
+          denominator to improve numerical stability. Default: ``1e-8``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        eps: float = 1e-8,
+    ):
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.eps = eps
+
+        if self.eps < 0.0:
+            raise ValueError(
+                f"Adagrad epsilon should be >0, {self.eps} was provided instead"
+            )
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["v"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the Adagrad parameter update and stores :math:`v` in the
+        optimizer state."""
+        lr = self.learning_rate.astype(gradient.dtype)
+        eps = self.eps
+
+        v = state["v"] + mx.square(gradient)
+        state["v"] = v
+
+        return parameter - lr * gradient / (mx.sqrt(v) + eps)
+
+
+class AdaDelta(Optimizer):
+    r"""The AdaDelta optimizer with a learning rate [1].
+
+    Our AdaDelta implementation follows the original paper. In detail,
+
+    [1]: Zeiler, M.D., 2012. ADADELTA: an adaptive learning rate method. arXiv preprint arXiv:1212.5701.
+
+    .. math::
+
+        v_{t+1} &= \rho v_t + (1 - \rho) g_t^2 \\
+        \Delta w_{t+1} &= \frac{\sqrt{u_t + \epsilon}}{\sqrt{v_{t+1} + \epsilon}} g_t \\
+        u_{t+1} &= \rho u_t + (1 - \rho) \Delta w_{t+1}^2 \\
+        w_{t+1} &= w_t - \lambda \Delta w_{t+1}
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\lambda`.
+        rho (float, optional): The coefficient :math:`\rho` used for computing a
+            running average of squared gradients. Default: ``0.9``
+        eps (float, optional): The term :math:`\epsilon` added to the denominator to improve
+          numerical stability. Default: `1e-8`
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        rho: float = 0.9,
+        eps: float = 1e-6,
+    ):
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.rho = rho
+        self.eps = eps
+        if self.rho < 0.0:
+            raise ValueError(
+                f"AdaDelta rho should be >=0, {self.rho} was provided instead"
+            )
+        if self.eps < 0.0:
+            raise ValueError(
+                f"AdaDelta epsilon should be >0, {self.eps} was provided instead"
+            )
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["v"] = mx.zeros_like(parameter)
+        state["u"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the AdaDelta parameter update and stores :math:`v` and
+        :math:`u` in the optimizer state."""
+        lr = self.learning_rate.astype(gradient.dtype)
+        rho = self.rho
+        eps = self.eps
+
+        v = state["v"]
+        u = state["u"]
+
+        v = rho * v + (1 - rho) * mx.square(gradient)
+        d = mx.sqrt(u + eps) / mx.sqrt(v + eps) * gradient
+        u = rho * u + (1 - rho) * mx.square(d)
+
+        state["v"] = v
+        state["u"] = u
+
+        return parameter - lr * d
+
+
+class Adam(Optimizer):
+    r"""The Adam optimizer [1]. In detail,
+
+    [1]: Kingma, D.P. and Ba, J., 2015. Adam: A method for stochastic
+    optimization. ICLR 2015.
+
+    .. math::
+
+        m_{t+1} &= \beta_1 m_t + (1 - \beta_1) g_t \\
+        v_{t+1} &= \beta_2 v_t + (1 - \beta_2) g_t^2 \\
+        w_{t+1} &= w_t - \lambda \frac{m_{t+1}}{\sqrt{v_{t+1}} + \epsilon}
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\lambda`.
+        betas (Tuple[float, float], optional): The coefficients
+          :math:`(\beta_1, \beta_2)` used for computing running averages of the
+          gradient and its square. Default: ``(0.9, 0.999)``
+        eps (float, optional): The term :math:`\epsilon` added to the
+          denominator to improve numerical stability. Default: ``1e-8``
+        bias_correction (bool, optional): If set to ``True``, bias correction
+          is applied. Default: ``False``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        betas: List[float] = [0.9, 0.999],
+        eps: float = 1e-8,
+        bias_correction: bool = False,
+    ):
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.betas = betas
+        self.eps = eps
+        self.bias_correction = bias_correction
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["m"] = mx.zeros_like(parameter)
+        state["v"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the Adam parameter update and stores :math:`v` and
+        :math:`m` in the optimizer state."""
+        lr = self.learning_rate.astype(gradient.dtype)
+        b1, b2 = self.betas
+        eps = self.eps
+        bias_correction = self.bias_correction
+        step = self.step
+
+        m = state["m"]
+        v = state["v"]
+        m = b1 * m + (1 - b1) * gradient
+        v = b2 * v + (1 - b2) * mx.square(gradient)
+        state["m"] = m
+        state["v"] = v
+
+        if bias_correction:
+            c1 = (lr / (1 - b1**step)).astype(gradient.dtype)
+            c2 = mx.rsqrt(1 - b2**step).astype(gradient.dtype)
+            numerator = c1 * m
+            denominator = mx.sqrt(v) * c2 + eps
+            return parameter - numerator / denominator
+        else:
+            return parameter - lr * m / (mx.sqrt(v) + eps)
+
+
+class AdamW(Adam):
+    r"""The AdamW optimizer [1]. We update the weights with a weight_decay
+    (:math:`\lambda`) value:
+
+    [1]: Loshchilov, I. and Hutter, F., 2019. Decoupled weight decay
+    regularization. ICLR 2019.
+
+    .. math::
+
+        m_{t+1} &= \beta_1 m_t + (1 - \beta_1) g_t \\
+        v_{t+1} &= \beta_2 v_t + (1 - \beta_2) g_t^2 \\
+        w_{t+1} &= w_t - \alpha (\frac{m_{t+1}}{\sqrt{v_{t+1}} + \epsilon} + \lambda w_t)
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\alpha`.
+        betas (Tuple[float, float], optional): The coefficients
+          :math:`(\beta_1, \beta_2)` used for computing running averages of the
+          gradient and its square. Default: ``(0.9, 0.999)``
+        eps (float, optional): The term :math:`\epsilon` added to the
+          denominator to improve numerical stability. Default: ``1e-8``
+        weight_decay (float, optional): The weight decay :math:`\lambda`.
+          Default: ``0.01``.
+        bias_correction (bool, optional): If set to ``True``, bias correction
+          is applied. Default: ``False``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        betas: List[float] = [0.9, 0.999],
+        eps: float = 1e-8,
+        weight_decay: float = 0.01,
+        bias_correction: bool = False,
+    ):
+        super().__init__(
+            learning_rate=learning_rate,
+            betas=betas,
+            eps=eps,
+            bias_correction=bias_correction,
+        )
+        self.weight_decay = weight_decay
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the AdamW parameter update by modifying the parameters
+        passed into Adam.
+        """
+
+        lr = self.learning_rate.astype(gradient.dtype)
+        return super().apply_single(
+            gradient, parameter * (1 - lr * self.weight_decay), state
+        )
+
+
+class Adamax(Adam):
+    r"""The Adamax optimizer, a variant of Adam based on the infinity norm [1].
+
+    Our Adam implementation follows the original paper and omits the bias
+    correction in the first and second moment estimates. In detail,
+
+    [1]: Kingma, D.P. and Ba, J., 2015. Adam: A method for stochastic
+    optimization. ICLR 2015.
+
+    .. math::
+
+        m_{t+1} &= \beta_1 m_t + (1 - \beta_1) g_t \\
+        v_{t+1} &= \max(\beta_2 v_t, |g_t|) \\
+        w_{t+1} &= w_t - \lambda \frac{m_{t+1}}{v_{t+1} + \epsilon}
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\lambda`.
+        betas (Tuple[float, float], optional): The coefficients
+          :math:`(\beta_1, \beta_2)` used for computing running averages of the
+          gradient and its square. Default: ``(0.9, 0.999)``
+        eps (float, optional): The term :math:`\epsilon` added to the
+          denominator to improve numerical stability. Default: ``1e-8``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        betas: List[float] = [0.9, 0.999],
+        eps: float = 1e-8,
+    ):
+        super().__init__(learning_rate, betas, eps)
+        if not 0.0 <= eps:
+            raise ValueError(
+                f"Epsilon value should be >=0, {self.eps} was provided instead"
+            )
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["m"] = mx.zeros_like(parameter)
+        state["v"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the Adamax parameter update and stores :math:`v` and
+        :math:`m` in the optimizer state."""
+        lr = self.learning_rate.astype(gradient.dtype)
+        b1, b2 = self.betas
+        eps = self.eps
+
+        m = state["m"]
+        v = state["v"]
+
+        m = b1 * m + (1 - b1) * gradient
+        v = mx.maximum(b2 * v, mx.abs(gradient))
+        state["m"] = m
+        state["v"] = v
+
+        return parameter - lr * m / (v + eps)
+
+
+class Lion(Optimizer):
+    r"""The Lion optimizer [1].
+
+    Since updates are computed through the sign operation, they tend to
+    have larger norm than for other optimizers such as SGD and Adam.
+    We recommend a learning rate that is 3-10x smaller than AdamW and a
+    weight decay 3-10x larger than AdamW to maintain the strength
+    (lr * wd). Our Lion implementation follows the original paper. In
+    detail,
+
+    [1]: Chen, X. Symbolic Discovery of Optimization Algorithms. arXiv
+    preprint arXiv:2302.06675.
+
+    .. math::
+
+        c_{t + 1} &= \beta_1 m_t + (1 - \beta_1) g_t \\
+        m_{t + 1} &= \beta_2 m_t + (1 - \beta_2) g_t \\
+        w_{t + 1} &= w_t - \eta (\text{sign}(c_t) + \lambda w_t)
+
+    Args:
+        learning_rate (float or callable): The learning rate :math:`\eta`.
+        betas (Tuple[float, float], optional): The coefficients
+          :math:`(\beta_1, \beta_2)` used for computing the gradient
+          momentum and update direction. Default: ``(0.9, 0.99)``
+        weight_decay (float, optional): The weight decay :math:`\lambda`. Default: ``0.0``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        betas: List[float] = [0.9, 0.99],
+        weight_decay: float = 0.0,
+    ):
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.betas = betas
+        self.weight_decay = weight_decay
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["m"] = mx.zeros_like(parameter)
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the Lion parameter update and stores :math:`m`
+        in the optimizer state."""
+        lr = self.learning_rate.astype(gradient.dtype)
+        b1, b2 = self.betas
+        weight_decay = self.weight_decay
+
+        m = state["m"]
+        c = b1 * m + (1 - b1) * gradient
+        state["m"] = b2 * m + (1 - b2) * gradient
+        if weight_decay > 0:
+            parameter = (1 - lr * weight_decay) * parameter
+        return parameter - lr * mx.sign(c)
+
+
+class Adafactor(Optimizer):
+    r"""The Adafactor optimizer.
+
+    Our Adafactor implementation follows the original paper: `Adafactor:
+    Adaptive Learning Rates with Sublinear Memory Cost
+    <https://arxiv.org/abs/1804.04235>`_
+
+    Args:
+        learning_rate (float or callable, optional): The learning rate.
+            Default: ``None``.
+        eps (tuple(float, float), optional): The first term :math:`\epsilon_1`
+            added to the square of the gradients to improve numerical
+            stability and the second term :math:`\epsilon_2` is used for
+            parameter scaling if ``parameter_scale`` is set to ``True``.
+            Default: ``(1e-30, 1e-3)``.
+        clip_threshold (float, optional): Clips the unscaled update at
+            ``clip_threshold``. Default: ``1.0``.
+        decay_rate (float, optional): Coefficient for the running average
+            of the squared gradient. Default: ``-0.8``.
+        beta_1 (float, optional): If set to a value bigger than zero
+            then first moment will be used. Default: ``None``.
+        weight_decay (float, optional): The weight decay :math:`\lambda`.
+            Default: ``0.0``.
+        scale_parameter (bool, optional): If set to ``True`` the learning rate
+            will be scaled by :math:`\max(\epsilon_1, \text{RMS}(w_{t-1}))`.
+            Default: ``True``.
+        relative_step (bool, optional): If set to ``True`` the ``learning_rate``
+            will be ignored and relative step size will be computed.
+            Default: ``True``.
+        warmup_init (bool, optional): If set to ``True`` then the relative
+            step size will be calculated by the current step. Default:
+            ``False``.
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array], None] = None,
+        eps: Tuple[float, float] = (1e-30, 1e-3),
+        clip_threshold: float = 1.0,
+        decay_rate: float = -0.8,
+        beta_1: Optional[float] = None,
+        weight_decay: float = 0.0,
+        scale_parameter: bool = True,
+        relative_step: bool = True,
+        warmup_init: bool = False,
+    ):
+        super().__init__()
+        if learning_rate is not None:
+            self._maybe_schedule("learning_rate", learning_rate)
+        self.eps = eps
+        self.clip_threshold = clip_threshold
+        self.decay_rate = decay_rate
+        self.beta_1 = beta_1
+        self.weight_decay = weight_decay
+        self.scale_parameter = scale_parameter
+        self.relative_step = relative_step
+        self.warmup_init = warmup_init
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        if parameter.ndim >= 2:
+            shape = parameter.shape
+            dtype = parameter.dtype
+            state["exp_avg_sq_row"] = mx.zeros(shape[:-1], dtype=dtype)
+            state["exp_avg_sq_col"] = mx.zeros(shape[:-2] + shape[-1:], dtype=dtype)
+        else:
+            state["exp_avg_sq"] = mx.zeros_like(parameter)
+
+        if self.beta_1 is not None:
+            state["exp_avg"] = mx.zeros_like(parameter)
+
+    def _compute_rms(self, inputs):
+        return mx.sqrt(mx.mean(mx.square(inputs)))
+
+    def _compute_learning_rate(self, step, parameter_rms):
+        if self.relative_step:
+            min_step = 1e-6 * step if self.warmup_init else 1e-2
+            relative_step_size = mx.minimum(min_step, mx.rsqrt(step))
+        else:
+            relative_step_size = self.learning_rate
+
+        relative_step_size = relative_step_size.astype(parameter_rms.dtype)
+        parameter_scale = 1.0
+        if self.scale_parameter:
+            parameter_scale = mx.maximum(self.eps[1], parameter_rms)
+        return parameter_scale * relative_step_size
+
+    def _approximate_exp_moving_avg(self, exp_avg_sq_row, exp_avg_sq_col):
+        r_factor = mx.rsqrt(
+            exp_avg_sq_row / mx.mean(exp_avg_sq_row, axis=-1, keepdims=True)
+        )
+        c_factor = mx.rsqrt(exp_avg_sq_col)
+        return mx.matmul(
+            mx.expand_dims(r_factor, axis=-1), mx.expand_dims(c_factor, axis=0)
+        )
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the Adafactor parameter and state update."""
+        factored = gradient.ndim >= 2
+
+        step = self.step
+        use_first_moment = self.beta_1 is not None
+
+        parameter_rms = self._compute_rms(parameter)
+        learning_rate = self._compute_learning_rate(step, parameter_rms)
+        beta_2 = 1.0 - (step**self.decay_rate).astype(parameter_rms.dtype)
+        update = mx.square(gradient) + self.eps[0]
+
+        if factored:
+            exp_avg_sq_row = state["exp_avg_sq_row"]
+            exp_avg_sq_col = state["exp_avg_sq_col"]
+            exp_avg_sq_row = (beta_2 * exp_avg_sq_row) + (
+                (1 - beta_2) * mx.mean(update, axis=-1)
+            )
+            exp_avg_sq_col = (beta_2 * exp_avg_sq_col) + (
+                (1 - beta_2) * mx.mean(update, axis=-2)
+            )
+            state["exp_avg_sq_row"] = exp_avg_sq_row
+            state["exp_avg_sq_col"] = exp_avg_sq_col
+            update = self._approximate_exp_moving_avg(exp_avg_sq_row, exp_avg_sq_col)
+            update = update * gradient
+        else:
+            exp_avg_sq = state["exp_avg_sq"]
+            exp_avg_sq = (beta_2 * exp_avg_sq) + ((1 - beta_2) * update)
+            state["exp_avg_sq"] = exp_avg_sq
+            update = mx.rsqrt(exp_avg_sq) * gradient
+
+        update = update / mx.maximum(
+            1.0, self._compute_rms(update) / self.clip_threshold
+        )
+        update = learning_rate * update
+
+        if use_first_moment:
+            exp_avg = state["exp_avg"]
+            exp_avg = (self.beta_1 * exp_avg) + ((1 - self.beta_1) * update)
+            state["exp_avg"] = exp_avg
+            update = exp_avg
+
+        if self.weight_decay != 0:
+            parameter += parameter * (-self.weight_decay * learning_rate)
+        return parameter - update
+
+
+class Muon(Optimizer):
+    r"""The Muon optimizer.
+
+    Our Muon (MomentUm Orthogonalized by Newton-schulz) optimizer follows the
+    original implementation: `Muon: An optimizer for hidden layers in neural
+    networks <https://kellerjordan.github.io/posts/muon/>`_
+
+    Note:
+        - Muon may be sub-optimal for the embedding layer, the final fully
+          connected layer, or any 0D/1D parameters. Those should be optimized
+          by a different method (e.g., :class:`AdamW`).
+        - For 4D convolutional filters, it works by flattening their last
+          dimensions.
+
+    Args:
+        learning_rate (float or callable): The learning rate.
+        momentum (float, optional): The momentum strength. Default: ``0.95``
+        weight_decay (float, optional): The weight decay (L2 penalty).
+            Default: ``0.01``
+        nesterov (bool, optional): Enables Nesterov momentum. Recommended for
+            better performance.  Default: ``True``
+        ns_steps (int, optional): Number of Newton-Schulz iteration steps for
+            orthogonalization.  Default: ``5``
+    """
+
+    def __init__(
+        self,
+        learning_rate: Union[float, Callable[[mx.array], mx.array]],
+        momentum: float = 0.95,
+        weight_decay: float = 0.01,
+        nesterov: bool = True,
+        ns_steps: int = 5,
+    ):
+        super().__init__()
+
+        self._maybe_schedule("learning_rate", learning_rate)
+        self.momentum = momentum
+        self.weight_decay = weight_decay
+        self.nesterov = nesterov
+        self.ns_steps = ns_steps
+
+    def init_single(self, parameter: mx.array, state: dict):
+        """Initialize optimizer state"""
+        state["v"] = mx.zeros_like(parameter)
+
+    def _zeropower_via_newtonschulz5(self, X, steps: int):
+        assert (
+            X.ndim == 2
+        ), f"Expected a 2D array for Newton-Schulz iteration, got shape {X.shape} instead."
+        a, b, c = (3.4445, -4.7750, 2.0315)
+        transpose_needed = X.shape[-2] > X.shape[-1]
+
+        if transpose_needed:
+            X = X.T
+
+        X = X / (mx.linalg.norm(X, keepdims=True) + 1e-7)
+
+        for _ in range(steps):
+            A = X @ X.T
+            B = mx.addmm(b * A, A, A, beta=1.0, alpha=c)
+            X = mx.addmm(a * X, B, X, beta=1.0, alpha=1.0)
+
+        if transpose_needed:
+            X = X.T
+        return X
+
+    def apply_single(self, gradient: mx.array, parameter: mx.array, state: dict):
+        """Performs the Muon parameter update"""
+
+        if self.weight_decay != 0:
+            gradient = gradient + self.weight_decay * parameter
+
+        v = self.momentum * state["v"]
+        v = v + (1 - self.momentum) * gradient
+        state["v"] = v
+
+        if self.nesterov:
+            update = gradient * (1 - self.momentum) + v * self.momentum
+        else:
+            update = v
+
+        lr = self.learning_rate.astype(gradient.dtype)
+
+        if update.ndim >= 2:
+            original_shape = update.shape
+            reshape_needed = update.ndim > 2
+
+            if reshape_needed:
+                update = mx.reshape(update, (update.shape[0], -1))
+
+            update = self._zeropower_via_newtonschulz5(update, steps=self.ns_steps)
+
+            if reshape_needed:
+                update = mx.reshape(update, original_shape)
+
+            lr *= max(1, update.shape[-2] / update.shape[-1]) ** 0.5
+
+        return parameter - lr * update
+
+
+def clip_grad_norm(grads, max_norm):
+    """Clips the global norm of the gradients.
+
+    This function ensures that the global norm of the gradients does not exceed
+    ``max_norm``. It scales down the gradients proportionally if their norm is
+    greater than ``max_norm``.
+
+    Example:
+        >>> grads = {"w1": mx.array([2, 3]), "w2": mx.array([1])}
+        >>> clipped_grads, total_norm = clip_grad_norm(grads, max_norm=2.0)
+        >>> print(clipped_grads)
+        {"w1": mx.array([...]), "w2": mx.array([...])}
+
+    Args:
+        grads (dict): A dictionary containing the gradient arrays.
+        max_norm (float): The maximum allowed global norm of the gradients.
+
+    Returns:
+        (dict, float): The possibly rescaled gradients and the original
+        gradient norm.
+    """
+    norm_squared = tree_reduce(lambda acc, g: acc + g.square().sum(), grads, 0.0)
+    total_norm = mx.sqrt(norm_squared)
+    normalizer = mx.minimum(max_norm / (total_norm + 1e-6), 1.0)
+    clipped_grads = tree_map(lambda g: g * normalizer, grads)
+    return clipped_grads, total_norm
diff --git a/ml-stable-diffusion/mlx/python/mlx/optimizers/schedulers.py b/ml-stable-diffusion/mlx/python/mlx/optimizers/schedulers.py
new file mode 100644
index 0000000000000000000000000000000000000000..67e4e29cd2560e42d2f6800cec319cd6f027933e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/optimizers/schedulers.py
@@ -0,0 +1,158 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+from typing import Callable, List
+
+import mlx.core as mx
+
+
+def exponential_decay(init: float, decay_rate: float) -> Callable:
+    r"""Make an exponential decay scheduler.
+
+    Args:
+        init (float): Initial value.
+        decay_rate (float): Multiplicative factor to decay by.
+
+    Example:
+        >>> lr_schedule = optim.exponential_decay(1e-1, 0.9)
+        >>> optimizer = optim.SGD(learning_rate=lr_schedule)
+        >>> optimizer.learning_rate
+        array(0.1, dtype=float32)
+        >>>
+        >>> for _ in range(5): optimizer.update({}, {})
+        ...
+        >>> optimizer.learning_rate
+        array(0.06561, dtype=float32)
+    """
+
+    def schedule(step):
+        return init * decay_rate**step
+
+    return schedule
+
+
+def step_decay(init: float, decay_rate: float, step_size: int) -> Callable:
+    r"""Make a step decay scheduler.
+
+    Args:
+        init (float): Initial value.
+        decay_rate (float): Multiplicative factor to decay by.
+        step_size (int): Decay every ``step_size`` steps.
+
+    Example:
+
+        >>> lr_schedule = optim.step_decay(1e-1, 0.9, 10)
+        >>> optimizer = optim.SGD(learning_rate=lr_schedule)
+        >>> optimizer.learning_rate
+        array(0.1, dtype=float32)
+        >>>
+        >>> for _ in range(21): optimizer.update({}, {})
+        ...
+        >>> optimizer.learning_rate
+        array(0.081, dtype=float32)
+    """
+
+    def schedule(step):
+        return init * (decay_rate ** (step // step_size))
+
+    return schedule
+
+
+def cosine_decay(init: float, decay_steps: int, end: float = 0.0) -> Callable:
+    r"""Make a cosine decay scheduler.
+
+    Args:
+        init (float): Initial value.
+        decay_steps (int): Number of steps to decay over. The decayed
+            value is constant for steps beyond ``decay_steps``.
+        end (float, optional): Final value to decay to. Default: ``0``.
+
+    Example:
+
+        >>> lr_schedule = optim.cosine_decay(1e-1, 1000)
+        >>> optimizer = optim.SGD(learning_rate=lr_schedule)
+        >>> optimizer.learning_rate
+        array(0.1, dtype=float32)
+        >>>
+        >>> for _ in range(5): optimizer.update({}, {})
+        ...
+        >>> optimizer.learning_rate
+        array(0.0999961, dtype=float32)
+    """
+
+    def schedule(step):
+        s = mx.minimum(step, decay_steps)
+        decay = 0.5 * (1.0 + mx.cos((math.pi / decay_steps) * s))
+        return end + decay * (init - end)
+
+    return schedule
+
+
+def join_schedules(schedules: List[Callable], boundaries: List[int]) -> Callable:
+    r"""Join multiple schedules to create a new schedule.
+
+    Args:
+        schedules (list(Callable)): A list of schedules. Schedule :math:`i+1`
+          receives a step count indicating the number of steps since
+          the :math:`i`-th boundary.
+        boundaries (list(int)): A list of integers of length ``len(schedules) - 1``
+          that indicates when to transition between schedules.
+
+    Example:
+        >>> linear = optim.linear_schedule(0, 1e-1, steps=10)
+        >>> cosine = optim.cosine_decay(1e-1, 200)
+        >>> lr_schedule = optim.join_schedules([linear, cosine], [10])
+        >>> optimizer = optim.Adam(learning_rate=lr_schedule)
+        >>> optimizer.learning_rate
+        array(0.0, dtype=float32)
+        >>> for _ in range(12): optimizer.update({}, {})
+        ...
+        >>> optimizer.learning_rate
+        array(0.0999938, dtype=float32)
+    """
+    if len(schedules) == 0:
+        raise ValueError("Must provide at least 1 schedule to join.")
+
+    if len(schedules) != len(boundaries) + 1:
+        raise ValueError(
+            f"Received {len(boundaries)} boundaries but "
+            f"expected {len(schedules) - 1}."
+        )
+
+    def schedule(step):
+        output = schedules[0](step)
+        for boundary, schedule in zip(boundaries, schedules[1:]):
+            output = mx.where(step < boundary, output, schedule(step - boundary))
+        return output
+
+    return schedule
+
+
+def linear_schedule(init: float, end: float, steps: int) -> Callable:
+    r"""Make a linear scheduler.
+
+    Args:
+        init (float): Initial value.
+        end (float): Final value.
+        steps (int): Number of steps to apply the schedule over. The value is
+          ``end`` for any steps beyond ``steps``.
+
+    Example:
+
+        >>> lr_schedule = optim.linear_schedule(0, 1e-1, 100)
+        >>> optimizer = optim.Adam(learning_rate=lr_schedule)
+        >>> optimizer.learning_rate
+        array(0.0, dtype=float32)
+        >>> for _ in range(101): optimizer.update({}, {})
+        ...
+        >>> optimizer.learning_rate
+        array(0.1, dtype=float32)
+    """
+    if steps < 1:
+        raise ValueError(f"steps must be greater than 0, but got {steps}.")
+
+    def schedule(step):
+        step = mx.minimum(step, steps)
+        return step * ((end - init) / steps) + init
+
+    return schedule
diff --git a/ml-stable-diffusion/mlx/python/mlx/py.typed b/ml-stable-diffusion/mlx/python/mlx/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/py.typed
@@ -0,0 +1 @@
+
diff --git a/ml-stable-diffusion/mlx/python/mlx/utils.py b/ml-stable-diffusion/mlx/python/mlx/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa9884c10f74449c36021e38086152479160a5bd
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/mlx/utils.py
@@ -0,0 +1,324 @@
+# Copyright © 2023 Apple Inc.
+from collections import defaultdict
+from itertools import zip_longest
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+
+def tree_map(
+    fn: Callable, tree: Any, *rest: Any, is_leaf: Optional[Callable] = None
+) -> Any:
+    """Applies ``fn`` to the leaves of the Python tree ``tree`` and
+    returns a new collection with the results.
+
+    If ``rest`` is provided, every item is assumed to be a superset of ``tree``
+    and the corresponding leaves are provided as extra positional arguments to
+    ``fn``. In that respect, :meth:`tree_map` is closer to :func:`itertools.starmap`
+    than to :func:`map`.
+
+    The keyword argument ``is_leaf`` decides what constitutes a leaf from
+    ``tree`` similar to :func:`tree_flatten`.
+
+    .. code-block:: python
+
+        import mlx.nn as nn
+        from mlx.utils import tree_map
+
+        model = nn.Linear(10, 10)
+        print(model.parameters().keys())
+        # dict_keys(['weight', 'bias'])
+
+        # square the parameters
+        model.update(tree_map(lambda x: x*x, model.parameters()))
+
+    Args:
+        fn (callable): The function that processes the leaves of the tree.
+        tree (Any): The main Python tree that will be iterated upon.
+        rest (tuple[Any]): Extra trees to be iterated together with ``tree``.
+        is_leaf (callable, optional): An optional callable that returns ``True``
+           if the passed object is considered a leaf or ``False`` otherwise.
+
+    Returns:
+        A Python tree with the new values returned by ``fn``.
+    """
+    if is_leaf is not None and is_leaf(tree):
+        return fn(tree, *rest)
+    elif isinstance(tree, (list, tuple)):
+        TreeType = type(tree)
+        return TreeType(
+            tree_map(fn, child, *(r[i] for r in rest), is_leaf=is_leaf)
+            for i, child in enumerate(tree)
+        )
+    elif isinstance(tree, dict):
+        return {
+            k: tree_map(fn, child, *(r[k] for r in rest), is_leaf=is_leaf)
+            for k, child in tree.items()
+        }
+    else:
+        return fn(tree, *rest)
+
+
+def tree_map_with_path(
+    fn: Callable,
+    tree: Any,
+    *rest: Any,
+    is_leaf: Optional[Callable] = None,
+    path: Optional[Any] = None,
+) -> Any:
+    """Applies ``fn`` to the path and leaves of the Python tree ``tree`` and
+    returns a new collection with the results.
+
+    This function is the same :func:`tree_map` but the ``fn`` takes the path as
+    the first argument followed by the remaining tree nodes.
+
+    Args:
+        fn (callable): The function that processes the leaves of the tree.
+        tree (Any): The main Python tree that will be iterated upon.
+        rest (tuple[Any]): Extra trees to be iterated together with ``tree``.
+        is_leaf (Optional[Callable]): An optional callable that returns ``True``
+           if the passed object is considered a leaf or ``False`` otherwise.
+        path (Optional[Any]): Prefix will be added to the result.
+
+    Returns:
+        A Python tree with the new values returned by ``fn``.
+
+    Example:
+        >>> from mlx.utils import tree_map_with_path
+        >>> tree = {"model": [{"w": 0, "b": 1}, {"w": 0, "b": 1}]}
+        >>> new_tree = tree_map_with_path(lambda path, _: print(path), tree)
+        model.0.w
+        model.0.b
+        model.1.w
+        model.1.b
+    """
+    if is_leaf is not None and is_leaf(tree):
+        return fn(path, tree, *rest)
+    elif isinstance(tree, (list, tuple)):
+        prefix = f"{path}." if path else ""
+        TreeType = type(tree)
+        return TreeType(
+            tree_map_with_path(
+                fn, child, *(r[i] for r in rest), is_leaf=is_leaf, path=f"{prefix}{i}"
+            )
+            for i, child in enumerate(tree)
+        )
+    elif isinstance(tree, dict):
+        prefix = f"{path}." if path else ""
+        return {
+            k: tree_map_with_path(
+                fn, child, *(r[k] for r in rest), is_leaf=is_leaf, path=f"{prefix}{k}"
+            )
+            for k, child in tree.items()
+        }
+    else:
+        return fn(path, tree, *rest)
+
+
+def tree_flatten(
+    tree: Any,
+    prefix: str = "",
+    is_leaf: Optional[Callable] = None,
+    destination: Optional[Union[List[Tuple[str, Any]], Dict[str, Any]]] = None,
+) -> Union[List[Tuple[str, Any]], Dict[str, Any]]:
+    """Flattens a Python tree to a list of key, value tuples.
+
+    The keys are using the dot notation to define trees of arbitrary depth and
+    complexity.
+
+    .. code-block:: python
+
+        from mlx.utils import tree_flatten
+
+        print(tree_flatten([[[0]]]))
+        # [("0.0.0", 0)]
+
+        print(tree_flatten([[[0]]], prefix=".hello"))
+        # [("hello.0.0.0", 0)]
+
+        tree_flatten({"a": {"b": 1}}, destination={})
+        {"a.b": 1}
+
+    .. note::
+       Dictionaries should have keys that are valid Python identifiers.
+
+    Args:
+        tree (Any): The Python tree to be flattened.
+        prefix (str): A prefix to use for the keys. The first character is
+            always discarded.
+        is_leaf (callable): An optional callable that returns True if the
+            passed object is considered a leaf or False otherwise.
+        destination (list or dict, optional): A list or dictionary to store the
+            flattened tree. If None an empty list will be used. Default: ``None``.
+
+    Returns:
+        Union[List[Tuple[str, Any]], Dict[str, Any]]: The flat representation of
+            the Python tree.
+    """
+    if destination is None:
+        destination = []
+
+    # Create the function to update the destination. We are taking advantage of
+    # the fact that list.extend and dict.update have the same API to simplify
+    # the code a bit.
+    if isinstance(destination, list):
+        _add_to_destination = destination.extend
+    elif isinstance(destination, dict):
+        _add_to_destination = destination.update
+    else:
+        raise ValueError("Destination should be either a list or a dictionary or None")
+
+    # Leaf identified by is_leaf so add it and return
+    if is_leaf is not None and is_leaf(tree):
+        _add_to_destination([(prefix[1:], tree)])
+        return destination
+
+    # List or tuple so recursively add each subtree
+    if isinstance(tree, (list, tuple)):
+        for i, item in enumerate(tree):
+            tree_flatten(item, f"{prefix}.{i}", is_leaf, destination)
+        return destination
+
+    # Dictionary so recursively add each subtree
+    if isinstance(tree, dict):
+        for key, value in tree.items():
+            tree_flatten(value, f"{prefix}.{key}", is_leaf, destination)
+        return destination
+
+    # Leaf so add it and return
+    _add_to_destination([(prefix[1:], tree)])
+
+    return destination
+
+
+def tree_unflatten(tree: Union[List[Tuple[str, Any]], Dict[str, Any]]) -> Any:
+    """Recreate a Python tree from its flat representation.
+
+    .. code-block:: python
+
+        from mlx.utils import tree_unflatten
+
+        d = tree_unflatten([("hello.world", 42)])
+        print(d)
+        # {"hello": {"world": 42}}
+
+        d = tree_unflatten({"hello.world": 42})
+        print(d)
+        # {"hello": {"world": 42}}
+
+    Args:
+        tree (list[tuple[str, Any]] or dict[str, Any]): The flat representation of a Python tree.
+           For instance as returned by :meth:`tree_flatten`.
+
+    Returns:
+        A Python tree.
+    """
+    items = tree.items() if isinstance(tree, dict) else tree
+
+    # Special case when we have just one element in the tree ie not a tree
+    if len(items) == 1:
+        key, value = next(iter(items))
+        if key == "":
+            return value
+
+    # collect children
+    children = defaultdict(list)
+    for key, value in items:
+        current_idx, *next_idx = key.split(".", maxsplit=1)
+        next_idx = "" if not next_idx else next_idx[0]
+        children[current_idx].append((next_idx, value))
+
+    # Assume they are a list and fail to dict if the keys are not all integers
+    try:
+        keys = sorted((int(idx), idx) for idx in children.keys())
+        l = []
+        for i, k in keys:
+            # if i <= len(l), no {} will be appended.
+            l.extend([{} for _ in range(i - len(l))])
+            l.append(tree_unflatten(children[k]))
+        return l
+    except ValueError:
+        return {k: tree_unflatten(v) for k, v in children.items()}
+
+
+def tree_reduce(fn, tree, initializer=None, is_leaf=None):
+    """Applies a reduction to the leaves of a Python tree.
+
+    This function reduces Python trees into an accumulated result by applying
+    the provided function ``fn`` to the leaves of the tree.
+
+    Example:
+        >>> from mlx.utils import tree_reduce
+        >>> tree = {"a": [1, 2, 3], "b": [4, 5]}
+        >>> tree_reduce(lambda acc, x: acc + x, tree, 0)
+        15
+
+    Args:
+        fn (callable): The reducer function that takes two arguments (accumulator,
+            current value) and returns the updated accumulator.
+        tree (Any): The Python tree to reduce. It can be any nested combination of
+            lists, tuples, or dictionaries.
+        initializer (Any, optional): The initial value to start the reduction. If
+            not provided, the first leaf value is used.
+        is_leaf (callable, optional): A function to determine if an object is a
+            leaf, returning ``True`` for leaf nodes and ``False`` otherwise.
+
+    Returns:
+        Any: The accumulated value.
+    """
+    if is_leaf is not None and is_leaf(tree):
+        return tree if initializer is None else fn(initializer, tree)
+
+    accumulator = initializer
+
+    if isinstance(tree, (list, tuple)):
+        for item in tree:
+            accumulator = tree_reduce(fn, item, accumulator, is_leaf)
+    elif isinstance(tree, dict):
+        for item in tree.values():
+            accumulator = tree_reduce(fn, item, accumulator, is_leaf)
+    else:
+        return tree if accumulator is None else fn(accumulator, tree)
+
+    return accumulator
+
+
+def tree_merge(tree_a, tree_b, merge_fn=None):
+    """Merge two Python trees in one containing the values of both. It can be
+    thought of as a deep dict.update method.
+
+    Args:
+        tree_a (Any): The first Python tree.
+        tree_b (Any): The second Python tree.
+        merge_fn (callable, optional): A function to merge leaves.
+
+    Returns:
+        The Python tree containing the values of both ``tree_a`` and
+        ``tree_b``.
+    """
+    if isinstance(tree_a, (dict, list, tuple)) and len(tree_a) == 0:
+        tree_a = None
+    if isinstance(tree_b, (dict, list, tuple)) and len(tree_b) == 0:
+        tree_b = None
+    if tree_a is None and tree_b is not None:
+        return tree_b
+    if tree_a is not None and tree_b is None:
+        return tree_a
+
+    if isinstance(tree_a, (list, tuple)) and isinstance(tree_b, (list, tuple)):
+        TreeType = type(tree_a)
+        return TreeType(
+            tree_merge(a, b, merge_fn) for a, b in zip_longest(tree_a, tree_b)
+        )
+    elif isinstance(tree_a, dict) and isinstance(tree_b, dict):
+        return {
+            k: tree_merge(tree_a.get(k, None), tree_b.get(k, None), merge_fn)
+            for k in set(tree_a.keys()) | set(tree_b.keys())
+        }
+    else:
+        if merge_fn is None:
+            raise ValueError(
+                (
+                    "Trees contain elements at the same locations but no merge "
+                    "function was provided"
+                )
+            )
+        return merge_fn(tree_a, tree_b)
diff --git a/ml-stable-diffusion/mlx/python/scripts/repair_cuda.sh b/ml-stable-diffusion/mlx/python/scripts/repair_cuda.sh
new file mode 100644
index 0000000000000000000000000000000000000000..9f8cd9b0d639db59c1871939ac79f165e673323f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/scripts/repair_cuda.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+
+auditwheel repair dist/* \
+  --plat manylinux_2_35_x86_64 \
+  --exclude libcublas* \
+  --exclude libnvrtc* \
+  --exclude libcuda* \
+  --exclude libcudnn* \
+  --exclude libnccl* \
+  -w wheel_tmp
+
+
+mkdir wheelhouse
+cd wheel_tmp
+repaired_wheel=$(find . -name "*.whl" -print -quit)
+unzip -q "${repaired_wheel}"
+rm "${repaired_wheel}"
+mlx_so="mlx/lib/libmlx.so"
+rpath=$(patchelf --print-rpath "${mlx_so}")
+base="\$ORIGIN/../../nvidia"
+rpath=$rpath:${base}/cublas/lib:${base}/cuda_nvrtc/lib:${base}/cudnn/lib:${base}/nccl/lib
+patchelf --force-rpath --set-rpath "$rpath" "$mlx_so"
+python ../python/scripts/repair_record.py ${mlx_so}
+
+# Re-zip the repaired wheel
+zip -r -q "../wheelhouse/${repaired_wheel}" .
diff --git a/ml-stable-diffusion/mlx/python/scripts/repair_linux.sh b/ml-stable-diffusion/mlx/python/scripts/repair_linux.sh
new file mode 100644
index 0000000000000000000000000000000000000000..880c43f4bfe4a37356fb53943b4ff50d51198ca6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/scripts/repair_linux.sh
@@ -0,0 +1,20 @@
+#!/bin/bash
+
+auditwheel repair dist/* \
+  --plat manylinux_2_35_x86_64 \
+  --only-plat \
+  --exclude libmlx* \
+  -w wheel_tmp
+
+mkdir wheelhouse
+cd wheel_tmp
+repaired_wheel=$(find . -name "*.whl" -print -quit)
+unzip -q "${repaired_wheel}"
+rm "${repaired_wheel}"
+core_so=$(find mlx -name "core*.so" -print -quit)
+rpath="\$ORIGIN/lib"
+patchelf --force-rpath --set-rpath "$rpath" "$core_so"
+python ../python/scripts/repair_record.py ${core_so}
+
+# Re-zip the repaired wheel
+zip -r -q "../wheelhouse/${repaired_wheel}" .
diff --git a/ml-stable-diffusion/mlx/python/scripts/repair_record.py b/ml-stable-diffusion/mlx/python/scripts/repair_record.py
new file mode 100644
index 0000000000000000000000000000000000000000..1738fd5adc691b2a3f158b645348a9f96e330768
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/scripts/repair_record.py
@@ -0,0 +1,33 @@
+import base64
+import glob
+import hashlib
+import sys
+
+filename = sys.argv[1]
+
+
+# Compute the new hash and size
+def urlsafe_b64encode(data: bytes) -> bytes:
+    return base64.urlsafe_b64encode(data).rstrip(b"=")
+
+
+hasher = hashlib.sha256()
+with open(filename, "rb") as f:
+    data = f.read()
+    hasher.update(data)
+hash_str = urlsafe_b64encode(hasher.digest()).decode("ascii")
+size = len(data)
+
+# Update the record file
+record_file = glob.glob("*/RECORD")[0]
+with open(record_file, "r") as f:
+    lines = [l.split(",") for l in f.readlines()]
+
+for l in lines:
+    if filename == l[0]:
+        l[1] = hash_str
+        l[2] = f"{size}\n"
+
+with open(record_file, "w") as f:
+    for l in lines:
+        f.write(",".join(l))
diff --git a/ml-stable-diffusion/mlx/python/src/CMakeLists.txt b/ml-stable-diffusion/mlx/python/src/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0580b8783ae18640ecc2bbd1d77afe8625ba1e29
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/CMakeLists.txt
@@ -0,0 +1,62 @@
+nanobind_add_module(
+  core
+  NB_STATIC
+  STABLE_ABI
+  LTO
+  NOMINSIZE
+  NB_DOMAIN
+  mlx
+  ${CMAKE_CURRENT_SOURCE_DIR}/mlx.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/array.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/convert.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/device.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/distributed.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/export.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/fast.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/fft.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/indexing.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/load.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/metal.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/cuda.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/memory.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/mlx_func.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/ops.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/stream.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/transforms.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/random.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/linalg.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/constants.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/trees.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/utils.cpp)
+
+if(NOT MLX_PYTHON_BINDINGS_OUTPUT_DIRECTORY)
+  if(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
+    set(MLX_PYTHON_BINDINGS_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
+  else()
+    set(MLX_PYTHON_BINDINGS_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
+  endif()
+endif()
+
+set_target_properties(
+  core
+  PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${MLX_PYTHON_BINDINGS_OUTPUT_DIRECTORY}
+             # Do not append a sub-dir for multi-config generators like MSVC
+             # and XCode.
+             LIBRARY_OUTPUT_DIRECTORY_RELEASE
+             ${MLX_PYTHON_BINDINGS_OUTPUT_DIRECTORY}
+             LIBRARY_OUTPUT_DIRECTORY_DEBUG
+             ${MLX_PYTHON_BINDINGS_OUTPUT_DIRECTORY}
+             LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO
+             ${MLX_PYTHON_BINDINGS_OUTPUT_DIRECTORY}
+             LIBRARY_OUTPUT_DIRECTORY_MINSIZEREL
+             ${MLX_PYTHON_BINDINGS_OUTPUT_DIRECTORY})
+
+target_link_libraries(core PRIVATE mlx)
+
+if(BUILD_SHARED_LIBS)
+  if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    target_link_options(core PRIVATE -Wl,-rpath,@loader_path/lib)
+  else()
+    target_link_options(core PRIVATE -Wl,-rpath,\$ORIGIN/lib)
+  endif()
+endif()
diff --git a/ml-stable-diffusion/mlx/python/src/array.cpp b/ml-stable-diffusion/mlx/python/src/array.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9367d4e091276a9abb4e93abfe00eadccf6e84af
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/array.cpp
@@ -0,0 +1,1539 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <cstdint>
+#include <cstring>
+#include <sstream>
+
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/complex.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/variant.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/typing.h>
+
+#include "mlx/backend/metal/metal.h"
+#include "python/src/buffer.h"
+#include "python/src/convert.h"
+#include "python/src/indexing.h"
+#include "python/src/small_vector.h"
+#include "python/src/utils.h"
+
+#include "mlx/mlx.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+class ArrayAt {
+ public:
+  ArrayAt(mx::array x) : x_(std::move(x)) {}
+  ArrayAt& set_indices(nb::object indices) {
+    initialized_ = true;
+    indices_ = indices;
+    return *this;
+  }
+  void check_initialized() {
+    if (!initialized_) {
+      throw std::invalid_argument(
+          "Must give indices to array.at (e.g. `x.at[0].add(4)`).");
+    }
+  }
+
+  mx::array add(const ScalarOrArray& v) {
+    check_initialized();
+    return mlx_add_item(x_, indices_, v);
+  }
+  mx::array subtract(const ScalarOrArray& v) {
+    check_initialized();
+    return mlx_subtract_item(x_, indices_, v);
+  }
+  mx::array multiply(const ScalarOrArray& v) {
+    check_initialized();
+    return mlx_multiply_item(x_, indices_, v);
+  }
+  mx::array divide(const ScalarOrArray& v) {
+    check_initialized();
+    return mlx_divide_item(x_, indices_, v);
+  }
+  mx::array maximum(const ScalarOrArray& v) {
+    check_initialized();
+    return mlx_maximum_item(x_, indices_, v);
+  }
+  mx::array minimum(const ScalarOrArray& v) {
+    check_initialized();
+    return mlx_minimum_item(x_, indices_, v);
+  }
+
+ private:
+  mx::array x_;
+  bool initialized_{false};
+  nb::object indices_;
+};
+
+class ArrayPythonIterator {
+ public:
+  ArrayPythonIterator(mx::array x) : idx_(0), x_(std::move(x)) {
+    if (x_.shape(0) > 0 && x_.shape(0) < 10) {
+      splits_ = mx::split(x_, x_.shape(0));
+    }
+  }
+
+  mx::array next() {
+    if (idx_ >= x_.shape(0)) {
+      throw nb::stop_iteration();
+    }
+
+    if (idx_ >= 0 && idx_ < splits_.size()) {
+      return mx::squeeze(splits_[idx_++], 0);
+    }
+
+    return *(x_.begin() + idx_++);
+  }
+
+ private:
+  int idx_;
+  mx::array x_;
+  std::vector<mx::array> splits_;
+};
+
+void init_array(nb::module_& m) {
+  // Set Python print formatting options
+  mx::get_global_formatter().capitalize_bool = true;
+
+  // Types
+  nb::class_<mx::Dtype>(
+      m,
+      "Dtype",
+      R"pbdoc(
+      An object to hold the type of a :class:`array`.
+
+      See the :ref:`list of types <data_types>` for more details
+      on available data types.
+      )pbdoc")
+      .def_prop_ro(
+          "size", &mx::Dtype::size, R"pbdoc(Size of the type in bytes.)pbdoc")
+      .def(
+          "__repr__",
+          [](const mx::Dtype& t) {
+            std::ostringstream os;
+            os << "mlx.core.";
+            os << t;
+            return os.str();
+          })
+      .def(
+          "__eq__",
+          [](const mx::Dtype& t, const nb::object& other) {
+            return nb::isinstance<mx::Dtype>(other) &&
+                t == nb::cast<mx::Dtype>(other);
+          })
+      .def("__hash__", [](const mx::Dtype& t) {
+        return static_cast<int64_t>(t.val());
+      });
+
+  m.attr("bool_") = nb::cast(mx::bool_);
+  m.attr("uint8") = nb::cast(mx::uint8);
+  m.attr("uint16") = nb::cast(mx::uint16);
+  m.attr("uint32") = nb::cast(mx::uint32);
+  m.attr("uint64") = nb::cast(mx::uint64);
+  m.attr("int8") = nb::cast(mx::int8);
+  m.attr("int16") = nb::cast(mx::int16);
+  m.attr("int32") = nb::cast(mx::int32);
+  m.attr("int64") = nb::cast(mx::int64);
+  m.attr("float16") = nb::cast(mx::float16);
+  m.attr("float32") = nb::cast(mx::float32);
+  m.attr("float64") = nb::cast(mx::float64);
+  m.attr("bfloat16") = nb::cast(mx::bfloat16);
+  m.attr("complex64") = nb::cast(mx::complex64);
+  nb::enum_<mx::Dtype::Category>(
+      m,
+      "DtypeCategory",
+      R"pbdoc(
+      Type to hold categories of :class:`dtypes <Dtype>`.
+
+      * :attr:`~mlx.core.generic`
+
+        * :ref:`bool_ <data_types>`
+        * :attr:`~mlx.core.number`
+
+          * :attr:`~mlx.core.integer`
+
+            * :attr:`~mlx.core.unsignedinteger`
+
+              * :ref:`uint8 <data_types>`
+              * :ref:`uint16 <data_types>`
+              * :ref:`uint32 <data_types>`
+              * :ref:`uint64 <data_types>`
+
+            * :attr:`~mlx.core.signedinteger`
+
+              * :ref:`int8 <data_types>`
+              * :ref:`int32 <data_types>`
+              * :ref:`int64 <data_types>`
+
+          * :attr:`~mlx.core.inexact`
+
+            * :attr:`~mlx.core.floating`
+
+              * :ref:`float16 <data_types>`
+              * :ref:`bfloat16 <data_types>`
+              * :ref:`float32 <data_types>`
+              * :ref:`float64 <data_types>`
+
+            * :attr:`~mlx.core.complexfloating`
+
+              * :ref:`complex64 <data_types>`
+
+      See also :func:`~mlx.core.issubdtype`.
+      )pbdoc")
+      .value("complexfloating", mx::complexfloating)
+      .value("floating", mx::floating)
+      .value("inexact", mx::inexact)
+      .value("signedinteger", mx::signedinteger)
+      .value("unsignedinteger", mx::unsignedinteger)
+      .value("integer", mx::integer)
+      .value("number", mx::number)
+      .value("generic", mx::generic)
+      .export_values();
+
+  nb::class_<mx::finfo>(
+      m,
+      "finfo",
+      R"pbdoc(
+      Get information on floating-point types.
+      )pbdoc")
+      .def(nb::init<mx::Dtype>())
+      .def_ro(
+          "min",
+          &mx::finfo::min,
+          R"pbdoc(The smallest representable number.)pbdoc")
+      .def_ro(
+          "max",
+          &mx::finfo::max,
+          R"pbdoc(The largest representable number.)pbdoc")
+      .def_ro(
+          "eps",
+          &mx::finfo::eps,
+          R"pbdoc(
+            The difference between 1.0 and the next smallest
+            representable number larger than 1.0.
+          )pbdoc")
+      .def_ro("dtype", &mx::finfo::dtype, R"pbdoc(The :obj:`Dtype`.)pbdoc")
+      .def("__repr__", [](const mx::finfo& f) {
+        std::ostringstream os;
+        os << "finfo("
+           << "min=" << f.min << ", max=" << f.max << ", dtype=" << f.dtype
+           << ")";
+        return os.str();
+      });
+
+  nb::class_<mx::iinfo>(
+      m,
+      "iinfo",
+      R"pbdoc(
+      Get information on integer types.
+      )pbdoc")
+      .def(nb::init<mx::Dtype>())
+      .def_ro(
+          "min",
+          &mx::iinfo::min,
+          R"pbdoc(The smallest representable number.)pbdoc")
+      .def_ro(
+          "max",
+          &mx::iinfo::max,
+          R"pbdoc(The largest representable number.)pbdoc")
+      .def_ro("dtype", &mx::iinfo::dtype, R"pbdoc(The :obj:`Dtype`.)pbdoc")
+      .def("__repr__", [](const mx::iinfo& i) {
+        std::ostringstream os;
+        os << "iinfo("
+           << "min=" << i.min << ", max=" << i.max << ", dtype=" << i.dtype
+           << ")";
+        return os.str();
+      });
+
+  nb::class_<ArrayAt>(
+      m,
+      "ArrayAt",
+      R"pbdoc(
+      A helper object to apply updates at specific indices.
+      )pbdoc")
+      .def("__getitem__", &ArrayAt::set_indices, "indices"_a.none())
+      .def("add", &ArrayAt::add, "value"_a)
+      .def("subtract", &ArrayAt::subtract, "value"_a)
+      .def("multiply", &ArrayAt::multiply, "value"_a)
+      .def("divide", &ArrayAt::divide, "value"_a)
+      .def("maximum", &ArrayAt::maximum, "value"_a)
+      .def("minimum", &ArrayAt::minimum, "value"_a);
+
+  nb::class_<ArrayLike>(
+      m,
+      "ArrayLike",
+      R"pbdoc(
+        Any Python object which has an ``__mlx__array__`` method that
+        returns an :obj:`array`.
+      )pbdoc")
+      .def(nb::init_implicit<nb::object>());
+
+  nb::class_<ArrayPythonIterator>(
+      m,
+      "ArrayIterator",
+      R"pbdoc(
+      A helper object to iterate over the 1st dimension of an array.
+      )pbdoc")
+      .def("__next__", &ArrayPythonIterator::next)
+      .def("__iter__", [](const ArrayPythonIterator& it) { return it; });
+
+  // Install buffer protocol functions
+  PyType_Slot array_slots[] = {
+      {Py_bf_getbuffer, (void*)getbuffer},
+      {Py_bf_releasebuffer, (void*)releasebuffer},
+      {0, nullptr}};
+
+  nb::class_<mx::array>(
+      m,
+      "array",
+      R"pbdoc(An N-dimensional array object.)pbdoc",
+      nb::type_slots(array_slots),
+      nb::is_weak_referenceable())
+      .def(
+          "__init__",
+          [](mx::array* aptr, ArrayInitType v, std::optional<mx::Dtype> t) {
+            new (aptr) mx::array(create_array(v, t));
+          },
+          "val"_a,
+          "dtype"_a = nb::none(),
+          nb::sig(
+              "def __init__(self: array, val: Union[scalar, list, tuple, numpy.ndarray, array], dtype: Optional[Dtype] = None)"))
+      .def_prop_ro(
+          "size",
+          &mx::array::size,
+          R"pbdoc(Number of elements in the array.)pbdoc")
+      .def_prop_ro(
+          "ndim", &mx::array::ndim, R"pbdoc(The array's dimension.)pbdoc")
+      .def_prop_ro(
+          "itemsize",
+          &mx::array::itemsize,
+          R"pbdoc(The size of the array's datatype in bytes.)pbdoc")
+      .def_prop_ro(
+          "nbytes",
+          &mx::array::nbytes,
+          R"pbdoc(The number of bytes in the array.)pbdoc")
+      .def_prop_ro(
+          "shape",
+          [](const mx::array& a) { return nb::cast(a.shape()); },
+          nb::sig("def shape(self) -> tuple[int, ...]"),
+          R"pbdoc(
+          The shape of the array as a Python tuple.
+
+          Returns:
+            tuple(int): A tuple containing the sizes of each dimension.
+        )pbdoc")
+      .def_prop_ro(
+          "dtype",
+          &mx::array::dtype,
+          R"pbdoc(
+            The array's :class:`Dtype`.
+          )pbdoc")
+      .def_prop_ro(
+          "real",
+          [](const mx::array& a) { return mx::real(a); },
+          R"pbdoc(
+            The real part of a complex array.
+          )pbdoc")
+      .def_prop_ro(
+          "imag",
+          [](const mx::array& a) { return mx::imag(a); },
+          R"pbdoc(
+            The imaginary part of a complex array.
+          )pbdoc")
+      .def(
+          "item",
+          &to_scalar,
+          nb::sig("def item(self) -> scalar"),
+          R"pbdoc(
+            Access the value of a scalar array.
+
+            Returns:
+                Standard Python scalar.
+          )pbdoc")
+      .def(
+          "tolist",
+          &tolist,
+          nb::sig("def tolist(self) -> list_or_scalar"),
+          R"pbdoc(
+            Convert the array to a Python :class:`list`.
+
+            Returns:
+                list: The Python list.
+
+                If the array is a scalar then a standard Python scalar is returned.
+
+                If the array has more than one dimension then the result is a nested
+                list of lists.
+
+                The value type of the list corresponding to the last dimension is either
+                ``bool``, ``int`` or ``float`` depending on the ``dtype`` of the array.
+          )pbdoc")
+      .def(
+          "astype",
+          &mx::astype,
+          "dtype"_a,
+          "stream"_a = nb::none(),
+          R"pbdoc(
+            Cast the array to a specified type.
+
+            Args:
+                dtype (Dtype): Type to which the array is cast.
+                stream (Stream): Stream (or device) for the operation.
+
+            Returns:
+                array: The array with type ``dtype``.
+          )pbdoc")
+      .def(
+          "__array_namespace__",
+          [](const mx::array& a,
+             const std::optional<std::string>& api_version) {
+            if (api_version) {
+              throw std::invalid_argument(
+                  "Explicitly specifying api_version is not yet implemented.");
+            }
+            return nb::module_::import_("mlx.core");
+          },
+          "api_version"_a = nb::none(),
+          R"pbdoc(
+            Returns an object that has all the array API functions on it.
+
+            See the `Python array API <https://data-apis.org/array-api/latest/index.html>`_
+            for more information.
+
+            Args:
+                api_version (str, optional): String representing the version
+                  of the array API spec to return. Default: ``None``.
+
+            Returns:
+                out (Any): An object representing the array API namespace.
+          )pbdoc")
+      .def("__getitem__", mlx_get_item, nb::arg().none())
+      .def("__setitem__", mlx_set_item, nb::arg().none(), nb::arg())
+      .def_prop_ro(
+          "at",
+          [](const mx::array& a) { return ArrayAt(a); },
+          R"pbdoc(
+            Used to apply updates at the given indices.
+
+            .. note::
+
+               Regular in-place updates map to assignment. For instance ``x[idx] += y``
+               maps to ``x[idx] = x[idx] + y``. As a result, assigning to the
+               same index ignores all but one update. Using ``x.at[idx].add(y)``
+               will correctly apply all updates to all indices.
+
+            .. list-table::
+               :header-rows: 1
+
+               * - array.at syntax
+                 - In-place syntax
+               * - ``x = x.at[idx].add(y)``
+                 - ``x[idx] += y``
+               * - ``x = x.at[idx].subtract(y)``
+                 - ``x[idx] -= y``
+               * - ``x = x.at[idx].multiply(y)``
+                 - ``x[idx] *= y``
+               * - ``x = x.at[idx].divide(y)``
+                 - ``x[idx] /= y``
+               * - ``x = x.at[idx].maximum(y)``
+                 - ``x[idx] = mx.maximum(x[idx], y)``
+               * - ``x = x.at[idx].minimum(y)``
+                 - ``x[idx] = mx.minimum(x[idx], y)``
+
+            Example:
+                >>> a = mx.array([0, 0])
+                >>> idx = mx.array([0, 1, 0, 1])
+                >>> a[idx] += 1
+                >>> a
+                array([1, 1], dtype=int32)
+                >>>
+                >>> a = mx.array([0, 0])
+                >>> a.at[idx].add(1)
+                array([2, 2], dtype=int32)
+          )pbdoc")
+      .def(
+          "__len__",
+          [](const mx::array& a) {
+            if (a.ndim() == 0) {
+              throw nb::type_error("len() 0-dimensional array.");
+            }
+            return a.shape(0);
+          })
+      .def(
+          "__iter__", [](const mx::array& a) { return ArrayPythonIterator(a); })
+      .def(
+          "__getstate__",
+          [](const mx::array& a) {
+            auto nd = (a.dtype() == mx::bfloat16)
+                ? mlx_to_np_array(mx::view(a, mx::uint16))
+                : mlx_to_np_array(a);
+            return nb::make_tuple(nd, static_cast<uint8_t>(a.dtype().val()));
+          })
+      .def(
+          "__setstate__",
+          [](mx::array& arr, const nb::tuple& state) {
+            if (nb::len(state) != 2) {
+              throw std::invalid_argument(
+                  "Invalid pickle state: expected (ndarray, Dtype::Val)");
+            }
+            using ND = nb::ndarray<nb::ro, nb::c_contig, nb::device::cpu>;
+            ND nd = nb::cast<ND>(state[0]);
+            auto val = static_cast<mx::Dtype::Val>(nb::cast<uint8_t>(state[1]));
+            if (val == mx::Dtype::Val::bfloat16) {
+              auto owner = nb::handle(state[0].ptr());
+              new (&arr) mx::array(nd_array_to_mlx(
+                  ND(nd.data(),
+                     nd.ndim(),
+                     reinterpret_cast<const size_t*>(nd.shape_ptr()),
+                     owner,
+                     nullptr,
+                     nb::bfloat16),
+                  mx::bfloat16));
+            } else {
+              new (&arr) mx::array(nd_array_to_mlx(nd, std::nullopt));
+            }
+          })
+      .def("__dlpack__", [](const mx::array& a) { return mlx_to_dlpack(a); })
+      .def(
+          "__dlpack_device__",
+          [](const mx::array& a) {
+            // See
+            // https://github.com/dmlc/dlpack/blob/5c210da409e7f1e51ddf445134a4376fdbd70d7d/include/dlpack/dlpack.h#L74
+            if (mx::metal::is_available()) {
+              return nb::make_tuple(8, 0);
+            } else if (mx::cu::is_available()) {
+              return nb::make_tuple(13, 0);
+            } else {
+              // CPU device
+              return nb::make_tuple(1, 0);
+            }
+          })
+      .def("__copy__", [](const mx::array& self) { return mx::array(self); })
+      .def(
+          "__deepcopy__",
+          [](const mx::array& self, nb::dict) { return mx::array(self); },
+          "memo"_a)
+      .def(
+          "__add__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("addition", v);
+            }
+            auto b = to_array(v, a.dtype());
+            return mx::add(a, b);
+          },
+          "other"_a)
+      .def(
+          "__iadd__",
+          [](mx::array& a, const ScalarOrArray v) -> mx::array& {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("inplace addition", v);
+            }
+            a.overwrite_descriptor(mx::add(a, to_array(v, a.dtype())));
+            return a;
+          },
+          "other"_a,
+          nb::rv_policy::none)
+      .def(
+          "__radd__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("addition", v);
+            }
+            return mx::add(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__sub__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("subtraction", v);
+            }
+            return mx::subtract(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__isub__",
+          [](mx::array& a, const ScalarOrArray v) -> mx::array& {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("inplace subtraction", v);
+            }
+            a.overwrite_descriptor(mx::subtract(a, to_array(v, a.dtype())));
+            return a;
+          },
+          "other"_a,
+          nb::rv_policy::none)
+      .def(
+          "__rsub__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("subtraction", v);
+            }
+            return mx::subtract(to_array(v, a.dtype()), a);
+          },
+          "other"_a)
+      .def(
+          "__mul__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("multiplication", v);
+            }
+            return mx::multiply(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__imul__",
+          [](mx::array& a, const ScalarOrArray v) -> mx::array& {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("inplace multiplication", v);
+            }
+            a.overwrite_descriptor(mx::multiply(a, to_array(v, a.dtype())));
+            return a;
+          },
+          "other"_a,
+          nb::rv_policy::none)
+      .def(
+          "__rmul__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("multiplication", v);
+            }
+            return mx::multiply(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__truediv__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("division", v);
+            }
+            return mx::divide(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__itruediv__",
+          [](mx::array& a, const ScalarOrArray v) -> mx::array& {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("inplace division", v);
+            }
+            if (!mx::issubdtype(a.dtype(), mx::inexact)) {
+              throw std::invalid_argument(
+                  "In place division cannot cast to non-floating point type.");
+            }
+            a.overwrite_descriptor(divide(a, to_array(v, a.dtype())));
+            return a;
+          },
+          "other"_a,
+          nb::rv_policy::none)
+      .def(
+          "__rtruediv__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("division", v);
+            }
+            return mx::divide(to_array(v, a.dtype()), a);
+          },
+          "other"_a)
+      .def(
+          "__div__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("division", v);
+            }
+            return mx::divide(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__rdiv__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("division", v);
+            }
+            return mx::divide(to_array(v, a.dtype()), a);
+          },
+          "other"_a)
+      .def(
+          "__floordiv__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("floor division", v);
+            }
+            return mx::floor_divide(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__ifloordiv__",
+          [](mx::array& a, const ScalarOrArray v) -> mx::array& {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("inplace floor division", v);
+            }
+            a.overwrite_descriptor(mx::floor_divide(a, to_array(v, a.dtype())));
+            return a;
+          },
+          "other"_a,
+          nb::rv_policy::none)
+      .def(
+          "__rfloordiv__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("floor division", v);
+            }
+            auto b = to_array(v, a.dtype());
+            return mx::floor_divide(b, a);
+          },
+          "other"_a)
+      .def(
+          "__mod__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("modulus", v);
+            }
+            return mx::remainder(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__imod__",
+          [](mx::array& a, const ScalarOrArray v) -> mx::array& {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("inplace modulus", v);
+            }
+            a.overwrite_descriptor(mx::remainder(a, to_array(v, a.dtype())));
+            return a;
+          },
+          "other"_a,
+          nb::rv_policy::none)
+      .def(
+          "__rmod__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("modulus", v);
+            }
+            return mx::remainder(to_array(v, a.dtype()), a);
+          },
+          "other"_a)
+      .def(
+          "__eq__",
+          [](const mx::array& a,
+             const ScalarOrArray& v) -> std::variant<mx::array, bool> {
+            if (!is_comparable_with_array(v)) {
+              return false;
+            }
+            return mx::equal(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__lt__",
+          [](const mx::array& a, const ScalarOrArray v) -> mx::array {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("less than", v);
+            }
+            return mx::less(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__le__",
+          [](const mx::array& a, const ScalarOrArray v) -> mx::array {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("less than or equal", v);
+            }
+            return mx::less_equal(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__gt__",
+          [](const mx::array& a, const ScalarOrArray v) -> mx::array {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("greater than", v);
+            }
+            return mx::greater(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__ge__",
+          [](const mx::array& a, const ScalarOrArray v) -> mx::array {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("greater than or equal", v);
+            }
+            return mx::greater_equal(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__ne__",
+          [](const mx::array& a,
+             const ScalarOrArray v) -> std::variant<mx::array, bool> {
+            if (!is_comparable_with_array(v)) {
+              return true;
+            }
+            return mx::not_equal(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def("__neg__", [](const mx::array& a) { return -a; })
+      .def("__bool__", [](mx::array& a) { return nb::bool_(to_scalar(a)); })
+      .def(
+          "__repr__",
+          [](mx::array& a) {
+            nb::gil_scoped_release nogil;
+            std::ostringstream os;
+            os << a;
+            return os.str();
+          })
+      .def(
+          "__matmul__",
+          [](const mx::array& a, mx::array& other) {
+            return mx::matmul(a, other);
+          },
+          "other"_a)
+      .def(
+          "__imatmul__",
+          [](mx::array& a, mx::array& other) -> mx::array& {
+            a.overwrite_descriptor(mx::matmul(a, other));
+            return a;
+          },
+          "other"_a,
+          nb::rv_policy::none)
+      .def(
+          "__pow__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("power", v);
+            }
+            return mx::power(a, to_array(v, a.dtype()));
+          },
+          "other"_a)
+      .def(
+          "__rpow__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("power", v);
+            }
+            return mx::power(to_array(v, a.dtype()), a);
+          },
+          "other"_a)
+      .def(
+          "__ipow__",
+          [](mx::array& a, const ScalarOrArray v) -> mx::array& {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("inplace power", v);
+            }
+            a.overwrite_descriptor(mx::power(a, to_array(v, a.dtype())));
+            return a;
+          },
+          "other"_a,
+          nb::rv_policy::none)
+      .def(
+          "__invert__",
+          [](const mx::array& a) {
+            if (mx::issubdtype(a.dtype(), mx::inexact)) {
+              throw std::invalid_argument(
+                  "Floating point types not allowed with bitwise inversion.");
+            }
+            if (a.dtype() == mx::bool_) {
+              return mx::logical_not(a);
+            }
+            return mx::bitwise_invert(a);
+          })
+      .def(
+          "__and__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("bitwise and", v);
+            }
+            auto b = to_array(v, a.dtype());
+            if (mx::issubdtype(a.dtype(), mx::inexact) ||
+                mx::issubdtype(b.dtype(), mx::inexact)) {
+              throw std::invalid_argument(
+                  "Floating point types not allowed with bitwise and.");
+            }
+            return mx::bitwise_and(a, b);
+          },
+          "other"_a)
+      .def(
+          "__iand__",
+          [](mx::array& a, const ScalarOrArray v) -> mx::array& {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("inplace bitwise and", v);
+            }
+            auto b = to_array(v, a.dtype());
+            if (mx::issubdtype(a.dtype(), mx::inexact) ||
+                mx::issubdtype(b.dtype(), mx::inexact)) {
+              throw std::invalid_argument(
+                  "Floating point types not allowed with bitwise and.");
+            }
+            a.overwrite_descriptor(mx::bitwise_and(a, b));
+            return a;
+          },
+          "other"_a,
+          nb::rv_policy::none)
+      .def(
+          "__or__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("bitwise or", v);
+            }
+            auto b = to_array(v, a.dtype());
+            if (mx::issubdtype(a.dtype(), mx::inexact) ||
+                mx::issubdtype(b.dtype(), mx::inexact)) {
+              throw std::invalid_argument(
+                  "Floating point types not allowed with bitwise or.");
+            }
+            return mx::bitwise_or(a, b);
+          },
+          "other"_a)
+      .def(
+          "__ior__",
+          [](mx::array& a, const ScalarOrArray v) -> mx::array& {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("inplace bitwise or", v);
+            }
+            auto b = to_array(v, a.dtype());
+            if (mx::issubdtype(a.dtype(), mx::inexact) ||
+                mx::issubdtype(b.dtype(), mx::inexact)) {
+              throw std::invalid_argument(
+                  "Floating point types not allowed with bitwise or.");
+            }
+            a.overwrite_descriptor(mx::bitwise_or(a, b));
+            return a;
+          },
+          "other"_a,
+          nb::rv_policy::none)
+      .def(
+          "__lshift__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("left shift", v);
+            }
+            auto b = to_array(v, a.dtype());
+            if (mx::issubdtype(a.dtype(), mx::inexact) ||
+                mx::issubdtype(b.dtype(), mx::inexact)) {
+              throw std::invalid_argument(
+                  "Floating point types not allowed with left shift.");
+            }
+            return mx::left_shift(a, b);
+          },
+          "other"_a)
+      .def(
+          "__ilshift__",
+          [](mx::array& a, const ScalarOrArray v) -> mx::array& {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("inplace left shift", v);
+            }
+            auto b = to_array(v, a.dtype());
+            if (mx::issubdtype(a.dtype(), mx::inexact) ||
+                mx::issubdtype(b.dtype(), mx::inexact)) {
+              throw std::invalid_argument(
+                  "Floating point types not allowed with left shift.");
+            }
+            a.overwrite_descriptor(mx::left_shift(a, b));
+            return a;
+          },
+          "other"_a,
+          nb::rv_policy::none)
+      .def(
+          "__rshift__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("right shift", v);
+            }
+            auto b = to_array(v, a.dtype());
+            if (mx::issubdtype(a.dtype(), mx::inexact) ||
+                mx::issubdtype(b.dtype(), mx::inexact)) {
+              throw std::invalid_argument(
+                  "Floating point types not allowed with right shift.");
+            }
+            return mx::right_shift(a, b);
+          },
+          "other"_a)
+      .def(
+          "__irshift__",
+          [](mx::array& a, const ScalarOrArray v) -> mx::array& {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("inplace right shift", v);
+            }
+            auto b = to_array(v, a.dtype());
+            if (mx::issubdtype(a.dtype(), mx::inexact) ||
+                mx::issubdtype(b.dtype(), mx::inexact)) {
+              throw std::invalid_argument(
+                  "Floating point types not allowed with right shift.");
+            }
+            a.overwrite_descriptor(mx::right_shift(a, b));
+            return a;
+          },
+          "other"_a,
+          nb::rv_policy::none)
+      .def(
+          "__xor__",
+          [](const mx::array& a, const ScalarOrArray v) {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("bitwise xor", v);
+            }
+            auto b = to_array(v, a.dtype());
+            if (mx::issubdtype(a.dtype(), mx::inexact) ||
+                mx::issubdtype(b.dtype(), mx::inexact)) {
+              throw std::invalid_argument(
+                  "Floating point types not allowed with bitwise xor.");
+            }
+            return mx::bitwise_xor(a, b);
+          },
+          "other"_a)
+      .def(
+          "__ixor__",
+          [](mx::array& a, const ScalarOrArray v) -> mx::array& {
+            if (!is_comparable_with_array(v)) {
+              throw_invalid_operation("inplace bitwise xor", v);
+            }
+            auto b = to_array(v, a.dtype());
+            if (mx::issubdtype(a.dtype(), mx::inexact) ||
+                mx::issubdtype(b.dtype(), mx::inexact)) {
+              throw std::invalid_argument(
+                  "Floating point types not allowed bitwise xor.");
+            }
+            a.overwrite_descriptor(mx::bitwise_xor(a, b));
+            return a;
+          },
+          "other"_a,
+          nb::rv_policy::none)
+      .def("__int__", [](mx::array& a) { return nb::int_(to_scalar(a)); })
+      .def("__float__", [](mx::array& a) { return nb::float_(to_scalar(a)); })
+      .def(
+          "__format__",
+          [](mx::array& a, nb::object format_spec) {
+            if (nb::len(nb::str(format_spec)) > 0 && a.ndim() > 0) {
+              throw nb::type_error(
+                  "unsupported format string passed to mx.array.__format__");
+            } else if (a.ndim() == 0) {
+              auto obj = to_scalar(a);
+              return nb::cast<std::string>(
+                  nb::handle(PyObject_Format(obj.ptr(), format_spec.ptr())));
+            } else {
+              nb::gil_scoped_release nogil;
+              std::ostringstream os;
+              os << a;
+              return os.str();
+            }
+          })
+      .def(
+          "flatten",
+          [](const mx::array& a,
+             int start_axis,
+             int end_axis,
+             const mx::StreamOrDevice& s) {
+            return mx::flatten(a, start_axis, end_axis, s);
+          },
+          "start_axis"_a = 0,
+          "end_axis"_a = -1,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          R"pbdoc(
+            See :func:`flatten`.
+          )pbdoc")
+      .def(
+          "reshape",
+          [](const mx::array& a, nb::args shape_, mx::StreamOrDevice s) {
+            mx::Shape shape;
+            if (!nb::isinstance<int>(shape_[0])) {
+              shape = nb::cast<mx::Shape>(shape_[0]);
+            } else {
+              shape = nb::cast<mx::Shape>(shape_);
+            }
+            return mx::reshape(a, std::move(shape), s);
+          },
+          "shape"_a,
+          "stream"_a = nb::none(),
+          R"pbdoc(
+            Equivalent to :func:`reshape` but the shape can be passed either as a
+            :obj:`tuple` or as separate arguments.
+
+            See :func:`reshape` for full documentation.
+          )pbdoc")
+      .def(
+          "squeeze",
+          [](const mx::array& a,
+             const IntOrVec& v,
+             const mx::StreamOrDevice& s) {
+            if (std::holds_alternative<std::monostate>(v)) {
+              return mx::squeeze(a, s);
+            } else if (auto pv = std::get_if<int>(&v); pv) {
+              return mx::squeeze(a, *pv, s);
+            } else {
+              return mx::squeeze(a, std::get<std::vector<int>>(v), s);
+            }
+          },
+          "axis"_a = nb::none(),
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          R"pbdoc(
+            See :func:`squeeze`.
+          )pbdoc")
+      .def(
+          "abs",
+          &mx::abs,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`abs`.")
+      .def(
+          "__abs__",
+          [](const mx::array& a) { return mx::abs(a); },
+          "See :func:`abs`.")
+      .def(
+          "square",
+          &mx::square,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`square`.")
+      .def(
+          "sqrt",
+          &mx::sqrt,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`sqrt`.")
+      .def(
+          "rsqrt",
+          &mx::rsqrt,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`rsqrt`.")
+      .def(
+          "reciprocal",
+          &mx::reciprocal,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`reciprocal`.")
+      .def(
+          "exp",
+          &mx::exp,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`exp`.")
+      .def(
+          "log",
+          &mx::log,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`log`.")
+      .def(
+          "log2",
+          &mx::log2,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`log2`.")
+      .def(
+          "log10",
+          &mx::log10,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`log10`.")
+      .def(
+          "sin",
+          &mx::sin,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`sin`.")
+      .def(
+          "cos",
+          &mx::cos,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`cos`.")
+      .def(
+          "log1p",
+          &mx::log1p,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`log1p`.")
+      .def(
+          "all",
+          [](const mx::array& a,
+             const IntOrVec& axis,
+             bool keepdims,
+             mx::StreamOrDevice s) {
+            return mx::all(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+          },
+          "axis"_a = nb::none(),
+          "keepdims"_a = false,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`all`.")
+      .def(
+          "any",
+          [](const mx::array& a,
+             const IntOrVec& axis,
+             bool keepdims,
+             mx::StreamOrDevice s) {
+            return mx::any(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+          },
+          "axis"_a = nb::none(),
+          "keepdims"_a = false,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`any`.")
+      .def(
+          "moveaxis",
+          &mx::moveaxis,
+          "source"_a,
+          "destination"_a,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`moveaxis`.")
+      .def(
+          "swapaxes",
+          &mx::swapaxes,
+          "axis1"_a,
+          "axis2"_a,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`swapaxes`.")
+      .def(
+          "transpose",
+          [](const mx::array& a, nb::args axes_, mx::StreamOrDevice s) {
+            if (axes_.size() == 0) {
+              return mx::transpose(a, s);
+            }
+            std::vector<int> axes;
+            if (!nb::isinstance<int>(axes_[0])) {
+              axes = nb::cast<std::vector<int>>(axes_[0]);
+            } else {
+              axes = nb::cast<std::vector<int>>(axes_);
+            }
+            return mx::transpose(a, axes, s);
+          },
+          "axes"_a,
+          "stream"_a = nb::none(),
+          R"pbdoc(
+            Equivalent to :func:`transpose` but the axes can be passed either as
+            a tuple or as separate arguments.
+
+            See :func:`transpose` for full documentation.
+          )pbdoc")
+      .def_prop_ro(
+          "T",
+          [](const mx::array& a) { return mx::transpose(a); },
+          "Equivalent to calling ``self.transpose()`` with no arguments.")
+      .def(
+          "sum",
+          [](const mx::array& a,
+             const IntOrVec& axis,
+             bool keepdims,
+             mx::StreamOrDevice s) {
+            return mx::sum(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+          },
+          "axis"_a = nb::none(),
+          "keepdims"_a = false,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`sum`.")
+      .def(
+          "prod",
+          [](const mx::array& a,
+             const IntOrVec& axis,
+             bool keepdims,
+             mx::StreamOrDevice s) {
+            return mx::prod(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+          },
+          "axis"_a = nb::none(),
+          "keepdims"_a = false,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`prod`.")
+      .def(
+          "min",
+          [](const mx::array& a,
+             const IntOrVec& axis,
+             bool keepdims,
+             mx::StreamOrDevice s) {
+            return mx::min(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+          },
+          "axis"_a = nb::none(),
+          "keepdims"_a = false,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`min`.")
+      .def(
+          "max",
+          [](const mx::array& a,
+             const IntOrVec& axis,
+             bool keepdims,
+             mx::StreamOrDevice s) {
+            return mx::max(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+          },
+          "axis"_a = nb::none(),
+          "keepdims"_a = false,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`max`.")
+      .def(
+          "logcumsumexp",
+          [](const mx::array& a,
+             std::optional<int> axis,
+             bool reverse,
+             bool inclusive,
+             mx::StreamOrDevice s) {
+            if (axis) {
+              return mx::logcumsumexp(a, *axis, reverse, inclusive, s);
+            } else {
+              // TODO: Implement that in the C++ API as well. See concatenate
+              // above.
+              return mx::logcumsumexp(
+                  mx::reshape(a, {-1}, s), 0, reverse, inclusive, s);
+            }
+          },
+          "axis"_a = nb::none(),
+          nb::kw_only(),
+          "reverse"_a = false,
+          "inclusive"_a = true,
+          "stream"_a = nb::none(),
+          "See :func:`logcumsumexp`.")
+      .def(
+          "logsumexp",
+          [](const mx::array& a,
+             const IntOrVec& axis,
+             bool keepdims,
+             mx::StreamOrDevice s) {
+            return mx::logsumexp(
+                a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+          },
+          "axis"_a = nb::none(),
+          "keepdims"_a = false,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`logsumexp`.")
+      .def(
+          "mean",
+          [](const mx::array& a,
+             const IntOrVec& axis,
+             bool keepdims,
+             mx::StreamOrDevice s) {
+            return mx::mean(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+          },
+          "axis"_a = nb::none(),
+          "keepdims"_a = false,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`mean`.")
+      .def(
+          "std",
+          [](const mx::array& a,
+             const IntOrVec& axis,
+             bool keepdims,
+             int ddof,
+             mx::StreamOrDevice s) {
+            return mx::std(
+                a, get_reduce_axes(axis, a.ndim()), keepdims, ddof, s);
+          },
+          "axis"_a = nb::none(),
+          "keepdims"_a = false,
+          "ddof"_a = 0,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`std`.")
+      .def(
+          "var",
+          [](const mx::array& a,
+             const IntOrVec& axis,
+             bool keepdims,
+             int ddof,
+             mx::StreamOrDevice s) {
+            return mx::var(
+                a, get_reduce_axes(axis, a.ndim()), keepdims, ddof, s);
+          },
+          "axis"_a = nb::none(),
+          "keepdims"_a = false,
+          "ddof"_a = 0,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`var`.")
+      .def(
+          "split",
+          [](const mx::array& a,
+             const std::variant<int, mx::Shape>& indices_or_sections,
+             int axis,
+             mx::StreamOrDevice s) {
+            if (auto pv = std::get_if<int>(&indices_or_sections); pv) {
+              return mx::split(a, *pv, axis, s);
+            } else {
+              return mx::split(
+                  a, std::get<mx::Shape>(indices_or_sections), axis, s);
+            }
+          },
+          "indices_or_sections"_a,
+          "axis"_a = 0,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`split`.")
+      .def(
+          "argmin",
+          [](const mx::array& a,
+             std::optional<int> axis,
+             bool keepdims,
+             mx::StreamOrDevice s) {
+            if (axis) {
+              return mx::argmin(a, *axis, keepdims, s);
+            } else {
+              return mx::argmin(a, keepdims, s);
+            }
+          },
+          "axis"_a = std::nullopt,
+          "keepdims"_a = false,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`argmin`.")
+      .def(
+          "argmax",
+          [](const mx::array& a,
+             std::optional<int> axis,
+             bool keepdims,
+             mx::StreamOrDevice s) {
+            if (axis) {
+              return mx::argmax(a, *axis, keepdims, s);
+            } else {
+              return mx::argmax(a, keepdims, s);
+            }
+          },
+          "axis"_a = nb::none(),
+          "keepdims"_a = false,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`argmax`.")
+      .def(
+          "cumsum",
+          [](const mx::array& a,
+             std::optional<int> axis,
+             bool reverse,
+             bool inclusive,
+             mx::StreamOrDevice s) {
+            if (axis) {
+              return mx::cumsum(a, *axis, reverse, inclusive, s);
+            } else {
+              // TODO: Implement that in the C++ API as well. See concatenate
+              // above.
+              return mx::cumsum(reshape(a, {-1}, s), 0, reverse, inclusive, s);
+            }
+          },
+          "axis"_a = nb::none(),
+          nb::kw_only(),
+          "reverse"_a = false,
+          "inclusive"_a = true,
+          "stream"_a = nb::none(),
+          "See :func:`cumsum`.")
+      .def(
+          "cumprod",
+          [](const mx::array& a,
+             std::optional<int> axis,
+             bool reverse,
+             bool inclusive,
+             mx::StreamOrDevice s) {
+            if (axis) {
+              return mx::cumprod(a, *axis, reverse, inclusive, s);
+            } else {
+              // TODO: Implement that in the C++ API as well. See concatenate
+              // above.
+              return mx::cumprod(
+                  mx::reshape(a, {-1}, s), 0, reverse, inclusive, s);
+            }
+          },
+          "axis"_a = nb::none(),
+          nb::kw_only(),
+          "reverse"_a = false,
+          "inclusive"_a = true,
+          "stream"_a = nb::none(),
+          "See :func:`cumprod`.")
+      .def(
+          "cummax",
+          [](const mx::array& a,
+             std::optional<int> axis,
+             bool reverse,
+             bool inclusive,
+             mx::StreamOrDevice s) {
+            if (axis) {
+              return mx::cummax(a, *axis, reverse, inclusive, s);
+            } else {
+              // TODO: Implement that in the C++ API as well. See concatenate
+              // above.
+              return mx::cummax(
+                  mx::reshape(a, {-1}, s), 0, reverse, inclusive, s);
+            }
+          },
+          "axis"_a = nb::none(),
+          nb::kw_only(),
+          "reverse"_a = false,
+          "inclusive"_a = true,
+          "stream"_a = nb::none(),
+          "See :func:`cummax`.")
+      .def(
+          "cummin",
+          [](const mx::array& a,
+             std::optional<int> axis,
+             bool reverse,
+             bool inclusive,
+             mx::StreamOrDevice s) {
+            if (axis) {
+              return mx::cummin(a, *axis, reverse, inclusive, s);
+            } else {
+              // TODO: Implement that in the C++ API as well. See concatenate
+              // above.
+              return mx::cummin(
+                  mx::reshape(a, {-1}, s), 0, reverse, inclusive, s);
+            }
+          },
+          "axis"_a = nb::none(),
+          nb::kw_only(),
+          "reverse"_a = false,
+          "inclusive"_a = true,
+          "stream"_a = nb::none(),
+          "See :func:`cummin`.")
+      .def(
+          "round",
+          [](const mx::array& a, int decimals, mx::StreamOrDevice s) {
+            return mx::round(a, decimals, s);
+          },
+          "decimals"_a = 0,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`round`.")
+      .def(
+          "diagonal",
+          [](const mx::array& a,
+             int offset,
+             int axis1,
+             int axis2,
+             mx::StreamOrDevice s) {
+            return mx::diagonal(a, offset, axis1, axis2, s);
+          },
+          "offset"_a = 0,
+          "axis1"_a = 0,
+          "axis2"_a = 1,
+          "stream"_a = nb::none(),
+          "See :func:`diagonal`.")
+      .def(
+          "diag",
+          [](const mx::array& a, int k, mx::StreamOrDevice s) {
+            return mx::diag(a, k, s);
+          },
+          "k"_a = 0,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          R"pbdoc(
+            Extract a diagonal or construct a diagonal matrix.
+        )pbdoc")
+      .def(
+          "conj",
+          [](const mx::array& a, mx::StreamOrDevice s) {
+            return mx::conjugate(to_array(a), s);
+          },
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`conj`.")
+      .def(
+          "view",
+          [](const ScalarOrArray& a,
+             const mx::Dtype& dtype,
+             mx::StreamOrDevice s) { return mx::view(to_array(a), dtype, s); },
+          "dtype"_a,
+          nb::kw_only(),
+          "stream"_a = nb::none(),
+          "See :func:`view`.");
+}
diff --git a/ml-stable-diffusion/mlx/python/src/buffer.h b/ml-stable-diffusion/mlx/python/src/buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..272a918883aa79049dfbbe4726475a5ca7d9dcf5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/buffer.h
@@ -0,0 +1,124 @@
+// Copyright © 2024 Apple Inc.
+#pragma once
+#include <optional>
+
+#include <nanobind/nanobind.h>
+
+#include "mlx/array.h"
+#include "mlx/utils.h"
+
+// Only defined in >= Python 3.9
+// https://github.com/python/cpython/blob/f6cdc6b4a191b75027de342aa8b5d344fb31313e/Include/typeslots.h#L2-L3
+#ifndef Py_bf_getbuffer
+#define Py_bf_getbuffer 1
+#define Py_bf_releasebuffer 2
+#endif
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+
+std::string buffer_format(const mx::array& a) {
+  // https://docs.python.org/3.10/library/struct.html#format-characters
+  switch (a.dtype()) {
+    case mx::bool_:
+      return "?";
+    case mx::uint8:
+      return "B";
+    case mx::uint16:
+      return "H";
+    case mx::uint32:
+      return "I";
+    case mx::uint64:
+      return "Q";
+    case mx::int8:
+      return "b";
+    case mx::int16:
+      return "h";
+    case mx::int32:
+      return "i";
+    case mx::int64:
+      return "q";
+    case mx::float16:
+      return "e";
+    case mx::float32:
+      return "f";
+    case mx::bfloat16:
+      return "B";
+    case mx::float64:
+      return "d";
+    case mx::complex64:
+      return "Zf\0";
+    default: {
+      std::ostringstream os;
+      os << "bad dtype: " << a.dtype();
+      throw std::runtime_error(os.str());
+    }
+  }
+}
+
+struct buffer_info {
+  std::string format;
+  std::vector<Py_ssize_t> shape;
+  std::vector<Py_ssize_t> strides;
+
+  buffer_info(
+      std::string format,
+      std::vector<Py_ssize_t> shape_in,
+      std::vector<Py_ssize_t> strides_in)
+      : format(std::move(format)),
+        shape(std::move(shape_in)),
+        strides(std::move(strides_in)) {}
+
+  buffer_info(const buffer_info&) = delete;
+  buffer_info& operator=(const buffer_info&) = delete;
+
+  buffer_info(buffer_info&& other) noexcept {
+    (*this) = std::move(other);
+  }
+
+  buffer_info& operator=(buffer_info&& rhs) noexcept {
+    format = std::move(rhs.format);
+    shape = std::move(rhs.shape);
+    strides = std::move(rhs.strides);
+    return *this;
+  }
+};
+
+extern "C" inline int getbuffer(PyObject* obj, Py_buffer* view, int flags) {
+  std::memset(view, 0, sizeof(Py_buffer));
+  auto a = nb::cast<mx::array>(nb::handle(obj));
+
+  {
+    nb::gil_scoped_release nogil;
+    a.eval();
+  }
+
+  std::vector<Py_ssize_t> shape(a.shape().begin(), a.shape().end());
+  std::vector<Py_ssize_t> strides(a.strides().begin(), a.strides().end());
+  for (auto& s : strides) {
+    s *= a.itemsize();
+  }
+  buffer_info* info =
+      new buffer_info(buffer_format(a), std::move(shape), std::move(strides));
+
+  view->obj = obj;
+  view->ndim = a.ndim();
+  view->internal = info;
+  view->buf = a.data<void>();
+  view->itemsize = a.itemsize();
+  view->len = a.nbytes();
+  view->readonly = false;
+  if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) {
+    view->format = const_cast<char*>(info->format.c_str());
+  }
+  if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) {
+    view->strides = info->strides.data();
+    view->shape = info->shape.data();
+  }
+  Py_INCREF(view->obj);
+  return 0;
+}
+
+extern "C" inline void releasebuffer(PyObject*, Py_buffer* view) {
+  delete (buffer_info*)view->internal;
+}
diff --git a/ml-stable-diffusion/mlx/python/src/constants.cpp b/ml-stable-diffusion/mlx/python/src/constants.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0d9de75b7d77b7760726c39182f79538d414498c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/constants.cpp
@@ -0,0 +1,15 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <nanobind/nanobind.h>
+#include <limits>
+
+namespace nb = nanobind;
+
+void init_constants(nb::module_& m) {
+  m.attr("e") = 2.71828182845904523536028747135266249775724709369995;
+  m.attr("euler_gamma") = 0.5772156649015328606065120900824024310421;
+  m.attr("inf") = std::numeric_limits<double>::infinity();
+  m.attr("nan") = NAN;
+  m.attr("newaxis") = nb::none();
+  m.attr("pi") = 3.1415926535897932384626433;
+}
diff --git a/ml-stable-diffusion/mlx/python/src/convert.cpp b/ml-stable-diffusion/mlx/python/src/convert.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..88da37103eece7d43b085da2814a49f0cab203a6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/convert.cpp
@@ -0,0 +1,491 @@
+// Copyright © 2024 Apple Inc.
+
+#include <nanobind/stl/complex.h>
+
+#include "python/src/convert.h"
+#include "python/src/utils.h"
+
+#include "mlx/utils.h"
+
+enum PyScalarT {
+  pybool = 0,
+  pyint = 1,
+  pyfloat = 2,
+  pycomplex = 3,
+};
+
+namespace nanobind {
+template <>
+struct ndarray_traits<mx::float16_t> {
+  static constexpr bool is_complex = false;
+  static constexpr bool is_float = true;
+  static constexpr bool is_bool = false;
+  static constexpr bool is_int = false;
+  static constexpr bool is_signed = true;
+};
+}; // namespace nanobind
+
+int check_shape_dim(int64_t dim) {
+  if (dim > std::numeric_limits<int>::max()) {
+    throw std::invalid_argument(
+        "Shape dimension falls outside supported `int` range.");
+  }
+  return static_cast<int>(dim);
+}
+
+template <typename T>
+mx::array nd_array_to_mlx_contiguous(
+    nb::ndarray<nb::ro, nb::c_contig, nb::device::cpu> nd_array,
+    const mx::Shape& shape,
+    mx::Dtype dtype) {
+  // Make a copy of the numpy buffer
+  // Get buffer ptr pass to array constructor
+  auto data_ptr = nd_array.data();
+  return mx::array(static_cast<const T*>(data_ptr), shape, dtype);
+}
+
+mx::array nd_array_to_mlx(
+    nb::ndarray<nb::ro, nb::c_contig, nb::device::cpu> nd_array,
+    std::optional<mx::Dtype> dtype) {
+  // Compute the shape and size
+  mx::Shape shape;
+  shape.reserve(nd_array.ndim());
+  for (int i = 0; i < nd_array.ndim(); i++) {
+    shape.push_back(check_shape_dim(nd_array.shape(i)));
+  }
+  auto type = nd_array.dtype();
+
+  // Copy data and make array
+  if (type == nb::dtype<bool>()) {
+    return nd_array_to_mlx_contiguous<bool>(
+        nd_array, shape, dtype.value_or(mx::bool_));
+  } else if (type == nb::dtype<uint8_t>()) {
+    return nd_array_to_mlx_contiguous<uint8_t>(
+        nd_array, shape, dtype.value_or(mx::uint8));
+  } else if (type == nb::dtype<uint16_t>()) {
+    return nd_array_to_mlx_contiguous<uint16_t>(
+        nd_array, shape, dtype.value_or(mx::uint16));
+  } else if (type == nb::dtype<uint32_t>()) {
+    return nd_array_to_mlx_contiguous<uint32_t>(
+        nd_array, shape, dtype.value_or(mx::uint32));
+  } else if (type == nb::dtype<uint64_t>()) {
+    return nd_array_to_mlx_contiguous<uint64_t>(
+        nd_array, shape, dtype.value_or(mx::uint64));
+  } else if (type == nb::dtype<int8_t>()) {
+    return nd_array_to_mlx_contiguous<int8_t>(
+        nd_array, shape, dtype.value_or(mx::int8));
+  } else if (type == nb::dtype<int16_t>()) {
+    return nd_array_to_mlx_contiguous<int16_t>(
+        nd_array, shape, dtype.value_or(mx::int16));
+  } else if (type == nb::dtype<int32_t>()) {
+    return nd_array_to_mlx_contiguous<int32_t>(
+        nd_array, shape, dtype.value_or(mx::int32));
+  } else if (type == nb::dtype<int64_t>()) {
+    return nd_array_to_mlx_contiguous<int64_t>(
+        nd_array, shape, dtype.value_or(mx::int64));
+  } else if (type == nb::dtype<mx::float16_t>()) {
+    return nd_array_to_mlx_contiguous<mx::float16_t>(
+        nd_array, shape, dtype.value_or(mx::float16));
+  } else if (type == nb::bfloat16) {
+    return nd_array_to_mlx_contiguous<mx::bfloat16_t>(
+        nd_array, shape, dtype.value_or(mx::bfloat16));
+  } else if (type == nb::dtype<float>()) {
+    return nd_array_to_mlx_contiguous<float>(
+        nd_array, shape, dtype.value_or(mx::float32));
+  } else if (type == nb::dtype<double>()) {
+    return nd_array_to_mlx_contiguous<double>(
+        nd_array, shape, dtype.value_or(mx::float32));
+  } else if (type == nb::dtype<std::complex<float>>()) {
+    return nd_array_to_mlx_contiguous<mx::complex64_t>(
+        nd_array, shape, dtype.value_or(mx::complex64));
+  } else if (type == nb::dtype<std::complex<double>>()) {
+    return nd_array_to_mlx_contiguous<mx::complex128_t>(
+        nd_array, shape, dtype.value_or(mx::complex64));
+  } else {
+    throw std::invalid_argument("Cannot convert numpy array to mlx array.");
+  }
+}
+
+template <typename T, typename... NDParams>
+nb::ndarray<NDParams...> mlx_to_nd_array_impl(
+    mx::array a,
+    std::optional<nb::dlpack::dtype> t = {}) {
+  {
+    nb::gil_scoped_release nogil;
+    a.eval();
+  }
+  std::vector<size_t> shape(a.shape().begin(), a.shape().end());
+  return nb::ndarray<NDParams...>(
+      a.data<T>(),
+      a.ndim(),
+      shape.data(),
+      /* owner= */ nb::none(),
+      a.strides().data(),
+      t.value_or(nb::dtype<T>()));
+}
+
+template <typename... NDParams>
+nb::ndarray<NDParams...> mlx_to_nd_array(const mx::array& a) {
+  switch (a.dtype()) {
+    case mx::bool_:
+      return mlx_to_nd_array_impl<bool, NDParams...>(a);
+    case mx::uint8:
+      return mlx_to_nd_array_impl<uint8_t, NDParams...>(a);
+    case mx::uint16:
+      return mlx_to_nd_array_impl<uint16_t, NDParams...>(a);
+    case mx::uint32:
+      return mlx_to_nd_array_impl<uint32_t, NDParams...>(a);
+    case mx::uint64:
+      return mlx_to_nd_array_impl<uint64_t, NDParams...>(a);
+    case mx::int8:
+      return mlx_to_nd_array_impl<int8_t, NDParams...>(a);
+    case mx::int16:
+      return mlx_to_nd_array_impl<int16_t, NDParams...>(a);
+    case mx::int32:
+      return mlx_to_nd_array_impl<int32_t, NDParams...>(a);
+    case mx::int64:
+      return mlx_to_nd_array_impl<int64_t, NDParams...>(a);
+    case mx::float16:
+      return mlx_to_nd_array_impl<mx::float16_t, NDParams...>(a);
+    case mx::bfloat16:
+      throw nb::type_error("bfloat16 arrays cannot be converted to NumPy.");
+    case mx::float32:
+      return mlx_to_nd_array_impl<float, NDParams...>(a);
+    case mx::float64:
+      return mlx_to_nd_array_impl<double, NDParams...>(a);
+    case mx::complex64:
+      return mlx_to_nd_array_impl<std::complex<float>, NDParams...>(a);
+    default:
+      throw nb::type_error("type cannot be converted to NumPy.");
+  }
+}
+
+nb::ndarray<nb::numpy> mlx_to_np_array(const mx::array& a) {
+  return mlx_to_nd_array<nb::numpy>(a);
+}
+
+nb::ndarray<> mlx_to_dlpack(const mx::array& a) {
+  return mlx_to_nd_array<>(a);
+}
+
+nb::object to_scalar(mx::array& a) {
+  if (a.size() != 1) {
+    throw std::invalid_argument(
+        "[convert] Only length-1 arrays can be converted to Python scalars.");
+  }
+  {
+    nb::gil_scoped_release nogil;
+    a.eval();
+  }
+  switch (a.dtype()) {
+    case mx::bool_:
+      return nb::cast(a.item<bool>());
+    case mx::uint8:
+      return nb::cast(a.item<uint8_t>());
+    case mx::uint16:
+      return nb::cast(a.item<uint16_t>());
+    case mx::uint32:
+      return nb::cast(a.item<uint32_t>());
+    case mx::uint64:
+      return nb::cast(a.item<uint64_t>());
+    case mx::int8:
+      return nb::cast(a.item<int8_t>());
+    case mx::int16:
+      return nb::cast(a.item<int16_t>());
+    case mx::int32:
+      return nb::cast(a.item<int32_t>());
+    case mx::int64:
+      return nb::cast(a.item<int64_t>());
+    case mx::float16:
+      return nb::cast(static_cast<float>(a.item<mx::float16_t>()));
+    case mx::float32:
+      return nb::cast(a.item<float>());
+    case mx::bfloat16:
+      return nb::cast(static_cast<float>(a.item<mx::bfloat16_t>()));
+    case mx::complex64:
+      return nb::cast(a.item<std::complex<float>>());
+    case mx::float64:
+      return nb::cast(a.item<double>());
+    default:
+      throw nb::type_error("type cannot be converted to Python scalar.");
+  }
+}
+
+template <typename T, typename U = T>
+nb::list to_list(mx::array& a, size_t index, int dim) {
+  nb::list pl;
+  auto stride = a.strides()[dim];
+  for (int i = 0; i < a.shape(dim); ++i) {
+    if (dim == a.ndim() - 1) {
+      pl.append(static_cast<U>(a.data<T>()[index]));
+    } else {
+      pl.append(to_list<T, U>(a, index, dim + 1));
+    }
+    index += stride;
+  }
+  return pl;
+}
+
+nb::object tolist(mx::array& a) {
+  if (a.ndim() == 0) {
+    return to_scalar(a);
+  }
+  {
+    nb::gil_scoped_release nogil;
+    a.eval();
+  }
+  switch (a.dtype()) {
+    case mx::bool_:
+      return to_list<bool>(a, 0, 0);
+    case mx::uint8:
+      return to_list<uint8_t>(a, 0, 0);
+    case mx::uint16:
+      return to_list<uint16_t>(a, 0, 0);
+    case mx::uint32:
+      return to_list<uint32_t>(a, 0, 0);
+    case mx::uint64:
+      return to_list<uint64_t>(a, 0, 0);
+    case mx::int8:
+      return to_list<int8_t>(a, 0, 0);
+    case mx::int16:
+      return to_list<int16_t>(a, 0, 0);
+    case mx::int32:
+      return to_list<int32_t>(a, 0, 0);
+    case mx::int64:
+      return to_list<int64_t>(a, 0, 0);
+    case mx::float16:
+      return to_list<mx::float16_t, float>(a, 0, 0);
+    case mx::float32:
+      return to_list<float>(a, 0, 0);
+    case mx::bfloat16:
+      return to_list<mx::bfloat16_t, float>(a, 0, 0);
+    case mx::complex64:
+      return to_list<std::complex<float>>(a, 0, 0);
+    default:
+      throw nb::type_error("data type cannot be converted to Python list.");
+  }
+}
+
+template <typename T, typename U>
+void fill_vector(T list, std::vector<U>& vals) {
+  for (auto l : list) {
+    if (nb::isinstance<nb::list>(l)) {
+      fill_vector(nb::cast<nb::list>(l), vals);
+    } else if (nb::isinstance<nb::tuple>(*list.begin())) {
+      fill_vector(nb::cast<nb::tuple>(l), vals);
+    } else {
+      vals.push_back(nb::cast<U>(l));
+    }
+  }
+}
+
+template <typename T>
+PyScalarT validate_shape(
+    T list,
+    const mx::Shape& shape,
+    int idx,
+    bool& all_python_primitive_elements) {
+  if (idx >= shape.size()) {
+    throw std::invalid_argument("Initialization encountered extra dimension.");
+  }
+  auto s = shape[idx];
+  if (nb::len(list) != s) {
+    throw std::invalid_argument(
+        "Initialization encountered non-uniform length.");
+  }
+
+  if (s == 0) {
+    return pyfloat;
+  }
+
+  PyScalarT type = pybool;
+  for (auto l : list) {
+    PyScalarT t;
+    if (nb::isinstance<nb::list>(l)) {
+      t = validate_shape(
+          nb::cast<nb::list>(l), shape, idx + 1, all_python_primitive_elements);
+    } else if (nb::isinstance<nb::tuple>(*list.begin())) {
+      t = validate_shape(
+          nb::cast<nb::tuple>(l),
+          shape,
+          idx + 1,
+          all_python_primitive_elements);
+    } else if (nb::isinstance<mx::array>(l)) {
+      all_python_primitive_elements = false;
+      auto arr = nb::cast<mx::array>(l);
+      if (arr.ndim() + idx + 1 == shape.size() &&
+          std::equal(
+              arr.shape().cbegin(),
+              arr.shape().cend(),
+              shape.cbegin() + idx + 1)) {
+        t = pybool;
+      } else {
+        throw std::invalid_argument(
+            "Initialization encountered non-uniform length.");
+      }
+    } else {
+      if (nb::isinstance<nb::bool_>(l)) {
+        t = pybool;
+      } else if (nb::isinstance<nb::int_>(l)) {
+        t = pyint;
+      } else if (nb::isinstance<nb::float_>(l)) {
+        t = pyfloat;
+      } else if (PyComplex_Check(l.ptr())) {
+        t = pycomplex;
+      } else {
+        std::ostringstream msg;
+        msg << "Invalid type " << nb::type_name(l.type()).c_str()
+            << " received in array initialization.";
+        throw std::invalid_argument(msg.str());
+      }
+
+      if (idx + 1 != shape.size()) {
+        throw std::invalid_argument(
+            "Initialization encountered non-uniform length.");
+      }
+    }
+    type = std::max(type, t);
+  }
+  return type;
+}
+
+template <typename T>
+void get_shape(T list, mx::Shape& shape) {
+  shape.push_back(check_shape_dim(nb::len(list)));
+  if (shape.back() > 0) {
+    auto l = list.begin();
+    if (nb::isinstance<nb::list>(*l)) {
+      return get_shape(nb::cast<nb::list>(*l), shape);
+    } else if (nb::isinstance<nb::tuple>(*l)) {
+      return get_shape(nb::cast<nb::tuple>(*l), shape);
+    } else if (nb::isinstance<mx::array>(*l)) {
+      auto arr = nb::cast<mx::array>(*l);
+      for (int i = 0; i < arr.ndim(); i++) {
+        shape.push_back(arr.shape(i));
+      }
+      return;
+    }
+  }
+}
+
+template <typename T>
+mx::array array_from_list_impl(
+    T pl,
+    const PyScalarT& inferred_type,
+    std::optional<mx::Dtype> specified_type,
+    const mx::Shape& shape) {
+  // Make the array
+  switch (inferred_type) {
+    case pybool: {
+      std::vector<bool> vals;
+      fill_vector(pl, vals);
+      return mx::array(vals.begin(), shape, specified_type.value_or(mx::bool_));
+    }
+    case pyint: {
+      auto dtype = specified_type.value_or(mx::int32);
+      if (dtype == mx::int64) {
+        std::vector<int64_t> vals;
+        fill_vector(pl, vals);
+        return mx::array(vals.begin(), shape, dtype);
+      } else if (dtype == mx::uint64) {
+        std::vector<uint64_t> vals;
+        fill_vector(pl, vals);
+        return mx::array(vals.begin(), shape, dtype);
+      } else if (dtype == mx::uint32) {
+        std::vector<uint32_t> vals;
+        fill_vector(pl, vals);
+        return mx::array(vals.begin(), shape, dtype);
+      } else if (mx::issubdtype(dtype, mx::inexact)) {
+        std::vector<float> vals;
+        fill_vector(pl, vals);
+        return mx::array(vals.begin(), shape, dtype);
+      } else {
+        std::vector<int> vals;
+        fill_vector(pl, vals);
+        return mx::array(vals.begin(), shape, dtype);
+      }
+    }
+    case pyfloat: {
+      std::vector<float> vals;
+      fill_vector(pl, vals);
+      return mx::array(
+          vals.begin(), shape, specified_type.value_or(mx::float32));
+    }
+    case pycomplex: {
+      std::vector<std::complex<float>> vals;
+      fill_vector(pl, vals);
+      return mx::array(
+          reinterpret_cast<mx::complex64_t*>(vals.data()),
+          shape,
+          specified_type.value_or(mx::complex64));
+    }
+    default: {
+      std::ostringstream msg;
+      msg << "Should not happen, inferred: " << inferred_type
+          << " on subarray made of only python primitive types.";
+      throw std::runtime_error(msg.str());
+    }
+  }
+}
+
+template <typename T>
+mx::array array_from_list_impl(T pl, std::optional<mx::Dtype> dtype) {
+  // Compute the shape
+  mx::Shape shape;
+  get_shape(pl, shape);
+
+  // Validate the shape and type
+  bool all_python_primitive_elements = true;
+  auto type = validate_shape(pl, shape, 0, all_python_primitive_elements);
+
+  if (all_python_primitive_elements) {
+    // `pl` does not contain mlx arrays
+    return array_from_list_impl(pl, type, dtype, shape);
+  }
+
+  // `pl` contains mlx arrays
+  std::vector<mx::array> arrays;
+  for (auto l : pl) {
+    arrays.push_back(create_array(nb::cast<ArrayInitType>(l), dtype));
+  }
+  return mx::stack(arrays);
+}
+
+mx::array array_from_list(nb::list pl, std::optional<mx::Dtype> dtype) {
+  return array_from_list_impl(pl, dtype);
+}
+
+mx::array array_from_list(nb::tuple pl, std::optional<mx::Dtype> dtype) {
+  return array_from_list_impl(pl, dtype);
+}
+
+mx::array create_array(ArrayInitType v, std::optional<mx::Dtype> t) {
+  if (auto pv = std::get_if<nb::bool_>(&v); pv) {
+    return mx::array(nb::cast<bool>(*pv), t.value_or(mx::bool_));
+  } else if (auto pv = std::get_if<nb::int_>(&v); pv) {
+    auto val = nb::cast<long>(*pv);
+    auto default_type = (val > std::numeric_limits<int>::max() ||
+                         val < std::numeric_limits<int>::min())
+        ? mx::int64
+        : mx::int32;
+    return mx::array(val, t.value_or(default_type));
+  } else if (auto pv = std::get_if<nb::float_>(&v); pv) {
+    return mx::array(nb::cast<float>(*pv), t.value_or(mx::float32));
+  } else if (auto pv = std::get_if<std::complex<float>>(&v); pv) {
+    return mx::array(
+        static_cast<mx::complex64_t>(*pv), t.value_or(mx::complex64));
+  } else if (auto pv = std::get_if<nb::list>(&v); pv) {
+    return array_from_list(*pv, t);
+  } else if (auto pv = std::get_if<nb::tuple>(&v); pv) {
+    return array_from_list(*pv, t);
+  } else if (auto pv = std::get_if<
+                 nb::ndarray<nb::ro, nb::c_contig, nb::device::cpu>>(&v);
+             pv) {
+    return nd_array_to_mlx(*pv, t);
+  } else if (auto pv = std::get_if<mx::array>(&v); pv) {
+    return mx::astype(*pv, t.value_or((*pv).dtype()));
+  } else {
+    auto arr = to_array_with_accessor(std::get<ArrayLike>(v).obj);
+    return mx::astype(arr, t.value_or(arr.dtype()));
+  }
+}
diff --git a/ml-stable-diffusion/mlx/python/src/convert.h b/ml-stable-diffusion/mlx/python/src/convert.h
new file mode 100644
index 0000000000000000000000000000000000000000..4f8a77abe50872087f24b37b19340d770e852af6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/convert.h
@@ -0,0 +1,50 @@
+// Copyright © 2024 Apple Inc.
+#pragma once
+
+#include <optional>
+
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+
+#include "mlx/array.h"
+#include "mlx/ops.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+
+namespace nanobind {
+static constexpr dlpack::dtype bfloat16{4, 16, 1};
+}; // namespace nanobind
+
+struct ArrayLike {
+  ArrayLike(nb::object obj) : obj(obj) {};
+  nb::object obj;
+};
+
+using ArrayInitType = std::variant<
+    nb::bool_,
+    nb::int_,
+    nb::float_,
+    // Must be above ndarray
+    mx::array,
+    // Must be above complex
+    nb::ndarray<nb::ro, nb::c_contig, nb::device::cpu>,
+    std::complex<float>,
+    nb::list,
+    nb::tuple,
+    ArrayLike>;
+
+mx::array nd_array_to_mlx(
+    nb::ndarray<nb::ro, nb::c_contig, nb::device::cpu> nd_array,
+    std::optional<mx::Dtype> dtype);
+
+nb::ndarray<nb::numpy> mlx_to_np_array(const mx::array& a);
+nb::ndarray<> mlx_to_dlpack(const mx::array& a);
+
+nb::object to_scalar(mx::array& a);
+
+nb::object tolist(mx::array& a);
+
+mx::array create_array(ArrayInitType v, std::optional<mx::Dtype> t);
+mx::array array_from_list(nb::list pl, std::optional<mx::Dtype> dtype);
+mx::array array_from_list(nb::tuple pl, std::optional<mx::Dtype> dtype);
diff --git a/ml-stable-diffusion/mlx/python/src/cuda.cpp b/ml-stable-diffusion/mlx/python/src/cuda.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..13b3a0154b31d98f176c7ad4def68f33bb032681
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/cuda.cpp
@@ -0,0 +1,19 @@
+// Copyright © 2023-2025 Apple Inc.
+
+#include <nanobind/nanobind.h>
+
+#include "mlx/backend/cuda/cuda.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+
+void init_cuda(nb::module_& m) {
+  nb::module_ cuda = m.def_submodule("cuda", "mlx.cuda");
+
+  cuda.def(
+      "is_available",
+      &mx::cu::is_available,
+      R"pbdoc(
+      Check if the CUDA back-end is available.
+      )pbdoc");
+}
diff --git a/ml-stable-diffusion/mlx/python/src/device.cpp b/ml-stable-diffusion/mlx/python/src/device.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..006a05dc0c6c51fedb5f855fe0e3307057f31d5e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/device.cpp
@@ -0,0 +1,66 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <sstream>
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/string.h>
+
+#include "mlx/device.h"
+#include "mlx/utils.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+void init_device(nb::module_& m) {
+  auto device_class = nb::class_<mx::Device>(
+      m, "Device", R"pbdoc(A device to run operations on.)pbdoc");
+  nb::enum_<mx::Device::DeviceType>(m, "DeviceType")
+      .value("cpu", mx::Device::DeviceType::cpu)
+      .value("gpu", mx::Device::DeviceType::gpu)
+      .export_values()
+      .def(
+          "__eq__",
+          [](const mx::Device::DeviceType& d, const nb::object& other) {
+            if (!nb::isinstance<mx::Device>(other) &&
+                !nb::isinstance<mx::Device::DeviceType>(other)) {
+              return false;
+            }
+            return d == nb::cast<mx::Device>(other);
+          });
+
+  device_class
+      .def(nb::init<mx::Device::DeviceType, int>(), "type"_a, "index"_a = 0)
+      .def_ro("type", &mx::Device::type)
+      .def(
+          "__repr__",
+          [](const mx::Device& d) {
+            std::ostringstream os;
+            os << d;
+            return os.str();
+          })
+      .def("__eq__", [](const mx::Device& d, const nb::object& other) {
+        if (!nb::isinstance<mx::Device>(other) &&
+            !nb::isinstance<mx::Device::DeviceType>(other)) {
+          return false;
+        }
+        return d == nb::cast<mx::Device>(other);
+      });
+
+  nb::implicitly_convertible<mx::Device::DeviceType, mx::Device>();
+
+  m.def(
+      "default_device",
+      &mx::default_device,
+      R"pbdoc(Get the default device.)pbdoc");
+  m.def(
+      "set_default_device",
+      &mx::set_default_device,
+      "device"_a,
+      R"pbdoc(Set the default device.)pbdoc");
+  m.def(
+      "is_available",
+      &mx::is_available,
+      "device"_a,
+      R"pbdoc(Check if a back-end is available for the given device.)pbdoc");
+}
diff --git a/ml-stable-diffusion/mlx/python/src/distributed.cpp b/ml-stable-diffusion/mlx/python/src/distributed.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e2e191dbbd2d332517a9908e0e6ba67290ea83f2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/distributed.cpp
@@ -0,0 +1,304 @@
+// Copyright  © 2024 Apple Inc.
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/shared_ptr.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/variant.h>
+#include <nanobind/stl/vector.h>
+
+#include "mlx/distributed/distributed.h"
+#include "mlx/distributed/ops.h"
+#include "python/src/small_vector.h"
+#include "python/src/utils.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+void init_distributed(nb::module_& parent_module) {
+  auto m = parent_module.def_submodule(
+      "distributed", "mlx.core.distributed: Communication operations");
+
+  nb::class_<mx::distributed::Group>(
+      m,
+      "Group",
+      R"pbcopy(
+        An :class:`mlx.core.distributed.Group` represents a group of independent mlx
+        processes that can communicate.
+      )pbcopy")
+      .def(
+          "rank", &mx::distributed::Group::rank, "Get the rank of this process")
+      .def("size", &mx::distributed::Group::size, "Get the size of the group")
+      .def(
+          "split",
+          &mx::distributed::Group::split,
+          "color"_a,
+          "key"_a = -1,
+          nb::sig("def split(self, color: int, key: int = -1) -> Group"),
+          R"pbdoc(
+            Split the group to subgroups based on the provided color.
+
+            Processes that use the same color go to the same group. The ``key``
+            argument defines the rank in the new group. The smaller the key the
+            smaller the rank. If the key is negative then the rank in the
+            current group is used.
+
+            Args:
+              color (int): A value to group processes into subgroups.
+              key (int, optional): A key to optionally change the rank ordering
+                of the processes.
+          )pbdoc");
+
+  m.def(
+      "is_available",
+      &mx::distributed::is_available,
+      R"pbdoc(
+      Check if a communication backend is available.
+      )pbdoc");
+
+  m.def(
+      "init",
+      &mx::distributed::init,
+      "strict"_a = false,
+      "backend"_a = "any",
+      nb::sig("def init(strict: bool = False, backend: str = 'any') -> Group"),
+      R"pbdoc(
+        Initialize the communication backend and create the global communication group.
+
+        Example:
+
+          .. code:: python
+
+            import mlx.core as mx
+
+            group = mx.distributed.init(backend="ring")
+
+        Args:
+          strict (bool, optional): If set to False it returns a singleton group
+            in case ``mx.distributed.is_available()`` returns False otherwise
+            it throws a runtime error. Default: ``False``
+          backend (str, optional): Which distributed backend to initialize.
+            Possible values ``mpi``, ``ring``, ``nccl``, ``any``. If set to ``any`` all
+            available backends are tried and the first one that succeeds
+            becomes the global group which will be returned in subsequent
+            calls. Default: ``any``
+
+        Returns:
+          Group: The group representing all the launched processes.
+      )pbdoc");
+
+  m.def(
+      "all_sum",
+      [](const ScalarOrArray& x,
+         std::optional<mx::distributed::Group> group,
+         mx::StreamOrDevice s) {
+        return mx::distributed::all_sum(to_array(x), group, s);
+      },
+      "x"_a,
+      nb::kw_only(),
+      "group"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def all_sum(x: array, *, group: Optional[Group] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        All reduce sum.
+
+        Sum the ``x`` arrays from all processes in the group.
+
+        Args:
+          x (array): Input array.
+          group (Group): The group of processes that will participate in the
+            reduction. If set to ``None`` the global group is used. Default:
+            ``None``.
+          stream (Stream, optional): Stream or device. Defaults to ``None``
+            in which case the default stream of the default device is used.
+
+        Returns:
+          array: The sum of all ``x`` arrays.
+      )pbdoc");
+  m.def(
+      "all_max",
+      [](const ScalarOrArray& x,
+         std::optional<mx::distributed::Group> group,
+         mx::StreamOrDevice s) {
+        return mx::distributed::all_max(to_array(x), group, s);
+      },
+      "x"_a,
+      nb::kw_only(),
+      "group"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def all_max(x: array, *, group: Optional[Group] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        All reduce max.
+
+        Find the maximum of the ``x`` arrays from all processes in the group.
+
+        Args:
+          x (array): Input array.
+          group (Group): The group of processes that will participate in the
+            reduction. If set to ``None`` the global group is used. Default:
+            ``None``.
+          stream (Stream, optional): Stream or device. Defaults to ``None``
+            in which case the default stream of the default device is used.
+
+        Returns:
+          array: The maximum of all ``x`` arrays.
+      )pbdoc");
+  m.def(
+      "all_min",
+      [](const ScalarOrArray& x,
+         std::optional<mx::distributed::Group> group,
+         mx::StreamOrDevice s) {
+        return mx::distributed::all_min(to_array(x), group, s);
+      },
+      "x"_a,
+      nb::kw_only(),
+      "group"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def all_min(x: array, *, group: Optional[Group] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+      All reduce min.
+
+      Find the minimum of the ``x`` arrays from all processes in the group.
+
+      Args:
+        x (array): Input array.
+        group (Group): The group of processes that will participate in the
+          reduction. If set to ``None`` the global group is used. Default:
+          ``None``.
+        stream (Stream, optional): Stream or device. Defaults to ``None``
+          in which case the default stream of the default device is used.
+
+      Returns:
+        array: The minimum of all ``x`` arrays.
+    )pbdoc");
+  m.def(
+      "all_gather",
+      [](const ScalarOrArray& x,
+         std::optional<mx::distributed::Group> group,
+         mx::StreamOrDevice s) {
+        return mx::distributed::all_gather(to_array(x), group, s);
+      },
+      "x"_a,
+      nb::kw_only(),
+      "group"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def all_gather(x: array, *, group: Optional[Group] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Gather arrays from all processes.
+
+        Gather the ``x`` arrays from all processes in the group and concatenate
+        them along the first axis. The arrays should all have the same shape.
+
+        Args:
+          x (array): Input array.
+          group (Group): The group of processes that will participate in the
+            gather. If set to ``None`` the global group is used. Default:
+            ``None``.
+          stream (Stream, optional): Stream or device. Defaults to ``None``
+            in which case the default stream of the default device is used.
+
+        Returns:
+          array: The concatenation of all ``x`` arrays.
+      )pbdoc");
+
+  m.def(
+      "send",
+      [](const ScalarOrArray& x,
+         int dst,
+         std::optional<mx::distributed::Group> group,
+         mx::StreamOrDevice s) {
+        return mx::distributed::send(to_array(x), dst, group, s);
+      },
+      "x"_a,
+      "dst"_a,
+      nb::kw_only(),
+      "group"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def send(x: array, dst: int, *, group: Optional[Group] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Send an array from the current process to the process that has rank
+        ``dst`` in the group.
+
+        Args:
+          x (array): Input array.
+          dst (int): Rank of the destination process in the group.
+          group (Group): The group of processes that will participate in the
+            sned. If set to ``None`` the global group is used. Default:
+            ``None``.
+          stream (Stream, optional): Stream or device. Defaults to ``None``
+            in which case the default stream of the default device is used.
+
+        Returns:
+          array: An array identical to ``x`` which when evaluated the send is performed.
+      )pbdoc");
+
+  m.def(
+      "recv",
+      &mx::distributed::recv,
+      "shape"_a,
+      "dtype"_a,
+      "src"_a,
+      nb::kw_only(),
+      "group"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def recv(shape: Sequence[int], dtype: Dtype, src: int, *, group: Optional[Group] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Recv an array with shape ``shape`` and dtype ``dtype`` from process
+        with rank ``src``.
+
+        Args:
+          shape (Tuple[int]): The shape of the array we are receiving.
+          dtype (Dtype): The data type of the array we are receiving.
+          src (int): Rank of the source process in the group.
+          group (Group): The group of processes that will participate in the
+            recv. If set to ``None`` the global group is used. Default:
+            ``None``.
+          stream (Stream, optional): Stream or device. Defaults to ``None``
+            in which case the default stream of the default device is used.
+
+        Returns:
+          array: The array that was received from ``src``.
+      )pbdoc");
+
+  m.def(
+      "recv_like",
+      [](const ScalarOrArray& x,
+         int src,
+         std::optional<mx::distributed::Group> group,
+         mx::StreamOrDevice s) {
+        return mx::distributed::recv_like(to_array(x), src, group, s);
+      },
+      "x"_a,
+      "src"_a,
+      nb::kw_only(),
+      "group"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def recv_like(x: array, src: int, *, group: Optional[Group] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Recv an array with shape and type like ``x`` from process with rank
+        ``src``.
+
+        It is equivalent to calling ``mx.distributed.recv(x.shape, x.dtype, src)``.
+
+        Args:
+          x (array): An array defining the shape and dtype of the array we are
+            receiving.
+          src (int): Rank of the source process in the group.
+          group (Group): The group of processes that will participate in the
+            recv. If set to ``None`` the global group is used. Default:
+            ``None``.
+          stream (Stream, optional): Stream or device. Defaults to ``None``
+            in which case the default stream of the default device is used.
+
+        Returns:
+          array: The array that was received from ``src``.
+      )pbdoc");
+}
diff --git a/ml-stable-diffusion/mlx/python/src/export.cpp b/ml-stable-diffusion/mlx/python/src/export.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4428e7cc81b82f5a07b42c6f661c5340f8fced87
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/export.cpp
@@ -0,0 +1,338 @@
+// Copyright © 2024 Apple Inc.
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/unordered_map.h>
+#include <nanobind/stl/vector.h>
+
+#include <fstream>
+
+#include "mlx/array.h"
+#include "mlx/export.h"
+#include "mlx/graph_utils.h"
+#include "python/src/small_vector.h"
+#include "python/src/trees.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+std::pair<mx::Args, mx::Kwargs> validate_and_extract_inputs(
+    const nb::args& args,
+    const nb::kwargs& kwargs,
+    const std::string& prefix) {
+  auto maybe_throw = [&prefix](bool valid) {
+    if (!valid) {
+      throw std::invalid_argument(
+          prefix +
+          " Inputs can either be a variable "
+          "number of positional and keyword arrays or a single tuple "
+          "and/or dictionary of arrays.");
+    }
+  };
+  mx::Args args_;
+  mx::Kwargs kwargs_;
+  if (args.size() == 0) {
+    // No args so kwargs must be keyword arrays
+    maybe_throw(nb::try_cast(kwargs, kwargs_));
+  } else if (args.size() > 0 && nb::isinstance<mx::array>(args[0])) {
+    // Args are positional arrays and kwargs are keyword arrays
+    maybe_throw(nb::try_cast(args, args_));
+    maybe_throw(nb::try_cast(kwargs, kwargs_));
+  } else if (args.size() == 1) {
+    // - args[0] can be a tuple or list or arrays or a dict
+    //   with string keys and array values
+    // - kwargs should be empty
+    maybe_throw(kwargs.size() == 0);
+    if (!nb::try_cast(args[0], args_)) {
+      maybe_throw(nb::try_cast(args[0], kwargs_));
+    }
+  } else if (args.size() == 2) {
+    // - args[0] can be a tuple or list of arrays
+    // - args[1] can be a dict of string keys with array values.
+    // - kwargs should be empty
+    maybe_throw(kwargs.size() == 0);
+    maybe_throw(nb::try_cast(args[0], args_));
+    maybe_throw(nb::try_cast(args[1], kwargs_));
+  } else {
+    maybe_throw(false);
+  }
+  return {args_, kwargs_};
+}
+
+int py_function_exporter_tp_traverse(
+    PyObject* self,
+    visitproc visit,
+    void* arg);
+
+class PyFunctionExporter {
+ public:
+  PyFunctionExporter(mx::FunctionExporter exporter, nb::handle dep)
+      : exporter_(std::move(exporter)), dep_(dep) {}
+  ~PyFunctionExporter() {
+    nb::gil_scoped_acquire gil;
+  }
+  PyFunctionExporter(const PyFunctionExporter&) = delete;
+  PyFunctionExporter& operator=(const PyFunctionExporter&) = delete;
+  PyFunctionExporter& operator=(const PyFunctionExporter&&) = delete;
+  PyFunctionExporter(PyFunctionExporter&& other)
+      : exporter_(std::move(other.exporter_)), dep_(std::move(other.dep_)) {}
+
+  void close() {
+    exporter_.close();
+  }
+  void operator()(const mx::Args& args, const mx::Kwargs& kwargs) {
+    exporter_(args, kwargs);
+  }
+
+  friend int py_function_exporter_tp_traverse(PyObject*, visitproc, void*);
+
+ private:
+  mx::FunctionExporter exporter_;
+  nb::handle dep_;
+};
+
+int py_function_exporter_tp_traverse(
+    PyObject* self,
+    visitproc visit,
+    void* arg) {
+  Py_VISIT(Py_TYPE(self));
+  if (!nb::inst_ready(self)) {
+    return 0;
+  }
+  auto* p = nb::inst_ptr<PyFunctionExporter>(self);
+  Py_VISIT(p->dep_.ptr());
+  return 0;
+}
+
+PyType_Slot py_function_exporter_slots[] = {
+    {Py_tp_traverse, (void*)py_function_exporter_tp_traverse},
+    {0, 0}};
+
+auto wrap_export_function(nb::callable fun) {
+  return
+      [fun = std::move(fun)](const mx::Args& args_, const mx::Kwargs& kwargs_) {
+        auto kwargs = nb::dict();
+        kwargs.update(nb::cast(kwargs_));
+        auto args = nb::tuple(nb::cast(args_));
+        auto outputs = fun(*args, **kwargs);
+        std::vector<mx::array> outputs_;
+        if (nb::isinstance<mx::array>(outputs)) {
+          outputs_.push_back(nb::cast<mx::array>(outputs));
+        } else if (!nb::try_cast(outputs, outputs_)) {
+          throw std::invalid_argument(
+              "[export_function] Outputs can be either a single array "
+              "a tuple or list of arrays.");
+        }
+        return outputs_;
+      };
+}
+
+void init_export(nb::module_& m) {
+  m.def(
+      "export_function",
+      [](const std::string& file,
+         const nb::callable& fun,
+         const nb::args& args,
+         bool shapeless,
+         const nb::kwargs& kwargs) {
+        auto [args_, kwargs_] =
+            validate_and_extract_inputs(args, kwargs, "[export_function]");
+        mx::export_function(
+            file, wrap_export_function(fun), args_, kwargs_, shapeless);
+      },
+      "file"_a,
+      "fun"_a,
+      "args"_a,
+      nb::kw_only(),
+      "shapeless"_a = false,
+      "kwargs"_a,
+      R"pbdoc(
+        Export a function to a file.
+
+        Example input arrays must be provided to export a function. The example
+        inputs can be variable ``*args`` and ``**kwargs`` or a tuple of arrays
+        and/or dictionary of string keys with array values.
+
+        .. warning::
+
+          This is part of an experimental API which is likely to
+          change in future versions of MLX. Functions exported with older
+          versions of MLX may not be compatible with future versions.
+
+        Args:
+            file (str): File path to export the function to.
+            fun (Callable): A function which takes as input zero or more
+              :class:`array` and returns one or more :class:`array`.
+            *args (array): Example array inputs to the function.
+            shapeless (bool, optional): Whether or not the function allows
+              inputs with variable shapes. Default: ``False``.
+            **kwargs (array): Additional example keyword array inputs to the
+              function.
+
+        Example:
+
+          .. code-block:: python
+
+            def fun(x, y):
+                return x + y
+
+            x = mx.array(1)
+            y = mx.array([1, 2, 3])
+            mx.export_function("fun.mlxfn", fun, x, y=y)
+      )pbdoc");
+  m.def(
+      "import_function",
+      [](const std::string& file) {
+        return nb::cpp_function(
+            [fn = mx::import_function(file)](
+                const nb::args& args, const nb::kwargs& kwargs) {
+              auto [args_, kwargs_] = validate_and_extract_inputs(
+                  args, kwargs, "[import_function::call]");
+              return nb::tuple(nb::cast(fn(args_, kwargs_)));
+            });
+      },
+      "file"_a,
+      nb::sig("def import_function(file: str) -> Callable"),
+      R"pbdoc(
+        Import a function from a file.
+
+        The imported function can be called either with ``*args`` and
+        ``**kwargs`` or with a tuple of arrays and/or dictionary of string
+        keys with array values. Imported functions always return a tuple of
+        arrays.
+
+        .. warning::
+
+          This is part of an experimental API which is likely to
+          change in future versions of MLX. Functions exported with older
+          versions of MLX may not be compatible with future versions.
+
+        Args:
+            file (str): The file path to import the function from.
+
+        Returns:
+            Callable: The imported function.
+
+        Example:
+          >>> fn = mx.import_function("function.mlxfn")
+          >>> out = fn(a, b, x=x, y=y)[0]
+          >>>
+          >>> out = fn((a, b), {"x": x, "y": y}[0]
+      )pbdoc");
+
+  nb::class_<PyFunctionExporter>(
+      m,
+      "FunctionExporter",
+      nb::type_slots(py_function_exporter_slots),
+      R"pbdoc(
+       A context managing class for exporting multiple traces of the same
+       function to a file.
+
+       Make an instance of this class by calling fun:`mx.exporter`.
+      )pbdoc")
+      .def("close", &PyFunctionExporter::close)
+      .def("__enter__", [](PyFunctionExporter& exporter) { return &exporter; })
+      .def(
+          "__exit__",
+          [](PyFunctionExporter& exporter,
+             const std::optional<nb::object>&,
+             const std::optional<nb::object>&,
+             const std::optional<nb::object>&) { exporter.close(); },
+          "exc_type"_a = nb::none(),
+          "exc_value"_a = nb::none(),
+          "traceback"_a = nb::none())
+      .def(
+          "__call__",
+          [](PyFunctionExporter& exporter,
+             const nb::args& args,
+             const nb::kwargs& kwargs) {
+            auto [args_, kwargs_] =
+                validate_and_extract_inputs(args, kwargs, "[export_function]");
+            exporter(args_, kwargs_);
+          });
+
+  m.def(
+      "exporter",
+      [](const std::string& file, nb::callable fun, bool shapeless) {
+        return PyFunctionExporter{
+            mx::exporter(file, wrap_export_function(fun), shapeless), fun};
+      },
+      "file"_a,
+      "fun"_a,
+      nb::kw_only(),
+      "shapeless"_a = false,
+      R"pbdoc(
+        Make a callable object to export multiple traces of a function to a file.
+
+        .. warning::
+
+          This is part of an experimental API which is likely to
+          change in future versions of MLX. Functions exported with older
+          versions of MLX may not be compatible with future versions.
+
+        Args:
+            file (str): File path to export the function to.
+            shapeless (bool, optional): Whether or not the function allows
+              inputs with variable shapes. Default: ``False``.
+
+        Example:
+
+          .. code-block:: python
+
+            def fun(*args):
+                return sum(args)
+
+            with mx.exporter("fun.mlxfn", fun) as exporter:
+                exporter(mx.array(1))
+                exporter(mx.array(1), mx.array(2))
+                exporter(mx.array(1), mx.array(2), mx.array(3))
+      )pbdoc");
+  m.def(
+      "export_to_dot",
+      [](nb::object file, const nb::args& args, const nb::kwargs& kwargs) {
+        std::vector<mx::array> arrays =
+            tree_flatten(nb::make_tuple(args, kwargs));
+        mx::NodeNamer namer;
+        for (const auto& n : kwargs) {
+          namer.set_name(
+              nb::cast<mx::array>(n.second), nb::cast<std::string>(n.first));
+        }
+        if (nb::isinstance<nb::str>(file)) {
+          std::ofstream out(nb::cast<std::string>(file));
+          mx::export_to_dot(out, std::move(namer), arrays);
+        } else if (nb::hasattr(file, "write")) {
+          std::ostringstream out;
+          mx::export_to_dot(out, std::move(namer), arrays);
+          auto write = file.attr("write");
+          write(out.str());
+        } else {
+          throw std::invalid_argument(
+              "[export_to_dot] Accepts file-like objects or strings "
+              "to be used as filenames.");
+        }
+      },
+      "file"_a,
+      "args"_a,
+      "kwargs"_a,
+      R"pbdoc(
+        Export a graph to DOT format for visualization.
+
+        A variable number of output arrays can be provided for exporting
+        The graph exported will recursively include all unevaluated inputs of
+        the provided outputs.
+
+        Args:
+            file (str): The file path to export to.
+            *args (array): The output arrays.
+            **kwargs (dict[str, array]): Provide some names for arrays in the
+              graph to make the result easier to parse.
+
+        Example:
+          >>> a = mx.array(1) + mx.array(2)
+          >>> mx.export_to_dot("graph.dot", a)
+          >>> x = mx.array(1)
+          >>> y = mx.array(2)
+          >>> mx.export_to_dot("graph.dot", x + y, x=x, y=y)
+      )pbdoc");
+}
diff --git a/ml-stable-diffusion/mlx/python/src/fast.cpp b/ml-stable-diffusion/mlx/python/src/fast.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0ed1aa6984b60030774aa2198a57fe9f48bdcd8d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/fast.cpp
@@ -0,0 +1,625 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/pair.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>
+#include <nanobind/stl/variant.h>
+#include <nanobind/stl/vector.h>
+
+#include "mlx/fast.h"
+#include "mlx/ops.h"
+#include "python/src/small_vector.h"
+#include "python/src/utils.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace {
+
+struct PyCustomKernelFunction {
+  PyCustomKernelFunction(mx::fast::CustomKernelFunction kernel, const char* tag)
+      : kernel_(std::move(kernel)), tag_(tag) {}
+
+  std::vector<mx::array> operator()(
+      const std::vector<ScalarOrArray>& inputs_,
+      const std::vector<mx::Shape>& output_shapes,
+      const std::vector<mx::Dtype>& output_dtypes,
+      std::tuple<int, int, int> grid,
+      std::tuple<int, int, int> threadgroup,
+      const std::optional<std::vector<std::pair<std::string, nb::object>>>&
+          template_args_ = std::nullopt,
+      std::optional<float> init_value = std::nullopt,
+      bool verbose = false,
+      mx::StreamOrDevice s = {}) const {
+    std::vector<mx::array> inputs;
+    for (const auto& value : inputs_) {
+      inputs.push_back(to_array(value, std::nullopt));
+    }
+    std::vector<std::pair<std::string, mx::fast::TemplateArg>> template_args;
+    if (template_args_) {
+      for (const auto& [name, value] : template_args_.value()) {
+        // Handle bool, int and dtype template args
+        if (nb::isinstance<bool>(value)) {
+          bool bool_val = nb::cast<bool>(value);
+          template_args.emplace_back(name, bool_val);
+        } else if (nb::isinstance<int>(value)) {
+          int int_val = nb::cast<int>(value);
+          template_args.emplace_back(name, int_val);
+        } else if (nb::isinstance<mx::Dtype>(value)) {
+          mx::Dtype dtype = nb::cast<mx::Dtype>(value);
+          template_args.emplace_back(name, dtype);
+        } else {
+          std::ostringstream msg;
+          msg << tag_
+              << " Invalid template argument. Must be `mlx.core.Dtype`, `int` or `bool`.";
+          throw std::invalid_argument(msg.str());
+        }
+      }
+    }
+    return kernel_(
+        inputs,
+        output_shapes,
+        output_dtypes,
+        grid,
+        threadgroup,
+        template_args,
+        init_value,
+        verbose,
+        s);
+  }
+
+  mx::fast::CustomKernelFunction kernel_;
+  const char* tag_;
+};
+
+} // namespace
+
+void init_fast(nb::module_& parent_module) {
+  auto m =
+      parent_module.def_submodule("fast", "mlx.core.fast: fast operations");
+
+  m.def(
+      "rms_norm",
+      &mx::fast::rms_norm,
+      "x"_a,
+      "weight"_a.none(),
+      "eps"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def rms_norm(x: array, weight: Optional[array], eps: float, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Root Mean Square normalization (RMS norm).
+
+        The normalization is with respect to the last axis of the input ``x``.
+
+        Args:
+            x (array): Input array.
+            weight (array, optional): A multiplicative weight to scale the result by.
+              The ``weight`` should be one-dimensional with the same size
+              as the last axis of ``x``. If set to ``None`` then no scaling happens.
+            eps (float): A small additive constant for numerical stability.
+
+        Returns:
+            array: The output array.
+      )pbdoc");
+
+  m.def(
+      "layer_norm",
+      &mx::fast::layer_norm,
+      "x"_a,
+      "weight"_a.none(),
+      "bias"_a.none(),
+      "eps"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def layer_norm(x: array, weight: Optional[array], bias: Optional[array], eps: float, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Layer normalization.
+
+        The normalization is with respect to the last axis of the input ``x``.
+
+        Args:
+            x (array): Input array.
+            weight (array, optional): A multiplicative weight to scale the result by.
+              The ``weight`` should be one-dimensional with the same size
+              as the last axis of ``x``. If set to ``None`` then no scaling happens.
+            bias (array, optional): An additive offset to be added to the result.
+              The ``bias`` should be one-dimensional with the same size
+              as the last axis of ``x``. If set to ``None`` then no translation happens.
+            eps (float): A small additive constant for numerical stability.
+
+        Returns:
+            array: The output array.
+      )pbdoc");
+
+  m.def(
+      "rope",
+      [](const mx::array& a,
+         int dims,
+         bool traditional,
+         std::optional<float> base,
+         float scale,
+         const ScalarOrArray& offset,
+         const std::optional<mx::array>& freqs /* = std::nullopt */,
+         mx::StreamOrDevice s /* = {} */) {
+        return mx::fast::rope(
+            a, dims, traditional, base, scale, to_array(offset), freqs, s);
+      },
+      "a"_a,
+      "dims"_a,
+      nb::kw_only(),
+      "traditional"_a,
+      "base"_a.none(),
+      "scale"_a,
+      "offset"_a,
+      "freqs"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def rope(a: array, dims: int, *, traditional: bool, base: Optional[float], scale: float, offset: Union[int, array], freqs: Optional[array] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Apply rotary positional encoding to the input.
+
+        The input is expected to be at least 3D with shape ``(B, *, T, D)`` where:
+          * ``B`` is the batch size.
+          * ``T`` is the sequence length.
+          * ``D`` is the feature dimension.
+
+        Args:
+            a (array): The input array.
+            dims (int): The feature dimensions to be rotated. If the input feature
+              is larger than dims then the rest is left unchanged.
+            traditional (bool): If set to ``True`` choose the traditional
+              implementation which rotates consecutive dimensions.
+            base (float, optional): The base used to compute angular frequency for
+              each dimension in the positional encodings. Exactly one of ``base`` and
+              ``freqs`` must be ``None``.
+            scale (float): The scale used to scale the positions.
+            offset (int or array): The position offset to start at. If an
+              :obj:`array` is given it can be a scalar or vector of ``B``
+              offsets for each example in the batch.
+            freqs (array, optional): Optional frequencies to use with RoPE.
+              If set, the ``base`` parameter must be ``None``. Default: ``None``.
+
+        Returns:
+            array: The output array.
+      )pbdoc");
+
+  m.def(
+      "scaled_dot_product_attention",
+      [](const mx::array& queries,
+         const mx::array& keys,
+         const mx::array& values,
+         const float scale,
+         const std::variant<std::monostate, std::string, mx::array>& mask,
+         const std::optional<mx::array>& sinks,
+         mx::StreamOrDevice s) {
+        bool has_mask = !std::holds_alternative<std::monostate>(mask);
+        bool has_str_mask =
+            has_mask && std::holds_alternative<std::string>(mask);
+        bool has_arr_mask = has_mask && std::holds_alternative<mx::array>(mask);
+
+        if (has_mask) {
+          if (has_str_mask) {
+            auto mask_str = std::get<std::string>(mask);
+            if (mask_str != "causal") {
+              std::ostringstream msg;
+              msg << "[scaled_dot_product_attention] invalid mask option '"
+                  << mask_str << "'. Must be 'causal', or an array.";
+              throw std::invalid_argument(msg.str());
+            }
+            return mx::fast::scaled_dot_product_attention(
+                queries, keys, values, scale, mask_str, {}, sinks, s);
+          } else {
+            auto mask_arr = std::get<mx::array>(mask);
+            return mx::fast::scaled_dot_product_attention(
+                queries, keys, values, scale, "", {mask_arr}, sinks, s);
+          }
+
+        } else {
+          return mx::fast::scaled_dot_product_attention(
+              queries, keys, values, scale, "", {}, sinks, s);
+        }
+      },
+      "q"_a,
+      "k"_a,
+      "v"_a,
+      nb::kw_only(),
+      "scale"_a,
+      "mask"_a = nb::none(),
+      "sinks"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def scaled_dot_product_attention(q: array, k: array, v: array, *, scale: float,  mask: Union[None, str, array] = None, sinks: Optional[array] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        A fast implementation of multi-head attention: ``O = softmax(Q @ K.T, dim=-1) @ V``.
+
+        Supports:
+
+        * `Multi-Head Attention <https://arxiv.org/abs/1706.03762>`_
+        * `Grouped Query Attention <https://arxiv.org/abs/2305.13245>`_
+        * `Multi-Query Attention <https://arxiv.org/abs/1911.02150>`_
+
+        .. note::
+
+          * The softmax operation is performed in ``float32`` regardless of
+            the input precision.
+          * For Grouped Query Attention and Multi-Query Attention, the ``k``
+            and ``v`` inputs should not be pre-tiled to match ``q``.
+
+        In the following the dimensions are given by:
+
+        * ``B``: The batch size.
+        * ``N_q``: The number of query heads.
+        * ``N_kv``: The number of key and value heads.
+        * ``T_q``: The number of queries per example.
+        * ``T_kv``: The number of keys and values per example.
+        * ``D``: The per-head dimension.
+
+        Args:
+            q (array): Queries with shape ``[B, N_q, T_q, D]``.
+            k (array): Keys with shape ``[B, N_kv, T_kv, D]``.
+            v (array): Values with shape ``[B, N_kv, T_kv, D]``.
+            scale (float): Scale for queries (typically ``1.0 / sqrt(q.shape(-1)``).
+            mask (str or array, optional): The mask to apply to the
+               query-key scores. The mask can be an array or a string indicating
+               the mask type. The only supported string type is ``"causal"``. If
+               the mask is an array it can be a boolean or additive mask. The mask
+               can have at most 4 dimensions and must be broadcast-compatible with
+               the shape ``[B, N, T_q, T_kv]``. If an additive mask is given its
+               type must promote to the promoted type of ``q``, ``k``, and ``v``.
+            sinks (array, optional): An optional array of attention sinks.
+               Default: ``None``.
+
+        Returns:
+            array: The output array.
+
+        Example:
+
+          .. code-block:: python
+
+            B = 2
+            N_q = N_kv = 32
+            T_q = T_kv = 1000
+            D = 128
+
+            q = mx.random.normal(shape=(B, N_q, T_q, D))
+            k = mx.random.normal(shape=(B, N_kv, T_kv, D))
+            v = mx.random.normal(shape=(B, N_kv, T_kv, D))
+            scale = D ** -0.5
+            out = mx.fast.scaled_dot_product_attention(q, k, v, scale=scale, mask="causal")
+      )pbdoc");
+
+  m.def(
+      "metal_kernel",
+      [](const std::string& name,
+         const std::vector<std::string>& input_names,
+         const std::vector<std::string>& output_names,
+         const std::string& source,
+         const std::string& header,
+         bool ensure_row_contiguous,
+         bool atomic_outputs) {
+        auto kernel = mx::fast::metal_kernel(
+            name,
+            input_names,
+            output_names,
+            source,
+            header,
+            ensure_row_contiguous,
+            atomic_outputs);
+        return nb::cpp_function(
+            PyCustomKernelFunction(std::move(kernel), "[metal_kernel]"),
+            nb::kw_only(),
+            "inputs"_a,
+            "output_shapes"_a,
+            "output_dtypes"_a,
+            "grid"_a,
+            "threadgroup"_a,
+            "template"_a = nb::none(),
+            "init_value"_a = nb::none(),
+            "verbose"_a = false,
+            "stream"_a = nb::none(),
+            nb::sig(
+                "def __call__(self, *, inputs: List[Union[scalar, array]], output_shapes: List[Sequence[int]], output_dtypes: List[Dtype], grid: tuple[int, int, int], threadgroup: tuple[int, int, int], template: Optional[List[Tuple[str, Union[bool, int, Dtype]]]] = None, init_value: Optional[float] = None, verbose: bool = false, stream: Union[None, Stream, Device] = None)"),
+            R"pbdoc(
+            Run the kernel.
+
+            Args:
+              inputs (List[array]): The inputs passed to the Metal kernel.
+              output_shapes (List[Sequence[int]]): The list of shapes for each output in ``output_names``.
+              output_dtypes (List[Dtype]): The list of data types for each output in ``output_names``.
+              grid (tuple[int, int, int]): 3-tuple specifying the grid to launch the kernel with.
+                This will be passed to ``MTLComputeCommandEncoder::dispatchThreads``.
+              threadgroup (tuple[int, int, int]): 3-tuple specifying the threadgroup size to use.
+                This will be passed to ``MTLComputeCommandEncoder::dispatchThreads``.
+              template (List[Tuple[str, Union[bool, int, Dtype]]], optional): Template arguments.
+                  These will be added as template arguments to the kernel definition. Default: ``None``.
+              init_value (float, optional): Optional value to use to initialize all of the output arrays.
+                  By default, output arrays are uninitialized. Default: ``None``.
+              verbose (bool, optional): Whether to print the full generated source code of the kernel
+                  when it is run. Default: ``False``.
+              stream (mx.stream, optional): Stream to run the kernel on. Default: ``None``.
+
+            Returns:
+              List[array]: The list of output arrays.)pbdoc");
+      },
+      "name"_a,
+      "input_names"_a,
+      "output_names"_a,
+      "source"_a,
+      "header"_a = "",
+      "ensure_row_contiguous"_a = true,
+      "atomic_outputs"_a = false,
+      R"pbdoc(
+      A jit-compiled custom Metal kernel defined from a source string.
+
+      Full documentation: :ref:`custom_metal_kernels`.
+
+      Args:
+        name (str): Name for the kernel.
+        input_names (List[str]): The parameter names of the inputs in the
+           function signature.
+        output_names (List[str]): The parameter names of the outputs in the
+           function signature.
+        source (str): Source code. This is the body of a function in Metal,
+           the function signature will be automatically generated.
+        header (str): Header source code to include before the main function.
+           Useful for helper functions or includes that should live outside of
+           the main function body.
+        ensure_row_contiguous (bool): Whether to ensure the inputs are row contiguous
+           before the kernel runs. Default: ``True``.
+        atomic_outputs (bool): Whether to use atomic outputs in the function signature
+           e.g. ``device atomic<float>``. Default: ``False``.
+
+      Returns:
+        Callable ``metal_kernel``.
+
+      Example:
+
+        .. code-block:: python
+
+          def exp_elementwise(a: mx.array):
+              source = '''
+                  uint elem = thread_position_in_grid.x;
+                  T tmp = inp[elem];
+                  out[elem] = metal::exp(tmp);
+              '''
+
+              kernel = mx.fast.metal_kernel(
+                  name="myexp",
+                  input_names=["inp"],
+                  output_names=["out"],
+                  source=source
+              )
+              outputs = kernel(
+                  inputs=[a],
+                  template=[("T", mx.float32)],
+                  grid=(a.size, 1, 1),
+                  threadgroup=(256, 1, 1),
+                  output_shapes=[a.shape],
+                  output_dtypes=[a.dtype],
+                  verbose=True,
+              )
+              return outputs[0]
+
+          a = mx.random.normal(shape=(4, 16)).astype(mx.float16)
+          b = exp_elementwise(a)
+          assert mx.allclose(b, mx.exp(a))
+     )pbdoc");
+
+  m.def(
+      "cuda_kernel",
+      [](const std::string& name,
+         const std::vector<std::string>& input_names,
+         const std::vector<std::string>& output_names,
+         const std::string& source,
+         const std::string& header,
+         bool ensure_row_contiguous,
+         int shared_mem) {
+        auto kernel = mx::fast::cuda_kernel(
+            name,
+            input_names,
+            output_names,
+            source,
+            header,
+            ensure_row_contiguous,
+            shared_mem);
+        return nb::cpp_function(
+            PyCustomKernelFunction(std::move(kernel), "[cuda_kernel]"),
+            nb::kw_only(),
+            "inputs"_a,
+            "output_shapes"_a,
+            "output_dtypes"_a,
+            "grid"_a,
+            "threadgroup"_a,
+            "template"_a = nb::none(),
+            "init_value"_a = nb::none(),
+            "verbose"_a = false,
+            "stream"_a = nb::none(),
+            nb::sig(
+                "def __call__(self, *, inputs: List[Union[scalar, array]], output_shapes: List[Sequence[int]], output_dtypes: List[Dtype], grid: tuple[int, int, int], threadgroup: tuple[int, int, int], template: Optional[List[Tuple[str, Union[bool, int, Dtype]]]] = None, init_value: Optional[float] = None, verbose: bool = false, stream: Union[None, Stream, Device] = None)"),
+            R"pbdoc(
+            Run the kernel.
+
+            Args:
+              inputs (List[array]): The inputs passed to the CUDA kernel.
+              output_shapes (List[Sequence[int]]): The list of shapes for each output in ``output_names``.
+              output_dtypes (List[Dtype]): The list of data types for each output in ``output_names``.
+              grid (tuple[int, int, int]): 3-tuple specifying the grid to launch the kernel with.
+                For compatibility with :func:`metal_kernel` the grid is in threads and not in threadgroups.
+              threadgroup (tuple[int, int, int]): 3-tuple specifying the threadgroup size to use.
+              template (List[Tuple[str, Union[bool, int, Dtype]]], optional): Template arguments.
+                  These will be added as template arguments to the kernel definition. Default: ``None``.
+              init_value (float, optional): Optional value to use to initialize all of the output arrays.
+                  By default, output arrays are uninitialized. Default: ``None``.
+              verbose (bool, optional): Whether to print the full generated source code of the kernel
+                  when it is run. Default: ``False``.
+              stream (mx.stream, optional): Stream to run the kernel on. Default: ``None``.
+
+            Returns:
+              List[array]: The list of output arrays.)pbdoc");
+      },
+      "name"_a,
+      "input_names"_a,
+      "output_names"_a,
+      "source"_a,
+      "header"_a = "",
+      "ensure_row_contiguous"_a = true,
+      "shared_memory"_a = 0,
+      R"pbdoc(
+      A jit-compiled custom CUDA kernel defined from a source string.
+
+      This is the CUDA equivalent of :ref:`custom_metal_kernels`.
+
+      Args:
+        name (str): Name for the kernel.
+        input_names (List[str]): The parameter names of the inputs in the
+           function signature.
+        output_names (List[str]): The parameter names of the outputs in the
+           function signature.
+        source (str): Source code. This is the body of a function in CUDA,
+           the function signature will be automatically generated.
+        header (str): Header source code to include before the main function.
+           Useful for helper functions or includes that should live outside of
+           the main function body.
+        ensure_row_contiguous (bool): Whether to ensure the inputs are row contiguous
+           before the kernel runs. Default: ``True``.
+        shared_memory (int): The dynamic shared memory to request for the
+          kernel. A value of 0 means no dynamic shared memory. Default: ``0``.
+
+      Returns:
+        Callable ``cuda_kernel``.
+
+      Example:
+
+        .. code-block:: python
+
+          def exp_elementwise(a: mx.array):
+              source = '''
+                  auto elem = cooperative_groups::this_grid().thread_rank();
+                  T tmp = inp[elem];
+                  out[elem] = exp(tmp);
+              '''
+
+              kernel = mx.fast.cuda_kernel(
+                  name="myexp",
+                  input_names=["inp"],
+                  output_names=["out"],
+                  source=source
+              )
+              outputs = kernel(
+                  inputs=[a],
+                  template=[("T", mx.float32)],
+                  grid=(a.size, 1, 1),
+                  threadgroup=(256, 1, 1),
+                  output_shapes=[a.shape],
+                  output_dtypes=[a.dtype],
+                  verbose=True,
+              )
+              return outputs[0]
+
+          a = mx.random.normal(shape=(16, 16)).astype(mx.float16)
+          b = exp_elementwise(a)
+          assert mx.allclose(b, mx.exp(a))
+     )pbdoc");
+
+  m.def(
+      "precompiled_cuda_kernel",
+      [](const std::string& name,
+         const nb::bytes compiled_source,
+         const std::vector<ScalarOrArray>& inputs_,
+         const std::vector<mx::Shape>& output_shapes,
+         const std::vector<mx::Dtype>& output_dtypes,
+         const std::vector<nb::object>& scalars_,
+         std::tuple<int, int, int> grid,
+         std::tuple<int, int, int> threadgroup,
+         int shared_memory,
+         std::optional<float> init_value = std::nullopt,
+         bool ensure_row_contiguous = false,
+         mx::StreamOrDevice s = {}) {
+        // Collect the inputs and cast them to array
+        std::vector<mx::array> inputs;
+        for (const auto& value : inputs_) {
+          inputs.push_back(to_array(value, std::nullopt));
+        }
+
+        // Collect the scalar inputs
+        std::vector<mx::fast::ScalarArg> scalars;
+        scalars.reserve(scalars_.size());
+        for (const auto& v : scalars_) {
+          if (nb::isinstance<bool>(v)) {
+            scalars.push_back(nb::cast<bool>(v));
+          } else if (nb::isinstance<int>(v)) {
+            scalars.push_back(nb::cast<int>(v));
+          } else if (nb::isinstance<float>(v)) {
+            scalars.push_back(nb::cast<float>(v));
+          } else {
+            nb::object vtype = v.attr("__class__");
+            std::string vtype_name =
+                nb::cast<std::string>(vtype.attr("__name__"));
+            std::ostringstream msg;
+            msg << "[precompiled_cuda_kernel] Invalid scalar argument type. "
+                << "Received " << vtype_name
+                << " but must be one of bool, int or float";
+            throw std::invalid_argument(msg.str());
+          }
+        }
+
+        return mx::fast::precompiled_cuda_kernel(
+            name,
+            std::string(
+                static_cast<const char*>(compiled_source.data()),
+                compiled_source.size()),
+            inputs,
+            output_shapes,
+            output_dtypes,
+            scalars,
+            grid,
+            threadgroup,
+            shared_memory,
+            init_value,
+            ensure_row_contiguous,
+            s);
+      },
+      nb::kw_only(),
+      "name"_a,
+      "compiled_source"_a,
+      "inputs"_a,
+      "output_shapes"_a,
+      "output_dtypes"_a,
+      "scalars"_a,
+      "grid"_a,
+      "threadgroup"_a,
+      "shared_memory"_a = 0,
+      "init_value"_a = nb::none(),
+      "ensure_row_contiguous"_a = false,
+      "stream"_a = nb::none(),
+      R"pbdoc(
+      Run a precompiled CUDA kernel defined from PTX or cubin.
+
+      This op is still experimental and various parts of the API may change.
+
+      Args:
+        name (str): Name for the kernel
+        compiled_source (bytes): The precompiled kernel in raw bytes.
+        inputs (List[array]): The inputs passed to the CUDA kernel.
+        output_shapes (List[Sequence[int]]): The list of shapes for each output.
+        output_dtypes (List[Dtype]): The list of data types for each output.
+        scalars (List[Union[bool, int, float]]): A list of scalar arguments to
+          pass to the kernel.
+        grid (tuple[int, int, int]): 3-tuple specifying the grid to launch the kernel with.
+          For compatibility with :func:`metal_kernel` the grid is in threads and not in threadblocks.
+        threadgroup (tuple[int, int, int]): 3-tuple specifying the threadgroup size to use.
+        shared_memory (int): The dynamic shared memory to request for the
+          kernel. A value of 0 means no dynamic shared memory. Default: ``0``.
+        init_value (float, optional): Optional value to use to initialize all of the output arrays.
+            By default, output arrays are uninitialized. Default: ``None``.
+        ensure_row_contiguous (bool): Whether to ensure the inputs are row contiguous
+           before the kernel runs. Default: ``False``.
+        stream (mx.stream, optional): Stream to run the kernel on. Default: ``None``.
+      )pbdoc");
+}
diff --git a/ml-stable-diffusion/mlx/python/src/fft.cpp b/ml-stable-diffusion/mlx/python/src/fft.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..522e1064c76146d6b65ff48f05669286440fcc2b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/fft.cpp
@@ -0,0 +1,514 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/variant.h>
+#include <nanobind/stl/vector.h>
+#include <numeric>
+
+#include "mlx/fft.h"
+#include "mlx/ops.h"
+#include "python/src/small_vector.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+void init_fft(nb::module_& parent_module) {
+  auto m = parent_module.def_submodule(
+      "fft", "mlx.core.fft: Fast Fourier Transforms.");
+  m.def(
+      "fft",
+      [](const mx::array& a,
+         const std::optional<int>& n,
+         int axis,
+         mx::StreamOrDevice s) {
+        if (n.has_value()) {
+          return mx::fft::fft(a, n.value(), axis, s);
+        } else {
+          return mx::fft::fft(a, axis, s);
+        }
+      },
+      "a"_a,
+      "n"_a = nb::none(),
+      "axis"_a = -1,
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        One dimensional discrete Fourier Transform.
+
+        Args:
+            a (array): The input array.
+            n (int, optional): Size of the transformed axis. The
+               corresponding axis in the input is truncated or padded with
+               zeros to match ``n``. The default value is ``a.shape[axis]``.
+            axis (int, optional): Axis along which to perform the FFT. The
+               default is ``-1``.
+
+        Returns:
+            array: The DFT of the input along the given axis.
+      )pbdoc");
+  m.def(
+      "ifft",
+      [](const mx::array& a,
+         const std::optional<int>& n,
+         int axis,
+         mx::StreamOrDevice s) {
+        if (n.has_value()) {
+          return mx::fft::ifft(a, n.value(), axis, s);
+        } else {
+          return mx::fft::ifft(a, axis, s);
+        }
+      },
+      "a"_a,
+      "n"_a = nb::none(),
+      "axis"_a = -1,
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        One dimensional inverse discrete Fourier Transform.
+
+        Args:
+            a (array): The input array.
+            n (int, optional): Size of the transformed axis. The
+               corresponding axis in the input is truncated or padded with
+               zeros to match ``n``. The default value is ``a.shape[axis]``.
+            axis (int, optional): Axis along which to perform the FFT. The
+               default is ``-1``.
+
+        Returns:
+            array: The inverse DFT of the input along the given axis.
+      )pbdoc");
+  m.def(
+      "fft2",
+      [](const mx::array& a,
+         const std::optional<mx::Shape>& n,
+         const std::optional<std::vector<int>>& axes,
+         mx::StreamOrDevice s) {
+        if (axes.has_value() && n.has_value()) {
+          return mx::fft::fftn(a, n.value(), axes.value(), s);
+        } else if (axes.has_value()) {
+          return mx::fft::fftn(a, axes.value(), s);
+        } else if (n.has_value()) {
+          throw std::invalid_argument(
+              "[fft2] `axes` should not be `None` if `s` is not `None`.");
+        } else {
+          return mx::fft::fftn(a, s);
+        }
+      },
+      "a"_a,
+      "s"_a = nb::none(),
+      "axes"_a.none() = std::vector<int>{-2, -1},
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        Two dimensional discrete Fourier Transform.
+
+        Args:
+            a (array): The input array.
+            s (list(int), optional): Sizes of the transformed axes. The
+               corresponding axes in the input are truncated or padded with
+               zeros to match the sizes in ``s``. The default value is the
+               sizes of ``a`` along ``axes``.
+            axes (list(int), optional): Axes along which to perform the FFT.
+               The default is ``[-2, -1]``.
+
+        Returns:
+            array: The DFT of the input along the given axes.
+      )pbdoc");
+  m.def(
+      "ifft2",
+      [](const mx::array& a,
+         const std::optional<mx::Shape>& n,
+         const std::optional<std::vector<int>>& axes,
+         mx::StreamOrDevice s) {
+        if (axes.has_value() && n.has_value()) {
+          return mx::fft::ifftn(a, n.value(), axes.value(), s);
+        } else if (axes.has_value()) {
+          return mx::fft::ifftn(a, axes.value(), s);
+        } else if (n.has_value()) {
+          throw std::invalid_argument(
+              "[ifft2] `axes` should not be `None` if `s` is not `None`.");
+        } else {
+          return mx::fft::ifftn(a, s);
+        }
+      },
+      "a"_a,
+      "s"_a = nb::none(),
+      "axes"_a.none() = std::vector<int>{-2, -1},
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        Two dimensional inverse discrete Fourier Transform.
+
+        Args:
+            a (array): The input array.
+            s (list(int), optional): Sizes of the transformed axes. The
+               corresponding axes in the input are truncated or padded with
+               zeros to match the sizes in ``s``. The default value is the
+               sizes of ``a`` along ``axes``.
+            axes (list(int), optional): Axes along which to perform the FFT.
+               The default is ``[-2, -1]``.
+
+        Returns:
+            array: The inverse DFT of the input along the given axes.
+      )pbdoc");
+  m.def(
+      "fftn",
+      [](const mx::array& a,
+         const std::optional<mx::Shape>& n,
+         const std::optional<std::vector<int>>& axes,
+         mx::StreamOrDevice s) {
+        if (axes.has_value() && n.has_value()) {
+          return mx::fft::fftn(a, n.value(), axes.value(), s);
+        } else if (axes.has_value()) {
+          return mx::fft::fftn(a, axes.value(), s);
+        } else if (n.has_value()) {
+          throw std::invalid_argument(
+              "[fftn] `axes` should not be `None` if `s` is not `None`.");
+        } else {
+          return mx::fft::fftn(a, s);
+        }
+      },
+      "a"_a,
+      "s"_a = nb::none(),
+      "axes"_a = nb::none(),
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        n-dimensional discrete Fourier Transform.
+
+        Args:
+            a (array): The input array.
+            s (list(int), optional): Sizes of the transformed axes. The
+               corresponding axes in the input are truncated or padded with
+               zeros to match the sizes in ``s``. The default value is the
+               sizes of ``a`` along ``axes``.
+            axes (list(int), optional): Axes along which to perform the FFT.
+               The default is ``None`` in which case the FFT is over the last
+               ``len(s)`` axes are or all axes if ``s`` is also ``None``.
+
+        Returns:
+            array: The DFT of the input along the given axes.
+      )pbdoc");
+  m.def(
+      "ifftn",
+      [](const mx::array& a,
+         const std::optional<mx::Shape>& n,
+         const std::optional<std::vector<int>>& axes,
+         mx::StreamOrDevice s) {
+        if (axes.has_value() && n.has_value()) {
+          return mx::fft::ifftn(a, n.value(), axes.value(), s);
+        } else if (axes.has_value()) {
+          return mx::fft::ifftn(a, axes.value(), s);
+        } else if (n.has_value()) {
+          throw std::invalid_argument(
+              "[ifftn] `axes` should not be `None` if `s` is not `None`.");
+        } else {
+          return mx::fft::ifftn(a, s);
+        }
+      },
+      "a"_a,
+      "s"_a = nb::none(),
+      "axes"_a = nb::none(),
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        n-dimensional inverse discrete Fourier Transform.
+
+        Args:
+            a (array): The input array.
+            s (list(int), optional): Sizes of the transformed axes. The
+               corresponding axes in the input are truncated or padded with
+               zeros to match the sizes in ``s``. The default value is the
+               sizes of ``a`` along ``axes``.
+            axes (list(int), optional): Axes along which to perform the FFT.
+               The default is ``None`` in which case the FFT is over the last
+               ``len(s)`` axes or all axes if ``s`` is also ``None``.
+
+        Returns:
+            array: The inverse DFT of the input along the given axes.
+      )pbdoc");
+  m.def(
+      "rfft",
+      [](const mx::array& a,
+         const std::optional<int>& n,
+         int axis,
+         mx::StreamOrDevice s) {
+        if (n.has_value()) {
+          return mx::fft::rfft(a, n.value(), axis, s);
+        } else {
+          return mx::fft::rfft(a, axis, s);
+        }
+      },
+      "a"_a,
+      "n"_a = nb::none(),
+      "axis"_a = -1,
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        One dimensional discrete Fourier Transform on a real input.
+
+        The output has the same shape as the input except along ``axis`` in
+        which case it has size ``n // 2 + 1``.
+
+        Args:
+            a (array): The input array. If the array is complex it will be silently
+               cast to a real type.
+            n (int, optional): Size of the transformed axis. The
+               corresponding axis in the input is truncated or padded with
+               zeros to match ``n``. The default value is ``a.shape[axis]``.
+            axis (int, optional): Axis along which to perform the FFT. The
+               default is ``-1``.
+
+        Returns:
+            array: The DFT of the input along the given axis. The output
+            data type will be complex.
+      )pbdoc");
+  m.def(
+      "irfft",
+      [](const mx::array& a,
+         const std::optional<int>& n,
+         int axis,
+         mx::StreamOrDevice s) {
+        if (n.has_value()) {
+          return mx::fft::irfft(a, n.value(), axis, s);
+        } else {
+          return mx::fft::irfft(a, axis, s);
+        }
+      },
+      "a"_a,
+      "n"_a = nb::none(),
+      "axis"_a = -1,
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        The inverse of :func:`rfft`.
+
+        The output has the same shape as the input except along ``axis`` in
+        which case it has size ``n``.
+
+        Args:
+            a (array): The input array.
+            n (int, optional): Size of the transformed axis. The
+               corresponding axis in the input is truncated or padded with
+               zeros to match ``n // 2 + 1``. The default value is
+               ``a.shape[axis] // 2 + 1``.
+            axis (int, optional): Axis along which to perform the FFT. The
+               default is ``-1``.
+
+        Returns:
+            array: The real array containing the inverse of :func:`rfft`.
+      )pbdoc");
+  m.def(
+      "rfft2",
+      [](const mx::array& a,
+         const std::optional<mx::Shape>& n,
+         const std::optional<std::vector<int>>& axes,
+         mx::StreamOrDevice s) {
+        if (axes.has_value() && n.has_value()) {
+          return mx::fft::rfftn(a, n.value(), axes.value(), s);
+        } else if (axes.has_value()) {
+          return mx::fft::rfftn(a, axes.value(), s);
+        } else if (n.has_value()) {
+          throw std::invalid_argument(
+              "[rfft2] `axes` should not be `None` if `s` is not `None`.");
+        } else {
+          return mx::fft::rfftn(a, s);
+        }
+      },
+      "a"_a,
+      "s"_a = nb::none(),
+      "axes"_a.none() = std::vector<int>{-2, -1},
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        Two dimensional real discrete Fourier Transform.
+
+        The output has the same shape as the input except along the dimensions in
+        ``axes`` in which case it has sizes from ``s``. The last axis in ``axes`` is
+        treated as the real axis and will have size ``s[-1] // 2 + 1``.
+
+        Args:
+            a (array): The input array. If the array is complex it will be silently
+               cast to a real type.
+            s (list(int), optional): Sizes of the transformed axes. The
+               corresponding axes in the input are truncated or padded with
+               zeros to match the sizes in ``s``. The default value is the
+               sizes of ``a`` along ``axes``.
+            axes (list(int), optional): Axes along which to perform the FFT.
+               The default is ``[-2, -1]``.
+
+        Returns:
+            array: The real DFT of the input along the given axes. The output
+            data type will be complex.
+      )pbdoc");
+  m.def(
+      "irfft2",
+      [](const mx::array& a,
+         const std::optional<mx::Shape>& n,
+         const std::optional<std::vector<int>>& axes,
+         mx::StreamOrDevice s) {
+        if (axes.has_value() && n.has_value()) {
+          return mx::fft::irfftn(a, n.value(), axes.value(), s);
+        } else if (axes.has_value()) {
+          return mx::fft::irfftn(a, axes.value(), s);
+        } else if (n.has_value()) {
+          throw std::invalid_argument(
+              "[irfft2] `axes` should not be `None` if `s` is not `None`.");
+        } else {
+          return mx::fft::irfftn(a, s);
+        }
+      },
+      "a"_a,
+      "s"_a = nb::none(),
+      "axes"_a.none() = std::vector<int>{-2, -1},
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        The inverse of :func:`rfft2`.
+
+        Note the input is generally complex. The dimensions of the input
+        specified in ``axes`` are padded or truncated to match the sizes
+        from ``s``. The last axis in ``axes`` is treated as the real axis
+        and will have size ``s[-1] // 2 + 1``.
+
+        Args:
+            a (array): The input array.
+            s (list(int), optional): Sizes of the transformed axes. The
+               corresponding axes in the input are truncated or padded with
+               zeros to match the sizes in ``s`` except for the last axis
+               which has size ``s[-1] // 2 + 1``. The default value is the
+               sizes of ``a`` along ``axes``.
+            axes (list(int), optional): Axes along which to perform the FFT.
+               The default is ``[-2, -1]``.
+
+        Returns:
+            array: The real array containing the inverse of :func:`rfft2`.
+      )pbdoc");
+  m.def(
+      "rfftn",
+      [](const mx::array& a,
+         const std::optional<mx::Shape>& n,
+         const std::optional<std::vector<int>>& axes,
+         mx::StreamOrDevice s) {
+        if (axes.has_value() && n.has_value()) {
+          return mx::fft::rfftn(a, n.value(), axes.value(), s);
+        } else if (axes.has_value()) {
+          return mx::fft::rfftn(a, axes.value(), s);
+        } else if (n.has_value()) {
+          throw std::invalid_argument(
+              "[rfftn] `axes` should not be `None` if `s` is not `None`.");
+        } else {
+          return mx::fft::rfftn(a, s);
+        }
+      },
+      "a"_a,
+      "s"_a = nb::none(),
+      "axes"_a = nb::none(),
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        n-dimensional real discrete Fourier Transform.
+
+        The output has the same shape as the input except along the dimensions in
+        ``axes`` in which case it has sizes from ``s``. The last axis in ``axes`` is
+        treated as the real axis and will have size ``s[-1] // 2 + 1``.
+
+        Args:
+            a (array): The input array. If the array is complex it will be silently
+               cast to a real type.
+            s (list(int), optional): Sizes of the transformed axes. The
+               corresponding axes in the input are truncated or padded with
+               zeros to match the sizes in ``s``. The default value is the
+               sizes of ``a`` along ``axes``.
+            axes (list(int), optional): Axes along which to perform the FFT.
+               The default is ``None`` in which case the FFT is over the last
+               ``len(s)`` axes or all axes if ``s`` is also ``None``.
+
+        Returns:
+            array: The real DFT of the input along the given axes. The output
+      )pbdoc");
+  m.def(
+      "irfftn",
+      [](const mx::array& a,
+         const std::optional<mx::Shape>& n,
+         const std::optional<std::vector<int>>& axes,
+         mx::StreamOrDevice s) {
+        if (axes.has_value() && n.has_value()) {
+          return mx::fft::irfftn(a, n.value(), axes.value(), s);
+        } else if (axes.has_value()) {
+          return mx::fft::irfftn(a, axes.value(), s);
+        } else if (n.has_value()) {
+          throw std::invalid_argument(
+              "[irfftn] `axes` should not be `None` if `s` is not `None`.");
+        } else {
+          return mx::fft::irfftn(a, s);
+        }
+      },
+      "a"_a,
+      "s"_a = nb::none(),
+      "axes"_a = nb::none(),
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        The inverse of :func:`rfftn`.
+
+        Note the input is generally complex. The dimensions of the input
+        specified in ``axes`` are padded or truncated to match the sizes
+        from ``s``. The last axis in ``axes`` is treated as the real axis
+        and will have size ``s[-1] // 2 + 1``.
+
+        Args:
+            a (array): The input array.
+            s (list(int), optional): Sizes of the transformed axes. The
+               corresponding axes in the input are truncated or padded with
+               zeros to match the sizes in ``s``. The default value is the
+               sizes of ``a`` along ``axes``.
+            axes (list(int), optional): Axes along which to perform the FFT.
+               The default is ``None`` in which case the FFT is over the last
+               ``len(s)`` axes or all axes if ``s`` is also ``None``.
+
+        Returns:
+            array: The real array containing the inverse of :func:`rfftn`.
+      )pbdoc");
+  m.def(
+      "fftshift",
+      [](const mx::array& a,
+         const std::optional<std::vector<int>>& axes,
+         mx::StreamOrDevice s) {
+        if (axes.has_value()) {
+          return mx::fft::fftshift(a, axes.value(), s);
+        } else {
+          return mx::fft::fftshift(a, s);
+        }
+      },
+      "a"_a,
+      "axes"_a = nb::none(),
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        Shift the zero-frequency component to the center of the spectrum.
+
+        Args:
+            a (array): The input array.
+            axes (list(int), optional): Axes over which to perform the shift.
+               If ``None``, shift all axes. 
+
+        Returns:
+            array: The shifted array with the same shape as the input.
+      )pbdoc");
+  m.def(
+      "ifftshift",
+      [](const mx::array& a,
+         const std::optional<std::vector<int>>& axes,
+         mx::StreamOrDevice s) {
+        if (axes.has_value()) {
+          return mx::fft::ifftshift(a, axes.value(), s);
+        } else {
+          return mx::fft::ifftshift(a, s);
+        }
+      },
+      "a"_a,
+      "axes"_a = nb::none(),
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        The inverse of :func:`fftshift`. While identical to :func:`fftshift` for even-length axes,
+        the behavior differs for odd-length axes.
+
+        Args:
+            a (array): The input array.
+            axes (list(int), optional): Axes over which to perform the inverse shift.
+               If ``None``, shift all axes. 
+
+        Returns:
+            array: The inverse-shifted array with the same shape as the input.
+      )pbdoc");
+}
diff --git a/ml-stable-diffusion/mlx/python/src/indexing.cpp b/ml-stable-diffusion/mlx/python/src/indexing.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..95c6e2a185b0c7b8fc9e37d0958dde4ee78fb8d2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/indexing.cpp
@@ -0,0 +1,977 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <numeric>
+#include <sstream>
+
+#include "python/src/convert.h"
+#include "python/src/indexing.h"
+
+#include "mlx/ops.h"
+
+bool is_none_slice(const nb::slice& in_slice) {
+  return (
+      nb::getattr(in_slice, "start").is_none() &&
+      nb::getattr(in_slice, "stop").is_none() &&
+      nb::getattr(in_slice, "step").is_none());
+}
+
+int get_slice_int(nb::object obj, int default_val) {
+  if (!obj.is_none()) {
+    if (!nb::isinstance<nb::int_>(obj)) {
+      throw std::invalid_argument("Slice indices must be integers or None.");
+    }
+    return nb::cast<int>(nb::cast<nb::int_>(obj));
+  }
+  return default_val;
+}
+
+void get_slice_params(
+    mx::ShapeElem& starts,
+    mx::ShapeElem& ends,
+    mx::ShapeElem& strides,
+    const nb::slice& in_slice,
+    int axis_size) {
+  // Following numpy's convention
+  //    Assume n is the number of elements in the dimension being sliced.
+  //    Then, if i is not given it defaults to 0 for k > 0 and n - 1 for
+  //    k < 0 . If j is not given it defaults to n for k > 0 and -n-1 for
+  //    k < 0 . If k is not given it defaults to 1
+
+  strides = get_slice_int(nb::getattr(in_slice, "step"), 1);
+  starts = get_slice_int(
+      nb::getattr(in_slice, "start"), strides < 0 ? axis_size - 1 : 0);
+  ends = get_slice_int(
+      nb::getattr(in_slice, "stop"), strides < 0 ? -axis_size - 1 : axis_size);
+}
+
+mx::array get_int_index(nb::object idx, int axis_size) {
+  int idx_ = nb::cast<int>(idx);
+  idx_ = (idx_ < 0) ? idx_ + axis_size : idx_;
+
+  return mx::array(idx_, mx::uint32);
+}
+
+bool is_valid_index_type(const nb::object& obj) {
+  return nb::isinstance<nb::slice>(obj) || nb::isinstance<nb::int_>(obj) ||
+      nb::isinstance<mx::array>(obj) || obj.is_none() ||
+      nb::ellipsis().is(obj) || nb::isinstance<nb::list>(obj);
+}
+
+mx::array mlx_get_item_slice(const mx::array& src, const nb::slice& in_slice) {
+  // Check input and raise error if 0 dim for parity with np
+  if (src.ndim() == 0) {
+    throw std::invalid_argument(
+        "too many indices for array: array is 0-dimensional");
+  }
+
+  // Return a copy of the array if none slice is request
+  if (is_none_slice(in_slice)) {
+    return src;
+  }
+
+  mx::Shape starts(src.ndim(), 0);
+  auto ends = src.shape();
+  mx::Shape strides(src.ndim(), 1);
+
+  // Check and update slice params
+  get_slice_params(starts[0], ends[0], strides[0], in_slice, ends[0]);
+  return slice(src, starts, ends, strides);
+}
+
+mx::array mlx_get_item_array(const mx::array& src, const mx::array& indices) {
+  // Check input and raise error if 0 dim for parity with np
+  if (src.ndim() == 0) {
+    throw std::invalid_argument(
+        "too many indices for array: array is 0-dimensional");
+  }
+
+  if (indices.dtype() == mx::bool_) {
+    throw std::invalid_argument("boolean indices are not yet supported");
+  }
+
+  // If only one input array is mentioned, we set axis=0 in take
+  // for parity with np
+  return take(src, indices, 0);
+}
+
+mx::array mlx_get_item_int(const mx::array& src, const nb::int_& idx) {
+  // Check input and raise error if 0 dim for parity with np
+  if (src.ndim() == 0) {
+    throw std::invalid_argument(
+        "too many indices for array: array is 0-dimensional");
+  }
+
+  // If only one input idx is mentioned, we set axis=0 in take
+  // for parity with np
+  return take(src, get_int_index(idx, src.shape(0)), 0);
+}
+
+mx::array mlx_gather_nd(
+    mx::array src,
+    const std::vector<nb::object>& indices,
+    bool gather_first,
+    int& max_dims) {
+  max_dims = 0;
+  std::vector<mx::array> gather_indices;
+  std::vector<bool> is_slice(indices.size(), false);
+  int num_slices = 0;
+  // gather all the arrays
+  for (int i = 0; i < indices.size(); i++) {
+    auto& idx = indices[i];
+
+    if (nb::isinstance<nb::slice>(idx)) {
+      mx::ShapeElem start, end, stride;
+      get_slice_params(
+          start, end, stride, nb::cast<nb::slice>(idx), src.shape(i));
+
+      // Handle negative indices
+      start = (start < 0) ? start + src.shape(i) : start;
+      end = (end < 0) ? end + src.shape(i) : end;
+
+      gather_indices.push_back(arange(start, end, stride, mx::uint32));
+      num_slices++;
+      is_slice[i] = true;
+    } else if (nb::isinstance<nb::int_>(idx)) {
+      gather_indices.push_back(get_int_index(idx, src.shape(i)));
+    } else if (nb::isinstance<mx::array>(idx)) {
+      auto arr = nb::cast<mx::array>(idx);
+      max_dims = std::max(static_cast<int>(arr.ndim()), max_dims);
+      gather_indices.push_back(arr);
+    }
+  }
+
+  // reshape them so that the int/array indices are first
+  if (gather_first) {
+    int slice_index = 0;
+    for (int i = 0; i < gather_indices.size(); i++) {
+      if (is_slice[i]) {
+        mx::Shape index_shape(max_dims + num_slices, 1);
+        index_shape[max_dims + slice_index] = gather_indices[i].shape(0);
+        gather_indices[i] = reshape(gather_indices[i], std::move(index_shape));
+        slice_index++;
+      } else {
+        auto index_shape = gather_indices[i].shape();
+        index_shape.insert(index_shape.end(), num_slices, 1);
+        gather_indices[i] = reshape(gather_indices[i], std::move(index_shape));
+      }
+    }
+  } else {
+    // reshape them so that the int/array indices are last
+    for (int i = 0; i < gather_indices.size(); i++) {
+      if (i < num_slices) {
+        mx::Shape index_shape(max_dims + num_slices, 1);
+        index_shape[i] = gather_indices[i].shape(0);
+        gather_indices[i] = reshape(gather_indices[i], std::move(index_shape));
+      }
+    }
+  }
+
+  // Do the gather
+  std::vector<int> axes(indices.size());
+  std::iota(axes.begin(), axes.end(), 0);
+  auto slice_sizes = src.shape();
+  std::fill(slice_sizes.begin(), slice_sizes.begin() + indices.size(), 1);
+  src = gather(src, gather_indices, axes, slice_sizes);
+
+  // Squeeze the array index dims
+  for (auto& ax : axes) {
+    ax += max_dims + num_slices;
+  }
+  return mx::squeeze(src, axes);
+}
+
+auto mlx_expand_ellipsis(const mx::Shape& shape, const nb::tuple& entries) {
+  std::vector<nb::object> indices;
+
+  // Go over all entries and note the position of ellipsis
+  int non_none_indices_before = 0;
+  int non_none_indices_after = 0;
+  std::vector<nb::object> r_indices;
+  int i = 0;
+  bool has_ellipsis = false;
+
+  // Start from dimension 0 till we hit an ellipsis
+  for (; i < entries.size(); i++) {
+    auto idx = entries[i];
+    if (!is_valid_index_type(idx)) {
+      throw std::invalid_argument(
+          "Cannot index mlx array using the given type yet");
+    }
+    if (!nb::ellipsis().is(idx)) {
+      indices.push_back(idx);
+      non_none_indices_before += !idx.is_none();
+    } else {
+      has_ellipsis = true;
+      break;
+    }
+  }
+
+  // If we do hit an ellipsis, collect indices from the back
+  for (int j = entries.size() - 1; j > i; j--) {
+    auto idx = entries[j];
+    if (!is_valid_index_type(idx)) {
+      throw std::invalid_argument(
+          "Cannot index mlx array using the given type yet");
+    }
+    if (nb::ellipsis().is(idx)) {
+      throw std::invalid_argument(
+          "An index can only have a single ellipsis (...)");
+    }
+    r_indices.push_back(idx);
+    non_none_indices_after += !idx.is_none();
+  }
+
+  // Count up the number of non none indices
+  int non_none_indices = non_none_indices_before + non_none_indices_after;
+
+  // Expand ellipsis
+  if (has_ellipsis) {
+    for (int axis = non_none_indices_before;
+         axis < shape.size() - non_none_indices_after;
+         axis++) {
+      indices.push_back(
+          nb::slice(mx::ShapeElem{0}, shape[axis], mx::ShapeElem{1}));
+      non_none_indices++;
+    }
+  }
+
+  // Insert indices collected after the ellipsis
+  indices.insert(indices.end(), r_indices.rbegin(), r_indices.rend());
+
+  return std::make_pair(non_none_indices, indices);
+}
+
+mx::array mlx_get_item_nd(mx::array src, const nb::tuple& entries) {
+  // No indices make this a noop
+  if (entries.size() == 0) {
+    return src;
+  }
+
+  // The plan is as follows:
+  // 1. Replace the ellipsis with a series of slice(None)
+  // 2. Convert list to array
+  // 3. Loop over the indices and calculate the gather indices
+  // 4. Calculate the remaining slices and reshapes
+
+  // Ellipsis handling
+  auto [non_none_indices, indices] = mlx_expand_ellipsis(src.shape(), entries);
+  // List handling
+  for (auto& idx : indices) {
+    if (nb::isinstance<nb::list>(idx)) {
+      idx = nb::cast(array_from_list(nb::cast<nb::list>(idx), {}));
+    }
+  }
+
+  // Check for the number of indices passed
+  if (non_none_indices > src.ndim()) {
+    std::ostringstream msg;
+    msg << "Too many indices for array with " << src.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // Gather handling
+  //
+  // Check whether we have arrays or integer indices and delegate to gather_nd
+  // after removing the slices at the end and all Nones.
+  std::vector<nb::object> remaining_indices;
+  bool have_array = false;
+  {
+    // First check whether the results of gather are going to be 1st or
+    // normally in between.
+    bool have_non_array = false;
+    bool gather_first = false;
+    for (auto& idx : indices) {
+      if (nb::isinstance<mx::array>(idx) || (nb::isinstance<nb::int_>(idx))) {
+        if (have_array && have_non_array) {
+          gather_first = true;
+          break;
+        }
+        have_array = true;
+      } else {
+        have_non_array |= have_array;
+      }
+    }
+
+    int n_arr = 0;
+    for (auto& idx : indices) {
+      n_arr += nb::isinstance<mx::array>(idx);
+    }
+
+    have_array &= n_arr > 0;
+
+    if (have_array) {
+      int last_array;
+      // Then find the last array
+      for (last_array = indices.size() - 1; last_array >= 0; last_array--) {
+        auto& idx = indices[last_array];
+        if (nb::isinstance<mx::array>(idx) || nb::isinstance<nb::int_>(idx)) {
+          break;
+        }
+      }
+
+      std::vector<nb::object> gather_indices;
+      for (int i = 0; i <= last_array; i++) {
+        auto& idx = indices[i];
+        if (!idx.is_none()) {
+          gather_indices.push_back(idx);
+        }
+      }
+      int max_dims;
+      src = mlx_gather_nd(src, gather_indices, gather_first, max_dims);
+
+      // Reassemble the indices for the slicing or reshaping if there are any
+      if (gather_first) {
+        for (int i = 0; i < max_dims; i++) {
+          remaining_indices.push_back(
+              nb::slice(nb::none(), nb::none(), nb::none()));
+        }
+        for (int i = 0; i < last_array; i++) {
+          auto& idx = indices[i];
+          if (idx.is_none()) {
+            remaining_indices.push_back(indices[i]);
+          } else if (nb::isinstance<nb::slice>(idx)) {
+            remaining_indices.push_back(
+                nb::slice(nb::none(), nb::none(), nb::none()));
+          }
+        }
+        for (int i = last_array + 1; i < indices.size(); i++) {
+          remaining_indices.push_back(indices[i]);
+        }
+      } else {
+        for (int i = 0; i < indices.size(); i++) {
+          auto& idx = indices[i];
+          if (nb::isinstance<mx::array>(idx) || nb::isinstance<nb::int_>(idx)) {
+            break;
+          } else if (idx.is_none()) {
+            remaining_indices.push_back(idx);
+          } else {
+            remaining_indices.push_back(
+                nb::slice(nb::none(), nb::none(), nb::none()));
+          }
+        }
+        for (int i = 0; i < max_dims; i++) {
+          remaining_indices.push_back(
+              nb::slice(nb::none(), nb::none(), nb::none()));
+        }
+        for (int i = last_array + 1; i < indices.size(); i++) {
+          remaining_indices.push_back(indices[i]);
+        }
+      }
+    }
+  }
+  if (have_array && remaining_indices.empty()) {
+    return src;
+  }
+  if (remaining_indices.empty()) {
+    remaining_indices = indices;
+  }
+
+  bool squeeze_needed = false;
+  bool unsqueeze_needed = false;
+
+  // Slice handling
+  {
+    mx::Shape starts(src.ndim(), 0);
+    auto ends = src.shape();
+    mx::Shape strides(src.ndim(), 1);
+    int axis = 0;
+    for (auto& idx : remaining_indices) {
+      if (!idx.is_none()) {
+        if (!have_array && nb::isinstance<nb::int_>(idx)) {
+          int st = nb::cast<int>(idx);
+          st = (st < 0) ? st + src.shape(axis) : st;
+
+          starts[axis] = st;
+          ends[axis] = st + 1;
+
+          squeeze_needed = true;
+
+        } else {
+          get_slice_params(
+              starts[axis],
+              ends[axis],
+              strides[axis],
+              nb::cast<nb::slice>(idx),
+              ends[axis]);
+        }
+
+        axis++;
+      } else {
+        unsqueeze_needed = true;
+      }
+    }
+    src = slice(src, starts, ends, strides);
+  }
+
+  // Unsqueeze handling
+  if (unsqueeze_needed || squeeze_needed) {
+    std::vector<int> squeeze_axes;
+    std::vector<int> unsqueeze_axes;
+    for (int axis = 0; axis < remaining_indices.size(); ++axis) {
+      auto& idx = remaining_indices[axis];
+      if (unsqueeze_needed && idx.is_none()) {
+        unsqueeze_axes.push_back(axis - squeeze_axes.size());
+      } else if (squeeze_needed && nb::isinstance<nb::int_>(idx)) {
+        squeeze_axes.push_back(axis - unsqueeze_axes.size());
+      }
+    }
+    if (!squeeze_axes.empty()) {
+      src = squeeze(src, std::move(squeeze_axes));
+    }
+    if (!unsqueeze_axes.empty()) {
+      src = expand_dims(src, std::move(unsqueeze_axes));
+    }
+  }
+
+  return src;
+}
+
+mx::array mlx_get_item(const mx::array& src, const nb::object& obj) {
+  if (nb::isinstance<nb::slice>(obj)) {
+    return mlx_get_item_slice(src, nb::cast<nb::slice>(obj));
+  } else if (nb::isinstance<mx::array>(obj)) {
+    return mlx_get_item_array(src, nb::cast<mx::array>(obj));
+  } else if (nb::isinstance<nb::int_>(obj)) {
+    return mlx_get_item_int(src, nb::cast<nb::int_>(obj));
+  } else if (nb::isinstance<nb::tuple>(obj)) {
+    return mlx_get_item_nd(src, nb::cast<nb::tuple>(obj));
+  } else if (nb::isinstance<nb::ellipsis>(obj)) {
+    return src;
+  } else if (obj.is_none()) {
+    return expand_dims(src, 0);
+  } else if (nb::isinstance<nb::list>(obj)) {
+    return mlx_get_item_array(
+        src, array_from_list(nb::cast<nb::list>(obj), {}));
+  }
+  throw std::invalid_argument("Cannot index mlx array using the given type.");
+}
+
+std::tuple<std::vector<mx::array>, mx::array, std::vector<int>>
+mlx_scatter_args_int(
+    const mx::array& src,
+    const nb::int_& idx,
+    const mx::array& update) {
+  if (src.ndim() == 0) {
+    throw std::invalid_argument(
+        "too many indices for array: array is 0-dimensional");
+  }
+
+  // Remove any leading singleton dimensions from the update
+  // and then broadcast update to shape of src[0, ...]
+  int s = 0;
+  for (; s < update.ndim() && update.shape(s) == 1; s++)
+    ;
+  auto up_shape = mx::Shape(update.shape().begin() + s, update.shape().end());
+  auto shape = src.shape();
+  shape[0] = 1;
+
+  return {
+      {get_int_index(idx, src.shape(0))},
+      broadcast_to(reshape(update, up_shape), shape),
+      {0}};
+}
+
+mx::array squeeze_leading_singletons(const mx::array& in) {
+  int s = 0;
+  for (; s < in.ndim() && in.shape(s) == 1; s++)
+    ;
+  auto squeeze_axes = std::vector<int>(s);
+  std::iota(squeeze_axes.begin(), squeeze_axes.end(), 0);
+  return mx::squeeze(in, squeeze_axes);
+}
+
+std::tuple<std::vector<mx::array>, mx::array, std::vector<int>>
+mlx_scatter_args_array(
+    const mx::array& src,
+    const mx::array& indices,
+    const mx::array& update) {
+  if (src.ndim() == 0) {
+    throw std::invalid_argument(
+        "too many indices for array: array is 0-dimensional");
+  }
+
+  auto up = squeeze_leading_singletons(update);
+
+  // The update shape must broadcast with indices.shape + [1] + src.shape[1:]
+  auto up_shape = indices.shape();
+  up_shape.insert(up_shape.end(), src.shape().begin() + 1, src.shape().end());
+  up = broadcast_to(up, up_shape);
+  up_shape.insert(up_shape.begin() + indices.ndim(), 1);
+  up = reshape(up, up_shape);
+
+  return {{indices}, up, {0}};
+}
+
+std::tuple<std::vector<mx::array>, mx::array, std::vector<int>>
+mlx_scatter_args_slice(
+    const mx::array& src,
+    const nb::slice& in_slice,
+    const mx::array& update) {
+  // Check input and raise error if 0 dim for parity with np
+  if (src.ndim() == 0) {
+    throw std::invalid_argument(
+        "too many indices for array: array is 0-dimensional");
+  }
+
+  // If none slice is requested broadcast the update
+  // to the src size and return it.
+  if (is_none_slice(in_slice)) {
+    return {
+        {}, broadcast_to(squeeze_leading_singletons(update), src.shape()), {}};
+  }
+
+  mx::ShapeElem start = 0;
+  auto end = src.shape(0);
+  mx::ShapeElem stride = 1;
+
+  // Check and update slice params
+  get_slice_params(start, end, stride, in_slice, end);
+
+  // If simple stride
+  if (stride == 1) {
+    // Squeeze out singleton dims from the start of update
+    auto up = squeeze_leading_singletons(update);
+
+    // Build array to mark start of slice
+    auto idx = mx::array({start}, {1}, mx::uint32);
+
+    // Get slice size
+    int slice_size = (end - start);
+
+    // Broadcast update to slice size
+    mx::Shape up_shape_broadcast = {1, slice_size};
+    up_shape_broadcast.insert(
+        up_shape_broadcast.end(), src.shape().begin() + 1, src.shape().end());
+
+    up = broadcast_to(up, up_shape_broadcast);
+
+    auto indices = std::vector<mx::array>{idx};
+    auto axes = std::vector<int>{0};
+
+    return {indices, up, axes};
+  }
+
+  return mlx_scatter_args_array(
+      src, arange(start, end, stride, mx::uint32), update);
+}
+
+std::tuple<std::vector<mx::array>, mx::array, std::vector<int>>
+mlx_scatter_args_nd(
+    const mx::array& src,
+    const nb::tuple& entries,
+    const mx::array& update) {
+  // Expand ellipses into a series of ':' slices
+  auto [non_none_indices, indices] = mlx_expand_ellipsis(src.shape(), entries);
+
+  // Convert List to array
+  for (auto& idx : indices) {
+    if (nb::isinstance<nb::list>(idx)) {
+      idx = nb::cast(array_from_list(nb::cast<nb::list>(idx), {}));
+    }
+  }
+
+  if (non_none_indices > src.ndim()) {
+    std::ostringstream msg;
+    msg << "Too many indices for array with " << src.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  auto up = squeeze_leading_singletons(update);
+
+  // If no non-None indices return the broadcasted update
+  if (non_none_indices == 0) {
+    return {{}, broadcast_to(up, src.shape()), {}};
+  }
+
+  // Analyse the types of the indices
+  size_t max_dim = 0;
+  bool arrays_first = false;
+  int num_none = 0;
+  int num_slices = 0;
+  int num_arrays = 0;
+  int num_strided_slices = 0;
+  int num_simple_slices_post = 0;
+  {
+    bool have_array = false;
+    bool have_non_array = false;
+    for (auto& idx : indices) {
+      if (idx.is_none()) {
+        have_non_array = have_array;
+        num_none++;
+
+      } else if (nb::isinstance<nb::slice>(idx)) {
+        have_non_array = have_array;
+        num_slices++;
+
+        auto slice = nb::cast<nb::slice>(idx);
+        int stride = get_slice_int(nb::getattr(slice, "step"), 1);
+        if (stride != 1) {
+          num_strided_slices++;
+          num_simple_slices_post = 0;
+        } else {
+          num_simple_slices_post++;
+        }
+
+      } else if (nb::isinstance<mx::array>(idx)) {
+        have_array = true;
+        if (have_array && have_non_array) {
+          arrays_first = true;
+        }
+        max_dim = std::max(nb::cast<mx::array>(idx).ndim(), max_dim);
+        num_arrays++;
+        num_simple_slices_post = 0;
+      }
+    }
+  }
+
+  // We have index dims for the arrays, strided slices (implemented as arrays),
+  // none
+  int idx_ndim = max_dim + num_none + num_slices - num_simple_slices_post;
+
+  // If we have simple non-strided slices, we also attach an index for that
+  idx_ndim = idx_ndim == 0 ? 1 : idx_ndim;
+
+  // Go over each index type and translate to the needed scatter args
+  std::vector<mx::array> arr_indices;
+  int slice_num = 0;
+  int array_num = 0;
+  int ax = 0;
+
+  // We collect the shapes of the slices and updates during this process
+  std::vector<int> update_shape(non_none_indices, 1);
+  std::vector<int> slice_shapes;
+
+  for (int i = 0; i < indices.size(); ++i) {
+    auto& pyidx = indices[i];
+    if (nb::isinstance<nb::slice>(pyidx)) {
+      mx::ShapeElem start, end, stride;
+      auto axis_size = src.shape(ax++);
+      get_slice_params(
+          start, end, stride, nb::cast<nb::slice>(pyidx), axis_size);
+
+      // Handle negative indices
+      start = (start < 0) ? start + axis_size : start;
+      end = (end < 0) ? end + axis_size : end;
+
+      mx::Shape idx_shape(idx_ndim, 1);
+
+      // If it's a simple slice, we only need to add the start index
+      if (array_num >= num_arrays && num_strided_slices <= 0 && stride == 1) {
+        auto idx = mx::array({start}, idx_shape, mx::uint32);
+        slice_shapes.push_back(end - start);
+        arr_indices.push_back(idx);
+
+        // Add the shape to the update
+        update_shape[ax - 1] = slice_shapes.back();
+      }
+      // Otherwise we expand the slice into indices using arange
+      else {
+        auto idx = arange(start, end, stride, mx::uint32);
+        auto loc = slice_num + (arrays_first ? max_dim : 0);
+        idx_shape[loc] = idx.size();
+        arr_indices.push_back(reshape(idx, idx_shape));
+
+        slice_num++;
+        num_strided_slices--;
+
+        // Add the shape to the update
+        update_shape[ax - 1] = 1;
+      }
+    } else if (nb::isinstance<nb::int_>(pyidx)) {
+      // Add index to arrays
+      arr_indices.push_back(get_int_index(pyidx, src.shape(ax++)));
+      // Add the shape to the update
+      update_shape[ax - 1] = 1;
+    } else if (pyidx.is_none()) {
+      // We only use the None's for bookeeping dimensions
+      slice_num++;
+    } else if (nb::isinstance<mx::array>(pyidx)) {
+      ax++;
+      auto idx = nb::cast<mx::array>(pyidx);
+      mx::Shape idx_shape(idx_ndim, 1);
+
+      // Place the arrays in the correct dimension
+      int st = (!arrays_first) * slice_num + max_dim - idx.ndim();
+      for (int j = 0; j < idx.ndim(); j++) {
+        idx_shape[st + j] = idx.shape()[j];
+      }
+      arr_indices.push_back(reshape(idx, idx_shape));
+      if (!arrays_first && ++array_num == num_arrays) {
+        slice_num += max_dim;
+      }
+
+      // Add the shape to the update
+      update_shape[ax - 1] = 1;
+    } else {
+      throw std::invalid_argument(
+          "Cannot index mlx array using the given type yet");
+    }
+  }
+
+  // Broadcast the update to the indices and slices
+  arr_indices = broadcast_arrays(arr_indices);
+  auto up_shape_broadcast = arr_indices[0].shape();
+
+  up_shape_broadcast.insert(
+      up_shape_broadcast.end(), slice_shapes.begin(), slice_shapes.end());
+  up_shape_broadcast.insert(
+      up_shape_broadcast.end(),
+      src.shape().begin() + non_none_indices,
+      src.shape().end());
+  up = broadcast_to(up, up_shape_broadcast);
+
+  // Reshape the update with the size-1 dims for the int and array indices
+  auto up_reshape = arr_indices[0].shape();
+  up_reshape.insert(up_reshape.end(), update_shape.begin(), update_shape.end());
+  up_reshape.insert(
+      up_reshape.end(),
+      src.shape().begin() + non_none_indices,
+      src.shape().end());
+
+  up = reshape(up, up_reshape);
+
+  // Collect axes
+  std::vector<int> axes(arr_indices.size(), 0);
+  std::iota(axes.begin(), axes.end(), 0);
+
+  return {arr_indices, up, axes};
+}
+
+std::tuple<std::vector<mx::array>, mx::array, std::vector<int>>
+mlx_compute_scatter_args(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v) {
+  auto vals = to_array(v, src.dtype());
+  if (nb::isinstance<nb::slice>(obj)) {
+    return mlx_scatter_args_slice(src, nb::cast<nb::slice>(obj), vals);
+  } else if (nb::isinstance<mx::array>(obj)) {
+    return mlx_scatter_args_array(src, nb::cast<mx::array>(obj), vals);
+  } else if (nb::isinstance<nb::int_>(obj)) {
+    return mlx_scatter_args_int(src, nb::cast<nb::int_>(obj), vals);
+  } else if (nb::isinstance<nb::tuple>(obj)) {
+    return mlx_scatter_args_nd(src, nb::cast<nb::tuple>(obj), vals);
+  } else if (obj.is_none()) {
+    return {{}, broadcast_to(vals, src.shape()), {}};
+  } else if (nb::isinstance<nb::list>(obj)) {
+    return mlx_scatter_args_array(
+        src, array_from_list(nb::cast<nb::list>(obj), {}), vals);
+  }
+
+  throw std::invalid_argument("Cannot index mlx array using the given type.");
+}
+
+auto mlx_slice_update(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v) {
+  // Can't route to slice update if not slice, tuple, or int
+  if (src.ndim() == 0 ||
+      (!nb::isinstance<nb::slice>(obj) && !nb::isinstance<nb::tuple>(obj) &&
+       !nb::isinstance<nb::int_>(obj))) {
+    return std::make_pair(false, src);
+  }
+  if (nb::isinstance<nb::tuple>(obj)) {
+    // Can't route to slice update if any arrays are present
+    for (auto idx : nb::cast<nb::tuple>(obj)) {
+      if (nb::isinstance<mx::array>(idx) || nb::isinstance<nb::list>(idx)) {
+        return std::make_pair(false, src);
+      }
+    }
+  }
+  // Should be able to route to slice update
+
+  // Pre process tuple
+  auto upd = to_array(v, src.dtype());
+
+  // Remove extra leading singletons dimensions from the update
+  int s = 0;
+  for (; s < static_cast<int>(upd.ndim()) - 1 && upd.shape(s) == 1 &&
+       (upd.ndim() - s) > src.ndim();
+       s++) {
+  };
+  auto squeeze_axes = std::vector<int>(s);
+  std::iota(squeeze_axes.begin(), squeeze_axes.end(), 0);
+  auto up = mx::squeeze(upd, squeeze_axes);
+
+  // Build slice update params
+  mx::Shape starts(src.ndim(), 0);
+  mx::Shape stops = src.shape();
+  mx::Shape strides(src.ndim(), 1);
+  if (nb::isinstance<nb::int_>(obj)) {
+    if (src.ndim() < 1) {
+      std::ostringstream msg;
+      msg << "Too many indices for array with " << src.ndim() << " dimensions.";
+      throw std::invalid_argument(msg.str());
+    }
+    auto idx = nb::cast<int>(obj);
+    idx = idx < 0 ? idx + stops[0] : idx;
+    starts[0] = idx;
+    stops[0] = idx + 1;
+    auto out = slice_update(
+        src, up, std::move(starts), std::move(stops), std::move(strides));
+    return std::make_pair(true, out);
+  }
+
+  // If it's just a simple slice, just do a slice update and return
+  if (nb::isinstance<nb::slice>(obj)) {
+    // Read slice arguments
+    get_slice_params(
+        starts[0],
+        stops[0],
+        strides[0],
+        nb::cast<nb::slice>(obj),
+        src.shape(0));
+
+    // Do slice update
+    auto out = slice_update(src, up, starts, stops, strides);
+    return std::make_pair(true, out);
+  }
+
+  // It must be a tuple
+  auto entries = nb::cast<nb::tuple>(obj);
+
+  // Expand ellipses into a series of ':' slices
+  auto [non_none_indices, indices] = mlx_expand_ellipsis(src.shape(), entries);
+
+  // Dimension check
+  if (non_none_indices > src.ndim()) {
+    std::ostringstream msg;
+    msg << "Too many indices for array with " << src.ndim() << " dimensions.";
+    throw std::invalid_argument(msg.str());
+  }
+
+  // If no non-None indices return the broadcasted update
+  if (non_none_indices == 0) {
+    return std::make_pair(true, broadcast_to(up, src.shape()));
+  }
+
+  int unspecified = src.ndim() - non_none_indices;
+  std::vector<int> squeeze_dims;
+  std::vector<int> expand_dims;
+  for (int i = indices.size() - 1,
+           ax = non_none_indices - 1,
+           upd_ax = upd.ndim() - unspecified - 1;
+       i >= 0;
+       --i) {
+    auto& pyidx = indices[i];
+    if (nb::isinstance<nb::slice>(pyidx)) {
+      get_slice_params(
+          starts[ax],
+          stops[ax],
+          strides[ax],
+          nb::cast<nb::slice>(pyidx),
+          src.shape(ax));
+      ax--;
+      upd_ax--;
+    } else if (nb::isinstance<nb::int_>(pyidx)) {
+      int st = nb::cast<int>(pyidx);
+      st = (st < 0) ? st + src.shape(i) : st;
+      starts[ax] = st;
+      stops[ax] = st + 1;
+      if (upd_ax >= 0) {
+        expand_dims.push_back(i - indices.size() - unspecified);
+      }
+      ax--;
+    } else if (pyidx.is_none()) {
+      if (upd_ax-- >= 0) {
+        squeeze_dims.push_back(i - indices.size() - unspecified);
+      }
+    }
+  }
+
+  up = mx::squeeze(
+      mx::expand_dims(up, std::move(expand_dims)), std::move(squeeze_dims));
+  auto out = slice_update(src, up, starts, stops, strides);
+  return std::make_pair(true, out);
+}
+
+void mlx_set_item(
+    mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v) {
+  auto [success, out] = mlx_slice_update(src, obj, v);
+  if (success) {
+    src.overwrite_descriptor(out);
+    return;
+  }
+
+  auto [indices, updates, axes] = mlx_compute_scatter_args(src, obj, v);
+  if (indices.size() > 0) {
+    auto out = scatter(src, indices, updates, axes);
+    src.overwrite_descriptor(out);
+  } else {
+    src.overwrite_descriptor(updates);
+  }
+}
+
+mx::array mlx_add_item(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v) {
+  auto [indices, updates, axes] = mlx_compute_scatter_args(src, obj, v);
+  if (indices.size() > 0) {
+    return scatter_add(src, indices, updates, axes);
+  } else {
+    return src + updates;
+  }
+}
+
+mx::array mlx_subtract_item(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v) {
+  auto [indices, updates, axes] = mlx_compute_scatter_args(src, obj, v);
+  if (indices.size() > 0) {
+    return scatter_add(src, indices, -updates, axes);
+  } else {
+    return src - updates;
+  }
+}
+
+mx::array mlx_multiply_item(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v) {
+  auto [indices, updates, axes] = mlx_compute_scatter_args(src, obj, v);
+  if (indices.size() > 0) {
+    return scatter_prod(src, indices, updates, axes);
+  } else {
+    return src * updates;
+  }
+}
+
+mx::array mlx_divide_item(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v) {
+  auto [indices, updates, axes] = mlx_compute_scatter_args(src, obj, v);
+  if (indices.size() > 0) {
+    return scatter_prod(src, indices, reciprocal(updates), axes);
+  } else {
+    return src / updates;
+  }
+}
+
+mx::array mlx_maximum_item(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v) {
+  auto [indices, updates, axes] = mlx_compute_scatter_args(src, obj, v);
+  if (indices.size() > 0) {
+    return scatter_max(src, indices, updates, axes);
+  } else {
+    return maximum(src, updates);
+  }
+}
+
+mx::array mlx_minimum_item(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v) {
+  auto [indices, updates, axes] = mlx_compute_scatter_args(src, obj, v);
+  if (indices.size() > 0) {
+    return scatter_min(src, indices, updates, axes);
+  } else {
+    return minimum(src, updates);
+  }
+}
diff --git a/ml-stable-diffusion/mlx/python/src/indexing.h b/ml-stable-diffusion/mlx/python/src/indexing.h
new file mode 100644
index 0000000000000000000000000000000000000000..c941425bfb65cee232822fb8ba90b020677e7e89
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/indexing.h
@@ -0,0 +1,41 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <nanobind/nanobind.h>
+
+#include "mlx/array.h"
+#include "python/src/utils.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+
+mx::array mlx_get_item(const mx::array& src, const nb::object& obj);
+void mlx_set_item(
+    mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v);
+mx::array mlx_add_item(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v);
+mx::array mlx_subtract_item(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v);
+mx::array mlx_multiply_item(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v);
+mx::array mlx_divide_item(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v);
+mx::array mlx_maximum_item(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v);
+mx::array mlx_minimum_item(
+    const mx::array& src,
+    const nb::object& obj,
+    const ScalarOrArray& v);
diff --git a/ml-stable-diffusion/mlx/python/src/linalg.cpp b/ml-stable-diffusion/mlx/python/src/linalg.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..58f9be77664ca92d9b5b49b5e2090c019bc62730
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/linalg.cpp
@@ -0,0 +1,663 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <variant>
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/pair.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/variant.h>
+#include <nanobind/stl/vector.h>
+
+#include "mlx/linalg.h"
+#include "python/src/small_vector.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+void init_linalg(nb::module_& parent_module) {
+  auto m = parent_module.def_submodule(
+      "linalg", "mlx.core.linalg: linear algebra routines.");
+
+  m.def(
+      "norm",
+      [](const mx::array& a,
+         const std::variant<std::monostate, int, double, std::string>& ord_,
+         const std::variant<std::monostate, int, std::vector<int>>& axis_,
+         const bool keepdims,
+         const mx::StreamOrDevice stream) {
+        std::optional<std::vector<int>> axis = std::nullopt;
+        if (auto pv = std::get_if<int>(&axis_); pv) {
+          axis = std::vector<int>{*pv};
+        } else if (auto pv = std::get_if<std::vector<int>>(&axis_); pv) {
+          axis = *pv;
+        }
+
+        if (std::holds_alternative<std::monostate>(ord_)) {
+          return mx::linalg::norm(a, axis, keepdims, stream);
+        } else {
+          if (auto pv = std::get_if<std::string>(&ord_); pv) {
+            return mx::linalg::norm(a, *pv, axis, keepdims, stream);
+          }
+          double ord;
+          if (auto pv = std::get_if<int>(&ord_); pv) {
+            ord = *pv;
+          } else {
+            ord = std::get<double>(ord_);
+          }
+          return mx::linalg::norm(a, ord, axis, keepdims, stream);
+        }
+      },
+      nb::arg(),
+      "ord"_a = nb::none(),
+      "axis"_a = nb::none(),
+      "keepdims"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def norm(a: array, /, ord: Union[None, int, float, str] = None, axis: Union[None, int, list[int]] = None, keepdims: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Matrix or vector norm.
+
+        This function computes vector or  matrix norms depending on the value of
+        the ``ord`` and ``axis`` parameters.
+
+        Args:
+          a (array): Input array.  If ``axis`` is ``None``, ``a`` must be 1-D or 2-D,
+            unless ``ord`` is ``None``. If both ``axis`` and ``ord`` are ``None``, the
+            2-norm of ``a.flatten`` will be returned.
+          ord (int, float or str, optional): Order of the norm (see table under ``Notes``).
+            If ``None``, the 2-norm (or Frobenius norm for matrices) will be computed
+            along the given ``axis``.  Default: ``None``.
+          axis (int or list(int), optional): If ``axis`` is an integer, it specifies the
+            axis of ``a`` along which to compute the vector norms.  If ``axis`` is a
+            2-tuple, it specifies the axes that hold 2-D matrices, and the matrix
+            norms of these matrices are computed. If `axis` is ``None`` then
+            either a vector norm (when ``a`` is 1-D) or a matrix norm (when ``a`` is
+            2-D) is returned. Default: ``None``.
+          keepdims (bool, optional): If ``True``, the axes which are normed over are
+            left in the result as dimensions with size one. Default ``False``.
+
+        Returns:
+          array: The output containing the norm(s).
+
+        Notes:
+          For values of ``ord < 1``, the result is, strictly speaking, not a
+          mathematical norm, but it may still be useful for various numerical
+          purposes.
+
+          The following norms can be calculated:
+
+          =====  ============================  ==========================
+          ord    norm for matrices             norm for vectors
+          =====  ============================  ==========================
+          None   Frobenius norm                2-norm
+          'fro'  Frobenius norm                --
+          'nuc'  nuclear norm                  --
+          inf    max(sum(abs(x), axis=1))      max(abs(x))
+          -inf   min(sum(abs(x), axis=1))      min(abs(x))
+          0      --                            sum(x != 0)
+          1      max(sum(abs(x), axis=0))      as below
+          -1     min(sum(abs(x), axis=0))      as below
+          2      2-norm (largest sing. value)  as below
+          -2     smallest singular value       as below
+          other  --                            sum(abs(x)**ord)**(1./ord)
+          =====  ============================  ==========================
+
+          The Frobenius norm is given by [1]_:
+
+              :math:`||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}`
+
+          The nuclear norm is the sum of the singular values.
+
+          Both the Frobenius and nuclear norm orders are only defined for
+          matrices and raise a ``ValueError`` when ``a.ndim != 2``.
+
+        References:
+          .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,
+                 Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15
+
+        Examples:
+          >>> import mlx.core as mx
+          >>> from mlx.core import linalg as la
+          >>> a = mx.arange(9) - 4
+          >>> a
+          array([-4, -3, -2, ..., 2, 3, 4], dtype=int32)
+          >>> b = a.reshape((3,3))
+          >>> b
+          array([[-4, -3, -2],
+                 [-1,  0,  1],
+                 [ 2,  3,  4]], dtype=int32)
+          >>> la.norm(a)
+          array(7.74597, dtype=float32)
+          >>> la.norm(b)
+          array(7.74597, dtype=float32)
+          >>> la.norm(b, 'fro')
+          array(7.74597, dtype=float32)
+          >>> la.norm(a, float("inf"))
+          array(4, dtype=float32)
+          >>> la.norm(b, float("inf"))
+          array(9, dtype=float32)
+          >>> la.norm(a, -float("inf"))
+          array(0, dtype=float32)
+          >>> la.norm(b, -float("inf"))
+          array(2, dtype=float32)
+          >>> la.norm(a, 1)
+          array(20, dtype=float32)
+          >>> la.norm(b, 1)
+          array(7, dtype=float32)
+          >>> la.norm(a, -1)
+          array(0, dtype=float32)
+          >>> la.norm(b, -1)
+          array(6, dtype=float32)
+          >>> la.norm(a, 2)
+          array(7.74597, dtype=float32)
+          >>> la.norm(a, 3)
+          array(5.84804, dtype=float32)
+          >>> la.norm(a, -3)
+          array(0, dtype=float32)
+          >>> c = mx.array([[ 1, 2, 3],
+          ...               [-1, 1, 4]])
+          >>> la.norm(c, axis=0)
+          array([1.41421, 2.23607, 5], dtype=float32)
+          >>> la.norm(c, axis=1)
+          array([3.74166, 4.24264], dtype=float32)
+          >>> la.norm(c, ord=1, axis=1)
+          array([6, 6], dtype=float32)
+          >>> m = mx.arange(8).reshape(2,2,2)
+          >>> la.norm(m, axis=(1,2))
+          array([3.74166, 11.225], dtype=float32)
+          >>> la.norm(m[0, :, :]), LA.norm(m[1, :, :])
+          (array(3.74166, dtype=float32), array(11.225, dtype=float32))
+      )pbdoc");
+  m.def(
+      "qr",
+      &mx::linalg::qr,
+      "a"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def qr(a: array, *, stream: Union[None, Stream, Device] = None) -> Tuple[array, array]"),
+      R"pbdoc(
+        The QR factorization of the input matrix.
+
+        This function supports arrays with at least 2 dimensions. The matrices
+        which are factorized are assumed to be in the last two dimensions of
+        the input.
+
+        Args:
+            a (array): Input array.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            tuple(array, array): ``Q`` and ``R`` matrices such that ``Q @ R = a``.
+
+        Example:
+            >>> A = mx.array([[2., 3.], [1., 2.]])
+            >>> Q, R = mx.linalg.qr(A, stream=mx.cpu)
+            >>> Q
+            array([[-0.894427, -0.447214],
+                   [-0.447214, 0.894427]], dtype=float32)
+            >>> R
+            array([[-2.23607, -3.57771],
+                   [0, 0.447214]], dtype=float32)
+      )pbdoc");
+  m.def(
+      "svd",
+      [](const mx::array& a,
+         bool compute_uv /* = true */,
+         mx::StreamOrDevice s /* = {} */) -> nb::object {
+        const auto result = mx::linalg::svd(a, compute_uv, s);
+        if (result.size() == 1) {
+          return nb::cast(result.at(0));
+        } else {
+          return nb::make_tuple(result.at(0), result.at(1), result.at(2));
+        }
+      },
+      "a"_a,
+      "compute_uv"_a = true,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def svd(a: array, compute_uv: bool = True, *, stream: Union[None, Stream, Device] = None) -> Tuple[array, array, array]"),
+      R"pbdoc(
+        The Singular Value Decomposition (SVD) of the input matrix.
+
+        This function supports arrays with at least 2 dimensions. When the input
+        has more than two dimensions, the function iterates over all indices of the first
+        a.ndim - 2 dimensions and for each combination SVD is applied to the last two indices.
+
+        Args:
+            a (array): Input array.
+            compute_uv (bool, optional): If ``True``, return the ``U``, ``S``, and ``Vt`` components.
+              If ``False``, return only the ``S`` array. Default: ``True``.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            Union[tuple(array, ...), array]:
+              If compute_uv is ``True`` returns the ``U``, ``S``, and ``Vt`` matrices, such that
+              ``A = U @ diag(S) @ Vt``. If compute_uv is ``False`` returns singular values array ``S``.
+      )pbdoc");
+  m.def(
+      "inv",
+      &mx::linalg::inv,
+      "a"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def inv(a: array, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Compute the inverse of a square matrix.
+
+        This function supports arrays with at least 2 dimensions. When the input
+        has more than two dimensions, the inverse is computed for each matrix
+        in the last two dimensions of ``a``.
+
+        Args:
+            a (array): Input array.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            array: ``ainv`` such that ``dot(a, ainv) = dot(ainv, a) = eye(a.shape[0])``
+      )pbdoc");
+  m.def(
+      "tri_inv",
+      &mx::linalg::tri_inv,
+      "a"_a,
+      "upper"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def tri_inv(a: array, upper: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Compute the inverse of a triangular square matrix.
+
+        This function supports arrays with at least 2 dimensions. When the input
+        has more than two dimensions, the inverse is computed for each matrix
+        in the last two dimensions of ``a``.
+
+        Args:
+            a (array): Input array.
+            upper (bool, optional): Whether the array is upper or lower triangular. Defaults to ``False``.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            array: ``ainv`` such that ``dot(a, ainv) = dot(ainv, a) = eye(a.shape[0])``
+      )pbdoc");
+  m.def(
+      "cholesky",
+      &mx::linalg::cholesky,
+      "a"_a,
+      "upper"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def cholesky(a: array, upper: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Compute the Cholesky decomposition of a real symmetric positive semi-definite matrix.
+
+        This function supports arrays with at least 2 dimensions. When the input
+        has more than two dimensions, the Cholesky decomposition is computed for each matrix
+        in the last two dimensions of ``a``.
+
+        If the input matrix is not symmetric positive semi-definite, behaviour is undefined.
+
+        Args:
+            a (array): Input array.
+            upper (bool, optional): If ``True``, return the upper triangular Cholesky factor.
+              If ``False``, return the lower triangular Cholesky factor. Default: ``False``.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+          array: If ``upper = False``, it returns a lower triangular ``L`` matrix such
+          that ``L @ L.T = a``.  If ``upper = True``, it returns an upper triangular
+          ``U`` matrix such that ``U.T @ U = a``.
+      )pbdoc");
+  m.def(
+      "cholesky_inv",
+      &mx::linalg::cholesky_inv,
+      "a"_a,
+      "upper"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def cholesky_inv(L: array, upper: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Compute the inverse of a real symmetric positive semi-definite matrix using it's Cholesky decomposition.
+
+        Let :math:`\mathbf{A}` be a real symmetric positive semi-definite matrix and :math:`\mathbf{L}` its Cholesky decomposition such that:
+
+        .. math::
+
+          \begin{aligned}
+            \mathbf{A} = \mathbf{L}\mathbf{L}^T
+          \end{aligned}
+
+        This function computes :math:`\mathbf{A}^{-1}`.
+
+        This function supports arrays with at least 2 dimensions. When the input
+        has more than two dimensions, the Cholesky inverse is computed for each matrix
+        in the last two dimensions of :math:`\mathbf{L}`.
+
+        If the input matrix is not a triangular matrix behaviour is undefined.
+
+        Args:
+            L (array): Input array.
+            upper (bool, optional): If ``True``, return the upper triangular Cholesky factor.
+              If ``False``, return the lower triangular Cholesky factor. Default: ``False``.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+          array: :math:`\mathbf{A^{-1}}` where :math:`\mathbf{A} = \mathbf{L}\mathbf{L}^T`.
+      )pbdoc");
+  m.def(
+      "pinv",
+      &mx::linalg::pinv,
+      "a"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def pinv(a: array, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Compute the (Moore-Penrose) pseudo-inverse of a matrix.
+
+        This function calculates a generalized inverse of a matrix using its
+        singular-value decomposition. This function supports arrays with at least 2 dimensions.
+        When the input has more than two dimensions, the inverse is computed for each
+        matrix in the last two dimensions of ``a``.
+
+        Args:
+            a (array): Input array.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            array: ``aplus`` such that ``a @ aplus @ a = a``
+      )pbdoc");
+  m.def(
+      "cross",
+      &mx::linalg::cross,
+      "a"_a,
+      "b"_a,
+      "axis"_a = -1,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def cross(a: array, b: array, axis: int = -1, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Compute the cross product of two arrays along a specified axis.
+
+        The cross product is defined for arrays with size 2 or 3 in the
+        specified axis. If the size is 2 then the third value is assumed
+        to be zero.
+
+        Args:
+            a (array): Input array.
+            b (array): Input array.
+            axis (int, optional): Axis along which to compute the cross
+              product. Default: ``-1``.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            array: The cross product of ``a`` and ``b`` along the specified axis.
+      )pbdoc");
+  m.def(
+      "eigvals",
+      &mx::linalg::eigvals,
+      "a"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        Compute the eigenvalues of a square matrix.
+
+        This function differs from :func:`numpy.linalg.eigvals` in that the
+        return type is always complex even if the eigenvalues are all real.
+
+        This function supports arrays with at least 2 dimensions. When the
+        input has more than two dimensions, the eigenvalues are computed for
+        each matrix in the last two dimensions.
+
+        Args:
+            a (array): The input array.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            array: The eigenvalues (not necessarily in order).
+
+        Example:
+            >>> A = mx.array([[1., -2.], [-2., 1.]])
+            >>> eigenvalues = mx.linalg.eigvals(A, stream=mx.cpu)
+            >>> eigenvalues
+            array([3+0j, -1+0j], dtype=complex64)
+      )pbdoc");
+  m.def(
+      "eig",
+      [](const mx::array& a, mx::StreamOrDevice s) {
+        auto result = mx::linalg::eig(a, s);
+        return nb::make_tuple(result.first, result.second);
+      },
+      "a"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def eig(a: array, *, stream: Union[None, Stream, Device] = None) -> Tuple[array, array]"),
+      R"pbdoc(
+        Compute the eigenvalues and eigenvectors of a square matrix.
+
+        This function differs from :func:`numpy.linalg.eig` in that the
+        return type is always complex even if the eigenvalues are all real.
+
+        This function supports arrays with at least 2 dimensions. When the input
+        has more than two dimensions, the eigenvalues and eigenvectors are
+        computed for each matrix in the last two dimensions.
+
+        Args:
+            a (array): The input array.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            Tuple[array, array]:
+              A tuple containing the eigenvalues and the normalized right
+              eigenvectors. The column ``v[:, i]`` is the eigenvector
+              corresponding to the i-th eigenvalue.
+
+        Example:
+            >>> A = mx.array([[1., -2.], [-2., 1.]])
+            >>> w, v = mx.linalg.eig(A, stream=mx.cpu)
+            >>> w
+            array([3+0j, -1+0j], dtype=complex64)
+            >>> v
+            array([[0.707107+0j, 0.707107+0j],
+                   [-0.707107+0j, 0.707107+0j]], dtype=complex64)
+      )pbdoc");
+
+  m.def(
+      "eigvalsh",
+      &mx::linalg::eigvalsh,
+      "a"_a,
+      "UPLO"_a = "L",
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      R"pbdoc(
+        Compute the eigenvalues of a complex Hermitian or real symmetric matrix.
+
+        This function supports arrays with at least 2 dimensions. When the
+        input has more than two dimensions, the eigenvalues are computed for
+        each matrix in the last two dimensions.
+
+        Args:
+            a (array): Input array. Must be a real symmetric or complex
+              Hermitian matrix.
+            UPLO (str, optional): Whether to use the upper (``"U"``) or
+              lower (``"L"``) triangle of the matrix.  Default: ``"L"``.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            array: The eigenvalues in ascending order.
+
+        Note:
+            The input matrix is assumed to be symmetric (or Hermitian). Only
+            the selected triangle is used. No checks for symmetry are performed.
+
+        Example:
+            >>> A = mx.array([[1., -2.], [-2., 1.]])
+            >>> eigenvalues = mx.linalg.eigvalsh(A, stream=mx.cpu)
+            >>> eigenvalues
+            array([-1., 3.], dtype=float32)
+      )pbdoc");
+  m.def(
+      "eigh",
+      [](const mx::array& a, const std::string& UPLO, mx::StreamOrDevice s) {
+        auto result = mx::linalg::eigh(a, UPLO, s);
+        return nb::make_tuple(result.first, result.second);
+      },
+      "a"_a,
+      "UPLO"_a = "L",
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def eigh(a: array, UPLO: str = 'L', *, stream: Union[None, Stream, Device] = None) -> Tuple[array, array]"),
+      R"pbdoc(
+        Compute the eigenvalues and eigenvectors of a complex Hermitian or
+        real symmetric matrix.
+
+        This function supports arrays with at least 2 dimensions. When the input
+        has more than two dimensions, the eigenvalues and eigenvectors are
+        computed for each matrix in the last two dimensions.
+
+        Args:
+            a (array): Input array. Must be a real symmetric or complex
+              Hermitian matrix.
+            UPLO (str, optional): Whether to use the upper (``"U"``) or
+               lower (``"L"``) triangle of the matrix.  Default: ``"L"``.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            Tuple[array, array]:
+              A tuple containing the eigenvalues in ascending order and
+              the normalized eigenvectors. The column ``v[:, i]`` is the
+              eigenvector corresponding to the i-th eigenvalue.
+
+        Note:
+            The input matrix is assumed to be symmetric (or Hermitian). Only
+            the selected triangle is used. No checks for symmetry are performed.
+
+        Example:
+            >>> A = mx.array([[1., -2.], [-2., 1.]])
+            >>> w, v = mx.linalg.eigh(A, stream=mx.cpu)
+            >>> w
+            array([-1., 3.], dtype=float32)
+            >>> v
+            array([[ 0.707107, -0.707107],
+                  [ 0.707107,  0.707107]], dtype=float32)
+      )pbdoc");
+  m.def(
+      "lu",
+      [](const mx::array& a, mx::StreamOrDevice s /* = {} */) {
+        auto result = mx::linalg::lu(a, s);
+        return nb::make_tuple(result.at(0), result.at(1), result.at(2));
+      },
+      "a"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def lu(a: array, *, stream: Union[None, Stream, Device] = None) -> Tuple[array, array, array]"),
+      R"pbdoc(
+        Compute the LU factorization of the given matrix ``A``.
+
+        Note, unlike the default behavior of ``scipy.linalg.lu``, the pivots
+        are indices. To reconstruct the input use ``L[P, :] @ U`` for 2
+        dimensions or ``mx.take_along_axis(L, P[..., None], axis=-2) @ U``
+        for more than 2 dimensions.
+
+        To construct the full permuation matrix do:
+
+        .. code-block::
+
+          P = mx.put_along_axis(mx.zeros_like(L), p[..., None], mx.array(1.0), axis=-1)
+
+        Args:
+            a (array): Input array.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            tuple(array, array, array):
+              The ``p``, ``L``, and ``U`` arrays, such that ``A = L[P, :] @ U``
+      )pbdoc");
+  m.def(
+      "lu_factor",
+      &mx::linalg::lu_factor,
+      "a"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def lu_factor(a: array, *, stream: Union[None, Stream, Device] = None) -> Tuple[array, array]"),
+      R"pbdoc(
+        Computes a compact representation of the LU factorization.
+
+        Args:
+            a (array): Input array.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            tuple(array, array): The ``LU`` matrix and ``pivots`` array.
+      )pbdoc");
+  m.def(
+      "solve",
+      &mx::linalg::solve,
+      "a"_a,
+      "b"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def solve(a: array, b: array, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Compute the solution to a system of linear equations ``AX = B``.
+
+        Args:
+            a (array): Input array.
+            b (array): Input array.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            array: The unique solution to the system ``AX = B``.
+      )pbdoc");
+  m.def(
+      "solve_triangular",
+      &mx::linalg::solve_triangular,
+      "a"_a,
+      "b"_a,
+      nb::kw_only(),
+      "upper"_a = false,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def solve_triangular(a: array, b: array, *, upper: bool = False, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Computes the solution of a triangular system of linear equations ``AX = B``.
+
+        Args:
+            a (array): Input array.
+            b (array): Input array.
+            upper (bool, optional): Whether the array is upper or lower
+              triangular. Default: ``False``.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            array: The unique solution to the system ``AX = B``.
+      )pbdoc");
+}
diff --git a/ml-stable-diffusion/mlx/python/src/load.cpp b/ml-stable-diffusion/mlx/python/src/load.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f98307f192a1fd697c7dd7a398b0ef953eabf0a2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/load.cpp
@@ -0,0 +1,531 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <nanobind/stl/vector.h>
+#include <cstring>
+#include <fstream>
+#include <stdexcept>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+#include "mlx/io/load.h"
+#include "mlx/ops.h"
+#include "mlx/utils.h"
+#include "python/src/load.h"
+#include "python/src/small_vector.h"
+#include "python/src/utils.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+///////////////////////////////////////////////////////////////////////////////
+// Helpers
+///////////////////////////////////////////////////////////////////////////////
+
+bool is_str_or_path(nb::object obj) {
+  if (nb::isinstance<nb::str>(obj)) {
+    return true;
+  }
+  nb::object path_type = nb::module_::import_("pathlib").attr("Path");
+  return nb::isinstance(obj, path_type);
+}
+
+bool is_istream_object(const nb::object& file) {
+  return nb::hasattr(file, "readinto") && nb::hasattr(file, "seek") &&
+      nb::hasattr(file, "tell") && nb::hasattr(file, "closed");
+}
+
+bool is_ostream_object(const nb::object& file) {
+  return nb::hasattr(file, "write") && nb::hasattr(file, "seek") &&
+      nb::hasattr(file, "tell") && nb::hasattr(file, "closed");
+}
+
+bool is_zip_file(const nb::module_& zipfile, const nb::object& file) {
+  if (is_istream_object(file)) {
+    auto st_pos = file.attr("tell")();
+    bool r = nb::cast<bool>(zipfile.attr("is_zipfile")(file));
+    file.attr("seek")(st_pos, 0);
+    return r;
+  }
+  return nb::cast<bool>(zipfile.attr("is_zipfile")(file));
+}
+
+class ZipFileWrapper {
+ public:
+  ZipFileWrapper(
+      const nb::module_& zipfile,
+      const nb::object& file,
+      char mode = 'r',
+      int compression = 0)
+      : zipfile_module_(zipfile),
+        zipfile_object_(zipfile.attr("ZipFile")(
+            file,
+            "mode"_a = mode,
+            "compression"_a = compression,
+            "allowZip64"_a = true)),
+        files_list_(zipfile_object_.attr("namelist")()),
+        open_func_(zipfile_object_.attr("open")),
+        read_func_(zipfile_object_.attr("read")),
+        close_func_(zipfile_object_.attr("close")) {}
+
+  std::vector<std::string> namelist() const {
+    return nb::cast<std::vector<std::string>>(files_list_);
+  }
+
+  nb::object open(const std::string& key, char mode = 'r') {
+    // Following numpy :
+    // https://github.com/numpy/numpy/blob/db4f43983cb938f12c311e1f5b7165e270c393b4/numpy/lib/npyio.py#L742C36-L742C47
+    if (mode == 'w') {
+      return open_func_(key, "mode"_a = mode, "force_zip64"_a = true);
+    }
+    return open_func_(key, "mode"_a = mode);
+  }
+
+ private:
+  nb::module_ zipfile_module_;
+  nb::object zipfile_object_;
+  nb::list files_list_;
+  nb::object open_func_;
+  nb::object read_func_;
+  nb::object close_func_;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// Loading
+///////////////////////////////////////////////////////////////////////////////
+
+class PyFileReader : public mx::io::Reader {
+ public:
+  PyFileReader(nb::object file)
+      : pyistream_(file),
+        readinto_func_(file.attr("readinto")),
+        seek_func_(file.attr("seek")),
+        tell_func_(file.attr("tell")) {}
+
+  ~PyFileReader() {
+    nb::gil_scoped_acquire gil;
+
+    pyistream_.release().dec_ref();
+    readinto_func_.release().dec_ref();
+    seek_func_.release().dec_ref();
+    tell_func_.release().dec_ref();
+  }
+
+  bool is_open() const override {
+    bool out;
+    {
+      nb::gil_scoped_acquire gil;
+      out = !nb::cast<bool>(pyistream_.attr("closed"));
+    }
+    return out;
+  }
+
+  bool good() const override {
+    bool out;
+    {
+      nb::gil_scoped_acquire gil;
+      out = !pyistream_.is_none();
+    }
+    return out;
+  }
+
+  size_t tell() override {
+    size_t out;
+    {
+      nb::gil_scoped_acquire gil;
+      out = nb::cast<size_t>(tell_func_());
+    }
+    return out;
+  }
+
+  void seek(int64_t off, std::ios_base::seekdir way = std::ios_base::beg)
+      override {
+    nb::gil_scoped_acquire gil;
+    seek_func_(off, (int)way);
+  }
+
+  void read(char* data, size_t n) override {
+    nb::gil_scoped_acquire gil;
+    _read(data, n);
+  }
+
+  void read(char* data, size_t n, size_t offset) override {
+    nb::gil_scoped_acquire gil;
+    seek_func_(offset, (int)std::ios_base::beg);
+    _read(data, n);
+  }
+
+  std::string label() const override {
+    return "python file object";
+  }
+
+ private:
+  void _read(char* data, size_t n) {
+    auto memview = PyMemoryView_FromMemory(data, n, PyBUF_WRITE);
+    nb::object bytes_read = readinto_func_(nb::handle(memview));
+
+    if (bytes_read.is_none() || nb::cast<size_t>(bytes_read) < n) {
+      throw std::runtime_error("[load] Failed to read from python stream");
+    }
+  }
+
+  nb::object pyistream_;
+  nb::object readinto_func_;
+  nb::object seek_func_;
+  nb::object tell_func_;
+};
+
+std::pair<
+    std::unordered_map<std::string, mx::array>,
+    std::unordered_map<std::string, std::string>>
+mlx_load_safetensor_helper(nb::object file, mx::StreamOrDevice s) {
+  if (is_str_or_path(file)) { // Assume .safetensors file path string
+    auto file_str = nb::cast<std::string>(nb::str(file));
+    return mx::load_safetensors(file_str, s);
+  } else if (is_istream_object(file)) {
+    // If we don't own the stream and it was passed to us, eval immediately
+    auto res = mx::load_safetensors(std::make_shared<PyFileReader>(file), s);
+    {
+      nb::gil_scoped_release gil;
+      for (auto& [key, arr] : std::get<0>(res)) {
+        arr.eval();
+      }
+    }
+    return res;
+  }
+
+  throw std::invalid_argument(
+      "[load_safetensors] Input must be a file-like object, or string");
+}
+
+mx::GGUFLoad mlx_load_gguf_helper(nb::object file, mx::StreamOrDevice s) {
+  if (is_str_or_path(file)) { // Assume .gguf file path string
+    auto file_str = nb::cast<std::string>(nb::str(file));
+    return mx::load_gguf(file_str, s);
+  }
+
+  throw std::invalid_argument("[load_gguf] Input must be a string");
+}
+
+std::unordered_map<std::string, mx::array> mlx_load_npz_helper(
+    nb::object file,
+    mx::StreamOrDevice s) {
+  bool own_file = is_str_or_path(file);
+
+  nb::module_ zipfile = nb::module_::import_("zipfile");
+  if (!is_zip_file(zipfile, file)) {
+    throw std::invalid_argument(
+        "[load_npz] Input must be a zip file or a file-like object that can be "
+        "opened with zipfile.ZipFile");
+  }
+  // Output dictionary filename in zip -> loaded array
+  std::unordered_map<std::string, mx::array> array_dict;
+
+  // Create python ZipFile object
+  ZipFileWrapper zipfile_object(zipfile, file);
+  for (const std::string& st : zipfile_object.namelist()) {
+    // Open zip file as a python file stream
+    nb::object sub_file = zipfile_object.open(st);
+
+    // Create array from python file stream
+    auto arr = mx::load(std::make_shared<PyFileReader>(sub_file), s);
+
+    // Remove .npy from file if it is there
+    auto key = st;
+    if (st.length() > 4 && st.substr(st.length() - 4, 4) == ".npy")
+      key = st.substr(0, st.length() - 4);
+
+    // Add array to dict
+    array_dict.insert({key, arr});
+  }
+
+  // If we don't own the stream and it was passed to us, eval immediately
+  if (!own_file) {
+    nb::gil_scoped_release gil;
+    for (auto& [key, arr] : array_dict) {
+      arr.eval();
+    }
+  }
+
+  return array_dict;
+}
+
+mx::array mlx_load_npy_helper(nb::object file, mx::StreamOrDevice s) {
+  if (is_str_or_path(file)) { // Assume .npy file path string
+    auto file_str = nb::cast<std::string>(nb::str(file));
+    return mx::load(file_str, s);
+  } else if (is_istream_object(file)) {
+    // If we don't own the stream and it was passed to us, eval immediately
+    auto arr = mx::load(std::make_shared<PyFileReader>(file), s);
+    {
+      nb::gil_scoped_release gil;
+      arr.eval();
+    }
+    return arr;
+  }
+  throw std::invalid_argument(
+      "[load_npy] Input must be a file-like object, or string");
+}
+
+LoadOutputTypes mlx_load_helper(
+    nb::object file,
+    std::optional<std::string> format,
+    bool return_metadata,
+    mx::StreamOrDevice s) {
+  if (!format.has_value()) {
+    std::string fname;
+    if (is_str_or_path(file)) {
+      fname = nb::cast<std::string>(nb::str(file));
+    } else if (is_istream_object(file)) {
+      fname = nb::cast<std::string>(file.attr("name"));
+    } else {
+      throw std::invalid_argument(
+          "[load] Input must be a file-like object opened in binary mode, or string");
+    }
+    size_t ext = fname.find_last_of('.');
+    if (ext == std::string::npos) {
+      throw std::invalid_argument(
+          "[load] Could not infer file format from extension");
+    }
+    format.emplace(fname.substr(ext + 1));
+  }
+
+  if (return_metadata && (format.value() == "npy" || format.value() == "npz")) {
+    throw std::invalid_argument(
+        "[load] metadata not supported for format " + format.value());
+  }
+  if (format.value() == "safetensors") {
+    auto [dict, metadata] = mlx_load_safetensor_helper(file, s);
+    if (return_metadata) {
+      return std::make_pair(dict, metadata);
+    }
+    return dict;
+  } else if (format.value() == "npz") {
+    return mlx_load_npz_helper(file, s);
+  } else if (format.value() == "npy") {
+    return mlx_load_npy_helper(file, s);
+  } else if (format.value() == "gguf") {
+    auto [weights, metadata] = mlx_load_gguf_helper(file, s);
+    if (return_metadata) {
+      return std::make_pair(weights, metadata);
+    } else {
+      return weights;
+    }
+  } else {
+    throw std::invalid_argument("[load] Unknown file format " + format.value());
+  }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Saving
+///////////////////////////////////////////////////////////////////////////////
+
+class PyFileWriter : public mx::io::Writer {
+ public:
+  PyFileWriter(nb::object file)
+      : pyostream_(file),
+        write_func_(file.attr("write")),
+        seek_func_(file.attr("seek")),
+        tell_func_(file.attr("tell")) {}
+
+  ~PyFileWriter() {
+    nb::gil_scoped_acquire gil;
+
+    pyostream_.release().dec_ref();
+    write_func_.release().dec_ref();
+    seek_func_.release().dec_ref();
+    tell_func_.release().dec_ref();
+  }
+
+  bool is_open() const override {
+    bool out;
+    {
+      nb::gil_scoped_acquire gil;
+      out = !nb::cast<bool>(pyostream_.attr("closed"));
+    }
+    return out;
+  }
+
+  bool good() const override {
+    bool out;
+    {
+      nb::gil_scoped_acquire gil;
+      out = !pyostream_.is_none();
+    }
+    return out;
+  }
+
+  size_t tell() override {
+    size_t out;
+    {
+      nb::gil_scoped_acquire gil;
+      out = nb::cast<size_t>(tell_func_());
+    }
+    return out;
+  }
+
+  void seek(int64_t off, std::ios_base::seekdir way = std::ios_base::beg)
+      override {
+    nb::gil_scoped_acquire gil;
+    seek_func_(off, (int)way);
+  }
+
+  void write(const char* data, size_t n) override {
+    nb::gil_scoped_acquire gil;
+
+    auto memview =
+        PyMemoryView_FromMemory(const_cast<char*>(data), n, PyBUF_READ);
+    nb::object bytes_written = write_func_(nb::handle(memview));
+
+    if (bytes_written.is_none() || nb::cast<size_t>(bytes_written) < n) {
+      throw std::runtime_error("[load] Failed to write to python stream");
+    }
+  }
+
+  std::string label() const override {
+    return "python file object";
+  }
+
+ private:
+  nb::object pyostream_;
+  nb::object write_func_;
+  nb::object seek_func_;
+  nb::object tell_func_;
+};
+
+void mlx_save_helper(nb::object file, mx::array a) {
+  if (is_str_or_path(file)) {
+    auto file_str = nb::cast<std::string>(nb::str(file));
+    mx::save(file_str, a);
+    return;
+  } else if (is_ostream_object(file)) {
+    auto writer = std::make_shared<PyFileWriter>(file);
+    {
+      nb::gil_scoped_release gil;
+      mx::save(writer, a);
+    }
+
+    return;
+  }
+
+  throw std::invalid_argument(
+      "[save] Input must be a file-like object, or string");
+}
+
+void mlx_savez_helper(
+    nb::object file_,
+    nb::args args,
+    const nb::kwargs& kwargs,
+    bool compressed) {
+  // Add .npz to the end of the filename if not already there
+  nb::object file = file_;
+
+  if (is_str_or_path(file)) {
+    std::string fname = nb::cast<std::string>(nb::str(file_));
+
+    // Add .npz to file name if it is not there
+    if (fname.length() < 4 || fname.substr(fname.length() - 4, 4) != ".npz")
+      fname += ".npz";
+
+    file = nb::cast(fname);
+  }
+
+  // Collect args and kwargs
+  auto arrays_dict =
+      nb::cast<std::unordered_map<std::string, mx::array>>(kwargs);
+  auto arrays_list = nb::cast<std::vector<mx::array>>(args);
+
+  for (int i = 0; i < arrays_list.size(); i++) {
+    std::string arr_name = "arr_" + std::to_string(i);
+
+    if (arrays_dict.count(arr_name) > 0) {
+      throw std::invalid_argument(
+          "[savez] Cannot use un-named variables and keyword " + arr_name);
+    }
+
+    arrays_dict.insert({arr_name, arrays_list[i]});
+  }
+
+  // Create python ZipFile object depending on compression
+  nb::module_ zipfile = nb::module_::import_("zipfile");
+  int compression = nb::cast<int>(
+      compressed ? zipfile.attr("ZIP_DEFLATED") : zipfile.attr("ZIP_STORED"));
+  char mode = 'w';
+  ZipFileWrapper zipfile_object(zipfile, file, mode, compression);
+
+  // Save each array
+  for (auto [k, a] : arrays_dict) {
+    std::string fname = k + ".npy";
+    auto py_ostream = zipfile_object.open(fname, 'w');
+    auto writer = std::make_shared<PyFileWriter>(py_ostream);
+    {
+      nb::gil_scoped_release nogil;
+      mx::save(writer, a);
+    }
+  }
+
+  return;
+}
+
+void mlx_save_safetensor_helper(
+    nb::object file,
+    nb::dict d,
+    std::optional<nb::dict> m) {
+  std::unordered_map<std::string, std::string> metadata_map;
+  if (m) {
+    try {
+      metadata_map =
+          nb::cast<std::unordered_map<std::string, std::string>>(m.value());
+    } catch (const nb::cast_error& e) {
+      throw std::invalid_argument(
+          "[save_safetensors] Metadata must be a dictionary with string keys and values");
+    }
+  } else {
+    metadata_map = std::unordered_map<std::string, std::string>();
+  }
+  auto arrays_map = nb::cast<std::unordered_map<std::string, mx::array>>(d);
+  if (is_str_or_path(file)) {
+    {
+      auto file_str = nb::cast<std::string>(nb::str(file));
+      nb::gil_scoped_release nogil;
+      mx::save_safetensors(file_str, arrays_map, metadata_map);
+    }
+  } else if (is_ostream_object(file)) {
+    auto writer = std::make_shared<PyFileWriter>(file);
+    {
+      nb::gil_scoped_release nogil;
+      mx::save_safetensors(writer, arrays_map, metadata_map);
+    }
+  } else {
+    throw std::invalid_argument(
+        "[save_safetensors] Input must be a file-like object, or string");
+  }
+}
+
+void mlx_save_gguf_helper(
+    nb::object file,
+    nb::dict a,
+    std::optional<nb::dict> m) {
+  auto arrays_map = nb::cast<std::unordered_map<std::string, mx::array>>(a);
+  if (is_str_or_path(file)) {
+    if (m) {
+      auto metadata_map =
+          nb::cast<std::unordered_map<std::string, mx::GGUFMetaData>>(
+              m.value());
+      {
+        auto file_str = nb::cast<std::string>(nb::str(file));
+        nb::gil_scoped_release nogil;
+        mx::save_gguf(file_str, arrays_map, metadata_map);
+      }
+    } else {
+      {
+        auto file_str = nb::cast<std::string>(nb::str(file));
+        nb::gil_scoped_release nogil;
+        mx::save_gguf(file_str, arrays_map);
+      }
+    }
+  } else {
+    throw std::invalid_argument("[save_gguf] Input must be a string");
+  }
+}
diff --git a/ml-stable-diffusion/mlx/python/src/load.h b/ml-stable-diffusion/mlx/python/src/load.h
new file mode 100644
index 0000000000000000000000000000000000000000..4188822f9d9df7f3db0fe3eaded46f448ec7048e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/load.h
@@ -0,0 +1,51 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#pragma once
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/unordered_map.h>
+#include <nanobind/stl/variant.h>
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include "mlx/io.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+
+using LoadOutputTypes = std::variant<
+    mx::array,
+    std::unordered_map<std::string, mx::array>,
+    mx::SafetensorsLoad,
+    mx::GGUFLoad>;
+
+mx::SafetensorsLoad mlx_load_safetensor_helper(
+    nb::object file,
+    mx::StreamOrDevice s);
+void mlx_save_safetensor_helper(
+    nb::object file,
+    nb::dict d,
+    std::optional<nb::dict> m);
+
+mx::GGUFLoad mlx_load_gguf_helper(nb::object file, mx::StreamOrDevice s);
+
+void mlx_save_gguf_helper(
+    nb::object file,
+    nb::dict d,
+    std::optional<nb::dict> m);
+
+LoadOutputTypes mlx_load_helper(
+    nb::object file,
+    std::optional<std::string> format,
+    bool return_metadata,
+    mx::StreamOrDevice s);
+void mlx_save_helper(nb::object file, mx::array a);
+void mlx_savez_helper(
+    nb::object file,
+    nb::args args,
+    const nb::kwargs& kwargs,
+    bool compressed = false);
diff --git a/ml-stable-diffusion/mlx/python/src/memory.cpp b/ml-stable-diffusion/mlx/python/src/memory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5ce9a765bad61be29667f69ad428197942db02d5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/memory.cpp
@@ -0,0 +1,125 @@
+// Copyright © 2025 Apple Inc.
+
+#include "mlx/memory.h"
+#include <nanobind/nanobind.h>
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+void init_memory(nb::module_& m) {
+  m.def(
+      "get_active_memory",
+      &mx::get_active_memory,
+      R"pbdoc(
+      Get the actively used memory in bytes.
+
+      Note, this will not always match memory use reported by the system because
+      it does not include cached memory buffers.
+      )pbdoc");
+  m.def(
+      "get_peak_memory",
+      &mx::get_peak_memory,
+      R"pbdoc(
+      Get the peak amount of used memory in bytes.
+
+      The maximum memory used recorded from the beginning of the program
+      execution or since the last call to :func:`reset_peak_memory`.
+      )pbdoc");
+  m.def(
+      "reset_peak_memory",
+      &mx::reset_peak_memory,
+      R"pbdoc(
+      Reset the peak memory to zero.
+      )pbdoc");
+  m.def(
+      "get_cache_memory",
+      &mx::get_cache_memory,
+      R"pbdoc(
+      Get the cache size in bytes.
+
+      The cache includes memory not currently used that has not been returned
+      to the system allocator.
+      )pbdoc");
+  m.def(
+      "set_memory_limit",
+      &mx::set_memory_limit,
+      "limit"_a,
+      R"pbdoc(
+      Set the memory limit.
+
+      The memory limit is a guideline for the maximum amount of memory to use
+      during graph evaluation. If the memory limit is exceeded and there is no
+      more RAM (including swap when available) allocations will result in an
+      exception.
+
+      When metal is available the memory limit defaults to 1.5 times the
+      maximum recommended working set size reported by the device.
+
+      Args:
+        limit (int): Memory limit in bytes.
+
+      Returns:
+        int: The previous memory limit in bytes.
+      )pbdoc");
+  m.def(
+      "set_cache_limit",
+      &mx::set_cache_limit,
+      "limit"_a,
+      R"pbdoc(
+      Set the free cache limit.
+
+      If using more than the given limit, free memory will be reclaimed
+      from the cache on the next allocation. To disable the cache, set
+      the limit to ``0``.
+
+      The cache limit defaults to the memory limit. See
+      :func:`set_memory_limit` for more details.
+
+      Args:
+        limit (int): The cache limit in bytes.
+
+      Returns:
+        int: The previous cache limit in bytes.
+      )pbdoc");
+  m.def(
+      "set_wired_limit",
+      &mx::set_wired_limit,
+      "limit"_a,
+      R"pbdoc(
+      Set the wired size limit.
+
+      .. note::
+         * This function is only useful on macOS 15.0 or higher.
+         * The wired limit should remain strictly less than the total
+           memory size.
+
+      The wired limit is the total size in bytes of memory that will be kept
+      resident. The default value is ``0``.
+
+      Setting a wired limit larger than system wired limit is an error. You can
+      increase the system wired limit with:
+
+      .. code-block::
+
+        sudo sysctl iogpu.wired_limit_mb=<size_in_megabytes>
+
+      Use :func:`device_info` to query the system wired limit
+      (``"max_recommended_working_set_size"``) and the total memory size
+      (``"memory_size"``).
+
+      Args:
+        limit (int): The wired limit in bytes.
+
+      Returns:
+        int: The previous wired limit in bytes.
+      )pbdoc");
+  m.def(
+      "clear_cache",
+      &mx::clear_cache,
+      R"pbdoc(
+      Clear the memory cache.
+
+      After calling this, :func:`get_cache_memory` should return ``0``.
+      )pbdoc");
+}
diff --git a/ml-stable-diffusion/mlx/python/src/metal.cpp b/ml-stable-diffusion/mlx/python/src/metal.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a56674428b0f31cf236625f8c83584b5e1022074
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/metal.cpp
@@ -0,0 +1,110 @@
+// Copyright © 2023-2024 Apple Inc.
+#include <iostream>
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/unordered_map.h>
+#include <nanobind/stl/variant.h>
+#include <nanobind/stl/vector.h>
+
+#include "mlx/backend/metal/metal.h"
+#include "mlx/memory.h"
+#include "python/src/small_vector.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+bool DEPRECATE(const char* old_fn, const char* new_fn) {
+  std::cerr << old_fn << " is deprecated and will be removed in a future "
+            << "version. Use " << new_fn << " instead." << std::endl;
+  return true;
+}
+
+#define DEPRECATE(oldfn, newfn) static bool dep = DEPRECATE(oldfn, newfn)
+
+void init_metal(nb::module_& m) {
+  nb::module_ metal = m.def_submodule("metal", "mlx.metal");
+  metal.def(
+      "is_available",
+      &mx::metal::is_available,
+      R"pbdoc(
+      Check if the Metal back-end is available.
+      )pbdoc");
+  metal.def("get_active_memory", []() {
+    DEPRECATE("mx.metal.get_active_memory", "mx.get_active_memory");
+    return mx::get_active_memory();
+  });
+  metal.def("get_peak_memory", []() {
+    DEPRECATE("mx.metal.get_peak_memory", "mx.get_peak_memory");
+    return mx::get_peak_memory();
+  });
+  metal.def("reset_peak_memory", []() {
+    DEPRECATE("mx.metal.reset_peak_memory", "mx.reset_peak_memory");
+    mx::reset_peak_memory();
+  });
+  metal.def("get_cache_memory", []() {
+    DEPRECATE("mx.metal.get_cache_memory", "mx.get_cache_memory");
+    return mx::get_cache_memory();
+  });
+  metal.def(
+      "set_memory_limit",
+      [](size_t limit) {
+        DEPRECATE("mx.metal.set_memory_limit", "mx.set_memory_limit");
+        return mx::set_memory_limit(limit);
+      },
+      "limit"_a);
+  metal.def(
+      "set_cache_limit",
+      [](size_t limit) {
+        DEPRECATE("mx.metal.set_cache_limit", "mx.set_cache_limit");
+        return mx::set_cache_limit(limit);
+      },
+      "limit"_a);
+  metal.def(
+      "set_wired_limit",
+      [](size_t limit) {
+        DEPRECATE("mx.metal.set_wired_limit", "mx.set_wired_limit");
+        return mx::set_wired_limit(limit);
+      },
+      "limit"_a);
+  metal.def("clear_cache", []() {
+    DEPRECATE("mx.metal.clear_cache", "mx.clear_cache");
+    mx::clear_cache();
+  });
+  metal.def(
+      "start_capture",
+      &mx::metal::start_capture,
+      "path"_a,
+      R"pbdoc(
+      Start a Metal capture.
+
+      Args:
+        path (str): The path to save the capture which should have
+          the extension ``.gputrace``.
+      )pbdoc");
+  metal.def(
+      "stop_capture",
+      &mx::metal::stop_capture,
+      R"pbdoc(
+      Stop a Metal capture.
+      )pbdoc");
+  metal.def(
+      "device_info",
+      &mx::metal::device_info,
+      R"pbdoc(
+      Get information about the GPU device and system settings.
+
+      Currently returns:
+
+      * ``architecture``
+      * ``max_buffer_size``
+      * ``max_recommended_working_set_size``
+      * ``memory_size``
+      * ``resource_limit``
+
+      Returns:
+          dict: A dictionary with string keys and string or integer values.
+      )pbdoc");
+}
diff --git a/ml-stable-diffusion/mlx/python/src/mlx.cpp b/ml-stable-diffusion/mlx/python/src/mlx.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0921d2ceaa2c0e62dcaaa62452554c9a69011be9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/mlx.cpp
@@ -0,0 +1,52 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <nanobind/nanobind.h>
+
+#include "mlx/version.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+
+void init_mlx_func(nb::module_&);
+void init_array(nb::module_&);
+void init_device(nb::module_&);
+void init_stream(nb::module_&);
+void init_metal(nb::module_&);
+void init_cuda(nb::module_&);
+void init_memory(nb::module_&);
+void init_ops(nb::module_&);
+void init_transforms(nb::module_&);
+void init_random(nb::module_&);
+void init_fft(nb::module_&);
+void init_linalg(nb::module_&);
+void init_constants(nb::module_&);
+void init_fast(nb::module_&);
+void init_distributed(nb::module_&);
+void init_export(nb::module_&);
+
+NB_MODULE(core, m) {
+  m.doc() = "mlx: A framework for machine learning on Apple silicon.";
+
+  auto reprlib_fix = nb::module_::import_("mlx._reprlib_fix");
+  nb::module_::import_("mlx._os_warning");
+  nb::set_leak_warnings(false);
+
+  init_mlx_func(m);
+  init_device(m);
+  init_stream(m);
+  init_array(m);
+  init_metal(m);
+  init_cuda(m);
+  init_memory(m);
+  init_ops(m);
+  init_transforms(m);
+  init_random(m);
+  init_fft(m);
+  init_linalg(m);
+  init_constants(m);
+  init_fast(m);
+  init_distributed(m);
+  init_export(m);
+
+  m.attr("__version__") = mx::version();
+}
diff --git a/ml-stable-diffusion/mlx/python/src/mlx_func.cpp b/ml-stable-diffusion/mlx/python/src/mlx_func.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..87912fdda361b8d325c60a59f1530ea3157e2550
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/mlx_func.cpp
@@ -0,0 +1,115 @@
+// Copyright © 2025 Apple Inc.
+
+#include "python/src/mlx_func.h"
+
+// A garbage collected function which wraps nb::cpp_function
+// See https://github.com/wjakob/nanobind/discussions/919
+
+struct gc_func {
+  PyObject_HEAD
+      // Vector call implementation that forwards calls to nanobind
+      PyObject* (*vectorcall)(PyObject*, PyObject* const*, size_t, PyObject*);
+  // The nanobind wrapper func
+  PyObject* func;
+
+  // The original wrapped func
+  PyObject* orig_func;
+  // A non-owning reference to dependencies owned by 'func'
+  std::vector<PyObject*> deps;
+};
+
+int gc_func_tp_traverse(PyObject* self, visitproc visit, void* arg) {
+  Py_VISIT(Py_TYPE(self));
+  gc_func* w = (gc_func*)self;
+  Py_VISIT(w->func);
+  for (auto d : w->deps) {
+    Py_VISIT(d);
+  }
+  return 0;
+};
+
+int gc_func_tp_clear(PyObject* self) {
+  gc_func* w = (gc_func*)self;
+  Py_CLEAR(w->func);
+  return 0;
+}
+
+PyObject* gc_func_get_doc(PyObject* self, void*) {
+  return PyObject_GetAttrString(((gc_func*)self)->func, "__doc__");
+}
+
+PyObject* gc_func_get_sig(PyObject* self, void*) {
+  return PyObject_GetAttrString(((gc_func*)self)->func, "__nb_signature__");
+}
+
+PyObject* gc_func_vectorcall(
+    PyObject* self,
+    PyObject* const* args,
+    size_t nargs,
+    PyObject* kwnames) {
+  return PyObject_Vectorcall(((gc_func*)self)->func, args, nargs, kwnames);
+}
+
+void gc_func_dealloc(PyObject* self) {
+  PyObject_GC_UnTrack(self);
+  Py_XDECREF(((gc_func*)self)->func);
+  PyObject_GC_Del(self);
+}
+
+static PyMemberDef gc_func_members[] = {
+    {"__vectorcalloffset__",
+     T_PYSSIZET,
+     (Py_ssize_t)offsetof(gc_func, vectorcall),
+     READONLY,
+     nullptr},
+    {nullptr, 0, 0, 0, nullptr}};
+
+static PyGetSetDef gc_func_getset[] = {
+    {"__doc__", gc_func_get_doc, nullptr, nullptr, nullptr},
+    {"__nb_signature__", gc_func_get_sig, nullptr, nullptr, nullptr},
+    {nullptr, nullptr, nullptr, nullptr, nullptr}};
+
+static PyObject* gc_func_getattro(PyObject* self, PyObject* name_) {
+  gc_func* w = (gc_func*)self;
+  return PyObject_GenericGetAttr(w->orig_func, name_);
+}
+
+// Table of custom type slots we want to install
+PyType_Slot gc_func_slots[] = {
+    {Py_tp_traverse, (void*)gc_func_tp_traverse},
+    {Py_tp_clear, (void*)gc_func_tp_clear},
+    {Py_tp_getset, (void*)gc_func_getset},
+    {Py_tp_getattro, (void*)gc_func_getattro},
+    {Py_tp_members, (void*)gc_func_members},
+    {Py_tp_call, (void*)PyVectorcall_Call},
+    {Py_tp_dealloc, (void*)gc_func_dealloc},
+    {0, 0}};
+
+static PyType_Spec gc_func_spec = {
+    /* .name = */ "mlx.gc_func",
+    /* .basicsize = */ (int)sizeof(gc_func),
+    /* .itemsize = */ 0,
+    /* .flags = */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | NB_HAVE_VECTORCALL,
+    /* .slots = */ gc_func_slots};
+
+static PyTypeObject* gc_func_tp = nullptr;
+
+nb::callable mlx_func(
+    nb::object func,
+    const nb::callable& orig_func,
+    std::vector<PyObject*> deps) {
+  gc_func* r = (gc_func*)PyType_GenericAlloc(gc_func_tp, 0);
+  r->func = func.inc_ref().ptr();
+  r->orig_func = orig_func.ptr();
+  deps.push_back(r->orig_func);
+  r->deps = std::move(deps);
+  r->vectorcall = gc_func_vectorcall;
+  return nb::steal<nb::callable>((PyObject*)r);
+}
+
+void init_mlx_func(nb::module_& m) {
+  gc_func_tp = (PyTypeObject*)PyType_FromSpec(&gc_func_spec);
+  if (!gc_func_tp) {
+    nb::raise("Could not register MLX function type.");
+  }
+}
diff --git a/ml-stable-diffusion/mlx/python/src/mlx_func.h b/ml-stable-diffusion/mlx/python/src/mlx_func.h
new file mode 100644
index 0000000000000000000000000000000000000000..79c8376dee7349e02c00ff75c2c7ba1f3ba57f0c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/mlx_func.h
@@ -0,0 +1,31 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include <vector>
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/function.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+nb::callable mlx_func(
+    nb::object func,
+    const nb::callable& orig_func,
+    std::vector<PyObject*> deps);
+
+template <typename F, typename... Deps>
+nb::callable mlx_func(F func, const nb::callable& orig_func, Deps&&... deps) {
+  return mlx_func(
+      nb::cpp_function(std::move(func)),
+      orig_func,
+      std::vector<PyObject*>{deps.ptr()...});
+}
+
+template <typename... Deps>
+nb::callable
+mlx_func(nb::object func, const nb::callable& orig_func, Deps&&... deps) {
+  return mlx_func(
+      std::move(func), orig_func, std::vector<PyObject*>{deps.ptr()...});
+}
diff --git a/ml-stable-diffusion/mlx/python/src/ops.cpp b/ml-stable-diffusion/mlx/python/src/ops.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..27d330d6e70334abc51c7f4253bfb1027dfaca29
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/ops.cpp
@@ -0,0 +1,5362 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <numeric>
+#include <ostream>
+#include <variant>
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/pair.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>
+#include <nanobind/stl/variant.h>
+#include <nanobind/stl/vector.h>
+
+#include "mlx/einsum.h"
+#include "mlx/ops.h"
+#include "mlx/utils.h"
+#include "python/src/load.h"
+#include "python/src/small_vector.h"
+#include "python/src/utils.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+using Scalar = std::variant<bool, int, double>;
+
+mx::Dtype scalar_to_dtype(Scalar s) {
+  if (std::holds_alternative<int>(s)) {
+    return mx::int32;
+  } else if (std::holds_alternative<double>(s)) {
+    return mx::float32;
+  } else {
+    return mx::bool_;
+  }
+}
+
+double scalar_to_double(Scalar s) {
+  if (auto pv = std::get_if<int>(&s); pv) {
+    return static_cast<double>(*pv);
+  } else if (auto pv = std::get_if<double>(&s); pv) {
+    return *pv;
+  } else {
+    return static_cast<double>(std::get<bool>(s));
+  }
+}
+
+void init_ops(nb::module_& m) {
+  m.def(
+      "reshape",
+      &mx::reshape,
+      nb::arg(),
+      "shape"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig("def reshape(a: array, /, shape: Sequence[int], *, stream: "
+              "Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Reshape an array while preserving the size.
+
+        Args:
+            a (array): Input array.
+            shape (tuple(int)): New shape.
+            stream (Stream, optional): Stream or device. Defaults to ``None``
+              in which case the default stream of the default device is used.
+
+        Returns:
+            array: The reshaped array.
+      )pbdoc");
+  m.def(
+      "flatten",
+      [](const mx::array& a,
+         int start_axis,
+         int end_axis,
+         const mx::StreamOrDevice& s) {
+        return mx::flatten(a, start_axis, end_axis);
+      },
+      nb::arg(),
+      "start_axis"_a = 0,
+      "end_axis"_a = -1,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig("def flatten(a: array, /, start_axis: int = 0, end_axis: int = "
+              "-1, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+      Flatten an array.
+
+      The axes flattened will be between ``start_axis`` and ``end_axis``,
+      inclusive. Negative axes are supported. After converting negative axis to
+      positive, axes outside the valid range will be clamped to a valid value,
+      ``start_axis`` to ``0`` and ``end_axis`` to ``ndim - 1``.
+
+      Args:
+          a (array): Input array.
+          start_axis (int, optional): The first dimension to flatten. Defaults to ``0``.
+          end_axis (int, optional): The last dimension to flatten. Defaults to ``-1``.
+          stream (Stream, optional): Stream or device. Defaults to ``None``
+            in which case the default stream of the default device is used.
+
+      Returns:
+          array: The flattened array.
+
+      Example:
+          >>> a = mx.array([[1, 2], [3, 4]])
+          >>> mx.flatten(a)
+          array([1, 2, 3, 4], dtype=int32)
+          >>>
+          >>> mx.flatten(a, start_axis=0, end_axis=-1)
+          array([1, 2, 3, 4], dtype=int32)
+  )pbdoc");
+  m.def(
+      "unflatten",
+      &mx::unflatten,
+      nb::arg(),
+      "axis"_a,
+      "shape"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def unflatten(a: array, /, axis: int, shape: Sequence[int], *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+      Unflatten an axis of an array to a shape.
+
+      Args:
+          a (array): Input array.
+          axis (int): The axis to unflatten.
+          shape (tuple(int)): The shape to unflatten to. At most one
+            entry can be ``-1`` in which case the corresponding size will be
+            inferred.
+          stream (Stream, optional): Stream or device. Defaults to ``None``
+            in which case the default stream of the default device is used.
+
+      Returns:
+          array: The unflattened array.
+
+      Example:
+          >>> a = mx.array([1, 2, 3, 4])
+          >>> mx.unflatten(a, 0, (2, -1))
+          array([[1, 2], [3, 4]], dtype=int32)
+  )pbdoc");
+  m.def(
+      "squeeze",
+      [](const mx::array& a, const IntOrVec& v, const mx::StreamOrDevice& s) {
+        if (std::holds_alternative<std::monostate>(v)) {
+          return mx::squeeze(a, s);
+        } else if (auto pv = std::get_if<int>(&v); pv) {
+          return mx::squeeze(a, *pv, s);
+        } else {
+          return mx::squeeze(a, std::get<std::vector<int>>(v), s);
+        }
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def squeeze(a: array, /, axis: Union[None, int, Sequence[int]] = "
+          "None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Remove length one axes from an array.
+
+        Args:
+            a (array): Input array.
+            axis (int or tuple(int), optional): Axes to remove. Defaults
+              to ``None`` in which case all size one axes are removed.
+
+        Returns:
+            array: The output array with size one axes removed.
+      )pbdoc");
+  m.def(
+      "expand_dims",
+      [](const mx::array& a,
+         const std::variant<int, std::vector<int>>& v,
+         mx::StreamOrDevice s) {
+        if (auto pv = std::get_if<int>(&v); pv) {
+          return mx::expand_dims(a, *pv, s);
+        } else {
+          return mx::expand_dims(a, std::get<std::vector<int>>(v), s);
+        }
+      },
+      nb::arg(),
+      "axis"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig("def expand_dims(a: array, /, axis: Union[int, Sequence[int]], "
+              "*, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Add a size one dimension at the given axis.
+
+        Args:
+            a (array): Input array.
+            axes (int or tuple(int)): The index of the inserted dimensions.
+
+        Returns:
+            array: The array with inserted dimensions.
+      )pbdoc");
+  m.def(
+      "abs",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::abs(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def abs(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise absolute value.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The absolute value of ``a``.
+      )pbdoc");
+  m.def(
+      "sign",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::sign(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def sign(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise sign.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The sign of ``a``.
+      )pbdoc");
+  m.def(
+      "negative",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::negative(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def negative(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise negation.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The negative of ``a``.
+      )pbdoc");
+  m.def(
+      "add",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::add(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def add(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise addition.
+
+        Add two arrays with numpy-style broadcasting semantics. Either or both input arrays
+        can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The sum of ``a`` and ``b``.
+      )pbdoc");
+  m.def(
+      "subtract",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::subtract(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def subtract(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise subtraction.
+
+        Subtract one array from another with numpy-style broadcasting semantics. Either or both
+        input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The difference ``a - b``.
+      )pbdoc");
+  m.def(
+      "multiply",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::multiply(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def multiply(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise multiplication.
+
+        Multiply two arrays with numpy-style broadcasting semantics. Either or both
+        input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The multiplication ``a * b``.
+      )pbdoc");
+  m.def(
+      "divide",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::divide(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def divide(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise division.
+
+        Divide two arrays with numpy-style broadcasting semantics. Either or both
+        input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The quotient ``a / b``.
+      )pbdoc");
+  m.def(
+      "divmod",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::divmod(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def divmod(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise quotient and remainder.
+
+        The fuction ``divmod(a, b)`` is equivalent to but faster than
+        ``(a // b, a % b)``. The function uses numpy-style broadcasting
+        semantics. Either or both input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            tuple(array, array): The quotient ``a // b`` and remainder ``a % b``.
+      )pbdoc");
+  m.def(
+      "floor_divide",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::floor_divide(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def floor_divide(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise integer division.
+
+        If either array is a floating point type then it is equivalent to
+        calling :func:`floor` after :func:`divide`.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The quotient ``a // b``.
+      )pbdoc");
+  m.def(
+      "remainder",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::remainder(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def remainder(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise remainder of division.
+
+        Computes the remainder of dividing a with b with numpy-style
+        broadcasting semantics. Either or both input arrays can also be
+        scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The remainder of ``a // b``.
+      )pbdoc");
+  m.def(
+      "equal",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::equal(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def equal(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise equality.
+
+        Equality comparison on two arrays with numpy-style broadcasting semantics.
+        Either or both input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The element-wise comparison ``a == b``.
+      )pbdoc");
+  m.def(
+      "not_equal",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::not_equal(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def not_equal(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise not equal.
+
+        Not equal comparison on two arrays with numpy-style broadcasting semantics.
+        Either or both input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The element-wise comparison ``a != b``.
+      )pbdoc");
+  m.def(
+      "less",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::less(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def less(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise less than.
+
+        Strict less than on two arrays with numpy-style broadcasting semantics.
+        Either or both input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The element-wise comparison ``a < b``.
+      )pbdoc");
+  m.def(
+      "less_equal",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::less_equal(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def less_equal(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise less than or equal.
+
+        Less than or equal on two arrays with numpy-style broadcasting semantics.
+        Either or both input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The element-wise comparison ``a <= b``.
+      )pbdoc");
+  m.def(
+      "greater",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::greater(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def greater(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise greater than.
+
+        Strict greater than on two arrays with numpy-style broadcasting semantics.
+        Either or both input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The element-wise comparison ``a > b``.
+      )pbdoc");
+  m.def(
+      "greater_equal",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::greater_equal(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def greater_equal(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise greater or equal.
+
+        Greater than or equal on two arrays with numpy-style broadcasting semantics.
+        Either or both input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The element-wise comparison ``a >= b``.
+      )pbdoc");
+  m.def(
+      "array_equal",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         bool equal_nan,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::array_equal(a, b, equal_nan, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "equal_nan"_a = false,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def array_equal(a: Union[scalar, array], b: Union[scalar, array], equal_nan: bool = False, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Array equality check.
+
+        Compare two arrays for equality. Returns ``True`` if and only if the arrays
+        have the same shape and their values are equal. The arrays need not have
+        the same type to be considered equal.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+            equal_nan (bool): If ``True``, NaNs are considered equal.
+              Defaults to ``False``.
+
+        Returns:
+            array: A scalar boolean array.
+      )pbdoc");
+  m.def(
+      "matmul",
+      &mx::matmul,
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def matmul(a: array, b: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Matrix multiplication.
+
+        Perform the (possibly batched) matrix multiplication of two arrays. This function supports
+        broadcasting for arrays with more than two dimensions.
+
+        - If the first array is 1-D then a 1 is prepended to its shape to make it
+          a matrix. Similarly if the second array is 1-D then a 1 is appended to its
+          shape to make it a matrix. In either case the singleton dimension is removed
+          from the result.
+        - A batched matrix multiplication is performed if the arrays have more than
+          2 dimensions.  The matrix dimensions for the matrix product are the last
+          two dimensions of each input.
+        - All but the last two dimensions of each input are broadcast with one another using
+          standard numpy-style broadcasting semantics.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The matrix product of ``a`` and ``b``.
+      )pbdoc");
+  m.def(
+      "square",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::square(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def square(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise square.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The square of ``a``.
+      )pbdoc");
+  m.def(
+      "sqrt",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::sqrt(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def sqrt(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise square root.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The square root of ``a``.
+      )pbdoc");
+  m.def(
+      "rsqrt",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::rsqrt(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def rsqrt(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise reciprocal and square root.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: One over the square root of ``a``.
+      )pbdoc");
+  m.def(
+      "reciprocal",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::reciprocal(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def reciprocal(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise reciprocal.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The reciprocal of ``a``.
+      )pbdoc");
+  m.def(
+      "logical_not",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::logical_not(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def logical_not(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise logical not.
+
+        Args:
+            a (array): Input array or scalar.
+
+        Returns:
+            array: The boolean array containing the logical not of ``a``.
+      )pbdoc");
+  m.def(
+      "logical_and",
+      [](const ScalarOrArray& a, const ScalarOrArray& b, mx::StreamOrDevice s) {
+        return mx::logical_and(to_array(a), to_array(b), s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def logical_and(a: array, b: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise logical and.
+
+        Args:
+            a (array): First input array or scalar.
+            b (array): Second input array or scalar.
+
+        Returns:
+            array: The boolean array containing the logical and of ``a`` and ``b``.
+    )pbdoc");
+
+  m.def(
+      "logical_or",
+      [](const ScalarOrArray& a, const ScalarOrArray& b, mx::StreamOrDevice s) {
+        return mx::logical_or(to_array(a), to_array(b), s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def logical_or(a: array, b: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise logical or.
+
+        Args:
+            a (array): First input array or scalar.
+            b (array): Second input array or scalar.
+
+        Returns:
+            array: The boolean array containing the logical or of ``a`` and ``b``.
+    )pbdoc");
+  m.def(
+      "logaddexp",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::logaddexp(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def logaddexp(a: Union[scalar, array], b: Union[scalar, array], /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise log-add-exp.
+
+        This is a numerically stable log-add-exp of two arrays with numpy-style
+        broadcasting semantics. Either or both input arrays can also be scalars.
+
+        The computation is is a numerically stable version of ``log(exp(a) + exp(b))``.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The log-add-exp of ``a`` and ``b``.
+      )pbdoc");
+  m.def(
+      "exp",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::exp(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def exp(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise exponential.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The exponential of ``a``.
+      )pbdoc");
+  m.def(
+      "expm1",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::expm1(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def expm1(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise exponential minus 1.
+
+        Computes ``exp(x) - 1`` with greater precision for small ``x``.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The expm1 of ``a``.
+      )pbdoc");
+  m.def(
+      "erf",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::erf(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def erf(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise error function.
+
+        .. math::
+          \mathrm{erf}(x) = \frac{2}{\sqrt{\pi}} \int_0^x e^{-t^2} \, dt
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The error function of ``a``.
+      )pbdoc");
+  m.def(
+      "erfinv",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::erfinv(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def erfinv(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise inverse of :func:`erf`.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The inverse error function of ``a``.
+      )pbdoc");
+  m.def(
+      "sin",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::sin(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def sin(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise sine.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The sine of ``a``.
+      )pbdoc");
+  m.def(
+      "cos",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::cos(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def cos(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise cosine.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The cosine of ``a``.
+      )pbdoc");
+  m.def(
+      "tan",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::tan(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def tan(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise tangent.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The tangent of ``a``.
+      )pbdoc");
+  m.def(
+      "arcsin",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::arcsin(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def arcsin(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise inverse sine.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The inverse sine of ``a``.
+      )pbdoc");
+  m.def(
+      "arccos",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::arccos(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def arccos(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise inverse cosine.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The inverse cosine of ``a``.
+      )pbdoc");
+  m.def(
+      "arctan",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::arctan(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def arctan(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise inverse tangent.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The inverse tangent of ``a``.
+      )pbdoc");
+  m.def(
+      "arctan2",
+      &mx::arctan2,
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def arctan2(a: array, b: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise inverse tangent of the ratio of two arrays.
+
+        Args:
+            a (array): Input array.
+            b (array): Input array.
+
+        Returns:
+            array: The inverse tangent of the ratio of ``a`` and ``b``.
+      )pbdoc");
+  m.def(
+      "sinh",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::sinh(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def sinh(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise hyperbolic sine.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The hyperbolic sine of ``a``.
+      )pbdoc");
+  m.def(
+      "cosh",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::cosh(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def cosh(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise hyperbolic cosine.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The hyperbolic cosine of ``a``.
+      )pbdoc");
+  m.def(
+      "tanh",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::tanh(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def tanh(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise hyperbolic tangent.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The hyperbolic tangent of ``a``.
+      )pbdoc");
+  m.def(
+      "arcsinh",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::arcsinh(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def arcsinh(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise inverse hyperbolic sine.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The inverse hyperbolic sine of ``a``.
+      )pbdoc");
+  m.def(
+      "arccosh",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::arccosh(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def arccosh(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise inverse hyperbolic cosine.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The inverse hyperbolic cosine of ``a``.
+      )pbdoc");
+  m.def(
+      "arctanh",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::arctanh(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def arctanh(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise inverse hyperbolic tangent.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The inverse hyperbolic tangent of ``a``.
+      )pbdoc");
+  m.def(
+      "degrees",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::degrees(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def degrees(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+      Convert angles from radians to degrees.
+
+      Args:
+          a (array): Input array.
+
+      Returns:
+          array: The angles in degrees.
+    )pbdoc");
+  m.def(
+      "radians",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::radians(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def radians(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+      Convert angles from degrees to radians.
+
+      Args:
+          a (array): Input array.
+
+      Returns:
+          array: The angles in radians.
+    )pbdoc");
+  m.def(
+      "log",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::log(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def log(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise natural logarithm.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The natural logarithm of ``a``.
+      )pbdoc");
+  m.def(
+      "log2",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::log2(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def log2(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise base-2 logarithm.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The base-2 logarithm of ``a``.
+      )pbdoc");
+  m.def(
+      "log10",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::log10(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def log10(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise base-10 logarithm.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The base-10 logarithm of ``a``.
+      )pbdoc");
+  m.def(
+      "log1p",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::log1p(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def log1p(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise natural log of one plus the array.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The natural logarithm of one plus ``a``.
+      )pbdoc");
+  m.def(
+      "stop_gradient",
+      &mx::stop_gradient,
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def stop_gradient(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Stop gradients from being computed.
+
+        The operation is the identity but it prevents gradients from flowing
+        through the array.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array:
+              The unchanged input ``a`` but without gradient flowing
+              through it.
+      )pbdoc");
+  m.def(
+      "sigmoid",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::sigmoid(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def sigmoid(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise logistic sigmoid.
+
+        The logistic sigmoid function is:
+
+        .. math::
+          \mathrm{sigmoid}(x) = \frac{1}{1 + e^{-x}}
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The logistic sigmoid of ``a``.
+      )pbdoc");
+  m.def(
+      "power",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::power(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def power(a: Union[scalar, array], b: Union[scalar, array], /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise power operation.
+
+        Raise the elements of a to the powers in elements of b with numpy-style
+        broadcasting semantics. Either or both input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: Bases of ``a`` raised to powers in ``b``.
+      )pbdoc");
+  m.def(
+      "arange",
+      [](Scalar start,
+         Scalar stop,
+         const std::optional<Scalar>& step,
+         const std::optional<mx::Dtype>& dtype_,
+         mx::StreamOrDevice s) {
+        // Determine the final dtype based on input types
+        mx::Dtype dtype = dtype_
+            ? *dtype_
+            : mx::promote_types(
+                  scalar_to_dtype(start),
+                  step ? mx::promote_types(
+                             scalar_to_dtype(stop), scalar_to_dtype(*step))
+                       : scalar_to_dtype(stop));
+        return mx::arange(
+            scalar_to_double(start),
+            scalar_to_double(stop),
+            step ? scalar_to_double(*step) : 1.0,
+            dtype,
+            s);
+      },
+      "start"_a.noconvert(),
+      "stop"_a.noconvert(),
+      "step"_a.noconvert() = nb::none(),
+      "dtype"_a = nb::none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def arange(start : Union[int, float], stop : Union[int, float], step : Union[None, int, float], dtype: Optional[Dtype] = None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+      Generates ranges of numbers.
+
+      Generate numbers in the half-open interval ``[start, stop)`` in
+      increments of ``step``.
+
+      Args:
+          start (float or int, optional): Starting value which defaults to ``0``.
+          stop (float or int): Stopping value.
+          step (float or int, optional): Increment which defaults to ``1``.
+          dtype (Dtype, optional): Specifies the data type of the output. If unspecified will default to ``float32`` if any of ``start``, ``stop``, or ``step`` are ``float``. Otherwise will default to ``int32``.
+
+      Returns:
+          array: The range of values.
+
+      Note:
+        Following the Numpy convention the actual increment used to
+        generate numbers is ``dtype(start + step) - dtype(start)``.
+        This can lead to unexpected results for example if `start + step`
+        is a fractional value and the `dtype` is integral.
+      )pbdoc");
+  m.def(
+      "arange",
+      [](Scalar stop,
+         const std::optional<Scalar>& step,
+         const std::optional<mx::Dtype>& dtype_,
+         mx::StreamOrDevice s) {
+        mx::Dtype dtype = dtype_ ? *dtype_
+            : step
+            ? mx::promote_types(scalar_to_dtype(stop), scalar_to_dtype(*step))
+            : scalar_to_dtype(stop);
+        return mx::arange(
+            0.0,
+            scalar_to_double(stop),
+            step ? scalar_to_double(*step) : 1.0,
+            dtype,
+            s);
+      },
+      "stop"_a.noconvert(),
+      "step"_a.noconvert() = nb::none(),
+      "dtype"_a = nb::none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def arange(stop : Union[int, float], step : Union[None, int, float] = None, dtype: Optional[Dtype] = None, *, stream: Union[None, Stream, Device] = None) -> array"));
+  m.def(
+      "linspace",
+      [](Scalar start,
+         Scalar stop,
+         int num,
+         std::optional<mx::Dtype> dtype,
+         mx::StreamOrDevice s) {
+        return mx::linspace(
+            scalar_to_double(start),
+            scalar_to_double(stop),
+            num,
+            dtype.value_or(mx::float32),
+            s);
+      },
+      "start"_a,
+      "stop"_a,
+      "num"_a = 50,
+      "dtype"_a.none() = mx::float32,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def linspace(start, stop, num: Optional[int] = 50, dtype: Optional[Dtype] = float32, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Generate ``num`` evenly spaced numbers over interval ``[start, stop]``.
+
+        Args:
+            start (scalar): Starting value.
+            stop (scalar): Stopping value.
+            num (int, optional): Number of samples, defaults to ``50``.
+            dtype (Dtype, optional): Specifies the data type of the output,
+              default to ``float32``.
+
+        Returns:
+            array: The range of values.
+      )pbdoc");
+  m.def(
+      "kron",
+      &mx::kron,
+      nb::arg("a"),
+      nb::arg("b"),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def kron(a: array, b: array, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Compute the Kronecker product of two arrays ``a`` and ``b``.
+
+        Args:
+          a (array): The first input array.
+          b (array): The second input array.
+          stream (Union[None, Stream, Device], optional): Optional stream or
+            device for execution. Default: ``None``.
+
+        Returns:
+          array: The Kronecker product of ``a`` and ``b``.
+
+        Examples:
+          >>> a = mx.array([[1, 2], [3, 4]])
+          >>> b = mx.array([[0, 5], [6, 7]])
+          >>> result = mx.kron(a, b)
+          >>> print(result)
+          array([[0, 5, 0, 10],
+                 [6, 7, 12, 14],
+                 [0, 15, 0, 20],
+                 [18, 21, 24, 28]], dtype=int32)
+      )pbdoc");
+  m.def(
+      "take",
+      [](const mx::array& a,
+         const std::variant<nb::int_, mx::array>& indices,
+         const std::optional<int>& axis,
+         mx::StreamOrDevice s) {
+        if (auto pv = std::get_if<nb::int_>(&indices); pv) {
+          auto idx = nb::cast<int>(*pv);
+          return axis ? mx::take(a, idx, axis.value(), s) : mx::take(a, idx, s);
+        } else {
+          auto indices_ = std::get<mx::array>(indices);
+          return axis ? mx::take(a, indices_, axis.value(), s)
+                      : mx::take(a, indices_, s);
+        }
+      },
+      nb::arg(),
+      "indices"_a,
+      "axis"_a = nb::none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def take(a: array, /, indices: Union[int, array], axis: Optional[int] = None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Take elements along an axis.
+
+        The elements are taken from ``indices`` along the specified axis.
+        If the axis is not specified the array is treated as a flattened
+        1-D array prior to performing the take.
+
+        As an example, if the ``axis=1`` this is equivalent to ``a[:, indices, ...]``.
+
+        Args:
+            a (array): Input array.
+            indices (int or array): Integer index or input array with integral type.
+            axis (int, optional): Axis along which to perform the take. If unspecified
+              the array is treated as a flattened 1-D vector.
+
+        Returns:
+            array: The indexed values of ``a``.
+      )pbdoc");
+  m.def(
+      "take_along_axis",
+      [](const mx::array& a,
+         const mx::array& indices,
+         const std::optional<int>& axis,
+         mx::StreamOrDevice s) {
+        if (axis.has_value()) {
+          return mx::take_along_axis(a, indices, axis.value(), s);
+        } else {
+          return mx::take_along_axis(mx::reshape(a, {-1}, s), indices, 0, s);
+        }
+      },
+      nb::arg(),
+      "indices"_a,
+      "axis"_a.none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def take_along_axis(a: array, /, indices: array, axis: Optional[int] = None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Take values along an axis at the specified indices.
+
+        Args:
+            a (array): Input array.
+            indices (array): Indices array. These should be broadcastable with
+              the input array excluding the `axis` dimension.
+            axis (int or None): Axis in the input to take the values from. If
+              ``axis == None`` the array is flattened to 1D prior to the indexing
+              operation.
+
+        Returns:
+            array: The output array.
+      )pbdoc");
+  m.def(
+      "put_along_axis",
+      [](const mx::array& a,
+         const mx::array& indices,
+         const mx::array& values,
+         const std::optional<int>& axis,
+         mx::StreamOrDevice s) {
+        if (axis.has_value()) {
+          return mx::put_along_axis(a, indices, values, axis.value(), s);
+        } else {
+          return mx::reshape(
+              mx::put_along_axis(
+                  mx::reshape(a, {-1}, s), indices, values, 0, s),
+              a.shape(),
+              s);
+        }
+      },
+      nb::arg(),
+      "indices"_a,
+      "values"_a,
+      "axis"_a.none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def put_along_axis(a: array, /, indices: array, values: array, axis: Optional[int] = None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Put values along an axis at the specified indices.
+
+        Args:
+            a (array): Destination array.
+            indices (array): Indices array. These should be broadcastable with
+              the input array excluding the `axis` dimension.
+            values (array): Values array. These should be broadcastable with
+              the indices.
+
+            axis (int or None): Axis in the destination to put the values to. If
+              ``axis == None`` the destination is flattened prior to the put
+              operation.
+
+        Returns:
+            array: The output array.
+      )pbdoc");
+  m.def(
+      "full",
+      [](const std::variant<int, mx::Shape>& shape,
+         const ScalarOrArray& vals,
+         std::optional<mx::Dtype> dtype,
+         mx::StreamOrDevice s) {
+        if (auto pv = std::get_if<int>(&shape); pv) {
+          return mx::full({*pv}, to_array(vals, dtype), s);
+        } else {
+          return mx::full(std::get<mx::Shape>(shape), to_array(vals, dtype), s);
+        }
+      },
+      "shape"_a,
+      "vals"_a,
+      "dtype"_a = nb::none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def full(shape: Union[int, Sequence[int]], vals: Union[scalar, array], dtype: Optional[Dtype] = None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Construct an array with the given value.
+
+        Constructs an array of size ``shape`` filled with ``vals``. If ``vals``
+        is an :obj:`array` it must be broadcastable to the given ``shape``.
+
+        Args:
+            shape (int or list(int)): The shape of the output array.
+            vals (float or int or array): Values to fill the array with.
+            dtype (Dtype, optional): Data type of the output array. If
+              unspecified the output type is inferred from ``vals``.
+
+        Returns:
+            array: The output array with the specified shape and values.
+      )pbdoc");
+  m.def(
+      "zeros",
+      [](const std::variant<int, mx::Shape>& shape,
+         std::optional<mx::Dtype> dtype,
+         mx::StreamOrDevice s) {
+        auto t = dtype.value_or(mx::float32);
+        if (auto pv = std::get_if<int>(&shape); pv) {
+          return mx::zeros({*pv}, t, s);
+        } else {
+          return mx::zeros(std::get<mx::Shape>(shape), t, s);
+        }
+      },
+      "shape"_a,
+      "dtype"_a.none() = mx::float32,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def zeros(shape: Union[int, Sequence[int]], dtype: Optional[Dtype] = float32, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Construct an array of zeros.
+
+        Args:
+            shape (int or list(int)): The shape of the output array.
+            dtype (Dtype, optional): Data type of the output array. If
+              unspecified the output type defaults to ``float32``.
+
+        Returns:
+            array: The array of zeros with the specified shape.
+      )pbdoc");
+  m.def(
+      "zeros_like",
+      &mx::zeros_like,
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def zeros_like(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        An array of zeros like the input.
+
+        Args:
+            a (array): The input to take the shape and type from.
+
+        Returns:
+            array: The output array filled with zeros.
+      )pbdoc");
+  m.def(
+      "ones",
+      [](const std::variant<int, mx::Shape>& shape,
+         std::optional<mx::Dtype> dtype,
+         mx::StreamOrDevice s) {
+        auto t = dtype.value_or(mx::float32);
+        if (auto pv = std::get_if<int>(&shape); pv) {
+          return mx::ones({*pv}, t, s);
+        } else {
+          return mx::ones(std::get<mx::Shape>(shape), t, s);
+        }
+      },
+      "shape"_a,
+      "dtype"_a.none() = mx::float32,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def ones(shape: Union[int, Sequence[int]], dtype: Optional[Dtype] = float32, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Construct an array of ones.
+
+        Args:
+            shape (int or list(int)): The shape of the output array.
+            dtype (Dtype, optional): Data type of the output array. If
+              unspecified the output type defaults to ``float32``.
+
+        Returns:
+            array: The array of ones with the specified shape.
+      )pbdoc");
+  m.def(
+      "ones_like",
+      &mx::ones_like,
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def ones_like(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        An array of ones like the input.
+
+        Args:
+            a (array): The input to take the shape and type from.
+
+        Returns:
+            array: The output array filled with ones.
+      )pbdoc");
+  m.def(
+      "eye",
+      [](int n,
+         std::optional<int> m,
+         int k,
+         std::optional<mx::Dtype> dtype,
+         mx::StreamOrDevice s) {
+        return mx::eye(n, m.value_or(n), k, dtype.value_or(mx::float32), s);
+      },
+      "n"_a,
+      "m"_a = nb::none(),
+      "k"_a = 0,
+      "dtype"_a.none() = mx::float32,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def eye(n: int, m: Optional[int] = None, k: int = 0, dtype: Optional[Dtype] = float32, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Create an identity matrix or a general diagonal matrix.
+
+        Args:
+            n (int): The number of rows in the output.
+            m (int, optional): The number of columns in the output. Defaults to n.
+            k (int, optional): Index of the diagonal. Defaults to 0 (main diagonal).
+            dtype (Dtype, optional): Data type of the output array. Defaults to float32.
+            stream (Stream, optional): Stream or device. Defaults to None.
+
+        Returns:
+            array: An array where all elements are equal to zero, except for the k-th diagonal, whose values are equal to one.
+      )pbdoc");
+  m.def(
+      "identity",
+      [](int n, std::optional<mx::Dtype> dtype, mx::StreamOrDevice s) {
+        return mx::identity(n, dtype.value_or(mx::float32), s);
+      },
+      "n"_a,
+      "dtype"_a.none() = mx::float32,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def identity(n: int, dtype: Optional[Dtype] = float32, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Create a square identity matrix.
+
+        Args:
+            n (int): The number of rows and columns in the output.
+            dtype (Dtype, optional): Data type of the output array. Defaults to float32.
+            stream (Stream, optional): Stream or device. Defaults to None.
+
+        Returns:
+            array: An identity matrix of size n x n.
+      )pbdoc");
+  m.def(
+      "tri",
+      [](int n,
+         std::optional<int> m,
+         int k,
+         std::optional<mx::Dtype> type,
+         mx::StreamOrDevice s) {
+        return mx::tri(n, m.value_or(n), k, type.value_or(mx::float32), s);
+      },
+      "n"_a,
+      "m"_a = nb::none(),
+      "k"_a = 0,
+      "dtype"_a.none() = mx::float32,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def tri(n: int, m: int, k: int, dtype: Optional[Dtype] = None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        An array with ones at and below the given diagonal and zeros elsewhere.
+
+        Args:
+          n (int): The number of rows in the output.
+          m (int, optional): The number of cols in the output. Defaults to ``None``.
+          k (int, optional): The diagonal of the 2-D array. Defaults to ``0``.
+          dtype (Dtype, optional): Data type of the output array. Defaults to ``float32``.
+          stream (Stream, optional): Stream or device. Defaults to ``None``.
+
+        Returns:
+          array: Array with its lower triangle filled with ones and zeros elsewhere
+      )pbdoc");
+  m.def(
+      "tril",
+      &mx::tril,
+      "x"_a,
+      "k"_a = 0,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def tril(x: array, k: int, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Zeros the array above the given diagonal.
+
+        Args:
+          x (array): input array.
+          k (int, optional): The diagonal of the 2-D array. Defaults to ``0``.
+          stream (Stream, optional): Stream or device. Defaults to ``None``.
+
+        Returns:
+          array: Array zeroed above the given diagonal
+      )pbdoc");
+  m.def(
+      "triu",
+      &mx::triu,
+      "x"_a,
+      "k"_a = 0,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def triu(x: array, k: int, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Zeros the array below the given diagonal.
+
+        Args:
+          x (array): input array.
+          k (int, optional): The diagonal of the 2-D array. Defaults to ``0``.
+          stream (Stream, optional): Stream or device. Defaults to ``None``.
+
+        Returns:
+          array: Array zeroed below the given diagonal
+    )pbdoc");
+  m.def(
+      "allclose",
+      &mx::allclose,
+      nb::arg(),
+      nb::arg(),
+      "rtol"_a = 1e-5,
+      "atol"_a = 1e-8,
+      nb::kw_only(),
+      "equal_nan"_a = false,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def allclose(a: array, b: array, /, rtol: float = 1e-05, atol: float = 1e-08, *, equal_nan: bool = False, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Approximate comparison of two arrays.
+
+        Infinite values are considered equal if they have the same sign, NaN values are not equal unless ``equal_nan`` is ``True``.
+
+        The arrays are considered equal if:
+
+        .. code-block::
+
+         all(abs(a - b) <= (atol + rtol * abs(b)))
+
+        Note unlike :func:`array_equal`, this function supports numpy-style
+        broadcasting.
+
+        Args:
+            a (array): Input array.
+            b (array): Input array.
+            rtol (float): Relative tolerance.
+            atol (float): Absolute tolerance.
+            equal_nan (bool): If ``True``, NaNs are considered equal.
+              Defaults to ``False``.
+
+        Returns:
+            array: The boolean output scalar indicating if the arrays are close.
+      )pbdoc");
+  m.def(
+      "isclose",
+      &mx::isclose,
+      nb::arg(),
+      nb::arg(),
+      "rtol"_a = 1e-5,
+      "atol"_a = 1e-8,
+      nb::kw_only(),
+      "equal_nan"_a = false,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def isclose(a: array, b: array, /, rtol: float = 1e-05, atol: float = 1e-08, *, equal_nan: bool = False, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Returns a boolean array where two arrays are element-wise equal within a tolerance.
+
+        Infinite values are considered equal if they have the same sign, NaN values are
+        not equal unless ``equal_nan`` is ``True``.
+
+        Two values are considered equal if:
+
+        .. code-block::
+
+         abs(a - b) <= (atol + rtol * abs(b))
+
+        Note unlike :func:`array_equal`, this function supports numpy-style
+        broadcasting.
+
+        Args:
+            a (array): Input array.
+            b (array): Input array.
+            rtol (float): Relative tolerance.
+            atol (float): Absolute tolerance.
+            equal_nan (bool): If ``True``, NaNs are considered equal.
+              Defaults to ``False``.
+
+        Returns:
+            array: The boolean output scalar indicating if the arrays are close.
+      )pbdoc");
+  m.def(
+      "all",
+      [](const mx::array& a,
+         const IntOrVec& axis,
+         bool keepdims,
+         mx::StreamOrDevice s) {
+        return mx::all(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      "keepdims"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def all(a: array, /, axis: Union[None, int, Sequence[int]] = None, keepdims: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        An `and` reduction over the given axes.
+
+        Args:
+            a (array): Input array.
+            axis (int or list(int), optional): Optional axis or
+              axes to reduce over. If unspecified this defaults
+              to reducing over the entire array.
+            keepdims (bool, optional): Keep reduced axes as
+              singleton dimensions, defaults to `False`.
+
+        Returns:
+            array: The output array with the corresponding axes reduced.
+      )pbdoc");
+  m.def(
+      "any",
+      [](const mx::array& a,
+         const IntOrVec& axis,
+         bool keepdims,
+         mx::StreamOrDevice s) {
+        return mx::any(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      "keepdims"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def any(a: array, /, axis: Union[None, int, Sequence[int]] = None, keepdims: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        An `or` reduction over the given axes.
+
+        Args:
+            a (array): Input array.
+            axis (int or list(int), optional): Optional axis or
+              axes to reduce over. If unspecified this defaults
+              to reducing over the entire array.
+            keepdims (bool, optional): Keep reduced axes as
+              singleton dimensions, defaults to `False`.
+
+        Returns:
+            array: The output array with the corresponding axes reduced.
+      )pbdoc");
+  m.def(
+      "minimum",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::minimum(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def minimum(a: Union[scalar, array], b: Union[scalar, array], /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise minimum.
+
+        Take the element-wise min of two arrays with numpy-style broadcasting
+        semantics. Either or both input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The min of ``a`` and ``b``.
+      )pbdoc");
+  m.def(
+      "maximum",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::maximum(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def maximum(a: Union[scalar, array], b: Union[scalar, array], /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise maximum.
+
+        Take the element-wise max of two arrays with numpy-style broadcasting
+        semantics. Either or both input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The max of ``a`` and ``b``.
+      )pbdoc");
+  m.def(
+      "floor",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::floor(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def floor(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise floor.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The floor of ``a``.
+      )pbdoc");
+  m.def(
+      "ceil",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::ceil(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def ceil(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise ceil.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The ceil of ``a``.
+      )pbdoc");
+  m.def(
+      "isnan",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::isnan(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def isnan(a: array, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return a boolean array indicating which elements are NaN.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The boolean array indicating which elements are NaN.
+      )pbdoc");
+  m.def(
+      "isinf",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::isinf(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def isinf(a: array, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return a boolean array indicating which elements are +/- inifnity.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The boolean array indicating which elements are +/- infinity.
+      )pbdoc");
+  m.def(
+      "isfinite",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::isfinite(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def isfinite(a: array, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return a boolean array indicating which elements are finite.
+
+        An element is finite if it is not infinite or NaN.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The boolean array indicating which elements are finite.
+      )pbdoc");
+  m.def(
+      "isposinf",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::isposinf(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def isposinf(a: array, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return a boolean array indicating which elements are positive infinity.
+
+        Args:
+            a (array): Input array.
+            stream (Union[None, Stream, Device]): Optional stream or device.
+
+        Returns:
+            array: The boolean array indicating which elements are positive infinity.
+      )pbdoc");
+  m.def(
+      "isneginf",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::isneginf(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def isneginf(a: array, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return a boolean array indicating which elements are negative infinity.
+
+        Args:
+            a (array): Input array.
+            stream (Union[None, Stream, Device]): Optional stream or device.
+
+        Returns:
+            array: The boolean array indicating which elements are negative infinity.
+      )pbdoc");
+  m.def(
+      "moveaxis",
+      &mx::moveaxis,
+      nb::arg(),
+      "source"_a,
+      "destination"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def moveaxis(a: array, /, source: int, destination: int, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Move an axis to a new position.
+
+        Args:
+            a (array): Input array.
+            source (int): Specifies the source axis.
+            destination (int): Specifies the destination axis.
+
+        Returns:
+            array: The array with the axis moved.
+      )pbdoc");
+  m.def(
+      "swapaxes",
+      &mx::swapaxes,
+      nb::arg(),
+      "axis1"_a,
+      "axis2"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def swapaxes(a: array, /, axis1 : int, axis2: int, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Swap two axes of an array.
+
+        Args:
+            a (array): Input array.
+            axis1 (int): Specifies the first axis.
+            axis2 (int): Specifies the second axis.
+
+        Returns:
+            array: The array with swapped axes.
+      )pbdoc");
+  m.def(
+      "transpose",
+      [](const mx::array& a,
+         const std::optional<std::vector<int>>& axes,
+         mx::StreamOrDevice s) {
+        if (axes.has_value()) {
+          return mx::transpose(a, *axes, s);
+        } else {
+          return mx::transpose(a, s);
+        }
+      },
+      nb::arg(),
+      "axes"_a = nb::none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def transpose(a: array, /, axes: Optional[Sequence[int]] = None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Transpose the dimensions of the array.
+
+        Args:
+            a (array): Input array.
+            axes (list(int), optional): Specifies the source axis for each axis
+              in the new array. The default is to reverse the axes.
+
+        Returns:
+            array: The transposed array.
+      )pbdoc");
+  m.def(
+      "permute_dims",
+      [](const mx::array& a,
+         const std::optional<std::vector<int>>& axes,
+         mx::StreamOrDevice s) {
+        if (axes.has_value()) {
+          return mx::transpose(a, *axes, s);
+        } else {
+          return mx::transpose(a, s);
+        }
+      },
+      nb::arg(),
+      "axes"_a = nb::none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def permute_dims(a: array, /, axes: Optional[Sequence[int]] = None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        See :func:`transpose`.
+      )pbdoc");
+  m.def(
+      "sum",
+      [](const mx::array& a,
+         const IntOrVec& axis,
+         bool keepdims,
+         mx::StreamOrDevice s) {
+        return mx::sum(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+      },
+      "array"_a,
+      "axis"_a = nb::none(),
+      "keepdims"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def sum(a: array, /, axis: Union[None, int, Sequence[int]] = None, keepdims: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Sum reduce the array over the given axes.
+
+        Args:
+            a (array): Input array.
+            axis (int or list(int), optional): Optional axis or
+              axes to reduce over. If unspecified this defaults
+              to reducing over the entire array.
+            keepdims (bool, optional): Keep reduced axes as
+              singleton dimensions, defaults to `False`.
+
+        Returns:
+            array: The output array with the corresponding axes reduced.
+      )pbdoc");
+  m.def(
+      "prod",
+      [](const mx::array& a,
+         const IntOrVec& axis,
+         bool keepdims,
+         mx::StreamOrDevice s) {
+        return mx::prod(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      "keepdims"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def prod(a: array, /, axis: Union[None, int, Sequence[int]] = None, keepdims: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        An product reduction over the given axes.
+
+        Args:
+            a (array): Input array.
+            axis (int or list(int), optional): Optional axis or
+              axes to reduce over. If unspecified this defaults
+              to reducing over the entire array.
+            keepdims (bool, optional): Keep reduced axes as
+              singleton dimensions, defaults to `False`.
+
+        Returns:
+            array: The output array with the corresponding axes reduced.
+      )pbdoc");
+  m.def(
+      "min",
+      [](const mx::array& a,
+         const IntOrVec& axis,
+         bool keepdims,
+         mx::StreamOrDevice s) {
+        return mx::min(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      "keepdims"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def min(a: array, /, axis: Union[None, int, Sequence[int]] = None, keepdims: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        A `min` reduction over the given axes.
+
+        Args:
+            a (array): Input array.
+            axis (int or list(int), optional): Optional axis or
+              axes to reduce over. If unspecified this defaults
+              to reducing over the entire array.
+            keepdims (bool, optional): Keep reduced axes as
+              singleton dimensions, defaults to `False`.
+
+        Returns:
+            array: The output array with the corresponding axes reduced.
+      )pbdoc");
+  m.def(
+      "max",
+      [](const mx::array& a,
+         const IntOrVec& axis,
+         bool keepdims,
+         mx::StreamOrDevice s) {
+        return mx::max(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      "keepdims"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def max(a: array, /, axis: Union[None, int, Sequence[int]] = None, keepdims: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        A `max` reduction over the given axes.
+
+        Args:
+            a (array): Input array.
+            axis (int or list(int), optional): Optional axis or
+              axes to reduce over. If unspecified this defaults
+              to reducing over the entire array.
+            keepdims (bool, optional): Keep reduced axes as
+              singleton dimensions, defaults to `False`.
+
+        Returns:
+            array: The output array with the corresponding axes reduced.
+      )pbdoc");
+  m.def(
+      "logcumsumexp",
+      [](const mx::array& a,
+         std::optional<int> axis,
+         bool reverse,
+         bool inclusive,
+         mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::logcumsumexp(a, *axis, reverse, inclusive, s);
+        } else {
+          return mx::logcumsumexp(
+              mx::reshape(a, {-1}, s), 0, reverse, inclusive, s);
+        }
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      nb::kw_only(),
+      "reverse"_a = false,
+      "inclusive"_a = true,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def logcumsumexp(a: array, /, axis: Optional[int] = None, *, reverse: bool = False, inclusive: bool = True, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return the cumulative logsumexp of the elements along the given axis.
+
+        Args:
+          a (array): Input array
+          axis (int, optional): Optional axis to compute the cumulative logsumexp
+            over. If unspecified the cumulative logsumexp of the flattened array is
+            returned.
+          reverse (bool): Perform the cumulative logsumexp in reverse.
+          inclusive (bool): The i-th element of the output includes the i-th
+            element of the input.
+
+        Returns:
+          array: The output array.
+      )pbdoc");
+  m.def(
+      "logsumexp",
+      [](const mx::array& a,
+         const IntOrVec& axis,
+         bool keepdims,
+         mx::StreamOrDevice s) {
+        return mx::logsumexp(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      "keepdims"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def logsumexp(a: array, /, axis: Union[None, int, Sequence[int]] = None, keepdims: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        A `log-sum-exp` reduction over the given axes.
+
+        The log-sum-exp reduction is a numerically stable version of:
+
+        .. code-block::
+
+          log(sum(exp(a), axis))
+
+        Args:
+            a (array): Input array.
+            axis (int or list(int), optional): Optional axis or
+              axes to reduce over. If unspecified this defaults
+              to reducing over the entire array.
+            keepdims (bool, optional): Keep reduced axes as
+              singleton dimensions, defaults to `False`.
+
+        Returns:
+            array: The output array with the corresponding axes reduced.
+      )pbdoc");
+  m.def(
+      "mean",
+      [](const mx::array& a,
+         const IntOrVec& axis,
+         bool keepdims,
+         mx::StreamOrDevice s) {
+        return mx::mean(a, get_reduce_axes(axis, a.ndim()), keepdims, s);
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      "keepdims"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def mean(a: array, /, axis: Union[None, int, Sequence[int]] = None, keepdims: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Compute the mean(s) over the given axes.
+
+        Args:
+            a (array): Input array.
+            axis (int or list(int), optional): Optional axis or
+              axes to reduce over. If unspecified this defaults
+              to reducing over the entire array.
+            keepdims (bool, optional): Keep reduced axes as
+              singleton dimensions, defaults to `False`.
+
+        Returns:
+            array: The output array of means.
+      )pbdoc");
+  m.def(
+      "var",
+      [](const mx::array& a,
+         const IntOrVec& axis,
+         bool keepdims,
+         int ddof,
+         mx::StreamOrDevice s) {
+        return mx::var(a, get_reduce_axes(axis, a.ndim()), keepdims, ddof, s);
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      "keepdims"_a = false,
+      "ddof"_a = 0,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def var(a: array, /, axis: Union[None, int, Sequence[int]] = None, keepdims: bool = False, ddof: int = 0, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Compute the variance(s) over the given axes.
+
+        Args:
+            a (array): Input array.
+            axis (int or list(int), optional): Optional axis or
+              axes to reduce over. If unspecified this defaults
+              to reducing over the entire array.
+            keepdims (bool, optional): Keep reduced axes as
+              singleton dimensions, defaults to `False`.
+            ddof (int, optional): The divisor to compute the variance
+              is ``N - ddof``, defaults to 0.
+
+        Returns:
+            array: The output array of variances.
+      )pbdoc");
+  m.def(
+      "std",
+      [](const mx::array& a,
+         const IntOrVec& axis,
+         bool keepdims,
+         int ddof,
+         mx::StreamOrDevice s) {
+        return mx::std(a, get_reduce_axes(axis, a.ndim()), keepdims, ddof, s);
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      "keepdims"_a = false,
+      "ddof"_a = 0,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def std(a: array, /, axis: Union[None, int, Sequence[int]] = None, keepdims: bool = False, ddof: int = 0, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Compute the standard deviation(s) over the given axes.
+
+        Args:
+            a (array): Input array.
+            axis (int or list(int), optional): Optional axis or
+              axes to reduce over. If unspecified this defaults
+              to reducing over the entire array.
+            keepdims (bool, optional): Keep reduced axes as
+              singleton dimensions, defaults to `False`.
+            ddof (int, optional): The divisor to compute the variance
+              is ``N - ddof``, defaults to 0.
+
+        Returns:
+            array: The output array of standard deviations.
+      )pbdoc");
+  m.def(
+      "split",
+      [](const mx::array& a,
+         const std::variant<int, mx::Shape>& indices_or_sections,
+         int axis,
+         mx::StreamOrDevice s) {
+        if (auto pv = std::get_if<int>(&indices_or_sections); pv) {
+          return mx::split(a, *pv, axis, s);
+        } else {
+          return mx::split(
+              a, std::get<mx::Shape>(indices_or_sections), axis, s);
+        }
+      },
+      nb::arg(),
+      "indices_or_sections"_a,
+      "axis"_a = 0,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def split(a: array, /, indices_or_sections: Union[int, Sequence[int]], axis: int = 0, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Split an array along a given axis.
+
+        Args:
+            a (array): Input array.
+            indices_or_sections (int or list(int)): If ``indices_or_sections``
+              is an integer the array is split into that many sections of equal
+              size. An error is raised if this is not possible. If ``indices_or_sections``
+              is a list, the list contains the indices of the start of each subarray
+              along the given axis.
+            axis (int, optional): Axis to split along, defaults to `0`.
+
+        Returns:
+            list(array): A list of split arrays.
+      )pbdoc");
+  m.def(
+      "argmin",
+      [](const mx::array& a,
+         std::optional<int> axis,
+         bool keepdims,
+         mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::argmin(a, *axis, keepdims, s);
+        } else {
+          return mx::argmin(a, keepdims, s);
+        }
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      "keepdims"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def argmin(a: array, /, axis: Union[None, int] = None, keepdims: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Indices of the minimum values along the axis.
+
+        Args:
+            a (array): Input array.
+            axis (int, optional): Optional axis to reduce over. If unspecified
+              this defaults to reducing over the entire array.
+            keepdims (bool, optional): Keep reduced axes as
+              singleton dimensions, defaults to `False`.
+
+        Returns:
+            array: The ``uint32`` array with the indices of the minimum values.
+      )pbdoc");
+  m.def(
+      "argmax",
+      [](const mx::array& a,
+         std::optional<int> axis,
+         bool keepdims,
+         mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::argmax(a, *axis, keepdims, s);
+        } else {
+          return mx::argmax(a, keepdims, s);
+        }
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      "keepdims"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def argmax(a: array, /, axis: Union[None, int] = None, keepdims: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Indices of the maximum values along the axis.
+
+        Args:
+            a (array): Input array.
+            axis (int, optional): Optional axis to reduce over. If unspecified
+              this defaults to reducing over the entire array.
+            keepdims (bool, optional): Keep reduced axes as
+              singleton dimensions, defaults to `False`.
+
+        Returns:
+            array: The ``uint32`` array with the indices of the maximum values.
+      )pbdoc");
+  m.def(
+      "sort",
+      [](const mx::array& a, std::optional<int> axis, mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::sort(a, *axis, s);
+        } else {
+          return mx::sort(a, s);
+        }
+      },
+      nb::arg(),
+      "axis"_a.none() = -1,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def sort(a: array, /, axis: Union[None, int] = -1, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Returns a sorted copy of the array.
+
+        Args:
+            a (array): Input array.
+            axis (int or None, optional): Optional axis to sort over.
+              If ``None``, this sorts over the flattened array.
+              If unspecified, it defaults to -1 (sorting over the last axis).
+
+        Returns:
+            array: The sorted array.
+      )pbdoc");
+  m.def(
+      "argsort",
+      [](const mx::array& a, std::optional<int> axis, mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::argsort(a, *axis, s);
+        } else {
+          return mx::argsort(a, s);
+        }
+      },
+      nb::arg(),
+      "axis"_a.none() = -1,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def argsort(a: array, /, axis: Union[None, int] = -1, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Returns the indices that sort the array.
+
+        Args:
+            a (array): Input array.
+            axis (int or None, optional): Optional axis to sort over.
+              If ``None``, this sorts over the flattened array.
+              If unspecified, it defaults to -1 (sorting over the last axis).
+
+        Returns:
+            array: The ``uint32`` array containing indices that sort the input.
+      )pbdoc");
+  m.def(
+      "partition",
+      [](const mx::array& a,
+         int kth,
+         std::optional<int> axis,
+         mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::partition(a, kth, *axis, s);
+        } else {
+          return mx::partition(a, kth, s);
+        }
+      },
+      nb::arg(),
+      "kth"_a,
+      "axis"_a.none() = -1,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def partition(a: array, /, kth: int, axis: Union[None, int] = -1, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Returns a partitioned copy of the array such that the smaller ``kth``
+        elements are first.
+
+        The ordering of the elements in partitions is undefined.
+
+        Args:
+            a (array): Input array.
+            kth (int): Element at the ``kth`` index will be in its sorted
+              position in the output. All elements before the kth index will
+              be less or equal to the ``kth`` element and all elements after
+              will be greater or equal to the ``kth`` element in the output.
+            axis (int or None, optional): Optional axis to partition over.
+              If ``None``, this partitions over the flattened array.
+              If unspecified, it defaults to ``-1``.
+
+        Returns:
+            array: The partitioned array.
+      )pbdoc");
+  m.def(
+      "argpartition",
+      [](const mx::array& a,
+         int kth,
+         std::optional<int> axis,
+         mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::argpartition(a, kth, *axis, s);
+        } else {
+          return mx::argpartition(a, kth, s);
+        }
+      },
+      nb::arg(),
+      "kth"_a,
+      "axis"_a.none() = -1,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def argpartition(a: array, /, kth: int, axis: Union[None, int] = -1, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Returns the indices that partition the array.
+
+        The ordering of the elements within a partition in given by the indices
+        is undefined.
+
+        Args:
+            a (array): Input array.
+            kth (int): Element index at the ``kth`` position in the output will
+              give the sorted position. All indices before the ``kth`` position
+              will be of elements less or equal to the element at the ``kth``
+              index and all indices after will be of elements greater or equal
+              to the element at the ``kth`` index.
+            axis (int or None, optional): Optional axis to partition over.
+              If ``None``, this partitions over the flattened array.
+              If unspecified, it defaults to ``-1``.
+
+        Returns:
+            array: The ``uint32`` array containing indices that partition the input.
+      )pbdoc");
+  m.def(
+      "topk",
+      [](const mx::array& a,
+         int k,
+         std::optional<int> axis,
+         mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::topk(a, k, *axis, s);
+        } else {
+          return mx::topk(a, k, s);
+        }
+      },
+      nb::arg(),
+      "k"_a,
+      "axis"_a.none() = -1,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def topk(a: array, /, k: int, axis: Union[None, int] = -1, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Returns the ``k`` largest elements from the input along a given axis.
+
+        The elements will not necessarily be in sorted order.
+
+        Args:
+            a (array): Input array.
+            k (int): ``k`` top elements to be returned
+            axis (int or None, optional): Optional axis to select over.
+              If ``None``, this selects the top ``k`` elements over the
+              flattened array. If unspecified, it defaults to ``-1``.
+
+        Returns:
+            array: The top ``k`` elements from the input.
+      )pbdoc");
+  m.def(
+      "broadcast_to",
+      [](const ScalarOrArray& a, const mx::Shape& shape, mx::StreamOrDevice s) {
+        return mx::broadcast_to(to_array(a), shape, s);
+      },
+      nb::arg(),
+      "shape"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def broadcast_to(a: Union[scalar, array], /, shape: Sequence[int], *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Broadcast an array to the given shape.
+
+        The broadcasting semantics are the same as Numpy.
+
+        Args:
+            a (array): Input array.
+            shape (list(int)): The shape to broadcast to.
+
+        Returns:
+            array: The output array with the new shape.
+      )pbdoc");
+  m.def(
+      "broadcast_arrays",
+      [](const nb::args& args, mx::StreamOrDevice s) {
+        return broadcast_arrays(nb::cast<std::vector<mx::array>>(args), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def broadcast_arrays(*arrays: array, stream: Union[None, Stream, Device] = None) -> Tuple[array, ...]"),
+      R"pbdoc(
+        Broadcast arrays against one another.
+
+        The broadcasting semantics are the same as Numpy.
+
+        Args:
+            *arrays (array): The input arrays.
+
+        Returns:
+            tuple(array): The output arrays with the broadcasted shape.
+      )pbdoc");
+  m.def(
+      "softmax",
+      [](const mx::array& a,
+         const IntOrVec& axis,
+         bool precise,
+         mx::StreamOrDevice s) {
+        return mx::softmax(a, get_reduce_axes(axis, a.ndim()), precise, s);
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      nb::kw_only(),
+      "precise"_a = false,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def softmax(a: array, /, axis: Union[None, int, Sequence[int]] = None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Perform the softmax along the given axis.
+
+        This operation is a numerically stable version of:
+
+        .. code-block::
+
+          exp(a) / sum(exp(a), axis, keepdims=True)
+
+        Args:
+            a (array): Input array.
+            axis (int or list(int), optional): Optional axis or axes to compute
+             the softmax over. If unspecified this performs the softmax over
+             the full array.
+
+        Returns:
+            array: The output of the softmax.
+      )pbdoc");
+  m.def(
+      "concatenate",
+      [](const std::vector<mx::array>& arrays,
+         std::optional<int> axis,
+         mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::concatenate(arrays, *axis, s);
+        } else {
+          return mx::concatenate(arrays, s);
+        }
+      },
+      nb::arg(),
+      "axis"_a.none() = 0,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def concatenate(arrays: list[array], axis: Optional[int] = 0, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Concatenate the arrays along the given axis.
+
+        Args:
+            arrays (list(array)): Input :obj:`list` or :obj:`tuple` of arrays.
+            axis (int, optional): Optional axis to concatenate along. If
+              unspecified defaults to ``0``.
+
+        Returns:
+            array: The concatenated array.
+      )pbdoc");
+  m.def(
+      "concat",
+      [](const std::vector<mx::array>& arrays,
+         std::optional<int> axis,
+         mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::concatenate(arrays, *axis, s);
+        } else {
+          return mx::concatenate(arrays, s);
+        }
+      },
+      nb::arg(),
+      "axis"_a.none() = 0,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def concat(arrays: list[array], axis: Optional[int] = 0, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        See :func:`concatenate`.
+      )pbdoc");
+  m.def(
+      "stack",
+      [](const std::vector<mx::array>& arrays,
+         std::optional<int> axis,
+         mx::StreamOrDevice s) {
+        if (axis.has_value()) {
+          return mx::stack(arrays, axis.value(), s);
+        } else {
+          return mx::stack(arrays, s);
+        }
+      },
+      nb::arg(),
+      "axis"_a = 0,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def stack(arrays: list[array], axis: Optional[int] = 0, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Stacks the arrays along a new axis.
+
+        Args:
+            arrays (list(array)): A list of arrays to stack.
+            axis (int, optional): The axis in the result array along which the
+              input arrays are stacked. Defaults to ``0``.
+            stream (Stream, optional): Stream or device. Defaults to ``None``.
+
+        Returns:
+            array: The resulting stacked array.
+      )pbdoc");
+  m.def(
+      "meshgrid",
+      [](nb::args arrays_,
+         bool sparse,
+         std::string indexing,
+         mx::StreamOrDevice s) {
+        std::vector<mx::array> arrays =
+            nb::cast<std::vector<mx::array>>(arrays_);
+        return mx::meshgrid(arrays, sparse, indexing, s);
+      },
+      "arrays"_a,
+      "sparse"_a = false,
+      "indexing"_a = "xy",
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def meshgrid(*arrays: array, sparse: Optional[bool] = False, indexing: Optional[str] = 'xy', stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Generate multidimensional coordinate grids from 1-D coordinate arrays
+
+        Args:
+            *arrays (array): Input arrays.
+            sparse (bool, optional): If ``True``, a sparse grid is returned in which each output
+              array has a single non-zero element. If ``False``, a dense grid is returned.
+              Defaults to ``False``.
+            indexing (str, optional): Cartesian ('xy') or matrix ('ij') indexing of the output arrays.
+              Defaults to ``'xy'``.
+
+        Returns:
+            list(array): The output arrays.
+      )pbdoc");
+  m.def(
+      "repeat",
+      [](const mx::array& array,
+         int repeats,
+         std::optional<int> axis,
+         mx::StreamOrDevice s) {
+        if (axis.has_value()) {
+          return mx::repeat(array, repeats, axis.value(), s);
+        } else {
+          return mx::repeat(array, repeats, s);
+        }
+      },
+      nb::arg(),
+      "repeats"_a,
+      "axis"_a = nb::none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def repeat(array: array, repeats: int, axis: Optional[int] = None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Repeat an array along a specified axis.
+
+        Args:
+            array (array): Input array.
+            repeats (int): The number of repetitions for each element.
+            axis (int, optional): The axis in which to repeat the array along. If
+              unspecified it uses the flattened array of the input and repeats
+              along axis 0.
+            stream (Stream, optional): Stream or device. Defaults to ``None``.
+
+        Returns:
+            array: The resulting repeated array.
+      )pbdoc");
+  m.def(
+      "clip",
+      [](const mx::array& a,
+         const std::optional<ScalarOrArray>& min,
+         const std::optional<ScalarOrArray>& max,
+         mx::StreamOrDevice s) {
+        std::optional<mx::array> min_ = std::nullopt;
+        std::optional<mx::array> max_ = std::nullopt;
+        if (min) {
+          min_ = to_arrays(a, min.value()).second;
+        }
+        if (max) {
+          max_ = to_arrays(a, max.value()).second;
+        }
+        return mx::clip(a, min_, max_, s);
+      },
+      nb::arg(),
+      "a_min"_a.none(),
+      "a_max"_a.none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def clip(a: array, /, a_min: Union[scalar, array, None], a_max: Union[scalar, array, None], *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Clip the values of the array between the given minimum and maximum.
+
+        If either ``a_min`` or ``a_max`` are ``None``, then corresponding edge
+        is ignored. At least one of ``a_min`` and ``a_max`` cannot be ``None``.
+        The input ``a`` and the limits must broadcast with one another.
+
+        Args:
+            a (array): Input array.
+            a_min (scalar or array or None): Minimum value to clip to.
+            a_max (scalar or array or None): Maximum value to clip to.
+
+        Returns:
+            array: The clipped array.
+      )pbdoc");
+  m.def(
+      "pad",
+      [](const mx::array& a,
+         const std::variant<
+             int,
+             std::tuple<int>,
+             std::pair<int, int>,
+             std::vector<std::pair<int, int>>>& pad_width,
+         const std::string& mode,
+         const ScalarOrArray& constant_value,
+         mx::StreamOrDevice s) {
+        if (auto pv = std::get_if<int>(&pad_width); pv) {
+          return mx::pad(a, *pv, to_array(constant_value), mode, s);
+        } else if (auto pv = std::get_if<std::tuple<int>>(&pad_width); pv) {
+          return mx::pad(
+              a, std::get<0>(*pv), to_array(constant_value), mode, s);
+        } else if (auto pv = std::get_if<std::pair<int, int>>(&pad_width); pv) {
+          return mx::pad(a, *pv, to_array(constant_value), mode, s);
+        } else {
+          auto v = std::get<std::vector<std::pair<int, int>>>(pad_width);
+          if (v.size() == 1) {
+            return mx::pad(a, v[0], to_array(constant_value), mode, s);
+          } else {
+            return mx::pad(a, v, to_array(constant_value), mode, s);
+          }
+        }
+      },
+      nb::arg(),
+      "pad_width"_a,
+      "mode"_a = "constant",
+      "constant_values"_a = 0,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def pad(a: array, pad_width: Union[int, tuple[int], tuple[int, int], list[tuple[int, int]]], mode: Literal['constant', 'edge'] = 'constant', constant_values: Union[scalar, array] = 0, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Pad an array with a constant value
+
+        Args:
+            a (array): Input array.
+            pad_width (int, tuple(int), tuple(int, int) or list(tuple(int, int))): Number of padded
+              values to add to the edges of each axis:``((before_1, after_1),
+              (before_2, after_2), ..., (before_N, after_N))``. If a single pair
+              of integers is passed then ``(before_i, after_i)`` are all the same.
+              If a single integer or tuple with a single integer is passed then
+              all axes are extended by the same number on each side.
+            mode: Padding mode. One of the following strings:
+              "constant" (default): Pads with a constant value.
+              "edge": Pads with the edge values of array.
+            constant_value (array or scalar, optional): Optional constant value
+              to pad the edges of the array with.
+
+        Returns:
+            array: The padded array.
+      )pbdoc");
+  m.def(
+      "as_strided",
+      [](const mx::array& a,
+         std::optional<mx::Shape> shape,
+         std::optional<mx::Strides> strides,
+         size_t offset,
+         mx::StreamOrDevice s) {
+        auto a_shape = (shape) ? *shape : a.shape();
+        mx::Strides a_strides;
+        if (strides) {
+          a_strides = *strides;
+        } else {
+          a_strides = mx::Strides(a_shape.size(), 1);
+          for (int i = a_shape.size() - 1; i > 0; i--) {
+            a_strides[i - 1] = a_shape[i] * a_strides[i];
+          }
+        }
+        return mx::as_strided(a, a_shape, a_strides, offset, s);
+      },
+      nb::arg(),
+      "shape"_a = nb::none(),
+      "strides"_a = nb::none(),
+      "offset"_a = 0,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def as_strided(a: array, /, shape: Optional[Sequence[int]] = None, strides: Optional[Sequence[int]] = None, offset: int = 0, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Create a view into the array with the given shape and strides.
+
+        The resulting array will always be as if the provided array was row
+        contiguous regardless of the provided arrays storage order and current
+        strides.
+
+        .. note::
+           Note that this function should be used with caution as it changes
+           the shape and strides of the array directly. This can lead to the
+           resulting array pointing to invalid memory locations which can
+           result into crashes.
+
+        Args:
+          a (array): Input array
+          shape (list(int), optional): The shape of the resulting array. If
+            None it defaults to ``a.shape()``.
+          strides (list(int), optional): The strides of the resulting array. If
+            None it defaults to the reverse exclusive cumulative product of
+            ``a.shape()``.
+          offset (int): Skip that many elements from the beginning of the input
+            array.
+
+        Returns:
+          array: The output array which is the strided view of the input.
+      )pbdoc");
+  m.def(
+      "cumsum",
+      [](const mx::array& a,
+         std::optional<int> axis,
+         bool reverse,
+         bool inclusive,
+         mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::cumsum(a, *axis, reverse, inclusive, s);
+        } else {
+          return mx::cumsum(mx::reshape(a, {-1}, s), 0, reverse, inclusive, s);
+        }
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      nb::kw_only(),
+      "reverse"_a = false,
+      "inclusive"_a = true,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def cumsum(a: array, /, axis: Optional[int] = None, *, reverse: bool = False, inclusive: bool = True, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return the cumulative sum of the elements along the given axis.
+
+        Args:
+          a (array): Input array
+          axis (int, optional): Optional axis to compute the cumulative sum
+            over. If unspecified the cumulative sum of the flattened array is
+            returned.
+          reverse (bool): Perform the cumulative sum in reverse.
+          inclusive (bool): The i-th element of the output includes the i-th
+            element of the input.
+
+        Returns:
+          array: The output array.
+      )pbdoc");
+  m.def(
+      "cumprod",
+      [](const mx::array& a,
+         std::optional<int> axis,
+         bool reverse,
+         bool inclusive,
+         mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::cumprod(a, *axis, reverse, inclusive, s);
+        } else {
+          return mx::cumprod(mx::reshape(a, {-1}, s), 0, reverse, inclusive, s);
+        }
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      nb::kw_only(),
+      "reverse"_a = false,
+      "inclusive"_a = true,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def cumprod(a: array, /, axis: Optional[int] = None, *, reverse: bool = False, inclusive: bool = True, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return the cumulative product of the elements along the given axis.
+
+        Args:
+          a (array): Input array
+          axis (int, optional): Optional axis to compute the cumulative product
+            over. If unspecified the cumulative product of the flattened array is
+            returned.
+          reverse (bool): Perform the cumulative product in reverse.
+          inclusive (bool): The i-th element of the output includes the i-th
+            element of the input.
+
+        Returns:
+          array: The output array.
+      )pbdoc");
+  m.def(
+      "cummax",
+      [](const mx::array& a,
+         std::optional<int> axis,
+         bool reverse,
+         bool inclusive,
+         mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::cummax(a, *axis, reverse, inclusive, s);
+        } else {
+          return mx::cummax(mx::reshape(a, {-1}, s), 0, reverse, inclusive, s);
+        }
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      nb::kw_only(),
+      "reverse"_a = false,
+      "inclusive"_a = true,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def cummax(a: array, /, axis: Optional[int] = None, *, reverse: bool = False, inclusive: bool = True, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return the cumulative maximum of the elements along the given axis.
+
+        Args:
+          a (array): Input array
+          axis (int, optional): Optional axis to compute the cumulative maximum
+            over. If unspecified the cumulative maximum of the flattened array is
+            returned.
+          reverse (bool): Perform the cumulative maximum in reverse.
+          inclusive (bool): The i-th element of the output includes the i-th
+            element of the input.
+
+        Returns:
+          array: The output array.
+      )pbdoc");
+  m.def(
+      "cummin",
+      [](const mx::array& a,
+         std::optional<int> axis,
+         bool reverse,
+         bool inclusive,
+         mx::StreamOrDevice s) {
+        if (axis) {
+          return mx::cummin(a, *axis, reverse, inclusive, s);
+        } else {
+          return mx::cummin(mx::reshape(a, {-1}, s), 0, reverse, inclusive, s);
+        }
+      },
+      nb::arg(),
+      "axis"_a = nb::none(),
+      nb::kw_only(),
+      "reverse"_a = false,
+      "inclusive"_a = true,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def cummin(a: array, /, axis: Optional[int] = None, *, reverse: bool = False, inclusive: bool = True, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return the cumulative minimum of the elements along the given axis.
+
+        Args:
+          a (array): Input array
+          axis (int, optional): Optional axis to compute the cumulative minimum
+            over. If unspecified the cumulative minimum of the flattened array is
+            returned.
+          reverse (bool): Perform the cumulative minimum in reverse.
+          inclusive (bool): The i-th element of the output includes the i-th
+            element of the input.
+
+        Returns:
+          array: The output array.
+      )pbdoc");
+  m.def(
+      "conj",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::conjugate(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def conj(a: array, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return the elementwise complex conjugate of the input.
+        Alias for `mx.conjugate`.
+
+        Args:
+          a (array): Input array
+
+        Returns:
+          array: The output array.
+      )pbdoc");
+  m.def(
+      "conjugate",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::conjugate(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def conjugate(a: array, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return the elementwise complex conjugate of the input.
+        Alias for `mx.conj`.
+
+        Args:
+          a (array): Input array
+
+        Returns:
+          array: The output array.
+      )pbdoc");
+  m.def(
+      "convolve",
+      [](const mx::array& a,
+         const mx::array& v,
+         const std::string& mode,
+         mx::StreamOrDevice s) {
+        if (a.ndim() != 1 || v.ndim() != 1) {
+          throw std::invalid_argument("[convolve] Inputs must be 1D.");
+        }
+
+        if (a.size() == 0 || v.size() == 0) {
+          throw std::invalid_argument("[convolve] Inputs cannot be empty.");
+        }
+
+        mx::array in = a.size() < v.size() ? v : a;
+        mx::array wt = a.size() < v.size() ? a : v;
+        wt = mx::slice(wt, {wt.shape(0) - 1}, {-wt.shape(0) - 1}, {-1}, s);
+
+        in = mx::reshape(in, {1, -1, 1}, s);
+        wt = mx::reshape(wt, {1, -1, 1}, s);
+
+        int padding = 0;
+
+        if (mode == "full") {
+          padding = wt.size() - 1;
+        } else if (mode == "valid") {
+          padding = 0;
+        } else if (mode == "same") {
+          // Odd sizes use symmetric padding
+          if (wt.size() % 2) {
+            padding = wt.size() / 2;
+          } else { // Even sizes use asymmetric padding
+            int pad_l = wt.size() / 2;
+            int pad_r = std::max(0, pad_l - 1);
+            in = mx::pad(
+                in,
+                {{0, 0}, {pad_l, pad_r}, {0, 0}},
+                mx::array(0),
+                "constant",
+                s);
+          }
+
+        } else {
+          throw std::invalid_argument("[convolve] Invalid mode.");
+        }
+
+        mx::array out = mx::conv1d(
+            in,
+            wt,
+            /*stride = */ 1,
+            /*padding = */ padding,
+            /*dilation = */ 1,
+            /*groups = */ 1,
+            s);
+
+        return mx::reshape(out, {-1}, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      "mode"_a = "full",
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          R"(def convolve(a: array, v: array, /, mode: str = "full", *, stream: Union[None, Stream, Device] = None) -> array)"),
+      R"pbdoc(
+        The discrete convolution of 1D arrays.
+
+        If ``v`` is longer than ``a``, then they are swapped.
+        The conv filter is flipped following signal processing convention.
+
+        Args:
+            a (array): 1D Input array.
+            v (array): 1D Input array.
+            mode (str, optional): {'full', 'valid', 'same'}
+
+        Returns:
+            array: The convolved array.
+      )pbdoc");
+  m.def(
+      "conv1d",
+      &mx::conv1d,
+      nb::arg(),
+      nb::arg(),
+      "stride"_a = 1,
+      "padding"_a = 0,
+      "dilation"_a = 1,
+      "groups"_a = 1,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def conv1d(input: array, weight: array, /, stride: int = 1, padding: int = 0, dilation: int = 1, groups: int = 1, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        1D convolution over an input with several channels
+
+        Args:
+            input (array): Input array of shape ``(N, L, C_in)``.
+            weight (array): Weight array of shape ``(C_out, K, C_in)``.
+            stride (int, optional): Kernel stride. Default: ``1``.
+            padding (int, optional): Input padding. Default: ``0``.
+            dilation (int, optional): Kernel dilation. Default: ``1``.
+            groups (int, optional): Input feature groups. Default: ``1``.
+
+        Returns:
+            array: The convolved array.
+      )pbdoc");
+  m.def(
+      "conv2d",
+      [](const mx::array& input,
+         const mx::array& weight,
+         const std::variant<int, std::pair<int, int>>& stride,
+         const std::variant<int, std::pair<int, int>>& padding,
+         const std::variant<int, std::pair<int, int>>& dilation,
+         int groups,
+         mx::StreamOrDevice s) {
+        std::pair<int, int> stride_pair{1, 1};
+        std::pair<int, int> padding_pair{0, 0};
+        std::pair<int, int> dilation_pair{1, 1};
+
+        if (auto pv = std::get_if<int>(&stride); pv) {
+          stride_pair = std::pair<int, int>{*pv, *pv};
+        } else {
+          stride_pair = std::get<std::pair<int, int>>(stride);
+        }
+
+        if (auto pv = std::get_if<int>(&padding); pv) {
+          padding_pair = std::pair<int, int>{*pv, *pv};
+        } else {
+          padding_pair = std::get<std::pair<int, int>>(padding);
+        }
+
+        if (auto pv = std::get_if<int>(&dilation); pv) {
+          dilation_pair = std::pair<int, int>{*pv, *pv};
+        } else {
+          dilation_pair = std::get<std::pair<int, int>>(dilation);
+        }
+
+        return mx::conv2d(
+            input, weight, stride_pair, padding_pair, dilation_pair, groups, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      "stride"_a = 1,
+      "padding"_a = 0,
+      "dilation"_a = 1,
+      "groups"_a = 1,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def conv2d(input: array, weight: array, /, stride: Union[int, tuple[int, int]] = 1, padding: Union[int, tuple[int, int]] = 0, dilation: Union[int, tuple[int, int]] = 1, groups: int = 1, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        2D convolution over an input with several channels
+
+        Args:
+            input (array): Input array of shape ``(N, H, W, C_in)``.
+            weight (array): Weight array of shape ``(C_out, KH, KW, C_in)``.
+            stride (int or tuple(int), optional): :obj:`tuple` of size 2 with
+                kernel strides. All spatial dimensions get the same stride if
+                only one number is specified. Default: ``1``.
+            padding (int or tuple(int), optional): :obj:`tuple` of size 2 with
+                symmetric input padding. All spatial dimensions get the same
+                padding if only one number is specified. Default: ``0``.
+            dilation (int or tuple(int), optional): :obj:`tuple` of size 2 with
+                kernel dilation. All spatial dimensions get the same dilation
+                if only one number is specified. Default: ``1``
+            groups (int, optional): input feature groups. Default: ``1``.
+
+        Returns:
+            array: The convolved array.
+      )pbdoc");
+  m.def(
+      "conv3d",
+      [](const mx::array& input,
+         const mx::array& weight,
+         const std::variant<int, std::tuple<int, int, int>>& stride,
+         const std::variant<int, std::tuple<int, int, int>>& padding,
+         const std::variant<int, std::tuple<int, int, int>>& dilation,
+         int groups,
+         mx::StreamOrDevice s) {
+        std::tuple<int, int, int> stride_tuple{1, 1, 1};
+        std::tuple<int, int, int> padding_tuple{0, 0, 0};
+        std::tuple<int, int, int> dilation_tuple{1, 1, 1};
+
+        if (auto pv = std::get_if<int>(&stride); pv) {
+          stride_tuple = std::tuple<int, int, int>{*pv, *pv, *pv};
+        } else {
+          stride_tuple = std::get<std::tuple<int, int, int>>(stride);
+        }
+
+        if (auto pv = std::get_if<int>(&padding); pv) {
+          padding_tuple = std::tuple<int, int, int>{*pv, *pv, *pv};
+        } else {
+          padding_tuple = std::get<std::tuple<int, int, int>>(padding);
+        }
+
+        if (auto pv = std::get_if<int>(&dilation); pv) {
+          dilation_tuple = std::tuple<int, int, int>{*pv, *pv, *pv};
+        } else {
+          dilation_tuple = std::get<std::tuple<int, int, int>>(dilation);
+        }
+
+        return mx::conv3d(
+            input,
+            weight,
+            stride_tuple,
+            padding_tuple,
+            dilation_tuple,
+            groups,
+            s);
+      },
+      nb::arg(),
+      nb::arg(),
+      "stride"_a = 1,
+      "padding"_a = 0,
+      "dilation"_a = 1,
+      "groups"_a = 1,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def conv3d(input: array, weight: array, /, stride: Union[int, tuple[int, int, int]] = 1, padding: Union[int, tuple[int, int, int]] = 0, dilation: Union[int, tuple[int, int, int]] = 1, groups: int = 1, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        3D convolution over an input with several channels
+
+        Note: Only the default ``groups=1`` is currently supported.
+
+        Args:
+            input (array): Input array of shape ``(N, D, H, W, C_in)``.
+            weight (array): Weight array of shape ``(C_out, KD, KH, KW, C_in)``.
+            stride (int or tuple(int), optional): :obj:`tuple` of size 3 with
+                kernel strides. All spatial dimensions get the same stride if
+                only one number is specified. Default: ``1``.
+            padding (int or tuple(int), optional): :obj:`tuple` of size 3 with
+                symmetric input padding. All spatial dimensions get the same
+                padding if only one number is specified. Default: ``0``.
+            dilation (int or tuple(int), optional): :obj:`tuple` of size 3 with
+                kernel dilation. All spatial dimensions get the same dilation
+                if only one number is specified. Default: ``1``
+            groups (int, optional): input feature groups. Default: ``1``.
+
+        Returns:
+            array: The convolved array.
+      )pbdoc");
+  m.def(
+      "conv_transpose1d",
+      &mx::conv_transpose1d,
+      nb::arg(),
+      nb::arg(),
+      "stride"_a = 1,
+      "padding"_a = 0,
+      "dilation"_a = 1,
+      "output_padding"_a = 0,
+      "groups"_a = 1,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def conv_transpose1d(input: array, weight: array, /, stride: int = 1, padding: int = 0, dilation: int = 1, output_padding: int = 0, groups: int = 1, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        1D transposed convolution over an input with several channels
+
+        Args:
+            input (array): Input array of shape ``(N, L, C_in)``.
+            weight (array): Weight array of shape ``(C_out, K, C_in)``.
+            stride (int, optional): Kernel stride. Default: ``1``.
+            padding (int, optional): Input padding. Default: ``0``.
+            dilation (int, optional): Kernel dilation. Default: ``1``.
+            output_padding (int, optional): Output padding. Default: ``0``.
+            groups (int, optional): Input feature groups. Default: ``1``.
+
+        Returns:
+            array: The convolved array.
+      )pbdoc");
+  m.def(
+      "conv_transpose2d",
+      [](const mx::array& input,
+         const mx::array& weight,
+         const std::variant<int, std::pair<int, int>>& stride,
+         const std::variant<int, std::pair<int, int>>& padding,
+         const std::variant<int, std::pair<int, int>>& dilation,
+         const std::variant<int, std::pair<int, int>>& output_padding,
+         int groups,
+         mx::StreamOrDevice s) {
+        std::pair<int, int> stride_pair{1, 1};
+        std::pair<int, int> padding_pair{0, 0};
+        std::pair<int, int> dilation_pair{1, 1};
+        std::pair<int, int> output_padding_pair{0, 0};
+
+        if (auto pv = std::get_if<int>(&stride); pv) {
+          stride_pair = std::pair<int, int>{*pv, *pv};
+        } else {
+          stride_pair = std::get<std::pair<int, int>>(stride);
+        }
+
+        if (auto pv = std::get_if<int>(&padding); pv) {
+          padding_pair = std::pair<int, int>{*pv, *pv};
+        } else {
+          padding_pair = std::get<std::pair<int, int>>(padding);
+        }
+
+        if (auto pv = std::get_if<int>(&dilation); pv) {
+          dilation_pair = std::pair<int, int>{*pv, *pv};
+        } else {
+          dilation_pair = std::get<std::pair<int, int>>(dilation);
+        }
+
+        if (auto pv = std::get_if<int>(&output_padding); pv) {
+          output_padding_pair = std::pair<int, int>{*pv, *pv};
+        } else {
+          output_padding_pair = std::get<std::pair<int, int>>(output_padding);
+        }
+
+        return mx::conv_transpose2d(
+            input,
+            weight,
+            stride_pair,
+            padding_pair,
+            dilation_pair,
+            output_padding_pair,
+            groups,
+            s);
+      },
+      nb::arg(),
+      nb::arg(),
+      "stride"_a = 1,
+      "padding"_a = 0,
+      "dilation"_a = 1,
+      "output_padding"_a = 0,
+      "groups"_a = 1,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def conv_transpose2d(input: array, weight: array, /, stride: Union[int, Tuple[int, int]] = 1, padding: Union[int, Tuple[int, int]] = 0, dilation: Union[int, Tuple[int, int]] = 1, output_padding: Union[int, Tuple[int, int]] = 0, groups: int = 1, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        2D transposed convolution over an input with several channels
+
+        Note: Only the default ``groups=1`` is currently supported.
+
+        Args:
+            input (array): Input array of shape ``(N, H, W, C_in)``.
+            weight (array): Weight array of shape ``(C_out, KH, KW, C_in)``.
+            stride (int or tuple(int), optional): :obj:`tuple` of size 2 with
+                kernel strides. All spatial dimensions get the same stride if
+                only one number is specified. Default: ``1``.
+            padding (int or tuple(int), optional): :obj:`tuple` of size 2 with
+                symmetric input padding. All spatial dimensions get the same
+                padding if only one number is specified. Default: ``0``.
+            dilation (int or tuple(int), optional): :obj:`tuple` of size 2 with
+                kernel dilation. All spatial dimensions get the same dilation
+                if only one number is specified. Default: ``1``
+            output_padding (int or tuple(int), optional): :obj:`tuple` of size 2 with
+                output padding. All spatial dimensions get the same output
+                padding if only one number is specified. Default: ``0``.
+            groups (int, optional): input feature groups. Default: ``1``.
+
+        Returns:
+            array: The convolved array.
+      )pbdoc");
+  m.def(
+      "conv_transpose3d",
+      [](const mx::array& input,
+         const mx::array& weight,
+         const std::variant<int, std::tuple<int, int, int>>& stride,
+         const std::variant<int, std::tuple<int, int, int>>& padding,
+         const std::variant<int, std::tuple<int, int, int>>& dilation,
+         const std::variant<int, std::tuple<int, int, int>>& output_padding,
+         int groups,
+         mx::StreamOrDevice s) {
+        std::tuple<int, int, int> stride_tuple{1, 1, 1};
+        std::tuple<int, int, int> padding_tuple{0, 0, 0};
+        std::tuple<int, int, int> dilation_tuple{1, 1, 1};
+        std::tuple<int, int, int> output_padding_tuple{0, 0, 0};
+
+        if (auto pv = std::get_if<int>(&stride); pv) {
+          stride_tuple = std::tuple<int, int, int>{*pv, *pv, *pv};
+        } else {
+          stride_tuple = std::get<std::tuple<int, int, int>>(stride);
+        }
+
+        if (auto pv = std::get_if<int>(&padding); pv) {
+          padding_tuple = std::tuple<int, int, int>{*pv, *pv, *pv};
+        } else {
+          padding_tuple = std::get<std::tuple<int, int, int>>(padding);
+        }
+
+        if (auto pv = std::get_if<int>(&dilation); pv) {
+          dilation_tuple = std::tuple<int, int, int>{*pv, *pv, *pv};
+        } else {
+          dilation_tuple = std::get<std::tuple<int, int, int>>(dilation);
+        }
+
+        if (auto pv = std::get_if<int>(&output_padding); pv) {
+          output_padding_tuple = std::tuple<int, int, int>{*pv, *pv, *pv};
+        } else {
+          output_padding_tuple =
+              std::get<std::tuple<int, int, int>>(output_padding);
+        }
+
+        return mx::conv_transpose3d(
+            input,
+            weight,
+            stride_tuple,
+            padding_tuple,
+            dilation_tuple,
+            output_padding_tuple,
+            groups,
+            s);
+      },
+      nb::arg(),
+      nb::arg(),
+      "stride"_a = 1,
+      "padding"_a = 0,
+      "dilation"_a = 1,
+      "output_padding"_a = 0,
+      "groups"_a = 1,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def conv_transpose3d(input: array, weight: array, /, stride: Union[int, Tuple[int, int, int]] = 1, padding: Union[int, Tuple[int, int, int]] = 0, dilation: Union[int, Tuple[int, int, int]] = 1, output_padding: Union[int, Tuple[int, int, int]] = 0, groups: int = 1, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        3D transposed convolution over an input with several channels
+
+        Note: Only the default ``groups=1`` is currently supported.
+
+        Args:
+            input (array): Input array of shape ``(N, D, H, W, C_in)``.
+            weight (array): Weight array of shape ``(C_out, KD, KH, KW, C_in)``.
+            stride (int or tuple(int), optional): :obj:`tuple` of size 3 with
+                kernel strides. All spatial dimensions get the same stride if
+                only one number is specified. Default: ``1``.
+            padding (int or tuple(int), optional): :obj:`tuple` of size 3 with
+                symmetric input padding. All spatial dimensions get the same
+                padding if only one number is specified. Default: ``0``.
+            dilation (int or tuple(int), optional): :obj:`tuple` of size 3 with
+                kernel dilation. All spatial dimensions get the same dilation
+                if only one number is specified. Default: ``1``
+            output_padding (int or tuple(int), optional): :obj:`tuple` of size 3 with
+                output padding. All spatial dimensions get the same output
+                padding if only one number is specified. Default: ``0``.
+            groups (int, optional): input feature groups. Default: ``1``.
+
+        Returns:
+            array: The convolved array.
+      )pbdoc");
+  m.def(
+      "conv_general",
+      [](const mx::array& input,
+         const mx::array& weight,
+         const std::variant<int, std::vector<int>>& stride,
+         const std::variant<
+             int,
+             std::vector<int>,
+             std::pair<std::vector<int>, std::vector<int>>>& padding,
+         const std::variant<int, std::vector<int>>& kernel_dilation,
+         const std::variant<int, std::vector<int>>& input_dilation,
+         int groups,
+         bool flip,
+         mx::StreamOrDevice s) {
+        std::vector<int> stride_vec;
+        std::vector<int> padding_lo_vec;
+        std::vector<int> padding_hi_vec;
+        std::vector<int> kernel_dilation_vec;
+        std::vector<int> input_dilation_vec;
+
+        if (auto pv = std::get_if<int>(&stride); pv) {
+          stride_vec.push_back(*pv);
+        } else {
+          stride_vec = std::get<std::vector<int>>(stride);
+        }
+
+        if (auto pv = std::get_if<int>(&padding); pv) {
+          padding_lo_vec.push_back(*pv);
+          padding_hi_vec.push_back(*pv);
+        } else if (auto pv = std::get_if<std::vector<int>>(&padding); pv) {
+          padding_lo_vec = *pv;
+          padding_hi_vec = *pv;
+        } else {
+          auto [pl, ph] =
+              std::get<std::pair<std::vector<int>, std::vector<int>>>(padding);
+          padding_lo_vec = pl;
+          padding_hi_vec = ph;
+        }
+
+        if (auto pv = std::get_if<int>(&kernel_dilation); pv) {
+          kernel_dilation_vec.push_back(*pv);
+        } else {
+          kernel_dilation_vec = std::get<std::vector<int>>(kernel_dilation);
+        }
+
+        if (auto pv = std::get_if<int>(&input_dilation); pv) {
+          input_dilation_vec.push_back(*pv);
+        } else {
+          input_dilation_vec = std::get<std::vector<int>>(input_dilation);
+        }
+
+        return mx::conv_general(
+            /* array input = */ std::move(input),
+            /* array weight = */ std::move(weight),
+            /* std::vector<int> stride = */ std::move(stride_vec),
+            /* std::vector<int> padding_lo = */ std::move(padding_lo_vec),
+            /* std::vector<int> padding_hi = */ std::move(padding_hi_vec),
+            /* std::vector<int> kernel_dilation = */
+            std::move(kernel_dilation_vec),
+            /* std::vector<int> input_dilation = */
+            std::move(input_dilation_vec),
+            /* int groups = */ groups,
+            /* bool flip = */ flip,
+            s);
+      },
+      nb::arg(),
+      nb::arg(),
+      "stride"_a = 1,
+      "padding"_a = 0,
+      "kernel_dilation"_a = 1,
+      "input_dilation"_a = 1,
+      "groups"_a = 1,
+      "flip"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def conv_general(input: array, weight: array, /, stride: Union[int, Sequence[int]] = 1, padding: Union[int, Sequence[int], tuple[Sequence[int], Sequence[int]]] = 0, kernel_dilation: Union[int, Sequence[int]] = 1, input_dilation: Union[int, Sequence[int]] = 1, groups: int = 1, flip: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        General convolution over an input with several channels
+
+        Args:
+            input (array): Input array of shape ``(N, ..., C_in)``.
+            weight (array): Weight array of shape ``(C_out, ..., C_in)``.
+            stride (int or list(int), optional): :obj:`list` with kernel strides.
+                All spatial dimensions get the same stride if
+                only one number is specified. Default: ``1``.
+            padding (int, list(int), or tuple(list(int), list(int)), optional):
+                :obj:`list` with input padding. All spatial dimensions get the same
+                padding if only one number is specified. Default: ``0``.
+            kernel_dilation (int or list(int), optional): :obj:`list` with
+                kernel dilation. All spatial dimensions get the same dilation
+                if only one number is specified. Default: ``1``
+            input_dilation (int or list(int), optional): :obj:`list` with
+                input dilation. All spatial dimensions get the same dilation
+                if only one number is specified. Default: ``1``
+            groups (int, optional): Input feature groups. Default: ``1``.
+            flip (bool, optional): Flip the order in which the spatial dimensions of
+                the weights are processed. Performs the cross-correlation operator when
+                ``flip`` is ``False`` and the convolution operator otherwise.
+                Default: ``False``.
+
+        Returns:
+            array: The convolved array.
+      )pbdoc");
+  m.def(
+      "save",
+      &mlx_save_helper,
+      "file"_a,
+      "arr"_a,
+      nb::sig(
+          "def save(file: Union[file, str, pathlib.Path], arr: array) -> None"),
+      R"pbdoc(
+        Save the array to a binary file in ``.npy`` format.
+
+        Args:
+            file (str, pathlib.Path, file): File to which the array is saved
+            arr (array): Array to be saved.
+      )pbdoc");
+  m.def(
+      "savez",
+      [](nb::object file, nb::args args, const nb::kwargs& kwargs) {
+        mlx_savez_helper(file, args, kwargs, /* compressed= */ false);
+      },
+      "file"_a,
+      "args"_a,
+      "kwargs"_a,
+      nb::sig(
+          "def savez(file: Union[file, str, pathlib.Path], *args, **kwargs)"),
+      R"pbdoc(
+        Save several arrays to a binary file in uncompressed ``.npz``
+        format.
+
+        .. code-block:: python
+
+            import mlx.core as mx
+
+            x = mx.ones((10, 10))
+            mx.savez("my_path.npz", x=x)
+
+            import mlx.nn as nn
+            from mlx.utils import tree_flatten
+
+            model = nn.TransformerEncoder(6, 128, 4)
+            flat_params = tree_flatten(model.parameters())
+            mx.savez("model.npz", **dict(flat_params))
+
+        Args:
+            file (file, str, pathlib.Path): Path to file to which the arrays are saved.
+            *args (arrays): Arrays to be saved.
+            **kwargs (arrays): Arrays to be saved. Each array will be saved
+              with the associated keyword as the output file name.
+      )pbdoc");
+  m.def(
+      "savez_compressed",
+      [](nb::object file, nb::args args, const nb::kwargs& kwargs) {
+        mlx_savez_helper(file, args, kwargs, /*compressed=*/true);
+      },
+      nb::arg(),
+      "args"_a,
+      "kwargs"_a,
+      nb::sig(
+          "def savez_compressed(file: Union[file, str, pathlib.Path], *args, **kwargs)"),
+      R"pbdoc(
+        Save several arrays to a binary file in compressed ``.npz`` format.
+
+        Args:
+            file (file, str, pathlib.Path): Path to file to which the arrays are saved.
+            *args (arrays): Arrays to be saved.
+            **kwargs (arrays): Arrays to be saved. Each array will be saved
+              with the associated keyword as the output file name.
+      )pbdoc");
+  m.def(
+      "load",
+      &mlx_load_helper,
+      nb::arg(),
+      "format"_a = nb::none(),
+      "return_metadata"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def load(file: Union[file, str, pathlib.Path], /, format: Optional[str] = None, return_metadata: bool = False, *, stream: Union[None, Stream, Device] = None) -> Union[array, dict[str, array]]"),
+      R"pbdoc(
+        Load array(s) from a binary file.
+
+        The supported formats are ``.npy``, ``.npz``, ``.safetensors``, and
+        ``.gguf``.
+
+        Args:
+            file (file, str, pathlib.Path): File in which the array is saved.
+            format (str, optional): Format of the file. If ``None``, the
+              format is inferred from the file extension. Supported formats:
+              ``npy``, ``npz``, and ``safetensors``. Default: ``None``.
+            return_metadata (bool, optional): Load the metadata for formats
+              which support matadata. The metadata will be returned as an
+              additional dictionary. Default: ``False``.
+        Returns:
+            array or dict:
+                A single array if loading from a ``.npy`` file or a dict
+                mapping names to arrays if loading from a ``.npz`` or
+                ``.safetensors`` file. If ``return_metadata`` is ``True`` an
+                additional dictionary of metadata will be returned.
+
+        Warning:
+
+          When loading unsupported quantization formats from GGUF, tensors
+          will automatically cast to ``mx.float16``
+      )pbdoc");
+  m.def(
+      "save_safetensors",
+      &mlx_save_safetensor_helper,
+      "file"_a,
+      "arrays"_a,
+      "metadata"_a = nb::none(),
+      nb::sig(
+          "def save_safetensors(file: Union[file, str, pathlib.Path], arrays: dict[str, array], metadata: Optional[dict[str, str]] = None)"),
+      R"pbdoc(
+        Save array(s) to a binary file in ``.safetensors`` format.
+
+        See the `Safetensors documentation
+        <https://huggingface.co/docs/safetensors/index>`_ for more
+        information on the format.
+
+        Args:
+            file (file, str, pathlib.Path): File in which the array is saved.
+            arrays (dict(str, array)): The dictionary of names to arrays to
+              be saved.
+            metadata (dict(str, str), optional): The dictionary of
+              metadata to be saved.
+      )pbdoc");
+  m.def(
+      "save_gguf",
+      &mlx_save_gguf_helper,
+      "file"_a,
+      "arrays"_a,
+      "metadata"_a = nb::none(),
+      nb::sig(
+          "def save_gguf(file: Union[file, str, pathlib.Path], arrays: dict[str, array], metadata: dict[str, Union[array, str, list[str]]])"),
+      R"pbdoc(
+        Save array(s) to a binary file in ``.gguf`` format.
+
+        See the `GGUF documentation
+        <https://github.com/ggerganov/ggml/blob/master/docs/gguf.md>`_ for
+        more information on the format.
+
+        Args:
+            file (file, str, pathlib.Path): File in which the array is saved.
+            arrays (dict(str, array)): The dictionary of names to arrays to
+              be saved.
+            metadata (dict(str, Union[array, str, list(str)])): The dictionary
+               of metadata to be saved. The values can be a scalar or 1D
+               obj:`array`, a :obj:`str`, or a :obj:`list` of :obj:`str`.
+      )pbdoc");
+  m.def(
+      "where",
+      [](const ScalarOrArray& condition,
+         const ScalarOrArray& x_,
+         const ScalarOrArray& y_,
+         mx::StreamOrDevice s) {
+        auto [x, y] = to_arrays(x_, y_);
+        return mx::where(to_array(condition), x, y, s);
+      },
+      "condition"_a,
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def where(condition: Union[scalar, array], x: Union[scalar, array], y: Union[scalar, array], /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Select from ``x`` or ``y`` according to ``condition``.
+
+        The condition and input arrays must be the same shape or
+        broadcastable with each another.
+
+        Args:
+          condition (array): The condition array.
+          x (array): The input selected from where condition is ``True``.
+          y (array): The input selected from where condition is ``False``.
+
+        Returns:
+            array: The output containing elements selected from
+            ``x`` and ``y``.
+      )pbdoc");
+  m.def(
+      "nan_to_num",
+      [](const ScalarOrArray& a,
+         float nan,
+         std::optional<float>& posinf,
+         std::optional<float>& neginf,
+         mx::StreamOrDevice s) {
+        return mx::nan_to_num(to_array(a), nan, posinf, neginf, s);
+      },
+      nb::arg(),
+      "nan"_a = 0.0f,
+      "posinf"_a = nb::none(),
+      "neginf"_a = nb::none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def nan_to_num(a: Union[scalar, array], nan: float = 0, posinf: Optional[float] = None, neginf: Optional[float] = None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Replace NaN and Inf values with finite numbers.
+
+        Args:
+            a (array): Input array
+            nan (float, optional): Value to replace NaN with. Default: ``0``.
+            posinf (float, optional): Value to replace positive infinities
+              with. If ``None``, defaults to largest finite value for the
+              given data type. Default: ``None``.
+            neginf (float, optional): Value to replace negative infinities
+              with. If ``None``, defaults to the negative of the largest
+              finite value for the given data type. Default: ``None``.
+
+        Returns:
+            array: Output array with NaN and Inf replaced.
+    )pbdoc");
+  m.def(
+      "round",
+      [](const ScalarOrArray& a, int decimals, mx::StreamOrDevice s) {
+        return mx::round(to_array(a), decimals, s);
+      },
+      nb::arg(),
+      "decimals"_a = 0,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def round(a: array, /, decimals: int = 0, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Round to the given number of decimals.
+
+        Basically performs:
+
+        .. code-block:: python
+
+          s = 10**decimals
+          x = round(x * s) / s
+
+        Args:
+          a (array): Input array
+          decimals (int): Number of decimal places to round to. (default: 0)
+
+        Returns:
+          array: An array of the same type as ``a`` rounded to the
+          given number of decimals.
+      )pbdoc");
+  m.def(
+      "quantized_matmul",
+      &mx::quantized_matmul,
+      nb::arg(),
+      nb::arg(),
+      "scales"_a,
+      "biases"_a = nb::none(),
+      "transpose"_a = true,
+      "group_size"_a = 64,
+      "bits"_a = 4,
+      "mode"_a = "affine",
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def quantized_matmul(x: array, w: array, /, scales: array, biases: Optional[array] = None, transpose: bool = True, group_size: int = 64, bits: int = 4, mode: str = 'affine', *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Perform the matrix multiplication with the quantized matrix ``w``. The
+        quantization uses one floating point scale and bias per ``group_size`` of
+        elements. Each element in ``w`` takes ``bits`` bits and is packed in an
+        unsigned 32 bit integer.
+
+        Args:
+          x (array): Input array
+          w (array): Quantized matrix packed in unsigned integers
+          scales (array): The scales to use per ``group_size`` elements of ``w``
+          biases (array, optional): The biases to use per ``group_size``
+            elements of ``w``. Default: ``None``.
+          transpose (bool, optional): Defines whether to multiply with the
+            transposed ``w`` or not, namely whether we are performing
+            ``x @ w.T`` or ``x @ w``. Default: ``True``.
+          group_size (int, optional): The size of the group in ``w`` that
+            shares a scale and bias. Default: ``64``.
+          bits (int, optional): The number of bits occupied by each element in
+            ``w``. Default: ``4``.
+          mode (str, optional): The quantization mode. Default: ``"affine"``.
+
+        Returns:
+          array: The result of the multiplication of ``x`` with ``w``.
+      )pbdoc");
+  m.def(
+      "quantize",
+      &mx::quantize,
+      nb::arg(),
+      "group_size"_a = 64,
+      "bits"_a = 4,
+      "mode"_a = "affine",
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def quantize(w: array, /, group_size: int = 64, bits: int = 4, mode: str = 'affine', *, stream: Union[None, Stream, Device] = None) -> tuple[array, array, array]"),
+      R"pbdoc(
+        Quantize the matrix ``w`` using ``bits`` bits per element.
+
+        Note, every ``group_size`` elements in a row of ``w`` are quantized
+        together. Hence, number of columns of ``w`` should be divisible by
+        ``group_size``. In particular, the rows of ``w`` are divided into groups of
+        size ``group_size`` which are quantized together.
+
+        .. warning::
+
+          ``quantize`` currently only supports 2D inputs with the second
+          dimension divisible by ``group_size``
+
+        The supported quantization modes are ``"affine"`` and ``"mxfp4"``. They
+        are described in more detail below.
+
+        Args:
+          w (array): Matrix to be quantized
+          group_size (int, optional): The size of the group in ``w`` that shares a
+            scale and bias. Default: ``64``.
+          bits (int, optional): The number of bits occupied by each element of
+            ``w`` in the returned quantized matrix. Default: ``4``.
+          mode (str, optional): The quantization mode. Default: ``"affine"``.
+
+        Returns:
+          tuple: A tuple with either two or three elements containing:
+
+          * w_q (array): The quantized version of ``w``
+          * scales (array): The quantization scales
+          * biases (array): The quantization biases (returned for ``mode=="affine"``).
+
+        Notes:
+          The ``affine`` mode quantizes groups of :math:`g` consecutive
+          elements in a row of ``w``. For each group the quantized
+          representation of each element :math:`\hat{w_i}` is computed as follows:
+
+          .. math::
+
+            \begin{aligned}
+              \alpha &= \max_i w_i \\
+              \beta &= \min_i w_i \\
+              s &= \frac{\alpha - \beta}{2^b - 1} \\
+              \hat{w_i} &= \textrm{round}\left( \frac{w_i - \beta}{s}\right).
+            \end{aligned}
+
+          After the above computation, :math:`\hat{w_i}` fits in :math:`b` bits
+          and is packed in an unsigned 32-bit integer from the lower to upper
+          bits. For instance, for 4-bit quantization we fit 8 elements in an
+          unsigned 32 bit integer where the 1st element occupies the 4 least
+          significant bits, the 2nd bits 4-7 etc.
+
+          To dequantize the elements of ``w``, we also save :math:`s` and
+          :math:`\beta` which are the returned ``scales`` and
+          ``biases`` respectively.
+
+          The ``mxfp4`` mode similarly quantizes groups of :math:`g` elements
+          of ``w``. For ``mxfp4`` the group size must be ``32``. The elements
+          are quantized to 4-bit precision floating-point values (E2M1) with a
+          shared 8-bit scale per group. Unlike ``affine`` quantization,
+          ``mxfp4`` does not have a bias value. More details on the format can
+          be found in the `specification <https://www.opencompute.org/documents/ocp-microscaling-formats-mx-v1-0-spec-final-pdf>`_.
+      )pbdoc");
+  m.def(
+      "dequantize",
+      &mx::dequantize,
+      nb::arg(),
+      "scales"_a,
+      "biases"_a = nb::none(),
+      "group_size"_a = 64,
+      "bits"_a = 4,
+      "mode"_a = "affine",
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def dequantize(w: array, /, scales: array, biases: Optional[array] = None, group_size: int = 64, bits: int = 4, mode: str = 'affine', *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Dequantize the matrix ``w`` using quantization parameters.
+
+        Args:
+          w (array): Matrix to be dequantized
+          scales (array): The scales to use per ``group_size`` elements of ``w``.
+          biases (array, optional): The biases to use per ``group_size``
+             elements of ``w``. Default: ``None``.
+          group_size (int, optional): The size of the group in ``w`` that shares a
+            scale and bias. Default: ``64``.
+          bits (int, optional): The number of bits occupied by each element in
+            ``w``. Default: ``4``.
+          mode (str, optional): The quantization mode. Default: ``"affine"``.
+
+        Returns:
+          array: The dequantized version of ``w``
+
+        Notes:
+          The currently supported quantization modes are ``"affine"`` and ``mxfp4``.
+
+          For ``affine`` quantization, given the notation in :func:`quantize`,
+          we compute :math:`w_i` from :math:`\hat{w_i}` and corresponding :math:`s`
+          and :math:`\beta` as follows
+
+          .. math::
+
+            w_i = s \hat{w_i} + \beta
+      )pbdoc");
+  m.def(
+      "gather_qmm",
+      &mx::gather_qmm,
+      nb::arg(),
+      nb::arg(),
+      "scales"_a,
+      "biases"_a = nb::none(),
+      "lhs_indices"_a = nb::none(),
+      "rhs_indices"_a = nb::none(),
+      "transpose"_a = true,
+      "group_size"_a = 64,
+      "bits"_a = 4,
+      "mode"_a = "affine",
+      nb::kw_only(),
+      "sorted_indices"_a = false,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def gather_qmm(x: array, w: array, /, scales: array, biases: Optional[array] = None, lhs_indices: Optional[array] = None, rhs_indices: Optional[array] = None, transpose: bool = True, group_size: int = 64, bits: int = 4, mode: str = 'affine', *, sorted_indices: bool = False, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Perform quantized matrix multiplication with matrix-level gather.
+
+        This operation is the quantized equivalent to :func:`gather_mm`.
+        Similar to :func:`gather_mm`, the indices ``lhs_indices`` and
+        ``rhs_indices`` contain flat indices along the batch dimensions (i.e.
+        all but the last two dimensions) of ``x`` and ``w`` respectively.
+
+        Note that ``scales`` and ``biases`` must have the same batch dimensions
+        as ``w`` since they represent the same quantized matrix.
+
+        Args:
+            x (array): Input array
+            w (array): Quantized matrix packed in unsigned integers
+            scales (array): The scales to use per ``group_size`` elements of ``w``
+            biases (array, optional): The biases to use per ``group_size``
+              elements of ``w``. Default: ``None``.
+            lhs_indices (array, optional): Integer indices for ``x``. Default: ``None``.
+            rhs_indices (array, optional): Integer indices for ``w``. Default: ``None``.
+            transpose (bool, optional): Defines whether to multiply with the
+              transposed ``w`` or not, namely whether we are performing
+              ``x @ w.T`` or ``x @ w``. Default: ``True``.
+            group_size (int, optional): The size of the group in ``w`` that
+              shares a scale and bias. Default: ``64``.
+            bits (int, optional): The number of bits occupied by each element in
+              ``w``. Default: ``4``.
+            mode (str, optional): The quantization mode. Default: ``"affine"``.
+            sorted_indices (bool, optional): May allow a faster implementation
+              if the passed indices are sorted. Default: ``False``.
+
+        Returns:
+            array: The result of the multiplication of ``x`` with ``w``
+              after gathering using ``lhs_indices`` and ``rhs_indices``.
+      )pbdoc");
+  m.def(
+      "segmented_mm",
+      &mx::segmented_mm,
+      nb::arg(),
+      nb::arg(),
+      "segments"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def segmented_mm(a: array, b: array, /, segments: array, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Perform a matrix multiplication but segment the inner dimension and
+        save the result for each segment separately.
+
+        Args:
+          a (array): Input array of shape ``MxK``.
+          b (array): Input array of shape ``KxN``.
+          segments (array): The offsets into the inner dimension for each segment.
+
+        Returns:
+          array: The result per segment of shape ``MxN``.
+      )pbdoc");
+  m.def(
+      "tensordot",
+      [](const mx::array& a,
+         const mx::array& b,
+         const std::variant<int, std::vector<std::vector<int>>>& axes,
+         mx::StreamOrDevice s) {
+        if (auto pv = std::get_if<int>(&axes); pv) {
+          return mx::tensordot(a, b, *pv, s);
+        } else {
+          auto& x = std::get<std::vector<std::vector<int>>>(axes);
+          if (x.size() != 2) {
+            throw std::invalid_argument(
+                "[tensordot] axes must be a list of two lists.");
+          }
+          return mx::tensordot(a, b, x[0], x[1], s);
+        }
+      },
+      nb::arg(),
+      nb::arg(),
+      "axes"_a = 2,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def tensordot(a: array, b: array, /, axes: Union[int, list[Sequence[int]]] = 2, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Compute the tensor dot product along the specified axes.
+
+        Args:
+            a (array): Input array
+            b (array): Input array
+            axes (int or list(list(int)), optional): The number of dimensions to
+              sum over. If an integer is provided, then sum over the last
+              ``axes`` dimensions of ``a`` and the first ``axes`` dimensions of
+              ``b``. If a list of lists is provided, then sum over the
+              corresponding dimensions of ``a`` and ``b``. Default: 2.
+
+        Returns:
+            array: The tensor dot product.
+      )pbdoc");
+  m.def(
+      "inner",
+      &mx::inner,
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def inner(a: array, b: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+      Ordinary inner product of vectors for 1-D arrays, in higher dimensions a sum product over the last axes.
+
+      Args:
+        a (array): Input array
+        b (array): Input array
+
+      Returns:
+        array: The inner product.
+    )pbdoc");
+  m.def(
+      "outer",
+      &mx::outer,
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def outer(a: array, b: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+      Compute the outer product of two 1-D arrays, if the array's passed are not 1-D a flatten op will be run beforehand.
+
+      Args:
+        a (array): Input array
+        b (array): Input array
+
+      Returns:
+        array: The outer product.
+    )pbdoc");
+  m.def(
+      "tile",
+      [](const mx::array& a,
+         const std::variant<int, std::vector<int>>& reps,
+         mx::StreamOrDevice s) {
+        if (auto pv = std::get_if<int>(&reps); pv) {
+          return mx::tile(a, {*pv}, s);
+        } else {
+          return mx::tile(a, std::get<std::vector<int>>(reps), s);
+        }
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def tile(a: array, reps: Union[int, Sequence[int]], /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+      Construct an array by repeating ``a`` the number of times given by ``reps``.
+
+      Args:
+        a (array): Input array
+        reps (int or list(int)): The number of times to repeat ``a`` along each axis.
+
+      Returns:
+        array: The tiled array.
+    )pbdoc");
+  m.def(
+      "addmm",
+      &mx::addmm,
+      nb::arg(),
+      nb::arg(),
+      nb::arg(),
+      "alpha"_a = 1.0f,
+      "beta"_a = 1.0f,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def addmm(c: array, a: array, b: array, /, alpha: float = 1.0, beta: float = 1.0,  *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Matrix multiplication with addition and optional scaling.
+
+        Perform the (possibly batched) matrix multiplication of two arrays and add to the result
+        with optional scaling factors.
+
+        Args:
+            c (array): Input array or scalar.
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+            alpha (float, optional): Scaling factor for the
+                matrix product of ``a`` and ``b`` (default: ``1``)
+            beta (float, optional): Scaling factor for ``c`` (default: ``1``)
+
+        Returns:
+            array: ``alpha * (a @ b)  + beta * c``
+      )pbdoc");
+  m.def(
+      "block_masked_mm",
+      &mx::block_masked_mm,
+      nb::arg(),
+      nb::arg(),
+      "block_size"_a = 64,
+      "mask_out"_a = nb::none(),
+      "mask_lhs"_a = nb::none(),
+      "mask_rhs"_a = nb::none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def block_masked_mm(a: array, b: array, /, block_size: int = 64, mask_out: Optional[array] = None, mask_lhs: Optional[array] = None, mask_rhs: Optional[array] = None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Matrix multiplication with block masking.
+
+        Perform the (possibly batched) matrix multiplication of two arrays and with blocks
+        of size ``block_size x block_size`` optionally masked out.
+
+        Assuming ``a`` with shape (..., `M`, `K`) and b with shape (..., `K`, `N`)
+
+        * ``lhs_mask`` must have shape (..., :math:`\lceil` `M` / ``block_size`` :math:`\rceil`, :math:`\lceil` `K` / ``block_size`` :math:`\rceil`)
+
+        * ``rhs_mask`` must have shape (..., :math:`\lceil` `K` / ``block_size`` :math:`\rceil`, :math:`\lceil` `N` / ``block_size`` :math:`\rceil`)
+
+        * ``out_mask`` must have shape (..., :math:`\lceil` `M` / ``block_size`` :math:`\rceil`, :math:`\lceil` `N` / ``block_size`` :math:`\rceil`)
+
+        Note: Only ``block_size=64`` and ``block_size=32`` are currently supported
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+            block_size (int): Size of blocks to be masked. Must be ``32`` or ``64``. Default: ``64``.
+            mask_out (array, optional): Mask for output. Default: ``None``.
+            mask_lhs (array, optional): Mask for ``a``. Default: ``None``.
+            mask_rhs (array, optional): Mask for ``b``. Default: ``None``.
+
+        Returns:
+            array: The output array.
+      )pbdoc");
+  m.def(
+      "gather_mm",
+      &mx::gather_mm,
+      nb::arg(),
+      nb::arg(),
+      "lhs_indices"_a = nb::none(),
+      "rhs_indices"_a = nb::none(),
+      nb::kw_only(),
+      "sorted_indices"_a = false,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def gather_mm(a: array, b: array, /, lhs_indices: array, rhs_indices: array, *, sorted_indices: bool = False, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Matrix multiplication with matrix-level gather.
+
+        Performs a gather of the operands with the given indices followed by a
+        (possibly batched) matrix multiplication of two arrays.  This operation
+        is more efficient than explicitly applying a :func:`take` followed by a
+        :func:`matmul`.
+
+        The indices ``lhs_indices`` and ``rhs_indices`` contain flat indices
+        along the batch dimensions (i.e. all but the last two dimensions) of
+        ``a`` and ``b`` respectively.
+
+        For ``a`` with shape ``(A1, A2, ..., AS, M, K)``, ``lhs_indices``
+        contains indices from the range ``[0, A1 * A2 * ... * AS)``
+
+        For ``b`` with shape ``(B1, B2, ..., BS, M, K)``, ``rhs_indices``
+        contains indices from the range ``[0, B1 * B2 * ... * BS)``
+
+        If only one index is passed and it is sorted, the ``sorted_indices``
+        flag can be passed for a possible faster implementation.
+
+        Args:
+            a (array): Input array.
+            b (array): Input array.
+            lhs_indices (array, optional): Integer indices for ``a``. Default: ``None``
+            rhs_indices (array, optional): Integer indices for ``b``. Default: ``None``
+            sorted_indices (bool, optional): May allow a faster implementation
+              if the passed indices are sorted. Default: ``False``.
+
+        Returns:
+            array: The output array.
+      )pbdoc");
+  m.def(
+      "diagonal",
+      &mx::diagonal,
+      "a"_a,
+      "offset"_a = 0,
+      "axis1"_a = 0,
+      "axis2"_a = 1,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def diagonal(a: array, offset: int = 0, axis1: int = 0, axis2: int = 1, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return specified diagonals.
+
+        If ``a`` is 2-D, then a 1-D array containing the diagonal at the given
+        ``offset`` is returned.
+
+        If ``a`` has more than two dimensions, then ``axis1`` and ``axis2``
+        determine the 2D subarrays from which diagonals are extracted. The new
+        shape is the original shape with ``axis1`` and ``axis2`` removed and a
+        new dimension inserted at the end corresponding to the diagonal.
+
+        Args:
+          a (array): Input array
+          offset (int, optional): Offset of the diagonal from the main diagonal.
+            Can be positive or negative. Default: ``0``.
+          axis1 (int, optional): The first axis of the 2-D sub-arrays from which
+              the diagonals should be taken. Default: ``0``.
+          axis2 (int, optional): The second axis of the 2-D sub-arrays from which
+              the diagonals should be taken. Default: ``1``.
+
+        Returns:
+            array: The diagonals of the array.
+      )pbdoc");
+  m.def(
+      "diag",
+      &mx::diag,
+      nb::arg(),
+      "k"_a = 0,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def diag(a: array, /, k: int = 0, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Extract a diagonal or construct a diagonal matrix.
+        If ``a`` is 1-D then a diagonal matrix is constructed with ``a`` on the
+        :math:`k`-th diagonal. If ``a`` is 2-D then the :math:`k`-th diagonal is
+        returned.
+
+        Args:
+            a (array): 1-D or 2-D input array.
+            k (int, optional): The diagonal to extract or construct.
+                Default: ``0``.
+
+        Returns:
+            array: The extracted diagonal or the constructed diagonal matrix.
+        )pbdoc");
+  m.def(
+      "trace",
+      [](const mx::array& a,
+         int offset,
+         int axis1,
+         int axis2,
+         std::optional<mx::Dtype> dtype,
+         mx::StreamOrDevice s) {
+        if (!dtype.has_value()) {
+          return mx::trace(a, offset, axis1, axis2, s);
+        }
+        return mx::trace(a, offset, axis1, axis2, dtype.value(), s);
+      },
+      nb::arg(),
+      "offset"_a = 0,
+      "axis1"_a = 0,
+      "axis2"_a = 1,
+      "dtype"_a = nb::none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def trace(a: array, /, offset: int = 0, axis1: int = 0, axis2: int = 1, dtype: Optional[Dtype] = None, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Return the sum along a specified diagonal in the given array.
+
+        Args:
+          a (array): Input array
+          offset (int, optional): Offset of the diagonal from the main diagonal.
+            Can be positive or negative. Default: ``0``.
+          axis1 (int, optional): The first axis of the 2-D sub-arrays from which
+              the diagonals should be taken. Default: ``0``.
+          axis2 (int, optional): The second axis of the 2-D sub-arrays from which
+              the diagonals should be taken. Default: ``1``.
+          dtype (Dtype, optional): Data type of the output array. If
+              unspecified the output type is inferred from the input array.
+
+        Returns:
+            array: Sum of specified diagonal.
+        )pbdoc");
+  m.def(
+      "atleast_1d",
+      [](const nb::args& arys, mx::StreamOrDevice s) -> nb::object {
+        if (arys.size() == 1) {
+          return nb::cast(mx::atleast_1d(nb::cast<mx::array>(arys[0]), s));
+        }
+        return nb::cast(
+            mx::atleast_1d(nb::cast<std::vector<mx::array>>(arys), s));
+      },
+      "arys"_a,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def atleast_1d(*arys: array, stream: Union[None, Stream, Device] = None) -> Union[array, list[array]]"),
+      R"pbdoc(
+        Convert all arrays to have at least one dimension.
+
+        Args:
+            *arys: Input arrays.
+            stream (Union[None, Stream, Device], optional): The stream to execute the operation on.
+
+        Returns:
+            array or list(array): An array or list of arrays with at least one dimension.
+        )pbdoc");
+  m.def(
+      "atleast_2d",
+      [](const nb::args& arys, mx::StreamOrDevice s) -> nb::object {
+        if (arys.size() == 1) {
+          return nb::cast(mx::atleast_2d(nb::cast<mx::array>(arys[0]), s));
+        }
+        return nb::cast(
+            mx::atleast_2d(nb::cast<std::vector<mx::array>>(arys), s));
+      },
+      "arys"_a,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def atleast_2d(*arys: array, stream: Union[None, Stream, Device] = None) -> Union[array, list[array]]"),
+      R"pbdoc(
+        Convert all arrays to have at least two dimensions.
+
+        Args:
+            *arys: Input arrays.
+            stream (Union[None, Stream, Device], optional): The stream to execute the operation on.
+
+        Returns:
+            array or list(array): An array or list of arrays with at least two dimensions.
+        )pbdoc");
+  m.def(
+      "atleast_3d",
+      [](const nb::args& arys, mx::StreamOrDevice s) -> nb::object {
+        if (arys.size() == 1) {
+          return nb::cast(mx::atleast_3d(nb::cast<mx::array>(arys[0]), s));
+        }
+        return nb::cast(
+            mx::atleast_3d(nb::cast<std::vector<mx::array>>(arys), s));
+      },
+      "arys"_a,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def atleast_3d(*arys: array, stream: Union[None, Stream, Device] = None) -> Union[array, list[array]]"),
+      R"pbdoc(
+        Convert all arrays to have at least three dimensions.
+
+        Args:
+            *arys: Input arrays.
+            stream (Union[None, Stream, Device], optional): The stream to execute the operation on.
+
+        Returns:
+            array or list(array): An array or list of arrays with at least three dimensions.
+        )pbdoc");
+  m.def(
+      "issubdtype",
+      [](const nb::object& d1, const nb::object& d2) {
+        auto dispatch_second = [](const auto& t1, const auto& d2) {
+          if (nb::isinstance<mx::Dtype>(d2)) {
+            return mx::issubdtype(t1, nb::cast<mx::Dtype>(d2));
+          } else if (nb::isinstance<mx::Dtype::Category>(d2)) {
+            return mx::issubdtype(t1, nb::cast<mx::Dtype::Category>(d2));
+          } else {
+            throw std::invalid_argument(
+                "[issubdtype] Received invalid type for second input.");
+          }
+        };
+        if (nb::isinstance<mx::Dtype>(d1)) {
+          return dispatch_second(nb::cast<mx::Dtype>(d1), d2);
+        } else if (nb::isinstance<mx::Dtype::Category>(d1)) {
+          return dispatch_second(nb::cast<mx::Dtype::Category>(d1), d2);
+        } else {
+          throw std::invalid_argument(
+              "[issubdtype] Received invalid type for first input.");
+        }
+      },
+      ""_a,
+      ""_a,
+      nb::sig(
+          "def issubdtype(arg1: Union[Dtype, DtypeCategory], arg2: Union[Dtype, DtypeCategory]) -> bool"),
+      R"pbdoc(
+        Check if a :obj:`Dtype` or :obj:`DtypeCategory` is a subtype
+        of another.
+
+        Args:
+            arg1 (Union[Dtype, DtypeCategory]: First dtype or category.
+            arg2 (Union[Dtype, DtypeCategory]: Second dtype or category.
+
+        Returns:
+            bool:
+               A boolean indicating if the first input is a subtype of the
+               second input.
+
+        Example:
+
+          >>> ints = mx.array([1, 2, 3], dtype=mx.int32)
+          >>> mx.issubdtype(ints.dtype, mx.integer)
+          True
+          >>> mx.issubdtype(ints.dtype, mx.floating)
+          False
+
+          >>> floats = mx.array([1, 2, 3], dtype=mx.float32)
+          >>> mx.issubdtype(floats.dtype, mx.integer)
+          False
+          >>> mx.issubdtype(floats.dtype, mx.floating)
+          True
+
+          Similar types of different sizes are not subdtypes of each other:
+
+          >>> mx.issubdtype(mx.float64, mx.float32)
+          False
+          >>> mx.issubdtype(mx.float32, mx.float64)
+          False
+
+          but both are subtypes of `floating`:
+
+          >>> mx.issubdtype(mx.float64, mx.floating)
+          True
+          >>> mx.issubdtype(mx.float32, mx.floating)
+          True
+
+          For convenience, dtype-like objects are allowed too:
+
+          >>> mx.issubdtype(mx.float32, mx.inexact)
+          True
+          >>> mx.issubdtype(mx.signedinteger, mx.floating)
+          False
+      )pbdoc");
+  m.def(
+      "bitwise_and",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::bitwise_and(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def bitwise_and(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise bitwise and.
+
+        Take the bitwise and of two arrays with numpy-style broadcasting
+        semantics. Either or both input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The bitwise and ``a & b``.
+      )pbdoc");
+  m.def(
+      "bitwise_or",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::bitwise_or(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def bitwise_or(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise bitwise or.
+
+        Take the bitwise or of two arrays with numpy-style broadcasting
+        semantics. Either or both input arrays can also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The bitwise or``a | b``.
+      )pbdoc");
+  m.def(
+      "bitwise_xor",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::bitwise_xor(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def bitwise_xor(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise bitwise xor.
+
+        Take the bitwise exclusive or of two arrays with numpy-style
+        broadcasting semantics. Either or both input arrays can also be
+        scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The bitwise xor ``a ^ b``.
+      )pbdoc");
+  m.def(
+      "left_shift",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::left_shift(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def left_shift(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise left shift.
+
+        Shift the bits of the first input to the left by the second using
+        numpy-style broadcasting semantics. Either or both input arrays can
+        also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The bitwise left shift ``a << b``.
+      )pbdoc");
+  m.def(
+      "right_shift",
+      [](const ScalarOrArray& a_,
+         const ScalarOrArray& b_,
+         mx::StreamOrDevice s) {
+        auto [a, b] = to_arrays(a_, b_);
+        return mx::right_shift(a, b, s);
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def right_shift(a: Union[scalar, array], b: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise right shift.
+
+        Shift the bits of the first input to the right by the second using
+        numpy-style broadcasting semantics. Either or both input arrays can
+        also be scalars.
+
+        Args:
+            a (array): Input array or scalar.
+            b (array): Input array or scalar.
+
+        Returns:
+            array: The bitwise right shift ``a >> b``.
+      )pbdoc");
+  m.def(
+      "bitwise_invert",
+      [](const ScalarOrArray& a_, mx::StreamOrDevice s) {
+        auto a = to_array(a_);
+        return mx::bitwise_invert(a, s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def bitwise_invert(a: Union[scalar, array], stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Element-wise bitwise inverse.
+
+        Take the bitwise complement of the input.
+
+        Args:
+            a (array): Input array or scalar.
+
+        Returns:
+            array: The bitwise inverse ``~a``.
+      )pbdoc");
+  m.def(
+      "view",
+      [](const ScalarOrArray& a, const mx::Dtype& dtype, mx::StreamOrDevice s) {
+        return mx::view(to_array(a), dtype, s);
+      },
+      nb::arg(),
+      "dtype"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def view(a: Union[scalar, array], dtype: Dtype, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        View the array as a different type.
+
+        The output shape changes along the last axis if the input array's
+        type and the input ``dtype`` do not have the same size.
+
+        Note: the view op does not imply that the input and output arrays share
+        their underlying data. The view only gaurantees that the binary
+        representation of each element (or group of elements) is the same.
+
+        Args:
+            a (array): Input array or scalar.
+            dtype (Dtype): The data type to change to.
+
+        Returns:
+            array: The array with the new type.
+      )pbdoc");
+  m.def(
+      "hadamard_transform",
+      &mx::hadamard_transform,
+      nb::arg(),
+      "scale"_a = nb::none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def hadamard_transform(a: array, scale: Optional[float] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Perform the Walsh-Hadamard transform along the final axis.
+
+        Equivalent to:
+
+        .. code-block:: python
+
+           from scipy.linalg import hadamard
+
+           y = (hadamard(len(x)) @ x) * scale
+
+        Supports sizes ``n = m*2^k`` for ``m`` in ``(1, 12, 20, 28)`` and ``2^k
+        <= 8192`` for float32 and ``2^k <= 16384`` for float16/bfloat16.
+
+        Args:
+            a (array): Input array or scalar.
+            scale (float): Scale the output by this factor.
+              Defaults to ``1/sqrt(a.shape[-1])`` so that the Hadamard matrix is orthonormal.
+
+        Returns:
+            array: The transformed array.
+      )pbdoc");
+  m.def(
+      "einsum_path",
+      [](const std::string& equation, const nb::args& operands) {
+        auto arrays_list = nb::cast<std::vector<mx::array>>(operands);
+        auto [path, str] = mx::einsum_path(equation, arrays_list);
+        // Convert to list of tuples
+        std::vector<nb::tuple> tuple_path;
+        for (auto& p : path) {
+          tuple_path.push_back(nb::tuple(nb::cast(p)));
+        }
+        return std::make_pair(tuple_path, str);
+      },
+      "subscripts"_a,
+      "operands"_a,
+      nb::sig("def einsum_path(subscripts: str, *operands)"),
+      R"pbdoc(
+
+      Compute the contraction order for the given Einstein summation.
+
+      Args:
+        subscripts (str): The Einstein summation convention equation.
+        *operands (array): The input arrays.
+
+      Returns:
+        tuple(list(tuple(int, int)), str):
+          The einsum path and a string containing information about the
+          chosen path.
+    )pbdoc");
+  m.def(
+      "einsum",
+      [](const std::string& subscripts,
+         const nb::args& operands,
+         mx::StreamOrDevice s) {
+        auto arrays_list = nb::cast<std::vector<mx::array>>(operands);
+        return mx::einsum(subscripts, arrays_list, s);
+      },
+      "subscripts"_a,
+      "operands"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def einsum(subscripts: str, *operands, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+
+      Perform the Einstein summation convention on the operands.
+
+      Args:
+        subscripts (str): The Einstein summation convention equation.
+        *operands (array): The input arrays.
+
+      Returns:
+        array: The output array.
+    )pbdoc");
+  m.def(
+      "roll",
+      [](const mx::array& a,
+         const std::variant<int, mx::Shape>& shift,
+         const IntOrVec& axis,
+         mx::StreamOrDevice s) {
+        return std::visit(
+            [&](auto sh, auto ax) -> mx::array {
+              if constexpr (std::is_same_v<decltype(ax), std::monostate>) {
+                return mx::roll(a, sh, s);
+              } else {
+                return mx::roll(a, sh, ax, s);
+              }
+            },
+            shift,
+            axis);
+      },
+      nb::arg(),
+      "shift"_a,
+      "axis"_a = nb::none(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def roll(a: array, shift: Union[int, Tuple[int]], axis: Union[None, int, Tuple[int]] = None, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Roll array elements along a given axis.
+
+        Elements that are rolled beyond the end of the array are introduced at
+        the beggining and vice-versa.
+
+        If the axis is not provided the array is flattened, rolled and then the
+        shape is restored.
+
+        Args:
+          a (array): Input array
+          shift (int or tuple(int)): The number of places by which elements
+            are shifted. If positive the array is rolled to the right, if
+            negative it is rolled to the left. If an int is provided but the
+            axis is a tuple then the same value is used for all axes.
+          axis (int or tuple(int), optional): The axis or axes along which to
+            roll the elements.
+      )pbdoc");
+  m.def(
+      "real",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::real(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def real(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Returns the real part of a complex array.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The real part of ``a``.
+      )pbdoc");
+  m.def(
+      "imag",
+      [](const ScalarOrArray& a, mx::StreamOrDevice s) {
+        return mx::imag(to_array(a), s);
+      },
+      nb::arg(),
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def imag(a: array, /, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Returns the imaginary part of a complex array.
+
+        Args:
+            a (array): Input array.
+
+        Returns:
+            array: The imaginary part of ``a``.
+      )pbdoc");
+  m.def(
+      "slice",
+      [](const mx::array& a,
+         const mx::array& start_indices,
+         std::vector<int> axes,
+         mx::Shape slice_size,
+         mx::StreamOrDevice s) {
+        return mx::slice(
+            a, start_indices, std::move(axes), std::move(slice_size), s);
+      },
+      nb::arg(),
+      "start_indices"_a,
+      "axes"_a,
+      "slice_size"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def slice(a: array, start_indices: array, axes: Sequence[int], slice_size: Sequence[int], *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Extract a sub-array from the input array.
+
+        Args:
+          a (array): Input array
+          start_indices (array): The index location to start the slice at.
+          axes (tuple(int)): The axes corresponding to the indices in ``start_indices``.
+          slice_size (tuple(int)): The size of the slice.
+
+        Returns:
+          array: The sliced output array.
+
+        Example:
+
+          >>> a = mx.array([[1, 2, 3], [4, 5, 6]])
+          >>> mx.slice(a, start_indices=mx.array(1), axes=(0,), slice_size=(1, 2))
+          array([[4, 5]], dtype=int32)
+          >>>
+          >>> mx.slice(a, start_indices=mx.array(1), axes=(1,), slice_size=(2, 1))
+          array([[2],
+                 [5]], dtype=int32)
+      )pbdoc");
+  m.def(
+      "slice_update",
+      [](const mx::array& src,
+         const mx::array& update,
+         const mx::array& start_indices,
+         std::vector<int> axes,
+         mx::StreamOrDevice s) {
+        return mx::slice_update(src, update, start_indices, axes, s);
+      },
+      nb::arg(),
+      "update"_a,
+      "start_indices"_a,
+      "axes"_a,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def slice_update(a: array, update: array, start_indices: array, axes: Sequence[int], *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Update a sub-array of the input array.
+
+        Args:
+          a (array): The input array to update
+          update (array): The update array.
+          start_indices (array): The index location to start the slice at.
+          axes (tuple(int)): The axes corresponding to the indices in ``start_indices``.
+
+        Returns:
+          array: The output array with the same shape and type as the input.
+
+        Example:
+
+          >>> a = mx.zeros((3, 3))
+          >>> mx.slice_update(a, mx.ones((1, 2)), start_indices=mx.array(1, 1), axes=(0, 1))
+          array([[0, 0, 0],
+                 [0, 1, 0],
+                 [0, 1, 0]], dtype=float32)
+      )pbdoc");
+  m.def(
+      "contiguous",
+      &mx::contiguous,
+      nb::arg(),
+      "allow_col_major"_a = false,
+      nb::kw_only(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def contiguous(a: array, /, allow_col_major: bool = False, *, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+      Force an array to be row contiguous. Copy if necessary.
+
+      Args:
+        a (array): The input to make contiguous
+        allow_col_major (bool): Consider column major as contiguous and don't copy
+
+      Returns:
+        array: The row or col contiguous output.
+    )pbdoc");
+  m.def(
+      "broadcast_shapes",
+      [](const nb::args& shapes) {
+        if (shapes.size() == 0)
+          throw std::invalid_argument(
+              "[broadcast_shapes] Must provide at least one shape.");
+
+        mx::Shape result = nb::cast<mx::Shape>(shapes[0]);
+        for (size_t i = 1; i < shapes.size(); ++i) {
+          if (!nb::isinstance<mx::Shape>(shapes[i]) &&
+              !nb::isinstance<nb::tuple>(shapes[i]))
+            throw std::invalid_argument(
+                "[broadcast_shapes] Expects a sequence of shapes (tuple or list of ints).");
+          result = mx::broadcast_shapes(result, nb::cast<mx::Shape>(shapes[i]));
+        }
+
+        return nb::tuple(nb::cast(result));
+      },
+      nb::sig("def broadcast_shapes(*shapes: Sequence[int]) -> Tuple[int]"),
+      R"pbdoc(
+        Broadcast shapes.
+
+        Returns the shape that results from broadcasting the supplied array shapes
+        against each other.
+
+        Args:
+            *shapes (Sequence[int]): The shapes to broadcast.
+
+        Returns:
+            tuple: The broadcasted shape.
+
+        Raises:
+            ValueError: If the shapes cannot be broadcast.
+
+        Example:
+            >>> mx.broadcast_shapes((1,), (3, 1))
+            (3, 1)
+            >>> mx.broadcast_shapes((6, 7), (5, 6, 1), (7,))
+            (5, 6, 7)
+            >>> mx.broadcast_shapes((5, 1, 4), (1, 3, 1))
+            (5, 3, 4)
+      )pbdoc");
+  m.def(
+      "depends",
+      [](const nb::object& inputs_, const nb::object& deps_) {
+        bool return_vec = false;
+        std::vector<mx::array> inputs;
+        std::vector<mx::array> deps;
+        if (nb::isinstance<mx::array>(inputs_)) {
+          inputs = {nb::cast<mx::array>(inputs_)};
+        } else {
+          return_vec = true;
+          inputs = {nb::cast<std::vector<mx::array>>(inputs_)};
+        }
+        if (nb::isinstance<mx::array>(deps_)) {
+          deps = {nb::cast<mx::array>(deps_)};
+        } else {
+          deps = {nb::cast<std::vector<mx::array>>(deps_)};
+        }
+        auto out = depends(inputs, deps);
+        if (return_vec) {
+          return nb::cast(out);
+        } else {
+          return nb::cast(out[0]);
+        }
+      },
+      nb::arg(),
+      nb::arg(),
+      nb::sig(
+          "def depends(inputs: Union[array, Sequence[array]], dependencies: Union[array, Sequence[array]])"),
+      R"pbdoc(
+        Insert dependencies between arrays in the graph. The outputs are
+        identical to ``inputs`` but with dependencies on ``dependencies``.
+
+        Args:
+            inputs (array or Sequence[array]): The input array or arrays.
+            dependencies (array or Sequence[array]): The array or arrays
+              to insert dependencies on.
+
+        Returns:
+            array or Sequence[array]: The outputs which depend on dependencies.
+      )pbdoc");
+}
diff --git a/ml-stable-diffusion/mlx/python/src/random.cpp b/ml-stable-diffusion/mlx/python/src/random.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0972c2cc3a34aea1b33ebd531bd7d9996d709887
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/random.cpp
@@ -0,0 +1,516 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/variant.h>
+#include <nanobind/stl/vector.h>
+
+#include <chrono>
+
+#include "mlx/ops.h"
+#include "mlx/random.h"
+#include "python/src/small_vector.h"
+#include "python/src/utils.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+class PyKeySequence {
+ public:
+  explicit PyKeySequence(uint64_t seed) {
+    state_.append(mx::random::key(seed));
+  }
+
+  void seed(uint64_t seed) {
+    state_[0] = mx::random::key(seed);
+  }
+
+  mx::array next() {
+    auto out = mx::random::split(nb::cast<mx::array>(state_[0]));
+    state_[0] = out.first;
+    return out.second;
+  }
+
+  nb::list state() {
+    return state_;
+  }
+
+  void release() {
+    nb::gil_scoped_acquire gil;
+    state_.release().dec_ref();
+  }
+
+ private:
+  nb::list state_;
+};
+
+PyKeySequence& default_key() {
+  auto get_current_time_seed = []() {
+    auto now = std::chrono::system_clock::now();
+    return std::chrono::duration_cast<std::chrono::milliseconds>(
+               now.time_since_epoch())
+        .count();
+  };
+  static PyKeySequence ks(get_current_time_seed());
+  return ks;
+}
+
+void init_random(nb::module_& parent_module) {
+  auto m = parent_module.def_submodule(
+      "random",
+      "mlx.core.random: functionality related to random number generation");
+
+  m.attr("state") = default_key().state();
+  m.def(
+      "seed",
+      [](uint64_t seed) { default_key().seed(seed); },
+      "seed"_a,
+      R"pbdoc(
+        Seed the global PRNG.
+
+        Args:
+            seed (int): Seed for the global PRNG.
+      )pbdoc");
+  m.def(
+      "key",
+      &mx::random::key,
+      "seed"_a,
+      R"pbdoc(
+        Get a PRNG key from a seed.
+
+        Args:
+            seed (int): Seed for the PRNG.
+
+        Returns:
+            array: The PRNG key array.
+      )pbdoc");
+  m.def(
+      "split",
+      nb::overload_cast<const mx::array&, int, mx::StreamOrDevice>(
+          &mx::random::split),
+      "key"_a,
+      "num"_a = 2,
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def split(key: array, num: int = 2, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Split a PRNG key into sub keys.
+
+        Args:
+            key (array): Input key to split.
+            num (int, optional): Number of sub keys. Default: ``2``.
+
+        Returns:
+            array: The array of sub keys with ``num`` as its first dimension.
+      )pbdoc");
+  m.def(
+      "uniform",
+      [](const ScalarOrArray& low,
+         const ScalarOrArray& high,
+         const mx::Shape& shape,
+         std::optional<mx::Dtype> type,
+         const std::optional<mx::array>& key_,
+         mx::StreamOrDevice s) {
+        auto key = key_ ? key_.value() : default_key().next();
+        return mx::random::uniform(
+            to_array(low),
+            to_array(high),
+            shape,
+            type.value_or(mx::float32),
+            key,
+            s);
+      },
+      "low"_a = 0,
+      "high"_a = 1,
+      "shape"_a = mx::Shape{},
+      "dtype"_a.none() = mx::float32,
+      "key"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def uniform(low: Union[scalar, array] = 0, high: Union[scalar, array] = 1, shape: Sequence[int] = [], dtype: Optional[Dtype] = float32, key: Optional[array] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Generate uniformly distributed random numbers.
+
+        The values are sampled uniformly in the half-open interval ``[low, high)``.
+        The lower and upper bound can be scalars or arrays and must be
+        broadcastable to ``shape``.
+
+        Args:
+            low (scalar or array, optional): Lower bound of the distribution.
+              Default: ``0``.
+            high (scalar or array, optional): Upper bound of the distribution.
+              Default: ``1``.
+            shape (list(int), optional): Shape of the output. Default:``()``.
+            dtype (Dtype, optional): Type of the output. Default: ``float32``.
+            key (array, optional): A PRNG key. Default: ``None``.
+
+        Returns:
+            array: The output array random values.
+      )pbdoc");
+  m.def(
+      "normal",
+      [](const mx::Shape& shape,
+         std::optional<mx::Dtype> type,
+         const std::optional<ScalarOrArray>& loc_,
+         const std::optional<ScalarOrArray>& scale_,
+         const std::optional<mx::array>& key_,
+         mx::StreamOrDevice s) {
+        auto dtype = type.value_or(mx::float32);
+        auto key = key_ ? key_.value() : default_key().next();
+        auto loc =
+            loc_ ? std::make_optional(to_array(*loc_, dtype)) : std::nullopt;
+        auto scale = scale_ ? std::make_optional(to_array(*scale_, dtype))
+                            : std::nullopt;
+        return mx::random::normal(shape, dtype, loc, scale, key, s);
+      },
+      "shape"_a = mx::Shape{},
+      "dtype"_a.none() = mx::float32,
+      "loc"_a = nb::none(),
+      "scale"_a = nb::none(),
+      "key"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def normal(shape: Sequence[int] = [], dtype: Optional[Dtype] = float32, loc: Union[scalar, array, None] = None, scale: Union[scalar, array, None] = None, key: Optional[array] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Generate normally distributed random numbers.
+
+        If ``loc`` and ``scale`` are not provided the "standard" normal
+        distribution is used. That means $x \sim \mathcal{N}(0, 1)$ for
+        real numbers and $\text{Re}(x),\text{Im}(x) \sim \mathcal{N}(0,
+        \frac{1}{2})$ for complex numbers.
+
+        Args:
+            shape (list(int), optional): Shape of the output. Default: ``()``.
+            dtype (Dtype, optional): Type of the output. Default: ``float32``.
+            loc (scalar or array, optional): Mean of the distribution.
+              Default: ``None``.
+            scale (scalar or array, optional): Standard deviation of the
+              distribution. Default: ``None``.
+            key (array, optional): A PRNG key. Default: ``None``.
+
+        Returns:
+            array: The output array of random values.
+      )pbdoc");
+  m.def(
+      "multivariate_normal",
+      [](const mx::array& mean,
+         const mx::array& cov,
+         const mx::Shape& shape,
+         std::optional<mx::Dtype> type,
+         const std::optional<mx::array>& key_,
+         mx::StreamOrDevice s) {
+        auto key = key_ ? key_.value() : default_key().next();
+        return mx::random::multivariate_normal(
+            mean, cov, shape, type.value_or(mx::float32), key, s);
+      },
+      "mean"_a,
+      "cov"_a,
+      "shape"_a = mx::Shape{},
+      "dtype"_a.none() = mx::float32,
+      "key"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def multivariate_normal(mean: array, cov: array, shape: Sequence[int] = [], dtype: Optional[Dtype] = float32, key: Optional[array] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Generate jointly-normal random samples given a mean and covariance.
+
+        The matrix ``cov`` must be positive semi-definite. The behavior is
+        undefined if it is not.  The only supported ``dtype`` is ``float32``.
+
+        Args:
+            mean (array): array of shape ``(..., n)``, the mean of the
+              distribution.
+            cov (array): array  of shape ``(..., n, n)``, the covariance
+              matrix of the distribution. The batch shape ``...`` must be
+              broadcast-compatible with that of ``mean``.
+            shape (list(int), optional): The output shape must be
+              broadcast-compatible with ``mean.shape[:-1]`` and ``cov.shape[:-2]``.
+              If empty, the result shape is determined by broadcasting the batch
+              shapes of ``mean`` and ``cov``. Default: ``[]``.
+            dtype (Dtype, optional): The output type. Default: ``float32``.
+            key (array, optional): A PRNG key. Default: ``None``.
+
+        Returns:
+            array: The output array of random values.
+      )pbdoc");
+  m.def(
+      "randint",
+      [](const ScalarOrArray& low,
+         const ScalarOrArray& high,
+         const mx::Shape& shape,
+         std::optional<mx::Dtype> type,
+         const std::optional<mx::array>& key_,
+         mx::StreamOrDevice s) {
+        auto key = key_ ? key_.value() : default_key().next();
+        return mx::random::randint(
+            to_array(low),
+            to_array(high),
+            shape,
+            type.value_or(mx::int32),
+            key,
+            s);
+      },
+      "low"_a,
+      "high"_a,
+      "shape"_a = mx::Shape{},
+      "dtype"_a.none() = mx::int32,
+      "key"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def randint(low: Union[scalar, array], high: Union[scalar, array], shape: Sequence[int] = [], dtype: Optional[Dtype] = int32, key: Optional[array] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Generate random integers from the given interval.
+
+        The values are sampled with equal probability from the integers in
+        half-open interval ``[low, high)``. The lower and upper bound can be
+        scalars or arrays and must be broadcastable to ``shape``.
+
+        Args:
+            low (scalar or array): Lower bound of the interval.
+            high (scalar or array): Upper bound of the interval.
+            shape (list(int), optional): Shape of the output. Default: ``()``.
+            dtype (Dtype, optional): Type of the output. Default: ``int32``.
+            key (array, optional): A PRNG key. Default: ``None``.
+
+        Returns:
+            array: The array of random integers.
+      )pbdoc");
+  m.def(
+      "bernoulli",
+      [](const ScalarOrArray& p_,
+         const std::optional<mx::Shape> shape,
+         const std::optional<mx::array>& key_,
+         mx::StreamOrDevice s) {
+        auto key = key_ ? key_.value() : default_key().next();
+        auto p = to_array(p_);
+        if (shape.has_value()) {
+          return mx::random::bernoulli(p, shape.value(), key, s);
+        } else {
+          return mx::random::bernoulli(p, key, s);
+        }
+      },
+      "p"_a = 0.5,
+      "shape"_a = nb::none(),
+      "key"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def bernoulli(p: Union[scalar, array] = 0.5, shape: Optional[Sequence[int]] = None, key: Optional[array] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Generate Bernoulli random values.
+
+        The values are sampled from the bernoulli distribution with parameter
+        ``p``. The parameter ``p`` can be a :obj:`float` or :obj:`array` and
+        must be broadcastable to ``shape``.
+
+        Args:
+            p (float or array, optional): Parameter of the Bernoulli
+              distribution. Default: ``0.5``.
+            shape (list(int), optional): Shape of the output.
+              Default: ``p.shape``.
+            key (array, optional): A PRNG key. Default: ``None``.
+
+        Returns:
+            array: The array of random integers.
+      )pbdoc");
+  m.def(
+      "truncated_normal",
+      [](const ScalarOrArray& lower_,
+         const ScalarOrArray& upper_,
+         const std::optional<mx::Shape> shape_,
+         std::optional<mx::Dtype> type,
+         const std::optional<mx::array>& key_,
+         mx::StreamOrDevice s) {
+        auto key = key_ ? key_.value() : default_key().next();
+        auto lower = to_array(lower_);
+        auto upper = to_array(upper_);
+        auto t = type.value_or(mx::float32);
+        if (shape_.has_value()) {
+          return mx::random::truncated_normal(
+              lower, upper, shape_.value(), t, key, s);
+        } else {
+          return mx::random::truncated_normal(lower, upper, t, key, s);
+        }
+      },
+      "lower"_a,
+      "upper"_a,
+      "shape"_a = nb::none(),
+      "dtype"_a.none() = mx::float32,
+      "key"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def truncated_normal(lower: Union[scalar, array], upper: Union[scalar, array], shape: Optional[Sequence[int]] = None, dtype: Optional[Dtype] = float32, key: Optional[array] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Generate values from a truncated normal distribution.
+
+        The values are sampled from the truncated normal distribution
+        on the domain ``(lower, upper)``. The bounds ``lower`` and ``upper``
+        can be scalars or arrays and must be broadcastable to ``shape``.
+
+        Args:
+            lower (scalar or array): Lower bound of the domain.
+            upper (scalar or array): Upper bound of the domain.
+            shape (list(int), optional): The shape of the output.
+              Default:``()``.
+            dtype (Dtype, optional): The data type of the output.
+              Default: ``float32``.
+            key (array, optional): A PRNG key. Default: ``None``.
+
+        Returns:
+            array: The output array of random values.
+      )pbdoc");
+  m.def(
+      "gumbel",
+      [](const mx::Shape& shape,
+         std::optional<mx::Dtype> type,
+         const std::optional<mx::array>& key_,
+         mx::StreamOrDevice s) {
+        auto key = key_ ? key_.value() : default_key().next();
+        return mx::random::gumbel(shape, type.value_or(mx::float32), key, s);
+      },
+      "shape"_a = mx::Shape{},
+      "dtype"_a.none() = mx::float32,
+      "key"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def gumbel(shape: Sequence[int] = [], dtype: Optional[Dtype] = float32, key: Union[None, Stream, Device] = None, stream: Optional[array] = None) -> array"),
+      R"pbdoc(
+        Sample from the standard Gumbel distribution.
+
+        The values are sampled from a standard Gumbel distribution
+        which CDF ``exp(-exp(-x))``.
+
+        Args:
+            shape (list(int)): The shape of the output.
+            dtype (Dtype, optional): The data type of the output.
+              Default: ``float32``.
+            key (array, optional): A PRNG key. Default: ``None``.
+
+        Returns:
+            array:
+              The :class:`array` with shape ``shape`` and distributed according
+              to the Gumbel distribution.
+      )pbdoc");
+  m.def(
+      "categorical",
+      [](const mx::array& logits,
+         int axis,
+         const std::optional<mx::Shape> shape,
+         const std::optional<int> num_samples,
+         const std::optional<mx::array>& key_,
+         mx::StreamOrDevice s) {
+        auto key = key_ ? key_.value() : default_key().next();
+        if (shape.has_value() && num_samples.has_value()) {
+          throw std::invalid_argument(
+              "[categorical] At most one of shape or num_samples can be specified.");
+        } else if (shape.has_value()) {
+          return mx::random::categorical(logits, axis, shape.value(), key, s);
+        } else if (num_samples.has_value()) {
+          return mx::random::categorical(
+              logits, axis, num_samples.value(), key, s);
+        } else {
+          return mx::random::categorical(logits, axis, key, s);
+        }
+      },
+      "logits"_a,
+      "axis"_a = -1,
+      "shape"_a = nb::none(),
+      "num_samples"_a = nb::none(),
+      "key"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def categorical(logits: array, axis: int = -1, shape: Optional[Sequence[int]] = None, num_samples: Optional[int] = None, key: Optional[array] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Sample from a categorical distribution.
+
+        The values are sampled from the categorical distribution specified by
+        the unnormalized values in ``logits``. Note, at most one of ``shape``
+        or ``num_samples`` can be specified. If both are ``None``, the output
+        has the same shape as ``logits`` with the ``axis`` dimension removed.
+
+        Args:
+            logits (array): The *unnormalized* categorical distribution(s).
+            axis (int, optional): The axis which specifies the distribution.
+               Default: ``-1``.
+            shape (list(int), optional): The shape of the output. This must
+               be broadcast compatible with ``logits.shape`` with the ``axis``
+               dimension removed. Default: ``None``
+            num_samples (int, optional): The number of samples to draw from each
+              of the categorical distributions in ``logits``. The output will have
+              ``num_samples`` in the last dimension. Default: ``None``.
+            key (array, optional): A PRNG key. Default: ``None``.
+
+        Returns:
+            array: The ``shape``-sized output array with type ``uint32``.
+      )pbdoc");
+  m.def(
+      "laplace",
+      [](const mx::Shape& shape,
+         std::optional<mx::Dtype> type,
+         float loc,
+         float scale,
+         const std::optional<mx::array>& key_,
+         mx::StreamOrDevice s) {
+        auto key = key_ ? key_.value() : default_key().next();
+        return mx::random::laplace(
+            shape, type.value_or(mx::float32), loc, scale, key, s);
+      },
+      "shape"_a = mx::Shape{},
+      "dtype"_a.none() = mx::float32,
+      "loc"_a = 0.0,
+      "scale"_a = 1.0,
+      "key"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def laplace(shape: Sequence[int] = [], dtype: Optional[Dtype] = float32, loc: float = 0.0, scale: float = 1.0, key: Optional[array] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Sample numbers from a Laplace distribution.
+
+        Args:
+            shape (list(int), optional): Shape of the output. Default: ``()``.
+            dtype (Dtype, optional): Type of the output. Default: ``float32``.
+            loc (float, optional): Mean of the distribution. Default: ``0.0``.
+            scale (float, optional): The scale "b" of the Laplace distribution.
+              Default:``1.0``.
+            key (array, optional): A PRNG key. Default: ``None``.
+
+        Returns:
+            array: The output array of random values.
+      )pbdoc");
+  m.def(
+      "permutation",
+      [](const std::variant<nb::int_, mx::array>& x,
+         int axis,
+         const std::optional<mx::array>& key_,
+         mx::StreamOrDevice s) {
+        auto key = key_ ? key_.value() : default_key().next();
+        if (auto pv = std::get_if<nb::int_>(&x); pv) {
+          return mx::random::permutation(nb::cast<int>(*pv), key, s);
+        } else {
+          return mx::random::permutation(std::get<mx::array>(x), axis, key, s);
+        }
+      },
+      "x"_a,
+      "axis"_a = 0,
+      "key"_a = nb::none(),
+      "stream"_a = nb::none(),
+      nb::sig(
+          "def permutation(x: Union[int, array], axis: int = 0, key: Optional[array] = None, stream: Union[None, Stream, Device] = None) -> array"),
+      R"pbdoc(
+        Generate a random permutation or permute the entries of an array.
+
+        Args:
+            x (int or array, optional): If an integer is provided a random
+              permtuation of ``mx.arange(x)`` is returned. Otherwise the entries
+              of ``x`` along the given axis are randomly permuted.
+            axis (int, optional): The axis to permute along. Default: ``0``.
+            key (array, optional): A PRNG key. Default: ``None``.
+
+        Returns:
+            array:
+              The generated random permutation or randomly permuted input array.
+      )pbdoc");
+  // Register static Python object cleanup before the interpreter exits
+  auto atexit = nb::module_::import_("atexit");
+  atexit.attr("register")(nb::cpp_function([]() { default_key().release(); }));
+}
diff --git a/ml-stable-diffusion/mlx/python/src/small_vector.h b/ml-stable-diffusion/mlx/python/src/small_vector.h
new file mode 100644
index 0000000000000000000000000000000000000000..c7b268721587bedb47418500c3751372dd7e4c78
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/small_vector.h
@@ -0,0 +1,77 @@
+// Copyright © 2025 Apple Inc.
+
+#pragma once
+
+#include "mlx/small_vector.h"
+
+#include <nanobind/stl/detail/nb_list.h>
+
+NAMESPACE_BEGIN(NB_NAMESPACE)
+NAMESPACE_BEGIN(detail)
+
+template <typename Type, size_t Size, typename Alloc>
+struct type_caster<mlx::core::SmallVector<Type, Size, Alloc>> {
+  using List = mlx::core::SmallVector<Type, Size, Alloc>;
+  using Caster = make_caster<Type>;
+
+  NB_TYPE_CASTER(
+      List,
+      const_name(NB_TYPING_TUPLE "[") + make_caster<Type>::Name +
+          const_name(", ...]"))
+
+  bool from_python(handle src, uint8_t flags, cleanup_list* cleanup) noexcept {
+    size_t size;
+    PyObject* temp;
+
+    // Will initialize 'size' and 'temp'. All return values and
+    // return parameters are zero/NULL in the case of a failure.
+    PyObject** o = seq_get(src.ptr(), &size, &temp);
+
+    value.clear();
+    value.reserve(size);
+
+    Caster caster;
+    bool success = o != nullptr;
+
+    flags = flags_for_local_caster<Type>(flags);
+
+    for (size_t i = 0; i < size; ++i) {
+      if (!caster.from_python(o[i], flags, cleanup) ||
+          !caster.template can_cast<Type>()) {
+        success = false;
+        break;
+      }
+
+      value.push_back(caster.operator cast_t<Type>());
+    }
+
+    Py_XDECREF(temp);
+
+    return success;
+  }
+
+  template <typename T>
+  static handle from_cpp(T&& src, rv_policy policy, cleanup_list* cleanup) {
+    object ret = steal(PyTuple_New(src.size()));
+
+    if (ret.is_valid()) {
+      Py_ssize_t index = 0;
+
+      for (auto&& value : src) {
+        handle h = Caster::from_cpp(forward_like_<T>(value), policy, cleanup);
+
+        if (!h.is_valid()) {
+          ret.reset();
+          break;
+        }
+
+        NB_TUPLE_SET_ITEM(ret.ptr(), index++, h.ptr());
+      }
+    }
+
+    return ret.release();
+  }
+};
+
+NAMESPACE_END(detail)
+NAMESPACE_END(NB_NAMESPACE)
diff --git a/ml-stable-diffusion/mlx/python/src/stream.cpp b/ml-stable-diffusion/mlx/python/src/stream.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e10f4751c5bbdaed371ab7ff76f2810432edffa9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/stream.cpp
@@ -0,0 +1,147 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <sstream>
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/variant.h>
+
+#include "mlx/stream.h"
+#include "mlx/utils.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+// Create the StreamContext on enter and delete on exit.
+class PyStreamContext {
+ public:
+  PyStreamContext(mx::StreamOrDevice s) : _inner(nullptr) {
+    if (std::holds_alternative<std::monostate>(s)) {
+      throw std::runtime_error(
+          "[StreamContext] Invalid argument, please specify a stream or device.");
+    }
+    _s = s;
+  }
+
+  void enter() {
+    _inner = new mx::StreamContext(_s);
+  }
+
+  void exit() {
+    if (_inner != nullptr) {
+      delete _inner;
+      _inner = nullptr;
+    }
+  }
+
+ private:
+  mx::StreamOrDevice _s;
+  mx::StreamContext* _inner;
+};
+
+void init_stream(nb::module_& m) {
+  nb::class_<mx::Stream>(
+      m,
+      "Stream",
+      R"pbdoc(
+      A stream for running operations on a given device.
+      )pbdoc")
+      .def_ro("device", &mx::Stream::device)
+      .def(
+          "__repr__",
+          [](const mx::Stream& s) {
+            std::ostringstream os;
+            os << s;
+            return os.str();
+          })
+      .def("__eq__", [](const mx::Stream& s, const nb::object& other) {
+        return nb::isinstance<mx::Stream>(other) &&
+            s == nb::cast<mx::Stream>(other);
+      });
+
+  nb::implicitly_convertible<mx::Device::DeviceType, mx::Device>();
+
+  m.def(
+      "default_stream",
+      &mx::default_stream,
+      "device"_a,
+      R"pbdoc(Get the device's default stream.)pbdoc");
+  m.def(
+      "set_default_stream",
+      &mx::set_default_stream,
+      "stream"_a,
+      R"pbdoc(
+        Set the default stream.
+
+        This will make the given stream the default for the
+        streams device. It will not change the default device.
+
+        Args:
+          stream (stream): Stream to make the default.
+      )pbdoc");
+  m.def(
+      "new_stream",
+      &mx::new_stream,
+      "device"_a,
+      R"pbdoc(Make a new stream on the given device.)pbdoc");
+
+  nb::class_<PyStreamContext>(m, "StreamContext", R"pbdoc(
+        A context manager for setting the current device and stream.
+
+        See :func:`stream` for usage.
+
+        Args:
+            s: The stream or device to set as the default.
+  )pbdoc")
+      .def(nb::init<mx::StreamOrDevice>(), "s"_a)
+      .def("__enter__", [](PyStreamContext& scm) { scm.enter(); })
+      .def(
+          "__exit__",
+          [](PyStreamContext& scm,
+             const std::optional<nb::type_object>& exc_type,
+             const std::optional<nb::object>& exc_value,
+             const std::optional<nb::object>& traceback) { scm.exit(); },
+          "exc_type"_a = nb::none(),
+          "exc_value"_a = nb::none(),
+          "traceback"_a = nb::none());
+  m.def(
+      "stream",
+      [](mx::StreamOrDevice s) { return PyStreamContext(s); },
+      "s"_a,
+      R"pbdoc(
+        Create a context manager to set the default device and stream.
+
+        Args:
+            s: The :obj:`Stream` or :obj:`Device` to set as the default.
+
+        Returns:
+            A context manager that sets the default device and stream.
+
+        Example:
+
+        .. code-block::python
+
+          import mlx.core as mx
+
+          # Create a context manager for the default device and stream.
+          with mx.stream(mx.cpu):
+              # Operations here will use mx.cpu by default.
+              pass
+      )pbdoc");
+  m.def(
+      "synchronize",
+      [](const std::optional<mx::Stream>& s) {
+        s ? mx::synchronize(s.value()) : mx::synchronize();
+      },
+      "stream"_a = nb::none(),
+      R"pbdoc(
+      Synchronize with the given stream.
+
+      Args:
+        stream (Stream, optional): The stream to synchronize with. If ``None``
+           then the default stream of the default device is used.
+           Default: ``None``.
+      )pbdoc");
+}
diff --git a/ml-stable-diffusion/mlx/python/src/transforms.cpp b/ml-stable-diffusion/mlx/python/src/transforms.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..12aa641f892d28755c3a3d2c742e7e774db3f454
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/transforms.cpp
@@ -0,0 +1,1490 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <algorithm>
+#include <numeric>
+#include <sstream>
+#include <unordered_set>
+
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/pair.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/unordered_set.h>
+#include <nanobind/stl/variant.h>
+#include <nanobind/stl/vector.h>
+
+#include "mlx/array.h"
+#include "mlx/compile.h"
+#include "mlx/compile_impl.h"
+#include "mlx/transforms.h"
+#include "mlx/transforms_impl.h"
+#include "mlx/utils.h"
+#include "python/src/mlx_func.h"
+#include "python/src/small_vector.h"
+#include "python/src/trees.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+using namespace nb::literals;
+
+// Needed for printing shapes and strides.
+using mx::operator<<;
+
+using IntOrVec = std::variant<int, std::vector<int>>;
+using StrOrSet = std::variant<std::string, std::unordered_set<std::string>>;
+
+inline std::string type_name_str(const nb::handle& o) {
+  return nb::cast<std::string>(nb::type_name(o.type()));
+}
+
+auto validate_argnums_argnames(
+    const std::optional<IntOrVec>& argnums,
+    const StrOrSet& argnames) {
+  std::unordered_set<std::string> setnames;
+  if (auto pv = std::get_if<std::string>(&argnames); pv) {
+    setnames = {*pv};
+  } else {
+    setnames = std::get<std::unordered_set<std::string>>(argnames);
+  }
+
+  if (!argnums.has_value()) {
+    // argnums was not provided and argnames was empty
+    if (setnames.empty()) {
+      return std::make_pair(std::vector<int>{0}, setnames);
+    } else {
+      return std::make_pair(std::vector<int>{}, setnames);
+    }
+  }
+
+  std::vector<int> vecnums;
+  if (auto pv = std::get_if<int>(&(*argnums)); pv) {
+    vecnums = {*pv};
+  } else {
+    vecnums = std::get<std::vector<int>>(*argnums);
+  }
+
+  return std::make_pair(vecnums, setnames);
+}
+
+auto py_value_and_grad(
+    const nb::callable& fun,
+    std::vector<int> argnums,
+    std::unordered_set<std::string> argnames,
+    const std::string& error_msg_tag,
+    bool scalar_func_only) {
+  // Sanitize argnums
+  if (argnums.size() == 0 && argnames.size() == 0) {
+    throw std::invalid_argument(
+        error_msg_tag + " Gradient wrt no argument requested");
+  }
+  for (auto arg : argnums) {
+    std::sort(argnums.begin(), argnums.end());
+    if (argnums[0] < 0) {
+      std::ostringstream msg;
+      msg << error_msg_tag
+          << " Can't compute the gradient of negative argument index "
+          << argnums[0];
+      throw std::invalid_argument(msg.str());
+    }
+    for (int i = 1; i < argnums.size(); ++i) {
+      if (argnums[i] == argnums[i - 1]) {
+        std::ostringstream msg;
+        msg << error_msg_tag << " Duplicate argument index " << argnums[0]
+            << " is not allowed.";
+        throw std::invalid_argument(msg.str());
+      }
+    }
+  }
+
+  return [fun, argnums, argnames, error_msg_tag, scalar_func_only](
+             nb::args& args, nb::kwargs& kwargs) {
+    // Sanitize the input
+    if (argnums.size() > 0 && argnums.back() >= args.size()) {
+      std::ostringstream msg;
+      msg << error_msg_tag << " Can't compute the gradient of argument index "
+          << argnums.back() << " because the function is called with only "
+          << args.size() << " positional arguments.";
+      throw std::invalid_argument(msg.str());
+    }
+
+    for (auto& key : argnames) {
+      if (!kwargs.contains(key)) {
+        std::ostringstream msg;
+        msg << error_msg_tag
+            << " Can't compute the gradient of keyword argument '" << key
+            << "' because the function is called with the "
+            << "following keyword arguments {";
+        for (auto item : kwargs) {
+          msg << nb::cast<std::string>(item.first) << ",";
+        }
+        msg << "}";
+        throw std::invalid_argument(msg.str());
+      }
+    }
+
+    // Collect the arrays
+    std::vector<mx::array> arrays;
+    std::vector<int> counts(1, 0);
+    std::vector<int> gradient_indices;
+    for (int i = 0, j = 0; i < args.size(); ++i) {
+      bool needs_grad = (j < argnums.size() && argnums[j] == i);
+      auto argsi = tree_flatten(args[i], /* strict = */ needs_grad);
+      if (needs_grad) {
+        auto old_size = gradient_indices.size();
+        gradient_indices.resize(old_size + argsi.size());
+        std::iota(
+            gradient_indices.begin() + old_size,
+            gradient_indices.end(),
+            arrays.size());
+        j++;
+        counts.push_back(argsi.size());
+      }
+      arrays.insert(arrays.end(), argsi.begin(), argsi.end());
+    }
+    for (auto item : kwargs) {
+      bool needs_grad =
+          (argnames.find(nb::cast<std::string>(item.first)) != argnames.end());
+      auto argsk = tree_flatten(item.second, /* strict = */ needs_grad);
+      if (needs_grad) {
+        auto old_size = gradient_indices.size();
+        gradient_indices.resize(old_size + argsk.size());
+        std::iota(
+            gradient_indices.begin() + old_size,
+            gradient_indices.end(),
+            arrays.size());
+        counts.push_back(argsk.size());
+      }
+      arrays.insert(arrays.end(), argsk.begin(), argsk.end());
+    }
+    std::partial_sum(counts.cbegin(), counts.cend(), counts.begin());
+
+    // value_out will hold the output of the python function in order to be
+    // able to reconstruct the python tree of extra return values
+    nb::object py_value_out;
+    auto value_and_grads = mx::value_and_grad(
+        [&fun,
+         &arrays,
+         &args,
+         &kwargs,
+         &py_value_out,
+         &error_msg_tag,
+         scalar_func_only](const std::vector<mx::array>& a) {
+          nb::list tree;
+          tree.append(args);
+          tree.append(kwargs);
+          tree_fill(tree, a);
+
+          // Call the python function
+          py_value_out = fun(*tree[0], **tree[1]);
+
+          // Replace the tracers with the originals. Don't overwrite
+          // locations which were written to during the call to fun
+          int index = 0;
+          tree_visit_update(tree, [&](nb::handle node) {
+            auto replace_arr = nb::cast<mx::array>(node);
+            if (replace_arr.id() == a[index].id()) {
+              return nb::cast(arrays[index++]);
+            } else {
+              return nb::cast(replace_arr);
+            }
+          });
+
+          // Validate the return value of the python function
+          if (!nb::isinstance<mx::array>(py_value_out)) {
+            if (scalar_func_only) {
+              std::ostringstream msg;
+              msg << error_msg_tag << " The return value of the function "
+                  << "whose gradient we want to compute should be a "
+                  << "scalar array; but " << type_name_str(py_value_out)
+                  << " was returned.";
+              throw std::invalid_argument(msg.str());
+            }
+            if (!nb::isinstance<nb::tuple>(py_value_out)) {
+              std::ostringstream msg;
+              msg << error_msg_tag << " The return value of the function "
+                  << "whose gradient we want to compute should be either a "
+                  << "scalar array or a tuple with the first value being a "
+                  << "scalar array (Union[array, tuple[array, Any, ...]]); but "
+                  << type_name_str(py_value_out) << " was returned.";
+              throw std::invalid_argument(msg.str());
+            }
+            nb::tuple ret = nb::cast<nb::tuple>(py_value_out);
+            if (ret.size() == 0) {
+              std::ostringstream msg;
+              msg << error_msg_tag << " The return value of the function "
+                  << "whose gradient we want to compute should be either a "
+                  << "scalar array or a non-empty tuple. The first value should be a "
+                  << "scalar array and the rest can be anything. Instead, "
+                  << "we got an empty tuple.";
+              throw std::invalid_argument(msg.str());
+            }
+            if (!nb::isinstance<mx::array>(ret[0])) {
+              std::ostringstream msg;
+              msg << error_msg_tag << " The return value of the function "
+                  << "whose gradient we want to compute should be either a "
+                  << "scalar array or a tuple with the first value being a "
+                  << "scalar array (Union[array, tuple[array, Any, ...]]); but it "
+                  << "was a tuple with the first value being of type "
+                  << type_name_str(ret[0]) << " .";
+              throw std::invalid_argument(msg.str());
+            }
+          }
+
+          return tree_flatten(py_value_out, false);
+        },
+        gradient_indices)(arrays);
+
+    auto value = value_and_grads.first;
+    auto gradients = value_and_grads.second;
+
+    // Put the gradients back in their container.
+    // We have the following cases:
+    //
+    // 1. Single python positional argument has a gradient (eg argnums=[0])
+    // 2. Many python positional arguments have gradients (eg argnums=[0, 1])
+    // 3. A python keyword argument has gradients
+    //
+    // In case 1 we return the original python variable but with the gradients.
+    // In case 2 we return a tuple of the above.
+    // In case 3 we return a tuple containing a tuple and dict (sth like
+    // (tuple(), dict(x=mx.array(5))) ).
+    nb::object positional_grads;
+    nb::object keyword_grads;
+    nb::object py_grads;
+
+    // Collect the gradients for the positional arguments
+    if (argnums.size() == 1) {
+      positional_grads = tree_unflatten(args[argnums[0]], gradients, counts[0]);
+    } else if (argnums.size() > 1) {
+      nb::list grads_;
+      for (int i = 0; i < argnums.size(); i++) {
+        grads_.append(tree_unflatten(args[argnums[i]], gradients, counts[i]));
+      }
+      positional_grads = nb::tuple(grads_);
+    } else {
+      positional_grads = nb::none();
+    }
+
+    // No keyword argument gradients so return the tuple of gradients
+    if (argnames.size() == 0) {
+      py_grads = positional_grads;
+    } else {
+      nb::dict grads_;
+      int i = 0;
+      for (auto item : kwargs) {
+        auto k = nb::cast<std::string>(item.first);
+        if (argnames.find(k) != argnames.end()) {
+          grads_[k.c_str()] = tree_unflatten(
+              nb::borrow(item.second), gradients, counts[i++ + argnums.size()]);
+        }
+      }
+      keyword_grads = grads_;
+
+      py_grads = nb::make_tuple(positional_grads, keyword_grads);
+    }
+
+    // Put the values back in the container
+    nb::object return_value = tree_unflatten(py_value_out, value);
+    return std::make_pair(return_value, py_grads);
+  };
+}
+
+auto py_vmap(
+    const nb::callable& fun,
+    const nb::object& in_axes,
+    const nb::object& out_axes) {
+  return [fun, in_axes, out_axes](const nb::args& args) {
+    auto axes_to_flat_tree = [](const nb::object& tree,
+                                const nb::object& axes,
+                                bool output_axes) {
+      std::vector<int> flat_axes;
+      bool encountered_tuple = false;
+      tree_visit(
+          {tree, axes},
+          [&flat_axes, &encountered_tuple, output_axes](
+              const std::vector<nb::object>& inputs) {
+            if (nb::isinstance<mx::array>(inputs[0])) {
+              if (inputs[1].is_none()) {
+                flat_axes.push_back(-1);
+              } else if (nb::isinstance<nb::int_>(inputs[1])) {
+                int axis = nb::cast<int>(nb::cast<nb::int_>(inputs[1]));
+                const mx::array& x = nb::cast<mx::array>(inputs[0]);
+                if (axis < 0) {
+                  axis += x.ndim() + output_axes;
+                }
+                if (axis < 0 || axis >= (x.ndim() + output_axes)) {
+                  std::ostringstream msg;
+                  msg << "[vmap] Invalid" << (output_axes ? " output " : " ")
+                      << "vectorization axis " << axis
+                      << " for array with shape " << x.shape();
+                  throw std::invalid_argument(msg.str());
+                }
+                flat_axes.push_back(axis);
+              } else if (nb::isinstance<nb::tuple>(inputs[1])) {
+                encountered_tuple = true;
+                auto l = nb::cast<nb::tuple>(inputs[1]);
+                if (l.size() == 1 && nb::isinstance<nb::int_>(l[0])) {
+                  int axis = nb::cast<int>(nb::cast<nb::int_>(l[0]));
+                  const mx::array& x = nb::cast<mx::array>(inputs[0]);
+                  if (axis < 0) {
+                    axis += x.ndim() + output_axes;
+                  }
+                  if (axis < 0 || axis >= (x.ndim() + output_axes)) {
+                    std::ostringstream msg;
+                    msg << "[vmap] Invalid" << (output_axes ? " output " : " ")
+                        << "vectorization axis " << axis
+                        << " for array with shape " << x.shape();
+                    throw std::invalid_argument(msg.str());
+                  }
+                  flat_axes.push_back(axis);
+                } else if (l.size() == 1 && l[0].is_none()) {
+                  flat_axes.push_back(-1);
+                } else {
+                  throw std::invalid_argument(
+                      "[vmap] axis must be int or None.");
+                }
+              } else {
+                throw std::invalid_argument("[vmap] axis must be int or None.");
+              }
+            } else {
+              throw std::invalid_argument(
+                  "[vmap] The arguments should contain only arrays");
+            }
+          });
+      if (encountered_tuple && !nb::isinstance<mx::array>(tree)) {
+        throw std::invalid_argument("[vmap] axis must be int or None.");
+      }
+      return flat_axes;
+    };
+
+    // Inputs must be array or tree of arrays
+    auto inputs = tree_flatten(args, true);
+    auto flat_in_axes =
+        axes_to_flat_tree((args.size() == 1) ? args[0] : args, in_axes, false);
+
+    // py_value_out will hold the output of the python function in order to be
+    // able to reconstruct the python tree of extra return values
+    nb::object py_outputs;
+
+    auto vmap_fn =
+        [&fun, &args, &inputs, &py_outputs](const std::vector<mx::array>& a) {
+          // Call the python function
+          py_outputs = fun(*tree_unflatten(args, a));
+
+          // Flatten the outputs
+          return tree_flatten(py_outputs, true);
+        };
+
+    auto [trace_inputs, trace_outputs] =
+        mx::detail::vmap_trace(vmap_fn, inputs, flat_in_axes);
+
+    auto flat_out_axes = axes_to_flat_tree(py_outputs, out_axes, true);
+
+    // Perform the vmap
+    auto outputs = mx::detail::vmap_replace(
+        inputs, trace_inputs, trace_outputs, flat_in_axes, flat_out_axes);
+
+    // Put the outputs back in the container
+    return tree_unflatten(py_outputs, outputs);
+  };
+}
+
+struct PyCompiledFun {
+  nb::callable fun;
+  std::uintptr_t fun_id;
+  nb::object captured_inputs;
+  nb::object captured_outputs;
+  bool shapeless;
+
+  // Data to attach to the compiled function that contains the python output
+  // structure and the number of arrays in said structure.
+  struct AttachedData {
+    nb::object output_structure;
+    int num_outputs;
+
+    AttachedData(nb::object output_structure_, int num_outputs_)
+        : output_structure(output_structure_), num_outputs(num_outputs_) {}
+  };
+
+  PyCompiledFun(
+      const nb::callable& fun,
+      nb::object inputs,
+      nb::object outputs,
+      bool shapeless)
+      : fun(fun),
+        fun_id(reinterpret_cast<std::uintptr_t>(fun.ptr())),
+        captured_inputs(inputs),
+        captured_outputs(outputs),
+        shapeless(shapeless) {}
+
+  PyCompiledFun(const PyCompiledFun&) = delete;
+  PyCompiledFun& operator=(const PyCompiledFun&) = delete;
+  PyCompiledFun& operator=(PyCompiledFun&& other) = delete;
+  PyCompiledFun(PyCompiledFun&& other)
+      : fun(std::move(other.fun)),
+        fun_id(reinterpret_cast<std::uintptr_t>(fun.ptr())) {
+    other.fun_id = 0;
+    captured_inputs = std::move(other.captured_inputs);
+    captured_outputs = std::move(other.captured_outputs);
+    shapeless = other.shapeless;
+  };
+
+  nb::object call_impl(const nb::args& args, const nb::kwargs& kwargs) {
+    // Flat array inputs
+    std::vector<mx::array> inputs;
+
+    // Compilation constants which includes the tree structure of the arguments
+    std::vector<uint64_t> constants;
+
+    // Reserve some large primes to signify the presence of an array, a list or
+    // a dict in order to encode the structure of the pytree. We choose primes
+    // to reduce slightly the chances of these numbers occurring by a
+    // multiplication as values in the constants list.
+    constexpr uint64_t array_identifier = 18446744073709551557UL;
+    constexpr uint64_t list_identifier = 18446744073709551533UL;
+    constexpr uint64_t dict_identifier = 18446744073709551521UL;
+    constexpr uint64_t none_identifier = 10239356951478402889UL;
+
+    // Flatten the tree with hashed constants and structure
+    std::function<void(nb::handle)> recurse;
+    recurse = [&](nb::handle obj) {
+      if (nb::isinstance<nb::list>(obj)) {
+        auto l = nb::cast<nb::list>(obj);
+        constants.push_back(list_identifier);
+        for (int i = 0; i < l.size(); ++i) {
+          recurse(l[i]);
+        }
+      } else if (nb::isinstance<nb::tuple>(obj)) {
+        auto l = nb::cast<nb::tuple>(obj);
+        constants.push_back(list_identifier);
+        for (auto item : obj) {
+          recurse(item);
+        }
+      } else if (nb::isinstance<nb::dict>(obj)) {
+        auto d = nb::cast<nb::dict>(obj);
+        constants.push_back(dict_identifier);
+        for (auto item : d) {
+          auto r = item.first.attr("__hash__")();
+          constants.push_back(nb::cast<int64_t>(r));
+          recurse(item.second);
+        }
+      } else if (nb::isinstance<mx::array>(obj)) {
+        inputs.push_back(nb::cast<mx::array>(obj));
+        constants.push_back(array_identifier);
+      } else if (nb::isinstance<nb::str>(obj)) {
+        auto r = obj.attr("__hash__")();
+        constants.push_back(nb::cast<int64_t>(r));
+      } else if (nb::isinstance<nb::int_>(obj)) {
+        constants.push_back(nb::cast<int64_t>(obj));
+      } else if (nb::isinstance<nb::float_>(obj)) {
+        auto r = nb::cast<double>(obj);
+        constants.push_back(*reinterpret_cast<uint64_t*>(&r));
+      } else if (obj.is_none()) {
+        constants.push_back(none_identifier);
+      } else {
+        std::ostringstream msg;
+        msg << "[compile] Function arguments must be trees of arrays "
+            << "or constants (floats, ints, strings, or None), but received "
+            << "type " << type_name_str(obj) << ".";
+        throw std::invalid_argument(msg.str());
+      }
+    };
+
+    recurse(args);
+    int num_args = inputs.size();
+    recurse(kwargs);
+    auto compile_fun = [this, &args, &kwargs, num_args](
+                           const std::vector<mx::array>& a) {
+      // Put tracers into captured inputs
+      std::vector<mx::array> flat_in_captures;
+      std::vector<mx::array> trace_captures;
+      if (!captured_inputs.is_none()) {
+        flat_in_captures = tree_flatten(captured_inputs, false);
+        trace_captures.insert(
+            trace_captures.end(), a.end() - flat_in_captures.size(), a.end());
+        tree_fill(captured_inputs, trace_captures);
+      }
+
+      auto tree_outputs =
+          fun(*tree_unflatten(args, a), **tree_unflatten(kwargs, a, num_args));
+      auto [outputs, py_outputs] =
+          tree_flatten_with_structure(std::move(tree_outputs), false);
+
+      std::shared_ptr<void> extra_data =
+          std::make_shared<AttachedData>(py_outputs, outputs.size());
+
+      if (!captured_outputs.is_none()) {
+        auto flat_out_captures = tree_flatten(captured_outputs, false);
+        outputs.insert(
+            outputs.end(),
+            std::make_move_iterator(flat_out_captures.begin()),
+            std::make_move_iterator(flat_out_captures.end()));
+      }
+
+      // Replace tracers with originals in captured inputs
+      if (!captured_inputs.is_none()) {
+        tree_replace(captured_inputs, trace_captures, flat_in_captures);
+      }
+      return mx::detail::ArraysAndExtra{outputs, extra_data};
+    };
+
+    if (!captured_inputs.is_none()) {
+      auto flat_in_captures = tree_flatten(captured_inputs, false);
+      inputs.insert(
+          inputs.end(),
+          std::make_move_iterator(flat_in_captures.begin()),
+          std::make_move_iterator(flat_in_captures.end()));
+    }
+
+    // Compile and call
+    auto [outputs, extra_data] =
+        mx::detail::compile(compile_fun, fun_id, shapeless, constants)(inputs);
+
+    int num_outputs =
+        reinterpret_cast<AttachedData*>(extra_data.get())->num_outputs;
+    nb::object py_outputs =
+        reinterpret_cast<AttachedData*>(extra_data.get())->output_structure;
+
+    if (!captured_outputs.is_none()) {
+      std::vector<mx::array> captures(
+          std::make_move_iterator(outputs.begin() + num_outputs),
+          std::make_move_iterator(outputs.end()));
+      tree_fill(captured_outputs, captures);
+    }
+
+    // Put the outputs back in the container
+    return tree_unflatten_from_structure(std::move(py_outputs), outputs);
+  }
+
+  nb::object operator()(const nb::args& args, const nb::kwargs& kwargs) const {
+    return const_cast<PyCompiledFun*>(this)->call_impl(args, kwargs);
+  };
+
+  ~PyCompiledFun() {
+    nb::gil_scoped_acquire gil;
+
+    mx::detail::compile_erase(fun_id);
+    fun.reset();
+    captured_inputs.reset();
+    captured_outputs.reset();
+  }
+};
+
+class PyCheckpointedFun {
+ public:
+  PyCheckpointedFun(nb::callable fun) : fun_(std::move(fun)) {}
+  ~PyCheckpointedFun() {
+    nb::gil_scoped_acquire gil;
+
+    fun_.reset();
+  }
+
+  struct InnerFunction {
+    nb::object fun_;
+    nb::object args_structure_;
+    std::weak_ptr<nb::object> output_structure_;
+
+    InnerFunction(
+        nb::object fun,
+        nb::object args_structure,
+        std::weak_ptr<nb::object> output_structure)
+        : fun_(std::move(fun)),
+          args_structure_(std::move(args_structure)),
+          output_structure_(output_structure) {}
+    ~InnerFunction() {
+      nb::gil_scoped_acquire gil;
+
+      fun_.reset();
+      args_structure_.reset();
+    }
+
+    std::vector<mx::array> operator()(const std::vector<mx::array>& inputs) {
+      auto args = nb::cast<nb::tuple>(
+          tree_unflatten_from_structure(args_structure_, inputs));
+      auto [outputs, output_structure] =
+          tree_flatten_with_structure(fun_(*args[0], **args[1]), false);
+      if (auto s = output_structure_.lock()) {
+        *s = output_structure;
+      }
+      return outputs;
+    }
+  };
+
+  nb::object call_impl(const nb::args& args, const nb::kwargs& kwargs) {
+    auto output_structure = std::make_shared<nb::object>();
+    auto full_args = nb::make_tuple(args, kwargs);
+    auto [inputs, args_structure] =
+        tree_flatten_with_structure(full_args, false);
+
+    auto outputs = mx::checkpoint(
+        InnerFunction(fun_, args_structure, output_structure))(inputs);
+
+    return tree_unflatten_from_structure(*output_structure, outputs);
+  }
+
+  nb::object operator()(const nb::args& args, const nb::kwargs& kwargs) const {
+    return const_cast<PyCheckpointedFun*>(this)->call_impl(args, kwargs);
+  }
+
+ private:
+  nb::callable fun_;
+};
+
+int py_custom_function_tp_traverse(PyObject* self, visitproc visit, void* arg);
+
+int py_custom_function_tp_clear(PyObject* self);
+
+/**
+ * PyCustomFunction is the class that implements the python decorator
+ * `mx.custom_function`.
+ *
+ * It implements a callable that instead of simply calling `fun` it creates a
+ * CustomTransforms primitive via the `custom_function` C++ op which allows us
+ * to redefine the vjp, jvp and vmap transformations.
+ *
+ * The implementation is verbose due to explicit handling of the destruction of
+ * various python objects to make sure that there is no double-free and that
+ * all of them are deleted while under GIL.
+ *
+ * Namely, for every one of the functions passed to the C++ `custom_function`
+ * we create a callable struct that holds the following python objects (when
+ * needed).
+ *
+ *    - An nb::callable which holds the passed function or transform
+ *    - An nb::object holding input structure, namely the `(args, kwargs)`
+ *      passed to the function in order to be able to recreate the arguments
+ *      from the input arrays.
+ *    - A std::shared_ptr<nb::object> holding the output structure name the
+ *      structure of the return value of `fun`. It is a shared_ptr so that it
+ *      can be set when the function is called and then used in the `vjp`
+ *      transform. We delete the object only when the shared_ptr is about to be
+ *      deleted see `output_structure_.use_count() == 1` to make sure that the
+ *      object is deleted under GIL.
+ */
+class PyCustomFunction {
+ public:
+  PyCustomFunction(nb::callable fun) : fun_(std::move(fun)) {}
+  ~PyCustomFunction() {
+    nb::gil_scoped_acquire gil;
+    reset();
+  }
+
+  struct InnerFunction {
+    nb::callable fun_;
+    nb::object input_structure_;
+    std::shared_ptr<nb::object> output_structure_;
+
+    InnerFunction(
+        nb::callable fun,
+        nb::object input_structure,
+        std::shared_ptr<nb::object> output_structure)
+        : fun_(std::move(fun)),
+          input_structure_(std::move(input_structure)),
+          output_structure_(std::move(output_structure)) {}
+    ~InnerFunction() {
+      nb::gil_scoped_acquire gil;
+
+      fun_.reset();
+      input_structure_.reset();
+      if (output_structure_.use_count() == 1) {
+        output_structure_->reset();
+      }
+    }
+
+    std::vector<mx::array> operator()(const std::vector<mx::array>& inputs) {
+      nb::gil_scoped_acquire gil;
+
+      auto new_inputs = nb::cast<nb::tuple>(
+          tree_unflatten_from_structure(input_structure_, inputs));
+      std::vector<mx::array> outputs;
+      std::tie(outputs, *output_structure_) =
+          tree_flatten_with_structure(fun_(*new_inputs[0], **new_inputs[1]));
+      return outputs;
+    }
+  };
+
+  struct InnerVJPFunction {
+    nb::callable vjp_fun_;
+    nb::object input_structure_;
+    std::shared_ptr<nb::object> output_structure_;
+
+    InnerVJPFunction(
+        nb::callable vjp_fun,
+        nb::object input_structure,
+        std::shared_ptr<nb::object> output_structure)
+        : vjp_fun_(std::move(vjp_fun)),
+          input_structure_(std::move(input_structure)),
+          output_structure_(std::move(output_structure)) {}
+    ~InnerVJPFunction() {
+      nb::gil_scoped_acquire gil;
+
+      vjp_fun_.reset();
+      input_structure_.reset();
+      if (output_structure_.use_count() == 1) {
+        output_structure_->reset();
+      }
+    }
+
+    std::vector<mx::array> operator()(
+        const std::vector<mx::array>& primals,
+        const std::vector<mx::array>& cotangents,
+        const std::vector<mx::array>& outputs) {
+      nb::gil_scoped_acquire gil;
+
+      auto new_inputs = nb::cast<nb::tuple>(
+          tree_unflatten_from_structure(input_structure_, primals));
+      auto args = nb::cast<nb::tuple>(new_inputs[0]);
+      auto new_cotangents =
+          tree_unflatten_from_structure(*output_structure_, cotangents);
+      auto new_outputs =
+          tree_unflatten_from_structure(*output_structure_, outputs);
+
+      if (args.size() == 1) {
+        return tree_flatten(
+            vjp_fun_(args[0], new_cotangents, new_outputs, **new_inputs[1]),
+            false);
+      } else {
+        return tree_flatten(
+            vjp_fun_(args, new_cotangents, new_outputs, **new_inputs[1]),
+            false);
+      }
+    }
+  };
+
+  struct InnerJVPFunction {
+    nb::callable jvp_fun_;
+    nb::object input_structure_;
+
+    InnerJVPFunction(nb::callable jvp_fun, nb::object input_structure)
+        : jvp_fun_(std::move(jvp_fun)),
+          input_structure_(std::move(input_structure)) {}
+    ~InnerJVPFunction() {
+      nb::gil_scoped_acquire gil;
+
+      jvp_fun_.reset();
+      input_structure_.reset();
+    }
+
+    std::vector<mx::array> operator()(
+        const std::vector<mx::array>& primals,
+        const std::vector<mx::array>& tangents,
+        const std::vector<int>& argnums) {
+      nb::gil_scoped_acquire gil;
+
+      auto new_inputs = nb::cast<nb::tuple>(
+          tree_unflatten_from_structure(input_structure_, primals));
+      auto args = nb::cast<nb::tuple>(new_inputs[0]);
+      auto kwargs = nb::cast<nb::dict>(new_inputs[1]);
+      if (kwargs.size() > 0) {
+        throw std::invalid_argument(
+            "[custom jvp] Function should only accept positional arguments");
+      }
+
+      // Make a new pytree which has tangents or None when a tangent is not
+      // available.
+      std::vector<bool> have_tangents(primals.size(), false);
+      for (auto arg : argnums) {
+        have_tangents[arg] = true;
+      }
+      int array_index = 0;
+      int tangent_index = 0;
+      auto new_tangents =
+          nb::cast<nb::tuple>(tree_map(args, [&](nb::handle element) {
+            if (nb::isinstance<mx::array>(element) &&
+                have_tangents[array_index++]) {
+              return nb::cast(tangents[tangent_index++]);
+            } else {
+              return nb::none();
+            }
+          }));
+
+      if (args.size() == 1) {
+        return tree_flatten(jvp_fun_(args[0], new_tangents[0]), false);
+      } else {
+        return tree_flatten(jvp_fun_(args, new_tangents), false);
+      }
+    }
+  };
+
+  struct InnerVmapFunction {
+    nb::callable vmap_fun_;
+    nb::object input_structure_;
+
+    InnerVmapFunction(nb::callable vmap_fun, nb::object input_structure)
+        : vmap_fun_(std::move(vmap_fun)),
+          input_structure_(std::move(input_structure)) {}
+    ~InnerVmapFunction() {
+      nb::gil_scoped_acquire gil;
+
+      vmap_fun_.reset();
+      input_structure_.reset();
+    }
+
+    std::pair<std::vector<mx::array>, std::vector<int>> operator()(
+        const std::vector<mx::array>& inputs,
+        const std::vector<int>& axes) {
+      nb::gil_scoped_acquire gil;
+
+      auto new_inputs = nb::cast<nb::tuple>(
+          tree_unflatten_from_structure(input_structure_, inputs));
+      auto args = nb::cast<nb::tuple>(new_inputs[0]);
+      auto kwargs = nb::cast<nb::dict>(new_inputs[1]);
+      if (kwargs.size() > 0) {
+        throw std::invalid_argument(
+            "[custom vmap] Function should only accept positional arguments");
+      }
+
+      int arr_index = 0;
+      auto new_axes =
+          nb::cast<nb::tuple>(tree_map(args, [&](nb::handle element) {
+            int axis = axes[arr_index++];
+            if (nb::isinstance<mx::array>(element) && axis >= 0) {
+              return nb::cast(axis);
+            } else {
+              return nb::none();
+            }
+          }));
+
+      nb::object result;
+      if (args.size() == 1) {
+        result = vmap_fun_(args[0], new_axes[0]);
+      } else {
+        result = vmap_fun_(args, new_axes);
+      }
+
+      if (!nb::isinstance<nb::tuple>(result)) {
+        throw std::invalid_argument(
+            "[custom vmap] Vmap function should return a tuple with 2 items.");
+      }
+      nb::tuple result_tuple = nb::cast<nb::tuple>(result);
+      if (result_tuple.size() != 2) {
+        throw std::invalid_argument(
+            "[custom vmap] Vmap function should return a tuple with 2 items.");
+      }
+
+      std::vector<mx::array> outputs;
+      std::vector<int> output_axes;
+      tree_visit({result_tuple[0], result_tuple[1]}, [&](auto objects) {
+        if (nb::isinstance<mx::array>(objects[0])) {
+          outputs.push_back(nb::cast<mx::array>(objects[0]));
+          output_axes.push_back(
+              objects[1].is_none() ? -1 : nb::cast<int>(objects[1]));
+        }
+      });
+
+      return {outputs, output_axes};
+    }
+  };
+
+  nb::object call_impl(const nb::args& args, const nb::kwargs& kwargs) {
+    if (!vjp_fun_.has_value() && !jvp_fun_.has_value() &&
+        !vmap_fun_.has_value()) {
+      return fun_(*args, **kwargs);
+    }
+
+    // Extract the inputs and their structure in capturable vars
+    std::vector<mx::array> input_arrays;
+    nb::object input_structure;
+    auto full_args = nb::make_tuple(args, kwargs);
+    std::tie(input_arrays, input_structure) =
+        tree_flatten_with_structure(full_args, false);
+
+    // The output structure will be stored here to be used in the custom vjp
+    // function
+    auto output_structure = std::make_shared<nb::object>();
+
+    // Make a function that calls fun_ in the forward pass and vjp_ in the
+    // backward pass. Then call it immediately and return the results.
+    auto f = mx::custom_function(
+        InnerFunction(fun_, input_structure, output_structure),
+        make_vjp_function(input_structure, output_structure),
+        make_jvp_function(input_structure),
+        make_vmap_function(input_structure));
+
+    auto outputs = f(input_arrays);
+    return tree_unflatten_from_structure(*output_structure, outputs);
+  }
+
+  PyCustomFunction& set_vjp(nb::callable vjp_fun) {
+    vjp_fun_ = vjp_fun;
+    return *this;
+  }
+
+  PyCustomFunction& set_jvp(nb::callable jvp_fun) {
+    jvp_fun_ = jvp_fun;
+    return *this;
+  }
+
+  PyCustomFunction& set_vmap(nb::callable vmap_fun) {
+    vmap_fun_ = vmap_fun;
+    return *this;
+  }
+  void reset() {
+    fun_.reset();
+    if (vjp_fun_.has_value()) {
+      (*vjp_fun_).reset();
+    }
+    if (jvp_fun_.has_value()) {
+      (*jvp_fun_).reset();
+    }
+    if (vmap_fun_.has_value()) {
+      (*vmap_fun_).reset();
+    }
+  }
+
+  friend int py_custom_function_tp_traverse(PyObject*, visitproc, void*);
+
+ private:
+  std::optional<InnerVJPFunction> make_vjp_function(
+      nb::object input_structure,
+      std::shared_ptr<nb::object> output_structure) {
+    if (!vjp_fun_.has_value()) {
+      return std::nullopt;
+    }
+
+    return InnerVJPFunction(*vjp_fun_, input_structure, output_structure);
+  }
+
+  std::optional<InnerJVPFunction> make_jvp_function(
+      nb::object input_structure) {
+    if (!jvp_fun_.has_value()) {
+      return std::nullopt;
+    }
+
+    return InnerJVPFunction(*jvp_fun_, input_structure);
+  }
+
+  std::optional<InnerVmapFunction> make_vmap_function(
+      nb::object input_structure) {
+    if (!vmap_fun_.has_value()) {
+      return std::nullopt;
+    }
+
+    return InnerVmapFunction(*vmap_fun_, input_structure);
+  }
+
+  nb::callable fun_;
+  std::optional<nb::callable> vjp_fun_;
+  std::optional<nb::callable> jvp_fun_;
+  std::optional<nb::callable> vmap_fun_;
+};
+
+int py_custom_function_tp_traverse(PyObject* self, visitproc visit, void* arg) {
+  Py_VISIT(Py_TYPE(self));
+  if (!nb::inst_ready(self)) {
+    return 0;
+  }
+
+  auto* p = nb::inst_ptr<PyCustomFunction>(self);
+  nb::handle v = nb::find(p->fun_);
+  Py_VISIT(v.ptr());
+  if (p->vjp_fun_.has_value()) {
+    nb::handle v = nb::find(*(p->vjp_fun_));
+    Py_VISIT(v.ptr());
+  }
+  if (p->jvp_fun_.has_value()) {
+    nb::handle v = nb::find(*(p->jvp_fun_));
+    Py_VISIT(v.ptr());
+  }
+  if (p->vmap_fun_.has_value()) {
+    nb::handle v = nb::find(*(p->vmap_fun_));
+    Py_VISIT(v.ptr());
+  }
+  return 0;
+}
+int py_custom_function_tp_clear(PyObject* self) {
+  auto* p = nb::inst_ptr<PyCustomFunction>(self);
+  p->reset();
+  return 0;
+}
+PyType_Slot py_custom_function_slots[] = {
+    {Py_tp_traverse, (void*)py_custom_function_tp_traverse},
+    {Py_tp_clear, (void*)py_custom_function_tp_clear},
+    {0, 0}};
+
+void init_transforms(nb::module_& m) {
+  nb::class_<PyCustomFunction>(
+      m,
+      "custom_function",
+      nb::type_slots(py_custom_function_slots),
+      R"pbdoc(
+      Set up a function for custom gradient and vmap definitions.
+
+      This class is meant to be used as a function decorator. Instances are
+      callables that behave identically to the wrapped function. However, when
+      a function transformation is used (e.g. computing gradients using
+      :func:`value_and_grad`) then the functions defined via
+      :meth:`custom_function.vjp`, :meth:`custom_function.jvp` and
+      :meth:`custom_function.vmap` are used instead of the default transformation.
+
+      Note, all custom transformations are optional. Undefined transformations
+      fall back to the default behaviour.
+
+      Example:
+
+        .. code-block:: python
+
+            import mlx.core as mx
+
+            @mx.custom_function
+            def f(x, y):
+                return mx.sin(x) * y
+
+            @f.vjp
+            def f_vjp(primals, cotangent, output):
+                x, y = primals
+                return cotan * mx.cos(x) * y, cotan * mx.sin(x)
+
+            @f.jvp
+            def f_jvp(primals, tangents):
+              x, y = primals
+              dx, dy = tangents
+              return dx * mx.cos(x) * y + dy * mx.sin(x)
+
+            @f.vmap
+            def f_vmap(inputs, axes):
+              x, y = inputs
+              ax, ay = axes
+              if ay != ax and ax is not None:
+                  y = y.swapaxes(ay, ax)
+              return mx.sin(x) * y, (ax or ay)
+
+      All ``custom_function`` instances behave as pure functions. Namely, any
+      variables captured will be treated as constants and no gradients will be
+      computed with respect to the captured arrays. For instance:
+
+        .. code-block:: python
+
+          import mlx.core as mx
+
+          def g(x, y):
+            @mx.custom_function
+            def f(x):
+              return x * y
+
+            @f.vjp
+            def f_vjp(x, dx, fx):
+              # Note that we have only x, dx and fx and nothing with respect to y
+              raise ValueError("Abort!")
+
+            return f(x)
+
+          x = mx.array(2.0)
+          y = mx.array(3.0)
+          print(g(x, y))                     # prints 6.0
+          print(mx.grad(g)(x, y))            # Raises exception
+          print(mx.grad(g, argnums=1)(x, y)) # prints 0.0
+      )pbdoc")
+      .def(
+          nb::init<nb::callable>(),
+          "f"_a,
+          nb::sig("def __init__(self, f: Callable)"))
+      .def("__call__", &PyCustomFunction::call_impl)
+      .def(
+          "vjp",
+          &PyCustomFunction::set_vjp,
+          "f"_a,
+          nb::sig("def vjp(self, f: Callable)"),
+          R"pbdoc(
+            Define a custom vjp for the wrapped function.
+
+            The vjp function takes three arguments:
+
+            - *primals*: A pytree that contains all the positional arguments to
+              the function. It could be a single array, a tuple of arrays or a
+              full blown tuple of dicts of arrays etc.
+            - *cotangents*: A pytree that matches the structure of the output
+              but contains the cotangents (usually the gradients of the loss
+              function with respect to the outputs).
+            - *outputs*: The outputs of the function to be used to avoid
+              recomputing them for the gradient computation.
+
+            The vjp function should return the same pytree structure as the
+            primals but containing the corresponding computed cotangents.
+          )pbdoc")
+      .def(
+          "jvp",
+          &PyCustomFunction::set_jvp,
+          "f"_a,
+          nb::sig("def jvp(self, f: Callable)"),
+          R"pbdoc(
+            Define a custom jvp for the wrapped function.
+
+            The jvp function takes two arguments:
+
+            - *primals*: A pytree that contains all the positional arguments to
+              the function. It could be a single array, a tuple of arrays or a
+              full blown tuple of dicts of arrays etc.
+            - *tangents*: A pytree that matches the structure of the inputs but
+              instead contains the gradients wrt to each input. Tangents could
+              be ``None`` if some inputs don't have an associated gradient.
+
+            The jvp function should return the same pytree structure as the
+            outputs of the function but containing the tangents.
+          )pbdoc")
+      .def(
+          "vmap",
+          &PyCustomFunction::set_vmap,
+          "f"_a,
+          nb::sig("def vmap(self, f: Callable)"),
+          R"pbdoc(
+            Define a custom vectorization transformation for the wrapped function.
+
+            The vmap function takes two arguments:
+
+            - *inputs*: A pytree that contains all the positional arguments to
+              the function. It could be a single array, a tuple of arrays or a
+              full blown tuple of dicts of arrays etc.
+            - *axes*: A pytree that matches the structure of the inputs but
+              instead contains the vectorization axis for each input or
+              ``None`` if an input is not vectorized.
+
+            The vmap function should return the outputs of the original
+            function but vectorized over the provided axes. It should also
+            return a pytree with the vectorization axes of each output. If some
+            outputs are no longer vectorized, then their vectorization axis
+            should be ``None``.
+          )pbdoc");
+
+  m.def(
+      "eval",
+      [](const nb::args& args) {
+        std::vector<mx::array> arrays = tree_flatten(args, false);
+        {
+          nb::gil_scoped_release nogil;
+          eval(arrays);
+        }
+      },
+      nb::arg(),
+      nb::sig("def eval(*args) -> None"),
+      R"pbdoc(
+        Evaluate an :class:`array` or tree of :class:`array`.
+
+        Args:
+            *args (arrays or trees of arrays): Each argument can be a single array
+              or a tree of arrays. If a tree is given the nodes can be a Python
+              :class:`list`, :class:`tuple` or :class:`dict`. Leaves which are not
+              arrays are ignored.
+      )pbdoc");
+  m.def(
+      "async_eval",
+      [](const nb::args& args) {
+        std::vector<mx::array> arrays = tree_flatten(args, false);
+        {
+          nb::gil_scoped_release nogil;
+          async_eval(arrays);
+        }
+      },
+      nb::arg(),
+      nb::sig("def async_eval(*args)"),
+      R"pbdoc(
+        Asynchronously evaluate an :class:`array` or tree of :class:`array`.
+
+        .. note::
+
+          This is an experimental API and may change in future versions.
+
+        Args:
+            *args (arrays or trees of arrays): Each argument can be a single array
+              or a tree of arrays. If a tree is given the nodes can be a Python
+              :class:`list`, :class:`tuple` or :class:`dict`. Leaves which are not
+              arrays are ignored.
+
+        Example:
+            >>> x = mx.array(1.0)
+            >>> y = mx.exp(x)
+            >>> mx.async_eval(y)
+            >>> print(y)
+            >>>
+            >>> y = mx.exp(x)
+            >>> mx.async_eval(y)
+            >>> z = y + 3
+            >>> mx.async_eval(z)
+            >>> print(z)
+      )pbdoc");
+  m.def(
+      "jvp",
+      [](const nb::callable& fun,
+         const std::vector<mx::array>& primals,
+         const std::vector<mx::array>& tangents) {
+        auto vfun = [&fun](const std::vector<mx::array>& primals) {
+          auto out = fun(*nb::cast(primals));
+          if (nb::isinstance<mx::array>(out)) {
+            return std::vector<mx::array>{nb::cast<mx::array>(out)};
+          } else {
+            return nb::cast<std::vector<mx::array>>(out);
+          }
+        };
+        return jvp(vfun, primals, tangents);
+      },
+      "fun"_a,
+      "primals"_a,
+      "tangents"_a,
+      nb::sig(
+          "def jvp(fun: Callable, primals: list[array], tangents: list[array]) -> tuple[list[array], list[array]]"),
+      R"pbdoc(
+        Compute the Jacobian-vector product.
+
+        This computes the product of the Jacobian of a function ``fun`` evaluated
+        at ``primals`` with the ``tangents``.
+
+        Args:
+            fun (Callable): A function which takes a variable number of :class:`array`
+              and returns a single :class:`array` or list of :class:`array`.
+            primals (list(array)): A list of :class:`array` at which to
+              evaluate the Jacobian.
+            tangents (list(array)): A list of :class:`array` which are the
+              "vector" in the Jacobian-vector product. The ``tangents`` should be the
+              same in number, shape, and type as the inputs of ``fun`` (i.e. the ``primals``).
+
+        Returns:
+            list(array): A list of the Jacobian-vector products which
+            is the same in number, shape, and type of the inputs to ``fun``.
+      )pbdoc");
+  m.def(
+      "vjp",
+      [](const nb::callable& fun,
+         const std::vector<mx::array>& primals,
+         const std::vector<mx::array>& cotangents) {
+        auto vfun = [&fun](const std::vector<mx::array>& primals) {
+          auto out = fun(*nb::cast(primals));
+          if (nb::isinstance<mx::array>(out)) {
+            return std::vector<mx::array>{nb::cast<mx::array>(out)};
+          } else {
+            return nb::cast<std::vector<mx::array>>(out);
+          }
+        };
+        return vjp(vfun, primals, cotangents);
+      },
+      "fun"_a,
+      "primals"_a,
+      "cotangents"_a,
+      nb::sig(
+          "def vjp(fun: Callable, primals: list[array], cotangents: list[array]) -> tuple[list[array], list[array]]"),
+      R"pbdoc(
+        Compute the vector-Jacobian product.
+
+        Computes the product of the ``cotangents`` with the Jacobian of a
+        function ``fun`` evaluated at ``primals``.
+
+        Args:
+          fun (Callable): A function which takes a variable number of :class:`array`
+            and returns a single :class:`array` or list of :class:`array`.
+          primals (list(array)): A list of :class:`array` at which to
+            evaluate the Jacobian.
+          cotangents (list(array)): A list of :class:`array` which are the
+            "vector" in the vector-Jacobian product. The ``cotangents`` should be the
+            same in number, shape, and type as the outputs of ``fun``.
+
+        Returns:
+            list(array): A list of the vector-Jacobian products which
+            is the same in number, shape, and type of the outputs of ``fun``.
+      )pbdoc");
+  m.def(
+      "value_and_grad",
+      [](const nb::callable& fun,
+         const std::optional<IntOrVec>& argnums,
+         const StrOrSet& argnames) {
+        auto [argnums_vec, argnames_set] =
+            validate_argnums_argnames(argnums, argnames);
+        return mlx_func(
+            py_value_and_grad(
+                fun, argnums_vec, argnames_set, "[value_and_grad]", false),
+            fun);
+      },
+      "fun"_a,
+      "argnums"_a = nb::none(),
+      "argnames"_a = std::vector<std::string>{},
+      nb::sig(
+          "def value_and_grad(fun: Callable, argnums: Optional[Union[int, Sequence[int]]] = None, argnames: Union[str, Sequence[str]] = []) -> Callable"),
+      R"pbdoc(
+        Returns a function which computes the value and gradient of ``fun``.
+
+        The function passed to :func:`value_and_grad` should return either
+        a scalar loss or a tuple in which the first element is a scalar
+        loss and the remaining elements can be anything.
+
+        .. code-block:: python
+
+            import mlx.core as mx
+
+            def mse(params, inputs, targets):
+                outputs = forward(params, inputs)
+                lvalue = (outputs - targets).square().mean()
+                return lvalue
+
+            # Returns lvalue, dlvalue/dparams
+            lvalue, grads = mx.value_and_grad(mse)(params, inputs, targets)
+
+            def lasso(params, inputs, targets, a=1.0, b=1.0):
+                outputs = forward(params, inputs)
+                mse = (outputs - targets).square().mean()
+                l1 = mx.abs(outputs - targets).mean()
+
+                loss = a*mse + b*l1
+
+                return loss, mse, l1
+
+            (loss, mse, l1), grads = mx.value_and_grad(lasso)(params, inputs, targets)
+
+        Args:
+            fun (Callable): A function which takes a variable number of
+              :class:`array` or trees of :class:`array` and returns
+              a scalar output :class:`array` or a tuple the first element
+              of which should be a scalar :class:`array`.
+            argnums (int or list(int), optional): Specify the index (or indices)
+              of the positional arguments of ``fun`` to compute the gradient
+              with respect to. If neither ``argnums`` nor ``argnames`` are
+              provided ``argnums`` defaults to ``0`` indicating ``fun``'s first
+              argument.
+            argnames (str or list(str), optional): Specify keyword arguments of
+              ``fun`` to compute gradients with respect to. It defaults to [] so
+              no gradients for keyword arguments by default.
+
+        Returns:
+            Callable: A function which returns a tuple where the first element
+            is the output of `fun` and the second element is the gradients w.r.t.
+            the loss.
+      )pbdoc");
+  m.def(
+      "grad",
+      [](const nb::callable& fun,
+         const std::optional<IntOrVec>& argnums,
+         const StrOrSet& argnames) {
+        auto [argnums_vec, argnames_set] =
+            validate_argnums_argnames(argnums, argnames);
+        auto fn =
+            py_value_and_grad(fun, argnums_vec, argnames_set, "[grad]", true);
+        return mlx_func(
+            [fn = std::move(fn)](nb::args& args, nb::kwargs& kwargs) {
+              return fn(args, kwargs).second;
+            },
+            fun);
+      },
+      "fun"_a,
+      "argnums"_a = nb::none(),
+      "argnames"_a = std::vector<std::string>{},
+      nb::sig(
+          "def grad(fun: Callable, argnums: Optional[Union[int, Sequence[int]]] = None, argnames: Union[str, Sequence[str]] = []) -> Callable"),
+      R"pbdoc(
+        Returns a function which computes the gradient of ``fun``.
+
+        Args:
+            fun (Callable): A function which takes a variable number of
+              :class:`array` or trees of :class:`array` and returns
+              a scalar output :class:`array`.
+            argnums (int or list(int), optional): Specify the index (or indices)
+              of the positional arguments of ``fun`` to compute the gradient
+              with respect to. If neither ``argnums`` nor ``argnames`` are
+              provided ``argnums`` defaults to ``0`` indicating ``fun``'s first
+              argument.
+            argnames (str or list(str), optional): Specify keyword arguments of
+              ``fun`` to compute gradients with respect to. It defaults to [] so
+              no gradients for keyword arguments by default.
+
+        Returns:
+            Callable: A function which has the same input arguments as ``fun`` and
+            returns the gradient(s).
+      )pbdoc");
+  m.def(
+      "vmap",
+      [](const nb::callable& fun,
+         const nb::object& in_axes,
+         const nb::object& out_axes) {
+        return mlx_func(
+            py_vmap(fun, in_axes, out_axes), fun, in_axes, out_axes);
+      },
+      "fun"_a,
+      "in_axes"_a = 0,
+      "out_axes"_a = 0,
+      nb::sig(
+          "def vmap(fun: Callable, in_axes: object = 0, out_axes: object = 0) -> Callable"),
+      R"pbdoc(
+        Returns a vectorized version of ``fun``.
+
+        Args:
+            fun (Callable): A function which takes a variable number of
+              :class:`array` or a tree of :class:`array` and returns
+              a variable number of :class:`array` or a tree of :class:`array`.
+            in_axes (int, optional): An integer or a valid prefix tree of the
+              inputs to ``fun`` where each node specifies the vmapped axis. If
+              the value is ``None`` then the corresponding input(s) are not vmapped.
+              Defaults to ``0``.
+            out_axes (int, optional): An integer or a valid prefix tree of the
+              outputs of ``fun`` where each node specifies the vmapped axis. If
+              the value is ``None`` then the corresponding outputs(s) are not vmapped.
+              Defaults to ``0``.
+
+        Returns:
+            Callable: The vectorized function.
+      )pbdoc");
+  m.def(
+      "compile",
+      [](const nb::callable& fun,
+         const nb::object& inputs,
+         const nb::object& outputs,
+         bool shapeless) {
+        return mlx_func(
+            nb::cpp_function(PyCompiledFun{fun, inputs, outputs, shapeless}),
+            fun,
+            inputs,
+            outputs);
+      },
+      "fun"_a,
+      "inputs"_a = nb::none(),
+      "outputs"_a = nb::none(),
+      "shapeless"_a = false,
+      nb::sig(
+          "def compile(fun: Callable, inputs: Optional[object] = None, outputs: Optional[object] = None, shapeless: bool = False) -> Callable"),
+      R"pbdoc(
+        Returns a compiled function which produces the same output as ``fun``.
+
+        Args:
+            fun (Callable): A function which takes a variable number of
+              :class:`array` or trees of :class:`array` and returns
+              a variable number of :class:`array` or trees of :class:`array`.
+            inputs (list or dict, optional): These inputs will be captured during
+              the function compilation along with the inputs to ``fun``. The ``inputs``
+              can be a :obj:`list` or a :obj:`dict` containing arbitrarily nested
+              lists, dictionaries, or arrays. Leaf nodes that are not
+              :obj:`array` are ignored. Default: ``None``
+            outputs (list or dict, optional): These outputs will be captured and
+              updated in a compiled function. The ``outputs`` can be a
+              :obj:`list` or a :obj:`dict` containing arbitrarily nested lists,
+              dictionaries, or arrays. Leaf nodes that are not :obj:`array` are ignored.
+              Default: ``None``
+            shapeless (bool, optional): A function compiled with the ``shapeless``
+              option enabled will not be recompiled when the input shape changes. Not all
+              functions can be compiled with ``shapeless`` enabled. Attempting to compile
+              such functions with shapeless enabled will throw. Note, changing the number
+              of dimensions or type of any input will result in a recompilation even with
+              ``shapeless`` set to ``True``. Default: ``False``
+
+        Returns:
+            Callable: A compiled function which has the same input arguments
+            as ``fun`` and returns the the same output(s).
+      )pbdoc");
+  m.def(
+      "disable_compile",
+      &mx::disable_compile,
+      R"pbdoc(
+        Globally disable compilation. Setting the environment variable
+        ``MLX_DISABLE_COMPILE`` can also be used to disable compilation.
+      )pbdoc");
+  m.def(
+      "enable_compile",
+      &mx::enable_compile,
+      R"pbdoc(
+        Globally enable compilation. This will override the environment
+        variable ``MLX_DISABLE_COMPILE`` if set.
+      )pbdoc");
+  m.def(
+      "checkpoint",
+      [](nb::callable fun) { return mlx_func(PyCheckpointedFun{fun}, fun); },
+      "fun"_a);
+
+  // Register static Python object cleanup before the interpreter exits
+  auto atexit = nb::module_::import_("atexit");
+  atexit.attr("register")(
+      nb::cpp_function([]() { mx::detail::compile_clear_cache(); }));
+}
diff --git a/ml-stable-diffusion/mlx/python/src/trees.cpp b/ml-stable-diffusion/mlx/python/src/trees.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b75d1187cc06bc9ced10cafabe16018b68c82276
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/trees.cpp
@@ -0,0 +1,303 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "python/src/trees.h"
+
+template <typename T, typename U, typename V>
+void validate_subtrees(const std::vector<nb::object>& subtrees) {
+  int len = nb::cast<T>(subtrees[0]).size();
+  for (auto& subtree : subtrees) {
+    if ((nb::isinstance<T>(subtree) && nb::cast<T>(subtree).size() != len) ||
+        nb::isinstance<U>(subtree) || nb::isinstance<V>(subtree)) {
+      throw std::invalid_argument(
+          "[tree_map] Additional input tree is not a valid prefix of the first tree.");
+    }
+  }
+}
+
+nb::object tree_map(
+    const std::vector<nb::object>& trees,
+    std::function<nb::object(const std::vector<nb::object>&)> transform) {
+  std::function<nb::object(const std::vector<nb::object>&)> recurse;
+
+  recurse = [&](const std::vector<nb::object>& subtrees) {
+    if (nb::isinstance<nb::list>(subtrees[0])) {
+      nb::list l;
+      std::vector<nb::object> items(subtrees.size());
+      validate_subtrees<nb::list, nb::tuple, nb::dict>(subtrees);
+      for (int i = 0; i < nb::cast<nb::list>(subtrees[0]).size(); ++i) {
+        for (int j = 0; j < subtrees.size(); ++j) {
+          if (nb::isinstance<nb::list>(subtrees[j])) {
+            items[j] = nb::cast<nb::list>(subtrees[j])[i];
+          } else {
+            items[j] = subtrees[j];
+          }
+        }
+        l.append(recurse(items));
+      }
+      return nb::cast<nb::object>(l);
+    } else if (nb::isinstance<nb::tuple>(subtrees[0])) {
+      //  Check the rest of the subtrees
+      std::vector<nb::object> items(subtrees.size());
+      int len = nb::cast<nb::tuple>(subtrees[0]).size();
+      nb::list l;
+      validate_subtrees<nb::tuple, nb::list, nb::dict>(subtrees);
+      for (int i = 0; i < len; ++i) {
+        for (int j = 0; j < subtrees.size(); ++j) {
+          if (nb::isinstance<nb::tuple>(subtrees[j])) {
+            items[j] = nb::cast<nb::tuple>(subtrees[j])[i];
+          } else {
+            items[j] = subtrees[j];
+          }
+        }
+        l.append(recurse(items));
+      }
+      return nb::cast<nb::object>(nb::tuple(l));
+    } else if (nb::isinstance<nb::dict>(subtrees[0])) {
+      std::vector<nb::object> items(subtrees.size());
+      validate_subtrees<nb::dict, nb::list, nb::tuple>(subtrees);
+      nb::dict d;
+      for (auto item : nb::cast<nb::dict>(subtrees[0])) {
+        for (int j = 0; j < subtrees.size(); ++j) {
+          if (nb::isinstance<nb::dict>(subtrees[j])) {
+            auto subdict = nb::cast<nb::dict>(subtrees[j]);
+            if (!subdict.contains(item.first)) {
+              throw std::invalid_argument(
+                  "[tree_map] Tree is not a valid prefix tree of the first tree.");
+            }
+            items[j] = subdict[item.first];
+          } else {
+            items[j] = subtrees[j];
+          }
+        }
+        d[item.first] = recurse(items);
+      }
+      return nb::cast<nb::object>(d);
+    } else {
+      return transform(subtrees);
+    }
+  };
+  return recurse(trees);
+}
+
+nb::object tree_map(
+    nb::object tree,
+    std::function<nb::object(nb::handle)> transform) {
+  return tree_map({tree}, [&](std::vector<nb::object> inputs) {
+    return transform(inputs[0]);
+  });
+}
+
+void tree_visit(
+    const std::vector<nb::object>& trees,
+    std::function<void(const std::vector<nb::object>&)> visitor) {
+  std::function<void(const std::vector<nb::object>&)> recurse;
+
+  recurse = [&](const std::vector<nb::object>& subtrees) {
+    if (nb::isinstance<nb::list>(subtrees[0])) {
+      std::vector<nb::object> items(subtrees.size());
+      validate_subtrees<nb::list, nb::tuple, nb::dict>(subtrees);
+      for (int i = 0; i < nb::cast<nb::list>(subtrees[0]).size(); ++i) {
+        for (int j = 0; j < subtrees.size(); ++j) {
+          if (nb::isinstance<nb::list>(subtrees[j])) {
+            items[j] = nb::cast<nb::list>(subtrees[j])[i];
+          } else {
+            items[j] = subtrees[j];
+          }
+        }
+        recurse(items);
+      }
+    } else if (nb::isinstance<nb::tuple>(subtrees[0])) {
+      //  Check the rest of the subtrees
+      std::vector<nb::object> items(subtrees.size());
+      int len = nb::cast<nb::tuple>(subtrees[0]).size();
+      validate_subtrees<nb::tuple, nb::list, nb::dict>(subtrees);
+      for (int i = 0; i < len; ++i) {
+        for (int j = 0; j < subtrees.size(); ++j) {
+          if (nb::isinstance<nb::tuple>(subtrees[j])) {
+            items[j] = nb::cast<nb::tuple>(subtrees[j])[i];
+          } else {
+            items[j] = subtrees[j];
+          }
+        }
+        recurse(items);
+      }
+    } else if (nb::isinstance<nb::dict>(subtrees[0])) {
+      std::vector<nb::object> items(subtrees.size());
+      validate_subtrees<nb::dict, nb::list, nb::tuple>(subtrees);
+      for (auto item : nb::cast<nb::dict>(subtrees[0])) {
+        for (int j = 0; j < subtrees.size(); ++j) {
+          if (nb::isinstance<nb::dict>(subtrees[j])) {
+            auto subdict = nb::cast<nb::dict>(subtrees[j]);
+            if (!subdict.contains(item.first)) {
+              throw std::invalid_argument(
+                  "[tree_visit] Tree is not a valid prefix tree of the first tree.");
+            }
+            items[j] = subdict[item.first];
+          } else {
+            items[j] = subtrees[j];
+          }
+        }
+        recurse(items);
+      }
+    } else {
+      visitor(subtrees);
+    }
+  };
+  return recurse(trees);
+}
+
+void tree_visit(nb::handle tree, std::function<void(nb::handle)> visitor) {
+  std::function<void(nb::handle)> recurse;
+  recurse = [&](nb::handle subtree) {
+    if (nb::isinstance<nb::list>(subtree) ||
+        nb::isinstance<nb::tuple>(subtree)) {
+      for (auto item : subtree) {
+        recurse(item);
+      }
+    } else if (nb::isinstance<nb::dict>(subtree)) {
+      for (auto item : nb::cast<nb::dict>(subtree)) {
+        recurse(item.second);
+      }
+    } else {
+      visitor(subtree);
+    }
+  };
+
+  recurse(tree);
+}
+
+void tree_visit_update(
+    nb::object tree,
+    std::function<nb::object(nb::handle)> visitor) {
+  std::function<nb::object(nb::handle)> recurse;
+  recurse = [&](nb::handle subtree) {
+    if (nb::isinstance<nb::list>(subtree)) {
+      auto l = nb::cast<nb::list>(subtree);
+      for (int i = 0; i < l.size(); ++i) {
+        l[i] = recurse(l[i]);
+      }
+      return nb::cast<nb::object>(l);
+    } else if (nb::isinstance<nb::tuple>(subtree)) {
+      nb::list l(subtree);
+      for (int i = 0; i < l.size(); ++i) {
+        l[i] = recurse(l[i]);
+      }
+      return nb::cast<nb::object>(nb::tuple(l));
+    } else if (nb::isinstance<nb::dict>(subtree)) {
+      auto d = nb::cast<nb::dict>(subtree);
+      for (auto item : d) {
+        d[item.first] = recurse(item.second);
+      }
+      return nb::cast<nb::object>(d);
+    } else if (nb::isinstance<mx::array>(subtree)) {
+      return visitor(subtree);
+    } else {
+      return nb::cast<nb::object>(subtree);
+    }
+  };
+  recurse(tree);
+}
+
+// Fill a pytree (recursive dict or list of dict or list)
+// in place with the given arrays
+// Non dict or list nodes are ignored
+void tree_fill(nb::object& tree, const std::vector<mx::array>& values) {
+  size_t index = 0;
+  tree_visit_update(
+      tree, [&](nb::handle node) { return nb::cast(values[index++]); });
+}
+
+// Replace all the arrays from the src values with the dst values in the tree
+void tree_replace(
+    nb::object& tree,
+    const std::vector<mx::array>& src,
+    const std::vector<mx::array>& dst) {
+  std::unordered_map<uintptr_t, mx::array> src_to_dst;
+  for (int i = 0; i < src.size(); ++i) {
+    src_to_dst.insert({src[i].id(), dst[i]});
+  }
+  tree_visit_update(tree, [&](nb::handle node) {
+    auto arr = nb::cast<mx::array>(node);
+    if (auto it = src_to_dst.find(arr.id()); it != src_to_dst.end()) {
+      return nb::cast(it->second);
+    }
+    return nb::cast(arr);
+  });
+}
+
+std::vector<mx::array> tree_flatten(nb::handle tree, bool strict /* = true */) {
+  std::vector<mx::array> flat_tree;
+
+  tree_visit(tree, [&](nb::handle obj) {
+    if (nb::isinstance<mx::array>(obj)) {
+      flat_tree.push_back(nb::cast<mx::array>(obj));
+    } else if (strict) {
+      throw std::invalid_argument(
+          "[tree_flatten] The argument should contain only arrays");
+    }
+  });
+
+  return flat_tree;
+}
+
+nb::object tree_unflatten(
+    nb::object tree,
+    const std::vector<mx::array>& values,
+    int index /* = 0 */) {
+  return tree_map(tree, [&](nb::handle obj) {
+    if (nb::isinstance<mx::array>(obj)) {
+      return nb::cast(values[index++]);
+    } else {
+      return nb::cast<nb::object>(obj);
+    }
+  });
+}
+
+nb::object structure_sentinel() {
+  static nb::object sentinel;
+
+  if (sentinel.ptr() == nullptr) {
+    sentinel = nb::capsule(&sentinel);
+    // probably not needed but this should make certain that we won't ever
+    // delete the sentinel
+    sentinel.inc_ref();
+  }
+
+  return sentinel;
+}
+
+std::pair<std::vector<mx::array>, nb::object> tree_flatten_with_structure(
+    nb::object tree,
+    bool strict /* = true */) {
+  auto sentinel = structure_sentinel();
+  std::vector<mx::array> flat_tree;
+  auto structure = tree_map(
+      tree,
+      [&flat_tree, sentinel = std::move(sentinel), strict](nb::handle obj) {
+        if (nb::isinstance<mx::array>(obj)) {
+          flat_tree.push_back(nb::cast<mx::array>(obj));
+          return sentinel;
+        } else if (!strict) {
+          return nb::cast<nb::object>(obj);
+        } else {
+          throw std::invalid_argument(
+              "[tree_flatten] The argument should contain only arrays");
+        }
+      });
+
+  return {flat_tree, structure};
+}
+
+nb::object tree_unflatten_from_structure(
+    nb::object structure,
+    const std::vector<mx::array>& values,
+    int index /* = 0 */) {
+  auto sentinel = structure_sentinel();
+  return tree_map(structure, [&](nb::handle obj) {
+    if (obj.is(sentinel)) {
+      return nb::cast(values[index++]);
+    } else {
+      return nb::cast<nb::object>(obj);
+    }
+  });
+}
diff --git a/ml-stable-diffusion/mlx/python/src/trees.h b/ml-stable-diffusion/mlx/python/src/trees.h
new file mode 100644
index 0000000000000000000000000000000000000000..3faa3e39cedf509a56937890686991c8d150af02
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/trees.h
@@ -0,0 +1,62 @@
+// Copyright © 2023-2024 Apple Inc.
+#pragma once
+#include <nanobind/nanobind.h>
+
+#include "mlx/array.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+
+void tree_visit(
+    const std::vector<nb::object>& trees,
+    std::function<void(const std::vector<nb::object>&)> visitor);
+void tree_visit(nb::handle tree, std::function<void(nb::handle)> visitor);
+
+nb::object tree_map(
+    const std::vector<nb::object>& trees,
+    std::function<nb::object(const std::vector<nb::object>&)> transform);
+
+nb::object tree_map(
+    nb::object tree,
+    std::function<nb::object(nb::handle)> transform);
+
+void tree_visit_update(
+    nb::object tree,
+    std::function<nb::object(nb::handle)> visitor);
+
+/**
+ * Fill a pytree (recursive dict or list of dict or list) in place with the
+ * given arrays. */
+void tree_fill(nb::object& tree, const std::vector<mx::array>& values);
+
+/**
+ * Replace all the arrays from the src values with the dst values in the
+ * tree.
+ */
+void tree_replace(
+    nb::object& tree,
+    const std::vector<mx::array>& src,
+    const std::vector<mx::array>& dst);
+
+/**
+ * Flatten a tree into a vector of arrays. If strict is true, then the
+ * function will throw if the tree contains a leaf which is not an array.
+ */
+std::vector<mx::array> tree_flatten(nb::handle tree, bool strict = true);
+
+/**
+ * Unflatten a tree from a vector of arrays.
+ */
+nb::object tree_unflatten(
+    nb::object tree,
+    const std::vector<mx::array>& values,
+    int index = 0);
+
+std::pair<std::vector<mx::array>, nb::object> tree_flatten_with_structure(
+    nb::object tree,
+    bool strict = true);
+
+nb::object tree_unflatten_from_structure(
+    nb::object structure,
+    const std::vector<mx::array>& values,
+    int index = 0);
diff --git a/ml-stable-diffusion/mlx/python/src/utils.cpp b/ml-stable-diffusion/mlx/python/src/utils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5366e501b20a0cceb529493725b8877ecc55c7fb
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/utils.cpp
@@ -0,0 +1,98 @@
+// Copyright © 2024 Apple Inc.
+
+#include "python/src/utils.h"
+#include "mlx/ops.h"
+#include "mlx/utils.h"
+#include "python/src/convert.h"
+
+mx::array to_array(
+    const ScalarOrArray& v,
+    std::optional<mx::Dtype> dtype /* = std::nullopt */) {
+  if (auto pv = std::get_if<nb::bool_>(&v); pv) {
+    return mx::array(nb::cast<bool>(*pv), dtype.value_or(mx::bool_));
+  } else if (auto pv = std::get_if<nb::int_>(&v); pv) {
+    auto val = nb::cast<long>(*pv);
+    auto default_type = (val > std::numeric_limits<int>::max() ||
+                         val < std::numeric_limits<int>::min())
+        ? mx::int64
+        : mx::int32;
+    auto out_t = dtype.value_or(default_type);
+    if (mx::issubdtype(out_t, mx::integer) && out_t.size() < 8) {
+      auto info = mx::iinfo(out_t);
+      if (val < info.min || val > static_cast<int64_t>(info.max)) {
+        std::ostringstream msg;
+        msg << "Converting " << val << " to " << out_t
+            << " would result in overflow.";
+        throw std::invalid_argument(msg.str());
+      }
+    }
+
+    // bool_ is an exception and is always promoted
+    return mx::array(val, (out_t == mx::bool_) ? mx::int32 : out_t);
+  } else if (auto pv = std::get_if<nb::float_>(&v); pv) {
+    auto out_t = dtype.value_or(mx::float32);
+    return mx::array(
+        nb::cast<float>(*pv),
+        mx::issubdtype(out_t, mx::floating) ? out_t : mx::float32);
+  } else if (auto pv = std::get_if<std::complex<float>>(&v); pv) {
+    return mx::array(static_cast<mx::complex64_t>(*pv), mx::complex64);
+  } else if (auto pv = std::get_if<mx::array>(&v); pv) {
+    return *pv;
+  } else if (auto pv = std::get_if<
+                 nb::ndarray<nb::ro, nb::c_contig, nb::device::cpu>>(&v);
+             pv) {
+    return nd_array_to_mlx(*pv, dtype);
+  } else {
+    return to_array_with_accessor(std::get<ArrayLike>(v).obj);
+  }
+}
+
+std::pair<mx::array, mx::array> to_arrays(
+    const ScalarOrArray& a,
+    const ScalarOrArray& b) {
+  // Four cases:
+  // - If both a and b are arrays leave their types alone
+  // - If a is an array but b is not, treat b as a weak python type
+  // - If b is an array but a is not, treat a as a weak python type
+  // - If neither is an array convert to arrays but leave their types alone
+  auto is_mlx_array = [](const ScalarOrArray& x) {
+    return std::holds_alternative<mx::array>(x) ||
+        std::holds_alternative<ArrayLike>(x) &&
+        nb::hasattr(std::get<ArrayLike>(x).obj, "__mlx_array__");
+  };
+  auto get_mlx_array = [](const ScalarOrArray& x) {
+    if (auto px = std::get_if<mx::array>(&x); px) {
+      return *px;
+    } else {
+      return nb::cast<mx::array>(
+          std::get<ArrayLike>(x).obj.attr("__mlx_array__"));
+    }
+  };
+
+  if (is_mlx_array(a)) {
+    auto arr_a = get_mlx_array(a);
+    if (is_mlx_array(b)) {
+      auto arr_b = get_mlx_array(b);
+      return {arr_a, arr_b};
+    }
+    return {arr_a, to_array(b, arr_a.dtype())};
+  } else if (is_mlx_array(b)) {
+    auto arr_b = get_mlx_array(b);
+    return {to_array(a, arr_b.dtype()), arr_b};
+  } else {
+    return {to_array(a), to_array(b)};
+  }
+}
+
+mx::array to_array_with_accessor(nb::object obj) {
+  if (nb::isinstance<mx::array>(obj)) {
+    return nb::cast<mx::array>(obj);
+  } else if (nb::hasattr(obj, "__mlx_array__")) {
+    return nb::cast<mx::array>(obj.attr("__mlx_array__")());
+  } else {
+    std::ostringstream msg;
+    msg << "Invalid type " << nb::type_name(obj.type()).c_str()
+        << " received in array initialization.";
+    throw std::invalid_argument(msg.str());
+  }
+}
diff --git a/ml-stable-diffusion/mlx/python/src/utils.h b/ml-stable-diffusion/mlx/python/src/utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..583d72a08f2f8b0a2face06d5f10fd5d35407a0f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/src/utils.h
@@ -0,0 +1,78 @@
+// Copyright © 2023-2024 Apple Inc.
+#pragma once
+#include <numeric>
+#include <optional>
+#include <string>
+#include <variant>
+
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/complex.h>
+#include <nanobind/stl/variant.h>
+
+#include "mlx/array.h"
+#include "python/src/convert.h"
+
+namespace mx = mlx::core;
+namespace nb = nanobind;
+
+using IntOrVec = std::variant<std::monostate, int, std::vector<int>>;
+using ScalarOrArray = std::variant<
+    nb::bool_,
+    nb::int_,
+    nb::float_,
+    // Must be above ndarray
+    mx::array,
+    // Must be above complex
+    nb::ndarray<nb::ro, nb::c_contig, nb::device::cpu>,
+    std::complex<float>,
+    ArrayLike>;
+
+inline std::vector<int> get_reduce_axes(const IntOrVec& v, int dims) {
+  std::vector<int> axes;
+  if (std::holds_alternative<std::monostate>(v)) {
+    axes.resize(dims);
+    std::iota(axes.begin(), axes.end(), 0);
+  } else if (auto pv = std::get_if<int>(&v); pv) {
+    axes.push_back(*pv);
+  } else {
+    axes = std::get<std::vector<int>>(v);
+  }
+  return axes;
+}
+
+inline bool is_comparable_with_array(const ScalarOrArray& v) {
+  // Checks if the value can be compared to an array (or is already an
+  // mlx array)
+  if (auto pv = std::get_if<ArrayLike>(&v); pv) {
+    auto obj = (*pv).obj;
+    return nb::isinstance<mx::array>(obj) || nb::hasattr(obj, "__mlx_array__");
+  } else {
+    // If it's not an object, it's a scalar (nb::int_, nb::float_, etc.)
+    // and can be compared to an array
+    return true;
+  }
+}
+
+inline nb::handle get_handle_of_object(const ScalarOrArray& v) {
+  return std::get<ArrayLike>(v).obj.ptr();
+}
+
+inline void throw_invalid_operation(
+    const std::string& operation,
+    const ScalarOrArray operand) {
+  std::ostringstream msg;
+  msg << "Cannot perform " << operation << " on an mlx.core.array and "
+      << nb::type_name(get_handle_of_object(operand).type()).c_str();
+  throw std::invalid_argument(msg.str());
+}
+
+mx::array to_array(
+    const ScalarOrArray& v,
+    std::optional<mx::Dtype> dtype = std::nullopt);
+
+std::pair<mx::array, mx::array> to_arrays(
+    const ScalarOrArray& a,
+    const ScalarOrArray& b);
+
+mx::array to_array_with_accessor(nb::object obj);
diff --git a/ml-stable-diffusion/mlx/python/tests/__main__.py b/ml-stable-diffusion/mlx/python/tests/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5230bd535428bf324012cc78272394e79168a9ff
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/__main__.py
@@ -0,0 +1,5 @@
+from . import mlx_tests
+
+__unittest = True
+
+mlx_tests.MLXTestRunner(module=None)
diff --git a/ml-stable-diffusion/mlx/python/tests/cuda_skip.py b/ml-stable-diffusion/mlx/python/tests/cuda_skip.py
new file mode 100644
index 0000000000000000000000000000000000000000..4723bda6ac676cedf3edc313bf82649154513406
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/cuda_skip.py
@@ -0,0 +1,59 @@
+cuda_skip = {
+    "TestLoad.test_load_f8_e4m3",
+    "TestLayers.test_quantized_embedding",
+    # Block masked matmul NYI
+    "TestBlas.test_block_masked_matmul",
+    # Gather matmul NYI
+    "TestBlas.test_gather_matmul",
+    "TestBlas.test_gather_matmul_grad",
+    "TestBlas.test_gather_mm_sorted",
+    # Segmented matmul NYI
+    "TestBlas.test_segmented_mm",
+    # Hadamard NYI
+    "TestOps.test_hadamard",
+    "TestOps.test_hadamard_grad_vmap",
+    # FFTs NYI
+    "TestFFT.test_fft",
+    "TestFFT.test_fft_big_powers_of_two",
+    "TestFFT.test_fft_contiguity",
+    "TestFFT.test_fft_exhaustive",
+    "TestFFT.test_fft_grads",
+    "TestFFT.test_fft_into_ifft",
+    "TestFFT.test_fft_large_numbers",
+    "TestFFT.test_fft_shared_mem",
+    "TestFFT.test_fftn",
+    # Lapack ops NYI
+    "TestLinalg.test_cholesky",
+    "TestLinalg.test_cholesky_inv",
+    "TestLinalg.test_eig",
+    "TestLinalg.test_eigh",
+    "TestLinalg.test_inverse",
+    "TestVmap.test_vmap_inverse",
+    "TestLinalg.test_lu",
+    "TestLinalg.test_lu_factor",
+    "TestLinalg.test_pseudo_inverse",
+    "TestLinalg.test_qr_factorization",
+    "TestInit.test_orthogonal",
+    "TestLinalg.test_svd_decomposition",
+    "TestVmap.test_vmap_svd",
+    "TestLinalg.test_tri_inverse",
+    # Quantization NYI
+    "TestQuantized.test_gather_matmul_grad",
+    "TestQuantized.test_gather_qmm",
+    "TestQuantized.test_gather_qmm_sorted",
+    "TestQuantized.test_gather_qmm_grad",
+    "TestQuantized.test_non_multiples",
+    "TestQuantized.test_qmm",
+    "TestQuantized.test_qmm_jvp",
+    "TestQuantized.test_qmm_shapes",
+    "TestQuantized.test_qmm_vjp",
+    "TestQuantized.test_qmv",
+    "TestQuantized.test_mxfp4_qmv",
+    "TestQuantized.test_mxfp4_qvm",
+    "TestQuantized.test_qvm",
+    "TestQuantized.test_qvm_splitk",
+    "TestQuantized.test_small_matrix",
+    "TestQuantized.test_throw",
+    "TestQuantized.test_vjp_scales_biases",
+    "TestExportImport.test_export_quantized_model",
+}
diff --git a/ml-stable-diffusion/mlx/python/tests/mlx_distributed_tests.py b/ml-stable-diffusion/mlx/python/tests/mlx_distributed_tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..5feb51bc9ccd255c3028c85fc2499e36673fa920
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/mlx_distributed_tests.py
@@ -0,0 +1,250 @@
+# Copyright © 2025 Apple Inc.
+
+import unittest
+
+import mlx.core as mx
+import mlx.nn as nn
+import mlx_tests
+from mlx.nn.layers.distributed import shard_inplace, shard_linear
+from mlx.nn.utils import average_gradients
+
+
+class MLXDistributedCommonTestCase(mlx_tests.MLXTestCase):
+    def test_average_gradients(self):
+        original_all_sum = mx.distributed.all_sum
+        n_calls = 0
+        xtype = None
+
+        def new_all_sum(x, **kwargs):
+            nonlocal n_calls
+            nonlocal xtype
+
+            n_calls += 1
+            if xtype is not None:
+                self.assertEqual(xtype, x.dtype)
+
+            return original_all_sum(x, **kwargs)
+
+        mx.distributed.all_sum = new_all_sum
+
+        try:
+            grads = [mx.ones(10) for i in range(10)]
+            new_grads = average_gradients(grads)
+            mx.eval(new_grads)
+            self.assertEqual(len(new_grads), 10)
+            self.assertTrue(all(mx.all(g == 1) for g in new_grads))
+            self.assertEqual(n_calls, 1)
+
+            n_calls = 0
+            new_grads = average_gradients(grads, all_reduce_size=4 * 50)
+            mx.eval(new_grads)
+            self.assertEqual(len(new_grads), 10)
+            self.assertTrue(all(mx.all(g == 1) for g in new_grads))
+            self.assertEqual(n_calls, 2)
+
+            n_calls = 0
+            new_grads = average_gradients(grads, all_reduce_size=0)
+            mx.eval(new_grads)
+            self.assertEqual(len(new_grads), 10)
+            self.assertTrue(all(mx.all(g == 1) for g in new_grads))
+            self.assertEqual(n_calls, 10)
+
+            n_calls = 0
+            xtype = mx.float16
+            new_grads = average_gradients(
+                grads, all_reduce_size=2 * 50, communication_type=mx.float16
+            )
+            mx.eval(new_grads)
+            self.assertEqual(len(new_grads), 10)
+            self.assertTrue(all(g.dtype == mx.float32 for g in new_grads))
+            self.assertTrue(all(mx.all(g == 1) for g in new_grads))
+            self.assertEqual(n_calls, 2)
+
+        finally:
+            mx.distributed.all_sum = original_all_sum
+
+    def test_donation(self):
+        x = mx.random.normal((1024,))
+        mx.eval(x)
+        mx.synchronize()
+
+        mx.reset_peak_memory()
+        scale = mx.array(2.0)
+        y = mx.distributed.all_sum(x)
+        mx.eval(y)
+        mx.synchronize()
+        all_sum_only = mx.get_peak_memory()
+        y = mx.distributed.all_sum(x) * scale
+        mx.eval(y)
+        mx.synchronize()
+        all_sum_with_binary = mx.get_peak_memory()
+
+        self.assertEqual(all_sum_only, all_sum_with_binary)
+
+    def test_shard_linear(self):
+        # Seed the prng to have the same inputs and weights generated everywhere
+        mx.random.seed(0xF0F0F0F0)
+
+        # Prepare inputs
+        world = mx.distributed.init()
+        part = (
+            slice(None),
+            slice(
+                world.rank() * 1024 // world.size(),
+                (world.rank() + 1) * 1024 // world.size(),
+            ),
+        )
+        x = mx.random.normal((4, 1024))
+
+        # Create and shard some linear layers
+        lin = nn.Linear(1024, 1024, bias=True)
+        slin1 = shard_linear(lin, "all-to-sharded")
+        slin2 = shard_linear(lin, "sharded-to-all")
+        y = lin(x)
+        y1 = slin1(x)
+        y2 = slin2(x[part])
+        self.assertTrue(mx.allclose(y, y2, atol=1e-6, rtol=1e-4))
+        self.assertTrue(mx.allclose(y[part], y1))
+
+        # And their quant versions
+        qlin = lin.to_quantized()
+        slin1 = shard_linear(qlin, "all-to-sharded")
+        slin2 = shard_linear(qlin, "sharded-to-all")
+        y = qlin(x)
+        y1 = slin1(x)
+        y2 = slin2(x[part])
+        self.assertTrue(mx.allclose(y, y2, atol=1e-6, rtol=1e-4))
+        self.assertTrue(mx.allclose(y[part], y1))
+
+        # Check the backward works as expected
+        def dummy_loss(model, x, y):
+            return (model(x) * y).sum()
+
+        mod = nn.Sequential(
+            nn.Linear(128, 128),
+            nn.Linear(128, 128),
+            nn.Linear(128, 128),
+            nn.Linear(128, 128),
+        )
+        smod = nn.Sequential(
+            shard_linear(mod.layers[0], "all-to-sharded"),
+            shard_linear(mod.layers[1], "sharded-to-all"),
+            shard_linear(mod.layers[2], "all-to-sharded"),
+            shard_linear(mod.layers[3], "sharded-to-all"),
+        )
+
+        grad1 = nn.value_and_grad(mod, dummy_loss)
+        grad2 = nn.value_and_grad(smod, dummy_loss)
+
+        x = mx.random.normal((4, 128))
+        y = mx.random.normal((4, 128))
+
+        l1, g1 = grad1(mod, x, y)
+        l2, g2 = grad2(smod, x, y)
+        mx.eval(l1, g1, l2, g2)
+
+        part = slice(
+            world.rank() * 128 // world.size(), (world.rank() + 1) * 128 // world.size()
+        )
+        self.assertTrue(mx.allclose(l1, l2))
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][0]["weight"][part],
+                g2["layers"][0]["weight"],
+                atol=1e-6,
+                rtol=1e-4,
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][2]["weight"][part],
+                g2["layers"][2]["weight"],
+                atol=1e-6,
+                rtol=1e-4,
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][1]["weight"][:, part],
+                g2["layers"][1]["weight"],
+                atol=1e-6,
+                rtol=1e-4,
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][3]["weight"][:, part],
+                g2["layers"][3]["weight"],
+                atol=1e-6,
+                rtol=1e-4,
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][0]["bias"][part],
+                g2["layers"][0]["bias"],
+                atol=1e-6,
+                rtol=1e-4,
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][2]["bias"][part],
+                g2["layers"][2]["bias"],
+                atol=1e-6,
+                rtol=1e-4,
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][1]["bias"], g2["layers"][1]["bias"], atol=1e-6, rtol=1e-4
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][3]["bias"], g2["layers"][3]["bias"], atol=1e-6, rtol=1e-4
+            )
+        )
+
+    def test_shard_predicate(self):
+        mx.random.seed(0xF0F0F0F0)
+
+        class MyConv(nn.Module):
+            def __init__(self, *args, **kwargs):
+                super().__init__()
+                self.aggregate = kwargs.pop("aggregate", False)
+                self.conv = nn.Conv2d(*args, **kwargs)
+
+            def __call__(self, x):
+                x = self.conv(x)
+                if self.aggregate:
+                    x = mx.distributed.all_sum(x)
+                return x
+
+        def sharding(path, weight):
+            parts = path.split(".")
+            even = int(parts[1]) % 2 == 0
+            if even:
+                return 0
+            else:
+                return -1 if parts[-1] != "bias" else None
+
+        mod = nn.Sequential(
+            MyConv(3, 128, kernel_size=3),
+            MyConv(128, 128, kernel_size=3),
+            MyConv(128, 128, kernel_size=3),
+            MyConv(128, 3, kernel_size=3),
+        )
+        smod = nn.Sequential(
+            MyConv(3, 128, kernel_size=3),
+            MyConv(128, 128, kernel_size=3, aggregate=True),
+            MyConv(128, 128, kernel_size=3),
+            MyConv(128, 3, kernel_size=3, aggregate=True),
+        )
+        smod.update(mod.parameters())
+        shard_inplace(smod, sharding)
+
+        x = mx.random.normal((4, 16, 16, 3))
+        y1 = mod(x)
+        y2 = smod(x)
+        self.assertTrue(mx.allclose(y1, y2, atol=1e-6, rtol=1e-4))
diff --git a/ml-stable-diffusion/mlx/python/tests/mlx_tests.py b/ml-stable-diffusion/mlx/python/tests/mlx_tests.py
new file mode 100644
index 0000000000000000000000000000000000000000..c344e7c864955ab9a71a9b5f5de63762e9f086d8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/mlx_tests.py
@@ -0,0 +1,116 @@
+# Copyright © 2023 Apple Inc.
+
+import os
+
+# Use regular fp32 precision for tests
+os.environ["MLX_ENABLE_TF32"] = "0"
+
+# Do not abort on cache thrashing
+os.environ["MLX_ENABLE_CACHE_THRASHING_CHECK"] = "0"
+
+import platform
+import unittest
+from typing import Any, Callable, List, Tuple, Union
+
+import mlx.core as mx
+import numpy as np
+
+
+class MLXTestRunner(unittest.TestProgram):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def createTests(self, *args, **kwargs):
+        super().createTests(*args, **kwargs)
+
+        # Asume CUDA backend in this case
+        device = os.getenv("DEVICE", None)
+        if device is not None:
+            device = getattr(mx, device)
+        else:
+            device = mx.default_device()
+
+        if not (device == mx.gpu and not mx.metal.is_available()):
+            return
+
+        from cuda_skip import cuda_skip
+
+        filtered_suite = unittest.TestSuite()
+
+        def filter_and_add(t):
+            if isinstance(t, unittest.TestSuite):
+                for sub_t in t:
+                    filter_and_add(sub_t)
+            else:
+                t_id = ".".join(t.id().split(".")[-2:])
+                if t_id in cuda_skip:
+                    print(f"Skipping {t_id}")
+                else:
+                    filtered_suite.addTest(t)
+
+        filter_and_add(self.test)
+        self.test = filtered_suite
+
+
+class MLXTestCase(unittest.TestCase):
+    @property
+    def is_apple_silicon(self):
+        return platform.machine() == "arm64" and platform.system() == "Darwin"
+
+    def setUp(self):
+        self.default = mx.default_device()
+        device = os.getenv("DEVICE", None)
+        if device is not None:
+            device = getattr(mx, device)
+            mx.set_default_device(device)
+
+    def tearDown(self):
+        mx.set_default_device(self.default)
+
+    # Note if a tuple is passed into args, it will be considered a shape request and convert to a mx.random.normal with the shape matching the tuple
+    def assertCmpNumpy(
+        self,
+        args: List[Union[Tuple[int], Any]],
+        mx_fn: Callable[..., mx.array],
+        np_fn: Callable[..., np.array],
+        atol=1e-2,
+        rtol=1e-2,
+        dtype=mx.float32,
+        **kwargs,
+    ):
+        assert dtype != mx.bfloat16, "numpy does not support bfloat16"
+        args = [
+            mx.random.normal(s, dtype=dtype) if isinstance(s, Tuple) else s
+            for s in args
+        ]
+        mx_res = mx_fn(*args, **kwargs)
+        np_res = np_fn(
+            *[np.array(a) if isinstance(a, mx.array) else a for a in args], **kwargs
+        )
+        return self.assertEqualArray(mx_res, mx.array(np_res), atol=atol, rtol=rtol)
+
+    def assertEqualArray(
+        self,
+        mx_res: mx.array,
+        expected: mx.array,
+        atol=1e-2,
+        rtol=1e-2,
+    ):
+        self.assertEqual(
+            tuple(mx_res.shape),
+            tuple(expected.shape),
+            msg=f"shape mismatch expected={expected.shape} got={mx_res.shape}",
+        )
+        self.assertEqual(
+            mx_res.dtype,
+            expected.dtype,
+            msg=f"dtype mismatch expected={expected.dtype} got={mx_res.dtype}",
+        )
+        if not isinstance(mx_res, mx.array) and not isinstance(expected, mx.array):
+            np.testing.assert_allclose(mx_res, expected, rtol=rtol, atol=atol)
+            return
+        elif not isinstance(mx_res, mx.array):
+            mx_res = mx.array(mx_res)
+        elif not isinstance(expected, mx.array):
+            expected = mx.array(expected)
+        self.assertTrue(mx.allclose(mx_res, expected, rtol=rtol, atol=atol))
diff --git a/ml-stable-diffusion/mlx/python/tests/mpi_test_distributed.py b/ml-stable-diffusion/mlx/python/tests/mpi_test_distributed.py
new file mode 100644
index 0000000000000000000000000000000000000000..26d340dbea6f70a6f24e939765b32abf99094415
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/mpi_test_distributed.py
@@ -0,0 +1,153 @@
+# Copyright © 2024 Apple Inc.
+
+import unittest
+
+import mlx.core as mx
+import mlx_distributed_tests
+
+
+class TestMPIDistributed(mlx_distributed_tests.MLXDistributedCommonTestCase):
+    @classmethod
+    def setUpClass(cls):
+        world = mx.distributed.init(strict=True, backend="mpi")
+
+    def test_groups(self):
+        world = mx.distributed.init()
+        self.assertEqual(world.size(), 8)
+        self.assertTrue(0 <= world.rank() < 8)
+
+        world2 = mx.distributed.init()
+        self.assertEqual(world.size(), world2.size())
+        self.assertEqual(world.rank(), world2.rank())
+
+        sub = world.split(world.rank() % 2)
+        self.assertEqual(sub.size(), 4)
+        self.assertEqual(sub.rank(), world.rank() // 2)
+
+        sub = world.split(world.rank() // 2)
+        self.assertEqual(sub.size(), 2)
+
+    def test_all_reduce(self):
+        world = mx.distributed.init()
+        dtypes = [
+            (mx.int8, 0),
+            (mx.uint8, 0),
+            (mx.int16, 0),
+            (mx.uint16, 0),
+            (mx.int32, 0),
+            (mx.uint32, 0),
+            (mx.float32, 1e-6),
+            (mx.float16, 5e-3),
+            (mx.bfloat16, 1e-1),
+            (mx.complex64, 1e-6),
+        ]
+        sizes = [
+            (7,),
+            (10,),
+            (1024,),
+            (1024, 1024),
+        ]
+        key = mx.random.key(0)
+        group = world.split(world.rank() % 2)
+
+        for dt, rtol in dtypes:
+            for sh in sizes:
+                for g in [world, group]:
+                    x = (
+                        mx.random.uniform(shape=(g.size(),) + sh, key=key) * 10
+                    ).astype(dt)
+
+                    # All sum
+                    y = mx.distributed.all_sum(x[g.rank()], group=g)
+                    z = x.sum(0)
+                    maxrelerror = (y - z).abs()
+                    if rtol > 0:
+                        maxrelerror /= z.abs()
+                    maxrelerror = maxrelerror.max()
+                    self.assertLessEqual(maxrelerror, rtol)
+
+                    # All max
+                    y = mx.distributed.all_max(x[g.rank()], group=g)
+                    z = x.max(0)
+                    self.assertTrue(mx.all(y == z))
+
+                    # All min
+                    y = mx.distributed.all_min(x[g.rank()], group=g)
+                    z = x.min(0)
+                    self.assertTrue(mx.all(y == z))
+
+    def test_all_gather(self):
+        world = mx.distributed.init()
+        dtypes = [
+            mx.int8,
+            mx.uint8,
+            mx.int16,
+            mx.uint16,
+            mx.int32,
+            mx.uint32,
+            mx.float32,
+            mx.complex64,
+        ]
+        for dt in dtypes:
+            x = mx.ones((2, 2, 4), dtype=dt)
+            y = mx.distributed.all_gather(x)
+            self.assertEqual(y.shape, (world.size() * 2, 2, 4))
+            self.assertTrue(mx.all(y == 1))
+
+        sub = world.split(world.rank() % 2)
+        for dt in dtypes:
+            x = mx.ones((2, 2, 4), dtype=dt)
+            y = mx.distributed.all_gather(x, group=sub)
+            self.assertEqual(y.shape, (sub.size() * 2, 2, 4))
+            self.assertTrue(mx.all(y == 1))
+
+    def test_mixed(self):
+        # Make the following groups:
+        # - world: 0 1 2 3 4 5 6 7
+        # - sub_1: 0 1 0 1 0 1 0 1
+        # - sub_2: 0 0 1 1 2 2 3 3
+        #
+        # The corresponding colors to make them are
+        # - world: N/A
+        # - sub_1: 0 0 1 1 2 2 3 3
+        # - sub_2: 0 1 0 1 0 1 0 1
+
+        world = mx.distributed.init()
+        sub_1 = world.split(world.rank() // 2)
+        sub_2 = world.split(world.rank() % 2)
+
+        x = mx.ones((1, 8)) * world.rank()
+        y = mx.distributed.all_sum(x, group=sub_1)
+        z = mx.distributed.all_gather(y, group=sub_2)
+        z_target = mx.arange(8).reshape(4, 2).sum(-1, keepdims=True)
+
+        self.assertTrue(mx.all(z == z_target))
+
+    def test_send_recv(self):
+        world = mx.distributed.init()
+        pairs = world.split(world.rank() // 2)
+        neighbor = (pairs.rank() + 1) % 2
+        send = pairs.rank() == 0
+
+        x = mx.ones(10)
+        for i in range(10):
+            if send:
+                mx.eval(mx.distributed.send(2 * x, neighbor, group=pairs))
+            else:
+                x = mx.distributed.recv_like(x, neighbor, group=pairs)
+                mx.eval(x)
+            send = not send
+
+        self.assertTrue(mx.all(x == (1024 if pairs.rank() == 0 else 512)))
+
+        # Check recv and computation in same eval:
+        y = mx.ones((5, 5)) + mx.array(2.0)
+        if send:
+            x = mx.distributed.send(2 * x, neighbor, group=pairs)
+        else:
+            x = mx.distributed.recv_like(x, neighbor, group=pairs)
+        mx.eval(y, x)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/ml-stable-diffusion/mlx/python/tests/nccl_test_distributed.py b/ml-stable-diffusion/mlx/python/tests/nccl_test_distributed.py
new file mode 100644
index 0000000000000000000000000000000000000000..c9461d118cbe2a6987e207ad0d8f7e3cb6098935
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/nccl_test_distributed.py
@@ -0,0 +1,283 @@
+# Copyright © 2024 Apple Inc.
+import mlx.core as mx
+import mlx.nn as nn
+import mlx_tests
+from mlx.nn.layers.distributed import shard_inplace, shard_linear
+from mlx.nn.utils import average_gradients
+
+
+class TestNCCLDistributed(mlx_tests.MLXTestCase):
+    @classmethod
+    def setUpClass(cls):
+        world = mx.distributed.init(strict=True, backend="nccl")
+        rank = world.rank()
+        mx.set_default_device(mx.Device(mx.gpu, rank % 8))
+
+    def test_all_reduce(self):
+        world = mx.distributed.init()
+        dtypes = [
+            (mx.int8, 0),
+            (mx.uint8, 0),
+            (mx.int32, 0),
+            (mx.uint32, 0),
+            (mx.float32, 1e-6),
+            (mx.float16, 5e-3),
+            (mx.bfloat16, 1e-1),
+        ]
+        sizes = [
+            (7,),
+            (10,),
+            (1024,),
+            (1024, 1024),
+        ]
+        key = mx.random.key(0)
+
+        for dt, rtol in dtypes:
+            for sh in sizes:
+                x = (
+                    mx.random.uniform(shape=(world.size(),) + sh, key=key) * 10
+                ).astype(dt)
+
+                # All sum
+                y = mx.distributed.all_sum(x[world.rank()])
+                z = x.sum(0)
+                maxrelerror = (y - z).abs()
+                if rtol > 0:
+                    maxrelerror /= z.abs()
+                maxrelerror = maxrelerror.max()
+                self.assertLessEqual(maxrelerror, rtol)
+
+    def test_average_gradients(self):
+        original_all_sum = mx.distributed.all_sum
+        n_calls = 0
+        xtype = None
+
+        def new_all_sum(x, **kwargs):
+            nonlocal n_calls
+            nonlocal xtype
+
+            n_calls += 1
+            if xtype is not None:
+                self.assertEqual(xtype, x.dtype)
+
+            return original_all_sum(x, **kwargs)
+
+        mx.distributed.all_sum = new_all_sum
+        try:
+            grads = [mx.ones(10) for i in range(10)]
+            new_grads = average_gradients(grads)
+            mx.eval(new_grads)
+            self.assertEqual(len(new_grads), 10)
+            self.assertTrue(all(mx.all(g == 1) for g in new_grads))
+            self.assertEqual(n_calls, 1)
+
+            n_calls = 0
+            new_grads = average_gradients(grads, all_reduce_size=4 * 50)
+            mx.eval(new_grads)
+            self.assertEqual(len(new_grads), 10)
+            self.assertTrue(all(mx.all(g == 1) for g in new_grads))
+            self.assertEqual(n_calls, 2)
+
+            n_calls = 0
+            new_grads = average_gradients(grads, all_reduce_size=0)
+            mx.eval(new_grads)
+            self.assertEqual(len(new_grads), 10)
+            self.assertTrue(all(mx.all(g == 1) for g in new_grads))
+            self.assertEqual(n_calls, 10)
+
+            n_calls = 0
+            xtype = mx.float16
+            new_grads = average_gradients(
+                grads,
+                all_reduce_size=2 * 50,
+                communication_type=mx.float16,
+            )
+            mx.eval(new_grads)
+            self.assertEqual(len(new_grads), 10)
+            self.assertTrue(all(g.dtype == mx.float32 for g in new_grads))
+            self.assertTrue(all(mx.all(g == 1) for g in new_grads))
+            self.assertEqual(n_calls, 2)
+
+        finally:
+            mx.distributed.all_sum = original_all_sum
+
+    def test_donation(self):
+        x = mx.random.normal((1024,))
+        mx.eval(x)
+        mx.synchronize()
+
+        mx.reset_peak_memory()
+        scale = mx.array(2.0)
+        y = mx.distributed.all_sum(x)
+        mx.eval(y)
+        mx.synchronize()
+        all_sum_only = mx.get_peak_memory()
+        y = mx.distributed.all_sum(x) * scale
+        mx.eval(y)
+        mx.synchronize()
+        all_sum_with_binary = mx.get_peak_memory()
+
+        self.assertEqual(all_sum_only, all_sum_with_binary)
+
+    def test_shard_linear(self):
+        # Seed the prng to have the same inputs and weights generated everywhere
+        mx.random.seed(0xF0F0F0F0)
+
+        # Prepare inputs
+        world = mx.distributed.init()
+        part = (
+            slice(None),
+            slice(
+                world.rank() * 1024 // world.size(),
+                (world.rank() + 1) * 1024 // world.size(),
+            ),
+        )
+        x = mx.random.normal((4, 1024))
+
+        # Create and shard some linear layers
+        lin = nn.Linear(1024, 1024, bias=True)
+        slin1 = shard_linear(lin, "all-to-sharded")
+        slin2 = shard_linear(lin, "sharded-to-all")
+        y = lin(x)
+        y1 = slin1(x)
+        y2 = slin2(x[part])
+        self.assertTrue(mx.allclose(y, y2, atol=1e-4, rtol=1e-4))
+        self.assertTrue(mx.allclose(y[part], y1, atol=1e-4, rtol=1e-4))
+
+        # Check the backward works as expected
+        def dummy_loss(model, x, y):
+            return (model(x) * y).sum()
+
+        mod = nn.Sequential(
+            nn.Linear(128, 128),
+            nn.Linear(128, 128),
+            nn.Linear(128, 128),
+            nn.Linear(128, 128),
+        )
+        smod = nn.Sequential(
+            shard_linear(mod.layers[0], "all-to-sharded"),
+            shard_linear(mod.layers[1], "sharded-to-all"),
+            shard_linear(mod.layers[2], "all-to-sharded"),
+            shard_linear(mod.layers[3], "sharded-to-all"),
+        )
+
+        grad1 = nn.value_and_grad(mod, dummy_loss)
+        grad2 = nn.value_and_grad(smod, dummy_loss)
+
+        x = mx.random.normal((4, 128))
+        y = mx.random.normal((4, 128))
+
+        l1, g1 = grad1(mod, x, y)
+        l2, g2 = grad2(smod, x, y)
+        mx.eval(l1, g1, l2, g2)
+
+        part = slice(
+            world.rank() * 128 // world.size(), (world.rank() + 1) * 128 // world.size()
+        )
+
+        self.assertTrue(mx.allclose(l1, l2))
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][0]["weight"][part],
+                g2["layers"][0]["weight"],
+                atol=1e-6,
+                rtol=1e-4,
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][2]["weight"][part],
+                g2["layers"][2]["weight"],
+                atol=1e-6,
+                rtol=1e-4,
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][1]["weight"][:, part],
+                g2["layers"][1]["weight"],
+                atol=1e-6,
+                rtol=1e-4,
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][3]["weight"][:, part],
+                g2["layers"][3]["weight"],
+                atol=1e-6,
+                rtol=1e-4,
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][0]["bias"][part],
+                g2["layers"][0]["bias"],
+                atol=1e-6,
+                rtol=1e-4,
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][2]["bias"][part],
+                g2["layers"][2]["bias"],
+                atol=1e-6,
+                rtol=1e-4,
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][1]["bias"], g2["layers"][1]["bias"], atol=1e-6, rtol=1e-4
+            )
+        )
+        self.assertTrue(
+            mx.allclose(
+                g1["layers"][3]["bias"], g2["layers"][3]["bias"], atol=1e-6, rtol=1e-4
+            )
+        )
+
+    def test_shard_predicate(self):
+        mx.random.seed(0xF0F0F0F0)
+
+        class MyConv(nn.Module):
+            def __init__(self, *args, **kwargs):
+                super().__init__()
+                self.aggregate = kwargs.pop("aggregate", False)
+                self.conv = nn.Conv2d(*args, **kwargs)
+
+            def __call__(self, x):
+                x = self.conv(x)
+                if self.aggregate:
+                    x = mx.distributed.all_sum(x)
+                return x
+
+        def sharding(path, weight):
+            parts = path.split(".")
+            even = int(parts[1]) % 2 == 0
+            if even:
+                return 0
+            else:
+                return -1 if parts[-1] != "bias" else None
+
+        mod = nn.Sequential(
+            MyConv(3, 128, kernel_size=3),
+            MyConv(128, 128, kernel_size=3),
+            MyConv(128, 128, kernel_size=3),
+            MyConv(128, 3, kernel_size=3),
+        )
+        smod = nn.Sequential(
+            MyConv(3, 128, kernel_size=3),
+            MyConv(128, 128, kernel_size=3, aggregate=True),
+            MyConv(128, 128, kernel_size=3),
+            MyConv(128, 3, kernel_size=3, aggregate=True),
+        )
+        smod.update(mod.parameters())
+        shard_inplace(smod, sharding)
+
+        x = mx.random.normal((4, 16, 16, 3))
+        y1 = mod(x)
+        y2 = smod(x)
+        self.assertTrue(mx.allclose(y1, y2, atol=1e-6, rtol=1e-4))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/ring_test_distributed.py b/ml-stable-diffusion/mlx/python/tests/ring_test_distributed.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8d08b0f623a3c3b377a89439aa260f5eaf7ac34
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/ring_test_distributed.py
@@ -0,0 +1,134 @@
+# Copyright © 2024 Apple Inc.
+
+import unittest
+
+import mlx.core as mx
+import mlx_distributed_tests
+import mlx_tests
+
+
+class TestRingDistributed(mlx_distributed_tests.MLXDistributedCommonTestCase):
+    @classmethod
+    def setUpClass(cls):
+        world = mx.distributed.init(strict=True, backend="ring")
+
+    def test_groups(self):
+        world = mx.distributed.init()
+        self.assertEqual(world.size(), 8)
+        self.assertTrue(0 <= world.rank() < 8)
+
+        world2 = mx.distributed.init()
+        self.assertEqual(world.size(), world2.size())
+        self.assertEqual(world.rank(), world2.rank())
+
+        with self.assertRaises(RuntimeError):
+            sub = world.split(world.rank() % 2)
+
+    def test_all_reduce(self):
+        world = mx.distributed.init()
+        dtypes = [
+            (mx.int8, 0),
+            (mx.uint8, 0),
+            (mx.int16, 0),
+            (mx.uint16, 0),
+            (mx.int32, 0),
+            (mx.uint32, 0),
+            (mx.float32, 1e-6),
+            (mx.float16, 5e-3),
+            (mx.bfloat16, 1e-1),
+            (mx.complex64, 1e-6),
+        ]
+        sizes = [
+            (7,),
+            (10,),
+            (1024,),
+            (1024, 1024),
+        ]
+        key = mx.random.key(0)
+        reductions = ["min", "max", "sum"]
+
+        for dt, rtol in dtypes:
+            for sh in sizes:
+                x = (
+                    mx.random.uniform(shape=(world.size(),) + sh, key=key) * 10
+                ).astype(dt)
+
+                # All sum
+                y = mx.distributed.all_sum(x[world.rank()])
+                z = x.sum(0)
+                maxrelerror = (y - z).abs()
+                if rtol > 0:
+                    maxrelerror /= z.abs()
+                maxrelerror = maxrelerror.max()
+                self.assertLessEqual(maxrelerror, rtol)
+
+                # All max
+                y = mx.distributed.all_max(x[world.rank()])
+                z = x.max(0)
+                self.assertTrue(mx.all(y == z))
+
+                # All min
+                y = mx.distributed.all_min(x[world.rank()])
+                z = x.min(0)
+                self.assertTrue(mx.all(y == z))
+
+    def test_all_gather(self):
+        world = mx.distributed.init()
+        dtypes = [
+            mx.int8,
+            mx.uint8,
+            mx.int16,
+            mx.uint16,
+            mx.int32,
+            mx.uint32,
+            mx.float32,
+            mx.complex64,
+        ]
+        for dt in dtypes:
+            x = mx.ones((2, 2, 4), dtype=dt)
+            y = mx.distributed.all_gather(x)
+            self.assertEqual(y.shape, (world.size() * 2, 2, 4))
+            self.assertTrue(mx.all(y == 1))
+
+    def test_send_recv(self):
+        world = mx.distributed.init()
+        dtypes = [
+            mx.int8,
+            mx.uint8,
+            mx.int16,
+            mx.uint16,
+            mx.int32,
+            mx.uint32,
+            mx.float32,
+            mx.float16,
+            mx.bfloat16,
+            mx.complex64,
+        ]
+        sizes = [
+            (7,),
+            (10,),
+            (1024,),
+            (1024, 1024),
+        ]
+        key = mx.random.key(0)
+        right = (world.rank() + 1) % world.size()
+        left = (world.rank() + world.size() - 1) % world.size()
+        for dt in dtypes:
+            for sh in sizes:
+                x = (
+                    mx.random.uniform(shape=(world.size(),) + sh, key=key) * 10
+                ).astype(dt)
+                if world.rank() % 2 == 0:
+                    y = mx.distributed.send(x[world.rank()], right)
+                    z = mx.distributed.recv_like(y, left)
+                    mx.eval(y, z)
+                else:
+                    z = mx.distributed.recv_like(x[world.rank()], left)
+                    y = mx.distributed.send(x[world.rank()], right)
+                    mx.eval(z, y)
+                self.assertTrue(mx.all(y == x[world.rank()]))
+                self.assertTrue(mx.all(z == x[left]))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_array.py b/ml-stable-diffusion/mlx/python/tests/test_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8f9474ef148c533df28cca54792831938b3c087
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_array.py
@@ -0,0 +1,2036 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import gc
+import operator
+import os
+import pickle
+import platform
+import sys
+import unittest
+import weakref
+from copy import copy, deepcopy
+from itertools import permutations
+
+if platform.system() == "Windows":
+    import psutil
+else:
+    import resource
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+try:
+    import tensorflow as tf
+
+    has_tf = True
+except ImportError as e:
+    has_tf = False
+
+
+class TestVersion(mlx_tests.MLXTestCase):
+    def test_version(self):
+        v = mx.__version__
+        vnums = v.split(".")
+        self.assertGreaterEqual(len(vnums), 3)
+        v = ".".join(str(int(vn)) for vn in vnums[:3])
+        self.assertEqual(v, mx.__version__[: len(v)])
+
+
+class TestDtypes(mlx_tests.MLXTestCase):
+    def test_dtypes(self):
+        self.assertEqual(mx.bool_.size, 1)
+        self.assertEqual(mx.uint8.size, 1)
+        self.assertEqual(mx.uint16.size, 2)
+        self.assertEqual(mx.uint32.size, 4)
+        self.assertEqual(mx.uint64.size, 8)
+        self.assertEqual(mx.int8.size, 1)
+        self.assertEqual(mx.int16.size, 2)
+        self.assertEqual(mx.int32.size, 4)
+        self.assertEqual(mx.int64.size, 8)
+        self.assertEqual(mx.float16.size, 2)
+        self.assertEqual(mx.float32.size, 4)
+        self.assertEqual(mx.bfloat16.size, 2)
+        self.assertEqual(mx.complex64.size, 8)
+
+        self.assertEqual(str(mx.bool_), "mlx.core.bool")
+        self.assertEqual(str(mx.uint8), "mlx.core.uint8")
+        self.assertEqual(str(mx.uint16), "mlx.core.uint16")
+        self.assertEqual(str(mx.uint32), "mlx.core.uint32")
+        self.assertEqual(str(mx.uint64), "mlx.core.uint64")
+        self.assertEqual(str(mx.int8), "mlx.core.int8")
+        self.assertEqual(str(mx.int16), "mlx.core.int16")
+        self.assertEqual(str(mx.int32), "mlx.core.int32")
+        self.assertEqual(str(mx.int64), "mlx.core.int64")
+        self.assertEqual(str(mx.float16), "mlx.core.float16")
+        self.assertEqual(str(mx.float32), "mlx.core.float32")
+        self.assertEqual(str(mx.bfloat16), "mlx.core.bfloat16")
+        self.assertEqual(str(mx.complex64), "mlx.core.complex64")
+
+    def test_scalar_conversion(self):
+        dtypes = [
+            "uint8",
+            "uint16",
+            "uint32",
+            "uint64",
+            "int8",
+            "int16",
+            "int32",
+            "int64",
+            "float16",
+            "float32",
+            "complex64",
+        ]
+
+        for dtype in dtypes:
+            with self.subTest(dtype=dtype):
+                x = np.array(2, dtype=getattr(np, dtype))
+                y = np.min(x)
+
+                self.assertEqual(x.dtype, y.dtype)
+                self.assertTupleEqual(x.shape, y.shape)
+
+                z = mx.array(y)
+                self.assertEqual(np.array(z), x)
+                self.assertEqual(np.array(z), y)
+                self.assertEqual(z.dtype, getattr(mx, dtype))
+                self.assertListEqual(list(z.shape), list(x.shape))
+                self.assertListEqual(list(z.shape), list(y.shape))
+
+    def test_finfo(self):
+        with self.assertRaises(ValueError):
+            mx.finfo(mx.int32)
+
+        self.assertEqual(mx.finfo(mx.float32).min, np.finfo(np.float32).min)
+        self.assertEqual(mx.finfo(mx.float32).max, np.finfo(np.float32).max)
+        self.assertEqual(mx.finfo(mx.float32).eps, np.finfo(np.float32).eps)
+        self.assertEqual(mx.finfo(mx.float32).dtype, mx.float32)
+
+        self.assertEqual(mx.finfo(mx.float16).min, np.finfo(np.float16).min)
+        self.assertEqual(mx.finfo(mx.float16).max, np.finfo(np.float16).max)
+        self.assertEqual(mx.finfo(mx.float16).eps, np.finfo(np.float16).eps)
+        self.assertEqual(mx.finfo(mx.float16).dtype, mx.float16)
+
+    def test_iinfo(self):
+        with self.assertRaises(ValueError):
+            mx.iinfo(mx.float32)
+
+        self.assertEqual(mx.iinfo(mx.int32).min, np.iinfo(np.int32).min)
+        self.assertEqual(mx.iinfo(mx.int32).max, np.iinfo(np.int32).max)
+        self.assertEqual(mx.iinfo(mx.int32).dtype, mx.int32)
+
+        self.assertEqual(mx.iinfo(mx.uint32).min, np.iinfo(np.uint32).min)
+        self.assertEqual(mx.iinfo(mx.uint32).max, np.iinfo(np.uint32).max)
+        self.assertEqual(mx.iinfo(mx.int8).dtype, mx.int8)
+
+
+class TestEquality(mlx_tests.MLXTestCase):
+    def test_array_eq_array(self):
+        a = mx.array([1, 2, 3])
+        b = mx.array([1, 2, 3])
+        c = mx.array([1, 2, 4])
+        self.assertTrue(mx.all(a == b))
+        self.assertFalse(mx.all(a == c))
+
+    def test_array_eq_scalar(self):
+        a = mx.array([1, 2, 3])
+        b = 1
+        c = 4
+        d = 2.5
+        e = mx.array([1, 2.5, 3.25])
+        self.assertTrue(mx.any(a == b))
+        self.assertFalse(mx.all(a == c))
+        self.assertFalse(mx.all(a == d))
+        self.assertTrue(mx.any(a == e))
+
+    def test_list_equals_array(self):
+        a = mx.array([1, 2, 3])
+        b = [1, 2, 3]
+        c = [1, 2, 4]
+
+        # mlx array equality returns false if is compared with any kind of
+        # object which is not an mlx array
+        self.assertFalse(a == b)
+        self.assertFalse(a == c)
+
+    def test_tuple_equals_array(self):
+        a = mx.array([1, 2, 3])
+        b = (1, 2, 3)
+        c = (1, 2, 4)
+
+        # mlx array equality returns false if is compared with any kind of
+        # object which is not an mlx array
+        self.assertFalse(a == b)
+        self.assertFalse(a == c)
+
+
+class TestInequality(mlx_tests.MLXTestCase):
+    def test_array_ne_array(self):
+        a = mx.array([1, 2, 3])
+        b = mx.array([1, 2, 3])
+        c = mx.array([1, 2, 4])
+        self.assertFalse(mx.any(a != b))
+        self.assertTrue(mx.any(a != c))
+
+    def test_array_ne_scalar(self):
+        a = mx.array([1, 2, 3])
+        b = 1
+        c = 4
+        d = 1.5
+        e = 2.5
+        f = mx.array([1, 2.5, 3.25])
+        self.assertFalse(mx.all(a != b))
+        self.assertTrue(mx.any(a != c))
+        self.assertTrue(mx.any(a != d))
+        self.assertTrue(mx.any(a != e))
+        self.assertFalse(mx.all(a != f))
+
+    def test_list_not_equals_array(self):
+        a = mx.array([1, 2, 3])
+        b = [1, 2, 3]
+        c = [1, 2, 4]
+
+        # mlx array inequality returns true if is compared with any kind of
+        # object which is not an mlx array
+        self.assertTrue(a != b)
+        self.assertTrue(a != c)
+
+    def test_dlx_device_type(self):
+        a = mx.array([1, 2, 3])
+        device_type, device_id = a.__dlpack_device__()
+        self.assertIn(device_type, [1, 8, 13])
+        self.assertEqual(device_id, 0)
+
+        if device_type == 8:
+            # Additional check if Metal is supposed to be available
+            self.assertTrue(mx.metal.is_available())
+        elif device_type == 1:
+            # Additional check if CPU is the fallback
+            self.assertFalse(mx.metal.is_available())
+
+    def test_tuple_not_equals_array(self):
+        a = mx.array([1, 2, 3])
+        b = (1, 2, 3)
+        c = (1, 2, 4)
+
+        # mlx array inequality returns true if is compared with any kind of
+        # object which is not an mlx array
+        self.assertTrue(a != b)
+        self.assertTrue(a != c)
+
+    def test_obj_inequality_array(self):
+        str_ = "hello"
+        a = mx.array([1, 2, 3])
+        lst_ = [1, 2, 3]
+        tpl_ = (1, 2, 3)
+
+        # check if object comparison(</>/<=/>=) with mlx array should throw an exception
+        # if not, the tests will fail
+        with self.assertRaises(ValueError):
+            a < str_
+        with self.assertRaises(ValueError):
+            a > str_
+        with self.assertRaises(ValueError):
+            a <= str_
+        with self.assertRaises(ValueError):
+            a >= str_
+        with self.assertRaises(ValueError):
+            a < lst_
+        with self.assertRaises(ValueError):
+            a > lst_
+        with self.assertRaises(ValueError):
+            a <= lst_
+        with self.assertRaises(ValueError):
+            a >= lst_
+        with self.assertRaises(ValueError):
+            a < tpl_
+        with self.assertRaises(ValueError):
+            a > tpl_
+        with self.assertRaises(ValueError):
+            a <= tpl_
+        with self.assertRaises(ValueError):
+            a >= tpl_
+
+    def test_invalid_op_on_array(self):
+        str_ = "hello"
+        a = mx.array([1, 2.5, 3.25])
+        lst_ = [1, 2.1, 3.25]
+        tpl_ = (1, 2.5, 3.25)
+
+        with self.assertRaises(ValueError):
+            a * str_
+        with self.assertRaises(ValueError):
+            a *= str_
+        with self.assertRaises(ValueError):
+            a /= lst_
+        with self.assertRaises(ValueError):
+            a // lst_
+        with self.assertRaises(ValueError):
+            a % lst_
+        with self.assertRaises(ValueError):
+            a**tpl_
+        with self.assertRaises(ValueError):
+            a & tpl_
+        with self.assertRaises(ValueError):
+            a | str_
+
+
+class TestArray(mlx_tests.MLXTestCase):
+    def test_array_basics(self):
+        x = mx.array(1)
+        self.assertEqual(x.size, 1)
+        self.assertEqual(x.ndim, 0)
+        self.assertEqual(x.itemsize, 4)
+        self.assertEqual(x.nbytes, 4)
+        self.assertEqual(x.shape, ())
+        self.assertEqual(x.dtype, mx.int32)
+        self.assertEqual(x.item(), 1)
+        self.assertTrue(isinstance(x.item(), int))
+
+        with self.assertRaises(TypeError):
+            len(x)
+
+        x = mx.array(1, mx.uint32)
+        self.assertEqual(x.item(), 1)
+        self.assertTrue(isinstance(x.item(), int))
+
+        x = mx.array(1, mx.int64)
+        self.assertEqual(x.item(), 1)
+        self.assertTrue(isinstance(x.item(), int))
+
+        x = mx.array(1, mx.bfloat16)
+        self.assertEqual(x.item(), 1.0)
+
+        x = mx.array(1.0)
+        self.assertEqual(x.size, 1)
+        self.assertEqual(x.ndim, 0)
+        self.assertEqual(x.shape, ())
+        self.assertEqual(x.dtype, mx.float32)
+        self.assertEqual(x.item(), 1.0)
+        self.assertTrue(isinstance(x.item(), float))
+
+        x = mx.array(False)
+        self.assertEqual(x.size, 1)
+        self.assertEqual(x.ndim, 0)
+        self.assertEqual(x.shape, ())
+        self.assertEqual(x.dtype, mx.bool_)
+        self.assertEqual(x.item(), False)
+        self.assertTrue(isinstance(x.item(), bool))
+
+        x = mx.array(complex(1, 1))
+        self.assertEqual(x.ndim, 0)
+        self.assertEqual(x.shape, ())
+        self.assertEqual(x.dtype, mx.complex64)
+        self.assertEqual(x.item(), complex(1, 1))
+        self.assertTrue(isinstance(x.item(), complex))
+
+        x = mx.array([True, False, True])
+        self.assertEqual(x.dtype, mx.bool_)
+        self.assertEqual(x.ndim, 1)
+        self.assertEqual(x.shape, (3,))
+        self.assertEqual(len(x), 3)
+
+        x = mx.array([True, False, True], mx.float32)
+        self.assertEqual(x.dtype, mx.float32)
+
+        x = mx.array([0, 1, 2])
+        self.assertEqual(x.dtype, mx.int32)
+        self.assertEqual(x.ndim, 1)
+        self.assertEqual(x.shape, (3,))
+
+        x = mx.array([0, 1, 2], mx.float32)
+        self.assertEqual(x.dtype, mx.float32)
+
+        x = mx.array([0.0, 1.0, 2.0])
+        self.assertEqual(x.dtype, mx.float32)
+        self.assertEqual(x.ndim, 1)
+        self.assertEqual(x.shape, (3,))
+
+        x = mx.array([1j, 1 + 0j])
+        self.assertEqual(x.dtype, mx.complex64)
+        self.assertEqual(x.ndim, 1)
+        self.assertEqual(x.shape, (2,))
+
+        # From tuple
+        x = mx.array((1, 2, 3), mx.int32)
+        self.assertEqual(x.dtype, mx.int32)
+        self.assertEqual(x.tolist(), [1, 2, 3])
+
+    def test_bool_conversion(self):
+        x = mx.array(True)
+        self.assertTrue(x)
+        x = mx.array(False)
+        self.assertFalse(x)
+        x = mx.array(1.0)
+        self.assertTrue(x)
+        x = mx.array(0.0)
+        self.assertFalse(x)
+
+    def test_int_type(self):
+        x = mx.array(1)
+        self.assertTrue(x.dtype == mx.int32)
+        x = mx.array(2**32 - 1)
+        self.assertTrue(x.dtype == mx.int64)
+        x = mx.array(2**40)
+        self.assertTrue(x.dtype == mx.int64)
+        x = mx.array(2**32 - 1, dtype=mx.uint32)
+        self.assertTrue(x.dtype == mx.uint32)
+        x = mx.array([1, 2], dtype=mx.int64) + 0x80000000
+        self.assertTrue(x.dtype == mx.int64)
+
+    def test_construction_from_lists(self):
+        x = mx.array([])
+        self.assertEqual(x.size, 0)
+        self.assertEqual(x.shape, (0,))
+        self.assertEqual(x.dtype, mx.float32)
+
+        x = mx.array([[], [], []])
+        self.assertEqual(x.size, 0)
+        self.assertEqual(x.shape, (3, 0))
+        self.assertEqual(x.dtype, mx.float32)
+
+        x = mx.array([[[], []], [[], []], [[], []]])
+        self.assertEqual(x.size, 0)
+        self.assertEqual(x.shape, (3, 2, 0))
+        self.assertEqual(x.dtype, mx.float32)
+
+        # Check failure cases
+        with self.assertRaises(ValueError):
+            x = mx.array([[[], []], [[]], [[], []]])
+
+        with self.assertRaises(ValueError):
+            x = mx.array([[[], []], [[1.0, 2.0], []], [[], []]])
+
+        with self.assertRaises(ValueError):
+            x = mx.array([[0, 1], [[0, 1], 1]])
+
+        with self.assertRaises(ValueError):
+            x = mx.array([[0, 1], ["hello", 1]])
+
+        x = mx.array([True, False, 3])
+        self.assertEqual(x.dtype, mx.int32)
+
+        x = mx.array([True, False, 3, 4.0])
+        self.assertEqual(x.dtype, mx.float32)
+
+        x = mx.array([[True, False], [1, 3], [2, 4.0]])
+        self.assertEqual(x.dtype, mx.float32)
+
+        x = mx.array([[1.0, 2.0], [0.0, 3.9]], mx.bool_)
+        self.assertEqual(x.dtype, mx.bool_)
+        self.assertTrue(mx.array_equal(x, mx.array([[True, True], [False, True]])))
+
+        x = mx.array([[1.0, 2.0], [0.0, 3.9]], mx.int32)
+        self.assertTrue(mx.array_equal(x, mx.array([[1, 2], [0, 3]])))
+
+        x = mx.array([1 + 0j, 2j, True, 0], mx.complex64)
+        self.assertEqual(x.tolist(), [1 + 0j, 2j, 1 + 0j, 0j])
+
+        xnp = np.array([0, 4294967295], dtype=np.uint32)
+        x = mx.array([0, 4294967295], dtype=mx.uint32)
+        self.assertTrue(np.array_equal(x, xnp))
+
+        xnp = np.array([0, 4294967295], dtype=np.float32)
+        x = mx.array([0, 4294967295], dtype=mx.float32)
+        self.assertTrue(np.array_equal(x, xnp))
+
+    def test_construction_from_lists_of_mlx_arrays(self):
+        dtypes = [
+            mx.bool_,
+            mx.uint8,
+            mx.uint16,
+            mx.uint32,
+            mx.uint64,
+            mx.int8,
+            mx.int16,
+            mx.int32,
+            mx.int64,
+            mx.float16,
+            mx.float32,
+            mx.bfloat16,
+            mx.complex64,
+        ]
+        for x_t, y_t in permutations(dtypes, 2):
+            # check type promotion and numeric correctness
+            x, y = mx.array([1.0], x_t), mx.array([2.0], y_t)
+            z = mx.array([x, y])
+            expected = mx.stack([x, y], axis=0)
+            self.assertEqualArray(z, expected)
+
+            # check heterogeneous construction with mlx arrays and python primitive types
+            x, y = mx.array([True], x_t), mx.array([False], y_t)
+            z = mx.array([[x, [2.0]], [[3.0], y]])
+            expected = mx.array([[[x.item()], [2.0]], [[3.0], [y.item()]]], z.dtype)
+            self.assertEqualArray(z, expected)
+
+        # check when create from an array which does not contain memory to the raw data
+        x = mx.array([1.0]).astype(mx.bfloat16)  # x does not hold raw data
+        for y_t in dtypes:
+            y = mx.array([2.0], y_t)
+            z = mx.array([x, y])
+            expected = mx.stack([x, y], axis=0)
+            self.assertEqualArray(z, expected)
+
+        # shape check from `stack()`
+        with self.assertRaises(ValueError) as e:
+            mx.array([x, 1.0])
+        self.assertEqual(
+            str(e.exception), "Initialization encountered non-uniform length."
+        )
+
+        # shape check from `validate_shape`
+        with self.assertRaises(ValueError) as e:
+            mx.array([1.0, x])
+        self.assertEqual(
+            str(e.exception), "Initialization encountered non-uniform length."
+        )
+
+        # check that `[mx.array, ...]` retains the `mx.array` in the graph
+        def f(x):
+            y = mx.array([x, mx.array([2.0])])
+            return (2 * y).sum()
+
+        x = mx.array([1.0])
+        dfdx = mx.grad(f)
+        self.assertEqual(dfdx(x).item(), 2.0)
+
+    def test_init_from_array(self):
+        x = mx.array(3.0)
+        y = mx.array(x)
+
+        self.assertTrue(mx.array_equal(x, y))
+
+        y = mx.array(x, mx.int32)
+        self.assertEqual(y.dtype, mx.int32)
+        self.assertEqual(y.item(), 3)
+
+        y = mx.array(x, mx.bool_)
+        self.assertEqual(y.dtype, mx.bool_)
+        self.assertEqual(y.item(), True)
+
+        y = mx.array(x, mx.complex64)
+        self.assertEqual(y.dtype, mx.complex64)
+        self.assertEqual(y.item(), 3.0 + 0j)
+
+    def test_array_repr(self):
+        x = mx.array(True)
+        self.assertEqual(str(x), "array(True, dtype=bool)")
+        x = mx.array(1)
+        self.assertEqual(str(x), "array(1, dtype=int32)")
+        x = mx.array(1.0)
+        self.assertEqual(str(x), "array(1, dtype=float32)")
+
+        x = mx.array([1, 0, 1])
+        self.assertEqual(str(x), "array([1, 0, 1], dtype=int32)")
+
+        x = mx.array([1] * 6)
+        expected = "array([1, 1, 1, 1, 1, 1], dtype=int32)"
+        self.assertEqual(str(x), expected)
+
+        x = mx.array([1] * 7)
+        expected = "array([1, 1, 1, ..., 1, 1, 1], dtype=int32)"
+        self.assertEqual(str(x), expected)
+
+        x = mx.array([[1, 2], [1, 2], [1, 2]])
+        expected = "array([[1, 2],\n       [1, 2],\n       [1, 2]], dtype=int32)"
+        self.assertEqual(str(x), expected)
+
+        x = mx.array([[[1, 2], [1, 2]], [[1, 2], [1, 2]]])
+        expected = (
+            "array([[[1, 2],\n"
+            "        [1, 2]],\n"
+            "       [[1, 2],\n"
+            "        [1, 2]]], dtype=int32)"
+        )
+        self.assertEqual(str(x), expected)
+
+        x = mx.array([[1, 2]] * 6)
+        expected = (
+            "array([[1, 2],\n"
+            "       [1, 2],\n"
+            "       [1, 2],\n"
+            "       [1, 2],\n"
+            "       [1, 2],\n"
+            "       [1, 2]], dtype=int32)"
+        )
+        self.assertEqual(str(x), expected)
+        x = mx.array([[1, 2]] * 7)
+        expected = (
+            "array([[1, 2],\n"
+            "       [1, 2],\n"
+            "       [1, 2],\n"
+            "       ...,\n"
+            "       [1, 2],\n"
+            "       [1, 2],\n"
+            "       [1, 2]], dtype=int32)"
+        )
+        self.assertEqual(str(x), expected)
+
+        x = mx.array([1], dtype=mx.int8)
+        expected = "array([1], dtype=int8)"
+        self.assertEqual(str(x), expected)
+        x = mx.array([1], dtype=mx.int16)
+        expected = "array([1], dtype=int16)"
+        self.assertEqual(str(x), expected)
+        x = mx.array([1], dtype=mx.uint8)
+        expected = "array([1], dtype=uint8)"
+        self.assertEqual(str(x), expected)
+
+        # Fp16 is not supported in all platforms
+        x = mx.array([1.2], dtype=mx.float16)
+        expected = "array([1.2002], dtype=float16)"
+        self.assertEqual(str(x), expected)
+
+        x = mx.array([1 + 1j], dtype=mx.complex64)
+        expected = "array([1+1j], dtype=complex64)"
+        self.assertEqual(str(x), expected)
+        x = mx.array([1 - 1j], dtype=mx.complex64)
+        expected = "array([1-1j], dtype=complex64)"
+
+        x = mx.array([1 + 1j], dtype=mx.complex64)
+        expected = "array([1+1j], dtype=complex64)"
+        self.assertEqual(str(x), expected)
+        x = mx.array([1 - 1j], dtype=mx.complex64)
+        expected = "array([1-1j], dtype=complex64)"
+
+    def test_array_to_list(self):
+        types = [mx.bool_, mx.uint32, mx.int32, mx.int64, mx.float32]
+        for t in types:
+            x = mx.array(1, t)
+            self.assertEqual(x.tolist(), 1)
+
+        vals = [1, 2, 3, 4]
+        x = mx.array(vals)
+        self.assertEqual(x.tolist(), vals)
+
+        vals = [[1, 2], [3, 4]]
+        x = mx.array(vals)
+        self.assertEqual(x.tolist(), vals)
+
+        vals = [[1, 0], [0, 1]]
+        x = mx.array(vals, mx.bool_)
+        self.assertEqual(x.tolist(), vals)
+
+        vals = [[1.5, 2.5], [3.5, 4.5]]
+        x = mx.array(vals)
+        self.assertEqual(x.tolist(), vals)
+
+        vals = [[[0.5, 1.5], [2.5, 3.5]], [[4.5, 5.5], [6.5, 7.5]]]
+        x = mx.array(vals)
+        self.assertEqual(x.tolist(), vals)
+
+        # Empty arrays
+        vals = []
+        x = mx.array(vals)
+        self.assertEqual(x.tolist(), vals)
+
+        vals = [[], []]
+        x = mx.array(vals)
+        self.assertEqual(x.tolist(), vals)
+
+        # Complex arrays
+        vals = [0.5 + 0j, 1.5 + 1j, 2.5 + 0j, 3.5 + 1j]
+        x = mx.array(vals)
+        self.assertEqual(x.tolist(), vals)
+
+        # Half types
+        vals = [1.0, 2.0, 3.0, 4.0, 5.0]
+        x = mx.array(vals, dtype=mx.float16)
+        self.assertEqual(x.tolist(), vals)
+
+        x = mx.array(vals, dtype=mx.bfloat16)
+        self.assertEqual(x.tolist(), vals)
+
+    def test_array_np_conversion(self):
+        # Shape test
+        a = np.array([])
+        x = mx.array(a)
+        self.assertEqual(x.size, 0)
+        self.assertEqual(x.shape, (0,))
+        self.assertEqual(x.dtype, mx.float32)
+
+        a = np.array([[], [], []])
+        x = mx.array(a)
+        self.assertEqual(x.size, 0)
+        self.assertEqual(x.shape, (3, 0))
+        self.assertEqual(x.dtype, mx.float32)
+
+        a = np.array([[[], []], [[], []], [[], []]])
+        x = mx.array(a)
+        self.assertEqual(x.size, 0)
+        self.assertEqual(x.shape, (3, 2, 0))
+        self.assertEqual(x.dtype, mx.float32)
+
+        # Content test
+        a = 2.0 * np.ones((3, 5, 4))
+        x = mx.array(a)
+        self.assertEqual(x.dtype, mx.float32)
+        self.assertEqual(x.ndim, 3)
+        self.assertEqual(x.shape, (3, 5, 4))
+
+        y = np.asarray(x)
+        self.assertTrue(np.allclose(a, y))
+
+        a = np.array(3, dtype=np.int32)
+        x = mx.array(a)
+        self.assertEqual(x.dtype, mx.int32)
+        self.assertEqual(x.ndim, 0)
+        self.assertEqual(x.shape, ())
+        self.assertEqual(x.item(), 3)
+
+        # mlx to numpy test
+        x = mx.array([True, False, True])
+        y = np.asarray(x)
+        self.assertEqual(y.dtype, np.bool_)
+        self.assertEqual(y.ndim, 1)
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y[0], True)
+        self.assertEqual(y[1], False)
+        self.assertEqual(y[2], True)
+
+        # complex64 mx <-> np
+        cvals = [0j, 1, 1 + 1j]
+        x = np.array(cvals)
+        y = mx.array(x)
+        self.assertEqual(y.dtype, mx.complex64)
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.tolist(), cvals)
+
+        y = mx.array([0j, 1, 1 + 1j])
+        x = np.asarray(y)
+        self.assertEqual(x.dtype, np.complex64)
+        self.assertEqual(x.shape, (3,))
+        self.assertEqual(x.tolist(), cvals)
+
+    def test_array_np_dtype_conversion(self):
+        dtypes_list = [
+            (mx.bool_, np.bool_),
+            (mx.uint8, np.uint8),
+            (mx.uint16, np.uint16),
+            (mx.uint32, np.uint32),
+            (mx.uint64, np.uint64),
+            (mx.int8, np.int8),
+            (mx.int16, np.int16),
+            (mx.int32, np.int32),
+            (mx.int64, np.int64),
+            (mx.float16, np.float16),
+            (mx.float32, np.float32),
+            (mx.complex64, np.complex64),
+        ]
+
+        for mlx_dtype, np_dtype in dtypes_list:
+            a_npy = np.random.uniform(low=0, high=100, size=(32,)).astype(np_dtype)
+            a_mlx = mx.array(a_npy)
+
+            self.assertEqual(a_mlx.dtype, mlx_dtype)
+            self.assertTrue(np.allclose(a_mlx, a_npy))
+
+            b_mlx = mx.random.uniform(
+                low=0,
+                high=10,
+                shape=(32,),
+            ).astype(mlx_dtype)
+            b_npy = np.array(b_mlx)
+
+            self.assertEqual(b_npy.dtype, np_dtype)
+
+    def test_array_from_noncontiguous_np(self):
+        for t in [np.int8, np.int32, np.float16, np.float32, np.complex64]:
+            np_arr = np.random.uniform(size=(10, 10)).astype(np.complex64)
+            np_arr = np_arr.T
+            mx_arr = mx.array(np_arr)
+            self.assertTrue(mx.array_equal(np_arr, mx_arr))
+
+    def test_array_np_shape_dim_check(self):
+        a_npy = np.empty(2**31, dtype=np.bool_)
+        with self.assertRaises(ValueError) as e:
+            mx.array(a_npy)
+        self.assertEqual(
+            str(e.exception), "Shape dimension falls outside supported `int` range."
+        )
+
+    def test_dtype_promotion(self):
+        dtypes_list = [
+            (mx.bool_, np.bool_),
+            (mx.uint8, np.uint8),
+            (mx.uint16, np.uint16),
+            (mx.uint32, np.uint32),
+            (mx.uint64, np.uint64),
+            (mx.int8, np.int8),
+            (mx.int16, np.int16),
+            (mx.int32, np.int32),
+            (mx.int64, np.int64),
+            (mx.float32, np.float32),
+        ]
+
+        promotion_pairs = permutations(dtypes_list, 2)
+
+        for (mlx_dt_1, np_dt_1), (mlx_dt_2, np_dt_2) in promotion_pairs:
+            with self.subTest(dtype1=np_dt_1, dtype2=np_dt_2):
+                a_npy = np.ones((3,), dtype=np_dt_1)
+                b_npy = np.ones((3,), dtype=np_dt_2)
+
+                c_npy = a_npy + b_npy
+
+                a_mlx = mx.ones((3,), dtype=mlx_dt_1)
+                b_mlx = mx.ones((3,), dtype=mlx_dt_2)
+
+                c_mlx = a_mlx + b_mlx
+
+                self.assertEqual(c_mlx.dtype, mx.array(c_npy).dtype)
+
+        a_mlx = mx.ones((3,), dtype=mx.float16)
+        b_mlx = mx.ones((3,), dtype=mx.float32)
+        c_mlx = a_mlx + b_mlx
+
+        self.assertEqual(c_mlx.dtype, mx.float32)
+
+        b_mlx = mx.ones((3,), dtype=mx.int32)
+        c_mlx = a_mlx + b_mlx
+
+        self.assertEqual(c_mlx.dtype, mx.float16)
+
+    def test_dtype_python_scalar_promotion(self):
+        tests = [
+            (mx.bool_, operator.mul, False, mx.bool_),
+            (mx.bool_, operator.mul, 0, mx.int32),
+            (mx.bool_, operator.mul, 1.0, mx.float32),
+            (mx.int8, operator.mul, False, mx.int8),
+            (mx.int8, operator.mul, 0, mx.int8),
+            (mx.int8, operator.mul, 1.0, mx.float32),
+            (mx.int16, operator.mul, False, mx.int16),
+            (mx.int16, operator.mul, 0, mx.int16),
+            (mx.int16, operator.mul, 1.0, mx.float32),
+            (mx.int32, operator.mul, False, mx.int32),
+            (mx.int32, operator.mul, 0, mx.int32),
+            (mx.int32, operator.mul, 1.0, mx.float32),
+            (mx.int64, operator.mul, False, mx.int64),
+            (mx.int64, operator.mul, 0, mx.int64),
+            (mx.int64, operator.mul, 1.0, mx.float32),
+            (mx.uint8, operator.mul, False, mx.uint8),
+            (mx.uint8, operator.mul, 0, mx.uint8),
+            (mx.uint8, operator.mul, 1.0, mx.float32),
+            (mx.uint16, operator.mul, False, mx.uint16),
+            (mx.uint16, operator.mul, 0, mx.uint16),
+            (mx.uint16, operator.mul, 1.0, mx.float32),
+            (mx.uint32, operator.mul, False, mx.uint32),
+            (mx.uint32, operator.mul, 0, mx.uint32),
+            (mx.uint32, operator.mul, 1.0, mx.float32),
+            (mx.uint64, operator.mul, False, mx.uint64),
+            (mx.uint64, operator.mul, 0, mx.uint64),
+            (mx.uint64, operator.mul, 1.0, mx.float32),
+            (mx.float32, operator.mul, False, mx.float32),
+            (mx.float32, operator.mul, 0, mx.float32),
+            (mx.float32, operator.mul, 1.0, mx.float32),
+            (mx.float16, operator.mul, False, mx.float16),
+            (mx.float16, operator.mul, 0, mx.float16),
+            (mx.float16, operator.mul, 1.0, mx.float16),
+        ]
+
+        for dtype_in, f, v, dtype_out in tests:
+            x = mx.array(0, dtype_in)
+            y = f(x, v)
+            self.assertEqual(y.dtype, dtype_out)
+
+    def test_array_comparison(self):
+        a = mx.array([0.0, 1.0, 5.0])
+        b = mx.array([-1.0, 2.0, 5.0])
+
+        self.assertEqual((a < b).tolist(), [False, True, False])
+        self.assertEqual((a <= b).tolist(), [False, True, True])
+        self.assertEqual((a > b).tolist(), [True, False, False])
+        self.assertEqual((a >= b).tolist(), [True, False, True])
+
+        self.assertEqual((a < 5).tolist(), [True, True, False])
+        self.assertEqual((5 < a).tolist(), [False, False, False])
+        self.assertEqual((5 <= a).tolist(), [False, False, True])
+        self.assertEqual((a > 1).tolist(), [False, False, True])
+        self.assertEqual((a >= 1).tolist(), [False, True, True])
+
+    def test_array_neg(self):
+        a = mx.array([-1.0, 4.0, 0.0])
+
+        self.assertEqual((-a).tolist(), [1.0, -4.0, 0.0])
+
+    def test_array_type_cast(self):
+        a = mx.array([0.1, 2.3, -1.3])
+        b = [0, 2, -1]
+
+        self.assertEqual(a.astype(mx.int32).tolist(), b)
+        self.assertEqual(a.astype(mx.int32).dtype, mx.int32)
+
+        b = mx.array(b).astype(mx.float32)
+        self.assertEqual(b.dtype, mx.float32)
+
+    def test_array_iteration(self):
+        a = mx.array([0, 1, 2])
+
+        for i, x in enumerate(a):
+            self.assertEqual(x.item(), i)
+
+        a = mx.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
+        x, y, z = a
+        self.assertEqual(x.tolist(), [1.0, 2.0])
+        self.assertEqual(y.tolist(), [3.0, 4.0])
+        self.assertEqual(z.tolist(), [5.0, 6.0])
+
+    def test_array_pickle(self):
+        dtypes = [
+            mx.int8,
+            mx.int16,
+            mx.int32,
+            mx.int64,
+            mx.uint8,
+            mx.uint16,
+            mx.uint32,
+            mx.uint64,
+            mx.float16,
+            mx.float32,
+            mx.bfloat16,
+            mx.complex64,
+        ]
+
+        for dtype in dtypes:
+            x = mx.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], dtype=dtype)
+            state = pickle.dumps(x)
+            y = pickle.loads(state)
+            self.assertEqualArray(y, x)
+
+    def test_array_copy(self):
+        dtypes = [
+            mx.int8,
+            mx.int16,
+            mx.int32,
+            mx.int64,
+            mx.uint8,
+            mx.uint16,
+            mx.uint32,
+            mx.uint64,
+            mx.float16,
+            mx.float32,
+            mx.bfloat16,
+            mx.complex64,
+        ]
+
+        for copy_function in [copy, deepcopy]:
+            for dtype in dtypes:
+                x = mx.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], dtype=dtype)
+                y = copy_function(x)
+                self.assertEqualArray(y, x)
+
+                y -= 1
+                self.assertEqualArray(y, x - 1)
+
+    def test_indexing(self):
+        # Only ellipsis is a no-op
+        a_mlx = mx.array([1])[...]
+        self.assertEqual(a_mlx.shape, (1,))
+        self.assertEqual(a_mlx.item(), 1)
+
+        # Basic content check, slice indexing
+        a_npy = np.arange(64, dtype=np.float32)
+        a_mlx = mx.array(a_npy)
+        a_sliced_mlx = a_mlx[2:50:4]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[2:50:4]))
+
+        # Basic content check, mlx array indexing
+        a_npy = np.arange(64, dtype=np.int32)
+        a_npy = a_npy.reshape((8, 8))
+        a_mlx = mx.array(a_npy)
+        idx_npy = np.array([0, 1, 2, 7, 5], dtype=np.uint32)
+        idx_mlx = mx.array(idx_npy)
+        a_sliced_mlx = a_mlx[idx_mlx]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[idx_npy]))
+
+        # Basic content check, int indexing
+        a_sliced_mlx = a_mlx[5]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[5]))
+        self.assertEqual(len(a_sliced_npy.shape), len(a_npy[5].shape))
+        self.assertEqual(len(a_sliced_npy.shape), 1)
+        self.assertEqual(a_sliced_npy.shape[0], a_npy[5].shape[0])
+
+        # Basic content check, negative indexing
+        a_sliced_mlx = a_mlx[-1]
+        self.assertTrue(np.array_equal(a_sliced_mlx, a_npy[-1]))
+
+        # Basic content check, empty index
+        a_sliced_mlx = a_mlx[()]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[()]))
+
+        # Basic content check, new axis
+        a_sliced_mlx = a_mlx[None]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[None]))
+
+        a_sliced_mlx = a_mlx[:, None]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[:, None]))
+
+        # Multi dim indexing, all ints
+        self.assertEqual(a_mlx[0, 0].item(), 0)
+        self.assertEqual(a_mlx[0, 0].ndim, 0)
+
+        # Multi dim indexing, all slices
+        a_sliced_mlx = a_mlx[2:4, 5:]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[2:4, 5:]))
+
+        a_sliced_mlx = a_mlx[:, 0:5]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[:, 0:5]))
+
+        # Slicing, strides
+        a_sliced_mlx = a_mlx[:, ::2]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[:, ::2]))
+
+        # Slicing, -ve index
+        a_sliced_mlx = a_mlx[-2:, :-1]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[-2:, :-1]))
+
+        # Slicing, start > end
+        a_sliced_mlx = a_mlx[8:3]
+        self.assertEqual(a_sliced_mlx.size, 0)
+
+        # Slicing, Clipping past the end
+        a_sliced_mlx = a_mlx[7:10]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[7:10]))
+
+        # Multi dim indexing, int and slices
+        a_sliced_mlx = a_mlx[0, :5]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[0, :5]))
+
+        a_sliced_mlx = a_mlx[:, -1]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[:, -1]))
+
+        # Multi dim indexing, int and array
+        a_sliced_mlx = a_mlx[idx_mlx, 0]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[idx_npy, 0]))
+
+        # Multi dim indexing, array and slices
+        a_sliced_mlx = a_mlx[idx_mlx, :5]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[idx_npy, :5]))
+
+        a_sliced_mlx = a_mlx[:, idx_mlx]
+        a_sliced_npy = np.asarray(a_sliced_mlx)
+        self.assertTrue(np.array_equal(a_sliced_npy, a_npy[:, idx_npy]))
+
+        # Multi dim indexing with multiple arrays
+        def check_slices(arr_np, *idx_np):
+            arr_mlx = mx.array(arr_np)
+            idx_mlx = [
+                mx.array(idx) if isinstance(idx, np.ndarray) else idx for idx in idx_np
+            ]
+            slice_mlx = arr_mlx[tuple(idx_mlx)]
+            self.assertTrue(
+                np.array_equal(arr_np[tuple(idx_np)], arr_mlx[tuple(idx_mlx)])
+            )
+
+        a_np = np.arange(16).reshape(4, 4)
+        check_slices(a_np, np.array([0, 1, 2, 3]), np.array([0, 1, 2, 3]))
+        check_slices(a_np, np.array([0, 1, 2, 3]), np.array([1, 0, 3, 3]))
+        check_slices(a_np, np.array([[0, 1]]), np.array([[0], [1], [3]]))
+
+        a_np = np.arange(64).reshape(2, 4, 2, 4)
+        check_slices(a_np, 0, np.array([0, 1, 2]))
+        check_slices(a_np, slice(0, 1), np.array([0, 1, 2]))
+        check_slices(
+            a_np, slice(0, 1), np.array([0, 1, 2]), slice(None), slice(0, 4, 2)
+        )
+        check_slices(
+            a_np, slice(0, 1), np.array([0, 1, 2]), slice(None), np.array([1, 2, 0])
+        )
+        check_slices(a_np, slice(0, 1), np.array([0, 1, 2]), 1, np.array([1, 2, 0]))
+        check_slices(
+            a_np, slice(0, 1), np.array([0, 1, 2]), np.array([1, 0, 0]), slice(0, 1)
+        )
+        check_slices(
+            a_np,
+            slice(0, 1),
+            np.array([[0], [1], [2]]),
+            np.array([[1, 0, 0]]),
+            slice(0, 1),
+        )
+        check_slices(
+            a_np,
+            slice(0, 2),
+            np.array([[0], [1], [2]]),
+            slice(0, 2),
+            np.array([[1, 0, 0]]),
+        )
+        for p in permutations([slice(None), slice(None), 0, np.array([1, 0])]):
+            check_slices(a_np, *p)
+        for p in permutations(
+            [slice(None), slice(None), 0, np.array([1, 0]), None, None]
+        ):
+            check_slices(a_np, *p)
+        for p in permutations([0, np.array([1, 0]), None, Ellipsis, slice(None)]):
+            check_slices(a_np, *p)
+
+        # Non-contiguous arrays in slicing
+        a_mlx = mx.reshape(mx.arange(128), (16, 8))
+        a_mlx = a_mlx[::2, :]
+        a_np = np.array(a_mlx)
+        idx_np = np.arange(8)[::2]
+        idx_mlx = mx.arange(8)[::2]
+        self.assertTrue(
+            np.array_equal(a_np[idx_np, idx_np], np.array(a_mlx[idx_mlx, idx_mlx]))
+        )
+
+        # Slicing with negative indices and integer
+        a_np = np.arange(10).reshape(5, 2)
+        a_mlx = mx.array(a_np)
+        self.assertTrue(np.array_equal(a_np[2:-1, 0], np.array(a_mlx[2:-1, 0])))
+
+    def test_indexing_grad(self):
+        x = mx.array([[1, 2], [3, 4]]).astype(mx.float32)
+        ind = mx.array([0, 1, 0]).astype(mx.float32)
+
+        def index_fn(x, ind):
+            return x[ind.astype(mx.int32)].sum()
+
+        grad_x, grad_ind = mx.grad(index_fn, argnums=(0, 1))(x, ind)
+        expected = mx.array([[2, 2], [1, 1]])
+
+        self.assertTrue(mx.array_equal(grad_x, expected))
+        self.assertTrue(mx.array_equal(grad_ind, mx.zeros(ind.shape)))
+
+    def test_setitem(self):
+        a = mx.array(0)
+        a[None] = 1
+        self.assertEqual(a.item(), 1)
+
+        a = mx.array([1, 2, 3])
+        a[0] = 2
+        self.assertEqual(a.tolist(), [2, 2, 3])
+
+        a[-1] = 2
+        self.assertEqual(a.tolist(), [2, 2, 2])
+
+        a[0] = mx.array([[[1]]])
+        self.assertEqual(a.tolist(), [1, 2, 2])
+
+        a[:] = 0
+        self.assertEqual(a.tolist(), [0, 0, 0])
+
+        a[None] = 1
+        self.assertEqual(a.tolist(), [1, 1, 1])
+
+        a[0:1] = 2
+        self.assertEqual(a.tolist(), [2, 1, 1])
+
+        a[0:2] = 3
+        self.assertEqual(a.tolist(), [3, 3, 1])
+
+        a[0:3] = 4
+        self.assertEqual(a.tolist(), [4, 4, 4])
+
+        a[0:1] = mx.array(0)
+        self.assertEqual(a.tolist(), [0, 4, 4])
+
+        a[0:1] = mx.array([1])
+        self.assertEqual(a.tolist(), [1, 4, 4])
+
+        with self.assertRaises(ValueError):
+            a[0:1] = mx.array([2, 3])
+
+        a[0:2] = mx.array([2, 2])
+        self.assertEqual(a.tolist(), [2, 2, 4])
+
+        a[:] = mx.array([[[[1, 1, 1]]]])
+        self.assertEqual(a.tolist(), [1, 1, 1])
+
+        # Array slices
+        def check_slices(arr_np, update_np, *idx_np):
+            arr_mlx = mx.array(arr_np)
+            update_mlx = mx.array(update_np)
+            idx_mlx = [
+                mx.array(idx) if isinstance(idx, np.ndarray) else idx for idx in idx_np
+            ]
+            if len(idx_np) > 1:
+                idx_np = tuple(idx_np)
+                idx_mlx = tuple(idx_mlx)
+            else:
+                idx_np = idx_np[0]
+                idx_mlx = idx_mlx[0]
+            arr_np[idx_np] = update_np
+            arr_mlx[idx_mlx] = update_mlx
+            self.assertTrue(np.array_equal(arr_np, arr_mlx))
+
+        check_slices(np.zeros((3, 3)), 1, 0)
+        check_slices(np.zeros((3, 3)), 1, -1)
+        check_slices(np.zeros((3, 3)), 1, slice(0, 2))
+        check_slices(np.zeros((3, 3)), np.array([[0, 1, 2], [3, 4, 5]]), slice(0, 2))
+
+        with self.assertRaises(ValueError):
+            a = mx.array(0)
+            a[0] = mx.array(1)
+
+        check_slices(np.zeros((3, 3)), 1, np.array([0, 1, 2]))
+        check_slices(np.zeros((3, 3)), np.array(3), np.array([0, 1, 2]))
+        check_slices(np.zeros((3, 3)), np.array([3]), np.array([0, 1, 2]))
+        check_slices(np.zeros((3, 3)), np.array([3]), np.array([0, 1]))
+        check_slices(np.zeros((3, 2)), np.array([[3, 3], [4, 4]]), np.array([0, 1]))
+        check_slices(np.zeros((3, 2)), np.array([[3, 3], [4, 4]]), np.array([0, 1]))
+        check_slices(
+            np.zeros((3, 2)), np.array([[3, 3], [4, 4], [5, 5]]), np.array([0, 2, 1])
+        )
+
+        # Multiple slices
+        a = mx.array(0)
+        a[None, None] = 1
+        self.assertEqual(a.item(), 1)
+
+        a[None, None] = mx.array(2)
+        self.assertEqual(a.item(), 2)
+
+        a[None, None] = mx.array([[[3]]])
+        self.assertEqual(a.item(), 3)
+
+        a[()] = 4
+        self.assertEqual(a.item(), 4)
+
+        a_np = np.zeros((2, 3, 4, 5))
+        check_slices(a_np, 1, np.array([0, 0]), slice(0, 2), slice(0, 3), 4)
+        check_slices(
+            a_np,
+            np.arange(10).reshape(2, 5),
+            np.array([0, 0]),
+            np.array([0, 1]),
+            np.array([2, 3]),
+        )
+        check_slices(
+            a_np,
+            np.array([[3], [4]]),
+            np.array([0, 0]),
+            np.array([0, 1]),
+            np.array([2, 3]),
+        )
+        check_slices(
+            a_np, np.arange(5), np.array([0, 0]), np.array([0, 1]), np.array([2, 3])
+        )
+        check_slices(np.zeros(5), np.arange(2), None, None, np.array([2, 3]))
+        check_slices(
+            np.zeros((4, 3, 4)),
+            np.arange(3),
+            np.array([2, 3]),
+            slice(0, 3),
+            np.array([2, 3]),
+        )
+
+        with self.assertRaises(ValueError):
+            a = mx.zeros((4, 3, 4))
+            a[mx.array([2, 3]), None, mx.array([2, 3])] = mx.arange(2)
+
+        with self.assertRaises(ValueError):
+            a = mx.zeros((4, 3, 4))
+            a[mx.array([2, 3]), None, mx.array([2, 3])] = mx.arange(3)
+
+        check_slices(np.zeros((4, 3, 4)), 1, np.array([2, 3]), None, np.array([2, 1]))
+        check_slices(
+            np.zeros((4, 3, 4)), np.arange(4), np.array([2, 3]), None, np.array([2, 1])
+        )
+        check_slices(
+            np.zeros((4, 3, 4)),
+            np.arange(2 * 4).reshape(2, 1, 4),
+            np.array([2, 3]),
+            None,
+            np.array([2, 1]),
+        )
+
+        check_slices(np.zeros((4, 4)), 1, slice(0, 2), slice(0, 2))
+        check_slices(np.zeros((4, 4)), np.arange(2), slice(0, 2), slice(0, 2))
+        check_slices(
+            np.zeros((4, 4)), np.arange(2).reshape(2, 1), slice(0, 2), slice(0, 2)
+        )
+        check_slices(
+            np.zeros((4, 4)), np.arange(4).reshape(2, 2), slice(0, 2), slice(0, 2)
+        )
+
+        with self.assertRaises(ValueError):
+            a = mx.zeros((2, 2, 2))
+            a[..., ...] = 1
+
+        with self.assertRaises(ValueError):
+            a = mx.zeros((2, 2, 2, 2, 2))
+            a[0, ..., 0, ..., 0] = 1
+
+        with self.assertRaises(ValueError):
+            a = mx.zeros((2, 2))
+            a[0, 0, 0] = 1
+
+        with self.assertRaises(ValueError):
+            a = mx.zeros((5, 4, 3))
+            a[:, 0] = mx.ones((5, 1, 3))
+
+        check_slices(np.zeros((2, 2, 2, 2)), 1, None, Ellipsis, None)
+        check_slices(
+            np.zeros((2, 2, 2, 2)), 1, np.array([0, 1]), Ellipsis, np.array([0, 1])
+        )
+        check_slices(
+            np.zeros((2, 2, 2, 2)),
+            np.arange(2 * 2 * 2).reshape(2, 2, 2),
+            np.array([0, 1]),
+            Ellipsis,
+            np.array([0, 1]),
+        )
+
+        # Check slice assign with negative indices works
+        a = mx.zeros((5, 5), mx.int32)
+        a[2:-2, 2:-2] = 4
+        self.assertEqual(a[2, 2].item(), 4)
+
+        # Check slice array slice
+        check_slices(
+            np.zeros((5, 4, 4)),
+            np.arange(4 * 2 * 3).reshape(4, 2, 3),
+            slice(0, 4),
+            np.array([1, 3]),
+            slice(None, -1),
+        )
+        check_slices(
+            np.zeros((5, 4, 4)),
+            np.arange(4 * 2 * 2).reshape(4, 2, 2),
+            slice(0, 4),
+            np.array([1, 3]),
+            slice(0, 4, 2),
+        )
+
+        check_slices(
+            np.zeros((1, 10, 4)),
+            np.arange(2 * 4).reshape(1, 2, 4),
+            slice(None, None, None),
+            np.array([1, 3]),
+        )
+
+        check_slices(
+            np.zeros((3, 4, 5, 3)),
+            np.arange(2 * 4 * 3 * 3).reshape(2, 4, 3, 3),
+            np.array([2, 1]),
+            slice(None, None, None),
+            slice(None, None, 2),
+            slice(None, None, None),
+        )
+
+        check_slices(
+            np.zeros((3, 4, 5, 3)),
+            np.arange(2 * 4 * 3 * 3).reshape(2, 4, 3, 3),
+            np.array([2, 1]),
+            slice(None, None, None),
+            slice(None, None, 2),
+        )
+
+        check_slices(np.zeros((5, 4, 3)), np.ones((5, 3)), slice(None), 0)
+
+        check_slices(np.zeros((5, 4, 3)), np.ones((5, 1, 3)), slice(None), slice(0, 1))
+        check_slices(
+            np.ones((3, 4, 4, 4)), np.zeros((4, 4)), 0, slice(0, 4), 3, slice(0, 4)
+        )
+
+        x = mx.zeros((2, 3, 4, 5, 3))
+        x[..., 0] = 1.0
+        self.assertTrue(mx.array_equal(x[..., 0], mx.ones((2, 3, 4, 5))))
+
+        x = mx.zeros((2, 3, 4, 5, 3))
+        x[:, 0] = 1.0
+        self.assertTrue(mx.array_equal(x[:, 0], mx.ones((2, 4, 5, 3))))
+
+        x = mx.zeros((2, 2, 2, 2, 2, 2))
+        x[0, 0] = 1
+        self.assertTrue(mx.array_equal(x[0, 0], mx.ones((2, 2, 2, 2))))
+
+        a = mx.zeros((2, 2, 2))
+        with self.assertRaises(ValueError):
+            a[:, None, :] = mx.ones((2, 2, 2))
+
+        # Ok, doesn't throw
+        a[:, None, :] = mx.ones((2, 1, 2, 2))
+        a[:, None, :] = mx.ones((2, 2))
+        a[:, None, 0] = mx.ones((2,))
+        a[:, None, 0] = mx.ones((1, 2))
+
+    def test_array_at(self):
+        a = mx.array(1)
+        with self.assertRaises(ValueError):
+            a.at.add(1)
+
+        a = a.at[None].add(1)
+        self.assertEqual(a.item(), 2)
+
+        a = mx.array([0, 1, 2])
+        a = a.at[1].add(2)
+        self.assertEqual(a.tolist(), [0, 3, 2])
+
+        a = a.at[mx.array([0, 0, 0, 0])].add(1)
+        self.assertEqual(a.tolist(), [4, 3, 2])
+
+        a = mx.zeros((10, 10))
+        a = a.at[0].add(mx.arange(10))
+        self.assertEqual(a[0].tolist(), list(range(10)))
+
+        a = mx.zeros((10, 10))
+        index_x = mx.array([0, 2, 3, 7])
+        index_y = mx.array([3, 3, 1, 2])
+        u = mx.random.uniform(shape=(4,))
+        a = a.at[index_x, index_y].add(u)
+        self.assertTrue(mx.allclose(a.sum(), u.sum()))
+        self.assertEqualArray(a.sum(), u.sum(), atol=1e-6, rtol=1e-5)
+        self.assertEqual(a[index_x, index_y].tolist(), u.tolist())
+
+        # Test all array.at ops
+        a = mx.random.uniform(shape=(10, 5, 2))
+        idx_x = mx.array([0, 4])
+        update = mx.ones((2, 5))
+        a[idx_x, :, 0] = 0
+        a = a.at[idx_x, :, 0].add(update)
+        self.assertEqualArray(a[idx_x, :, 0], update)
+        a = a.at[idx_x, :, 0].subtract(update)
+        self.assertEqualArray(a[idx_x, :, 0], mx.zeros_like(update))
+        a = a.at[idx_x, :, 0].add(2 * update)
+        self.assertEqualArray(a[idx_x, :, 0], 2 * update)
+        a = a.at[idx_x, :, 0].multiply(2 * update)
+        self.assertEqualArray(a[idx_x, :, 0], 4 * update)
+        a = a.at[idx_x, :, 0].divide(3 * update)
+        self.assertEqualArray(a[idx_x, :, 0], (4 / 3) * update)
+        a[idx_x, :, 0] = 5
+        update = mx.arange(10).reshape(2, 5)
+        a = a.at[idx_x, :, 0].maximum(update)
+        self.assertEqualArray(a[idx_x, :, 0], mx.maximum(a[idx_x, :, 0], update))
+        a[idx_x, :, 0] = 5
+        a = a.at[idx_x, :, 0].minimum(update)
+        self.assertEqualArray(a[idx_x, :, 0], mx.minimum(a[idx_x, :, 0], update))
+
+        update = mx.array([1.0, 2.0])[None, None, None]
+        src = mx.array([1.0, 2.0])[None, :]
+        src = src.at[0:1].add(update)
+        self.assertTrue(mx.array_equal(src, mx.array([[2.0, 4.0]])))
+
+    def test_slice_negative_step(self):
+        a_np = np.arange(20)
+        a_mx = mx.array(a_np)
+
+        # Basic negative slice
+        b_np = a_np[::-1]
+        b_mx = a_mx[::-1]
+        self.assertTrue(np.array_equal(b_np, b_mx))
+
+        # Bounds negative slice
+        b_np = a_np[-3:3:-1]
+        b_mx = a_mx[-3:3:-1]
+        self.assertTrue(np.array_equal(b_np, b_mx))
+
+        # Bounds negative slice
+        b_np = a_np[25:-50:-1]
+        b_mx = a_mx[25:-50:-1]
+        self.assertTrue(np.array_equal(b_np, b_mx))
+
+        # Jumping negative slice
+        b_np = a_np[::-3]
+        b_mx = a_mx[::-3]
+        self.assertTrue(np.array_equal(b_np, b_mx))
+
+        # Bounds and negative slice
+        b_np = a_np[-3:3:-3]
+        b_mx = a_mx[-3:3:-3]
+        self.assertTrue(np.array_equal(b_np, b_mx))
+
+        # Bounds and negative slice
+        b_np = a_np[25:-50:-3]
+        b_mx = a_mx[25:-50:-3]
+        self.assertTrue(np.array_equal(b_np, b_mx))
+
+        # Negative slice and ascending bounds
+        b_np = a_np[0:20:-3]
+        b_mx = a_mx[0:20:-3]
+        self.assertTrue(np.array_equal(b_np, b_mx))
+
+        # Multi-dim negative slices
+        a_np = np.arange(3 * 6 * 4).reshape(3, 6, 4)
+        a_mx = mx.array(a_np)
+
+        # Flip each dim
+        b_np = a_np[..., ::-1]
+        b_mx = a_mx[..., ::-1]
+        self.assertTrue(np.array_equal(b_np, b_mx))
+
+        b_np = a_np[:, ::-1, :]
+        b_mx = a_mx[:, ::-1, :]
+        self.assertTrue(np.array_equal(b_np, b_mx))
+
+        b_np = a_np[::-1, ...]
+        b_mx = a_mx[::-1, ...]
+        self.assertTrue(np.array_equal(b_np, b_mx))
+
+        # Flip pairs of dims
+        b_np = a_np[::-1, 1:5:2, ::-2]
+        b_mx = a_mx[::-1, 1:5:2, ::-2]
+        self.assertTrue(np.array_equal(b_np, b_mx))
+
+        b_np = a_np[::-1, ::-2, 1:5:2]
+        b_mx = a_mx[::-1, ::-2, 1:5:2]
+        self.assertTrue(np.array_equal(b_np, b_mx))
+
+        # Flip all dims
+        b_np = a_np[::-1, ::-3, ::-2]
+        b_mx = a_mx[::-1, ::-3, ::-2]
+        self.assertTrue(np.array_equal(b_np, b_mx))
+
+    def test_api(self):
+        x = mx.array(np.random.rand(10, 10, 10))
+        ops = [
+            ("reshape", (100, -1)),
+            "square",
+            "sqrt",
+            "rsqrt",
+            "reciprocal",
+            "exp",
+            "log",
+            "sin",
+            "cos",
+            "log1p",
+            "abs",
+            "log10",
+            "log2",
+            "conj",
+            ("all", 1),
+            ("any", 1),
+            ("transpose", (0, 2, 1)),
+            ("sum", 1),
+            ("prod", 1),
+            ("min", 1),
+            ("max", 1),
+            ("logcumsumexp", 1),
+            ("logsumexp", 1),
+            ("mean", 1),
+            ("var", 1),
+            ("argmin", 1),
+            ("argmax", 1),
+            ("cummax", 1),
+            ("cummin", 1),
+            ("cumprod", 1),
+            ("cumsum", 1),
+            ("diagonal", 0, 0, 1),
+            ("flatten", 0, -1),
+            ("moveaxis", 1, 2),
+            ("round", 2),
+            ("std", 1, True, 0),
+            ("swapaxes", 1, 2),
+        ]
+        for op in ops:
+            if isinstance(op, tuple):
+                op, *args = op
+            else:
+                args = tuple()
+            y1 = getattr(mx, op)(x, *args)
+            y2 = getattr(x, op)(*args)
+            self.assertEqual(y1.dtype, y2.dtype)
+            self.assertEqual(y1.shape, y2.shape)
+            self.assertTrue(mx.array_equal(y1, y2))
+
+        y1 = mx.split(x, 2)
+        y2 = x.split(2)
+        self.assertEqual(len(y1), 2)
+        self.assertEqual(len(y1), len(y2))
+        self.assertTrue(mx.array_equal(y1[0], y2[0]))
+        self.assertTrue(mx.array_equal(y1[1], y2[1]))
+        x = mx.array(np.random.rand(10, 10, 1))
+        y1 = mx.squeeze(x, axis=2)
+        y2 = x.squeeze(axis=2)
+        self.assertEqual(y1.shape, y2.shape)
+        self.assertTrue(mx.array_equal(y1, y2))
+
+    def test_memoryless_copy(self):
+        a_mx = mx.ones((2, 2))
+        b_mx = mx.broadcast_to(a_mx, (5, 2, 2))
+
+        # Make np arrays without copy
+        a_np = np.array(a_mx, copy=False)
+        b_np = np.array(b_mx, copy=False)
+
+        # Check that we get read-only array that does not own the underlying data
+        self.assertFalse(a_np.flags.owndata)
+        self.assertTrue(a_np.flags.writeable)
+
+        # Check contents
+        self.assertTrue(np.array_equal(np.ones((2, 2), dtype=np.float32), a_np))
+        self.assertTrue(np.array_equal(np.ones((5, 2, 2), dtype=np.float32), b_np))
+
+        # Check strides
+        self.assertSequenceEqual(b_np.strides, (0, 8, 4))
+
+    def test_np_array_conversion_copies_by_default(self):
+        a_mx = mx.ones((2, 2))
+        a_np = np.array(a_mx)
+        self.assertTrue(a_np.flags.owndata)
+        self.assertTrue(a_np.flags.writeable)
+
+    def test_buffer_protocol(self):
+        dtypes_list = [
+            (mx.bool_, np.bool_, None),
+            (mx.uint8, np.uint8, np.iinfo),
+            (mx.uint16, np.uint16, np.iinfo),
+            (mx.uint32, np.uint32, np.iinfo),
+            (mx.uint64, np.uint64, np.iinfo),
+            (mx.int8, np.int8, np.iinfo),
+            (mx.int16, np.int16, np.iinfo),
+            (mx.int32, np.int32, np.iinfo),
+            (mx.int64, np.int64, np.iinfo),
+            (mx.float16, np.float16, np.finfo),
+            (mx.float32, np.float32, np.finfo),
+            (mx.complex64, np.complex64, np.finfo),
+        ]
+
+        for mlx_dtype, np_dtype, info_fn in dtypes_list:
+            a_np = np.random.uniform(low=0, high=100, size=(3, 4)).astype(np_dtype)
+            if info_fn is not None:
+                info = info_fn(np_dtype)
+                a_np[0, 0] = info.min
+                a_np[0, 1] = info.max
+            a_mx = mx.array(a_np)
+            for f in [lambda x: x, lambda x: x.T]:
+                mv_mx = memoryview(f(a_mx))
+                mv_np = memoryview(f(a_np))
+                self.assertEqual(mv_mx.strides, mv_np.strides, f"{mlx_dtype}{np_dtype}")
+                self.assertEqual(mv_mx.shape, mv_np.shape, f"{mlx_dtype}{np_dtype}")
+                # correct buffer format for 8 byte (unsigned) 'long long' is Q/q, see
+                # https://docs.python.org/3.10/library/struct.html#format-characters
+                # numpy returns L/l, as 'long' is equivalent to 'long long' on 64bit machines, so q and l are equivalent
+                # see https://github.com/pybind/pybind11/issues/1908
+                if np_dtype == np.uint64:
+                    self.assertEqual(mv_mx.format, "Q", f"{mlx_dtype}{np_dtype}")
+                elif np_dtype == np.int64:
+                    self.assertEqual(mv_mx.format, "q", f"{mlx_dtype}{np_dtype}")
+                else:
+                    self.assertEqual(
+                        mv_mx.format, mv_np.format, f"{mlx_dtype}{np_dtype}"
+                    )
+                self.assertFalse(mv_mx.readonly)
+                back_to_npy = np.array(mv_mx, copy=False)
+                self.assertEqualArray(
+                    back_to_npy,
+                    f(a_np),
+                    atol=0,
+                    rtol=0,
+                )
+
+        # extra test for bfloat16, which is not numpy convertible
+        a_mx = mx.random.uniform(low=0, high=100, shape=(3, 4), dtype=mx.bfloat16)
+        mv_mx = memoryview(a_mx)
+        self.assertEqual(mv_mx.strides, (8, 2))
+        self.assertEqual(mv_mx.shape, (3, 4))
+        self.assertEqual(mv_mx.format, "B")
+        with self.assertRaises(RuntimeError) as cm:
+            np.array(a_mx)
+        e = cm.exception
+        self.assertTrue("Item size 2 for PEP 3118 buffer format string" in str(e))
+
+        # Test buffer protocol with non-arrays ie bytes
+        a = ord("a") * 257 + mx.arange(10).astype(mx.int16)
+        ab = bytes(a)
+        self.assertEqual(len(ab), 20)
+        if sys.byteorder == "little":
+            self.assertEqual(b"aaaaaaaaaa", ab[1::2])
+            self.assertEqual(b"abcdefghij", ab[::2])
+        else:
+            self.assertEqual(b"aaaaaaaaaa", ab[::2])
+            self.assertEqual(b"abcdefghij", ab[1::2])
+
+    def test_buffer_protocol_ref_counting(self):
+        a = mx.arange(3)
+        wr = weakref.ref(a)
+        self.assertIsNotNone(wr())
+        mv = memoryview(a)
+        a = None
+        self.assertIsNotNone(wr())
+        mv = None
+        self.assertIsNone(wr())
+
+    def test_array_view_ref_counting(self):
+        a = mx.arange(3)
+        wr = weakref.ref(a)
+        self.assertIsNotNone(wr())
+        a_np = np.array(a, copy=False)
+        a = None
+        self.assertIsNotNone(wr())
+        a_np = None
+        self.assertIsNone(wr())
+
+    @unittest.skipIf(not has_tf, "requires TensorFlow")
+    def test_buffer_protocol_tf(self):
+        dtypes_list = [
+            (
+                mx.bool_,
+                tf.bool,
+                np.bool_,
+            ),
+            (
+                mx.uint8,
+                tf.uint8,
+                np.uint8,
+            ),
+            (
+                mx.uint16,
+                tf.uint16,
+                np.uint16,
+            ),
+            (
+                mx.uint32,
+                tf.uint32,
+                np.uint32,
+            ),
+            (mx.uint64, tf.uint64, np.uint64),
+            (mx.int8, tf.int8, np.int8),
+            (mx.int16, tf.int16, np.int16),
+            (mx.int32, tf.int32, np.int32),
+            (mx.int64, tf.int64, np.int64),
+            (mx.float16, tf.float16, np.float16),
+            (mx.float32, tf.float32, np.float32),
+            (
+                mx.complex64,
+                tf.complex64,
+                np.complex64,
+            ),
+        ]
+
+        for mlx_dtype, tf_dtype, np_dtype in dtypes_list:
+            a_np = np.random.uniform(low=0, high=100, size=(3, 4)).astype(np_dtype)
+            a_tf = tf.constant(a_np, dtype=tf_dtype)
+            a_mx = mx.array(np.array(a_tf))
+            for f in [
+                lambda x: x,
+                lambda x: tf.transpose(x) if isinstance(x, tf.Tensor) else x.T,
+            ]:
+                mv_mx = memoryview(f(a_mx))
+                mv_tf = memoryview(f(a_tf))
+                if (mv_mx.c_contiguous and mv_tf.c_contiguous) or (
+                    mv_mx.f_contiguous and mv_tf.f_contiguous
+                ):
+                    self.assertEqual(
+                        mv_mx.strides, mv_tf.strides, f"{mlx_dtype}{tf_dtype}"
+                    )
+                self.assertEqual(mv_mx.shape, mv_tf.shape, f"{mlx_dtype}{tf_dtype}")
+                self.assertFalse(mv_mx.readonly)
+                back_to_npy = np.array(mv_mx)
+                self.assertEqualArray(
+                    back_to_npy,
+                    f(a_tf),
+                    atol=0,
+                    rtol=0,
+                )
+
+    def test_logical_overloads(self):
+        with self.assertRaises(ValueError):
+            mx.array(1.0) & mx.array(1)
+        with self.assertRaises(ValueError):
+            mx.array(1.0) | mx.array(1)
+
+        self.assertEqual((mx.array(True) & True).item(), True)
+        self.assertEqual((mx.array(True) & False).item(), False)
+        self.assertEqual((mx.array(True) | False).item(), True)
+        self.assertEqual((mx.array(False) | False).item(), False)
+        self.assertEqual((~mx.array(False)).item(), True)
+        self.assertEqual((mx.array(False) ^ True).item(), True)
+
+    def test_inplace(self):
+        iops = [
+            "__iadd__",
+            "__isub__",
+            "__imul__",
+            "__ifloordiv__",
+            "__imod__",
+            "__ipow__",
+            "__ixor__",
+        ]
+
+        for op in iops:
+            a = mx.array([1, 2, 3])
+            a_np = np.array(a)
+            b = a
+            b = getattr(a, op)(3)
+            self.assertTrue(mx.array_equal(a, b))
+            out_np = getattr(a_np, op)(3)
+            self.assertTrue(np.array_equal(out_np, a))
+
+        with self.assertRaises(ValueError):
+            a = mx.array([1])
+            a /= 1
+
+        a = mx.array([2.0])
+        b = a
+        b /= 2
+        self.assertEqual(b.item(), 1.0)
+        self.assertEqual(b.item(), a.item())
+
+        a = mx.array(True)
+        b = a
+        b &= False
+        self.assertEqual(b.item(), False)
+        self.assertEqual(b.item(), a.item())
+
+        a = mx.array(False)
+        b = a
+        b |= True
+        self.assertEqual(b.item(), True)
+        self.assertEqual(b.item(), a.item())
+
+        # In-place matmul on its own
+        a = mx.array([[1.0, 2.0], [3.0, 4.0]])
+        b = a
+        b @= a
+        self.assertTrue(mx.array_equal(a, b))
+
+        a = mx.array(False)
+        a ^= True
+        self.assertEqual(a.item(), True)
+
+    def test_inplace_preserves_ids(self):
+        a = mx.array([1.0])
+        orig_id = id(a)
+        a += mx.array(2.0)
+        self.assertEqual(id(a), orig_id)
+
+        a[0] = 2.0
+        self.assertEqual(id(a), orig_id)
+
+        a -= mx.array(3.0)
+        self.assertEqual(id(a), orig_id)
+
+        a *= mx.array(3.0)
+        self.assertEqual(id(a), orig_id)
+
+    def test_load_from_pickled_np(self):
+        a = np.array([1, 2, 3], dtype=np.int32)
+        b = pickle.loads(pickle.dumps(a))
+        self.assertTrue(mx.array_equal(mx.array(a), mx.array(b)))
+
+        a = np.array([1.0, 2.0, 3.0], dtype=np.float16)
+        b = pickle.loads(pickle.dumps(a))
+        self.assertTrue(mx.array_equal(mx.array(a), mx.array(b)))
+
+    def test_multi_output_leak(self):
+        def fun():
+            a = mx.zeros((2**20))
+            mx.eval(a)
+            b, c = mx.divmod(a, a)
+            del b, c
+
+        fun()
+        mx.synchronize()
+        peak_1 = mx.get_peak_memory()
+        fun()
+        mx.synchronize()
+        peak_2 = mx.get_peak_memory()
+        self.assertEqual(peak_1, peak_2)
+
+        def fun():
+            a = mx.array([1.0, 2.0, 3.0, 4.0])
+            b, _ = mx.divmod(a, a)
+            return mx.log(b)
+
+        fun()
+        mx.synchronize()
+        peak_1 = mx.get_peak_memory()
+        fun()
+        mx.synchronize()
+        peak_2 = mx.get_peak_memory()
+        self.assertEqual(peak_1, peak_2)
+
+    def test_add_numpy(self):
+        x = mx.array(1)
+        y = np.array(2, dtype=np.int32)
+        z = x + y
+        self.assertEqual(z.dtype, mx.int32)
+        self.assertEqual(z.item(), 3)
+
+    def test_dlpack(self):
+        x = mx.array(1, dtype=mx.int32)
+        y = np.from_dlpack(x)
+        self.assertTrue(mx.array_equal(y, x))
+
+        x = mx.array([[1.0, 2.0], [3.0, 4.0]])
+        y = np.from_dlpack(x)
+        self.assertTrue(mx.array_equal(y, x))
+
+        x = mx.arange(16).reshape(4, 4)
+        x = x[::2, ::2]
+        y = np.from_dlpack(x)
+        self.assertTrue(mx.array_equal(y, x))
+
+    def test_getitem_with_list(self):
+        a = mx.array([1, 2, 3, 4, 5])
+        idx = [0, 2, 4]
+        self.assertTrue(np.array_equal(a[idx], np.array(a)[idx]))
+
+        a = mx.array([[1, 2], [3, 4], [5, 6]])
+        idx = [0, 2]
+        self.assertTrue(np.array_equal(a[idx], np.array(a)[idx]))
+
+        a = mx.arange(10).reshape(5, 2)
+        idx = [0, 2, 4]
+        self.assertTrue(np.array_equal(a[idx], np.array(a)[idx]))
+
+        idx = [0, 2]
+        a = mx.arange(16).reshape(4, 4)
+        anp = np.array(a)
+        self.assertTrue(np.array_equal(a[idx, 0], anp[idx, 0]))
+        self.assertTrue(np.array_equal(a[idx, :], anp[idx, :]))
+        self.assertTrue(np.array_equal(a[0, idx], anp[0, idx]))
+        self.assertTrue(np.array_equal(a[:, idx], anp[:, idx]))
+
+    def test_setitem_with_list(self):
+        a = mx.array([1, 2, 3, 4, 5])
+        anp = np.array(a)
+        idx = [0, 2, 4]
+        a[idx] = 3
+        anp[idx] = 3
+        self.assertTrue(np.array_equal(a, anp))
+
+        a = mx.array([[1, 2], [3, 4], [5, 6]])
+        idx = [0, 2]
+        anp = np.array(a)
+        a[idx] = 3
+        anp[idx] = 3
+        self.assertTrue(np.array_equal(a, anp))
+
+        a = mx.arange(10).reshape(5, 2)
+        idx = [0, 2, 4]
+        anp = np.array(a)
+        a[idx] = 3
+        anp[idx] = 3
+        self.assertTrue(np.array_equal(a, anp))
+
+        idx = [0, 2]
+        a = mx.arange(16).reshape(4, 4)
+        anp = np.array(a)
+        a[idx, 0] = 1
+        anp[idx, 0] = 1
+        self.assertTrue(np.array_equal(a, anp))
+
+        a[idx, :] = 2
+        anp[idx, :] = 2
+        self.assertTrue(np.array_equal(a, anp))
+
+        a[0, idx] = 3
+        anp[0, idx] = 3
+        self.assertTrue(np.array_equal(a, anp))
+
+        a[:, idx] = 4
+        anp[:, idx] = 4
+        self.assertTrue(np.array_equal(a, anp))
+
+    def test_array_namespace(self):
+        a = mx.array(1.0)
+        api = a.__array_namespace__()
+        self.assertTrue(hasattr(api, "array"))
+        self.assertTrue(hasattr(api, "add"))
+
+    def test_to_scalar(self):
+        a = mx.array(1)
+        self.assertEqual(int(a), 1)
+        self.assertEqual(float(a), 1)
+
+        a = mx.array(1.5)
+        self.assertEqual(float(a), 1.5)
+        self.assertEqual(int(a), 1)
+
+        a = mx.zeros((2, 1))
+        with self.assertRaises(ValueError):
+            float(a)
+        with self.assertRaises(ValueError):
+            int(a)
+
+    def test_format(self):
+        a = mx.arange(3)
+        self.assertEqual(f"{a[0]:.2f}", "0.00")
+
+        b = mx.array(0.35487)
+        self.assertEqual(f"{b:.1f}", "0.4")
+
+        with self.assertRaises(TypeError):
+            s = f"{a:.2f}"
+
+        a = mx.array([1, 2, 3])
+        self.assertEqual(f"{a}", "array([1, 2, 3], dtype=int32)")
+
+    def test_deep_graphs(self):
+        # The following tests should simply run cleanly without a segfault or
+        # crash due to exceeding recursion depth limits.
+
+        # Deep graph destroyed without eval
+        x = mx.array([1.0, 2.0])
+        for _ in range(100_000):
+            x = mx.sin(x)
+        del x
+
+        # Duplicate input deep graph destroyed without eval
+        x = mx.array([1.0, 2.0])
+        for _ in range(100_000):
+            x = x + x
+
+        # Deep graph with siblings destroyed without eval
+        x = mx.array([1, 2])
+        for _ in range(100_000):
+            x = mx.concatenate(mx.split(x, 2))
+        del x
+
+        # Deep graph with eval
+        x = mx.array([1.0, 2.0])
+        for _ in range(100_000):
+            x = mx.sin(x)
+        mx.eval(x)
+
+    def test_siblings_without_eval(self):
+        def get_mem():
+            if platform.system() == "Windows":
+                process = psutil.Process(os.getpid())
+                return process.memory_info().peak_wset
+            else:
+                return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+
+        key = mx.array([1, 2])
+
+        def t():
+            a, b = mx.split(key, 2)
+            a = mx.reshape(a, [])
+            b = mx.reshape(b, [])
+            return b
+
+        mx.synchronize()
+        t()
+        gc.collect()
+        expected = get_mem()
+        for _ in range(100):
+            t()
+        used = get_mem()
+        self.assertEqual(expected, used)
+
+    def test_scalar_integer_conversion_overflow(self):
+        y = mx.array(2000000000, dtype=mx.int32)
+        x = 3000000000
+        with self.assertRaises(ValueError):
+            y + x
+        with self.assertRaises(ValueError):
+            mx.add(y, x)
+
+    def test_real_imag(self):
+        x = mx.array([1.0])
+        self.assertEqual(x.real.item(), 1.0)
+        self.assertEqual(x.imag.item(), 0.0)
+
+        x = mx.array([1.0 + 1.0j])
+        self.assertEqual(x.imag.item(), 1.0)
+        self.assertEqual(x.real.item(), 1.0)
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_autograd.py b/ml-stable-diffusion/mlx/python/tests/test_autograd.py
new file mode 100644
index 0000000000000000000000000000000000000000..38bb6089d3679a0a69c708e28cf258f23069ed2e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_autograd.py
@@ -0,0 +1,803 @@
+# Copyright © 2023 Apple Inc.
+
+import gc
+import unittest
+
+import mlx.core as mx
+import mlx_tests
+
+
+class TestAutograd(mlx_tests.MLXTestCase):
+    def test_jvp(self):
+        fun = lambda x: 2 * x
+        out, dout = mx.jvp(fun, [mx.array(1.0)], [mx.array(2.0)])
+        self.assertEqual(out[0].item(), 2.0)
+        self.assertEqual(dout[0].item(), 4.0)
+
+        fun = lambda x, y: x * y
+        _, out = mx.jvp(
+            fun, [mx.array(4.0), mx.array(2.0)], [mx.array(3.0), mx.array(2.0)]
+        )
+        self.assertEqual(out[0].item(), 4.0 * 2.0 + 2.0 * 3.0)
+
+        fun = lambda x, y, z: (x * y, y * z)
+        _, out = mx.jvp(
+            fun,
+            [mx.array(2.0), mx.array(4.0), mx.array(6.0)],
+            [mx.array(1.0), mx.array(3.0), mx.array(1.0)],
+        )
+        self.assertEqual(len(out), 2)
+        self.assertEqual(out[0].item(), 4.0 * 1.0 + 2.0 * 3.0)
+        self.assertEqual(out[1].item(), 4.0 * 1.0 + 6.0 * 3.0)
+
+    def test_vjp(self):
+        fun = lambda x: 2 * x
+        out, dout = mx.vjp(fun, [mx.array(1.0)], [mx.array(2.0)])
+        self.assertEqual(out[0].item(), 2.0)
+        self.assertEqual(dout[0].item(), 4.0)
+
+        fun = lambda x, y: x * y
+        _, dout = mx.vjp(fun, [mx.array(4.0), mx.array(2.0)], [mx.array(3.0)])
+        self.assertEqual(dout[0].item(), 6.0)
+        self.assertEqual(dout[1].item(), 12.0)
+
+        fun = lambda x, y, z: (x * y, y * z)
+        _, out = mx.vjp(
+            fun,
+            [mx.array(2.0), mx.array(4.0), mx.array(6.0)],
+            [mx.array(1.0), mx.array(3.0)],
+        )
+        self.assertEqual(len(out), 3)
+        self.assertEqual(out[0].item(), 4.0 * 1.0)
+        self.assertEqual(out[1].item(), 2.0 * 1.0 + 6.0 * 3.0)
+        self.assertEqual(out[2].item(), 4.0 * 3.0)
+
+    def test_grad(self):
+        fun = lambda x: x * x
+
+        value, dfdx = mx.value_and_grad(fun)(mx.array(0.5))
+        self.assertEqual(value.item(), 0.25)
+        self.assertEqual(dfdx.item(), 1.0)
+
+        dfdx = mx.grad(fun)(mx.array(0.5))
+        self.assertEqual(dfdx.item(), 1.0)
+
+        df2dx2 = mx.grad(mx.grad(fun))(mx.array(0.5))
+        self.assertEqual(df2dx2.item(), 2.0)
+        df3dx3 = mx.grad(mx.grad(mx.grad(fun)))(mx.array(0.5))
+        self.assertEqual(df3dx3.item(), 0.0)
+
+        fun = lambda x, y: x * y
+        x = mx.array(2.0)
+        y = mx.array(3.0)
+        dfdx = mx.grad(fun, argnums=0)(x, y)
+        self.assertEqual(dfdx.item(), 3.0)
+        dfdx = mx.grad(fun, argnums=1)(x, y)
+        self.assertEqual(dfdx.item(), 2.0)
+
+        # Pass non array args to functions works
+        fun = lambda x, y: x
+        value, dfdx = mx.value_and_grad(fun)(mx.array(2.0), "hello")
+        self.assertEqual(value.item(), 2.0)
+        self.assertEqual(dfdx.item(), 1.0)
+
+        dfdx = mx.grad(fun)(mx.array(2.0), "hello")
+        self.assertEqual(dfdx.item(), 1.0)
+
+        # Raises when function does not return array
+        fun = lambda x: "hello"
+        with self.assertRaises(ValueError):
+            mx.grad(fun)(mx.array(2.0))
+
+        # Raises for invalid argument number or argument type
+        fun = lambda x: x
+        with self.assertRaises(ValueError):
+            mx.grad(fun, argnums=2)(mx.array(2.0))
+        with self.assertRaises(ValueError):
+            mx.grad(fun, argnums=-2)(mx.array(2.0))
+        with self.assertRaises(ValueError):
+            mx.grad(fun)("hello")
+
+        # Raises when output is not a scalar array
+        fun = lambda x: mx.sum(x, keepdims=True)
+        with self.assertRaises(ValueError):
+            mx.grad(fun)(mx.ones((2, 2)))
+
+    def test_grad_trees(self):
+        fun = lambda x, y: x * y
+        value, dfdx = mx.value_and_grad(fun, (0, 1))(mx.array(0.5), mx.array(2.0))
+        self.assertEqual(value.item(), 1.0)
+        self.assertTrue(isinstance(dfdx, tuple))
+        self.assertEqual(dfdx[0].item(), 2.0)
+        self.assertEqual(dfdx[1].item(), 0.5)
+
+        fun = lambda x, y: x * y
+        value, dfdx = mx.value_and_grad(fun, 1)(mx.array(0.5), mx.array(2.0))
+        self.assertEqual(value.item(), 1.0)
+        self.assertEqual(dfdx.item(), 0.5)
+
+        fun = lambda p: p["x"] * p["y"]
+        value, dfdx = mx.value_and_grad(fun)({"x": mx.array(0.5), "y": mx.array(2.0)})
+        self.assertEqual(value.item(), 1.0)
+        self.assertEqual(dfdx["x"].item(), 2.0)
+        self.assertEqual(dfdx["y"].item(), 0.5)
+
+        fun = lambda p: p["x"] * p["y"]
+        with self.assertRaises(ValueError):
+            mx.value_and_grad(fun)({"x": 0.5, "y": mx.array(2.0)})
+        with self.assertRaises(ValueError):
+            mx.value_and_grad(fun, (0, 1))({"x": mx.array(0.5), "y": mx.array(2.0)})
+
+        fun = lambda p, b: mx.square(p[0]["foo"][2]) * b
+        value, dfdx = mx.value_and_grad(fun)(
+            [{"foo": [[], [], mx.array(2.0)]}], mx.array(0.5)
+        )
+        self.assertEqual(value.item(), 2.0)
+        self.assertEqual(dfdx[0]["foo"][2].item(), 2.0)
+
+        fun = lambda x: x
+        with self.assertRaises(TypeError):
+            mx.value_and_grad(fun, (None, None))
+        with self.assertRaises(ValueError):
+            mx.value_and_grad(fun, tuple())
+        with self.assertRaises(ValueError):
+            mx.grad(fun, argnums=(0, 0))
+
+    def test_auxiliary_values(self):
+        def fun(x, y):
+            l = (x * y).sum()
+            extra = {"loss": l, "foo": y.square() + x.square(), "bar": [1, 2, 3, y, x]}
+            return l, extra
+
+        fun_value_grad = mx.value_and_grad(fun)
+        fun_grad = mx.grad(fun)
+
+        (loss, a), b = fun_value_grad(mx.ones((2, 2)), mx.ones((2, 2)))
+        self.assertEqual(a["loss"].item(), 4)
+        self.assertTrue(mx.array_equal(b, mx.ones((2, 2))))
+        self.assertTrue(mx.array_equal(a["foo"], 2 * mx.ones((2, 2))))
+        self.assertEqual(a["bar"][:3], [1, 2, 3])
+        self.assertTrue(mx.array_equal(a["bar"][3], mx.ones((2, 2))))
+        self.assertTrue(mx.array_equal(a["bar"][4], mx.ones((2, 2))))
+
+        with self.assertRaises(ValueError):
+            _ = fun_grad(mx.ones((2, 2)), mx.ones((2, 2)))
+
+    def test_grad_kwargs(self):
+        fun = lambda x, y: x * y
+        a, b = mx.array(0.5), mx.array(2.0)
+        dfdx = mx.grad(fun)
+        self.assertEqual(dfdx(a, b).item(), 2.0)
+        self.assertEqual(dfdx(a, y=b).item(), 2.0)
+        with self.assertRaises(ValueError):
+            dfdx(x=a, y=b).item()
+
+        dfdy = mx.grad(fun, argnums=[], argnames=["y"])
+        with self.assertRaises(ValueError):
+            dfdy(a, b)
+        grads = dfdy(a, y=b)
+        self.assertTrue(isinstance(grads, tuple))
+        self.assertTrue(grads[0] is None)
+        self.assertTrue(isinstance(grads[1], dict))
+        self.assertEqual(grads[1]["y"].item(), 0.5)
+        grads = dfdy(x=a, y=b)
+        self.assertEqual(grads[1]["y"].item(), 0.5)
+        self.assertEqual(len(grads[1]), 1)
+
+        dfdxy = mx.grad(fun, argnums=[0], argnames=["y"])
+        with self.assertRaises(ValueError):
+            dfdxy(a, b)
+        with self.assertRaises(ValueError):
+            dfdxy(x=a, y=b)
+        grads = dfdxy(a, y=b)
+        self.assertTrue(isinstance(grads, tuple))
+        self.assertEqual(grads[0].item(), 2.0)
+        self.assertTrue(isinstance(grads[1], dict))
+        self.assertEqual(grads[1]["y"].item(), 0.5)
+
+        fun = lambda x, y, z: x * y * z
+        dfdxyz = mx.grad(fun, argnums=[0, 1], argnames=["z"])
+        c = mx.array(4.0)
+        grads = dfdxyz(a, b, z=c)
+        self.assertTrue(isinstance(grads, tuple))
+        self.assertTrue(isinstance(grads[0], tuple))
+        self.assertEqual(grads[0][0].item(), 8.0)
+        self.assertEqual(grads[0][1].item(), 2.0)
+        self.assertTrue(isinstance(grads[1], dict))
+        self.assertEqual(grads[1]["z"].item(), 1.0)
+
+        fun = lambda x, y: x * y
+        dfdy = mx.grad(fun, argnames=["y"])
+        grads = dfdy(a, y=b)
+        self.assertTrue(isinstance(grads, tuple))
+        self.assertTrue(grads[0] is None)
+        self.assertTrue(isinstance(grads[1], dict))
+        self.assertEqual(grads[1]["y"].item(), 0.5)
+
+    def test_captured(self):
+        a = mx.array(5.0)
+        f = lambda x: a + x
+        g = lambda x: a + a
+        h = lambda x: x + x
+
+        dfdx = mx.grad(f)
+        self.assertEqual(dfdx(a).item(), 1.0)
+
+        dgdx = mx.grad(g)
+        self.assertEqual(dgdx(a).item(), 0.0)
+
+        dhdx = mx.grad(h)
+        self.assertEqual(dhdx(a).item(), 2.0)
+
+        d2fdx2 = mx.grad(dfdx)
+        self.assertEqual(d2fdx2(a).item(), 0.0)
+
+        d2gdx2 = mx.grad(dgdx)
+        self.assertEqual(d2gdx2(a).item(), 0.0)
+
+        d2hdx2 = mx.grad(dhdx)
+        self.assertEqual(d2hdx2(a).item(), 0.0)
+
+    def test_stop_gradient(self):
+        shape_in = (4, 4)
+        w_in = mx.ones(shape_in)
+        x_in = mx.ones(shape_in)
+        cotan = mx.ones(shape_in)
+
+        def h(w, x):
+            x1 = 2 * x
+            y = mx.stop_gradient(x1)
+            y1 = 3 * y
+            return w @ y1
+
+        vals, vjps = mx.vjp(h, [w_in, x_in], [cotan])
+        mx.eval(vjps)
+
+        self.assertTrue(mx.allclose(vjps[0], 24.0 * mx.ones(shape_in)))
+        self.assertTrue(mx.allclose(vjps[1], mx.zeros(shape_in)))
+
+        g = lambda x: h(w_in, x)
+        vals, vjps = mx.vjp(g, [x_in], [cotan])
+        mx.eval(vjps)
+
+        self.assertTrue(mx.allclose(vjps[0], mx.zeros(shape_in)))
+
+    def test_update_state(self):
+        y = mx.array([1.0])
+        state = mx.zeros((2,))
+
+        def fn(y, x):
+            nonlocal state
+            x = y * x
+            state = state + x
+            return x.sum()
+
+        x = mx.ones((2,))
+        mx.grad(fn)(y, x)
+        mx.eval(state)
+        self.assertTrue(mx.allclose(state, mx.ones((2,))))
+
+    def test_scatter_vjp(self):
+        def fun(x, idx):
+            x[idx] = 2.0
+            return x.sum()
+
+        dfdx = mx.grad(fun)(mx.array([1.0, 2.0, 3.0]), mx.array([1]))
+        self.assertTrue(mx.array_equal(dfdx, mx.array([1.0, 0.0, 1.0])))
+        self.assertEqual(dfdx.dtype, mx.float32)
+
+        y = mx.array([0.0, 1.0, 2.0])
+
+        def fun(x, idx):
+            y[idx] = x
+            return y.sum()
+
+        dfdx = mx.grad(fun)(mx.array([2.0]), mx.array([1]))
+        self.assertTrue(mx.array_equal(dfdx, mx.array([1.0])))
+        self.assertEqual(dfdx.dtype, mx.float32)
+
+    def test_scatter_max_vjp(self):
+        def fun(src, updates):
+            x = src.at[1].maximum(updates)
+            return x
+
+        cotan = mx.array([4.0, 5.0, 6.0])
+        _, vjps = mx.vjp(fun, [mx.array([1.0, 2.0, 3.0]), mx.array([[3.0]])], [cotan])
+        mx.eval(vjps)
+
+        # Update larger than value
+        self.assertTrue(mx.allclose(vjps[0], mx.array([4.0, 0.0, 6.0])))
+        self.assertTrue(mx.allclose(vjps[1], mx.array([5.0])))
+
+        cotan = mx.array([[4.0], [5.0], [6.0]])
+        _, vjps = mx.vjp(
+            fun, [mx.array([[1.0], [2.0], [3.0]]), mx.array([[[2.0]]])], [cotan]
+        )
+        mx.eval(vjps)
+
+        # Update and value are equal
+        self.assertTrue(mx.allclose(vjps[0], mx.array([[4.0], [5.0], [6.0]])))
+        self.assertTrue(mx.allclose(vjps[1], mx.array([[[5.0]]])))
+
+    def test_scatter_min_vjp(self):
+        def fun(src, updates):
+            x = src.at[1].minimum(updates)
+            return x
+
+        cotan = mx.array([4.0, 5.0, 6.0])
+        _, vjps = mx.vjp(fun, [mx.array([1.0, 2.0, 3.0]), mx.array([[3.0]])], [cotan])
+        mx.eval(vjps)
+
+        # Update larger than value
+        self.assertTrue(mx.allclose(vjps[0], mx.array([4.0, 5.0, 6.0])))
+        self.assertTrue(mx.allclose(vjps[1], mx.array([0.0])))
+
+        cotan = mx.array([[4.0], [5.0], [6.0]])
+        _, vjps = mx.vjp(
+            fun, [mx.array([[1.0], [2.0], [3.0]]), mx.array([[[2.0]]])], [cotan]
+        )
+        mx.eval(vjps)
+
+        # Update and value are equal
+        self.assertTrue(mx.allclose(vjps[0], mx.array([[4.0], [5.0], [6.0]])))
+        self.assertTrue(mx.allclose(vjps[1], mx.array([[[5.0]]])))
+
+    def test_split_against_slice(self):
+        def f_split(x):
+            a, _, b = x.split(3, -1)
+            return (a * b).sum()
+
+        def f_slice(x):
+            step = x.shape[-1] // 3
+            a = x[..., :step]
+            b = x[..., -step:]
+            return (a * b).sum()
+
+        x = mx.random.uniform(shape=(100, 300))
+        mx.eval(x)
+
+        df1 = mx.grad(f_split)
+        df2 = mx.grad(f_slice)
+
+        self.assertTrue(mx.allclose(df1(x), df2(x)))
+
+    def test_vjp_types(self):
+        def fun(x):
+            return x
+
+        for t in [mx.float16, mx.bfloat16, mx.float32]:
+            out = mx.grad(fun)(mx.array(1.0, t))
+            self.assertEqual(out.dtype, t)
+
+        def fun(x):
+            return x.sum()
+
+        for t in [mx.float16, mx.bfloat16, mx.float32]:
+            out = mx.grad(fun)(mx.array(1.0, t))
+            self.assertEqual(out.dtype, t)
+
+        def fun(x, y):
+            return (x + y).sum()
+
+        for t in [mx.float16, mx.bfloat16, mx.float32]:
+            out = mx.grad(fun)(mx.array(1.0, t), mx.array(1.0, t))
+            self.assertEqual(out.dtype, t)
+
+    def test_power_grad(self):
+        x = mx.array(0.0)
+        g = mx.grad(lambda x: x**2)(x)
+        self.assertEqual(g.item(), 0.0)
+
+        x = mx.array(0.0)
+        g = mx.grad(lambda x: x**1.5)(x)
+        self.assertEqual(g.item(), 0.0)
+
+        x = mx.array(2.0)
+        g = mx.grad(lambda x: x**2)(x)
+        self.assertAlmostEqual(g.item(), 4.0)
+
+    def test_eval_in_grad(self):
+        arr = mx.array([1.0])
+        cotan = mx.array([1.0, 1.0])
+        y = mx.array([2.0, 2.0])
+
+        def func(x):
+            x = x + y
+            cond = x < 1
+            cond.tolist()
+            return x**2
+
+        _, vjps = mx.vjp(func, (arr,), (cotan,))
+        self.assertEqual(vjps[0].item(), 12.0)
+
+        def func(x):
+            x = x + mx.array([1.0, 1.0])
+            mx.eval(x)
+            return x**2
+
+        _, vjps = mx.vjp(func, (arr,), (cotan,))
+        self.assertEqual(vjps[0].item(), 8.0)
+
+    def test_power_grad(self):
+        def fun(x, y):
+            res = x - y
+            return res**x
+
+        grad = mx.grad(fun)(mx.array(1.0), mx.array(1.0))
+        self.assertEqual(grad.item(), 1.0)
+
+    def test_cumprod_grad(self):
+        def fun(y):
+            return mx.cumprod(y).sum()
+
+        y = mx.array([2.0, 1.0, 2.0, 2.0, 3.0])
+        out = mx.grad(fun)(y)
+        expected = mx.array([20.0, 38.0, 18.0, 16.0, 8.0])
+        self.assertTrue(mx.allclose(out, expected))
+
+        y = mx.array([2.0, 0.0, 2.0, 2.0, 3.0])
+        out = mx.grad(fun)(y)
+        expected = mx.array([1.0, 38.0, 0.0, 0.0, 0.0])
+        self.assertTrue(mx.allclose(out, expected))
+
+        y = mx.array([2.0, 0.0, 2.0, 0.0, 3.0])
+        out = mx.grad(fun)(y)
+        expected = mx.array([1.0, 6.0, 0.0, 0.0, 0.0])
+        self.assertTrue(mx.allclose(out, expected))
+
+        def fun(y):
+            return mx.cumprod(y, inclusive=False).sum()
+
+        y = mx.array([2.0, 1.0, 2.0, 2.0, 3.0])
+        out = mx.grad(fun)(y)
+        expected = mx.array([8.0, 14.0, 6.0, 4.0, 0.0])
+        self.assertTrue(mx.allclose(out, expected))
+
+        y = mx.array([2.0, 0.0, 2.0, 2.0, 3.0])
+        out = mx.grad(fun)(y)
+        expected = mx.array([1.0, 14.0, 0.0, 0.0, 0.0])
+        self.assertTrue(mx.allclose(out, expected))
+
+        y = mx.array([2.0, 0.0, 2.0, 0.0, 3.0])
+        out = mx.grad(fun)(y)
+        expected = mx.array([1.0, 6.0, 0.0, 0.0, 0.0])
+        self.assertTrue(mx.allclose(out, expected))
+
+        def fun(y):
+            return mx.cumprod(y, inclusive=False, reverse=True).sum()
+
+        y = mx.array([2.0, 1.0, 2.0, 2.0, 3.0])
+        out = mx.grad(fun)(y)
+        expected = mx.array([0.0, 12.0, 12.0, 15.0, 11.0])
+        self.assertTrue(mx.allclose(out, expected))
+
+        y = mx.array([2.0, 0.0, 2.0, 2.0, 3.0])
+        out = mx.grad(fun)(y)
+        expected = mx.array([0.0, 12.0, 6.0, 9.0, 7.0])
+        self.assertTrue(mx.allclose(out, expected))
+
+        y = mx.array([2.0, 0.0, 2.0, 0.0, 3.0])
+        out = mx.grad(fun)(y)
+        expected = mx.array([0.0, 0.0, 0.0, 9.0, 1.0])
+        self.assertTrue(mx.allclose(out, expected))
+
+        def fun(y):
+            return mx.cumprod(y, reverse=True).sum()
+
+        y = mx.array([2.0, 1.0, 2.0, 2.0, 3.0])
+        out = mx.grad(fun)(y)
+        expected = mx.array([12.0, 36.0, 24.0, 27.0, 19.0])
+        self.assertTrue(mx.allclose(out, expected))
+
+        y = mx.array([2.0, 0.0, 2.0, 2.0, 3.0])
+        out = mx.grad(fun)(y)
+        expected = mx.array([0.0, 36.0, 6.0, 9.0, 7.0])
+        self.assertTrue(mx.allclose(out, expected))
+
+        y = mx.array([2.0, 0.0, 2.0, 0.0, 3.0])
+        out = mx.grad(fun)(y)
+        expected = mx.array([0.0, 0.0, 0.0, 9.0, 1.0])
+        self.assertTrue(mx.allclose(out, expected))
+
+    def test_topk_grad(self):
+        a = mx.array([[1, 2, 6, 4, 5], [9, 5, 6, 7, 8]], mx.float32)
+
+        def fun(x):
+            return mx.topk(x, 2)
+
+        out = mx.vjp(fun, (a,), (mx.ones((2, 2)),))[1][0]
+        expected = mx.array([[0, 0, 1, 0, 1], [1, 0, 0, 0, 1]], mx.float32)
+        self.assertTrue(mx.array_equal(out, expected))
+
+    def test_custom_function(self):
+        # Make a custom function
+        my_exp = mx.custom_function(mx.exp)
+
+        # Ensure everything works
+        dy = mx.grad(my_exp)(mx.array(1.0))
+        self.assertTrue(mx.allclose(dy, mx.exp(mx.array(1.0))))
+        (ex,), (dex,) = mx.jvp(my_exp, [mx.array(1.0)], [mx.array(1.0)])
+        self.assertTrue(mx.allclose(dex, mx.exp(mx.array(1.0))))
+        self.assertTrue(mx.allclose(ex, dex))
+        ex = mx.vmap(my_exp)(mx.ones(10))
+        self.assertTrue(mx.allclose(ex, mx.exp(mx.ones(10))))
+
+        # Ensure that the vjp is being overriden but everything else still
+        # works.
+        @my_exp.vjp
+        def my_exp_vjp(x, dx, ex):
+            return mx.ones_like(x) * 42
+
+        dy = mx.grad(my_exp)(mx.array(1.0))
+        self.assertTrue(mx.allclose(dy, mx.array(42.0)))
+        (ex,), (dex,) = mx.jvp(my_exp, [mx.array(1.0)], [mx.array(1.0)])
+        self.assertTrue(mx.allclose(dex, mx.exp(mx.array(1.0))))
+        self.assertTrue(mx.allclose(ex, dex))
+        ex = mx.vmap(my_exp)(mx.ones(10))
+        self.assertTrue(mx.allclose(ex, mx.exp(mx.ones(10))))
+
+        # Ensure that setting the jvp and vmap also works.
+        @my_exp.jvp
+        def my_exp_jvp(x, dx):
+            return mx.ones_like(x) * 7 * dx
+
+        @my_exp.vmap
+        def my_exp_vmap(x, axis):
+            return mx.ones_like(x) * 3, axis
+
+        dy = mx.grad(my_exp)(mx.array(1.0))
+        self.assertTrue(mx.allclose(dy, mx.array(42.0)))
+        (ex,), (dex,) = mx.jvp(my_exp, [mx.array(1.0)], [mx.array(1.0)])
+        self.assertTrue(mx.allclose(dex, mx.array(7.0)))
+        self.assertTrue(mx.allclose(ex, mx.exp(mx.array(1.0))))
+        ex = mx.vmap(my_exp)(mx.ones(10))
+        self.assertTrue(mx.allclose(ex, 3 * mx.ones(10)))
+
+        # Test pytrees
+        @mx.custom_function
+        def my_double(params):
+            return {"out": 2 * params["x"] * params["y"]}
+
+        dy = mx.grad(lambda p: my_double(p)["out"].sum())(
+            {"x": mx.ones(2), "y": mx.ones(2)}
+        )
+        self.assertTrue(mx.allclose(dy["x"], mx.ones(2) * 2))
+        self.assertTrue(mx.allclose(dy["y"], mx.ones(2) * 2))
+
+        @my_double.vjp
+        def random_grads(primals, cotangents, outputs):
+            return {"x": mx.zeros_like(primals["x"]), "y": mx.ones_like(primals["y"])}
+
+        dy = mx.grad(lambda p: my_double(p)["out"].sum())(
+            {"x": mx.ones(2), "y": mx.ones(2)}
+        )
+        self.assertTrue(mx.allclose(dy["x"], mx.zeros(2)))
+        self.assertTrue(mx.allclose(dy["y"], mx.ones(2)))
+
+        def outer_f(a, b):
+            return my_double({"x": a, "y": b})["out"]
+
+        inputs = [mx.random.normal(shape=(2,)) for i in range(2)]
+        tans = [mx.random.normal(shape=(2,)) for i in range(2)]
+        out1, dout1 = mx.jvp(outer_f, inputs, tans)
+
+        @my_double.jvp
+        def random_grads(primals, tangents):
+            return {
+                "out": 2 * primals["x"] * tangents["y"]
+                + 2 * primals["y"] * tangents["x"]
+                + 1
+            }
+
+        out2, dout2 = mx.jvp(outer_f, inputs, tans)
+        self.assertTrue(mx.allclose(out1[0], out2[0]))
+        self.assertTrue(mx.allclose(dout1[0] + 1, dout2[0]))
+
+    def test_complex_vjps(self):
+        def fun(x):
+            return (2.0 * mx.real(x)).sum()
+
+        x = mx.array([0.0 + 1j, 1.0 + 0.0j, 0.5 + 0.5j])
+        dfdx = mx.grad(fun)(x)
+        self.assertTrue(mx.allclose(dfdx, 2 * mx.ones_like(x)))
+
+        def fun(x):
+            return (2.0 * mx.imag(x)).sum()
+
+        x = mx.array([0.0 + 1j, 1.0 + 0.0j, 0.5 + 0.5j])
+        dfdx = mx.grad(fun)(x)
+        self.assertTrue(mx.allclose(dfdx, 2j * mx.ones_like(x)))
+
+    def test_flatten_unflatten_vjps(self):
+        def fun(x):
+            y = mx.unflatten(x, 0, (2, 2))
+            return y.sum()
+
+        x = mx.zeros((4, 8))
+        self.assertEqual(mx.grad(fun)(x).shape, (4, 8))
+
+        def fun(x):
+            y = mx.flatten(x, 0, 2)
+            return y.sum()
+
+        x = mx.zeros((2, 4, 8))
+        self.assertEqual(mx.grad(fun)(x).shape, (2, 4, 8))
+
+    def test_concatenate_vjps(self):
+        def fun(x, y):
+            return mx.concatenate([x, y])
+
+        x = mx.array([1, 2, 3], mx.float32)
+        y = mx.array([1, 2, 3], mx.float16)
+        grads = mx.vjp(fun, (x, y), (mx.ones((6,)),))[1]
+        self.assertTrue(mx.allclose(grads[0], mx.ones(3)))
+        self.assertTrue(mx.allclose(grads[1], mx.ones(3)))
+        self.assertEqual(grads[0].dtype, mx.float32)
+        self.assertEqual(grads[1].dtype, mx.float16)
+
+    def test_matmul_jvps(self):
+        a = mx.random.uniform(shape=(4, 4))
+        b = mx.random.uniform(shape=(4, 4))
+        c = mx.random.uniform(shape=(4, 4))
+        d = mx.random.uniform(shape=(4, 4))
+
+        _, tangent = mx.jvp(lambda a: a @ b, (a,), (c,))
+        self.assertTrue(mx.allclose(tangent[0], c @ b))
+
+        _, tangent = mx.jvp(lambda b: a @ b, (b,), (d,))
+        self.assertTrue(mx.allclose(tangent[0], a @ d))
+
+        _, tangent = mx.jvp(lambda a, b: a @ b, (a, b), (c, d))
+        self.assertTrue(mx.allclose(tangent[0], a @ d + c @ b))
+
+        x = mx.random.uniform(shape=(4, 4))
+        y = mx.random.uniform(shape=(4, 4))
+        z = mx.random.uniform(shape=(4, 4))
+
+        _, (tangent,) = mx.jvp(lambda a, b, c: a @ b + c, (a, b, c), (x, y, z))
+        _, (expected,) = mx.jvp(lambda a, b, c: mx.addmm(c, a, b), (a, b, c), (x, y, z))
+        self.assertTrue(mx.allclose(tangent, expected))
+
+        _, (tangent,) = mx.jvp(lambda a, c: a @ b + c, (a, c), (x, z))
+        _, (expected,) = mx.jvp(lambda a, c: mx.addmm(c, a, b), (a, c), (x, z))
+        self.assertTrue(mx.allclose(tangent, expected))
+
+        _, (tangent,) = mx.jvp(lambda b, c: a @ b + c, (b, c), (y, z))
+        _, (expected,) = mx.jvp(lambda b, c: mx.addmm(c, a, b), (b, c), (y, z))
+        self.assertTrue(mx.allclose(tangent, expected))
+
+        _, (tangent,) = mx.jvp(lambda c: a @ b + c, (c,), (z,))
+        _, (expected,) = mx.jvp(lambda c: mx.addmm(c, a, b), (c,), (z,))
+        self.assertTrue(mx.allclose(tangent, expected))
+
+    def test_put_along_axis_grads(self):
+        a = mx.zeros((5, 1))
+        b = mx.ones((2, 1))
+
+        def fun(a, b):
+            idx = mx.array([[0], [3]])
+            return mx.put_along_axis(a, idx, b, axis=0)
+
+        # Test VJP
+        cotan = mx.full((5, 1), 2.0)
+        _, (da, db) = mx.vjp(fun, (a, b), (cotan,))
+        expected_da = mx.array([0.0, 2.0, 2.0, 0.0, 2.0])[:, None]
+        expected_db = mx.array([2.0, 2.0])[:, None]
+        self.assertTrue(mx.allclose(expected_da, da))
+        self.assertTrue(mx.allclose(expected_db, db))
+
+        # Test JVP
+        tan_a = mx.full((5, 1), 2.0)
+        tan_b = mx.full((2, 1), 3.0)
+        _, (jout,) = mx.jvp(fun, (a, b), (tan_a, tan_b))
+        expected = mx.array([3.0, 2.0, 2.0, 3.0, 2.0])[:, None]
+        self.assertTrue(mx.allclose(expected, jout))
+
+        def fun(a):
+            idx = mx.array([[0], [3]])
+            return mx.put_along_axis(a, idx, b, axis=0)
+
+        _, (jout,) = mx.jvp(fun, (a,), (tan_a,))
+        expected = mx.array([0.0, 2.0, 2.0, 0.0, 2.0])[:, None]
+        self.assertTrue(mx.allclose(expected, jout))
+
+    def test_slice_grads(self):
+        # Slice
+        def fun(a):
+            return a[5:-6:-1]
+
+        a = mx.ones(shape=(5,))
+        cotan = mx.random.uniform(shape=(5,))
+        _, (grad,) = mx.vjp(fun, (a,), (cotan,))
+        self.assertTrue(mx.allclose(grad, cotan[::-1]))
+
+        tan = mx.random.uniform(shape=(5,))
+        mx.eval(tan)
+        _, (grad,) = mx.jvp(fun, (a,), (tan,))
+        self.assertTrue(mx.allclose(grad, tan[::-1]))
+
+        # Slice update
+        def fun(a, b):
+            a[4:-5:-2] = b
+            return a
+
+        a = mx.ones(shape=(4,))
+        b = mx.zeros(shape=(2,))
+
+        cotan = mx.random.uniform(shape=(4,))
+        _, (grad_a, grad_b) = mx.vjp(fun, (a, b), (cotan,))
+        expected_a = mx.array(cotan)
+        expected_a[1::2] = 0.0
+        self.assertTrue(mx.allclose(grad_a, expected_a))
+        self.assertTrue(mx.allclose(grad_b, cotan[4:-5:-2]))
+
+        tan_a = mx.random.uniform(shape=(4,))
+        tan_b = mx.random.uniform(shape=(2,))
+        _, (grad,) = mx.jvp(fun, (a, b), (tan_a, tan_b))
+        expected = tan_a
+        expected[4:-5:-2] = tan_b
+        self.assertTrue(mx.allclose(grad, expected))
+
+    def test_leaks(self):
+        for transform in [
+            mx.grad,
+            mx.value_and_grad,
+            mx.custom_function,
+            mx.checkpoint,
+        ]:
+            mx.synchronize()
+            gc.collect()
+            mem_pre = mx.get_active_memory()
+
+            def outer():
+                d = {}
+
+                def f(x):
+                    return d["x"]
+
+                d["f"] = transform(f)
+                d["x"] = mx.array([0] * 1000)
+
+            for _ in range(5):
+                outer()
+                gc.collect()
+            mem_post = mx.get_active_memory()
+            self.assertEqual(mem_pre, mem_post)
+
+    def test_grad_with_copies(self):
+        a = mx.array(2.0)
+        arrays = [a, a, a]
+
+        def fun(arrays):
+            return arrays[0] + arrays[2]
+
+        grads = mx.grad(fun)(arrays)
+        self.assertEqual(grads[0].item(), 1.0)
+        self.assertEqual(grads[2].item(), 1.0)
+
+    def test_grad_ids_pre_post(self):
+        def fun(arrs):
+            return arrs[0]
+
+        arrs = [mx.array(1.0)]
+        init_id = id(arrs[0])
+        mx.grad(fun)(arrs)
+        self.assertEqual(init_id, id(arrs[0]))
+
+    def test_grad_with_inplace_update(self):
+        def loss_fn(model):
+            model[1] = mx.array(2.0)
+            return model[0]
+
+        model = [
+            mx.array(0.0),
+            mx.array(1.0),
+        ]
+
+        grad_fn = mx.grad(loss_fn)
+        grad_fn(model)
+        self.assertEqual(model[1].item(), 2.0)
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_bf16.py b/ml-stable-diffusion/mlx/python/tests/test_bf16.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e4e2e0c33f2c6f8fac27c275dfe5a0799e48d85
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_bf16.py
@@ -0,0 +1,196 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+import unittest
+from itertools import permutations
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+try:
+    import torch
+
+    has_torch = True
+except ImportError as e:
+    has_torch = False
+
+
+class TestBF16(mlx_tests.MLXTestCase):
+    def __test_ops(
+        self,
+        ref_op,  # Function that outputs array_like
+        mlx_op,  # Function that outputs array_like
+        np_args,  # Numpy arguments
+        ref_transform=lambda x: x,
+        mlx_transform=lambda x: mx.array(x),
+        atol=1e-5,
+    ):
+        ref_args = map(ref_transform, np_args)
+        mlx_args = map(mlx_transform, np_args)
+
+        r_ref = ref_op(*ref_args)
+        r_mlx = mlx_op(*mlx_args)
+
+        self.assertTrue(np.allclose(r_mlx, r_ref, atol=atol))
+
+    def __default_test(
+        self,
+        op,
+        np_args,
+        simple_transform=lambda x: x,
+        atol_np=1e-3,
+        atol_torch=1e-5,
+        np_kwargs=dict(),
+        mlx_kwargs=dict(),
+        torch_kwargs=dict(),
+        torch_op=None,
+    ):
+        with self.subTest(reference="numpy"):
+
+            def np_transform(x):
+                x_mx_bf16 = mx.array(x).astype(mx.bfloat16)
+                x_mx_fp32 = x_mx_bf16.astype(mx.float32)
+                return np.asarray(x_mx_fp32)
+
+            def mlx_fn(*args):
+                out_bf16 = getattr(mx, op)(*args, **mlx_kwargs)
+                return np.asarray(out_bf16.astype(mx.float32))
+
+            def np_fn(*args):
+                out_fp32 = getattr(np, op)(*args, **np_kwargs)
+                return np_transform(out_fp32)
+
+            ref_op = np_fn
+            mlx_op = mlx_fn
+
+            ref_transform = lambda x: simple_transform(np_transform(x))
+            mlx_transform = lambda x: simple_transform(mx.array(x).astype(mx.bfloat16))
+
+            self.__test_ops(
+                ref_op,
+                mlx_op,
+                np_args,
+                ref_transform=ref_transform,
+                mlx_transform=mlx_transform,
+                atol=atol_np,
+            )
+
+        if has_torch:
+            with self.subTest(reference="torch"):
+                torch_op = op if torch_op is None else torch_op
+
+                def torch_fn(*args):
+                    out_bf16 = getattr(torch, torch_op)(*args, **torch_kwargs)
+                    return out_bf16.to(torch.float32).numpy()
+
+                ref_op = torch_fn
+                ref_transform = lambda x: simple_transform(
+                    torch.from_numpy(x).to(torch.bfloat16)
+                )
+                self.__test_ops(
+                    ref_op,
+                    mlx_op,
+                    np_args,
+                    ref_transform=ref_transform,
+                    mlx_transform=mlx_transform,
+                    atol=atol_torch,
+                )
+
+    def test_unary_ops(self):
+        x = np.random.rand(18, 28, 38)
+        for op in ["abs", "exp", "log", "square", "sqrt"]:
+            with self.subTest(op=op):
+                np_args = (x.astype(np.float32),)
+                self.__default_test(op, np_args)
+
+    def test_binary_ops(self):
+        x = np.random.rand(18, 28, 38)
+        y = np.random.rand(18, 28, 38)
+        for op in ["add", "subtract", "multiply", "divide", "maximum", "minimum"]:
+            with self.subTest(op=op):
+                np_args = (
+                    x.astype(np.float32),
+                    y.astype(np.float32),
+                )
+                self.__default_test(op, np_args, simple_transform=lambda x: x)
+                self.__default_test(op, np_args, simple_transform=lambda x: x[:1])
+                self.__default_test(op, np_args, simple_transform=lambda x: x[:, :1])
+
+    def test_reduction_ops(self):
+        x = np.random.rand(18, 28, 38).astype(np.float32)
+
+        for op in ("min", "max"):
+            with self.subTest(op=op):
+                for axes in (0, 1, 2, (0, 1), (0, 2), (1, 2), (0, 1, 2)):
+                    with self.subTest(axes=axes):
+                        np_args = (x.astype(np.float32),)
+                        self.__default_test(
+                            op,
+                            np_args,
+                            np_kwargs={"axis": axes},
+                            mlx_kwargs={"axis": axes},
+                            torch_kwargs={"dim": axes},
+                            torch_op="a" + op,
+                        )
+
+    def test_arg_reduction_ops(self):
+        data = np.random.rand(10, 12, 13).astype(np.float32)
+        x = mx.array(data).astype(mx.bfloat16)
+        data = np.asarray(x.astype(mx.float32))
+
+        for op in ["argmin", "argmax"]:
+            for axis in range(3):
+                for kd in [True, False]:
+                    a = getattr(mx, op)(x, axis, kd)
+                    b = getattr(np, op)(data, axis, keepdims=kd)
+                    a = a.astype(mx.float32)
+                    self.assertEqual(a.tolist(), b.tolist())
+
+        for op in ["argmin", "argmax"]:
+            a = getattr(mx, op)(x, keepdims=True)
+            b = getattr(np, op)(data, keepdims=True)
+            a = a.astype(mx.float32)
+            self.assertEqual(a.tolist(), b.tolist())
+            a = getattr(mx, op)(x)
+            b = getattr(np, op)(data)
+            a = a.astype(mx.float32)
+            self.assertEqual(a.item(), b)
+
+    def test_blas_ops(self):
+        if mx.default_device() != mx.gpu:
+            return
+
+        def test_blas(shape_x, shape_y):
+            np.random.seed(42)
+            with self.subTest(shape_x=shape_x, shape_y=shape_y):
+                x = np.random.normal(0.0, 1.0 / shape_x[-1], size=shape_x)
+                y = np.random.normal(0.0, 1.0 / shape_x[-1], size=shape_y)
+
+                np_args = (
+                    x.astype(np.float32),
+                    y.astype(np.float32),
+                )
+                op = "matmul"
+
+                self.__default_test(op, np_args, atol_np=1e-3, atol_torch=1e-3)
+
+        for shape_x, shape_y in [
+            [(32, 32), (32, 32)],
+            [(23, 57), (57, 1)],
+            [(1, 3), (3, 128)],
+            [(8, 128, 768), (768, 16)],
+        ]:
+            test_blas(shape_x, shape_y)
+
+    @unittest.skipIf(not has_torch, "requires PyTorch")
+    def test_conversion(self):
+        a_torch = torch.tensor([1.0, 2.0, 3.0], dtype=torch.bfloat16)
+        a_mx = mx.array(a_torch)
+        expected = mx.array([1.0, 2.0, 3.0], mx.bfloat16)
+        self.assertEqual(a_mx.dtype, mx.bfloat16)
+        self.assertTrue(mx.array_equal(a_mx, expected))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_blas.py b/ml-stable-diffusion/mlx/python/tests/test_blas.py
new file mode 100644
index 0000000000000000000000000000000000000000..67289ceeff52b47c0a427a39d1a7b1ab890d4b76
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_blas.py
@@ -0,0 +1,1352 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+import unittest
+from itertools import permutations
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+
+class TestBlas(mlx_tests.MLXTestCase):
+    @property
+    def dtypes(self):
+        return ["float32", "float16"]
+
+    def __gemm_test(
+        self,
+        shape_a,
+        shape_b,
+        np_dtype=np.float32,
+        f_np_a=lambda x: x,
+        f_np_b=lambda x: x,
+        f_mx_a=lambda x: x,
+        f_mx_b=lambda x: x,
+    ):
+        with self.subTest(
+            dtype=np.dtype(np_dtype).name, shape_a=shape_a, shape_b=shape_b
+        ):
+            np.random.seed(42)
+            scale = max(np.sum(shape_a), 128)
+            a_np = np.random.normal(0.0, 1.0 / scale, shape_a).astype(np_dtype)
+            b_np = np.random.normal(0.0, 1.0 / scale, shape_b).astype(np_dtype)
+
+            a_mx = mx.array(a_np)
+            b_mx = mx.array(b_np)
+
+            a_np = f_np_a(a_np.astype(np.float32))
+            b_np = f_np_b(b_np.astype(np.float32))
+            a_mx = f_mx_a(a_mx)
+            b_mx = f_mx_b(b_mx)
+
+            out_npy = a_np @ b_np
+            out_mlx = a_mx @ b_mx
+
+            self.assertListEqual(list(out_npy.shape), list(out_mlx.shape))
+            self.assertTrue(np.allclose(out_mlx, out_npy.astype(np_dtype), atol=1e-5))
+
+    def test_matmul_unaligned(self):
+        if not mx.is_available(mx.gpu):
+            return
+
+        for dtype in self.dtypes:
+            np_dtype = getattr(np, dtype)
+            base_shapes = [4, 8, 16, 32, 64, 128]
+            perturbations = [-2, -1, 0, 1, 2]
+
+            for dim in base_shapes:
+                for p in perturbations:
+                    shape_a = (dim + p, dim + p)
+                    shape_b = (dim + p, dim + p)
+                    self.__gemm_test(shape_a, shape_b, np_dtype)
+
+    def test_matvec_unaligned(self):
+        a = mx.random.normal(shape=(4, 128))
+        b = mx.random.normal(shape=(129,))[1:]
+        out = a @ b
+        np_out = np.array(a) @ np.array(b)
+        self.assertTrue(np.allclose(out, np_out))
+
+    def test_matmul_shapes(self):
+        if not mx.is_available(mx.gpu):
+            return
+
+        shapes = [
+            (1, 2, 1, 1),
+            (1, 1, 2, 1),
+            (3, 23, 457, 3),
+        ]
+
+        if mx.default_device() == mx.gpu:
+            shapes += [
+                (16, 768, 768, 128),
+                (1, 64, 64, 4096),
+            ]
+
+        for dtype in self.dtypes:
+            np_dtype = getattr(np, dtype)
+
+            for B, M, N, K in shapes:
+                with self.subTest(transpose="nn"):
+                    shape_a = (B, M, K)
+                    shape_b = (B, K, N)
+                    self.__gemm_test(shape_a, shape_b, np_dtype)
+
+                with self.subTest(transpose="nt"):
+                    shape_a = (B, M, K)
+                    shape_b = (B, N, K)
+                    self.__gemm_test(
+                        shape_a,
+                        shape_b,
+                        np_dtype,
+                        f_np_b=lambda x: np.transpose(x, (0, 2, 1)),
+                        f_mx_b=lambda x: mx.transpose(x, (0, 2, 1)),
+                    )
+
+                with self.subTest(transpose="tn"):
+                    shape_a = (B, K, M)
+                    shape_b = (B, K, N)
+                    self.__gemm_test(
+                        shape_a,
+                        shape_b,
+                        np_dtype,
+                        f_np_a=lambda x: np.transpose(x, (0, 2, 1)),
+                        f_mx_a=lambda x: mx.transpose(x, (0, 2, 1)),
+                    )
+
+                with self.subTest(transpose="tt"):
+                    shape_a = (B, K, M)
+                    shape_b = (B, N, K)
+                    self.__gemm_test(
+                        shape_a,
+                        shape_b,
+                        np_dtype,
+                        f_np_a=lambda x: np.transpose(x, (0, 2, 1)),
+                        f_mx_a=lambda x: mx.transpose(x, (0, 2, 1)),
+                        f_np_b=lambda x: np.transpose(x, (0, 2, 1)),
+                        f_mx_b=lambda x: mx.transpose(x, (0, 2, 1)),
+                    )
+
+    def test_matmul(self):
+        # Note: so far, matmul only works with floating-point types
+        a = mx.array([[1.0, 2.0], [3.0, 4.0]])
+
+        b = mx.array([[0.0, -1.0], [-3.0, 3.0]])
+
+        expected = [[-6.0, 5.0], [-12.0, 9.0]]
+
+        self.assertEqual((a @ b).tolist(), expected)
+        self.assertEqual(mx.matmul(a, b).tolist(), expected)
+
+        # Transposed matmul
+        np.random.seed(0)
+        a_npy = np.random.normal(0.0, 1.0 / 128, (128, 16)).astype(np.float32)
+        b_npy = np.random.normal(0.0, 1.0 / 128, (128, 16)).astype(np.float32)
+        c_npy = a_npy @ np.transpose(b_npy, (1, 0))
+        d_npy = np.transpose(a_npy, (1, 0)) @ b_npy
+
+        a_mlx = mx.array(a_npy)
+        b_mlx = mx.array(b_npy)
+        c_mlx = a_mlx @ mx.transpose(b_mlx, (1, 0))
+        d_mlx = mx.transpose(a_mlx, (1, 0)) @ b_mlx
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertListEqual(list(d_npy.shape), list(d_mlx.shape))
+
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-6))
+        self.assertTrue(np.allclose(d_mlx, d_npy, atol=1e-6))
+
+    def test_matmul_dtypes(self):
+        for dt in self.dtypes:
+            a_npy = np.random.normal(0.0, 1.0 / 256, (16, 16, 16)).astype(
+                getattr(np, dt)
+            )
+            b_npy = np.random.normal(0.0, 1.0 / 256, (16, 16, 16)).astype(
+                getattr(np, dt)
+            )
+            a_mlx = mx.array(a_npy)
+            b_mlx = mx.array(b_npy)
+
+            c_npy = np.matmul(a_npy, b_npy, dtype=getattr(np, dt))
+            c_mlx = a_mlx @ b_mlx
+
+            self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-6))
+
+    def test_matmul_batched(self):
+        np.random.seed(0)
+        # Batched matmul
+        a_npy = np.random.normal(0.0, 1.0 / 128, (32, 128, 16)).astype(np.float32)
+        b_npy = np.random.normal(0.0, 1.0 / 128, (32, 16, 16)).astype(np.float32)
+        c_npy = a_npy @ b_npy
+
+        a_mlx = mx.array(a_npy)
+        b_mlx = mx.array(b_npy)
+        c_mlx = a_mlx @ b_mlx
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-6))
+
+        # Batched and transposed matmul
+        b_npy = np.random.normal(0.0, 1.0 / 128, (32, 128, 16)).astype(np.float32)
+        c_npy = a_npy @ np.transpose(b_npy, (0, 2, 1))
+
+        b_mlx = mx.array(b_npy)
+        c_mlx = a_mlx @ mx.transpose(b_mlx, (0, 2, 1))
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-6))
+
+        # Batched matmul with simple broadcast
+        a_npy = np.random.normal(0.0, 1.0 / 128, (32, 128, 16)).astype(np.float32)
+        b_npy = np.random.normal(0.0, 1.0 / 128, (16, 16)).astype(np.float32)
+        c_npy = a_npy @ b_npy
+
+        a_mlx = mx.array(a_npy)
+        b_mlx = mx.array(b_npy)
+        c_mlx = a_mlx @ b_mlx
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-6))
+
+        # Both operands broadcasted
+        d_npy = np.broadcast_to(b_npy, (5, 16, 16))
+        d_mlx = mx.broadcast_to(b_mlx, (5, 16, 16))
+
+        e_npy = d_npy @ d_npy
+        e_mlx = d_mlx @ d_mlx
+
+        self.assertListEqual(list(e_npy.shape), list(e_mlx.shape))
+        self.assertTrue(np.allclose(e_mlx, e_npy, atol=1e-6))
+
+        # Batched and transposed matmul with simple broadcast
+        a_npy = np.random.normal(0.0, 1.0 / 128, (32, 128, 16)).astype(np.float32)
+        b_npy = np.random.normal(0.0, 1.0 / 128, (128, 16)).astype(np.float32)
+        a_mlx = mx.array(a_npy)
+        b_mlx = mx.array(b_npy)
+
+        c_npy = a_npy @ np.transpose(b_npy, (1, 0))
+        c_mlx = a_mlx @ mx.transpose(b_mlx, (1, 0))
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-6))
+
+        # Matmul with vector
+        a_npy = np.random.normal(0.0, 1.0 / 128, (32, 128, 16)).astype(np.float32)
+        b_npy = np.random.normal(0.0, 1.0 / 128, (16,)).astype(np.float32)
+        a_mlx = mx.array(a_npy)
+        b_mlx = mx.array(b_npy)
+
+        c_npy = a_npy @ b_npy
+        c_mlx = a_mlx @ b_mlx
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-6))
+
+        # Test Multiheaded attention style matmul
+        a_npy = np.random.normal(0.0, 1.0 / 128, (64, 16, 4, 32)).astype(np.float32)
+        b_npy = np.random.normal(0.0, 1.0 / 128, (64, 16, 4, 32)).astype(np.float32)
+        a_mlx = mx.array(a_npy)
+        b_mlx = mx.array(b_npy)
+
+        a_npy = np.transpose(a_npy, (0, 2, 1, 3))
+        b_npy = np.transpose(b_npy, (0, 2, 1, 3))
+        a_mlx = mx.transpose(a_mlx, (0, 2, 1, 3))
+        b_mlx = mx.transpose(b_mlx, (0, 2, 1, 3))
+
+        c_npy = a_npy @ np.transpose(b_npy, (0, 1, 3, 2))
+        c_mlx = a_mlx @ mx.transpose(b_mlx, (0, 1, 3, 2))
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-6))
+
+    def __gemv_test(
+        self,
+        shape_mat,
+        shape_vec,
+        np_dtype=np.float32,
+        mat_first=True,
+        np_mat_f=lambda x: x,
+        np_vec_f=lambda x: x,
+        mlx_mat_f=lambda x: x,
+        mlx_vec_f=lambda x: x,
+    ):
+        with self.subTest(
+            shape_mat=shape_mat, shape_vec=shape_vec, mat_first=mat_first
+        ):
+            np.random.seed(42)
+            scale = max(np.sum(shape_mat), 32)
+            mat_npy = np.random.normal(0.0, 1.0 / scale, shape_mat).astype(np_dtype)
+            vec_npy = np.random.normal(0.0, 1.0 / scale, shape_vec).astype(np_dtype)
+
+            mat_mlx = mx.array(mat_npy)
+            vec_mlx = mx.array(vec_npy)
+
+            mat_npy = np_mat_f(mat_npy)
+            vec_npy = np_vec_f(vec_npy)
+            mat_mlx = mlx_mat_f(mat_mlx)
+            vec_mlx = mlx_vec_f(vec_mlx)
+
+            if mat_first:
+                out_npy = mat_npy @ vec_npy
+                out_mlx = mat_mlx @ vec_mlx
+            else:
+                out_npy = vec_npy @ mat_npy
+                out_mlx = vec_mlx @ mat_mlx
+
+            self.assertListEqual(list(out_npy.shape), list(out_mlx.shape))
+            self.assertTrue(np.allclose(out_mlx, out_npy, atol=1e-5))
+
+    def test_matrix_vector(self):
+        for dtype in self.dtypes:
+            with self.subTest(dtype=dtype):
+                np_dtype = getattr(np, dtype)
+
+                # Basic square matrix test
+                self.__gemv_test(
+                    shape_mat=(64, 64), shape_vec=(64, 1), np_dtype=np_dtype
+                )
+                self.__gemv_test(
+                    shape_mat=(64, 64),
+                    shape_vec=(64, 1),
+                    np_dtype=np_dtype,
+                    mat_first=False,
+                    np_vec_f=lambda x: np.transpose(x, (1, 0)),
+                    mlx_vec_f=lambda x: mx.transpose(x, (1, 0)),
+                )
+
+                # Vector matrix product with aligned and unaligned shapes
+                for in_len_base, out_len_base in (
+                    (2, 2),
+                    (32, 32),
+                    (64, 64),
+                    (2048, 2048),
+                ):
+                    for mi in (-1, 0, 1):
+                        for mj in (-1, 0, 1):
+                            # Vec mat
+                            shape_mat = (in_len_base + mi, out_len_base + mj)
+                            shape_vec = (1, in_len_base + mi)
+                            self.__gemv_test(
+                                shape_mat, shape_vec, mat_first=False, np_dtype=np_dtype
+                            )
+
+                            # Mat vec
+                            shape_mat = (out_len_base + mj, in_len_base + mi)
+                            shape_vec = (in_len_base + mi, 1)
+                            self.__gemv_test(
+                                shape_mat, shape_vec, mat_first=True, np_dtype=np_dtype
+                            )
+
+    def test_matrix_vector_batched(self):
+        for dtype in self.dtypes:
+            with self.subTest(dtype=dtype):
+                np_dtype = getattr(np, dtype)
+
+                # Batched mat vec
+                for shape_mat, shape_vec in (
+                    ((32, 128, 64), (32, 64, 1)),
+                    ((128, 64), (32, 64, 1)),
+                    ((32, 128, 64), (64, 1)),
+                    ((2, 1, 8, 1, 6, 128), (2, 1, 8, 4, 128, 1)),
+                ):
+                    self.__gemv_test(
+                        shape_mat, shape_vec, mat_first=True, np_dtype=np_dtype
+                    )
+
+                # Batched vec mat
+                for shape_vec, shape_mat in (
+                    ((32, 1, 128), (32, 128, 64)),
+                    ((32, 1, 128), (128, 64)),
+                    ((1, 128), (32, 128, 64)),
+                    ((1, 8, 4, 1, 128), (1, 8, 1, 128, 6)),
+                ):
+                    self.__gemv_test(
+                        shape_mat, shape_vec, mat_first=False, np_dtype=np_dtype
+                    )
+
+    def test_matrix_vector_broadcast(self):
+        for dtype in self.dtypes:
+            with self.subTest(dtype=dtype):
+                np_dtype = getattr(np, dtype)
+
+                # Different broadcasts mat vec
+                for shape_mat, shape_vec in (
+                    ((32, 64, 64), (32, 64, 1)),
+                    ((64, 64), (32, 64, 1)),
+                    ((32, 64, 64), (64, 1)),
+                ):
+                    self.__gemv_test(
+                        shape_mat=(64, 64),
+                        shape_vec=(64, 1),
+                        np_dtype=np_dtype,
+                        np_mat_f=(lambda mat_npy: np.broadcast_to(mat_npy, shape_mat)),
+                        np_vec_f=(lambda vec_npy: np.broadcast_to(vec_npy, shape_vec)),
+                        mlx_mat_f=(lambda mat_mlx: mx.broadcast_to(mat_mlx, shape_mat)),
+                        mlx_vec_f=(lambda vec_mlx: mx.broadcast_to(vec_mlx, shape_vec)),
+                    )
+
+                # Different broadcasts vec mat
+                for shape_vec, shape_mat in (
+                    ((32, 1, 64), (32, 64, 64)),
+                    ((32, 1, 64), (64, 64)),
+                    ((1, 64), (32, 64, 64)),
+                ):
+                    self.__gemv_test(
+                        shape_mat=(64, 64),
+                        shape_vec=(1, 64),
+                        np_dtype=np_dtype,
+                        mat_first=False,
+                        np_mat_f=lambda mat_npy: np.broadcast_to(mat_npy, shape_mat),
+                        np_vec_f=lambda vec_npy: np.broadcast_to(vec_npy, shape_vec),
+                        mlx_mat_f=lambda mat_mlx: mx.broadcast_to(mat_mlx, shape_mat),
+                        mlx_vec_f=lambda vec_mlx: mx.broadcast_to(vec_mlx, shape_vec),
+                    )
+
+    def test_matrix_vector_attn(self):
+        # Multi-query style attention check
+        for dtype in self.dtypes:
+            # fmt: off
+            for (B,  D, n_kv_heads, factor,  qsl,  ksl) in (
+                (1, 16,          8,      4,    1,  256),
+                (1, 16,          8,      4,   32,  256),
+                (1, 16,          8,      4,  256,    1),
+                (4, 16,          8,      4,    1,  256),
+                (4, 16,          8,      4,  256,    1),
+            ):
+            # fmt: on
+                with self.subTest(
+                        B=B, # Batch size
+                        D=D, # Dimension of mm
+                        n_kv_heads=n_kv_heads, # key-value heads
+                        factor=factor, # factor to get query heads
+                        qsl=qsl, # Query sequence length
+                        ksl=ksl, # Key sequence length
+                        dtype=dtype # Data type
+                    ):
+
+                    np_dtype = getattr(np, dtype)
+
+                    # Fix shapes for kqv
+                    n_q_heads = n_kv_heads * factor
+                    Dk = D * n_kv_heads
+                    Dq = D * n_q_heads
+                    scale = 1. / math.sqrt(Dk)
+
+                    shape_queries = (B, qsl, Dq)
+                    shape_keys = (B, ksl, Dk)
+                    shape_values = (B, ksl, Dk)
+
+                    # Prepare numpy arrays
+                    q_np = np.random.uniform(-scale, scale, size=shape_queries).astype(np_dtype)
+                    k_np = np.random.uniform(-scale, scale, size=shape_keys).astype(np_dtype)
+                    v_np = np.random.uniform(-scale, scale, size=shape_values).astype(np_dtype)
+
+                    # Rearrange to move heads up
+                    q_np_reshape = q_np.reshape(B, qsl, n_kv_heads, factor, -1).transpose(0, 2, 3, 1, 4)
+                    k_np_reshape = k_np.reshape(B, ksl, n_kv_heads, 1, -1).transpose(0, 2, 3, 4, 1)
+                    v_np_reshape = v_np.reshape(B, ksl, n_kv_heads, 1, -1).transpose(0, 2, 3, 1, 4)
+
+                    # Do attn style matmul
+                    s_np = q_np_reshape @ k_np_reshape
+                    o_np = s_np @ v_np_reshape
+                    o_np = o_np.transpose(0, 3, 1, 2, 4).reshape(B, qsl, -1)
+
+                    # Test mlx
+                    q_mx = mx.array(q_np)
+                    k_mx = mx.array(k_np)
+                    v_mx = mx.array(v_np)
+
+                    # Rearrange to move heads up
+                    q_mx_reshape = q_mx.reshape(B, qsl, n_kv_heads, factor, -1).transpose(0, 2, 3, 1, 4)
+                    k_mx_reshape = k_mx.reshape(B, ksl, n_kv_heads, 1, -1).transpose(0, 2, 3, 4, 1)
+                    v_mx_reshape = v_mx.reshape(B, ksl, n_kv_heads, 1, -1).transpose(0, 2, 3, 1, 4)
+
+                    # Do attn style matmul
+                    s_mx = q_mx_reshape @ k_mx_reshape
+                    o_mx = (s_mx @ v_mx_reshape)
+                    o_mx = o_mx.transpose(0, 3, 1, 2, 4).reshape(B, qsl, -1)
+
+                    # Check against np
+                    self.assertListEqual(list(s_np.shape), list(s_mx.shape))
+                    self.assertTrue(np.allclose(s_np, s_mx, atol=1e-4))
+
+                    self.assertListEqual(list(o_np.shape), list(o_mx.shape))
+                    self.assertTrue(np.allclose(o_np, o_mx, atol=1e-4))
+
+    def test_matrix_vector_edgecases(self):
+        for dtype in self.dtypes:
+            with self.subTest(dtype=dtype):
+                np_dtype = getattr(np, dtype)
+
+                for in_vec_len in np.arange(1, 5):
+                    for out_vec_len in np.arange(1, 5):
+                        for batch_size in np.arange(1, 5):
+                            with self.subTest(
+                                problem_shape=(batch_size, in_vec_len, out_vec_len)
+                            ):
+                                # Matrix vector
+                                with self.subTest(transpose=False):
+                                    a_npy = np.ones(
+                                        (batch_size, out_vec_len, in_vec_len),
+                                        dtype=np_dtype,
+                                    )
+                                    b_npy = np.ones(
+                                        (batch_size, in_vec_len, 1), dtype=np_dtype
+                                    )
+                                    for i in range(batch_size):
+                                        b_npy[i] *= i + 1.0
+
+                                    a_mlx, b_mlx = map(mx.array, [a_npy, b_npy])
+                                    c_npy = a_npy @ b_npy
+                                    c_mlx = a_mlx @ b_mlx
+
+                                    self.assertListEqual(
+                                        list(c_npy.shape), list(c_mlx.shape)
+                                    )
+                                    self.assertTrue(np.array_equal(c_mlx, c_npy))
+
+                                # Vector matrix
+                                with self.subTest(transpose=True):
+                                    a_npy = np.ones(
+                                        (batch_size, out_vec_len, in_vec_len),
+                                        dtype=np_dtype,
+                                    )
+                                    b_npy = np.ones(
+                                        (batch_size, 1, out_vec_len), dtype=np_dtype
+                                    )
+                                    for i in range(batch_size):
+                                        b_npy[i] *= i + 1.0
+
+                                    a_mlx, b_mlx = map(mx.array, [a_npy, b_npy])
+                                    c_npy = b_npy @ a_npy
+                                    c_mlx = b_mlx @ a_mlx
+
+                                    self.assertListEqual(
+                                        list(c_npy.shape), list(c_mlx.shape)
+                                    )
+                                    self.assertTrue(np.array_equal(c_mlx, c_npy))
+
+    def test_mismatch_stride_mm(self):
+        np.random.seed(0)
+        a_npy = np.random.normal(0.0, 1.0 / 128, (4, 16, 16)).astype(np.float32)
+        b_npy = np.random.normal(0.0, 1.0 / 128, (4, 16, 16)).astype(np.float32)
+
+        a_mlx = mx.array(a_npy)
+        b_mlx = mx.array(b_npy)
+
+        # Matmul with batches
+        c_npy = a_npy[::2, :, :] @ b_npy[1::2, :, :]
+        c_mlx = a_mlx[::2, :, :] @ b_mlx[1::2, :, :]
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-5))
+
+        # Matvec with batches
+        c_npy = a_npy[::2, :, :] @ b_npy[1::2, :, 2:3]
+        c_mlx = a_mlx[::2, :, :] @ b_mlx[1::2, :, 2:3]
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-5))
+
+        # Matmul with slice
+        c_npy = a_npy[:, :8, :] @ b_npy[:, :, :8]
+        c_mlx = a_mlx[:, :8, :] @ b_mlx[:, :, :8]
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-5))
+
+        # Matmul with slice
+        c_npy = a_npy[:, :, :8] @ b_npy[:, :8, :]
+        c_mlx = a_mlx[:, :, :8] @ b_mlx[:, :8, :]
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-5))
+
+        # Matmul transpose with slice
+        c_npy = a_npy[:, :8, :] @ b_npy[:, :8, :].swapaxes(-1, -2)
+        c_mlx = a_mlx[:, :8, :] @ b_mlx[:, :8, :].swapaxes(-1, -2)
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-5))
+
+        # Matmul transpose with slice
+        c_npy = a_npy[:, :, :8] @ b_npy[:, :, :8].swapaxes(-1, -2)
+        c_mlx = a_mlx[:, :, :8] @ b_mlx[:, :, :8].swapaxes(-1, -2)
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-5))
+
+        # Matvec with slice
+        c_npy = a_npy[:, :8, :] @ b_npy[:, :, 6:7]
+        c_mlx = a_mlx[:, :8, :] @ b_mlx[:, :, 6:7]
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-5))
+
+        # Matvec with slice
+        c_npy = a_npy[:, :, :8] @ b_npy[:, 3:11, 2:3]
+        c_mlx = a_mlx[:, :, :8] @ b_mlx[:, 3:11, 2:3]
+
+        self.assertListEqual(list(c_npy.shape), list(c_mlx.shape))
+        self.assertTrue(np.allclose(c_mlx, c_npy, atol=1e-5))
+
+    def test_addmm(self):
+        np.random.seed(0)
+        # Batched matmul
+        alpha = 0.5
+        for beta in (1.0, 2.0):
+            # c must broadcast to the output shape
+            with self.assertRaises(ValueError):
+                mx.addmm(mx.zeros((2, 2, 2)), mx.zeros((2, 2)), mx.zeros((2, 2)))
+
+            # Regular batched case
+            a_npy = np.random.normal(0.0, 1.0 / 128, (32, 128, 16)).astype(np.float32)
+            b_npy = np.random.normal(0.0, 1.0 / 128, (32, 16, 16)).astype(np.float32)
+
+            a_mlx = mx.array(a_npy)
+            b_mlx = mx.array(b_npy)
+
+            for c_shape in ((1,), (1, 16), (32, 1, 16), (1, 128, 16)):
+                c_npy = np.ones(c_shape).astype(np.float32)
+                c_mlx = mx.array(c_npy)
+
+                d_npy = alpha * (a_npy @ b_npy) + beta * c_npy
+                d_mlx = mx.addmm(c_mlx, a_mlx, b_mlx, alpha, beta)
+
+                self.assertListEqual(list(d_npy.shape), list(d_mlx.shape))
+                self.assertTrue(np.allclose(d_mlx, d_npy, atol=1e-5))
+
+            # Batched and transposed matmul
+            b_npy = np.random.normal(0.0, 1.0 / 128, (32, 128, 16)).astype(np.float32)
+            b_mlx = mx.array(b_npy)
+
+            for c_shape in ((1,), (32, 1, 128), (1, 128)):
+                c_npy = np.ones(c_shape).astype(np.float32)
+                c_mlx = mx.array(c_npy)
+
+                b_np_t = np.transpose(b_npy, (0, 2, 1))
+                b_mx_t = mx.transpose(b_mlx, (0, 2, 1))
+
+                d_npy = alpha * (a_npy @ b_np_t) + beta * c_npy
+                d_mlx = mx.addmm(c_mlx, a_mlx, b_mx_t, alpha, beta)
+
+                self.assertListEqual(list(d_npy.shape), list(d_mlx.shape))
+                self.assertTrue(np.allclose(d_mlx, d_npy, atol=1e-5))
+            # Batched matmul with simple broadcast
+            a_npy = np.random.normal(0.0, 1.0 / 128, (32, 128, 16)).astype(np.float32)
+            b_npy = np.random.normal(0.0, 1.0 / 128, (16, 16)).astype(np.float32)
+
+            a_mlx = mx.array(a_npy)
+            b_mlx = mx.array(b_npy)
+
+            for c_shape in ((1,), (1, 16), (32, 1, 16), (1, 128, 16)):
+                c_npy = np.ones(c_shape).astype(np.float32)
+                c_mlx = mx.array(c_npy)
+
+                d_npy = alpha * (a_npy @ b_npy) + beta * c_npy
+                d_mlx = mx.addmm(c_mlx, a_mlx, b_mlx, alpha, beta)
+
+                self.assertListEqual(list(d_npy.shape), list(d_mlx.shape))
+                self.assertTrue(np.allclose(d_mlx, d_npy, atol=1e-5))
+            # Matmul with vector
+            a_npy = np.random.normal(0.0, 1.0 / 128, (16,)).astype(np.float32)
+            b_npy = np.random.normal(0.0, 1.0 / 128, (32, 16, 128)).astype(np.float32)
+            a_mlx = mx.array(a_npy)
+            b_mlx = mx.array(b_npy)
+
+            for c_shape in ((1,), (128,), (32, 128)):
+                c_npy = np.ones(c_shape).astype(np.float32)
+                c_mlx = mx.array(c_npy)
+
+                d_npy = alpha * (a_npy @ b_npy) + beta * c_npy
+                d_mlx = mx.addmm(c_mlx, a_mlx, b_mlx, alpha, beta)
+
+                self.assertListEqual(list(d_npy.shape), list(d_mlx.shape))
+                self.assertTrue(np.allclose(d_mlx, d_npy, atol=1e-5))
+
+            # Matmul with vector
+            a_npy = np.random.normal(0.0, 1.0 / 128, (32, 128, 16)).astype(np.float32)
+            b_npy = np.random.normal(0.0, 1.0 / 128, (16,)).astype(np.float32)
+            a_mlx = mx.array(a_npy)
+            b_mlx = mx.array(b_npy)
+
+            for c_shape in ((1,), (32, 128)):
+                c_npy = np.ones(c_shape).astype(np.float32)
+                c_mlx = mx.array(c_npy)
+
+                d_npy = alpha * (a_npy @ b_npy) + beta * c_npy
+                d_mlx = mx.addmm(c_mlx, a_mlx, b_mlx, alpha, beta)
+
+                self.assertListEqual(list(d_npy.shape), list(d_mlx.shape))
+                self.assertTrue(np.allclose(d_mlx, d_npy, atol=1e-5))
+
+            # Split K specializtion
+            a_npy = np.random.normal(0.0, 1.0 / 128, (64, 4096)).astype(np.float32)
+            b_npy = np.random.normal(0.0, 1.0 / 128, (4096, 32)).astype(np.float32)
+
+            a_mlx = mx.array(a_npy)
+            b_mlx = mx.array(b_npy)
+
+            for c_shape in ((1,), (1, 32), (64, 1), (64, 32)):
+                c_npy = np.ones(c_shape).astype(np.float32)
+                c_mlx = mx.array(c_npy)
+
+                d_npy = alpha * (a_npy @ b_npy) + beta * c_npy
+                d_mlx = mx.addmm(c_mlx, a_mlx, b_mlx, alpha, beta)
+
+                self.assertListEqual(list(d_npy.shape), list(d_mlx.shape))
+                self.assertTrue(np.allclose(d_mlx, d_npy, atol=1e-5))
+
+            # Transposed c
+            a = mx.ones((10, 5)).T
+            b = mx.ones((5, 5))
+            out = mx.addmm(a, b, a, beta=beta, alpha=alpha)
+            expected = beta * a + alpha * (b @ a)
+            self.assertTrue(mx.allclose(expected, out))
+
+            # Broadcast c
+            a = mx.ones((5, 5))
+            b = mx.ones((5, 5))
+            c = mx.ones((1, 5))
+            out = mx.addmm(c, a, b, beta=beta, alpha=alpha)
+            expected = beta * c + alpha * (a @ b)
+            self.assertTrue(mx.allclose(expected, out))
+
+    def test_addmm_grad(self):
+        def make_ref_addmm(alpha, beta):
+            return lambda c, a, b: alpha * (a @ b) + beta * c
+
+        def make_addmm(alpha, beta):
+            return lambda c, a, b: mx.addmm(c, a, b, alpha, beta)
+
+        # B, M, N, K
+        shapes = ((1, 64, 32, 128), (4, 28, 24, 47), (1, 1, 24, 47))
+
+        alpha = 2.0
+        for beta in (1.0, 0.5):
+            f_test = make_addmm(alpha, beta)
+            f_ref = make_ref_addmm(alpha, beta)
+
+            for B, M, N, K in shapes:
+                cotan = mx.ones((B, M, N))
+                c = mx.random.normal((B, M, N))
+                a = mx.random.normal((B, M, K))
+                b = mx.random.normal((B, K, N))
+
+                out_ref, dout_ref = mx.vjp(
+                    f_ref,
+                    [c, a, b],
+                    [cotan],
+                )
+                out_test, dout_test = mx.vjp(
+                    f_test,
+                    [c, a, b],
+                    [cotan],
+                )
+
+                self.assertTrue(mx.allclose(out_ref[0], out_test[0], atol=1e-4).item())
+
+                for r, t in zip(dout_ref, dout_test):
+                    self.assertEqual(r.shape, t.shape)
+                    self.assertTrue(mx.allclose(r, t, atol=1e-4).item())
+
+    def test_empty_matmul(self):
+        a = mx.array([[], []]).T
+        b = mx.array([[1.0, 2.0], [2.0, 3.0]])
+        c = a @ b
+        mx.eval(c)
+        self.assertEqual(c.shape, (0, 2))
+
+        a = mx.array([[1.0, 2.0], [2.0, 3.0]])
+        b = mx.array([[], []])
+        c = a @ b
+        mx.eval(c)
+        self.assertEqual(c.shape, (2, 0))
+
+        a = mx.array([[], []]).T
+        b = mx.array([[], []])
+        c = a @ b
+        mx.eval(c)
+        self.assertEqual(c.shape, (0, 0))
+
+        c = mx.array(1.0, dtype=mx.float32)
+        a = mx.array([], dtype=mx.float32)
+        b = mx.array([], dtype=mx.float32)
+        out = mx.addmm(c, a, b)
+        self.assertEqual(out.item(), 1.0)
+        self.assertEqual(out.shape, ())
+
+        a = mx.zeros(shape=(5, 0))
+        b = mx.zeros(shape=(0, 5))
+        c = mx.random.uniform(shape=(5, 5))
+        out = mx.addmm(c, a, b)
+        self.assertTrue(mx.allclose(out, c))
+
+    def test_block_masked_matmul(self):
+        def ref_block_masked_mm(
+            a, b, block_size, out_mask=None, lhs_mask=None, rhs_mask=None
+        ):
+            # Get mask adjusted shapes
+            M = a.shape[-2]
+            N = b.shape[-1]
+            K = a.shape[-1]
+
+            bsx_shape = np.broadcast_shapes(a.shape[:-2], b.shape[:-2])
+
+            # Expand mask dims
+            def expand_mask(mask, block_size, Y, X):
+                mask = mx.expand_dims(mask, (-3, -1))
+                mask_shape = list(bsx_shape) + list(mask.shape[-4:])
+                mask_shape[-1] = block_size
+                x = mask_shape[-2] * block_size
+                mask_shape[-3] = block_size
+                y = mask_shape[-4] * block_size
+                mask = mx.broadcast_to(mask, mask_shape)
+                mask_shape = mask_shape[:-4] + [y, x]
+                return mask.reshape(mask_shape)[..., :Y, :X]
+
+            a_masked = a
+            b_masked = b
+
+            if lhs_mask is not None:
+                lhs_mask = expand_mask(lhs_mask, block_size, M, K).astype(mx.float32)
+                a_masked = lhs_mask * a_masked
+
+            if rhs_mask is not None:
+                rhs_mask = expand_mask(rhs_mask, block_size, K, N).astype(mx.float32)
+                b_masked = rhs_mask * b_masked
+
+            out = a_masked @ b_masked
+
+            if out_mask is not None:
+                out_mask = expand_mask(out_mask, block_size, M, N).astype(mx.float32)
+                out = out * out_mask
+            return out
+
+        def run_test(a, b, block_size, out_mask, a_mask, b_mask, cotan):
+            def f_ref(a_, b_):
+                return ref_block_masked_mm(a_, b_, block_size, out_mask, a_mask, b_mask)
+
+            def f_test(a_, b_):
+                return mx.block_masked_mm(a_, b_, block_size, out_mask, a_mask, b_mask)
+
+            out_ref, dout_ref = mx.vjp(f_ref, [a, b], [cotan])
+            out_test, dout_test = mx.vjp(f_test, [a, b], [cotan])
+
+            self.assertTrue(mx.allclose(out_ref[0], out_test[0], atol=1e-5).item())
+
+            for r, t in zip(dout_ref, dout_test):
+                self.assertEqual(r.shape, t.shape)
+                self.assertTrue(mx.allclose(r, t, atol=1e-4).item())
+
+        def run_test_mask_vjp(a, b, block_size, out_mask, a_mask, b_mask, cotan):
+            def f_ref(a_, b_, a_mask_, b_mask_):
+                return ref_block_masked_mm(
+                    a_, b_, block_size, out_mask, a_mask_, b_mask_
+                )
+
+            def f_test(a_, b_, a_mask_, b_mask_):
+                return mx.block_masked_mm(
+                    a_, b_, block_size, out_mask, a_mask_, b_mask_
+                )
+
+            out_ref, dout_ref = mx.vjp(f_ref, [a, b, a_mask, b_mask], [cotan])
+            out_test, dout_test = mx.vjp(f_test, [a, b, a_mask, b_mask], [cotan])
+
+            mx.eval((out_ref, dout_ref, out_test, dout_test))
+
+            self.assertTrue(mx.allclose(out_ref[0], out_test[0], atol=1e-5).item())
+
+            for r, t in zip(dout_ref, dout_test):
+                self.assertEqual(r.shape, t.shape)
+                self.assertTrue(mx.allclose(r, t, atol=1e-4).item())
+
+        def make_mask(tm_, tn_, batch, np_dtype):
+            arr_np_mask = np.random.normal(size=batch + (tm_, tn_)).astype(np_dtype)
+            arr_np_bool_mask = arr_np_mask < 0.0
+            arr_np_mask[arr_np_bool_mask] = 0.0
+
+            return mx.array(arr_np_bool_mask), mx.array(arr_np_mask)
+
+        def test_shape(
+            M,
+            N,
+            K,
+            block_size,
+            transpose=False,
+            np_dtype=np.float32,
+            batch_A=(),
+            batch_B=(),
+        ):
+            with self.subTest(
+                M=M,
+                N=N,
+                K=K,
+                block_size=block_size,
+                np_dtype=np_dtype,
+                transpose=transpose,
+                batch_A=batch_A,
+                batch_B=batch_B,
+            ):
+                batch_out = np.broadcast_shapes(batch_A, batch_B)
+                cotan = mx.ones(batch_out + (M, N))
+
+                a_np = np.random.normal(size=batch_A + (M, K)).astype(np_dtype)
+                b_np = np.random.normal(size=batch_B + (K, N)).astype(np_dtype)
+
+                a_mx = mx.array(a_np)
+                b_mx = mx.array(b_np)
+
+                tm = (M + block_size - 1) // block_size
+                tn = (N + block_size - 1) // block_size
+                tk = (K + block_size - 1) // block_size
+
+                a_mx_bool_mask, a_mx_mask = make_mask(tm, tk, batch_A, np_dtype)
+                b_mx_bool_mask, b_mx_mask = make_mask(tk, tn, batch_B, np_dtype)
+                out_mx_bool_mask, out_mx_mask = make_mask(tm, tn, batch_out, np_dtype)
+
+                # Boolean block masks
+                run_test(
+                    a_mx,
+                    b_mx,
+                    block_size,
+                    out_mx_bool_mask,
+                    a_mx_bool_mask,
+                    b_mx_bool_mask,
+                    cotan,
+                )
+                run_test(a_mx, b_mx, block_size, out_mx_bool_mask, None, None, cotan)
+                run_test(
+                    a_mx, b_mx, block_size, None, a_mx_bool_mask, b_mx_bool_mask, cotan
+                )
+
+                # Float block masks
+                run_test(
+                    a_mx, b_mx, block_size, out_mx_mask, a_mx_mask, b_mx_mask, cotan
+                )
+                run_test(a_mx, b_mx, block_size, None, a_mx_mask, b_mx_mask, cotan)
+                run_test_mask_vjp(
+                    a_mx, b_mx, block_size, out_mx_mask, a_mx_mask, b_mx_mask, cotan
+                )
+                run_test_mask_vjp(
+                    a_mx, b_mx, block_size, None, a_mx_mask, b_mx_mask, cotan
+                )
+
+        shapes = (
+            (16, 16, 16, 32),
+            (64, 64, 16, 32),
+            (128, 128, 128, 32),
+            (256, 256, 128, 64),
+            (1, 128, 128, 32),
+            (256, 1, 128, 64),
+        )
+
+        for M, N, K, block_size in shapes:
+            test_shape(M, N, K, block_size)
+
+        # Test broadcasting
+        test_shape(64, 64, 64, 32, batch_A=(1, 2), batch_B=(2, 2))
+        test_shape(1, 128, 128, 32, batch_A=(1, 2), batch_B=(2, 2))
+        test_shape(128, 1, 128, 32, batch_A=(1, 2), batch_B=(2, 2))
+
+        a_np = np.ones((128, 256)).astype(np.float32)
+        b_np = np.ones((128, 1)).astype(np.float32)
+        d_np = np.ones((1, 256)).astype(np.float32)
+        a_mask_np = np.random.normal(size=(4, 8)).astype(np.float32)
+        b_mask_np = np.ones((4, 1)).astype(np.bool_)
+        d_mask_np = np.ones((1, 8)).astype(np.bool_)
+        c_mask_np = np.random.normal(size=(8, 1)).astype(np.float32)
+        e_mask_np = np.random.normal(size=(1, 4)).astype(np.float32)
+
+        a_mask_np[a_mask_np < 0.0] = 0.0
+        e_mask_np[e_mask_np < 0.0] = 0.0
+        c_mask_np[c_mask_np < 0.0] = 0.0
+
+        a_mx = mx.array(a_np)
+        b_mx = mx.array(b_np)
+        d_mx = mx.array(d_np)
+        a_mask_mx = mx.array(a_mask_np)
+        b_mask_mx = mx.array(b_mask_np)
+        d_mask_mx = mx.array(d_mask_np)
+        e_mask_mx = mx.array(e_mask_np)
+        c_mask_mx = mx.array(c_mask_np)
+
+        c_mx = mx.block_masked_mm(a_mx.T, b_mx, 32, c_mask_mx, a_mask_mx.T, b_mask_mx)
+        e_mx = mx.block_masked_mm(d_mx, a_mx.T, 32, e_mask_mx, d_mask_mx, a_mask_mx.T)
+
+        a_mask_np = np.broadcast_to(np.expand_dims(a_mask_np, (-3, -1)), (4, 32, 8, 32))
+        a_mask_np = a_mask_np.reshape((128, 256))
+        a_np *= a_mask_np
+
+        c_np = a_np.T @ b_np
+        e_np = d_np @ a_np.T
+
+        c_mask_np = np.broadcast_to(np.expand_dims(c_mask_np, (-2)), (8, 32, 1))
+        c_mask_np = c_mask_np.reshape((256, 1))
+        c_np *= c_mask_np
+
+        e_mask_np = np.broadcast_to(np.expand_dims(e_mask_np, (-1)), (1, 4, 32))
+        e_mask_np = e_mask_np.reshape((1, 128))
+        e_np *= e_mask_np
+
+        self.assertTrue(np.allclose(c_mx, c_np, atol=1e-5))
+        self.assertTrue(np.allclose(e_mx, e_np, atol=1e-5))
+
+    def test_gather_matmul(self):
+        def np_gather_mm(a, b, lhs_indices=None, rhs_indices=None):
+            a = a.reshape((-1, a.shape[-2], a.shape[-1]))
+            b = b.reshape((-1, b.shape[-2], b.shape[-1]))
+            lhs_indices = lhs_indices or np.arange(a.shape[0])
+            rhs_indices = rhs_indices or np.arange(b.shape[0])
+            a = a[lhs_indices, :, :]
+            b = b[rhs_indices, :, :]
+            out = a @ b
+            return out
+
+        def test_shape(
+            M,
+            N,
+            K,
+            np_dtype=np.float32,
+            batch_A=(),
+            batch_B=(),
+            lhs_indices=None,
+            rhs_indices=None,
+        ):
+            with self.subTest(
+                M=M,
+                N=N,
+                K=K,
+                np_dtype=np_dtype,
+                batch_A=batch_A,
+                batch_B=batch_B,
+                lhs_indices=lhs_indices,
+                rhs_indices=rhs_indices,
+            ):
+                a_np = np.random.normal(size=batch_A + (M, K)).astype(np_dtype)
+                b_np = np.random.normal(size=batch_B + (K, N)).astype(np_dtype)
+
+                a_mx = mx.array(a_np)
+                b_mx = mx.array(b_np)
+
+                out_np = np_gather_mm(a_np, b_np, lhs_indices, rhs_indices)
+
+                lhs_indices_mx = None if lhs_indices is None else mx.array(lhs_indices)
+                rhs_indices_mx = None if rhs_indices is None else mx.array(rhs_indices)
+
+                out_mx = mx.gather_mm(a_mx, b_mx, lhs_indices_mx, rhs_indices_mx)
+
+                self.assertTrue(np.allclose(out_np, out_mx, atol=1e-5))
+
+        inputs = (
+            {
+                "batch_A": (1,),
+                "lhs_indices": (0,),
+                "batch_B": (3,),
+                "rhs_indices": (2, 1),
+            },
+            {
+                "batch_A": (1,),
+                "lhs_indices": None,
+                "batch_B": (3,),
+                "rhs_indices": (2, 1),
+            },
+            {
+                "batch_A": (2,),
+                "lhs_indices": None,
+                "batch_B": (3,),
+                "rhs_indices": (2, 1),
+            },
+            {
+                "batch_A": (3,),
+                "lhs_indices": (0, 2),
+                "batch_B": (1,),
+                "rhs_indices": (0,),
+            },
+            {
+                "batch_A": (5,),
+                "lhs_indices": (0, 2),
+                "batch_B": (3,),
+                "rhs_indices": (2, 1),
+            },
+            {
+                "batch_A": (4, 2),
+                "lhs_indices": (
+                    (7, 6),
+                    (5, 4),
+                    (1, 2),
+                ),
+                "batch_B": (4, 1),
+                "rhs_indices": ((2,), (0,), (1,)),
+            },
+        )
+
+        for kwargs in inputs:
+            test_shape(32, 32, 32, **kwargs)
+            test_shape(16, 1, 16, **kwargs)
+
+        # Add tests for broadcasting
+        a_np = np.random.normal(size=(5, 32, 32)).astype(np.float32)
+        b_np = np.random.normal(size=(3, 32, 32)).astype(np.float32)
+        a_mx = mx.array(a_np)
+        b_mx = mx.array(b_np)
+
+        # Numpy
+        a_np = a_np.reshape((5, 1, 32, 32))
+        b_np = b_np.reshape((1, 3, 32, 32))
+
+        a_np = np.broadcast_to(a_np, (5, 4, 32, 32))
+        b_np = np.broadcast_to(b_np, (2, 3, 32, 32)).swapaxes(1, 0)
+
+        lhs_indices = [0, 13, 12]
+        rhs_indices = [0, 3, 5]
+
+        out_np = np_gather_mm(a_np, b_np, lhs_indices, rhs_indices)
+
+        # MLX
+        a_mx = a_mx.reshape((5, 1, 32, 32))
+        b_mx = b_mx.reshape((1, 3, 32, 32))
+
+        a_mx = mx.broadcast_to(a_mx, (5, 4, 32, 32))
+        b_mx = mx.broadcast_to(b_mx, (2, 3, 32, 32)).swapaxes(1, 0)
+
+        lhs_indices_mx = mx.array(lhs_indices)
+        rhs_indices_mx = mx.array(rhs_indices)
+
+        out_mx = mx.gather_mm(a_mx, b_mx, lhs_indices_mx, rhs_indices_mx)
+
+        self.assertTrue(np.allclose(out_np, out_mx, atol=1e-5))
+
+        # Gemv test
+        a_np = np.random.normal(size=(5, 1, 32)).astype(np.float32)
+        b_np = np.random.normal(size=(3, 16, 32)).astype(np.float32)
+        a_mx = mx.array(a_np)
+        b_mx = mx.array(b_np)
+
+        lhs_indices = [3, 1]
+        rhs_indices = [0, 2]
+
+        b_np_t = np.swapaxes(b_np, -1, -2)
+        out_np = np_gather_mm(a_np, b_np_t, lhs_indices, rhs_indices)
+
+        lhs_indices_mx = mx.array(lhs_indices)
+        rhs_indices_mx = mx.array(rhs_indices)
+
+        b_mx_t = mx.swapaxes(b_mx, -1, -2)
+        out_mx = mx.gather_mm(a_mx, b_mx_t, lhs_indices_mx, rhs_indices_mx)
+
+        self.assertTrue(np.allclose(out_np, out_mx, atol=1e-5))
+
+    def test_gather_matmul_grad(self):
+        lhs_indices = mx.array([[7, 6], [4, 1], [0, 2]], dtype=mx.uint32)
+        rhs_indices = mx.array([[2], [0], [1]], dtype=mx.uint32)
+
+        def f_ref(a, b):
+            lhs_indices_ = mx.broadcast_to(lhs_indices, (3, 2))
+            rhs_indices_ = mx.broadcast_to(rhs_indices, (3, 2))
+            M = a.shape[-2]
+            N = b.shape[-1]
+            K = a.shape[-1]
+
+            a = a.reshape((-1, M, K))
+            b = b.reshape((-1, K, N))
+
+            a = mx.take(a, lhs_indices_, 0)
+            b = mx.take(b, rhs_indices_, 0)
+
+            return a @ b
+
+        def f_test(a, b):
+            return mx.gather_mm(a, b, lhs_indices, rhs_indices)
+
+        a_mx = mx.random.normal((4, 2, 32, 32))
+        b_mx = mx.random.normal((4, 1, 32, 32))
+
+        out_test = f_test(a_mx, b_mx)
+        out_ref = f_ref(a_mx, b_mx)
+
+        self.assertTrue(mx.allclose(out_test, out_ref, atol=1e-5))
+
+        cotan = mx.ones_like(out_test)
+        out_ref, dout_ref = mx.vjp(
+            f_ref,
+            [a_mx, b_mx],
+            [cotan],
+        )
+        out_test, dout_test = mx.vjp(
+            f_test,
+            [a_mx, b_mx],
+            [cotan],
+        )
+
+        for r, t in zip(dout_ref, dout_test):
+            self.assertEqual(r.shape, t.shape)
+            self.assertTrue(mx.allclose(r, t, atol=1e-4).item())
+
+    def test_gather_mm_sorted(self):
+        def gather_mm_ref(a, b, rhs):
+            b = b[rhs]
+            return a @ b
+
+        def gather_mm_test(a, b, rhs):
+            return mx.gather_mm(a, b, rhs_indices=rhs, sorted_indices=True)
+
+        a = mx.random.normal((100, 1, 100))
+        b = mx.random.normal((8, 100, 100))
+        rhs = mx.sort(mx.random.randint(0, 8, shape=(100,)))
+
+        c1 = gather_mm_ref(a, b, rhs)
+        c2 = gather_mm_test(a, b, rhs)
+        self.assertTrue(mx.allclose(c1, c2, atol=1e-4))
+
+        cotan = mx.random.normal(c1.shape)
+        c1, dc1 = mx.vjp(
+            lambda a, b: gather_mm_ref(a, b, rhs),
+            [a, b],
+            [cotan],
+        )
+        c2, dc2 = mx.vjp(
+            lambda a, b: gather_mm_test(a, b, rhs),
+            [a, b],
+            [cotan],
+        )
+        self.assertTrue(mx.allclose(c1[0], c2[0], atol=1e-4))
+        self.assertTrue(mx.allclose(dc1[0], dc2[0], atol=1e-4))
+        self.assertTrue(mx.allclose(dc1[1], dc2[1], atol=1e-4))
+
+    def test_segmented_mm(self):
+        def segmented_mm_ref(a, b, s):
+            s = s.tolist()
+            c = []
+            for s1, s2 in s:
+                c.append(a[:, s1:s2] @ b[s1:s2, :])
+            return mx.stack(c, axis=0)
+
+        shapes = [
+            (10, 10, 10),
+            (10, 10, 1000),
+            (1000, 1000, 1000),
+        ]
+        all_segments = [[0, 0, 1.0], [0, 0.5, 1.0], [r / 9 for r in range(10)]]
+
+        for M, N, K in shapes:
+            for s in all_segments:
+                segments = []
+                for i in range(len(s) - 1):
+                    segments.append([s[i], s[i + 1]])
+                segments = mx.array(segments)
+                segments = mx.minimum(K - 1, (K * segments).astype(mx.uint32))
+                a = mx.random.normal((M, K))
+                b = mx.random.normal((K, N))
+                c1 = segmented_mm_ref(a, b, segments)
+                c2 = mx.segmented_mm(a, b, segments)
+                self.assertTrue(mx.allclose(c1, c2, atol=1e-4))
+
+                a = mx.random.normal((K, M))
+                b = mx.random.normal((K, N))
+                c1 = segmented_mm_ref(a.T, b, segments)
+                c2 = mx.segmented_mm(a.T, b, segments)
+                self.assertTrue(mx.allclose(c1, c2, atol=1e-4))
+
+                a = mx.random.normal((M, K))
+                b = mx.random.normal((N, K))
+                c1 = segmented_mm_ref(a, b.T, segments)
+                c2 = mx.segmented_mm(a, b.T, segments)
+                self.assertTrue(mx.allclose(c1, c2, atol=1e-4))
+
+                a = mx.random.normal((K, M))
+                b = mx.random.normal((N, K))
+                c1 = segmented_mm_ref(a.T, b.T, segments)
+                c2 = mx.segmented_mm(a.T, b.T, segments)
+                self.assertTrue(mx.allclose(c1, c2, atol=1e-4))
+
+        with self.assertRaises(ValueError):
+            a = mx.ones((2, 10, 10))
+            s = mx.array([[0, 5], [5, 10]]).astype(mx.uint32)
+            mx.segmented_mm(a, a, s)
+
+        a = mx.ones((10, 1000))
+        s = mx.random.randint(0, 16, shape=(1000,))
+        s = mx.zeros(16, dtype=s.dtype).at[s].add(1)
+        s = mx.sort(s)
+        s = mx.cumsum(s)
+        s = mx.concatenate([mx.array([0]), s])
+        s = mx.as_strided(s, (16, 2), (1, 1))
+        s = mx.reshape(s, (2, 2, 4, 2))
+        c = mx.segmented_mm(a, a.T, s)
+        self.assertEqual(c.shape, (2, 2, 4, 10, 10))
+
+    def test_gemv_gemm_same_precision(self):
+        mx.random.seed(0)
+        N = 256
+        if mx.is_available(mx.gpu):
+            t = mx.bfloat16
+            a = mx.random.normal([1, N]).astype(t)
+            b = mx.concatenate([a, a], axis=0).astype(t)
+            c = mx.random.normal([N, 64]).astype(t)
+            out_gemv = a @ c
+            out_gemm = (b @ c)[0]
+            self.assertTrue(mx.allclose(out_gemv, out_gemm))
+
+    def test_complex_gemv(self):
+        M = 16
+        N = 50
+
+        def rand(shape):
+            return mx.random.uniform(shape=shape) + 1j * mx.random.uniform(shape=shape)
+
+        a = rand((M, N))
+        b = rand((N, 1))
+        c = mx.matmul(a, b)
+        c_np = np.matmul(a, b)
+        self.assertTrue(np.allclose(c, c_np))
+
+        # Transposed
+        a = rand((N, M))
+        b = rand((N, 1))
+        c = mx.matmul(a.T, b)
+        c_np = np.matmul(np.array(a).T, b)
+        self.assertTrue(np.allclose(c, c_np))
+
+        # Check shapes
+        a = mx.random.normal((2, 3)).astype(mx.complex64)
+        b = mx.random.normal((3,))
+        self.assertEqual((a @ b).shape, (2,))
+
+        a = mx.random.normal((2, 3)).astype(mx.complex64)
+        b = mx.random.normal((3,))
+        c = mx.random.normal((2,))
+        self.assertEqual(mx.addmm(c, a, b).shape, (2,))
+
+    def test_complex_gemm(self):
+        M = 16
+        K = 50
+        N = 32
+
+        def rand(shape):
+            return mx.random.uniform(shape=shape) + 1j * mx.random.uniform(shape=shape)
+
+        a = rand((M, K))
+        b = rand((K, N))
+        c = mx.matmul(a, b)
+        c_np = np.matmul(a, b)
+        self.assertTrue(np.allclose(c, c_np))
+
+        # Test addmm
+        a = rand((M, K))
+        b = rand((K, N))
+        c = rand((M, N))
+        out = mx.addmm(c, a, b, 2.0, 2.0)
+        out_np = 2.0 * np.matmul(a, b) + 2.0 * c
+        self.assertTrue(np.allclose(out, out_np))
+
+        # complex with real
+        a = rand((M, K)).real
+        b = rand((K, N))
+        c = mx.matmul(a, b)
+        c_np = np.matmul(a, b)
+        self.assertTrue(np.allclose(out, out_np))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_compile.py b/ml-stable-diffusion/mlx/python/tests/test_compile.py
new file mode 100644
index 0000000000000000000000000000000000000000..b786730270c6d9a820cc6e02e48d1cc2ac032d62
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_compile.py
@@ -0,0 +1,1139 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import gc
+import inspect
+import io
+import math
+import unittest
+from functools import partial, wraps
+from io import StringIO
+
+import mlx.core as mx
+import mlx_tests
+
+
+class TestCompile(mlx_tests.MLXTestCase):
+    def test_simple_compile(self):
+        def fun(x, y):
+            return x + y
+
+        compiled_fn = mx.compile(fun)
+        compiled_fn = mx.compile(fun)
+        x = mx.array(1.0)
+        y = mx.array(1.0)
+        out = compiled_fn(x, y)
+        self.assertEqual(out.item(), 2.0)
+
+        # Try again
+        out = compiled_fn(x, y)
+        self.assertEqual(out.item(), 2.0)
+
+        # Change sizes
+        x = mx.array([1.0, 2.0])
+        out = compiled_fn(x, y)
+        self.assertTrue(mx.array_equal(out, mx.array([2.0, 3.0])))
+
+        y = mx.array([1.0, 2.0])
+        out = compiled_fn(x, y)
+        self.assertTrue(mx.array_equal(out, mx.array([2.0, 4.0])))
+
+        # Change types
+        x = mx.array([1, 2], mx.int32)
+        y = mx.array([1, 2], mx.int32)
+        out = compiled_fn(x, y)
+        self.assertEqual(out.dtype, mx.int32)
+        self.assertTrue(mx.array_equal(out, mx.array([2, 4])))
+
+    def test_compile_grad(self):
+        def loss_fn(x):
+            return mx.exp(x).sum()
+
+        grad_fn = mx.grad(loss_fn)
+
+        x = mx.array([0.5, -0.5, 1.2])
+        dfdx = grad_fn(x)
+        compile_grad_fn = mx.compile(grad_fn)
+        c_dfdx = grad_fn(x)
+
+        self.assertTrue(mx.allclose(c_dfdx, dfdx))
+
+        # Run it again without calling compile
+        c_dfdx = compile_grad_fn(x)
+        self.assertTrue(mx.allclose(c_dfdx, dfdx))
+
+        # Run it again with calling compile
+        c_dfdx = mx.compile(grad_fn)(x)
+        self.assertTrue(mx.allclose(c_dfdx, dfdx))
+
+        # Value and grad
+        def loss_fn(x):
+            return mx.exp(x).sum(), mx.sin(x)
+
+        val_and_grad_fn = mx.value_and_grad(loss_fn)
+        (loss, val), dfdx = val_and_grad_fn(x)
+        (c_loss, c_val), c_dfdx = mx.compile(val_and_grad_fn)(x)
+
+        self.assertTrue(mx.allclose(c_dfdx, dfdx))
+        self.assertTrue(mx.allclose(c_loss, loss))
+        self.assertTrue(mx.allclose(c_val, val))
+
+    def test_compile_inputs_with_primitives(self):
+        x = mx.array([1, 2, 3])
+        y = mx.array([1, 2, 3])
+        for _ in range(5):
+            x = x + y
+            y = y + 1
+
+        def fun(x, y):
+            return x * y
+
+        out = fun(x, y)
+
+        x = mx.array([1, 2, 3])
+        y = mx.array([1, 2, 3])
+        for _ in range(5):
+            x = x + y
+            y = y + 1
+
+        c_out = mx.compile(fun)(x, y)
+        self.assertTrue(mx.array_equal(out, c_out))
+
+        # Try again
+        c_out = mx.compile(fun)(x, y)
+        self.assertTrue(mx.array_equal(out, c_out))
+
+    def test_compile_with_closure(self):
+        x = mx.array(1)
+
+        def closure(y):
+            return x + y
+
+        compiled = mx.compile(closure)
+        out = compiled(mx.array(1))
+        self.assertEqual(out.item(), 2)
+
+        # Try again
+        out = compiled(mx.array(1))
+        self.assertEqual(out.item(), 2)
+
+        # Change the shape of the enclosed variable
+        x = mx.array([1, 2])
+        out = compiled(mx.array(1))
+
+        # We still get the original input (closures are not updated)
+        self.assertEqual(out.item(), 2)
+
+        # Try with a tree of enclosed variables
+        x = {"a": mx.array(1), "b": mx.array(2)}
+
+        def closure(y):
+            return x["a"] + y + x["b"]
+
+        compiled = mx.compile(closure)
+        out = compiled(mx.array(1))
+        self.assertEqual(out.item(), 4)
+
+        # Change the shape of one input
+        x["a"] = mx.array([4, 5])
+        out = compiled(mx.array(1))
+        self.assertEqual(out.item(), 4)
+
+        x["b"] = mx.array([-6, -8])
+        out = compiled(mx.array(1))
+        self.assertEqual(out.item(), 4)
+
+        # Enclosed variable is not evaluated yet
+        x = mx.array(1)
+        x = x + x
+
+        def closure(y):
+            return x + y
+
+        compiled = mx.compile(closure)
+        out = compiled(mx.array(2))
+        self.assertEqual(out.item(), 4)
+
+        # And again
+        out = compiled(mx.array(2))
+        self.assertEqual(out.item(), 4)
+
+    def test_function_creates_array(self):
+        def fun(x):
+            return x + mx.array(1)
+
+        cfun = mx.compile(fun)
+        out = cfun(mx.array(3))
+        self.assertEqual(out.item(), 4)
+
+        # And again
+        out = cfun(mx.array(3))
+        self.assertEqual(out.item(), 4)
+
+    def test_enable_disable(self):
+        def fun(x):
+            y = x + 1
+            z = x + 1
+            return y + z
+
+        def count_prims(outputs):
+            buf = io.StringIO()
+            mx.export_to_dot(buf, outputs)
+            buf.seek(0)
+            return len([l for l in buf.read().split() if "label" in l])
+
+        x = mx.array(1.0)
+        cfun = mx.compile(fun)
+        n_compiled = count_prims(cfun(x))
+
+        # Check disabled
+        mx.disable_compile()
+        n_uncompiled = count_prims(cfun(x))
+        self.assertTrue(n_compiled < n_uncompiled)
+
+        # Check renabled
+        mx.enable_compile()
+        n_enable_compiled = count_prims(cfun(x))
+        self.assertEqual(n_compiled, n_enable_compiled)
+
+    def test_compile_two_input_grad(self):
+        def loss(w, x):
+            y = x * w
+            return (y * mx.exp(y)).sum()
+
+        x = mx.array([1.0, 0.5, 2.0, -0.5])
+        w = mx.array([-1.0, 0.3, 1.0, -0.9])
+
+        expected_grad = mx.grad(loss)(w, x)
+        compiled_grad = mx.compile(mx.grad(loss))(w, x)
+        self.assertTrue(mx.allclose(expected_grad, compiled_grad))
+
+    def test_vmap_compiled(self):
+        def simple_unary(x):
+            return -mx.exp(x)
+
+        x = mx.array([[1.0, 2.0], [2.0, 3.0]])
+
+        expected_out = mx.vmap(simple_unary)(x)
+        out = mx.vmap(mx.compile(simple_unary))(x)
+        self.assertTrue(mx.allclose(expected_out, out))
+
+        def simple_binary(x, y):
+            return mx.abs(mx.exp(x + y) + y)
+
+        x = mx.array([[1.0, -3.0], [0.5, -0.5]])
+        y = mx.array([[2.0, -1.0], [0.25, -0.25]])
+
+        expected_out = mx.vmap(simple_binary)(x, y)
+        out = mx.vmap(mx.compile(simple_binary))(x, y)
+        self.assertTrue(mx.allclose(expected_out, out))
+
+        expected_out = mx.vmap(simple_binary, in_axes=(0, 1))(x, y)
+        out = mx.vmap(mx.compile(simple_binary), in_axes=(0, 1))(x, y)
+        self.assertTrue(mx.allclose(expected_out, out))
+
+        y = mx.array([0.25, -0.25])
+        expected_out = mx.vmap(simple_binary, in_axes=(0, None))(x, y)
+        out = mx.vmap(mx.compile(simple_binary), in_axes=(0, None))(x, y)
+        self.assertTrue(mx.allclose(expected_out, out))
+
+        def simple_unary_outer(x):
+            x = mx.abs(x)
+
+            @mx.compile
+            def simple_unary_inner(z):
+                return -mx.exp(x)
+
+            return simple_unary_inner(x)
+
+        expected_out = -mx.exp(mx.abs(x))
+        out = mx.vmap(simple_unary_outer)(x)
+        self.assertTrue(mx.allclose(expected_out, out))
+
+    def test_vjp_vjp_compiled(self):
+        def simple_unary(x):
+            return -mx.exp(x)
+
+        x = mx.array([[1.0, 2.0], [2.0, 3.0]])
+        y = mx.array([[1.0, 1.0], [1.0, 1.0]])
+
+        expected_out, expected_vjp_out = mx.vjp(simple_unary, (x,), (y,))
+        out, vjp_out = mx.vjp(mx.compile(simple_unary), (x,), (y,))
+        self.assertTrue(mx.allclose(expected_vjp_out[0], vjp_out[0]))
+        self.assertTrue(mx.allclose(expected_out[0], out[0]))
+
+        expected_out, expected_jvp_out = mx.jvp(simple_unary, (x,), (y,))
+        out, jvp_out = mx.jvp(mx.compile(simple_unary), (x,), (y,))
+        self.assertTrue(mx.allclose(expected_jvp_out[0], jvp_out[0]))
+        self.assertTrue(mx.allclose(expected_out[0], out[0]))
+
+        def simple_binary(x, y):
+            return mx.abs(mx.exp(x + y) + y)
+
+        x = mx.array([[1.0, -3.0], [0.5, -0.5]])
+        y = mx.array([[2.0, -1.0], [0.25, -0.25]])
+        cotans = mx.ones_like(x)
+
+        expected_out, expected_vjp_out = mx.vjp(simple_binary, (x, y), (cotans,))
+        out, vjp_out = mx.vjp(mx.compile(simple_binary), (x, y), (cotans,))
+        self.assertTrue(mx.allclose(expected_out[0], out[0]))
+        self.assertTrue(mx.allclose(expected_vjp_out[0], vjp_out[0]))
+        self.assertTrue(mx.allclose(expected_vjp_out[1], vjp_out[1]))
+
+        tans = (mx.ones_like(x), mx.ones_like(y))
+        expected_out, expected_jvp_out = mx.jvp(simple_binary, (x, y), tans)
+        out, jvp_out = mx.jvp(mx.compile(simple_binary), (x, y), tans)
+        self.assertTrue(mx.allclose(expected_jvp_out[0], jvp_out[0]))
+        self.assertTrue(mx.allclose(expected_out[0], out[0]))
+
+    def test_transform_over_eval_compiled(self):
+        def outer(x):
+            y = mx.exp(mx.abs(x))
+            mx.eval(y)
+            return y.sum()
+
+        x = mx.array([2.0, -1.0, 0.5])
+        dfdx = mx.grad(outer)(x)
+
+        @mx.compile
+        def simple_unary(x):
+            return mx.exp(mx.abs(x))
+
+        def outer(x):
+            y = simple_unary(x)
+            mx.eval(y)
+            return y.sum()
+
+        cdfdx = mx.grad(outer)(x)
+        self.assertTrue(mx.allclose(dfdx, cdfdx))
+
+    def test_compile_capture(self):
+        # Test update captured state outside compiled function
+        state = {"y": mx.array(2)}
+
+        @partial(mx.compile, inputs=state)
+        def test_state(x):
+            x = x + state["y"]
+            return x
+
+        test_state(mx.array(1))
+        # Check the state is unchanged
+        self.assertEqual(state["y"], 2)
+
+        # Check the udpated state is used
+        state["y"] = mx.array(3)
+        out = test_state(mx.array(1))
+        self.assertEqual(out.item(), 4)
+
+        # Capture list
+        state = [mx.array(2)]
+
+        @partial(mx.compile, inputs=state)
+        def test_state(x):
+            x = x + state[0]
+            return x
+
+        out = test_state(mx.array(1))
+        self.assertEqual(out.item(), 3)
+        state[0] = mx.array(3)
+        out = test_state(mx.array(1))
+        self.assertEqual(out.item(), 4)
+
+        # Capture tuple of list
+        state = ([mx.array(2)],)
+
+        @partial(mx.compile, inputs=state)
+        def test_state(x):
+            x = x + state[0][0]
+            return x
+
+        out = test_state(mx.array(1))
+        self.assertEqual(out.item(), 3)
+        state[0][0] = mx.array(3)
+        out = test_state(mx.array(1))
+        self.assertEqual(out.item(), 4)
+
+        # Test state updated inside compiled function
+        state = {}
+
+        @partial(mx.compile, outputs=state)
+        def test_state(x):
+            state["y"] = x + 3
+            return mx.abs(x)
+
+        test_state(mx.array(-1))
+        self.assertEqual(state["y"].item(), 2)
+
+        # Test state changed inside compiled function
+        # triggers recompile
+        state = {}
+
+        @partial(mx.compile, inputs=state, outputs=state)
+        def test_state(x):
+            y = state.get("y", mx.array(0))
+            state["y"] = x + y
+            return x + 2 * y
+
+        test_state(mx.array(1))
+        self.assertEqual(state["y"].item(), 1)
+        test_state(mx.array(1))
+        self.assertEqual(state["y"].item(), 2)
+
+    def test_compile_rng(self):
+        @partial(mx.compile, inputs=mx.random.state, outputs=mx.random.state)
+        def fun():
+            return mx.random.uniform(shape=(10, 10))
+
+        self.assertFalse(mx.allclose(fun(), fun(), 1e-2, 1e-2))
+
+    def test_compile_kwargs(self):
+        @mx.compile
+        def fun(x, y, z):
+            return x + y + z
+
+        x = mx.array(1)
+        y = mx.array(2)
+        z = mx.array(3)
+        out = fun(x, y=y, z=z)
+        self.assertEqual(out.item(), 6)
+
+    def test_shapeless_compile(self):
+        y = 1
+
+        @partial(mx.compile, shapeless=True)
+        def fun(x):
+            return x + y
+
+        x = mx.array([1, 2])
+        self.assertTrue(mx.array_equal(fun(x), mx.array([2, 3])))
+
+        # The function is not recompiled, so the change
+        # to y should not be reflected in the output
+        y = 2
+        x = mx.array([1, 2, 3])
+        self.assertTrue(mx.array_equal(fun(x), mx.array([2, 3, 4])))
+
+        # Type change recompiles
+        x = mx.array([1.0, 2.0, 3.0])
+        self.assertTrue(mx.array_equal(fun(x), mx.array([3.0, 4.0, 5.0])))
+
+        # Dim change recompiles
+        x = mx.array([[1, 2, 3]])
+        self.assertTrue(mx.array_equal(fun(x), mx.array([[3, 4, 5]])))
+
+    def test_shapeless_compile_with_broadcasts(self):
+        x = mx.ones((2, 2))
+        y = mx.array([2, 2])
+
+        def fun(x, y):
+            return x * y
+
+        cfun = mx.compile(fun, shapeless=True)
+        self.assertTrue(mx.array_equal(cfun(x, y), fun(x, y)))
+        self.assertTrue(mx.array_equal(cfun(y, x), fun(y, x)))
+        y = mx.array([[3]])
+        self.assertTrue(mx.array_equal(cfun(x, y), fun(x, y)))
+        self.assertTrue(mx.array_equal(cfun(y, x), fun(y, x)))
+
+    def test_shapeless_compile_with_reduction(self):
+        # Test shapeless compile with a reduction
+        z = 1
+
+        @partial(mx.compile, shapeless=True)
+        def fun(x, y):
+            return x + y.sum(0, keepdims=True) + z
+
+        x = mx.ones((2, 2), mx.int32)
+        y = mx.ones((2, 2), mx.int32)
+        self.assertTrue(mx.array_equal(fun(x, y), mx.full(shape=(2, 2), vals=4)))
+        x = mx.ones((3, 3), mx.int32)
+        y = mx.ones((3, 3), mx.int32)
+        z = 2
+        self.assertTrue(mx.array_equal(fun(x, y), mx.full(shape=(3, 3), vals=5)))
+
+        x1 = mx.array([[1, 2], [3, 4], [5, 6]])
+        x2 = mx.array([[1, 2]])
+
+        def fun(x):
+            return x * x.sum(-1, keepdims=True)
+
+        cfun = mx.compile(fun, shapeless=True)
+        mx.eval(cfun(x1))
+        self.assertTrue(mx.array_equal(fun(x2), cfun(x2)))
+
+        def fun(x):
+            return x * x.sum(-1, keepdims=False)
+
+        cfun = mx.compile(fun, shapeless=True)
+        self.assertTrue(mx.array_equal(fun(x2), cfun(x2)))
+
+    def test_shapeless_compile_unflatten(self):
+        x = mx.zeros((1, 1, 4 * 32))
+
+        def fun(x):
+            return mx.unflatten(x, -1, (4, -1))
+
+        self.assertEqual(mx.compile(fun, shapeless=True)(x).shape, (1, 1, 4, 32))
+
+    def test_shapeless_compile_gather(self):
+        x = mx.zeros((1, 1, 32))
+
+        def fun(x):
+            return x[:, -1, :]
+
+        self.assertEqual(mx.compile(fun, shapeless=True)(x).shape, (1, 32))
+
+    def test_compile_with_constant(self):
+        # Test float
+        @partial(mx.compile)
+        def fun(x, y):
+            return x + y
+
+        z = fun(mx.array(1.0), 1.0)
+        self.assertEqual(z.item(), 2.0)
+
+        z = fun(mx.array(1.0), 2.0)
+        self.assertEqual(z.item(), 3.0)
+
+        z = fun(mx.array(1.0), y=1.0)
+        self.assertEqual(z.item(), 2.0)
+
+        z = fun(mx.array(1.0), y=3.0)
+        self.assertEqual(z.item(), 4.0)
+
+        # Test tuple
+        @partial(mx.compile)
+        def fun(x, y=(1, 2)):
+            return x + y[0] + y[1]
+
+        z = fun(mx.array(1))
+        self.assertEqual(z.item(), 4)
+
+        z = fun(mx.array(1), (2, 2))
+        self.assertEqual(z.item(), 5)
+
+        z = fun(mx.array(1), (2, 1))
+        self.assertEqual(z.item(), 4)
+
+        # Test bool
+        @partial(mx.compile)
+        def fun(x, y):
+            if y:
+                return x + 1
+            else:
+                return x + 2
+
+        z = fun(mx.array(1), True)
+        self.assertEqual(z.item(), 2)
+
+        z = fun(mx.array(1), False)
+        self.assertEqual(z.item(), 3)
+
+        # Test string
+        @partial(mx.compile)
+        def fun(x, y):
+            if y == "one":
+                return x + 1
+            else:
+                return x + 2
+
+        z = fun(mx.array(1), "one")
+        self.assertEqual(z.item(), 2)
+
+        z = fun(mx.array(1), "two")
+        self.assertEqual(z.item(), 3)
+
+        # Test nested constant
+        @partial(mx.compile)
+        def fun(x, y):
+            if y[0][0] == 1:
+                return x + 1
+            else:
+                return x + 2
+
+        z = fun(mx.array(1), [[1]])
+        self.assertEqual(z.item(), 2)
+
+        z = fun(mx.array(1), [[0]])
+        self.assertEqual(z.item(), 3)
+
+        @partial(mx.compile)
+        def fun(x, a, b):
+            for ai in a:
+                for bi in b:
+                    x = bi * x + ai
+            return x
+
+        z = fun(mx.array(1), [1, 1], [2])
+        self.assertEqual(z.item(), 7)
+
+        z = fun(mx.array(1), [1], [1, 2])
+        self.assertEqual(z.item(), 5)
+
+        counter = [0]
+
+        @partial(mx.compile)
+        def fun(x, y):
+            counter[0] += 1
+            return x + y
+
+        z = fun(mx.array(1), 1)
+        self.assertEqual(z.item(), 2)
+
+        z = fun(1, mx.array(1))
+        self.assertEqual(z.item(), 2)
+
+        self.assertEqual(counter[0], 2)
+
+        y = 1.0
+
+        @mx.compile
+        def fun(x, constant):
+            return x + y
+
+        constant1 = "abc"
+        out = fun(mx.array(0.0), constant1)
+        self.assertEqual(out, mx.array(1.0))
+
+        # new object, same value, no recompilation
+        y = 2.0
+        constant2 = "abc".encode("utf-8").decode("utf-8")
+        out = fun(mx.array(0.0), constant2)
+        self.assertEqual(out, mx.array(1.0))
+
+        # same object, new value, recompilation
+        constant2 = "xyz"
+        out = fun(mx.array(0.0), constant2)
+        self.assertEqual(out, mx.array(2.0))
+
+    def test_compile_inf(self):
+        @mx.compile
+        def fun(x):
+            return mx.isinf(x + 2)
+
+        out = fun(mx.array([0.0]))
+        self.assertEqual(out.item(), False)
+
+    def test_unsupported_input_types(self):
+        class MyClass:
+            value = 1
+
+        @mx.compile
+        def fun(x, y):
+            return x + y.value
+
+        with self.assertRaises(ValueError):
+            out = fun(mx.array(0.0), MyClass())
+
+        with self.assertRaises(ValueError):
+            out = fun(mx.array(0.0), y=MyClass())
+
+    def test_compile_create_list(self):
+        @mx.compile
+        def fun():
+            return [0.1 * mx.zeros((2,)), 0.1 * mx.zeros((2,))]
+
+        out = fun()
+        mx.eval(out)
+
+    def test_compile_vjp(self):
+        def fun(w):
+            w1 = w + w
+            w2 = w + w
+            return w @ w1 + w2 @ w2
+
+        def step(w):
+            out, grad = mx.vjp(fun, (w,), (mx.array([[1.0, 1.0], [1.0, 1.0]]),))
+            return out[0], grad[0]
+
+        w = mx.zeros((2, 2))
+        mx.eval(w)
+
+        expected = step(w)
+        out = mx.compile(step)(w)
+        self.assertTrue(mx.allclose(expected[0], out[0]))
+        self.assertTrue(mx.allclose(expected[1], out[1]))
+
+        def fun(w1, w2, x):
+            x = x @ w1
+            y = x @ w2
+            x = x + y * y
+            return (x * x).sum()
+
+        w1 = mx.zeros((4, 4))
+        w2 = mx.zeros((4, 4))
+        x = mx.zeros((4, 4))
+
+        def step(w1, w2, x):
+            loss, gradient = mx.value_and_grad(fun)(w1, w2, x)
+            w1 = w1 + gradient
+            return loss, w1
+
+        mx.eval(x, w1, w2)
+        expected = step(w1, w2, x)
+        out = mx.compile(step)(w1, w2, x)
+
+        self.assertTrue(mx.allclose(expected[0], out[0]))
+        self.assertTrue(mx.allclose(expected[1], out[1]))
+
+    def test_shapeless_mean(self):
+        def mean(x):
+            return mx.mean(x, keepdims=True)
+
+        cfun = mx.compile(mean)
+        out = cfun(mx.ones((5, 5)))
+        self.assertTrue(mx.allclose(out, mx.array(1.0)))
+
+        cmean = mx.compile(mean, shapeless=True)
+
+        x = mx.ones(2)
+        out = cmean(x)
+        self.assertTrue(mx.allclose(out, mean(x)))
+
+        x = mx.ones(4)
+        out = cmean(x)
+        self.assertTrue(mx.allclose(out, mean(x)))
+
+        x = mx.ones(7)
+        out = cmean(x)
+        self.assertTrue(mx.allclose(out, mean(x)))
+
+    def test_compile_broadcast_only(self):
+        def fn(a):
+            a = mx.broadcast_to(a, (1,))
+            return a + a
+
+        out = mx.compile(fn)(mx.array(2.0))
+        # Make sure repr can be called
+        self.assertTrue(repr(out) is not None)
+        self.assertTrue(mx.array_equal(out, mx.array([4.0])))
+
+    def test_compile_with_long_name(self):
+        def fn(a, b):
+            for _ in range(10):
+                a = a - 1.0
+                b = b - 1.0
+            return a + b
+
+        out = mx.compile(fn)(mx.array(10.0), mx.array(20.0))
+        self.assertEqual(out.item(), 10.0)
+
+    def test_compile_multi_output(self):
+        def fn(x):
+            ys = [x]
+            for i in range(5):
+                ys.append(ys[-1] + x)
+            return ys, mx.sum(ys[-1])
+
+        x = mx.ones(1, dtype=mx.int32)
+        y1 = mx.compile(fn)(x)[1]
+        y2 = fn(x)[1]
+        self.assertEqual(y1.item(), y2.item())
+        self.assertEqual(y1.item(), 6)
+
+    def test_inf_constant(self):
+        def fn(x):
+            return mx.where(mx.isinf(x), 0, 1)
+
+        x = mx.array([0, float("inf"), 1], dtype=mx.bfloat16)
+        self.assertTrue(mx.array_equal(mx.compile(fn)(x), fn(x)))
+
+    def test_max_into_equal(self):
+        x = mx.random.uniform(shape=(1, 2, 2))
+        mx.eval(x)
+
+        def fn():
+            maxes = mx.max(x, axis=(1, 2), keepdims=True)
+            return x == maxes
+
+        out = mx.compile(fn)()
+        expected = fn()
+        self.assertTrue(mx.array_equal(expected, out))
+
+    def test_dtypes(self):
+        x = mx.array([0, 1, 2, 3])
+        dtypes = [mx.bool_, mx.int8, mx.uint8, mx.int16, mx.uint16]
+        for dtype in dtypes:
+            x = x.astype(dtype)
+            mx.eval(x)
+
+            def fn(x):
+                return x * 1 + 0
+
+            out = mx.compile(fn)(x)
+            expected = fn(x)
+            self.assertTrue(mx.array_equal(expected, out))
+
+    def test_compile_without_captured_inputs(self):
+        x = mx.array([1, 2, 3]) + 2
+
+        def fn(a):
+            y = x + 1
+            return a + y
+
+        with self.assertRaises(ValueError):
+            y = mx.compile(fn)(x)
+
+        x = mx.array([1.0, 2.0]) + mx.array([1.0, 2.0])
+        y = None
+
+        def fn(x):
+            nonlocal y
+            if y is None:
+                y = mx.array([1.0, 2.0])
+
+            y = y + x
+            return y
+
+        fn(x)
+        with self.assertRaises(ValueError):
+            y = mx.compile(fn)(x)
+
+    def test_compile_dynamic_dims(self):
+        a = mx.random.uniform(shape=(2,) * 10)
+        b = mx.random.uniform(shape=(2,) * 10)
+        a = a.T
+        mx.eval(a, b)
+
+        def fn(a, b):
+            return mx.abs(a + b)
+
+        out = mx.compile(fn)(a, b)
+        expected = fn(a, b)
+        self.assertTrue(mx.allclose(out, expected))
+
+    def test_compile_many_inputs(self):
+        inputs = [mx.ones((2, 2, 2, 2)) for _ in range(20)]
+        inputs[0] = inputs[0].T
+
+        @mx.compile
+        def fun(*inputs):
+            x = inputs[0]
+            for y in inputs[1:10]:
+                x = x + y
+            a = inputs[10]
+            for b in inputs[11:]:
+                a = a + b
+            return x + a
+
+        out = fun(*inputs)
+        self.assertTrue(mx.allclose(out, mx.full((2, 2), 20)))
+
+        @mx.compile
+        def fun(arrs):
+            for _ in range(6):
+                arrs = [x + y for x, y in zip(arrs[::2], arrs[1::2])]
+            return arrs[0]
+
+        arrs = [mx.array([1.0, 2.0]) for _ in range(64)]
+        out = fun(arrs)
+        self.assertTrue(mx.allclose(out, mx.array([64.0, 128.0])))
+
+        inputs = [mx.arange(16384).astype(mx.float16) for _ in range(8)]
+
+        def fun(inputs):
+            a = inputs[0] + inputs[1]
+            b = inputs[2] + inputs[3]
+            c = inputs[4] + inputs[5]
+            d = inputs[6] + inputs[7]
+            return a * b * c * d
+
+        out = mx.compile(fun)(inputs)
+        expected = fun(inputs)
+        self.assertTrue(mx.allclose(out, expected))
+
+    def test_compile_many_outputs(self):
+
+        @mx.compile
+        def fun(arr):
+            arrs = [arr] * 64
+            first_arrs = None
+            for _ in range(6):
+                arrs = [x + y for x, y in zip(arrs[::2], arrs[1::2])]
+                if first_arrs is None:
+                    first_arrs = arrs
+            return arrs[0], first_arrs
+
+        out = fun(mx.array([1.0, 2.0]))
+        self.assertTrue(mx.allclose(out[0], mx.array([64.0, 128.0])))
+
+    def test_shapeless_compile_matmul(self):
+        a = mx.array([0.0, 1.0, 2.0])
+        b = mx.array([0.0, 1.0, 2.0])
+
+        fun = mx.compile(lambda a, b: a @ b, shapeless=True)
+        self.assertTrue(mx.allclose(fun(a, b), a @ b))
+
+    def test_shapeless_compile_slice_update(self):
+        def fun(x):
+            x[2] = mx.array([3.0])
+            return x
+
+        cfun = mx.compile(fun, shapeless=True)
+
+        a = mx.array([0.0, 1.0, 2.0, 3.0])
+        self.assertTrue(mx.allclose(cfun(a), fun(a)))
+
+        a = mx.array([0.0, 1.0, 2.0, 3.0, 4.0])
+        self.assertTrue(mx.allclose(cfun(a), fun(a)))
+
+    def test_shapeless_compile_with_reshape(self):
+        def fun(x):
+            return x.reshape(x.shape[0] * x.shape[1], -1)
+
+        compiled_fun = mx.compile(fun, shapeless=True)
+
+        x = mx.zeros(shape=(2, 3, 4))
+        out = compiled_fun(x)
+        self.assertEqual(out.shape, (6, 4))
+
+        x = mx.zeros(shape=(2, 3, 8))
+        out = compiled_fun(x)
+        self.assertEqual(out.shape, (6, 8))
+
+        x = mx.zeros(shape=(5, 5, 5))
+
+        with self.assertRaises(ValueError):
+            compiled_fun(x)
+
+    def test_compile_shapeless_with_broadcast(self):
+        a = mx.array(0.0)
+        b = mx.ones((2, 2))
+
+        def fun(a):
+            return mx.broadcast_to(a, b.shape)
+
+        cfun = mx.compile(fun, shapeless=True)
+        # Works on the first shape
+        cfun(a)
+
+        # Fails on a different shape
+        with self.assertRaises(ValueError):
+            cfun(mx.array(0.0).reshape(1, 1, 1))
+
+        def fun(a, b):
+            return mx.broadcast_arrays(a, b)
+
+        cfun = mx.compile(fun, shapeless=True)
+        a, b = cfun(a, b)
+        self.assertEqual(a.shape, (2, 2))
+        self.assertEqual(b.shape, (2, 2))
+
+        # Batched matmul
+        a = mx.zeros((2, 1, 4, 2))
+        b = mx.zeros((3, 2, 5))
+
+        def fun(a, b):
+            return a @ b
+
+        cfun = mx.compile(fun, shapeless=True)
+        out = cfun(a, b)
+        self.assertEqual(out.shape, (2, 3, 4, 5))
+
+        # Shapeless compile should be preserved over vjp, jvp, vmap
+        def fun(args):
+            return sum(args).sum()
+
+        a = mx.array(0.0)
+        b = mx.ones((2, 2))
+
+        cfun = mx.compile(mx.grad(fun), shapeless=True)
+        out = cfun((a, b))
+
+        self.assertEqual(out[0].shape, ())
+        self.assertEqual(out[1].shape, (2, 2))
+
+        out = cfun((b, a))
+
+        self.assertEqual(out[0].shape, (2, 2))
+        self.assertEqual(out[1].shape, ())
+
+        # Shapeless compile should be preserved over vjp, jvp, vmap
+        def fun(args):
+            return (args[0] @ args[1]).sum()
+
+        a = mx.zeros((2, 1, 4, 2))
+        b = mx.zeros((3, 2, 5))
+
+        cfun = mx.compile(mx.grad(fun), shapeless=True)
+        out = cfun((a, b))
+
+        self.assertEqual(out[0].shape, (2, 1, 4, 2))
+        self.assertEqual(out[1].shape, (3, 2, 5))
+
+        a = mx.zeros((3, 1, 4, 2))
+        b = mx.zeros((2, 2, 5))
+
+        out = cfun((a, b))
+
+        self.assertEqual(out[0].shape, (3, 1, 4, 2))
+        self.assertEqual(out[1].shape, (2, 2, 5))
+
+    def test_leaks(self):
+        gc.collect()
+        if mx.metal.is_available():
+            mem_pre = mx.get_active_memory()
+        else:
+            mem_pre = 0
+
+        def outer():
+            d = {}
+
+            def f(x):
+                return d["x"]
+
+            d["f"] = mx.compile(f)
+            d["x"] = mx.array([0] * 1000)
+
+        for _ in range(5):
+            outer()
+            gc.collect()
+
+        if mx.metal.is_available():
+            mem_post = mx.get_active_memory()
+        else:
+            mem_post = 0
+
+        self.assertEqual(mem_pre, mem_post)
+
+    def test_double_constant(self):
+        with mx.stream(mx.cpu):
+            x = mx.array(1.0, dtype=mx.float64)
+
+            def fun(x):
+                return (x + math.pi) * 2.0
+
+            y = fun(x).item()
+            y_compiled = mx.compile(fun)(x).item()
+            self.assertEqual(y, y_compiled)
+
+    def test_shared_broadcast(self):
+        def fun(x, y, z):
+            yy = mx.broadcast_to(y, z.shape)
+            return (x + yy * z), yy.sum()
+
+        a = mx.random.normal((10, 10))
+        b = mx.array(0.1)
+        c = mx.random.normal((10, 10))
+        mx.eval(a, b, c)
+        fc = mx.compile(fun)
+        d = fc(a, b, c)
+
+        s = StringIO()
+        mx.export_to_dot(s, a=a, b=b, c=c, d1=d[0], d2=d[1])
+        s.seek(0)
+        s = s.read()
+
+        self.assertTrue("CompiledBroadcastMultiplyAdd" in s)
+        d_hat = fun(a, b, c)
+        self.assertTrue(mx.allclose(d[0], d_hat[0]))
+        self.assertTrue(mx.allclose(d[1], d_hat[1]))
+
+    def test_wrap_compiled(self):
+        @mx.compile
+        def inner():
+            pass
+
+        @wraps(inner)
+        def wrapper():
+            pass
+
+    def test_compiled_preserves_attributes(self):
+        def inner(x: mx.array, y: str):
+            """
+            A useful function.
+            """
+            pass
+
+        c_inner = mx.compile(inner)
+        self.assertEqual(inner.__name__, c_inner.__name__)
+        self.assertEqual(inner.__qualname__, c_inner.__qualname__)
+        self.assertEqual(inner.__doc__, c_inner.__doc__)
+        self.assertEqual(inspect.signature(inner), inspect.signature(c_inner))
+
+    def test_compile_with_none(self):
+        @mx.compile
+        def fun(x, y):
+            if y is None:
+                return mx.abs(x - 2.0)
+            else:
+                return mx.abs(x + y)
+
+        out = fun(mx.array(1.0), None)
+        self.assertEqual(out.item(), 1.0)
+
+        out = fun(mx.array(1.0), mx.array(2.0))
+        self.assertEqual(out.item(), 3.0)
+
+    def test_compile_changing_outputs(self):
+        @mx.compile
+        def fun(x, y):
+            if y is None:
+                return 2 * x
+            elif (
+                isinstance(x, mx.array)
+                and isinstance(y, mx.array)
+                and x.dtype == y.dtype == mx.float32
+            ):
+                return [x + y]
+            elif y.dtype == mx.bool_:
+                return {"a": x, "b": y * x}
+            else:
+                return None
+
+        a = fun(mx.array(1.0), mx.array(2.0))
+        self.assertTrue(isinstance(a, list))
+        self.assertEqual(a[0].item(), 3.0)
+
+        b = fun(mx.array(1.0), mx.array(True))
+        self.assertTrue(isinstance(b, dict))
+        self.assertEqual(b["a"].item(), 1.0)
+        self.assertEqual(b["b"].item(), 1.0)
+
+        c = fun(mx.array(1.0), None)
+        self.assertTrue(isinstance(c, mx.array))
+        self.assertEqual(c.item(), 2.0)
+
+        d = fun(False, mx.array(1.0))
+        self.assertTrue(d is None)
+
+    def test_compile_changing_outputs_with_state(self):
+        state = [mx.array(1.0)]
+
+        @partial(mx.compile, inputs=state, outputs=state)
+        def fun(y):
+            x = state[0]
+            if y.dtype == mx.float32:
+                state[0] = 2 * y
+                return [x, y, x + y]
+            elif y.dtype == mx.int32:
+                state[0] *= 2
+                return x + y
+
+        for i in range(10):
+            fun(mx.array(1.0))
+            fun(mx.array(1))
+
+        self.assertEqual(state[0].item(), 4)
+
+    def test_outputs_changing(self):
+        @mx.compile
+        def fun(x):
+            x = mx.abs(mx.negative(x))
+            y = mx.abs(x)
+            return x, y
+
+        @mx.compile
+        def fun2(x):
+            x = mx.abs(mx.negative(x))
+            y = mx.abs(x)
+            return y
+
+        a, b = fun(mx.array(-1.0))
+        mx.eval(a, b)
+
+        a = fun2(mx.array(-1.0))
+        self.assertEqual(a.item(), 1.0)
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_constants.py b/ml-stable-diffusion/mlx/python/tests/test_constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfd971fbe0d03e30c376e218d0cd038439b74fc7
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_constants.py
@@ -0,0 +1,41 @@
+# Copyright © 2023 Apple Inc.
+
+import unittest
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+
+class TestConstants(mlx_tests.MLXTestCase):
+    def test_constants_values(self):
+        # Check if mlx constants match expected values
+        self.assertAlmostEqual(
+            mx.e, 2.71828182845904523536028747135266249775724709369995
+        )
+        self.assertAlmostEqual(
+            mx.euler_gamma, 0.5772156649015328606065120900824024310421
+        )
+        self.assertAlmostEqual(mx.inf, float("inf"))
+        self.assertTrue(np.isnan(mx.nan))
+        self.assertIsNone(mx.newaxis)
+        self.assertAlmostEqual(mx.pi, 3.1415926535897932384626433)
+
+    def test_constants_availability(self):
+        # Check if mlx constants are available
+        self.assertTrue(hasattr(mx, "e"))
+        self.assertTrue(hasattr(mx, "euler_gamma"))
+        self.assertTrue(hasattr(mx, "inf"))
+        self.assertTrue(hasattr(mx, "nan"))
+        self.assertTrue(hasattr(mx, "newaxis"))
+        self.assertTrue(hasattr(mx, "pi"))
+
+    def test_newaxis_for_reshaping_arrays(self):
+        arr_1d = mx.array([1, 2, 3, 4, 5])
+        arr_2d_column = arr_1d[:, mx.newaxis]
+        expected_result = mx.array([[1], [2], [3], [4], [5]])
+        self.assertTrue(mx.array_equal(arr_2d_column, expected_result))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_conv.py b/ml-stable-diffusion/mlx/python/tests/test_conv.py
new file mode 100644
index 0000000000000000000000000000000000000000..cef912aee38922a02affe8a8bd10faa371dba5f8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_conv.py
@@ -0,0 +1,1198 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+import unittest
+from itertools import permutations
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+try:
+    import torch
+    import torch.nn.functional as F
+
+    has_torch = True
+except ImportError as e:
+    has_torch = False
+
+
+class TestConv(mlx_tests.MLXTestCase):
+    def test_numpy_conv(self):
+        for dtype in (
+            "float16",
+            "float32",
+        ):
+            np_dtype = getattr(np, dtype)
+            for M, N, mode in (
+                (1, 1, "full"),
+                (25, 5, "full"),
+                (24, 5, "same"),
+                (24, 4, "same"),
+                (24, 4, "valid"),
+                (4, 24, "full"),
+                (5, 25, "same"),
+                (4, 25, "valid"),
+            ):
+                with self.subTest(dtype=dtype, M=M, N=N, mode=mode):
+                    atol = 1e-6 if dtype == "float32" else 1e-5
+                    a_np = np.random.rand(M).astype(np_dtype)
+                    v_np = np.random.rand(N).astype(np_dtype)
+                    a_mx = mx.array(a_np)
+                    v_mx = mx.array(v_np)
+
+                    c_np = np.convolve(a_np, v_np, mode=mode)
+                    c_mx = mx.convolve(a_mx, v_mx, mode=mode)
+
+                    self.assertEqual(c_mx.shape, c_np.shape)
+                    self.assertTrue(np.allclose(c_mx, c_np, atol=atol))
+
+    def test_conv_1d_groups_flipped(self):
+        x = mx.broadcast_to(mx.arange(5).astype(mx.float32), (2, 5)).T
+        w = mx.broadcast_to(mx.arange(4).astype(mx.float32), (2, 4))
+        out = mx.conv_general(x[None], w[..., None], flip=True, groups=2)
+        expected = mx.array([4.0, 4.0, 10.0, 10.0]).reshape(1, 2, 2)
+        self.assertTrue(mx.allclose(out, expected))
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_1D(self):
+        def run_conv1D(
+            N,
+            C,
+            O,
+            iH,
+            kH,
+            stride,
+            padding,
+            dilation=1,
+            groups=1,
+            dtype="float32",
+            atol=1e-5,
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                iH=iH,
+                kH=kH,
+                stride=stride,
+                padding=padding,
+                dilation=dilation,
+                groups=groups,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                in_np = np.random.normal(0, 1.0 / C, (N, iH, C)).astype(np_dtype)
+                wt_np = np.random.normal(0, 1.0 / C, (O, kH, int(C / groups))).astype(
+                    np_dtype
+                )
+
+                in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+                in_pt, wt_pt = map(
+                    lambda x: torch.from_numpy(x.transpose(0, 2, 1)), (in_np, wt_np)
+                )
+
+                out_mx = mx.conv1d(
+                    in_mx,
+                    wt_mx,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                out_pt = torch.conv1d(
+                    in_pt,
+                    wt_pt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                out_pt = torch.transpose(out_pt, 2, 1)
+
+                self.assertEqual(out_pt.shape, out_mx.shape)
+                self.assertTrue(np.allclose(out_pt.numpy(), out_mx, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in (
+                (1, 1, 1),
+                (1, 6, 1),
+                (1, 1, 6),
+                (4, 32, 64),
+            ):
+                for iH, kH, stride, padding in (
+                    (1, 1, 1, 0),
+                    (3, 3, 1, 0),
+                    (31, 5, 5, 2),
+                ):
+                    run_conv1D(N, C, O, iH, kH, stride, padding, dtype=dtype)
+
+        # Groups tests
+        N, C, O = (4, 32, 64)
+        for iH, kH, stride, padding in (
+            (1, 1, 1, 0),
+            (3, 3, 1, 0),
+            (31, 5, 5, 2),
+        ):
+            for group in (1, 2, 4, 8, 16, 32):
+                run_conv1D(N, C, O, iH, kH, stride, padding, groups=group, dtype=dtype)
+
+        # Strided inputs tests
+        for tpose_in, tpose_wt in (
+            ((0, 2, 1), (0, 1, 2)),
+            ((0, 2, 1), (0, 2, 1)),
+        ):
+            with self.subTest(name="strided", tpose_in=tpose_in, tpose_wt=tpose_wt):
+                in_np = np.random.normal(0, 1.0 / 16, (16, 16, 16)).astype(np.float32)
+                wt_np = np.random.normal(0, 1.0 / 16, (16, 16, 16)).astype(np.float32)
+
+                in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+                in_mx_t = mx.transpose(in_mx, tpose_in)
+                wt_mx_t = mx.transpose(wt_mx, tpose_wt)
+                out_mx = mx.conv1d(in_mx_t, wt_mx_t)
+
+                in_pt, wt_pt = map(
+                    lambda x: torch.from_numpy(x.transpose(0, 2, 1)),
+                    (in_np.transpose(tpose_in), wt_np.transpose(tpose_wt)),
+                )
+
+                out_pt = torch.conv1d(in_pt, wt_pt)
+                out_pt = torch.transpose(out_pt, 2, 1)
+
+                self.assertEqual(out_pt.shape, out_mx.shape)
+                self.assertTrue(np.allclose(out_pt.numpy(), out_mx, atol=1e-5))
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_1D_grad(self):
+        def run_conv1D_grad(
+            N,
+            C,
+            O,
+            iH,
+            kH,
+            stride,
+            padding,
+            dilation=1,
+            groups=1,
+            dtype="float32",
+            atol=1e-5,
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                iH=iH,
+                kH=kH,
+                stride=stride,
+                padding=padding,
+                dilation=dilation,
+                groups=groups,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                oH = 1 + ((iH + 2 * padding - dilation * (kH - 1) - 1) // stride)
+
+                in_np = np.random.normal(0, 1.0 / C, (N, iH, C)).astype(np_dtype)
+                wt_np = np.random.normal(0, 1.0 / C, (O, kH, C)).astype(np_dtype)
+                ct_np = np.random.normal(0, 1.0 / C, (N, oH, O)).astype(np_dtype)
+
+                in_mx, wt_mx, ct_mx = map(mx.array, (in_np, wt_np, ct_np))
+                in_pt, wt_pt, ct_pt = map(
+                    lambda x: torch.from_numpy(x.transpose(0, 2, 1)),
+                    (in_np, wt_np, ct_np),
+                )
+
+                def f(a, b):
+                    return mx.conv1d(
+                        a,
+                        b,
+                        stride=stride,
+                        padding=padding,
+                        dilation=dilation,
+                        groups=groups,
+                    )
+
+                _, outs_mx = mx.vjp(
+                    f,
+                    [
+                        in_mx,
+                        wt_mx,
+                    ],
+                    [
+                        ct_mx,
+                    ],
+                )
+                pt_grad_in = F.grad.conv1d_input(
+                    in_pt.shape,
+                    wt_pt,
+                    ct_pt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                pt_grad_wt = F.grad.conv1d_weight(
+                    in_pt,
+                    wt_pt.shape,
+                    ct_pt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                pt_grad_in = torch.transpose(pt_grad_in, 2, 1).numpy()
+                pt_grad_wt = torch.transpose(pt_grad_wt, 2, 1).numpy()
+
+                mx_grad_in, mx_grad_wt = outs_mx
+
+                self.assertEqual(pt_grad_in.shape, mx_grad_in.shape)
+                self.assertEqual(in_mx.shape, mx_grad_in.shape)
+                self.assertTrue(np.allclose(pt_grad_in, mx_grad_in, atol=atol))
+
+                self.assertEqual(pt_grad_wt.shape, mx_grad_wt.shape)
+                self.assertEqual(wt_mx.shape, mx_grad_wt.shape)
+                self.assertTrue(np.allclose(pt_grad_wt, mx_grad_wt, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in (
+                (1, 1, 1),
+                (1, 6, 1),
+                (1, 1, 6),
+                (4, 32, 64),
+            ):
+                for iH, kH, stride, padding in (
+                    (1, 1, 1, 0),
+                    (3, 3, 1, 0),
+                    (31, 5, 5, 2),
+                ):
+                    run_conv1D_grad(N, C, O, iH, kH, stride, padding, dtype=dtype)
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_2D(self):
+        def run_conv2D(
+            N,
+            C,
+            O,
+            idim,
+            kdim,
+            stride,
+            padding,
+            dilation=(1, 1),
+            groups=1,
+            dtype="float32",
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                idim=idim,
+                kdim=kdim,
+                stride=stride,
+                padding=padding,
+                dilation=dilation,
+                groups=groups,
+            ):
+                np.random.seed(0)
+                iH, iW = idim
+                kH, kW = kdim
+                scale = 1.0 / math.sqrt(kH * kW * C)
+                in_np = np.random.normal(0.0, scale, (N, iH, iW, C))
+                wt_np = np.random.normal(0.0, 1.0, (O, kH, kW, int(C / groups)))
+
+                mx_dtype = getattr(mx, dtype)
+                torch_dtype = getattr(torch, dtype)
+                in_mx, wt_mx = map(
+                    lambda x: mx.array(x).astype(mx_dtype), (in_np, wt_np)
+                )
+                in_pt, wt_pt = map(
+                    lambda x: torch.from_numpy(x.transpose(0, 3, 1, 2))
+                    .to("cpu")
+                    .to(torch_dtype),
+                    (in_np, wt_np),
+                )
+
+                out_mx = mx.conv2d(
+                    in_mx,
+                    wt_mx,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                ).astype(mx.float32)
+                out_pt = torch.conv2d(
+                    in_pt,
+                    wt_pt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                out_pt = (
+                    torch.permute(out_pt, (0, 2, 3, 1))
+                    .to(torch.float32)
+                    .numpy(force=True)
+                )
+
+                self.assertEqual(out_pt.shape, out_mx.shape)
+                if dtype == "bfloat16":
+                    atol, rtol = 1e-1, 1e-3
+                else:
+                    atol, rtol = 1e-5, 1e-6
+                self.assertTrue(np.allclose(out_pt, out_mx, atol=atol))
+
+        for dtype in ("float32", "bfloat16"):
+            for N, C, O in (
+                (1, 1, 1),
+                (1, 6, 1),
+                (1, 1, 6),
+                (4, 32, 64),
+            ):
+                for idim, kdim, stride, padding in (
+                    ((1, 1), (1, 1), (1, 1), (0, 0)),
+                    ((3, 3), (3, 1), (1, 1), (0, 0)),
+                    ((31, 31), (5, 5), (5, 5), (2, 2)),
+                ):
+                    run_conv2D(N, C, O, idim, kdim, stride, padding, dtype=dtype)
+
+            # Groups tests
+            N, C, O = (4, 32, 64)
+            for idim, kdim, stride, padding in (
+                ((1, 1), (1, 1), (1, 1), (0, 0)),
+                ((3, 3), (3, 1), (1, 1), (0, 0)),
+                ((31, 31), (5, 5), (5, 5), (2, 2)),
+            ):
+                for group in (1, 2, 4, 8, 16, 32):
+                    run_conv2D(
+                        N, C, O, idim, kdim, stride, padding, groups=group, dtype=dtype
+                    )
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_2D_grad(self):
+        def run_conv2D_grad(
+            N,
+            C,
+            O,
+            idim,
+            kdim,
+            stride,
+            padding,
+            dilation=(1, 1),
+            groups=1,
+            dtype="float32",
+            atol=1e-5,
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                idim=idim,
+                kdim=kdim,
+                stride=stride,
+                padding=padding,
+                dilation=dilation,
+                groups=groups,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                iH, iW = idim
+                kH, kW = kdim
+                scale = 1.0 / math.sqrt(kH * kW * C)
+
+                oH = 1 + (
+                    (iH + 2 * padding[0] - dilation[0] * (kH - 1) - 1) // stride[0]
+                )
+                oW = 1 + (
+                    (iW + 2 * padding[1] - dilation[1] * (kW - 1) - 1) // stride[1]
+                )
+
+                in_np = np.random.normal(0.0, scale, (N, iH, iW, C)).astype(np_dtype)
+                wt_np = np.random.normal(0.0, scale, (O, kH, kW, C)).astype(np_dtype)
+                ct_np = np.random.normal(0.0, scale, (N, oH, oW, O)).astype(np_dtype)
+
+                in_mx, wt_mx, ct_mx = map(mx.array, (in_np, wt_np, ct_np))
+                in_pt, wt_pt, ct_pt = map(
+                    lambda x: torch.from_numpy(x.transpose(0, 3, 1, 2)).to("cpu"),
+                    (in_np, wt_np, ct_np),
+                )
+
+                def f(a, b):
+                    return mx.conv2d(
+                        a,
+                        b,
+                        stride=stride,
+                        padding=padding,
+                        dilation=dilation,
+                        groups=groups,
+                    )
+
+                _, outs_mx = mx.vjp(
+                    f,
+                    [in_mx, wt_mx],
+                    [ct_mx],
+                )
+                pt_grad_in = F.grad.conv2d_input(
+                    in_pt.shape,
+                    wt_pt,
+                    ct_pt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                pt_grad_wt = F.grad.conv2d_weight(
+                    in_pt,
+                    wt_pt.shape,
+                    ct_pt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                pt_grad_in = torch.permute(pt_grad_in, (0, 2, 3, 1)).numpy()
+                pt_grad_wt = torch.permute(pt_grad_wt, (0, 2, 3, 1)).numpy()
+
+                mx_grad_in, mx_grad_wt = outs_mx
+
+                self.assertEqual(pt_grad_in.shape, mx_grad_in.shape)
+                self.assertEqual(in_mx.shape, mx_grad_in.shape)
+                self.assertTrue(np.allclose(pt_grad_in, mx_grad_in, atol=atol))
+
+                self.assertEqual(pt_grad_wt.shape, mx_grad_wt.shape)
+                self.assertEqual(wt_mx.shape, mx_grad_wt.shape)
+                self.assertTrue(np.allclose(pt_grad_wt, mx_grad_wt, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in ((1, 1, 1), (1, 6, 1), (1, 1, 6), (4, 32, 64), (4, 16, 32)):
+                for idim, kdim, stride, padding, dilation in (
+                    ((1, 1), (1, 1), (1, 1), (0, 0), (1, 1)),
+                    ((3, 3), (3, 1), (1, 1), (0, 0), (1, 1)),
+                    ((31, 31), (5, 5), (5, 5), (2, 2), (1, 1)),
+                    ((32, 32), (3, 3), (2, 2), (1, 1), (1, 1)),
+                    ((31, 31), (5, 5), (5, 5), (2, 2), (3, 2)),
+                    ((32, 32), (3, 3), (2, 2), (1, 1), (3, 2)),
+                ):
+                    run_conv2D_grad(
+                        N, C, O, idim, kdim, stride, padding, dilation, dtype=dtype
+                    )
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_3D(self):
+        def run_conv3D(
+            N,
+            C,
+            O,
+            idim,
+            kdim,
+            stride,
+            padding,
+            dilation=(1, 1, 1),
+            groups=1,
+            dtype="float32",
+            atol=1e-5,
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                idim=idim,
+                kdim=kdim,
+                stride=stride,
+                padding=padding,
+                dilation=dilation,
+                groups=groups,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                iD, iH, iW = idim
+                kD, kH, kW = kdim
+                scale = 1.0 / math.sqrt(kD * kH * kW * C)
+                in_np = np.random.normal(0.0, scale, (N, iD, iH, iW, C)).astype(
+                    np_dtype
+                )
+                wt_np = np.random.normal(0.0, 1.0, (O, kD, kH, kW, C)).astype(np_dtype)
+
+                in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+                in_pt, wt_pt = map(
+                    lambda x: torch.from_numpy(x.transpose(0, 4, 1, 2, 3)).to("cpu"),
+                    (in_np, wt_np),
+                )
+
+                out_mx = mx.conv3d(
+                    in_mx,
+                    wt_mx,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                out_pt = torch.conv3d(
+                    in_pt,
+                    wt_pt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                out_pt = torch.permute(out_pt, (0, 2, 3, 4, 1)).numpy(force=True)
+
+                self.assertEqual(out_pt.shape, out_mx.shape)
+                self.assertTrue(np.allclose(out_pt, out_mx, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in (
+                (1, 1, 1),
+                (1, 6, 1),
+                (1, 1, 6),
+                (4, 16, 32),
+            ):
+                continue
+                for idim, kdim, stride, padding in (
+                    ((1, 1, 1), (1, 1, 1), (1, 1, 1), (0, 0, 0)),
+                    ((3, 3, 3), (3, 1, 1), (1, 1, 1), (0, 0, 0)),
+                    ((31, 31, 31), (5, 5, 5), (5, 5, 5), (2, 2, 2)),
+                ):
+                    run_conv3D(N, C, O, idim, kdim, stride, padding, dtype=dtype)
+
+            N, C, O = (2, 4, 4)
+            idim, kdim, stride, padding = (6, 6, 6), (3, 1, 1), (1, 1, 1), (0, 0, 0)
+            run_conv3D(
+                N, C, O, idim, kdim, stride, padding, dilation=(2, 2, 2), dtype=dtype
+            )
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_3D_grad(self):
+        def run_conv3D_grad(
+            N,
+            C,
+            O,
+            idim,
+            kdim,
+            stride,
+            padding,
+            dilation=(1, 1, 1),
+            groups=1,
+            dtype="float32",
+            atol=1e-5,
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                idim=idim,
+                kdim=kdim,
+                stride=stride,
+                padding=padding,
+                dilation=dilation,
+                groups=groups,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                iD, iH, iW = idim
+                kD, kH, kW = kdim
+                scale = 1.0 / math.sqrt(kD * kH * kW * C)
+
+                oD = 1 + (
+                    (iD + 2 * padding[0] - dilation[0] * (kD - 1) - 1) // stride[0]
+                )
+                oH = 1 + (
+                    (iH + 2 * padding[1] - dilation[1] * (kH - 1) - 1) // stride[1]
+                )
+                oW = 1 + (
+                    (iW + 2 * padding[2] - dilation[2] * (kW - 1) - 1) // stride[2]
+                )
+
+                in_np = np.random.normal(0.0, scale, (N, iD, iH, iW, C)).astype(
+                    np_dtype
+                )
+                wt_np = np.random.normal(0.0, scale, (O, kD, kH, kW, C)).astype(
+                    np_dtype
+                )
+                ct_np = np.random.normal(0.0, scale, (N, oD, oH, oW, O)).astype(
+                    np_dtype
+                )
+
+                in_mx, wt_mx, ct_mx = map(mx.array, (in_np, wt_np, ct_np))
+                in_pt, wt_pt, ct_pt = map(
+                    lambda x: torch.from_numpy(x.transpose(0, 4, 1, 2, 3)).to("cpu"),
+                    (in_np, wt_np, ct_np),
+                )
+
+                def f(a, b):
+                    return mx.conv3d(
+                        a,
+                        b,
+                        stride=stride,
+                        padding=padding,
+                        dilation=dilation,
+                        groups=groups,
+                    )
+
+                _, outs_mx = mx.vjp(
+                    f,
+                    [in_mx, wt_mx],
+                    [ct_mx],
+                )
+                pt_grad_in = F.grad.conv3d_input(
+                    in_pt.shape,
+                    wt_pt,
+                    ct_pt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                pt_grad_wt = F.grad.conv3d_weight(
+                    in_pt,
+                    wt_pt.shape,
+                    ct_pt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                pt_grad_in = torch.permute(pt_grad_in, (0, 2, 3, 4, 1)).numpy()
+                pt_grad_wt = torch.permute(pt_grad_wt, (0, 2, 3, 4, 1)).numpy()
+
+                mx_grad_in, mx_grad_wt = outs_mx
+
+                self.assertEqual(pt_grad_in.shape, mx_grad_in.shape)
+                self.assertEqual(in_mx.shape, mx_grad_in.shape)
+                self.assertTrue(np.allclose(pt_grad_in, mx_grad_in, atol=atol))
+
+                self.assertEqual(pt_grad_wt.shape, mx_grad_wt.shape)
+                self.assertEqual(wt_mx.shape, mx_grad_wt.shape)
+                self.assertTrue(np.allclose(pt_grad_wt, mx_grad_wt, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in ((1, 1, 1), (1, 6, 1), (1, 1, 6), (4, 16, 32), (4, 8, 16)):
+                for idim, kdim, stride, padding, dilation in (
+                    ((1, 1, 1), (1, 1, 1), (1, 1, 1), (0, 0, 0), (1, 1, 1)),
+                    ((3, 3, 3), (3, 1, 1), (1, 1, 1), (0, 0, 0), (1, 1, 1)),
+                    ((15, 15, 15), (5, 5, 5), (5, 5, 5), (2, 2, 2), (1, 1, 1)),
+                    ((16, 16, 16), (3, 3, 3), (2, 2, 2), (1, 1, 1), (1, 1, 1)),
+                    ((15, 15, 15), (5, 5, 5), (5, 5, 5), (2, 2, 2), (3, 2, 2)),
+                    ((16, 16, 16), (3, 3, 3), (2, 2, 2), (1, 1, 1), (3, 2, 2)),
+                ):
+                    run_conv3D_grad(
+                        N, C, O, idim, kdim, stride, padding, dilation, dtype=dtype
+                    )
+
+    def __conv_general_test(
+        self,
+        in_shape,
+        wt_shape,
+        stride=1,
+        padding=0,
+        kernel_dilation=1,
+        input_dilation=1,
+        groups=1,
+        flip=False,
+        np_dtype=np.float32,
+        atol=1e-5,
+    ):
+        with self.subTest(
+            in_shape=in_shape,
+            wt_shape=wt_shape,
+            stride=stride,
+            padding=padding,
+            kernel_dilation=kernel_dilation,
+            input_dilation=input_dilation,
+            groups=groups,
+            flip=flip,
+            np_dtype=np_dtype,
+        ):
+            np.random.seed(0)
+            scale = 1.0 / math.sqrt(np.prod(wt_shape[1:]))
+            scale = min(0.3, scale)
+            in_np = np.random.normal(0, scale, in_shape).astype(np_dtype)
+            wt_np = np.random.normal(0, scale, wt_shape).astype(np_dtype)
+
+            in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+
+            in_pt, wt_pt = map(
+                lambda x: torch.from_numpy(np.moveaxis(x, -1, 1)).to("cpu"),
+                (in_np, wt_np),
+            )
+
+            out_mx = mx.conv_general(
+                in_mx,
+                wt_mx,
+                stride=stride,
+                padding=padding,
+                kernel_dilation=kernel_dilation,
+                input_dilation=input_dilation,
+                groups=groups,
+                flip=flip,
+            )
+
+            def conv_general_pt(
+                inp, wt, stride, padding, kernel_dilation, input_dilation, groups, flip
+            ):
+                C = inp.size()[1]
+                ndim = inp.ndim - 2
+                map_ints = lambda x: [x] * ndim if isinstance(x, int) else x
+
+                stride, padding, kernel_dilation, input_dilation = map(
+                    map_ints, (stride, padding, kernel_dilation, input_dilation)
+                )
+
+                torch_convt_list = (
+                    F.conv_transpose1d,
+                    F.conv_transpose2d,
+                    F.conv_transpose3d,
+                )
+                torch_conv_list = (F.conv1d, F.conv2d, F.conv3d)
+
+                conv_f = torch_conv_list[ndim - 1]
+                convt_f = torch_convt_list[ndim - 1]
+
+                if flip:
+                    wt = torch.flip(wt, tuple(np.arange(2, wt.ndim)))
+
+                if not np.all(input_dilation == 1):
+                    ones = torch.ones(
+                        [C]
+                        + [
+                            1,
+                        ]
+                        * (ndim + 1)
+                    ).to(inp.dtype)
+                    inp = convt_f(inp, ones, stride=input_dilation, groups=C)
+
+                return conv_f(
+                    inp,
+                    wt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=kernel_dilation,
+                    groups=groups,
+                )
+
+            out_pt = conv_general_pt(
+                in_pt,
+                wt_pt,
+                stride=stride,
+                padding=padding,
+                kernel_dilation=kernel_dilation,
+                input_dilation=input_dilation,
+                groups=groups,
+                flip=flip,
+            )
+
+            out_pt = np.moveaxis(out_pt.numpy(), 1, -1)
+
+            self.assertEqual(out_mx.shape, out_pt.shape)
+            self.assertTrue(np.allclose(out_mx, out_pt, atol=atol))
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_general(self):
+        in_shape = (2, 32, 32, 16)
+        wt_shape = (32, 5, 5, 16)
+        stride = (1, 1)
+        padding = (2, 2)
+        kernel_dilation = (2, 3)
+        input_dilation = (1, 1)
+        flip = False
+
+        self.__conv_general_test(
+            in_shape,
+            wt_shape,
+            stride,
+            padding,
+            kernel_dilation,
+            input_dilation,
+            flip=flip,
+        )
+
+        in_shape = (2, 32, 32, 16)
+        wt_shape = (32, 5, 10, 16)
+        stride = (2, 3)
+        padding = (0, 0)
+        kernel_dilation = (3, 2)
+        input_dilation = (2, 4)
+        flip = False
+
+        self.__conv_general_test(
+            in_shape,
+            wt_shape,
+            stride,
+            padding,
+            kernel_dilation,
+            input_dilation,
+            flip=flip,
+        )
+
+        in_shape = (2, 32, 32, 16)
+        wt_shape = (32, 5, 10, 16)
+        stride = (2, 2)
+        padding = (3, 2)
+        kernel_dilation = (3, 2)
+        input_dilation = (2, 4)
+        flip = False
+
+        self.__conv_general_test(
+            in_shape,
+            wt_shape,
+            stride,
+            padding,
+            kernel_dilation,
+            input_dilation,
+            flip=flip,
+        )
+
+        in_shape = (2, 32, 32, 16)
+        wt_shape = (32, 5, 10, 16)
+        stride = (2, 3)
+        padding = (3, 2)
+        kernel_dilation = (3, 2)
+        input_dilation = (2, 5)
+        flip = False
+
+        self.__conv_general_test(
+            in_shape,
+            wt_shape,
+            stride,
+            padding,
+            kernel_dilation,
+            input_dilation,
+            flip=flip,
+        )
+
+        in_shape = (2, 32, 32, 16)
+        wt_shape = (32, 5, 5, 16)
+        stride = (2, 3)
+        padding = (0, 0)
+        kernel_dilation = (3, 1)
+        input_dilation = (2, 5)
+        flip = True
+
+        self.__conv_general_test(
+            in_shape,
+            wt_shape,
+            stride,
+            padding,
+            kernel_dilation,
+            input_dilation,
+            flip=flip,
+        )
+
+    def test_conv_general_flip_grad(self):
+        for s in (1, 2):
+            w = mx.random.normal(shape=(1, 2, 2, 1))
+            x = mx.random.normal(shape=(1, 2, 2, 1))
+
+            def conv_t(w):
+                return mx.conv_general(
+                    x,
+                    w,
+                    stride=1,
+                    padding=(1, 1),
+                    kernel_dilation=1,
+                    input_dilation=s,
+                    flip=True,
+                )
+
+            cotan = mx.random.normal(shape=(1, 2 + s, 2 + s, 1))
+
+            dw = mx.vjp(conv_t, (w,), (cotan,))[1][0]
+
+            x = x.squeeze()
+            cotan = cotan.squeeze()
+            dw = dw.squeeze()
+
+            dw00 = (cotan[:-1:s, :-1:s] * x).sum()
+            dw01 = (cotan[:-1:s, 1::s] * x).sum()
+            dw10 = (cotan[1::s, :-1:s] * x).sum()
+            dw11 = (cotan[1::s, 1::s] * x).sum()
+            expected = mx.array([[dw00, dw01], [dw10, dw11]])
+            self.assertTrue(mx.allclose(dw, expected, rtol=1e-5, atol=1e-5))
+
+        # Test with input dilation
+        inputs = mx.random.normal((1, 14, 14, 2))
+        kernel = mx.random.normal((2, 7, 7, 2))
+
+        def conv_flip(kernel):
+            return mx.conv_general(
+                inputs,
+                kernel,
+                stride=1,
+                padding=([6, 6], [15, 15]),
+                kernel_dilation=(1, 1),
+                input_dilation=(16, 16),
+                groups=1,
+                flip=True,
+            ).sum()
+
+        def reverse_sequence(xs, axis=0):
+            indices = mx.arange(xs.shape[axis] - 1, -1, -1)
+            return mx.take(xs, indices, axis=axis)
+
+        def conv_manual_flip(kernel):
+            for ax in range(1, kernel.ndim - 1):
+                kernel = reverse_sequence(kernel, axis=ax)
+            return mx.conv_general(
+                inputs,
+                kernel,
+                stride=1,
+                padding=([6, 6], [15, 15]),
+                kernel_dilation=(1, 1),
+                input_dilation=(16, 16),
+                groups=1,
+                flip=False,
+            ).sum()
+
+        grad = mx.grad(conv_flip)(kernel)
+        expected_grad = mx.grad(conv_manual_flip)(kernel)
+        self.assertTrue(mx.allclose(grad, expected_grad))
+
+    def test_conv_groups_grad(self):
+        def fn(x, w):
+            num_groups = x.shape[-1] // w.shape[-1]
+            return mx.conv1d(x, w, groups=num_groups)
+
+        def fn_gt(x, w):
+            num_groups = x.shape[-1] // w.shape[-1]
+            group_size = w.shape[-1]
+            ws = w.reshape(num_groups, -1, *w.shape[1:]).split(num_groups)
+            xs = x.reshape(*x.shape[:-1], num_groups, -1).split(num_groups, axis=-2)
+            return mx.concatenate(
+                [mx.conv_general(x.squeeze(-2), w.squeeze(0)) for x, w in zip(xs, ws)],
+                axis=-1,
+            )
+
+        mx.random.seed(3)
+
+        w = mx.random.normal(shape=(2, 3, 1))
+        x = mx.random.normal(shape=(1, 5, 2))
+        cotans = (mx.ones(shape=(1, 3, 2)),)
+        grads = mx.vjp(fn, (x, w), cotans)[1]
+        expected = mx.vjp(fn_gt, (x, w), cotans)[1]
+        self.assertTrue(mx.allclose(expected[0], grads[0]))
+        self.assertTrue(mx.allclose(expected[1], grads[1]))
+
+        w = mx.random.normal(shape=(2, 3, 2))
+        x = mx.random.normal(shape=(1, 5, 4))
+        cotans = (mx.ones(shape=(1, 3, 2)),)
+        grads = mx.vjp(fn, (x, w), cotans)[1]
+        expected = mx.vjp(fn_gt, (x, w), cotans)[1]
+        self.assertTrue(mx.allclose(expected[0], grads[0]))
+        self.assertTrue(mx.allclose(expected[1], grads[1]))
+
+        w = mx.random.normal(shape=(6, 3, 2))
+        x = mx.random.normal(shape=(1, 5, 4))
+        cotans = (mx.ones(shape=(1, 3, 6)),)
+        grads = mx.vjp(fn, (x, w), cotans)[1]
+        expected = mx.vjp(fn_gt, (x, w), cotans)[1]
+        self.assertTrue(mx.allclose(expected[0], grads[0]))
+        self.assertTrue(mx.allclose(expected[1], grads[1]))
+
+        # Test 2D
+        w = mx.random.normal(shape=(2, 3, 3, 1))
+        x = mx.random.normal(shape=(1, 5, 5, 2))
+        cotans = (mx.ones(shape=(1, 3, 3, 2)),)
+        grads = mx.vjp(fn, (x, w), cotans)[1]
+        expected = mx.vjp(fn_gt, (x, w), cotans)[1]
+        self.assertTrue(mx.allclose(expected[0], grads[0]))
+        self.assertTrue(mx.allclose(expected[1], grads[1]))
+
+        # Test with flip
+        def fn(x, w):
+            num_groups = x.shape[-1] // w.shape[-1]
+            return mx.conv_general(x, w, groups=num_groups, flip=True)
+
+        def fn_gt(x, w):
+            num_groups = x.shape[-1] // w.shape[-1]
+            group_size = w.shape[-1]
+            ws = w.reshape(num_groups, -1, *w.shape[1:]).split(num_groups)
+            xs = x.reshape(*x.shape[:-1], num_groups, -1).split(num_groups, axis=-2)
+            return mx.concatenate(
+                [
+                    mx.conv_general(x.squeeze(-2), w.squeeze(0), flip=True)
+                    for x, w in zip(xs, ws)
+                ],
+                axis=-1,
+            )
+
+        w = mx.random.normal(shape=(2, 3, 1))
+        x = mx.random.normal(shape=(1, 5, 2))
+        cotans = (mx.ones(shape=(1, 3, 2)),)
+        grads = mx.vjp(fn, (x, w), cotans)[1]
+        expected = mx.vjp(fn_gt, (x, w), cotans)[1]
+        self.assertTrue(mx.allclose(expected[0], grads[0]))
+        self.assertTrue(mx.allclose(expected[1], grads[1]))
+
+        w = mx.random.normal(shape=(2, 3, 2))
+        x = mx.random.normal(shape=(1, 5, 4))
+        cotans = (mx.ones(shape=(1, 3, 2)),)
+        grads = mx.vjp(fn, (x, w), cotans)[1]
+        expected = mx.vjp(fn_gt, (x, w), cotans)[1]
+        self.assertTrue(mx.allclose(expected[0], grads[0]))
+        self.assertTrue(mx.allclose(expected[1], grads[1]))
+
+        # Test 2D
+        w = mx.random.normal(shape=(2, 3, 3, 1))
+        x = mx.random.normal(shape=(1, 5, 5, 2))
+        cotans = (mx.ones(shape=(1, 3, 3, 2)),)
+        grads = mx.vjp(fn, (x, w), cotans)[1]
+        expected = mx.vjp(fn_gt, (x, w), cotans)[1]
+        self.assertTrue(mx.allclose(expected[0], grads[0]))
+        self.assertTrue(mx.allclose(expected[1], grads[1]))
+
+    def test_repeated_conv(self):
+        x = mx.random.normal((1, 3, 3, 320))
+        w = mx.random.normal((320, 3, 3, 320))
+        for i in range(8):
+            y1 = mx.conv2d(x, w, (1, 1), (1, 1), (1, 1), 1)
+            y2 = mx.conv2d(x, w, (1, 1), (1, 1), (1, 1), 1)
+            self.assertTrue(mx.allclose(y1, y2))
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_depthwise(self):
+
+        # fmt: off
+        shapes = (
+            # N,   H,   W,    C   kH,  kW,   O, strides, padding,  groups
+            ( 2,  16,  16,   32,   1,   1,  32,  (2, 2),  (1, 1),    32),
+            ( 1,  16,  16,   32,   3,   3,  32,  (2, 2),  (1, 1),    32),
+            ( 1,  32,  32,   32,   7,   7,  32,  (1, 1),  (3, 3),    32),
+            ( 3,  32,  32,   32,   5,   5,  32,  (1, 2),  (0, 0),    32),
+            ( 1,  32,  32,   32,   7,   7,  32,  (2, 1),  (1, 3),    32),
+        )
+        # fmt: on
+
+        dtypes = [np.float32]
+        if mx.default_device() == mx.gpu:
+            dtypes += [np.float16]
+
+        for N, H, W, C, kH, kW, O, strides, padding, groups in shapes:
+            for dtype in dtypes:
+                for flip in [False, True]:
+                    Cw = C // groups
+
+                    self.__conv_general_test(
+                        (N, H, W, C),
+                        (O, kH, kW, Cw),
+                        strides,
+                        padding,
+                        kernel_dilation=1,
+                        input_dilation=1,
+                        groups=groups,
+                        flip=flip,
+                        np_dtype=dtype,
+                        atol=2e-5 if dtype == np.float32 else 5e-4,
+                    )
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_asymmetric_padding(self):
+        inputs = np.random.normal(size=(2, 8, 8, 8, 3)).astype(np.float32)
+        kernel = np.random.normal(size=(2, 3, 3, 3, 3)).astype(np.float32)
+        strides = (2, 2, 2)
+
+        pt_out = torch.conv3d(
+            torch.permute(torch.tensor(inputs), (0, 4, 1, 2, 3)),
+            torch.permute(torch.tensor(kernel), (0, 4, 1, 2, 3)),
+            stride=strides,
+            padding=2,
+        )
+        pt_out = torch.permute(pt_out, (0, 2, 3, 4, 1))[:, 1:, 1:, 1:, :].numpy()
+
+        mx_out = mx.conv_general(
+            mx.array(inputs),
+            mx.array(kernel),
+            stride=strides,
+            padding=([0, 0, 0], [1, 1, 1]),
+        )
+
+        self.assertTrue(mx.allclose(mx_out, mx.array(pt_out), atol=1e-3, rtol=1e-3))
+
+        inputs = np.random.normal(size=(2, 10, 10, 3)).astype(np.float32)
+        kernel = np.random.normal(size=(2, 2, 2, 3)).astype(np.float32)
+
+        pt_out = torch.conv2d(
+            torch.permute(torch.tensor(inputs), (0, 3, 1, 2)),
+            torch.permute(torch.tensor(kernel), (0, 3, 1, 2)),
+            stride=1,
+            padding=(1, 0),
+        )
+        pt_out = torch.permute(pt_out, (0, 2, 3, 1))[:, 1:].numpy()
+
+        mx_out = mx.conv_general(
+            mx.array(inputs),
+            mx.array(kernel),
+            stride=1,
+            padding=([0, 0], [1, 0]),
+        )
+        self.assertTrue(mx.allclose(mx_out, mx.array(pt_out), atol=1e-3, rtol=1e-3))
+
+    def test_basic_grad_shapes(self):
+        def loss_fn(kernel, inputs, strides, groups):
+            return mx.sum(
+                mx.conv_general(
+                    inputs,
+                    kernel,
+                    stride=strides,
+                    groups=groups,
+                )
+            )
+
+        for in_shape, k_shape, strides, groups in [
+            ((3, 5, 4), (6, 2, 2), (2,), 2),
+            ((3, 5, 4), (24, 2, 1), (2,), 4),
+            ((3, 5, 5, 4), (6, 2, 2, 2), (2, 1), 2),
+            ((3, 5, 5, 4), (24, 2, 2, 1), (2, 2), 4),
+        ]:
+            grads = mx.grad(loss_fn)(
+                mx.zeros(k_shape), mx.zeros(in_shape), strides, groups
+            )
+            self.assertEqual(grads.shape, k_shape)
+
+    def test_1d_conv_with_2d(self):
+        x = mx.random.uniform(shape=(2, 10, 16))
+        y = mx.random.normal(shape=(16, 3, 16))
+
+        out = mx.conv1d(x, y, padding=1)
+        out_2d = mx.conv2d(
+            mx.expand_dims(x, axis=2), mx.expand_dims(y, axis=2), padding=(1, 0)
+        )
+
+        self.assertTrue(mx.allclose(out, out_2d.squeeze(2)))
+
+        x = mx.random.uniform(shape=(2, 10, 4))
+        y = mx.random.normal(shape=(4, 3, 4))
+
+        out = mx.conv1d(x, y, padding=1)
+        out_2d = mx.conv2d(
+            mx.expand_dims(x, axis=2), mx.expand_dims(y, axis=2), padding=(1, 0)
+        )
+
+        self.assertTrue(mx.allclose(out, out_2d.squeeze(2)))
+
+    def test_conv2d_unaligned_channels(self):
+        x = mx.random.uniform(shape=(2, 16, 16, 21))
+        w = mx.random.uniform(shape=(32, 3, 3, 21))
+        y = mx.conv2d(x, w, stream=mx.cpu)
+        y_hat = mx.conv2d(x, w)
+        self.assertTrue(mx.allclose(y, y_hat))
+
+        x = mx.random.uniform(shape=(2, 16, 16, 21))
+        w = mx.random.uniform(shape=(21, 3, 3, 21))
+        y = mx.conv2d(x, w, stream=mx.cpu)
+        y_hat = mx.conv2d(x, w)
+        self.assertTrue(mx.allclose(y, y_hat))
+
+    def test_conv2d_large_filter_small_channels(self):
+        x = mx.random.normal(shape=(1, 181, 181, 1))
+        w = mx.random.normal(shape=(1, 182, 182, 1))
+        y = mx.conv2d(x, w, (1, 1), (1, 1), stream=mx.cpu)
+        y_hat = mx.conv2d(x, w, (1, 1), (1, 1))
+        self.assertTrue(mx.allclose(y, y_hat, rtol=1e-3, atol=1e-3))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_conv_transpose.py b/ml-stable-diffusion/mlx/python/tests/test_conv_transpose.py
new file mode 100644
index 0000000000000000000000000000000000000000..7289955ed42becadae9d4ecd3915d5393a28ffe9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_conv_transpose.py
@@ -0,0 +1,810 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+import unittest
+from itertools import permutations
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+try:
+    import torch
+    import torch.nn.functional as F
+
+    has_torch = True
+except ImportError as e:
+    has_torch = False
+
+
+class TestConvTranspose(mlx_tests.MLXTestCase):
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_transpose_1D(self):
+        def run_conv_transpose_1D(
+            N,
+            C,
+            O,
+            iH,
+            kH,
+            stride,
+            padding,
+            output_padding=0,
+            dilation=1,
+            groups=1,
+            dtype="float32",
+            atol=1e-5,
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                iH=iH,
+                kH=kH,
+                stride=stride,
+                padding=padding,
+                dilation=dilation,
+                groups=groups,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                in_np = np.random.normal(0, 1.0 / C, (N, iH, C)).astype(np_dtype)
+                wt_np = np.random.normal(0, 1.0 / C, (O, kH, int(C / groups))).astype(
+                    np_dtype
+                )
+
+                in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+                in_pt = torch.from_numpy(in_np.transpose(0, 2, 1))
+                wt_pt = torch.from_numpy(wt_np.transpose(2, 0, 1))
+
+                out_mx = mx.conv_transpose1d(
+                    in_mx,
+                    wt_mx,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                out_pt = torch.conv_transpose1d(
+                    in_pt,
+                    wt_pt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                out_pt = torch.transpose(out_pt, 2, 1)
+
+                self.assertEqual(out_pt.shape, out_mx.shape)
+                self.assertTrue(np.allclose(out_pt.numpy(), out_mx, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in (
+                (1, 1, 1),
+                (1, 6, 1),
+                (1, 1, 6),
+                (4, 32, 64),
+            ):
+                for iH, kH, stride, padding in (
+                    (1, 1, 1, 0),
+                    (3, 3, 1, 0),
+                    (31, 5, 5, 2),
+                ):
+                    run_conv_transpose_1D(N, C, O, iH, kH, stride, padding, dtype=dtype)
+
+        # Groups tests
+        N, C, O = (4, 32, 64)
+        for iH, kH, stride, padding in (
+            (1, 1, 1, 0),
+            (3, 3, 1, 0),
+            (31, 5, 5, 2),
+        ):
+            for group in (1,):
+                run_conv_transpose_1D(
+                    N, C, O, iH, kH, stride, padding, groups=group, dtype=dtype
+                )
+
+        # Strided inputs tests
+        for tpose_in, tpose_wt in (
+            ((0, 2, 1), (0, 1, 2)),
+            ((0, 2, 1), (0, 2, 1)),
+        ):
+            with self.subTest(name="strided", tpose_in=tpose_in, tpose_wt=tpose_wt):
+                in_np = np.random.normal(0, 1.0 / 16, (16, 16, 16)).astype(np.float32)
+                wt_np = np.random.normal(0, 1.0 / 16, (16, 16, 16)).astype(np.float32)
+
+                in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+                in_mx_t = mx.transpose(in_mx, tpose_in)
+                wt_mx_t = mx.transpose(wt_mx, tpose_wt)
+                out_mx = mx.conv_transpose1d(in_mx_t, wt_mx_t)
+
+                in_pt = torch.from_numpy(in_np.transpose(tpose_in).transpose(0, 2, 1))
+                wt_pt = torch.from_numpy(wt_np.transpose(tpose_wt).transpose(2, 0, 1))
+
+                out_pt = torch.conv_transpose1d(in_pt, wt_pt)
+                out_pt = torch.transpose(out_pt, 2, 1)
+
+                self.assertEqual(out_pt.shape, out_mx.shape)
+                self.assertTrue(np.allclose(out_pt.numpy(), out_mx, atol=1e-5))
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_transpose_1D_grad(self):
+        def run_conv_transpose1D_grad(
+            N,
+            C,
+            O,
+            iH,
+            kH,
+            stride,
+            padding,
+            dilation=1,
+            groups=1,
+            dtype="float32",
+            atol=1e-5,
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                iH=iH,
+                kH=kH,
+                stride=stride,
+                padding=padding,
+                dilation=dilation,
+                groups=groups,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                # oH = 1 + ((iH + 2 * padding - dilation * (kH - 1) - 1) // stride)
+
+                in_np = np.random.normal(0, 1.0 / C, (N, iH, C)).astype(np_dtype)
+                wt_np = np.random.normal(0, 1.0 / C, (O, kH, C)).astype(np_dtype)
+
+                in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+                in_pt = torch.from_numpy(in_np.transpose(0, 2, 1)).requires_grad_(True)
+                wt_pt = torch.from_numpy(wt_np.transpose(2, 0, 1)).requires_grad_(True)
+
+                out_pt = F.conv_transpose1d(
+                    in_pt, wt_pt, stride=stride, padding=padding, dilation=dilation
+                )
+
+                # use torch to compute ct
+                out_pt.retain_grad()
+                out_pt.sum().backward()
+
+                pt_grad_in = in_pt.grad.permute(0, 2, 1).numpy()
+                pt_grad_wt = wt_pt.grad.permute(1, 2, 0).numpy()
+
+                ct_mx = mx.array(out_pt.grad.numpy().transpose(0, 2, 1))
+
+                def f(a, b):
+                    return mx.conv_transpose1d(
+                        a,
+                        b,
+                        stride=stride,
+                        padding=padding,
+                        dilation=dilation,
+                        groups=groups,
+                    )
+
+                _, outs_mx = mx.vjp(
+                    f,
+                    [
+                        in_mx,
+                        wt_mx,
+                    ],
+                    [
+                        ct_mx,
+                    ],
+                )
+
+                mx_grad_in, mx_grad_wt = outs_mx
+
+                self.assertEqual(pt_grad_in.shape, mx_grad_in.shape)
+                self.assertEqual(in_mx.shape, mx_grad_in.shape)
+                self.assertTrue(np.allclose(pt_grad_in, mx_grad_in, atol=atol))
+
+                self.assertEqual(pt_grad_wt.shape, mx_grad_wt.shape)
+                self.assertEqual(wt_mx.shape, mx_grad_wt.shape)
+                self.assertTrue(np.allclose(pt_grad_wt, mx_grad_wt, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in (
+                (1, 1, 1),
+                (1, 6, 1),
+                (1, 1, 6),
+                (4, 32, 64),
+            ):
+                for iH, kH, stride, padding in (
+                    (1, 1, 1, 0),
+                    (3, 3, 1, 0),
+                    (31, 5, 5, 2),
+                ):
+                    run_conv_transpose1D_grad(
+                        N, C, O, iH, kH, stride, padding, dtype=dtype
+                    )
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_transpose_2D(self):
+        def run_conv_transpose2D(
+            N,
+            C,
+            O,
+            idim,
+            kdim,
+            stride,
+            padding,
+            dilation=(1, 1),
+            groups=1,
+            dtype="float32",
+            atol=1e-5,
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                idim=idim,
+                kdim=kdim,
+                stride=stride,
+                padding=padding,
+                dilation=dilation,
+                groups=groups,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                iH, iW = idim
+                kH, kW = kdim
+                scale = 1.0 / math.sqrt(kH * kW * C)
+                in_np = np.random.normal(0.0, scale, (N, iH, iW, C)).astype(np_dtype)
+                wt_np = np.random.normal(0.0, 1.0, (O, kH, kW, int(C / groups))).astype(
+                    np_dtype
+                )
+
+                in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+                in_pt = torch.from_numpy(in_np.transpose(0, 3, 1, 2)).to("cpu")
+                wt_pt = torch.from_numpy(wt_np.transpose(3, 0, 1, 2)).to("cpu")
+
+                out_mx = mx.conv_transpose2d(
+                    in_mx,
+                    wt_mx,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                out_pt = torch.conv_transpose2d(
+                    in_pt,
+                    wt_pt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                out_pt = torch.permute(out_pt, (0, 2, 3, 1)).numpy(force=True)
+
+                self.assertEqual(out_pt.shape, out_mx.shape)
+                self.assertTrue(np.allclose(out_pt, out_mx, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in (
+                (1, 1, 1),
+                (1, 6, 1),
+                (1, 1, 6),
+                (4, 32, 64),
+            ):
+                for idim, kdim, stride, padding in (
+                    ((1, 1), (1, 1), (1, 1), (0, 0)),
+                    ((3, 3), (3, 1), (1, 1), (0, 0)),
+                    ((31, 31), (5, 5), (5, 5), (2, 2)),
+                ):
+                    run_conv_transpose2D(
+                        N, C, O, idim, kdim, stride, padding, dtype=dtype
+                    )
+
+            # Groups tests
+            N, C, O = (4, 32, 64)
+            for idim, kdim, stride, padding in (
+                ((1, 1), (1, 1), (1, 1), (0, 0)),
+                ((3, 3), (3, 1), (1, 1), (0, 0)),
+                ((31, 31), (5, 5), (5, 5), (2, 2)),
+            ):
+                for group in (1,):
+                    run_conv_transpose2D(
+                        N, C, O, idim, kdim, stride, padding, groups=group, dtype=dtype
+                    )
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_transpose_2D_grad(self):
+        def run_conv_transpose2D_grad(
+            N,
+            C,
+            O,
+            idim,
+            kdim,
+            stride,
+            padding,
+            dilation=(1, 1),
+            groups=1,
+            dtype="float32",
+            atol=1e-5,
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                idim=idim,
+                kdim=kdim,
+                stride=stride,
+                padding=padding,
+                dilation=dilation,
+                groups=groups,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                iH, iW = idim
+                kH, kW = kdim
+                scale = 1.0 / math.sqrt(kH * kW * C * O)
+
+                in_np = np.random.normal(0.0, scale, (N, iH, iW, C)).astype(np_dtype)
+                wt_np = np.random.normal(0.0, scale, (O, kH, kW, C)).astype(np_dtype)
+
+                in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+                in_pt = torch.from_numpy(in_np.transpose(0, 3, 1, 2)).requires_grad_(
+                    True
+                )
+                wt_pt = torch.from_numpy(wt_np.transpose(3, 0, 1, 2)).requires_grad_(
+                    True
+                )
+
+                out_pt = F.conv_transpose2d(
+                    in_pt, wt_pt, stride=stride, padding=padding, dilation=dilation
+                )
+
+                # use torch to compute ct
+                out_pt.retain_grad()
+                out_pt.sum().backward()
+
+                pt_grad_in = in_pt.grad.permute(0, 2, 3, 1).numpy()
+                pt_grad_wt = wt_pt.grad.permute(1, 2, 3, 0).numpy()
+
+                ct_mx = mx.array(out_pt.grad.numpy().transpose(0, 2, 3, 1))
+
+                def f(a, b):
+                    return mx.conv_transpose2d(
+                        a,
+                        b,
+                        stride=stride,
+                        padding=padding,
+                        dilation=dilation,
+                        groups=groups,
+                    )
+
+                _, outs_mx = mx.vjp(
+                    f,
+                    [in_mx, wt_mx],
+                    [ct_mx],
+                )
+
+                mx_grad_in, mx_grad_wt = outs_mx
+
+                self.assertEqual(pt_grad_in.shape, mx_grad_in.shape)
+                self.assertEqual(in_mx.shape, mx_grad_in.shape)
+                self.assertTrue(np.allclose(pt_grad_in, mx_grad_in, atol=atol))
+
+                self.assertEqual(pt_grad_wt.shape, mx_grad_wt.shape)
+                self.assertEqual(wt_mx.shape, mx_grad_wt.shape)
+                self.assertTrue(np.allclose(pt_grad_wt, mx_grad_wt, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in ((1, 1, 1), (1, 6, 1), (1, 1, 6), (4, 32, 64), (4, 16, 32)):
+                for idim, kdim, stride, padding, dilation in (
+                    ((1, 1), (1, 1), (1, 1), (0, 0), (1, 1)),
+                    ((3, 3), (3, 1), (1, 1), (0, 0), (1, 1)),
+                    ((31, 31), (5, 5), (5, 5), (2, 2), (1, 1)),
+                    ((32, 32), (3, 3), (2, 2), (1, 1), (1, 1)),
+                    ((31, 31), (5, 5), (5, 5), (2, 2), (3, 2)),
+                    ((32, 32), (3, 3), (2, 2), (1, 1), (3, 2)),
+                ):
+                    run_conv_transpose2D_grad(
+                        N, C, O, idim, kdim, stride, padding, dilation, dtype=dtype
+                    )
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_transpose_3D(self):
+        def run_conv_transpose3D(
+            N,
+            C,
+            O,
+            idim,
+            kdim,
+            stride,
+            padding,
+            dilation=(1, 1, 1),
+            groups=1,
+            dtype="float32",
+            atol=1e-5,
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                idim=idim,
+                kdim=kdim,
+                stride=stride,
+                padding=padding,
+                dilation=dilation,
+                groups=groups,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                iD, iH, iW = idim
+                kD, kH, kW = kdim
+                scale = 1.0 / math.sqrt(kD * kH * kW * C * O)
+                in_np = np.random.normal(0.0, scale, (N, iD, iH, iW, C)).astype(
+                    np_dtype
+                )
+                wt_np = np.random.normal(0.0, 1.0, (O, kD, kH, kW, C)).astype(np_dtype)
+
+                in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+                in_pt = torch.from_numpy(in_np.transpose(0, 4, 1, 2, 3))
+                wt_pt = torch.from_numpy(wt_np.transpose(4, 0, 1, 2, 3))
+
+                out_mx = mx.conv_transpose3d(
+                    in_mx,
+                    wt_mx,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                out_pt = torch.conv_transpose3d(
+                    in_pt,
+                    wt_pt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+                out_pt = torch.permute(out_pt, (0, 2, 3, 4, 1)).numpy(force=True)
+
+                self.assertEqual(out_pt.shape, out_mx.shape)
+                self.assertTrue(np.allclose(out_pt, out_mx, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in (
+                (1, 1, 1),
+                (1, 6, 1),
+                (1, 1, 6),
+                (2, 8, 16),
+            ):
+                for idim, kdim, stride, padding in (
+                    ((1, 1, 1), (1, 1, 1), (1, 1, 1), (0, 0, 0)),
+                    ((3, 3, 3), (3, 1, 1), (1, 1, 1), (0, 0, 0)),
+                    ((15, 15, 15), (3, 3, 3), (3, 3, 3), (2, 2, 2)),
+                ):
+                    run_conv_transpose3D(
+                        N, C, O, idim, kdim, stride, padding, dtype=dtype
+                    )
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_transpose_3D_grad(self):
+        def run_conv_transpose3D_grad(
+            N,
+            C,
+            O,
+            idim,
+            kdim,
+            stride,
+            padding,
+            dilation=(1, 1, 1),
+            groups=1,
+            dtype="float32",
+            atol=1e-4,
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                idim=idim,
+                kdim=kdim,
+                stride=stride,
+                padding=padding,
+                dilation=dilation,
+                groups=groups,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                iD, iH, iW = idim
+                kD, kH, kW = kdim
+                scale = 1.0 / math.sqrt(kD * kH * kW * C * O)
+
+                in_np = np.random.normal(0.0, scale, (N, iD, iH, iW, C)).astype(
+                    np_dtype
+                )
+                wt_np = np.random.normal(0.0, scale, (O, kD, kH, kW, C)).astype(
+                    np_dtype
+                )
+
+                in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+                in_pt = torch.from_numpy(in_np.transpose(0, 4, 1, 2, 3)).requires_grad_(
+                    True
+                )
+                wt_pt = torch.from_numpy(wt_np.transpose(4, 0, 1, 2, 3)).requires_grad_(
+                    True
+                )
+
+                out_pt = F.conv_transpose3d(
+                    in_pt,
+                    wt_pt,
+                    stride=stride,
+                    padding=padding,
+                    dilation=dilation,
+                    groups=groups,
+                )
+
+                # use torch to compute ct
+                out_pt.retain_grad()
+                out_pt.sum().backward()
+
+                pt_grad_in = in_pt.grad.permute(0, 2, 3, 4, 1).numpy()
+                pt_grad_wt = wt_pt.grad.permute(1, 2, 3, 4, 0).numpy()
+
+                ct_mx = mx.array(out_pt.grad.numpy().transpose(0, 2, 3, 4, 1))
+
+                def f(a, b):
+                    return mx.conv_transpose3d(
+                        a,
+                        b,
+                        stride=stride,
+                        padding=padding,
+                        dilation=dilation,
+                        groups=groups,
+                    )
+
+                _, outs_mx = mx.vjp(
+                    f,
+                    [in_mx, wt_mx],
+                    [ct_mx],
+                )
+
+                mx_grad_in, mx_grad_wt = outs_mx
+
+                self.assertEqual(pt_grad_in.shape, mx_grad_in.shape)
+                self.assertEqual(in_mx.shape, mx_grad_in.shape)
+                self.assertTrue(np.allclose(pt_grad_in, mx_grad_in, atol=atol))
+
+                self.assertEqual(pt_grad_wt.shape, mx_grad_wt.shape)
+                self.assertEqual(wt_mx.shape, mx_grad_wt.shape)
+                self.assertTrue(np.allclose(pt_grad_wt, mx_grad_wt, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in ((1, 1, 1), (1, 6, 1), (1, 1, 6), (2, 4, 8), (2, 8, 16)):
+                for idim, kdim, stride, padding, dilation in (
+                    ((1, 1, 1), (1, 1, 1), (1, 1, 1), (0, 0, 0), (1, 1, 1)),
+                    ((3, 3, 3), (3, 1, 1), (1, 1, 1), (0, 0, 0), (1, 1, 1)),
+                    ((7, 7, 7), (5, 5, 5), (5, 5, 5), (2, 2, 2), (1, 1, 1)),
+                    ((8, 8, 8), (3, 3, 3), (2, 2, 2), (1, 1, 1), (1, 1, 1)),
+                    ((7, 7, 7), (5, 5, 5), (3, 3, 3), (2, 2, 2), (3, 2, 2)),
+                    ((8, 8, 8), (3, 3, 3), (2, 2, 2), (1, 1, 1), (3, 2, 2)),
+                ):
+                    run_conv_transpose3D_grad(
+                        N, C, O, idim, kdim, stride, padding, dilation, dtype=dtype
+                    )
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_tranpose_1d_output_padding(self):
+        def run_conv_transpose_1d_output_padding(
+            N, C, O, iH, kH, stride, padding, output_padding, dtype="float32", atol=1e-5
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                iH=iH,
+                kH=kH,
+                stride=stride,
+                padding=padding,
+                output_padding=output_padding,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                in_np = np.random.normal(0, 1.0 / C, (N, iH, C)).astype(np_dtype)
+                wt_np = np.random.normal(0, 1.0 / C, (O, kH, C)).astype(np_dtype)
+
+                in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+                in_pt = torch.from_numpy(in_np.transpose(0, 2, 1))
+                wt_pt = torch.from_numpy(wt_np.transpose(2, 0, 1))
+
+                out_mx = mx.conv_transpose1d(
+                    in_mx,
+                    wt_mx,
+                    stride=stride,
+                    padding=padding,
+                    output_padding=output_padding,
+                )
+
+                out_pt = torch.conv_transpose1d(
+                    in_pt,
+                    wt_pt,
+                    stride=stride,
+                    padding=padding,
+                    output_padding=output_padding,
+                )
+                out_pt = torch.transpose(out_pt, 2, 1)
+
+                self.assertEqual(out_pt.shape, out_mx.shape)
+                self.assertTrue(np.allclose(out_pt.numpy(), out_mx, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in ((1, 1, 1), (1, 6, 1), (4, 32, 64)):
+                for iH, kH, stride, padding, output_padding in (
+                    (3, 2, 2, 0, 1),
+                    (5, 3, 2, 1, 0),
+                    (7, 4, 3, 1, 2),
+                ):
+                    run_conv_transpose_1d_output_padding(
+                        N, C, O, iH, kH, stride, padding, output_padding, dtype=dtype
+                    )
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_transpose_2d_output_padding(self):
+        def run_conv_transpose_2d_output_padding(
+            N,
+            C,
+            O,
+            idim,
+            kdim,
+            stride,
+            padding,
+            output_padding,
+            dtype="float32",
+            atol=1e-5,
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                idim=idim,
+                kdim=kdim,
+                stride=stride,
+                padding=padding,
+                output_padding=output_padding,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                iH, iW = idim
+                kH, kW = kdim
+                in_np = np.random.normal(0, 1.0 / C, (N, iH, iW, C)).astype(np_dtype)
+                wt_np = np.random.normal(0, 1.0 / C, (O, kH, kW, C)).astype(np_dtype)
+
+                in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+                in_pt = torch.from_numpy(in_np.transpose(0, 3, 1, 2))
+                wt_pt = torch.from_numpy(wt_np.transpose(3, 0, 1, 2))
+
+                out_mx = mx.conv_transpose2d(
+                    in_mx,
+                    wt_mx,
+                    stride=stride,
+                    padding=padding,
+                    output_padding=output_padding,
+                )
+
+                out_pt = torch.conv_transpose2d(
+                    in_pt,
+                    wt_pt,
+                    stride=stride,
+                    padding=padding,
+                    output_padding=output_padding,
+                )
+                out_pt = torch.permute(out_pt, (0, 2, 3, 1)).numpy(force=True)
+
+                self.assertEqual(out_pt.shape, out_mx.shape)
+                self.assertTrue(np.allclose(out_pt, out_mx, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in ((1, 1, 1), (1, 6, 1), (4, 32, 64)):
+                for idim, kdim, stride, padding, output_padding in (
+                    ((3, 3), (2, 2), (2, 2), (0, 0), (1, 1)),
+                    ((5, 5), (3, 3), (2, 2), (1, 1), (0, 0)),
+                    ((7, 7), (4, 4), (3, 3), (1, 1), (2, 2)),
+                ):
+                    run_conv_transpose_2d_output_padding(
+                        N,
+                        C,
+                        O,
+                        idim,
+                        kdim,
+                        stride,
+                        padding,
+                        output_padding,
+                        dtype=dtype,
+                    )
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_conv_transpose_3d_output_padding(self):
+        def run_conv_transpose_3d_output_padding(
+            N,
+            C,
+            O,
+            idim,
+            kdim,
+            stride,
+            padding,
+            output_padding,
+            dtype="float32",
+            atol=1e-5,
+        ):
+            with self.subTest(
+                dtype=dtype,
+                N=N,
+                C=C,
+                O=O,
+                idim=idim,
+                kdim=kdim,
+                stride=stride,
+                padding=padding,
+                output_padding=output_padding,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                iD, iH, iW = idim
+                kD, kH, kW = kdim
+                in_np = np.random.normal(0, 1.0 / C, (N, iD, iH, iW, C)).astype(
+                    np_dtype
+                )
+                wt_np = np.random.normal(0, 1.0 / C, (O, kD, kH, kW, C)).astype(
+                    np_dtype
+                )
+
+                in_mx, wt_mx = map(mx.array, (in_np, wt_np))
+                in_pt = torch.from_numpy(in_np.transpose(0, 4, 1, 2, 3))
+                wt_pt = torch.from_numpy(wt_np.transpose(4, 0, 1, 2, 3))
+
+                out_mx = mx.conv_transpose3d(
+                    in_mx,
+                    wt_mx,
+                    stride=stride,
+                    padding=padding,
+                    output_padding=output_padding,
+                )
+                out_pt = torch.conv_transpose3d(
+                    in_pt,
+                    wt_pt,
+                    stride=stride,
+                    padding=padding,
+                    output_padding=output_padding,
+                )
+                out_pt = torch.permute(out_pt, (0, 2, 3, 4, 1)).numpy(force=True)
+
+                self.assertEqual(out_pt.shape, out_mx.shape)
+                self.assertTrue(np.allclose(out_pt, out_mx, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C, O in ((1, 1, 1), (1, 6, 1), (4, 32, 64)):
+                for idim, kdim, stride, padding, output_padding in (
+                    ((3, 3, 3), (2, 2, 2), (2, 2, 2), (0, 0, 0), (1, 1, 1)),
+                    ((5, 5, 5), (3, 3, 3), (2, 2, 2), (1, 1, 1), (0, 0, 0)),
+                    ((7, 7, 7), (4, 4, 4), (3, 3, 3), (1, 1, 1), (2, 2, 2)),
+                ):
+                    run_conv_transpose_3d_output_padding(
+                        N,
+                        C,
+                        O,
+                        idim,
+                        kdim,
+                        stride,
+                        padding,
+                        output_padding,
+                        dtype=dtype,
+                    )
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_device.py b/ml-stable-diffusion/mlx/python/tests/test_device.py
new file mode 100644
index 0000000000000000000000000000000000000000..d51028def47ec06a67a16d87b996966f1f757101
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_device.py
@@ -0,0 +1,117 @@
+# Copyright © 2023 Apple Inc.
+
+import unittest
+
+import mlx.core as mx
+import mlx_tests
+
+
+# Don't inherit from MLXTestCase to avoid call to setUp
+class TestDefaultDevice(unittest.TestCase):
+    def test_mlx_default_device(self):
+        device = mx.default_device()
+        if mx.is_available(mx.gpu):
+            self.assertEqual(device, mx.Device(mx.gpu))
+            self.assertEqual(str(device), "Device(gpu, 0)")
+            self.assertEqual(device, mx.gpu)
+            self.assertEqual(mx.gpu, device)
+        else:
+            self.assertEqual(device.type, mx.Device(mx.cpu))
+            with self.assertRaises(ValueError):
+                mx.set_default_device(mx.gpu)
+
+
+class TestDevice(mlx_tests.MLXTestCase):
+    def test_device(self):
+        device = mx.default_device()
+
+        cpu = mx.Device(mx.cpu)
+        mx.set_default_device(cpu)
+        self.assertEqual(mx.default_device(), cpu)
+        self.assertEqual(str(cpu), "Device(cpu, 0)")
+
+        mx.set_default_device(mx.cpu)
+        self.assertEqual(mx.default_device(), mx.cpu)
+        self.assertEqual(cpu, mx.cpu)
+        self.assertEqual(mx.cpu, cpu)
+
+        # Restore device
+        mx.set_default_device(device)
+
+    @unittest.skipIf(not mx.is_available(mx.gpu), "GPU is not available")
+    def test_device_context(self):
+        default = mx.default_device()
+        diff = mx.cpu if default == mx.gpu else mx.gpu
+        self.assertNotEqual(default, diff)
+        with mx.stream(diff):
+            a = mx.add(mx.zeros((2, 2)), mx.ones((2, 2)))
+            mx.eval(a)
+            self.assertEqual(mx.default_device(), diff)
+        self.assertEqual(mx.default_device(), default)
+
+    def test_op_on_device(self):
+        x = mx.array(1.0)
+        y = mx.array(1.0)
+
+        a = mx.add(x, y, stream=None)
+        b = mx.add(x, y, stream=mx.default_device())
+        self.assertEqual(a.item(), b.item())
+        b = mx.add(x, y, stream=mx.cpu)
+        self.assertEqual(a.item(), b.item())
+
+        if mx.metal.is_available():
+            b = mx.add(x, y, stream=mx.gpu)
+            self.assertEqual(a.item(), b.item())
+
+
+class TestStream(mlx_tests.MLXTestCase):
+    def test_stream(self):
+        s1 = mx.default_stream(mx.default_device())
+        self.assertEqual(s1.device, mx.default_device())
+
+        s2 = mx.new_stream(mx.default_device())
+        self.assertEqual(s2.device, mx.default_device())
+        self.assertNotEqual(s1, s2)
+
+        if mx.is_available(mx.gpu):
+            s_gpu = mx.default_stream(mx.gpu)
+            self.assertEqual(s_gpu.device, mx.gpu)
+        else:
+            with self.assertRaises(ValueError):
+                mx.default_stream(mx.gpu)
+
+        s_cpu = mx.default_stream(mx.cpu)
+        self.assertEqual(s_cpu.device, mx.cpu)
+
+        s_cpu = mx.new_stream(mx.cpu)
+        self.assertEqual(s_cpu.device, mx.cpu)
+
+        if mx.is_available(mx.gpu):
+            s_gpu = mx.new_stream(mx.gpu)
+            self.assertEqual(s_gpu.device, mx.gpu)
+        else:
+            with self.assertRaises(ValueError):
+                mx.new_stream(mx.gpu)
+
+    def test_op_on_stream(self):
+        x = mx.array(1.0)
+        y = mx.array(1.0)
+
+        a = mx.add(x, y, stream=mx.default_stream(mx.default_device()))
+
+        if mx.is_available(mx.gpu):
+            b = mx.add(x, y, stream=mx.default_stream(mx.gpu))
+            self.assertEqual(a.item(), b.item())
+            s_gpu = mx.new_stream(mx.gpu)
+            b = mx.add(x, y, stream=s_gpu)
+            self.assertEqual(a.item(), b.item())
+
+        b = mx.add(x, y, stream=mx.default_stream(mx.cpu))
+        self.assertEqual(a.item(), b.item())
+        s_cpu = mx.new_stream(mx.cpu)
+        b = mx.add(x, y, stream=s_cpu)
+        self.assertEqual(a.item(), b.item())
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_double.py b/ml-stable-diffusion/mlx/python/tests/test_double.py
new file mode 100644
index 0000000000000000000000000000000000000000..fccf3628fccf68874aa659f65154d83abdbe06d4
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_double.py
@@ -0,0 +1,297 @@
+# Copyright © 2024 Apple Inc.
+
+import math
+import os
+import unittest
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+
+class TestDouble(mlx_tests.MLXTestCase):
+    def test_unary_ops(self):
+        shape = (3, 3)
+        x = mx.random.normal(shape=shape)
+
+        if mx.default_device() == mx.gpu:
+            with self.assertRaises(ValueError):
+                x.astype(mx.float64)
+
+        x_double = x.astype(mx.float64, stream=mx.cpu)
+
+        ops = [
+            mx.abs,
+            mx.arccos,
+            mx.arccosh,
+            mx.arcsin,
+            mx.arcsinh,
+            mx.arctan,
+            mx.arctanh,
+            mx.ceil,
+            mx.erf,
+            mx.erfinv,
+            mx.exp,
+            mx.expm1,
+            mx.floor,
+            mx.log,
+            mx.logical_not,
+            mx.negative,
+            mx.round,
+            mx.sin,
+            mx.sinh,
+            mx.sqrt,
+            mx.rsqrt,
+            mx.tan,
+            mx.tanh,
+        ]
+        for op in ops:
+            if mx.default_device() == mx.gpu:
+                with self.assertRaises(ValueError):
+                    op(x_double)
+                continue
+            y = op(x)
+            y_double = op(x_double)
+            self.assertTrue(
+                mx.allclose(y, y_double.astype(mx.float32, mx.cpu), equal_nan=True)
+            )
+
+    def test_binary_ops(self):
+        shape = (3, 3)
+        a = mx.random.normal(shape=shape)
+        b = mx.random.normal(shape=shape)
+
+        a_double = a.astype(mx.float64, stream=mx.cpu)
+        b_double = b.astype(mx.float64, stream=mx.cpu)
+
+        ops = [
+            mx.add,
+            mx.arctan2,
+            mx.divide,
+            mx.multiply,
+            mx.subtract,
+            mx.logical_and,
+            mx.logical_or,
+            mx.remainder,
+            mx.maximum,
+            mx.minimum,
+            mx.power,
+            mx.equal,
+            mx.greater,
+            mx.greater_equal,
+            mx.less,
+            mx.less_equal,
+            mx.not_equal,
+            mx.logaddexp,
+        ]
+        for op in ops:
+            if mx.default_device() == mx.gpu:
+                with self.assertRaises(ValueError):
+                    op(a_double, b_double)
+                continue
+            y = op(a, b)
+            y_double = op(a_double, b_double)
+            self.assertTrue(
+                mx.allclose(y, y_double.astype(mx.float32, mx.cpu), equal_nan=True)
+            )
+
+    def test_where(self):
+        shape = (3, 3)
+        cond = mx.random.uniform(shape=shape) > 0.5
+        a = mx.random.normal(shape=shape)
+        b = mx.random.normal(shape=shape)
+
+        a_double = a.astype(mx.float64, stream=mx.cpu)
+        b_double = b.astype(mx.float64, stream=mx.cpu)
+
+        if mx.default_device() == mx.gpu:
+            with self.assertRaises(ValueError):
+                mx.where(cond, a_double, b_double)
+            return
+        y = mx.where(cond, a, b)
+        y_double = mx.where(cond, a_double, b_double)
+        self.assertTrue(mx.allclose(y, y_double.astype(mx.float32, mx.cpu)))
+
+    def test_reductions(self):
+        shape = (32, 32)
+        a = mx.random.normal(shape=shape)
+        a_double = a.astype(mx.float64, stream=mx.cpu)
+
+        axes = [0, 1, (0, 1)]
+        ops = [mx.sum, mx.prod, mx.min, mx.max, mx.any, mx.all]
+
+        for op in ops:
+            for ax in axes:
+                if mx.default_device() == mx.gpu:
+                    with self.assertRaises(ValueError):
+                        op(a_double, axis=ax)
+                    continue
+                y = op(a)
+                y_double = op(a_double)
+                self.assertTrue(mx.allclose(y, y_double.astype(mx.float32, mx.cpu)))
+
+    def test_get_and_set_item(self):
+        shape = (3, 3)
+        a = mx.random.normal(shape=shape)
+        b = mx.random.normal(shape=(2,))
+        a_double = a.astype(mx.float64, stream=mx.cpu)
+        b_double = b.astype(mx.float64, stream=mx.cpu)
+        idx_i = mx.array([0, 2])
+        idx_j = mx.array([0, 2])
+
+        if mx.default_device() == mx.gpu:
+            with self.assertRaises(ValueError):
+                a_double[idx_i, idx_j]
+        else:
+            y = a[idx_i, idx_j]
+            y_double = a_double[idx_i, idx_j]
+            self.assertTrue(mx.allclose(y, y_double.astype(mx.float32, mx.cpu)))
+
+        if mx.default_device() == mx.gpu:
+            with self.assertRaises(ValueError):
+                a_double[idx_i, idx_j] = b_double
+        else:
+            a[idx_i, idx_j] = b
+            a_double[idx_i, idx_j] = b_double
+            self.assertTrue(mx.allclose(a, a_double.astype(mx.float32, mx.cpu)))
+
+    def test_gemm(self):
+        shape = (8, 8)
+        a = mx.random.normal(shape=shape)
+        b = mx.random.normal(shape=shape)
+
+        a_double = a.astype(mx.float64, stream=mx.cpu)
+        b_double = b.astype(mx.float64, stream=mx.cpu)
+
+        if mx.default_device() == mx.gpu:
+            with self.assertRaises(ValueError):
+                a_double @ b_double
+            return
+        y = a @ b
+        y_double = a_double @ b_double
+        self.assertTrue(
+            mx.allclose(y, y_double.astype(mx.float32, mx.cpu), equal_nan=True)
+        )
+
+    def test_type_promotion(self):
+        import mlx.core as mx
+
+        a = mx.array([4, 8], mx.float64)
+        b = mx.array([4, 8], mx.int32)
+
+        with mx.stream(mx.cpu):
+            c = a + b
+            self.assertEqual(c.dtype, mx.float64)
+
+    def test_lapack(self):
+        with mx.stream(mx.cpu):
+            # QRF
+            A = mx.array([[2.0, 3.0], [1.0, 2.0]], dtype=mx.float64)
+            Q, R = mx.linalg.qr(A)
+            out = Q @ R
+            self.assertTrue(mx.allclose(out, A))
+            out = Q.T @ Q
+            self.assertTrue(mx.allclose(out, mx.eye(2)))
+            self.assertTrue(mx.allclose(mx.tril(R, -1), mx.zeros_like(R)))
+            self.assertEqual(Q.dtype, mx.float64)
+            self.assertEqual(R.dtype, mx.float64)
+
+            # SVD
+            A = mx.array(
+                [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], dtype=mx.float64
+            )
+            U, S, Vt = mx.linalg.svd(A)
+            self.assertTrue(mx.allclose(U[:, : len(S)] @ mx.diag(S) @ Vt, A))
+
+            # Inverse
+            A = mx.array([[1, 2, 3], [6, -5, 4], [-9, 8, 7]], dtype=mx.float64)
+            A_inv = mx.linalg.inv(A)
+            self.assertTrue(mx.allclose(A @ A_inv, mx.eye(A.shape[0])))
+
+            # Tri inv
+            A = mx.array([[1, 0, 0], [6, -5, 0], [-9, 8, 7]], dtype=mx.float64)
+            B = mx.array([[7, 0, 0], [3, -2, 0], [1, 8, 3]], dtype=mx.float64)
+            AB = mx.stack([A, B])
+            invs = mx.linalg.tri_inv(AB, upper=False)
+            for M, M_inv in zip(AB, invs):
+                self.assertTrue(mx.allclose(M @ M_inv, mx.eye(M.shape[0])))
+
+            # Cholesky
+            sqrtA = mx.array(
+                [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]], dtype=mx.float64
+            )
+            A = sqrtA.T @ sqrtA / 81
+            L = mx.linalg.cholesky(A)
+            U = mx.linalg.cholesky(A, upper=True)
+            self.assertTrue(mx.allclose(L @ L.T, A))
+            self.assertTrue(mx.allclose(U.T @ U, A))
+
+            # Psueod inverse
+            A = mx.array([[1, 2, 3], [6, -5, 4], [-9, 8, 7]], dtype=mx.float64)
+            A_plus = mx.linalg.pinv(A)
+            self.assertTrue(mx.allclose(A @ A_plus @ A, A))
+
+            # Eigh
+            def check_eigs_and_vecs(A_np, kwargs={}):
+                A = mx.array(A_np, dtype=mx.float64)
+                eig_vals, eig_vecs = mx.linalg.eigh(A, **kwargs)
+                eig_vals_np, _ = np.linalg.eigh(A_np, **kwargs)
+                self.assertTrue(np.allclose(eig_vals, eig_vals_np))
+                self.assertTrue(
+                    mx.allclose(A @ eig_vecs, eig_vals[..., None, :] * eig_vecs)
+                )
+
+                eig_vals_only = mx.linalg.eigvalsh(A, **kwargs)
+                self.assertTrue(mx.allclose(eig_vals, eig_vals_only))
+
+            # Test a simple 2x2 symmetric matrix
+            A_np = np.array([[1.0, 2.0], [2.0, 4.0]], dtype=np.float64)
+            check_eigs_and_vecs(A_np)
+
+            # Test a larger random symmetric matrix
+            n = 5
+            np.random.seed(1)
+            A_np = np.random.randn(n, n).astype(np.float64)
+            A_np = (A_np + A_np.T) / 2
+            check_eigs_and_vecs(A_np)
+
+            # Test with upper triangle
+            check_eigs_and_vecs(A_np, {"UPLO": "U"})
+
+            # LU factorization
+            # Test 3x3 matrix
+            a = mx.array(
+                [[3.0, 1.0, 2.0], [1.0, 8.0, 6.0], [9.0, 2.0, 5.0]], dtype=mx.float64
+            )
+            P, L, U = mx.linalg.lu(a)
+            self.assertTrue(mx.allclose(L[P, :] @ U, a))
+
+            # Solve triangular
+            # Test lower triangular matrix
+            a = mx.array(
+                [[4.0, 0.0, 0.0], [2.0, 3.0, 0.0], [1.0, -2.0, 5.0]], dtype=mx.float64
+            )
+            b = mx.array([8.0, 14.0, 3.0], dtype=mx.float64)
+
+            result = mx.linalg.solve_triangular(a, b, upper=False)
+            expected = np.linalg.solve(np.array(a), np.array(b))
+            self.assertTrue(np.allclose(result, expected))
+
+            # Test upper triangular matrix
+            a = mx.array(
+                [[3.0, 2.0, 1.0], [0.0, 5.0, 4.0], [0.0, 0.0, 6.0]], dtype=mx.float64
+            )
+            b = mx.array([13.0, 33.0, 18.0], dtype=mx.float64)
+
+            result = mx.linalg.solve_triangular(a, b, upper=True)
+            expected = np.linalg.solve(np.array(a), np.array(b))
+            self.assertTrue(np.allclose(result, expected))
+
+    def test_conversion(self):
+        a = mx.array([1.0, 2.0], mx.float64)
+        b = np.array(a)
+        self.assertTrue(np.array_equal(a, b))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_einsum.py b/ml-stable-diffusion/mlx/python/tests/test_einsum.py
new file mode 100644
index 0000000000000000000000000000000000000000..a73ea381872f8888a8ef070c4676272de03b9dee
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_einsum.py
@@ -0,0 +1,363 @@
+# Copyright © 2024 Apple Inc.
+
+import unittest
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+
+class TestEinsum(mlx_tests.MLXTestCase):
+
+    def test_simple_path(self):
+        a = mx.zeros((5, 5))
+        path = mx.einsum_path("ii", a)
+        self.assertEqual(path[0], [(0,)])
+
+        path = mx.einsum_path("ij->i", a)
+        self.assertEqual(path[0], [(0,)])
+
+        path = mx.einsum_path("ii->i", a)
+        self.assertEqual(path[0], [(0,)])
+
+        a = mx.zeros((5, 8))
+        b = mx.zeros((8, 3))
+        path = mx.einsum_path("ij,jk", a, b)
+        self.assertEqual(path[0], [(0, 1)])
+        path = mx.einsum_path("ij,jk -> ijk", a, b)
+        self.assertEqual(path[0], [(0, 1)])
+
+        a = mx.zeros((5, 8))
+        b = mx.zeros((8, 3))
+        c = mx.zeros((3, 7))
+        path = mx.einsum_path("ij,jk,kl", a, b, c)
+
+        self.assertEqual(path[0], [(0, 1), (0, 1)])
+
+        a = mx.zeros((5, 8))
+        b = mx.zeros((8, 10))
+        c = mx.zeros((10, 7))
+        path = mx.einsum_path("ij,jk,kl", a, b, c)
+        self.assertEqual(path[0], [(1, 2), (0, 1)])
+
+    def test_longer_paths(self):
+        chars = "abcdefghijklmopqABC"
+        sizes = [2, 3, 4, 5, 4, 3, 2, 6, 5, 4, 3, 2, 5, 7, 4, 3, 2, 3, 4]
+        dim_dict = {c: s for c, s in zip(chars, sizes)}
+        cases = [
+            "eb,cb,fb->cef",
+            "dd,fb,be,cdb->cef",
+            "dd,fb,be,cdb->cef",
+            "bca,cdb,dbf,afc->",
+            "dcc,fce,ea,dbf->ab",
+            "dcc,fce,ea,dbf->ab",
+        ]
+
+        for case in cases:
+            subscripts = case[: case.find("->")].split(",")
+            inputs = []
+            for s in subscripts:
+                shape = [dim_dict[c] for c in s]
+                inputs.append(np.ones(shape))
+            np_path = np.einsum_path(case, *inputs)
+
+            inputs = [mx.array(i) for i in inputs]
+            mx_path = mx.einsum_path(case, *inputs)
+            self.assertEqual(np_path[0][1:], mx_path[0])
+
+    def test_simple_einsum(self):
+        a = mx.arange(4 * 4).reshape(4, 4)
+        a_mx = mx.einsum("ii->i", a)
+        a_np = np.einsum("ii->i", a)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        a = mx.arange(2 * 2 * 2).reshape(2, 2, 2)
+        a_mx = mx.einsum("iii->i", a)
+        a_np = np.einsum("iii->i", a)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        a = mx.arange(2 * 2 * 3 * 3).reshape(2, 2, 3, 3)
+        a_mx = mx.einsum("iijj->ij", a)
+        a_np = np.einsum("iijj->ij", a)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        a = mx.arange(2 * 2 * 3 * 3).reshape(2, 3, 2, 3)
+        a_mx = mx.einsum("ijij->ij", a)
+        a_np = np.einsum("ijij->ij", a)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        # Test some simple reductions
+        a = mx.arange(2 * 2).reshape(2, 2)
+        a_mx = mx.einsum("ii", a)
+        a_np = np.einsum("ii", a)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        a = mx.arange(2 * 4).reshape(2, 4)
+        a_mx = mx.einsum("ij->", a)
+        a_np = np.einsum("ij->", a)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        a = mx.arange(2 * 4).reshape(2, 4)
+        a_mx = mx.einsum("ij->i", a)
+        a_np = np.einsum("ij->i", a)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        a = mx.arange(2 * 4).reshape(2, 4)
+        a_mx = mx.einsum("ij->j", a)
+        a_np = np.einsum("ij->j", a)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        a = mx.arange(2 * 2 * 2).reshape(2, 2, 2)
+        a_mx = mx.einsum("iii->", a)
+        a_np = np.einsum("iii->", a)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        a = mx.arange(2 * 2 * 3 * 3).reshape(2, 3, 2, 3)
+        a_mx = mx.einsum("ijij->j", a)
+        a_np = np.einsum("ijij->j", a)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        # Test some simple transposes
+        a = mx.arange(2 * 4).reshape(2, 4)
+        a_mx = mx.einsum("ij", a)
+        a_np = np.einsum("ij", a)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        a = mx.arange(2 * 4).reshape(2, 4)
+        a_mx = mx.einsum("ij->ji", a)
+        a_np = np.einsum("ij->ji", a)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        a = mx.arange(2 * 3 * 4).reshape(2, 3, 4)
+        a_mx = mx.einsum("ijk->jki", a)
+        a_np = np.einsum("ijk->jki", a)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+    def test_two_input_einsum(self):
+
+        # Matmul
+        a = mx.full((2, 8), 1.0)
+        b = mx.full((8, 2), 1.0)
+        a_mx = mx.einsum("ik,kj", a, b)
+        a_np = np.einsum("ik,kj", a, b)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        # Matmul + transpose
+        a = mx.full((2, 8), 1.0)
+        b = mx.full((8, 3), 1.0)
+        a_mx = mx.einsum("ik,kj->ji", a, b)
+        a_np = np.einsum("ik,kj->ji", a, b)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        # Inner product
+        a = mx.full((4,), 1.0)
+        b = mx.full((4,), 1.0)
+        a_mx = mx.einsum("i,i", a, b)
+        a_np = np.einsum("i,i", a, b)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        # Outer product
+        a = mx.full((4,), 0.5)
+        b = mx.full((6,), 2.0)
+        a_mx = mx.einsum("i,j->ij", a, b)
+        a_np = np.einsum("i,j->ij", a, b)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        # Elementwise multiply
+        a = mx.full((2, 8), 1.0)
+        b = mx.full((2, 8), 1.0)
+        a_mx = mx.einsum("ij,ij->ij", a, b)
+        a_np = np.einsum("ij,ij->ij", a, b)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        # Medley
+        a = mx.full((2, 8, 3, 5), 1.0)
+        b = mx.full((3, 7, 5, 2), 1.0)
+        a_mx = mx.einsum("abcd,fgda->bfca", a, b)
+        a_np = np.einsum("abcd,fgda->bfca", a, b)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+    def test_sum_first(self):
+        a = mx.full((5, 8), 1.0)
+        b = mx.full((8, 2), 1.0)
+        a_mx = mx.einsum("ab,bc->c", a, b)
+        a_np = np.einsum("ab,bc->c", a, b)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+    def test_broadcasting(self):
+        a = mx.full((5, 1), 1.0)
+        b = mx.full((8, 2), 1.0)
+        a_mx = mx.einsum("ab,bc->c", a, b)
+        return
+        a_np = np.einsum("ab,bc->c", a, b)
+        self.assertTrue(np.array_equal(a_mx, a_np))
+
+        a = mx.random.uniform(shape=(5, 1, 3, 1))
+        b = mx.random.uniform(shape=(1, 7, 1, 2))
+        a_mx = mx.einsum("abcd,cdab->abcd", a, b)
+        a_np = np.einsum("abcd,cdab->abcd", a, b)
+        self.assertTrue(np.allclose(a_mx, a_np))
+
+    def test_attention(self):
+        q = mx.random.uniform(shape=(2, 3, 4, 5))
+        k = mx.random.uniform(shape=(2, 3, 4, 5))
+        v = mx.random.uniform(shape=(2, 3, 4, 5))
+
+        s = mx.einsum("itjk,iujk->ijtu", q, k)
+        out_mx = mx.einsum("ijtu,iujk->itjk", s, v)
+
+        s = np.einsum("itjk,iujk->ijtu", q, k)
+        out_np = np.einsum("ijtu,iujk->itjk", s, v)
+
+        self.assertTrue(np.allclose(out_mx, out_np))
+
+    def test_multi_input_einsum(self):
+        a = mx.ones((3, 4, 5))
+        out_mx = mx.einsum("ijk,lmk,ijf->lf", a, a, a)
+        out_np = np.einsum("ijk,lmk,ijf->lf", a, a, a)
+        self.assertTrue(np.allclose(out_mx, out_np))
+
+    def test_opt_einsum_test_cases(self):
+        # Test cases from
+        # https://github.com/dgasmith/opt_einsum/blob/c826bb7df16f470a69f7bf90598fc27586209d11/opt_einsum/tests/test_contract.py#L11
+        tests = [
+            # Test hadamard-like products
+            "a,ab,abc->abc",
+            "a,b,ab->ab",
+            # Test index-transformations
+            "ea,fb,gc,hd,abcd->efgh",
+            "ea,fb,abcd,gc,hd->efgh",
+            "abcd,ea,fb,gc,hd->efgh",
+            # Test complex contractions
+            "acdf,jbje,gihb,hfac,gfac,gifabc,hfac",
+            "cd,bdhe,aidb,hgca,gc,hgibcd,hgac",
+            "abhe,hidj,jgba,hiab,gab",
+            "bde,cdh,agdb,hica,ibd,hgicd,hiac",
+            "chd,bde,agbc,hiad,hgc,hgi,hiad",
+            "chd,bde,agbc,hiad,bdi,cgh,agdb",
+            "bdhe,acad,hiab,agac,hibd",
+            # Test collapse
+            "ab,ab,c->",
+            "ab,ab,c->c",
+            "ab,ab,cd,cd->",
+            "ab,ab,cd,cd->ac",
+            "ab,ab,cd,cd->cd",
+            "ab,ab,cd,cd,ef,ef->",
+            # Test outer prodcuts
+            "ab,cd,ef->abcdef",
+            "ab,cd,ef->acdf",
+            "ab,cd,de->abcde",
+            "ab,cd,de->be",
+            "ab,bcd,cd->abcd",
+            "ab,bcd,cd->abd",
+            # Random test cases that have previously failed
+            "eb,cb,fb->cef",
+            "dd,fb,be,cdb->cef",
+            "bca,cdb,dbf,afc->",
+            "dcc,fce,ea,dbf->ab",
+            "fdf,cdd,ccd,afe->ae",
+            "abcd,ad",
+            "ed,fcd,ff,bcf->be",
+            "baa,dcf,af,cde->be",
+            "bd,db,eac->ace",
+            "fff,fae,bef,def->abd",
+            "efc,dbc,acf,fd->abe",
+            # Inner products
+            "ab,ab",
+            "ab,ba",
+            "abc,abc",
+            "abc,bac",
+            "abc,cba",
+            # GEMM test cases
+            "ab,bc",
+            "ab,cb",
+            "ba,bc",
+            "ba,cb",
+            "abcd,cd",
+            "abcd,ab",
+            "abcd,cdef",
+            "abcd,cdef->feba",
+            "abcd,efdc",
+            # Inner then dot
+            "aab,bc->ac",
+            "ab,bcc->ac",
+            "aab,bcc->ac",
+            "baa,bcc->ac",
+            "aab,ccb->ac",
+            # Randomly build test caes
+            "aab,fa,df,ecc->bde",
+            "ecb,fef,bad,ed->ac",
+            "bcf,bbb,fbf,fc->",
+            "bb,ff,be->e",
+            "bcb,bb,fc,fff->",
+            "fbb,dfd,fc,fc->",
+            "afd,ba,cc,dc->bf",
+            "adb,bc,fa,cfc->d",
+            "bbd,bda,fc,db->acf",
+            "dba,ead,cad->bce",
+            "aef,fbc,dca->bde",
+        ]
+
+        size_dict = dict(zip("abcdefghij", [2, 3, 4, 5, 2, 3, 4, 5, 2, 3]))
+
+        def inputs_for_case(test_case):
+            inputs = test_case.split("->")[0].split(",")
+            return [
+                mx.random.uniform(shape=tuple(size_dict[c] for c in inp))
+                for inp in inputs
+            ]
+
+        for test_case in tests:
+            inputs = inputs_for_case(test_case)
+            np_out = np.einsum(test_case, *inputs)
+            mx_out = mx.einsum(test_case, *inputs)
+            self.assertTrue(np.allclose(mx_out, np_out, rtol=1e-4, atol=1e-4))
+
+    def test_ellipses(self):
+        size_dict = dict(zip("abcdefghij", [2, 3, 4, 5, 2, 3, 4, 5, 2, 3]))
+
+        def inputs_for_case(test_case):
+            inputs = test_case.split("->")[0].split(",")
+            return [
+                mx.random.uniform(shape=tuple(size_dict[c] for c in inp))
+                for inp in inputs
+            ]
+
+        tests = [
+            ("abc->ab", "...c->..."),
+            ("abcd->ad", "a...d->..."),
+            ("abij,abgj->abig", "...ij,...gj->...ig"),
+            ("abij,abgj->abig", "...ij,...gj->..."),
+            ("abhh->abh", "...hh->...h"),
+            ("abhh->abh", "...hh->...h"),
+            ("bch,abcj->abchj", "...h,...j->...hj"),
+            ("bc,cd->bd", "...c,cd"),
+            ("abc,acd->bd", "...bc,...cd"),
+            ("abcd,c->abd", "...cd,c"),
+            ("abcd,c->abd", "...cd,c..."),
+            ("abcd,c->abd", "...cd,c...->d..."),
+            ("abc,b->abc", "ab...,b...->ab..."),
+            ("abc,b->abc", "ab...,...b->ab..."),
+            ("abc,b->abc", "ab...,b->ab..."),
+            ("ab,bc->ac", "ab...,b...->a..."),
+            ("ab,bc->ac", "ab...,...bc->a...c"),
+            ("ab,bc->ac", "ab,b...->a..."),
+            ("abcdef,defg->abcg", "...def,defg->...g"),
+        ]
+        for test_case in tests:
+            inputs = inputs_for_case(test_case[0])
+            np_out = np.einsum(test_case[1], *inputs)
+            mx_out = mx.einsum(test_case[1], *inputs)
+            self.assertTrue(np.allclose(mx_out, np_out, rtol=1e-4, atol=1e-4))
+
+        error_tests = [
+            ("abc,abc->ab", "a...b...c,a...b...c->abc"),
+        ]
+        for test_case in error_tests:
+            inputs = inputs_for_case(test_case[0])
+            with self.assertRaises(ValueError):
+                mx.einsum(test_case[1], *inputs)
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_eval.py b/ml-stable-diffusion/mlx/python/tests/test_eval.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d6daaec21c8e2f40af2408e21a64c7f3773af2d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_eval.py
@@ -0,0 +1,200 @@
+# Copyright © 2023 Apple Inc.
+
+import unittest
+from functools import partial
+
+import mlx.core as mx
+import mlx_tests
+
+
+class TestEval(mlx_tests.MLXTestCase):
+    def test_eval(self):
+        arrs = [mx.ones((2, 2)) for _ in range(4)]
+        mx.eval(*arrs)
+        for x in arrs:
+            self.assertEqual(x.tolist(), [[1, 1], [1, 1]])
+
+    def test_retain_graph(self):
+        def fun(x):
+            y = 3 * x
+            mx.eval(y)
+            return 2 * y
+
+        dfun_dx = mx.grad(fun)
+        y = dfun_dx(mx.array(1.0))
+        self.assertEqual(y.item(), 6.0)
+
+    def test_eval_mixed(self):
+        x = mx.array(1) + 1 + 1
+        y = 0
+        z = "hello"
+        state = [x, y, z]
+        mx.eval(state)
+        self.assertEqual(x.item(), 3)
+
+    def test_async_eval(self):
+        x = mx.array(1) + mx.array(1) + mx.array(1)
+        mx.async_eval(x)
+        self.assertEqual(x.item(), 3)
+
+        # It should be safe to call eval on the array which has been async
+        # eval'ed
+        x = mx.array(1) + mx.array(1) + mx.array(1)
+        self.assertEqual(x.item(), 3)
+
+        x = mx.array([1, 2, 3])
+        y = 2 * x
+        mx.async_eval(y)
+        z = 2 * y
+        mx.async_eval(z)
+        self.assertTrue(mx.array_equal(y, mx.array([2, 4, 6])))
+        self.assertTrue(mx.array_equal(z, mx.array([4, 8, 12])))
+
+    def test_async_eval_twice(self):
+        for _ in range(1000):
+            x = mx.array(1) + mx.array(1) + mx.array(1)
+            mx.async_eval(x)
+            y = x + 1
+            mx.async_eval(y)
+            self.assertEqual(x.item(), 3)
+            self.assertEqual(y.item(), 4)
+
+    def test_async_eval_in_trace(self):
+        def fun(x):
+            y = x + 1.0
+            mx.async_eval(y)
+            return mx.exp(y)
+
+        # Raises
+        with self.assertRaises(ValueError):
+            mx.grad(fun)(mx.array(1.0))
+
+        # Also raises
+        with self.assertRaises(ValueError):
+            mx.vmap(fun)(mx.ones((2, 2)))
+
+    def test_async_eval_into_eval(self):
+        x = mx.array(1)
+        y = x + 1
+        mx.async_eval(y)
+        a = y - 10
+        b = mx.abs(a)
+        self.assertEqual(b.item(), 8)
+
+    def test_async_eval_into_eval_diff_stream(self):
+        s = mx.new_stream(mx.cpu)
+        x = mx.array(0)
+        y = x - 5
+        mx.async_eval(y)
+        z = mx.abs(y, stream=s)
+        self.assertEqual(z.item(), 5)
+
+    def test_eval_slow_fast_multi_stream(self):
+        x = mx.ones((8000,))
+        y = mx.abs(mx.array(-1.0))
+        for _ in range(20):
+            x = x + mx.array(1.0)
+        z = mx.add(x, y, stream=mx.cpu)
+        self.assertTrue(mx.allclose(z, mx.full((8000,), 22.0)))
+
+        # Switch eval order
+        x = mx.ones((8000,))
+        y = mx.abs(mx.array(-1.0))
+        for _ in range(20):
+            x = x + mx.array(1.0)
+        z = mx.add(y, x, stream=mx.cpu)
+        self.assertTrue(mx.allclose(z, mx.full((8000,), 22.0)))
+
+    def test_multi_output_eval_during_transform(self):
+        x = mx.random.uniform(shape=(1024,))
+        y = mx.ones((1024,))
+        mx.eval(x, y)
+
+        def fn(x):
+            a, b = mx.divmod(x, x)
+            mx.eval(a)
+            return a
+
+        out = mx.vjp(fn, (x,), (y,))
+        out = mx.vjp(fn, (x,), (y,))
+        peak_mem = mx.get_peak_memory()
+        out = mx.vjp(fn, (x,), (y,))
+        self.assertEqual(peak_mem, mx.get_peak_memory())
+
+    def test_async_eval_with_multiple_streams(self):
+        x = mx.array([1.0])
+        y = mx.array([1.0])
+        a = mx.array([1.0])
+        b = mx.array([1.0])
+
+        d = mx.default_device()
+        s2 = mx.new_stream(d)
+
+        for _ in range(50):
+            for _ in range(20):
+                x = x + y
+            mx.async_eval(x)
+            mx.eval(a + b)
+
+    def test_donation_for_noops(self):
+        def fun(x):
+            s = x.shape
+            for _ in range(10):
+                x = mx.abs(x)
+                x = mx.reshape(x, (-1,))
+                x = x.T.T
+                x = mx.stop_gradient(x)
+                x = mx.abs(x)
+            return x
+
+        x = mx.zeros((4096, 4096))
+        mx.eval(x)
+        pre = mx.get_peak_memory()
+        out = fun(x)
+        del x
+        mx.eval(out)
+        post = mx.get_peak_memory()
+        self.assertEqual(pre, post)
+
+        def fun(x):
+            for _ in range(10):
+                x = mx.abs(x)
+                x = x[:-1]
+                x = mx.abs(x)
+            return x
+
+        x = mx.zeros((4096 * 4096,))
+        mx.eval(x)
+        pre = mx.get_peak_memory()
+        out = fun(x)
+        del x
+        mx.eval(out)
+        post = mx.get_peak_memory()
+        self.assertEqual(pre, post)
+
+    @unittest.skipIf(not mx.is_available(mx.gpu), "GPU is not available")
+    def test_multistream_deadlock(self):
+        s1 = mx.default_stream(mx.gpu)
+        s2 = mx.new_stream(mx.gpu)
+
+        x = mx.array(1.0)
+        x = mx.abs(x, stream=s1)
+        for _ in range(1000):
+            x = mx.abs(x, stream=s2)
+        mx.eval(x)
+
+        s1 = mx.default_stream(mx.gpu)
+        s2 = mx.new_stream(mx.gpu)
+        old_limit = mx.set_memory_limit(1000)
+
+        x = mx.ones((512, 512), stream=s2)
+        for _ in range(80):
+            x = mx.abs(x, stream=s1)
+        y = mx.abs(x, stream=s2)
+        z = mx.abs(y, stream=s2)
+        mx.eval(z)
+        mx.set_memory_limit(old_limit)
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_export_import.py b/ml-stable-diffusion/mlx/python/tests/test_export_import.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d8af85093039155da43048cd45497e236f366b8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_export_import.py
@@ -0,0 +1,490 @@
+# Copyright © 2024 Apple Inc.
+
+import gc
+import os
+import tempfile
+import unittest
+
+import mlx.core as mx
+import mlx.nn as nn
+import mlx_tests
+
+
+class TestExportImport(mlx_tests.MLXTestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.test_dir_fid = tempfile.TemporaryDirectory()
+        cls.test_dir = cls.test_dir_fid.name
+        if not os.path.isdir(cls.test_dir):
+            os.mkdir(cls.test_dir)
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.test_dir_fid.cleanup()
+
+    def test_basic_export_import(self):
+        path = os.path.join(self.test_dir, "fn.mlxfn")
+
+        # Function with no inputs
+        def fun():
+            return mx.zeros((3, 3))
+
+        mx.export_function(path, fun)
+        imported = mx.import_function(path)
+
+        expected = fun()
+        (out,) = imported()
+        self.assertTrue(mx.array_equal(out, expected))
+
+        # Simple function with inputs
+        def fun(x):
+            return mx.abs(mx.sin(x))
+
+        inputs = mx.array([1.0, 2.0, 3.0, 4.0, 5.0])
+
+        mx.export_function(path, fun, inputs)
+        imported = mx.import_function(path)
+
+        expected = fun(inputs)
+        (out,) = imported(inputs)
+        self.assertTrue(mx.allclose(out, expected))
+
+        # Inputs in a list or tuple
+        def fun(x):
+            x = mx.abs(mx.sin(x))
+            return x
+
+        mx.export_function(path, fun, [inputs])
+        imported = mx.import_function(path)
+
+        expected = fun(inputs)
+        (out,) = imported([inputs])
+        self.assertTrue(mx.allclose(out, expected))
+
+        (out,) = imported(inputs)
+        self.assertTrue(mx.allclose(out, expected))
+
+        mx.export_function(path, fun, (inputs,))
+        imported = mx.import_function(path)
+        (out,) = imported((inputs,))
+        self.assertTrue(mx.allclose(out, expected))
+
+        # Outputs in a list
+        def fun(x):
+            return [mx.abs(mx.sin(x))]
+
+        mx.export_function(path, fun, inputs)
+        imported = mx.import_function(path)
+        (out,) = imported(inputs)
+        self.assertTrue(mx.allclose(out, expected))
+
+        # Outputs in a tuple
+        def fun(x):
+            return (mx.abs(mx.sin(x)),)
+
+        mx.export_function(path, fun, inputs)
+        imported = mx.import_function(path)
+        (out,) = imported(inputs)
+        self.assertTrue(mx.allclose(out, expected))
+
+        # Check throws on invalid inputs / outputs
+        def fun(x):
+            return mx.abs(x)
+
+        with self.assertRaises(ValueError):
+            mx.export_function(path, fun, "hi")
+
+        with self.assertRaises(ValueError):
+            mx.export_function(path, fun, mx.array(1.0), "hi")
+
+        def fun(x):
+            return mx.abs(x[0][0])
+
+        with self.assertRaises(ValueError):
+            mx.export_function(path, fun, [[mx.array(1.0)]])
+
+        def fun():
+            return (mx.zeros((3, 3)), 1)
+
+        with self.assertRaises(ValueError):
+            mx.export_function(path, fun)
+
+        def fun():
+            return (mx.zeros((3, 3)), [mx.zeros((3, 3))])
+
+        with self.assertRaises(ValueError):
+            mx.export_function(path, fun)
+
+        def fun(x, y):
+            return x + y
+
+        mx.export_function(path, fun, mx.array(1.0), mx.array(1.0))
+        imported = mx.import_function(path)
+
+        with self.assertRaises(ValueError):
+            imported(mx.array(1.0), 1.0)
+
+        with self.assertRaises(ValueError):
+            imported(mx.array(1.0), mx.array(1.0), mx.array(1.0))
+
+        with self.assertRaises(ValueError):
+            imported(mx.array(1.0), [mx.array(1.0)])
+
+    def test_export_random_sample(self):
+        path = os.path.join(self.test_dir, "fn.mlxfn")
+
+        mx.random.seed(5)
+
+        def fun():
+            return mx.random.uniform(shape=(3,))
+
+        mx.export_function(path, fun)
+        imported = mx.import_function(path)
+
+        (out,) = imported()
+
+        mx.random.seed(5)
+        expected = fun()
+
+        self.assertTrue(mx.array_equal(out, expected))
+
+    def test_export_with_kwargs(self):
+        path = os.path.join(self.test_dir, "fn.mlxfn")
+
+        def fun(x, z=None):
+            out = x
+            if z is not None:
+                out += z
+            return out
+
+        x = mx.array([1, 2, 3])
+        y = mx.array([1, 1, 0])
+        z = mx.array([2, 2, 2])
+
+        mx.export_function(path, fun, (x,), {"z": z})
+        imported_fun = mx.import_function(path)
+
+        with self.assertRaises(ValueError):
+            imported_fun(x, z)
+
+        with self.assertRaises(ValueError):
+            imported_fun(x, y=z)
+
+        with self.assertRaises(ValueError):
+            imported_fun((x,), {"y": z})
+
+        out = imported_fun(x, z=z)[0]
+        self.assertTrue(mx.array_equal(out, mx.array([3, 4, 5])))
+
+        out = imported_fun((x,), {"z": z})[0]
+        self.assertTrue(mx.array_equal(out, mx.array([3, 4, 5])))
+
+        mx.export_function(path, fun, x, z=z)
+        imported_fun = mx.import_function(path)
+        out = imported_fun(x, z=z)[0]
+        self.assertTrue(mx.array_equal(out, mx.array([3, 4, 5])))
+
+        out = imported_fun((x,), {"z": z})[0]
+        self.assertTrue(mx.array_equal(out, mx.array([3, 4, 5])))
+
+        # Only specify kwargs
+        mx.export_function(path, fun, x=x, z=z)
+        imported_fun = mx.import_function(path)
+        with self.assertRaises(ValueError):
+            out = imported_fun(x, z=z)[0]
+
+        out = imported_fun(x=x, z=z)[0]
+        self.assertTrue(mx.array_equal(out, mx.array([3, 4, 5])))
+
+        out = imported_fun({"x": x, "z": z})[0]
+        self.assertTrue(mx.array_equal(out, mx.array([3, 4, 5])))
+
+    def test_export_variable_inputs(self):
+        path = os.path.join(self.test_dir, "fn.mlxfn")
+
+        def fun(x, y, z=None):
+            out = x + y
+            if z is not None:
+                out += z
+            return out
+
+        with mx.exporter(path, fun) as exporter:
+            exporter(mx.array([1, 2, 3]), mx.array([1, 1, 1]))
+            exporter(mx.array([1, 2, 3]), mx.array([1, 1, 1]), z=mx.array([2]))
+
+        with self.assertRaises(RuntimeError):
+            exporter(mx.array([1, 2, 3, 4]), mx.array([1, 1, 1, 1]))
+
+        imported_fun = mx.import_function(path)
+        out = imported_fun(mx.array([1, 2, 3]), mx.array([1, 1, 1]))[0]
+        self.assertTrue(mx.array_equal(out, mx.array([2, 3, 4])))
+
+        out = imported_fun(mx.array([1, 2, 3]), mx.array([1, 1, 1]), z=mx.array([2]))[0]
+        self.assertTrue(mx.array_equal(out, mx.array([4, 5, 6])))
+
+        with self.assertRaises(ValueError):
+            imported_fun(mx.array([1, 2, 3, 4]), mx.array([1, 1, 1, 1]))
+
+        # A function with a large constant
+        constant = mx.zeros((16, 2048))
+        mx.eval(constant)
+
+        def fun(*args):
+            return constant + sum(args)
+
+        with mx.exporter(path, fun) as exporter:
+            for i in range(5):
+                exporter(*[mx.array(1)] * i)
+
+        # Check the exported file size < constant size + small amount
+        constants_size = constant.nbytes + 8192
+        self.assertTrue(os.path.getsize(path) < constants_size)
+
+    def test_leaks(self):
+        path = os.path.join(self.test_dir, "fn.mlxfn")
+        mx.synchronize()
+        if mx.metal.is_available():
+            mem_pre = mx.get_active_memory()
+        else:
+            mem_pre = 0
+
+        def outer():
+            d = {}
+
+            def f(x):
+                return d["x"]
+
+            d["f"] = mx.exporter(path, f)
+            d["x"] = mx.array([0] * 1000)
+
+        for _ in range(5):
+            outer()
+            gc.collect()
+
+        if mx.metal.is_available():
+            mem_post = mx.get_active_memory()
+        else:
+            mem_post = 0
+
+        self.assertEqual(mem_pre, mem_post)
+
+    def test_export_import_shapeless(self):
+        path = os.path.join(self.test_dir, "fn.mlxfn")
+
+        def fun(*args):
+            return sum(args)
+
+        with mx.exporter(path, fun, shapeless=True) as exporter:
+            exporter(mx.array(1))
+            exporter(mx.array(1), mx.array(2))
+            exporter(mx.array(1), mx.array(2), mx.array(3))
+
+        f2 = mx.import_function(path)
+        self.assertEqual(f2(mx.array(1))[0].item(), 1)
+        self.assertEqual(f2(mx.array(1), mx.array(1))[0].item(), 2)
+        self.assertEqual(f2(mx.array(1), mx.array(1), mx.array(1))[0].item(), 3)
+        with self.assertRaises(ValueError):
+            f2(mx.array(10), mx.array([5, 10, 20]))
+
+    def test_export_scatter_gather(self):
+        path = os.path.join(self.test_dir, "fn.mlxfn")
+
+        def fun(a, b):
+            return mx.take_along_axis(a, b, axis=0)
+
+        x = mx.random.uniform(shape=(4, 4))
+        y = mx.array([[0, 1, 2, 3], [1, 2, 0, 3]])
+        mx.export_function(path, fun, (x, y))
+        imported_fun = mx.import_function(path)
+        expected = fun(x, y)
+        out = imported_fun(x, y)[0]
+        self.assertTrue(mx.array_equal(expected, out))
+
+        def fun(a, b, c):
+            return mx.put_along_axis(a, b, c, axis=0)
+
+        x = mx.random.uniform(shape=(4, 4))
+        y = mx.array([[0, 1, 2, 3], [1, 2, 0, 3]])
+        z = mx.random.uniform(shape=(2, 4))
+        mx.export_function(path, fun, (x, y, z))
+        imported_fun = mx.import_function(path)
+        expected = fun(x, y, z)
+        out = imported_fun(x, y, z)[0]
+        self.assertTrue(mx.array_equal(expected, out))
+
+    def test_export_conv(self):
+        path = os.path.join(self.test_dir, "fn.mlxfn")
+
+        class Model(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.c1 = nn.Conv2d(
+                    3, 16, kernel_size=3, stride=1, padding=1, bias=False
+                )
+                self.c2 = nn.Conv2d(
+                    16, 16, kernel_size=3, stride=2, padding=1, bias=False
+                )
+                self.c3 = nn.Conv2d(
+                    16, 16, kernel_size=3, stride=1, padding=2, bias=False
+                )
+
+            def __call__(self, x):
+                return self.c3(self.c2(self.c1(x)))
+
+        model = Model()
+        mx.eval(model.parameters())
+
+        def forward(x):
+            return model(x)
+
+        input_data = mx.random.normal(shape=(4, 32, 32, 3))
+        mx.export_function(path, forward, input_data)
+
+        imported_fn = mx.import_function(path)
+        out = imported_fn(input_data)[0]
+        expected = forward(input_data)
+        self.assertTrue(mx.allclose(expected, out))
+
+    def test_export_conv_shapeless(self):
+        # Conv1d (NLC)
+        path = os.path.join(self.test_dir, "conv1d.mlxfn")
+
+        class M1(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.c = nn.Conv1d(3, 8, kernel_size=3, stride=2, padding=1, bias=False)
+
+            def __call__(self, x):
+                return self.c(x)
+
+        m1 = M1()
+        mx.eval(m1.parameters())
+
+        def f1(x):
+            return m1(x)
+
+        x = mx.random.normal(shape=(4, 64, 3))
+        mx.export_function(path, f1, x, shapeless=True)
+        f1_imp = mx.import_function(path)
+        for shape in [(4, 64, 3), (1, 33, 3), (2, 128, 3)]:
+            xt = mx.random.normal(shape=shape)
+            self.assertTrue(mx.allclose(f1_imp(xt)[0], f1(xt)))
+
+        # Conv2d (NHWC)
+        path = os.path.join(self.test_dir, "conv2d.mlxfn")
+
+        class M2(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.c = nn.Conv2d(3, 6, kernel_size=3, stride=2, padding=1, bias=False)
+
+            def __call__(self, x):
+                return self.c(x)
+
+        m2 = M2()
+        mx.eval(m2.parameters())
+
+        def f2(x):
+            return m2(x)
+
+        x = mx.random.normal(shape=(2, 32, 32, 3))
+        mx.export_function(path, f2, x, shapeless=True)
+        f2_imp = mx.import_function(path)
+        for shape in [(2, 32, 32, 3), (1, 31, 31, 3), (4, 64, 48, 3)]:
+            xt = mx.random.normal(shape=shape)
+            self.assertTrue(mx.allclose(f2_imp(xt)[0], f2(xt)))
+
+        # Conv3d (NDHWC)
+        path = os.path.join(self.test_dir, "conv3d.mlxfn")
+
+        class M3(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.c = nn.Conv3d(2, 4, kernel_size=3, stride=2, padding=1, bias=False)
+
+            def __call__(self, x):
+                return self.c(x)
+
+        m3 = M3()
+        mx.eval(m3.parameters())
+
+        def f3(x):
+            return m3(x)
+
+        x = mx.random.normal(shape=(1, 8, 8, 8, 2))
+        mx.export_function(path, f3, x, shapeless=True)
+        f3_imp = mx.import_function(path)
+        for shape in [(1, 8, 8, 8, 2), (2, 7, 8, 9, 2), (1, 16, 16, 4, 2)]:
+            xt = mx.random.normal(shape=shape)
+            self.assertTrue(mx.allclose(f3_imp(xt)[0], f3(xt)))
+
+        # Grouped Conv2d (NHWC)
+        path = os.path.join(self.test_dir, "conv2d_grouped.mlxfn")
+
+        class MG(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.c = nn.Conv2d(
+                    4, 6, kernel_size=3, stride=2, padding=1, groups=2, bias=False
+                )
+
+            def __call__(self, x):
+                return self.c(x)
+
+        mg = MG()
+        mx.eval(mg.parameters())
+
+        def fg(x):
+            return mg(x)
+
+        x = mx.random.normal(shape=(2, 32, 32, 4))
+        mx.export_function(path, fg, x, shapeless=True)
+        fg_imp = mx.import_function(path)
+        for shape in [(2, 32, 32, 4), (1, 32, 32, 4), (3, 15, 20, 4)]:
+            xt = mx.random.normal(shape=shape)
+            self.assertTrue(mx.allclose(fg_imp(xt)[0], fg(xt)))
+
+    def test_export_control_flow(self):
+
+        def fun(x, y):
+            if y.shape[0] <= 2:
+                return x + y
+            else:
+                return x + 2 * y
+
+        for y in (mx.array([1, 2, 3]), mx.array([1, 2])):
+            for shapeless in (True, False):
+                with self.subTest(y=y, shapeless=shapeless):
+                    x = mx.array(1)
+                    export_path = os.path.join(self.test_dir, "control_flow.mlxfn")
+                    mx.export_function(export_path, fun, x, y, shapeless=shapeless)
+
+                    imported_fn = mx.import_function(export_path)
+                    self.assertTrue(mx.array_equal(imported_fn(x, y)[0], fun(x, y)))
+
+    def test_export_quantized_model(self):
+        for shapeless in (True, False):
+            with self.subTest(shapeless=shapeless):
+                model = nn.Sequential(
+                    nn.Linear(1024, 512), nn.ReLU(), nn.Linear(512, 1024)
+                )
+                model.eval()
+                mx.eval(model.parameters())
+                input_data = mx.ones(shape=(512, 1024))
+                nn.quantize(model)
+                self.assertTrue(isinstance(model.layers[0], nn.QuantizedLinear))
+                self.assertTrue(isinstance(model.layers[2], nn.QuantizedLinear))
+                mx.eval(model.parameters())
+
+                export_path = os.path.join(self.test_dir, "quantized_linear.mlxfn")
+                mx.export_function(export_path, model, input_data, shapeless=shapeless)
+
+                imported_fn = mx.import_function(export_path)
+                self.assertTrue(
+                    mx.array_equal(imported_fn(input_data)[0], model(input_data))
+                )
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_fast.py b/ml-stable-diffusion/mlx/python/tests/test_fast.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cfef7b11709fb72fc724620ed187375301cbf69
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_fast.py
@@ -0,0 +1,894 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+import unittest
+
+import mlx.core as mx
+import mlx_tests
+
+
+def rope_orig(x, dims, traditional, base, scale, offset, freqs=None):
+    N = x.shape[-2]
+    dtype = x.dtype
+    half_D = dims // 2
+    positions = mx.arange(N, dtype=dtype)
+    if isinstance(offset, mx.array) and offset.size > 1:
+        expand = tuple(range(1, x.ndim - 1))
+        positions = mx.expand_dims(offset, expand) + positions
+    else:
+        positions = offset + positions
+    positions = positions * scale
+    if freqs is None:
+        inv_freqs = mx.exp(
+            -mx.arange(0.0, half_D, dtype=dtype) * (math.log(base) / half_D)
+        )
+    else:
+        inv_freqs = (1 / freqs).astype(x.dtype)
+    theta = mx.expand_dims(positions, -1) * inv_freqs
+    costheta, sintheta = mx.cos(theta), mx.sin(theta)
+    if traditional:
+        x1 = x[..., :dims:2]
+        x2 = x[..., 1:dims:2]
+        rx1 = x1 * costheta - x2 * sintheta
+        rx2 = x1 * sintheta + x2 * costheta
+        rx = mx.concatenate([rx1[..., None], rx2[..., None]], axis=-1)
+        if dims < x.shape[-1]:
+            rx = mx.reshape(rx, (*x.shape[:-1], dims))
+            rx = mx.concatenate([rx, x[..., dims:]], axis=-1)
+        return mx.reshape(rx, x.shape)
+    else:
+        x1 = x[..., : dims // 2]
+        x2 = x[..., dims // 2 : dims]
+        rx1 = x1 * costheta - x2 * sintheta
+        rx2 = x1 * sintheta + x2 * costheta
+        if dims < x.shape[-1]:
+            rx = mx.concatenate([rx1, rx2, x[..., dims:]], axis=-1)
+        else:
+            rx = mx.concatenate([rx1, rx2], axis=-1)
+        return rx
+
+
+def rms_norm(x, weight, eps):
+    x = x.astype(mx.float32)
+    x = x * mx.rsqrt(x.square().mean(-1, keepdims=True) + eps)
+    return weight * x.astype(weight.dtype)
+
+
+def layer_norm(x, weight, bias, eps):
+    ot = x.dtype
+    x = x.astype(mx.float32)
+    mean = x.mean(axis=-1, keepdims=True)
+    var = x.var(axis=-1, keepdims=True)
+    x = (x - mean) * mx.rsqrt(var + eps)
+    x = x.astype(ot)
+    if weight is not None:
+        x = x * weight
+    if bias is not None:
+        x = x + bias
+    return x
+
+
+class TestFast(mlx_tests.MLXTestCase):
+    def test_rope(self):
+        T = 4
+
+        # Defaults: dims, dtype, base, scale, offset, traditional
+        defaults = (8, mx.float32, 10000.0, 1.0, 0, False)
+
+        # Per dtype absolute tolerance
+        tolerances = {mx.float32: 1e-6, mx.float16: 1e-3, mx.bfloat16: 1e-2}
+
+        # Test cases:
+        dtypes = [mx.float32, mx.float16, mx.bfloat16]
+        bases = [10000.0, 1000000.0]
+        scales = [1.0, 2.0]
+        offsets = [0, 3, mx.array(3)]
+        traditional = [True, False]
+
+        for traditional in [True, False]:
+            dims, dtype, _, scale, offset, _ = defaults
+            for base in bases:
+                x = mx.random.uniform(shape=(2, T, dims)).astype(dtype)
+                rx = rope_orig(x, dims, traditional, base, scale, offset)
+                rx_fast = mx.fast.rope(
+                    x,
+                    dims,
+                    traditional=traditional,
+                    base=base,
+                    scale=scale,
+                    offset=offset,
+                )
+                self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+
+            dims, _, base, scale, offset, _ = defaults
+            for dtype in dtypes:
+                x = mx.random.uniform(shape=(2, T, dims)).astype(dtype)
+                ry = rope_orig(
+                    x.astype(mx.float32), dims, traditional, base, scale, offset
+                )
+                rx = rope_orig(x, dims, traditional, base, scale, offset)
+                rx_fast = mx.fast.rope(
+                    x,
+                    dims,
+                    traditional=traditional,
+                    base=base,
+                    scale=scale,
+                    offset=offset,
+                )
+                if dtype != mx.float32:
+                    self.assertLessEqual(
+                        mx.abs(ry - rx_fast).max(), mx.abs(ry - rx).max()
+                    )
+                self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+
+            dims, dtype, base, scale, _, _ = defaults
+            for offset in offsets:
+                x = mx.random.uniform(shape=(2, T, dims)).astype(dtype)
+                rx = rope_orig(x, dims, traditional, base, scale, offset)
+                rx_fast = mx.fast.rope(
+                    x,
+                    dims,
+                    traditional=traditional,
+                    base=base,
+                    scale=scale,
+                    offset=offset,
+                )
+                self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+
+            dims, dtype, base, _, offset, _ = defaults
+            for scale in scales:
+                x = mx.random.uniform(shape=(2, T, dims)).astype(dtype)
+                rx = rope_orig(x, dims, traditional, base, scale, offset)
+                rx_fast = mx.fast.rope(
+                    x,
+                    dims,
+                    traditional=traditional,
+                    base=base,
+                    scale=scale,
+                    offset=offset,
+                )
+                self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+
+        # Test transpose into rope
+        dims, _, base, scale, offset, traditional = defaults
+        x = mx.random.uniform(shape=(1, 1, 4, dims)).swapaxes(1, 2)
+        rx = rope_orig(x, dims, traditional, base, scale, offset)
+        rx_fast = mx.fast.rope(
+            1.0 * x,  # multiply here to allow donation
+            dims,
+            traditional=traditional,
+            base=base,
+            scale=scale,
+            offset=offset,
+        )
+        self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[mx.float32])
+
+        # Test raises with integer inputs
+        dims, _, base, scale, offset, traditional = defaults
+        x = (mx.random.uniform(shape=(2, T, dims)) * 10).astype(mx.int32)
+        with self.assertRaises(ValueError):
+            y = mx.fast.rope(
+                x, dims, traditional=traditional, base=base, scale=scale, offset=offset
+            )
+
+    def test_rope_with_freqs(self):
+        mx.random.seed(0)
+
+        # Check throws
+        T = 4
+        dims = 8
+        x = mx.random.uniform(shape=(2, T, dims))
+
+        with self.assertRaises(ValueError):
+            freqs = mx.random.uniform(shape=(dims - 1,))
+            mx.fast.rope(
+                x,
+                dims,
+                traditional=False,
+                base=None,
+                scale=1.0,
+                offset=0,
+                freqs=freqs,
+            )
+        with self.assertRaises(ValueError):
+            freqs = mx.random.uniform(shape=(1, dims))
+            mx.fast.rope(
+                x,
+                dims,
+                traditional=False,
+                base=None,
+                scale=1.0,
+                offset=0,
+                freqs=freqs,
+            )
+
+        freqs = mx.random.uniform(shape=(dims // 2,))
+
+        tolerances = {mx.float32: 1e-5, mx.float16: 1e-2}
+        for dtype in [mx.float32, mx.float16]:
+            x_ = x.astype(dtype)
+            rx = rope_orig(x_, dims, False, None, 1.0, 0, freqs)
+            rx_fast = mx.fast.rope(
+                x_,
+                dims,
+                traditional=False,
+                base=None,
+                scale=1.0,
+                offset=0,
+                freqs=freqs,
+            )
+            self.assertEqual(dtype, rx.dtype)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+            return
+
+        # Test single vector
+        x = mx.random.uniform(shape=(1, 1, dims))
+        rx = rope_orig(x, dims, False, None, 1.0, 0, freqs)
+        rx_fast = mx.fast.rope(
+            x,
+            dims,
+            traditional=False,
+            base=None,
+            scale=1.0,
+            offset=0,
+            freqs=freqs,
+        )
+        self.assertLess(mx.abs(rx - rx_fast).max(), 1e-5)
+
+        # Test grad with freqs
+        f1 = lambda x, y: (rope_orig(x, dims, False, None, 1.0, 0, freqs) * y).sum()
+        f2 = lambda x, y: (
+            mx.fast.rope(
+                x,
+                dims,
+                traditional=False,
+                base=None,
+                scale=1.0,
+                offset=0,
+                freqs=freqs,
+            )
+            * y
+        ).sum()
+
+        x = mx.random.uniform(shape=(2, 4, dims))
+        y = mx.random.uniform(shape=(2, 4, dims))
+        g1 = mx.grad(f1)(x, y)
+        g2 = mx.grad(f2)(x, y)
+        self.assertLess(mx.abs(g1 - g2).max(), 1e-5)
+
+    def test_rope_grad(self):
+        D = 32
+        defaults = (D, 10000.0, 1.0, 0, False)
+        for dims in (D, D // 2):
+            for traditional in (True, False):
+                _, base, scale, offset, _ = defaults
+                f1 = lambda x, y: (
+                    rope_orig(x, dims, traditional, base, scale, offset) * y
+                ).sum()
+                f2 = lambda x, y: (
+                    mx.fast.rope(
+                        x,
+                        dims,
+                        traditional=traditional,
+                        base=base,
+                        scale=scale,
+                        offset=offset,
+                    )
+                    * y
+                ).sum()
+
+                x = mx.random.uniform(shape=(2, 100, D))
+                y = mx.random.uniform(shape=(2, 100, D))
+                g1 = mx.grad(f1)(x, y)
+                g2 = mx.grad(f2)(x, y)
+                self.assertLess(mx.abs(g1 - g2).max(), 1e-5)
+
+    def test_rope_batch(self):
+        T = 4
+        base = 10000.0
+        scale = 1.0
+        traditional = True
+        batch_sizes = [3, 8, 11]
+        num_heads = [1, 3, 5]
+        dims = 32
+
+        x = mx.random.uniform(shape=(8, 4, T, dims))
+
+        offset = mx.array([1, 2, 3])
+        with self.assertRaises(ValueError):
+            mx.fast.rope(
+                x,
+                dims,
+                traditional=traditional,
+                base=base,
+                scale=scale,
+                offset=offset,
+            )
+
+        for batch_size in batch_sizes:
+            for n_head in num_heads:
+                x = mx.random.uniform(shape=(batch_size, n_head, T, dims))
+                offset = mx.arange(batch_size)
+                rx = rope_orig(x, dims, traditional, base, scale, offset)
+                rx_fast = mx.fast.rope(
+                    x,
+                    dims,
+                    traditional=traditional,
+                    base=base,
+                    scale=scale,
+                    offset=offset,
+                )
+                self.assertLess(mx.abs(rx - rx_fast).max(), 1e-5)
+        x = mx.random.normal(shape=(2, 6, 8, 64)).transpose(0, 2, 1, 3)
+        dims = 64
+        offset = 0
+        rx_fast = mx.fast.rope(
+            x, dims, traditional=traditional, scale=scale, base=base, offset=offset
+        )
+        rx_fast_single = mx.fast.rope(
+            x[0:1], dims, traditional=traditional, scale=scale, base=base, offset=offset
+        )
+
+        rx = rope_orig(x, dims, traditional, base, scale, offset)
+        self.assertLess(mx.abs(rx - rx_fast).max(), 1e-5)
+
+    def test_rms_norm(self):
+        # Per dtype absolute tolerance
+        tolerances = {mx.float32: 1e-6, mx.float16: 1e-3, mx.bfloat16: 1e-2}
+
+        dtypes = [mx.float32, mx.float16, mx.bfloat16]
+        epss = [1e-3, 1e-5]
+        dimss = [31, 32, 33]
+        defaults = (mx.float32, 1e-5, 32)
+
+        for dtype in dtypes:
+            _, eps, dims = defaults
+            x = mx.random.uniform(
+                shape=(
+                    2,
+                    dims,
+                )
+            ).astype(dtype)
+            weight = mx.random.uniform(shape=(dims,)).astype(dtype)
+            rx = rms_norm(x, weight, eps)
+            rx_fast = mx.fast.rms_norm(x, weight, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+            rx = rms_norm(x, mx.ones_like(weight), eps)
+            rx_fast = mx.fast.rms_norm(x, None, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+
+        for eps in epss:
+            dtype, _, dims = defaults
+            x = mx.random.uniform(shape=(2, dims)).astype(dtype)
+            weight = mx.random.uniform(shape=(dims,)).astype(dtype)
+            rx = rms_norm(x, weight, eps)
+            rx_fast = mx.fast.rms_norm(x, weight, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+            rx = rms_norm(x, mx.ones_like(weight), eps)
+            rx_fast = mx.fast.rms_norm(x, None, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+
+        for dims in dimss:
+            dtype, eps, _ = defaults
+            x = mx.random.uniform(shape=(2, dims)).astype(dtype)
+            weight = mx.random.uniform(shape=(dims,)).astype(dtype)
+            rx = rms_norm(x, weight, eps)
+            rx_fast = mx.fast.rms_norm(x, weight, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+            rx = rms_norm(x, mx.ones_like(weight), eps)
+            rx_fast = mx.fast.rms_norm(x, None, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+
+        # Test > 4096
+        dims, dtype, eps = 4099, mx.float32, 1e-5
+        x = mx.random.uniform(shape=(dims,)).astype(dtype)
+        weight = mx.random.uniform(shape=(dims,)).astype(dtype)
+        rx = rms_norm(x, weight, eps)
+        rx_fast = mx.fast.rms_norm(x, weight, eps)
+        self.assertLess(mx.abs(rx - rx_fast).max(), 1e-6)
+
+        # Wrong size w raises
+        with self.assertRaises(ValueError):
+            x = mx.random.uniform(shape=(1, 5))
+            mx.fast.rms_norm(x, mx.ones((4,)), 1e-5)
+
+    def test_rms_norm_grad(self):
+        D = 32
+        eps = 1e-5
+        f1 = lambda x, w, y: (rms_norm(x, w, eps) * y).sum()
+        f2 = lambda x, w, y: (mx.fast.rms_norm(x, w, eps) * y).sum()
+        f3 = lambda x, y: (rms_norm(x, mx.ones((x.shape[-1],)), eps) * y).sum()
+        f4 = lambda x, y: (mx.fast.rms_norm(x, None, eps) * y).sum()
+
+        x = mx.random.uniform(shape=(8, 100, D))
+        w = mx.random.uniform(shape=(D,))
+        y = mx.random.uniform(shape=(8, 100, D))
+        gx1, gw1 = mx.grad(f1, argnums=(0, 1))(x, w, y)
+        gx2, gw2 = mx.grad(f2, argnums=(0, 1))(x, w, y)
+        self.assertLess(mx.abs(gx1 - gx2).max(), 1e-5)
+        self.assertLess(mx.abs(gw1 - gw2).max() / mx.abs(gw1).mean(), 1e-5)
+        gx1 = mx.grad(f3, argnums=(0,))(x, y)
+        gx2 = mx.grad(f4, argnums=(0,))(x, y)
+        self.assertLess(mx.abs(gx1 - gx2).max(), 1e-5)
+
+        D = 8192
+        x = mx.random.uniform(shape=(2, 2, D))
+        w = mx.random.uniform(shape=(D,))
+        y = mx.random.uniform(shape=(2, 2, D))
+        gx1, gw1 = mx.grad(f1, argnums=(0, 1))(x, w, y)
+        gx2, gw2 = mx.grad(f2, argnums=(0, 1))(x, w, y)
+        self.assertLess(mx.abs(gx1 - gx2).max(), 1e-5)
+        self.assertLess(mx.abs(gw1 - gw2).max() / mx.abs(gw1).mean(), 1e-5)
+        gx1 = mx.grad(f3, argnums=(0,))(x, y)
+        gx2 = mx.grad(f4, argnums=(0,))(x, y)
+        self.assertLess(mx.abs(gx1 - gx2).max(), 1e-5)
+
+        def gf(f):
+            def inner(x, w, y):
+                gx, gw = mx.grad(f, argnums=(0, 1))(x, w, y)
+                return (gx + gw).sum()
+
+            return inner
+
+        gx1, gw1 = mx.grad(gf(f1), argnums=(0, 1))(x, w, y)
+        gx2, gw2 = mx.grad(gf(f2), argnums=(0, 1))(x, w, y)
+        self.assertLess(mx.abs(gx1 - gx2).max(), 1e-5)
+        self.assertLess(mx.abs(gw1 - gw2).max() / mx.abs(gw1).mean(), 1e-5)
+
+    def test_layer_norm(self):
+        # Per dtype absolute tolerance
+        tolerances = {mx.float32: 1e-5, mx.float16: 5e-3, mx.bfloat16: 5e-2}
+
+        dtypes = [mx.float32, mx.float16, mx.bfloat16]
+        epss = [1e-3, 1e-5]
+        dimss = [31, 32, 33]
+        defaults = (mx.float32, 1e-5, 32)
+
+        for dtype in dtypes:
+            _, eps, dims = defaults
+            x = mx.random.uniform(
+                shape=(
+                    2,
+                    dims,
+                )
+            ).astype(dtype)
+            weight = mx.random.uniform(shape=(dims,)).astype(dtype)
+            bias = mx.random.uniform(shape=(dims,)).astype(dtype)
+            rx = layer_norm(x, weight, bias, eps)
+            rx_fast = mx.fast.layer_norm(x, weight, bias, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+            rx = layer_norm(x, weight, None, eps)
+            rx_fast = mx.fast.layer_norm(x, weight, None, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+            rx = layer_norm(x, None, bias, eps)
+            rx_fast = mx.fast.layer_norm(x, None, bias, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+            rx = layer_norm(x, None, None, eps)
+            rx_fast = mx.fast.layer_norm(x, None, None, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+
+        for eps in epss:
+            dtype, _, dims = defaults
+            x = mx.random.uniform(shape=(2, dims)).astype(dtype)
+            weight = mx.random.uniform(shape=(dims,)).astype(dtype)
+            bias = mx.random.uniform(shape=(dims,)).astype(dtype)
+            rx = layer_norm(x, weight, bias, eps)
+            rx_fast = mx.fast.layer_norm(x, weight, bias, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+            rx = layer_norm(x, weight, None, eps)
+            rx_fast = mx.fast.layer_norm(x, weight, None, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+            rx = layer_norm(x, None, bias, eps)
+            rx_fast = mx.fast.layer_norm(x, None, bias, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+            rx = layer_norm(x, None, None, eps)
+            rx_fast = mx.fast.layer_norm(x, None, None, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+
+        for dims in dimss:
+            dtype, eps, _ = defaults
+            x = mx.random.uniform(shape=(2, dims)).astype(dtype)
+            weight = mx.random.uniform(shape=(dims,)).astype(dtype)
+            bias = mx.random.uniform(shape=(dims,)).astype(dtype)
+            rx = layer_norm(x, weight, bias, eps)
+            rx_fast = mx.fast.layer_norm(x, weight, bias, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+            rx = layer_norm(x, weight, None, eps)
+            rx_fast = mx.fast.layer_norm(x, weight, None, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+            rx = layer_norm(x, None, bias, eps)
+            rx_fast = mx.fast.layer_norm(x, None, bias, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+            rx = layer_norm(x, None, None, eps)
+            rx_fast = mx.fast.layer_norm(x, None, None, eps)
+            self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+
+        # Test > 4096
+        dims, dtype, eps = 4099, mx.float32, 1e-5
+        x = mx.random.uniform(shape=(dims,)).astype(dtype)
+        weight = mx.random.uniform(shape=(dims,)).astype(dtype)
+        bias = mx.random.uniform(shape=(dims,)).astype(dtype)
+        rx = layer_norm(x, weight, bias, eps)
+        rx_fast = mx.fast.layer_norm(x, weight, bias, eps)
+        self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+        rx = layer_norm(x, weight, None, eps)
+        rx_fast = mx.fast.layer_norm(x, weight, None, eps)
+        self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+        rx = layer_norm(x, None, bias, eps)
+        rx_fast = mx.fast.layer_norm(x, None, bias, eps)
+        self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+        rx = layer_norm(x, None, None, eps)
+        rx_fast = mx.fast.layer_norm(x, None, None, eps)
+        self.assertLess(mx.abs(rx - rx_fast).max(), tolerances[dtype])
+
+    def test_slice_into_layer_norm(self):
+        dim = 128
+        eps = 1e-5
+        x = mx.random.uniform(shape=(8, 100, 128))[:, 99:]
+        rx_fast = mx.fast.layer_norm(x, weight=None, bias=None, eps=eps)
+        rx = layer_norm(x, None, None, eps)
+        self.assertLess(mx.abs(rx - rx_fast).max(), 1e-4)
+
+    def test_layer_norm_grad(self):
+        D = 32
+        eps = 1e-5
+        f1 = lambda x, w, b, y: (layer_norm(x, w, b, eps) * y).sum()
+        f2 = lambda x, w, b, y: (mx.fast.layer_norm(x, w, b, eps) * y).sum()
+
+        x = mx.random.uniform(shape=(8, 100, D))
+        w = mx.random.uniform(shape=(D,))
+        b = mx.random.uniform(shape=(D,))
+        y = mx.random.uniform(shape=(8, 100, D))
+
+        gx1, gw1, gb1 = mx.grad(f1, argnums=(0, 1, 2))(x, w, b, y)
+        gx2, gw2, gb2 = mx.grad(f2, argnums=(0, 1, 2))(x, w, b, y)
+        self.assertLess(mx.abs(gx1 - gx2).max(), 1e-5)
+        self.assertLess(mx.abs(gw1 - gw2).max() / mx.abs(gw1).mean(), 1e-5)
+        self.assertLess(mx.abs(gb1 - gb2).max() / mx.abs(gb1).mean(), 1e-5)
+
+        D = 8192
+        x = mx.random.uniform(shape=(8, 100, D))
+        w = mx.random.uniform(shape=(D,))
+        b = mx.random.uniform(shape=(D,))
+        y = mx.random.uniform(shape=(8, 100, D))
+
+        gx1, gw1, gb1 = mx.grad(f1, argnums=(0, 1, 2))(x, w, b, y)
+        gx2, gw2, gb2 = mx.grad(f2, argnums=(0, 1, 2))(x, w, b, y)
+        self.assertLess(mx.abs(gx1 - gx2).max(), 5e-5)
+        self.assertLess(mx.abs(gw1 - gw2).max() / mx.abs(gw1).mean(), 5e-5)
+        self.assertLess(mx.abs(gb1 - gb2).max() / mx.abs(gb1).mean(), 5e-5)
+
+        def gf(f):
+            def inner(x, w, b, y):
+                gx, gw, gb = mx.grad(f, argnums=(0, 1, 2))(x, w, b, y)
+                return ((gx + gw + gb) * y).sum()
+
+            return inner
+
+        gx1, gw1, gb1 = mx.grad(gf(f1), argnums=(0, 1, 2))(x, w, b, y)
+        gx2, gw2, gb2 = mx.grad(gf(f2), argnums=(0, 1, 2))(x, w, b, y)
+        self.assertLess(mx.abs(gx1 - gx2).max() / mx.abs(gx1).mean(), 5e-5)
+        self.assertLess(mx.abs(gw1 - gw2).max() / mx.abs(gw1).mean(), 5e-5)
+        self.assertLess(mx.abs(gb1).max(), 1e-9)
+        self.assertLess(mx.abs(gb2).max(), 1e-9)
+
+    def test_layer_norm_grad_no_params(self):
+        eps = 1e-5
+        f1 = lambda x: layer_norm(x, None, None, eps).sum()
+        f2 = lambda x: mx.fast.layer_norm(x, None, None, eps).sum()
+        x = mx.random.normal(shape=(2, 2, 8))
+        mx.eval(x)
+
+        gx1 = mx.grad(f1)(x)
+        gx2 = mx.grad(f2)(x)
+        self.assertTrue(mx.allclose(gx1, gx2, atol=1e-6))
+
+    def test_layer_norm_grad_params(self):
+        eps = 1e-5
+        f1 = lambda params, x: (layer_norm(x, params[0], params[1], eps)).sum()
+        f2 = lambda params, x: (mx.fast.layer_norm(x, params[0], params[1], eps)).sum()
+
+        w = mx.ones((8,))
+        b = mx.zeros((8,))
+        x = mx.random.normal(shape=(2, 2, 8))
+        mx.eval(x, w, b)
+
+        gw1, gb1 = mx.grad(f1)((w, b), x)
+        gw2, gb2 = mx.grad(f2)((w, b), x)
+        self.assertLess(mx.abs(gw1 - gw2).max() / mx.abs(gw1).mean(), 1e-5)
+        self.assertLess(mx.abs(gb1 - gb2).max() / mx.abs(gb1).mean(), 1e-5)
+
+    def test_fast_transforms(self):
+        x = mx.random.uniform(shape=(2, 2, 8))
+
+        defaults = (8, False, 10000.0, 1.0, 0)
+        dims, traditional, base, scale, offset = defaults
+
+        # VJP
+        _, vjp_out = mx.vjp(lambda x: rope_orig(x, *defaults), (x,), (mx.ones_like(x),))
+        _, vjp_fast_out = mx.vjp(
+            lambda x: mx.fast.rope(
+                x, dims, traditional=traditional, base=base, scale=scale, offset=offset
+            ),
+            (x,),
+            (mx.ones_like(x),),
+        )
+        self.assertTrue(mx.allclose(vjp_out[0], vjp_fast_out[0]))
+
+        # JVP
+        _, jvp_out = mx.jvp(lambda x: rope_orig(x, *defaults), (x,), (mx.ones_like(x),))
+        _, jvp_fast_out = mx.jvp(
+            lambda x: mx.fast.rope(
+                x, dims, traditional=traditional, base=base, scale=scale, offset=offset
+            ),
+            (x,),
+            (mx.ones_like(x),),
+        )
+        self.assertTrue(mx.allclose(jvp_out[0], jvp_fast_out[0]))
+
+        # VMAP
+        x = mx.random.uniform(shape=(2, 2, 2, 8))
+        vmap_out = mx.vmap(lambda x: rope_orig(x, *defaults))(x)
+        vmap_fast_out = mx.vmap(
+            lambda x: mx.fast.rope(
+                x, dims, traditional=traditional, base=base, scale=scale, offset=offset
+            )
+        )(x)
+        self.assertTrue(mx.allclose(vmap_out, vmap_fast_out))
+
+    @unittest.skipIf(not mx.is_available(mx.gpu), "No GPU available")
+    def test_custom_kernel_basic(self):
+        if mx.metal.is_available():
+            source = """
+                uint elem = thread_position_in_grid.x;
+                out1[elem] = a[elem];
+            """
+            custom_kernel = mx.fast.metal_kernel
+        elif mx.cuda.is_available():
+            source = """
+                auto elem = cooperative_groups::this_grid().thread_rank();
+                out1[elem] = a[elem];
+            """
+            custom_kernel = mx.fast.cuda_kernel
+
+        mx.random.seed(7)
+        a = mx.random.normal(shape=(2, 2))
+        kernel = custom_kernel(
+            name="basic",
+            input_names=["a"],
+            output_names=["out1"],
+            source=source,
+        )
+        out = kernel(
+            inputs=[a],
+            grid=(4, 1, 1),
+            threadgroup=(2, 1, 1),
+            output_shapes=[(2, 2)],
+            output_dtypes=[mx.float32],
+            stream=mx.gpu,
+        )
+        self.assertTrue(mx.allclose(out[0], a))
+
+    @unittest.skipIf(not mx.is_available(mx.gpu), "No GPU available")
+    def test_custom_kernel_args(self):
+        if mx.metal.is_available():
+            source = """
+                uint elem = thread_position_in_grid.x;
+                T tmp = a[0];
+                if (e) {
+                    out1[elem] = a[1] + b[2] + c[3] + d + f;
+                } else {
+                    out1[elem] = 1;
+                }
+                out2[elem] = a[1] + b[2] + c[1] - d;
+            """
+            custom_kernel = mx.fast.metal_kernel
+        elif mx.cuda.is_available():
+            source = """
+                auto elem = cooperative_groups::this_grid().thread_rank();
+                T tmp = a[0];
+                if (e) {
+                    out1[elem] = a[1] + b[2] + static_cast<float>(c[3]) + d[0] + f;
+                } else {
+                    out1[elem] = 1;
+                }
+                out2[elem] = a[1] + b[2] + static_cast<float>(c[1]) - d[0];
+            """
+            custom_kernel = mx.fast.cuda_kernel
+
+        mx.random.seed(7)
+        a = mx.random.normal(shape=(3, 6))
+        c = mx.random.normal(shape=(2, 2)).astype(mx.bfloat16)
+
+        kernel = custom_kernel(
+            name="arg_test",
+            input_names=["a", "b", "c", "d"],
+            output_names=["out1", "out2"],
+            source=source,
+        )
+        out = kernel(
+            inputs=[
+                a,
+                mx.array([3, 4, 5]),
+                c,
+                7.3,
+            ],
+            template=[
+                ("e", True),
+                ("f", 3),
+                ("T", mx.float16),
+            ],
+            grid=(6, 1, 1),
+            threadgroup=(2, 1, 1),
+            output_shapes=[(3, 2), (3, 2)],
+            output_dtypes=[mx.float32, mx.int32],
+            stream=mx.gpu,
+        )
+
+        self.assertTrue(mx.allclose(out[0], mx.full((3, 2), 14.0484)))
+        self.assertTrue(mx.allclose(out[1], mx.full((3, 2), -2, dtype=mx.int32)))
+
+    @unittest.skipIf(not mx.is_available(mx.gpu), "No GPU available")
+    def test_custom_kernel_strides(self):
+        if mx.metal.is_available():
+            source = """
+                uint elem = thread_position_in_grid.x;
+                uint loc = elem_to_loc(elem, inp_shape, inp_strides, inp_ndim);
+                T tmp = inp[loc];
+                out[elem] = metal::precise::exp(tmp) * threads_per_simdgroup;
+            """
+            source_contig = """
+                uint elem = thread_position_in_grid.x;
+                T tmp = inp[elem];
+                out[elem] = metal::precise::exp(tmp) * threads_per_simdgroup;
+            """
+            custom_kernel = mx.fast.metal_kernel
+        elif mx.cuda.is_available():
+            source = """
+                auto elem = cooperative_groups::this_grid().thread_rank();
+                auto loc = elem_to_loc(elem, inp_shape.data(), inp_strides.data(), inp_ndim);
+                T tmp = inp[loc];
+                out[elem] = exp(tmp) * WARP_SIZE;
+            """
+            source_contig = """
+                auto elem = cooperative_groups::this_grid().thread_rank();
+                T tmp = inp[elem];
+                out[elem] = exp(tmp) * WARP_SIZE;
+            """
+            custom_kernel = mx.fast.cuda_kernel
+
+        mx.random.seed(7)
+        a = mx.random.normal(shape=(3, 6))
+
+        # non contiguous
+        a = mx.tile(a[::2], [4, 1])
+
+        for contig in [True, False]:
+            kernel = custom_kernel(
+                name="myexp" + str(contig),
+                input_names=["inp"],
+                output_names=["out"],
+                source=source_contig if contig else source,
+                ensure_row_contiguous=contig,
+            )
+            outputs = kernel(
+                inputs=[a],
+                template=[("T", mx.float32)],
+                grid=(a.size, 1, 1),
+                threadgroup=(256, 1, 1),
+                output_shapes=[a.shape],
+                output_dtypes=[a.dtype],
+                stream=mx.gpu,
+            )
+            self.assertTrue(mx.allclose(mx.exp(a) * 32, outputs[0]))
+
+    @unittest.skipIf(not mx.is_available(mx.gpu), "No GPU available")
+    def test_custom_kernel_helper(self):
+        if mx.metal.is_available():
+            header = """
+            template <typename T>
+            T do_exp(T x) {
+                return metal::precise::exp(x);
+            }
+            """
+            source = """
+                uint elem = thread_position_in_grid.x;
+                out1[elem] = do_exp(a[elem]);
+            """
+            custom_kernel = mx.fast.metal_kernel
+        elif mx.cuda.is_available():
+            header = """
+            template <typename T>
+            __device__ T do_exp(T x) {
+                return exp(x);
+            }
+            """
+            source = """
+                auto elem = cooperative_groups::this_grid().thread_rank();
+                out1[elem] = do_exp(a[elem]);
+            """
+            custom_kernel = mx.fast.cuda_kernel
+
+        mx.random.seed(7)
+        a = mx.random.normal(shape=(2, 2))
+        kernel = custom_kernel(
+            name="helper",
+            input_names=["a"],
+            output_names=["out1"],
+            header=header,
+            source=source,
+        )
+        out = kernel(
+            inputs=[a],
+            grid=(4, 1, 1),
+            threadgroup=(2, 1, 1),
+            output_shapes=[(2, 2)],
+            output_dtypes=[mx.float32],
+            stream=mx.gpu,
+        )
+        self.assertTrue(mx.allclose(out[0], mx.exp(a)))
+
+    @unittest.skipIf(not mx.is_available(mx.gpu), "No GPU available")
+    def test_custom_kernel_attributes(self):
+        if mx.metal.is_available():
+            source = "out[0] = threads_per_threadgroup.x;"
+            custom_kernel = mx.fast.metal_kernel
+        elif mx.cuda.is_available():
+            source = "out[0] = blockDim.x;"
+            custom_kernel = mx.fast.cuda_kernel
+
+        a = mx.zeros(shape=(1, 1))
+        kernel = custom_kernel(
+            name="test_fun",
+            input_names=["a"],
+            output_names=["out"],
+            source=source,
+        )
+        out = kernel(
+            inputs=[a],
+            grid=(2, 1, 1),
+            threadgroup=(2, 1, 1),
+            output_shapes=[(1, 1)],
+            output_dtypes=[mx.uint32],
+            stream=mx.gpu,
+        )[0]
+        self.assertEqual(out.item(), 2)
+
+    @unittest.skipIf(not mx.metal.is_available(), "Metal is not available")
+    def test_custom_kernel_caching(self):
+        def call_kernel(a: mx.array, source):
+            kernel = mx.fast.metal_kernel(
+                name="my_kernel",
+                input_names=["inp"],
+                output_names=["out"],
+                source=source,
+            )
+            return kernel(
+                inputs=[a],
+                grid=(a.size, 1, 1),
+                threadgroup=(a.size, 1, 1),
+                output_shapes=[a.shape],
+                output_dtypes=[a.dtype],
+                stream=mx.gpu,
+            )[0]
+
+        a = mx.random.normal(shape=(32,))
+
+        source = """
+            uint elem = thread_position_in_grid.x;
+            out[elem] = 0.0;
+        """
+
+        out = call_kernel(a, source)
+        self.assertTrue(mx.array_equal(out, mx.zeros_like(out)))
+
+        source = """
+            uint elem = thread_position_in_grid.x;
+            out[elem] = 1.0;
+        """
+        out = call_kernel(a, source)
+        self.assertTrue(mx.array_equal(out, mx.ones_like(out)))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_fast_sdpa.py b/ml-stable-diffusion/mlx/python/tests/test_fast_sdpa.py
new file mode 100644
index 0000000000000000000000000000000000000000..19af012c6ab1c5cc15e6f9033dbacd4853225f1d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_fast_sdpa.py
@@ -0,0 +1,746 @@
+import math
+import unittest
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+
+def mlx_ref_attn(q, k, v, scale=1.0, mask=None, sinks=None):
+    q_dtype = q.dtype
+    q = q * mx.array(scale, q_dtype)
+    n_q_heads = q.shape[-3]
+    n_kv_heads = k.shape[-3]
+    n_repeats = n_q_heads // n_kv_heads
+
+    B = q.shape[0]
+    L = q.shape[2]
+    kL = k.shape[2]
+
+    if n_repeats > 1:
+        q = mx.reshape(q, [B, n_kv_heads, n_repeats, L, -1])
+        k = mx.expand_dims(k, 2)
+        v = mx.expand_dims(v, 2)
+
+    scores = q @ mx.swapaxes(k, -1, -2)
+    if mask is not None:
+
+        if mask == "causal":
+            q_offset = max(0, kL - L)
+            q_indices = mx.arange(q_offset, q_offset + L)
+            k_indices = mx.arange(kL)
+            mask = q_indices[:, None] >= k_indices[None]
+
+        if n_repeats > 1 and mask.ndim >= 3:
+            if mask.shape[-3] == 1:
+                mask = mx.expand_dims(mask, -3)
+            else:
+                mask = mx.unflatten(mask, -3, (n_kv_heads, n_repeats))
+
+        if mask.dtype == mx.bool_:
+            scores = mx.where(mask, scores, mx.finfo(scores.dtype).min)
+        else:
+            scores += mask
+
+    if sinks is not None:
+        sinks = mx.expand_dims(sinks, (0, 2, 3))
+        if n_repeats > 1:
+            sinks = mx.unflatten(sinks, 1, (n_kv_heads, n_repeats))
+        score_shape = list(scores.shape)
+        score_shape[-1] = 1
+        sinks = mx.broadcast_to(sinks, score_shape)
+        scores = mx.concatenate([sinks, scores], axis=-1)
+
+    scores = mx.softmax(scores, axis=-1, precise=True)
+    if sinks is not None:
+        scores = scores[..., 1:]
+
+    out = scores @ v
+    if n_repeats > 1:
+        out = mx.reshape(out, [B, n_q_heads, L, -1])
+
+    return out
+
+
+def do_attention(f, q, k, v, scale, mask=None, transpose=False):
+    if transpose:
+        q_t = mx.transpose(q, (0, 2, 1, 3))
+        k_t = mx.transpose(k, (0, 2, 1, 3))
+        v_t = mx.transpose(v, (0, 2, 1, 3))
+        o_t = f(q_t, k_t, v_t, scale=scale, mask=mask)
+        return mx.transpose(o_t, (0, 2, 1, 3))
+    else:
+        return f(q, k, v, scale=scale, mask=mask)
+
+
+def prepare_inputs(B, qL, kL, D, qH, kH, mask, transpose, dtype):
+    np.random.seed(0)
+    np_dtype = getattr(np, dtype)
+
+    shape_q = (B, qL, qH, D) if transpose else (B, qH, qL, D)
+    shape_kv = (B, kL, kH, D) if transpose else (B, kH, kL, D)
+
+    scale = 1.0 / math.sqrt(D)
+
+    q_np = np.random.normal(0.0, 0.5, shape_q).astype(np_dtype)
+    k_np = np.random.normal(0.0, 0.5, shape_kv).astype(np_dtype)
+    v_np = np.random.normal(0.0, scale, shape_kv).astype(np_dtype)
+
+    q_mx = mx.array(q_np)
+    k_mx = mx.array(k_np)
+    v_mx = mx.array(v_np)
+
+    if mask is not None:
+        if mask == "additive":
+            mask_np = np.random.normal(0.0, 0.5, (B, qH, qL, kL)).astype(np_dtype)
+            mask = mx.array(mask_np)
+        elif mask == "bool":
+            mask_np = np.random.uniform(0.0, 1.0, (B, qH, qL, kL)) < 0.5
+            mask = mx.array(mask_np)
+
+    return q_mx, k_mx, v_mx, scale, mask
+
+
+# SDPA for MHA (n_heads == n_kv_heads)
+def mlx_primitives_sdpa(q, k, v, scale, mask=None):
+    p = (q * scale) @ k.transpose(0, 1, 3, 2)
+    if mask is not None:
+        if mask == "causal":
+            q_offset = max(0, k.shape[2] - q.shape[2])
+            q_indices = mx.arange(q_offset, q_offset + q.shape[2])
+            k_indices = mx.arange(k.shape[2])
+            mask = q_indices[:, None] >= k_indices[None]
+            p = mx.where(mask, p, mx.finfo(mx.float32).min)
+        elif mask.dtype == mx.bool_:
+            p = mx.where(mask, p, mx.finfo(mx.float32).min)
+        else:
+            p += mask
+    scores = mx.softmax(p.astype(mx.float32), axis=-1).astype(p.dtype)
+    return scores @ v
+
+
+# SDPA for GQA (n_heads > n_kv_heads, n_kv_heads > 1, n_heads % n_kv_heads == 0)
+def mlx_primitives_sdpa_with_gqa(q, k, v, scale, mask=None):
+    n_repeats = q.shape[1] // k.shape[1]
+
+    # borrowing kv cache tiling from mlx-examples/llms/mistral/mistral.py
+    n_heads = q.shape[1]
+    B = q.shape[0]
+    L = k.shape[2]
+
+    def repeat(a):
+        a = mx.concatenate([mx.expand_dims(a, 2)] * n_repeats, axis=2)
+        return a.reshape([B, n_heads, L, -1])
+
+    k, v = map(repeat, (k, v))
+
+    return mlx_primitives_sdpa(q, k, v, scale, mask=mask)
+
+
+class TestFastSelfAttentionSDPA(mlx_tests.MLXTestCase):
+    def test_fast_sdpa(self):
+        # Not yet supported:
+        # * K pre-transposed in kernel, V pre-transposed in kernel
+        np.random.seed(0)
+        R = 20
+        L = R
+        Dk = 64
+        H = 3
+        scale = float(1.0 / np.sqrt(Dk))
+        q_npy = np.random.normal(0.0, 1.0, (1, H, R, Dk)).astype(np.float32)
+        k_npy = np.random.normal(0.0, 1.0, (1, H, L, Dk)).astype(np.float32)
+        v_npy = np.random.normal(0.0, 1.0, (1, H, L, Dk)).astype(np.float32)
+
+        q_mlx = mx.array(q_npy)
+        k_mlx = mx.array(k_npy)
+        v_mlx = mx.array(v_npy)
+
+        reference = mlx_primitives_sdpa(q_mlx, k_mlx, v_mlx, scale)
+
+        o_mlx = mx.fast.scaled_dot_product_attention(
+            q_mlx, k_mlx, v_mlx, scale=scale, mask=None
+        )
+
+        self.assertListEqual(list(reference.shape), list(o_mlx.shape))
+        self.assertTrue(mx.allclose(o_mlx, reference, atol=1e-4))
+
+        dtypes = [np.float32]
+
+        Dk = 64
+
+        if self.is_apple_silicon or mx.cuda.is_available():
+            dtypes.append(np.half)
+
+        for SEQUENCE_LENGTH in [63, 129, 400]:
+            for DTYPE in dtypes:
+                B = 2
+                H = 24
+                n_kv_heads = H
+                q_npy = np.random.normal(0.0, 1.0, (B, H, SEQUENCE_LENGTH, Dk)).astype(
+                    DTYPE
+                )
+                k_npy = np.random.normal(
+                    0.0, 1.0, (B, n_kv_heads, SEQUENCE_LENGTH, Dk)
+                ).astype(DTYPE)
+                v_npy = np.random.normal(
+                    0.0, 1.0, (B, n_kv_heads, SEQUENCE_LENGTH, Dk)
+                ).astype(DTYPE)
+
+                q_mlx = mx.array(q_npy)
+                k_mlx = mx.array(k_npy)
+                v_mlx = mx.array(v_npy)
+
+                reference = mlx_primitives_sdpa_with_gqa(q_mlx, k_mlx, v_mlx, scale)
+                o_mlx = mx.fast.scaled_dot_product_attention(
+                    q_mlx,
+                    k_mlx,
+                    v_mlx,
+                    scale=scale,
+                )
+
+                self.assertListEqual(list(reference.shape), list(o_mlx.shape))
+                rtol = 1e-3
+                atol = 1e-2
+
+                if SEQUENCE_LENGTH > 500:
+                    rtol = 1e-2
+
+                if DTYPE == np.half:
+                    rtol = 1e-2
+
+                self.assertTrue(mx.allclose(o_mlx, reference, rtol=rtol, atol=atol))
+
+
+class TestFastSDPA(mlx_tests.MLXTestCase):
+    def test_fast_sdpa(self):
+        # Not yet supported:
+        # * K pre-transposed in kernel, V pre-transposed in kernel
+        np.random.seed(0)
+        L = 43
+        R = 1
+        Dk = 128
+        scale = float(1.0 / np.sqrt(128.0))
+        q_npy = np.random.normal(0.0, 1.0, (1, 32, R, Dk)).astype(np.float32)
+        k_npy = np.random.normal(0.0, 1.0, (1, 32, L, Dk)).astype(np.float32)
+        v_npy = np.random.normal(0.0, 1.0, (1, 32, L, Dk)).astype(np.float32)
+
+        q_mlx = mx.array(q_npy)
+        k_mlx = mx.array(k_npy)
+        v_mlx = mx.array(v_npy)
+
+        reference = mlx_primitives_sdpa(q_mlx, k_mlx, v_mlx, scale)
+
+        o_mlx = mx.fast.scaled_dot_product_attention(
+            q_mlx, k_mlx, v_mlx, scale=scale, mask=None
+        )
+
+        self.assertListEqual(list(reference.shape), list(o_mlx.shape))
+        self.assertTrue(mx.allclose(o_mlx, reference, atol=1e-4))
+
+        B = 1
+        H = 32
+        dtypes = [np.float32]
+        if self.is_apple_silicon or mx.cuda.is_available():
+            dtypes.append(np.half)
+
+        for SEQUENCE_LENGTH in [1, 7, 9, 32, 63, 67, 129, 400, 2000]:
+            for DO_GQA in [0, 1]:
+                for DTYPE in dtypes:
+                    n_kv_heads = 8 if DO_GQA else 32
+                    q_npy = np.random.normal(0.0, 1.0, (B, H, R, Dk)).astype(DTYPE)
+                    k_npy = np.random.normal(
+                        0.0, 1.0, (B, n_kv_heads, SEQUENCE_LENGTH, Dk)
+                    ).astype(DTYPE)
+                    v_npy = np.random.normal(
+                        0.0, 1.0, (B, n_kv_heads, SEQUENCE_LENGTH, Dk)
+                    ).astype(DTYPE)
+
+                    q_mlx = mx.array(q_npy)
+                    k_mlx = mx.array(k_npy)
+                    v_mlx = mx.array(v_npy)
+
+                    reference = mlx_primitives_sdpa_with_gqa(q_mlx, k_mlx, v_mlx, scale)
+                    o_mlx = mx.fast.scaled_dot_product_attention(
+                        q_mlx, k_mlx, v_mlx, scale=scale
+                    )
+
+                    self.assertListEqual(list(reference.shape), list(o_mlx.shape))
+                    rtol = 1e-5
+                    atol = 1e-1
+
+                    if SEQUENCE_LENGTH > 500:
+                        rtol = 1e-2
+
+                    if DTYPE == np.half:
+                        rtol = 1e-2
+
+                    self.assertTrue(mx.allclose(o_mlx, reference, rtol=rtol, atol=atol))
+        q = mx.random.normal(shape=(1, 32, 1, Dk))
+        k = mx.random.normal(shape=(1, 32, 32, Dk))
+        v = mx.random.normal(shape=(1, 32, 128, Dk))
+
+        atol = 1e-6
+        y = mlx_primitives_sdpa(q, k, v[:, :, :32], scale)
+        y_hat = mx.fast.scaled_dot_product_attention(q, k, v[:, :, :32], scale=scale)
+        self.assertTrue(mx.allclose(y, y_hat, atol=atol))
+
+        # Test with per-example mask
+        q = mx.random.normal(shape=(2, 8, 4, 32))
+        k = mx.random.normal(shape=(2, 2, 8, 32))
+        v = mx.random.normal(shape=(2, 2, 8, 32))
+        mask = 10 * mx.random.normal(shape=(2, 1, 4, 8))
+        y = mlx_primitives_sdpa_with_gqa(q, k, v, scale, mask=mask)
+        y_hat = mx.fast.scaled_dot_product_attention(q, k, v, scale=scale, mask=mask)
+        self.assertTrue(mx.allclose(y, y_hat, atol=atol))
+
+        # Test with boolean causal mask
+        indices = mx.arange(8)
+        bool_mask = indices[:, None] >= indices[None]
+        additive_mask = (~bool_mask).astype(mx.float32) * mx.finfo(mx.float32).min
+        x = mx.random.normal(shape=(1, 2, 8, 32))
+        y = mlx_primitives_sdpa_with_gqa(x, x, x, scale, mask=additive_mask)
+        y_hat = mx.fast.scaled_dot_product_attention(
+            x, x, x, scale=scale, mask=bool_mask
+        )
+        self.assertTrue(mx.allclose(y, y_hat, atol=atol))
+
+    def test_fast_sdpa_vector_kv_transposed_head_seq(self):
+        D = 64
+        Nq = 4
+        Nkv = 1
+        scale = 1.0
+        mx.random.seed(0)
+        q = 5e-1 * mx.random.normal(shape=(1, Nq, 1, D))
+
+        lengths = [43, 4096]
+        for L in lengths:
+            k = 5e-1 * mx.random.normal(shape=(1, L, Nkv, D))
+            v = 5e-1 * mx.random.normal(shape=(1, L, Nkv, D))
+            k = k.swapaxes(1, 2)
+            v = v.swapaxes(1, 2)
+            masks = [
+                mx.array(True),
+                mx.array([True] * (L - 10) + [False] * 10),
+                mx.random.uniform(shape=(Nq, 1, L)) > 0.2,
+                mx.random.uniform(shape=(L, 1, Nq)).T > 0.2,
+            ]
+
+            for m in masks:
+                ref = mlx_primitives_sdpa(q, k, v, scale, mask=m)
+                out = mx.fast.scaled_dot_product_attention(
+                    q,
+                    k,
+                    v,
+                    scale=scale,
+                    mask=m,
+                )
+                self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+    def test_fast_sdpa_vector(self):
+        D = 64
+        L = 43
+        Nq = 4
+        Nkv = 1
+        scale = 1.0
+        mx.random.seed(0)
+        q = 5e-1 * mx.random.normal(shape=(1, Nq, 1, D))
+        k = 5e-1 * mx.random.normal(shape=(1, Nkv, L, D))
+        v = 5e-1 * mx.random.normal(shape=(1, Nkv, L, D))
+
+        with self.assertRaises(ValueError):
+            mx.fast.scaled_dot_product_attention(
+                q,
+                k,
+                v,
+                scale=scale,
+                mask=mx.full((Nq, 2, L), False),
+            )
+
+        masks = [
+            None,
+            mx.array(True),
+            mx.array([True] * (L - 10) + [False] * 10),
+            mx.random.uniform(shape=(Nq, 1, L)) > 0.2,
+            mx.random.uniform(shape=(L, 1, Nq)).T > 0.2,
+            mx.random.uniform(shape=(Nq, 1, L)),
+            mx.random.uniform(shape=(L, 1, Nq)).T,
+            mx.log(mx.random.uniform(shape=(Nq, 1, L)) > 0.2),
+            mx.log(mx.random.uniform(shape=(L, 1, Nq)).T > 0.2),
+            "causal",
+        ]
+        for m in masks:
+            ref = mlx_primitives_sdpa(q, k, v, scale, mask=m)
+            out = mx.fast.scaled_dot_product_attention(
+                q,
+                k,
+                v,
+                scale=scale,
+                mask=m,
+            )
+            self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+        L = 4096
+        scale = 1.0
+        mx.random.seed(0)
+        q = 5e-1 * mx.random.normal(shape=(1, Nq, 1, D))
+        k = 5e-1 * mx.random.normal(shape=(1, Nkv, L, D))
+        v = 5e-1 * mx.random.normal(shape=(1, Nkv, L, D))
+
+        masks = [
+            mx.array(True),
+            mx.array([True] * (L - 10) + [False] * 10),
+            mx.random.uniform(shape=(Nq, 1, L)) > 0.2,
+            mx.random.uniform(shape=(L, 1, Nq)).T > 0.2,
+            mx.random.uniform(shape=(Nq, 1, L)),
+            mx.random.uniform(shape=(L, 1, Nq)).T,
+            mx.log(mx.random.uniform(shape=(Nq, 1, L)) > 0.2),
+            mx.log(mx.random.uniform(shape=(L, 1, Nq)).T > 0.2),
+            "causal",
+        ]
+        for m in masks:
+            ref = mlx_primitives_sdpa(q, k, v, scale, mask=m)
+            out = mx.fast.scaled_dot_product_attention(
+                q,
+                k,
+                v,
+                scale=scale,
+                mask=m,
+            )
+            self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+    def test_fully_masked(self):
+        Lkv = 8
+        mask = mx.array(False)
+        for D in [128]:
+            for Lq in [1, 8, 32]:
+                q = mx.random.normal(shape=(1, 4, Lq, D))
+                k = mx.random.normal(shape=(1, 4, Lkv, D))
+                v = mx.random.normal(shape=(1, 4, Lkv, D))
+
+                out = mx.fast.scaled_dot_product_attention(q, k, v, mask=mask, scale=1)
+                self.assertFalse(mx.any(mx.isnan(out)))
+
+    def test_inf_score(self):
+        Lkv = 8
+        for D in [4, 128]:
+            for Lq in [1, 8]:
+                q = mx.ones(shape=(1, 4, Lq, D))
+                k = mx.ones(shape=(1, 4, Lkv, D))
+                v = mx.random.normal(shape=(1, 4, Lkv, D))
+                k[..., 0, :] = -float("inf")
+                ref = mlx_primitives_sdpa(q, k, v, scale=1, mask=None)
+                out = mx.fast.scaled_dot_product_attention(q, k, v, mask=None, scale=1)
+                self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+    def test_fast_sdpa_few_query(self):
+        D = 64
+        L = 43
+        Lq = 8
+        Nq = 8
+        Nkv = 1
+        scale = 1.0
+        mx.random.seed(0)
+        q = 5e-1 * mx.random.normal(shape=(1, Lq, Nq, D))
+        q = q.swapaxes(1, 2)
+        k = 5e-1 * mx.random.normal(shape=(1, Nkv, L, D))
+        v = 5e-1 * mx.random.normal(shape=(1, Nkv, L, D))
+
+        masks = [
+            None,
+            mx.array(True),
+            mx.array([True] * (L - 10) + [False] * 10),
+            mx.random.uniform(shape=(Nq, 1, L)) > 0.2,
+            mx.random.uniform(shape=(L, 1, Nq)).T > 0.2,
+            "causal",
+        ]
+        for m in masks:
+            ref = mlx_primitives_sdpa(q, k, v, scale, mask=m)
+            out = mx.fast.scaled_dot_product_attention(
+                q,
+                k,
+                v,
+                scale=scale,
+                mask=m,
+            )
+            self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+        L = 4096
+        scale = 1.0
+        mx.random.seed(0)
+        q = 5e-1 * mx.random.normal(shape=(1, Nq, Lq, D))
+        k = 5e-1 * mx.random.normal(shape=(1, Nkv, L, D))
+        v = 5e-1 * mx.random.normal(shape=(1, Nkv, L, D))
+
+        masks = [
+            None,
+            mx.array(True),
+            mx.array([True] * (L - 10) + [False] * 10),
+            mx.random.uniform(shape=(Nq, 1, L)) > 0.2,
+            mx.random.uniform(shape=(L, 1, Nq)).T > 0.2,
+            "causal",
+        ]
+        for m in masks:
+            ref = mlx_primitives_sdpa(q, k, v, scale, mask=m)
+            out = mx.fast.scaled_dot_product_attention(
+                q,
+                k,
+                v,
+                scale=scale,
+                mask=m,
+            )
+            self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+    @unittest.skip("Different head and value dims is not enabled")
+    def test_fast_sdpa_vector_value_dims(self):
+        D = 192
+        V = 128
+        Nq = 4
+        Nkv = 1
+        scale = 1.0
+        mx.random.seed(0)
+
+        for L in [43, 128, 237, 8192]:
+            q = 5e-1 * mx.random.normal(shape=(1, Nq, 1, D))
+            k = 5e-1 * mx.random.normal(shape=(1, Nkv, L, D))
+            v = 5e-1 * mx.random.normal(shape=(1, Nkv, L, V))
+            ref = mlx_primitives_sdpa(q, k, v, scale)
+            out = mx.fast.scaled_dot_product_attention(q, k, v, scale=scale)
+            self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+    def test_sdpa_vector_batched(self):
+        D = 64
+        q = mx.random.normal(shape=(2, 1, 3, D))
+        k = mx.random.normal(shape=(2, 1, 3, D))
+        v = mx.random.normal(shape=(2, 1, 3, D))
+
+        out = mx.fast.scaled_dot_product_attention(q, k, v, mask=None, scale=1.0)
+        ref = mlx_ref_attn(q, k, v)
+        self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+        q = mx.random.normal(shape=(2, 4, 3, D))
+        out = mx.fast.scaled_dot_product_attention(q, k, v, mask=None, scale=1.0)
+        ref = mlx_ref_attn(q, k, v)
+        self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+        q = mx.random.normal(shape=(2, 3, 4, D)).swapaxes(1, 2)
+        out = mx.fast.scaled_dot_product_attention(q, k, v, mask=None, scale=1.0)
+        ref = mlx_ref_attn(q, k, v)
+        self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+        k = mx.random.normal(shape=(2, 3, 1, D)).swapaxes(1, 2)
+        out = mx.fast.scaled_dot_product_attention(q, k, v, mask=None, scale=1.0)
+        ref = mlx_ref_attn(q, k, v)
+        self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+        q = mx.random.normal(shape=(2, 4, 3, D))
+        k = mx.random.normal(shape=(2, 3, 2, D)).swapaxes(1, 2)
+        v = mx.random.normal(shape=(2, 2, 3, D))
+        out = mx.fast.scaled_dot_product_attention(q, k, v, mask=None, scale=1.0)
+        ref = mlx_ref_attn(q, k, v)
+        self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+        q = mx.random.normal(shape=(2, 4, 3, D))
+        k = mx.random.normal(shape=(2, 1, 3, D))
+        v = mx.random.normal(shape=(2, 1, 3, D))
+        mask = 10 * mx.random.normal(shape=(1, 2, 3, 3)).swapaxes(0, 1)
+        out = mx.fast.scaled_dot_product_attention(q, k, v, mask=mask, scale=1.0)
+        ref = mlx_ref_attn(q, k, v, mask=mask)
+        self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+
+class TestSDPA(mlx_tests.MLXTestCase):
+    @property
+    def dtypes(self):
+        return ["float32", "float16"] if mx.metal.is_available() else ["float32"]
+
+    def test_sdpa(self):
+        if not mx.metal.is_available():
+            return
+
+        # fmt: off
+        shapes_64 = (
+            # (  B,   qsl,   ksl, head_dim, n_qh, n_kvh)
+            (  1,   128,   128,       64,   32,    32),
+            (  1,    64,   128,       64,   32,    32),
+            (  1,    65,   128,       64,   32,     8),
+            (  1,    64,   127,       64,   32,     8),
+            (  1,    65,   127,       64,   32,     8),
+            (  1,   127,    65,       64,   32,     8),
+        )
+
+        shapes_128 = (
+            # (  B,   qsl,   ksl, head_dim, n_qh, n_kvh)
+            (  1,   128,   128,      128,   32,     8),
+            (  1,    64,   128,      128,   32,     8),
+            (  1,    65,   127,      128,   32,     8),
+            (  1,   127,    65,      128,   32,     8),
+        )
+        # fmt: on
+
+        shapes = shapes_64 + shapes_128
+        masks = [None, "additive", "bool", "causal"]
+        transposes = (False, True)
+
+        for dtype in self.dtypes:
+            for t in transposes:
+                for mask_str in masks:
+                    for B, qL, kL, D, qH, kH in shapes:
+                        with self.subTest(
+                            B=B,
+                            qsl=qL,
+                            ksl=kL,
+                            head_dim=D,
+                            n_q_heads=qH,
+                            n_kv_heads=kH,
+                            mask=mask_str,
+                            transpose=t,
+                            dtype=dtype,
+                        ):
+
+                            np.random.seed(0)
+                            q_mx, k_mx, v_mx, scale, mask = prepare_inputs(
+                                B, qL, kL, D, qH, kH, mask_str, t, dtype
+                            )
+
+                            out_ref = do_attention(
+                                mlx_ref_attn, q_mx, k_mx, v_mx, scale, mask, t
+                            )
+
+                            out_fst = do_attention(
+                                mx.fast.scaled_dot_product_attention,
+                                q_mx,
+                                k_mx,
+                                v_mx,
+                                scale,
+                                mask,
+                                t,
+                            )
+
+                            atol = 2e-5 if dtype == "float32" else 3e-4
+
+                            self.assertListEqual(
+                                list(out_ref.shape), list(out_fst.shape)
+                            )
+
+                            diff = mx.abs(out_fst - out_ref) - atol * mx.abs(out_ref)
+                            self.assertLessEqual(mx.max(diff).item(), atol)
+
+    def test_sdpa_broadcast_mask(self):
+        mask = mx.array(True)
+        D = 64
+        Nq = 4
+        Nkv = 1
+        scale = 1.0
+        L = 256
+
+        mx.random.seed(0)
+        q = 5e-1 * mx.random.normal(shape=(1, Nq, L, D))
+        k = 5e-1 * mx.random.normal(shape=(1, Nkv, L, D))
+        v = 5e-1 * mx.random.normal(shape=(1, Nkv, L, D))
+        ref = mlx_primitives_sdpa(q, k, v, scale, mask=mask)
+        out = mx.fast.scaled_dot_product_attention(q, k, v, scale=scale, mask=mask)
+        self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+    def test_sdpa_noncontiguous_inputs(self):
+        mask = mx.ones(shape=(4, 1, 7, 7), dtype=mx.bool_)
+        mx.random.seed(0)
+        q = mx.random.normal(shape=(4, 7, 32, 64)).swapaxes(1, 2)
+
+        k = mx.random.normal(shape=(4, 7, 8, 64)).swapaxes(1, 2)
+        v = mx.random.normal(shape=(4, 7, 8, 64)).swapaxes(1, 2)
+        out = mx.fast.scaled_dot_product_attention(q, k, v, scale=1.0, mask=mask)
+        ref = mlx_ref_attn(q, k, v, scale=1.0, mask=mask)
+        self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+    def test_sdpa_promote_mask(self):
+        mask = mx.array(2.0, mx.bfloat16)
+        D = 64
+        Nq = 4
+        Nkv = 1
+        scale = 1.0
+        L = 256
+
+        mx.random.seed(0)
+        q = 5e-1 * mx.random.normal(shape=(1, Nq, L, D))
+        k = 5e-1 * mx.random.normal(shape=(1, Nkv, L, D))
+        v = 5e-1 * mx.random.normal(shape=(1, Nkv, L, D))
+        ref = mlx_primitives_sdpa(q, k, v, scale, mask=mask)
+        out = mx.fast.scaled_dot_product_attention(q, k, v, scale=scale, mask=mask)
+        self.assertTrue(mx.allclose(ref, out, atol=1e-4, rtol=1e-4))
+
+    def test_sdpa_nan_bug(self):
+        N = 128
+        q_shape = (1, 1, N, 128)
+        kv_shape = (1, 1, N, 128)
+        q = mx.random.uniform(shape=q_shape)
+        k = mx.random.uniform(shape=kv_shape)
+        v = mx.random.uniform(shape=kv_shape)
+
+        # Make boolean window causal mask
+        linds = rinds = mx.arange(N)
+        linds = linds[:, None]
+        rinds = rinds[None]
+        mask = linds >= rinds
+        mask = mask & (linds <= rinds + 111)
+
+        out = mx.fast.scaled_dot_product_attention(q, k, v, mask=mask, scale=1.0)
+        expected = mlx_ref_attn(q, k, v, mask=mask, scale=1.0)
+        self.assertFalse(mx.isnan(out).any().item())
+        self.assertLessEqual(mx.abs(out - expected).max().item(), 1e-4)
+
+        # And an additive one
+        mask = mx.log(mask)
+
+        out = mx.fast.scaled_dot_product_attention(q, k, v, mask=mask, scale=1.0)
+        expected = mlx_ref_attn(q, k, v, mask=mask, scale=1.0)
+        self.assertFalse(mx.isnan(out).any().item())
+        self.assertLessEqual(mx.abs(out - expected).max().item(), 1e-4)
+
+    def test_sdpa_attention_sinks(self):
+        B = 2
+        N_q = N_kv = 8
+        T_q = T_kv = 128
+        D = 64
+
+        q = mx.random.normal(shape=(B, N_q, T_q, D))
+        k = mx.random.normal(shape=(B, N_kv, T_kv, D))
+        v = mx.random.normal(shape=(B, N_kv, T_kv, D))
+        scale = D**-0.5
+
+        # sinks should promote to correct type
+        sinks = mx.random.normal(shape=(N_q,))
+        with self.assertRaises(ValueError):
+            mx.fast.scaled_dot_product_attention(
+                q.astype(mx.float16),
+                k.astype(mx.float16),
+                v.astype(mx.float16),
+                scale=scale,
+                sinks=sinks,
+            )
+
+        # Wrong shapes
+        sinks = mx.random.normal(shape=(N_q + 1,))
+        with self.assertRaises(ValueError):
+            mx.fast.scaled_dot_product_attention(q, k, v, scale=scale, sinks=sinks)
+
+        sinks = mx.random.normal(shape=())
+        with self.assertRaises(ValueError):
+            mx.fast.scaled_dot_product_attention(q, k, v, scale=scale, sinks=sinks)
+
+        for T_kv in [128, 4096]:
+            for T_q in [1, 128]:
+                for N_kv in [2, 8]:
+                    q = mx.random.normal(shape=(B, N_q, T_q, D))
+                    k = mx.random.normal(shape=(B, N_kv, T_kv, D))
+                    v = mx.random.normal(shape=(B, N_kv, T_kv, D))
+                    sinks = 10 * mx.random.normal(shape=(N_q,))
+
+                    expected = mlx_ref_attn(q, k, v, scale, sinks=sinks)
+                    out = mx.fast.scaled_dot_product_attention(
+                        q, k, v, scale=scale, sinks=sinks
+                    )
+                    self.assertTrue(mx.allclose(out, expected, atol=1e-5))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner(failfast=True)
diff --git a/ml-stable-diffusion/mlx/python/tests/test_fft.py b/ml-stable-diffusion/mlx/python/tests/test_fft.py
new file mode 100644
index 0000000000000000000000000000000000000000..07ab626722ac828555f9758a54602f22235b00ed
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_fft.py
@@ -0,0 +1,323 @@
+# Copyright © 2023 Apple Inc.
+
+import itertools
+import unittest
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+try:
+    import torch
+
+    has_torch = True
+except ImportError as e:
+    has_torch = False
+
+
+class TestFFT(mlx_tests.MLXTestCase):
+    def check_mx_np(self, op_mx, op_np, a_np, atol=1e-5, rtol=1e-6, **kwargs):
+        out_np = op_np(a_np, **kwargs)
+        a_mx = mx.array(a_np)
+        out_mx = op_mx(a_mx, **kwargs)
+        np.testing.assert_allclose(out_np, out_mx, atol=atol, rtol=rtol)
+
+    def test_fft(self):
+        r = np.random.rand(100).astype(np.float32)
+        i = np.random.rand(100).astype(np.float32)
+        a_np = r + 1j * i
+        self.check_mx_np(mx.fft.fft, np.fft.fft, a_np)
+
+        # Check with slicing and padding
+        r = np.random.rand(100).astype(np.float32)
+        i = np.random.rand(100).astype(np.float32)
+        a_np = r + 1j * i
+        self.check_mx_np(mx.fft.fft, np.fft.fft, a_np, n=80)
+        self.check_mx_np(mx.fft.fft, np.fft.fft, a_np, n=120)
+
+        # Check different axes
+        r = np.random.rand(100, 100).astype(np.float32)
+        i = np.random.rand(100, 100).astype(np.float32)
+        a_np = r + 1j * i
+        self.check_mx_np(mx.fft.fft, np.fft.fft, a_np, axis=0)
+        self.check_mx_np(mx.fft.fft, np.fft.fft, a_np, axis=1)
+
+        # Check real fft
+        a_np = np.random.rand(100).astype(np.float32)
+        self.check_mx_np(mx.fft.rfft, np.fft.rfft, a_np)
+        self.check_mx_np(mx.fft.rfft, np.fft.rfft, a_np, n=80)
+        self.check_mx_np(mx.fft.rfft, np.fft.rfft, a_np, n=120)
+
+        # Check real inverse
+        r = np.random.rand(100, 100).astype(np.float32)
+        i = np.random.rand(100, 100).astype(np.float32)
+        a_np = r + 1j * i
+        self.check_mx_np(mx.fft.ifft, np.fft.ifft, a_np)
+        self.check_mx_np(mx.fft.ifft, np.fft.ifft, a_np, n=80)
+        self.check_mx_np(mx.fft.ifft, np.fft.ifft, a_np, n=120)
+
+        x = np.fft.rfft(np.real(a_np))
+        self.check_mx_np(mx.fft.irfft, np.fft.irfft, x)
+
+    def test_fftn(self):
+        r = np.random.randn(8, 8, 8).astype(np.float32)
+        i = np.random.randn(8, 8, 8).astype(np.float32)
+        a = r + 1j * i
+
+        axes = [None, (1, 2), (2, 1), (0, 2)]
+        shapes = [None, (10, 5), (5, 10)]
+        ops = [
+            "fft2",
+            "ifft2",
+            "rfft2",
+            "irfft2",
+            "fftn",
+            "ifftn",
+            "rfftn",
+            "irfftn",
+        ]
+
+        for op, ax, s in itertools.product(ops, axes, shapes):
+            if ax is None and s is not None:
+                continue
+            x = a
+            if op in ["rfft2", "rfftn"]:
+                x = r
+            elif op == "irfft2":
+                x = np.ascontiguousarray(np.fft.rfft2(r, axes=ax, s=s))
+            elif op == "irfftn":
+                x = np.ascontiguousarray(np.fft.rfftn(r, axes=ax, s=s))
+            mx_op = getattr(mx.fft, op)
+            np_op = getattr(np.fft, op)
+            self.check_mx_np(mx_op, np_op, x, axes=ax, s=s)
+
+    def _run_ffts(self, shape, atol=1e-4, rtol=1e-4):
+        np.random.seed(9)
+
+        r = np.random.rand(*shape).astype(np.float32)
+        i = np.random.rand(*shape).astype(np.float32)
+        a_np = r + 1j * i
+        self.check_mx_np(mx.fft.fft, np.fft.fft, a_np, atol=atol, rtol=rtol)
+        self.check_mx_np(mx.fft.ifft, np.fft.ifft, a_np, atol=atol, rtol=rtol)
+
+        self.check_mx_np(mx.fft.rfft, np.fft.rfft, r, atol=atol, rtol=rtol)
+
+        ia_np = np.fft.rfft(r)
+        self.check_mx_np(
+            mx.fft.irfft, np.fft.irfft, ia_np, atol=atol, rtol=rtol, n=shape[-1]
+        )
+        self.check_mx_np(mx.fft.irfft, np.fft.irfft, ia_np, atol=atol, rtol=rtol)
+
+    def test_fft_shared_mem(self):
+        nums = np.concatenate(
+            [
+                # small radix
+                np.arange(2, 14),
+                # powers of 2
+                [2**k for k in range(4, 13)],
+                # stockham
+                [3 * 3 * 3, 3 * 11, 11 * 13 * 2, 7 * 4 * 13 * 11, 13 * 13 * 11],
+                # rader
+                [17, 23, 29, 17 * 8 * 3, 23 * 2, 1153, 1982],
+                # bluestein
+                [47, 83, 17 * 17],
+                # large stockham
+                [3159, 3645, 3969, 4004],
+            ]
+        )
+        for batch_size in (1, 3, 32):
+            for num in nums:
+                atol = 1e-4 if num < 1025 else 1e-3
+                self._run_ffts((batch_size, num), atol=atol)
+
+    @unittest.skip("Too slow for CI but useful for local testing.")
+    def test_fft_exhaustive(self):
+        nums = range(2, 4097)
+        for batch_size in (1, 3, 32):
+            for num in nums:
+                print(num)
+                atol = 1e-4 if num < 1025 else 1e-3
+                self._run_ffts((batch_size, num), atol=atol)
+
+    def test_fft_big_powers_of_two(self):
+        # TODO: improve precision on big powers of two on GPU
+        for k in range(12, 17):
+            self._run_ffts((3, 2**k), atol=1e-3)
+
+        for k in range(17, 20):
+            self._run_ffts((3, 2**k), atol=1e-2)
+
+    def test_fft_large_numbers(self):
+        numbers = [
+            1037,  # prime > 2048
+            18247,  # medium size prime factors
+            1259 * 11,  # large prime factors
+            7883,  # large prime
+            3**8,  # large stockham decomposable
+            3109,  # bluestein
+            4006,  # large rader
+        ]
+        for large_num in numbers:
+            self._run_ffts((1, large_num), atol=1e-3)
+
+    def test_fft_contiguity(self):
+        r = np.random.rand(4, 8).astype(np.float32)
+        i = np.random.rand(4, 8).astype(np.float32)
+        a_np = r + 1j * i
+        a_mx = mx.array(a_np)
+
+        # non-contiguous in the FFT dim
+        out_mx = mx.fft.fft(a_mx[:, ::2])
+        out_np = np.fft.fft(a_np[:, ::2])
+        np.testing.assert_allclose(out_np, out_mx, atol=1e-5, rtol=1e-5)
+
+        # non-contiguous not in the FFT dim
+        out_mx = mx.fft.fft(a_mx[::2])
+        out_np = np.fft.fft(a_np[::2])
+        np.testing.assert_allclose(out_np, out_mx, atol=1e-5, rtol=1e-5)
+
+        out_mx = mx.broadcast_to(mx.reshape(mx.transpose(a_mx), (4, 8, 1)), (4, 8, 16))
+        out_np = np.broadcast_to(np.reshape(np.transpose(a_np), (4, 8, 1)), (4, 8, 16))
+        np.testing.assert_allclose(out_np, out_mx, atol=1e-5, rtol=1e-5)
+
+        out2_mx = mx.fft.fft(mx.abs(out_mx) + 4)
+        out2_np = np.fft.fft(np.abs(out_np) + 4)
+        np.testing.assert_allclose(out2_mx, out2_np, atol=1e-5, rtol=1e-5)
+
+        b_np = np.array([[0, 1, 2, 3]])
+        out_mx = mx.abs(mx.fft.fft(mx.tile(mx.reshape(mx.array(b_np), (1, 4)), (4, 1))))
+        out_np = np.abs(np.fft.fft(np.tile(np.reshape(np.array(b_np), (1, 4)), (4, 1))))
+        np.testing.assert_allclose(out_mx, out_np, atol=1e-5, rtol=1e-5)
+
+    def test_fft_into_ifft(self):
+        n_fft = 8193
+        mx.random.seed(0)
+
+        segment = mx.random.normal(shape=[1, n_fft]) + 1j * mx.random.normal(
+            shape=(1, n_fft)
+        )
+        segment = mx.fft.fft(segment, n=n_fft)
+        r = mx.fft.ifft(segment, n=n_fft)
+        r_np = np.fft.ifft(segment, n=n_fft)
+        self.assertTrue(np.allclose(r, r_np, atol=1e-5, rtol=1e-5))
+
+    def test_fft_throws(self):
+        x = mx.array(3.0)
+        with self.assertRaises(ValueError):
+            mx.fft.irfftn(x)
+
+    def test_fftshift(self):
+        # Test 1D arrays
+        r = np.random.rand(100).astype(np.float32)
+        self.check_mx_np(mx.fft.fftshift, np.fft.fftshift, r)
+
+        # Test with specific axis
+        r = np.random.rand(4, 6).astype(np.float32)
+        self.check_mx_np(mx.fft.fftshift, np.fft.fftshift, r, axes=[0])
+        self.check_mx_np(mx.fft.fftshift, np.fft.fftshift, r, axes=[1])
+        self.check_mx_np(mx.fft.fftshift, np.fft.fftshift, r, axes=[0, 1])
+
+        # Test with negative axes
+        self.check_mx_np(mx.fft.fftshift, np.fft.fftshift, r, axes=[-1])
+
+        # Test with odd lengths
+        r = np.random.rand(5, 7).astype(np.float32)
+        self.check_mx_np(mx.fft.fftshift, np.fft.fftshift, r)
+        self.check_mx_np(mx.fft.fftshift, np.fft.fftshift, r, axes=[0])
+
+        # Test with complex input
+        r = np.random.rand(8, 8).astype(np.float32)
+        i = np.random.rand(8, 8).astype(np.float32)
+        c = r + 1j * i
+        self.check_mx_np(mx.fft.fftshift, np.fft.fftshift, c)
+
+    def test_ifftshift(self):
+        # Test 1D arrays
+        r = np.random.rand(100).astype(np.float32)
+        self.check_mx_np(mx.fft.ifftshift, np.fft.ifftshift, r)
+
+        # Test with specific axis
+        r = np.random.rand(4, 6).astype(np.float32)
+        self.check_mx_np(mx.fft.ifftshift, np.fft.ifftshift, r, axes=[0])
+        self.check_mx_np(mx.fft.ifftshift, np.fft.ifftshift, r, axes=[1])
+        self.check_mx_np(mx.fft.ifftshift, np.fft.ifftshift, r, axes=[0, 1])
+
+        # Test with negative axes
+        self.check_mx_np(mx.fft.ifftshift, np.fft.ifftshift, r, axes=[-1])
+
+        # Test with odd lengths
+        r = np.random.rand(5, 7).astype(np.float32)
+        self.check_mx_np(mx.fft.ifftshift, np.fft.ifftshift, r)
+        self.check_mx_np(mx.fft.ifftshift, np.fft.ifftshift, r, axes=[0])
+
+        # Test with complex input
+        r = np.random.rand(8, 8).astype(np.float32)
+        i = np.random.rand(8, 8).astype(np.float32)
+        c = r + 1j * i
+        self.check_mx_np(mx.fft.ifftshift, np.fft.ifftshift, c)
+
+    def test_fftshift_errors(self):
+        # Test invalid axes
+        x = mx.array(np.random.rand(4, 4).astype(np.float32))
+        with self.assertRaises(ValueError):
+            mx.fft.fftshift(x, axes=[2])
+        with self.assertRaises(ValueError):
+            mx.fft.fftshift(x, axes=[-3])
+
+        # Test empty array
+        x = mx.array([])
+        self.assertTrue(mx.array_equal(mx.fft.fftshift(x), x))
+
+    @unittest.skipIf(not has_torch, "requires PyTorch")
+    def test_fft_grads(self):
+        real = [True, False]
+        inverse = [True, False]
+        axes = [
+            (-1,),
+            (-2, -1),
+        ]
+        shapes = [
+            (4, 4),
+            (2, 4),
+            (2, 7),
+            (7, 7),
+        ]
+
+        mxffts = {
+            (True, True): mx.fft.irfftn,
+            (True, False): mx.fft.rfftn,
+            (False, True): mx.fft.ifftn,
+            (False, False): mx.fft.fftn,
+        }
+        tffts = {
+            (True, True): torch.fft.irfftn,
+            (True, False): torch.fft.rfftn,
+            (False, True): torch.fft.ifftn,
+            (False, False): torch.fft.fftn,
+        }
+
+        for r, i, ax, sh in itertools.product(real, inverse, axes, shapes):
+
+            def f(x):
+                y = mxffts[r, i](x)
+                return (mx.abs(y) ** 2).sum()
+
+            def g(x):
+                y = tffts[r, i](x)
+                return (torch.abs(y) ** 2).sum()
+
+            if r and not i:
+                x = mx.random.normal(sh)
+            else:
+                x = mx.random.normal((*sh, 2)).view(mx.complex64).squeeze()
+            fx = f(x)
+            gx = g(torch.tensor(x))
+            self.assertLess((fx - gx).abs().max() / gx.abs().mean(), 1e-4)
+
+            dfdx = mx.grad(f)(x)
+            dgdx = torch.func.grad(g)(torch.tensor(x))
+            self.assertLess((dfdx - dgdx).abs().max() / dgdx.abs().mean(), 1e-4)
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_graph.py b/ml-stable-diffusion/mlx/python/tests/test_graph.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c6a114128e5ecd8387777ad25f0e8cbfdfa2e0e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_graph.py
@@ -0,0 +1,37 @@
+# Copyright © 2023 Apple Inc.
+
+import io
+import unittest
+
+import mlx.core as mx
+import mlx_tests
+
+
+class TestGraph(mlx_tests.MLXTestCase):
+    def test_to_dot(self):
+        # Simply test that a few cases run.
+        # Nothing too specific about the graph format
+        # for now to keep it flexible
+        a = mx.array(1.0)
+        f = io.StringIO()
+        mx.export_to_dot(f, a)
+        f.seek(0)
+        self.assertTrue(len(f.read()) > 0)
+
+        b = mx.array(2.0)
+        c = a + b
+        f = io.StringIO()
+        mx.export_to_dot(f, c)
+        f.seek(0)
+        self.assertTrue(len(f.read()) > 0)
+
+        # Multi output case
+        c = mx.divmod(a, b)
+        f = io.StringIO()
+        mx.export_to_dot(f, *c)
+        f.seek(0)
+        self.assertTrue(len(f.read()) > 0)
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_init.py b/ml-stable-diffusion/mlx/python/tests/test_init.py
new file mode 100644
index 0000000000000000000000000000000000000000..046a6e836f83b1d766dfbe647301026a9e96210b
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_init.py
@@ -0,0 +1,139 @@
+# Copyright © 2023 Apple Inc.
+import unittest
+
+import mlx.core as mx
+import mlx.nn.init as init
+import mlx_tests
+import numpy as np
+
+
+class TestInit(mlx_tests.MLXTestCase):
+    def test_constant(self):
+        value = 5.0
+
+        for dtype in [mx.float32, mx.float16]:
+            initializer = init.constant(value, dtype)
+            for shape in [(3,), (3, 3), (3, 3, 3)]:
+                result = initializer(mx.array(mx.zeros(shape)))
+                with self.subTest(shape=shape):
+                    self.assertEqual(result.shape, shape)
+                    self.assertEqual(result.dtype, dtype)
+
+    def test_normal(self):
+        mean = 0.0
+        std = 1.0
+        for dtype in [mx.float32, mx.float16]:
+            initializer = init.normal(mean, std, dtype=dtype)
+            for shape in [(3,), (3, 3), (3, 3, 3)]:
+                result = initializer(mx.array(np.empty(shape)))
+                with self.subTest(shape=shape):
+                    self.assertEqual(result.shape, shape)
+                    self.assertEqual(result.dtype, dtype)
+
+    def test_uniform(self):
+        low = -1.0
+        high = 1.0
+
+        for dtype in [mx.float32, mx.float16]:
+            initializer = init.uniform(low, high, dtype)
+            for shape in [(3,), (3, 3), (3, 3, 3)]:
+                result = initializer(mx.array(np.empty(shape)))
+                with self.subTest(shape=shape):
+                    self.assertEqual(result.shape, shape)
+                    self.assertEqual(result.dtype, dtype)
+                    self.assertTrue(mx.all(result >= low) and mx.all(result <= high))
+
+    def test_identity(self):
+        for dtype in [mx.float32, mx.float16]:
+            initializer = init.identity(dtype)
+            for shape in [(3,), (3, 3), (3, 3, 3)]:
+                result = initializer(mx.zeros((3, 3)))
+                self.assertTrue(mx.array_equal(result, mx.eye(3)))
+                self.assertEqual(result.dtype, dtype)
+                with self.assertRaises(ValueError):
+                    result = initializer(mx.zeros((3, 2)))
+
+    def test_glorot_normal(self):
+        for dtype in [mx.float32, mx.float16]:
+            initializer = init.glorot_normal(dtype)
+            for shape in [(3, 3), (3, 3, 3)]:
+                result = initializer(mx.array(np.empty(shape)))
+                with self.subTest(shape=shape):
+                    self.assertEqual(result.shape, shape)
+                    self.assertEqual(result.dtype, dtype)
+
+    def test_glorot_uniform(self):
+        for dtype in [mx.float32, mx.float16]:
+            initializer = init.glorot_uniform(dtype)
+            for shape in [(3, 3), (3, 3, 3)]:
+                result = initializer(mx.array(np.empty(shape)))
+                with self.subTest(shape=shape):
+                    self.assertEqual(result.shape, shape)
+                    self.assertEqual(result.dtype, dtype)
+
+    def test_he_normal(self):
+        for dtype in [mx.float32, mx.float16]:
+            initializer = init.he_normal(dtype)
+            for shape in [(3, 3), (3, 3, 3)]:
+                result = initializer(mx.array(np.empty(shape)))
+                with self.subTest(shape=shape):
+                    self.assertEqual(result.shape, shape)
+                    self.assertEqual(result.dtype, dtype)
+
+    def test_he_uniform(self):
+        for dtype in [mx.float32, mx.float16]:
+            initializer = init.he_uniform(dtype)
+            for shape in [(3, 3), (3, 3, 3)]:
+                result = initializer(mx.array(np.empty(shape)))
+                with self.subTest(shape=shape):
+                    self.assertEqual(result.shape, shape)
+                    self.assertEqual(result.dtype, dtype)
+
+    def test_sparse(self):
+        mean = 0.0
+        std = 1.0
+        sparsity = 0.5
+        for dtype in [mx.float32, mx.float16]:
+            initializer = init.sparse(sparsity, mean, std, dtype=dtype)
+            for shape in [(3, 2), (2, 2), (4, 3)]:
+                result = initializer(mx.array(np.empty(shape)))
+                with self.subTest(shape=shape):
+                    self.assertEqual(result.shape, shape)
+                    self.assertEqual(result.dtype, dtype)
+                    self.assertEqual(
+                        (mx.sum(result == 0) >= 0.5 * shape[0] * shape[1]), True
+                    )
+            with self.assertRaises(ValueError):
+                result = initializer(mx.zeros((1,)))
+
+    def test_orthogonal(self):
+        initializer = init.orthogonal(gain=1.0, dtype=mx.float32)
+
+        # Test with a square matrix
+        shape = (4, 4)
+        result = initializer(mx.zeros(shape, dtype=mx.float32))
+        self.assertEqual(result.shape, shape)
+        self.assertEqual(result.dtype, mx.float32)
+
+        I = result @ result.T
+        eye = mx.eye(shape[0], dtype=mx.float32)
+        self.assertTrue(
+            mx.allclose(I, eye, atol=1e-5), "Orthogonal init failed on a square matrix."
+        )
+
+        # Test with a rectangular matrix: more rows than cols
+        shape = (6, 4)
+        result = initializer(mx.zeros(shape, dtype=mx.float32))
+        self.assertEqual(result.shape, shape)
+        self.assertEqual(result.dtype, mx.float32)
+
+        I = result.T @ result
+        eye = mx.eye(shape[1], dtype=mx.float32)
+        self.assertTrue(
+            mx.allclose(I, eye, atol=1e-5),
+            "Orthogonal init failed on a rectangular matrix.",
+        )
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_linalg.py b/ml-stable-diffusion/mlx/python/tests/test_linalg.py
new file mode 100644
index 0000000000000000000000000000000000000000..81a43ed7fa3642777449581055098fc0971b47ec
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_linalg.py
@@ -0,0 +1,548 @@
+# Copyright © 2023 Apple Inc.
+
+import itertools
+import math
+import unittest
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+
+class TestLinalg(mlx_tests.MLXTestCase):
+    def test_norm(self):
+        vector_ords = [None, 0.5, 0, 1, 2, 3, -1, float("inf"), -float("inf")]
+        matrix_ords = [None, "fro", "nuc", -1, 1, -2, 2, float("inf"), -float("inf")]
+
+        for shape in [(3,), (2, 3), (2, 3, 3)]:
+            x_mx = mx.arange(1, math.prod(shape) + 1, dtype=mx.float32).reshape(shape)
+            x_np = np.arange(1, math.prod(shape) + 1, dtype=np.float32).reshape(shape)
+            # Test when at least one axis is provided
+            for num_axes in range(1, len(shape)):
+                if num_axes == 1:
+                    ords = vector_ords
+                else:
+                    ords = matrix_ords
+                for axis in itertools.combinations(range(len(shape)), num_axes):
+                    for keepdims in [True, False]:
+                        for o in ords:
+                            stream = (
+                                mx.cpu if o in ["nuc", -2, 2] else mx.default_device()
+                            )
+                            out_np = np.linalg.norm(
+                                x_np, ord=o, axis=axis, keepdims=keepdims
+                            )
+                            out_mx = mx.linalg.norm(
+                                x_mx, ord=o, axis=axis, keepdims=keepdims, stream=stream
+                            )
+                            with self.subTest(
+                                shape=shape, ord=o, axis=axis, keepdims=keepdims
+                            ):
+                                self.assertTrue(
+                                    np.allclose(out_np, out_mx, atol=1e-5, rtol=1e-6)
+                                )
+
+        # Test only ord provided
+        for shape in [(3,), (2, 3)]:
+            x_mx = mx.arange(1, math.prod(shape) + 1).reshape(shape)
+            x_np = np.arange(1, math.prod(shape) + 1).reshape(shape)
+            for o in [None, 1, -1, float("inf"), -float("inf")]:
+                for keepdims in [True, False]:
+                    out_np = np.linalg.norm(x_np, ord=o, keepdims=keepdims)
+                    out_mx = mx.linalg.norm(x_mx, ord=o, keepdims=keepdims)
+                    with self.subTest(shape=shape, ord=o, keepdims=keepdims):
+                        self.assertTrue(
+                            np.allclose(out_np, out_mx, atol=1e-5, rtol=1e-6)
+                        )
+
+        # Test no ord and no axis provided
+        for shape in [(3,), (2, 3), (2, 3, 3)]:
+            x_mx = mx.arange(1, math.prod(shape) + 1).reshape(shape)
+            x_np = np.arange(1, math.prod(shape) + 1).reshape(shape)
+            for keepdims in [True, False]:
+                out_np = np.linalg.norm(x_np, keepdims=keepdims)
+                out_mx = mx.linalg.norm(x_mx, keepdims=keepdims)
+                with self.subTest(shape=shape, keepdims=keepdims):
+                    self.assertTrue(np.allclose(out_np, out_mx, atol=1e-5, rtol=1e-6))
+
+    def test_complex_norm(self):
+        for shape in [(3,), (2, 3), (2, 3, 3)]:
+            x_np = np.random.uniform(size=shape).astype(
+                np.float32
+            ) + 1j * np.random.uniform(size=shape).astype(np.float32)
+            x_mx = mx.array(x_np)
+            out_np = np.linalg.norm(x_np)
+            out_mx = mx.linalg.norm(x_mx)
+            with self.subTest(shape=shape):
+                self.assertTrue(np.allclose(out_np, out_mx, atol=1e-5, rtol=1e-6))
+            for num_axes in range(1, len(shape)):
+                for axis in itertools.combinations(range(len(shape)), num_axes):
+                    out_np = np.linalg.norm(x_np, axis=axis)
+                    out_mx = mx.linalg.norm(x_mx, axis=axis)
+                    with self.subTest(shape=shape, axis=axis):
+                        self.assertTrue(
+                            np.allclose(out_np, out_mx, atol=1e-5, rtol=1e-6)
+                        )
+
+        x_np = np.random.uniform(size=(4, 4)).astype(
+            np.float32
+        ) + 1j * np.random.uniform(size=(4, 4)).astype(np.float32)
+        x_mx = mx.array(x_np)
+        out_np = np.linalg.norm(x_np, ord="fro")
+        out_mx = mx.linalg.norm(x_mx, ord="fro")
+        self.assertTrue(np.allclose(out_np, out_mx, atol=1e-5, rtol=1e-6))
+
+    def test_qr_factorization(self):
+        with self.assertRaises(ValueError):
+            mx.linalg.qr(mx.array(0.0))
+
+        with self.assertRaises(ValueError):
+            mx.linalg.qr(mx.array([0.0, 1.0]))
+
+        with self.assertRaises(ValueError):
+            mx.linalg.qr(mx.array([[0, 1], [1, 0]]))
+
+        A = mx.array([[2.0, 3.0], [1.0, 2.0]])
+        Q, R = mx.linalg.qr(A, stream=mx.cpu)
+        out = Q @ R
+        self.assertTrue(mx.allclose(out, A))
+        out = Q.T @ Q
+        self.assertTrue(mx.allclose(out, mx.eye(2), rtol=1e-5, atol=1e-7))
+        self.assertTrue(mx.allclose(mx.tril(R, -1), mx.zeros_like(R)))
+        self.assertEqual(Q.dtype, mx.float32)
+        self.assertEqual(R.dtype, mx.float32)
+
+        # Multiple matrices
+        B = mx.array([[-1.0, 2.0], [-4.0, 1.0]])
+        A = mx.stack([A, B])
+        Q, R = mx.linalg.qr(A, stream=mx.cpu)
+        for a, q, r in zip(A, Q, R):
+            out = q @ r
+            self.assertTrue(mx.allclose(out, a))
+            out = q.T @ q
+            self.assertTrue(mx.allclose(out, mx.eye(2), rtol=1e-5, atol=1e-7))
+            self.assertTrue(mx.allclose(mx.tril(r, -1), mx.zeros_like(r)))
+
+        # Non square matrices
+        for shape in [(4, 8), (8, 4)]:
+            A = mx.random.uniform(shape=shape)
+            Q, R = mx.linalg.qr(A, stream=mx.cpu)
+            out = Q @ R
+            self.assertTrue(mx.allclose(out, A, rtol=1e-4, atol=1e-6))
+            out = Q.T @ Q
+            self.assertTrue(
+                mx.allclose(out, mx.eye(min(A.shape)), rtol=1e-4, atol=1e-6)
+            )
+
+    def test_svd_decomposition(self):
+        A = mx.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], dtype=mx.float32)
+        U, S, Vt = mx.linalg.svd(A, compute_uv=True, stream=mx.cpu)
+        self.assertTrue(
+            mx.allclose(U[:, : len(S)] @ mx.diag(S) @ Vt, A, rtol=1e-5, atol=1e-7)
+        )
+
+        S = mx.linalg.svd(A, compute_uv=False, stream=mx.cpu)
+        self.assertTrue(
+            mx.allclose(
+                mx.linalg.norm(S), mx.linalg.norm(A, ord="fro"), rtol=1e-5, atol=1e-7
+            )
+        )
+
+        # Multiple matrices
+        B = A + 10.0
+        AB = mx.stack([A, B])
+        Us, Ss, Vts = mx.linalg.svd(AB, compute_uv=True, stream=mx.cpu)
+        for M, U, S, Vt in zip([A, B], Us, Ss, Vts):
+            self.assertTrue(
+                mx.allclose(U[:, : len(S)] @ mx.diag(S) @ Vt, M, rtol=1e-5, atol=1e-7)
+            )
+
+        Ss = mx.linalg.svd(AB, compute_uv=False, stream=mx.cpu)
+        for M, S in zip([A, B], Ss):
+            self.assertTrue(
+                mx.allclose(
+                    mx.linalg.norm(S),
+                    mx.linalg.norm(M, ord="fro"),
+                    rtol=1e-5,
+                    atol=1e-7,
+                )
+            )
+
+    def test_inverse(self):
+        A = mx.array([[1, 2, 3], [6, -5, 4], [-9, 8, 7]], dtype=mx.float32)
+        A_inv = mx.linalg.inv(A, stream=mx.cpu)
+        self.assertTrue(mx.allclose(A @ A_inv, mx.eye(A.shape[0]), rtol=0, atol=1e-6))
+
+        # Multiple matrices
+        B = A - 100
+        AB = mx.stack([A, B])
+        invs = mx.linalg.inv(AB, stream=mx.cpu)
+        for M, M_inv in zip(AB, invs):
+            self.assertTrue(
+                mx.allclose(M @ M_inv, mx.eye(M.shape[0]), rtol=0, atol=1e-5)
+            )
+
+    def test_tri_inverse(self):
+        for upper in (False, True):
+            A = mx.array([[1, 0, 0], [6, -5, 0], [-9, 8, 7]], dtype=mx.float32)
+            B = mx.array([[7, 0, 0], [3, -2, 0], [1, 8, 3]], dtype=mx.float32)
+            if upper:
+                A = A.T
+                B = B.T
+            AB = mx.stack([A, B])
+            invs = mx.linalg.tri_inv(AB, upper=upper, stream=mx.cpu)
+            for M, M_inv in zip(AB, invs):
+                self.assertTrue(
+                    mx.allclose(M @ M_inv, mx.eye(M.shape[0]), rtol=0, atol=1e-5)
+                )
+
+        # Ensure that tri_inv will 0-out the supposedly 0 triangle
+        x = mx.random.normal((2, 8, 8))
+        y1 = mx.linalg.tri_inv(x, upper=True, stream=mx.cpu)
+        y2 = mx.linalg.tri_inv(x, upper=False, stream=mx.cpu)
+        self.assertTrue(mx.all(y1 == mx.triu(y1)))
+        self.assertTrue(mx.all(y2 == mx.tril(y2)))
+
+    def test_cholesky(self):
+        sqrtA = mx.array(
+            [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]], dtype=mx.float32
+        )
+        A = sqrtA.T @ sqrtA / 81
+        L = mx.linalg.cholesky(A, stream=mx.cpu)
+        U = mx.linalg.cholesky(A, upper=True, stream=mx.cpu)
+        self.assertTrue(mx.allclose(L @ L.T, A, rtol=1e-5, atol=1e-7))
+        self.assertTrue(mx.allclose(U.T @ U, A, rtol=1e-5, atol=1e-7))
+
+        # Multiple matrices
+        B = A + 1 / 9
+        AB = mx.stack([A, B])
+        Ls = mx.linalg.cholesky(AB, stream=mx.cpu)
+        for M, L in zip(AB, Ls):
+            self.assertTrue(mx.allclose(L @ L.T, M, rtol=1e-5, atol=1e-7))
+
+    def test_pseudo_inverse(self):
+        A = mx.array([[1, 2, 3], [6, -5, 4], [-9, 8, 7]], dtype=mx.float32)
+        A_plus = mx.linalg.pinv(A, stream=mx.cpu)
+        self.assertTrue(mx.allclose(A @ A_plus @ A, A, rtol=0, atol=1e-5))
+
+        # Multiple matrices
+        B = A - 100
+        AB = mx.stack([A, B])
+        pinvs = mx.linalg.pinv(AB, stream=mx.cpu)
+        for M, M_plus in zip(AB, pinvs):
+            self.assertTrue(mx.allclose(M @ M_plus @ M, M, rtol=0, atol=1e-3))
+
+        # Test singular matrix
+        A = mx.array([[4.0, 1.0], [4.0, 1.0]])
+        A_plus = mx.linalg.pinv(A, stream=mx.cpu)
+        self.assertTrue(mx.allclose(A @ A_plus @ A, A))
+
+    def test_cholesky_inv(self):
+        mx.random.seed(7)
+
+        sqrtA = mx.array(
+            [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]], dtype=mx.float32
+        )
+        A = sqrtA.T @ sqrtA / 81
+
+        N = 3
+        A = mx.random.uniform(shape=(N, N))
+        A = A @ A.T
+
+        for upper in (False, True):
+            L = mx.linalg.cholesky(A, upper=upper, stream=mx.cpu)
+            A_inv = mx.linalg.cholesky_inv(L, upper=upper, stream=mx.cpu)
+            self.assertTrue(mx.allclose(A @ A_inv, mx.eye(N), atol=1e-4))
+
+        # Multiple matrices
+        B = A + 1 / 9
+        AB = mx.stack([A, B])
+        Ls = mx.linalg.cholesky(AB, stream=mx.cpu)
+        for upper in (False, True):
+            Ls = mx.linalg.cholesky(AB, upper=upper, stream=mx.cpu)
+            AB_inv = mx.linalg.cholesky_inv(Ls, upper=upper, stream=mx.cpu)
+            for M, M_inv in zip(AB, AB_inv):
+                self.assertTrue(mx.allclose(M @ M_inv, mx.eye(N), atol=1e-4))
+
+    def test_cross_product(self):
+        a = mx.array([1.0, 2.0, 3.0])
+        b = mx.array([4.0, 5.0, 6.0])
+        result = mx.linalg.cross(a, b)
+        expected = np.cross(a, b)
+        self.assertTrue(np.allclose(result, expected))
+
+        # Test with negative values
+        a = mx.array([-1.0, -2.0, -3.0])
+        b = mx.array([4.0, -5.0, 6.0])
+        result = mx.linalg.cross(a, b)
+        expected = np.cross(a, b)
+        self.assertTrue(np.allclose(result, expected))
+
+        # Test with integer values
+        a = mx.array([1, 2, 3])
+        b = mx.array([4, 5, 6])
+        result = mx.linalg.cross(a, b)
+        expected = np.cross(a, b)
+        self.assertTrue(np.allclose(result, expected))
+
+        # Test with 2D arrays and axis parameter
+        a = mx.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
+        b = mx.array([[4.0, 5.0, 6.0], [1.0, 2.0, 3.0]])
+        result = mx.linalg.cross(a, b, axis=1)
+        expected = np.cross(a, b, axis=1)
+        self.assertTrue(np.allclose(result, expected))
+
+        # Test with broadcast
+        a = mx.random.uniform(shape=(2, 1, 3))
+        b = mx.random.uniform(shape=(1, 2, 3))
+        result = mx.linalg.cross(a, b)
+        expected = np.cross(a, b)
+        self.assertTrue(np.allclose(result, expected))
+
+        # Type promotion
+        a = mx.array([1.0, 2.0, 3.0])
+        b = mx.array([4, 5, 6])
+        result = mx.linalg.cross(a, b)
+        expected = np.cross(a, b)
+        self.assertTrue(np.allclose(result, expected))
+
+        # Test with incorrect vector size (should raise an exception)
+        a = mx.array([1.0])
+        b = mx.array([4.0])
+        with self.assertRaises(ValueError):
+            mx.linalg.cross(a, b)
+
+    def test_eig(self):
+        tols = {"atol": 1e-5, "rtol": 1e-5}
+
+        def check_eigs_and_vecs(A_np, kwargs={}):
+            A = mx.array(A_np)
+            eig_vals, eig_vecs = mx.linalg.eig(A, stream=mx.cpu, **kwargs)
+            self.assertTrue(
+                mx.allclose(A @ eig_vecs, eig_vals[..., None, :] * eig_vecs, **tols)
+            )
+            eig_vals_only = mx.linalg.eigvals(A, stream=mx.cpu, **kwargs)
+            self.assertTrue(mx.allclose(eig_vals, eig_vals_only, **tols))
+
+        # Test a simple 2x2 matrix
+        A_np = np.array([[1.0, 1.0], [3.0, 4.0]], dtype=np.float32)
+        check_eigs_and_vecs(A_np)
+
+        # Test complex eigenvalues
+        A_np = np.array([[1.0, -1.0], [1.0, 1.0]], dtype=np.float32)
+        check_eigs_and_vecs(A_np)
+
+        # Test a larger random symmetric matrix
+        n = 5
+        np.random.seed(1)
+        A_np = np.random.randn(n, n).astype(np.float32)
+        check_eigs_and_vecs(A_np)
+
+        # Test with batched input
+        A_np = np.random.randn(3, n, n).astype(np.float32)
+        check_eigs_and_vecs(A_np)
+
+        # Test error cases
+        with self.assertRaises(ValueError):
+            mx.linalg.eig(mx.array([1.0, 2.0]))  # 1D array
+
+        with self.assertRaises(ValueError):
+            mx.linalg.eig(
+                mx.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
+            )  # Non-square matrix
+
+        with self.assertRaises(ValueError):
+            mx.linalg.eigvals(mx.array([1.0, 2.0]))  # 1D array
+
+        with self.assertRaises(ValueError):
+            mx.linalg.eigvals(
+                mx.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
+            )  # Non-square matrix
+
+    def test_eigh(self):
+        tols = {"atol": 1e-5, "rtol": 1e-5}
+
+        def check_eigs_and_vecs(A_np, kwargs={}):
+            A = mx.array(A_np)
+            eig_vals, eig_vecs = mx.linalg.eigh(A, stream=mx.cpu, **kwargs)
+            eig_vals_np, _ = np.linalg.eigh(A_np, **kwargs)
+            self.assertTrue(np.allclose(eig_vals, eig_vals_np, **tols))
+            self.assertTrue(
+                mx.allclose(A @ eig_vecs, eig_vals[..., None, :] * eig_vecs, **tols)
+            )
+
+            eig_vals_only = mx.linalg.eigvalsh(A, stream=mx.cpu, **kwargs)
+            self.assertTrue(mx.allclose(eig_vals, eig_vals_only, **tols))
+
+        # Test a simple 2x2 symmetric matrix
+        A_np = np.array([[1.0, 2.0], [2.0, 4.0]], dtype=np.float32)
+        check_eigs_and_vecs(A_np)
+
+        # Test a larger random symmetric matrix
+        n = 5
+        np.random.seed(1)
+        A_np = np.random.randn(n, n).astype(np.float32)
+        A_np = (A_np + A_np.T) / 2
+        check_eigs_and_vecs(A_np)
+
+        # Test with upper triangle
+        check_eigs_and_vecs(A_np, {"UPLO": "U"})
+
+        # Test with batched input
+        A_np = np.random.randn(3, n, n).astype(np.float32)
+        A_np = (A_np + np.transpose(A_np, (0, 2, 1))) / 2
+        check_eigs_and_vecs(A_np)
+
+        # Test with complex inputs
+        A_np = (
+            np.random.randn(8, 8, 2).astype(np.float32).view(np.complex64).squeeze(-1)
+        )
+        A_np = A_np + A_np.T.conj()
+        check_eigs_and_vecs(A_np)
+
+        # Test error cases
+        with self.assertRaises(ValueError):
+            mx.linalg.eigh(mx.array([1.0, 2.0]))  # 1D array
+
+        with self.assertRaises(ValueError):
+            mx.linalg.eigh(
+                mx.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
+            )  # Non-square matrix
+
+        with self.assertRaises(ValueError):
+            mx.linalg.eigvalsh(mx.array([1.0, 2.0]))  # 1D array
+
+        with self.assertRaises(ValueError):
+            mx.linalg.eigvalsh(
+                mx.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])
+            )  # Non-square matrix
+
+    def test_lu(self):
+        with self.assertRaises(ValueError):
+            mx.linalg.lu(mx.array(0.0), stream=mx.cpu)
+
+        with self.assertRaises(ValueError):
+            mx.linalg.lu(mx.array([0.0, 1.0]), stream=mx.cpu)
+
+        with self.assertRaises(ValueError):
+            mx.linalg.lu(mx.array([[0, 1], [1, 0]]), stream=mx.cpu)
+
+        # Test 3x3 matrix
+        a = mx.array([[3.0, 1.0, 2.0], [1.0, 8.0, 6.0], [9.0, 2.0, 5.0]])
+        P, L, U = mx.linalg.lu(a, stream=mx.cpu)
+        self.assertTrue(mx.allclose(L[P, :] @ U, a))
+
+        # Test batch dimension
+        a = mx.broadcast_to(a, (5, 5, 3, 3))
+        P, L, U = mx.linalg.lu(a, stream=mx.cpu)
+        L = mx.take_along_axis(L, P[..., None], axis=-2)
+        self.assertTrue(mx.allclose(L @ U, a))
+
+        # Test non-square matrix
+        a = mx.array([[3.0, 1.0, 2.0], [1.0, 8.0, 6.0]])
+        P, L, U = mx.linalg.lu(a, stream=mx.cpu)
+        self.assertTrue(mx.allclose(L[P, :] @ U, a))
+
+        a = mx.array([[3.0, 1.0], [1.0, 8.0], [9.0, 2.0]])
+        P, L, U = mx.linalg.lu(a, stream=mx.cpu)
+        self.assertTrue(mx.allclose(L[P, :] @ U, a))
+
+    def test_lu_factor(self):
+        mx.random.seed(7)
+
+        # Test 3x3 matrix
+        a = mx.random.uniform(shape=(5, 5))
+        LU, pivots = mx.linalg.lu_factor(a, stream=mx.cpu)
+        n = a.shape[-1]
+
+        pivots = pivots.tolist()
+        perm = list(range(n))
+        for i in range(len(pivots)):
+            perm[i], perm[pivots[i]] = perm[pivots[i]], perm[i]
+
+        L = mx.add(mx.tril(LU, k=-1), mx.eye(n))
+        U = mx.triu(LU)
+        self.assertTrue(mx.allclose(L @ U, a[perm, :]))
+
+    def test_solve(self):
+        mx.random.seed(7)
+
+        # Test 3x3 matrix with 1D rhs
+        a = mx.array([[3.0, 1.0, 2.0], [1.0, 8.0, 6.0], [9.0, 2.0, 5.0]])
+        b = mx.array([11.0, 35.0, 28.0])
+
+        result = mx.linalg.solve(a, b, stream=mx.cpu)
+        expected = np.linalg.solve(a, b)
+        self.assertTrue(np.allclose(result, expected))
+
+        # Test symmetric positive-definite matrix
+        N = 5
+        a = mx.random.uniform(shape=(N, N))
+        a = mx.matmul(a, a.T) + N * mx.eye(N)
+        b = mx.random.uniform(shape=(N, 1))
+
+        result = mx.linalg.solve(a, b, stream=mx.cpu)
+        expected = np.linalg.solve(a, b)
+        self.assertTrue(np.allclose(result, expected))
+
+        # Test batch dimension
+        a = mx.random.uniform(shape=(5, 5, 4, 4))
+        b = mx.random.uniform(shape=(5, 5, 4, 1))
+
+        result = mx.linalg.solve(a, b, stream=mx.cpu)
+        expected = np.linalg.solve(a, b)
+        self.assertTrue(np.allclose(result, expected, atol=1e-5))
+
+        # Test large matrix
+        N = 1000
+        a = mx.random.uniform(shape=(N, N))
+        b = mx.random.uniform(shape=(N, 1))
+
+        result = mx.linalg.solve(a, b, stream=mx.cpu)
+        expected = np.linalg.solve(a, b)
+        self.assertTrue(np.allclose(result, expected, atol=1e-3))
+
+        # Test multi-column rhs
+        a = mx.random.uniform(shape=(5, 5))
+        b = mx.random.uniform(shape=(5, 8))
+
+        result = mx.linalg.solve(a, b, stream=mx.cpu)
+        expected = np.linalg.solve(a, b)
+        self.assertTrue(np.allclose(result, expected))
+
+        # Test batched multi-column rhs
+        a = mx.broadcast_to(a, (3, 2, 5, 5))
+        b = mx.broadcast_to(b, (3, 1, 5, 8))
+
+        result = mx.linalg.solve(a, b, stream=mx.cpu)
+        expected = np.linalg.solve(a, b)
+        self.assertTrue(np.allclose(result, expected, rtol=1e-5, atol=1e-5))
+
+    def test_solve_triangular(self):
+        # Test lower triangular matrix
+        a = mx.array([[4.0, 0.0, 0.0], [2.0, 3.0, 0.0], [1.0, -2.0, 5.0]])
+        b = mx.array([8.0, 14.0, 3.0])
+
+        result = mx.linalg.solve_triangular(a, b, upper=False, stream=mx.cpu)
+        expected = np.linalg.solve(a, b)
+        self.assertTrue(np.allclose(result, expected))
+
+        # Test upper triangular matrix
+        a = mx.array([[3.0, 2.0, 1.0], [0.0, 5.0, 4.0], [0.0, 0.0, 6.0]])
+        b = mx.array([13.0, 33.0, 18.0])
+
+        result = mx.linalg.solve_triangular(a, b, upper=True, stream=mx.cpu)
+        expected = np.linalg.solve(a, b)
+        self.assertTrue(np.allclose(result, expected))
+
+        # Test batch multi-column rhs
+        a = mx.broadcast_to(a, (3, 4, 3, 3))
+        b = mx.broadcast_to(mx.expand_dims(b, -1), (3, 4, 3, 8))
+
+        result = mx.linalg.solve_triangular(a, b, upper=True, stream=mx.cpu)
+        expected = np.linalg.solve(a, b)
+        self.assertTrue(np.allclose(result, expected))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_load.py b/ml-stable-diffusion/mlx/python/tests/test_load.py
new file mode 100644
index 0000000000000000000000000000000000000000..eaf7bcade657f875686f6cf7c9b2f5191cef3c32
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_load.py
@@ -0,0 +1,424 @@
+# Copyright © 2023 Apple Inc.
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+
+class TestLoad(mlx_tests.MLXTestCase):
+    dtypes = [
+        "uint8",
+        "uint16",
+        "uint32",
+        "uint64",
+        "int8",
+        "int16",
+        "int32",
+        "int64",
+        "float32",
+        "float16",
+        "complex64",
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        cls.test_dir_fid = tempfile.TemporaryDirectory()
+        cls.test_dir = cls.test_dir_fid.name
+        if not os.path.isdir(cls.test_dir):
+            os.mkdir(cls.test_dir)
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.test_dir_fid.cleanup()
+
+    def test_save_and_load(self):
+        for dt in self.dtypes:
+            with self.subTest(dtype=dt):
+                for i, shape in enumerate([(1,), (23,), (1024, 1024), (4, 6, 3, 1, 2)]):
+                    with self.subTest(shape=shape):
+                        save_file_mlx = os.path.join(self.test_dir, f"mlx_{dt}_{i}.npy")
+                        save_file_npy = os.path.join(self.test_dir, f"npy_{dt}_{i}.npy")
+
+                        save_arr = np.random.uniform(0.0, 32.0, size=shape)
+                        save_arr_npy = save_arr.astype(getattr(np, dt))
+                        save_arr_mlx = mx.array(save_arr_npy)
+
+                        mx.save(save_file_mlx, save_arr_mlx)
+                        np.save(save_file_npy, save_arr_npy)
+
+                        # Load array saved by mlx as mlx array
+                        load_arr_mlx_mlx = mx.load(save_file_mlx)
+                        self.assertTrue(mx.array_equal(load_arr_mlx_mlx, save_arr_mlx))
+
+                        # Load array saved by numpy as mlx array
+                        load_arr_npy_mlx = mx.load(save_file_npy)
+                        self.assertTrue(mx.array_equal(load_arr_npy_mlx, save_arr_mlx))
+
+                        # Load array saved by mlx as numpy array
+                        load_arr_mlx_npy = np.load(save_file_mlx)
+                        self.assertTrue(np.array_equal(load_arr_mlx_npy, save_arr_npy))
+
+        save_file = os.path.join(self.test_dir, f"mlx_path.npy")
+        save_arr = mx.ones((32,))
+        mx.save(Path(save_file), save_arr)
+
+        # Load array saved by mlx as mlx array
+        load_arr = mx.load(Path(save_file))
+        self.assertTrue(mx.array_equal(load_arr, save_arr))
+
+    def test_save_and_load_safetensors(self):
+        test_file = os.path.join(self.test_dir, "test.safetensors")
+        with self.assertRaises(Exception):
+            mx.save_safetensors(test_file, {"a": mx.ones((4, 4))}, {"testing": 0})
+
+        for obj in [str, Path]:
+            mx.save_safetensors(
+                obj(test_file),
+                {"test": mx.ones((2, 2))},
+                {"testing": "test", "format": "mlx"},
+            )
+            res = mx.load(obj(test_file), return_metadata=True)
+            self.assertEqual(len(res), 2)
+            self.assertEqual(res[1], {"testing": "test", "format": "mlx"})
+
+        for dt in self.dtypes + ["bfloat16"]:
+            with self.subTest(dtype=dt):
+                for i, shape in enumerate([(1,), (23,), (1024, 1024), (4, 6, 3, 1, 2)]):
+                    with self.subTest(shape=shape):
+                        save_file_mlx = os.path.join(
+                            self.test_dir, f"mlx_{dt}_{i}_fs.safetensors"
+                        )
+                        save_dict = {
+                            "test": (
+                                mx.random.normal(shape=shape, dtype=getattr(mx, dt))
+                                if dt in ["float32", "float16", "bfloat16"]
+                                else mx.ones(shape, dtype=getattr(mx, dt))
+                            )
+                        }
+
+                        with open(save_file_mlx, "wb") as f:
+                            mx.save_safetensors(f, save_dict)
+                        with open(save_file_mlx, "rb") as f:
+                            load_dict = mx.load(f)
+
+                        self.assertTrue("test" in load_dict)
+                        self.assertTrue(
+                            mx.array_equal(load_dict["test"], save_dict["test"])
+                        )
+
+    def test_save_and_load_gguf(self):
+        if not os.path.isdir(self.test_dir):
+            os.mkdir(self.test_dir)
+
+        # TODO: Add support for other dtypes (self.dtypes + ["bfloat16"])
+        supported_dtypes = ["float16", "float32", "int8", "int16", "int32"]
+        for dt in supported_dtypes:
+            with self.subTest(dtype=dt):
+                for i, shape in enumerate([(1,), (23,), (1024, 1024), (4, 6, 3, 1, 2)]):
+                    with self.subTest(shape=shape):
+                        save_file_mlx = os.path.join(
+                            self.test_dir, f"mlx_{dt}_{i}_fs.gguf"
+                        )
+                        save_dict = {
+                            "test": (
+                                mx.random.normal(shape=shape, dtype=getattr(mx, dt))
+                                if dt in ["float32", "float16", "bfloat16"]
+                                else mx.ones(shape, dtype=getattr(mx, dt))
+                            )
+                        }
+
+                        mx.save_gguf(save_file_mlx, save_dict)
+                        load_dict = mx.load(save_file_mlx)
+
+                        self.assertTrue("test" in load_dict)
+                        self.assertTrue(
+                            mx.array_equal(load_dict["test"], save_dict["test"])
+                        )
+
+        save_file_mlx = os.path.join(self.test_dir, f"mlx_path_test_fs.gguf")
+        save_dict = {"test": mx.ones(shape)}
+        mx.save_gguf(Path(save_file_mlx), save_dict)
+        load_dict = mx.load(Path(save_file_mlx))
+        self.assertTrue("test" in load_dict)
+        self.assertTrue(mx.array_equal(load_dict["test"], save_dict["test"]))
+
+    def test_load_f8_e4m3(self):
+        if not os.path.isdir(self.test_dir):
+            os.mkdir(self.test_dir)
+
+        expected = [
+            0,
+            mx.nan,
+            mx.nan,
+            -0.875,
+            0.4375,
+            -0.005859,
+            -1.25,
+            -1.25,
+            -1.5,
+            -0.0039,
+        ]
+        expected = mx.array(expected, dtype=mx.bfloat16)
+        contents = b'H\x00\x00\x00\x00\x00\x00\x00{"tensor":{"dtype":"F8_E4M3","shape":[10],"data_offsets":[0,10]}}       \x00\x7f\xff\xb6.\x83\xba\xba\xbc\x82'
+        with tempfile.NamedTemporaryFile(suffix=".safetensors") as f:
+            f.write(contents)
+            f.seek(0)
+            out = mx.load(f)["tensor"]
+        self.assertTrue(mx.allclose(out[0], expected[0], equal_nan=True))
+
+    def test_save_and_load_gguf_metadata_basic(self):
+        if not os.path.isdir(self.test_dir):
+            os.mkdir(self.test_dir)
+
+        save_file_mlx = os.path.join(self.test_dir, f"mlx_gguf_with_metadata.gguf")
+        save_dict = {"test": mx.ones((4, 4), dtype=mx.int32)}
+        metadata = {}
+
+        # Empty works
+        mx.save_gguf(save_file_mlx, save_dict, metadata)
+
+        # Loads without the metadata
+        load_dict = mx.load(save_file_mlx)
+        self.assertTrue("test" in load_dict)
+        self.assertTrue(mx.array_equal(load_dict["test"], save_dict["test"]))
+
+        # Loads empty metadata
+        load_dict, meta_load_dict = mx.load(save_file_mlx, return_metadata=True)
+        self.assertTrue("test" in load_dict)
+        self.assertTrue(mx.array_equal(load_dict["test"], save_dict["test"]))
+        self.assertEqual(len(meta_load_dict), 0)
+
+        # Loads string metadata
+        metadata = {"meta": "data"}
+        mx.save_gguf(save_file_mlx, save_dict, metadata)
+        load_dict, meta_load_dict = mx.load(save_file_mlx, return_metadata=True)
+        self.assertTrue("test" in load_dict)
+        self.assertTrue(mx.array_equal(load_dict["test"], save_dict["test"]))
+        self.assertEqual(len(meta_load_dict), 1)
+        self.assertTrue("meta" in meta_load_dict)
+        self.assertEqual(meta_load_dict["meta"], "data")
+
+    def test_save_and_load_gguf_metadata_arrays(self):
+        if not os.path.isdir(self.test_dir):
+            os.mkdir(self.test_dir)
+
+        save_file_mlx = os.path.join(self.test_dir, f"mlx_gguf_with_metadata.gguf")
+        save_dict = {"test": mx.ones((4, 4), dtype=mx.int32)}
+
+        # Test scalars and one dimensional arrays
+        for t in [
+            mx.uint8,
+            mx.int8,
+            mx.uint16,
+            mx.int16,
+            mx.uint32,
+            mx.int32,
+            mx.uint64,
+            mx.int64,
+            mx.float32,
+        ]:
+            for shape in [(), (2,)]:
+                arr = mx.random.uniform(shape=shape).astype(t)
+                metadata = {"meta": arr}
+                mx.save_gguf(save_file_mlx, save_dict, metadata)
+                _, meta_load_dict = mx.load(save_file_mlx, return_metadata=True)
+                self.assertEqual(len(meta_load_dict), 1)
+                self.assertTrue("meta" in meta_load_dict)
+                self.assertTrue(mx.array_equal(meta_load_dict["meta"], arr))
+                self.assertEqual(meta_load_dict["meta"].dtype, arr.dtype)
+
+        for t in [mx.float16, mx.bfloat16, mx.complex64]:
+            with self.assertRaises(ValueError):
+                arr = mx.array(1, t)
+                metadata = {"meta": arr}
+                mx.save_gguf(save_file_mlx, save_dict, metadata)
+
+    def test_save_and_load_gguf_metadata_mixed(self):
+        if not os.path.isdir(self.test_dir):
+            os.mkdir(self.test_dir)
+
+        save_file_mlx = os.path.join(self.test_dir, f"mlx_gguf_with_metadata.gguf")
+        save_dict = {"test": mx.ones((4, 4), dtype=mx.int32)}
+
+        # Test string and array
+        arr = mx.array(1.5)
+        metadata = {"meta1": arr, "meta2": "data"}
+        mx.save_gguf(save_file_mlx, save_dict, metadata)
+        _, meta_load_dict = mx.load(save_file_mlx, return_metadata=True)
+        self.assertEqual(len(meta_load_dict), 2)
+        self.assertTrue("meta1" in meta_load_dict)
+        self.assertTrue(mx.array_equal(meta_load_dict["meta1"], arr))
+        self.assertEqual(meta_load_dict["meta1"].dtype, arr.dtype)
+        self.assertTrue("meta2" in meta_load_dict)
+        self.assertEqual(meta_load_dict["meta2"], "data")
+
+        # Test list of strings
+        metadata = {"meta": ["data1", "data2", "data345"]}
+        mx.save_gguf(save_file_mlx, save_dict, metadata)
+        _, meta_load_dict = mx.load(save_file_mlx, return_metadata=True)
+        self.assertEqual(len(meta_load_dict), 1)
+        self.assertEqual(meta_load_dict["meta"], metadata["meta"])
+
+        # Test a combination of stuff
+        metadata = {
+            "meta1": ["data1", "data2", "data345"],
+            "meta2": mx.array([1, 2, 3, 4]),
+            "meta3": "data",
+            "meta4": mx.array(1.5),
+        }
+        mx.save_gguf(save_file_mlx, save_dict, metadata)
+        _, meta_load_dict = mx.load(save_file_mlx, return_metadata=True)
+        self.assertEqual(len(meta_load_dict), 4)
+        for k, v in metadata.items():
+            if isinstance(v, mx.array):
+                self.assertTrue(mx.array_equal(meta_load_dict[k], v))
+            else:
+                self.assertEqual(meta_load_dict[k], v)
+
+    def test_save_and_load_fs(self):
+        if not os.path.isdir(self.test_dir):
+            os.mkdir(self.test_dir)
+
+        for dt in self.dtypes:
+            with self.subTest(dtype=dt):
+                for i, shape in enumerate([(1,), (23,), (1024, 1024), (4, 6, 3, 1, 2)]):
+                    with self.subTest(shape=shape):
+                        save_file_mlx = os.path.join(
+                            self.test_dir, f"mlx_{dt}_{i}_fs.npy"
+                        )
+                        save_file_npy = os.path.join(
+                            self.test_dir, f"npy_{dt}_{i}_fs.npy"
+                        )
+
+                        save_arr = np.random.uniform(0.0, 32.0, size=shape)
+                        save_arr_npy = save_arr.astype(getattr(np, dt))
+                        save_arr_mlx = mx.array(save_arr_npy)
+
+                        with open(save_file_mlx, "wb") as f:
+                            mx.save(f, save_arr_mlx)
+
+                        np.save(save_file_npy, save_arr_npy)
+
+                        # Load array saved by mlx as mlx array
+                        with open(save_file_mlx, "rb") as f:
+                            load_arr_mlx_mlx = mx.load(f)
+                        self.assertTrue(mx.array_equal(load_arr_mlx_mlx, save_arr_mlx))
+
+                        # Load array saved by numpy as mlx array
+                        with open(save_file_npy, "rb") as f:
+                            load_arr_npy_mlx = mx.load(f)
+                        self.assertTrue(mx.array_equal(load_arr_npy_mlx, save_arr_mlx))
+
+                        # Load array saved by mlx as numpy array
+                        load_arr_mlx_npy = np.load(save_file_mlx)
+                        self.assertTrue(np.array_equal(load_arr_mlx_npy, save_arr_npy))
+
+    def test_savez_and_loadz(self):
+        if not os.path.isdir(self.test_dir):
+            os.mkdir(self.test_dir)
+
+        for dt in self.dtypes:
+            with self.subTest(dtype=dt):
+                shapes = [(6,), (6, 6), (4, 1, 3, 1, 2)]
+                save_file_mlx_uncomp = os.path.join(
+                    self.test_dir, f"mlx_{dt}_uncomp.npz"
+                )
+                save_file_npy_uncomp = os.path.join(
+                    self.test_dir, f"npy_{dt}_uncomp.npz"
+                )
+                save_file_mlx_comp = os.path.join(self.test_dir, f"mlx_{dt}_comp.npz")
+                save_file_npy_comp = os.path.join(self.test_dir, f"npy_{dt}_comp.npz")
+
+                # Make dictionary of multiple
+                save_arrs_npy = {
+                    f"save_arr_{i}": np.random.uniform(
+                        0.0, 32.0, size=shapes[i]
+                    ).astype(getattr(np, dt))
+                    for i in range(len(shapes))
+                }
+                save_arrs_mlx = {k: mx.array(v) for k, v in save_arrs_npy.items()}
+
+                # Save as npz files
+                np.savez(save_file_npy_uncomp, **save_arrs_npy)
+                mx.savez(save_file_mlx_uncomp, **save_arrs_mlx)
+                np.savez_compressed(save_file_npy_comp, **save_arrs_npy)
+                mx.savez_compressed(save_file_mlx_comp, **save_arrs_mlx)
+
+                for save_file_npy, save_file_mlx in (
+                    (save_file_npy_uncomp, save_file_mlx_uncomp),
+                    (save_file_npy_comp, save_file_mlx_comp),
+                ):
+                    # Load array saved by mlx as mlx array
+                    load_arr_mlx_mlx = mx.load(save_file_mlx)
+                    for k, v in load_arr_mlx_mlx.items():
+                        self.assertTrue(mx.array_equal(save_arrs_mlx[k], v))
+
+                    # Load arrays saved by numpy as mlx arrays
+                    load_arr_npy_mlx = mx.load(save_file_npy)
+                    for k, v in load_arr_npy_mlx.items():
+                        self.assertTrue(mx.array_equal(save_arrs_mlx[k], v))
+
+                    # Load array saved by mlx as numpy array
+                    load_arr_mlx_npy = np.load(save_file_mlx)
+                    for k, v in load_arr_mlx_npy.items():
+                        self.assertTrue(np.array_equal(save_arrs_npy[k], v))
+
+    def test_non_contiguous(self):
+        a = mx.broadcast_to(mx.array([1, 2]), [4, 2])
+
+        save_file = os.path.join(self.test_dir, "a.npy")
+        mx.save(save_file, a)
+        aload = mx.load(save_file)
+        self.assertTrue(mx.array_equal(a, aload))
+
+        save_file = os.path.join(self.test_dir, "a.safetensors")
+        mx.save_safetensors(save_file, {"a": a})
+        aload = mx.load(save_file)["a"]
+        self.assertTrue(mx.array_equal(a, aload))
+
+        save_file = os.path.join(self.test_dir, "a.gguf")
+        mx.save_gguf(save_file, {"a": a})
+        aload = mx.load(save_file)["a"]
+        self.assertTrue(mx.array_equal(a, aload))
+
+        # safetensors and gguf only work with row contiguous
+        # make sure col contiguous is handled properly
+        save_file = os.path.join(self.test_dir, "a.safetensors")
+        a = mx.arange(4).reshape(2, 2).T
+        mx.save_safetensors(save_file, {"a": a})
+        aload = mx.load(save_file)["a"]
+        self.assertTrue(mx.array_equal(a, aload))
+
+        save_file = os.path.join(self.test_dir, "a.gguf")
+        mx.save_gguf(save_file, {"a": a})
+        aload = mx.load(save_file)["a"]
+        self.assertTrue(mx.array_equal(a, aload))
+
+    def test_load_donation(self):
+        x = mx.random.normal((1024,))
+        mx.eval(x)
+        save_file = os.path.join(self.test_dir, "donation.npy")
+        mx.save(save_file, x)
+        mx.synchronize()
+
+        mx.reset_peak_memory()
+        scale = mx.array(2.0)
+        y = mx.load(save_file)
+        mx.eval(y)
+        mx.synchronize()
+        load_only = mx.get_peak_memory()
+        y = mx.load(save_file) * scale
+        mx.eval(y)
+        mx.synchronize()
+        load_with_binary = mx.get_peak_memory()
+
+        self.assertEqual(load_only, load_with_binary)
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_losses.py b/ml-stable-diffusion/mlx/python/tests/test_losses.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb22eec8e1b75061ba48733340abacb519c8121d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_losses.py
@@ -0,0 +1,427 @@
+# Copyright © 2023 Apple Inc.
+
+import unittest
+
+import mlx.core as mx
+import mlx.nn as nn
+import mlx_tests
+import numpy as np
+
+
+class TestLosses(mlx_tests.MLXTestCase):
+    def test_cross_entropy(self):
+        # No weights, no label smoothing
+        logits = mx.array([[0.0, -float("inf")], [-float("inf"), 0.0]])
+        indices = mx.array([0, 1])
+        expected = mx.array([0.0, 0.0])
+        loss = nn.losses.cross_entropy(logits, indices, reduction="none")
+        self.assertTrue(mx.allclose(loss, expected))
+
+        probs = mx.array([[1.0, 0.0], [0.0, 1.0]])
+        loss = nn.losses.cross_entropy(logits, probs, reduction="none")
+        self.assertTrue(mx.isnan(loss).all())  # produce NaNs, like PyTorch
+
+        # With weights, no label smoothing
+        logits = mx.array([[2.0, -1.0], [-1.0, 2.0]])
+        indices = mx.array([0, 1])
+        weights = mx.array([1.0, 2.0])
+        expected = mx.array([0.04858735, 0.0971747])
+        loss = nn.losses.cross_entropy(
+            logits, indices, weights=weights, reduction="none"
+        )
+        self.assertTrue(mx.allclose(loss, expected))
+
+        probs = mx.array([[1.0, 0.0], [0.0, 1.0]])
+        loss = nn.losses.cross_entropy(logits, probs, weights=weights, reduction="none")
+        self.assertTrue(mx.allclose(loss, expected))
+
+        # No weights, with label smoothing
+        logits = mx.array([[2.0, -1.0], [-1.0, 2.0]])
+        indices = mx.array([0, 1])
+        expected = mx.array([0.498587, 0.498587])
+        loss = nn.losses.cross_entropy(
+            logits, indices, label_smoothing=0.3, reduction="none"
+        )
+        self.assertTrue(mx.allclose(loss, expected))
+
+        probs = mx.array([[1.0, 0.0], [0.0, 1.0]])
+        loss = nn.losses.cross_entropy(
+            logits, probs, label_smoothing=0.3, reduction="none"
+        )
+        self.assertTrue(mx.allclose(loss, expected))
+
+        # With weights and label smoothing
+        logits = mx.array([[2.0, -1.0], [-1.0, 2.0]])
+        indices = mx.array([0, 1])
+        weights = mx.array([1.0, 2.0])
+        expected = mx.array([0.49858734, 0.9971747])
+        loss = nn.losses.cross_entropy(
+            logits, indices, weights=weights, label_smoothing=0.3, reduction="none"
+        )
+        self.assertTrue(mx.allclose(loss, expected))
+
+        # Test a different axis
+        logits = mx.random.normal((4, 8))
+        targets = mx.array([1, 2, 3, 0])
+        loss = nn.losses.cross_entropy(
+            logits.T,
+            targets,
+            axis=0,
+        )
+        targets = mx.array([1, 2, 3, 0])
+        expected = nn.losses.cross_entropy(
+            logits,
+            targets,
+            axis=-1,
+        )
+        self.assertTrue(mx.allclose(loss, expected))
+
+    def test_binary_cross_entropy(self):
+        def _test_logits_as_inputs():
+            logits = mx.array([0.105361, 0.223144, 1.20397, 0.916291])
+            targets = mx.array([0, 0, 1, 1])
+
+            # Test with reduction 'none'
+            losses_none = nn.losses.binary_cross_entropy(
+                logits, targets, reduction="none"
+            )
+            expected_none = mx.array([0.747215, 0.810930, 0.262365, 0.336472])
+            self.assertTrue(mx.allclose(losses_none, expected_none))
+
+            # Test with reduction 'mean'
+            losses_mean = nn.losses.binary_cross_entropy(
+                logits, targets, reduction="mean"
+            )
+            expected_mean = mx.mean(expected_none)
+            self.assertTrue(mx.allclose(losses_mean, expected_mean))
+
+            # Test with reduction 'sum'
+            losses_sum = nn.losses.binary_cross_entropy(
+                logits, targets, reduction="sum"
+            )
+            expected_sum = mx.sum(expected_none)
+            self.assertTrue(mx.allclose(losses_sum, expected_sum))
+
+            # With weights, no label smoothing
+            weights = mx.array([1.0, 2.0, 1.0, 2.0])
+            expected = mx.array([0.747215, 1.62186, 0.262365, 0.672944])
+            loss = nn.losses.binary_cross_entropy(
+                logits, targets, weights=weights, reduction="none"
+            )
+            self.assertTrue(mx.allclose(loss, expected))
+
+        def _test_probs_as_inputs():
+            probs = mx.array([0.5, 0.6, 0.7, 0.8])
+            targets = mx.array([0, 0, 1, 1])
+
+            # Test with reduction 'none'
+            losses_none = nn.losses.binary_cross_entropy(
+                probs, targets, with_logits=False, reduction="none"
+            )
+            expected_none = mx.array([0.693147, 0.916291, 0.356675, 0.223144])
+            self.assertTrue(mx.allclose(losses_none, expected_none))
+
+            # Test with reduction 'mean'
+            losses_mean = nn.losses.binary_cross_entropy(
+                probs, targets, with_logits=False, reduction="mean"
+            )
+            expected_mean = mx.mean(expected_none)
+            self.assertTrue(mx.allclose(losses_mean, expected_mean))
+
+            # Test with reduction 'sum'
+            losses_sum = nn.losses.binary_cross_entropy(
+                probs, targets, with_logits=False, reduction="sum"
+            )
+            expected_sum = mx.sum(expected_none)
+            self.assertTrue(mx.allclose(losses_sum, expected_sum))
+
+        def _test_tiny_probs_as_inputs():
+            TINY_PROB = 1e-59
+            probs = mx.array([0, TINY_PROB, 1 - TINY_PROB, 1])
+            targets = mx.array([0, 0, 1, 1])
+
+            losses_none = nn.losses.binary_cross_entropy(
+                probs, targets, with_logits=False, reduction="none"
+            )
+            expected_none = mx.array([0.0, TINY_PROB, TINY_PROB, 0.0])
+            self.assertTrue(mx.allclose(losses_none, expected_none))
+
+            # Test with reduction 'mean'
+            losses_mean = nn.losses.binary_cross_entropy(
+                probs, targets, with_logits=False, reduction="mean"
+            )
+            expected_mean = mx.mean(expected_none)
+            self.assertTrue(mx.allclose(losses_mean, expected_mean))
+
+            # Test with reduction 'sum'
+            losses_sum = nn.losses.binary_cross_entropy(
+                probs, targets, with_logits=False, reduction="sum"
+            )
+            expected_sum = mx.sum(expected_none)
+            self.assertTrue(mx.allclose(losses_sum, expected_sum))
+
+        _test_logits_as_inputs()
+        _test_probs_as_inputs()
+        _test_tiny_probs_as_inputs()
+
+    def test_l1_loss(self):
+        predictions = mx.array([0.5, 0.2, 0.9, 0.0])
+        targets = mx.array([0.5, 0.2, 0.9, 0.0])
+
+        # Expected result
+        expected_none = mx.array([0, 0, 0, 0]).astype(mx.float32)
+        expected_sum = mx.sum(expected_none)
+        expected_mean = mx.mean(expected_none)
+
+        losses = nn.losses.l1_loss(predictions, targets, reduction="none")
+        self.assertTrue(
+            mx.array_equal(losses, expected_none),
+            "Test failed for l1_loss --reduction='none'",
+        )
+
+        losses = nn.losses.l1_loss(predictions, targets, reduction="sum")
+        self.assertTrue(mx.array_equal(losses, expected_sum))
+
+        losses = nn.losses.l1_loss(predictions, targets, reduction="mean")
+        self.assertTrue(mx.array_equal(losses, expected_mean))
+
+    def test_mse_loss(self):
+        predictions = mx.array([0.5, 0.2, 0.9, 0.0])
+        targets = mx.array([0.7, 0.1, 0.8, 0.2])
+
+        expected_none = mx.array([0.04, 0.01, 0.01, 0.04])
+        expected_mean = mx.mean(expected_none)
+        expected_sum = mx.sum(expected_none)
+
+        # Test with reduction 'none'
+        losses_none = nn.losses.mse_loss(predictions, targets, reduction="none")
+        self.assertTrue(
+            np.allclose(losses_none, expected_none, 1e-5),
+            "Test case failed for mse_loss --reduction='none'",
+        )
+
+        # Test with reduction 'mean'
+        losses_mean = nn.losses.mse_loss(predictions, targets, reduction="mean")
+        self.assertEqual(
+            losses_mean,
+            expected_mean,
+            "Test case failed for mse_loss --reduction='mean'",
+        )
+
+        # Test with reduction 'sum'
+        losses_sum = nn.losses.mse_loss(predictions, targets, reduction="sum")
+        self.assertEqual(
+            losses_sum, expected_sum, "Test case failed for mse_loss --reduction='sum'"
+        )
+
+    def test_smooth_l1_loss(self):
+        predictions = mx.array([1.5, 2.5, 0.5, 3.5])
+        targets = mx.array([1.0, 2.0, 0.5, 2.5])
+        beta = 1.0
+
+        # Expected results
+        expected_none = mx.array([0.125, 0.125, 0.0, 0.5])
+        expected_sum = mx.sum(expected_none)
+        expected_mean = mx.mean(expected_none)
+
+        # Test with reduction 'none'
+        loss_none = nn.losses.smooth_l1_loss(
+            predictions, targets, beta, reduction="none"
+        )
+        self.assertTrue(
+            mx.array_equal(loss_none, expected_none),
+            "Test case failed for smooth_l1_loss --reduction='none'",
+        )
+
+        # Test with reduction 'sum'
+        loss_sum = nn.losses.smooth_l1_loss(predictions, targets, beta, reduction="sum")
+        self.assertEqual(
+            loss_sum,
+            expected_sum,
+            "Test case failed for smooth_l1_loss --reduction='sum'",
+        )
+
+        # Test with reduction 'mean'
+        loss_mean = nn.losses.smooth_l1_loss(
+            predictions, targets, beta, reduction="mean"
+        )
+        self.assertEqual(
+            loss_mean,
+            expected_mean,
+            "Test case failed for smooth_l1_loss --reduction='mean'",
+        )
+
+    def test_nll_loss(self):
+        logits = mx.array([[0.0, -float("inf")], [-float("inf"), 0.0]])
+        targets = mx.array([0, 1])
+
+        # Test with reduction 'none'
+        losses_none = nn.losses.nll_loss(logits, targets, reduction="none")
+        expected_none = mx.array([0.0, 0.0])
+        self.assertTrue(mx.array_equal(losses_none, expected_none))
+
+        # Test with reduction 'mean'
+        losses_mean = nn.losses.nll_loss(logits, targets, reduction="mean")
+        expected_mean = mx.mean(expected_none)
+        self.assertEqual(losses_mean, expected_mean)
+
+        # Test with reduction 'sum'
+        losses_sum = nn.losses.nll_loss(logits, targets, reduction="sum")
+        expected_sum = mx.sum(expected_none)
+        self.assertEqual(losses_sum, expected_sum)
+
+    def test_gaussian_nll_loss(self):
+        inputs = mx.array([[0.1, 0.2], [0.3, 0.4]])
+        targets = mx.array([[0.2, 0.1], [0.1, 0.2]])
+        vars = mx.array([[0.1, 0.2], [0.3, 0.4]])
+
+        # Test with reduction 'none', full=False
+        losses_none = nn.losses.gaussian_nll_loss(
+            inputs, targets, vars, reduction="none"
+        )
+        expected_none = mx.array([[-1.101293, -0.779719], [-0.535320, -0.408145]])
+        self.assertTrue(mx.allclose(losses_none, expected_none))
+
+        # Test with reduction 'mean', full=False
+        losses_mean = nn.losses.gaussian_nll_loss(
+            inputs, targets, vars, reduction="mean"
+        )
+        expected_mean = mx.mean(expected_none)
+        self.assertTrue(mx.allclose(losses_mean, expected_mean))
+
+        # Test with reduction 'sum', full=False
+        losses_sum = nn.losses.gaussian_nll_loss(inputs, targets, vars, reduction="sum")
+        expected_sum = mx.sum(expected_none)
+        self.assertTrue(mx.allclose(losses_sum, expected_sum))
+
+        # Test with reduction='none', full=True
+        losses_none_full = nn.losses.gaussian_nll_loss(
+            inputs, targets, vars, full=True, reduction="none"
+        )
+        expected_none_full = mx.array([[-0.182354, 0.139220], [0.383619, 0.510793]])
+        self.assertTrue(mx.allclose(losses_none_full, expected_none_full))
+
+        # Test with reduction='mean', full=True
+        losses_mean_full = nn.losses.gaussian_nll_loss(
+            inputs, targets, vars, full=True, reduction="mean"
+        )
+        expected_mean_full = mx.mean(expected_none_full)
+        self.assertTrue(mx.allclose(losses_mean_full, expected_mean_full))
+
+        # Test with reduction='sum', full=True
+        losses_sum_full = nn.losses.gaussian_nll_loss(
+            inputs, targets, vars, full=True, reduction="sum"
+        )
+        expected_sum_full = mx.sum(expected_none_full)
+        self.assertTrue(mx.allclose(losses_sum_full, expected_sum_full))
+
+    def test_kl_div_loss(self):
+        p_logits = mx.log(mx.array([[0.5, 0.5], [0.8, 0.2]]))
+        q_logits = mx.log(mx.array([[0.5, 0.5], [0.2, 0.8]]))
+
+        # Test with reduction 'none'
+        losses_none = nn.losses.kl_div_loss(p_logits, q_logits, reduction="none")
+        expected_none = mx.array([0.0, 0.831777])
+        self.assertTrue(mx.allclose(losses_none, expected_none))
+
+        # Test with reduction 'mean'
+        losses_mean = nn.losses.kl_div_loss(p_logits, q_logits, reduction="mean")
+        expected_mean = mx.mean(expected_none)
+        self.assertTrue(mx.allclose(losses_mean, expected_mean))
+
+        # Test with reduction 'sum'
+        losses_sum = nn.losses.kl_div_loss(p_logits, q_logits, reduction="sum")
+        expected_sum = mx.sum(expected_none)
+        self.assertTrue(mx.allclose(losses_sum, expected_sum))
+
+    def test_triplet_loss(self):
+        anchors = mx.array([[1, 2, 3], [1, 2, 3]])
+        positives = mx.array([[4, 5, 6], [0, -1, 2]])
+        negatives = mx.array([[7, 8, 9], [3, 2, 3]])
+
+        # Test with reduction 'none'
+        losses_none = nn.losses.triplet_loss(
+            anchors, positives, negatives, reduction="none"
+        )
+        expected_none = mx.array([0, 2.31662])
+        self.assertTrue(mx.allclose(losses_none, expected_none))
+
+        # Test with reduction 'mean'
+        losses_mean = nn.losses.triplet_loss(
+            anchors, positives, negatives, reduction="mean"
+        )
+        expected_mean = mx.mean(expected_none)
+        self.assertTrue(mx.allclose(losses_mean, expected_mean))
+
+        # Test with reduction 'sum'
+        losses_sum = nn.losses.triplet_loss(
+            anchors, positives, negatives, reduction="sum"
+        )
+        expected_sum = mx.sum(expected_none)
+        self.assertTrue(mx.allclose(losses_sum, expected_sum))
+
+    def test_hinge_loss(self):
+        inputs = mx.ones((2, 4))
+        targets = mx.zeros((2, 4))
+        loss = nn.losses.hinge_loss(inputs, targets, reduction="mean")
+        self.assertEqual(loss, 1.0)
+
+    def test_huber_loss(self):
+        inputs = mx.ones((2, 4))
+        targets = mx.zeros((2, 4))
+        loss = nn.losses.huber_loss(inputs, targets, reduction="mean")
+        self.assertEqual(loss, 0.5)
+
+    def test_log_cosh_loss(self):
+        inputs = mx.ones((2, 4))
+        targets = mx.zeros((2, 4))
+        loss = nn.losses.log_cosh_loss(inputs, targets, reduction="mean")
+        self.assertAlmostEqual(loss.item(), 0.433781, places=6)
+
+    def test_cosine_similarity_loss(self):
+        embeddings1 = mx.array([[0.5, 0.5, 0.2, 0.9], [0.1, 0.3, 0.5, 0.5]])
+        embeddings2 = mx.array([[0.6, 0.4, 0.3, 0.8], [0.2, 0.5, 0.6, 0.4]])
+
+        # Test with reduction 'none'
+        losses_none = nn.losses.cosine_similarity_loss(
+            embeddings1, embeddings2, reduction="none"
+        )
+        expected_none = mx.array([0.985344, 0.961074])
+        self.assertTrue(mx.allclose(losses_none, expected_none))
+
+        # Test with reduction 'mean'
+        losses_mean = nn.losses.cosine_similarity_loss(
+            embeddings1, embeddings2, reduction="mean"
+        )
+        expected_mean = mx.mean(expected_none)
+        self.assertTrue(mx.allclose(losses_mean, expected_mean))
+
+        # Test with reduction 'sum'
+        losses_sum = nn.losses.cosine_similarity_loss(
+            embeddings1, embeddings2, reduction="sum"
+        )
+        expected_sum = mx.sum(expected_none)
+        self.assertTrue(mx.allclose(losses_sum, expected_sum))
+
+    def test_margin_ranking_loss(self):
+        inputs1 = mx.array([-0.573409, -0.765166, -0.0638])
+        inputs2 = mx.array([0.75596, 0.225763, 0.256995])
+        targets = mx.array([1, 1, -1])
+
+        # Test with no margin
+        losses = nn.losses.margin_ranking_loss(
+            inputs1, inputs2, targets, reduction="none"
+        )
+        expected = mx.array([1.329369, 0.990929, 0.0])
+        self.assertTrue(mx.allclose(losses, expected))
+
+        # Test with margin
+        losses = nn.losses.margin_ranking_loss(
+            inputs1, inputs2, targets, margin=0.5, reduction="none"
+        )
+        expected = mx.array([1.829369, 1.490929, 0.179205])
+        self.assertTrue(mx.allclose(losses, expected))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_memory.py b/ml-stable-diffusion/mlx/python/tests/test_memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..08da7ccc6f6728c0b0a3352571e3e8857a02f4c5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_memory.py
@@ -0,0 +1,63 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import unittest
+
+import mlx.core as mx
+import mlx_tests
+
+
+class TestMemory(mlx_tests.MLXTestCase):
+    def test_memory_info(self):
+        old_limit = mx.set_cache_limit(0)
+
+        a = mx.zeros((4096,))
+        mx.eval(a)
+        del a
+        self.assertEqual(mx.get_cache_memory(), 0)
+        self.assertEqual(mx.set_cache_limit(old_limit), 0)
+        self.assertEqual(mx.set_cache_limit(old_limit), old_limit)
+
+        old_limit = mx.set_memory_limit(10)
+        self.assertTrue(mx.set_memory_limit(old_limit), 10)
+        self.assertTrue(mx.set_memory_limit(old_limit), old_limit)
+
+        # Query active and peak memory
+        a = mx.zeros((4096,))
+        mx.eval(a)
+        mx.synchronize()
+        active_mem = mx.get_active_memory()
+        self.assertTrue(active_mem >= 4096 * 4)
+
+        b = mx.zeros((4096,))
+        mx.eval(b)
+        del b
+        mx.synchronize()
+
+        new_active_mem = mx.get_active_memory()
+        self.assertEqual(new_active_mem, active_mem)
+        peak_mem = mx.get_peak_memory()
+        self.assertTrue(peak_mem >= 4096 * 8)
+
+        if mx.metal.is_available():
+            cache_mem = mx.get_cache_memory()
+            self.assertTrue(cache_mem >= 4096 * 4)
+
+        mx.clear_cache()
+        self.assertEqual(mx.get_cache_memory(), 0)
+
+        mx.reset_peak_memory()
+        self.assertEqual(mx.get_peak_memory(), 0)
+
+    @unittest.skipIf(not mx.metal.is_available(), "Metal is not available")
+    def test_wired_memory(self):
+        old_limit = mx.set_wired_limit(1000)
+        old_limit = mx.set_wired_limit(0)
+        self.assertEqual(old_limit, 1000)
+
+        max_size = mx.metal.device_info()["max_recommended_working_set_size"]
+        with self.assertRaises(ValueError):
+            mx.set_wired_limit(max_size + 10)
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_nn.py b/ml-stable-diffusion/mlx/python/tests/test_nn.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ded372278d7c072c9217dc45426a691a3e4c939
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_nn.py
@@ -0,0 +1,1953 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import os
+import tempfile
+import unittest
+
+import mlx.core as mx
+import mlx.nn as nn
+import mlx_tests
+import numpy as np
+from mlx.utils import tree_flatten, tree_map, tree_reduce
+
+
+class TestBase(mlx_tests.MLXTestCase):
+    def test_module_utilities(self):
+        m = nn.Sequential(
+            nn.Sequential(nn.Linear(2, 10), nn.relu),
+            nn.Sequential(nn.Linear(10, 10), nn.ReLU()),
+            nn.Linear(10, 1),
+            mx.sigmoid,
+        )
+
+        children = m.children()
+        self.assertTrue(isinstance(children, dict))
+        self.assertEqual(len(children), 1)
+        self.assertTrue(isinstance(children["layers"], list))
+        self.assertEqual(len(children["layers"]), 4)
+        self.assertEqual(children["layers"][3], {})
+        flat_children = tree_flatten(children, is_leaf=nn.Module.is_module)
+        self.assertEqual(len(flat_children), 3)
+
+        leaves = tree_flatten(m.leaf_modules(), is_leaf=nn.Module.is_module)
+        self.assertEqual(len(leaves), 4)
+        self.assertEqual(leaves[0][0], "layers.0.layers.0")
+        self.assertEqual(leaves[1][0], "layers.1.layers.0")
+        self.assertEqual(leaves[2][0], "layers.1.layers.1")
+        self.assertEqual(leaves[3][0], "layers.2")
+        self.assertTrue(leaves[0][1] is m.layers[0].layers[0])
+        self.assertTrue(leaves[1][1] is m.layers[1].layers[0])
+        self.assertTrue(leaves[2][1] is m.layers[1].layers[1])
+        self.assertTrue(leaves[3][1] is m.layers[2])
+
+        m.eval()
+
+        def assert_not_training(k, m):
+            self.assertFalse(m.training)
+
+        m.apply_to_modules(assert_not_training)
+
+        m.train()
+
+        def assert_training(k, m):
+            self.assertTrue(m.training)
+
+        m.apply_to_modules(assert_training)
+
+    def test_module_attributes(self):
+        class Model(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.val = None
+                self.initialize()
+
+            def initialize(self):
+                self.val = mx.array(1.0)
+
+        model = Model()
+        self.assertTrue(mx.array_equal(model.val, mx.array(1.0)))
+
+        model.val = None
+        self.assertEqual(model.val, None)
+
+        model.val = mx.array([3])
+        self.assertEqual(model.val.item(), 3)
+
+    def test_model_with_dict(self):
+        class DictModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.weights = {"w1": mx.zeros((2, 2)), "w2": mx.ones((2, 2))}
+
+        model = DictModule()
+        params = tree_flatten(model.parameters(), destination={})
+        self.assertEqual(len(params), 2)
+        self.assertTrue(mx.array_equal(params["weights.w1"], mx.zeros((2, 2))))
+        self.assertTrue(mx.array_equal(params["weights.w2"], mx.ones((2, 2))))
+
+    def test_save_npz_weights(self):
+        def make_model():
+            return nn.Sequential(nn.Linear(2, 2), nn.ReLU(), nn.Linear(2, 2))
+
+        m = make_model()
+        tdir = tempfile.TemporaryDirectory()
+        npz_file = os.path.join(tdir.name, "model.npz")
+        m.save_weights(npz_file)
+        m_load = make_model()
+        m_load.load_weights(npz_file)
+
+        # Eval before cleanup so model file is unlocked.
+        mx.eval(m_load.state)
+        tdir.cleanup()
+
+        eq_tree = tree_map(mx.array_equal, m.parameters(), m_load.parameters())
+        self.assertTrue(all(tree_flatten(eq_tree)))
+
+    def test_save_safetensors_weights(self):
+        def make_model():
+            return nn.Sequential(nn.Linear(2, 2), nn.ReLU(), nn.Linear(2, 2), nn.ReLU())
+
+        m = make_model()
+        tdir = tempfile.TemporaryDirectory()
+        safetensors_file = os.path.join(tdir.name, "model.safetensors")
+        m.save_weights(safetensors_file)
+        m_load = make_model()
+        m_load.load_weights(safetensors_file)
+
+        # Eval before cleanup so model file is unlocked.
+        mx.eval(m_load.state)
+        tdir.cleanup()
+
+        eq_tree = tree_map(mx.array_equal, m.parameters(), m_load.parameters())
+        self.assertTrue(all(tree_flatten(eq_tree)))
+
+    def test_load_from_weights(self):
+        m = nn.Linear(2, 2)
+
+        # Too few weights
+        weights = [("weight", mx.ones((2, 2)))]
+        with self.assertRaises(ValueError):
+            m.load_weights(weights)
+
+        m.load_weights(weights, strict=False)
+        self.assertTrue(mx.array_equal(m.weight, weights[0][1]))
+
+        # Wrong name
+        with self.assertRaises(ValueError):
+            m.load_weights([("weihgt", mx.ones((2, 2)))])
+
+        # Ok
+        m.load_weights([("weihgt", mx.ones((2, 2)))], strict=False)
+
+        # Too many weights
+        with self.assertRaises(ValueError):
+            m.load_weights(
+                [
+                    ("weight", mx.ones((2, 2))),
+                    ("bias", mx.ones((2,))),
+                    ("bias2", mx.ones((2,))),
+                ]
+            )
+
+        # Wrong shape
+        with self.assertRaises(ValueError):
+            m.load_weights(
+                [
+                    ("weight", mx.ones((2, 2))),
+                    ("bias", mx.ones((2, 1))),
+                ]
+            )
+
+        # Wrong type
+        with self.assertRaises(ValueError):
+            m.load_weights(
+                [
+                    ("weight", mx.ones((2, 2))),
+                    ("bias", 3),
+                ]
+            )
+
+        # Empty weights is ok if strict is false
+        m.load_weights([], strict=False)
+
+    def test_module_state(self):
+        m = nn.Linear(10, 1)
+        m.state["hello"] = "world"
+        self.assertEqual(m.state["hello"], "world")
+
+    def test_chaining(self):
+        m = nn.Sequential(nn.Linear(2, 2), nn.ReLU(), nn.Linear(2, 1))
+        pre_freeze_num_params = len(m.parameters())
+        m.freeze().unfreeze()
+        self.assertEqual(len(m.parameters()), pre_freeze_num_params)
+        params_dict = m.parameters()
+
+        self.assertFalse(m.update(params_dict).eval()._training)
+        self.assertTrue(m.train()._training)
+
+    def test_quantize(self):
+        m = nn.Sequential(nn.Embedding(5, 256), nn.ReLU(), nn.Linear(256, 256))
+        nn.quantize(m)
+        self.assertTrue(isinstance(m.layers[0], nn.QuantizedEmbedding))
+        self.assertTrue(isinstance(m.layers[1], nn.ReLU))
+        self.assertTrue(isinstance(m.layers[2], nn.QuantizedLinear))
+
+        m = nn.Sequential(nn.Embedding(5, 256), nn.ReLU(), nn.Linear(256, 256))
+        nn.quantize(m, class_predicate=lambda _, m: isinstance(m, nn.Linear))
+        self.assertTrue(isinstance(m.layers[0], nn.Embedding))
+        self.assertTrue(isinstance(m.layers[1], nn.ReLU))
+        self.assertTrue(isinstance(m.layers[2], nn.QuantizedLinear))
+
+        nn.quantize(m, group_size=32, mode="mxfp4")
+        self.assertTrue(isinstance(m.layers[0], nn.QuantizedEmbedding))
+        self.assertTrue(isinstance(m.layers[1], nn.ReLU))
+        self.assertTrue(isinstance(m.layers[2], nn.QuantizedLinear))
+        self.assertTrue(isinstance(m.layers[2].scales, mx.array))
+
+    def test_quantize_freeze(self):
+        lin = nn.Linear(512, 512)
+        qlin = lin.to_quantized()
+        qlin.unfreeze(keys=["scales"])
+        size = tree_reduce(lambda acc, p: acc + p.size, qlin.trainable_parameters(), 0)
+        self.assertTrue(size > 0)
+
+    def test_grad_of_module(self):
+        class Model(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.m1 = nn.Linear(3, 3)
+
+        model = Model()
+
+        def loss_fn(model):
+            return model.m1(x).sum()
+
+        x = mx.zeros((3,))
+        mx.grad(loss_fn)(model)
+
+    def test_update(self):
+        m = nn.Sequential(nn.Linear(3, 3), nn.Linear(3, 3))
+
+        # Updating non-existent parameters
+        with self.assertRaises(ValueError):
+            updates = {"layers": [{"value": 0}]}
+            m.update(updates)
+
+        with self.assertRaises(ValueError):
+            updates = {"layers": ["hello"]}
+            m.update(updates)
+
+        # Wronge type
+        with self.assertRaises(ValueError):
+            updates = {"layers": [{"weight": "hi"}]}
+            m.update(updates)
+
+    def test_update_modules(self):
+        m = nn.Sequential(nn.Linear(3, 3), nn.Linear(3, 3))
+
+        # Updating non-existent modules should not be allowed by default
+        with self.assertRaises(ValueError):
+            m = m.update_modules({"values": [0, 1]})
+
+        # Update wrong types
+        with self.assertRaises(ValueError):
+            m = m.update_modules({"layers": [0, 1]})
+
+        class MyModule(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.test = mx.array(1.0)
+                self.list = [mx.array(1.0), mx.array(2.0)]
+
+        m = MyModule()
+        with self.assertRaises(ValueError):
+            m = m.update_modules({"test": "hi"})
+        with self.assertRaises(ValueError):
+            m = m.update_modules({"list": ["hi"]})
+
+        # Allow updating a strict subset
+        m = nn.Sequential(nn.Linear(3, 3), nn.Linear(3, 3))
+        m.update_modules({"layers": [{}, nn.Linear(3, 4)]})
+        self.assertEqual(m.layers[1].weight.shape, (4, 3))
+
+        # Using leaf_modules in the update should always work
+        class MyModel(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.stuff = [nn.Linear(2, 2), 0, nn.Linear(2, 2)]
+                self.more_stuff = {"hi": nn.Linear(2, 2), "bye": 0}
+
+        m = MyModel()
+        m.update_modules(m.leaf_modules())
+
+    def test_parameter_deletion(self):
+        m = nn.Linear(32, 32)
+        del m.weight
+        self.assertFalse(hasattr(m, "weight"))
+
+    def test_circular_leaks(self):
+        y = mx.random.uniform(1)
+        mx.eval(y)
+
+        def make_and_update():
+            model = nn.Linear(1024, 512)
+            mx.eval(model.parameters())
+            leaves = {}
+            model.update_modules(leaves)
+
+        mx.synchronize()
+        pre = mx.get_active_memory()
+        make_and_update()
+        mx.synchronize()
+        post = mx.get_active_memory()
+        self.assertEqual(pre, post)
+
+
+class TestLayers(mlx_tests.MLXTestCase):
+    def test_identity(self):
+        inputs = mx.zeros((10, 4))
+        layer = nn.Identity()
+        outputs = layer(inputs)
+        self.assertEqual(inputs.shape, outputs.shape)
+
+    def test_linear(self):
+        inputs = mx.zeros((10, 4))
+        layer = nn.Linear(input_dims=4, output_dims=8)
+        outputs = layer(inputs)
+        self.assertEqual(outputs.shape, (10, 8))
+
+    def test_bilinear(self):
+        inputs1 = mx.zeros((10, 2))
+        inputs2 = mx.zeros((10, 4))
+        layer = nn.Bilinear(input1_dims=2, input2_dims=4, output_dims=6)
+        outputs = layer(inputs1, inputs2)
+        self.assertEqual(outputs.shape, (10, 6))
+
+    def test_group_norm(self):
+        x = mx.arange(100, dtype=mx.float32)
+        x = x.reshape(1, 10, 10, 1)
+        x = mx.broadcast_to(x, (2, 10, 10, 4))
+        x = mx.concatenate([x, 0.5 * x], axis=-1)
+
+        # Group norm in groups last mode
+        g = nn.GroupNorm(2, 8)
+        y = g(x)
+        means = y.reshape(2, -1, 2).mean(axis=1)
+        var = y.reshape(2, -1, 2).var(axis=1)
+        self.assertTrue(np.allclose(means, np.zeros_like(means), atol=1e-6))
+        self.assertTrue(np.allclose(var, np.ones_like(var), atol=1e-6))
+        g.weight = g.weight * 2
+        g.bias = g.bias + 3
+        y = g(x)
+        means = y.reshape(2, -1, 2).mean(axis=1)
+        var = y.reshape(2, -1, 2).var(axis=1)
+        self.assertTrue(np.allclose(means, 3 * np.ones_like(means), atol=1e-6))
+        self.assertTrue(np.allclose(var, 4 * np.ones_like(var), atol=1e-6))
+
+        # Group norm in groups first mode
+        g = nn.GroupNorm(2, 8, pytorch_compatible=True)
+        y = g(x)
+        means = y.reshape(2, -1, 2, 4).mean(axis=(1, -1))
+        var = y.reshape(2, -1, 2, 4).var(axis=(1, -1))
+        self.assertTrue(np.allclose(means, np.zeros_like(means), atol=1e-6))
+        self.assertTrue(np.allclose(var, np.ones_like(var), atol=1e-6))
+        g.weight = g.weight * 2
+        g.bias = g.bias + 3
+        y = g(x)
+        means = y.reshape(2, -1, 2, 4).mean(axis=(1, -1))
+        var = y.reshape(2, -1, 2, 4).var(axis=(1, -1))
+        self.assertTrue(np.allclose(means, 3 * np.ones_like(means), atol=1e-6))
+        self.assertTrue(np.allclose(var, 4 * np.ones_like(var), atol=1e-6))
+
+    def test_instance_norm(self):
+        # Test InstanceNorm1d
+        x = mx.array(
+            [
+                [
+                    [-0.0119524, 1.1263, 2.02223],
+                    [-0.500331, 0.517899, -1.21143],
+                    [1.12958, -0.21413, -2.48738],
+                    [1.39955, 0.891329, 1.63289],
+                ],
+                [
+                    [0.241417, -0.619157, -0.77484],
+                    [-1.42512, 0.970817, -1.31352],
+                    [2.739, -1.2506, 1.56844],
+                    [-1.23175, 0.32756, 1.13969],
+                ],
+            ]
+        )
+        inorm = nn.InstanceNorm(dims=3)
+        y = inorm(x)
+        expected_y = [
+            [
+                [-0.657082, 1.07593, 1.0712],
+                [-1.27879, -0.123074, -0.632505],
+                [0.796101, -1.56572, -1.30476],
+                [1.13978, 0.612862, 0.866067],
+            ],
+            [
+                [0.0964426, -0.557906, -0.759885],
+                [-0.904772, 1.30444, -1.20013],
+                [1.59693, -1.29752, 1.15521],
+                [-0.7886, 0.550987, 0.804807],
+            ],
+        ]
+        self.assertTrue(x.shape == y.shape)
+        self.assertTrue(np.allclose(y, expected_y, atol=1e-5))
+        # Test InstanceNorm2d
+        x = mx.array(
+            [
+                [
+                    [
+                        [-0.458824, 0.483254, -0.58611],
+                        [-0.447996, -0.176577, -0.622545],
+                        [0.0486988, -0.0611224, 1.8845],
+                    ],
+                    [
+                        [1.13049, 0.345315, -0.926389],
+                        [0.301795, 0.99207, -0.184927],
+                        [-2.23876, -0.758631, -1.12639],
+                    ],
+                    [
+                        [0.0986325, -1.82973, -0.241765],
+                        [-1.25257, 0.154442, -0.556204],
+                        [-0.329399, -0.319107, 0.830584],
+                    ],
+                ],
+                [
+                    [
+                        [1.04407, 0.073752, 0.407081],
+                        [0.0800776, 1.2513, 1.20627],
+                        [0.782321, -0.444367, 0.563132],
+                    ],
+                    [
+                        [0.671423, -1.21689, -1.88979],
+                        [-0.110299, -1.42248, 1.17838],
+                        [0.159905, 0.516452, -0.539121],
+                    ],
+                    [
+                        [0.810252, 1.50456, 1.08659],
+                        [0.182597, 0.0576239, 0.973883],
+                        [-0.0621687, 0.184253, 0.784216],
+                    ],
+                ],
+            ]
+        )
+        inorm = nn.InstanceNorm(dims=3)
+        y = inorm(x)
+        expected_y = [
+            [
+                [
+                    [-0.120422, 0.801503, -0.463983],
+                    [-0.108465, -0.0608611, -0.504602],
+                    [0.440008, 0.090032, 2.29032],
+                ],
+                [
+                    [1.63457, 0.621224, -0.843335],
+                    [0.719488, 1.4665, -0.0167344],
+                    [-2.08591, -0.821575, -1.0663],
+                ],
+                [
+                    [0.495147, -2.22145, -0.0800989],
+                    [-0.996913, 0.371763, -0.430643],
+                    [0.022495, -0.24714, 1.11538],
+                ],
+            ],
+            [
+                [
+                    [1.5975, 0.0190292, -0.0123306],
+                    [-0.776381, 1.28291, 0.817237],
+                    [0.952927, -0.537076, 0.149652],
+                ],
+                [
+                    [0.679836, -1.36624, -2.39651],
+                    [-1.24519, -1.5869, 0.788287],
+                    [-0.579802, 0.494186, -0.994499],
+                ],
+                [
+                    [1.02171, 1.55474, 0.693008],
+                    [-0.523922, 0.00171862, 0.576016],
+                    [-1.12667, 0.137632, 0.37914],
+                ],
+            ],
+        ]
+        self.assertTrue(x.shape == y.shape)
+        self.assertTrue(np.allclose(y, expected_y, atol=1e-5))
+        # # Test InstanceNorm3d
+        x = mx.array(
+            [
+                [
+                    [
+                        [[0.777621, 0.528145, -1.56133], [-2.1722, 0.128192, 0.153862]],
+                        [
+                            [-1.41317, 0.476288, -1.20411],
+                            [0.284446, -0.649858, 0.152112],
+                        ],
+                    ],
+                    [
+                        [[0.11, -0.12431, 1.18768], [-0.837743, 1.93502, 0.00236324]],
+                        [
+                            [-2.40205, -1.25873, -2.04243],
+                            [0.336682, -0.261986, 1.54289],
+                        ],
+                    ],
+                    [
+                        [
+                            [0.789185, -1.63747, 0.67917],
+                            [-1.42998, -1.73247, -0.402572],
+                        ],
+                        [
+                            [-0.459489, -2.15559, -0.249959],
+                            [0.0298199, 0.10275, -0.821897],
+                        ],
+                    ],
+                ],
+                [
+                    [
+                        [
+                            [-2.12354, 0.643973, 0.72391],
+                            [0.317797, -0.682916, 0.016364],
+                        ],
+                        [
+                            [-0.146628, -0.987925, 0.573199],
+                            [0.0329215, 1.54086, 0.213092],
+                        ],
+                    ],
+                    [
+                        [
+                            [-1.55784, 0.71179, -0.0678402],
+                            [2.41031, -0.290786, 0.00449439],
+                        ],
+                        [
+                            [0.226341, 0.057712, -1.58342],
+                            [0.265387, -0.742304, 1.28133],
+                        ],
+                    ],
+                    [
+                        [
+                            [0.990317, -0.399875, -0.357647],
+                            [0.475161, -1.10479, -1.07389],
+                        ],
+                        [
+                            [-1.37804, 1.40097, 0.141618],
+                            [-0.501041, 0.0723374, -0.386141],
+                        ],
+                    ],
+                ],
+            ]
+        )
+        inorm = nn.InstanceNorm(dims=3)
+        y = inorm(x)
+        expected_y = [
+            [
+                [
+                    [[1.23593, 0.821849, -1.30944], [-1.54739, 0.462867, 0.357126]],
+                    [[-0.831204, 0.775304, -0.962338], [0.770588, -0.23548, 0.355425]],
+                ],
+                [
+                    [[0.605988, 0.236231, 1.36163], [-0.288258, 2.0846, 0.209922]],
+                    [[-1.76427, -0.78198, -1.77689], [0.819875, 0.112659, 1.70677]],
+                ],
+                [
+                    [[1.24684, -1.12192, 0.867539], [-0.847068, -1.20719, -0.183531]],
+                    [
+                        [0.0686449, -1.58697, -0.0352458],
+                        [0.530334, 0.440032, -0.590967],
+                    ],
+                ],
+            ],
+            [
+                [
+                    [[-1.75315, 0.733967, 1.04349], [0.343736, -0.822472, 0.080661]],
+                    [[-0.0551618, -1.18025, 0.838402], [0.0990544, 1.78602, 0.348368]],
+                ],
+                [
+                    [[-1.26726, 0.813517, -0.033924], [2.14101, -0.362504, 0.0645089]],
+                    [[0.265184, 0.0462839, -2.09632], [0.298721, -0.892134, 1.80203]],
+                ],
+                [
+                    [[0.921369, -0.490465, -0.428293], [0.478897, -1.31732, -1.40296]],
+                    [[-1.11283, 1.62192, 0.251107], [-0.35957, 0.0634394, -0.467067]],
+                ],
+            ],
+        ]
+        self.assertTrue(x.shape == y.shape)
+        self.assertTrue(np.allclose(y, expected_y, atol=1e-5))
+        # Test repr
+        self.assertTrue(str(inorm) == "InstanceNorm(3, eps=1e-05, affine=False)")
+
+    def test_batch_norm(self):
+        mx.random.seed(42)
+        x = mx.random.normal((5, 4), dtype=mx.float32)
+
+        # Batch norm
+        bn = nn.BatchNorm(num_features=4, affine=True)
+        self.assertTrue(mx.allclose(bn.running_mean, mx.zeros_like(bn.running_mean)))
+        self.assertTrue(mx.allclose(bn.running_var, mx.ones_like(bn.running_var)))
+        y = bn(x)
+        expected_y = mx.array(
+            [
+                [-0.439520, 1.647328, -0.955515, 1.966031],
+                [-1.726690, -1.449826, -0.234026, -0.723364],
+                [0.938414, -0.349603, -0.354470, -0.175369],
+                [0.305006, 0.234914, -0.393017, -0.459385],
+                [0.922789, -0.082813, 1.937028, -0.607913],
+            ],
+        )
+        expected_mean = mx.array([0.008929, 0.005680, -0.016092, 0.027778])
+        expected_var = mx.array([0.928435, 1.00455, 1.04117, 0.94258])
+        self.assertTrue(x.shape == y.shape)
+        self.assertTrue(mx.allclose(y, expected_y, atol=1e-5))
+        self.assertTrue(mx.allclose(bn.running_mean, expected_mean, atol=1e-5))
+        self.assertTrue(mx.allclose(bn.running_var, expected_var, atol=1e-5))
+
+        # test eval mode
+        bn.eval()
+        y = bn(x)
+        expected_y = mx.array(
+            [
+                [-0.15984, 1.73159, -1.25456, 1.57891],
+                [-0.872193, -1.4281, -0.414439, -0.228678],
+                [0.602743, -0.30566, -0.554687, 0.139639],
+                [0.252199, 0.29066, -0.599572, -0.0512532],
+                [0.594096, -0.0334829, 2.11359, -0.151081],
+            ]
+        )
+
+        self.assertTrue(x.shape == y.shape)
+        self.assertTrue(mx.allclose(y, expected_y, atol=1e-5))
+
+        # test_no_affine
+        bn = nn.BatchNorm(num_features=4, affine=False)
+        y = bn(x)
+        expected_y = mx.array(
+            [
+                [-0.439520, 1.647328, -0.955515, 1.966031],
+                [-1.726690, -1.449826, -0.234026, -0.723364],
+                [0.938414, -0.349603, -0.354470, -0.175369],
+                [0.305006, 0.234914, -0.393017, -0.459385],
+                [0.922789, -0.082813, 1.937028, -0.607913],
+            ]
+        )
+        self.assertTrue(x.shape == y.shape)
+        self.assertTrue(mx.allclose(y, expected_y, atol=1e-5))
+
+        # test with 3D input
+        mx.random.seed(42)
+        N = 2
+        L = 4
+        C = 5
+        x = mx.random.normal((N, L, C), dtype=mx.float32)
+
+        # Batch norm
+        bn = nn.BatchNorm(num_features=C, affine=True)
+        self.assertTrue(mx.allclose(bn.running_mean, mx.zeros_like(bn.running_mean)))
+        self.assertTrue(mx.allclose(bn.running_var, mx.ones_like(bn.running_var)))
+        y = bn(x)
+        self.assertTrue(x.shape == y.shape)
+        expected_y = mx.array(
+            [
+                [
+                    [-0.335754, 0.342054, 1.02653, 0.628588, -1.63899],
+                    [1.92092, 0.432319, 0.343043, 1.95489, 1.0696],
+                    [-0.853748, 1.3661, 0.868569, 0.0199196, -0.887284],
+                    [0.459206, -0.684822, -0.706354, -0.271531, 0.566341],
+                ],
+                [
+                    [-0.921179, 0.684951, -0.77466, -0.490372, -0.247032],
+                    [1.10839, -2.13179, 0.628924, -1.62639, -0.539708],
+                    [-0.348943, 0.412194, -2.03818, 0.524972, 1.64568],
+                    [-1.02889, -0.421, 0.652127, -0.740079, 0.0313996],
+                ],
+            ]
+        )
+        self.assertTrue(mx.allclose(y, expected_y, atol=1e-5))
+        expected_mean = mx.array(
+            [[[0.00207845, -5.3259e-05, 0.04755, -0.0697296, 0.0236228]]]
+        )
+        expected_var = mx.array([[[0.968415, 1.05322, 0.96913, 0.932305, 0.967224]]])
+        self.assertTrue(mx.allclose(bn.running_mean, expected_mean, atol=1e-5))
+        self.assertTrue(mx.allclose(bn.running_var, expected_var, atol=1e-5))
+
+        x = mx.random.normal((N, L, C, L, C), dtype=mx.float32)
+        with self.assertRaises(ValueError):
+            y = bn(x)
+
+        # Check that the running stats are in the param dictionary
+        bn_parameters = bn.parameters()
+        self.assertIn("running_mean", bn_parameters)
+        self.assertIn("running_var", bn_parameters)
+        self.assertIn("weight", bn_parameters)
+        self.assertIn("bias", bn_parameters)
+
+        bn_trainable = bn.trainable_parameters()
+        self.assertNotIn("running_mean", bn_trainable)
+        self.assertNotIn("running_var", bn_trainable)
+        self.assertIn("weight", bn_trainable)
+        self.assertIn("bias", bn_trainable)
+
+        bn.unfreeze()
+        bn_trainable = bn.trainable_parameters()
+        self.assertNotIn("running_mean", bn_trainable)
+        self.assertNotIn("running_var", bn_trainable)
+        self.assertIn("weight", bn_trainable)
+        self.assertIn("bias", bn_trainable)
+
+    def test_batch_norm_stats(self):
+        batch_size = 2
+        num_features = 4
+        h = 3
+        w = 3
+        momentum = 0.1
+
+        batch_norm = nn.BatchNorm(num_features)
+
+        batch_norm.train()
+        running_mean = batch_norm.running_mean
+        running_var = batch_norm.running_var
+
+        data = mx.random.normal((batch_size, num_features))
+
+        normalized_data = batch_norm(data)
+        means = mx.mean(data, axis=0)
+        variances = mx.var(data, axis=0)
+        running_mean = (1 - momentum) * running_mean + momentum * means
+        running_var = (1 - momentum) * running_var + momentum * variances
+        self.assertTrue(mx.allclose(batch_norm.running_mean, running_mean, atol=1e-5))
+        self.assertTrue(mx.allclose(batch_norm.running_var, running_var, atol=1e-5))
+
+        batch_norm = nn.BatchNorm(num_features)
+
+        batch_norm.train()
+        running_mean = batch_norm.running_mean
+        running_var = batch_norm.running_var
+        data = mx.random.normal((batch_size, h, w, num_features))
+
+        normalized_data = batch_norm(data)
+        means = mx.mean(data, axis=(0, 1, 2))
+        variances = mx.var(data, axis=(0, 1, 2))
+        running_mean = (1 - momentum) * running_mean + momentum * means
+        running_var = (1 - momentum) * running_var + momentum * variances
+        self.assertTrue(mx.allclose(batch_norm.running_mean, running_mean, atol=1e-5))
+        self.assertTrue(mx.allclose(batch_norm.running_var, running_var, atol=1e-5))
+
+        self.assertEqual(batch_norm.running_mean.shape, running_mean.shape)
+        self.assertEqual(batch_norm.running_var.shape, running_var.shape)
+
+    def test_conv1d(self):
+        N = 5
+        L = 12
+        ks = 3
+        C_in = 2
+        C_out = 4
+        x = mx.ones((N, L, C_in))
+        c = nn.Conv1d(in_channels=C_in, out_channels=C_out, kernel_size=ks)
+        c.weight = mx.ones_like(c.weight)
+        y = c(x)
+        self.assertEqual(y.shape, (N, L - ks + 1, C_out))
+        self.assertTrue(mx.allclose(y, mx.full(y.shape, ks * C_in, mx.float32)))
+
+        c = nn.Conv1d(in_channels=C_in, out_channels=C_out, kernel_size=ks, stride=2)
+        y = c(x)
+        self.assertEqual(y.shape, (N, (L - ks + 1) // 2, C_out))
+        self.assertTrue("bias" in c.parameters())
+
+        dil = 2
+        c = nn.Conv1d(
+            in_channels=C_in, out_channels=C_out, kernel_size=ks, dilation=dil
+        )
+        y = c(x)
+        self.assertEqual(y.shape, (N, L - (ks - 1) * dil, C_out))
+
+        c = nn.Conv1d(in_channels=C_in, out_channels=C_out, kernel_size=ks, bias=False)
+        self.assertTrue("bias" not in c.parameters())
+
+        groups = C_in
+        c = nn.Conv1d(
+            in_channels=C_in, out_channels=C_out, kernel_size=ks, groups=groups
+        )
+        y = c(x)
+        self.assertEqual(c.weight.shape, (C_out, ks, C_in // groups))
+        self.assertEqual(y.shape, (N, L - ks + 1, C_out))
+
+    def test_conv2d(self):
+        x = mx.ones((4, 8, 8, 3))
+        c = nn.Conv2d(3, 1, 8)
+        y = c(x)
+        self.assertEqual(y.shape, (4, 1, 1, 1))
+        c.weight = mx.ones_like(c.weight) / 8 / 8 / 3
+        y = c(x)
+        self.assertTrue(np.allclose(y[:, 0, 0, 0], x.mean(axis=(1, 2, 3))))
+
+        # 3x3 conv no padding stride 1
+        c = nn.Conv2d(3, 8, 3)
+        y = c(x)
+        self.assertEqual(y.shape, (4, 6, 6, 8))
+        self.assertLess(mx.abs(y - c.weight.sum((1, 2, 3))).max(), 1e-4)
+
+        # 3x3 conv padding 1 stride 1
+        c = nn.Conv2d(3, 8, 3, padding=1)
+        y = c(x)
+        self.assertEqual(y.shape, (4, 8, 8, 8))
+        self.assertLess(mx.abs(y[:, 1:7, 1:7] - c.weight.sum((1, 2, 3))).max(), 1e-4)
+        self.assertLess(
+            mx.abs(y[:, 0, 0] - c.weight[:, 1:, 1:].sum(axis=(1, 2, 3))).max(),
+            1e-4,
+        )
+        self.assertLess(
+            mx.abs(y[:, 7, 7] - c.weight[:, :-1, :-1].sum(axis=(1, 2, 3))).max(),
+            1e-4,
+        )
+        self.assertLess(
+            mx.abs(y[:, 1:7, 7] - c.weight[:, :, :-1].sum(axis=(1, 2, 3))).max(),
+            1e-4,
+        )
+        self.assertLess(
+            mx.abs(y[:, 7, 1:7] - c.weight[:, :-1, :].sum(axis=(1, 2, 3))).max(),
+            1e-4,
+        )
+
+        # 3x3 conv no padding stride 2
+        c = nn.Conv2d(3, 8, 3, padding=0, stride=2)
+        y = c(x)
+        self.assertEqual(y.shape, (4, 3, 3, 8))
+        self.assertLess(mx.abs(y - c.weight.sum((1, 2, 3))).max(), 1e-4)
+
+        c = nn.Conv2d(3, 8, 3, dilation=2)
+        y = c(x)
+        self.assertEqual(y.shape, (4, 4, 4, 8))
+        self.assertLess(mx.abs(y - c.weight.sum((1, 2, 3))).max(), 1e-4)
+
+        # 3x3 conv groups > 1
+        x = mx.ones((4, 7, 7, 4))
+        c = nn.Conv2d(4, 8, 3, padding=1, stride=1, groups=2)
+        y = c(x)
+        self.assertEqual(y.shape, (4, 7, 7, 8))
+
+    def test_sequential(self):
+        x = mx.ones((10, 2))
+        m = nn.Sequential(nn.Linear(2, 10), nn.ReLU(), nn.Linear(10, 1))
+        y = m(x)
+        self.assertEqual(y.shape, (10, 1))
+        params = m.parameters()
+        self.assertTrue("layers" in params)
+        self.assertEqual(len(params["layers"]), 3)
+        self.assertTrue("weight" in params["layers"][0])
+        self.assertEqual(len(params["layers"][1]), 0)
+        self.assertTrue("weight" in params["layers"][2])
+
+        m.layers[1] = nn.relu
+        y2 = m(x)
+        self.assertTrue(mx.array_equal(y, y2))
+
+    def test_gelu(self):
+        inputs = [1.15286231, -0.81037411, 0.35816911, 0.77484438, 0.66276414]
+
+        # From: jax.nn.gelu(np.array(inputs), approximate=False)
+        expected = np.array(
+            [1.0093501, -0.16925684, 0.22918941, 0.60498625, 0.49459383]
+        )
+        # From: jax.nn.gelu(np.array(inputs), approximate=True)
+        expected_approx = np.array(
+            [1.0091482, -0.1693441, 0.22918446, 0.60491, 0.4945476]
+        )
+
+        out = nn.GELU()(mx.array(inputs))
+        self.assertTrue(np.allclose(out, expected))
+
+        # Test the precise/tanh approximation
+        out_approx = nn.GELU(approx="precise")(mx.array(inputs))
+        out_approx_tanh = nn.GELU(approx="tanh")(mx.array(inputs))
+        self.assertTrue(np.allclose(out_approx, expected_approx))
+        self.assertTrue(np.allclose(out_approx_tanh, expected_approx))
+        self.assertTrue(np.allclose(out_approx, out_approx_tanh))
+
+        # Crudely check the approximations
+        x = mx.arange(-6.0, 6.0, 12 / 100)
+        y = nn.gelu(x)
+        y_hat1 = nn.gelu_approx(x)
+        y_hat2 = nn.gelu_fast_approx(x)
+        self.assertLess(mx.abs(y - y_hat1).max(), 0.0005)
+        self.assertLess(mx.abs(y - y_hat2).max(), 0.025)
+
+    def test_sin_pe(self):
+        m = nn.SinusoidalPositionalEncoding(16, min_freq=0.01)
+        x = mx.arange(10)
+        y = m(x)
+
+        self.assertEqual(y.shape, (10, 16))
+        similarities = y @ y.T
+        self.assertLess(
+            mx.abs(similarities[mx.arange(10), mx.arange(10)] - 1).max(), 1e-5
+        )
+
+    def test_sigmoid(self):
+        x = mx.array([1.0, 0.0, -1.0])
+        y1 = mx.sigmoid(x)
+        y2 = nn.activations.sigmoid(x)
+        y3 = nn.Sigmoid()(x)
+
+        self.assertEqualArray(y1, y2, atol=0, rtol=0)
+        self.assertEqualArray(y1, y3, atol=0, rtol=0)
+
+    def test_relu(self):
+        x = mx.array([1.0, -1.0, 0.0])
+        y = nn.relu(x)
+        self.assertTrue(mx.array_equal(y, mx.array([1.0, 0.0, 0.0])))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_leaky_relu(self):
+        x = mx.array([1.0, -1.0, 0.0])
+        y = nn.leaky_relu(x)
+        self.assertTrue(mx.array_equal(y, mx.array([1.0, -0.01, 0.0])))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+        y = nn.LeakyReLU(negative_slope=0.1)(x)
+        self.assertTrue(mx.array_equal(y, mx.array([1.0, -0.1, 0.0])))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_elu(self):
+        x = mx.array([1.0, -1.0, 0.0])
+        y = nn.elu(x)
+        epsilon = 1e-4
+        expected_y = mx.array([1.0, -0.6321, 0.0])
+        self.assertTrue(mx.all(mx.abs(y - expected_y) < epsilon))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+        y = nn.ELU(alpha=1.1)(x)
+        epsilon = 1e-4
+        expected_y = mx.array([1.0, -0.6953, 0.0])
+        self.assertTrue(mx.all(mx.abs(y - expected_y) < epsilon))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_relu6(self):
+        x = mx.array([1.0, -1.0, 0.0, 7.0, -7.0])
+        y = nn.relu6(x)
+        self.assertTrue(mx.array_equal(y, mx.array([1.0, 0.0, 0.0, 6.0, 0.0])))
+        self.assertEqual(y.shape, (5,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_softmax(self):
+        x = mx.array([1.0, -1.0, 0.0])
+        y = nn.softmax(x)
+        epsilon = 1e-4
+        expected_y = mx.array([0.6652, 0.0900, 0.2447])
+        self.assertTrue(mx.all(mx.abs(y - expected_y) < epsilon))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_softmin(self):
+        x = mx.array([1.0, 2.0, 3.0])
+        y = nn.softmin(x)
+        epsilon = 1e-4
+        expected_y = mx.array([0.6652, 0.2447, 0.0900])
+        self.assertTrue(mx.all(mx.abs(y - expected_y) < epsilon))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_softplus(self):
+        x = mx.array([1.0, -1.0, 0.0])
+        y = nn.softplus(x)
+        epsilon = 1e-4
+        expected_y = mx.array([1.3133, 0.3133, 0.6931])
+        self.assertTrue(mx.all(mx.abs(y - expected_y) < epsilon))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_softsign(self):
+        x = mx.array([1.0, -1.0, 0.0])
+        y = nn.softsign(x)
+        epsilon = 1e-4
+        expected_y = mx.array([0.5, -0.5, 0.0])
+        self.assertTrue(mx.all(mx.abs(y - expected_y) < epsilon))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_softshrink(self):
+        x = mx.array([1.0, -1.0, 0.0])
+        y = nn.softshrink(x)
+        epsilon = 1e-4
+        expected_y = mx.array([0.5, -0.5, 0.0])
+        self.assertTrue(mx.all(mx.abs(y - expected_y) < epsilon))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+        y = nn.Softshrink(lambd=0.7)(x)
+        expected_y = mx.array([0.3, -0.3, 0.0])
+        self.assertTrue(mx.all(mx.abs(y - expected_y) < epsilon))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_celu(self):
+        x = mx.array([1.0, -1.0, 0.0])
+        y = nn.celu(x)
+        epsilon = 1e-4
+        expected_y = mx.array([1.0, -0.6321, 0.0])
+        self.assertTrue(mx.all(mx.abs(y - expected_y) < epsilon))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+        y = nn.CELU(alpha=1.1)(x)
+        expected_y = mx.array([1.0, -0.6568, 0.0])
+        self.assertTrue(mx.all(mx.abs(y - expected_y) < epsilon))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_log_softmax(self):
+        x = mx.array([1.0, 2.0, 3.0])
+        y = nn.log_softmax(x)
+        epsilon = 1e-4
+        expected_y = mx.array([-2.4076, -1.4076, -0.4076])
+        self.assertTrue(mx.all(mx.abs(y - expected_y) < epsilon))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_log_sigmoid(self):
+        x = mx.array([1.0, -1.0, 0.0])
+        y = nn.log_sigmoid(x)
+        epsilon = 1e-4
+        expected_y = mx.array([-0.3133, -1.3133, -0.6931])
+        self.assertTrue(mx.all(mx.abs(y - expected_y) < epsilon))
+        self.assertEqual(y.shape, (3,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_prelu(self):
+        self.assertEqualArray(
+            nn.PReLU()(mx.array([1.0, -1.0, 0.0, 0.5])),
+            mx.array([1.0, -0.25, 0.0, 0.5]),
+        )
+
+    def test_mish(self):
+        self.assertEqualArray(
+            nn.Mish()(mx.array([1.0, -1.0, 0.0, 0.5])),
+            mx.array([0.8651, -0.3034, 0.0000, 0.3752]),
+        )
+
+    def test_hardswish(self):
+        x = mx.array([-3.0, -1.5, 0.0, 1.5, 3.0])
+        y = nn.hardswish(x)
+        epsilon = 1e-4
+        expected_y = mx.array([0.0, -0.375, 0.0, 1.125, 3.0])
+        self.assertTrue(mx.all(mx.abs(y - expected_y) < epsilon))
+        self.assertEqual(y.shape, (5,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_glu(self):
+        x = mx.array([[[1.0, 2.0, 3.0, 4.0]]], dtype=mx.float32)
+        y = mx.array([[[0.952574, 1.96403]]], dtype=mx.float32)
+        out = nn.glu(x)
+        self.assertEqualArray(out, y)
+
+    def test_hard_tanh(self):
+        x = mx.array([1.0, -2.0, 0.0, 0.5, 2.0])
+        y = nn.hard_tanh(x)
+        expected_y = mx.array([1.0, -1.0, 0.0, 0.5, 1.0])
+        self.assertTrue(mx.array_equal(y, expected_y))
+        self.assertEqual(y.shape, (5,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_hard_shrink(self):
+        x = mx.array([1.0, -0.5, 0.0, 0.5, -1.5])
+        y = nn.hard_shrink(x)
+        expected_y = mx.array([1.0, 0.0, 0.0, 0.0, -1.5])
+        self.assertTrue(mx.array_equal(y, expected_y))
+        self.assertEqual(y.shape, (5,))
+        self.assertEqual(y.dtype, mx.float32)
+
+        y = nn.hard_shrink(x, lambd=0.1)
+        expected_y = mx.array([1.0, -0.5, 0.0, 0.5, -1.5])
+        self.assertTrue(mx.array_equal(y, expected_y))
+        self.assertEqual(y.shape, (5,))
+        self.assertEqual(y.dtype, mx.float32)
+
+    def test_rope(self):
+        for kwargs in [{}, {"traditional": False}, {"base": 10000}, {"scale": 0.25}]:
+            rope = nn.RoPE(4, **kwargs)
+            shape = (1, 3, 4)
+            x = mx.random.uniform(shape=shape)
+            y = rope(x)
+            self.assertEqual(y.shape, shape)
+            self.assertEqual(y.dtype, mx.float32)
+
+            y = rope(x, offset=3)
+            self.assertEqual(y.shape, shape)
+
+            y = rope(x.astype(mx.float16))
+            self.assertEqual(y.dtype, mx.float16)
+
+    def test_alibi(self):
+        alibi = nn.ALiBi()
+        shape = (1, 8, 20, 20)
+        x = mx.random.uniform(shape=shape)
+        y = alibi(x)
+        self.assertEqual(y.shape, shape)
+        self.assertEqual(y.dtype, mx.float32)
+
+        y = alibi(x.astype(mx.float16))
+        self.assertEqual(y.dtype, mx.float16)
+
+    def test_dropout(self):
+        x = mx.ones((2, 4))
+        y = nn.Dropout(0.5)(x)
+        self.assertEqual(y.shape, x.shape)
+        self.assertEqual(y.dtype, mx.float32)
+
+        x = mx.ones((2, 4), dtype=mx.bfloat16)
+        y = nn.Dropout(0.5)(x)
+        self.assertEqual(y.shape, x.shape)
+        self.assertEqual(y.dtype, mx.bfloat16)
+
+        x = mx.ones((2, 4), dtype=mx.float16)
+        y = nn.Dropout(0.5)(x)
+        self.assertEqual(y.shape, x.shape)
+        self.assertEqual(y.dtype, mx.float16)
+
+    def test_dropout2d(self):
+        x = mx.ones((2, 4, 4, 4))
+        y = nn.Dropout2d(0.5)(x)
+        self.assertEqual(y.shape, x.shape)
+        self.assertEqual(y.dtype, mx.float32)
+
+        x = mx.ones((2, 4, 4, 4), dtype=mx.bfloat16)
+        y = nn.Dropout2d(0.5)(x)
+        self.assertEqual(y.shape, x.shape)
+        self.assertEqual(y.dtype, mx.bfloat16)
+
+        x = mx.ones((2, 4, 4, 4), dtype=mx.float16)
+        y = nn.Dropout2d(0.5)(x)
+        self.assertEqual(y.shape, x.shape)
+        self.assertEqual(y.dtype, mx.float16)
+
+    def test_dropout3d(self):
+        x = mx.ones((2, 4, 4, 4, 4))
+        y = nn.Dropout3d(0.5)(x)
+        self.assertEqual(y.shape, x.shape)
+        self.assertEqual(y.dtype, mx.float32)
+
+        x = mx.ones((2, 4, 4, 4, 4), dtype=mx.bfloat16)
+        y = nn.Dropout3d(0.5)(x)
+        self.assertEqual(y.shape, x.shape)
+        self.assertEqual(y.dtype, mx.bfloat16)
+
+        x = mx.ones((2, 4, 4, 4, 4), dtype=mx.float16)
+        y = nn.Dropout3d(0.5)(x)
+        self.assertEqual(y.shape, x.shape)
+        self.assertEqual(y.dtype, mx.float16)
+
+    def test_upsample(self):
+        b, h, w, c = 1, 2, 2, 1
+        scale_factor = 2
+        upsample_nearest = nn.Upsample(
+            scale_factor=scale_factor, mode="nearest", align_corners=True
+        )
+        upsample_bilinear = nn.Upsample(
+            scale_factor=scale_factor, mode="linear", align_corners=True
+        )
+        upsample_nearest = nn.Upsample(
+            scale_factor=scale_factor, mode="nearest", align_corners=True
+        )
+        upsample_bilinear_no_align_corners = nn.Upsample(
+            scale_factor=scale_factor, mode="linear", align_corners=False
+        )
+        upsample_nearest_no_align_corners = nn.Upsample(
+            scale_factor=scale_factor, mode="nearest", align_corners=False
+        )
+        # Test single feature map, align corners
+        x = mx.arange(b * h * w * c).reshape((b, c, h, w)).transpose((0, 2, 3, 1))
+        expected_nearest = mx.array(
+            [[[[0, 0, 1, 1], [0, 0, 1, 1], [2, 2, 3, 3], [2, 2, 3, 3]]]]
+        ).transpose((0, 2, 3, 1))
+        expected_bilinear = mx.array(
+            [
+                [
+                    [
+                        [0, 0.333333, 0.666667, 1],
+                        [0.666667, 1, 1.33333, 1.66667],
+                        [1.33333, 1.66667, 2, 2.33333],
+                        [2, 2.33333, 2.66667, 3],
+                    ]
+                ]
+            ]
+        ).transpose((0, 2, 3, 1))
+        # Test single feature map, no align corners
+        x = (
+            mx.arange(1, b * h * w * c + 1)
+            .reshape((b, c, h, w))
+            .transpose((0, 2, 3, 1))
+        )
+        expected_bilinear_no_align_corners = mx.array(
+            [
+                [
+                    [
+                        [1.0000, 1.2500, 1.7500, 2.0000],
+                        [1.5000, 1.7500, 2.2500, 2.5000],
+                        [2.5000, 2.7500, 3.2500, 3.5000],
+                        [3.0000, 3.2500, 3.7500, 4.0000],
+                    ]
+                ]
+            ]
+        ).transpose((0, 2, 3, 1))
+        expected_nearest_no_align_corners = mx.array(
+            [[[[1, 1, 2, 2], [1, 1, 2, 2], [3, 3, 4, 4], [3, 3, 4, 4]]]]
+        ).transpose((0, 2, 3, 1))
+        self.assertTrue(
+            np.allclose(
+                upsample_nearest_no_align_corners(x), expected_nearest_no_align_corners
+            )
+        )
+        self.assertTrue(
+            np.allclose(
+                upsample_bilinear_no_align_corners(x),
+                expected_bilinear_no_align_corners,
+            )
+        )
+
+        # Test a more complex batch
+        b, h, w, c = 2, 3, 3, 2
+        scale_factor = 2
+        x = mx.arange((b * h * w * c)).reshape((b, c, h, w)).transpose((0, 2, 3, 1))
+
+        upsample_nearest = nn.Upsample(
+            scale_factor=scale_factor, mode="nearest", align_corners=True
+        )
+        upsample_bilinear = nn.Upsample(
+            scale_factor=scale_factor, mode="linear", align_corners=True
+        )
+
+        expected_nearest = mx.array(
+            [
+                [
+                    [
+                        [0.0, 0.0, 1.0, 1.0, 2.0, 2.0],
+                        [0.0, 0.0, 1.0, 1.0, 2.0, 2.0],
+                        [3.0, 3.0, 4.0, 4.0, 5.0, 5.0],
+                        [3.0, 3.0, 4.0, 4.0, 5.0, 5.0],
+                        [6.0, 6.0, 7.0, 7.0, 8.0, 8.0],
+                        [6.0, 6.0, 7.0, 7.0, 8.0, 8.0],
+                    ],
+                    [
+                        [9.0, 9.0, 10.0, 10.0, 11.0, 11.0],
+                        [9.0, 9.0, 10.0, 10.0, 11.0, 11.0],
+                        [12.0, 12.0, 13.0, 13.0, 14.0, 14.0],
+                        [12.0, 12.0, 13.0, 13.0, 14.0, 14.0],
+                        [15.0, 15.0, 16.0, 16.0, 17.0, 17.0],
+                        [15.0, 15.0, 16.0, 16.0, 17.0, 17.0],
+                    ],
+                ],
+                [
+                    [
+                        [18.0, 18.0, 19.0, 19.0, 20.0, 20.0],
+                        [18.0, 18.0, 19.0, 19.0, 20.0, 20.0],
+                        [21.0, 21.0, 22.0, 22.0, 23.0, 23.0],
+                        [21.0, 21.0, 22.0, 22.0, 23.0, 23.0],
+                        [24.0, 24.0, 25.0, 25.0, 26.0, 26.0],
+                        [24.0, 24.0, 25.0, 25.0, 26.0, 26.0],
+                    ],
+                    [
+                        [27.0, 27.0, 28.0, 28.0, 29.0, 29.0],
+                        [27.0, 27.0, 28.0, 28.0, 29.0, 29.0],
+                        [30.0, 30.0, 31.0, 31.0, 32.0, 32.0],
+                        [30.0, 30.0, 31.0, 31.0, 32.0, 32.0],
+                        [33.0, 33.0, 34.0, 34.0, 35.0, 35.0],
+                        [33.0, 33.0, 34.0, 34.0, 35.0, 35.0],
+                    ],
+                ],
+            ]
+        ).transpose((0, 2, 3, 1))
+        expected_bilinear = mx.array(
+            [
+                [
+                    [
+                        [0.0, 0.4, 0.8, 1.2, 1.6, 2.0],
+                        [1.2, 1.6, 2.0, 2.4, 2.8, 3.2],
+                        [2.4, 2.8, 3.2, 3.6, 4.0, 4.4],
+                        [3.6, 4.0, 4.4, 4.8, 5.2, 5.6],
+                        [4.8, 5.2, 5.6, 6.0, 6.4, 6.8],
+                        [6.0, 6.4, 6.8, 7.2, 7.6, 8.0],
+                    ],
+                    [
+                        [9.0, 9.4, 9.8, 10.2, 10.6, 11.0],
+                        [10.2, 10.6, 11.0, 11.4, 11.8, 12.2],
+                        [11.4, 11.8, 12.2, 12.6, 13.0, 13.4],
+                        [12.6, 13.0, 13.4, 13.8, 14.2, 14.6],
+                        [13.8, 14.2, 14.6, 15.0, 15.4, 15.8],
+                        [15.0, 15.4, 15.8, 16.2, 16.6, 17.0],
+                    ],
+                ],
+                [
+                    [
+                        [18.0, 18.4, 18.8, 19.2, 19.6, 20.0],
+                        [19.2, 19.6, 20.0, 20.4, 20.8, 21.2],
+                        [20.4, 20.8, 21.2, 21.6, 22.0, 22.4],
+                        [21.6, 22.0, 22.4, 22.8, 23.2, 23.6],
+                        [22.8, 23.2, 23.6, 24.0, 24.4, 24.8],
+                        [24.0, 24.4, 24.8, 25.2, 25.6, 26.0],
+                    ],
+                    [
+                        [27.0, 27.4, 27.8, 28.2, 28.6, 29.0],
+                        [28.2, 28.6, 29.0, 29.4, 29.8, 30.2],
+                        [29.4, 29.8, 30.2, 30.6, 31.0, 31.4],
+                        [30.6, 31.0, 31.4, 31.8, 32.2, 32.6],
+                        [31.8, 32.2, 32.6, 33.0, 33.4, 33.8],
+                        [33.0, 33.4, 33.8, 34.2, 34.6, 35.0],
+                    ],
+                ],
+            ]
+        ).transpose((0, 2, 3, 1))
+        self.assertTrue(np.allclose(upsample_nearest(x), expected_nearest))
+        self.assertTrue(np.allclose(upsample_bilinear(x), expected_bilinear))
+
+        # Test different height and width scale_factor
+        b, h, w, c = 1, 2, 2, 2
+        x = mx.arange(b * h * w * c).reshape((b, c, h, w)).transpose((0, 2, 3, 1))
+        upsample_nearest = nn.Upsample(
+            scale_factor=(2, 3), mode="nearest", align_corners=True
+        )
+        upsample_bilinear = nn.Upsample(
+            scale_factor=(2, 3), mode="linear", align_corners=True
+        )
+
+        expected_nearest = mx.array(
+            [
+                [
+                    [
+                        [0, 0, 0, 1, 1, 1],
+                        [0, 0, 0, 1, 1, 1],
+                        [2, 2, 2, 3, 3, 3],
+                        [2, 2, 2, 3, 3, 3],
+                    ],
+                    [
+                        [4, 4, 4, 5, 5, 5],
+                        [4, 4, 4, 5, 5, 5],
+                        [6, 6, 6, 7, 7, 7],
+                        [6, 6, 6, 7, 7, 7],
+                    ],
+                ]
+            ]
+        ).transpose((0, 2, 3, 1))
+        expected_bilinear = mx.array(
+            [
+                [
+                    [
+                        [0, 0.2, 0.4, 0.6, 0.8, 1],
+                        [0.666667, 0.866667, 1.06667, 1.26667, 1.46667, 1.66667],
+                        [1.33333, 1.53333, 1.73333, 1.93333, 2.13333, 2.33333],
+                        [2, 2.2, 2.4, 2.6, 2.8, 3],
+                    ],
+                    [
+                        [4, 4.2, 4.4, 4.6, 4.8, 5],
+                        [4.66667, 4.86667, 5.06667, 5.26667, 5.46667, 5.66667],
+                        [5.33333, 5.53333, 5.73333, 5.93333, 6.13333, 6.33333],
+                        [6, 6.2, 6.4, 6.6, 6.8, 7],
+                    ],
+                ]
+            ]
+        ).transpose((0, 2, 3, 1))
+        self.assertTrue(np.allclose(upsample_nearest(x), expected_nearest))
+        self.assertTrue(np.allclose(upsample_bilinear(x), expected_bilinear))
+
+        # Test repr
+        self.assertEqual(
+            str(nn.Upsample(scale_factor=2)),
+            "Upsample(scale_factor=2.0, mode='nearest', align_corners=False)",
+        )
+        self.assertEqual(
+            str(nn.Upsample(scale_factor=(2, 3))),
+            "Upsample(scale_factor=(2.0, 3.0), mode='nearest', align_corners=False)",
+        )
+
+    def test_pooling(self):
+        # Test 1d pooling
+        x = mx.array(
+            [
+                [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]],
+                [[12, 13, 14], [15, 16, 17], [18, 19, 20], [21, 22, 23]],
+            ]
+        )
+        expected_max_pool_output_no_padding_stride_1 = [
+            [[3.0, 4.0, 5.0], [6.0, 7.0, 8.0], [9.0, 10.0, 11.0]],
+            [[15.0, 16.0, 17.0], [18.0, 19.0, 20.0], [21.0, 22.0, 23.0]],
+        ]
+        expected_max_pool_output_no_padding_stride_2 = [
+            [[3.0, 4.0, 5.0], [9.0, 10.0, 11.0]],
+            [[15.0, 16.0, 17.0], [21.0, 22.0, 23.0]],
+        ]
+        expected_max_pool_output_padding_1_stride_2 = [
+            [[0.0, 1.0, 2.0], [6.0, 7.0, 8.0], [9.0, 10.0, 11.0]],
+            [[12.0, 13.0, 14.0], [18.0, 19.0, 20.0], [21.0, 22.0, 23.0]],
+        ]
+        expected_max_pool_output_padding_1_stride_2_kernel_3 = [
+            [[3.0, 4.0, 5.0], [9.0, 10.0, 11.0]],
+            [[15.0, 16.0, 17.0], [21.0, 22.0, 23.0]],
+        ]
+        expected_avg_pool_output_no_padding_stride_1 = [
+            [
+                [1.5000, 2.5000, 3.5000],
+                [4.5000, 5.5000, 6.5000],
+                [7.5000, 8.5000, 9.5000],
+            ],
+            [
+                [13.5000, 14.5000, 15.5000],
+                [16.5000, 17.5000, 18.5000],
+                [19.5000, 20.5000, 21.5000],
+            ],
+        ]
+        expected_avg_pool_output_no_padding_stride_2 = [
+            [[1.5000, 2.5000, 3.5000], [7.5000, 8.5000, 9.5000]],
+            [[13.5000, 14.5000, 15.5000], [19.5000, 20.5000, 21.5000]],
+        ]
+        expected_avg_pool_output_padding_1_stride_2 = [
+            [
+                [0.0000, 0.5000, 1.0000],
+                [4.5000, 5.5000, 6.5000],
+                [4.5000, 5.0000, 5.5000],
+            ],
+            [
+                [6.0000, 6.5000, 7.0000],
+                [16.5000, 17.5000, 18.5000],
+                [10.5000, 11.0000, 11.5000],
+            ],
+        ]
+        expected_avg_pool_output_padding_1_kernel_3 = [
+            [[1, 1.66667, 2.33333], [6, 7, 8]],
+            [[9, 9.66667, 10.3333], [18, 19, 20]],
+        ]
+        self.assertTrue(
+            np.array_equal(
+                nn.MaxPool1d(kernel_size=2, stride=1, padding=0)(x),
+                expected_max_pool_output_no_padding_stride_1,
+            )
+        )
+        self.assertTrue(
+            np.array_equal(
+                nn.MaxPool1d(kernel_size=2, stride=2, padding=0)(x),
+                expected_max_pool_output_no_padding_stride_2,
+            )
+        )
+        self.assertTrue(
+            np.array_equal(
+                nn.MaxPool1d(kernel_size=2, stride=2, padding=1)(x),
+                expected_max_pool_output_padding_1_stride_2,
+            )
+        )
+        self.assertTrue(
+            np.array_equal(
+                nn.MaxPool1d(kernel_size=3, stride=2, padding=1)(x),
+                expected_max_pool_output_padding_1_stride_2_kernel_3,
+            )
+        )
+        self.assertTrue(
+            np.allclose(
+                nn.AvgPool1d(kernel_size=2, stride=1, padding=0)(x),
+                expected_avg_pool_output_no_padding_stride_1,
+            )
+        )
+        self.assertTrue(
+            np.allclose(
+                nn.AvgPool1d(kernel_size=2, stride=2, padding=0)(x),
+                expected_avg_pool_output_no_padding_stride_2,
+            )
+        )
+        self.assertTrue(
+            np.allclose(
+                nn.AvgPool1d(kernel_size=2, stride=2, padding=1)(x),
+                expected_avg_pool_output_padding_1_stride_2,
+            )
+        )
+        self.assertTrue(
+            np.allclose(
+                nn.AvgPool1d(kernel_size=3, stride=2, padding=1)(x),
+                expected_avg_pool_output_padding_1_kernel_3,
+            )
+        )
+        # Test 2d pooling
+        x = mx.array(
+            [
+                [
+                    [[0, 16], [1, 17], [2, 18], [3, 19]],
+                    [[4, 20], [5, 21], [6, 22], [7, 23]],
+                    [[8, 24], [9, 25], [10, 26], [11, 27]],
+                    [[12, 28], [13, 29], [14, 30], [15, 31]],
+                ]
+            ]
+        )
+        expected_max_pool_output_no_padding_stride_1 = [
+            [
+                [[5, 21], [6, 22], [7, 23]],
+                [[9, 25], [10, 26], [11, 27]],
+                [[13, 29], [14, 30], [15, 31]],
+            ]
+        ]
+        expected_max_pool_output_no_padding_stride_2 = [
+            [[[5, 21], [7, 23]], [[13, 29], [15, 31]]]
+        ]
+        expected_max_pool_output_padding_1 = [
+            [
+                [[0, 16], [2, 18], [3, 19]],
+                [[8, 24], [10, 26], [11, 27]],
+                [[12, 28], [14, 30], [15, 31]],
+            ]
+        ]
+        expected_mean_pool_output_no_padding_stride_1 = [
+            [
+                [[2.5000, 18.5000], [3.5000, 19.5000], [4.5000, 20.5000]],
+                [[6.5000, 22.5000], [7.5000, 23.5000], [8.5000, 24.5000]],
+                [[10.5000, 26.5000], [11.5000, 27.5000], [12.5000, 28.5000]],
+            ]
+        ]
+        expected_mean_pool_output_no_padding_stride_2 = [
+            [
+                [[2.5000, 18.5000], [4.5000, 20.5000]],
+                [[10.5000, 26.5000], [12.5000, 28.5000]],
+            ]
+        ]
+        expected_mean_pool_output_padding_1 = [
+            [
+                [[0.0000, 4.0000], [0.7500, 8.7500], [0.7500, 4.7500]],
+                [[3.0000, 11.0000], [7.5000, 23.5000], [4.5000, 12.5000]],
+                [[3.0000, 7.0000], [6.7500, 14.7500], [3.7500, 7.7500]],
+            ]
+        ]
+        self.assertTrue(
+            np.array_equal(
+                nn.MaxPool2d(kernel_size=2, stride=1, padding=0)(x),
+                expected_max_pool_output_no_padding_stride_1,
+            )
+        )
+        self.assertTrue(
+            np.array_equal(
+                nn.MaxPool2d(kernel_size=2, stride=2, padding=0)(x),
+                expected_max_pool_output_no_padding_stride_2,
+            )
+        )
+        self.assertTrue(
+            np.array_equal(
+                nn.MaxPool2d(kernel_size=2, stride=2, padding=1)(x),
+                expected_max_pool_output_padding_1,
+            )
+        )
+        # Average pooling
+        self.assertTrue(
+            np.allclose(
+                nn.AvgPool2d(kernel_size=2, stride=1, padding=0)(x),
+                expected_mean_pool_output_no_padding_stride_1,
+            )
+        )
+        self.assertTrue(
+            np.array_equal(
+                nn.AvgPool2d(kernel_size=2, stride=2, padding=0)(x),
+                expected_mean_pool_output_no_padding_stride_2,
+            )
+        )
+        self.assertTrue(
+            np.array_equal(
+                nn.AvgPool2d(kernel_size=2, stride=2, padding=1)(x),
+                expected_mean_pool_output_padding_1,
+            )
+        )
+        # Test multiple batches
+        x = mx.array(
+            [
+                [
+                    [[0, 1], [2, 3], [4, 5], [6, 7]],
+                    [[8, 9], [10, 11], [12, 13], [14, 15]],
+                    [[16, 17], [18, 19], [20, 21], [22, 23]],
+                    [[24, 25], [26, 27], [28, 29], [30, 31]],
+                ],
+                [
+                    [[32, 33], [34, 35], [36, 37], [38, 39]],
+                    [[40, 41], [42, 43], [44, 45], [46, 47]],
+                    [[48, 49], [50, 51], [52, 53], [54, 55]],
+                    [[56, 57], [58, 59], [60, 61], [62, 63]],
+                ],
+            ]
+        )
+        expected_max_pool_output = [
+            [[[10.0, 11.0], [14.0, 15.0]], [[26.0, 27.0], [30.0, 31.0]]],
+            [[[42.0, 43.0], [46.0, 47.0]], [[58.0, 59.0], [62.0, 63.0]]],
+        ]
+        expected_avg_pool_output = [
+            [[[2.22222, 2.66667], [5.33333, 6]], [[11.3333, 12], [20, 21]]],
+            [[[16.4444, 16.8889], [26.6667, 27.3333]], [[32.6667, 33.3333], [52, 53]]],
+        ]
+        self.assertTrue(
+            np.array_equal(
+                nn.MaxPool2d(kernel_size=3, stride=2, padding=1)(x),
+                expected_max_pool_output,
+            )
+        )
+        self.assertTrue(
+            np.allclose(
+                nn.AvgPool2d(kernel_size=3, stride=2, padding=1)(x),
+                expected_avg_pool_output,
+            )
+        )
+        # Test irregular kernel (2, 4), stride (3, 1) and padding (1, 2)
+        x = mx.array(
+            [
+                [
+                    [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]],
+                    [[12, 13, 14], [15, 16, 17], [18, 19, 20], [21, 22, 23]],
+                    [[24, 25, 26], [27, 28, 29], [30, 31, 32], [33, 34, 35]],
+                    [[36, 37, 38], [39, 40, 41], [42, 43, 44], [45, 46, 47]],
+                ],
+                [
+                    [[48, 49, 50], [51, 52, 53], [54, 55, 56], [57, 58, 59]],
+                    [[60, 61, 62], [63, 64, 65], [66, 67, 68], [69, 70, 71]],
+                    [[72, 73, 74], [75, 76, 77], [78, 79, 80], [81, 82, 83]],
+                    [[84, 85, 86], [87, 88, 89], [90, 91, 92], [93, 94, 95]],
+                ],
+            ]
+        )
+        expected_irregular_max_pool_output = [
+            [
+                [
+                    [3.0, 4.0, 5.0],
+                    [6.0, 7.0, 8.0],
+                    [9.0, 10.0, 11.0],
+                    [9.0, 10.0, 11.0],
+                    [9.0, 10.0, 11.0],
+                ],
+                [
+                    [39.0, 40.0, 41.0],
+                    [42.0, 43.0, 44.0],
+                    [45.0, 46.0, 47.0],
+                    [45.0, 46.0, 47.0],
+                    [45.0, 46.0, 47.0],
+                ],
+            ],
+            [
+                [
+                    [51.0, 52.0, 53.0],
+                    [54.0, 55.0, 56.0],
+                    [57.0, 58.0, 59.0],
+                    [57.0, 58.0, 59.0],
+                    [57.0, 58.0, 59.0],
+                ],
+                [
+                    [87.0, 88.0, 89.0],
+                    [90.0, 91.0, 92.0],
+                    [93.0, 94.0, 95.0],
+                    [93.0, 94.0, 95.0],
+                    [93.0, 94.0, 95.0],
+                ],
+            ],
+        ]
+        expected_irregular_average_pool_output = [
+            [
+                [
+                    [0.3750, 0.6250, 0.8750],
+                    [1.1250, 1.5000, 1.8750],
+                    [2.2500, 2.7500, 3.2500],
+                    [2.2500, 2.6250, 3.0000],
+                    [1.8750, 2.1250, 2.3750],
+                ],
+                [
+                    [15.7500, 16.2500, 16.7500],
+                    [24.7500, 25.5000, 26.2500],
+                    [34.5000, 35.5000, 36.5000],
+                    [27.0000, 27.7500, 28.5000],
+                    [18.7500, 19.2500, 19.7500],
+                ],
+            ],
+            [
+                [
+                    [12.3750, 12.6250, 12.8750],
+                    [19.1250, 19.5000, 19.8750],
+                    [26.2500, 26.7500, 27.2500],
+                    [20.2500, 20.6250, 21.0000],
+                    [13.8750, 14.1250, 14.3750],
+                ],
+                [
+                    [39.7500, 40.2500, 40.7500],
+                    [60.7500, 61.5000, 62.2500],
+                    [82.5000, 83.5000, 84.5000],
+                    [63.0000, 63.7500, 64.5000],
+                    [42.7500, 43.2500, 43.7500],
+                ],
+            ],
+        ]
+        self.assertTrue(
+            np.array_equal(
+                nn.MaxPool2d(kernel_size=(2, 4), stride=(3, 1), padding=(1, 2))(x),
+                expected_irregular_max_pool_output,
+            )
+        )
+        self.assertTrue(
+            np.allclose(
+                nn.AvgPool2d(kernel_size=(2, 4), stride=(3, 1), padding=(1, 2))(x),
+                expected_irregular_average_pool_output,
+            )
+        )
+        # Test repr
+        self.assertEqual(
+            str(nn.MaxPool1d(kernel_size=3, padding=2)),
+            "MaxPool1d(kernel_size=(3,), stride=(3,), padding=(2,))",
+        )
+        self.assertEqual(
+            str(nn.AvgPool1d(kernel_size=2, stride=3)),
+            "AvgPool1d(kernel_size=(2,), stride=(3,), padding=(0,))",
+        )
+        self.assertEqual(
+            str(nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
+            "MaxPool2d(kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))",
+        )
+        self.assertEqual(
+            str(nn.AvgPool2d(kernel_size=(1, 2), stride=2, padding=(1, 2))),
+            "AvgPool2d(kernel_size=(1, 2), stride=(2, 2), padding=(1, 2))",
+        )
+        # Test 3d pooling
+        x = mx.array(
+            [
+                [
+                    [
+                        [[0, 1, 2], [3, 4, 5], [6, 7, 8]],
+                        [[9, 10, 11], [12, 13, 14], [15, 16, 17]],
+                        [[18, 19, 20], [21, 22, 23], [24, 25, 26]],
+                    ],
+                    [
+                        [[27, 28, 29], [30, 31, 32], [33, 34, 35]],
+                        [[36, 37, 38], [39, 40, 41], [42, 43, 44]],
+                        [[45, 46, 47], [48, 49, 50], [51, 52, 53]],
+                    ],
+                ]
+            ]
+        )
+        expected_max_pool_output_no_padding_stride_1 = [
+            [[[[39, 40, 41], [42, 43, 44]], [[48, 49, 50], [51, 52, 53]]]]
+        ]
+
+        expected_max_pool_output_no_padding_stride_2 = [[[[[39, 40, 41]]]]]
+        expected_max_pool_output_padding_1 = [
+            [
+                [[[0, 1, 2], [6, 7, 8]], [[18, 19, 20], [24, 25, 26]]],
+                [[[27, 28, 29], [33, 34, 35]], [[45, 46, 47], [51, 52, 53]]],
+            ]
+        ]
+        expected_irregular_max_pool_output = [
+            [
+                [[[9, 10, 11], [12, 13, 14], [15, 16, 17]]],
+                [[[36, 37, 38], [39, 40, 41], [42, 43, 44]]],
+            ]
+        ]
+
+        self.assertTrue(
+            np.array_equal(
+                nn.MaxPool3d(kernel_size=2, stride=1, padding=0)(x),
+                expected_max_pool_output_no_padding_stride_1,
+            )
+        )
+        self.assertTrue(
+            np.array_equal(
+                nn.MaxPool3d(kernel_size=2, stride=2, padding=0)(x),
+                expected_max_pool_output_no_padding_stride_2,
+            )
+        )
+        self.assertTrue(
+            np.array_equal(
+                nn.MaxPool3d(kernel_size=2, stride=2, padding=1)(x),
+                expected_max_pool_output_padding_1,
+            )
+        )
+        self.assertTrue(
+            np.array_equal(
+                nn.MaxPool3d(kernel_size=(1, 2, 1), stride=(1, 2, 1))(x),
+                expected_irregular_max_pool_output,
+            )
+        )
+        self.assertEqual(
+            str(nn.MaxPool3d(kernel_size=3, stride=3, padding=2)),
+            "MaxPool3d(kernel_size=(3, 3, 3), stride=(3, 3, 3), padding=(2, 2, 2))",
+        )
+
+        expected_avg_pool_output_no_padding_stride_1 = [
+            [
+                [
+                    [[19.5, 20.5, 21.5], [22.5, 23.5, 24.5]],
+                    [[28.5, 29.5, 30.5], [31.5, 32.5, 33.5]],
+                ]
+            ]
+        ]
+
+        expected_avg_pool_output_no_padding_stride_2 = [[[[[19.5, 20.5, 21.5]]]]]
+        expected_avg_pool_output_padding_1 = [
+            [
+                [
+                    [[0, 0.125, 0.25], [1.125, 1.375, 1.625]],
+                    [[3.375, 3.625, 3.875], [9, 9.5, 10]],
+                ],
+                [
+                    [[3.375, 3.5, 3.625], [7.875, 8.125, 8.375]],
+                    [[10.125, 10.375, 10.625], [22.5, 23, 23.5]],
+                ],
+            ]
+        ]
+        expected_irregular_avg_pool_output = [
+            [
+                [[[4.5, 5.5, 6.5], [7.5, 8.5, 9.5], [10.5, 11.5, 12.5]]],
+                [[[31.5, 32.5, 33.5], [34.5, 35.5, 36.5], [37.5, 38.5, 39.5]]],
+            ]
+        ]
+
+        self.assertTrue(
+            np.array_equal(
+                nn.AvgPool3d(kernel_size=2, stride=1, padding=0)(x),
+                expected_avg_pool_output_no_padding_stride_1,
+            )
+        )
+        self.assertTrue(
+            np.array_equal(
+                nn.AvgPool3d(kernel_size=2, stride=2, padding=0)(x),
+                expected_avg_pool_output_no_padding_stride_2,
+            )
+        )
+        self.assertTrue(
+            np.array_equal(
+                nn.AvgPool3d(kernel_size=2, stride=2, padding=1)(x),
+                expected_avg_pool_output_padding_1,
+            )
+        )
+        self.assertTrue(
+            np.array_equal(
+                nn.AvgPool3d(kernel_size=(1, 2, 1), stride=(1, 2, 1))(x),
+                expected_irregular_avg_pool_output,
+            )
+        )
+        self.assertEqual(
+            str(nn.AvgPool3d(kernel_size=3, stride=3, padding=2)),
+            "AvgPool3d(kernel_size=(3, 3, 3), stride=(3, 3, 3), padding=(2, 2, 2))",
+        )
+
+    def test_set_dtype(self):
+        def assert_dtype(layer, dtype):
+            for k, v in tree_flatten(layer.parameters()):
+                self.assertEqual(v.dtype, dtype, f"dtype mismatch for {k}")
+
+        layer = nn.Linear(input_dims=4, output_dims=8, bias=True)
+        assert_dtype(layer, mx.float32)
+
+        layer.set_dtype(mx.bfloat16)
+        assert_dtype(layer, mx.bfloat16)
+
+        layer.set_dtype(mx.float32, lambda x: False)
+        assert_dtype(layer, mx.bfloat16)
+
+        layer.set_dtype(mx.int32, lambda x: True)
+        assert_dtype(layer, mx.int32)
+
+        layer.set_dtype(mx.int64, predicate=None)
+        assert_dtype(layer, mx.int64)
+
+        layer.set_dtype(mx.int16, lambda x: mx.issubdtype(x, mx.integer))
+        assert_dtype(layer, mx.int16)
+
+    def test_rnn(self):
+        layer = nn.RNN(input_size=5, hidden_size=12, bias=True)
+        inp = mx.random.normal((2, 25, 5))
+
+        h_out = layer(inp)
+        self.assertEqual(h_out.shape, (2, 25, 12))
+
+        layer = nn.RNN(
+            5,
+            12,
+            bias=False,
+            nonlinearity=lambda x: mx.maximum(0, x),
+        )
+
+        h_out = layer(inp)
+        self.assertEqual(h_out.shape, (2, 25, 12))
+
+        with self.assertRaises(ValueError):
+            nn.RNN(5, 12, nonlinearity="tanh")
+
+        inp = mx.random.normal((44, 5))
+        h_out = layer(inp)
+        self.assertEqual(h_out.shape, (44, 12))
+
+        h_out = layer(inp, hidden=h_out[-1, :])
+        self.assertEqual(h_out.shape, (44, 12))
+
+    def test_gru(self):
+        layer = nn.GRU(5, 12, bias=True)
+        inp = mx.random.normal((2, 25, 5))
+
+        h_out = layer(inp)
+        self.assertEqual(h_out.shape, (2, 25, 12))
+
+        h_out = layer(inp, hidden=h_out[:, -1, :])
+        self.assertEqual(h_out.shape, (2, 25, 12))
+
+        inp = mx.random.normal((44, 5))
+        h_out = layer(inp)
+        self.assertEqual(h_out.shape, (44, 12))
+
+        h_out = layer(inp, h_out[-1, :])
+        self.assertEqual(h_out.shape, (44, 12))
+
+    def test_lstm(self):
+        layer = nn.LSTM(5, 12)
+        inp = mx.random.normal((2, 25, 5))
+
+        h_out, c_out = layer(inp)
+        self.assertEqual(h_out.shape, (2, 25, 12))
+        self.assertEqual(c_out.shape, (2, 25, 12))
+
+        h_out, c_out = layer(inp, hidden=h_out[:, -1, :], cell=c_out[:, -1, :])
+        self.assertEqual(h_out.shape, (2, 25, 12))
+        self.assertEqual(c_out.shape, (2, 25, 12))
+
+        inp = mx.random.normal((44, 5))
+        h_out, c_out = layer(inp)
+        self.assertEqual(h_out.shape, (44, 12))
+        self.assertEqual(c_out.shape, (44, 12))
+
+        inp = mx.random.normal((44, 5))
+        h_out, c_out = layer(inp, hidden=h_out[-1, :], cell=c_out[-1, :])
+        self.assertEqual(h_out.shape, (44, 12))
+        self.assertEqual(c_out.shape, (44, 12))
+
+    def test_quantized_embedding(self):
+        emb = nn.Embedding(32, 256)
+        qemb = nn.QuantizedEmbedding.from_embedding(emb, bits=8)
+        x = mx.array([2, 6, 9, 3, 0, 3])
+        y = emb(x)
+        yq = qemb(x)
+        self.assertLess((y - yq).abs().max(), qemb.scales.max())
+
+        x = mx.random.uniform(shape=(2, 256))
+        y = emb.as_linear(x)
+        yq = qemb.as_linear(x)
+
+        def cosine(a, b):
+            ab = (a * b).sum(-1)
+            aa = mx.linalg.norm(a, axis=-1)
+            bb = mx.linalg.norm(b, axis=-1)
+            return ab / aa / bb
+
+        self.assertGreater(cosine(y, yq).min(), 0.99)
+
+    def test_causal_mask(self):
+        mask = nn.MultiHeadAttention.create_additive_causal_mask(4, mx.float16)
+        self.assertFalse(mx.any(mx.isnan(mask)))
+        self.assertTrue(mask[0, -1].item() < 0)
+
+        mask = nn.MultiHeadAttention.create_additive_causal_mask(4, mx.bfloat16)
+        self.assertFalse(mx.any(mx.isnan(mask)))
+        self.assertTrue(mask[0, -1].item() < 0)
+
+    def test_attention(self):
+        attn = nn.MultiHeadAttention(32, 4)
+        x = mx.random.normal(shape=(2, 5, 32))
+        out = attn(x, x, x)
+        self.assertEqual(out.shape, x.shape)
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_ops.py b/ml-stable-diffusion/mlx/python/tests/test_ops.py
new file mode 100644
index 0000000000000000000000000000000000000000..e60952aa73a5c6356545d2131a60eca767886195
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_ops.py
@@ -0,0 +1,3139 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import math
+import os
+import unittest
+from itertools import permutations, product
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+
+def np_wrap_between(x, a):
+    """Wraps `x` between `[-a, a]`."""
+    two_a = 2 * a
+    zero = 0
+    rem = np.remainder(np.add(x, a), two_a)
+    if isinstance(rem, np.ndarray):
+        rem = np.select(rem < zero, np.add(rem, two_a), rem)
+    else:
+        rem = np.add(rem, two_a) if rem < zero else rem
+    return np.subtract(rem, a)
+
+
+def np_logaddexp(x1: np.ndarray, x2: np.ndarray):
+    amax = np.maximum(x1, x2)
+    if np.issubdtype(x1.dtype, np.floating):
+        delta = np.subtract(x1, x2)
+        if isinstance(delta, np.ndarray):
+            return np.select(
+                np.isnan(delta),
+                np.add(x1, x2),
+                np.add(amax, np.log1p(np.exp(np.negative(np.abs(delta))))),
+            )
+        else:
+            return (
+                np.add(x1, x2)
+                if np.isnan(delta)
+                else np.add(amax, np.log1p(np.exp(np.negative(np.abs(delta)))))
+            )
+    else:
+        delta = np.subtract(np.add(x1, x2), np.multiply(amax, 2))
+        out = np.add(amax, np.log1p(np.exp(delta)))
+        return np.real(out) + 1j * np_wrap_between(np.imag(out), np.pi)
+
+
+def np_cumlogaddexp(x1: np.ndarray, axis: int = -1):
+    out = x1.copy()
+    for i in range(1, out.shape[axis]):
+        out[i] = np_logaddexp(out[i], out[i - 1])
+    return out
+
+
+class TestOps(mlx_tests.MLXTestCase):
+    def test_full_ones_zeros(self):
+        x = mx.full(2, 3.0)
+        self.assertEqual(x.shape, (2,))
+        self.assertEqual(x.tolist(), [3.0, 3.0])
+
+        x = mx.full((2, 3), 2.0)
+        self.assertEqual(x.dtype, mx.float32)
+        self.assertEqual(x.shape, (2, 3))
+        self.assertEqual(x.tolist(), [[2, 2, 2], [2, 2, 2]])
+
+        x = mx.full([3, 2], mx.array([False, True]))
+        self.assertEqual(x.dtype, mx.bool_)
+        self.assertEqual(x.tolist(), [[False, True], [False, True], [False, True]])
+
+        x = mx.full([3, 2], mx.array([2.0, 3.0]))
+        self.assertEqual(x.tolist(), [[2, 3], [2, 3], [2, 3]])
+
+        x = mx.zeros(2)
+        self.assertEqual(x.shape, (2,))
+        self.assertEqual(x.tolist(), [0.0, 0.0])
+
+        x = mx.ones(2)
+        self.assertEqual(x.shape, (2,))
+        self.assertEqual(x.tolist(), [1.0, 1.0])
+
+        for t in [mx.bool_, mx.int32, mx.float32]:
+            x = mx.zeros([2, 2], t)
+            self.assertEqual(x.dtype, t)
+            self.assertTrue(mx.array_equal(x, mx.array([[0, 0], [0, 0]])))
+            y = mx.zeros_like(x)
+            self.assertEqual(y.dtype, t)
+            self.assertTrue(mx.array_equal(y, x))
+
+            x = mx.ones([2, 2], t)
+            self.assertEqual(x.dtype, t)
+            self.assertTrue(mx.array_equal(x, mx.array([[1, 1], [1, 1]])))
+            y = mx.ones_like(x)
+            self.assertEqual(y.dtype, t)
+            self.assertTrue(mx.array_equal(y, x))
+
+    def test_scalar_inputs(self):
+        # Check combinations of python types
+        a = mx.add(False, True)
+        self.assertEqual(a.dtype, mx.bool_)
+        self.assertEqual(a.item(), True)
+
+        a = mx.add(1, 2)
+        self.assertEqual(a.dtype, mx.int32)
+        self.assertEqual(a.item(), 3)
+
+        a = mx.add(1.0, 2.0)
+        self.assertEqual(a.dtype, mx.float32)
+        self.assertEqual(a.item(), 3.0)
+
+        a = mx.add(True, 2)
+        self.assertEqual(a.dtype, mx.int32)
+        self.assertEqual(a.item(), 3)
+
+        a = mx.add(True, 2.0)
+        self.assertEqual(a.dtype, mx.float32)
+        self.assertEqual(a.item(), 3.0)
+
+        a = mx.add(1, 2.0)
+        self.assertEqual(a.dtype, mx.float32)
+        self.assertEqual(a.item(), 3.0)
+
+        a = mx.add(2, True)
+        self.assertEqual(a.dtype, mx.int32)
+        self.assertEqual(a.item(), 3)
+
+        a = mx.add(2.0, True)
+        self.assertEqual(a.dtype, mx.float32)
+        self.assertEqual(a.item(), 3.0)
+
+        a = mx.add(2.0, 1)
+        self.assertEqual(a.dtype, mx.float32)
+        self.assertEqual(a.item(), 3.0)
+
+        # Check combinations with mlx arrays
+        a = mx.add(mx.array(True), False)
+        self.assertEqual(a.dtype, mx.bool_)
+        self.assertEqual(a.item(), True)
+
+        a = mx.add(mx.array(1), False)
+        self.assertEqual(a.dtype, mx.int32)
+        self.assertEqual(a.item(), 1.0)
+
+        # Edge case: take the type of the scalar
+        a = mx.add(mx.array(True), 1)
+        self.assertEqual(a.dtype, mx.int32)
+        self.assertEqual(a.item(), 2)
+
+        a = mx.add(mx.array(1.0), 1)
+        self.assertEqual(a.dtype, mx.float32)
+        self.assertEqual(a.item(), 2.0)
+
+        a = mx.add(1, mx.array(1.0))
+        self.assertEqual(a.dtype, mx.float32)
+        self.assertEqual(a.item(), 2.0)
+
+        binary_ops = [
+            "add",
+            "subtract",
+            "multiply",
+            "divide",
+            "floor_divide",
+            "remainder",
+            "equal",
+            "not_equal",
+            "less",
+            "greater",
+            "less_equal",
+            "greater_equal",
+            "maximum",
+            "minimum",
+        ]
+
+        for op in binary_ops:
+            npop = getattr(np, op)
+            mlxop = getattr(mx, op)
+
+            # Avoid subtract from bool and divide by 0
+            for x in [-1, 0, 1, -1.0, 1.0]:
+                for y in [True, -1, 1, -1.0, 1.0]:
+                    self.assertEqual(npop(x, y).item(), mlxop(x, y).item())
+
+    def test_add(self):
+        x = mx.array(1)
+        y = mx.array(1)
+        z = mx.add(x, y)
+        self.assertEqual(z.item(), 2)
+
+        x = mx.array(False, mx.bool_)
+        z = x + 1
+        self.assertEqual(z.dtype, mx.int32)
+        self.assertEqual(z.item(), 1)
+        z = 2 + x
+        self.assertEqual(z.dtype, mx.int32)
+        self.assertEqual(z.item(), 2)
+
+        x = mx.array(1, mx.uint32)
+        z = x + 3
+        self.assertEqual(z.dtype, mx.uint32)
+        self.assertEqual(z.item(), 4)
+
+        z = 3 + x
+        self.assertEqual(z.dtype, mx.uint32)
+        self.assertEqual(z.item(), 4)
+
+        z = x + 3.0
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 4.0)
+
+        z = 3.0 + x
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 4.0)
+
+        x = mx.array(1, mx.int64)
+        z = x + 3
+        self.assertEqual(z.dtype, mx.int64)
+        self.assertEqual(z.item(), 4)
+        z = 3 + x
+        self.assertEqual(z.dtype, mx.int64)
+        self.assertEqual(z.item(), 4)
+        z = x + 3.0
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 4.0)
+        z = 3.0 + x
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 4.0)
+
+        x = mx.array(1, mx.float32)
+        z = x + 3
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 4)
+        z = 3 + x
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 4)
+
+    def test_subtract(self):
+        x = mx.array(4.0)
+        y = mx.array(3.0)
+
+        z = mx.subtract(x, y)
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 1.0)
+
+        z = x - 3.0
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 1.0)
+
+        z = 5.0 - x
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 1.0)
+
+    def test_multiply(self):
+        x = mx.array(2.0)
+        y = mx.array(3.0)
+
+        z = mx.multiply(x, y)
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 6.0)
+
+        z = x * 3.0
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 6.0)
+
+        z = 3.0 * x
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 6.0)
+
+    def test_divide(self):
+        x = mx.array(2.0)
+        y = mx.array(4.0)
+
+        z = mx.divide(x, y)
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 0.5)
+
+        z = x / 4.0
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 0.5)
+
+        z = 1.0 / x
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 0.5)
+
+        x = x.astype(mx.float16)
+        z = x / 4.0
+        self.assertEqual(z.dtype, mx.float16)
+
+        x = x.astype(mx.float16)
+        z = 4.0 / x
+        self.assertEqual(z.dtype, mx.float16)
+
+        x = mx.array(5)
+        y = mx.array(2)
+        z = x / y
+        self.assertEqual(z.dtype, mx.float32)
+        self.assertEqual(z.item(), 2.5)
+
+        z = x // y
+        self.assertEqual(z.dtype, mx.int32)
+        self.assertEqual(z.item(), 2)
+
+    def test_remainder(self):
+        for dt in [mx.int32, mx.float32]:
+            x = mx.array(2, dtype=dt)
+            y = mx.array(4, dtype=dt)
+
+            z1 = mx.remainder(x, y)
+            z2 = mx.remainder(y, x)
+            self.assertEqual(z1.dtype, dt)
+            self.assertEqual(z1.item(), 2)
+            self.assertEqual(z2.item(), 0)
+
+            z = x % 4
+            self.assertEqual(z.dtype, dt)
+            self.assertEqual(z.item(), 2)
+
+            z = 1 % x
+            self.assertEqual(z.dtype, dt)
+            self.assertEqual(z.item(), 1)
+
+            z = -1 % x
+            self.assertEqual(z.dtype, dt)
+            self.assertEqual(z.item(), 1)
+
+            z = -1 % -x
+            self.assertEqual(z.dtype, dt)
+            self.assertEqual(z.item(), -1)
+
+            x = mx.arange(10).astype(dt) - 5
+            y = x % 5
+            z = x % -5
+            self.assertEqual(y.tolist(), [0, 1, 2, 3, 4, 0, 1, 2, 3, 4])
+            self.assertEqual(z.tolist(), [0, -4, -3, -2, -1, 0, -4, -3, -2, -1])
+
+        z = -mx.ones(64) % mx.full(64, 2)
+        self.assertTrue(mx.array_equal(z, mx.ones(64)))
+
+    def test_comparisons(self):
+        a = mx.array([0.0, 1.0, 5.0])
+        b = mx.array([-1.0, 2.0, 5.0])
+
+        self.assertEqual(mx.less(a, b).tolist(), [False, True, False])
+        self.assertEqual(mx.less_equal(a, b).tolist(), [False, True, True])
+        self.assertEqual(mx.greater(a, b).tolist(), [True, False, False])
+        self.assertEqual(mx.greater_equal(a, b).tolist(), [True, False, True])
+
+        self.assertEqual(mx.less(a, 5).tolist(), [True, True, False])
+        self.assertEqual(mx.less(5, a).tolist(), [False, False, False])
+        self.assertEqual(mx.less_equal(5, a).tolist(), [False, False, True])
+        self.assertEqual(mx.greater(a, 1).tolist(), [False, False, True])
+        self.assertEqual(mx.greater_equal(a, 1).tolist(), [False, True, True])
+
+        a = mx.array([0.0, 1.0, 5.0, -1.0])
+        b = mx.array([0.0, 2.0, 5.0, 3.0])
+        self.assertEqual(mx.equal(a, b).tolist(), [True, False, True, False])
+        self.assertEqual(mx.not_equal(a, b).tolist(), [False, True, False, True])
+
+    def test_array_equal(self):
+        x = mx.array([1, 2, 3, 4])
+        y = mx.array([1, 2, 3, 4])
+        self.assertTrue(mx.array_equal(x, y))
+
+        y = mx.array([1, 2, 4, 5])
+        self.assertFalse(mx.array_equal(x, y))
+
+        y = mx.array([1, 2, 3])
+        self.assertFalse(mx.array_equal(x, y))
+
+        # Can still be equal with different types
+        y = mx.array([1.0, 2.0, 3.0, 4.0])
+        self.assertTrue(mx.array_equal(x, y))
+
+        x = mx.array([0.0, float("nan")])
+        y = mx.array([0.0, float("nan")])
+        self.assertFalse(mx.array_equal(x, y))
+        self.assertTrue(mx.array_equal(x, y, equal_nan=True))
+
+        for t in [mx.float32, mx.float16, mx.bfloat16, mx.complex64]:
+            with self.subTest(type=t):
+                x = mx.array([0.0, float("nan")]).astype(t)
+                y = mx.array([0.0, float("nan")]).astype(t)
+                self.assertFalse(mx.array_equal(x, y))
+                self.assertTrue(mx.array_equal(x, y, equal_nan=True))
+
+    def test_isnan(self):
+        x = mx.array([0.0, float("nan")])
+        self.assertEqual(mx.isnan(x).tolist(), [False, True])
+
+        x = mx.array([0.0, float("nan")]).astype(mx.float16)
+        self.assertEqual(mx.isnan(x).tolist(), [False, True])
+
+        x = mx.array([0.0, float("nan")]).astype(mx.bfloat16)
+        self.assertEqual(mx.isnan(x).tolist(), [False, True])
+
+        x = mx.array([0.0, float("nan")]).astype(mx.complex64)
+        self.assertEqual(mx.isnan(x).tolist(), [False, True])
+
+        self.assertEqual(mx.isnan(0 * mx.array(float("inf"))).tolist(), True)
+
+    def test_isinf(self):
+        x = mx.array([0.0, float("inf")])
+        self.assertEqual(mx.isinf(x).tolist(), [False, True])
+
+        x = mx.array([0.0, float("inf")]).astype(mx.float16)
+        self.assertEqual(mx.isinf(x).tolist(), [False, True])
+
+        x = mx.array([0.0, float("inf")]).astype(mx.bfloat16)
+        self.assertEqual(mx.isinf(x).tolist(), [False, True])
+
+        x = mx.array([0.0, float("inf")]).astype(mx.complex64)
+        self.assertEqual(mx.isinf(x).tolist(), [False, True])
+
+        self.assertEqual(mx.isinf(0 * mx.array(float("inf"))).tolist(), False)
+
+        x = mx.array([-2147483648, 0, 2147483647], dtype=mx.int32)
+        result = mx.isinf(x)
+        self.assertEqual(result.tolist(), [False, False, False])
+
+        x = mx.array([-32768, 0, 32767], dtype=mx.int16)
+        result = mx.isinf(x)
+        self.assertEqual(result.tolist(), [False, False, False])
+
+    def test_isfinite(self):
+        x = mx.array([0.0, float("inf"), float("nan")])
+        self.assertEqual(mx.isfinite(x).tolist(), [True, False, False])
+
+        x = x.astype(mx.float16)
+        self.assertEqual(mx.isfinite(x).tolist(), [True, False, False])
+
+        x = x.astype(mx.bfloat16)
+        self.assertEqual(mx.isfinite(x).tolist(), [True, False, False])
+
+    def test_tri(self):
+        for shape in [[4], [4, 4], [2, 10]]:
+            for diag in [-1, 0, 1, -2]:
+                self.assertCmpNumpy(shape, mx.tri, np.tri, k=diag)
+        self.assertEqual(mx.tri(1, 1).dtype, mx.float32)
+        self.assertEqual(mx.tri(1, 1, dtype=mx.bfloat16).dtype, mx.bfloat16)
+
+    def test_tril(self):
+        for diag in [-1, 0, 1, -2]:
+            self.assertCmpNumpy([(10, 10)], mx.tril, np.tril, k=diag)
+
+        with self.assertRaises(Exception):
+            mx.tril(mx.zeros((1)))
+
+    def test_triu(self):
+        for diag in [-1, 0, 1, -2]:
+            self.assertCmpNumpy([(10, 10)], mx.triu, np.triu, k=diag)
+        with self.assertRaises(Exception):
+            mx.triu(mx.zeros((1)))
+
+    def test_minimum(self):
+        x = mx.array([0.0, -5, 10.0])
+        y = mx.array([1.0, -7.0, 3.0])
+
+        expected = [0, -7, 3]
+        self.assertListEqual(mx.minimum(x, y).tolist(), expected)
+
+        a = mx.array([float("nan")])
+        b = mx.array([0.0])
+        self.assertTrue(math.isnan(mx.minimum(a, b).item()))
+        self.assertTrue(math.isnan(mx.minimum(b, a).item()))
+
+    def test_maximum(self):
+        x = mx.array([0.0, -5, 10.0])
+        y = mx.array([1.0, -7.0, 3.0])
+
+        expected = [1, -5, 10]
+        self.assertListEqual(mx.maximum(x, y).tolist(), expected)
+
+        a = mx.array([float("nan")])
+        b = mx.array([0.0])
+        self.assertTrue(math.isnan(mx.maximum(a, b).item()))
+        self.assertTrue(math.isnan(mx.maximum(b, a).item()))
+
+    def test_floor(self):
+        x = mx.array([-22.03, 19.98, -27, 9, 0.0, -np.inf, np.inf])
+        expected = [-23, 19, -27, 9, 0, -np.inf, np.inf]
+        self.assertListEqual(mx.floor(x).tolist(), expected)
+
+        with self.assertRaises(ValueError):
+            mx.floor(mx.array([22 + 3j, 19 + 98j]))
+
+    def test_ceil(self):
+        x = mx.array([-22.03, 19.98, -27, 9, 0.0, -np.inf, np.inf])
+        expected = [-22, 20, -27, 9, 0, -np.inf, np.inf]
+        self.assertListEqual(mx.ceil(x).tolist(), expected)
+
+        with self.assertRaises(ValueError):
+            mx.ceil(mx.array([22 + 3j, 19 + 98j]))
+
+    def test_isposinf(self):
+        x = mx.array([0.0, float("-inf")])
+        self.assertEqual(mx.isposinf(x).tolist(), [False, False])
+
+        x = mx.array([0.0, float("-inf")]).astype(mx.float16)
+        self.assertEqual(mx.isposinf(x).tolist(), [False, False])
+
+        x = mx.array([0.0, float("-inf")]).astype(mx.bfloat16)
+        self.assertEqual(mx.isposinf(x).tolist(), [False, False])
+
+        x = mx.array([0.0, float("-inf")]).astype(mx.complex64)
+        self.assertEqual(mx.isposinf(x).tolist(), [False, False])
+
+        self.assertEqual(mx.isposinf(0 * mx.array(float("inf"))).tolist(), False)
+
+        x = mx.array([-2147483648, 0, 2147483647], dtype=mx.int32)
+        result = mx.isposinf(x)
+        self.assertEqual(result.tolist(), [False, False, False])
+
+        x = mx.array([-32768, 0, 32767], dtype=mx.int16)
+        result = mx.isposinf(x)
+        self.assertEqual(result.tolist(), [False, False, False])
+
+    def test_isneginf(self):
+        x = mx.array([0.0, float("-inf")])
+        self.assertEqual(mx.isneginf(x).tolist(), [False, True])
+
+        x = mx.array([0.0, float("-inf")]).astype(mx.float16)
+        self.assertEqual(mx.isneginf(x).tolist(), [False, True])
+
+        x = mx.array([0.0, float("-inf")]).astype(mx.bfloat16)
+        self.assertEqual(mx.isneginf(x).tolist(), [False, True])
+
+        x = mx.array([0.0, float("-inf")]).astype(mx.complex64)
+        self.assertEqual(mx.isneginf(x).tolist(), [False, True])
+
+        self.assertEqual(mx.isneginf(0 * mx.array(float("inf"))).tolist(), False)
+
+        x = mx.array([-2147483648, 0, 2147483647], dtype=mx.int32)
+        result = mx.isneginf(x)
+        self.assertEqual(result.tolist(), [False, False, False])
+
+        x = mx.array([-32768, 0, 32767], dtype=mx.int16)
+        result = mx.isneginf(x)
+        self.assertEqual(result.tolist(), [False, False, False])
+
+    def test_round(self):
+        # float
+        x = mx.array(
+            [0.5, -0.5, 1.5, -1.5, -21.03, 19.98, -27, 9, 0.0, -np.inf, np.inf]
+        )
+        expected = [0, -0, 2, -2, -21, 20, -27, 9, 0, -np.inf, np.inf]
+        self.assertListEqual(mx.round(x).tolist(), expected)
+
+        # complex
+        y = mx.round(mx.array([22.2 + 3.6j, 18.5 + 98.2j]))
+        self.assertListEqual(y.tolist(), [22 + 4j, 18 + 98j])
+
+        # decimals
+        y0 = mx.round(mx.array([15, 122], mx.int32), decimals=0)
+        y1 = mx.round(mx.array([15, 122], mx.int32), decimals=-1)
+        y2 = mx.round(mx.array([15, 122], mx.int32), decimals=-2)
+        self.assertEqual(y0.dtype, mx.int32)
+        self.assertEqual(y1.dtype, mx.int32)
+        self.assertEqual(y2.dtype, mx.int32)
+        self.assertListEqual(y0.tolist(), [15, 122])
+        self.assertListEqual(y1.tolist(), [20, 120])
+        self.assertListEqual(y2.tolist(), [0, 100])
+
+        y1 = mx.round(mx.array([1.537, 1.471], mx.float32), decimals=1)
+        y2 = mx.round(mx.array([1.537, 1.471], mx.float32), decimals=2)
+        self.assertTrue(mx.allclose(y1, mx.array([1.5, 1.5])))
+        self.assertTrue(mx.allclose(y2, mx.array([1.54, 1.47])))
+
+        # check round to nearest for different types
+        dtypes = [mx.bfloat16, mx.float16, mx.float32]
+        for dtype in dtypes:
+            x = mx.arange(10, dtype=dtype) - 4.5
+            x = mx.round(x)
+            self.assertEqual(
+                x.astype(mx.float32).tolist(),
+                [-4.0, -4.0, -2.0, -2.0, -0.0, 0.0, 2.0, 2.0, 4.0, 4.0],
+            )
+
+    def test_transpose_noargs(self):
+        x = mx.array([[0, 1, 1], [1, 0, 0]])
+
+        expected = [
+            [0, 1],
+            [1, 0],
+            [1, 0],
+        ]
+
+        self.assertListEqual(mx.transpose(x).tolist(), expected)
+
+    def test_transpose_axis(self):
+        x = mx.array(
+            [
+                [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]],
+                [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]],
+            ]
+        )
+        expected = [
+            [[0, 4, 8], [1, 5, 9], [2, 6, 10], [3, 7, 11]],
+            [[12, 16, 20], [13, 17, 21], [14, 18, 22], [15, 19, 23]],
+        ]
+
+        self.assertListEqual(mx.transpose(x, axes=(0, 2, 1)).tolist(), expected)
+
+    def test_move_swap_axes(self):
+        x = mx.zeros((2, 3, 4))
+        self.assertEqual(mx.moveaxis(x, 0, 2).shape, (3, 4, 2))
+        self.assertEqual(x.moveaxis(0, 2).shape, (3, 4, 2))
+        self.assertEqual(mx.swapaxes(x, 0, 2).shape, (4, 3, 2))
+        self.assertEqual(x.swapaxes(0, 2).shape, (4, 3, 2))
+
+    def test_sum(self):
+        x = mx.array(
+            [
+                [1, 2],
+                [3, 3],
+            ]
+        )
+        self.assertEqual(mx.sum(x).item(), 9)
+        y = mx.sum(x, keepdims=True)
+        self.assertEqual(y, mx.array(9))
+        self.assertEqual(y.shape, (1, 1))
+
+        self.assertEqual(mx.sum(x, axis=0).tolist(), [4, 5])
+        self.assertEqual(mx.sum(x, axis=1).tolist(), [3, 6])
+
+        x_npy = np.arange(3 * 5 * 4 * 7).astype(np.float32)
+        x_npy = np.reshape(x_npy, (3, 5, 4, 7))
+        x_mlx = mx.array(x_npy)
+
+        for axis in (None, 0, 1, 2, 3, (0, 1), (2, 3), (1, 2, 3)):
+            sum_npy = np.sum(x_npy, axis=axis)
+            sum_mlx = np.asarray(mx.sum(x_mlx, axis=axis))
+            self.assertListEqual(list(sum_npy.shape), list(sum_mlx.shape))
+            self.assertTrue(np.all(sum_npy == sum_mlx))
+
+        x_npy = np.array([1.0, 2.0, 3.0, 4.0]).astype(np.float32)
+        x_mlx = mx.array(x_npy)
+
+        y_npy = x_npy[0:4:2]
+        y_npy = np.broadcast_to(y_npy, (2, 2))
+
+        y_mlx = x_mlx[0:4:2]
+        y_mlx = mx.broadcast_to(y_mlx, (2, 2))
+
+        for axis in (None, 0, 1, (0, 1)):
+            sum_npy = np.sum(y_npy, axis=axis)
+            sum_mlx = np.asarray(mx.sum(y_mlx, axis=axis))
+            self.assertListEqual(list(sum_npy.shape), list(sum_mlx.shape))
+            self.assertTrue(np.all(sum_npy == sum_mlx))
+
+        x_npy = (
+            np.arange(3 * 2 * 3 * 3 * 3 * 3)
+            .reshape(3, 2, 3, 3, 3, 3)
+            .astype(np.float32)
+        )
+        x_mlx = mx.array(x_npy)
+
+        y_mlx = x_mlx.sum(axis=(0, 1, 3, 4, 5))
+        y_npy = x_npy.sum(axis=(0, 1, 3, 4, 5))
+
+        self.assertTrue(np.array_equal(y_mlx, y_npy))
+
+    def test_prod(self):
+        x = mx.array(
+            [
+                [1, 2],
+                [3, 3],
+            ]
+        )
+        self.assertEqual(mx.prod(x).item(), 18)
+        y = mx.prod(x, keepdims=True)
+        self.assertEqual(y, mx.array(18))
+        self.assertEqual(y.shape, (1, 1))
+
+        self.assertEqual(mx.prod(x, axis=0).tolist(), [3, 6])
+        self.assertEqual(mx.prod(x, axis=1).tolist(), [2, 9])
+
+    def test_min_and_max(self):
+        x = mx.array(
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        )
+        self.assertEqual(mx.min(x).item(), 1)
+        self.assertEqual(mx.max(x).item(), 4)
+        y = mx.min(x, keepdims=True)
+        self.assertEqual(y.shape, (1, 1))
+        self.assertEqual(y, mx.array(1))
+
+        y = mx.max(x, keepdims=True)
+        self.assertEqual(y.shape, (1, 1))
+        self.assertEqual(y, mx.array(4))
+
+        self.assertEqual(mx.min(x, axis=0).tolist(), [1, 2])
+        self.assertEqual(mx.min(x, axis=1).tolist(), [1, 3])
+        self.assertEqual(mx.max(x, axis=0).tolist(), [3, 4])
+        self.assertEqual(mx.max(x, axis=1).tolist(), [2, 4])
+
+    def test_argmin_argmax(self):
+        data = np.random.rand(10, 12, 13)
+        x = mx.array(data)
+        for op in ["argmin", "argmax"]:
+            for axis in range(3):
+                for kd in [True, False]:
+                    a = getattr(mx, op)(x, axis, kd)
+                    b = getattr(np, op)(data, axis, keepdims=kd)
+                    self.assertEqual(a.tolist(), b.tolist())
+
+        for op in ["argmin", "argmax"]:
+            a = getattr(mx, op)(x, keepdims=True)
+            b = getattr(np, op)(data, keepdims=True)
+            self.assertEqual(a.tolist(), b.tolist())
+            a = getattr(mx, op)(x)
+            b = getattr(np, op)(data)
+            self.assertEqual(a.item(), b)
+
+    def test_broadcast(self):
+        a_npy = np.reshape(np.arange(200), (10, 20))
+        a_mlx = mx.array(a_npy)
+
+        b_npy = np.broadcast_to(a_npy, (30, 10, 20))
+        b_mlx = mx.broadcast_to(a_mlx, (30, 10, 20))
+        self.assertListEqual(list(b_npy.shape), list(b_mlx.shape))
+        self.assertTrue(np.array_equal(b_npy, b_mlx))
+
+        b_npy = np.broadcast_to(a_npy, (1, 10, 20))
+        b_mlx = mx.broadcast_to(a_mlx, (1, 10, 20))
+        self.assertListEqual(list(b_npy.shape), list(b_mlx.shape))
+        self.assertTrue(np.array_equal(b_npy, b_mlx))
+
+        b_npy = np.broadcast_to(1, (10, 20))
+        b_mlx = mx.broadcast_to(1, (10, 20))
+        self.assertListEqual(list(b_npy.shape), list(b_mlx.shape))
+        self.assertTrue(np.array_equal(b_npy, b_mlx))
+
+    def test_logsumexp(self):
+        def logsumexp(x, axes=None):
+            maxs = mx.max(x, axis=axes, keepdims=True)
+            return mx.log(mx.sum(mx.exp(x - maxs), axis=axes, keepdims=True)) + maxs
+
+        x = mx.array(
+            [
+                [1.0, 2.0],
+                [3.0, 4.0],
+            ]
+        )
+        self.assertTrue(math.isclose(mx.logsumexp(x).item(), logsumexp(x).item()))
+
+        x = mx.random.uniform(shape=(1025,))
+        self.assertTrue(mx.allclose(mx.logsumexp(x), logsumexp(x)))
+
+        # Transposed
+        x = mx.random.uniform(shape=(2, 2, 8))
+        x = x.swapaxes(0, 1)
+        self.assertTrue(mx.allclose(mx.logsumexp(x), logsumexp(x)))
+
+        # Broadcast
+        x = mx.broadcast_to(mx.random.uniform(shape=(2, 1, 8)), (2, 2, 8))
+        self.assertTrue(mx.allclose(mx.logsumexp(x), logsumexp(x)))
+
+        # Large
+        x = mx.random.uniform(shape=(1025,))
+        x = mx.broadcast_to(mx.random.uniform(shape=(2, 1, 8)), (2, 2, 8))
+        self.assertTrue(mx.allclose(mx.logsumexp(x), logsumexp(x)))
+
+    def test_mean(self):
+        x = mx.array(
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        )
+        self.assertEqual(mx.mean(x).item(), 2.5)
+        y = mx.mean(x, keepdims=True)
+        self.assertEqual(y, mx.array(2.5))
+        self.assertEqual(y.shape, (1, 1))
+
+        self.assertEqual(mx.mean(x, axis=0).tolist(), [2, 3])
+        self.assertEqual(mx.mean(x, axis=1).tolist(), [1.5, 3.5])
+
+    def test_var(self):
+        x = mx.array(
+            [
+                [1, 2],
+                [3, 4],
+            ]
+        )
+        self.assertEqual(mx.var(x).item(), 1.25)
+        y = mx.var(x, keepdims=True)
+        self.assertEqual(y, mx.array(1.25))
+        self.assertEqual(y.shape, (1, 1))
+
+        self.assertEqual(mx.var(x, axis=0).tolist(), [1.0, 1.0])
+        self.assertEqual(mx.var(x, axis=1).tolist(), [0.25, 0.25])
+
+        x = mx.array([1.0, 2.0])
+        out = mx.var(x, ddof=2)
+        self.assertEqual(out.item(), float("inf"))
+
+        x = mx.array([1.0, 2.0])
+        out = mx.var(x, ddof=3)
+        self.assertEqual(out.item(), float("inf"))
+
+    def test_std(self):
+        x = mx.random.uniform(shape=(5, 5))
+        x_np = np.array(x)
+        self.assertAlmostEqual(mx.std(x).item(), x_np.std().item(), places=6)
+
+    def test_abs(self):
+        a = mx.array([-1.0, 1.0, -2.0, 3.0])
+        result = mx.abs(a)
+        expected = np.abs(a, dtype=np.float32)
+        self.assertTrue(np.allclose(result, expected))
+
+        self.assertTrue(np.allclose(a.abs(), abs(a)))
+
+    def test_negative(self):
+        a = mx.array([-1.0, 1.0, -2.0, 3.0])
+        result = mx.negative(a)
+        expected = np.negative(a, dtype=np.float32)
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_sign(self):
+        a = mx.array([-1.0, 1.0, 0.0, -2.0, 3.0])
+        result = mx.sign(a)
+        expected = np.sign(a, dtype=np.float32)
+        self.assertTrue(np.allclose(result, expected))
+
+        a = mx.array([-1.0, 1.0, 0.0, -2.0, 3.0])
+        b = mx.array([-4.0, -3.0, 1.0, 0.0, 3.0])
+        c = a + b * 1j
+        result = mx.sign(c)
+        # np.sign differs in NumPy 1 and 2 so
+        # we manually implement the NumPy 2 version here.
+        expected = c / np.abs(c)
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_logical_not(self):
+        a = mx.array([-1.0, 1.0, 0.0, 1.0, -2.0, 3.0])
+        result = mx.logical_not(a)
+        expected = np.logical_not(a)
+        self.assertTrue(np.array_equal(result, expected))
+
+    def test_logical_and(self):
+        a = mx.array([True, False, True, False])
+        b = mx.array([True, True, False, False])
+        result = mx.logical_and(a, b)
+        expected = np.logical_and(a, b)
+        self.assertTrue(np.array_equal(result, expected))
+
+        # test overloaded operator
+        result = a & b
+        self.assertTrue(np.array_equal(result, expected))
+
+    def test_logical_or(self):
+        a = mx.array([True, False, True, False])
+        b = mx.array([True, True, False, False])
+        result = mx.logical_or(a, b)
+        expected = np.logical_or(a, b)
+        self.assertTrue(np.array_equal(result, expected))
+
+        # test overloaded operator
+        result = a | b
+        self.assertTrue(np.array_equal(result, expected))
+
+    def test_square(self):
+        a = mx.array([0.1, 0.5, 1.0, 10.0])
+        result = mx.square(a)
+        expected = np.square(a, dtype=np.float32)
+
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_sqrt(self):
+        a = mx.array([0.1, 0.5, 1.0, 10.0])
+        result = mx.sqrt(a)
+        expected = np.sqrt(a, dtype=np.float32)
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_rsqrt(self):
+        a = mx.array([0.1, 0.5, 1.0, 10.0])
+        result = mx.rsqrt(a)
+        expected = 1.0 / np.sqrt(a, dtype=np.float32)
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_reciprocal(self):
+        a = mx.array([0.1, 0.5, 1.0, 2.0])
+        result = mx.reciprocal(a)
+        expected = np.reciprocal(a, dtype=np.float32)
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_logaddexp(self):
+        a = mx.array([0, 1, 2, 9.0])
+        b = mx.array([1, 0, 4, 2.5])
+
+        result = mx.logaddexp(a, b)
+        expected = np.logaddexp(a, b, dtype=np.float32)
+
+        self.assertTrue(np.allclose(result, expected))
+
+        # Complex test
+
+        a = mx.array([0, 1, 2, 9.0]) + 1j
+        b = mx.array([1, 0, 4, 2.5]) + 1j
+
+        result = mx.logaddexp(a, b)
+        expected = np_logaddexp(np.array(a), np.array(b))
+
+        self.assertTrue(np.allclose(result, expected))
+
+        a = mx.array([float("nan")])
+        b = mx.array([0.0])
+        self.assertTrue(math.isnan(mx.logaddexp(a, b).item()))
+
+    def test_log(self):
+        a = mx.array([1, 0.5, 10, 100])
+        result = mx.log(a)
+        expected = np.log(a, dtype=np.float32)
+
+        self.assertTrue(np.allclose(result, expected))
+
+        a = mx.array(1.0) + 1j * mx.array(2.0)
+        result = mx.log(a)
+        expected = np.log(np.array(a))
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_log2(self):
+        a = mx.array([0.5, 1, 2, 10, 16])
+        result = mx.log2(a)
+        expected = np.log2(a, dtype=np.float32)
+
+        self.assertTrue(np.allclose(result, expected))
+
+        a = mx.array(1.0) + 1j * mx.array(2.0)
+        result = mx.log2(a)
+        expected = np.log2(np.array(a))
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_log10(self):
+        a = mx.array([0.1, 1, 10, 20, 100])
+        result = mx.log10(a)
+        expected = np.log10(a, dtype=np.float32)
+
+        self.assertTrue(np.allclose(result, expected))
+
+        a = mx.array(1.0) + 1j * mx.array(2.0)
+        result = mx.log10(a)
+        expected = np.log10(np.array(a))
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_exp(self):
+        a = mx.array([0, 0.5, -0.5, 5])
+        result = mx.exp(a)
+        expected = np.exp(a, dtype=np.float32)
+
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_expm1(self):
+        a = mx.array([-88, -87, 0, 0.5, -0.5, 5, 87, 88, 89, 90])
+        result = mx.expm1(a)
+        errs = np.seterr(over="ignore")
+        expected = np.expm1(a)
+        np.seterr(over=errs["over"])
+        self.assertTrue(np.allclose(result, expected, rtol=1e-3, atol=1e-4))
+
+    def test_erf(self):
+        inputs = [-5, 0.0, 0.5, 1.0, 2.0, 10.0]
+        x = mx.array(inputs)
+        expected = np.array([math.erf(i) for i in inputs])
+        self.assertTrue(np.allclose(mx.erf(x), expected))
+
+    def test_erfinv(self):
+        inputs = [-5.0, -1.0, 0.5, 0.0, 0.5, 1.0, 5.0]
+        x = mx.array(inputs)
+        # Output of:
+        # scipy.special.erfinv([-5.0, -1.0, 0.5, 0.0, 0.5, 1.0, 5.0])
+        expected = np.array(
+            [
+                float("nan"),
+                -float("inf"),
+                0.47693628,
+                0.0,
+                0.47693628,
+                float("inf"),
+                float("nan"),
+            ]
+        ).astype(np.float32)
+        self.assertTrue(np.allclose(mx.erfinv(x), expected, equal_nan=True))
+
+        result = mx.erfinv(mx.array([0.9999999403953552] * 8))
+        expected = mx.array([3.8325066566467285] * 8)
+        self.assertTrue(mx.allclose(result, expected))
+
+    def test_sin(self):
+        a = mx.array(
+            [0, math.pi / 4, math.pi / 2, math.pi, 3 * math.pi / 4, 2 * math.pi]
+        )
+        result = mx.sin(a)
+        expected = np.sin(a, dtype=np.float32)
+
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_cos(self):
+        a = mx.array(
+            [0, math.pi / 4, math.pi / 2, math.pi, 3 * math.pi / 4, 2 * math.pi]
+        )
+        result = mx.cos(a)
+        expected = np.cos(a, dtype=np.float32)
+
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_degrees(self):
+        a = mx.array(
+            [0, math.pi / 4, math.pi / 2, math.pi, 3 * math.pi / 4, 2 * math.pi]
+        )
+        result = mx.degrees(a)
+        expected = np.degrees(a, dtype=np.float32)
+
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_radians(self):
+        a = mx.array([0.0, 45.0, 90.0, 180.0, 270.0, 360.0])
+        result = mx.radians(a)
+        expected = np.radians(a, dtype=np.float32)
+
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_log1p(self):
+        a = mx.array([1, 0.5, 10, 100])
+        result = mx.log1p(a)
+        expected = np.log1p(a, dtype=np.float32)
+
+        self.assertTrue(np.allclose(result, expected))
+
+        # Complex test
+        a = mx.array([1, 0.5, 10, 100]) + 1j
+        result = mx.log1p(a)
+        expected = np.log1p(a, dtype=np.complex64)
+
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_sigmoid(self):
+        a = mx.array([0.0, 1.0, -1.0, 5.0, -5.0])
+        result = mx.sigmoid(a)
+        expected = 1 / (1 + np.exp(-a, dtype=np.float32))
+        self.assertTrue(np.allclose(result, expected))
+
+    def test_allclose(self):
+        a = mx.array(1.0)
+        b = mx.array(1.0)
+
+        self.assertTrue(mx.allclose(a, b).item())
+
+        b = mx.array(1.1)
+        self.assertFalse(mx.allclose(a, b).item())
+        self.assertTrue(mx.allclose(a, b, 0.1).item())
+        self.assertFalse(mx.allclose(a, b, 0.01).item())
+        self.assertTrue(mx.allclose(a, b, 0.01, 0.1).item())
+
+        c = mx.array(float("inf"))
+        self.assertTrue(mx.allclose(c, c).item())
+
+    def test_isclose(self):
+        a = mx.array([float("inf"), float("inf"), float("-inf")])
+        b = mx.array([float("inf"), float("-inf"), float("-inf")])
+
+        self.assertListEqual(mx.isclose(a, b).tolist(), [True, False, True])
+
+        a = mx.array([np.nan])
+        self.assertListEqual(mx.isclose(a, a).tolist(), [False])
+
+        a = mx.array([np.nan])
+        self.assertListEqual(mx.isclose(a, a, equal_nan=True).tolist(), [True])
+
+    def test_all(self):
+        a = mx.array([[True, False], [True, True]])
+
+        self.assertFalse(mx.all(a).item())
+        self.assertEqual(mx.all(a, keepdims=True).shape, (1, 1))
+        self.assertFalse(mx.all(a, axis=[0, 1]).item())
+        self.assertEqual(mx.all(a, axis=[0]).tolist(), [True, False])
+        self.assertEqual(mx.all(a, axis=[1]).tolist(), [False, True])
+        self.assertEqual(mx.all(a, axis=0).tolist(), [True, False])
+        self.assertEqual(mx.all(a, axis=1).tolist(), [False, True])
+
+    def test_any(self):
+        a = mx.array([[True, False], [False, False]])
+
+        self.assertTrue(mx.any(a).item())
+        self.assertEqual(mx.any(a, keepdims=True).shape, (1, 1))
+        self.assertTrue(mx.any(a, axis=[0, 1]).item())
+        self.assertEqual(mx.any(a, axis=[0]).tolist(), [True, False])
+        self.assertEqual(mx.any(a, axis=[1]).tolist(), [True, False])
+        self.assertEqual(mx.any(a, axis=0).tolist(), [True, False])
+        self.assertEqual(mx.any(a, axis=1).tolist(), [True, False])
+
+    def test_stop_gradient(self):
+        def func(x):
+            return mx.sum(2 * x + mx.stop_gradient(3 * x))
+
+        x = mx.array([0.0, 0.1, -3])
+        expected = [2, 2, 2]
+
+        self.assertListEqual(mx.grad(func)(x).tolist(), expected)
+
+    def test_kron(self):
+        # Basic vector test
+        x = mx.array([1, 2])
+        y = mx.array([3, 4])
+        z = mx.kron(x, y)
+        self.assertEqual(z.tolist(), [3, 4, 6, 8])
+
+        # Basic matrix test
+        x = mx.array([[1, 2], [3, 4]])
+        y = mx.array([[0, 5], [6, 7]])
+        z = mx.kron(x, y)
+        self.assertEqual(
+            z.tolist(),
+            [[0, 5, 0, 10], [6, 7, 12, 14], [0, 15, 0, 20], [18, 21, 24, 28]],
+        )
+
+        # Test with different dimensions
+        x = mx.array([1, 2])  # (2,)
+        y = mx.array([[3, 4], [5, 6]])  # (2, 2)
+        z = mx.kron(x, y)
+        self.assertEqual(z.tolist(), [[3, 4, 6, 8], [5, 6, 10, 12]])
+
+        # Test with empty array
+        x = mx.array([])
+        y = mx.array([1, 2])
+        with self.assertRaises(ValueError):
+            mx.kron(x, y)
+
+    def test_take(self):
+        # Shape: 4 x 3 x 2
+        l = [
+            [[1, 3], [-2, -2], [-3, -2]],
+            [[2, 4], [-3, 2], [-4, -2]],
+            [[2, 3], [2, 4], [2, 1]],
+            [[1, -5], [3, -1], [2, 3]],
+        ]
+
+        a = mx.array(l)
+        a_npy = np.array(l)
+
+        indices = [0, -1]
+        flatten_take = mx.take(a, mx.array(indices)).tolist()
+        flatten_take_expected = np.take(a_npy, np.array(indices)).tolist()
+        self.assertListEqual(flatten_take, flatten_take_expected)
+
+        indices = [-1, 2, 0]
+        axis_take = mx.take(a, mx.array(indices), axis=0).tolist()
+        axis_take_expected = np.take(a_npy, np.array(indices), axis=0).tolist()
+        self.assertListEqual(axis_take, axis_take_expected)
+
+        indices = [0, 0, -2]
+        axis_take = mx.take(a, mx.array(indices), axis=1).tolist()
+        axis_take_expected = np.take(a_npy, np.array(indices), axis=1).tolist()
+        self.assertListEqual(axis_take, axis_take_expected)
+
+        indices = [0, -1, -1]
+        axis_take = mx.take(a, mx.array(indices), axis=-1).tolist()
+        axis_take_expected = np.take(a_npy, np.array(indices), axis=-1).tolist()
+        self.assertListEqual(axis_take, axis_take_expected)
+
+        a_npy = np.arange(8 * 8 * 8, dtype=np.int32)
+        a_npy = a_npy.reshape((8, 8, 8))
+        idx_npy = np.arange(6, dtype=np.uint32)
+        idx_npy = idx_npy.reshape((2, 3))
+        a_mlx = mx.array(a_npy)
+        idx_mlx = mx.array(idx_npy)
+
+        a_npy_taken = np.take(a_npy, idx_npy)
+        a_mlx_taken = mx.take(a_mlx, idx_mlx)
+        self.assertEqual(a_npy_taken.shape, a_mlx_taken.shape)
+        self.assertListEqual(a_npy_taken.tolist(), a_mlx_taken.tolist())
+
+        a_npy_taken = np.take(a_npy, idx_npy, axis=0)
+        a_mlx_taken = mx.take(a_mlx, idx_mlx, axis=0)
+        self.assertEqual(a_npy_taken.shape, a_mlx_taken.shape)
+        self.assertListEqual(a_npy_taken.tolist(), a_mlx_taken.tolist())
+
+        a_npy_taken = np.take(a_npy, idx_npy, axis=1)
+        a_mlx_taken = mx.take(a_mlx, idx_mlx, axis=1)
+        self.assertEqual(a_npy_taken.shape, a_mlx_taken.shape)
+        self.assertListEqual(a_npy_taken.tolist(), a_mlx_taken.tolist())
+
+        a_npy_taken = np.take(a_npy, idx_npy, axis=2)
+        a_mlx_taken = mx.take(a_mlx, idx_mlx, axis=2)
+        self.assertEqual(a_npy_taken.shape, a_mlx_taken.shape)
+        self.assertListEqual(a_npy_taken.tolist(), a_mlx_taken.tolist())
+
+        # Take with integer index
+        a = mx.arange(8).reshape(2, 4)
+        out = mx.take(a, 1, axis=0)
+        self.assertTrue(mx.array_equal(out, mx.array([4, 5, 6, 7])))
+        out = mx.take(a, 1, axis=1)
+        self.assertTrue(mx.array_equal(out, mx.array([1, 5])))
+
+        # Take with multi-dim scalar preserves dims
+        out = mx.take(a, mx.array(1), axis=0)
+        self.assertEqual(out.shape, (4,))
+
+        out = mx.take(a, mx.array([1]), axis=0)
+        self.assertEqual(out.shape, (1, 4))
+
+        out = mx.take(a, mx.array([[1]]), axis=0)
+        self.assertEqual(out.shape, (1, 1, 4))
+
+    def test_take_along_axis(self):
+        a_np = np.arange(8).reshape(2, 2, 2)
+        a_mlx = mx.array(a_np)
+        idx_np = np.array([1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0])
+        idx_mlx = mx.array(idx_np)
+
+        for ax in [None, 0, 1, 2]:
+            if ax == None:
+                shape = [-1]
+            else:
+                shape = [2] * 3
+                shape[ax] = 3
+            out_np = np.take_along_axis(a_np, idx_np.reshape(shape), axis=ax)
+            out_mlx = mx.take_along_axis(a_mlx, mx.reshape(idx_mlx, shape), axis=ax)
+            self.assertTrue(np.array_equal(out_np, np.array(out_mlx)))
+
+    def test_put_along_axis(self):
+        for ax in [None, 0, 1, 2]:
+
+            a_np = np.arange(16).reshape(2, 2, 4).astype(np.int32)
+            a_mlx = mx.array(a_np)
+
+            if ax == None:
+                idx_np = np.random.permutation(a_np.size)
+                values_np = np.random.randint(low=0, high=100, size=(16,))
+            else:
+                shape = list(a_np.shape)
+                shape[ax] = 2
+                idx_np = np.random.choice(a_np.shape[ax], replace=False, size=(2,))
+                idx_np = np.expand_dims(idx_np, list(range(1, 2 - ax + 1)))
+                idx_np = np.broadcast_to(idx_np, shape)
+                values_np = np.random.randint(low=0, high=100, size=shape)
+
+            idx_np.astype(np.int32)
+            values_np.astype(a_np.dtype)
+
+            idx_mlx = mx.array(idx_np)
+            values_mlx = mx.array(values_np)
+
+            np.put_along_axis(a_np, idx_np, values_np, axis=ax)
+            out_mlx = mx.put_along_axis(a_mlx, idx_mlx, values_mlx, axis=ax)
+            self.assertTrue(np.array_equal(a_np, out_mlx))
+
+        source = mx.zeros((1, 1, 8, 32))
+        indices = mx.array([0, 2, 4, 5]).reshape((1, 1, 4, 1))
+        update = mx.array(1.0)
+
+        out_mlx = mx.put_along_axis(source, indices, update, axis=-2)
+        out_np = np.array(source)
+        np.put_along_axis(out_np, np.array(indices), np.array(update), axis=-2)
+        self.assertTrue(np.array_equal(out_np, np.array(out_mlx)))
+
+        a = mx.array([], mx.float32)
+        b = mx.put_along_axis(a, a, a, axis=None)
+        mx.eval(b)
+        self.assertEqual(b.size, 0)
+        self.assertEqual(b.shape, a.shape)
+
+    def test_split(self):
+        a = mx.array([1, 2, 3])
+        splits = mx.split(a, 3)
+        for e, x in enumerate(splits):
+            self.assertEqual(x.item(), e + 1)
+
+        a = mx.array([[1, 2], [3, 4], [5, 6]])
+        x, y, z = mx.split(a, 3, axis=0)
+        self.assertEqual(x.tolist(), [[1, 2]])
+        self.assertEqual(y.tolist(), [[3, 4]])
+        self.assertEqual(z.tolist(), [[5, 6]])
+
+        with self.assertRaises(ValueError):
+            mx.split(a, 3, axis=2)
+
+        a = mx.arange(8)
+        x, y, z = mx.split(a, [1, 5])
+        self.assertEqual(x.tolist(), [0])
+        self.assertEqual(y.tolist(), [1, 2, 3, 4])
+        self.assertEqual(z.tolist(), [5, 6, 7])
+
+    def test_arange_overload_dispatch(self):
+        with self.assertRaises(ValueError):
+            a = mx.arange(float("nan"), 1, 5)
+        with self.assertRaises(ValueError):
+            a = mx.arange(0, float("nan"), 5)
+        with self.assertRaises(ValueError):
+            a = mx.arange(0, 2, float("nan"))
+        with self.assertRaises(ValueError):
+            a = mx.arange(0, float("inf"), float("inf"))
+        with self.assertRaises(ValueError):
+            a = mx.arange(float("inf"), 1, float("inf"))
+        with self.assertRaises(ValueError):
+            a = mx.arange(float("inf"), 1, 5)
+        with self.assertRaises(TypeError):
+            INT_MAX = 2147483647
+            a = mx.arange(0, INT_MAX + 1, 1)
+
+        a = mx.arange(5)
+        expected = [0, 1, 2, 3, 4]
+        self.assertListEqual(a.tolist(), expected)
+
+        a = mx.arange(1, 5)
+        expected = [1, 2, 3, 4]
+        self.assertListEqual(a.tolist(), expected)
+
+        a = mx.arange(-3, step=-1)
+        expected = [0, -1, -2]
+        self.assertListEqual(a.tolist(), expected)
+
+        a = mx.arange(stop=2, step=0.5)
+        expected = [0, 0.5, 1.0, 1.5]
+        self.assertListEqual(a.tolist(), expected)
+
+        with self.assertRaises(TypeError):
+            mx.arange(start=1, step=2)
+
+        a = mx.arange(stop=3)
+        expected = [0, 1, 2]
+        self.assertListEqual(a.tolist(), expected)
+
+    def test_arange_inferred_dtype(self):
+        a = mx.arange(5)
+        self.assertEqual(a.dtype, mx.int32)
+
+        a = mx.arange(5.0)
+        self.assertEqual(a.dtype, mx.float32)
+
+        a = mx.arange(1, 3.0)
+        self.assertEqual(a.dtype, mx.float32)
+
+        a = mx.arange(1, 3, dtype=mx.float32)
+        self.assertEqual(a.dtype, mx.float32)
+
+        a = mx.arange(1, 5, 1)
+        self.assertEqual(a.dtype, mx.int32)
+
+        a = mx.arange(1.0, 5, 1)
+        self.assertEqual(a.dtype, mx.float32)
+
+        a = mx.arange(1, 5.0, 1)
+        self.assertEqual(a.dtype, mx.float32)
+
+        a = mx.arange(1, 5, 1.0)
+        self.assertEqual(a.dtype, mx.float32)
+
+        a = mx.arange(1.0, 3.0, 0.2, dtype=mx.int32)
+        self.assertEqual(a.dtype, mx.int32)
+
+    def test_arange_corner_cases_cast(self):
+        a = mx.arange(0, 3, 0.2, dtype=mx.int32)
+        expected = [0] * 15
+        self.assertListEqual(a.tolist(), expected)
+        self.assertEqual(a.dtype, mx.int32)
+
+        a = mx.arange(-1, -4, -0.9, dtype=mx.int32)
+        expected = [-1] * 4
+        self.assertListEqual(a.tolist(), expected)
+        self.assertEqual(a.dtype, mx.int32)
+
+        a = mx.arange(-1, -20, -1.2, dtype=mx.int32)
+        expected = [
+            -1,
+            -2,
+            -3,
+            -4,
+            -5,
+            -6,
+            -7,
+            -8,
+            -9,
+            -10,
+            -11,
+            -12,
+            -13,
+            -14,
+            -15,
+            -16,
+        ]
+        self.assertListEqual(a.tolist(), expected)
+        self.assertEqual(a.dtype, mx.int32)
+
+        a = mx.arange(0, 10, 100)
+        expected = [0]
+        self.assertListEqual(a.tolist(), expected)
+        self.assertEqual(a.dtype, mx.int32)
+
+        a = mx.arange(10, 0, 1)
+        expected = []
+        self.assertListEqual(a.tolist(), expected)
+
+        a = mx.arange(10, 0, float("inf"))
+        expected = []
+        self.assertListEqual(a.tolist(), expected)
+
+        a = mx.arange(0, 10, float("inf"))
+        expected = [0]
+        self.assertListEqual(a.tolist(), expected)
+
+        a = mx.arange(0, -10, float("-inf"))
+        expected = [0]
+        self.assertListEqual(a.tolist(), expected)
+
+    def test_unary_ops(self):
+        def test_ops(npop, mlxop, x, y, atol):
+            r_np = npop(x)
+            r_mlx = mlxop(y)
+            mx.eval(r_mlx)
+
+            self.assertTrue(np.allclose(r_np, r_mlx, atol=atol))
+
+        x = np.random.rand(18, 28, 38)
+        for op in ["abs", "exp", "log", "square", "sqrt"]:
+            with self.subTest(op=op):
+                float_dtypes = [("float16", 1e-3), ("float32", 1e-6)]
+
+                for dtype, atol in float_dtypes:
+                    with self.subTest(dtype=dtype):
+                        x_ = x.astype(getattr(np, dtype))
+                        y_ = mx.array(x_)
+                        test_ops(getattr(np, op), getattr(mx, op), x_, y_, atol)
+
+    def test_unary_ops_from_non_array(self):
+        unary_ops = [
+            "abs",
+            "exp",
+            "log",
+            "square",
+            "sqrt",
+            "sin",
+            "cos",
+            "tan",
+            "sinh",
+            "cosh",
+            "tanh",
+            "sign",
+            "negative",
+            "expm1",
+            "arcsin",
+            "arccos",
+            "arctan",
+            "arcsinh",
+            "arctanh",
+            "degrees",
+            "radians",
+            "log2",
+            "log10",
+            "log1p",
+            "floor",
+            "ceil",
+            "conjugate",
+        ]
+
+        x = 0.5
+        x_np = np.random.rand(10).astype(np.float32)
+        for op in unary_ops:
+            with self.subTest(op=op):
+                # Test from scalar
+                expected = getattr(np, op)(x)
+                out = getattr(mx, op)(x)
+
+                # Check close
+                self.assertTrue(np.allclose(expected, out, equal_nan=True))
+
+                # Test from NumPy
+                expected = getattr(np, op)(x_np)
+                out = getattr(mx, op)(x_np)
+
+                # Check close
+                self.assertTrue(np.allclose(expected, np.array(out), equal_nan=True))
+
+    def test_trig_ops(self):
+        def test_ops(npop, mlxop, x, y, atol):
+            r_np = npop(x)
+            r_mlx = mlxop(y)
+            mx.eval(r_mlx)
+
+            self.assertTrue(np.allclose(r_np, r_mlx, atol=atol, equal_nan=True))
+
+        x = np.random.rand(9, 12, 18)
+        xi = np.random.rand(9, 12, 18)
+        base_ops = ["sin", "cos", "tan"]
+        hyperbolic_ops = ["sinh", "cosh", "tanh"]
+        all_fwd_ops = base_ops + hyperbolic_ops
+
+        for op in all_fwd_ops:
+            with self.subTest(op=op):
+                float_dtypes = [("float16", 1e-3), ("float32", 1e-6)]
+
+                for dtype, atol in float_dtypes:
+                    with self.subTest(dtype=dtype):
+                        x_ = x.astype(getattr(np, dtype))
+                        y_ = mx.array(x_)
+                        test_ops(getattr(np, op), getattr(mx, op), x_, y_, atol)
+
+            with self.subTest(op=op):
+                float_dtypes = [("complex64", 1e-5)]
+
+                for dtype, atol in float_dtypes:
+                    with self.subTest(dtype=dtype):
+                        x_ = x + 1.0j * xi
+                        x_ = x_.astype(getattr(np, dtype))
+                        y_ = mx.array(x_)
+                        test_ops(getattr(np, op), getattr(mx, op), x_, y_, atol)
+
+            with self.subTest(op="arc" + op):
+                float_dtypes = [("float16", 1e-3), ("float32", 1e-6)]
+                op_inv = "arc" + op
+
+                for dtype, atol in float_dtypes:
+                    with self.subTest(dtype=dtype):
+                        np_op_fwd = getattr(np, op)
+                        x_ = np_op_fwd(x).astype(getattr(np, dtype))
+                        y_ = mx.array(x_)
+                        test_ops(getattr(np, op_inv), getattr(mx, op_inv), x_, y_, atol)
+
+        # Test grads
+        np_vjp_funcs = {
+            "sin": lambda primal, cotan: cotan * np.cos(primal),
+            "cos": lambda primal, cotan: -cotan * np.sin(primal),
+            "tan": lambda primal, cotan: cotan / (np.cos(primal) ** 2),
+            "sinh": lambda primal, cotan: cotan * np.cosh(primal),
+            "cosh": lambda primal, cotan: cotan * np.sinh(primal),
+            "tanh": lambda primal, cotan: cotan / (np.cosh(primal) ** 2),
+            "arcsin": lambda primal, cotan: cotan / np.sqrt(1.0 - primal**2),
+            "arccos": lambda primal, cotan: -cotan / np.sqrt(1.0 - primal**2),
+            "arctan": lambda primal, cotan: cotan / (1.0 + primal**2),
+            "arctan2": lambda primal, cotan: cotan / (1.0 + primal**2),
+            "arcsinh": lambda primal, cotan: cotan / np.sqrt(primal**2 + 1),
+            "arccosh": lambda primal, cotan: cotan / np.sqrt(primal**2 - 1),
+            "arctanh": lambda primal, cotan: cotan / (1.0 - primal**2),
+        }
+        with self.subTest(name="grads"):
+            for op in all_fwd_ops:
+                with self.subTest(op=op):
+                    primal_np = xi.astype(np.float32)
+                    primal_mx = mx.array(primal_np)
+                    x_ = x.astype(np.float32)
+                    y_ = mx.array(x_)
+                    op_ = op
+                    atol_ = 1e-5
+
+                    np_vjp = lambda x: np_vjp_funcs[op_](primal_np, x)
+                    mx_vjp = lambda x: mx.vjp(getattr(mx, op_), [primal_mx], [x])[1][0]
+                    test_ops(np_vjp, mx_vjp, x_, y_, atol_)
+
+                with self.subTest(op="arc" + op):
+                    np_op_fwd = getattr(np, op)
+                    primal_np = np_op_fwd(xi).astype(np.float32)
+
+                    # To avoid divide by zero error
+                    if op == "cosh":
+                        primal_np[np.isclose(primal_np, 1.0)] += 1e-3
+                    elif op == "cos":
+                        primal_np[np.isclose(primal_np, 1.0)] -= 1e-3
+
+                    primal_mx = mx.array(primal_np)
+                    x_ = x.astype(np.float32)
+                    y_ = mx.array(x_)
+                    op_ = "arc" + op
+                    atol_ = 1e-5
+
+                    np_vjp = lambda x: np_vjp_funcs[op_](primal_np, x)
+                    mx_vjp = lambda x: mx.vjp(getattr(mx, op_), [primal_mx], [x])[1][0]
+                    test_ops(np_vjp, mx_vjp, x_, y_, atol_)
+
+    def test_binary_ops(self):
+        def test_ops(npop, mlxop, x1, x2, y1, y2, atol):
+            r_np = npop(x1, x2)
+            r_mlx = mlxop(y1, y2)
+            mx.eval(r_mlx)
+            self.assertTrue(np.allclose(r_np, r_mlx, atol=atol))
+
+            r_np = npop(x1[:1], x2)
+            r_mlx = mlxop(y1[:1], y2)
+            mx.eval(r_mlx)
+            self.assertTrue(np.allclose(r_np, r_mlx, atol=atol))
+
+            r_np = npop(x1[:, :1], x2)
+            r_mlx = mlxop(y1[:, :1], y2)
+            mx.eval(r_mlx)
+            self.assertTrue(np.allclose(r_np, r_mlx, atol=atol))
+
+            r_np = npop(x1[:, :, :1], x2)
+            r_mlx = mlxop(y1[:, :, :1], y2)
+            mx.eval(r_mlx)
+            self.assertTrue(np.allclose(r_np, r_mlx, atol=atol))
+
+        x1 = np.maximum(np.random.rand(18, 28, 38), 0.1)
+        x2 = np.maximum(np.random.rand(18, 28, 38), 0.1)
+        y1 = mx.array(x1)
+        y2 = mx.array(x2)
+        mx.eval(y1, y2)
+        for op in [
+            "add",
+            "subtract",
+            "multiply",
+            "divide",
+            "floor_divide",
+            "maximum",
+            "minimum",
+            "power",
+        ]:
+            with self.subTest(op=op):
+                int_dtypes = [
+                    "int8",
+                    "int16",
+                    "int32",
+                    "int64",
+                    "uint8",
+                    "uint16",
+                    "uint32",
+                    "uint64",
+                ]
+                float_dtypes = ["float16", "float32"]
+
+                dtypes = {
+                    "divide": float_dtypes,
+                    "power": float_dtypes,
+                    "floor_divide": ["float32"] + int_dtypes,
+                }
+                dtypes = dtypes.get(op, int_dtypes + float_dtypes)
+
+                for dtype in dtypes:
+                    atol = 1e-3 if dtype == "float16" else 1e-6
+                    with self.subTest(dtype=dtype):
+                        m = 10 if dtype in int_dtypes else 1
+                        x1_ = (x1 * m).astype(getattr(np, dtype))
+                        x2_ = (x2 * m).astype(getattr(np, dtype))
+                        y1_ = mx.array(x1_)
+                        y2_ = mx.array(x2_)
+                        test_ops(
+                            getattr(np, op), getattr(mx, op), x1_, x2_, y1_, y2_, atol
+                        )
+
+    def test_irregular_binary_ops(self):
+        # Check transposed binary ops
+        dims = [2, 3, 4, 5]
+        size = 3
+        trial_mul = 2
+        np.random.seed(0)
+        for d in dims:
+            anp = np.random.randint(-20, 20, (size**d,)).reshape([size] * d)
+            bnp = np.random.randint(-20, 20, (size**d,)).reshape([size] * d)
+            for _ in range(trial_mul * d):
+                amlx = mx.array(anp)
+                bmlx = mx.array(bnp)
+                a_t = np.random.permutation(d).tolist()
+                b_t = np.random.permutation(d).tolist()
+                outnp = np.add(anp.transpose(a_t), bnp.transpose(b_t))
+                outmlx = mx.add(mx.transpose(amlx, a_t), mx.transpose(bmlx, b_t))
+                self.assertTrue(np.array_equal(outnp, outmlx))
+
+        # Check broadcast binary ops
+        for d in dims:
+            anp = np.random.randint(-20, 20, (size**d,)).reshape([size] * d)
+            for n_bsx in range(d):
+                bnp = np.random.randint(-20, 20, (size**n_bsx,)).reshape([size] * n_bsx)
+                for _ in range(trial_mul * d):
+                    amlx = mx.array(anp)
+                    bmlx = mx.array(bnp)
+                    b_shape = [1] * (d - n_bsx) + [size] * n_bsx
+                    np.random.shuffle(b_shape)
+                    outnp = np.add(anp, bnp.reshape(b_shape))
+                    outmlx = mx.add(amlx, mx.reshape(bmlx, b_shape))
+                    self.assertTrue(np.array_equal(outnp, outmlx))
+
+        # Check strided binary ops
+        for d in dims:
+            a = np.random.randint(-20, 20, (10,) * d)
+            b = np.random.randint(-20, 20, (10,) * d)
+            a_ = mx.array(a)
+            b_ = mx.array(b)
+            for t in permutations(range(d)):
+                for s in range(d):
+                    idx = tuple(
+                        [slice(None)] * s
+                        + [slice(None, None, 2)]
+                        + [slice(None)] * (d - s - 1)
+                    )
+                    c = a.transpose(t)[idx] + b[idx]
+                    c_ = mx.transpose(a_, t)[idx] + b_[idx]
+                    self.assertTrue(np.array_equal(c, c_))
+
+    def test_softmax(self):
+        cases = [(np.float32, 1e-6), (np.float16, 1e-3)]
+
+        for dtype, atol in cases:
+            a_npy = np.random.randn(16, 8, 32).astype(dtype)
+            a_mlx = mx.array(a_npy)
+
+            def np_softmax(x, axis):
+                ex = np.exp(x - np.max(x, axis=axis, keepdims=True))
+                return ex / np.sum(ex, axis=axis, keepdims=True)
+
+            for axes in (None, 0, 1, 2, (0, 1), (1, 2), (0, 2), (0, 1, 2)):
+                b_npy = np_softmax(a_npy, axes)
+                b_mlx = mx.softmax(a_mlx, axes)
+                self.assertTrue(np.allclose(b_npy, b_mlx, atol=atol))
+
+        for s in [100, 2049, 4097, 8193]:
+            a = np.full(s, -np.inf)
+            a[-1] = 0.0
+            a = mx.softmax(mx.array(a))
+            self.assertFalse(np.any(np.isnan(a)))
+            self.assertTrue((a[:-1] < 1e-9).all())
+            self.assertEqual(a[-1], 1)
+
+        # Sliced inputs
+        y = mx.random.uniform(shape=(8, 4))
+        out = mx.softmax(y[:, 0:2], axis=-1)
+        self.assertAlmostEqual(out.sum().item(), 8.0, 5)
+
+        # Precise
+        for t in [mx.float16, mx.bfloat16]:
+            a = (10 * mx.random.normal(shape=(1024,))).astype(t)
+            out_expect = mx.softmax(a.astype(mx.float32)).astype(t)
+            out = mx.softmax(a, axis=-1, precise=True)
+            self.assertTrue(mx.allclose(out_expect, out))
+
+        # All Infs give NaNs
+        for n in [127, 128, 129]:
+            x = mx.full((n,), vals=-float("inf"))
+            self.assertTrue(mx.all(mx.isnan(mx.softmax(x))))
+
+        # Transposed inputs
+        a = mx.random.uniform(shape=(32, 32, 32))
+        b = mx.softmax(a, axis=-1)
+        c = mx.softmax(a.swapaxes(0, 1), axis=-1).swapaxes(0, 1)
+        self.assertEqual((b - c).abs().max().item(), 0.0)
+
+        with self.assertRaises(ValueError):
+            mx.softmax(mx.array(1.0), axis=-1)
+
+    def test_concatenate(self):
+        a_npy = np.random.randn(32, 32, 32)
+        b_npy = np.random.randn(32, 32, 32)
+        a_mlx = mx.array(a_npy)
+        b_mlx = mx.array(b_npy)
+
+        for axis in (None, 0, 1, 2):
+            for p in permutations([0, 1, 2]):
+                c_npy = np.concatenate([a_npy, np.transpose(b_npy, p)], axis=axis)
+                c_mlx = mx.concatenate([a_mlx, mx.transpose(b_mlx, p)], axis=axis)
+                self.assertEqual(list(c_npy.shape), list(c_mlx.shape))
+                self.assertTrue(np.allclose(c_npy, c_mlx, atol=1e-6))
+
+        with self.assertRaises(ValueError):
+            a = mx.array([[1, 2], [1, 2], [1, 2]])
+            b = mx.array([1, 2])
+            mx.concatenate([a, b], axis=0)
+
+        # Cocnatenate with 0-sized array
+        a = mx.zeros((2, 0, 2))
+        b = mx.zeros((2, 2, 2))
+        out = mx.concatenate([a, b], axis=1)
+        self.assertTrue(mx.array_equal(out, b))
+
+    def test_meshgrid(self):
+        x = mx.array([1, 2, 3], dtype=mx.int32)
+        y = np.array([1, 2, 3], dtype=np.int32)
+
+        # Test single input
+        a_mlx = mx.meshgrid(x)
+        a_np = np.meshgrid(y)
+        self.assertEqualArray(a_mlx[0], mx.array(a_np[0]))
+
+        # Test sparse
+        a_mlx, b_mlx, c_mlx = mx.meshgrid(x, x, x, sparse=True)
+        a_np, b_np, c_np = np.meshgrid(y, y, y, sparse=True)
+        self.assertEqualArray(a_mlx, mx.array(a_np))
+        self.assertEqualArray(b_mlx, mx.array(b_np))
+        self.assertEqualArray(c_mlx, mx.array(c_np))
+
+        # Test different lengths
+        x = mx.array([1, 2], dtype=mx.int32)
+        y = mx.array([1, 2, 3], dtype=mx.int32)
+        z = np.array([1, 2], dtype=np.int32)
+        w = np.array([1, 2, 3], dtype=np.int32)
+        a_mlx, b_mlx = mx.meshgrid(x, y)
+        a_np, b_np = np.meshgrid(z, w)
+        self.assertEqualArray(a_mlx, mx.array(a_np))
+        self.assertEqualArray(b_mlx, mx.array(b_np))
+
+        # Test empty input
+        x = mx.array([], dtype=mx.int32)
+        y = np.array([], dtype=np.int32)
+        a_mlx = mx.meshgrid(x)
+        a_np = np.meshgrid(y)
+        self.assertEqualArray(a_mlx[0], mx.array(a_np[0]))
+
+        # Test float32 input
+        x = mx.array([1.1, 2.2, 3.3], dtype=mx.float32)
+        y = np.array([1.1, 2.2, 3.3], dtype=np.float32)
+        a_mlx = mx.meshgrid(x, x, x)
+        a_np = np.meshgrid(y, y, y)
+        self.assertEqualArray(a_mlx[0], mx.array(a_np[0]))
+        self.assertEqualArray(a_mlx[1], mx.array(a_np[1]))
+        self.assertEqualArray(a_mlx[2], mx.array(a_np[2]))
+
+        # Test ij indexing
+        x = mx.array([1.1, 2.2, 3.3, 4.4, 5.5], dtype=mx.float32)
+        y = np.array([1.1, 2.2, 3.3, 4.4, 5.5], dtype=np.float32)
+        a_mlx = mx.meshgrid(x, x, indexing="ij")
+        a_np = np.meshgrid(y, y, indexing="ij")
+        self.assertEqualArray(a_mlx[0], mx.array(a_np[0]))
+        self.assertEqualArray(a_mlx[1], mx.array(a_np[1]))
+
+        # Test different lengths, sparse, and ij indexing
+        a = mx.array([1, 2], dtype=mx.int64)
+        b = mx.array([1, 2, 3], dtype=mx.int64)
+        c = mx.array([1, 2, 3, 4], dtype=mx.int64)
+        x = np.array([1, 2], dtype=np.int64)
+        y = np.array([1, 2, 3], dtype=np.int64)
+        z = np.array([1, 2, 3, 4], dtype=np.int64)
+        a_mlx, b_mlx, c_mlx = mx.meshgrid(a, b, c, sparse=True, indexing="ij")
+        a_np, b_np, c_np = np.meshgrid(x, y, z, sparse=True, indexing="ij")
+        self.assertEqualArray(a_mlx, mx.array(a_np))
+        self.assertEqualArray(b_mlx, mx.array(b_np))
+        self.assertEqualArray(c_mlx, mx.array(c_np))
+
+    def test_pad(self):
+        pad_width_and_values = [
+            ([(1, 1), (1, 1), (1, 1)], 0),
+            ([(1, 1), (1, 1), (1, 1)], 5),
+            ([(3, 0), (0, 2), (5, 7)], 0),
+            ([(3, 0), (0, 2), (5, 7)], -7),
+            ([(0, 0), (0, 0), (0, 0)], 0),
+        ]
+
+        for pw, v in pad_width_and_values:
+            with self.subTest(pad_width=pw, value=v):
+                a_npy = np.random.randn(16, 16, 16).astype(np.float32)
+                a_mlx = mx.array(a_npy)
+
+                b_npy = np.pad(a_npy, pw, constant_values=v)
+                b_mlx = mx.pad(a_mlx, pw, constant_values=v)
+
+                self.assertEqual(list(b_npy.shape), list(b_mlx.shape))
+                self.assertTrue(np.allclose(b_npy, b_mlx, atol=1e-6))
+
+                b_npy = np.pad(a_npy, pw, mode="edge")
+                b_mlx = mx.pad(a_mlx, pw, mode="edge")
+
+                self.assertEqual(list(b_npy.shape), list(b_mlx.shape))
+                self.assertTrue(np.allclose(b_npy, b_mlx, atol=1e-6))
+
+        a = mx.zeros((1, 1, 1))
+        self.assertEqual(mx.pad(a, 1).shape, (3, 3, 3))
+        self.assertEqual(mx.pad(a, (1,)).shape, (3, 3, 3))
+        self.assertEqual(mx.pad(a, [1]).shape, (3, 3, 3))
+        self.assertEqual(mx.pad(a, (1, 2)).shape, (4, 4, 4))
+        self.assertEqual(mx.pad(a, [(1, 2)]).shape, (4, 4, 4))
+        self.assertEqual(mx.pad(a, ((1, 2),)).shape, (4, 4, 4))
+        self.assertEqual(mx.pad(a, ((1, 2), (2, 1), (2, 2))).shape, (4, 4, 5))
+
+        # Test grads
+        a_fwd = mx.array(np.random.rand(16, 16).astype(np.float32))
+        a_bwd = mx.ones((22, 22))
+        f = lambda x: mx.pad(x, ((4, 2), (2, 4)))
+
+        _, df = mx.vjp(f, [a_fwd], [a_bwd])
+        self.assertTrue(mx.allclose(a_bwd[4:-2, 2:-4], df[0]).item())
+
+    def test_where(self):
+        self.assertCmpNumpy([True, mx.array([[1, 2], [3, 4]]), 1], mx.where, np.where)
+        self.assertCmpNumpy([True, 1, mx.array([[1, 2], [3, 4]])], mx.where, np.where)
+        self.assertCmpNumpy(
+            [
+                mx.array([[True, False], [False, True]]),
+                mx.array([[1, 2], [3, 4]]),
+                mx.array([5, 6]),
+            ],
+            mx.where,
+            np.where,
+        )
+
+        # Check non-contiguous input with several dimensions
+        shape = [1, 2, 2, 3, 3, 1]
+        strides = [16, 4, 1, 4, 1, 1]
+        x = mx.ones(shape=(1, 4, 4, 1))
+        x = mx.as_strided(x, shape, strides)
+        out = mx.where(mx.isnan(x), mx.nan, x)
+        self.assertTrue(mx.allclose(out, mx.ones_like(out)))
+
+    def test_nan_to_num(self):
+        a = mx.array([6, float("inf"), 2, 0])
+        out_mx = mx.nan_to_num(a)
+        out_np = np.nan_to_num(a)
+        self.assertTrue(np.allclose(out_mx, out_np))
+
+        for t in [mx.float32, mx.float16]:
+            a = mx.array([float("inf"), 6.9, float("nan"), float("-inf")])
+            out_mx = mx.nan_to_num(a)
+            out_np = np.nan_to_num(a)
+            self.assertTrue(np.allclose(out_mx, out_np))
+
+            a = mx.array([float("inf"), 6.9, float("nan"), float("-inf")]).astype(t)
+            out_np = np.nan_to_num(a, nan=0.0, posinf=1000, neginf=-1000)
+            out_mx = mx.nan_to_num(a, nan=0.0, posinf=1000, neginf=-1000)
+            self.assertTrue(np.allclose(out_mx, out_np))
+
+    def test_as_strided(self):
+        x_npy = np.random.randn(128).astype(np.float32)
+        x_mlx = mx.array(x_npy)
+
+        shapes = [(10, 10), (5, 5), (2, 20), (10,)]
+        strides = [(3, 3), (7, 1), (1, 5), (4,)]
+        for shape, stride in zip(shapes, strides):
+            for offset in [0, 1, 3]:
+                y_npy = np.lib.stride_tricks.as_strided(
+                    x_npy[offset:], shape, np.multiply(stride, 4)
+                )
+                y_mlx = mx.as_strided(x_mlx, shape, stride, offset)
+                self.assertTrue(np.array_equal(y_npy, y_mlx))
+
+        x = mx.random.uniform(shape=(32,))
+        y = mx.as_strided(x, (x.size,), (-1,), x.size - 1)
+        self.assertTrue(mx.array_equal(y, x[::-1]))
+
+    def test_logcumsumexp(self):
+        npop = np.logaddexp.accumulate
+        mxop = mx.logcumsumexp
+
+        a_npy = np.random.randn(32, 32, 32).astype(np.float32)
+        a_mlx = mx.array(a_npy)
+
+        for axis in (0, 1, 2):
+            c_npy = npop(a_npy, axis=axis)
+            c_mlx = mxop(a_mlx, axis=axis)
+            self.assertTrue(np.allclose(c_npy, c_mlx, rtol=1e-3, atol=1e-3))
+
+        edge_cases_npy = [
+            np.float32([-float("inf")] * 8),
+            np.float32([-float("inf"), 0, -float("inf")]),
+            np.float32([-float("inf"), float("inf"), -float("inf")]),
+        ]
+        edge_cases_mlx = [mx.array(a) for a in edge_cases_npy]
+
+        for a_npy, a_mlx in zip(edge_cases_npy, edge_cases_mlx):
+            c_npy = npop(a_npy, axis=0)
+            c_mlx = mxop(a_mlx, axis=0)
+            self.assertTrue(np.allclose(c_npy, c_mlx, rtol=1e-3, atol=1e-3))
+
+        # Complex tests
+
+        a_npy = np.array([1, 2, 3]).astype(np.float32) + 1j
+        a_mlx = mx.array(a_npy)
+        c_npy = np_cumlogaddexp(a_npy, axis=-1)
+        c_mlx = mxop(a_mlx, axis=-1)
+        self.assertTrue(np.allclose(c_npy, c_mlx, rtol=1e-3, atol=1e-3))
+
+    def test_scans(self):
+        a_npy = np.random.randn(32, 32, 32).astype(np.float32)
+        a_mlx = mx.array(a_npy)
+
+        for op in ["cumsum", "cumprod"]:
+            npop = getattr(np, op)
+            mxop = getattr(mx, op)
+            for axis in (None, 0, 1, 2):
+                c_npy = npop(a_npy, axis=axis)
+                c_mlx = mxop(a_mlx, axis=axis)
+                self.assertTrue(np.allclose(c_npy, c_mlx, rtol=1e-3, atol=1e-3))
+
+        # Complex test
+
+        a_npy = np.random.randn(32, 32, 32).astype(np.float32) + 0.5j
+        a_mlx = mx.array(a_npy)
+
+        for op in ["cumsum", "cumprod"]:
+            npop = getattr(np, op)
+            mxop = getattr(mx, op)
+            for axis in (None, 0, 1, 2):
+                c_npy = npop(a_npy, axis=axis)
+                c_mlx = mxop(a_mlx, axis=axis)
+                self.assertTrue(np.allclose(c_npy, c_mlx, rtol=1e-3, atol=1e-3))
+
+        a_mlx = mx.random.randint(shape=(32, 32, 32), low=-100, high=100)
+        for dt in [mx.int32, mx.int64]:
+            mxx = a_mlx.astype(dt)
+            npx = np.array(mxx)
+            for op in ["cumsum", "cumprod"]:
+                npop = getattr(np, op)
+                mxop = getattr(mx, op)
+                for axis in (None, 0, 1, 2):
+                    c_npy = npop(npx, axis=axis, dtype=npx.dtype)
+                    c_mlx = mxop(mxx, axis=axis)
+                    self.assertTrue(np.array_equal(c_npy, c_mlx))
+
+        a_mlx = mx.random.randint(shape=(32, 32, 32), low=-100, high=100)
+        for op in ["cumsum", "cumprod", "cummax", "cummin"]:
+            mxop = getattr(mx, op)
+            c1 = mxop(a_mlx, axis=2)
+            c2 = mxop(a_mlx, axis=2, inclusive=False, reverse=False)
+            self.assertTrue(mx.array_equal(c1[:, :, :-1], c2[:, :, 1:]))
+            c1 = mxop(a_mlx, axis=1)
+            c2 = mxop(a_mlx, axis=1, inclusive=False, reverse=False)
+            self.assertTrue(mx.array_equal(c1[:, :-1, :], c2[:, 1:, :]))
+            c1 = mxop(a_mlx, axis=0)
+            c2 = mxop(a_mlx, axis=0, inclusive=False, reverse=False)
+            self.assertTrue(mx.array_equal(c1[:-1, :, :], c2[1:, :, :]))
+
+            rev_idx = mx.arange(31, -1, -1)
+            c1 = mxop(a_mlx[:, :, rev_idx], axis=2)[:, :, rev_idx]
+            c2 = mxop(a_mlx, axis=2, inclusive=True, reverse=True)
+            self.assertTrue(mx.array_equal(c1, c2))
+            c1 = mxop(a_mlx[:, rev_idx, :], axis=1)[:, rev_idx, :]
+            c2 = mxop(a_mlx, axis=1, inclusive=True, reverse=True)
+            self.assertTrue(mx.array_equal(c1, c2))
+            c1 = mxop(a_mlx[rev_idx, :, :], axis=0)[rev_idx, :, :]
+            c2 = mxop(a_mlx, axis=0, inclusive=True, reverse=True)
+            self.assertTrue(mx.array_equal(c1, c2))
+
+            rev_idx = mx.arange(31, -1, -1)
+            c1 = mxop(a_mlx[:, :, rev_idx], axis=2)[:, :, rev_idx][:, :, 1:]
+            c2 = mxop(a_mlx, axis=2, inclusive=False, reverse=True)[:, :, :-1]
+            self.assertTrue(mx.array_equal(c1, c2))
+            c1 = mxop(a_mlx[:, rev_idx, :], axis=1)[:, rev_idx, :][:, 1:, :]
+            c2 = mxop(a_mlx, axis=1, inclusive=False, reverse=True)[:, :-1, :]
+            self.assertTrue(mx.array_equal(c1, c2))
+            c1 = mxop(a_mlx[rev_idx, :, :], axis=0)[rev_idx, :, :][1:, :, :]
+            c2 = mxop(a_mlx, axis=0, inclusive=False, reverse=True)[:-1, :, :]
+            self.assertTrue(mx.array_equal(c1, c2))
+
+        a = mx.random.uniform(shape=(8, 32))
+        mat = mx.tri(32)
+        for t in [mx.float16, mx.bfloat16]:
+            a_t = a.astype(t)
+            mat_t = mat.astype(t)
+            out = mx.cumsum(a_t, axis=-1)
+            expected = (mat_t * a_t[:, None, :]).sum(axis=-1)
+            self.assertTrue(mx.allclose(out, expected, rtol=0.02, atol=1e-3))
+        sizes = [1023, 1024, 1025, 2047, 2048, 2049]
+        for s in sizes:
+            a = mx.ones((s,), mx.int32)
+            out = mx.cumsum(a)
+            expected = mx.arange(1, s + 1, dtype=mx.int32)
+            self.assertTrue(mx.array_equal(expected, out))
+
+            # non-contiguous scan
+            a = mx.ones((s, 2), mx.int32)
+            out = mx.cumsum(a, axis=0)
+            expected = mx.repeat(expected[:, None], 2, axis=1)
+            self.assertTrue(mx.array_equal(expected, out))
+
+        # Test donation
+        def fn(its):
+            x = mx.ones((32,))
+            for _ in range(its):
+                x = mx.cumsum(x)
+            return x
+
+        mx.synchronize()
+        mx.eval(fn(2))
+        mx.synchronize()
+        mem2 = mx.get_peak_memory()
+        mx.eval(fn(4))
+        mx.synchronize()
+        mem4 = mx.get_peak_memory()
+        self.assertEqual(mem2, mem4)
+
+    def test_squeeze_expand(self):
+        a = mx.zeros((2, 1, 2, 1))
+        self.assertEqual(mx.squeeze(a).shape, (2, 2))
+        self.assertEqual(mx.squeeze(a, 1).shape, (2, 2, 1))
+        self.assertEqual(mx.squeeze(a, [1, 3]).shape, (2, 2))
+        self.assertEqual(a.squeeze().shape, (2, 2))
+        self.assertEqual(a.squeeze(1).shape, (2, 2, 1))
+        self.assertEqual(a.squeeze([1, 3]).shape, (2, 2))
+
+        a = mx.zeros((2, 2))
+        self.assertEqual(mx.squeeze(a).shape, (2, 2))
+
+        self.assertEqual(mx.expand_dims(a, 0).shape, (1, 2, 2))
+        self.assertEqual(mx.expand_dims(a, (0, 1)).shape, (1, 1, 2, 2))
+        self.assertEqual(mx.expand_dims(a, [0, -1]).shape, (1, 2, 2, 1))
+
+    def test_sort(self):
+        shape = (6, 4, 10)
+        tests = product(
+            ("int32", "float32"),  # type
+            (None, 0, 1, 2),  # axis
+            (True, False),  # strided
+        )
+        for dtype, axis, strided in tests:
+            with self.subTest(dtype=dtype, axis=axis, strided=strided):
+                np.random.seed(0)
+                np_dtype = getattr(np, dtype)
+                a_np = np.random.uniform(0, 100, size=shape).astype(np_dtype)
+                a_mx = mx.array(a_np)
+                if strided:
+                    a_mx = a_mx[::2, :, ::2]
+                    a_np = a_np[::2, :, ::2]
+
+                b_np = np.sort(a_np, axis=axis)
+                b_mx = mx.sort(a_mx, axis=axis)
+
+                self.assertTrue(np.array_equal(b_np, b_mx))
+                self.assertEqual(b_mx.dtype, a_mx.dtype)
+
+                c_np = np.argsort(a_np, axis=axis)
+                c_mx = mx.argsort(a_mx, axis=axis)
+                d_np = np.take_along_axis(a_np, c_np, axis=axis)
+                d_mx = mx.take_along_axis(a_mx, c_mx, axis=axis)
+
+                self.assertTrue(np.array_equal(d_np, d_mx))
+                self.assertEqual(c_mx.dtype, mx.uint32)
+
+        # Set random seed
+        np.random.seed(0)
+
+        # Test multi-block sort
+        for strided in (False, True):
+            with self.subTest(strided=strided):
+                a_np = np.random.normal(size=(32769,)).astype(np.float32)
+                a_mx = mx.array(a_np)
+
+                if strided:
+                    a_mx = a_mx[::3]
+                    a_np = a_np[::3]
+
+                b_np = np.sort(a_np)
+                b_mx = mx.sort(a_mx)
+
+                self.assertTrue(np.array_equal(b_np, b_mx))
+                self.assertEqual(b_mx.dtype, a_mx.dtype)
+
+                # Test multi-dum multi-block sort
+                a_np = np.random.normal(size=(2, 4, 32769)).astype(np.float32)
+                a_mx = mx.array(a_np)
+
+                if strided:
+                    a_mx = a_mx[..., ::3]
+                    a_np = a_np[..., ::3]
+
+                b_np = np.sort(a_np, axis=-1)
+                b_mx = mx.sort(a_mx, axis=-1)
+
+                self.assertTrue(np.array_equal(b_np, b_mx))
+                self.assertEqual(b_mx.dtype, a_mx.dtype)
+
+                a_np = np.random.normal(size=(2, 32769, 4)).astype(np.float32)
+                a_mx = mx.array(a_np)
+
+                if strided:
+                    a_mx = a_mx[:, ::3]
+                    a_np = a_np[:, ::3]
+
+                b_np = np.sort(a_np, axis=1)
+                b_mx = mx.sort(a_mx, axis=1)
+
+                self.assertTrue(np.array_equal(b_np, b_mx))
+                self.assertEqual(b_mx.dtype, a_mx.dtype)
+
+        # test 0 strides
+        a_np = np.array([1, 0, 2, 1, 3, 0, 4, 0])
+        a_mx = mx.array(a_np)
+        b_np = np.broadcast_to(a_np, (16, 8))
+        b_mx = mx.broadcast_to(a_mx, (16, 8))
+        mx.eval(b_mx)
+        for axis in (0, 1):
+            c_np = np.sort(b_np, axis=axis)
+            c_mx = mx.sort(b_mx, axis=axis)
+            self.assertTrue(np.array_equal(c_np, c_mx))
+            self.assertEqual(b_mx.dtype, c_mx.dtype)
+
+        # Test very large array
+        if mx.default_device() == mx.gpu:
+            a_np = np.random.normal(20, 20, size=(2**22)).astype(np.float32)
+            a_mx = mx.array(a_np)
+
+            b_np = np.sort(a_np)
+            b_mx = mx.sort(a_mx)
+            self.assertTrue(np.array_equal(b_np, b_mx))
+
+        # 1D strided sort
+        a = mx.array([[4, 3], [2, 1], [5, 4], [3, 2]])
+        out = mx.argsort(a[:, 1])
+        expected = mx.array([1, 3, 0, 2], dtype=mx.uint32)
+        self.assertTrue(mx.array_equal(out, expected))
+
+        # Test array with singleton dim
+        out = mx.sort(mx.array([1, 2, 3]), axis=0)
+        self.assertTrue(mx.array_equal(out, mx.array([1, 2, 3])))
+
+        x = np.random.uniform(size=(1, 4, 8, 1)).astype(np.float32)
+        y_np = np.sort(x, axis=-2)
+        y_mx = mx.sort(mx.array(x), axis=-2)
+        self.assertTrue(np.array_equal(y_np, y_mx))
+
+        # Test many segments
+        a = mx.random.uniform(shape=(512, 128))
+        y_mx = mx.sort(a, axis=-1)
+        y_np = np.sort(np.array(a), axis=-1)
+        self.assertTrue(np.array_equal(y_np, y_mx))
+
+    def test_partition(self):
+        shape = (3, 4, 5)
+        for dtype in ("int32", "float32"):
+            for axis in (None, 0, 1, 2):
+                for kth in (-2, 0, 2):
+                    with self.subTest(dtype=dtype, axis=axis, kth=kth):
+                        np.random.seed(0)
+                        np_dtype = getattr(np, dtype)
+                        a_np = np.random.uniform(0, 100, size=shape).astype(np_dtype)
+                        a_mx = mx.array(a_np)
+
+                        b_np = np.partition(a_np, kth, axis=axis)
+                        b_mx = mx.partition(a_mx, kth, axis=axis)
+
+                        c_np = np.take(b_np, (kth,), axis=axis)
+                        c_mx = np.take(np.array(b_mx), (kth,), axis=axis)
+
+                        self.assertTrue(np.array_equal(c_np, c_mx))
+                        self.assertEqual(b_mx.dtype, a_mx.dtype)
+
+                        if kth >= 0:
+                            top_k_mx = mx.topk(a_mx, kth, axis=axis)
+                            top_k_np = np.take(
+                                np.partition(a_np, -kth, axis=axis), (-kth,), axis=axis
+                            )
+                            self.assertTrue(np.all(top_k_np <= top_k_mx))
+                            self.assertEqual(top_k_mx.dtype, a_mx.dtype)
+                            N = a_mx.shape[axis] if axis is not None else a_mx.size
+                            M = top_k_mx.shape[axis or 0]
+                            self.assertEqual(M, (kth + N) % N)
+
+    def test_argpartition(self):
+        x = mx.broadcast_to(mx.array([1, 2, 3]), (2, 3))
+        out = mx.argpartition(x, kth=1, axis=0)
+        expected = mx.array([[0, 0, 0], [1, 1, 1]])
+        self.assertTrue(mx.array_equal(out, expected))
+
+        x = mx.array([[1, 2], [3, 4]]).T
+        out = mx.argpartition(x, kth=1, axis=0)
+        expected = mx.array([[0, 0], [1, 1]])
+        self.assertTrue(mx.array_equal(out, expected))
+
+    @unittest.skipIf(
+        os.getenv("LOW_MEMORY", None) is not None,
+        "This test requires a lot of memory",
+    )
+    def test_large_binary(self):
+        a = mx.ones([1000, 2147484], mx.int8)
+        b = mx.ones([2147484], mx.int8)
+        self.assertEqual((a + b)[0, 0].item(), 2)
+
+    def test_eye(self):
+        self.assertCmpNumpy([3], mx.eye, np.eye)
+        # Test for non-square matrix
+        self.assertCmpNumpy([3, 4], mx.eye, np.eye)
+        # Test with positive k parameter
+        self.assertCmpNumpy([3, 4], mx.eye, np.eye, k=1)
+        # Test with negative k parameter
+        self.assertCmpNumpy([5, 6], mx.eye, np.eye, k=-2)
+
+    def test_stack(self):
+        a = mx.ones((2,))
+        np_a = np.ones((2,))
+        b = mx.ones((2,))
+        np_b = np.ones((2,))
+
+        # One dimensional stack axis=0
+        c = mx.stack([a, b])
+        np_c = np.stack([np_a, np_b])
+        self.assertTrue(np.array_equal(c, np_c))
+
+        # One dimensional stack axis=1
+        c = mx.stack([a, b], axis=1)
+        np_c = np.stack([np_a, np_b], axis=1)
+        self.assertTrue(np.array_equal(c, np_c))
+
+        a = mx.ones((1, 2))
+        np_a = np.ones((1, 2))
+        b = mx.ones((1, 2))
+        np_b = np.ones((1, 2))
+
+        # Two dimensional stack axis=0
+        c = mx.stack([a, b])
+        np_c = np.stack([np_a, np_b])
+        self.assertTrue(np.array_equal(c, np_c))
+
+        # Two dimensional stack axis=1
+        c = mx.stack([a, b], axis=1)
+        np_c = np.stack([np_a, np_b], axis=1)
+        self.assertTrue(np.array_equal(c, np_c))
+
+    def test_flatten(self):
+        x = mx.zeros([2, 3, 4])
+        self.assertEqual(mx.flatten(x).shape, (2 * 3 * 4,))
+        self.assertEqual(mx.flatten(x, start_axis=1).shape, (2, 3 * 4))
+        self.assertEqual(mx.flatten(x, end_axis=1).shape, (2 * 3, 4))
+        self.assertEqual(x.flatten().shape, (2 * 3 * 4,))
+        self.assertEqual(x.flatten(start_axis=1).shape, (2, 3 * 4))
+        self.assertEqual(x.flatten(end_axis=1).shape, (2 * 3, 4))
+
+    def test_clip(self):
+        a = np.array([1, 4, 3, 8, 5], np.int32)
+        expected = np.clip(a, 2, 6)
+        clipped = mx.clip(mx.array(a), 2, 6)
+        self.assertTrue(np.array_equal(clipped, expected))
+
+        a = np.array([-1, 1, 0, 5], np.int32)
+        expected = np.clip(a, 0, None)
+        clipped = mx.clip(mx.array(a), 0, None)
+        self.assertTrue(np.array_equal(clipped, expected))
+
+        a = np.array([2, 3, 4, 5], np.int32)
+        expected = np.clip(a, None, 4)
+        clipped = mx.clip(mx.array(a), None, 4)
+        self.assertTrue(np.array_equal(clipped, expected))
+
+        mins = np.array([3, 1, 5, 5])
+        a = np.array([2, 3, 4, 5], np.int32)
+        expected = np.clip(a, mins, 4)
+        clipped = mx.clip(mx.array(a), mx.array(mins), 4)
+        self.assertTrue(np.array_equal(clipped, expected))
+
+        maxs = np.array([5, -1, 2, 9])
+        a = np.array([2, 3, 4, 5], np.int32)
+        expected = np.clip(a, mins, maxs)
+        clipped = mx.clip(mx.array(a), mx.array(mins), mx.array(maxs))
+        self.assertTrue(np.array_equal(clipped, expected))
+
+        # Check clip output types
+        a = mx.array([1, 2, 3], mx.int16)
+        out_t = mx.clip(a, a_min=0, a_max=5).dtype
+        self.assertEqual(out_t, mx.int16)
+
+        out_t = mx.clip(a, a_min=0.0, a_max=5).dtype
+        self.assertEqual(out_t, mx.float32)
+
+        a = mx.array([1, 2, 3], mx.float16)
+        out_t = mx.clip(a, a_min=0.0, a_max=5).dtype
+        self.assertEqual(out_t, mx.float16)
+
+        a = mx.array([1, 2, 3], mx.float16)
+        out_t = mx.clip(a, a_min=0.0, a_max=mx.array(1.0)).dtype
+        self.assertEqual(out_t, mx.float32)
+
+    def test_linspace(self):
+        # Test default num = 50
+        a = mx.linspace(0, 1)
+        expected = mx.array(np.linspace(0, 1))
+        self.assertEqualArray(a, expected)
+
+        # Test int64 dtype
+        b = mx.linspace(0, 10, 5, mx.int64)
+        expected = mx.array(np.linspace(0, 10, 5, dtype=int))
+        self.assertEqualArray(b, expected)
+
+        # Test negative sequence with float start and stop
+        c = mx.linspace(-2.7, -0.7, 7)
+        expected = mx.array(np.linspace(-2.7, -0.7, 7))
+        self.assertEqualArray(c, expected)
+
+        # Test irrational step size of 1/9
+        d = mx.linspace(0, 1, 10)
+        expected = mx.array(np.linspace(0, 1, 10))
+        self.assertEqualArray(d, expected)
+
+        # Test num equal to 1
+        d = mx.linspace(1, 10, 1)
+        expected = mx.array(np.linspace(1, 10, 1))
+        self.assertEqualArray(d, expected)
+
+        # Ensure that the start and stop are always the ones provided
+        ranges = mx.random.normal((16, 2)).tolist()
+        nums = (2 + mx.random.uniform(shape=(16,)) * 10).astype(mx.uint32).tolist()
+        for (a, b), n in zip(ranges, nums):
+            d = mx.linspace(a, b, n).tolist()
+            self.assertEqual(d[0], a)
+            self.assertEqual(d[-1], b)
+
+    def test_repeat(self):
+        # Setup data for the tests
+        data = mx.array([[[13, 3], [16, 6]], [[14, 4], [15, 5]], [[11, 1], [12, 2]]])
+        # Test repeat 0 times
+        self.assertCmpNumpy([data, 0], mx.repeat, np.repeat)
+        # Test repeat along axis 0
+        self.assertCmpNumpy([data, 2], mx.repeat, np.repeat, axis=0)
+        # Test repeat along axis 1
+        self.assertCmpNumpy([data, 2], mx.repeat, np.repeat, axis=1)
+        # Test repeat along the last axis (default)
+        self.assertCmpNumpy([data, 2], mx.repeat, np.repeat)
+        # Test repeat with a 1D array along axis 0
+        self.assertCmpNumpy([mx.array([1, 3, 2]), 3], mx.repeat, np.repeat, axis=0)
+        # Test repeat with a 2D array along axis 0
+        self.assertCmpNumpy(
+            [mx.array([[1, 2, 3], [4, 5, 4], [0, 1, 2]]), 2],
+            mx.repeat,
+            np.repeat,
+            axis=0,
+        )
+
+    def test_tensordot(self):
+        # No fp16 matmuls on common cpu backend
+        if not self.is_apple_silicon:
+            dtypes = [mx.float32]
+        else:
+            dtypes = [mx.float16, mx.float32]
+        for dtype in dtypes:
+            with self.subTest(dtype=dtype):
+                self.assertCmpNumpy(
+                    [(3, 4, 5), (4, 3, 2)],
+                    mx.tensordot,
+                    np.tensordot,
+                    dtype=dtype,
+                    axes=([1, 0], [0, 1]),
+                )
+                self.assertCmpNumpy(
+                    [(3, 4, 5), (4, 5, 6)],
+                    mx.tensordot,
+                    np.tensordot,
+                    dtype=dtype,
+                    axes=2,
+                )
+                self.assertCmpNumpy(
+                    [(3, 5, 4, 6), (6, 4, 5, 3)],
+                    mx.tensordot,
+                    np.tensordot,
+                    dtype=dtype,
+                    axes=([2, 1, 3], [1, 2, 0]),
+                )
+
+    def test_inner(self):
+        self.assertCmpNumpy([(3,), (3,)], mx.inner, np.inner)
+        self.assertCmpNumpy([(1, 1, 2), (3, 2)], mx.inner, np.inner)
+        self.assertCmpNumpy([(2, 3, 4), (4,)], mx.inner, np.inner)
+
+    def test_outer(self):
+        self.assertCmpNumpy([(3,), (3,)], mx.outer, np.outer)
+        self.assertCmpNumpy(
+            [
+                mx.ones(
+                    5,
+                ),
+                mx.linspace(-2, 2, 5),
+            ],
+            mx.outer,
+            np.outer,
+        )
+        self.assertCmpNumpy(
+            [
+                1j * mx.linspace(2, -2, 5),
+                mx.ones(
+                    5,
+                ),
+            ],
+            mx.outer,
+            np.outer,
+        )
+
+    def test_divmod(self):
+        # A few sizes for the inputs with and without broadcasting
+        sizes = [
+            ((1,), (1,)),
+            ((1,), (10,)),
+            ((10,), (1,)),
+            ((3,), (3,)),
+            ((2, 2, 2), (1, 2, 1)),
+            ((2, 1, 2), (1, 2, 1)),
+            ((2, 2, 2, 2), (2, 2, 2, 2)),
+        ]
+        types = [np.uint16, np.uint32, np.int32, np.float16, np.float32]
+        for s1, s2 in sizes:
+            for t in types:
+                a_np = np.random.uniform(1, 100, size=s1).astype(t)
+                b_np = np.random.uniform(1, 100, size=s2).astype(t)
+                np_out = np.divmod(a_np, b_np)
+                mx_out = mx.divmod(mx.array(a_np), mx.array(b_np))
+                self.assertTrue(
+                    np.allclose(np_out[0], mx_out[0]), msg=f"Shapes {s1} {s2}, Type {t}"
+                )
+
+    def test_tile(self):
+        self.assertCmpNumpy([(2,), [2]], mx.tile, np.tile)
+        self.assertCmpNumpy([(2, 3, 4), [2]], mx.tile, np.tile)
+        self.assertCmpNumpy([(2, 3, 4), [2, 1]], mx.tile, np.tile)
+        self.assertCmpNumpy(
+            [
+                (2, 3, 4),
+                [
+                    2,
+                    2,
+                ],
+            ],
+            mx.tile,
+            np.tile,
+        )
+        self.assertCmpNumpy([(3,), [2, 2, 2]], mx.tile, np.tile)
+
+    def test_empty_matmuls(self):
+        a = mx.array([])
+        b = mx.array([])
+        self.assertEqual(mx.inner(a, b).item(), 0.0)
+
+        a = mx.zeros((10, 0))
+        b = mx.zeros((0, 10))
+        out = a @ b
+        self.assertTrue(mx.array_equal(out, mx.zeros((10, 10))))
+
+    def test_diagonal(self):
+        x = mx.array(
+            [
+                [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]],
+                [[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23]],
+            ]
+        )
+        expected = [[0, 13], [4, 17], [8, 21]]
+
+        self.assertListEqual(mx.diagonal(x, 0, -1, 0).tolist(), expected)
+
+        expected = [[1, 14], [5, 18], [9, 22]]
+        self.assertListEqual(mx.diagonal(x, -1, 2, 0).tolist(), expected)
+
+    def test_diag(self):
+        # Test 1D input
+        x = mx.array([1, 2, 3, 4])
+        expected = mx.array([[1, 0, 0, 0], [0, 2, 0, 0], [0, 0, 3, 0], [0, 0, 0, 4]])
+        result = mx.diag(x)
+        self.assertTrue(mx.array_equal(result, expected))
+
+        # Test 1D with offset
+        x = mx.array([2, 6])
+        result = mx.diag(x, k=5)
+        expected = mx.array(np.diag(x, k=5))
+        self.assertTrue(mx.array_equal(result, expected))
+
+        # Test 2D input
+        x = mx.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        expected = mx.array([1, 5, 9])
+        result = mx.diag(x)
+        self.assertTrue(mx.array_equal(result, expected))
+
+        # Test with offset
+        expected = mx.array([2, 6])
+        result = mx.diag(x, 1)
+        self.assertTrue(mx.array_equal(result, expected))
+
+        # Test non-square
+        x = mx.array([[1, 2, 3], [4, 5, 6]])
+        result = mx.diag(x)
+        expected = mx.array(np.diag(x))
+        self.assertTrue(mx.array_equal(result, expected))
+
+        result = mx.diag(x, k=10)
+        expected = mx.array(np.diag(x, k=10))
+        self.assertTrue(mx.array_equal(result, expected))
+
+        result = mx.diag(x, k=-10)
+        expected = mx.array(np.diag(x, k=-10))
+        self.assertTrue(mx.array_equal(result, expected))
+
+        result = mx.diag(x, k=-1)
+        expected = mx.array(np.diag(x, k=-1))
+        self.assertTrue(mx.array_equal(result, expected))
+
+    def test_trace(self):
+        a_mx = mx.arange(9, dtype=mx.int64).reshape((3, 3))
+        a_np = np.arange(9, dtype=np.int64).reshape((3, 3))
+
+        # Test 2D array
+        result = mx.trace(a_mx)
+        expected = np.trace(a_np)
+        self.assertEqualArray(result, mx.array(expected))
+
+        # Test dtype
+        result = mx.trace(a_mx, dtype=mx.float16)
+        expected = np.trace(a_np, dtype=np.float16)
+        self.assertEqualArray(result, mx.array(expected))
+
+        # Test offset
+        result = mx.trace(a_mx, offset=1)
+        expected = np.trace(a_np, offset=1)
+        self.assertEqualArray(result, mx.array(expected))
+
+        # Test axis1 and axis2
+        b_mx = mx.arange(27, dtype=mx.int64).reshape(3, 3, 3)
+        b_np = np.arange(27, dtype=np.int64).reshape(3, 3, 3)
+
+        result = mx.trace(b_mx, axis1=1, axis2=2)
+        expected = np.trace(b_np, axis1=1, axis2=2)
+        self.assertEqualArray(result, mx.array(expected))
+
+        # Test offset, axis1, axis2, and dtype
+        result = mx.trace(b_mx, offset=1, axis1=1, axis2=2, dtype=mx.float32)
+        expected = np.trace(b_np, offset=1, axis1=1, axis2=2, dtype=np.float32)
+        self.assertEqualArray(result, mx.array(expected))
+
+    def test_atleast_1d(self):
+        # Test 1D input
+        arrays = [
+            [1],
+            [1, 2, 3],
+            [1, 2, 3, 4],
+            [[1], [2], [3]],
+            [[1, 2], [3, 4]],
+            [[1, 2, 3], [4, 5, 6]],
+            [[[[1]], [[2]], [[3]]]],
+        ]
+
+        mx_arrays = [mx.atleast_1d(mx.array(x)) for x in arrays]
+        atleast_arrays = mx.atleast_1d(*mx_arrays)
+
+        for i, array in enumerate(arrays):
+            mx_res = mx.atleast_1d(mx.array(array))
+            np_res = np.atleast_1d(np.array(array))
+            self.assertEqual(mx_res.shape, np_res.shape)
+            self.assertEqual(mx_res.ndim, np_res.ndim)
+            self.assertTrue(mx.array_equal(mx_res, atleast_arrays[i]))
+
+    def test_atleast_2d(self):
+        # Test 1D input
+        arrays = [
+            [1],
+            [1, 2, 3],
+            [1, 2, 3, 4],
+            [[1], [2], [3]],
+            [[1, 2], [3, 4]],
+            [[1, 2, 3], [4, 5, 6]],
+            [[[[1]], [[2]], [[3]]]],
+        ]
+
+        mx_arrays = [mx.atleast_2d(mx.array(x)) for x in arrays]
+        atleast_arrays = mx.atleast_2d(*mx_arrays)
+
+        for i, array in enumerate(arrays):
+            mx_res = mx.atleast_2d(mx.array(array))
+            np_res = np.atleast_2d(np.array(array))
+            self.assertEqual(mx_res.shape, np_res.shape)
+            self.assertEqual(mx_res.ndim, np_res.ndim)
+            self.assertTrue(mx.array_equal(mx_res, atleast_arrays[i]))
+
+    def test_atleast_3d(self):
+        # Test 1D input
+        arrays = [
+            [1],
+            [1, 2, 3],
+            [1, 2, 3, 4],
+            [[1], [2], [3]],
+            [[1, 2], [3, 4]],
+            [[1, 2, 3], [4, 5, 6]],
+            [[[[1]], [[2]], [[3]]]],
+        ]
+
+        mx_arrays = [mx.atleast_3d(mx.array(x)) for x in arrays]
+        atleast_arrays = mx.atleast_3d(*mx_arrays)
+
+        for i, array in enumerate(arrays):
+            mx_res = mx.atleast_3d(mx.array(array))
+            np_res = np.atleast_3d(np.array(array))
+            self.assertEqual(mx_res.shape, np_res.shape)
+            self.assertEqual(mx_res.ndim, np_res.ndim)
+            self.assertTrue(mx.array_equal(mx_res, atleast_arrays[i]))
+
+    def test_issubdtype(self):
+        self.assertTrue(mx.issubdtype(mx.bfloat16, mx.inexact))
+
+        cats = [
+            "complexfloating",
+            "floating",
+            "inexact",
+            "signedinteger",
+            "unsignedinteger",
+            "integer",
+            "number",
+            "generic",
+            "bool_",
+            "uint8",
+            "uint16",
+            "uint32",
+            "uint64",
+            "int8",
+            "int16",
+            "int32",
+            "int64",
+            "float16",
+            "float32",
+            "complex64",
+        ]
+
+        for a in cats:
+            for b in cats:
+                self.assertEqual(
+                    mx.issubdtype(getattr(mx, a), getattr(mx, b)),
+                    np.issubdtype(getattr(np, a), getattr(np, b)),
+                    f"mx and np don't aggree on {a}, {b}",
+                )
+
+    def test_bitwise_ops(self):
+        types = [
+            mx.uint8,
+            mx.uint16,
+            mx.uint32,
+            mx.uint64,
+            mx.int8,
+            mx.int16,
+            mx.int32,
+            mx.int64,
+        ]
+        a = mx.random.randint(0, 4096, (1000,))
+        b = mx.random.randint(0, 4096, (1000,))
+        for op in ["bitwise_and", "bitwise_or", "bitwise_xor"]:
+            for t in types:
+                a_mlx = a.astype(t)
+                b_mlx = b.astype(t)
+                a_np = np.array(a_mlx)
+                b_np = np.array(b_mlx)
+                out_mlx = getattr(mx, op)(a_mlx, b_mlx)
+                out_np = getattr(np, op)(a_np, b_np)
+                self.assertTrue(np.array_equal(np.array(out_mlx), out_np))
+        for op in ["left_shift", "right_shift"]:
+            for t in types:
+                a_mlx = a.astype(t)
+                b_mlx = mx.random.randint(0, t.size, (1000,)).astype(t)
+                a_np = np.array(a_mlx)
+                b_np = np.array(b_mlx)
+                out_mlx = getattr(mx, op)(a_mlx, b_mlx)
+                out_np = getattr(np, op)(a_np, b_np)
+                self.assertTrue(np.array_equal(np.array(out_mlx), out_np))
+
+        for t in types:
+            a_mlx = a.astype(t)
+            a_np = np.array(a_mlx)
+
+            out_mlx = ~a_mlx
+            out_np = ~a_np
+            self.assertTrue(np.array_equal(np.array(out_mlx), out_np))
+
+            out_mlx = mx.bitwise_invert(a_mlx)
+            out_np = mx.bitwise_invert(a_np)
+            self.assertTrue(np.array_equal(np.array(out_mlx), out_np))
+
+        # Check broadcasting
+        a = mx.ones((3, 1, 5), dtype=mx.bool_)
+        b = mx.zeros((1, 2, 5), dtype=mx.bool_)
+        c = a | b
+        self.assertEqual(c.shape, (3, 2, 5))
+        self.assertTrue(mx.array_equal(c, mx.ones((3, 2, 5), dtype=mx.bool_)))
+
+    def test_bitwise_grad(self):
+        a = np.random.randint(0, 10, size=(4, 3))
+        b = np.random.randint(0, 10, size=(4, 3))
+        cotangent = np.random.randint(0, 10, size=(4, 3))
+        a = mx.array(a)
+        b = mx.array(b)
+        cotangent = mx.array(cotangent)
+
+        def bitwise(a, b):
+            return a.astype(mx.int32) & b.astype(mx.int32)
+
+        _, vjps = mx.vjp(bitwise, [a, b], [cotangent])
+        for vjp in vjps:
+            self.assertFalse(np.any(np.array(vjp)))
+
+    def test_conjugate(self):
+        shape = (3, 5, 7)
+        a = np.random.normal(size=shape) + 1j * np.random.normal(size=shape)
+        a = a.astype(np.complex64)
+        ops = ["conjugate", "conj"]
+        for op in ops:
+            out_mlx = getattr(mx, op)(mx.array(a))
+            out_np = getattr(np, op)(a)
+            self.assertTrue(np.array_equal(np.array(out_mlx), out_np))
+        out_mlx = mx.array(a).conj()
+        out_np = a.conj()
+        self.assertTrue(np.array_equal(np.array(out_mlx), out_np))
+
+    def test_view(self):
+        # Check scalar
+        out = mx.array(1, mx.int8).view(mx.uint8).item()
+        self.assertEqual(out, 1)
+
+        a = mx.random.randint(shape=(4, 2, 4), low=-100, high=100)
+        a_np = np.array(a)
+
+        for t in ["bool_", "int16", "float32", "int64"]:
+            out = a.view(getattr(mx, t))
+            expected = a_np.view(getattr(np, t))
+            self.assertTrue(np.array_equal(out, expected, equal_nan=True))
+
+        # Irregular strides
+        a = mx.random.randint(shape=(2, 4), low=-100, high=100)
+        a = mx.broadcast_to(a, shape=(4, 2, 4))
+
+        for t in ["bool_", "int16", "float32", "int64"]:
+            out = a.view(getattr(mx, t))
+            a_out = out.view(mx.int32)
+            self.assertTrue(mx.array_equal(a_out, a, equal_nan=True))
+
+        a = mx.random.randint(shape=(4, 4), low=-100, high=100).T
+        for t in ["bool_", "int16", "float32", "int64"]:
+            out = a.view(getattr(mx, t))
+            a_out = out.view(mx.int32)
+            self.assertTrue(mx.array_equal(a_out, a, equal_nan=True))
+
+    def _hadamard(self, N):
+        # Matches scipy.linalg.hadamard
+        H = np.array([[1]], dtype=np.int64)
+        for i in range(0, np.log2(N).astype(np.int64)):
+            H = np.vstack((np.hstack((H, H)), np.hstack((H, -H))))
+        return H
+
+    def test_hadamard(self):
+        with self.assertRaises(ValueError):
+            mx.hadamard_transform(mx.array([]))
+
+        h28_str = """
+        +------++----++-+--+-+--++--
+        -+-----+++-----+-+--+-+--++-
+        --+-----+++---+-+-+----+--++
+        ---+-----+++---+-+-+-+--+--+
+        ----+-----+++---+-+-+++--+--
+        -----+-----++++--+-+--++--+-
+        ------++----++-+--+-+--++--+
+        --++++-+-------++--+++-+--+-
+        ---++++-+-----+-++--+-+-+--+
+        +---+++--+----++-++--+-+-+--
+        ++---++---+----++-++--+-+-+-
+        +++---+----+----++-++--+-+-+
+        ++++--------+-+--++-++--+-+-
+        -++++--------+++--++--+--+-+
+        -+-++-++--++--+--------++++-
+        +-+-++--+--++--+--------++++
+        -+-+-++--+--++--+----+---+++
+        +-+-+-++--+--+---+---++---++
+        ++-+-+-++--+------+--+++---+
+        -++-+-+-++--+------+-++++---
+        +-++-+---++--+------+-++++--
+        -++--++-+-++-+++----++------
+        +-++--++-+-++-+++-----+-----
+        ++-++---+-+-++-+++-----+----
+        -++-++-+-+-+-+--+++-----+---
+        --++-++++-+-+----+++-----+--
+        +--++-+-++-+-+----+++-----+-
+        ++--++-+-++-+-+----++------+
+        """
+
+        def parse_h_string(h_str):
+            return np.array(
+                [[1 if s == "+" else -1 for s in row] for row in h_str.split()]
+            )
+
+        h28 = parse_h_string(h28_str)
+
+        x = mx.array(5)
+        y = mx.hadamard_transform(x)
+        self.assertEqual(y.item(), 5)
+
+        x = mx.array(5)
+        y = mx.hadamard_transform(x, scale=0.2)
+        self.assertEqual(y.item(), 1)
+
+        x = mx.random.normal((8, 8, 1))
+        y = mx.hadamard_transform(x)
+        self.assertTrue(mx.all(y == x).item())
+
+        # Too slow to compare to numpy so let's compare CPU to GPU
+        if mx.default_device() == mx.gpu:
+            rk = mx.random.key(42)
+            for k in range(14, 17):
+                for m in [1, 3, 5, 7]:
+                    x = mx.random.normal((4, m * 2**k), key=rk)
+                    y1 = mx.hadamard_transform(x, stream=mx.cpu)
+                    y2 = mx.hadamard_transform(x, stream=mx.gpu)
+                    self.assertLess(mx.abs(y1 - y2).max().item(), 5e-6)
+
+        np.random.seed(7)
+        tests = product([np.float32, np.float16, np.int32], [1, 28], range(1, 14))
+        for dtype, m, k in tests:
+            # skip large m=28 cases because they're very slow in NumPy
+            if m > 1 and k > 8:
+                continue
+            with self.subTest(dtype=dtype, m=m, k=k):
+                n = m * 2**k
+                b = 4
+                scale = 0.34
+                x = np.random.normal(size=(b, n)).astype(dtype)
+                # contiguity check
+                x = mx.array(x)[::2]
+                y = mx.hadamard_transform(x, scale=scale)
+                mx.eval(y)
+                h = (
+                    self._hadamard(2**k)
+                    if m == 1
+                    else np.kron(h28, self._hadamard(2**k))
+                )
+                y_np = np.einsum("ij,bj->bi", h, x) * scale
+                atol = 2e-4 if dtype == np.float32 else 5e-2 * k
+                np.testing.assert_allclose(y, y_np, atol=atol)
+
+                # bfloat16 emulation on M1 means 2**14 doesn't fit in threadgroup memory
+                if dtype == np.float16 and k < 14:
+                    y_bf16 = mx.hadamard_transform(x.astype(mx.bfloat16), scale=scale)
+                    np.testing.assert_allclose(
+                        y_bf16.astype(mx.float16), y, atol=atol * 2
+                    )
+
+    def test_hadamard_grad_vmap(self):
+        np.random.seed(4)
+
+        for k in range(2, 8):
+            n = 2**k
+            x = np.random.normal(size=(n,))
+            h = self._hadamard(n)
+            c = np.random.normal(size=(n,))
+            x = mx.array(x).astype(mx.float32)
+            h = mx.array(h).astype(mx.float32)
+            c = mx.array(c).astype(mx.float32)
+
+            def hadamard_transform(x):
+                return h @ x / mx.sqrt(x.shape[-1])
+
+            out = mx.vjp(hadamard_transform, [x], [c])
+            out_t = mx.vjp(mx.hadamard_transform, [x], [c])
+            np.testing.assert_allclose(out, out_t, atol=1e-4)
+
+            for axis in (0, 1, 2):
+                vht = mx.vmap(mx.vmap(hadamard_transform, 0, 0), axis, axis)
+                vht_t = mx.vmap(mx.vmap(mx.hadamard_transform, 0, 0), axis, axis)
+
+                xb = mx.array(np.random.normal(size=(n, n, n)))
+                out = vht(xb)
+                out_t = vht_t(xb)
+                np.testing.assert_allclose(out, out_t, atol=1e-4)
+
+    def test_roll(self):
+        x = mx.arange(10).reshape(2, 5)
+
+        for s in [-2, -1, 0, 1, 2]:
+            y1 = np.roll(x, s)
+            y2 = mx.roll(x, s)
+            self.assertTrue(mx.array_equal(y1, y2).item())
+
+            y1 = np.roll(x, (s, s, s))
+            y2 = mx.roll(x, (s, s, s))
+            self.assertTrue(mx.array_equal(y1, y2).item())
+
+        shifts = [
+            1,
+            2,
+            -1,
+            -2,
+            (1, 1),
+            (-1, 2),
+            (33, 33),
+        ]
+        axes = [
+            0,
+            1,
+            (1, 0),
+            (0, 1),
+            (0, 0),
+            (1, 1),
+        ]
+        for s, a in product(shifts, axes):
+            y1 = np.roll(x, s, a)
+            y2 = mx.roll(x, s, a)
+            self.assertTrue(mx.array_equal(y1, y2).item())
+
+    def test_roll_errors(self):
+        x = mx.array([])
+        result = mx.roll(x, [0], [0])
+        self.assertTrue(mx.array_equal(result, x))
+
+    def test_real_imag(self):
+        x = mx.random.uniform(shape=(4, 4))
+        out = mx.real(x)
+        self.assertTrue(mx.array_equal(x, out))
+
+        out = mx.imag(x)
+        self.assertTrue(mx.array_equal(mx.zeros_like(x), out))
+
+        y = mx.random.uniform(shape=(4, 4))
+        z = x + 1j * y
+        self.assertEqual(mx.real(z).dtype, mx.float32)
+        self.assertTrue(mx.array_equal(mx.real(z), x))
+        self.assertEqual(mx.imag(z).dtype, mx.float32)
+        self.assertTrue(mx.array_equal(mx.imag(z), y))
+
+    def test_dynamic_slicing(self):
+        x = mx.random.randint(0, 100, shape=(4, 4, 4))
+        expected = x[1:, 2:, 3:]
+        out = mx.slice(x, mx.array([1, 2, 3]), (0, 1, 2), (3, 2, 1))
+        self.assertTrue(mx.array_equal(expected, out))
+
+        x = mx.zeros(shape=(4, 4, 4))
+        update = mx.random.randint(0, 100, shape=(3, 2, 1))
+        out = mx.slice_update(x, update, mx.array([1, 2, 3]), (0, 1, 2))
+        expected = mx.zeros_like(x)
+        expected[1:, 2:, 3:] = update
+        self.assertTrue(mx.array_equal(expected, out))
+
+    def test_broadcast_arrays(self):
+        a = mx.array(1)
+        b = mx.array(1.0)
+        a, b = mx.broadcast_arrays(a, b)
+        self.assertEqual(a.shape, ())
+        self.assertEqual(a.dtype, mx.int32)
+        self.assertEqual(b.shape, ())
+        self.assertEqual(b.dtype, mx.float32)
+
+        a, b = mx.broadcast_arrays(mx.zeros((3, 1, 2)), mx.zeros((4, 1)))
+        self.assertEqual(a.shape, (3, 4, 2))
+        self.assertEqual(b.shape, (3, 4, 2))
+
+    def test_slice_update_reversed(self):
+        a = mx.array([1, 2, 3, 4])
+        b = a[::-1]
+        b[::2] = 0
+        self.assertTrue(mx.array_equal(b, mx.array([0, 3, 0, 1])))
+
+    def test_slice_with_negative_stride(self):
+        a = mx.random.uniform(shape=(128, 4))
+        out = a[::-1]
+        self.assertTrue(mx.array_equal(out[-1, :], a[0, :]))
+
+    def test_complex_ops(self):
+        x = mx.array(
+            [
+                3.0 + 4.0j,
+                -5.0 + 12.0j,
+                -8.0 + 0.0j,
+                0.0 + 9.0j,
+                0.0 + 0.0j,
+            ]
+        )
+
+        ops = ["arccos", "arcsin", "arctan", "square", "sqrt"]
+        for op in ops:
+            with self.subTest(op=op):
+                np_op = getattr(np, op)
+                mx_op = getattr(mx, op)
+                self.assertTrue(np.allclose(mx_op(x), np_op(x)))
+
+        x = mx.array(
+            [
+                3.0 + 4.0j,
+                -5.0 + 12.0j,
+                -8.0 + 0.0j,
+                0.0 + 9.0j,
+                9.0 + 1.0j,
+            ]
+        )
+        self.assertTrue(np.allclose(mx.rsqrt(x), 1.0 / np.sqrt(x)))
+
+    def test_complex_power(self):
+        out = mx.power(mx.array(0j), 2)
+        self.assertEqual(out.item(), 0j)
+
+        out = mx.power(mx.array(0j), float("nan"))
+        self.assertTrue(mx.isnan(out))
+
+    def test_irregular_alignments(self):
+        # Unaligned unary op
+        a = mx.ones((64, 1))
+        b = -a[1:]
+        self.assertTrue(mx.all(b == -1.0))
+
+        # Unaligned binary op
+        a = mx.ones((64, 1))
+        b = a[1:]
+        c = b + b
+        self.assertTrue(mx.all(c == 2.0))
+
+        # Unaligned ternary op
+        a = mx.ones((64, 1))
+        b = mx.zeros((63, 1))
+        c = mx.ones((63, 1)).astype(mx.bool_)
+        d = mx.where(c, a[1:], b)
+        self.assertTrue(mx.all(d == 1.0))
+
+    def test_integer_power(self):
+        x = mx.power(2, mx.array([8, 8, 8, 8, 8, 8, 8, 8]))
+        self.assertTrue(mx.all(x == 256))
+
+        # Doesn't hang
+        x = mx.power(2, -1)
+
+    def test_depends(self):
+        a = mx.array([1.0, 2.0, 3.0])
+        b = mx.exp(a)
+        c = mx.log(a)
+        out = mx.depends([b], [c])[0]
+        self.assertTrue(mx.array_equal(out, b))
+
+        a = mx.array([1.0, 2.0, 3.0])
+        b = mx.exp(a)
+        c = mx.log(a)
+        out = mx.depends(b, c)
+        self.assertTrue(mx.array_equal(out, b))
+
+
+class TestBroadcast(mlx_tests.MLXTestCase):
+    def test_broadcast_shapes(self):
+        # Basic broadcasting
+        self.assertEqual(mx.broadcast_shapes((1, 2, 3), (3,)), (1, 2, 3))
+        self.assertEqual(mx.broadcast_shapes((4, 1, 6), (5, 6)), (4, 5, 6))
+        self.assertEqual(mx.broadcast_shapes((5, 1, 4), (1, 3, 4)), (5, 3, 4))
+
+        # Multiple arguments
+        self.assertEqual(mx.broadcast_shapes((1, 1), (1, 8), (7, 1)), (7, 8))
+        self.assertEqual(
+            mx.broadcast_shapes((6, 1, 5), (1, 7, 1), (6, 7, 5)), (6, 7, 5)
+        )
+
+        # Same shapes
+        self.assertEqual(mx.broadcast_shapes((3, 4, 5), (3, 4, 5)), (3, 4, 5))
+
+        # Single argument
+        self.assertEqual(mx.broadcast_shapes((2, 3)), (2, 3))
+
+        # Empty shapes
+        self.assertEqual(mx.broadcast_shapes((), ()), ())
+        self.assertEqual(mx.broadcast_shapes((), (1,)), (1,))
+        self.assertEqual(mx.broadcast_shapes((1,), ()), (1,))
+
+        # Broadcasting with zeroes
+        self.assertEqual(mx.broadcast_shapes((0,), (0,)), (0,))
+        self.assertEqual(mx.broadcast_shapes((1, 0, 5), (3, 1, 5)), (3, 0, 5))
+        self.assertEqual(mx.broadcast_shapes((5, 0), (0, 5, 0)), (0, 5, 0))
+
+        # Error cases
+        with self.assertRaises(ValueError):
+            mx.broadcast_shapes((3, 4), (4, 3))
+
+        with self.assertRaises(ValueError):
+            mx.broadcast_shapes((2, 3, 4), (2, 5, 4))
+
+        with self.assertRaises(ValueError):
+            mx.broadcast_shapes()
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_optimizers.py b/ml-stable-diffusion/mlx/python/tests/test_optimizers.py
new file mode 100644
index 0000000000000000000000000000000000000000..6869ac357a55f73bac2e42bf6fef6bdc9d938287
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_optimizers.py
@@ -0,0 +1,584 @@
+# Copyright © 2023 Apple Inc.
+
+import inspect
+import math
+import unittest
+from functools import partial
+
+import mlx.core as mx
+import mlx.nn as nn
+import mlx.optimizers as opt
+import mlx.utils
+import mlx_tests
+import numpy as np
+from mlx.utils import tree_flatten, tree_map, tree_unflatten
+
+try:
+    import torch
+    import torch.nn.functional as F
+
+    has_torch = True
+except ImportError as e:
+    has_torch = False
+
+
+def get_all_optimizers():
+    classes = dict()
+    for name, obj in inspect.getmembers(opt):
+        if (
+            inspect.isclass(obj)
+            and issubclass(obj, opt.Optimizer)
+            and obj != opt.Optimizer
+        ):
+            classes[name] = obj
+    return classes
+
+
+def tree_equal(fn, *args):
+    return all(v for _, v in tree_flatten(tree_map(fn, *args)))
+
+
+optimizers_dict = get_all_optimizers()
+del optimizers_dict["MultiOptimizer"]
+
+
+class TestOptimizers(mlx_tests.MLXTestCase):
+    def test_optimizer_state(self):
+        optim = opt.SGD(0.1)
+        optim.state["hello"] = "world"
+        self.assertEqual(optim.state["hello"], "world")
+
+        optim.state = {0: 1}
+        self.assertEqual(optim.state, {0: 1})
+
+    def test_optimizers(self):
+        params = {
+            "first": [mx.zeros((10,)), mx.zeros((1,))],
+            "second": mx.zeros((1,)),
+        }
+        grads = tree_map(lambda x: mx.ones_like(x), params)
+
+        for optim_class in optimizers_dict.values():
+            optim = optim_class(0.1)
+            update = optim.apply_gradients(grads, params)
+            mx.eval(update)
+            equal_shape = tree_map(lambda x, y: x.shape == y.shape, params, update)
+            all_equal = all(v for _, v in mlx.utils.tree_flatten(equal_shape))
+            self.assertTrue(all_equal)
+
+    def test_types_conserved(self):
+        params = {"w": mx.ones((5, 5), mx.float16)}
+        grads = tree_map(lambda x: mx.ones_like(x), params)
+        for optim_class in optimizers_dict.values():
+            optim = optim_class(0.1)
+            update = optim.apply_gradients(grads, params)
+            self.assertEqual(update["w"].dtype, mx.float16)
+
+    def test_sgd(self):
+        params = {
+            "first": [mx.zeros((10,)), mx.zeros((1,))],
+            "second": mx.zeros((1,)),
+        }
+        grads = tree_map(lambda x: mx.ones_like(x), params)
+
+        # Explicit init
+        optim = opt.SGD(learning_rate=1e-2, momentum=0.9)
+        optim.init(params)
+        self.assertTrue(
+            tree_equal(
+                lambda p, s: mx.array_equal(s["v"], mx.zeros_like(p)),
+                params,
+                optim.state,
+            )
+        )
+
+        # Implicit init
+        optim = opt.SGD(learning_rate=1e-2, momentum=0.9)
+        optim.apply_gradients(grads, params)
+        self.assertTrue(
+            tree_equal(lambda g, s: mx.array_equal(s["v"], g), grads, optim.state)
+        )
+
+    def test_rmsprop(self):
+        params = {
+            "first": [mx.zeros((10,)), mx.zeros((1,))],
+            "second": mx.zeros((1,)),
+        }
+        grads = tree_map(lambda x: mx.ones_like(x), params)
+
+        # Explicit init
+        optim = opt.RMSprop(learning_rate=1e-2)
+        optim.init(params)
+        self.assertTrue(
+            tree_equal(
+                lambda p, s: mx.array_equal(s["v"], mx.zeros_like(p)),
+                params,
+                optim.state,
+            )
+        )
+
+        # Implicit init
+        alpha = 0.99
+        optim = opt.RMSprop(learning_rate=1e-2, alpha=alpha)
+        optim.apply_gradients(grads, params)
+        self.assertTrue(
+            tree_equal(
+                lambda g, s: mx.allclose(s["v"], (1 - alpha) * g), grads, optim.state
+            )
+        )
+
+    def test_adagrad(self):
+        params = {
+            "first": [mx.zeros((10,)), mx.zeros((1,))],
+            "second": mx.zeros((1,)),
+        }
+        grads = tree_map(lambda x: mx.ones_like(x), params)
+
+        # Explicit init
+        optim = opt.Adagrad(learning_rate=1e-2)
+        optim.init(params)
+        self.assertTrue(
+            tree_equal(
+                lambda p, s: mx.array_equal(s["v"], mx.zeros_like(p)),
+                params,
+                optim.state,
+            )
+        )
+
+    def test_adadelta(self):
+        params = {
+            "first": [mx.zeros((10,)), mx.zeros((1,))],
+            "second": mx.zeros((1,)),
+        }
+        grads = tree_map(lambda x: mx.ones_like(x), params)
+
+        # Explicit init
+        optim = opt.AdaDelta(learning_rate=1e-2)
+        optim.init(params)
+        self.assertTrue(
+            tree_equal(
+                lambda p, s: mx.array_equal(s["v"], mx.zeros_like(p)),
+                params,
+                optim.state,
+            )
+        )
+        self.assertTrue(
+            tree_equal(
+                lambda p, s: mx.array_equal(s["u"], mx.zeros_like(p)),
+                params,
+                optim.state,
+            )
+        )
+
+    def test_adam(self):
+        params = {
+            "first": [mx.zeros((10,)), mx.zeros((1,))],
+            "second": mx.zeros((1,)),
+        }
+        grads = tree_map(lambda x: mx.ones_like(x), params)
+
+        # Explicit init
+        for optimizer in [opt.Adam, opt.AdamW, opt.Adamax]:
+            optim = optimizer(learning_rate=1e-2)
+            optim.init(params)
+            self.assertTrue(
+                tree_equal(
+                    lambda p, s: mx.array_equal(s["v"], mx.zeros_like(p)),
+                    params,
+                    optim.state,
+                )
+            )
+            self.assertTrue(
+                tree_equal(
+                    lambda p, s: mx.array_equal(s["m"], mx.zeros_like(p)),
+                    params,
+                    optim.state,
+                )
+            )
+
+        # Test for correct gradient type propagation
+        params = tree_map(lambda x: x.astype(mx.float16), params)
+        grads = tree_map(lambda x: x.astype(mx.float16), grads)
+        optim = opt.Adam(1e-2, bias_correction=True)
+        new_params = optim.apply_gradients(grads, params)
+        self.assertTrue(tree_equal(lambda p: p.dtype == mx.float16, new_params))
+
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_adamw_matches_pytorch(self):
+        mx.random.seed(0)
+        np.random.seed(0)
+
+        model = nn.Linear(3, 1)
+        init_weight = np.array(model.weight.tolist())
+        init_bias = np.array(model.bias.tolist())
+
+        def loss_fn(model, x, y):
+            pred = model(x)
+            return nn.losses.mse_loss(pred, y)
+
+        x = np.random.rand(3, 3)
+        y = np.random.rand(3, 1)
+
+        optimizer = opt.AdamW(learning_rate=3e-4, bias_correction=True)
+        loss_and_grad_fn = nn.value_and_grad(model, loss_fn)
+        loss, grads = loss_and_grad_fn(model, mx.array(x), mx.array(y))
+        optimizer.update(model, grads)
+
+        # Equivalent torch code
+        torch_model = torch.nn.Linear(3, 1)
+
+        # copy over the parameters
+        torch_model.weight.data = torch.tensor(init_weight, dtype=torch.float32)
+        torch_model.bias.data = torch.tensor(init_bias, dtype=torch.float32)
+
+        torch_optimizer = torch.optim.AdamW(torch_model.parameters(), lr=3e-4)
+        torch_optimizer.zero_grad()
+        pred = torch_model(torch.tensor(x, dtype=torch.float32))
+        loss = torch.nn.MSELoss()(pred, torch.tensor(y, dtype=torch.float32))
+        loss.backward()
+        torch_optimizer.step()
+
+        for name, param in torch_model.named_parameters():
+            mlx_grad = np.array(grads[name])
+            torch_grad = param.grad.detach().numpy()
+            self.assertTrue(np.allclose(torch_grad, mlx_grad))
+
+        for name, param in torch_model.named_parameters():
+            mlx_param = np.array(model[name])
+            torch_param = param.data.detach().numpy()
+            self.assertTrue(np.allclose(torch_param, mlx_param))
+
+    def test_lion(self):
+        params = {
+            "first": [mx.zeros((10,)), mx.zeros((1,))],
+            "second": mx.zeros((1,)),
+        }
+        grads = tree_map(lambda x: mx.ones_like(x), params)
+
+        # Explicit init
+        optim = opt.Lion(learning_rate=1e-2)
+        optim.init(params)
+        self.assertTrue(
+            tree_equal(
+                lambda p, s: mx.array_equal(s["m"], mx.zeros_like(p)),
+                params,
+                optim.state,
+            )
+        )
+
+    def test_adafactor(self):
+        x = mx.zeros((5, 5))
+        params = {"x": x}
+        grad = {"x": mx.ones_like(x)}
+        optimizer = opt.Adafactor()
+        for _ in range(2):
+            xp = optimizer.apply_gradients(grad, params)
+            self.assertEqual(xp["x"].dtype, x.dtype)
+            self.assertEqual(xp["x"].shape, x.shape)
+
+        x = mx.zeros((5, 5), mx.float16)
+        params = {"x": x}
+        grad = {"x": mx.ones_like(x)}
+        optimizer = opt.Adafactor()
+        for _ in range(2):
+            xp = optimizer.apply_gradients(grad, params)
+            self.assertEqual(xp["x"].dtype, x.dtype)
+            self.assertEqual(xp["x"].shape, x.shape)
+        self.assertEqual(optimizer.state["step"], 2)
+
+    def test_muon(self):
+        params = {
+            "first": [mx.zeros((10, 5)), mx.zeros((1,))],
+            "second": mx.zeros((3, 3)),
+            "conv": mx.zeros((16, 8, 3, 3)),
+        }
+        grads = tree_map(lambda x: mx.ones_like(x), params)
+
+        # Explicit init
+        optim = opt.Muon(learning_rate=1e-2, momentum=0.95, nesterov=True)
+        optim.init(params)
+        self.assertTrue(
+            tree_equal(
+                lambda p, s: mx.array_equal(s["v"], mx.zeros_like(p)),
+                params,
+                optim.state,
+            )
+        )
+
+        # Test update
+        updated_params = optim.apply_gradients(grads, params)
+
+        # Check that shapes are preserved
+        self.assertTrue(
+            tree_equal(
+                lambda p, u: p.shape == u.shape,
+                params,
+                updated_params,
+            )
+        )
+
+        # Check that parameters actually changed
+        self.assertFalse(
+            tree_equal(
+                lambda p, u: mx.array_equal(p, u),
+                params,
+                updated_params,
+            )
+        )
+
+        # Test with different configurations
+        optim_no_nesterov = opt.Muon(learning_rate=1e-2, momentum=0.95, nesterov=False)
+        optim_no_nesterov.apply_gradients(grads, params)
+
+        optim_no_momentum = opt.Muon(learning_rate=1e-2, momentum=0.0)
+        optim_no_momentum.apply_gradients(grads, params)
+
+    def test_compiled_optimizer(self):
+        model = nn.Linear(10, 10)
+        x = mx.random.uniform(shape=(2, 10))
+        optim = opt.SGD(learning_rate=1e-2, momentum=0.9)
+
+        orig_params = model.parameters()
+
+        def loss(model, x):
+            return model(x).sum()
+
+        # Uncompiled version
+        def step(x):
+            _, grad = nn.value_and_grad(model, loss)(model, x)
+            optim.update(model, grad)
+
+        step(x)
+        uncompiled_params = model.parameters()
+
+        # Pure version
+        def loss(params, x):
+            model.update(params)
+            return model(x).sum()
+
+        model.update(orig_params)
+        optim = opt.SGD(learning_rate=1e-2, momentum=0.9)
+
+        @mx.compile
+        def step(params, opt_state, x):
+            grad = mx.grad(loss)(params, x)
+            optim.state = opt_state
+            params = optim.apply_gradients(grad, params)
+            return params, optim.state
+
+        optim.init(model.parameters())
+        pure_params, _ = step(model.parameters(), optim.state, x)
+        self.assertTrue(mx.allclose(pure_params["weight"], uncompiled_params["weight"]))
+        self.assertTrue(mx.allclose(pure_params["bias"], uncompiled_params["bias"]))
+
+        # Impure version
+        def loss(model, x):
+            return model(x).sum()
+
+        model.update(orig_params)
+        optim = opt.SGD(learning_rate=1e-2, momentum=0.9)
+        state = [model.state, optim.state]
+
+        @partial(mx.compile, inputs=state, outputs=state)
+        def step(x):
+            _, grad = nn.value_and_grad(model, loss)(model, x)
+            optim.update(model, grad)
+
+        step(x)
+        impure_params = model.parameters()
+        self.assertTrue(
+            mx.allclose(impure_params["weight"], uncompiled_params["weight"])
+        )
+        self.assertTrue(mx.allclose(impure_params["bias"], uncompiled_params["bias"]))
+
+    def test_update_lr_compiled(self):
+        params = {"w": mx.ones((5, 5))}
+        grads = tree_map(lambda x: mx.ones_like(x), params)
+        optim = opt.SGD(-1.0)
+
+        @partial(mx.compile, inputs=optim.state)
+        def update(grads):
+            return optim.apply_gradients(grads, params)
+
+        result = update(grads)
+        self.assertTrue(mx.allclose(result["w"], mx.full((5, 5), 2.0)))
+        optim.learning_rate = -2.0
+        result = update(grads)
+        self.assertTrue(mx.allclose(result["w"], mx.full((5, 5), 3.0)))
+
+
+class TestSchedulers(mlx_tests.MLXTestCase):
+    def test_decay_lr(self):
+        for optim_class in optimizers_dict.values():
+            lr_schedule = opt.step_decay(1e-1, 0.9, 1)
+            optimizer = optim_class(learning_rate=lr_schedule)
+
+            params = {"w": mx.ones((5, 5))}
+            grads = tree_map(lambda x: mx.ones_like(x), params)
+
+            for it in range(10):
+                optimizer.apply_gradients(grads, params)
+                expected_lr = 0.1 * (0.9**it)
+                self.assertAlmostEqual(optimizer.learning_rate, expected_lr, delta=1e-7)
+
+    def test_step_decay(self):
+        lr_schedule = opt.step_decay(1e-1, 0.9, 1000)
+        lr = lr_schedule(2500)
+        expected_lr = 0.1 * (0.9**2)
+        self.assertAlmostEqual(lr, expected_lr, delta=1e-7)
+
+    def test_exponential_decay(self):
+        lr_schedule = opt.exponential_decay(1e-1, 0.99)
+        lr = lr_schedule(10)
+        expected_lr = 0.1 * (0.99**10)
+        self.assertAlmostEqual(lr, expected_lr, delta=1e-7)
+
+    def test_cosine_decay(self):
+        lr_schedule = opt.cosine_decay(0.1, 10)
+        lr = lr_schedule(4)
+        expected_lr = 0.1 * 0.5 * (1.0 + math.cos(math.pi * 4 / 10))
+        self.assertAlmostEqual(lr, expected_lr, delta=1e-7)
+
+        lr_schedule = opt.cosine_decay(0.1, 10, 0.05)
+        lr = lr_schedule(9)
+        expected_end_lr = 0.05
+        self.assertGreater(lr, expected_end_lr)
+        lr = lr_schedule(20)
+        self.assertEqual(lr, expected_end_lr)
+
+    def test_schedule_joiner(self):
+        boundaries = [2, 3, 4]
+        schedules = [lambda _: 3, lambda _: 4, lambda _: 5]
+        with self.assertRaises(ValueError):
+            opt.schedulers.join_schedules(schedules, boundaries)
+        boundaries = [2, 4]
+        schedule = opt.schedulers.join_schedules(schedules, boundaries)
+        self.assertEqual(schedule(0).item(), 3)
+        self.assertEqual(schedule(1).item(), 3)
+        self.assertEqual(schedule(2).item(), 4)
+        self.assertEqual(schedule(3).item(), 4)
+        self.assertEqual(schedule(5).item(), 5)
+        self.assertEqual(schedule(7).item(), 5)
+
+    def test_linear_warmup_with_cosine_decay(self):
+        warmup_schedule = opt.schedulers.linear_schedule(0.0, 1e-5, 100)
+        cosine_schedule = opt.schedulers.cosine_decay(1e-5, 100)
+        cos_with_warmup = opt.schedulers.join_schedules(
+            [warmup_schedule, cosine_schedule], [101]
+        )
+        self.assertEqual(cos_with_warmup(0), 0.0)
+        self.assertAlmostEqual(cos_with_warmup(101), 1e-5, delta=1e-1)
+        optimizer = opt.Adam(learning_rate=cos_with_warmup)
+        for _ in range(100):
+            optimizer.update({}, {})
+        self.assertAlmostEqual(optimizer.learning_rate.item(), 1e-5, delta=1e-1)
+        for _ in range(100):
+            optimizer.update({}, {})
+        expected_lr = 1e-5 * 0.5 * (1.0 + math.cos(math.pi * 200 / 10))
+        self.assertAlmostEqual(optimizer.learning_rate.item(), expected_lr, delta=1e-1)
+
+    def test_compile_with_schedule(self):
+        lr_schedule = opt.exponential_decay(1e-1, 0.9)
+        optimizer = opt.SGD(learning_rate=lr_schedule)
+
+        @partial(mx.compile, inputs=optimizer.state, outputs=optimizer.state)
+        def update():
+            optimizer.update({}, {})
+
+        for step in range(5):
+            update()
+            self.assertAlmostEqual(lr_schedule(step), optimizer.learning_rate.item())
+
+    def test_clip_grad_norm(self):
+        # Test with small gradients that do not require clipping
+        small_grads = {
+            "first": [mx.array([0.1, 0.2]), mx.array([0.1])],
+            "second": mx.array([0.3]),
+        }
+        max_norm = 10.0  # A large max_norm that shouldn't trigger clipping
+        clipped_grads, total_norm = opt.clip_grad_norm(small_grads, max_norm)
+        self.assertTrue(
+            tree_equal(lambda x, y: mx.array_equal(x, y), small_grads, clipped_grads),
+            "Gradients should not be modified when clipping is not necessary.",
+        )
+
+        # Test with large gradients that require clipping
+        large_grads = {
+            "first": [mx.array([10, 20]), mx.array([10])],
+            "second": mx.array([30]),
+        }
+        max_norm = 1.0  # A small max_norm that should trigger clipping
+        clipped_grads, total_norm = opt.clip_grad_norm(large_grads, max_norm)
+        # Correctly extract only the gradient values for norm calculation
+        clipped_values = [value for _, value in tree_flatten(clipped_grads)]
+        norm_of_clipped = mx.sqrt(
+            sum(mx.square(g).sum() for g in clipped_values)
+        ).item()
+        self.assertAlmostEqual(
+            norm_of_clipped,
+            max_norm,
+            places=6,
+            msg="Clipped gradients norm should be close to the specified max_norm.",
+        )
+
+        # Ensures that the scaling was done correctly
+        scale = max_norm / total_norm
+        expected_grads = tree_map(lambda g: g * scale, large_grads)
+        self.assertTrue(
+            tree_equal(
+                lambda x, y: mx.allclose(x, y, atol=1e-6), expected_grads, clipped_grads
+            ),
+            "Gradients were not scaled correctly during clipping.",
+        )
+
+    def test_init_from_state(self):
+        class Model(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.l1 = nn.Linear(2, 2)
+                self.drop = nn.Dropout(p=0.5)
+                self.l2 = nn.Linear(2, 2)
+                self.vals = [nn.Linear(2, 2), nn.ReLU(), nn.ReLU()]
+
+        model = Model()
+        optimizer = opt.Adam(learning_rate=3e-4)
+        optimizer.init(model.trainable_parameters())
+
+        # Flatten the state for serialization
+        state = tree_flatten(optimizer.state)
+
+        # Make a new optimizer and load the state
+        optimizer = opt.Adam(learning_rate=3e-4)
+        optimizer.state = tree_unflatten(state)
+
+        # This should work without any errors
+        grads = model.trainable_parameters()
+        optimizer.update(model, grads)
+
+    def test_multi_optimizer(self):
+        class Model(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.l1 = nn.Linear(2, 2)
+                self.drop = nn.Dropout(p=0.5)
+                self.l2 = nn.Linear(2, 2)
+                self.vals = [nn.Linear(2, 2), nn.ReLU(), nn.ReLU()]
+
+        model = Model()
+        optimizer = opt.MultiOptimizer(
+            [opt.Adam(learning_rate=0.001), opt.SGD(learning_rate=0.1)],
+            [lambda name, weight: weight.ndim > 1],
+        )
+        optimizer.init(model.trainable_parameters())
+
+        self.assertEqual(len(optimizer.state["states"]), 2)
+
+        adam_states = tree_flatten(optimizer.state["states"][0])
+        sgd_states = tree_flatten(optimizer.state["states"][1])
+        self.assertEqual((len(sgd_states) - 2) * 2, len(adam_states) - 2)
+        self.assertFalse(any("bias" in k for k, v in adam_states))
+        self.assertFalse(any("weight" in k for k, v in sgd_states))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_quantized.py b/ml-stable-diffusion/mlx/python/tests/test_quantized.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a195ef541d1abb8d60ba1873eaa4857108f154c
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_quantized.py
@@ -0,0 +1,878 @@
+# Copyright © 2023 Apple Inc.
+
+import unittest
+from itertools import product
+
+import mlx.core as mx
+import mlx_tests
+
+
+class TestQuantized(mlx_tests.MLXTestCase):
+    def test_quantize_dequantize(self):
+        w = mx.random.normal(shape=(128, 512))
+        for gs in [32, 64, 128]:
+            for b in [2, 3, 5, 6, 4, 8]:
+                with self.subTest(gs=gs, b=b):
+                    w_q, scales, biases = mx.quantize(w, group_size=gs, bits=b)
+                    w_hat = mx.dequantize(w_q, scales, biases, gs, b)
+                    errors = (w - w_hat).abs().reshape(*scales.shape, -1)
+                    eps = 1e-6
+                    self.assertTrue((errors <= (scales[..., None] + eps).abs()).all())
+
+        # test quantize/dequantize 0s
+        a = mx.zeros((256, 512))
+        for gs in [32, 64, 128]:
+            for b in [2, 3, 4, 5, 6, 8]:
+                w_q, scales, biases = mx.quantize(a, gs, b)
+                a_hat = mx.dequantize(w_q, scales, biases, gs, b)
+                self.assertTrue(mx.all(a_hat == 0))
+
+    def test_mxfp4_quantize_dequantize(self):
+        lut = mx.array(
+            [
+                +0.0,
+                +0.5,
+                +1.0,
+                +1.5,
+                +2.0,
+                +3.0,
+                +4.0,
+                +6.0,
+                -0.0,
+                -0.5,
+                -1.0,
+                -1.5,
+                -2.0,
+                -3.0,
+                -4.0,
+                -6.0,
+            ]
+        )
+        w = lut[mx.random.randint(0, 16, shape=(128, 512))]
+        w = w.reshape(-1, 32)
+        w[:, 0] = 6
+        w = (w + 3e-6).astype(mx.bfloat16)
+
+        # Invalid bits / group size
+        with self.assertRaises(ValueError):
+            mx.quantize(w, bits=3, group_size=32, mode="mxfp4")
+
+        with self.assertRaises(ValueError):
+            mx.quantize(w, group_size=64, bits=4, mode="mxfp4")
+
+        w_q, scales = mx.quantize(w, group_size=32, bits=4, mode="mxfp4")
+
+        with self.assertRaises(ValueError):
+            mx.dequantize(w_q, scales, bits=3, group_size=32, mode="mxfp4")
+
+        with self.assertRaises(ValueError):
+            mx.dequantize(w_q, scales, group_size=64, bits=4, mode="mxfp4")
+
+        w_hat = mx.dequantize(w_q, scales, group_size=32, bits=4, mode="mxfp4")
+        self.assertTrue(mx.allclose(w, w_hat, rtol=1e-5, atol=1e-5))
+
+        # test quantize/dequantize 0s
+        a = mx.zeros((256, 512))
+        w_q, scales = mx.quantize(a, group_size=32, bits=4, mode="mxfp4")
+        w_hat = mx.dequantize(w_q, scales, group_size=32, bits=4, mode="mxfp4")
+        self.assertTrue(mx.all(w_hat == 0))
+
+    def test_qmm(self):
+        key = mx.random.key(0)
+        k1, k2 = mx.random.split(key)
+        tests = product(
+            [128, 64, 32],  # group_size
+            [2, 4, 8],  # bits
+            [8, 32, 33, 64],  # M
+            [128, 256],  # N
+            [128, 256],  # K
+            [True, False],  # transposed
+        )
+        for group_size, bits, M, N, K, transposed in tests:
+            with self.subTest(
+                shape=(M, N, K),
+                group_size=group_size,
+                bits=bits,
+                transposed=transposed,
+            ):
+                x = mx.random.normal(shape=(M, K), key=k1)
+                w = mx.random.normal(shape=(N, K) if transposed else (K, N), key=k2)
+                w_q, scales, biases = mx.quantize(w, group_size, bits)
+                w_hat = mx.dequantize(w_q, scales, biases, group_size, bits)
+                y_q = mx.quantized_matmul(
+                    x, w_q, scales, biases, transposed, group_size, bits
+                )
+                y_hat = (x @ w_hat.T) if transposed else (x @ w_hat)
+                self.assertEqual(y_q.shape, y_hat.shape)
+                self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+    def test_qmm_vjp(self):
+        key = mx.random.key(0)
+        k1, k2 = mx.random.split(key)
+
+        bits = 8
+        group_size = 64
+        M = 64
+        N = 1024
+        K = 512
+
+        x = mx.random.normal(shape=(2, M, K), key=k1)
+        c = mx.ones(shape=(2, M, N))
+
+        transposes = [True, False]
+        for transposed in transposes:
+            w = mx.random.normal(shape=(N, K) if transposed else (K, N), key=k2)
+            w_q, scales, biases = mx.quantize(w, group_size, bits)
+
+            def fn(x):
+                return mx.quantized_matmul(
+                    x, w_q, scales, biases, transposed, group_size, bits
+                )
+
+            _, vjp_out = mx.vjp(fn, primals=(x,), cotangents=(c,))
+
+            expected_out = mx.quantized_matmul(
+                c, w_q, scales, biases, not transposed, group_size, bits
+            )
+            self.assertTrue(mx.allclose(vjp_out[0], expected_out))
+
+    def test_qmm_jvp(self):
+        key = mx.random.key(0)
+        k1, k2 = mx.random.split(key)
+
+        bits = 8
+        group_size = 64
+        M = 64
+        N = 128
+        K = 128
+
+        x = mx.random.normal(shape=(2, M, K), key=k1)
+        x_tan = mx.ones(shape=(2, M, N))
+
+        transposes = [True, False]
+        for transposed in transposes:
+            w = mx.random.normal(shape=(N, K) if transposed else (K, N), key=k2)
+            w_q, scales, biases = mx.quantize(w, group_size, bits)
+
+            def fn(x):
+                return mx.quantized_matmul(
+                    x, w_q, scales, biases, transposed, group_size, bits
+                )
+
+            _, jvp_out = mx.jvp(fn, primals=(x,), tangents=(x_tan,))
+
+            expected_out = mx.quantized_matmul(
+                x_tan, w_q, scales, biases, transposed, group_size, bits
+            )
+            self.assertTrue(mx.allclose(jvp_out[0], expected_out))
+
+    def test_qmm_shapes(self):
+        key = mx.random.key(0)
+        k1, k2 = mx.random.split(key)
+        group_size = 64
+        bits = 4
+        w = mx.random.normal(shape=(32, 256), key=k2)
+        w_q, scales, biases = mx.quantize(w, group_size, bits)
+        w_hat = mx.dequantize(w_q, scales, biases, group_size, bits)
+        for s in [(3, 256), (2, 1, 7, 256)]:
+            x = mx.random.normal(shape=s, key=k1)
+            y_q = mx.quantized_matmul(x, w_q, scales, biases, True, group_size, bits)
+            y_hat = x @ w_hat.T
+            self.assertEqual(y_q.shape, y_hat.shape)
+            self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+        w = mx.random.normal(shape=(256, 256), key=k2)
+        w_q, scales, biases = mx.quantize(w, group_size, bits)
+        w_hat = mx.dequantize(w_q, scales, biases, group_size, bits)
+        for s in [(3, 256), (2, 1, 7, 256)]:
+            x = mx.random.normal(shape=s, key=k1)
+            y_q = mx.quantized_matmul(x, w_q, scales, biases, False, group_size, bits)
+            y_hat = x @ w_hat
+            self.assertEqual(y_q.shape, y_hat.shape)
+            self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+    def test_qmv(self):
+        key = mx.random.key(0)
+        k1, k2 = mx.random.split(key)
+        tests = product(
+            [128, 64, 32],  # group_size
+            [2, 3, 4, 5, 6, 8],  # bits
+            [256, 512, 67],  # M
+            [64, 128],  # N
+            [0, 1, 3, 8],  # B
+        )
+        for group_size, bits, M, N, B in tests:
+            if group_size > N:
+                continue
+            with self.subTest(shape=(B, M, N), group_size=group_size, bits=bits):
+                x_shape = (3, 1, N) if B == 0 else (B, 1, N)
+                w_shape = (M, N) if B == 0 else (B, M, N)
+                x = mx.random.normal(shape=x_shape, key=k1)
+                w = mx.random.normal(shape=w_shape, key=k2)
+                w_q, scales, biases = mx.quantize(w, group_size, bits)
+                w_hat = mx.dequantize(w_q, scales, biases, group_size, bits)
+                y_q = mx.quantized_matmul(
+                    x, w_q, scales, biases, True, group_size, bits
+                )
+                y_hat = x @ mx.swapaxes(w_hat, -1, -2)
+                self.assertEqual(y_q.shape, y_hat.shape)
+                self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+    def test_mxfp4_qmv(self):
+        key = mx.random.key(0)
+        k1, k2 = mx.random.split(key)
+        tests = product(
+            [256, 512, 67],  # M
+            [64, 128],  # N
+            [0, 1, 3, 8],  # B
+        )
+        for M, N, B in tests:
+            with self.subTest(shape=(B, M, N), group_size=32):
+                x_shape = (3, 1, N) if B == 0 else (B, 1, N)
+                w_shape = (M, N) if B == 0 else (B, M, N)
+                x = mx.random.normal(shape=x_shape, key=k1)
+                w = mx.random.normal(shape=w_shape, key=k2)
+                w_q, scales = mx.quantize(w, group_size=32, mode="mxfp4")
+                w_hat = mx.dequantize(w_q, scales, group_size=32, mode="mxfp4")
+                y_q = mx.quantized_matmul(
+                    x,
+                    w_q,
+                    scales,
+                    transpose=True,
+                    group_size=32,
+                    mode="mxfp4",
+                )
+                y_hat = x @ mx.swapaxes(w_hat, -1, -2)
+                self.assertEqual(y_q.shape, y_hat.shape)
+                self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+    def test_qvm(self):
+        key = mx.random.key(0)
+        k1, k2 = mx.random.split(key)
+        tests = product(
+            [128, 64, 32],  # group_size
+            [2, 3, 4, 5, 6, 8],  # bits
+            [32, 128, 256],  # M
+            [128, 256, 67],  # N
+            [0, 1, 3, 8],  # B
+        )
+        for group_size, bits, M, N, B in tests:
+            with self.subTest(shape=(B, M, N), group_size=group_size, bits=bits):
+                if M < group_size:
+                    continue
+                x_shape = (1, N) if B == 0 else (B, 1, N)
+                w_shape = (N, M) if B == 0 else (B, N, M)
+                x = mx.random.normal(shape=x_shape, key=k1)
+                w = mx.random.normal(shape=w_shape, key=k2)
+                w_q, scales, biases = mx.quantize(w, group_size, bits)
+                w_hat = mx.dequantize(w_q, scales, biases, group_size, bits)
+                y_q = mx.quantized_matmul(
+                    x, w_q, scales, biases, False, group_size, bits
+                )
+                y_hat = x @ w_hat
+                self.assertEqual(y_q.shape, y_hat.shape)
+                self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+    def test_qvm_splitk(self):
+        key = mx.random.key(0)
+        k1, k2 = mx.random.split(key)
+        tests = product(
+            [128, 64, 32],  # group_size
+            [2, 4, 8],  # bits
+            [128],  # M
+            [16384],  # N
+            [1, 3],  # B
+        )
+        for group_size, bits, M, N, B in tests:
+            with self.subTest(shape=(B, M, N), group_size=group_size, bits=bits):
+                x_shape = (1, N) if B == 0 else (B, 1, N)
+                w_shape = (N, M) if B == 0 else (B, N, M)
+                x = 1e-1 * mx.random.normal(shape=x_shape, key=k1)
+                w = 1e-1 * mx.random.normal(shape=w_shape, key=k2)
+                w_q, scales, biases = mx.quantize(w, group_size, bits)
+                w_hat = mx.dequantize(w_q, scales, biases, group_size, bits)
+                y_q = mx.quantized_matmul(
+                    x, w_q, scales, biases, False, group_size, bits
+                )
+                y_hat = x @ w_hat
+                self.assertEqual(y_q.shape, y_hat.shape)
+                self.assertLess((y_q - y_hat).abs().max(), 2e-3)
+
+        # Test with 1D vector
+        group_size = 32
+        bits = 8
+        N = 2048
+        x = 1e-1 * mx.random.normal(shape=(N,), key=k1)
+        w = 1e-1 * mx.random.normal(shape=(N, N), key=k2)
+        w_q, scales, biases = mx.quantize(w, group_size, bits)
+        w_hat = mx.dequantize(w_q, scales, biases, group_size, bits)
+        y_q = mx.quantized_matmul(x, w_q, scales, biases, False, group_size, bits)
+        y_hat = x @ w_hat
+        self.assertEqual(y_q.shape, y_hat.shape)
+        self.assertLess((y_q - y_hat).abs().max(), 2e-3)
+
+    def test_mxfp4_qvm(self):
+        key = mx.random.key(0)
+        k1, k2 = mx.random.split(key)
+        tests = product(
+            [32, 128, 256],  # M
+            [128, 256, 67],  # N
+            [0, 1, 3, 8],  # B
+        )
+        # Add a splitk
+        tests = list(tests)
+        tests.append((128, 16384, 0))
+
+        for M, N, B in tests:
+            with self.subTest(shape=(B, M, N)):
+                x_shape = (1, N) if B == 0 else (B, 1, N)
+                w_shape = (N, M) if B == 0 else (B, N, M)
+                x = mx.random.normal(shape=x_shape, key=k1)
+                w = mx.random.normal(shape=w_shape, key=k2)
+                w_q, scales = mx.quantize(w, group_size=32, mode="mxfp4")
+                w_hat = mx.dequantize(w_q, scales, group_size=32, mode="mxfp4")
+                y_q = mx.quantized_matmul(
+                    x,
+                    w_q,
+                    scales,
+                    transpose=False,
+                    group_size=32,
+                    mode="mxfp4",
+                )
+                y_hat = x @ w_hat
+                self.assertEqual(y_q.shape, y_hat.shape)
+                self.assertLess((y_q - y_hat).abs().max(), 2e-3)
+
+    def test_mode_error_cases(self):
+        w = mx.random.normal(shape=(256, 256))
+        x = mx.random.normal(shape=(1, 256))
+
+        # Invalid mode
+        with self.assertRaises(ValueError):
+            mx.quantize(w, mode="xyz")
+
+        wq, scales, biases = mx.quantize(w, bits=4, group_size=32)
+
+        with self.assertRaises(ValueError):
+            mx.dequantize(wq, scales, biases, bits=4, group_size=32, mode="xyz")
+
+        with self.assertRaises(ValueError):
+            mx.quantized_matmul(
+                x, wq, scales, biases, bits=4, group_size=32, mode="xyz"
+            )
+
+        rhs_indices = mx.array(0)
+        with self.assertRaises(ValueError):
+            mx.gather_qmm(
+                x,
+                wq,
+                scales,
+                biases,
+                rhs_indices=rhs_indices,
+                bits=4,
+                group_size=32,
+                mode="xyz",
+            )
+
+        # Only quantize floating point types
+        with self.assertRaises(ValueError):
+            mx.quantize(mx.zeros((128, 128), mx.int32))
+
+        with self.assertRaises(ValueError):
+            mx.quantize(mx.zeros((128, 128), mx.int32), mode="mxfp4")
+
+        # Must have bias for affine
+        with self.assertRaises(ValueError):
+            mx.dequantize(wq, scales, None, bits=4, group_size=32)
+
+        with self.assertRaises(ValueError):
+            mx.quantized_matmul(x, wq, scales, None, bits=4, group_size=32)
+
+        with self.assertRaises(ValueError):
+            mx.gather_qmm(
+                x, wq, scales, None, rhs_indices=rhs_indices, bits=4, group_size=32
+            )
+
+        # Must be floating point
+        x = mx.zeros(shape=(256,), dtype=mx.int32)
+        scales = mx.zeros(scales.shape, dtype=mx.int32)
+        biases = mx.zeros(scales.shape, dtype=mx.int32)
+        with self.assertRaises(ValueError):
+            mx.dequantize(wq, scales, biases, bits=4, group_size=32)
+
+        with self.assertRaises(ValueError):
+            mx.quantized_matmul(x, wq, scales, biases, bits=4, group_size=32)
+
+        with self.assertRaises(ValueError):
+            mx.gather_qmm(
+                x, wq, scales, biases, rhs_indices=rhs_indices, bits=4, group_size=32
+            )
+
+    def test_throw(self):
+        x = mx.random.normal(shape=(10, 512))
+        w = mx.random.normal(shape=(32, 512))
+        w_q, scales, biases = mx.quantize(w)
+
+        with self.assertRaises(ValueError):
+            mx.quantized_matmul(x, w_q.T, scales, biases)
+        with self.assertRaises(ValueError):
+            mx.quantized_matmul(x, w_q.T, scales.T, biases)
+        with self.assertRaises(ValueError):
+            mx.quantized_matmul(x, w_q, scales, biases, False)
+        with self.assertRaises(ValueError):
+            mx.quantized_matmul(x, w_q, scales.T, biases.T)
+        y = mx.quantized_matmul(x, w_q, scales, biases, True)
+        mx.eval(y)
+
+    def test_small_matrix(self):
+        for w_shape in [(8, 256), (1, 8, 256), (3, 8, 256)]:
+            with self.subTest(w_shape=w_shape):
+                w = mx.random.normal(shape=(w_shape))
+                w_q, scales, biases = mx.quantize(w)
+                w_hat = mx.dequantize(w_q, scales, biases)
+
+                # Test qmv
+                for shape in [(3, 1, 256), (3, 4, 256)]:
+                    x = mx.random.normal(shape=shape)
+                    y_q = mx.quantized_matmul(x, w_q, scales, biases, transpose=True)
+                    y_hat = x @ mx.swapaxes(w_hat, -1, -2)
+                    self.assertEqual(y_q.shape, y_hat.shape)
+                    self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+                # Test qmm_t
+                x = mx.random.normal(shape=(3, 10, 256))
+                y_q = mx.quantized_matmul(x, w_q, scales, biases, transpose=True)
+                y_hat = x @ mx.swapaxes(w_hat, -1, -2)
+                self.assertEqual(y_q.shape, y_hat.shape)
+                self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+                # Test qvm
+                x = mx.random.normal(shape=(3, 1, 8))
+                y_q = mx.quantized_matmul(x, w_q, scales, biases, transpose=False)
+                y_hat = x @ w_hat
+                self.assertEqual(y_q.shape, y_hat.shape)
+                self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+                # Test qmm
+                x = mx.random.normal(shape=(3, 10, 8))
+                y_q = mx.quantized_matmul(x, w_q, scales, biases, transpose=False)
+                y_hat = x @ w_hat
+                self.assertEqual(y_q.shape, y_hat.shape)
+                self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+    def test_non_multiples(self):
+        w = mx.random.normal(shape=(33, 256))
+        w_q, scales, biases = mx.quantize(w)
+        w_hat = mx.dequantize(w_q, scales, biases)
+
+        # Test qmv
+        x = mx.random.normal(shape=(1, 256))
+        y_q = mx.quantized_matmul(x, w_q, scales, biases, transpose=True)
+        y_hat = x @ w_hat.T
+        self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+        # Test qmm_t
+        x = mx.random.normal(shape=(10, 256))
+        y_q = mx.quantized_matmul(x, w_q, scales, biases, transpose=True)
+        y_hat = x @ w_hat.T
+        self.assertEqual(y_q.shape, y_hat.shape)
+        self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+        # Test qvm
+        x = mx.random.normal(shape=(1, 33))
+        y_q = mx.quantized_matmul(x, w_q, scales, biases, transpose=False)
+        y_hat = x @ w_hat
+        self.assertEqual(y_q.shape, y_hat.shape)
+        self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+        # Test qmm
+        x = mx.random.normal(shape=(10, 33))
+        y_q = mx.quantized_matmul(x, w_q, scales, biases, transpose=False)
+        y_hat = x @ w_hat
+        self.assertEqual(y_q.shape, y_hat.shape)
+        self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+        # Smaller than 8
+        w = mx.random.normal(shape=(3, 256))
+        w_q, scales, biases = mx.quantize(w)
+        w_hat = mx.dequantize(w_q, scales, biases)
+
+        # Test qmv
+        x = mx.random.normal(shape=(1, 256))
+        y_q = mx.quantized_matmul(x, w_q, scales, biases, transpose=True)
+        y_hat = x @ w_hat.T
+        self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+        # Test qmm_t
+        x = mx.random.normal(shape=(10, 256))
+        y_q = mx.quantized_matmul(x, w_q, scales, biases, transpose=True)
+        y_hat = x @ w_hat.T
+        self.assertEqual(y_q.shape, y_hat.shape)
+        self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+        # Test qvm
+        x = mx.random.normal(shape=(1, 3))
+        y_q = mx.quantized_matmul(x, w_q, scales, biases, transpose=False)
+        y_hat = x @ w_hat
+        self.assertEqual(y_q.shape, y_hat.shape)
+        self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+        # Test qmm
+        x = mx.random.normal(shape=(10, 3))
+        y_q = mx.quantized_matmul(x, w_q, scales, biases, transpose=False)
+        y_hat = x @ w_hat
+        self.assertEqual(y_q.shape, y_hat.shape)
+        self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+        # Test with larger than 128 unaligned sizes
+        w = mx.random.normal(shape=(99, 256))
+        w_q, scales, biases = mx.quantize(w)
+        w_hat = mx.dequantize(w_q, scales, biases)
+        x = mx.random.normal(shape=(129, 256))
+        y_q = mx.quantized_matmul(x, w_q, scales, biases, transpose=True)
+        y_hat = x @ w_hat.T
+        self.assertEqual(y_q.shape, y_hat.shape)
+        self.assertLess((y_q - y_hat).abs().max(), 1e-3)
+
+    def test_gather_qmm(self):
+        def quantize(w, transpose=True, group_size=64, bits=4, mode="affine"):
+            if mode == "affine":
+                qw, s, b = mx.quantize(w, group_size=group_size, bits=bits, mode=mode)
+            else:
+                qw, s = mx.quantize(w, group_size=group_size, bits=bits, mode=mode)
+                b = None
+            w_hat = mx.dequantize(qw, s, b, group_size=group_size, bits=bits, mode=mode)
+            if transpose:
+                w_hat = w_hat.swapaxes(-1, -2)
+            return w_hat, qw, s, b
+
+        def test_shape(
+            M,
+            N,
+            K,
+            dtype=mx.float32,
+            batch_A=(),
+            batch_B=(),
+            lhs_indices=None,
+            rhs_indices=None,
+            transpose=True,
+            group_size=64,
+            bits=4,
+            mode="affine",
+        ):
+            with self.subTest(
+                M=M,
+                N=N,
+                K=K,
+                dtype=dtype,
+                batch_A=batch_A,
+                batch_B=batch_B,
+                lhs_indices=lhs_indices,
+                rhs_indices=rhs_indices,
+                transpose=transpose,
+                group_size=group_size,
+                bits=bits,
+                mode=mode,
+            ):
+                x = mx.random.normal(shape=batch_A + (M, K)).astype(dtype)
+                w = mx.random.normal(
+                    shape=batch_B + ((N, K) if transpose else (K, N))
+                ).astype(dtype)
+                w_hat, qw, s, b = quantize(w, transpose, group_size, bits, mode=mode)
+
+                if lhs_indices is not None:
+                    lhs_indices = mx.array(lhs_indices)
+                if rhs_indices is not None:
+                    rhs_indices = mx.array(rhs_indices)
+
+                c1 = mx.gather_mm(x, w_hat, lhs_indices, rhs_indices)
+                c2 = mx.gather_qmm(
+                    x,
+                    qw,
+                    s,
+                    b,
+                    lhs_indices,
+                    rhs_indices,
+                    transpose=transpose,
+                    group_size=group_size,
+                    bits=bits,
+                    mode=mode,
+                )
+                self.assertTrue(mx.allclose(c1, c2, atol=1e-4))
+
+        inputs = (
+            {
+                "batch_A": (1,),
+                "lhs_indices": (0,),
+                "batch_B": (3,),
+                "rhs_indices": (2, 1),
+            },
+            {
+                "batch_A": (1,),
+                "lhs_indices": None,
+                "batch_B": (3,),
+                "rhs_indices": (2, 1),
+            },
+            {
+                "batch_A": (2,),
+                "lhs_indices": None,
+                "batch_B": (3,),
+                "rhs_indices": (2, 1),
+            },
+            {
+                "batch_A": (3,),
+                "lhs_indices": (0, 2),
+                "batch_B": (1,),
+                "rhs_indices": (0,),
+            },
+            {
+                "batch_A": (5,),
+                "lhs_indices": (0, 2),
+                "batch_B": (3,),
+                "rhs_indices": (2, 1),
+            },
+            {
+                "batch_A": (4, 2),
+                "lhs_indices": (
+                    (7, 6),
+                    (5, 4),
+                    (1, 2),
+                ),
+                "batch_B": (4, 1),
+                "rhs_indices": ((2,), (0,), (1,)),
+            },
+            {
+                "batch_A": (1,),
+                "lhs_indices": (0,),
+                "batch_B": (3,),
+                "rhs_indices": (2, 1),
+                "group_size": 32,
+                "mode": "mxfp4",
+            },
+        )
+
+        for kwargs in inputs:
+            test_shape(1, 32, 128, **kwargs)
+            test_shape(32, 32, 256, **kwargs)
+            test_shape(1, 32, 256, **kwargs)
+            test_shape(32, 256, 32, transpose=False, **kwargs)
+            test_shape(1, 256, 32, transpose=False, **kwargs)
+            test_shape(32, 32, 512, **kwargs)
+            test_shape(1, 32, 512, **kwargs)
+            test_shape(32, 512, 32, transpose=False, **kwargs)
+            test_shape(1, 512, 32, transpose=False, **kwargs)
+
+    def test_gather_matmul_grad(self):
+        def quantize(w, transpose=True, group_size=64, bits=4):
+            qw, s, b = mx.quantize(w, group_size=group_size, bits=bits)
+            w_hat = mx.dequantize(qw, s, b, group_size=group_size, bits=bits)
+            if transpose:
+                w_hat = w_hat.swapaxes(-1, -2)
+            return w_hat, qw, s, b
+
+        lhs_indices = mx.array([[7, 6], [4, 1], [0, 2]], dtype=mx.uint32)
+        rhs_indices = mx.array([[2], [0], [1]], dtype=mx.uint32)
+
+        x = mx.random.normal((4, 2, 32, 256))
+        w = mx.random.normal((4, 1, 32, 256))
+        w_hat, qw, s, b = quantize(w)
+
+        def f_ref(x, w, i1, i2):
+            return mx.gather_mm(x, w, i1, i2).sum()
+
+        def f_test(x, qw, s, b, i1, i2):
+            return mx.gather_qmm(x, qw, s, b, i1, i2, transpose=True).sum()
+
+        r1 = f_ref(x, w_hat, lhs_indices, rhs_indices)
+        r2 = f_test(x, qw, s, b, lhs_indices, rhs_indices)
+        self.assertTrue(mx.allclose(r1, r2, atol=1e-4))
+
+        g1 = mx.grad(f_ref)(x, w_hat, lhs_indices, rhs_indices)
+        g2 = mx.grad(f_test)(x, qw, s, b, lhs_indices, rhs_indices)
+        self.assertTrue(mx.allclose(g1, g2, atol=1e-4))
+
+    def test_gather_qmm_sorted(self):
+        def quantize(w, transpose=True, bits=4, group_size=64, mode="affine"):
+            if mode == "affine":
+                qw, s, b = mx.quantize(w, group_size=group_size, bits=bits, mode=mode)
+            else:
+                qw, s = mx.quantize(w, group_size=group_size, bits=bits, mode=mode)
+                b = None
+
+            w_hat = mx.dequantize(qw, s, b, group_size=group_size, bits=bits, mode=mode)
+            if transpose:
+                w_hat = w_hat.swapaxes(-1, -2)
+            return w_hat, qw, s, b
+
+        def gather_sort(x, indices):
+            N, M = indices.shape
+            indices = indices.flatten()
+            order = mx.argsort(indices)
+            inv_order = mx.argsort(order)
+            return x.flatten(0, -3)[order // M], indices[order], inv_order
+
+        def scatter_unsort(x, inv_order, shape=None):
+            x = x[inv_order]
+            if shape is not None:
+                x = mx.unflatten(x, 0, shape)
+            return x
+
+        parameters = [
+            # L, K, D, E, I, transpose
+            (32, 512, 512, 4, 2, True, "affine"),
+            (32, 512, 544, 4, 2, True, "mxfp4"),
+            (133, 512, 512, 4, 2, True, "affine"),
+            (133, 512, 555, 4, 2, True, "affine"),
+            (133, 512, 512, 4, 2, True, "affine"),
+            (64, 512, 512, 4, 2, False, "affine"),
+            (64, 512, 544, 4, 2, False, "mxfp4"),
+            (133, 512, 512, 4, 2, False, "affine"),
+            (133, 512, 544, 4, 2, False, "affine"),
+            (133, 512, 555, 4, 2, False, "affine"),
+            (64, 512, 512, 4, 2, False, "affine"),
+        ]
+        for L, K, D, E, I, transpose, mode in parameters:
+            if mode == "mxfp4":
+                group_size = 32
+            else:
+                group_size = 64
+            K, D = (K, D) if transpose else (D, K)
+            ishape = (L, I)
+            xshape = (L, 1, 1, K)
+            wshape = (E, D, K) if transpose else (E, K, D)
+
+            indices = (mx.random.uniform(shape=ishape) * E).astype(mx.uint32)
+            x = mx.random.normal(xshape) / K**0.5
+            w = mx.random.normal(wshape) / K**0.5
+            w, *wq = quantize(w, group_size=group_size, mode=mode, transpose=transpose)
+
+            y1 = mx.gather_mm(x, w, rhs_indices=indices)
+            y2 = mx.gather_qmm(
+                x,
+                *wq,
+                group_size=group_size,
+                mode=mode,
+                transpose=transpose,
+                rhs_indices=indices
+            )
+            xs, idx, inv_order = gather_sort(x, indices)
+            y3 = mx.gather_mm(xs, w, rhs_indices=idx, sorted_indices=True)
+
+            y4 = mx.gather_qmm(
+                xs,
+                *wq,
+                group_size=group_size,
+                mode=mode,
+                rhs_indices=idx,
+                transpose=transpose,
+                sorted_indices=True
+            )
+            y3 = scatter_unsort(y3, inv_order, indices.shape)
+            y4 = scatter_unsort(y4, inv_order, indices.shape)
+
+            self.assertTrue(mx.allclose(y1, y2, atol=1e-5))
+            self.assertTrue(mx.allclose(y1, y3, atol=1e-5))
+            self.assertTrue(mx.allclose(y1, y4, atol=1e-5))
+
+    def test_gather_qmm_grad(self):
+        def gather_qmm_ref(x, w, s, b, lhs, rhs, trans, sort):
+            if lhs is not None:
+                x = x[lhs]
+            if rhs is not None:
+                w = w[rhs]
+                s = s[rhs]
+                b = b[rhs]
+            return mx.quantized_matmul(x, w, s, b, transpose=trans)
+
+        def gather_qmm(x, w, s, b, lhs, rhs, trans, sort):
+            return mx.gather_qmm(
+                x,
+                w,
+                s,
+                b,
+                transpose=trans,
+                lhs_indices=lhs,
+                rhs_indices=rhs,
+                sorted_indices=sort,
+            )
+
+        x = mx.random.normal((16, 1, 256))
+        w, s, b = mx.quantize(mx.random.normal((4, 256, 256)))
+        indices = mx.sort(mx.random.randint(0, 4, shape=(16,)))
+        cotan = mx.random.normal((16, 1, 256))
+
+        (o1,), (dx1, ds1, db1) = mx.vjp(
+            lambda x, s, b: gather_qmm_ref(x, w, s, b, None, indices, True, True),
+            [x, s, b],
+            [cotan],
+        )
+        (o2,), (dx2, ds2, db2) = mx.vjp(
+            lambda x, s, b: gather_qmm(x, w, s, b, None, indices, True, True),
+            [x, s, b],
+            [cotan],
+        )
+
+        self.assertTrue(mx.allclose(o1, o2, atol=1e-4))
+        self.assertTrue(mx.allclose(dx1, dx2, atol=1e-4))
+        self.assertTrue(mx.allclose(ds1, ds2, atol=1e-3))
+        self.assertTrue(mx.allclose(db1, db2, atol=1e-3))
+
+    def test_vjp_scales_biases(self):
+        mx.random.seed(0)
+        x = mx.random.normal(shape=(2, 2, 512))
+        w = mx.random.normal(shape=(512, 512))
+        wq, s, b = mx.quantize(w, bits=4, group_size=64)
+
+        def mm(sb, x, wq):
+            return mx.quantized_matmul(x, wq, *sb, bits=4, group_size=64).sum()
+
+        params = (s, b)
+        dparams = mx.grad(mm)((s, b), x, wq)
+
+        eps = 8e-3
+        # numerical grad check with a few indices
+        indices = [(0, 0), (11, 4), (22, 7)]
+        for idx in indices:
+            for p in [0, 1]:
+                params[p][idx] += eps
+                out_up = mm(params, x, wq)
+                params[p][idx] -= 2 * eps
+                out_down = mm(params, x, wq)
+                params[p][idx] += eps
+                num_ds = (out_up - out_down) / (2 * eps)
+                self.assertAlmostEqual(dparams[p][idx], num_ds, delta=2e-2)
+
+    def test_mxfp4_vjp_scales_throws(self):
+        mx.random.seed(0)
+        x = mx.random.normal(shape=(2, 512))
+        w = mx.random.normal(shape=(512, 512))
+        wq, s = mx.quantize(w, bits=4, group_size=32, mode="mxfp4")
+
+        def mm(s, x, wq):
+            return mx.quantized_matmul(
+                x, wq, s, bits=4, group_size=32, mode="mxfp4"
+            ).sum()
+
+        # Should raise
+        with self.assertRaises(ValueError):
+            ds = mx.grad(mm)(s, x, wq)
+
+        rhs_indices = mx.array(0)
+        with self.assertRaises(ValueError):
+
+            def gmm(s, x, wq):
+                return mx.gather_qmm(
+                    x,
+                    wq,
+                    s,
+                    rhs_indices=rhs_indices,
+                    bits=4,
+                    group_size=32,
+                    mode="mxfp4",
+                ).sum()
+
+            ds = mx.grad(gmm)(s, x, wq)
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_random.py b/ml-stable-diffusion/mlx/python/tests/test_random.py
new file mode 100644
index 0000000000000000000000000000000000000000..551c32993caed79e416c87dfbf852fbcbe6bf770
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_random.py
@@ -0,0 +1,392 @@
+# Copyright © 2023 Apple Inc.
+
+import math
+import unittest
+
+import mlx.core as mx
+import mlx_tests
+
+
+class TestRandom(mlx_tests.MLXTestCase):
+    def test_global_rng(self):
+        mx.random.seed(3)
+        a = mx.random.uniform()
+        b = mx.random.uniform()
+
+        mx.random.seed(3)
+        x = mx.random.uniform()
+        y = mx.random.uniform()
+
+        self.assertEqual(a.item(), x.item())
+        self.assertEqual(y.item(), b.item())
+
+    def test_key(self):
+        k1 = mx.random.key(0)
+        k2 = mx.random.key(0)
+        self.assertTrue(mx.array_equal(k1, k2))
+
+        k2 = mx.random.key(1)
+        self.assertFalse(mx.array_equal(k1, k2))
+
+    def test_key_split(self):
+        key = mx.random.key(0)
+
+        k1, k2 = mx.random.split(key)
+        self.assertFalse(mx.array_equal(k1, k2))
+
+        r1, r2 = mx.random.split(key)
+        self.assertTrue(mx.array_equal(k1, r1))
+        self.assertTrue(mx.array_equal(k2, r2))
+
+        keys = mx.random.split(key, 10)
+        self.assertEqual(keys.shape, (10, 2))
+
+    def test_uniform(self):
+        key = mx.random.key(0)
+        a = mx.random.uniform(key=key)
+        self.assertEqual(a.shape, ())
+        self.assertEqual(a.dtype, mx.float32)
+
+        b = mx.random.uniform(key=key)
+        self.assertEqual(a.item(), b.item())
+
+        a = mx.random.uniform(shape=(2, 3))
+        self.assertEqual(a.shape, (2, 3))
+
+        a = mx.random.uniform(shape=(1000,), low=-1, high=5)
+        self.assertTrue(mx.all((a > -1) < 5).item())
+
+        a = mx.random.uniform(shape=(1000,), low=mx.array(-1), high=5)
+        self.assertTrue(mx.all((a > -1) < 5).item())
+
+        a = mx.random.uniform(low=-0.1, high=0.1, shape=(1,), dtype=mx.bfloat16)
+        self.assertEqual(a.dtype, mx.bfloat16)
+
+        self.assertEqual(mx.random.uniform().dtype, mx.random.uniform(dtype=None).dtype)
+
+    def test_normal_and_laplace(self):
+        # Same tests for normal and laplace.
+        for distribution_sampler in [mx.random.normal, mx.random.laplace]:
+            key = mx.random.key(0)
+            a = distribution_sampler(key=key)
+            self.assertEqual(a.shape, ())
+            self.assertEqual(a.dtype, mx.float32)
+
+            b = distribution_sampler(key=key)
+            self.assertEqual(a.item(), b.item())
+
+            a = distribution_sampler(shape=(2, 3))
+            self.assertEqual(a.shape, (2, 3))
+
+            ## Generate in float16 or bfloat16
+            for t in [mx.float16, mx.bfloat16]:
+                a = distribution_sampler(dtype=t)
+                self.assertEqual(a.dtype, t)
+
+            # Generate with a given mean and standard deviation
+            loc = 1.0
+            scale = 2.0
+
+            a = distribution_sampler(shape=(3, 2), loc=loc, scale=scale, key=key)
+            b = scale * distribution_sampler(shape=(3, 2), key=key) + loc
+            self.assertTrue(mx.allclose(a, b))
+
+            a = distribution_sampler(
+                shape=(3, 2), loc=loc, scale=scale, dtype=mx.float16, key=key
+            )
+            b = (
+                scale * distribution_sampler(shape=(3, 2), dtype=mx.float16, key=key)
+                + loc
+            )
+            self.assertTrue(mx.allclose(a, b))
+
+            self.assertEqual(
+                distribution_sampler().dtype, distribution_sampler(dtype=None).dtype
+            )
+
+            # Test not getting -inf or inf with half precison
+            for hp in [mx.float16, mx.bfloat16]:
+                a = abs(distribution_sampler(shape=(10000,), loc=0, scale=1, dtype=hp))
+                self.assertTrue(mx.all(a < mx.inf))
+
+    def test_multivariate_normal(self):
+        key = mx.random.key(0)
+        mean = mx.array([0, 0])
+        cov = mx.array([[1, 0], [0, 1]])
+
+        a = mx.random.multivariate_normal(mean, cov, key=key, stream=mx.cpu)
+        self.assertEqual(a.shape, (2,))
+
+        ## Check dtypes
+        for t in [mx.float32]:
+            a = mx.random.multivariate_normal(
+                mean, cov, dtype=t, key=key, stream=mx.cpu
+            )
+            self.assertEqual(a.dtype, t)
+        for t in [
+            mx.int8,
+            mx.int32,
+            mx.int64,
+            mx.uint8,
+            mx.uint32,
+            mx.uint64,
+            mx.float16,
+            mx.bfloat16,
+        ]:
+            with self.assertRaises(ValueError):
+                mx.random.multivariate_normal(
+                    mean, cov, dtype=t, key=key, stream=mx.cpu
+                )
+
+        ## Check incompatible shapes
+        with self.assertRaises(ValueError):
+            mean = mx.zeros((2, 2))
+            cov = mx.zeros((2, 2))
+            mx.random.multivariate_normal(mean, cov, shape=(3,), key=key, stream=mx.cpu)
+
+        with self.assertRaises(ValueError):
+            mean = mx.zeros((2))
+            cov = mx.zeros((2, 2, 2))
+            mx.random.multivariate_normal(mean, cov, shape=(3,), key=key, stream=mx.cpu)
+
+        with self.assertRaises(ValueError):
+            mean = mx.zeros((3,))
+            cov = mx.zeros((2, 2))
+            mx.random.multivariate_normal(mean, cov, key=key, stream=mx.cpu)
+
+        with self.assertRaises(ValueError):
+            mean = mx.zeros((2,))
+            cov = mx.zeros((2, 3))
+            mx.random.multivariate_normal(mean, cov, key=key, stream=mx.cpu)
+
+        ## Different shape of mean and cov
+        mean = mx.array([[0, 7], [1, 2], [3, 4]])
+        cov = mx.array([[1, 0.5], [0.5, 1]])
+        a = mx.random.multivariate_normal(mean, cov, shape=(4, 3), stream=mx.cpu)
+        self.assertEqual(a.shape, (4, 3, 2))
+
+        ## Check correcteness of the mean and covariance
+        n_test = int(1e5)
+
+        def check_jointly_gaussian(data, mean, cov):
+            empirical_mean = mx.mean(data, axis=0)
+            empirical_cov = (
+                (data - empirical_mean).T @ (data - empirical_mean) / data.shape[0]
+            )
+            N = data.shape[1]
+            self.assertTrue(
+                mx.allclose(
+                    empirical_mean, mean, rtol=0.0, atol=10 * N**2 / math.sqrt(n_test)
+                )
+            )
+            self.assertTrue(
+                mx.allclose(
+                    empirical_cov, cov, rtol=0.0, atol=10 * N**2 / math.sqrt(n_test)
+                )
+            )
+
+        mean = mx.array([4.0, 7.0])
+        cov = mx.array([[2, 0.5], [0.5, 1]])
+        data = mx.random.multivariate_normal(
+            mean, cov, shape=(n_test,), key=key, stream=mx.cpu
+        )
+        check_jointly_gaussian(data, mean, cov)
+
+        mean = mx.arange(3)
+        cov = mx.array([[1, -1, 0.5], [-1, 1, -0.5], [0.5, -0.5, 1]])
+        data = mx.random.multivariate_normal(
+            mean, cov, shape=(n_test,), key=key, stream=mx.cpu
+        )
+        check_jointly_gaussian(data, mean, cov)
+
+    def test_randint(self):
+        a = mx.random.randint(0, 1, [])
+        self.assertEqual(a.shape, ())
+        self.assertEqual(a.dtype, mx.int32)
+
+        shape = (88,)
+        low = mx.array(3)
+        high = mx.array(15)
+
+        key = mx.random.key(0)
+        a = mx.random.randint(low, high, shape, key=key)
+        self.assertEqual(a.shape, shape)
+        self.assertEqual(a.dtype, mx.int32)
+
+        # Check using the same key yields the same value
+        b = mx.random.randint(low, high, shape, key=key)
+        self.assertListEqual(a.tolist(), b.tolist())
+
+        shape = (3, 4)
+        low = mx.reshape(mx.array([0] * 3), [3, 1])
+        high = mx.reshape(mx.array([12, 13, 14, 15]), [1, 4])
+
+        a = mx.random.randint(low, high, shape)
+        self.assertEqual(a.shape, shape)
+
+        a = mx.random.randint(-10, 10, [1000, 1000])
+        self.assertTrue(mx.all(-10 <= a).item() and mx.all(a < 10).item())
+
+        a = mx.random.randint(10, -10, [1000, 1000])
+        self.assertTrue(mx.all(a == 10).item())
+
+        self.assertEqual(
+            mx.random.randint(0, 1).dtype, mx.random.randint(0, 1, dtype=None).dtype
+        )
+
+    def test_bernoulli(self):
+        a = mx.random.bernoulli()
+        self.assertEqual(a.shape, ())
+        self.assertEqual(a.dtype, mx.bool_)
+
+        a = mx.random.bernoulli(mx.array(0.5), [5])
+        self.assertEqual(a.shape, (5,))
+
+        a = mx.random.bernoulli(mx.array([2.0, -2.0]))
+        self.assertEqual(a.tolist(), [True, False])
+        self.assertEqual(a.shape, (2,))
+
+        p = mx.array([0.1, 0.2, 0.3])
+        mx.reshape(p, [1, 3])
+        x = mx.random.bernoulli(p, [4, 3])
+        self.assertEqual(x.shape, (4, 3))
+
+        with self.assertRaises(ValueError):
+            mx.random.bernoulli(p, [2])  # Bad shape
+
+        with self.assertRaises(ValueError):
+            mx.random.bernoulli(0, [2])  # Bad type
+
+    def test_truncated_normal(self):
+        a = mx.random.truncated_normal(-2.0, 2.0)
+        self.assertEqual(a.size, 1)
+        self.assertEqual(a.dtype, mx.float32)
+
+        a = mx.random.truncated_normal(mx.array([]), mx.array([]))
+        self.assertEqual(a.dtype, mx.float32)
+        self.assertEqual(a.size, 0)
+
+        lower = mx.reshape(mx.array([-2.0, 0.0]), [1, 2])
+        upper = mx.reshape(mx.array([0.0, 1.0, 2.0]), [3, 1])
+        a = mx.random.truncated_normal(lower, upper)
+
+        self.assertEqual(a.shape, (3, 2))
+        self.assertTrue(mx.all(lower <= a).item() and mx.all(a <= upper).item())
+
+        a = mx.random.truncated_normal(2.0, -2.0)
+        self.assertTrue(mx.all(a == 2.0).item())
+
+        a = mx.random.truncated_normal(-3.0, 3.0, [542, 399])
+        self.assertEqual(a.shape, (542, 399))
+
+        lower = mx.array([-2.0, -1.0])
+        higher = mx.array([1.0, 2.0, 3.0])
+        with self.assertRaises(ValueError):
+            mx.random.truncated_normal(lower, higher)  # Bad shape
+
+        self.assertEqual(
+            mx.random.truncated_normal(0, 1).dtype,
+            mx.random.truncated_normal(0, 1, dtype=None).dtype,
+        )
+
+    def test_gumbel(self):
+        samples = mx.random.gumbel(shape=(100, 100))
+        self.assertEqual(samples.shape, (100, 100))
+        self.assertEqual(samples.dtype, mx.float32)
+        mean = 0.5772
+        # Std deviation of the sample mean is small (<0.02),
+        # so this test is pretty conservative
+        self.assertTrue(mx.abs(mx.mean(samples) - mean) < 0.2)
+
+        self.assertEqual(
+            mx.random.gumbel((1, 1)).dtype, mx.random.gumbel((1, 1), dtype=None).dtype
+        )
+
+    def test_categorical(self):
+        logits = mx.zeros((10, 20))
+        self.assertEqual(mx.random.categorical(logits, -1).shape, (10,))
+        self.assertEqual(mx.random.categorical(logits, 0).shape, (20,))
+        self.assertEqual(mx.random.categorical(logits, 1).shape, (10,))
+
+        out = mx.random.categorical(logits)
+        self.assertEqual(out.shape, (10,))
+        self.assertEqual(out.dtype, mx.uint32)
+        self.assertTrue(mx.max(out).item() < 20)
+
+        out = mx.random.categorical(logits, 0, [5, 20])
+        self.assertEqual(out.shape, (5, 20))
+        self.assertTrue(mx.max(out).item() < 10)
+
+        out = mx.random.categorical(logits, 1, num_samples=7)
+        self.assertEqual(out.shape, (10, 7))
+        out = mx.random.categorical(logits, 0, num_samples=7)
+        self.assertEqual(out.shape, (20, 7))
+
+        with self.assertRaises(ValueError):
+            mx.random.categorical(logits, shape=[10, 5], num_samples=5)
+
+    def test_permutation(self):
+        x = sorted(mx.random.permutation(4).tolist())
+        self.assertEqual([0, 1, 2, 3], x)
+
+        x = mx.array([0, 1, 2, 3])
+        x = sorted(mx.random.permutation(x).tolist())
+        self.assertEqual([0, 1, 2, 3], x)
+
+        x = mx.array([0, 1, 2, 3])
+        x = sorted(mx.random.permutation(x).tolist())
+
+        # 2-D
+        x = mx.arange(16).reshape(4, 4)
+        out = mx.sort(mx.random.permutation(x, axis=0), axis=0)
+        self.assertTrue(mx.array_equal(x, out))
+        out = mx.sort(mx.random.permutation(x, axis=1), axis=1)
+        self.assertTrue(mx.array_equal(x, out))
+
+        # Basically 0 probability this should fail.
+        sorted_x = mx.arange(16384)
+        x = mx.random.permutation(16384)
+        self.assertFalse(mx.array_equal(sorted_x, x))
+
+        # Preserves shape / doesn't cast input to int
+        x = mx.random.permutation(mx.array([[1]]))
+        self.assertEqual(x.shape, (1, 1))
+
+    def test_complex_normal(self):
+        sample = mx.random.normal(tuple(), dtype=mx.complex64)
+        self.assertEqual(sample.shape, tuple())
+        self.assertEqual(sample.dtype, mx.complex64)
+
+        sample = mx.random.normal((1, 2, 3, 4), dtype=mx.complex64)
+        self.assertEqual(sample.shape, (1, 2, 3, 4))
+        self.assertEqual(sample.dtype, mx.complex64)
+
+        sample = mx.random.normal((1, 2, 3, 4), dtype=mx.complex64, scale=2.0, loc=3.0)
+        self.assertEqual(sample.shape, (1, 2, 3, 4))
+        self.assertEqual(sample.dtype, mx.complex64)
+
+        sample = mx.random.normal(
+            (1, 2, 3, 4), dtype=mx.complex64, scale=2.0, loc=3.0 + 1j
+        )
+        self.assertEqual(sample.shape, (1, 2, 3, 4))
+        self.assertEqual(sample.dtype, mx.complex64)
+
+    def test_broadcastable_scale_loc(self):
+        b = mx.random.normal((10, 2))
+        sample = mx.random.normal((2, 10, 2), loc=b, scale=b)
+        mx.eval(sample)
+        self.assertEqual(sample.shape, (2, 10, 2))
+
+        with self.assertRaises(ValueError):
+            b = mx.random.normal((10,))
+            sample = mx.random.normal((2, 10, 2), loc=b, scale=b)
+
+        b = mx.random.normal((3, 1, 2))
+        sample = mx.random.normal((3, 4, 2), dtype=mx.float16, loc=b, scale=b)
+        mx.eval(sample)
+        self.assertEqual(sample.shape, (3, 4, 2))
+        self.assertEqual(sample.dtype, mx.float16)
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_reduce.py b/ml-stable-diffusion/mlx/python/tests/test_reduce.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6ddf353b3b6a3ff315eece7d8bf9e18d8b429df
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_reduce.py
@@ -0,0 +1,215 @@
+# Copyright © 2023 Apple Inc.
+
+import unittest
+from itertools import combinations, permutations
+
+import mlx.core as mx
+import mlx_tests
+import numpy as np
+
+
+class TestReduce(mlx_tests.MLXTestCase):
+    def test_axis_permutation_sums(self):
+        for shape in [(5, 5, 1, 5, 5), (65, 65, 1, 65)]:
+            with self.subTest(shape=shape):
+                x_npy = (np.random.randn(*shape) * 128).astype(np.int32)
+                x_mlx = mx.array(x_npy)
+                for t in permutations(range(len(shape))):
+                    with self.subTest(t=t):
+                        y_npy = np.transpose(x_npy, t)
+                        y_mlx = mx.transpose(x_mlx, t)
+                        for n in range(1, len(shape) + 1):
+                            for a in combinations(range(len(shape)), n):
+                                with self.subTest(a=a):
+                                    z_npy = np.sum(y_npy, axis=a)
+                                    z_mlx = mx.sum(y_mlx, axis=a)
+                                    mx.eval(z_mlx)
+                                    self.assertTrue(np.all(z_npy == z_mlx))
+
+    def test_expand_sums(self):
+        x_npy = np.random.randn(5, 1, 5, 1, 5, 1).astype(np.float32)
+        x_mlx = mx.array(x_npy)
+        for m in range(1, 4):
+            for ax in combinations([1, 3, 5], m):
+                shape = np.array([5, 1, 5, 1, 5, 1])
+                shape[list(ax)] = 5
+                shape = shape.tolist()
+                with self.subTest(shape=shape):
+                    y_npy = np.broadcast_to(x_npy, shape)
+                    y_mlx = mx.broadcast_to(x_mlx, shape)
+                    for n in range(1, 7):
+                        for a in combinations(range(6), n):
+                            with self.subTest(a=a):
+                                z_npy = np.sum(y_npy, axis=a) / 1000
+                                z_mlx = mx.sum(y_mlx, axis=a) / 1000
+                                mx.eval(z_mlx)
+                                self.assertTrue(
+                                    np.allclose(z_npy, np.array(z_mlx), atol=1e-4)
+                                )
+
+    def test_dtypes(self):
+        int_dtypes = [
+            "int8",
+            "int16",
+            "int32",
+            "uint8",
+            "uint16",
+            "uint32",
+            "int64",
+            "uint64",
+            "complex64",
+        ]
+        float_dtypes = ["float32"]
+
+        for dtype in int_dtypes + float_dtypes:
+            with self.subTest(dtype=dtype):
+                x = np.random.uniform(0, 2, size=(3, 3, 3)).astype(getattr(np, dtype))
+                y = mx.array(x)
+
+                for op in ("sum", "prod", "min", "max"):
+                    with self.subTest(op=op):
+                        np_op = getattr(np, op)
+                        mlx_op = getattr(mx, op)
+
+                        for axes in (None, 0, 1, 2, (0, 1), (0, 2), (1, 2), (0, 1, 2)):
+                            with self.subTest(axes=axes):
+                                if op in ("sum", "prod"):
+                                    r_np = np_op(
+                                        x, axis=axes, dtype=(getattr(np, dtype))
+                                    )
+                                else:
+                                    r_np = np_op(x, axis=axes)
+                                r_mlx = mlx_op(y, axis=axes)
+                                mx.eval(r_mlx)
+                                self.assertTrue(np.allclose(r_np, r_mlx, atol=1e-4))
+
+    def test_arg_reduce(self):
+        dtypes = [
+            "uint8",
+            "uint16",
+            "uint32",
+            "uint64",
+            "int8",
+            "int16",
+            "int32",
+            "int64",
+            "float16",
+            "float32",
+        ]
+        for dtype in dtypes:
+            with self.subTest(dtype=dtype):
+                data = np.random.rand(10, 12, 13).astype(getattr(np, dtype))
+                x = mx.array(data)
+                for op in ["argmin", "argmax"]:
+                    for axis in range(3):
+                        for kd in [True, False]:
+                            a = getattr(mx, op)(x, axis, kd)
+                            b = getattr(np, op)(data, axis, keepdims=kd)
+                            self.assertEqual(a.tolist(), b.tolist())
+
+                for op in ["argmin", "argmax"]:
+                    a = getattr(mx, op)(x, keepdims=True)
+                    b = getattr(np, op)(data, keepdims=True)
+                    self.assertEqual(a.tolist(), b.tolist())
+                    a = getattr(mx, op)(x)
+                    b = getattr(np, op)(data)
+                    self.assertEqual(a.item(), b)
+
+    def test_edge_case(self):
+        x = (mx.random.normal((100, 1, 100, 100)) * 128).astype(mx.int32)
+        x = x.transpose(0, 3, 1, 2)
+
+        y = x.sum((0, 2, 3))
+        mx.eval(y)
+        z = np.array(x).sum((0, 2, 3))
+        self.assertTrue(np.all(z == y))
+
+    def test_sum_bool(self):
+        x = np.random.uniform(0, 1, size=(10, 10, 10)) > 0.5
+        y = mx.array(x)
+        npsum = x.sum().item()
+        mxsum = y.sum().item()
+        self.assertEqual(npsum, mxsum)
+
+    def test_many_reduction_axes(self):
+
+        def check(x, axes):
+            expected = x
+            for ax in axes:
+                expected = mx.sum(expected, axis=ax, keepdims=True)
+            out = mx.sum(x, axis=axes, keepdims=True)
+            self.assertTrue(mx.array_equal(out, expected))
+
+        x = mx.random.randint(0, 10, shape=(4, 4, 4, 4, 4))
+        check(x, (0, 2, 4))
+
+        x = mx.random.randint(0, 10, shape=(4, 4, 4, 4, 4, 4, 4))
+        check(x, (0, 2, 4, 6))
+
+        x = mx.random.randint(0, 10, shape=(4, 4, 4, 4, 4, 4, 4, 4, 4))
+        check(x, (0, 2, 4, 6, 8))
+
+        x = mx.random.randint(0, 10, shape=(4, 4, 4, 4, 4, 4, 4, 4, 4, 128))
+        x = x.transpose(1, 0, 2, 3, 4, 5, 6, 7, 8, 9)
+        check(x, (1, 3, 5, 7, 9))
+
+    def test_nan_propagation(self):
+        dtypes = [
+            "uint8",
+            "uint16",
+            "uint32",
+            "int8",
+            "int16",
+            "int32",
+            "float16",
+            "float32",
+        ]
+
+        for dtype in dtypes:
+            with self.subTest(dtype=dtype):
+                x = (mx.random.normal((4, 4)) * 10).astype(getattr(mx, dtype))
+                indices = mx.random.randint(0, 4, shape=(6,)).reshape(3, 2)
+                for idx in indices:
+                    x[idx[0], idx[1]] = mx.nan
+                x_np = np.array(x)
+
+                for op in ["max", "min"]:
+                    for axis in [0, 1]:
+                        out = getattr(mx, op)(x, axis=axis)
+                        ref = getattr(np, op)(x_np, axis=axis)
+                        self.assertTrue(np.array_equal(out, ref, equal_nan=True))
+
+    def test_nan_propagation_complex64(self):
+        complex_array_1 = mx.array(
+            [1 + 1j, 2 + 2j, 3 + 3j, mx.nan + 4j], dtype=mx.complex64
+        ).reshape(2, 2)
+        complex_array_2 = mx.array(
+            [1 + 1j, 2 + 2j, 3 + mx.nan * 1j, 4 + 4j], dtype=mx.complex64
+        ).reshape(2, 2)
+        complex_array_3 = mx.array(
+            [1 + 1j, 2 + mx.nan * 1j, 3 + 3j, 4 + 4j], dtype=mx.complex64
+        ).reshape(2, 2)
+        complex_array_4 = mx.array(
+            [mx.nan + 1j, 2 + 2j, 3 + 3j, 4 + 4j], dtype=mx.complex64
+        ).reshape(2, 2)
+
+        np_arrays = [
+            np.array(complex_array_1),
+            np.array(complex_array_2),
+            np.array(complex_array_3),
+            np.array(complex_array_4),
+        ]
+
+        for mx_arr, np_arr in zip(
+            [complex_array_1, complex_array_2, complex_array_3, complex_array_4],
+            np_arrays,
+        ):
+            for axis in [0, 1]:
+                for op in ["max", "min"]:
+                    out = getattr(mx, op)(mx_arr, axis=axis)
+                    ref = getattr(np, op)(np_arr, axis=axis)
+                    self.assertTrue(np.array_equal(out, ref, equal_nan=True))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner(failfast=True)
diff --git a/ml-stable-diffusion/mlx/python/tests/test_tree.py b/ml-stable-diffusion/mlx/python/tests/test_tree.py
new file mode 100644
index 0000000000000000000000000000000000000000..bacf6e71d80b6e6065e111dc09fd3a3f0fa5158e
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_tree.py
@@ -0,0 +1,51 @@
+# Copyright © 2023 Apple Inc.
+
+import unittest
+
+import mlx.core as mx
+import mlx.nn as nn
+import mlx.utils
+import mlx_tests
+
+
+class TestTreeUtils(mlx_tests.MLXTestCase):
+    def test_tree_map(self):
+        tree = {"a": 0, "b": 1, "c": 2}
+        tree = mlx.utils.tree_map(lambda x: x + 1, tree)
+
+        expected_tree = {"a": 1, "b": 2, "c": 3}
+        self.assertEqual(tree, expected_tree)
+
+    def test_tree_flatten(self):
+        tree = [{"a": 1, "b": 2}, "c"]
+        vals = (1, 2, "c")
+        flat_tree = mlx.utils.tree_flatten(tree)
+        self.assertEqual(list(zip(*flat_tree))[1], vals)
+        self.assertEqual(mlx.utils.tree_unflatten(flat_tree), tree)
+
+    def test_merge(self):
+        t1 = {"a": 0}
+        t2 = {"b": 1}
+        t = mlx.utils.tree_merge(t1, t2)
+        self.assertEqual({"a": 0, "b": 1}, t)
+        with self.assertRaises(ValueError):
+            mlx.utils.tree_merge(t1, t1)
+        with self.assertRaises(ValueError):
+            mlx.utils.tree_merge(t, t1)
+
+        mod1 = nn.Sequential(nn.Linear(2, 2), nn.Linear(2, 2))
+        mod2 = nn.Sequential(nn.Linear(2, 2), nn.Linear(2, 2))
+        mod = nn.Sequential(mod1, mod2)
+
+        params1 = {"layers": [mod1.parameters()]}
+        params2 = {"layers": [None, mod2.parameters()]}
+        params = mlx.utils.tree_merge(params1, params2)
+        for (k1, v1), (k2, v2) in zip(
+            mlx.utils.tree_flatten(params), mlx.utils.tree_flatten(mod.parameters())
+        ):
+            self.assertEqual(k1, k2)
+            self.assertTrue(mx.array_equal(v1, v2))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_upsample.py b/ml-stable-diffusion/mlx/python/tests/test_upsample.py
new file mode 100644
index 0000000000000000000000000000000000000000..631853cce051061ab5f1ae21b587b2f25bcd6ad6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_upsample.py
@@ -0,0 +1,100 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import unittest
+
+import mlx.core as mx
+import mlx.nn as nn
+import mlx_tests
+import numpy as np
+
+try:
+    import torch
+    import torch.nn.functional as F
+
+    has_torch = True
+except ImportError as e:
+    has_torch = False
+
+
+class TestUpsample(mlx_tests.MLXTestCase):
+    @unittest.skipIf(not has_torch, "requires Torch")
+    def test_torch_upsample(self):
+        def run_upsample(
+            N,
+            C,
+            idim,
+            scale_factor,
+            mode,
+            align_corner,
+            dtype="float32",
+            atol=1e-5,
+        ):
+            with self.subTest(
+                N=N,
+                C=C,
+                idim=idim,
+                scale_factor=scale_factor,
+                mode=mode,
+                align_corner=align_corner,
+            ):
+                np_dtype = getattr(np, dtype)
+                np.random.seed(0)
+                iH, iW = idim
+                in_np = np.random.normal(-1.0, 1.0, (N, iH, iW, C)).astype(np_dtype)
+
+                in_mx = mx.array(in_np)
+                in_pt = torch.from_numpy(in_np.transpose(0, 3, 1, 2)).to("cpu")
+
+                out_mx = nn.Upsample(
+                    scale_factor=scale_factor,
+                    mode=mode,
+                    align_corners=align_corner,
+                )(in_mx)
+                mode_pt = {
+                    "nearest": "nearest",
+                    "linear": "bilinear",
+                    "cubic": "bicubic",
+                }[mode]
+                out_pt = F.interpolate(
+                    in_pt,
+                    scale_factor=scale_factor,
+                    mode=mode_pt,
+                    align_corners=align_corner if mode != "nearest" else None,
+                )
+                out_pt = torch.permute(out_pt, (0, 2, 3, 1)).numpy(force=True)
+                self.assertEqual(out_pt.shape, out_mx.shape)
+                self.assertTrue(np.allclose(out_pt, out_mx, atol=atol))
+
+        for dtype in ("float32",):
+            for N, C in ((1, 1), (2, 3)):
+                # only test cases in which target sizes are intergers
+                # if not, there will be numerical difference between mlx
+                # and torch due to different indices selection.
+                for idim, scale_factor in (
+                    ((2, 2), (1.0, 1.0)),
+                    ((2, 2), (1.5, 1.5)),
+                    ((2, 2), (2.0, 2.0)),
+                    ((4, 4), (0.5, 0.5)),
+                    ((7, 7), (2.0, 2.0)),
+                    ((10, 10), (0.2, 0.2)),
+                    ((10, 10), (0.3, 0.3)),
+                    ((11, 21), (3.0, 3.0)),
+                    ((11, 21), (3.0, 2.0)),
+                ):
+                    for mode in ("cubic", "linear", "nearest"):
+                        for align_corner in (False, True):
+                            if mode == "nearest" and align_corner:
+                                continue
+                            run_upsample(
+                                N,
+                                C,
+                                idim,
+                                scale_factor,
+                                mode,
+                                align_corner,
+                                dtype=dtype,
+                            )
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/python/tests/test_vmap.py b/ml-stable-diffusion/mlx/python/tests/test_vmap.py
new file mode 100644
index 0000000000000000000000000000000000000000..a88e59585cf51a3d43bee8dd3209c323e133134a
--- /dev/null
+++ b/ml-stable-diffusion/mlx/python/tests/test_vmap.py
@@ -0,0 +1,728 @@
+# Copyright © 2023-2024 Apple Inc.
+
+import gc
+import unittest
+
+import mlx.core as mx
+import mlx_tests
+
+
+class TestVmap(mlx_tests.MLXTestCase):
+    def test_basics(self):
+        # Can't vmap over scalars
+        with self.assertRaises(ValueError):
+            mx.vmap(mx.exp)(mx.array(1.0))
+
+        # Invalid input
+        with self.assertRaises(ValueError):
+            mx.vmap(mx.exp)("hello")
+
+        # Invalid axes
+        with self.assertRaises(ValueError):
+            mx.vmap(mx.exp, in_axes="hello")(mx.array([0, 1]))
+
+        with self.assertRaises(ValueError):
+            mx.vmap(mx.exp, in_axes=2)(mx.array([0, 1]))
+
+        with self.assertRaises(ValueError):
+            mx.vmap(mx.exp, out_axes="hello")(mx.array([0, 1]))
+
+        with self.assertRaises(ValueError):
+            mx.vmap(mx.exp, out_axes=2)(mx.array([0, 1]))
+
+    def test_unary(self):
+        ops = [
+            "abs",
+            "cos",
+            "erf",
+            "erfinv",
+            "exp",
+            "log",
+            "log1p",
+            "log2",
+            "log10",
+            "logical_not",
+            "negative",
+            "reciprocal",
+            "rsqrt",
+            "sigmoid",
+            "sign",
+            "sin",
+            "sqrt",
+            "square",
+            "degrees",
+            "radians",
+        ]
+        for opname in ops:
+            with self.subTest(op=opname):
+                op = getattr(mx, opname)
+                x = mx.arange(5)
+                y = mx.vmap(op)(x)
+                self.assertTrue(mx.array_equal(y, op(x), equal_nan=True))
+
+                x = mx.arange(8).reshape(2, 4)
+                y = mx.vmap(op)(x)
+                self.assertTrue(mx.array_equal(y, op(x), equal_nan=True))
+
+                y = mx.vmap(op, in_axes=1, out_axes=1)(x)
+                self.assertTrue(mx.array_equal(y, op(x), equal_nan=True))
+
+    def test_binary(self):
+        ops = [
+            "add",
+            "divide",
+            "equal",
+            "greater",
+            "greater_equal",
+            "less",
+            "less_equal",
+            "logaddexp",
+            "maximum",
+            "minimum",
+            "multiply",
+            "power",
+            "subtract",
+            "logical_or",
+            "logical_and",
+        ]
+        for opname in ops:
+            with self.subTest(op=opname):
+                op = getattr(mx, opname)
+                x = mx.random.uniform(shape=(5,))
+                y = mx.random.uniform(shape=(5,))
+                out = mx.vmap(op)(x, y)
+                self.assertTrue(mx.array_equal(out, op(x, y)))
+
+                x = mx.random.uniform(shape=(2, 4))
+                y = mx.random.uniform(shape=(2, 4))
+                out = mx.vmap(op)(x, y)
+                self.assertTrue(mx.array_equal(out, op(x, y)))
+
+                out = mx.vmap(op, in_axes=(0, 0), out_axes=0)(x, y)
+                self.assertTrue(mx.array_equal(out, op(x, y)))
+
+                y = mx.random.uniform(shape=(4, 2))
+                out = mx.vmap(op, in_axes=(0, 1), out_axes=0)(x, y)
+                self.assertTrue(mx.array_equal(out, op(x, y.T)))
+
+                out = mx.vmap(op, in_axes=(0, 1), out_axes=1)(x, y)
+                self.assertTrue(mx.array_equal(out, op(x, y.T).T))
+
+    def test_tree(self):
+        def my_fun(tree):
+            return (tree["a"] + tree["b"][0]) * tree["b"][1]
+
+        tree = {
+            "a": mx.random.uniform(shape=(2, 4)),
+            "b": (
+                mx.random.uniform(shape=(2, 4)),
+                mx.random.uniform(shape=(2, 4)),
+            ),
+        }
+        out = mx.vmap(my_fun)(tree)
+        expected = my_fun(tree)
+        self.assertTrue(mx.array_equal(out, my_fun(tree)))
+
+        with self.assertRaises(ValueError):
+            mx.vmap(my_fun, in_axes={"a": 0, "b": ((0, 0), 0)}, out_axes=0)(tree)
+
+        out = mx.vmap(my_fun, in_axes={"a": 0, "b": 0}, out_axes=0)(tree)
+        self.assertTrue(mx.array_equal(out, my_fun(tree)))
+
+        out = mx.vmap(my_fun, in_axes={"a": 0, "b": (0, 0)}, out_axes=0)(tree)
+        self.assertTrue(mx.array_equal(out, my_fun(tree)))
+
+        tree = {
+            "a": mx.random.uniform(shape=(2, 4)),
+            "b": (
+                mx.random.uniform(shape=(4, 2)),
+                mx.random.uniform(shape=(4, 2)),
+            ),
+        }
+        out = mx.vmap(my_fun, in_axes={"a": 0, "b": (1, 1)}, out_axes=0)(tree)
+        expected = (tree["a"] + tree["b"][0].T) * tree["b"][1].T
+        self.assertTrue(mx.array_equal(out, expected))
+
+        def my_fun(x, y):
+            return {"a": x + y, "b": x * y}
+
+        x = mx.random.uniform(shape=(2, 4))
+        y = mx.random.uniform(shape=(2, 4))
+        out = mx.vmap(my_fun, in_axes=0, out_axes=0)(x, y)
+        expected = my_fun(x, y)
+        self.assertTrue(mx.array_equal(out["a"], expected["a"]))
+        self.assertTrue(mx.array_equal(out["b"], expected["b"]))
+
+        with self.assertRaises(ValueError):
+            mx.vmap(my_fun, in_axes=0, out_axes=(0, 1))(x, y)
+
+        with self.assertRaises(ValueError):
+            mx.vmap(my_fun, in_axes=0, out_axes={"a": 0, "c": 1})(x, y)
+
+        out = mx.vmap(my_fun, in_axes=0, out_axes={"a": 1, "b": 0})(x, y)
+        expected = my_fun(x, y)
+        self.assertTrue(mx.array_equal(out["a"].T, expected["a"]))
+        self.assertTrue(mx.array_equal(out["b"], expected["b"]))
+
+    def test_vmap_indexing(self):
+        x = mx.arange(16).reshape(2, 2, 2, 2)
+        inds = mx.array([[0, 1, 0], [1, 1, 0]])
+
+        out = mx.vmap(lambda x, y: x[y], in_axes=(0, 0))(x, inds)
+        expected = mx.array(
+            [
+                [[[0, 1], [2, 3]], [[4, 5], [6, 7]], [[0, 1], [2, 3]]],
+                [[[12, 13], [14, 15]], [[12, 13], [14, 15]], [[8, 9], [10, 11]]],
+            ]
+        )
+        self.assertTrue(mx.array_equal(out, expected))
+
+        out = mx.vmap(lambda x, y: x[y], in_axes=(0, None))(x, inds)
+        expected = mx.array(
+            [
+                [
+                    [[[0, 1], [2, 3]], [[4, 5], [6, 7]], [[0, 1], [2, 3]]],
+                    [[[4, 5], [6, 7]], [[4, 5], [6, 7]], [[0, 1], [2, 3]]],
+                ],
+                [
+                    [[[8, 9], [10, 11]], [[12, 13], [14, 15]], [[8, 9], [10, 11]]],
+                    [[[12, 13], [14, 15]], [[12, 13], [14, 15]], [[8, 9], [10, 11]]],
+                ],
+            ]
+        )
+        self.assertTrue(mx.array_equal(out, expected))
+
+        out = mx.vmap(lambda x, y: x[y], in_axes=(None, 0))(x, inds)
+        expected = mx.array(
+            [
+                [
+                    [[[0, 1], [2, 3]], [[4, 5], [6, 7]]],
+                    [[[8, 9], [10, 11]], [[12, 13], [14, 15]]],
+                    [[[0, 1], [2, 3]], [[4, 5], [6, 7]]],
+                ],
+                [
+                    [[[8, 9], [10, 11]], [[12, 13], [14, 15]]],
+                    [[[8, 9], [10, 11]], [[12, 13], [14, 15]]],
+                    [[[0, 1], [2, 3]], [[4, 5], [6, 7]]],
+                ],
+            ]
+        )
+        self.assertTrue(mx.array_equal(out, expected))
+
+        inds2 = mx.array([[0, 1, 0], [0, 1, 0]])
+        out = mx.vmap(lambda x, y, z: x[y, z], in_axes=(None, 0, 0))(x, inds, inds2)
+        expected = mx.array(
+            [
+                [[[0, 1], [2, 3]], [[12, 13], [14, 15]], [[0, 1], [2, 3]]],
+                [[[8, 9], [10, 11]], [[12, 13], [14, 15]], [[0, 1], [2, 3]]],
+            ]
+        )
+        self.assertTrue(mx.array_equal(out, expected))
+
+    def test_vmap_reduce(self):
+        a = mx.ones((5, 5), mx.int32)
+        out = mx.vmap(lambda x: x.sum())(a)
+        self.assertTrue(mx.array_equal(out, mx.full((5,), 5)))
+
+        out = mx.vmap(lambda x: x.sum(keepdims=True))(a)
+        self.assertTrue(mx.array_equal(out, mx.full((5, 1), 5)))
+
+        out = mx.vmap(lambda x: x.sum(axis=0))(a)
+        self.assertTrue(mx.array_equal(out, mx.full((5,), 5)))
+
+        a = mx.ones((5, 3, 2), mx.int32)
+        out = mx.vmap(lambda x: x.sum(axis=(0, 1)))(a)
+        self.assertTrue(mx.array_equal(out, mx.full((5,), 6)))
+
+        a = mx.ones((5, 3, 2), mx.int32)
+        out = mx.vmap(lambda x: x.sum(axis=(0, 1)), in_axes=(1,))(a)
+        self.assertTrue(mx.array_equal(out, mx.full((3,), 10)))
+
+        a = mx.ones((5, 3, 2), mx.int32)
+        out = mx.vmap(lambda x: x.sum(axis=(0, 1)), in_axes=(2,))(a)
+        self.assertTrue(mx.array_equal(out, mx.full((2,), 15)))
+
+    def test_vmap_argreduce(self):
+        a = mx.array([[1, 2, 3], [2, 3, 1]])
+        out = mx.vmap(lambda x: mx.argmin(x))(a)
+        expected = mx.array([0, 2])
+        self.assertTrue(mx.array_equal(out, expected))
+
+        out = mx.vmap(lambda x: mx.argmax(x))(a)
+        expected = mx.array([2, 1])
+        self.assertTrue(mx.array_equal(out, expected))
+
+    def test_vmap_mean(self):
+        a = mx.arange(8).reshape(2, 4)
+        out = mx.vmap(mx.mean)(a)
+        expected = mx.mean(a, axis=1)
+        self.assertTrue(mx.allclose(out, expected))
+
+        a = mx.arange(16).reshape(2, 2, 4)
+        out = mx.vmap(mx.vmap(mx.mean))(a)
+        expected = mx.mean(a, axis=2)
+        self.assertTrue(mx.allclose(out, expected))
+
+    def test_mismatch_input_sizes(self):
+        a = mx.ones((10, 1))
+        b = mx.ones((1, 1, 1, 5))
+
+        with self.assertRaises(ValueError):
+            out = mx.vmap(lambda x, y: x + y)(a, b)
+
+        b = mx.ones((10, 5))
+        with self.assertRaises(ValueError):
+            out = mx.vmap(lambda x, y: x + y, in_axes=(0, 1))(a, b)
+
+    def test_vmap_matmul(self):
+        a = mx.random.uniform(shape=(2, 3, 4))
+        b = mx.random.uniform(shape=(4, 3))
+
+        # matmul
+        out = mx.vmap(mx.matmul, in_axes=(0, None))(a, b)
+        self.assertTrue(mx.allclose(out, a @ b))
+
+        # addmm
+        c = mx.random.uniform(shape=(3,))
+        out = mx.vmap(mx.addmm, in_axes=(None, 0, None))(c, a, b)
+        self.assertTrue(mx.allclose(out, mx.addmm(c, a, b)))
+
+        b = mx.random.uniform(shape=(4, 2))
+
+        # matmul
+        out = mx.vmap(mx.matmul, in_axes=(1, None), out_axes=(1,))(a, b)
+        expected = mx.moveaxis(mx.moveaxis(a, 1, 0) @ b, 0, 1)
+        self.assertTrue(mx.allclose(out, expected))
+
+        # addmm
+        c = mx.random.uniform(shape=(2,))
+        out = mx.vmap(mx.addmm, in_axes=(None, 1, None))(c, a, b)
+        self.assertTrue(mx.allclose(out, mx.addmm(c, mx.moveaxis(a, 1, 0), b)))
+
+        a = mx.random.uniform(shape=(2, 3, 4))
+        b = mx.random.uniform(shape=(4, 2, 3))
+
+        # matmul
+        out = mx.vmap(mx.matmul, in_axes=(0, 1))(a, b)
+        expected = a @ mx.moveaxis(b, 1, 0)
+        self.assertTrue(mx.allclose(out, expected))
+
+        # addmm
+        c = mx.random.uniform(shape=(3, 3, 2))
+        out = mx.vmap(mx.addmm, in_axes=(2, 0, 1))(c, a, b)
+        expected = mx.addmm(mx.moveaxis(c, 2, 0), a, mx.moveaxis(b, 1, 0))
+        self.assertTrue(mx.allclose(out, expected))
+
+    def test_vmap_svd(self):
+        a = mx.random.uniform(shape=(3, 4, 2))
+
+        cpu_svd_full = lambda x: mx.linalg.svd(x, compute_uv=True, stream=mx.cpu)
+        cpu_svd_singular = lambda x: mx.linalg.svd(x, compute_uv=False, stream=mx.cpu)
+
+        # Vmap over the first axis (this is already supported natively by the primitive).
+        Us, Ss, Vts = mx.vmap(cpu_svd_full, in_axes=(0,))(a)
+        self.assertEqual(Us.shape, (a.shape[0], a.shape[1], a.shape[1]))
+        self.assertEqual(Ss.shape, (a.shape[0], a.shape[2]))
+        self.assertEqual(Vts.shape, (a.shape[0], a.shape[2], a.shape[2]))
+
+        Sv = mx.vmap(cpu_svd_singular, in_axes=(0,))(a)
+        self.assertEqual(Sv.shape, (a.shape[0], a.shape[2]))
+
+        for i in range(a.shape[0]):
+            M = a[i]
+            U, S, Vt = Us[i], Ss[i], Vts[i]
+            self.assertTrue(
+                mx.allclose(U[:, : len(S)] @ mx.diag(S) @ Vt, M, rtol=1e-5, atol=1e-7)
+            )
+            self.assertTrue(
+                mx.allclose(
+                    mx.linalg.norm(Sv[i]),
+                    mx.linalg.norm(M, ord="fro"),
+                    rtol=1e-5,
+                    atol=1e-7,
+                )
+            )
+
+        # Vmap over the second axis.
+        Us, Ss, Vts = mx.vmap(cpu_svd_full, in_axes=(1,))(a)
+        self.assertEqual(Us.shape, (a.shape[1], a.shape[0], a.shape[0]))
+        self.assertEqual(Ss.shape, (a.shape[1], a.shape[2]))
+        self.assertEqual(Vts.shape, (a.shape[1], a.shape[2], a.shape[2]))
+
+        Sv = mx.vmap(cpu_svd_singular, in_axes=(1,))(a)
+        self.assertEqual(Sv.shape, (a.shape[1], a.shape[2]))
+
+        for i in range(a.shape[1]):
+            M = a[:, i, :]
+            U, S, Vt = Us[i], Ss[i], Vts[i]
+            self.assertTrue(
+                mx.allclose(U[:, : len(S)] @ mx.diag(S) @ Vt, M, rtol=1e-5, atol=1e-7)
+            )
+            self.assertTrue(
+                mx.allclose(
+                    mx.linalg.norm(Sv[i]),
+                    mx.linalg.norm(M, ord="fro"),
+                    rtol=1e-5,
+                    atol=1e-7,
+                )
+            )
+
+    def test_vmap_inverse(self):
+        mx.random.seed(42)
+        a = mx.random.uniform(shape=(3, 4, 4))
+
+        cpu_inv = lambda x: mx.linalg.inv(x, stream=mx.cpu)
+
+        # Vmap over the first axis (this is already supported natively by the primitive).
+        invs = mx.vmap(cpu_inv, in_axes=(0,))(a)
+
+        for i in range(a.shape[0]):
+            self.assertTrue(
+                mx.allclose(a[i] @ invs[i], mx.eye(a.shape[1]), rtol=1e-4, atol=1e-5)
+            )
+
+        a = mx.random.uniform(shape=(4, 3, 4))
+
+        # Without vmapping, each input matrix is not square.
+        with self.assertRaises(ValueError):
+            mx.eval(cpu_inv(a))
+
+        # Vmap over the second axis.
+        invs = mx.vmap(cpu_inv, in_axes=(1,))(a)
+
+        for i in range(a.shape[1]):
+            self.assertTrue(
+                mx.allclose(
+                    a[:, i, :] @ invs[i], mx.eye(a.shape[0]), rtol=1e-4, atol=1e-5
+                )
+            )
+
+    def test_vmap_gather(self):
+        def gather(a, idx):
+            return a[idx]
+
+        a = mx.array([[1, 2], [3, 4]])
+        idx = mx.array(0)
+        out = mx.vmap(gather, (0, None))(a, idx)
+        self.assertTrue(mx.array_equal(out, mx.array([1, 3])))
+
+        out = mx.vmap(gather, (1, None))(a, idx)
+        self.assertTrue(mx.array_equal(out, mx.array([1, 2])))
+
+        idx = mx.array([0, 1])
+        out = mx.vmap(gather, (0, 0))(a, idx)
+        self.assertTrue(mx.array_equal(out, mx.array([1, 4])))
+
+        a = mx.ones((2, 3, 4))
+        idx = mx.zeros(4, mx.int32)
+        out = mx.vmap(gather, (2, 0))(a, idx)
+        self.assertEqual(out.shape, (4, 3))
+
+        f = mx.vmap(gather, (0, None))
+        f = mx.vmap(gather, (0, 0))
+        out = f(mx.ones((2, 3, 4)), mx.zeros(2, dtype=mx.int32))
+        self.assertEqual(out.shape, (2, 4))
+
+        def gather(a, idxa, idxb):
+            return a[idxa, idxb]
+
+        a = mx.ones((2, 3, 4))
+        idxa = mx.zeros((2, 3), mx.int32)
+        idxb = mx.zeros(3, mx.int32)
+        out = mx.vmap(gather, (0, 0, None))(a, idxa, idxb)
+        self.assertEqual(out.shape, (2, 3))
+
+        idxa = mx.zeros((3, 1, 2), mx.int32)
+        idxb = mx.zeros((2, 3, 1, 2), mx.int32)
+        out = mx.vmap(gather, (0, None, 0))(a, idxa, idxb)
+        self.assertEqual(out.shape, (2, 3, 1, 2))
+
+        idxa = mx.zeros((3, 1, 2), mx.int32)
+        idxb = mx.zeros((3, 1, 2, 2), mx.int32)
+        out = mx.vmap(gather, (0, None, 3))(a, idxa, idxb)
+        self.assertEqual(out.shape, (2, 3, 1, 2))
+
+    def test_vmap_scatter(self):
+        def scatter(a):
+            a[mx.array(0)] = mx.array(0.0)
+            return a
+
+        a = mx.array([[1.0, 2.0, 3.0], [2.0, 3.0, 4.0]])
+        out = mx.vmap(scatter)(a)
+        expected = mx.array([[0.0, 2.0, 3.0], [0.0, 3.0, 4.0]])
+        self.assertTrue(mx.allclose(out, expected))
+
+        out = mx.vmap(scatter, in_axes=(1,), out_axes=1)(a)
+        expected = mx.array([[0.0, 0.0, 0.0], [2.0, 3.0, 4.0]])
+        self.assertTrue(mx.allclose(out, expected))
+
+        def scatter_add(a):
+            return a.at[mx.array(0)].add(mx.array(1.0))
+
+        a = mx.array([[1.0, 2.0, 3.0], [2.0, 3.0, 4.0]])
+        out = mx.vmap(scatter_add)(a)
+        expected = mx.array([[2.0, 2.0, 3.0], [3.0, 3.0, 4.0]])
+        self.assertTrue(mx.allclose(out, expected))
+
+        out = mx.vmap(scatter_add, in_axes=(1,), out_axes=1)(a)
+        expected = mx.array([[2.0, 3.0, 4.0], [2.0, 3.0, 4.0]])
+        self.assertTrue(mx.allclose(out, expected))
+
+        # Multiple indices
+        def scatter(a):
+            a[mx.array([0, 1]), mx.array([0, 1])] = mx.array((1.0, 1.0))
+            return a
+
+        a = mx.zeros((3, 3, 3))
+
+        expected = mx.repeat(scatter(mx.zeros((3, 3)))[None], 3, axis=0)
+        out = mx.vmap(scatter, in_axes=(0,), out_axes=0)(a)
+        self.assertTrue(mx.allclose(out, expected))
+
+        expected = mx.zeros((3, 3, 3))
+        expected[0, :, 0] = 1
+        expected[1, :, 1] = 1
+        out = mx.vmap(scatter, in_axes=(1,), out_axes=1)(a)
+        self.assertTrue(mx.allclose(out, expected))
+
+        expected = mx.zeros((3, 3, 3))
+        expected[0, 0, :] = 1
+        expected[1, 1, :] = 1
+        out = mx.vmap(scatter, in_axes=(2,), out_axes=2)(a)
+        self.assertTrue(mx.allclose(out, expected))
+
+        # vmap over src and indices
+        def scatter(a, idx):
+            a[idx] = mx.array(1.0)
+            return a
+
+        a = mx.zeros((3, 4))
+        idx = mx.array([0, 1, 2])
+        out = mx.vmap(scatter, in_axes=(0, 0), out_axes=0)(a, idx)
+        self.assertTrue(mx.allclose(out, mx.eye(n=3, m=4)))
+
+        # vmap over only indices
+        out = mx.vmap(scatter, in_axes=(None, 0), out_axes=0)(a, idx)
+        expected = mx.zeros((3, 3, 4))
+        expected[0, 0] = 1
+        expected[1, 1] = 1
+        expected[2, 2] = 1
+        self.assertTrue(mx.allclose(out, expected))
+
+        # vmap over src, indices, updates
+        def scatter(a, idx, updates):
+            a[idx] = updates
+            return a
+
+        a = mx.zeros((3, 4))
+        idx = mx.array([0, 1, 2])
+        updates = mx.array([1, 2, 3])
+        out = mx.vmap(scatter, in_axes=(0, 0, 0), out_axes=0)(a, idx, updates)
+        expected = mx.diag(mx.array([1, 2, 3]), k=-1)[1:]
+        self.assertTrue(mx.allclose(out, expected))
+
+        # vmap over only updates
+        def scatter(a, idx, updates):
+            a[idx] = updates
+            return a
+
+        a = mx.zeros((3, 4))
+        idx = mx.array([0])
+        updates = mx.array([1, 2, 3])
+        out = mx.vmap(scatter, in_axes=(None, None, 0), out_axes=0)(a, idx, updates)
+        expected = mx.zeros((3, 3, 4))
+        expected[:, 0] = mx.array([1, 2, 3])[:, None]
+        self.assertTrue(mx.allclose(out, expected))
+
+    def test_vmap_const_func(self):
+        a = mx.random.uniform(shape=(2, 3, 4))
+        b = mx.random.uniform(shape=(4, 3))
+
+        def const_func(a, b):
+            return mx.array(2)
+
+        out = mx.vmap(const_func, in_axes=(0, None))(a, b)
+        self.assertTrue(mx.array_equal(mx.full((2,), 2), out))
+        out = mx.vmap(const_func, in_axes=(None, 0))(a, b)
+        self.assertTrue(mx.array_equal(mx.full((4,), 2), out))
+        out = mx.vmap(const_func, in_axes=(1, 1))(a, b)
+        self.assertTrue(mx.array_equal(mx.full((3,), 2), out))
+
+        with self.assertRaises(ValueError):
+            out = mx.vmap(const_func, in_axes=(None, None))(a, b)
+
+        with self.assertRaises(ValueError):
+            out = mx.vmap(const_func, in_axes=(0, 0))(a, b)
+
+    def test_vmap_concatenate(self):
+        x = mx.random.uniform(shape=(2, 2, 2))
+
+        def cat_fun(x, y):
+            return mx.concatenate([x, y], axis=1)
+
+        def cat_constant(x):
+            y = mx.ones((2, 1))
+            return mx.concatenate([x, y], 1)
+
+        out = mx.vmap(cat_fun, in_axes=(0, 2))(x, x)
+        target = mx.stack(
+            [mx.concatenate([x[i], x[:, :, i]], axis=1) for i in range(2)]
+        )
+        self.assertTrue(mx.array_equal(out, target))
+
+        out = mx.vmap(cat_constant)(x)
+        target = mx.concatenate([x, mx.ones((2, 2, 1))], axis=2)
+        self.assertTrue(mx.array_equal(out, target))
+
+    def test_vmap_take_along_axis(self):
+        a = mx.zeros((4, 5, 1))
+        idx = mx.zeros((2, 4, 1), mx.int32)
+
+        def fun(a, idx):
+            return mx.take_along_axis(a, idx, axis=0)
+
+        out = mx.vmap(fun, in_axes=(0, 1))(a, idx)
+        self.assertEqual(out.shape, (4, 2, 1))
+
+        idx = mx.zeros((2, 1), mx.int32)
+
+        out = mx.vmap(fun, in_axes=(0, None))(a, idx)
+        self.assertEqual(out.shape, (4, 2, 1))
+
+        a = mx.zeros((5, 1))
+        idx = mx.zeros((4, 2, 1), mx.int32)
+
+        out = mx.vmap(fun, in_axes=(None, 0))(a, idx)
+        self.assertEqual(out.shape, (4, 2, 1))
+
+    def test_vmap_put_along_axis(self):
+        a = mx.zeros((4, 5, 1))
+        idx = mx.ones((2, 4, 1), mx.int32)
+        upd = mx.ones((2, 4, 1))
+
+        def fun(a, idx, upd):
+            return mx.put_along_axis(a, idx, upd, axis=0)
+
+        out = mx.vmap(fun, in_axes=(0, 1, 1))(a, idx, upd)
+        self.assertEqual(out.shape, (4, 5, 1))
+
+        upd = mx.ones((2, 1))
+        out = mx.vmap(fun, in_axes=(0, 1, None))(a, idx, upd)
+        self.assertEqual(out.shape, (4, 5, 1))
+
+        idx = mx.ones((2, 1), mx.int32)
+        upd = mx.ones((2, 1))
+        out = mx.vmap(fun, in_axes=(0, None, None))(a, idx, upd)
+        self.assertEqual(out.shape, (4, 5, 1))
+
+        a = mx.zeros((5, 1))
+        idx = mx.ones((2, 4, 1), mx.int32)
+        upd = mx.ones((2, 4, 1))
+        out = mx.vmap(fun, in_axes=(None, 1, 1))(a, idx, upd)
+        self.assertEqual(out.shape, (4, 5, 1))
+
+    def test_vmap_split_vmap(self):
+        def fun(x):
+            a, b = mx.split(x, 2, 1)
+            return mx.concatenate([b, a], 1)
+
+        x = mx.ones((5, 6, 7))
+        y = mx.ones((5, 4, 6, 7))
+        fx = fun(x)
+        fy = mx.vmap(fun, in_axes=1)(y)
+        self.assertEqual(fx.shape, (5, 6, 7))
+        self.assertEqual(fy.shape, (4, 5, 6, 7))
+
+    def test_leaks(self):
+        gc.collect()
+        mx.synchronize()
+        if mx.metal.is_available():
+            mem_pre = mx.get_active_memory()
+        else:
+            mem_pre = 0
+
+        def outer():
+            d = {}
+
+            def f(x):
+                return d["x"]
+
+            d["f"] = mx.vmap(f)
+            d["x"] = mx.array([0] * 1000)
+
+        for _ in range(5):
+            outer()
+            gc.collect()
+
+        mx.synchronize()
+        if mx.metal.is_available():
+            mem_post = mx.get_active_memory()
+        else:
+            mem_post = 0
+
+        self.assertEqual(mem_pre, mem_post)
+
+    def test_vmap_flatten(self):
+        def fun(x):
+            return mx.flatten(x, 0, 1)
+
+        x = mx.zeros((2, 3, 4))
+
+        self.assertEqual(mx.vmap(fun)(x).shape, (2, 12))
+        self.assertEqual(mx.vmap(fun, in_axes=(1,))(x).shape, (3, 8))
+        self.assertEqual(mx.vmap(fun, in_axes=(2,))(x).shape, (4, 6))
+
+    def test_vmap_conv(self):
+        # vmap input only
+        x = mx.random.uniform(shape=(2, 2, 5, 4))
+        w = mx.random.uniform(shape=(8, 3, 4))
+
+        expected = mx.stack([mx.conv1d(xi, w) for xi in x])
+        out = mx.vmap(mx.conv1d, in_axes=(0, None))(x, w)
+        self.assertTrue(mx.allclose(expected, out))
+
+        x = mx.moveaxis(x, 0, 2)
+        out = mx.vmap(mx.conv1d, in_axes=(2, None))(x, w)
+        self.assertTrue(mx.allclose(expected, out))
+
+        # vmap weights only
+        x = mx.random.uniform(shape=(2, 5, 4))
+        w = mx.random.uniform(shape=(3, 8, 3, 4))
+
+        expected = mx.stack([mx.conv1d(x, wi) for wi in w])
+        out = mx.vmap(mx.conv1d, in_axes=(None, 0))(x, w)
+        self.assertTrue(mx.allclose(expected, out))
+
+        w = mx.moveaxis(w, 0, 1)
+        out = mx.vmap(mx.conv1d, in_axes=(None, 1))(x, w)
+        self.assertTrue(mx.allclose(expected, out))
+
+        # vmap weights and input
+        x = mx.random.uniform(shape=(3, 2, 5, 4))
+        w = mx.random.uniform(shape=(3, 8, 3, 4))
+
+        expected = mx.stack([mx.conv1d(xi, wi) for xi, wi in zip(x, w)])
+        out = mx.vmap(mx.conv1d, in_axes=(0, 0))(x, w)
+        self.assertTrue(mx.allclose(expected, out))
+
+        x = mx.random.uniform(shape=(2, 3, 5, 4))
+        w = mx.random.uniform(shape=(8, 3, 4, 3))
+
+        expected = mx.stack([mx.conv1d(x[:, i], w[..., i]) for i in range(3)])
+        out = mx.vmap(mx.conv1d, in_axes=(1, 3))(x, w)
+        self.assertTrue(mx.allclose(expected, out))
+
+        # Test with groups
+        x = mx.random.uniform(shape=(3, 2, 5, 8))
+        w = mx.random.uniform(shape=(3, 2, 3, 4))
+
+        def gconv(x, w):
+            return mx.conv1d(x, w, groups=2)
+
+        expected = mx.stack([gconv(xi, wi) for xi, wi in zip(x, w)])
+        out = mx.vmap(gconv, in_axes=(0, 0))(x, w)
+        self.assertTrue(mx.allclose(expected, out))
+
+
+if __name__ == "__main__":
+    mlx_tests.MLXTestRunner()
diff --git a/ml-stable-diffusion/mlx/setup.py b/ml-stable-diffusion/mlx/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..176d078fb51400a2b199145421704151a10aff46
--- /dev/null
+++ b/ml-stable-diffusion/mlx/setup.py
@@ -0,0 +1,305 @@
+# Copyright © 2023 Apple Inc.
+
+import datetime
+import os
+import platform
+import re
+import subprocess
+from functools import partial
+from pathlib import Path
+from subprocess import run
+
+from setuptools import Command, Extension, find_namespace_packages, setup
+from setuptools.command.bdist_wheel import bdist_wheel
+from setuptools.command.build_ext import build_ext
+
+
+def get_version():
+    with open("mlx/version.h", "r") as fid:
+        for l in fid:
+            if "#define MLX_VERSION_MAJOR" in l:
+                major = l.split()[-1]
+            if "#define MLX_VERSION_MINOR" in l:
+                minor = l.split()[-1]
+            if "#define MLX_VERSION_PATCH" in l:
+                patch = l.split()[-1]
+    version = f"{major}.{minor}.{patch}"
+    if "PYPI_RELEASE" not in os.environ:
+        today = datetime.date.today()
+        version = f"{version}.dev{today.year}{today.month:02d}{today.day:02d}"
+
+        if "DEV_RELEASE" not in os.environ:
+            git_hash = (
+                run(
+                    "git rev-parse --short HEAD".split(),
+                    capture_output=True,
+                    check=True,
+                )
+                .stdout.strip()
+                .decode()
+            )
+            version = f"{version}+{git_hash}"
+
+    return version
+
+
+build_stage = int(os.environ.get("MLX_BUILD_STAGE", 0))
+build_macos = platform.system() == "Darwin"
+build_cuda = "MLX_BUILD_CUDA=ON" in os.environ.get("CMAKE_ARGS", "")
+
+
+# A CMakeExtension needs a sourcedir instead of a file list.
+# The name must be the _single_ output extension from the CMake build.
+# If you need multiple extensions, see scikit-build.
+class CMakeExtension(Extension):
+    def __init__(self, name: str, sourcedir: str = "") -> None:
+        super().__init__(name, sources=[])
+        self.sourcedir = os.fspath(Path(sourcedir).resolve())
+
+
+class CMakeBuild(build_ext):
+    def build_extension(self, ext: CMakeExtension) -> None:
+        # Must be in this form due to bug in .resolve() only fixed in Python 3.10+
+        ext_fullpath = Path.cwd() / self.get_ext_fullpath(ext.name)  # type: ignore[no-untyped-call]
+        extdir = ext_fullpath.parent.resolve()
+
+        debug = int(os.environ.get("DEBUG", 0)) if self.debug is None else self.debug
+        cfg = "Debug" if debug else "Release"
+
+        build_temp = Path(self.build_temp) / ext.name
+        if not build_temp.exists():
+            build_temp.mkdir(parents=True)
+
+        build_python = "ON"
+        install_prefix = f"{extdir}{os.sep}"
+        if build_stage == 1:
+            # Don't include MLX libraries in the wheel
+            install_prefix = f"{build_temp}"
+        elif build_stage == 2:
+            # Don't include Python bindings in the wheel
+            build_python = "OFF"
+        cmake_args = [
+            f"-DCMAKE_INSTALL_PREFIX={install_prefix}",
+            f"-DCMAKE_BUILD_TYPE={cfg}",
+            f"-DMLX_BUILD_PYTHON_BINDINGS={build_python}",
+            "-DMLX_BUILD_TESTS=OFF",
+            "-DMLX_BUILD_BENCHMARKS=OFF",
+            "-DMLX_BUILD_EXAMPLES=OFF",
+            f"-DMLX_PYTHON_BINDINGS_OUTPUT_DIRECTORY={extdir}{os.sep}",
+        ]
+        if build_stage == 2 and build_cuda:
+            # Last arch is always real and virtual for forward-compatibility
+            cuda_archs = ";".join(("70-real", "80-real", "90-real", "100-real", "120"))
+            cmake_args += [f"-DMLX_CUDA_ARCHITECTURES={cuda_archs}"]
+
+        # Some generators require explcitly passing config when building.
+        build_args = ["--config", cfg]
+        # Adding CMake arguments set as environment variable
+        # (needed e.g. to build for ARM OSx on conda-forge)
+        if "CMAKE_ARGS" in os.environ:
+            cmake_args += [item for item in os.environ["CMAKE_ARGS"].split(" ") if item]
+
+        # Pass version to C++
+        cmake_args += [f"-DMLX_VERSION={self.distribution.get_version()}"]  # type: ignore[attr-defined]
+
+        if build_macos:
+            # Cross-compile support for macOS - respect ARCHFLAGS if set
+            archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", ""))
+            if archs:
+                cmake_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs))]
+        if platform.system() == "Windows":
+            # On Windows DLLs must be put in the same dir with the extension
+            # while cmake puts mlx.dll into the "bin" sub-dir. Link with mlx
+            # statically to work around it.
+            cmake_args += ["-DBUILD_SHARED_LIBS=OFF"]
+        else:
+            cmake_args += ["-DBUILD_SHARED_LIBS=ON"]
+
+        # Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level
+        # across all generators.
+        if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ:
+            build_args += [f"-j{os.cpu_count()}"]
+
+        # Avoid cache miss when building from temporary dirs.
+        os.environ["CCACHE_BASEDIR"] = os.path.realpath(self.build_temp)
+        os.environ["CCACHE_NOHASHDIR"] = "true"
+
+        subprocess.run(
+            ["cmake", ext.sourcedir, *cmake_args], cwd=build_temp, check=True
+        )
+        subprocess.run(
+            ["cmake", "--build", ".", "--target", "install", *build_args],
+            cwd=build_temp,
+            check=True,
+        )
+
+    # Make sure to copy mlx.metallib for inplace builds
+    def run(self):
+        super().run()
+
+        # Based on https://github.com/pypa/setuptools/blob/main/setuptools/command/build_ext.py#L102
+        if self.inplace:
+            for ext in self.extensions:
+                if ext.name == "mlx.core":
+                    # Resolve inplace package dir
+                    build_py = self.get_finalized_command("build_py")
+                    inplace_file, regular_file = self._get_inplace_equivalent(
+                        build_py, ext
+                    )
+
+                    inplace_dir = str(Path(inplace_file).parent.resolve())
+                    regular_dir = str(Path(regular_file).parent.resolve())
+
+                    self.copy_tree(regular_dir, inplace_dir)
+
+
+class GenerateStubs(Command):
+    user_options = []
+
+    def initialize_options(self):
+        pass
+
+    def finalize_options(self):
+        pass
+
+    def run(self) -> None:
+        out_path = "python/mlx/core"
+        stub_cmd = [
+            "python",
+            "-m",
+            "nanobind.stubgen",
+            "-m",
+            "mlx.core",
+            "-p",
+            "python/mlx/_stub_patterns.txt",
+        ]
+        subprocess.run(stub_cmd + ["-r", "-O", out_path])
+        # Run again without recursive to specify output file name
+        subprocess.run(["rm", f"{out_path}/mlx.pyi"])
+        subprocess.run(stub_cmd + ["-o", f"{out_path}/__init__.pyi"])
+
+
+class MLXBdistWheel(bdist_wheel):
+    def get_tag(self) -> tuple[str, str, str]:
+        impl, abi, plat_name = super().get_tag()
+        if build_stage == 2:
+            impl = self.python_tag
+            abi = "none"
+        return (impl, abi, plat_name)
+
+
+# Read the content of README.md
+with open(Path(__file__).parent / "README.md", encoding="utf-8") as f:
+    long_description = f.read()
+
+
+if __name__ == "__main__":
+    package_dir = {"": "python"}
+    packages = find_namespace_packages(
+        where="python",
+        exclude=[
+            "src",
+            "tests",
+            "scripts",
+            "mlx.lib",
+            "mlx.include",
+            "mlx.share",
+            "mlx.share.**",
+            "mlx.include.**",
+        ],
+    )
+
+    version = get_version()
+
+    _setup = partial(
+        setup,
+        version=version,
+        author="MLX Contributors",
+        author_email="mlx@group.apple.com",
+        description="A framework for machine learning on Apple silicon.",
+        long_description=long_description,
+        long_description_content_type="text/markdown",
+        license="MIT",
+        url="https://github.com/ml-explore/mlx",
+        include_package_data=True,
+        package_dir=package_dir,
+        zip_safe=False,
+        python_requires=">=3.9",
+        ext_modules=[CMakeExtension("mlx.core")],
+        cmdclass={
+            "build_ext": CMakeBuild,
+            "generate_stubs": GenerateStubs,
+            "bdist_wheel": MLXBdistWheel,
+        },
+    )
+
+    package_data = {"mlx.core": ["*.pyi"]}
+
+    extras = {
+        "dev": [
+            "nanobind==2.4.0",
+            "numpy",
+            "pre-commit",
+            "setuptools>=80",
+            "torch",
+            "typing_extensions",
+        ],
+    }
+    entry_points = {
+        "console_scripts": [
+            "mlx.launch = mlx.distributed_run:main",
+            "mlx.distributed_config = mlx.distributed_run:distributed_config",
+        ]
+    }
+    install_requires = []
+
+    # Release builds for PyPi are in two stages.
+    # Each stage should be run from a clean build:
+    #   python setup.py clean --all
+    #
+    # Stage 1:
+    #  - Triggered with `MLX_BUILD_STAGE=1`
+    #  - Include everything except backend-specific binaries (e.g. libmlx.so, mlx.metallib, etc)
+    #  - Wheel has Python ABI and platform tags
+    #  - Wheel should be built for the cross-product of python version and platforms
+    #  - Package name is mlx and it depends on subpackage in stage 2 (e.g. mlx-metal)
+    # Stage 2:
+    #  - Triggered with `MLX_BUILD_STAGE=2`
+    #  - Includes only backend-specific binaries (e.g. libmlx.so, mlx.metallib, etc)
+    #  - Wheel has only platform tags
+    #  - Wheel should be built only for different platforms
+    #  - Package name is back-end specific, e.g mlx-metal
+    if build_stage != 2:
+        if build_stage == 1:
+            install_requires.append(
+                f'mlx-metal=={version}; platform_system == "Darwin"'
+            )
+            extras["cuda"] = [f'mlx-cuda=={version}; platform_system == "Linux"']
+            extras["cpu"] = [f'mlx-cpu=={version}; platform_system == "Linux"']
+
+        _setup(
+            name="mlx",
+            packages=packages,
+            extras_require=extras,
+            entry_points=entry_points,
+            install_requires=install_requires,
+            package_data=package_data,
+        )
+    else:
+        if build_macos:
+            name = "mlx-metal"
+        elif build_cuda:
+            name = "mlx-cuda"
+            install_requires += [
+                "nvidia-cublas-cu12==12.9.*",
+                "nvidia-cuda-nvrtc-cu12==12.9.*",
+                "nvidia-cudnn-cu12==9.*",
+                "nvidia-nccl-cu12",
+            ]
+        else:
+            name = "mlx-cpu"
+        _setup(
+            name=name,
+            packages=["mlx"],
+            install_requires=install_requires,
+        )
diff --git a/ml-stable-diffusion/mlx/tests/CMakeLists.txt b/ml-stable-diffusion/mlx/tests/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9e977d628117c9bb02af9de24069b92d9de61404
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/CMakeLists.txt
@@ -0,0 +1,49 @@
+FetchContent_Declare(
+  doctest
+  GIT_REPOSITORY https://github.com/onqtam/doctest.git
+  GIT_TAG v2.4.12)
+FetchContent_MakeAvailable(doctest)
+
+add_executable(tests ${PROJECT_SOURCE_DIR}/tests/tests.cpp)
+
+if(MLX_BUILD_METAL OR MLX_BUILD_CUDA)
+  set(METAL_TEST_SOURCES gpu_tests.cpp)
+endif()
+
+include(${doctest_SOURCE_DIR}/scripts/cmake/doctest.cmake)
+
+target_sources(
+  tests
+  PRIVATE allocator_tests.cpp
+          array_tests.cpp
+          arg_reduce_tests.cpp
+          autograd_tests.cpp
+          blas_tests.cpp
+          compile_tests.cpp
+          custom_vjp_tests.cpp
+          creations_tests.cpp
+          device_tests.cpp
+          einsum_tests.cpp
+          export_import_tests.cpp
+          eval_tests.cpp
+          fft_tests.cpp
+          load_tests.cpp
+          ops_tests.cpp
+          random_tests.cpp
+          scheduler_tests.cpp
+          utils_tests.cpp
+          vmap_tests.cpp
+          linalg_tests.cpp
+          ${METAL_TEST_SOURCES})
+
+if(MLX_BUILD_CUDA)
+  # Find the CCCL headers in install dir.
+  target_compile_definitions(
+    mlx
+    PRIVATE
+      MLX_CCCL_DIR="${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/cccl")
+endif()
+
+target_link_libraries(tests PRIVATE mlx doctest)
+doctest_discover_tests(tests)
+add_test(NAME tests COMMAND tests)
diff --git a/ml-stable-diffusion/mlx/tests/allocator_tests.cpp b/ml-stable-diffusion/mlx/tests/allocator_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..db155d23e1836851d2852ae38cf98026c90af2c6
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/allocator_tests.cpp
@@ -0,0 +1,41 @@
+// Copyright © 2023 Apple Inc.
+
+#include <stdexcept>
+
+#include "doctest/doctest.h"
+
+#include "mlx/allocator.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test simple allocations") {
+  {
+    auto buffer = allocator::malloc(sizeof(float));
+    auto fptr = static_cast<float*>(buffer.raw_ptr());
+    *fptr = 0.5f;
+    CHECK_EQ(*fptr, 0.5f);
+    allocator::free(buffer);
+  }
+
+  {
+    auto buffer = allocator::malloc(128 * sizeof(int));
+    int* ptr = static_cast<int*>(buffer.raw_ptr());
+    for (int i = 0; i < 128; ++i) {
+      ptr[i] = i;
+    }
+    allocator::free(buffer);
+  }
+
+  {
+    auto buffer = allocator::malloc(0);
+    allocator::free(buffer);
+  }
+}
+
+TEST_CASE("test large allocations") {
+  size_t size = 1 << 30;
+  for (int i = 0; i < 100; ++i) {
+    auto buffer = allocator::malloc(size);
+    allocator::free(buffer);
+  }
+}
diff --git a/ml-stable-diffusion/mlx/tests/arg_reduce_tests.cpp b/ml-stable-diffusion/mlx/tests/arg_reduce_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..124fd67edecd61bf5401a7d9fed2bcacf2b1b2f2
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/arg_reduce_tests.cpp
@@ -0,0 +1,204 @@
+// Copyright © 2023 Apple Inc.
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+#include "mlx/primitives.h"
+
+using namespace mlx::core;
+
+void test_arg_reduce_small(
+    Device d,
+    const array& x,
+    ArgReduce::ReduceType r,
+    Shape out_shape,
+    int axis,
+    std::vector<int> expected_output) {
+  auto s = default_stream(d);
+  auto y =
+      array(out_shape, uint32, std::make_shared<ArgReduce>(s, r, axis), {x});
+  y.eval();
+  const uint32_t* ydata = y.data<uint32_t>();
+  for (int i = 0; i < y.size(); i++) {
+    CHECK_EQ(expected_output[i], ydata[i]);
+  }
+}
+
+void test_arg_reduce_against_cpu(
+    const array& x,
+    ArgReduce::ReduceType r,
+    Shape out_shape,
+    int axis) {
+  auto y1 = array(
+      out_shape,
+      uint32,
+      std::make_shared<ArgReduce>(default_stream(Device::cpu), r, axis),
+      {x});
+  auto y2 = array(
+      out_shape,
+      uint32,
+      std::make_shared<ArgReduce>(default_stream(Device::gpu), r, axis),
+      {x});
+  y1.eval();
+  y2.eval();
+  CHECK(array_equal(y1, y2).item<bool>());
+}
+
+TEST_CASE("test arg reduce small") {
+  auto x = array(
+      {0, 2, 1, 7, 5, -5, 0, 2, 1, 7, 5, -5,
+       0, 2, 1, 7, 5, -5, 0, 2, 1, 7, 5, -5},
+      {2, 3, 4});
+  test_arg_reduce_small(
+      Device::cpu, x, ArgReduce::ArgMin, {2, 3}, 2, {0, 1, 3, 0, 1, 3});
+  test_arg_reduce_small(
+      Device::cpu, x, ArgReduce::ArgMin, {2, 4}, 1, {0, 1, 1, 2, 0, 1, 1, 2});
+  test_arg_reduce_small(
+      Device::cpu,
+      x,
+      ArgReduce::ArgMin,
+      {3, 4},
+      0,
+      {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
+  test_arg_reduce_small(
+      Device::cpu, x, ArgReduce::ArgMax, {2, 3}, 2, {3, 0, 1, 3, 0, 1});
+  test_arg_reduce_small(
+      Device::cpu, x, ArgReduce::ArgMax, {2, 4}, 1, {1, 2, 2, 0, 1, 2, 2, 0});
+  test_arg_reduce_small(
+      Device::cpu,
+      x,
+      ArgReduce::ArgMax,
+      {3, 4},
+      0,
+      {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
+
+  if (!metal::is_available()) {
+    INFO("Skipping arg reduction gpu tests");
+    return;
+  }
+
+  test_arg_reduce_small(
+      Device::gpu, x, ArgReduce::ArgMin, {2, 3}, 2, {0, 1, 3, 0, 1, 3});
+  test_arg_reduce_small(
+      Device::gpu, x, ArgReduce::ArgMin, {2, 4}, 1, {0, 1, 1, 2, 0, 1, 1, 2});
+  test_arg_reduce_small(
+      Device::gpu,
+      x,
+      ArgReduce::ArgMin,
+      {3, 4},
+      0,
+      {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
+  test_arg_reduce_small(
+      Device::gpu, x, ArgReduce::ArgMax, {2, 3}, 2, {3, 0, 1, 3, 0, 1});
+  test_arg_reduce_small(
+      Device::gpu, x, ArgReduce::ArgMax, {2, 4}, 1, {1, 2, 2, 0, 1, 2, 2, 0});
+  test_arg_reduce_small(
+      Device::gpu,
+      x,
+      ArgReduce::ArgMax,
+      {3, 4},
+      0,
+      {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
+}
+
+TEST_CASE("test arg reduce against cpu") {
+  if (!metal::is_available()) {
+    INFO("Skipping arg reduction gpu tests");
+    return;
+  }
+
+  auto x = random::uniform(array(0.0), array(1.0), {127, 92, 55});
+  x.eval();
+  test_arg_reduce_against_cpu(x, ArgReduce::ArgMin, {127, 92}, 2);
+  test_arg_reduce_against_cpu(x, ArgReduce::ArgMin, {127, 55}, 1);
+  test_arg_reduce_against_cpu(x, ArgReduce::ArgMin, {92, 55}, 0);
+  test_arg_reduce_against_cpu(x, ArgReduce::ArgMax, {127, 92}, 2);
+  test_arg_reduce_against_cpu(x, ArgReduce::ArgMax, {127, 55}, 1);
+  test_arg_reduce_against_cpu(x, ArgReduce::ArgMax, {92, 55}, 0);
+
+  auto y = random::uniform(array(0.0), array(1.0), {1234});
+  y.eval();
+  test_arg_reduce_against_cpu(y, ArgReduce::ArgMin, {}, 0);
+  test_arg_reduce_against_cpu(y, ArgReduce::ArgMax, {}, 0);
+}
+
+void test_arg_reduce_small_bool(
+    Device d,
+    ArgReduce::ReduceType r,
+    Shape out_shape,
+    int axis,
+    std::vector<int> expected_output) {
+  auto s = default_stream(d);
+  auto x = array(
+      {0, 2, 1, 7, 5, -5, 0, 2, 1, 7, 5, -5,
+       0, 2, 1, 7, 5, -5, 0, 2, 1, 7, 5, -5},
+      {2, 3, 4});
+  x.eval();
+  auto y =
+      array(out_shape, uint32, std::make_shared<ArgReduce>(s, r, axis), {x});
+  y.eval();
+  const uint32_t* ydata = y.data<uint32_t>();
+  for (int i = 0; i < y.size(); i++) {
+    CHECK_EQ(expected_output[i], ydata[i]);
+  }
+}
+
+TEST_CASE("test arg reduce bool") {
+  if (!metal::is_available()) {
+    INFO("Skipping arg reduction gpu tests");
+    return;
+  }
+  auto x = array(
+      {false, true,  true,  false, false, false, false, true,
+       true,  false, true,  true,  false, true,  true,  false,
+       false, false, false, true,  true,  false, true,  true},
+      {2, 3, 4});
+  x.eval();
+  test_arg_reduce_small(
+      Device::gpu, x, ArgReduce::ArgMin, {2, 3}, 2, {0, 0, 1, 0, 0, 1});
+  test_arg_reduce_small(
+      Device::gpu, x, ArgReduce::ArgMin, {2, 4}, 1, {0, 1, 1, 0, 0, 1, 1, 0});
+  test_arg_reduce_small(
+      Device::gpu,
+      x,
+      ArgReduce::ArgMin,
+      {3, 4},
+      0,
+      {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
+  test_arg_reduce_small(
+      Device::gpu, x, ArgReduce::ArgMax, {2, 3}, 2, {1, 3, 0, 1, 3, 0});
+  test_arg_reduce_small(
+      Device::gpu, x, ArgReduce::ArgMax, {2, 4}, 1, {2, 0, 0, 1, 2, 0, 0, 1});
+  test_arg_reduce_small(
+      Device::gpu,
+      x,
+      ArgReduce::ArgMax,
+      {3, 4},
+      0,
+      {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
+}
+
+TEST_CASE("test arg reduce edge cases") {
+  auto a = argmin(array(1.0));
+  CHECK_EQ(a.item<uint32_t>(), 0);
+  auto b = argmax(array(1.0));
+  CHECK_EQ(b.item<uint32_t>(), 0);
+  CHECK_THROWS(argmin(array({})));
+  CHECK_THROWS(argmax(array({})));
+}
+
+TEST_CASE("test arg reduce irregular strides") {
+  auto x = array(
+      {0, 2, 1, 7, 5, -5, 0, 2, 1, 7, 5, -5,
+       0, 2, 1, 7, 5, -5, 0, 2, 1, 7, 5, -5},
+      {2, 3, 4});
+  x = transpose(x, {2, 0, 1});
+  x.eval();
+  test_arg_reduce_small(
+      Device::cpu, x, ArgReduce::ArgMin, {4, 2}, 2, {0, 0, 1, 1, 1, 1, 2, 2});
+
+  if (!metal::is_available()) {
+    INFO("Skipping arg reduction gpu tests");
+    return;
+  }
+}
diff --git a/ml-stable-diffusion/mlx/tests/array_tests.cpp b/ml-stable-diffusion/mlx/tests/array_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b31da98994c72d44cb4e0bc1af9466d78d10b1f8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/array_tests.cpp
@@ -0,0 +1,610 @@
+// Copyright © 2023 Apple Inc.
+
+#include <climits>
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test array basics") {
+  // Scalar
+  array x(1.0);
+  CHECK_EQ(x.size(), 1);
+  CHECK_EQ(x.ndim(), 0);
+  CHECK_EQ(x.shape(), Shape{});
+  CHECK_THROWS_AS(x.shape(0), std::out_of_range);
+  CHECK_THROWS_AS(x.shape(-1), std::out_of_range);
+  CHECK_EQ(x.strides(), Strides{});
+  CHECK_EQ(x.itemsize(), sizeof(float));
+  CHECK_EQ(x.nbytes(), sizeof(float));
+  CHECK_EQ(x.dtype(), float32);
+  CHECK_EQ(x.item<float>(), 1.0);
+
+  // Scalar with specified type
+  x = array(1, float32);
+  CHECK_EQ(x.dtype(), float32);
+  CHECK_EQ(x.item<float>(), 1.0);
+
+  // Scalar with specified type
+  x = array(1, bool_);
+  CHECK_EQ(x.dtype(), bool_);
+  CHECK_EQ(x.itemsize(), sizeof(bool));
+  CHECK_EQ(x.nbytes(), sizeof(bool));
+  CHECK_EQ(x.item<bool>(), true);
+
+  // Check shaped arrays
+  x = array({1.0});
+  CHECK_EQ(x.dtype(), float32);
+  CHECK_EQ(x.size(), 1);
+  CHECK_EQ(x.ndim(), 1);
+  CHECK_EQ(x.shape(), Shape{1});
+  CHECK_EQ(x.shape(0), 1);
+  CHECK_EQ(x.shape(-1), 1);
+  CHECK_THROWS_AS(x.shape(1), std::out_of_range);
+  CHECK_THROWS_AS(x.shape(-2), std::out_of_range);
+  CHECK_EQ(x.strides(), Strides{1});
+  CHECK_EQ(x.item<float>(), 1.0);
+
+  // Check empty array
+  x = array({});
+  CHECK_EQ(x.size(), 0);
+  CHECK_EQ(x.dtype(), float32);
+  CHECK_EQ(x.itemsize(), sizeof(float));
+  CHECK_EQ(x.nbytes(), 0);
+  CHECK_THROWS_AS(x.item<float>(), std::invalid_argument);
+
+  x = array({1.0, 1.0});
+  CHECK_EQ(x.size(), 2);
+  CHECK_EQ(x.shape(), Shape{2});
+  CHECK_EQ(x.itemsize(), sizeof(float));
+  CHECK_EQ(x.nbytes(), x.itemsize() * x.size());
+
+  // Accessing item in non-scalar array throws
+  CHECK_THROWS_AS(x.item<float>(), std::invalid_argument);
+
+  x = array({1.0, 1.0, 1.0}, {1, 3});
+  CHECK_EQ(x.size(), 3);
+  CHECK_EQ(x.shape(), Shape{1, 3});
+  CHECK_EQ(x.strides(), Strides{3, 1});
+
+  // Test wrong size/shapes throw:
+  CHECK_THROWS_AS(array({1.0, 1.0, 1.0}, {4}), std::invalid_argument);
+  CHECK_THROWS_AS(array({1.0, 1.0, 1.0}, {1, 4}), std::invalid_argument);
+  CHECK_THROWS_AS(array({1.0, 1.0, 1.0}, {1, 2}), std::invalid_argument);
+
+  // Test array ids work as expected
+  x = array(1.0);
+  auto y = x;
+  CHECK_EQ(y.id(), x.id());
+  array z(2.0);
+  CHECK_NE(z.id(), x.id());
+  z = x;
+  CHECK_EQ(z.id(), x.id());
+
+  // Array creation from pointer
+  float data[] = {0.0, 1.0, 2.0, 3.0};
+  x = array(data, {4});
+  CHECK_EQ(x.dtype(), float32);
+  CHECK(array_equal(x, array({0.0, 1.0, 2.0, 3.0})).item<bool>());
+
+  // Array creation from vectors
+  {
+    std::vector<int> data = {0, 1, 2, 3};
+    x = array(data.begin(), {4});
+    CHECK_EQ(x.dtype(), int32);
+    CHECK(array_equal(x, array({0, 1, 2, 3})).item<bool>());
+  }
+
+  {
+    std::vector<bool> data = {false, true, false, true};
+    x = array(data.begin(), {4});
+    CHECK_EQ(x.dtype(), bool_);
+    CHECK(array_equal(x, array({false, true, false, true})).item<bool>());
+  }
+}
+
+TEST_CASE("test array types") {
+#define basic_dtype_test(T, mlx_type) \
+  T val = 42;                         \
+  array x(val);                       \
+  CHECK_EQ(x.dtype(), mlx_type);      \
+  CHECK_EQ(x.item<T>(), val);         \
+  x = array({val, val});              \
+  CHECK_EQ(x.dtype(), mlx_type);
+
+  // bool_
+  {
+    array x(true);
+    CHECK_EQ(x.dtype(), bool_);
+    CHECK_EQ(x.item<bool>(), true);
+
+    x = array({true, false});
+    CHECK_EQ(x.dtype(), bool_);
+
+    x = array({true, false}, float32);
+    CHECK_EQ(x.dtype(), float32);
+    CHECK(array_equal(x, array({1.0f, 0.0f})).item<bool>());
+  }
+
+  // uint8
+  {
+    basic_dtype_test(uint8_t, uint8);
+  }
+
+  // uint16
+  {
+    basic_dtype_test(uint16_t, uint16);
+  }
+
+  // uint32
+  {
+    basic_dtype_test(uint32_t, uint32);
+  }
+
+  // uint64
+  {
+    basic_dtype_test(uint64_t, uint64);
+  }
+
+  // int8
+  {
+    basic_dtype_test(int8_t, int8);
+  }
+
+  // int16
+  {
+    basic_dtype_test(int16_t, int16);
+  }
+
+  // int32
+  {
+    basic_dtype_test(int32_t, int32);
+  }
+
+  // int64
+  {
+    basic_dtype_test(int64_t, int64);
+  }
+
+  // float16
+  {
+    basic_dtype_test(float16_t, float16);
+  }
+
+  // float32
+  {
+    basic_dtype_test(float, float32);
+  }
+
+  // bfloat16
+  {
+    basic_dtype_test(bfloat16_t, bfloat16);
+  }
+
+#undef basic_dtype_test
+
+  // uint32
+  {
+    uint32_t val = UINT_MAX;
+    array x(val);
+    CHECK_EQ(x.dtype(), uint32);
+    CHECK_EQ(x.item<uint32_t>(), val);
+
+    x = array({1u, 2u});
+    CHECK_EQ(x.dtype(), uint32);
+  }
+
+  // int32
+  {
+    array x(-1);
+    CHECK_EQ(x.dtype(), int32);
+    CHECK_EQ(x.item<int>(), -1);
+
+    x = array({-1, 2});
+    CHECK_EQ(x.dtype(), int32);
+
+    std::vector<int> data{0, 1, 2};
+    x = array(data.data(), {static_cast<int>(data.size())}, bool_);
+    CHECK_EQ(x.dtype(), bool_);
+    CHECK(array_equal(x, array({false, true, true})).item<bool>());
+  }
+
+  // int64
+  {
+    int64_t val = static_cast<int64_t>(INT_MIN) - 1;
+    array x(val);
+    CHECK_EQ(x.dtype(), int64);
+    CHECK_EQ(x.item<int64_t>(), val);
+
+    x = array({val, val});
+    CHECK_EQ(x.dtype(), int64);
+  }
+
+  // float32
+  {
+    array x(3.14f);
+    CHECK_EQ(x.dtype(), float32);
+    CHECK_EQ(x.item<float>(), 3.14f);
+
+    x = array(1.25);
+    CHECK_EQ(x.dtype(), float32);
+    CHECK_EQ(x.item<float>(), 1.25f);
+
+    x = array({1.0f, 2.0f});
+    CHECK_EQ(x.dtype(), float32);
+
+    x = array({1.0, 2.0});
+    CHECK_EQ(x.dtype(), float32);
+
+    std::vector<double> data{1.0, 2.0, 4.0};
+    x = array(data.data(), {static_cast<int>(data.size())});
+    CHECK_EQ(x.dtype(), float32);
+    CHECK(array_equal(x, array({1.0f, 2.0f, 4.0f})).item<bool>());
+  }
+
+  // complex64
+  {
+    CHECK_EQ(sizeof(complex64_t), sizeof(std::complex<float>));
+
+    complex64_t v = {1.0f, 1.0f};
+    array x(v);
+    CHECK_EQ(x.dtype(), complex64);
+    CHECK_EQ(x.item<complex64_t>(), v);
+
+    array y(std::complex<float>{1.0f, 1.0f});
+    CHECK_EQ(x.dtype(), complex64);
+    CHECK_EQ(x.item<complex64_t>(), v);
+  }
+}
+
+TEST_CASE("test array metadata") {
+  array x(1.0f);
+  CHECK_EQ(x.data_size(), 1);
+  CHECK_EQ(x.flags().contiguous, true);
+  CHECK_EQ(x.flags().row_contiguous, true);
+  CHECK_EQ(x.flags().col_contiguous, true);
+
+  x = array({1.0f}, {1, 1, 1});
+  CHECK_EQ(x.data_size(), 1);
+  CHECK_EQ(x.flags().contiguous, true);
+  CHECK_EQ(x.flags().row_contiguous, true);
+  CHECK_EQ(x.flags().col_contiguous, true);
+
+  x = array({1.0f, 1.0f}, {1, 2});
+  CHECK_EQ(x.data_size(), 2);
+  CHECK_EQ(x.flags().contiguous, true);
+  CHECK_EQ(x.flags().row_contiguous, true);
+  CHECK_EQ(x.flags().col_contiguous, true);
+
+  x = zeros({1, 1, 4});
+  eval(x);
+  CHECK_EQ(x.data_size(), 4);
+  CHECK_EQ(x.flags().contiguous, true);
+  CHECK_EQ(x.flags().row_contiguous, true);
+  CHECK_EQ(x.flags().col_contiguous, true);
+
+  x = zeros({2, 4});
+  eval(x);
+  CHECK_EQ(x.data_size(), 8);
+  CHECK_EQ(x.flags().contiguous, true);
+  CHECK_EQ(x.flags().row_contiguous, true);
+  CHECK_EQ(x.flags().col_contiguous, false);
+
+  x = array(1.0f);
+  auto y = broadcast_to(x, {1, 1, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 1);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  y = broadcast_to(x, {2, 8, 10});
+  eval(y);
+  CHECK_EQ(y.data_size(), 1);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, false);
+  CHECK_EQ(y.flags().col_contiguous, false);
+
+  y = broadcast_to(x, {1, 0});
+  eval(y);
+  CHECK_EQ(y.data_size(), 0);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  y = broadcast_to(zeros({4, 2, 1}), {4, 2, 0});
+  eval(y);
+  CHECK_EQ(y.data_size(), 0);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = array(1.0f);
+  y = transpose(x);
+  eval(y);
+  CHECK_EQ(y.data_size(), 1);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = ones({1, 1, 1});
+  y = transpose(x);
+  eval(y);
+  CHECK_EQ(y.data_size(), 1);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = ones({1, 1, 1});
+  y = transpose(x, {0, 1, 2});
+  eval(y);
+  CHECK_EQ(y.data_size(), 1);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = ones({1, 1, 1});
+  y = transpose(x, {1, 2, 0});
+  eval(y);
+  CHECK_EQ(y.data_size(), 1);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = ones({4, 1});
+  y = transpose(x);
+  eval(y);
+  CHECK_EQ(y.data_size(), 4);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = ones({2, 3, 4});
+  y = transpose(x);
+  eval(y);
+  CHECK_EQ(y.data_size(), 24);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, false);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  y = transpose(x, {0, 2, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 24);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, false);
+  CHECK_EQ(y.flags().col_contiguous, false);
+
+  y = transpose(transpose(x, {0, 2, 1}), {0, 2, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 24);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, false);
+
+  x = array(1.0f);
+  y = reshape(x, {1, 1, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 1);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = ones({2, 4});
+  y = reshape(x, {8});
+  eval(y);
+  CHECK_EQ(y.data_size(), 8);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  y = reshape(x, {8, 1, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 8);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  y = reshape(x, {1, 8, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 8);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = ones({12});
+  y = reshape(x, {2, 3, 2});
+  eval(y);
+  CHECK_EQ(y.data_size(), 12);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, false);
+
+  x = array(1.0f);
+  y = slice(x, {}, {});
+  eval(y);
+  CHECK_EQ(y.data_size(), 1);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = array({1.0f});
+  y = slice(x, {-10}, {10}, {10});
+  eval(y);
+  CHECK_EQ(y.data_size(), 1);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = array({1.0f, 2.0f, 3.0f}, {1, 3});
+  y = slice(x, {0, 0}, {1, 3}, {1, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 3);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = array({1.0f, 2.0f, 3.0f}, {1, 3});
+  y = slice(x, {0, 0}, {1, 3}, {1, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 3);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = array({1.0f, 2.0f, 3.0f}, {1, 3});
+  y = slice(x, {0, 0}, {0, 3}, {1, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 0);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = array({1.0f, 2.0f, 3.0f}, {1, 3});
+  y = slice(x, {0, 0}, {1, 2}, {1, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 2);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = array({1.0f, 2.0f, 3.0f}, {1, 3});
+  y = slice(x, {0, 0}, {1, 2}, {2, 3});
+  eval(y);
+  CHECK_EQ(y.shape(), Shape{1, 1});
+  CHECK_EQ(y.data_size(), 1);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = array({0.0f, 1.0f, 2.0f, 3.0f}, {1, 4});
+  y = slice(x, {0, 0}, {1, 4}, {1, 2});
+  eval(y);
+  CHECK_EQ(y.shape(), Shape{1, 2});
+  CHECK_EQ(y.flags().contiguous, false);
+  CHECK_EQ(y.flags().row_contiguous, false);
+  CHECK_EQ(y.flags().col_contiguous, false);
+
+  x = broadcast_to(array(1.0f), {4, 10});
+  y = slice(x, {0, 0}, {4, 10}, {2, 2});
+  eval(y);
+  CHECK_EQ(y.shape(), Shape{2, 5});
+  CHECK_EQ(y.data_size(), 1);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, false);
+  CHECK_EQ(y.flags().col_contiguous, false);
+
+  x = broadcast_to(array({1.0f, 2.0f}), {4, 2});
+  y = slice(x, {0, 0}, {1, 2}, {1, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 2);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  y = slice(x, {1, 0}, {2, 2}, {1, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 2);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = array({0.0f, 1.0f, 2.0f, 3.0f}, {2, 2});
+  y = slice(x, {0, 0}, {2, 2}, {1, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 4);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, true);
+  CHECK_EQ(y.flags().col_contiguous, false);
+
+  y = slice(transpose(x), {0, 0}, {2, 2}, {1, 1});
+  eval(y);
+  CHECK_EQ(y.data_size(), 4);
+  CHECK_EQ(y.flags().contiguous, true);
+  CHECK_EQ(y.flags().row_contiguous, false);
+  CHECK_EQ(y.flags().col_contiguous, true);
+
+  x = ones({2, 4});
+  auto out = split(x, 2);
+  eval(out);
+  for (auto y : out) {
+    CHECK_EQ(y.data_size(), 4);
+    CHECK_EQ(y.flags().contiguous, true);
+    CHECK_EQ(y.flags().row_contiguous, true);
+    CHECK_EQ(y.flags().col_contiguous, true);
+  }
+  out = split(x, 4, 1);
+  eval(out);
+  for (auto y : out) {
+    CHECK_EQ(y.flags().contiguous, false);
+    CHECK_EQ(y.flags().row_contiguous, false);
+    CHECK_EQ(y.flags().col_contiguous, false);
+  }
+}
+
+TEST_CASE("test array iteration") {
+  // Dim 0 arrays
+  auto arr = array(1);
+  CHECK_THROWS(arr.begin());
+
+  // Iterated arrays are read only
+  CHECK(std::is_const_v<decltype(*arr.begin())>);
+
+  arr = array({1, 2, 3, 4, 5});
+  int i = 0;
+  for (auto a : arr) {
+    i++;
+    CHECK_EQ(a.item<int>(), i);
+  }
+  CHECK_EQ(i, 5);
+
+  arr = array({1, 2, 3, 4}, {2, 2});
+  CHECK(array_equal(*arr.begin(), array({1, 2})).item<bool>());
+  CHECK(array_equal(*(arr.begin() + 1), array({3, 4})).item<bool>());
+  CHECK_EQ(arr.begin() + 2, arr.end());
+}
+
+TEST_CASE("test array shared buffer") {
+  Shape shape = {2, 2};
+  auto n_elem = shape[0] * shape[1];
+
+  allocator::Buffer buf_b = allocator::malloc(n_elem * sizeof(float));
+  void* buf_b_ptr = buf_b.raw_ptr();
+  float* float_buf_b = (float*)buf_b_ptr;
+
+  for (int i = 0; i < n_elem; i++) {
+    float_buf_b[i] = 2.;
+  }
+
+  CHECK_EQ(float_buf_b[0], ((float*)buf_b_ptr)[0]);
+
+  auto deleter = [float_buf_b](allocator::Buffer buf) {
+    CHECK_EQ(float_buf_b, (float*)buf.raw_ptr());
+    CHECK_EQ(float_buf_b[0], ((float*)buf.raw_ptr())[0]);
+    allocator::free(buf);
+  };
+
+  array a = ones(shape, float32);
+  array b = array(buf_b, shape, float32, deleter);
+
+  eval(a + b);
+}
+
+TEST_CASE("test make empty array") {
+  auto a = array({});
+  CHECK_EQ(a.size(), 0);
+  CHECK_EQ(a.dtype(), float32);
+
+  a = array({}, int32);
+  CHECK_EQ(a.size(), 0);
+  CHECK_EQ(a.dtype(), int32);
+
+  a = array({}, float32);
+  CHECK_EQ(a.size(), 0);
+  CHECK_EQ(a.dtype(), float32);
+
+  a = array({}, bool_);
+  CHECK_EQ(a.size(), 0);
+  CHECK_EQ(a.dtype(), bool_);
+}
diff --git a/ml-stable-diffusion/mlx/tests/autograd_tests.cpp b/ml-stable-diffusion/mlx/tests/autograd_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3a373fb18bbb0bdfabb2f1890db8a44725c29f06
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/autograd_tests.cpp
@@ -0,0 +1,1355 @@
+// Copyright © 2023 Apple Inc.
+
+// Required for using M_2_SQRTPI in MSVC.
+#define _USE_MATH_DEFINES
+
+#include <algorithm>
+#include <cmath>
+#include <numeric>
+#include <sstream>
+#include <vector>
+#include "doctest/doctest.h"
+
+#include "mlx/graph_utils.h"
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test stop gradient") {
+  auto x = zeros({5, 5});
+  auto y = stop_gradient(x);
+  CHECK(array_equal(y, zeros({5, 5})).item<bool>());
+
+  x = zeros({5, 5}, int32);
+  y = stop_gradient(x);
+  CHECK_EQ(y.dtype(), int32);
+  CHECK(array_equal(y, zeros({5, 5}, int32)).item<bool>());
+
+  {
+    auto fun = [](array input) { return stop_gradient(add(input, ones({2}))); };
+    auto vfun = vmap(fun);
+    auto out = vfun(ones({3, 2}));
+    CHECK(array_equal(out, full({3, 2}, 2.0)).item<bool>());
+  }
+
+  {
+    auto fun = [](array input) { return add(stop_gradient(input), ones({2})); };
+    auto vfun = vmap(fun);
+    auto out = vfun(ones({3, 2}));
+    CHECK(array_equal(out, full({3, 2}, 2.0)).item<bool>());
+  }
+
+  {
+    auto x = array(1.);
+    auto fun = [](array in) { return stop_gradient(add(in, in)); };
+    auto out = vjp(fun, x, array(1.)).second;
+    CHECK(array_equal(out, array(0.)).item<bool>());
+
+    out = jvp(fun, x, array(1.)).second;
+    CHECK(array_equal(out, array(0.)).item<bool>());
+  }
+
+  {
+    auto x = array(1.);
+    auto fun = [](array in) { return add(in, stop_gradient(in)); };
+    auto out = vjp(fun, x, array(1.)).second;
+    CHECK(array_equal(out, array(1.)).item<bool>());
+
+    out = jvp(fun, x, array(1.)).second;
+    CHECK(array_equal(out, array(1.)).item<bool>());
+  }
+
+  {
+    auto x = array(1.);
+    auto fun = [](array in) {
+      for (int i = 0; i < 10; ++i) {
+        in = add(in, in);
+      }
+      return stop_gradient(in);
+    };
+    {
+      auto out = vjp(fun, x, array(1.)).second;
+      std::ostringstream g_ss;
+      print_graph(g_ss, out);
+      auto g_str = g_ss.str();
+      auto count = std::count(g_str.begin(), g_str.end(), '\n');
+      CHECK(count < 5);
+    }
+    {
+      auto out = jvp(fun, x, array(1.)).second;
+      std::ostringstream g_ss;
+      print_graph(g_ss, out);
+      auto g_str = g_ss.str();
+      auto count = std::count(g_str.begin(), g_str.end(), '\n');
+      CHECK(count < 5);
+    }
+  }
+}
+
+TEST_CASE("test jvp") {
+  {
+    auto fun = [](const std::vector<array>& inputs) {
+      return std::vector<array>{add(inputs[0], inputs[1])};
+    };
+    auto x = array(1.0f);
+    auto y = array(1.0f);
+    auto [out, dout] = jvp(fun, {x, y}, {array(1.0f), array(3.0f)});
+    CHECK_EQ(out[0].item<float>(), 2.0f);
+    CHECK_EQ(dout[0].item<float>(), 4.0f);
+  }
+
+  // Evaling in function while tracing performs graph retention
+  {
+    auto fun1 = [](const array& x) {
+      auto y = 3 * x;
+      eval(y);
+      CHECK(y.is_available());
+      CHECK(y.has_primitive());
+      CHECK(y.is_tracer());
+      return 2 * y;
+    };
+    CHECK_EQ(jvp(fun1, array(1.0f), array(1.0f)).second.item<float>(), 6.0f);
+  }
+
+  // Only one argument
+  {
+    auto x = array(1.0f);
+    auto fun = [x](array in) { return add(x, in); };
+    auto y = array(1.0f);
+    auto out = jvp(fun, y, array(3.0f)).second;
+    CHECK_EQ(out.item<float>(), 3.0f);
+  }
+
+  // Input also in capture clause
+  {
+    auto x = array(1.0f);
+    auto fun = [x](array in) { return in + x; };
+    auto out = jvp(fun, x, array(1.0f)).second;
+    CHECK_EQ(out.item<float>(), 1.0f);
+  }
+
+  // Throws on incorrectly shaped inputs
+  {
+    auto fun = [](array in) { return add(in, in); };
+    CHECK_THROWS_AS(jvp(fun, array(1), array({1, 1})), std::invalid_argument);
+  }
+
+  // Throws on wrong number of inputs
+  {
+    auto fun = [](std::vector<array> inputs) {
+      return std::vector<array>{inputs[0], inputs[1]};
+    };
+    CHECK_THROWS_AS(
+        jvp(fun, {array(1), array(1)}, {array(1)}), std::invalid_argument);
+  }
+
+  // No dependence between input and output
+  {
+    auto fun = [](array in) { return array({1.0, 1.0}); };
+    auto out = jvp(fun, array(1.0f), array(1.0f)).second;
+    CHECK(array_equal(out, zeros({2})).item<bool>());
+  }
+}
+
+TEST_CASE("test vjp") {
+  {
+    auto x = array(1.0f);
+    auto y = array(1.0f);
+    auto fun = [y](array in) { return add(in, y); };
+    auto [out, dout] = vjp(fun, x, array(1.0f));
+    CHECK_EQ(out.item<float>(), 2.0f);
+    CHECK_EQ(dout.item<float>(), 1.0f);
+  }
+
+  {
+    auto x = array(1.0f);
+    auto fun = [](array in) { return in + in + in; };
+    auto out = vjp(fun, x, array(1.0f)).second;
+    CHECK_EQ(out.item<float>(), 3.0f);
+    out = vjp(fun, x, array(2.)).second;
+    CHECK_EQ(out.item<float>(), 6.0f);
+  }
+
+  // Input also in capture clause
+  {
+    auto x = array(1.0f);
+    auto fun = [x](array in) { return in + x; };
+    auto out = vjp(fun, x, array(1.0f)).second;
+    CHECK_EQ(out.item<float>(), 1.0f);
+  }
+
+  // Throws on incorrectly shaped outputs
+  {
+    auto fun = [](array in) { return add(in, in); };
+    CHECK_THROWS_AS(vjp(fun, zeros({1}), zeros({2})), std::invalid_argument);
+  }
+
+  // Throws on wrong number of outputs
+  {
+    auto fun = [](std::vector<array> inputs) {
+      return std::vector<array>{inputs[0], inputs[0]};
+    };
+    CHECK_THROWS_AS(
+        vjp(fun, {zeros({1})}, {zeros({2})}), std::invalid_argument);
+  }
+
+  // No dependence between input and output
+  {
+    auto fun = [](array in) { return array(1.); };
+    auto out = vjp(fun, zeros({2}), array(1.)).second;
+    CHECK(array_equal(out, zeros({2})).item<bool>());
+  }
+
+  // Handles multiple outputs
+  {
+    auto x = array(1.);
+    auto y = array(2.);
+    auto z = array(3.);
+    auto fun = [](const std::vector<array>& in) {
+      return std::vector<array>{in[0] * in[1], in[1] * in[2]};
+    };
+    auto out = vjp(fun, {x, y, z}, {array(2.), array(3.)}).second;
+    CHECK_EQ(out.size(), 3);
+    CHECK_EQ(out[0].item<float>(), 2.0f * 2.0f);
+    CHECK_EQ(out[1].item<float>(), 1.0f * 2.0f + 3.0f * 3.0f);
+    CHECK_EQ(out[2].item<float>(), 3.0f * 2.0f);
+  }
+}
+
+TEST_CASE("test grad") {
+  {
+    auto x = array(1.0);
+    auto fun = [](array in) { return in + 1; };
+    auto [y, dfdx] = value_and_grad(fun)(x);
+    CHECK_EQ(y.item<float>(), 2.0f);
+    CHECK_EQ(dfdx.item<float>(), 1.0f);
+    auto [z, d2fdx2] = value_and_grad(grad(fun))(x);
+    CHECK_EQ(z.item<float>(), 1.0f);
+    CHECK_EQ(d2fdx2.item<float>(), 0.0f);
+  }
+
+  {
+    auto x = array(1.);
+    auto fun = [](array in) { return add(in, array(1.)); };
+    auto dfdx = grad(fun);
+    CHECK(array_equal(dfdx(x), array(1.)).item<bool>());
+    auto d2fdx2 = grad(grad(fun));
+    CHECK(array_equal(d2fdx2(x), array(0.)).item<bool>());
+  }
+
+  {
+    auto x = array(1.);
+    auto expfn = [](array input) { return exp(input); };
+    auto dfdx = grad(expfn);
+    CHECK_EQ(dfdx(x).item<float>(), doctest::Approx(std::exp(1.0f)));
+    auto d2fdx2 = grad(grad(expfn));
+    CHECK_EQ(d2fdx2(x).item<float>(), doctest::Approx(std::exp(1.0f)));
+    auto d3fdx3 = grad(grad(grad(expfn)));
+    CHECK_EQ(d3fdx3(x).item<float>(), doctest::Approx(std::exp(1.0f)));
+  }
+
+  {
+    // No graph retention since the output is independent of y
+    auto y = ones({3, 3});
+    auto fn1 = [y](array x) {
+      x = x + 2.0f;
+      eval(y);
+      CHECK(x.is_tracer());
+      CHECK(!y.is_tracer());
+      CHECK(y.is_available());
+      CHECK(!y.has_primitive());
+      return square(x);
+    };
+    auto dfdx = grad(fn1)(array(1.0f));
+    CHECK_EQ(dfdx.item<float>(), 6.0f);
+
+    // Graph automatically retained to compute the grad
+    auto fn2 = [](array x) {
+      x = x + 2.0f;
+      eval(x);
+      CHECK(x.is_tracer());
+      CHECK(x.is_available());
+      CHECK(x.has_primitive());
+      return square(x);
+    };
+    dfdx = grad(fn2)(array(1.0f));
+    CHECK_EQ(dfdx.item<float>(), 6.0f);
+  }
+
+  // Control flow in grad computation
+  {
+    auto fn = [](array x) {
+      x = x + array(2.0f);
+      if (x.item<float>() > 3) {
+        return square(x);
+      } else {
+        return 4 * x;
+      }
+    };
+
+    auto dfdx = grad(fn)(array(0.5f));
+    CHECK_EQ(dfdx.item<float>(), 4.0f);
+
+    dfdx = grad(fn)(array(1.5f));
+    CHECK_EQ(dfdx.item<float>(), 7.0f);
+  }
+
+  // Grad with multiple inputs
+  {
+    auto fn = [](std::vector<array> inputs) { return inputs[0] * inputs[1]; };
+    auto x = array(2.0f);
+    auto y = array(3.0f);
+
+    auto [value, grads] = value_and_grad(fn)({x, y});
+    CHECK_EQ(value.item<float>(), 6.0f);
+    CHECK_EQ(grads[0].item<float>(), 3.0f);
+
+    auto dfdx = grad(fn)({x, y})[0];
+    CHECK_EQ(dfdx.item<float>(), 3.0f);
+
+    auto dfdy = grad(fn, 1)({x, y})[0];
+    CHECK_EQ(dfdy.item<float>(), 2.0f);
+
+    // Negative indexing
+    dfdy = grad(fn, -1)({x, y})[0];
+    CHECK_EQ(dfdy.item<float>(), 2.0f);
+
+    grads = grad(fn, {0, 1})({x, y});
+    CHECK_EQ(grads[0].item<float>(), 3.0f);
+    CHECK_EQ(grads[1].item<float>(), 2.0f);
+
+    CHECK_THROWS_AS(
+        grad(fn, std::vector<int>{})({x, y}), std::invalid_argument);
+    CHECK_THROWS_AS(grad(fn, {0, 1, 2})({x, y}), std::invalid_argument);
+    CHECK_THROWS_AS(grad(fn, {0, 0})({x, y}), std::invalid_argument);
+    CHECK_THROWS_AS(grad(fn, -3)({x, y}), std::invalid_argument);
+  }
+}
+
+TEST_CASE("test creation grads") {
+  // Test astype
+  {
+    auto fn = [](array a) { return astype(a, int32); };
+    auto x = ones({4, 4}, float32);
+    auto out = vjp(fn, x, full({4, 4}, 2, int32)).second;
+    CHECK_EQ(out.dtype(), float32);
+    CHECK(array_equal(out, full({4, 4}, 2.0f)).item<bool>());
+
+    out = jvp(fn, x, full({4, 4}, 2, float32)).second;
+    CHECK_EQ(out.dtype(), int32);
+    CHECK(array_equal(out, full({4, 4}, 2, int32)).item<bool>());
+  }
+
+  // Test full
+  {
+    auto full_fn = [](array a) { return full({5, 5, 2}, a); };
+    auto x = ones({2}, float32);
+    auto out = vjp(full_fn, x, full({5, 5, 2}, 2.0f)).second;
+    CHECK(array_equal(out, array({50.0f, 50.0f})).item<bool>());
+
+    out = jvp(full_fn, x, array({3.0f, 3.0f})).second;
+    CHECK(array_equal(out, full({5, 5, 2}, 3.0f)).item<bool>());
+  }
+}
+
+TEST_CASE("test op vjps") {
+  // Test abs
+  {
+    auto out = vjp([](array in) { return abs(in); }, array(-5.0f), array(1.0f));
+    CHECK_EQ(out.second.item<float>(), -1.0f);
+  }
+
+  // Test sign
+  {
+    auto out =
+        vjp([](array in) { return sign(in); }, array(-5.0f), array(10.0f));
+    CHECK_EQ(out.second.item<float>(), 0.0f);
+  }
+
+  // Test negate
+  {
+    auto out = vjp([](array in) { return -in; }, array(1.0), array(2.0));
+    CHECK(array_equal(out.second, array(-2.)).item<bool>());
+  }
+
+  // Test square
+  {
+    auto out =
+        vjp([](array in) { return square(in); }, array(2.0f), array(3.0f));
+    CHECK_EQ(out.second.item<float>(), 12.0f);
+  }
+
+  // Test sqrt
+  {
+    auto out = vjp(
+        [](array in) { return mlx::core::sqrt(in); }, array(4.0f), array(8.0f));
+    CHECK_EQ(out.second.item<float>(), 2.0f);
+  }
+
+  // Test rsqrt
+  {
+    auto out =
+        vjp([](array in) { return rsqrt(in); }, array(4.0f), array(8.0f));
+    CHECK_EQ(out.second.item<float>(), -0.5f);
+  }
+
+  // Test exp
+  {
+    auto out = vjp([](array in) { return exp(in); }, array(1.0f), array(2.0f));
+    CHECK_EQ(out.second.item<float>(), doctest::Approx(2.0f * std::exp(1.0f)));
+  }
+
+  // Test sin
+  {
+    auto out =
+        vjp([](array input) { return sin(input); }, array(1.0f), array(1.0f));
+    CHECK(out.second.item<float>() == doctest::Approx(std::cos(1.0f)));
+  }
+
+  // Test cos
+  {
+    auto out =
+        vjp([](array input) { return cos(input); }, array(1.0f), array(1.0f));
+    CHECK(out.second.item<float>() == doctest::Approx(-std::sin(1.0f)));
+  }
+
+  // Test arctan
+  {
+    auto out = vjp(
+        [](array input) { return arctan(input); }, array(2.0f), array(1.0f));
+    CHECK(out.second.item<float>() == doctest::Approx(0.2f));
+  }
+
+  // Test arctan2
+  {
+    auto out = vjp(
+        [](const std::vector<array>& xs) {
+          return std::vector<array>{arctan2(xs[0], xs[1])};
+        },
+        {array(2.0f), array(3.0f)},
+        {array(1.0f)});
+    CHECK(out.second[0].item<float>() == doctest::Approx(3.0f / 13.0f));
+    CHECK(out.second[1].item<float>() == doctest::Approx(-2.0f / 13.0f));
+  }
+
+  // Test log
+  {
+    auto out = vjp([](array in) { return log(in); }, array(2.0f), array(1.0f));
+    CHECK_EQ(out.second.item<float>(), 0.5f);
+
+    out = vjp([](array in) { return log(in); }, array(2.0f), array(2.0f));
+    CHECK_EQ(out.second.item<float>(), 1.0f);
+  }
+
+  // Test log1p
+  {
+    auto out =
+        vjp([](array in) { return log1p(in); }, array(1.0f), array(1.0f));
+    CHECK_EQ(out.second.item<float>(), 0.5f);
+
+    out = vjp([](array in) { return log1p(in); }, array(1.0f), array(2.0f));
+    CHECK_EQ(out.second.item<float>(), 1.0f);
+  }
+
+  constexpr auto inf = std::numeric_limits<float>::infinity();
+
+  // Test erf
+  {
+    auto out = vjp([](array in) { return erf(in); }, array(inf), array(1.0f));
+    CHECK_EQ(out.second.item<float>(), doctest::Approx(0.0f));
+
+    out = vjp([](array in) { return erf(in); }, array(-inf), array(2.0f));
+    CHECK_EQ(out.second.item<float>(), doctest::Approx(0.0f));
+
+    out = vjp([](array in) { return erf(in); }, array(0.0f), array(1.0f));
+    CHECK_EQ(out.second.item<float>(), static_cast<float>(M_2_SQRTPI));
+  }
+
+  // Test erfinv
+  {
+    auto out =
+        vjp([](array in) { return erfinv(in); }, array(1.0f), array(1.0f));
+    CHECK_EQ(out.second.item<float>(), inf);
+
+    out = vjp([](array in) { return erfinv(in); }, array(-1.0f), array(2.0f));
+    CHECK_EQ(out.second.item<float>(), inf);
+
+    out = vjp([](array in) { return erfinv(in); }, array(0.0f), array(1.0f));
+    CHECK_EQ(out.second.item<float>(), static_cast<float>(1.0 / M_2_SQRTPI));
+  }
+
+  // Test sigmoid
+  {
+    auto out =
+        vjp([](array in) { return sigmoid(in); }, array(0.0f), array(1.0f));
+    CHECK_EQ(out.second.item<float>(), 0.25f);
+
+    out = vjp([](array in) { return sigmoid(in); }, array(0.0f), array(2.0f));
+    CHECK_EQ(out.second.item<float>(), 0.5f);
+  }
+
+  // Test add
+  {
+    auto fun = [](std::vector<array> inputs) {
+      return std::vector<array>{inputs[0] + inputs[1]};
+    };
+    auto out = vjp(fun, {array(1.0), array(2.0)}, {array(3.0)}).second;
+    CHECK_EQ(out[0].item<float>(), 3.0);
+    CHECK_EQ(out[1].item<float>(), 3.0);
+
+    // Check with broadcasting
+    out = vjp(fun, {ones({3, 1}), ones({1, 2})}, {full({3, 2}, 2.0)}).second;
+    CHECK(array_equal(out[0], full({3, 1}, 4.0)).item<bool>());
+    CHECK(array_equal(out[1], full({1, 2}, 6.0)).item<bool>());
+  }
+
+  // Test subtract
+  {
+    auto fun = [](std::vector<array> inputs) {
+      return std::vector<array>{inputs[0] - inputs[1]};
+    };
+    auto out = vjp(fun, {array(1.0), array(2.0)}, {array(3.0)}).second;
+    CHECK_EQ(out[0].item<float>(), 3.0);
+    CHECK_EQ(out[1].item<float>(), -3.0);
+
+    // Check with broadcasting
+    out = vjp(fun, {ones({3, 1}), ones({1, 2})}, {ones({3, 2})}).second;
+    CHECK(array_equal(out[0], full({3, 1}, 2.0)).item<bool>());
+    CHECK(array_equal(out[1], full({1, 2}, -3.0)).item<bool>());
+  }
+
+  // Test multiply
+  {
+    auto fun = [](std::vector<array> inputs) {
+      return std::vector<array>{inputs[0] * inputs[1]};
+    };
+    auto out = vjp(fun, {array(4.0f), array(2.0f)}, {array(3.0f)}).second;
+    CHECK_EQ(out[0].item<float>(), 6.0f);
+    CHECK_EQ(out[1].item<float>(), 12.0f);
+
+    // Check with broadcasting
+    out = vjp(fun, {full({3, 1}, 2.0f), full({1, 2}, 4.0f)}, {ones({3, 2})})
+              .second;
+    CHECK(array_equal(out[0], full({3, 1}, 8.0f)).item<bool>());
+    CHECK(array_equal(out[1], full({1, 2}, 6.0)).item<bool>());
+  }
+
+  // Test divide
+  {
+    auto fun = [](std::vector<array> inputs) {
+      return std::vector<array>{inputs[0] / inputs[1]};
+    };
+    auto out = vjp(fun, {array(4.0f), array(2.0f)}, {array(1.0f)}).second;
+    CHECK_EQ(out[0].item<float>(), 0.5f);
+    CHECK_EQ(out[1].item<float>(), -1.0f);
+
+    // Check with broadcasting
+    out = vjp(fun, {full({3, 1}, 4.0f), full({1, 2}, 2.0f)}, {ones({3, 2})})
+              .second;
+    CHECK(array_equal(out[0], full({3, 1}, 1.0f)).item<bool>());
+    CHECK(array_equal(out[1], full({1, 2}, -3.0f)).item<bool>());
+  }
+
+  // Test maximum
+  {
+    auto fun = [](std::vector<array> inputs) {
+      return std::vector<array>{maximum(inputs[0], inputs[1])};
+    };
+    auto out = vjp(fun, {array(5.0f), array(2.0f)}, {array(2.0f)}).second;
+    CHECK_EQ(out[0].item<float>(), 2.0f);
+    CHECK_EQ(out[1].item<float>(), 0.0f);
+
+    out = vjp(fun, {array(2.0f), array(2.0f)}, {array(1.0f)}).second;
+    auto out_a = out[0].item<float>();
+    auto out_b = out[1].item<float>();
+    // When inputs are equal at most one gradient is nonzero
+    CHECK(
+        ((out_a == 1.0f && out_b == 0.0f) || (out_a == 0.0f && out_b == 1.0f)));
+  }
+
+  // Test minimum
+  {
+    auto fun = [](std::vector<array> inputs) {
+      return std::vector<array>{minimum(inputs[0], inputs[1])};
+    };
+    auto out = vjp(fun, {array(4.0f), array(2.0f)}, {array(2.0f)}).second;
+    CHECK_EQ(out[0].item<float>(), 0.0f);
+    CHECK_EQ(out[1].item<float>(), 2.0f);
+
+    out = vjp(fun, {array(2.0f), array(2.0f)}, {array(1.0f)}).second;
+    auto out_a = out[0].item<float>();
+    auto out_b = out[1].item<float>();
+    CHECK(
+        ((out_a == 1.0f && out_b == 0.0f) || (out_a == 0.0f && out_b == 1.0f)));
+  }
+
+  // Test logaddexp
+  {
+    auto fun = [](std::vector<array> inputs) {
+      return std::vector<array>{logaddexp(inputs[0], inputs[1])};
+    };
+
+    constexpr auto inf = std::numeric_limits<float>::infinity();
+
+    auto out = vjp(fun, {array(2.0), array(2.0f)}, {array(1.0f)}).second;
+    CHECK_EQ(out[0].item<float>(), 0.5f);
+    CHECK_EQ(out[1].item<float>(), 0.5f);
+    out = vjp(fun, {array(2.0), array(2.0f)}, {array(2.0f)}).second;
+    CHECK_EQ(out[0].item<float>(), 1.0f);
+    CHECK_EQ(out[1].item<float>(), 1.0f);
+
+    out = vjp(fun, {array(inf), array(2.0f)}, {array(1.0f)}).second;
+    CHECK_EQ(out[0].item<float>(), 1.0f);
+    CHECK_EQ(out[1].item<float>(), 0.0f);
+
+    out = vjp(fun, {array(-inf), array(2.0f)}, {array(1.0f)}).second;
+    CHECK_EQ(out[0].item<float>(), 0.0f);
+    CHECK_EQ(out[1].item<float>(), 1.0f);
+
+    out = vjp(fun, {array(-10.0f), array(-inf)}, {array(1.0f)}).second;
+    CHECK_EQ(out[0].item<float>(), 1.0f);
+    CHECK_EQ(out[1].item<float>(), 0.0f);
+
+    out = vjp(fun, {array(-inf), array(-inf)}, {array(1.0f)}).second;
+    CHECK(std::isnan(out[0].item<float>()));
+    CHECK(std::isnan(out[1].item<float>()));
+  }
+
+  // Test power
+  {
+    auto fun = [](std::vector<array> inputs) {
+      return std::vector<array>{power(inputs[0], inputs[1])};
+    };
+    auto out = vjp(fun, {array(4.0f), array(3.0f)}, {array(1.0f)}).second;
+    CHECK_EQ(out[0].item<float>(), 48.0f);
+    CHECK_EQ(out[1].item<float>(), std::log(4.0f) * 64.0f);
+  }
+
+  // Test sum
+  {
+    std::vector<int> axes;
+    auto fun = [&axes](array input) { return sum(input, axes); };
+    axes = {};
+    auto out = vjp(fun, array(2.0f), array(3.0f)).second;
+    CHECK_EQ(out.item<float>(), 3.0f);
+
+    axes = {0};
+    out = vjp(fun, array({}), array(3.0f)).second;
+    CHECK_EQ(out.size(), 0);
+    CHECK_EQ(out.shape(), Shape{0});
+
+    axes = {0};
+    out = vjp(fun, ones({2, 2, 2}), array({1.0f, 2.0f, 3.0f, 4.0f}, {2, 2}))
+              .second;
+    auto expected =
+        array({1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f}, {2, 2, 2});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    axes = {1};
+    out = vjp(fun, ones({2, 2, 2}), array({1.0f, 2.0f, 3.0f, 4.0f}, {2, 2}))
+              .second;
+    expected =
+        array({1.0f, 2.0f, 1.0f, 2.0f, 3.0f, 4.0f, 3.0f, 4.0f}, {2, 2, 2});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    axes = {2};
+    out = vjp(fun, ones({2, 2, 2}), array({1.0f, 2.0f, 3.0f, 4.0f}, {2, 2}))
+              .second;
+    expected =
+        array({1.0f, 1.0f, 2.0f, 2.0f, 3.0f, 3.0f, 4.0f, 4.0f}, {2, 2, 2});
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+
+  // Test prod
+  {
+    std::vector<int> axes;
+    auto fun = [&axes](array input) { return prod(input, axes); };
+    axes = {};
+    auto out = vjp(fun, array(2.0f), array(3.0f)).second;
+    CHECK_EQ(out.item<float>(), 3.0f);
+
+    axes = {0};
+    out = vjp(fun,
+              array({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}, {2, 3}),
+              array(
+                  {1.0f, 2.0f, 3.0f},
+                  {
+                      3,
+                  }))
+              .second;
+    auto expected = array({4.0f, 10.0f, 18.0f, 1.0f, 4.0f, 9.0f}, {2, 3});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    axes = {0, 1};
+    out = vjp(fun,
+              array({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}, {2, 3}),
+              array(1.0f))
+              .second;
+    expected = array({720.0f, 360.0f, 240.0f, 180.0f, 144.0f, 120.0f}, {2, 3});
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+}
+
+TEST_CASE("test gather and take grads") {
+  // Check linear takes
+  auto linear_f = [](array indices) {
+    auto fun_linear = [&indices](array input) { return take(input, indices); };
+
+    return fun_linear;
+  };
+
+  auto src = ones({4, 4});
+  auto ind = array({0, 1, 2, 3}, uint32);
+  auto out = vjp(linear_f(ind), src, ones({4})).second;
+  auto out_1 = take(out, array({0}, uint32), 0);
+  auto out_2 = take(out, array({1, 2, 3}, uint32), 0);
+  CHECK(array_equal(out_1, ones({1, 4})).item<bool>());
+  CHECK(array_equal(out_2, zeros({3, 4})).item<bool>());
+  auto tangent = reshape(arange(16), {4, 4});
+  out = jvp(linear_f(ind), src, tangent).second;
+  CHECK(array_equal(out, array({0, 1, 2, 3})).item<bool>());
+
+  src = ones({4});
+  ind = array({0, 0, 0, 0}, uint32);
+  out = vjp(linear_f(ind), src, ones({4})).second;
+  out_1 = take(out, array({0}, uint32));
+  CHECK_EQ(out_1.item<float>(), 4.0f);
+
+  tangent = arange(4);
+  out = jvp(linear_f(ind), src, tangent).second;
+  CHECK(array_equal(out, array({0, 0, 0, 0})).item<bool>());
+
+  // Check axis takes
+  src = ones({4, 4});
+  ind = array({0, 1, 2, 3}, uint32);
+
+  auto fun = [&ind](array input) { return take(input, ind, 0); };
+
+  out = vjp(fun, src, ones({4, 4})).second;
+  CHECK(array_equal(out, src).item<bool>());
+
+  out = jvp(fun, src, ones({4, 4})).second;
+  CHECK(array_equal(out, src).item<bool>());
+
+  // Check index throw
+  auto fun_throw = [](std::vector<array> inputs) {
+    return std::vector<array>{take(inputs[0], inputs[1])};
+  };
+
+  CHECK_THROWS_AS(
+      vjp(fun_throw, {src, ind}, {ones({4, 4})}), std::invalid_argument);
+
+  CHECK_THROWS_AS(
+      jvp(fun_throw, {src, ind}, {ones({4, 4}), ind}), std::invalid_argument);
+}
+
+TEST_CASE("test slice grads") {
+  Shape start = {5, 0, 0};
+  Shape stop = {7, 2, 4};
+  Shape strides = {1, 1, 1};
+
+  auto fn = [&start, &stop, &strides](array input) {
+    return slice(input, start, stop, strides);
+  };
+
+  auto src = ones({8, 8, 8});
+  auto out = vjp(fn, src, ones({2, 2, 4})).second;
+  CHECK_EQ(sum(out).item<float>(), 16.);
+
+  out = jvp(fn, src, full({8, 8, 8}, 2.0f)).second;
+  CHECK(array_equal(out, full({2, 2, 4}, 2.0f)).item<bool>());
+
+  src = ones({4, 4});
+  start = {2, 0};
+  stop = {4, 4};
+  strides = {1, 1};
+  out = vjp(fn, src, ones({2, 4})).second;
+  auto out_1 = take(out, array({0, 1}, uint32), 0);
+  auto out_2 = take(out, array({2, 3}, uint32), 0);
+
+  CHECK(array_equal(out_1, zeros({2, 4})).item<bool>());
+  CHECK(array_equal(out_2, ones({2, 4})).item<bool>());
+
+  start = {0, 0};
+  stop = {4, 4};
+  strides = {2, 2};
+  auto cotangent = array({1.0f, 2.0f, 3.0f, 4.0f}, {2, 2});
+  out = vjp(fn, src, cotangent).second;
+  auto expected = astype(
+      array({1, 0, 2, 0, 0, 0, 0, 0, 3, 0, 4, 0, 0, 0, 0, 0}, {4, 4}), float32);
+  CHECK(array_equal(out, expected).item<bool>());
+
+  out = jvp(fn, src, ones({4, 4})).second;
+  CHECK(array_equal(out, ones({2, 2})).item<bool>());
+
+  // Empty slices.
+  start = {0, 0};
+  stop = {0, 4};
+  cotangent = reshape(array({}), {0, 2});
+  out = vjp(fn, src, cotangent).second;
+  CHECK(array_equal(out, zeros({4, 4})).item<bool>());
+
+  out = jvp(fn, src, ones({4, 4})).second;
+  CHECK_EQ(out.size(), 0);
+}
+
+TEST_CASE("test min and max vjp") {
+  // Test min
+  {
+    std::vector<int> axes;
+    array in({});
+    array v({});
+    array expected({});
+    array out({});
+    auto fun = [&axes](array input) { return min(input, axes); };
+
+    axes = {};
+    in = array({2.0f});
+    out = vjp(fun, array(2.0f), array(3.0f)).second;
+    CHECK_EQ(out.item<float>(), 3.0f);
+
+    axes = {0};
+    in = reshape(array({1.0f, 2.0f, 2.0f, -1.0f}), {2, 2});
+    v = array({3.0f, 7.0f});
+    out = vjp(fun, in, v).second;
+    expected = array({3.0f, 0.0f, 0.0f, 7.0f});
+    expected = reshape(expected, {2, 2});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    axes = {0, 2};
+    in = reshape(
+        array({1.0f, 0.0f, 0.0f, 1.0f, -1.0f, -1.0f, 1.0f, 0.0f}), {2, 2, 2});
+    v = array({3.0f, 7.0f});
+    out = vjp(fun, in, v).second;
+    expected = array({0.0f, 0.0f, 3.5f, 0.0f, 1.5f, 1.5f, 0.0f, 3.5f});
+    expected = reshape(expected, {2, 2, 2});
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+
+  // Test max
+  {
+    std::vector<int> axes;
+    array in({});
+    array v({});
+    array expected({});
+    array out({});
+    auto fun = [&axes](array input) { return max(input, axes); };
+
+    axes = {};
+    in = array({2.0f});
+    out = vjp(fun, array(2.0f), array(3.0f)).second;
+    CHECK_EQ(out.item<float>(), 3.0f);
+
+    axes = {0};
+    in = reshape(array({1.0f, 2.0f, 2.0f, -1.0f}), {2, 2});
+    v = array({3.0f, 7.0f});
+    out = vjp(fun, in, v).second;
+    expected = array({0.0f, 7.0f, 3.0f, 0.0f});
+    expected = reshape(expected, {2, 2});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    axes = {0, 2};
+    in = reshape(
+        array({1.0f, 0.0f, 0.0f, 1.0f, -1.0f, -1.0f, 1.0f, 0.0f}), {2, 2, 2});
+    v = array({3.0f, 7.0f});
+    out = vjp(fun, in, v).second;
+    expected = array({3.0f, 0.0f, 0.0f, 3.5f, 0.0f, 0.0f, 3.5f, 0.0f});
+    expected = reshape(expected, {2, 2, 2});
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+}
+
+TEST_CASE("test reshape and transpose grads") {
+  {
+    auto fn = [](array a) { return reshape(a, {3, 4}); };
+
+    auto out = vjp(fn, ones({12}), full({3, 4}, 2.0f)).second;
+    CHECK(array_equal(out, full({12}, 2.0f)).item<bool>());
+
+    out = jvp(fn, ones({12}), full({12}, 2.0f)).second;
+    CHECK(array_equal(out, full({3, 4}, 2.0f)).item<bool>());
+  }
+
+  {
+    auto fn = [](array a) { return transpose(a, {1, 2, 0}); };
+
+    auto cotan = reshape(arange(24), {3, 4, 2});
+    auto out = vjp(fn, ones({2, 3, 4}), cotan).second;
+    CHECK(array_equal(out, transpose(cotan, {2, 0, 1})).item<bool>());
+
+    auto tangent = reshape(arange(24), {2, 3, 4});
+    out = jvp(fn, ones({2, 3, 4}), tangent).second;
+    CHECK(array_equal(out, transpose(tangent, {1, 2, 0})).item<bool>());
+  }
+}
+
+TEST_CASE("test copy grads") {
+  auto fn = [](array a) { return copy(a); };
+
+  auto cotan = arange(4, float32);
+  auto out = vjp(fn, ones({4}), cotan).second;
+  CHECK(array_equal(out, arange(4, float32)).item<bool>());
+
+  auto tangent = arange(4, float32);
+  out = jvp(fn, ones({4}), tangent).second;
+  CHECK(array_equal(out, tangent).item<bool>());
+}
+
+TEST_CASE("test matmul vjp") {
+  auto fun = [](std::vector<array> inputs) {
+    return std::vector<array>{matmul(inputs[0], inputs[1])};
+  };
+
+  auto a = array({1.0f, 2.0f}, {1, 2});
+  auto b = array({3.0f, 4.0f}, {2, 1});
+  auto out = vjp(fun, {a, b}, {array({2.0f}, {1, 1})}).second;
+
+  CHECK(array_equal(out[0], array({6.0f, 8.0f}, {1, 2})).item<bool>());
+  CHECK(array_equal(out[1], array({2.0f, 4.0f}, {2, 1})).item<bool>());
+
+  a = array({1.0f, 2.0f}, {2, 1});
+  b = array({3.0f, 4.0f}, {1, 2});
+  out = vjp(fun, {a, b}, {array({1.0f, 2.0f, 3.0f, 4.0f}, {2, 2})}).second;
+  CHECK(array_equal(out[0], array({11.0f, 25.0f}, {2, 1})).item<bool>());
+  CHECK(array_equal(out[1], array({7.0f, 10.0f}, {1, 2})).item<bool>());
+
+  a = array({1.0f, 2.0f, 1.0f, 2.0f}, {2, 2, 1});
+  b = array({1.0f, 1.0f, 2.0f, 2.0f}, {2, 1, 2});
+  auto vjps = vjp(fun, {a, b}, {ones({2, 2, 2})}).second;
+  auto vjpx = array({2.0f, 2.0f, 4.0f, 4.0f}, {2, 2, 1});
+  auto vjpy = array({3.0f, 3.0f, 3.0f, 3.0f}, {2, 1, 2});
+  CHECK(array_equal(vjps[0], vjpx).item<bool>());
+  CHECK(array_equal(vjps[1], vjpy).item<bool>());
+}
+
+TEST_CASE("test concatenate grads") {
+  auto arrs = split(arange(5, float32), 5);
+  eval(arrs);
+
+  auto fn = [&arrs](const std::vector<array>& inputs) {
+    arrs[2] = inputs[0];
+    arrs[4] = inputs[1];
+    return std::vector<array>{concatenate(arrs, 0)};
+  };
+  auto out = vjp(fn, {arrs[2], arrs[4]}, {arange(5, float32)}).second;
+
+  CHECK_EQ(out.size(), 2);
+  CHECK_EQ(out[0].item<float>(), 2.0f);
+  CHECK_EQ(out[1].item<float>(), 4.0f);
+
+  out = jvp(fn, {arrs[2], arrs[4]}, {array({2.0f}, {1}), array({3.0f}, {1})})
+            .second;
+  CHECK_EQ(out.size(), 1);
+  CHECK(
+      array_equal(out[0], array({0.0f, 0.0f, 2.0f, 0.0f, 3.0f})).item<bool>());
+}
+
+TEST_CASE("test split grads") {
+  array x = arange(6, float32);
+  eval(x);
+
+  {
+    auto fn = [](const array& x) {
+      auto parts = split(x, 3);
+      return parts[0] * parts[1] + parts[2];
+    };
+    auto out = vjp(fn, {x}, {ones({2})}).second;
+
+    CHECK_EQ(out.size(), 6);
+    CHECK(array_equal(out, array({2.0f, 3.0f, 0.0f, 1.0f, 1.0f, 1.0f}))
+              .item<bool>());
+  }
+
+  {
+    auto fn = [](const array& x) {
+      auto parts = split(x, 3);
+      return parts[0] * parts[2];
+    };
+    auto out = vjp(fn, {x}, {ones({2})}).second;
+
+    CHECK_EQ(out.size(), 6);
+    CHECK(array_equal(out, array({4.0f, 5.0f, 0.0f, 0.0f, 0.0f, 1.0f}))
+              .item<bool>());
+  }
+}
+
+TEST_CASE("test comparison grads") {
+  auto x = ones({3, 1});
+  auto y = zeros({1, 3});
+
+  auto check_vjp_jvp = [&x, &y](auto fn) {
+    auto fn_wrap = [&fn](std::vector<array> inputs) {
+      return std::vector<array>{fn(inputs[0], inputs[1], default_device())};
+    };
+    auto out_shape = broadcast_shapes(x.shape(), y.shape());
+    std::vector<array> vjps = vjp(fn_wrap, {x, y}, {ones(out_shape)}).second;
+    bool correct = array_equal(vjps[0], zeros(x.shape())).item<bool>();
+    correct &= array_equal(vjps[1], zeros(y.shape())).item<bool>();
+
+    std::vector<array> jvps =
+        jvp(fn_wrap, {x, y}, {ones(x.shape()), ones(y.shape())}).second;
+    correct &= array_equal(jvps[0], zeros(out_shape)).item<bool>();
+    return correct;
+  };
+
+  CHECK(check_vjp_jvp(equal));
+  CHECK(check_vjp_jvp(greater));
+  CHECK(check_vjp_jvp(less));
+  CHECK(check_vjp_jvp(greater_equal));
+  CHECK(check_vjp_jvp(less_equal));
+}
+
+TEST_CASE("test as_strided grads") {
+  auto x = ones({11});
+  Shape shape = {5, 5};
+  Strides strides = {1, 1};
+  size_t offset = 0;
+
+  auto fun = [&shape, &strides, &offset](array x) {
+    return as_strided(x, shape, strides, offset);
+  };
+
+  auto out = vjp(fun, x, ones(shape)).second;
+  auto expected = array({1, 2, 3, 4, 5, 4, 3, 2, 1, 0, 0});
+  CHECK(array_equal(out, expected).item<bool>());
+
+  offset = 1;
+  out = vjp(fun, x, ones(shape)).second;
+  expected = array({0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0});
+  CHECK(array_equal(out, expected).item<bool>());
+
+  offset = 3;
+  shape = {3, 3};
+  strides = {0, 1};
+  out = vjp(fun, x, ones(shape)).second;
+  expected = array({0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0});
+  CHECK(array_equal(out, expected).item<bool>());
+
+  offset = 3;
+  shape = {3, 3};
+  strides = {0, 1};
+  out = vjp(fun, x, reshape(astype(arange(9), x.dtype()), {3, 3})).second;
+  expected = array({0, 0, 0, 9, 12, 15, 0, 0, 0, 0, 0});
+  CHECK(array_equal(out, expected).item<bool>());
+}
+
+TEST_CASE("test jvp from vjp") {
+  // Unary element-wise ops
+  {
+    auto x = random::uniform({5, 10});
+    eval(x);
+
+    auto compute_derivs = [&x](auto fn) {
+      auto fn_wrap = [&fn](array input) { return fn(input, default_device()); };
+
+      // Compute vjp
+      array vjp_out = vjp(fn_wrap, x, ones(x.shape())).second;
+
+      // Compute jvp
+      array jvp_out = jvp(fn_wrap, x, ones(x.shape())).second;
+
+      return array_equal(vjp_out, jvp_out).item<bool>();
+    };
+
+    CHECK(compute_derivs(mlx::core::abs));
+    CHECK(compute_derivs(mlx::core::cos));
+    CHECK(compute_derivs(mlx::core::erf));
+    CHECK(compute_derivs(mlx::core::erfinv));
+    CHECK(compute_derivs(mlx::core::exp));
+    CHECK(compute_derivs(mlx::core::log));
+    CHECK(compute_derivs(mlx::core::log1p));
+    CHECK(compute_derivs(mlx::core::negative));
+    CHECK(compute_derivs(mlx::core::sigmoid));
+    CHECK(compute_derivs(mlx::core::sign));
+    CHECK(compute_derivs(mlx::core::sin));
+    CHECK(compute_derivs(mlx::core::square));
+    CHECK(compute_derivs(mlx::core::sqrt));
+    CHECK(compute_derivs(mlx::core::rsqrt));
+  }
+
+  // Binary element-wise ops
+  {
+    auto x = random::uniform({5, 10});
+    auto y = random::uniform({5, 10});
+    eval(x, y);
+
+    auto compute_derivs = [&x, &y](auto fn) {
+      auto fn_wrap = [&fn](std::vector<array> inputs) {
+        return std::vector<array>{fn(inputs[0], inputs[1], default_device())};
+      };
+
+      // Compute vjp and add results
+      auto vjps = vjp(fn_wrap, {x, y}, {ones(x.shape())}).second;
+      array vjp_out = add(vjps[0], vjps[1]);
+
+      // Compute jvp
+      array jvp_out =
+          jvp(fn_wrap, {x, y}, {ones(x.shape()), ones(y.shape())}).second[0];
+      return array_equal(vjp_out, jvp_out).item<bool>();
+    };
+
+    CHECK(compute_derivs(add));
+    CHECK(compute_derivs(divide));
+    CHECK(compute_derivs(logaddexp));
+    CHECK(compute_derivs(maximum));
+    CHECK(compute_derivs(minimum));
+    CHECK(compute_derivs(multiply));
+    CHECK(compute_derivs(subtract));
+    CHECK(compute_derivs(power));
+  }
+
+  // Conditional selection element-wise op
+  {
+    auto condition = random::randint(0, 2, {5, 10});
+    auto x = random::uniform({5, 10});
+    auto y = random::uniform({5, 10});
+    eval(condition, x, y);
+
+    auto compute_derivs = [&condition, &x, &y](auto fn) {
+      auto fn_wrap = [&fn](std::vector<array> inputs) {
+        return std::vector<array>{
+            fn(inputs[0], inputs[1], inputs[2], default_device())};
+      };
+
+      // Compute vjp and add results
+      auto vjps = vjp(fn_wrap, {condition, x, y}, {ones(x.shape())}).second;
+      auto vjp_out = add(add(vjps[0], vjps[1]), vjps[2]);
+
+      // Compute jvp
+      array jvp_out =
+          jvp(fn_wrap,
+              {condition, x, y},
+              {ones(condition.shape()), ones(y.shape()), ones(x.shape())})
+              .second[0];
+
+      array result = array_equal(vjp_out, jvp_out);
+      return result.item<bool>();
+    };
+
+    CHECK(compute_derivs(where));
+  }
+}
+
+TEST_CASE("test complex gradients") {
+  {
+    auto add_fn = [](std::vector<array> inputs) {
+      return std::vector<array>{add(inputs[0], inputs[1], default_device())};
+    };
+
+    // Compute jvp
+    auto x = array(complex64_t{1.0, 1.0});
+    auto y = array(complex64_t{1.0, 1.0});
+    auto x_tan = array(complex64_t{1.0, 2.0});
+    auto y_tan = array(complex64_t{2.0, 1.0});
+    auto jvp_out = jvp(add_fn, {x, y}, {x_tan, y_tan}).second;
+    CHECK_EQ(jvp_out[0].item<complex64_t>(), complex64_t{3.0, 3.0});
+
+    // Compute vjp
+    auto cotan = array(complex64_t{3.0, 3.0});
+    auto vjp_out = vjp(add_fn, {x, y}, {cotan}).second;
+    CHECK_EQ(vjp_out[0].item<complex64_t>(), complex64_t{3.0, 3.0});
+    CHECK_EQ(vjp_out[1].item<complex64_t>(), complex64_t{3.0, 3.0});
+  }
+
+  {
+    auto multiply_fn =
+        [](const std::vector<array>& inputs) -> std::vector<array> {
+      return {multiply(inputs[0], inputs[1])};
+    };
+
+    // Compute jvp
+    auto x = array(complex64_t{2.0, 4.0});
+    auto y = array(3.0f);
+    auto x_tan = array(complex64_t{1.0, 2.0});
+    auto y_tan = array(2.0f);
+    auto jvp_out = jvp(multiply_fn, {x, y}, {x_tan, y_tan}).second;
+    CHECK_EQ(jvp_out[0].item<complex64_t>(), complex64_t{7.0, 14.0});
+
+    // Compute vjp
+    auto cotan = array(complex64_t{2.0, 3.0});
+    auto vjp_out = vjp(multiply_fn, {x, y}, {cotan}).second;
+    CHECK_EQ(vjp_out[0].dtype(), complex64);
+    CHECK_EQ(vjp_out[0].item<complex64_t>(), complex64_t{6.0, 9.0});
+    CHECK_EQ(vjp_out[1].dtype(), float32);
+    CHECK_EQ(vjp_out[1].item<float>(), 16);
+  }
+
+  {
+    auto divide_fn =
+        [](const std::vector<array>& inputs) -> std::vector<array> {
+      return {divide(inputs[0], inputs[1])};
+    };
+
+    // Compute jvp
+    auto x = array(complex64_t{2.0, 3.0});
+    auto y = array(complex64_t{1.0, 2.0});
+    auto x_tan = array(complex64_t{3.0, 4.0});
+    auto y_tan = array(complex64_t{4.0, -2.0});
+    auto jvp_out = jvp(divide_fn, {x, y}, {x_tan, y_tan}).second;
+    CHECK_EQ(
+        jvp_out[0].item<complex64_t>(), doctest::Approx(complex64_t{2.6, 2.8}));
+
+    // Compute vjp
+    auto cotan = array(complex64_t{2.0, -4.0});
+    auto vjp_out = vjp(divide_fn, {x, y}, {cotan}).second;
+    CHECK_EQ(vjp_out[0].item<complex64_t>(), complex64_t{2.0, 0.0});
+    CHECK_EQ(vjp_out[1].item<complex64_t>(), complex64_t{-3.2, -0.4});
+  }
+}
+
+TEST_CASE("test scan grads") {
+  // Test cumsum
+  {
+    int axis = 0;
+    int reverse = false;
+    int inclusive = true;
+    auto fun = [&axis, &reverse, &inclusive](array x) {
+      return cumsum(x, axis, reverse, inclusive);
+    };
+
+    auto out = vjp(fun, ones({4}), ones({4})).second;
+    auto expected = array({4.0f, 3.0f, 2.0f, 1.0f}, {4});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    reverse = true;
+    out = vjp(fun, ones({4}), ones({4})).second;
+    expected = array({1.0f, 2.0f, 3.0f, 4.0f}, {4});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    reverse = true;
+    inclusive = false;
+    out = vjp(fun, ones({4}), ones({4})).second;
+    expected = array({0.0f, 1.0f, 2.0f, 3.0f}, {4});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    reverse = false;
+    inclusive = false;
+    out = vjp(fun, ones({4}), ones({4})).second;
+    expected = array({3.0f, 2.0f, 1.0f, 0.0f}, {4});
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+
+  // Test cumprod
+  {
+    int axis = 0;
+    int reverse = false;
+    int inclusive = true;
+    auto fun = [&axis, &reverse, &inclusive](array x) {
+      return cumprod(x, axis, reverse, inclusive);
+    };
+
+    auto x = array({1.0f, 2.0f, 3.0f, 4.0f}, {4});
+    auto g = array({1.0f, 2.0f, 3.0f, 4.0f}, {4});
+    auto out = vjp(fun, x, g).second;
+    auto expected = array({119.0f, 59.0f, 38.0f, 24.0f}, {4});
+    CHECK(allclose(out, expected).item<bool>());
+
+    reverse = true;
+    out = vjp(fun, x, g).second;
+    expected = array({24.0f, 36.0f, 36.0f, 31.0f}, {4});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    inclusive = false;
+    out = vjp(fun, x, g).second;
+    expected = array({0.0f, 12.0f, 16.0f, 15.0f}, {4});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    reverse = false;
+    out = vjp(fun, x, g).second;
+    expected = array({32.0f, 15.0f, 8.0f, 0.0f}, {4});
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+
+  // Test cumsum jvp
+  {
+    int axis = 0;
+    int reverse = false;
+    int inclusive = true;
+    auto fun = [&axis, &reverse, &inclusive](array x) {
+      return cumsum(x, axis, reverse, inclusive);
+    };
+
+    auto x = array({1.0f, 2.0f, 3.0f, 4.0f}, {4});
+    auto out = jvp(fun, x, ones({4})).second;
+    auto expected = array({1.0f, 2.0f, 3.0f, 4.0f}, {4});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    reverse = true;
+    out = jvp(fun, x, ones({4})).second;
+    expected = array({4.0f, 3.0f, 2.0f, 1.0f}, {4});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    inclusive = false;
+    out = jvp(fun, x, ones({4})).second;
+    expected = array({3.0f, 2.0f, 1.0f, 0.0f}, {4});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    reverse = false;
+    out = jvp(fun, x, ones({4})).second;
+    expected = array({0.0f, 1.0f, 2.0f, 3.0f}, {4});
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+}
+
+TEST_CASE("test update state") {
+  auto y = array({1.0});
+  auto x = array({1.0, 1.0});
+  auto state = array({0.0, 0.0});
+  auto fn = [&state, &x](array y) {
+    x = y * x;
+    state = state + x;
+    return sum(x);
+  };
+  grad(fn)(y);
+  eval(state);
+  CHECK(!state.has_primitive());
+  CHECK(state.is_available());
+  CHECK(array_equal(state, array({1.0, 1.0})).item<bool>());
+}
+
+TEST_CASE("test grad types") {
+  {
+    auto fn = [](array x) { return sum(x); };
+
+    for (auto t : {float16, bfloat16, float32}) {
+      auto x = array(1.0, t);
+      auto dfdx = grad(fn)(x);
+      CHECK_EQ(dfdx.dtype(), t);
+    }
+  }
+
+  {
+    // Check for multi-input grad
+    auto fn = [](std::vector<array> inputs) {
+      return sum(inputs[0] + inputs[1]);
+    };
+
+    for (auto t : {float16, bfloat16, float32}) {
+      auto x = array(1.0, t);
+      auto y = array(1.0, t);
+      auto out = grad(fn)({x, y});
+      CHECK_EQ(out[0].dtype(), t);
+    }
+  }
+}
+
+TEST_CASE("test grad dynamic slices") {
+  {
+    auto fn = [](const array& x) { return slice(x, array({0}), {0}, {1, 2}); };
+    auto x = array({1, 2, 3, 4}, {2, 2});
+    auto out = vjp(fn, x, array({1, 1}, {1, 2})).second;
+    CHECK(array_equal(out, array({1, 1, 0, 0}, {2, 2})).item<bool>());
+  }
+  {
+    auto fn = [](const std::vector<array>& inputs) {
+      const auto& x = inputs[0];
+      const auto& update = inputs[1];
+      return std::vector<array>{slice_update(x, update, array({0}), {0})};
+    };
+    auto x = zeros({2, 2});
+    auto update = array({3.f, 4.f}, {1, 2});
+    auto outs = vjp(fn, {x, update}, {ones({2, 2})}).second;
+    CHECK(allclose(outs[0], array({0.f, 0.f, 1.f, 1.f}, {2, 2})).item<bool>());
+    CHECK(allclose(outs[1], ones({1, 2})).item<bool>());
+  }
+}
diff --git a/ml-stable-diffusion/mlx/tests/blas_tests.cpp b/ml-stable-diffusion/mlx/tests/blas_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..37653ba040659f933d1696877de427072fbf8f2d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/blas_tests.cpp
@@ -0,0 +1,110 @@
+// Copyright © 2023 Apple Inc.
+
+#include <numeric>
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test matmul") {
+  auto a = array(1);
+  auto b = array({1.0});
+  CHECK_THROWS_AS(matmul(a, b), std::invalid_argument);
+
+  a = array({1.0});
+  b = array({1.0});
+  auto out = matmul(a, b);
+  CHECK_EQ(out.shape(), Shape{});
+  CHECK_EQ(out.size(), 1);
+  CHECK_EQ(out.dtype(), float32);
+  CHECK_EQ(out.item<float>(), 1.0f);
+
+  a = ones({2, 4});
+  b = ones({2});
+  CHECK_THROWS_AS(matmul(a, b), std::invalid_argument);
+
+  a = ones({2, 4});
+  b = ones({3, 2});
+  CHECK_THROWS_AS(matmul(a, b), std::invalid_argument);
+
+  a = ones({2, 4});
+  b = ones({4, 3, 2});
+  CHECK_THROWS_AS(matmul(a, b), std::invalid_argument);
+
+  a = ones({2});
+  b = ones({4, 2});
+  CHECK_THROWS_AS(matmul(a, b), std::invalid_argument);
+
+  a = ones({2, 3});
+  b = ones({4, 2});
+  CHECK_THROWS_AS(matmul(a, b), std::invalid_argument);
+
+  a = ones({2, 4, 3});
+  b = ones({4, 2});
+  CHECK_THROWS_AS(matmul(a, b), std::invalid_argument);
+
+  a = ones({2, 4});
+  b = ones({4, 2});
+  out = matmul(a, b);
+  CHECK(array_equal(out, full({2, 2}, 4.0f)).item<bool>());
+
+  a = ones({2, 4}, int32);
+  b = ones({4, 2}, float32);
+  out = matmul(a, b);
+  CHECK(array_equal(out, full({2, 2}, 4.0f)).item<bool>());
+
+  // Check single dimensions
+  a = ones({4});
+  b = ones({4, 2});
+  out = matmul(a, b);
+  CHECK(array_equal(out, full({2}, 4.0f)).item<bool>());
+
+  a = ones({2, 4});
+  b = ones({4});
+  out = matmul(a, b);
+  CHECK(array_equal(out, full({2}, 4.0f)).item<bool>());
+
+  a = ones({4});
+  b = ones({4});
+  out = matmul(a, b);
+  CHECK(array_equal(out, full({}, 4.0f)).item<bool>());
+
+  // Test transposed arrays
+  a = array({1.0f, 1.0f, 1.0f, 1.0f}, {1, 4});
+  b = array({1.0f, 1.0f, 1.0f, 1.0f}, {4, 1});
+  out = matmul(transpose(a), transpose(b));
+  CHECK(array_equal(out, ones({4, 4})).item<bool>());
+
+  a = array({1.0f, 2.0f, 3.0f, 4.0f}, {2, 2});
+  b = array({1.0f, 2.0f, 1.0f, 2.0f}, {2, 2});
+  out = matmul(transpose(a), b);
+  CHECK(
+      array_equal(out, array({4.0f, 8.0f, 6.0f, 12.0f}, {2, 2})).item<bool>());
+
+  out = matmul(a, transpose(b));
+  CHECK(
+      array_equal(out, array({5.0f, 5.0f, 11.0f, 11.0f}, {2, 2})).item<bool>());
+
+  out = matmul(transpose(a), transpose(b));
+  CHECK(
+      array_equal(out, array({7.0f, 7.0f, 10.0f, 10.0f}, {2, 2})).item<bool>());
+
+  // Test broadcasting for both arrays
+  a = ones({5, 4, 2});
+  b = ones({2, 3});
+  out = matmul(a, b);
+  CHECK(array_equal(out, full({5, 4, 3}, 2.0f)).item<bool>());
+
+  a = ones({5, 1, 4, 2});
+  b = ones({1, 7, 2, 3});
+  out = matmul(a, b);
+  CHECK(array_equal(out, full({5, 7, 4, 3}, 2.0f)).item<bool>());
+
+  // Test batched matmul with transpose
+  a = ones({2, 2, 4});
+  b = ones({2, 4, 2});
+  out = matmul(transpose(a, {0, 2, 1}), transpose(b, {0, 2, 1}));
+  CHECK(array_equal(out, full({2, 4, 4}, 2.0f)).item<bool>());
+}
diff --git a/ml-stable-diffusion/mlx/tests/compile_tests.cpp b/ml-stable-diffusion/mlx/tests/compile_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..96552ef9ddb88f4df37acabe7d4a7b952fdec3e8
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/compile_tests.cpp
@@ -0,0 +1,806 @@
+// Copyright © 2023-2024 Apple Inc.
+
+// Required for using M_SQRT2 in MSVC.
+#define _USE_MATH_DEFINES
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+#include "mlx/primitives.h"
+
+using namespace mlx::core;
+
+std::vector<array> simple_fun(const std::vector<array>& inputs) {
+  return std::vector<array>{inputs[0] + inputs[1]};
+}
+
+TEST_CASE("test simple compile") {
+  auto compfn = compile(simple_fun);
+  auto out = compfn({array(1.0f), array(2.0f)})[0];
+  CHECK_EQ(out.item<float>(), 3.0f);
+
+  out = compfn({array(1.0f), array(2.0f)})[0];
+  CHECK_EQ(out.item<float>(), 3.0f);
+
+  // Change the shapes
+  out = compfn({array({1.0f, 2.0f}), array(2.0f)})[0];
+  CHECK(array_equal(out, array({3.0f, 4.0f})).item<bool>());
+
+  out = compfn({array(2.0f), array({1.0f, 2.0f})})[0];
+  CHECK(array_equal(out, array({3.0f, 4.0f})).item<bool>());
+
+  // Change the types
+  out = compfn({array(2, int32), array({1.0f, 2.0f})})[0];
+  CHECK(array_equal(out, array({3.0f, 4.0f})).item<bool>());
+
+  out = compfn({array(2.0f), array({1, 2}, int32)})[0];
+  CHECK(array_equal(out, array({3.0f, 4.0f})).item<bool>());
+}
+
+std::vector<array> grad_fun(const std::vector<array>& inputs) {
+  auto loss = [](std::vector<array> ins) { return exp(ins[0] + ins[1]); };
+  return grad(loss, {0, 1})(inputs);
+}
+
+TEST_CASE("test compile with grad") {
+  auto x = array(1.0f);
+  auto y = array(1.0f);
+  auto grads_expected = grad_fun({x, y});
+  auto grads_compile = compile(grad_fun)({x, y});
+  CHECK(allclose(grads_compile[0], grads_expected[0]).item<bool>());
+  CHECK(allclose(grads_compile[1], grads_expected[1]).item<bool>());
+}
+
+TEST_CASE("test compile inputs with primitive") {
+  auto [k1, k2] = random::split(random::key(0));
+  auto x = random::uniform({5, 5}, k1);
+  auto y = random::uniform({5, 5}, k2);
+  auto expected = simple_fun({x, y})[0];
+
+  x = random::uniform({5, 5}, k1);
+  y = random::uniform({5, 5}, k2);
+  auto out = compile(simple_fun)({x, y})[0];
+  CHECK(array_equal(expected, out).item<bool>());
+
+  // Same thing twice
+  out = compile(simple_fun)({x, y})[0];
+  CHECK(array_equal(expected, out).item<bool>());
+}
+
+std::vector<array> fun_creats_array(const std::vector<array>& inputs) {
+  return {inputs[0] + array(1.0f)};
+}
+
+TEST_CASE("test compile with created array") {
+  auto cfun = compile(fun_creats_array);
+  auto out = cfun({array(2.0f)});
+  CHECK_EQ(out[0].item<float>(), 3.0f);
+
+  // Try again
+  out = cfun({array(2.0f)});
+  CHECK_EQ(out[0].item<float>(), 3.0f);
+}
+
+std::vector<array> inner_fun(const std::vector<array>& inputs) {
+  return {array(2) * inputs[0]};
+}
+
+std::vector<array> outer_fun(const std::vector<array>& inputs) {
+  auto x = inputs[0] + inputs[1];
+  auto y = compile(inner_fun)({x})[0];
+  return {x + y};
+}
+
+TEST_CASE("test nested compile") {
+  auto cfun = compile(outer_fun);
+  auto out = cfun({array(1), array(2)})[0];
+  CHECK_EQ(out.item<int>(), 9);
+
+  // Try again
+  out = cfun({array(1), array(2)})[0];
+  CHECK_EQ(out.item<int>(), 9);
+}
+
+TEST_CASE("test enable and disable compile") {
+  CHECK_THROWS(compile(nullptr));
+  disable_compile();
+  compile(nullptr);
+  enable_compile();
+  CHECK_THROWS(compile(nullptr));
+}
+
+auto add_scalars(const std::vector<array>&) {
+  auto a = array(-1.0f);
+  auto b = array(-1.0f);
+  return std::vector<array>{abs(a), abs(b)};
+};
+
+auto max_scalars(const std::vector<array>&) {
+  auto a = array({-1.0f, 2.0f});
+  auto b = maximum(a, array(0.0f));
+  auto c = maximum(-a, array(0.0f));
+  auto d = b + c;
+  return std::vector<array>{b, c, d};
+};
+
+TEST_CASE("test simplify scalars") {
+  set_compile_mode(CompileMode::no_fuse);
+  {
+    auto cfun = compile(add_scalars);
+    auto out = cfun({});
+    auto c = out[0];
+    auto d = out[1];
+    CHECK(c.inputs()[0].id() == d.inputs()[0].id());
+  }
+
+  {
+    auto a = array({-1.0f, 2.0f});
+    auto out = compile(max_scalars)({a});
+    auto b = out[0];
+    auto c = out[1];
+    auto d = out[2];
+    CHECK(b.inputs()[1].id() == c.inputs()[1].id());
+  }
+  set_compile_mode(CompileMode::enabled);
+}
+
+auto exp_two(const std::vector<array>& inputs) {
+  auto a = inputs[0];
+  return std::vector<array>{exp(a) + exp(a)};
+};
+
+TEST_CASE("test simplify") {
+  set_compile_mode(CompileMode::no_fuse);
+  auto a = array({1.0f, 2.0f});
+  auto b = compile(exp_two)({a})[0];
+  CHECK(b.inputs()[0].id() == b.inputs()[1].id());
+  set_compile_mode(CompileMode::enabled);
+}
+
+TEST_CASE("test simplify noops") {
+  set_compile_mode(CompileMode::no_fuse);
+  auto a = array({1.0f, 2.0f});
+  auto fun = [](const std::vector<array>& inputs) -> std::vector<array> {
+    return {copy(stop_gradient(exp(stop_gradient(inputs[0]))))};
+  };
+  auto b = compile(fun)({a})[0];
+  CHECK(b.inputs()[0].id() == a.id());
+  set_compile_mode(CompileMode::enabled);
+}
+
+auto add_diff(const std::vector<array>& inputs) {
+  auto a = inputs[0];
+  return std::vector<array>{cos(a) + sin(a)};
+};
+
+TEST_CASE("test no simplify") {
+  set_compile_mode(CompileMode::no_fuse);
+  auto a = array({1.0f, 2.0f});
+  auto b = compile(add_diff)({a})[0];
+  CHECK(b.inputs()[0].id() != b.inputs()[1].id());
+  set_compile_mode(CompileMode::enabled);
+}
+
+auto multi_one(const std::vector<array>&) {
+  auto a = array(1.0);
+  auto b = array(2.0);
+  auto c = divmod(a, b);
+  auto d = divmod(a, b);
+  auto e = c[0] + d[0];
+  auto f = c[1] + d[1];
+  return std::vector<array>{e, f};
+}
+
+auto multi_two(const std::vector<array>&) {
+  auto a = array(1.0);
+  auto b = array(1.0);
+  auto c = divmod(a, b);
+  return std::vector<array>{c};
+}
+
+auto multi_three(const std::vector<array>&) {
+  auto a = array(1.0);
+  auto b = array(2.0);
+  auto c = divmod(a, b);
+  auto d = divmod(a, b);
+  auto e = stack({c[0], c[1], d[0], d[1]});
+  return std::vector<array>{e};
+}
+
+TEST_CASE("test simplify multi output") {
+  set_compile_mode(CompileMode::no_fuse);
+  {
+    auto out = compile(multi_one)({});
+    auto e = out[0];
+    auto f = out[1];
+    CHECK_EQ(e.inputs()[0].id(), e.inputs()[1].id());
+    CHECK_EQ(f.inputs()[0].id(), f.inputs()[1].id());
+  }
+
+  {
+    auto c = compile(multi_two)({});
+    CHECK_EQ(c[0].inputs()[0].id(), c[0].inputs()[1].id());
+    CHECK_EQ(c[0].inputs()[0].id(), c[1].inputs()[0].id());
+    CHECK_EQ(c[1].inputs()[0].id(), c[1].inputs()[1].id());
+  }
+
+  // Make sure the output order of multi-output primitives
+  // is respected in simplification
+  {
+    auto e = compile(multi_three)({})[0];
+    CHECK_EQ(e.inputs().size(), 4);
+    CHECK_EQ(e.inputs().at(0).id(), e.inputs().at(2).id());
+    CHECK_EQ(e.inputs().at(1).id(), e.inputs().at(3).id());
+    CHECK(array_equal(e, array({0.0f, 1.0f, 0.0f, 1.0f})).item<bool>());
+  }
+  set_compile_mode(CompileMode::enabled);
+}
+
+// No fusion
+auto unary_fused_0(const std::vector<array>& inputs) {
+  return std::vector<array>{exp(inputs[0])};
+}
+
+// All compilable
+auto unary_fused_1(const std::vector<array>& inputs) {
+  return std::vector<array>{abs(negative(exp(inputs[0])))};
+}
+
+auto unary_fused_1_copy(const std::vector<array>& inputs) {
+  return std::vector<array>{abs(negative(exp(inputs[0])))};
+}
+
+auto unary_fused_1_diff(const std::vector<array>& inputs) {
+  return std::vector<array>{abs(exp(negative(inputs[0])))};
+}
+
+// Output into un-compilable primitive
+auto unary_fused_2(const std::vector<array>& inputs) {
+  return std::vector<array>{sum(abs(negative(exp(inputs[0]))), true)};
+}
+
+// Input from un-compilable primitive
+auto unary_fused_3(const std::vector<array>& inputs) {
+  return std::vector<array>{exp(abs(negative(sum(inputs[0], true))))};
+}
+
+TEST_CASE("test compile unary fused") {
+  // NB: some of these tests are brittle and may need to be
+  // updated if we change compile conditions
+  {
+    auto cfun = compile(unary_fused_0);
+    auto x = array(2.0);
+    auto out = cfun({x})[0];
+
+    auto& p = out.primitive();
+    CHECK_EQ(typeid(p), typeid(Exp));
+    CHECK_EQ(out.inputs()[0].id(), x.id());
+  }
+
+  {
+    auto cfun = compile(unary_fused_1);
+    auto x = array(2.0);
+    auto out = cfun({x})[0];
+
+    auto& p = out.primitive();
+    CHECK_EQ(typeid(p), typeid(Compiled));
+    CHECK_EQ(out.inputs()[0].id(), x.id());
+
+    auto expected_out = unary_fused_1({array(2.0)})[0];
+    CHECK(allclose(out, expected_out).item<bool>());
+  }
+
+  {
+    auto cfun = compile(unary_fused_2);
+    auto x = array({1.0, 2.0});
+    auto out = cfun({x});
+    CHECK_EQ(out.size(), 1);
+
+    auto& p = out[0].primitive();
+    // NB: this test is brittle, will need to update
+    // it if we change compile conditions
+    CHECK_EQ(typeid(p), typeid(Reduce));
+    auto cout = out[0].inputs()[0];
+    auto& cp = cout.primitive();
+    CHECK_EQ(typeid(cp), typeid(Compiled));
+    CHECK_EQ(cout.inputs()[0].id(), x.id());
+  }
+
+  {
+    auto cfun = compile(unary_fused_3);
+    auto x = array({1.0, 2.0});
+    auto out = cfun({x});
+
+    auto& p = out[0].primitive();
+    CHECK_EQ(typeid(p), typeid(Compiled));
+    auto sout = out[0].inputs()[0];
+    CHECK_EQ(out[0].inputs().size(), 1);
+    auto& sp = sout.primitive();
+    CHECK_EQ(typeid(sp), typeid(Reduce));
+    CHECK_EQ(sout.inputs()[0].id(), x.id());
+  }
+
+  // Is equivalent works
+  {
+    auto out1 = compile(unary_fused_1)({array(1.0)});
+    auto out2 = compile(unary_fused_1_copy)({array(1.0)});
+    CHECK(out1[0].primitive().is_equivalent(out2[0].primitive()));
+    auto out3 = compile(unary_fused_1_diff)({array(1.0)});
+    CHECK(!out1[0].primitive().is_equivalent(out3[0].primitive()));
+  }
+}
+
+// All compilable
+auto binary_fused_0(const std::vector<array>& inputs) {
+  return std::vector<array>{inputs[0] + inputs[1]};
+}
+
+// Binary into unary
+auto binary_fused_1(const std::vector<array>& inputs) {
+  return std::vector<array>{abs(inputs[0] + inputs[1])};
+}
+
+// Binary into binary
+auto binary_fused_2(const std::vector<array>& inputs) {
+  auto x = inputs[0] + inputs[1];
+  return std::vector<array>{x + inputs[0]};
+}
+
+// Binary into unary into un-compilable
+auto binary_fused_3(const std::vector<array>& inputs) {
+  return std::vector<array>{sum(abs(inputs[0] + inputs[1]), true)};
+}
+
+TEST_CASE("test compile binary fused") {
+  {
+    auto cfun = compile(binary_fused_0);
+    auto x = array(2.0);
+    auto y = array(2.0);
+    auto out = cfun({x, y})[0];
+
+    auto& p = out.primitive();
+    CHECK_EQ(typeid(p), typeid(Add));
+    CHECK_EQ(out.inputs()[0].id(), x.id());
+  }
+
+  {
+    auto cfun = compile(binary_fused_1);
+    auto x = array(2.0);
+    auto y = array(2.0);
+    auto out = cfun({x, y})[0];
+
+    auto& p = out.primitive();
+    CHECK_EQ(typeid(p), typeid(Compiled));
+    CHECK_EQ(out.inputs()[0].id(), x.id());
+    CHECK_EQ(out.inputs()[1].id(), y.id());
+
+    auto expected_out = binary_fused_1({x, y})[0];
+    CHECK_EQ(out.item<float>(), expected_out.item<float>());
+  }
+
+  {
+    auto cfun = compile(binary_fused_2);
+    auto x = array(2.0);
+    auto y = array(2.0);
+    auto out = cfun({x, y})[0];
+
+    auto& p = out.primitive();
+    CHECK_EQ(typeid(p), typeid(Compiled));
+    CHECK_EQ(out.inputs()[0].id(), x.id());
+    CHECK_EQ(out.inputs()[1].id(), y.id());
+  }
+
+  {
+    auto cfun = compile(binary_fused_3);
+    auto x = array({1.0, 2.0});
+    auto y = array({1.0, 2.0});
+    auto out = cfun({x, y})[0];
+
+    auto& p = out.primitive();
+    CHECK_EQ(typeid(p), typeid(Reduce));
+
+    auto cout = out.inputs()[0];
+    auto& cp = cout.primitive();
+    CHECK_EQ(typeid(cp), typeid(Compiled));
+    CHECK_EQ(cout.inputs()[0].id(), x.id());
+    CHECK_EQ(cout.inputs()[1].id(), y.id());
+  }
+}
+
+auto gelu_1(const std::vector<array>& inputs) {
+  auto& x = inputs[0];
+  auto out = x * (1.0f + erf(x / M_SQRT2)) / 2.0f;
+  return std::vector<array>{out};
+}
+
+TEST_CASE("test compile gelu") {
+  {
+    auto cfun = compile(gelu_1);
+    auto x = array(1.0);
+    auto out = cfun({x})[0];
+    auto& p = out.primitive();
+    CHECK_EQ(typeid(p), typeid(Compiled));
+    CHECK_EQ(out.inputs().size(), 4);
+    for (auto& in : out.inputs()) {
+      CHECK(in.inputs().empty());
+    }
+    auto expected_out = gelu_1({x})[0];
+    CHECK(allclose(out, expected_out).item<bool>());
+  }
+
+  {
+    auto cfun = compile(gelu_1);
+    auto x = array({1.0, 0.5});
+    auto out = cfun({x})[0];
+    auto& p = out.primitive();
+    CHECK_EQ(typeid(p), typeid(Compiled));
+    CHECK_EQ(out.inputs().size(), 4);
+    for (auto& in : out.inputs()) {
+      CHECK(in.inputs().empty());
+    }
+
+    auto expected_out = gelu_1({x})[0];
+    CHECK(allclose(out, expected_out).item<bool>());
+  }
+}
+
+// Uncompilable input outside fused tape
+auto unary_with_two_outputs(const std::vector<array>& inputs) {
+  auto x = exp(inputs[0]);
+  return std::vector<array>{exp(x), sum(x, true)};
+}
+
+auto uncompilable_inputs(const std::vector<array>& inputs) {
+  auto& x = inputs[0];
+  auto& y = inputs[1];
+  return std::vector<array>{x * abs(exp(y)), sum(x, true)};
+}
+
+auto uncompilable_inputs_order_matters(const std::vector<array>& inputs) {
+  auto& x = inputs[0];
+  auto& y = inputs[1];
+  return std::vector<array>{x / abs(exp(y)), sum(x, true)};
+}
+
+TEST_CASE("test compile tape with outside parents") {
+  {
+    auto cfun = compile(unary_with_two_outputs);
+    auto x = array({2.0, 2.0});
+    auto out = cfun({x});
+
+    auto& p1 = out[0].primitive();
+    CHECK_EQ(typeid(p1), typeid(Exp));
+    auto& p2 = out[1].primitive();
+    CHECK_EQ(typeid(p2), typeid(Reduce));
+  }
+
+  {
+    auto cfun = compile(uncompilable_inputs);
+    auto x = array({2.0, 2.0});
+    auto y = array({1.6, 0.6});
+    auto outs = cfun({x, y});
+
+    auto& p1 = outs[0].primitive();
+    CHECK_EQ(typeid(p1), typeid(Compiled));
+    auto& p2 = outs[1].primitive();
+    CHECK_EQ(typeid(p2), typeid(Reduce));
+    CHECK_EQ(outs[0].inputs().size(), 2);
+
+    auto expected_outs = uncompilable_inputs({x, y});
+    CHECK(allclose(outs[0], expected_outs[0]).item<bool>());
+    CHECK(allclose(outs[1], expected_outs[1]).item<bool>());
+  }
+
+  {
+    auto cfun = compile(uncompilable_inputs_order_matters);
+    auto x = array({2.0, 2.0});
+    auto y = array({1.6, 0.6});
+    auto outs = cfun({x, y});
+
+    auto& p1 = outs[0].primitive();
+    CHECK_EQ(typeid(p1), typeid(Compiled));
+    auto& p2 = outs[1].primitive();
+    CHECK_EQ(typeid(p2), typeid(Reduce));
+    CHECK_EQ(outs[0].inputs().size(), 2);
+
+    auto expected_outs = uncompilable_inputs_order_matters({x, y});
+    CHECK(allclose(outs[0], expected_outs[0]).item<bool>());
+    CHECK(allclose(outs[1], expected_outs[1]).item<bool>());
+  }
+}
+
+auto compile_across_streams(const std::vector<array>& inputs) {
+  auto s2 = new_stream(default_device());
+  auto x = exp(abs(inputs[0]));
+  auto y = exp(abs(x, s2), s2);
+  return std::vector<array>{y};
+}
+
+TEST_CASE("test compile across streams") {
+  auto cfun = compile(compile_across_streams);
+  auto x = array({2.0f});
+  auto out = cfun({x})[0];
+  auto& p1 = out.primitive();
+  CHECK_EQ(typeid(p1), typeid(Compiled));
+  CHECK_EQ(out.inputs().size(), 1);
+  auto child = out.inputs()[0];
+  auto& p2 = child.primitive();
+  CHECK_EQ(typeid(p2), typeid(Compiled));
+  CHECK_EQ(child.inputs()[0].id(), x.id());
+}
+
+auto unary_compile_outputs(const std::vector<array>& inputs) {
+  auto x = abs(inputs[0]);
+  auto y = square(x);
+  return std::vector<array>{x, y};
+}
+
+auto binary_compile_outputs(const std::vector<array>& inputs) {
+  auto x = inputs[0];
+  auto y = inputs[1];
+  x = x + y;
+  y = x + y;
+  return std::vector<array>{x, y};
+}
+
+TEST_CASE("test compile internal output") {
+  {
+    auto cfun = compile(unary_compile_outputs);
+    auto x = array({3, -2});
+    auto outs = cfun({x});
+    auto& p1 = outs[0].primitive();
+    CHECK_EQ(typeid(p1), typeid(Compiled));
+    auto& p2 = outs[1].primitive();
+    CHECK_EQ(typeid(p2), typeid(Compiled));
+    CHECK_EQ(outs[0].siblings()[0].id(), outs[1].id());
+    auto expected_outs = unary_compile_outputs({x});
+    CHECK(array_equal(outs[0], expected_outs[0]).item<bool>());
+    CHECK(array_equal(outs[1], expected_outs[1]).item<bool>());
+  }
+
+  {
+    auto cfun = compile(binary_compile_outputs);
+    auto x = array({3, -2});
+    auto y = array({1, -1});
+    auto outs = cfun({x, y});
+    auto& p1 = outs[0].primitive();
+    CHECK_EQ(typeid(p1), typeid(Compiled));
+    auto& p2 = outs[1].primitive();
+    CHECK_EQ(typeid(p2), typeid(Compiled));
+    auto expected_outs = binary_compile_outputs({x, y});
+    CHECK(array_equal(outs[0], expected_outs[0]).item<bool>());
+    CHECK(array_equal(outs[1], expected_outs[1]).item<bool>());
+  }
+}
+
+auto deep_unary_compile(const std::vector<array>& inputs) {
+  auto x = inputs[0];
+  for (int i = 0; i < 10; ++i) {
+    x = cos(sin(x));
+  }
+  return std::vector<array>{x};
+}
+
+TEST_CASE("test compile deep graph") {
+  auto cfun = compile(deep_unary_compile);
+  auto x = array({3.0f, -2.0f});
+  auto out = cfun({x})[0];
+  auto expected_out = deep_unary_compile({x})[0];
+  CHECK(allclose(out, expected_out).item<bool>());
+}
+
+auto repeat_input_to_compiled(const std::vector<array>& inputs) {
+  auto x = abs(exp(inputs[0]));
+  auto y = abs(exp(sum(x)));
+  return std::vector<array>{x + y};
+}
+
+TEST_CASE("test compile repeat input") {
+  auto cfun = compile(repeat_input_to_compiled);
+  auto x = array({3.0f, -2.0f});
+  auto out = cfun({x})[0];
+  auto expected_out = repeat_input_to_compiled({x})[0];
+  CHECK(allclose(out, expected_out).item<bool>());
+}
+
+auto compile_unary_inner(const std::vector<array>& inputs) {
+  auto x = inputs[0];
+  return std::vector<array>{exp(exp(x))};
+}
+
+auto compile_unary_outer(const std::vector<array>& inputs) {
+  auto cfun = compile(compile_unary_inner);
+  return cfun(cfun(inputs));
+}
+
+TEST_CASE("test compile compiled function") {
+  auto cfun = compile(compile_unary_outer);
+  auto x = array({1.0f});
+  auto out = cfun({x})[0];
+  auto& p = out.primitive();
+  CHECK_EQ(typeid(p), typeid(Compiled));
+  CHECK_EQ(out.inputs()[0].id(), x.id());
+}
+
+auto grad_unary_compiled(const std::vector<array>& inputs) {
+  auto gradfn = value_and_grad(compile(compile_unary_inner));
+  auto [out, grad] = gradfn(inputs);
+  return std::vector{out[0], grad[0]};
+}
+
+TEST_CASE("test transform compiled function") {
+  auto cfun = compile(grad_unary_compiled);
+  auto x = array(1.0f);
+  auto outs = cfun({x});
+  auto& p = outs[0].primitive();
+  CHECK_EQ(typeid(p), typeid(Compiled));
+  CHECK_EQ(outs[0].siblings()[0].id(), outs[1].id());
+  CHECK(!outs[0].inputs()[0].has_primitive());
+  CHECK(!outs[0].inputs()[1].has_primitive());
+}
+
+TEST_CASE("test fusion kernel reuse") {
+  auto cfun = compile(gelu_1);
+  auto x = array({2.0f, -2.0f});
+  auto y = cfun({x})[0];
+  auto p = std::dynamic_pointer_cast<Compiled>(y.primitive_ptr());
+  eval(y);
+
+  std::string lib_name = p->lib_name();
+  CHECK(!lib_name.empty());
+
+  x = astype(reshape(arange(10), {2, 5}), float32);
+  auto z = cfun({x})[0];
+  auto pz = std::dynamic_pointer_cast<Compiled>(z.primitive_ptr());
+  eval(z);
+
+  std::string lib_name_z = pz->lib_name();
+  CHECK(!lib_name_z.empty());
+
+  CHECK_EQ(lib_name, lib_name_z);
+}
+
+auto add3(const std::vector<array>& xs) {
+  return std::vector<array>{xs[0] + xs[0] + xs[0]};
+}
+
+TEST_CASE("test fusion types") {
+  auto cfun = compile(add3);
+  auto x = array({2.0f, -2.0f});
+  auto y = cfun({x})[0];
+  auto p = std::dynamic_pointer_cast<Compiled>(y.primitive_ptr());
+  eval(y);
+
+  std::string lib_name = p->lib_name();
+  CHECK(!lib_name.empty());
+
+  x = array({2, -2}, int32);
+  auto z = cfun({x})[0];
+  auto pz = std::dynamic_pointer_cast<Compiled>(z.primitive_ptr());
+  eval(z);
+
+  std::string lib_name_z = pz->lib_name();
+  CHECK(!lib_name_z.empty());
+}
+
+auto compile_shapeless_not_ok(const std::vector<array>& inputs) {
+  auto x = reshape(inputs[0], {2, 2});
+  return std::vector<array>{x};
+}
+
+auto compile_shapeless_ok(const std::vector<array>& inputs) {
+  auto x = inputs[0] + array({2});
+  return std::vector<array>{x};
+}
+
+TEST_CASE("test shapeless compile") {
+  {
+    auto cfun = compile(compile_shapeless_not_ok, /* shapeless */ true);
+    cfun({array({1, 2, 3, 4})});
+    CHECK_THROWS(cfun({array({1, 2, 3, 4, 5})}));
+  }
+
+  {
+    auto cfun = compile(compile_shapeless_ok, /* shapeless */ true);
+    auto out = cfun({array({1, 2})})[0];
+    auto out2 = cfun({array({1, 2, 3, 4})})[0];
+
+    // Not making a new constant array since no recompile,
+    // hence the ids should be the same
+    CHECK_EQ(out.inputs()[1].id(), out2.inputs()[1].id());
+    CHECK(array_equal(out2, array({3, 4, 5, 6})).item<bool>());
+
+    // Recompile since type changes
+    out2 = cfun({array({1.0, 2.0})})[0];
+    CHECK_NE(out.inputs()[1].id(), out2.inputs()[1].id());
+
+    // Recompile since ndim changes
+    out2 = cfun({array({1.0, 2.0}, {1, 2})})[0];
+    CHECK_NE(out.inputs()[1].id(), out2.inputs()[1].id());
+  }
+}
+
+auto compile_broadcast_add(const std::vector<array>& inputs) {
+  auto b = zeros({8, 8});
+  return std::vector<array>{inputs[0] + b};
+}
+
+TEST_CASE("test compile strides") {
+  {
+    auto cfun = compile(compile_broadcast_add);
+    auto a = zeros({1, 8, 8});
+    auto out = cfun({a})[0];
+    eval(out);
+    CHECK_EQ(out.strides().size(), 3);
+  }
+}
+
+TEST_CASE("test compile change streams") {
+  auto cfun = compile(simple_fun);
+  auto out = cfun({array(1.0f), array(2.0f)})[0];
+  CHECK_EQ(out.primitive().stream(), default_stream(default_device()));
+
+  auto s = new_stream(default_device());
+  StreamContext sctx(s);
+  out = cfun({array(1.0f), array(2.0f)})[0];
+  CHECK_EQ(out.primitive().stream(), s);
+}
+
+TEST_CASE("test compile lambda") {
+  auto fun = [](const std::vector<array>& inputs) {
+    return std::vector<array>{abs(inputs[0])};
+  };
+
+  auto out = compile(fun)({array(-1)});
+  CHECK_EQ(out[0].item<int>(), 1);
+
+  decltype(compile(nullptr)) c_local_fun;
+  {
+    auto local_fun = [](const std::vector<array>& inputs) {
+      return std::vector<array>{abs(inputs[0])};
+    };
+    c_local_fun = compile(local_fun);
+  }
+
+  // This is ok even though local_fun is out of scope
+  out = c_local_fun({array(-1)});
+  CHECK_EQ(out[0].item<int>(), 1);
+
+  {
+    int x = 2;
+    auto local_fun = [x](const std::vector<array>& inputs) {
+      return std::vector<array>{inputs[0] + x};
+    };
+    c_local_fun = compile(local_fun);
+  }
+  // Also ok even though local_fun is out of scope.
+  out = c_local_fun({array(0)});
+  CHECK_EQ(out[0].item<int>(), 2);
+
+  int x = 2;
+  auto fun_with_capture = [&x](const std::vector<array>& inputs) {
+    return std::vector<array>{inputs[0] + x};
+  };
+  auto cfun = compile(fun_with_capture);
+  out = cfun({array(0)});
+  CHECK_EQ(out[0].item<int>(), 2);
+
+  // Doesn't recompile
+  x = 3;
+  out = cfun({array(0)});
+  CHECK_EQ(out[0].item<int>(), 2);
+
+  // Recompiles
+  auto cfun2 = compile(fun_with_capture);
+  out = cfun2({array(0)});
+  CHECK_EQ(out[0].item<int>(), 3);
+}
+
+TEST_CASE("test compile with no-ops") {
+  auto fun = [](const std::vector<array>& inputs) {
+    return std::vector<array>{abs(stop_gradient(abs(inputs[0])))};
+  };
+  auto in = array(1.0);
+  auto out = compile(fun)({in})[0];
+  CHECK_EQ(out.inputs()[0].id(), in.id());
+}
diff --git a/ml-stable-diffusion/mlx/tests/creations_tests.cpp b/ml-stable-diffusion/mlx/tests/creations_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ea43bd0e23f618972064ec1d6d0c1405def52ce0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/creations_tests.cpp
@@ -0,0 +1,239 @@
+// Copyright © 2023 Apple Inc.
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test arange") {
+  // Check type is inferred correctly
+  {
+    auto x = arange(10);
+    CHECK_EQ(x.dtype(), int32);
+
+    x = arange(10.0);
+    CHECK_EQ(x.dtype(), float32);
+
+    x = arange(10, float32);
+    CHECK_EQ(x.dtype(), float32);
+
+    x = arange(10, float16);
+    CHECK_EQ(x.dtype(), float16);
+
+    x = arange(10, bfloat16);
+    CHECK_EQ(x.dtype(), bfloat16);
+
+    x = arange(10.0, int32);
+    CHECK_EQ(x.dtype(), int32);
+
+    x = arange(0, 10);
+    CHECK_EQ(x.dtype(), int32);
+
+    x = arange(0.0, 10.0, int32);
+    CHECK_EQ(x.dtype(), int32);
+
+    x = arange(0.0, 10.0);
+    CHECK_EQ(x.dtype(), float32);
+
+    x = arange(0, 10, float32);
+    CHECK_EQ(x.dtype(), float32);
+
+    x = arange(0, 10, 0.1, float32);
+    CHECK_EQ(x.dtype(), float32);
+
+    x = arange(0.0, 10.0, 0.5, int32);
+    CHECK_EQ(x.dtype(), int32);
+
+    x = arange(10.0, uint32);
+    CHECK_EQ(x.dtype(), uint32);
+    x = arange(0.0, 10.0, uint32);
+    CHECK_EQ(x.dtype(), uint32);
+    x = arange(0.0, 10.0, 0.5, uint32);
+    CHECK_EQ(x.dtype(), uint32);
+
+    // arange unsupported for bool_
+    CHECK_THROWS_AS(arange(10, bool_), std::invalid_argument);
+  }
+
+  // Check correct sizes
+  {
+    auto x = arange(10);
+    CHECK_EQ(x.size(), 10);
+
+    x = arange(0.0, 10.0, 0.5);
+    CHECK_EQ(x.size(), 20);
+
+    x = arange(0.0, 10.0, 0.45);
+    CHECK_EQ(x.size(), 23);
+
+    x = arange(0, 10, 10);
+    CHECK_EQ(x.size(), 1);
+
+    x = arange(0, 10, 9);
+    CHECK_EQ(x.size(), 2);
+
+    x = arange(0, 10, 100);
+    CHECK_EQ(x.size(), 1);
+
+    x = arange(0, -10, 1);
+    CHECK_EQ(x.size(), 0);
+
+    x = arange(0, -10, -1);
+    CHECK_EQ(x.size(), 10);
+
+    x = arange(0, -10, -10);
+    CHECK_EQ(x.size(), 1);
+  }
+
+  // Check values
+  {
+    auto x = arange(0, 3);
+    CHECK(array_equal(x, array({0, 1, 2})).item<bool>());
+
+    x = arange(0, 3, 2);
+    CHECK(array_equal(x, array({0, 2})).item<bool>());
+
+    x = arange(0, 3, 3);
+    CHECK(array_equal(x, array({0})).item<bool>());
+
+    x = arange(0, -3, 1);
+    CHECK(array_equal(x, array({})).item<bool>());
+
+    x = arange(0, 3, -1);
+    CHECK(array_equal(x, array({})).item<bool>());
+
+    x = arange(0, -3, -1);
+    CHECK(array_equal(x, array({0, -1, -2})).item<bool>());
+
+    x = arange(0.0, 5.0, 0.5, int32);
+    CHECK(array_equal(x, zeros({10})).item<bool>());
+
+    x = arange(0.0, 5.0, 1.5, int32);
+    CHECK(array_equal(x, array({0, 1, 2, 3})).item<bool>());
+
+    x = arange(0.0, 5.0, 1.0, float16);
+    CHECK(array_equal(x, array({0, 1, 2, 3, 4}, float16)).item<bool>());
+
+    x = arange(0.0, 5.0, 1.0, bfloat16);
+    CHECK(array_equal(x, array({0, 1, 2, 3, 4}, bfloat16)).item<bool>());
+
+    x = arange(0.0, 5.0, 1.5, bfloat16);
+    CHECK(array_equal(x, array({0., 1.5, 3., 4.5}, bfloat16)).item<bool>());
+  }
+}
+
+TEST_CASE("test astype") {
+  // Check type conversions
+  {
+    auto x = array(1);
+    auto y = astype(x, float32);
+    CHECK_EQ(y.dtype(), float32);
+    CHECK_EQ(y.item<float>(), 1.0f);
+
+    y = astype(x, int32);
+    CHECK_EQ(y.dtype(), int32);
+    CHECK_EQ(y.item<int>(), 1);
+
+    x = array(-3.0f);
+    y = astype(x, int32);
+    CHECK_EQ(y.dtype(), int32);
+    CHECK_EQ(y.item<int>(), -3);
+  }
+}
+
+TEST_CASE("test full") {
+  // Check throws on bad shape
+  {
+    CHECK_THROWS(full({-5, 0}, 0));
+    CHECK_THROWS(full({0, -5}, 0));
+  }
+
+  // Check full works for different types
+  {
+    auto x = full({}, 0);
+    CHECK_EQ(x.dtype(), int32);
+    CHECK_EQ(x.item<int>(), 0);
+
+    x = full({}, 0.0);
+    CHECK_EQ(x.dtype(), float32);
+    CHECK_EQ(x.item<float>(), 0);
+
+    x = full({}, false);
+    CHECK_EQ(x.item<bool>(), false);
+
+    x = full({}, 0, int32);
+    CHECK_EQ(x.item<int>(), 0);
+
+    x = full({}, 0, float32);
+    CHECK_EQ(x.item<float>(), 0);
+
+    x = full({1, 2}, 2, float32);
+    CHECK(array_equal(x, array({2.0, 2.0}, {1, 2})).item<bool>());
+
+    x = full({2, 1}, 2, float32);
+    CHECK(array_equal(x, array({2.0, 2.0}, {2, 1})).item<bool>());
+
+    x = full({2}, false);
+    CHECK_EQ(x.dtype(), bool_);
+    CHECK(array_equal(x, array({false, false})).item<bool>());
+
+    x = full({2}, 1.0, bool_);
+    CHECK_EQ(x.dtype(), bool_);
+    CHECK(array_equal(x, array({true, true})).item<bool>());
+
+    x = full({2}, 1.0, uint32);
+    CHECK_EQ(x.dtype(), uint32);
+    CHECK(array_equal(x, array({1, 1})).item<bool>());
+
+    CHECK_THROWS_AS(full({2}, array({})), std::invalid_argument);
+  }
+
+  // Check broadcasting works
+  {
+    auto x = full({2, 2}, array({3, 4}, {2, 1}));
+    CHECK(array_equal(x, array({3, 3, 4, 4}, {2, 2})).item<bool>());
+    x = full({2, 2}, array({3, 4}, {1, 2}));
+    CHECK(array_equal(x, array({3, 4, 3, 4}, {2, 2})).item<bool>());
+  }
+
+  // Check zeros and ones
+  {
+    auto x = zeros({2, 2}, float32);
+    CHECK_EQ(x.shape(), Shape{2, 2});
+    CHECK_EQ(x.ndim(), 2);
+    CHECK_EQ(x.dtype(), float32);
+    auto y = array({0.0, 0.0, 0.0, 0.0}, {2, 2});
+    CHECK(array_equal(x, y).item<bool>());
+
+    x = ones({2, 2}, float32);
+    CHECK_EQ(x.shape(), Shape{2, 2});
+    CHECK_EQ(x.ndim(), 2);
+    CHECK_EQ(x.dtype(), float32);
+    y = array({1.0, 1.0, 1.0, 1.0}, {2, 2});
+    CHECK(array_equal(x, y).item<bool>());
+
+    x = zeros({2, 2}, int32);
+    y = zeros_like(x);
+    CHECK_EQ(y.dtype(), int32);
+    CHECK(array_equal(x, y).item<bool>());
+
+    x = ones({2, 2}, int32);
+    y = ones_like(x);
+    CHECK_EQ(y.dtype(), int32);
+    CHECK(array_equal(x, y).item<bool>());
+  }
+
+  // Works for empty shape and empty array
+  {
+    array x = ones({}, int32);
+    CHECK_EQ(x.shape(), Shape{});
+    CHECK_EQ(x.item<int>(), 1);
+
+    x = full({0}, array({}));
+    CHECK_EQ(x.shape(), Shape{0});
+    CHECK_EQ(x.size(), 0);
+
+    CHECK_THROWS_AS(full({}, array({})), std::invalid_argument);
+  }
+}
diff --git a/ml-stable-diffusion/mlx/tests/custom_vjp_tests.cpp b/ml-stable-diffusion/mlx/tests/custom_vjp_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e0b4029be2c35a345d8450527d502d616cd6c142
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/custom_vjp_tests.cpp
@@ -0,0 +1,55 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test simple custom vjp") {
+  auto one = array(1.0);
+  auto x = array(2.0);
+  auto y = array(3.0);
+
+  auto fn = [](const std::vector<array>& inputs) {
+    return std::vector<array>{inputs[0] * inputs[1], inputs[0] + inputs[1]};
+  };
+  auto transformed_fn = custom_vjp(
+      fn,
+      [&](const std::vector<array>&,
+          const std::vector<array>&,
+          const std::vector<array>&) { return std::vector<array>{one, one}; });
+
+  auto [z, g] = vjp(fn, {x, y}, {one, one});
+  CHECK_EQ(z[0].item<float>(), 6.0f);
+  CHECK_EQ(z[1].item<float>(), 5.0f);
+  CHECK_EQ(g[0].item<float>(), 4.0f);
+  CHECK_EQ(g[1].item<float>(), 3.0f);
+
+  std::tie(z, g) = vjp(transformed_fn, {x, y}, {one, one});
+  CHECK_EQ(z[0].item<float>(), 6.0f);
+  CHECK_EQ(z[1].item<float>(), 5.0f);
+  CHECK_EQ(g[0].item<float>(), 1.0f);
+  CHECK_EQ(g[1].item<float>(), 1.0f);
+}
+
+TEST_CASE("test checkpointing") {
+  auto one = array(1.0);
+  auto x = array(2.0);
+  auto y = array(3.0);
+
+  int cnt = 0;
+  auto fn = [&cnt](const std::vector<array>& inputs) {
+    cnt++;
+    auto x = inputs[0] * inputs[1];
+    auto y = inputs[0] + inputs[1];
+    return std::vector<array>{square(x + y)};
+  };
+  auto checkpointed_fn = checkpoint(fn);
+
+  auto [z, g] = vjp(checkpointed_fn, {x, y}, {one});
+  CHECK_EQ(z[0].item<float>(), 121.0f);
+  CHECK_EQ(g[0].item<float>(), 88.0f);
+  CHECK_EQ(g[1].item<float>(), 66.0f);
+  CHECK_EQ(cnt, 2);
+}
diff --git a/ml-stable-diffusion/mlx/tests/device_tests.cpp b/ml-stable-diffusion/mlx/tests/device_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7bae91d88d6e6999de0f827cfa211ab521b956b5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/device_tests.cpp
@@ -0,0 +1,35 @@
+// Copyright © 2023 Apple Inc.
+
+#include "doctest/doctest.h"
+
+#include <cstdlib>
+
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test device placement") {
+  auto device = default_device();
+  Device d = gpu::is_available() ? Device::gpu : Device::cpu;
+  if (std::getenv("DEVICE") == nullptr) {
+    CHECK_EQ(device, d);
+  }
+
+  array x(1.0f);
+  array y(1.0f);
+  auto z = add(x, y, default_device());
+  if (gpu::is_available()) {
+    z = add(x, y, Device::gpu);
+    z = add(x, y, Device(Device::gpu, 0));
+  } else {
+    CHECK_THROWS_AS(set_default_device(Device::gpu), std::invalid_argument);
+    CHECK_THROWS_AS(add(x, y, Device::gpu), std::invalid_argument);
+  }
+
+  // Set the default device to the CPU
+  set_default_device(Device::cpu);
+  CHECK_EQ(default_device(), Device::cpu);
+
+  // Revert
+  set_default_device(device);
+}
diff --git a/ml-stable-diffusion/mlx/tests/einsum_tests.cpp b/ml-stable-diffusion/mlx/tests/einsum_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..834d533cf0fbbb79f2c067dcf9ac7e13c917c11f
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/einsum_tests.cpp
@@ -0,0 +1,76 @@
+// Copyright © 2024 Apple Inc.
+
+#include "doctest/doctest.h"
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test einsum path") {
+  std::vector<std::vector<int>> expected = {{1, 2}, {0, 1}};
+  auto path =
+      einsum_path("ij,jk,kl", {ones({2, 2}), ones({2, 4}), ones({4, 2})}).first;
+  CHECK_EQ(path, expected);
+
+  expected = {{0}};
+  path = einsum_path("jki", {ones({2, 3, 4})}).first;
+  CHECK_EQ(path, expected);
+
+  expected = {{0, 1}};
+  path = einsum_path("i,i", {ones({2}), ones({1})}).first;
+  CHECK_EQ(path, expected);
+
+  expected = {{0, 1}};
+  path = einsum_path("ij,jk", {ones({2, 2}), ones({2, 2})}).first;
+  CHECK_EQ(path, expected);
+
+  expected = {{0, 1}};
+  path = einsum_path("ijk,jil->kl", {ones({3, 4, 5}), ones({4, 3, 2})}).first;
+  CHECK_EQ(path, expected);
+
+  expected = {{0, 3}, {1, 3}, {0, 2}, {0, 1}};
+  path = einsum_path(
+             "ijk,ilm,njm,nlk,abc->",
+             {ones({2, 6, 8}),
+              ones({2, 4, 5}),
+              ones({3, 6, 5}),
+              ones({3, 4, 8}),
+              ones({9, 4, 7})})
+             .first;
+  CHECK_EQ(path, expected);
+
+  expected = {{0, 2}, {0, 3}, {0, 2}, {0, 1}};
+  path = einsum_path(
+             "ea,fb,abcd,gc,hd->efgh",
+             {ones({10, 10}),
+              ones({10, 10}),
+              ones({10, 10, 10, 10}),
+              ones({10, 10}),
+              ones({10, 10})})
+             .first;
+  CHECK_EQ(path, expected);
+}
+
+TEST_CASE("test einsum") {
+  CHECK_THROWS(einsum("i,j", {array({1.0})}));
+  CHECK_THROWS(einsum("ijk", {full({2, 2}, 2.0f)}));
+  CHECK_THROWS(einsum("", {}));
+  CHECK_THROWS(einsum("ij", {array({1, 2})}));
+  CHECK_THROWS(einsum("", {array({1, 2})}));
+  CHECK_THROWS(einsum("i,ij", {array({1, 2}), array({2, 3})}));
+  CHECK_THROWS(einsum("i,i", {array({1, 2}), array({2, 3, 4})}));
+  CHECK_THROWS(einsum("i->ii", {array({1, 2})}));
+  CHECK_THROWS(einsum("12", {zeros({4, 4})}));
+  CHECK_THROWS(einsum("ii->i", {zeros({3, 2})}));
+
+  auto x = einsum("jki", {full({2, 3, 4}, 3.0f)});
+  auto expected = full({4, 2, 3}, 3.0f);
+  CHECK_EQ(allclose(x, expected).item<bool>(), true);
+
+  x = einsum("ij,jk->ik", {full({2, 2}, 2.0f), full({2, 2}, 3.0f)});
+  expected = array({12.0f, 12.0f, 12.0f, 12.0f}, {2, 2});
+  CHECK_EQ(allclose(x, expected).item<bool>(), true);
+
+  x = einsum("i,j->ij", {full({2}, 15.0f), full({4}, 20.0f)});
+  expected = full({2, 4}, 300.0f);
+  CHECK_EQ(allclose(x, expected).item<bool>(), true);
+}
diff --git a/ml-stable-diffusion/mlx/tests/eval_tests.cpp b/ml-stable-diffusion/mlx/tests/eval_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ce4bc980f58e66473aee53b86cc46784a16b2189
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/eval_tests.cpp
@@ -0,0 +1,93 @@
+// Copyright © 2023 Apple Inc.
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test eval") {
+  {
+    array x(1.0);
+    array y(1);
+    array z(true);
+    eval({x, y, z});
+    CHECK_EQ(x.item<float>(), 1.0);
+  }
+
+  {
+    array x(1.0);
+    array y = ones({2, 2});
+    array z(true);
+    eval({x, y, z});
+    CHECK(array_equal(y, array({1.0, 1.0, 1.0, 1.0}, {2, 2})).item<bool>());
+  }
+}
+
+TEST_CASE("test eval multiple") {
+  auto x = ones({10, 10});
+  auto y = ones({10, 10});
+  eval({x, y});
+  CHECK(array_equal(x, y).item<bool>());
+
+  auto a = x + y;
+  auto b = x - y;
+  eval({a, b});
+  CHECK(array_equal(a, full({10, 10}, 2.0f)).item<bool>());
+  CHECK(array_equal(b, full({10, 10}, 0.0f)).item<bool>());
+
+  x = ones({10, 10});
+  y = ones({10, 10});
+  eval(x, y);
+  CHECK(array_equal(x, y).item<bool>());
+
+  a = x + y;
+  b = x - y;
+  eval(a, b);
+  CHECK(array_equal(a, full({10, 10}, 2.0f)).item<bool>());
+  CHECK(array_equal(b, full({10, 10}, 0.0f)).item<bool>());
+}
+
+TEST_CASE("test eval with tracer when not tracing") {
+  // Since we are not tracing it doesn't matter that the array flags are
+  // tracers they will always be detached.
+  auto x = array(1);
+  x.set_tracer(true);
+  CHECK(!x.is_tracer());
+  eval(x);
+  CHECK(!x.has_primitive());
+  CHECK(x.is_available());
+
+  x = ones({2, 3});
+  x.set_tracer(true);
+  eval(x);
+  CHECK(!x.has_primitive());
+  CHECK(x.is_available());
+}
+
+TEST_CASE("test eval graph retention when not tracing") {
+  // Since we are not tracing it doesn't matter that the array flags are
+  // tracers they will always be detached.
+  auto x = array(1);
+  x.set_tracer(true);
+  auto y = array(2);
+  auto z = x + y;
+  eval(z);
+  CHECK(!z.has_primitive());
+  CHECK(z.is_available());
+  CHECK_EQ(z.item<int>(), 3);
+
+  z.set_tracer(false);
+  CHECK_EQ(z.item<int>(), 3);
+  CHECK(!z.has_primitive());
+  CHECK(z.is_available());
+
+  z = x + y;
+  auto a = z + x;
+  auto b = a + y;
+  eval(b);
+  CHECK(!z.has_primitive());
+  CHECK(z.is_available());
+  CHECK(!a.has_primitive());
+  CHECK(a.is_available());
+}
diff --git a/ml-stable-diffusion/mlx/tests/export_import_tests.cpp b/ml-stable-diffusion/mlx/tests/export_import_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ad2c640d88abddb63bc0dac0686f35338b51b75
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/export_import_tests.cpp
@@ -0,0 +1,164 @@
+// Copyright © 2024 Apple Inc.
+
+#include <filesystem>
+#include <stdexcept>
+#include <vector>
+
+#include "doctest/doctest.h"
+
+#include "mlx/export.h"
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+namespace {
+std::string get_temp_file(const std::string& name) {
+  return std::filesystem::temp_directory_path().append(name).string();
+}
+} // namespace
+
+TEST_CASE("test export basic functions") {
+  std::string file_path = get_temp_file("model.mlxfn");
+
+  auto fun = [](std::vector<array> x) -> std::vector<array> {
+    return {negative(exp(x[0]))};
+  };
+
+  export_function(file_path, fun, {array({1.0, 2.0})});
+
+  auto imported_fun = import_function(file_path);
+
+  // Check num inputs mismatch throws
+  CHECK_THROWS_AS(
+      imported_fun({array({1.0}), array({2.0})}), std::invalid_argument);
+
+  // Check shape mismatch throws
+  CHECK_THROWS_AS(imported_fun({array({1.0})}), std::invalid_argument);
+
+  // Check type mismatch throws
+  CHECK_THROWS_AS(imported_fun({array({1.0}, float16)}), std::invalid_argument);
+
+  auto expected = fun({array({1.0, -1.0})});
+  auto out = imported_fun({array({1.0, -1.0})});
+  CHECK(allclose(expected[0], out[0]).item<bool>());
+}
+
+TEST_CASE("test export function with no inputs") {
+  auto fun = [](std::vector<array> x) -> std::vector<array> {
+    return {zeros({2, 2})};
+  };
+
+  std::string file_path = get_temp_file("model.mlxfn");
+
+  export_function(file_path, fun, {});
+
+  auto imported_fun = import_function(file_path);
+
+  auto expected = fun({});
+  auto out = imported_fun({});
+  CHECK(allclose(expected[0], out[0]).item<bool>());
+}
+
+TEST_CASE("test export multi output primitives") {
+  std::string file_path = get_temp_file("model.mlxfn");
+
+  auto fun = [](std::vector<array> x) -> std::vector<array> {
+    return {divmod(x[0], x[1])};
+  };
+
+  auto inputs = std::vector<array>{array({5.0, -10.0}), array({3.0, -2.0})};
+  export_function(file_path, fun, inputs);
+
+  auto imported_fun = import_function(file_path);
+
+  auto expected = fun(inputs);
+  auto out = imported_fun(inputs);
+  CHECK(allclose(expected[0], out[0]).item<bool>());
+  CHECK(allclose(expected[1], out[1]).item<bool>());
+}
+
+TEST_CASE("test export primitives with state") {
+  std::string file_path = get_temp_file("model.mlxfn");
+
+  auto fun = [](std::vector<array> x) -> std::vector<array> {
+    return {argpartition(x[0], 2, 0)};
+  };
+
+  auto x = array({1, 3, 2, 4, 5, 7, 6, 8}, {4, 2});
+  export_function(file_path, fun, {x});
+
+  auto imported_fun = import_function(file_path);
+
+  auto expected = fun({x});
+  auto out = imported_fun({x});
+  CHECK(allclose(expected[0], out[0]).item<bool>());
+}
+
+TEST_CASE("test export functions with kwargs") {
+  std::string file_path = get_temp_file("model.mlxfn");
+
+  auto fun = [](const Kwargs& kwargs) -> std::vector<array> {
+    return {kwargs.at("x") + kwargs.at("y")};
+  };
+
+  export_function(file_path, fun, {{"x", array(1)}, {"y", array(2)}});
+  auto fn = import_function(file_path);
+
+  // Must use kwargs
+  CHECK_THROWS(fn({array(1), array(2)}));
+
+  // Wrong number of keys
+  CHECK_THROWS(fn({{"x", array(1)}, {"y", array(2)}, {"z", array(3)}}));
+
+  // Wrong keys
+  CHECK_THROWS(fn({{"a", array(1)}, {"b", array(2)}}));
+
+  // Works
+  auto out = fn({{"x", array(1)}, {"y", array(2)}})[0];
+  CHECK_EQ(out.item<int>(), 3);
+  out = fn({}, {{"x", array(1)}, {"y", array(2)}})[0];
+  CHECK_EQ(out.item<int>(), 3);
+}
+
+TEST_CASE("test export function with variable inputs") {
+  std::string file_path = get_temp_file("model.mlxfn");
+
+  auto fun = [](const std::vector<array>& args) -> std::vector<array> {
+    auto out = array({1, 1, 1, 1});
+    for (auto x : args) {
+      out = out + x;
+    }
+    return {out};
+  };
+
+  {
+    auto fn_exporter = exporter(file_path, fun);
+    fn_exporter({array(0), array(0)});
+    fn_exporter({array(0), array(0), array(0)});
+  }
+
+  auto imported_fun = import_function(file_path);
+
+  // Call with two inputs
+  auto out = imported_fun({array(1), array(2)})[0];
+
+  CHECK(array_equal(out, array({4, 4, 4, 4})).item<bool>());
+
+  // Call with three inputs
+  out = imported_fun({array(1), array(2), array(3)})[0];
+  CHECK(array_equal(out, array({7, 7, 7, 7})).item<bool>());
+}
+
+TEST_CASE("test export function on different stream") {
+  std::string file_path = get_temp_file("model.mlxfn");
+
+  // Caller is responsible for setting up streams before
+  // importing functoins
+  auto fun = [](const std::vector<array>& args) -> std::vector<array> {
+    return {abs(args[0], Stream(1000, Device::cpu))};
+  };
+
+  export_function(file_path, fun, {array({0, 1, 2})});
+
+  CHECK_THROWS(import_function(file_path));
+}
diff --git a/ml-stable-diffusion/mlx/tests/fft_tests.cpp b/ml-stable-diffusion/mlx/tests/fft_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b9e2d1bcc0ad62ef62feb0e6fa4a9afb458a62d5
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/fft_tests.cpp
@@ -0,0 +1,366 @@
+// Copyright © 2023 Apple Inc.
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test fft basics") {
+  array x(1.0);
+  CHECK_THROWS(fft::fft(x));
+  CHECK_THROWS(fft::ifft(x));
+
+  x = array({1.0});
+  auto y = fft::fft(x);
+  CHECK_EQ(y.dtype(), complex64);
+  CHECK_EQ(y.size(), x.size());
+  CHECK_EQ(y.item<complex64_t>(), complex64_t{1.0f, 0.0f});
+
+  y = fft::ifft(x);
+  CHECK_EQ(y.dtype(), complex64);
+  CHECK_EQ(y.size(), x.size());
+  CHECK_EQ(y.item<complex64_t>(), complex64_t{1.0f, 0.0f});
+
+  x = array({complex64_t{1.0f, 1.0f}}, complex64);
+  y = fft::fft(x);
+  CHECK_EQ(y.size(), x.size());
+  CHECK_EQ(y.item<complex64_t>(), complex64_t{1.0f, 1.0f});
+
+  y = fft::ifft(x);
+  CHECK_EQ(y.dtype(), complex64);
+  CHECK_EQ(y.size(), x.size());
+  CHECK_EQ(y.item<complex64_t>(), complex64_t{1.0f, 1.0f});
+
+  {
+    x = array({0.0f, 1.0f, 2.0f, 3.0f});
+    y = fft::fft(x);
+    std::initializer_list<complex64_t> expected = {
+        {6.0, 0.0},
+        {-2.0, 2.0},
+        {-2.0, 0.0},
+        {-2.0, -2.0},
+    };
+    CHECK_EQ(y.size(), x.size());
+    CHECK(array_equal(y, array(expected)).item<bool>());
+
+    y = fft::ifft(x);
+    std::initializer_list<complex64_t> expected_inv = {
+        {1.5, 0.0},
+        {-0.5, -0.5},
+        {-0.5, 0.0},
+        {-0.5, 0.5},
+    };
+    CHECK(array_equal(y, array(expected_inv)).item<bool>());
+  }
+
+  {
+    std::initializer_list<complex64_t> vals = {
+        {1.0f, 1.0f}, {2.0f, 1.0f}, {1.0f, 2.0f}, {2.0f, 2.0f}};
+    x = array(vals);
+    y = fft::fft(x);
+    std::initializer_list<complex64_t> expected = {
+        {6.0, 6.0},
+        {-1.0, -1.0},
+        {-2.0, 0.0},
+        {1.0, -1.0},
+    };
+    CHECK_EQ(y.size(), x.size());
+    CHECK(array_equal(y, array(expected)).item<bool>());
+    CHECK(array_equal(fft::ifft(y), x).item<bool>());
+  }
+
+  // Specify axes
+  {
+    x = array({0.0f, 1.0f, 2.0f, 3.0f}, {2, 2});
+    std::initializer_list<complex64_t> expected_0 = {
+        {2.0, 0.0},
+        {4.0, 0.0},
+        {-2.0, 0.0},
+        {-2.0, 0.0},
+    };
+    y = fft::fft(x, 0);
+    CHECK(array_equal(y, array(expected_0, {2, 2})).item<bool>());
+    CHECK(array_equal(fft::ifft(y, 0), x).item<bool>());
+    std::initializer_list<complex64_t> expected_1 = {
+        {1.0, 0.0},
+        {-1.0, 0.0},
+        {5.0, 0.0},
+        {-1.0, 0.0},
+    };
+    y = fft::fft(x, 1);
+    CHECK(array_equal(y, array(expected_1, {2, 2})).item<bool>());
+    CHECK(array_equal(fft::ifft(y, 1), x).item<bool>());
+  }
+}
+
+TEST_CASE("test real ffts") {
+  auto x = array({1.0});
+  auto y = fft::rfft(x);
+  CHECK_EQ(y.dtype(), complex64);
+  CHECK_EQ(y.size(), x.size());
+  CHECK_EQ(y.item<complex64_t>(), complex64_t{1.0f, 0.0f});
+
+  {
+    x = array({0.0f, 1.0f, 2.0f, 3.0f});
+    y = fft::rfft(x);
+    std::initializer_list<complex64_t> expected = {
+        {6.0, 0.0}, {-2.0, 2.0}, {-2.0, -0.0}};
+    CHECK_EQ(y.size(), x.size() / 2 + 1);
+    CHECK(array_equal(y, array(expected)).item<bool>());
+  }
+
+  x = array(complex64_t{1, 1});
+  CHECK_THROWS(fft::irfft(x));
+
+  x = array({complex64_t{0, 1}, complex64_t{1, 0}});
+  y = fft::irfft(x);
+  CHECK_EQ(y.size(), 2);
+  CHECK_EQ(y.dtype(), float32);
+  CHECK(array_equal(y, array({0.5f, -0.5f})).item<bool>());
+}
+
+TEST_CASE("test fftn") {
+  auto x = zeros({5, 5, 5});
+  CHECK_THROWS_AS(fft::fftn(x, {}, {0, 3}), std::invalid_argument);
+  CHECK_THROWS_AS(fft::fftn(x, {}, {0, -4}), std::invalid_argument);
+  CHECK_THROWS_AS(fft::fftn(x, {}, {0, 0}), std::invalid_argument);
+  CHECK_THROWS_AS(fft::fftn(x, {5, 5, 5}, {0}), std::invalid_argument);
+  CHECK_THROWS_AS(fft::fftn(x, {0}, {}, {}), std::invalid_argument);
+  CHECK_THROWS_AS(fft::fftn(x, {1, -1}, {}, {}), std::invalid_argument);
+
+  // Test 2D FFT
+  {
+    x = array({0.0f, 1.0f, 2.0f, 3.0f}, {2, 2});
+    std::initializer_list<complex64_t> expected = {
+        {6.0, 0.0},
+        {-2.0, 0.0},
+        {-4.0, 0.0},
+        {0.0, 0.0},
+    };
+    auto y = fft::fft2(x);
+    CHECK(array_equal(y, array(expected, {2, 2})).item<bool>());
+    CHECK(array_equal(fft::ifft2(y), x).item<bool>());
+  }
+
+  // Test 3D FFT
+  {
+    x = reshape(arange(8, float32), {2, 2, 2});
+    std::initializer_list<complex64_t> expected = {
+        {28.0, 0.0},
+        {-4.0, 0.0},
+        {-8.0, 0.0},
+        {0.0, 0.0},
+        {-16.0, 0.0},
+        {0.0, 0.0},
+        {0.0, 0.0},
+        {0.0, 0.0},
+    };
+    auto y = fft::fftn(x);
+    CHECK(array_equal(y, array(expected, {2, 2, 2})).item<bool>());
+    CHECK(array_equal(fft::ifftn(y), x).item<bool>());
+
+    x = reshape(arange(20, float32), {5, 4});
+    y = fft::rfftn(x);
+    CHECK_EQ(y.shape(), Shape{5, 3});
+    y = fft::rfftn(x, {1, 0});
+    CHECK_EQ(y.shape(), Shape{3, 4});
+
+    x = reshape(arange(20, float32), {5, 4});
+    y = fft::irfftn(x);
+    CHECK_EQ(y.shape(), Shape{5, 6});
+    y = fft::irfftn(x, {1, 0});
+    CHECK_EQ(y.shape(), Shape{8, 4});
+  }
+
+  // Check the types of real ffts
+  {
+    x = zeros({5, 5}, float32);
+    auto y = fft::rfft2(x);
+    CHECK_EQ(y.shape(), Shape{5, 3});
+    CHECK_EQ(y.dtype(), complex64);
+
+    y = fft::rfftn(x);
+    CHECK_EQ(y.shape(), Shape{5, 3});
+    CHECK_EQ(y.dtype(), complex64);
+
+    x = zeros({5, 5}, complex64);
+    y = fft::irfft2(x);
+    CHECK_EQ(y.shape(), Shape{5, 8});
+    CHECK_EQ(y.dtype(), float32);
+
+    y = fft::irfftn(x);
+    CHECK_EQ(y.shape(), Shape{5, 8});
+    CHECK_EQ(y.dtype(), float32);
+  }
+}
+
+TEST_CASE("test fft with provided shape") {
+  auto x = ones({5, 5});
+
+  auto y = fft::fft(x, 7, 0);
+  CHECK_EQ(y.shape(), Shape{7, 5});
+
+  y = fft::fft(x, 3, 0);
+  CHECK_EQ(y.shape(), Shape{3, 5});
+
+  y = fft::fft(x, 7, 1);
+  CHECK_EQ(y.shape(), Shape{5, 7});
+
+  y = fft::fft(x, 3, 1);
+  CHECK_EQ(y.shape(), Shape{5, 3});
+
+  y = fft::rfft(x, 7, 0);
+  CHECK_EQ(y.shape(), Shape{4, 5});
+
+  y = fft::rfft(x, 3, 0);
+  CHECK_EQ(y.shape(), Shape{2, 5});
+
+  y = fft::rfft(x, 3, 1);
+  CHECK_EQ(y.shape(), Shape{5, 2});
+}
+
+TEST_CASE("test fft vmap") {
+  auto fft_fn = [](array x) { return fft::fft(x); };
+  auto x = reshape(arange(8), {2, 4});
+  auto y = vmap(fft_fn)(x);
+  CHECK(array_equal(y, fft::fft(x)).item<bool>());
+
+  y = vmap(fft_fn, 1, 1)(x);
+  CHECK(array_equal(y, fft::fft(x, 0)).item<bool>());
+
+  auto rfft_fn = [](array x) { return fft::rfft(x); };
+
+  y = vmap(rfft_fn)(x);
+  CHECK(array_equal(y, fft::rfft(x)).item<bool>());
+
+  y = vmap(rfft_fn, 1, 1)(x);
+  CHECK(array_equal(y, fft::rfft(x, 0)).item<bool>());
+}
+
+TEST_CASE("test fft grads") {
+  // Regular
+  auto fft_fn = [](array x) { return fft::fft(x); };
+  auto cotangent = astype(arange(10), complex64);
+  auto vjp_out = vjp(fft_fn, zeros_like(cotangent), cotangent).second;
+  CHECK(array_equal(fft::ifft(cotangent) * 10, vjp_out).item<bool>());
+
+  auto tangent = astype(arange(10), complex64);
+  auto jvp_out = jvp(fft_fn, zeros_like(tangent), tangent).second;
+  CHECK(array_equal(fft::fft(tangent), jvp_out).item<bool>());
+
+  // Inverse
+  auto ifft_fn = [](array x) { return fft::ifft(x); };
+  vjp_out = vjp(ifft_fn, zeros_like(cotangent), cotangent).second;
+  CHECK(array_equal(fft::fft(cotangent) * 0.1, vjp_out).item<bool>());
+
+  jvp_out = jvp(ifft_fn, zeros_like(tangent), tangent).second;
+  CHECK(array_equal(fft::ifft(tangent), jvp_out).item<bool>());
+
+  // Real
+  auto rfft_fn = [](array x) { return fft::rfft(x); };
+  cotangent = astype(arange(6), complex64);
+  vjp_out = vjp(rfft_fn, zeros({10}), cotangent).second;
+  array mask({1.0, 0.5, 0.5, 0.5, 0.5, 1.0}, complex64);
+  auto expected = fft::irfft(cotangent * mask, 10, 0) * 10;
+  CHECK(array_equal(expected, vjp_out).item<bool>());
+
+  tangent = astype(arange(10), float32);
+  jvp_out = jvp(rfft_fn, zeros_like(tangent), tangent).second;
+  CHECK(array_equal(fft::rfft(tangent), jvp_out).item<bool>());
+
+  // Inverse real
+  auto irfft_fn = [](array x) { return fft::irfft(x); };
+  cotangent = astype(arange(10), float32);
+  vjp_out = vjp(irfft_fn, astype(zeros({6}), complex64), cotangent).second;
+  mask = array({0.1, 0.2, 0.2, 0.2, 0.2, 0.1}, float32);
+  expected = fft::rfft(cotangent) * mask;
+  CHECK(array_equal(expected, vjp_out).item<bool>());
+
+  tangent = astype(arange(10), complex64);
+  jvp_out = jvp(irfft_fn, zeros_like(tangent), tangent).second;
+  CHECK(array_equal(fft::irfft(tangent), jvp_out).item<bool>());
+
+  // Check ND vjps run properly
+  vjp_out = vjp([](array x) { return fft::fftn(x); },
+                astype(zeros({5, 5}), complex64),
+                astype(zeros({5, 5}), complex64))
+                .second;
+  CHECK_EQ(vjp_out.shape(), Shape{5, 5});
+
+  vjp_out = vjp([](array x) { return fft::ifftn(x); },
+                astype(zeros({5, 5}), complex64),
+                astype(zeros({5, 5}), complex64))
+                .second;
+  CHECK_EQ(vjp_out.shape(), Shape{5, 5});
+
+  vjp_out = vjp([](array x) { return fft::rfftn(x); },
+                zeros({5, 9}),
+                astype(zeros({5, 5}), complex64))
+                .second;
+  CHECK_EQ(vjp_out.shape(), Shape{5, 9});
+
+  vjp_out = vjp([](array x) { return fft::irfftn(x); },
+                astype(zeros({5, 5}), complex64),
+                zeros({5, 8}))
+                .second;
+  CHECK_EQ(vjp_out.shape(), Shape{5, 5});
+}
+
+TEST_CASE("test fftshift and ifftshift") {
+  // Test 1D array with even length
+  auto x = arange(8);
+  auto y = fft::fftshift(x);
+  CHECK_EQ(y.shape(), x.shape());
+  // print y
+  CHECK(array_equal(y, array({4, 5, 6, 7, 0, 1, 2, 3})).item<bool>());
+
+  // Test 1D array with odd length
+  x = arange(7);
+  y = fft::fftshift(x);
+  CHECK_EQ(y.shape(), x.shape());
+  CHECK(array_equal(y, array({4, 5, 6, 0, 1, 2, 3})).item<bool>());
+
+  // Test 2D array
+  x = reshape(arange(16), {4, 4});
+  y = fft::fftshift(x);
+  auto expected =
+      array({10, 11, 8, 9, 14, 15, 12, 13, 2, 3, 0, 1, 6, 7, 4, 5}, {4, 4});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  // Test with specific axes
+  y = fft::fftshift(x, {0});
+  expected =
+      array({8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7}, {4, 4});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  y = fft::fftshift(x, {1});
+  expected =
+      array({2, 3, 0, 1, 6, 7, 4, 5, 10, 11, 8, 9, 14, 15, 12, 13}, {4, 4});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  // Test ifftshift (inverse operation)
+  x = arange(8);
+  y = fft::ifftshift(x);
+  CHECK_EQ(y.shape(), x.shape());
+  CHECK(array_equal(y, array({4, 5, 6, 7, 0, 1, 2, 3})).item<bool>());
+
+  // Test ifftshift with odd length (different from fftshift)
+  x = arange(7);
+  y = fft::ifftshift(x);
+  CHECK_EQ(y.shape(), x.shape());
+  CHECK(array_equal(y, array({3, 4, 5, 6, 0, 1, 2})).item<bool>());
+
+  // Test 2D ifftshift
+  x = reshape(arange(16), {4, 4});
+  y = fft::ifftshift(x);
+  expected =
+      array({10, 11, 8, 9, 14, 15, 12, 13, 2, 3, 0, 1, 6, 7, 4, 5}, {4, 4});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  // Test error cases
+  CHECK_THROWS_AS(fft::fftshift(x, {3}), std::invalid_argument);
+  CHECK_THROWS_AS(fft::fftshift(x, {-5}), std::invalid_argument);
+  CHECK_THROWS_AS(fft::ifftshift(x, {3}), std::invalid_argument);
+  CHECK_THROWS_AS(fft::ifftshift(x, {-5}), std::invalid_argument);
+}
diff --git a/ml-stable-diffusion/mlx/tests/gpu_tests.cpp b/ml-stable-diffusion/mlx/tests/gpu_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..625cbf5520a1634bab060df0028146a08557acef
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/gpu_tests.cpp
@@ -0,0 +1,523 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include <array>
+
+#include "doctest/doctest.h"
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+static const std::array<Dtype, 5> types =
+    {bool_, uint32, int32, int64, float32};
+
+TEST_CASE("test gpu arange") {
+  for (auto t : types) {
+    if (t == bool_) {
+      continue;
+    }
+    auto out_cpu = arange(1, 100, 2, t, Device::cpu);
+    auto out_gpu = arange(1, 100, 2, t, Device::gpu);
+    CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+
+    out_cpu = arange(1, 5, 0.25, t, Device::cpu);
+    out_gpu = arange(1, 5, 0.25, t, Device::gpu);
+    CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+  }
+}
+
+TEST_CASE("test gpu full") {
+  for (auto t : types) {
+    auto out_cpu = full({4, 4}, 2, t, Device::cpu);
+    auto out_gpu = full({4, 4}, 2, t, Device::gpu);
+    CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+  }
+
+  // Check broadcasting works
+  {
+    auto x = full({2, 2}, array({3, 4}, {2, 1}), Device::gpu);
+    CHECK(
+        array_equal(x, array({3, 3, 4, 4}, {2, 2}), Device::cpu).item<bool>());
+    x = full({2, 2}, array({3, 4}, {1, 2}), Device::gpu);
+    CHECK(
+        array_equal(x, array({3, 4, 3, 4}, {2, 2}), Device::cpu).item<bool>());
+  }
+
+  // Check zeros and ones
+  {
+    auto x = zeros({2, 2}, float32, Device::gpu);
+    auto y = array({0.0, 0.0, 0.0, 0.0}, {2, 2});
+    CHECK(array_equal(x, y, Device::cpu).item<bool>());
+
+    x = ones({2, 2}, float32, Device::gpu);
+    y = array({1.0, 1.0, 1.0, 1.0}, {2, 2});
+    CHECK(array_equal(x, y, Device::cpu).item<bool>());
+  }
+}
+
+TEST_CASE("test gpu astype") {
+  array x = array({-4, -3, -2, -1, 0, 1, 2, 3});
+  // Check all types work
+  for (auto t : types) {
+    auto out_cpu = astype(x, t, Device::cpu);
+    auto out_gpu = astype(x, t, Device::gpu);
+    CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+  }
+
+  x = transpose(reshape(x, {2, 2, 2}), {1, 2, 0});
+  for (auto t : types) {
+    auto out_cpu = astype(x, t, Device::cpu);
+    auto out_gpu = astype(x, t, Device::gpu);
+    CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+  }
+}
+
+TEST_CASE("test gpu reshape") {
+  array x = array({0, 1, 2, 3, 4, 5, 6, 7});
+  auto out_cpu = reshape(x, {2, 2, 2});
+  auto out_gpu = reshape(x, {2, 2, 2}, Device::gpu);
+  CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+
+  x = transpose(reshape(x, {2, 2, 2}), {1, 2, 0});
+  out_cpu = reshape(x, {4, 2});
+  out_gpu = reshape(x, {4, 2}, Device::gpu);
+  CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+
+  out_cpu = reshape(x, {8});
+  out_gpu = reshape(x, {8}, Device::gpu);
+  CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+}
+
+TEST_CASE("test gpu reduce") {
+  {
+    array a(true);
+    CHECK_EQ(all(a, Device::gpu).item<bool>(), true);
+    CHECK_EQ(any(a, Device::gpu).item<bool>(), true);
+
+    a = array(std::initializer_list<bool>{});
+    CHECK_EQ(all(a, Device::gpu).item<bool>(), true);
+    CHECK_EQ(any(a, Device::gpu).item<bool>(), false);
+  }
+
+  {
+    std::vector<int> vals(33, 1);
+    array a(vals.data(), {33});
+    CHECK_EQ(all(a, Device::gpu).item<bool>(), true);
+
+    vals[32] = 0;
+    a = array(vals.data(), {33});
+    CHECK_EQ(all(a, Device::gpu).item<bool>(), false);
+  }
+
+  {
+    std::vector<int> vals(33, 0);
+    array a(vals.data(), {33});
+    CHECK_EQ(any(a, Device::gpu).item<bool>(), false);
+
+    vals[32] = 1;
+    a = array(vals.data(), {33});
+    CHECK_EQ(any(a, Device::gpu).item<bool>(), true);
+  }
+
+  {
+    std::vector<int> vals(1 << 14, 0);
+    array a(vals.data(), {1 << 14});
+    CHECK_EQ(all(a, Device::gpu).item<bool>(), false);
+    CHECK_EQ(any(a, Device::gpu).item<bool>(), false);
+
+    vals[4] = 1;
+    vals[999] = 1;
+    vals[2000] = 1;
+    a = array(vals.data(), {1 << 14});
+    CHECK_EQ(all(a, Device::gpu).item<bool>(), false);
+    CHECK_EQ(any(a, Device::gpu).item<bool>(), true);
+  }
+
+  // sum and prod
+  {
+    array a = array({true, false, true});
+    CHECK_EQ(sum(a, Device::gpu).item<uint32_t>(), 2);
+    CHECK_EQ(prod(a, Device::gpu).item<bool>(), false);
+
+    a = array({true, true, true});
+    CHECK_EQ(sum(a, Device::gpu).item<uint32_t>(), 3);
+    CHECK_EQ(prod(a, Device::gpu).item<bool>(), true);
+
+    a = full({2, 2, 2}, 2.0f);
+    CHECK_EQ(sum(a, Device::gpu).item<float>(), 16.0f);
+    CHECK_EQ(prod(a, Device::gpu).item<float>(), 256.0f);
+
+    a = full({500, 2, 2}, 1u);
+    CHECK_EQ(sum(a, Device::gpu).item<uint32_t>(), 2000);
+    CHECK_EQ(prod(a, Device::gpu).item<uint32_t>(), 1u);
+
+    a = full({500, 2, 2}, 1);
+    CHECK_EQ(sum(a, Device::gpu).item<int32_t>(), 2000);
+    CHECK_EQ(prod(a, Device::gpu).item<int32_t>(), 1);
+  }
+
+  // sum and prod overflow
+  {
+    auto a = full({256, 2, 2}, 1u, uint8);
+    CHECK_EQ(sum(a, Device::gpu).item<uint32_t>(), 256 * 4);
+    CHECK_EQ(prod(a, Device::gpu).item<uint32_t>(), 1);
+
+    a = full({65535, 2, 2}, 1u, uint16);
+    CHECK_EQ(sum(a, Device::gpu).item<uint32_t>(), 65535 * 4);
+    CHECK_EQ(prod(a, Device::gpu).item<uint32_t>(), 1);
+  }
+}
+
+TEST_CASE("test gpu reduce with axes") {
+  // reducing only some axes and irregular layouts
+  {
+    array a(1.0f);
+    a = broadcast_to(a, {2, 2, 2});
+    CHECK_EQ(sum(a, Device::gpu).item<float>(), 8.0f);
+
+    a = ones({2, 4, 8, 16});
+    for (auto ax : {0, 1, 2, 3}) {
+      auto out_gpu = sum(a, ax, false, Device::gpu);
+      auto out_cpu = sum(a, ax, false, Device::cpu);
+      CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+    }
+
+    for (auto ax : {1, 2, 3}) {
+      auto out_gpu = sum(a, {0, ax}, false, Device::gpu);
+      auto out_cpu = sum(a, {0, ax}, false, Device::cpu);
+      CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+    }
+    for (auto ax : {2, 3}) {
+      auto out_gpu = sum(a, {0, 1, ax}, false, Device::gpu);
+      auto out_cpu = sum(a, {0, 1, ax}, false, Device::cpu);
+      CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+    }
+  }
+}
+
+TEST_CASE("test gpu binary ops") {
+  // scalar-scalar
+  {
+    array a(2.0f);
+    array b(4.0f);
+    auto out = add(a, b, Device::gpu);
+    CHECK_EQ(out.item<float>(), 6.0f);
+  }
+
+  // scalar-vector and vector-scalar
+  {
+    array a(2.0f);
+    array b({2.0f, 4.0f, 6.0f});
+    auto out = add(a, b, Device::gpu);
+    auto expected = array({4.0f, 6.0f, 8.0f});
+    CHECK(array_equal(out, expected, Device::cpu).item<bool>());
+    out = add(b, a, Device::gpu);
+    CHECK(array_equal(out, expected, Device::cpu).item<bool>());
+  }
+
+  // vector-vector
+  {
+    array a({0.0f, 1.0f, 2.0f});
+    array b({3.0f, 4.0f, 5.0f});
+    auto out = add(a, b, Device::gpu);
+    auto expected = array({3.0f, 5.0f, 7.0f});
+    CHECK(array_equal(out, expected, Device::cpu).item<bool>());
+  }
+
+  // general
+  {
+    array a({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f}, {2, 2, 2});
+    array b({0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f}, {2, 2, 2});
+    a = transpose(a, {0, 2, 1});
+    b = transpose(b, {1, 0, 2});
+    auto out_gpu = add(a, b, Device::gpu);
+    auto out_cpu = add(a, b, Device::cpu);
+    auto expected =
+        array({0.0f, 3.0f, 5.0f, 8.0f, 6.0f, 9.0f, 11.0f, 14.0f}, {2, 2, 2});
+    CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+    CHECK(array_equal(out_gpu, expected, Device::cpu).item<bool>());
+  }
+
+  // Check all types work
+  for (auto t : types) {
+    auto a = astype(array({0, 1, 2}), t);
+    auto b = astype(array({3, 4, 5}), t);
+    auto out_cpu = add(a, b, Device::cpu);
+    auto out_gpu = add(a, b, Device::gpu);
+    CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+  }
+
+  // Check subtraction
+  {
+    auto a = array({3, 2, 1});
+    auto b = array({1, 1, 1});
+    auto out = subtract(a, b, Device::gpu);
+    CHECK(array_equal(out, array({2, 1, 0}), Device::cpu).item<bool>());
+  }
+
+  // Check multiplication
+  {
+    auto a = array({1, 2, 3});
+    auto b = array({2, 2, 2});
+    auto out = multiply(a, b, Device::gpu);
+    CHECK(array_equal(out, array({2, 4, 6}), Device::cpu).item<bool>());
+  }
+
+  // Check division
+  {
+    auto x = array(1.0f);
+    auto y = array(1.0f);
+    CHECK_EQ(divide(x, y, Device::gpu).item<float>(), 1.0f);
+
+    x = array(1.0f);
+    y = array(0.5);
+    CHECK_EQ(divide(x, y, Device::gpu).item<float>(), 2.0f);
+
+    x = array(1.0f);
+    y = array(0.0f);
+    CHECK(std::isinf(divide(x, y, Device::gpu).item<float>()));
+
+    x = array(0.0f);
+    y = array(0.0f);
+    CHECK(std::isnan(divide(x, y, Device::gpu).item<float>()));
+  }
+
+  // Check maximum and minimum
+  {
+    auto x = array(1.0f);
+    auto y = array(0.0f);
+    CHECK_EQ(maximum(x, y, Device::gpu).item<float>(), 1.0f);
+    CHECK_EQ(minimum(x, y, Device::gpu).item<float>(), 0.0f);
+    y = array(2.0f);
+    CHECK_EQ(maximum(x, y, Device::gpu).item<float>(), 2.0f);
+    CHECK_EQ(minimum(x, y, Device::gpu).item<float>(), 1.0f);
+  }
+
+  // Check equal
+  {
+    array x(1.0f);
+    array y(1.0f);
+    CHECK(equal(x, y, Device::gpu).item<bool>());
+    x = array(0.0f);
+    CHECK(!equal(x, y, Device::gpu).item<bool>());
+  }
+
+  // Greater and less
+  {
+    array x(1.0f);
+    array y(0.0f);
+    CHECK(greater(x, y, Device::gpu).item<bool>());
+    CHECK(greater_equal(x, y, Device::gpu).item<bool>());
+    CHECK(!greater(y, x, Device::gpu).item<bool>());
+    CHECK(!greater_equal(y, x, Device::gpu).item<bool>());
+    y = array(1.0f);
+    CHECK(!greater(x, y, Device::gpu).item<bool>());
+    CHECK(greater_equal(x, y, Device::gpu).item<bool>());
+
+    x = array(0.0f);
+    y = array(1.0f);
+    CHECK(less(x, y, Device::gpu).item<bool>());
+    CHECK(less_equal(x, y, Device::gpu).item<bool>());
+    CHECK(!less(y, x, Device::gpu).item<bool>());
+    CHECK(!less_equal(y, x, Device::gpu).item<bool>());
+    y = array(0.0f);
+    CHECK(!less(x, y, Device::gpu).item<bool>());
+    CHECK(less_equal(x, y, Device::gpu).item<bool>());
+  }
+
+  // Check logaddexp
+  {
+    constexpr float inf = std::numeric_limits<float>::infinity();
+    array x(inf);
+    array y(2.0f);
+    auto out = logaddexp(x, y, Device::gpu);
+    CHECK_EQ(out.item<float>(), inf);
+
+    x = array(-inf);
+    out = logaddexp(x, y, Device::gpu);
+    CHECK_EQ(out.item<float>(), 2.0f);
+
+    y = array(-inf);
+    out = logaddexp(x, y, Device::gpu);
+    CHECK_EQ(out.item<float>(), -inf);
+  }
+}
+
+TEST_CASE("test gpu unary ops") {
+  // contiguous
+  {
+    array x({-1.0f, 0.0f, 1.0f});
+    auto expected = array({1.0f, 0.0f, 1.0f});
+    CHECK(array_equal(abs(x, Device::gpu), expected, Device::cpu).item<bool>());
+  }
+
+  // general
+  {
+    array x({-1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f, 3.0f, -3.0f});
+    auto y = slice(x, {0}, {8}, {2});
+    auto expected = array({1.0f, 1.0f, 1.0f, 3.0f});
+    CHECK(array_equal(abs(y, Device::gpu), expected, Device::cpu).item<bool>());
+
+    y = slice(x, {4}, {8});
+    expected = array({1.0f, 1.0f, 3.0f, 3.0f});
+    CHECK(array_equal(abs(y, Device::gpu), expected, Device::cpu).item<bool>());
+  }
+
+  // Test negative
+  {
+    array x(1.0f);
+    CHECK_EQ(negative(x, Device::gpu).item<float>(), -1.0f);
+  }
+
+  // Check all types work
+  for (auto t : types) {
+    if (t == bool_) {
+      continue;
+    }
+    auto in = astype(array({1}), t);
+    auto out_cpu = negative(in, Device::cpu);
+    auto out_gpu = negative(in, Device::gpu);
+    CHECK(array_equal(out_gpu, out_cpu, Device::cpu).item<bool>());
+  }
+
+  // Test log1p
+  {
+    constexpr float inf = std::numeric_limits<float>::infinity();
+    array x(-1.0f);
+    CHECK_EQ(log1p(x, Device::gpu).item<float>(), -inf);
+
+    x = array(0.0f);
+    CHECK_EQ(log1p(x, Device::gpu).item<float>(), 0.0f);
+
+    x = array(1e-9f);
+    CHECK_EQ(log1p(x, Device::gpu).item<float>(), 1e-9f);
+
+    x = array(-2.0f);
+    CHECK(std::isnan(log1p(x, Device::gpu).item<float>()));
+  }
+}
+
+TEST_CASE("test gpu random") {
+  {
+    auto key = random::key(0);
+    auto x = random::bits({}, 4, key, Device::gpu);
+    auto y = random::bits({}, 4, key, Device::gpu);
+    CHECK_EQ(x.item<uint32_t>(), 1797259609u);
+    CHECK_EQ(x.item<uint32_t>(), y.item<uint32_t>());
+  }
+
+  {
+    auto key = random::key(1);
+    auto x = random::bits({}, 4, key, Device::gpu);
+    CHECK_EQ(x.item<uint32_t>(), 507451445u);
+  }
+
+  {
+    auto key = random::key(0);
+    auto x = random::bits({3, 1}, 4, key, Device::gpu);
+    auto expected = array({4146024105u, 1351547692u, 2718843009u}, {3, 1});
+    CHECK(array_equal(x, expected, Device::cpu).item<bool>());
+  }
+}
+
+TEST_CASE("test gpu matmul") {
+  {
+    auto a = ones({2, 2});
+    auto b = ones({2, 2});
+    auto out = matmul(a, b, Device::gpu);
+    CHECK(array_equal(out, full({2, 2}, 2.0f), Device::cpu).item<bool>());
+  }
+
+  // Batched matmul
+  {
+    auto a = ones({3, 2, 2});
+    auto b = ones({3, 2, 2});
+    auto out = matmul(a, b, Device::gpu);
+    CHECK(array_equal(out, full({3, 2, 2}, 2.0f), Device::cpu).item<bool>());
+  }
+
+  // Broadcast batched matmul
+  {
+    auto a = ones({1, 3, 2, 2});
+    auto b = ones({3, 1, 2, 2});
+    auto out = matmul(a, b, Device::gpu);
+    CHECK(array_equal(out, full({3, 3, 2, 2}, 2.0f), Device::cpu).item<bool>());
+  }
+}
+
+TEST_CASE("test gpu validation") {
+  // Run this test with Metal validation enabled
+  // METAL_DEVICE_WRAPPER_TYPE=1 METAL_DEBUG_ERROR_MODE=0 ./tests/tests \
+  //     -tc="test metal validation" \
+
+  auto x = array({});
+  eval(exp(x));
+
+  auto y = array({});
+  eval(add(x, y));
+
+  eval(sum(x));
+
+  x = array({1, 2, 3});
+  y = array(0);
+  eval(gather(x, y, 0, {0}));
+  eval(gather(x, y, 0, {2}));
+
+  eval(gather(x, y, 0, {0}));
+  eval(gather(x, y, 0, {2}));
+
+  eval(scatter(x, y, array({2}), 0));
+
+  x = arange(0, -3, 1);
+  eval(x);
+  array_equal(x, array({})).item<bool>();
+
+  x = array({1.0, 0.0});
+  eval(argmax(x));
+
+  eval(scatter_max(array(1), {}, array(2), std::vector<int>{}));
+}
+
+TEST_CASE("test memory info") {
+  // Test cache limits
+  {
+    auto old_limit = set_cache_limit(0);
+    {
+      auto a = zeros({4096});
+      eval(a);
+    }
+    CHECK_EQ(get_cache_memory(), 0);
+    CHECK_EQ(set_cache_limit(old_limit), 0);
+    CHECK_EQ(set_cache_limit(old_limit), old_limit);
+  }
+
+  // Test memory limits
+  {
+    auto old_limit = set_memory_limit(10);
+    CHECK_EQ(set_memory_limit(old_limit), 10);
+    CHECK_EQ(set_memory_limit(old_limit), old_limit);
+  }
+
+  // Query active and peak memory
+  {
+    auto a = zeros({4096});
+    eval(a);
+    synchronize();
+    auto active_mem = get_active_memory();
+    CHECK(active_mem >= 4096 * 4);
+    {
+      auto b = zeros({4096});
+      eval(b);
+    }
+    synchronize();
+    auto new_active_mem = get_active_memory();
+    CHECK_EQ(new_active_mem, active_mem);
+    auto peak_mem = get_peak_memory();
+    CHECK(peak_mem >= 4096 * 8);
+
+    auto cache_mem = get_cache_memory();
+    CHECK(cache_mem >= 4096 * 4);
+  }
+
+  clear_cache();
+  CHECK_EQ(get_cache_memory(), 0);
+}
diff --git a/ml-stable-diffusion/mlx/tests/linalg_tests.cpp b/ml-stable-diffusion/mlx/tests/linalg_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0660a69fef32fdd46d6936200a7bf000436e1de0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/linalg_tests.cpp
@@ -0,0 +1,631 @@
+// Copyright © 2023-2024 Apple Inc.
+
+#include "doctest/doctest.h"
+
+#include <cmath>
+
+#include "mlx/mlx.h"
+#include "mlx/ops.h"
+
+using namespace mlx::core;
+using namespace mlx::core::linalg;
+
+TEST_CASE("[mlx.core.linalg.norm] no ord") {
+  // Zero dimensions
+  array x(2.0);
+  CHECK_EQ(norm(x).item<float>(), 2.0f);
+  CHECK_THROWS(norm(x, 0));
+
+  x = array({1, 2, 3});
+  float expected = std::sqrt(1 + 4 + 9);
+  CHECK_EQ(norm(x).item<float>(), doctest::Approx(expected));
+  CHECK_EQ(norm(x, 0, false).item<float>(), doctest::Approx(expected));
+  CHECK_EQ(norm(x, -1, false).item<float>(), doctest::Approx(expected));
+  CHECK_EQ(norm(x, -1, true).ndim(), 1);
+  CHECK_THROWS(norm(x, 1));
+
+  x = reshape(arange(9), {3, 3});
+  expected =
+      std::sqrt(0 + 1 + 2 * 2 + 3 * 3 + 4 * 4 + 5 * 5 + 6 * 6 + 7 * 7 + 8 * 8);
+
+  CHECK_EQ(norm(x).item<float>(), doctest::Approx(expected));
+  CHECK_EQ(
+      norm(x, std::vector<int>{0, 1}).item<float>(), doctest::Approx(expected));
+  CHECK(allclose(
+            norm(x, 0, false),
+            array(
+                {std::sqrt(0 + 3 * 3 + 6 * 6),
+                 std::sqrt(1 + 4 * 4 + 7 * 7),
+                 std::sqrt(2 * 2 + 5 * 5 + 8 * 8)}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, 1, false),
+            array(
+                {std::sqrt(0 + 1 + 2 * 2),
+                 std::sqrt(3 * 3 + 4 * 4 + 5 * 5),
+                 std::sqrt(6 * 6 + 7 * 7 + 8 * 8)}))
+            .item<bool>());
+
+  x = reshape(arange(18), {2, 3, 3});
+  CHECK(allclose(
+            norm(x, 2, false),
+            array(
+                {
+                    std::sqrt(0 + 1 + 2 * 2),
+                    std::sqrt(3 * 3 + 4 * 4 + 5 * 5),
+                    std::sqrt(6 * 6 + 7 * 7 + 8 * 8),
+                    std::sqrt(9 * 9 + 10 * 10 + 11 * 11),
+                    std::sqrt(12 * 12 + 13 * 13 + 14 * 14),
+                    std::sqrt(15 * 15 + 16 * 16 + 17 * 17),
+                },
+                {2, 3}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, std::vector<int>{1, 2}, false),
+            array(
+                {std::sqrt(
+                     0 + 1 + 2 * 2 + 3 * 3 + 4 * 4 + 5 * 5 + 6 * 6 + 7 * 7 +
+                     8 * 8),
+                 std::sqrt(
+                     9 * 9 + 10 * 10 + 11 * 11 + 12 * 12 + 13 * 13 + 14 * 14 +
+                     15 * 15 + 16 * 16 + 17 * 17)},
+                {2}))
+            .item<bool>());
+  CHECK_THROWS(norm(x, std::vector<int>{0, 1, 2}));
+}
+
+TEST_CASE("[mlx.core.linalg.norm] double ord") {
+  CHECK_THROWS(norm(array(0), 2.0));
+
+  array x({1, 2, 3});
+
+  float expected = std::sqrt(1 + 4 + 9);
+  CHECK_EQ(norm(x, 2.0).item<float>(), doctest::Approx(expected));
+  CHECK_EQ(norm(x, 2.0, 0).item<float>(), doctest::Approx(expected));
+  CHECK_THROWS(norm(x, 2.0, 1));
+
+  expected = 1 + 2 + 3;
+  CHECK_EQ(norm(x, 1.0).item<float>(), doctest::Approx(expected));
+
+  expected = 3;
+  CHECK_EQ(norm(x, 0.0).item<float>(), doctest::Approx(expected));
+
+  expected = 3;
+  CHECK_EQ(
+      norm(x, std::numeric_limits<double>::infinity()).item<float>(),
+      doctest::Approx(expected));
+
+  expected = 1;
+  CHECK_EQ(
+      norm(x, -std::numeric_limits<double>::infinity()).item<float>(),
+      doctest::Approx(expected));
+
+  x = reshape(arange(9, float32), {3, 3});
+
+  CHECK(allclose(
+            norm(x, 2.0, 0, false),
+            array(
+                {std::sqrt(0 + 3 * 3 + 6 * 6),
+                 std::sqrt(1 + 4 * 4 + 7 * 7),
+                 std::sqrt(2 * 2 + 5 * 5 + 8 * 8)}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, 2.0, 1, false),
+            array(
+                {sqrt(0 + 1 + 2 * 2),
+                 sqrt(3 * 3 + 4 * 4 + 5 * 5),
+                 sqrt(6 * 6 + 7 * 7 + 8 * 8)}))
+            .item<bool>());
+
+  CHECK_EQ(
+      norm(x, 1.0, std::vector<int>{0, 1}).item<float>(),
+      doctest::Approx(15.0));
+  CHECK_EQ(
+      norm(x, 1.0, std::vector<int>{1, 0}).item<float>(),
+      doctest::Approx(21.0));
+  CHECK_EQ(
+      norm(x, -1.0, std::vector<int>{0, 1}).item<float>(),
+      doctest::Approx(9.0));
+  CHECK_EQ(
+      norm(x, -1.0, std::vector<int>{1, 0}).item<float>(),
+      doctest::Approx(3.0));
+  CHECK_EQ(
+      norm(x, 2.0, std::vector<int>{0, 1}, false, Device::cpu).item<float>(),
+      doctest::Approx(14.226707));
+  CHECK_EQ(
+      norm(x, 2.0, std::vector<int>{1, 0}, false, Device::cpu).item<float>(),
+      doctest::Approx(14.226707));
+  CHECK_EQ(
+      norm(x, -2.0, std::vector<int>{0, 1}, false, Device::cpu).item<float>(),
+      doctest::Approx(0.0));
+  CHECK_EQ(
+      norm(x, -2.0, std::vector<int>{1, 0}, false, Device::cpu).item<float>(),
+      doctest::Approx(0.0));
+  CHECK_EQ(norm(x, 1.0, std::vector<int>{0, 1}, true).shape(), Shape{1, 1});
+  CHECK_EQ(norm(x, 1.0, std::vector<int>{1, 0}, true).shape(), Shape{1, 1});
+  CHECK_EQ(norm(x, -1.0, std::vector<int>{0, 1}, true).shape(), Shape{1, 1});
+  CHECK_EQ(norm(x, -1.0, std::vector<int>{1, 0}, true).shape(), Shape{1, 1});
+  CHECK_EQ(
+      norm(x, 2.0, std::vector<int>{0, 1}, true, Device::cpu).shape(),
+      Shape{1, 1});
+  CHECK_EQ(
+      norm(x, 2.0, std::vector<int>{1, 0}, true, Device::cpu).shape(),
+      Shape{1, 1});
+  CHECK_EQ(
+      norm(x, -2.0, std::vector<int>{0, 1}, true, Device::cpu).shape(),
+      Shape{1, 1});
+  CHECK_EQ(
+      norm(x, -2.0, std::vector<int>{1, 0}, true, Device::cpu).shape(),
+      Shape{1, 1});
+
+  CHECK_EQ(
+      norm(x, -1.0, std::vector<int>{-2, -1}, false).item<float>(),
+      doctest::Approx(9.0));
+  CHECK_EQ(
+      norm(x, 1.0, std::vector<int>{-2, -1}, false).item<float>(),
+      doctest::Approx(15.0));
+  CHECK_EQ(
+      norm(x, -2.0, std::vector<int>{-2, -1}, false, Device::cpu).item<float>(),
+      doctest::Approx(0.0));
+  CHECK_EQ(
+      norm(x, 2.0, std::vector<int>{-2, -1}, false, Device::cpu).item<float>(),
+      doctest::Approx(14.226707));
+
+  x = reshape(arange(18, float32), {2, 3, 3});
+  CHECK_THROWS(norm(x, 2.0, std::vector{0, 1, 2}));
+  CHECK(allclose(
+            norm(x, 3.0, 0),
+            array(
+                {9.,
+                 10.00333222,
+                 11.02199456,
+                 12.06217728,
+                 13.12502645,
+                 14.2094363,
+                 15.31340617,
+                 16.43469751,
+                 17.57113899},
+                {3, 3}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, 3.0, 2),
+            array(
+                {2.08008382,
+                 6.,
+                 10.23127655,
+                 14.5180117,
+                 18.82291607,
+                 23.13593104},
+                {2, 3}))
+            .item<bool>());
+  CHECK(
+      allclose(
+          norm(x, 0.0, 0), array({1., 2., 2., 2., 2., 2., 2., 2., 2.}, {3, 3}))
+          .item<bool>());
+  CHECK(allclose(norm(x, 0.0, 1), array({2., 3., 3., 3., 3., 3.}, {2, 3}))
+            .item<bool>());
+  CHECK(allclose(norm(x, 0.0, 2), array({2., 3., 3., 3., 3., 3.}, {2, 3}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, 1.0, 0),
+            array({9., 11., 13., 15., 17., 19., 21., 23., 25.}, {3, 3}))
+            .item<bool>());
+  CHECK(allclose(norm(x, 1.0, 1), array({9., 12., 15., 36., 39., 42.}, {2, 3}))
+            .item<bool>());
+  CHECK(allclose(norm(x, 1.0, 2), array({3., 12., 21., 30., 39., 48.}, {2, 3}))
+            .item<bool>());
+
+  CHECK(allclose(norm(x, 1.0, std::vector<int>{0, 1}), array({21., 23., 25.}))
+            .item<bool>());
+  CHECK(allclose(norm(x, 1.0, std::vector<int>{1, 2}), array({15., 42.}))
+            .item<bool>());
+  CHECK(allclose(norm(x, -1.0, std::vector<int>{0, 1}), array({9., 11., 13.}))
+            .item<bool>());
+  CHECK(allclose(norm(x, -1.0, std::vector<int>{1, 2}), array({9., 36.}))
+            .item<bool>());
+  CHECK(allclose(norm(x, -1.0, std::vector<int>{1, 0}), array({9., 12., 15.}))
+            .item<bool>());
+  CHECK(allclose(norm(x, -1.0, std::vector<int>{2, 1}), array({3, 30}))
+            .item<bool>());
+  CHECK(allclose(norm(x, -1.0, std::vector<int>{1, 2}), array({9, 36}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, 2.0, std::vector<int>{0, 1}, false, Device::cpu),
+            array({22.045408, 24.155825, 26.318918}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, 2.0, std::vector<int>{1, 2}, false, Device::cpu),
+            array({14.226707, 39.759212}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, -2.0, std::vector<int>{0, 1}, false, Device::cpu),
+            array({3, 2.7378995, 2.5128777}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, -2.0, std::vector<int>{1, 2}, false, Device::cpu),
+            array({4.979028e-16, 7.009628e-16}),
+            /* rtol = */ 1e-5,
+            /* atol = */ 1e-6)
+            .item<bool>());
+}
+
+TEST_CASE("[mlx.core.linalg.norm] string ord") {
+  array x({1, 2, 3});
+  CHECK_THROWS(norm(x, "fro"));
+
+  x = reshape(arange(9, float32), {3, 3});
+  CHECK_THROWS(norm(x, "bad ord"));
+
+  CHECK_EQ(
+      norm(x, "f", std::vector<int>{0, 1}).item<float>(),
+      doctest::Approx(14.2828568570857));
+  CHECK_EQ(
+      norm(x, "fro", std::vector<int>{0, 1}).item<float>(),
+      doctest::Approx(14.2828568570857));
+  CHECK_EQ(
+      norm(x, "nuc", std::vector<int>{0, 1}, false, Device::cpu).item<float>(),
+      doctest::Approx(15.491934));
+
+  x = reshape(arange(18, float32), {2, 3, 3});
+  CHECK(allclose(
+            norm(x, "fro", std::vector<int>{0, 1}),
+            array({22.24859546, 24.31049156, 26.43860813}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, "fro", std::vector<int>{1, 2}),
+            array({14.28285686, 39.7617907}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, "f", std::vector<int>{0, 1}),
+            array({22.24859546, 24.31049156, 26.43860813}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, "f", std::vector<int>{1, 0}),
+            array({22.24859546, 24.31049156, 26.43860813}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, "f", std::vector<int>{1, 2}),
+            array({14.28285686, 39.7617907}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, "f", std::vector<int>{2, 1}),
+            array({14.28285686, 39.7617907}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, "nuc", std::vector<int>{0, 1}, false, Device::cpu),
+            array({25.045408, 26.893724, 28.831797}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, "nuc", std::vector<int>{1, 2}, false, Device::cpu),
+            array({15.491934, 40.211937}))
+            .item<bool>());
+  CHECK(allclose(
+            norm(x, "nuc", std::vector<int>{-2, -1}, false, Device::cpu),
+            array({15.491934, 40.211937}))
+            .item<bool>());
+}
+
+TEST_CASE("test QR factorization") {
+  // 0D and 1D throw
+  CHECK_THROWS(linalg::qr(array(0.0)));
+  CHECK_THROWS(linalg::qr(array({0.0, 1.0})));
+
+  // Unsupported types throw
+  CHECK_THROWS(linalg::qr(array({0, 1}, {1, 2})));
+
+  array A = array({2., 3., 1., 2.}, {2, 2});
+  auto [Q, R] = linalg::qr(A, Device::cpu);
+  auto out = matmul(Q, R);
+  CHECK(allclose(out, A).item<bool>());
+  out = matmul(Q, Q);
+  CHECK(allclose(out, eye(2), 1e-5, 1e-7).item<bool>());
+  CHECK(allclose(tril(R, -1), zeros_like(R)).item<bool>());
+  CHECK_EQ(Q.dtype(), float32);
+  CHECK_EQ(R.dtype(), float32);
+}
+
+TEST_CASE("test SVD factorization") {
+  // 0D and 1D throw
+  CHECK_THROWS(linalg::svd(array(0.0)));
+  CHECK_THROWS(linalg::svd(array({0.0, 1.0})));
+
+  // Unsupported types throw
+  CHECK_THROWS(linalg::svd(array({0, 1}, {1, 2})));
+
+  const auto prng_key = random::key(42);
+  const auto A = mlx::core::random::normal({5, 4}, prng_key);
+  const auto outs = linalg::svd(A, true, Device::cpu);
+  CHECK_EQ(outs.size(), 3);
+
+  const auto& U = outs[0];
+  const auto& S = outs[1];
+  const auto& Vt = outs[2];
+
+  CHECK_EQ(U.shape(), Shape{5, 5});
+  CHECK_EQ(S.shape(), Shape{4});
+  CHECK_EQ(Vt.shape(), Shape{4, 4});
+
+  const auto U_slice = slice(U, {0, 0}, {U.shape(0), S.shape(0)});
+
+  const auto A_again = matmul(matmul(U_slice, diag(S)), Vt);
+
+  CHECK(
+      allclose(A_again, A, /* rtol = */ 1e-4, /* atol = */ 1e-4).item<bool>());
+  CHECK_EQ(U.dtype(), float32);
+  CHECK_EQ(S.dtype(), float32);
+  CHECK_EQ(Vt.dtype(), float32);
+
+  // Test singular values
+  const auto& outs_sv = linalg::svd(A, false, Device::cpu);
+  const auto SV = outs_sv[0];
+
+  CHECK_EQ(SV.shape(), Shape{4});
+  CHECK_EQ(SV.dtype(), float32);
+
+  CHECK(allclose(norm(SV), norm(A, "fro")).item<bool>());
+}
+
+TEST_CASE("test matrix inversion") {
+  // 0D and 1D throw
+  CHECK_THROWS(linalg::inv(array(0.0), Device::cpu));
+  CHECK_THROWS(linalg::inv(array({0.0, 1.0}), Device::cpu));
+
+  // Unsupported types throw
+  CHECK_THROWS(linalg::inv(array({0, 1}, {1, 2}), Device::cpu));
+
+  // Non-square throws.
+  CHECK_THROWS(linalg::inv(array({1, 2, 3, 4, 5, 6}, {2, 3}), Device::cpu));
+
+  const auto prng_key = random::key(42);
+  const auto A = random::normal({5, 5}, prng_key);
+  const auto A_inv = linalg::inv(A, Device::cpu);
+  const auto identity = eye(A.shape(0));
+
+  CHECK(allclose(matmul(A, A_inv), identity, /* rtol = */ 0, /* atol = */ 1e-6)
+            .item<bool>());
+  CHECK(allclose(matmul(A_inv, A), identity, /* rtol = */ 0, /* atol = */ 1e-6)
+            .item<bool>());
+}
+
+TEST_CASE("test matrix cholesky") {
+  // 0D and 1D throw
+  CHECK_THROWS(linalg::cholesky(array(0.0), /* upper = */ false, Device::cpu));
+  CHECK_THROWS(
+      linalg::cholesky(array({0.0, 1.0}), /* upper = */ false, Device::cpu));
+
+  // Unsupported types throw
+  CHECK_THROWS(linalg::cholesky(
+      array({0, 1}, {1, 2}), /* upper = */ false, Device::cpu));
+
+  // Non-square throws.
+  CHECK_THROWS(linalg::cholesky(
+      array({1, 2, 3, 4, 5, 6}, {2, 3}), /* upper = */ false, Device::cpu));
+
+  const auto prng_key = random::key(220398);
+  const auto sqrtA = random::normal({5, 5}, prng_key);
+  const auto A = matmul(sqrtA, transpose(sqrtA));
+  const auto L = linalg::cholesky(A, /* upper = */ false, Device::cpu);
+  const auto U = linalg::cholesky(A, /* upper = */ true, Device::cpu);
+
+  CHECK(allclose(matmul(L, transpose(L)), A, /* rtol = */ 0, /* atol = */ 1e-6)
+            .item<bool>());
+  CHECK(allclose(matmul(transpose(U), U), A, /* rtol = */ 0, /* atol = */ 1e-6)
+            .item<bool>());
+}
+
+TEST_CASE("test matrix pseudo-inverse") {
+  // 0D and 1D throw
+  CHECK_THROWS(linalg::pinv(array(0.0), Device::cpu));
+  CHECK_THROWS(linalg::pinv(array({0.0, 1.0}), Device::cpu));
+
+  // Unsupported types throw
+  CHECK_THROWS(linalg::pinv(array({0, 1}, {1, 2}), Device::cpu));
+
+  { // Square m == n
+    const auto A = array({1.0, 2.0, 3.0, 4.0}, {2, 2});
+    const auto A_pinv = linalg::pinv(A, Device::cpu);
+    const auto A_again = matmul(matmul(A, A_pinv), A);
+    CHECK(allclose(A_again, A).item<bool>());
+    const auto A_pinv_again = matmul(matmul(A_pinv, A), A_pinv);
+    CHECK(allclose(A_pinv_again, A_pinv).item<bool>());
+  }
+  { // Rectangular matrix m < n
+    const auto prng_key = random::key(42);
+    const auto A = random::normal({4, 5}, prng_key);
+    const auto A_pinv = linalg::pinv(A, Device::cpu);
+    const auto zeros = zeros_like(A_pinv, Device::cpu);
+    CHECK_FALSE(allclose(zeros, A_pinv, /* rtol = */ 0, /* atol = */ 1e-6)
+                    .item<bool>());
+    const auto A_again = matmul(matmul(A, A_pinv), A);
+    CHECK(allclose(A_again, A).item<bool>());
+    const auto A_pinv_again = matmul(matmul(A_pinv, A), A_pinv);
+    CHECK(allclose(A_pinv_again, A_pinv).item<bool>());
+  }
+  { // Rectangular matrix m > n
+    const auto prng_key = random::key(10);
+    const auto A = random::normal({6, 5}, prng_key);
+    const auto A_pinv = linalg::pinv(A, Device::cpu);
+    const auto zeros2 = zeros_like(A_pinv, Device::cpu);
+    CHECK_FALSE(allclose(zeros2, A_pinv, /* rtol = */ 0, /* atol = */ 1e-6)
+                    .item<bool>());
+    const auto A_again = matmul(matmul(A, A_pinv), A);
+    CHECK(allclose(A_again, A).item<bool>());
+    const auto A_pinv_again = matmul(matmul(A_pinv, A), A_pinv);
+    CHECK(allclose(A_pinv_again, A_pinv).item<bool>());
+  }
+}
+
+TEST_CASE("test cross product") {
+  using namespace mlx::core::linalg;
+
+  // Test for vectors of length 3
+  array a = array({1.0, 2.0, 3.0});
+  array b = array({4.0, 5.0, 6.0});
+
+  array expected = array(
+      {2.0 * 6.0 - 3.0 * 5.0, 3.0 * 4.0 - 1.0 * 6.0, 1.0 * 5.0 - 2.0 * 4.0});
+
+  array result = cross(a, b);
+  CHECK(allclose(result, expected).item<bool>());
+
+  // Test for vectors of length 3 with negative values
+  a = array({-1.0, -2.0, -3.0});
+  b = array({4.0, -5.0, 6.0});
+
+  expected = array(
+      {-2.0 * 6.0 - (-3.0 * -5.0),
+       -3.0 * 4.0 - (-1.0 * 6.0),
+       -1.0 * -5.0 - (-2.0 * 4.0)});
+
+  result = cross(a, b);
+  CHECK(allclose(result, expected).item<bool>());
+
+  // Test for incorrect vector size (should throw)
+  b = array({1.0, 2.0});
+  expected = array(
+      {-2.0 * 0.0 - (-3.0 * 2.0),
+       -3.0 * 1.0 - (-1.0 * 0.0),
+       -1.0 * 2.0 - (-2.0 * 1.0)});
+
+  result = cross(a, b);
+  CHECK(allclose(result, expected).item<bool>());
+
+  // Test for vectors of length 3 with integer values
+  a = array({1, 2, 3});
+  b = array({4, 5, 6});
+
+  expected = array({2 * 6 - 3 * 5, 3 * 4 - 1 * 6, 1 * 5 - 2 * 4});
+
+  result = cross(a, b);
+  CHECK(allclose(result, expected).item<bool>());
+}
+
+TEST_CASE("test matrix eigh") {
+  // 0D and 1D throw
+  CHECK_THROWS(linalg::eigh(array(0.0)));
+  CHECK_THROWS(linalg::eigh(array({0.0, 1.0})));
+  CHECK_THROWS(linalg::eigvalsh(array(0.0)));
+  CHECK_THROWS(linalg::eigvalsh(array({0.0, 1.0})));
+
+  // Unsupported types throw
+  CHECK_THROWS(linalg::eigh(array({0, 1}, {1, 2})));
+
+  // Non-square throws
+  CHECK_THROWS(linalg::eigh(array({1, 2, 3, 4, 5, 6}, {2, 3})));
+
+  // Test a simple 2x2 symmetric matrix
+  array A = array({1.0, 2.0, 2.0, 4.0}, {2, 2}, float32);
+  auto [eigvals, eigvecs] = linalg::eigh(A, "L", Device::cpu);
+
+  // Expected eigenvalues
+  array expected_eigvals = array({0.0, 5.0});
+  CHECK(allclose(
+            eigvals,
+            expected_eigvals,
+            /* rtol = */ 1e-5,
+            /* atol = */ 1e-5)
+            .item<bool>());
+
+  // Verify orthogonality of eigenvectors
+  CHECK(allclose(
+            matmul(eigvecs, transpose(eigvecs)),
+            eye(2),
+            /* rtol = */ 1e-5,
+            /* atol = */ 1e-5)
+            .item<bool>());
+
+  // Verify eigendecomposition
+  CHECK(allclose(matmul(A, eigvecs), eigvals * eigvecs).item<bool>());
+}
+
+TEST_CASE("test lu") {
+  // Test 2x2 matrix
+  array a = array({1., 2., 3., 4.}, {2, 2});
+  auto out = linalg::lu(a, Device::cpu);
+  auto L = take_along_axis(out[1], expand_dims(out[0], -1), -2);
+  array expected = matmul(L, out[2]);
+  CHECK(allclose(a, expected).item<bool>());
+
+  // Test 3x3 matrix
+  a = array({1., 2., 3., 4., 5., 6., 7., 8., 10.}, {3, 3});
+  out = linalg::lu(a, Device::cpu);
+  L = take_along_axis(out[1], expand_dims(out[0], -1), -2);
+  expected = matmul(L, out[2]);
+  CHECK(allclose(a, expected).item<bool>());
+
+  // Test batch dimension
+  a = broadcast_to(a, {3, 3, 3});
+  out = linalg::lu(a, Device::cpu);
+  L = take_along_axis(out[1], expand_dims(out[0], -1), -2);
+  expected = matmul(L, out[2]);
+  CHECK(allclose(a, expected).item<bool>());
+}
+
+TEST_CASE("test solve") {
+  // 0D and 1D throw
+  CHECK_THROWS(linalg::solve(array(0.), array(0.), Device::cpu));
+  CHECK_THROWS(linalg::solve(array({0.}), array({0.}), Device::cpu));
+
+  // Unsupported types throw
+  CHECK_THROWS(
+      linalg::solve(array({0, 1, 1, 2}, {2, 2}), array({1, 3}), Device::cpu));
+
+  // Non-square throws
+  array a = reshape(arange(6), {3, 2});
+  array b = reshape(arange(3), {3, 1});
+  CHECK_THROWS(linalg::solve(a, b, Device::cpu));
+
+  // Test 2x2 matrix with 1D rhs
+  a = array({2., 1., 1., 3.}, {2, 2});
+  b = array({8., 13.}, {2});
+
+  array result = linalg::solve(a, b, Device::cpu);
+  CHECK(allclose(matmul(a, result), b).item<bool>());
+
+  // Test 3x3 matrix
+  a = array({1., 2., 3., 4., 5., 6., 7., 8., 10.}, {3, 3});
+  b = array({6., 15., 25.}, {3, 1});
+
+  result = linalg::solve(a, b, Device::cpu);
+  CHECK(allclose(matmul(a, result), b).item<bool>());
+
+  // Test batch dimension
+  a = broadcast_to(a, {5, 3, 3});
+  b = broadcast_to(b, {5, 3, 1});
+
+  result = linalg::solve(a, b, Device::cpu);
+  CHECK(allclose(matmul(a, result), b).item<bool>());
+
+  // Test multi-column rhs
+  a = array({2., 1., 1., 1., 3., 2., 1., 0., 0.}, {3, 3});
+  b = array({4., 2., 5., 3., 6., 1.}, {3, 2});
+
+  result = linalg::solve(a, b, Device::cpu);
+  CHECK(allclose(matmul(a, result), b).item<bool>());
+
+  // Test batch multi-column rhs
+  a = broadcast_to(a, {5, 3, 3});
+  b = broadcast_to(b, {5, 3, 2});
+
+  result = linalg::solve(a, b, Device::cpu);
+  CHECK(allclose(matmul(a, result), b).item<bool>());
+}
+
+TEST_CASE("test solve_triangluar") {
+  // Test lower triangular matrix
+  array a = array({2., 0., 0., 3., 1., 0., 1., -1., 1.}, {3, 3});
+  array b = array({2., 5., 0.});
+
+  array result =
+      linalg::solve_triangular(a, b, /* upper = */ false, Device::cpu);
+  array expected = array({1., 2., 1.});
+  CHECK(allclose(expected, result).item<bool>());
+
+  // Test upper triangular matrix
+  a = array({2., 1., 3., 0., 4., 2., 0., 0., 1.}, {3, 3});
+  b = array({5., 14., 3.});
+
+  result = linalg::solve_triangular(a, b, /* upper = */ true, Device::cpu);
+  expected = array({-3., 2., 3.});
+  CHECK(allclose(expected, result).item<bool>());
+}
diff --git a/ml-stable-diffusion/mlx/tests/load_tests.cpp b/ml-stable-diffusion/mlx/tests/load_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1531ce060cdffa7524ce52c59f5c2362a02a6cac
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/load_tests.cpp
@@ -0,0 +1,270 @@
+// Copyright © 2023 Apple Inc.
+
+#include <filesystem>
+#include <stdexcept>
+#include <vector>
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+std::string get_temp_file(const std::string& name) {
+  return std::filesystem::temp_directory_path().append(name).string();
+}
+
+TEST_CASE("test save_safetensors") {
+  std::string file_path = get_temp_file("test_arr.safetensors");
+  auto map = std::unordered_map<std::string, array>();
+  map.insert({"test", array({1.0, 2.0, 3.0, 4.0})});
+  map.insert({"test2", ones({2, 2})});
+  auto _metadata = std::unordered_map<std::string, std::string>();
+  _metadata.insert({"test", "test"});
+  _metadata.insert({"test2", "test2"});
+  save_safetensors(file_path, map, _metadata);
+  auto [dict, metadata] = load_safetensors(file_path);
+
+  CHECK_EQ(metadata, _metadata);
+
+  CHECK_EQ(dict.size(), 2);
+  CHECK_EQ(dict.count("test"), 1);
+  CHECK_EQ(dict.count("test2"), 1);
+  array test = dict.at("test");
+  CHECK_EQ(test.dtype(), float32);
+  CHECK_EQ(test.shape(), Shape{4});
+  CHECK(array_equal(test, array({1.0, 2.0, 3.0, 4.0})).item<bool>());
+  array test2 = dict.at("test2");
+  CHECK_EQ(test2.dtype(), float32);
+  CHECK_EQ(test2.shape(), Shape{2, 2});
+  CHECK(array_equal(test2, ones({2, 2})).item<bool>());
+}
+
+TEST_CASE("test gguf") {
+  std::string file_path = get_temp_file("test_arr.gguf");
+  using dict = std::unordered_map<std::string, array>;
+  dict original_weights = {
+      {"test", array({1.0f, 2.0f, 3.0f, 4.0f})},
+      {"test2", reshape(arange(6), {3, 2})}};
+
+  {
+    // Check saving loading just arrays, no metadata
+    save_gguf(file_path, original_weights);
+    auto [loaded_weights, loaded_metadata] = load_gguf(file_path);
+    CHECK_EQ(loaded_metadata.size(), 0);
+    CHECK_EQ(loaded_weights.size(), 2);
+    CHECK_EQ(loaded_weights.count("test"), 1);
+    CHECK_EQ(loaded_weights.count("test2"), 1);
+    for (auto [k, v] : loaded_weights) {
+      CHECK(array_equal(v, original_weights.at(k)).item<bool>());
+    }
+  }
+
+  // Test saving and loading string metadata
+  std::unordered_map<std::string, GGUFMetaData> original_metadata;
+  original_metadata.insert({"test_str", "my string"});
+
+  save_gguf(file_path, original_weights, original_metadata);
+  auto [loaded_weights, loaded_metadata] = load_gguf(file_path);
+  CHECK_EQ(loaded_metadata.size(), 1);
+  CHECK_EQ(loaded_metadata.count("test_str"), 1);
+  CHECK_EQ(std::get<std::string>(loaded_metadata.at("test_str")), "my string");
+
+  CHECK_EQ(loaded_weights.size(), 2);
+  CHECK_EQ(loaded_weights.count("test"), 1);
+  CHECK_EQ(loaded_weights.count("test2"), 1);
+  for (auto [k, v] : loaded_weights) {
+    CHECK(array_equal(v, original_weights.at(k)).item<bool>());
+  }
+
+  std::vector<Dtype> unsupported_types = {
+      bool_, uint8, uint32, uint64, int64, bfloat16, complex64};
+  for (auto t : unsupported_types) {
+    dict to_save = {{"test", astype(arange(5), t)}};
+    CHECK_THROWS(save_gguf(file_path, to_save, original_metadata));
+  }
+
+  std::vector<Dtype> supported_types = {int8, int32, float16, float32};
+  for (auto t : supported_types) {
+    auto arr = astype(arange(5), t);
+    dict to_save = {{"test", arr}};
+    save_gguf(file_path, to_save, original_metadata);
+    const auto& [loaded_weights, loaded_metadata] = load_gguf(file_path);
+    CHECK(array_equal(loaded_weights.at("test"), arr).item<bool>());
+  }
+}
+
+TEST_CASE("test gguf metadata") {
+  std::string file_path = get_temp_file("test_arr.gguf");
+  using dict = std::unordered_map<std::string, array>;
+  dict original_weights = {
+      {"test", array({1.0f, 2.0f, 3.0f, 4.0f})},
+      {"test2", reshape(arange(6), {3, 2})}};
+
+  // Scalar array
+  {
+    std::unordered_map<std::string, GGUFMetaData> original_metadata;
+    original_metadata.insert({"test_arr", array(1.0)});
+    save_gguf(file_path, original_weights, original_metadata);
+
+    auto [loaded_weights, loaded_metadata] = load_gguf(file_path);
+    CHECK_EQ(loaded_metadata.size(), 1);
+    CHECK_EQ(loaded_metadata.count("test_arr"), 1);
+
+    auto arr = std::get<array>(loaded_metadata.at("test_arr"));
+    CHECK_EQ(arr.item<float>(), 1.0f);
+  }
+
+  // 1D Array
+  {
+    std::unordered_map<std::string, GGUFMetaData> original_metadata;
+    auto arr = array({1.0, 2.0});
+    original_metadata.insert({"test_arr", arr});
+    save_gguf(file_path, original_weights, original_metadata);
+
+    auto [loaded_weights, loaded_metadata] = load_gguf(file_path);
+    CHECK_EQ(loaded_metadata.size(), 1);
+    CHECK_EQ(loaded_metadata.count("test_arr"), 1);
+
+    auto loaded_arr = std::get<array>(loaded_metadata.at("test_arr"));
+    CHECK(array_equal(arr, loaded_arr).item<bool>());
+
+    // Preserves dims
+    arr = array({1.0});
+    original_metadata["test_arr"] = arr;
+    save_gguf(file_path, original_weights, original_metadata);
+
+    std::tie(loaded_weights, loaded_metadata) = load_gguf(file_path);
+    CHECK_EQ(loaded_metadata.size(), 1);
+    CHECK_EQ(loaded_metadata.count("test_arr"), 1);
+
+    loaded_arr = std::get<array>(loaded_metadata.at("test_arr"));
+    CHECK(array_equal(arr, loaded_arr).item<bool>());
+  }
+
+  // > 1D array throws
+  {
+    std::unordered_map<std::string, GGUFMetaData> original_metadata;
+    original_metadata.insert({"test_arr", array({1.0}, {1, 1})});
+    CHECK_THROWS(save_gguf(file_path, original_weights, original_metadata));
+  }
+
+  // empty array throws
+  {
+    std::unordered_map<std::string, GGUFMetaData> original_metadata;
+    original_metadata.insert({"test_arr", array({})});
+    CHECK_THROWS(save_gguf(file_path, original_weights, original_metadata));
+  }
+
+  // vector of string
+  {
+    std::unordered_map<std::string, GGUFMetaData> original_metadata;
+    std::vector<std::string> data = {"data1", "data2", "data1234"};
+    original_metadata.insert({"meta", data});
+    save_gguf(file_path, original_weights, original_metadata);
+
+    auto [loaded_weights, loaded_metadata] = load_gguf(file_path);
+    CHECK_EQ(loaded_metadata.size(), 1);
+    CHECK_EQ(loaded_metadata.count("meta"), 1);
+    auto& strs = std::get<std::vector<std::string>>(loaded_metadata["meta"]);
+    CHECK_EQ(strs.size(), 3);
+    for (int i = 0; i < strs.size(); ++i) {
+      CHECK_EQ(strs[i], data[i]);
+    }
+  }
+
+  // vector of string, string, scalar, and array
+  {
+    std::unordered_map<std::string, GGUFMetaData> original_metadata;
+    std::vector<std::string> data = {"data1", "data2", "data1234"};
+    original_metadata.insert({"meta1", data});
+    original_metadata.insert({"meta2", array(2.5)});
+    original_metadata.insert({"meta3", array({1, 2, 3})});
+    original_metadata.insert({"meta4", "last"});
+    save_gguf(file_path, original_weights, original_metadata);
+
+    auto [loaded_weights, loaded_metadata] = load_gguf(file_path);
+    CHECK_EQ(loaded_metadata.size(), 4);
+    auto& strs = std::get<std::vector<std::string>>(loaded_metadata["meta1"]);
+    CHECK_EQ(strs.size(), 3);
+    for (int i = 0; i < strs.size(); ++i) {
+      CHECK_EQ(strs[i], data[i]);
+    }
+    auto& arr = std::get<array>(loaded_metadata["meta2"]);
+    CHECK_EQ(arr.item<float>(), 2.5);
+
+    arr = std::get<array>(loaded_metadata["meta3"]);
+    CHECK(array_equal(arr, array({1, 2, 3})).item<bool>());
+
+    auto& str = std::get<std::string>(loaded_metadata["meta4"]);
+    CHECK_EQ(str, "last");
+  }
+}
+
+TEST_CASE("test single array serialization") {
+  // Basic test
+  {
+    auto a = random::uniform(-5.f, 5.f, {2, 5, 12}, float32);
+
+    std::string file_path = get_temp_file("test_arr.npy");
+
+    save(file_path, a);
+    auto b = load(file_path);
+
+    CHECK_EQ(a.dtype(), b.dtype());
+    CHECK_EQ(a.shape(), b.shape());
+    CHECK(array_equal(a, b).item<bool>());
+  }
+
+  // Other shapes
+  {
+    auto a = random::uniform(
+        -5.f,
+        5.f,
+        {
+            1,
+        },
+        float32);
+
+    std::string file_path = get_temp_file("test_arr_0.npy");
+
+    save(file_path, a);
+    auto b = load(file_path);
+
+    CHECK_EQ(a.dtype(), b.dtype());
+    CHECK_EQ(a.shape(), b.shape());
+    CHECK(array_equal(a, b).item<bool>());
+  }
+
+  {
+    auto a = random::uniform(
+        -5.f,
+        5.f,
+        {
+            46,
+        },
+        float32);
+
+    std::string file_path = get_temp_file("test_arr_1.npy");
+
+    save(file_path, a);
+    auto b = load(file_path);
+
+    CHECK_EQ(a.dtype(), b.dtype());
+    CHECK_EQ(a.shape(), b.shape());
+    CHECK(array_equal(a, b).item<bool>());
+  }
+
+  {
+    auto a = random::uniform(-5.f, 5.f, {5, 2, 1, 3, 4}, float32);
+
+    std::string file_path = get_temp_file("test_arr_2.npy");
+
+    save(file_path, a);
+    auto b = load(file_path);
+
+    CHECK_EQ(a.dtype(), b.dtype());
+    CHECK_EQ(a.shape(), b.shape());
+    CHECK(array_equal(a, b).item<bool>());
+  }
+}
diff --git a/ml-stable-diffusion/mlx/tests/ops_tests.cpp b/ml-stable-diffusion/mlx/tests/ops_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..878c7101b89e87fd3867c2d65a03feabc9124741
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/ops_tests.cpp
@@ -0,0 +1,4034 @@
+// Copyright © 2023-2024 Apple Inc.
+
+// Required for using M_PI_2 in MSVC.
+#define _USE_MATH_DEFINES
+
+#include <cmath>
+#include <numeric>
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test copy") {
+  array x(1.0);
+  auto y = copy(x);
+  CHECK_EQ(y.shape(), Shape{});
+  CHECK_NE(y.id(), x.id());
+  CHECK_EQ(y.item<float>(), 1.0f);
+
+  x = array({1, 2}, {2, 1});
+  y = copy(x);
+  CHECK_EQ(y.shape(), Shape{2, 1});
+  CHECK_EQ(y.dtype(), int32);
+  CHECK_NE(y.id(), x.id());
+  CHECK(array_equal(y, x).item<bool>());
+}
+
+TEST_CASE("test reshape") {
+  array x(1.0);
+  CHECK_EQ(reshape(x, {}).shape(), Shape{});
+  CHECK_THROWS_AS(reshape(x, {2}), std::invalid_argument);
+  auto y = reshape(x, {1, 1, 1});
+  CHECK_EQ(y.shape(), Shape{1, 1, 1});
+  y = reshape(x, {-1, 1, 1});
+  CHECK_EQ(y.shape(), Shape{1, 1, 1});
+  y = reshape(x, {1, 1, -1});
+  CHECK_EQ(y.shape(), Shape{1, 1, 1});
+  CHECK_THROWS_AS(reshape(x, {1, -1, -1}), std::invalid_argument);
+  CHECK_THROWS_AS(reshape(x, {2, -1}), std::invalid_argument);
+
+  x = zeros({2, 2, 2});
+  y = reshape(x, {8});
+  CHECK_EQ(y.shape(), Shape{8});
+  CHECK_THROWS_AS(reshape(x, {7}), std::invalid_argument);
+  y = reshape(x, {-1});
+  CHECK_EQ(y.shape(), Shape{8});
+  y = reshape(x, {-1, 2});
+  CHECK_EQ(y.shape(), Shape{4, 2});
+  CHECK_THROWS_AS(reshape(x, {-1, 7}), std::invalid_argument);
+
+  // Works with empty array
+  x = array({});
+  y = reshape(x, {0, 0, 0});
+  CHECK_EQ(y.shape(), Shape{0, 0, 0});
+  y.eval();
+  CHECK_EQ(y.size(), 0);
+  CHECK_THROWS_AS(reshape(x, {}), std::invalid_argument);
+  CHECK_THROWS_AS(reshape(x, {1}), std::invalid_argument);
+  y = reshape(x, {1, 5, 0});
+  CHECK_EQ(y.shape(), Shape{1, 5, 0});
+
+  // Check that reshaping a transposed array doesn't result in a copy
+  x = reshape(arange(64), {2, 4, 8});
+  x.eval();
+  CHECK_EQ(x.strides()[0], 32);
+  CHECK_EQ(x.strides()[1], 8);
+  CHECK_EQ(x.strides()[2], 1);
+  y = reshape(transpose(x, {0, 2, 1}), {2, 4, 2, 4});
+  y.eval();
+  CHECK_EQ(y.strides()[0], 32);
+  CHECK_EQ(y.strides()[1], 2);
+  CHECK_EQ(y.strides()[2], 1);
+  CHECK_EQ(y.strides()[3], 8);
+  CHECK_EQ(x.data<int32_t>(), y.data<int32_t>());
+
+  // Split transposed (2, 8, 4) -> (2, 8, 2, 2)
+  y = reshape(transpose(x, {0, 2, 1}), {2, 8, 2, 2});
+  y.eval();
+  CHECK_EQ(y.strides()[0], 32);
+  CHECK_EQ(y.strides()[1], 1);
+  CHECK_EQ(y.strides()[2], 16);
+  CHECK_EQ(y.strides()[3], 8);
+  CHECK_EQ(x.data<int32_t>(), y.data<int32_t>());
+
+  // Split transposed (2, 8, 4) -> (2, 8, 2, 1, 2)
+  y = reshape(transpose(x, {0, 2, 1}), {2, 8, 2, 1, 2});
+  y.eval();
+  CHECK_EQ(y.strides()[0], 32);
+  CHECK_EQ(y.strides()[1], 1);
+  CHECK_EQ(y.strides()[2], 16);
+  // y.strides()[3] can be anything since y.shape()[3] == 1
+  CHECK_EQ(y.strides()[4], 8);
+  CHECK_EQ(x.data<int32_t>(), y.data<int32_t>());
+
+  // Split transposed (2, 8, 4) -> (2, 8, 2, 1, 2, 1)
+  y = reshape(transpose(x, {0, 2, 1}), {2, 8, 2, 1, 2, 1});
+  y.eval();
+  CHECK_EQ(y.strides()[0], 32);
+  CHECK_EQ(y.strides()[1], 1);
+  CHECK_EQ(y.strides()[2], 16);
+  // y.strides()[3] can be anything since y.shape()[3] == 1
+  CHECK_EQ(y.strides()[4], 8);
+  // y.strides()[5] can be anything since y.shape()[5] == 1
+  CHECK_EQ(x.data<int32_t>(), y.data<int32_t>());
+
+  // Check contiguity preservation
+  x = ones({10, 10});
+  eval(x);
+  CHECK(x.flags().row_contiguous);
+  CHECK(!x.flags().col_contiguous);
+  y = reshape(x, {2, 5, 10});
+  eval(y);
+  CHECK(y.flags().row_contiguous);
+  CHECK(!y.flags().col_contiguous);
+  y = reshape(x, {10, 1, 10, 1});
+  eval(y);
+  CHECK(y.flags().row_contiguous);
+  CHECK(!y.flags().col_contiguous);
+  x = transpose(x, {1, 0});
+  eval(x);
+  CHECK(!x.flags().row_contiguous);
+  CHECK(x.flags().col_contiguous);
+  y = reshape(x, {2, 5, 10});
+  eval(y);
+  CHECK(!y.flags().row_contiguous);
+  CHECK(y.flags().col_contiguous);
+  y = reshape(x, {2, 50});
+  eval(y);
+  CHECK(y.flags().row_contiguous);
+  CHECK(!y.flags().col_contiguous);
+  y = reshape(x, {10, 1, 10, 1});
+  eval(y);
+  CHECK(!y.flags().row_contiguous);
+  CHECK(y.flags().col_contiguous);
+}
+
+TEST_CASE("test flatten") {
+  array x = zeros({2, 3, 4});
+  CHECK_EQ(flatten(x).shape(), Shape({2 * 3 * 4}));
+
+  CHECK_EQ(flatten(x, 1, 1).shape(), Shape({2, 3, 4}));
+  CHECK_EQ(flatten(x, 1, 2).shape(), Shape({2, 3 * 4}));
+  CHECK_EQ(flatten(x, 1, 3).shape(), Shape({2, 3 * 4}));
+  CHECK_EQ(flatten(x, 1, -1).shape(), Shape({2, 3 * 4}));
+  CHECK_EQ(flatten(x, -2, -1).shape(), Shape({2, 3 * 4}));
+  CHECK_EQ(flatten(x, -3, -1).shape(), Shape({2 * 3 * 4}));
+  CHECK_EQ(flatten(x, -4, -1).shape(), Shape({2 * 3 * 4}));
+
+  // Check start > end throws
+  CHECK_THROWS(flatten(x, 2, 1));
+
+  // Check start >= ndim throws
+  CHECK_THROWS(flatten(x, 5, 6));
+
+  // Check end < 0 throws
+  CHECK_THROWS(flatten(x, -5, -4));
+
+  // Check scalar flattens to 1D
+  x = array(1);
+  CHECK_EQ(flatten(x, -3, -1).shape(), Shape({1}));
+  CHECK_EQ(flatten(x, 0, 0).shape(), Shape({1}));
+}
+
+TEST_CASE("test unflatten") {
+  array x = array(1);
+  CHECK_THROWS(unflatten(x, 0, {1, 1}));
+
+  x = array({1});
+  auto out = unflatten(x, 0, {1, 1});
+  CHECK_EQ(out.shape(), Shape({1, 1}));
+  CHECK_THROWS(unflatten(x, 1, {1, 1}));
+  CHECK_THROWS(unflatten(x, 0, {-1, -1}));
+  CHECK_THROWS(unflatten(x, 0, {-1, 2}));
+  CHECK_THROWS(unflatten(x, 0, {}));
+
+  x = zeros({4, 8});
+  out = unflatten(x, 1, {2, 2, 2});
+  CHECK_EQ(out.shape(), Shape({4, 2, 2, 2}));
+}
+
+TEST_CASE("test squeeze and expand") {
+  array x = zeros({2, 1, 2, 1, 2, 1});
+  CHECK_EQ(squeeze(x).shape(), Shape{2, 2, 2});
+  CHECK_EQ(squeeze(x, {1, 3, 5}).shape(), Shape{2, 2, 2});
+  CHECK_EQ(squeeze(x, {-1, -3, -5}).shape(), Shape{2, 2, 2});
+  CHECK_EQ(squeeze(x, 1).shape(), Shape{2, 2, 1, 2, 1});
+  CHECK_EQ(squeeze(x, -1).shape(), Shape{2, 1, 2, 1, 2});
+
+  CHECK_THROWS(squeeze(x, 0));
+  CHECK_THROWS(squeeze(x, 2));
+  CHECK_THROWS(squeeze(x, {1, 3, 1}));
+  CHECK_THROWS(squeeze(x, {1, 3, -3}));
+
+  x = zeros({2, 2});
+  CHECK_EQ(expand_dims(x, 0).shape(), Shape{1, 2, 2});
+  CHECK_EQ(expand_dims(x, -1).shape(), Shape{2, 2, 1});
+  CHECK_EQ(expand_dims(x, 1).shape(), Shape{2, 1, 2});
+  CHECK_EQ(expand_dims(x, {0, 1, 2}).shape(), Shape{1, 1, 1, 2, 2});
+  CHECK_EQ(
+      expand_dims(x, {0, 1, 2, 5, 6, 7}).shape(),
+      Shape{1, 1, 1, 2, 2, 1, 1, 1});
+
+  CHECK_THROWS(expand_dims(x, 3));
+  CHECK_THROWS(expand_dims(x, -4));
+  CHECK_THROWS(expand_dims(x, {0, 1, 0}));
+  CHECK_THROWS(expand_dims(x, {0, 1, -4}));
+}
+
+TEST_CASE("test slice") {
+  array x = array(3);
+  auto out = slice(x, {}, {});
+  CHECK_EQ(out.item<int>(), 3);
+  CHECK_THROWS_AS(slice(x, {1}, {2}), std::invalid_argument);
+  CHECK_THROWS_AS(slice(x, {}, {2}), std::invalid_argument);
+  CHECK_THROWS_AS(slice(x, {0}, {}), std::invalid_argument);
+
+  x = array({3});
+  out = slice(x, {0}, {1});
+  CHECK_EQ(out.item<int>(), 3);
+  out = slice(x, {-1}, {1});
+  CHECK_EQ(out.item<int>(), 3);
+
+  out = slice(x, {-3}, {10});
+  CHECK_EQ(out.item<int>(), 3);
+
+  out = slice(x, {1}, {0});
+  eval(out);
+  CHECK_EQ(out.shape(), Shape{0});
+
+  out = slice(x, {0}, {1}, {1});
+  CHECK_EQ(out.item<int>(), 3);
+
+  out = slice(x, {0}, {1}, {10});
+  CHECK_EQ(out.item<int>(), 3);
+
+  x = array({0, 1, 2, 3, 4, 5, 6, 7}, {2, 4});
+  out = slice(x, {0, 0}, {2, 2});
+  CHECK(array_equal(out, array({0, 1, 4, 5}, {2, 2})).item<bool>());
+
+  out = slice(x, {0, 0}, {0, 2});
+  CHECK(array_equal(out, reshape(array({}), {0, 2})).item<bool>());
+
+  out = slice(x, {0, 2}, {2, 3});
+  CHECK(array_equal(out, array({2, 6}, {2, 1})).item<bool>());
+
+  out = slice(x, {0, 0}, {2, 4}, {1, 2});
+  CHECK(array_equal(out, array({0, 2, 4, 6}, {2, 2})).item<bool>());
+
+  // Check contiguity preservation
+  x = ones({10, 10});
+  eval(x);
+  CHECK(x.flags().row_contiguous);
+  CHECK(!x.flags().col_contiguous);
+  out = slice(x, {0, 0}, {10, 5});
+  eval(out);
+  CHECK(!out.flags().row_contiguous);
+  CHECK(!out.flags().col_contiguous);
+  out = slice(x, {0, 0}, {5, 10});
+  eval(out);
+  CHECK(out.flags().row_contiguous);
+  CHECK(!out.flags().col_contiguous);
+  x = transpose(x, {1, 0});
+  eval(x);
+  CHECK(!x.flags().row_contiguous);
+  CHECK(x.flags().col_contiguous);
+  out = slice(x, {0, 0}, {10, 5});
+  eval(out);
+  CHECK(!out.flags().row_contiguous);
+  CHECK(out.flags().col_contiguous);
+  out = slice(x, {0, 0}, {5, 10});
+  eval(out);
+  CHECK(!out.flags().row_contiguous);
+  CHECK(!out.flags().col_contiguous);
+
+  x = ones({6, 4, 10});
+  out = slice(x, {0, 0, 0}, {6, 4, 10}, {2, 1, 2});
+  eval(out);
+  CHECK(!out.flags().contiguous);
+  CHECK(!out.flags().row_contiguous);
+  CHECK(!out.flags().col_contiguous);
+
+  // Check data size correctness
+  x = ones({4});
+  out = slice(x, {0}, {2});
+  eval(out);
+  CHECK_EQ(out.data_size(), 2);
+
+  out = slice(x, {2}, {4});
+  eval(out);
+  CHECK_EQ(out.data_size(), 2);
+
+  out = slice(x, {0}, {4}, {2});
+  eval(out);
+  CHECK_EQ(out.data_size(), 4);
+
+  x = ones({4, 4});
+  out = slice(x, {0, 0}, {2, 4});
+  eval(out);
+  CHECK_EQ(out.data_size(), 8);
+
+  out = slice(x, {0, 0}, {1, 2});
+  eval(out);
+  CHECK_EQ(out.data_size(), 2);
+
+  out = slice(x, {0, 1}, {4, 4});
+  eval(out);
+  CHECK_EQ(out.data_size(), 15);
+
+  out = slice(x, {1, 2}, {3, 4});
+  eval(out);
+  CHECK_EQ(out.data_size(), 6);
+
+  x = ones({4, 4, 4});
+  out = slice(x, {0, 0, 0}, {4, 2, 2});
+  eval(out);
+  CHECK_EQ(out.data_size(), 54);
+
+  x = ones({4, 4, 4});
+  out = slice(x, {2, 2, 2}, {3, 3, 3});
+  eval(out);
+  CHECK_EQ(out.data_size(), 1);
+
+  x = ones({4, 4, 4});
+  out = slice(x, {2, 2, 2}, {3, 4, 3});
+  eval(out);
+  CHECK_EQ(out.data_size(), 5);
+}
+
+TEST_CASE("test slice update") {
+  array x = array({0., 0., 0., 0., 0., 0., 0., 0.}, {8}, float32);
+  array y = array(
+      {
+          1.,
+          2.,
+          3.,
+          4.,
+      },
+      {4},
+      float32);
+
+  auto out = slice_update(x, y, {2}, {6}, {1});
+  CHECK(array_equal(slice(out, {2}, {6}, {1}), y).item<bool>());
+
+  out = slice_update(x, y, {5}, {1}, {-1});
+  CHECK(array_equal(slice(out, {5}, {1}, {-1}), y).item<bool>());
+
+  x = reshape(x, {2, 4});
+  out = slice_update(x, y, {0, 0}, {2, 4}, {1, 1});
+  out = reshape(out, {8});
+  CHECK(array_equal(slice(out, {0}, {4}, {1}), y).item<bool>());
+  CHECK(array_equal(slice(out, {4}, {8}, {1}), y).item<bool>());
+}
+
+TEST_CASE("test dynamic slice") {
+  auto src = reshape(arange(6), {2, 3});
+  CHECK_THROWS(slice(src, array({1, 0, 0}), {0, 0, 0}, {1, 1}));
+  CHECK_THROWS(slice(src, array({1, 0}), {0}, {1, 1}));
+  CHECK_THROWS(slice(src, array({1}), {3}, {1, 1}));
+  CHECK_THROWS(slice(src, array({1, 0}), {0, 0}, {1, 1}));
+
+  CHECK_THROWS(slice(src, array({1}), {0}, {2, 4}));
+  CHECK_THROWS(slice(src, array({1.0f}, float32), {0}, {1, 1}));
+
+  auto out = slice(src, array({1}), {0}, {1, 2});
+  auto expected = array({3, 4}, {1, 2});
+  CHECK(array_equal(out, expected).item<bool>());
+
+  out = slice(src, array({1, 1}), {0, 1}, {1, 2});
+  expected = array({4, 5}, {1, 2});
+  CHECK(array_equal(out, expected).item<bool>());
+}
+
+TEST_CASE("test dynamic slice update") {
+  auto src = zeros({2, 3}, int32);
+  auto upd = ones({1, 2}, int32);
+  CHECK_THROWS(slice_update(src, upd, array({1, 0, 0}), {0, 0, 0}));
+  CHECK_THROWS(slice_update(src, upd, array({1, 0}), {0}));
+  CHECK_THROWS(slice_update(src, upd, array({1}), {3}));
+  CHECK_THROWS(slice_update(src, upd, array({1, 0}), {0, 0}));
+
+  upd = ones({4}, int32);
+  CHECK_THROWS(slice_update(src, upd, array({1}), {0}));
+  upd = ones({1, 4}, int32);
+  CHECK_THROWS(slice_update(src, upd, array({1}), {0}));
+  CHECK_THROWS(slice_update(src, upd, array({1.0f}, float32), {0}));
+
+  upd = ones({1, 2}, int32);
+  auto out = slice_update(src, upd, array({1}), {0});
+  auto expected = reshape(array({0, 0, 0, 1, 1, 0}), {2, 3});
+  CHECK(array_equal(out, expected).item<bool>());
+
+  upd = ones({1, 2}, int32);
+  out = slice_update(src, upd, array({1, 1}), {0, 1});
+  expected = reshape(array({0, 0, 0, 0, 1, 1}), {2, 3});
+  CHECK(array_equal(out, expected).item<bool>());
+}
+
+TEST_CASE("test split") {
+  array x = array(1);
+  CHECK_THROWS(split(x, 0));
+
+  x = array({3});
+  CHECK_EQ(split(x, 1)[0].item<int>(), 3);
+
+  x = array({0, 1, 2});
+  CHECK_THROWS(split(x, 3, 1));
+  CHECK_THROWS(split(x, 3, -2));
+
+  auto out = split(x, 3, 0);
+  CHECK_EQ(out.size(), 3);
+
+  out = split(x, 3, -1);
+  CHECK_EQ(out.size(), 3);
+  for (auto i = 0; i < 3; ++i) {
+    CHECK_EQ(out[i].shape(), Shape{1});
+    CHECK_EQ(out[i].dtype(), int32);
+    CHECK_EQ(out[i].item<int>(), i);
+  }
+
+  x = array({0, 1, 2, 3, 4, 5}, {2, 3});
+  out = split(x, 2);
+  CHECK(array_equal(out[0], array({0, 1, 2}, {1, 3})).item<bool>());
+  CHECK(array_equal(out[1], array({3, 4, 5}, {1, 3})).item<bool>());
+  out = split(x, 3, 1);
+  CHECK(array_equal(out[0], array({0, 3}, {2, 1})).item<bool>());
+  CHECK(array_equal(out[1], array({1, 4}, {2, 1})).item<bool>());
+  CHECK(array_equal(out[2], array({2, 5}, {2, 1})).item<bool>());
+
+  x = zeros({8, 12});
+  out = split(x, 2);
+  CHECK_EQ(out.size(), 2);
+  CHECK_EQ(out[0].shape(), Shape{4, 12});
+  CHECK_EQ(out[1].shape(), Shape{4, 12});
+  out = split(x, 3, 1);
+  CHECK_EQ(out.size(), 3);
+  CHECK_EQ(out[0].shape(), Shape{8, 4});
+  CHECK_EQ(out[1].shape(), Shape{8, 4});
+  CHECK_EQ(out[2].shape(), Shape{8, 4});
+
+  out = split(x, Shape{});
+  CHECK_EQ(out.size(), 1);
+  CHECK_EQ(out[0].shape(), x.shape());
+
+  out = split(x, {3, 7});
+  CHECK_EQ(out.size(), 3);
+  CHECK_EQ(out[0].shape(), Shape{3, 12});
+  CHECK_EQ(out[1].shape(), Shape{4, 12});
+  CHECK_EQ(out[2].shape(), Shape{1, 12});
+
+  out = split(x, Shape{20});
+  CHECK_EQ(out.size(), 2);
+  CHECK_EQ(out[0].shape(), Shape{8, 12});
+  CHECK_EQ(out[1].shape(), Shape{0, 12});
+
+  // Negative indices
+  out = split(x, Shape{-5});
+  CHECK_EQ(out[0].shape(), Shape{3, 12});
+  CHECK_EQ(out[1].shape(), Shape{5, 12});
+
+  // Different axis
+  out = split(x, {2, 8}, 1);
+  CHECK_EQ(out[0].shape(), Shape{8, 2});
+  CHECK_EQ(out[1].shape(), Shape{8, 6});
+  CHECK_EQ(out[2].shape(), Shape{8, 4});
+
+  // Out of order indices
+  x = arange(5);
+  out = split(x, {2, 1, 2});
+  CHECK(array_equal(out[0], array({0, 1})).item<bool>());
+  CHECK(array_equal(out[1], array({})).item<bool>());
+  CHECK(array_equal(out[2], array({1})).item<bool>());
+  CHECK(array_equal(out[3], array({2, 3, 4})).item<bool>());
+}
+
+TEST_CASE("test swap and move axes") {
+  // Test swapaxes
+  array a(0.0);
+  CHECK_THROWS(swapaxes(a, 0, 0));
+
+  a = zeros({2});
+  CHECK_THROWS(swapaxes(a, 0, 1));
+  CHECK_EQ(swapaxes(a, 0, 0).shape(), Shape{2});
+  CHECK_EQ(swapaxes(a, -1, -1).shape(), Shape{2});
+
+  a = zeros({2, 3, 4});
+  CHECK_THROWS(swapaxes(a, 0, -4));
+  CHECK_THROWS(swapaxes(a, 0, 3));
+  CHECK_THROWS(swapaxes(a, 3, 0));
+  CHECK_THROWS(swapaxes(a, -4, 0));
+  CHECK_EQ(swapaxes(a, 0, 2).shape(), Shape{4, 3, 2});
+  CHECK_EQ(swapaxes(a, 0, 1).shape(), Shape{3, 2, 4});
+  CHECK_EQ(swapaxes(a, 0, -1).shape(), Shape{4, 3, 2});
+  CHECK_EQ(swapaxes(a, -2, 2).shape(), Shape{2, 4, 3});
+
+  // Test moveaxis
+  a = array(0.0);
+  CHECK_THROWS(moveaxis(a, 0, 0));
+
+  a = zeros({2});
+  CHECK_THROWS(moveaxis(a, 0, 1));
+  CHECK_EQ(moveaxis(a, 0, 0).shape(), Shape{2});
+  CHECK_EQ(moveaxis(a, -1, -1).shape(), Shape{2});
+
+  a = zeros({2, 3, 4});
+  CHECK_THROWS(moveaxis(a, 0, -4));
+  CHECK_THROWS(moveaxis(a, 0, 3));
+  CHECK_THROWS(moveaxis(a, 3, 0));
+  CHECK_THROWS(moveaxis(a, -4, 0));
+  CHECK_EQ(moveaxis(a, 0, 2).shape(), Shape{3, 4, 2});
+  CHECK_EQ(moveaxis(a, 0, 1).shape(), Shape{3, 2, 4});
+  CHECK_EQ(moveaxis(a, 0, -1).shape(), Shape{3, 4, 2});
+  CHECK_EQ(moveaxis(a, -2, 2).shape(), Shape{2, 4, 3});
+}
+
+TEST_CASE("test transpose") {
+  array x(1);
+  auto y = transpose(x);
+  CHECK_EQ(y.shape(), Shape{});
+  CHECK_EQ(y.item<int>(), 1);
+  CHECK_THROWS_AS(transpose(x, {0}), std::invalid_argument);
+  CHECK_THROWS_AS(transpose(x, {1}), std::invalid_argument);
+
+  x = array({1}, {1});
+  y = transpose(x);
+  CHECK_EQ(y.shape(), Shape{1});
+  CHECK_EQ(y.item<int>(), 1);
+
+  // Negative indices
+  y = transpose(x, {-1});
+  CHECK_EQ(y.shape(), Shape{1});
+  CHECK_EQ(y.item<int>(), 1);
+
+  CHECK_THROWS_AS(transpose(x, {1}), std::invalid_argument);
+  CHECK_THROWS_AS(transpose(x, {0, 0}), std::invalid_argument);
+
+  // Works with empty array
+  x = array({});
+  y = transpose(x);
+  CHECK_EQ(y.shape(), Shape{0});
+  y.eval();
+  CHECK_EQ(y.size(), 0);
+
+  x = array({1, 2, 3, 4, 5, 6}, {2, 3});
+  y = transpose(x);
+  CHECK_EQ(y.shape(), Shape{3, 2});
+  y = transpose(x, {-1, 0});
+  CHECK_EQ(y.shape(), Shape{3, 2});
+  y = transpose(x, {-1, -2});
+  CHECK_EQ(y.shape(), Shape{3, 2});
+  y.eval();
+  CHECK(array_equal(y, array({1, 4, 2, 5, 3, 6}, {3, 2})).item<bool>());
+  y = transpose(x, {0, 1});
+  CHECK_EQ(y.shape(), Shape{2, 3});
+  CHECK(array_equal(y, x).item<bool>());
+  y = transpose(x, {0, -1});
+  CHECK_EQ(y.shape(), Shape{2, 3});
+  CHECK(array_equal(y, x).item<bool>());
+
+  CHECK_THROWS_AS(transpose(x, {}), std::invalid_argument);
+  CHECK_THROWS_AS(transpose(x, {0}), std::invalid_argument);
+  CHECK_THROWS_AS(transpose(x, {0, 0}), std::invalid_argument);
+  CHECK_THROWS_AS(transpose(x, {0, 0, 0}), std::invalid_argument);
+  CHECK_THROWS_AS(transpose(x, {0, 1, 1}), std::invalid_argument);
+
+  x = array({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}, {2, 3, 2});
+  y = transpose(x);
+  CHECK_EQ(y.shape(), Shape{2, 3, 2});
+  auto expected = array({1, 7, 3, 9, 5, 11, 2, 8, 4, 10, 6, 12}, {2, 3, 2});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  y = transpose(x, {0, 1, 2});
+  CHECK_EQ(y.shape(), Shape{2, 3, 2});
+  CHECK(array_equal(y, x).item<bool>());
+  y = transpose(x, {1, 0, 2});
+  CHECK_EQ(y.shape(), Shape{3, 2, 2});
+  expected = array({1, 2, 7, 8, 3, 4, 9, 10, 5, 6, 11, 12}, {3, 2, 2});
+  CHECK(array_equal(y, expected).item<bool>());
+  y = transpose(x, {0, 2, 1});
+  CHECK_EQ(y.shape(), Shape{2, 2, 3});
+  expected = array({1, 3, 5, 2, 4, 6, 7, 9, 11, 8, 10, 12}, {2, 2, 3});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  // Check reshaping a transposed array
+  x = array({0, 1, 2, 3, 4, 5, 6, 7}, {4, 2});
+  x = reshape(transpose(x), {2, 2, 2});
+  expected = array({0, 2, 4, 6, 1, 3, 5, 7}, {2, 2, 2});
+  CHECK(array_equal(x, expected).item<bool>());
+
+  // Check maintaining contiguous status
+  x = array({0, 1, 2, 3, 4, 5, 6, 7}, {1, 4, 1, 2});
+  CHECK(x.flags().row_contiguous);
+  x = transpose(x, {2, 1, 0, 3});
+  eval(x);
+  CHECK(x.flags().row_contiguous);
+}
+
+TEST_CASE("test comparison ops") {
+  // Empty array
+  {
+    array x({});
+    array y({});
+    auto z = x == y;
+    CHECK_EQ(z.dtype(), bool_);
+    CHECK_EQ(z.shape(), Shape{0});
+  }
+
+  // Basic cases
+  {
+    array x(1.0);
+    array y(1.0);
+    CHECK(equal(x, y).item<bool>());
+    CHECK((x == y).item<bool>());
+    CHECK((x == 1.0f).item<bool>());
+    CHECK((1.0f == y).item<bool>());
+
+    CHECK(!(x != y).item<bool>());
+    CHECK(!not_equal(x, y).item<bool>());
+    CHECK(!(1.0f != y).item<bool>());
+    CHECK(!(x != 1.0f).item<bool>());
+
+    CHECK(array_equal(x, y).item<bool>());
+
+    x = array(0.0);
+    CHECK(!equal(x, y).item<bool>());
+    CHECK(!array_equal(x, y).item<bool>());
+    CHECK(not_equal(x, y).item<bool>());
+  }
+
+  // Greater and less
+  {
+    array x(1.0);
+    array y(0.0);
+    CHECK(greater(x, y).item<bool>());
+    CHECK((x > 0.0f).item<bool>());
+    CHECK((1.0f > y).item<bool>());
+    CHECK(greater_equal(x, y).item<bool>());
+    CHECK((1.0f >= y).item<bool>());
+    CHECK(!(x > 1.0f).item<bool>());
+    CHECK((x >= 1.0f).item<bool>());
+
+    CHECK(less(y, x).item<bool>());
+    CHECK((y < 1.0).item<bool>());
+    CHECK((y <= 1.0f).item<bool>());
+    CHECK(!(x < 1.0).item<bool>());
+    CHECK((x <= 1.0f).item<bool>());
+  }
+
+  // Check array_equal works
+  {
+    auto x = zeros({5, 5});
+    auto y = zeros({5, 5});
+    CHECK(array_equal(x, y).item<bool>());
+
+    x = zeros({1, 1});
+    CHECK(!array_equal(x, y).item<bool>());
+
+    x = ones({5, 5});
+    CHECK(!array_equal(x, y).item<bool>());
+
+    x = array({0.0f, 1.0f, NAN});
+    y = array({0.0f, 1.0f, NAN});
+    CHECK(!array_equal(x, y).item<bool>());
+    CHECK(array_equal(x, y, true).item<bool>());
+  }
+
+  // Check other types
+  {
+    auto x = zeros({5, 5}, int32);
+    auto y = zeros({5, 5}, int32);
+    CHECK(array_equal(x, y).item<bool>());
+
+    x = ones({5, 5}, bool_);
+    y = ones({5, 5}, bool_);
+    CHECK(array_equal(x, y).item<bool>());
+  }
+
+  // Check type promotion
+  {
+    array x(1.0f);
+    array y(1);
+    CHECK_EQ(equal(x, y).item<bool>(), true);
+
+    x = array(true, bool_);
+    CHECK_EQ(equal(x, y).item<bool>(), true);
+  }
+
+  // Broadcasting works
+  {
+    auto x = zeros({1, 2});
+    auto y = zeros({2, 1});
+    auto z = equal(x, y);
+    CHECK_EQ(z.dtype(), bool_);
+    CHECK_EQ(z.shape(), Shape{2, 2});
+    auto expected = array({true, true, true, true}, {2, 2});
+    CHECK(array_equal(z, expected).item<bool>());
+
+    x = array({1.0, 2.0}, {1, 2});
+    y = array({1.0, 2.0}, {2, 1});
+    z = equal(x, y);
+    CHECK_EQ(z.dtype(), bool_);
+    CHECK_EQ(z.shape(), Shape{2, 2});
+    expected = array({true, false, false, true}, {2, 2});
+    CHECK(array_equal(z, expected).item<bool>());
+
+    expected = array({false, true, false, false}, {2, 2});
+    z = greater(x, y);
+    CHECK(array_equal(z, expected).item<bool>());
+
+    expected = array({true, true, false, true}, {2, 2});
+    z = greater_equal(x, y);
+    CHECK(array_equal(z, expected).item<bool>());
+
+    expected = array({false, false, true, false}, {2, 2});
+    z = less(x, y);
+    CHECK(array_equal(z, expected).item<bool>());
+
+    expected = array({true, false, true, true}, {2, 2});
+    z = less_equal(x, y);
+    CHECK(array_equal(z, expected).item<bool>());
+  }
+}
+
+TEST_CASE("test is nan") {
+  array x(1.0f);
+  CHECK_FALSE(isnan(x).item<bool>());
+
+  array y(NAN);
+  CHECK(isnan(y).item<bool>());
+
+  array z = identity(7);
+  CHECK_FALSE(all(isnan(z)).item<bool>());
+
+  array w = array({1.0f, NAN, 2.0f});
+  CHECK_FALSE(all(isnan(w)).item<bool>());
+
+  array a(1.0f, bfloat16);
+  CHECK_FALSE(isnan(a).item<bool>());
+
+  array b(1.0f, float16);
+  CHECK_FALSE(isnan(b).item<bool>());
+
+  array c(NAN, bfloat16);
+  CHECK(isnan(c).item<bool>());
+
+  array d(NAN, float16);
+  CHECK(isnan(d).item<bool>());
+}
+
+TEST_CASE("test is inf") {
+  array x(1.0f);
+  CHECK_FALSE(isinf(x).item<bool>());
+
+  auto inf = std::numeric_limits<float>::infinity();
+
+  array y(inf);
+  CHECK(isinf(y).item<bool>());
+
+  auto neginf = -std::numeric_limits<float>::infinity();
+  CHECK(isinf(array(neginf)).item<bool>());
+
+  array z = identity(7);
+  CHECK_FALSE(any(isinf(z)).item<bool>());
+
+  array w = array({1.0f, inf, 2.0f});
+  CHECK(array_equal(array({false, true, false}), isinf(w)).item<bool>());
+
+  array a(1.0f, bfloat16);
+  CHECK_FALSE(isinf(a).item<bool>());
+
+  array b(1.0f, float16);
+  CHECK_FALSE(isinf(b).item<bool>());
+
+  array c(inf, bfloat16);
+  CHECK(isinf(c).item<bool>());
+
+  array d(inf, float16);
+  CHECK(isinf(d).item<bool>());
+}
+
+TEST_CASE("test all close") {
+  array x(1.0f);
+  array y(1.0f);
+  CHECK(allclose(x, y).item<bool>());
+
+  y = array(1.1f);
+  CHECK_FALSE(allclose(x, y).item<bool>());
+  CHECK(allclose(x, y, 0.1).item<bool>());
+  CHECK_FALSE(allclose(x, y, 0.01).item<bool>());
+  CHECK(allclose(x, y, 0.01, 0.1).item<bool>());
+}
+
+TEST_CASE("test is close") {
+  {
+    array a({1.0, std::numeric_limits<float>::infinity()});
+    array b({1.0, std::numeric_limits<float>::infinity()});
+    CHECK(array_equal(isclose(a, b), array({true, true})).item<bool>());
+  }
+  {
+    array a({1.0, -std::numeric_limits<float>::infinity()});
+    array b({1.0, -std::numeric_limits<float>::infinity()});
+    CHECK(array_equal(isclose(a, b), array({true, true})).item<bool>());
+  }
+  {
+    array a({1.0, std::numeric_limits<float>::infinity()});
+    array b({1.0, -std::numeric_limits<float>::infinity()});
+    CHECK(array_equal(isclose(a, b), array({true, false})).item<bool>());
+  }
+  {
+    array a({1.0, std::nan("1"), std::nan("1")});
+    array b({1.0, std::nan("1"), 2.0});
+    CHECK(array_equal(isclose(a, b), array({true, false, false})).item<bool>());
+  }
+  {
+    array a({1.0, std::nan("1"), std::nan("1")});
+    array b({1.0, std::nan("1"), 2.0});
+    CHECK(
+        array_equal(isclose(a, b, 1e-5, 1e-8, true), array({true, true, false}))
+            .item<bool>());
+  }
+}
+
+TEST_CASE("test reduction ops") {
+  // Check shapes and throws correctly
+  {
+    auto x = array(1);
+    auto out = sum(x);
+    CHECK_EQ(out.ndim(), 0);
+    CHECK_THROWS_AS(sum(x, 0), std::out_of_range);
+    CHECK_THROWS_AS(sum(x, -1), std::out_of_range);
+    out = sum(x, std::vector<int>{});
+    CHECK_EQ(out.shape(), Shape{});
+    CHECK_EQ(out.size(), 1);
+
+    x = array({});
+    out = sum(x);
+    CHECK_EQ(out.shape(), Shape{});
+    CHECK_EQ(out.size(), 1);
+    out = sum(x, true);
+    CHECK_EQ(out.shape(), Shape{1});
+    out = sum(x, std::vector<int>{});
+    CHECK_EQ(out.shape(), x.shape());
+
+    x = zeros({2});
+    out = sum(x);
+    CHECK_EQ(out.ndim(), 0);
+    out = sum(x, -1);
+    CHECK_EQ(out.ndim(), 0);
+    out = sum(x, -1, true);
+    CHECK_EQ(out.ndim(), 1);
+    CHECK_EQ(out.shape(), Shape{1});
+
+    CHECK_THROWS_AS(sum(x, 1), std::out_of_range);
+    CHECK_THROWS_AS(sum(x, -2), std::out_of_range);
+    CHECK_THROWS_AS(sum(x, {0, 0}), std::invalid_argument);
+    CHECK_THROWS_AS(sum(x, {-1, 0}), std::invalid_argument);
+
+    x = zeros({2, 3, 4});
+    out = sum(x, {0, 2});
+    CHECK_EQ(out.shape(), Shape{3});
+    out = sum(x, std::vector<int>{});
+    CHECK_EQ(out.shape(), x.shape());
+
+    out = sum(x, {0, -1});
+    CHECK_EQ(out.shape(), Shape{3});
+
+    out = sum(x, {0, -1}, true);
+    CHECK_EQ(out.shape(), Shape{1, 3, 1});
+
+    out = sum(x, true);
+    CHECK_EQ(out.shape(), Shape{1, 1, 1});
+
+    out = sum(x);
+    CHECK_EQ(out.shape(), Shape{});
+
+    CHECK_THROWS_AS(sum(x, 3), std::out_of_range);
+    CHECK_THROWS_AS(sum(x, -4), std::out_of_range);
+    CHECK_THROWS_AS(sum(x, {0, 1, -2}), std::invalid_argument);
+  }
+
+  // Test sum
+  {
+    auto x = array({});
+    CHECK_EQ(sum(x).item<float>(), 0.0f);
+
+    x = array({1, 2, 3});
+    CHECK_EQ(sum(x).item<int>(), 6);
+    CHECK(array_equal(sum(x, std::vector<int>{}), x).item<bool>());
+
+    x = ones({2, 3});
+    CHECK(array_equal(sum(x, 1), full({2}, 3.0f)).item<bool>());
+    CHECK(array_equal(sum(x, 0), full({3}, 2.0f)).item<bool>());
+    CHECK_EQ(sum(x, {0, 1}).item<float>(), 6.0f);
+
+    x = ones({2, 3, 4});
+    CHECK(array_equal(sum(x, 0), full({3, 4}, 2.0f)).item<bool>());
+    CHECK(array_equal(sum(x, 1), full({2, 4}, 3.0f)).item<bool>());
+    CHECK(array_equal(sum(x, 2), full({2, 3}, 4.0f)).item<bool>());
+    CHECK(array_equal(sum(x, {0, 1}), full({4}, 6.0f)).item<bool>());
+    CHECK(array_equal(sum(x, {0, 2}), full({3}, 8.0f)).item<bool>());
+    CHECK(array_equal(sum(x, {1, 2}), full({2}, 12.0f)).item<bool>());
+
+    // Output for bool gets higher precision
+    x = array({true, true, true});
+    CHECK_EQ(sum(x).item<int32_t>(), 3);
+
+    x = array(2.0f);
+    x = broadcast_to(x, {2, 2, 2});
+    CHECK_EQ(sum(x).item<float>(), 16.0f);
+
+    // Tests with non-uniform results after reduction
+    x = array({1.0f, 1.0f, 1.0f, 2.0f, 2.0f, 2.0f}, {2, 3});
+    CHECK(array_equal(sum(x, 0), full({3}, 3.0f)).item<bool>());
+    CHECK(array_equal(sum(x, 1), array({3.0f, 6.0f}, {2})).item<bool>());
+  }
+
+  // Test unsigned sum
+  {
+    const int num_elems = 1000;
+
+    auto x = astype(full({num_elems}, 255), uint8);
+    CHECK_EQ(sum(x, Device::cpu).item<uint32_t>(), 255 * num_elems);
+
+    x = astype(full({num_elems}, 65535), uint16);
+    CHECK_EQ(sum(x, Device::cpu).item<uint32_t>(), 65535 * num_elems);
+
+    x = full({3, 3, 3}, 10000, uint32);
+    CHECK_EQ(sum(x, Device::cpu).item<uint32_t>(), 270000);
+
+    x = full({3, 3, 3}, 10000, uint64);
+    CHECK_EQ(sum(x, Device::cpu).item<uint64_t>(), 270000);
+  }
+
+  // Test prod
+  {
+    auto x = array({});
+    CHECK_EQ(prod(x).item<float>(), 1.0f);
+
+    x = array({2, 2, 2});
+    CHECK_EQ(prod(x).item<int>(), 8);
+    CHECK(array_equal(prod(x, std::vector<int>{}), x).item<bool>());
+
+    x = full({2, 3}, 2.0f);
+    CHECK(array_equal(prod(x, 1), full({2}, 8.0f)).item<bool>());
+    CHECK(array_equal(prod(x, 0), full({3}, 4.0f)).item<bool>());
+    CHECK_EQ(prod(x, {0, 1}).item<float>(), 64.0f);
+
+    x = full({2, 3, 4}, 2.0f);
+    CHECK(array_equal(prod(x, 0), full({3, 4}, 4.0f)).item<bool>());
+    CHECK(array_equal(prod(x, 1), full({2, 4}, 8.0f)).item<bool>());
+    CHECK(array_equal(prod(x, 2), full({2, 3}, 16.0f)).item<bool>());
+    CHECK(array_equal(prod(x, {0, 1}), full({4}, 64.0f)).item<bool>());
+    CHECK(array_equal(prod(x, {0, 2}), full({3}, 256.0f)).item<bool>());
+    CHECK(array_equal(prod(x, {1, 2}), full({2}, 4096.0f)).item<bool>());
+
+    // Tests with non-uniform results after reduction
+    x = array({1.0f, 1.0f, 1.0f, 2.0f, 2.0f, 2.0f}, {2, 3});
+    CHECK(array_equal(prod(x, 0), full({3}, 2.0f)).item<bool>());
+    CHECK(array_equal(prod(x, 1), array({1.0f, 8.0f}, {2})).item<bool>());
+
+    x = array({true, true, true, false, true, false}, {2, 3});
+    CHECK(array_equal(prod(x, 0), array({false, true, false})).item<bool>());
+    CHECK(array_equal(prod(x, 1), array({true, false})).item<bool>());
+  }
+
+  // Test unsigned prod
+  {
+    auto x = array({255, 255}, {2}, uint8);
+    CHECK_EQ(prod(x, Device::cpu).item<uint32_t>(), 65025);
+
+    x = array({65535, 2}, {2}, uint16);
+    CHECK_EQ(prod(x, Device::cpu).item<uint32_t>(), 131070);
+
+    x = array({100000, 2}, {2}, uint32);
+    CHECK_EQ(prod(x, Device::cpu).item<uint32_t>(), 200000);
+
+    x = array({100000, 2}, {2}, uint64);
+    CHECK_EQ(prod(x, Device::cpu).item<uint64_t>(), 200000);
+  }
+
+  // Test all
+  {
+    auto x = array({});
+    CHECK_EQ(all(x).item<bool>(), true);
+
+    x = array({2, 2, 2});
+    CHECK_EQ(all(x).item<bool>(), true);
+    auto out = all(x, std::vector<int>{});
+    CHECK(array_equal(out, array({true, true, true})).item<bool>());
+
+    x = array({0, 2, 2});
+    CHECK_EQ(all(x).item<bool>(), false);
+
+    x = array({true, true, true, false, true, false}, {2, 3});
+    CHECK(array_equal(all(x, 1), array({true, false})).item<bool>());
+    CHECK(array_equal(all(x, 0), array({false, true, false})).item<bool>());
+  }
+
+  // Test any
+  {
+    auto x = array({});
+    CHECK_EQ(any(x).item<bool>(), false);
+
+    x = array({0, 0, 0});
+    CHECK_EQ(any(x).item<bool>(), false);
+
+    x = array({0, 2, 0});
+    CHECK_EQ(any(x).item<bool>(), true);
+    auto out = any(x, std::vector<int>{});
+    CHECK(array_equal(out, array({false, true, false})).item<bool>());
+
+    x = array({true, false, true, false, false, false}, {2, 3});
+    CHECK(array_equal(any(x, 1), array({true, false})).item<bool>());
+    CHECK(array_equal(any(x, 0), array({true, false, true})).item<bool>());
+  }
+
+  // Test max and min
+  {
+    auto x = array({});
+    CHECK_THROWS(max(x));
+    CHECK_THROWS(min(x));
+
+    x = array({1.0f, 2.0f, 3.0f});
+    CHECK_EQ(max(x).item<float>(), 3.0f);
+    CHECK_EQ(min(x).item<float>(), 1.0f);
+
+    x = array({-2.0f, -1.0f});
+    CHECK_EQ(max(x).item<float>(), -1.0f);
+    CHECK_EQ(min(x).item<float>(), -2.0f);
+
+    constexpr float inf = std::numeric_limits<float>::infinity();
+    x = array({inf});
+    CHECK_EQ(min(x).item<float>(), inf);
+
+    x = array({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}, {2, 3});
+    CHECK(array_equal(max(x, 0), array({4.0f, 5.0f, 6.0f})).item<bool>());
+    CHECK(array_equal(max(x, 1), array({3.0f, 6.0f})).item<bool>());
+    CHECK(array_equal(min(x, 0), array({1.0f, 2.0f, 3.0f})).item<bool>());
+    CHECK(array_equal(min(x, 1), array({1.0f, 4.0f})).item<bool>());
+
+    x = array({1u, 2u, 3u});
+    CHECK_EQ(max(x).item<uint32_t>(), 3u);
+    CHECK_EQ(min(x).item<uint32_t>(), 1u);
+
+    x = array({1u, 2u, 3u, 4u, 5u, 6u}, {2, 3});
+    CHECK(array_equal(max(x, 0), array({4u, 5u, 6u})).item<bool>());
+    CHECK(array_equal(max(x, 1), array({3u, 6u})).item<bool>());
+    CHECK(array_equal(min(x, 0), array({1u, 2u, 3u})).item<bool>());
+    CHECK(array_equal(min(x, 1), array({1u, 4u})).item<bool>());
+
+    x = array({true, false, true, false, false, false}, {2, 3});
+    CHECK(array_equal(max(x, 1), array({true, false})).item<bool>());
+    CHECK(array_equal(max(x, 0), array({true, false, true})).item<bool>());
+
+    x = array({true, true, true, false, true, false}, {2, 3});
+    CHECK(array_equal(min(x, 1), array({true, false})).item<bool>());
+    CHECK(array_equal(min(x, 0), array({false, true, false})).item<bool>());
+
+    x = array({1.0f, NAN, 3.0f, 4.0f, 5.0f, 6.0f}, {2, 3});
+    CHECK(array_equal(max(x, 0), array({4.0f, NAN, 6.0f}), true).item<bool>());
+    CHECK(array_equal(max(x, 1), array({NAN, 6.0f}), true).item<bool>());
+  }
+
+  // Test logsumexp
+  {
+    auto x = array({});
+    CHECK_THROWS(logsumexp(x));
+
+    constexpr float inf = std::numeric_limits<float>::infinity();
+
+    x = array({-inf, -inf});
+    CHECK_EQ(logsumexp(x).item<float>(), -inf);
+
+    x = repeat(array(-inf), 5000);
+    CHECK_EQ(logsumexp(x).item<float>(), -inf);
+
+    x = array({0.0f, -inf});
+    CHECK_EQ(logsumexp(x).item<float>(), 0.0f);
+
+    x = array({0.0f, inf});
+    CHECK_EQ(logsumexp(x).item<float>(), inf);
+
+    x = reshape(arange(6, float32), {2, 3});
+
+    std::vector<float> nums = {0.0f, 1.0f, 2.0f, 3.0f};
+    x = array(nums.data(), {2, 2});
+    auto y = logsumexp(x, {0, 1}, true);
+    CHECK_EQ(y.shape(), Shape{1, 1});
+    auto result = std::log(
+        std::exp(nums[0]) + std::exp(nums[1]) + std::exp(nums[2]) +
+        std::exp(nums[3]));
+    CHECK(y.item<float>() == doctest::Approx(result));
+    auto expected = array(
+        {std::log(std::exp(nums[0]) + std::exp(nums[2])),
+         std::log(std::exp(nums[1]) + std::exp(nums[3]))});
+    CHECK(allclose(logsumexp(x, 0), expected).item<bool>());
+
+    expected = array(
+        {std::log(std::exp(nums[0]) + std::exp(nums[1])),
+         std::log(std::exp(nums[2]) + std::exp(nums[3]))});
+    CHECK(allclose(logsumexp(x, 1), expected).item<bool>());
+  }
+
+  // Test softmax
+  {
+    for (auto t : {float16, bfloat16, float32}) {
+      const auto rtol = t == float32 ? 1e-5 : 1e-2;
+      auto x = array({}, t);
+      CHECK(array_equal(x, softmax(x)).item<bool>());
+
+      // all zeros
+      x = array({0., 0., 0., 0.}, t);
+      auto y = array({0.25, 0.25, 0.25, 0.25}, t);
+      CHECK(array_equal(y, softmax(x)).item<bool>());
+      CHECK(array_equal(y, softmax(x, -1)).item<bool>());
+      CHECK(array_equal(y, softmax(x, std::vector<int>{-1})).item<bool>());
+      CHECK(array_equal(y, softmax(x, std::vector<int>{0})).item<bool>());
+
+      auto ones = array(1.0f, t);
+      CHECK(array_equal(ones, sum(softmax(x))).item<bool>());
+
+      // all ones
+      x = array({1., 1., 1., 1.}, t);
+      CHECK(array_equal(y, softmax(x)).item<bool>());
+      CHECK(array_equal(ones, sum(softmax(x))).item<bool>());
+
+      // negative values
+      x = array({-1., -2., -3., -4.}, t);
+      y = array({0.643914, 0.236883, 0.0871443, 0.0320586}, t);
+      CHECK(allclose(y, softmax(x), rtol).item<bool>());
+      CHECK(allclose(ones, sum(softmax(x)), rtol).item<bool>());
+
+      // positive and negative values
+      x = array({1., 0., -1., 0.}, t);
+      y = array({0.534447, 0.196612, 0.0723295, 0.196612}, t);
+      CHECK(allclose(y, softmax(x), rtol).item<bool>());
+      CHECK(allclose(ones, sum(softmax(x)), rtol).item<bool>());
+
+      // large positive values
+      x = array({1000., 1000., 1000.}, t);
+      y = array({0.333333, 0.333333, 0.333333}, t);
+      CHECK(allclose(y, softmax(x)).item<bool>());
+      CHECK(array_equal(ones, sum(softmax(x))).item<bool>());
+
+      // large negative values
+      x = negative(x);
+      CHECK(allclose(y, softmax(x)).item<bool>());
+      CHECK(array_equal(ones, sum(softmax(x))).item<bool>());
+    }
+  }
+}
+
+TEST_CASE("test irregular binary ops") {
+  // 1D strided
+  {
+    auto x = full({128}, 1.0f);
+    auto y = full({64}, 1.0f);
+    x = slice(x, {0}, {128}, {4});
+    y = slice(y, {0}, {64}, {2});
+    CHECK(array_equal(add(x, y), full({32}, 2.0f)).item<bool>());
+  }
+
+  // 2D broadcasts
+  {
+    auto x = full({32, 32}, 4.0f);
+    auto y = full({32}, 4.0f);
+    CHECK(array_equal(add(x, y), full({32, 32}, 8.0f)).item<bool>());
+    y = reshape(y, {32, 1});
+    CHECK(array_equal(add(x, y), full({32, 32}, 8.0f)).item<bool>());
+    CHECK(array_equal(subtract(y, x), zeros({32, 32})).item<bool>());
+  }
+}
+
+TEST_CASE("test arithmetic unary ops") {
+  // Test negative
+  {
+    array x(1.0f);
+    CHECK_EQ(negative(x).item<float>(), -1.0f);
+    CHECK_EQ((-x).item<float>(), -1.0f);
+
+    // works on empty array
+    CHECK(array_equal(-array({}), array({})).item<bool>());
+
+    // Throws on bool
+    CHECK_THROWS(negative(array(true)));
+  }
+
+  // Test logical not
+  {
+    array x(false);
+    CHECK_EQ(logical_not(x).item<bool>(), true);
+
+    x = array(1.0f);
+    auto y = logical_not(x);
+    CHECK_EQ(y.dtype(), bool_);
+    CHECK_EQ(y.item<bool>(), false);
+
+    x = array(0);
+    y = logical_not(x);
+    CHECK_EQ(y.dtype(), bool_);
+    CHECK_EQ(y.item<bool>(), true);
+  }
+
+  // Test logical and
+  {
+    array x(true);
+    array y(true);
+    CHECK_EQ(logical_and(x, y).item<bool>(), true);
+
+    x = array(1.0f);
+    y = array(1.0f);
+    auto z = logical_and(x, y);
+    CHECK_EQ(z.dtype(), bool_);
+    CHECK_EQ(z.item<bool>(), true);
+
+    x = array(0);
+    y = array(1.0f);
+    z = logical_and(x, y);
+    CHECK_EQ(z.dtype(), bool_);
+    CHECK_EQ(z.item<bool>(), false);
+  }
+
+  // Test logical or
+  {
+    array x(false);
+    array y(false);
+    CHECK_EQ(logical_or(x, y).item<bool>(), false);
+
+    x = array(1.0f);
+    y = array(1.0f);
+    auto z = logical_or(x, y);
+    CHECK_EQ(z.dtype(), bool_);
+    CHECK_EQ(z.item<bool>(), true);
+
+    x = array(0);
+    y = array(1.0f);
+    z = logical_or(x, y);
+    CHECK_EQ(z.dtype(), bool_);
+    CHECK_EQ(z.item<bool>(), true);
+  }
+
+  // Test abs
+  {
+    array x({-1.0f, 0.0f, 1.0f});
+    CHECK(array_equal(abs(x), array({1.0f, 0.0f, 1.0f})).item<bool>());
+
+    // works on empty array
+    CHECK(array_equal(abs(array({})), array({})).item<bool>());
+
+    // int32
+    x = array({-1, 0, 1});
+    CHECK(array_equal(abs(x), array({1, 0, 1})).item<bool>());
+
+    // uint32
+    x = array({1u, 0u, 1u});
+    CHECK(array_equal(abs(x), array({1u, 0u, 1u})).item<bool>());
+
+    // bool
+    x = array({false, true});
+    CHECK(array_equal(abs(x), array({false, true})).item<bool>());
+  }
+
+  // Test sign
+  {
+    array x({-1.0f, 0.0f, 1.0f});
+    CHECK(array_equal(sign(x), x).item<bool>());
+
+    // works on empty array
+    CHECK(array_equal(sign(array({})), array({})).item<bool>());
+
+    // int32
+    x = array({-1, 0, 1});
+    CHECK(array_equal(sign(x), x).item<bool>());
+
+    // uint32
+    x = array({1u, 0u, 1u});
+    CHECK(array_equal(sign(x), x).item<bool>());
+
+    // bool
+    x = array({false, true});
+    CHECK(array_equal(sign(x), x).item<bool>());
+
+    // uint64
+    array x_uint64(
+        {uint64_t(0xa11cc311cb6acd70),
+         uint64_t(0x7a375ac3ebb533f3),
+         uint64_t(0x734969adf9d7190c),
+         uint64_t(0xb400515a4f673424)});
+    array expected(
+        {uint64_t(0x0000000000000001),
+         uint64_t(0x0000000000000001),
+         uint64_t(0x0000000000000001),
+         uint64_t(0x0000000000000001)});
+    CHECK(array_equal(sign(x_uint64), expected).item<bool>());
+
+    x_uint64 = array(
+        {uint64_t(0xa11cc311cb6acd70),
+         uint64_t(0x7a375ac3ebb533f3),
+         uint64_t(0x734969adf9d7190c)});
+    expected = array(
+        {uint64_t(0x0000000000000001),
+         uint64_t(0x0000000000000001),
+         uint64_t(0x0000000000000001)});
+    CHECK(array_equal(sign(x_uint64), expected).item<bool>());
+
+    x_uint64 =
+        array({uint64_t(0xa11cc311cb6acd70), uint64_t(0x7a375ac3ebb533f3)});
+    expected =
+        array({uint64_t(0x0000000000000001), uint64_t(0x0000000000000001)});
+    CHECK(array_equal(sign(x_uint64), expected).item<bool>());
+
+    x_uint64 = array({uint64_t(0xa11cc311cb6acd70)});
+    expected = array({uint64_t(0x0000000000000001)});
+    CHECK(array_equal(sign(x_uint64), expected).item<bool>());
+
+    x_uint64 = array({uint64_t(0xffffffffffffffff)});
+    expected = array({uint64_t(0x0000000000000001)});
+    CHECK(array_equal(sign(x_uint64), expected).item<bool>());
+
+    x_uint64 = array({uint64_t(0x0000000000000001)});
+    expected = array({uint64_t(0x0000000000000001)});
+    CHECK(array_equal(sign(x_uint64), expected).item<bool>());
+  }
+
+  constexpr float neginf = -std::numeric_limits<float>::infinity();
+
+  // Test floor and ceil
+  {
+    array x(1.0f);
+    CHECK_EQ(floor(x).item<float>(), 1.0f);
+    CHECK_EQ(ceil(x).item<float>(), 1.0f);
+
+    x = array(1.5f);
+    CHECK_EQ(floor(x).item<float>(), 1.0f);
+    CHECK_EQ(ceil(x).item<float>(), 2.0f);
+
+    x = array(-1.5f);
+    CHECK_EQ(floor(x).item<float>(), -2.0f);
+    CHECK_EQ(ceil(x).item<float>(), -1.0f);
+
+    x = array(neginf);
+    CHECK_EQ(floor(x).item<float>(), neginf);
+    CHECK_EQ(ceil(x).item<float>(), neginf);
+
+    x = array(std::complex<float>(1.0f, 1.0f));
+    CHECK_THROWS_AS(floor(x), std::invalid_argument);
+    CHECK_THROWS_AS(ceil(x), std::invalid_argument);
+  }
+
+  // Test round
+  {
+    array x({0.5, -0.5, 1.5, -1.5, 2.3, 2.6});
+    CHECK(array_equal(round(x), array({0, -0, 2, -2, 2, 3})).item<bool>());
+
+    x = array({11, 222, 32});
+    CHECK(array_equal(round(x, -1), array({10, 220, 30})).item<bool>());
+  }
+
+  // Test exponential
+  {
+    array x(0.0);
+    CHECK_EQ(exp(x).item<float>(), 1.0);
+
+    x = array(2.0);
+    CHECK_EQ(exp(x).item<float>(), doctest::Approx(std::exp(2.0f)));
+
+    CHECK(array_equal(exp(array({})), array({})).item<bool>());
+
+    x = array(neginf);
+    CHECK_EQ(exp(x).item<float>(), doctest::Approx(0.0f));
+
+    // Integer input type
+    x = array(2);
+    CHECK_EQ(x.dtype(), int32);
+    CHECK_EQ(exp(x).item<float>(), doctest::Approx(std::exp(2.0f)));
+
+    // Input is irregularly strided
+    x = broadcast_to(array(1.0f), {2, 2, 2});
+    CHECK(allclose(exp(x), full({2, 2, 2}, std::exp(1.0f))).item<bool>());
+
+    x = split(array({0.0f, 1.0f, 2.0f, 3.0f}, {2, 2}), 2, 1)[0];
+    auto expected = array({std::exp(0.0f), std::exp(2.0f)}, {2, 1});
+    CHECK(allclose(exp(x), expected).item<bool>());
+
+    // Complex of -inf
+    constexpr float inf = std::numeric_limits<float>::infinity();
+    x = array(complex64_t{-inf, -inf});
+    CHECK_EQ(exp(x).item<complex64_t>(), complex64_t{0, 0});
+  }
+
+  // Test expm1
+  {
+    array x(-1.0f);
+    CHECK_EQ(expm1(x).item<float>(), doctest::Approx(std::expm1(-1.0f)));
+
+    x = array(1.0f);
+    CHECK_EQ(expm1(x).item<float>(), doctest::Approx(std::expm1(1.0f)));
+
+    // Integer input type
+    x = array(1);
+    CHECK_EQ(expm1(x).dtype(), float32);
+    CHECK_EQ(expm1(x).item<float>(), doctest::Approx(std::expm1(1.0f)));
+  }
+
+  // Test sine
+  {
+    array x(0.0);
+    CHECK_EQ(sin(x).item<float>(), 0.0);
+
+    x = array(M_PI_2);
+    CHECK(sin(x).item<float>() == doctest::Approx(std::sin(M_PI_2)));
+
+    CHECK(array_equal(sin(array({})), array({})).item<bool>());
+
+    // Integer input type
+    x = array(0);
+    CHECK_EQ(x.dtype(), int32);
+    CHECK_EQ(sin(x).item<float>(), std::sin(0.0f));
+
+    // Input is irregularly strided
+    x = broadcast_to(array(1.0f), {2, 2, 2});
+    CHECK(allclose(sin(x), full({2, 2, 2}, std::sin(1.0f))).item<bool>());
+
+    x = split(array({0.0f, 1.0f, 2.0f, 3.0f}, {2, 2}), 2, 1)[0];
+    auto expected = array({std::sin(0.0f), std::sin(2.0f)}, {2, 1});
+    CHECK(allclose(sin(x), expected).item<bool>());
+  }
+
+  // Test cos
+  {
+    array x(0.0);
+    CHECK_EQ(cos(x).item<float>(), doctest::Approx(1.0));
+
+    x = array(M_PI_2);
+    CHECK(cos(x).item<float>() == doctest::Approx(std::cos(M_PI_2)));
+
+    CHECK(array_equal(cos(array({})), array({})).item<bool>());
+
+    // Integer input type
+    x = array(0);
+    CHECK_EQ(x.dtype(), int32);
+    CHECK(cos(x).item<float>() == doctest::Approx(std::cos(0.0f)));
+
+    // Input is irregularly strided
+    x = broadcast_to(array(1.0f), {2, 2, 2});
+    CHECK(allclose(cos(x), full({2, 2, 2}, std::cos(1.0f))).item<bool>());
+
+    x = split(array({0.0f, 1.0f, 2.0f, 3.0f}, {2, 2}), 2, 1)[0];
+    auto expected = array({std::cos(0.0f), std::cos(2.0f)}, {2, 1});
+    CHECK(allclose(cos(x), expected).item<bool>());
+  }
+
+  // Test degrees
+  {
+    array x(0.0);
+    CHECK_EQ(degrees(x).item<float>(), 0.0);
+
+    x = array(M_PI_2);
+    CHECK(degrees(x).item<float>() == doctest::Approx(90.0));
+
+    CHECK(array_equal(degrees(array({})), array({})).item<bool>());
+
+    // Integer input type
+    x = array(0);
+    CHECK_EQ(x.dtype(), int32);
+    CHECK_EQ(degrees(x).item<float>(), 0.0);
+
+    // Input is irregularly strided
+    x = broadcast_to(array(M_PI_2), {2, 2, 2});
+    CHECK(allclose(degrees(x), full({2, 2, 2}, 90.0)).item<bool>());
+
+    float angles[] = {0.0f, M_PI_2, M_PI, 3.0f * M_PI_2};
+    x = split(array(angles, {2, 2}), 2, 1)[0];
+    auto expected = array({0.0f, 180.0f}, {2, 1});
+    CHECK(allclose(degrees(x), expected).item<bool>());
+  }
+
+  // Test radians
+  {
+    array x(0.0);
+    CHECK_EQ(radians(x).item<float>(), 0.0);
+
+    x = array(90.0);
+    CHECK(radians(x).item<float>() == doctest::Approx(M_PI_2));
+
+    CHECK(array_equal(radians(array({})), array({})).item<bool>());
+
+    // Integer input type
+    x = array(90);
+    CHECK_EQ(x.dtype(), int32);
+    CHECK(radians(x).item<float>() == doctest::Approx(M_PI_2));
+
+    // Input is irregularly strided
+    x = broadcast_to(array(90.0f), {2, 2, 2});
+    CHECK(allclose(radians(x), full({2, 2, 2}, M_PI_2)).item<bool>());
+
+    x = split(array({0.0f, 90.0f, 180.0f, 270.0f}, {2, 2}), 2, 1)[0];
+    float angles[] = {0.0f, M_PI};
+    auto expected = array(angles, {2, 1});
+    CHECK(allclose(radians(x), expected).item<bool>());
+  }
+
+  // Test log
+  {
+    array x(0.0);
+    CHECK_EQ(log(x).item<float>(), neginf);
+
+    x = array(1.0);
+    CHECK_EQ(log(x).item<float>(), log(1.0f));
+
+    // Integer input type
+    x = array(1);
+    CHECK_EQ(log(x).dtype(), float32);
+    CHECK_EQ(log(x).item<float>(), log(1.0f));
+
+    // Input is irregularly strided
+    x = broadcast_to(array(1.0f), {2, 2, 2});
+    CHECK(array_equal(log(x), full({2, 2, 2}, std::log(1.0f))).item<bool>());
+
+    x = split(array({1.0f, 2.0f, 3.0f, 4.0f}, {2, 2}), 2, 1)[0];
+    auto expected = array({std::log(1.0f), std::log(3.0f)}, {2, 1});
+    CHECK(array_equal(log(x), expected).item<bool>());
+  }
+
+  // Test log2
+  {
+    array x(0.0);
+    CHECK_EQ(log2(x).item<float>(), neginf);
+
+    x = array(1.0);
+    CHECK_EQ(log2(x).item<float>(), 0.0f);
+
+    x = array(1024.0f);
+    CHECK_EQ(log2(x).item<float>(), 10.0f);
+  }
+
+  // Test log10
+  {
+    array x(0.0);
+    CHECK_EQ(log10(x).item<float>(), neginf);
+
+    x = array(1.0);
+    CHECK_EQ(log10(x).item<float>(), 0.0f);
+
+    x = array(1000.0f);
+    CHECK_EQ(log10(x).item<float>(), 3.0f);
+  }
+
+  // Test log1p
+  {
+    array x(-1.0f);
+    CHECK_EQ(log1p(x).item<float>(), neginf);
+
+    x = array(1.0f);
+    CHECK_EQ(log1p(x).item<float>(), std::log1pf(1.0f));
+
+    // Integer input type
+    x = array(1);
+    CHECK_EQ(log1p(x).dtype(), float32);
+    CHECK_EQ(log1p(x).item<float>(), std::log1pf(1.0f));
+
+    // Input is irregularly strided
+    x = broadcast_to(array(1.0f), {2, 2, 2});
+    CHECK(
+        array_equal(log1p(x), full({2, 2, 2}, std::log1pf(1.0f))).item<bool>());
+
+    x = split(array({1.0f, 2.0f, 3.0f, 4.0f}, {2, 2}), 2, 1)[0];
+    auto expected = array({std::log1pf(1.0f), std::log1pf(3.0f)}, {2, 1});
+    CHECK(array_equal(log1p(x), expected).item<bool>());
+  }
+
+  // Test sigmoid
+  {
+    array x(0.0);
+    CHECK_EQ(sigmoid(x).item<float>(), 0.5f);
+
+    // Integer input type
+    x = array(0);
+    CHECK_EQ(sigmoid(x).dtype(), float32);
+    CHECK_EQ(sigmoid(x).item<float>(), 0.5f);
+
+    constexpr auto inf = std::numeric_limits<float>::infinity();
+    x = array(inf);
+    CHECK_EQ(sigmoid(x).item<float>(), 1.0f);
+    x = array(-inf);
+    CHECK_EQ(sigmoid(x).item<float>(), 0.0f);
+  }
+
+  // Test square
+  {
+    array x(3.0);
+    CHECK_EQ(square(x).item<float>(), 9.0);
+
+    x = array(2);
+    CHECK_EQ(square(x).item<int>(), 4);
+
+    x = full({3, 3}, 2.0f);
+    CHECK(array_equal(square(x), full({3, 3}, 4.0f)).item<bool>());
+  }
+
+  // Test sqrt and rsqrt
+  {
+    array x(4.0);
+    CHECK_EQ(sqrt(x).item<float>(), 2.0);
+    CHECK_EQ(rsqrt(x).item<float>(), 0.5);
+
+    x = full({3, 3}, 9.0f);
+    CHECK(array_equal(sqrt(x), full({3, 3}, 3.0f)).item<bool>());
+
+    x = array(4, int32);
+    CHECK_EQ(sqrt(x).item<float>(), 2.0f);
+    CHECK_EQ(rsqrt(x).item<float>(), 0.5f);
+  }
+
+  // Test reciprocal
+  {
+    array x(8.0);
+    CHECK_EQ(reciprocal(x).item<float>(), 0.125f);
+
+    x = array(2);
+    auto out = reciprocal(x);
+    CHECK_EQ(out.dtype(), float32);
+    CHECK_EQ(out.item<float>(), 0.5f);
+
+    x = full({3, 3}, 2.0f);
+    CHECK(array_equal(reciprocal(x), full({3, 3}, 0.5f)).item<bool>());
+  }
+}
+
+TEST_CASE("test error functions") {
+  constexpr float inf = std::numeric_limits<float>::infinity();
+  array x(0.0f);
+  CHECK_EQ(erf(x).item<float>(), 0.0f);
+  x = array(inf);
+  CHECK_EQ(erf(x).item<float>(), 1.0f);
+  x = array(-inf);
+  CHECK_EQ(erf(x).item<float>(), -1.0f);
+
+  x = array(1, int32);
+  CHECK_EQ(erf(x).dtype(), float32);
+
+  x = array(0.0f);
+  CHECK_EQ(erfinv(x).item<float>(), 0.0f);
+  x = array(1.0f);
+  CHECK_EQ(erfinv(x).item<float>(), inf);
+  x = array(-1.0f);
+  CHECK_EQ(erfinv(x).item<float>(), -inf);
+
+  x = array(1, int32);
+  CHECK_EQ(erfinv(x).dtype(), float32);
+
+  x = array(2.0f);
+  CHECK(std::isnan(erfinv(x).item<float>()));
+  x = array(-2.0f);
+  CHECK(std::isnan(erfinv(x).item<float>()));
+
+  auto vals = {0.9f, 0.5f, 0.1f, -0.1f, -0.5f, -0.9f};
+  // Expected values are generated from scipy's error function:
+  //   python -c "import scipy.special as ss;
+  //   vals = [0.9, 0.5, 0.1, -0.1, -0.5, -0.9];
+  //   print([ss.erf(x) for x in vals])"
+  {
+    auto expected = {
+        0.7969082124228322,
+        0.5204998778130465,
+        0.1124629160182849,
+        -0.1124629160182849,
+        -0.5204998778130465,
+        -0.7969082124228322};
+    for (int i = 0; i < vals.size(); ++i) {
+      x = array(vals.begin()[i]);
+      CHECK_EQ(erf(x).item<float>(), doctest::Approx(expected.begin()[i]));
+    }
+  }
+
+  // Expected values are generated from scipy's inverse error function:
+  //   python -c "import scipy.special as ss;
+  //   vals = [0.9, 0.5, 0.1, -0.1, -0.5, -0.9];
+  //   print([ss.erfinv(x) for x in vals])"
+  {
+    auto expected = {
+        1.1630871536766738,
+        0.4769362762044699,
+        0.08885599049425778,
+        -0.08885599049425769,
+        -0.4769362762044699,
+        -1.1630871536766743};
+    for (int i = 0; i < vals.size(); ++i) {
+      x = array(vals.begin()[i]);
+      CHECK_EQ(erfinv(x).item<float>(), doctest::Approx(expected.begin()[i]));
+    }
+  }
+
+  // float16_t
+  {
+    array x(0.0f, float16);
+    auto out = erf(x);
+    CHECK_EQ(out.dtype(), float16);
+    CHECK_EQ(out.item<float16_t>(), 0.0f);
+
+    out = erfinv(x);
+    CHECK_EQ(out.dtype(), float16);
+    CHECK_EQ(out.item<float16_t>(), 0.0f);
+  }
+
+  // bfloat
+  {
+    array x(0.0f, bfloat16);
+    auto out = erf(x);
+    CHECK_EQ(out.dtype(), bfloat16);
+    CHECK_EQ(out.item<bfloat16_t>(), 0.0f);
+
+    out = erfinv(x);
+    CHECK_EQ(out.dtype(), bfloat16);
+    CHECK_EQ(out.item<float16_t>(), 0.0f);
+  }
+}
+
+TEST_CASE("test arithmetic binary ops") {
+  array x(1.0);
+  array y(1.0);
+  auto z = add(x, y);
+  CHECK_EQ(z.item<float>(), 2.0);
+  z = x + y;
+  CHECK_EQ(z.item<float>(), 2.0);
+  z = add(z, x);
+  CHECK_EQ(z.item<float>(), 3.0);
+  z.eval(); // No-op
+  CHECK_EQ(z.item<float>(), 3.0);
+
+  // Chain a few adds:
+  auto out = x;
+  for (int i = 0; i < 10; ++i) {
+    out = add(out, x);
+  }
+  CHECK_EQ(out.item<float>(), 11.0);
+
+  // Works for different shapes
+  x = array({1.0, 2.0, 3.0}, {1, 3});
+  y = array({1.0, 2.0, 3.0}, {1, 3});
+  z = add(x, y);
+  CHECK_EQ(z.shape(), Shape{1, 3});
+  auto eq = array_equal(z, array({2.0, 4.0, 6.0}, {1, 3}));
+  CHECK(eq.item<bool>());
+
+  // Works with scalars
+  x = array({1.0, 2.0, 3.0}, {1, 3});
+  y = x + 2.0;
+  CHECK_EQ(y.dtype(), float32);
+  eq = array_equal(y, array({3.0, 4.0, 5.0}, {1, 3}));
+  CHECK(eq.item<bool>());
+  y = 2.0 + x;
+  CHECK_EQ(y.dtype(), float32);
+  eq = array_equal(y, array({3.0, 4.0, 5.0}, {1, 3}));
+  CHECK(eq.item<bool>());
+
+  // Check type promotion
+  y = 2 + x;
+  CHECK_EQ(y.dtype(), float32);
+
+  y = 2.0 + array({1, 2, 3});
+  CHECK_EQ(y.dtype(), float32);
+  CHECK(array_equal(y, array({3.0, 4.0, 5.0})).item<bool>());
+
+  // Broadcasting works
+  x = broadcast_to(array({1.0}), {10});
+  y = broadcast_to(array({2.0}), {10});
+  z = add(x, y);
+  CHECK(array_equal(z, full({10}, 3.0)).item<bool>());
+
+  x = array({1.0, 2.0}, {1, 2});
+  y = array({1.0, 2.0}, {2, 1});
+  z = add(x, y);
+  CHECK_EQ(z.shape(), Shape{2, 2});
+  eq = array_equal(z, array({2.0, 3.0, 3.0, 4.0}, {2, 2}));
+  CHECK(eq.item<bool>());
+
+  x = ones({3, 2, 1});
+  z = x + 2.0;
+  CHECK_EQ(z.shape(), Shape{3, 2, 1});
+  eq = array_equal(z, array({3.0, 3.0, 3.0, 3.0, 3.0, 3.0}, {3, 2, 1}));
+  CHECK(eq.item<bool>());
+
+  // Works for empty arrays
+  x = array({});
+  y = array({});
+  z = x + y;
+  z.eval();
+  CHECK_EQ(z.size(), 0);
+  CHECK_EQ(z.shape(), Shape{0});
+
+  // Check subtraction
+  x = array({3, 2, 1});
+  y = array({1, 1, 1});
+  CHECK(array_equal(x - y, array({2, 1, 0})).item<bool>());
+
+  // Check multiplication
+  x = array({1, 2, 3});
+  y = array({2, 2, 2});
+  CHECK(array_equal(x * y, array({2, 4, 6})).item<bool>());
+
+  // Check division
+  x = array(1);
+  y = array(1);
+  CHECK_EQ(divide(x, y).item<float>(), 1.0f);
+
+  x = array(1);
+  y = array(0.5);
+  CHECK_EQ(divide(x, y).item<float>(), 2.0f);
+
+  x = array(1);
+  y = array(4);
+  CHECK_EQ(divide(x, y).item<float>(), 0.25f);
+
+  x = array(true);
+  y = array(true);
+  CHECK_EQ(divide(x, y).item<float>(), 1.0f);
+
+  x = array(false);
+  y = array(true);
+  CHECK_EQ(divide(x, y).item<float>(), 0.0f);
+
+  x = array(true);
+  y = array(false);
+  CHECK(std::isinf(divide(x, y).item<float>()));
+
+  x = array(false);
+  y = array(false);
+  CHECK(std::isnan(divide(x, y).item<float>()));
+
+  // Check maximum and minimum
+  x = array(1.0f);
+  y = array(0.0f);
+  CHECK_EQ(maximum(x, y).item<float>(), 1.0f);
+  CHECK_EQ(minimum(x, y).item<float>(), 0.0f);
+  y = array(2.0f);
+  CHECK_EQ(maximum(x, y).item<float>(), 2.0f);
+  CHECK_EQ(minimum(x, y).item<float>(), 1.0f);
+
+  // Check logaddexp
+  x = array(0.0f);
+  y = array(0.0f);
+  CHECK_EQ(logaddexp(x, y).item<float>(), std::log(2.0f));
+
+  x = array(0u);
+  y = array(10000u);
+  CHECK_EQ(logaddexp(x, y).item<float>(), 10000.0f);
+
+  constexpr float inf = std::numeric_limits<float>::infinity();
+  x = array(inf);
+  y = array(3.0f);
+  CHECK_EQ(logaddexp(x, y).item<float>(), inf);
+
+  x = array(-inf);
+  y = array(3.0f);
+  CHECK_EQ(logaddexp(x, y).item<float>(), 3.0f);
+
+  x = array(-inf);
+  y = array(-inf);
+  CHECK_EQ(logaddexp(x, y).item<float>(), -inf);
+
+  x = array(inf);
+  y = array(inf);
+  CHECK_EQ(logaddexp(x, y).item<float>(), inf);
+
+  x = array(-inf);
+  y = array(inf);
+  CHECK_EQ(logaddexp(x, y).item<float>(), inf);
+
+  x = array(complex64_t{1, 1});
+  y = array(complex64_t{-inf, -inf});
+  CHECK_EQ(logaddexp(x, y).item<complex64_t>(), complex64_t{1, 1});
+}
+
+TEST_CASE("test broadcast") {
+  auto s = broadcast_shapes({1}, {1, 2});
+  CHECK_EQ(s, Shape{1, 2});
+
+  s = broadcast_shapes({1, 2}, {1});
+  CHECK_EQ(s, Shape{1, 2});
+
+  s = broadcast_shapes({2, 2}, {});
+  CHECK_EQ(s, Shape{2, 2});
+
+  s = broadcast_shapes({}, {1, 1});
+  CHECK_EQ(s, Shape{1, 1});
+
+  s = broadcast_shapes({1, 2, 1}, {2});
+  CHECK_EQ(s, Shape{1, 2, 2});
+
+  s = broadcast_shapes({2}, {1, 2, 1});
+  CHECK_EQ(s, Shape{1, 2, 2});
+
+  s = broadcast_shapes({2, 2, 2}, {1, 2, 1});
+  CHECK_EQ(s, Shape{2, 2, 2});
+
+  s = broadcast_shapes({2, 2, 2, 1}, {1, 2, 1});
+  CHECK_EQ(s, Shape{2, 2, 2, 1});
+
+  s = broadcast_shapes({0}, {0, 0});
+  CHECK_EQ(s, Shape{0, 0});
+
+  CHECK_EQ(broadcast_shapes({}, {0}), Shape{0});
+
+  s = broadcast_shapes({5, 0}, {0, 5, 0});
+  CHECK_EQ(s, Shape{0, 5, 0});
+
+  CHECK_EQ(broadcast_shapes({}, {0}), Shape{0});
+  CHECK_EQ(broadcast_shapes({1}, {0}), Shape{0});
+  CHECK_EQ(broadcast_shapes({1}, {0}), Shape{0});
+  CHECK_EQ(broadcast_shapes({1}, {0, 0}), Shape{0, 0});
+  CHECK_EQ(broadcast_shapes({1, 1}, {0}), Shape{1, 0});
+  CHECK_EQ(broadcast_shapes({1, 1}, {0, 0}), Shape{0, 0});
+  CHECK_EQ(broadcast_shapes({2, 1}, {1, 0}), Shape{2, 0});
+  CHECK_EQ(broadcast_shapes({2, 1}, {2, 0}), Shape{2, 0});
+  CHECK_EQ(broadcast_shapes({2, 1}, {1, 2, 0}), Shape{1, 2, 0});
+  CHECK_THROWS_AS(broadcast_shapes({2}, {0}), std::invalid_argument);
+  CHECK_THROWS_AS(broadcast_shapes({2, 1}, {0, 0}), std::invalid_argument);
+
+  CHECK_THROWS_AS(broadcast_shapes({3}, {2}), std::invalid_argument);
+  CHECK_THROWS_AS(broadcast_shapes({1, 3}, {2}), std::invalid_argument);
+  CHECK_THROWS_AS(broadcast_shapes({3}, {1, 2}), std::invalid_argument);
+  CHECK_THROWS_AS(
+      broadcast_shapes({1, 3, 2}, {1, 2, 2}), std::invalid_argument);
+
+  auto x = full({1, 1}, 2.3f);
+  CHECK_EQ(broadcast_to(x, {1, 1}).item<float>(), 2.3f);
+
+  x = broadcast_to(x, {5, 1});
+  CHECK_EQ(x.shape(), Shape{5, 1});
+  x.eval();
+  CHECK_EQ(x.strides(), Strides{0, 0});
+
+  CHECK_THROWS_AS(broadcast_to(x, {1, 5}), std::invalid_argument);
+  x = broadcast_to(x, {5, 5});
+  CHECK_EQ(x.shape(), Shape{5, 5});
+
+  x = zeros({2, 1, 2});
+  x = broadcast_to(x, {4, 2, 1, 2});
+  CHECK_EQ(x.shape(), Shape{4, 2, 1, 2});
+  x.eval();
+  CHECK_EQ(x.strides(), Strides{0, 2, 0, 1});
+
+  // Broadcast on empty arrays works as expected
+  x = array({});
+  CHECK_THROWS_AS(broadcast_to(x, {1}), std::invalid_argument);
+
+  // Broadcast to empty array works as expected
+  x = array({1});
+  auto y = broadcast_to(x, {0});
+  eval(y);
+  CHECK_EQ(y.size(), 0);
+  CHECK_EQ(y.shape(), Shape{0});
+
+  x = array({1, 2}, {2, 1});
+  y = broadcast_to(x, {2, 0});
+  eval(y);
+  CHECK_EQ(y.size(), 0);
+  CHECK_EQ(y.shape(), Shape{2, 0});
+
+  // Check repeat application works
+  x = zeros({2});
+  x = broadcast_to(broadcast_to(x, {2, 2}), {2, 2});
+  CHECK_EQ(x.shape(), Shape{2, 2});
+  x.eval();
+  CHECK_EQ(x.strides(), Strides{0, 1});
+  x = broadcast_to(broadcast_to(x, {2, 2}), {2, 2, 2});
+  CHECK_EQ(x.shape(), Shape{2, 2, 2});
+  x.eval();
+  CHECK_EQ(x.strides(), Strides{0, 0, 1});
+
+  // Broadcast on transposed array works
+  x = array({0, 1, 2, 3, 4, 5}, {2, 3});
+  x = broadcast_to(transpose(x), {2, 3, 2});
+  CHECK_EQ(x.shape(), Shape{2, 3, 2});
+  y = broadcast_to(array({0, 3, 1, 4, 2, 5}, {3, 2}), {2, 3, 2});
+  CHECK(array_equal(x, y).item<bool>());
+
+  // Reshape on broadcasted array works
+  x = array(1.0);
+  x = broadcast_to(x, {2});
+  x = reshape(x, {1, 2});
+  CHECK(array_equal(x, ones({1, 2})).item<bool>());
+}
+
+TEST_CASE("test gather") {
+  // Empty input, non-empty indices/slice
+  CHECK_THROWS(gather(array({}), array({1}), 0, {1}));
+
+  // More indices than dimensions
+  CHECK_THROWS(gather(array(0), array({1}), 0, {1}));
+
+  // Mismatch dimensions and indices
+  CHECK_THROWS(gather(array({0}), {array({0})}, {0, 1}, {1}));
+  CHECK_THROWS(gather(array({0}), array({0}), -1, {1}));
+
+  // Repeat dimensions
+  CHECK_THROWS(
+      gather(array({0}, {1, 1}), {array({0}), array({0})}, {0, 0}, {1, 1}));
+
+  // Slice sizes incorrect
+  CHECK_THROWS(gather(array({0}), array({0}), 0, {2}));
+  CHECK_THROWS(gather(array({0}), array({0}), 0, {0, 0}));
+  CHECK_THROWS(gather(array({0}), array({0}), 0, {-1}));
+
+  // Wrong index type
+  CHECK_THROWS(gather(array({0}), array({0.0f}), 0, {0}));
+  CHECK_THROWS(
+      gather(array({0}, {1, 1}), {array({0}), array({0.0f})}, {0, 1}, {1, 1}));
+
+  // Index arrays must be broadcastable
+  CHECK_THROWS(gather(
+      array({0}, {1, 1}),
+      {array({0, 0, 0}, {3}), array({0, 0}, {2})},
+      {0, 1},
+      {1, 1}));
+
+  // Basic test of correctness with 1D input
+  auto x = arange(20);
+  auto y = arange(10);
+  auto out = gather(x, y, 0, {1});
+  CHECK_EQ(out.shape(), Shape{10, 1});
+  CHECK(array_equal(reshape(out, {-1}), y).item<bool>());
+
+  out = gather(x, array({15}, uint32), 0, {1});
+  CHECK_EQ(out.shape(), Shape{1, 1});
+  CHECK_EQ(out.item<int32_t>(), 15);
+
+  // No index gather works
+  out = gather(x, {}, std::vector<int>{}, {10});
+  CHECK_EQ(out.shape(), Shape{10});
+  CHECK(array_equal(out, arange(10)).item<bool>());
+
+  // Basic test of correctness with 2D input
+  x = arange(128);
+  x = reshape(x, {4, 32});
+  y = array({0, 1}, uint32);
+  out = gather(x, y, 0, {1, 32});
+  CHECK_EQ(out.shape(), Shape{2, 1, 32});
+  CHECK(array_equal(reshape(out, {64}), arange(64)).item<bool>());
+
+  x = reshape(x, {64, 2});
+  y = array({0}, uint32);
+  out = gather(x, y, 0, {64, 1});
+  CHECK_EQ(out.shape(), Shape{1, 64, 1});
+  CHECK(array_equal(out, reshape(arange(0, 128, 2), {1, 64, 1})).item<bool>());
+
+  // Basic test of correctness with 3D input
+  x = arange(256);
+  x = reshape(x, {8, 4, 8});
+  y = array({0}, uint32);
+  out = gather(x, y, 0, {8, 1, 1});
+  CHECK_EQ(out.shape(), Shape{1, 8, 1, 1});
+  CHECK(
+      array_equal(out, reshape(arange(0, 256, 32), {1, 8, 1, 1})).item<bool>());
+
+  x = broadcast_to(array({1, 2}), {20, 2});
+  out = gather(x, array({5}), 0, {1, 1});
+  CHECK_EQ(out.item<int>(), 1);
+  out = gather(x, {array({5}), array({1})}, {0, 1}, {1, 1});
+  CHECK_EQ(out.item<int>(), 2);
+}
+
+TEST_CASE("test take") {
+  // Empty takes
+  auto empty = astype(array({}), int32);
+  auto z = take(array({1}), empty);
+  CHECK_EQ(z.shape(), Shape{0});
+  empty = reshape(empty, {1, 0, 1});
+  z = take(array({1}), empty);
+  CHECK_EQ(z.shape(), Shape{1, 0, 1});
+
+  CHECK_THROWS(take(array({}), array(1)));
+
+  z = take(array({}), empty);
+  CHECK_EQ(z.size(), 0);
+
+  // Take a single row
+  auto x = reshape(arange(256), {8, 4, 8});
+  z = take(x, array({0}, uint32), 0);
+  CHECK_EQ(z.shape(), Shape{1, 4, 8});
+  z = reshape(z, {32});
+  CHECK(array_equal(z, arange(32)).item<bool>());
+
+  z = take(x, array({1}, uint32), 0);
+  z = reshape(z, {32});
+  CHECK(array_equal(z, arange(32, 64)).item<bool>());
+
+  // Take multiple rows
+  x = arange(256);
+  x = reshape(x, {8, 4, 8});
+  z = take(x, array({0, 1}, uint32), 0);
+  z = reshape(z, {64});
+  CHECK(array_equal(z, arange(64)).item<bool>());
+
+  // Take along middle axis
+  x = reshape(arange(8), {2, 2, 2});
+  z = take(x, array({0}), 1);
+  CHECK(array_equal(z, array({0, 1, 4, 5}, {2, 1, 2})).item<bool>());
+
+  // Irregular strides test
+  auto a = array({1, 2, 3}, float32);
+  auto indices = broadcast_to(array(0), {10});
+  auto b = take(a, indices);
+  CHECK(array_equal(b, ones({10})).item<bool>());
+
+  // Take with 0 dim index
+  z = take(array({0, 1, 2}), array(0));
+  CHECK_EQ(z.item<int>(), 0);
+  CHECK_EQ(z.ndim(), 0);
+
+  // Check take with float indices crashes
+  CHECK_THROWS(take(array({}), array({})));
+  CHECK_THROWS(take(a, array({1.0, 2.0, 3.0})));
+
+  // Check axis
+  a = array({1, 2, 3, 4}, {2, 2});
+  CHECK_THROWS(take(a, array({1}), -3));
+  CHECK_THROWS(take(a, array({1}), 2));
+
+  // Check negative indices
+  a = array({1, 2, 3, 4}, {2, 2});
+  CHECK_EQ(take(a, array({-1})).item<int>(), 4);
+  CHECK(array_equal(take(a, array({1, -1})), array({2, 4})).item<bool>());
+  CHECK(array_equal(take(a, array(-1), 0), array({3, 4})).item<bool>());
+
+  // Check shapes
+  a = zeros({2, 1, 1});
+  auto out = take(a, array({1}), 0);
+  CHECK(array_equal(out, zeros({1, 1, 1})).item<bool>());
+  out = take(a, array({0}), 1);
+  CHECK(array_equal(out, zeros({2, 1, 1})).item<bool>());
+  out = take(a, array({0}), 1);
+  CHECK(array_equal(out, zeros({2, 1, 1})).item<bool>());
+  a = zeros({1, 2, 1});
+  out = take(a, array({0}), 0);
+  CHECK(array_equal(out, zeros({1, 2, 1})).item<bool>());
+  out = take(a, array({0}), 1);
+  CHECK(array_equal(out, zeros({1, 1, 1})).item<bool>());
+  out = take(a, array({0, 1}), 1);
+  CHECK(array_equal(out, zeros({1, 2, 1})).item<bool>());
+
+  // Indices have wrong shape
+  a = zeros({2, 3, 4});
+  CHECK_THROWS(take(a, zeros({1, 3, 4}), 1));
+  CHECK_THROWS(take(a, zeros({2, 3, 7}), 1));
+  CHECK_THROWS(take(a, zeros({2, 3, 2}), 0));
+}
+
+TEST_CASE("test take along axis") {
+  // No zero dim arrays
+  auto a = array(1);
+  CHECK_THROWS(take_along_axis(a, array(0), 0));
+
+  // Index and array size mismatches
+  a = arange(5);
+  CHECK_THROWS(take_along_axis(a, array({1}), 1));
+  CHECK_THROWS(take_along_axis(a, array({1}, {1, 1}), 0));
+  CHECK_THROWS(take_along_axis(a, array(1), -1));
+
+  auto out = take_along_axis(a, array({1}), 0);
+  CHECK_EQ(out.item<int>(), 1);
+  out = take_along_axis(a, array({1}), -1);
+  CHECK_EQ(out.item<int>(), 1);
+
+  // Empty arrays
+  a = reshape(array({}), {1, 0});
+  CHECK_THROWS(take_along_axis(a, array({1}), 0));
+
+  out = take_along_axis(a, reshape(array({1}), {1, 1}), 0);
+  eval(out); // Make sure it runs
+  CHECK_EQ(out.shape(), Shape{1, 0});
+
+  auto inds = reshape(astype(array({}), int32), {1, 0});
+  out = take_along_axis(a, inds, 0);
+  eval(out); // Make sure it runs
+  CHECK_EQ(out.shape(), Shape{1, 0});
+
+  a = array({1, 2, 3, 4}, {2, 2});
+  inds = array({0, 1}, {1, 2});
+  out = take_along_axis(a, inds, 0);
+  CHECK(array_equal(out, array({1, 4}, {1, 2})).item<bool>());
+
+  inds = array({0, 1, 0, 1, 0, 0, 1, 0}, {4, 2}, int32);
+  out = take_along_axis(a, inds, 0);
+  CHECK(array_equal(out, array({1, 4, 1, 4, 1, 2, 3, 2}, {4, 2})).item<bool>());
+
+  inds = array({0, 1}, {2, 1});
+  out = take_along_axis(a, inds, 1);
+  CHECK(array_equal(out, array({1, 4}, {2, 1})).item<bool>());
+
+  // Broadcasting works
+  inds = array({0}, {1, 1});
+  out = take_along_axis(a, inds, 0);
+  CHECK(array_equal(out, array({1, 2}, {1, 2})).item<bool>());
+  out = take_along_axis(a, inds, 1);
+  CHECK(array_equal(out, array({1, 3}, {2, 1})).item<bool>());
+
+  inds = array({0, 1, 1, 0, 0, 1}, {2, 3}, int32);
+  out = take_along_axis(a, inds, 1);
+  CHECK(array_equal(out, array({1, 2, 2, 3, 3, 4}, {2, 3})).item<bool>());
+
+  a = reshape(arange(8), {2, 2, 2});
+  inds = array({0, 1, 0, 0, 1, 0, 0, 1}, {2, 2, 2});
+  out = take_along_axis(a, inds, 0);
+  CHECK(array_equal(out, array({0, 5, 2, 3, 4, 1, 2, 7}, {2, 2, 2}))
+            .item<bool>());
+  out = take_along_axis(a, inds, 1);
+  CHECK(array_equal(out, array({0, 3, 0, 1, 6, 5, 4, 7}, {2, 2, 2}))
+            .item<bool>());
+  out = take_along_axis(a, inds, 2);
+  CHECK(array_equal(out, array({0, 1, 2, 2, 5, 4, 6, 7}, {2, 2, 2}))
+            .item<bool>());
+}
+
+TEST_CASE("test put along axis") {
+  // No zero dim arrays
+  auto a = array(1);
+  auto v = array(1);
+  CHECK_THROWS(put_along_axis(a, array(0), v, 0));
+
+  // Index and array size mismatches
+  a = arange(5);
+  CHECK_THROWS(put_along_axis(a, array({1}), array({0}), 1));
+  CHECK_THROWS(put_along_axis(a, array({1}, {1, 1}), array({0}), 0));
+  CHECK_THROWS(put_along_axis(a, array(1), array(0), -1));
+
+  auto expected = array({0, 0, 2, 3, 4});
+  auto out = put_along_axis(a, array({1}), array({0}), 0);
+  CHECK(array_equal(out, expected).item<bool>());
+
+  // Empty arrays
+  a = reshape(array({}), {1, 0});
+  CHECK_THROWS(put_along_axis(a, array({1}), array({0}), 0));
+
+  auto inds = reshape(astype(array({}), int32), {1, 0});
+  out = take_along_axis(a, inds, 0);
+  eval(out); // Make sure it runs
+  CHECK_EQ(out.shape(), Shape{1, 0});
+
+  a = array({1, 2, 3, 4}, {2, 2});
+  inds = array({0, 1}, {1, 2});
+  out = put_along_axis(a, inds, array({0}), 0);
+  expected = array({0, 2, 3, 0}, {2, 2});
+  CHECK(array_equal(out, expected).item<bool>());
+
+  inds = array({0, 0, 1, 1}, {2, 2}, int32);
+  auto values = array({2, 3, 4, 5}, {2, 2}, int32);
+  out = put_along_axis(a, inds, values, 0);
+  CHECK(array_equal(out, array({2, 3, 4, 5}, {2, 2})).item<bool>());
+
+  inds = array({0, 1}, {2, 1});
+  out = put_along_axis(a, inds, array({0}), 1);
+  expected = array({0, 2, 3, 0}, {2, 2});
+  CHECK(array_equal(out, expected).item<bool>());
+}
+
+TEST_CASE("test scatter") {
+  // More indices than dimensions
+  CHECK_THROWS(scatter(array(0), array({1}), array(1), 0));
+
+  // Mismatch dimensions and indices
+  CHECK_THROWS(scatter(array({0}), {array({0})}, array({1}, {1, 1}), {0, 1}));
+  CHECK_THROWS(scatter(array({0}), array({0}), array({1}, {1, 1}), -1));
+
+  // Repeat dimensions
+  CHECK_THROWS(scatter(
+      array({0}, {1, 1}), {array({0}), array({0})}, array({1}), {0, 0}));
+
+  // Update sizes incorrect
+  CHECK_THROWS(scatter(array({0}), array({0}), array({0, 1}), 0));
+  CHECK_THROWS(scatter(array({0}), array({0}), array({0, 1}, {2, 1}), 0));
+  CHECK_THROWS(scatter(array({0}, {1}), array({0}), array({0, 1}, {1, 2}), 0));
+
+  // Wrong index type
+  CHECK_THROWS(scatter(array({0}), array({0.0f}), array({0}, {1, 1}), 0));
+  CHECK_THROWS(scatter(
+      array({0}, {1, 1}),
+      {array({0}), array({0.0f})},
+      array({1}, {1, 1, 1}),
+      {0, 1}));
+
+  // Index arrays must be broadcastable
+  CHECK_THROWS(scatter(
+      array({0}, {1, 1}),
+      {array({0, 0, 0}, {3}), array({0, 0}, {2})},
+      ones({3, 2, 1, 1}),
+      {0, 1}));
+
+  // Single element scatter
+  auto in = zeros({4}, float32);
+  auto inds = arange(2);
+  auto updates = ones({2, 1}, float32);
+  auto out = scatter(in, inds, updates, 0);
+  CHECK(array_equal(out, array({1.0f, 1.0f, 0.0f, 0.0f})).item<bool>());
+
+  // Single element scatter add
+  in = ones({4}, float32);
+  inds = array({0, 0, 3});
+  updates = ones({3, 1}, float32);
+  out = scatter_add(in, inds, updates, 0);
+  CHECK(array_equal(out, array({3.0f, 1.0f, 1.0f, 2.0f})).item<bool>());
+
+  // Single element scatter prod
+  in = ones({4}, float32);
+  inds = array({0, 0, 3});
+  updates = full({3, 1}, 2.0f, float32);
+  out = scatter_prod(in, inds, updates, 0);
+  CHECK(array_equal(out, array({4.0f, 1.0f, 1.0f, 2.0f})).item<bool>());
+
+  // Single element scatter max
+  in = ones({4}, float32);
+  inds = array({0, 0, 3});
+  updates = array({1.0f, 6.0f, -2.0f}, {3, 1});
+  out = scatter_max(in, inds, updates, 0);
+  CHECK(array_equal(out, array({6.0f, 1.0f, 1.0f, 1.0f})).item<bool>());
+
+  // Single element scatter min
+  in = ones({4}, float32);
+  inds = array({0, 0, 3});
+  updates = array({1.0f, -6.0f, 2.0f}, {3, 1});
+  out = scatter_min(in, inds, updates, 0);
+  CHECK(array_equal(out, array({-6.0f, 1.0f, 1.0f, 1.0f})).item<bool>());
+
+  // Empty scatter
+  in = arange(4, float32);
+  inds = astype(array({}), uint32);
+  updates = reshape(array({}), {0, 1});
+  out = scatter(in, inds, updates, 0);
+  CHECK(array_equal(out, in).item<bool>());
+
+  // Array scatters
+  in = zeros({4, 4}, float32);
+  inds = array({0, 1, 2, 3});
+  updates = reshape(arange(16, float32), {4, 1, 4});
+  out = scatter(in, inds, updates, 0);
+  CHECK(array_equal(out, reshape(arange(16, float32), {4, 4})).item<bool>());
+
+  // Array scatters with col contiguous updates
+  in = zeros({4, 4}, float32);
+  inds = array({0, 1, 2, 3});
+  updates = transpose(reshape(arange(16, float32), {4, 1, 4}));
+  out = scatter(in, inds, updates, 0);
+  CHECK(array_equal(out, transpose(reshape(arange(16, float32), {4, 4})))
+            .item<bool>());
+
+  // Irregular strided index and reduce collision test
+  in = zeros({10}, float32);
+  inds = broadcast_to(array(3), {10});
+  updates = ones({10, 1}, float32);
+  out = scatter_add(in, inds, updates, 0);
+  CHECK_EQ(take(out, array(3)).item<float>(), 10);
+
+  // 1 element array with 0 dim index
+  in = array({1}, int32);
+  updates = array({2}, int32);
+  out = scatter_max(in, array(0), updates, 0);
+  CHECK_EQ(out.item<int>(), 2);
+
+  // No index arrays or axes
+  out = scatter_max(array(1), {}, array(2), std::vector<int>{});
+  CHECK_EQ(out.item<int>(), 2);
+
+  // Irregularly strided updates test
+  in = ones({3, 3});
+  updates = broadcast_to(array({2, 2, 2}), {1, 3, 3});
+  inds = array({0});
+  out = scatter(in, inds, updates, 0);
+  CHECK(array_equal(out, ones({3, 3}) * 2).item<bool>());
+
+  // Along different axis
+  in = zeros({2, 3});
+  updates = array({1, 2, 3, 4}, {2, 2, 1});
+  inds = array({0, 2});
+  out = scatter(in, inds, updates, 1);
+  auto expected = array({1, 0, 3, 2, 0, 4}, {2, 3});
+  CHECK(array_equal(out, expected).item<bool>());
+
+  // Multiple index arrays
+  in = zeros({2, 2});
+  updates = array({1, 2}, {2, 1, 1});
+  inds = array({0, 1});
+  out = scatter(in, {inds, inds}, updates, {0, 1});
+  CHECK(array_equal(out, array({1, 0, 0, 2}, {2, 2})).item<bool>());
+
+  // Broadcasted indices
+  in = zeros({2, 2});
+  updates = array({5, 2, 9, 1}, {2, 2, 1, 1});
+  auto inds0 = array({0, 1}, {2, 1});
+  auto inds1 = array({0, 1}, {1, 2});
+  out = scatter(in, {inds0, inds1}, updates, {0, 1});
+  CHECK(array_equal(out, array({5, 2, 9, 1}, {2, 2})).item<bool>());
+
+  // Brodacasted operand
+  in = broadcast_to(array({0, 0}), {2, 2});
+  updates = array({1, 1}, {2, 1, 1});
+  inds = array({0, 1});
+  out = scatter_add(in, inds, updates, 0);
+  CHECK(array_equal(out, array({1, 0, 1, 0}, {2, 2})).item<bool>());
+
+  // 1D scatter
+  {
+    auto dst = zeros({2, 4}, int32);
+    auto src = reshape(array({1, 2, 3, 4}), {1, 1, 4});
+    auto idx = array({1});
+    auto expected = reshape(array({0, 0, 0, 0, 1, 2, 3, 4}), {2, 4});
+    auto out = scatter(dst, idx, src, 0);
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+
+  // 1D indices with 2D update
+  {
+    auto dst = zeros({3, 4}, int32);
+    auto indices = {array({1}), array({2})};
+    auto axes = {0, 1};
+    auto updates = reshape(array({1, 2, 3, 4}, int32), {1, 2, 2});
+    auto out = scatter(dst, indices, updates, axes);
+    auto expected =
+        reshape(array({0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 3, 4}), {3, 4});
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+}
+
+TEST_CASE("test is positive infinity") {
+  array x(1.0f);
+  CHECK_FALSE(isposinf(x).item<bool>());
+
+  array y(std::numeric_limits<float>::infinity());
+  CHECK(isposinf(y).item<bool>());
+
+  array z = identity(7);
+  CHECK_FALSE(all(isposinf(z)).item<bool>());
+
+  array w = array({1.0f, std::numeric_limits<float>::infinity(), 2.0f});
+  CHECK_FALSE(all(isposinf(w)).item<bool>());
+
+  array a(1.0f, bfloat16);
+  CHECK_FALSE(isposinf(a).item<bool>());
+
+  array b(std::numeric_limits<float>::infinity(), float16);
+  CHECK(isposinf(b).item<bool>());
+
+  array c(std::numeric_limits<float>::infinity(), bfloat16);
+  CHECK(isposinf(c).item<bool>());
+}
+
+TEST_CASE("test is negative infinity") {
+  array x(1.0f);
+  CHECK_FALSE(isneginf(x).item<bool>());
+
+  array y(-std::numeric_limits<float>::infinity());
+  CHECK(isneginf(y).item<bool>());
+
+  array z = identity(7);
+  CHECK_FALSE(all(isneginf(z)).item<bool>());
+
+  array w = array({1.0f, -std::numeric_limits<float>::infinity(), 2.0f});
+  CHECK_FALSE(all(isneginf(w)).item<bool>());
+
+  array a(1.0f, bfloat16);
+  CHECK_FALSE(isneginf(a).item<bool>());
+
+  array b(-std::numeric_limits<float>::infinity(), float16);
+  CHECK(isneginf(b).item<bool>());
+
+  array c(-std::numeric_limits<float>::infinity(), bfloat16);
+  CHECK(isneginf(c).item<bool>());
+}
+
+TEST_CASE("test scatter types") {
+  for (auto t : {bool_, uint8, uint16, int8, int16}) {
+    auto in = zeros({4, 4}, t);
+    auto inds = {arange(4), arange(4)};
+    auto updates = ones({4, 1, 1}, t);
+    auto out = scatter(in, inds, updates, {0, 1});
+    auto expected =
+        array({1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}, {4, 4}, t);
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+
+  for (auto t : {float16, bfloat16}) {
+    auto in = zeros({4, 4}, t);
+    auto inds = {arange(4), arange(4)};
+    auto updates = ones({4, 1, 1}, t);
+    auto out = scatter(in, inds, updates, {0, 1});
+    auto expected =
+        array({1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}, {4, 4}, t);
+    CHECK(allclose(out, expected).item<bool>());
+  }
+}
+
+TEST_CASE("test complex ops") {
+  //  Creation ops
+  {
+    auto x = full({2, 2}, complex64_t{1, 1});
+    CHECK_EQ(x.dtype(), complex64);
+    std::initializer_list<complex64_t> expected = {
+        {1, 1}, {1, 1}, {1, 1}, {1, 1}};
+    CHECK(array_equal(x, array(expected, {2, 2})).item<bool>());
+  }
+
+  // Unary ops
+  {
+    std::initializer_list<complex64_t> vals = {{0, 1}, {1, 0}, {1, 1}};
+    auto x = array(vals);
+
+    auto y = abs(x);
+    CHECK_EQ(y.dtype(), float32);
+    CHECK(array_equal(y, array({1.0f, 1.0f, std::sqrt(2.0f)})).item<bool>());
+
+    y = negative(x);
+    std::initializer_list<complex64_t> expected = {{0, -1}, {-1, 0}, {-1, -1}};
+    CHECK(array_equal(y, array(expected)).item<bool>());
+
+    y = exp(x);
+    {
+      std::initializer_list<complex64_t> expected = {
+          {0.54030231, 0.84147098}, {2.71828183, 0.}, {1.46869394, 2.28735529}};
+      CHECK(allclose(y, array(expected)).item<bool>());
+    }
+
+    y = sin(x);
+    {
+      std::initializer_list<complex64_t> expected = {
+          {0., 1.17520119}, {0.84147098, 0.}, {1.29845758, 0.63496391}};
+      CHECK(allclose(y, array(expected)).item<bool>());
+    }
+
+    y = cos(x);
+    {
+      std::initializer_list<complex64_t> expected = {
+          {1.54308063, -0.}, {0.54030231, -0.}, {0.83373003, -0.98889771}};
+      CHECK(allclose(y, array(expected)).item<bool>());
+    }
+  }
+
+  // Binary ops
+  {
+    std::initializer_list<complex64_t> vals_x = {{0, 1}, {1, 0}, {1, 1}};
+    auto x = array(vals_x);
+
+    std::initializer_list<complex64_t> vals_y = {{2, 0}, {1, 1}, {0, 1}};
+    auto y = array(vals_y);
+
+    auto z = add(x, y);
+    {
+      std::initializer_list<complex64_t> expected = {{2, 1}, {2, 1}, {1, 2}};
+      CHECK(array_equal(z, array(expected)).item<bool>());
+    }
+
+    z = subtract(x, y);
+    {
+      std::initializer_list<complex64_t> expected = {{-2, 1}, {0, -1}, {1, 0}};
+      CHECK(array_equal(z, array(expected)).item<bool>());
+    }
+
+    z = multiply(x, y);
+    {
+      std::initializer_list<complex64_t> expected = {{0, 2}, {1, 1}, {-1, 1}};
+      CHECK(array_equal(z, array(expected)).item<bool>());
+    }
+
+    z = maximum(x, y);
+    {
+      std::initializer_list<complex64_t> expected = {{2, 0}, {1, 1}, {1, 1}};
+      CHECK(array_equal(z, array(expected)).item<bool>());
+    }
+  }
+
+  // Reductions
+  if (default_device() == Device::cpu) {
+    std::initializer_list<complex64_t> vals = {{0, 0}, {1, 0}, {0, 1}};
+    auto x = array(vals);
+    CHECK_EQ(max(x).item<complex64_t>(), complex64_t{1, 0});
+    CHECK_EQ(min(x).item<complex64_t>(), complex64_t{0, 0});
+    CHECK_EQ(sum(x).item<complex64_t>(), complex64_t{1, 1});
+    CHECK_EQ(prod(x).item<complex64_t>(), complex64_t{0, 0});
+  }
+}
+
+TEST_CASE("test as_strided op") {
+  auto x = arange(10);
+  auto y = as_strided(x, {3, 3}, {1, 1}, 0);
+  auto expected = array({0, 1, 2, 1, 2, 3, 2, 3, 4}, {3, 3});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  y = as_strided(x, {3, 3}, {0, 3}, 0);
+  expected = array({0, 3, 6, 0, 3, 6, 0, 3, 6}, {3, 3});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  x = reshape(x, {2, 5}); // 0 1 2 3 ...
+  x = transpose(x, {1, 0}); // 0 5 1 6 2 7 ...
+  y = as_strided(x, {3, 3}, {2, 1}, 1);
+  expected = array({5, 1, 6, 6, 2, 7, 7, 3, 8}, {3, 3});
+  CHECK(array_equal(y, expected).item<bool>());
+}
+
+TEST_CASE("test scan op") {
+  auto x = array({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}, {2, 3});
+  auto y = cumsum(x, 1, false, true);
+  auto expected = array({1.0f, 3.0f, 6.0f, 4.0f, 9.0f, 15.0f}, {2, 3});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  y = cumsum(x, 1, false, false);
+  expected = array({0.0f, 1.0f, 3.0f, 0.0f, 4.0f, 9.0f}, {2, 3});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  y = cumsum(x, 1, true, true);
+  expected = array({6.0f, 5.0f, 3.0f, 15.0f, 11.0f, 6.0f}, {2, 3});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  y = cumsum(x, 1, true, false);
+  expected = array({5.0f, 3.0f, 0.0f, 11.0f, 6.0f, 0.0f}, {2, 3});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  x = array({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f}, {2, 2, 2});
+  y = cumsum(x, 0, false, true);
+  expected =
+      array({1.0f, 2.0f, 3.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f}, {2, 2, 2});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  y = cumsum(x, 1, false, true);
+  expected =
+      array({1.0f, 2.0f, 4.0f, 6.0f, 5.0f, 6.0f, 12.0f, 14.0f}, {2, 2, 2});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  x = array({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f}, {2, 2, 2});
+  y = cumsum(x, 0, true, true);
+  expected =
+      array({6.0f, 8.0f, 10.0f, 12.0f, 5.0f, 6.0f, 7.0f, 8.0f}, {2, 2, 2});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  y = cumsum(x, 1, true, true);
+  expected =
+      array({4.0f, 6.0f, 3.0f, 4.0f, 12.0f, 14.0f, 7.0f, 8.0f}, {2, 2, 2});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  x = reshape(x, {4, 2});
+  y = cumsum(x, 0, false, false);
+  expected = array({0.0f, 0.0f, 1.0f, 2.0f, 4.0f, 6.0f, 9.0f, 12.0f}, {4, 2});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  y = cumsum(x, 0, true, false);
+  expected =
+      array({15.0f, 18.0f, 12.0f, 14.0f, 7.0f, 8.0f, 0.0f, 0.0f}, {4, 2});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  // Check the vmap implementation
+  auto fun = [](array x) { return cumsum(x, 0, false, true); };
+  y = vmap(fun, 0, 0)(x);
+  expected = array({1.0f, 3.0f, 3.0f, 7.0f, 5.0f, 11.0f, 7.0f, 15.0f}, {4, 2});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  y = vmap(fun, 1, 1)(x);
+  expected = array({1.0f, 2.0f, 4.0f, 6.0f, 9.0f, 12.0f, 16.0f, 20.0f}, {4, 2});
+  CHECK(array_equal(y, expected).item<bool>());
+}
+
+TEST_CASE("test pad") {
+  auto x = zeros({1, 2, 3});
+  CHECK_EQ(pad(x, 1).shape(), Shape{3, 4, 5});
+  CHECK_EQ(pad(x, {0, 1}).shape(), Shape{2, 3, 4});
+  CHECK_EQ(pad(x, {{1, 1}, {1, 2}, {3, 1}}).shape(), Shape{3, 5, 7});
+
+  x = array({1.0f, 2.0f, 3.0f, 4.0f}, {2, 2});
+  auto padded_x = pad(x, 1);
+  auto expected = array(
+      {0.0f,
+       0.0f,
+       0.0f,
+       0.0f,
+       0.0f,
+       1.0f,
+       2.0f,
+       0.0f,
+       0.0f,
+       3.0f,
+       4.0f,
+       0.0f,
+       0.0f,
+       0.0f,
+       0.0f,
+       0.0f},
+      {4, 4});
+  CHECK(array_equal(padded_x, expected).item<bool>());
+}
+
+TEST_CASE("test power") {
+  CHECK_EQ(power(array(1), array(2)).item<int>(), 1);
+  CHECK_EQ((power(array(-1), array(2))).item<int>(), 1);
+  CHECK_EQ((power(array(-1), array(3))).item<int>(), -1);
+
+  CHECK_EQ((power(array(true), array(false))).item<bool>(), true);
+  CHECK_EQ((power(array(false), array(false))).item<bool>(), true);
+  CHECK_EQ((power(array(true), array(true))).item<bool>(), true);
+  CHECK_EQ((power(array(false), array(true))).item<bool>(), false);
+
+  auto x = array(2.0f);
+  CHECK_EQ(
+      (power(x, array(0.5))).item<float>(),
+      doctest::Approx(std::pow(2.0f, 0.5f)));
+  CHECK_EQ(power(x, array(2.0f)).item<float>(), 4.0f);
+
+  CHECK(std::isnan((power(array(-1.0f), array(0.5))).item<float>()));
+
+  auto a = complex64_t{0.5, 0.5};
+  auto b = complex64_t{0.5, 0.5};
+  auto expected = std::pow(a, b);
+  auto out = (power(array(a), array(b))).item<complex64_t>();
+  CHECK(abs(out.real() - expected.real()) < 1e-7);
+  CHECK(abs(out.imag() - expected.imag()) < 1e-7);
+
+  a = complex64_t{-1.2, 0.1};
+  b = complex64_t{2.2, 0.0};
+  expected = std::pow(a, b);
+  out = (power(array(a), array(b))).item<complex64_t>();
+  CHECK(abs(out.real() - expected.real()) < 1e-6);
+  CHECK(abs(out.imag() - expected.imag()) < 1e-6);
+}
+
+TEST_CASE("test where") {
+  const float inf = std::numeric_limits<float>::infinity();
+
+  array condition(true);
+  array x(1.0f);
+  array y(0.0f);
+  auto out = where(condition, x, y);
+  CHECK_EQ(out.dtype(), float32);
+  CHECK_EQ(out.item<float>(), 1.0f);
+
+  x = array({1, 2}, {2, 1});
+  y = array({3, 4}, {1, 2});
+  CHECK(array_equal(where(condition, x, y), broadcast_to(x, {2, 2}))
+            .item<bool>());
+
+  condition = array(false);
+  CHECK(array_equal(where(condition, x, y), broadcast_to(y, {2, 2}))
+            .item<bool>());
+
+  condition = array({true, false});
+  out = where(condition, x, y);
+  auto expected = array({1, 4, 2, 4}, {2, 2});
+  CHECK(array_equal(where(condition, x, y), expected).item<bool>());
+
+  condition = array({true, false, false, true}, {2, 2});
+  out = where(condition, x, y);
+  expected = array({1, 4, 3, 2}, {2, 2});
+  CHECK(array_equal(where(condition, x, y), expected).item<bool>());
+
+  x = array(1);
+  y = array(2);
+  out = where(condition, x, y);
+  expected = array({1, 2, 2, 1}, {2, 2});
+  CHECK(array_equal(where(condition, x, y), expected).item<bool>());
+
+  condition = array(true);
+  x = array({1, 2, 3});
+  y = array({3, 6, 13});
+  CHECK(array_equal(where(condition, x, y), array({1, 2, 3})).item<bool>());
+
+  condition = array(false);
+  x = array({1, 2, 3});
+  y = array({3, 6, 13});
+  CHECK(array_equal(where(condition, x, y), array({3, 6, 13})).item<bool>());
+
+  condition = array({1, 1, 0});
+  x = array({1, 2, 3});
+  y = array({11, 12, 13});
+  CHECK(array_equal(where(condition, x, y), array({1, 2, 13})).item<bool>());
+
+  condition = array({true, false}, {2, 1, 1});
+  x = array({1, 2, 3, 4}, {2, 1, 2});
+  y = array({11, 22, 33, 44}, {2, 2, 1});
+  expected = array({1, 2, 1, 2, 33, 33, 44, 44}, {2, 2, 2});
+  CHECK(array_equal(where(condition, x, y), expected).item<bool>());
+
+  condition = array({true, false, false});
+  x = array({inf, 2.0, 3.0});
+  y = array({10.0, 20.0, -inf});
+  CHECK(array_equal(where(condition, x, y), array({inf, 20.0, -inf}))
+            .item<bool>());
+
+  // 4-dim optimized case.
+  condition = array({false});
+  x = array({1, 2}, {2, 1, 1, 1});
+  y = array({3, 4}, {1, 1, 2, 1});
+  CHECK(array_equal(where(condition, x, y), array({3, 4, 3, 4}, {2, 1, 2, 1}))
+            .item<bool>());
+
+  // 5-dim optimized case.
+  condition = array({true, false}, {2, 1, 1, 1, 1});
+  x = array({1, 2, 3, 4}, {2, 1, 1, 1, 2});
+  y = array({11, 22}, {1, 1, 2, 1, 1});
+  CHECK(array_equal(
+            where(condition, x, y),
+            array({1, 2, 1, 2, 11, 11, 22, 22}, {2, 1, 2, 1, 2}))
+            .item<bool>());
+}
+
+TEST_CASE("test stack") {
+  auto x = array({});
+  CHECK_EQ(stack({x}, 0).shape(), Shape{1, 0});
+  CHECK_EQ(stack({x}, 1).shape(), Shape{0, 1});
+
+  x = array({1, 2, 3}, {3});
+  CHECK_EQ(stack({x}, 0).shape(), Shape{1, 3});
+  CHECK_EQ(stack({x}, 1).shape(), Shape{3, 1});
+
+  auto y = array({4, 5, 6}, {3});
+  auto z = std::vector<array>{x, y};
+  CHECK_EQ(stack(z).shape(), Shape{2, 3});
+  CHECK_EQ(stack(z, 0).shape(), Shape{2, 3});
+  CHECK_EQ(stack(z, 1).shape(), Shape{3, 2});
+  CHECK_EQ(stack(z, -1).shape(), Shape{3, 2});
+  CHECK_EQ(stack(z, -2).shape(), Shape{2, 3});
+
+  CHECK_THROWS_MESSAGE(stack({}, 0), "No arrays provided for stacking");
+
+  x = array({1, 2, 3}, {3}, float16);
+  y = array({4, 5, 6}, {3}, int32);
+  CHECK_EQ(stack({x, y}, 0).dtype(), float16);
+
+  x = array({1, 2, 3}, {3}, int32);
+  y = array({4, 5, 6, 7}, {4}, int32);
+  CHECK_THROWS_MESSAGE(
+      stack({x, y}, 0), "All arrays must have the same shape and dtype");
+}
+
+TEST_CASE("test eye") {
+  auto eye_3 = eye(3);
+  CHECK_EQ(eye_3.shape(), Shape{3, 3});
+  auto expected_eye_3 =
+      array({1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f}, {3, 3});
+  CHECK(array_equal(eye_3, expected_eye_3).item<bool>());
+
+  auto eye_3x2 = eye(3, 2);
+  CHECK_EQ(eye_3x2.shape(), Shape{3, 2});
+  auto expected_eye_3x2 = array({1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f}, {3, 2});
+  CHECK(array_equal(eye_3x2, expected_eye_3x2).item<bool>());
+}
+
+TEST_CASE("test tri") {
+  auto _tri = tri(4, 4, 0, float32);
+  CHECK_EQ(_tri.shape(), Shape{4, 4});
+  auto expected_tri = array(
+      {1.0f,
+       0.0f,
+       0.0f,
+       0.0f,
+       1.0f,
+       1.0f,
+       0.0f,
+       0.0f,
+       1.0f,
+       1.0f,
+       1.0f,
+       0.0f,
+       1.0f,
+       1.0f,
+       1.0f,
+       1.0f},
+      {4, 4});
+  CHECK(array_equal(_tri, expected_tri).item<bool>());
+}
+
+TEST_CASE("test tril") {
+  auto _tril = tril(full({4, 4}, 2.0f, float32), 0);
+  CHECK_EQ(_tril.shape(), Shape{4, 4});
+  auto expected_tri = array(
+      {2.0f,
+       0.0f,
+       0.0f,
+       0.0f,
+       2.0f,
+       2.0f,
+       0.0f,
+       0.0f,
+       2.0f,
+       2.0f,
+       2.0f,
+       0.0f,
+       2.0f,
+       2.0f,
+       2.0f,
+       2.0f},
+      {4, 4});
+  CHECK(array_equal(_tril, expected_tri).item<bool>());
+}
+
+TEST_CASE("test triu") {
+  auto _triu = triu(full({4, 4}, 2.0f, float32), 0);
+  CHECK_EQ(_triu.shape(), Shape{4, 4});
+  auto expected_tri = array(
+      {2.0f,
+       2.0f,
+       2.0f,
+       2.0f,
+       0.0f,
+       2.0f,
+       2.0f,
+       2.0f,
+       0.0f,
+       0.0f,
+       2.0f,
+       2.0f,
+       0.0f,
+       0.0f,
+       0.0f,
+       2.0f},
+      {4, 4});
+  CHECK(array_equal(_triu, expected_tri).item<bool>());
+}
+
+TEST_CASE("test identity") {
+  auto id_4 = identity(4);
+  CHECK_EQ(id_4.shape(), Shape{4, 4});
+  auto expected_id_4 = array(
+      {1.0f,
+       0.0f,
+       0.0f,
+       0.0f,
+       0.0f,
+       1.0f,
+       0.0f,
+       0.0f,
+       0.0f,
+       0.0f,
+       1.0f,
+       0.0f,
+       0.0f,
+       0.0f,
+       0.0f,
+       1.0f},
+      {4, 4});
+  CHECK(array_equal(id_4, expected_id_4).item<bool>());
+}
+
+TEST_CASE("test eye with positive k offset") {
+  auto eye_3_k1 = eye(3, 4, 1);
+  CHECK_EQ(eye_3_k1.shape(), Shape{3, 4});
+  auto expected_eye_3_k1 = array(
+      {0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f},
+      {3, 4});
+  CHECK(array_equal(eye_3_k1, expected_eye_3_k1).item<bool>());
+}
+
+TEST_CASE("test eye with negative k offset") {
+  auto eye_4_k_minus1 = eye(4, 3, -1);
+  CHECK_EQ(eye_4_k_minus1.shape(), Shape{4, 3});
+  auto expected_eye_4_k_minus1 = array(
+      {0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f},
+      {4, 3});
+  CHECK(array_equal(eye_4_k_minus1, expected_eye_4_k_minus1).item<bool>());
+}
+
+TEST_CASE("test basic clipping") {
+  array a({1.0f, 4.0f, 3.0f, 8.0f, 5.0f}, {5});
+  array expected({2.0f, 4.0f, 3.0f, 6.0f, 5.0f}, {5});
+  auto clipped = clip(a, array(2.0f), array(6.0f));
+  CHECK(array_equal(clipped, expected).item<bool>());
+}
+
+TEST_CASE("test clipping with only min") {
+  array a({-1.0f, 1.0f, 0.0f, 5.0f}, {4});
+  array expected({0.0f, 1.0f, 0.0f, 5.0f}, {4});
+  auto clipped = clip(a, array(0.0f), std::nullopt);
+  CHECK(array_equal(clipped, expected).item<bool>());
+}
+
+TEST_CASE("test clipping with only max") {
+  array a({2.0f, 3.0f, 4.0f, 5.0f}, {4});
+  array expected({2.0f, 3.0f, 4.0f, 4.0f}, {4});
+  auto clipped = clip(a, std::nullopt, array(4.0f));
+  CHECK(array_equal(clipped, expected).item<bool>());
+}
+
+TEST_CASE("test linspace") {
+  auto x = linspace(0, 10, 5);
+  auto expected = array({0.0f, 2.5f, 5.0f, 7.5f, 10.0f}, {5});
+  CHECK(array_equal(x, expected).item<bool>());
+
+  x = linspace(0, 10, 5, int32);
+  expected = array({0, 2, 5, 7, 10}, {5});
+  CHECK(array_equal(x, expected).item<bool>());
+
+  x = linspace(0, 1, 0);
+  expected = array(std::initializer_list<float>{}, {0});
+  CHECK(array_equal(x, expected).item<bool>());
+}
+
+TEST_CASE("test quantize dequantize") {
+  auto x1 = ones({128, 1});
+  auto x2 = expand_dims(arange(0, 512, float32), 0);
+  auto x = x1 * x2;
+
+  for (int i = 2; i <= 8; i *= 2) {
+    int el_per_int = 32 / i;
+    auto res = quantize(x, 128, i);
+    auto x_q = res[0];
+    auto scales = res[1];
+    auto biases = res[2];
+    CHECK_EQ(x_q.shape(), Shape{128, 512 / el_per_int});
+    CHECK_EQ(scales.shape(), Shape{128, 4});
+    CHECK_EQ(biases.shape(), Shape{128, 4});
+
+    auto x_hat = dequantize(x_q, scales, biases, 128, i);
+    auto max_diff = max(abs(x - x_hat)).item<float>();
+    CHECK(max_diff <= 127.0 / (1 << i));
+  }
+}
+
+TEST_CASE("test repeat") {
+  auto data = array({13, 3, 16, 6, 14, 4, 15, 5, 11, 1, 12, 2}, {3, 2, 2});
+  auto repeat_axis_0 = repeat(data, 2, 0);
+  auto expected_axis_0 = array(
+      {13, 3, 16, 6, 13, 3, 16, 6, 14, 4, 15, 5,
+       14, 4, 15, 5, 11, 1, 12, 2, 11, 1, 12, 2},
+      {6, 2, 2});
+
+  auto repeat_axis_1 = repeat(data, 2, 1);
+  auto expected_axis_1 = array(
+      {13, 3, 13, 3, 16, 6, 16, 6, 14, 4, 14, 4,
+       15, 5, 15, 5, 11, 1, 11, 1, 12, 2, 12, 2},
+      {3, 4, 2});
+
+  auto repeat_axis_2 = repeat(data, 2); // default axis == ndim - 1 == 2
+  auto expected_axis_2 = array(
+      {13, 13, 3, 3, 16, 16, 6, 6, 14, 14, 4, 4,
+       15, 15, 5, 5, 11, 11, 1, 1, 12, 12, 2, 2},
+      {24});
+
+  // check output
+  CHECK(array_equal(repeat_axis_0, expected_axis_0).item<bool>());
+  CHECK(array_equal(repeat_axis_1, expected_axis_1).item<bool>());
+  CHECK(array_equal(repeat_axis_2, expected_axis_2).item<bool>());
+
+  auto data_2 = array({1, 3, 2}, {3});
+  auto repeat_2 = repeat(data_2, 2, 0);
+  auto expected_2 = array({1, 1, 3, 3, 2, 2}, {6});
+  CHECK(array_equal(repeat_2, expected_2).item<bool>());
+
+  auto data_3 = array({1, 2, 3, 4, 5, 4, 0, 1, 2}, {3, 3});
+  auto repeat_3 = repeat(data_3, 2, 0);
+  auto expected_3 =
+      array({1, 2, 3, 1, 2, 3, 4, 5, 4, 4, 5, 4, 0, 1, 2, 0, 1, 2}, {6, 3});
+  CHECK(array_equal(repeat_3, expected_3).item<bool>());
+
+  // 0 repeats
+  auto repeat_4 = repeat(data_3, 0, 0);
+  auto expected_4 = array({});
+  CHECK(array_equal(repeat_2, expected_2).item<bool>());
+
+  // negative repeats
+  CHECK_THROWS_AS(repeat(data_3, -3, 0), std::invalid_argument);
+}
+
+TEST_CASE("tile") {
+  auto x = array({1, 2, 3}, {3});
+  auto y = tile(x, {2});
+  auto expected = array({1, 2, 3, 1, 2, 3}, {6});
+  CHECK(array_equal(y, expected).item<bool>());
+  x = array({1, 2, 3, 4}, {2, 2});
+  y = tile(x, {2});
+  expected = array({1, 2, 1, 2, 3, 4, 3, 4}, {2, 4});
+  CHECK(array_equal(y, expected).item<bool>());
+  x = array({1, 2, 3, 4}, {2, 2});
+  y = tile(x, {4, 1});
+  expected = array({1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4}, {8, 2});
+  CHECK(array_equal(y, expected).item<bool>());
+
+  x = array({1, 2, 3, 4}, {2, 2});
+  y = tile(x, {2, 2});
+  expected = array({1, 2, 1, 2, 3, 4, 3, 4, 1, 2, 1, 2, 3, 4, 3, 4}, {4, 4});
+  CHECK(array_equal(y, expected).item<bool>());
+  x = array({1, 2, 3}, {3});
+  y = tile(x, {2, 2, 2});
+  expected = array(
+      {1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3},
+      {2, 2, 6});
+  CHECK(array_equal(y, expected).item<bool>());
+}
+
+TEST_CASE("tensordot") {
+  auto x = reshape(arange(60.), {3, 4, 5});
+  auto y = reshape(arange(24.), {4, 3, 2});
+  auto z = tensordot(x, y, {1, 0}, {0, 1});
+  auto expected = array(
+      {4400, 4730, 4532, 4874, 4664, 5018, 4796, 5162, 4928, 5306}, {5, 2});
+  CHECK(array_equal(z, expected).item<bool>());
+  x = reshape(arange(360.), {3, 4, 5, 6});
+  y = reshape(arange(360.), {6, 4, 5, 3});
+  CHECK_THROWS_AS(tensordot(x, y, {2, 1, 3}, {1, 2, 0}), std::invalid_argument);
+  x = reshape(arange(60.), {3, 4, 5});
+  y = reshape(arange(120.), {4, 5, 6});
+  z = tensordot(x, y, 2);
+  expected = array(
+      {14820.,
+       15010.,
+       15200.,
+       15390.,
+       15580.,
+       15770.,
+       37620.,
+       38210.,
+       38800.,
+       39390.,
+       39980.,
+       40570.,
+       60420.,
+       61410.,
+       62400.,
+       63390.,
+       64380.,
+       65370.},
+      {3, 6});
+  CHECK(array_equal(z, expected).item<bool>());
+}
+
+TEST_CASE("outer") {
+  auto x = arange(1.0, 5.0);
+  auto y = arange(1.0, 4.0);
+  auto z = outer(x, y);
+  auto expected = array(
+      {1.0, 2.0, 3.0, 2.0, 4.0, 6.0, 3.0, 6.0, 9.0, 4.0, 8.0, 12.0}, {4, 3});
+  CHECK(array_equal(z, expected).item<bool>());
+
+  x = ones({5});
+  y = linspace(-2., 2., 5);
+  z = outer(x, y);
+  expected = array(
+      {-2., -1., 0.,  1.,  2., -2., -1., 0.,  1.,  2., -2., -1., 0.,
+       1.,  2.,  -2., -1., 0., 1.,  2.,  -2., -1., 0., 1.,  2.},
+      {5, 5});
+  CHECK(array_equal(z, expected).item<bool>());
+}
+
+TEST_CASE("inner") {
+  CHECK_THROWS_AS(
+      inner(reshape(arange(5.), {1, 5}), reshape(arange(6.), {2, 3})),
+      std::invalid_argument);
+  auto x = array({1., 2., 3.});
+  auto y = array({0., 1., 0.});
+  auto z = inner(x, y);
+  CHECK_EQ(z.item<float>(), 2.f);
+
+  x = reshape(arange(24.), {2, 3, 4});
+  y = arange(4.);
+  z = inner(x, y);
+  auto expected = array({14., 38., 62., 86., 110., 134.}, {2, 3});
+  CHECK(array_equal(z, expected).item<bool>());
+
+  x = reshape(arange(2.), {1, 1, 2});
+  y = reshape(arange(6.), {3, 2});
+  z = inner(x, y);
+  expected = array({1., 3., 5.}, {1, 1, 3});
+  CHECK(array_equal(z, expected).item<bool>());
+
+  z = inner(eye(2), array(7.));
+  expected = array({7., 0., 0., 7.}, {2, 2});
+  CHECK(array_equal(z, expected).item<bool>());
+}
+
+TEST_CASE("test divmod") {
+  auto x = array({1, 2, 3});
+  auto y = array({1, 1, 1});
+  auto out = divmod(x, y);
+  CHECK(array_equal(out[0], array({1, 2, 3})).item<bool>());
+  CHECK(array_equal(out[1], array({0, 0, 0})).item<bool>());
+
+  x = array({5, 6, 7});
+  y = array({2, 2, 2});
+  out = divmod(x, y);
+  CHECK(array_equal(out[0], array({2, 3, 3})).item<bool>());
+  CHECK(array_equal(out[1], array({1, 0, 1})).item<bool>());
+
+  // Siblings should be gone after evaling the graph
+  CHECK(out[0].siblings().empty());
+  CHECK(out[1].siblings().empty());
+
+  x = array({5.0, 6.0, 7.0});
+  y = array({2.0, 2.0, 2.0});
+  out = divmod(x, y);
+  CHECK(array_equal(out[0], array({2.0, 3.0, 3.0})).item<bool>());
+  CHECK(array_equal(out[1], array({1.0, 0.0, 1.0})).item<bool>());
+
+  x = array({1.0}, complex64);
+  y = array({2.0}, complex64);
+  CHECK_THROWS(divmod(x, y));
+
+  // Check that we can eval on both outputs
+  x = array({1.0});
+  y = array({2.0});
+  out = divmod(x, y);
+  eval(out);
+  CHECK_EQ(out[0].item<float>(), 0.0);
+  CHECK_EQ(out[1].item<float>(), 1.0);
+
+  // Check nested in the graph
+  x = array({1.0});
+  y = array({2.0});
+  out = divmod(x, y);
+  auto z = out[0] + out[1];
+  CHECK_EQ(z.item<float>(), 1.0);
+
+  // Check that we can still eval when one output goes out of scope
+  std::vector<array> out_holder;
+  {
+    out_holder.push_back(divmod(x, y)[0]);
+  }
+  eval(out_holder);
+  CHECK_EQ(out_holder[0].item<float>(), 0.0);
+
+  // Check that we can still eval when the other output goes out of scope
+  out_holder.clear();
+  {
+    out_holder.push_back(divmod(x, y)[1]);
+  }
+  eval(out_holder);
+  CHECK_EQ(out_holder[0].item<float>(), 1.0);
+}
+
+TEST_CASE("test diagonal") {
+  auto x = array({0, 1, 2, 3, 4, 5, 6, 7}, {4, 2});
+  auto out = diagonal(x);
+  CHECK(array_equal(out, array({0, 3}, {2})).item<bool>());
+
+  CHECK_THROWS_AS(diagonal(x, 1, 6, 0), std::out_of_range);
+  CHECK_THROWS_AS(diagonal(x, 1, 0, -3), std::out_of_range);
+
+  x = array({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, {3, 4});
+  out = diagonal(x, 2, 1, 0);
+  CHECK(array_equal(out, array({8}, {1})).item<bool>());
+
+  out = diagonal(x, -1, 0, 1);
+  CHECK(array_equal(out, array({4, 9}, {2})).item<bool>());
+
+  out = diagonal(x, -5, 0, 1);
+  eval(out);
+  CHECK_EQ(out.shape(), Shape{0});
+
+  x = array({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, {3, 2, 2});
+  out = diagonal(x, 1, 0, 1);
+  CHECK(array_equal(out, array({2, 3}, {2, 1})).item<bool>());
+
+  out = diagonal(x, 0, 2, 0);
+  CHECK(array_equal(out, array({0, 5, 2, 7}, {2, 2})).item<bool>());
+
+  out = diagonal(x, 1, -1, 0);
+  CHECK(array_equal(out, array({4, 9, 6, 11}, {2, 2})).item<bool>());
+
+  x = reshape(arange(16), {2, 2, 2, 2});
+  out = diagonal(x, 0, 0, 1);
+  CHECK(array_equal(out, array({0, 12, 1, 13, 2, 14, 3, 15}, {2, 2, 2}))
+            .item<bool>());
+
+  CHECK_THROWS_AS(diagonal(x, 0, 1, 1), std::invalid_argument);
+
+  x = array({0, 1}, {2});
+  CHECK_THROWS_AS(diagonal(x, 0, 0, 1), std::invalid_argument);
+}
+
+TEST_CASE("test diag") {
+  // To few or too many dimensions
+  CHECK_THROWS(diag(array(0.0)));
+  CHECK_THROWS(diag(array({0.0}, {1, 1, 1})));
+
+  // Test with 1D array
+  auto x = array({0, 1, 2, 3}, {4});
+  auto out = diag(x, 0);
+  CHECK(
+      array_equal(
+          out, array({0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3}, {4, 4}))
+          .item<bool>());
+
+  out = diag(x, 1);
+  CHECK(array_equal(
+            out,
+            array(
+                {0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+                 2, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0},
+                {5, 5}))
+            .item<bool>());
+
+  out = diag(x, -1);
+  CHECK(array_equal(
+            out,
+            array(
+                {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
+                 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 3, 0},
+                {5, 5}))
+            .item<bool>());
+
+  // Test with 2D array
+  x = array({0, 1, 2, 3, 4, 5, 6, 7, 8}, {3, 3});
+  out = diag(x, 0);
+  CHECK(array_equal(out, array({0, 4, 8}, {3})).item<bool>());
+
+  out = diag(x, 1);
+  CHECK(array_equal(out, array({1, 5}, {2})).item<bool>());
+
+  out = diag(x, -1);
+  CHECK(array_equal(out, array({3, 7}, {2})).item<bool>());
+}
+
+TEST_CASE("test issubdtype") {
+  const auto cats = {
+      complexfloating,
+      floating,
+      inexact,
+      signedinteger,
+      unsignedinteger,
+      integer,
+      number,
+      generic};
+  const auto types = {
+      bool_,
+      uint8,
+      uint16,
+      uint32,
+      uint64,
+      int8,
+      int16,
+      int32,
+      int64,
+      float16,
+      float32,
+      bfloat16,
+      complex64};
+  for (const auto& type : types) {
+    CHECK(issubdtype(type, type));
+    CHECK(issubdtype(type, generic));
+    switch (kindof(type)) {
+      case Dtype::Kind::b:
+        CHECK_FALSE(issubdtype(type, complexfloating));
+        CHECK_FALSE(issubdtype(type, floating));
+        CHECK_FALSE(issubdtype(type, inexact));
+        CHECK_FALSE(issubdtype(type, signedinteger));
+        CHECK_FALSE(issubdtype(type, unsignedinteger));
+        CHECK_FALSE(issubdtype(type, integer));
+        CHECK_FALSE(issubdtype(type, number));
+        CHECK(issubdtype(type, generic));
+        break;
+      case Dtype::Kind::u:
+        CHECK_FALSE(issubdtype(type, complexfloating));
+        CHECK_FALSE(issubdtype(type, floating));
+        CHECK_FALSE(issubdtype(type, inexact));
+        CHECK_FALSE(issubdtype(type, signedinteger));
+        CHECK(issubdtype(type, unsignedinteger));
+        CHECK(issubdtype(type, integer));
+        CHECK(issubdtype(type, number));
+        CHECK(issubdtype(type, generic));
+        break;
+      case Dtype::Kind::i:
+        CHECK_FALSE(issubdtype(type, complexfloating));
+        CHECK_FALSE(issubdtype(type, floating));
+        CHECK_FALSE(issubdtype(type, inexact));
+        CHECK(issubdtype(type, signedinteger));
+        CHECK_FALSE(issubdtype(type, unsignedinteger));
+        CHECK(issubdtype(type, integer));
+        CHECK(issubdtype(type, number));
+        CHECK(issubdtype(type, generic));
+        break;
+      case Dtype::Kind::f:
+        CHECK_FALSE(issubdtype(type, complexfloating));
+        CHECK(issubdtype(type, floating));
+        CHECK(issubdtype(type, inexact));
+        CHECK_FALSE(issubdtype(type, signedinteger));
+        CHECK_FALSE(issubdtype(type, unsignedinteger));
+        CHECK_FALSE(issubdtype(type, integer));
+        CHECK(issubdtype(type, number));
+        CHECK(issubdtype(type, generic));
+        break;
+      case Dtype::Kind::c:
+        CHECK(issubdtype(type, complexfloating));
+        CHECK_FALSE(issubdtype(type, floating));
+        CHECK(issubdtype(type, inexact));
+        CHECK_FALSE(issubdtype(type, signedinteger));
+        CHECK_FALSE(issubdtype(type, unsignedinteger));
+        CHECK_FALSE(issubdtype(type, integer));
+        CHECK(issubdtype(type, number));
+        CHECK(issubdtype(type, generic));
+        break;
+      case Dtype::Kind::V:
+        CHECK_FALSE(issubdtype(type, complexfloating));
+        CHECK(issubdtype(type, floating));
+        CHECK(issubdtype(type, inexact));
+        CHECK_FALSE(issubdtype(type, signedinteger));
+        CHECK_FALSE(issubdtype(type, unsignedinteger));
+        CHECK_FALSE(issubdtype(type, integer));
+        CHECK(issubdtype(type, number));
+        CHECK(issubdtype(type, generic));
+        break;
+    }
+  }
+
+  for (const auto& type : types) {
+    CHECK(issubdtype(type, type));
+    CHECK(issubdtype(type, generic));
+    for (auto type1 : types) {
+      CHECK_EQ(issubdtype(type, type1), type == type1);
+    }
+  }
+
+  for (const auto& cat : cats) {
+    CHECK(issubdtype(cat, cat));
+    switch (cat) {
+      case Dtype::Category::complexfloating:
+        CHECK(issubdtype(cat, complexfloating));
+        CHECK_FALSE(issubdtype(cat, floating));
+        CHECK(issubdtype(cat, inexact));
+        CHECK_FALSE(issubdtype(cat, signedinteger));
+        CHECK_FALSE(issubdtype(cat, unsignedinteger));
+        CHECK_FALSE(issubdtype(cat, integer));
+        CHECK(issubdtype(cat, number));
+        CHECK(issubdtype(cat, generic));
+        break;
+      case Dtype::Category::floating:
+        CHECK_FALSE(issubdtype(cat, complexfloating));
+        CHECK(issubdtype(cat, floating));
+        CHECK(issubdtype(cat, inexact));
+        CHECK_FALSE(issubdtype(cat, signedinteger));
+        CHECK_FALSE(issubdtype(cat, unsignedinteger));
+        CHECK_FALSE(issubdtype(cat, integer));
+        CHECK(issubdtype(cat, number));
+        CHECK(issubdtype(cat, generic));
+        break;
+      case Dtype::Category::inexact:
+        CHECK_FALSE(issubdtype(cat, complexfloating));
+        CHECK_FALSE(issubdtype(cat, floating));
+        CHECK(issubdtype(cat, inexact));
+        CHECK_FALSE(issubdtype(cat, signedinteger));
+        CHECK_FALSE(issubdtype(cat, unsignedinteger));
+        CHECK_FALSE(issubdtype(cat, integer));
+        CHECK(issubdtype(cat, number));
+        CHECK(issubdtype(cat, generic));
+        break;
+      case Dtype::Category::signedinteger:
+        CHECK_FALSE(issubdtype(cat, complexfloating));
+        CHECK_FALSE(issubdtype(cat, floating));
+        CHECK_FALSE(issubdtype(cat, inexact));
+        CHECK(issubdtype(cat, signedinteger));
+        CHECK_FALSE(issubdtype(cat, unsignedinteger));
+        CHECK(issubdtype(cat, integer));
+        CHECK(issubdtype(cat, number));
+        CHECK(issubdtype(cat, generic));
+        break;
+      case Dtype::Category::unsignedinteger:
+        CHECK_FALSE(issubdtype(cat, complexfloating));
+        CHECK_FALSE(issubdtype(cat, floating));
+        CHECK_FALSE(issubdtype(cat, inexact));
+        CHECK_FALSE(issubdtype(cat, signedinteger));
+        CHECK(issubdtype(cat, unsignedinteger));
+        CHECK(issubdtype(cat, integer));
+        CHECK(issubdtype(cat, number));
+        CHECK(issubdtype(cat, generic));
+        break;
+      case Dtype::Category::integer:
+        CHECK_FALSE(issubdtype(cat, complexfloating));
+        CHECK_FALSE(issubdtype(cat, floating));
+        CHECK_FALSE(issubdtype(cat, inexact));
+        CHECK_FALSE(issubdtype(cat, signedinteger));
+        CHECK_FALSE(issubdtype(cat, unsignedinteger));
+        CHECK(issubdtype(cat, integer));
+        CHECK(issubdtype(cat, number));
+        CHECK(issubdtype(cat, generic));
+        break;
+      case Dtype::Category::number:
+        CHECK_FALSE(issubdtype(cat, complexfloating));
+        CHECK_FALSE(issubdtype(cat, floating));
+        CHECK_FALSE(issubdtype(cat, inexact));
+        CHECK_FALSE(issubdtype(cat, signedinteger));
+        CHECK_FALSE(issubdtype(cat, unsignedinteger));
+        CHECK_FALSE(issubdtype(cat, integer));
+        CHECK(issubdtype(cat, number));
+        CHECK(issubdtype(cat, generic));
+        break;
+      case Dtype::Category::generic:
+        CHECK_FALSE(issubdtype(cat, complexfloating));
+        CHECK_FALSE(issubdtype(cat, floating));
+        CHECK_FALSE(issubdtype(cat, inexact));
+        CHECK_FALSE(issubdtype(cat, signedinteger));
+        CHECK_FALSE(issubdtype(cat, unsignedinteger));
+        CHECK_FALSE(issubdtype(cat, integer));
+        CHECK_FALSE(issubdtype(cat, number));
+        CHECK(issubdtype(cat, generic));
+        break;
+    }
+  }
+}
+
+TEST_CASE("test atleast_1d") {
+  auto x = array(1);
+  auto out = atleast_1d(x);
+  CHECK_EQ(out.ndim(), 1);
+  CHECK_EQ(out.shape(), Shape{1});
+
+  x = array({1, 2, 3}, {3});
+  out = atleast_1d(x);
+  CHECK_EQ(out.ndim(), 1);
+  CHECK_EQ(out.shape(), Shape{3});
+
+  x = array({1, 2, 3}, {3, 1});
+  out = atleast_1d(x);
+  CHECK_EQ(out.ndim(), 2);
+  CHECK_EQ(out.shape(), Shape{3, 1});
+}
+
+TEST_CASE("test atleast_1d vector") {
+  auto x = std::vector<array>{
+      array(1), array({1, 2, 3}, {3}), array({1, 2, 3}, {3, 1})};
+  auto out = atleast_1d(x);
+  CHECK_EQ(out.size(), 3);
+  CHECK_EQ(out[0].ndim(), 1);
+  CHECK_EQ(out[0].shape(), Shape{1});
+  CHECK_EQ(out[1].ndim(), 1);
+  CHECK_EQ(out[1].shape(), Shape{3});
+  CHECK_EQ(out[2].ndim(), 2);
+  CHECK_EQ(out[2].shape(), Shape{3, 1});
+}
+
+TEST_CASE("test atleast_2d") {
+  auto x = array(1);
+  auto out = atleast_2d(x);
+  CHECK_EQ(out.ndim(), 2);
+  CHECK_EQ(out.shape(), Shape{1, 1});
+
+  x = array({1, 2, 3}, {3});
+  out = atleast_2d(x);
+  CHECK_EQ(out.ndim(), 2);
+  CHECK_EQ(out.shape(), Shape{1, 3});
+
+  x = array({1, 2, 3}, {3, 1});
+  out = atleast_2d(x);
+  CHECK_EQ(out.ndim(), 2);
+  CHECK_EQ(out.shape(), Shape{3, 1});
+}
+
+TEST_CASE("test atleast_2d vector") {
+  auto x = std::vector<array>{
+      array(1), array({1, 2, 3}, {3}), array({1, 2, 3}, {3, 1})};
+  auto out = atleast_2d(x);
+  CHECK_EQ(out.size(), 3);
+  CHECK_EQ(out[0].ndim(), 2);
+  CHECK_EQ(out[0].shape(), Shape{1, 1});
+  CHECK_EQ(out[1].ndim(), 2);
+  CHECK_EQ(out[1].shape(), Shape{1, 3});
+  CHECK_EQ(out[2].ndim(), 2);
+  CHECK_EQ(out[2].shape(), Shape{3, 1});
+}
+
+TEST_CASE("test atleast_3d") {
+  auto x = array(1);
+  auto out = atleast_3d(x);
+  CHECK_EQ(out.ndim(), 3);
+  CHECK_EQ(out.shape(), Shape{1, 1, 1});
+
+  x = array({1, 2, 3}, {3});
+  out = atleast_3d(x);
+  CHECK_EQ(out.ndim(), 3);
+  CHECK_EQ(out.shape(), Shape{1, 3, 1});
+
+  x = array({1, 2, 3}, {3, 1});
+  out = atleast_3d(x);
+  CHECK_EQ(out.ndim(), 3);
+  CHECK_EQ(out.shape(), Shape{3, 1, 1});
+}
+
+TEST_CASE("test atleast_3d vector") {
+  auto x = std::vector<array>{
+      array(1), array({1, 2, 3}, {3}), array({1, 2, 3}, {3, 1})};
+  auto out = atleast_3d(x);
+  CHECK_EQ(out.size(), 3);
+  CHECK_EQ(out[0].ndim(), 3);
+  CHECK_EQ(out[0].shape(), Shape{1, 1, 1});
+  CHECK_EQ(out[1].ndim(), 3);
+  CHECK_EQ(out[1].shape(), Shape{1, 3, 1});
+  CHECK_EQ(out[2].ndim(), 3);
+  CHECK_EQ(out[2].shape(), Shape{3, 1, 1});
+}
+
+TEST_CASE("test topk") {
+  auto x = reshape(arange(10), {2, 5});
+
+  {
+    auto y = topk(x, 1, 1);
+    CHECK(array_equal(y, array({4, 9}, {2, 1})).item<bool>());
+  }
+
+  {
+    auto y = topk(x, 2, 0);
+    CHECK(array_equal(y, x).item<bool>());
+  }
+
+  {
+    auto y = topk(x, 1, 0);
+    CHECK(array_equal(y, array({5, 6, 7, 8, 9}, {1, 5})).item<bool>());
+  }
+}
+
+TEST_CASE("test meshgrid") {
+  // Test default
+  auto x = array({1, 2, 3}, {3});
+  auto in = std::vector<array>{x};
+  auto out = meshgrid(in);
+  CHECK(array_equal(out[0], x).item<bool>());
+
+  // Test different lengths
+  auto y = array({4, 5}, {2});
+  in = std::vector<array>{x, y};
+  out = meshgrid(in);
+  auto expected_zero = array({1, 2, 3, 1, 2, 3}, {2, 3});
+  auto expected_one = array({4, 4, 4, 5, 5, 5}, {2, 3});
+  CHECK(array_equal(out[0], expected_zero).item<bool>());
+  CHECK(array_equal(out[1], expected_one).item<bool>());
+
+  // Test sparse true
+  in = std::vector<array>{x, x};
+  out = meshgrid(in, true);
+  expected_zero = array({1, 2, 3}, {1, 3});
+  expected_one = array({1, 2, 3}, {3, 1});
+  CHECK(array_equal(out[0], expected_zero).item<bool>());
+  CHECK(array_equal(out[1], expected_one).item<bool>());
+}
+
+TEST_CASE("test conv1d") {
+  auto in = astype(
+      array(
+          {0.5488135,
+           0.71518937,
+           0.60276338,
+           0.54488318,
+           0.4236548,
+           0.64589411},
+          {1, 3, 2}),
+      float16);
+
+  int kernel = 3;
+  int stride = 1;
+  int padding = 1;
+
+  {
+    int groups = 1;
+    auto wt = astype(
+        array(
+            {
+
+                0.43758721, 0.891773,   0.96366276, 0.38344152,
+                0.79172504, 0.52889492,
+
+                0.56804456, 0.92559664, 0.07103606, 0.0871293,
+                0.0202184,  0.83261985,
+
+                0.77815675, 0.87001215, 0.97861834, 0.79915856,
+                0.46147936, 0.78052918,
+
+                0.11827443, 0.63992102, 0.14335329, 0.94466892,
+                0.52184832, 0.41466194
+
+            },
+            {4, 3, 2}),
+        float16);
+
+    auto expected = array(
+        {1.56836,
+         0.567383,
+         1.8125,
+         1.29492,
+         2.34375,
+         1.61035,
+         2.77539,
+         1.61328,
+         1.40527,
+         0.933105,
+         1.87402,
+         1.09082},
+        {1, 3, 4});
+
+    auto out = conv1d(in, wt, stride, padding, /* dilation= */ 1, groups);
+    CHECK(allclose(out, expected).item<bool>());
+  }
+
+  {
+    int groups = 2;
+    auto wt = array(
+        {0.43758721,
+         0.891773,
+         0.96366276,
+
+         0.38344152,
+         0.79172504,
+         0.52889492,
+
+         0.56804456,
+         0.92559664,
+         0.07103606,
+
+         0.0871293,
+         0.0202184,
+         0.83261985
+
+        },
+        {4, 3, 1});
+
+    auto expected = array(
+        {1.07007,
+         0.753201,
+         0.700818,
+         0.468176,
+         1.18568,
+         0.91152,
+         0.956607,
+         0.611213,
+         0.641404,
+         0.566401,
+         0.907472,
+         0.0605397},
+        {1, 3, 4});
+
+    auto out = conv1d(in, wt, stride, padding, /* dilation= */ 1, groups);
+    CHECK(allclose(out, expected).item<bool>());
+  }
+}
+
+TEST_CASE("test conv2d") {
+  auto in = array(
+      {0.57429284,
+       -0.21628855,
+       -0.18673691,
+       -0.3793517,
+
+       0.3059678,
+       -0.8137168,
+       0.6168841,
+       -0.26912728},
+      {1, 2, 2, 2});
+
+  std::pair<int, int> kernel{2, 2};
+  std::pair<int, int> stride{1, 1};
+  std::pair<int, int> padding{0, 0};
+
+  {
+    int groups = 1;
+
+    auto wt = array(
+        {0.3190391,   -0.24937038, 1.4621079,   -2.0601406,  -0.3224172,
+         -0.38405436, 1.1337694,   -1.0998913,  -0.1724282,  -0.8778584,
+         0.04221375,  0.58281523,  -1.1006192,  1.1447237,   0.9015907,
+         0.50249434,  0.90085596,  -0.68372786, -0.12289023, -0.93576944,
+         -0.26788807, 0.53035545,  -0.69166076, -0.39675352, -0.6871727,
+         -0.84520566, -0.6712461,  -0.0126646,  -1.1173104,  0.2344157,
+         1.6598022,   0.74204415},
+        {4, 2, 2, 2});
+
+    auto expected =
+        array({1.9549234, -0.98542136, 0.2097499, 0.20991313}, {1, 1, 1, 4});
+    auto out = conv2d(in, wt, stride, padding, /* dilation= */ {1, 1}, groups);
+    CHECK(allclose(out, expected).item<bool>());
+  }
+
+  {
+    int groups = 2;
+    auto wt = array(
+        {0.3190391,
+         -0.24937038,
+
+         1.46210794,
+         -2.06014071,
+
+         -0.3224172,
+         -0.38405435,
+
+         1.13376944,
+         -1.09989127,
+
+         -0.17242821,
+         -0.87785842,
+
+         0.04221375,
+         0.58281521,
+
+         -1.10061918,
+         1.14472371,
+
+         0.90159072,
+         0.50249434},
+        {4, 2, 2, 1});
+
+    auto expected = array(
+        {-0.59372161, -0.44505326, 0.17910982, -1.06507601}, {1, 1, 1, 4});
+
+    auto out = conv2d(in, wt, stride, padding, /* dilation= */ {1, 1}, groups);
+    CHECK(allclose(out, expected).item<bool>());
+  }
+
+  {
+    in = array(
+        {0.57429284,
+         -0.21628855,
+         -0.18673691,
+         -0.3793517,
+
+         0.3059678,
+         -0.8137168,
+         0.6168841,
+         -0.26912728,
+
+         0.57429284,
+         -0.21628855,
+         -0.18673691,
+         -0.3793517,
+
+         0.3059678,
+         -0.8137168,
+         0.6168841,
+         -0.26912728},
+        {2, 2, 2, 2});
+
+    int groups = 2;
+    auto wt = array(
+        {0.3190391,
+         -0.24937038,
+
+         1.46210794,
+         -2.06014071,
+
+         -0.3224172,
+         -0.38405435,
+
+         1.13376944,
+         -1.09989127,
+
+         -0.17242821,
+         -0.87785842,
+
+         0.04221375,
+         0.58281521,
+
+         -1.10061918,
+         1.14472371,
+
+         0.90159072,
+         0.50249434},
+        {4, 2, 2, 1});
+
+    auto expected = array(
+        {-0.59372161, -0.44505326, 0.17910982, -1.06507601}, {1, 1, 1, 4});
+
+    auto out = conv2d(in, wt, stride, padding, /* dilation= */ {1, 1}, groups);
+    CHECK(allclose(out, expected).item<bool>());
+  }
+}
+
+TEST_CASE("test trace") {
+  auto in = eye(3);
+  auto out = trace(in).item<float>();
+  CHECK_EQ(out, 3.0);
+
+  in = array({1, 2, 3, 4, 5, 6, 7, 8, 9}, {3, 3}, int32);
+  auto out2 = trace(in).item<int>();
+  CHECK_EQ(out2, 15);
+
+  in = reshape(arange(8), {2, 2, 2});
+  auto out3 = trace(in, 0, 0, 1);
+  CHECK(array_equal(out3, array({6, 8}, {2})).item<bool>());
+
+  auto out4 = trace(in, 0, 1, 2, float32);
+  CHECK(array_equal(out4, array({3, 11}, {2})).item<bool>());
+}
+
+TEST_CASE("test view") {
+  auto in = array(3);
+  CHECK_THROWS(view(in, int64));
+
+  in = array({1, 2, 3});
+  CHECK_THROWS(view(in, int64));
+
+  in = array({1, 2, 3, 4}, int64);
+  auto out = view(in, int32);
+  CHECK(array_equal(out, array({1, 0, 2, 0, 3, 0, 4, 0})).item<bool>());
+}
+
+TEST_CASE("test roll") {
+  auto x = reshape(arange(10), {2, 5});
+
+  auto y = roll(x, 2);
+  CHECK(array_equal(y, array({8, 9, 0, 1, 2, 3, 4, 5, 6, 7}, {2, 5}))
+            .item<bool>());
+
+  y = roll(x, -2);
+  CHECK(array_equal(y, array({2, 3, 4, 5, 6, 7, 8, 9, 0, 1}, {2, 5}))
+            .item<bool>());
+
+  y = roll(x, 2, 1);
+  CHECK(array_equal(y, array({3, 4, 0, 1, 2, 8, 9, 5, 6, 7}, {2, 5}))
+            .item<bool>());
+
+  y = roll(x, -2, 1);
+  CHECK(array_equal(y, array({2, 3, 4, 0, 1, 7, 8, 9, 5, 6}, {2, 5}))
+            .item<bool>());
+
+  y = roll(x, 2, {0, 0, 0});
+  CHECK(array_equal(y, array({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, {2, 5}))
+            .item<bool>());
+
+  y = roll(x, 1, {1, 1, 1});
+  CHECK(array_equal(y, array({2, 3, 4, 0, 1, 7, 8, 9, 5, 6}, {2, 5}))
+            .item<bool>());
+
+  y = roll(x, {1, 2}, {0, 1});
+  CHECK(array_equal(y, array({8, 9, 5, 6, 7, 3, 4, 0, 1, 2}, {2, 5}))
+            .item<bool>());
+
+  y = roll(array({}), 0, 0);
+  CHECK(array_equal(y, array({})).item<bool>());
+}
+
+TEST_CASE("test contiguous") {
+  auto x = array({1, 2, 3});
+  x = contiguous(broadcast_to(x, {2, 2, 3}));
+  eval(x);
+  CHECK(x.flags().row_contiguous);
+  CHECK_EQ(x.strides(), decltype(x.strides()){6, 3, 1});
+
+  x = array({1, 2, 1, 2}, {2, 2});
+  x = contiguous(transpose(x), true);
+  eval(x);
+  CHECK(x.flags().col_contiguous);
+  CHECK_EQ(x.strides(), decltype(x.strides()){1, 2});
+}
+
+TEST_CASE("test bitwise shift operations") {
+  std::vector<Dtype> dtypes = {
+      int8, int16, int32, int64, uint8, uint16, uint32, uint64};
+
+  for (const auto& dtype : dtypes) {
+    array x = full({4}, 1, dtype);
+    array y = full({4}, 2, dtype);
+
+    auto left_shift_result = left_shift(x, y);
+    CHECK_EQ(left_shift_result.dtype(), dtype);
+    CHECK(array_equal(left_shift_result, array({4, 4, 4, 4}, dtype))
+              .item<bool>());
+
+    auto right_shift_result = right_shift(full({4}, 4, dtype), y);
+    CHECK_EQ(right_shift_result.dtype(), dtype);
+    CHECK(array_equal(right_shift_result, full({4}, 1, dtype)).item<bool>());
+  }
+
+  array x = array({127, -128}, int8);
+  array y = array({1, 1}, int8);
+  auto left_shift_result = left_shift(x, y);
+  auto right_shift_result = right_shift(x, y);
+
+  CHECK(array_equal(left_shift_result, array({-2, 0}, int8)).item<bool>());
+  CHECK(array_equal(right_shift_result, array({63, -64}, int8)).item<bool>());
+
+  array x_bool = full({4}, true, bool_);
+  array y_bool = full({4}, true, bool_);
+  auto left_shift_bool_result = left_shift(x_bool, y_bool);
+  auto right_shift_bool_result = right_shift(x_bool, y_bool);
+
+  CHECK_EQ(left_shift_bool_result.dtype(), uint8);
+  CHECK(array_equal(left_shift_bool_result, full({4}, 2, uint8)).item<bool>());
+
+  CHECK_EQ(right_shift_bool_result.dtype(), uint8);
+  CHECK(array_equal(right_shift_bool_result, full({4}, 0, uint8)).item<bool>());
+}
+
+TEST_CASE("test conv_transpose1d with output_padding") {
+  auto in = array({1.0, 2.0, 3.0}, {1, 1, 3});
+  auto wt = array({1.0, 1.0, 1.0}, {1, 1, 3});
+  int stride = 2;
+  int padding = 0;
+  int dilation = 1;
+  int output_padding = 1;
+  int groups = 1;
+
+  auto out = conv_transpose1d(
+      in, wt, stride, padding, dilation, output_padding, groups);
+  auto expected = array({6.0, 0.0}, {1, 2, 1});
+  CHECK(array_equal(out, expected).item<bool>());
+}
+
+TEST_CASE("test conv_transpose2d with output_padding") {
+  auto in = array({1.0, 2.0, 3.0, 4.0}, {1, 1, 2, 2});
+  auto wt = array({1.0, 1.0, 1.0, 1.0}, {2, 1, 1, 2});
+  std::pair<int, int> stride{2, 2};
+  std::pair<int, int> padding{0, 0};
+  std::pair<int, int> output_padding{1, 1};
+  std::pair<int, int> dilation{1, 1};
+  int groups = 1;
+
+  auto out = conv_transpose2d(
+      in, wt, stride, padding, dilation, output_padding, groups);
+  auto expected = array(
+      {3.0,
+       3.0,
+       0.0,
+       0.0,
+       7.0,
+       7.0,
+       0.0,
+       0.0,
+       0.0,
+       0.0,
+       0.0,
+       0.0,
+       0.0,
+       0.0,
+       0.0,
+       0.0},
+      {1, 2, 4, 2});
+  CHECK(array_equal(out, expected).item<bool>());
+}
+
+TEST_CASE("test conv_transpose3d with output_padding") {
+  auto in = array({1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0}, {1, 1, 2, 2, 2});
+  auto wt = array({1.0, 1.0}, {1, 1, 1, 1, 2});
+  std::tuple<int, int, int> stride{2, 2, 2};
+  std::tuple<int, int, int> padding{0, 0, 0};
+  std::tuple<int, int, int> output_padding{1, 1, 1};
+  std::tuple<int, int, int> dilation{1, 1, 1};
+  int groups = 1;
+
+  auto out = conv_transpose3d(
+      in, wt, stride, padding, dilation, output_padding, groups);
+  auto expected = array(
+      {3.0, 0.0, 7.0, 0.0, 0.0, 0.0, 0.0, 0.0, 11.0, 0.0, 15.0,
+       0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,  0.0, 0.0,
+       0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,  0.0},
+      {1, 2, 4, 4, 1});
+  CHECK(array_equal(out, expected).item<bool>());
+}
diff --git a/ml-stable-diffusion/mlx/tests/random_tests.cpp b/ml-stable-diffusion/mlx/tests/random_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6ddd37104554d0071b51a9586f4692218bb0d484
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/random_tests.cpp
@@ -0,0 +1,716 @@
+// Copyright © 2023 Apple Inc.
+
+#include <numeric>
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test random key") {
+  auto key = random::key(0);
+  CHECK(array_equal(key, array({0, 0})).item<bool>());
+
+  key = random::key(1);
+  CHECK(array_equal(key, array({0, 1})).item<bool>());
+
+  int64_t seed = static_cast<int64_t>(1) << 32;
+  key = random::key(seed);
+  CHECK(array_equal(key, array({1, 0})).item<bool>());
+
+  key = random::key(seed + 1);
+  CHECK(array_equal(key, array({1, 1})).item<bool>());
+}
+
+TEST_CASE("test global rng") {
+  random::seed(4);
+  auto x = random::bits({});
+  auto y = random::bits({});
+
+  random::seed(4);
+  auto a = random::bits({});
+  auto b = random::bits({});
+
+  CHECK_EQ(x.item<uint32_t>(), a.item<uint32_t>());
+  CHECK_EQ(y.item<uint32_t>(), b.item<uint32_t>());
+}
+
+TEST_CASE("test random split") {
+  auto [key, subkey] = random::split(random::key(0));
+  CHECK(array_equal(key, array({4146024105u, 967050713u})).item<bool>());
+  CHECK(array_equal(subkey, array({2718843009u, 1272950319u})).item<bool>());
+
+  auto keys = random::split(random::key(0), 3);
+  auto expected = array(
+      {2467461003u,
+       428148500u,
+       3186719485u,
+       3840466878u,
+       2562233961u,
+       1946702221u},
+      {3, 2});
+  CHECK(array_equal(keys, expected).item<bool>());
+}
+
+TEST_CASE("test random bits") {
+  // Test shapes, types, and sizes
+  {
+    auto key = random::key(0);
+    auto x = random::bits({}, key);
+    CHECK_EQ(x.size(), 1);
+    CHECK_EQ(x.dtype(), uint32);
+
+    x = random::bits({0}, key);
+    CHECK(array_equal(x, array({})).item<bool>());
+
+    // Check wrong key type or shape
+    key = array({0, 0});
+    CHECK_THROWS_AS(random::uniform({}, key), std::invalid_argument);
+    key = array({0, 0}, {1, 2});
+    CHECK_THROWS_AS(random::uniform({}, key), std::invalid_argument);
+    key = array({0u, 0u, 0u}, {3, 1});
+    CHECK_THROWS_AS(random::uniform({}, key), std::invalid_argument);
+    key = array({0u, 0u}, {2, 1});
+    CHECK_THROWS_AS(random::uniform({}, key), std::invalid_argument);
+  }
+
+  // Expected bits in the following tests were generated from
+  // Jax's Threefry 2x32 implementation using the following in
+  // python:
+  //
+  // ```
+  //   import jax
+  //   import jax.prng
+  //   shape = (SET THIS)
+  //   seed = (SET THIS)
+  //   width = (SET THIS)
+  //   key = jax.random.PRNGKey(seed)
+  //   print(jax.prng.threefry_prng_impl.random_bits(key, width, shape))
+
+  {
+    auto key = random::key(0);
+    auto x = random::bits({}, key);
+    auto y = random::bits({}, key);
+    CHECK_EQ(x.item<uint32_t>(), 1797259609u);
+    CHECK_EQ(x.item<uint32_t>(), y.item<uint32_t>());
+
+    x = random::bits({}, 2, key);
+    CHECK_EQ(x.item<uint16_t>(), 345);
+
+    x = random::bits({}, 1, key);
+    CHECK_EQ(x.item<uint8_t>(), 89);
+  }
+
+  {
+    auto key = random::key(1);
+    auto x = random::bits({}, key);
+    CHECK_EQ(x.item<uint32_t>(), 507451445u);
+
+    x = random::bits({}, 2, key);
+    CHECK_EQ(x.item<uint16_t>(), 6197);
+
+    x = random::bits({}, 1, key);
+    CHECK_EQ(x.item<uint8_t>(), 53);
+
+    CHECK_THROWS(random::bits({}, 0, key));
+    CHECK_THROWS(random::bits({}, 5, key));
+    CHECK_THROWS(random::bits({}, -1, key));
+  }
+
+  {
+    auto key = random::key(0);
+    auto x = random::bits({3, 1}, key);
+    auto expected = array({4146024105u, 1351547692u, 2718843009u}, {3, 1});
+    CHECK(array_equal(x, expected).item<bool>());
+
+    x = random::bits({5}, 2, key);
+    expected = array({20137, 63263, 64300, 20622, 16513}, uint16);
+    CHECK(array_equal(x, expected).item<bool>());
+    expected = array({20137, 63263, 64300, 20622, 16513, 41486}, uint16);
+    x = random::bits({6}, 2, key);
+    CHECK(array_equal(x, expected).item<bool>());
+    expected = array({20137, 63263, 1497, 14756, 16513, 41486, 44591}, uint16);
+    x = random::bits({7}, 2, key);
+    CHECK(array_equal(x, expected).item<bool>());
+    x = random::bits({8}, 2, key);
+    expected =
+        array({20137, 63263, 1497, 14756, 16513, 41486, 44591, 19423}, uint16);
+    CHECK(array_equal(x, expected).item<bool>());
+  }
+
+  {
+    auto key = array({0u, 0u, 1u, 1u}, {2, 2});
+    auto shape = Shape{3};
+    auto fn = [&shape](array k) { return random::bits(shape, k); };
+
+    auto expected = array(
+        {4146024105u,
+         1351547692u,
+         2718843009u,
+         3725146706u,
+         1802982961u,
+         1349634643u},
+        {2, 3});
+    CHECK(array_equal(vmap(fn)(key), expected).item<bool>());
+    expected = array(
+        {2441914641u,
+         1110694964u,
+         3819641963u,
+         2441914641u,
+         1110694964u,
+         3819641963u},
+        {2, 3});
+    CHECK(array_equal(vmap(fn, 1)(key), expected).item<bool>());
+
+    // Vmap twice
+    key = array(
+        {0u,
+         0u,
+         1u,
+         1u,
+         2u,
+         2u,
+
+         3u,
+         3u,
+         4u,
+         4u,
+         5u,
+         5u},
+        {3, 2, 2});
+    shape = {2};
+    auto out = vmap(vmap(fn))(key);
+    expected = array(
+        {928981903u,
+         3453687069u,
+         3606183818u,
+         460005496u,
+
+         2799733733u,
+         856293553u,
+         4081856343u,
+         3445925136u,
+
+         2775548010u,
+         1430281703u,
+         305173070u,
+         2615843348u},
+        {3, 2, 2});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    out = vmap(vmap(fn, 1), 0)(key);
+    expected = array(
+        {1948878966u,
+         4237131848u,
+         1948878966u,
+         4237131848u,
+
+         2531170506u,
+         1858648356u,
+         2531170506u,
+         1858648356u,
+
+         740561898u,
+         4234094099u,
+         740561898u,
+         4234094099u},
+        {3, 2, 2});
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+
+  // Vmap smaller type
+  {
+    auto key = array({0u, 0u, 1u, 1u}, {2, 2});
+    auto fn = [](array k) { return random::bits({5}, 2, k); };
+
+    auto expected = array(
+        {4146024105u,
+         1351547692u,
+         2718843009u,
+         3725146706u,
+         1802982961u,
+         1349634643u},
+        {2, 3});
+    auto out = vmap(fn)(key);
+    auto x1 = random::bits({5}, 2, take(key, array(0), 0));
+    auto x2 = random::bits({5}, 2, take(key, array(1), 0));
+
+    CHECK(array_equal(take(out, array(0), 0), x1).item<bool>());
+    CHECK(array_equal(take(out, array(1), 0), x2).item<bool>());
+  }
+}
+
+TEST_CASE("test random uniform") {
+  // Test shapes, types, and sizes
+  {
+    auto x = random::uniform({});
+    CHECK_EQ(x.size(), 1);
+    CHECK_EQ(x.dtype(), float32);
+
+    x = random::uniform({}, float16);
+    CHECK_EQ(x.size(), 1);
+    CHECK_EQ(x.dtype(), float16);
+
+    x = random::uniform({0});
+    CHECK(array_equal(x, array({})).item<bool>());
+
+    // Non float type throws
+    CHECK_THROWS_AS(random::uniform({}, int32), std::invalid_argument);
+
+    // dtype respected
+    x = random::uniform(-.1, .1, {0}, bfloat16);
+    CHECK_EQ(x.dtype(), bfloat16);
+
+    // Check broadcasting
+    x = random::uniform(zeros({3, 1}), ones({1, 3}), {3, 3});
+    CHECK_EQ(x.shape(), Shape{3, 3});
+    CHECK_THROWS_AS(
+        random::uniform(zeros({3, 3}), 1.0, {1, 3}), std::invalid_argument);
+    CHECK_THROWS_AS(
+        random::uniform(zeros({3, 3}), 1.0, {2, 3}), std::invalid_argument);
+    CHECK_THROWS_AS(
+        random::uniform(zeros({3, 1}), ones({1, 3}), {1, 3}),
+        std::invalid_argument);
+
+    // Check wrong key type or shape
+    auto key = array({0, 0});
+    CHECK_THROWS_AS(random::uniform({}, key), std::invalid_argument);
+    key = array({0, 0}, {1, 2});
+    CHECK_THROWS_AS(random::uniform({}, key), std::invalid_argument);
+    key = array({0u, 0u, 0u}, {3, 1});
+    CHECK_THROWS_AS(random::uniform({}, key), std::invalid_argument);
+    key = array({0u, 0u}, {2, 1});
+    CHECK_THROWS_AS(random::uniform({}, key), std::invalid_argument);
+  }
+
+  // Expected bits in the following tests were generated from
+  // Jax's Threefry 2x32 implementation using the following in
+  // python:
+  //
+  // ```
+  //   import jax
+  //   import jax.prng
+  //   shape = (SET THIS)
+  //   seed = (SET THIS)
+  //   key = jax.random.PRNGKey(seed)
+  //   print(jax.prng.threefry_prng_impl.random_bits(key, 32, shape))
+
+  constexpr auto to_float = [](uint32_t n) {
+    return static_cast<float>(n) / UINT32_MAX;
+  };
+
+  {
+    auto key = random::key(0);
+    auto x = random::uniform({}, key);
+    auto y = random::uniform({}, key);
+    auto expected = to_float(1797259609);
+    CHECK_EQ(x.item<float>(), expected);
+    CHECK_EQ(x.item<float>(), y.item<float>());
+  }
+
+  {
+    auto key = random::key(1);
+    auto x = random::uniform({}, key);
+    auto expected = to_float(507451445);
+    CHECK_EQ(x.item<float>(), expected);
+  }
+
+  {
+    auto key = random::key(0);
+    auto x = random::uniform({3, 1}, key);
+    auto expected = array(
+        {to_float(4146024105), to_float(1351547692), to_float(2718843009)},
+        {3, 1});
+    CHECK(array_equal(x, expected).item<bool>());
+  }
+
+  // Check vmap
+  {
+    auto key = random::key(0);
+    auto fun = [](array k, array low) {
+      return random::uniform(low, 1, {3}, float32, k);
+    };
+    auto out = vmap(fun, -1)(key, zeros({2, 3}));
+    CHECK_EQ(out.shape(), Shape{2, 3});
+
+    key = zeros({2, 2}, uint32);
+    out = vmap(fun)(key, zeros({2, 3}));
+    CHECK_EQ(out.shape(), Shape{2, 3});
+  }
+
+  // Check bounds are respected
+  {
+    auto key = random::key(128291);
+    auto out = random::uniform(array(-1.0f), array(1.0f), {100}, float32, key);
+    CHECK(all(less(out, array(1.0f))).item<bool>());
+    CHECK(all(greater_equal(out, array(-1.0f))).item<bool>());
+  }
+
+  // Check float16
+  {
+    auto key = random::key(0);
+    auto out = random::uniform({1000}, float16, key);
+    CHECK_EQ(out.dtype(), float16);
+    CHECK(all(less(out, array(1.0f))).item<bool>());
+    CHECK(all(greater_equal(out, array(0.0f))).item<bool>());
+    CHECK(!all(equal(out, array(0.0f))).item<bool>());
+    CHECK(abs(float(mean(out).item<float16_t>()) - 0.5f) < 0.02);
+  }
+
+  {
+    auto key = random::key(0);
+    auto out = random::uniform({1000}, bfloat16, key);
+    CHECK_EQ(out.dtype(), bfloat16);
+    CHECK(all(less(out, array(1.0f))).item<bool>());
+    CHECK(all(greater_equal(out, array(0.0f))).item<bool>());
+    CHECK(!all(equal(out, array(0.0f))).item<bool>());
+    CHECK(abs(float(mean(out).item<bfloat16_t>()) - 0.5f) < 0.02);
+  }
+}
+
+TEST_CASE("test random normal") {
+  // Test shapes, types, and sizes
+  {
+    auto x = random::normal({});
+    CHECK_EQ(x.size(), 1);
+    CHECK_EQ(x.dtype(), float32);
+
+    x = random::uniform({0});
+    CHECK(array_equal(x, array({})).item<bool>());
+
+    // Non float type throws
+    CHECK_THROWS_AS(random::normal({}, int32), std::invalid_argument);
+
+    // Check wrong key type or shape
+    auto key = array({0, 0});
+    CHECK_THROWS_AS(random::normal({}, key), std::invalid_argument);
+    key = array({0, 0}, {1, 2});
+    CHECK_THROWS_AS(random::normal({}, key), std::invalid_argument);
+    key = array({0u, 0u, 0u}, {3, 1});
+    CHECK_THROWS_AS(random::normal({}, key), std::invalid_argument);
+    key = array({0u, 0u}, {2, 1});
+    CHECK_THROWS_AS(random::normal({}, key), std::invalid_argument);
+  }
+
+  {
+    constexpr float inf = std::numeric_limits<float>::infinity();
+    auto key = random::key(128291);
+    auto out = random::normal({100}, key);
+    CHECK(all(less(abs(out), array(inf))).item<bool>());
+    CHECK(abs(mean(out).item<float>()) < 0.1);
+  }
+
+  {
+    constexpr float inf = std::numeric_limits<float>::infinity();
+    auto key = random::key(128291);
+    auto out = random::normal({200}, float16, key);
+    CHECK_EQ(out.dtype(), float16);
+    CHECK(all(less(abs(out), array(inf))).item<bool>());
+    CHECK(abs(float(mean(out).item<float16_t>())) < 0.1);
+  }
+
+  {
+    constexpr float inf = std::numeric_limits<float>::infinity();
+    auto key = random::key(128291);
+    auto out = random::normal({200}, bfloat16, key);
+    CHECK_EQ(out.dtype(), bfloat16);
+    CHECK(all(less(abs(out), array(inf))).item<bool>());
+    CHECK(abs(float(mean(out).item<bfloat16_t>())) < 0.1);
+  }
+}
+
+TEST_CASE("test random multivariate_normal") {
+  // Scope switch to the cpu for SVDs
+  StreamContext sc(Device::cpu);
+
+  {
+    auto mean = zeros({3});
+    auto cov = eye(3);
+    auto x = random::multivariate_normal(mean, cov, {1000}, float32);
+    CHECK_EQ(x.shape(), Shape{1000, 3});
+    CHECK_EQ(x.dtype(), float32);
+  }
+
+  // Limit case
+  {
+    auto mean = array({0, 0});
+    auto cov = array({1., -1, -.1, 1.});
+    cov = reshape(cov, {2, 2});
+    auto x = random::multivariate_normal(mean, cov, {1}, float32);
+    CHECK_EQ(x.shape(), Shape{1, 2});
+    CHECK_EQ(x.dtype(), float32);
+  }
+
+  // Check wrong shapes
+  {
+    auto mean = zeros({3, 1});
+    auto cov = eye(3);
+    CHECK_THROWS_AS(
+        random::multivariate_normal(
+            mean,
+            cov,
+            {
+                1000,
+            },
+            float32),
+        std::invalid_argument);
+  }
+  {
+    auto mean = zeros({3});
+    auto cov = zeros({1, 2, 3, 3});
+    auto x = random::multivariate_normal(mean, cov, {1000, 2}, float32);
+    CHECK_EQ(x.shape(), Shape{1000, 2, 3});
+  }
+  {
+    auto mean = zeros({3});
+    auto cov = eye(4);
+    CHECK_THROWS_AS(
+        random::multivariate_normal(mean, cov, {1000, 3}, float32),
+        std::invalid_argument);
+  }
+
+  // Check wrong type
+  {
+    auto mean = zeros({3});
+    auto cov = eye(3);
+    CHECK_THROWS_AS(
+        random::multivariate_normal(mean, cov, {1000, 3}, float16),
+        std::invalid_argument);
+  }
+}
+
+TEST_CASE("test random randint") {
+  CHECK_THROWS_AS(
+      random::randint(array(3), array(5), {1}, float32), std::invalid_argument);
+
+  auto x = random::randint(0, 10, {}, uint32);
+  CHECK_EQ(x.size(), 1);
+  CHECK_EQ(x.dtype(), uint32);
+
+  x = random::randint(0, 2, {}, bool_);
+  CHECK_EQ(x.size(), 1);
+  CHECK_EQ(x.dtype(), bool_);
+
+  x = random::randint(0, 2, {}, int32);
+  CHECK_EQ(x.size(), 1);
+  CHECK_EQ(x.dtype(), int32);
+
+  x = random::randint(0, 2, {}, int64);
+  CHECK_EQ(x.size(), 1);
+  CHECK_EQ(x.dtype(), int64);
+
+  // Check all in bounds
+  auto low = -10.0;
+  auto high = 20.0;
+  x = random::randint(low, high, {1000, 1000});
+  CHECK((all(low <= x).item<bool>() && all(x < high).item<bool>()));
+
+  // Check high < low => all equals to low
+  low = 20.0;
+  high = -10.0;
+  x = random::randint(low, high, {3, 3});
+  CHECK(all(equal(x, array(low))).item<bool>());
+
+  // Check wrong key type or shape
+  auto key = array({0, 0}, {1, 2});
+  CHECK_THROWS_AS(
+      random::randint(low, high, {}, float32, key), std::invalid_argument);
+}
+
+TEST_CASE("test random bernoulli") {
+  auto x = random::bernoulli();
+
+  CHECK_EQ(x.size(), 1);
+  CHECK_EQ(x.dtype(), bool_);
+
+  // Bernoulli parameter can have floating point type
+  x = random::bernoulli(array(0.5, float16));
+  CHECK_EQ(x.size(), 1);
+  CHECK_EQ(x.dtype(), bool_);
+
+  CHECK_THROWS(random::bernoulli(array(1, int32)));
+
+  // Negative numbers allowed in Jax
+  x = random::bernoulli(array(-1.0));
+  CHECK_FALSE(x.item<bool>());
+
+  x = random::bernoulli(array(5.0));
+  CHECK(x.item<bool>());
+
+  // Return array with correct shape
+  x = random::bernoulli(0.5, {3, 3});
+  CHECK_EQ(x.shape(), Shape{3, 3});
+
+  // Try with p = {}
+  x = random::bernoulli(array({}));
+  CHECK_EQ(x.size(), 0);
+
+  // Try broadcasting
+  auto p = array({0.1, 0.2, 0.3});
+  p = reshape(p, {1, 3});
+  x = random::bernoulli(p, {4, 3});
+  CHECK_EQ(x.shape(), Shape{4, 3});
+
+  CHECK_THROWS_AS(random::bernoulli(array({}), {3, 3}), std::invalid_argument);
+
+  p = array({0.1, 0.2, 0.3});
+  // Ask for the wrong shape => throws
+  CHECK_THROWS_AS(random::bernoulli(p, Shape{2}), std::invalid_argument);
+
+  // Check wrong key type or shape
+  auto key = array({0, 0}, {1, 2});
+  CHECK_THROWS_AS(random::bernoulli(array(0.5), key), std::invalid_argument);
+}
+
+TEST_CASE("Test truncated normal") {
+  auto x = random::truncated_normal(array(-2.0), array(2.0));
+
+  CHECK_EQ(x.size(), 1);
+  CHECK_EQ(x.dtype(), float32);
+
+  x = random::truncated_normal(array(-2.0), array(2.0), {}, float16);
+  CHECK_EQ(x.size(), 1);
+  CHECK_EQ(x.dtype(), float16);
+
+  // Requested shape
+  x = random::truncated_normal(array(-2.0), array(2.0), {3, 4});
+  CHECK_EQ(x.shape(), Shape{3, 4});
+
+  // Empty array
+  x = random::truncated_normal(array({}), array({}));
+  CHECK_EQ(x.size(), 0);
+
+  // Broadcast
+  auto lower = reshape(array({-2.0, -3.0}), {1, 2});
+  auto higher = reshape(array({0.0, 3.0, 1.5}), {3, 1});
+  x = random::truncated_normal(lower, higher);
+
+  // All in bounds
+  CHECK_EQ(x.shape(), Shape{3, 2});
+  CHECK((all(x <= higher).item<bool>() && all(lower <= x).item<bool>()));
+
+  // high < low => all equal to low
+  x = random::truncated_normal(array(2.0), array(-2.0));
+  CHECK(all(x == array(2.0)).item<bool>());
+
+  // Non broadcastable => throws
+  CHECK_THROWS_AS(
+      random::truncated_normal(lower, higher, {4, 2}), std::invalid_argument);
+
+  auto key = array({0, 0}, {1, 2});
+  CHECK_THROWS_AS(
+      random::truncated_normal(array(-2.0), array(2.0), {1, 1}, float32, key),
+      std::invalid_argument);
+}
+
+TEST_CASE("test categorical") {
+  auto logits = zeros({10, 20});
+
+  using random::categorical;
+
+  // Invalid axes
+  CHECK_THROWS(categorical(logits, 2));
+  CHECK_THROWS(categorical(logits, -3));
+
+  // Invalid requested shapes
+  CHECK_THROWS(categorical(logits, 1, Shape{1}));
+  CHECK_THROWS(categorical(logits, 1, Shape{11}));
+  CHECK_THROWS(categorical(logits, 1, {10, 1}));
+
+  CHECK_EQ(categorical(logits, -1).shape(), Shape{10});
+  CHECK_EQ(categorical(logits, 0).shape(), Shape{20});
+  CHECK_EQ(categorical(logits, 1).shape(), Shape{10});
+
+  auto out = categorical(logits);
+  CHECK_EQ(out.shape(), Shape{10});
+  CHECK_EQ(out.dtype(), uint32);
+  CHECK(max(out).item<uint32_t>() < 20);
+
+  out = categorical(logits, 0, {5, 20});
+  CHECK_EQ(out.shape(), Shape{5, 20});
+  CHECK(max(out).item<uint32_t>() < 10);
+
+  float inf = std::numeric_limits<float>::infinity();
+  logits = array({1.0f, -2.0f, inf, 4.0f, 3.0f});
+  CHECK_EQ(categorical(logits).item<uint32_t>(), 2);
+
+  logits = array({-inf, -2.0f, -inf, -inf});
+  CHECK_EQ(categorical(logits).item<uint32_t>(), 1);
+
+  logits = zeros({5, 4, 3});
+  CHECK_EQ(categorical(logits, -1, 7).shape(), Shape{5, 4, 7});
+  CHECK_EQ(categorical(logits, -2, 7).shape(), Shape{5, 3, 7});
+  CHECK_EQ(categorical(logits, -3, 7).shape(), Shape{4, 3, 7});
+}
+
+TEST_CASE("test laplace") {
+  // Test shapes, types, and sizes
+  {
+    auto x = random::laplace({});
+    CHECK_EQ(x.size(), 1);
+    CHECK_EQ(x.dtype(), float32);
+
+    // Non float type throws
+    CHECK_THROWS_AS(random::laplace({}, int32), std::invalid_argument);
+
+    // Check wrong key type or shape
+    auto key = array({0, 0});
+    CHECK_THROWS_AS(random::laplace({}, key), std::invalid_argument);
+    key = array({0, 0}, {1, 2});
+    CHECK_THROWS_AS(random::laplace({}, key), std::invalid_argument);
+    key = array({0u, 0u, 0u}, {3, 1});
+    CHECK_THROWS_AS(random::laplace({}, key), std::invalid_argument);
+    key = array({0u, 0u}, {2, 1});
+    CHECK_THROWS_AS(random::laplace({}, key), std::invalid_argument);
+  }
+
+  {
+    constexpr float inf = std::numeric_limits<float>::infinity();
+    auto key = random::key(128291);
+    auto out = random::laplace({1000000}, key);
+    float sample_mean = mean(out).item<float>();
+    float sample_variance = var(out).item<float>();
+
+    CHECK(all(less(abs(out), array(inf))).item<bool>());
+    CHECK(abs(sample_mean) < 0.1);
+
+    // Chebyshev's inequality.
+    for (int k = 1; k <= 5; ++k) {
+      float prob_above =
+          mean(greater_equal(out, array(k * std::sqrt(sample_variance))))
+              .item<float>();
+      float bound = 1 / std::pow(k, 2);
+      CHECK(prob_above < bound);
+    }
+
+    // Expected variance for Laplace distribution is 2*scale^2.
+    float expected_variance = 2.0;
+    CHECK(std::abs(sample_variance - expected_variance) < 0.01);
+
+    // Expected kurtosis of Laplace distribution is 3.
+    array fourth_pows = power(out - sample_mean, array(4));
+    float sample_kurtosis =
+        mean(fourth_pows).item<float>() / std::pow(sample_variance, 2) - 3;
+    float expected_kurtosis = 3.0;
+    CHECK(std::abs(sample_kurtosis - expected_kurtosis) < 0.1);
+  }
+
+  {
+    constexpr float inf = std::numeric_limits<float>::infinity();
+    auto key = random::key(128291);
+    auto out = random::laplace({10000}, float16, key);
+    CHECK_EQ(out.dtype(), float16);
+    CHECK(all(less(abs(out), array(inf))).item<bool>());
+    CHECK(abs(float(mean(out).item<float16_t>())) < 0.1);
+  }
+
+  {
+    constexpr float inf = std::numeric_limits<float>::infinity();
+    auto key = random::key(128291);
+    auto out = random::laplace({10000}, bfloat16, key);
+    CHECK_EQ(out.dtype(), bfloat16);
+    CHECK(all(less(abs(out), array(inf))).item<bool>());
+    CHECK(abs(float(mean(out).item<bfloat16_t>())) < 0.1);
+  }
+}
diff --git a/ml-stable-diffusion/mlx/tests/scheduler_tests.cpp b/ml-stable-diffusion/mlx/tests/scheduler_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bbf97d05c4e01750698e778873906e99f6b427a9
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/scheduler_tests.cpp
@@ -0,0 +1,121 @@
+// Copyright © 2023 Apple Inc.
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+#include "mlx/scheduler.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test stream management") {
+  auto s1 = default_stream(default_device());
+  CHECK_EQ(s1.device, default_device());
+
+  auto s2 = new_stream(default_device());
+  CHECK_EQ(s2.device, default_device());
+  CHECK_NE(s1, s2);
+
+  // Check that default streams have the correct devices
+  if (gpu::is_available()) {
+    auto s_gpu = default_stream(Device::gpu);
+    CHECK_EQ(s_gpu.device, Device::gpu);
+  } else {
+    CHECK_THROWS_AS(default_stream(Device::gpu), std::invalid_argument);
+  }
+  auto s_cpu = default_stream(Device::cpu);
+  CHECK_EQ(s_cpu.device, Device::cpu);
+
+  s_cpu = new_stream(Device::cpu);
+  CHECK_EQ(s_cpu.device, Device::cpu);
+
+  if (gpu::is_available()) {
+    auto s_gpu = new_stream(Device::gpu);
+    CHECK_EQ(s_gpu.device, Device::gpu);
+  } else {
+    CHECK_THROWS_AS(new_stream(Device::gpu), std::invalid_argument);
+  }
+}
+
+TEST_CASE("test asynchronous launch") {
+  auto s1 = default_stream(Device::cpu);
+  auto s2 = new_stream(Device::cpu);
+
+  // Make sure streams execute asynchronously
+  int x = 1;
+  auto p1 = std::make_shared<std::promise<void>>();
+  auto p2 = std::make_shared<std::promise<void>>();
+  auto f1 = p1->get_future().share();
+  auto f2 = p2->get_future().share();
+  auto fn1 = [&x, p = std::move(p1)]() {
+    x++;
+    p->set_value();
+  };
+  auto fn2 = [&x, p = std::move(p2), f = std::move(f1)]() {
+    f.wait();
+    x *= 5;
+    p->set_value();
+  };
+
+  // fn2 is launched first and is waiting on fn1 but since
+  // they are on different streams there is no deadlock.
+  scheduler::enqueue(s2, std::move(fn2));
+  scheduler::enqueue(s1, std::move(fn1));
+
+  f2.wait();
+
+  CHECK_EQ(x, 10);
+}
+
+TEST_CASE("test stream placement") {
+  auto s1 = default_stream(Device::cpu);
+  auto s2 = new_stream(Device::cpu);
+
+  {
+    // Wait on stream 1
+    auto p = std::make_shared<std::promise<void>>();
+    auto f = p->get_future().share();
+    scheduler::enqueue(s1, [f = std::move(f)]() { f.wait(); });
+
+    // Do some work on stream 2
+    auto x = zeros({100}, float32, s2);
+    auto y = ones({100}, float32, s2);
+    auto z = add(x, y, s2);
+    eval(z);
+    p->set_value();
+  }
+
+  {
+    // Wait on stream 1
+    auto p = std::make_shared<std::promise<void>>();
+    auto f = p->get_future().share();
+    scheduler::enqueue(s1, [f = std::move(f)]() { f.wait(); });
+
+    // Do some work on stream 2
+    auto fn = [&s2](array a) { return add(a, add(a, a, s2), s2); };
+    auto x = zeros({100}, s2);
+
+    // The whole vjp computation should happen
+    // on the second stream otherwise this will hang.
+    auto [out, dout] = vjp(fn, x, ones({100}, s2));
+
+    // The whole jvp computation should happen on the
+    // second stream.
+    std::tie(out, dout) = jvp(fn, x, ones({100}, s2));
+    eval(out, dout);
+
+    p->set_value();
+  }
+}
+
+TEST_CASE("test scheduler races") {
+  auto x = zeros({1});
+  auto y = zeros({100});
+  eval(x, y);
+  auto a = exp(x);
+  eval(a);
+  a = exp(x);
+  for (int i = 0; i < 10000; ++i) {
+    y = exp(y);
+  }
+  eval(a, y);
+}
diff --git a/ml-stable-diffusion/mlx/tests/tests.cpp b/ml-stable-diffusion/mlx/tests/tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..edaf49c271e31fec29044eda43762003858ee54d
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/tests.cpp
@@ -0,0 +1,24 @@
+// Copyright © 2023 Apple Inc.
+
+#define DOCTEST_CONFIG_IMPLEMENT
+#include "doctest/doctest.h"
+
+#include <cstdlib>
+
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+int main(int argc, char** argv) {
+  doctest::Context context;
+
+  const char* device = std::getenv("DEVICE");
+  if (device != nullptr && std::string(device) == "cpu") {
+    set_default_device(Device::cpu);
+  } else if (metal::is_available()) {
+    set_default_device(Device::gpu);
+  }
+
+  context.applyCommandLine(argc, argv);
+  return context.run();
+}
diff --git a/ml-stable-diffusion/mlx/tests/utils_tests.cpp b/ml-stable-diffusion/mlx/tests/utils_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..88c3e7b37880137af3e0b0a1c7c5b995233f1b43
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/utils_tests.cpp
@@ -0,0 +1,67 @@
+// Copyright © 2023 Apple Inc.
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test type promotion") {
+  for (auto t : {bool_, uint32, int32, int64, float32}) {
+    auto a = array(0, t);
+    CHECK_EQ(result_type({a}), t);
+
+    std::vector<array> arrs = {array(0, t), array(0, t)};
+    CHECK_EQ(result_type(arrs), t);
+  }
+
+  {
+    std::vector<array> arrs = {array(false), array(0, int32)};
+    CHECK_EQ(result_type(arrs), int32);
+  }
+
+  {
+    std::vector<array> arrs = {array(0, int32), array(false), array(0.0f)};
+    CHECK_EQ(result_type(arrs), float32);
+  }
+}
+
+TEST_CASE("test normalize axis") {
+  struct TestCase {
+    int axis;
+    int ndim;
+    int expected;
+  };
+
+  std::vector<TestCase> testCases = {
+      {0, 3, 0}, {1, 3, 1}, {2, 3, 2}, {-1, 3, 2}, {-2, 3, 1}, {-3, 3, 0}};
+
+  for (const auto& tc : testCases) {
+    CHECK_EQ(normalize_axis_index(tc.axis, tc.ndim), tc.expected);
+  }
+
+  CHECK_THROWS(normalize_axis_index(3, 3));
+  CHECK_THROWS(normalize_axis_index(-4, 3));
+}
+
+TEST_CASE("test finfo") {
+  CHECK_EQ(finfo(float32).dtype, float32);
+  CHECK_EQ(finfo(complex64).dtype, float32);
+  CHECK_EQ(finfo(float16).dtype, float16);
+  CHECK_EQ(finfo(float32).min, std::numeric_limits<float>::lowest());
+  CHECK_EQ(finfo(float32).max, std::numeric_limits<float>::max());
+  CHECK_EQ(finfo(complex64).min, std::numeric_limits<float>::lowest());
+  CHECK_EQ(finfo(complex64).max, std::numeric_limits<float>::max());
+  CHECK_EQ(finfo(float16).min, -65504);
+  CHECK_EQ(finfo(float16).max, 65504);
+}
+
+TEST_CASE("test iinfo") {
+  CHECK_EQ(iinfo(int8).dtype, int8);
+  CHECK_EQ(iinfo(int64).dtype, int64);
+  CHECK_EQ(iinfo(int64).max, std::numeric_limits<int64_t>::max());
+  CHECK_EQ(iinfo(uint64).max, std::numeric_limits<uint64_t>::max());
+  CHECK_EQ(iinfo(uint64).max, std::numeric_limits<uint64_t>::max());
+  CHECK_EQ(iinfo(uint64).min, 0);
+  CHECK_EQ(iinfo(int64).min, std::numeric_limits<int64_t>::min());
+}
diff --git a/ml-stable-diffusion/mlx/tests/vmap_tests.cpp b/ml-stable-diffusion/mlx/tests/vmap_tests.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2a2a2857133fb79dc0ee57ca56986909f4d143b0
--- /dev/null
+++ b/ml-stable-diffusion/mlx/tests/vmap_tests.cpp
@@ -0,0 +1,547 @@
+// Copyright © 2023 Apple Inc.
+
+#include "doctest/doctest.h"
+
+#include "mlx/mlx.h"
+
+using namespace mlx::core;
+
+TEST_CASE("test simple vmap") {
+  // vmap reshape
+  {
+    auto vfun = vmap([](array input) { return reshape(input, {2, 2}); });
+    auto x = zeros({3, 4});
+    CHECK(array_equal(vfun(x), zeros({3, 2, 2})).item<bool>());
+
+    x = array({0, 1, 2, 3, 4, 5, 6, 7}, {2, 2, 2});
+    vfun = vmap([](array input) { return reshape(input, {4}); });
+    auto expected = array({0, 1, 2, 3, 4, 5, 6, 7}, {2, 4});
+    CHECK(array_equal(vfun(x), expected).item<bool>());
+
+    vfun = vmap([](array input) { return reshape(input, {4}); }, 1);
+    expected = array({0, 1, 4, 5, 2, 3, 6, 7}, {2, 4});
+    CHECK(array_equal(vfun(x), expected).item<bool>());
+
+    vfun = vmap([](array input) { return reshape(input, {4}); }, 1, 1);
+    expected = array({0, 2, 1, 3, 4, 6, 5, 7}, {4, 2});
+    CHECK(array_equal(vfun(x), expected).item<bool>());
+  }
+
+  // vmap broadcast
+  {
+    auto fun = [](array input) { return broadcast_to(input, {4, 2}); };
+
+    CHECK_THROWS_AS(vmap(fun, 0, -1), std::invalid_argument);
+    CHECK_THROWS_AS(vmap(fun, -1, 0), std::invalid_argument);
+
+    auto vfun = vmap(fun);
+    auto x = zeros({3, 2});
+    CHECK(array_equal(vfun(x), zeros({3, 4, 2})).item<bool>());
+
+    vfun = vmap(fun, 0, 1);
+    CHECK(array_equal(vfun(x), zeros({4, 3, 2})).item<bool>());
+
+    vfun = vmap(fun, 0, 2);
+    CHECK(array_equal(vfun(x), zeros({4, 2, 3})).item<bool>());
+
+    vfun = vmap(fun, 0, 2);
+    x = zeros({2, 3});
+    CHECK_THROWS_AS(vfun(x), std::invalid_argument);
+
+    x = zeros({2, 3});
+    vfun = vmap(fun, 1);
+    CHECK(array_equal(vfun(x), zeros({3, 4, 2})).item<bool>());
+
+    vfun = vmap(fun, 1, 1);
+    CHECK(array_equal(vfun(x), zeros({4, 3, 2})).item<bool>());
+
+    vfun = vmap(fun, 1, 2);
+    CHECK(array_equal(vfun(x), zeros({4, 2, 3})).item<bool>());
+  }
+
+  // vmap transpose
+  {
+    auto fun = [](array input) { return transpose(input); };
+    auto vfun = vmap(fun);
+    auto x = array({0, 1, 2, 3, 4, 5}, {3, 2});
+    CHECK(array_equal(vfun(x), x).item<bool>());
+
+    vfun = vmap(fun, 0, 1);
+    CHECK(array_equal(vfun(x), transpose(x)).item<bool>());
+
+    x = array({0, 1, 2, 3, 4, 5, 6, 7}, {2, 2, 2});
+    vfun = vmap(fun);
+    CHECK(array_equal(vfun(x), transpose(x, {0, 2, 1})).item<bool>());
+
+    vfun = vmap(fun, 1, 1);
+    CHECK(array_equal(vfun(x), transpose(x, {2, 1, 0})).item<bool>());
+
+    vfun = vmap(fun, 2, 2);
+    CHECK(array_equal(vfun(x), transpose(x, {1, 0, 2})).item<bool>());
+
+    // vmap twice
+    x = array(
+        {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, {2, 2, 2, 2});
+    vfun = vmap(vmap(fun));
+    CHECK(array_equal(vfun(x), transpose(x, {0, 1, 3, 2})).item<bool>());
+  }
+
+  // vmap add
+  {
+    auto fun = [](std::vector<array> inputs) {
+      auto out = add(inputs[0], inputs[1]);
+      return std::vector<array>{out};
+    };
+
+    auto vfun = vmap(fun);
+    array x({1.0, 2.0}, {2, 1});
+    array y({2.0, 3.0}, {2, 1});
+    auto out = vfun({x, y})[0];
+    CHECK(array_equal(out, array({3.0, 5.0}, {2, 1})).item<bool>());
+
+    x = ones({2, 1, 3});
+    y = ones({3, 2});
+    vfun = vmap(fun, {2, 0});
+    out = vfun({x, y})[0];
+    CHECK(array_equal(out, full({3, 2, 2}, 2.0)).item<bool>());
+
+    x = array(1.);
+    y = ones({3, 2});
+    vfun = vmap(fun, {-1, 0});
+    out = vfun({x, y})[0];
+    CHECK(array_equal(out, full({3, 2}, 2.0)).item<bool>());
+
+    x = ones({3, 2});
+    y = array(1.);
+    vfun = vmap(fun, {0, -1});
+    out = vfun({x, y})[0];
+    CHECK(array_equal(out, full({3, 2}, 2.0)).item<bool>());
+
+    CHECK_THROWS_AS(vmap(fun, {-1, 0}, {-1}), std::invalid_argument);
+    CHECK_THROWS_AS(vmap(fun, {0, -1}, {-1}), std::invalid_argument);
+
+    x = ones({3, 2, 1});
+    y = ones({3, 2, 1});
+    vfun = vmap(vmap(fun));
+    out = vfun({x, y})[0];
+    CHECK(array_equal(out, x + y).item<bool>());
+  }
+
+  // vmap where (ternary op)
+  {
+    auto fun = [](std::vector<array> inputs) {
+      auto out = where(inputs[0], inputs[1], inputs[2]);
+      return std::vector<array>{out};
+    };
+
+    auto vfun = vmap(fun);
+    array cond({true, false}, {2, 1});
+    array x({1.0, 2.0}, {2, 1});
+    array y({2.0, 4.0}, {2, 1});
+    auto out = vfun({cond, x, y})[0];
+    CHECK(array_equal(out, array({1.0, 4.0}, {2, 1})).item<bool>());
+
+    cond = array({true, true, false}, {1, 3});
+    x = ones({2, 1, 3});
+    y = zeros({3, 2});
+    vfun = vmap(fun, {1, 2, 0});
+    out = vfun({cond, x, y})[0];
+
+    CHECK(
+        array_equal(out, array({1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0}, {3, 2, 2}))
+            .item<bool>());
+
+    vfun = vmap(fun, {1, 2, 0}, {1});
+    out = vfun({cond, x, y})[0];
+    CHECK(
+        array_equal(out, array({1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0}, {2, 3, 2}))
+            .item<bool>());
+
+    cond = array({true, false});
+    x = array(2.);
+    y = ones({3, 2});
+    vfun = vmap(fun, {-1, -1, 0});
+    out = vfun({cond, x, y})[0];
+    CHECK(array_equal(out, array({2, 1, 2, 1, 2, 1}, {3, 2})).item<bool>());
+
+    cond = array({true, false});
+    x = ones({3, 2});
+    y = array(2.);
+    vfun = vmap(fun, {-1, 0, -1});
+    out = vfun({cond, x, y})[0];
+    CHECK(array_equal(out, array({1, 2, 1, 2, 1, 2}, {3, 2})).item<bool>());
+
+    CHECK_THROWS_AS(vmap(fun, {-1, -1, -1}, {0}), std::invalid_argument);
+    CHECK_THROWS_AS(vmap(fun, {-1, 0, -1}, {-1}), std::invalid_argument);
+    CHECK_THROWS_AS(vmap(fun, {-1, -1, 0}, {-1}), std::invalid_argument);
+    CHECK_THROWS_AS(vmap(fun, {0, -1, -1}, {-1}), std::invalid_argument);
+
+    cond = array({1, 1, 1, 0, 0, 0}, {3, 2, 1});
+    x = ones({3, 2, 1});
+    y = full({3, 2, 1}, 2);
+    vfun = vmap(vmap(fun));
+    out = vfun({cond, x, y})[0];
+    CHECK(array_equal(out, array({1, 1, 1, 2, 2, 2}, {3, 2, 1})).item<bool>());
+  }
+
+  // vmap with capturing closure
+  {
+    auto x = add(add(ones({2}), zeros({2})), zeros({2}));
+    auto fun = [x](const array& input) { return add(input, x); };
+
+    auto vfun = vmap(fun);
+    auto y = ones({3, 2});
+    CHECK(array_equal(vfun(y), full({3, 2}, 2.0f)).item<bool>());
+  }
+  {
+    auto x = ones({4});
+    auto z = x + x;
+    auto vfun = vmap(
+        [z](std::vector<array> inputs) {
+          return std::vector<array>{add(z, inputs[1])};
+        },
+        {-1, 0});
+    auto y = ones({3, 4});
+    CHECK(array_equal(vfun({x, y})[0], full({3, 4}, 3.0)).item<bool>());
+  }
+}
+
+TEST_CASE("test vmap with eval") {
+  auto fun = [](std::vector<array> inputs) {
+    auto x = inputs[0] + 1;
+    auto y = inputs[1] + 2;
+    eval(x);
+    auto out = add(x, y);
+    return std::vector<array>{out};
+  };
+
+  auto vfun = vmap(fun);
+  array x({1.0, 2.0}, {2, 1});
+  array y({2.0, 3.0}, {2, 1});
+  CHECK_THROWS(vfun({x, y}));
+
+  // Ok to eval functions of non-vmapped input
+  x = array(1.0);
+  vfun = vmap(fun, {-1, 0});
+  CHECK(array_equal(vfun({x, y})[0], array({6.0f, 7.0f}, {2, 1})).item<bool>());
+
+  // Not ok to eval function of vmapped input even with retain graph
+  auto fun2 = [](std::vector<array> inputs) {
+    auto x = inputs[0] + 1;
+    auto y = inputs[1] + 2;
+    eval(x);
+    auto out = add(x, y);
+    return std::vector<array>{out};
+  };
+  x = array({1.0, 2.0}, {2, 1});
+  CHECK_THROWS(vmap(fun2)({x, y}));
+}
+
+TEST_CASE("test vmap comparison ops") {
+  // vmap equal
+  {
+    auto fun = [](std::vector<array> inputs) {
+      return std::vector<array>{equal(inputs[0], inputs[1])};
+    };
+    auto vfun = vmap(fun);
+    auto x = zeros({2, 3}, float32);
+    auto y = zeros({2, 3}, float32);
+    auto out = vfun({x, y})[0];
+    CHECK(all(out).item<bool>());
+
+    vfun = vmap(fun, {0, -1});
+    x = zeros({2, 3}, float32);
+    y = zeros({3}, float32);
+    out = vfun({x, y})[0];
+    CHECK(all(out).item<bool>());
+
+    vfun = vmap(fun, {0, -1});
+    x = array({0, 0, 0, 1, 1, 1}, {2, 3});
+    y = zeros({3}, float32);
+    out = vfun({x, y})[0];
+    auto expected = array({true, true, true, false, false, false}, {2, 3});
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+}
+
+TEST_CASE("test vmap creation ops") {
+  // vmap astype
+  {
+    auto fun = [](array in) { return astype(in, int32); };
+    auto x = zeros({2, 3}, float32);
+    auto out = vmap(fun)(x);
+    CHECK_EQ(out.dtype(), int32);
+    CHECK(array_equal(out, zeros({2, 3}, int32)).item<bool>());
+  }
+
+  // vmap full
+  {
+    auto fun = [](array in) { return full({2}, in); };
+    auto x = array({1, 2, 3});
+    auto out = vmap(fun)(x);
+    auto expected = array({1, 1, 2, 2, 3, 3}, {3, 2});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    x = array({1, 2, 3}, {3, 1});
+    out = vmap(fun)(x);
+    expected = array({1, 1, 2, 2, 3, 3}, {3, 2});
+    CHECK(array_equal(out, expected).item<bool>());
+
+    x = array({1, 2, 3}, {1, 3});
+    CHECK_THROWS_AS(vmap(fun)(x), std::invalid_argument);
+    out = vmap(fun, 1, 1)(x);
+    expected = array({1, 2, 3, 1, 2, 3}, {2, 3});
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+}
+
+TEST_CASE("test vmap slice") {
+  {
+    auto fun = [](array in) { return slice(in, {4}, {8}, {2}); };
+    auto x = reshape(arange(16), {2, 8});
+    auto out = vmap(fun)(x);
+    auto expected = reshape(array({4, 6, 12, 14}), {2, 2});
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+
+  {
+    auto fun = [](array in) { return slice(in, {0, 1}, {2, 3}); };
+    auto x = reshape(arange(12), {2, 2, 3});
+    auto out = vmap(fun, 1, 0)(x);
+    auto expected = reshape(array({1, 2, 7, 8, 4, 5, 10, 11}), {2, 2, 2});
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+}
+
+TEST_CASE("test vmap concatenate") {
+  auto fun = [](std::vector<array> inputs) {
+    return std::vector<array>{concatenate(inputs, 0)};
+  };
+  auto x = reshape(arange(4), {2, 2});
+  auto y = reshape(arange(4), {2, 2});
+  auto out = vmap(fun)({x, y})[0];
+  auto expected = reshape(array({0, 1, 0, 1, 2, 3, 2, 3}), {2, 4});
+  CHECK(array_equal(out, expected).item<bool>());
+  out = vmap(fun, {1, 1})({x, y})[0];
+  expected = reshape(array({0, 2, 0, 2, 1, 3, 1, 3}), {2, 4});
+  CHECK(array_equal(out, expected).item<bool>());
+  out = vmap(fun, {0, 1})({x, y})[0];
+  expected = reshape(array({0, 1, 0, 2, 2, 3, 1, 3}), {2, 4});
+  CHECK(array_equal(out, expected).item<bool>());
+}
+
+TEST_CASE("test vmap gather") {
+  {
+    auto fun = [](std::vector<array> inputs) {
+      auto src = inputs[0];
+      auto indices = inputs[1];
+      auto out = squeeze(gather(src, indices, 0, {1, 2, 2}), 2);
+      return std::vector<array>{out};
+    };
+    auto x = zeros({2, 2, 2, 2});
+    auto y = array({0, 1, 0, 0, 1, 0}, {2, 3});
+    auto out = vmap(fun, {0, -1})({x, y})[0];
+    CHECK_EQ(out.shape(), Shape{2, 2, 3, 2, 2});
+    out = vmap(fun, {0, -1}, {3})({x, y})[0];
+    CHECK_EQ(out.shape(), Shape{2, 3, 2, 2, 2});
+  }
+
+  {
+    auto fun = [](std::vector<array> inputs) {
+      auto src = inputs[0];
+      auto indices = inputs[1];
+      auto out = squeeze(gather(src, indices, 0, {1, 2, 2}), 1);
+      return std::vector<array>{out};
+    };
+    auto x = zeros({2, 2, 2, 2});
+    auto y = array({0, 1, 0, 0, 1, 0}, {2, 3});
+    auto out = vmap(fun, {0, 0})({x, y})[0];
+    CHECK_EQ(out.shape(), Shape{2, 3, 2, 2});
+  }
+
+  {
+    auto fun = [](std::vector<array> inputs) {
+      auto src = inputs[0];
+      auto indices = inputs[1];
+      auto out = squeeze(gather(src, indices, 0, {1, 2, 2, 2}), 1);
+      return std::vector<array>{out};
+    };
+    auto x = zeros({2, 2, 2, 2});
+    auto y = array({0, 1, 0, 0, 1, 0}, {2, 3});
+
+    auto out = vmap(fun, {-1, 0})({x, y})[0];
+    CHECK_EQ(out.shape(), Shape{2, 3, 2, 2, 2});
+  }
+
+  {
+    auto fun = [](std::vector<array> inputs) {
+      auto src = inputs[0];
+      auto indices = std::vector<array>(inputs.begin() + 1, inputs.end());
+      auto out = squeeze(gather(src, indices, {0, 1}, {1, 1, 2, 2}), {1, 2});
+      return std::vector<array>{out};
+    };
+    auto x = zeros({2, 2, 2, 2});
+    auto y = array({0, 1, 0, 0, 1, 0}, {2, 3});
+    auto z = array({0, 1, 0, 0, 1, 0}, {2, 3});
+    auto out = vmap(fun, {-1, 0, 0})({x, y, z})[0];
+    CHECK_EQ(out.shape(), Shape{2, 3, 2, 2});
+
+    z = array({0, 1, 0, 0, 1, 0}, {3, 2});
+    out = vmap(fun, {-1, 0, 1})({x, y, z})[0];
+    CHECK_EQ(out.shape(), Shape{2, 3, 2, 2});
+  }
+}
+
+TEST_CASE("test vmap scatter") {
+  auto make_scatter_fn = [](const std::vector<array>& indices,
+                            const array& updates,
+                            const std::vector<int>& axes) {
+    return [=](const std::vector<array>& inputs) {
+      auto a = inputs.at(0);
+      return std::vector<array>{scatter(a, indices, updates, axes)};
+    };
+  };
+
+  {
+    // vmap src on axis 0, scatter on axis 0.
+    auto a = zeros({2, 3, 4});
+    auto indices = array({1});
+    auto updates = reshape(array({1, 2}, float32), {1, 1, 2});
+
+    auto func = make_scatter_fn({indices}, updates, std::vector<int>{0});
+    auto out = vmap(func, /* in_axes = */ {0})({a})[0];
+    auto expected = array(
+        {0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0,
+         0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0},
+        {2, 3, 4},
+        float32);
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+
+  {
+    // vmap src on axis 1, scatter on axis 0.
+    auto a = zeros({3, 2, 4});
+    auto indices = array({1});
+    auto updates = reshape(array({1, 2}, float32), {1, 1, 2});
+
+    auto func = make_scatter_fn({indices}, updates, std::vector<int>{0});
+    auto out = vmap(func, /* in_axes = */ {1}, /* out_axes = */ {1})({a})[0];
+    auto expected = array(
+        {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0,
+         1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+        {3, 2, 4},
+        float32);
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+
+  {
+    // vmap src on axis 0, scatter on axis 1.
+    auto a = zeros({2, 3, 4});
+    auto indices = array({1});
+    auto updates = reshape(array({1, 2}, float32), {1, 2, 1});
+
+    auto func = make_scatter_fn({indices}, updates, std::vector<int>{1});
+    auto out = vmap(func, /* in_axes = */ {0})({a})[0];
+    auto expected = array(
+        {0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
+         0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0},
+        {2, 3, 4},
+        float32);
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+
+  {
+    // vmap src on axis 2, scatter on axes (0, 1).
+    auto a = zeros({2, 3, 2});
+    auto indices = {array({1}), array({2})};
+    auto axes = {0, 1};
+    auto updates = reshape(array({1}, float32), {1, 1, 1});
+
+    auto func = make_scatter_fn(indices, updates, axes);
+    auto out = vmap(func, /* in_axes = */ {2}, /* out_axes = */ {2})({a})[0];
+    auto expected =
+        array({0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1}, {2, 3, 2}, float32);
+    CHECK(array_equal(out, expected).item<bool>());
+  }
+}
+
+TEST_CASE("test vmap SVD") {
+  auto svd_full = [](std::vector<array> inputs) {
+    return linalg::svd(inputs.at(0), true, Device::cpu);
+  };
+
+  auto svd_singular = [](std::vector<array> inputs) {
+    return linalg::svd(inputs.at(0), false, Device::cpu);
+  };
+
+  auto a = astype(reshape(arange(24), {3, 4, 2}), float32);
+
+  // vmap over the second axis.
+  {
+    auto out = vmap(svd_full, /* in_axes = */ {1})({a});
+    const auto& U = out.at(0);
+    const auto& S = out.at(1);
+    const auto& Vt = out.at(2);
+
+    CHECK_EQ(U.shape(), Shape{a.shape(1), a.shape(0), a.shape(0)});
+    CHECK_EQ(S.shape(), Shape{a.shape(1), a.shape(2)});
+    CHECK_EQ(Vt.shape(), Shape{a.shape(1), a.shape(2), a.shape(2)});
+  }
+
+  // vmap over the third axis.
+  {
+    auto out = vmap(svd_full, /* in_axes = */ {2})({a});
+    const auto& U = out.at(0);
+    const auto& S = out.at(1);
+    const auto& Vt = out.at(2);
+
+    CHECK_EQ(U.shape(), Shape{a.shape(2), a.shape(0), a.shape(0)});
+    CHECK_EQ(S.shape(), Shape{a.shape(2), a.shape(0)});
+    CHECK_EQ(Vt.shape(), Shape{a.shape(2), a.shape(1), a.shape(1)});
+  }
+
+  // test singular values
+  {
+    auto out = vmap(svd_singular, /* in_axes = */ {1})({a});
+    const auto& S = out.at(0);
+
+    CHECK_EQ(S.shape(), Shape{a.shape(1), a.shape(2)});
+  }
+
+  {
+    auto out = vmap(svd_singular, /* in_axes = */ {2})({a});
+    const auto& S = out.at(0);
+
+    CHECK_EQ(S.shape(), Shape{a.shape(2), a.shape(0)});
+  }
+}
+
+TEST_CASE("test vmap dynamic slices") {
+  {
+    auto fun = [](std::vector<array> inputs) {
+      return std::vector<array>{slice(inputs[0], array({1}), {0}, {2})};
+    };
+    auto x = reshape(arange(12), {3, 4});
+    auto out = vmap(fun)({x})[0];
+    CHECK(array_equal(out, array({1, 2, 5, 6, 9, 10}, {3, 2})).item<bool>());
+
+    out = vmap(fun, /* in_axes */ {1}, /* out_axes */ {1})({x})[0];
+    CHECK(array_equal(out, array({4, 5, 6, 7, 8, 9, 10, 11}, {2, 4}))
+              .item<bool>());
+  }
+
+  {
+    auto fun = [](std::vector<array> inputs) {
+      return std::vector<array>{
+          slice_update(inputs[0], inputs[1], array({1}), {0})};
+    };
+    auto x = zeros({2, 2});
+    auto upd = ones({2, 1});
+
+    auto out = vmap(fun)({x, upd})[0];
+    CHECK(array_equal(out, array({0, 1, 0, 1}, {2, 2})).item<bool>());
+
+    out = vmap(fun, /* in_axes */ {1, 0}, /* out_axes */ {1})({x, upd})[0];
+    CHECK(array_equal(out, array({0, 0, 1, 1}, {2, 2})).item<bool>());
+  }
+}